diff --git a/.github/workflows/documentation.yml b/.github/workflows/documentation.yml index ce6b5871..469bb518 100644 --- a/.github/workflows/documentation.yml +++ b/.github/workflows/documentation.yml @@ -4,10 +4,10 @@ jobs: docs: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 - - uses: actions/setup-python@v2 + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 with: - python-version: '3.9' + python-version: '3.11' - name: Install dependencies run: | pip install -r requirements.txt @@ -21,7 +21,7 @@ jobs: id: extract_branch - name: Deploy uses: peaceiris/actions-gh-pages@v3 - if: ${{ github.event_name == 'push' && (github.ref == 'refs/heads/dev' || github.ref == 'refs/heads/main') }} + if: ${{ github.event_name == 'push' && (github.ref == 'refs/heads/v3' || github.ref == 'refs/heads/main') }} with: publish_branch: gh-pages github_token: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 23185066..6ba28fb0 100644 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -6,13 +6,17 @@ jobs: build: runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + python-version: ["3.10", "3.11", "3.12"] steps: - - uses: actions/checkout@v2 - - name: Set up Python 3.9 - uses: actions/setup-python@v2 + - uses: actions/checkout@v4 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v5 with: - python-version: "3.9" + python-version: ${{ matrix.python-version }} - name: Install dependencies run: | python -m pip install --upgrade pip diff --git a/.gitignore b/.gitignore index a9dc132c..073f30db 100644 --- a/.gitignore +++ b/.gitignore @@ -1,24 +1,35 @@ .DS_Store .idea +.vscode +.pylintrc .ipynb_checkpoints/ *.pyc __pycache__ .pytest_cache demo/ +demo_old/ catboost_info/ +./tests/* +testlogs/ dask_logs/ OUTPUT/ +OSA_OUTPUT/ +OSA/ docs/build/ +job_old.e job.o job.e logs.log +Scratchpad.ipynb UserData/ UserRepData/ UserOutput/ DemoOutput/ DemoOutputLocal/ OSAData/ -tests/ +/test/ +/tests/ +/out/ OSAData.zip multiplexer_dataset/ gametes_dataset/ @@ -26,6 +37,3 @@ run_configs/cedars_amd.cfg data/AMD_Final/* data/PLCO/* run_configs/cedars_plco.cfg -run_configs/cedars_gametes.cfg -exp_configs/ -exp_data/ \ No newline at end of file diff --git a/README.md b/README.md index 7d619b9c..8049833c 100644 --- a/README.md +++ b/README.md @@ -1,89 +1,230 @@ -![alttext](https://github.com/UrbsLab/STREAMLINE/blob/main/docs/source/pictures/STREAMLINE_Logo_Full.png?raw=true) -# Overview +![STREAMLINE Logo](https://github.com/UrbsLab/STREAMLINE/blob/main/docs/source/pictures/STREAMLINE_Logo_Full.png?raw=true) + +# STREAMLINE + +STREAMLINE is an end-to-end automated machine learning pipeline for tabular biomedical and general supervised learning workflows. The current codebase supports binary classification, multiclass classification, and regression, with integrated feature learning, feature importance, feature selection, base-model training, classification ensembles, summary statistics, dataset comparison, replication, and PDF reporting. -STREAMLINE is an end-to-end automated machine learning (AutoML) pipeline -that empowers anyone to easily train, interpret, and apply a variety of predictive models as -part of a rigorous and optionally customizable data mining analysis. It is programmed in -Python 3 using many common libraries including [Pandas](https://pandas.pydata.org/) -and [scikit-learn](https://scikit-learn.org/stable/). +This repository is the main starting point for the STREAMLINE v1.0.0 release and its current 11-phase implementation. -The schematic below summarizes the automated STREAMLINE analysis pipeline with individual elements organized into 9 phases. +## What Is Included In This Version -![alttext](https://github.com/UrbsLab/STREAMLINE/blob/main/docs/source/pictures/STREAMLINE_paper_new_lightcolor.png?raw=true) +- Unified support for binary classification, multiclass classification, and regression +- Phase-first architecture spanning P1 through P11 +- Registry-backed extension points for multiple phases +- Feature learning with PCA and related outputs +- Feature importance methods including mutual information, MultiSURF, MultiSURF*, MultiSWRFDB, and MultiSWRFDB* +- Modeling with base learners, calibration support for classification, and composite feature importance from modeling +- Classification ensemble evaluation +- Summary statistics and cross-dataset comparison +- Replication / external validation as a dedicated phase +- Automated reporting for both standard experiment outputs and replication outputs +- Updated Google Colab and Jupyter notebook workflows -* Detailed documentation of STREAMLINE is available [here](https://urbslab.github.io/STREAMLINE/index.html). +## Pipeline Overview -* A simple demonstration of STREAMLINE on example biomedical data in our ready-to-run Google Colab Notebook [here](https://colab.research.google.com/drive/14AEfQ5hUPihm9JB2g730Fu3LiQ15Hhj2?usp=sharing). +The current pipeline is organized into 11 phases: -* A video tutorial playlist covering all aspects of STREAMLINE is available [here](https://www.youtube.com/playlist?list=PLafPhSv1OSDcvu8dcbxb-LHyasQ1ZvxfJ) +| Phase | Name | Purpose | +| --- | --- | --- | +| P1 | Data Process | Load datasets, define CV partitions, run exploratory analysis, and prepare dataset-specific metadata | +| P2 | Impute and Scale | Apply preprocessing, imputation, and scaling | +| P3 | Feature Learning | Learn transformed features such as PCA-derived components and write feature-learning artifacts | +| P4 | Feature Importance | Score features with filter-style feature importance methods | +| P5 | Feature Selection | Select and persist reduced feature sets | +| P6 | Modeling | Train and evaluate base models | +| P7 | Ensembles | Train and evaluate classification ensembles on top of base models | +| P8 | Summary Statistics | Aggregate CV metrics, generate plots, and summarize feature/model behavior | +| P9 | Compare Datasets | Compare results across datasets within an experiment | +| P10 | Replication | Apply the trained workflow to external replication datasets | +| P11 | Reporting | Build publication-style PDF reports for standard or replication outputs | -### YouTube Overview of STREAMLINE -[![IMAGE ALT TEXT HERE](https://img.youtube.com/vi/xVc4JEbnIs8/0.jpg)](https://www.youtube.com/watch?v=xVc4JEbnIs8) +## Supported Learning Tasks -### Pipeline Design -The goal of STREAMLINE is to provide an easy and transparent framework -to reliably learn predictive associations from tabular data with a particular focus on the needs of biomedical data applications. -The design of this pipeline is meant to not only pick a best performing algorithm/model for a given dataset, -but to leverage the different algorithm perspectives (i.e. biases, strengths, -and weaknesses) to gain a broader understanding of the associations in that data. +### Binary Classification -The overall development of this pipeline focused on: - 1. Automation and ease of use - 2. Optimizing modeling performance - 3. Capturing complex associations in data (e.g. feature interactions) - 4. Enhancing interpretability of output throughout the analysis - 5. Avoiding and detecting common sources of bias - 6. Reproducibility (see STREAMLINE parameter settings) - 7. Run mode flexibility (accomodates users with different levels of expertise) - 8. More advanced users can easily add their own scikit-learn compatible modeling algorithms to STREAMLINE +- Standard classification metrics such as balanced accuracy, accuracy, F1, recall, precision, ROC AUC, PRC AUC, PRC APS, and Brier score +- ROC and PR curve outputs +- Calibration-aware outputs and decision-threshold workflows -See the [About (FAQs)](https://urbslab.github.io/STREAMLINE/about.html) to gain a deeper understanding of STREAMLINE with respect to it's overall design, what it includes, what it can be used for, and implementation highlights that differentiate it from other AutoML tools. +### Multiclass Classification -### Current Limitations -* At present, STREAMLINE is limited to supervised learning on tabular, -binary classification data. We are currently expanding STREAMLINE to multi-class -and regression outcome data. +- Macro and micro metric support where appropriate +- Multiclass ROC/PR curve summaries +- Multiclass Brier score and one-vs-rest evaluation logic +- Report outputs and summary statistics tailored to multiclass evaluation -* STREAMLINE also does not automate feature extraction from unstructured data (e.g. text, images, video, time-series data), or handle more advanced aspects of data cleaning or feature engineering that would likely require domain expertise for a given dataset. +### Regression -* As STREAMLINE is currently in its 'beta' release, we recommend users first check that they have downloaded the -most recent release of STREAMLINE before use. We are actively updating this software as feedback is received. +- Regression metrics such as explained variance, Pearson correlation, MAE, MSE, median absolute error, and max error +- Actual-versus-predicted and residual diagnostics +- Replication and reporting flows adapted for regression outputs +- Phase 7 ensembles are currently classification-only; regression runs should proceed from Phase 6 directly to Phase 8. -### Publications and Citations -The most recent publication on STREAMLINE (release Beta 0.3.4) with benchmarking on simulated data and application to investigate obstructive sleep apena risk prediction as a clinical outcome is available as a preprint on arxiv [here]( -https://doi.org/10.48550/arXiv.2312.05461). +## Repository Layout -The first publication detailing the initial implementation of STREAMLINE (release Beta 0.2.4) and applying it to -simulated benchmark data can be found [here](https://link.springer.com/chapter/10.1007/978-981-19-8460-0_9), or as a preprint on arxiv, [here](https://arxiv.org/abs/2206.12002?fbclid=IwAR1toW5AtDJQcna0_9Sj73T9kJvuB-x-swnQETBGQ8lSwBB0z2N1TByEwlw). +Top-level items you will use most often: -See [citations](https://urbslab.github.io/STREAMLINE/citation.html) for more information on citing STREAMLINE, as well as publications applying STREAMLINE and publications on algorithms developed in our research group and incorporated into STREAMLINE. +- [`STREAMLINE_GoogleColab.ipynb`](STREAMLINE_GoogleColab.ipynb): primary Colab-oriented notebook +- [`STREAMLINE_Notebook.ipynb`](STREAMLINE_Notebook.ipynb): local Jupyter notebook workflow +- [`run_configs/`](run_configs): example `.cfg` files for full UCI demo pipelines +- [`data/`](data): demo training and replication datasets +- [`streamline/`](streamline): source code organized by phase +- [`usefulnotebooks/`](usefulnotebooks): focused post hoc analysis and visualization notebooks +- [`requirements.txt`](requirements.txt): local dependency list -*** -# Installation and Use -STREAMLINE can be run using a variety of modes balancing ease of use and efficiency. -* Google Colab Notebook: runs serially on Google Cloud (best for beginners) -* Jupyter Notebook: runs serially/locally -* Command Line: runs serially or locally - * Locally, serially - * Locally, cpu core in parallel - * CPU Computing Cluster (HPC), in parallel (best for efficiency) - * All phases can be run from a single command (with a job monitor/submitter running on the head node until completion) - * Each phase can be run separately in sequence +Key source directories: -See the [documentation](https://urbslab.github.io/STREAMLINE/index.html) for requirements, installation, and use details for each. +- `streamline/p1_data_process` +- `streamline/p2_impute_scale` +- `streamline/p3_feature_learning` +- `streamline/p4_feature_importance` +- `streamline/p5_feature_selection` +- `streamline/p6_modeling` +- `streamline/p7_ensembles` +- `streamline/p8_summary_statistics` +- `streamline/p9_compare_datasets` +- `streamline/p10_replication` +- `streamline/p11_reporting` +- `streamline/pipeline` for config-driven P1-P11 orchestration -Basic installation instructions for use on Google Colab, and local runs are given below. +## Run Modes + +STREAMLINE can be used in several ways depending on user preference and compute environment: + +- Google Colab notebook +- Local Jupyter notebook +- Config-driven full pipeline runs +- Local command line +- Local parallel execution with `run_cluster=Parallel` (joblib, no Dask) +- Local Dask execution with `run_cluster=Local` +- HPC / cluster execution using the phase CLIs and job submission helpers + +The current codebase includes CLI and runner modules for every phase from P1 through P11. + +## Saved Run Commands + +Each phase CLI records its resolved arguments in `//run_commands.pickle` after a successful run. On later runs, the same phase will reuse saved arguments for options you omit, while command-line values you provide override and update the saved entry. Use `--ignore_saved_run_command` for a fresh run or `--no_update_saved_run_command` to avoid updating the pickle. + +## Config-Driven Pipeline Runs + +STREAMLINE can run multiple phases from one `.cfg` file, matching the config-file workflow used in earlier releases. The config runner reads shared settings from `[run]`, phase toggles from `[phases]`, phase-specific settings from sections such as `[p1]` and `[p6]`, and then calls the same P1-P11 runner classes used by the phase CLIs. The `[phases]` section supports direct flags such as `do_p1 = True` as well as old-style broad flags such as `do_till_report = True`. + +Dry-run a config to inspect the resolved phase calls: + +```bash +python run.py -c run_configs/uci_binary_hcc.cfg --dry_run +``` + +Run the configured pipeline: + +```bash +python run.py -c run_configs/uci_binary_hcc.cfg +``` + +Useful controls: + +```bash +python run.py -c run_configs/uci_binary_hcc.cfg --start_at p4 +python run.py -c run_configs/uci_binary_hcc.cfg --stop_after p8 +python run.py -c run_configs/uci_binary_hcc.cfg --only p6,p8,p11 +python run.py -c run_configs/uci_binary_hcc.cfg --skip p3,p4 +``` + +Example configs are included for the three UCI demos: + +- `run_configs/uci_binary_hcc.cfg` +- `run_configs/uci_multiclass_student.cfg` +- `run_configs/uci_regression_auto_mpg.cfg` + +Phase 10 runs only when replication paths are configured, unless it is explicitly enabled. Phase 7 is automatically skipped for continuous/regression runs because the current ensemble registry is classification-only. + +## Feature Type Handling + +Phase 1 exposes `--one_hot_encoding`. The default keeps historical behavior and expands non-binary categorical features during data processing. Set `--one_hot_encoding 0` when you want Phase 6 to handle raw categorical columns per model. + +Phase 6 then uses `--bypass_one_hot_for_native_models` and `--native_categorical_models` to decide how raw categoricals are prepared. If Phase 1 metadata shows `one_hot_encoding=False`, Phase 6 only runs models listed in `--native_categorical_models` by default. Auto-discovered models are filtered to that native-capable list, and explicitly requested unsupported models raise an error instead of being silently one-hot encoded. With the default settings, this means CGB/CatBoost and ExSTraCS are the native categorical models; CatBoost receives `cat_features`, while ExSTraCS receives `discrete_attribute_limit="d"` plus zero-indexed `specified_attributes` for the categorical feature columns. + +Phase 6 also writes Optuna trial accounting to `/models/optuna_trials/*_optuna_trials*.csv` and includes the same trial summary in each per-CV metrics JSON. This records how many trials actually ran and completed within the requested `--n_trials` and `--timeout` budget. + +## Getting Started ### Google Colab -There is no local installation or additional steps required to run -STREAMLINE on Google Colab. -Just have a Google Account and open this Colab link to run the demo (takes ~ 6-7 min): -[https://colab.research.google.com/drive/14AEfQ5hUPihm9JB2g730Fu3LiQ15Hhj2?usp=sharing](https://colab.research.google.com/drive/14AEfQ5hUPihm9JB2g730Fu3LiQ15Hhj2?usp=sharing) +Use the current Colab notebook here: + +[Open the STREAMLINE Colab notebook](https://colab.research.google.com/drive/1ByQuU805GzDGAAGzbUYz8wahnOTUuzvg?usp=sharing) + +The updated Colab workflow is designed to support: + +- classification and regression in the same notebook +- demo runs and custom runs through configuration flags +- richer explanatory markdown and visible phase outputs + +### Local Jupyter + +For local notebook use, start from: + +- [`STREAMLINE_Notebook.ipynb`](STREAMLINE_Notebook.ipynb) for local binary, multiclass, regression, and custom workflows +- [`STREAMLINE_ColabNotebook.ipynb`](STREAMLINE_ColabNotebook.ipynb) for the Colab version of the parameter-driven flow + +### Local CLI + +Each phase can be run independently with its CLI entry point. For example: + +```bash +python -m streamline.p1_data_process.p1_cli --data_path data/UCIBinaryClassification --output_path out --experiment_name DemoBinary --outcome_label Class --outcome_type Binary --instance_label InstanceID --categorical_features data/UCIFeatureTypes/hcc_survival_categorical_features.csv --quantitative_features data/UCIFeatureTypes/hcc_survival_quantitative_features.csv +python -m streamline.p2_impute_scale.p2_cli --output_path out --experiment_name DemoBinary +python -m streamline.p3_feature_learning.p3_cli --output_path out --experiment_name DemoBinary +python -m streamline.p4_feature_importance.p4_cli --output_path out --experiment_name DemoBinary +python -m streamline.p5_feature_selection.p5_cli --output_path out --experiment_name DemoBinary +python -m streamline.p6_modeling.p6_cli --output_path out --experiment_name DemoBinary --outcome_label Class --outcome_type Binary --instance_label InstanceID +python -m streamline.p7_ensembles.p7_cli --output_path out --experiment_name DemoBinary +python -m streamline.p8_summary_statistics.p8_cli --output_path out --experiment_name DemoBinary --outcome_label Class --outcome_type Binary --instance_label InstanceID +python -m streamline.p9_compare_datasets.p9_cli --output_path out --experiment_name DemoBinary --outcome_label Class --outcome_type Binary --instance_label InstanceID +python -m streamline.p11_reporting.p11_cli --experiment_path out/DemoBinary --report_mode standard +``` + +For a longer command cookbook covering classification, regression, replication, and reporting examples, see [`sample_runcommands.txt`](sample_runcommands.txt). + +Replication and replication reporting are available through: + +```bash +python -m streamline.p10_replication.p10_cli \ + --rep_data_path data/UCIRepBinaryClassification \ + --dataset_for_rep data/UCIBinaryClassification/hcc_survival.csv \ + --output_path out \ + --experiment_name DemoBinary + +python -m streamline.p11_reporting.p11_cli \ + --experiment_path out/DemoBinary \ + --report_mode replication +``` + +## Local Installation +For a reproducible local setup, create a dedicated environment and install the repository requirements. -### Local -Install STREAMLINE for local use with the following command line commands: +STREAMLINE supports Python 3.10 and newer. Python 3.11 is the recommended +default for local demos because it works well across the current scientific +Python stack while remaining close to the Colab/runtime defaults. + +Example with conda: + +```bash +git clone --single-branch https://github.com/UrbsLab/STREAMLINE.git +cd STREAMLINE +conda create -n streamline python=3.11 pip +conda activate streamline +conda install pytorch=2.6 -y +pip install -r requirements.txt +``` + +TabPFN requires a Prior Labs token before local model weights can be downloaded. +Without the token, Phase 6 warns and skips requested TabPFN models while other +models continue. See `docs/source/tabpfn_token.md` before running TabPFN models +locally. + +Example with `venv`: ``` git clone --single-branch https://github.com/UrbsLab/STREAMLINE @@ -91,64 +232,148 @@ cd STREAMLINE pip install -r requirements.txt ``` -Now your STREAMLINE package is ready to use from the `STREAMLINE` folder either -from the included [Jupyter Notebook](https://github.com/UrbsLab/STREAMLINE/blob/main/STREAMLINE_Notebook.ipynb) file or the command line. +Notes: + +- The pinned requirements are the best starting point for local reproducibility. +- Continuous integration runs the main end-to-end tests on Python 3.10, 3.11, 3.12, and 3.13. +- If you intentionally install the latest unpinned package versions, expect to do some compatibility testing because the upstream scientific Python stack changes frequently. +- Some optional packages depend on compiled libraries or environment-specific binaries. + +## Demo Data And Demo Paths + +Included UCI demo datasets with missing values and mixed categorical/quantitative features: + +- `data/UCIBinaryClassification/hcc_survival.csv` and companion `_copy.csv` +- `data/UCIMulticlassClassification/student_dropout_academic_success.csv` and companion `_copy.csv` +- `data/UCIRegression/auto_mpg.csv` and companion `_copy.csv` +- `data/UCIRepBinaryClassification/hcc_survival_rep.csv` +- `data/UCIRepMulticlassClassification/student_dropout_academic_success_rep.csv` +- `data/UCIRepRegression/auto_mpg_rep.csv` +- `data/UCIFeatureTypes/` for UCI categorical and quantitative feature-type examples +- `data/UCI_DemoDatasets_README.md` for source links, target labels, Auto MPG field handling, and example Phase 1 commands + +These datasets are used by the notebooks and test suite to exercise classification, multiclass classification, and regression workflows. The normal UCI folders contain deterministic 80% training splits; the matching `data/UCIRep*` folders contain the held-out 20% replication splits. + +## Output Structure + +STREAMLINE writes experiment outputs under: + +```text +// +``` + +Within an experiment, common directories include: + +- `/exploratory` +- `/CVDatasets` +- `/feature_learning` +- `/feature_importance` +- `/feature_selection` +- `/models` +- `/model_evaluation` +- `/ensemble_evaluation` +- `/runtime` +- `/replication//...` +- `DatasetComparisons/` +- `reporting/` +- `reporting_replication/` +- `jobsCompleted/` + +Standard reports are written to: + +- `/reporting/_STREAMLINE_Report.pdf` + +Replication reports are written to: + +- `/reporting_replication/_STREAMLINE_Replication_Report.pdf` + +## Reporting + +The reporting phase can: + +- discover datasets dynamically +- handle binary, multiclass, and regression outputs +- generate missing figures when possible +- reuse existing figures when available +- generate standard experiment reports +- generate replication-focused reports from replication folders + +Reporting entry point: + +```bash +python -m streamline.p11_reporting.p11_cli --experiment_path out/DemoRun --report_mode standard +python -m streamline.p11_reporting.p11_cli --experiment_path out/DemoRun --report_mode replication +``` + +## Useful Notebooks + +The `usefulnotebooks/` directory contains focused notebooks for downstream analysis and visualization, including: + +- decision-threshold analysis +- ROC and PR curve generation +- composite feature-importance visualization +- feature-importance heatmaps +- model visualization +- test-set probability access +- replication probability analysis + +These notebooks are intended for users who want to inspect outputs after a pipeline run rather than drive the entire workflow from a single notebook. + +## Extending STREAMLINE + +The refactored codebase uses registry-driven discovery across multiple phases. This makes it easier to add new methods without rewriting pipeline orchestration for every new component. + +Relevant extension points include: + +- `streamline/p2_impute_scale/registry` +- `streamline/p3_feature_learning/registry` +- `streamline/p4_feature_importance/registry` +- `streamline/p5_feature_selection/registry` +- `streamline/p6_modeling/models` +- `streamline/p7_ensembles/registry` + +In practice, this means new preprocessing, feature-learning, feature-importance, feature-selection, modeling, and ensemble components can be added in a more modular way than in older versions of STREAMLINE. + +## Current Notes And Limitations + +- STREAMLINE is designed for supervised learning on tabular data. +- Unstructured data pipelines such as image, text, audio, and raw time-series feature extraction are not automated here. +- The documentation in `docs/source` is the current documentation for the v1.0.0 main release. +- As with any ML pipeline assembled on top of evolving third-party libraries, latest-version local environments may expose compatibility issues that require updates. -*** -# Other Information -## Demonstration Data -Included with this pipeline is a folder named `DemoData` including [two small datasets](https://urbslab.github.io/STREAMLINE/data.html#demonstration-data) used as a demonstration of -pipeline efficacy. New users can easily test/run STREAMLINE in all run modes set up to run automatically on these datasets. +## Publications And Citation -## List of Run Parameters -A complete list of STREAMLINE Parameters can be found [here](https://urbslab.github.io/STREAMLINE/parameters.html). +The first publication detailing STREAMLINE (release Beta 0.2.4) and applying it to simulated benchmark data is available here: -*** -## Disclaimer -We make no claim that this is the best or only viable way to assemble an ML analysis pipeline for a given -classification problem, nor that the included ML modeling algorithms will yield the best performance possible. -We intend many expansions/improvements to this pipeline in the future. We welcome feedback, suggestions, and contributions for improvement. +[Springer chapter](https://link.springer.com/chapter/10.1007/978-981-19-8460-0_9) -*** -# Contact -We welcome ideas, suggestions on improving the pipeline, [code-contributions](https://https://urbslab.github.io/STREAMLINE/contributing.html), and collaborations! +The paper is also available as a preprint: -* For general questions, or to discuss potential collaborations (applying, or extending STREAMLINE); contact Ryan Urbanowicz at ryan.urbanowicz@cshs.org. +[arXiv preprint](https://arxiv.org/abs/2206.12002) -* For questions on the code-base, installing/running STREAMLINE, report bugs, or discuss other troubleshooting issues; contact Harsh Bandhey at harsh.bandhey@cshs.org. +Additional citation information and related publications: -# Other STREAMLINE Tutorial Videos on YouTube -### A Brief Introduction to Automated Machine Learning -[![IMAGE ALT TEXT HERE](https://img.youtube.com/vi/IjX0phz3LLE/0.jpg)](https://www.youtube.com/watch?v=IjX0phz3LLE) +[STREAMLINE citations](https://urbslab.github.io/STREAMLINE/citation.html) -### A Detailed Walkthrough -[![IMAGE ALT TEXT HERE](https://img.youtube.com/vi/sAB8d1KnMDw/0.jpg)](https://www.youtube.com/watch?v=sAB8d1KnMDw) +## Additional Resources -### Input Data -[![IMAGE ALT TEXT HERE](https://img.youtube.com/vi/5HnangrEF5E/0.jpg)](https://www.youtube.com/watch?v=5HnangrEF5E) +- Documentation source: [`docs/source`](docs/source) +- Command cookbook: [`sample_runcommands.txt`](sample_runcommands.txt) +- Included demo dataset notes: [`data/UCI_DemoDatasets_README.md`](data/UCI_DemoDatasets_README.md) -### Run Parameters -[![IMAGE ALT TEXT HERE](https://img.youtube.com/vi/qMi9vhVag-4/0.jpg)](https://www.youtube.com/watch?v=qMi9vhVag-4) +## Contact -### Running in Google Colab Notebook -[![IMAGE ALT TEXT HERE](https://img.youtube.com/vi/nknyJWhm7pg/0.jpg)](https://www.youtube.com/watch?v=nknyJWhm7pg) +We welcome ideas, suggestions, bug reports, code contributions, and collaborations. -### Running in Jupyter Notebook -[![IMAGE ALT TEXT HERE](https://img.youtube.com/vi/blat3gAfUaI/0.jpg)](https://www.youtube.com/watch?v=blat3gAfUaI) +- General questions and collaboration inquiries: Ryan Urbanowicz at `ryan.urbanowicz@cshs.org` +- Codebase, installation, running, troubleshooting, and implementation questions: Harsh Bandhey at `harsh.bandhey@cshs.org` -### Running From Command Line -[![IMAGE ALT TEXT HERE](https://img.youtube.com/vi/-5yjGxnJ7eI/0.jpg)](https://www.youtube.com/watch?v=-5yjGxnJ7eI) +## Acknowledgements -*** -# Acknowledgements The development of STREAMLINE benefited from feedback across multiple biomedical research collaborators at the University of Pennsylvania, Fox Chase Cancer Center, Cedars Sinai Medical Center, and the University of Kansas Medical Center. -The bulk of the coding was completed by Ryan Urbanowicz, Robert Zhang, and Harsh Bandhey. Special thanks to -Yuhan Cui, Pranshu Suri, Patryk Orzechowski, Trang Le, Sy Hwang, Richard Zhang, Wilson Zhang, -and Pedro Ribeiro for their code contributions and feedback. +The bulk of the coding was completed by Ryan Urbanowicz, Robert Zhang, and Harsh Bandhey. Special thanks to Yuhan Cui, Pranshu Suri, Patryk Orzechowski, Trang Le, Sy Hwang, Richard Zhang, Wilson Zhang, and Pedro Ribeiro for their code contributions and feedback. -We also thank the following collaborators for their feedback on application -of the pipeline during development: Shannon Lynch, Rachael Stolzenberg-Solomon, -Ulysses Magalang, Allan Pack, Brendan Keenan, Danielle Mowery, Jason Moore, and Diego Mazzotti. +We also thank the following collaborators for their feedback on application of the pipeline during development: Shannon Lynch, Rachael Stolzenberg-Solomon, Ulysses Magalang, Allan Pack, Brendan Keenan, Danielle Mowery, Jason Moore, and Diego Mazzotti. Funding supporting this work comes from NIH grants: R01 AI173095, U01 AG066833, and P01 HL160471. diff --git a/STREAMLINE-GoogleColab.ipynb b/STREAMLINE-GoogleColab.ipynb deleted file mode 100644 index 6710ca9f..00000000 --- a/STREAMLINE-GoogleColab.ipynb +++ /dev/null @@ -1 +0,0 @@ -{"cells":[{"cell_type":"markdown","metadata":{"id":"s405-rXWFkas"},"source":["![alttext](https://github.com/UrbsLab/STREAMLINE/blob/main/docs/source/pictures/STREAMLINE_Logo_Full.png?raw=true)"]},{"cell_type":"markdown","metadata":{"id":"cgyTC3LLFvsE"},"source":["# GOOGLE COLAB NOTEBOOK README\n","STREAMLINE is an end-to-end automated machine learning (AutoML) pipeline that empowers anyone to easily run, interpret, and apply a rigorous and customizable analysis for data mining or predictive modeling. Currently limited to binary classification in tabular data.\n","\n","* This notebook runs all primary elements STREAMLINE. We recommend users review the STREAMLINE documentation for details.\n","\n","## What to expect running this notebook 'as-is'?\n","* This notebook has been initially set up to run 'as-is' on two 'demo' datasets: (1) hcc-data_example.csv: the original HCC dataset downloaded from the UCI repository and (2) hcc-data_example_custom.csv: a 'custom' datasets which removes the two covariate features from the HCC dataset, and adds simulated features and instances to it to explicitly test aspects of data preprocessing (i.e. cleaning and feature engineering). Suggested default STREAMLINE run parameters are already specified.\n","\n","* After model training and testing evaluations are complete, the models trained from hcc-data_example_custom.csv are applied to a 'replication' dataset (hcc-data_example_custom_rep.csv) for another round of evaluations. Since no true replication data was available for this example, we simulated a replication dataset by taking the original hcc-data_example_custom.csv data and randomly resampling feature values for 30% of instances in the data to add some noise/variation to it.\n","\n","* Notebook run parameters have initially been set up to run only three of the available modeling algorithms (logistic regression, decision tree, and naive bayes), with 3-fold CV so that it runs completely in about 6-7 minutes.\n","\n","* As the notebook run completes, the PDF summary(s) and zipped output folder will automatically downloaded to your computer. You will likely be propted to accept the download on your first run.\n","\n","## Run Instructions for this Notebook\n","* For Demo:\n"," * Leave all run parameter cells (below) unchanged and choose 'RunAll' under 'Runtime' tab in Colab Notebook\n"," * You can optionally change non-dataset related run parameters below to run the demo with different settings\n","\n","* Custom Dataset Run:\n","\n"," * Easy Mode:\n"," * Set (demo_run = False) and (use_data_prompt = True), then edit the remaining run parameters below as desired, excluding dataset parameters\n"," * Choose 'RunAll' under 'Runtime' tab in Colab Notebook.\n"," * When notebook runs, the user will first be prompted to load datasets, and specify other critical dataset parameters. This includes:\n"," * (Required) The output folder name for the current STREAMLINE experiment\n"," * (Required) Selecting dataset(s) for STREAMLINE analysis\n"," * Specifying (without single or double quotation marks):\n"," * (Required) class column label\n"," * (If present) instanceID column label, otherwise type (None)\n"," * (If present) Match column label (for covariate matched data), otherwise type (None) \n"," * (Required) If replication data is available\n"," * (If available) Selecting dataset(s) for replication evaluation\n"," * (If available) Specifying the name of the target dataset (including file extension) whos models the replication data will be evaluating\n","\n"," * Manual Mode:\n"," * Set (demo_run = False) and (use_data_prompt = False)\n"," * Manually create a folder in /content/ (i.e. locally in the google colab workspace)\n"," * Edit all run parameters accordingly, including target dataset filepaths\n"," * Choose 'RunAll' under 'Runtime' tab in Colab Notebook.\n","* Before running the STREAMLIN notebook again we generally recommend selecting \"Disconnect and delete runtime' under 'Runtime' tab in Colab Notebook."]},{"cell_type":"markdown","metadata":{"id":"FK8eqAI0FzCr"},"source":["--------------"]},{"cell_type":"markdown","metadata":{"id":"Y-5hwPRCYDZM"},"source":["# STREAMLINE RUN PARAMETERS\n","The first two paramters below are specific to this Google Colab notebook."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"JhBZoMAWbDaR"},"outputs":[],"source":["demo_run = True # Leave (True) to run the demo dataset, make (False) to have new temporary folder created to upload datasets\n","use_data_prompt = True # Generally leave as (True) unless you want to dissable the prompts (that allows users to run their own data without changing the dataset run parameters in this notebook)"]},{"cell_type":"markdown","metadata":{"id":"3JaK2AXyoSyN"},"source":["### Run Parameters: Target Datasets (Ignore if Running Demo Data)\n","* No need to edit unless (demo_run = False) and (use_data_prompt = False).\n","* Update these parameters to run STREAMLINE on a different folder of datasets. Any folder of datasets to be analyzed should include one or more datasets saved as .txt or .csv files. See documentation for dataset formatting requirements.\n","\n","* All datasets should have the same header names for the class, instance, and match labels (note instance and match labels are optional)."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"FyViM3Q-oTFU"},"outputs":[],"source":["if not demo_run: # Leave this command as is.\n","\n"," # File path to the folder containing dataset(s) to be analyzed (must include one or more .txt, .tsv, or .csv datasets)\n"," data_path = \"/content/UserData\" # (str) Data Folder Path\n","\n"," # Output foder path: where to save pipeline outputs (must be updated for a given user)\n"," output_path = '/content/UserOutput' # (str) Ouput Folder Path (folder will be created by STREAMLINE automatically)\n","\n"," # Unique experiment name - folder created for this analysis within output folder path\n"," experiment_name = 'my_experiment' # (str) Experiment Name (change to save a new STREAMLINE run output folder instead of overwriting previous run)\n","\n"," # Data Labels\n"," class_label = 'Class' # (str) i.e. class outcome column label\n"," instance_label = 'InstanceID' # (str) If data includes instance labels, given respective column name here, otherwise put 'None'\n"," match_label = None # (str or None) Only applies when M selected for partition-method; indicates column label with matched instance ids'\n","\n"," # Option to manually specify feature names to leave out of analysis, or which to treat as categorical (without using built in variable type detector)\n"," ignore_features = None # list of column names (given as string values) to exclude from the analysis (only insert column names if needed, otherwise leave empty)\n"," categorical_feature_headers = None # empty list for 'auto-detect' otherwise list feature names (given as string values) to be treated as categorical. Only impacts algorithms that can take variable type into account."]},{"cell_type":"markdown","metadata":{"id":"2lfjpdkrcGf5"},"source":["### Run Parameters: General\n","* Optionally update these general parameters used throughout all/most phases of the pipeline."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"KtyZbhKUXyjF"},"outputs":[],"source":["# Cross Validation (CV)\n","n_splits = 3 # (int, > 1) Number of training/testing data partitions to create - and resulting number of models generated using each ML algorithm\n","partition_method = 'Stratified' # (str) for Stratified, Random, or Group, respectively\n","\n","# Cutoffs\n","categorical_cutoff = 10 # (int) Number of unique values after which a variable is considered to be quantitative vs categorical if categorical_features_headers not specified.\n","sig_cutoff = 0.05 # (float, 0-1) Significance cutoff used throughout pipeline\n","# Set Random Seed for Reproducible Analysis\n","random_state = 42 # (int) Sets a specific random seed for reproducible results"]},{"cell_type":"markdown","metadata":{"id":"60Pbh38acLlj"},"source":["### Run Parameters: Data Processing\n","* Optionally, update these parameters to decide what analyses are run and outputs are produced by STREAMLINE in the exploratory analysis phase."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"mBoYcHI0cgEz"},"outputs":[],"source":["# Analysis options to turn on or off in the exploratory analysis (\"Describe\" = basic descriptive data stats, \"Differentiate\")\n","exploration_list = [\"Describe\", \"Univariate Analysis\", \"Feature Correlation\"] # (list of strings) Options:[\"Describe\", \"Differentiate\", \"Univariate Analysis\"]\n","\n","# Control what exploratory analysis plots get generated\n","plot_list = [\"Describe\", \"Univariate Analysis\", \"Feature Correlation\"] # (list of strings) Options:[\"Describe\", \"Univariate Analysis\", \"Feature Correlation\"]\n","\n","# univariate analysis plots (note: univariate analysis still output by default)\n","top_features = 20 # (int) Number of top features to report in notebook for univariate analysis\n","\n","featureeng_missingness = 0.5 # (float, 0-1) Percentage of missing after which categorical featrure identifier is generated.\n","cleaning_missingness = 0.5 # (float, 0-1) Percentage of missing after instance and feature removal is performed.\n","correlation_removal_threshold = 1 # (float, 0-1)"]},{"cell_type":"markdown","metadata":{"id":"DBQP30iGpV6j"},"source":["### Run Parameters: Scaling and Imputing\n","* Optionally update these parameters to turn specific data preprocessing options on or off."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"2hKlwP7wpWUA"},"outputs":[],"source":["# Data Transformation (i.e. scaling) - important for running and interpreting built-in feature importance estimates for certain ML modeling algorithms\n","scale_data = True # (bool, True or False) Perform data scaling\n","\n","# Missing Data Imputation Options\n","impute_data = True # (bool, True or False) Perform missing value data imputation? (required for most ML algorithms if missing data is present)\n","multi_impute = True # (bool, True or False) Applies multivariate imputation to quantitative features, otherwise uses mean imputation\n","\n","# Option for how cross validation datasets are saved (for external use)\n","overwrite_cv = True # (bool, True or False) Overwrites earlier cv datasets with new scaled/imputed ones"]},{"cell_type":"markdown","metadata":{"id":"20i7JqJH332M"},"source":["### Run Parameters: Feature Importance Estimation\n","* Optionally update these parameters to decide which filter-based feature importance estimation algorithms to apply (currently only mutual information and MultiSURF are options)."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"CtQxdYfi34P8"},"outputs":[],"source":["# Available Filter-based Feature Importance/Selection Algorithms\n","do_mutual_info = True # (bool, True or False) Do mutual information analysis\n","do_multisurf = True # (bool, True or False) Do multiSURF analysis\n","\n","# Additional MultiSURF Options\n","use_TURF = False # (bool, True or False) Use TURF wrapper around MultiSURF\n","TURF_pct = 0.5 # (float, 0.01-0.5) Proportion of instances removed in an iteration (also dictates number of iterations)\n","instance_subset = 2000 # (int) Sample subset size to use with MultiSURF (since MultiSURF's compute time scales quadratically with instance count)\n","njobs = -1 # (int) Number of cores dedicated to running algorithm; setting to -1 will use all available cores when run locally"]},{"cell_type":"markdown","metadata":{"id":"zXlPgkcn6T0A"},"source":["### Run Parameters: Feature Selection\n","* Optionally update these parameters to control how 'collective' feature selection is conducted prior to modeling.\n","\n"," * When 'filter_poor_features' = False, all features will be used in the modeling phase.\n","\n"," * When 'filter_poor_features' = True:\n"," * And 'max_features_to_keep' = 'None', all features with a score <= 0 from all active feature importance algorithm will be removed, but the rest kept.\n","\n"," * And 'max_features_to_keep' = n (where n is a 'value' less than the total number of features in the dataset), first all features with a score <= 0 from all active feature importance algorithm will be removed, then the top n scoring (non-redundant) features from each algorithm will be kept."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"9I5eaBmU6UEl"},"outputs":[],"source":["# Turn feature selection on or off\n","filter_poor_features = True # (bool, True or False) Filter out the worst performing features prior to modeling\n","\n","# Control maximum number of features to keep out of total features in dataset.\n","max_features_to_keep = 2000 # (int) Maximum features to keep. 'None' if no max\n","\n","# Controls the feature importance estimation plots generation\n","top_features = 40 # (int) Number of top features to illustrate in figures\n","export_scores = True # (bool, True or False) Export figure summarizing average feature importance scores over cv partitions"]},{"cell_type":"markdown","metadata":{"id":"QmjcXp6y9yDC"},"source":["### Run Parameters: Modeling\n","* Optionally update these parameters to control what modeling algorithms are run, as well as other options relevant to the modeling phase. The 16 Classification algorithms currently available in STREAMLINE include:\n","\n"," * Naive Bayes (NB)\n"," * Logistic Regression (LR)\n"," * Elastic Net (EN)\n"," * Decision Tree (DT)\n"," * Random Forest (RF)\n"," * Gradient Boosting (GB)\n"," * Extreame Gradient Boosting (XGB)\n"," * Light Gradient Boosting (LGB)\n"," * Category Gradient Boosting (CGB)\n"," * Support Vector Machines (SVM)\n"," * Artificial Neural Networks (ANN)\n"," * K-Nearest Neighbors (KNN)\n"," * Genetic Programming, i.e. symbolic classification (GP)\n"," * Educational Learning Classifier System (eLCS)\n"," * 'X' Classifier System (XCS)\n"," * Extended Supervised Tracking Classifier System (ExSTraCS)\n","\n","The last 3 algorithms above are rule-based ML approaches implemented by our research group. Their are currently suspected bugs in eLCS and XCS so they have been turned off when using default settings.\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Tc_cuqYo9yTF"},"outputs":[],"source":["# Machine Learning Algorithms to Run (Setting 'algorithms' to 'None' rather than a list will run all algorithms except those specified in 'exclude')\n","algorithms = [\"NB\", \"LR\", \"DT\"] # (list of strings) Options: [\"NB\",\"LR\",\"EN\",\"DT\",\"RF\",\"GB\",\"XGB\",\"LGB\",\"CGB\",\"SVM\",\"ANN\",\"KNN\",\"GP\",\"eLCS\",\"XCS\",\"ExSTraCS\"]\n","\n","# ML Model Algorithm to exclude\n","exclude = ['eLCS', 'XCS'] # (list of strings) Options: [\"NB\",\"LR\",\"EN\",\"DT\",\"RF\",\"GB\",\"XGB\",\"LGB\",\"CGB\",\"SVM\",\"ANN\",\"KNN\",\"GP\",\"eLCS\",\"XCS\",\"ExSTraCS\"]\n","\n","# Other Analysis Parameters\n","training_subsample = 0 # (int) For long running algorithms, option to subsample training set (0 for no subsample) Limit Sample Size Used to train algorithms that do not scale up well in large instance spaces (i.e. XGB,SVM,KN,ANN,and LR to a lesser degree) and depending on 'instances' settings, ExSTraCS, eLCS, and XCS)\n","use_uniform_FI = True # (bool, True or False) Overides use of any available feature importances estimate methods from models, instead using permutation_importance uniformly\n","primary_metric = 'balanced_accuracy' # (str) Must be an available metric identifier from (https://scikit-learn.org/stable/modules/model_evaluation.html#scoring-parameter)\n","metric_direction = 'maximize' # (str, either of 'maximize' or 'minimize')\n","\n","# Hyperparameter Sweep Options\n","n_trials = 200 # (int or None) Number of bayesian hyperparameter optimization trials using optuna\n","timeout = 900 # (int or None) Seconds until hyperparameter sweep stops running new trials (Note: it may run longer to finish last trial started)\n","export_hyper_sweep_plots = True # (bool, True or False) Export hyper parameter sweep plots from optuna\n","\n","# Learning classifier system algorithm options (ExSTraCS, eLCS, XCS)\n","do_lcs_sweep = False # (bool, True or False) Do LCS hyperparam tuning or use below params\n","lcs_nu = 1 # (int, 0-10) Fixed LCS nu param\n","lcs_iterations = 200000 # (int, > data sample size) Fixed LCS # learning iterations param\n","lcs_N = 2000 # (int) > 500) Fixed LCS rule population maximum size param\n","lcs_timeout = 1200 # (int) Seconds until hyperparameter sweep stops for LCS algorithms (evolutionary algorithms often require more time for a single run)"]},{"cell_type":"markdown","metadata":{"id":"6zKal9-MB1IH"},"source":["### Run Parameters: Evaluation Figure Generation (Stats Phase)\n","* Optionally update these parameters to control aspects of model evaluation figure generation. Note that all STREAMLINE performance metric evaluations and figures are generated with respect to the hold out testing data in this phase."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"9ZoJ7JVIB1aP"},"outputs":[],"source":["# ROC and PRC Plot Generation for Individual Algorithms (including separate curves for each CV model trained)\n","plot_ROC = True # (bool, True or False) Plot ROC curves individually for each algorithm including all CV results and averages\n","plot_PRC = True # (bool, True or False) Plot PRC curves individually for each algorithm including all CV results and averages\n","\n","# Feature Importance Plots (for each algorithm)\n","plot_FI_box = True # (bool, True or False) Plot feature importance boxplots for each algorithm\n","\n","# Box Plots Comparing Algorithm Performance (for each evaluation metric)\n","plot_metric_boxplots = True # (bool, True or False) Plot box plot summaries comparing algorithms for each metric\n","\n","# Composite Feature Importance Plot Setting\n","metric_weight = 'balanced_accuracy' # (str, balanced_accuracy or roc_auc) ML model metric used as weight in composite FI plots (only supports balanced_accuracy or roc_auc as options) Recommend setting the same as primary_metric if possible.\n","\n","# Feature Importance Plot Setting (impacts individual feature importance plots for each algorith and the composite feature importance plot)\n","top_model_features = 40 # (int) Number of top features in model to illustrate in feature importance figures"]},{"cell_type":"markdown","metadata":{"id":"-TUI02jpqAYW"},"source":["### Run Parameters: Replication Data (Ignore if Running Demo Data)\n","* Don't edit unless (demo_run = False) and (use_data_prompt = False).\n","\n","* Update these parameters to run STREAMLINE's 'apply' phase where all models trained in the earlier phases are evaluated on the same hold-out replication data (recommended when available).\n","\n","* Multiple replication datasets (e.g. data collected from different sites) can be included in the replication data folder and STREAMLINE will apply replication analyses to each individually."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"WU5Qg99kqArq"},"outputs":[],"source":["if not demo_run: # Leave this command as is.\n","\n"," # Turns the replication data analysis phase on or off\n"," applyToReplication = True # (bool, True or False) Leave false unless you have a replication dataset handy to further evaluate/compare all models in uniform manner\n","\n"," # File path to the folder containing the replication dataset(s) to be evaluated using previously trained models (.txt, .tsv, or .csv datasets))\n"," rep_data_path = \"/content/UserRepData\" # (txt) Name of folder with replication Dataset(s)\n","\n"," # File path to one of the individual datasets used to train models within STREAMLINE\n"," dataset_for_rep = \"/content/UserData/user_data_example.csv\" # (txt) Path and name of an individual dataset used to generate the models being evaluated with replication data"]},{"cell_type":"markdown","metadata":{"id":"rZHO8BTccGuR"},"source":["### Run Parameters: Output File Cleanup\n","* Optionally update these parameters to delete temporary files in output folder (generally recommended to leave these as True)."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"aWhgkZFTcG-H"},"outputs":[],"source":["del_time = True # (bool, True or False) Delete individual run-time files (but save summary)\n","del_old_cv = True # (bool, True or False) Delete any of the older versions of CV training and testing datasets if overwrite_cv was set to False (preserves training and testing datasets used in pipeline)"]},{"cell_type":"markdown","metadata":{"id":"oGjuHXOdZFyh"},"source":["-------------\n","\n","# Users - We recommend you do not make code edits below this cell.\n","\n","--------------"]},{"cell_type":"markdown","metadata":{"id":"WDP9cvFQTN1N"},"source":["# DEMO DATA ANALYSIS SETUP\n"]},{"cell_type":"markdown","metadata":{"id":"Ej-ZhNo_ZKzX"},"source":["### Demo Data Run Parameters:\n","* Set up for Demo Run (never edit the code cell below)\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"G46uzad2RJPL"},"outputs":[],"source":["if demo_run: # Leave this command as is.\n","\n"," # File path to the folder containing dataset(s) to be analyzed (must include one or more .txt, .tsv, or .csv datasets)\n"," data_path = \"/content/STREAMLINE/data/DemoData\" # (str) Data Folder Path\n","\n"," # Output foder path: where to save pipeline outputs (must be updated for a given user)\n"," output_path = '/content/DemoOutput' # (str) Ouput Folder Path (folder will be created by STREAMLINE automatically)\n","\n"," # Unique experiment name - folder created for this analysis within output folder path\n"," experiment_name = 'demo_experiment' # (str) Experiment Name (change to save a new STREAMLINE run output folder instead of overwriting previous run)\n","\n"," # Data Labels\n"," class_label = 'Class' # (str) i.e. class outcome column label\n"," instance_label = 'InstanceID' # (str) If data includes instance labels, given respective column name here, otherwise put 'None'\n"," match_label = None # (str or None) Only applies when M selected for partition-method; indicates column label with matched instance ids'\n","\n"," # Option to manually specify feature names to leave out of analysis\n"," ignore_features = None # list of column names (given as string values) to exclude from the analysis (only insert column names if needed, otherwise leave empty)\n","\n"," # Recommended option to manually specify what features to treat as categorical (None for 'auto-detect', otherwise list feature names (given as string values) to be treated as categorical.\n"," # See https://archive.ics.uci.edu/ml/datasets/HCC+Survival for breakdown of feature types: nominal (i.e. categorical), or ordinal, continuous and integer (i.e. quantitative)\n"," categorical_feature_headers = ['Gender','Symptoms','Alcohol','Hepatitis B Surface Antigen','Hepatitis B e Antigen','Hepatitis B Core Antibody','Hepatitis C Virus Antibody','Cirrhosis',\n"," 'Endemic Countries','Smoking','Diabetes','Obesity','Hemochromatosis','Arterial Hypertension','Chronic Renal Insufficiency','Human Immunodeficiency Virus',\n"," 'Nonalcoholic Steatohepatitis','Esophageal Varices','Splenomegaly','Portal Hypertension','Portal Vein Thrombosis','Liver Metastasis','Radiological Hallmark',\n"," 'Sim_Cat_2','Sim_Cat_3','Sim_Cat_4','Sim_Text_Cat_2','Sim_Text_Cat_3','Sim_Text_Cat_4']\n","\n"," # Turns the replication data analysis phase on or off\n"," applyToReplication = True # (bool, True or False) Leave false unless you have a replication dataset handy to further evaluate/compare all models in uniform manner\n","\n"," # File path to the folder containing the replication dataset(s) to be evaluated using previously trained models (.txt, .tsv, or .csv datasets))\n"," rep_data_path = \"/content/STREAMLINE/data/DemoRepData\" # (txt) Name of folder with replication Dataset(s)\n","\n"," # File path to one of the individual datasets used to train models within STREAMLINE\n"," dataset_for_rep = \"/content/STREAMLINE/data/DemoData/hcc-data_example_custom.csv\" # (txt) Path and name of an individual dataset used to generate the models being evaluated with replication data"]},{"cell_type":"markdown","metadata":{"id":"JV_tzea2hnFY"},"source":["-------------"]},{"cell_type":"markdown","metadata":{"id":"dcJt-Gc4go8A"},"source":["# PROMPT SETUP FOR DATASET PARAMETERS"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"rq9TndZzTVWE"},"outputs":[],"source":["def run_prompts(demo_run,use_data_prompt,original_wd):\n"," import os\n","\n"," output_path = '/content/UserOutput' # Make separate ouput folder to save STREAMLINE experiment runs on non-demo data\n","\n"," # Get and save user datasets locally\n"," custom_data_path = '/content/UserData' # Make local folder for saving user specified target datasets for STREAMLINE anlaysis\n","\n"," # Check if the directory exists\n"," if not os.path.exists(custom_data_path):\n"," # Create the directory if it doesn't exist\n"," os.makedirs(custom_data_path)\n"," else:\n"," # Traverse the directory tree and delete all files and directories\n"," for root, dirs, files in os.walk(custom_data_path, topdown=False):\n"," for name in files:\n"," os.remove(os.path.join(root, name))\n"," for name in dirs:\n"," os.rmdir(os.path.join(root, name))\n"," os.rmdir(custom_data_path)\n"," os.makedirs(custom_data_path)\n","\n"," os.chdir(custom_data_path)\n","\n"," # Ask user for unique experiment name (we do this first so the screen jumps to this prompt)\n"," experiment_name = input(\"Enter unique experiment name for output folder (required, no spaces): \\n\")\n","\n"," # Have user upload target dataset(s)\n"," from google.colab import files\n"," uploaded = files.upload() # Prompt user to select one or more datasets to upload into the 'UserData' folder\n"," os.chdir(original_wd)\n","\n"," # Gather other necessary target data information\n"," class_label = input(\"Enter header label of class column (required): \\n\")\n"," instance_label = input(\"Enter header label of instance ID or specify None: \\n\")\n"," match_label = input(\"Enter header label of match column or specify None: \\n\")\n"," if instance_label == \"None\":\n"," instance_label = None\n"," if match_label == \"None\":\n"," match_label = None\n","\n"," # Ask user whether replication dataset(s) are available\n"," applyToReplication = eval(input(\"Is replication data available? Enter True or False (required): \\n\"))\n"," custom_rep_data_path = None\n"," dataset_for_rep = None\n"," if applyToReplication:\n"," custom_rep_data_path = '/content/UserRepData' # Make local folder for saving user specified target datasets for STREAMLINE anlaysis\n","\n"," # Check if the directory exists\n"," if not os.path.exists(custom_rep_data_path):\n"," # Create the directory if it doesn't exist\n"," os.makedirs(custom_rep_data_path)\n"," else:\n"," # Traverse the directory tree and delete all files and directories\n"," for root, dirs, files in os.walk(custom_rep_data_path, topdown=False):\n"," for name in files:\n"," os.remove(os.path.join(root, name))\n"," for name in dirs:\n"," os.rmdir(os.path.join(root, name))\n"," os.rmdir(custom_rep_data_path)\n"," os.makedirs(custom_rep_data_path)\n","\n"," os.chdir(custom_rep_data_path)\n","\n"," # Have user upload replication dataset(s)\n"," from google.colab import files\n"," uploaded = files.upload() # Prompt user to select one or more datasets to upload into the 'UserData' folder\n"," os.chdir(original_wd)\n","\n"," #Have user idenify the name of the target dataset used to train the model to which the replication dataset(s) will be applied\n"," dataset_for_rep = custom_data_path +'/'+ input('Enter the filename (with extension) of the dataset in /UserData/ to indicate which models the replication data will be applied to: \\n')\n","\n"," return custom_data_path,custom_rep_data_path,class_label,instance_label,match_label,dataset_for_rep,applyToReplication,experiment_name"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"I4PLWbQsUZ0k"},"outputs":[],"source":["import os\n","\n","# Get current working directory\n","original_wd = os.getcwd()\n","\n","if not demo_run and use_data_prompt:\n"," # Run User Prompts\n"," data_path,rep_data_path,class_label,instance_label,match_label,dataset_for_rep,applyToReplication,experiment_name = run_prompts(demo_run,use_data_prompt,original_wd)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"BopjHVZnVEM3"},"outputs":[],"source":["# Leave this empty code cell"]},{"cell_type":"markdown","metadata":{"id":"sgqLm-qZhHc7"},"source":["# STREAMLINE RUN CODE\n"]},{"cell_type":"markdown","metadata":{"id":"42TpOz1eF1R9"},"source":["## Install STREAMLINE and Prerequisites\n","* Downloads most recent version of STREAMLINE from GitHub and installs other packages required by STREAMLINE."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":54993,"status":"ok","timestamp":1685752442772,"user":{"displayName":"ryan urbanowicz","userId":"09525282221743790591"},"user_tz":420},"id":"eJXUp8_yFrRn","outputId":"af912521-9b69-4627-dd3b-e2ce8acc2cc0"},"outputs":[{"output_type":"stream","name":"stdout","text":["/content/STREAMLINE\n"]}],"source":["!git clone -b main https://github.com/UrbsLab/STREAMLINE.git -q\n","#!git clone -b dev https://github.com/UrbsLab/STREAMLINE.git -q\n","\n","%cd STREAMLINE\n","\n","!pip install -r requirements.txt &> /dev/null\n","!pip install --upgrade scipy>=1.8.0"]},{"cell_type":"markdown","metadata":{"id":"8cbakQ8iF_kl"},"source":["## Notebook Housekeeping\n","* Sets up notebook cells to display internal process.\n","\n","* Use logging.INFO for higher level output, logging.WARNING for only critical information. Comment to hide all text output.\n","\n","* You can use run_parallel=True for phases other than modeling, but the advantage is not significant vs the overhead for small jobs."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"_0Y-6f2x85co"},"outputs":[],"source":["import logging\n","FORMAT = '%(levelname)s: %(message)s'\n","logging.basicConfig(format=FORMAT)\n","logger = logging.getLogger()\n","logger.setLevel(logging.INFO)"]},{"cell_type":"markdown","metadata":{"id":"FP4W9tfhRHmd"},"source":["* Housekeeping code allowing notebook to be run again with the same settings, overwriting a previously run experiment with the same name."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"nMK0OPphGHGZ"},"outputs":[],"source":["import os\n","import shutil\n","if os.path.exists(output_path+'/'+experiment_name):\n"," shutil.rmtree(output_path+'/'+experiment_name)"]},{"cell_type":"markdown","metadata":{"id":"wbkz75LgGD9r"},"source":["## STREAMLINE Workflow\n","* The code below runs through the analysis phases of STREAMLINE."]},{"cell_type":"markdown","metadata":{"id":"Q-k3iBM190S6"},"source":["## Phase 1: Data Processing Phase\n","After cell runs, for each target dataset you will see:\n","* A data count summary\n","* Class balance barplot\n","* Feature correlation heatmap\n","* Top univariate analysis results\n"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"executionInfo":{"elapsed":33185,"status":"ok","timestamp":1685752475955,"user":{"displayName":"ryan urbanowicz","userId":"09525282221743790591"},"user_tz":420},"id":"ofRidh1S9xgE","outputId":"1a445737-dfcd-45fb-bcf7-81402881af64"},"outputs":[{"output_type":"stream","name":"stderr","text":["INFO:numexpr.utils:NumExpr defaulting to 2 threads.\n","INFO:root:Loading Dataset: hcc-data_example_custom\n","INFO:root:Initial Data Counts: ----------------\n","INFO:root:Instance Count = 169\n","INFO:root:Feature Count = 61\n","INFO:root: Categorical = 29\n","INFO:root: Quantitative = 32\n","INFO:root:Missing Count = 1138\n","INFO:root: Missing Percent = 0.11038898050247356\n","INFO:root:Class Counts: ----------------\n","INFO:root:Class Count Information\n","INFO:root:\n"," Class Instances\n","0 0.0 104\n","1 1.0 63\n","INFO:root:Identifying Feature Types...\n","INFO:root:Ordinal encoding the following features:\n","INFO:root:\tSim_Text_Cat_2\n","INFO:root:\tSim_Text_Cat_3\n","INFO:root:\tSim_Text_Cat_4\n","INFO:root:Running Feature Engineering\n","INFO:root:Engineering the following Features for missingness:\n","INFO:root:\t miss_Sim_Miss_0.6\n","INFO:root:\t miss_Sim_Miss_0.7\n","INFO:root:Removing the following Features due to Missingness:\n","INFO:root:\tSim_Miss_0.6\n","INFO:root:\tSim_Miss_0.7\n","INFO:root:One-hot encoding the following features:\n","INFO:root:\tSim_Cat_3\n","INFO:root:\tSim_Cat_4\n","INFO:root:\tSim_Text_Cat_3\n","INFO:root:\tSim_Text_Cat_4\n","INFO:root:Top 10 Correlated Features\n","INFO:root:\n"," Removed_Feature Correlated_Feature Correlation\n","3519 Sim_Cor_-1.0_A Sim_Cor_-1.0_B -1.000000\n","3807 Sim_Cor_1.0_A Sim_Cor_1.0_B 1.000000\n","2449 Total Bilirubin(mg/dL) Direct Bilirubin (mg/dL) 0.978124\n","3159 Iron Oxygen Saturation (%) 0.782957\n","2513 Alanine transaminase (U/L) Aspartate transaminase (U/L) 0.727780\n","93 Alcohol Grams of Alcohol per day 0.712681\n","1146 Esophageal Varices Splenomegaly 0.629077\n","1147 Esophageal Varices Portal Hypertension 0.624371\n","1218 Splenomegaly Portal Hypertension 0.617743\n","4599 Sim_Text_Cat_3_Category 1 Sim_Text_Cat_3_Category 2 -0.567977\n","INFO:root:Removing the following Features due to high correlation:\n","INFO:root:Sim_Cor_-1.0_A\n","INFO:root:Sim_Cor_1.0_A\n","WARNING:root:Index(['Symptoms ', 'Alcohol', 'Hepatitis B Surface Antigen',\n"," 'Hepatitis B e Antigen', 'Hepatitis B Core Antibody',\n"," 'Hepatitis C Virus Antibody', 'Cirrhosis', 'Endemic Countries',\n"," 'Smoking', 'Diabetes', 'Obesity', 'Hemochromatosis',\n"," 'Arterial Hypertension', 'Chronic Renal Insufficiency',\n"," 'Human Immunodeficiency Virus', 'Nonalcoholic Steatohepatitis',\n"," 'Esophageal Varices', 'Splenomegaly', 'Portal Hypertension',\n"," 'Portal Vein Thrombosis', 'Liver Metastasis', 'Radiological Hallmark',\n"," 'Grams of Alcohol per day', 'Packs of cigarets per year',\n"," 'Performance Status*', 'Encephalopathy degree*', 'Ascites degree*',\n"," 'International Normalised Ratio*', 'Alpha-Fetoprotein (ng/mL)',\n"," 'Haemoglobin (g/dL)', 'Mean Corpuscular Volume', 'Leukocytes(G/L)',\n"," 'Platelets', 'Albumin (mg/dL)', 'Total Bilirubin(mg/dL)',\n"," 'Alanine transaminase (U/L)', 'Aspartate transaminase (U/L)',\n"," 'Gamma glutamyl transferase (U/L)', 'Alkaline phosphatase (U/L)',\n"," 'Total Proteins (g/dL)', 'Creatinine (mg/dL)', 'Number of Nodules',\n"," 'Major dimension of nodule (cm)', 'Direct Bilirubin (mg/dL)', 'Iron',\n"," 'Oxygen Saturation (%)', 'Ferritin (ng/mL)', 'Sim_Cat_2',\n"," 'Sim_Text_Cat_2', 'Sim_Cor_-1.0_A', 'Sim_Cor_-1.0_B', 'Sim_Cor_0.9_A',\n"," 'Sim_Cor_0.9_B', 'Sim_Cor_1.0_A', 'Sim_Cor_1.0_B', 'miss_Sim_Miss_0.6',\n"," 'miss_Sim_Miss_0.7', 'Sim_Cat_3_1', 'Sim_Cat_3_2', 'Sim_Cat_3_3',\n"," 'Sim_Cat_4_1', 'Sim_Cat_4_2', 'Sim_Cat_4_3', 'Sim_Cat_4_4',\n"," 'Sim_Text_Cat_3_Category 1', 'Sim_Text_Cat_3_Category 2',\n"," 'Sim_Text_Cat_3_Category 3', 'Sim_Text_Cat_4_Category 1',\n"," 'Sim_Text_Cat_4_Category 2', 'Sim_Text_Cat_4_Category 3',\n"," 'Sim_Text_Cat_4_Category 4'],\n"," dtype='object')\n","INFO:root:Running Basic Exploratory Analysis...\n","INFO:root:Processed Data Counts: ----------------\n","INFO:root:Instance Count = 165\n","INFO:root:Feature Count = 69\n","INFO:root: Categorical = 39\n","INFO:root: Quantitative = 30\n","INFO:root:Missing Count = 826\n","INFO:root: Missing Percent = 0.07255160298638559\n","INFO:root:Class Counts: ----------------\n","INFO:root:Class Count Information\n","INFO:root:\n"," Class Instances\n","0 0 102\n","1 1 63\n","INFO:root:Original Categorical Features: ['Alcohol', 'Hepatitis B Surface Antigen', 'Hepatitis B e Antigen', 'Hepatitis B Core Antibody', 'Hepatitis C Virus Antibody', 'Cirrhosis', 'Endemic Countries', 'Smoking', 'Diabetes', 'Obesity', 'Hemochromatosis', 'Arterial Hypertension', 'Chronic Renal Insufficiency', 'Human Immunodeficiency Virus', 'Nonalcoholic Steatohepatitis', 'Esophageal Varices', 'Splenomegaly', 'Portal Hypertension', 'Portal Vein Thrombosis', 'Liver Metastasis', 'Radiological Hallmark', 'Sim_Cat_2', 'Sim_Text_Cat_2']\n","INFO:root:Engineered Features: ['miss_Sim_Miss_0.6', 'miss_Sim_Miss_0.7']\n","INFO:root:One Hot Features: ['Sim_Cat_3_1', 'Sim_Cat_3_2', 'Sim_Cat_3_3', 'Sim_Cat_4_1', 'Sim_Cat_4_2', 'Sim_Cat_4_3', 'Sim_Cat_4_4', 'Sim_Text_Cat_3_Category 1', 'Sim_Text_Cat_3_Category 2', 'Sim_Text_Cat_3_Category 3', 'Sim_Text_Cat_4_Category 1', 'Sim_Text_Cat_4_Category 2', 'Sim_Text_Cat_4_Category 3', 'Sim_Text_Cat_4_Category 4']\n","INFO:root:Final List of Features:\n","INFO:root:['Symptoms ', 'Alcohol', 'Hepatitis B Surface Antigen', 'Hepatitis B e Antigen', 'Hepatitis B Core Antibody', 'Hepatitis C Virus Antibody', 'Cirrhosis', 'Endemic Countries', 'Smoking', 'Diabetes', 'Obesity', 'Hemochromatosis', 'Arterial Hypertension', 'Chronic Renal Insufficiency', 'Human Immunodeficiency Virus', 'Nonalcoholic Steatohepatitis', 'Esophageal Varices', 'Splenomegaly', 'Portal Hypertension', 'Portal Vein Thrombosis', 'Liver Metastasis', 'Radiological Hallmark', 'Grams of Alcohol per day', 'Packs of cigarets per year', 'Performance Status*', 'Encephalopathy degree*', 'Ascites degree*', 'International Normalised Ratio*', 'Alpha-Fetoprotein (ng/mL)', 'Haemoglobin (g/dL)', 'Mean Corpuscular Volume', 'Leukocytes(G/L)', 'Platelets', 'Albumin (mg/dL)', 'Total Bilirubin(mg/dL)', 'Alanine transaminase (U/L)', 'Aspartate transaminase (U/L)', 'Gamma glutamyl transferase (U/L)', 'Alkaline phosphatase (U/L)', 'Total Proteins (g/dL)', 'Creatinine (mg/dL)', 'Number of Nodules', 'Major dimension of nodule (cm)', 'Direct Bilirubin (mg/dL)', 'Iron', 'Oxygen Saturation (%)', 'Ferritin (ng/mL)', 'Sim_Cat_2', 'Sim_Text_Cat_2', 'Sim_Cor_-1.0_B', 'Sim_Cor_0.9_A', 'Sim_Cor_0.9_B', 'Sim_Cor_1.0_B', 'miss_Sim_Miss_0.6', 'miss_Sim_Miss_0.7', 'Sim_Cat_3_1', 'Sim_Cat_3_2', 'Sim_Cat_3_3', 'Sim_Cat_4_1', 'Sim_Cat_4_2', 'Sim_Cat_4_3', 'Sim_Cat_4_4', 'Sim_Text_Cat_3_Category 1', 'Sim_Text_Cat_3_Category 2', 'Sim_Text_Cat_3_Category 3', 'Sim_Text_Cat_4_Category 1', 'Sim_Text_Cat_4_Category 2', 'Sim_Text_Cat_4_Category 3', 'Sim_Text_Cat_4_Category 4']\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stderr","text":["INFO:root:Generating Feature Correlation Heatmap...\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"iVBORw0KGgoAAAANSUhEUgAACokAAAlnCAYAAABDXXxsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzde1zP9///8Xsnh1RSDjnMpOVtUnMYpaIcY2wOXzZmDtPmkGFolqGNMT5hM7FRMWaMj+NH+TjswzQfw2wYNh82bAihpBCV3r8//HpfvFcR4r212/VyeV8uvZ7Hx/P1fu/wx+PyeFoZjUajAAAAAAAAAAAAAAAAAAAAUKJYWzoAAAAAAAAAAAAAAAAAAAAAFD+SRAEAAAAAAAAAAAAAAAAAAEogkkQBAAAAAAAAAAAAAAAAAABKIJJEAQAAAAAAAAAAAAAAAAAASiCSRAEAAAAAAAAAAAAAAAAAAEogkkQBAAAAAAAAAAAAAAAAAABKIJJEAQAAAAAAAAAAAAAAAAAASiCSRAEAAAAAAAAAAAAAAAAAAEogkkQBAAAAAAAAAAAAAAAAAABKIJJEAQAAAAAAAAAAAAAAAAAASiCSRAEAAAAAAAAAAAAAAAAAAEogkkQBAAAAAAAAAAAAAAAAAABKIJJEAQAAAAAAAAAAAAAAAAAASiCSRAEAAAAAAAAAAAAAAAAAAEogkkQBAAAAAAAAAAAAAAAAAABKIJJEAQAAAAAAAAAAAAAAAAAASiCSRAEAAAAAAAAAAAAAAAAAAEogW0sHAFjS+vXr9fnnn+vkyZMyGo2qUqWKGjVqpFGjRsnV1dXS4ZmcOXNGa9eu1YsvvqgqVapYOhwAAAAAAAAAAAAAAAAAwF8ASaL424qNjdXMmTPVv39/DR8+XEajUb/88ovi4+N14cKFP1WSaFJSkubMmaPg4GCSRAEAAAAAAAAAAAAAAAAARUKSKP62lixZoq5duyoiIsLUFhQUpNdee025ubkWjAwAAAAAAAAAAAAAAAAAgIdnbekAAEtJT09X5cqVC+yztr79j8a0adMUHBycL2k0MTFRBoNBv/76qySpVatWmjRpkhYtWqSgoCA1bNhQERERysrK0pEjR9SzZ081aNBA3bt319GjR83WMhgMiomJUVRUlPz8/Exzr169Kknas2eP+vbtK0nq3r27DAaDDAaDaX5SUpKGDx+uxo0bq0GDBgoNDc23x8PEt2rVKnXs2FE+Pj7y9fVVr169dPDgwft93QAAAAAAAAAAAAAAAACAx8zKaDQaLR0EYAm9e/fWr7/+qvDwcAUHB6tSpUr5xhw/flzPPfec4uLi1Lx5c1P78OHDlZycrBUrVki6nYR569YteXp6qk+fPjp9+rSmTZumrl276sCBA+rfv78qVqyoGTNmKDs7W//+979NiagGg0GVK1eWl5eXevXqpTNnzmjGjBkKDg7WRx99pKtXr+pf//qXJk2apKlTp6p27dqSpAYNGujq1at64YUXZG1trTfffFOlS5fWp59+qtOnT2v9+vWqWrXqQ8W3d+9evfLKKxowYICCgoJ048YNHTx4UI0bN1ZAQMCj/ooAAAAAAAAAAAAAAAAAAA+B6+bxt/Xuu+/qjTfe0Pjx4yVJNWrUUMuWLdW/f3/VqFFDkuTh4aHGjRtr9erVpiTRy5cva9u2bYqMjMy35ieffKJSpUpJkr777jv985//VGxsrFq0aCFJys3N1eDBg3Xs2DHVrVvXNK9UqVKaO3eubGxsJEmlS5fW+PHj9cYbb8jDw0NPPfWUJMnT01Pe3t6meWvWrNHZs2e1YcMGeXh4SJKaNGmili1bavHixYqIiHio+A4ePChnZ2e9/fbbpjWCg4Mf5HUDAAAAAAAAAAAAAAAAAB4zrpvH31adOnWUkJCgmJgY9e3bV46OjlqyZIleeOEFHTlyxDTuxRdf1NatW5WWliZJio+Pl52dnZ577jmz9Zo0aWJKwJSkWrVqydraWn5+fmZtknTu3DmzuS1btjQliEpS+/btZTQadejQobue4fvvv5enp6cpQVSSnJ2d5e/vrx9++OGh46tXr57S0tIUERGhnTt3KjMz867xAAAAAAAAAAAAAAAAAAD+PEgSxd9aqVKlFBQUpHHjxmndunWKi4vTjRs3NHfuXNOY9u3bq0yZMlq/fr2k29U7Q0JC5ODgYLaWk5OT2bOdnZ3KlCljlphpZ2cnSbp586bZWFdXV7NnBwcHlS5dWhcuXLhr/Onp6apYsWK+dldXV125cuWh42vWrJmioqL0yy+/KDQ0VH5+fhozZowpYRYAAAAAAAAAAAAAAAAA8OdFkihwh+bNm6tu3bo6fvy4qa1MmTJ6/vnntWbNGv300086cuSIunfvXqz7pqSkmD1fvXpVN2/eVOXKle86r3z58vnm5q1Xvnz5Yomtc+fOWr16tb799luNHz9e//nPfxQVFVUsawMAAAAAAAAAAAAAAAAAHh2SRPG3denSpXxtN27c0Llz5/JV53zxxRd15MgRTZ06VbVq1dKzzz5brLF8/fXXunXrlul506ZNsrKykre3t6TCK5A2btxYx44d04kTJ0xtV65c0bfffqvGjRsXa4wuLi7q0aOHAgICzPYDAAAAAAAAAAAAAAAAAPw52Vo6AMBSnn/+ebVs2VKBgYGqXLmykpOT9cUXX+jy5cvq16+f2di6devK29tbe/fu1ejRo4s9lqysLA0dOlS9evXSmTNnNGPGDIWEhMjDw0OSVKtWLdnY2Gj16tWytbWVjY2NvL291a1bNy1atEiDBg3Sm2++qdKlS+vTTz+Vra1tvjM8iNmzZystLU1NmzaVq6urjh07ph07dqh///4PvTYAAAAAAAAAAAAAAAAA4NEiSRR/W2+88Ya+/vprTZs2TampqapQoYIMBoMWLVokPz+/fOPbtm2rn3/+WV26dCn2WPr06aPU1FSNGTNGWVlZatu2rSIjI039Li4uioyMVFxcnNavX6+cnBwdPXpUDg4OWrJkiaZNm6YJEyYoNzdXjRo10hdffKGqVas+dFze3t5avHixNm7cqKtXr8rNzU2hoaEaMmTIQ68NAAAAAAAAAAAAAAAAAHi0rIxGo9HSQQB/Bb1795ajo6PmzZtXrOsaDAaNGTNGoaGhxbouAAAAAAAAAAAAAAAAAODvjUqiwD0cOnRIP/zwg77//nt99tlnlg4HAAAAAAAAAAAAAAAAAIAiIUkUuIfu3bvL0dFRYWFh8vf3t3Q4AAAAAAAAAAAAAAAAAAAUCdfNAwAAAAAAAAAAAAAAAAAAlEDWlg4AAAAAAAAAAAAAAAAAAAAAxY8kUQAAAAAAAAAAAAAAAAAAgBKIJFEAAAAAAAAAAAAAAAAAAIASiCRRAAAAAAAAAAAAAAAAAACAEogkUQAAAAAAAAAAAAAAAAAAgBKIJFEAAAAAAAAAAAAAAAAAAIASyNbSAQD4e7tx/ZrF9i5jX85iewMAAAAAAAAAAAAAAADAo0YlUQAAAAAAAAAAAAAAAAAAgBKIJFEAAAAAAAAAAAAAAAAAAIASiCRRAAAAAAAAAAAAAAAAAACAEogkUQAAAAAAAAAAAAAAAAAAgBKIJFEAAAAAAAAAAAAAAAAAAIASiCRRAAAAAAAAAAAAAAAAAACAEogkUQAAAAAAAAAAAAAAAAAAgBKIJFHAwl544QUZDAZ9//33Zu179uyRwWDQoUOHinW/M2fOyGAwaNOmTX+qtQAAAAAAAAAAAAAAAAAAxYskUcCCfvnlFx09elSSFB8fb+FoAAAAAAAAAAAAAAAAAAAlCUmigAXFx8fL2tpavr6+2rRpk7Kzsy0dEgAAAAAAAAAAAAAAAACghCBJFLAQo9GohIQE+fn56dVXX1VaWpp27Nhx1zm5ubn67LPP1KFDB9WvX18BAQEaPny4MjIyTGP27t2rnj17ysfHR76+vho7dqzS0tLyrXXz5k1NmjRJTZo0UWBgoP7xj38oJyfHbExR1wIAAAAAAAAAAAAAAAAA/PmQJApYyL59+5SUlKROnTopMDBQzs7OSkhIuOuc999/X9OnT1dwcLDmzZunyMhIlStXTtevX5ckHT58WK+++qrKlSunjz/+WOHh4fr666/1+uuv69atW2ZrzZo1S9bW1po1a5Z69uyphQsXauXKlab++1kLAAAAAAAAAAAAAAAAAPDnY2vpAIC/q4SEBJUuXVrt2rWTnZ2dQkJCtH79el27dk3lypXLN/7kyZP68ssvNXLkSA0aNMjUHhISYvp73rx5qlSpkubNmyc7OztJUtWqVRUaGqrExES1atXKNNbHx0fjx4+XJAUEBGjPnj3avHmzevXqdd9rAQAAAAAAAAAAAAAAAAD+fKgkClhATk6ONm3apKCgIDk6OkqSnn/+eWVmZuqrr74qcM7u3btlNBrVvXv3Qtf9/vvv1bp1a1NSpyQFBgbKyclJP/zwg9nYwMBAs2cPDw+dP3/+gdYCAAAAAAAAAAAAAAAAAPz5kCQKWMDOnTuVmpqqli1bKj09Xenp6apTp44qVapU6JXzaWlpsrW1laura6HrpqenF9jv6uqqK1eumLXlJafmsbOzU1ZW1gOtBQAAAAAAAAAAAAAAAAD48+G6ecAC4uPjJUljx47V2LFjzfouX76slJSUfHOcnZ2Vk5OjlJSUQhNFy5cvX+DclJQUlS9f/r5iLM61AAAAAAAAAAAAAAAAAACPH5VEgccsMzNTW7duVZs2bfT555+bfT788EPl5OTo3//+d755fn5+srKy0urVqwtdu3Hjxtq6datycnJMbTt37lR6eroaN258X3EW51oAAAAAAAAAAAAAAAAAgMePSqLAY7Z161Zdv35dffr0ka+vb77+uLg4JSQkaNSoUWbt7u7u6tmzpz7++GNduXJFzZo1040bN7R9+3YNGzZMVapU0eDBg9WzZ08NGjRIffr00aVLlzRz5kz5+PgoKCjovuIszrUAAAAAAAAAAAAAAAAAAI8fSaLAY5aQkKBq1aoVmCAqSV26dNEHH3ygU6dO5euLjIxUjRo1tHLlSi1evFjOzs5q0qSJypUrJ0mqX7++Fi5cqA8//FDDhg2Tvb29WrVqpbfffls2Njb3FWdxrgUAAAAAAAAAAAAAAAAAePysjEaj0dJBAPj7unH9msX2LmNfzmJ7AwAAAAAAAAAAAAAAAMCjZm3pAAAAAAAAAAAAAAAAAAAAAFD8SBIFAAAAAAAAAAAAAAAAAAAogUgSBQAAAAAAAAAAAAAAAAAAKIFIEgUAAAAAAAAAAAAAAAAAACiBSBIFAAAAAAAAAAAAAAAAAAAogUgSBQAAAAAAAAAAAAAAAAAAKIFIEgUAAAAAAAAAAAAAAAAAACiBSBIFAAAAAAAAAAAAAAAAAAAogUgSBQAAAAAAAAAAAAAAAAAAKIFIEgUAAAAAAAAAAAAAAAAAACiBbC0dAIC/tws3jBbbu2rGSYvtbVfF3WJ7AwAAAAAAAAAAAAAAAPh7oJIoAAAAAAAAAAAAAAAAAABACUSSKAAAAAAAAAAAAAAAAAAAQAlEkigAAAAAAAAAAAAAAAAAAEAJRJIoAAAAAAAAAAAAAAAAAABACUSSKAAAAAAAAAAAAAAAAAAA+Nv6/fffFRkZqc6dO6tevXrq1KlTkeYZjUbFxMQoODhYPj4+eumll3TgwIF845KTkzVs2DA1bNhQTZs21bhx43T16tViPkXBSBIFAAAAAAAAAAAAAAAAAAB/W7/88osSExP15JNPysPDo8jzYmNjNXv2bPXv31/z589XpUqVNGDAAJ0+fdo0Jjs7W6+99pp+++03zZw5U++9957++9//avTo0Y/iKPnYPpZdAAAAAAAAAAAAAAAAAAAA/oRatWqlNm3aSJIiIiJ0+PDhe865efOm5s+frwEDBqh///6SpMaNG6t9+/ZasGCB3nvvPUnS5s2b9csvv+jf//63ateuLUlycnJSaGioDh48KB8fn0dypjxUEv3/oqOj1bBhw/vue1z27NmjefPm5Wv/Y2xnzpxRdHS0kpOT8803GAw6dOjQQ8VhMBjMPv7+/ho8eLCOHj16z7k5OTlasmSJXnjhBTVs2FBNmjTRCy+8oEmTJikrK+uh4rpTWlqahg4dqiZNmshgMOg///lPsa1dHCZPniyDwaC5c+c+8BpHjhxRdHS0MjMzzdrXrFkjg8Gg1NTUhw0TAAAAAAAAAAAAAAAAAP4WrK3vP5Vy3759unr1qjp06GBqK1WqlNq2batvvvnG1PbNN9/IYDCYEkQlKSAgQM7OzkpMTHy4wIuAJNG/iO+++07z58/P196jRw8tXrzY9JyUlKQ5c+bowoULZuO8vLy0YsWK+yqFW5g+ffpoxYoVWr58uSZMmKDz588rNDRU6enpd503efJkTZ8+Xe3atdPcuXM1bdo0tWvXTv/9739148aNh44rz2effaY9e/Zo2rRpWrFihZo0aVJsaz+sW7duaePGjZKkhISEB17nyJEjmjNnTr4k0eDgYK1YsUJOTk4PFScAAAAAAAAAAAAAAAAAoHAnTpyQJLPkT0ny8PDQ2bNnTTlxJ06cyDfGyspK7u7upjUeJa6b/4tzc3OTm5vbPcc5ODioQYMGxbJn1apVzdZyd3dX586dtX//fgUFBRU4JzMzU6tWrdLgwYP1xhtvmNpbt26tN954Q0aj8aHjunHjhsqUKaOTJ0/KYDCodevWD71mcdu1a5cuXbokf39/ffvtt/rpp5/k5eVVbOu7uLjIxcWl2NYDAAAAAAAAAAAAAAAAgL+Ce+WLbd26tVj3S09PV6lSpVS6dGmzdicnJxmNRl25ckVlypRRenq6HB0d880vX768rly5UqwxFYQk0QeUlZWlOXPmKD4+XhcvXtQTTzyhsLAwPf/886YxEREROnz4sN566y1Nnz5dv//+uzw9PRUZGWmWZLlu3TqtWLFCx48fl9FoVN26dfXWW2/Jx8dH0u0r5efMmSPp9nXvktS0aVMtWbJE0dHRWrhwofbv3689e/aob9++kqTu3bub1j969Kipb9WqVfL29pYkrVq1Sp999plOnz6tsmXLqnbt2ho7dqxp36IqV66cJCk7O7vQMZmZmcrOzlblypUL7LeyspIknTlzRq1bt9bHH3+s9u3bm/qnTJmirVu3atu2bZJuX6s+duxYLV++XLNnz9b+/fvVrVs3LV261DQn710dPXpU+/fv1/z583X48GFdvXpVTz75pF599VV16dLFLI709HR9/PHH+uqrr5SamqrKlSurY8eOGj16tGnM9u3bNXfuXB09elT29vYKCQnR22+/LXt7+3u+q4SEBJUrV07Tpk1T69atFR8fny9J1GAwKDw8XDdu3NCXX36pW7duqVWrVpowYYLs7e1NZ5ekZs2aSZKqV6+ubdu2mfp27dplShY9f/683n33Xe3evVvOzs569dVXlZSUZPY+88bNmDFDO3bsUGZmpry9vTV27FjVr1/fNKZVq1YKDg6Wh4eH4uLilJ6eLl9fX02ePJnkVAAAAAAAAAAAAAAAAPwtlWo4wNIhQFJz0pcKRJLoH+Tk5ORry83Nzdc2YsQI7du3T0OHDpWHh4cSExP11ltvycnJyaya5sWLFzVx4kQNGzZMTk5Oio2NVWhoqLZs2SJXV1dJtxMju3Tpopo1ayorK0sbNmxQ7969tX79erm7u6tHjx46f/68EhISTFfLOzg45IvJy8tLkZGRmjRpkqZOnZqvRO2d9u7dq3HjxmnAgAEKCgrSjRs3dPDgQWVkZNzzHeXm5ionJ0dGo1HJycmaPn26KlSoIF9f30LnuLi4qFq1avr0009Vrlw5BQYGqnz58vfc615Gjx6tl156SYMGDVLZsmX1wgsvaMaMGbp27Zreffdd07izZ8+qUaNG6tWrl0qVKqV9+/Zp/PjxMhqN6tq1q6Tbib/9+vVTUlKShg4dqjp16uj8+fP64YcfTOts2rRJI0eOVLdu3TRs2DBdvHhRM2fOVHp6uj766KO7xnrz5k1t2bJFbdu2VZUqVRQYGKgNGzZozJgxsra2Nhu7dOlSNW7cWNOmTdNvv/2mqKgoubq6Kjw8XMHBwRoyZIg+/fRTxcXFydHRUaVKlSpwT6PRqLCwMF26dEkTJ06Uo6OjFixYoLNnz5rteeXKFb388suyt7fXhAkT5OjoqCVLlqhfv35mv1VJ2rZtm37//XdFRkbq8uXLmjp1qt5///17nh8AAAAAAAAAAAAAAAAAHpXirhR6L05OTsrKytLNmzfNqommp6fLysrKlB/n5OSkq1ev5pt/5coVVa1a9ZHHSZLoHa5fv17o1d93VoncvXu3tm3bpgULFigwMFCSFBAQoIsXLyo6OtosSTQtLU2zZs0yVXxs2rSpgoKCtGjRIlN1yjuvX8/NzVVAQIAOHjyotWvXatSoUaYr5a2tre96ZbyDg4OeeuopSZKnp6epYmhBDh48KGdnZ7399tumtuDg4ELH32nGjBmaMWOG6dnZ2Vlz5swpsCTunaZNm6ZRo0Zp1KhRsrKyUu3atdW6dWu9+uqrD1yFsmfPnho4cKBZm5OTk6ysrMzeVceOHU1/G41GNWnSRMnJyVqxYoUpSXTdunX6+eeftXz5cjVs2NA0Pq/faDQqKipKzz33nKZMmWLqr1SpkgYOHKiwsDB5enoWGuu2bdt07do1derUSZL0/PPP6+uvv9aePXtMv48715w5c6YkqUWLFvr555+1efNmhYeHy8XFRTVr1pR0OzH4bu/um2++0U8//aSlS5fq2WeflST5+fkpKChITk5OpnGLFy9Wenq6Vq5caUoIbdasmUJCQrRgwQKNGTPG7P19+umnpsTUpKQkzZ8/X7m5ufmSXQEAAAAAAAAAAAAAAACgJMor4njy5EnVrVvX1H7ixAlVq1ZNZcqUMY07duyY2Vyj0aiTJ08qICDgkcdJkugdypQpoy+++CJf+z//+U8lJCSYnnfu3ClnZ2f5+fmZVR719/fXe++9p1u3bsnGxkaS5OjoaJYA6OjoKH9/f/3444+mtuPHj+vDDz/U/v37lZKSYmr/7bffivN4ZurVq6e0tDRFRETo+eefV6NGjVS2bNkize3bt69eeOEFSVJqaqqWLVumsLAwLVmyxOzH/ke+vr766quv9M0332jXrl3avXu3YmJitGbNGq1Zs0ZVqlS573MUNbH1ypUrio6O1tatW5WcnKxbt25Jup3gmmfXrl3y8PAwSxC908mTJ5WUlKR33nnH7Htv2rSprK2tdfjw4bsmiSYkJMjV1VX+/v6Sbl/dbm9vr/j4+HxJonlj8nh4eGjDhg1FOuudDh06JCcnJ1OCqCSVK1dOzZo1008//WRq27lzp3x9fVW+fHnT2aytrdWkSRMdOnTIbM0mTZqYVS718PBQdna2UlJSVKlSpfuOEQAAAAAAAAAAAAAAAAD+aho1aiQHBwdt3LjRlDeXnZ2tLVu2qEWLFqZxLVq00Pr16/Xbb7+pVq1akm7nqqWlpZkVpHxUSBK9g7W1dYHVN7dv3272fPnyZaWlpRVadfTixYtyc3OTpAKrPLq6uur48eOSpKtXr2rAgAFycXFRRESEqlWrptKlS2v8+PG6efPmQ56ocM2aNVNUVJQ+//xzhYaGqnTp0goJCdE777xjljhZEDc3N7P31KxZM7Vo0UKffPKJZs+efde59vb2at++vdq3by9JWrlypcaPH6+FCxdq7Nix932OihUrFmlcRESE9u/fr6FDh+qpp56Sg4ODvvzyS23cuNE0Ji0tTZUrVy50jcuXL0uShg4dWmD/uXPnCp2bnp6uxMREde7cWdeuXTO1N2/eXF999ZXee+89s8TLO6t8SpKdnZ2ysrLufsgCXLhwocDf4B/bLl++rAMHDhT4m86rWlpYbHlxP8rfKwAAAAAAAAAAAAAAAAA8KpmZmUpMTJR0+2blq1evatOmTZJuFxF0cXFRv379dPbsWX311VeSpNKlS2vQoEGKjo6Wi4uL6tSpoy+//FJpaWkKDQ01rR0SEqL58+dr2LBhGjVqlDIzMxUVFaXg4GD5+Pg88rORJPoAypcvLxcXF8XExBTYf2cCXmpqar7+OysuHjhwQOfPn9f8+fPNqnBmZGSYEk0flc6dO6tz585KTU3V1q1bNXXqVNna2uqDDz64r3VKlSqlJ554Qr/88st9x9CjRw/NmDHDlDRbunRpSbczqu+Unp5+32vnuXnzprZv366IiAj16dPH1L5s2TKzcc7Ozjp69Gih6+Qlz0ZGRhb4D+fdEkw3b96s7OxsrVq1SqtWrcrXv337drVr1+5eR7lvlStXLvA3+Me28uXLq3nz5hoxYkS+sXcmrwIAAAAAAAAAAAAAAABASZOSkpIvdyrv+fPPP5evr69yc3NNN1jnef3112U0GrVw4UKlpqbq6aef1oIFC/TEE0+YxtjZ2SkuLk6TJ0/WqFGjZGtrq7Zt2+qdd9559AcTSaIPxN/fX3FxcbKzs7vr9erS7WTPXbt2ma4Tz8jI0LfffqvevXtLkm7cuCHp9g8hz759+5SUlGR2dXlRK0nmrXM/VR1dXFzUo0cPffPNNzpx4kSR5+W5efOmTp06JQ8Pj0LHZGdn6/r16ypfvrxZe0pKijIyMkxJs66urrKzszMljUpSVlaW9u7de99x3Tk/NzfX7B1fvXpV27ZtMxvn7++vf//73/rxxx/1zDPP5Fundu3acnNz0+nTp03fX1HFx8erevXqmjp1ar6+UaNGKT4+/r6SRPPOcq/fhLe3t9LT07V37141adJEknTt2jXt2rXLrCKov7+/1q9fLw8PD9nb2xc5DgAAAAAAAAAAAAAAAAD4q6tRo8ZdCwxK0pIlS/K1WVlZadCgQRo0aNBd51apUkXR0dEPFeODIkn0AQQEBKhly5Z67bXX9Nprr8lgMCgzM1O//vqrfv/9d02ZMsU01tnZWePGjdPw4cPl6Oio2NhYGY1G9evXT5LUoEED2dvba+LEiRo4cKCSk5MVHR2tKlWqmO3p4eGhnJwcLV68WA0bNpSDg4Nq166dL7ZatWrJxsZGq1evlq2trWxsbMyuhs8ze/ZspaWlqWnTpnJ1ddWxY8e0Y8cO9e/f/57nP3funA4cOCDpdkXKpUuXKi0tTT179ix0TkZGhkJCQtS5c2f5+fmpfPnyOnPmjBYuXChra2v16tVLkmRtba22bdtq6dKlevLJJ1WhQgV98cUXMhqNsrKyumdsBXF0dJS3t7diY2Pl4uIiW1tbxcTEyMHBwayiZufOnbVs2TINHDhQb7zxhjw9PZWcnKzvv/9e77//vqysrBQREaHw8HBdv35dwcHBKlu2rM6ePavExESNHDlS7u7u+fZPTk7W3r17NWTIEPn6+ubr79Spk5YtW6aMjAw5OjoW6Ux5CblLly5VmzZtVKZMGRkMhnzjWrRoIS8vL40ePVqjRo2Sk5OT4uLiVK5cObP32b9/f8XHx+uVV15R3759Va1aNaWmpurHH39UlSpVivS7AAAAAAAAAAAAAAAAAP6OrKxtLB0CUCiSRB/Q7NmzFRMToy+//FJJSUlydHSUp6enunXrZjauUqVKCg8PV1RUlE6dOiVPT08tWLBAFStWlCRVrFhRH3/8saKiohQWFqZatWpp4sSJiouLM1unZcuWevnllxUTE6OUlBQ1adKkwMxkFxcXRUZGKi4uTuvXr1dOTk6BGc7e3t5avHixNm7cqKtXr8rNzU2hoaEaMmTIPc++ZMkS095OTk7y8PDQ3Llz1aZNm0LnODg46PXXX9eOHTu0adMmXblyRRUrVpS3t7emTZsmLy8v09gJEyZowoQJmjx5ssqVK6fQ0FC5u7tr69at94ytMDNnzlRkZKQiIiLk7OysPn366Pr161q4cKFpTKlSpbRo0SJ99NFHmj9/vtLS0uTm5qaOHTuaxnTo0EFOTk6aN2+e4uPjJUnVq1dX8+bNTd/pH23YsEG5ubnq0qVLgf1du3bVokWLtHnzZnXv3r1I56lXr56GDRumlStXKi4uTlWrVs1XGVW6nan+ySefKDIyUpGRkXJyclLfvn118uRJHTlyxDSuQoUKWrFihWbNmqUZM2YoLS1Nrq6ueuaZZ9S2bdsixQQAAAAAAAAAAAAAAAAA+HOxMhqNRksHUVJFRETo8OHDSkhIsHQogElWVpY6duyoZ599VlOnTrV0ODqVetVie1fNvmixve2q5K86CwAAAAAAAAAAAAAAgL+e0o1ft3QIkHTzh1hLh/CnRCVRoIRbsWKFcnNz5e7urvT0dFP12w8//NDSoQEAAAAAAAAAAAAAAAAAHiGSRIESrnTp0oqJiVFSUpIkqW7dupo/f768vb0tHBkAAAAAAAAAAAAAAAAA4FHiunkAFsV18wAAAAAAAAAAAAAAAPgr47r5Pweumy+YtaUDAAAAAAAAAAAAAAAAAAAAQPEjSRQAAAAAAAAAAAAAAAAAAKAEsrV0AAAAAAAAAAAAAAAAAAAA/FVZWdtYOgSgUFQSBQAAAAAAAAAAAAAAAAAAKIFIEgUAAAAAAAAAAAAAAAAAACiBSBIFAAAAAAAAAAAAAAAAAAAogWwtHQCAv7eytpbLVc+wq2KxvQ8dv2SRfYM8KlpkXwAAAAAAAAAAAAAAAACPH5VEAQAAAAAAAAAAAAAAAAAASiCSRAEAAAAAAAAAAAAAAAAAAEogkkQBAAAAAAAAAAAAAAAAAABKIFtLBwAAAAAAAAAAAAAAAAAAwF+VlbWNpUMACkUlUQAAAAAAAAAAAAAAAAAAgBKIJFEAAAAAAAAAAAAAAAAAAIASiCRRAAAAAAAAAAAAAAAAAACAEogk0RIkOjpaDRs2vO++x2XPnj2aN29evvY/xnbmzBlFR0crOTk533yDwaBDhw49VBwGg8Hs4+/vr8GDB+vo0aMPtW5RTZ48WQaDQXPnzn3gNY4cOaLo6GhlZmaata9Zs0YGg0GpqakPGyYAAAAAAAAAAAAAAAAA4C+OJFE8Nt99953mz5+fr71Hjx5avHix6TkpKUlz5szRhQsXzMZ5eXlpxYoV8vDweOhY+vTpoxUrVmj58uWaMGGCzp8/r9DQUKWnpz/02ndz69Ytbdy4UZKUkJDwwOscOXJEc+bMyZckGhwcrBUrVsjJyemh4gQAAAAAAAAAAAAAAAAA/PXZWjoAwM3NTW5ubvcc5+DgoAYNGhTLnlWrVjVby93dXZ07d9b+/fsVFBRULHsUZNeuXbp06ZL8/f317bff6qeffpKXl1exre/i4iIXF5diWw8AAAAAAAAAAAAAAAAA8NdFJdG/saysLH344Ydq2bKl6tevrw4dOig+Pt5sTEREhDp16qTExER16tRJ3t7e6tatmw4cOGA2bt26derVq5eaNm2qJk2aqE+fPjp48KCpPzo6WnPmzNH169dN17z36dPH1Jd33fyePXvUt29fSVL37t1NY/P6/njd/KpVq9SxY0f5+PjI19dXvXr1Mtu3qMqVKydJys7OvufY7du3q0ePHvLx8ZGfn5/effddXb9+vUj7JCQkqFy5cpo2bZrs7OzyvW9JMhgMio2NVXR0tPz9/eXr66uxY8ea9lizZo3Gjh0rSWrWrJkMBoNatWpl6vvjdfPnz5/XoEGD9MwzzygoKEiLFi3SlClTTHPuHBceHi5fX1/5+Piod+/eOnz4sNmYVq1aadKkSVq6dKlatmypxo0bKywsjOvtAQAAAAAAAAAAAAAA8LdlZW3D50/wQcGoJFoC5eTk5GvLzc3N1zZixAjt27dPQ4cOlYeHhxITE/XWW2/JycnJrJrmxYsXNXHiRA0bNkxOTk6KjY1VaGiotmzZIldXV0nSmTNn1KVLF9WsWVNZWVnasGGDevfurfXr18vd3V09evTQ+fPnlZCQYLpa3sHBIV9MXl5eioyM1KRJkzR16lTVrl270HPu3btX48aN04ABAxQUFKQbN27o4MGDysjIuOc7ys3NVU5OjoxGo5KTkzV9+nRVqFBBvr6+d523adMmjRw5Ut26ddOwYcN08eJFzZw5U+np6froo4/uOvfmzZvasmWL2rZtqypVqigwMFAbNmzQmDFjZG1tnq+9dOlSNW7cWNOmTdNvv/2mqKgoubq6Kjw8XMHBwRoyZIg+/fRTxcXFydHRUaVKlSpwT6PRqLCwMF26dEkTJ06Uo6OjFixYoLNnz5rteeXKFb388suyt7fXhAkT5OjoqCVLlqhfv35m37Mkbdu2Tb///rsiIyN1+fJlTZ06Ve+///49zw8AAAAAAAAAAAAAAAAAeLxIEi1hrl+/Xuj15fb29qa/d+/erW3btmnBggUKDAyUJAUEBOjixYuKjo42SxJNS0vTrFmz1KxZM0lS06ZNTRUpR48eLUl64403TONzc3MVEBCggwcPau3atRo1apTpSnlra+u7Xhnv4OCgp556SpLk6ekpb2/vQscePHhQzs7Oevvtt01twcHBhY6/04wZMzRjxgzTs7Ozs+bMmSNHR8dC5xiNRkVFRem5557TlClTTO2VKlXSwIEDFRYWJk9Pz0Lnb9u2TdeuXVOnTp0kSc8//7y+/vpr7dmzx/Ru71xz5syZkqQWLVro559/1ubNmxUeHi4XFxfVrFlT0u2k2rtdL//NN9/op59+0tKlS/Xss89Kkvz8/BQUFCQnJyfTuMWLFys9PV0rV640JYQ2a9ZMISEhWrBggcaMGWP2Hj799FNTYmpSUpLmz5+v3NzcfMmuAAAAAAAAAAAAAAAAAADLIaOrhClTpoxWrVqV7/Piiy+ajdu5c6ecnZ3l5+ennJwc08ff319HjhzRrVu3TGMdHR3NkhgdHR3l7++vH3/80dR2/PhxDR06VP7+/nr66afl5eWlkydP6rfffntkZ61Xr57S0tIUERGhnTt3KjMzs8hz+/bta3o3MTExatCggcLCwvS///2v0DknT55UUlKSOnToYPbOmjZtKmtr63xXs/9RQkKCXF1d5e/vL+n21e329vYFXjmfNyaPh4eHzp8/X+Tz5Tl06JCcnJxMCaKSVK5cuXxJqTt37pSvr6/Kly9vOpe1tbWaNGmiQ4cOmY1t0qSJWeVSDw8PZWdnKyUl5b7jAwAAAAAAAAAAAAAAAAA8OlQSLWGsra0LrL65fft2s+fLly8rLS2t0KqjFy9elJubmyQVWKnS1dVVx48flyRdvXpVAwYMkIuLiyIiIlStWjWVLl1a48eP182bNx/yRIVr1qyZoqKi9Pnnnys0NFSlS5dWSEiI3nnnHTk7O991rpubm9l7atasmVq0aKFPPvlEs2fPLnDO5cuXJUlDhw4tsP/cuXOF7peenq7ExER17txZ165dM7U3b95cX331ld577z2zxMs7q3xKkp2dnbKysu56poJcuHChwO/vj22XL1/WgQMHCvw95FUtLSy2vLgf5XcNAAAAAAAAAAAAAAAAALh/JIn+TZUvX14uLi6KiYkpsP/OJMLU1NR8/SkpKapUqZIk6cCBAzp//rzmz5+vunXrmsZkZGSYEk0flc6dO6tz585KTU3V1q1bNXXqVNna2uqDDz64r3VKlSqlJ554Qr/88kuhY/ISTyMjI+Xj45Ovv3LlyoXO3bx5s7Kzs03VS/9o+/btateu3X3FXBSVK1cu8Pv7Y1v58uXVvHlzjRgxIt/YO5NXAQAAAAAAAAAAAAAAAAB/HSSJ/k35+/srLi5OdnZ2ZomdBcnIyNCuXbtMV5RnZGTo22+/Ve/evSVJN27ckHS72mWeffv2KSkpSZ6enqa2olbDzFvnfipTuri4qEePHvrmm2904sSJIs/Lc/PmTZ06dUoeHh6Fjqldu7bc3Nx0+vRp09mLKj4+XtWrV9fUqVPz9Y0aNUrx8fH3lSSa947u9T69vb2Vnp6uvXv3qkmTJpKka9euadeuXWYVQf39/bV+/Xp5eHjI3t6+yHEAAAAAAAAAAAAAAAAAAP68SBL9mwoICFDLli312muv6bXXXpPBYFBmZqZ+/fVX/f7775oyZYpprLOzs8aNG6fhw4fL0dFRsbGxMhqN6tevnySpQYMGsre318SJEzVw4EAlJycrOjpaVapUMdvTw8NDOTk5Wrx4sRo2bCgHBwfVrl07X2y1atWSjY2NVq9eLVtbW9nY2JhdDZ9n9uzZSktLU9OmTeXq6qpjx45px44d6t+//z3Pf+7cOR04cEDS7aqaS5cuVVpamnr27FnoHCsrK0VERCg8PFzXr19XcHCwypYtq7NnzyoxMVEjR46Uu7t7vnnJycnau3evhgwZIl9f33z9nTp10rJly5SRkSFHR8d7xi7JlMy6dOlStWnTRmXKlJHBYMg3rkWLFvLy8tLo0aM1atQoOTk5KS4uTuXKlZOVlZVpXP/+/RUfH69XXnlFffv2VbVq1ZSamqoff/xRVapUKdI7BQAAAAAAAAAAAAAAAAD8uZAk+jc2e/ZsxcTE6Msvv1RSUpIcHR3l6empbt26mY2rVKmSwsPDFRUVpVOnTsnT01MLFixQxYoVJUkVK1bUxx9/rKioKIWFhalWrVqaOHGi4uLizNZp2bKlXn75ZcXExCglJUVNmjTRkiVL8sXl4uKiyMhIxcXFaf369crJydHRo0fzjfP29tbixYu1ceNGXb16VW5ubgoNDdWQIUPuefYlS5aY9nZycpKHh4fmzp2rNm3a3HVehw4d5OTkpHnz5ik+Pl6SVL16dTVv3tz0Pv5ow4YNys3NVZcuXQrs79q1qxYtWqTNmzere/fu94xdkurVq6dhw4Zp5cqViouLU9WqVbVt27Z846ysrPTJJ58oMjJSkZGRcnJyUt++fXXy5EkdOXLENK5ChQpasWKFZs2apRkzZigtLU2urq565pln1LZt2yLFBAAAAAAAAAAAAAAAAPwdWdnYWDoEoFBWRqPRaOkg8OcVERGhw4cPKyEhwdKhoJhkZWWpY8eOevbZZzV16lRLh6OL6dcttreN1b3HPCqHLljm3EEeBSczAwAAAAAAAAAAAAAA4MGUCxxp6RAg6dp/P7J0CH9KVBIFSrgVK1YoNzdX7u7uSk9PN1WO/fDDDy0dGgAAAAAAAAAAAAAAAADgESJJFCjhSpcurZiYGCUlJUmS6tatq/nz58vb29vCkQEAAAAAAAAAAAAAAAAAHiWumwdgUVw3/3hx3TwAAAAAAAAAAAAAAEDx4rr5Pweumy+YtaUDAAAAAAAAAAAAAAAAAAAAQPEjSRQAAAAAAAAAAAAAAAAAAKAEIkkUAAAAAAAAAAAAAAAAAACgBLK1dAAAAAAAAAAAAAAAAAAAAPxVWVvbWDoEoFBUEgUAAAAAAAAAAAAAAAAAACiBSBIFAAAAAAAAAAAAAAAAAAAogUgSBQAAAAAAAAAAAAAAAAAAKIFsLR0AgL+3q1m3LLb3E9nnLbb3hp+zLLJvNcfSFtlXkjwrO1psbwAAAAAAAAAAAAAAAODviEqiAAAAAAAAAAAAAAAAAAAAJRBJogAAAAAAAAAAAAAAAAAAACUQ180DAAAAAAAAAAAAAAAAAPCArKxtLB0CUCgqiQIAAAAAAAAAAAAAAAAAAJRAJIkCAAAAAAAAAAAAAAAAAACUQCSJAgAAAAAAAAAAAAAAAAAAlEAkiQIAAAAAAAAAAAAAAAAAAJRAJIk+pOjoaDVs2PC++x6XPXv2aN68efna/xjbmTNnFB0dreTk5HzzDQaDDh069FBxGAwGs4+/v78GDx6so0ePFmm+0WjU2rVr9fLLL6tx48aqX7++QkJCNG3atHwxW9LkyZNlMBg0d+7cB17jyJEjio6OVmZmpln7mjVrZDAYlJqaKun2d2YwGLRp06aHivluFi1aJIPB8MjWBwAAAAAAAAAAAAAAAAA8OiSJlnDfffed5s+fn6+9R48eWrx4sek5KSlJc+bM0YULF8zGeXl5acWKFfLw8HjoWPr06aMVK1Zo+fLlmjBhgs6fP6/Q0FClp6ffdZ7RaNTo0aP1zjvvyN3dXdOnT9fChQvVr18/ffvtt5o0adJDx1Ycbt26pY0bN0qSEhISHnidI0eOaM6cOfmSRIODg7VixQo5OTk9VJwAAAAAAAAAAAAAAAAAgL8HW0sHAMtwc3OTm5vbPcc5ODioQYMGxbJn1apVzdZyd3dX586dtX//fgUFBRU6b9myZdqwYYOmTJmi7t27m9qbNm2ql156Sf/9738fKq5bt24pNzdXdnZ2D7XOrl27dOnSJfn7++vbb7/VTz/9JC8vr4da804uLi5ycXEptvUAAAAAAAAAAAAAAAAAACUblUQfs6ysLH344Ydq2bKl6tevrw4dOig+Pt5sTEREhDp16qTExER16tRJ3t7e6tatmw4cOGA2bt26derVq5eaNm2qJk2aqE+fPjp48KCpPzo6WnPmzNH169dN17z36dPH1Jd33fyePXvUt29fSVL37t1NY/P6/njd/KpVq9SxY0f5+PjI19dXvXr1Mtu3qMqVKydJys7Ovuu4zz77TF5eXmYJonlsbGzMEkzT0tI0duxY+fr6ysfHRz179tTevXvN5vTp00eDBg3S2rVrFRISIm9vb/3vf/+TJG3fvl09evSQj4+P/Pz89O677+r69etFOk9CQoLKlSunadOmyc7OLt/3KkkGg0GxsbGKjo6Wv7+/fH19NXbsWNMea9as0dixYyVJzZo1k8FgUKtWrUx9d143nyczM1PvvPOOGjdurKZNm2rq1KnKyckxG3P06FGFhoaqQYMGaty4sYYPH66zZ8+ajbl69arGjBmjhg0bys/PT1FRUbp165apPzs7WwEBAfroo4/ynevNN98s8PsBAAAAAAAAAAAAAAAASjoraxs+f4IPCkYl0WLyx6Q8ScrNzc3XNmLECO3bt09Dhw6Vh4eHEhMT9dZbb8nJycks2fHixYuaOHGihg0bJicnJ8XGxio0NFRbtmyRq6urJOnMmTPq0qWLatasqaysLG3YsEG9e/fW+vXr5e7urh49euj8+fNKSEgwXS3v4OCQLyYvLy9FRkZq0qRJmjp1qmrXrl3oOffu3atx48ZpwIABCgoK0o0bN3Tw4EFlZGTc8x3l5uYqJydHRqNRycnJmj59uipUqCBfX99C55w/f16nT5/W4MGD77n+rVu39Prrr+v06dMKDw9XxYoVtWTJEr366qtavny56tevbxp7+PBhJSUlacSIEXJyclLVqlW1adMmjRw5Ut26ddOwYcN08eJFzZw5U+np6QUmRt7p5s2b2rJli9q2basqVaooMDBQGzZs0JgxY2RtbZ6LvXTpUjVu3FjTpk3Tb7/9pqioKLm6uio8PFzBwcEaMmSIPv30U8XFxcnR0VGlSpW6694ffvihAgMDNWvWLP3888+aPXu27OzsFB4eLkk6d+6cXnnlFT3xxBOaPn26bt68qY8++kivvPKK1q9fb/pNvPPOO9qxY4fCw8NVo0YNLVu2TAkJCaZ97Ozs1LVrV61bt04jRowwnSstLU1bt27VuHHj7vkdAQAAAAAAAAAAAAAAAAAeH5JEi8H169cLvVbc3t7e9Pfu3bu1bds2LViwQIGBgZKkgIAAXbx4UdHR0fkqYs6aNUvNmjWTdPtq9aCgIC1atEijR4+WJL3xxhum8bm5uQoICNDBgwe1du1ajRo1ynSlvLW19V2vjHdwcNBTTz0lSfL09JS3t3ehYw8ePChnZ2e9/fbbprbg4OBCx99pxowZmjFjhunZ2dlZc+bMkaOjY6FzkpOTJd2+qv5etm/froMHDyouLk7NmzeXJAUGBqpdu3aaP3++oqOjTWOvXLmiVatWmdY1Go2KiorSc889pylTppjGVapUSQMHDlRYWJg8PT0L3Xvbtm26du2aOnXqJEl6/vnn9fXXX2vPnj2m7/DONWfOnClJatGihX7++Wdt3rxZ4eHhcnFxUc2aNSXdTt4tyvXyNWvW1NSpUyVJzZs3140bN/TZZ5/p9ddfV/ny5bVo0SLl5ORo4cKFcnZ2liQ9/fTT6tixo9auXas+ffro119/1ZYtWzR58mRTRdC8d3enHj16KC4uTjt27DD9XuPj42VtbW06OwAAAAAAAAAAAAAAAADgz4Hr5otBmTJltGrVqnyfF1980Wzczp075ezsLD8/P+Xk5Jg+/v7+OnLkiNnV3o6OjmbJhY6OjvL399ePP/5oajt+/LiGDh0qf39/Pf300/Ly8tLJkyf122+/PbKz1qtXT2lpaYqIiNDOnTuVmZlZ5Ll9+/Y1vZuYmBg1aNBAYWFhpqve78bKyuqeY77//ns5ODiYEkSl29Uv27Ztqx9++MFsbJ06dcwST0+ePKmkpCR16NDB7Ltp2rSprK2tdfjw4bvunZCQIFdXV/n7+0uSWrVqJXt7+wKvnM8bk8fDw0Pnz5+/5/kK07ZtW7PnkJAQZWZm6tixY5JuvxdfX19TgmjennXr1jW9l0OHDsloNJqtZWNjozZt2pit/eSTT6pp06ZavXq1qW3NmjUKCQkpsEotAAAAAAAAAAAAAAAAAMByqCRaDKytrQusvrl9+3az58uXLystLa3QqqMXL16Um5ubJBVYQdLV1VXHjx+XJF29elUDBgyQi4uLIiIiVK1aNZUuXVrjx4/XzZs3H/JEhWvWrJmioqL0+eefKzQ0VKVLl1ZISIjeeecdsyTEgri5uZm9p2bNmqlFixb65JNPNHv27ALnVKlSRZJ09uzZe8aWnp4uV1fXfO0VK1bUlStX8rXd6fLly5KkoUOHFrj2uXPn7rpvYmKiOnfurGvXrpnamzdvrq+++krvvfee2ZXxTk5OZvPt7OyUlZVV6Pr38sffSt7ZLl68aIrv6aefzjfP1dXV9F4uXrwoOzs7lS9fPt+YP3rxxRcVERGh1NRUXbhwQT///LMiIiIeOH4AAAAAAAAAAAAAAAAAwKNBkuhjVL58ebm4uCgmJqbA/juT/VJTU/P1p6SkqFKlSpKkAwcO6Pz585o/f77q1q1rGpORkWFKNH1UOnfurM6dOys1NVVbt27V1KlTZWtrqw8++OC+1ilVqpSeeOIJ/fLLL4WOcXNzU82aNfXf//5XI0eOvOt65cuXV0pKSr72S5cu5Ut+/GNl0rwE18jISPn4+ORbo3LlyoXuu3nzZmVnZ5uqpP7R9u3b813bXpz++Fu5dOmSJJl+K4W9l5SUFNWqVcs0Njs7W1euXDF7VwXNa9eund5//32tX79eZ86cUc2aNdW0adPiOg4AAAAAAAAAAAAAAAAAoJhw3fxj5O/vr9TUVNnZ2cnb2zvf585qkxkZGdq1a5fZ87fffqtnnnlGknTjxg1Jt6tQ5tm3b5+SkpLM9ixqlcq8de6nCqmLi4t69OihgIAAnThxosjz8ty8eVOnTp1ShQoV7jquf//+Onz4sNauXZuvLzc3V998840kqXHjxrp69ar++9//mvpzcnL0n//8R40bN77rHrVr15abm5tOnz5d4HeTV9G0IPHx8apevbo+//zzfJ+KFSsWeOX83eR9F0WtLvrVV1+ZPW/evFlly5ZVnTp1JN1+L7t37zarpnrixAkdPXrU9F7yKrzeudatW7f0n//8J99+pUqVUufOnbVy5UrFx8erW7du+ZJuAQAAAAAAAAAAAAAAAACWRyXRxyggIEAtW7bUa6+9ptdee00Gg0GZmZn69ddf9fvvv2vKlCmmsc7Ozho3bpyGDx8uR0dHxcbGymg0ql+/fpKkBg0ayN7eXhMnTtTAgQOVnJys6OjofMmMHh4eysnJ0eLFi9WwYUM5ODiodu3a+WKrVauWbGxstHr1atna2srGxsbsavg8s2fPVlpampo2bSpXV1cdO3ZMO3bsUP/+/e95/nPnzunAgQOSble/XLp0qdLS0tSzZ8+7znv55Zf1ww8/aNy4cdq3b59at24te3t7nThxQsuXL1f16tXVokULBQcHy8fHR2+99ZZGjx6tihUrasmSJbpw4UKh19nnsbKyUkREhMLDw3X9+nUFBwerbNmyOnv2rBITEzVy5Ei5u7vnm5ecnKy9e/dqyJAh8vX1zdffqVMnLVu2TBkZGXJ0dLznO5Juf2eStHTpUrVp00ZlypSRwWAodPypU6c0duxYPffcc/r5558VExOjfv36mSqC9u/fX2vWrNGAAQM0ZMgQ3bx5U7NmzVLVqlXVtWtXSdJTTz2ltm3b6oMPPtDNmzdVo0YNLVu2TNnZ2QXu+eKLL2rx4sWysbFRt27dinQuAAAAAAAAAAAAAAAAAMDjRZLoYzZ79mzFxMToyy+/VFJSkhwdHeXp6Zkv0a5SpUoKDw9XVFSUTp06JU9PTy1YsEAVK1aUJFWsWFEff/yxoqKiFBYWplq1amnixImKi4szW6dly5Z6+eWXFRMTo5SUFDVp0kRLlizJF5eLi4siIyMVFxen9evXKycnR0ePHs03ztvbW4sXL9bGjRt19epVubm5KTQ0VEOGDLnn2ZcsWWLa28nJSR4eHpo7d67atGlz13lWVlaaOXOmAgMDtXLlSm3YsEFZWVmqXr26WrVqpQEDBkiSbGxsFBMTo6ioKE2fPl3Xr1+Xl5eXFi5cqPr1698zvg4dOsjJyUnz5s0zVf+sXr26mjdvbnrvf7Rhwwbl5uaqS5cuBfZ37dpVixYt0ubNm9W9e/d7xiBJ9erV07Bhw7Ry5UrFxcWpatWq2rZtW6HjR44cqe+++04jRoyQjY2NXn75ZY0cOdLUX7VqVS1ZskRRUVEKDw+XtbW1AgICFBERIQcHB9O4Dz74QJMmTdKMGTNUqlQpde3aVU2bNlVUVFS+PZ966inVqlVLNWvWvGuVVQAAAAAAAAAAAAAAAKCks7LmQm/8eVkZjUajpYOAuYiICB0+fFgJCQmWDgUo0KlTp9SuXTt9/PHHCgkJeai1Tl7KKKao7t8T2ecttvc732dZZN/XfWtaZF9J8qxctGq6AAAAAAAAAAAAAAAAfyXObcZbOgRISvvPZEuH8KdEJVEARXb58mWdPHlSc+fOVbVq1dS6dWtLhwQAAAAAAAAAAAAAAAAAKAR1bgEU2ddff62XX35ZZ86c0fTp02VrS545AAAAAAAAAAAAAAAAAPxZkeH1JzRt2jRLhwAUqFu3burWrZulwwAAAAAAAAAAAAAAAAAAFAGVRAEAAAAAAAAAAAAAAAAAAEogkkQBAAAAAAAAAAAAAAAAAABKIJJEAQAAAAAAAAAAAAAAAAAASiBbSwcAAAAAAAAAAAAAAAAAAMBflZW1jaVDAApFJVEAAAAAAAAAAAAAAAAAAIASiCRRAAAAAAAAAAAAAAAAAACAEojr5gFYVLUyuRbb2+radYvtPan1UxbZ1zo70yL7StJ/frlhkX3beFayyL4AAAAAAAAAAAAAAACApVFJFAAAAAAAAAAAAAAAAAAAoAQiSRQAAAAAAAAAAAAAAAAAAKAEIkkUAAAAAAAAAAAAAAAAAACgBLK1dAAAAAAAAAAAAAAAAAAAAPxVWVnbWDoEoFBUEgUAAAAAAAAAAAAAAAAAACiBSBIFAAAAAAAAAAAAAAAAAAAogUgSBQAAAAAAAAAAAAAAAAAAKIFIEgUAAAAAAAAAAAAAAAAAACiBSBJ9ANHR0WrYsOF99z0ue/bs0bx58/K1/zG2M2fOKDo6WsnJyfnmGwwGHTp06KFjSU1N1bRp0xQSEiJvb281atRIr7zyilauXKlbt24VOGfw4MFq165doWsuWbJEBoNBp06dUkREhDp16vTQcRaXIUOGyGAwaN26dQ+8RlG/v+L8ngozZcoUtWrV6pGtDwAAAAAAAAAAAAAAAAB4dEgSLYG+++47zZ8/P197jx49tHjxYtNzUlKS5syZowsXLpiN8/Ly0ooVK+Th4fFQcfz+++/q2rWrEhIS9OKLLyo2NlazZs2Sj4+Ppk6dqq+//rrAeZ06ddLvv/+ugwcPFti/YcMGNWjQQDVr1lRYWJhmzJjxUHEWl7S0NO3YsUOSlJCQ8MDrFPX7AwAAAAAAAAAAAAAAAADgbmwtHQAeHzc3N7m5ud1znIODgxo0aPDQ+4WHh+vWrVtavXq1qlSpYmpv0aKFXnnlFWVkZBQ4r3Xr1rK3t1dCQoJ8fHzM+s6cOaP9+/dr/PjxkqSaNWveM44bN26oTJkyD3GSotm8ebOys7Pl7++vXbt2KSUlRa6ursW2flG/PwAAAAAAAAAAAAAAAAAAJCqJPhZZWVn68MMP1bJlS9WvX18dOnRQfHy82Zi8a9MTExPVqVMneXt7q1u3bjpw4IDZuHXr1qlXr15q2rSpmjRpoj59+phV3IyOjtacOXN0/fp1GQwGGQwG9enTx9SXd135nj171LdvX0lS9+7dTWPz+v54jfmqVavUsWNH+fj4yNfXV7169Sq00qckff/99zp48KAGDRpkliCap1q1aqb9/qhs2bJq3bq1Nm7cqNzcXLO+DRs2yMbGRs8995zZe8uzZs0aGQwG7d+/X6+++qoaNGigqKgonTlzRgaDQZs2bTJb74/Xqaenp2v8+PFq3ry5vL29FRQUpJEjRxZ6zjslJCToySefVEREhHJycvTvf//brD8vhn/961+aNGmSmjRposDAQP3jH/9QTk6OpKJ/f3dKTU3VG2+8oQYNGigwMLDAq+r37t2rnj17mr6/sWPHKi0tzWxMcnKyBg8erGeeeUbNmzdXbGxsvn3q16+vf/7zn/nW79Gjh0aMGFGk9wQAAAAAAAAAAAAAAACUJFbWNnz+BB8UjEqiDyEvse9Of0xqlKQRI0Zo3759Gjp0qDw8PJSYmKi33npLTk5OCgoKMo27ePGiJk6cqGHDhsnJyUmxsbEKDQ3Vli1bTBUpz5w5oy5duqhmzZrKysrShg0b1Lt3b61fv17u7u7q0aOHzp8/r4SEBNPV5A4ODvli8vLyUmRkpCZNmqSpU6eqdu3ahZ5z7969GjdunAYMGKCgoCDduHFDBw8eLLQSqHT7ynRJat68eaFj7ub5559XfHy89uzZo2bNmpnaExIS5O/vf88KnaNHj9ZLL72kQYMGqWzZskXed+rUqdqxY4dGjx6t6tWr6+LFi/rmm2/uOe/8+fPau3evwsLCZDAYVKdOHSUkJJgSPO80a9YstW7dWrNmzdL+/fsVHR2tmjVrqlevXkX+/u40YcIEdezYUdHR0fr222/10UcfqXz58urVq5ck6fDhw3r11Vfl6+urjz/+WJcuXdLMmTP166+/avny5bKxuf0vyLCwMCUnJ+u9996To6OjYmNjde7cOdna3v7XhIuLi9q2bavVq1frxRdfNO3/yy+/6ODBgxo+fHjRXjIAAAAAAAAAAAAAAAAA4LEgSfQBXb9+XV5eXgX22dvbm/7evXu3tm3bpgULFigwMFCSFBAQoIsXLyo6OtosSTQtLU2zZs0yJUU2bdpUQUFBWrRokUaPHi1JeuONN0zjc3NzFRAQoIMHD2rt2rUaNWqU6Upya2vru14Z7+DgoKeeekqS5OnpKW9v70LHHjx4UM7Oznr77bdNbcHBwYWOl25XpZRuVwx9EAEBAXJxcdGGDRtM7+PYsWM6duyYQkND7zm/Z8+eGjhwoOn5zJkzRdr30KFD6tSpk7p27Wpq69ix4z3nJSQkyGg0mqqaPv/885o5c6ZOnTqlmjVrmo318fHR+PHjJd0+5549e7R582b16tWryN/fnfz8/EzfTfPmzZWSkqJPP/1UL730kqytrTVv3jxVqlRJ8+bNk52dnSSpatWqCg0NVWJiolq1aqVvvvlGhw8f1qJFi0zv29fXV0FBQXJ2djbt9eKLL6p///46fvy4PDw8JEmrV69W1apVFRAQUKR4AQAAAAAAAAAAAAAAAACPB9fNP6AyZcpo1apV+T53VliUpJ07d8rZ2Vl+fn7Kyckxffz9/XXkyBHdunXLNNbR0dGsaqajo6P8/f31448/mtqOHz+uoUOHyt/fX08//bS8vLx08uRJ/fbbb4/srPXq1VNaWpoiIiK0c+dOZWZmPrK98tja2qp9+/basmWLsrKyJN2+ar5s2bJq27btPeffK4m1MPXq1dPatWu1YMECHTt2rMjzEhIS5OXlZarI2rFjR1lZWSk+Pj7f2Lxk4TweHh46f/78A8UrKd/7CAkJUXJysmnN77//Xq1btzYliObF4OTkpB9++EHS7UTgwn5/d/Lz89MTTzyhVatWSbpdTXf9+vXq2rWrrK351wkAAAAAAAAAAAAAAAAA/JmQ1fWArK2t5e3tne9TuXJls3GXL19WWlqavLy8zD7jx49XTk6OLl68aBrr4uKSbx9XV1fTmKtXr2rAgAE6e/asIiIitHTpUq1atUp169bVzZs3H9lZmzVrpqioKP3yyy8KDQ2Vn5+fxowZo7S0tELnVKlSRZJ07ty5B963U6dOunLlinbs2CHpdiJmq1atVK5cuXvOrVix4gPtOWHCBL3wwgv67LPP9Pzzzys4OFjLli2765zjx4/ryJEjatWqldLT05Weni5HR0fVr19fCQkJ+cY7OjqaPdvZ2ZkSYR/EH383eWfP+92kp6fL1dU13zxXV1dduXJFknThwoVCf393srKyUo8ePbR+/Xrl5ORo+/btSk1NVbdu3R44fgAAAAAAAAAAAAAAAADAo8F1849Y+fLl5eLiopiYmAL770zMS01NzdefkpKiSpUqSZIOHDig8+fPa/78+apbt65pTEZGhtzc3Io5cnOdO3dW586dlZqaqq1bt2rq1KmytbXVBx98UOD4pk2bSpL++9//6sknn3ygPRs1aqTq1atrw4YNcnV11ZkzZzRu3LgHWqt06dKSpOzsbLP29PR0s2dHR0eNGzdO48aN09GjR/X5559r4sSJqlOnjp599tkC116/fr0kKTo6WtHR0fn6f/rpJ3l5eT1Q3EXxx9/NpUuXJMn0uylfvrxSUlLyzUtJSVH58uUlSZUrVy709/dH3bp10+zZs7V9+3atWrVKvr6+euKJJx76HAAAAAAAAAAAAAAAAACA4kUl0UfM399fqampsrOzK7DyaKlSpUxjMzIytGvXLrPnb7/9Vs8884wk6caNG5Jkdm34vn37lJSUZLZnUStT5q1zP1VIXVxc1KNHDwUEBOjEiROFjnv22Wfl4+OjefPm6cKFC/n6z507p6NHj951LysrK3Xq1Enbtm3TP//5Tzk7O6t58+ZFjvVOrq6usrOz0/Hjx01tWVlZ2rt3b6FzDAaDxo4dK0lm8/5ow4YNatCggT7//HOzz4IFC2RnZ1fglfN3c7+VRb/66iuz582bN6ty5cqmxOHGjRtr69atysnJMY3ZuXOn0tPT1bhxY0mSt7d3ob+/P6pUqZKCg4MVFxenHTt26P/+7//u63wAAAAAAAAAAAAAAAAAgMeDSqKPWEBAgFq2bKnXXntNr732mgwGgzIzM/Xrr7/q999/15QpU0xjnZ2dNW7cOA0fPlyOjo6KjY2V0WhUv379JEkNGjSQvb29Jk6cqIEDByo5OVnR0dGmq93zeHh4KCcnR4sXL1bDhg3l4OCg2rVr54utVq1asrGx0erVq2VraysbGxt5e3vnGzd79mylpaWpadOmcnV11bFjx7Rjxw7179//rmefMWOG+vTpo//7v//Tq6++Ki8vL1Ni5tKlS/WPf/xDBoPhrmt06tRJ8+fP15o1a/TSSy+ZJcjeD2tra7Vt21ZLly7Vk08+qQoVKuiLL76Q0WiUlZWVaVzPnj3Vtm1beXp6ysbGRuvWrZOdnV2hVUT379+v06dPa8iQIfL19c3XHxwcrA0bNmjMmDFFjrWo31+e3bt36x//+IcCAgK0c+dO/etf/1JkZKSsrW/ngA8ePFg9e/bUoEGD1KdPH126dEkzZ86Uj4+PgoKCJEktWrSQl5eX3nrrLYWHh8vR0VExMTFycHAocM8XX3xRAwcOlJOTk0JCQop8NgAAAAAAAAAAAAAAAADA40OS6GMwe/ZsxcTE6Msvv1RSUpIcHR3l6empbt26mY2rVKmSwsPDFRUVpVOnTsnT01MLFixQxYoVJUkVK1bUxx9/rKioKIWFhalWrVqaOHGi4uLizNZp2bKlXn75ZcXExCglJUVNmjTRkiVL8sXl4uKiyMhIxcXFaf369crJySmwuqe3t7cWL16sjRs36urVq3Jzc1NoaKiGDBly13M/+eSTWrt2rWJjY/Xll1/q3LlzKlWqlOrVq6d33nlHLVu2vOe7q1OnjgwGg44eParnn3/+nuPvZsKECZowYYImT56scuXKKTQ0VO7u7tq6datpTKNGjbRu3TqdOXNG1tbWqlOnjubNmycPD48C10xISFDZsmULTZTs0qWLvvrqK+3Zs6fIV7IX9fvLM2nSJK1YsUJffvmlypUrpxEjRqh3796m/vr162vhwoX68MMPNWzYMNnb26tVq1Z6++23ZWNjI+l21dZPPvlE7777riIjI+Xk5GRKKL3z/eQJDAxU2bJl1bFjR5UuXbpI5wIAAAAAAAAAAAAAAABKIqv/n4MD/BlZGY1Go6WDgBQREaHDhw8rISHB0qEA97Rr1y71799fq1evVv369R9qrZtXrxRTVPfPNuU3i+2dXekpi+xrnZ1pkX0l6ZsLlvnPTRvPShbZFwAAAAAAAAAAAAAA/D1UfH6apUOApEvxEZYO4U+JSqIAiiw5OVmnTp3S9OnT1ahRo4dOEAUAAAAAAAAAAAAAAAAAPDrWlg4AwF/HP//5T/Xt21eSNHnyZAtHAwAAAAAAAAAAAAAAAAC4G66bB2BRXDf/eHHdPAAAAAAAAAAAAAAAQPHiuvk/B66bLxiVRAEAAAAAAAAAAAAAAAAAAEogkkQBAAAAAAAAAAAAAAAAAABKIFtLBwAAAAAAAAAAAAAAAAAAwF+VlbWNpUMACkUlUQAAAAAAAAAAAAAAAAAAgBKIJFEAAAAAAAAAAAAAAAAAAIASiCRRAAAAAAAAAAAAAAAAAACAEsjW0gEA+HuzST9vsb3f/bmUxfYe7Gu0yL7ly5SzyL6S5FEhxyL7pl29bpF9JcnZwd5iewMAAAAAAAAAAAAAAABUEgUAAAAAAAAAAAAAAAAAACiBSBIFAAAAAAAAAAAAAAAAAAAogUgSBQAAAAAAAAAAAAAAAAAAKIFsLR0AAAAAAAAAAAAAAAAAAAB/VVbWNpYOASgUlUQBAAAAAAAAAAAAAAAAAABKIJJEAQAAAAAAAAAAAAAAAAAASiCSRAEAAAAAAAAAAAAAAAAAAEogkkSBR2Dr1q0aMGCAmjZtqvr166tVq1aKjIzUyZMnJUkGg0ELFix44PWjo6PVsGHD4gr3T7MXAAAAAAAAAAAAAAAAAKD42Fo6AKCkmTFjhmJjYxUSEqL3339fLi4uOnXqlFavXq2RI0dq3bp1WrFihapVq2bpUIukR48eCgoKsnQYAAAAAAAAAAAAAAAAAID7RJIoUIwSExMVGxursLAwjRgxwtTepEkT/d///Z++/vprSVKDBg3uus6tW7eUm5srOzs7s3aj0ajs7Oxij/tu3Nzc5Obm9lj3BAAAAAAAAAAAAAAAAAA8PK6bB4rRwoULVbFiRYWFhRXY37JlS0n5r5vv06ePBg0apLVr1yokJETe3t763//+p4iICHXq1EmJiYl64YUX5O3trW3btpnmHT16VL169dIzzzyjTp06aceOHWb75ebm6pNPPlGrVq1Uv359tW/fXsuXLzcbc/78eY0YMUL+/v7y9vZWq1at9MEHH5j6/3jdfHZ2tv7xj38oODhY9evXV2BgoAYPHqyMjIwHf3EAAAAAAAAAAAAAAAAAgGJHJVGgmOTk5Gjfvn1q165dvgqgRXH48GElJSVpxIgRcnJyUtWqVSVJFy5c0OTJkzVkyBBVrVpV1apV0y+//KLs7GyFh4erb9++CgsLU2xsrIYPH65t27apQoUKkqSoqCh9/vnnGjJkiBo2bKjt27fr3XffVU5Ojl555RVJ0pgxY3ThwgWNHz9erq6uOnfunA4fPlxonPPnz9fy5csVHh4uT09PXb58WTt37lRWVtYDvDUAAAAAAAAAAAAAAADgr83a2sbSIQCFIkkUKCZpaWnKyspStWrVHmj+lStXtGrVKlNy6J3tsbGxeuaZZ8za85JEg4KCJEnu7u5q3bq1vvnmG3Xu3Fmpqan64osvFBoaqmHDhkmSAgMDdfnyZc2dO1e9evWSjY2NDh06pFGjRum5554zrd2lS5dC4zx06JACAwPVu3dvU1tISMgDnRkAAAAAAAAAAAAAAAAA8Ohw3TxQzKysrB5oXp06dfIliEqSs7NzvgRRSbK2tlazZs1MzzVq1FCZMmWUnJwsSTp48KCys7PVvn17s3kdOnRQamqqfvvtN0lSvXr1tHDhQi1btky///77PeOsV6+eEhMTFR0drYMHDyo3N/d+jgkAAAAAAAAAAAAAAAAAeExIEgWKibOzs0qXLq2zZ88+0PyKFSveV3uZMmVUqlQpszY7OzvdvHlT0u0KpAXNz3tOS0uTJH300Ufy8/PTrFmz1K5dO7Vv315btmwpNM4hQ4bo9ddf19q1a9WjRw8FBARozpw5MhqN9z4kAAAAAAAAAAAAAAAAAOCxIUkUKCa2trZq1KiRdu/erZycnPueX1gF0getTOrs7CxJSklJMWu/dOmSWX/lypU1depU7d69WytXrpS7u7tGjhyp06dPF7huqVKlNGzYMG3btk1btmxRjx49FB0drX/9618PFCcAAAAAAAAAAAAAAAAA4NEgSRQoRq+++qouXryoefPmFdifmJj42GLx9vaWnZ2dNm3aZNa+ceNGubq6qlatWmbt1tbW8vHx0ZtvvqmcnJwiXT3/5JNPatSoUXJ2dtaJEyeKM3wAAAAAAAAAAAAAAAAAwEOytXQAQEkSFBSk1157TdHR0fr111/VsWNHVahQQWfOnNHq1auVkZGhoKCgxxKLi4uLXnnlFS1YsEClSpVSgwYNlJiYqISEBE2YMEE2NjbKyMhQaGioOnfuLHd3d2VnZ2vJkiVycnJSvXr1Clw3LCxMXl5eqlevnsqWLauvv/5aV65ckZ+f32M5FwAAAAAAAAAAAAAAAACgaEgSBYrZW2+9pYYNG2rp0qV65513lJmZqcqVKyswMFChoaGPNZYxY8bI0dFRq1at0rx581S9enVNnDhRPXv2lCSVLl1aderU0ZIlS3Tu3DmVKVNG9evX14IFC+Ti4lLgmo0aNdLGjRv12Wef6datW3J3d9eMGTPk7+//OI8GAAAAAAAAAAAAAAAA/ClYWdtYOgSgUFZGo9Fo6SAA/H3lnD1qsb3f+zHXYnsP9n3CIvuWL2O5/ym5dD3HIvtWsOCZnR3sLbY3AAAAAAAAAAAAAAB4PKr2mGPpECDp3Mo3LB3Cn5K1pQMAAAAAAAAAAAAAAAAAAABA8SNJFAAAAAAAAAAAAAAAAAAAoAQiSRQAAAAAAAAAAAAAAAAAAKAEIkkUAAAAAAAAAAAAAAAAAACgBCJJFAAAAAAAAAAAAAAAAAAAoAQiSRQAAAAAAAAAAAAAAAAAAKAEsrV0AAAAAAAAAAAAAAAAAAAA/FVZWdtYOgSgUFQSBQAAAAAAAAAAAAAAAAAAKIFIEgUAAAAAAAAAAAAAAAAAACiBuG4egEWdL1PdYnu/2/iSxfaef/SiRfZ9vX4Fi+wrSUZZprT6+Ws5FtlXkuxvnLHIvqUq1rDIvgAAAAAAAAAAAAAAAPhzoZIoAAAAAAAAAAAAAAAAAABACUSSKAAAAAAAAAAAAAAAAAAAQAlEkigAAAAAAAAAAAAAAAAAAEAJRJIoAAAAAAAAAAAAAAAAAABACWRr6QAAAAAAAAAAAAAAAAAAAPirsrK2sXQIQKGoJAoAAAAAAAAAAAAAAAAAAFACkSQKAAAAAAAAAAAAAAAAAABQApEkCgAAAAAAAAAAAAAAAAAAUAKRJIp8oqOjZTAYCvzExMQUyx6dO3dWREREsaxVFHv27JHBYNChQ4eKZb2tW7dqwIABatq0qerXr69WrVopMjJSJ0+eLJb1H8SRI0cUHR2tzMzMIs8xGAxasGDBI4wKAAAAAAAAAAAAAAAAAGAptpYOAH9OZcqU0eLFi/O1V61a1QLRPDwvLy+tWLFCHh4eD73WjBkzFBsbq5CQEL3//vtycXHRqVOntHr1ao0cOVLr1q17+IAfwJEjRzRnzhz17t1bZcuWLdKcFStWqFq1ao84MgAAAAAAAAAAAAAAAACAJZAkigJZW1urQYMGlg6j2Dg4OBTLeRITExUbG6uwsDCNGDHC1N6kSRP93//9n77++uuH3uNxuHHjhsqUKVOivmMAAAAAAAAAAAAAAAAAgDmum8cDMxgMio2NVXR0tPz9/eXr66uxY8fq+vXrZuP27dunbt26ydvbW506dVJiYmKB6+3fv199+/ZVgwYN1LhxY40ePVopKSmm/jNnzshgMGjdunWKjIzUs88+q2bNmumzzz6TJG3YsEEhISFq1KiR3njjDaWnp5vmFnTdfG5urj777DN16NBB9evXV0BAgIYPH66MjIxCz7xw4UJVrFhRYWFhBfa3bNnS9PfNmzc1depUBQYGytvbW507d9ZXX31lNr5Pnz4aNGiQWduRI0dkMBi0Z88eU9u93vWaNWs0duxYSVKzZs1kMBjUqlUrU5/BYND+/fv16quvqkGDBoqKijKt+8fr5rdv364ePXrIx8dHfn5+evfdd82+0+zsbP3jH/9QcHCw6tevr8DAQA0ePPiu7w0AAAAAAAAAAAAAAAAoqaysbfj8CT4oGJVEUaicnJx8bba25j+ZpUuXqnHjxpo2bZp+++03RUVFydXVVeHh4ZKkixcvKjQ0VAaDQbNmzVJ6eromTpyo69ev6+mnnzats3//fvXp00dBQUH66KOPlJmZqVmzZiksLEwrVqww23PWrFlq166dPv74Y/3nP//RtGnTlJqaqu+++05vvfWWrl69qsmTJ2v69Ol6//33Cz3f+++/rxUrVqhfv34KCAjQtWvXtH37dl2/fl2Ojo4Fvo99+/apXbt2srOzu+f7Cw8P144dO/Tmm2+qdu3a+te//qVhw4Zp7ty5at269T3n/9Hd3nVwcLCGDBmiTz/9VHFxcXJ0dFSpUqXM5o8ePVovvfSSBg0aVOh19Js2bdLIkSPVrVs3DRs2TBcvXtTMmTOVnp6ujz76SJI0f/58LV++XOHh4fL09NTly5e1c+dOZWVl3feZAAAAAAAAAAAAAAAAAACPDkmiKND169fl5eWVr33p0qV69tlnTc+VKlXSzJkzJUktWrTQzz//rM2bN5uSRBcvXiwrKyvFxsaaEi/d3NzUv39/s3Vnzpyp+vXra86cObKyspIk1alTx1R5NCgoyDS2QYMGeueddyRJfn5+2rJli7744gtt27ZNFSpUkCQdPXpUq1atKjRJ9OTJk/ryyy81cuRIs0qeISEhhb6TtLQ0ZWVlqVq1aoWOyfO///1PW7Zs0cSJE9WzZ0/T+0lKSnrgJNG7vWsXFxfVrFlTkuTl5SUXF5d883v27KmBAwcWur7RaFRUVJSee+45TZkyxWzfgQMHKiwsTJ6enjp06JACAwPVu3dv05i7vTcAAAAAAAAAAAAAAAAAgGVw3TwKVKZMGa1atSrf587qn5Lk7+9v9uzh4aHz58+bnn/88Uf5+vqaVeZs1qyZnJ2dTc+ZmZnat2+f2rdvr1u3biknJ0c5OTmqVauWqlatanZFvCQFBASY/raxsdETTzyhunXrmhJEJalWrVpKT0/XtWvXCjzf7t27ZTQa1b1796K/lP8vL4n1bn744QdJUvv27c3aO3TooJ9//tns+vaiute7vpfg4OC79p88eVJJSUnq0KGD6TvIyclR06ZNZW1trcOHD0uS6tWrp8TEREVHR+vgwYPKzc2977MAAAAAAAAAAAAAAAAAAB49KomiQNbW1vL29r7nOCcnJ7NnOzs7s2vHL168qCeffDLfvDsrXaanp+vWrVuaOnWqpk6dmm/suXPnzJ7/eBW8nZ2d7O3t87VJ0s2bN1WuXLl8a6alpcnW1laurq6FHS0fZ2dnlS5dWmfPnr3n2CtXrsjOzs4sGVaSKlasKKPRqIyMjHwx38u93vW9VKxY8a79ly9fliQNHTq0wP6872HIkCGytrbW2rVrNWfOHLm4uKh3794aOnRokRJoAQAAAAAAAAAAAAAAAACPB0mieKQqVaqklJSUfO2pqammvx0dHWVlZaVBgwapTZs2+cbeWSG0uDg7OysnJ0cpKSlFThS1tbVVo0aNtHv3buXk5MjWtvB/fMqXL6/s7GxduXJF5cuXN7VfunRJVlZWpkTXUqVKKTs722zulStXHuBEDy8voTUyMlI+Pj75+itXrizpdszDhg3TsGHD9Pvvv2v16tWKjo5WjRo11KVLl8cYMQAAAAAAAAAAAAAAAADgbrhuHo+Uj4+P9uzZo4yMDFPbrl27lJaWZnq2t7dXgwYNdOLECXl7e+f71KhRo9jj8vPzk5WVlVavXn1f81599VVdvHhR8+bNK7A/MTFRktS4cWNJ0qZNm8z6N23apHr16pmqiLq5uenkyZMyGo2mMTt37ryvmPLkVU+9n+qid6pdu7bc3Nx0+vTpAr+HKlWq5Jvz5JNPatSoUXJ2dtaJEyceaF8AAAAAAAAAAAAAAAAAwKNBJVEUKDc3VwcOHMjX7urqqieeeKLI6/Tr10/Lli3T66+/rtdff13p6emKjo7Odw37mDFj1K9fP7355pvq2LGjnJycdP78eX377bfq1q2bfH19H/JE5tzd3dWzZ099/PHHunLlipo1a6YbN25o+/btGjZsWIEJkZIUFBSk1157TdHR0fr111/VsWNHVahQQWfOnNHq1auVkZGhoKAg1a1bV+3atdO0adN048YNubu7a/369dq/f78++eQT03ohISFatWqV3n//fbVp00b79u3T5s2bH+hMHh4ekqSlS5eqTZs2KlOmjAwGQ5HnW1lZKSIiQuHh4bp+/bqCg4NVtmxZnT17VomJiRo5cqTc3d0VFhYmLy8v1atXT2XLltXXX3+tK1euyM/P74HiBgAAAAAAAAAAAAAAAAA8GiSJokA3btzQSy+9lK+9e/fumjJlSpHXqVy5smJjYzV58mSNGDFCNWvWVGRkpD766COzcY0aNdKyZcsUHR2tsWPHKjs7W25ubvLz89OTTz750OcpSGRkpGrUqKGVK1dq8eLFcnZ2VpMmTVSuXLm7znvrrbfUsGFDLV26VO+8844yMzNVuXJlBQYGKjQ01DRu+vTp+vDDDxUbG6u0tDTVrl1bs2fPVqtWrUxjWrRoobfeektffPGF1q5dqxYtWmjixInq37//fZ+nXr16GjZsmFauXKm4uDhVrVpV27Ztu681OnToICcnJ82bN0/x8fGSpOrVq6t58+aqWLGipNvf1caNG/XZZ5/p1q1bcnd314wZM+Tv73/fMQMAAAAAAAAAAAAAAAB/dVbWNpYOASiUlfHOe64B4DE7k3rVYntXyblksb3nH7fMv3pfr1/BIvtKUtJNy/wPUdYty/1nrrZNukX2LVWxhkX2BQAAAAAAAAAAAADg7+iJPossHQIknV7S39Ih/ClZWzoAAAAAAAAAAAAAAAAAAAAAFD+SRAEAAAAAAAAAAAAAAAAAAEogkkQBAAAAAAAAAAAAAAAAAABKIJJEAQAAAAAAAAAAAAAAAAAASiCSRAEAAAAAAAAAAAAAAAAAAEogkkQBAAAAAAAAAAAAAAAAAABKIFtLBwAAAAAAAAAAAAAAAAAAwF+VlY2NpUMACkUlUQAAAAAAAAAAAAAAAAAAgBKIJFEAAAAAAAAAAAAAAAAAAIASiOvmAVhUaVvL5aqvTyplsb171Xe2yL6lHe0tsq8kuVpnWmTfnFyjRfaVpN8zy1tk3+qZNyyyryTZly1jsb0BAAAAAAAAAAAAAABgjkqiAAAAAAAAAAAAAAAAAAAAJRBJogAAAAAAAAAAAAAAAAAAACUQSaIAAAAAAAAAAAAAAAAAAAAlkK2lAwAAAAAAAAAAAAAAAAAA4K/KytrG0iEAhaKSKAAAAAAAAAAAAAAAAAAAQAlEkigAAAAAAAAAAAAAAAAAAEAJRJIoAAAAAAAAAAAAAAAAAABACWRr6QCAkmT9+vX6/PPPdfLkSRmNRlWpUkWNGjXSqFGj5Orq+lhiiIiI0OHDh5WQkFDomD59+sje3l7z589/LDEBAAAAAAAAAAAAAAAAAB4/kkSBYhIbG6uZM2eqf//+Gj58uIxGo3755RfFx8frwoULjy1JtCjeffddWVtTSBgAAAAAAAAAAAAAAAAASjKSRIFismTJEnXt2lURERGmtqCgIL322mvKzc21YGT5PfXUU5YOAQAAAAAAAAAAAAAAAADwiFFKECgm6enpqly5coF9d1btbNWqlSZNmqRFixYpKChIDRs2VEREhLKysnTkyBH17NlTDRo0UPfu3XX06FGzdW7evKmpU6cqMDBQ3t7e6ty5s7766qu7xpWbm6tx48bJ19dXhw4dknT7uvlBgwaZxkRHR6thw4Y6evSoevXqpWeeeUadOnXSjh07zNbKysrS5MmT1bRpUz377LOKjIxUfHy8DAaDzpw5c1/vCwAAAAAAAAAAAAAAAADwaFFJFCgmXl5eWr58uWrUqKHg4GBVqlSp0LFbt26Vp6enJk2apNOnT2vatGmys7PTgQMH1L9/f1WsWFEzZszQiBEj9O9//9uUZBoeHq4dO3bozTffVO3atfWvf/1Lw4YN09y5c9W6det8++Tk5GjMmDH67rvvtGTJEtWpU6fQmLKzsxUeHq6+ffsqLCxMsbGxGj58uLZt26YKFSpIkmbOnKnly5dr+PDhevrpp7V582bNnDnzId8cAAAAAAAAAAAAAAAA8NdlZW1j6RCAQpEkChSTd999V2+88YbGjx8vSapRo4Zatmyp/v37q0aNGvnGf/LJJypVqpQk6bvvvtM///lPxcbGqkWLFpJuVwAdPHiwjh07prp16+p///uftmzZookTJ6pnz56SpBYtWigpKanAJNGsrCyNGDFC//vf//TFF1+oVq1ad40/L0k0KChIkuTu7q7WrVvrm2++UefOnZWWlqYvv/xSQ4YM0cCBAyVJzZs3V//+/XXu3LkHf3EAAAAAAAAAAAAAAAAAgEeC6+aBYlKnTh0lJCQoJiZGffv2laOjo5YsWaIXXnhBR44cMRvbpEkTU4KoJNWqVUvW1tby8/Mza5NkSsD84YcfJEnt27c3W6tDhw76+eefdf36dVPbjRs3NGjQIJ04cUJLly69Z4KoJFlbW6tZs2am5xo1aqhMmTJKTk6WJB07dkw3b97Ml4xaUAVTAADw/9i777Cq6///4w+2i+keqbiOISiCE1AEc2uO3EnO3HsUltrHleZIE9TSNM0VpX7MkVjpVz9laUPLrBypuTWSIYpsfn94cX6dAANF30r323VxXZzXej7P+xzTP549XwAAAAAAAAAAAAAAGI8iUSAf2dvbKzAwUK+++qq2bdumd999V4mJiVq6dKnFOicnJ4vXdnZ2KlSokEXhqJ2dnSQpKSlJkhQXFyc7Ozu5uLhY7C1RooQyMjIUHx9vHouOjta3336rwMBAlStXLle5/z1+Zg6Z8aOioiTJfPV8puLFi+fqfAAAAAAAAAAAAAAAAADAo0WRKPAQNWnSRDVr1tSZM2ce+CxnZ2elpKQoLi7OYvzPP/+UlZWVHB0dzWPlypXTggULtH79ei1fvvyBY0tSyZIlJUkxMTEW4zdu3MiX8wEAAAAAAAAAAAAAAAAA+YsiUSCf/Pnnn1nGEhMTdfXqVZUoUeKBz/f19ZUkRUZGWoxHRkbKw8NDRYoUsRhv3bq15s6dqyVLlmjNmjUPHL969epycHDQ559/bjH+99cAAAAAAAAAAAAAAAAAgMeDrdEJAAVFhw4dFBQUpICAAJUqVUrXr1/X+vXrFRMTo759+z7w+TVr1lTLli01d+5cJSYmyt3dXdu3b9fRo0e1bNmybPc8++yzSkpK0rRp01SoUCH17NnzvuO7urqqV69eevvtt+Xg4KCnn35akZGR+v333yVJ1tbUnAMAAAAAAAAAAAAAAADA44QiUSCfjBw5Uv/3f/+nuXPnKjo6Wq6urjKZTFqzZo0aNWqULzHmz5+vN998UytXrlRsbKyqVKmiJUuWKDg4OMc93bp1U1JSkqZPn65ChQqpU6dO9x1/woQJSk1N1YoVK5Senq4WLVpo8ODBmjFjhsV19wAAAAAAAAAAAAAAAAAA41llZGRkGJ0EgCfXpEmT9P3332vfvn33tT/qZkI+Z5R7/zsfa1jsZpVdDIlb3LGIIXElKe72HUPipqYb99dc9J00Q+KWd7QzJK4kFSlcyLDYAAAAAAAAAAAAAAAYwX3wZqNTgKRzK7oancJjiU6iAHLtm2++0ZEjR1SrVi2lp6dr//792rFjh0JDQ41ODQAAAAAAAAAAAAAAAADwNxSJAsi1IkWKaP/+/Vq5cqWSkpJUvnx5hYaGql+/fkanBgAAAAAAAAAAAAAAAAD4G4pEAeSap6enPvjgA6PTAAAAAAAAAAAAAAAAAADkgrXRCQAAAAAAAAAAAAAAAAAAACD/USQKAAAAAAAAAAAAAAAAAABQAFEkCgAAAAAAAAAAAAAAAAAAUADZGp0AAAAAAAAAAAAAAAAAAABPKmtrK6NTAHJEJ1EAAAAAAAAAAAAAAAAAAIACiCJRAAAAAAAAAAAAAAAAAACAAogiUQAAAAAAAAAAAAAAAAAAgALI1ugEAPy7ud66aFjsNtUqGRbb4fy3hsRNLl3dkLiSVOjHvYbEzWjQyZC4kuRQzJi/Zm2TbxkSV5KS0lMMietQ1NGQuAAAAAAAAAAAAAAAAI8zOokCAAAAAAAAAAAAAAAAAAAUQBSJAgAAAAAAAAAAAAAAAAAAFEAUiQIAAAAAAAAAAAAAAAAAABRAtkYnAAAAAAAAAAAAAAAAAADAk8rK2sroFIAc0UkUAAAAAAAAAAAAAAAAAACgAKJIFAAAAAAAAAAAAAAAAAAAoACiSBQAAAAAAAAAAAAAAAAAAKAAokgUyAdhYWEymUwymUyqWbOmfH191aFDB82YMUNnzpyxWBscHKwZM2bk6fzDhw/LZDLpp59+yrd8jxw5ki9nAQAAAAAAAAAAAAAAAAAeT7ZGJwAUFIUKFdLatWslSbdv39apU6cUERGhDz/8ULNnz1bHjh0lSeHh4XJycjIyVYWHh6tIkSLy8fExNA8AAAAAAAAAAAAAAAAAwMNDkSiQT6ytreXt7W1+7e/vr969e2vw4MF69dVX5ePjo6eeekoeHh7GJQkAAAAAAAAAAAAAAAAA+NfgunngIXJwcNDUqVOVkpKijz76SFLW6+aPHj2qoUOHKiAgQN7e3urYsaO2bduW7XnR0dEaOXKkvL29FRAQoLfffjvLmjNnzmjYsGHy9fWVt7e3Bg8erAsXLpjnTSaTJGnevHkymUwymUw6fPiwJCkjI0OrVq1Sq1at5OnpqebNm2vNmjUW51+7dk1jxoyRn5+fvLy8FBwcrNdff/1BHhMAAAAAAAAAAAAAAAAA4CGgkyjwkFWrVk2lS5fW0aNHs52/cuWKfHx81KtXL9nb2+vIkSOaMmWKMjIy1LlzZ4u1U6dOVbt27RQWFqavvvpKixYtkrOzs3r16iVJunjxonr27Knq1atr7ty5srKy0ttvv61+/fopMjJS9vb2ioiIUI8ePRQSEqL27dubc5Sk2bNn66OPPtLQoUNVp04dHTlyRAsWLJCDg4M5xksvvaQ//vhDU6ZMUfHixXX16lUdP378YT0+AAAAAAAAAAAAAAAA4LFmZWVldApAjigSBR6BsmXL6s8//8x2rl27dubfMzIyVL9+fV2/fl0RERFZikQbNWqkl19+WZLUpEkT3bhxQ8uXL1ePHj1kbW2t8PBwOTs767333pODg4MkycfHR82bN9dHH32k559/Xt7e3uacMn+XpAsXLmj9+vWaPn26evToIUny8/NTYmKili5dao7x008/afz48Wrbtq15b6dOnR70EQEAAAAAAAAAAAAAAAAA8hlFosAjkJGRkeP/MRAXF6ewsDDt3btX169fV1pamiTJxcUly9oWLVpYvG7VqpU+/vhjXbt2TeXKldPBgwfVtm1b2djYKDU1VZLk5OQkDw+Pf+z2+dVXX0mSWrZsad4r3S0UXblypa5evary5cvLw8NDq1evlo2Njfz9/VWpUqVcPwcAAAAAAAAAAAAAAAAAwKNDkSjwCFy7dk2VK1fOdi40NFRHjx7ViBEjVK1aNRUrVkybNm3S7t27s6x1c3OzeF2iRAlJUlRUlMqVK6eYmBitXbtWa9euzbLXzs7unjnGxMQoIyNDjRo1ynY+s0h00aJFWrRokRYvXqzp06fL3d1d48ePV8uWLe95PgAAAAAAAAAAAAAAAADg0aJIFHjITp8+revXr2e5Ol6SkpKStH//foWGhiokJMQ8vnHjxmzPio6OtnideYV9yZIlJUnOzs4KDAxU7969s+wtWrToPfN0dnaWlZWVNm7cmG1Bqbu7uySpVKlSmjNnjtLT03X8+HEtX75c48aNU2RkpJ566ql7xgAAAAAAAAAAAAAAAAAAPDoUiQIPUVJSkmbOnCl7e3t169Yty3xycrLS09MtijJv3bqlffv2ZXveZ599ZnHl/J49e1SqVCmVKVNGktS4cWOdPn1aHh4esrGxyTEvOzs7JSUlWYw1btxYkhQbG6vg4OB/fG/W1taqXbu2xo4dq3379un8+fMUiQIAAAAAAAAAAAAAAADAY4QiUSCfpKen64cffpAkJSQk6NSpU4qIiNDFixc1d+5cVahQIcseR0dHeXl5aeXKlXJzc5Otra1WrFihYsWKZekaKkmHDh3SG2+8IX9/fx08eFAff/yxpk2bJmtra0nS6NGj1bVrVw0cOFDdu3dXiRIl9Oeff+qbb75RvXr11L59e0lSlSpVtHfvXtWrV0+FCxeWu7u73N3d9fzzz+ull17SwIEDVadOHaWkpOj333/X4cOHtWzZMsXHx2vgwIHq2LGj3N3dlZKSonXr1snJyUkeHh4P7+ECAAAAAAAAAAAAAAAAAPKMIlEgnyQmJqpHjx6SpCJFiqhChQpq3LixwsPDVbVq1Rz3LVy4UNOmTVNoaKhcXFwUEhKihIQErV69OsvaGTNmKCIiQps2bVLRokU1ZswYPf/88+b5SpUq6aOPPtLixYs1ffp0JSQkqGTJkqpfv75MJpN53bRp0/T666/rxRdfVGJiot5//301bNhQU6ZMkbu7uyIiIrR06VIVLVpU7u7uat26tSTJwcFBNWrU0Lp163T16lUVKlRInp6eWrVqldzc3PLrUQIAAAAAAAAAAAAAAABPDGtrK6NTAHJklZGRkWF0EgD+vVKvnDQsdrJrJcNiO5z/1pC4aaWrGxJXkjJ+3GtM3AadDIkrSamyNiSufcptQ+JKUoatgyFxHYo6GhIXAAAAAAAAAAAAAADTqG1GpwBJJ8M6GZ3CY8mY6hUAAAAAAAAAAAAAAAAAAAA8VBSJAgAAAAAAAAAAAAAAAAAAFEAUiQIAAAAAAAAAAAAAAAAAABRAFIkCAAAAAAAAAAAAAAAAAAAUQBSJAgAAAAAAAAAAAAAAAAAAFEAUiQIAAAAAAAAAAAAAAAAAABRAtkYnAAAAAAAAAAAAAAAAAADAk8rK2sroFIAc0UkUAAAAAAAAAAAAAAAAAACgAKJIFAAAAAAAAAAAAAAAAAAAoADiunkAhsqwdTAsdvSdVMNil3EsYUjcDNtChsSVpIyGXQyJaxN3xZC4knTVtpQhcSukxhkSV5LSXMobEvdyzG1D4kpSedeihsUGAAAAAAAAAAAAAAC4FzqJAgAAAAAAAAAAAAAAAAAAFEAUiQIAAAAAAAAAAAAAAAAAABRAFIkCAAAAAAAAAAAAAAAAAAAUQBSJAgAAAAAAAAAAAAAAAAAAFEC2RicAAAAAAAAAAAAAAAAAAMCTysrayugUgBzRSRQAAAAAAAAAAAAAAAAAAKAAopMoAAAAAAAAAAAAAAAAAAD4Vztz5oxmzZqlo0ePqmjRourYsaPGjh0re3v7HPccPnxYL7zwQrZz7u7uioyMvOe6tm3batGiRfnzBnJAkShggO3bt2vjxo06efKkJKlGjRrq1auXOnXqZF4TGhqq48ePa+fOnQ89n61bt2ry5Mn6+uuv5ebmpps3b2rt2rVq06aNqlWr9tDjAwAAAAAAAAAAAAAAAIBR4uLi1LdvX1WuXFlhYWG6fv265s6dq8TERE2bNi3HfbVq1VJERITF2K1bt/Tiiy+qadOmWdbPmTNHVapUMb92dXXNvzeRA4pEgUds5syZ2rBhg5577jkNHz5cVlZW2rNnj0JDQ/XTTz9p6tSpjzynZs2aKSIiQk5OTpKkmzdvKjw8XNWrV6dIFAAAAAAAAAAAAAAAAECB9sEHH+j27dsKDw+Xi4uLJCktLU3Tp0/XkCFDVLp06Wz3FStWTN7e3hZjW7duVXp6utq3b59lffXq1eXl5ZXf6d8TRaLAI7R3716tX79eI0eO1KhRo8zjTZo0UalSpbR06VL5+/srODj4kebl5uYmNze3RxoTAAAAAAAAAAAAAAAAAB4H//vf/9S4cWNzgagktWnTRq+99poOHjyoLl265PqsnTt3qnLlyqpdu/ZDyDTvrI1OAPg3Wbt2rZydnTVgwIAscwMHDpSzs7PWrl1rMX7gwAG1b99eXl5e6tKli3744Ycse7du3aoOHTrIy8tLTZo00aJFi5SWlmaev3nzpqZMmaImTZrIy8tLgYGBGjdunMV+k8mk6OhoXbp0Sc2bN5ckjRkzRiaTSSaTSZcuXVKXLl00YcKELPHnz5+vgIAAi5gAAAAAAAAAAAAAAAAA8Kg0b978nj/3cvbsWYtr4CXJyclJJUuW1NmzZ3Odw59//qlDhw5l20VUkgYPHqynn35aTZs21RtvvKHExMRcn32/6CQKPCKpqak6evSomjVrpqJFi2aZL1q0qBo2bKgDBw4oNTVVkhQVFaXp06dr1KhRcnJy0sqVKzVw4EB9+umnKl68uCTpvffe0/z589W3b1+FhobqzJkz5iLRiRMnSpLmzJmjL774QhMmTFD58uUVFRWl//3vf9nmWapUKYWHh2vkyJEaP368GjZsaB7v1q2b5s6dq/j4eDk6Okq621b5448/VufOnWVjY5Pvzw0AAAAAAAAAAAAAAAB4nFlbWRmdAh7QzZs35eTklGXc2dlZcXFxuT7nk08+UVpaWpYiUUdHRw0aNEj169eXg4ODDh06pNWrV+vs2bN65513Hjj/e6FIFHhEYmJilJycrLJly+a4pmzZskpKSlJsbKwkKTY2VosXL1bjxo0lSQ0aNFBgYKDWrFmjCRMm6NatW1qyZIkGDRqk8ePHS5L8/f1lZ2enuXPnauDAgXJ1ddVPP/2k9u3bq3PnzuZY7dq1yzYHe3t7Pf3005KkSpUqydvb2zzXoUMHvfHGG9qxY4d69+4t6W6n06ioKD333HP3/WwAAAAAAAAAAAAAAAAA4EHs3bvX6BS0Y8cO1apVS+7u7hbjHh4e8vDwML9u3LixSpUqpRkzZujYsWMP9Wp6rpsHHmOOjo7mAtHM135+fvrxxx8lSUePHlVCQoJat26t1NRU84+fn58SExN1+vRpSXf/I/Pf//5Xq1at0qlTp+47n2LFiqlNmzbasmWLeWzr1q2qV6+eKleufN/nAgAAAAAAAAAAAAAAAIBRnJycFB8fn2U8Li5Ozs7OuTrjwoULOnbsmJ599tlcrW/Tpo0k6fjx47lP9D7QSRR4RFxdXWVvb6+rV6/muObq1atycHCQi4uLJMnNzS3LmuLFi+vMmTOS7nYnlWTRIfTv50nS1KlT5ezsrPfee0/z5s1T2bJlNXjwYHM30Lzo3r27evbsqRMnTqhUqVLav3+/ZsyYkedzAAAAAAAAAAAAAAAAAOBxUKVKFZ09e9ZiLD4+XlFRUapSpUquztixY4esra3Vtm3bh5HifaNIFHhEbG1tVbduXX3zzTdKSEhQkSJFLOYTEhL0zTffqG7durK1vftHMzo6Oss5N27cUMmSJSXJXKUeHh6uMmXKZFlboUIFSXc7kL766qt69dVXdfLkSb3//vuaPn26atSooXr16uXpfdStW1fVq1fXli1bVK5cOdnb26t169Z5OgMAAAAAAAAAAAAAAAAAHhdNmzbV22+/rZs3b8rJyUmSFBkZKWtra/n7++fqjF27dqlBgwYqVapUrtdLkpeX1/0lnUtcNw88Qn379lVsbKxWr16dZW716tWKjY1V3759zWPx8fH6+uuvLV5/9dVXqlOnjqS7BZuFCxfWtWvX5OXlleXH1dU1SxyTyaTJkydLkrkj6d/Z2dlJkpKSkrKd79atm3bs2KHNmzerbdu2WQpeAQAAAAAAAAAAAAAAAOBJ0bNnTxUtWlQjRozQl19+qS1btmjevHnq2bOnSpcubV7Xt29ftWjRIsv+X375RWfOnFH79u2zPX/ixIkKCwvT3r179eWXX2rBggV644039Mwzzzz0IlE6iQKPUPPmzdWnTx+Fh4fr2rVr5g6cn376qT788EP16dNHwcHB5vUuLi569dVXNXr0aDk6OmrlypXKyMgwF5I6OTlp9OjRmj9/vq5du6YGDRrIxsZGFy9e1N69exUWFqbChQurZ8+eatGihapXry4bGxtt27ZNdnZ2OXYRLVmypJycnLRr1y5VqFBB9vb2MplMsre3lyR17NhRCxYsUExMjGbPnv2QnxoAAAAAAAAAAAAAAAAAPDzOzs5au3atZs6cqREjRqho0aLq2rWrxo0bZ7EuPT1daWlpWfbv2LFD9vb2atWqVbbnV69eXTt27NDq1auVkpKi8uXLa+jQoRo8ePBDeT9/ZZWRkZHx0KMAsLB9+3Zt3LhRJ0+elCTVqFFDvXr1UqdOncxrQkNDdfz4cU2cOFHz5s3ThQsXVL16dU2dOlU+Pj4W5+3atUvvvfeeTp8+LVtbW1WsWFHNmjXTiBEjZGtrq3nz5umLL77QpUuXZG1trRo1amjEiBEKCAiQJG3dulWTJ0/W119/LTc3N0nS559/rjfffFMXL15UcnKy9u7da76+XpIGDhyoa9eumdse36+UP35/oP0P4rptCcNil7lz0ZC4aU5lDYkrSRm2DobEtYm7YkhcSbpkm7v24fmtQuofhsSVpFSX8obEjb6T9R9gj0p516KGxQYAAAAAAAAAAAAAGK/W+B1GpwBJP7/ZwegUHksUiQLIs1u3bqlJkyYaNWqUBgwY8EBnUST6aFEk+mhRJProUCQKAAAAAAAAAAAAADCK58SdRqcASccXZH/V+78d180DyLVbt27pzJkz2rhxo6ysrNSlSxejUwIAAAAAAAAAAAAAAAAA5IAiUQC59vPPP+uFF15Q2bJl9cYbb8jFxcXolAAAAAAAAAAAAAAAAAAAOaBIFECuNWzYUCdPnjQ6DQAAAAAAAAAAAAAAAABALlgbnQAAAAAAAAAAAAAAAAAAAADyH0WiAAAAAAAAAAAAAAAAAAAABRBFogAAAAAAAAAAAAAAAAAAAAUQRaIAAAAAAAAAAAAAAAAAAAAFkK3RCQAAAAAAAAAAAAAAAAAA8KSysrYyOgUgR3QSBQAAAAAAAAAAAAAAAAAAKIAoEgUAAAAAAAAAAAAAAAAAACiAuG4egKHSipU0LHZyQrphsTPsixoT2Mq49ubWd2IMiXu7WFlD4kpSMYO+Yhk2Bn2/JCWnZRgSt5Ctcd/tuNt3DIvtXLSwYbEBAAAAAAAAAAAAAMDjj06iAAAAAAAAAAAAAAAAAAAABRBFogAAAAAAAAAAAAAAAAAAAAUQRaIAAAAAAAAAAAAAAAAAAAAFkK3RCQAAAAAAAAAAAAAAAAAA8KSytrYyOgUgR3QSBQAAAAAAAAAAAAAAAAAAKIAoEgUAAAAAAAAAAAAAAAAAACiAKBIFAAAAAAAAAAAAAAAAAAAogCgSRa6FhYWpbt26eZ57nAUHB2vGjBlGp/FAPv/8c23YsOGhnH348GGZTCb99NNPD+V8AAAAAAAAAAAAAAAAAMDDQ5Eo8IT7/PPPtWnTpodydq1atRQREaGqVas+lPMBAAAAAAAAAAAAAAAAAA+PrdEJAE+ixMREFSpUyOg0HrpixYrJ29vb6DQAAAAAAAAAAAAAAAAAAPeBTqJ4KJKTk/Xmm28qKChInp6eatOmjXbs2GGxJjQ0VO3bt9dXX32lDh06qHbt2urTp48uXbqk2NhYjRkzRj4+PnrmmWf0ySefZInxwQcfqFWrVvL09FRwcLCWLVum9PR0izXXr1/XSy+9JD8/P9WuXVutW7fW2rVrs5y1YcMGBQUFydfXV8OHD1d0dLR5LvPK9f3792v06NHy8fHRmDFjJEmXL1/W6NGj5evrK29vbw0cOFAnT560ODvzSvs1a9YoMDBQdevWVWhoqJKTk/Xrr7+qZ8+e8vb2VteuXbPsXb16tZ577jn5+vqqcePGGjJkiM6dO2fxDP/73//q9OnTMplMMplMCg0NNc9/+umn6tixo7y8vBQQEKA5c+YoKSnJPJ+SkqI33nhDzZo1k6enpwICAjR06FDFx8dbvPe/Xje/efNmtWvXTrVr11bDhg3Vq1cvHTt2LMszBQAAAAAAAAAAAAAAAAAYi06iyLPU1NQsY38vzhwzZoyOHDmiESNGqGrVqjpw4IAmTZokJycnBQYGmtdFRUVp7ty5GjZsmGxtbTVr1ixNnDhRhQsXVr169dS9e3d9+OGHmjRpkurUqaPy5ctLktatW6dZs2YpJCREzZo109GjRxUeHq74+Hi9/PLLkqSYmBj16NFDkjRu3DhVqFBB58+f14ULFyxy3bdvn86fP69p06YpJiZGc+bM0cyZM7Vo0SKLdVOnTtWzzz6rpUuXytraWrdu3VJISIisra01ffp0OTg4aPny5erTp4+2b9+usmXLmvfu3btX1atX14wZM3Tx4kXNnTtXdnZ2+uGHH9SvXz+VKFFCCxYs0JgxY/TJJ5/I2vpu/fa1a9fUp08flStXTrdu3dIHH3ygnj17as+ePXJxcTEXtJ49e1YLFiyQJLm5uZljjh49Wu3atdOECRN09uxZLVq0SFevXtWSJUskSe+8844++OADTZw4UdWrV1dMTIwOHjyo5OTkbD/7b7/9Vq+++qoGDBigwMBAJSYm6tixY+aiUgAAAAAAAAAAAAAAAODfxopWjXiMUSSKPElISFCtWrWynStSpIgk6dChQ9q3b59WrVqlgIAASZK/v7+ioqIUFhZmUSQaFxen9evXq3r16pKkP/74QzNnztSLL76oESNGSJK8vLz02Wef6fPPP1ffvn2VlpampUuXql27dpoyZYokKSAgQCkpKVq9erUGDx4sV1dXrVmzRjdu3NDu3btVoUIFSVLjxo2z5J2RkaHly5fL3t5e0t3uoO+8847S09PNxZrS3Y6gkyZNMr9+//33deXKFe3atUtVq1aVJNWvX19BQUFau3atRUdPSVq2bJk5xjfffKMPP/xQK1euVNOmTSXdLbQdOnSoTp06pZo1a0qSXnnlFfP+tLQ0+fv7q3HjxtqzZ4969OihihUrys3NTVeuXMlyLXx4eLi8vb21cOFCSVLTpk1VuHBhTZs2TSdPnjR3CA0ICNDzzz9v3teqVatsP19JOnbsmFxcXMyFuJLUrFmzHNcDAAAAAAAAAAAAAAAAAIxDDTPypFChQtq8eXOWn+7du5vXHDx4UC4uLmrUqJFSU1PNP35+fvr111+VlpZmXluqVClzgagkVa5cWZLk5+dnHnNycpKbm5uuXbsmSTp79qxiYmLUunVri9zatm2rlJQU89XnX3/9tRo1amQuEM1J/fr1zcWbklS1alWlpKToxo0bFuv+Xgz53XffqXr16uYCUUlycXGRn5+fvv/++3vGqFy5sqytrdWoUaMs7/3q1avmsR9++EH9+/dXw4YN5eHhoTp16ighIUG///77Pd/T7du39euvv2Yp+Gzbtq0kmfPz8PDQgQMHFBYWpmPHjmXpCPt3Hh4eio2NVWhoqA4ePKg7d+7ccz0AAAAAAAAAAAAAAAAAwDh0EkWeWFtby8vLK8v4/v37zb/HxMQoNjY2x46jUVFRKlOmjKS7BaB/ZWdnJ0lydHS0GLe3t1dSUpKku91HJal48eIWazJfZ87HxsZaFKDm5O85ZBZzZsb7+/mZbt68qRIlSmQ5r3jx4jp9+vQ9Y9jZ2alQoUIWhaOZ7z0z7pUrVzRgwAB5enpq+vTpKlWqlOzs7DRkyJAsuf1dfHy8MjIysuTs6Ogoe3t78zMaNmyYrK2t9d///lfh4eFyc3PT888/rxEjRsjKyirLuY0bN9a8efP0/vvva+DAgXJwcFCrVq30yiuvyMXF5Z45AQAAAAAAAAAAAAAAAAAeLYpEke+cnZ3l5uamFStWZDvv5ub2QOdnFiNGR0dbjGd2/nR2djav++OPPx4o1l/9vWjS2dlZ586dy7Luxo0b5hwexBdffKGEhASFh4ebi0xTU1PNBZ734ujoKCsrqyzPKD4+XsnJyeb87O3tNWrUKI0aNUrnz5/Xli1bFBYWpgoVKqhTp07Znt2xY0d17NhR0dHR2rt3r+bMmSNbW1u9/vrrD/aGAQAAAAAAAAAAAAAAAAD5iuvmke/8/PwUHR0tOzs7eXl5Zfn5a/fM++Hu7i43NzdFRkZajO/evVt2dnaqXbu2pLtdLw8dOqQrV648ULyc+Pr66tSpUzp79qx5LC4uTl999ZV8fX0f+PzExERZWVnJ1vb/13Lv3r1bqampFuvs7OyydBYtWrSonn766WyfUWbuf1epUiWNHz9eLi4uFu8pJ25uburWrZv8/f1ztR4AAAAAAAAAAAAAAAAA8GjRSRT5zt/fX0FBQRo0aJAGDRokk8mkO3fu6LffftP58+c1e/bsBzrfxsZGw4cP16xZs+Tm5qbAwED98MMPWrlypfr27StXV1dJUr9+/fTxxx+rT58+GjZsmJ566ildvHhRv//+uyZNmvTA77NLly5as2aNhgwZorFjx8rBwUHLly+Xra2t+vbt+8DnN2rUSJI0efJk9ezZU6dPn9Z7772X5er6qlWrasuWLdq5c6cqVaokV1dXVahQQSNHjtSIESM0ceJEPfvsszp37pwWLVqkVq1ayWQySZKGDx+uWrVqycPDQ4ULF9b//d//KS4uzhz775YsWaLY2Fg1aNBAxYsX16lTp/TFF1+oX79+D/x+AQAAAAAAAAAAAAAAAAD5iyJRPBRLlizRihUrtGnTJl2+fFmOjo6qXr26unTpki/nh4SEyNbWVmvWrNGmTZtUsmRJjRw5UkOHDjWvcXV11aZNm7Rw4UItWLBAd+7cUfny5dW7d+98yaFYsWJat26d5s6dq6lTpyo9PV0+Pj5av369ypYt+8Dnm0wmzZkzR+Hh4RoyZIiefvppvfXWWxo7dqzFuq5du+rYsWOaOXOmYmNj1blzZ82dO1fNmzfXW2+9paVLl2r48OFycXFR9+7dNWHCBPNeHx8f7d69W++9957S0tLk7u6uBQsWyM/PL9ucvLy8tHbtWu3evVu3bt1SmTJlNHDgQA0bNuyB3y8AAAAAAAAAAAAAAAAAIH9ZZWRkZBidBIB/r8SE24bFvpKQbljspzJiDImbXtjZkLiSZJVszGedYO9iSFxJSjHoK+acdtOYwJLu2BvzHUtNN+6fM7bWVobFdi5a2LDYAAAAAAAAAAAAAIC76r662+gUIOno7DZGp/BYsjY6AQAAAAAAAAAAAAAAAAAAAOQ/ikQBAAAAAAAAAAAAAAAAAAAKIIpEAQAAAAAAAAAAAAAAAAAACiCKRAEAAAAAAAAAAAAAAAAAAAogikQBAAAAAAAAAAAAAAAAAAAKIIpEAQAAAAAAAAAAAAAAAAAACiBboxMAAAAAAAAAAAAAAAAAAOBJZW1tZXQKQI7oJAoAAAAAAAAAAAAAAAAAAFAAUSQKAAAAAAAAAAAAAAAAAABQAHHdPABDXbyVbljsikUNC61Um1KGxLW5E2tIXEmySks1JG7RO38aEleSrJJvGxL3epGKhsSVpELpGYbE/exsjCFxJalZZRfDYhc7/6MhcW0q1TEkLgAAAAAAAAAAAAAAyBs6iQIAAAAAAAAAAAAAAAAAABRAFIkCAAAAAAAAAAAAAAAAAAAUQBSJAgAAAAAAAAAAAAAAAAAAFEAUiQIAAAAAAAAAAAAAAAAAABRAtkYnAAAAAAAAAAAAAAAAAADAk8rK2sroFIAc0UkUAAAAAAAAAAAAAAAAAACgAKJIFAAAAAAAAAAAAAAAAAAAoACiSLSAefbZZ2UymfTdd9/lad+aNWt04MCBfM/HZDJp1apVedqzdetWmUwmRUdH57jm0qVLMplMioyMzNOc0W7evKmwsDD99ttvhuZxP58LAAAAAAAAAAAAAAAAAODJQpFoAXL69GmdPHlSkrRjx4487X3//fcfSpFoRESEOnTokO/nPqlu3ryp8PBww4tE+VwAAAAAAAAAAAAAAAAAoOCjSLQA2bFjh6ytrdWwYUNFRkYqJSXlH/ckJiY+lFwyz/X29lapUqUeSownzcN61veDzwUAAAAAAAAAAAAAAAAACj6KRAuIjIwM7dy5U40aNVL//v0VGxurL774wmLN4cOHZTKZtH//fo0ePVo+Pj4aM2aMgoODdfnyZW3YsEEmk0kmk0lbt24179u6das6dOggLy8vNWnSRIsWLVJaWprFvMlk0tGjR9W/f395e3tr3rx5krJea75//371799fjRs3lo+Pj7p166b//e9/D/XZrFu3TnXq1NGtW7csxs+cOSOTyWTuoBoSEqIhQ4Zo27ZteuaZZ1S7dm2FhITo7NmzFvsyMjK0atUqtWrVSp6enmrevLnWrFljsSYsLEx169bVsWPH1KNHD3l5eWnDhg1q3ry5JGnMmDHmZ33p0iVJUnJyst58800FBQXJ09NTbdq0ydIRNjQ0VO3bt9fhw4fVqVMneXt7q2vXrjp+/LjFus2bN6tdu3aqXbu2GjZsqF69eunYsWPm+eyum//ggw/M7yk4OFjLli1Tenq6eT7zc/7ll180aNAgeXt7q2XLltq2bVsuPwkAAAAAAAAAAAAAAAAAwKNka3QCyB9HjhzR5cuXNWLECAUEBMjFxUU7d+5UcHBwlrVTp07Vs88+q6VLl8ra2lqOjo4aPHiwfHx8NGDAAElSxYoVJUnvvfee5s+fr759+yo0NFRnzpwxF4lOnDjR4twJEyaoR48eGjJkiAoXLpxtnpcuXVJQUJAGDBgga2tr/e9//9PgwYO1du1aNWzYMM/vOz09XampqVnG/urZZ5/V/PnztXPnTvXs2dM8vnnzZpUuXVoBAQHmsZ9//lkXLlzQhAkTJEmLFy/WoEGDFBkZKXt7e0nS7Nmz9dFHH2no0KGqU6eOjhw5ogULFsjBwUG9evUyn5WSkqIJEyaoX79+GjdunFxcXBQeHq6RI0dq/Pjx5veb2dFzzJgxOnLkiEaMGKGqVavqwIEDmjRpkpycnBQYGGg+NyoqSrNmzdLgwYPl6OiohQsXauTIkfrss89kZ2enb7/9Vq+++qoGDBigwMBAJSYm6tixY4qPj8/xOa5bt06zZs1SSEiImjVrpqNHjyo8PFzx8fF6+eWXLdZOnDhR3bt3V//+/fXhhx8qNDRUXl5eqlq16j9/YAAAAAAAAAAAAAAAAACAR4Yi0QJi586dcnBwUMuWLWVnZ6dWrVpp+/btun37tooWLWqxNjg4WJMmTbIYs7e3V4kSJeTt7W0eu3XrlpYsWaJBgwZp/PjxkiR/f3/Z2dlp7ty5GjhwoFxdXc3re/bsqcGDB98zzz59+ph/T09PV8OGDfXbb7/pww8/vK8i0XHjxv3jGmdnZ7Vq1UpbtmwxF4mmpqZq+/bt6tq1q2xsbMxrb9y4ofXr16ty5cqSJA8PD7Vu3Vpbt25Vz549deHCBa1fv17Tp09Xjx49JEl+fn5KTEzU0qVL1aNHD1lb323Qm5KSonHjxqlt27bm84sVKyZJqlSpksWzPnTokPbt26dVq1aZi1b9/f0VFRWlsLAwiyLRuLg4rV+/XtWrV5ckFS5cWC+88IJ+/PFH1atXT8eOHZOLi4tFcWezZs1yfD5paWlaunSp2rVrpylTpkiSAgIClJKSotWrV2vw4MEWn/Pzzz+v559/XpJUt25dHThwQHv27NHw4cP/8bMAAAAAAAAAAAAAAAAAChorayujUwByxHXzBUBqaqoiIyMVGBgoR0dHSVKHDh10584dffbZZ1nW36tg8K+OHj2qhIQEtW7dWqmpqeafzKLI06dP5/nca9eu6eWXX1aTJk3k4eGhWrVq6csvv9S5c+dyldPfTZw4UZs3b7b4Wb58eZZ13bt317Fjx8w5HzhwQDdu3NBzzz1nsa569ermAlHpbjFnzZo19eOPP0qSvvrqK0lSy5YtszyTqKgoXb161eK8vxZ33svBgwfl4uKiRo0aZTn3119/VVpamnltqVKlzAWiklStWjVJ0vXr1yXdLWyNjY1VaGioDh48qDt37twz9tmzZxUTE6PWrVtbjLdt21YpKSkW19RLsui8WqRIEZUrV07Xrl3L1fsEAAAAAAAAAAAAAAAAADw6dBItAA4ePKjo6GgFBQXp5s2bkqQaNWqoZMmS2rlzpzp16mSxvnjx4rk6NyYmRpLUuXPnbOf/XhBZokSJe56Xnp6uYcOGKT4+XqNHj1alSpVUuHBhLVmyJMtZufXUU0/Jy8vLYuzSpUtZ1tWvX1/u7u7avHmzJk+erC1btqh+/fqqWLGixbrsnk3x4sUVFRUl6e4zycjIUKNGjbLN5+rVqypfvrykux0+/97FNScxMTGKjY1VrVq1sp2PiopSmTJlJElOTk4Wc3Z2dpKkpKQkSVLjxo01b948vf/++xo4cKAcHBzUqlUrvfLKK3JxcclydlxcnPl9/lXm68z5TJmFyH+Nn5ycnJu3CQAAAAAAAAAAAAAAAAB4hCgSLQB27NghSZo8ebImT55sMRcTE6MbN25YFABaWeWuvbGzs7MkKTw83Fyg+FcVKlTIU57nz5/XL7/8oqVLl+qZZ54xjycmJubpnPvVrVs3vfvuu+rfv78OHDig2bNnZ1lz48aNbMdq1qwp6e4zsbKy0saNG83FmX/l7u5u/j23zznzXDc3N61YsSLbeTc3t1yfJUkdO3ZUx44dFR0drb1792rOnDmytbXV66+/nmVtZuFodHS0xXjms8j8HgAAAAAAAAAAAAAAAAAAniwUiT7h7ty5o7179+qZZ57RCy+8YDH3559/avz48frkk08UEhJyz3Ps7OzMnSgz1a1bV4ULF9a1a9fUokWLB8418/y/FldevnxZR48etbji/WHp3LmzFi1apIkTJ6pQoUJZrleXpNOnT+v8+fOqVKmSpLuFrSdOnFCPHj0k3e3SKUmxsbEKDg7Ocw5/7/qZyc/PT++++67s7OzMBan5wc3NTd26ddP//vc/nT17Nts17u7ucnNzU2RkpMXnvHv3btnZ2al27dr5lg8AAAAAAAAAAAAAAAAA4NGhSPQJt3fvXiUkJCgkJEQNGzbMMv/uu+9q586d/1gkWqVKFR06dEgHDx6Uk5OTKlSoIFdXV40ePVrz58/XtWvX1KBBA9nY2OjixYvau3evwsLCVLhw4VznWqVKFZUpU0YLFy5Uenq6EhIStGTJEpUqVSrP7/t+uLm5qXnz5oqMjFSPHj1UqFChLGuKFy+uoUOHavTo0ZKkt956S6VLl1aXLl0k3S2ofP755/XSSy9p4MCBqlOnjlJSUvT777/r8OHDWrZs2T1zKFmypJycnLRr1y5VqFBB9vb2MplM8vf3V1BQkAYNGqRBgwbJZDLpzp07+u2333T+/Plsu57mZMmSJYqNjVWDBg1UvHhxnTp1Sl988YX69euX7XobGxsNHz5cs2bNkpubmwIDA/XDDz9o5cqV6tu3r1xdXXMdGwAAAAAAAAAAAAAAAADw+KBI9Am3c+dOlStXLtsCUUnq1KmTXn/9dV24cOGe54wfP17/+c9/NGrUKN2+fVtz5sxRly5dNGDAAJUuXVrvvfee1q9fL1tbW1WsWFHNmjXL9rr1e7G3t1dYWJhmzJihMWPGqGzZsho2bJgOHTqk48eP5+ms+9WiRQtFRkaqa9eu2c7XqlVLLVu21Pz58xUVFaU6depo+vTpsre3N6+ZMmWK3N3dFRERoaVLl6po0aJyd3fPtjPp31lbW2vOnDl688031a9fPyUnJ2vv3r2qUKGClixZohUrVmjTpk26fPmyHB0dVb16dXOBam55eXlp7dq12r17t27duqUyZcpo4MCBGjZsWI57QkJCZGtrqzVr1mjTpk0qWbKkRo4cqaFDh+YpNgAAAAAAAAAAAAAAAADg8WGVkZGRYXQSwKPy0ksv6ddff9WOHTuyzIWEhKhIkSJ65513DMjs3+v0H/GGxa5Y1LDQSrfJW5F1frG5E2tIXEmySk02LLZRrJJvGxL3epGKhsSVpEK2VobE/exsjCFxJalZZRfDYpeM/c2QuDaV6hgSFwAAAAAAAAAAAAAeRw1nfGZ0CpB0eFoLo1N4LNFJFP8KJ0+e1K+//qpPPvlEr732mtHpAAAAAAAAAAAAAAAAAADw0FEkin+FYcOGKTo6Wp06ddJzzz1ndDoAAAAAAAAAAAAAAAAAADx0FIniX2Hfvn3/uGbdunWPIBMAAAAAAAAAAAAAAAAAAB4Na6MTAAAAAAAAAAAAAAAAAAAAQP6jSBQAAAAAAAAAAAAAAAAAAKAAokgUAAAAAAAAAAAAAAAAAACgAKJIFAAAAAAAAAAAAAAAAAAAoACyNToBAAAAAAAAAAAAAAAAAACeVFbWVkanAOSITqIAAAAAAAAAAAAAAAAAAAAFEEWiAAAAAAAAAAAAAAAAAAAABRDXzQMwVKmiBv5nKD3JsNAZ1nbGxLUtZEhcScqwK2xQ4Axj4kqySbljSNxSyX8YEleS0gqVMSRu7dKOhsSVpLR0w0IroWQNQ+KeuBBjSFxJql/R1bDYAAAAAAAAAAAAAAA8aegkCgAAAAAAAAAAAAAAAAAAUABRJAoAAAAAAAAAAAAAAAAAAFAAUSQKAAAAAAAAAAAAAAAAAABQAFEkCgAAAAAAAAAAAAAAAAAAUADZGp0AAAAAAAAAAAAAAAAAAABPKitrK6NTAHJEJ1EAAAAAAAAAAAAAAAAAAIACiCJRAAAAAAAAAAAAAAAAAACAAogi0VzYu3evBgwYoAYNGsjT01PBwcGaNm2azp07Z15jMpm0atUqA7O8a+vWrTKZTIqOjn6gc0JDQ2Uymcw/fn5+GjBggI4ePZpPmd6fw4cPy2Qy6aeffrrnOqM/j4MHD6pDhw7y9PRUvXr1JEmxsbEaMWKE6tevL5PJpM8//1yhoaFq3759ns4ODg7WjBkzHkbaAAAAAAAAAAAAAAAAAIACxNboBB53CxYs0MqVK9WqVSvNnDlTbm5uunDhgrZs2aJx48Zp27ZtRqdooVmzZoqIiJCTk9MDn/XUU09pwYIFysjI0MWLFxUWFqb+/ftrx44deuqpp/Ih24Jr8uTJMplMeu211+Tg4CBJeu+993T48GG98cYbKl68uNzd3VWjRg0lJCTk6ezw8PB8+XwBAAAAAAAAAAAAAAAAAAUbRaL3cODAAa1cuVLDhw/XmDFjzOP169fXc889p//7v/974BiJiYkqVKjQA5+Tyc3NTW5ubvlyVqFCheTt7S1Jqlu3ripUqKBevXrpk08+0ZAhQ/IlRkF0+/ZtXb9+XaNHjzZ3EZWkc+fOyWQyqXnz5uYxZ2fnPJ/v4eGRL3kCAAAAAAAAAAAAAAAAAAo2rpu/h9WrV6tEiRIaPnx4tvNBQUEWr9PT0xUWFiY/Pz81bNhQkydPtugSmXkV/NGjR9W/f395e3tr3rx5kqSTJ09q4MCB8vb2lq+vr0aPHq0rV65YnG8ymbRy5cpcxfjrdfPJyclatGiRmjdvLk9PTzVt2lShoaF5fh6ZxYl/z2v//v3q1q2bateurUaNGum1116zyCnziviDBw9qwoQJqlu3roKCgrRy5UqLc44ePaqhQ4cqICBA3t7e6tixY751as281v3w4cPq1KmTvL291bVrVx0/ftxi3ebNm9WuXTvVrl1bDRs2VK9evXTs2DFJ0qVLl2QymRQZGWmxZ/bs2QoODpZ09/n7+PhIkl599VWZTCaFhobKZDJpz549+u6772QymWQymSzy+qvr16/rpZdekp+fn2rXrq3WrVtr7dq15vnsrps/evSoXnjhBfP3Z8KECbpx44Z5PjP3jz/+WDNmzFD9+vUVEBCgN954Q6mpqRZnnTlzRiNHjlSDBg1Up04dPfvss9q5c6ckadSoUerZs2eW57tx40Z5eXkpNjb23h8EAAAAAAAAAAAAAAAAAOCRoZNoDlJTU3XkyBG1bNlSdnZ2udqzYcMG+fr6au7cufr99981b948FS9eXBMnTrRYN2HCBPXo0UNDhgxR4cKFdfXqVfXp00dPPfWU5s+fr6SkJC1atEh9+vTR9u3bVaxYsTzH+KtRo0bp0KFDGjJkiLy9vRUdHa1PP/00z8/k8uXLkqQKFSqYxyIjIzVu3Dh16dJFo0aNUlRUlBYuXKibN29q0aJFFvtfe+01dezYUUuXLtXnn3+uBQsWyGQyqWnTppLuFp/6+PioV69esre315EjRzRlyhRlZGSoc+fOec7376KiojRr1iwNHjxYjo6OWrhwoUaOHKnPPvtMdnZ2+vbbb/Xqq69qwIABCgwMVGJioo4dO6b4+Phcx2jWrJnee+899e/fX8OGDVOzZs3k5uamnj17asGCBbp9+7Zee+21HPfHxMSoR48ekqRx48apQoUKOn/+vC5cuJDjnqNHjyokJESBgYFatGiR7ty5o8WLF2v48OGKiIiwWLt48WI1b95cixcv1tGjRxUWFqaKFSuqV69ekqTff/9dPXr0UNmyZfXqq6+qZMmSOnXqlLkwuFu3bnrxxRd19uxZValSxXzuli1b1KJFC7m4uOT6WQEAAAAAAAAAAAAAAAAFgbW1ldEpADmiSDQHsbGxSk5OVrly5XK9p2TJklq4cKEkqWnTpvrll1+0Z8+eLAWcPXv21ODBg82v58yZo9TUVK1evdpcZPf000+rXbt2+u9//6uQkJA8x8h08OBB7d+/XwsXLrToWPn37pU5SU1NVUZGhi5duqTp06erfPnyeu655yRJGRkZmjdvntq2bavZs2db5Dh48GANHz5c1atXN4+3bNlSo0aNkiQ1btxY+/fv1549e8xFou3atTOvzcjIUP369XX9+nVFRETkS5FoXFyc1q9fb86pcOHCeuGFF/Tjjz+qXr16OnbsmFxcXPTyyy+b9zRr1ixPMdzc3OTp6SlJqlixory9vc2/Ozk5ycrKyjyWnTVr1ujGjRvavXu3uRi3cePG94y5cOFCeXp6Kjw8XFZWd//CqVGjhtq3b68DBw4oMDDQvLZ27dqaMmWKJMnf31+HDx/Wnj17zEWiYWFhsrOz06ZNm8zFyX5+fub9AQEBKleunLZs2aJJkyZJkk6dOqXjx49r/PjxuX1MAAAAAAAAAAAAAAAAAIBHgOvm/0Fm0V1u/LWYTpKqVq2qa9euZVn398LD7777Tg0bNrTowli1alXVrFlT33///X3FyPT111+rcOHCFgWYuXX69GnVqlVLnp6eat26tY4dO6awsDC5ublJks6dO6fLly+rTZs2Sk1NNf80aNBA1tbWWa5yDwgIMP9uZWWVJfe4uDjNmjVLQUFBqlWrlmrVqqWIiAidO3cuz7lnp1SpUhZFq9WqVZN093p3SfLw8FBsbKxCQ0N18OBB3blzJ1/i5sXXX3+tRo0aWXRrvZc7d+7oyJEjat26tdLS0syfQeXKlVW2bFn99NNPFuv/+hlIWb8/hw4dUqtWrSy61/6VtbW1nnvuOX388cfma+q3bNmi8uXL/2MxKwAAAAAAAAAAAAAAAADg0aKTaA5cXFzk4OBgvmY7N5ycnCxe29nZKTk5Ocu6EiVKWLy+efOmnn766Szrihcvrri4uPuKkSk2NlYlS5bMU7FrpooVK+rNN99Uenq6Tpw4ofnz52vs2LHavn27ChcurJiYGEnSiBEjst1/9epVi9eOjo5Zcv/rVe6hoaE6evSoRowYoWrVqqlYsWLatGmTdu/enefcs5Pds5OkpKQkSXc7ds6bN0/vv/++Bg4cKAcHB7Vq1UqvvPLKI7tGPTY21qKQ9Z/cvHlTaWlpmjNnjubMmZNlPjefwV+/P7GxsSpVqtQ9Y3bt2lXLli3TgQMH1LRpU23fvl29e/eWtTU15wAAAAAAAAAAAAAAAADwOKFINAe2trby8fHRoUOHlJqaKlvbh/eonJ2ddePGjSzjN27cUOXKlR/obBcXF0VFRSkjIyPPhaIODg7y8vKSJNWpU0eurq4aNWqU1q1bp8GDB5sLJ6dNm6batWtn2f9PxYZ/lZSUpP379ys0NFQhISHm8Y0bN+Yp5wfVsWNHdezYUdHR0dq7d6/mzJkjW1tbvf7663JwcJAkpaSkWOy5efNmvsV3cXHRH3/8kev1jo6OsrKy0pAhQ/TMM89kmXd1dc33+GXKlFGTJk20ZcsWpaWlKSYmRl26dMlTHAAAAAAAAAAAAAAAAADAw0frv3vo37+/oqKi9Pbbb2c7f+DAgXyJ4+vrq0OHDll0DT179qxOnjwpX1/fBzrbz89Pd+7cyZdunC1btpSPj4/Wrl2rpKQkValSRWXKlNHFixfl5eWV5ad06dK5Pjs5OVnp6enm7p6SdOvWLe3bt++B874fbm5u6tatm/z9/XX27FlJdzu72tnZ6cyZM+Z1ycnJ+vbbb/MtbuPGjXXo0KFcd7AtUqSIvL29dfbs2Ww/g9xeW//X+Hv27NGtW7fuua5bt246cOCAVq9ercaNG6t8+fJ5igMAAAAAAAAAAAAAAAAAePjoJHoPgYGBGjRokMLCwvTbb7+pXbt2cnV11aVLl7RlyxbFx8crMDDwgeP069dPW7du1YABAzRs2DAlJSVp8eLFKlu2rDp37vxAZ/v5+SkwMFCvvPKKLly4oDp16ig2NlZ79uzR4sWL83zeqFGj1L9/f23dulW9evVSaGioJk6cqISEBDVr1kyFCxfWlStXdODAAY0bN07u7u65OtfR0VFeXl5auXKl3NzcZGtrqxUrVqhYsWKKjo7Oc573Y8mSJYqNjVWDBg1UvHhxnTp1Sl988YX69esnSbK2tlaLFi20YcMGVapUSa6urlq/fv19dWnNSb9+/fTxxx+rT58+GjZsmJ566ildvHhRv//+uyZNmpTtnpdeekl9+/bV2LFj1a5dOzk5OenatWv66quv1KVLFzVs2DDX8UeOHKn9+/erd+/eGjRokEqWLKkzZ87ozp07evHFF83rmjVrJldXVx09elRvvvnmA79vAAAAAAAAAAAAAAAAAED+o0j0H0yaNEl169bVhg0b9Morr+jOnTsqVaqUAgICNHDgwHyJUbZsWa1bt07z5s3TxIkTZW1tLX9/f4WGhqpYsWIPfH5YWJjCw8MVERGh8PBwFS9eXP7+/vd1lp+fn3x9fbV69Wp1795dbdq0kZOTk95++23t2LFDklS+fHk1adJEJUqUyNPZCxcu1LRp0xQaGioXFxeFhIQoISFBq1evvq9c88rLy0tr167V7t27devWLZUpU0YDBw7UsGHDzGumTp2qqVOnatasWSpatKgGDhwod3d37d27N19ycHV11aZNm7Rw4UItWLBAd+7cUfny5dW7d+8c9/j4+Gjjxo0KCwvT5MmTlZKSojJlyqhRo0aqVKlSnuJXrlxZH3zwgRYuXKjp06crLS1NlStX1uDBgy3W2draKjg4WJGRkWrRosV9vVcAAAAAAAAAAAAAAAAAwMNllZGRkWF0EgCeLOnp6XrmmWcUFBSkqVOnPtBZcbfv5FNWeVcoPcmw2Gm2hQyJa5OaaEhcSVI+ddzNMwP/mrOJv25I3Awbe0PiSlKaUxlD4p6NSzEkriQ5O9gYFtvJwdqQuCf+NO6/JfUruhoWGwAAAAAAAAAAAACyE/DG/xmdAiR9+XKQ0Sk8lugkCiDXkpOTdeLECe3Zs0fXrl3T888/b3RKAAAAAAAAAAAAAAAAAIAcUCQKINf++OMPdevWTW5ubpo6daqqVKlidEoAAAAAAAAAAAAAAAAAgBxQJAog1ypUqKCTJ08anQYAAAAAAAAAAAAAAAAAIBesjU4AAAAAAAAAAAAAAAAAAAAA+Y8iUQAAAAAAAAAAAAAAAAAAgAKIIlEAAAAAAAAAAAAAAAAAAIACiCJRAAAAAAAAAAAAAAAAAACAAsjW6AQAAAAAAAAAAAAAAAAAAHhSWdGqEY8xvp4AAAAAAAAAAAAAAAAAAAAFEJ1EARjK8dpPhsVOKVXDsNiX41MMiftUMTtD4krSqdhUQ+JejU82JK4kNSz/lCFxoxLSDIkrSekGfberW90wJK4kZVg7Ghc7zZh/ynk7xBoSV5KS44z5fts7lzAkLgAAAAAAAAAAAAAAD4JOogAAAAAAAAAAAAAAAAAAAAUQRaIAAAAAAAAAAAAAAAAAAAAFEEWiAAAAAAAAAAAAAAAAAAAABRBFogAAAAAAAAAAAAAAAAAAAAWQrdEJAAAAAAAAAAAAAAAAAADwpLK2tjI6BSBHdBIFAAAAAAAAAAAAAAAAAAAogCgSBQAAAAAAAAAAAAAAAAAAKIAeiyLRsLAw1a1bN89zT6rQ0FC1b9/e6DQeG59//rlMJpMuXbqU571r1qxRs2bN9PTTT2v48OE6fPiwTCaTfvrpp1yf8SR+xzp06KB+/frlOD937lx5e3vr9u3bCgkJ0ZAhQx5dcgAAAAAAAAAAAAAAAACAx4Kt0QkA9+v333/X3Llz9eKLLyooKEiurq4qWbKkIiIiVLVq1Vyf061bNwUGBj7ETPNf+/bt9dZbbykqKkolS5a0mEtPT9cnn3yi4OBgFS1aVK+99pqsrR+LenAAAAAAAAAAAAAAAAAAwCNE5RieWOfOnVNGRoa6d+8uHx8fubu7q1ixYvL29laRIkVyfU6ZMmVUu3bth5hp/mvfvr25GPTvvv32W12/ft3crbZatWqqUqXKPc9LTEx8KHkCAAAAAAAAAAAAAAAAAIzzxBWJ5nSd+PDhwxUSEmJ+nXmF+C+//KIePXqodu3a6ty5s3755RclJSXptddeU/369dW0aVOtWbPG4qyjR49q6NChCggIkLe3tzp27Kht27Zlm8fBgwc1YcIE1a1bV0FBQVq5cuV9v6cvvvhCY8aMUd26ddWsWTPt2LFDkvT++++rWbNmatCggV599VUlJyeb927dutX8PAYMGKA6deqoVatW+uqrr5Senq5FixbJz89Pfn5+WrhwodLT0817s7v2/ubNmzKZTNq6dat5LDg4WDNmzNCGDRsUFBQkX19fDR8+XNHR0RZ7L1++rNGjR8vX11fe3t4aOHCgTp48abEmJSVFs2fPVoMGDeTr66tXXnlFt2/fzvJMkpOT9eabbyooKEienp5q06aN+Xlk5j506FBJ0jPPPGPOObvvR3p6ut577z21adNGnp6e8vf31+jRoxUfHy8p++vmb968qf/85z8KCAiQp6enunTpoi+//NJiTeY17pGRkWrVqpXq1q2rF154QRcuXMjyXhYtWqTmzZvL09NTTZs2VWhoqCRp3759MplM+v333y32xMXFqXbt2tqwYUOWZyNJ5cuXV926dbVr164sc7t27ZKLi4uaNGlikWemzPd77Ngx9ejRQ15eXtqwYUOu/2xdu3ZNY8aMkZ+fn7y8vBQcHKzXX3892zwBAAAAAAAAAAAAAAAAAMZ5rK6bT01NzTL216LGvEpJSdHLL7+sfv36qUSJElqwYIFGjhwpHx8fFS9eXIsXL9bevXs1Z84c1a5dWz4+PpKkK1euyMfHR7169ZK9vb2OHDmiKVOmKCMjQ507d7aI8dprr6ljx45aunSpPv/8cy1YsEAmk0lNmzbNc77/+c9/1LlzZ3Xv3l0ffvihXnrpJZ04cUKnT5/W9OnTdfHiRc2dO1dPPfWUuUAy08svv6yePXuqf//+WrFihUaOHKnOnTvr1q1beuONN/Tjjz8qLCxMNWrUUIcOHfKc2759+3T+/HlNmzZNMTExmjNnjmbOnKlFixZJkm7duqWQkBBZW1tr+vTpcnBw0PLly9WnTx9t375dZcuWlSS9+eab2rRpk0aNGiUPDw/t2rVLCxcuzBJvzJgxOnLkiEaMGKGqVavqwIEDmjRpkpycnBQYGKjhw4eratWqWrBggcLDw1WyZElVrFhRp0+fznLWzJkzFRERob59+8rf31+3b9/W/v37lZCQIEdHxyzrk5OT1b9/f924cUNjx45V6dKltX37dg0ZMsRclJvp119/VXR0tCZOnKi0tDTNnTtXkyZNUkREhHnNqFGjdOjQIQ0ZMkTe3t6Kjo7Wp59+KkkKDAxU6dKltWXLFk2YMMG8Z+fOnZJ0z8+qffv2mjFjhi5evKinnnpK0t3v/J49e9S6dWvZ2dnluDclJUUTJkxQv379NG7cOLm4uCguLi7H9X/10ksv6Y8//tCUKVNUvHhxXb16VcePH8/VXgAAAAAAAAAAAAAAAADAo/PYFIkmJCSoVq1a2c7l5erwv0pJSdHEiRMVGBgo6W7B6dChQ1WnTh1NnjxZktSoUSNFRkYqMjLSXCTarl078xkZGRmqX7++rl+/roiIiCxFoi1bttSoUaMkSY0bN9b+/fu1Z8+e+yoSbd26tUaOHClJql27tj777DPt2rVLn332mbng75tvvlFkZGSWItE+ffqod+/ekqTSpUurQ4cOOn78uLlYsUmTJtq3b58iIyPvq0g0IyNDy5cvl729vaS7XUPfeecdpaeny9raWlu3btWVK1e0a9cuVa1aVZJUv359BQUFae3atQoNDVVsbKw2btyoF1980dzZskmTJurTp4+uX79ujnXo0CHt27dPq1atUkBAgCTJ399fUVFRCgsLU2BgoCpWrCh3d3dJ0tNPP60KFSpkm/e5c+e0adMmjRs3zqKbZqtWrXJ8rzt27NCJEyf08ccfq1q1auY8z58/r2XLlumtt94yr42Pj9e2bdvk5uYm6e73ePLkybp27ZrKlCmjgwcPav/+/Vq4cKFF19bM321sbNSlSxdt2bJFY8eOlY2NjSRpy5YtatGihZycnHLMs02bNnr99de1c+dODRs2TJL05ZdfKjY29h8/45SUFI0bN05t27Y1jx0+fPieezL99NNPGj9+vMXeTp065WovAAAAAAAAAAAAAAAAUNBYWVsZnQKQo8fmuvlChQpp8+bNWX66d+9+32daW1urcePG5teVK1eWJPn5+ZnHbGxsVLFiRV27ds08FhcXp1mzZikoKEi1atVSrVq1FBERoXPnzmWJkVnEKElWVlaqWrWqxVl54e/vb/7d0dFRbm5uqlevnkVHyMqVK+vq1av33Jv5Phs1amSxxt3dPdu9uVG/fn1zgagkVa1aVSkpKbpx44Yk6bvvvlP16tXNBaKS5OLiIj8/P33//feSpFOnTikxMVEtWrSwOLtly5YWrw8ePCgXFxc1atRIqamp5h8/Pz/9+uuvSktLy3Xehw4dUkZGhrp27ZrrPQcPHlSNGjVUuXLlLPH/fhV7zZo1zQWiksxFpZnfga+//lqFCxe2KDz+u65duyoqKkpffPGFJOnEiRP6+eef/zFnNzc3+fv7W1w5v3PnTpUrV06+vr7/+D4zi6fzysPDQ6tXr9bGjRt1/vz5+zoDAAAAAAAAAAAAAAAAAPDwPTadRK2treXl5ZVlfP/+/fd9ZqFChSwKGzOLLf9+xbidnZ2SkpLMr0NDQ3X06FGNGDFC1apVU7FixbRp0ybt3r07S4zszoqPj7+vfP9+lr29fZZOknZ2dkpOTr7n3sz3nNu9ufH3szJjZD63mzdvqkSJEln2FS9e3HwFfFRUlHnsr/6+LyYmRrGxsTl2lo2KilKZMmVylXdsbKxsbW2zxLyXmJgY/fLLL9nGz+z0mSm7Zyz9/+cSGxurkiVLysoq5/9boEKFCvL399fmzZvVrFkzbdmyRRUqVMhS5Jud9u3ba9KkSTpx4oQqVaqkffv2qU+fPveMJ0mFCxdW0aJF//H87CxatEiLFi3S4sWLNX36dLm7u2v8+PFZin0BAAAAAAAAAAAAAAAAAMZ6bIpEc8vBwUHS3euy/+rmzZv/WBiXG0lJSdq/f79CQ0MVEhJiHt+4ceMDn/24sbe3z/Ic4+Li7ussZ2fnbDut3rhxQ87OzpKkkiVLmsdKly5tXvPnn39mOcvNzU0rVqzINtZfO3f+ExcXF6WmpurGjRu5LhR1dnaWyWTS7Nmzcx3nXvGjoqKUkZFxz+9nt27dNHHiRF2/fl07duxQSEhIrr7PzzzzjIoUKaJdu3apZs2aSkhIsLjWPifZnZ3bP1ulSpXSnDlzlJ6eruPHj2v58uUaN26cIiMj9dRTT/1jbAAAAAAAAAAAAAAAAADAo/HYXDefW5kdJM+cOWMei46O1s8//5wv5ycnJys9Pd3iivdbt25p3759+XL+46RMmTK6du2abt++bR47ePDgfZ3l6+urU6dO6ezZs+axuLg4ffXVV+arz2vUqKFChQrps88+s9j76aefWrz28/NTdHS07Ozs5OXlleXnr91h/0mjRo1kZWWlLVu25HqPn5+fLl68qFKlSmUbPy/8/Px0586dbLvQ/lXz5s3l5OSkCRMmKC4uTl26dMnV+UWKFFFwcLB27dqlHTt2qEaNGjKZTHnKMVNe/2xZW1urdu3aGjt2rFJTU7l6HgAAAAAAAAAAAAAAAAAeM09cJ9EyZcqoTp06Wrp0qRwdHWVra6uVK1dmuar9fjk6OsrLy0srV66Um5ubbG1ttWLFChUrVkzR0dH5EuNx0bJlSy1ZskSvvPKKunfvrtOnT2vz5s33dVaXLl20Zs0aDRkyRGPHjpWDg4OWL18uW1tb9e3bV9Ldrpo9e/bUypUrVahQIXl4eGjXrl26cOGCxVn+/v4KCgrSoEGDNGjQIJlMJt25c0e//fabzp8/n6cOn+7u7urZs6feeustxcXFqXHjxkpMTNT+/fs1atQoi46mmTp16qQPPvhAL7zwggYMGKDKlSsrPj5ev/zyi1JSUjRhwoRcx/fz81NgYKBeeeUVXbhwQXXq1FFsbKz27NmjxYsXm9fZ2dmpU6dOWrVqlQICAlS2bNlcx2jfvr127typK1euaPz48bne93e5+bMVHx+vgQMHqmPHjnJ3d1dKSorWrVsnJycneXh43HdsAAAAAAAAAAAAAAAAAED+e+KKRCVpwYIFmjJliiZPnqwSJUpo7Nix2rVrl+Lj4/Pl/IULF2ratGkKDQ2Vi4uLQkJClJCQoNWrV+fL+Y+LatWqae7cuVq2bJmGDx8uX19fLViwQB07dszzWcWKFdO6des0d+5cTZ06Venp6fLx8dH69estCh4nTJigtLQ0vfvuu0pPT1eLFi00YcIEvfTSSxbnLVmyRCtWrNCmTZt0+fJlOTo6qnr16rnusPlX06ZNU4UKFfTRRx9p7dq1cnFxUf369VW0aNFs19vb2+v9999XWFiY3n77bUVFRcnFxUUeHh7q3bt3nuOHhYUpPDxcERERCg8PV/HixeXv759lXYsWLbRq1So999xzeTo/ICBALi4uiouLy9VV8/fyT3+2HBwcVKNGDa1bt05Xr15VoUKF5OnpqVWrVsnNze2BYgMAAAAAAAAAAAAAAAAA8pdVRkZGhtFJAJDeeustbdy4UV988YXs7e2NTueRST/zjWGxU0rVMCz2hTs2hsR9qpi1IXEl6VRsqiFxr8YnGRJXkhqWL2ZI3KiENEPiSlK6jPlnRZWMG4bElaSMQvnTzfy+Ylsb8//7WCfEGBJXMu552zuXMCQuAAAAAAAAAAAAgMdfs0UHjE4BkvaPCzQ6hcfSE9lJFChIzp49q3Pnzmn9+vXq3bv3v6pAFAAAAAAAAAAAAAAAAHjSWVlZGZ0CkCOKRAGDvfbaa/rhhx/UpEkTDRkyxOh0AAAAAAAAAAAAAAAAAAAFBEWigMHWrVtndAoAAAAAAAAAAAAAAAAAgALI2ugEAAAAAAAAAAAAAAAAAAAAkP8oEgUAAAAAAAAAAAAAAAAAACiAKBIFAAAAAAAAAAAAAAAAAAAogCgSBQAAAAAAAAAAAAAAAAAAKIBsjU4AAAAAAAAAAAAAAAAAAIAnlbW1ldEpADmikygAAAAAAAAAAAAAAAAAAEABRJEoAAAAAAAAAAAAAAAAAABAAcR18wAMFVPK07DYjmm3DItd2SrRkLjp6c6GxJWkGq72hsStWTTFkLiSlCFjYleyvW1IXElKK+JmSNxLt0oYEleSrsYkGxa7nmuqIXHji5Q2JK4k2dsYc01DRnysIXElycHRxbDYAAAAAAAAAAAAAIAnG51EAQAAAAAAAAAAAAAAAAAACiCKRAEAAAAAAAAAAAAAAAAAAAogikQBAAAAAAAAAAAAAAAAAAAKIIpEAQAAAAAAAAAAAAAAAAAACiBboxMAAAAAAAAAAAAAAAAAAOBJZWVtZXQKQI7oJAoAAAAAAAAAAAAAAAAAAFAAUSQKAAAAAAAAAAAAAAAAAABQAP1rikTDwsJkMpn0/PPPZ5mbPXu2goODDcjq/wsODtaMGTPy/dyQkBANGTLkoZwVFhamunXrPvC5d+7cUXh4uNq2bas6deqoYcOGeu6557Ro0SLzmps3byosLEy//fbbA8fLyaVLlxQWFqbr16/f1/6H9Rk+qM8//1wbNmzIMh4aGqr27dubX//6668KCwvTnTt3LNZt3bpVJpNJ0dHRDz1XAAAAAAAAAAAAAAAAAED++dcUiWb67rvvdPjwYaPTKBC6deumtWvXPvA5o0eP1rp169S1a1e9/fbbmjFjhho3bqzPP//cvObmzZsKDw9/qEWily9fVnh4uP7444+HFsMIn3/+uTZt2pRlfPjw4VqwYIH59a+//qrw8PAsRaLNmjVTRESEnJycHnquAAAAAAAAAAAAAAAAAID8Y2t0Ao9SkSJFVK1aNS1btkwNGzY0Op0nXpkyZVSmTJkHOuP8+fP63//+pzfeeEOdOnUyj7dq1Urjx49/wAxxLxUrVszVOjc3N7m5uT3kbAAAAAAAAAAAAAAAAAAA+e1f10l0+PDhOnTokI4cOXLPdZcvX9bo0aPl6+srb29vDRw4UCdPnrRYk3m9+IYNGxQUFCRfX18NHz7c4lruhIQEzZgxQ61atVKdOnUUHBysadOmKT4+/h9zPXr0qAYMGCAfHx/VrVtX3bp108GDB83zsbGxmjx5sho2bKjatWurZ8+e+vbbb7M9KzIyUq1atVLdunX1wgsv6MKFCxbzeTkrU3bXzd+8eVMzZ85U06ZN5enpqeDgYC1cuDDHM+Li4iRJJUuWzDJnbX3363np0iU1b95ckjRmzBiZTCaZTCZdunRJkpScnKw333xTQUFB8vT0VJs2bbRjxw6Ls44ePaqhQ4cqICBA3t7e6tixo7Zt22aeP3z4sF544QVJUteuXc0xMuXm+5DpXt+HzGf0n//8RwEBAfL09FSXLl305ZdfWqwJCQnRkCFDtG3bNj3zzDOqXbu2QkJCdPbsWYt1q1ev1nPPPSdfX181btxYQ4YM0blz58zzoaGh+u9//6vTp0+b31NoaKh5LvO6+a1bt2ry5MmSpMaNG8tkMik4ONg89/fr5lesWKEWLVrIy8tLjRo1Ur9+/XTx4sVsnwcAAAAAAAAAAAAAAAAAwBj/qk6ikhQUFCQPDw8tXbpUq1atynbNrVu3FBISImtra02fPl0ODg5avny5+vTpo+3bt6ts2bLmtfv27dP58+c1bdo0xcTEaM6cOZo5c6YWLVokSUpMTFRaWprGjRsnNzc3Xb16VW+//baGDx+udevW5Zjn999/r759+8rb21uzZs2Sk5OTjh8/ritXrkiS0tLS9OKLL+rixYuaOHGiSpQooXXr1ql///764IMP5OnpaT7r119/VXR0tCZOnKi0tDTNnTtXkyZNUkRERJ7Pupfk5GT17dtXly9f1ogRI1SjRg1du3ZN33//fY57qlSpoiJFimju3LkaP368GjRooKJFi1qsKVWqlMLDwzVy5EiNHz/e3AW2VKlSku4Wjh45ckQjRoxQ1apVdeDAAU2aNElOTk4KDAyUJF25ckU+Pj7q1auX7O3tdeTIEU2ZMkUZGRnq3LmzatWqpWnTpmnGjBmaM2eOqlSpYo6fn9+H5ORk9e/fXzdu3NDYsWNVunRpbd++XUOGDDEXY2b6+eefdeHCBU2YMEGStHjxYg0aNEiRkZGyt7eXJF27dk19+vRRuXLldOvWLX3wwQfq2bOn9uzZIxcXF3OR6tmzZ81Xy2fXFbRZs2YaNmyYli9frnfffVeOjo7mGH+3bds2vfXWWxo9erS8vb0VHx+v77//Xrdv387xcwYAAAAAAAAAAAAAAAAAPHr/uiJRSRo2bJhGjRqlY8eOqXbt2lnmt27dqitXrmjXrl2qWrWqJKl+/foKCgrS2rVrzZ0YJSkjI0PLly83F9RdvnxZ77zzjtLT02VtbS03NzdNnz7dvD41NVUVKlRQ7969de7cObm7u2eb4/z581WpUiWtXbtWNjY2kqSAgADz/P79+3Xs2DG9++67atKkiXm+ZcuWeueddxQWFmZeGx8fr23btpmLAxMSEjR58mRdu3ZNZcqUydNZ97Jt2zb98ssv+uCDDyw6jHbu3DnHPcWKFdPs2bM1ZcoUDR06VDY2NqpZs6ZatGihvn37qkiRIrK3t9fTTz8tSapUqZK8vb3N+w8dOqR9+/Zp1apV5ufj7++vqKgohYWFmYtE27VrZ96TkZGh+vXr6/r164qIiFDnzp1VrFgxVatWTZJUvXp1eXl5mdfn5/dhx44dOnHihD7++GNzvCZNmuj8+fNatmyZ3nrrLfNZN27c0Pr161W5cmVJkoeHh1q3bq2tW7eqZ8+ekqRXXnnFvD4tLU3+/v5q3Lix9uzZox49eqhixYpyc3PTlStXLJ7b37m5uZmvn69Vq9Y9r5c/duyYTCaThgwZYh575plnclwPAAAAAAAAAAAAAAAAFGQ21lZGpwDk6F933bwktWjRQjVq1NDSpUuznf/uu+9UvXp1c0GgJLm4uMjPzy9LV8z69etbdFysWrWqUlJSdOPGDfPYtm3b1KlTJ9WtW1e1atVS7969JUm///57tvHv3LmjH3/8UZ06dTIXiGaXY7FixcxFnZJkZ2enFi1aZMmxZs2aFkV/mcWJ165dy/NZ9/L111+ratWqWa6g/ydt27bV//3f/+mNN95Qx44dFRMTo8WLF+u5555TQkLCPfcePHhQLi4uatSokVJTU80/fn5++vXXX5WWlibp7rX2s2bNUlBQkGrVqqVatWopIiLC4mr2nOTn9+HgwYOqUaOGKleunCXfn376yeKs6tWrmwtEpbsFsjVr1tSPP/5oHvvhhx/Uv39/NWzYUB4eHqpTp44SEhJy/G7lBw8PD/3yyy+aM2eOvvvuO6WkpDy0WAAAAAAAAAAAAAAAAACA+/ev7CRqZWWloUOHavz48fr555+zzN+8eVMlSpTIMl68eHGdPn3aYszJycnidWaBYFJSkiTps88+08svv6wePXpo3LhxcnFxUVRUlEaMGGFek1389PR083XqOa0pXrx4lvESJUooLi7unjna2dlZ5JiXs+4lNjb2njnfi7Ozszp16qROnTopIyNDS5Ys0bJly7R582a98MILOe6LiYlRbGysatWqle18VFSUypQpo9DQUB09elQjRoxQtWrVVKxYMW3atEm7d+/+x9zy8/sQExOjX375Jdt8/14QnN1nUrx4cUVFRUmSrly5ogEDBsjT01PTp09XqVKlZGdnpyFDhuT43coPXbp00e3bt/Xhhx9qzZo1cnR0VKdOnTRx4kQVKlToocUFAAAAAAAAAAAAAAAAAOTNv7JIVJLatGmjsLAwLVu2TOXKlbOYc3Z2zrbD5I0bN+Ts7JynOJGRkXr66ac1Y8YM89g333xzzz2Ojo6ytrbWH3/8keMaZ2dni26lmf78888855hfZ7m4uOjkyZN5ip0dKysrDRw4UMuWLdOZM2fuudbZ2Vlubm5asWJFtvNubm5KSkrS/v37FRoaqpCQEPPcxo0bc5VPfn4fnJ2dZTKZNHv27H9cm91ncuPGDdWsWVOS9MUXXyghIUHh4eHm4tTU1NQ8FfbeD2tra/Xt21d9+/bV9evXtWvXLi1cuFCurq4aMWLEQ40NAAAAAAAAAAAAAAAAAMi9f+V189LdQrehQ4dq7969WQobfX19derUKZ09e9Y8FhcXp6+++kq+vr55ipOYmGju3Jlpx44d99xTpEgReXt76+OPPzZfl/53vr6+unXrlr788kvzWGpqqj7//PM855hfZ/n5+enMmTMW16H/k1u3bikxMTHLeOZ16SVLlpSUtfvpX2NGR0fLzs5OXl5eWX7s7e2VnJys9PR0i8/h1q1b2rdvn8VZOcXIz++Dn5+fLl68qFKlSmWb71+dPn1a58+fN78+f/68Tpw4oTp16ki6+92ysrKSre3/r/XevXu3UlNTs7yv3HQWzXz/ycnJuX4/pUuX1oABA2QymSyeDwAAAAAAAAAAAAAAAADAeP/aTqKS1KFDBy1dulSHDx9W+fLlzeNdunTRmjVrNGTIEI0dO1YODg5avny5bG1t1bdv3zzF8PPz04wZM7R06VLVrVtXBw4c0Ndff/2P+yZMmKB+/fqpX79+6t27t5ydnfXzzz/L1dVVXbt2VbNmzVS7dm1NmjRJEyZMUIkSJbRu3Tr98ccfWrJkSZ5yzK+zOnbsqI0bN2rw4MEaOXKkqlevruvXr+u7777TzJkzs91z7tw5DRs2TJ07d5avr6+KFCmi3377TStXrpSjo6M6d+4s6W6xqJOTk3bt2qUKFSrI3t5eJpNJ/v7+CgoK0qBBgzRo0CCZTCbduXNHv/32m86fP6/Zs2fL0dFRXl5eWrlypdzc3GRra6sVK1aoWLFiio6ONudSuXJl2djYaMuWLbK1tZWNjY28vLzy9fvQqVMnffDBB3rhhRc0YMAAVa5cWfHx8frll1+UkpKiCRMmmNcWL15cQ4cO1ejRoyVJb731lkqXLq0uXbpIkho1aiRJmjx5snr27KnTp0/rvffey3LlfdWqVbVlyxbt3LlTlSpVkqurqypUqJAlt6pVq0qSNmzYoGeeeUaFChWSyWTKsm7atGlycnKSt7e3nJycdOTIEZ04cUK9evXK07MAAAAAAAAAAAAAAAAAADxc/+oiURsbGw0ePFhTpkyxGC9WrJjWrVunuXPnaurUqUpPT5ePj4/Wr1+vsmXL5ilGz549denSJa1fv16rVq1SQECAFi5cqO7du99zX7169fT+++9r8eLFmjx5sqytrVW9enWNHTvWnPuKFSs0b948zZ8/XwkJCapVq5ZWr14tT0/PPD+H/DjL3t5ea9as0aJFi/TOO+8oNjZWZcqUUbt27XLcU6lSJfXo0UMHDx7URx99pNu3b6t06dJq1KiRhg4dai7etba21pw5c/Tmm2+qX79+Sk5O1t69e1WhQgUtWbJEK1as0KZNm3T58mU5OjqqevXq5mJKSVq4cKGmTZum0NBQubi4KCQkRAkJCVq9erV5jZubm6ZNm6Z3331X27dvV2pqqk6ePJmv3wd7e3u9//77CgsL09tvv62oqCi5uLjIw8NDvXv3tlhbq1YttWzZUvPnz1dUVJTq1Kmj6dOny97eXpJkMpk0Z84chYeHa8iQIXr66af11ltvmb8jmbp27apjx45p5syZio2NVefOnTV37twsuXl4eGjUqFH66KOP9O6776ps2bJZuq1KUt26dfXhhx/qo48+0p07d/TUU09p8uTJ6tatW56eBQAAAAAAAAAAAAAAAADg4bLKyMjIMDoJAJZCQkJUpEgRvfPOO0an8tDdiE8wLLZj2i3DYlulJBoSN72wsyFxJSnDxt6QuNbJtw2JK0kZNnaGxLUy8D2nFXEzJO61WymGxJWkq7eSDYtdz9WYf8bdsi5iSFxJsrexMiSuXVqSIXElycHRxbDYAAAAAAAAAAAAAP5Z27e/MjoFSPpkqJ/RKTyWrI1OAAAAAAAAAAAAAAAAAAAAAPmPIlEAAAAAAAAAAAAAAAAAAIACyNboBABktW7dOqNTAAAAAAAAAAAAAAAAAAA84egkCgAAAAAAAAAAAAAAAAAAUABRJAoAAAAAAAAAAAAAAAAAAFAAUSQKAAAAAAAAAAAAAAAAAABQAFEkCgAAAAAAAAAAAAAAAAAAUADZGp0AAAAAAAAAAAAAAAAAAABPKhtrK6NTAHJEJ1EAAAAAAAAAAAAAAAAAAIACiE6iAAzlev2YYbG/sathWGzvksUNiVuoSFFD4kpS6uVfDYmbYWNvSFxJ2hFV2JC4/hWdDYkrSTdikg2JW72IMXElqVwJO8Ni30g15p9ypf48YUhcScoo5GhIXOs7cYbElaTkY2cNiWvv392QuAAAAAAAAAAAAACA/EMnUQAAAAAAAAAAAAAAAAAAgAKIIlEAAAAAAAAAAAAAAAAAAIACiCJRAAAAAAAAAAAAAAAAAACAAogiUQAAAAAAAAAAAAAAAAAAgAKIIlEAAAAAAAAAAAAAAAAAAIACyNboBAAAAAAAAAAAAAAAAAAAeFLZWFsZnQKQIzqJAgAAAAAAAAAAAAAAAAAAFEAUiQIAAAAAAAAAAAAAAAAAABRAFIlCYWFhMplM2f6sWLHCkJyCg4M1Y8YMQ2I/qMOHD8tkMumnn37Kdv748eMymUz6+OOPs51PS0uTn5+fXnrppQfK49KlSzKZTIqMjHygcwAAAAAAAAAAAAAAAAAATyZboxPA46FQoUJau3ZtlvGyZcsakE3B5unpKXd3d+3atUsdO3bMMv/111/rxo0b6tChwwPFKVWqlCIiIlS5cuUHOgcAAAAAAAAAAAAAAAAA8GSiSBSSJGtra3l7exudxr9G+/bt9fbbbysmJkaurq4Wczt37lTx4sXl5+d33+cnJiaqUKFCfKYAAAAAAAAAAAAAAAAA8C/GdfPItc2bN6tdu3aqXbu2GjZsqF69eunYsWPm+aSkJM2ZM0cBAQHy8vJSx44d9dlnn1mcERoaqvbt2+vAgQNq3769vLy81KVLF/3www/ZxtywYYOCgoLk6+ur4cOHKzo62jyXkJCgGTNmqFWrVqpTp46Cg4M1bdo0xcfHW5yRnJysWbNmqUGDBqpXr56mTZumHTt2yGQy6dKlSxbr3nzzTQUFBcnT01Nt2rTRjh07LM46evSohg4dqoCAAHl7e6tjx47atm1bnp9lhw4dlJKSkuUq+KSkJH322Wdq27atbGxstG3bNvXq1UsNGjRQ/fr1FRISYvHMJSksLEx169bVsWPH1KNHD3l5eWnDhg05Xje/bds2derUSV5eXmrYsKFefPFFXb582Tx/7do1TZw4UQ0bNlTt2rX1/PPP6/jx4xZn7N27V126dFHdunVVr149denSRQcOHMjzcwAAAAAAAAAAAAAAAAAAPDx0EoVZampqljFb27tfkW+//VavvvqqBgwYoMDAQCUmJurYsWMWBZkTJ07UF198obFjx6pKlSr6+OOPNWrUKC1dulTNmzc3r4uKitL06dM1atQoOTk5aeXKlRo4cKA+/fRTFS9e3Lxu3759On/+vKZNm6aYmBjNmTNHM2fO1KJFiyTd7ZaZlpamcePGyc3NTVevXtXbb7+t4cOHa926deZzFi5cqA8++ECjR4/W008/rT179mjhwoVZ3uuYMWN05MgRjRgxQlWrVtWBAwc0adIkOTk5KTAwUJJ05coV+fj4qFevXrK3t9eRI0c0ZcoUZWRkqHPnzrl+1pUqVZKXl5d27typXr16mcf379+vW7duma+av3Tpkjp16qSKFSsqOTlZu3bt0vPPP6/t27fL3d3dvC8lJUUTJkxQv379NG7cOLm4uGQb991339X8+fPVtWtXjRs3TikpKTp06JCio6NVvnx5xcXFqXfv3ipSpIimTp0qR0dHrVu3Tn379jV/PhcuXNCYMWPUrl07TZgwQenp6Tpx4oTi4uJy/f4BAAAAAAAAAAAAAACAgsLG2sroFIAcUSQKSXe7ctaqVSvL+IYNG1SvXj0dO3ZMLi4uevnll81zzZo1M/9+4sQJffrpp5o+fbp69uwpSWratKkuX76cpUg0NjZWixcvVuPGjSVJDRo0UGBgoNasWaMJEyaY12VkZGj58uWyt7eXJF2+fFnvvPOO0tPTZW1tLTc3N02fPt28PjU1VRUqVFDv3r117tw5ubu7KzY2Vps2bdKwYcM0ePBgSVKTJk3Ur18/Xb161bz30KFD2rdvn1atWqWAgABJkr+/v6KiohQWFmYuEm3Xrp1FfvXr19f169cVERGRpyJR6W430Tlz5ujq1asqW7asJGnXrl2qWLGi6tSpI0kaOXKkeX16err8/f117Ngx/fe//9X48ePNcykpKRo3bpzatm1rHvtrl1RJio+PV3h4uHr06KEZM2aYx5955hnz72vXrtXNmzf10UcfmQt2GzdurFatWmnVqlV66aWX9MsvvyglJUVTp05VsWLFzM8UAAAAAAAAAAAAAAAAAPB4oUgUkqRChQpp/fr1WcarVKkiSfLw8FBsbKxCQ0PVoUMH+fj4qHDhwuZ133//vSSpdevWFvvbtGmjOXPmKCEhQUWKFJEkOTo6mgtEM1/7+fnpxx9/tNhbv359c4GoJFWtWlUpKSm6ceOGSpYsKenu1elr1qzR+fPnlZCQYF77+++/y93dXadOnVJSUpJFkaokNW/eXF9//bX59cGDB+Xi4qJGjRpZdFT18/PTf/7zH6WlpcnGxub/sXfnUVXV+//HXxwGRZkEwTETTU+BIIiGIqSiOHvTrlOOqKmZUyqZ3NTSLOchUXPImcwhrRSLrlqat8GuZakNVpolXlEUmUSQ6feHP8/XE+CIbaPnYy3WYu/92Z/Xe2+O5l33zeej1NRUxcTEaM+ePTp79qzy8vIkqdiVO2+kffv2mjlzpt5//30NGjRIGRkZ2rt3rwYNGmQZc/z4cc2bN0+HDh3ShQsXrJ7vj641shbn0KFDunz5srp27VrsmE8//VTBwcFydXW1vAeTyaRGjRrpyJEjkiSz2SxbW1tFRUWpe/fuatSokZydnW/n0QEAAAAAAAAAAAAAAAAAfwKaRCHpaiOgn59fsdebNGmiWbNmad26dRo0aJDKlCmjNm3a6F//+pfc3NyUmpoqe3v7Qs2SFStWVEFBgdLT0y1Nou7u7oXm9/Dw0PHjx63Oubi4WB1faxjNzs6WJO3atUvPP/+8evToYdliPSkpScOHD7eMSUpKkiRVqFChUN71Ll68qJSUlCJXU702T+XKlTVhwgQdOnRIw4cP10MPPSQnJye99dZb+uCDD4p9d8Xx9PRUcHCw4uLiNGjQIO3atUvZ2dmWreYzMjI0cOBAubu7a8KECapatarKlCmjiRMnWp7vGkdHR5UvX/6GeSkpKZIkLy+vYsdcvHhR33zzTZHvoUaNGpIkb29vLV26VMuWLdOIESNkMpkUGhqqyZMnq2rVqrfzCgAAAAAAAAAAAAAAAAAA9xBNorhljz/+uB5//HElJydrz549mj59uuzs7PTqq6/K1dVVOTk5Sk1Nlaurq+We8+fPy8bGxmqlyeTk5EJzX7866K2Kj4/XI488YrV1+pdffmk15tqcFy9eVKVKlazyrufq6ip3d3ctX768yCx3d3dlZ2dr7969mjBhgvr27Wu5tmHDhtuq+3qdOnVSdHS0Tpw4obi4OPn6+lpWb/3mm2+UmJioZcuW6eGHH7bck56ersqVK1vNY2Njc9Osaw28586dK3T/Na6urgoLC9Po0aMLXbt+VdfHHntMjz32mDIyMvTJJ59o+vTpio6O1tq1a29aBwAAAAAAAAAAAAAAAADgz2EyugD89bi7u6tbt25q2rSpTpw4IUkKCgqSdLVx83rx8fHy8fGxrCIqXW1yvH6r9/T0dH322WeqX7/+bdWRlZUle3t7q3M7duywOq5Tp47KlCmj3bt3W53/43FISIiSk5Nlb28vPz+/Ql8ODg66cuWK8vPzrTIzMjL00Ucf3Vbd12vdurXKlCmjtWvX6osvvrCsInrt+SRZ5X399dc6ffr0HWUFBgbK0dFRW7duLXZMSEiIjh8/rtq1axd6B2azudB4JycntW/fXh06dCi0EiwAAAAAAAAAAAAAAAAAwFisJApJUn5+vr755ptC5z08PPTAAw9o4cKFSklJ0aOPPioPDw/99NNP2r9/vyIjIyVJDz/8sFq3bq0ZM2YoKytL3t7e2r59uw4dOqQlS5ZYzenm5qYXXnhBo0aNkrOzs1asWKGCggL179//tmoOCQnR1KlTtXjxYgUGBmrfvn1WzafS1W3mn3zySS1dulRlypTRI488ovj4eJ08eVKSZDJd7ZNu2rSpWrRooaeeekpPPfWUzGazLl++rF9++UW//fabXnnlFTk7O8vPz08rVqyQu7u77OzstHz5cjk5ORW5OuqtcHJyUvPmzbVp0ybZ2Nioffv2lmsBAQEqV66cpkyZoiFDhujs2bOKiYmxWhH1djg7O2v48OGaM2eOCgoK1LJlS+Xn5+vAgQPq0KGD/Pz8FBkZqR07dqhPnz7q16+fqlatquTkZH377beqVKmSIiMjtXHjRn3zzTcKCwuTp6enEhIStH37djVt2vSO6gIAAAAAAAAAAAAAAAAA3Bs0iULS1VUre/ToUeh8165d9corr8jPz09r167VBx98oIyMDFWuXFmDBg3SsGHDLGNnz56tefPmacWKFUpJSVGtWrW0cOFChYeHW83p6empqKgozZo1S7///rvq1KmjlStXqmLFirdVc8+ePZWQkKDY2FitXLlSoaGhmjt3rrp37241bty4ccrNzdXy5cuVn5+viIgIDRkyRFOnTpWzs7Nl3MKFC7V8+XK99dZbOn36tJydnVWnTh098cQTljFz587V5MmTNWHCBLm5ualv377KzMzUqlWrbqv263Xq1EkffvihgoODrRpAK1asqNdee02zZs3SM888o5o1a2rKlCl644037jhr8ODBcnd315o1a7Rt2zaVL19egYGB8vDwkHS1qXbTpk1asGCB5syZo5SUFHl4eKh+/fqKiIiQJJnNZn388ceaPn26UlJS5OnpqQ4dOhS5RT0AAAAAAAAAAAAAAAAAwDg2BQUFBUYXgb+PCRMm6OjRo4qLizO0jueee05fffXVXW0Vj5KR/8sXhmV/aV/XsOwAzzKG5JYtV96QXEnKPf2DIbkFtg6G5ErS9iRHQ3Kb1nA1JFeSLmTmGZJbp9wVQ3IlqcDW3rDs5Fxjft/H6+IxQ3IlqaCs880H3QOmy6mG5EpS7pkThuQ6NO1+80EAAAAAAAAAAAAA1GPNl0aXAEmbIh81uoT7EiuJotT78ssv9fXXX8vX11f5+fnau3evduzYoQkTJhhdGgAAAAAAAAAAAAAAAAAA9wxNoij1ypUrp71792rFihXKzs5WtWrVNGHCBEVGRhpdGgAAAAAAAAAAAAAAAAAA9wxNovhTzZgx40/PrFevnjZu3Pin5wIAAAAAAAAAAAAAAAAAYCST0QUAAAAAAAAAAAAAAAAAAACg5NEkCgAAAAAAAAAAAAAAAAAAUArRJAoAAAAAAAAAAAAAAAAAAFAK0SQKAAAAAAAAAAAAAAAAAABQCtkZXQAAAAAAAAAAAAAAAAAAAH9VtiYbo0sAisVKogAAAAAAAAAAAAAAAAAAAKUQK4kCMFSu50OGZVfKsTcsu8Bka0huYuolQ3IlqYJzJUNys2wdDcmVJNf0DENyy9oa9xtKeQUFhuRetitvSK4klc27bFi2W9kyhuTa5OcakitJyko3JDanktmQXEmyszXmv1fN5u41JFeS9o1rblg2AAAAAAAAAAAAAJQmrCQKAAAAAAAAAAAAAAAAAABQCtEkCgAAAAAAAAAAAAAAAAAAUArRJAoAAAAAAAAAAAAAAAAAAFAK0SQKAAAAAAAAAAAAAAAAAABQCtkZXQAAAAAAAAAAAAAAAAAAAH9VtiYbo0sAisVKogAAAAAAAAAAAAAAAAAAAKUQTaIAAAAAAAAAAAAAAAAAAAClEE2iuO9t375dXbt2VVBQkBo0aKB27drphRde0IULF25rnoSEBJnNZsXHx9+jSkuf8PBwTZ061egyAAAAAAAAAAAAAAAAAAB3wM7oAoAbWbFihebOnavIyEiNGjVKBQUF+vnnn7Vjxw6dO3dOHh4eRpcIAAAAAAAAAAAAAAAAAMB9iSZR3NfWr1+vLl26aMKECZZzzZo101NPPaX8/HwDKwMAAAAAAAAAAAAAAAAA4P7GdvO4r6WlpcnLy6vIaybT/318r22L/sYbbygsLEz169fXsGHDdO7cuZtmbNu2TZ06dZKfn5/CwsI0f/585eXlWV03m836/vvv9dRTTykgIECtW7fWu+++W2iujRs3qk2bNqpXr57Cw8O1ZMkSq2bWa3MdOXJEAwcOVP369dWmTRt99tlnys/P1/z58xUSEqKQkBDNnTu3UCPs8ePHNWzYMAUFBSkgIEBDhgzR77//bjUmPT1dUVFRCgwMVJMmTTRv3jytWrVKZrPZMiYzM1NTp05VmzZtVL9+fYWHh2vy5MlKT08v9j199NFHMpvNOnnypNX51NRU+fv7680337zpuwYAAAAAAAAAAAAAAAAA/HloEsV9zdfXVxs3btSWLVuUlJR0w7G7du3S7t279dJLL+mll17S4cOHNXLkyBves3r1ak2cOFGhoaFaunSpBg8erHXr1mn+/PmFxkZFRSk0NFSLFy/WI488ogkTJuj48eOW6+vXr9eLL76osLAwLV26VF26dNGiRYs0e/bsQnM9//zzat68uRYtWiQvLy+NGDFCr7zyihITEzVz5kz16tVLy5cv186dOy33nDp1Sj179lRqaqpmzJihOXPmKDk5WZGRkbpy5YplXHR0tPbu3avnnntOM2bM0PHjx7Vu3Tqr/KysLOXl5WnMmDFasWKFRo8erf/+97965plnin1XzZo1U6VKlbR161ar83FxcZKkTp063fBdAwAAAAAAAAAAAAAAAAD+XGw3j/vaiy++qBEjRmjixImSpOrVq6tFixaKjIxU9erVrcZeunRJK1askLOzsySpcuXKioyM1P79+xUWFlZo7oyMDC1cuFBPPfWUxo4dK0lq2rSp7O3tNWPGDA0aNEgVKlSwjO/du7d69+4tSQoMDNS+ffv04Ycf6plnnlFeXp4WL16sDh06WGoNDQ1VTk6OVq1apSFDhljN1adPH/Xq1UuSVKlSJXXq1ElHjx7Vpk2bJElhYWH66KOPFB8fb2m+XLRokVxdXbV69WqVKVNGktSgQQO1bNlSW7ZsUe/evfXLL79o165dmjlzpjp37myZq127dlbP7u7urilTpliOc3NzVb16dfXq1Uu//vqrvL29C70vW1tbPfHEE9q6daueffZZ2draSpK2bt2qiIgIubi4FPNTBAAAAAAAAAAAAAAAAEovWxNrNeL+xacT97W6desqLi5Oy5cvV79+/eTs7Kz169frH//4h3744QerscHBwZYGUUlq0qSJ3Nzc9O233xY596FDh5SZmam2bdsqNzfX8hUSEqKsrCz9/PPPVuNDQ0Mt35crV05Vq1ZVYmKiJOnEiRO6ePGi2rZta3VP+/btlZOTo8OHD1udb9q0qeX7mjVrSpIaN25sNcbb21tnzpyxHH/66acKDw+Xra2tpVYXFxf5+Pjo6NGjkqQjR45Iklq2bGm5z2QyqUWLFoWe/91331Xnzp0VGBgoX19fS9PqH7eTv17Xrl2VlJSk/fv3S5J+/PFHfffdd+ratWux9wAAAAAAAAAAAAAAAAAAjMFKorjvOTg4qFmzZmrWrJkkaf/+/Ro6dKgWL16sRYsWWcZ5eHgUutfd3b3YbeovXrwoSerSpUuR169v0JRk1YAqSfb29pZt3lNTU4us4drxtetFzeXg4CBJhVbivH7+a/WuXbtWa9euLVSrvb29JCkpKUn29vaFanV3d7c63rVrl55//nn16NFDY8aMkZubm5KSkjR8+HBlZ2cXmv+a6tWrq2nTpnr77bfVvHlzbd26VdWrVy/U4AoAAAAAAAAAAAAAAAAAMB5NovjLCQsL08MPP6zjx49bnb9w4UKhscnJyfL09CxyHldXV0lXt3GvXLlyoet/3M7+Rtzc3Cx5RdV0LetuuLq6qlmzZpYVP69Xvnx5SZKnp6dycnKUnp5u1Sj6x7ri4+P1yCOPaOrUqZZzX3755S3V0a1bN0VFRens2bPasWOH+vbtKxsbmzt5JAAAAAAAAAAAAAAAAADAPUSTKO5r58+fV8WKFa3OZWVl6cyZM3rooYeszh84cMCqOfLzzz9XSkqK6tevX+TcgYGBcnR0VGJioiIiIu6qTm9vb7m7uys+Pt5qrg8++ED29vby9/e/q/klqUmTJvr555/l4+MjW1vbIsfUq1dPkrRnzx517txZkpSfn6+PP/7YalxWVpZl9dFrduzYcUt1tGzZUi4uLho3bpxSU1P1xBNP3OaTAAAAAAAAAAAAAAAAAAD+DDSJ4r7WqVMntWjRQqGhofLy8tLZs2cVGxurixcvqn///lZjy5cvr8GDB2vw4MFKT0/XnDlz5O/vr7CwsCLndnFx0ahRozR79mwlJibq0Ucfla2trU6dOqU9e/YoJiZGjo6Ot1Snra2tnnnmGU2bNk3u7u5q1qyZvvnmG61YsUL9+/dXhQoV7vpdjBo1Sl27dtWgQYPUvXt3VaxYUefPn9eXX36phg0bqmPHjqpTp44iIiI0bdo0Xb58WVWrVtXmzZuVlZVltdpnSEiIpk6dqsWLFyswMFD79u3T559/fkt12Nvbq3Pnzlq5cqVCQ0NVpUqVu342AAAAAAAAAAAAAAAAAEDJo0kU97URI0bo448/1owZM5ScnKwKFSrIbDZrzZo1aty4sdXYiIgIVa5cWS+++KLS0tIUEhKiKVOm3HD+gQMHqlKlSlq9erViY2NlZ2enGjVqqHnz5oVW2ryZvn37ys7OTmvWrNFbb70lT09PjRgxQk8//fRtP3dRHnzwQW3ZskULFizQlClTlJmZKU9PTzVq1Ehms9ky7tVXX9XUqVM1a9YsOTg4qEuXLqpTp47efPNNy5iePXsqISFBsbGxlmbPuXPnqnv37rdUS0REhFauXKl//vOfJfJsAAAAAAAAAAAAAAAAAICSZ1NQUFBgdBHA3QoPD1fz5s01efJko0u5L/Xu3Vsmk0nr168vkflee+01bdiwQfv375eDg8NdzXUl9XyJ1HQnTueUMSy7stPtNSGXlNTsPENyJamCTbYhuVm2t7Yi8L3w3/9lGJLbsEp5Q3Il6fe0HENyH3S9u7+L7kbZvMuGZec7lDMkt8zpw4bkSlKByZjfccr1qmNIriTZnT9hSG742xcNyZWkfeOaG5YNAAAAAAAAAAAA3K7IDV8bXQIkrenVwOgS7kusJAqUMh9++KHOnDmjunXr6vLly4qLi9PBgwe1ePHiu577xIkT+vXXXxUbG6tevXrddYMoAAAAAAAAAAAAAAAA8Fdna7IxugSgWDSJAqVMuXLl9N577+nkyZPKyclRrVq1NHv2bLVq1equ537xxRf1zTffKCwsTEOHDi2BagEAAAAAAAAAAAAAAAAA9wpNoigVPvroI6NLuG+EhYUpLCzsnsxdUtvVAwAAAAAAAAAAAAAAAADuPZPRBQAAAAAAAAAAAAAAAAAAAKDk0SQKAAAAAAAAAAAAAAAAAABQCtEkCgAAAAAAAAAAAAAAAAAAUArRJAoAAAAAAAAAAAAAAAAAAFAK2RldAAAAAAAAAAAAAAAAAAAAf1W2JhujSwCKxUqiAAAAAAAAAAAAAAAAAAAApRAriQIwVIapnGHZ6w+dMix7TNMahuTaG/ibK5dtyhqSW9Ym35BcSTqTnm1IbqJLGUNyJSm/oMCQ3DIG/tpLUraDYdkeBkXnuVQ2JliSTa4xf65srlwyJFeS8ss4GZJrY0oxJFeSms/fZ0ju3jHNDMkFAAAAAAAAAAAAgHuFlUQBAAAAAAAAAAAAAAAAAABKIZpEAQAAAAAAAAAAAAAAAAAASiGaRAEAAAAAAAAAAAAAAAAAAEohmkQBAAAAAAAAAAAAAAAAAABKIZpEAQAAAAAAAAAAAAAAAAAASiE7owsAAAAAAAAAAAAAAAAAAOCvytZkY3QJQLFYSRQAAAAAAAAAAAAAAAAAAKAUYiVRAAAAAAAAAAAAAAAAAADwt3b8+HFNmzZNhw4dUvny5fX444/r2WeflYODww3vCw8P1+nTpwudP3z4sMqUKWM5Pnv2rKZNm6b//Oc/sre3V0REhKKjo+Xk5FTiz3I9VhL9m4qJiZHZbLZ8NW7cWP369dPBgwdLZP60tDTFxMTol19+uaP7+/btq6FDh95wTExMjAIDA2/7mtEOHDigpUuXGlrDtm3bZDablZycbGgdAAAAAAAAAAAAAAAAAGC01NRU9e/fXzk5OYqJidGYMWO0efNmzZgx45bub9OmjTZt2mT1dX1zaU5Ojp566imdPHlSc+fO1UsvvaT//Oc/Gjdu3L16JAtWEv0bK1u2rNauXStJSkxM1JIlSxQZGalt27apbt26dzV3WlqaFi1apDp16uihhx4qiXJLjS+//FKrVq3S008/bVgNzZs316ZNm+Ti4mJYDQAAAAAAAAAAAAAAAABwP9i4caMuXbqkRYsWyc3NTZKUl5enKVOmaOjQoapUqdIN769YsaICAgKKvf7hhx/q559/1vvvv69atWpJklxcXDRo0CAdPnxY/v7+JfUohbCS6N+YyWRSQECAAgIC1LZtWy1dulS5ubnauHHjXc2blZVVQhWWLleuXFF+fr7RZUiS3N3dFRAQIDs7+sQBAAAAAAAAAAAAAAAA/L198sknatKkiaVBVJLatWun/Px8ffrppyUyv9lstjSISlLTpk3l5uamffv23fX8N0KTKCyqVq0qd3d3JSQkSJLy8/O1ZMkShYeHq169emrbtm2hBtJr27ofPnxYPXr0kJ+fn9588021bNlSkjR69GjLlvbX5p0zZ446deqkwMBAhYWFaezYsTp37tw9fbYnnniiyKV5Z8+erdDQUOXl5SkhIUFms1nvvPOO/vWvfykoKEiPPvqopk+frtzcXKv7EhMTFRUVpeDgYPn7+6t37946evSo1Zjw8HBNnTpVK1asUIsWLeTv769p06Zp0aJFyszMtLyXvn37Wu45fvy4hg0bpqCgIAUEBGjIkCH6/fffreY1m81asWKFYmJiFBISouDgYEVHRyszM9MyJi0tTRMnTlRYWJj8/PzUrFkzjRkzxnK9qO3mU1JSFB0dbXmmnj176r///a9Vdt++fTV06FDFx8erTZs2CgwMVL9+/QrVCAAAAAAAAAAAAAAAAAB/FSdOnLBq4JSurvTp6empEydO3PT+HTt2qF69egoMDNTgwYN17Nixm85vY2Mjb2/vW5r/brCMICwyMjKUkpIiLy8vSdKsWbO0bt06DRs2TIGBgdq7d69efPFF5ebmqk+fPpb7cnJyNG7cOEVGRmrMmDFyc3PTokWLNGLECI0dO1bBwcGSZJn3woULGjp0qLy8vJScnKzVq1erb9++2rlz5x2tbPnHBk5JhVbs7Natm2bMmKH09HQ5OztLuroc8HvvvacuXbrI1tbWMnbevHkKDQ3VggUL9P3332vhwoWyt7dXVFSUJCk1NVW9evVSuXLlNGnSJDk7O2v9+vXq37+//v3vf8vDw8My17///W89+OCDeuGFF2QymfTII48oOztbcXFxWrt2rSTJyclJknTq1Cn17NlTderU0YwZM2RjY6OlS5cqMjJS8fHxcnBwsMz75ptvKigoSDNmzNDJkyc1a9YseXh4WGqcPn269u/fr3HjxqlatWpKSkrSJ598Uuw7zMvL0+DBg3Xq1ClFRUWpYsWKWr9+vQYMGKCNGzeqXr16lrE//PCDkpOTFRUVpby8PM2YMUPPPfecNm3adGs/MAAAAAAAAAAAAAAAAAAoYdcWNizOnj17ir2WlpYmFxeXQuddXV2Vmpp6w3nDw8Pl7++vqlWr6tSpU1q6dKl69eqld999Vw888IBl/mt9a7c7/92iSfRv7lqDZWJiombOnKm8vDy1adNGycnJio2N1aBBgzRy5EhJUmhoqC5evKjFixfrySeftDRW5uTkaMyYMWrfvr1l3muNjw8++KACAgKsMqdPn275Pi8vT4GBgXrsscf0xRdfKDQ09Lbqz8zMlK+vb5HXypUrZ/m+U6dOmjlzpnbs2KFevXpJkvbt26ekpCT985//tLqvRo0alhrDwsKUlZWl1atXa/DgwXJ1ddXatWuVlpamLVu2WBpCmzRpojZt2mjlypUaP368Za6cnBytWLHCqpbKlSvLZDIVei+LFi2Sq6urVq9erTJlykiSGjRooJYtW2rLli3q3bu3Zaynp6fmzp0rSXrsscf0/fff68MPP7Q0iR45ckQdO3ZUly5dLPd06NCh2Pe4d+9eHT58WG+88YbCwsIkXf15t27dWsuWLVNMTIxlbHp6ut599125u7tLuvoziI6OVmJioipXrlxsBgAAAAAAAAAAAAAAAFAa2drYGF0CDDRx4kTL9w0bNlTTpk3Vrl07rVy5Ui+99JJxhf1/NIn+jf2xwdLV1VWTJ09WWFiY9u7dq5ycHLVt29bqnnbt2ikuLk4nT55U7dq1LeebNWt2y7n79u3T66+/rp9//lkZGRmW8ydPnrztJtGyZcsqNja20PnNmzcrLi7Ocuzk5KR27dpp69atlibRbdu2qWHDhqpZs6bVvREREVbHbdq00ZIlS/TTTz+pUaNG+vTTTxUcHCxXV1dLk63JZFKjRo105MgRq3uDg4OtGkRv5NNPP1X79u1la2trmdfFxUU+Pj6FtrIPCQmxOq5du7Z27txpOfbx8dE777wjT09PhYWFqW7dujfMPnjwoJycnCwNopJkb2+viIgIq/coSQ8//LClQVSSHnroIUmiSRQAAAAAAAAAAAAAAACAYW60UujNuLi4KD09vdD51NRUubq63tZcXl5eCgoK0nfffWc1//W9ctfPX6VKldsv+DbQJPo3dq3B0sbGRhUqVFCVKlVkMpkkybKEbcWKFa3uuXackpJiOefo6Kjy5cvfUubhw4f1zDPPqGXLlho8eLA8PDxkY2Oj7t27Kzs7+7afwWQyyc/Pr9D5vXv3FjrXvXt39ezZUz/++KO8vLy0d+9eTZ06tdC46xsgpf975qSkJEnSxYsX9c033xS5gmmNGjWsjq/fev5mLl68qLVr11q2ob+evb291fEflza2t7fXlStXLMeTJk2yrEo6a9YsValSRUOGDLE0yP5RWlpakbVWrFix0HLGRWVLuqOfHwAAAAAAAAAAAAAAAAAYrVatWjpx4oTVufT0dCUlJalWrVolMv9PP/1kda6goEC//vqrmjZtetfz3whNon9jxTVYSpKbm5sk6cKFC6pUqZLl/Pnz562uS5LNbSyXvHv3bjk5OWnBggWWhtTTp0/fZuV3JjAwUHXq1NHWrVtVtWpVOTg4FFopVZKSk5Otjq89s6enp6SrK66GhYVp9OjRhe51cHCwOr6dd+Pq6qpmzZoV2ch5q0241zg7O+uFF17QCy+8oGPHjmndunWaMmWK6tatq4YNGxaZfeHChULnz58/f9ud8AAAAAAAAAAAAAAAAADwV/LYY49p6dKlSktLsyyiFx8fL5PJdNtNnGfPntVXX32lxx9/3Gr+7du36+TJk5adrz///HOlpKTc1i7ed4ImURTJz89P9vb2io+Pl4+Pj+X8Bx98IA8Pj0JbtP9RcatLZmVlyd7e3qp5cseOHSVX+E1069ZNr7/+ujw8PNS+ffsit4LftWuXIiMjLccffvihHB0dLVu2h4SEaPv27apdu/YtbyV/vT+u+nlNkyZN9PPPP8vHx0e2tra3PW9xzGazoqOj9fbbb+v48eNFNokGBQVp5cqV+s9//qPQ0FBJUm5urnbv3q2goKASqwUAAAAAAAAAAAAAAAAA7jc9e/bU+vXrNXz4cA0dOlRnz57VrFmz1LNnT6tFFvv376///e9/2rVrlyQpLi5OH3/8sZo1ayYvLy+dOnVKy5cvl62trQYMGGC5r02bNlq2bJlGjhypsWPH6vLly5o1a5aaN28uf3//e/psNImiSO7u7urTp49WrlwpBwcHBQQEaN++fYqLi9OkSZNu2sTo6ekpFxcX7dy5U9WrV5eDg4PMZrOaNm2qtWvX6uWXX1ZERIQOHTqk99577096Kunxxx/XnDlzdPHiRb3yyitFjvn9998VHR2t9u3b6/vvv9fy5cvVv39/y4qakZGR2rFjh/r06aN+/fqpatWqSk5O1rfffqtKlSpZNZgWpXbt2srNzdXatWsVGBgoJycn1apVS6NGjVLXrl01aNAgde/eXRUrVtT58+f15ZdfqmHDhurYseMtP2fPnj0VERGhOnXqyNbWVu+++67s7e2LbBCVZPnL5rnnntO4ceNUsWJFrV+/XufOndPChQtvORcAAAAAAAAAAAAAAAAA/mpcXV0tfW3Dhw9X+fLl1bVrV40ZM8ZqXH5+vvLy8izH1atX17lz5/Tqq68qPT1dzs7Oaty4sUaNGqUHHnjAMs7e3l5vvPGGpk2bprFjx8rOzk4RERH617/+dc+fjSZRFGv8+PFydnbW22+/raVLl6patWqaMmWKevbsedN7TSaTpk+frnnz5ikyMlJXrlzRnj171KxZM0VFRSk2Nlbbtm1TgwYNtGzZMrVp0+ZPeCLJzc1Njz76qBITExUQEFDkmDFjxujLL7/U6NGjZWtrq169eln9Ya9QoYI2bdqkBQsWaM6cOUpJSZGHh4fq16+viIiIm9bQokUL9erVS8uXL9eFCxfUqFEjrV+/Xg8++KC2bNmiBQsWaMqUKcrMzJSnp6caNWoks9l8W8/ZoEEDvfvuu0pISJDJZFLdunW1dOlS1a5du8jxtra2Wr58uWbNmqXZs2crMzNTvr6+WrVqlerVq3db2QAAAAAAAAAAAAAAAADwV1O7dm2tWbPmhmPWr19vdRwQEFDoXHEqVaqkmJiYOy3vjtkUFBQU/OmpgEEyMjIUFhamkSNHauDAgVbXEhIS1LJlS7322mtq27atQRX+/SSnZxqWveiLU4Zlj2law5DcK3nG/ZVva2NMblmTYOkCnwABAABJREFUcc+85ceLhuQ2quZiSK4kZeXmG5L7sHsZQ3Il6fzlvJsPukc8yhnz+z526ecMyZUkm9xsQ3LzyzobkitJNtmXDMmNeCvBkFwj7R3TzOgSAAAAAAAAAAAA8Bc0+p0jRpcASa918TO6hPsSK4nibyEjI0PHjx/Xhg0bZGNjoyeeeMLokgAAAAAAAAAAAAAAAAAAuKdoEsXfwnfffad+/fqpSpUqmjlzptzc3IwuCQAAAAAAAAAAAAAAAACAe4omUfwtBAcH69ixYzccU7169ZuOAQAAAAAAAAAAAAAAAADgr8JkdAEAAAAAAAAAAAAAAAAAAAAoeTSJAgAAAAAAAAAAAAAAAAAAlEI0iQIAAAAAAAAAAAAAAAAAAJRCNIkCAAAAAAAAAAAAAAAAAACUQnZGFwAAAAAAAAAAAAAAAAAAwF+VrcnG6BKAYrGSKAAAAAAAAAAAAAAAAAAAQCnESqIADJV0Odew7D6BVQ3LvpyTb0iumy4bkitJKjDmmU0ZSYbkStJjDz5oSG5+QYEhuZJ06YoxubZpicYES7It42VYdnauMX+u7PJyDMmVpAIbY37HKdPexZBcSSpnMuaf7LP/6W5IrpE+O3nBsOyQmh6GZQMAAAAAAAAAAAAovVhJFAAAAAAAAAAAAAAAAAAAoBSiSRQAAAAAAAAAAAAAAAAAAKAUokkUAAAAAAAAAAAAAAAAAACgFKJJFAAAAAAAAAAAAAAAAAAAoBSiSRQAAAAAAAAAAAAAAAAAAKAUsjO6AAAAAAAAAAAAAAAAAAAA/qrsTDZGlwAUi5VEAQAAAAAAAAAAAAAAAAAASiGaRO9TMTExMpvNlq/GjRurX79+OnjwYInMn5aWppiYGP3yyy93dH/fvn01dOjQYq8//fTTat26dbHX169fL7PZrN9///2W8sLDwzV16tTbrvN6f3ynRX2Fh4dLuvnzGa0k3setut/fBQAAAAAAAAAAAAAAAACgaGw3fx8rW7as1q5dK0lKTEzUkiVLFBkZqW3btqlu3bp3NXdaWpoWLVqkOnXq6KGHHiqJcq107NhR48aN0+HDh+Xv71/o+s6dOxUQEKAaNWrc0nyLFi2Si4vLXdXUrVs3hYWFWY63bNmiuLg4yzuWJAcHh7vKKI1efPFFmUz0kwMAAAAAAAAAAAAAAADAXw1Novcxk8mkgIAAy7G/v7/Cw8O1ceNGTZ48+Y7nzcrKKoHqbqxly5YqV66c4uLiCjWJJiQk6NChQ5o4ceItz+fj43PXNVWuXFmVK1e2HO/fv7/QO75bWVlZKlu2bInNdz+4F03EAAAAAAAAAAAAAAAAAIB7j+UB/0KqVq0qd3d3JSQkSJLy8/O1ZMkShYeHq169emrbtq02btxodU9MTIwCAwN1+PBh9ejRQ35+fnrzzTfVsmVLSdLo0aMtW61fm3fOnDnq1KmTAgMDFRYWprFjx+rcuXO3Vaujo6NatmypDz74QPn5+VbXdu7cKVtbW7Vv317S1VVSo6KiFBwcLH9/f/Xu3VtHjx61uueP26tPmDBBHTt21IEDB9S5c2cFBASoa9euhe67W/Hx8WrTpo0CAwPVr18//f7775ZrCQkJMpvN2rZtmyZOnKjg4GB169ZNkpSSkqLo6GjLM/Xs2VP//e9/rea+to17XFycWrdurfr16+vpp59WamqqTp8+rUGDBikwMFAdOnTQgQMHiqzvjTfeUFhYmOrXr69hw4YV+jndSh1fffWVevfuraCgIAUGBqpTp0565513CtV5TWJiokaPHq2QkBD5+fkpPDxcr7766p29YAAAAAAAAAAAAAAAAADAPcNKon8hGRkZSklJkZeXlyRp1qxZWrdunYYNG6bAwEDt3btXL774onJzc9WnTx/LfTk5ORo3bpwiIyM1ZswYubm5adGiRRoxYoTGjh2r4OBgSbLMe+HCBQ0dOlReXl5KTk7W6tWr1bdvX+3cuVN2drf+kenUqZN27NihAwcOqEmTJpbzcXFxCgkJkYeHh1JTU9WrVy+VK1dOkyZNkrOzs9avX6/+/fvr3//+tzw8PIqdPykpSdOmTdOQIUPk7OysuXPnasSIEdq1a5fs7e1v690W5YcfflBycrKioqKUl5enGTNm6LnnntOmTZusxs2bN0/NmjXT3LlzlZ+fr7y8PA0ePFinTp1SVFSUKlasqPXr12vAgAHauHGj6tWrZ7n3+++/18WLFzV+/HhlZGRo2rRpmjRpkk6fPq3OnTtrwIABWrZsmUaOHKmPP/5Y5cuXt9y7a9cuVatWTS+99JLS0tI0Z84cjRw50lLfrdSRkZGhoUOHKigoSPPmzZODg4N++eUXpaWlFftexo8fr3PnzmnixIny8PDQmTNnSrw5FwAAAAAAAAAAAAAAAABw92gSvc/l5uZKurp648yZM5WXl6c2bdooOTlZsbGxGjRokEaOHClJCg0N1cWLF7V48WI9+eSTsrW1lXS1SXTMmDGWlTslycnJSZL04IMPFtpuffr06Zbv8/LyFBgYqMcee0xffPGFQkNDb7n2pk2byt3dXTt37rQ0if7000/66aefNGjQIEnS2rVrlZaWpi1btlgaQps0aaI2bdpo5cqVGj9+fLHzp6amKjY2VnXq1JF0dfXSfv366dtvv1XDhg1vuc7ipKen691335W7u7skKTMzU9HR0UpMTLTatv7hhx/WK6+8Yjnes2ePDh8+bFnlU7r6s2ndurWWLVummJgYy9iMjAwtXbrUknHs2DGtWrVKL730kp588klJV5t3O3XqpM8//1ytWrWy3Hvp0iWtWLFCzs7OkqTKlSsrMjJS+/fvV1hYmPbu3XvTOn799Velp6dr7NixMpvNkmTV0FuUI0eOaOzYsVafp86dO9/eywUAAAAAAAAAAAAAAABKCVuTjdElAMViu/n7WGZmpnx9feXr66uWLVvqwIEDmjx5ssLCwnT48GHl5OSobdu2Vve0a9dOycnJOnnypNX5Zs2a3XLuvn371LNnTwUFBcnHx0ePPfaYJBWa82bs7OzUtm1b/fvf/9aVK1ckXd1q3tHRUREREZKkTz/9VMHBwXJ1dVVubq5yc3NlMpnUqFEjHTly5Ibze3l5WRpEJemhhx6SJJ09e/a26izOww8/bGnevH7+xMREq3HNmze3Oj548KCcnJwsjZmSZG9vr4iICH311Vc3zKhZs6YkKSQkpNC5P+YGBwdbGkSlq82dbm5u+vbbb2+5jho1asjJyUkvvfSS3n//fSUnJxf/Qv4/Hx8frVq1Shs2bNBvv/120/EAAAAAAAAAAAAAAAAAAGOwkuh9rGzZsoqNjZWNjY0qVKigKlWqyGS62tebmpoqSapYsaLVPdeOU1JSLOccHR2ttim/kcOHD+uZZ55Ry5YtNXjwYHl4eMjGxkbdu3dXdnb2bT9Dx44dtWHDBu3fv18tW7ZUXFycwsPDLfVcvHhR33zzjXx9fQvdW6NGjRvO7eLiYnV8bYv5O6nzbua/tgLqNWlpaYXOSVd/Ntd+bjfLuL7508HB4ZZyJcnd3V1JSUm3XIerq6tWr16thQsXavz48crLy1PDhg01ceJEy8qifzR//nzNnz9fCxYs0JQpU+Tt7a2xY8eqdevWRY4HAAAAAAAAAAAAAAAAABiDJtH7mMlkkp+fX5HX3NzcJEkXLlxQpUqVLOfPnz9vdV2SbGxufTnj3bt3y8nJSQsWLLA0pJ4+ffo2K/8/DRo0ULVq1bRz5055eHgoISFBL7zwguW6q6urwsLCNHr06EL3XmuOvN/98f26urrqwoULhcadP39erq6uJZZbVEZycrI8PT1vqw5/f3+98cYbysrK0oEDBzRz5kwNHz5cu3fvLjLXy8tL06dPV35+vo4eParXX39dY8aMUXx8vB544IESejoAAAAAAAAAAAAAAAAAwN1iu/m/KD8/P9nb2ys+Pt7q/AcffCAPDw/LFuXFKW5VzKysLNnb21s1Pu7YseOO67SxsVHHjh310UcfafPmzXJzc7Pa/jwkJETHjx9X7dq15efnZ/VV3EqW97ugoCBlZGToP//5j+Vcbm6udu/eraCgoBLLOXDggNLT0y3Hn3/+uVJSUlS/fv07qqNs2bJq1qyZnnzySSUkJNx0RVaTySR/f389++yzys3NZet5AAAAAAAAAAAAAAAAALjPsJLoX5S7u7v69OmjlStXysHBQQEBAdq3b5/i4uI0adIk2dra3vB+T09Pubi4aOfOnapevbocHBxkNpvVtGlTrV27Vi+//LIiIiJ06NAhvffee3dVa8eOHbVs2TJt27ZNPXr0sDSoSlJkZKR27NihPn36qF+/fqpataqSk5P17bffqlKlSoqMjLyrbCM0b95c/v7+eu655zRu3DhVrFhR69ev17lz57Rw4cISyylfvrwGDx6swYMHKz09XXPmzJG/v7+lCfdW6ti7d6/efvtttWrVSlWrVtX58+cVGxurBg0aqEyZMoUy09PTNWjQID3++OPy9vZWTk6O1q9fLxcXF/n4+JTYswEAAAAAAAAAAAAAAAAA7h5Non9h48ePl7Ozs95++20tXbpU1apV05QpU9SzZ8+b3msymTR9+nTNmzdPkZGRunLlivbs2aNmzZopKipKsbGx2rZtmxo0aKBly5apTZs2d1xn3bp1ZTabdezYMXXq1MnqWoUKFbRp0yYtWLBAc+bMUUpKijw8PFS/fn1FRETccaaRbG1ttXz5cs2aNUuzZ89WZmamfH19tWrVKtWrV6/EciIiIlS5cmW9+OKLSktLU0hIiKZMmXJbddSoUUMmk0kLFizQhQsX5ObmptDQUI0dO7bIzDJlyqhu3bpav369zpw5o7Jly6pevXpauXKl3N3dS+zZAAAAAAAAAAAAAAAAAAB3z6agoKDA6CIA/H0dO5dmWLa9ycawbCd7kyG5brpsSK4kqSDfkFhTRpIhuZJ02vFBQ3LzDfxPe/LlPENy/R0uGpIrSefLeBmW7WhnzN9j5TPOGJJrpEtOVQzLLpeXaUjut6k3Xpm+NMrJN+a/VZIUUtPDsGwAAAAAAAAAAADcneid3xtdAiRN78BOyEVhJVEAAAAAAAAAAAAAAAAAAO6QrYELlQE3Y8xSdgAAAAAAAAAAAAAAAAAAALinaBIFAAAAAAAAAAAAAAAAAAAohWgSBQAAAAAAAAAAAAAAAAAAKIVoEgUAAAAAAAAAAAAAAAAAACiFaBIFAAAAAAAAAAAAAAAAAAAohWgSBQAAAAAAAAAAAAAAAAAAKIVoEgUAAAAAAAAAAAAAAAAAACiF7IwuAAAAAAAAAAAAAAAAAACAvypbk43RJQDFYiVRAAAAAAAAAAAAAAAAAACAUoiVRAEY6kTyZcOyWzzoYlj2d+ezDcl1M+6RlWJT3pBcW1cnQ3IlqbKuGJJ7xbaMIbmSVM3OmD/TBfnGPbO7Xa5h2bbp5wzJzXCuZkiuJDkqx7BsoyTL0ZDcgDLGfL4kqcDBmGc20i9J6YbkPuTpbEguAAAAAAAAAAAAgD8HK4kCAAAAAAAAAAAAAAAAAACUQjSJAgAAAAAAAAAAAAAAAAAAlEI0iQIAAAAAAAAAAAAAAAAAAJRCNIkCAAAAAAAAAAAAAAAAAACUQnZGFwAAAAAAAAAAAAAAAAAAwF+VrcnG6BKAYrGSKAAAAAAAAAAAAAAAAAAAQClEkygAAAAAAAAAAAAAAAAAAEApRJMo7rmYmBgFBgYWez0hIUFms1nx8fF/YlVFM5vNMpvNeuuttwpd+/TTTy3XExISbmveAwcOaOnSpSVVppW0tDTFxMTol19+uSfz9+3bV0OHDr0ncwMAAAAAAAAAAAAAAAAA7h2aRGE4Ly8vbdq0SY0bNza6FElSuXLl9P777xc6HxcXp3Llyt3RnF9++aWWLVt2t6UVKS0tTYsWLbpnTaIvvviinn/++XsyNwAAAAAAAAAAAAAAAADg3qFJFIZzcHBQQECA3Nzc/pS8rKysG15v2bKlDh48qLNnz1rOXblyRbt27VKrVq3udXn3nYceeki1atUyugwAAAAAAAAAAAAAAAAAwG2iSRSG++N28xMmTFDHjh0Ljfv4449lNpt14sQJy7lt27apU6dO8vPzU1hYmObPn6+8vDyr62azWYcOHdKAAQMUEBCgWbNm3bCeRx55RDVr1rRaTXTfvn0qKChQ8+bNC40vKCjQypUr1aZNG9WrV08tW7bUmjVrLNdjYmK0aNEiZWZmWrar79u3ryTp+PHjGjNmjJo1a6b69eurffv2WrVqlfLz860yli9froiICPn5+alx48aKjIzUqVOnlJCQoJYtW0qSRo8ebZk/ISFBkjRnzhx16tRJgYGBCgsL09ixY3Xu3Dmrub/66iv17t1bQUFBCgwMVKdOnfTOO+9Yrv9xu/nExESNHj1aISEh8vPzU3h4uF599dUbvlMAAAAAAAAAAAAAAAAAwJ/PzugCgD/q0KGD3nnnHf3000+qW7eu5XxcXJx8fX0tq1quXr1as2fPVv/+/TVhwgQdP37c0iQaFRVlNee4cePUo0cPDR06VI6OjrdUQ1xcnAYMGGDJjoiIUJkyZQqNfeWVV7RlyxY9/fTTql+/vr7++mvNmTNHZcqU0ZNPPqlu3bopMTFRcXFxWrt2rSTJyclJknTu3Dl5e3urU6dOKl++vH744QfFxMQoMzNTI0aMkCS9++67eu211zRq1CgFBAQoPT1dX331lS5duqRatWpp0aJFGjFihMaOHavg4GBJkpeXlyTpwoULGjp0qLy8vJScnKzVq1erb9++2rlzp+zs7JSRkaGhQ4cqKChI8+bNk4ODg3755RelpaUV+27Gjx+vc+fOaeLEifLw8NCZM2d09OjRm75TAAAAAAAAAAAAAAAAAMCfiyZR3HeaNGkid3d37dy509IkevnyZX300UeWxsmMjAwtXLhQTz31lMaOHStJatq0qezt7TVjxgwNGjRIFSpUsMzZs2dPDRky5JZr6Nixo2JiYvT777/Lw8NDe/fu1eLFiwttVf/7778rNjZWU6ZMUY8ePSRJISEhysrK0uLFi9WjRw9VrlxZlStXlslkUkBAQKFnbdKkiaSrK5IGBQUpKytLsbGxlmc9fPiwzGaz1Wqe1297/8gjj0iSHnzwwULzT58+3fJ9Xl6eAgMD9dhjj+mLL75QaGiofv31V6Wnp2vs2LEym82Wmm7kyJEjGjt2rNq3b28517lz5xveAwAAAAAAAAAAAAAAAJRWtiYbo0sAisV287jv2NnZqW3btlbbvX/88ce6fPmyOnToIEk6dOiQMjMz1bZtW+Xm5lq+rjVo/vzzz1ZzFrVN/I3UrFlTvr6+iouL0+7du1W+fPkimyc/++wzSVLr1q0L1ZGUlKQzZ87cMCc7O1sLFy60bCXv6+ur+fPnKykpSZcuXZIk+fj46Pvvv9f06dN18OBB5eTk3PJz7Nu3Tz179lRQUJB8fHz02GOPSZJOnjwpSapRo4acnJz00ksv6f3331dycvJN5/Tx8dGqVau0YcMG/fbbb7dcCwAAAAAAAAAAAAAAAADgz8VKorgvdejQQRs2bNDhw4fl7++vnTt3qmHDhqpcubIk6eLFi5KkLl26FHn/H5szK1aseNs1dOzYUVu3blXVqlXVrl072draFhpz8eJFFRQUqHHjxsXWUa1atWIzZs+erS1btmj48OGqV6+enJ2dtWfPHr3++uvKzs5W+fLl9cQTT+jSpUvavHmz1qxZI2dnZ3Xu3FlRUVEqW7ZssXMfPnxYzzzzjFq2bKnBgwfLw8NDNjY26t69u7KzsyVJrq6uWr16tRYuXKjx48crLy9PDRs21MSJEy0ri/7R/PnzNX/+fC1YsEBTpkyRt7e3xo4dq9atW9/odQIAAAAAAAAAAAAAAAAA/mQ0ieK+FBQUpCpVqmjnzp3y9vbWJ598on/961+W666urpKkRYsWWRpHr1e9evW7rqF9+/aaNWuWTpw4oTfffLPIMa6urrKxsdGGDRtkb29f6Lq3t/cNM+Lj49WjRw8NGTLEcm7fvn1WY0wmk/r376/+/fvr7Nmz2rlzp+bOnasKFSpo+PDhxc69e/duOTk5acGCBTKZri4afPr06ULj/P399cYbbygrK0sHDhzQzJkzNXz4cO3evbvIeb28vDR9+nTl5+fr6NGjev311zVmzBjFx8frgQceuOHzAgAAAAAAAAAAAAAAAAD+PDSJ4r5kY2Oj9u3bKy4uTnXq1FF+fr7atGljuR4YGChHR0clJiYqIiLintRQuXJl9e/fX8nJyWrQoEGRY65tQZ+SkqLw8PBi57K3t9eVK1cKnc/OzrZqLs3Ly9POnTuLnadSpUoaOHCg4uLidOLECcvc1+a6XlZWluzt7WVjY2M5t2PHjmLnLlu2rJo1a6bff/9dr7zyirKzs1WmTJlix5tMJvn7++vZZ5/VRx99pN9++40mUQAAAAAAAAAAAAAAAAC4j9Akij9FXl6e4uPjC5339/cv9p6OHTtq5cqVeu2119S0aVO5u7tbrrm4uGjUqFGaPXu2EhMT9eijj8rW1lanTp3Snj17FBMTI0dHx7uuOzo6+obXvb291bt3b40fP16DBg1S/fr1lZOTo5MnT+rAgQNasmSJJKl27drKzc3V2rVrFRgYKCcnJ9WqVUshISHasmWLHnroIVWoUEEbNmwo1Ew6efJkubi4KCAgQC4uLvr666/1448/6sknn5QkeXp6ysXFRTt37lT16tXl4OAgs9mspk2bau3atXr55ZcVERGhQ4cO6b333rOae+/evXr77bfVqlUrVa1aVefPn1dsbKwaNGhQZINoenq6Bg0apMcff1ze3t7KycnR+vXr5eLiIh8fn7t51QAAAAAAAAAAAAAAAACAEkaTKP4U2dnZGj16dKHzs2bNUlBQUJH3+Pj4yNvbW7/++quioqIKXR84cKAqVaqk1atXKzY2VnZ2dqpRo4aaN29e5Nbv98rEiRPl7e2tTZs2afHixSpfvry8vb3Vtm1by5gWLVqoV69eWr58uS5cuKBGjRpp/fr1mjRpkl588UW9/PLLcnR0VJcuXRQREaGJEyda7g0MDNTmzZu1ZcsWXb58WQ888ICio6PVrVs3SVdX9Jw+fbrmzZunyMhIXblyRXv27FGzZs0UFRWl2NhYbdu2TQ0aNNCyZcusVmStUaOGTCaTFixYoAsXLsjNzU2hoaEaO3Zskc9apkwZ1a1bV+vXr9eZM2dUtmxZ1atXTytXrrRq4gUAAAAAAAAAAAAAAAAAGM+moKCgwOgiAPx9ffDjWcOyWzzoYlj2d+ezDcn1c8k1JFeSUnT3q/veCVuTjSG5kuSkKzcfdA9csS28EvCfpcyVdGOC8437bBc4lDcs2zb9nCG5Gc7VDMmVJEflGJJ7WX/eL6D8UVaeMf9c98gy5vMlSQUOxvw3w0i/5xrzd8lDns6G5AIAAAAAAAAAAJQmr+z5yegSIOmFlnWNLuG+xEqiAAAAAAAAAAAAAAAAAADcISMXsAJuxmR0AQAAAAAAAAAAAAAAAAAAACh5NIkCAAAAAAAAAAAAAAAAAACUQjSJAgAAAAAAAAAAAAAAAAAAlEI0iQIAAAAAAAAAAAAAAAAAAJRCNIkCAAAAAAAAAAAAAAAAAACUQjSJAgAAAAAAAAAAAAAAAAAAlEJ2RhcAAAAAAAAAAAAAAAAAAMBfla3JxugSgGKxkigAAAAAAAAAAAAAAAAAAEApxEqiAAwVWMXJsOyfLl4xLNu/bJohuTYZlwzJlSRX50qG5ObZlTMkV5LOZ9kbknslO9eQXElycjDmz3RmXr4huZJU2abAsOz8chUMy/67KWtr3G/+Xcox5jNm5OfrdLatIbmXDXrXklTN2ZhnvpJyzpBcSXJw8zIsGwAAAAAAAAAAAPi7YCVRAAAAAAAAAAAAAAAAAACAUogmUQAAAAAAAAAAAAAAAAAAgFKIJlEAAAAAAAAAAAAAAAAAAIBSiCZRAAAAAAAAAAAAAAAAAACAUogmUQAAAAAAAAAAAAAAAAAAgFLIzugCAAAAAAAAAAAAAAAAAAD4q7I12RhdAlAsVhIFAAAAAAAAAAAAAAAAAAAohWgS/QuLiYmR2Wy2fAUHB+vJJ5/Uvn37SixjzZo1MpvNluMDBw7IbDbryJEjtzXPhAkT1LFjxxKr63p3WtPNJCQkyGw2Kz4+/objwsPDNXXq1Nu+dju5dzLPvWI2m7Vy5UqjywAAAAAAAAAAAAAAAAAA3ARNon9xZcuW1aZNm7Rp0ya9/PLLys7O1tNPP62vv/76nuT5+vpq06ZNql279j2Z/07cjzUBAAAAAAAAAAAAAAAAAGA0O6MLwN0xmUwKCAiwHNevX1/NmjXTu+++qwYNGpR4npOTk1Xe/eB+rKk0ysrKUtmyZY0uAwAAAAAAAAAAAAAAAABwi1hJtJSpVKmS3N3d9b///c9y7ty5c4qOjlbLli3l7++v1q1ba968ebpy5YrVvRkZGRo/frwCAwPVuHFjzZo1S3l5eVZjitraPTs7W9OnT1doaKj8/Pz0+OOPa9euXTet9dixYxo0aJACAgIUFBSkUaNGWdUtSenp6YqKilJgYKCaNGmiefPmadWqVTKbzTesKT8/X6tXr1a7du1Ur149NW3aVKNGjVJ6erok6fjx4xozZoyaNWum+vXrq3379lq1apXy8/Nv4S3fuZLKnTBhgjp27KjPPvtMnTp1kr+/v/r06aOEhASlpKRo9OjRatCggVq1aqX333/f6t69e/dqwIABatKkiRo0aKBu3brpk08+sRqzbds2mc1mHTp0SAMGDFBAQIBmzZpVZC2nTp1Sq1at9NRTTykrK+v2XggAAAAAAAAAAAAAAAAA4J5hJdFS5tKlS0pNTVX16tUt5y5evCg3NzdFR0fLxcVFJ0+eVExMjJKSkjR9+nTLuH/961/av3+/oqKiVL16dW3YsEFxcXE3zYyKitL+/fv17LPPqlatWnrvvfc0cuRILV68WC1btizynjNnzqhPnz564IEHNHv2bGVnZ2v+/Pnq06ePtm/fLicnJ0lSdHS0vvjiCz333HOqVq2aNm/erO++++6mNb388svatGmT+vfvr6ZNm+rSpUvau3evMjMz5ezsrHPnzsnb21udOnVS+fLl9cMPPygmJkaZmZkaMWLETef/o4KCAuXm5t50XEnmJiUlacaMGRo2bJjs7Ow0bdo0RUVFydHRUQ0bNlT37t21efNmPffcc6pfv76qVasmSUpISFCLFi00cOBAmUwmffLJJxoyZIjWrl2r4OBgq4xx48apR48eGjp0qBwdHQvVcOLECUVGRqp+/fqaO3euHBwcbusZAAAAAAAAAAAAAAAAAAD3Dk2ipcC15sRz585p9uzZKl++vPr162e5bjab9fzzz1uOGzRoIEdHR02YMEGTJ0+Wo6OjfvnlF/373//WtGnT1LVrV0lSaGioWrdufcPsH3/8Uf/+9781ZcoU9ezZU5L02GOP6fTp0zdsEl2zZo1yc3O1atUqubm5SZIeeeQRdejQQe+884769u2rX375Rbt27dLMmTPVuXNnSVJYWJjatWt3w5p+/fVXvfXWWxozZoyGDh1qOd+mTRvL902aNFGTJk0kXW3wDAoKUlZWlmJjY++oSXTDhg3asGHDTceVZG5qaqpiY2NVp04dSVd//i+//LIGDx6s4cOHS5L8/Py0a9cu7d69W/3795ck9enTxzJHfn6+goOD9csvv2jz5s2FmkR79uypIUOGFJn/448/auDAgQoNDdX06dNla2t7W/UDAAAAAAAAAAAAAAAAAO4tmkT/4jIzM+Xr62s5trW11ZIlS1SrVi3LuYKCAq1du1abN29WQkKCsrOzLddOnTqlunXr6siRIyooKFBERITVXK1atdKaNWuKzf/qq68kSW3btrU6365dO02fPl2ZmZkqV65cofsOHjyo4OBgS4OoJNWuXVsPP/ywvvrqK/Xt29eyffz1jaYmk0ktWrTQ6tWri63piy++UEFBgaXZtSjZ2dlatmyZduzYoTNnzignJ8dy7dKlSypfvnyx9xalXbt2GjRoUKHzw4YNu2e5Xl5elgZRSapZs6YkKSQkxHLOxcVF7u7uSkxMtJxLTEzU/Pnz9dlnnykpKUkFBQWSZPU5uqZ58+ZFZh85ckRLly5V+/bt9dJLL8nGxuaW6wYAAAAAAAAAAAAAAABKE1sTvTO4f9Ek+hdXtmxZxcbGqqCgQCdPntTcuXP1/PPPa8eOHfLy8pIkrV27VjNnztRTTz2l4OBgubi46MiRI5o6daqlYTQpKUn29vZydXW1mt/Dw+OG+ampqbK3t7dq9pSkihUrqqCgQOnp6UU2iaalpemRRx4pdN7Dw0OpqalWNTk7O1uNcXd3v2FNKSkpsrOzu2Hts2fP1pYtWzR8+HDVq1dPzs7O2rNnj15//XVlZ2ffdpOou7u7/Pz8Cp3/4/brJZnr4uJidWxvby9Jhd6Xg4OD5eecn5+vYcOGKT09XaNGjdKDDz4oR0dHLVy4UGfOnCmUUbFixSKzP//8c12+fFldu3alQRQAAAAAAAAAAAAAAAAA7lM0if7FmUwmS3Oiv7+/vL291b17dy1evFhTpkyRJMXHxys8PFzjxo2z3Hf8+HGreTw9PZWTk6PU1FSrRtELFy7cMN/V1bXI+86fPy8bG5tCDYvX31fU3BcuXLCsiHmtpvT0dKt5kpOTb1iTm5ubcnNzdeHChWIbRePj49WjRw+rrdT37dt3w3lLglG51/z222/6/vvvtXjxYrVq1cpyPisr67bmGTRokI4ePaqnnnpK69atk9lsLulSAQAAAAAAAAAAAAAAAAB3yWR0AShZfn5+6tChg7Zt26akpCRJVxsAr60yec2OHTsK3SdJu3btspzLy8vT7t27b5gXFBQk6Wrz4/Xi4+Pl4+NT5Cqi1+774osvLKuGStKJEyd07Ngxy5z16tWTJO3Zs8cyJj8/Xx9//PENa2rcuLFsbGy0devWYsdkZ2dbvZO8vDzt3LnzhvOWBKNyr8+XZFXD6dOndejQoduax9bWVnPnzlVgYKAGDBigEydOlGidAAAAAAAAAAAAAAAAAIC7x0qipdAzzzyj999/X2vXrlVUVJRCQkK0bt06xcbGqmbNmtq+fbt+++03q3seeughRURE6NVXX1V2draqV6+uDRs2KCcn54ZZDz/8sFq3bq0ZM2YoKytL3t7e2r59uw4dOqQlS5YUe19kZKS2bdumgQMHatiwYcrOztaCBQtUpUoVdenSRZJUp04dRUREaNq0abp8+bKqVq2qzZs3Kysr64ZbnHt7e6tnz5567bXXlJqaqiZNmigrK0t79+7VyJEjValSJYWEhGjLli166KGHVKFCBW3YsEFXrly5jbd8Z4zKvaZWrVqqXLmy5s6dq/z8fGVmZmrhwoXy8vK67bns7e21cOFCPf3004qMjNSbb76pBx544B5UDQAAAAAAAAAAAAAAAAC4E6wkWgrVqlVL7du311tvvaX09HQNHz5cnTp10sKFCzV27FiVKVNGEydOLHTfq6++qvDwcM2ZM0fjx4+Xt7e3+vfvf9O82bNnq1u3blqxYoWeeeYZ/fTTT1q4cKHCw8OLvadKlSpav369XF1dFRUVpUmTJunhhx/W+vXr5eTkZFVT8+bNNWvWLI0fP14PPPCAunTpUuw29tdMnjxZY8aM0e7du/X000/rpZde0qVLl1S+fHlJ0qRJk9SoUSO9/PLLeuGFF1S3bl09/fTTN33Wu2VU7jUODg6KiYmRg4ODRo8erYULF2rYsGF69NFH73i+xYsXq0aNGurfv7/OnDlTwhUDAAAAAAAAAAAAAAAAAO6UTUFBQYHRRQC3o3fv3jKZTFq/fr3RpaAEJKZeMiz73KVcw7IfsU81JNfminHvO8+5kjG59uUMyZWki1l5huReycs3JFeSnBxsDcnNzDHumSuXNe6fUja52YbkZtoa9+fKUTde5fxeKbB1MCRXki5kGfP5rmhnzLuWpNPZxvxdcjnHuD/P1ZyN2eShXG6GIbmS5OB2+6vZAwAAAAAAAAAA3I9e+/SE0SVA0uimtYwu4b7EdvO4r3344Yc6c+aM6tatq8uXLysuLk4HDx7U4sWLjS4NAAAAAAAAAAAAAAAAAGRrsjG6BKBYNInivlauXDm99957OnnypHJyclSrVi3Nnj1brVq1Mro0AAAAAAAAAAAAAAAAAADuazSJ4r4WFhamsLAwo8sAAAAAAAAAAAAAAAAAAOAvx2R0AQAAAAAAAAAAAAAAAAAAACh5NIkCAAAAAAAAAAAAAAAAAACUQjSJAgAAAAAAAAAAAAAAAAAAlEI0iQIAAAAAAAAAAAAAAAAAAJRCNIkCAAAAAAAAAAAAAAAAAACUQnZGFwAAAAAAAAAAAAAAAAAAwF+VrY2N0SUAxWIlUQAAAAAAAAAAAAAAAAAAgFKIlUQBGCo3r8Cw7H6LPjUs+8vnGhiSm1a2oiG5kuSacdqQXLtcY3Il6ctUY953+5rlDMmVpI3HUgzJ7VjXw5BcSUrKzjcsu4ydMT/r1Mt5huRKUnUnB0NybdPPGpIrSZ4mY/7JviPBuN8n86/kbEjugdMphuRKUtMabobkejo6GZIrSb8b+L4DqrkZlg0AAAAAAAAAAAD8mVhJFAAAAAAAAAAAAAAAAAAAoBSiSRQAAAAAAAAAAAAAAAAAAKAUokkUAAAAAAAAAAAAAAAAAACgFKJJFAAAAAAAAAAAAAAAAAAAoBSiSRQAAAAAAAAAAAAAAAAAAKAUsjO6AAAAAAAAAAAAAAAAAAAA/qpMNjZGlwAUi5VEAQAAAAAAAAAAAAAAAAAASiGaRO+Bffv2afDgwWrcuLF8fX0VEhKiIUOGKC4uTvn5+UaXd09duXJF0dHRaty4scxms9asWXPTe/7xj3/IbDbr4MGDha4dOHBAZrNZR44cKdE6ExISZDabFR8ff1/N9Wdq2LChYmJijC4DAAAAAAAAAAAAAAAAAHCPsN18CZs3b56WLVumiIgITZ48WZ6enjp//rx2796t5557Tq6urgoLCzO6zHvmvffe03vvvacZM2aoRo0aqlat2g3H//zzzzp27JgkaceOHWrYsOGfUSYAAAAAAAAAAAAAAAAAAKUeTaIlaO/evVq2bJlGjBihkSNHWl1r166d+vfvLzu74l95Xl6e8vPzZW9vf69LvWdOnDghLy8v/eMf/7il8Tt27JDJZFKjRo0UHx+viRMn/qWf3yil4bMDAAAAAAAAAAAAAAAAAChZbDdfglavXi1PT08NGzasyOv+/v7y8fGxHPft21dDhw7VO++8ozZt2sjPz08//vijzp07p+joaLVs2VL+/v5q3bq15s2bpytXrljNZzabtXz5cs2fP19NmjRRw4YNNWvWLBUUFOjzzz/X448/rsDAQPXv319nzpyxunf58uWKiIiQn5+fGjdurMjISJ06deqGz3f69GmNGjVKQUFBCggI0KBBgyyrgEpSeHi4Vq1apTNnzshsNstsNishIaHY+QoKChQXF6fGjRtrwIABSklJ0f79+29YgyTl5+dr9erVateunerVq6emTZtq1KhRSk9Pt4z573//q549e8rf31/BwcGKjo5WSkpKobmys7M1depUNWrUSKGhoZo5c6Zyc3OtxtzqXDdz7ec1a9YsNW7cWIGBgZowYYIyMjKsxqWlpemll15SaGio6tWrpyeeeEL/+c9/rMYU99kpzu7du9W2bVv5+fmpa9euOnz4cKExe/fu1YABA9SkSRM1aNBA3bp10yeffGK5npycrHr16mnz5s2F7u3WrZtGjx59u68EAAAAAAAAAAAAAAAAAHAPsZJoCcnNzdXXX3+tNm3a3HC10D86evSoTp8+rdGjR8vFxUVVqlTRhQsX5ObmpujoaLm4uOjkyZOKiYlRUlKSpk+fbnX/m2++qUcffVSzZs3St99+q5iYGOXn5+vTTz/VsGHDZG9vr2nTpumFF17QqlWrJEnvvvuuXnvtNY0aNUoBAQFKT0/XV199pUuXLhVbZ0ZGhvr27SuTyaQpU6aoTJkyev3119WnTx9t375dVapU0aJFi7RixQr997//1aJFiyRJXl5exc759ddf6/Tp0xo+fLhCQ0Pl5uamuLg4hYeH3/Cdvfzyy9q0aZP69++vpk2b6tKlS9q7d68yMzPl7Oyso0ePasCAAQoODtZrr72m8+fPa+7cufrll1+0ceNG2draWuZasGCBWrZsqQULFujQoUOKiYlRjRo19OSTT1p+Prc6161Yv369fH19NXPmTCUkJGjOnDnKzs7W/PnzJUlXrlzRgAEDdOHCBT377LOqVKmStm/frqFDh2rbtm0ym82WuYr67BTlhx9+0KhRo/TYY48pOjpaCQkJevbZZws1HSckJKhFixYaOHCgTCaTPvnkEw0ZMkRr165VcHCw3N3dFRERoa1bt6p79+6W+37++WcdPnxYo0aNuq13AQAAAAAAAAAAAAAAAAC4t2gSLSEpKSm6cuVKoUa9goIC5eXlWY5NJpNMpv9bwDU1NVVvv/221X0VK1bU888/bzlu0KCBHB0dNWHCBE2ePFmOjo6Wa15eXpo9e7YkKSwsTB999JHWrFmjnTt3qnbt2pKks2fP6uWXX1ZaWppcXFx0+PBhmc1mDR061DJPq1atbvh827Zt0//+9z+reRs1aqQWLVpo7dq1mjBhgnx8fFSxYkU5ODgoICDgpu8sLi5OZcqUUevWrWVvb682bdpo+/btunTpksqXL1/kPb/++qveeustjRkzxqr+Nm3aWL5funSpPD09tXTpUsv261WqVNGgQYO0b98+qyZUf39/TZw4UZLUtGlTHThwQB9++KGlSfR25roVDg4OWrx4saW5tEyZMpo4caJGjBih2rVra8eOHfrxxx/13nvv6aGHHpJ09ef622+/acmSJXrttdcscxX12SnK8uXLVaVKlUK5L7zwgtW4Pn36WL7Pz89XcHCwfvnlF23evFnBwcGSpO7duysyMlLHjx+3fA62bt2qKlWqqGnTprf1LgAAAAAAAAAAAAAAAIDSwNbG6AqA4rHdfAmzsbH+E//hhx/K19fX8jVt2jSr63Xr1i2ysXTNmjVq3769/P395evrq6ioKOXm5hbaEj4kJMTq2NvbW15eXpYGPkmqWbOmJCkxMVGS5OPjo++//17Tp0/XwYMHlZOTc9PnOnjwoOrUqWM1r5ubm0JCQvTVV1/d9P4/ys3NVXx8vJo1ayZnZ2dJUqdOnXT58mXt2rWr2Pu++OILFRQUqGvXrjestWXLlpamTkkKDQ2Vi4tLoVpDQ0OtjmvXrm15T7c7161o0aKF1eqjbdu2VUFBgY4cOSJJ+vTTT1W3bl3VrFlTubm5lq+QkBDLmGuK+uwU5dtvvy0y948SExP1/PPPKywsTD4+PvL19dV//vMf/frrr5YxjRs31gMPPKC3335b0tWf4/bt29WlSxer5mcAAAAAAAAAAAAAAAAAgPFYSbSEuLm5ycHBwarBUJKaNGliaagbNmxYofsqVqxY6NzatWs1c+ZMPfXUUwoODpaLi4uOHDmiqVOnKjs722qsi4uL1bG9vX2R5yRZ7n3iiSd06dIlbd68WWvWrJGzs7M6d+6sqKgolS1btsjnS0tLK7JWDw8P/fzzz0XecyOffvqpkpOT1aJFC6WlpUm62vTo6empuLg4de7cucj7UlJSZGdnJw8Pj2LnTktLK/K6h4eHUlNTrc5da1C9xt7e3mob9tuZ61b8cS4nJyeVKVNG586dkyRdvHhR33//vXx9fQvd+8et7Yv6eRQlKSmp2Nxr8vPzNWzYMKWnp2vUqFF68MEH5ejoqIULF+rMmTOWcTY2NurWrZvWrVuncePGae/evUpOTtYTTzxxS7UAAAAAAAAAAAAAAAAAAP48NImWEDs7OzVo0ECff/658vLyLA19rq6u8vPzk3R1q/E/+uPKo5IUHx+v8PBwjRs3znLu+PHjJVaryWRS//791b9/f509e1Y7d+7U3LlzVaFCBQ0fPrzIe1xdXa1WlLzmwoULcnV1ve0aduzYIUmKjo5WdHS01bWLFy/qwoULRTZnurm5KTc3t9jr12q9cOFCidRaknNdu+96GRkZys7OlpeXlyXPbDbrlVdeuelcRX12iuLp6Vls7jW//fabvv/+ey1evFitWrWynM/Kyio03xNPPKGFCxdq7969evvttxUcHKwHHnjglmoBAAAAAAAAAAAAAAAAAPx52B+6BA0YMEDnzp3T0qVL72qerKwsq+3Npf9rqixplSpV0sCBA2U2m3XixIlixwUFBemnn36yGpOamqrPPvtMQUFBt5V5+fJl7dmzR61atdK6deusvubNm6fc3Fy9//77Rd7buHFj2djYaOvWrTesdc+ePcrNzbWc+/TTT5WWlnbbtZbkXJL08ccfKy8vz3IcHx8vGxsbSyNxSEiITp06JS8vL/n5+RX6uhP+/v5F5l7vWsPo9Z+706dP69ChQ4Xm8/T0VPPmzfXGG29o//79+uc//3lHdQEAAAAAAAAAAAAAAAAA7i1WEi1BzZs315AhQ7Rw4UL9+OOPateunby8vJSenq6DBw8qKSlJ5cuXv+k8ISEhWrdunWJjY1WzZk1t375dv/32W4nVOXnyZLm4uCggIEAuLi76+uuv9eOPP+rJJ58s9p4nnnhCa9as0dChQ/Xss8+qTJkyev3112VnZ6f+/fvfVv6ePXuUmZmpvn37Kjg4uND1N954Q3Fxcerbt2+ha97e3urZs6dee+01paamqkmTJsrKytLevXs1cuRIVapUSU8//bR69uypoUOHqm/fvjp//rzmzp0rf39/NWvW7LZqLcm5JOnKlSsaPny4nnzySSUkJGjOnDlq06aNateuLUnq3LmzNm7cqH79+mngwIGqWbOm0tPT9f333ysnJ8dqddlbNWTIEHXt2tUqd+XKlVbbzdeqVUuVK1fW3LlzlZ+fr8zMTC1cuNCywukfde/eXUOGDJGLi4vatGlz2zUBAAAAAAAAAAAAAAAAAO49mkRL2Lhx4xQUFKQ333xTU6ZMUUZGhlxdXeXr66tXX31VHTp0uOkcw4cP18WLF7Vw4UJJUps2bTRx4kQ9/fTTJVJjYGCgNm/erC1btujy5ct64IEHFB0drW7duhV7j5OTk9avX68ZM2Zo0qRJys/PV4MGDRQbG6sqVarcVn5cXJyqVq1aZIOodLVR8tVXX9Xvv/9e5PXJkyerevXq2rJli9auXSs3Nzc1atTI0oBbr149rVq1SvPmzdPIkSNVrlw5hYeH6/nnn5etre1t1VqSc0lS3759lZycrPHjx+vKlSuKiIjQ5MmTLdcdHBy0bt06xcTEaOnSpUpKSpKbm5t8fHzUq1ev286TJB8fH7322muaM2eORowYoTp16mj+/PkaNGiQVW5MTIymTp2q0aNHq0qVKho2bJi++OILHT16tNCcoaGhcnR0VIcOHayaTQEAAAAAAAAAAAAAAAAA9w+bgoKCAqOLAP4OzGazxo8fb9Wc+Vf1+eefKzIyUlu3blW9evXuaq6E5IwSqur2dZzziWHZXz7XwJDcdDsXQ3IlyTXjtCG5NrlZhuRK0vbUiobktq9ZzpBcSdp4LM2Q3I51PQzJlaTLOfmGZZexMxmSm5qdZ0iuJFV3MuZ3nGzTzxqSK0kFJmOeeccZYz5fkuRfydmQ3P2/XzQkV5Ka1nAzJNfT0bjfG/w97Yph2QHV3AzLBgAAAAAAAAAApc8bX5bcLtG4c089+qDRJdyXWEkUwC07e/asfv/9d82ePVsNGjS46wZRAAAAAAAAAAAAAAAA4K/OZLIxugSgWMYtDwTgL2fz5s3q16+fJGnatGkGVwMAAAAAAAAAAAAAAAAAuBFWEgX+JMeOHTO6hLs2cuRIjRw50ugyAAAAAAAAAAAAAAAAAAC3gJVEAQAAAAAAAAAAAAAAAAAASiGaRAEAAAAAAAAAAAAAAAAAAEohmkQBAAAAAAAAAAAAAAAAAABKIZpEAQAAAAAAAAAAAAAAAAAASiGaRAEAAAAAAAAAAAAAAAAAAEohO6MLAAAAAAAAAAAAAAAAAADgr8rWxsboEoBi0SQKwFCVs04bln0gOsSw7IMX8gzJDalZzpBcSbqS7WhMcJnyxuRKeszN1ZhgG2M+X5KUkHLZkFznvAxDciXJyaGMYdk2uZmG5Lo4GvfMeTLmf1zlOlUyJFeS7Az635PVXIz58yxJ+SowJLdPLeP+59HlMvaG5JbNM+7nXM90wbDs1EvG/D3mWt6gfw8BAAAAAAAAAADgb4vt5gEAAAAAAAAAAAAAAAAAAEohmkQBAAAAAAAAAAAAAAAAAABKIZpEAQAAAAAAAAAAAAAAAAAASiGaRAEAAAAAAAAAAAAAAAAAAEohmkQBAAAAAAAAAAAAAAAAAABKITujCwAAAAAAAAAAAAAAAAAA4K/KZGNjdAlAsVhJFAAAAAAAAAAAAAAAAAAAoBSiSfQOxcTEyGw2W74aN26sfv366eDBgyWak5CQILPZrPj4+BKd91alpKRo+PDhatSokcxms3bv3n1H8xw4cEBms1lHjhwp4Qrv3g8//KCYmBhdvnzZ6FIAAAAAAAAAAAAAAAAAACgxbDd/F8qWLau1a9dKkhITE7VkyRJFRkZq27Ztqlu3rsHVlYzVq1frwIEDmjlzpjw8POTt7X1H8/j6+mrTpk2qXbt2CVd493744QctWrRIvXv3lqOjo9HlAAAAAAAAAAAAAAAAAABQImgSvQsmk0kBAQGWY39/f4WHh2vjxo2aPHmycYWVoF9//VVms1ktW7a8q3mcnJys3tW9duXKFdnZ2clkKl2L5WZlZals2bJGl1Gk+7k2AAAAAAAAAAAAAAAAAPg7Kl0ddAarWrWq3N3dlZCQIElatWqV/vnPfyooKEhNmjTR0KFD9euvvxa679ChQxo4cKAaNGigwMBAdevWTZ9++mmxOd99950aN26s6Oho5efnKycnRzNnzlTz5s1Vr149hYaG6umnn1Z6evoN6z127JgGDRqkgIAABQUFadSoUfrf//5nuW42m/Xhhx/q4MGDMpvNMpvNN5xv79696tmzp+rXr69GjRqpb9+++v777yUVvd18enq6oqKiFBgYqCZNmmjevHlatWqVVU5mZqamTp2qNm3aqH79+goPD9fkyZMLPVt4eLimTp2qFStWqEWLFvL391dKSookadu2berUqZP8/PwUFham+fPnKy8vz3ItOjpaktSkSROZzWaFh4dLktLS0jRx4kSFhYXJz89PzZo105gxY274DmJiYhQYGKjDhw+ra9eu8vPzU7t27fTxxx8X+b66desmf39/NW7cWC+++KIyMzMt16+9s71792rUqFFq0KCBRo8eXWTuyJEj1bNnz0LnN2zYID8/P8u7KCgo0MqVK9WmTRvVq1dPLVu21Jo1a6zuOX78uMaMGaNmzZqpfv36at++vVatWqX8/HzLmISEBJnNZm3btk0TJ05UcHCwunXrdsN3AwAAAAAAAAAAAAAAAAD4c7GSaAnKyMhQSkqKvLy8JF3dgr5Pnz6qWrWqMjIytHHjRvXs2VMffvih3NzcJElfffWV+vfvr4CAAE2bNk0uLi46evSoVbPm9b766isNHTpUnTt31gsvvCAbGxstWbJEGzduVFRUlOrUqaOLFy/q008/1ZUrV4qt9cyZM+rTp48eeOABzZ49W9nZ2Zo/f7769Omj7du3y8nJSZs2bdKcOXN06dIlvfjiizd89vfff19jx45Vy5YtNXfuXNnb2+vrr7/W2bNn5ePjU+Q90dHR+uKLL/Tcc8+pWrVq2rx5s7777jurMVlZWcrLy9OYMWPk7u6uM2fOaOnSpXrmmWe0fv16q7H//ve/9eCDD+qFF16QyWRSuXLltHr1as2ePVv9+/fXhAkTdPz4cUuTaFRUlJo3b65hw4bp9ddf1xtvvCFnZ2c5ODhIkqZPn679+/dr3LhxqlatmpKSkvTJJ5/c8D1IUk5OjsaMGaOBAweqevXqeuuttzRixAht27bN0gAbHx+vMWPG6IknntDIkSOVlJSkuXPnKi0tTfPnz7eab9KkSfrHP/6hxYsXF7syardu3TR48GCdOHFCtWrVspzfunWrIiIiLJ+3V155RVu2bNHTTz+t+vXr6+uvv9acOXNUpkwZPfnkk5Kkc+fOydvbW506dVL58uX1ww8/KCYmRpmZmRoxYoRV7rx589SsWTPNnTvXqokUAAAAAAAAAAAAAAAAAGA8mkTvUm5urqSrDaEzZ85UXl6e2rRpI0n617/+ZRmXl5enpk2bqkmTJvrwww/Vo0cPSdLs2bP14IMPau3atbK1tZUkhYaGFpn12Wefafjw4erbt6/Gjh1rOX/kyBGFhoaqd+/elnPXaijOmjVrlJubq1WrVlkaCB955BF16NBB77zzjvr27auAgAC5uLjIxsbmhlvFFxQUaObMmWratKkWL15sOd+sWbNi7/nll1+0a9cuzZw5U507d5YkhYWFqV27dlbj3N3dNWXKFMtxbm6uqlevrl69eunXX3+Vt7e35VpOTo5WrFihcuXKSbratLtw4UI99dRTlvfVtGlT2dvba8aMGRo0aJDc3d1Vo0YNSZKvr6/c3d0t8x05ckQdO3ZUly5dLOc6dOhQ7DNdX8ewYcPUtWtXSVd/nq1bt9ayZcs0b948FRQUaNasWWrfvr1eeeUVy32enp4aMmSInnnmGdWpU8dyPjw8XM8999wNM0NDQ1W1alVt3brVMvann37S0aNHLc/++++/KzY2VlOmTLF8/kJCQpSVlaXFixerR48eMplMatKkiZo0aSLp6s82KChIWVlZio2NLdQk+vDDD1s9AwAAAAAAAAAAAAAAAADg/sF283chMzNTvr6+8vX1VcuWLXXgwAFNnjxZYWFhkqRvvvlGAwYMUHBwsHx8fFS/fn1lZmbq5MmTkqTLly/r22+/VefOnS0NosXZu3evhg4dqqefftqqQVSSfHx8tG/fPsXExOjw4cO3tKLjwYMHFRwcbGkQlaTatWvr4Ycf1ldffXVb7+HEiRNKTEzUP//5z1u+59q28y1btrScM5lMatGiRaGx7777rjp37qzAwED5+vqqV69ekmR5j9cEBwdbGkQl6dChQ8rMzFTbtm2Vm5tr+brWGPnzzz/fsEYfHx+98847WrlypX766adbfjZJioiIsHxva2urVq1a6dtvv5Uk/frrrzp9+rTatWtnVdejjz4qk8mko0ePWs3VvHnzm+aZTCb985//1HvvvWdpXN66dauqVatmafj87LPPJEmtW7cu9D6SkpJ05swZSVJ2drYWLlyoiIgI+fn5ydfXV/Pnz1dSUpIuXbp027UBAAAAAAAAAAAAAAAApZmtDV/3wxeKxkqid6Fs2bKKjY2VjY2NKlSooCpVqli2A//f//6ngQMHql69epoyZYq8vLxkb2+voUOHKjs7W5KUlpam/Px8y/b0N/Lxxx/L0dFR7du3L3Rt2LBhMplMeuedd7Ro0SK5u7urd+/eGj58uGxsiv70p6Wl6ZFHHil03sPDQ6mpqbfzGpSSkiJJt/Qc1yQlJcne3l7Ozs5W569fyVOSdu3apeeff149evTQmDFj5ObmpqSkJA0fPtzyHq+v/XoXL16UJKuVQK93rSmyOJMmTZKrq6tWr16tWbNmqUqVKhoyZIilSbU49vb2cnV1LVRbUlKSVV3Dhw+/pbr++FzF6dq1q5YsWaJ9+/bpscce0/bt29WrVy/LZ/LixYsqKChQ48aNi82tVq2aZs+erS1btmj48OGqV6+enJ2dtWfPHr3++uvKzs5W+fLlb7s2AAAAAAAAAAAAAAAAAMCfjybRu2AymeTn51fktf379yszM1OLFi2Si4uLpKtbpV/fgOns7CyTyaRz587dNGvChAnavHmzIiMj9eabb6py5cqWaw4ODho5cqRGjhyp3377TVu3blVMTIyqV69u2cr9j1xdXXXhwoVC5y9cuKCaNWvetJ7rXVuN9Fae4xpPT0/l5OQoPT3dqlE0OTnZalx8fLweeeQRTZ061XLuyy+/LHLOPzbEXmvUXLRokdX7uqZ69eo3rNHZ2VkvvPCCXnjhBR07dkzr1q3TlClTVLduXTVs2LDY+3JycpSammrVKHrhwgV5enpK+r/3NXnyZPn7+xe6/4/NtsU1+v5R5cqVFRYWpq1btyovL08XL17UE088Ybnu6uoqGxsbbdiwQfb29oXu9/b2lnT1nffo0UNDhgyxXNu3b1+RmbdaGwAAAAAAAAAAAAAAAADgz8d28/dIVlaWbGxsZGf3f324H3zwgWUrcEkqV66cAgIC9N577ykvL++G8zk6OmrFihVyc3NT//79df78+SLHPfjggxo7dqzc3Nx04sSJYucLCgrSF198YdW0euLECR07dkxBQUG3+piSpFq1aqly5cratm3bLd9Tr149SdKePXss5/Lz8/Xxxx9bjcvKyirU0Lhjx45byggMDJSjo6MSExPl5+dX6KtChQqSZJn/ypUrxc5lNpsVHR0tSTp+/PhNs3ft2mX5Pi8vT7t371b9+vUl/d/7OnXqVJF1VapU6ZaeryjdunXTvn37tGrVKjVp0kTVqlWzXLu27XxKSkqRuU5OTpKubjd//TvPy8vTzp0777gmAAAAAAAAAAAAAAAAAIAxWEn0Hrm2pXd0dLR69uypn3/+WatXr7asKnrNuHHjFBkZqcjISPXq1Uuurq767rvvVKFCBXXt2tVqrJOTk1atWqV+/fppwIABWrdunSpUqKBnnnlGvr6+8vHxkaOjoz7++GOlpqYWu624JEVGRmrbtm0aOHCghg0bpuzsbC1YsEBVqlQpdnv24tjY2Oj555/X2LFjNXLkSD3++ONycHDQN998Iz8/P7Vo0aLQPXXq1FFERISmTZumy5cvq2rVqtq8ebOlufaakJAQTZ06VYsXL1ZgYKD27dunzz///JbqcnFx0ahRozR79mwlJibq0Ucfla2trU6dOqU9e/YoJiZGjo6Oql27tiTpzTffVKtWrVS2bFmZzWb17NlTERERqlOnjmxtbfXuu+/K3t7+hquISlebTq9tzV69enW99dZbSkxM1OLFiy3va8KECYqKilJmZqaaN28uR0dH/e9//9O+ffs0ZswYy6qet6t58+aqUKGCDh06pHnz5lld8/b2Vu/evTV+/HgNGjRI9evXV05Ojk6ePKkDBw5oyZIlkq6+8y1btuihhx5ShQoVtGHDhhs20AIAAAAAAAAAAAAAAAAA7k80id4jZrNZ06dP16JFizR06FA98sgjeu211/Tss89ajWvYsKHWrVunBQsWKDo6WiaTSXXq1Ck07hpXV1etXr1affr00aBBg7R27Vo1aNBAH3zwgVavXq28vDx5e3trzpw5CgkJKba+KlWqaP369Zo1a5aioqJkMpnUtGlTTZgwwbKi5O1o3769ypYtq6VLl2rs2LEqU6aMfHx8FBERUew9r776qqZOnapZs2bJwcFBXbp0UZ06dfTmm29axvTs2VMJCQmKjY3VypUrFRoaqrlz56p79+63VNfAgQNVqVIlrV69WrGxsbKzs1ONGjXUvHlzy2qZPj4+GjlypLZs2aI33nhDVapU0UcffaQGDRro3XffVUJCgkwmk+rWraulS5damkqLY29vr3nz5mnKlCn66aefVL16dS1cuFAPP/ywZUy7du3k4uKipUuXWlZGrVatmsLCwlSxYsVberai2NnZKTw8XPHx8UW++4kTJ8rb21ubNm3S4sWLVb58eXl7e6tt27aWMZMmTdKLL76ol19+WY6OjurSpYsiIiI0ceLEO64LAAAAAAAAAAAAAAAAAPDnsykoKCgwugjgmt69e8tkMmn9+vVGl3JHYmJitGrVKh06dMiQ/Pz8fLVq1UotWrTQpEmTDKnhduX+75hh2XnOlQzL/upCniG5ITU9DMmVpCvnE4wJNpmMyZWUbu9mSK6TyZjPlyTN+eKMIbnPBbkZkitJBXZlDMu2yc02JNfIZ86zNSY738B/MtvZ3HzMvfDNucvGBEuq4GjM77J522UYkitJl8tUMCS3bJ5xP2fbSxcMy77kUt2QXNfyjobkAgAAAAAAAACAe2vDIYN6ImClV6Ax/x/Q/Y6VRGGYDz/8UGfOnFHdunV1+fJlxcXF6eDBg5Zt2XHrrly5oh9//FEffvihEhMT1bt3b6NLAgAAAAAAAAAAAAAAAAAYjCZRGKZcuXJ67733dPLkSeXk5KhWrVqaPXu2WrVqZXRpfznnzp1Tt27d5O7urkmTJqlWrVpGlwQAAAAAAAAAAAAAAAD8LZhMBm0PCNwCmkRhmLCwMIWFhRldRokaOXKkRo4c+afnVq9eXceOGbdtOwAAAAAAAAAAAAAAAADg/vP/2LvvuK7K///jzzcIOFji3gPtrSgILsSFYoqlZZqZlahpiducYYNypTnSAkslV2plwyy1MDM1v+bIstSGmRvcIktk8/vDH+fjW8CVeooe99uN241znetcr9d1zuENn08vr8vO7AQAAAAAAAAAAAAAAAAAAABw51EkCgAAAAAAAAAAAAAAAAAAUAhRJAoAAAAAAAAAAAAAAAAAAFAIUSQKAAAAAAAAAAAAAAAAAABQCFEkCgAAAAAAAAAAAAAAAAAAUAgVMTsBAAAAAAAAAAAAAAAAAAD+rewsFrNTAArESqIAAAAAAAAAAAAAAAAAAACFECuJAjDVl/FupsW2FjGvTr5sCXtT4u44FmdKXElq6F7UlLh2SWdMiStJTh4lTYmbYzHv1/sQ/8qmxM2xZJkS90rwbNNCpxRxNiVuMRPvd2K6ObFLWtJMiStJlqx0U+KWK1HClLiSlGNS3FUnzIosOdnHmxK3RslipsSVpPLOFU2LnZVuzmd3WuYlU+JKUlk3836mAQAAAAAAAAAAYB5WEgUAAAAAAAAAAAAAAAAAACiEKBIFAAAAAAAAAAAAAAAAAAAohCgSBQAAAAAAAAAAAAAAAAAAKIQoEgUAAAAAAAAAAAAAAAAAACiEKBIFAAAAAAAAAAAAAAAAAAAohIqYnQAAAAAAAAAAAAAAAAAAAP9W9hazMwAKxkqiAAAAAAAAAAAAAAAAAAAAhRBFooVYRESErFar8dWsWTP17t1bu3fvvmMx4uPjNWTIEDVp0kRWq1XffPPNHRu7MPv555/1zDPPqEWLFvLx8VFQUJCGDx+uX375xejzzTffaMWKFbc1fkxMjCIiInTmzJk7lXK+wsLCtHPnzrsaAwAAAAAAAAAAAAAAAABweygSLeSKFi2qlStXauXKlXr11VcVHx+vvn376s8//7wj4y9evFg7d+7UtGnTtHLlSjVp0uSOjFuY/fjjj3rqqadUpEgRTZgwQfPnz9eAAQOUkpKivXv3Gv2++eYbffDBB7cVIzY2VpGRkTp79uydStvw008/acOGDTZtly5d0rx585SRkXHH4wEAAAAAAAAAAAAAAAAAbk8RsxPA3WVnZydfX1/jOHfVyg8//FDh4eG3PW5qaqqKFi2qI0eOyGq1ql27dn8719wxC7sPPvhAlSpV0ty5c2Vvby9JCggIUM+ePZWdnW1ydjdWsWJFffTRR/r000+VlpamzZs36/XXX1e3bt1ksVjMTg8AAAAAAAAAAAAAAAAA8P+xkuh/TMWKFeXh4aGYmBijbdWqVXrooYfk7e2tVq1aafbs2crKyrI5b7VatWfPHj399NPy9fXV9OnTZbVatX79eu3evdvY0j7X119/rS5dusjb21stW7bU1KlTlZaWZpzfuXOnrFarNm/erOHDh6thw4YaMWKEYmJiZLVatXr1aoWHh6tx48YKCAjQ4sWLJUnr1q1TcHCwGjZsqKFDhyoxMdEYMyUlRRMnTlRwcLAaNGigoKAghYeHKykpyeYeBAUFaeLEiVqxYoXatm2rRo0aafDgwYqLi7Ppl5iYqEmTJql169aqX7++goKCNGvWLJs+mzdv1mOPPSYfHx81a9ZMr7zyilJSUq77DBITE+Xh4WEUiF7Nzu7Kj2RYWJg+++wzHTx40Li3YWFhkqQ9e/Zo4MCBatmypXx9fdWlSxetXr3a5t727t1bktS9e3ebZ5P7LK+da5cuXYzxJengwYN69tln5e/vrwYNGig4OFhRUVGSpPLly2vatGnq1KmTtm/frvXr12vevHnq1auXihSh7hwAAAAAAAAAAAAAAAAA/imo6PqPSU5OVnx8vMqWLSvpynbxM2bMUJ8+fRQWFqZDhw4ZRaJjxoyxuXb06NF6/PHHFRoaqmLFiunhhx/WzJkzdenSJb3yyitGv40bN2r48OHq1KmTRo8ercOHD2v27Nk6deqU3nrrLZsxX375ZT388MOaO3euUSApSXPmzFGHDh305ptv6ptvvtG0adMUFxenXbt2aezYsUpOTtbkyZM1Y8YMTZo0SdKVlUizsrI0cuRIeXh46NSpU5o3b54GDx6sZcuW2cT99ttvdezYMYWHh+vixYuaOnWqJk2apNmzZ0uS0tPT1adPH8XGxmrIkCG67777dPr0af3444/GGNHR0Ro5cqS6deumYcOG6dy5c5o1a5YSExONcfJTr149vf3225ozZ44eeugheXp65umTW7R6+PBhzZw5U5Lk4eEhSTp58qQaNmyoJ554Qo6Ojvrpp5/00ksvKScnR127dlW9evUUHh6uiRMnaurUqapZs2aBuRRk4MCBKl26tKZMmSJnZ2cdP35cp0+fliSdOXNGb775puLi4hQQECCr1aqBAwfqscceU48ePfItfgUAAAAAAAAAAAAAAAAA3HsUif4HZGZmSpJOnz6t119/XVlZWQoODlZycrLeeustPfPMMxo1apQkqUWLFnJwcNC0adPUv39/lSxZ0hinZ8+eGjBggM3Yrq6uslgsNlvaR0ZGytfX11h1s3Xr1ipWrJjCw8N14MABmxVHg4KCNHbsWOM4d4VTX19fvfDCC5KkZs2a6euvv9by5cv17bffGjkdOHBAn3zyiVEk6uHhoQkTJtjMu3LlynryySd15MgR1ahRwziXk5Ojd955R46OjpKk2NhYzZ8/X9nZ2bKzs9Pq1av122+/6cMPP5Sfn59xXdeuXY3rp0+frgcffFBTpkwxzpcpU0YDBgzQ4MGDVbt27XyfR//+/fXLL7/onXfe0TvvvCN3d3e1bNlSTzzxhBo3bixJqlq1qjw8PHTy5EmbeytJnTp1splHkyZNdObMGa1cuVJdu3aVs7OzatWqJUmqXbu2vL29882jIHFxcYqJidGLL76ooKAgSVeeQa6YmBi1adNGHTp0UFhYmNq2bathw4Zp2bJlysrKokgUAAAAAAAAAAAAAAAAAP4hKBIt5FJSUlSvXj3j2M3NTeHh4WrVqpW2bt2qlJQUdezY0SgklaTmzZsrNTVVBw8eVNOmTY32Nm3a3DDepUuX9Pvvv+v555+3aX/wwQcVHh6uH3/80aZItKAxW7RoYXxvb2+vKlWqyGKx2BStVq9eXYmJibp06ZJKlCghSVq9erWWLFmiY8eO2Wz7fvToUZsi0SZNmhgFopLk6empjIwMXbhwQWXKlNH27dvl6elpUyB6tSNHjig2NlYvvPCCzb1r2rSp7OzstH///gKLRJ2dnbVo0SLt3btXmzdv1o8//qj169dr3bp1mjRpkh577LF8r8uVkJCgiIgIbdy4UWfOnFFWVpYkyd3d/brX3aySJUuqUqVKeuONN5SQkKCAgACVL1/eON+oUaM815QoUUIDBw68I/EBAAAAAAAAAAAAAACAfxM7i8XsFIACUSRayBUtWlTLly83CiwrVKhgbOt+8eJFSf9bHfNap06dsjkuXbr0DeMlJSUpJydHpUqVsml3cXGRo6OjEhISbNqv7Xd1/6s5ODioePHiedokKS0tTSVKlNCGDRv0/PPP6/HHH9fIkSPl7u6uc+fOaciQIUpLS7O51tXV1eY4t2A0t198fLzKli1b4Dxz792QIUPyPX/tvcuPj4+PfHx8JEknTpxQSEiIZs6cecMi0bCwMO3Zs0dDhgxRrVq15OzsrA8++EBfffXVDWPeDIvFooULF2r27NmaOHGiUWg8fvx4NWnSxKbvtGnT7khMAAAAAAAAAAAAAAAAAMCdR5FoIWdnZ1fgduNubm6SrmwPf/VKkbkqV658y/FcXFxksVgUFxdn056UlKT09HQjZi7LHayij46OVt26dTVx4kSjbdeuXbc1lru7uw4cOHDd85IUHh5uFHpe7XoFpvmpUqWKOnbsqMWLF+v8+fMFFuSmpaVp8+bNCgsLU0hIiNH+/vvv31QcJycnSVJGRoZNe2Jios1xjRo19NZbbykjI0N79uzRG2+8oYEDB+q7774zVm0FAAAAAAAAAAAAAAAAAPyz2ZmdAMzj5+enYsWK6fTp0/L29s7zdfXW7jerRIkSqlu3rqKjo23ac1e5zG+r8jslNTXVWF0015o1a25rrObNm+vQoUP65Zdf8j1fs2ZNlS9fXidOnMj33pUrV67Asc+fP59v+9GjR+Xo6Giscurg4JBnBdT09HRlZ2fbzDM5OVnffvutTb+rV1m9Wm5ehw8fNtoOHTpU4MqnDg4Oatq0qQYMGKDk5GSdPXu2wHkBAAAAAAAAAAAAAAAAAP5ZWEn0P8zV1VXDhw/XjBkzdPr0aTVt2lT29vY6ceKENm7cqIiICBUrVuyWxx06dKiGDBmiMWPG6OGHH9aRI0c0e/ZsBQcHy2q13oWZXNG8eXNNnDhRc+fOlZ+fn7Zs2aLt27ff1lhdunTR+++/rwEDBmjo0KGqXbu2zpw5o927d2vSpEmyWCwKCwvTmDFjlJKSojZt2qhYsWI6efKktmzZopEjR6pGjRr5jv3SSy8pKytLHTp0UPXq1ZWcnKz169dr06ZN6tOnjxwdHSVJnp6e+vTTT7V27VpVq1ZNJUuWVOXKleXt7a2oqCh5eHioSJEiWrBggZydnW1Wb61evbrs7e316aefqkiRIrK3t5e3t7caNGigChUq6LXXXtPo0aOVnJysBQsWGCujStIff/yh119/XQ8++KCqVKmi5ORkzZ8/X5UqVVLVqlVv634CAAAAAAAAAAAAAAAAAO49ikT/4/r166dy5cpp8eLFWr58uYoUKaKqVauqTZs2eVblvFnt2rXTm2++qblz52rw4MFyd3dXjx49NHr06Ducva2ePXsqJiZGy5cv18KFC9WyZUvNmjVLPXr0uOWxHB0dtWTJEs2ePVvz589XfHy8ypcvr06dOhl9HnjgAbm6umrevHnGiqWVKlVSq1atCtwuXpKeeuoprV69WvPnz9e5c+dUtGhRVa1aVVOmTFHXrl2Nft27d9fevXs1adIkxcfHq2vXrpo2bZpmzZql8PBwhYWFyd3dXSEhIUpJSdGiRYuMaz08PBQeHq53331XX3zxhTIzM3XgwAE5ODgoMjJSr776qkaMGKGqVavqhRde0LRp04xry5Qpo9KlS2v+/Pk6c+aMXFxc1LhxY82YMUP29va3fC8BAAAAAAAAAAAAAAAAAOaw5OTk5JidBID/ri9+O21abGvp4qbFtrdYTIl7PiXDlLiS1NA925S4dklnTIkrSakeNU2JW8Sc10uSlJplzp8VxSxZpsSVJOWY825L0mXd3j/o+LvMvN8XM+1MiVvSkmZKXEmyZKWbEjc2q4QpcSXJrP+Bsis20aTIkpO9Oe92jZK3vnPAnVLe2ZzPMEnKMumj28GcxyxJKutm3s80AAAAAAAAAACF3Wf7T5mdAiR1rV/B7BT+kVhJFAAAAAAAAAAAAAAAAACA22RvZ+JqTsANmLiOCQAAAAAAAAAAAAAAAAAAAO4WikQBAAAAAAAAAAAAAAAAAAAKIYpEAQAAAAAAAAAAAAAAAAAACiGKRAEAAAAAAAAAAAAAAAAAAAohikQBAAAAAAAAAAAAAAAAAAAKIYpEAQAAAAAAAAAAAAAAAAAACiGKRAEAAAAAAAAAAAAAAAAAAAqhImYnAAAAAAAAAAAAAAAAAADAv5WdxWJ2CkCBKBIFYKomFV1Mi52elWNa7FPJ6abE3XMq0ZS4klSuRClT4lZ0q2RKXElKycg2JW7J1LOmxJWkIi7lTYmbbedgSlxJsk9LNi12qkl/yrnEHzYlriR5uJv0M23erwxlO5nzu9Ijx7xNB85eyjQlbp3SJUyJK0nOjvamxK1cwrznfD7VvB8spyLmzNvVLsOUuJI0ft1vpsSd2snLlLgAAAAAAAAAAAC4gu3mAQAAAAAAAAAAAAAAAAAACiGKRAEAAAAAAAAAAAAAAAAAAAohikQBAAAAAAAAAAAAAAAAAAAKIYpEAQAAAAAAAAAAAAAAAAAACiGKRAEAAAAAAAAAAAAAAAAAAAohikQBAAAAAAAAAAAAAAAAAAAKoSJmJwAAAAAAAAAAAAAAAAAAwL+VvcXsDICCsZIoAAAAAAAAAAAAAAAAAABAIUSR6F0UEREhq9Wa79eCBQvMTu+6wsLC1Llz53/cWLdryZIl2rJlS572oKAgTZw48Z7m0qVLF4WFhd3TmHfDqlWrFBERYXYaAAAAAAAAAAAAAAAAAIACsN38XVa0aFEtXbo0T3uFChVMyOa/67333lObNm0UGBhodir/agkJCfrkk0/Uu3dvoy0nJ0cff/yx/P39Va1aNROzAwAAAAAAAAAAAAAAAABcjSLRu8zOzk6+vr5mp4H/sNTUVBUtWvSOjOXo6KjU1FQ99dRTqlOnjhITE9W7d295eXmpQ4cOdyQGAAAAAAAAAAAAAAAAAODOYLv5fwCr1aqoqChFRESoefPm8vf31/jx45WSkmLT78yZMxo3bpyaN28uHx8fdezYMc8qpatWrdJDDz0kb29vtWrVSrNnz1ZWVpbNeavVqp9//lm9e/dWgwYNFBQUpE8++STf3Hbu3KlHHnlEvr6+6t69u/bv329zftGiRXr00UfVqFEjBQQEKDQ0VEeOHLnhnA8cOKD+/fvL19dXjRo10vDhw3Xy5Mk892XBggWaPn26mjVrJj8/P4WFhSk5Odnok5KSookTJyo4ONiYS3h4uJKSkow+QUFBio2N1YoVK2S1WmW1WrVq1SqbWCtWrFDbtm3VqFEjDR48WHFxcZKkjIwMtWjRQrNnz84zh+eee07du3e/7jx/+ukndevWTd7e3urcuXO+W95L0p49e9S7d2/jfowePVoXLlyw6XP69GmFhoaqQYMGCgwM1JIlSzRlyhQFBQUZfXKf7549e/T000/L19dX06dPN64fM2aM/P395ePjo6eeeirP88wdo6B3qFixYhoyZIimTJmi6Ohobdy4UUOHDtX48ePl7u5+3XsBAAAAAAAAAAAAAAAAALi3WEn0HsjMzMzTVqSI7a1fsWKFGjVqpGnTpuno0aOaPn26SpUqpTFjxkiSLl68qMcff1ySNHLkSFWuXFnHjh3T8ePHjTEWL16sGTNmqE+fPgoLC9OhQ4eMAr/ccXKNGjVKjz/+uJ599ll9+eWXevHFF1W2bFm1bt3a6HPu3DlNnjxZAwYMkIuLi2bNmqWhQ4dqw4YNcnBwkHSl8LBXr16qWLGikpOT9eGHH6pnz55av359gUWDp06dUq9evVSlShXNmDFDaWlpmj17tnr16qUvvvhCzs7ORt9ly5apXr16ev311xUTE6OZM2ca/aUrq2RmZWVp5MiR8vDw0KlTpzRv3jwNHjxYy5YtkyRFRkZqwIABatiwofr16ydJqlq1qhHj22+/1bFjxxQeHq6LFy9q6tSpmjRpkmbPni0HBwd17dpVq1ev1ogRI2Rnd6WuOj4+Xhs3btSLL75Y0GPXuXPn1L9/f1mtVs2ZM0eJiYmaMGGCUlJSVLduXaPfnj17FBISosDAQM2ePVuXL1/WnDlzNHjwYK1cuVLSlS3dBw8erPPnz2vChAlycXHRwoULdfLkSSOnq40ePVqPP/64QkNDVaxYMSUkJOjJJ59U8eLF9fLLL8vFxUXLli1Tnz599PXXX6tUqVI39Q6lpqZq6dKl+vbbbxUcHKykpCRFRkZq8+bNGjRokFxdXQu8HwAAAAAAAAAAAAAAAACAe4si0bssJSVF9erVy9O+YsUKNW7c2DguU6aMZs2aJUlq3bq1fvvtN61fv94o7lyyZIkuXLigr776SpUrV5YkBQQEGNcnJyfrrbfe0jPPPKNRo0ZJklq0aCEHBwdNmzZN/fv3V8mSJY3+Xbp0UWhoqCSpVatWOnHihObOnWtTJJqQkKDly5erdu3akq6sItm7d2/98ssvRu4vvPCC0T8rK0stWrRQQECA1q9fbxS1XmvJkiXKzMzUokWLjELSunXrqlOnTvrss88UEhJi9HV0dNTcuXNlb28vSXJyctJLL72koUOHytPTUx4eHpowYYLRPzMzU5UrV9aTTz6pI0eOqEaNGvLy8pKjo6NKly4tX1/fPPnk5OTonXfekaOjoyQpNjZW8+fPV3Z2tuzs7PTYY4/p3Xff1datWxUYGChJWrNmjezs7NS5c+d85yhJS5culcViUVRUlFxcXCRJ5cuXV9++fW36zZo1S/Xr11dkZKQsFosk6b777jNWHg0MDNR3332nX3/91ea9adasmQIDA/MtzOzZs6cGDBhgHL/11ltKTEzUxx9/bBSEBgQEKDg4WAsXLtS4ceNu6h2yWCwqUqSIli9frjVr1ig2NlazZ8/WRx99pLi4OIpEAQAAAAAAAAAAAAAA8J9j9/9rfoB/Irabv8uKFi2qTz75JM/X1StJSlLz5s1tjj09PXX69GnjePv27WrWrJlRIHqtPXv2KCUlRR07dlRmZqbx1bx5c6WmpurgwYM2/du3b29z3KFDB/366682W9OXLVvWKBCVpFq1akm6su19rp9//llPP/20/P395eXlpQYNGiglJUVHjx4t8J7s3r1b/v7+NiuNenp6qk6dOvrxxx9t+rZt29YoEJWkjh07KicnR/v27TPaVq9erUceeUR+fn6qV6+ennzySUm6bg5Xa9KkiVEgmptLRkaGsd17tWrV1LRpU3366adGn1WrVik4ONhm1dNr/fLLL/L39zcKRKUrhZlXz/vy5cv66aef1LFjR2VlZRnPrXr16qpQoYIxz3379snV1dWmsLhEiRI2hcJXa9Omjc3xtm3b5O/vLzc3NyOGnZ2dmjRpYsS4mXfI3d1d/fv3N1aSlSSLxaLHH39c1atXL/BeAAAAAAAAAAAAAAAAAADuPVYSvcvs7Ozk7e19w37XrsDo4OCg9PR04zg+Pt6mYPNaFy9elCR17do13/OnTp2yOc5dTTJX6dKllZGRoYsXL6p06dIF5iRJaWlpkqSTJ0+qX79+ql+/viZMmKCyZcvKwcFBoaGhRp/8JCYm5imSzc0pISHhunk6OzvLyclJZ8+elSRt2LBBzz//vB5//HGNHDlS7u7uOnfunIYMGXLdHK527TxzC0avvr5Hjx4KCwtTXFyczp49q99++01hYWHXHffcuXOqVq1annYPDw/j+8TERGVlZWnq1KmaOnVqnr65z+3s2bM21+U31tVyn2Guixcv6ueff853VduqVasafaSbf4e6deuWbz8AAAAAAAAAAAAAAAAAwD8DRaL/Eu7u7kZhZH7c3NwkSZGRkSpfvnye89euQHrhwgWVK1fOOD5//rwcHBxstqS/ka1btyolJUWRkZFGoWVmZmaeQs/8cs1dpfPanK5djfLafsnJyUpLS1PZsmUlSdHR0apbt64mTpxo9Nm1a9dNz+FmdejQQZMmTdIXX3yhmJgYVa1aVU2bNr3uNWXKlMl3nnFxccb3Li4uslgsCg0N1f3335+nb+7zKFu2rM11+Y11PW5ubmrVqpVGjBiR51xuUeytvkMAAAAAAAAAAAAAAAAAgH82ikT/JQICArRo0SKdPHlSFStWzHPez89PxYoV0+nTp/NsJZ+fDRs2yMvLyzj++uuvVa9ePZut3W8kNTVVFotFRYr87zX66quvlJmZed3rGjVqpI8++kgJCQlGYeLhw4d14MABPfroozZ9N23apPHjxxt5RUdHy2KxGKuzpqam2mx9Lklr1qzJE9PBweGmVxbNj6Ojo7p06aKPP/5Y58+fV9++fWWxWK57jY+Pjz744AMlJSUZW85v375d8fHxRp/ixYvL19dXhw8fvu6Ks97e3kpMTNQPP/ygJk2aSJIuXbqk7du351kJNT/NmzfXF198IU9PTxUvXjzfPrf6DgEAAAAAAAAAAAAAAAAA/tkoEr3LsrOz9fPPP+dpL1WqlKpUqXLT4/Tt21eff/65evXqpUGDBqlKlSo6ceKEjh49qrFjx8rV1VXDhw/XjBkzdPr0aTVt2lT29vY6ceKENm7cqIiICBUrVswY7/PPP1fRokXl5eWlL7/8Uj/88IMWLFhwS3Nr1qyZJGn8+PHq2bOnDh48qMWLF9+waLFv375atWqV+vXrp0GDBiktLU1z5sxRhQoV8mx1np6eriFDhuiJJ55QTEyMZs6cqeDgYHl6ekq6Uvw4ceJEzZ07V35+ftqyZYu2b9+eJ2bNmjW1Y8cObdu2Ta6urqpcufItrZoqXdlyfunSpbK3t7+prdb79Omj999/X88++6yeffZZJSYmKiIiQu7u7jb9xo0bpz59+ui5555Tp06d5OrqqtOnT+v7779Xt27d5O/vr9atW6tevXoaPXq0Ro0aJVdXV7377rsqUaLEDYtVpSv3fM2aNerVq5d69+6tihUrKi4uTr/88ovKlSunvn373vI7BAAAAAAAAAAAAAAAAAD4Z6NI9C5LTU3V448/nqe9e/fumjJlyk2PU7JkSX3wwQeaNWuWZs6cqcuXL6tSpUp68sknjT79+vVTuXLltHjxYi1fvlxFihRR1apV1aZNmzyrbc6aNUtvvPGG5s6dq1KlSmnSpEkKDAy8pblZrVZNnTpVkZGRCg0NVd26dfXmm2/queeeu+51FSpU0LJlyzR9+nSNGTNGdnZ2atGihcLCwuTs7GzTNyQkRHFxcRo3bpzS09PVvn17hYeHG+d79uypmJgYLV++XAsXLlTLli01a9Ys9ejRw2acUaNG6dVXX9WwYcN06dIlTZ069aYKPa9Wq1YtVa9eXVWrVlW5cuVu2L9s2bKKiorS5MmTNWLECFWtWlXh4eGaPXu2Tb+GDRvq/fffV0REhMaPH6+MjAyVL19ezZo1U7Vq1SRJFotFb7/9tsLDwxUeHi5XV1f17t1bR44c0e+//37DXEqWLKmVK1dqzpw5mjlzpuLj41WqVCk1aNDAZtXQW3mHAAAAAAAAAAAAAAAAAAD/bJacnJwcs5PAvbNq1SqNHz9e27dvl4eHh9npXJfVatW4cePUv39/s1ORJB0/flwdOnTQm2++qeDgYLPTUXp6ujp16qTGjRtr6tSpZqdz207FXzItdnqWeR9/p5LTTYm751SiKXElqWOtUqbEreiUZUpcSUrINqe4umTqWVPiSlKaS3lT4trb3XhV5bsWOy3ZtNhxMmeF5zLxf5kSV5Ky3CuZFtss2Q7mPOe0HDtT4krS2UuZpsS9lGHe7wxnR3tT4lYuYd5zPp9q3t9iTkXMmberXYYpcSXp1S2xpsSd2snLlLgAAAAAAAAAANxL6w+Y99/p8T/B1rJmp/CPxEqiwA1cvHhRR44c0dy5c1WxYkW1a9fOlDxWrlyp7Oxs1ahRQ4mJifrggw8UGxurN954w5R8AAAAAAAAAAAAAAAAAJi7sBFwIxSJAjewadMmvfDCC6pWrZpmzJihIkXM+bFxcnLSggULFBt7ZQWgOnXqaP78+fL29jYlHwAAAAAAAAAAAAAAAADAPxvbzQMwFdvN31tsN39vsd38vcN28/cW283fW2w3f++w3fy9xXbz9xbbzQMAAAAAAAAAcPd8c/Cc2SlA0v21y5idwj+Sef9FEAAAAAAAAAAAAAAAAAAAAHcNRaIAAAAAAAAAAAAAAAAAAACFEEWiAAAAAAAAAAAAAAAAAAAAhRBFogAAAAAAAAAAAAAAAAAAAIUQRaIAAAAAAAAAAAAAAAAAAACFUBGzEwAAAAAAAAAAAAAAAAAA4N/KzmJ2BkDBKBIFYKqYxHTTYjsVMW8x5doeRU2J61nSnLiS5GqXYUrcLHvz5nwu3pz32724iylxJSk+NcuUuOXSz5gSV5IuFitvWuwSDuZ8jsV71DYlriRl55gT16zPMEmyTzprSty9l1xNiStJ2TnmPOjfziWbEleSmlZyNyVuJRcHU+JKkqO9Ob8zJCn6rzhT4vawupkSV5Kqly5hStyP9p40Ja4k9fCpaFpsAAAAAAAAAACAfwq2mwcAAAAAAAAAAAAAAAAAACiEKBIFAAAAAAAAAAAAAAAAAAAohCgSBQAAAAAAAAAAAAAAAAAAKIQoEgUAAAAAAAAAAAAAAAAAACiEKBIFAAAAAAAAAAAAAAAAAAAohIqYnQAAAAAAAAAAAAAAAAAAAP9W9haL2SkABWIlUQAAAAAAAAAAAAAAAAAAgEKIIlGY5uGHH5bVatXu3bvvyvghISEKDQ01jnfu3Kl58+bdlVi3YsqUKQoKCjI7jb8tJiZGISEhZqcBAAAAAAAAAAAAAAAAACgARaIwxcGDB3XgwAFJ0po1a+5KjFdeeUXPP/+8cbxr1y7Nnz//rsT6L4mKilJcXJxN2w8//KBNmzaZlBEAAAAAAAAAAAAAAAAA/D2HDh3S008/LV9fX7Vo0ULTp09Xenr6da85e/aspk+fri5dusjPz0+tW7fW6NGjFRsba9Nv586dslqteb5Gjhx5N6ckSSpy1yMA+VizZo3s7OzUpEkTRUdH66WXXpKDg8MdjVGrVq07Ot6/VWpqqooWLXrHxitXrpyeeeYZBQYGKikpSc8//7ySkpI0evToOxYDAAAAAAAAAAAAAAAAAO6VhIQE9enTR9WrV1dERITOnDmjadOmKTU1VeHh4QVe9+uvv2rDhg169NFH1aBBA128eFHvvPOOHnvsMa1du1YeHh42/adOnaqaNWsaxyVLlrxrc8rFSqK453JycrR27Vo1a9ZMTz/9tOLj47V161abPhkZGXr99dfVpk0b1a9fXy1bttTAgQOVlJRk9ElMTNSkSZPUunVr1a9fX0FBQZo1a5Zx/urt5iMiIhQZGamUlBSjCvvqrdIPHTqkQYMGqVGjRvL19dWAAQN0/Phxm5w++eQTderUST4+PvL399cTTzyhvXv3XneuZ86c0cCBA9WgQQO1atVKUVFR+fY7ffq0xowZI39/f/n4+Oipp57S/v37bfqkp6dr8uTJatq0qRo3bqzw8HCtWbNGVqtVMTExkq5sAW+1WrVq1Sq99NJL8vf312OPPWZc/8Ybb6ht27aqX7++HnjggXxXcd2zZ4969+4tX19fNWrUSKNHj9aFCxeM8w8//LDee+89bdmyRb///rs8PT319ttvy9PT87r3AgAAAAAAAAAAAAAAAAD+iT788ENdunRJkZGRatWqlbp3766xY8fqww8/1JkzZwq8rlGjRvrqq680cOBABQQE6MEHHzR2al69enWe/rVr15avr6/xVa1atbs4qytYSRT33E8//aTY2FgNGTJELVu2lLu7u9auXaugoCCjz/z58/Xhhx9qzJgxql27ti5evKht27YZy/emp6erT58+xjj33XefTp8+rR9//DHfmI899phOnz6ttWvXaunSpZIkZ2dnSdKJEyfUs2dP1a5dW9OmTZPFYtG8efPUt29fRUdHy9HRUT/88INefPFF9evXT4GBgUpNTdXevXttilbzM3jwYJ05c0avvvqqXFxcFBUVpVOnTqlIkf/96CUkJOjJJ59U8eLF9fLLL8vFxUXLli1Tnz599PXXX6tUqVKSpFmzZunDDz/U8OHDVbduXa1fv96mKPZqb7zxhgIDAzVr1ixlZ2dLkkaMGKGffvpJQ4YMkaenp7Zs2aKxY8fK1dVVgYGBkq4UiIaEhCgwMFCzZ8/W5cuXNWfOHA0ePFgrV66UJH355ZdauHChAgMDlZWVpb/++kvDhg3TqFGjVKNGjes/fAAAAAAAAAAAAAAAAAD4h/nuu+8UEBAgd3d3o+2BBx7QK6+8om3btqlbt275Xufq6pqnrXz58vLw8NDZs2fvVrq3hCJR3HNr166Vk5OTOnToIAcHBwUHB+uLL77QpUuXVKJECUnSvn371LJlSz311FPGdcHBwcb3q1ev1m+//aYPP/xQfn5+RnvXrl3zjVm+fHmVL19ednZ28vX1tTkXGRkpNzc3LV68WE5OTpKkhg0bql27dvr444/11FNPae/evXJ3d9fzzz9vXNemTZvrzvO7777T/v37tWTJEgUEBEiS/P39FRgYaPNhsnTpUiUmJurjjz82CkIDAgIUHByshQsXaty4cYqPj9cHH3ygQYMGacCAAZKkVq1aqW/fvjp16lSe2HXq1NGUKVOM4x07dujbb7/VwoUL1bJlS0lSixYtdO7cOUVERBhForNmzVL9+vUVGRkpi8UiSbrvvvvUuXNnbdmyRYGBgYqJiVFUVJRSUlK0e/duTZ8+Xbt27dKRI0coEgUAAAAAAAAAAAAAAABginbt2l33/MaNGws8d/jwYT366KM2ba6uripTpowOHz58S3kcOXJEFy5cyHdn5gEDBig+Pl5lypRRp06dNGLECBUtWvSWxr9VbDePeyozM1PR0dEKDAyUi4uLJOmhhx7S5cuXtWHDBqOfl5eXtmzZooiICO3du9dYDTPX9u3b5enpaVMgeru2bdumoKAg2dvbKzMzU5mZmXJ1dZWXl5ex5buXl5fi4+MVFhambdu26fLlyzccd+/evXJxcTEKRCXJxcVFzZs3zxPf399fbm5uRnw7Ozs1adJE+/btkyT9+eefSktLy/NBVtAH27UFrNu2bZO7u7uaNWtmxMjMzFTz5s31+++/KysrS5cvX9ZPP/2kjh07Kisry+hTvXp1VahQwchlwIAB8vDwsBm/adOmNivBAgAAAAAAAAAAAAAAAP8VdhYLX/+Ar78jMTEx31VB3dzclJCQcNPj5OTkaPLkySpbtqw6depktLu4uOiZZ57R1KlTtWjRInXt2lXLly/XiBEj/lbeN4OVRHFPbdu2TXFxcWrbtq0SExMlXVmpskyZMlq7dq0eeeQRSdKgQYNkZ2enzz77TJGRkfLw8NBTTz2lIUOGyGKxKD4+XmXLlr0jOV28eFFLly41tqG/moODg6QrK3tOnz5d7733nvr37y8nJycFBwfrhRdesFkV9Gpnz57NU0wpyVgt9Or4P//8s+rVq5enb9WqVSVJ586dkySVLFnyumNdL0Z8fHy+MXLHt1gsysrK0tSpUzV16tQ8fa5dsbRy5cpatmxZvuMBAAAAAAAAAAAAAAAAwL10vZVC75WIiAjt2LFD7777rooXL260e3l5ycvLyzgOCAhQ2bJlNXHiRO3du1c+Pj53LSeKRHFPrVmzRpI0fvx4jR8/3ubcxYsXdeHCBZUqVUqOjo4aNmyYhg0bpmPHjunTTz9VRESEKleurEceeUTu7u46cODAHcnJzc1NgYGBevLJJ/OcK1GihPF9ly5d1KVLF8XFxWnjxo2aOnWqihQpotdeey3fccuWLau4uLg87RcuXMgTv1WrVvlWhTs6OkqSypQpI+nKPSpXrlyBY+WyXFMZ7+bmJg8PDy1YsCDf/h4eHsrMzJTFYlFoaKjuv//+PH2uLVAFAAAAAAAAAAAAAAAAgMLA1dVVSUlJedoTEhLk5uZ2U2N89NFHmjt3rqZMmWKz+3RBHnjgAU2cOFH79++nSBSFw+XLl7Vx40bdf//96t27t8258+fPa9SoUfryyy8VEhJic65atWoaNWqUVq5cqcOHD0uSmjdvri+//FK//PKLGjRocFPxHRwclJ6enqc9ICBABw8elJeXl+zt7W84joeHhx577DF99913Rj758fb2VlJSkrZv32780CclJen777+3WX20efPm+uKLL+Tp6WlTPX612rVry8nJSd98843q1KljtH/zzTc3zDc3xrvvvisHBweb66/m6OgoX19fHT58WN7e3jc1LgAAAAAAAAAAAAAAAAD829WsWTNPLVhSUpLOnTunmjVr3vD6DRs26NVXX9Xw4cPVvXv3u5XmbaFIFPfMxo0blZKSopCQEPn7++c5/+6772rt2rUKCQnR4MGDVa9ePXl5ealYsWLatGmTEhIS1KxZM0lXVvV8//33NWDAAA0dOlS1a9fWmTNntHv3bk2aNCnf+J6ensrMzNTSpUvl5+cnZ2dn1axZ0/jB7N+/v3r06KHSpUvr/Pnz2rVrlxo3bqzOnTvrrbfeUnx8vJo2bapSpUrpzz//1NatW9W3b98C59u6dWvVq1dPY8eO1ZgxY+Ti4qIFCxbI2dnZpl/fvn21Zs0a9erVS71791bFihUVFxenX375ReXKlVPfvn1VsmRJPfHEE5o3b56cnJxUt25dRUdH6+jRo5IkOzu76977Fi1aqG3btnrmmWf0zDPPyGq16vLly/rrr7907NgxTZkyRZI0btw49enTR88995w6deokV1dXnT59Wt9//726deuW73MDAAAAAAAAAAAAAAAAgH+z1q1ba968eUpMTJSrq6skKTo6WnZ2dmrRosV1r925c6dGjRqlxx57TEOGDLnpmOvWrZOku76gH0WiuGfWrl2rihUrFlho+Mgjj+i1117T8ePH1bBhQ3311VdavHixsrKyVKNGDc2cOVPNmzeXdGXVyyVLlmj27NmaP3++4uPjVb58eXXq1KnA+G3bttWTTz6pBQsW6MKFC2rSpImWLVumatWq6eOPP9acOXM0YcIEpaSkqEyZMmrSpImsVqukKz+IS5cu1VdffaXk5GSVL19e/fv316BBgwqMZ7FY9Pbbb+uVV15ReHi4XF1dFRISovPnz2vjxo1Gv5IlS2rlypWaM2eOZs6cqfj4eJUqVUoNGjRQ+/btjX6jR49WZmamFixYoOzsbLVv314DBgzQxIkT5eLicsP7/9Zbb2nBggX64IMPFBsbKxcXF9WuXVvdunUz+jRs2FDvv/++IiIiNH78eGVkZKh8+fJq1qyZqlWrdsMYAAAAAAAAAAAAAAAAAPBv07NnTy1btkxDhgxRaGiozpw5o+nTp6tnz54qV66c0a9Pnz46efKkNmzYIEk6dOiQhgwZourVq6tLly76+eefjb4eHh6qWrWqJGnMmDGqVq2avLy85OTkpB07dmjJkiW6//7773qRqCUnJyfnrkYAcNeMHTtWP/74o7799luzU7ltPxy/aFpspyLXX4H1bqrk4mBK3GwTP/Fd7TJMiZtl72RKXEk6Ep9uStzaxc2JK0lns4qaErdc+hlT4krSxWLlTYtdzMGcz7H0LPM+TMz6HDPrM0yS7C7FmRJ3xyVXU+JKUrZJ/xPlt3PJpsSVpKaV3E2J61XGnM9tSUpKyzIt9vpD5vwN2sPqZkpcSVqy35zPkpLFzPm7V5J6+FQ0LTYAAAAAAAAA4L9l6+ELZqcASa1qlvpb1x86dEiTJk3Snj17VKJECXXp0kUjR46Uo6Oj0SckJESxsbFGvdaqVas0fvz4fMfr2rWrpk2bJkmaP3++1qxZo9jYWGVkZKhSpUp66KGHNGDAAJvx7wZWEgX+JXbt2qWffvpJ9erVU3Z2tjZv3qw1a9YoLCzM7NQAAAAAAAAAAAAAAAAA4F/N09NTS5YsuW6fZcuW2Rx369bNZifngoSGhio0NPTvpHfbKBIF/iWKFy+uzZs3KyoqSmlpaapUqZLCwsLUt29fs1MDAAAAAAAAAAAAAAAA/rPszdvMFrghikSBf4n69evrww8/NDsNAAAAAAAAAAAAAAAAAMC/BDXMAAAAAAAAAAAAAAAAAAAAhRBFogAAAAAAAAAAAAAAAAAAAIUQRaIAAAAAAAAAAAAAAAAAAACFEEWiAAAAAAAAAAAAAAAAAAAAhRBFogAAAAAAAAAAAAAAAAAAAIVQEbMTAAAAAAAAAAAAAAAAAADg38rOYjE7BaBAFIkCMFXd0kVNi304Pt202M6WDFPi/plsSlhJknuRBFPiWuzN+1Xn4uRqStzj6U6mxL0ix5SoZxzLmRJXksrYZ5oWO0OOpsQ183/elEw8Ykrc9FKepsSVJPtsc96xjOxsU+JKkoujOZ/dlVzN+7vEwd6cnyy7jFRT4kqSo705n2GSVN29mClxs+0dTIkrSQ0rmPN3iYuTvSlxJenA2URT4lrLmnOvAQAAAAAAAAAA8sN28wAAAAAAAAAAAAAAAAAAAIUQRaIAAAAAAAAAAAAAAAAAAACFEEWiAAAAAAAAAAAAAAAAAAAAhRBFogAAAAAAAAAAAAAAAAAAAIUQRaIAAAAAAAAAAAAAAAAAAACFEEWiAAAAAAAAAAAAAAAAAAAAhVARsxMAAAAAAAAAAAAAAAAAAODfyt5iMTsFoECsJAoAAAAAAAAAAAAAAAAAAFAI/eOKRCMiIuTn53fL1+3cuVPz5s27CxndOUuWLNGWLVvytAcFBWnixIkmZHTFzp07ZbVatW/fvuv2s1qtslqt2r59u017YmKirFarVq1adTfTvKOsVqsWLlxoHIeEhCg0NPSexF6yZImsVut1++Q+k9wvX19fPfTQQ1q6dKmysrJuOeaqVau0Zs2aPO1/Z94xMTEKCQm5rWsBAAAAAAAAAAAAAAAAAHdfodlufteuXVq0aJEGDhxodioFeu+999SmTRsFBgbatEdGRsrV1dWkrG7d22+/rYCAALPTuKNeeeUV2dn942qmNXXqVNWsWVNJSUlavXq1XnvtNaWlpWnAgAG3NM5nn32m4sWL66GHHrJpv515R0VF6dFHH7Vp++GHH5ScnKy2bdve0lgAAAAAAAAAAAAAAAAAgLun0BSJ3mmpqakqWrToPYnl5eV1T+LcCf7+/tq5c6d2796txo0b3/Hx7+V9v1qtWrXuecybUbt2bXl7e0uSWrRood9++02ffvrpLReJFuR25l2uXDk988wzCgwMVFJSkp5//nklJSVp9OjRdyQnAAAAAAAAAAAAAAAAAMCd8c9bOvEaMTExslqt+vzzzzVx4kQ1adJELVu21Ouvv67MzExJV7aoj4yMVEpKirE999XbYB86dEiDBg1So0aN5OvrqwEDBuj48eM2caxWqxYsWKAZM2aoRYsWxkqZuVvBr1ixQm3btlWjRo00ePBgxcXFGdempKRo4sSJCg4OVoMGDRQUFKTw8HAlJSUZfYKCghQbG6sVK1YYOeZuz57fdvNff/21unTpIm9vb7Vs2VJTp05VWlqacT53O/Jt27Zp9OjR8vPzU9u2bRUVFWUzzp49ezRw4EC1bNlSvr6+6tKli1avXn3bzyMwMFD16tXT3Llzb9j3ww8/VHBwsOrXr6+goCC9/fbbys7ONs6vWrVKVqtVe/bs0dNPPy1fX19Nnz7dmNvWrVs1YsQI+fn5qU2bNsZ26bkrsjZt2lQvvvii0tPTjTHPnj2r8ePHq127dvLx8VGHDh30xhtv2PTJz7Xbrp8+fVojRoxQ8+bN5e3traCgIL322ms219zMe5WcnKxx48bJz89PzZo10/Tp029ru3hJsrOzk9Vq1alTp2zaZ86cqYceekh+fn5q1aqVRo0apbNnz9rMbdeuXdq8ebPx7kVEROQ7b+nKqqA9e/aUj4+P/P39NX78eMXHxxvnH374Yb333nvasmWLfv/9d3l6eurtt9+Wp6fnbc0LAAAAAAAAAAAAAAAAAHB3/GtWEp0zZ47atWunOXPmaM+ePYqIiFDVqlX1xBNP6LHHHtPp06e1du1aLV26VJLk7OwsSTpx4oR69uyp2rVra9q0abJYLJo3b5769u2r6OhoOTo6GjHee+89NWjQQFOmTDEKUCXp22+/1bFjxxQeHq6LFy9q6tSpmjRpkmbPni3pyuqXWVlZGjlypDw8PHTq1CnNmzdPgwcP1rJlyyRd2VJ+wIABatiwofr16ydJqlq1ar5z3bhxo4YPH65OnTpp9OjROnz4sGbPnq1Tp07prbfesun7yiuvqEuXLpo7d66++eYbzZw5U1arVa1bt5YknTx5Ug0bNtQTTzwhR0dH/fTTT3rppZeUk5Ojrl273tazGDx4sIYMGaKff/5Zvr6++fZZtmyZJk+erJCQELVp00Z79uxRZGSksfLk1UaPHq3HH39coaGhKlasmFJTUyVJr776qrp27aoePXroo48+0rhx4/THH3/o4MGDmjBhgk6cOKFp06apSpUqGjhwoCTp4sWLcnd31/jx4+Xq6qqjR48qIiJC586d09SpU296juPGjdPZs2f10ksvqVSpUjp16pT2799vnL/Z9+qFF17Q1q1bNWbMGFWuXFnvv/++1q5deyu328bJkydVuXJlm7YLFy4oNDRUZcuWVVxcnBYvXqyQkBCtW7dORYoU0SuvvKKxY8eqaNGixr0vX758vuPv379fTz/9tPz9/fXmm2/q/PnzmjVrlv766y99+OGHsre315dffqmFCxcqMDBQWVlZ+uuvvzRs2DCNGjVKNWrUuO25AQAAAAAAAAAAAAAAAADurH9NkaiPj49eeuklSVe23d65c6fWr1+vJ554QuXLl1f58uVlZ2eXp2gxMjJSbm5uWrx4sZycnCRJDRs2VLt27fTxxx/rqaeeMvq6ubkpMjJSFovFZoycnBy98847RuFfbGys5s+fr+zsbNnZ2cnDw0MTJkww+mdmZqpy5cp68skndeTIEdWoUUNeXl5ydHRU6dKlCyysvDpnX19fzZo1S5LUunVrFStWTOHh4Tpw4ICsVqvRt0OHDho2bJgkKSAgQJs3b9b69euNItFOnTrZzKNJkyY6c+aMVq5cedtFou3atZPVatXcuXPzrFwqSVlZWZo7d646depkPLOWLVsqIyNDixYt0oABA1SyZEmjf8+ePW22T9+5c6ckqWPHjho6dKikK89/w4YNWrdunTZs2CAHBwdJ0q5duxQdHW0UiVqtVpsi1IYNG6pYsWIKCwtTeHi4ihUrdlNz3Ldvn0aNGqUHH3zQaHvkkUeM72/mvfrrr7/09ddfa/LkyerevbtxHzp06HBTOUhSdna2MjMzlZSUpFWrVmnv3r164403bPpcXfyalZUlPz8/tW7dWjt27FDLli1Vq1YtOTs7q3jx4jd89+bNm6cyZcpo3rx5xj2uUKGC+vfvry1btigoKEgxMTGKiopSSkqKdu/erenTp2vXrl3Guw4AAAAAAAAAAAAAAAAA+Gf41xSJtmzZ0ubY09NTO3bsuOF127Zt04MPPih7e3tjdVBXV1d5eXnZrAwpXSnGvLZAVJKaNGlis+Kop6enMjIydOHCBZUpU0aStHr1ai1ZskTHjh1TSkqK0ffo0aO3VDh36dIl/f7773lW23zwwQcVHh6uH3/80aZI9Or7YrFY5OnpqdOnTxttCQkJioiI0MaNG3XmzBljq3N3d/ebzulaFotFgwYN0nPPPad9+/apWrVqNucPHz6sixcvqmPHjnnmMH/+fO3du1eBgYFGe5s2bfKN06JFC+N7FxcXeXh4qHHjxkbxoiRVr17dKCqVrhTCLl26VB999JFiYmKUlpZmnDtx4oTuu+++m5qjl5eXFi1aJHt7e7Vo0SLPHG/mvdq3b59ycnLUvn174zp7e3vdf//9WrJkyU3l0aNHD5vjAQMG2BSuStKWLVv0zjvv6ODBg0pOTjbajx49mufn5kZ2796tzp0729zjli1bytXVVT/++KOCgoKMgt6r3/OmTZveUhwAAAAAAAAAAAAAAACgsLDLp+YM+Kf41xSJuri42Bw7ODgoPT39htddvHhRS5cuNbahv3aMq5UqVSrfMVxdXW2OcwtGcwsQN2zYoOeff16PP/64Ro4cKXd3d507d05DhgyxKVK8GUlJScrJycmTi4uLixwdHZWQkJCn/do5JSUlGcdhYWHas2ePhgwZYqwo+cEHH+irr766pbyuFRwcrFq1auntt9/W66+/bnMuN8dr55B7fO0cSpcunW+Ma+fm6OiY51lc+x4sXbpUr7/+up555hn5+/vL1dVV+/bt08SJE2/pWcyePVuzZ8/WnDlzNGHCBNWoUUOjRo0yVgG9mffq3LlzcnBwkJubm835gt6z/Lz++uvy9PRUXFyc5s+fr6ioKDVp0sRYKXbv3r0aPHiw2rVrp2effValSpWSxWJRjx49bvndk6TExMR88ytVqlSe51a5cmUtW7bslmMAAAAAAAAAAAAAAAAAAO6Nf02R6O1yc3NTYGCgnnzyyTznSpQoYXOc3yqiNyM6Olp169bVxIkTjbZdu3bd1lguLi6yWCyKi4uzaU9KSlJ6enqegsPrSUtL0+bNmxUWFqaQkBCj/f3337+t3K5mZ2engQMHauzYsfrjjz9szuWuUnrtHC5cuCBJtzSHWxUdHa2goCCNHj3aaDt06NAtj1O2bFlNnTpV2dnZ2r9/v9555x2NHDlS0dHRqlKlyk29V2XKlFFGRoYSEhJs5px7H26Gp6envL29JUmNGzdWx44d9frrr6tVq1ayWCz65ptv5OzsrDlz5sjOzk6SFBsbe8vzzeXm5pZvfhcuXLirzw0AAAAAAAAAAAAAAAAAcOfZmZ3AnVLQyqIBAQE6ePCgvLy85O3tbfNVs2bNOxI7NTU1z6qka9asyTfHG63uWKJECdWtW1fR0dE27bkrfzZq1Oim80pPT1d2drZNbsnJyfr2229veozrefDBB1WtWjXNnTvXpr1GjRry8PDIdw4ODg7y8fG5I/Hzc7PP4mbZ2dnJx8dHzz33nDIzM3Xs2DFJN/de5RZ3btiwwRgvKytL33zzzW3lUqJECQ0fPlx//fWXMUbufK8ucL7dd0+68n5t3LhRmZmZRtu2bduUmJh4S+8eAAAAAAAAAAAAAAAAAMB8hWYlUU9PT2VmZmrp0qXy8/OTs7OzatasqeHDh6t79+7q37+/evToodKlS+v8+fPatWuXGjdurM6dO//t2M2bN9fEiRM1d+5c+fn5acuWLdq+fXuefjVr1tSOHTu0bds2ubq6qnLlyipZsmSefkOHDtWQIUM0ZswYPfzwwzpy5Ihmz56t4OBgWa3Wm87LxcVF3t7eioqKkoeHh4oUKaIFCxbI2dk5zyqft8Pe3l6hoaEaP358nvbBgwdr8uTJ8vDwUGBgoH7++WdFRUWpT58++c75TmnevLnee+89LV++XNWrV9cXX3xhFHberKSkJPXv319dunRRjRo1lJGRoWXLlsnV1VVeXl6SdFPvVa1atdS+fXu99tprSktLU+XKlfX+++8rIyPjtuf3yCOPaN68eYqKilL79u3VokULLV26VJMmTVL79u21Z88eff7553muq1mzplavXq1vv/1WZcqUUdmyZVWuXLk8/QYOHKiePXsqNDRUISEhOn/+vGbNmiUfHx8FBgbedt4AAAAAAAAAAAAAAAAAgHuv0Kwk2rZtWz355JNasGCBevTooVdeeUWSVK1aNX388cdyd3fXhAkT1L9/f82cOVOXL1++pYLL6+nZs6f69eun5cuXa+jQoTp16pRmzZqVp9+oUaNUvnx5DRs2TN27d9emTZvyHa9du3Z688039eeff2rw4MGKiopSjx49NGPGjFvObdasWapatarCwsI0efJkBQcH65FHHrnlcQry8MMPq3LlynnaQ0JC9Oqrr+q7777TwIED9emnn2ro0KEaO3bsHYudnyFDhuihhx7SW2+9pVGjRsnJyUkvvfTSLY3h5OSk++67T8uWLdOgQYM0btw45eTkaOHChfLw8JB08+/Va6+9pqCgIM2cOVPjxo1TjRo11KdPn9uen4ODgwYOHKhffvlFO3fuVGBgoMaMGaONGzdq0KBB2r17t+bPn5/numeffVYNGzbU888/r+7du+ujjz7Kd/z69etr0aJFunTpkoYNG6YZM2aoTZs2ioqKkr29/W3nDQAAAAAAAAAAAAAAAAC49yw5OTk5ZicB4L8rOeWyabEPx6ebFtvqak7cP5PMiStJdYokmBI3x968RbNPy5wHnZ713/vVXtTeYlrsMo5ZpsXOsHM0Ja6Z75hrwhFT4qaX8jQlriQ5xp8wJe53l9xNiStJLo7mfHafSk4zJa4kVXcvZkpcq4t5P8+XLeZ8hknSvrPm/A3auGIJU+JK0n6T5uziZN4/NrOY9OeBtaxJf+wDAAAAAAAAAEzz44l4s1OApEZV3M1O4R+p0Gw3DwAAAAAAAAAAAAAAAADAvWZfaPbzRmHE6wkAAAAAAAAAAAAAAAAAAFAIUSQKAAAAAAAAAAAAAAAAAABQCFEkCgAAAAAAAAAAAAAAAAAAUAhRJAoAAAAAAAAAAAAAAAAAAFAIUSQKAAAAAAAAAAAAAAAAAABQCFEkCgAAAAAAAAAAAAAAAAAAUAhRJAoAAAAAAAAAAAAAAAAAAFAIFTE7AQAAAAAAAAAAAAAAAAAA/q3sLBazUwAKZMnJyckxOwkA/10XklJMi52Vbd7Hn5t9pilxc+wdTYkrSXapCabEzXEoZkpcSbosB1PiFrNkmRJXks6lmfOHb9nseFPiSlKOk7Npsc1iSUs2LbZZ9zvD3smUuJL05V8XTYnbrZQ5n9uSeb+vEktUMCWuJJ1MzjAlrqO9ef+HRbni5v2bRUd7czbVSM/KNiWuJB1PNOcdM1MZk96xUjlJpsSVJMeS5U2LDQAAAAAAAAD/ZXtPmvff1vA/PhXdzE7hH4nt5gEAAAAAAAAAAAAAAAAAAAohikQBAAAAAAAAAAAAAAAAAAAKIYpEAQAAAAAAAAAAAAAAAAAACiGKRAEAAAAAAAAAAAAAAAAAAAohikQBAAAAAAAAAAAAAAAAAAAKIYpEAQAAAAAAAAAAAAAAAAAACqEiZicAAAAAAAAAAAAAAAAAAMC/lcVidgZAwVhJ9G96+OGHZbVatXv37jzndu7cKavVqn379t3SmLd73a0ICwuT1WrN8xUaGnrTY/z++++KiIjQ5cuX71qef9eSJUu0ZcuW27p21apVslqtiouLu2P5dO/eXStWrLhj4+UnOTlZ9evXz/edvBU3eg+zs7MVHBysL7744m/FAQAAAAAAAAAAAAAAAADcHawk+jccPHhQBw4ckCStWbNGjRs3NjmjW1OlShXNnDnTps3V1fWmr//9998VGRmpp556SsWKFbvT6d0R7733ntq0aaPAwMBbvrZNmzZauXLlLd2T69mwYYNiY2P16KOP3pHxCrJt2zaVKFFCfn5+dzWOnZ2dBgwYoIiICD344IMqUoSPEwAAAAAAAAAAAAAAAAD4J2El0b9hzZo1srOzk7+/v6Kjo5WRkWF2SrekaNGi8vX1tfmqWbOm2WndUGpq6j2J4+HhIV9f3ztW/Lh06VJ16tRJRYsWvSPjFWTz5s1q2bKl7O3t72ocSXrwwQd1/vx5bd68+a7HAgAAAAAAAAAAAAAAAADcGopEb1NOTo7Wrl2rZs2a6emnn1Z8fLy2bt16w+usVqsWLFig6dOnq1mzZvLz81NYWJiSk5Pz9E1MTNTo0aPl5+entm3bKioqyub8nj17NHDgQLVs2VK+vr7q0qWLVq9efaemqFWrVumhhx6St7e3WrVqpdmzZysrK8s4N378eElSQECArFargoKCjGsPHDig/v37y9fXV40aNdLw4cN18uTJW74XuVueb968WcOHD1fDhg01YsQISVJsbKyGDx+uRo0aydfXV/379zdWdpWkoKAgxcbGasWKFbJarbJarVq1atVNzS/3/NXbzcfExMhqterzzz/XxIkT1aRJE7Vs2VKvv/66MjMzr3svT5w4od27d6tjx4427SEhIQoNDVV0dLSCg4Pl5+en3r176/jx4zb9Tp8+rdDQUDVo0ECBgYFasmSJpkyZYnPPpStbwG/ZssVoz71/W7du1YgRI+Tn56c2bdpozZo1kv630mrTpk314osvKj09/brzuFaxYsUUGBiozz777JauAwAAAAAAAAAAAAAAAADcfewPfZt++uknxcbGasiQIWrZsqXc3d21du3aPEV7+Vm2bJnq1aun119/XTExMZo5c6bS0tI0e/Zsm36vvPKKunTporlz5+qbb77RzJkzZbVa1bp1a0nSyZMn1bBhQz3xxBNydHTUTz/9pJdeekk5OTnq2rXrTc3j2uLG3FUzFy9erBkzZqhPnz4KCwvToUOHjCLKMWPGqE2bNho0aJDeeecdvfvuu3JxcZGjo6Mk6dSpU+rVq5eqVKmiGTNmGHPr1auXvvjiCzk7O9/yvXj55Zf18MMPa+7cubKzs1NycrJCQkJkZ2enCRMmyMnJSe+8844Ro0KFCoqMjNSAAQPUsGFD9evXT5JUtWrVm5rf9cyZM0ft2rXTnDlztGfPHkVERKhq1ap64oknCrxmx44dKlKkiHx8fPKc+/333xUXF6cxY8YoKytL06ZN09ixY7Vy5UpJVwqSBw8erPPnz2vChAlycXHRwoULdfLkSdnZ2dZ57927VwkJCWrVqpVN+6uvvqquXbuqR48e+uijjzRu3Dj98ccfOnjwoCZMmKATJ05o2rRpqlKligYOHHjd+V/Lz89Pb731lrKzs/PkAwAAAAAAAAAAAAAAAAAwD0Wit2nt2rVycnJShw4d5ODgoODgYH3xxRe6dOmSSpQocd1rHR0dNXfuXGM7cCcnJ7300ksaOnSoPD09jX4dOnTQsGHDJF1ZrXPz5s1av369USTaqVMno29OTo6aNGmiM2fOaOXKlTdVJHrw4EHVq1fPpm3FihWqU6eO3nrrLT3zzDMaNWqUJKlFixZycHDQtGnT1L9/f3l4eBgFl/Xq1ZOHh4cxxpIlS5SZmalFixbJ3d1dklS3bl116tRJn332mUJCQm75XgQFBWns2LHG8XvvvaeTJ09q3bp1Rr8mTZqobdu2Wrp0qcLCwuTl5SVHR0eVLl1avr6+xrXJyck3nF/JkiULvG8+Pj566aWXjOt27typ9evXX7dIdN++fapevbpRSHu1pKQkrV692riHKSkpGj9+vE6fPq3y5cvru+++06+//qoVK1aocePGkqRmzZopMDBQrq6uNmNt2rRJDRs2zNPesWNHDR061Mh/w4YNWrdunTZs2CAHBwdJ0q5duxQdHX3LRaJ16tRRcnKyDh06pNq1a9/StQAAAAAAAAAAAAAAAACAu4dl/25DZmamoqOjFRgYKBcXF0nSQw89pMuXL2vDhg03vL5t27ZGUaR0pYAvJydH+/bts+nXsmVL43uLxSJPT0+dPn3aaEtISNDkyZPVtm1b1atXT/Xq1dPKlSt15MgRo09WVpYyMzONr6tVrVpVn3zyic1X3bp1tWfPHqWkpKhjx4421zZv3lypqak6ePDgdee3e/du+fv7GwWikuTp6ak6deroxx9/vK170aZNmzwxateubVNI6u7urubNm+eJca2/O7+rn0vu3K5+Lvk5e/ZsgYWnderUsSmyrVWrliQZY+7bt0+urq5GgagklShRQgEBAXnG2rx5s9q2bZunvUWLFsb3Li4u8vDwUOPGjY0CUUmqXr26Tp06dd155Cd3XufOnbvlawEAAAAAAAAAAAAAAIB/OztZ+PoHfCF/rCR6G7Zt26a4uDi1bdtWiYmJkqT77rtPZcqU0dq1a/XII49c9/pSpUrZHDs7O8vJyUlnz561ac8tQM3l4OCgpKQk4zgsLEx79uzRkCFDVKtWLTk7O+uDDz7QV199ZfRp3769YmNjjeONGzeqcuXKkq6s2unt7Z0nv4sXL0pSgauR3qiQMDExUXXr1s3TXqpUKSUkJORpu1pB9+LafomJiSpdunS+MW5U5Pl355ffc0lPT7/uNenp6fmuIiopz6qfuYWbaWlpkq4UmF5dRJrr2rZTp07pjz/+0OzZs2+Ys6OjY75xbzSP/OTOKzU19ZavBQAAAAAAAAAAAAAAAADcPRSJ3oY1a9ZIksaPH6/x48fbnLt48aIuXLiQp6jxahcuXLA5Tk5OVlpamsqWLXvTOaSlpWnz5s0KCwuz2b79/ffft+n3zjvv2BT+3UwMNzc3SVJkZKTKly+f53xuken1rr92jtKVeVevXj1P29UKuhcWi22lt5ubm82KqVePl5v/9fKTbn9+t8PNzc2mWPdWlC1bVnFxcXnar23btGmTqlWrppo1a95WnNuVWyh99cqxAAAAAAAAAAAAAAAAAADzUSR6iy5fvqyNGzfq/vvvV+/evW3OnT9/XqNGjdKXX35pU7h5rU2bNmn8+PHGNuvR0dGyWCz5rupZkPT0dGVnZ9tsF56cnKxvv/3Wpp/Var3pMXP5+fmpWLFiOn36tNq3b19gv9zY164+2ahRI3300UdKSEgwCjIPHz6sAwcO6NFHH7Xpe7v3olGjRlq/fr0OHz5sFEUmJCTo+++/1+OPP26TY+6KnLc6vzupRo0a2rlz521d6+3trcTERP3www9q0qSJJOnSpUvavn27zWqgBW01f7flFr9eWwAMAAAAAAAAAAAAAAAAADAXRaK3aOPGjUpJSVFISIj8/f3znH/33Xe1du3a6xaJpqena8iQIXriiScUExOjmTNnKjg4WJ6enjedh4uLi7y9vRUVFSUPDw8VKVJECxYskLOzc76rTt4KV1dXDR8+XDNmzNDp06fVtGlT2dvb68SJE9q4caMiIiJUrFgxI98VK1bo/vvvV9GiRWW1WtW3b1+tWrVK/fr106BBg5SWlqY5c+aoQoUKebZ4v9170a1bNy1ZskShoaF67rnn5OTkpHfeeUdFihRRnz59jH41a9bUjh07tG3bNrm6uqpy5coqWbLkTc3vTmrYsKHmzp2r06dP57t66fW0bt1a9erV0+jRozVq1Ci5urrq3XffVYkSJYwVVi9fvqwdO3bo6aefvqN5S9KOHTvyrIJauXJl1a9fX5K0f/9+eXp6ysPD447HBgAAAAAAAAAAAAAAAADcPopEb9HatWtVsWLFfAtEJemRRx7Ra6+9puPHjxc4RkhIiOLi4jRu3Dilp6erffv2Cg8Pv+VcZs2apfDwcIWFhcnd3V0hISFKSUnRokWLbnmsa/Xr10/lypXT4sWLtXz5chUpUkRVq1ZVmzZtjBVEvby8NGzYMH388cd69913VaFCBX377beqUKGCli1bpunTp2vMmDGys7NTixYtFBYWJmdn5ztyL5ydnbVs2TJNmzZNL7/8srKzs9WwYUMtX75cFSpUMPqNGjVKr776qoYNG6ZLly5p6tSp6tat203N705q2rSp3N3d9d1336lHjx63dK3FYtHbb7+t8PBwhYeHy9XVVb1799aRI0f0+++/S5K+//57OTo6qnHjxnc895kzZ+Zp6969u6ZMmSJJ+u677xQcHHzH4wIAAAAAAAAAAAAAAAAA/h5LTk5OjtlJ/JdYrVaNGzdO/fv3NzsV0/3X7sW0adP022+/6b333vvbY6Wnp6tTp05q3Lixpk6dqpdfflmJiYl6880370CmN+/gwYPq0qWL1q9frypVqtzWGBeSUu5wVjcvK9u8jz83+0xT4ubYO5oSV5LsUhNMiZvjcGdXBr4Vl3Xni85vRjFLlilxJelcmsWUuGWz402JK0k5Ts437lTIWNKSTYtt1v3OsHcyJa4kffnXRVPiditlzue2ZN7vq8QSFW7c6S45mZxhSlxHe3M+tyWpXHHz/s2io72dKXHTs7JNiStJxxPNecfMVMakd6xUTpIpcSXJseSt7VwBAAAAAAAAALgzfj2VaHYKkFSvgqvZKfwjsZIocI/069dPHTp00B9//KE6derc0rUrV65Udna2atSoocTERH3wwQeKjY3VG2+8IUmaNGnS3Uj5hhYtWqQuXbrcdoEoAAAAAAAAAAAAAAAAAODuoUgUuEfKli2rqVOnKi4u7pavdXJy0oIFCxQbGytJqlOnjubPny9vb+87neZNy87OVrVq1fTII4+YlgMAAAAAAAAAAAAAAABgNot5m7cBN8R28wBMxXbz9xbbzd9bbDd/77Dd/L3FdvP3FtvN3ztsN39vsd38vcV28/cO280DAAAAAAAAwH/Pb6fZbv6fwKs8283nx5z/MgYAAAAAAAAAAAAAAAAAAIC7iiJRAAAAAAAAAAAAAAAAAACAQogiUQAAAAAAAAAAAAAAAAAAgEKIIlEAAAAAAAAAAAAAAAAAAIBCiCJRAAAAAAAAAAAAAAAAAACAQogiUQAAAAAAAAAAAAAAAAAAgEKoiNkJAAAAAAAAAAAAAAAAAADwb2VnMTsDoGAUiQIwVckze02LneVcxrTYaa4VTYnrkJlmSlxJiskqYUpc+2zz/hJzczIttGnSs3NMiVskPsaUuJKUVKGBabHNYlfcvJe7WPxxU+L+ZalgSlxJur+GuylxsyzmfG5LksWk31clz+43Ja4klahQz5S4dqkJpsSVJMvlTNNi5zgWNyWuxcnZlLiSdN/P75sSt4hvkClxJcmSkGpK3Oyzx0yJK0lJ9dqbEteleDFT4gIAAAAAAAAAgBtju3kAAAAAAAAAAAAAAAAAAIBCiCJRAAAAAAAAAAAAAAAAAACAQogiUQAAAAAAAAAAAAAAAAAAgEKIIlEAAAAAAAAAAAAAAAAAAIBCiCJRAAAAAAAAAAAAAAAAAACAQqiI2QkAAAAAAAAAAAAAAAAAAPBvZbGYnQFQMFYSBQAAAAAAAAAAAAAAAAAAKIQoEv2PioiIkJ+f3y2fKyx27twpq9Wqffv23dJ1YWFh6ty58w37BQUFaeLEibebXh6bN29W69atlZ6eflvXHzlyRFarVSdPniywT5cuXRQWFmYc3+g9iImJka+vr2JiYm4rJwAAAAAAAAAAAAAAAADA3UWRKHAXREZGql+/fndkrJycHM2ePVt9+/aVo6PjbY2xadMmWa1WVaxY8Y7kJEmVK1dWcHCwIiIi7tiYAAAAAAAAAAAAAAAAAIA7hyJR4C7w8vJS5cqV78hYO3fu1MGDB/XII4/c9hibNm1S27Zt70g+V+vevbvWrVunuLi4Oz42AAAAAAAAAAAAAAAAAODvoUgUN2XmzJl66KGH5Ofnp1atWmnUqFE6e/Zsnn6bN2/WY489Jh8fHzVr1kyvvPKKUlJSjPO527xv3bpVI0aMkJ+fn9q0aaM1a9ZIkt577z21adNGTZs21Ysvvphne/UDBw6of//+8vX1VaNGjTR8+PA8W6gnJSVpzJgx8vPzU0BAgN544w0tWrRIVqv1unNMS0vT1KlT1bJlS3l7e6tLly7asGFDvn23bNmizp07y9vbW926ddPPP/9sc/7a7eZzt6nfuXOnHnnkEfn6+qp79+7av3//dXOSpNWrV6tJkyby8PCwaT948KCeeuopeXt7q0OHDvriiy80ePBghYSE2PRLTEzUTz/9ZFMk+tNPP6lbt27y9vZW586dtWXLlhvmkZ9GjRrJ3d3deH4AAAAAAAAAAAAAAAAAgH8OikT/4zIzM/N8ZWdn5+l34cIFhYaGav78+XrxxRcVGxurkJAQZWZmGn2io6M1aNAg3XfffYqMjNTYsWO1YcMGvfjii3nGe/XVV1W7dm1FRkaqQYMGGjdunGbMmKH/+7//04QJEzR8+HB9/vnnWrRokXHNqVOn1KtXL128eFEzZszQhAkT9Ouvv6pXr15KTk42+o0fP16bN2/W2LFjNW3aNB06dEjvvffeDe/FmDFjtHLlSj3zzDOaO3euatWqpWHDhmnjxo02/c6dO6cJEyaof//+mjNnjhwdHdW/f39duHDhuuOfO3dOkydPNq5LS0vT0KFDlZGRcd3rvv/+ezVs2NCmLTU1Vf369VN8fLxmzJihUaNGKSoqSr/++mue67du3So3Nzf5+PgYefTv31+Ojo6aM2eO+vfvrwkTJujMmTM3vEfXsrOzU4MGDfT999/f8rUAAAAAAAAAAAAAAAAAgLuriNkJwDwpKSmqV69evueKFy9uczx16lTj+6ysLPn5+al169basWOHWrZsqZycHE2fPl0PPvigpkyZYvQtU6aMBgwYoMGDB6t27dpGe8eOHTV06FBJko+PjzZs2KB169Zpw4YNcnBwkCTt2rVL0dHRGjhwoCRpyZIlyszM1KJFi+Tu7i5Jqlu3rjp16qTPPvtMISEh+uuvv7Rhwwa9/vrrxvbsrVq10gMPPHDde/HHH3/o66+/1oQJE9SzZ09JUuvWrRUbG6u5c+eqXbt2Rt/4+HjNmTNHAQEBkqSmTZsqMDBQS5Ys0ejRowuMkZCQoOXLlxv3oVixYurdu7d++eUXNW7cON9rzp49qzNnzuRZBfXTTz/VhQsX9MEHHxjb2tevX18dOnRQ1apVbfpu2rRJrVu3lp3dlZrwpUuXymKxKCoqSi4uLpKk8uXLq2/fvte9RwWpU6eOVqxYcVvXAgAAAAAAAAAAAAAAAADuHlYS/Q8rWrSoPvnkkzxfPXr0yNN3y5Yt6tmzpxo1aiQvLy+1bt1aknT06FFJ0pEjRxQbG6sHHnjAZlXSpk2bys7OLs+26i1atDC+d3FxkYeHhxo3bmwUiEpS9erVderUKeN49+7d8vf3NwpEJcnT01N16tTRjz/+KEnat2+fJNkUddrZ2dlstZ6f3Os7duxo0/7AAw/ot99+U0pKik2+uQWiucfNmzfXL7/8ct0YZcuWtSmUrVWrliRddwXPc+fOSVKereb379+v++67zygQlaTKlSurTp06Nv2ysrK0detWm/n/8ssv8vf3NwpEJSkgIMDmvt6KkiVL6uLFizdcERUAAAAAAAAAAAAAAAAojOxk4esf8IX8sZLof5idnZ28vb3ztG/evNnmeO/evRo8eLDatWunZ599VqVKlZLFYlGPHj2UlpYmSbp48aIkaciQIfnGurrYU5JNgaIkOTo6ytXV1abNwcFB6enpxnFiYqLq1q2bZ+xSpUopISFB0pWiSgcHhzzjX1tkea2EhAQ5ODjkKZQsXbq0cnJylJSUZKyumt9YpUqV0qFDh64bI7/5STLuYX5yzzk6Otq0nz17Nt88PDw8bMbbs2ePLl26ZFOUe+7cOVWrVi3fa29Hbm5paWk2Rb4AAAAAAAAAAAAAAAAAAHNRJIob+uabb+Ts7Kw5c+YYW5bHxsba9MktrgwPD5ePj0+eMcqWLfu383Bzc9OFCxfytF+4cEHVq1eXdGV7+4yMDCUlJdkUisbFxd1w7IyMDCUkJMjNzc1oP3/+vCwWyw3HunDhgsqUKXOrU7qh3FwSExNt2suWLavff/89T/+4uDiVKFHCON60aZOaNGkiZ2dno61MmTL53scb3aOCJCYmysHBwSYGAAAAAAAAAAAAAAAAAMB8bDePG0pNTZWDg4Mslv8tybtmzRqbPjVr1lT58uV14sQJeXt75/kqV67c386jUaNG2rFjh7FqqCQdPnxYBw4cUKNGjSRJ9evXlyRt3LjR6JOdna1NmzbdcGxJio6OtmmPjo6Wl5eXsYqoJCUlJWn79u02x99//70aNGhwmzMrWOXKleXg4KCYmBib9vr16+vAgQM6ceKE0RYTE6M//vjDpt/mzZtttpqXJB8fH+3cuVNJSUlG2/bt2xUfH39bOcbGxqpGjRq3dS0AAAAAAAAAAAAAAAAA4O5hJVHcUIsWLbR06VJNmjRJ7du31549e/T555/b9LFYLAoLC9OYMWOUkpKiNm3aqFixYjp58qS2bNmikSNH/u1Cwr59+2rVqlXq16+fBg0apLS0NM2ZM0cVKlRQ165dJUm1a9dW+/btNXnyZF2+fFkVK1bURx99pNTUVJsi12vVqVNHHTp00LRp05SamqoaNWroiy++0J49e/T222/b9HV3d9eLL76o4cOHy8XFRVFRUcrJyVGfPn3+1vzy4+TkpPr16+vXX3+1aX/00Uc1b948DRw4UMOGDZMkRUZGqnTp0sY8T5w4ob/++itPkWifPn30/vvv69lnn9Wzzz6rxMRERUREGKvBXi0rKytP4ax0pdC0YsWKkqT9+/cbRbYAAAAAAAAAAAAAAAAAgH8OikRxQ4GBgRozZoyWL1+uVatWqWHDhpo/f76Cg4Nt+j3wwANydXXVvHnzjJVGK1WqpFatWql06dJ/O48KFSpo2bJlmj59usaMGSM7Ozu1aNFCYWFhNludv/baa5o4caKmT58uR0dHde3aVbVr19aKFSuuO/6MGTP0xhtvKCoqSvHx8apZs6beeustBQUF2fQrU6aMxowZo+nTp+v48eOqXbu2Fi5ceEfmmJ/g4GAtWbJEOTk5RgFo0aJFtWjRIr3yyisaM2aMypUrp8GDB2v16tVycXGRdGWreU9PT1WpUsVmvLJlyyoqKkqTJ0/WiBEjVLVqVYWHh2v27Nl5YqelpWnEiBF52qdPn64uXbrowoUL+vXXXzVq1Ki7MHMAAAAAAAAAAAAAAAAAwN9hycnJyTE7CeBue+qpp2RnZ6dly5aZncoti4uLU2BgoBYtWqQmTZoU2C8+Pl7333+/+vbtq6FDh6pfv36qU6eOxo0bd9dyW7FihZYsWaKvv/76uiu1Xk/2XzvucFY3L8u5jGmx01wrmhLXISvNlLiSFJtmb0pc+9t8N+8ENyc7U+IWs2SZEleSYi+bE7d6/K837nSXJFVoYFpss9iZ92OlYvHHTYl7wFLBlLiSVMHZnH/XVcKSYUpcSbJkmvP7qsiFo6bElaT0CvVMiWuXmmBKXEmyZGWaFjvHsbgpcbOcnG/c6S6xfLvYlLhFfINu3OkusWSkmhI3++wxU+JKUmq99qbEdSlezJS4AAAAAAAAAPBPcfBsktkpQFLtsi5mp/CPxEqiKHTWr1+vU6dO6b777tPly5e1du1a7d69W3PnzjU7tdvi4eGhJ554QkuXLrUpEl2wYIFKly6tSpUq6dy5c1q0aJGysrL06KOPSpIWLVp0V/PKzs7We++9pyFDhtx2gSgAAAAAAAAAAAAAAAAA4O6hSBSFTvHixfX555/r6NGjysjIUM2aNTVjxgzdf//9Zqd22wYOHKj3339f6enpcnR0lCTZ2dnpnXfe0ZkzZ2Rvb68GDRpo6dKlqlDh3qx0dvbsWXXt2lUPP/zwPYkHAAAAAAAAAAAAAAAA/BOxvhr+ydhuHoCp2G7+3mK7+XuL7ebvHbabv7fYbv7eYrv5e4ft5u8ttpu/t9hu/t5hu3kAAAAAAAAA+O/56xzbzf8T1CrDdvP5Mad6BQAAAAAAAAAAAAAAAAAAAHcVRaIAAAAAAAAAAAAAAAAAAACFEEWiAAAAAAAAAAAAAAAAAAAAhRBFogAAAAAAAAAAAAAAAAAAAIUQRaIAAAAAAAAAAAAAAAAAAACFUBGzEwAAAAAAAAAAAAAAAAAA4N/KzmJ2BkDBKBIFYKocpxKmxf4zp4xpsT3Ss02JezHVvAWkSxczJ7ajvXl/iZ2/nGVK3KqWBFPiSpJFbqbEzSh7nylxJSkzO8e02Ga93cWyU0yKLFkyUk2Jm2pnzue2ZN47dibL3pS4kpSVXcyUuHbuXqbElSTHdHPilrJ3NCewpEuO7qbFPp6YYUrcqvbmfZZktepjStxzKZmmxJUk9xLmfI4dzKpsSlxJ8jbpd8avpxJNiStJ9Sq4mhYbAAAAAAAAAIB/A7abBwAAAAAAAAAAAAAAAAAAKIQoEgUAAAAAAAAAAAAAAAAAACiEKBIFAAAAAAAAAAAAAAAAAAAohCgSBQAAAAAAAAAAAAAAAAAAKIQoEgUAAAAAAAAAAAAAAAAAACiEKBIFAAAAAAAAAAAAAAAAAAAohIqYnQAAAAAAAAAAAAAAAAAAAP9WFrMTAK6DlURvQ0REhKxWq1q1aqXs7Ow853v27Cmr1aqwsDATsruxuLg4TZs2TcHBwfL29lbDhg3Vq1cvffzxx8rKyjI7PdPs3LlTVqtV+/btuyvjL1q0SHXq1NGpU6fyPX/gwAFZrVZ98sknNzVeSEiIQkND72SKAAAAAAAAAAAAAAAAAIBChCLR2+Tg4KCLFy/qhx9+sGmPjY3Vzz//rOLFi5uU2fUdO3ZMXbt21dq1a9WjRw9FRUVpzpw58vHx0dSpU7Vp0yazUyy0OnXqJIvFonXr1uV7ft26dXJ0dFRwcPA9zgwAAAAAAAAAAAAAAAAAUBix3fxtcnBwUEBAgNatWyd/f3+jfd26dapdu7bs7P6Z9bdjxoxRVlaWPv30U5UrV85ob926tXr16qWkpKS/NX5qaqqKFi36d9P8V8vJyVFGRoYcHR1t2suVK6cmTZpo7dq1euaZZ/Jct27dOrVp00YuLi73KlUAAAAAAAAAAAAAAAAAQCH2z6xk/Jfo3Lmz1q9fr4yMDKNt7dq16ty5c779Dx06pEGDBqlRo0by9fXVgAEDdPz4cZs+ixYt0qOPPqpGjRopICBAoaGhOnLkiE2fsLAwde7cWTt37tQjjzwiX19fde/eXfv3779uvrt379bevXsVGhpqUyCaq2LFirJarcbxDz/8oJ49e8rHx0f+/v4aP3684uPjjfMxMTGyWq1atWqVXnrpJfn7++uxxx6T9L+t0FevXq37779fPj4+CgkJ0eHDh/NcHx0dbZPHlClTFBQUZBwnJibqpZdeUqtWreTt7a3AwECNHDnS5pozZ85o3Lhxat68uXx8fNSxY0ctXbrUOG+1WrVw4UKba5YsWWIz3/zcyvPYsmWLHn74YXl7e+vbb7/Nd7yHHnpIv//+uw4dOmTTvmfPHsXExOihhx6SJMXHx2v8+PHy9/eXj4+PevbsmWfV2mvl5nG1xMRE4xnlCgoK0sSJE7VkyRIFBgbKz89PYWFhSk9P1++//66ePXsa79SBAwdsxsvJydHChQsVHBys+vXrq127dlqyZMl18wIAAAAAAAAAAAAAAAAAmIOVRP+Gtm3b6sUXX9S2bdvUpk0b/fXXXzpw4IDmzp2rL7/80qbviRMn1LNnT9WuXVvTpk2TxWLRvHnz1LdvX0VHRxurTp4+fVq9evVSxYoVlZycrA8//FA9e/bU+vXr5e7ubox37tw5TZ48WQMGDJCLi4tmzZqloUOHasOGDXJwcMg33127dkmSWrVqdcO57d+/X08//bT8/f315ptv6vz585o1a5b++usvffjhh7K3tzf6vvHGGwoMDNSsWbOUnZ1ttP/66686fvy4Ro8eLUmaM2eOnnnmGZv53oypU6dq69atGj16tCpVqqRz587pu+++M85fvHhRjz/+uCRp5MiRqly5so4dO5anAPd23OzzOHv2rCZPnqxBgwapQoUKqlixYr7jBQcHa8KECVq7dq1GjBhhtK9du1YuLi5q06aNsrKy9Oyzz+rEiRMaM2aMSpcurWXLlunpp5/Whx9+qPr16//teW3cuFG1a9fWxIkTdeLECU2bNk0ODg76+eef1bdvX5UuXVozZ87UiBEj9OWXXxor406ZMkUff/yxBg4cqAYNGuinn37SzJkz5eTkpCeeeOJv5wUAAAAAAAAAAAAAAAAAuHMoEv0bihUrpqCgIGOb8LVr18rPz09VqlTJ0zcyMlJubm5avHixnJycJEkNGzZUu3bt9PHHH+upp56SJL3wwgvGNVlZWWrRooUCAgK0fv16oxBSkhISErR8+XLVrl3byKV379765Zdf1Lhx43zzPXPmjCQVWMB4tXnz5qlMmTKaN2+eUXRaoUIF9e/fX1u2bLFZ6bNOnTqaMmVKnjEuXLig5cuXq3r16pIkLy8vdezYUatWrVLPnj1vmEOuffv2qXPnzuratavR1qlTJ+P7JUuW6MKFC/rqq69UuXJlSVJAQMBNj389t/I8oqKi1KBBg+uO5+rqqsDAQK1bt84oEs3KylJ0dLQ6dOggR0dHbdy4UXv37tW7775rFPS2bNlSHTp00Pz58xUREXFH5vb2228bxbq7du3SRx99pKioKLVu3VqSlJ2drYEDB+rPP/9UnTp1dPz4cS1fvlwTJkww5t68eXOlpqZq7ty5evzxx41iUgAAAAAAAAAAAAAAAACA+ajo+ps6d+6sjRs3KjU1VV9++aVN8eLVtm3bpqCgINnb2yszM1OZmZlydXWVl5eXzTbxP//8s7GCp5eXlxo0aKCUlBQdPXrUZryyZcsaBaKSVKtWLUn/KwT9u3bv3q127drZrErasmVLubq66scff7Tp26ZNm3zHqF27tlEgKknVqlVTnTp19Msvv9xSLl5eXvrss8+0cOFC/fnnn3nOb9++Xc2aNTMKRO+km30e7u7uNywQzdW5c2cdO3ZM+/btkyTt2LFD58+fN7aa3717t5ydnW1WfHVwcFD79u3z3Pvb1aRJE5vVXKtXry47Ozs1a9bMpk2STp06JUn6/vvvJUkdOnQw3uHMzEw1b95c586dM/oBAAAAAAAAAAAAAAAAAP4ZWEn0b2rZsqUcHBz05ptvKiYmRg888EC+/S5evKilS5dq6dKlec7lFmKePHlS/fr1U/369TVhwgSVLVtWDg4OCg0NVVpams01rq6u+Y5xbb+rlStXTtKVor9q1apdd16JiYkqVapUnvZSpUopISEhT1t+Crr+3Llz1419rZdfftlYhXX69OmqUKGCBgwYoCeffFKSFB8fb1Mwe6fcyvMoXbr0TY8bFBSkEiVKaO3atfL29tbatWtVtmxZ+fv7Syr43pcuXTrPvb9d+b0/RYsWtSkcvfadunjxonJycmwKSa926tQpVapU6Y7kBwAAAAAAAAAAAAAAAPxb2FksZqcAFIgi0b/JwcFBHTp00JIlSxQQEFBgsaCbm5sCAwONwsarlShRQpK0detWpaSkKDIy0ijiy8zMvGOFgU2bNpUk/d///d8Ni0Td3Nx04cKFPO0XLlyQm5ubTZulgA+5gq6vU6eOJMnJyUmSlJGRYdMnMTHR5tjFxUUvvviiXnzxRR04cEDvvfeeJkyYoPvuu0+NGzeWu7u7zp49e935ODo63jDOtW7leRR0D/Lj5OSkDh066Msvv9TIkSO1YcMGde/e3diqvaB7f/78+Tz3/mr5zfFOvTu5eVksFr3//vs2K8zmqlGjxh2LBQAAAAAAAAAAAAAAAAD4+9hu/g547LHH1LZtW/Xu3bvAPgEBATp48KC8vLzk7e1t81WzZk1JUmpqqiwWi4oU+V/t7ldffaXMzMw7kmfjxo3l4+OjefPm5VtUeerUKR04cECS1KhRI23cuNEm9rZt25SYmKhGjRrdVLyDBw/q2LFjxvGxY8f0xx9/GNuylypVSg4ODjp06JDRJz09XT/88EOBY1qtVo0fP16SjOsCAgK0Y8cOnTx5ssDrypcvbxNH+t/26QW5m8+jc+fOOnv2rGbMmKGkpCRjq3npyr1PTk7W//3f/xltmZmZ+uabb65778uXL6/Tp0/r0qVLRtu2bdv+dq65AgICJF1ZufXad9jb21vOzs53LBYAAAAAAAAAAAAAAAAA4O9jJdE7wMfHR2+//fZ1+wwfPlzdu3dX//791aNHD5UuXVrnz5/Xrl271LhxY3Xu3NnYxnv8+PHq2bOnDh48qMWLF+fZGvzvmDlzpkJCQvToo4/q6aefVr169YzCzBUrVuj111+X1WrVwIED1bNnT4WGhiokJETnz5/XrFmz5OPjo8DAwJuKVapUKQ0cOFDDhw+XJL355psqV66cunXrJkmys7NT+/bttWLFClWrVk0lS5bU8uXLlZOTY7MyZ8+ePdW+fXvVrl1b9vb2Wr16tRwcHNS4cWNJUt++ffX555+rV69eGjRokKpUqaITJ07o6NGjGjt2rCQpODhYS5culbe3t2rUqKEvvvhCZ86cuW7+d/N55K46u2LFCtWsWVP16tUzzrVp00Y+Pj4aO3asRo8erdKlS2vZsmU6e/as3nrrrQLH7NChg9566y298MIL6tGjhw4ePKhPPvnkb+eaq0aNGnrqqac0btw49e/fXw0aNFBGRoaOHj2qnTt33vBnAAAAAAAAAAAAAAAAAABwb1Ekeo9Uq1ZNH3/8sebMmaMJEyYoJSVFZcqUUZMmTWS1WiVdWSVz6tSpioyMVGhoqOrWras333xTzz333B3N47PPPlNUVJQ++OADnTp1So6OjvLy8tILL7ygtm3bSpLq16+vRYsW6Y033tCwYcNUvHhxBQUF6fnnn5e9vf1NxapXr546dOigGTNm6Ny5c2rQoIEmTJggR0dHo8/LL7+sl19+WZMnT1aJEiXUv39/1ahRQxs3bjT6NGzYUKtXr1ZMTIzs7Ox03333ad68efL09JQklSxZUh988IFmzZqlmTNn6vLly6pUqZKefPJJY4zBgwfrwoULmjt3riwWix5//HH17t1b06ZNKzD/u/k87O3t9cADD2jZsmXq3LlznnMLFizQ9OnTNWPGDKWkpKhevXpatGiR6tevX+CYtWrV0rRp0/T2229r8ODBatSokWbOnKkuXf4fe3ceX9O1/3/8nZN5jpCYWzEdRRBDI2ZKQ1ulWkWJoeai2hpKTaWtqZQKLVrz0KaDupXeRl1EldLrUqUtdbWGqCFEJpH5/P7wc749MkhIbM19PR+PPJqz917rvfY+O+ec1Cdrdbnr8d40efJkBQQEKCIiQkuWLJG7u7sCAgLUsWPHIssAAAAAAAAAAAAAAAAAABQNO4vFYjF6ECh5wsLC5ObmpmXLlhk9FNznss4eMSz7mMODhmX7uhas2LqoXU3NMiRXksoYdM5O9na3P6iYXL5uzPV+wC7BkFxJOidvQ3IrOGUYkitJyXYuhmUbdXd7ZKcYlCzZx58zJPdHk3HvGZW9HA3JTc0y7teErGxjsk12xr1nGPV+VdruuiG5kpRi72ZY9plEY943HjDo51mSjPqRjk3JNCZYko+LMZ8/T1xJNSRXkgL9XQ3JPZdk3PNcp3zRrb4CAAAAAAAAAHfq9JVko4cASQ+W9jB6CPclk9EDAAAAAAAAAAAAAAAAAAAAQNGjSBQAAAAAAAAAAAAAAAAAAKAEcjB6ACiZ1q1bZ/QQAAAAAAAAAAAAAAAAAKDY2dkZPQIgb8wkCgAAAAAAAAAAAAAAAAAAUAJRJAoAAAAAAAAAAAAAAAAAAFACUSQKAAAAAAAAAAAAAAAAAABQAlEkCgAAAAAAAAAAAAAAAAAAUAJRJAoAAAAAAAAAAAAAAAAAAFACUSQKAAAAAAAAAAAAAAAAAABQAjkYPQAAAAAAAAAAAAAAAAAAAP6umKkR9zOKRAEY6rRrFcOyazhcNyz7uqOnIbml7Yw7Z1myDYnNtjfmWktSQMrvhuSe96xmSK4klXMz5qNFRrZxH2nssy2GZV/LMCb7QpqTIbmSVNWvuiG5ZgN/rdv2e7whuV1czxqSK0kWJ1dDcrNdvA3JlSSLvYshuckmD0NyJcnN3s6w7GyLMa+fLgaesyk1wZBcTxfj3qNT7N0MyQ0ubdxng/8mZxqSW93DmM/6kpSWGGdYtrOXr2HZAAAAAAAAAAAUFEXMAAAAAAAAAAAAAAAAAAAAJRBFogAAAAAAAAAAAAAAAAAAACUQRaIAAAAAAAAAAAAAAAAAAAAlEEWiAAAAAAAAAAAAAAAAAAAAJRBFogAAAAAAAAAAAAAAAAAAACUQRaIAAAAAAAAAAAAAAAAAAAAlkIPRAwAAAAAAAAAAAAAAAAAA4O/Kzs7O6CEAeWImUdwT4eHhCgoKKvac/fv3y2w268iRI8WeVRDh4eE6ePBgsWa8+OKLmjNnTo7tu3bt0uDBg9W0aVPVqVNHzZo105AhQxQZGans7Owcx0dERKh9+/bWcef3fMXExKhBgwaKiYkpuhMBAAAAAAAAAAAAAAAAABQpikSBYrR48WIdOnSo2Pr/+eeftXPnTvXv399m+zvvvKMhQ4bI2dlZU6dO1erVqzVlyhR5enpq3Lhx2rNnT46+du7cqTZt2hQot1KlSgoNDVV4eHgRnAUAAAAAAAAAAAAAAAAAoDiw3DzwN7Z27Vq1aNFCZcuWtW6Ljo7WsmXLNHLkSI0aNcrm+E6dOqlfv35ycLD90U9LS9O+ffu0ZMmSAmc/88wzGjBggF599VX5+vre3YkAAAAAAAAAAAAAAAAAAIocM4nivnDhwgWNHTtWwcHBqlevnnr37q2jR4/aHGM2m7VixQqbbatXr5bZbM6372+//Vb169fXokWLJEnZ2dl677331K5dO9WtW1cdO3bUxx9/nKPdyZMnNXLkSD388MOqX7++nnzySUVGRkqSRo0apZ49e+Zos3HjRgUGBio+Pt46rrlz58psNstsNmv//v2SJIvFohUrVig0NFR169bVI488otWrV+e4JqNHj1azZs0UGBiodu3aaebMmdb9KSkp+uabbxQaGmrTbtWqVfLz89Pw4cNzvR716tVT7dq1bbZ9//33MplMatKkSX6X0kajRo3k4+OjLVu2FLgNAAAAAAAAAAAAAAAAAODeYSZRGC4hIUHPPfec3NzcrEuir1u3Tv369dM333yj0qVL33Hf33zzjcaMGaOXXnpJAwcOlHSjaHPt2rUaPny4goKCFB0drWnTpikzM1N9+vSRJJ06dUo9evRQ+fLlNWnSJPn5+em3337Tn3/+KUnq3r27Bg8erN9//11Vq1a15n3++efq0KGDfHx8FBERoR49eigsLExPPPGEJKl69eqSpLfeekuffvqphg0bpvr16+vgwYOaN2+enJ2d1atXL0nS+PHjdenSJU2ePFmlS5fW+fPnbQpnf/zxR6WkpKhRo0bWbZmZmTp48KBCQ0NzzBaanx07dqhFixZycnIqcBuTyaT69etr79696tevX4HbAQAAAAAAAAAAAAAAAADuDYpEYbg1a9YoMTFRn376qbUgNCQkRKGhoVqxYoXGjx9/R/1u3rxZkydP1qRJk6yFl3FxcVq/fr0GDhxoXYq9RYsWunr1qpYsWaJevXrJ3t5e4eHhcnR01EcffSQPDw9JUrNmzax9t2jRQhUqVNDnn3+ucePGSZJ+++03HT16VK+88ookqUGDBpKk8uXLW7+XpDNnzmj9+vWaPn26evToYe07NTVVS5YsUY8ePWQymXTkyBG98soreuyxx6xtu3btav3+yJEjcnNzU+XKla3b4uPjlZ6ervLly9tcC4vFoqysLOtjk8kkk+n/JhLetWuXRo8eXbgLLKlWrVrasGFDodsBAAAAAAAAAAAAAAAAAIofy83DcHv27FFwcLC8vb2VmZmpzMxM69LnR44cuaM+P/nkE02ePFlvvvmmtUBUkn766SdlZGSoY8eONsd36tRJcXFxOnXqlCRp3759Cg0NtRaI3spkMunpp5/WP/7xD2VmZkq6MYtoxYoVFRISku/Y9u7dK0l69NFHreebmZmpZs2aKTY2VufPn5ck1a5dWytXrtTGjRt1+vTpHP3ExsaqVKlSuWbY2dnZPN66davq1Klj/XrzzTet+3799VddunRJbdq0yXfcuSlVqpSuXr2qjIyMQrcFAAAAAAAAAAAAAAAAABQvZhKF4a5evaoff/xRderUybHvgQceuKM+v/nmG5UvXz5H4WNCQoIkqUyZMjbbbz6Oj4+3/tff3z/fjGeeeUbvvfeedu3apVatWunLL7/Uc889ZzNDZ26uXr0qi8Wipk2b5rr//PnzqlixohYsWKAFCxZo4cKFmj59ugICAvTKK6/o0UcflSSlpaXlWB7ex8dHTk5OunDhgs32kJAQffbZZ5Kk4cOH2+zbsWOH6tWrJ19f33zHnZub+WlpaXJ0dCx0ewAAAAAAAAAAAAAAAODvzmR3+2MAo1AkCsN5e3urZcuWuS53/tciSCcnpxwzViYmJuba55w5czR79mwNHDhQa9assc4I6uPjI0m6cuWKypYtaz3+8uXLNvt9fHx06dKlfMddrlw5tWzZUp9//rmysrJ09epVdevWLf+T1Y3ztbOz08aNG3MtrAwICJAk+fv7a9asWcrOztbRo0f1/vvv6+WXX1ZUVJQqV64sb29vJSUl2bR1cHBQw4YN9f333ysrK0v29vbWzMDAQEnKUVgaHR2tdu3a3XbcuUlMTJSjo2OeM64CAAAAAAAAAAAAAAAAAIzDcvMwXLNmzXTy5ElVq1ZNgYGBNl9ms9l6XLly5XTy5EmbtjeXbr9V6dKltWbNGiUkJGjQoEFKSUmRJAUGBsrR0VFRUVE2x3/99dcqXbq0qlSpIunGzJtbt25VcnJyvmPv3r27du3apZUrVyokJEQVK1a02e/o6Ki0tDSbbTeXo4+Pj89xvoGBgTkKLk0mk+rVq6eXXnpJmZmZ1qXnAwICFBcXZz23mwYMGKBLly5p6dKl+Y5dulEce+TIEbVt2/a2x+bm3Llz1qJWAAAAAAAAAAAAAAAAAMD9hZlEcc9kZWXlKM6UpGeffVZbtmxRnz591LdvX1WoUEFxcXE6fPiwypYtq/79+0uSQkNDtWbNGgUGBiogIEBffvmlLl68mGde2bJltXr1avXp00fDhw/X8uXL5evrqz59+mjFihVycnJSgwYNtGvXLkVGRmrKlCnWmTdHjhyp6OhoPffccxo0aJD8/Px08uRJXb9+XYMHD7ZmtGnTRqVKldKhQ4f0zjvv5BhD1apVtX37djVu3Fiurq4KCAhQQECAevfurfHjx2vgwIGqX7++MjIydOrUKe3fv1/vvfeekpKSNHDgQHXp0kUBAQHKyMjQunXr5OXlpdq1a0uSGjZsqOzsbP3yyy9q3LixzZiGDBmiRYsW6dixY+rUqZP8/f2VlJSkAwcOKDY2Vu7u7pJuzCJavnx51apVq8DPV7169VShQgVJ0tGjR9WoUaM8nwMAAAAAAAAAAAAAAAAAgHEoEsU9k5aWluuS8nPnzlVERIQWLlyoefPmKT4+XqVLl1b9+vXVoUMH63EvvPCCrly5oiVLlsjOzk49evRQ3759NXv27DwzK1WqpDVr1qh3794aOXKklixZovHjx8vT01OfffaZli5dqooVK2r69Onq2bOntV2VKlX08ccfa/78+Zo+fbqysrJUpUoVDRkyxKZ/BwcHtWvXTlFRUTZjvWnq1KmaOXOmBg8erNTUVK1du1bBwcGaPHmyAgICFBERoSVLlsjd3V0BAQHq2LGjJMnZ2Vk1a9bUunXrdP78ebm4uKhu3bpasWKFfH19Jd2YSbRmzZravXu3TZGoJI0ZM0aNGjXShg0bNH36dCUnJ8vb21t16tTRzJkz9fjjj0u6USTaunXrQj9fXbp00ZUrV/Tzzz/rlVdeyfP6AwAAAAAAAAAAAAAAAACMY2exWCxGDwL4u8rOzlb79u3Vtm1bTZky5Z7nr1u3TmvXrtU333wjOzu7QrVNT09XcHCwFi5cmGehaH42bNig1atX31H2X/1+OemO296tSg7XDcu+7uhpSK5r5jVDciVJlmxDYrOdjbnWkuR46TdDcs97VjMkV5JKuxnz9ydZ2cZ9nMk0MPtahjHZCWlZhuRKUlUve0NyM2UyJFeStv0eb0huF9ezhuRKksXJ1ZDcbBdvQ3IlyeLoYkhusr2HIbmS5OZw558h79axuDRDcmv5OhuSK0mm1ASDgo3729QUezdDct2yUgzJlaT/XncyJLeauzGf9SUZ9nuGJDl7+RqWDQAAAAAAAOD+cj7ewHoMWJX3cTd6CPcl4/61G/gbS09P108//aT58+frwoUL6t27tyHj6N69u1JTU7Vjx45Ct3VyctKhQ4fuqEA0Oztba9eu1YgRI+6qQBQAAAAAAAAAAAAAAAAAUHxYbh64A5cuXVL37t3l6+urKVOmqGrVqoaMw8XFRbNnz1ZS0r2djfPSpUt66qmn9OSTT97TXAAAAAAAAAAAAAAAAOB+wxxruJ9RJArcgUqVKun48eNGD0OS1Lx583ueWa5cOQ0bNuye5wIAAAAAAAAAAAAAAAAACo7l5gEAAAAAAAAAAAAAAAAAAEogikQBAAAAAAAAAAAAAAAAAABKIIpEAQAAAAAAAAAAAAAAAAAASiCKRAEAAAAAAAAAAAAAAAAAAEogikQBAAAAAAAAAAAAAAAAAABKIIpEAQAAAAAAAAAAAAAAAAAASiAHowcA4H/btYxsw7JN6VcNy3Z1yTQk1+LoZkiuJNknXTQk90K2cedc/sIfhuT6la5iSK4kJWcY8/cnTvZ2huRK0uXrWYZlV3I35npnWYz7O6PLqRZDct0cjcmVpPKezobkpnwXZUiuJDlVqWVIrunBOobkSlK2WylDcs8lZhiSK0m1U08al12qkiG5567ZG5IrSWXcvA3JTc007vXT06DPBxY5GpIrSWcTUg3JLevuYUiuJHknGvOZW5K+jEk3JPfJ2uUMyQUAAAAAAACQN2ZqxP2M+xMAAAAAAAAAAAAAAAAAAKAEokgUAAAAAAAAAAAAAAAAAACgBKJIFAAAAAAAAAAAAAAAAAAAoASiSBQAAAAAAAAAAAAAAAAAAKAEokgUAAAAAAAAAAAAAAAAAACgBKJIFAAAAAAAAAAAAAAAAAAAoASiSBQAAAAAAAAAAAAAAAAAAKAEokgUKELh4eEym83Wr6ZNm6pv3746cOCAJGnTpk0ym82Ki4srVL+bNm3Sli1b7mhM+/fvl9ls1pEjRwrdbunSpXeUCQAAAAAAAAAAAAAAAPyvsLOz4+s++ELuKBIFipiLi4siIiIUERGh119/XfHx8erfv79+++23O+7ziy++UGRkZBGO8vZ++OEHLVu27J5mAgAAAAAAAAAAAAAAAACKjoPRAwBKGpPJpAYNGlgf16tXT+3atdPHH3+sunXrGjcwAAAAAAAAAAAAAAAAAMD/FGYSBYpZhQoV5Ovrq5iYmFz3z5s3T507d1ZQUJBatmypV155RZcuXbLuDwsL0w8//KDo6GjrMvbh4eHW/dHR0erevbvq1aunpk2batq0aUpJScl3TBaLRStWrFBoaKjq1q2rRx55RKtXr7buDw8P1+LFi5WSkmLNDAsLkyRduHBBo0ePVrNmzRQYGKh27dpp5syZd3GFAAAAAAAAAAAAAAAAAADFgZlEgWKWnJys+Ph4+fv757r/ypUrGjp0qPz9/RUXF6dVq1YpLCxMX331lRwcHDRt2jSNGzdOLi4uevXVVyVJ5cqVkyRFRUXp5ZdfVrdu3TRq1CjFxsZq/vz5SkxM1IIFC/Ic01tvvaVPP/1Uw4YNU/369XXw4EHNmzdPzs7O6tWrl7p3764LFy4oMjJSa9askSR5eHhIksaPH69Lly5p8uTJKl26tM6fP6+jR48W5SUDAAAAAAAAAAAAAAAAABQBikSBYpCZmSnpxqybc+bMUVZWlkJDQxUbG5vj2FmzZlm/z8rKUlBQkFq1aqV9+/apRYsWql69ujw8POTm5mazjL3FYtHcuXP12GOP6a233rJu9/Pz05AhQ/TCCy+oRo0aOfLOnDmj9evXa/r06erRo4ckqVmzZkpNTdWSJUvUo0cPlStXTuXKlZPJZLLJlKQjR47olVde0WOPPWbd1rVr1zu5TAAAAAAAAAAAAAAAAACAYsRy80ARS0lJUZ06dVSnTh098sgj2r9/v6ZOnaqWLVvmevyuXbvUs2dPNWrUSLVr11arVq0kSadOnco3548//tC5c+fUqVMnZWZmWr8efvhhmUymPGf33Lt3ryTp0UcftWnXrFkzxcbG6vz58/nm1q5dWytXrtTGjRt1+vTp21wNAAAAAAAAAAAAAAAAAIBRmEkUKGIuLi5av3697OzsVKpUKZUvX14mU+712D/99JNeeOEFPfLIIxo8eLBKly4tOzs7Pfvss0pLS8s35+rVq5KkESNG5Lo/r2LPq1evymKxqGnTpnm2q1ixYp65CxYs0IIFC7Rw4UJNnz5dAQEBeuWVV/Too4/mO14AAAAAAAAAAAAAAACgJDLZGT0CIG8UiQJFzGQyKTAwsEDH/utf/5KHh4cWLlxoLSQ9d+5cgdr6+PhIkqZOnap69erl2O/v759rO29vb9nZ2Wnjxo1ydHTMsT8gICDfXH9/f82aNUvZ2dk6evSo3n//fb388suKiopS5cqVCzR2AAAAAAAAAAAAAAAAAEDxo0gUMFBqaqocHR1lZ/d/f06wZcuWHMc5OjrmmFm0atWqKleunM6ePavevXsXODMkJESSFB8fr3bt2uV5nKOjo9LT0/PcbzKZVK9ePb300kvasWOHTp8+TZEoAAAAAAAAAAAAAAAAANxHKBIFDNS8eXOtWbNGb7zxhjp06KBDhw7pH//4R47jqlatqs2bN2vHjh3y8/OTv7+/ypYtqwkTJmjs2LFKSUlRmzZt5Orqqj///FO7du3Syy+/nOusoAEBAerdu7fGjx+vgQMHqn79+srIyNCpU6e0f/9+vffee5KkatWqKTMzU2vWrFFQUJA8PDzk5+engQMHqkuXLgoICFBGRobWrVsnLy8v1a5du9ivFwAAAAAAAAAAAAAAAACg4CgSBQzUunVrjR07VuvXr9emTZvUsGFDLVu2TKGhoTbHDR48WGfOnNGrr76qxMREjRw5UqNGjVKnTp3k5eWlpUuXWmcgrVixolq2bKkyZcrkmTt58mQFBAQoIiJCS5Yskbu7uwICAtSxY0frMW3bttVzzz2n5cuX68qVK2rSpIlWrFihmjVrat26dTp//rxcXFxUt25drVixQr6+vsVzkQAAAAAAAAAAAAAAAAAAd8TOYrFYjB4EgP9dR84nGJb9kOWCYdnZLp6G5Foc3QzJlST7pIuG5P7pUtGQXEkqf+JfhuRm12lrSK4kJVscDcl1srczJFeSLl7LNCy7krvJkNxLqcZ9fDTmjCU3R6OSpd/iUg3JrfvdYkNyJcmpSi1Dck0P1jEkV5KySj1gSO5vidmG5EpS7dSThmVnlapkSO65TFdDciWpjJsxfyOammnce4anozGfD+yy0g3JlaToc2mG5Dau4GFIriR5J/xhWPY/E0sbkvtk7XKG5AIAAAAAAADI25WkFKOHAEmlPY2ri7mfGfev3QAAAAAAAAAAAAAAAAAAACg2FIkCAAAAAAAAAAAAAAAAAACUQMasNwcAAAAAAAAAAAAAAAAAQAlgZ/QAgHwwkygAAAAAAAAAAAAAAAAAAEAJRJEoAAAAAAAAAAAAAAAAAABACUSRKAAAAAAAAAAAAAAAAAAAQAlEkSgAAAAAAAAAAAAAAAAAAEAJRJEoAAAAAAAAAAAAAAAAAABACUSRKAAAAAAAAAAAAAAAAAAAQAlEkSgAAAAAAAAAAAAAAAAAAEAJZGexWCxGDwLA/67s3/YYlm1x9TIs+4pXVUNyvR2yDcmVpLgMY/4uwdPJuL+HcLRkGpKbbudgSK4kJaYZc4/5ma4bkitJWc4ehmXbZWcZkmsx2RuSK0npWcZ8dP3tSqohuZJUxs2Yn+nKZ417j7ZzdDQkN+PMb4bkSpJDUHtjgrPSjcmVlO1WyrBs+6RYQ3Kv+FQ3JFeSnCLeMiTXPaipIbmSlBV7zpBcOxd3Q3IlydL0aUNyF+7/05BcSRpbw7jXsaxSDxiSm5Bp3O84/t7G3d8AAAAAAADA/Sw+OcXoIUCSj4eb0UO4LzGTKAAAAAAAAAAAAAAAAAAAQAlEkSgAAAAAAAAAAAAAAAAAAEAJRJEoAAAAAAAAAAAAAAAAAABACUSRKAAAAAAAAAAAAAAAAAAAQAlEkSgAAAAAAAAAAAAAAAAAAEAJRJEoAAAAAAAAAAAAAAAAAABACeRg9AAAAAAAAAAAAAAAAAAAAPi7srOzM3oIQJ6YSRTF7sknn5TZbNaBAwdy7Nu/f7/MZrOOHDli3WY2m7VixYp7OcRchYWFaejQoUXW3/HjxxUUFKS4uLgi67Og/vjjD5nNZv355595HtOlSxdNmDDB+jg8PFxBQUF5Hh8TE6MGDRooJiamSMcKAAAAAAAAAAAAAAAAACgaFImiWJ04cULHjx+XJG3ZssXg0RTOtGnT9OqrrxZZfwsXLlS3bt3k6+tbZH0W1M6dO2U2m1WhQoUi67NSpUoKDQ1VeHh4kfUJAAAAAAAAAAAAAAAAACg6FImiWG3ZskUmk0nBwcGKiopSRkaG0UMqsOrVq6tq1apF0tfZs2e1c+dOPf3000XSX2Ht3LlTbdu2LfJ+n3nmGX311VeGzI4KAAAAAAAAAAAAAAAAAMgfRaIoNhaLRZGRkWratKkGDBig+Ph47d69u0Bts7KyNHfuXDVt2lRBQUGaMGGCkpOTrfs3bdoks9mcozjx1iXTJ0yYoCeeeEJ79+5V586dVa9ePfXp00cxMTGKj4/X6NGj1bBhQ7Vv317//Oc/bfq6dbn5m8uvHz9+XL169VL9+vX1xBNPFOicNm/erMqVK6t27drWbTExMTKbzdq8ebOmTp2qxo0bKyQkRKtWrZIkffXVVwoNDVXDhg01cuRIJSYm2vR54sQJ9e7dW4GBgXr00Uf15Zdf6oUXXlBYWJjNcYmJiTp48KBNkejBgwfVrVs3BQYG6oknntCuXbtuew65adSokXx8fP52s8QCAAAAAAAAAAAAAAAAwP8CikRRbA4ePKhz587piSeeUIsWLeTj46PIyMgCtV23bp1+//13zZkzR2PHjtXWrVs1ZcqUOxpHbGysZs+ereHDh2vevHk6c+aMxo4dq5dfflk1a9ZUeHi46tSpo3HjxuncuXP59pWRkaGxY8eqW7duWrx4sXx9ffXiiy/q6tWr+bbbu3evgoKCct23cOFCubi46N1331XHjh01e/ZszZ8/X2vXrtW4ceM0depU7du3T2+//ba1TWpqqp5//nnFx8fr7bff1iuvvKIPPvhAP//8c47+d+/eLW9vb9WrV896PQYOHCgnJyctXLhQAwcO1PTp03Xx4sXbXcocTCaT6tevr7179xa6LQAAAAAAAAAAAAAAAACgeDkYPQCUXJGRkXJ2dtajjz4qR0dHhYaG6ssvv9S1a9fk7u6eb1snJyctWbJE9vb2kiRnZ2dNnjxZI0eOVLVq1Qo1joSEBK1fv141atSQJF26dElvvPGGBg8erBEjRkiSAgMDtW3bNv3rX/9Sv3798uzrZpFo69atJUkBAQF65JFH9O2336pLly65trFYLDp69Kjat2+f6/4GDRrotddekyQ1bdpU33zzjdavX68dO3aoVKlSkqTjx4/rs88+0xtvvCFJ+vzzz3XlyhV99NFHqlSpkiSpbt26evTRR/XAAw/Y9L9z5061atVKJtONmvA1a9bIzs5OH3zwgTw9PSVJ5cqVU//+/fO/kHmoVauWNmzYcEdtAQAAAAAAAAAAAAAAAADFh5lEUSwyMzMVFRWl1q1bWwsRO3furOvXr2vbtm23bd+2bVtrgagkdezYURaLRUeOHCn0WPz9/a0FopJUpUoVSVKzZs2s27y8vOTr66sLFy7k25fJZFJISIj1caVKleTi4pLvLJwJCQlKT0+Xr69vrvubN29u/d7e3l6VK1dWrVq1rAWiN8ecmJioa9euSZKOHj2qmjVrWgtEb46lVq1aNn1nZWVp9+7dNkvNHz58WMHBwdbnRZJCQkLk4+OT77nnpVSpUrp69aoyMjLuqD0AAAAAAAAAAAAAAAAAoHhQJIpisWfPHsXFxalt27ZKTExUYmKiatasKT8/vwItOV+6dGmbxx4eHnJ2dtalS5cKPRYvLy+bx46OjpJkUyQp3Zi9NC0tLd++XFxc5OTklKO//Nrd3Hdru5tuHYejo2OeY77Z16VLl3ItOr1126FDh3Tt2jWbQtTY2Ngc1ze3tgV187xud+0AAAAAAAAAAAAAAACAkshkx9f98IXcsdw8isWWLVskSRMnTtTEiRNt9l29elVXrlzJtVDxpitXrtg8Tk5OVlpamvz9/SXdWH5eUo7ZKxMTE+967EXt5gydRTk2f39//frrrzm2x8XFyd3d3fp4586datKkiTw8PKzb/Pz8clzfm23vRGJiohwdHW0yAAAAAAAAAAAAAAAAAADGYyZRFLnr169r+/btat++vdauXWvz9c477ygzM1P//Oc/8+1j586dysrKsj6OioqSnZ2dAgMDJUlly5aVJP3+++/WY06ePKnz588XwxndHWdnZ1WoUEExMTFF1mfdunV1/PhxnT171rotJiZGx44dszkuOjraZql5SapXr57279+vpKQk67bvv/9e8fHxdzSWc+fOKSAg4I7aAgAAAAAAAAAAAAAAAACKDzOJosht375dKSkpCgsLU3BwcI79H374oSIjIxUWFpZnH+np6RoxYoR69eqlmJgYzZs3T6GhoapWrZokqX79+ipfvrxmzpypMWPGKDk5WcuXL7fO2nm/adiwoX7++eci6+/pp5/W0qVLNWzYMI0aNUqStHjxYpUpU0Z2djfmTj579qz++9//5igS7devnzZu3KjBgwdr8ODBSkxMVHh4eK7XLisrS1FRUTm216tXTxUqVJAkHT16VI0aNSqycwMAAAAAAAAAAAAAAAAAFA1mEkWRi4yMVIUKFXItEJWkrl276scff9SZM2fy7CMsLExVqlTR+PHjNW/ePHXo0EFvvfWWdb+jo6MWL14sZ2dnjR49WsuWLdPEiROtM4zeb0JDQ3Xw4EElJycXSX8uLi5auXKlvL29NXbsWL399tsaMGCAHnzwQXl6ekq6MRtrtWrVVLlyZZu2/v7++uCDD5SamqrRo0frgw8+0NSpU1WuXLkcOWlpaRo9enSOr3//+9+SpCtXrujnn39WaGhokZwXAAAAAAAAAAAAAAAAAKDo2FksFovRgwBKuoyMDLVt21Zjx45V165diyUjPj5e7du3V//+/TVy5Eg9//zzqlWrlsaPH18seZK0YcMGrV69Wt988411BtPCyv5tTxGPquAsrl6GZV/xqmpIrrdDtiG5khSXYczfJXg6Gff3EI6WTENy0+2Mmyg8Mc2Ye8zPdN2QXEnKcvYwLNsuO8uQXIvJ3pBcSUrPMuaj629XUg3JlaQybsb8TFc+a9x7tJ2joyG5GWd+MyRXkhyC2hsTnJVuTK6kbLdShmXbJ8UaknvFp7ohuZLkFPHW7Q8qBu5BTQ3JlaSs2HOG5Nq5uBuSK0mWpk8bkrtw/5+G5ErS2BrGvY5llXrAkNyETON+x/H3Nu7+BgAAAAAAAO5nSSnG/Zs1/o+nm6vRQ7gvsdw8cA84Ojpq8ODBWrt2bZEViS5fvlxlypRRxYoVFRsbq5UrVyorK0tPP33jHwVXrlxZJDl5yc7O1tq1azVixIg7LhAFAAAAAAAAAAAAAAAAABQfikSBe6RXr15KTk5WXFycfH1977o/k8mk999/XxcvXpS9vb3q16+vNWvWqHz58kUw2tu7dOmSnnrqKT355JP3JA8AAAAAAAAAAAAAAAAAUDgUiQL3iJOTk0aMGFFk/Q0aNEiDBg0qsv4Kq1y5cho2bJhh+QAAAAAAAAAAAAAAAMD9gDV4cT8zGT0AAAAAAAAAAAAAAAAAAAAAFD2KRAEAAAAAAAAAAAAAAAAAAEogikQBAAAAAAAAAAAAAAAAAABKIIpEAQAAAAAAAAAAAAAAAAAASiCKRAEAAAAAAAAAAAAAAAAAAEogikQBAAAAAAAAAAAAAAAAAABKIDuLxWIxehAA/nddSLhmWLaXk71h2RevZRiSe+xyiiG5ktTBO9GQ3F/lb0iuZNw9Vs4x3ZBcSbqc5WxIrn9GrCG5kpTkatw95upozN/7OCScNyRXkuwyjHkdy3YvbUiuJCkr05DYz84aEitJcnU05vXT19XRkFxJeqiMqyG5DiY7Q3Ilyd2UZVi2xc6Y10+7zDRDciVpzyVjrvep+OuG5EpSRU8XQ3Id7Y37uWpWwc2QXFO6cb/XHb9uzOdPSari7WRIbkKqca+f5U5/Z0iuQ1BHQ3IBAAAAAACAgkq5nmr0ECDJzdWYfxu43zGTKAAAAAAAAAAAAAAAAAAAQAlEkSgAAAAAAAAAAAAAAAAAAEAJRJEoAAAAAAAAAAAAAAAAAABACUSRKAAAAAAAAAAAAAAAAAAAQAlEkSgAAAAAAAAAAAAAAAAAAEAJRJEoAAAAAAAAAAAAAAAAAABACUSRKAAAAAAAAAAAAAAAAAAAQAnkYPQAAAAAAAAAAAAAAAAAAAD4u7KzM3oEQN6YSbQEMJvNt/3atGlTvn3s379fS5cuvaP8mJgYmc1mRUVF5Xtcu3btbMYUHBysvn376sCBAzbHhYeHKygoyGZsZrNZR44csW4zm81asWLFHY03N2FhYRo6dOhtj7ub3OjoaLVq1Urp6el31P5ufPfdd2rQoIHS0tLyPKZx48YKDw+3Pp4wYYKeeOKJPI//z3/+o+DgYCUnJxfpWAEAAAAAAAAAAAAAAAAARYOZREuAiIgIm8c9evRQWFiYTYHfAw88kG8fP/zwg1auXKlhw4YVyxhvCg0N1fPPPy9JunLlitasWaNBgwbpyy+/tI6xe/fuat26db79REREqEKFCsU61qLMtVgsWrBggfr37y8nJ6diGFn+du7cqZCQEDk7OxdZn40aNVKNGjW0cuVKvfjii0XWLwAAAAAAAAAAAAAAAADcaydPntSbb76pQ4cOyd3dXV26dNFLL71023ovi8WiDz74QBs3blRcXJweeughTZw4UQ0aNLA57uLFi3rzzTf13XffydHRUR06dNDEiRPl4eFRjGdFkWiJcOvNJEnly5fPdbvRypQpYzOuxo0bKzg4WLt371bv3r0lSeXKlVO5cuXy7ed255aVlaXs7Gw5Ojre7ZALlZuX/fv368SJE+ratWuRjqegoqOjCzRTamE988wzmjNnjoYPH17k1xoAAAAAAAAAAAAAAAAA7oWEhAT169dPVapUUXh4uC5evKjZs2crNTVVU6dOzbftBx98oEWLFmns2LEym83asGGDnn/+ef3jH/9Q5cqVJUkZGRkaNGiQJGn+/PlKTU3VnDlzNGbMGC1btqxYz43l5v8HZGdn67333lO7du1Ut25ddezYUR9//LF1f3h4uBYvXqyUlBTrUvBhYWGSblRHv/zyy2rdurXq16+vxx57TCtXrlR2dnaRjM3V1VX29vbKzMy0Gc9fl5vPza3Lvt9cLv6LL75QaGioAgMDdezYsTz7unVp9Zs2b96s9u3bq169egoLC9Pvv/9eoNyoqCiFhoYqKChIffv21ZkzZ3L026RJE/n6+lq37d+/X2azWbt379bo0aMVFBSkNm3aaMuWLZKktWvXqk2bNnr44Yc1adKkHMvUHzhwQF27dlVgYKA6d+6sPXv2qEuXLpowYYLNcSdOnNC5c+fUpk0b67Z//etf6tixowIDA/XMM8/op59+yutS56t9+/ZKSkrSrl277qg9AAAAAAAAAAAAAAAAABjt448/1rVr17R48WK1bNlSzzzzjMaNG6ePP/5YFy9ezLNdWlqali1bpueff179+/dXSEiI3nnnHfn4+NjUmW3dulUnTpzQu+++q3bt2umxxx7TW2+9pejo6Duu3SooZhL9HzB37lytXbtWw4cPV1BQkKKjozVt2jRlZmaqT58+6t69uy5cuKDIyEitWbNGkqxT2F66dEkBAQHq3Lmz3N3d9euvvyo8PFwpKSkaOXJkocdisVisBaFxcXF6//33ZW9vb1PAeKeOHj2qc+fOafTo0fLy8lL58uUL1f7nn3/WmTNnNGbMGEnSwoULNWjQIEVFReU7ZfCvv/6quLg4jR07VllZWZo9e7bGjRuniIgI6zF79+7V008/nWv7119/XU899ZSeffZZffLJJxo/fryOHTumEydOaPr06Tp79qxmz56typUra9iwYZJuPC+DBw9W7dq1tXDhQiUlJen1119XUlKSHnroIZv+d+7cqdq1a8vf39863hdffFGtWrXSxIkTFRMTo5deeilHEWpBeHh4qHr16tq7d6/at29f6PYAAAAAAAAAAAAAAAAAYLRvv/1WISEh8vHxsW7r1KmTpk2bpj179qhbt265tjt48KCSk5PVqVMn6zYnJyd16NBB27Zts+nfbDaratWq1m3NmzeXj4+Pdu3apXr16hX9Sf1/FImWcHFxcVq/fr0GDhyoUaNGSZJatGihq1evasmSJerVq5d1eXeTyZRjOfWQkBCFhIRIulHg2ahRI6Wmpmr9+vV3VCS6ceNGbdy40frYxcVFc+bM0YMPPnjnJ/n/JSQk6LPPPit0cehNV65c0fr161WlShVJUu3atdWxY0dt2rRJPXv2zLNdUlKSNm/ebJ0lNCUlRRMnTtSFCxdUrlw5Xbp0SRcvXpTZbM61fceOHa3Xsl69etq2bZu++uorbdu2zbqE+w8//KCoqChrkejq1atlb2+vZcuWWQt6K1WqpN69e+fof+fOnWrbtq318fLly1W+fHktWbJE9vb2kiRnZ2dNmjSpMJfLqlatWjp8+PAdtQUAAAAAAAAAAAAAAAAAo/3+++85JgH08vKSn59fjtWob20nyab4U5KqVaumNWvWKDU1VS4uLvr9999zHGNnZ6eAgIB8+y8KFImWcD/99JMyMjLUsWNHm+2dOnVSZGSkTp06pWrVquXZ/uZ0uFu2bNH58+eVkZFh3Xft2jW5u7sXajydOnXSwIEDJd0o6oyMjNT48ePl5eWl5s2bF6qvW9WsWfOOC0QlqUaNGtYCUUl68MEHrQWQ+RWJ1qpVy2YZ+erVq0uStUg0NjZWkmyO+au/nrenp6d8fX3VuHFja4GoJFWpUkX79++3Pj5y5IiCg4OtBaKS1LhxY5tKdkm6evWqDh8+bFMAevjwYbVr185aICrdKFS90yLRUqVKWc8RAAAAAAAAAAAAAAAAAIzwyCOP5Lt/+/btee5LTEyUl5dXju3e3t5KSEjIt52Tk5OcnZ1ttnt5eclisSghIUEuLi5KTEyUp6dnofsvChSJlnA3b6AyZcrYbL/5OD4+Pt/2b7/9tj799FONGDFCdevWlaenp7Zv3673339faWlphS4S9fX1VWBgoPVx8+bN9csvv2j+/Pl3XSR66zkWVunSpXPddrsCyFtfHG4Wd6alpdn8N68l62/94Xdycsq1z78uBx8bG2tT0HrTrYWou3btUunSpVWnTh2btreeq4eHR44XqoJycnKyniMAAAAAAAAAAAAAAADwv8bOYjF6CECeKBIt4W7OLHnlyhWVLVvWuv3y5cs2+/MSFRWlHj16aMiQIdZtu3btKrLx2dnZqWrVqtqxY0eR9HUrZ2dnm9lPJSkjI0MpKSk5jr1y5Uqu22rVqnVX4/L29pZ0o2q8qPj5+SkuLi7H9lu3RUdHq3Xr1jbXxs/PL8e5Jicn33GhZ2Ji4m3vIwAAAAAAAAAAAAAAAAAoTvnNFHo7Xl5eSkpKyrE9ISHBWv+VV7v09HSlpaXZTNKXmJgoOzs7a1svLy8lJyfn2v/drJ5dEKZi7R2GCwwMlKOjo6Kiomy2f/311ypdurR1NspbZ6q8KS0tzWbZ86ysLH311VdFNj6LxaKTJ0+qVKlSRdbnX5UtW1YZGRk6c+aMddu+ffuUlZWV49gTJ07o9OnT1senT5/WsWPHVL9+/bsaQ6VKleTo6KiYmJi76uevAgMDtW/fPpsXjgMHDtjMDJuRkaHvvvtObdu2tWlbr1497dy50+Ya3Hp/FMa5c+cUEBBwx+0BAAAAAAAAAAAAAAAAwEhVq1bV77//brMtKSlJsbGxqlq1ar7tJOmPP/6w2f7777+rQoUKcnFxybN/i8WiP/74I9/+iwIziZZwvr6+6tOnj1asWCEnJyc1aNBAu3btUmRkpKZMmSJ7e3tJUrVq1ZSZmak1a9YoKChIHh4eqlq1qpo1a6ZPP/1U1atXV6lSpbRx48Zci0kL6vLly/rxxx8l3aiCjoyM1G+//aaXX365KE43h1atWsnNzU2TJ0/W4MGDdeHCBa1duzbXpdVLly6tYcOG6cUXX5Qkvfvuuypbtqy6det2V2NwdnZW3bp19fPPP99VP3/Vv39/ffTRRxo6dKgGDhyoxMRELVmyRKVKlbLOGnrgwAGlp6erWbNmNm2HDBmiZ555RiNGjFCvXr0UExOjFStW5HpNkpOTcy0gDQ4Othb2Hj16VAMGDCiycwMAAAAAAAAAAAAAAACAe6lVq1ZaunSpEhMT5eXlJenGxHsmk0nNmzfPs13Dhg3l4eGhr7/+2rpidUZGhr755hu1atXKpv8vv/xSp06dsk7s+P333ys+Pl6tW7cuvhMTRaL/E8aPHy9PT0999tlnWrp0qSpWrKjp06erZ8+e1mPatm2r5557TsuXL9eVK1fUpEkTrVu3TlOmTNG0adP0xhtvyNXVVU899ZQ6dOigyZMn39FYtm7dqq1bt0qS3N3d9eCDD+qtt97S008/XSTneqtSpUpp0aJFmjNnjkaMGKGHHnpIc+fOVVhYWI5j69Spo0cffVRvv/22YmNjVb9+fU2fPl1OTk53PY7Q0FCtXr1aFovFZun3O+Xv768PPvhAb775pl588UU98MADmjRpkmbMmCFPT09JN5aaDw4Olqurq03b2rVr691339W8efM0cuRI1ahRQwsWLNDAgQNz5Jw/f16jR4/OsX3Dhg1q3Lixfv75Z8XFxSk0NPSuzwkAAAAAAAAAAAAAAAAAjNCzZ0+tW7dOI0aM0NChQ3Xx4kXNnTtXPXv2VNmyZa3H9evXT3/++ae2bdsm6cYEgkOHDlV4eLh8fX1Vs2ZNffTRR4qPj7epxwoNDdWyZcs0atQovfLKK7p+/brmzp2rNm3aqF69esV6bnYWi8VSrAkAFBcXp9atW2vlypVq0qRJsWScOnVKnTp10syZM/XUU08pNDRUffv2Ve/evYslT5LmzJmjn3/+WWvXrr3jPi4kXCvCERWOl5O9YdkXr2UYknvscoohuZLUwTvRkNxf5W9IrmTcPVbO8c5nfL5bl7Nyzkp8L/hnxBqSK0lJrsbdY66OJkNyHRLOG5IrSXYZxryOZbuXNiRXkpSVaUjsZ2cNiZUkuToa8/rp6+poSK4kPVTG9fYHFQMH093/AdOdcjdlGZZtsTPm9dMuM82QXEnac8mY630q/rohuZJU0dPFkFxHe+N+rppVcDMk15Ru3O91x68b8/lTkqp43/0fld6JhFTjXj/Lnf7OkFyHoI6G5AIAAAAAAAAFlXrduP8fjv/j4np3/+Z28uRJvfHGGzp06JDc3d3VpUsXvfzyyzaTDIaFhencuXPasWOHdZvFYtHy5cu1ceNGxcXF6aGHHtLEiRMVFBRk0//Fixf15ptv6rvvvpODg4M6dOig1157TR4eHnc17tuhSBS4R2bOnKk///xTixcvLpL+5s+fL7PZLH9/f509e1bLli1Tamqqvv76a7m7uxdJRn6Sk5PVtm1bvffee3dV+EqR6L1Fkei9RZHovUOR6L1Fkeg9RpHoPUOR6L1Fkei9RZHovUOR6L1Fkei9RZEoAAAAAAAAkDuKRO8Pd1skWlKx3DxwjwwbNkwbN25Uenp6kSxhn5GRoXnz5uny5ctycXHRww8/rPHjx9+TAlFJ+vPPPzV69OhimxkVAAAAAAAAAAAAAAAA+FuwZBs9AiBPFIkC94ivr69GjhxZZP1NmDBBEyZMKLL+CqtmzZqqWbOmYfkAAAAAAAAAAAAAAAAAgPwZs8YeAAAAAAAAAAAAAAAAAAAAihVFogAAAAAAAAAAAAAAAAAAACUQRaIAAAAAAAAAAAAAAAAAAAAlEEWiAAAAAAAAAAAAAAAAAAAAJRBFogAAAAAAAAAAAAAAAAAAACUQRaIAAAAAAAAAAAAAAAAAAAAlkJ3FYrEYPQgA/7viklIMy3Z1NK5OPikty5Dc9CzjXvKPXbluSO7llHRDciWpQTlPQ3J9XOwNyZWkUvaZhuSarsUZkitJV1z8Dct2NNkZkuudfM6QXEnKditlSK7F5GBIriSdum7M+9WDno6G5EpSSqYx71f2Bv1MSdL1zGxDcn2Me5qVmm3c9XbLMuYzqF26cZ99LY4uhuQm2XsYkitJ7g7G3GOXrxvzWV+SHOyNOWcj/89SRrZx4eUzLxuSm+XhZ0iuJFlMxvyu8ftV436vq1Pey7BsAAAAAAAA/H2kXUsyegiQ5OxuTJ3G/Y6ZRAEAAAAAAAAAAAAAAAAAAEogikQBAAAAAAAAAAAAAAAAAABKIIpEAQAAAAAAAAAAAAAAAAAASiCKRAEAAAAAAAAAAAAAAAAAAEogikQBAAAAAAAAAAAAAAAAAABKIIpEAQAAAAAAAAAAAAAAAAAASiCKRAEAAAAAAAAAAAAAAAAAAEogB6MHAAAAAAAAAAAAAAAAAADA35Yl2+gRAHliJtHbePLJJ2U2m3XgwIEc+/bv3y+z2awjR44US7bZbNaKFSuKpe/cbNq0SVu2bLlnefeTmJgYmc1mRUVFGT2UO/Liiy9qzpw51scTJkzQE088keuxb731ltq1a5dje3JysurWrasDBw4U6HoMGDBA77///t0PHgAAAAAAAAAAAAAAAABQLCgSzceJEyd0/PhxSTKkeDIiIkKdO3e+Z3lffPGFIiMj71ne/cTf318RERFq2rSp0UMptJ9//lk7d+5U//7976qfPXv2yN3dXUFBQQU6fujQoVq5cqUSEhLuKhcAAAAAAAAAAAAAAAAAUDwoEs3Hli1bZDKZFBwcrKioKGVkZNzT/AYNGsjf3/+eZhZEVlbWPb8Wxc3JyUkNGjSQj4+P0UMptLVr16pFixYqW7bsXfUTHR2tFi1ayN7evkDHN23aVF5eXvriiy/uKhcAAAAAAAAAAAAAAAAAUDwoEs2DxWJRZGSkmjZtqgEDBig+Pl67d+++bbuVK1fq6aefVqNGjRQSEqKhQ4fqjz/+sDnm5lLg+/fvV9euXdWgQQM988wzOnr0qM1xty43HxYWpqFDhyoqKkqhoaEKCgpS3759debMGZt26enpeuedd9S2bVvVrVtXnTp1uu1MqGFhYfrhhx8UHR0ts9kss9ms8PBwm9wvvvhCoaGhCgwM1LFjx3Tp0iVNnDhRjzzyiOrVq6dHH31U77zzjtLT03OcxwcffKDw8HA1a9ZMwcHBmjhxolJSUqzHJCYmavLkyWrZsqUCAwPVunVrvfzyy9b9hclavny5FixYoJCQEDVu3Fhz586VxWLR999/ry5duigoKEj9+vXT+fPnre1yW169Xbt2mjFjhjZs2KC2bduqUaNGeuGFFxQXF2c9JiUlRTNmzFBoaKjq16+vdu3aaerUqUpKSrIZ1/bt29WtWzcFBQWpcePG6tatm3bt2mVzzKZNm9S5c2cFBgaqZcuWWrBggbKysvJ93lJSUvTNN98oNDQ03+NuJzs7W7t27cp1Gfr8dOzYUZs3b76rbAAAAAAAAAAAAAAAAABA8XAwegD3q4MHD+rcuXMaMWKEWrRoIR8fH0VGRt62iO7ChQvq06ePKlSooOTkZH388cfq2bOntm7dajNLZWxsrN58800NGTJEnp6emj9/vkaOHKlt27bJ0XHbenYAAQAASURBVNExz/5//fVXxcXFaezYscrKytLs2bM1btw4RUREWI8ZPXq0Dh48qBEjRqhatWratWuXxo0bJy8vL7Vu3TrXfqdNm6Zx48bJxcVFr776qiSpXLly1v1Hjx7VuXPnNHr0aHl5eal8+fK6cuWKfHx8NHHiRHl5eenUqVMKDw9XbGysZs2aZdP/hg0b1KhRI82ePVunTp3S3LlzVbp0aY0dO1aSNGvWLO3evVtjxoxRxYoVFRsbq2+//dba/urVq4XKevjhhzV37lwdPnxY4eHhys7O1p49ezR8+HA5OjrqzTff1KRJk7Ry5cp8n88dO3bo9OnTmjp1qq5evapZs2bpjTfe0IIFCyRJqampysrK0ssvvyxfX1+dP39eS5cu1QsvvKB169ZJks6cOaPRo0fr8ccf15gxY5Sdna1jx47ZLNO+atUqvf322+rXr58mTJigkydPWotEb16j3Pz4449KSUlRo0aN8j2P2/npp5+UkJCgli1bFqpdUFCQPvzwQ8XFxcnX1/euxgAAAAAAAAAAAAAAAAAAKFoUieYhMjJSzs7OevTRR+Xo6KjQ0FB9+eWXunbtmtzd3fNs99prr1m/z8rKUvPmzRUSEqKtW7eqR48e1n0JCQlav369atSoIUlydXVV3759dfjwYTVu3DjP/pOSkrR582ZrQV5KSoomTpyoCxcuqFy5ctq3b5927NihFStWqEWLFpKk5s2bKzY2VuHh4XkWiVavXl0eHh5yc3NTgwYNcuxPSEjQZ599pvLly1u3lSlTxlpQKkkNGzaUq6urJkyYoKlTp8rV1dW6z8/PT/Pnz5cktWrVSr/88ou2bt1qLYA8cuSInnjiCT311FPWNo8//rj1e7PZXOAsf39/vf3225Kkli1baseOHVq9erW++uorVatWTZJ08eJFvfHGG0pMTJSXl1ee19tisej999+Xk5OTJOncuXNatmyZsrOzZTKZ5Ovrq+nTp1uPz8zMVKVKlfTcc8/pjz/+UEBAgH755RdlZGRoypQp8vDwsI7rpuTkZC1atEiDBg3SK6+8IunGc+bo6KjZs2dr4MCBKlWqVK7jO3LkiNzc3FS5cuU8z6Egdu7cqYYNG+Z7LXJTq1YtSTeKTNu0aXNXYwAAAAAAAAAAAAAAAAAAFC2KRHORmZmpqKgotW7dWp6enpKkzp07KyIiQtu2bVPXrl3zbPvjjz/q3Xff1S+//KL4+Hjr9lOnTtkc5+/vby0QlW4UaUo3ihfzU6tWLZsZG2+2u1kkumfPHvn4+Khp06bKzMy0HtesWTO9/vrrysrKkr29fb4ZualZs6ZNgah0o4ByzZo1+uSTTxQTE6O0tDTrvrNnz6pmzZo2+X9VrVo1ffXVV9bHtWvX1hdffCE/Pz+1bNnSpu3dZgUEBOjy5cvWAlFJqlKliqQb1y2/wsgmTZpYC0RvjjsjI0NXrlyRn5+fJGnz5s1avXq1Tp8+rZSUFOuxp06dUkBAgMxms+zt7TV27Fg9++yzatKkifW+kqRDhw4pJSVFHTt2zPGcpaam6sSJE3r44YdzHV9sbGyeBaSFER0drS5duhS63c3s2NjYux4DAAAAAAAAAAAAAAAA8LdksRg9AiBPFInmYs+ePYqLi1Pbtm2VmJgo6UaRpJ+fnyIjI/MsEv3zzz/1/PPPq27dupo+fbr8/f3l6OiooUOH2hQ1SspRmHhziflbj7vV7dpdvXpV8fHxqlOnTq7tY2NjbZaRL6gyZcrk2LZmzRrNmTNHgwYNUnBwsLy8vHTkyBHNmDGjQOebnp5ufTxlyhR5e3tr1apVmjt3rsqXL68hQ4boueeeK5KsorreNwtGb7bbtm2bXn31VfXo0UMvv/yyfHx8FBsbqxEjRliPCQgI0NKlS7Vs2TKNHDlSJpNJLVq00NSpU1WhQgVdvXpVkmxmUf2r8+fP5zm+tLQ0myLWm+zt7ZWVlZVrm+zsbDk4/N+P/vnz53Xs2DEtWLAgz5y83MxOTU0tdFsAAAAAAAAAAAAAAAAAQPGiSDQXW7ZskSRNnDhREydOtNl39epVXblyRaVLl87Rbvfu3UpJSdHixYutxYWZmZlKSEgo/kH/f97e3vL19dXy5ctz3f/XWUgLw87OLse2qKgotWvXTmPGjLFuO3ny5B317+npqUmTJmnSpEk6fvy41q5dq+nTp6tmzZpq3LhxkWYVpaioKD300EOaMWOGddsPP/yQ47hWrVqpVatWSk5O1rfffqtZs2Zp4sSJWrNmjby9vSVJixcvzrWAt1KlSnnme3t7KykpKcd2X19fXb58Odc2ly5dsrkPdu7cqQcffFBVq1bN+0TzcDPbx8en0G0BAAAAAAAAAAAAAAAAAMWLItFbXL9+Xdu3b1f79u3Vt29fm32XL1/WK6+8on/+858KCwvL0TY1NVV2dnY2szR+/fXXNkuIF7dmzZrpww8/lKOjo2rVqlWoto6OjredWfOvUlNTrTNy3nSzwPZumM1mTZw4UZ999plOnjypxo0bF1vW3SrsuDw8PPTYY4/pp59+UmRkpCQpKChIrq6uunDhgjp06FCo/ICAAMXFxSklJUVubm7W7U2aNNHy5cv173//W02aNLFuT05O1v79+9WjRw/rtujoaLVt27ZQuTfFxMRYxwEAAAAAAAAAAAAAAAAAuL9QJHqL7du3KyUlRWFhYQoODs6x/8MPP1RkZGSuRaJNmzaVdGMG0p49e+rEiRNatWpVjiXLi1Pz5s3Vtm1bDRo0SIMGDZLZbNb169f13//+V6dPn9Zbb72VZ9uqVatq8+bN2rFjh/z8/OTv76+yZcvmeXyzZs20du1arV+/XlWqVNGXX36p06dP39G4e/bsqQ4dOqhGjRqyt7fX5s2b5ejoqMaNGxd5VlFq1qyZZsyYoSVLligoKEi7du3S999/b3PMxx9/rB9//FEtW7aUn5+fYmJi9OWXX6p58+aSbixp/+KLL+rtt9/WhQsX9PDDD8ve3l5nz57V9u3bFR4eLldX11zzGzZsqOzsbP3yyy/WayVJLVq0UOPGjTVy5EiNGDFCNWrU0KVLl/Thhx/KZDJZ79/r169r3759GjBgQK79Hz58OMe2MmXKWLOOHj0qNzc3PfTQQ4W/eAAAAAAAAAAAAAAAAACAYkWR6C0iIyNVoUKFXAtEJalr166aOXOmzpw5k2Of2WzWrFmztHjxYg0dOlQPPfSQ3n33Xb300kvFPGpbixYt0vLly/XRRx/p3Llz8vT0VI0aNdStW7d82w0ePFhnzpzRq6++qsTERI0cOVKjRo3K8/gRI0bo6tWrWrRokSQpNDRUkydP1rBhwwo95oYNG2rz5s2KiYmRyWRSzZo1tXTpUlWrVq3Is4pSz549FRMTo/Xr12vFihVq0aKF5s+fr2effdZ6jNls1s6dOzVr1izFx8fLz89Pjz/+uEaPHm095vnnn1fZsmW1atUqrV+/Xg4ODnrggQfUpk2bHDOV/lVAQIBq1qyp3bt32xSJmkwmLVu2TIsWLdKqVat06dIleXh4qGnTpgoPD5e/v78kae/evXJycrJp+1crV67MsS0kJESrV6+WJH377bfq0KGD7O3tC3XdAAAAAAAAAAAAAAAAAADFz85isViMHgSAO7du3TqtXbtW33zzjezs7ArVdsqUKUpMTNS7775b6NyEhAQ1b95cq1atslnSvrDiklLuuO3dcnU0GZadlJZlSG56lnEv+ceuXDck93JKuiG5ktSgnKchuT4uxhVul7LPNCTXdC3OkFxJuuLib1i2o6lwr/tFxTv5nCG5kpTtVsqQXIvJuL+tOnXdmPerBz3z/kOV4paSacz7lb1BP1OSdD0z25BcH+OeZqVmG3e93bKM+Qxql27cZ1+Lo4shuUn2HobkSpK7gzH32OXrxnzWlyQHe2PO2cj/s5SRbVx4+czLhuRmefgZkitJFpMxv2v8ftW43+vqlL93KwQBAAAAAADg7ystKd7oIUCSs6eP0UO4LxlXIQWgSHTv3l2pqanasWNHodu+8cYbd1QgKt0oTm3YsOFdFYgCAAAAAAAAAAAAAAAAAIoPy80Df3MuLi6aPXu2kpKS7mmuj4+PJk+efE8zAQAAAAAAAAAAAAAAgPuOxZhV44CCoEgUKAGaN29+zzP79OlzzzMBAAAAAAAAAAAAAAAAAAXHcvMAAAAAAAAAAAAAAAAAAAAlEEWiAAAAAAAAAAAAAAAAAAAAJRBFogAAAAAAAAAAAAAAAAAAACUQRaIAAAAAAAAAAAAAAAAAAAAlEEWiAAAAAAAAAAAAAAAAAAAAJZCD0QMA8L8tLctiWLa9ybhsozjY2xmWXd7D2ZDc1MxsQ3IlycFkzPX21XVDciXpup27IbnumamG5EpSpoGvY6UcjLm/LfaOhuRKkrIzDYm1y0o3JFeSqri6GZJ7ISXLkFxJcnYw5vXTwDtbVwy63iY3e0NyJeOeZ0nKdPIwJNfIX8CvOxjzHm1vMe598qJBP1d+bsY90yYZc72TMox7npPTjfu8n+3qY0iuXVaGIbmSZJ94wZDcP+KNed2WpJ4LdhuSe2Tu44bkAgAAAAAAACh5KBIFAAAAAAAAAAAAAAAAAOAO2VmM+4N24HZYbh4AAAAAAAAAAAAAAAAAAKAEokgUAAAAAAAAAAAAAAAAAACgBKJIFAAAAAAAAAAAAAAAAAAAoASiSBQAAAAAAAAAAAAAAAAAAKAEokgUAAAAAAAAAAAAAAAAAACgBKJIFAAAAAAAAAAAAAAAAAAAoARyMHoAAAAAAAAAAAAAAAAAAAD8bVmyjR4BkKcSPZPok08+KbPZrAMHDhg9lDxt2rRJW7ZsuaO2v/76q8LDw3X9+vUiG094eLgOHjxYZP39nWzatElms1lxcXFGD6XQ0tLS1Lp1a0VHR1u3tWvXTjNmzMj1+C5dumjChAk5tn/33Xdq0KCB0tLSbns9kpOT9fDDD+s///lPkZwDAAAAAAAAAAAAAAAAAKBoldgi0RMnTuj48eOSdMdFmPfCF198ocjIyDtq++uvv2rx4sVFWiS6ePFiHTp0qMj6+ztp06aNIiIi5OXlZfRQCu2jjz6Sl5eX2rRpc1f97Ny5UyEhIXJ2dr7tsR4eHurTp48WLFhwV5kAAAAAAAAAAAAAAAAAgOJRYotEt2zZIpPJpODgYEVFRSkjI8PoIdlITU01egh35e8+/tz4+vqqQYMGcnBwMHoohWKxWLR27Vo9/fTTd91XdHS02rZtW+Djn376af373//WsWPH7jobAAAAAAAAAAAAAAAAAFC0SmSRqMViUWRkpJo2baoBAwYoPj5eu3fvtjkmIyNDc+bMUZs2bVS3bl21aNFCw4YNU1JSkiRp//79MpvN2rVrl0aOHKkGDRqoRYsWWrp0qU0/J0+e1Msvv6zWrVurfv36euyxx7Ry5UplZ2dbj4mJiZHZbNamTZs0efJkBQcHq3v37goLC9MPP/yg6Ohomc1mmc1mhYeHS7pRrDdgwACFhISoYcOG6t69u7799ltrn5s2bdLEiRMlSSEhITKbzWrXrp11/4ULFzR27FgFBwerXr166t27t44ePZrvdTObzZKkuXPnWsezf/9+677ly5fr7bffVvPmzRUSEiJJOnTokIYNG6YWLVqoQYMG6tKlizZv3mzT781ruWfPHo0ZM0ZBQUFq27atPvjgA5vjTpw4ocGDBys4OFj169dXaGiozTGFydq9e7dGjx6toKAgtWnTxjqb7Nq1a9WmTRs9/PDDmjRpktLT022u6V+XV7/5vP3jH//QjBkz1KRJE7Vo0UJz5sxRZmZmoe4BSVq+fLk6dOigwMBANW3aVP3799fZs2et+9PT0/XOO++obdu2qlu3rjp16lSgWXB/+OEHnTt3TqGhobc9Nj8nTpzQuXPnCjUbacWKFVWvXj1t2rTprrIBAAAAAAAAAAAAAAAAAEXv7zVlYgEdPHhQ586d04gRI9SiRQv5+PgoMjLSpohy2bJl+vjjjzV27FjVqFFDV69e1Z49e2yKBiVpypQpevzxxxUeHq69e/dqwYIF8vb2Vq9evSRJly5dUkBAgDp37ix3d3f9+uuvCg8PV0pKikaOHGnT1zvvvKPWrVtr/vz5ys7OVoUKFTRu3Di5uLjo1VdflSSVK1dO0o0CxbZt2+r555+XyWTSt99+qyFDhmjNmjUKDg5WmzZtNHz4cL3//vv68MMP5enpKScnJ0lSQkKCnnvuObm5uWnKlCny9PTUunXr1K9fP33zzTcqXbp0rtctIiJCPXr0UFhYmJ544glJUvXq1a37165dq/r16+utt96yFkn++eefatiwoXr16iUnJycdPHhQkydPlsVi0VNPPWXT/7Rp09SlSxctWbJE//rXvzRv3jyZzWa1atVKkjRs2DCVKVNGb731ljw8PHTmzBlduHDB2r4wWa+//rqeeuopPfvss/rkk080fvx4HTt2TCdOnND06dN19uxZzZ49W5UrV9awYcPyvJckaeHChXrkkUe0cOFCHTp0SOHh4XrggQcKdQ9s3rxZ7777rl588UU1aNBASUlJ+s9//qNr165Zc0aPHq2DBw9qxIgRqlatmnbt2qVx48bJy8tLrVu3znN8e/fuVfny5VW+fPl8z+N2du7cqdq1a8vf379Q7YKCgrR37967ygYAAAAAAAAAAAAAAAAAFL0SWSQaGRkpZ2dnPfroo3J0dFRoaKi+/PJLXbt2Te7u7pKkI0eOqEWLFurdu7e1XW4zMTZt2tRawNmyZUtduXJF77//vnr06CGTyaSQkBDrrJoWi0WNGjVSamqq1q9fn6NItFatWnrrrbdstnl4eMjNzU0NGjSw2d6nTx/r99nZ2QoODtZ///tfffLJJwoODpavr68eeOABSVKdOnXk6+trPX7NmjVKTEzUp59+ai0IDQkJUWhoqFasWKHx48fnet1ujqF8+fI5xiNJ3t7eWrx4sezs7KzbHn/8cev3FotFTZo00cWLFxUREZGjcPPRRx/VqFGjrOOJjo7W1q1b1apVK8XFxSkmJkaTJk2yFvM2bdrUpn1hsjp27Gi9/vXq1dO2bdv01Vdfadu2bXJ0dJR0YwbOqKio2xaJ1qtXT5MnT5YkNW/eXPv379fWrVutRaIFuQd++uknmc1mDR061Npv+/btrd/v27dPO3bs0IoVK9SiRQtrVmxsrMLDw/MtEj169Kh1Fti7sXPnzkItNX9TrVq1tHbtWiUnJ8vDw+OuxwEAAAAAAAAAAAAAAAAAKBolrkg0MzNTUVFRat26tTw9PSVJnTt3VkREhLZt26auXbtKkmrXrq0VK1ZYC/Dq1q0rk8mUo78OHTrYPA4NDdU//vEPXbhwQRUqVFBaWpqWLVumLVu26Pz588rIyLAe+9eiVEmFWsb7woULWrBggfbu3avY2FhZLBZJNwpCb2fPnj0KDg6Wt7e3dcZPk8mkJk2a6MiRIwUew61atWplUyAq3Zi1NDw8XNu3b9fFixeVlZUlSfLx8cnR/mbxoyTZ2dmpWrVq1plCS5UqpYoVK+qdd95RQkKCQkJCrLOq3klW8+bNrd97enrK19dXjRs3thaISlKVKlW0f//+2573X8ctSdWqVdO+ffusjwtyD9SuXVsbN27UrFmz1KFDB9WvX99mLHv27JGPj4+aNm1qs5R9s2bN9PrrrysrK0v29va5ju/SpUuqW7fubc8jP1evXtXhw4c1adKkQrctVaqULBaLrly5QpEoAAAAAAAAAAAAAAAAANxHSlyR6J49exQXF6e2bdsqMTFRklSzZk35+fkpMjLSWiQ6fPhwmUwmffHFF1q8eLF8fX3Vu3dvjRgxwqYQ8q8zdEpSmTJlJEmxsbGqUKGC3n77bX366acaMWKE6tatK09PT23fvl3vv/++0tLSbIpE81rm/VbZ2dkaPny4kpKS9OKLL+rBBx+Uq6urFi1apPPnz9+2/dWrV/Xjjz/mWlB6c/bRO5Hb+CdMmKBDhw5pxIgRql69ujw8PPTRRx/p66+/znHszaLdmxwdHZWUlCTpRtHoihUrtGDBAs2YMUMpKSmqU6eOJk6cqCZNmtx1lpOTk7y8vHLkp6en3/a8cxv3X9sV5B7o1q2brl27pk8++USrV6+Wp6enunbtqrFjx8rFxUVXr15VfHx8nkXAsbGxOYpmb0pPT7cpOL3J3t7eWkh7q+zsbDk4/N+P/65du1S6dOkCFSHfysnJSZKUmppa6LYAAAAAAAAAAAAAAADA354l2+gRAHkqcUWiW7ZskSRNnDhREydOtNl39epVXblyRaVLl5aTk5NGjRqlUaNG6fTp0/r8888VHh6uSpUqWQtJJSkuLs6mj8uXL0uS/Pz8JElRUVHq0aOHhgwZYj1m165duY7t1lk483L69Gn98ssvWrJkic2S5AUtwvP29lbLli01evToHPtuFvTdiVvHn5aWpujoaE2YMEFhYWHW7Rs3bryj/gMCArRo0SJlZGTo0KFDeueddzRs2DB9++23cnBwKNKsolSQe8BkMqlfv37q16+fLl68qK+++krz589XqVKlNGLECHl7e8vX11fLly/PNePWYuW/8vb2thbb3trm5v16q0uXLtkU/UZHR6t169YFvkf/6mYxdm4zugIAAAAAAAAAAAAAAAAAjFOiikSvX7+u7du3q3379urbt6/NvsuXL+uVV17RP//5T5siQ0l68MEH9corrygiIkK///67zb5t27bZLDm/detW+fv7W2d1TEtLs5nFMSsrS1999VWBx+zo6Ki0tDSbbTcf/7Xfc+fO6dChQ6pSpYpNW0k5ZsNs1qyZvvzyS1WrVk1ubm4FHkte48lLenq6srOzbcaZnJysHTt2FCoztzE8/PDDGjJkiIYPH65Lly6pTJkyxZJVFAp7D5QtW1bPP/+8IiMjrfdbs2bN9OGHH8rR0VG1atUqVH5AQECO+1aSmjRpooiICCUlJdnMhnrgwAHFx8ercePGkqSMjAx99913mjNnTqFybzp37pw8PT2thdMAAAAAAAAAAAAAAAAAgPtDiSoS3b59u1JSUhQWFqbg4OAc+z/88ENFRkYqLCxML7zwgurUqaPatWvL1dVVO3fuVEJCgpo2bWrTZt++fZozZ46aN2+uPXv26B//+IemTp0qk8kk6UZx36effqrq1aurVKlS2rhxY4GWML+patWq2rx5s3bs2CE/Pz/5+/uratWqKleunObPn6/s7GylpKRo0aJF8vf3t2lbrVo1SdKGDRvUvn17ubi4yGw2q3///tqyZYv69Omjvn37qkKFCoqLi9Phw4dVtmxZ9e/fP9/xbN++XY0bN5arq6sCAgLk4eGR67Genp4KDAzUBx98IF9fXzk4OGj58uXy8PDIMQPr7Rw7dkxz5szRY489psqVKys5OVnLli1TxYoV9cADD8je3r7IsopaQe6BqVOnysvLSw0aNJCXl5cOHjyoY8eOqVevXpKk5s2bq23btho0aJAGDRoks9ms69ev67///a9Onz6tt956K8/8hg0b6uuvv1ZGRoZNsWrfvn312Wef6bnnntOgQYPk7++vEydOaMmSJWrcuLGaN28u6UbRaHp6upo1a5Zr/zt37pS7u7vNtho1aljvv6NHjyooKMj6MwEAAAAAAAAAAAAAAAAAuD+UqCLRyMhIVahQIdcCUUnq2rWrZs6cqTNnzlgL61atWqWsrCwFBARo3rx5OQrlZsyYoYiICH300Udyd3fX6NGj1bt3b+v+KVOmaNq0aXrjjTfk6uqqp556Sh06dNDkyZMLNObBgwfrzJkzevXVV5WYmKiRI0dq1KhRCg8P14wZMzR69GiVL19ew4cP1759+3T06FFr29q1a2vUqFH69NNP9eGHH6p8+fLasWOHSpUqpYiICC1cuFDz5s1TfHy8Spcurfr169vMipqbqVOnaubMmRo8eLBSU1O1du3aPK+nJM2fP19Tp07VhAkT5OPjo7CwMKWkpGjlypUFOv+b/Pz8VKZMGS1btkwXL16Up6enGjdurLffflv29vZFmlXUCnIPBAUF6ZNPPtGnn36q69evq3Llypo4caK6d+9uPWbRokVavny5PvroI+vsnDVq1FC3bt3yzX/kkUc0Y8YM/fDDD9bCT0ny9/fXxx9/rAULFmjmzJlKTk6Wv7+/unTpohdffNFa1BkdHa3g4GC5urrm2v9rr72WY9vo0aP1wgsvKCMjQ99//73GjRtXqGsGAAAAAAAAAAAAAAAAACh+dhaLxWL0IO5H+/fvt87EGBgYaPRwgHyNGjVKHh4emjVrVqHbhoaGqm/fvjbFzwUVHR2tMWPG6Ntvv80x22hBnY+/dkftioKbo3Gzn6ZlZhuSa0zqDVdSsgzJ/SP+uiG5klSrjJshuQ84pRmSK0nXHe7steBuucefMiRXki64VjYs28/ZmI9xpmtXDMmVJIuji0HBxr2CWhyNeS25kG7c35M5O9gZkutoMiZXki4kZxqS6+dmb0iuJDk7GPdZzKjn2iE92ZBcybj3aCP/l0NCmjGv3X5uxr1+mmTM9U7KMO55jk815vcMSXrA1bhsoxj1OXDr1dxXubkXJq46YEjukbmPG5ILAAAAAACAO5N+9YLRQ4Akp1LljB7CfYn1oYES4IUXXtDXX3+ty5cvF7rt1q1b76hAVJJWrlypAQMG3HGBKAAAAAAAAAAAAAAAAACg+FAkCpQADz30kF577TWdP3/+nmVeu3ZNDz/8sPr373/PMgEAAAAAAAAAAAAAAAAABWfcGmj3ueDgYB0/ftzoYQAF9uyzz97TPHd3d40cOfKeZgIAAAAAAAAAAAAAAAD3HUu20SMA8sRMogAAAAAAAAAAAAAAAAAAACUQRaIAAAAAAAAAAAAAAAAAAAAlEEWiAAAAAAAAAAAAAAAAAAAAJRBFogAAAAAAAAAAAAAAAAAAACUQRaIAAAAAAAAAAAAAAAAAAAAlEEWiAAAAAAAAAAAAAAAAAAAAJZCdxWKxGD0IAP+7/hubZFi2i72dYdllXIzJNqUmGJIrSVluvobkpmcZ9zZn1Fvs2aQMQ3IlqYa3gyG5pvRrhuRKUpaLl2HZdgbdY3aZaYbkSpLF3tGYXJO9IbmSdCUl05Bc/+x4Q3IlyS7LmNexa+5lDcmVpAvXjHmejXyfNHsb9zeLcRnGZJdyNu6c49OzDcn1MeZlW5KUYdDfxTpnGPe55N0f4w3Jfbmmca8lWe6lDcv+7Zoxnw9iElINyZWkdpXdDMnNsDPm9wxJOhp73bBsozR90Jjf3wEAAAAAAP7O0i/HGD0ESHIqU8noIdyXmEkUAAAAAAAAAAAAAAAAAACgBKJIFAAAAAAAAAAAAAAAAAAAoASiSBQAAAAAAAAAAAAAAAAAAKAEokgUAAAAAAAAAAAAAAAAAACgBKJIFAAAAAAAAAAAAAAAAAAAoASiSBQAAAAAAAAAAAAAAAAAAKAEokgUAAAAAAAAAAAAAAAAAACgBLqjItFdu3Zp8ODBatq0qerUqaNmzZppyJAhioyMVHZ2dlGP8W9pwoQJeuKJJwrdbtOmTdqyZUsxjOjuhYeHKygoKN9jfv31V4WHh+v69ev3aFSFEx8frxEjRqhJkyYym83617/+ZfSQisTx48cVFBSkuLg4SVJMTIzMZrOioqJyHJuYmCiz2axNmzbl2PfOO++oX79+km5/D//nP/9RcHCwkpOTi+gsAAAAAAAAAAAAAAAAgL8fO0s2X/fBF3JX6CLRd955R0OGDJGzs7OmTp2q1atXa8qUKfL09NS4ceO0Z8+e4hjn/4wvvvhCkZGRRg/jjv36669avHjxfVskumrVKu3fv1+zZ89WRESEmjRpYvSQisTChQvVrVs3+fr63lU/O3fuVNu2bQt0bKNGjVSjRg2tXLnyrjIBAAAAAAAAAAAAAAAAAMXDoTAHR0dHa9myZRo5cqRGjRpls69Tp07q16+fHBwK1SX+h6WmpsrFxeWeZv7xxx8ym8165JFH7rovI8afm7Nnz2rnzp25zgxaGOfOndNvv/2mNm3aFLjNM888ozlz5mj48OFydHS8q3wAAAAAAAAAAAAAAAAAQNEq1Eyiq1atkp+fn4YPH57r/nr16ql27drWx9HR0RowYIBCQkLUsGFDde/eXd9++61Nm02bNslsNuvIkSN6/vnnVb9+fYWGhmrv3r3Kzs7WggUL1KxZMzVr1kzz58+3Wc7+5vLnv/zyi3r06KF69erpqaee0i+//KK0tDRNmzZNTZo0UatWrbR69Wqb3EOHDmnYsGFq0aKFGjRooC5dumjz5s0Fug4HDhxQ165dFRgYqM6dO2vPnj3q0qWLJkyYkGebvJZqb9y4scLDwyVJYWFh+uGHHxQdHS2z2Syz2WzdV5zX8vjx4zKbzTlmgc3KylLLli01d+7cAl2XTZs2aeLEiZKkkJAQmc1mtWvXzmZshw4d0oABA9SgQQNrvytXrtTTTz+tRo0aKSQkREOHDtUff/xh0/fNpc/379+vrl27qkGDBnrmmWd09OhRm+M+++wzPf7446pXr56Cg4PVq1cv/fTTT5Iks9msrVu36sCBA9bre9OhQ4fUt29fNWjQQI0aNdKYMWN05coV6/6by7dv2rRJkydPVnBwsLp3717g5yYxMVGTJ09Wy5YtFRgYqNatW+vll1+2OebChQsaO3asgoODVa9ePfXu3TvH+eVm8+bNqly5ss3P3p2Ijo5WQECAqlSpUuA27du3V1JSknbt2nVX2QAAAAAAAAAAAAAAAACAolfgaT8zMzN18OBBhYaGFni20JiYGLVt21bPP/+8TCaTvv32Ww0ZMkRr1qxRcHCwzbGvvvqqevbsqQEDBmj58uUaOXKknnrqKSUnJ2vOnDk6fPiwwsPDVbNmTXXu3NnaLiMjQ6+++qr69++vMmXKaN68eRo5cqQaNmyo0qVLa+HChdq+fbtmzZqlevXqqWHDhpKkP//8Uw0bNlSvXr3k5OSkgwcPavLkybJYLHrqqafyPKdLly5p8ODBql27thYuXKikpCS9/vrrSkpK0kMPPVTQy5mradOmady4cXJxcdGrr74qSSpXrlyxX0uz2az69evr888/V/Pmza397N69W5cuXdLTTz9doPG3adNGw4cP1/vvv68PP/xQnp6ecnJysjlmzJgx6tGjh4YOHSpXV1dJN4oj+/TpowoVKig5OVkff/yxevbsqa1bt8rHx8faNjY2Vm+++aaGDBkiT09PzZ8/XyNHjtS2bdvk6Oiof//735o0aZKef/55tW7dWqmpqfrpp5+UlJQkSYqIiNC8efN07do1TZs2zdrvoUOHFBYWptatW2vBggW6fv26Fi5cqBdeeEERERE243/nnXfUunVrmyLbgjw3s2bN0u7duzVmzBhVrFhRsbGxNoWkCQkJeu655+Tm5qYpU6bI09NT69atU79+/fTNN9+odOnSeV73vXv35lqAXFg7duwo8FLzN3l4eKh69erau3ev2rdvf9djAAAAAAAAAAAAAAAAAAAUnQIXicbHxys9PV3ly5e32W6xWJSVlWV9bDKZZDLdmKC0T58+1u3Z2dkKDg7Wf//7X33yySc5Chv79Omj5557TpJUtmxZde7cWUePHrUW6bVs2VI7duxQVFRUjiLRsWPHqnXr1tacYcOGqX79+tZZLZs2baqoqChFRUVZi0Qff/xxm3No0qSJLl68qIiIiHyLRFevXi17e3stW7ZMHh4ekqRKlSqpd+/eBbmM+apevbo8PDzk5uamBg0a2Owr7mvZvXt3vfHGG0pISJC3t7ck6fPPP1dQUJCqVatWoPH7+vrqgQcekCTVqVNHvr6+OY7p2bOnhgwZYrPttddes36flZWl5s2bKyQkRFu3blWPHj2s+xISErR+/XrVqFFDkuTq6qq+ffvq8OHDaty4sX766Sf5+PhYC2wl2Syd3qBBA3l5ecnOzs7m+s6fP19169bV4sWLZWdnJ0mqWbOmnnjiCe3atct6b0lSrVq19NZbb9mMvyDPzZEjR/TEE0/Y3Ft/vQfXrFmjxMREffrpp9aC0JCQEIWGhmrFihUaP358jmsp3bh3jx49etcFmikpKfrhhx9yPDcFUatWLR0+fPiu8gEAAAAAAAAAAAAAAAAARa/ARaI33Syiu2nr1q0aPXq09XHv3r01depUSTdmiFywYIH27t2r2NhYWSwWSTcKCG/11xksby533bRpU5tjAgICcixDbjKZFBISkqNts2bNrNvs7e31wAMP6MKFC9ZtCQkJCg8P1/bt23Xx4kVroetfZ67MzZEjRxQcHGwtEJVuLBl/u3Z3q7iv5eOPP65Zs2YpMjJSvXv3VlxcnHbu3KnXX3+9SM/jr0WbN/34449699139csvvyg+Pt66/dSpUzbH+fv7WwtEpRtFtZJ08eJFSVLt2rUVHx+vCRMmqHPnzmrYsKF1ttK8XL9+XQcPHtT48eNtip2rVKmi8uXL68iRIzZFormNvyDPTe3atfXFF1/Iz89PLVu2VM2aNW362LNnj4KDg+Xt7a3MzExJN+7tJk2a6MiRI3mOPyEhQenp6bkW5BbG3r175eLiokaNGhW6balSpRQbG3tX+QAAAAAAAAAAAAAAAACAolfgIlEfHx85OTnZFFpKN2Y7/OyzzyRJw4cPt27Pzs7W8OHDlZSUpBdffFEPPvigXF1dtWjRIp0/fz5H/56entbvby5R7uXlZXOMo6Oj0tPTbba5uLjYLGnu6OiYo7+b29PS0qyPJ0yYoEOHDmnEiBHWGTw/+ugjff311/leh9jYWGvh5V/dbZFefu7FtXRzc9MTTzyhzz77TL1799aXX34pR0dHderUqUjPpUyZMjaP//zzTz3//POqW7eupk+fLn9/fzk6Omro0KE2z1de5yDJelxISIjmzp2rtWvXauDAgXJ2dlZoaKhee+21PIt4ExMTlZWVpVmzZmnWrFk59t96fW9d9r2gz82UKVPk7e2tVatWae7cuSpfvryGDBlinfH16tWr+vHHH3Mt+r05O2tubp77X38GJMnBwcE6vlvdLIa9eYx0Y6n5li1b2mwrKCcnpxzPFQAAAAAAAAAAAAAAAADAeAWuCHNwcFDDhg31/fffKysrS/b29pIkb29vBQYGSrItVDt9+rR++eUXLVmyxGYp7NTU1KIa+x1LS0tTdHS0JkyYoLCwMOv2jRs33ratn5+f4uLicmzPbdtfOTs7KyMjw2ZbRkaGUlJSbpt5r65l9+7dFRERoWPHjmnTpk3q1KmT3N3dizTjVrt371ZKSooWL15sLQLNzMxUQkLCHfXXpUsXdenSRXFxcdq+fbtmzZolBwcHzZw5M9fjPT09ZWdnp6FDh+a6ZHupUqVsHt86k25BnxtPT09NmjRJkyZN0vHjx7V27VpNnz5dNWvWVOPGjeXt7a2WLVvazMp7060FoH91s/g1MTExx3aTyZTrDJ+XLl2S9H8FrxaLRd9++22eS9rfTmJiYrHPpAsAAAAAAAAAAAAAAADctyw5J3ID7hemwhw8YMAAXbp0SUuXLr3tsTdnFrw526MknTt3TocOHSrkEIteenq6srOzbcaWnJysHTt23LZtYGCg9u3bp+TkZOu2AwcO2CyTnpuyZcsqIyNDZ86csW7bt2+fzRLnUs4ZT6V7dy0DAwP10EMP6c0339Tx48f19NNPF7qPm2O8dcbXvKSmpsrOzs5mBsuvv/7auuT6nfL19VX37t3VvHlz/f7773ke5+bmpgYNGuj3339XYGBgjq9KlSrlm3Mnz43ZbNbEiRMlSSdPnpQkNWvWTCdPnlS1atVyjMFsNufZl7OzsypUqKCYmBib7S4uLgoMDNT27dtztPnXv/4lZ2dna3H3kSNHFBcXp1atWuV7rnk5d+6cAgIC7qgtAAAAAAAAAAAAAAAAAKD4FGpt6TZt2mjIkCFatGiRjh07pk6dOsnf319JSUk6cOCAYmNjrTNPVq1aVeXKldP8+fOVnZ2tlJQULVq0SP7+/sVyIoXh6empwMBAffDBB/L19ZWDg4OWL18uDw+P284I2r9/f3300UcaOnSoBg4cqMTERC1ZskSlSpXKMcvkX7Vq1Upubm6aPHmyBg8erAsXLmjt2rVydna2Oa5q1aravHmzduzYIT8/P/n7+9/Ta9m9e3fNmDFDAQEBatSoUaHbV6tWTZK0YcMGtW/fXi4uLvkWOTZt2lSSNHHiRPXs2VMnTpzQqlWrciwtXxCLFi1SfHy8Hn74YZUuXVq//fabdu/erf79++fbbvz48erXr59eeuklPf744/Ly8tKFCxe0d+9edevWTcHBwXm2Lehz07NnT3Xo0EE1atSQvb29Nm/eLEdHRzVu3FjSjftqy5Yt6tOnj/r27asKFSooLi5Ohw8fVtmyZfM9h4YNG+rnn3/OsX3UqFEaMmSIRo4cqS5dusjZ2Vn79u3T6tWrNXjwYOs13rlzp4KCgnKdDTQ5OVlRUVE5tgcHB1tnWT169KgGDBiQ5/gAAAAAAAAAAAAAAAAAAMYoVJGoJI0ZM0aNGjXShg0bNH36dCUnJ8vb21t16tTRzJkz9fjjj0u6sUR2eHi4ZsyYodGjR6t8+fIaPny49u3bp6NHjxb5iRTW/PnzNXXqVE2YMEE+Pj4KCwtTSkqKVq5cmW87f39/ffDBB3rzzTf14osv6oEHHtCkSZM0Y8YMeXp65tmuVKlSWrRokebMmaMRI0booYce0ty5c22Wu5ekwYMH68yZM3r11VeVmJiokSNHatSoUffsWnbo0EEzZsy4o1lEJal27doaNWqUPv30U3344YcqX758vjO0ms1mzZo1S4sXL9bQoUP10EMP6d1339VLL71U6OzAwECtWbNGX3/9tZKTk1WuXDkNHDhQw4cPz7ddw4YNtXHjRoWHh2vixInKyMhQuXLl1LRpUz344IP5ti3ofd6wYUNt3rxZMTExMplMqlmzppYuXWotqi1VqpQiIiK0cOFCzZs3T/Hx8SpdurTq16+vDh065DuG0NBQjR07VsnJyfLw8LBub9mypT788EO9//77Gj9+vDIyMlSlShVNnDhRffr0sR4XHR2txx57LNe+z58/r9GjR+fYvmHDBjVu3Fg///yz4uLiFBoamu8YAQAAAAAAAAAAAAAAAAD3np3FYrEYPYi/u1OnTqlTp06aOXOmnnrqKaOHc1c+++wzTZs2TdHR0fLz8zN6OCiAjIwMtW3bVmPHjlXXrl0L1fbixYtq1aqVvvrqK1WvXr3Q2XPmzNHPP/+stWvXFrrtTf+NTbrjtnfLxT7v2X+LWxkXY7JNqQmG5EpSlpuvIbnpWca9zRn1Fns2KcOQXEmq4V3ovz8pEqb0a4bkSlKWS+Fnvy4qdgbdY3aZaYbkSpLF3tGYXJO9IbmSdCUl05Bc/+x4Q3IlyS7LmNexa+5lDcmVpAvXjHmejXyfNHubDMuOyzAmu5Szceccn55tSK6PMS/bkqQMGXO9nTOM+1zy7o/xhuS+XNO415Is99KGZf92zZjPBzEJqYbkSlK7ym6G5GbYGfN7hiQdjb1uWLZRmj5ozO/vAAAAAAAAf2cZl04ZPQRIcvSvYvQQ7kvG/R/Wv7H58+fLbDbL399fZ8+e1bJly+Tn56dHH33U6KHdsZiYGJ0+fVrvvfeeOnXqRIHo34ijo6MGDx6stWvXFrpItGzZsjp+/Pgd5SYnJ+uzzz7Te++9d0ftAQAAAAAAAAAAAAAAAADFiyLRO5CRkaF58+bp8uXLcnFx0cMPP6zx48fL3d3d6KHdscWLFysyMlJBQUGaMGGC0cNBIfXq1UvJycmKi4uTr++9me3hzz//1OjRo9WkSZN7kgcAAAAAAAAAAAAAAAAAKByWmwdgKJabv7dYbv7eYrn5e4fl5u9xLsvN31MsN3/vsNz8vcVy8/cWy83fOyw3f2+x3Py9xXLz/xtYbh4AAAAAAKDwMi7+YfQQIMmxbIDRQ7gvGfcvVAAAAAAAAAAAAAAAAAAAACg2FIkCAAAAAAAAAAAAAAAAAACUQBSJAgAAAAAAAAAAAAAAAAAAlEAUiQIAAAAAAAAAAAAAAAAAAJRAFIkCAAAAAAAAAAAAAAAAAACUQBSJAgAAAAAAAAAAAAAAAAAAlEAORg8AwP+280nphmUH+6QZlp2U5WNIroejmyG5kmSflmxIbrqdcefs++d/DMn1KNPAkFxJMqVfMyzbKKasDMOyM+yM+SjnaGdnSK5k4D2Wadz7lb/JmL/rMvLn2WLvZEiue8olQ3IlydvZz5Dci9eMew2Tga+fpe2yjQlOzTQmV1JShrshuS729obkSpJRb1cWB2djgiX1CCxnSK7dhQOG5EqSY8pVw7KvOVQ3JNfZwbi/+Xb44wdDcv/wa2JIriSVdnU0JDc1y6D3KkldP9xnSO7mQU0NyQUAAAAAAABKOopEAQAAAAAAAAAAAAAAAAC4Uxbj/ugXuB2WmwcAAAAAAAAAAAAAAAAAACiBKBIFAAAAAAAAAAAAAAAAAAAogSgSBQAAAAAAAAAAAAAAAAAAKIEoEgUAAAAAAAAAAAAAAAAAACiBKBIFAAAAAAAAAAAAAAAAAAAogSgSBQAAAAAAAAAAAAAAAAAAKIEoEgUAAAAAAAAAAAAAAAAAACiBKBIthCeffFJms1kHDhzIsW///v0ym806cuSIdZvZbNaKFSvuOvfWfsLCwjR06NC77reo3Y/jKqrnQJLCw8N18ODBIumrqG3YsEFPP/3/2Lv3+J7r///j9x3e28xOmPOcctgaOxnNmDMjkYjwcT5FzrFEKUl9EDltCCHHWgcplERI+qSTnEKiMIXZ7GQ27x1+f/jt/e3dDobx0rpdL5ddPt6v9+v5vD9er/d721ufh+fzccvjjRs3ytvbW/Hx8bnO3bFjh7y9vRUTE5PruZ49e2rRokWSpFatWunll1/ON3PJkiUaOHBgEVQPAAAAAAAAAAAAAAAA/HPZZGfxdR98IW80iRbSyZMndeLECUnS5s2bDa1l6tSpevbZZw2t4d8oKipKBw4cMLqMXK5du6YlS5boySefvKN54uPjdfDgQbVs2bJQ5/fu3VuHDh3SN998c0e5AAAAAAAAAAAAAAAAAIC7gybRQtq8ebNsbW0VEhKibdu2yWw2G1ZLrVq19MADDxiWj/vLJ598IrPZrNatW9/RPHv27FHZsmXl6+tbqPPd3NwUHh6uNWvW3FEuAAAAAAAAAAAAAAAAAODuoEm0ELKzs7VlyxY1atRIAwcOVEJCgvbu3XvL85w7d05t2rTRkCFDlJaWpkuXLmny5Mlq3bq1/P39FR4errlz5+r69esFzvP3bd0jIyMVFBSkEydOqFevXgoICFDHjh3zrHHjxo3q1KmT/Pz81LRpU82bN0+ZmZkF5uXMf+jQIXXr1k1+fn56+OGHtWvXrjzP37Ztm9q1a6egoCD169dPZ8+etXo+ISFBkydPVkhIiPz9/dWzZ0999913Vuf88MMP6t27t4KDgxUUFKROnTrpww8/zHUPNm3apDZt2sjf3199+/bV6dOnc9WTlZWlyMhINW7cWCEhIZo8ebJSU1MtzxfmdfD29pYkvfbaa/L29pa3t7f2798vSVq5cqUef/xxBQcHKzQ0VMOGDdNvv/1mVcPJkyc1dOhQhYSEKCAgQO3atdPy5cutzjlw4ID69eunwMBABQcHa8KECYqLi8v3dcmxadMmtW7dWvb29jc9tyC7du1SixYtbmlM+/bttWfPnjy3tQcAAAAAAAAAAAAAAAAAGIsm0UL48ccfdf78eXXs2FFhYWHy8PDQli1bbmmO06dPq3fv3nrwwQe1ePFiOTk56cqVK/Lw8NDkyZP15ptvasiQIfrwww81derUW67RbDYrIiJCXbt2VVRUlEqXLq0xY8boypUrlnNWrVqlKVOmKCwsTG+88YaGDh2qNWvWaN68eYWa/+mnn1aXLl0UFRWlatWqadSoUTpx4oTVeceOHdOKFSsUERGhGTNm6OzZs3rmmWcsz2dmZmro0KHatWuXIiIitGDBAjk7O2vgwIE6cuSIJCklJUXDhg2Ti4uL5s6dq8WLF+uJJ55QUlKSVdbRo0e1dOlSTZgwQbNmzdKlS5c0ZMiQXE2269ev1++//66ZM2dq5MiR2rx5sxYvXmx5vjCvQ3R0tKQbzanR0dGKjo5W3bp1JUkXLlxQnz59tHjxYr3yyivKyspSz549lZCQYBk/fPhwJSUl6dVXX9XSpUs1ePBgXbt2zfL8gQMH1LdvX7m6umrevHmaPn26Dh8+rBEjRhT4uqSlpenAgQOqX79+gefdjNls1ldffVXoreZzBAUFKTMzU99+++0d5QMAAAAAAAAAAAAAAAAAit6dLT34L7FlyxY5OjoqPDxcJpNJ7dq108cff6yrV6+qZMmSNx1//PhxDRo0SGFhYZoxY4bs7Owk3Vid8tlnn7WcV79+fZUoUUKTJk3Siy++qBIlShS6xpwm0ebNm0uSatSoodatW+vLL79U586dlZKSooULF2rIkCEaP368JKlJkyYymUyaOXOmBg8erFKlShU4/1NPPaVu3bpJksLCwhQeHq6lS5dq7ty5lvOSk5O1adMmlS5dWpKUmpqqyZMn68KFC6pQoYJ2796tQ4cO6c0331TTpk1zzRUZGanffvtNycnJGj9+vGUFz9DQ0Fw1xcXFad26dapevbokydfXV+3bt9fGjRvVs2dPy3lly5bV66+/Lklq1qyZfv75Z3322WeKiIgo9OsQGBgoSapYsaLlzzmee+45y58zMzPVpEkThYaG6rPPPlOPHj0UHx+vmJgYPf/882rVqpUkqVGjRlZzvP7666pXr56ioqJkY2MjSapTp446duyoPXv2WF7Xvzt27JjMZrPlPt2u7777TpmZmXne54K4ubmpUqVKOnjwoNq3b39HNQAAAAAAAAAAAAAAAAAAihYrid5ERkaGtm3bpubNm8vV1VWS1KlTJ127dk2ff/75TccfPnxYffv2Vdu2bTVr1ixLg6h0Yxv7t956Sx06dJC/v7/q1q2riIgIZWRk6Ny5c7dUp62trVWDn5eXl5ycnHTx4kVJN1aqTE1NVfv27ZWRkWH5aty4sdLS0nTy5MmbZrRt29byZzs7O7Vp00YHDx60OsfHx8fSICpJtWrVknRjtU1J+v777+Xi4mJpEJUkk8mktm3b6ocffpAkVa1aVS4uLnrppZf0ySef5LuVee3atS0NopJUrVo1+fj45KqpcePGVo9r1qxpqUe689fhp59+0sCBAxUSEiJfX18FBAQoNTVVv//+uySpVKlSqly5subOnasPP/zQKluSrl27ph9//FHt27dXZmam5bWpXr26KlasqMOHD+ebHRsbK0lW9/x27Nq1S6GhoXJycrrlsR4eHpY6AAAAAAAAAAAAAAAAAAD3D1YSvYl9+/YpPj5eLVu2tGx3XqdOHZUtW1ZbtmzRY489VuD4//3vf7p27Zq6detmWSEyx+rVqzVr1iwNGTJEISEhcnNz0+HDh/Xyyy8rPT39lup0cnKSg4OD1TGTyWSZJ2fb+S5duuQ5/s8//yxwfpPJJHd3d6tjZcqUydUc6ObmlmucJEsdSUlJKlOmTK75PT09lZiYKElyd3fXqlWrtHDhQk2cOFGZmZlq0KCBpkyZYrViZl7zFLamv25Jfyevwx9//KFBgwapXr16mjZtmsqVKyeTyaRhw4ZZxtrY2GjFihWaN2+eXn75ZaWmpqpu3bqaPHmyGjZsqKSkJGVmZmrGjBmaMWNGroyCXpucjL+/9jnNyFlZWbnGZGZmWu5Djt27d2vw4MEFXmt+HBwcbvn9CgAAAAAAAAAAAAAAABQb2bl7dID7BU2iN7F582ZJ0uTJkzV58mSr565cuaK4uLg8mxVzDB48WEeOHNGQIUO0Zs0aqybHbdu2qVWrVpowYYLl2KlTp4r4Cm7IafCMiopShQoVcj3v5eVV4Hiz2azExESrRtG4uDiVLVv2luuIi4vLdfzy5ctWc/v7++vNN99UWlqa9u/fr1mzZmnkyJHasWOHVf7fxcXFycfH55ZqupPXYe/evUpNTVVUVJSlGTUjI8PS8JqjRo0aWrhwocxmsw4cOKC5c+dq+PDh+vLLL+Xq6iobGxsNGzZMbdq0yZVRqlSpfPNz7llSUpLVa5Gzsujly5fl6elpNebSpUuytbWVh4eH5VrPnj2rli1bFuqa/y45OVm1a9e+rbEAAAAAAAAAAAAAAAAAgLuH7eYLcO3aNe3cuVNt2rTRmjVrrL7mzp2rjIwMffLJJwXOYWdnp9dff11BQUEaOHCgTp8+bXkuLS3NajVH6f+aUotaUFCQSpQooQsXLsjPzy/XV0GNiDk+//xzy58zMzO1Y8cOBQQE3FIdwcHBSklJ0VdffWU5lpGRoR07dig4ODjX+U5OTmrevLl69eqlmJgYqxUrT548qTNnzlgenzlzRsePH7/lmgr7Ovx1Zda/jrWxsZG9/f/1W3/66afKyMjIM8tkMumhhx7Sk08+qZSUFF26dEnOzs4KDAzU6dOn83xtCmrgrVGjhiQpJibG6nhAQIAcHBysmmpz7NixQ/7+/nJ0dJR0Y6t5X19flS9fPt+c/GRlZemPP/6w1AEAAAAAAAAAAAAAAAAAuH+wkmgBdu7cqdTUVPXt21chISG5nn/zzTe1ZcsW9e3bt8B5TCaTFi5cqOHDh2vAgAFav369qlSposaNG2vNmjVat26dqlevro8//tiq6bEoubm5acyYMZo9e7YuXLighx56SHZ2djp37px27typyMhIlShRosBrWLJkidLT0+Xl5aW3335bFy5c0KJFi26pjhYtWsjf31/PPPOMJkyYIE9PT61du1aXLl3SwoULJd3Y+vz9999XmzZtVKlSJV2+fFnr1q1T/fr1LY2N0o2t5YcPH64xY8ZIkhYsWKDy5cura9eut1RTYV+HBx54QDt37lSDBg1UokQJ1ahRQ40aNZJ0Y6XZnj176uTJk1q1apXVFvfHjx/XrFmz1KFDB1WpUkUpKSlaunSpKleurKpVq0qSJk6cqP79+2vcuHF65JFH5ObmpgsXLujrr79W165d83z/SVKVKlVUtmxZHT16VM2bN7ccd3Nz06BBg7R48WKlpqaqUaNGSk9P10cffaRvv/1Wy5Yts5y7a9cutWjRIs/5z549q23btlkds7W1VXh4uCTpt99+U2pqqho0aFCIOw0AAAAAAAAAAAAAAAAAuJdoEi3Ali1bVKlSpXwb9B577DH997//1dmzZ286l4ODgxYtWqShQ4eqf//+Wr9+vUaOHKkrV65YmiPbtWunKVOmaPjw4UV6HTkGDRqk8uXLa9WqVVq3bp3s7e1VtWpVtWjRItdKmn9nMpk0d+5cTZs2Tb/88ou8vLy0cOHCW97a3c7OTsuWLdNrr72m2bNnKzU1VXXr1tXKlStVr149SVLVqlVla2ur+fPnKy4uTh4eHgoLC9P48eOt5qpbt67Cw8M1e/ZsxcbGKiAgQNOmTZODg8Mt1VTY1+HFF1/Uf//7Xw0dOlRpaWlas2aNQkJCNGPGDEVFRWnYsGF68MEHtWDBAo0bN84yrmzZsvL09NTSpUt18eJFubq6qkGDBpo9e7bs7OwkSfXr19eGDRsUGRmpyZMny2w2q0KFCmrUqJGqVatWYP3t27fXl19+qREjRlgdHzdunMqWLavo6GitXbtW9vb2qlu3rpYvX66wsDBJUmJiog4cOKBnn302z7n37t2rvXv3Wh2zs7PTzz//LEn68ssvVblyZfn5+d3kLgMAAAAAAAAAAAAAAAAA7jWb7OzsbKOLwP0tMjJSK1eu1IEDB4wuxaJv375ydnbW0qVLjS7FcMePH1eXLl20Y8cOVa5c+ZbGbt68WTNnztRXX30lGxubW85+/PHH1bJlS40aNeqWx+bYezrutsfeqRCPdMOyk00ehuS66LohuZJkk5VhSG6ijbMhuZJU+o8fDMk96xloSK4kVba/Zli2UbJN+a/EfbeZbYz59z6mLAN/lmQY9LM7w7hrlq2tMbFpyYbkSlK23a39o58icxufh4rKZYeyhuRevGo2JFeSHnTNMizbJtugbIM+D0nSGXNJQ3LLOtsZkivptv6OUxScZNzrfDHdmGuufOF7Q3IlycbRuM/739rXMiQ31ZxpSK4kNU87ZEjuybINDcmVJDuDfpakZRr3e/KFrccMyd00pJEhuQAAAAAAAEUh448TRpcASfaVvI0u4b5kzP/jDKDI+Pj4qFWrVlqzZs0tj+3UqZP27dt3W//n6Xfffadz586pX79+tzwWAAAAAAAAAAAAAAAAAHD30SQKFAPPPPOMypUrd08zU1JSNGvWLLm5ud3TXAAAAAAAAAAAAAAAAABA4RizRyn+UUaPHq3Ro0cbXYaVtWvXGl3CfaV69eoaPHjwPc1s2bLlPc0DAAAAAAAAAAAAAAAA7kvZWUZXAOSLlUQBAAAAAAAAAAAAAAAAAACKIZpEAQAAAAAAAAAAAAAAAAAAiiGaRAEAAAAAAAAAAAAAAAAAAIohmkQBAAAAAAAAAAAAAAAAAACKIZpEAQAAAAAAAAAAAAAAAAAAiiGaRAEAAAAAAAAAAAAAAAAAAIohm+zs7GyjiwDw73Up8aph2aXSLhmWne1Y0pDcLAdjciXpj9QsQ3I9HO0MyZUkl4wkQ3KzTSUMyZWkazIZkuuckWJIriRdM7kalu2UlW5IbnymMa+zJJXJSjQkN9vRuNdZWZmGxNqmXjEkV5KuOJUzJNfFwbjfGabkC8YEG/T+kqRse0fDsrOcSxmSm21r4HvsyjlDcrMM/FyS7ehiTK6dcb8nbbIyjAk28D8t2WSkGZZ9Is2Y93cVVwPfYzY2huSWSDfuc0m2ydmYXAN/T6Yb89d32Rrz9pIkuTob9/sKAAAAAAAUDxnnjxldAiTZV37Q6BLuS/ZGFwAAAAAAAAAAAAAAAAAAwD9WtkH/8hYoBLabBwAAAAAAAAAAAAAAAAAAKIZoEgUAAAAAAAAAAAAAAAAAACiGaBIFAAAAAAAAAAAAAAAAAAAohmgSBQAAAAAAAAAAAAAAAAAAKIZoEgUAAAAAAAAAAAAAAAAAACiGaBIFAAAAAAAAAAAAAAAAAAAohmgS/Zfx9va+6dfGjRsLnGP//v164403bis/JiZG3t7e2rZtW4HntWrVylKPr6+vWrduralTpyo+Pv62cv9ux44dWr9+/W2NLew1FKVZs2ZpzJgxtz0+Ojpabdq0yff5pKSkXK993759NWzYsHzHfPzxx3r44YeVmZl523UBAAAAAAAAAAAAAAAA/3Q22Vl83QdfyJu90QXg3oqOjrZ63KNHD/Xt21cdO3a0HKtatWqBc3z77bdauXKlhg8ffldqzNGuXTsNGjRIGRkZ+umnnxQVFaVffvlF69evl63tnfU379ixQ0eOHFHv3r1veWy5cuUUHR2t6tWr31ENhXXx4kVt2LDhtptaJWnXrl1q0aJF0RUl6ZFHHtGCBQu0adMmPf7440U6NwAAAAAAAAAAAAAAAADgztEk+i8TGBiY61jFihXzPG40T09PS10NGjRQenq6Fi5cqKNHj8rPzy/X+WlpaXJycrrrdTk4ONzT+xUdHa1q1aqpXr16tzU+PT1d33zzjRYtWlSkddnZ2alLly5au3YtTaIAAAAAAAAAAAAAAAAAcB9iu3lYycrK0uLFi9WqVSvVq1dP7du31zvvvGN5PjIyUlFRUUpNTbVsB9+3b19J0qlTp/T000+refPmCggIUIcOHbRy5UplZRXNUr45TZIxMTGSJG9vby1btkyzZ89WkyZNFBoaKulGU+SMGTMUFhYmPz8/de7cWZ9//rllnkmTJunDDz/UyZMnLdcwadIky/MHDhxQv379FBgYqODgYE2YMEFxcXGW5/Pabr5Vq1Z6+eWXtX79erVs2VLBwcEaMWKE4uPjLeeYzWbNmjVLLVq0UL169RQWFqbhw4crOTm5wOvetGmT2rVrl+v4559/rnbt2snPz09PPPGEjh49qgYNGigyMtLqvP/973+ytbVVw4YNLcfeffddtWrVSgEBAerfv7/OnDlTYA35efjhh3Xs2DEdP378tsYDAAAAAAAAAAAAAAAAAO4eVhKFlddee01r1qzRU089paCgIO3evVtTp05VRkaG+vTpo+7du+vChQvasmWLVq9eLUlycXGRJF26dEk1atRQp06dVLJkSR07dkyRkZFKTU3VqFGj7ri2nObQcuXKWY6tWbNGAQEBevXVV5WRkSFJioiI0N69ezVu3Dg98MAD+uijjzR69GgtWrRIrVu3tjRvnj59WnPmzJEklS5dWtKNBtG+ffuqefPmmjdvnq5du6b58+drxIgRio6OLrC+L774QmfOnNGLL76oK1euaMaMGZo+fbrmzZsnSVq6dKneeecdRUREqHbt2rpy5Yr27dun69ev5zvnmTNndP78edWvX9/q+M8//6yxY8eqZcuWeu6553T+/Hk9/fTTec71xRdfKCwsTA4ODpJubD3/wgsvqGvXrurQoYOOHj2qsWPHFnht+alZs6bc3d21b98++fj43NYcAAAAAAAAAAAAAAAAAIC7gyZRWMTHx2vdunUaPHiwRo8eLUkKCwvTlStXtGjRIvXq1UsVKlRQhQoVZGtrm2vL9dDQUMtqntnZ2QoODlZaWprWrVt3W02i2dnZysjIUEZGhg4ePKg33nhDVapUUd26dS3nuLu7KyoqSjY2NpKk48ePa/v27Zo2bZp69uwpSWrWrJnOnz9vaRKtWrWqSpcurT/++CPXNbz++uuqV6+e1Zx16tRRx44dtWfPHjVv3rzAepcsWWJpxjx//ryWLl2qrKws2dra6vDhwwoLC1Pv3r0tY/JaIfSvDh8+LOnGqql/tXTpUnl5eSkyMlK2tjcWBC5ZsqQmTpyYa449e/ZYNYEuWbJEDRo00IwZMyRJTZs2VXp6uhYvXlxgLfnx9vbWwYMHb2ssAAAAAAAAAAAAAAAAAODuYbt5WBw6dEhms1nt27e3Ov7www8rPj5ev//+e4Hj09PTtXDhQrVt21Z+fn6qW7eu5s2bp9jYWF29evWW69mwYYPq1q2rgIAA9evXT+XLl1dkZKScnJws5zRr1szSzClJP/zwgyTleQ0///yzUlNT8827du2afvzxR7Vv316ZmZmWBtXq1aurYsWKlobN/DRs2NDSICrdWGXTbDZbtqr39fXVnj17FBkZqUOHDikrK+um9yA2Nla2trYqVaqU1fHDhw+rRYsWlgZRSWrdunWu8ceOHdOlS5fUokULSVJmZqaOHj2qtm3bWp13s2bVgpQqVUqxsbG3PR4AAAAAAAAAAAAAAAAAcHewkigsEhMTJUmenp5Wx3MeJyQkFDh+9uzZeu+99zRy5EjVq1dPrq6u2rlzp5YsWaL09HSVLFnylup5+OGHNXjwYJlMJlWoUEEeHh65zilTpkyuazCZTLnO9fT0VHZ2tpKTk+Xs7JxnXlJSkjIzMzVjxgzLKpt/9eeffxZYr5ubm9XjnIbR9PR0SdJTTz0lW1tbffjhh4qKilLp0qXVu3dvjRw50qrR9a/S09Nlb2+f6/nY2FiVLl3a6piLi4scHR2tjn3xxRfy9/e3nBsfH6+MjIxcY//+mt8Kk8lkuUYAAAAAAAAAAAAAAAAAwP2DJlFY5DRWxsXFqXz58pbjly9ftno+P9u2bVOPHj305JNPWo7t2bPntuspXbq0/Pz8Cjzn782T7u7uMpvNSkxMlLu7u+X45cuXZWNjI1dX13zncnV1lY2NjYYNG6Y2bdrkev7vq3neKgcHB40ePVqjR4/WmTNn9MEHHygyMlJeXl567LHH8hzj7u6u69evKz093aoBtGzZsoqPj7c6NyUlJVez5u7du9WqVSvL49KlS8ve3j7X2JzX+HYkJyff9L0BAAAAAAAAAAAAAAAAFFuF2FEYMArbzcPCz89PJpNJ27Ztszr+6aefqkyZMqpevbqkGytHXr9+Pdf49PR0mUwmy+PMzExt3br1rtb8d8HBwZKU6xq2bdsmX19fyyqiea1+6ezsrMDAQJ0+fVp+fn65vry8vIqszmrVqmn8+PHy8PDQ6dOn8z2vRo0akqSYmBir435+ftq9e7fVlvU7duywOufy5cs6fPiwWrZsaTlmZ2cnX19fff7551bnfvbZZ7d9LefPn7fUCQAAAAAAAAAAAAAAAAC4f7CSKCxKly6tPn36aMWKFXJwcFBgYKD27NmjLVu26IUXXpCdnZ0kqWbNmsrIyNDq1asVFBQkFxcXPfDAA2rcuLHee+891apVS6VKldKGDRvybCa9m3x8fBQeHq6ZM2cqLS1NNWrU0Mcff6wDBw5o8eLFlvNq1qypDz74QFu2bFG1atVUqlQpeXl5aeLEierfv7/GjRunRx55RG5ubrpw4YK+/vprde3aVSEhIbdd24gRI1S3bl35+vqqRIkS2rVrlxITE9WoUaN8x/j7+8ve3l5HjhxRzZo1LceHDRumbt26afTo0XriiSf0xx9/aOXKlXJ0dLSsrrp7925VrFhRPj4+VnMOHz5cI0aM0OTJk9WhQwcdPXpUH330UZ75sbGxuRpuJalFixZycnJSamqqTp8+rZEjR97OLQEAAAAAAAAAAAAAAAAA3EU0icLKxIkT5erqqvfff19vvPGGKleurGnTpqlnz56Wc1q2bKn//Oc/WrZsmeLi4tSwYUOtXbtWL7zwgqZOnarp06erRIkS6tKli9q2baspU6bc02uYPXu25s6dq+XLlyshIUEPPPCAFi5caLXterdu3XTo0CFNnz5dCQkJ6tKli2bOnKn69etrw4YNioyM1OTJk2U2m1WhQgU1atRI1apVu6O66tevr08//VSrVq1SZmamatSooTlz5qhx48b5jnF2dlbTpk315ZdfqnPnzpbjvr6+mj9/vl5//XWNGjVKtWvX1syZM9WvXz+5urpKutEk2rx581xztm7dWtOmTdMbb7yhrVu3KiAgQPPnz1f37t1znXv06FGNHTs21/E9e/aoQoUK+uqrr+Tk5KRmzZrdzi0BAAAAAAAAAAAAAAAAANxFNtnZ2dlGFwEgf1988YUmTJigr7/+WiVKlMj3vP/9738aMGCA1q5dq8DAQIWEhGj+/Pl5NooWlTFjxqhkyZKaMWPGbc9xKfFqEVZ0a0qlXTIsO9uxpCG5WQ7G5ErSH6lZhuR6ONoZkitJLhlJhuRmm/L/WXG3XZPJkFznjBRDciXpmsnVsGynrHRDcuMzjXmdJalMVqIhudmOxr3Oyso0JNY29YohuZJ0xamcIbkuDsb9zjAlXzAm2KD3lyRl2zsalp3lXMqQ3GxbA99jV84Zkptl4OeSbEcXY3LtjPs9aZOVYUywgf9pySYjzbDsE2nGvL+ruBr4Hvv/u5fcayXSjftckm1yNibXwN+T6cb89V22xry9JEmuzsb9vgIAAAAAAMVD5pmDRpcASXbVAowu4b7ESqLAfa5ly5aqUaOG3nvvPfXr189y/KWXXlJoaKg8PDz066+/avHixfL19VWDBg1ka2urAwcO3NW6zp07pz179mjz5s13NQcAAAAAAAAAAAAAAAAAcHtoEgXuczY2NnrppZd04sQJq+NJSUmaPn26EhIS5OLioqZNm+rZZ5+Vra3tPanr4sWLevnll1W1atV7kgcAAAAAAAAAAAAAAAAAuDU0iQL/AP7+/vL397c6NnfuXIOquaFBgwZq0KCBoTUAAAAAAAAAAAAAAAAAAPJHkygAAAAAAAAAAAAAAAAAALcrO9voCoB83Zt9qQEAAAAAAAAAAAAAAAAAAHBP0SQKAAAAAAAAAAAAAAAAAABQDNEkCgAAAAAAAAAAAAAAAAAAUAzRJAoAAAAAAAAAAAAAAAAAAFAM0SQKAAAAAAAAAAAAAAAAAABQDNEkCgAAAAAAAAAAAAAAAAAAUAzZG10AgH83d1uzYdlZLp6GZV++bkyPfnxihiG5kuTtbMxr/etVB0NyJekBd3dDcs8lG/c6V7NPMCQ329HVkFxJKpF+xbBso6RlGXe/l51MNyT3yQcN/NicZcz3dIZ7RUNyJcnjWoIhudlm435n2KYnG5KbUaqqIbmSlG1r3PeVTaYxn0uybOwMyZWkC47GfE9nZhsSK0lyNejfxZbMSDMk998q26GkYdl1DPq1kZRpTK4kudkZ87nkyziTIbmSFFTBmBc6y2zcD1A7G2Nyrxv4O8Mx8bIhuQ7uxv23KQAAAAAAUMSys4yuAMgXK4kCAAAAAAAAAAAAAAAAAAAUQzSJAgAAAAAAAAAAAAAAAAAAFEM0iQIAAAAAAAAAAAAAAAAAABRDNIkCAAAAAAAAAAAAAAAAAAAUQzSJAgAAAAAAAAAAAAAAAAAAFEM0iQIAAAAAAAAAAAAAAAAAABRDNIkCAAAAAAAAAAAAAAAAAAAUQzSJokA7d+7UoEGD9NBDD6levXpq1aqVXnzxRf3222/3rIakpCRFRkbq119/tToeExMjb29vbdu27Zbm279/v7y9vXX48OGiLPOmTpw4oaCgIMXHx9/TXEn67bff5O3trT/++CPfczp37qxJkyZZHkdGRiooKCjf82NiYhQYGKiYmJgirRUAAAAAAAAAAAAAAAD4J7HJzuLrPvhC3mgSRb7mzJmjESNGyMXFRdOnT9eqVas0cuRI/frrr3r66afvWR1JSUmKiorK1SRarlw5RUdHq1GjRrc0X926dRUdHa2aNWsWZZk3NX/+fHXt2lWlS5e+p7mStGvXLnl7e6tSpUpFNqeXl5fatWunyMjIIpsTAAAAAAAAAAAAAAAAAFB07I0uAPenPXv2aPny5RoxYoTGjh1rOd6wYUM9/vjj2rVrV75j09LS5OTkdNdrdHBwUGBg4C2Pc3Fxua1xd+LcuXPatWuXNm7ceE9zc+zatUstW7Ys8nm7deumgQMH6tlnnzWk+RUAAAAAAAAAAAAAAAAAkD9WEkWeVq5cKU9PT40YMSLP5//acOjt7a1ly5Zp9uzZatKkiUJDQyVJ2dnZWrFihdq1a6d69eqpdevWeuutt6zmOXXqlJ5++mk1b95cAQEB6tChg1auXKmsrBvL/8bExKh169aSpLFjx8rb21ve3t6KiYnJc7v5Vq1a6eWXX9b69evVsmVLBQcHa8SIEVZbvOe13by3t7eWL1+uyMhINW7cWCEhIZo8ebJSU1Ot6r1w4YIiIiIUEhIif39/9e7dW0eOHLnp/dy0aZOqVKkiX19fy7Gc+jdt2qQXX3xRDRo0UGhoqFatWiVJ2rp1q9q1a6f69etr1KhRSkpKsprz5MmT6t27t/z8/BQeHq6PP/5YI0aMUN++fa3OS0pK0o8//mj1mv3444/q2rWr/Pz81LFjR+3Zs+em15CX4OBgeXh4aPPmzbc1HgAAAAAAAAAAAAAAAABw97CSKHLJyMjQjz/+qPDwcJlMpkKNWbNmjQICAvTqq68qIyNDkvTqq6/qvffe0/DhwxUQEKAff/xRc+bMkaOjo3r16iVJunTpkmrUqKFOnTqpZMmSOnbsmCIjI5WamqpRo0apXLlyioqK0qhRozR+/HiFhIRIurHV/KVLl/Ks5YsvvtCZM2f04osv6sqVK5oxY4amT5+uefPmFXgN69evV3BwsGbOnKnff/9dr732msqUKaOIiAhJUmJiov7zn//I2dlZL7zwglxdXbV27Vr1799f27dvV5kyZfKd++uvv1ZQUFCez82fP1/h4eFasGCBduzYoZkzZyo+Pl7ffvutnnnmGaWkpOiVV17R7NmzNX36dEk3VmsdNGiQ3NzcNHv2bEnSokWLlJSUpKpVq1rNv3fvXrm7u8vf31+SFBsbq8GDB8vb21vz589XUlKSpk2bptTUVD344IMF3qO/s7W1VUBAgL7++mv179//lsYCAAAAAAAAAAAAAAAAAO4umkSRS0JCgq5fv65KlSoVeoy7u7uioqJkY2MjSTp79qzWrVunadOmqUePHpKkxo0bKy0tTYsWLVKPHj1ka2ur0NBQq5VHg4ODlZaWpnXr1mnUqFFycHCwNC5Wq1atUNvEZ2dna8mSJXJwcJAknT9/XkuXLlVWVpZsbfNfPLds2bJ6/fXXJUnNmjXTzz//rM8++8zSJLp69WolJSXpvffeszSEhoaGql27dlqxYoUmTpyYbz1HjhxRmzZt8nw+MDBQzz33nCSpUaNG2r59u9atW6cvvvhCpUqVkiSdOHFC77//vqVJ9IMPPlBcXJzefvtteXl5SZLq1aun8PDwXE2iu3btUrNmzSzXvnr1atnY2Gj58uVydXWVJFWoUEEDBgwo4K7mz8fHR+vXr7+tsQAAAAAAAAAAAAAAAACAu4ft5pGvnIbPwmjWrJnV+V9//bUkKTw8XBkZGZavxo0bKzY2Vn/++ackKT09XQsXLlTbtm3l5+enunXrat68eYqNjdXVq1dvq+6GDRtaGkQlqWbNmjKbzYqLiytwXOPGja0e16xZUxcuXLA83rdvn0JCQuTu7m65HltbWzVs2NBq6/q/S0xM1PXr11W6dOk8n2/SpInlz3Z2dqpSpYp8fHwsDaKSVL16dSUlJVnuyZEjR1SnTh1Lg6gkeXl5ycfHx2ruzMxM7d2712qr+YMHDyokJMTSICrdaHb18PDI9xoKUqpUKV25ckVms/m2xgMAAAAAAAAAAAAAAAAA7g5WEkUuHh4ecnR01B9//FHoMX/fav3KlSvKzs5Wo0aN8jz/zz//VOXKlTV79my99957GjlypOrVqydXV1ft3LlTS5YsUXp6ukqWLHnL9bu5uVk9zmkYTU9Pv6VxJpNJ169ft7qmn376SXXr1s019u+rd/5VTu5fG1f/6q/Nmjm5zs7OuY7lzFWyZEldunQpz6bT0qVLW13ngQMHdPXqVatG1NjYWFWrVi3Psbfjr/c3p04AAAAAAAAAAAAAAAAAgPFoEkUu9vb2ql+/vr755htlZGTI3v7mb5O/rzrq7u4uGxsbbdiwIc/GwRo1akiStm3bph49eujJJ5+0PLdnz547vIK7w93dXU2bNtXYsWNzPZdfA6gkywqdSUlJRVZLuXLldOzYsVzH4+PjrRprd+3apYYNG8rFxcVyrGzZsnmuqhofH39btSQlJclkMlllAAAAAAAAAAAAAAAAAP8a2VlGVwDki+3mkaeBAwcqNjZWb7zxRp7P36yRMzQ0VJKUkJAgPz+/XF85DYV/X30yMzNTW7dutZrrr6toGqlx48Y6deqUatasmet6vL298x3n6OioSpUqKSYmpshqqVevnk6cOKFz585ZjsXExOj48eNW5+3evdtqq3lJ8vf31/79+5WcnGw59r///U8JCQm3Vcv58+ctTb8AAAAAAAAAAAAAAAAAgPsHK4kiT82bN9eQIUMUGRmpX3/9VY888ohKlSqlmJgYffDBB0pOTlbz5s3zHV+jRg317t1bEydO1ODBgxUQECCz2azff/9d+/fv1+LFiyXdaLx87733VKtWLZUqVUobNmyw2uJdurHypZubm7Zu3SovLy85ODgU2JR5twwYMECbN29Wnz591K9fP1WqVEnx8fE6ePCgypcvrwEDBuQ7tn79+jp69GiR1fL444/rjTfe0PDhwzV69GhJUlRUlDw9PS2rup47d06//vprribR/v37a8OGDRo6dKiGDh2qpKQkRUZGWlY8/avMzExt27Yt13F/f39VqlRJknTkyBEFBwcX2bUBAAAAAAAAAAAAAAAAAIoGTaLI1zPPPKOgoCCtX79ezz33nK5du6Zy5copLCxMgwcPvun4KVOmqEaNGoqOjtaiRYtUsmRJ1ahRQ+3bt7ec88ILL2jq1KmaPn26SpQooS5duqht27aaMmWK5RxbW1vNmDFDc+fO1YABA3T9+nXt3LnzrlxzQUqVKqXo6GjNnz9fc+bMUUJCgsqUKaOAgAC1bdu2wLHt2rVTRESEUlJSimRbdicnJ61cuVJTp05VRESEypcvrxEjRmjTpk1ydXWVdGOr+Zo1a6pKlSpWY8uVK6fly5frlVde0dixY1W1alW9+OKLmjdvXq6c9PR0jR07Ntfx1157TZ07d1ZcXJyOHj2q8ePH3/E1AQAAAAAAAAAAAAAAAACKlk12dna20UUAxZ3ZbFbLli0VERGhxx577K5kJCQkqE2bNhowYIBGjRqlQYMGycfHRxMnTrwreZK0fv16vfXWW9q+fbtlBdNblZ6cULRF3QpbO8OiL1+3NSQ3Pi3DkFxJ8nY2G5L76zUHQ3Il6QF3kyG555KNe52r2Scbkpvt6GpIriTZpBtzzUY6n2Xc/d568rIhuU8+WNKQXElSljHf05nOpQ3JlSS7awmG5GbbGfc7wz7xvCG5GaWqGpIrSdm2xv2bRZtMYz6XZNo7GZIrSfHXDPpZYuB/cXB1MOYzd8nsNENy/7XsjPnMbaSkTOP+Lutml2lI7t4/jPu+CqpgzOfALAN/ftrd3n/iuWNG/s5wz041JNfB3dOQXAAAAAAAUPSyTn1rdAmQZFvzIaNLuC+xkihwD5hMJg0dOlRr1qwpsibRZcuWydPTU5UrV1ZsbKxWrlypzMxMPf7445KklStXFklOfrKysrRmzRqNHDnythtEAQAAAAAAAAAAAAAAAAB3D02iwD3Sq1cvpaSkKD4+XqVL3/nKXLa2tlqyZIkuXrwoOzs7BQQEaPXq1apYsWIRVHtzly5dUpcuXfToo4/ekzwAAAAAAAAAAAAAAAAAwK2hSRS4RxwcHDRy5Mgim2/IkCEaMmRIkc13qypUqKDhw4cblg8AAAAAAAAAAAAAAADcF7KzjK4AyJet0QUAAAAAAAAAAAAAAAAAAACg6NEkCgAAAAAAAAAAAAAAAAAAUAzRJAoAAAAAAAAAAAAAAAAAAFAM0SQKAAAAAAAAAAAAAAAAAABQDNEkCgAAAAAAAAAAAAAAAAAAUAzRJAoAAAAAAAAAAAAAAAAAAFAM2RtdAIB/t8sZJsOy3R2N65NPz8wwJNfblGxIriRl27sbklvFzbhfdRdTMw3JTUgz5v0lSdWcswzJtclINyRXkrKcjHlvS5Ip7rQhuaVKeRiSK0lD65UyJPd8up0huZLk7mhMtmvyJUNyJSnTpawhuVfSjfkZJkk2bg8Ykrtk3zlDciWpV2Alw7JL2Bvz+aBiVoohuZLkYFfCkFw34z7uKy4925BcF103JFeSYuVqSK6nvdmQXEnKtjHu73UZBv3b64ws435f2SXHGJJbs5SXIbmSZM4y5meJydbGkFxJunDVmL9TZhtzqyVJJT1cDMlNSLxqSK4klXMvaVg2AAAAAAAA7i2aRAEAAAAAAAAAAAAAAAAAuF1ZxiwiBRQG280DAAAAAAAAAAAAAAAAAAAUQzSJAgAAAAAAAAAAAAAAAAAAFEM0iQIAAAAAAAAAAAAAAAAAABRDNIkCAAAAAAAAAAAAAAAAAAAUQzSJAgAAAAAAAAAAAAAAAAAAFEM0iQIAAAAAAAAAAAAAAAAAABRDNIlCkZGR8vb2Vu/evXM99+qrr6pVq1b3tJ6+fftq2LBh9zTzVly/fl2TJ09Wo0aN5O3trbfeeivP8+7Vfd2xY4e8vb0VExNzS+MiIyMVFBRUJDUAAAAAAAAAAAAAAAAAAO4/9kYXgPvH999/r/379yskJMToUu5rH330kT766CPNnDlTVatWVeXKlQs8n/sKAAAAAAAAAAAAAAAAFF/ZWVlGlwDki5VEIUlydnaWv7+/Fi9ebHQpd11aWtodjT99+rTKlSunRx99VIGBgSpbtmy+5/6b7isAAAAAAAAAAAAAAAAA4P5CkygsRowYoW+++UY//vhjvuds3LhR3t7eio+PtzreuXNnTZo0yfJ40qRJ6tixo77++mt16tRJ/v7+6tOnj2JiYpSQkKCxY8eqfv36atOmjT755JM8szZt2qQ2bdrI399fffv21enTp62ez87O1ooVK9SuXTvVq1dPrVu3zrX1e86W6ocOHVKPHj3k5+en9evX53t958+f15gxYxQcHKzAwEANHjxYJ06csDzfqlUrrVy5Un/++ae8vb0Ltc17Ye5rYbIlyWw269VXX9VDDz2k4OBgPffcc7p69arVOfv375e3t7cOHz6cq46+ffsWWENSUpJeeuklhYWFqV69euratau++uorq3N++OEH9e7dW8HBwQoKClKnTp304YcfFjgvAAAAAAAAAAAAAAAAAODeY7t5WLRs2VK+vr5atGiRVqxYccfzxcbGaubMmXrqqadkb2+vV155RRERESpRooQaNGigJ554Qu+++66eeeYZBQQEWG3bfvToUZ09e1YTJkyQJM2fP19DhgzRtm3b5ODgIEl69dVX9d5772n48OEKCAjQjz/+qDlz5sjR0VG9evWyzGU2mzVhwgQNGDBATz/9tDw8PPKsNyUlRX379pWtra2mTZsmR0dHLVmyRH369NHHH3+sihUrKioqSsuXL9d3332nqKgoSVK5cuUKvA+Fua+FyZakuXPn6u2339bo0aPl6+urrVu36vXXXy/cC3IT169f18CBAxUXF6dx48apfPny+vjjjzVs2DBLc3BKSoqGDRum4OBgzZ07Vw4ODvr111+VlJRUJDUAAAAAAAAAAAAAAAAAAIoOTaKw8tRTT2n06NE6dOiQ/P3972iuxMRErVu3TrVr15YkXbp0SdOnT9fQoUM1cuRISZKfn58+//xz7dixQ/3797eMjYuL07p161S9enVJkq+vr9q3b6+NGzeqZ8+eOnv2rNatW6dp06apR48ekqTGjRsrLS1NixYtUo8ePWRre2OhXLPZrKefflodOnQosN6NGzfqjz/+0NatW1WzZk1JUsOGDdWyZUutXr1akyZNkq+vrzw9PeXg4KDAwMBC34ub3dfCZCckJGjDhg0aOnSohg0bJklq2rSp+vTpo4sXLxa6lvxs3rxZx48f10cffaRatWpZ5j9z5owWL16sBQsW6LffflNycrLGjx8vb29vSVJoaOgdZwMAAAAAAAAAAAAAAAAAih7bzcNK27ZtVadOHS1atOiO5ypXrpylQVSSpeGzcePGlmNubm4qXbq0Lly4YDW2du3alvMlqVq1avLx8dHBgwclSV9//bUkKTw8XBkZGZavxo0bKzY2Vn/++afVfM2bN79pvd9//71q165tadKUJA8PDzVu3Fg//PBD4S46Hze7r4XJ/uWXX5SWlqa2bdtajQ0PD7+j2nLs27dPderUUfXq1XPd05yt66tWrSoXFxe99NJL+uSTTxQfH18k2QAAAAAAAAAAAAAAAACAosdKorBiY2Oj4cOHa/z48Tp69OgdzeXm5mb12GQySZJcXV2tjjs4OCg9Pd3qWJkyZXLNV6ZMGcXGxkqSrly5ouzsbDVq1CjP7D///NOyfX2JEiVUsmTJm9ablJQkT0/PPHNPnjx50/EFudl9LUx2zrX//d7kNe52XLlyRT///LPq1q2b6zk7OztJkru7u1atWqWFCxdq4sSJyszMVIMGDTRlyhTLyqIAAAAAAAAAAAAAAAAAgPsDTaLI5eGHH1ZkZKQWL16sSpUqWT3n6Ogo6cYW7n+VlJRUpDXExcXleczHx0fSjWZFGxsbbdiwwdJ8+lc1atSw/NnGxqZQme7u7vrtt9/yzHV3dy9s6fkq6L4WJrts2bKWY+XLl7ecc/nyZasxBb1GBd0Ld3d3eXt769VXXy3wOvz9/fXmm28qLS1N+/fv16xZszRy5Ejt2LGjwHEAAAAAAAAAAAAAAABAsZSVaXQFQL7Ybh652Nraavjw4dq5c6dOnDhh9VxOc+Lp06ctx06dOpVre/c7dfLkSZ05c8by+MyZMzp+/LgCAgIkSaGhoZKkhIQE+fn55fpycXG55czg4GD98ssvVteWmJior7/+WsHBwXd4RQXf18Jk16lTR05OTvr888+txm7fvt3qcYUKFSTdeF1yxMfH33Rl2MaNG+vcuXMqV65cnvf075ycnNS8eXP16tVLMTExuVaDBQAAAAAAAAAAAAAAAAAYi5VEkadOnTpp0aJF2r9/v2XbdkkKCAhQxYoV9d///lcTJkxQSkqKli1bJg8PjyLNL1OmjIYPH64xY8ZIkhYsWKDy5cura9eukm6sFNq7d29NnDhRgwcPVkBAgMxms37//Xft379fixcvvuXMrl276q233tKwYcM0btw4OTo6asmSJbK3t1f//v2L5Lryu6+Fyfbw8FDPnj21fPlyOTk5ydfXV1u3btXZs2etMipUqKCAgAAtWrRIrq6usre31/Lly+Xq6lpgbY899pjeeecd9evXT4MGDVL16tWVnJysn3/+WWazWRMmTNDu3bv1/vvvq02bNqpUqZIuX76sdevWqX79+pYVTAEAAAAAAAAAAAAAAAAA9weaRJEnOzs7Pfnkk5oyZYrVcZPJpKioKL300ksaO3asqlatqueee04zZ84s0vy6desqPDxcs2fPVmxsrAICAjRt2jQ5ODhYzpkyZYpq1Kih6OhoLVq0SCVLllSNGjXUvn3728p0cXHR2rVrNXPmTL3wwgvKyspS/fr1tW7dOlWsWLFIriu/+1rY7AkTJigzM1NvvvmmsrKy1LZtW02YMEETJ060mm/OnDmaMmWKJk+eLE9PT40bN05bt25VcnJyvrU5ODhozZo1ioyM1BtvvKHY2Fh5eHjI19dX//nPfyRJVatWla2trebPn6+4uDh5eHgoLCxM48ePL5L7AwAAAAAAAAAAAAAAAAAoOjbZ2dnZRhcB4N/r/JWrhmW7O9oaln0pNcOQXC8lGpIrSdkl3A3JvW5j3L+HiL+WaUjupatmQ3IlKcDZoO9pk5MxuZKyTCUMyzbFnTYkN7lUTUNyJalE9nVDcv9ItzMkV5LcHY3Jdk27bEiuJGW6lDUk90p6liG5kmRjY0zukm/OGRMsqVdgJcOyS9gb8zmwon2aIbmSlCBjfl+5mQyJlSTFpRuTW1b5/+O8uy1WBe8gcbd42hv3+TPbzrg3WYaM+VmSfN2431dlr569+Ul3wTlHL0NyJamEyZjX2WRr0IcDSRevGvPfLIz8r9Q1PBxuftJdkHLdmP9uIEnl3Esalg0AAAAAQHGU+fNuo0uAJDvfFkaXcF8yrkMKAAAAAAAAAAAAAAAAAAAAdw1NogAAAAAAAAAAAAAAAAAAAMUQTaIAAAAAAAAAAAAAAAAAAADFkL3RBQAAAAAAAAAAAAAAAAAA8I+VlWl0BUC+WEkUAAAAAAAAAAAAAAAAAACgGKJJFAAAAAAAAAAAAAAAAAAAoBiiSRQAAAAAAAAAAAAAAAAAAKAYokkUAAAAAAAAAAAAAAAAAACgGKJJFAAAAAAAAAAAAAAAAAAAoBiiSRQAAAAAAAAAAAAAAAAAAKAYsje6AAD/bueS0g3LrmB73rDsNFM1Q3IdKngZkitJ5gunDMl1dCxpSK4kVTi805DcNN9OhuRK0rUSZQzJtbMxJFaSZK8sw7IzSxpzv6+kZRqSK0kptsZ8fPV0tjMkV5Iup2YYkuv83VZDciXJrmxlQ3LLZJgNyZWkeN/2huRWK+NsSK4kVXVzMCzb8eJxQ3KvlfM2JFeSrl0z5me3h9IMyZWk8lcvGhNs0O8qSYpTCUNyy5mSDMmVJNu4M4Zlx5QJNCT3bKJx31c2Zasaklsl+XdDciUpy7aUMcHGfeTW72ZjPh8kphv3WayWmzF/qXRzMO53xm+Xkw3LruHpalg2AAAAAADAvxFNogAAAAAAAAAAAAAAAAAA3KbsTAP/1S9wE2w3DwAAAAAAAAAAAAAAAAAAUAzRJAoAAAAAAAAAAAAAAAAAAFAM0SQKAAAAAAAAAAAAAAAAAABQDNEkCgAAAAAAAAAAAAAAAAAAUAzRJAoAAAAAAAAAAAAAAAAAAFAM0SQKAAAAAAAAAAAAAAAAAABQDN03TaKRkZHy9vZW06ZNlZWVlev5nj17ytvbW5MmTbqleWNiYuTt7a1t27YVVamFNmLECPXt29fyODIyUkFBQfe8jju1f/9+eXt76/Dhw0aXkstrr72msLAw+fj46NVXXzWsjgYNGigyMvKWxtyN9+aYMWM0a9asIpuvID/88INCQkKUkpJyT/IAAAAAAAAAAAAAAACA+1JWFl/3wxfyZG90AX9lMpl05coVfffddwoJCbEcP3/+vH766Sc5Ozvf8pzlypVTdHS0qlevXoSV3p7u3burefPmRpdxy+rWravo6GjVrFnT6FKsfP3111qxYoUmT56sgIAAlStXzuiSDHX06FHt2rVLO3bsuCd5wcHBql27tlauXKkxY8bck0wAAAAAAAAAAAAAAAAAQOHdNyuJSjeaRJs1a6atW7daHd+6datq166tqlWr3vKcDg4OCgwMlIeHxx3Xl5aWdkfjK1SoIH9//zuu415zcXFRYGDgbTXp3k2nT5+WJPXr109BQUGqXLmywRUZa82aNQoLC1P58uXvWWa3bt309ttvy2w237NMAAAAAAAAAAAAAAAAADDaF198oUcffVR+fn5q166dPvjgg5uOOXTokCZPnqy2bdsqICBA4eHhev3115Wammp1Xs7O7H//evvtt2+5zvuqSVSSOnbsqM8++8yq6WzLli3q2LFjrnNPnTqlp59+Ws2bN1dAQIA6dOiglStXWm1Xn9eW3llZWVq8eLFatWqlevXqqX379nrnnXes5s7ZGv7QoUPq0aOH/Pz8tH79+nzrPnXqlPr06SM/Pz+1adNGH374Ya5z/r7dfM427nv37tXYsWMVFBSkFi1aaPPmzZJuNP21aNFCDz30kJ5//nldv37dar4LFy4oIiJCISEh8vf3V+/evXXkyBGrc1q1aqWXX35Z69evV8uWLRUcHKwRI0YoPj7eco7ZbNasWbPUokUL1atXT2FhYRo+fLiSk5Ot6vzrdvPp6emaMWOGwsLC5Ofnp86dO+vzzz+3yp40aZI6duyo/fv367HHHlNgYKC6deuWq8a8JCQkaPLkyZZr69mzp7777jvL83379tX06dMlSQ8++KC8vb21f//+POfKue8nTpxQr169FBAQoI4dO2rv3r1W5xXmfSFJO3bsUPv27eXn56du3brp0KFDuc7Jue9/H+ft7a2YmJgCr33jxo3q1KmT/Pz81LRpU82bN0+ZmZkFjklNTdX27dvVrl27XM8dOHBAgwYNUv369RUUFKTu3btr3759kv7v+2PTpk168cUX1aBBA4WGhmrVqlWSbjRot2vXTvXr19eoUaOUlJRkNXebNm2UnJysPXv2FFgfAAAAAAAAAAAAAAAAABQX33//vUaNGqXAwEAtX75cDz/8sJ5//nmrPsW8fPrppzpz5oyGDBmiZcuWqX///nr33Xc1fPjwXOc6OTkpOjra6is8PPyWa72vtpuXpJYtW+r555/Xvn371KJFC/366686ceKEFi1apE8++cTq3EuXLqlGjRrq1KmTSpYsqWPHjikyMlKpqakaNWpUvhmvvfaa1qxZo6eeekpBQUHavXu3pk6dqoyMDPXp08dyntls1oQJEzRgwAA9/fTT+a5Gmp6erkGDBqlEiRJ67bXXJEkLFy5USkpKoba5f+mll9SlSxc98cQTevfddzVx4kQdP35cJ0+e1LRp03Tu3DnNnDlTVapUsbwZEhMT9Z///EfOzs564YUX5OrqqrVr16p///7avn27ypQpY5n/iy++0JkzZ/Tiiy/qypUrmjFjhqZPn6558+ZJkpYuXap33nlHERERql27tq5cuaJ9+/blakr9q4iICO3du1fjxo3TAw88oI8++kijR4/WokWL1Lp1a8t5sbGxeuWVV/Tkk0/K1dVVr7/+ukaNGqXPP/9cJpMpz7kzMzM1dOhQnTt3ThEREfL09NTatWs1cOBAvfPOO6pXr56mTp2qd999V6tXr1Z0dLQkqVatWvnWazabFRERoX79+mnEiBFavny5xowZoy+++EKlSpWSVLj3xbFjxzRmzBg1a9ZMkydPVkxMjMaNG1fgvboVq1at0uzZs9W/f39NmjRJp06dsjSJRkRE5Dvup59+UmpqqoKDg62O//DDD+rfv78CAwP1yiuvyM3NTUeOHNEff/xhdd78+fMVHh6uBQsWaMeOHZo5c6bi4+P17bff6plnnlFKSopeeeUVzZ4929KcK91YZbZWrVr6+uuv1aZNmyK5BwAAAAAAAAAAAAAAAABwP1uyZIn8/f0tCwk2atRI586d08KFC9W+fft8xw0dOlSlS5e2PA4JCZGbm5siIiJ05MgR1atXz/Kcra2tAgMD77jW+65JtESJEmrVqpW2bt2qFi1aaMuWLQoKClKVKlVynRsaGqrQ0FBJUnZ2toKDg5WWlqZ169bl2yQaHx+vdevWafDgwRo9erQkKSwsTFeuXNGiRYvUq1cv2dnZSbrRWPj000+rQ4cOBda8ceNGXbp0SZ9++qmlKdTX11ft27cvVJNo+/btLfX6+/vr888/19atW60aKb/99ltt27bN0iS6evVqJSUl6b333rM0hIaGhqpdu3ZasWKFJk6caJk/OztbS5YskYODgyTp/PnzWrp0qbKysmRra6vDhw8rLCxMvXv3tozJa0XKHMePH9f27ds1bdo09ezZU5LUrFkznT9/PleTaGJiotatW6fatWtLuvH69uvXTwcPHlSDBg3ynH/37t06dOiQ3nzzTTVt2lTSjdcoPDxcS5cuVWRkpGrVqqVKlSpJUqG+EXKaRJs3by5JqlGjhlq3bq0vv/xSnTt3LvT7YtmyZapYsaIWLVpkeZ84Ojrq+eefv2kNN5OSkqKFCxdqyJAhGj9+vCSpSZMmMplMmjlzpgYPHmxpaP27w4cPy9nZOdf3yezZs1WtWjWtXr3aUm9YWFiu8YGBgXruueck3fiBtX37dq1bt86qifbEiRN6//33rZpEJcnHx0cHDx68s4sHAAAAAAAAAAAAAAAAgH+A69eva//+/bkW/evQoYO2bNmimJgYeXl55Tn2rw2iOXx9fSXdWDTzbrjvtpuXbmw5v3PnTqWlpemTTz7RI488kud56enpWrhwodq2bSs/Pz/VrVtX8+bNU2xsrK5evZrnmEOHDslsNufq1n344YcVHx+v33//3ep4TlNhQQ4dOqTatWtbNYRWq1ZNPj4+Nx0r3WgEzOHq6qrSpUurQYMGVittVq9eXX/++afl8b59+xQSEiJ3d3dlZGQoIyNDtra2atiwodW28JLUsGFDS4OoJNWsWVNms1lxcXGSbrzJ9uzZo8jISB06dEhZWVkF1vvDDz9IUp738Oeff1ZqaqrlWLly5SwNotL/rfZ58eLFfOf//vvv5eLiYmkQlSSTyaS2bdtasm+Vra2tpaFYkry8vOTk5GSpo7Dvi4MHD6ply5aWhksp9324XQcOHFBqaqrat29veU0zMjLUuHFjpaWl6eTJk/mOjY2NzdVAeu3aNR08eFCPPfaYVb15+et70M7OTlWqVJGPj4/VnNWrV1dSUlKu761SpUopNjb2Vi4VAAAAAAAAAAAAAAAAAP6Rzp49K7PZrAceeMDqeM2aNSVJp0+fvqX5cnri/j5fWlqaGjVqJF9fX3Xo0EHvvvvubdV7360kKt1Y6dBkMmnBggWKiYnRww8/nOd5s2fP1nvvvaeRI0eqXr16cnV11c6dO7VkyRKlp6erZMmSucYkJiZKkjw9Pa2O5zxOSEiwHCtRokSec/zdpUuXrLZ3z1GmTBmlp6ffdLyrq6vVYwcHB7m5uVkdM5lMVluaX7lyRT/99JPq1q2ba76qVataPf77XDkNozm1PfXUU7K1tdWHH36oqKgolS5dWr1799bIkSNlY2OTa/7ExESZTCZ5eHhYHff09FR2draSk5Pl7OycZ3ZO42tB9yUpKSnP++np6Wl5/W6Vk5OTVaNsTi05dRT2fREbG5urNhcXFzk6Ot5WXX915coVSVKXLl3yfP6vTcJ/l56enuv6kpKSlJWVpXLlyt00++/vQZPJZHkN/3osJ+uv3xcODg6Fep8DAAAAAAAAAAAAAAAAwN3y1x2w87Jz584iycnpNft7b1zO41vpcYuPj1dkZKRat25ttUhl1apVFRERIV9fX6Wnp2vz5s164YUXlJycrMGDB99Svfdlk6jJZFJ4eLjeeusthYaG5mrcy7Ft2zb16NFDTz75pOXYnj17Cpw7p7ExLi5O5cuXtxy/fPmy1fOS8myQzEu5cuV09OjRXMfj4uLk4uJSqDlulbu7u5o2baqxY8fmeu7vzYI34+DgoNGjR2v06NE6c+aMPvjgA0VGRsrLy0uPPfZYntlms1mJiYlyd3e3HL98+bJsbGxyNRzeKnd3d8sqp391+fJlq7yiVNj3RdmyZXPVlpKSkqtJ0sHBQWaz2erYzb75c64tKipKFSpUyPV8fksQ54xNTk62Oubq6ipbW9u7tgxxjqSkpFwNwwAAAAAAAAAAAAAAAMC/Rlam0RXgDiUnJxeqz6pKlSpFlmk2mzV+/HhJ0ksvvWT1XOfOna0et2jRQmazWUuWLFG/fv2sdim/mfuySVSSunfvrri4OD3xxBP5npOenm51sZmZmdq6dWuB8/r5+clkMmnbtm3y9fW1HP/0009VpkwZq27cwvLz89OmTZt05swZVatWTZJ05swZHT9+XA0aNLjl+QqjcePG+vjjj1WzZs1cKz7eiWrVqmn8+PGKjo7Od9nb4OBgSf/XpJsj557eaT3BwcFasWKFvvrqK4WFhUmSMjIytGPHDkt2USvs+8Lf31+7du3S5MmTLVu4b9u2Ldd8FSpU0KlTp6yO7du3r8AagoKCVKJECV24cEFt27a9pfpr1Kih+Ph4paamWu6/s7OzAgMD9dFHH2nQoEE33XL+dp0/f141atS4K3MDAAAAAAAAAAAAAAAAQGHcyUqh27Zt05QpU2563ieffGJZDPDvi/olJSVJUqEWQszOztZzzz2nQ4cOacOGDYXaLfrhhx/WZ599prNnz1q2ti+M+7ZJ1N/fX4sXLy7wnMaNG+u9995TrVq1VKpUKW3YsMFqS/a8lC5dWn369NGKFSvk4OCgwMBA7dmzR1u2bNELL7xwW410Xbt21ZIlSzRs2DDLyp4LFy7MdwXUojBgwABt3rxZffr0Ub9+/VSpUiXFx8fr4MGDKl++vAYMGFDouUaMGKG6devK19dXJUqU0K5du5SYmKhGjRrleb6Pj4/Cw8M1c+ZMpaWlqUaNGvr444914MCBm75mhdGiRQv5+/vrmWee0YQJE+Tp6am1a9fq0qVLWrhw4R3Pn5fCvi+efPJJdevWTSNHjlSvXr0UExOjFStW5Npuvl27dnrppZcUFRWloKAg7dmzRz/99FOBNbi5uWnMmDGaPXu2Lly4oIceekh2dnY6d+6cdu7cqcjISJUoUSLPsfXr11dWVpZ+/vlnq8bkCRMmaMCAARowYID+85//yN3dXUePHlWpUqXUrVu3O7tp/9+RI0c0cODAIpkLAAAAAAAAAAAAAAAAAO617t27q3v37oU69/r16zKZTDp9+rSaNm1qOZ6zKOMDDzxw0zlmzZqlTz/9VMuXL5ePj8/tFV1I922TaGG88MILmjp1qqZPn64SJUqoS5cuatu2bZ4dvX/dOn7ixIlydXXV+++/rzfeeEOVK1fWtGnT1LNnz9uqw8nJSStXrtRLL72kZ555RuXLl9eIESO0c+fOXN3CRaVUqVKKjo7W/PnzNWfOHCUkJKhMmTIKCAi45VUo69evr08//VSrVq1SZmamatSooTlz5qhx48b5jpk9e7bmzp2r5cuXKyEhQQ888IAWLlyoVq1a3emlyc7OTsuWLdNrr72m2bNnKzU1VXXr1tXKlStVr169O54/P4V5X/j6+mrBggWaM2eORo0apdq1a2vevHkaPHiw1Vzdu3fX2bNn9fbbb+utt95Shw4dNH78eE2YMKHAGgYNGqTy5ctr1apVWrdunezt7VW1alW1aNGiwCWCa9SooTp16mjv3r1WTaINGjTQmjVrNH/+fE2ePFm2traqXbu2xo0bd3s36W+OHj2q+Ph4tWvXrkjmAwAAAAAAAAAAAAAAAID7mYODg0JCQvTZZ5+pf//+luOffPKJatasKS8vrwLHL1u2TG+99ZbmzJmj0NDQQud+8skncnNzU9WqVW+pXpvs7OzsWxrxD3PixAk9+uijWr16db4rYwLFwdq1a7VmzRpt377dqin6bpo1a5aOHj2qNWvW3PYc35yJL8KKbk1D2/OGZZ8wVTMk17eCmyG5kmS+cMqQ3GzHkobkSlL2wdtfxvxO/O7byZBcSapQMv+G9rvJ7t782MuTvbIMy7ZNSzQk93yWqyG5kmSyNebFdne69dXmi8rl1AxDcit+u86QXEmyK1vZkNzsDLMhuZIU79vekNxPTsYZkitJPevefMuMu8Xx4nFDcq+V8zYkV5LirmUaklvRPs2QXEmyTb5oULBx/x73Z1UwJPdBkzGfSSTJNu6MYdm/lQk0JPdsonHfV75lnQ3J9Uz+3ZBcScpyLmVYtlEOXzXmdU5MN+6zWJOKTobkZhv4O+PPq8b8PUOSanga93dKAAAAAADulowfthpdAiTZBz9yz7K+//579evXT0888YQefvhh7d+/X4sXL9a8efP08MMPW87z9fXVY489pv/+97+SpM2bNysiIkKPPvqoevfubTVn1apVVbp0aUk3djd/7LHH9MADDygtLU2bN2/Wtm3b9Nxzz1k1phbGP3ol0Zv5+eeftW7dOjk6OqpOnTpGlwPcVd27d9eyZcv0xRdfqHXr1nc9LyUlRe+//74WL15817MAAAAAAAAAAAAAAAAA4H7RoEEDRUZGav78+Xr//fdVqVIlvfLKK1YNopKUmZmprKz/W3xq3759kqSPP/5YH3/8sdW5M2bMUNeuXSXdaBh96623dPnyZdnY2KhOnTqaPXu2Hn300VuutVg3iT7//PNKTEzUyy+/bOmwBYorJycnzZw5U8nJyfck748//tDYsWPVsGHDe5IHAAAAAAAAAAAAAAAAAPeL1q1b33QxvxMnTlg9njlzpmbOnHnTuefPn38npVkp1k2iH374odElAPdUkyZN7llWnTp1WKEXAAAAAAAAAAAAAAAAAO5jxbpJFAAAAAAAAAAAAAAAAACAuyk7K9PoEoB82RpdAAAAAAAAAAAAAAAAAAAAAIoeTaIAAAAAAAAAAAAAAAAAAADFEE2iAAAAAAAAAAAAAAAAAAAAxRBNogAAAAAAAAAAAAAAAAAAAMUQTaIAAAAAAAAAAAAAAAAAAADFkL3RBQD4d/NwMu7HUJatu2HZdtnG5P5wLsGYYEkBttcNyd1x0cWQXEkKDnrMkNwa2VcNyZWks6k2huRWTz9rSK4kmT1rGpadbXI2JNfrWpwhuZKkLGNiTc7VjQmW5Gi+bEjuYb9ehuRKUla2Mb8o3ZzsDMmVpEomY/793sO1yhiSK0m22ZmGZWc5exiSG59m3DWfTUw3JPfHVLMhuZLk6ljOkNxyJR0MyZWkOh4G/f0qxaBf0JLOeAYalm3Uv7x2Nhn3+6rcxZ8MyXXuvdaQXEnat3GmIblnE68ZkitJzasZ83PseJxxvydtrhvz9+gtMcb9/PTxNO6/l1xPNObvOA7unobkAgAAAAAAGI0mUQAAAAAAAAAAAAAAAAAAbleWcf8YFLgZtpsHAAAAAAAAAAAAAAAAAAAohmgSBQAAAAAAAAAAAAAAAAAAKIZoEgUAAAAAAAAAAAAAAAAAACiGaBIFAAAAAAAAAAAAAAAAAAAohmgSBQAAAAAAAAAAAAAAAAAAKIZoEgUAAAAAAAAAAAAAAAAAACiGaBK9j0RGRsrb21ve3t7y8fFRcHCwOnXqpJdfflmnTp3KdX6rVq308ssv37P6duzYofXr1xfq3EmTJlmuxdvbW4GBgXr00Uf13nvvWZ23f/9+eXt76/Dhw5Zj3t7eWrFiheVx3759NWzYsKK5CN24z0FBQTc9r6hzT5w4oaCgIMXHxxfZnIX122+/ydvbW3/88Ue+53Tu3FmTJk2yPL7ZfYqJiVFgYKBiYmKKtFYAAAAAAAAAAAAAAAAAQNGwN7oAWHNyctLq1aslSVevXtUvv/yi6Ohovfvuu3r11VfVuXNny7lRUVFyc3O7Z7Xt2LFDR44cUe/evQt1fpUqVTRnzhxJN67l888/15QpU+Ts7KxHHnlEklS3bl1FR0erZs2a+c4zdepU2dre+37mos6dP3++unbtqtKlSxfZnIW1a9cueXt7q1KlSkU2p5eXl9q1a6fIyEjNmjWryOYFAAAAAAAAAAAAAAAA/kmyszKNLgHIF02i9xlbW1sFBgZaHjdp0kT/+c9/9OSTT+r5559X/fr1VaVKFUmSr69vgXNlZ2fLbDbLwcHhbpacLycnp1zX8tNPP2n79u2WJlEXFxerc/JSq1atm2alpaXJycnpTsq9rdzCOnfunHbt2qWNGzcW2Zy3YteuXWrZsmWRz9utWzcNHDhQzz77rCHNrwAAAAAAAAAAAAAAAACA/LHd/D+Ao6OjXnjhBZnNZqvt2v++3fykSZPUsWNH7dmzR48++qj8/Pz0xRdfSJIOHDigfv36KTAwUMHBwZowYYLi4uKscq5fv6558+apdevWqlevnpo1a2bZfnzSpEn68MMPdfLkScsW8n/dmrywSpYsqYyMDMvjvLab/7u/b/uesw36oUOH1KNHD/n5+Wn9+vX5zjVixAj17ds317yHDh1St27d5Ofnp4cffli7du0qVO6JEyfUq1cvBQQEqGPHjtq7d+9Nr3vTpk2qUqWKVWNvTEyMvL29tWnTJr344otq0KCBQkNDtWrVKknS1q1b1a5dO9WvX1+jRo1SUlKS1ZwnT55U79695efnp/DwcH388cd5XmtSUpJ+/PFHqybRH3/8UV27dpWfn5/lPXM7goOD5eHhoc2bN9/WeAAAAAAAAAAAAAAAAADA3cNKov8QtWrVUvny5XXgwIECz7t06ZJeeeUVPfXUU6pYsaIqVaqkAwcOqG/fvmrevLnmzZuna9euaf78+RoxYoSio6MtY0ePHq1vvvlGw4YNU2BgoOLj47V9+3ZJNxot4+Pjdfr0acsW8oVZOTKnITQ1NVXbt2/Xjz/+WCRbk5vNZk2YMEEDBgzQ008/LQ8PDyUmJt7S+KefflqDBg2Sl5eX3n77bY0aNUobN26Ut7d3geMiIiLUr18/jRgxQsuXL9eYMWP0xRdfqFSpUvmO+/rrrxUUFJTnc/Pnz1d4eLgWLFigHTt2aObMmYqPj9e3336rZ555RikpKXrllVc0e/ZsTZ8+XdKNlVMHDRokNzc3zZ49W5K0aNEiJSUlqWrVqlbz7927V+7u7vL395ckxcbGavDgwfL29tb8+fOVlJSkadOmKTU1VQ8++GCh76F0Y+XbgIAAff311+rfv/8tjQUAAAAAAAAAAAAAAAAA3F00if6DVKxYUZcvXy7wnMTERC1fvlwBAQGWY88//7zq1aunqKgo2djYSJLq1KljWUGyefPm2rdvn3bv3q3XX39dHTt2tIzN+XPVqlVVunRp/fHHHzfdHj7HyZMnVbduXatjgwYN0qOPPlqo8QXJafLs0KGD5dj+/ftvafxTTz2lbt26SZLCwsIUHh6upUuXau7cuQWOi4iIUPPmzSVJNWrUUOvWrfXll1+qc+fOeY7Jzs7WkSNH1KZNmzyfDwwM1HPPPSdJatSokbZv365169ZZNZ6eOHFC77//vqVJ9IMPPlBcXJzefvtteXl5SZLq1aun8PDwXE2iu3btUrNmzWRre2Ph4NWrV8vGxkbLly+Xq6urJKlChQoaMGDATe9bXnx8fLR+/frbGgsAAAAAAAAAAAAAAAAAuHtoEv0Hyc7OtjR55sfDw8OqQfTatWv68ccfNXHiRGVmZlqOV69eXRUrVtThw4fVvHlz/e9//1OJEiX0yCOPFFm9VatWtTRcpqWl6fvvv9eiRYtUsmRJjRo16o7nz2nUvF1t27a1/NnOzk5t2rTRjh07Chxja2ur0NBQy2MvLy85OTnp4sWL+Y5JTEzU9evX8115tUmTJlZ1VKlSRTY2NlYrk1avXl1JSUm6evWqSpYsqSNHjqhOnTqWBtGcWnx8fKzmzszM1N69e/Xyyy9bjh08eFAhISGWBlFJCg0NlYeHR4HXnp9SpUrpypUrMpvNMplMtzUHAAAAAAAAAAAAAAAAAKDo0ST6D3LhwgVVr169wHM8PT2tHiclJSkzM1MzZszQjBkzcp3/559/SpISEhJUtmzZmzah3gpHR0f5+flZHjds2FBxcXF644031KdPn9tuSpSkEiVKqGTJkrc93mQyyd3d3epYmTJlFBsbW+A4JycnOTg45JorPT093zE5z/19XI6/NmvmzOfs7JzrWM5cJUuW1KVLl/JsOi1durRVLQcOHNDVq1etGlFjY2NVrVq1PMfejpzrSk9Pp0kUAAAAAAAAAAAAAAAAAO4jNIn+Q5w8eVIXL15Uly5dCjzv702erq6usrGx0bBhw/Lc7jxntUoPDw/FxsYWarXSO/HAAw/IbDbrzJkzd9QkmleNjo6Okm5sCf9XSUlJuc43m81KTEy0ahSNi4tT2bJlb7um/ORcZ1JSUpHNWa5cOR07dizX8fj4eKvm2V27dqlhw4ZycXGxHCtbtqzi4uLyHHs7kpKSZDKZrDIAAAAAAAAAAAAAAAAAAMazNboA3Fx6erqmT58uBwcHde/e/ZbGOjs7KzAwUKdPn5afn1+ur5ztyhs3bqxr167p008/zXeum62YWRgnT56UJKut1ItKhQoVJEmnTp2yHIuPj9fRo0fzPP/zzz+3/DkzM1M7duxQQEBAkdfl6OioSpUqKSYmpsjmrFevnk6cOKFz585ZjsXExOj48eNW5+3evVstW7a0Oubv76/9+/crOTnZcux///ufEhISbquW8+fPq0aNGrc1FgAAAAAAAAAAAAAAAPjHy8rk6374Qp5YSfQ+k5WVpZ9++kmSlJqaql9++UXR0dE6d+6cZs6caWnqvBUTJ05U//79NW7cOD3yyCNyc3PThQsX9PXXX6tr164KCQlR48aN1bx5cz333HM6e/asAgIClJCQoM8++0zz58+XJNWsWVMffPCBtmzZomrVqqlUqVIF1pOWlma5lrS0NH3//fd677331KRJE1WtWvWWr+NmKlSooICAAC1atEiurq6yt7fX8uXLc23nLt1oeF2yZInS09Pl5eWlt99+WxcuXNCiRYuKvC5Jql+/fr7Nqrfj8ccf1xtvvKHhw4dr9OjRkqSoqCh5enpaVk09d+6cfv3111xNov3799eGDRs0dOhQDR06VElJSYqMjMxzZdfMzExt27Yt13F/f39VqlRJknTkyBEFBwcX2bUBAAAAAAAAAAAAAAAAAIoGTaL3mbS0NPXo0UPSjVVAvby8FBoaqqioKNWsWfO25qxfv742bNigyMhITZ48WWazWRUqVFCjRo1UrVo1y3mRkZGKiopSdHS0oqKiVKZMGTVp0sTyfLdu3XTo0CFNnz5dCQkJ6tKli2bOnJlv7rlz5yzXYjKZVLlyZQ0ePFhDhw69resojDlz5mjKlCmaPHmyPD09NW7cOG3dutVq1cyceubOnatp06bpl19+kZeXlxYuXCgfH5+7Ule7du0UERGhlJSUItmW3cnJSStXrtTUqVMVERGh8uXLa8SIEdq0aZOlKXbXrl2qWbOmqlSpYjW2XLlyWr58uV555RWNHTtWVatW1Ysvvqh58+blyklPT9fYsWNzHX/ttdfUuXNnxcXF6ejRoxo/fvwdXxMAAAAAAAAAAAAAAAAAoGjZZGdnZxtdBFDcmc1mtWzZUhEREXrsscfuSkZCQoLatGmjAQMGaNSoURo0aJB8fHw0ceLEu5InSevXr9dbb72l7du3W1YwvVXHLyYVcVWFV9M2wbDs09kehuSmpGcZkitJAbZ/GpL7eXJpQ3IlKbjinTeF3w6P7KuG5ErSWXMJQ3Krp581JFeSzJ639484ioKtOc2Y3GsJhuQayVSuumHZ1xMvG5J7OMm4f0+WZdBfUdyc7AzJlaRKLiZDclOuG/fZoJSDYdGyS4k1JPdPe09DciXpTEK6IbmXU68bkitJro7G/BwrV9K4N3cdD2Ou2ajvKUk6Z1vGsGyjXLpqNiz7ofRjhuQ6915rSK4k7duY/z+QvpvOJl4zJFeSmldzNyT3eJxx19zA3Zjvq80xxn0W8/E05r9ZSFJtZ2M+Hzi4G/dZDAAAAABQ/F3f967RJUCSQ5MnjC7hvsRKosA9YDKZNHToUK1Zs6bImkSXLVsmT09PVa5cWbGxsVq5cqUyMzP1+OOPS5JWrlxZJDn5ycrK0po1azRy5MjbbhAFAAAAAAAAAAAAAAAAANw9NIkC90ivXr2UkpKi+Ph4lS595ysb2traasmSJbp48aLs7OwUEBCg1atXq2LFikVQ7c1dunRJXbp00aOPPnpP8gAAAAAAAAAAAAAAAAAAt4YmUeAecXBw0MiRI4tsviFDhmjIkCFFNt+tqlChgoYPH25YPgAAAAAAAAAAAAAAAACgYDSJAgAAAAAAAAAAAAAAAABwu7KyjK4AyJet0QUAAAAAAAAAAAAAAAAAAACg6NEkCgAAAAAAAAAAAAAAAAAAUAzRJAoAAAAAAAAAAAAAAAAAAFAM0SQKAAAAAAAAAAAAAAAAAABQDNEkCgAAAAAAAAAAAAAAAAAAUAzRJAoAAAAAAAAAAAAAAAAAAFAM2RtdAIB/t9rXzxiW/WfJGoZlVythZ0huaolsQ3Ilad+lsobkOpsMiZUkXbiaYUiug5uLIbmS5GJjzHss07GiIbmSlGrOMiz79wRjcuuWMeb7WZJsD24zJDfWqZwhuZLknnndkFwnewdDciXp4tV0Q3LLlTTul4ZDpkHXnHzOkFxJ+s2pumHZtrZlDMn1skszJFeSKqceNCT3dLmHDMmVpAdSTxmSa/aobUiuJJniThuS++px435nSH8Yljw5wNGQ3Orp5w3JlaQYzwBDcvdtrGtIriSVLWnMfz51czTw73VZqYbkhtj9aUiuJCXa1zQkt11NG0NyJckp4axh2TYJxnwmOpluzM9tSapdztWwbAAAAAAAAJpEAQAAAAAAAAAAAAAAAAC4TdmZmUaXAOSL7eYBAAAAAAAAAAAAAAAAAACKIZpEAQAAAAAAAAAAAAAAAAAAiiGaRAEAAAAAAAAAAAAAAAAAAIohmkQBAAAAAAAAAAAAAAAAAACKIZpEAQAAAAAAAAAAAAAAAAAAiiGaRAEAAAAAAAAAAAAAAAAAAIohmkSBYiwyMlJBQUFGlwEAAAAAAAAAAAAAAAAAMIC90QUAAAAAAAAAAAAAAAAAAPCPlZVpdAVAvlhJFPgXS0tLM7oEAAAAAAAAAAAAAAAAAMBdQpMo8C8RExMjb29vbdy4UVOmTFFISIi6d+8uSUpISNDkyZMVEhIif39/9ezZU999953V+L59+2rYsGHatm2b2rVrp6CgIPXr109nz5414nIAAAAAAAAAAAAAAAAAADfBdvPAv8zcuXPVvHlzvf7668rKylJmZqaGDh2qc+fOKSIiQp6enlq7dq0GDhyod955R/Xq1bOMPXbsmOLj4xUREaHMzEzNnDlTzzzzjKKjow28IgAAAAAAAAAAAAAAAABAXmgSBf5lfHx89Oqrr1oe79y5U4cOHdKbb76ppk2bSpLCwsIUHh6upUuXKjIy0nJucnKyNm3apNKlS0uSUlNTNXnyZF24cEEVKlS4txcCAAAAAAAAAAAAAAAAACgQ280D/zItWrSwevz999/LxcXF0iAqSSaTSW3bttUPP/xgda6Pj4+lQVSSatWqJUm6cOHC3SsYAAAAAAAAAAAAAAAAAHBbaBIF/mXKlClj9TgpKSnXMUny9PRUYmKi1TE3NzerxyaTSZKUnp5exFUCAAAAAAAAAAAAAAAAAO4U280D/zI2NjZWj93d3RUXF5frvMuXL8vd3f1elQUAAAAAAAAAAAAAAAD8M2VlGl0BkC9WEgX+5YKDg5WSkqKvvvrKciwjI0M7duxQcHCwgZUBAAAAAAAAAAAAAAAAAO4EK4kC/3ItWrSQv7+/nnnmGU2YMEGenp5au3atLl26pIULFxpdHgAAAAAAAAAAAAAAAADgNtEkCvzL2dnZadmyZXrttdc0e/Zspaamqm7dulq5cqXq1atndHkAAAAAAAAAAAAAAAAAgNtEkyhQjI0ePVqjR4+WJHl5eenEiRN5nleqVCnNmDGjwLnWrl2b69iDDz6Y75wAAAAAAAAAAAAAAAAAAGPZGl0AAAAAAAAAAAAAAAAAAAAAih5NogAAAAAAAAAAAAAAAAAAAMUQTaIAAAAAAAAAAAAAAAAAAADFkL3RBQAAAAAAAAAAAAAAAAAA8E+VnZVldAlAvlhJFAAAAAAAAAAAAAAAAAAAoBiiSRQAAAAAAAAAAAAAAAAAAKAYokkUAAAAAAAAAAAAAAAAAACgGKJJFAAAAAAAAAAAAAAAAAAAoBiiSRQAAAAAAAAAAAAAAAAAAKAYsje6AAD/bumetQ3LTksxG5adJRtDchPSMwzJlaS0jCxDcsu7OBiSK0nmzGxDcktkpRmSK0lpcjQk90q2MbmSdN2g97YkOdgb87PEUFmZhsS62hvz/SxJCdnuhuSWcTYkVpL0S5wxv6+uG/RzW5LiM02G5Ja1Ne6vhJeuXjcsu4yzMffbJj3FkFxJuvZAY0Nyz5w37pqrVDbm7xoxV437bFDDoNyWNT0NSpaWfHXasGwFljcm1964z76Vk341JPcXc2VDciUpK9uYzwcmOwM/6zsY83Mss2QZQ3Il4+63KeOaIbmSlOZR1bBsp8QYw7KNUmvERkNyf13c1ZBcAAAAAABwf2ElUQAAAAAAAAAAAAAAAAAAgGKIlUQBAAAAAAAAAAAAAAAAALhdBu2ICBQGK4kCAAAAAAAAAAAAAAAAAAAUQzSJAgAAAAAAAAAAAAAAAAAAFEM0iQIAAAAAAAAAAAAAAAAAABRDNIkCAAAAAAAAAAAAAAAAAAAUQzSJAgAAAAAAAAAAAAAAAAAAFEM0iQIAAAAAAAAAAAAAAAAAABRDNIn+A3z88cfq2bOngoKCFBQUpB49emjTpk1Gl3XXXbt2TVFRUerQoYMCAgIUEhKixx9/XPPmzbvluTZu3KjNmzffhSpv7tixY4qMjNS1a9dy1eTt7a34+Ph7Ws/69ev1+OOPWx5fvXpVEyZMUHBwsDp37qxDhw5ZnW82m9W+fXt9/vnnueYaOHCglixZctdrBgAAAAAAAAAAAAAAAO5bWZl83Q9fyBNNove56dOna+LEiapZs6YWLFighQsXqnbt2po0aZKmT59udHl31ZgxY7R27Vp169ZNb7zxhl5++WWFhoZqx44dtzzXhx9+qC1bttyFKm/u2LFjioqKytUk2qJFC0VHR8vNze2e1XLt2jUtWbJETz75pOXY0qVL9euvv2r+/PmqWbOmxo0bJ7PZbHl+9erVqlixotq2bZtrvmHDhmnlypVKTEy8J/UDAAAAAAAAAAAAAAAAAArP3ugCkL+dO3dq3bp1GjVqlEaPHm053rRpU5UrV06LFi1SkyZN1KpVKwOrvDvOnDmjL7/8UrNmzdJjjz1mOd6uXTuNHz/euML+v7S0NDk5Od3RHKVLl1bp0qWLqKLC+eSTT2Q2m9W6dWvLsX379mn48OFq2rSpHnzwQTVp0kRnzpxRrVq1FBsbq+XLl2v9+vV5zteoUSO5ubnpww8/1IABA+7RVQAAAAAAAAAAAAAAAAAACoOVRO9jq1evlru7uwYNGpTrucGDB8vd3V2rV6+WJKWkpKhly5YaM2aM1XkvvviiQkJCdPHiRX3xxRfy9vbW77//bnVOYmKi/P39rRoB33nnHbVs2VIBAQEaOHCgfv75Z3l7e2vjxo1WYzdu3KhOnTrJz89PTZs21bx585SZmWn1vLe3t37++WcNGTJEgYGBCg8P16ZNmwq89pyVKcuWLZvrOVtb67ftnDlz1KlTJwUFBalp06YaP368Ll26ZHm+b9+++vbbb7V79255e3vL29tbkZGRkqRWrVrp5Zdftppvx44d8vb2VkxMjCQpJibGcu1TpkxRSEiIunfvLknavXu3Bg4cqNDQUNWvX1/du3fXl19+aXX9kydPliSFhobK29vb0tSb13bzCQkJmjx5skJCQuTv76+ePXvqu+++s6qvb9++GjZsmLZt26Z27dopKChI/fr109mzZwu8p5K0adMmtW7dWvb2/9cffv36dUvDa87/Xr9+3XJvO3furFq1auU7Z/v27W/6egIAAAAAAAAAAAAAAAAA7j2aRO9TGRkZOnDggEJCQlSyZMlcz5csWVIhISE6cOCAMjIy5OLiov/+97/avn27pWFvz549io6O1tSpU1W+fHk1b95c5cuX1wcffGA1V8427J06dZJ0YwXTqVOnqkmTJoqKilJoaKjGjRuXq4ZVq1ZpypQpCgsL0xtvvKGhQ4dqzZo1mjdvXq5zIyIiFBYWpkWLFunBBx/UpEmTdOrUqXyv/4EHHpCzs7NmzpypXbt26erVq/meGxcXp2HDhmnp0qV6/vnndf78efXt21cZGRmSpKlTp8rX11f169dXdHS0oqOjLU2et2Lu3LnKzs7W66+/rmeeeUbSjQbSli1b6rXXXlNkZKTq16+vJ598Uvv375d0Y0v5p556SpL05ptvKjo6WlFRUXnOn5mZqaFDh2rXrl2KiIjQggUL5OzsrIEDB+rIkSNW5x47dkwrVqxQRESEZsyYobNnz1pqyk9aWpoOHDig+vXrWx338/PTu+++qytXrmjNmjVydXVV9erV9dNPP+mrr76yWsU2L0FBQTp27JhVsysAAAAAAAAAAAAAAAAAwHhsN3+funLliq5fv66KFSvme07FihWVnp6uhIQEeXp6KjQ0VH369NErr7wib29vPf/88+rYsaM6dOggSbKzs1PXrl31wQcfaNy4cbKzs5MkffDBB2rbtq3c3NwkSUuWLFGjRo30yiuvSLqxvX1GRoYWLFhgyU5JSdHChQs1ZMgQy/bvTZo0kclk0syZMzV48GCVKlXKcn7v3r3Vu3dvSTeaCvfs2aPPPvtMI0aMyPPaXFxc9Oqrr2rKlCkaPny47Ozs5OPjo7Zt26p///5ydna2nDtjxgzLnzMzMxUUFKRmzZrpm2++UVhYmGrVqiUXFxc5OzsrMDCw0K/B3/n4+OjVV1+1OtanTx/Ln7OyshQSEqJff/1V7777rkJCQlS6dGlVrVpVklS3bt0Ct5ffvXu3Dh06pDfffFNNmzaVJIWFhSk8PFxLly61rH4qScnJydq0aZNlvtTUVE2ePFkXLlxQhQoV8pz/2LFjMpvN8vb2tjo+cuRIDRo0SI0aNZLJZNJ///tflShRQq+88orGjRsnV1fXm94XSTp06JBatGhR4LkAAAAAAAAAAAAAAAAAgHuHlUSLmYiICJUtW1ZPPPGEbG1t9eKLL1o9361bN8XGxmrv3r2SpOPHj+vo0aPq1q2bpBtNlseOHbNsiZ6jdevWVo8PHDig1NRUtW/fXhkZGZavxo0bKy0tTSdPnrQ6PywszPJnZ2dnVapUSRcuXCjwWjp06KBdu3Zp1qxZ6ty5s65cuaL58+fr8ccfV2pqquW8PXv2qGfPngoODpavr6+aNWsmSfr9998LcccKL68GyAsXLujZZ59V06ZN5evrq7p16+qrr77Sb7/9dsvzf//993JxcbE0iEqSyWRS27Zt9cMPP1id6+PjY9VwmrMdfEH3NDY2VpJyNapWrlxZn3zyiT777DN98803evTRR/X+++8rOztb3bp108GDB9W1a1c99NBDeuqpp3KtGJrTDJwzPwAAAAAAAAAAAAAAAADg/kCT6H2qVKlScnBw0J9//pnvOX/++accHR3l4eFhOebk5KQ2bdro+vXr6tixo9zd3a3GeHl5qUmTJnr//fcl3VhF1MvLS40aNZIkxcfHKyMjI1cjYZkyZaweX7lyRZLUpUsX1a1b1/IVHh5uqe2v/r4apclk0vXr1292G+Tu7q7HHntMM2bM0BdffKERI0bo9OnTlvoPHTqkESNGqFy5cnrttdcUHR2td999V5KUnp5+0/lvxd/vQVZWlp566in98MMPGjNmjNasWaP3339fzZo1K9S1/V1SUlKuDEny9PRUYmKi1bGcVV9zmEwmSQVfc85zDg4OuZ6zs7NT9erV5eLiouTkZM2fP18vvPCCzGazRo8erQ4dOmj37t2ysbGxrDCbI2e+tLS0QlwlAAAAAAAAAAAAAAAAAOBeYbv5+5S9vb2CgoL07bffKjU11Wp7denG9uLffvutgoKCZG//fy/j8ePHtWrVKvn6+mrdunV6/PHHVbNmTaux3bt3V0REhC5evKjNmzerb9++srGxkXRjlUl7e/tcq0XGxcVZPc5pPo2Kispze3MvL6/bv/h82NjYaPDgwVq8eLFOnTolSdqxY4dcXFw0f/582dre6Hk+f/58oed0cHCQ2Wy2Ovb3hsy/5v/VmTNn9PPPP2vRokVq06aN5fjtNku6u7vnus+SdPny5VzNvrc7v3SjGbVs2bL5nhcZGamwsDAFBgbq+PHjunjxonr16iVnZ2d1795dkyZNsjo/OTlZkqyalQEAAAAAAP4fe/cdHmWZvv//nJlkSJ2QBBJKkCYECAlSJIhAClhwQUUUWaUEkEX6yoIgsqKgElxAhbAiLHylrShWQNaPNEFkFVhFxHVdmiUQQglJCJA2M78//DFrhJAEktwY3q/j4Dicp9zn9UymPDNecz8AAAAAAADA9cLtcpkuASgWM4lewwYOHKjMzEwtWbLkonVLlixRZmamBg4c6FmWn5+vxx9/XDExMXrjjTfUpEkTPf744yosLCyyb9euXeVwOPSnP/1JWVlZuu+++zzrbDabmjdvrk2bNhXZZ+PGjUVut27dWr6+vjp27Jiio6Mv+nfhEuRXKicn55LNlhcuIX+hyTE3N1fe3t5FGjjXrl170X7e3t6XnGWzVq1anobTCz799NNS1XhhvAuzeEo/N6h++eWXF2VLKnF20bZt2yonJ0fbt2/3LCssLNTGjRvVtm3bUtV0OQ0bNpQkpaamFrvNwYMH9f7772v8+PFFll/4W5w/f/6ifS6Md2F8AAAAAAAAAAAAAAAAAMC1gZlEr2Fdu3ZVv379lJKSomPHjunOO++UJH300Ud688031a9fPyUmJnq2nzt3rn766Se9//77stvteuGFF9SrVy+98sorGj16tGc7b29v3XvvvVq8eLE6deqk2rVrF8kdPny4RowYoSlTpujOO+/Uv//9b7333nuS5Jmt0+FwaMyYMfrLX/6iY8eOqX379rLZbPrpp5+0adMmzZs3T76+vld87IcPH9bw4cPVq1cvtW3bVn5+fjpw4IAWLVqkwMBA9erVS5J06623aunSpZo+fbpuu+02ffnll3r//fcvGq9Ro0Z67733tHnzZtWsWVNhYWEKDw/XHXfcoaefflopKSlq3bq1tm7dqj179pSqxkaNGqlWrVqaPXu2XC6Xzp07p7lz5yosLKzIdhdmcl25cqW6desmHx8fRUZGXjRefHy8YmJiNGHCBP3pT39SjRo1tHz5ch0/flxz584t4z14sXr16qlmzZr65ptvFBcXd8ltnnvuOQ0dOtTThNuoUSOFhYVpxowZuvfee/Xqq6+qQ4cORfbZt2+f/Pz81Lx586uuEQAAAAAAAAAAAAAAAABQfphJ9Br35z//WS+88IIOHDig0aNHa/To0fruu++UnJysP//5z57tvvjiCy1evFgTJ07UDTfcIOnn5sRx48ZpwYIF+vrrr4uMe9ttt0mSevfufVFm165d9fTTT2v79u0aMWKEPvnkEz399NOSpICAAM92gwcP1owZM/T5559rzJgxGjt2rN58801FR0cXmV3zStSvX18PPvigdu3apUmTJmnIkCFasmSJOnTooLffflt169aVJMXFxWn8+PHatGmThg8frt27d+vVV1+9aLyhQ4eqTZs2mjhxou6//369+eabkqQHHnhAgwcP1uuvv66xY8cqNzdX48aNK1WNdrtd8+bNk91u19ixYzV37lwNHz5c7du3L7JdixYtNHr0aK1Zs0Z9+/bV8OHDLzmezWbTwoULFR8fr7/85S8aPXq0zp49qyVLlqhly5ZlufuKdeedd2rbtm2XXLdhwwYdOXKkyOy0drtdL7/8svbv36/Ro0crLCxMTz75ZJH9tm3bpttuu002m61cagQAAAAAAAAAAAAAAAAAlA+L2+12my4Cle/ll1/W3//+d33yySey2+0lbr969WpNmTJFmzZtUkRERCVUiIrwn//8R7169dLGjRs9jbZXIysrS7feeqv+3//7f7r55puvaIxz53Ovuo4rdTSnwFh2nYCra6S+UsfOmjvm/afOG8kNDyj5Na6iOF1mclsGGQqWdNpdzVi2KflOc6dSWXlOI7lNgsxNRm/98gMjua7WvzOSK0nZhl66zb2SSP/8KdtIbsuwgJI3qiABdjO/36t59kcjuZK0syCs5I0qSKifmXOxRsowkitJeQHhRnI/O5JjJFeSOtX1M5KbetbcK2jD3O+N5O4oqGMkV5Je2X7IWPbS7maeV7Yzx43kSpLbauY8cEvB1X+HcaWCqpk5Zm+bxUiuJLXwzzcT7Co0kyspzyfYSK690Mx3JZJU4HXlV4G6Wj5ZqUZyD9tqGcmVpO5PbzCSe+Cv9xnJBQAAAIDr0fl1802XAEm+PUaaLuGaxOXmrzOHDh3S4cOHtWLFCj300EOXbBDNzMxUSkqKOnToIH9/f3399ddasGCBunbtSoPob1yzZs2UmJioZcuW6Yknnrjq8ZYvX642bdpccYMoAAAAAAAAAAAAAAAAAKDi0CR6nZk6dar27Nmjzp07a9iwYZfcxsvLSz/99JPWrVunM2fOKDg4WPfcc4/Gjx9fydWiIkyYMEGbNm0ql7GqV6+uKVOmlMtYAAAAAAAAAAAAAAAAAIDyRZPodWb58uUlbhMQEKBXX321EqqBCQ0aNNCQIUPKZax+/fqVyzgAAAAAAAAAAAAAAAAAgPJHkygAAAAAAAAAAAAAAAAAAFfK5TRdAVAsq+kCAAAAAAAAAAAAAAAAAAAAUP5oEgUAAAAAAAAAAAAAAAAAAKiCaBIFAAAAAAAAAAAAAAAAAACogmgSBQAAAAAAAAAAAAAAAAAAqIJoEgUAAAAAAAAAAAAAAAAAAKiCvEwXAOD6djgz31h2dR+bsex8p8tI7oovjxrJlaQHW9U2kpuTZ+a+lqRaAd5Gcq3njxvJlaTggBpGcgss5k5prHaLsezzhWYe316nfzSSK0muFl2M5NpyThjJlaT/SzXz+O6TvdVIriTd0vpeI7k+NnPPZx+r20huYbUGRnIlqV3+WWPZx5xmfi/plt1IriQdO1toJLd+kI+RXEk6es7M+2Shy8zzWZKyqjc2ktva4OtntxbhxrJ/sgQbyQ0IDTWSK0nBuWY+a6Rl5BnJlaSPD5w0ktuyjsNIriTVCqhuJNdtcDqDYJl5z3B7+xrJlaT8QnPvV9bq9YzkbvzqmJFcSVo3tZuR3HHv7zOSK0lz7mlpLBsAAAAAABRFkygAAAAAAAAAAAAAAAAAAFfK5TRdAVAsLjcPAAAAAAAAAAAAAAAAAABQBdEkCgAAAAAAAAAAAAAAAAAAUAXRJAoAAAAAAAAAAAAAAAAAAFAF0SQKAAAAAAAAAAAAAAAAAABQBdEkCgAAAAAAAAAAAAAAAAAAUAXRJAoAAAAAAAAAAAAAAAAAAFAF0SQKY+bNm6fIyMiL/vXo0aNCc/v3769hw4Z5bn/++edasGDBJetr3bp1ueXm5eUpLi5OH3/8cbmNeSmHDx9WZGSkjh49elXjvPPOO4qMjFRGRsYl1+fk5Kh9+/b617/+dVU5AAAAAAAAAAAAAAAAAICK4WW6AFzffHx8tHTp0ouWVaSpU6fKav1ff/TOnTu1ZMkSPfroo0W2e+CBBxQXF1duua+//rocDofi4+PLbcxL2bJliyIjI1WnTp0KzQkICFC/fv304osvasWKFRWaBQAAAAAAAAAAAAAAAFyr3E6n6RKAYtEkCqOsVqtuuummch0zNzf3ko2mF5bfeOONpRqnVq1aqlWrVrnU5Ha7tWzZMg0YMKBcxrucLVu2KCEhocJzJKl3796aP3++/vOf/6hZs2aVkgkAAAAAAAAAAAAAAAAAKB0uN49r2scff6wHHnhAMTEx6tChg6ZOnapz58551n/++eeKjIzUxx9/rDFjxqhNmzYaO3asUlNTFRkZqXfeeUdTpkxRbGysHnjgAUlFLzc/b948paSk6Ny5c57L3ffv39+z7peXm7+Q9emnn+pPf/qTWrdurYSEBC1atKjE49i5c6eOHDmiO+64o8jyxMRETZs2TStXrlRCQoLatm2rESNGXHSJ9/379+vhhx9WdHS0br/9dq1Zs0YjRozw1HpBdna2vvjiC0+T6IVLxn/99dcaPHiwWrVqpTvuuEM7duyQy+XSiy++qI4dO6pjx46aPXu2XC5Xaf80kqS6desqJiZG77zzTpn2AwAAAAAAAAAAAAAAAABUPGYShXGFhYVFbttsNlksFn344Yd67LHHdN9992n06NE6ceKEZs+erezsbL344otF9vnzn/+su+++W/Pnzy9yKfk5c+YoLi6u2AbIBx54QMeOHdO6des8l70PCAi4bL1Tp07VPffco/nz52vjxo2aNWuWIiMj1aVLl2L32bFjh2rXrq3atWtftG7z5s364Ycf9NRTT+n06dOaMWOGpk+f7jnG3NxcDR48WA6HQ3/5y18kSfPnz1d2drZuuOGGImN98sknCgoKUkxMTJHlEydOVN++fTVo0CAtXLhQo0aNUq9evZSTk6OZM2fqq6++0rx589S0aVP17Nnzssf/a61bt9aOHTvKtA8AAAAAAAAAAAAAAAAAoOLRJAqjzp07p6ioqCLLXnjhBd1999164YUXdNddd+m5557zrKtZs6b+8Ic/aMSIEWrSpIlneWJioiZMmOC5nZqaKklq1qxZkf1/7cIl5cty2fvbb79do0ePliTdcsst+vjjj/V///d/l20S3bdvnyIjIy+5zu1265VXXpHdbpckHTlyRK+++qpcLpesVqvefvttnTp1Sq+//roiIiIkSS1bttTtt99+UZPoli1b1KVLlyKNspLUr18/PfTQQ5Kk8PBw9ezZU/v27dMbb7whSercubM2b96sDz/8sMxNos2aNdOyZcuUk5NTYoMtAAAAAAAAAAAAAAAAAKDy0CQKo3x8fLRixYoiy+rVq6fDhw/ryJEjmjx5cpGZRtu3by+r1ap9+/YVaRKNj4+/5PjFLb8anTp18vy3xWJR48aNdezYscvuc/z4cbVs2fKS626++WZPg6gkNW7cWAUFBTp16pRq1qypffv2qWnTpp4GUUmKiIhQs2bNiozjdDr1ySefaNq0aRdl3HrrrZ7/btCggSSpQ4cORbZp2LChDh8+fNnjuJTg4GC53W6dOnWKJlEAAAAAAAAAAAAAAAAAuIbQJAqjrFaroqOjL1p+8OBBSdLIkSMvuV9aWlqR26GhoZfcrrjlVyMwMLDIbW9vb505c+ay++Tn58vb2/uS6xwOR5HbFxpG8/LyJP3cYBoSEnLRfiEhIZ5tJOnLL7/U2bNnizSEXqrmC+P/Otfb21v5+fmXPY5LuTBebm5umfcFAAAAAAAAAAAAAAAAAFQcmkRxTapevbok6amnnlJMTMxF68PCworctlgslxynuOWVLSgoqMRG0uKEhYXp22+/vWh5RkaG/P39Pbe3bNmim2++udJn88zOzpb0v78ZAAAAAAAAAAAAAAAAAODaQJMorkmNGjVSrVq19NNPP+nhhx+u0KwrnUGzLBo2bKhDhw5d0b4tW7bUe++9p59++kn16tWTJKWmpuo///mP2rZt69nu448/1oMPPlgu9ZbFkSNHFBgYqJo1a1Z6NgAAAAAAAAAAAAAAAGCcy2W6AqBYNInimmSxWDRp0iSNHz9e586dU3x8vHx9fXX06FFt3bpVjz32mBo2bFguWY0bN1ZhYaGWLl2q1q1bKyAgQI0aNSqXsS9o06aN/vGPf6igoKDYy84Xp3fv3lqwYIEeffRRjR49WpKUkpKiGjVqeGZK/emnn3TgwAElJCSUa93SzzOU/nLGUklq0qSJGjduLEnat2+fWrduLavVWu7ZAAAAAAAAAAAAAAAAAIArR5Morlndu3eXw+HQggULtHbtWklS3bp11blzZ9WoUaPcchISEvTQQw9p4cKFOnXqlG6++WYtX7683MaXpK5du2ratGnauXOnbr311jLt6+PjoyVLlmjq1KkaP368wsPDNWLECL333nsKDAyU9HMjZ+PGjT0zjZanyZMnX7Rs7NixGjFihAoKCvTPf/5TEyZMKPdcAAAAAAAAAAAAAAAAAMDVsbjdbrfpIoDrwejRoxUQEKAZM2Zc9ViZmZnq1q2bkpKSNGrUKA0ePFjNmjXT448/Xg6Vlt7HH3+sP/3pT9q2bdtFs42W1jdp2eVcVelV97EZy/b3thjJnfvPn4zkStKDrWobyc3JMzele62Ass0cXF7C8o8byZUkV0D5NfGXRYHF3O9erBYzz2dJ+ulMvpHcxgVHjORKkssv2EiupSDXSK4krUo18/juk73VSK4knW59r5FcH5u557OP1dDHMou52eCt+WeNZR9z+hjJrSVz574/OgON5Jr8xsFm6OGd7zR30GF+Zt4z7AZfP9/89wlj2fENzJyXBHibe+0OzjXzWWPVETOfrSTpu/QzRnJb1nEYyZWk+AbVjeSafM8IthsKNngudq7Q3B3u42XmuJd+dcxIriQlNAwxkrvwsx+N5ErSnHtaGssGAAAAABPOrX7BdAmQ5PdA5fZO/VYwkyhQSUaMGKHf//73+tOf/lTmmVAXLlyoGjVqqG7dujpx4oSWLFkip9Op3r17S5KWLFlSESWXaMmSJRo0aNAVN4gCAAAAAAAAAAAAAAAAACoOTaJAJWnevLkmT56stLS0MjeJWq1WvfLKK0pPT5fNZlOrVq20dOlS1a5tZmZGSTp79qzat2+vpKQkYzUAAAAAAAAAAAAAAAAAAIpHkyhQifr06XNF+z3yyCN65JFHyrmaq+Pv769Ro0aZLgMAAAAAAAAAAAAAAAAAUAyaRAEAAAAAAAAAAAAAAAAAuFIup+kKgGJZTRcAAAAAAAAAAAAAAAAAAACA8keTKAAAAAAAAAAAAAAAAAAAQBVEkygAAAAAAAAAAAAAAAAAAEAVRJMoAAAAAAAAAAAAAAAAAABAFUSTKAAAAAAAAAAAAAAAAAAAQBVkcbvdbtNFALh+5Z3JNJZdYKtmLNtLLiO5p/KMxEqSvA39LMFhN/d7CJcsRnJtTnN/6LNubyO5gbknjeRKktti7jGWZqluJDfc18xjW5LOFJrJtpo7ZFU/9V8juSeCmxjJlcz9ki3Xae6jkan3K8exvUZyJamwRiNj2SrMN5PrZTeTK8ll9zeSm37e3PMq0NDzyuR7hl9hjpHcM7YAI7mS5HSZe4wF5x43knvaJ8xIriRV8zLzvKpm8Gfu1twsc+GGFPpUN5LrlZtpJFeSTijQSG6e08z3Q5LUIPs7Y9kuHzP3tzOgppFcSfox18z3JQEGvxczlR3o52skFwAAAADOvTHDdAmQ5PfgE6ZLuCYxkygAAAAAAAAAAAAAAAAAAEAV5GW6AAAAAAAAAAAAAAAAAAAAfqvcLqfpEoBiMZMoAAAAAAAAAAAAAAAAAABAFUSTKAAAAAAAAAAAAAAAAAAAQBVEkygAAAAAAAAAAAAAAAAAAEAVRJMoAAAAAAAAAAAAAAAAAABAFUSTKAAAAAAAAAAAAAAAAAAAQBXkZboA4Fq1Zs0aLVu2TIcPH5bb7VZ4eLjatGmjcePGKTQ0VJKUmJio+Ph4PfXUU5VSU0ZGhhYuXKgtW7bo6NGj8vb2VosWLXTPPffovvvuk81mK9U42dnZWrp0qbp3764bb7yx1Pk7duzQ6tWr9dVXX+nUqVOqW7eu7rvvPg0cOFDe3t5XelgAAAAAAAAAAAAAAAAAgApAkyhwCYsWLdLs2bOVlJSkMWPGyO12a//+/Vq7dq2OHz/uaRJNSUmRw+GolJp++OEHDRgwQE6nU4MGDVJUVJTy8/P12WefacaMGQoODla3bt1KNVZ2drZSUlLUpEmTMjWJrlq1Srm5uRozZoxq166tr776SvPmzdPBgwc1Y8aMKz00AAAAAAAAAAAAAAAAAEAFoEkUuITly5erV69emjRpkmdZXFycHnnkEblcLs+yFi1aVFpN48ePl9Pp1Ntvv63w8HDP8i5duqhfv346c+ZMhdfw9NNPKyQkxHM7NjZWLpdLL730kiZMmFBkHQAAAAAAAAAAAAAAAHA9cP+inwi41lhNFwBci7KzsxUWFnbJdVbr/542iYmJmjZtmuf2pEmT1KNHD+3YsUM9e/ZUTEyM+vXrp9TUVGVmZmrs2LFq06aNunXrpvXr15e6nt27d2vv3r0aNmxYkQbRC+rUqaPIyEhJ0sGDB/XYY48pLi5OrVq10l133aUlS5Z4mltTU1PVtWtXSdLYsWMVGRmpyMhIpaamlljHpZpAmzdvLrfbrRMnTpT6eAAAAAAAAAAAAAAAAAAAFY+ZRIFLiIqK0qpVqxQREaH4+HjVrFmz1PueOHFCycnJGj58uLy8vPTss89q/Pjx8vX1Vbt27dSnTx+9+eabmjBhglq1aqW6deuWOObOnTslSZ07dy5x2+PHj6thw4bq2bOn/P399e2332revHk6d+6cRo0apbCwMKWkpGjUqFEaN26cYmNjJanYptiSfPHFF7Lb7YqIiLii/QEAAAAAAAAAAAAAAAAAFYMmUeASpk6dqlGjRmnKlCmSpIiICCUkJCgpKanEZsisrCytWLFCTZo0kfRz0+b06dM1dOhQjRw5UpIUHR2tDRs2aOPGjRo4cGCJ9aSnp0v6ecbQktxyyy265ZZbJElut1tt27ZVbm6uVqxYoVGjRslut6t58+aSpPr16+umm24qcczifP/991q2bJn69u0rf3//Kx4HAAAAAAAAAAAAAAAAAFD+aBIFLqFp06Zat26d/vnPf2r79u3atWuXli9frnfeeUcrV670NFleSlhYmKdBVJIaNGggSerYsaNnmcPhUEhIiI4dO1butefl5enVV1/V2rVrlZaWpoKCAs+6s2fPllszZ05OjkaPHq2IiAg99thj5TImAAAAAAAAAAAAAAAAAKD80CQKFMNutysuLk5xcXGSpE8++UTDhg3T/PnzlZKSUux+DoejyG1vb29JUmBg4EXj5+XllaqW8PBwSVJaWprq169/2W3/8pe/aPXq1Ro5cqRatmypwMBAbdq0Sa+88ory8vLKpUk0Pz9fI0eOVFZWlt544w35+fld9ZgAAAAAAAAAAAAAAAAAgPJFkyhQSp07d1azZs108ODBSs9u3769JGn79u0lNol++OGHevDBB/WHP/zBs2zr1q3lVovL5dL48eP1zTffaOXKlapdu3a5jQ0AAAAAAAAAAAAAAAAAKD80iQKXcPLkSdWoUaPIstzcXKWlpenGG2+s9HratWunmJgYLViwQLfddpvCwsKKrE9LS1N2drYiIyOVl5fnmb1UkpxOpz744IMi219YX9qZTH/pmWee0ZYtW7R48WJFRkZewdEAAAAAAAAAAAAAAAAAVYfb6TJdAlAsmkSBS+jZs6cSEhLUqVMnhYWFKT09XStWrNDp06c1cOBAIzXNmjVL/fv3V+/evTVo0CBFRUUpPz9fu3bt0sqVKzVz5kxFRkaqY8eOWr16tW688UYFBwfr73//u/Lz84uMVbNmTTkcDn3wwQeKiIiQ3W5XZGSk7Hb7ZWtYsGCBVq1apSFDhshut2vPnj2edTfeeKMCAgIq4tABAAAAAAAAAAAAAAAAAFeAJlHgEkaNGqUtW7YoOTlZGRkZCg4OVmRkpF577TV16NDBSE3169fXu+++q0WLFun1119XWlqa7Ha7WrRoocmTJyshIUGS9Oc//1lTp07V9OnT5evrq169eum2227TlClTPGNZrVbNmDFDc+bMUVJSkvLz87Vp0yZFRERctoZPP/1UkrR48WItXry4yLply5YpNja2nI8aAAAAAAAAAAAAAAAAAHClLG632226CADXr7wzmcayC2zVjGV7ycw046fyjMRKkrytZnIddkPBklyyGMm1Oc39oc+6vY3kBuaeNJIrSW6LucdYmqW6kdxwXzOPbUk6U2gm22rukFX91H+N5J4IbmIkV5JMPatyneY+Gpl6v3Ic22skV5IKazQylq3C/JK3qQhel5+5vyK57P5GctPPm3teBRp6Xpl8z/ArzDGSe8Zm7qoSTpe5x1hw7nEjuad9wozkSlI1LzPPq2rmTrllzc0yF25IoU91I7leuZlGciXphAKN5OYZvAxdg+zvjGW7fMzc386AmkZyJenHXDPflwQY/F7MVHagn6+RXAAAAAA4s+xp0yVAUuCAp02XcE0y+BUrAAAAAAAAAAAAAAAAAAAAKgqXmwcMc7vdcjqdxa63Wq2yWiu+n9vlcsnlKn72ApvNJovF4JQ4AAAAAAAAAAAAAAAAAIAyoUkUMGznzp0aMGBAset79eql5OTkCq9j8uTJevfdd4tdv2zZMsXGxlZ4HQAAAAAAAAAAAAAAAACA8kGTKGBYVFSU3nrrrWLXBwcHV0odo0aN0sMPP1zs+oYNG1ZKHQAAAAAAAAAAAAAAAACA8kGTKGBYQECAoqOjTZehiIgIRUREmC4DAAAAAAAAAAAAAAAA+E1xO12mSwCKZTVdAAAAAAAAAAAAAAAAAAAAAMofTaIAAAAAAAAAAAAAAAAAAABVEE2iAAAAAAAAAAAAAAAAAAAAVRBNogAAAAAAAAAAAAAAAAAAAFUQTaIAAAAAAAAAAAAAAAAAAABVkJfpAgBc3wps1Yxle8llLNtttRnJtVmdRnIlKeRsqpHcs143GMmVJL9zx43kui3mfgPi5x9qJNeac9JIriQVhjYwll3bdc5Irkv+RnIlKTPXzOtYmL+50+bCGg2N5IYUnDGSK0mW/PNGct02byO5kmQ9Y+aYC2s0MpIrSZaCXGPZ5/xqGsl1u91GciXJ4rYYya1tzTKSK0kZrkAjudXNvZTIkm/m3CDQmm8kV5IsbnOf6075hBnJ9fc2d77vZTXzWnK2wNzf2Wk181riZ/Dv7F1g5rWk0Ke6kVxJCnWb+ZxxOt/c37kgPNJYtgy9dh/LM/N9nCTV37/eSK7z1DEjuZLkFdvTSG6eu4aRXEmq5m/mPQMAAAAAgJIwkygAAAAAAAAAAAAAAAAAAEAVxEyiAAAAAAAAAAAAAAAAAABcIbfL3NVwgJIwkygAAAAAAAAAAAAAAAAAAEAVRJMoAAAAAAAAAAAAAAAAAABAFUSTKAAAAAAAAAAAAAAAAAAAQBVEkygAAAAAAAAAAAAAAAAAAEAVRJMoAAAAAAAAAAAAAAAAAABAFeRlugBc39asWaNly5bp8OHDcrvdCg8PV5s2bTRu3DiFhoZKkhITExUfH6+nnnqqwuqYN2+eUlJSLrtN3bp1tXnz5qvKyc7O1tKlS9W9e3fdeOONZd5/9+7dWrx4sfbs2aMzZ84oJCRE7du318CBAxUdHV3qcT7//HN9+eWXevTRR0u9j9Pp1JIlS/Txxx/rwIEDcrvdioyM1NixY9WuXbsyHwsAAAAAAAAAAAAAAAAAoGLRJApjFi1apNmzZyspKUljxoyR2+3W/v37tXbtWh0/ftzTJJqSkiKHw1GhtTzwwAPq3Lmz5/bq1au1bt06LV261LPMbrdfdU52drZSUlLUpEmTMjeJrly5UtOnT1eHDh305JNPKjw8XOnp6Vq7dq0GDx6sXbt2lXqsnTt3asmSJWVqEs3NzdXChQvVq1cvDR06VFarVW+++aYGDBigxYsX65ZbbinT8QAAAAAAAAAAAAAAAABVgdvpMl0CUCyaRGHM8uXL1atXL02aNMmzLC4uTo888ohcrv+9cLZo0aLCa6lVq5Zq1arluf3JJ5/IarXqpptuqvDs0vjPf/6j559/Xvfcc4+Sk5NlsVg863r06KEtW7ZUeA0+Pj7auHGjgoKCPMtuvfVW9ejRQ0uXLqVJFAAAAAAAAAAAAAAAAACuMVbTBeD6lZ2drbCwsEuus1r/99BMTEzUtGnTPLcnTZqkHj16aMeOHerZs6diYmLUr18/paamKjMzU2PHjlWbNm3UrVs3rV+/vtzqPXbsmMaPH6/Y2FjFxMTo4Ycf1r59+zzrX3vtNbVs2VL//ve/Pct+/PFHtW7dWrNnz1Zqaqq6du0qSRo7dqwiIyMVGRmp1NTUErOXLVsmi8WiiRMnFmkQvSAhIcHz3++9955+//vfq3379rr55pvVv39/7d2717N+3rx5SklJ0blz5zw19O/fv8QabDZbkQbRC8siIyN1/PjxEvcHAAAAAAAAAAAAAAAAAFQuZhKFMVFRUVq1apUiIiIUHx+vmjVrlnrfEydOKDk5WcOHD5eXl5eeffZZjR8/Xr6+vmrXrp369OmjN998UxMmTFCrVq1Ut27dq6o1KytLDz30kPz8/PTnP/9ZgYGBWr58uQYOHKiPPvpIoaGhGjhwoDZt2qQJEybonXfekZeXlx5//HHdcMMNGj16tCQpJSVFo0aN0rhx4xQbGytJxTbK/tKuXbvUsmVLhYSElLhtamqq7r33Xt1www3Kz8/XBx98oIcfflhr1qxRw4YN9cADD+jYsWNat26dli5dKkkKCAi4ovulsLBQX331ldq2bXtF+wMAAAAAAAAAAAAAAAAAKg5NojBm6tSpGjVqlKZMmSJJioiIUEJCgpKSkhQREXHZfbOysrRixQo1adJEknT8+HFNnz5dQ4cO1ciRIyVJ0dHR2rBhgzZu3KiBAwdeVa1Lly5Vdna2Vq9erdDQUEnSLbfcojvuuEOLFy/W448/LovFouTkZN19992aM2eOQkJC9M033+itt96S3W6XJDVv3lySVL9+/TJdyj49PV3R0dGl2nbUqFGe/3a5XLr11lu1d+9evfvuuxo3bpxq1aqlWrVqyWq1lqmGS/nb3/6m9PR0JSUlXdU4AAAAAAAAAAAAAAAAAIDyR5MojGnatKnWrVunf/7zn9q+fbt27dql5cuX65133tHKlSs9DZWXEhYW5mkQlaQGDRpIkjp27OhZ5nA4FBISomPHjl11rZ9++qliY2MVFBSkwsJCSZLVatXNN9+sr7/+2rNd3bp1NXnyZD355JPy8vLyXFa+PFzqMvOXcvDgQc2ZM0dffvmlTp065Vn+/fffl0sdF3z66aeaN2+eRowYoZYtW5br2AAAAAAAAAAAAAAAAACAq0eTKIyy2+2Ki4tTXFycJOmTTz7RsGHDNH/+fKWkpBS7n8PhKHLb29tbkhQYGHjR+Hl5eVdd5+nTp7Vnzx5FRUVdtO6GG24ocrtr166aPn26nE6n+vTpc9XZkhQeHq6jR4+WuF1OTo4GDx6skJAQTZo0SXXq1FG1atU0ZcqUcrkfLvjmm280evRo9ejRo8jMpQAAAAAAAAAAAAAAAACAawdNorimdO7cWc2aNdPBgwdNl1JEUFCQOnfurLFjx1607sKl5C945pln5HA4VFhYqOeff14zZ8686vz27dtrzZo1yszMVPXq1Yvdbs+ePTp27JheffVVNWvWzLP8zJkzqlWr1lXXIUk//PCDhg4dqtatW+vZZ58tlzEBAAAAAAAAAAAAAAAAAOWPJlEYc/LkSdWoUaPIstzcXKWlpenGG280VNWldezYUWvWrFHjxo3l5+dX7HYffPCB1q9fr7/97W/Ky8vTyJEjddttt6lbt26S/jfjaVln9ezfv7/ee+89zZw5UzNmzLho/ccff6z4+Hjl5uYWyZGkL774QkeOHFGTJk08y7y9vZWfn1+mGiTp+PHjGjx4sGrXrq25c+cWyQEAAAAAAAAAAAAAAACuR26ny3QJQLFoEoUxPXv2VEJCgjp16qSwsDClp6drxYoVOn36tAYOHGi6vCKSkpK0du1a9evXTwMGDFCdOnWUkZGhr776SuHh4UpKSlJ6erqmTZumvn37qnPnzpKkXr166c9//rNat26t0NBQ1axZUw6HQx988IEiIiJkt9sVGRl50Wykv9asWTNNnjxZ06dPV3p6unr37q3w8HClp6frgw8+0O7du7Vz507ddNNN8vPz0zPPPKM//OEPSk9P17x58xQeHl5kvMaNG6uwsFBLly5V69atFRAQoEaNGl22htzcXA0dOlSnT5/Wk08+qf3793vW2e12tWjR4grvXQAAAAAAAAAAAAAAAABARaBJFMaMGjVKW7ZsUXJysjIyMhQcHKzIyEi99tpr6tChg+nyiggODtYbb7yhl156SbNmzVJmZqZCQ0PVqlUr3XbbbZKkJ598Ug6HQxMnTvTsN2XKFH3++ed66qmnNH/+fFmtVs2YMUNz5sxRUlKS8vPztWnTJkVERJRYw8MPP6zIyEgtXrxY06ZNU05OjkJCQtShQwf9v//3/yRJNWrU0Msvv6wXXnhBI0aMUIMGDfTMM8/ob3/7W5GxEhIS9NBDD2nhwoU6deqUbr75Zi1fvvyy+SdPntR//vMfSdLw4cOLrKtbt642b95c8h0JAAAAAAAAAAAAAAAAAKg0Frfb7TZdBIDrV86588ayvWRuqm+31WYkNyvPaSRXkmqcTTWSezboBiO5kuR37oSRXLfFaiRXklz+oUZyvY99ayRXkgpDGxjLtrgKjeS67P5GciXppxwzr91h/uZ+W+XjzjeSaykw9x5tyTeT7bZ5G8mVJKuh+9vlG2QkV5IsBbnGss/51TSSa/Ljt8ViMZLrm59lJFeSMqyBRnKrm3spkS3H0Pmn1dz7pMVt7nPdKbuZc19/b3Pn+15WM68l5wrM/Z2dLjOv3X4G/87ehWbOS5zefkZyJcnqNvN9yWkzp/qSpBBvg5fAM/TafSzPzPdxklT7P+uN5DpPHTOSK0lesT2N5LoCahjJlaRq/mbOPwEAAABcG06/Msl0CZAUPDzZdAnXJHPfNgIAAAAAAAAAAAAAAAAAAKDCcLl5XBfcbreczuJnBLBarbJazfRMu1wuuVzF/3reZrNVyqw/hYXFz0ZnsVhks5n7pT0AAAAAAAAAAAAAAAAAoOxoEsV1YefOnRowYECx63v16qXkZDPTDU+ePFnvvvtuseuXLVum2NjYCq8jKiqq2HV169bV5s2bK7wGAAAAAAAAAAAAAAAAAED5oUkU14WoqCi99dZbxa4PDg6uxGqKGjVqlB5++OFi1zds2LBS6rjc/WO32yulBgAAAAAAAAAAAAAAAABA+aFJFNeFgIAARUdHmy7jkiIiIhQREWG6jGv2/gEAAAAAAAAAAAAAAACuZS6n03QJQLGspgsAAAAAAAAAAAAAAAAAAABA+aNJFAAAAAAAAAAAAAAAAAAAoAqiSRQAAAAAAAAAAAAAAAAAAKAKokkUAAAAAAAAAAAAAAAAAACgCqJJFAAAAAAAAAAAAAAAAAAAoAryMl0AgOtbVp7LWLavl8VYtp+cRnLznW4juZJUGHyDkVzfs6eM5EpSZrUaRnJ9TD62j31rJDevVgsjuZKUk2/m+SxJ+S67kdycM+aOuZrNzOPbP+tHI7mSlFvdzOun1aeakVxJsnn7Gsm1njttJFeS5DZzTnTGFmAkV5J8qzmMZctl5pzIcWyvkVxJOlunlZlgi7nfpubkm3lehSjPSK4kWQrOG8l1BYYbyZVk7PVTkqp7m8m1Fpw1Eywpz9vfSK6hU0BJUjVvM69jZwy9hklSzfNmPkfnOsycA0qSt9VmJDc7P99IriR5Wc39r4FAbzPZ1bzMPa/OxPQwkhtYmG0kV5LO2YOM5PqdOWokV5LyXGa+L6kWWN1ILgAAAADgt4MmUQAAAAAAAAAAAAAAAAAArpDbZe7HiUBJuNw8AAAAAAAAAAAAAAAAAABAFUSTKAAAAAAAAAAAAAAAAAAAQBVEkygAAAAAAAAAAAAAAAAAAEAVRJMoAAAAAAAAAAAAAAAAAABAFUSTKAAAAAAAAAAAAAAAAAAAQBXkZboAXN/WrFmjZcuW6fDhw3K73QoPD1ebNm00btw4hYaGSpISExMVHx+vp556qlJqysjI0MKFC7VlyxYdPXpU3t7eatGihe655x7dd999stlslVLHr/3www9avHixvvrqK+3fv1+NGjXSunXrSrWv2+3WokWL9Pe//10ZGRlq3ry5nnjiCd10002lzu/fv7927tzpuR0QEKDGjRvrD3/4g7p161bWwwEAAAAAAAAAAAAAAAAAVDCaRGHMokWLNHv2bCUlJWnMmDFyu93av3+/1q5dq+PHj3uaRFNSUuRwOCqlph9++EEDBgyQ0+nUoEGDFBUVpfz8fH322WeaMWOGgoODjTVE7t+/X1u3blWrVq3kcrnkdrtLve+iRYs0d+5cjR8/XpGRkVq5cqUGDx6s999/X/Xq1Sv1OG3atNHEiRMlSdnZ2Xrrrbc0evRorVixQm3bti3zMQEAAAAAAAAAAAAAAAAAKg5NojBm+fLl6tWrlyZNmuRZFhcXp0ceeUQul8uzrEWLFpVW0/jx4+V0OvX2228rPDzcs7xLly7q16+fzpw5c1Xj5+bmysfH54r2TUxM9DSoTpo0Sfv27SvVfnl5eXr11Vc1ePBgJSUlSZLatm2rO++8U4sXL9bTTz9d6hocDkeR2Uc7duyoTp06adOmTTSJAgAAAAAAAAAAAAAA4LrkdrpK3ggwxGq6AFy/srOzFRYWdsl1Vuv/HpqJiYmaNm2a5/akSZPUo0cP7dixQz179lRMTIz69eun1NRUZWZmauzYsWrTpo26deum9evXl7qe3bt3a+/evRo2bFiRBtEL6tSpo8jISM/tXbt2qW/fvoqJiVFsbKyeeOIJZWZmetanpqYqMjJS77zzjqZMmaLY2Fg98MADpa7n1355n5TFF198oZycHHXv3t2zzG6367bbbtO2bduuuB5J8vLyko+PjwoLC69qHAAAAAAAAAAAAAAAAABA+WMmURgTFRWlVatWKSIiQvHx8apZs2ap9z1x4oSSk5M1fPhweXl56dlnn9X48ePl6+urdu3aqU+fPnrzzTc1YcIEtWrVSnXr1i1xzJ07d0qSOnfuXOK2+/bt06BBgxQbG6uXX35ZJ0+e1OzZs3XgwAGtWrVKNpvNs+2cOXMUFxen2bNnF5khtbIcOnRIktSoUaMiyxs3bqylS5eWaXZTt9vtaQjNzs7WG2+8ofT0dN1+++3lWzQAAAAAAAAAAAAAAAAA4KrRJApjpk6dqlGjRmnKlCmSpIiICCUkJCgpKUkRERGX3TcrK0srVqxQkyZNJEnHjx/X9OnTNXToUI0cOVKSFB0drQ0bNmjjxo0aOHBgifWkp6dL+nnG0JIsWLBANWvW1IIFC+Tt7S1Jql27toYMGaKtW7cqMTHRs22zZs303HPPlThmRcnOzpbdble1atWKLHc4HHK73crKyip1k+jWrVsVFRXluW2z2TRp0iS1a9euXGsGAAAAAAAAAAAAAAAAAFw9mkRhTNOmTbVu3Tr985//1Pbt27Vr1y4tX75c77zzjlauXKnmzZsXu29YWJinQVSSGjRoIEnq2LGjZ5nD4VBISIiOHTtW7rXv3r1bPXr08DSISlKnTp3kcDj0r3/9q0iTaHx8fJnGdjqdcrvdnts2m00Wi+Wqay4Pbdu21RNPPCFJOnv2rLZu3ark5GQ5HA716tXLcHUAAAAAAAAAAAAAAAAAgF+iSRRG2e12xcXFKS4uTpL0ySefaNiwYZo/f75SUlKK3c/hcBS5faFZMzAw8KLx8/LySlVLeHi4JCktLU3169e/7LbZ2dkKDQ29aHloaKiysrIuWlYWSUlJ2rlzp+f2smXLFBsbW6YxfsnhcCg/P195eXlFZhPNzs6WxWJRUFBQqccKDAxUdHS053aHDh10+PBhzZw5U/fee+8108wKAAAAAAAAAAAAAAAAAKBJFNeYzp07q1mzZjp48GClZ7dv316StH379hKbRIOCgnTq1KmLlp86deqipsuyNk4+88wzOnv2rOd2w4YNy7T/rzVq1EiSdPjwYTVr1syz/NChQ6pTp06pLzVfnMaNG2vLli06deqUatSocVVjAQAAAAAAAAAAAAAAAADKj9V0Abh+nTx58qJlubm5SktLM9Js2K5dO8XExGjBggU6fvz4RevT0tL03XffSfr5suubNm1SYWGhZ/2nn36q7OxstW3b9qrqaNSokaKjoz3/AgICrmq8Nm3aKCAgQP/4xz88ywoKCvTRRx+pS5cuVzW2JO3fv1/e3t5XXScAAAAAAAAAAAAAAAAAoHwxkyiM6dmzpxISEtSpUyeFhYUpPT1dK1as0OnTpzVw4EAjNc2aNUv9+/dX7969NWjQIEVFRSk/P1+7du3SypUrNXPmTEVGRurRRx9V3759NWzYMPXv318nT57U7NmzFRMTo7i4uAqp7fz589q6dask6ciRI8rJydGHH34o6edZUENCQiRJAwcO1NGjR7VhwwZJUrVq1TRs2DDNmzdPISEhatq0qV5//XVlZmZqyJAhZaohOztbe/bskSSdPXtWW7du1datW9WnT5+rnpEUAAAAAAAAAAAAAAAA+C1yO12mSwCKRZMojBk1apS2bNmi5ORkZWRkKDg4WJGRkXrttdfUoUMHIzXVr19f7777rhYtWqTXX39daWlpstvtatGihSZPnqyEhARJUsuWLbVkyRLNmTNHo0ePlp+fnxITEzVx4kTZbLYKqe3UqVMaO3ZskWUXbi9btkyxsbGSJJfLJafTWWS7oUOHyu12a8mSJcrIyFDz5s21ePFi1atXr0w1fPHFF3rwwQclST4+PqpXr54ef/xx9e/f/0oPCwAAAAAAAAAAAAAAAABQQSxut9ttuggA168jp88ay/b1shjL9rOZeek9nmvuJT/Mt2IaqEtiPXvKSK4kZdlDjOT6mHxsp39rJDevVgsjuZKUk+8seaMKku8085zOKTD3K7hqNjOP73r5R43kSlJu9RuM5Fot5l5LbM48I7nWc6eN5EqSpdDMMWcFlu1HQ+XJ18tqLLvAZeb1MzDtKyO5knS2TisjudXyzxjJlaQfC3yN5N5gN/N8liRrzgkjuc7AcCO5kmRxmzsvcXmbeYxZC84byZWkPG9/I7lOQ6/bkuRlNXNOdCbf3GO75nkz575nHRFGciXJ29Df+acz+UZyJSnEx9z8EYHeZu7vTIPPK1OPscDCbCO5knTeHmQk1++Muc/vLv9QI7nVAqsbyQUAAABQ1PFZY0veCBUubPzLpku4Jpn7v3IAAAAAAAAAAAAAAAAAAACoMFxuHtcFt9t90SXYf8lqtcpqrfie6Wuljl8rLCwsdp3FYpHNZmYGSAAAAAAAAAAAAAAAAADAlaNJFNeFnTt3asCAAcWu79Wrl5KTk6+bOn4tKiqq2HV169bV5s2bK7EaAAAAAAAAAAAAAAAAAEB5oEkU14WoqCi99dZbxa4PDg6+rur4tcvVZLfbK7ESAAAAAAAAAAAAAAAAAEB5oUkU14WAgABFR0ebLuOaqePXrsWaAAAAAAAAAAAAAAAAgN8Ct8tlugSgWFbTBQAAAAAAAAAAAAAAAAAAAKD80SQKAAAAAAAAAAAAAAAAAABQBdEkCgAAAAAAAAAAAAAAAAAAUAXRJAoAAAAAAAAAAAAAAAAAAFAF0SQKAAAAAAAAAAAAAAAAAABQBXmZLgDA9a2GV4G5cLfLWHS+fI3kFroKjeRKkvfx/xrJdQbVNpIrST5eFiO5XlYzuZL0Q2ATI7khTnPP5yAvc9nW/NNGcmsEhhrJlSRrwXkjuU6fWkZyJSnP6TaSm3He3HtGiK+3kdxc75pGciUpNMBMrp/V3O8GnS4zj21J8s/83kjuXt9mRnIlKSTXaSTXx+ZvJFeSAuxmcjMMnetLkiOkoZFcmzPPSK4kuWUzlp1p6OOsr5e555VvwVkjud+dM3NuIElNA8y8X9lthl7EJJ11RBjJ9Tb4WdYrL9tIbrifoZNASdW8zJ0HFho6DzyWY+57yOZBZh7f1vNZRnIlya8w30iu2zfISK4kWZxmjvnUmXNGciUpNNDPWDYAAAAAoPSYSRQAAAAAAAAAAAAAAAAAAKAKYiZRAAAAAAAAAAAAAAAAAACukMvg1S+BkjCTKAAAAAAAAAAAAAAAAAAAQBVEkygAAAAAAAAAAAAAAAAAAEAVRJMoAAAAAAAAAAAAAAAAAABAFUSTKAAAAAAAAAAAAAAAAAAAQBVEkygAAAAAAAAAAAAAAAAAAEAVRJMorjlr1qzR/fffr7Zt26pNmzbq3r27nnzySZ06dcqzTWJioqZNm1ZpNWVkZCg5OVl33HGHoqOj1aZNG/Xr10+rV6+W0+mslBrcbrcWLlyo+Ph4xcTE6MEHH9SePXtKte+WLVvUq1cvtWzZUnFxcZo7d+4V1/3aa68pMjJSkydPvqL9AQAAAAAAAAAAAAAAAACVw8t0AcAvLVq0SLNnz1ZSUpLGjBkjt9ut/fv3a+3atTp+/LhCQ0MlSSkpKXI4HJVS0w8//KABAwbI6XRq0KBBioqKUn5+vj777DPNmDFDwcHB6tatW4XXsWjRIs2dO1fjx49XZGSkVq5cqcGDB+v9999XvXr1it1vz549GjFihH73u99p3LhxOnDggF566SWdP39eEydOLHMda9askSRt2LBBTz/9tOx2+xUfEwAAAAAAAAAAAAAAAACg4tAkimvK8uXL1atXL02aNMmzLC4uTo888ohcLpdnWYsWLSqtpvHjx8vpdOrtt99WeHi4Z3mXLl3Ur18/nTlz5qrGz83NlY+Pz2W3ycvL06uvvqrBgwcrKSlJktS2bVvdeeedWrx4sZ5++uli9503b56aN2+uWbNmSZI6d+4st9utOXPmaMiQIapRo0apaz18+LC++eYbdezYUTt27NDHH3+s22+/vdT7AwAAAAAAAAAAAAAAAFWN2+kqeSPAEC43j2tKdna2wsLCLrnOav3fw/XXl5ufNGmSevTooR07dqhnz56KiYlRv379lJqaqszMTI0dO1Zt2rRRt27dtH79+lLXs3v3bu3du1fDhg0r0iB6QZ06dRQZGem5vWvXLvXt21cxMTGKjY3VE088oczMTM/61NRURUZG6p133tGUKVMUGxurBx54oMQ6vvjiC+Xk5Kh79+6eZXa7Xbfddpu2bdt22X2//fZb3XrrrUWWderUSQUFBdq+fXuJ2b+0bt06WSwWTZs2TTVq1NDatWvLtD8AAAAAAAAAAAAAAAAAoPLQJIprSlRUlFatWqXVq1frxIkTZdr3xIkTSk5O1vDhwzVr1iz9+OOPGj9+vB577DE1bdpU8+bNU1RUlCZMmKAjR46UasydO3dK+nn2zZLs27dPgwYNkr+/v15++WWNHz9eW7Zs0dChQ+V0OotsO2fOHLndbs2ePVsTJkwocexDhw5Jkho1alRkeePGjXX06FHl5uYWu29eXt5Fl4S/cPvgwYMlZv/SunXr1K5dO9WrV0/du3fXxx9/fNUzqQIAAAAAAAAAAAAAAADAb83mzZt19913Kzo6WnfccYfefvvtEve5MMngr//16dPnom2/+OILPfjgg4qJiVFCQoIWLlwot9td5jq53DyuKVOnTtWoUaM0ZcoUSVJERIQSEhKUlJSkiIiIy+6blZWlFStWqEmTJpKk48ePa/r06Ro6dKhGjhwpSYqOjtaGDRu0ceNGDRw4sMR60tPTJf08Y2hJFixYoJo1a2rBggXy9vaWJNWuXVtDhgzR1q1blZiY6Nm2WbNmeu6550oc84Ls7GzZ7XZVq1atyHKHwyG3262srKxiL1lfv3597d27t8iyPXv2SPr5PiutvXv36vvvv9egQYMkST169NDy5cv1f//3f7r//vtLPQ4AAAAAAAAAAAAAAAAA/Jbt3r1bo0aN0v3336/Jkyfrs88+05NPPil/f3/deeedJe4/btw4xcbGem77+/sXWf/DDz9oyJAhuvXWW/XHP/5R3333nWbNmiWbzaYhQ4aUqVZmEsU1pWnTplq3bp0WLlyoAQMGKDAwUMuXL9fdd9+tb7/99rL7hoWFeRpEJalBgwaSpI4dO3qWORwOhYSE6NixY+Ve++7du9W1a1dPg6j082XdHQ6H/vWvfxXZNj4+vtzzi/PQQw9p27ZtWrp0qTIzM7V792699NJLstlsZRpn3bp18vb29ryI3XTTTapXrx6XnAcAAAAAAAAAAAAAAABwXXnllVcUExOjadOmqUOHDvrjH/+o3/3ud5o7d26p9q9fv75uuukmz79f9r1J0uLFixUcHKw5c+bolltuUVJSkgYPHqwFCxYoPz+/TLXSJIprjt1uV1xcnJ588km99957+tvf/qbc3FzNnz//svs5HI4ity80awYGBl40fl5eXqlqCQ8PlySlpaWVuG12drZCQ0MvWh4aGnrRjJ2X2u5yHA6H8vPzL6o7OztbFotFQUFBxe573333aeDAgXrhhRcUGxurpKQk9e3bV0FBQQoLCytVvsvl0vr169W+fXtZrVZlZ2crOztbXbt21c6dOz0zrgIAAAAAAAAAAAAAAABAVZafn6/PP//8ohlD77rrLh08eFCpqalXnbFt2zZ17dpVdru9yPjZ2dn68ssvyzQWl5vHNa9z585q1qyZDh48WOnZ7du3lyRt375d9evXv+y2QUFBOnXq1EXLT506dVETp8ViKVMdjRo1kiQdPnxYzZo18yw/dOiQ6tSpU+yl5iXJarVq8uTJGj16tI4cOaI6deqosLBQL774olq1alWq/M8++0wnTpzQiRMndPPNN1+0fv369Z7L0AMAAAAAAAAAAAAAAABAZevatetl12/atKlccn788UcVFBR4erouaNy4saSfe7oiIiIuO8bTTz+txx57TNWrV1fXrl01fvx4Va9eXZJ07tw5paWlXTR+o0aNZLFYdOjQoSKXqi8JTaK4ppw8eVI1atQosiw3N1dpaWm68cYbK72edu3aKSYmRgsWLNBtt9120cybaWlpys7OVmRkpNq2batNmzZp0qRJ8vL6+an16aefKjs7W23btr2qOtq0aaOAgAD94x//8DSJFhQU6KOPPlKXLl1KNUZgYKBn35dfflkRERHq2LFjqfZdu3at/Pz89Ne//lVWa9EJiJ9//nmtXbuWJlEAAAAAAAAAAAAAAABcl9xOl+kSUIkuXFX611e+vnD711ed/iW73a7f//736tSpkxwOh7766istWLBA+/bt0+rVq+Xt7a0zZ85ccny73S5fX9/Ljn8pNInimtKzZ08lJCSoU6dOCgsLU3p6ulasWKHTp09r4MCBRmqaNWuW+vfvr969e2vQoEGKiopSfn6+du3apZUrV2rmzJmKjIzUo48+qr59+2rYsGHq37+/Tp48qdmzZysmJkZxcXFXVUO1atU0bNgwzZs3TyEhIWratKlef/11ZWZmasiQIZ7tdu7cqaSkJD3//PO69957JUl79+7Vzp071bx5c+Xm5mrz5s16//33tWjRItlsthKz8/LytGHDBt1+++265ZZbLlrfu3dvPffcczp06NBF3esAAAAAAAAAAAAAAAAAUBmuZqbQM2fO6Pjx4yVuV69evSvOkKSwsDA9/fTTntvt27dXkyZNNGzYMG3YsEF33XXXVY1/KTSJ4poyatQobdmyRcnJycrIyFBwcLAiIyP12muvqUOHDkZqql+/vt59910tWrRIr7/+utLS0mS329WiRQtNnjxZCQkJkqSWLVtqyZIlmjNnjkaPHi0/Pz8lJiZq4sSJpWrGLMnQoUPldru1ZMkSZWRkqHnz5lq8eHGRFx632y2n0ymX63+/TvD29tZHH32k+fPnS5JatWql5cuXq3Xr1qXK/fjjj3XmzBlP0+mv9ejRQy+88ILWrl2rsWPHXvkBAgAAAAAAAAAAAAAAAIABH374oaZMmVLiduvXr1dQUJAkeWb8vCA7O1uSPOtLKy4uTn5+fvrmm2901113KTAw8JLj5+fn6/z582Ue3+J2u91l2gMAylHemUxz4W5zU33ne/kayT1xrtBIriTVP3vISK4zqLaRXEnKswcayfWyWozkSlJaToGR3BCfq2/Gv1K+FqexbOu500Zynf6hRnIlyVpw3kiu2+ZtJFeSctxmsjPOm3tsh/iaeU7nFpr7aBRazUyu22ru9dPpMnd/+5z+3kjuPpk7LwnxNfMbUR+bufOS6/HCPg67mee0zZlnJNe0004zzytfL6uRXEnyLTxrJPe7c+bOxZoGmHm/ypHdSK5k7jOlt8HPsl552UZyz3kFGMmVpGoGX0tMnQceOG3u/ap5kJnHty37mJFcSXJ7m/n+0233M5L7c7iZM9AzNnOvJaGBBu9vAAAA4Bpz5JlhpkuApLpTX62UnPz8fLVp00YTJkwocnXszZs3a/jw4dq0aZMiIiJKPZ7b7VabNm300EMPacKECZKk+Ph43X777Zo8ebJnu++++0533323li1bptjY2FKPb+6bIAAAAAAAAAAAAAAAAAAAgN8Qu92u2NhY/d///V+R5evXr1fjxo3L1CAqSVu2bNG5c+cUHR3tWdalSxdt2rRJBQX/m6xr/fr1cjgcpb6C9AVcbh7XrQuXZi+O1WqV1VrxfdSm6zCdDwAAAAAAAAAAAAAAAAC/JcOHD9eAAQP09NNPq3v37vr888+1bt06vfjii0W2a9Gihe699149//zzkqTk5GRZLBbddNNNcjgc2rt3r1599VW1bNlS3bp18+w3ZMgQrV27Vn/605/0+9//Xv/973+1ePFiPfbYY7Lby3YlIppEcd3auXOnBgwYUOz6Xr16KTk5ucrX8e677+qJJ54odv2oUaM0evToCssHAAAAAAAAAAAAAAAAgN+Sdu3aad68eXrppZf01ltvqU6dOnr22WfVvXv3Its5nU65XC7P7caNG+v111/Xm2++qdzcXIWHh+v+++/XmDFj5OX1v3bO+vXra/HixUpOTtYf/vAHhYSEaMyYMRo8eHCZa7W43W73lR8q8NuVk5Ojw4cPF7s+ODi4zFP//hbrOH36tFJTU4tdHxYWpvDw8ArLzzuTWWFjl8jtKnmbCpLv5Wsk98S5QiO5klT/7CEjuc6g2kZyJSnPHmgk18tqMZIrSWk5BSVvVAFCfGxGciXJ11L8bMwVzXrutJFcp3+okVxJshacN5LrtnkbyZWkHLeZ7Izz5h7bIb5mntO5heY+GoVWM5Prtpp7/XS6zN3fPqe/N5K7T+bOS0J8zfxG1Mdm7rzE3Nm+OQ67mee0zZlnJNe0004zzytfL3NX+/AtPGsk97tz5s7FmgaYeb/KUdlmAihPpj5Tehv8LOuVl20k95xXgJFcSapm8LXE1HnggdPm3q+aB5l5fNuyjxnJlSS3t5nvP912PyO5P4ebOQM9YzP3WhIaaPD+BgAAAK4xR54ZZroESKo79VXTJVyTmEkU162AgABFR0ebLsN4HcHBwQoODjaWDwAAAAAAAAAAAAAAAPyWuV3X49QF+K0w93NhAAAAAAAAAAAAAAAAAAAAVBiaRAEAAAAAAAAAAAAAAAAAAKogmkQBAAAAAAAAAAAAAAAAAACqIJpEAQAAAAAAAAAAAAAAAAAAqiCaRAEAAAAAAAAAAAAAAAAAAKogL9MFALi+5VqrGcv2O5tuLNvL4Wckt5a/t5FcSXIVBhjJtR7+wkiuJNmb3GImuNBpJldS7QAzj+1zBS4juZLk8jL3vLLYzdzfhQZ/Z+RtM3N/W3NOGsmVJH9HLSO5ud7m/s7+NreRXLvN3DEXGMq1F+QaSjb7i0VnYLiR3HCXufcMu81iJNfU81ky935V6DJ3zE63mex8mXtse1nNPLYl6acMM6+hTULMfY6WofeNEB9fI7mSZHGdN5IbYOh1W5KynWae0/lOc6+fgXZ/I7m+znwjuZJ0tsBuLNtfZo67hq+5/x1iKcgxkuu2mfs75/rXNJJrdxcayZWkAouZx1iAwWMesupLY9mL+7Y2lg0AAAAAvzXMJAoAAAAAAAAAAAAAAAAAAFAFMZMoAAAAAAAAAAAAAAAAAABXyO00d/VLoCTMJAoAAAAAAAAAAAAAAAAAAFAF0SQKAAAAAAAAAAAAAAAAAABQBdEkCgAAAAAAAAAAAAAAAAAAUAXRJAoAAAAAAAAAAAAAAAAAAFAFeZkuAPi1NWvWaNmyZTp8+LDcbrfCw8PVpk0bjRs3TqGhoZKkxMRExcfH66mnnqqUmjIyMrRw4UJt2bJFR48elbe3t1q0aKF77rlH9913n2w2W4XX4Ha7tWjRIv39739XRkaGmjdvrieeeEI33XRTiftu2bJFc+fO1f79+xUaGqrevXtr5MiRpa47NTVVXbt29dy2WCyqWbOm2rdvr3Hjxqlu3bpXelgAAAAAAAAAAAAAAAAAgApCkyiuKYsWLdLs2bOVlJSkMWPGyO12a//+/Vq7dq2OHz/uaRJNSUmRw+GolJp++OEHDRgwQE6nU4MGDVJUVJTy8/P12WefacaMGQoODla3bt0qvI5FixZp7ty5Gj9+vCIjI7Vy5UoNHjxY77//vurVq1fsfnv27NGIESP0u9/9TuPGjdOBAwf00ksv6fz585o4cWKZahg3bpxiY2Plcrn0448/au7cufrDH/6gNWvWVEqjLAAAAAAAAAAAAAAAAACg9GgSxTVl+fLl6tWrlyZNmuRZFhcXp0ceeUQul8uzrEWLFpVW0/jx4+V0OvX2228rPDzcs7xLly7q16+fzpw5c1Xj5+bmysfH57Lb5OXl6dVXX9XgwYOVlJQkSWrbtq3uvPNOLV68WE8//XSx+86bN0/NmzfXrFmzJEmdO3eW2+3WnDlzNGTIENWoUaPUtdavX98zc2mbNm0UEBCgkSNH6vDhw7rxxhtLPQ4AAAAAAAAAAAAAAABQVbidrpI3Agyxmi4A+KXs7GyFhYVdcp3V+r+Ha2JioqZNm+a5PWnSJPXo0UM7duxQz549FRMTo379+ik1NVWZmZkaO3as2rRpo27dumn9+vWlrmf37t3au3evhg0bVqRB9II6deooMjLSc3vXrl3q27evYmJiFBsbqyeeeEKZmZme9ampqYqMjNQ777yjKVOmKDY2Vg888ECJdXzxxRfKyclR9+7dPcvsdrtuu+02bdu27bL7fvvtt7r11luLLOvUqZMKCgq0ffv2ErMvx9/fX5JUWFh4VeMAAAAAAAAAAAAAAAAAAMofTaK4pkRFRWnVqlVavXq1Tpw4UaZ9T5w4oeTkZA0fPlyzZs3Sjz/+qPHjx+uxxx5T06ZNNW/ePEVFRWnChAk6cuRIqcbcuXOnpJ9n3yzJvn37NGjQIPn7++vll1/W+PHjtWXLFg0dOlROp7PItnPmzJHb7dbs2bM1YcKEEsc+dOiQJKlRo0ZFljdu3FhHjx5Vbm5usfvm5eXJbrcXWXbh9sGDB0vM/iWXy6XCwkLl5+fr4MGDSklJUaNGjdSkSZMyjQMAAAAAAAAAAAAAAAAAqHhcbh7XlKlTp2rUqFGaMmWKJCkiIkIJCQlKSkpSRETEZffNysrSihUrPA2Lx48f1/Tp0zV06FCNHDlSkhQdHa0NGzZo48aNGjhwYIn1pKenS/p5xtCSLFiwQDVr1tSCBQvk7e0tSapdu7aGDBmirVu3KjEx0bNts2bN9Nxzz5U45gXZ2dmy2+2qVq1akeUOh0Nut1tZWVnFXrK+fv362rt3b5Fle/bskfTzfVYWjz32WJHbderU0aJFi2Sz2co0DgAAAAAAAAAAAAAAAACg4jGTKK4pTZs21bp167Rw4UINGDBAgYGBWr58ue6++259++23l903LCysyIyWDRo0kCR17NjRs8zhcCgkJETHjh0r99p3796trl27ehpEpZ8v6+5wOPSvf/2ryLbx8fHlnl+chx56SNu2bdPSpUuVmZmp3bt366WXXrqixs7x48frrbfe0urVqzV//nyFhYXpkUce8TTTAgAAAAAAAAAAAAAAAACuHTSJ4ppjt9sVFxenJ598Uu+9957+9re/KTc3V/Pnz7/sfg6Ho8jtC82agYGBF42fl5dXqlrCw8MlSWlpaSVum52drdDQ0IuWh4aGXjRj56W2uxyHw6H8/PyL6s7OzpbFYlFQUFCx+953330aOHCgXnjhBcXGxiopKUl9+/ZVUFCQwsLCylRHvXr1FB0drZiYGHXr1k2vvPKK0tPT9dprr5VpHAAAAAAAAAAAAAAAAABAxaNJFNe8zp07q1mzZjp48GClZ7dv316StH379hK3DQoK0qlTpy5afurUqYuaOC0WS5nqaNSokSTp8OHDRZYfOnRIderUKfZS85JktVo1efJkffbZZ3r//fe1Y8cO9enTRxkZGWrVqlWZ6vi1kJAQBQcHa//+/Vc1DgAAAAAAAAAAAAAAAACg/NEkimvKyZMnL1qWm5urtLQ01ahRo9LradeunWJiYrRgwQIdP378ovVpaWn67rvvJElt27bVpk2bVFhY6Fn/6aefKjs7W23btr2qOtq0aaOAgAD94x//8CwrKCjQRx99pC5dupRqjMDAQDVr1kwOh0PLly9XRESEOnbseFV1nTx5UqdPn1ZwcPBVjQMAAAAAAAAAAAAAAAAAKH9epgsAfqlnz55KSEhQp06dFBYWpvT0dK1YsUKnT5/WwIEDjdQ0a9Ys9e/fX71799agQYMUFRWl/Px87dq1SytXrtTMmTMVGRmpRx99VH379tWwYcPUv39/nTx5UrNnz1ZMTIzi4uKuqoZq1app2LBhmjdvnkJCQtS0aVO9/vrryszM1JAhQzzb7dy5U0lJSXr++ed17733SpL27t2rnTt3qnnz5srNzdXmzZv1/vvva9GiRbLZbGWq44cfftCePXvkdruVnp6uxYsXy2KxqE+fPld1fAAAAAAAAAAAAAAAAMBvlcvlMl0CUCyaRHFNGTVqlLZs2aLk5GRlZGQoODhYkZGReu2119ShQwcjNdWvX1/vvvuuFi1apNdff11paWmy2+1q0aKFJk+erISEBElSy5YttWTJEs2ZM0ejR4+Wn5+fEhMTNXHixDI3Y17K0KFD5Xa7tWTJEmVkZKh58+ZavHix6tWr59nG7XbL6XQWeePx9vbWRx99pPnz50uSWrVqpeXLl6t169ZlrmHOnDme/w4ODlazZs20dOlS3XzzzVdxZAAAAAAAAAAedVJRAAEAAElEQVQAAAAAAACAimBxu91u00UAuH5lnT1vLNvvbLqx7EJHLSO5Jl/xvbOOGMm1pO03kitJzia3mAl2Oc3kSnLZ/Yzknisw96ssP2+rsWxbXo6R3HxvfyO5kuTtyjeSa805aSRXkpyG3jNO5RmJlSSFVjOTWyBzz2dT7E6Df2iT3GbeNzJchh7ckuw2i5Fcf5u5E9BCQ8/pQpe5Y7ZZzfydnQaP2cvQMUvStydzjeQ2CTH3WuKXm2Ek94Qt2EiuJNW0mvnewm3zNpIrSdkuc9mmBHqZeR2zOAuM5ErSWdmNZfvLzOe6EwXm5swIs5j5/G7JN/fda26gmc+ydnehkVxJKrCYeYx5GzzmEWsPGMte3LfsE2EAAAAAFen7iWaukIyiGsxcarqEa9L1939BAQAAAAAAAAAAAAAAAAAArgNcbh7XrQuXZi+O1WqV1VrxfdSm6zCdDwAAAAAAAAAAAAAAAACoGDSJ4rq1c+dODRgwoNj1vXr1UnJycpWv491339UTTzxR7PpRo0Zp9OjRFZYPAAAAAAAAAAAAAAAAAKgYNIniuhUVFaW33nqr2PXBwcHXRR0JCQmXzQ8LC6vQfAAAAAAAAAAAAAAAAABAxaBJFNetgIAARUdHmy7DeB3BwcGV1hALAAAAAAAAAAAAAAAAAKg8NIkCAAAAAAAAAAAAAAAAAHCF3E6X6RKAYllNFwAAAAAAAAAAAAAAAAAAAIDyR5MoAAAAAAAAAAAAAAAAAABAFUSTKAAAAAAAAAAAAAAAAAAAQBVEkygAAAAAAAAAAAAAAAAAAEAV5GW6AADXt3+l5RjLbl6jprFse4HLSG5QzhEjuZJUGFTHSK53wTkjuZKU4/Y2kutlsxvJlSSby20m12IkVpJ04lyhsexwLzO/96mWk24kV5LkNvMYs7jM/Z0LDP2uq4bd3DG7LWY+pnyfmW8kV5KCq9mM5Ib4+hjJlSSnoeezJNldZv7Woe7zRnIl6cBZM+cHNXzNPLYlySUz59zBXmZyJSnHaeb+Nvk5w5J31lj2Tf4hRnJPO82d7/v6BBrJ9XEbPOF3mntOm5KT7zSSa+7MQHJYDf2dLQYf2wbvcLfN0PclBp/OtiP/MZLrrN3MSK4k+Zw9YSTX7W3uM061fDPfQ1oK84zkStJLd5t7jKVlmjkPrF3d30guAAAAAFwNZhIFAAAAAAAAAAAAAAAAAACogphJFAAAAAAAAAAAAAAAAACAK+R2mrk6C1AazCQKAAAAAAAAAAAAAAAAAABQBdEkCgAAAAAAAAAAAAAAAAAAUAXRJAoAAAAAAAAAAAAAAAAAAFAF0SQKAAAAAAAAAAAAAAAAAABQBdEkCgAAAAAAAAAAAAAAAAAAUAV5mS4A+LU1a9Zo2bJlOnz4sNxut8LDw9WmTRuNGzdOoaGhkqTExETFx8frqaeeqpSaMjIytHDhQm3ZskVHjx6Vt7e3WrRooXvuuUf33XefbDZbhdewcuVKbdu2TV999ZVOnz6tl19+WXfeeWep9j148KCeffZZffnll/L399c999yjP/7xj7Lb7aXa//PPP9eAAQM8t202m8LDw9WlSxf98Y9/VHBw8BUdEwAAAAAAAAAAAAAAAACg4tAkimvKokWLNHv2bCUlJWnMmDFyu93av3+/1q5dq+PHj3uaRFNSUuRwOCqlph9++EEDBgyQ0+nUoEGDFBUVpfz8fH322WeaMWOGgoOD1a1btwqv4/3335ckxcXF6b333iv1fllZWRo4cKAaNGigefPmKT09XcnJycrNzS1zk+2MGTPUqFEjFRYW6sCBA3rxxReVmpqqxYsXl2kcAAAAAAAAAAAAAAAAAEDFo0kU15Tly5erV69emjRpkmdZXFycHnnkEblcLs+yFi1aVFpN48ePl9Pp1Ntvv63w8HDP8i5duqhfv346c+bMVY2fm5srHx+fErdbtWqVrFarUlNTy9QkumrVKp09e1YpKSmqXr26JMnpdOqZZ57RsGHDihxTSZo0aaLo6GhJUrt27ZSXl6cZM2bo7Nmz8vf3L/U4AAAAAAAAAAAAAAAAQFXh/kVfE3CtsZouAPil7OxshYWFXXKd1fq/h2tiYqKmTZvmuT1p0iT16NFDO3bsUM+ePRUTE6N+/fopNTVVmZmZGjt2rNq0aaNu3bpp/fr1pa5n9+7d2rt3b7HNlHXq1FFkZKTn9q5du9S3b1/FxMQoNjZWTzzxhDIzMz3rU1NTFRkZqXfeeUdTpkxRbGysHnjggVLV8svjL4tt27bplltu8TSISlL37t3lcrn06aefXtGYF/j7+8vtdhdp4AUAAAAAAAAAAAAAAAAAXBuYSRTXlKioKK1atUoRERGKj49XzZo1S73viRMnlJycrOHDh8vLy0vPPvusxo8fL19fX7Vr1059+vTRm2++qQkTJqhVq1aqW7duiWPu3LlTktS5c+cSt923b58GDRqk2NhYvfzyyzp58qRmz56tAwcOaNWqVbLZbJ5t58yZo7i4OM2ePbvCGywPHTqk3r17F1nmcDhUs2ZNHTp0qExjuVwuFRYWyul0av/+/VqyZIk6duyowMDA8iwZAAAAAAAAAAAAAAAAAFAOaBLFNWXq1KkaNWqUpkyZIkmKiIhQQkKCkpKSFBERcdl9s7KytGLFCjVp0kSSdPz4cU2fPl1Dhw7VyJEjJUnR0dHasGGDNm7cqIEDB5ZYT3p6uqSfZwwtyYIFC1SzZk0tWLBA3t7ekqTatWtryJAh2rp1qxITEz3bNmvWTM8991yJY5aH7OxsORyOi5YHBQUpKyurTGP16dOnyO3IyEjNnDnzquoDAAAAAAAAAAAAAAAAAFQMLjePa0rTpk21bt06LVy4UAMGDFBgYKCWL1+uu+++W99+++1l9w0LC/M0iEpSgwYNJEkdO3b0LHM4HAoJCdGxY8fKvfbdu3era9eungZRSerUqZMcDof+9a9/Fdk2Pj6+3PMrw8yZM/XWW29p9erVmjNnjgoKCvTII4/o7NmzpksDAAAAAAAAAAAAAAAAAPwKTaK45tjtdsXFxenJJ5/Ue++9p7/97W/Kzc3V/PnzL7vfr2fLvNCs+etLodvtduXl5ZWqlvDwcElSWlpaidtmZ2crNDT0ouWhoaEXzdh5qe0qisPh0JkzZy5anpWVpaCgoDKN1bhxY0VHRysmJka/+93vNGvWLH333Xd69913y6tcAAAAAAAAAAAAAAAAAEA5oUkU17zOnTurWbNmOnjwYKVnt2/fXpK0ffv2ErcNCgrSqVOnLlp+6tSpi5oxLRZL+RRYCo0aNdKhQ4eKLDtz5oxOnDihRo0aXdXYjRs3liTt37//qsYBAAAAAAAAAAAAAAAAAJQ/mkRxTTl58uRFy3Jzc5WWlqYaNWpUej3t2rVTTEyMFixYoOPHj1+0Pi0tTd99950kqW3bttq0aZMKCws96z/99FNlZ2erbdu2lVbzr3Xp0kU7duxQdna2Z9mHH34oq9WqW2+99arG/u9//ytJCg4OvqpxAAAAAAAAAAAAAAAAAADlz8t0AcAv9ezZUwkJCerUqZPCwsKUnp6uFStW6PTp0xo4cKCRmmbNmqX+/furd+/eGjRokKKiopSfn69du3Zp5cqVmjlzpiIjI/Xoo4+qb9++GjZsmPr376+TJ09q9uzZiomJUVxc3FXX8fXXX+vIkSPKyMiQJH311VeSpJCQEM+Mpzt37lRSUpKef/553XvvvZKkvn37avny5Ro5cqSGDRum9PR0vfDCC+rbt6/Cw8PLVMP+/fvldDrlcrn0008/6a9//at8fX09WQAAAAAAAAAAAAAAAMD1xu10mS4BKBZNorimjBo1Slu2bFFycrIyMjIUHBysyMhIvfbaa+rQoYORmurXr693331XixYt0uuvv660tDTZ7Xa1aNFCkydPVkJCgiSpZcuWWrJkiebMmaPRo0fLz89PiYmJmjhxomw221XXsXLlSr377rue20uWLJEktW/fXsuXL5ckud1uTxPnBUFBQVq6dKmmT5+ukSNHyt/fX/fff78ee+yxMtfwxBNPSJIsFotq1Kih6Ohovfzyy2rQoMFVHBkAAAAAAAAAAAAAAAAAoCJY3G6323QRAK5fmw+cMJbdvIafsWy7zWIkNyjniJFcSSoMqmMk1/vUISO5kpRZvbGRXC+rmceXJBl6aKvQZe50Jjvf3C/Cwr3yjeRac7ON5EqSDJ26Wpxm7mtJOl/9BiO5dnehkVxJclvN/JZtf6a5v3Nwtav/UdGVCPE197tBp8GPonaXmb+1xVlgJFeSDpy3G8mt4WvmsS1Jpt6hg73MnRvkuMzc3yY/Z1jyzhrLdvmHGMk9bQ81kitJQTYz5wc5bm8juZIU6Mwxkuv2qmYkV5KO5lqN5Jr8krquz/U308dZg88rP5uZv3amuVMx1Tyyy0ius3YzI7mSZCk0c87t9vYxkitJlvxzZnIL84zkSua+s5CkHEPfydWu7m8kFwAAANe+A6P6mC4Bkm5MedN0CdckM9/4AQAAAAAAAAAAAAAAAAAAoEJxuXlcty5cmr04VqtVVmvF91GbrsPlchW5PP2v2Ww2WSzmZiUEAAAAAAAAAAAAAAAAAFwZmkRx3dq5c6cGDBhQ7PpevXopOTm5ytcxf/58paSkFLt+xowZuu+++yosHwAAAAAAAAAAAAAAAABQMWgSxXUrKipKb731VrHrg4ODr4s6+vTpo/j4+GLXR0REVGg+AAAAAAAAAAAAAAAAAKBi0CSK61ZAQICio6NNl2G8jvDwcIWHhxvLBwAAAAAAAAAAAAAAAH7L3E6X6RKAYllNFwAAAAAAAAAAAAAAAAAAAIDyR5MoAAAAAAAAAAAAAAAAAABAFUSTKAAAAAAAAAAAAAAAAAAAQBVEkygAAAAAAAAAAAAAAAAAAEAVRJMoAAAAAAAAAAAAAAAAAABAFeRlugAA17c2tfyNZZ8tcBvLDso5YibY7TKTK8niLDCSe8rRyEiuJFkMPcRsFjO5kpRTYOYxFuBt7ncvtSw5xrJ/yDXzGlrfau4U0uUXbCbYYu4x5nSaeTFJzzf3YlLLdcpIboiPoceXpAC7mceYV7651zCbzdtYdkahmdexGnkZRnIl6cZqvkZyXd6BRnIlc+ef1rOZRnIlyWEo97CtlqFkqYGfmfcMSXL5mLnH7RZz79FHcs28X9X0M3fMOQowkutvcRrJlaS63nlGci3ns4zkSpLbGWQm2JlvJldSvs3QMUsKcJ03kuvvbe57yB/C2hrJtbnMvX5W97MZyfUtOGMkVzL3ncVpp7nvafJzzb1fOQx9jj515pyRXEkKDfQzlg0AAADgt42ZRAEAAAAAAAAAAAAAAAAAAKogZhIFAAAAAAAAAAAAAAAAAOAKuZzmruwKlISZRAEAAAAAAAAAAAAAAAAAAKogmkQBAAAAAAAAAAAAAAAAAACqIJpEAQAAAAAAAAAAAAAAAAAAqiCaRAEAAAAAAAAAAAAAAAAAAKogmkQBAAAAAAAAAAAAAAAAAACqIJpEUW769++vYcOGVVre+fPnlZKSorvuukutWrVSbGysevfurRdffNGzTWpqqiIjI/Xhhx9WeD2ff/65IiMjFRkZqYMHD160/sUXX1RkZKQSExMv2ufrr7+u8PouOHPmjCZPnqz27durdevWGjNmjI4fP16qffPy8vTyyy8rMTFRLVu2VHx8vGbOnFnBFQMAAAAAAAAAAAAAAAAAroSX6QJQdUydOlVWa+X1HY8ZM0Z79+7VsGHD1Lx5c2VnZ+vrr7/Wxo0b9dhjj0mSwsLC9MYbb6hBgwaVVpefn5/Wr1+v0aNHF1n+wQcfyM/Pr8iyqKgovfHGG2rcuHGl1ffHP/5RBw4c0NNPP61q1arppZde0tChQ/X222/Ly6v4lwSXy6URI0bop59+0qhRoxQREaGjR4/q8OHDlVY7AAAAAAAAAAAAAAAAAKD0aBJFubnxxhsrLeuHH37Qtm3bNHPmTN17772e5XfccYfGjRvnuW2323XTTTdVWl2S1LVrV61bt65Ik+hXX32lo0ePqnv37vryyy89ywMCAiq1vi+//FLbt2/X4sWL1alTJ0lSw4YNddddd+mjjz7SXXfdVey+b7/9tr766iutX79eYWFhlVUyAAAAAAAAAAAAAAAAcE1zu1ymSwCKxeXmcZFJkyapR48e2rFjh3r27KmYmBj169dPqampyszM1NixY9WmTRt169ZN69ev9+z368vNHzt2TGPHjlXHjh0VHR2txMREPf/886VefzlZWVmSpJo1a1607pezmV7qcvOJiYmaNm2aXnvtNcXFxal169aaNGmS8vPz9e2336pv37666aabdP/99+u7774r/R33/+vevbt+/PFHffPNN55la9eu1S233KKQkJAi217qcvNvvfWWfve73ykmJkaxsbH6/e9/r71795Z6/eVs27ZNDodDt956q2dZo0aN1Lx5c23btu2y+65evVp33nknDaIAAAAAAAAAAAAAAAAA8BvBTKK4pBMnTig5OVnDhw+Xl5eXnn32WY0fP16+vr5q166d+vTpozfffFMTJkxQq1atVLdu3YvGePzxx3X8+HFNmTJFoaGhSktL0759+0q9/nIaNWokPz8/JScna9y4cWrfvr38/f1LfXybNm1SkyZNNG3aNP30009KTk6Wt7e39uzZo6SkJNWoUUOzZs3S2LFjtX79+iKNpyUJCwvTzTffrHXr1ikqKkoul0sffvihxo0bp2+//fay++7atUtPPvmkBg8erLi4OOXm5mrv3r06c+ZMqdaX5NChQ2rYsKEsFkuR5Y0aNdKhQ4eK3a+goED//ve/FR8fr8cff1wfffSRLBaLunTpoilTplyyWRcAAAAAAAAAAAAAAAAAYBZNorikrKwsrVixQk2aNJEkHT9+XNOnT9fQoUM1cuRISVJ0dLQ2bNigjRs3auDAgReN8fXXX2vcuHFFLmH+y0vDl7T+cgICAvTcc89pypQpevTRR2Wz2dSsWTPddtttGjhwoPz8/Eoc469//avsdrskaefOnXrzzTe1aNEidenSRZLkcrn06KOP6r///a+aNWtWqrou6NGjh/7617/q8ccf1+eff67s7GzdfvvtJTaJ7t27V9WrV9fEiRM9y+Lj40u9viTZ2dkKDAy8aHlQUNBlG3QzMzNVUFCgRYsW6eabb1ZKSooyMjL0l7/8RaNHj9aqVatKXQMAAAAAAAAAAAAAAAAAoHJwuXlcUlhYmKdBVJIaNGggSerYsaNnmcPhUEhIiI4dO3bJMVq0aKElS5bo73//u3744Ycyry/JXXfdpS1btmjmzJm65557dPr0ab300kvq3bu3zp07d9l9b775Zk+D6IXjs1qt6tChQ5FlkpSWllbm2m6//XadPHlS//rXv7Ru3TrFxcUpICCgxP1atGihzMxMTZo0SZ9++qnOnz9fpvUVxeVySZL8/f2VkpKiTp066e6779bMmTP15Zdf6p///Gel1AEAAAAAAAAAAAAAAAAAKD2aRHFJDoejyG1vb29JumgWSrvdrry8vEuO8eKLL6pDhw566aWXdPvtt+vOO+/URx99VOr1pREUFKR7771XM2bM0ObNmzVixAgdOnRIb731VpmPz8fHp0jj6IVjLu74Lqd69erq1KmT3n33XX300Ufq0aNHqfa75ZZb9MILL2j//v0aMmSIOnTooMcff1yZmZmlWl8Sh8OhnJyci5ZnZWUpKCjosvtZLBa1adOmyH3Uvn172Ww2HThwoFT5AAAAAAAAAAAAAAAAAIDKQ5MoKkxYWJhmzJihzz77TKtXr1bDhg312GOP6aeffirV+rKyWCwaMmSIJOngwYPldhxX6ne/+53eeecduVyuMl0S/p577tHbb7+tHTt2aMqUKdq4caNeeOGFUq+/nEaNGunw4cNyu91Flh8+fFiNGjUqdj9fX1/VrVu32PVX0kgLAAAAAAAAAAAAAAAAAKhYNImiwlmtVsXExOiPf/yjCgsLL7q0fEnrLyUnJ0e5ubkXLf/+++8lSTVr1iyX2q9G165d1bVrVw0bNkzVqlUr8/4hISF64IEHdOutt+rQoUNlXn8pXbp0UVZWVpHLwx8+fFj//ve/1aVLl8vum5CQoC+++KJIQ+hnn30mp9OpqKioUh4VAAAAAAAAAAAAAAAAULW4nS7+XQP/cGlepgtA1XTmzBkNGTJE99xzjxo2bKiCggItX75cDodDLVq0KHF9SQ4fPqzhw4erV69eatu2rfz8/HTgwAEtWrRIgYGB6tWrVyUc5eX5+fkpJSWlTPvMnTtXmZmZat++vUJDQ/Xf//5Xn3zyiZKSkkq1viStW7dWp06dNHnyZE2cOFHVqlXTiy++qMjISN1+++2e7VJSUvTXv/5VGzZs8MwgOmTIEL3//vsaMWKEBgwYoIyMDM2ePVtt27ZVhw4dynScAAAAAAAAAAAAAAAAAICKR5MoKkS1atXUtGlTLV++XGlpafLx8VHLli21ePFihYSEKD8//7LrS1K/fn09+OCD+vTTT7V69WqdPXtW4eHh6tChgx599NHLXhr9WhYdHa2lS5fqH//4h3JyclSrVi0NGTJEw4cPL9X60njppZc0Y8YMPfXUUyosLFSnTp00ZcoUeXn97+XA7XbL6XQWuSx97dq1tWzZMj3//PMaPXq0fH191bVrV02aNEkWi6X87gQAAAAAAAAAAAAAAAAAQLmwuH/ZBQYAlSwz55yx7LMF5l7+wnOPmgl2m5ta2xkYbiQ3y+VtJFeSsQZqXy9zjds5BWYeYwHeViO5kmTPyzKW/UOBv5Hc+lZzx+zyCzYTbDH3GMt1mnm/ys43955Ry5VpJPeEzdDjS1KA3cxjzLfwrJFcSXLbzL1HZxSa+b1kjbzjRnIlyW33NZLrqhZoJFeSLM4CI7nW85lGck36XqHGshvolLFsl291I7nnLXYjuZKUkes0klvTz9zv3AsMnYv5W83c15JkKcwzk3ve3OcMt2+QmWBnvplcSRk2Q8csKUTnjeTmeZv5DC1JJ84VGsm1Gfxxf3Ufm5Fc34IzRnIlye1VzUjuaae598l8Q++TkuQw9Dna4CErNNDPXDgAAABK9O2gu02XAEnN/98a0yVck8z9324AAAAAAAAAAAAAAAAAAABUGC43j2tSYWHxv6y2WCyy2Sr3V8gul0suV/GzadlsNuOXXP8t1AgAAAAAAAAAAAAAAAAAqDw0ieKaFBUVVey6unXravPmzZVYjTR//nylpKQUu37GjBm67777KrGii/0WagQAAAAAAAAAAAAAAAAAVB6aRHFNeuutt4pdZ7fbK7GSn/Xp00fx8fHFro+IiKi8YorxW6gRAAAAAAAAAAAAAAAAAFB5aBLFNSk6Otp0CUWEh4crPDzcdBmX9VuoEQAAAAAAAAAAAAAAAKhq3E636RKAYllNFwAAAAAAAAAAAAAAAAAAAIDyR5MoAAAAAAAAAAAAAAAAAABAFUSTKAAAAAAAAAAAAAAAAAAAQBVEkygAAAAAAAAAAAAAAAAAAEAV5GW6AADXN4vFYiw7qJq5bKe9lpHcHJfNSK4kOV1uI7kBdnPHnJXnNJJ7rsDMfS1JPjYzzytvV76RXEnK8XIYyw60mvlbu72CjORKUq7LzGPsfKHLSK4khVjzjOS6vH2M5EqSyyvUSG6wzJ0bFBh6n5Tb3GPbpBBvM8dtOZtrJFeSsv3CjeTm5pk7Lwk/l2Yk97B3hJFcSWqU972R3FqhZh5fkpSeW8NYtq+h314HWMx8zpCkG/JSjeRmVatvJFeSsbMDk5/fA7yqGcktDKprJFeSvM5nGMnN8wk2kitJ3k5z79GWs1lGcs/K10iuJPl6mXnPyDhv7j2juo+Z17Esa4CRXEky9DWNArzNfZYttJl7LTlfaCbb1OdJSdrx/SkjuR0bmPmeBgAAAED5YSZRAAAAAAAAAAAAAAAAAACAKogmUQAAAAAAAAAAAAAAAAAAgCqIy80DAAAAAAAAAAAAAAAAAHCFXE6X6RKAYjGTKAAAAAAAAAAAAAAAAAAAQBVEkygAAAAAAAAAAAAAAAAAAEAVRJMoAAAAAAAAAAAAAAD/H3v3Hhd1nff//8kAgwiinE2nUNPGINDQRFkV8bBdurpFpl27mmIHza+kmzcrFy02tRW3slpxO9jBPJR57FL0ssx12yxL3XbX2qurzFyLRFBRTgoDM/P7o19zRYqMCLxtetxvN28353N4P1+fYQ6fGV68PwAAAIAPokkUAAAAAAAAAAAAAAAAAADAB9EkiiZz++23a8qUKS2Wd/bsWeXl5WnEiBHq0aOHUlJSNHr0aD355JOebQoKCmS327V9+/Zmr+fDDz+U3W6X3W7XoUOHzln/5JNPym63a/Dgwefs8/HHHzd7fd8pLy9Xdna2+vTpo+uvv17Tp09XcXFxg/t9d2zn++fN/gAAAAAAAAAAAAAAAACAlhVgugD4jpycHFksLdd3PH36dB04cEBTpkzRtddeq7KyMn388cd6++23dd9990mSYmJi9Prrr6tTp04tVlfr1q21bds23XvvvXWWb926Va1bt66zLCEhQa+//rquvvrqFqvvN7/5jb744gv97ne/U1BQkJ566indfffd2rBhgwIC6n9JeP31189Z9uCDDyo4OFgxMTHNWTIAAAAAAAAAAAAAAAAAoBFoEkWT6dq1a4tlHTlyRH/961+1aNEi3XzzzZ7lN954o2bOnOm5bbVa1bNnzxarS5KGDBmi/Pz8Ok2i//znP3X06FENHz5cf//73z3LQ0NDW7S+v//979q9e7defPFF9e/fX5LUuXNnjRgxQm+99ZZGjBhR774/rLOgoED//ve/df/99zdnyQAAAAAAAAAAAAAAAMBlze1ymy4BqBeXm8c5Zs+erZEjR+r999/XqFGjlJSUpPHjx6ugoECnT5/WjBkzlJycrKFDh2rbtm2e/X54ufljx45pxowZSk1NVWJiogYPHqzf//73Xq+/kNLSUklSdHT0Oeu+P5vp+S43P3jwYM2bN0/Lly9XWlqarr/+es2ePVsOh0Offvqp/vM//1M9e/bUrbfeqs8++8z7O+7/N3z4cH311Vf617/+5Vm2ZcsW9evXTxEREXW2Pd/l5tevX69f/OIXSkpKUkpKin71q1/pwIEDXq+/kL/+9a8KCwvTz372M8+yLl266Nprr9Vf//rXizrO/Px8+fn5aeTIkRe1HwAAAAAAAAAAAAAAAACgZTCTKM7r+PHjys3N1dSpUxUQEKAFCxZo1qxZCg4OVu/evTV27FitXbtW999/v3r06KGOHTueM8YDDzyg4uJizZ07V5GRkSosLNQnn3zi9foL6dKli1q3bq3c3FzNnDlTffr0UUhIiNfHt3PnTnXr1k3z5s3T119/rdzcXAUGBuof//iHMjMzFRUVpccff1wzZszQtm3b6jSeNiQmJkY33HCD8vPzlZCQIJfLpe3bt2vmzJn69NNPL7jvvn37NGfOHN1xxx1KS0tTVVWVDhw4oPLycq/WN+TLL79U586d5efnV2d5ly5d9OWXX3p9jJK0detW3XDDDWrfvv1F7QcAAAAAAAAAAAAAAAAAaBk0ieK8SktLtWrVKnXr1k2SVFxcrPnz5+vuu+/WtGnTJEmJiYnasWOH3n77bU2cOPGcMT7++GPNnDmzziXMv39p+IbWX0hoaKgeffRRzZ07V/fcc4/8/f3VvXt3DRs2TBMnTlTr1q0bHONPf/qTrFarJGnv3r1au3atli1bpoEDB0qSXC6X7rnnHn3++efq3r27V3V9Z+TIkfrTn/6kBx54QB9++KHKysr085//vMEm0QMHDqhdu3Z68MEHPcsGDRrk9fqGlJWVqU2bNucsb9u2rdcNupL0v//7v/r88881b948r/cBAAAAAAAAAAAAAAAAALQsLjeP84qJifE0iEpSp06dJEmpqameZWFhYYqIiNCxY8fOO0Z8fLxeeuklvfrqqzpy5MhFr2/IiBEjtGvXLi1atEg33XSTTp06paeeekqjR4/WmTNnLrjvDTfc4GkQ/e74LBaL+vbtW2eZJBUWFl50bT//+c914sQJ/e1vf1N+fr7S0tIUGhra4H7x8fE6ffq0Zs+erffee09nz569qPUtZcuWLQoMDNSNN95oJB8AAAAAAAAAAAAAAAAA0DCaRHFeYWFhdW4HBgZK0jmzUFqtVlVXV593jCeffFJ9+/bVU089pZ///Of6j//4D7311lter/dG27ZtdfPNN2vhwoX685//rP/3//6fvvzyS61fv/6ij69Vq1Z1Gke/O+b6ju9C2rVrp/79+2vTpk166623NHLkSK/269evn/7whz/o4MGDuvPOO9W3b1898MADOn36tFfrGxIWFqaKiopzlpeWlqpt27ZejeF2u7Vt2zYNGDBA7dq182ofAAAAAAAAAAAAAAAAAEDLo0kUzSYmJkYLFy7UBx98oHXr1qlz586677779PXXX3u1/mL5+fnpzjvvlCQdOnSoyY6jsX7xi19o48aNcrlcF3VJ+JtuukkbNmzQ+++/r7lz5+rtt9/WH/7wB6/XX0iXLl10+PBhud3uOssPHz6sLl26eDXG3/72Nx09elSjRo3y+pgAAAAAAAAAAAAAAAAAAC2PJlE0O4vFoqSkJP3mN79RbW3tOZeWb2j9+VRUVKiqquqc5f/+978lSdHR0U1S+6UYMmSIhgwZoilTpigoKOii94+IiNCYMWP0s5/9TF9++eVFrz+fgQMHqrS0VHv27PEsO3z4sP7nf/5HAwcO9GqMLVu2qHXr1ho8eLB3BwIAAAAAAAAAAAAAAAAAMCLAdAHwTeXl5brzzjt10003qXPnzqqpqdHKlSsVFham+Pj4Btc35PDhw5o6daoyMjLUq1cvtW7dWl988YWWLVumNm3aKCMjowWO8sJat26tvLy8i9rnj3/8o06fPq0+ffooMjJSn3/+ud59911lZmZ6tb4h119/vfr376/s7Gw9+OCDCgoK0pNPPim73a6f//znnu3y8vL0pz/9STt27FDHjh09y2tra/Xmm29q6NChatWq1UUdGwAAAAAAAAAAAAAAAOCLXE53wxsBhtAkimYRFBSka665RitXrlRhYaFatWql6667Ti+++KIiIiLkcDguuL4hcXFxuu222/Tee+9p3bp1qqysVGxsrPr27at77rmnTmPjj0liYqJeeeUV/fd//7cqKirUvn173XnnnZo6dapX673x1FNPaeHChXr44YdVW1ur/v37a+7cuQoI+L+XA7fbLafTec5l6Xfv3q1Tp05p5MiRTXPAAAAAAAAAAAAAAAAAAIBm4+f+YRcYALSg0sqzxrL9/YxFK9BdayS3wuVvJFeSnC4zbzehVnPHXFrtNJJr8rFtNRQerBojuZJU6Q40lu0w9LwKD3AZyZWks24zz+mzteZOmSMs1UZyK/3MzRreOsDMa4lL5l5Aaww9n4Nryo3kSpI7IMhYtvwsRmL9TxcYyZWk0rA4I7lVBl8/Y898ZST3cKDNSK4kdan+t5HcM5FdjeRKUmmVmXNuSQoONPNaEmoxd8ymXsdMvYZJMnZ2YPILW1OPMafF3GergLMlRnKrW4UbyZUkh8HZTcIqC43kngxubyRXkkz9FqbkrLn3DFuYmee0yce2xdCbRpDBLwNrDX2Wlcx9VxMRaO57sb8ddxjJTe0UaSQXAADgx+afY4ebLgGSeqz9b9MlXJbMfJsNAAAAAAAAAAAAAAAAAACAZsXl5nFZqq2tf5ZFPz8/+fu37CxiLpdLLlf9fx3q7+8vPz+DU/fpx1EjAAAAAAAAAAAAAAAAAKDl0CSKy1JCQkK96zp27Kg///nPLViNtHTpUuXl5dW7fuHChbrllltasKJz/RhqBAAAAAAAAAAAAAAAAAC0HJpEcVlav359veusVmsLVvKtsWPHatCgQfWut9lsLVdMPX4MNQIAAAAAAAAAAAAAAAAAWg5NorgsJSYmmi6hjtjYWMXGxpou44J+DDUCAAAAAAAAAAAAAAAAAFoOTaIAAAAAAAAAAAAAAAAAADSS2+kyXQJQL4vpAgAAAAAAAAAAAAAAAAAAAND0aBIFAAAAAAAAAAAAAAAAAADwQTSJAgAAAAAAAAAAAAAAAAAA+CCaRAEAAAAAAAAAAAAAAAAAAHxQgOkCAPy0tXI7zIW7zUVXuAON5FbWuIzkSlJ712kjuW5LqJFcSQq1BhnJPVZRayRXktoGmfn7kzZlXxnJlaTWkV2MZftbzNzffrVnjeRKUlCQmed0K39zbxouv9ZGck+W1RjJlaQSPzO57UPMfTyqrjXzHu0OMPc+afU39zeLAY4KI7mf+3c0kitJHQw9r6ICzL2WnA3vZCQ30mnuPeOwXycjuZ1OmzsXCwpuayz7tKuNkdwyt7+RXEkKa9vBSG7rAHPvGeXVTiO5DoOvJV8a+kwZYjV3zFeGhRvJtbrMfS8WVF1uLLsgIMZI7hVmvo6TJFkL/2UkN7ritJFcSapqO8BIrtXf0ImvJKfLzOuYwa+5dbbWXHq41UyupfyEmWBJKSo1kltdYe77kqBQc+f7AAAAgC9hJlEAAAAAAAAAAAAAAAAAAAAfxEyiAAAAAAAAAAAAAAAAAAA0ktvglWGAhjCTKAAAAAAAAAAAAAAAAAAAgA+iSRQAAAAAAAAAAAAAAAAAAMAH0SQKAAAAAAAAAAAAAAAAAADgg2gSBQAAAAAAAAAAAAAAAAAA8EE0iQIAAAAAAAAAAAAAAAAAAPggmkThczZv3qxbb71VvXr1UnJysoYPH645c+bo5MmTnm0GDx6sefPmtVhNJSUlys3N1Y033qjExEQlJydr/PjxWrdunZxOp9fjlJWVacmSJfriiy8uKv/AgQOaNGmSfvazn+m6667ToEGDlJ2draKioosaZ/Xq1ZoyZYr69u0ru92u7du3X9T+AAAAAAAAAAAAAAAAAICWE2C6AKApLVu2TE888YQyMzM1ffp0ud1uHTx4UFu2bFFxcbEiIyMlSXl5eQoLC2uRmo4cOaIJEybI6XRq0qRJSkhIkMPh0AcffKCFCxcqPDxcQ4cO9WqssrIy5eXlqVu3buratavXNZSVlalLly4aM2aMIiMj9fXXX+tPf/qTPv74Y23YsEFWq9Wrcf7rv/5LkpSWlqY33njD63wAAAAAAAAAAAAAAAAAQMujSRQ+ZeXKlcrIyNDs2bM9y9LS0nTXXXfJ5XJ5lsXHx7dYTbNmzZLT6dSGDRsUGxvrWT5w4ECNHz9e5eXlzV5D//791b9/f8/tlJQUXXHFFbrjjjv0ySefKDk52atx1qxZI4vFooKCAppEAQAAAAAAAAAAAAAAAEkup9t0CUC9uNw8fEpZWZliYmLOu85i+b+H+w8vNz979myNHDlS77//vkaNGqWkpCSNHz9eBQUFOn36tGbMmKHk5GQNHTpU27Zt87qe/fv368CBA5oyZUqdBtHvdOjQQXa7XZJ06NAh3XfffUpLS1OPHj00YsQIvfTSS57m1oKCAg0ZMkSSNGPGDNntdtntdhUUFHhdz/e1a9dOklRTU+P1Pt+/DwEAAAAAAAAAAAAAAAAAlzdmEoVPSUhI0Jo1a2Sz2TRo0CBFR0d7ve/x48eVm5urqVOnKiAgQAsWLNCsWbMUHBys3r17a+zYsVq7dq3uv/9+9ejRQx07dmxwzL1790qSBgwY0OC2xcXF6ty5s0aNGqWQkBB9+umnWrJkic6cOaOsrCzFxMQoLy9PWVlZmjlzplJSUiSp3qbY83E6nXI6nfr666/12GOPKSEhQb169fJ6fwAAAAAAAAAAAAAAAADAjwdNovApOTk5ysrK0ty5cyVJNptN6enpyszMlM1mu+C+paWlWrVqlbp16ybp26bN+fPn6+6779a0adMkSYmJidqxY4fefvttTZw4scF6ioqKJH07Y2hD+vXrp379+kmS3G63evXqpaqqKq1atUpZWVmyWq269tprJUlxcXHq2bNng2P+0Pjx4/XRRx9Jkq677jo9//zzCgjgZQAAAAAAAAAAAAAAAAAAfBHdYfAp11xzjfLz87Vnzx7t3r1b+/bt08qVK7Vx40atXr3a02R5PjExMZ4GUUnq1KmTJCk1NdWzLCwsTBERETp27FiT115dXa3nnntOW7ZsUWFhYZ3LwFdWViokJOSSMx599FGVl5fryJEjWrZsmSZNmqTXXntNoaGhlzw2AAAAAAAAAAAAAAAAAODyYjFdANDUrFar0tLSNGfOHL3xxht64YUXVFVVpaVLl15wv7CwsDq3AwMDJUlt2rQ5Z/zq6mqvaomNjZUkFRYWNrjtY489phdffFFjxozR888/r/Xr12vq1KmS5HVeQ7p06aIePXrol7/8pV5++WX9+9//1uuvv94kYwMAAAAAAAAAAAAAAAAALi/MJAqfN2DAAHXv3l2HDh1q8ew+ffpIknbv3q24uLgLbrt9+3bddtttmjx5smfZO++802y1RUVFqX379jpy5EizZQAAAAAAAAAAAAAAAAAAzGEmUfiUEydOnLOsqqpKhYWFioqKavF6evfuraSkJD377LMqLi4+Z31hYaE+++wzSd/OFvrd7KWS5HQ6tXXr1jrbf7e+KWYWLSws1NGjR3XllVde8lgAAAAAAAAAAAAAAAAAgMsPM4nCp4waNUrp6enq37+/YmJiVFRUpFWrVunUqVOaOHGikZoef/xx3X777Ro9erQmTZqkhIQEORwO7du3T6tXr9aiRYtkt9uVmpqqdevWqWvXrgoPD9err74qh8NRZ6zo6GiFhYVp69atstlsslqtstvtslqtF6zh4YcfVnh4uBITExUaGqrDhw/r5ZdfVmRkpG699Vavj+Xjjz/WN998o5KSEknSP//5T0lSRESEZ9ZUAAAAAAAAAAAAAAAA4KfE7XSZLgGoF02i8ClZWVnatWuXcnNzVVJSovDwcNntdi1fvlx9+/Y1UlNcXJw2bdqkZcuW6bXXXlNhYaGsVqvi4+OVnZ2t9PR0SdJDDz2knJwczZ8/X8HBwcrIyNCwYcM0d+5cz1gWi0ULFy7U4sWLlZmZKYfDoZ07d8pms12whqSkJK1du9bTeHrFFVdo4MCBuueeexQeHu71saxevVqbNm3y3H7ppZckSX369NHKlSsv5m4BAAAAAAAAAAAAAAAAADQzP7fb7TZdBICfruqKUtMlGFHhDjSSW1lj7i9X2rtOG8l1B4UayZUkh3+QkdxjFbVGciWpbZDFSG5k2ZdGciWpJrKLsexqt5n7O7i20kiuJDkNPaf9DJ4yu/38jOQWlNUYyZUkQ4es9iHm/obujKH3aKu/oTtbktXfzGuYJAU4KozkfnH2wlcAaE4dQs08voPdjoY3aiamzsVqnObeM0qqnEZyO9UcNZIrSa7gtsayT1vaGMn1M/VGKSnMYub8wBVg5vksSeXVZp5XDoOvJYUVZn7OIVZ/I7mSdGWYme9prC5z75N+VeXGsr+RmdfuK1qbO/+0Fv7LSK6r4rSRXEmq6jbASK7Bl085XWbCAw1+rqtwmPu+OdzQxyv/8mIzwZIsZ838PqU2qrORXEkKCjV3vg8AAHCx9o8YYroESOq9bafpEi5L5r4VAQAAAAAAAAAAAAAAAAAAQLPhcvNAI7ndbjmd9c8mYbFYZLE0fx+2y+WSy1X/X+v6+/s3OMvI5XIsAAAAAAAAAAAAAAAAAICmQ5Mo0Eh79+7VhAkT6l2fkZGh3NzcZq8jOztbmzZtqnf9ihUrlJKScsExLpdjAQAAAAAAAAAAAAAAAAA0HZpEgUZKSEjQ+vXr610fHh7eInVkZWVp3Lhx9a7v3Llzg2NcLscCAAAAAAAAAAAAAAAAAGg6NIkCjRQaGqrExETTZchms8lms13SGJfLsQAAAAAAAAAAAAAAAAA/Ni6X23QJQL0spgsAAAAAAAAAAAAAAAAAAABA06NJFAAAAAAAAAAAAAAAAAAAwAfRJAoAAAAAAAAAAAAAAAAAAOCDaBIFAAAAAAAAAAAAAAAAAADwQQGmCwDw01bpDjSWHejvZyw7wG0mt73ljJlgSSX+4UZyrTL3cw5xVhvJ7aTTRnIlyRkYbST3I7fNSK4kJfj5G8sOPnPCSO43amskV5LCLC4jua0Dzf1tVa3LzJtG58I9RnIlydUp2UhurZ+585Lws8eM5FaGXmEkV5IcTjPPZ0ny9zPznO6m40ZyJcnvdJWR3NrILkZyJSmoqtRIbqtah5FcSQoNsBrJrQq5ykiuJPlbzJ3vh5cXG8ktbxVlJFeSnP5BRnIDy8y8T0pScGiskdx2LjOvYZLUwfFvM8G15r6qrg0y85nSHdDKSK4klQSa+Z5Gkq4wdNptOXPKTLAkR4dEY9mmWA2di5l8XrkDzLxP1hr6rlmSos8eNZZdGWjmtbtVa3Ovn0WGvnuNdpn7jPPNI1OM5HbMec5ILgAAANBcmEkUAAAAAAAAAAAAAAAAAADAB9EkCgAAAAAAAAAAAAAAAAAA4IO43DwAAAAAAAAAAAAAAAAAAI3kdrpNlwDUi5lEAQAAAAAAAAAAAAAAAAAAfBBNogAAAAAAAAAAAAAAAAAAAD6IJlEAAAAAAAAAAAAAAAAAAAAfRJMoAAAAAAAAAAAAAAAAAACADwowXQDQ1DZv3qwVK1bo8OHDcrvdio2NVXJysmbOnKnIyEhJ0uDBgzVo0CA9/PDDLVJTSUmJnn/+ee3atUtHjx5VYGCg4uPjddNNN+mWW26Rv7+/V+OUlZXplVde0fDhw9W1a1ev8w8cOKAnn3xSn3/+uUpLSxUVFaXU1FTNmDFDsbGxXo1RXFys5cuX67333tNXX32lNm3a6IYbbtDMmTPVsWNHr2sBAAAAAAAAAAAAAAAAALQMmkThU5YtW6YnnnhCmZmZmj59utxutw4ePKgtW7aouLjY0ySal5ensLCwFqnpyJEjmjBhgpxOpyZNmqSEhAQ5HA598MEHWrhwocLDwzV06FCvxiorK1NeXp66det2UU2iZWVl6tKli8aMGaPIyEh9/fXX+tOf/qSPP/5YGzZskNVqbXCMf/3rX9qxY4dGjx6tHj166NSpU3rmmWc0ZswY5efnKyIiwut6AAAAAAAAAAAAAAAAAADNjyZR+JSVK1cqIyNDs2fP9ixLS0vTXXfdJZfL5VkWHx/fYjXNmjVLTqdTGzZsqDNr58CBAzV+/HiVl5c3ew39+/dX//79PbdTUlJ0xRVX6I477tAnn3yi5OTkBsfo1auX/vu//1sBAf/3spGcnKxBgwbpjTfe0B133NEstQMAAAAAAAAAAAAAAAAAGocmUfiUsrIyxcTEnHedxWLx/P+Hl5ufPXu2PvnkE2VnZ2vhwoU6cuSIkpKSlJubq9DQUOXk5Ojdd99VRESEZs6cqREjRnhVz/79+3XgwAHNnTv3vJd179Chg+f/hw4dUl5enj766COdPn1aHTt21K233qrMzExZLBYVFBRoyJAhkqQZM2Z49tu5c6dsNptX9Xxfu3btJEk1NTVebX++mVfbt2+viIgIFRcXX3Q+AAAAAAAAAAAAAAAA4AtcTlfDGwGG0CQKn5KQkKA1a9bIZrNp0KBBio6O9nrf48ePKzc3V1OnTlVAQIAWLFigWbNmKTg4WL1799bYsWO1du1a3X///erRo4c6duzY4Jh79+6VJA0YMKDBbYuLi9W5c2eNGjVKISEh+vTTT7VkyRKdOXNGWVlZiomJUV5enrKysjRz5kylpKRIUr1NsefjdDrldDr19ddf67HHHlNCQoJ69erl9f4/dPjwYZ08eVJXX311o8cAAAAAAAAAAAAAAAAAADQPmkThU3JycpSVlaW5c+dKkmw2m9LT05WZmdngbJulpaVatWqVunXrJunbps358+fr7rvv1rRp0yRJiYmJ2rFjh95++21NnDixwXqKiook1Z0xtD79+vVTv379JElut1u9evVSVVWVVq1apaysLFmtVl177bWSpLi4OPXs2bPBMX9o/Pjx+uijjyRJ1113nZ5//vk6l4+/GG63WwsWLFBMTIx+8YtfNGoMAAAAAAAAAAAAAAAAAEDzoUkUPuWaa65Rfn6+9uzZo927d2vfvn1auXKlNm7cqNWrV3uaLM8nJibG0yAqSZ06dZIkpaamepaFhYUpIiJCx44da/Laq6ur9dxzz2nLli0qLCyscxn4yspKhYSEXHLGo48+qvLych05ckTLli3TpEmT9Nprryk0NPSix1qyZIk++OADvfDCC2rduvUl1wYAAAAAAAAAAAAAAAAAaFoW0wUATc1qtSotLU1z5szRG2+8oRdeeEFVVVVaunTpBfcLCwurczswMFCS1KZNm3PGr66u9qqW2NhYSVJhYWGD2z722GN68cUXNWbMGD3//PNav369pk6dKkle5zWkS5cu6tGjh375y1/q5Zdf1r///W+9/vrrFz3O2rVrtXTpUj3yyCOe2U8BAAAAAAAAAAAAAAAAAJcXZhKFzxswYIC6d++uQ4cOtXh2nz59JEm7d+9WXFzcBbfdvn27brvtNk2ePNmz7J133mm22qKiotS+fXsdOXLkovbbsWOHfve732n69Om69dZbm6k6AAAAAAAAAAAAAAAAAMClYiZR+JQTJ06cs6yqqkqFhYWKiopq8Xp69+6tpKQkPfvssyouLj5nfWFhoT777DNJ384W+t3spZLkdDq1devWOtt/t74pZhYtLCzU0aNHdeWVV3q9z4cffqiZM2dqzJgxmjZt2iXXAAAAAAAAAAAAAAAAAABoPswkCp8yatQopaenq3///oqJiVFRUZFWrVqlU6dOaeLEiUZqevzxx3X77bdr9OjRmjRpkhISEuRwOLRv3z6tXr1aixYtkt1uV2pqqtatW6euXbsqPDxcr776qhwOR52xoqOjFRYWpq1bt8pms8lqtcput8tqtV6whocffljh4eFKTExUaGioDh8+rJdfflmRkZFezwZ66NAhTZs2TZ06ddJNN92kf/zjH551ERERuuqqqy76vgEAAAAAAAAAAAAAAAAANB+aROFTsrKytGvXLuXm5qqkpETh4eGy2+1avny5+vbta6SmuLg4bdq0ScuWLdNrr72mwsJCWa1WxcfHKzs7W+np6ZKkhx56SDk5OZo/f76Cg4OVkZGhYcOGae7cuZ6xLBaLFi5cqMWLFyszM1MOh0M7d+6UzWa7YA1JSUlau3atp/H0iiuu0MCBA3XPPfcoPDzcq+P45z//qfLycpWXl+tXv/pVnXUZGRnKzc29yHsGAAAAAAAAAAAAAAAA+PFzO92mSwDq5ed2u3mEAjCmpPyMsexAfz9j2S5Dr7zBNeVmgiWV+IUYybVazP2cQ+RoeKNmYDl72kiuJDlDo43kfnzCzH0tSQnRwcayAypPGMn9Rm2N5EpSWJC/kdzWgRYjuZJUa+hNI/jgu0ZyJcnVKdlIbq011EiuJAWWfmMktzL0CiO5pgW7qozkWs6cMpIrSX61Zo65NrKLkVxJslSVGsn1qzV3XuIOuPBVJpqLI8jcuYG/wfP9gPJiI7nlraKM5EpSqwAz50SB5ceM5EpSVWiskdygajOvYZIUcPLfZoIt5uYzqA2/8B9gNxd3QCsjuZJ0yhVoLLudoWiT52KukEhj2aaYOhcz+bxyBwQZya01+Fu+VqUFxrIrw8y8drdyVRvJlaTjNWbeK6MDzH3GOfHkb43kdsx5zkguAAD4cXs/baDpEiAp9Z2/mi7hsmTut90AAAAAAAAAAAAAAAAAAABoNlxuHmgkt9stp9NZ73qLxSKLpfn7sF0ul1wuV73r/f395ed34ZlVLpdjAQAAAAAAAAAAAAAAAAA0HZpEgUbau3evJkyYUO/6jIwM5ebmNnsd2dnZ2rRpU73rV6xYoZSUlAuOcbkcCwAAAAAAAAAAAAAAAACg6dAkCjRSQkKC1q9fX+/68PDwFqkjKytL48aNq3d9586dGxzjcjkWAAAAAAAAAAAAAAAAAEDToUkUaKTQ0FAlJiaaLkM2m002m+2SxrhcjgUAAAAAAAAAAAAAAAAA0HRoEgUAAAAAAAAAAAAAAAAAoJHcTrfpEoB6WUwXAAAAAAAAAAAAAAAAAAAAgKZHkygAAAAAAAAAAAAAAAAAAIAPokkUAAAAAAAAAAAAAAAAAADAB9EkCgAAAAAAAAAAAAAAAAAA4IP83G6323QRAH66qivLjWW7/AONZQeUFxvJdQe2MpIrSc5WYUZy/VxOI7mS5PLzN5IbUF1mJFeS5HaZyzbE1aqtsewztWZO40KrS4zkSpICrEZiTb2GSZKlpspIbonT3PtkVM1JI7muYHPP5yo/M4/t4LNm7mtJxp7PknTcHWIkN9qv0kiuZO6YQwL9jOT+VLWuMvMefczSzkiuJAUHmPv75+AAM4/vVqUFRnIlqaqtzUhuabW5zxkxDjOf302el8jQ9yUmv6eprjXzGKsx+BE61Gru9TPw1NdGcotadTCSK0mnq8x8P1VaXWMkV5Lio4KN5AYZPDewOM4Yyzalyt/Mz1mSWqnWSO7XBn/MbYPMfN9s8lfJjsW/MZIbGGLudymxDywxlg0AAC7Ne/0HmC4Bkn62+13TJVyWmEkUAAAAAAAAAAAAAAAAAADAB9EkCgAAAAAAAAAAAAAAAAAA4IMCTBcAAAAAAAAAAAAAAAAAAMCPlcvpMl0CUC9mEgUAAAAAAAAAAAAAAAAAAPBBNIkCAAAAAAAAAAAAAAAAAAD4IJpEAQAAAAAAAAAAAAAAAAAAfBBNogAAAAAAAAAAAAAAAAAAAD4owHQBQFPbvHmzVqxYocOHD8vtdis2NlbJycmaOXOmIiMjJUmDBw/WoEGD9PDDD7dITSUlJXr++ee1a9cuHT16VIGBgYqPj9dNN92kW265Rf7+/l6NU1ZWpldeeUXDhw9X165dvc4/cOCAnnzySX3++ecqLS1VVFSUUlNTNWPGDMXGxno9zqxZs3TgwAEVFxcrMDBQ11xzjaZOnar+/ft7PQYAAAAAAAAAAAAAAAAAoGXQJAqfsmzZMj3xxBPKzMzU9OnT5Xa7dfDgQW3ZskXFxcWeJtG8vDyFhYW1SE1HjhzRhAkT5HQ6NWnSJCUkJMjhcOiDDz7QwoULFR4erqFDh3o1VllZmfLy8tStW7eLahItKytTly5dNGbMGEVGRurrr7/Wn/70J3388cfasGGDrFarV+PU1NQoMzNTnTp1UnV1tdavX6/JkydrxYoV6t27t9f1AAAAAAAAAAAAAAAAAACaH02i8CkrV65URkaGZs+e7VmWlpamu+66Sy6Xy7MsPj6+xWqaNWuWnE6nNmzYUGfWzoEDB2r8+PEqLy9v9hr69+9fZ7bPlJQUXXHFFbrjjjv0ySefKDk52atxnn766Tq3Bw4cqCFDhui//uu/aBIFAAAAAAAAAAAAAAAAgMuMxXQBQFMqKytTTEzMeddZLP/3cB88eLDmzZvnuT179myNHDlS77//vkaNGqWkpCSNHz9eBQUFOn36tGbMmKHk5GQNHTpU27Zt87qe/fv368CBA5oyZcp5L+veoUMH2e12SdKhQ4d03333KS0tTT169NCIESP00ksveZpbCwoKNGTIEEnSjBkzZLfbZbfbVVBQ4HU939euXTtJ384O2lj+/v5q06bNJY0BAAAAAAAAAAAAAAAA/Ji5XW7+XQb/cH7MJAqfkpCQoDVr1shms2nQoEGKjo72et/jx48rNzdXU6dOVUBAgBYsWKBZs2YpODhYvXv31tixY7V27Vrdf//96tGjhzp27NjgmHv37pUkDRgwoMFti4uL1blzZ40aNUohISH69NNPtWTJEp05c0ZZWVmKiYlRXl6esrKyNHPmTKWkpEhSvU2x5+N0OuV0OvX111/rscceU0JCgnr16uX1/pLkdrvldDpVXl6ujRs36siRI3UabgEAAAAAAAAAAAAAAAAAlweaROFTcnJylJWVpblz50qSbDab0tPTlZmZKZvNdsF9S0tLtWrVKnXr1k3St02b8+fP1913361p06ZJkhITE7Vjxw69/fbbmjhxYoP1FBUVSfp2xtCG9OvXT/369ZP0bSNmr169VFVVpVWrVikrK0tWq1XXXnutJCkuLk49e/ZscMwfGj9+vD766CNJ0nXXXafnn39eAQEX9zKwfv16z/3bunVrPfnkk7r++usvuhYAAAAAAAAAAAAAAAAAQPOiSRQ+5ZprrlF+fr727Nmj3bt3a9++fVq5cqU2btyo1atXe5oszycmJsbTICpJnTp1kiSlpqZ6loWFhSkiIkLHjh1r8tqrq6v13HPPacuWLSosLKxzCffKykqFhIRccsajjz6q8vJyHTlyRMuWLdOkSZP02muvKTQ01OsxhgwZou7du+vUqVPavn27fvOb3ygvL09paWmXXB8AAAAAAAAAAAAAAAAAoOnQJAqfY7ValZaW5mlafPfddzVlyhQtXbpUeXl59e4XFhZW53ZgYKAkqU2bNueMX11d7VUtsbGxkqTCwkLFxcVdcNvHHntM69at07Rp03TdddepTZs22rlzp5555hlVV1c3SZNoly5dJEk9evRQamqq0tPT9frrr+vOO+/0eoyIiAhFRERIkgYOHKjS0lI99thjNIkCAAAAAAAAAAAAAAAAwGXGYroAoLkNGDBA3bt316FDh1o8u0+fPpKk3bt3N7jt9u3bddttt2ny5MlKTU1VYmLiRV8K/mJERUWpffv2OnLkyCWNk5CQcMljAAAAAAAAAAAAAAAAAACaHk2i8CknTpw4Z1lVVZUKCwsVFRXV4vX07t1bSUlJevbZZ1VcXHzO+sLCQn322WeSvr3c/Hezl0qS0+nU1q1b62z/3XpvZzK9kMLCQh09elRXXnnlJY3zt7/97ZLHAAAAAAAAAAAAAAAAAAA0PS43D58yatQopaenq3///oqJiVFRUZFWrVqlU6dOaeLEiUZqevzxx3X77bdr9OjRmjRpkhISEuRwOLRv3z6tXr1aixYtkt1uV2pqqtatW6euXbsqPDxcr776qhwOR52xoqOjFRYWpq1bt8pms8lqtcput8tqtV6whocffljh4eFKTExUaGioDh8+rJdfflmRkZG69dZbvTqOv/zlL3rjjTc0aNAgXXHFFSotLVV+fr52796txYsXN/r+AQAAAAAAAAAAAAAAAH7MXE636RKAetEkCp+SlZWlXbt2KTc3VyUlJQoPD5fdbtfy5cvVt29fIzXFxcVp06ZNWrZsmV577TUVFhbKarUqPj5e2dnZSk9PlyQ99NBDysnJ0fz58xUcHKyMjAwNGzZMc+fO9YxlsVi0cOFCLV68WJmZmXI4HNq5c6dsNtsFa0hKStLatWs9jadXXHGFBg4cqHvuuUfh4eFeHceVV14ph8OhJ554QqdOnfLctytXrlSfPn0afwcBAAAAAAAAAAAAAAAAAJqFn9vtpo0ZgDHVleXGsl3+gcayA8qLjeS6A1sZyZUkZ6swI7l+LqeRXEly+fkbyQ2oLjOSK0lyu8xlG+Jq1dZY9plaM6dxodUlRnIlSQEXnj27uZh6DZMkS02VkdwSp7n3yaiak0ZyXcHmns9VfmYe28FnzdzXkow9nyXpuDvESG60X6WRXMncMYcE+hnJ/alqXWXmPfqYpZ2RXEkKDrAYzDbz+G5VWmAkV5Kq2l74j1SbS2m1uc8ZMQ4zn99NnpfI0PclJr+nqa418xirMfgROtRq7vUz8NTXRnKLWnUwkitJp6vMfD9VWl1jJFeS4qOCjeQGGTw3sDjOGMs2pcrfzM9Zklqp1kju1wZ/zG2DzHzfbPJXyY7FvzGSGxhi7ncpsQ8sMZYNAAAuzV969zNdAiQN2r/HdAmXJXOflgEAAAAAAAAAAAAAAAAAANBsuNw80Ehut1tOZ/1/AW6xWGSxNH8ftsvlkstV/7QD/v7+8vO78Owml8uxAAAAAAAAAAAAAAAAAACaDk2iQCPt3btXEyZMqHd9RkaGcnNzm72O7Oxsbdq0qd71K1asUEpKygXHuFyOBQAAAAAAAAAAAAAAAADQdGgSBRopISFB69evr3d9eHh4i9SRlZWlcePG1bu+c+fODY5xuRwLAAAAAAAAAAAAAAAAAKDp0CQKNFJoaKgSExNNlyGbzSabzXZJY1wuxwIAAAAAAAAAAAAAAAAAaDo0iQIAAAAAAAAAAAAAAAAA0Ehup8t0CUC9LKYLAAAAAAAAAAAAAAAAAAAAQNOjSRQAAAAAAAAAAAAAAAAAAMAH0SQKAAAAAAAAAAAAAAAAAADggwJMFwDgp63K4MtQK8cZY9llraKM5J44W2skV5LaB7qN5AbXVBrJlaSqgFAjuf4Wc8+rs5ZWRnJDKouM5EqSn7/VWHZYuZnjdraJNZIrSf4Vx43kng1sYyRXkoICgozkRvg5jORK0r8qw4zkdgoONJIrSWXVTiO5wQHmXsNUa+4xFltl5rXki8ArjeRKUsc2Zv5GtLLGZSRXkqprzZx/RgT7G8mVJBl6TscaOteXpGNV5h5j4eVfmwn2M/c3361KC4zkflYbbSRXksKjrjCSG+CoMJIrSao5ayTW4qwxkitJFbVmXj+jg8y9fpZWm8uONPSd3GeV5r4LjI9ubSS3XStz5yUVDjPv0UEB5t4nTX0vFuxn5vOkJLVym/tc5zL0fUmY1dz93a76hJFct7+575sdD/7RSG6gs9pIriRVnDFzLhbaOthILgAAAFoGM4kCAAAAAAAAAAAAAAAAAAD4IJpEAQAAAAAAAAAAAAAAAAAAfBBNogAAAAAAAAAAAAAAAAAAAD4owHQBAAAAAAAAAAAAAAAAAAD8WLmdbtMlAPViJlEAAAAAAAAAAAAAAAAAAAAfRJMoAAAAAAAAAAAAAAAAAACAD6JJFAAAAAAAAAAAAAAAAAAAwAfRJAqfs3nzZt16663q1auXkpOTNXz4cM2ZM0cnT570bDN48GDNmzevxWoqKSlRbm6ubrzxRiUmJio5OVnjx4/XunXr5HQ6vR6nrKxMS5Ys0RdffNHoWlwul2655RbZ7XZt3779ovZdunSpJk2apN69e8tut+vjjz9udB0AAAAAAAAAAAAAAAAAgOYVYLoAoCktW7ZMTzzxhDIzMzV9+nS53W4dPHhQW7ZsUXFxsSIjIyVJeXl5CgsLa5Gajhw5ogkTJsjpdGrSpElKSEiQw+HQBx98oIULFyo8PFxDhw71aqyysjLl5eWpW7du6tq1a6PqWbNmjYqKihq17+uvv66rrrpKqampevPNNxs1BgAAAAAAAAAAAAAAAACgZdAkCp+ycuVKZWRkaPbs2Z5laWlpuuuuu+RyuTzL4uPjW6ymWbNmyel0asOGDYqNjfUsHzhwoMaPH6/y8vIWq6WkpERPP/20HnjgAWVnZ1/0/n/5y19ksVj04Ycf0iQKAAAAAAAAAAAAAAAAAJc5LjcPn1JWVqaYmJjzrrNY/u/h/sPLzc+ePVsjR47U+++/r1GjRikpKUnjx49XQUGBTp8+rRkzZig5OVlDhw7Vtm3bvK5n//79OnDggKZMmVKnQfQ7HTp0kN1ulyQdOnRI9913n9LS0tSjRw+NGDFCL730kqe5taCgQEOGDJEkzZgxQ3a7XXa7XQUFBV7Xs3jxYqWkpCglJcXrfb7v+/chAAAAAAAAAAAAAAAAAMnldPPvMviH82MmUfiUhIQErVmzRjabTYMGDVJ0dLTX+x4/fly5ubmaOnWqAgICtGDBAs2aNUvBwcHq3bu3xo4dq7Vr1+r+++9Xjx491LFjxwbH3Lt3ryRpwIABDW5bXFyszp07a9SoUQoJCdGnn36qJUuW6MyZM8rKylJMTIzy8vKUlZWlmTNneho962uK/aEDBw4oPz9f+fn5Xm0PAAAAAAAAAAAAAAAAAPhxo0kUPiUnJ0dZWVmaO3euJMlmsyk9PV2ZmZmy2WwX3Le0tFSrVq1St27dJH3btDl//nzdfffdmjZtmiQpMTFRO3bs0Ntvv62JEyc2WE9RUZGkb2cMbUi/fv3Ur18/SZLb7VavXr1UVVWlVatWKSsrS1arVddee60kKS4uTj179mxwzO+4XC498sgjmjRpkmw220XNPgoAAAAAAAAAAAAAAAAAqOvPf/6znnrqKR0+fFgdOnTQ5MmTNXr06Avus2TJEuXl5Z133W233ea5OnZ92/3ud7/Tr371q4uqkyZR+JRrrrlG+fn52rNnj3bv3q19+/Zp5cqV2rhxo1avXu1psjyfmJgYT4OoJHXq1EmSlJqa6lkWFhamiIgIHTt2rMlrr66u1nPPPactW7aosLBQNTU1nnWVlZUKCQlp9Njr1q3TiRMnNHny5KYoFQAAAAAAAAAAAAAAAAB+svbv36+srCzdeuutys7O1gcffKA5c+YoJCRE//Ef/1HvfmPGjDnnqtT79u3T448/roEDB9ZZ3qpVK73yyit1ll155ZUXXStNovA5VqtVaWlpSktLkyS9++67mjJlipYuXVpvF7b0bQPo9wUGBkqS2rRpc8741dXVXtUSGxsrSSosLFRcXNwFt33ssce0bt06TZs2Tdddd53atGmjnTt36plnnlF1dXWjm0QrKyu1ePFi3XfffaqpqVFNTY0qKiokSVVVVaqoqFBoaGijxgYAAAAAAAAAAAAAAACAn5pnnnlGSUlJnpk/+/btq6+//lp//OMfL9gk2r59e7Vv377OsjVr1qht27bnNIlaLJaLutp0fSyXPAJwmRswYIC6d++uQ4cOtXh2nz59JEm7d+9ucNvt27frtttu0+TJk5WamqrExEQFBFx6H/epU6d0+vRp5eTk6IYbbtANN9ygm266SZL04IMP6sYbb7zkDAAAAAAAAAAAAAAAAAD4KXA4HPrwww/PaQYdMWKEDh06pIKCAq/Hqq6u1o4dO3TjjTfKarU2damSmEkUPubEiROKioqqs6yqqkqFhYXq2rVri9fTu3dvJSUl6dlnn9WwYcMUExNTZ31hYaHKyspkt9tVXV3tmb1UkpxOp7Zu3Vpn++/WezuTqSRFR0drxYoVdZadOHFCM2fO1L333qvU1NSLPSwAAAAAAAAAAAAAAAAA+En66quvVFNToy5dutRZfvXVV0uSvvzyS9lsNq/G2rVrlyoqKjRy5Mhz1lVVValv374qKytTp06dlJmZqbFjx150vTSJwqeMGjVK6enp6t+/v2JiYlRUVKRVq1bp1KlTmjhxopGaHn/8cd1+++0aPXq0Jk2apISEBDkcDu3bt0+rV6/WokWLZLfblZqaqnXr1qlr164KDw/Xq6++KofDUWes6OhohYWFaevWrbLZbLJarbLb7RfsIg8KClJKSkqdZd91q3ft2lXJycleH8vevXtVUlKiL774QpL0wQcf6JtvvlHHjh2VmJjo9TgAAAAAAAAAAAAAAAAA0JSGDBlywfU7d+5skpzS0lJJUlhYWJ3l393+br038vPzFRsbqxtuuKHO8quuukqzZs1SfHy8qqurtWXLFj300EMqLy/XnXfeeVH10iQKn5KVlaVdu3YpNzdXJSUlCg8Pl91u1/Lly9W3b18jNcXFxWnTpk1atmyZXnvtNRUWFspqtSo+Pl7Z2dlKT0+XJD300EPKycnR/PnzFRwcrIyMDA0bNkxz5871jGWxWLRw4UItXrxYmZmZcjgc2rlzp9ed55dqyZIl2rt3r+f2448/LknKyMhQbm5ui9QAAAAAAAAAAAAAAAAAXE7cLpfpEnCJysvLVVxc3OB2V155ZZNllpWV6Z133tH48eNlsVjqrLvpppvq3B40aJBqamr0zDPPaMKECXWuWN0QmkThU8aNG6dx48Y1uN2f//znOrfP1+CYkpKizz77rMF9vREZGanZs2dr9uzZ9W4TFRWlpUuXnrN8zJgxdW4PHTpUQ4cOvegavs9ms5332BqycuXKS8oFAAAAAAAAAAAAAAAAgOZwKTOFbt++vc5kfvXZtm2b2rZtK+nbxtLvKysrkyTP+oa8+eabcjgcGjVqlFfbDx8+XG+++aa++uorz6XtvUGTKAAAAAAAAAAAAAAAAAAA+MkaM2bMOZP51cfhcCgwMFBffvmlBgwY4Fn+5ZdfSpK6dOni1Tj5+fnq0qWL4uPjL77gi2BpeBMA5+N2u1VbW1vvP1cLTSPtcrkuWIfb7W5wjMvlWAAAAAAAAAAAAAAAAADgcma1WpWSkqI333yzzvJt27bp6quvls1ma3CM4uJi7d27VyNHjvQ6d9u2bQoLC9NVV111UfUykyjQSHv37tWECRPqXZ+RkXHey9g3tezsbG3atKne9StWrFBKSsoFx9i0aZN++9vf1rs+KytL9957b6NrBAAAAAAAAAAAAAAAAABfMXXqVE2YMEG/+93vNHz4cH344YfKz8/Xk08+WWe7+Ph43Xzzzfr9739fZ/m2bdvkcrnqvdT8LbfcoptvvlldunRRVVWVtmzZorfeekvZ2dkKDAy8qFppEgUaKSEhQevXr693fXh4eIvUkZWVpXHjxtW7vnPnzg2OkZ6efsFjiYmJaVRtAAAAAAAAAAAAAAAAAOBrevfurSVLluipp57S+vXr1aFDBy1YsEDDhw+vs53T6TzvVZy3bNmipKSkemcFveqqq7R8+XKdOHFCfn5+uuaaa/TYY4/pl7/85UXXSpMo0EihoaFKTEw0XYZsNptXUxRfSHh4eIs1tQIAAAAAAAAAAAAAAADAj92QIUM0ZMiQC27z2WefnXf5hg0bLrjfU0891diyzmFpspEAAAAAAAAAAAAAAAAAAABw2WAmUQAAAAAAAAAAAAAAAAAAGsnldJsuAagXM4kCAAAAAAAAAAAAAAAAAAD4IJpEAQAAAAAAAAAAAAAAAAAAfBBNogAAAAAAAAAAAAAAAAAAAD7Iz+12u00XAeCnq/zMWWPZVpfDWLafo9JMsCXATK4kd0CQmVx/q5FcSbJUlRrJLfUPM5IrSeHlR4zkukIijeRKZh9jrsBWRnIdTnOnj63cZl67LWfNPJ8lydU63Eyuf6CRXEnyP3vaSK4rqI2RXEmqMfT3eyafz0H+fsayS6tdRnKjnaeM5EpSdWsz75XmfsqSqYd3kME/xy2oqDWSG+c+aSRXkvxqzH2m/CrIZiQ3opW/kVxJal1TZibYaeaxLUnuoFAzwRZzP+fSWjMvZP4Wc+8aoe4qM8F+5t40avzNfE8jSRU1Zs7FoioLjORKUmXbq4zknjF0X0uS02XmZMxq8HNG60Azz+laQ/e1JAUYfO029b4RUHbMSK4knQqKNpLbJsjceYmpx3fr4s+M5ErS4ZCrjeR23POykVxJCv7ldGPZAAA0pTevSTZdAiTd+PlHpku4LDGTKAAAAAAAAAAAAAAAAAAAgA+iSRQAAAAAAAAAAAAAAAAAAMAHmbvuMAAAAAAAAAAAAAAAAAAAP3Jup9t0CUC9mEkUAAAAAAAAAAAAAAAAAADAB9EkCgAAAAAAAAAAAAAAAAAA4INoEgUAAAAAAAAAAAAAAAAAAPBBNIkCAAAAAAAAAAAAAAAAAAD4IJpE4XM2b96sW2+9Vb169VJycrKGDx+uOXPm6OTJk55tBg8erHnz5rVYTSUlJcrNzdWNN96oxMREJScna/z48Vq3bp2cTqfX45SVlWnJkiX64osvGl2Ly+XSLbfcIrvdru3bt3u935dffql58+ZpxIgR6tGjhwYPHqycnByVlJQ0uhYAAAAAAAAAAAAAAAAAQPMJMF0A0JSWLVumJ554QpmZmZo+fbrcbrcOHjyoLVu2qLi4WJGRkZKkvLw8hYWFtUhNR44c0YQJE+R0OjVp0iQlJCTI4XDogw8+0MKFCxUeHq6hQ4d6NVZZWZny8vLUrVs3de3atVH1rFmzRkVFRRe93/vvv6/9+/frtttuU/fu3XX06FH98Y9/1N69e/Vf//VfslqtjaoHAAAAAAAAAAAAAAAAANA8aBKFT1m5cqUyMjI0e/Zsz7K0tDTdddddcrlcnmXx8fEtVtOsWbPkdDq1YcMGxcbGepYPHDhQ48ePV3l5eYvVUlJSoqeffloPPPCAsrOzL2rfX/ziFxo3bpz8/Pw8y+Li4vSrX/1Ku3bt0o033tjU5QIAAAAAAAAAAAAAAAAALgGXm4dPKSsrU0xMzHnXWSz/93D/4eXmZ8+erZEjR+r999/XqFGjlJSUpPHjx6ugoECnT5/WjBkzlJycrKFDh2rbtm1e17N//34dOHBAU6ZMqdMg+p0OHTrIbrdLkg4dOqT77rtPaWlp6tGjh0aMGKGXXnrJ09xaUFCgIUOGSJJmzJghu90uu92ugoICr+tZvHixUlJSlJKS4vU+3wkPD6/TICr9X7NtcXHxRY8HAAAAAAAAAAAAAAAA+AK308W/y+Afzo+ZROFTEhIStGbNGtlsNg0aNEjR0dFe73v8+HHl5uZq6tSpCggI0IIFCzRr1iwFBwerd+/eGjt2rNauXav7779fPXr0UMeOHRscc+/evZKkAQMGNLhtcXGxOnfurFGjRikkJESffvqplixZojNnzigrK0sxMTHKy8tTVlaWZs6c6Wn0rK8p9ocOHDig/Px85efne7W9N/72t79Jkq6++uomGxMAAAAAAAAAAAAAAAAA0DRoEoVPycnJUVZWlubOnStJstlsSk9PV2Zmpmw22wX3LS0t1apVq9StWzdJ3zZtzp8/X3fffbemTZsmSUpMTNSOHTv09ttva+LEiQ3WU1RUJOnbGUMb0q9fP/Xr10+S5Ha71atXL1VVVWnVqlXKysqS1WrVtddeK+nby7z37NmzwTG/43K59Mgjj2jSpEmy2WwXNftofaqrq7Vo0SLFx8d76gYAAAAAAAAAAAAAAAAAXD5oEoVPueaaa5Sfn689e/Zo9+7d2rdvn1auXKmNGzdq9erVnibL84mJifE0iEpSp06dJEmpqameZWFhYYqIiNCxY8eavPbq6mo999xz2rJliwoLC1VTU+NZV1lZqZCQkEaPvW7dOp04cUKTJ09uilIlfduQW1BQoDVr1pxzGXoAAAAAAAAAAAAAAAAAgHkW0wUATc1qtSotLU1z5szRG2+8oRdeeEFVVVVaunTpBfcLCwurczswMFCS1KZNm3PGr66u9qqW2NhYSVJhYWGD2z722GN68cUXNWbMGD3//PNav369pk6dKkle551PZWWlFi9erKlTp6qmpkZlZWWqqKiQJFVVVXn+fzGefPJJbdmyRU8//bSuueaaRtcGAAAAAAAAAAAAAAAAAGg+zCQKnzdgwAB1795dhw4davHsPn36SJJ2796tuLi4C267fft23XbbbXVm+3znnXcuuYZTp07p9OnTysnJUU5OTp11Dz74oKKiovTee+95Pd7KlSv13HPPKTc3VwMGDLjk+gAAAAAAAAAAAAAAAAAAzYMmUfiUEydOKCoqqs6yqqoqFRYWqmvXri1eT+/evZWUlKRnn31Ww4YNU0xMTJ31hYWFKisrk91uV3V1tWf2UklyOp3aunVrne2/W38xM4tGR0drxYoVdZadOHFCM2fO1L333qvU1FSvx8rPz9ejjz6qmTNn6uabb/Z6PwAAAAAAAAAAAAAAAABAy6NJFD5l1KhRSk9PV//+/RUTE6OioiKtWrVKp06d0sSJE43U9Pjjj+v222/X6NGjNWnSJCUkJMjhcGjfvn1avXq1Fi1aJLvdrtTUVK1bt05du3ZVeHi4Xn31VTkcjjpjRUdHKywsTFu3bpXNZpPVapXdbpfVaq03PygoSCkpKXWWFRQUSJK6du2q5ORkr45j7969mj17tvr27as+ffroH//4h2dd+/bt1b59ey/vEQAAAAAAAAAAAAAAAABAS6BJFD4lKytLu3btUm5urkpKShQeHi673a7ly5erb9++RmqKi4vTpk2btGzZMr322msqLCyU1WpVfHy8srOzlZ6eLkl66KGHlJOTo/nz5ys4OFgZGRkaNmyY5s6d6xnLYrFo4cKFWrx4sTIzM+VwOLRz507ZbLZmP44PP/xQNTU12rNnj/bs2VNnXVZWlu69995mrwEAAAAAAAAAAAAAAAC43LicbtMlAPXyc7vdPEIBGFN+5qyxbKvL0fBGzcTPUWkm2GLubwPcAUFmcv3rn2m3uVmqSo3klvqHGcmVpPDyI0ZyXSGRRnIls48xV2ArI7kOgx9wWrnNvHZbzpp5PkuSq3W4mVz/QCO5kuR/9rSRXFdQGyO5klQji5Fck8/nIH8/Y9ml1S4judHOU0ZyJam6tZn3SnM/ZcnUwzvIzNNZklRQUWskN8590kiuJPnVmPtM+VVQ8//B5vlEtPI3kitJrWvKzAQ7zTy2JckdFGom2GLu51xaa+aFzN9i7l0j1F1lJtjP3JtGjb+Z72kkqaLGzLlYVGWBkVxJqmx7lZHcM4bua0lyusycjFkNfs5oHWjmOV1r6L6WpACDr92m3jcCyo4ZyZWkU0HRRnLbBJk7LzH1+G5d/JmRXEk6HHK1kdyOe142kitJwb+cbiwbAICmtPXKJNMlQNIvvj5guoTLksFfXQAAAAAAAAAAAAAAAAAAAKC5cLl5oJHcbrecTme96y0WiyyW5u/Ddrlccrnq/4twf39/+fld+C9qL5djAQAAAAAAAAAAAAAAAAA0HZpEgUbau3evJkyYUO/6jIwM5ebmNnsd2dnZ2rRpU73rV6xYoZSUlAuOsWnTJv32t7+td31WVpbuvffeRtcIAAAAAAAAAAAAAAAAAGh5NIkCjZSQkKD169fXuz48PLxF6sjKytK4cePqXd+5c+cGx0hPT7/gscTExDSqNgAAAAAAAAAAAAAAAACAOTSJAo0UGhqqxMRE02XIZrPJZrNd0hjh4eEt1tQKAAAAAAAAAAAAAAAAAGgZNIkCAAAAAAAAAAAAAAAAANBIbqfbdAlAvSymCwAAAAAAAAAAAAAAAAAAAEDTo0kUAAAAAAAAAAAAAAAAAADAB9EkCgAAAAAAAAAAAAAAAAAA4INoEgUAAAAAAAAAAAAAAAAAAPBBAaYLAPDTFuQoN5Z9JiDUWHZrPzM9+m6LwZd9l9NIbLHDTK4khQSGGckN9vczkitJzrYdjOSeqDH32K44a+4x1slSYyS31uVvJFeSvq4y8/oZ0SrKSK4khbjN/JwdTreRXElqFdDKSK6lqtRIriQ5re2M5JYYfA2zhQUayw4LMvT3kjVmHtuSFGAxc34QeOKQkVxJcrWJNZLrDDL3OcMWYuaxXeaMMZIrSe2qzT3G2gaZOSeqcLiM5ErSWUsbI7lRruNGciXpeK2Z96tyg59lrf5mHmNWQ+9VktRGVUZyS/zbGsmVpECZO98/U2PmMeb2txrJlaTWn7xpJDckwNw5t6VdtJHc2qguRnIlye0OMpNr8jtfg9yGXsachj5nSFI7Q99bHD9r5hxQkiLNPK10OvIaM8GSrnKdMRMc2d5MrqTqP68wkhs0eIKRXAAAABOYSRQAAAAAAAAAAAAAAAAAAMAH0SQKAAAAAAAAAAAAAAAAAADgg36a16AAAAAAAAAAAAAAAAAAAKAJuNxu0yUA9WImUQAAAAAAAAAAAAAAAAAAAB9EkygAAAAAAAAAAAAAAAAAAIAPokkUAAAAAAAAAAAAAAAAAADAB9EkCp+zefNm3XrrrerVq5eSk5M1fPhwzZkzRydPnvRsM3jwYM2bN6/FaiopKVFubq5uvPFGJSYmKjk5WePHj9e6devkdDq9HqesrExLlizRF1980ehaXC6XbrnlFtntdm3fvt3r/crLy3Xvvfdq8ODBSkpKUt++fXXXXXfpwIEDja4FAAAAAAAAAAAAAAAAANB8AkwXADSlZcuW6YknnlBmZqamT58ut9utgwcPasuWLSouLlZkZKQkKS8vT2FhYS1S05EjRzRhwgQ5nU5NmjRJCQkJcjgc+uCDD7Rw4UKFh4dr6NChXo1VVlamvLw8devWTV27dm1UPWvWrFFRUdFF7+dwOGS1WjV16lTZbDZVVFTolVde0cSJE7Vx40Z17ty5UfUAAAAAAAAAAAAAAAAAAJoHTaLwKStXrlRGRoZmz57tWZaWlqa77rpLLpfLsyw+Pr7Fapo1a5acTqc2bNig2NhYz/KBAwdq/PjxKi8vb7FaSkpK9PTTT+uBBx5Qdnb2Re0bGRmpJ554os6y1NRUpaSk6M0339Q999zTlKUCAAAAAAAAAAAAAAAAAC4Rl5uHTykrK1NMTMx511ks//dw/+Hl5mfPnq2RI0fq/fff16hRo5SUlKTx48eroKBAp0+f1owZM5ScnKyhQ4dq27ZtXtezf/9+HThwQFOmTKnTIPqdDh06yG63S5IOHTqk++67T2lpaerRo4dGjBihl156ydPcWlBQoCFDhkiSZsyYIbvdLrvdroKCAq/rWbx4sVJSUpSSkuL1PhfSunVrBQUFqaampknGAwAAAAAAAAAAAAAAAAA0HWYShU9JSEjQmjVrZLPZNGjQIEVHR3u97/Hjx5Wbm6upU6cqICBACxYs0KxZsxQcHKzevXtr7NixWrt2re6//3716NFDHTt2bHDMvXv3SpIGDBjQ4LbFxcXq3LmzRo0apZCQEH366adasmSJzpw5o6ysLMXExCgvL09ZWVmaOXOmp9GzvqbYHzpw4IDy8/OVn5/v1fb1cblccrlcKikp0YsvviiLxaKbb775ksYEAAAAAAAAAAAAAAAAfqycbrfpEoB60SQKn5KTk6OsrCzNnTtXkmSz2ZSenq7MzEzZbLYL7ltaWqpVq1apW7dukr5t2pw/f77uvvtuTZs2TZKUmJioHTt26O2339bEiRMbrKeoqEjStzOGNqRfv37q16+fJMntdqtXr16qqqrSqlWrlJWVJavVqmuvvVaSFBcXp549ezY45ndcLpceeeQRTZo0STab7aJmH/2hp59+Ws8++6ykby9B//zzz+vKK69s9HgAAAAAAAAAAAAAAAAAgOZBkyh8yjXXXKP8/Hzt2bNHu3fv1r59+7Ry5Upt3LhRq1ev9jRZnk9MTIynQVSSOnXqJElKTU31LAsLC1NERISOHTvW5LVXV1frueee05YtW1RYWFjnEu6VlZUKCQlp9Njr1q3TiRMnNHny5Euu89e//rWGDh2q48ePa926dZo8ebKWL1+uhISESx4bAAAAAAAAAAAAAAAAANB0LKYLAJqa1WpVWlqa5syZozfeeEMvvPCCqqqqtHTp0gvuFxYWVud2YGCgJKlNmzbnjF9dXe1VLbGxsZKkwsLCBrd97LHH9OKLL2rMmDF6/vnntX79ek2dOlWSvM47n8rKSi1evFhTp05VTU2NysrKVFFRIUmqqqry/N9bsbGxSkxM1ODBg7V06VJdeeWV+uMf/9jo+gAAAAAAAAAAAAAAAAAAzYOZROHzBgwYoO7du+vQoUMtnt2nTx9J0u7duxUXF3fBbbdv367bbrutzmyf77zzziXXcOrUKZ0+fVo5OTnKycmps+7BBx9UVFSU3nvvvUaNbbFYdO211+pvf/vbJdcJAAAAAAAAAAAAAAAAAGhaNInCp5w4cUJRUVF1llVVVamwsFBdu3Zt8Xp69+6tpKQkPfvssxo2bJhiYmLqrC8sLFRZWZnsdruqq6s9s5dKktPp1NatW+ts/936i5lZNDo6WitWrKiz7MSJE5o5c6buvfdepaamXuxhedTW1urAgQO68sorGz0GAAAAAAAAAAAAAAAAAKB50CQKnzJq1Cilp6erf//+iomJUVFRkVatWqVTp05p4sSJRmp6/PHHdfvtt2v06NGaNGmSEhIS5HA4tG/fPq1evVqLFi2S3W5Xamqq1q1bp65duyo8PFyvvvqqHA5HnbGio6MVFhamrVu3ymazyWq1ym63y2q11psfFBSklJSUOssKCgokSV27dlVycrJXx/H666/rwIEDSk1NVXR0tE6cOKE1a9bo8OHD58xQCgAAAAAAAAAAAAAAAAAwjyZR+JSsrCzt2rVLubm5KikpUXh4uOx2u5YvX66+ffsaqSkuLk6bNm3SsmXL9Nprr6mwsFBWq1Xx8fHKzs5Wenq6JOmhhx5STk6O5s+fr+DgYGVkZGjYsGGaO3euZyyLxaKFCxdq8eLFyszMlMPh0M6dO2Wz2Zr9OLp27aq33npLjz76qMrKyhQdHa3ExEStX79e3bt3b/Z8AAAAAAAAAAAAAAAA4HLkdJuuAKifn9vt5iEKwBjH6WJj2WcCQo1lt64pM5Lr9q9/1llfVVRr7phDAi1GcoP8/YzkSlKgy9HwRs3gRI25v3upqHEay+4UYuZnXeHyN5IrSaeqzNzfEa3MHXOIX42R3Co/c6+frVzVRnL9as4YyZWkM9Z2RnKPnzH3GmYLCzSWXesy8zE4qKbSSK4kOYPMnPsGnjhkJFeSXG1ijeSauq8lyc9l5jld6TR3/tnutLnH2Ol2VxvJPVvjMpIrSf4WMz/rKMdxI7mSVBwYbSS33GHuPdpq6DOl1dDjS5JiZOZ7mhL/tkZyJSnQ4P1dWm3m8X2l84SRXEnSv/9pJNYvwNw5t6WdmdfP2qguRnIlyR0QZCTX4WfuezFzrySSxc9MukXmfq1qqSo1kntcbYzkSlKkmaeV0c84bVyGvp/65M9mciW5q6uM5AYNnmAkFwDgu9bHJpguAZJuLfqX6RIuS2a6VwAAAAAAAAAAAAAAAAAAANCsuNw80Ehut1tOZ/1/9W6xWGSxNH8ftsvlkstV/ywi/v7+8mvgL2ovl2MBAAAAAAAAAAAAAAAAADQdmkSBRtq7d68mTKj/MgQZGRnKzc1t9jqys7O1adOmetevWLFCKSkpFxxj06ZN+u1vf1vv+qysLN17772NrhEAAAAAAAAAAAAAAAAA0PJoEgUaKSEhQevXr693fXh4eIvUkZWVpXHjxtW7vnPnzg2OkZ6efsFjiYmJaVRtAAAAAAAAAAAAAAAAAABzaBIFGik0NFSJiYmmy5DNZpPNZrukMcLDw1usqRUAAAAAAAAAAAAAAAAA0DIspgsAAAAAAAAAAAAAAAAAAABA02MmUQAAAAAAAAAAAAAAAAAAGsnpdpsuAagXM4kCAAAAAAAAAAAAAAAAAAD4IJpEAQAAAAAAAAAAAAAAAAAAfBBNogAAAAAAAAAAAAAAAAAAAD4owHQBAH7aXNYQY9n+8jOWfdrSxkhuO1elkVxJOhto5phjddZIriTJz99Mbq3TTK6kolqrkdxWhu5qSepsrTKW/dWZYCO5VwaZO+agEDPHbFKlM9BIbnCAufdJS8UpI7lnQtsbyZWkNsWfGskNtZp7TpXVxBnLtvqbeXy7LeY+gvtXlRnJPRvRxUiuJLUqO2ok1xIQZCRXkvzOlpoJDoowkyvpy6BOxrLjnBVGckNamfscfbLaTK4ruJ2ZYEnRTjOfo2Ms5s65/arNHLPb38znSUmqbdfRSG47l7nP7wGnjhjLbhMabSTX1crc+9WxrkON5EYEm/vCJKjKzOc6k+fcMvSctrprjORKktvkua/LZSS3yuCvVqsN/V4hKsDMfS1Jcpp5XpWcNff6GeYy87mu9uQxI7mS5D5r5vyz+s8rjORKUtDgCcayAQDATxMziQIAAAAAAAAAAAAAAAAAAPggmkQBAAAAAAAAAAAAAAAAAAB8EE2iAAAAAAAAAAAAAAAAAAAAPijAdAEAAAAAAAAAAAAAAAAAAPxYOd2mKwDqx0yiAAAAAAAAAAAAAAAAAAAAPogmUQAAAAAAAAAAAAAAAAAAAB9EkygAAAAAAAAAAAAAAAAAAIAPokkUPmfz5s269dZb1atXLyUnJ2v48OGaM2eOTp486dlm8ODBmjdvXovVVFJSotzcXN14441KTExUcnKyxo8fr3Xr1snpdHo9TllZmZYsWaIvvvii0bW4XC7dcsststvt2r59e6PHefTRR2W321v0fgQAAAAAAAAAAAAAAAAAeC/AdAFAU1q2bJmeeOIJZWZmavr06XK73Tp48KC2bNmi4uJiRUZGSpLy8vIUFhbWIjUdOXJEEyZMkNPp1KRJk5SQkCCHw6EPPvhACxcuVHh4uIYOHerVWGVlZcrLy1O3bt3UtWvXRtWzZs0aFRUVNWrf73z22WfasGGDQkNDL2kcAAAAAAAAAAAAAAAAAEDzoUkUPmXlypXKyMjQ7NmzPcvS0tJ01113yeVyeZbFx8e3WE2zZs2S0+nUhg0bFBsb61k+cOBAjR8/XuXl5S1WS0lJiZ5++mk98MADys7ObvQ48+fPV2Zmpt54442mKw4AAAAAAAAAAAAAAAAA0KS43Dx8SllZmWJiYs67zmL5v4f7Dy83P3v2bI0cOVLvv/++Ro0apaSkJI0fP14FBQU6ffq0ZsyYoeTkZA0dOlTbtm3zup79+/frwIEDmjJlSp0G0e906NBBdrtdknTo0CHdd999SktLU48ePTRixAi99NJLnubWgoICDRkyRJI0Y8YM2e122e12FRQUeF3P4sWLlZKSopSUFK/3+aHNmzeroKBAd999d6PHAAAAAAAAAAAAAAAAAHyF0+3m32XwD+fHTKLwKQkJCVqzZo1sNpsGDRqk6Ohor/c9fvy4cnNzNXXqVAUEBGjBggWaNWuWgoOD1bt3b40dO1Zr167V/fffrx49eqhjx44Njrl3715J0oABAxrctri4WJ07d9aoUaMUEhKiTz/9VEuWLNGZM2eUlZWlmJgY5eXlKSsrSzNnzvQ0etbXFPtDBw4cUH5+vvLz873a/nwqKir0hz/8QdnZ2QoODm70OAAAAAAAAAAAAAAAAACA5keTKHxKTk6OsrKyNHfuXEmSzWZTenq6MjMzZbPZLrhvaWmpVq1apW7dukn6tmlz/vz5uvvuuzVt2jRJUmJionbs2KG3335bEydObLCeoqIiSd/OGNqQfv36qV+/fpIkt9utXr16qaqqSqtWrVJWVpasVquuvfZaSVJcXJx69uzZ4JjfcblceuSRRzRp0iTZbLaLmn30+/Ly8hQXF6cRI0Y0an8AAAAAAAAAAAAAAAAAQMuhSRQ+5ZprrlF+fr727Nmj3bt3a9++fVq5cqU2btyo1atXe5oszycmJsbTICpJnTp1kiSlpqZ6loWFhSkiIkLHjh1r8tqrq6v13HPPacuWLSosLFRNTY1nXWVlpUJCQho99rp163TixAlNnjy50WMcPHhQq1ev1tq1axs9BgAAAAAAAAAAAAAAAACg5VhMFwA0NavVqrS0NM2ZM0dvvPGGXnjhBVVVVWnp0qUX3C8sLKzO7cDAQElSmzZtzhm/urraq1piY2MlSYWFhQ1u+9hjj+nFF1/UmDFj9Pzzz2v9+vWaOnWqJHmddz6VlZVavHixpk6dqpqaGpWVlamiokKSVFVV5fl/Q3Jzc/Uf//Ef6tixo8rKylRWViaXy+UZ0+VyNbpGAAAAAAAAAAAAAAAAAEDTYyZR+LwBAwaoe/fuOnToUItn9+nTR5K0e/duxcXFXXDb7du367bbbqsz2+c777xzyTWcOnVKp0+fVk5OjnJycuqse/DBBxUVFaX33nuvwXEOHz6s3bt3a/PmzXWWr127VmvXrtW2bdt09dVXX3K9AAAAAAAAAAAAAAAAAICmQZMofMqJEycUFRVVZ1lVVZUKCwvVtWvXFq+nd+/eSkpK0rPPPqthw4YpJiamzvrCwkKVlZXJbrerurraM3upJDmdTm3durXO9t+tv5iZRaOjo7VixYo6y06cOKGZM2fq3nvvVWpqqlfjLF68+JzcmTNnqmfPnpowYYI6dOjgdU0AAAAAAAAAAAAAAAAAgOZHkyh8yqhRo5Senq7+/fsrJiZGRUVFWrVqlU6dOqWJEycaqenxxx/X7bffrtGjR2vSpElKSEiQw+HQvn37tHr1ai1atEh2u12pqalat26dunbtqvDwcL366qtyOBx1xoqOjlZYWJi2bt0qm80mq9Uqu90uq9Vab35QUJBSUlLqLCsoKJAkde3aVcnJyV4dR8+ePc87dmxs7DnjAwAAAAAAAAAAAAAAAADMo0kUPiUrK0u7du1Sbm6uSkpKFB4eLrvdruXLl6tv375GaoqLi9OmTZu0bNkyvfbaayosLJTValV8fLyys7OVnp4uSXrooYeUk5Oj+fPnKzg4WBkZGRo2bJjmzp3rGctisWjhwoVavHixMjMz5XA4tHPnTtlsNiPHBgAAAAAAAAAAAAAAAPzUOd2mKwDq5+d2u3mIAjCm6kylsewaWYxln61xGclt5zZ3f58NbGMkt5XzrJFcSZLF30yuy2kmV1JRbf0zGzenVv5+RnIls8+rr2qCjeReGVRjJFeSagLMHLNJDkOfKIMDzb1PBpQWGsk9E9reSK4khRZ/aiTXbTX3nCoLizOWbTX0vhHorDaSK0l+TkfDGzWDaquZc0BJalV21Eiuq02MkVxJ8jtbaiS3PCjCSK4klZw1d+4bZzXzWcNlDTGSK0knDb2MRQWYO/809frpV1NlJFeS/BxmPuO4/c18npSk2nYdjeT6Gfz8HnDqK2PZrtBoI7lu/0AjuZJ0rNrMd0QRwYa+m5IUVHXKSK47sLWRXKPcZr5rliR3QJCxbD9Dx11lcP6d6lozx9w2wNxjzNR33V+dNff62clVbCS3du9WI7mS5D5r5vzTP9rMOaAkBQ2eYCwbANB8lkdea7oESMo8aeZ3bpc7c7/5BQAAAAAAAAAAAAAAAAAAQLPhcvNAI7ndbjmd9f8Fo8VikcXS/H3YLpdLLlf9f8Xp7+8vP78Lz5R0uRwLAAAAAAAAAAAAAAAAAKDp0CQKNNLevXs1YUL9lwLIyMhQbm5us9eRnZ2tTZs21bt+xYoVSklJueAYmzZt0m9/+9t612dlZenee+9tdI0AAAAAAAAAAAAAAAAAgJZHkyjQSAkJCVq/fn2968PDw1ukjqysLI0bN67e9Z07d25wjPT09AseS0xMTKNqAwAAAAAAAAAAAAAAAACYQ5Mo0EihoaFKTEw0XYZsNptsNtsljREeHt5iTa0AAAAAAAAAAAAAAAAAgJZhMV0AAAAAAAAAAAAAAAAAAAAAmh4ziQIAAAAAAAAAAAAAAAAA0EhOt9t0CUC9mEkUAAAAAAAAAAAAAAAAAADAB9EkCgAAAAAAAAAAAAAAAAAA4INoEgUAAAAAAAAAAAAAAAAAAPBBAaYLAPDTVun0M5Yd5G8sWq0DDfXoV9WayZXkb+hH7ecyd8wylH3wbCsjuZIU2drMD7qdu9JIriT51VQZy74qwGUktzawnZFcSbJWnjCS6w5uayRXkmr9zLxhBZQWGsmVJHdQiJHcVs6zRnIl6WSE3Uiun5+5c7Ewvxpj2Q5ZjeQePmPu7zQ7tmljJDeoxtx7tNsabCTX72ypkVxJ+kZm3q9iA8w9tm1h5rKLz5h5Da2scBrJlaSrwsy8fvqdMfe8cgeY+Xx1JjjKSK4kHXW2M5IbYuq7EkmVpx1Gcrv5nTSSK0lfBdmMZTurzeTGBZo7L3E4zXzGOX7G3PdiV9aa+XxVGtDOSK4khfmZeS2p9DP3XaC/29xnSqu/me9LzlSZOxerqjXzXWA7GXrhllRhaW0k96oQcz9nlyvSSO6Z9LuM5EpSZY2Zx3aHqm+M5EqSo9TM99ySZG1r7rMGAAAwh5lEAQAAAAAAAAAAAAAAAAAAfBBNogAAAAAAAAAAAAAAAAAAAD6Iy80DAAAAAAAAAAAAAAAAANBITrfpCoD6MZMoAAAAAAAAAAAAAAAAAACAD6JJFAAAAAAAAAAAAAAAAAAAwAfRJAoAAAAAAAAAAAAAAAAAAOCDaBIFAAAAAAAAAAAAAAAAAADwQQGmC7jcbN68WStWrNDhw4fldrsVGxur5ORkzZw5U5GRkZKkwYMHa9CgQXr44YebrY4lS5YoLy/vgtt07NhRf/7zny8pp6ysTK+88oqGDx+url27XvT++/fv14svvqh//OMfKi8vV0REhPr06aOJEycqMTHR63E+/PBD/f3vf9c999xzUfkvvPCC8vPzVVBQoNraWl155ZW67bbbNG7cOPn5+f2ojuXH4MiRI3rxxRf1z3/+UwcPHlSXLl2Un59vuiwAAAAAAAAAAAAAAAAAwHnQJPo9y5Yt0xNPPKHMzExNnz5dbrdbBw8e1JYtW1RcXOxpEs3Ly1NYWFiz1jJmzBgNGDDAc3vdunXKz8/XK6+84llmtVovOaesrEx5eXnq1q3bRTeJrl69WvPnz1ffvn01Z84cxcbGqqioSFu2bNEdd9yhffv2eT3W3r179dJLL110Y2V5eblGjBihbt26KSgoSHv27NGCBQtUUVFxUWNdDsfyY3Dw4EG988476tGjh1wul9xut+mSAAAAAAAAAAAAAAAAAAD1oEn0e1auXKmMjAzNnj3bsywtLU133XWXXC6XZ1l8fHyz19K+fXu1b9/ec/vdd9+VxWJRz549mz3bG//7v/+r3//+97rpppuUm5tbZ9bOkSNHateuXS1Sx3333Vfndmpqqo4ePapNmzZ53aR5uRxLS3A4HAoICJDFYmnU/oMHD9bQoUMlSbNnz9Ynn3zSlOUBAAAAAAAAAAAAAAAAAJpQ4zrFfFRZWZliYmLOu+77TXWDBw/WvHnzPLdnz56tkSNH6v3339eoUaOUlJSk8ePHq6CgQKdPn9aMGTOUnJysoUOHatu2bU1W77FjxzRr1iylpKQoKSlJ48aNq9O0t3z5cl133XX6n//5H8+yr776Stdff72eeOIJFRQUaMiQIZKkGTNmyG63y263q6CgoMHsFStWyM/PTw8++OB5L+uenp7u+f8bb7yhX/3qV+rTp49uuOEG3X777Tpw4IBn/ZIlS5SXl6czZ854arj99tsbdZ9IUnh4uGpqarzeviWP5dChQ5o6dap69eqlnj17avLkyfrqq6/q5JWXl2vWrFm6/vrr1a9fPy1evFgvvfSS7HZ7ne2++eYbTZ8+3TPWnXfeqc8++6zONt89VpctW6b09HQlJSXpo48+kt1u13vvvVdnW6fTqQEDBugPf/hDvfdVY5tLAQAAAAAAAAAAAAAAAF/ldPPvcviH82Mm0e9JSEjQmjVrZLPZNGjQIEVHR3u97/Hjx5Wbm6upU6cqICBACxYs0KxZsxQcHKzevXtr7NixWrt2re6//3716NFDHTt2vKRaS0tL9etf/1qtW7fWQw89pDZt2mjlypWaOHGi3nrrLUVGRmrixInauXOn7r//fm3cuFEBAQF64IEHdNVVV+nee++VJOXl5SkrK0szZ85USkqKJNXbKPt9+/bt03XXXaeIiIgGty0oKNDNN9+sq666Sg6HQ1u3btW4ceO0efNmde7cWWPGjNGxY8eUn5+vV155RZIUGhp6UfdHbW2tqqqqtH//fr3xxhvKysryet+WOpavv/5a//mf/6lu3bp5Zix99tlnlZmZqe3bt8tqtUqSfvvb3+qDDz7Q/fffr44dO2rt2rX617/+VaeOiooK3X777bJYLHrkkUcUFBSkZ555RuPHj9fmzZt1xRVXeLZ96623FBcXpzlz5shisei6665Tjx49tGHDBv3sZz/zbPfuu++quLhYo0eP9vq+AwAAAAAAAAAAAAAAAABcvmgS/Z6cnBxlZWVp7ty5kiSbzab09HRlZmbKZrNdcN/S0lKtWrVK3bp1kyQVFxdr/vz5uvvuuzVt2jRJUmJionbs2KG3335bEydOvKRaX3nlFZWVlWndunWKjIyUJPXr10833nijXnzxRT3wwAPy8/NTbm6ufvnLX2rx4sWKiIjQv/71L61fv97TkHjttddKkuLi4i7qUvZFRUVKTEz0atvvN2y6XC797Gc/04EDB7Rp0ybNnDlT7du3V/v27WWxWC6qhu8cOXJEP//5zz23p06dqszMTK/3b6ljycvLU9u2bfXyyy8rKChIkpScnKwhQ4Zo3bp1GjdunL744gvt2LFDixYt0s033yxJGjBggIYPH15nrI0bN+ro0aPaunWrrr76aknSDTfcoPT0dL3yyiuaPXu2Z9uamhotW7ZMrVu39iwbM2aM5s+fr9LSUrVt21aStGHDBl1//fWe8QAAAAAAAAAAAAAAAAAAP240iX7PNddco/z8fO3Zs0e7d+/Wvn37tHLlSm3cuFGrV6/2NFSeT0xMjKdBVJI6deokSUpNTfUsCwsLU0REhI4dO3bJtb733ntKSUlR27ZtVVtbK+nbS4HfcMMN+vjjjz3bdezYUdnZ2ZozZ44CAgI8l5VvCue7NPv5HDp0SIsXL9bf//53nTx50rP83//+d5PUccUVV2j9+vU6c+aM9u/fr2XLlslisWj69Olej9ESx/Lee+9pxIgR8vf39/zMwsLCFB8fr08++USSPD+7IUOGePazWCxKT0/Xyy+/7Fm2f/9+devWrU5DZ7t27ZSamqq//e1vdXJTUlLqNIhK0i9+8QstXLhQ+fn5GjdunEpKSrRr1y797ne/8+p+AAAAAAAAAAAAAAAAAABc/mgS/QGr1aq0tDSlpaVJ+vYS3FOmTNHSpUuVl5dX735hYWF1bgcGBkqS2rRpc8741dXVl1znqVOn9I9//EMJCQnnrLvqqqvq3B4yZIjmz58vp9OpsWPHXnK2JMXGxuro0aMNbldRUaE77rhDERERmj17tjp06KCgoCDNnTu3Se4H6dv79LuZQFNSUhQaGqpFixbpV7/6laKjoxvcv6WO5dSpU3rllVc8l6H/vu8eL8ePH1dgYOA5j5uIiIg6t8vKyhQVFXXOOJGRkTp48OA5y36odevWGjlypNavX69x48Zp8+bNCgwMPGfGUgAAAAAAAAAAAAAAAADAjxdNog0YMGCAunfvrkOHDpkupY62bdtqwIABmjFjxjnrvruU/HceeeQRhYWFqba2Vr///e+1aNGiS87v06ePNm/erNOnT6tdu3b1bvePf/xDx44d03PPPafu3bt7lpeXl6t9+/aXXMf5JCQkyOl06ptvvvGqSbSljqVt27ZKS0vTr3/963PWhYSESJKio6NVU1Oj8vLyOo2iJSUl54x1+PDhc8Y5efKk5/Lx36lvltQxY8bo9ddf1//+7/9q48aNGj58uKcOAAAAAAAAAAAAAAAAAMCPn8V0AZeTEydOnLOsqqpKhYWF55210aTU1FQdOnRIV199tRITE+v8+/7l5Ldu3apt27bp0Ucf1bx58/TGG2/o7bff9qz/bgbLi53V8/bbb5fL5aq34fQvf/mLpG/vv+/nSNJHH32kb775ps72gYGBcjgcF1VDfT766CP5+fnJZrN5tX1LHUu/fv108OBBxcfHn/Mz69KliyTpuuuukyTt3LnTs5/L5dKuXbvqjNWrVy99/vnn+vLLLz3LSktL9f7776tXr15eHXdiYqKuvfZaLViwQJ999plGjx7t1X4AAAAAAAAAAAAAAAAAgB8HZhL9nlGjRik9PV39+/dXTEyMioqKtGrVKp06dUoTJ040XV4dmZmZ2rJli8aPH68JEyaoQ4cOKikp0T//+U/FxsYqMzNTRUVFmjdvnv7zP/9TAwYMkCRlZGTooYce0vXXX6/IyEhFR0crLCxMW7dulc1mk9Vqld1uP2c20h/q3r27srOzNX/+fBUVFWn06NGKjY1VUVGRtm7dqv3792vv3r3q2bOnWrdurUceeUSTJ09WUVGRlixZotjY2DrjXX311aqtrdUrr7yi66+/XqGhoZ7GyfqUl5fr7rvv1i9/+UvFxcWptrZWH374oVasWKHbbrvN68beljqW6dOn69Zbb9Wdd96psWPHKioqSidOnNDevXvVu3dvjRw5Ut26ddOwYcO0YMECnT17Vh06dNDatWtVVVVVZ0bQW265RcuXL9eUKVP0m9/8RkFBQXrmmWcUEBBwUY/VMWPGaN68eercubNXzaVnz57VO++8I0n65ptvVFFRoe3bt0v6dkbWiIgIr7MBAAAAAAAAAAAAAAAAAM2LJtHvycrK0q5du5Sbm6uSkhKFh4fLbrdr+fLl6tu3r+ny6ggPD9frr7+up556So8//rhOnz6tyMhI9ejRQ8OGDZMkzZkzR2FhYXrwwQc9+82dO1cffvihHn74YS1dulQWi0ULFy7U4sWLlZmZKYfDoZ07d3o1C+e4ceNkt9v14osvat68eaqoqFBERIT69u2rl19+WZIUFRWlp59+Wn/4wx/0//7f/1OnTp30yCOP6IUXXqgzVnp6un7961/r+eef18mTJ3XDDTdo5cqVF8wPCgpS586dtXz5chUVFalVq1a66qqr9Mgjj+jmm2++qPuzJY4lLi5O69at01NPPaVHHnlEZ86cUXR0tG644YY6s7/+/ve/17x58/SHP/xBVqtVGRkZ6tatm1avXu3ZJjQ0VCtXrlRubq4eeughuVwuJScna9WqVbriiiu8Pu5hw4Zp3rx5Xs8ievLkSc2YMaPOsu9ur1ixQikpKV5nAwAAAAAAAAAAAAAAAL7A6XabLgGol5/bzSMUuNyNGzdOFoulwcbZi7V+/Xrl5OToL3/5i6Kjo5t0bG+dLD9jJFeSgvz9Gt7Ix1irThnLdrQKN5JrdZQbyTXp4NlWxrIjW/sbyY1wVxrJlSS/mipj2e6AC8/83VxqW7UzkitJAZUnjOS6g9sayZWks24zz6uQyiIjuZLkDgoxk2sx9zd0pe4gI7nfn62+pYVZaoxlOyxmXj+/KTd3zB3bBBrJDaox9x4tp8NMrstlJlfSNzLzfhUbYubxJUkGX8Z08kytkdzKWnOPsavCzLx++p8pMZIrSe4AM5+vzlrMfa47WmHmsR0SaDGSK0mVNWaeV938ThrJlaSv/b27ClNzcBp6GYsLNHdecqTGzGccf3NPK11ZW2wk93Rr7ydRaGphfmbOPytl5v1Zkvwt5k7GrIa+3z9d5TSSK0lVhs4DOwZWG8mVpApLayO5If8fe3ceVnWZ/3/8xWFTZBFQQCXXDBVRccONEJdpSivJbBEV0owy0nKLzGyQUlo0u8SZScPEZaZS1FH0O5XLNH7b1NQxnfJnavlFBE2FA4LigfP7o8szEKKQy+3Y83FdXhfns9yv+/6cc+BzPr7P/bGYe55Vbia7yODvElPnYo3PHTOSK0nl9fyNZbv5mDsPBIBbXZpPyJU3wnWXWHDAdBduSswkCtxkPvroIx0/flx33HGHSkpKlJWVpZ07d2rBggXXLCM7O1s//vij/vjHP+ruu+82ViAKAAAAAAAAAAAAAAAAALh+KBI1xG63q6ys+m+CWSwWWSxmvuZbXl6u8svMfOLs7HxDZhyy2aqftcDJyUnOzleeVetmGUtteHh46G9/+5t++OEHXbhwQS1bttQbb7yhAQMGXLOMtLQ0ZWVlKTw8XElJSdesXQAAAAAAAAAAAAAAAADAzYMiUUO2b9+uUaNGVbs+JiZGqampN7BH/zFt2jStWbOm2vVLly5VRETEde9HaGhoteuaNGmiLVu2XLGNm2UstREZGanIyMjrmpGammrs9QUAAAAAAAAAAAAAAAAAuDEoEjUkNDRUq1atqna9r6/vDexNZYmJiYqNja12fYsWLW5IPy53fNzc3GrUxs0yFgAAAAAAAAAAAAAAAAAAbjSKRA3x9PRUWFiY6W5cUnBwsIKDg01345ocn5tlLAAAAAAAAAAAAAAAAAAA3GgUiQIAAAAAAAAAAAAAAAAA8CuV2U33AKiexXQHAAAAAAAAAAAAAAAAAAAAcO1RJAoAAAAAAAAAAAAAAAAAAHALokgUAAAAAAAAAAAAAAAAAADgFuRiugMAftu8LuQbyy52qm8su275OTPBTua+G1Dn9GEjuXZ3LyO5klTu7mkk9w6XfCO5klTu7GMk1+5U10iuJJW4mnuNFZwvM5IbVHLaSK4knffwN5JbcM7MsZakhm4XjOSerRdoJFeSXCxORnJdy0uN5EpS/XNnjGWbUlzHz1i2x4WzRnJb2QuM5EqS/Xw9I7lFLt5GciVJFg8jsZ5lRUZyJamJzcxr7GiRmXNASfKt42wsO+jcMSO5TmXm/l4dL25hJLdBHXOvMefCE0Zyvc79n5FcSQqxmLl24GS1GsmVpDLvICO55Z4BRnIl6TZDr21JkrOrkdhyg+clTeqYGbPzhWIjuZJkl7uR3DouZj5PSlJRmZuRXC+D5592u7n/ZrRbzFwPDMg/aCRXkmz+zY3kniozd+3VT2bOfcssdYzkSlKZk5n3lafB62I+53KN5ObVDTaSK0lmzgx+Zk18yEju7WkfGskFAAA/YyZRAAAAAAAAAAAAAAAAAACAWxBFogAAAAAAAAAAAAAAAAAAALcgikQBAAAAAAAAAAAAAAAAAABuQS6mOwAAAAAAAAAAAAAAAAAAwH+rMrvddBeAajGTKAAAAAAAAAAAAAAAAAAAwC2IIlEAAAAAAAAAAAAAAAAAAIBbEEWiAAAAAAAAAAAAAAAAAAAAtyAX0x242axbt05Lly7VkSNHZLfbFRgYqM6dO2vixIny9/eXJPXr1099+/bVjBkzrls/5s+fr7S0tMtu06RJE23ZsuWqcqxWqzIyMnT33Xfr9ttvr/X+O3fuVHp6uvbs2aPCwkL5+fmpe/fuiouLU1hYWI3b+eqrr7R79249+eSTtcp/9913lZWVpezsbNlsNt122216+OGHFRsbKycnp/+qsfw3+J//+R+tW7dO+/fvl9VqVbNmzTRy5EgNHTq01scbAAAAAAAAAAAAAAAAAHB9USRawaJFizRnzhzFx8dr/PjxstvtOnjwoNavX68TJ044ikTT0tLk7e19XfsybNgwRUZGOh6vXLlSWVlZysjIcCxzc3O76hyr1aq0tDS1bt261kWiK1asUEpKinr06KEXX3xRgYGBysvL0/r16zV69Gjt2LGjxm1t375dixcvrnVhZWFhoe655x61bt1a7u7u+uKLL/TKK6+oqKioVm3dDGP5b7BkyRI1adJESUlJ8vX11eeff66XXnpJubm5SkxMNN09AAAAAAAAAAAAAAAAAEAFFIlWsGzZMsXExCgpKcmxLCoqSo8//rjKy8sdy9q1a3fd+xIUFKSgoCDH423btslisahTp07XPbsmvvvuO82aNUv333+/UlNTK80iOXjwYG3duvWG9OO5556r9LhXr17KycnRmjVralykebOM5UYoLS2Vi4uLLBbLr9r/T3/6k/z8/ByPe/bsqfz8fL333nsaN27cr24XAAAAAAAAAAAAAAAAAHDtUdFVgdVqVUBAwCXXVSx+69evn2bOnOl4nJSUpMGDB+vzzz/Xvffeqw4dOmjEiBHKzs5Wfn6+JkyYoM6dO2vAgAHauHHjNetvbm6uJk+erIiICHXo0EGxsbHat2+fY/2SJUvUvn17/fvf/3YsO3r0qMLDwzVnzhxlZ2erf//+kqQJEyYoJCREISEhys7OvmL20qVL5eTkpOeff/6StxmPjo52/Lx27Vo9+uij6t69u7p166aRI0dq7969jvXz589XWlqaiouLHX0YOXLkrzomkuTr66sLFy7UePsbOZZDhw7pqaeeUpcuXdSpUyc98cQTOnr0aKW8wsJCTZ48WeHh4erZs6fmzp2rxYsXKyQkpNJ2x44d0/jx4x1tjRkzRgcOHKi0zcXX6qJFixQdHa0OHTpo165dCgkJ0WeffVZp27KyMkVGRur111+v9lhVLBC9qG3btioqKlJxcXG1+wEAAAAAAAAAAAAAAAAAbjxmEq0gNDRU77//voKDg9W3b181bNiwxvuePHlSqampeuqpp+Ti4qJXXnlFkydPVt26ddW1a1c99NBD+vDDDzVlyhR17NhRTZo0uaq+FhQUaPjw4fLw8NBLL70kLy8vLVu2THFxcfr444/l7++vuLg4bd68WVOmTNHq1avl4uKiqVOnqmnTpnrmmWckSWlpaUpMTNTEiRMVEREhSdUWyla0Y8cOtW/f/pJFg7+UnZ2tIUOGqGnTpiotLdWGDRsUGxurdevWqUWLFho2bJhyc3OVlZWljIwMSZKnp2etjofNZtO5c+e0c+dOrV27tla3Pr9RY/m///s/PfLII2rdurVjxtI///nPio+P19///ne5ublJkl544QV9+eWXmjJlipo0aaIPP/xQ+/fvr9SPoqIijRw5UhaLRcnJyXJ3d9ef/vQnjRgxQuvWrVOjRo0c23788cdq1qyZXnzxRVksFrVv314dO3ZUZmamevfu7dhu27ZtOnHihIYOHVrjYydJX3/9tQIDA2v9nAEAAAAAAAAAAAAAAAC3gjK76R4A1aNItIKXX35ZiYmJmj59uiQpODhY0dHRio+PV3Bw8GX3LSgo0PLly9W6dWtJ0okTJ5SSkqKxY8fq6aefliSFhYXpk08+0aZNmxQXF3dVfc3IyJDVatXKlSvl7+8v6edbf991111KT0/X1KlT5eTkpNTUVN13332aO3eu/Pz8tH//fq1atcpRkNi2bVtJUrNmzWp1K/u8vDyFhYXVaNuKBZvl5eXq3bu39u7dqzVr1mjixIkKCgpSUFCQLBZLrfpw0Y8//qjf/e53jsdPPfWU4uPja7z/jRpLWlqafHx89N5778nd3V2S1LlzZ/Xv318rV65UbGysvv/+e33yySd67bXXNGTIEElSZGSk7r777kptrV69Wjk5OdqwYYNatWolSerWrZuio6OVkZGhpKQkx7YXLlzQokWL5OHh4Vg2bNgwpaSkqKCgQD4+PpKkzMxMhYeHO9qriZ07d2rjxo16/vnna7wPAAAAAAAAAAAAAAAAAODGoEi0gjvuuENZWVn64osv9L//+7/asWOHli1bptWrV2vFihWOgspLCQgIcBSISlLz5s0lSb169XIs8/b2lp+fn3Jzc6+6r5999pkiIiLk4+Mjm80mSbJYLOrWrZu++eYbx3ZNmjTRtGnT9OKLL8rFxcVxW/lr4VK3Zr+UQ4cOae7cudq9e7dOnTrlWP7DDz9ck340atRIq1atUnFxsXbu3KlFixbJYrFo/PjxNW7jRozls88+0z333CNnZ2fHc+bt7a127dpp3759kuR47vr37+/Yz2KxKDo6Wu+9955j2c6dO9W6detKBZ3169dXr1699PXXX1fKjYiIqFQgKkmDBg3S7NmzlZWVpdjYWJ0+fVpbt27VH/7whxodB0nKzc3Vc889p4iICI0aNarG+wEAAAAAAAAAAAAAAAAAbgyKRH/Bzc1NUVFRioqKkvTzLbgTEhK0YMECpaWlVbuft7d3pceurq6SJC8vryrtnz9//qr7eebMGe3Zs0ehoaFV1jVt2rTS4/79+yslJUVlZWV66KGHrjpbkgIDA5WTk3PF7YqKijR69Gj5+fkpKSlJjRs3lru7u6ZPn35NjoP08zG9OBNoRESEPD099dprr+nRRx9Vw4YNr7j/jRrLmTNnlJGR4bgNfUUXXy8nT56Uq6trldeNn59fpcdWq1UNGjSo0o6/v78OHjxYZdkveXh4aPDgwVq1apViY2O1bt06ubq6VpmxtDpWq1Vjx45V/fr1NX/+fFkslhrtBwAAAAAAAAAAAAAAAAC4cSgSvYLIyEi1adNGhw4dMt2VSnx8fBQZGakJEyZUWXfxVvIXJScny9vbWzabTbNmzdJrr7121fndu3fXunXrlJ+fr/r161e73Z49e5Sbm6t33nlHbdq0cSwvLCxUUFDQVffjUkJDQ1VWVqZjx47VqEj0Ro3Fx8dHUVFRGj58eJV19erVkyQ1bNhQFy5cUGFhYaVC0dOnT1dp68iRI1XaOXXqlOP28RdVN0vqsGHD9MEHH+i7777T6tWrdffddzv6cTnnzp1TQkKCCgsL9cEHH1QpaAUAAAAAAAAAAAAAAAAA3ByY/q+Cn376qcqyc+fO6fjx45ectdGkXr166dChQ2rVqpXCwsIq/at4O/kNGzZo48aNevXVVzVz5kytXbtWmzZtcqy/OINlbWf1HDlypMrLy6stOP3HP/4h6efjVzFHknbt2qVjx45V2t7V1VWlpaW16kN1du3aJScnJwUHB9do+xs1lp49e+rgwYNq165dleesZcuWkqT27dtLkjZv3uzYr7y8XFu3bq3UVpcuXfT//t//0+HDhx3LCgoK9Pnnn6tLly41GndYWJjatm2rV155RQcOHNDQoUOvuI/NZtOzzz6rw4cP691331VgYGCNsgAAAAAAAAAAAAAAAAAANx4ziVZw7733Kjo6Wn369FFAQIDy8vK0fPlynTlzRnFxcaa7V0l8fLzWr1+vESNGaNSoUWrcuLFOnz6tf/3rXwoMDFR8fLzy8vI0c+ZMPfLII4qMjJQkxcTE6KWXXlJ4eLj8/f3VsGFDeXt7a8OGDQoODpabm5tCQkKqzEb6S23atNG0adOUkpKivLw8DR06VIGBgcrLy9OGDRu0c+dObd++XZ06dZKHh4eSk5P1xBNPKC8vT/Pnz69SXNiqVSvZbDZlZGQoPDxcnp6ejsLJ6hQWFmrs2LG677771KxZM9lsNn311VdaunSpHn744RoX9t6osYwfP14PPvigxowZo4ceekgNGjTQTz/9pO3bt6tr164aPHiwWrdurYEDB+qVV15RSUmJGjdurA8//FDnzp2rNCPoAw88oCVLlighIUHPPvus3N3d9ac//UkuLi61eq0OGzZMM2fOVIsWLWpUXJqcnKytW7cqKSlJRUVF2rNnj2Ndu3btrvi6AQAAAAAAAAAAAAAAAADcOBSJVpCYmKitW7cqNTVVp0+flq+vr0JCQrRkyRL16NHDdPcq8fX11QcffKB58+bpzTffVH5+vvz9/dWxY0cNHDhQkvTiiy/K29tbzz//vGO/6dOn66uvvtKMGTO0YMECWSwWzZ49W3PnzlV8fLxKS0u1efPmGs3CGRsbq5CQEKWnp2vmzJkqKiqSn5+fevTooffee0+S1KBBA7399tt6/fXXNW7cODVv3lzJycl69913K7UVHR2t4cOHa+HChTp16pS6deumZcuWXTbf3d1dLVq00JIlS5SXl6c6deqoadOmSk5O1pAhQ2p1PG/EWJo1a6aVK1dq3rx5Sk5OVnFxsRo2bKhu3bpVmv111qxZmjlzpl5//XW5ubkpJiZGrVu31ooVKxzbeHp6atmyZUpNTdVLL72k8vJyde7cWcuXL1ejRo1qPO6BAwdq5syZNZpFVJI+++wzSVJqamqVdTV93QAAAAAAAAAAAAAAAAC3kjK73XQXgGo52e28QoGbXWxsrCwWyxULZ2tr1apVevnll/WPf/xDDRs2vKZt11Tp6RwjuZJU7FbfWHbd8nNGcp3KSo3kSpLl7CkjuXZ3LyO5klTu7mkk13K+yEiuJJXX9TET7GQxkyvpnMHv3BScLzOSGySrkVxJOl/H10huwTkzx1qSGrqZyS6Rq5FcSXKxOF15o+vAtdzc30mnc4XGsk0pruNnLNujrNhIrlNJgZFcSbK71zOSW+TibSTXJM8yc+dispn5PXbUbugcUJJvHWdj2T6F/2ck1+TnuuP1WhjJbVDHzLmBJDkXnjCSazln7pxbFjOfr5xKzI25zDvISG65V4CRXEmyGHptS5KczXzWKK9j7rykzKWOkVznC2bOeyXJqdRM9nkPfyO5klRaZua/27wMnn/aLeaui9ld6xrJdc07YCRXkmz+zY3kni4zd43Iz/mCkVxTv7clc8Ulbgavizlbc43k5tU1N/mNq7n/0pD1xceM5N6e9qGRXAC4kVLrtTbdBUhKOnvQdBduSswkCtxkPvroIx0/flx33HGHSkpKlJWVpZ07d2rBggXXLCM7O1s//vij/vjHP+ruu+82ViAKAAAAAAAAAAAAAAAAALh+KBI1xG63q6ys+lmhLBaLLIa+tV9eXq7y8vJq1zs7O8vJ6frP4GCz2apd5+TkJGfnK88WcrOMpTY8PDz0t7/9TT/88IMuXLigli1b6o033tCAAQOuWUZaWpqysrIUHh6upKSka9YuAAAAAAAAAAAAAAAAAODmQZGoIdu3b9eoUaOqXR8TE6PU1NQb2KP/mDZtmtasWVPt+qVLlyoiIuK69yM0NLTadU2aNNGWLVuu2MbNMpbaiIyMVGRk5HXNSE1NNfb6AgAAAAAAAAAAAAAAAADcGBSJGhIaGqpVq1ZVu97X1/cG9qayxMRExcbGVru+RYsWN6Qflzs+bm5uNWrjZhkLAAAAAAAAAAAAAAAAAAA3GkWihnh6eiosLMx0Ny4pODhYwcHBprtxTY7PzTIWAAAAAAAAAAAAAAAAAABuNIvpDgAAAAAAAAAAAAAAAAAAAODaYyZRAAAAAAAAAAAAAAAAAAB+pTK76R4A1WMmUQAAAAAAAAAAAAAAAAAAgFsQRaIAAAAAAAAAAAAAAAAAAAC3IIpEAQAAAAAAAAAAAAAAAAAAbkEupjsA4LfNVtfPWLZHyWlj2efr+BrJzTvvaiRXklzrehrJLS2zG8mVpLo2JyO5geVlRnIlyelCiZHc0xYvI7mS5Gox9xoLcj5nJLfQUt9IriTJ0Hs6sMzc34wyi7+R3NIL5l7b5Yaii8rNfTzy8WxgJNdu7mlW3fILxrJLXesZyXUrKzWSK0klbj5Gcus6mzkfksydB/5YUtdIriQ1czOT2yL/kJlgSWUuQcayz9VvaiTX1W4zkitJgUUnjeSecAowkitJRU5mzsXqeDY0kitJQe5mPlOe8TZ3LuZ34YyR3GNmPkJLkprUM/PaliSn80VGck9eMPcaa3xyn5HcMkOfMyTpW5uZ659ty3KN5EqSm6HjXe5i7rpYucyd71tk5nz/lG9rI7mS5Ft8wkiun4eZ97MkyeJsJLbc4AUTZydD7yuDYy71bWYkt15ZuZFcSarrZO7/cUr9zVwjsr43w0iuJHk/NtNYNgAANwtmEgUAAAAAAAAAAAAAAAAAALgFUSQKAAAAAAAAAAAAAAAAAABwC6JIFAAAAAAAAAAAAAAAAAAA4BbkYroDAAAAAAAAAAAAAAAAAAD8tyqz2013AagWM4kCAAAAAAAAAAAAAAAAAADcgigSBQAAAAAAAAAAAAAAAAAAuAVRJAoAAAAAAAAAAAAAAAAAAHALcjHdgZvNunXrtHTpUh05ckR2u12BgYHq3LmzJk6cKH9/f0lSv3791LdvX82YMeO69WP+/PlKS0u77DZNmjTRli1brirHarUqIyNDd999t26//fZa779z506lp6drz549KiwslJ+fn7p37664uDiFhYXVuJ2vvvpKu3fv1pNPPlmr/HfffVdZWVnKzs6WzWbTbbfdpocfflixsbFycnL6rxrLf4NPP/1UixYt0vfff6+ioiIFBgZqwIABSkxMlJeXl+nuAQAAAAAAAAAAAAAAAAAqoEi0gkWLFmnOnDmKj4/X+PHjZbfbdfDgQa1fv14nTpxwFImmpaXJ29v7uvZl2LBhioyMdDxeuXKlsrKylJGR4Vjm5uZ21TlWq1VpaWlq3bp1rYtEV6xYoZSUFPXo0UMvvviiAgMDlZeXp/Xr12v06NHasWNHjdvavn27Fi9eXOvCysLCQt1zzz1q3bq13N3d9cUXX+iVV15RUVFRrdq6Gcby3yA/P18dOnTQyJEjVb9+fR08eFDz58/XwYMHtXjxYtPdAwAAAAAAAAAAAAAAAABUQJFoBcuWLVNMTIySkpIcy6KiovT444+rvLzcsaxdu3bXvS9BQUEKCgpyPN62bZssFos6dep03bNr4rvvvtOsWbN0//33KzU1tdKsnYMHD9bWrVtvSD+ee+65So979eqlnJwcrVmzpsZFmjfLWG6E0tJSubi4yGKx/Kr977///kqPIyIi5Obmppdeekl5eXkKDAy8Ft0EAAAAAAAAAAAAAAAAAFwDv65S7BZltVoVEBBwyXUVi+r69eunmTNnOh4nJSVp8ODB+vzzz3XvvfeqQ4cOGjFihLKzs5Wfn68JEyaoc+fOGjBggDZu3HjN+pubm6vJkycrIiJCHTp0UGxsrPbt2+dYv2TJErVv317//ve/HcuOHj2q8PBwzZkzR9nZ2erfv78kacKECQoJCVFISIiys7OvmL106VI5OTnp+eefv+Rt3aOjox0/r127Vo8++qi6d++ubt26aeTIkdq7d69j/fz585WWlqbi4mJHH0aOHPmrjokk+fr66sKFCzXe/kaO5dChQ3rqqafUpUsXderUSU888YSOHj1aKa+wsFCTJ09WeHi4evbsqblz52rx4sUKCQmptN2xY8c0fvx4R1tjxozRgQMHKm1z8bW6aNEiRUdHq0OHDtq1a5dCQkL02WefVdq2rKxMkZGRev3112t87CSpfv36klSrYw4AAAAAAAAAAAAAAADcKsr5d1P8w6Uxk2gFoaGhev/99xUcHKy+ffuqYcOGNd735MmTSk1N1VNPPSUXFxe98sormjx5surWrauuXbvqoYce0ocffqgpU6aoY8eOatKkyVX1taCgQMOHD5eHh4deeukleXl5admyZYqLi9PHH38sf39/xcXFafPmzZoyZYpWr14tFxcXTZ06VU2bNtUzzzwjSUpLS1NiYqImTpyoiIgISaq2ULaiHTt2qH379vLz87vittnZ2RoyZIiaNm2q0tJSbdiwQbGxsVq3bp1atGihYcOGKTc3V1lZWcrIyJAkeXp61up42Gw2nTt3Tjt37tTatWuVmJhY431v1Fj+7//+T4888ohat27tmLH0z3/+s+Lj4/X3v/9dbm5ukqQXXnhBX375paZMmaImTZroww8/1P79+yv1o6ioSCNHjpTFYlFycrLc3d31pz/9SSNGjNC6devUqFEjx7Yff/yxmjVrphdffFEWi0Xt27dXx44dlZmZqd69ezu227Ztm06cOKGhQ4de8TiUlZXJZrPp+++/14IFC9SvXz8FBwdf+WADAAAAAAAAAAAAAAAAAG4YikQrePnll5WYmKjp06dLkoKDgxUdHa34+PgrFsAVFBRo+fLlat26tSTpxIkTSklJ0dixY/X0009LksLCwvTJJ59o06ZNiouLu6q+ZmRkyGq1auXKlfL395ck9ezZU3fddZfS09M1depUOTk5KTU1Vffdd5/mzp0rPz8/7d+/X6tWrXIUJLZt21aS1KxZs1rdyj4vL09hYWE12rZiwWZ5ebl69+6tvXv3as2aNZo4caKCgoIUFBQki8VSqz5c9OOPP+p3v/ud4/FTTz2l+Pj4Gu9/o8aSlpYmHx8fvffee3J3d5ckde7cWf3799fKlSsVGxur77//Xp988olee+01DRkyRJIUGRmpu+++u1Jbq1evVk5OjjZs2KBWrVpJkrp166bo6GhlZGQoKSnJse2FCxe0aNEieXh4OJYNGzZMKSkpKigokI+PjyQpMzNT4eHhjvYuJzo6Wnl5eY7+zZkzp0bHDwAAAAAAAAAAAAAAAABw41AkWsEdd9yhrKwsffHFF/rf//1f7dixQ8uWLdPq1au1YsUKR0HlpQQEBDgKRCWpefPmkqRevXo5lnl7e8vPz0+5ublX3dfPPvtMERER8vHxkc1mkyRZLBZ169ZN33zzjWO7Jk2aaNq0aXrxxRfl4uLiuK38tXCpW7NfyqFDhzR37lzt3r1bp06dciz/4Ycfrkk/GjVqpFWrVqm4uFg7d+7UokWLZLFYNH78+Bq3cSPG8tlnn+mee+6Rs7Oz4znz9vZWu3bttG/fPklyPHf9+/d37GexWBQdHa333nvPsWznzp1q3bp1pYLO+vXrq1evXvr6668r5UZERFQqEJWkQYMGafbs2crKylJsbKxOnz6trVu36g9/+EONjsPChQtVUlKi77//Xn/605/05JNP6r333pOzs3ON9gcAAAAAAAAAAAAAAAAAXH8Uif6Cm5uboqKiFBUVJennW3AnJCRowYIFSktLq3Y/b2/vSo9dXV0lSV5eXlXaP3/+/FX388yZM9qzZ49CQ0OrrGvatGmlx/3791dKSorKysr00EMPXXW2JAUGBionJ+eK2xUVFWn06NHy8/NTUlKSGjduLHd3d02fPv2aHAfp52N6cSbQiIgIeXp66rXXXtOjjz6qhg0bXnH/GzWWM2fOKCMjw3Eb+oouvl5OnjwpV1fXKq8bPz+/So+tVqsaNGhQpR1/f38dPHiwyrJf8vDw0ODBg7Vq1SrFxsZq3bp1cnV1rTJjaXXatGkjSQoPD1dYWJjuv/9+ffLJJ/r9739fo/0BAAAAAAAAAAAAAAAAANcfRaJXEBkZqTZt2ujQoUOmu1KJj4+PIiMjNWHChCrrLt5K/qLk5GR5e3vLZrNp1qxZeu211646v3v37lq3bp3y8/NVv379arfbs2ePcnNz9c477zgKCyWpsLBQQUFBV92PSwkNDVVZWZmOHTtWoyLRGzUWHx8fRUVFafjw4VXW1atXT5LUsGFDXbhwQYWFhZUKRU+fPl2lrSNHjlRp59SpU47bx19U3Sypw4YN0wcffKDvvvtOq1ev1t133+3oR22EhITI1dVVR48erfW+AAAAAAAAAAAAAAAAAIDrx2K6AzeTn376qcqyc+fO6fjx45ectdGkXr166dChQ2rVqpXCwsIq/at4O/kNGzZo48aNevXVVzVz5kytXbtWmzZtcqy/OINlbWf1HDlypMrLy6stOP3HP/4h6efjVzFHknbt2qVjx45V2t7V1VWlpaW16kN1du3aJScnJwUHB9do+xs1lp49e+rgwYNq165dleesZcuWkqT27dtLkjZv3uzYr7y8XFu3bq3UVpcuXfT//t//0+HDhx3LCgoK9Pnnn6tLly41GndYWJjatm2rV155RQcOHNDQoUNrtN8v/etf/9KFCxdqfLwBAAAAAAAAAAAAAAAAADcGM4lWcO+99yo6Olp9+vRRQECA8vLytHz5cp05c0ZxcXGmu1dJfHy81q9frxEjRmjUqFFq3LixTp8+rX/9618KDAxUfHy88vLyNHPmTD3yyCOKjIyUJMXExOill15SeHi4/P391bBhQ3l7e2vDhg0KDg6Wm5ubQkJCqsxG+ktt2rTRtGnTlJKSory8PA0dOlSBgYHKy8vThg0btHPnTm3fvl2dOnWSh4eHkpOT9cQTTygvL0/z589XYGBgpfZatWolm82mjIwMhYeHy9PT01E4WZ3CwkKNHTtW9913n5o1ayabzaavvvpKS5cu1cMPP1zjwt4bNZbx48frwQcf1JgxY/TQQw+pQYMG+umnn7R9+3Z17dpVgwcPVuvWrTVw4EC98sorKikpUePGjfXhhx/q3LlzlWYEfeCBB7RkyRIlJCTo2Weflbu7u/70pz/JxcWlVq/VYcOGaebMmWrRokWNiksTExPVvn17hYSEqE6dOvruu++Unp6ukJAQDRgwoMa5AAAAAAAAAAAAAAAAAIDrjyLRChITE7V161alpqbq9OnT8vX1VUhIiJYsWaIePXqY7l4lvr6++uCDDzRv3jy9+eabys/Pl7+/vzp27KiBAwdKkl588UV5e3vr+eefd+w3ffp0ffXVV5oxY4YWLFggi8Wi2bNna+7cuYqPj1dpaak2b95co1khY2NjFRISovT0dM2cOVNFRUXy8/NTjx499N5770mSGjRooLfffluvv/66xo0bp+bNmys5OVnvvvtupbaio6M1fPhwLVy4UKdOnVK3bt20bNmyy+a7u7urRYsWWrJkifLy8lSnTh01bdpUycnJGjJkSK2O540YS7NmzbRy5UrNmzdPycnJKi4uVsOGDdWtW7dKs7/OmjVLM2fO1Ouvvy43NzfFxMSodevWWrFihWMbT09PLVu2TKmpqXrppZdUXl6uzp07a/ny5WrUqFGNxz1w4EDNnDmzxrOIdujQQRs3btTChQtlt9vVpEkTDRs2TGPGjLliYTEAAAAAAAAAAAAAAABwKyqz2013AaiWk93OKxS42cXGxspisVyxcLa2Vq1apZdffln/+Mc/1LBhw2vadk0Vl5wzkitJLiWnjWWfr+NrJDfvrM1IriS5WpyuvNF1UFpm7s9cXRczYw68cNJIriTZ3eoayT1t8TKSK5l7bUuSV3mxkdxCi4eRXJO8z/1kLLusnr+RXOsFI7GSJBdTfzPKzf3N8HF3NpJr8tOgc7m5F9kFJzPfl3Q7d8ZIriSVuJs5/3RzNvd30tR54AmD59zN3EqM5Drn5xjJlaQynyBj2aXuPkZyXe3mXmOWIjPnRCfcAozkSlLRhTIjuXWcLUZyJSnI3cyYz5SZm8/A74KZv9HZMvN7RJKaGHqeJcnpfJGR3BOW+kZyJalx/ndGcss8a3a3revhW5uZ88+2zuau+ZYbOt52i7nfn+Uyd75vkZnzfWtpuZFcSfI9d8JIbrmHmfezJMli5nqJqesGkmRxMvO+craZ+/+6Mpc6RnJLy8y9n+s6mTsXO/n6RCO53s1rPtHRNc9+bKaxbAC/LS/VaWW6C5CUcu6Q6S7clJhJFLjJfPTRRzp+/LjuuOMOlZSUKCsrSzt37tSCBQuuWUZ2drZ+/PFH/fGPf9Tdd99trEAUAAAAAAAAAAAAAAAAAHD9UCRqiN1uV1lZ9d8QslgssljMzBhQXl6u8vLqvznl7OwspxvwLTabrfqZMZycnOTsfOVvD94sY6kNDw8P/e1vf9MPP/ygCxcuqGXLlnrjjTc0YMCAa5aRlpamrKwshYeHKykp6Zq1CwAAAAAAAAAAAAAAAAC4eVAkasj27ds1atSoatfHxMQoNTX1BvboP6ZNm6Y1a9ZUu37p0qWKiIi47v0IDQ2tdl2TJk20ZcuWK7Zxs4ylNiIjIxUZGXldM1JTU429vgAAAAAAAAAAAAAAAAAANwZFooaEhoZq1apV1a739fW9gb2pLDExUbGxsdWub9GixQ3px+WOj5ubW43auFnGAgAAAAAAAAAAAAAAAADAjUaRqCGenp4KCwsz3Y1LCg4OVnBwsOluXJPjc7OMBQAAAAAAAAAAAAAAAACAG81iugMAAAAAAAAAAAAAAAAAAAC49phJFAAAAAAAAAAAAAAAAACAX6nMbroHQPWYSRQAAAAAAAAAAAAAAAAAAOAWRJEoAAAAAAAAAAAAAAAAAADALcjJbrcz2S0AY05ai41l28rN/frzt50xkmt38zCSa5JTuc1Ytt21rpHc3HNORnIlyc3ZTLaXm7nvvbidLzCWbXd2M5J7wcXMa9skk7eHKL5QbiT3t/i+Ou/uYyRXkuoU5RnJLffwNZJrmrXc1Uiul6u5v9HOhWZeY3bXOkZyJcnp/FkjufkejYzkSpKP3cznqzJ3TyO5kuR8vshY9okyc69vU9xdzJwfeFsuGMmVzJ1zu5w5aiRXkv7PrbGRXL+6LkZyJXPn3L7u5s65fyopM5bd0M1QtpO54+2a+62RXLvF3PvK5t/cSG6Rk7m/z2WGrjfXv2DmWrMkFbr7GcsuOG/md0lDD3Pvq7OG/l6ZnHHI29D1Kcv5QiO5klTobObz1TmbuQugDZzPG8ktNXid2/2cud/dpXXMXA+0OBm8LmY7ZyTX3au+kVwA5kxzb2W6C5A06/wh0124KTGTKAAAAAAAAAAAAAAAAAAAwC2IIlEAAAAAAAAAAAAAAAAAAIBbEEWiAAAAAAAAAAAAAAAAAAAAtyAX0x0AAAAAAAAAAAAAAAAAAOC/VZndbroLQLWYSRQAAAAAAAAAAAAAAAAAAOAWRJEoAAAAAAAAAAAAAAAAAADALYgiUQAAAAAAAAAAAAAAAAAAgFuQi+kO3GzWrVunpUuX6siRI7Lb7QoMDFTnzp01ceJE+fv7S5L69eunvn37asaMGdetH/Pnz1daWtplt2nSpIm2bNlyVTlWq1UZGRm6++67dfvtt9d6/507dyo9PV179uxRYWGh/Pz81L17d8XFxSksLKzG7Xz11VfavXu3nnzyyVr34aJ9+/Zp2LBhqlOnjnbv3l3r/Tdv3qwVK1Zo3759Ki4uVkBAgPr06aPHHntMLVq0qHE7mzZtUl5enmJjY2vdh5vdN998o7/85S/as2ePjhw5oqioKL3zzjumuwUAAAAAAAAAAAAAAAAAuASKRCtYtGiR5syZo/j4eI0fP152u10HDx7U+vXrdeLECUeRaFpamry9va9rX4YNG6bIyEjH45UrVyorK0sZGRmOZW5ubledY7ValZaWptatW9e6SHTFihVKSUlRjx499OKLLyowMFB5eXlav369Ro8erR07dtS4re3bt2vx4sW/ukjUbrcrJSVFfn5+Ki4urvX+b775phYtWqS77rrL0c7Ro0eVmZmp5557TmvXrq1xW5s2bdK+fftuySLRXbt2aefOnerQoYPOnz9vujsAAAAAAAAAAAAAAAAAgMugSLSCZcuWKSYmRklJSY5lUVFRevzxx1VeXu5Y1q5du+vel6CgIAUFBTkeb9u2TRaLRZ06dbru2TXx3XffadasWbr//vuVmpoqJycnx7rBgwdr69atN7Q/mZmZOnPmjIYOHaply5bVat9PP/1UixYt0rhx4zRhwgTH8m7dumno0KE3fCzX07lz51SnTp1fvf/IkSMVFxfn+BkAAAAAAAAAAAAAAAAAcPOymO7AzcRqtSogIOCS6yyW/xyqfv36aebMmY7HSUlJGjx4sD7//HPde++96tChg0aMGKHs7Gzl5+drwoQJ6ty5swYMGKCNGzdes/7m5uZq8uTJioiIUIcOHRQbG6t9+/Y51i9ZskTt27fXv//9b8eyo0ePKjw8XHPmzFF2drb69+8vSZowYYJCQkIUEhKi7OzsK2YvXbpUTk5Oev755ysViF4UHR3t+Hnt2rV69NFH1b17d3Xr1k0jR47U3r17Hevnz5+vtLQ0FRcXO/pQmwJEq9WqOXPm6IUXXpCrq2uN97to8eLFatCggcaNG3fJ9RXHsnjxYg0dOlRdunRRz549lZCQoCNHjjjWJyUlac2aNTp48KBjLBWLjnfv3q1Ro0apU6dO6tKliyZNmqRTp05VysvNzVVCQoI6duyoqKgoLVmyRK+++qr69etXabsDBw5ozJgxjrbGjx+vnJycStuEhIRo4cKFeuONN9S7d2/17NlTW7ZsUUhIiH744YdK2xYUFKhDhw5asWJFtceq4vsAAAAAAAAAAAAAAAAAAHBzYybRCkJDQ/X+++8rODhYffv2VcOGDWu878mTJ5WamqqnnnpKLi4ueuWVVzR58mTVrVtXXbt21UMPPaQPP/xQU6ZMUceOHdWkSZOr6mtBQYGGDx8uDw8PvfTSS/Ly8tKyZcsUFxenjz/+WP7+/oqLi9PmzZs1ZcoUrV69Wi4uLpo6daqaNm2qZ555RpKUlpamxMRETZw4UREREZJUbaFsRTt27FD79u3l5+d3xW2zs7M1ZMgQNW3aVKWlpdqwYYNiY2O1bt06tWjRQsOGDVNubq6ysrKUkZEhSfL09KzxsZg3b55CQ0MVHR1dqUi2Jmw2m3bt2qXf/e53NSowzc3N1YgRI9S4cWMVFRXp/fff1yOPPKKPPvpI9evX17hx43T69GkdPnxYb775piQ5jtHu3bs1cuRIRUVF6a233lJJSYnmzZuncePG6YMPPpAk2e12jRs3Tj/99JOSk5Pl5eWl9PR05eTkVCrQPH78uEaMGKHbbrtNb7zxhs6fP6+33npLI0aM0Lp16yodv6VLl6pjx4569dVXZbPZFBUVpcDAQGVmZmrSpEmO7bKysiRJ9957b62OIQAAAAAAAAAAAAAAAPBbVmY33QOgehSJVvDyyy8rMTFR06dPlyQFBwcrOjpa8fHxCg4Ovuy+BQUFWr58uVq3bi1JOnHihFJSUjR27Fg9/fTTkqSwsDB98skn2rRpk+OW3b9WRkaGrFarVq5cKX9/f0lSz549dddddyk9PV1Tp06Vk5OTUlNTdd9992nu3Lny8/PT/v37tWrVKrm5uUmS2rZtK0lq1qxZrW5ln5eXp7CwsBptm5iY6Pi5vLxcvXv31t69e7VmzRpNnDhRQUFBCgoKksViqVUfJOnbb7/VqlWrtGbNmlrtd1F+fr5KS0vVuHHjGm0/bdo0x89lZWWO2Tk/+ugjPfzww2ratKn8/PyUk5NTZSxz5sxR+/btlZaW5ph99Y477tDgwYP16aefKioqSv/85z+1f/9+rVixQl27dpUk9ejRQ1FRUfL29na0tWTJEtlsNi1evFj169eX9PNzOWjQIK1Zs6bSTKw+Pj6VMiXpgQceUGZmpp599lk5OztLkjIzMzVw4MBKOQAAAAAAAAAAAAAAAACA/17cO7qCO+64Q1lZWVq4cKFGjRrlmJ3zvvvu07fffnvZfQMCAhwFopLUvHlzSVKvXr0cy7y9veXn56fc3Nyr7utnn32miIgI+fj4yGazyWazyWKxqFu3bvrmm28c2zVp0kTTpk1TRkaG5s+fr/HjxyskJOSq8yVd8jbzl3Lo0CE9/fTT6tWrl9q2bavQ0FAdOXKkyu3Oa8tutys5OVnDhw9Xq1atrqqtmo5lz549euyxxxQREaF27dqpY8eOKi4uvuJYSkpKtGvXLv3+979XWVmZ4zlr3ry5GjVq5HjOvvnmG3l7ezsKRCWpXr166tmzZ6X2du7cqYiICEeBqCS1atVKbdq00ddff11p2zvvvLPK+B588EGdPHlS27ZtkyR999132r9/vx588MEaHQcAAAAAAAAAAAAAAAAAwM2PmUR/wc3NTVFRUYqKipIkbdu2TQkJCVqwYIHS0tKq3e+Xsy9evHW5l5dXlfbPnz9/1f08c+aM9uzZo9DQ0CrrmjZtWulx//79lZKSorKyMj300ENXnS1JgYGBysnJueJ2RUVFGj16tPz8/JSUlKTGjRvL3d1d06dPv+rjsHHjRh0+fFhz5syR1WqVJEebVqtV7u7ucnd3v2wb9evXl7u7e43GkpOTo9GjR6t9+/ZKTk5WQECAXF1dlZCQcMWxWK1WlZWVafbs2Zo9e3aV9cePH5f08wy0F29PX9Evl1mtVscssBX5+/uroKCgyrJfCg4OVu/evbVq1Sr17dtXmZmZCg4OVo8ePS47DgAAAAAAAAAAAAAAAADAfw+KRK8gMjJSbdq00aFDh0x3pRIfHx9FRkZqwoQJVdZdvJX8RcnJyfL29pbNZtOsWbP02muvXXV+9+7dtW7dOuXn51eazfKX9uzZo9zcXL3zzjtq06aNY3lhYaGCgoKuqg+HDx9WQUGB+vXrV2Vdt27dNHbsWE2ePPmybbi4uKhz58768ssvZbPZ5OJS/Vti27ZtKi4uVlpamqMo2GazVSnKvBQvLy85OTkpISFBAwYMqLLe19dX0s8z0p4+fbrK+l8u8/Hx0alTp6psd+rUKccsthdVN0vqsGHDNHnyZOXl5Wn9+vUaOXJkjWdUBQAAAAAAAAAAAAAAAADc/LjdfAU//fRTlWXnzp3T8ePH1aBBAwM9ql6vXr106NAhtWrVSmFhYZX+Vbyd/IYNG7Rx40a9+uqrmjlzptauXatNmzY51l+c8bS2s3qOHDlS5eXl1Rac/uMf/5D08/GrmCNJu3bt0rFjxypt7+rqqtLS0lr1ISYmRkuXLq30LyYmRu7u7lq6dKkefvjhGrXz2GOP6eTJk/rzn/98yfWffvqpYyxOTk6VCkn/53/+RzabrcpYfnk8PTw81KlTJx0+fLjK8xUWFqbg4GBJUlhYmKxWq3bs2OHY9+zZs/riiy8qtdelSxd9+eWXlQpUDx8+rAMHDqhLly41Gnf//v3l7e2tSZMmqaCgQA888ECN9gMAAAAAAAAAAAAAAAAA/HdgJtEK7r33XkVHR6tPnz4KCAhQXl6eli9frjNnziguLs509yqJj4/X+vXrNWLECI0aNUqNGzfW6dOn9a9//UuBgYGKj49XXl6eZs6cqUceeUSRkZGSfi6sfOmllxQeHi5/f381bNhQ3t7e2rBhg4KDg+Xm5qaQkJAqs5H+Ups2bTRt2jSlpKQoLy9PQ4cOVWBgoPLy8rRhwwbt3LlT27dvV6dOneTh4aHk5GQ98cQTysvL0/z58xUYGFipvVatWslmsykjI0Ph4eHy9PRUy5YtL9uH4OBgR3HlRdu3b5ezs7MiIiJqfCyjoqL0+OOPa/78+fr+++81aNAg+fr6Kjs7W5mZmSosLFRUVJTjVuwvvPCCHnnkER08eFDvvfeeY1bRimPJzMxUVlaWmjVrJl9fXwUHB2vq1KmKi4vTs88+q0GDBsnb21u5ubn6/PPP9cADDygiIkJ33nmnQkNDNWnSJE2cOFHe3t569913Va9evUqzfMbHx2v16tUaPXq0nnrqKZ0/f17z5s1To0aNFBMTU6Nxu7q6asiQIUpPT1efPn3UqFGjK+5z+vRpbd++3fHz2bNn9fe//91xHOvWrVujbAAAAAAAAAAAAAAAAADA9UeRaAWJiYnaunWrUlNTdfr0afn6+iokJERLlixxFAjeLHx9ffXBBx9o3rx5evPNN5Wfny9/f3917NhRAwcOlCS9+OKL8vb21vPPP+/Yb/r06frqq680Y8YMLViwQBaLRbNnz9bcuXMVHx+v0tJSbd68uUrx5aXExsYqJCRE6enpmjlzpoqKiuTn56cePXrovffekyQ1aNBAb7/9tl5//XWNGzdOzZs3V3Jyst59991KbUVHR2v48OFauHChTp06pW7dumnZsmXX8Ihd3pQpUxQeHq4VK1Zo2rRpKikpUUBAgPr06aMxY8ZIkkJCQjR79mylpaUpISFBbdu21dtvv61nn322UlsPPvig9u7dq5SUFOXn5ysmJkapqanq3Lmz/vKXv2j+/Pl64YUXdOHCBQUFBalHjx5q1qyZpJ9vDf/HP/5RM2bM0IwZM+Tt7a1Ro0bpyJEj+vbbbx0ZjRo10rJly/T6669r8uTJslgs6t27t5KSkuTp6VnjcQ8cOFDp6ekaOnRojbY/ePCgJkyYUGnZxcc1fd0AAAAAAAAAAAAAAAAAAG4MJ7vdbjfdCQDVKy0t1aBBg9S1a1fNnj37mrb99ttv6y9/+Yu2bdt2xdljr5eT1mIjuZJkKzf368/fdsZIrt3Nw0iuSU7lNmPZdlczs+vmnnO68kbXiZuzmWwvN4uRXElyO19gLNvubOZ39wWX397M0WUGz5iLL5Qbyf0tvq/Ou/sYyZWkOkV5RnLLPXyN5JpmLXc1kuvlau5vtHOhmdeY3bWOkVxJcjp/1khuvseV79JwvfjYzXy+KnOv+ZcVrzXn80XGsk+UmXt9m+LuYub8wNtywUiuZO6c2+XMUSO5kvR/bo2N5PrVNTefgalzbl93c+fcP5WUGctu6GYo28nc8XbN/fbKG10Hdou595XNv7mR3CInc3+fywxdb65/wcy1ZkkqdPczll1w3szvkoYe5t5XZw39vTL321PyNnR9ynK+0EiuJBU6m/l8dc5m7gJoA+fzRnJLDV7ndj9n7nd3aR0z1wMtTgavi9nOGcl196pvJBeAOc+5tDDdBUh6y3bEdBduSswkCtxkPvjgA5WXl6tFixayWq3661//qmPHjmnu3LnXLOPw4cM6cuSIli9fruHDhxsrEAUAAAAAAAAAAAAAAAAAXD8UiRpit9tVVlb9txwtFossFjPfjisvL1d5efXfRnR2dpbTDfimj81W/ex/Tk5OcnZ2vmIbZWVlutxkuS4uN99bwN3dXQsXLtSxY8ckSW3atNE777yjsLCwa5bx8ssva8+ePYqMjFRCQsI1axcAAAAAAAAAAAAAAAAAcPO4+SrkfiO2b9+uUaNGVbs+JiZGqampN7BH/zFt2jStWbOm2vVLly5VRETEde9HaGhoteuaNGmiLVu2XLGN+Ph4bd++vdr1mzdvVnBw8K/q3/UyZMgQDRky5LpmLFu27Lq2DwAAAAAAAAAAAAAAAAAwjyJRQ0JDQ7Vq1apq1/v6+t7A3lSWmJio2NjYate3aNHihvTjcsenprdHT05O1tmzZ6tdHxAQUOt+AQAAAAAAAAAAAAAAAADw34AiUUM8PT2v6e3Dr6Xg4OCbYnbNa3F8WrZseQ16AgAAAAAAAAAAAAAAAADAfx+L6Q4AAAAAAAAAAAAAAAAAAADg2mMmUQAAAAAAAAAAAAAAAAAAfqUyu+keANVjJlEAAAAAAAAAAAAAAAAAAIBbEEWiAAAAAAAAAAAAAAAAAAAAtyCKRAEAAAAAAAAAAAAAAAAAAG5BLqY7AOC3rX5JnrFsex0vY9kFbn5Gcn3Ki4zkStJ5NzPH28XiZCRXkmzldiO5jZwLjeRKkuzlZnKLbWZyJRXXMfN+liSP0nwjuWXOdY3kSlJRqZnXmG8dZyO5klTXxczvsToHtxnJlSQFtDASW7ekwEiuJJXX8zcUXGYmV1KRUx1j2Z5uZr4vecLg36vAuvWN5F5wdjeSK0k/nvMwknvH+Z+M5EqS3dXM+8q5JN9IriRZzp4ylt3Ar7mR3OPFhs65JTmVmfmMY3d1M5IrmXuNlXv4GsmVpMaWC0ZyyyyuRnIlyc/ZzJhzzpr7nFHHxdz8ERcsZt7Tpq7TSFJJYHsjuQaHLM8yM9chPV3NfcYpdzXzeyz7go+RXEnyMPgiu812wkjueTU2kitJfvazRnKdSouN5ErSWecAI7lmPk3+zN3ZzLVA77PHjeRK0o+GnufmhT8YyZWkk/WaGsv2lZnPlHYnc+e+5Yaul5zb+CcjuZJU556njGUDAG5OzCQKAAAAAAAAAAAAAAAAAABwC6JIFAAAAAAAAAAAAAAAAAAA4BZEkSgAAAAAAAAAAAAAAAAAAMAtyMV0BwAAAAAAAAAAAAAAAAAA+G9VZreb7gJQLWYSBQAAAAAAAAAAAAAAAAAAuAVRJAoAAAAAAAAAAAAAAAAAAHALokgUAAAAAAAAAAAAAAAAAADgFuRiugM3m3Xr1mnp0qU6cuSI7Ha7AgMD1blzZ02cOFH+/v6SpH79+qlv376aMWPGdevH/PnzlZaWdtltmjRpoi1btlxVjtVqVUZGhu6++27dfvvttd5/586dSk9P1549e1RYWCg/Pz91795dcXFxCgsLq3E7X331lXbv3q0nn3yy1n24aN++fRo2bJjq1Kmj3bt313r/zZs3a8WKFdq3b5+Ki4sVEBCgPn366LHHHlOLFi1q3M6mTZuUl5en2NjYWvfhZvf+++/r448/1oEDB1RSUqLbb79dTzzxhAYMGGC6awAAAAAAAAAAAAAAAACAX6BItIJFixZpzpw5io+P1/jx42W323Xw4EGtX79eJ06ccBSJpqWlydvb+7r2ZdiwYYqMjHQ8XrlypbKyspSRkeFY5ubmdtU5VqtVaWlpat26da2LRFesWKGUlBT16NFDL774ogIDA5WXl6f169dr9OjR2rFjR43b2r59uxYvXvyri0TtdrtSUlLk5+en4uLiWu//5ptvatGiRbrrrrsc7Rw9elSZmZl67rnntHbt2hq3tWnTJu3bt++WLBL985//rD59+ujRRx+Vh4eH/v73v+vpp59WamqqYmJiTHcPAAAAAAAAAAAAAAAAAFABRaIVLFu2TDExMUpKSnIsi4qK0uOPP67y8nLHsnbt2l33vgQFBSkoKMjxeNu2bbJYLOrUqdN1z66J7777TrNmzdL999+v1NRUOTk5OdYNHjxYW7duvaH9yczM1JkzZzR06FAtW7asVvt++umnWrRokcaNG6cJEyY4lnfr1k1Dhw694WO5ns6dO6c6der86v1Xr14tPz8/x+PevXvr2LFjWrx4MUWiAAAAAAAAAAAAAAAAAHCTsZjuwM3EarUqICDgkusslv8cqn79+mnmzJmOx0lJSRo8eLA+//xz3XvvverQoYNGjBih7Oxs5efna8KECercubMGDBigjRs3XrP+5ubmavLkyYqIiFCHDh0UGxurffv2OdYvWbJE7du317///W/HsqNHjyo8PFxz5sxRdna2+vfvL0maMGGCQkJCFBISouzs7CtmL126VE5OTnr++ecrFYheFB0d7fh57dq1evTRR9W9e3d169ZNI0eO1N69ex3r58+fr7S0NBUXFzv6MHLkyBofB6vVqjlz5uiFF16Qq6trjfe7aPHixWrQoIHGjRt3yfUVx7J48WINHTpUXbp0Uc+ePZWQkKAjR4441iclJWnNmjU6ePCgYywVi453796tUaNGqVOnTurSpYsmTZqkU6dOVcrLzc1VQkKCOnbsqKioKC1ZskSvvvqq+vXrV2m7AwcOaMyYMY62xo8fr5ycnErbhISEaOHChXrjjTfUu3dv9ezZU1u2bFFISIh++OGHStsWFBSoQ4cOWrFiRbXHqmKB6EVt27bViRMnqt0HAAAAAAAAAAAAAAAAAGAGM4lWEBoaqvfff1/BwcHq27evGjZsWON9T548qdTUVD311FNycXHRK6+8osmTJ6tu3brq2rWrHnroIX344YeaMmWKOnbsqCZNmlxVXwsKCjR8+HB5eHjopZdekpeXl5YtW6a4uDh9/PHH8vf3V1xcnDZv3qwpU6Zo9erVcnFx0dSpU9W0aVM988wzkqS0tDQlJiZq4sSJioiIkKRqC2Ur2rFjh9q3b3/JosFfys7O1pAhQ9S0aVOVlpZqw4YNio2N1bp169SiRQsNGzZMubm5ysrKUkZGhiTJ09Ozxsdi3rx5Cg0NVXR0dKUi2Zqw2WzatWuXfve739WowDQ3N1cjRoxQ48aNVVRUpPfff1+PPPKIPvroI9WvX1/jxo3T6dOndfjwYb355puS/lNYuXv3bo0cOVJRUVF66623VFJSonnz5mncuHH64IMPJEl2u13jxo3TTz/9pOTkZHl5eSk9PV05OTmVCpWPHz+uESNG6LbbbtMbb7yh8+fP66233tKIESO0bt26Ssdv6dKl6tixo1599VXZbDZFRUUpMDBQmZmZmjRpkmO7rKwsSdK9995bq2P49ddfq2XLlrXaBwAAAAAAAAAAAAAAALhVlNlN9wCoHkWiFbz88stKTEzU9OnTJUnBwcGKjo5WfHy8goODL7tvQUGBli9frtatW0uSTpw4oZSUFI0dO1ZPP/20JCksLEyffPKJNm3apLi4uKvqa0ZGhqxWq1auXCl/f39JUs+ePXXXXXcpPT1dU6dOlZOTk1JTU3Xfffdp7ty58vPz0/79+7Vq1Sq5ublJ+nkWSElq1qxZrW5ln5eXp7CwsBptm5iY6Pi5vLxcvXv31t69e7VmzRpNnDhRQUFBCgoKksViqVUfJOnbb7/VqlWrtGbNmlrtd1F+fr5KS0vVuHHjGm0/bdo0x89lZWWO2Tk/+ugjPfzww2ratKn8/PyUk5NTZSxz5sxR+/btlZaW5ph99Y477tDgwYP16aefKioqSv/85z+1f/9+rVixQl27dpUk9ejRQ1FRUfL29na0tWTJEtlsNi1evFj169eX9PNzOWjQIK1Zs6bSTKw+Pj6VMiXpgQceUGZmpp599lk5OztLkjIzMzVw4MBKOVeyfv167d69WwsWLKjxPgAAAAAAAAAAAAAAAACAG4PbzVdwxx13KCsrSwsXLtSoUaMcs3Ped999+vbbby+7b0BAgKNAVJKaN28uSerVq5djmbe3t/z8/JSbm3vVff3ss88UEREhHx8f2Ww22Ww2WSwWdevWTd98841juyZNmmjatGnKyMjQ/PnzNX78eIWEhFx1vqRL3mb+Ug4dOqSnn35avXr1Utu2bRUaGqojR45Uud15bdntdiUnJ2v48OFq1arVVbVV07Hs2bNHjz32mCIiItSuXTt17NhRxcXFVxxLSUmJdu3apd///vcqKytzPGfNmzdXo0aNHM/ZN998I29vb0eBqCTVq1dPPXv2rNTezp07FRER4SgQlaRWrVqpTZs2+vrrrytte+edd1YZ34MPPqiTJ09q27ZtkqTvvvtO+/fv14MPPlij43Bxn5dfflkPPPCABgwYUOP9AAAAAAAAAAAAAAAAAOC/2WeffaZJkyZpwIABCgkJ0cyZM2u8b2FhoaZNm6bu3bsrPDxc48eP14kTJ6pst2vXLj388MPq0KGDoqOjtXDhQtnttZ+2lplEf8HNzU1RUVGKioqSJG3btk0JCQlasGCB0tLSqt3vl7MvXrx1uZeXV5X2z58/f9X9PHPmjPbs2aPQ0NAq65o2bVrpcf/+/ZWSkqKysjI99NBDV50tSYGBgcrJybnidkVFRRo9erT8/PyUlJSkxo0by93dXdOnT7/q47Bx40YdPnxYc+bMkdVqlSRHm1arVe7u7nJ3d79sG/Xr15e7u3uNxpKTk6PRo0erffv2Sk5OVkBAgFxdXZWQkHDFsVitVpWVlWn27NmaPXt2lfXHjx+X9PMMtBdvT1/RL5dZrVbHLLAV+fv7q6CgoMqyXwoODlbv3r21atUq9e3bV5mZmQoODlaPHj0uO46Ljh07prFjx6pDhw61+gUHAAAAAAAAAAAAAAAAAP/ttm3bpu+++07dunWrUq91Jc8++6y+//57/eEPf5C7u7vmzZunsWPHKjMzUy4uP5d0/vjjjxozZox69+6tZ599VgcOHNCbb74pZ2dnjRkzplZ5FIleQWRkpNq0aaNDhw6Z7kolPj4+ioyM1IQJE6qsu3gr+YuSk5Pl7e0tm82mWbNm6bXXXrvq/O7du2vdunXKz8+vNJvlL+3Zs0e5ubl655131KZNG8fywsJCBQUFXVUfDh8+rIKCAvXr16/Kum7dumns2LGaPHnyZdtwcXFR586d9eWXX8pmszneZJeybds2FRcXKy0tzVEUbLPZavQm9/LykpOTkxISEi4566avr6+kn2ekPX36dJX1v1zm4+OjU6dOVdnu1KlTjllsL6pultRhw4Zp8uTJysvL0/r16zVy5Mgazah6+vRpjRkzRv7+/kpLS3MURAMAAAAAAAAAAAAAAADAb8HUqVOVlJQkSfrqq69qvN/u3bv1v//7v0pPT1efPn0kSS1atNA999yjjz/+WPfcc48kKT09Xb6+vpo7d67c3NzUs2dPnT59Wn/+8581cuTIKjWCl8Pt5iv46aefqiw7d+6cjh8/rgYNGhjoUfV69eqlQ4cOqVWrVgoLC6v0r+Lt5Dds2KCNGzfq1Vdf1cyZM7V27Vpt2rTJsf5igV9tZ/UcOXKkysvLqy04/cc//iHp5+NXMUf6eRrcY8eOVdre1dVVpaWltepDTEyMli5dWulfTEyM3N3dtXTpUj388MM1auexxx7TyZMn9ec///mS6z/99FPHWJycnCoVkv7P//yPbDZblbH88nh6eHioU6dOOnz4cJXnKywsTMHBwZKksLAwWa1W7dixw7Hv2bNn9cUXX1Rqr0uXLvryyy8rFagePnxYBw4cUJcuXWo07v79+8vb21uTJk1SQUGBHnjggSvuc/bsWY0dO1YXLlzQwoUL5enpWaMsAAAAAAAAAAAAAAAAALhVWCy/rvTyn//8p7y9vdW7d2/HspYtW6pt27b65z//WWm7/v37VyoGveeee2S1WrV79+5aZTKTaAX33nuvoqOj1adPHwUEBCgvL0/Lly/XmTNnFBcXZ7p7lcTHx2v9+vUaMWKERo0apcaNG+v06dP617/+pcDAQMXHxysvL08zZ87UI488osjISEk/F1a+9NJLCg8Pl7+/vxo2bChvb29t2LBBwcHBcnNzU0hIyBUrjdu0aaNp06YpJSVFeXl5Gjp0qAIDA5WXl6cNGzZo586d2r59uzp16iQPDw8lJyfriSeeUF5enubPn6/AwMBK7bVq1Uo2m00ZGRkKDw+Xp6enWrZsedk+BAcHO4orL9q+fbucnZ0VERFR42MZFRWlxx9/XPPnz9f333+vQYMGydfXV9nZ2crMzFRhYaGioqIct2J/4YUX9Mgjj+jgwYN67733HLOKVhxLZmamsrKy1KxZM/n6+io4OFhTp05VXFycnn32WQ0aNEje3t7Kzc3V559/rgceeEARERG68847FRoaqkmTJmnixIny9vbWu+++q3r16lWa5TM+Pl6rV6/W6NGj9dRTT+n8+fOaN2+eGjVqpJiYmBqN29XVVUOGDHFUpTdq1OiK+zzzzDP67rvv9OqrryonJ0c5OTmOdZ06dapRLgAAAAAAAAAAAAAAAABca/3797/s+s2bN9+gnlTv8OHDatGiRZU7Prds2VKHDx+WJBUXF+v48eNV6udatmwpJycnHT58uFb1cRSJVpCYmKitW7cqNTVVp0+flq+vr0JCQrRkyRJHgeDNwtfXVx988IHmzZunN998U/n5+fL391fHjh01cOBASdKLL74ob29vPf/88479pk+frq+++kozZszQggULZLFYNHv2bM2dO1fx8fEqLS3V5s2bqxRfXkpsbKxCQkKUnp6umTNnqqioSH5+furRo4fee+89SVKDBg309ttv6/XXX9e4cePUvHlzJScn6913363UVnR0tIYPH66FCxfq1KlT6tatm5YtW3YNj9jlTZkyReHh4VqxYoWmTZumkpISBQQEqE+fPhozZowkKSQkRLNnz1ZaWpoSEhLUtm1bvf3223r22WcrtfXggw9q7969SklJUX5+vmJiYpSamqrOnTvrL3/5i+bPn68XXnhBFy5cUFBQkHr06KFmzZpJ+vnW8H/84x81Y8YMzZgxQ97e3ho1apSOHDmib7/91pHRqFEjLVu2TK+//romT54si8Wi3r17KykpqVazew4cOFDp6ekaOnRojbb/7LPPJKnSa+qiAwcO1DgXAAAAAAAAAAAAAAAAuFX82f6D6S5AVy4SvRlYrVZ5eXlVWe7j46N9+/ZJkgoLCyWpyuSFbm5uqlu3bqW7T9eEk91ut//K/gK4AUpLSzVo0CB17dpVs2fPvqZtv/322/rLX/6ibdu2XXH22OvlQt4RI7mSZK9T9RfujVLg5GEk16e8yEiuJJ13M3O8XSxOV97oOrGVm/kT615aaCRXkmQvN5NbZjOTK6m4jp+xbI/SfCO5Je6+RnIlqajUzGvMt46zkVxJKi0zM2bPQ/9rJFeSFNDCTK6p32GSyuv5G8m1O/2622BcC0VOdYxle7iaGffJYnN/rwJdzWRfcHY3kitJPxZcMJJ7h0u+kVxJsrsael8Z/P1pOXvKWLbNr7mR3OPF5o63m7OZ35/+dcz9vTL2GnMxc51GkuwWM/MKlLmauVYiSc62c0Zyc86b+5xRx8Xc+8rLzUy2qes0JpkcsmeZmeuQdte6RnIlqdzZ1Uju8SIz572Suc9WkuRfkmsk97x3YyO5kuRm6LqvU2mxkVxJOusRYCTXw2bu/1JKDf1firs158obXSc/Opt5npuXZhvJlaST9Zoay/Y19FHDbjF37muK05b3jGXXuecpY9kA8N+ssLBQJ06cuOJ2t912W5U6q379+qlv376aMWPGFfd/7LHHZLFYlJ6eXmn5zJkz9dlnn+mjjz5SXl6e7rzzTs2dO1eDBg2qtF14eLgSEhL05JNP1mBUP2MmUeAm88EHH6i8vFwtWrSQ1WrVX//6Vx07dkxz5869ZhmHDx/WkSNHtHz5cg0fPtxYgSgAAAAAAAAAAAAAAAAAmPb3v/9d06dPv+J2GzduVKtWrX51jre3t3Jzq37xraCgQD4+PpLkmGn04oyiF5WWlqqkpMSxXU1RJGqI3W5XWVlZtestFossFjPfwCwvL1d5efWzUjg7O8vJ6frPzGezVT/TjZOTk5ydr/xto7KyMl1uslwXl5vvLeDu7q6FCxfq2LFjkqQ2bdronXfeUVhY2DXLePnll7Vnzx5FRkYqISHhmrULAAAAAAAAAAAAAAAAAP9thg0bpmHDhl33nJYtW+qLL76Q3W6vVIN35MgR3XHHHZIkDw8PNWrUSIcPH66075EjR2S329WyZctaZd58FXK/Edu3b9eoUaOqXR8TE6PU1NQb2KP/mDZtmtasWVPt+qVLlyoiIuK69yM0NLTadU2aNNGWLVuu2EZ8fLy2b99e7frNmzcrODj4V/XvehkyZIiGDBlyXTOWLVt2XdsHAAAAAAAAAAAAAAAAAFR255136o9//KO++OIL9erVS9LPxZ///ve/9fjjj1fabvPmzZoyZYpcXV0l/TyLqbe3t8LDw2uVSZGoIaGhoVq1alW16319fW9gbypLTExUbGxstetbtGhxQ/pxueNT09ujJycn6+zZs9WuDwgIqHW/AAAAAAAAAAAAAAAAAAC/XceOHdM333wjSSopKdHRo0f197//XZL0+9//3rFdu3btNGTIEM2aNUuSFB4erj59+mjatGl6/vnn5e7urrfeekshISH63e9+59hvzJgxWr9+vSZNmqRHH31U/+///T+lp6frueeeq3Ht3EUUiRri6el5TW8ffi0FBwffFLNrXovjU9updQEAAAAAAAAAAAAAAAAAuJyvvvpKL7zwguPxtm3btG3bNknSgQMHHMvLyspUXl5ead958+Zp9uzZmjFjhmw2m/r06aPp06fLxeU/5ZzNmjVTenq6UlNT9cQTT8jPz0/jx4/X6NGja91XikQBAAAAAAAAAAAAAAAAAABq6IEHHtADDzxwxe0qFoxe5OXlpVmzZjlmF61O586d9eGHH/7qPl5kueoWAAAAAAAAAAAAAAAAAAAAcNOhSBQAAAAAAAAAAAAAAAAAAOAWRJEoAAAAAAAAAAAAAAAAAADALcjJbrfbTXcCwG/X+bOFxrKtZc7Gsuu5mqnRdzlvNZIrSeVu9Yzk5hSXG8mVJBeLk5FcN2czuZLk427mfVV8wdzzXG7wTOpoQamR3I6W40ZyJanUr4WxbFNcSk4byf2+1NNIrkmebr+979CZ/Jth8pOov93MOajdpY6RXEmy2t2M5Bp8iame0wUjuU6280ZyJcnu4m4k1+SY853MfM6QJN9zJ4zkWk79aCRXkuw+gUZyC7ybGcmVzP2t/KnYZiRXkhp4uBjJNfnZyv23dxooS+lZY9mFFg8juQZPS1RYaua6hZfBzziuhn5/up87YyRXkiwlBUZyTV4rcTmXbyzbueikkdwyLzPnQ5JU6GzmWk0959/gfyU7mfv9aTN0uF3t5s4/VV5mJNbUtRJJ8nI1d2Zi7DVWbub/MySp3NT1ki3vGcmVpLKCU0Zy6z063UguAODKfoOXvwAAAAAAAAAAAAAAAAAAAG59FIkCAAAAAAAAAAAAAAAAAADcgigSBQAAAAAAAAAAAAAAAAAAuAVRJAoAAAAAAAAAAAAAAAAAAHALokgUAAAAAAAAAAAAAAAAAADgFkSRKAAAAAAAAAAAAAAAAAAAwC2IIlEAAAAAAAAAAAAAAAAAAIBbkIvpDtxs1q1bp6VLl+rIkSOy2+0KDAxU586dNXHiRPn7+0uS+vXrp759+2rGjBnXrR/z589XWlraZbdp0qSJtmzZclU5VqtVGRkZuvvuu3X77bfXev+dO3cqPT1de/bsUWFhofz8/NS9e3fFxcUpLCysxu189dVX2r17t5588sla9+Giffv2adiwYapTp452795d6/03b96sFStWaN++fSouLlZAQID69Omjxx57TC1atKhxO5s2bVJeXp5iY2Nr3Yeb3Zo1a/TXv/5VP/zwg0pKStS4cWPdd999Gjt2rNzc3Ex3DwAAAAAAAAAAAAAAAABQAUWiFSxatEhz5sxRfHy8xo8fL7vdroMHD2r9+vU6ceKEo0g0LS1N3t7e17Uvw4YNU2RkpOPxypUrlZWVpYyMDMeya1GUZ7ValZaWptatW9e6SHTFihVKSUlRjx499OKLLyowMFB5eXlav369Ro8erR07dtS4re3bt2vx4sW/ukjUbrcrJSVFfn5+Ki4urvX+b775phYtWqS77rrL0c7Ro0eVmZmp5557TmvXrq1xW5s2bdK+fftuySLRgoICRUZG6oknnpCnp6f27t2rtLQ05ebmKiUlxXT3AAAAAAAAAAAAAAAAAAAVUCRawbJlyxQTE6OkpCTHsqioKD3++OMqLy93LGvXrt1170tQUJCCgoIcj7dt2yaLxaJOnTpd9+ya+O677zRr1izdf//9Sk1NlZOTk2Pd4MGDtXXr1hvan8zMTJ05c0ZDhw7VsmXLarXvp59+qkWLFmncuHGaMGGCY3m3bt00dOjQGz6W6+ncuXOqU6fOr94/Pj6+0uMePXro7NmzWrJkif7whz/I2dn5KnsIAAAAAAAAAAAAAAAAALhWLKY7cDOxWq0KCAi45DqL5T+Hql+/fpo5c6bjcVJSkgYPHqzPP/9c9957rzp06KARI0YoOztb+fn5mjBhgjp37qwBAwZo48aN16y/ubm5mjx5siIiItShQwfFxsZq3759jvVLlixR+/bt9e9//9ux7OjRowoPD9ecOXOUnZ2t/v37S5ImTJigkJAQhYSEKDs7+4rZS5culZOTk55//vlKBaIXRUdHO35eu3atHn30UXXv3l3dunXTyJEjtXfvXsf6+fPnKy0tTcXFxY4+jBw5ssbHwWq1as6cOXrhhRfk6upa4/0uWrx4sRo0aKBx48Zdcn3FsSxevFhDhw5Vly5d1LNnTyUkJOjIkSOO9UlJSVqzZo0OHjzoGEvFouPdu3dr1KhR6tSpk7p06aJJkybp1KlTlfJyc3OVkJCgjh07KioqSkuWLNGrr76qfv36VdruwIEDGjNmjKOt8ePHKycnp9I2ISEhWrhwod544w317t1bPXv21JYtWxQSEqIffvih0rYFBQXq0KGDVqxYUavjV79+fdlstkqF1AAAAAAAAAAAAAAAAAAA85hJtILQ0FC9//77Cg4OVt++fdWwYcMa73vy5EmlpqbqqaeekouLi1555RVNnjxZdevWVdeuXfXQQw/pww8/1JQpU9SxY0c1adLkqvpaUFCg4cOHy8PDQy+99JK8vLy0bNkyxcXF6eOPP5a/v7/i4uK0efNmTZkyRatXr5aLi4umTp2qpk2b6plnnpEkpaWlKTExURMnTlRERIQkVVsoW9GOHTvUvn17+fn5XXHb7OxsDRkyRE2bNlVpaak2bNig2NhYrVu3Ti1atNCwYcOUm5urrKwsZWRkSJI8PT1rfCzmzZun0NBQRUdHVyqSrQmbzaZdu3bpd7/7XY0KTHNzczVixAg1btxYRUVFev/99/XII4/oo48+Uv369TVu3DidPn1ahw8f1ptvvilJjmO0e/dujRw5UlFRUXrrrbdUUlKiefPmady4cfrggw8kSXa7XePGjdNPP/2k5ORkeXl5KT09XTk5OZUKlY8fP64RI0botttu0xtvvKHz58/rrbfe0ogRI7Ru3bpKx2/p0qXq2LGjXn31VdlsNkVFRSkwMFCZmZmaNGmSY7usrCxJ0r333luj43bhwgXt379fGRkZevTRR39VgS4AAAAAAAAAAAAAAAAA4PqhSLSCl19+WYmJiZo+fbokKTg4WNHR0YqPj1dwcPBl9y0oKNDy5cvVunVrSdKJEyeUkpKisWPH6umnn5YkhYWF6ZNPPtGmTZsUFxd3VX3NyMiQ1WrVypUr5e/vL0nq2bOn7rrrLqWnp2vq1KlycnJSamqq7rvvPs2dO1d+fn7av3+/Vq1aJTc3N0lS27ZtJUnNmjWr1a3s8/LyFBYWVqNtExMTHT+Xl5erd+/e2rt3r9asWaOJEycqKChIQUFBslgsteqDJH377bdatWqV1qxZU6v9LsrPz1dpaakaN25co+2nTZvm+LmsrMwxO+dHH32khx9+WE2bNpWfn59ycnKqjGXOnDlq37690tLSHLOv3nHHHRo8eLA+/fRTRUVF6Z///Kf279+vFStWqGvXrpJ+vqV7VFSUvL29HW0tWbJENptNixcvVv369SX9/FwOGjRIa9asqTQTq4+PT6VMSXrggQeUmZmpZ5991nGL+MzMTA0cOLBSzqXYbDaFhoY6HsfExFQ6LgAAAAAAAAAAAAAAAACAmwO3m6/gjjvuUFZWlhYuXKhRo0Y5Zue877779O23315234CAAEeBqCQ1b95cktSrVy/HMm9vb/n5+Sk3N/eq+/rZZ58pIiJCPj4+stlsstlsslgs6tatm7755hvHdk2aNNG0adOUkZGh+fPna/z48QoJCbnqfEmXvM38pRw6dEhPP/20evXqpbZt2yo0NFRHjhypcrvz2rLb7UpOTtbw4cPVqlWrq2qrpmPZs2ePHnvsMUVERKhdu3bq2LGjiouLrziWkpIS7dq1S7///e9VVlbmeM6aN2+uRo0aOZ6zb775Rt7e3o4CUUmqV6+eevbsWam9nTt3KiIiwlEgKkmtWrVSmzZt9PXXX1fa9s4776wyvgcffFAnT57Utm3bJEnfffed9u/frwcffPCKx8DFxUWrVq3SihUr9MILL2jr1q164YUXrrgfAAAAAAAAAAAAAAAAAODGYibRX3Bzc1NUVJSioqIkSdu2bVNCQoIWLFigtLS0avf75eyLF2+97eXlVaX98+fPX3U/z5w5oz179lSa0fGipk2bVnrcv39/paSkqKysTA899NBVZ0tSYGCgcnJyrrhdUVGRRo8eLT8/PyUlJalx48Zyd3fX9OnTr/o4bNy4UYcPH9acOXNktVolydGm1WqVu7u73N3dL9tG/fr15e7uXqOx5OTkaPTo0Wrfvr2Sk5MVEBAgV1dXJSQkXHEsVqtVZWVlmj17tmbPnl1l/fHjxyX9PAPtxdvTV/TLZVar1TELbEX+/v4qKCiosuyXgoOD1bt3b61atUp9+/ZVZmamgoOD1aNHj8uO46KLs8h27dpVwcHBevrppzVixIgazy4LAAAAAAAAAAAAAAAAALj+KBK9gsjISLVp00aHDh0y3ZVKfHx8FBkZqQkTJlRZd/FW8hclJyfL29tbNptNs2bN0muvvXbV+d27d9e6deuUn59faTbLX9qzZ49yc3P1zjvvqE2bNo7lhYWFCgoKuqo+HD58WAUFBerXr1+Vdd26ddPYsWM1efLky7bh4uKizp0768svv5TNZpOLS/VviW3btqm4uFhpaWmOomCbzValKPNSvLy85OTkpISEBA0YMKDKel9fX0k/z0h7+vTpKut/uczHx0enTp2qst2pU6ccs9heVN0sqcOGDdPkyZOVl5en9evXa+TIkTWeUbWi9u3bS5KOHj1KkSgAAAAAAAAAAAAAAAAA3ES43XwFP/30U5Vl586d0/Hjx9WgQQMDPaper169dOjQIbVq1UphYWGV/lW8nfyGDRu0ceNGvfrqq5o5c6bWrl2rTZs2OdZfnPG0trN6jhw5UuXl5dUWnP7jH/+Q9PPxq5gjSbt27dKxY8cqbe/q6qrS0tJa9SEmJkZLly6t9C8mJkbu7u5aunSpHn744Rq189hjj+nkyZP685//fMn1n376qWMsTk5OlQpJ/+d//kc2m63KWH55PD08PNSpUycdPny4yvMVFham4OBgST/P0Gm1WrVjxw7HvmfPntUXX3xRqb0uXbroyy+/rFSgevjwYR04cEBdunSp0bj79+8vb29vTZo0SQUFBXrggQdqtN8vXby9/W233far9gcAAAAAAAAAAAAAAAAAXB/MJFrBvffeq+joaPXp00cBAQHKy8vT8uXLdebMGcXFxZnuXiXx8fFav369RowYoVGjRqlx48Y6ffq0/vWvfykwMFDx8fHKy8vTzJkz9cgjjygyMlLSz4WVL730ksLDw+Xv76+GDRvK29tbGzZsUHBwsNzc3BQSElJlNtJfatOmjaZNm6aUlBTl5eVp6NChCgwMVF5enjZs2KCdO3dq+/bt6tSpkzw8PJScnKwnnnhCeXl5mj9/vgIDAyu116pVK9lsNmVkZCg8PFyenp5q2bLlZfsQHBzsKK68aPv27XJ2dlZERESNj2VUVJQef/xxzZ8/X99//70GDRokX19fZWdnKzMzU4WFhYqKinLciv2FF17QI488ooMHD+q9995zzCpacSyZmZnKyspSs2bN5Ovrq+DgYE2dOlVxcXF69tlnNWjQIHl7eys3N1eff/65HnjgAUVEROjOO+9UaGioJk2apIkTJ8rb21vvvvuu6tWrV2mWz/j4eK1evVqjR4/WU089pfPnz2vevHlq1KiRYmJiajRuV1dXDRkyROnp6erTp48aNWp0xX1iY2M1cOBAtWzZUhaLRf/617+0ePFiRUZGqkOHDjU+5gAAAAAAAAAAAAAAAACA648i0QoSExO1detWpaam6vTp0/L19VVISIiWLFniKBC8Wfj6+uqDDz7QvHnz9Oabbyo/P1/+/v7q2LGjBg4cKEl68cUX5e3treeff96x3/Tp0/XVV19pxowZWrBggSwWi2bPnq25c+cqPj5epaWl2rx5c5Xiy0uJjY1VSEiI0tPTNXPmTBUVFcnPz089evTQe++9J0lq0KCB3n77bb3++usaN26cmjdvruTkZL377ruV2oqOjtbw4cO1cOFCnTp1St26ddOyZcuu4RG7vClTpig8PFwrVqzQtGnTVFJSooCAAPXp00djxoyRJIWEhGj27NlKS0tTQkKC2rZtq7ffflvPPvtspbYefPBB7d27VykpKcrPz1dMTIxSU1PVuXNn/eUvf9H8+fP1wgsv6MKFCwoKClKPHj3UrFkzST/fGv6Pf/yjZsyYoRkzZsjb21ujRo3SkSNH9O233zoyGjVqpGXLlun111/X5MmTZbFY1Lt3byUlJcnT07PG4x44cKDS09M1dOjQGm3fvn17ffjhh8rJyZGLi4uCg4P1zDPPaPjw4TXOBAAAAAAAAAAAAAAAAADcGE52u91uuhMAqldaWqpBgwapa9eumj179jVt++2339Zf/vIXbdu27Yqzx14v588WGsmVJGuZs7Hseq4WI7ku561GciWp3K2ekdyc4nIjuZLkYnG68kbXgZuzmVxJ8nE3874qvmDueS43eCZ1tKDUSG5Hy3EjuZJU6tfCWLYpLiWnjeR+X1rzL57cKjzdzPx9Nsnk3wyTn0T97WbOQe0udYzkSpLVbuZ83+BLTPWcLhjJdbKdN5IrSXYXdyO5Jsec72Tmc4Yk+Z47YSTXcupHI7mSZPcJvPJG10GBdzMjuZK5v5U/FduM5EpSAw8z8wqY/Gzl/ts7DZSl9Kyx7EKLh5Fcg6clKiw1c93Cy+BnHFdDvz/dz50xkitJlpICI7kmr5W4nMs3lu1cdNJIbpmXmfMhSSp0NnOtpp7zb/C/kp3M/f60GTrcrnZz558qLzMSa+paiSR5uZo7MzH2Gis38/8ZklRu6nrJlveM5EpSWcEpI7n1Hp1uJBcAcGXMJArcZD744AOVl5erRYsWslqt+utf/6pjx45p7ty51yzj8OHDOnLkiJYvX67hw4cbKxAFAAAAAAAAAAAAAAAAAFw/FIkaYrfbVVZW/beiLBaLLBYz31IrLy9XeXn132x2dnaWk9P1/3aTzVb9N9acnJzk7Hzl2erKysp0uclyXVxuvreAu7u7Fi5cqGPHjkmS2rRpo3feeUdhYWHXLOPll1/Wnj17FBkZqYSEhGvWLgAAAAAAAAAAAAAAAADg5nHzVcj9Rmzfvl2jRo2qdn1MTIxSU1NvYI/+Y9q0aVqzZk2165cuXaqIiIjr3o/Q0NBq1zVp0kRbtmy5Yhvx8fHavn17tes3b96s4ODgX9W/62XIkCEaMmTIdc1YtmzZdW0fAAAAAAAAAAAAAAAAAGAeRaKGhIaGatWqVdWu9/X1vYG9qSwxMVGxsbHVrm/RosUN6cfljk9Nb4+enJyss2fPVrs+ICCg1v0CAAAAAAAAAAAAAAAAAOC/AUWihnh6el7T24dfS8HBwTfF7JrX4vi0bNnyGvQEAAAAAAAAAAAAAAAAAID/PhbTHQAAAAAAAAAAAAAAAAAAAMC1R5EoAAAAAAAAAAAAAAAAAADALYgiUQAAAAAAAAAAAAAAAAAAgFsQRaIAAAAAAAAAAAAAAAAAAAC3IIpEAQAAAAAAAAAAAAAAAAAAbkFOdrvdbroTAH67TlqLjWXXL8kzll3mHWQk91D+BSO5ktTUx9VIbp0ic8+z04USM7nlNiO5kmTzbWokt8zZ3UiuJLmctxrLdjpXaCT3hLuZ32GSFHj2ByO55fX8jeRKkpzMfK+rwOJpJFeSPN3MjNnJ4EejC4aiXVVuJliSy5mjxrJtfs2N5DoXnTSSK0nWOg2M5NZzNve+spSeNZJ70l7PSK4kFV8w8552+Y1+Bbmhh4uRXBcnI7GSJKeyUnPhhljLzXyWdTb4PHsXHTOSa3cx97nO7uZhJNdi8NxAdnPngeVegWaCL5wzkyupzNPMuVhRqbnnuczQ56s6Bn+BGjoVU/3zP5kJlmR3NnM+JElHbGauW9zm5WYkV5JcSk4byS1yrW8kV5LqOZn5P42cc+Y+5ASXnzKSW1g3wEiuJHmeN/TadvczkitJ9SxlxrJNnQea/H8cU+cl7v/aaCRXksoL841lm1Lnd2NMdwEAbmq/0cv4AAAAAAAAAAAAAAAAAAAAtzaKRAEAAAAAAAAAAAAAAAAAAG5BFIkCAAAAAAAAAAAAAAAAAADcgigSBQAAAAAAAAAAAAAAAAAAuAVRJAoAAAAAAAAAAAAAAAAAAHALokgUAAAAAAAAAAAAAAAAAADgFkSRKAAAAAAAAAAAAAAAAAAAwC3IxXQHbjbr1q3T0qVLdeTIEdntdgUGBqpz586aOHGi/P39JUn9+vVT3759NWPGjOvWj/nz5ystLe2y2zRp0kRbtmy5qhyr1aqMjAzdfffduv3222u9/86dO5Wenq49e/aosLBQfn5+6t69u+Li4hQWFlbjdr766ivt3r1bTz75ZK37cNG+ffs0bNgw1alTR7t37671/ps3b9aKFSu0b98+FRcXKyAgQH369NFjjz2mFi1a1LidTZs2KS8vT7GxsbXuw3+T3Nxc3X333SouLtYXX3whPz8/010CAAAAAAAAAAAAAAAAAFRAkWgFixYt0pw5cxQfH6/x48fLbrfr4MGDWr9+vU6cOOEoEk1LS5O3t/d17cuwYcMUGRnpeLxy5UplZWUpIyPDsczNze2qc6xWq9LS0tS6detaF4muWLFCKSkp6tGjh1588UUFBgYqLy9P69ev1+jRo7Vjx44at7V9+3YtXrz4VxeJ2u12paSkyM/PT8XFxbXe/80339SiRYt01113Odo5evSoMjMz9dxzz2nt2rU1bmvTpk3at2/fLV8kmpqaKg8Pj191vAEAAAAAAAAAAAAAAAAA1x9FohUsW7ZMMTExSkpKciyLiorS448/rvLycseydu3aXfe+BAUFKSgoyPF427Ztslgs6tSp03XPronvvvtOs2bN0v3336/U1FQ5OTk51g0ePFhbt269of3JzMzUmTNnNHToUC1btqxW+3766adatGiRxo0bpwkTJjiWd+vWTUOHDr3hY7mezp07pzp16lx1O1988YW++OILJSQk6LXXXrsGPQMAAAAAAAAAAAAAAAAAXGsW0x24mVitVgUEBFxyncXyn0PVr18/zZw50/E4KSlJgwcP1ueff657771XHTp00IgRI5Sdna38/HxNmDBBnTt31oABA7Rx48Zr1t/c3FxNnjxZERER6tChg2JjY7Vv3z7H+iVLlqh9+/b697//7Vh29OhRhYeHa86cOcrOzlb//v0lSRMmTFBISIhCQkKUnZ19xeylS5fKyclJzz//fKUC0Yuio6MdP69du1aPPvqounfvrm7dumnkCZw3CwABAABJREFUyJHau3evY/38+fOVlpam4uJiRx9GjhxZ4+NgtVo1Z84cvfDCC3J1da3xfhctXrxYDRo00Lhx4y65vuJYFi9erKFDh6pLly7q2bOnEhISdOTIEcf6pKQkrVmzRgcPHnSMpWLR8e7duzVq1Ch16tRJXbp00aRJk3Tq1KlKebm5uUpISFDHjh0VFRWlJUuW6NVXX1W/fv0qbXfgwAGNGTPG0db48eOVk5NTaZuQkBAtXLhQb7zxhnr37q2ePXtqy5YtCgkJ0Q8//FBp24KCAnXo0EErVqy47PG6cOGCUlJS9Mwzz6h+/fqX3RYAAAAAAAAAAAAAAAAAYA4ziVYQGhqq999/X8HBwerbt68aNmxY431Pnjyp1NRUPfXUU3JxcdErr7yiyZMnq27duurataseeughffjhh5oyZYo6duyoJk2aXFVfCwoKNHz4cHl4eOill16Sl5eXli1bpri4OH388cfy9/dXXFycNm/erClTpmj16tVycXHR1KlT1bRpUz3zzDOSpLS0NCUmJmrixImKiIiQpGoLZSvasWOH2rdvLz8/vytum52drSFDhqhp06YqLS3Vhg0bFBsbq3Xr1qlFixYaNmyYcnNzlZWVpYyMDEmSp6dnjY/FvHnzFBoaqujo6EpFsjVhs9m0a9cu/e53v6tRgWlubq5GjBihxo0bq6ioSO+//74eeeQRffTRR6pfv77GjRun06dP6/Dhw3rzzTclyXGMdu/erZEjRyoqKkpvvfWWSkpKNG/ePI0bN04ffPCBJMlut2vcuHH66aeflJycLC8vL6WnpysnJ6dSofLx48c1YsQI3XbbbXrjjTd0/vx5vfXWWxoxYoTWrVtX6fgtXbpUHTt21KuvviqbzaaoqCgFBgYqMzNTkyZNcmyXlZUlSbr33nsvewyWLl0qZ2dnPfroo/rb3/5WwyMNAAAAAAAAAAAAAAAAALjRKBKt4OWXX1ZiYqKmT58uSQoODlZ0dLTi4+MVHBx82X0LCgq0fPlytW7dWpJ04sQJpaSkaOzYsXr66aclSWFhYfrkk0+0adMmxcXFXVVfMzIyZLVatXLlSvn7+0uSevbsqbvuukvp6emaOnWqnJyclJqaqvvuu09z586Vn5+f9u/fr1WrVsnNzU2S1LZtW0lSs2bNanUr+7y8PIWFhdVo28TERMfP5eXl6t27t/bu3as1a9Zo4sSJCgoKUlBQkCwWS636IEnffvutVq1apTVr1tRqv4vy8/NVWlqqxo0b12j7adOmOX4uKytzzM750Ucf6eGHH1bTpk3l5+ennJycKmOZM2eO2rdvr7S0NMfsq3fccYcGDx6sTz/9VFFRUfrnP/+p/fv3a8WKFerataskqUePHoqKipK3t7ejrSVLlshms2nx4sWO2Tzbtm2rQYMGac2aNZVmYvXx8amUKUkPPPCAMjMz9eyzz8rZ2VmSlJmZqYEDB1bK+aW8vDwtWLBACxYscOwHAAAAAAAAAAAAAAAAALg5cbv5Cu644w5lZWVp4cKFGjVqlGN2zvvuu0/ffvvtZfcNCAhwFIhKUvPmzSVJvXr1cizz9vaWn5+fcnNzr7qvn332mSIiIuTj4yObzSabzSaLxaJu3brpm2++cWzXpEkTTZs2TRkZGZo/f77Gjx+vkJCQq86XdMnbzF/KoUOH9PTTT6tXr15q27atQkNDdeTIkSq3O68tu92u5ORkDR8+XK1atbqqtmo6lj179uixxx5TRESE2rVrp44dO6q4uPiKYykpKdGuXbv0+9//XmVlZY7nrHnz5mrUqJHjOfvmm2/k7e3tKBCVpHr16qlnz56V2tu5c6ciIiIq3e69VatWatOmjb7++utK2955551Vxvfggw/q5MmT2rZtmyTpu+++0/79+/Xggw9edhyvv/66ozAWAAAAAAAAAAAAAAAAAHBzYybRX3Bzc1NUVJSioqIkSdu2bVNCQoIWLFigtLS0avf75eyLF29d7uXlVaX98+fPX3U/z5w5oz179ig0NLTKuqZNm1Z63L9/f6WkpKisrEwPPfTQVWdLUmBgoHJycq64XVFRkUaPHi0/Pz8lJSWpcePGcnd31/Tp06/6OGzcuFGHDx/WnDlzZLVaJcnRptVqlbu7u9zd3S/bRv369eXu7l6jseTk5Gj06NFq3769kpOTFRAQIFdXVyUkJFxxLFarVWVlZZo9e7Zmz55dZf3x48cl/TwD7cXb01f0y2VWq9UxC2xF/v7+KigoqLLsl4KDg9W7d2+tWrVKffv2VWZmpoKDg9WjR49qx7B792599NFH+vDDDx3Hu6SkRJJ09uxZ1a1bV3Xr1q12fwAAAAAAAAAAAAAAAADAjUWR6BVERkaqTZs2OnTokOmuVOLj46PIyEhNmDChyrqLt5K/KDk5Wd7e3rLZbJo1a5Zee+21q87v3r271q1bp/z8/EqzWf7Snj17lJubq3feeUdt2rRxLC8sLFRQUNBV9eHw4cMqKChQv379qqzr1q2bxo4dq8mTJ1+2DRcXF3Xu3FlffvmlbDabXFyqf0ts27ZNxcXFSktLcxQF22y2KkWZl+Ll5SUnJyclJCRowIABVdb7+vpK+nlG2tOnT1dZ/8tlPj4+OnXqVJXtTp065ZjF9qLqZkkdNmyYJk+erLy8PK1fv14jR4687IyqR44c0YULFxQTE1Nl3YABA3TPPfforbfeqnZ/AAAAAAAAAAAAAAAAAMCNRZFoBT/99JMaNGhQadm5c+d0/Phx3f7/2bvzsBr2Pw7g79NqSRHJvnWpJEpCSqvStVPWUBSV7ET2fUmhlCKyVNdaZN9Vluw715qdqJQW2pvfHz3Nr6NTuGbOdN3P63l+z3M18zvvM3POmTNn5vP9fP/4Q6BnJVmXLl1w8OBBaGhooFq1auWud+TIERw9ehSbN29Gbm4uPDw8YG1tzRYqlnQ8/dmuniNGjEB0dDS8vb0ldsaMjY2Fubk5cnJyxHIA4ObNm3j37h1atmzJ/k1eXh55eXk/9Rz69++Pjh07iv1t//79OHr0KDZt2oQGDRr80OOMGjUKY8eOxYYNGzB+/Pgyy+Pi4mBmZoacnByIRCKxQtJjx46hoKBAbH15efky+7NatWrQ09PD8+fPoaurW+5z0dXVRUZGBq5duwZDQ0MAxV06L126JNat1sDAAHv27EF6ejpUVFQAFBfNPn78GHZ2dj+03VZWVlBWVsa0adOQnp6OAQMGVLh+165dERYWJva38+fPY9OmTVi/fn2Z4lRCCCGEEEIIIYQQQgghhBBCCCGEEEIIIcKiItFSevfuDQsLC5iYmKBu3br4+PEjIiIikJaWBkdHR6GfnhgnJyccOnQIw4cPx8iRI9GgQQOkpqbizp07UFdXh5OTEz5+/IjFixdjyJAh6Nq1K4Diwsp58+ZBX18ftWvXhpqaGpSVlXHkyBE0atQICgoK0NTULNON9FtaWlqYPXs2lixZgo8fP8LOzg7q6ur4+PEjjhw5guvXr+Pq1avQ09NDtWrVsGjRIowdOxYfP35EQEAA1NXVxR5PQ0MDBQUF2L59O/T19aGkpIQWLVpU+BwaNWqERo0aif3t6tWrkJWVRadOnX54X5qZmcHFxQUBAQF49uwZevbsiVq1auHt27eIiopCZmYmzMzM2KnYZ82ahSFDhuDp06fYunWrWPFmybZERUXh8OHDaNq0KWrVqoVGjRphxowZcHR0xOTJk9GzZ08oKyvjw4cPiI+Px4ABA9CpUyeYmppCR0cH06ZNw9SpU6GsrIzNmzejevXqYl0+nZycsG/fPowePRru7u7Izc2Fn58f6tevL7HTpyTy8vLo168fQkNDYWJigvr161e4vpqaGtTU1MT+9u7dOwBA+/btoaqq+kO5hBBCCCGEEEIIIYQQQgghhBBCCCGEEEKkQ0boJ1CZjB8/HklJSVi5ciWcnJywcuVKVK9eHdu2bZM4RbiQatWqhd27d0NbWxu+vr4YPXo0VqxYgXfv3qFt27YAgDlz5kBZWRkzZ85k/39z585FlSpVMH/+fACAjIwMVqxYgbdv38LJyQn29vZISkr6oefg4OCAiIgIKCoqYvHixXB0dGT32datWwEAderUgb+/P1JTUzFu3Dhs374dixYtQtOmTcUey8LCAsOGDUNISAgGDRqEBQsWcLGbfpinpyfWr1+P9PR0zJ49G05OTli3bh2aN28Of39/AICmpiZWrFiBBw8ewNXVFUeOHIG/vz9q1Kgh9lj29vawtbXFkiVLYG9vj8DAQADFhZQ7duzA169fMWvWLIwdOxZBQUGoUqUKuz9EIhGCgoKgpaWF+fPnY/78+TA3N0eXLl3EcurXr4/w8HCoqKhg+vTpmDdvHrS0tBAeHg4lJaUf3m5ra2sA+OHuo4QQQgghhBBCCCGEEEIIIYQQQgghhBBC/j1EDMMwQj8JQkj58vLy0LNnT3To0AErVqzg9LH9/f2xY8cOnD9//rvdY/mSnPFVkFwAqJn9UbDsQuV6guQmfM4XJBcAmqjIC5JbJUu411mUny1MblGBILkAUFCriSC5hbKKguQCgFxuhmDZopxMQXKTFIU5hgGA+peXguQWVa8tSC4AQCTMuK50mR8feMI1JQVhtlkk4E+jfIGi5VEkTDAAubTXgmUXqDYTJFc2K1mQXADIqFJHkNzqssJ9rmTyvgiSm8xUFyQXAL7mC/OZlvuPDkFWqybMBD1you+vwxdRYZ5w4QLJKBLmt6ysgK+zctY7QXIZOeF+1zEK1QTJlRHw3ACMcOeBRTXUv78SH/JzhMkFUKgkzLlYVp5wr3OhQL+vqgh4ABXoVAw1c1OECQbAyAo3YeGLAmGuWzSuIcy9FACQy04VJDdLvqYguQBQXSTMPY33OcL9yGlU9EmQ3MyqdQXJBQClXIHe24rCzZJYXaZQsGyhzgOFvI8j1HmJ4p2jguQCQFHmZ8GyhVLFxlnop0AIIZUaTTdPSCWze/duFBUVoXnz5sjIyMDOnTvx7t07rFmzhrOM58+f48WLF4iIiMCwYcMEKxAlhBBCCCGEEEIIIYQQQgghhBBCCCGEEMIfKhIVCMMwKCwsf4SQjIwMZGSEGaVWVFSEoqLyRxDJyspCJOJ/NG5BQfmd8EQiEWRlZb/7GIWFhaioWa6cXOX7CCgqKiIkJATv3hV3bdDS0sLGjRuhq6vLWcaCBQtw+/ZtdO3aFa6urpw9LiGEEEIIIYQQQgghhBBCCCGEEEIIIYSQyqPyVcj9R1y9ehUjR44sd3n//v2xcuVKKT6j/5s9ezb2799f7vKwsDB06tSJ9+eho6NT7rKGDRvi7Nmz330MJycnXL16tdzlZ86cQaNGjf7R8+NLv3790K9fP14zwsPDeX18QgghhBBCCCGEEEIIIYQQQgghhBBCCCHCoyJRgejo6CAyMrLc5bVq1ZLisxE3fvx4ODg4lLu8efPmUnkeFe2fH50efdGiRfjy5Uu5y+vWrfvTz4sQQgghhBBCCCGEEEIIIYQQQgghhBBCCPk3oCJRgSgpKXE6fTiXGjVqVCm6a3Kxf1q0aMHBMyGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQv59ZIR+AoQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEe1QkSgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEPIboiJRQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEkN8QFYkSQgghhBBCCCGEEEIIIYQQQgghhBBCCCGE/IaoSJQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCHkNyRiGIYR+kkQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEG5RJ1FCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYSQ3xAViRJCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYT8hqhIlBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIeQ3REWihBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIb8hKhIlhBBCCCGEEEIIIYQQQgghhBBCCCGEEEII+Q1RkSghhBBCCCGEEEIIIYQQQgghhBBCCCGEEELIb4iKRAkhhBBCCCGEEEIIIYQQQgghhBBCCCGEEEJ+Q1QkSgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEPIboiJRQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEkN8QFYkSQgghhBBCCCGEEEIIIYQQQgghhBBCCCGE/IaoSJQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCHkN0RFooQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCG/ISoSJYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCPkNUZEoIYQQAmDKlCmIj48X+mkQQjiQkZEh9FMQ8/btW8THx+Pz589CPxXymxLqPSat3Ly8vAqXf/z4kZdcoc4NcnNz0adPH1y4cEFqmYWFhSgqKgIAMAyDgoICqWW/efOGPW5nZWXh9evXUsuOi4vD8+fPAQCvXr1CbGzsb51L/i8xMRE3b97E169fhX4qhBDyr/W9czRCCCGEEEIIIYQQUnnICf0ECCGEfN+nT5+Qm5tb5u8NGjT4rbIHDRqEgQMHokePHqhevTrnj1+Rt2/fYvTo0WjQoAEGDBiA/v37o2HDhlJ9DtKWlZWFvLw8qKqqsn87ePAgEhISYGRkhM6dOwv47H5PDMNAJBIJ/TSk6vnz5zh58iQ+fPhQ5lgiEomwfPlyzjNNTExgY2MDOzs7GBkZcf74FVm5ciUKCwsxZ84cAMCpU6cwZcoUFBQUQEVFBaGhoWjTpg3nue/evUNWVhY0NTUBFN+wDQ0NRUJCArp06YIBAwZwnlni3LlzyMjIQK9evQAUF97Mnj2bzZ4/fz6qVavGW/7OnTvRu3dvKCkp8ZZRno8fP+Ljx48SvycNDQ15yRTqPSZULgCMHz8eQUFBkJMr+/P1zZs3GDVqFE6fPs15rlDnBoqKivj48SNkZKQ3pnPz5s1QUlKCg4MD9uzZg/T0dIwdO1Yq2ZcvX8bz588xc+ZMBAcHo1mzZmjSpIlUsqtXr441a9YgMDAQq1evxsiRI3/rXEkSEhKQlJSE3Nxc1KxZE82aNUPNmjWlkl1YWIjc3FxevyO+tXv3bgQGBiIlJQUAEBkZCR0dHXh4eKBjx45wdHSU2nP5r5Dm61xYWIi4uDjEx8fjzp07SE5ORk5ODmrWrInmzZujQ4cOsLGxQePGjXl7Dmlpabh79y6Sk5PZz1Xz5s2hra3N+++Ar1+/4tOnT+w2q6mp8Zon5P7+/Pkzrl69Wia3RYsWMDAwgK6uLueZJR4/flzuNhsaGqJr1668v9+lffyMjo5GZmYmRowYAQB48uQJxo8fj7dv38LAwAB+fn6oXbs2p5mV4fNc+rlI+/tKKEIewwDpH8fI/6WmpkJJSQkKCgqC5L98+RKHDh3ChAkTBMknhJB/E4Zh8PLlSzRo0ACKioqCPIe0tDQ8e/aMt+ufX79+LffcKz8/H8nJyZzfo0xOTkZ+fj77uAzD4NSpU3j16hWaNGkCKysridcmpSE3NxefPn2Syj1haWEYBkVFRZCVlWX/9uDBA7x69QqNGzfm9Tfdt3JycjBnzhyMGzcOGhoaUsslhBAhiBiGYYR+EoQQUtmcPHnyp9a3sbHh/DmkpaVh6dKlOHnyZJluTiWFZg8fPuQ8V8jsyZMn4+zZs5CVlYWtrS3s7OzQoUMHznPK8/TpU0RFReHQoUNIS0tDp06dYG9vD2tra14vkgpVrOnu7o66deti0aJFAIDAwEAEBgZCRUUFmZmZ8PX1RY8ePXjJBoD379+Xu0xGRgZKSkpSLfp6+/YtXr9+jdatW/NWHGFqaor+/fvDzs5OagUwQoqOjsbs2bOhqKiIBg0aQF5eXmy5SCTC/v37Oc/dsWMH9u3bh/v376Nhw4YYMGAABgwYgPr163Oe9S0rKytMnDgRffv2BQD8+eefaNGiBSZNmoRVq1YBKC7G4tro0aOhpaWFGTNmAACWLVuGnTt3olWrVnjy5AlmzZoFBwcHznMBwN7eHn/++SecnZ0BFB9bHjx4gJ49e+LgwYPo3bs3vLy8eMkGgHbt2kEkEsHGxgb29vbo2LEjb1kl3rx5A09PT9y5cwdA8XdjaXx+Rwv1HhMqFwCsra3RunVr+Pn5id2cfvnyJRwdHdGkSROEh4fzki3UucG8efMAAEuWLOEto7SvX79ixIgR2LhxI1xdXREREYGqVatKJRsARo4ciQkTJiAwMBDbt2+XWi4AeHl5QUNDAwkJCVi5cuVvn1tUVISYmBhER0fj8uXLyMrKEjuGiUQiaGhowNbWlvPC6LS0NBw+fBgXL17E3bt3kZaWBgCQl5dHs2bN0KFDB9ja2vJ2HN+2bRt8fX0xatQoGBkZYfTo0YiKioKOjg62b9+O48ePY+fOnbxkVzZ8nvcK8Tp/+fIFW7duxc6dO5Geno6WLVtCS0sLNWvWhIKCAjIzM/Hu3Tvcv38faWlp6NixIyZMmAADAwNO8jMzM7F//35ER0fj4cOHEs8LqlWrBmtrawwcOJCzXKC4YHH//v24ePEiEhISxLJr1KgBfX192NrawtbWlrPjupD7++rVqwgLC0NsbCwKCwtRv3591KpVi819//49vn79ioYNG8Le3h4jRozg5DclwzCIjo5GeHg4/v77b6ioqKBVq1Zi2e/evcPz589RpUoV/Pnnn3B3d0ejRo1+ORsQ/vjZu3dvDBkyhP09MWLECKSmpmLo0KEIDw9Hhw4dsGzZMk6yhP48A8Lvb2kT8hgGCHMcK/H582ckJyejUaNGEh87KysLDx8+5K0ARtpu3bqFM2fOoKCgADY2Nmjfvj2io6OxatUqpKWlQU5ODgMGDMC8efOkUgSTnJyMI0eO4NChQ3jw4AHk5eVx7949TjMYhsHz589RUFCAVq1aQSQSISkpCdu2bcOzZ8+gqqrKy/saALKzs1FYWMh+D2VnZ2Pfvn1sbt++ff8T1wYri2vXriEgIABhYWGcPm5aWhoOHDiAjx8/4o8//kDPnj1RpUoVsXXevHmDoKAgrFixgrPcGzdu4MCBA8jPz8fQoUPRtm1bnD9/HqtWrcLr16/RuHFjeHh44M8//+Qs82fcv38ff/31F6fbnJ+fj9jYWCQlJaFFixYSGwN8/PgRe/fuxfjx4znLBYpnADlx4gTy8vLQr18/NGrUCA8fPoS/vz+7v11dXdG+fXtOc8uTmZmJjh07sudhQjhx4gQmT57M+fXP9evXY9u2bcjKyoK6ujqcnZ3ZgUol7ty5gyFDhnCWnZWVhUmTJrGzCVlZWcHX1xeurq64cuUK5OTkUFBQAG1tbUREREi9wQ3Az/6Ojo7Gli1bkJSUBA0NDTg7O8PS0lJsHa73NVDc3GLp0qU4dOgQ8vPz4eDggFmzZsHLywvR0dEAis8/TU1NERgYWOae0j9V0UxYmZmZsLa2RnBwMPT19QFAagOoCSFE2qhIlBBCJNDS0vrhdfkqBPHw8MC1a9cwcuRIaGhoSDwR7tatG+e5Qmenp6fj4MGD2L9/P/7++280bdoUdnZ26NevH+rWrctL5rcKCwsRExODqKgonD9/HtWrV0evXr1gb28PbW1tzvOEKtY0MTHBggULYG1tDYZhYGxsjIEDB2LKlClYsWIFrl+/jqioKM5zS2hpaX23E0XDhg3h6OhY5kLArxKqI56Pjw8OHjyIlJQUdOjQAXZ2drC1tS1z8ZAP9+/fR2ZmJnsBLT09HT4+Pmy3Rw8PD8671nXv3h2tW7fG8uXLpVpsVOLJkydscdfnz59hZGQEe3t7dOvWjbOLC99q27YtQkNDYWhoiNevX8PGxgaRkZFo06YN4uLiMHPmTFy+fJnzXCMjIyxbtgyWlpYoKCiAkZERPDw84OTkhA0bNrA3XvhgaGgIPz8/GBsbIysrC507d4avry9sbW2xb98+BAYG4uzZs7xkA0BGRgYOHTqEqKgo/P3332jcuDHs7OzQv39/qKur85Lp6OiI169fY+LEidDQ0JBYLPgz5xI/Q6j3mFC5QPENleHDh6NLly7sDYanT5/CyckJWlpaWL9+Pe/HUWmfG+zfvx9r1qxB69atYWpqijp16pT5zuRqkNK1a9cAAGfPnsWpU6dgbW3NXhTm+4Z4YGAggOJulmfPnoWVlRVatGgBAJzf1PnWiBEjIBKJkJmZiUePHkFLSws1atQAAM5vHFaGXAA4fPgw1q1bh+TkZJibm0NfXx9aWlpskVNGRgZbeHPu3Dk8f/4c/fr1w4QJE37pePr+/XusW7cOR44cgYqKCvT09MrNffDgARo1agQPDw/06dOHw60v/v0yYMAAjBs3DoWFhdDR0WGLRM+dO4cZM2bwdhz7ljS70knrvFfI17lz585o2bIl7Ozs0K1btwqLAh88eIDDhw8jKioKkyZN+uVBNBs2bMCWLVugrKwMW1vb736uLly4AAMDA8ydOxd//PHHP869desW1qxZg2vXrqFt27YV5sbHx6OoqAijR4+Go6PjL7/vhNrfo0ePxt27d2FjY8Pu65LjZ4mSYqBz587hyJEjePPmDVatWgUzM7N/nAsAPXr0QH5+Pvr16wdbW9tyu8tkZ2fj/PnzOHLkCM6dO4fFixejd+/e/zi3shw/27dvj6CgIHTu3BmpqakwMTHBhg0bYGpqiqNHj8Lb2xtxcXGcZAn5ea4s+7s0vmcuEOoYBgh7HCsoKMD8+fMRHR0NhmGgoKCAoUOHYvLkyWK/K/gojLhy5Qq2bduGpKQk/PHHH3Bycirze+Lhw4cYP348zpw5w1numTNnMGHCBKioqKBKlSpISkqCl5cXVqxYATMzM2hoaODJkyc4f/48Zs6cCScnJ86yS8vKysLJkydx6NAhXL16FUVFRdDU1ISdnR169eqFWrVqcZb1/v17uLq64tmzZwAADQ0N+Pv7w8XFBR8/fkStWrWQlpYGGRkZbN++nbNC0c+fP8PT0xMXL14EwzDo0qULvL294ezsjMePH7PrVa1aFbt370arVq04ya3IlStX8OzZM+Tm5kJHRwedOnXiPCMlJQV16tTh/HG5wkeB1fv37zFw4ECkpqZCVVUVnz59grq6OlatWiW2j7k+lly8eBFjx45F3bp1UaNGDbx+/Rpr167FpEmTYGpqCh0dHVy/fh3x8fGCFRFyvb/T0tIwfPhwJCQkACi+J9e6dWusWrVK7LyMj+P2vXv34OjoiPz8fCgqKkJWVhYhISEYM2YMGjVqhNatW+POnTt4+fIloqKiOPtML126tNxleXl52LNnD6ytrdnf6nPnzuUk90fx8ZmKiorCvHnz2Gtt169fx7Fjx2BkZAR/f3/2vJDr13nlypWIjo7GtGnToKKigqCgINStWxfPnj1DUFAQtLS0cPv2bYwfPx5Dhgzh/XqVJFzv7zNnzsDDwwPGxsbQ1tbGjRs3cPv2bdjZ2WHRokVsd08+PlNBQUHYuHEjnJycULNmTYSFhaFz586IiYnBsmXL0KZNG1y/fh0LFizAxIkTOZt953vXb7+dBZCvBhCEECI0mm6eEEIk4PIi3D915coVzJ07F/369ftPZauoqGDEiBEYMWIEHj16hMjISGzZsgXr1q2DiYkJ7O3tYWlpyesUrLKysmxxRFpaGm7fvo19+/Zhx44dMDAwwJIlS9C8eXPO8u7du4cFCxYAKP4hsmPHDri6urLFmqGhobwUiaanp7MXX0u6cNjb2wMALC0tsXfvXs4zS/Px8cGaNWvQrFkzWFlZQVVVFampqewUHmPGjMHt27fZgiAuC0VPnTqFiRMnsv9es2YNzMzM2I54fn5+vHTE8/T0xLRp0xAbG4v9+/dj7ty5WLp0KXr06AF7e3u0bduW88wSK1asgJGREVskunz5cpw+fRrGxsbYsmULZGRk4OHhwWlmUlISFi5cKEiBKAC0atUKs2bNgqenJ2JiYhAaGoqpU6dCWVkZffr0gYODA5o1a8ZpZo0aNfDp0ycAxRdtVVRU2MILBQUFiTf3uPDlyxf2JvmdO3eQlZXFHjcMDAywYcMGXnKB4htsJcfkkmKzrl27AgAaN27MTunLF2VlZTg4OMDBwQGPHj1CVFQUtm/fjoCAABgbG8POzg6WlpacFgbfvXsX3t7evHQS/x6h3mNC5QLF76OtW7dixIgRWLx4Mezs7DB69Gjo6+tj3bp1UpkSUdrnBrNmzQIAxMXFSSy64HKQ0r59+wAUFyG8e/cOT548YUfX810kWtKlMikpCVWqVIGSkhKnnSsrUtK9MyoqCjIyMjA3N8eAAQN+21yguCjXzc0NPXr0KLewWldXF7a2tpg+fTqePn2KrVu34sCBAxg7duw/zu3ZsydsbW2xdetWGBgYVDhIKDU1FceOHcP69evx4cOHX8r91sePH9mOEN+Sl5fH169fOcv6lpBd6aR13ivk6xwUFPTDXXt0dHSgo6MDDw8PJCYm/lIuUNzZMiAgoNxiC1VVVaiqqkJXVxdDhw5Feno6IiIicOXKlV8qsHJzc8OIESPg7e393SkHCwoKcOHCBWzduhVFRUW/fM4v1P7u2LEj/P39yxSGllbSDVlDQwOjRo3C9evXkZWV9Uu5QPHAzp49e373OkTVqlVhY2MDGxsbvH37Fh8/fvyl3Mpy/JSRkUF+fj4AsN2USmY8UVNTq7Arz88S8vNcWfY3IL2ZC4Q6hgHCHse2b9+Oo0ePYtKkSWxhRFhYGC5duoSQkBDeBhtev34do0ePRtOmTaGpqYlr167hyJEj8PDwgLu7O7teXl5ehbPv/BMhISGwsbHB6tWrISsri+DgYHh7e2PUqFHw9PRk11u+fDmioqI4LRLNz89HXFwcDh48iLi4OOTm5qJx48YYMWIEtm/fjjlz5vDyu2P16tX4+vUrAgMDUa1aNaxfvx5jxoyBuro6oqKioKqqipSUFLi7u2P9+vXYsmULJ7l+fn64d+8evLy8UK1aNWzduhUuLi7Iz8/Hvn37oKGhgcePH2PGjBlYt24dO3COCz4+PpCXl8fkyZMBFBduTpgwAbdu3WILfoqKitChQwcEBwdzOoNT165doa2tjd69e6NHjx68fY6+9aMzwt2+fZvz7NWrV0NVVRX79u2Duro6Xrx4gaVLl8LZ2RlLlixB//79Oc8EgODgYFhaWsLf3x8yMjIIDQ3F9OnT0adPH7HCwokTJyIkJITTItEHDx780Hpv3rzhLBMA/P39kZ2djZ07d6J169a4fv06vL29MXjwYKxbtw5dunThNK+0devWQUdHBxs3bkTVqlWxcuVKeHh4wNDQEIGBgRCJRCgsLMSoUaOwfv16+Pv7c5IbERGBGjVqSDz3LSlmu3XrFhQUFCASiTgrEv3RAU5fvnzhJK+08PBwjBkzBlOmTAEADB06FEOHDsXUqVMxfPhwbNq0CWpqapznnj59GhMmTMDAgQMBFF+rsrOzw9KlS9kmAHp6enB2dsa+ffs4LRJ1c3P7ofW4vr4eEhKCQYMGYfHixezfDh06hIULFyIxMRHr1q3jrWPqwYMHMX78eIwZMwZA8XWo4cOHY/bs2bCysgJQfF7+8uVLREdHc1YkWqVKFVSvXh0uLi5QUVERW/b161csWbIELi4u7OB1Qgj5bTGEEEIqJQsLCyY2NvY/l11aWloas23bNqZnz56MpqYm0717d0ZLS4uxsrJibt26xUtmQkICs2rVKsbY2JjR0dFhPDw8mNjYWKawsJCJj49n+vfvz9jZ2XGa2aZNG+batWsMwzDM3bt3GS0tLeb169cMwzDM5cuXGX19fU7zSpibmzM7d+5kGIZhAgICGCsrK3ZZTEwMY2hoyEtuifnz5zPz5s2TuGzu3LnMrFmzGIZhmIULFzK2tracZuvq6jJXr15lGIZhXr16xWhqajL37t1jGIZhYmNjmU6dOnGaV55Pnz4xW7duZXr27MloaWkxvXr1YrZu3cqkp6dzntWxY0f2c52dnc20a9eOiYyMZBiGYSIiIhgbGxvOM11cXJht27Zx/rg/o7CwkDl79izj4eHB6OjoMCYmJsy8efMYS0tLRkdHh9m9ezeneRMnTmT+/PNPJiIigrGwsGBmz57NLouIiGD+/PNPTvNKWFtbMyEhIQzDMMyKFSuYXr16sctOnTrF63t6wIABjJeXF/PlyxfG1dWVGT58OLvsyJEjTNeuXXnLLs+HDx+Y4cOHM5qamoympibTuXNnxt/fn8nOzubk8bt3786cOnWKk8f6WUK9x4TKLe3hw4eMoaEh06ZNG2bixIlMQUEB75kMI8y5wdu3b7/7P665ubkxhw4dYtzd3Tl/7Irk5+czgwcPZp4+fcoMHjxYaq8rwxR/Dw8YMIDJyspi7OzsmNTU1N86t6ioSKr/vxL/5P1aVFTEfPjw4Zdyv2VjY8Ns3LiRYRiGKSgoYDQ1NZn79+8zDMMwwcHBTO/evTnNYxiGeffuHTNz5kymTZs2jLGxMePh4cEEBAQwERERzJ49e5jNmzczixYtYgYOHMi0bt2asbGxYQ4cOMDpc5DWeW9leZ0rkpaWxty4cUNqeXzKysr6R/+/L1++cPxMyvc77e8flZuby+l7urJ8rhwcHBg3NzfmyZMnzNChQ5kxY8awy6KjoxkLCwtO84RSWfY3wzDMyJEjGXNzc2bfvn3MnTt3mIcPH5b537+dkMexHj16sL+fS7x48YLp1asXY2Zmxjx9+pRhGIa5ffs2o6Wl9ct5JUaMGMFMmDCBKSwsZBim+HwkODiY0dHRYby8vNjzYK5zGYZhDAwMmPPnz7P/Tk1NZTQ1NZkrV66IrXfx4kVGT0+Ps9w5c+YwHTt2ZLS0tBhjY2NmyZIlzO3btxmGYZiMjAxGU1OTPU/hWteuXcXOq549e8Zoamoyp0+fFlvv2LFjjJGREWe5FhYWYtea7t27x2hqajJHjhwRWy86OpoxMTHhLJdhiq/1RkdHs/+eNGkS07VrVyY+Pp4pKChgCgoKmPPnzzPGxsbM3LlzOc3W1NRkbGxsGE1NTUZbW5sZMWIEs2fPHl6ucX6bq6WlxV7/qeh/XH+uTE1NmWPHjpX5u7+/P6OlpcUEBwczDMP9Z9rQ0FDs3k1aWhqjqakp9hlnGIY5efIkY2pqylkuw/x/f3/vf1zvb0tLS2b//v1if8vNzWVmzpzJ6OjosJ91Po6fnTt3FrsGmJSUxGhqajIxMTFi6x05coTTc6KlS5cy7du3ZwICApicnByxZenp6bwdP1u3bs306dOH8fLyqvB/I0aM4Hxf6+npMZcvXy7z98TERKZXr16MhYUFk5CQwPnr3KZNG7F9mZuby2hqarLfVyXi4+M5v1enpaXFWFpaMsOHD6/wfyX3j7jSvn17Jj4+vszfHz58yHTt2pXp378/k5KSwstnSldXV+z8Izs7m9HU1Czz2/HChQuc3qP88OEDM2nSJKZTp07MX3/9JXati+9zEkIIqUyokygh5F9BiGmSS2MYBnFxcbhx4wbS09OhoqKCDh06wNTU9LvTZf9Tzs7OCA8Ph7GxMeTkpHu4FjIbAM6fP4+oqCicPXsW1atXR58+feDv7w8NDQ28fv0aixYtwuzZs3H06FHOMvfu3YuoqCjcuXMHjRo1wsiRIzFgwACxaXKMjIwwa9YsODo6cpYLAHXq1MGzZ8/QoUMHxMXFoWHDhmjcuDGA4unq+HoNbG1t4ePjg/j4eJw7dw4uLi7ssr///htNmzblJbfE0aNH4efnV+5zmzx5MpYvXw5zc3NERkZymi1kR7zSUlJSkJiYiE+fPkFeXh5169Zluwh4e3uzIye5kJOTw3b0vHnzJvLy8tjH19TUxIcPHzjLKjF16lR4enpCUVERxsbGEkc+16xZk/NcAOwUP9HR0UhNTUXXrl3h7+8Pc3NzyMrKgmEY+Pr6wt/fH4MGDeIsd/bs2fD09ISvry90dHTYkc9A8ShZvqZ4sre3h7+/P44fP46HDx+yXQiB4s6i5U2JyYVx48Zh0qRJiI6OhqysrFjX0vPnz6N169a8ZZfGMAzOnTuHqKgoxMTEQFlZGc7OzrC2tkZcXBwiIiLw9OlTBAQE/HLWlClTsGnTJnTo0IG393B5hHqPSTt369atEv9ubGyMS5cuQVdXl52aWyQS8TIdopDnBtLqplni9OnTqFmzJnr16oVLly7h9OnT6Natm1Syw8LCYGpqij/++AOWlpYICwvDqFGjpJK9b98+ODk5oXr16nB2dkZUVJTY+dDvlvujv1sePHiAXbt2YcmSJT/1/yvPj76fExMTcf36dfTu3RsikYjz7kODBg1CYGAgatWqxXaCLigoQGxsLEJDQ9mOS1yqDF3ppHXeW1le54pcuXKF8ykRf9T169cRFBTEWZeyH+3q8vz5c5w8eZLtUPOrUzT/DKH296lTpzBlyhTcv39fqrkAEBMTw+k2V5bP1ZQpU+Dm5oY+ffqgevXqYudpp0+fhq6uLqd5kmRnZ0s8XnF5Ll5Z9jcg7MwF0iLkcezdu3fQ09MT+1uzZs2wc+dOeHh4YNiwYQgKCuJ0NgoAePz4MVavXs1ew5aVlYWbmxt0dXUxceJEfPr0ibMOdN/KysqCsrIy+++S//72dahevTpycnI4y42MjIRIJEKXLl2wePFiqf7OSU5ORpMmTdh/l/z3t5/ZevXqsV3eufDx40exTrslU0+XXOst/XxKztG4kpKSIraPz507h8WLF7P3VADAxMQE06ZNg7e3N3u+zxUfHx/Url0bhw4dwpEjRzBv3jwsXrwYZmZm6NWrFywtLTmfCaRWrVowNzf/bme/uLg4zrc3MzOTnaWrtIkTJ6JevXpYtGgRkpKSfrgz44/Kz88X248l11u/fS4qKiqcvrdLsrp06QIHB4cK17t69SrWr1/PWe6nT5/KHD8UFBSwcuVKqKurw8vLC8nJybxcE/v69avYNW1VVVUAKNPRUk1NjdNuj3PmzIG9vT2WLl2Kffv2YcaMGbC1tQXw67/RK9KyZUs0bdqUnd2tPCdOnGBnlOKKsrIyUlNTy/y9Xr162LFjB8aOHYthw4b9cPfNH6WkpCTWGV9OTg7q6uplZkfLzc3l/D508+bNoaOjAx8fnwrXO378uNi12F9VtWpVid1gtbS0sHPnTjg7O2Po0KGcdk0tnZ2Zmcn+u+R8S1FRUWy9oqIidjYDLqirq8PPzw+XLl3C0qVLsWvXLsydO5eXGV0IIaQyoyJRQsi/ghDTJJdIT0/H2LFjcefOHSgrK6N27dr49OkTNm3aBD09PYSEhIhdZOPK8+fPkZCQAGtraxgaGkrM4GoKicqS7efnhwMHDuDDhw/o2LEjVqxYAWtra7GLHk2aNIGHh8d3L0T8rMWLF8Pa2hqTJk0Su3D2raZNm2LcuHGcZgtVrDlt2jRUr14d9+/fx+jRo8VuRD948AB//vknL7klZGRk8OjRIxgbG5dZ9vDhQ7GL5uVNifpPdejQAevWrcOnT58QGhoqVgjz/Plz1K9fn9O80rKysnD48GFERUXh/v37+OOPP+Du7o6+fftCRUUFWVlZWLJkCZYtW8ZpkWjjxo1x7tw5dOzYEYcOHYKOjg57Q+3Tp0+cTjFVomRapYULF5Z78YqPm8ZDhw7F7du3Ub9+fQwZMgT29vZlbgKIRCJ0794doaGhnGarq6uzhWvfCg0N5W1a7LFjx6Ju3bq4d+8ehg0bJjZ1cXp6OjtdDh+srKxw7Ngx/P3339DU1ESzZs3YZXp6etDU1OQtGwBev37NFgQnJSWhS5cu8PX1hZWVFVtkr6enhzZt2mDq1KmcZO7fvx8fPnyApaUltLW1yxRAi0QiBAcHc5L1LaHeY9LO9fb2rnC5r68v+998FYkKeW5QmjSKImrXrs0WyE2aNAlv377l7LG/x97enn3/ODo6cnpT+ntKn3Pxfd5TGXJ/1Nu3bxEZGcn5TdTvuXv3LmbMmMH5TdQSzs7OSExMxPz587FgwQIAxecMADBs2DDOf18AwOHDh3+4GEJVVRUODg4YNmwYkpKSOHsOQp73SsL361xZffr0CZcuXZJ67tOnT+Hv78/5jdTKrKioCIWFhUI/Dani+3NlYGCAmJgYvHz5Ek2aNBG7RmRvby9WhMWlrKwsrFq1CidOnEBGRobEdYQo+pbGcUxdXZ3XwfDfk5aWhqVLlyI+Ph4Mw6BLly6YPXu22GApaeHjOKaqqipxOnclJSVs3rwZ06ZNg7OzM0aMGMFZJgB2SuJvGRsbIywsDGPHjoWjoyOvvy0kPSc+eXl54dChQ7h48SKsra3RoUMH9O7dG927d+c9m2EYsc9RyX9/m8v18ygsLBQb8F8yzfu3n2kZGRkwDMNpdt26dfH27Vu2UI5hGLagrTRVVVXefnc1bNgQbm5ucHNzw6NHj3Do0CEcO3YMp0+fRvXq1WFtbY1evXrBxMSEk7x27drhxYsX3z3nrl27Nid5pTVp0gR37txBp06dyiwbNGgQatWqhWnTpuH69euc5tatWxevXr1ir1PIyspiyZIlZfZBYmKixCLWX6Grq4vU1NTvFlVxXZzasGFDPH78GIaGhmWWTZkyBXXq1MHy5csrvHbzT9WuXRtv375lX2cZGRm4ubmhbt26YuslJydzfp9QU1MT4eHhOHjwIJYtW4a//voLc+fORYMGDTjNKa1t27Y4f/78D63L9TFMR0cHp0+flnidpEaNGti2bRsmTZqElStXcnrs/uOPP3Dnzh1YW1sDKH6N4+Liyqz3+PFjzs9727Vrh5s3b353PZFIxOn+1tTUxLlz5yQOEG/YsCF27twJFxcXzJ49m7PMEs2aNcPDhw/Ze1+ysrJ48OAB+31ZIiEhgZfBJUZGRjhw4AC2b98Od3d3mJiYwN3dnfMcQgiprKhIlBDyr/Ds2TO2gC0nJwcnTpzAvHnzYGdnh7/++gthYWG8FYl6e3vj9evXCA0NFStmu3jxIjw9PeHt7Y1ly5ZxnhsTE8P+0JF0IUEkEvFWJCpUdmRkJPr374+BAwdW+GOrRYsWWL58OafZ586d+6GLJnXr1uV89Ny3xZqurq7sMj6LNeXk5MrdFi5H+pand+/e8Pf3R35+PiwsLKCqqorU1FScOXMGwcHBGDx4MIDifcB1F0ShOvF5enri9OnTAIqLQubMmVOme4WSkhKGDRuGAwcOcJrt5OSEuXPnIjIyEunp6Vi1ahW77OrVq7wU8i1fvpz3i/6SqKmpISQkBCYmJhXma2tr48yZM1J7XnwU4pbWr18/9OvXr8zfFy9ezGsuUFyE/G1XDADs55hPNjY2UFdXx4ABA2Bvb1/uxaMWLVqgbdu2nGR++fJF7HtK0shrIfD9HpNm7qNHjzh/zJ8l5LkBwzAICgrC7t27kZycLHEdLosi9PX12f+uW7eu2M2O7OxsJCUloUmTJrwc00vfRFFUVEROTg6uX7+OxMREmJqaQkVFBbm5uZCXl+e9WOLcuXO4d+8ePnz4AHd3dzRo0ADXrl1DkyZNeOt2KMSMBf9lc+fOhaOjIy5evIjPnz9DRUUFRkZGYgMcuFQZutIJdd5LCPm9KCkpsV2ISzMzM+Mtc9asWbh8+TLs7e3RvHlzzrs6VmZCzlwA/H9g+IoVK/D161eEhIRg7ty5YrNG/Jvp6enh2LFj6Nu3b5ll8vLy8Pf3x8KFC7F582bOi1AuX74s8XOjo6ODHTt2wNnZGdOnT+csszRvb+8yAxyXL18u9nuudGcvLjg5OcHJyQkvX77EoUOHcPjwYba7ZMeOHSESiVBUVMRpZmlXrlxhZ84pKiqCSCTClStX8O7dO3adly9fcp77/PlzttilpDD4+fPnZdbhWp8+fRAcHIyuXbuidu3asLGxQVhYGAwNDdljaF5eHsLCwji7PlIRLS0taGlpwdPTE9evX8ehQ4dw8uRJHDhwgLPfs127dsXBgwe/u17Dhg0lXjP7FV26dGFnhZD0W9Xa2hqbNm3i/L6Vrq4urly5giFDhrB/kzQ4PDY2lvNu3wYGBtizZ89311NVVeX0d0anTp0QGRmJ4cOHS1w+YsQI1KpVC15eXpxllmjTpg0uX74MOzs7AMX3xiTNQhEfHw9tbW3O84Hiz7aVlRUCAgIwaNAg2Nra8na9wMXF5YfO78zMzDi/rt67d29s374dnz9/lnj+o6ioiPXr12PhwoW4ePEiZ7kuLi5IT0//7nr379/n/F6dg4PDD71vDA0Nyx28/09YW1tj48aN5e7rWrVqITw8HOPHj0d8fDxnuUDxYN3SnVsBlCkQBYpnLOjatSun2SXk5OTg7OyMXr16YdWqVbC3t6drcISQ/wwRw/UwD0II4UG7du2wadMmdOzYEfHx8XBxcUF8fDxq1qyJ69evw9nZGXfu3OElu3PnzvD09GR/BJYWGRkJX19fXL58mZfs/5qCggJBprf/r0tISGALIuzs7KCmpoZXr16hdu3avBYc5efnw9fXF7t27UJeXh77dwUFBQwdOhTTp0+HnJwcrl27hmrVqkFHR4e351JaVlYWFBQUeOnGN2DAAAwaNAi9evWqcN9++fIFDx484Hyqi2vXruHevXto3bo1OnfuzP49ICAAurq6MDc35zTvv2jkyJHfXYerCzqfP3+GsrIyZGRkylxYkYTPm4upqanYsmULeywJDAxEy5YtsX37drRr165MMTSXYmJiYGZmJminHb65ubnBy8sLzZo1+24HHS67mAqVW1pubi58fHzQp08fqdzEqiy2bt2KoKAguLi4YO3atXB3d4esrCyOHDmC/Px8uLm5wd7envPc0NBQZGdns0Wv169fh7u7O7KystCoUSOEhoby1i2MYRisXbsW4eHhyM7OhkgkQmRkJHR0dDBmzBi0a9eOl2mugOJj2Lhx43Dnzh3Ur18fiYmJbLaXlxeqVq3Kdp7kUnkzFmRkZPA6Y8H3nDhxQpApooXKrQyE2vasrCwoKipKtfBKyNf5v5hN2yxdv/M2P336FEFBQez5/u7du6Gjo4O1a9eiffv2vBSLGhgYYMGCBejTpw/nj/0rpLG/3dzc8PDhQ2RmZvI6c8Hp06cldpDq1KkT4uLi2FldLl68iIkTJ+LGjRu/nPmz+Njfly5dwq5du7Bo0aIKfydv2LABFy9eRHh4OCe5mzZtwqZNm3DmzJkyr2mJ5ORkuLi44MmTJ5xu8892ReVqmyW5e/cuDh8+jKNHjyIlJQXVqlVD9+7d0a9fP4kdGf8pLS2tH15XJBJxtr+1tLTKFJqU3IYt/XeGYTjNBYoLQN3d3XHv3j3Y2tqiQYMGCAkJgZKSEjsw8ObNm8jLy8P27dt/ah99j5aWFvbs2fPd3+2FhYW4cOECr4MMpCU5ORkPHjxAhw4dKrzOm5CQgLt377IzLklLXFwcGjdujBYtWkg1lw8vXrxAfHw8evXqBRUVlXLXu3r1Kq5evcrptYOsrCzk5eVJ7Mpb2p49e/DHH3+gffv2nGVL8vTpU6xcuRIvXryAn5/ff+paGSF8uXXrFl6+fAlTU1NeOk8TQkhlQpU4hJB/BSGmSS6RnZ1d7nRKampqyM7O5i37v0baBaKWlpY/NTpMmh0HpSE7Oxtz587F0aNHISMjg6KiInTt2hVqampYvXo1GjVqhBkzZvCWLy8vj1mzZmHcuHF48uQJkpOToaamhpYtW4pdpJc0jQyXEhMTkZiYCC0tLVSrVo3X40lgYCDU1NQk3ogvKChAUlISGjRogOrVq3NeIAoU70tJ+3PChAmcZ5WWnp6Ou3fvsh3S2rZtW+EFvV919OhRvH//Xmw63xKhoaFo0KABbx16lZSUyhxXMjIy8ODBAygrK0vsvvNPGRkZYffu3Wjbti06d+783eMZXzcxHzx4ACcnJ9SoUQOGhoa4evUqW/j98eNHbNu2DX5+frxkA4CFhQVvj11ZfPnyhe0+Is2upULllqaoqIioqCjY2NgIkn/t2jXs3r0bL1++lDjl+6FDh3jJjYyMxIQJE+Dg4IC1a9eiW7du0NHRwbhx4+Du7o7Xr1/zkrt37144Ozuz/16xYgX++OMPjB07FsHBwVizZg1vn2c/Pz9ERERg5syZMDIyQvfu3dlllpaW2Lt3L29FosuWLUNaWhoOHz6Mpk2bih2rjYyMeCmABoSbseC/7vHjx/jw4YPEz7RQxxo+jRw5EgsWLJDYmT85ORkLFizgtCMJIeT3c/HiRbi6ukJHRwe9e/cW+16Uk5PDzp07eSn2UVNTK7eQ7ncnrZkLVq9ejZ07d2LOnDliRUSNGjXCzp07MXToUHz9+hUHDhzgbaCQEIyMjH5oSuKSKbNLu3btGnR0dFCtWrWfznV2doaDgwNbfCuJmpoa9uzZg5SUlJ9+/IrwWfT5s9q2bYu2bduy3YIPHjyI06dPIzo6mtPrFkJdxxXyvEpBQQGbN29GZGQkIiMjsW/fPhQUFODr1684efIkGjZsiO7du8PFxQX16tUT5DnKyspWigJRhmEwe/ZsTJgw4R9P3a2mpvZDA+41NDTEzsW5yP4R3+5naeVKwjAM1q9fj8GDB0NNTe2n///NmzdH8+bNv7tex44dxa6p/2ou8OOz5wwaNEjs31xkS9KyZUuEhoaWu5yvXEJ+Z/r6+mKzLBFCyO+MikQJIf8KQkyTXEJbWxsREREwMTERa3lfVFSE8PBwtG7dmrdsITuzSStb0ujqinB5sdDKykos+8SJE8jKykKXLl3YTk7x8fGoUaOGWKECF9q3b4+wsDC0adMG+vr6390HN2/e5DQfKC5MuHz5MjuFWenX1MzMDNu2beO1SLSEiooK74WgkuzevRuBgYFITk4W61bm4eGBjh07wtHRkfNMKysrtqjvW48ePcLAgQM5fY8/ePAAGhoaqFKlCh48ePDd9bnu1sowDHx8fBAREVGmW+yIESPg6enJaV6JjRs3Suz+DABVqlTBpk2beCsSDQoKkvj3ki51PXr04Cxr+fLl7BTvy5cvF2xKlBUrVkBPTw9BQUEQiUQ4cOAAu6xdu3Y4duwY55lLly79qfVLpkvk0t9//40NGzbg5s2b7NQ8BgYGcHV15fzcoPQNPWne3BMq91v6+vq4ffs2L8XzFTl//jxcXV1hZGSE+/fvw9TUFDk5Obh58ybq1avH63fXu3fvoK2tDVlZWcjJySEjIwMAICMjg2HDhmHOnDmYOnUq57kfPnxA06ZNARQXeT948AARERHo0KEDCgsLsXDhQs4zS+zfvx9Tp07FkCFD2OLkEk2aNMGbN294y46Li8OSJUugoaFRJrt+/fr4+PEjL7lnz56Fp6enWIEoABgbG2Pq1Knw9fXltEj0R84FAPC6r4X05MkTTJ48GS9evICkSXW47uRUWVy9erXc4qKsrCxcv35dys+Ie7179/6h9bKysjjPPnny5A+td/v2bU5zf6SLPMBPYZlQ+/tHz//4GEjxvY7qJbgu6qosVq9ejR49emDVqlUoKCgQKxLV1tbG3r17ecmdMGECNm7cCAMDA0E6awtJWufehw4dwrZt2zB06FAMGDAAHh4eUFJSwvz58zFx4kT2+mvdunXh7+/PabaQx7F/qrCwECNHjmSvH/0sGRmZHyouVVRURMOGDdl/FxUVwdraGhs2bEDLli1/OvdX8JktEonYgt1FixYhNjaWXcZFkVPpffgzfjX7V363RkdHw8LC4pcGVotEIgwcOBADBw5EQUEBPn/+jKKiIigrK1dYoPyrHj16xNtj86GoqAjR0dEYPny41AsmhcoWepvXr18PCwsLqRYuCpUrZLaQ20wIIYSQyo+KRAkh/wr29vZo2rSpxGmSa9as+UPT+/5T06ZNw+jRo2FtbQ0rKyvUqVMHnz59wunTp5GSkoItW7bwkitkZzZpZnt5ebGFTYWFhdi+fTvk5eXRrVs31K5dGykpKTh9+jQKCgrg5OTESWaJOXPmsP+9efNm1K9fH5s3bxYbHZqZmYkxY8ZwPsXA6NGj2R/po0ePFqS468SJE5gxYwZMTEzKFEQ0bNgQ79694/05pKen49y5cxK7OYlEInh4ePCSu23bNvj6+mLUqFEwMjLC6NGj2WUdO3bE8ePHeSkSlVSQUCIvL4/zKe7t7OzYqZ7s7OzKfZ/xMcUVUDw12/bt2+Hi4oI///wTderUQUpKCo4dO4bNmzdDWVkZrq6unGYCwKtXr8q9eaGhoYEXL15wnvk9qqqqcHFxgY+PD2eFoqWnqRowYAAnj/lP3Lt3DwEBAZCXly9zLFFVVcWnT584zzx79uwPrysSiTgvEr1+/TpGjRoFNTU19OzZkx1YcOrUKQwZMgRbtmxBhw4dOM38Hj6OIZUld+LEiZg+fTrbcaR27dpljmcVTRP5TwUEBMDR0RHTp0+Hjo4OJk2aBB0dHbx79w7Ozs5i56Ncq1mzJr5+/QoAaNCgAf7++2+221FaWhpycnJ4yVVUVGSLei5duoRq1aqxI+lr1KiBzMxMXnKB4kIBSZ0OgeJzxIKCAt6yCwsLy71hn5GRwdtU3NKesaCic4HSSs4LuPIjA6IAlPkO4dqcOXMgKyuL4OBgNGvWTKpTrFdWt27d+u60iT9KyNdZR0dHsMEyEydO/OF1uXyOP9JFHuD+8wwIt79/5vyvfv36nGb/aJFa1apVOT0HrCzHz6dPn2LatGkAyr6PlZWVkZaWxktuz5498fjxY5ibm/M65XqJyrK/pUlOTg4uLi7o27cvfH19YWtri6lTp2LAgAE4ffo0nj9/DqC4gxvX5/xCHsd+RUXXdfjMfPfundjg298tW0FBQayj+3+xsKuwsBCzZs1CZGQkZ7PvyMnJlft7gwjzeRY6m7b5v5Et5DYTQgghpHKjIlFCyL+GUNMkGxoaYufOndiwYQMOHz6MjIwMqKiowMDAAG5ubpx33ishRGc2IbJLF376+PhAW1sbQUFBkJGRYf8+c+ZMjBs3DklJSZzlfis8PBwLFiwoM31IjRo1MGbMGCxatAhjx47lLK/0dKl8v4fL8/Xr13IvdnJdlCDJhQsXMHHiRHz9+hVVqlQpc6OezyLRiIgIjBs3DuPGjStzg6d58+acFhEmJCQgISGB/feVK1fw4cMHsXVyc3Nx5MgRtiskV8LCwtiCGyGmu9q7dy/c3d3F3u916tSBlpYW5OXlsXv3bl6KRBUVFcstTExOToacnDCnwIWFhUhOTublsa2srLB+/XpoaWmVWfbkyRO4u7vzNtVa1apVy+0U9f79e16K936mSIAPvr6+6NixIzZu3Cj2fpoxYwbGjh3LTtvIh+joaGRmZmLEiBEAil/f8ePH4+3btzAwMICfnx/nAxuEzAWAIUOGACg+T/D19ZW4Dh/d/xISEjBlyhTIyMhAJBKx340NGzbEhAkTEBAQgL59+3KeCxR3HL937x7MzMzQq1cvBAYGIiUlBXJyctizZ88PTY/5T7Rt2xYhISGQkZFBaGgoTE1N2U76r1+/hrq6Oi+5ANCsWTNcvHhR4rZdvXqV165Jbdu2RVRUlMRpD48cOYL27dvzkivtGQuEmvpSqAFR33r27Bn8/f1hamoq9FPh3caNG7Fx40YAxefUjo6OZV6DvLw8FBYWYtiwYZxkCvk6r1y5UpBcQLipbIXsIi/U/hby/E+ojuqV5fipoqJS7vWYly9f8lZEtW3bNoSEhKBOnTooLCzkvaNkZdnfJaQ5c4Gamhq8vb1x+/ZtLFu2DDt37sS8efMkzoLCFSGPY+TfgQq7+JOYmAiGYaTeTVLobEIIIYQQQv7rqEiUEPKv8vjxY4kdBwGIjTbmWps2bRAYGMjb40siRGc2obP379+PlStXihWIAsXTMQ0dOhReXl6YOXMmL9np6enldsfKzMxkp3mVlrdv3+L169do3bo1LwVWAKCpqYmTJ0/CxMSkzLLY2Fi0adOGl9wS3t7e0NXVxfLly//xFFD/1MePH9nOaN+Sl5dnu7dx4dixY+zxQyQSYfXq1RLXU1ZWxooVKzjLBcSnuJL2NM1AcUFmeYU1+vr6bPEC1wwNDRESEgJLS0uxznBfv37F5s2bed0Xkqbyzc/PR0JCAtavX8/bTbaKOnvk5OSUKUzmkomJCYKDg2FkZMROAykSiZCTk4OwsDCJRVf/dg8fPsS6devKFBzLyspi5MiRP9VV7GeFhoayRZMAsGTJEsjLy2P27NkIDw/HmjVrOJ2eWuhcQLgbyIqKiigqKoJIJIKamhpev37NdgerXr06r5+r8ePHs1Ocu7m5ISMjA4cPH0Zubi66dOmCefPm8ZI7c+ZMuLq6ws3NDQ0aNMCUKVPYZceOHSv3u5MLTk5OmDdvHuTk5GBrawsA+PDhA27fvo3w8HDOvyNLmzx5MkaOHAkHBwd0794dIpEIp0+fxsaNGxEXF4cdO3bwkivtGQuEOBcAhBsQ9S0tLS2kpqZKNVOornT6+voYPXo0O11qz549Ua9ePbF15OXloaGhAQsLC04yK8vrLG0fPnxA+/btpf491atXL0E6iAPAqFGjYGFhAQsLC84HuVUkODgYFhYWEgdF/a4qy+eqW7duCAgIQLt27dC0aVMAxef7ycnJCA0NRffu3XnJDQkJgYODA+bMmVPmOhEfKsv+BqQ7c0FhYSFevnyJ/Px8aGlpYe/evdi7dy/GjRuHrl27wtPTk7Ou06UJORsGIf913bp1A8Mw+Pvvv/9T2YQQQgghhPzXUZEoIeRf4cmTJ5g8eTJevHghcUQtH9MkC02IzmxCZ+fk5JQ7xfm7d+8kFgdzpXPnzvD19UX9+vXFbqBfuXIFq1ev5nVK2ZUrV6KwsBBz5swBAJw6dQpTpkxBQUEBVFRUEBoaykvBZkknzezsbNja2kIkEuHu3bs4fPgwoqKisGnTJs4zS3vz5g28vLykXiAKFE/de+/ePYndyu7cuYNmzZpxluXo6Ij+/fuDYRh069YNgYGB0NbWFltHXl4eampqvN5czsrKQl5entjNnYMHDyIhIQFGRka8vMcbNmyI2NhYdOnSpcyyuLg43l77KVOmYMiQIbC2tkb37t1Rt25dJCUl4cSJE8jPz8eaNWt4yQUkT+Vb8r3Vrl07LFmyhLOs3NxcZGdns4+flZWFz58/l1nn9OnTqFu3Lme53/L09MTQoUPRvXt3dOrUCSKRCH5+fnj27BlEIhEmT57MW3Zpr169wsuXL6UykKRq1arlDphISUlB1apVOc0r7d27d2yH4NTUVNy4cQMbNmyAqakpVFVV4e3t/VvlAsLdQNbS0sKLFy9gbGwMIyMjbNiwAbVq1YKcnBz8/PzQqlUr3rJbtGiBFi1aACieenHu3LmYO3cub3kl/vjjD5w5cwZpaWmoVauW2LKZM2fyOt3igAEDkJ6ejoCAAHYQgYeHB6pWrYrJkyejR48evGXr6+sjLCwMq1evhre3NxiGwYYNG6Cnp4dt27bxNnOAUDMW/FfNnz+ffR936tRJKp3FhepK17FjR/Y3jUgkwsCBA3ntBCy0nx3QWbrL/a9ycnJC9erV0bVrV1hYWMDU1LTM7BR86NSpE7p06QILCwuYm5tLdSpZXV1d7N27F8uXL0eLFi1gbm4OCwsLGBgY8FrIFxcXh4CAANStW5fNNDIykkqxbHR09E+t369fP16eh1CmTZuGe/fuoU+fPuz5z+zZs/HmzRs0b96c089Uafn5+ejWrZtUCkQrG2nNXHDv3j1MnjyZvRanrKyMBQsWYODAgbC1tUVAQAB69OgBV1dXjBw5UqzzOSHk38vd3f0/mU0I+Tm+vr6wt7fn9F5JZc8Wcpt37tyJ3r17S+X3ZGXIFTJbyG0mhBChUZEoIeRfYc6cOZCVlUVwcDCaNWtWZlpqPhUVFWHv3r04ceKExC6mJZ2GuCZkZzahsrt16wZfX19UqVIF3bp1Q40aNZCZmYlTp05hzZo16NatGy+5ALB48WK4u7vD0dERNWrUQK1atZCWlobMzExoa2tj0aJFvGWfOnVKrOvcmjVrYGZmhkmTJmHVqlXw8/PD5s2bOc81NzfHmjVrsGrVKhw6dAgAsGjRItSrVw++vr68TWVbonXr1khMTOQ1ozyDBg1CYGAgatWqxRaPFRQUIDY2FqGhoZwWtdWoUQM1atQAUDwdpZqamiBdfzw9PVG3bl32vRwYGIjAwECoqKhg06ZN8PX15bwAx8nJCQsXLkRqaipsbW3Z7ifHjx/HkSNHsHDhQk7zSmhoaCAyMhLr1q3DyZMn2an5unTpgvHjx7Pdb/ggaSpfRUVF1KtXj/PijE2bNmH9+vUAio/Rzs7O5a7L141bAFBXV0d0dDS2bduG+Ph4NGnSBJ8/f0bv3r0xatQoXgc1AMXFsR4eHrh69SqA/xflli7K4XogiYWFBXx9fVGvXj2xIuj4+HisWbMGlpaWnOaVJiMjg/z8fADFAxnk5OTYIm81NbUyhcL/9lwhOTo64u3btwCAqVOnws3Njb2hVa9ePal1mU9MTERiYiK0tLTEuiPz6dsCUaC4AznfRo0ahUGDBrHTqqqoqEBfX5/9HuWTvr4+IiIikJOTg/T0dCgrK/Na8F1CiBkLgOLCm61bt+L48eNITEyUWGB/8+ZNTrJmzZr1U+vz1TVWQ0MDenp6cHFxgYyMDBQVFcWWi0Qi3Lhxg9PMytCVrvQ5AJ/HEyFf5+3bt4v9Oz8/Hzk5OQCKz8NK3t9VqlSBgoICp+dFly9fxoULFxAbG4tly5ZhxowZaN++PSwtLWFubs7bzcWAgADExsZiw4YNmD9/Plq3bg1zc3NYWlpyPg31t6ZOnYqpU6fi/fv3iImJQUxMDCIiIlC1alWYmJiwxbIl1xK4smvXLqSmpiIuLg6xsbGYOnUqioqK0LlzZ7ZYlq+BUV5eXmL/LjnPLD2IufS5J1dFopXl+FmjRg3s2rULBw8eRHx8PGrWrAkVFRU4ODigb9++vP2+7dGjB+Li4ni/NlGisuxvQHozF8ybNw96enrYs2cPFBUVERYWhlmzZsHCwgI1atTA7NmzMXjwYCxfvhx79uzBsWPHOMmV5MiRI+Wel4hEIhw8eJC3bEL+a/i8RlSZswkhP+fAgQMIDQ2Fvr4+O4BEGtdJhMwWcptXrlwJb29v2NjYwN7eXmqzwQiVK2S2kNtMCCFCoyJRQsi/wrNnz+Dv7w9TU1OpZ/v4+GDr1q0wNDREp06dpFagKmRnNqGy58+fj5ycHMyePRuzZ8+GnJwcCgoKwDAMrK2tMX/+fF5yAaBu3bqIiorCuXPncPfuXSQnJ0NNTQ1t27bl/X2XnJyMBg0aAABev36NFy9ewMfHB61atcKIESMwc+ZM3rJtbW1ha2uLFy9eIC0tDSoqKmynOL4tXLgQnp6eUFdXh5GRkVS6OZVwdnZGYmIi5s+fjwULFgAAhg4dCgAYNmwYHBwcOMv6/PkzlJWVISMjg+rVq+Pr168VTmfPV0HdvXv32G1lGAY7duyAq6srpkyZghUrViA0NJTzItEhQ4YgPz8fQUFBOHz4MEQiERiGgaqqKubMmYPBgwdzmlda06ZNsXr1at4eX5Lc3Fw8ePAAxsbGvHYYLNGtWzc0bNgQDMNg9uzZcHd3R5MmTcTWKZlK9tvutVxTVlbGxIkTeZ1mvTw+Pj5ISUnBX3/9hWHDhrHFzwcPHsTly5d5eR94eXnh2bNncHZ2hpKSElRVVZGamoqsrCzo6uryetzW0tLCjh07UK9ePYSHh6Nz587sjfn379+jdu3av1VuiWvXrmH37t3ldostGezApdKDYtTV1bFv3z68evUKOTk5aNGiBe8F/7t370ZgYCCSk5MhEokQGRkJHR0deHh4oGPHjnB0dOQ880eKI/gsiADAduQTSknhoDQHpQlh0aJFiI6OhqWlJbp27crr9n5bqP/x40f2vLNkAEl6ejpq1apVZkp0Li1YsACHDx+GtbU1mjdvLpXX2MbGhi1eMzQ0lOr5bmnSOJ4I+Tpfu3aN/e+Srnjjxo1D9+7doaSkhKysLBw/fhzBwcFYu3Ytp9nVq1dH9+7d0b17dzAMgzt37iA2NhbR0dFYuXIlmjZtCktLS7bTJldd+ExMTGBiYoK5c+fi6dOniImJQWxsLIKDg1GnTh2YmZnB0tISRkZGZQqiudKgQQM4ODjAwcEB2dnZuHjxImJiYrBy5Up4eXlBX18f5ubmMDc35+w3pqqqKvr374/+/fujoKAAV69eRWxsLDZv3owFCxZAW1ub/czp6upykgmIv8devXqFSZMmoW/fvujevTvq1KmDlJQUHD9+HAcPHoSfnx9nuZXl+AkUfy/a2dnBzs6O15zS2rdvD39/fyQnJ4sNYi6NyxkDKtP+ltbMBW/fvoWnpyd7Lj9s2DCsW7cOKSkp7G9LDQ0NhIaG8jJAvsSaNWsQEhICHR0dNGvWTJCBtZWdEJ3JK0M2IYQQ4cTFxeHcuXPYt28f5s2bh6VLl6JHjx4YMGAA9PX1f8tsIbf5/PnzOHToEKKiojBy5Eg0btwYdnZ26N+/P68zgwiVK2S2kNtMCCFCEzGS5m0mhJBKZujQoRg8eLAgU3aZmJhg6NCh8PDwkHp2RkYG25mt5MK0kZGRVDqzCZmdkJDAFmrWrVsXurq6UitcFIKxsTHmzZsHW1tb7Ny5E35+frhy5QoA4NKlSxg3bhxu3bol8LPknr6+PgoKClBQUCC1bk7fevPmTZn3ONfdfrS1tbF79260bdsWWlpa3724znXHwxK6urrYunUrOnTogHv37mHQoEE4efIkGjdujCtXrsDd3Z2zjmHfKioqwvPnz5Geno6aNWuiefPmv+2Uge3atcOmTZukPvp0//79MDMzg6qqqlRzgeKuZKmpqRKnRX7w4AFq167N601US0tLTJkyBT169ICOjg727NmDtm3bAigeFfzx40fOC0KA4vd1TEwMbty4ITZFtLm5Oa/v7xs3bsDNzQ1ZWVmoXr06tm7dyhZBTJgwATIyMvD39/9tcoHiC3eurq4wMjLCxYsXYWpqipycHNy8eRP16tWDoaEh74WL0rZt2zb4+vpi1KhRMDIywujRoxEVFQUdHR1s374dx48f52SK0W9JOtfOyMhAYmIiatWqBXV1dezfv5/z3BKpqanYsmUL7t27hw8fPiAwMBAtW7bE9u3b0a5dO+jp6fGWff78eQQEBODvv/9mZxLQ0dHBvHnzYGhoiD59+nCS4+bmBi8vLzRr1gxubm4VrisSiRAcHMxJ7rc6deqEiRMncjow5kecO3cOCxcuxPLly9luxEDxOe+cOXOwYMEC3mYtaN++PaZNmybVbd69ezdiYmJw5coVyMrKwtjYGBYWFjAzM5PYsZcPQhxPhHydBw0ahH79+mHYsGFllv3111/Yv38/IiMjecn+1ocPH9jizcuXL0NRUREmJiZYs2YNb5mfP39GbGws4uLicOHCBeTn56NTp06wsLDAkCFDeMv91t27dxEbG4vY2Fg8fPiQt984pSUkJCA2NhYxMTG4desWatWqhQsXLnCeU/JZGjt2bJllGzduRHx8fJnutlwQ8nMlFC0trQqXi0Qi3t5bQu/vWbNmIS4uDr6+vmVmLvD09ISZmRmWL1/+yznTpk3D8+fP4ebmhipVqmD37t14/vw5jh07JtXCQGNjYzg4OGDcuHFSyyzx/v17qKmpSRw8UlBQgKSkJHZgd8kAzQkTJrB/k4bCwkLo6Oiw39/SJFQ2bfM/zy0qKsLJkycRFxeHFy9esLN+lFyPMzc3h7W1NS/XLYTM/ieuXr2KNm3aSG3GjsqQLeQ279+/H5aWllBRUflP5AqZzUduWloaDhw4gP379+PJkydo0aIF7Ozs0LdvX94HjguVLeQ2P3r0CFFRUTh8+DAyMjJgbGwMOzs7WFpa8jrgVahcIbOF3GZCCBECFYkSQv4VHj58iJkzZ2LmzJno1KmTVDuwdOzYEf7+/lKb3ooIh2EYxMXF4caNG0hPT4eKigo6dOgAU1NTXi+OT5o0CU+fPoWDgwNCQ0NhZGSEZcuWASi+kfnXX3/h6NGjnGRt3boVvXv3Rp06dbB169YK1xWJRHBycuIkV5KAgIDv7le+piC6du0aWrdujerVq5dZ9vXrVzx48ACGhoacZO3fvx/m5uaoVasW9u3b991t7t+/Pye537KwsICrqyuGDBmCwMBAREdHs51AYmNjMWPGDHa67n+7kuKeEydO4MOHDxKnquOrC8qQIUPQp08fiYUJvytXV1c0bdoUs2fPLrPM29sbL1++5K3ICQD09PSwefNmdOjQAfr6+mKdxy9duoQJEybg+vXrvOULISsrCy9fvkSTJk3EOirFxcWhSZMmaN68+W+VO2jQIBgYGGD69OliN83evXsHZ2dnuLu7o2/fvpxk/ey033x9T3Xr1g0DBgzAuHHjytwsPHfuHGbMmIHLly/zki1JQkICpk6dilmzZokVSnDpwYMHcHJyQo0aNWBoaIiDBw+y3Q5XrVqF9+/fc9qdrbTDhw/D09MTf/75J4yMjDBv3jx2f4eEhCA+Ph7btm3jJGvEiBFYuHAhNDQ0MGLEiO+uHx4ezknutywsLLBo0SKpz9TQu3dvODs7SyxI3r9/P0JDQ3H48GFess3NzbF48WJBZqfIy8tDfHw8YmJiEBcXh+TkZOjq6sLCwgIWFha8diAX4ngi5Ovctm1bBAYGSnydz507hwkTJuDOnTu8ZFckJycHFy9eRFxcHBYvXiyVzIKCAly7do0tGj1+/LhUcr+VlJTE2zTw5UlPT8f58+fRq1cvzh9bT08P69evh7GxcZllFy5cwPjx43H79m3Oc6X9udLX1//h6yB8DfB89+7dd9dp2LAh57mAsMcxoPg97OLigvv370ucuWDTpk2cFH58/foVGzZsQHx8PPLy8qCrqwsPDw+pFkACxUWiq1atkvi54lvpgb3fun//PgYOHMhLMfLIkSOxYMECiYPiX7x4gQULFiAsLIzz3BJ5eXlIT08HAKioqFTK7q3/tcIuhmGwfv16DB48GGpqav/oMZKTkzF27Fg8evQI2traaNGiBbsN6enpeP78OR4+fAhtbW1s3LjxH+dUtuz8/Hw8ePAA+fn5MDAwgIyMDL58+YI9e/bg1atXaNKkCezs7Hh5PYXKFnKby5OVlQVbW1sEBgbyOsCzsuQKmS3kNj969AjLli1jO+3LycmhZ8+emDlzJu/NC4TKFnKbP378iOnTp7PZtWrVwtChQzF27FhUqVLlt8sVMlvIbSaEEGmi6eYJIf8KGhoa0NPTg4uLi9Q7Dvbu3Rtnz56lIlEp+fr1K/bv3y9WqGlgYID+/fvzOsI1PT0dY8eOxZ07d6CsrMxOJbZp0ybo6ekhJCRE4tRmXJg9ezY8PT3h6+sLHR0dTJkyhV128OBBdOjQgbMsb29vGBgYoE6dOvD29q5wXb6LRCdMmMDbY3/PyJEjy70J8Pz5c4wcOZKzmwCliz4HDBjAyWP+E7a2tvDx8UF8fDzOnTsHFxcXdtnff/+Npk2bcpJTGQqRfXx8sHXrVhgaGqJTp05SHfFZ8nlWVVWFmZkZZ9MAStK7d2+sXr0arVq1Qu/evStcVyQS4eDBg7w8jzt37mDw4MESl3Xq1AnR0dG85JaoV68e0tLSAADNmjXD2bNn2cKQW7ducTbF6ufPn6GsrAwZGRm2G0ZF+Oy6raSkhDZt2pT5O9/do4TKTUhIwJQpUyAjIwORSITs7GwAxUUBEyZMQEBAAGdFot92/srPz0dOTg6A4mnIS4rOq1SpAgUFBd6KRD9+/FjuNFby8vL4+vUrL7nl0dDQwJgxY7BixQocOHCAl4wVK1ZAT08PQUFBEIlEYjnt2rXDsWPHeMkFgKCgIDg6OsLLywuFhYWYN28eu6ykkylXShd98lUA+iNGjRqFHTt2wNjYmLPpr3/Eq1evyj0+qqio4PXr17xljxo1ChEREejSpYvUp31XUFBgp90GigdBxsTE4MyZM/Dz80P9+vVhbm4OCwsLdO3aldNsIY4nQr7ODRs2xK5du9C1a1exAjeGYbBjxw6pFz6VqFKlCqysrGBlZSW1TDk5ORgZGcHIyAizZs3i7HErOreTk5ND7dq1oaurCyUlJQDgrED0/fv3FebWrFmTLXJSUVHhpUAUKJ7y/ujRoxKL2Y4cOcLbjWJpf65Gjx4t+BTTfBWA/gghj2MlGSXdqPmcuaBatWqYOnUqpk6dysnj/VP29vY4fPiwIEWiFfVQycvL46148urVq/jy5YvEZVlZWbwMdHz79i22bNmCuLg4JCYmstsuEonYc5FRo0ahUaNGnGenpqbi/PnzeP78OT5//gyRSAQ1NTXo6+vDyMhI4vGGq0HUQmUnJyfj4sWLbC5QfJ2gRYsWMDY2LlMkKRKJfvn35ZIlS1BQUICjR4+WO4jzxYsXmDRpEpYuXcrpbCBCZSclJWHMmDF48uQJGIZBmzZtEBISAkdHR7x69Qr16tVDZGQkwsPDERUVxen3tFDZQm7zyZMny12WnZ2NlJQUxMfHIykpCQBgY2Pzr84VMlvIbf5WZmYmDh06hMjISDx8+BBaWlqYP38+rK2tERcXh+DgYEyZMoWXbvpCZQu5zQzD4Ny5c4iKikJMTAyUlZXh7OzMZkdERODp06cICAj4LXKFzBZymwkhRChUJEoI+VdYsGABDh8+DGtrazRv3pz3gp/SP8D09PSwdu1afPr0CV26dJFYKMjHDzBLS8tyL8jLyMigRo0a0NLSgoODA+dT3wiVnZiYiBEjRuDdu3fQ0tJC7dq18eLFCxw/fhzbtm1DWFgY6tevz1lead7e3nj9+jVCQ0PFLkpfvHgRnp6e8Pb2Zrt7ck1dXb3c7gChoaGcXpB+9OiRxP/+r6noJkB2drZURwbeuHEDz58/h4GBAVq0aMFbzrRp01C9enXcv38fo0ePFpse8cGDB/jzzz85yakMhciHDh3ChAkT4OHhwfljf4+joyPy8/PZYu8qVaqIHU+5HNTQpk0btghVR0dHsJu4X79+LbfYRiQSlXvjiyvGxsaIj4+HtbU1W+R19+5dyMvL4+7duxg1ahQnOUZGRmxxeefOnb+7v/mcVvXvv//Ghg0bcPPmTXz+/Bk1a9aEgYEB3NzcoK2tzVtuUVERLl++jBcvXiAvL09sGZ8DCxQVFVFUVMTezHv9+jU7gKJ69er48OEDZ1klo8UB4N69e5g8eTLGjRuH7t27Q0lJCVlZWTh+/DiCg4Oxdu1aznK/1aBBA9y7d0/iIKU7d+6gWbNmvGWXp0aNGrwWRNy7dw8BAQGQl5dHYWGh2DJVVVV8+vSJt+w3b96UW+xctWpVZGZm8pIbGBiIgQMHQl1dvcyypKQk7Nmzh7dC5JEjRyIpKQnW1tbo0KGDxN84c+fO5Tz3jz/+QEhICAwNDcU6umdlZSEkJAR//PEH55klXr9+jSdPnsDa2hqGhoZS22ZJtLW1oa2tjXHjxiElJYXt9Dh58mTOBz8KcTwR8nWeNm0aJk2aBBsbG1hYWLCD/2JiYvD+/XtOiyGAin87lxRMGhoaYsSIEahTpw5nuRUVfcrLy0NVVRWGhoa8FFx5eXl9d50qVapg9OjRmDhxIme5Fe1roPhaha6uLiZOnCg2PTfX3NzcMH/+fLx+/RrdunVj32OnT5/GtWvXeOsUK+3PlZCDOktcunQJ79+/h52dXZll+/btQ4MGDXjrcC7kcSw3NxcDBw7EjBkzpF5cLpTJkydj2bJlGDJkCIyMjMp8R3P9WyMhIQEJCQnsv69cuVLmN0Vubi6OHDmCxo0bc5b7o27dusV5wfmdO3cwevRoqKiowMbGBhoaGux+zsjIwPPnz3Hy5EkcOHAAW7ZskTio+p8oKiqCr68vwsPDkZ+fz/5dTk4OysrKCAgIQOPGjbFs2TJ07NiRk0yhs/Pz8+Ht7Y1du3ahsLAQampqYh01k5OTISsriyFDhsDLy4vTwUsXLlzA6tWrK5zlo3nz5pg8eTI8PT05yxUy29/fH5mZmQgNDYWKigp8fX3h6uoKGRkZxMTEoHbt2khMTISTkxM2btzI6cAZobKF3OaJEydCJBKVe21dJBJh3bp17H9zdW1MqFwhs4Xc5hKXLl1CZGQkzpw5A1lZWfTs2ROLFy8WG0Bub2+P+vXrw83N7bfIFnKbX79+jaioKERHRyMpKQldunSBr68vrKys2O8KPT09tGnThtMBPkLlCpkt5DYTQojQqEiUEPKvcOLECXh5ecHBwUEqeZJuZLx//17ilN98/QCzsrLC6dOnkZWVBSMjI3ZqqUuXLkFJSQmampq4fv06Dh48iJCQEE5vggiVvWLFCgDF3TdKF8s9f/4cbm5uWLlyJec39UqcPXsWnp6eZW6iGRsbY+rUqfD19eWtSLQEwzB48eIF20G1efPmbPcVruXm5sLHxwd9+vTh7MLvj3Bzc4OXlxeaNWv23R/RIpGI0ymqb9++jVu3brH/PnToUJmb8Lm5uThz5gxvxZrTpk2DgoIC+17fuXMnFi1aBKC4w9TGjRt561osJydXbqHJ+vXrOcupDIXIeXl5aN++vSDZ0uy4U/I+AoCVK1dKJVMSDQ0NnD59WuK0rmfOnOFtCvIS06dPZztL9uvXD9WrV8fx48eRm5uLefPmYciQIZzkLF++nL1BuHz5csGKcq9fv45Ro0ZBTU0NPXv2ZAsTTp06hcGDB2PLli2cdqAukZycjBEjRuDly5diF6lL7we+ikS1tLTw4sULGBsbw8jICBs2bECtWrUgJycHPz8/3qZpXrJkCZydncUKE5SUlGBvb4/c3FwsXrwYkZGRvGQPGjQIgYGBqFWrFjsYqaCgALGxsQgNDcXkyZN5yZXUJTc/Px8JCQlYs2YNWrZsyUsuUFyMmZWVJXHZ+/fvee3Oq6amhufPn0v8Dn78+DFvnQfXr18PU1PTcotE169fz1uR6OHDh7FlyxaIRCJcunSpzCA8kUjES8Hk3Llz4eLiAjMzM3Tq1Ik9hl25cgWFhYXYvHkz55klYmJi2M5rkrpz8bXN31OnTh3Y29vD3t5erICBK0IcT4R8nbt164bIyEiEhITgzJkzSE5OhpqaGtq2bYt169ZxPpjCysqq3HOCoqIiJCUlYdeuXYiMjMTOnTvRpEkTTnIrugZRWFiI5ORkbNiwAYaGhti4cSOns3KUHlAhKTspKQmnTp1CUFAQateuzdl1nMDAwHKXlezrU6dOYcyYMdi8eTNvv6sGDRoENTU1bNiwAT4+PigoKICcnBxat26NoKAgWFpa8pIr5OdKKH5+fuUWSKampmLPnj3YtWsXL9lC7m9FRUV8/PiRs26hFRk4cCBcXV1haWn5Q3mJiYkICwtD3bp1ORuMBwCXL1/G/v378eXLF9y+fbvMcq6LRI8dO8YeU0QiEVavXi1xPWVlZbHf3b9q48aN2LhxI5vr6OhY5jskLy8PhYWFGDZsGGe5QPH1gy5dumDNmjXlNl+YNm0apk6diuXLl3P22Vq/fj127NiBqVOnwsTEBAoKCrh16xb8/f0xdOhQ2NvbIzw8HC4uLoiIiOD0GqVQ2X5+fjhw4ADmz5+PP//8EzVq1BBbnpWVhWPHjsHHxwdVqlTB9OnTOckFigeKfDugU5K8vDzOO+sLlR0fH48JEyaw9yfmzp2Lnj17wtfXF7Vr1wYA1K9fH05OTggPD+e0YFKobCG3uXXr1khKSsK0adPKFFdnZmaiX79+WLNmDdq1a8dZppC5QmYLuc0lRo0ahXbt2rHvsfJmzGrWrBnnXfyFyhZym21sbKCuro4BAwbA3t6+3K76LVq04PT7UqhcIbOF3GZCCBEaFYkSQv4VlJWVpTpy+8yZM1LLKk/Dhg3RoEEDbNq0SeyGzpcvXzB27Fi0aNECixcvxtixY7Fu3TpOi0SFyo6Pj8fixYvLFOi1aNECkyZNwoIFCzjJkSQ7O7vczi5qampsARJf/vrrLwQFBSE1NZX9W+3atTFu3DjOLwwDxTcdoqKieJ2GRJIvX76w3cH47i74rQsXLojdBJA0xaucnBw0NDR4e6/duHEDM2bMYP8dEhKCgQMHwsvLCwsXLkRgYCBvNzNLPH36FDdu3GCLkQ0MDHgt+hFC7969cfbsWd73pSRCddyZNWsWxo0bJ/G78t27dwgMDOT05lZpJd07ZWRkYGdnh7p16yIpKQn79u3D3r17sXz5cl5yS1StWlXsgp21tTWsra05zyk93dyAAQM4f/wf5evri44dO2Ljxo1iN1ZmzJiBsWPHYvXq1di5cyfnuStXrkTNmjURFxcHMzMz7NmzB3Xq1MHBgwcRHR2NkJAQzjNLODo64u3btwCAqVOnws3NDe7u7gCAevXqVVg08isePXpU7lSLjRs3xtOnT3nJBQBnZ2ckJiZi/vz57HfS0KFDAQDDhg3jbeBUeV1yGYZB/fr1OR1U8C0TExMEBweLdY8SiUTIyclBWFhYuZ0+udCrVy8EBASgRYsW7M0XkUiEJ0+eYPPmzey+51pFnc2Tk5MldrrkyurVq9G9e3csWbKEt0FJkrRv3x4nT57Etm3bcPfuXTx//hxqamoYMmQIHB0dy0y7yaWzZ8/y9tjlYRgG8fHxqF27NrS0tNi/fTv4rHr16pgyZQovM2YIcTyR9uv87XTA2travHZ7Lm3OnDnfXScrKwvDhg2Dn58f1qxZw0luRVO+l7h+/To8PDwQEBCAmTNncpILoEyxy7dq1qyJVq1a4cuXL9i1axdn77Fu3bp9d53hw4dj/PjxCAoK4vW3gIWFBSwsLFBUVITU1FSoqqryXtAn5PFz5MiR312nvNlRfsXTp08xadIkict0dHSwYcMGzjNLCLm/geIb18eOHeO1Ky5QPMhu4cKFmDdvHqysrNC+fXtoampCVVUVCgoKyMjIwNu3b/HgwQOcO3cOd+7cgaWlJefnRosWLUKbNm0wd+5cNGvWjPcZpBwdHdG/f38wDINu3bohMDCwzCACeXl5qKmpcTo4UF9fH6NHjwbDMFi/fj169uyJevXqlcnV0NCAhYUFZ7lA8eCCyZMnV7hv5eTkMGzYMLi6unKWGxUVhcmTJ4sV+TZt2hSNGjXC6NGjMWzYMEyaNAlJSUnw8/PDli1b/vXZBw4cwKxZs8q9bqCkpISBAwdCRkYGa9eu5bRI1MrKCitXroSysnK534OXLl3CqlWrOL9uIlR2SkqK2LWwkgE53w7MadGiBRITEznLFTJbyG2OiorCzp07sXLlShgZGWHmzJnszG8lM3CoqamVW3D1b8sVMlvIbQaKf7dGRERAV1cXioqKFa7bsGFDTq87C5Ut5DYDQHBwMMzMzL77u6J58+YS723923KFzBZymwkhRGhUJEoI+VcYNWoUIiIi0KVLF85HuUrC1w+rn7F9+3bMnz+/TMeP6tWrw9nZGQsXLsSYMWMwdOhQTm/4CJldWFhY7o8vRUXFMlOPcklbWxsREREwMTGBrKws+/eioiKEh4ejdevWvGXv3r0bS5YsQc+ePdGjRw/UqVMHKSkpOHr0KJYsWQJ5eXkMHDiQ81x9fX3cvn2b8+mcKlL6B5W0f1yNHz+e7calpaWFPXv2SH0UYGpqKurWrQug+IZXYmIiRo4cierVq6N///7l3gDjQl5eHjw9PXHy5EkwDAMFBQXk5eVBJBKhe/fuWLVqldjNdS7cv38fmZmZ7MXh9PR0+Pj4ICEhAV26dIGHhwcvN1PbtWsHPz8/fPr0CV26dJFYZCPtAmm+7d+/H0OHDpVYJJqWlobo6GjeikT79euHlJQUrF+/Hrt372b/XqVKFUybNk2suPJ3duPGDTx//hwGBga8dSMGim/urVu3rsz5kKysLEaOHMnptK6lXbt2DXPnzhW7Id6gQQO4ubmBYRgsXryYt45KpYsD1dXVsW/fPrx69Qo5OTlo0aIF58euEg0bNsSuXbvQtWtXsZvDDMNgx44dvHWXLDF37lw4OjoiPj4eaWlpUFFRgZGREa9TzUvqkquoqAh1dXW0a9eO1/NwT09PDB06FN27d0enTp0gEong5+eHZ8+eQSQS8dY9FSg+R3j69ClGjRrFdiwdM2YMUlNTYW5ujrFjx3KWdfjwYRw+fBhAcSGqt7d3mYKrvLw83L9/n9eu2J8/f8agQYOkUiD64cMHsQKIOnXqcHozvDI7evQoZsyYIdaNq6ioCBEREVBTU2MLNT59+gRNTU306NGDl+dRcjy5ePEiPn/+zMvxRMjXuVOnTujSpQvMzc1hYWHB6bTuXFBSUoKzs7PUO7936NABHh4e2LZtG+fXDH6EkZERIiIipJ7br18/sYF5XLC2tmYLQw0NDdnvQxkZGV7fb5Xl+KmkpFTm/CAjIwMPHjyAsrKy2PSbXBKJRGwRxLfS09M5v0ZUWfY3UFykumbNGri6usLU1BR16tQp8xpw8ZvWwcEBdnZ2OHLkCKKjoxEdHV1mvzIMAzU1NXTv3h0LFiyApqbmL+d+68OHD5g3b57UBrDWqFGDPf86c+YM1NTUePtNUVrHjh3FBiQNHDhQYkd5PqiqquLJkyfo3Llzhes9efKE06nuP336JPF1bdmyJfLy8vD+/Xu0atUKVlZWnE9/LlT2ly9fyhT/SlKvXj3OB9DPnj0bkyZNwqhRo9hZqkre65mZmXjx4gUyMjJgbGwMLy+v3yJbRUUFKSkp7L9lZWXRvn37MtcCMzMzOf+cC5Ut5DaLRCIMGzYMtra2WLNmDXr06AFnZ2eMGTOG05zKkitktpDbDBTPKjNy5EgEBQXB3NxcKplCZwu5zbm5uZg+fTp8fHx4m5mgMuUKmS3kNhNCSGVARaKEkH+F169f48mTJ7C2toahoaHEgh8+pwZkGAZxcXFi3fc6dOgAU1NT3qabTUtLK3fKzczMTGRkZAAovijwu2S3b98ewcHB6Nixo9jN8szMTGzYsIHXG+XTpk3D6NGjYW1tDSsrK9SpUwefPn3C6dOnkZKSwulI9m9t27YNI0aMKNOFxsrKCqqqqggNDeWlSHTixImYPn06ZGVlYWZmhtq1a5d5P/M5teuDBw+go6NT7vIDBw6gb9++vGQLNQ16zZo18e7dO3To0AHnz5+Hmpoae8G6sLAQRUVFvGWvWbMGcXFxWLRoEXr06AElJSVkZWXh6NGjWLFiBdauXcv5zeMVK1bAyMiILRJdvnw5Tp8+DWNjY2zZsgUyMjLw8PDgNBMAe1P4/fv3OHr0aJnlIpGowik6f5abmxu8vLzQrFkzuLm5VbiuSCRCcHAwZ9k/4tWrV7x+lgHAxcUFQ4YMwa1bt/D582fUrFkT+vr6Uik+0tLSKve7WCQSoUaNGtDS0oKjoyNnF36mTZsGBQUFtvB2586dWLRoEQBAQUEBGzdu5K17VdWqVfHp0yeJy1JSUsqdBulXZWZmsl2ylJSUxJ6Dnp4er51EvyUSiXgtlCwxbdo0TJo0CTY2NrCwsGCnGY2JicH79+/h7+/PW3ZGRgbbSX/w4MG85XxLyC656urqiI6OxrZt2xAfH48mTZrg8+fP6N27t1jxJh8UFBQQHByMy5cvixXldunShfMOXvn5+ezNYIZhkJ2dXWbAhIKCAvr27QsXFxdOs0szMzPDrVu3pNJ129zcHFpaWjA3N4elpaVgU3X9SOfFfv36cZp58OBB9OjRA7q6umWWbdiwgT0X9vHxwYEDB3grEgWKOyAPGTKEt8cX8nUOCAhAbGwsNm7ciAULFqB169bs8+BzsN/PUFdXL7fYjU+tWrVCUlKS1HOB4ptv0hjk+y0+Bpi6uLggJiYG48aNg6ysLIyNjWFhYQEzMzPUqlWL06zSKsvxMygoSOLfU1NTMW7cON6OXe3atcNff/0FGxsbiQN2uJ5etbLsbwDs1MBxcXGIi4srs5zL37RVqlSBnZ0d7OzskJubi4cPHyI5ORm5ublsoVd53fW5YmBggBcvXsDY2JjXHElKNwrIzs5Gbm5umXX4OA8tGcQsLUOHDoWvry9SU1Nha2srNtguLy8PL168wPHjx7FlyxZOr9O0bNkSBw8eLPPaHjhwAHJycuzAuypVqnCWKXS2np4eNmzYAF1d3XK7b2dlZWHDhg3Q19fnNFtJSQmhoaG4desWzp8/j+fPn7PX8evVq4cuXbrA1NQUenp6nOYKmd2qVSvcuHEDf/75J4DiARw7duwos979+/fRvHnz3yJbyG0uoaqqiqVLl2LQoEFYvHgxoqKi4O7uztu9MqFzhcwWKldBQQH16tXjtXFLZcsWcpsVFRVRtWpVsQY2v3OukNlCbjMhhFQGVCRKCPlXiImJYW+eXr9+vcxykUjEW5Foeno6xo4dizt37kBZWZktENi0aRNbFMHHVJCdOnXC6tWr0bBhQ7HiyOvXr2PNmjXsyO8XL15w3vlUqOyZM2di+PDhMDMzQ+fOndlCzUuXLkFeXp7XKYsNDQ2xc+dObNiwAYcPH0ZGRgY7Fbebm1uFxYy/6u3bt+VOI2Vubi7WeYhLJTeJfXx84OvrK3EdLgvpvuXi4oKIiAhoaGiUWbZ7924sXryYtyJRoLhIIzIyEvfu3cOHDx8wf/58NGvWDEePHoWmpqbE5/WrTE1N4evri0ePHmH//v1i2/f06VNeb7wcOXIEU6dOxaBBg9i/KSkpYdCgQcjOzsbmzZs5LxJ99uwZ230tJycHJ06cwLx582BnZ4e//voLYWFhvBSJnjlzhvPHrMiXL1/Yi0dcd4GoyI4dO9hpxUUiEaZPn16mG3NeXh7evXuH7t278/58lJSU0LVrV95zvjVjxgyEh4dDQUEBlpaWUFVVZQv5cnNz0b9/f1y9ehUeHh7w9fVFz549fznzxo0bYh2qQkJCMHDgQHh5eWHhwoUIDAzkrfDKwsICvr6+7E2WEvHx8VizZg1vI6AbNWrEFpn88ccfOHDgAPvddfr0ad4LkRMTE3H69GkkJiYiLy+vzHI+zgO7deuGyMhIhISE4MyZM0hOToaamhratm2LdevWlZmSkksmJiawsbGBnZ2dVIr4Smhra2P37t0SiyLu37+PgQMH8nJukJubCx8fH/Tp0wcTJ07krSNuedkDBw7EjBkzYGJi8t3uSr+qf//+bIflESNGYOHChbycc3yPvb09Fi1ahJycHBgZGUn8PcPV+e+xY8cQGxuLmJgYbN68GTVr1kTXrl1haWkJY2PjMrMX8KW8jkWlb65xXSR6//59zJ8//7vrGRoa4sCBA5zlPnjw4KfW5+K1FvJ1NjExgYmJCebOnYunT58iJiYGsbGxCA4ORp06dWBmZgZLS0sYGRl9d9pAvjx9+pSdUUCakpKSvjs9PF8OHDjA6+/o8ly+fBlNmzbl9DEHDx6MwYMHIy8vD/Hx8YiJiYGfnx/mzJkDXV1dtstoq1atOM2tLMfP8qiqqsLFxQU+Pj68FIpOmDABI0eORJ8+fdC/f3+oqakhKSkJ0dHRePnyJeezk1Sm/S3t37QlFBUVeSke+54pU6bAy8sL8vLy6NKli8TjFl+/NxiGQVBQEHbv3o3k5GSJ6/B1bezVq1fYt28fXr58KbE4dcOGDZxllVybCQkJwcaNGwFArEgUKJ5BysPDg9Mu+hMmTICHhweePXsGExMTyMvL4969ezh37hwcHR3ZgaUPHz7EH3/8wVmukNnz5s2Do6MjzMzM0KVLF7Ro0YJ9T2dlZeH58+eIj49H9erVsW3bNs5yS9PX1//pAtTo6GhYWFj8clMIaWdPmTKFLUatSFpaGudNGITKFnKbv9W2bVvs3bsXe/bswZo1a8AwDK95QucKmS1E7rBhw7Bt2zaYmJhI/XeUUNlCbnO/fv0QGRkpNqPS75wrZLaQ20wIIUITMdI8cyKEkH+h2bNnIyYmBr6+vmIjjy9evAhPT09YWFhg2bJlnOd+/PgR7u7uePjwIZSVlVGrVi2kpaUhIyMD2traCA4Ohrq6Ovbs2QMFBQVOb2gKmf3hwwds3boVN27cECvUdHJy+qGpev6NLC0tYWdnJ7FYbv369YiKisLZs2c5z923b993R5zyOU30nDlzcO7cOezYsUNsiuzt27dj1apVmD17NhwcHHjJfvPmDZycnJCWlobWrVvjxo0biIyMhI6ODlswwcfU3JmZmVi+fDnu37+P1q1bY968eexF6aFDh8LAwIC36ezatm2LoKAgmJiYlFl2/vx5eHh44O7du5xmtmvXDps2bULHjh0RHx8PFxcXxMfHo2bNmrh+/TqcnZ1x584dTjOFkJ2dzVv3xoqcPn2avXm4f/9+mJmZlZkWTl5eHi1atIC9vT2nXT1PnjyJzp07Q1lZGSdPnvzu+lxMhVietWvX4vnz51i3bl2ZDkMTJkxA48aNMXPmTEyZMgUvXrz4oU5y39O2bVts2bIFHTp0wNOnT9G7d28cOnQILVu2RHx8PCZNmoRr1679co4k6enpcHFxwf3796GkpARVVVWkpqYiKysLurq62LRpEy9dxlevXo3U1FQsW7YMcXFx8PDwQI0aNSAnJ4eUlBRMnz4dzs7OnOcC/5+umWEYqKqqstMzlxCJRILdSOfLjh07sG/fPty/fx8NGzbEgAEDMGDAANSvX5/XXC0tLezZs0dikeidO3fg4OCA+/fv85Ktr6+PjRs3slNwSlOnTp2wdu1azruGVmZaWlpi//72+Ml11+0SmZmZOHfuHGJjY3Hu3DlkZ2fD0NAQFhYWMDc353XAjKQujunp6bhw4QL++usv+Pr6cj6Fbps2bbBt2zZ06NBB7O8nTpwQK4K5fv06nJycOPt8VdRluzS+XmshX+fSPn/+jNjYWMTFxeHChQvIz89Hp06dYGFhwWtX1W9dv34dEyZMQN++fTmf2rUiWVlZGDZsGDQ0NLB27VrOHreic7/CwkKkpKTgzJkzuHbtGjZv3szZYIfPnz+Xu6yoqAjJyck4c+YMgoKCMGvWLN5+S5b28OFDtij53r17qF+/PszNzWFhYcH54KnK8rn61okTJzBr1izcvHmTl8e/ceMGfHx8cPfuXRQVFUFGRgZ6enqYNm0aDAwMeMkEKu/+/l2VPi8p7/uLr0LNrVu3IigoCC4uLli7di3c3d0hKyuLI0eOID8/H25ubrC3t+c89+7duxgxYgQaNGiAly9fQlNTE5mZmXj37h3q1auHJk2aICwsjPPcvLw83Lx5U6zLo7KyMlq0aIH27dtzPjU1ANy+fRsBAQF49OgRcnNz0bRpUwwbNgwDBgxgX++7d+9CQUGhzDnqvzU7IyMDO3fuLNNRs2Rfm5qaYsiQIbw0nvgnCgsL0aZNG/ba6H8l+9q1a9DR0RFk0IVQ2Xzmfv36FWlpaVBTU5N4LOErW6hcIbOllbtkyRKcOHEChYWF6NixI+rUqVPme5qv5j1CZQu5zSEhIQgPD2cHKn2bLRKJ4OTk9NvkCpkt5DYTQojQqEiUEEK+o3PnzvD09ISdnV2ZZZGRkfD19cXly5d5y4+Li8O9e/fY7lW6urpSG90kZLaQPnz4gKSkJKirq0NdXZ33vKCgIAQFBcHZ2Rm2traoXbs2UlNTcezYMYSGhsLDwwPu7u68Pw9pYxgG06ZNw+3bt7Fz506oq6tjw4YNCAgIwMKFC3kd6ezq6orU1FRs3LgRysrKaNOmDaKioqCjo4OjR49izZo1OH36NG/5QujXrx9atmwJHx+fMss8PT3x9OlTTornSuvVqxfMzc0xffp0zJo1C8+ePcPevXsBFN9MXLx4MS5evMhpZmnnzp1jO8W6u7ujQYMGuHbtGpo0acLpZ1tfXx9WVlbo3bs3TExMBJmqZNasWRg3bpxYwTWfSheSfe9GCl+FRiWMjY2xYsUKmJqalll27tw5zJw5E5cuXcKZM2cwZcoUToqhTU1NMW3aNPTt2xdbtmzB1q1bcf78eQDFRdeTJ0/GjRs3fjmnPEVFRYiJiSkzoMLc3LzMtNV8uXfvHk6fPo2cnBx06dKF1/MDa2tr6OjoYMmSJYJ1QxPKkydPEBUVhUOHDuHz588wMjKCvb09unXrVqZY9p9KTk5mu8Ta2dlh5cqVaNmypdg6ubm5iIqKwrVr136oMPyfGD16NDp37sxp56IfNW/ePADFNwOkraioCJcvX8aLFy/KdMnl86L01atXv7sO3wW7RUVFuHnzJmJjYxEbG4uEhARoaGjAwsIC06ZN4zX7W9u3b8f58+exefNmTh/XyMgI8+fPZ6eCLM+xY8ewePFiXLp0iZPcH3l9S+Pzta4sr3NBQQGuXbvGFo0eP36ck8ft3bt3ucuKioqQkpKCjIwMGBgYICQkhLMbxEuXLi13WUmh5tWrVyErK4tdu3ahSZMmnOQCZYvMvyUjIwNdXV1MmDBB4gC1X8n9XvGzvLw8Ro0ahSlTpnCW+6NSUlLY91d8fDzv54LS/FxJ6k6cn5+PhIQErF+/Hk2aNOGtG16JnJwcpKenQ1lZWeoD9KS1v/X19X946liRSMTre0zahBzE3LNnTwwePBgODg7Q0dFhrw0VFRXB3d0dmpqamDp1Kue5I0aMQMOGDbFs2TKx3Js3b2LatGlYvHixIDN1kP+mwsJCsffhfyH7v1gYS9tM2/yzvjdbEZ+DtoXKFnKbhbrGLuS1/f/iNhNCiNBounlCyL/Gx48fsW3bNty8eROfP39GzZo1YWBgAEdHR14L+bKzs1GnTh2Jy9TU1JCdnc1bNgCYmZkJVpgpVHZmZiYeP36M5ORk1K1bF61atZJKUcju3bsRHByMjx8/sl116tatC3d3d147zbi7uyMjIwOhoaEICQlh/y4rK4sRI0bwViBqZWWF9evXS/xB9OTJE7i7u/PamU0kEsHHxwfjx4+Ho6MjzM3NER4ejpUrV1Z4s5ULV69exerVq6GqqspOE15CTU2t3CnGuJKeno6nT58iMTERpqamUFFRQW5uLuTl5Xkr8Bo3bhwmTZqEd+/ewcbGBnXq1MGnT59w4sQJ3L59G/7+/pxnOjk5Ye7cuYiMjER6ejpWrVrFLrt69Srn3bpKpKamYty4cbhz5w7q16+PxMREDBkyBA0aNEBUVBSqVq2KBQsWcJY3ePBgHDt2DIcPH0atWrXw559/olevXmjfvj1nGd/DR+fbipw5cwZqamrsfwspOzsbiYmJEpe9f/+enbavWrVqnBXVmZqawtfXF48ePcL+/fvRt29fdtnTp0957ywkIyMDKysrWFlZ8ZpT2vv376GmpsbuQ11dXejq6gIoLhJ4//49GjRowEt2amoqBg8e/J8rEAWAVq1aYdasWfD09ERMTAxCQ0MxdepUKCsro0+fPnBwcECzZs1+KWP37t0IDAyESCSCSCTCrFmzyqzDMAxkZWU5PXZ+a+LEiZg+fTpkZWVhZmaG2rVrlykW4Gua0fbt22PNmjVwdXWFqampxE4RfHRETk5OxvDhw/Hq1SuIRCJ2urjS2VwWid64cQPt27eHSCQSpGPrt2RkZNChQwd06NAB06dPx5s3bxATE4O4uDipP5eWLVvCz8+P88fV1dXFsWPHfqhIVFIH33+qMry+JSrL6ywnJwcjIyMYGRlJPM79Uzo6OuUWNsnKykJVVRWGhoYwMTH54eKvH1HRTBNycnJQVVXFoEGDMHLkSPacjSsVnfvJycmhZs2avEzNuHz58u/u63bt2gl2vlCnTh3Y29vD3t4e+fn5vGZJ+3NlZ2dXZt+XfGe1a9dOKoMsqlSpgipVqvCeI4m09vfo0aM5PU5Udh8+fGBnDBowYIBgz+Pdu3fQ1taGrKws5OTk2I6PMjIyGDZsGObMmcNLkejjx48xduxY9hpQye/W9u3bY/z48Vi9ejUViRLCMyF7KAmVTdv838jmKpeP2e0qe7aQ2/zo0aP/VK6Q2UJuMyGECI2KRAkh/wpPnjzB8OHDkZ+fD2NjY2hpaeHTp0/YtWsXoqKiEBERUabjEVe0tbURERFRpjtcUVERwsPD0bp1a86yPn/+DGVlZcjIyFQ4lVoJLm+UC5ldoqioCH5+fggPDxcrvq1atSqGDx+OyZMn89ahb+PGjVi7di369u2L7t27o06dOkhJScHx48exaNEipKenw9XVlZdskUgELy8vuLq64u7du0hPT4eKigratm2LWrVq8ZIJFF8I/7ZjVYmcnBx8+PCBt+wSsrKy8Pf3h5ubG/766y+sXbuW12mpS+eWd7EkJSWFt6l+GIbB2rVr2fe4SCRCZGQkVFRUMH78eLRr1w7jx4/nJdvGxgaBgYFYv349vL292UJobW1tBAYGfneU7D9hb2+Ppk2b4t69e2jdujU6d+7MLqtZsyZGjhzJeSYALFu2DGlpaTh8+DCaNm2KNm3asMuMjIwQHBzMaZ6XlxdmzpyJq1ev4siRIzhy5Ah27tyJ+vXro3fv3ujVqxdv31GlZWRk4MSJExK70QHcToXTsGFDAMU3sk6ePAljY2O0atWKs8f/GZaWlli9ejWqVasGCwsLKCkpISsrC2fOnMHq1avRrVs3AMU34Zo2bcpJ5syZM1FYWIgLFy7AzMwMEyZMYJedOnVKKjfzLl68iDt37rDdvvX09HidKtvKygq7d++WWMT0+PFjDBw4kLcR1l27dsXt27c5m67236aoqAjnz5/HgQMHcP/+fdSpUwcWFhY4e/Ysdu7cifnz52PQoEH/+PH79++Pjh07gmEYODo6Yv78+fjjjz/E1pGXl0ezZs14PS8pGZDj4+MDX19fievw9R4rKRiLi4uTWPDBVweBlStXolatWggLC4OZmRn27NmDOnXq4ODBg4iOjhYbPMQFJycnVK9eHV27doWlpSW6du0KJSUlTjN+RePGjTFy5Ejezg/Kk52djT179qBu3bqcP7aDgwNcXV2xfv16uLu7lxkMxDAMgoODcerUKWzYsIHz/NISEhLYDut2dnZQU1PDq1evULt2bam+D/h+nSsqAJWRkUGNGjWgra0NGxsbTroRrly58pcf458Q8uZlyXmgtAlZRFZaYGBguctKv8c6dOggtefE9+dK0pTXioqKqFevHueDtn18fDBq1KhyB2tLEhMTg/z8fKlcSwD429+lf1P8F5ibm0NLSwvm5uawtLTkdLDEz6hZsya+fv0KAGjQoAH+/vtv9ndHWloacnJyeMkViUSQl5eHSCRC7dq18f79e3agab169fDy5Utecr/HxsYGRUVFUp9d58CBA2AYBv369ZNqrpDZQm4zIYQQQggh5L+JikQJIf8K3t7eaNy4MbZs2QIVFRX27+np6Rg9ejS8vb05nxqwxLRp0zB69GhYW1vDysqK7b53+vRppKSkYMuWLZxlGRkZsQUYnTt3/m4HAS5vVguZXWLVqlWIiIjA2LFjyxRqbtq0Cfn5+fDy8uI8FwDCw8Ph7OwMT09Psb9bWlqidu3aCA8P561ItEStWrV479yam5uL7OxstkAyKyurTFFwbm4uTp8+zcuN8vI6hObk5EBBQQEBAQEICAgAUHzB/ODBg5w/BwAwNDTE1q1bYWpqyt6sL+ngtWfPHt4Kkfz8/BAREYGZM2fCyMgI3bt3Z5dZWlpi7969vBWJAmA7D379+hWZmZmoUaMGbwWxJQwNDWFoaFjm73zeAIuLi8OSJUugoaFRplNs/fr18fHjR84zRSIROnXqhE6dOmH+/Pk4f/48Dh8+jLCwMISEhKBVq1bo06cPevbsyXZL4dLLly8xZMgQ5OXlITs7G6qqqkhPT0dBQQFUVFSgpKTEaZFoCUVFRfj5+Ul9yqbSFi5cCC8vL3h6ekIkEkFOTg4FBQVgGAbW1taYP38+gOIbflx1gKlRo0a53Vt37tzJSUZ5kpOTMWHCBNy+fRsqKiqoXbs2Pn36hHXr1kFPTw8BAQGcdwwDKu5CkJeXBwUFBc4zSyxatAhTpkxBTk4OOnfuDGVl5TLrCPke5MvLly8RFRWF6OhopKamomvXrvD394e5uTk72MHX1xf+/v6/VCTasGFDtuAnLCwMrVu3FqRwsKIOcXwTqiPytWvXMHfuXLHPbIMGDeDm5gaGYbB48WJOf+NcvnwZFy5cQGxsLJYuXYr09HS0b98elpaWMDc3/+WutD+iooKa0sVVdnZ2nBceSToPzc/Px8ePH5GTkwNvb29O84DimRnGjh2LgIAA7N69G507d0b9+vUBFM+UcenSJSQlJWHMmDG8/Q7Izs7G3LlzcfToUcjIyKCoqAhdu3aFmpoaVq9ejUaNGmHGjBmcZgr5Oj98+BBJSUlITU0V+55MT0+HqqoqqlatirCwMPj5+WH79u2cTsP+X5GWlvaPBg2UzAjzb7d9+3bk5+ezhWOKiopsB8AqVaqgoKAABQUF0NHRwaZNm6CqqspJrpCfK2l2J37z5g2srKxgYmKC7t27o3379mW69Ofk5ODvv//GuXPncOzYMeTk5HBesC3k/v6vOHbsGGJjYxETE4PNmzejZs2a7EAWY2Nj3q9VlGjfvj3u3bsHMzMz9OrVC4GBgUhJSYGcnByv14c0NDTw5s0bdO7cGXp6etiyZQtatWoFOTk5hISEoHHjxrzkfk/9+vVRVFQk9dzZs2ejqKhIkIJJobKF3GZCCPlRQs3wKGS2kNv89etX7N+/Hzdu3GCbyRgYGKB///68nhsJlStktpDbTAghQqIiUULIv8LNmzfh4+MjViAKACoqKnB3dy9T2MclQ0ND7Ny5Exs2bMDhw4eRkZHBniy6ublxWpSwfPly9iKgtG+UC5ldYv/+/Zg4cSLGjh3L/q127drQ1NRElSpVsGXLFt6KRL98+VJuBzYTExPs2rWLl9wS6enpOHfuHD58+MDeYCohEong4eHBSc6mTZuwfv169nGdnZ3LXZePYsWKpmOUpunTp2Po0KHo2bMnLC0tIRKJ8Ndff+Hp06d49eoV9u7dy0vu/v37MXXqVAwZMqRM8WKTJk3w5s0bXnKB4q5K48aNQ+PGjVGtWjWxH7rv3r1DYGAgL1OWFxYW4s6dO/jw4YPE7pZ8XAwvLCws94d8RkYGZ1OOl0dOTg4WFhawsLBATk4Ozp49i4MHD2L16tVYs2YNHjx4wHnmypUr0a5dO/j7+0NPTw8hISHQ0tLC0aNHsXbtWvj7+3OeWUJbWxvPnj0TbGpbJSUlBAYGIiEhAXfv3kVycjLq1q2LNm3aiHVDlFZnIb4tWLAAb9++xbZt28S68166dAmenp5YuHAhe5z/VQkJCUhISGD/feXKlTJdpnNzc3HkyBFeb2J++fIF2dnZ2LhxY5nOiiVdkbkevFJQUIDHjx+jfv36nBV3/IyhQ4fi9u3bqF+/PoYMGQJ7e/syF6JFIhG6d++O0NBQznKFnKJayA5xQnXFy8zMhKqqKmRkZKCkpIRPnz6xy0qO5VyqXr06unfvju7du4NhGNy5cwexsbGIjo7GypUr0bRpU1haWsLCwgIGBga8dPCvUaMGHjx4gOTkZGhqarIFfI8fP4aamhqaNGmCrVu3IjQ0FGFhYZz+1pJ0HqqgoIB69erBxsYGGhoanGWVNnXqVLRv3x5bt27F8ePH2fMhBQUFtG/fHosXL+Z1oJi3tzcuX76MTZs2oUOHDtDT02OXmZmZYdu2bZwXiQr5Os+YMQMLFy5EQEAADAwM2L9fv34ds2fPxpw5c9C0aVO4urrCx8eHHaD2TwnV9TAuLu6n3zepqalITEz85f1tZWUFOzs72NnZQUtLq8J1v379ilOnTiEsLAzdunWDu7v7P84dOHAgXF1dYWlpWaYrrySJiYkICwtD3bp1MWrUqH+c+63t27fjf+ydeVwN+//HX6eVK52opCy3hDZL2ihLWsiVkOLKloqo7CqhZI0oRIqoCBEinFJEsmRJ2fclW5K0R3v9/ujR/Eony9d8zuDO85+rZu55zed0Zs5n5vN6v97z58+Hi4sLTExM0KpVK3z69AlnzpxBUFAQfH19UVZWBjc3N6xfv54286Kgz6t379790P4KCgo/pVfPli1bcP/+fezduxfe3t4oKyvDX3/9hTZt2kBMTAxFRUXIz89HTU0NunXrhsmTJ2Ps2LEQFxenRb8eJq9jTJOdnY3s7Owmz6YA8C0A/V9RUlKCkpIS7OzsUFxcjAsXLuD8+fPw9PREaWkpdHV1YWRkhMGDBzcxCtPJrFmzqELSmTNnoqioCDweD+Xl5TAwMICXlxcR3XHjxlHn2YIFC2Bvb49Ro0YBqOuotGXLFiK632LPnj2M6O7evZuxtsxMaTM5ZhYWFpbvgckOj0xpMznmrKwsTJ48GZmZmVBVVYW0tDQyMjIQHx+P3bt3IyIigio6/RN0mdRmcswsLCwsTMOaRFlYWH4LhIWFm22LXVFRQawFeT09evT4aksxurC0tKT+LeiFcia166murm72wbqGhkYTUx2dDBgwACkpKejfv3+TbZcvXyba4vbSpUuYM2cOPn/+jBYtWjQxsNFpEjU1NUWHDh1QW1uLJUuWwMnJqUl6jqioKJSVlaGmpkaLZkOYasf4JcrKyoiOjkZgYCB4PB6EhYVx/vx56Ovrw8/Pj1iiUEFBQbMGhOrqalRVVRHRBeoMqjY2NnyNXPn5+YiJiaHdJHr//n3Mnj0bWVlZfB98czgcIibRXr16ITo6mu/CeWxsLNXCTRC8fv0ajx8/xtOnT1FTU0MsPenOnTtYs2YNleZYWVkJYWFhWFhYID8/H6tXryZmdl+yZAnc3NzQtm1bGBoa0tK69X9BWVmZmMHnS8rKyhAUFISEhIRmDdCk2mKnpKRg+fLljQyiQF0iuKurK5YvX06b1qlTp6j5D4fDgb+/P9/9JCUliZjM61m0aBGysrLg5eUFRUVF4kZvoC4h6t9//0VISEizRSQkkZWVRUhICAYMGPDV4go1NTXaUzBjYmIQFRWFly9f8jUHpKen06r3K/A1I0y9gZNEumrHjh3x4cMHAEDXrl1x/PhxGBkZAQASExOJJu5xOBxoampCU1MT8+bNw/v375GUlITz588jMjIS4uLiGDBgADZu3Eir7rBhw/D69Wvs37+/kTn37du3cHJygqWlJbZu3Qo7Ozts3LiRVhM0k/PQwYMHY/DgwaiurqZS/KWkpIjfxwJAQkIC3N3dMWDAgCb3Ux06dEBmZibtmkz+nX19fTFr1qxGBlEA0NHRgbOzMzZs2AAejwdHR0da0mOZSj309vYGl8uFlZUVzMzMmk20qa6uxvXr18Hj8RAXF4clS5b8tJntwIEDCAgIgKWlJTp37ow+ffpARUWFMvEVFxfj7du3uH//PtLT09G6dWtMnz4d48eP/ynd0aNHY/ny5fDy8oKJiQm0tLSgoqKCtm3bUubBet0LFy7g9u3bMDY2ho2NzU/pfsnKlSthZ2eHkSNHUr9r1aoVRo8ejdLSUvj4+ODw4cNwcnKirXAHEPx5VV9M+b3QOffV0NDAunXr4O3tjZs3b+LevXv48OEDKioqwOVyoaSkBC0tLaIJ2Exex5jizZs3cHNzw+3btwE07SRAojCrntatW8Pc3Bzm5uaoqalBeno6zp8/j4MHD2LNmjVQVlaGkZERFi5cSLt2ly5d0KVLFwB1BRyenp5EunB8ScNnIcrKyoiLi8OtW7dQVlYGTU1NSEtLEz+GXwk6Dci/izaTY2ZhYWH5Hpjs8MiUNpNjrn+2GhsbS81NAODFixeYOXMm1q1bRyQIgildJrWZHDMLCwsL07AmURYWlt8CAwMDbN68GWpqalBSUqJ+//LlSwQEBBBdvC8pKcHnz5/5tt7+8OEDWrVqhVatWtGua2Jigm3btvFN5njy5AmcnJyItcZkStvMzAyxsbF8jZqxsbEYMmQIrXoN0/ysra3h7e2NvLw8mJiYUCkRiYmJuHr1KlasWEGrdkN8fX3Rs2dP+Pj4EE+yUlVVpf6uHA4HhoaGjCSkfUlZWRmKioogKSmJFi1aCESzU6dORNqKfg1FRcVmTcfXr18nVoX6LV69ekXEiLJ8+XJISEhgz5496Nq1q0CMXQAwb948TJkyBRMnToSZmRk4HA4SExOxY8cOJCcnIzIykqj+27dvERsbCx6Ph2fPnqFFixYwNjaGl5cXBgwYQESzoqICEhISEBISApfLpUxHANCtWzc8evSIiC4A2NraorKyEvPnzwdQ12az4YIyh8NBWloaMX2gzhR75MgR3L17F+/fv8eyZcugqKiIuLg4qKio0G4eXbFiBXg8HkaMGAFlZWWBfbaBOkPml8nqDbe1bt2aNi1bW1tYWlqitrYWpqamCAwMbFJAICoqCllZWaIp0Xfu3IG/vz9MTU2JaXyJkJAQOnbsiMLCQoFpNuR7k4NERUVpnTscP34cXl5esLS0xM2bN2FlZYWamhqcO3cOkpKSVLoRCb5mRqlv66qqqoqJEyfSntb1PUaYDh06wNbWFpMnT6ZNd/Dgwbh8+TKGDx8OJycnuLi4QF9fHyIiIvj48SNcXV1p0/oW7du3h42NDWxsbFBWVobLly8jOTmZdp3AwEAsXLiwyee2Y8eOcHFxgb+/PywtLWFvbw9vb2/a9ZlGWFhY4KaPz58/Q1ZWlu+20tJSIppM/p0zMjIgKSnJdxuXy8Xr168B1KX417cL/xmYSj08ffo0IiMjsWfPHqxduxby8vLo3r07ZZisN2o+fvwYVVVVMDY2xoEDB76Z/Pk9qKioICgoCG/evEFMTAyuXLmCuLi4RkUzCgoK6NOnDzZs2AAjIyOIiPz8I+iJEyfCysoKsbGxiImJQUxMTBPjc21tLWRlZWFmZgZvb2+oqKj8tO6XPHjwAM7Ozny3dejQAU+ePAFQNwcvLi6mTVfQ51XDQunPnz/D398fnTt3xtChQyEtLY2PHz/i9OnTePPmDbHvq5YtW8LAwICRgp3/4veVp6cnsrOz4ePjA2VlZaoAUdAICQlBR0cHOjo6cHV1xZs3b5CUlETrvKSmpgbnz59Hp06dmn0O8/TpU7x58wZGRkYC6YjTqlUrvs9DBU1eXh6eP39OzMBYUVFB3WNxuVyBfs6Y1P7VERISwqxZs/iuf/zJ2iwsLF+HyQ6PTGkzOeaUlBSsXLmykWkRqCtomTt3LrE5J1O6TGozOWYWFhYWpmFNoiwsLL8FHh4emDRpEszNzdGtWzfIyMggNzcXT548gby8PBYvXkxM29PTE61atcKaNWuabNu6dSv1sJxuMjMzm01PLSsra9Lu9XfVPn36NPVvXV1dbNq0CZMnT4apqWkjo+br168pAxJdWFlZNXrQW1tbi2PHjuHYsWPgcDiNUhNmzpxJLDHhzZs38PDwEHir04bpsUyRlJSEwMBAPHz4kGoZrKamhjlz5hBtu9mQ9+/f48OHD5CTk2s2gYcupk6dCi8vL4iIiGDYsGGU/q1bt7B3717ak/giIyNx4MABAHVGPVdX1yYL0hUVFcjMzISZmRmt2gDw7NkzbN68WeDti/v06YOIiAj4+/vD19cXtbW12L59OzQ1NbF7924irQBzc3MRFxeH2NhY3L59G8LCwujfvz8cHR1hampKPF1TUVERmZmZ0NXVhbq6OiIjI2FgYAARERFERUURfdhub28vkEWz5njz5g2mTp2K/Px8qKurIy0tDZ8+fQIApKam4uLFi7SfW0lJSVi0aBEmTZpE6+t+D7a2tggJCYGenl6jIpWSkhLs3LkTU6ZMoU2rdevWlOn07NmzaNeunUANsfX8/fffRJOWm2PmzJkICgqClpYW8e+HX4Xw8HA4OzvD0dERhw4dwoQJE6ChoYGSkhI4ODgQKYyqx8TEBImJiSgpKYG+vj7atm2LvLw8XLlyBRISElBRUcGNGzdw4sQJ2hNeN2zYgI0bN0JRUREmJiaU9pkzZ/Dq1StMnz4dt27doq4ldBlFG6ZhGRoa4sCBA0hMTERZWRkMDAwENhf6khYtWsDExAQmJia0v3ZWVlaz3xkcDodq99quXTtaugjMnDnzu/flcDgIDg7+ac2GMNWKvCEqKio4ffo030KV8+fPo0ePHrToNETQf+eGdOnSBaGhoejbt2+j+dfnz58RGhqKrl27Aqgr+PyRv8vXYCL1UExMDFOnTsXUqVNx7do1XLlyBXfv3sW9e/dQXl4OKSkpKCkpwcrKiiqCpJtOnTph9uzZmD17NoC6dJ16bVLGmxYtWlCt7svLy/Hw4UPk5OSgvLyceq9JtqUG6gywR44cwaBBg5psO3ToENV2vaCgAG3atKFNV9DnVcPiHE9PTxgYGDSZU0+ZMgWLFy9GSkoKLCwsflrzV4LJ6xhT3LlzB76+vrR9/9BFp06dMGXKFFrvc44ePYp169aBx+M1u0/r1q3h7u4OT09P2jqg3Lt3Dw4ODli/fn2z87zk5GS4u7tjz549tBj7f5TU1FTMmzeP1megb9++RVhYGJKTkxt1muFwOJCXl8fgwYNhZ2dH5PrNpPa3SE1NxdatWxEREUHk9e/du4fi4mKqUL2wsBAbNmzA8+fPYWBgABcXFwgJCQGoez9mzZr122u/e/cOsrKyfJ9bVFVV4cOHD9T3tJCQECwtLWn7rmZKmx2z4HSZ1GZKl8kOj0xpMznm6urqZosJxcXFic05mdJlUpvJMbOwsLAwDWsSZWFh+S1QUFDAyZMnER0djbS0NBQVFUFRURFWVlYYM2YM0QXrGzduNFs1ZGhoSGvCZHl5OUpLS6kHViUlJVQ7wob7JCYm0m74YUp7zpw5TX6XnZ2N1NTUJr9fvHgxra2pST2E+1HU1dWRlZUlcF0m2yUDdW1UZ8+ejd69e8PDwwMyMjLIyclBfHw8nJycsGXLFqKpcVFRUQgODkZ2djZlUG3Xrh2cnJx+uhVic4wZMwaFhYXYunUrduzYAQBwcXFBy5YtMW/ePAwfPpxWvXbt2lEL/0+fPoWSklKT5FhRUVF06dIF1tbWtGoDdcbFerOeoOnTpw/27duHsrIyFBYWQlJSkphR097eHtevX0d1dTX69OkDLy8v/PPPP7QuCn8Lc3NzKi107ty5cHBwgJ6eHmV4J9lit94YwBSrV69G27ZtcfjwYUhKSjYyu+jq6tLeKhmoe2BIsr3ll6xevbrRz5mZmTA0NETfvn2pgopr166hVatW1II1CV68eEElclVUVCA0NJRa5BkzZgwx3cWLF8PX1xfdunWjPRX2a8THxyM/Px+mpqZQUVFpYiYiYShjmlevXkFLSwvCwsIQFhZGSUkJAEBCQgLTp0+Hj48P7OzsiGh36NABCgoK2LlzJ/766y/q958+fYKjoyO6dOmClStXwtHREVu2bKHVJHrjxg0MHDgQK1eubPT7SZMmwcvLC/fv38eGDRsgISGByMhIWtNEG9KzZ0/07NmT+jk1NZVYitP3JLeqqalRRmG66NmzJ7Zs2YIePXpAXl6e+n1mZia2bt2KXr16UT/TYc5mah5SD1OtyBvi7OwMZ2dnlJaWYtiwYeBwOLhz5w54PB6io6Oxc+dO2rTqEfTfuSGenp6YPn069T3Zpk0b5Ofn4+rVq6iqqqJaAz5+/Jj2IimmUg/79u2Lvn37ClSTH80lnZNCXFwcmpqaAtUE6gz+8+bNg5mZGYyMjKjCgqSkJLx9+5ZqS3jlyhVar+FMnlfx8fHNtls0NzfH/PnzaS/KYhom32+mkJOTo0xbguZrBtCG8xIrKyta3u/jx49j/PjxaN++fbP7tG/fHhMmTEB0dDRtzyL37NmDPn36fLUQyNDQENra2ggPDxd49xsS3L59G/b29uByuRg6dCiUlZWpxO+ioiK8ePECp0+fxvHjxxEWFkadW7+79veQl5fH9/k3Xaxduxb6+vqUUdPHxweJiYno378/wsLCICQkBBcXlz9K28TEBFFRUXz/lo8ePcLYsWOpZ90cDofW7y6mtNkxC06XSW2mdJns8MiUNpNj1tLSQnBwMPT09Bp1iiouLsb27duhpaX1R+kyqc3kmFlYWFiYhjWJsrCw/Da0atWK9srx76GwsLBZE2rLli2bGCl/hp07d2Lbtm0A6m7mHBwcmt2XzupeJrVJtK3/XgSdbtgcy5cvh5ubG+Tk5KgWo4KAyXbJQF37NnNzc/j5+TX6va2tLVxdXREYGEjMJLpjxw5s2rQJo0aNgpmZGWRkZPDx40fEx8djxYoVKCwsxIwZM4ho29nZYdy4cUhPT0dBQQG4XC769OlDa4voekxNTRu9h87OzujUqRPtOs2xePFirFmzhki77++lRYsWaNGiBVGNnJwczJkzByNGjKCqtgVNQ9OWpqYmeDweLly4gPLycvTr1w/du3dn5LgEwfXr1+Hv74+2bds2qfKVlZVFTk4O7Zo2NjY4fvw431Q2Epw7d67RzyIiIpCUlGxk5K9f7EpKSoKnpyftx+Dl5QVVVVW4u7sDqEvHO3DgALp37474+HiUlpZi4sSJtOsCdQtKOTk5sLCwQLt27ZpcLzkcDk6cOEG77qdPnxo9EGbabCYIJCQkqKIROTk5PHv2jDIeVVdXIz8/n5j2nj17sGzZskYGUaDuHsDBwQHLly/H9OnTYWNjg0WLFtGqHRcXh82bN/PdNmzYMMybNw8+Pj4YPHgwjhw5Qqs2PxITE7Fr1y7cvn2bWMHO9yS3pqam4vjx47Qmt65YsQJ2dnYYMmQIunfvThn4Hj9+DGlpacqE9PHjR4wbN+6n9fbu3fvTr/EzMNWKvCGDBw/Gxo0bsX79epw8eRJA3d+hffv28PPzoxbv6UTQf+eG6Ojo4PTp0wgPD8e9e/fw7NkzyMrKYty4cZg6dSpkZWUBAAsWLKBVl+W/w5AhQ3D48GHs2LEDZ86cQU5ODmRlZdGzZ09qQRkA7S0KmTyvhIWF8eDBA76tsB88eMCYsZAkTL7fTDF//nzs3LkTOjo6kJKSEqh269atcf/+feTk5EBFRYUqhHv8+DFkZWXRuXNnhIeHIzQ0FBERET9dwPLgwYPveuajp6eHyMjIn9JqyPXr179rHjtixAjaDaLfm/ZL9z3P2rVrYWBggI0bNzb73HHhwoVYsGABfHx8cPDgwd9eu2HXrK9x69YtWvSa49mzZ3B0dARQV5SUkJAALy8vWFlZYf/+/YiIiCBmEmVKu2FXsC+pqKgglnTOpDY7ZsHpMqnNlC6THR6Z0mZyzPVdqwwNDdGvXz9K+8qVKxAVFYWPj88fpcukNpNjZmFhYWEa1iTKwsLyW6CmptZspdy9e/caVcrRTadOnZCSksJ3YfTKlSu0tgg3NTVFhw4dUFtbiyVLlsDJyQmdO3dutI+oqCiUlZWphYffXVvQLdZ/Ffr06dMovamyshKOjo4QEhJqsijM4XCQlpZG+zEw2S4ZqEukc3V15btt1KhRxB5UAnWGAQcHB7i5uTX6vbGxMaSlpbF3715iJlGgzvAycOBAYq/PDyaSXVatWiUwY9fq1athb28PBQWFJqmL/KDTRFdvuPiVkJeXx7///iswvVevXuHo0aN4+fIlysvLm2zfvn07MW1hYeFmH5Z+/PixieGMDlq0aIG0tDSMHz8e+vr6lEGzHg6Hg6lTp9Km96VJlAkePnxIfV9UVVUhJiYGrq6umDp1KrZv346DBw8SM4lqaGg0m3hIEqbNZUzQo0cPPH78GAMHDoSxsTG2bduG2tpaiIiIICQkhGhiW35+PpVc+iXFxcUoKioCQCapTkhICI8ePeJrfnn48CFlfhEWFv7pwoOamhqEhobi6NGjyMrKQseOHTFr1iwMGzYMly5dgq+vL549e4YOHTo0STalE6aSW7t27YrExEQcOXIE9+7do8wg1tbWsLKyoubB06dPp0XvV4CJVuRfMmzYMAwbNgwZGRnIz88Hl8slWsDD9N9ZVlaWKmpgYSGBurp6s8mapGDyvBo5ciS2bNmC8vJymJqaUoUFZ86cQUhICLFOHEzC9HWMCY4dO4b379/D2NgYampqfO/fSaXoDxs2DK9fv8b+/fsbPSd8+/YtnJycYGlpia1bt8LOzg4bN25EaGjoT+lVVlZ+l6FGTEys2Zaz/wu5ubnf1Z2pXbt2yM3NpU0XqHsG17VrV6irq391v8zMTFq7HT18+BDz5s37amG6iIgIJkyYQPtzOKa058yZQ3V1+RYk73PLysqojjrp6emoqKiAiYkJAEBFRQXv37//I7SfP3+O58+fUz9fu3atyeuXl5cjNjaW9sJ5prTZMbNjJqnbECY7PDKlzeSYu3fvjhMnTiA8PBxpaWl49uwZuFwuVfD4tQT031GXSW0mx8zCwsLCNKxJlIWF5bfgaw9VqqurISwsTEx77Nix8Pf3B5fLhZWVFfUw/OjRo9i9ezetCSSqqqpQVVUFUPeQyNDQsElraFIwpV1QUABJSUkICQl9VyornWkGWlpaiIiIQI8ePZqYNvmRnp5Om7a9vT0jhpeGCLpd8pdwuVxkZGTwTeLLyMgg2q7w06dPzZodBgwYQGtywZfk5eVhz549uH37NpU607t3b9ja2hI/54qKipCQkICMjAy+Cx10pw8K0th17tw5WFtbQ0FB4ZuGOg6HQyRpkWkqKytx7NixRp8tTU1NjB49mmhS8J07dzB58mQoKCjg5cuXUFFRQXFxMTIzM9G+ffsmBQd0o6uri/DwcAwaNIgyctUvyBw6dIhIQlp9AvK7d+/4pn/QbRL9Ffj06RO1UHz79m2UlJRg+PDhAABtbW2iRmA62y7/DpSXl2Pu3LlwcHAg1mq8OWbMmIF3794BqFvczMzMhI+PD2pqatCzZ0+sWLGCmHbfvn3h7++PDh06NGrrdOPGDWzcuBH9+vUDUDdHoLvIyMLCAgEBAaisrGzUOvjs2bMIDg6mTPf379//aWPdvn374O/vjy5dusDIyAjv3r3DggUL8PDhQ4SEhEBWVhYrV66EpaUl0XR5JpNbxcXFiZnKv8WDBw+wfft2KtFdSkoK2tramDFjxjdNEz8LU63IAwMDMXbsWMjJyUFJSalRQvKHDx9w6NAh2rtUAMz+nVlY/lSYOq8WLVoEERER7Nq1i+pA0/B4Fi5cKPBjEgT/tevYp0+fGt27CTJFPzAwEAsXLmwyx+vYsSNcXFzg7+8PS0tL2Nvb05LSKy8vjwcPHnyzw9D9+/chLy//03r1SEpK4sOHD9/c78OHD7R3m+nWrRv+/vvvbxYQJyQk0NoCvW3btnjy5Ak1l2+OJ0+e0P5MjCntNm3aYPDgwd+cXyUnJ2PVqlW06X5Jp06dcOHCBejp6eHkyZPQ0NCgnqvn5uZCQkLij9A+deoUAgMDAdQ9i/H39+e7n6SkJO0F9Exps2Nmx0xS90uY6vDIpDaTY27fvj3RtNJfTZdJbSbHzMLCwsIkrEmUhYXllyUnJ6fRg7MXL140MYOWl5cjOjqaaHvfqVOn4vXr19i4cSM2btwIYWFhqp3t+PHjYW9vT0TX0tKSyOv+atr6+vpUSmy/fv2+aSijMzHW3t6eajcoaNPm7NmzAdS1Azl//jzU1NQE2gYcEHy75C8ZPnw4Nm7ciBYtWsDMzAySkpIoLi5GfHw8Nm/eTLRl24ABA5CSksI3Mezy5ctETGVAnbFq2rRpqKmpgYGBARQVFZGbm4t9+/Zh3759CAsLQ+/evYlov3z5EuPHj0dFRQVKS0vRtm1bFBYWoqqqClwuFxISErQbJwVp7GpoDP0VUhcFTUZGBqZNm4asrCyoqqpCWloaDx8+xLFjxxAcHIxdu3ahS5cuRLQ3bNiAf/75B2vWrIGGhgb13/T0dCxcuJB4uo6rqytsbGxgbm4OY2NjcDgc7N+/H0+fPsWrV69w+PBh2jUfPXpE+2v+CKWlpbhy5QqysrKaGL5JGVTbt2+PW7duQVdXF2fOnEHXrl2pFJzCwsKfTlf8VXn69CmCgoJw9+5dvH//HlFRUdDQ0MCmTZugpaUFQ0ND2jXFxcWRmprKiNFYU1OTSguVlJREcHAwKioqUFFRQXQREQBWrlwJJycnTJw4EZKSklRb16KiIqipqVEGVSEhIUybNo1W7UWLFkFYWBjBwcGNkuHExMQwceJEKvlcS0vrp+dNhw8fxogRI7BhwwZq7hkaGooNGzZAR0cHISEhRBKQv0SQya1VVVX/k+H1f/3/muPGjRuws7ODrKwszM3NqVa2Z86cwfjx4xEWFgYdHR3a9L6Ht2/f4vXr11BXVyfW2nfbtm0YNGgQ5OTkmmz78OEDtm3bRsQkWk9paSnflHFS462srER4eDji4+ORlZXVRJtUlwaWP5t58+ZhxowZ391Vpby8HIcPH0aLFi1gbW1N+/EI+rwSERHBokWLMHPmTDx+/BgfP36ErKwsunfvTrS4s57CwkI8ffoUWVlZGDRoELhcLsrLyyEqKiqQVveCfr+ZgskU/aysrGafyXE4HGRnZwOoS9isfyb7MxgZGSEsLAzm5ubUc8EvycnJQXh4OMzNzX9arx5NTU0cOXKEKrZrjujo6EZFU3TQq1cvXLx48bv2/Z4EzO/FxsYGfn5+yMvLw7Bhw9ClSxcqxbWiogIZGRmIj49HWFgY7R2FmNLu3bv3dxW2SUtL06bJj6lTp8LT0xNHjhxBYWEh1q9fT227fv06VFRU/ghtW1tbWFpaora2FqampggMDGzyfS0qKgpZWVnan/0zpc2OmR0zSV0WFhYWFhaWPxtOLZ13fCwsLCw0EhgYiMDAwK/e4NTW1kJYWBje3t5EDWVAncHq6tWrVOJMv379iKYwlpWVISgoCAkJCXj//j3f1D86DZNMaR87dgyDBw9GmzZtcPTo0W/e0DJpniVFz549sWvXLvTt21egurt27UJkZCTatWsnkHbJX1JRUYGFCxfizJkz4HA4EBERQVVVFWprazF06FD4+fl9V/uv7+X+/fvUvz9+/Ahvb2/o6+vDxMSEMgkkJibi6tWrWLFiBRHjz5gxYyAuLo6dO3c2MtsUFxdj+vTpqKysRHR0NO26ADBz5kzU1tYiICAAmpqaiI6OhqqqKuLi4rBp0yZs2bIFPXr0IKIN1F2vP3z4AGlpaaLJaP9VJk+ejJycHISEhDRKf3n16hVmzpwJWVlZREREENHW09ODv78/BgwYADU1NURGRlILWtHR0di7dy9iYmKIaNfz5s0bBAYG4vLlyygoKACXy4W+vj7mzJlDPMlU0Fy/fh2zZ89GYWEh3+0cDofI/CAkJARbtmyBiooKHj58iMWLF2Py5MkAAH9/f6Snp2P//v206a1evfqH9ieRDnz58mXMmDEDGhoaMDAwQHBwMKKjo6GhoYGtW7fi/v37xBJU58yZg7///lvgyVyLFy+Gs7Mz38KVzMxMBAYGEk2oAOoSde7evUslIvfs2ZPIdzI/CgsLG5lfunXrRrsBpE+fPggMDGxUqFJQUIB+/fohJCQEgwYNolWvOWbMmIHHjx9j48aNTZJbFy5cCDU1NWzfvh0HDx7Evn37wOPx/mctQ0ND2NnZYdSoUWjTps03979x4wYiIiKgqqoKZ2fn/1n3S8aPH49WrVphx44djeYi1dXVcHR0xOfPn3HgwAHa9L5k3bp1qK6uxtKlSwEAZ86cwfz586mCndDQUCJzMVVVVRw6dAi9evVqsi0pKQkeHh64du0arZolJSVYv349EhISKMPxl5C6l/X09ERMTAyMjY2hpKTEN02dpCmW5c/E19cXBw4cgKKiIszMzKClpQUVFRXqO6KiogJv377F/fv3ceHCBZw7dw6KiopYsWIFbec1k+cVU9TW1mLTpk3Yu3cvSktLweFwcOTIEWhoaGD69Ono3bs3sfP5v/h+M8nEiRNRVFSEkJCQRsmdmZmZmDFjBqSkpLBv3z4cO3YM27dvR0JCwk/p5eXlwdLSEjU1NZg5cyYGDhwIeXl5cDgcZGVl4eLFi9ixYwc4HA6OHj1KW8rkjRs3MHnyZIwePRqLFi1qMs8sKiqCr68vjh07hr1790JbW5sWXQB4/fo1nj59SrX8bo6ysjLk5ubSmtwfEhKCkJAQKp22oVETqEtsc3R0hKOjI22aTGrv378fJ06cQFRU1Ff3u3fvHvbv30/0/io1NRV3796Furp6o0TVrVu3omfPnhg8ePAfpZ2ZmQlZWVlanyf/6trsmAXLf23MqqqqXy3iaN26NVRVVWFrawtjY+M/QpvJMdeHH/BDSEiI0p44cSI0NDR+e10mtZkcMwsLCwvTsCZRFhaWX5bMzExkZmaitrYWtra2WLZsGbp27dpoH1FRUSgqKn7XYuPvxuLFi8Hj8TBixAgoKyvzXdyytbX947SZYsqUKfD29ubbQjQjIwPe3t7EDFajRo2CnZ0dRo8eTeT1m0NVVfWr20kZjb7k8ePHuHHjBoqKisDlcqGtrU2kmv3LG/yGU6D61tQNfyYx9l69eiEgIABGRkZNtp09exbz58/HnTt3aNcFAAMDA6xZswaGhoZQV1fHwYMHqbS4iIgIxMXF4eDBg7TrXrx4EVu3bsWDBw9QXV1NLep5eXlBV1cXI0eOpF1z7969yM7OppLfGuLn5wd5efk/rm1g7969sX79epiZmTXZdurUKXh4eOD27dtEtPv27YuAgAD069cP/fv3x+LFizFixAgAdSY7FxcXvi3Zf3cqKytx5MgRKmFy2bJlUFRURFxcHFRUVH66JXVzjBgxAm3btoWXlxcUFRX5fkeTIiYmhlrkGTNmDHVNXbZsGbS0tGj9HvuRB60cDgdnz56lTbueMWPGoGvXrli/fj2qqqrQo0cPyiSamJiIlStX4sKFC7TrAnVGyWXLlsHExASGhoaQlpZu8vCSxEPKr5nJ7t27h7Fjx7KGiJ+E33tcXV0NDQ0N6vMlCLKzs+Hk5ISHDx/yTW4NDg6GnJwcDh06BDExsZ86v8+fP4/Nmzfj2bNn0NXVpcxVbdu2hZiYGIqKiihz1aVLl5CXlwcbGxs4OjrS2vqzd+/e2LJlC1/TcXJyMubMmUPsuxIATExMMGfOHIwaNQoA8M8//6BLly6YO3cula60a9cuWrR4PB5l7E1OToaWllaTtrUVFRW4d+8etLS0aDe8z549G1evXoW1tXWzRk1SxX99+/bFnDlzGJ3rMZl6yERhVl5eHsLCwqg5UWBgILp164Y9e/agd+/e1D0HCS5cuEDpOjk5QUFBAampqejcuTPf9Nyf4cOHDzh48CCOHz+OzMxMcDgcCAkJQUREhDIbCQsLY+DAgRg3bhzfe76fgcnzCqj73ti9ezfS09Op4mltbW3Y2trS/l7XU28QdXd3h76+PszMzKjvygMHDuDw4cM4evQoEW2m32+mePDgAbZv397k7zxjxgyoq6sT03327Bns7OyQn5+P7t27U/OSx48fQ1paGuHh4VBWVsbOnTshJCQEBweHn9Z89eoVXF1dcffu3Sbz7NraWvTq1Qt+fn60Fx3WmwKFhITQo0ePRubUe/fuobq6GkuWLMGECRNo1WWaiooKpKen48WLF5TxWlJSEl26dIGWlhZR4xOT2izMwWQKNFPa7JgFp8uktiB1w8LCsHfvXoiJicHY2Bht27ZFbm4ukpKSUF5eDktLS1y/fh3p6enw8/OjNX2bKW0mx7xmzRokJiaipKQE+vr6aNu2LfLy8nDlyhVISEigX79+SEtLw7t37xASEgIDA4PfWpdJbSbHzMLCwsI0bIwTCwvLL0uHDh2oquWIiAioq6sTb3NZT8PEwe+BxGJuUlISFi1ahEmTJtH+2r+qtomJCbZt28bXvPjkyRM4OTkRMYEAdcls9VXlX1JSUoIbN24Q0QWABQsWwMfHB8rKyujZsycxnS9hul1yPSoqKkRbHNVDyuT7I/z999/NppAUFxfzTW6ji/pWwUJCQuByufjw4QO1rVu3bkQ+DzweD25ubvjnn38wduxYeHl5Uds6deqEo0ePEjGJRkZGws7Oju82RUVFhIeHEzMOHDhwABYWFgL7vqqnXbt2X61ylpGRIaatrKyMN2/eoF+/ftDU1ERYWBi6d+8OERERhISEEP1cM8WbN28wdepU5OfnQ11dHWlpadR3SGpqKi5evEgsDSQzMxNLlixBt27diLz+1xg9ejRfo9jKlStp1zp37hztr/mjPH36lEry/PL8kpSURH5+PjHtGTNmAKi7nkVGRjYpchBUIUdDXr16JZCFFkEafhoiSJPTixcvICwsTP1c3zb1xYsXTfYlZRqVk5PD0aNHv5ncSke3hsGDB2Pw4MG4evUqjh8/jiNHjlBtY+sLdURFRaGhoQFbW1uMHDmSVnNoPS1btkRubi7fbR8/fkTLli1p12xITk4OFBQUANSleWVkZGDDhg3o3r07Jk+ejEWLFtGmVVlZSX0v1dbWorS0tIk5UUxMDKNGjcK0adNo060nJSUF3t7eROZ53+Kvv/5ibO7RXOohl8vFrFmziKYeNizMqqmpweHDh4kXZgF1z06mTp2K1q1bQ1dXF9evX6cMk/Wmws2bN9Oum5eXB2dnZ9y+fRvy8vLIysrC+PHjoaCggOjoaLRs2RLe3t60arZr1w5z5szBnDlz8Pr1a+raWV5eDi6XCyUlJfTq1YvYtYTJ8+rJkyeYNGkSKisr0b9/f6iqqiI3NxcHDx5EdHQ09u3bR2RueuzYMSxYsADjx49v0mK8c+fOePPmDe2a9TD5fjPFjRs3YGdnB1lZWZibm1MdV86cOYPx48cjLCwMOjo6RLS7du2KxMREHDlyBPfu3UNOTg5UVFRgbW0NKysriIuLAwCmT59Om+bff/+Nw4cP48aNG0hNTaXmJnJyctDT06M1xbMhEydOhLa2NiIiInDjxg3qGbScnBwsLCwwefJkgTwja0hqaio0NDTw119/EdMQExNDv379GiVKfo3a2losWbIEs2fPpuZPv6P2j0C37r1791BcXAx9fX0AdUUsGzZswPPnz2FgYAAXFxdixStMadfW1iIoKAhRUVHIycnhuw+p+2imtNkxs2MmqVtYWIgePXpgy5YtjZ5LLVq0CLNnz0ZZWRn279+P+fPnY+fOnbQaJpnSZnLMHTp0gIKCAnbu3NnoO/nTp09wdHREly5dsHLlSjg6OmLLli20GReZ0mVSm8kxs7CwsDANaxJlYWH5LdDT0wNQl+h4586dRouYXbp0oV3Pysrqm23PAbKL9MLCwkTb2f+K2pmZmXxb2wN17Y7ev38v4COq4+bNm0QWquvx8/NDQUEBxo0bBykpqSZmLg6HgxMnThDTZ5rHjx/j/fv3fCtghw4dSptO/XWESdzc3LBy5UrIy8s3Op5r164hMDCwkYmSbhQVFZGZmQldXV2oq6sjMjISBgYGEBERQVRUFNq1a0e7ZlBQEGxtbeHh4YHq6upG46s33pDg3bt3+Pvvv/lu69SpEzIzM4noAnWtZH19fTF06FBYW1sL7HPn4uKCgIAAqKmpNTJGvHnzBlu3biXaVnXcuHHUe7pgwQLY29tTKWktW7bEli1biGnXExsbi/j4eGRlZTW5lpC4hq5evRpt27bF4cOHISkp2aiNqK6uLjZu3EirXkO0tLSQkZHB6MMpJpMaBMmXhvqGvHz5ErKyssS0BVnYEBkZSbXY5nA4cHV1pRbi66moqEBmZibftGK6YMLwU4+gTU6LFy/m+3s3NzfqHkRQZmBDQ0O+yZokaLg4n5OT08hc1bFjR+IpTkZGRvDz80P79u0bXUNTUlKwceNG2lvFfUnr1q0pk+rly5fB5XKp7w8xMTG+19X/FUtLSyrhbvLkyVi+fDmxhGt+yMrKNkkuFRR2dnaIjIxE//79G5mxBcHmzZuxb98+LFq0iEo9rMfY2BiHDx8mMidjqjALANauXQtNTU0EBQWBw+Hg+PHj1LbevXvj1KlTRHTXrFmD/Px88Hg8/P33343mYvr6+ggODiaiW0/nzp1pTxf8FkyeV76+vujUqRPCwsLA5XKp3xcWFsLe3h6+vr60JSE3pKCgoNlrV3V1NaqqqmjXrIfJ95sp/Pz8oKenhx07djRKInZ3d4ejoyP8/f2pOSMJxMXFGUmB1tHR+W7zK10mPlVVVfj4+PzQ/0PKyFldXY0pU6ZQXV9+FWpqahATE4NJkyYJ1KjJpDbdumvXroW+vj5l1PTx8UFiYiL69++PsLAwCAkJwcXF5ad1fiXt3bt3Y/fu3Zg2bRo2bdoEJycnCAsLIzY2FpWVlZg5cybtmkxrs2Nmx0xS98iRI1i7dm2TtVIOh4Nx48Zh0aJFWLRoEUaMGIH58+f/EdpMjnnPnj1YtmxZk+/6Vq1awcHBAcuXL8f06dNhY2NDa5EpU7pMajM5ZhYWFhamYU2iLCwsvwWfP3+Gl5cXTp06hZqaGoiLi6O8vBxCQkIYNmwYVq1ahVatWtGm9yML86SSC2xsbHD8+HEMGDCAyOv/Ktrl5eUoLS2lWn2XlJSgoKCgyT6JiYm0m9h27NiBHTt2AKi7ybO1tW1y81dRUYHq6mqibZ4aLmgJktTU1G/uo6urS0z/yZMnmDdvHjIyMhq1eq+HiZQ0ElhYWDT6ubi4GLa2tmjdujXVQq24uBiSkpLw8/MjZtQwNzen0kLnzp0LBwcH6OnpUQle69ato13zzZs3zY6nZcuWKC4upl0TACQkJPD27Vv07duX7zG1aNGCiC5Ql+J08uRJREdHY8qUKejUqROsrKxgaWlJNAEvPj4eRUVFGDZsGLp160alvjx9+hTS0tJISEhAQkICgLpz62cXzj08PDBy5Ejo6+s3SpZUVlZGXFwcbt26hbKyMmhqakJaWvqntL7Fxo0bERISAg0NDSgqKgqkVdz169fh7++Ptm3bNkk1kpWVbbaqnw5WrlyJuXPnQlRUFPr6+nwXr0mYNQWdWnD69Okf2p/OooJ6TE1NsXXrVvTu3ZsynnM4HOTk5CA0NJSoYVKQhQ3t2rWj5iJPnz6FkpJSk+IYUVFRdOnSBdbW1sSOg0nDjyBNTr9CsnlDsrOzkZ2dzdegSHIeKCsrS9RozQ8PDw88e/YMDg4OkJCQoNqJlZSUoGfPnsQf/Ovo6GDLli3Izc1FaGgoTE1NqW0vXryAvLw8Ed29e/cSed2vMXv2bOzYsQPa2tqQlJQUqPaUKVPw4cMHDBkyBDo6Onz1PT09iWgzlXrIVGEWANy9exdbt26FqKhokzHXt2YkQXJyMlatWgVlZeUmuvLy8lQi4J8Ek+dVeno6NmzY0MggCtQV1Dg5OcHNzY2IrqKiIi5fvkyZjBpy/fp1osn6TL7fTPHw4UNs2bKlkUEUqCsknzJlCubMmSOQ48jNzeU7LxG0UZAfTJkHSRs5+T2T+xVg8riY0qZT99mzZ3B0dARQF76QkJAALy8vWFlZYf/+/YiIiCBmEmVK+8iRI5g9ezYmTpyITZs2wdTUFBoaGnB2doaTkxNev35NuybT2uyY2TGT1C0tLUVWVhbfbe/evaO+r//66y+Iior+EdpMjjk/Px8lJSV8txUXF1Md6r6ck/+uukxqMzlmFhYWFqZhTaIsLCy/BatWrUJSUhJWrVoFMzMzSEhIoKSkBPHx8fDx8cHq1atpbev6rYX5vLw8nDp1CidPnsTt27dhZWVFm3Y9LVq0QFpaGsaPHw99ff0mD6U5HA6mTp1Ku66gtXfu3Ilt27ZRr+vg4NDsvnSnrvTp0wf29vaora3Ftm3bYG5ujvbt2zfaR1RUFMrKyjAyMqJVu56qqipMmjQJ7du3J26k+pLJkydTBsF6vjTJkjRpLl26FMLCwggODoaioiLtN9XfIiYmBlFRUXj58iXfBYj09HRadDQ0NL4rmZg0Dduva2pqgsfj4cKFCygvL0e/fv3QvXt32jVlZWXx4sULvot6jx8/Jrao0r9/f2zbtg0GBgaNDBfv379HUFAQBg0aREQXqGtBPXHiREycOBGPHj1CdHQ09uzZg61bt6J///6wsrKCsbEx7Z/3T58+QVFRkUqBrqioQOvWraGlpUVtp5MLFy7g+PHjkJaWxvDhw2FhYYGePXsCqKu47d+/P616XyM6Ohpz5syBs7OzwDSFhYWbXbz5+PEj0TZ9kpKSUFBQwLJly5q9tpC4dgs6teBHFqFJFRUsXLgQd+/exciRI6lr5JIlS/DmzRsoKSkRTeit5/nz51T7cysrK8jKyuLVq1eQlpaGhIQELRqmpqaNzGrOzs6MtGpm0vAjSJPTr5BsDtQVTbi5ueH27dsAmi5I/ynFOkePHsXQoUMhISEBLpeLqKgoJCUlIS0tDUVFReByudDW1sbgwYOJtdusZ8mSJXBzc4Ofnx80NDQapY6cOHGCWAtfoM7UcvXqVWRkZDTp3EDivtLc3ByPHz/G4MGDoaam1qSggY6Clebg8XgICwsDh8PBlStXmsy5OBwOMZMoU6mHTBVm1b9+c4tr7969I5YyXl1d3ex8q6ioSOD3loKAyfNKWFi42a4vFRUVxFJ7p06dCi8vL4iIiGDYsGEA6u7pbt26hb1799L6HPBLmHy/maJly5bNznk+fvyIli1bEtPOz8/H6tWrcfr06SbXSkGlq38vf4J5kOW/QVlZGXXepqeno6KiAiYmJgAAFRUVoh27mNLOzMyEmpoahIWFISIiQpl8hISEMGHCBCxduhQLFiz4o7TZMbNjJqlrbGwMf39//PXXXzAyMqLWZc+ePQt/f3/qWdLjx4+b7er1u2kzOea+ffvC398fHTp0oJ7pA8CNGzewceNGqjNLRkYGOnTo8NvrMqnN5JhZWFhYmIY1ibKwsPwWJCQkwNXVtZEZU0JCAtbW1igvL8fGjRuJPhwG6irIzpw5Ax6Ph5SUFFRXV0NNTa3ZdpE/i5+fH4C6hZVbt2412U7SJCpIbVNTU3To0IFq2eTk5NSkbVu9UVNNTY0WzXr09PSohXoOh4OxY8cSTfrjh5CQEP7991+EhIQIvHVwTExMk98VFhbi0qVLOH36NFasWEFU/9mzZwgICCBq2GuO48ePw8vLC5aWlrh58yasrKxQU1ODc+fOQVJSkmqVTQdfJnTW1NRQablSUlLEDQnNIS8vj3///ZeoxogRI7B161Z06dKl0bn25MkT7Nq1CzY2NkR0Fy5ciH///RfDhg1Dv3790K5dO3z48AFXr15F27ZtsXDhQiK6X6KqqoqlS5di2rRpcHV1xYULF3DhwgW0adMGNjY2cHR0pC3VVNApYZcuXUJKSgp4PB6OHj2KvXv3onPnzrCwsMCIESMos6qg6N27t0D1dHV1ER4ejkGDBlHncL3p/tChQ3yN0XTh5uaG9PR02NnZQUlJSWAmCEGnFpw9e5bW1/tfaN26NQ4ePIgTJ04gJSUFUlJS4HK5mDhxIkaNGkU0tba0tBSenp6Ii4uDkJAQampqMHDgQMjKysLf3x8dO3aEu7s77br85tN5eXlo3bo18c8ak4YfpkxOTOLp6Yns7Gz4+PhAWVlZICnMTLBkyRKsWLECgwcPhoWFBQwNDWFiYkItUgsSOTm5ZpNkQ0NDif0NcnJyMGnSJLx69apRgVjDQgO67yt3796NkJAQyMjIoLq6mvZila/h7+8PMzMzrFq1ijYz/ffCVOohU4VZADBgwAAEBwc3Ki7lcDgoKytDREQEsS4JvXr1QnR0NN/Xj42NbbTQ96fA5HllYGCAzZs3Q01NDUpKStTvX758iYCAAGLPMsaMGYPCwkJs3bqV6gLj4uKCli1bYt68eRg+fDgRXYDZ95spjIyM4Ofnh/bt2zf6m6akpGDjxo0wNjYmpu3p6YnU1FTMmDEDysrKf6TR+1eFw+FAV1eX1g5dLL8GnTp1woULF6Cnp4eTJ09CQ0ODuq/Jzc0lOk9iSltKSgqfP38GUJc+/ODBA2p+lJ+fj7KyMiK6TGqzY2bHTFJ3+fLl8PDwgJubGzgcDkRERFBVVYXa2loMGTIEy5Yto46JbpMqU9pMjnnlypVwcnLCxIkTISkpSXWhKyoqgpqaGrVeJyQkhGnTpv32ukxqMzlmFhYWFqZhTaIsLCy/BeLi4ujYsSPfbZ06dWrSCokuqqurqdbB586dQ1lZGfWA2N/fn+gD6fq20EwgSG1VVVWoqqoCqHswaWho2KTFqSAQRBoYP4SEhNCxY0cUFhYKXLv+ff+Svn37okWLFoiKiqIq5kjp5+XlEXv9rxEeHg5nZ2c4Ojri0KFDmDBhAjQ0NFBSUgIHBwciD8fPnz+PPXv24ObNm1Ryqbi4OLS0tGBra0tsAfVLHj9+jPfv3/NNT6W7XfOsWbPw9OlT2NnZUQ+Dp0+fjry8PAwePJhqPUU3cnJyiImJQXh4OK5evYqXL19CSkoKdnZ2mDp1qkDMPrW1tbhw4QKio6ORlJQESUlJODg4YMiQIUhOTsa+ffvw9OlTbN26lfixkEBISAgDBgzAgAEDUFFRgaSkJMTGxlLp0Orq6hg5ciSGDx9OvJ2wtbU1eDyeQNNLXV1dYWNjA3NzcxgbG4PD4WD//v14+vQpXr16hcOHDxPTvnr1KlasWEGrmf17EHRqwa9SpS0qKgorKysiqfFfw9fXF1evXsXOnTuho6MDTU1NapuhoSF2795Nm0n0zp07uHv3LiZOnNjo90eOHIGfnx8KCwshJiaGCRMmwN3dnVg6NpOGH6ZMTkxy584d+Pr60v7d/6tx/PhxxMbGIi4uDgkJCZCUlISZmRksLCwYTXXNyspCVlYWVFVV8ddffxFdpF+3bh3atGlDfZYPHToEGRkZnDhxAjExMQgJCaFdMyQkBBMnTsTSpUsFXhBVUFCAcePGCdwgCjCXeshUYRZQV7xiY2MDMzMz9O3bFxwOB5s3b8azZ8/A4XAwb948Irrz5s3DlClTMHHiRJiZmYHD4SAxMRE7duxAcnIyIiMjiegyCZPnlYeHByZNmgRzc3N069YNMjIyyM3NxZMnTyAvL0+seBqo64gxbtw43Lx5E/n5+eByuejTp0+TZE+6YfL9ZgoPDw88e/YMDg4OkJCQQNu2bZGXl4eSkhL07NkTixYtIqZ97do1eHp6YvTo0cQ0WPgjJCT01aLT+qL+2bNnEy06YKGfqVOnwtPTE0eOHEFhYSHWr19Pbbt+/TpUVFT+OG0tLS3cvXsXhoaGGDFiBAIDA/Hx40eIiIgQL+hlSpsdMztmkroSEhIIDAzE8+fPcefOHeTk5KBdu3bo0aMHunbtSu1H4rkCU9pMjllOTg5Hjx5FcnIy7t69i5ycHMjKyqJnz56NnkuNGzfuj9BlUpvJMbOwsLAwDWsSZWFh+S0YM2YMDhw4gIEDBzZamK6trUVkZCTGjBlDq15aWhp4PB7i4+ORn58PKSkpjBw5EhYWFujWrRv69u1L3PTyNUpKSnD69Gnax820tqWlJe2v+b3U1NTg8OHDSEhI4Gugq190IsHMmTMRFBQELS0tgSeZNoeWlhZCQ0OJaixbtgyLFi2CrKws+vbtS8zszY9Xr15BS0sLwsLCEBYWptLDJCQkMH36dPj4+DRqz/6zrF69Gvv27QOXy8WgQYOoFuhZWVm4du0aZs6ciUmTJmHp0qW0aX7JkydPMG/ePGRkZPBtU0aifZuYmBiCg4Nx9epVpKSkUIt6BgYGxJNzpaSkGrVxFRSvX79GdHQ0YmJi8OHDBxgYGMDPzw8mJibUZ1xTUxM9evSgvdr46dOnCAoKolpTR0VFQUNDA5s2bYKWlhYxk5OYmBjMzMxgZmaGT58+4fTp04iNjcWGDRuwfv169O3bF2FhYUS0gTqTwJo1azB+/PhGBq96SCRvKysrIzo6GoGBgeDxeBAWFsb58+ehr68PPz+/JonYdCInJ0d8UZwfTCY1NKS0tJSvyZ2k+TsjI6PJg+EuXboQ0wPqUvTd3d0xYMCAJu3PO3TogMzMTNq0du3ahbKyskYm0Rs3bsDLywvt27eHpaUlMjIysHv3bnTv3p3YfI1Jww9TJicmkZOT+0+YXlRUVKCiooIFCxbg5s2b4PF4SEhIwJEjR9CuXTuYm5vDwsKC9o4FzREVFYXAwEDk5OSAw+HgyJEj0NDQgIuLC/T09GBra0u7ZmpqKjw9PRvdvyooKGDmzJmora3FypUrsWvXLlo1KysrYWpqyshnzNDQEDdv3iS6ONwcTKUeMlWYBfx/cdbu3buRkpKCzp07o6CgABYWFo2Oh2769OmDiIgI+Pv7w9fXF7W1tdi+fTs0NTWxe/duaGhoENFlEibPKwUFBZw8eRLR0dFIS0tDUVERFBUVYWVlhTFjxhBPIGzVqhUGDBhAVONLmHy/mYLL5SIqKgpJSUnU35nL5UJbWxuDBw8m+l7UJzix/HrU1NQgJiYGkyZNYk2ivxnW1tb4+++/cffuXairqzcKApCSksKUKVP+OO1Zs2YhOzsbQN3z9qKiIvB4PJSXl8PAwABeXl5EdJnUZsfMjpn0mIG656DKyspENX41bSbHbGhoyEixMlO6TGozOWYWFhYWpuDU8nMJsLCwsPxihISEYP/+/RATE4ORkRGkpaWRm5uLpKQkVFRUYNKkSZT5hg4ziKqqKjgcDvr27Qs7Ozv079+fev3i4mLo6upi79690NXV/dmhfTeVlZVITk7GiRMnkJycjIqKCtoNXUxrl5WVISgoiDJqVlRUNNmH1Jh9fX0RHh4OXV1ddO3alW9rqyVLlhDRnjlzJu7du4fCwkKoqKhARkam0XYOh4Pg4GAi2s2xatUqJCUl4dy5c8Q0KioqsHr1ahw+fBhCQkIQFxdvtJ3D4SAtLY2I9sCBA+Hj44OBAwfC2NgYDg4OlDkmISEBHh4euHnzJi1ax48fh4eHB5ydneHg4NCklW5paSlCQ0MRFBQEX19fWFhY0KL7JWPHjkVZWRkWLlwIRUVFvp9xupP73r17B1lZWb5aVVVV+PDhwx+3yKCqqgo5OTmMGTMG1tbWzb6nGRkZWLZsGW1t4i9fvowZM2ZAQ0MDBgYGCA4ORnR0NDQ0NLB161bcv38f27dvp0Xre8jIyMCePXsQFRUFgNy1GwCuXLmCWbNmNdsCkoQBmkliY2Oxd+9e7NixA1wuV2C6CxYsQJcuXTBr1ixs2bIF4eHhGD9+PJVaoKenRywZt7a2FkFBQYiKikJOTg7ffUj8jT99+oRly5bh1KlTqKmpgbi4OMrLyyEkJIRhw4Zh1apVxEwRvXv3xrZt2yiTqIaGBnVOJyUlYeHChUhPT6dFy9jYGDNnzmxUHe/q6oqEhATEx8dT1zEPDw9kZGRQ5zUJbt68CX9/f9y8eRPV1dXgcDjQ1NSEu7s7+vTpQ0wXqGtpX29yqi9q0NfXJ2pyYpKEhASEhYVhx44df+T4vkZNTQ2uXLkCHo+HxMRElJSUoEuXLrCwsMDMmTOJ6e7evRt+fn6ws7ODvr4+7O3tqfN6z549iI+Px4EDB2jX7dOnD5VKrKOjgw0bNsDIyAhA3Xeos7MzbfPeery9vdGyZUt4eHjQ+rrfw6VLl7BixQr8888/fItHABA3EH769EngqYcAGCnM+hUoKytDYWEhJCUl0bJlS+J6JSUlqKioaNQB5cSJE3j+/Dn09fWJdeNg8rwSJKdPn/6h/UklYv9X3u9fhf379yMpKQnbt28XaAHxj/LlvPxP12VSmx3zn1fswMLC8ntSWVmJI0eOUKEEy5Ytg6KiIuLi4qCiokLUSMmUNpNjBoALFy5Q2k5OTlBQUEBqaio6d+5MNGSGKV0mtZkcMwsLCwtT/Lp33CwsLCwN2LhxI/XviIiIJtv9/f2pf9NhEu3evTuePHmC1NRUCAsLIz8/H6ampoy0rLt27RpOnjyJM2fOoKioCNLS0rCxsRFICyZBa69YsQI8Hg8jRoyAsrIyX2MZKU6ePInZs2fDxcVFYJr1fPr0CUpKSo1+FgT8FsErKyuRkZGBrKwsuLm5EdX39vYGj8fDkCFDoKSkJNC/d48ePfD48WPKJLpt2zbU1tZCREQEISEhjdr6/iwHDhzA2LFjMXv2bL7bW7ZsiVmzZuHDhw/Yv38/MZPos2fPEBAQgEGDBhF5fX6YmJggKioKvXr1arLt0aNHGDt2LG3GLgsLC/j7+6N79+7ffA85HA5OnDhBi+6XBAcHw9DQ8JspK0pKSrQZRIG678Hhw4dj/fr1qKqqamQsV1NTI9r+vJ7s7GzExcXh5MmTePjwIcTExDBkyBCMHDmSqO6KFSvQo0cPeHp6NmuAppspU6bA29ub70PBjIwMeHt7852v0MHJkyfx7t07GBkZQU1NrYnphFRhAZOpBbt378bu3bsxbdo0bNq0CU5OThAWFkZsbCwqKyuJmbpWr16NpKQkrFq1CmZmZpCQkEBJSQni4+Ph4+OD1atXE2sdrKKigtOnT/NNzTp//jx69OhBm1Zubi7+/vvvRr+7ePEidHR0Ghndhw0bRrSdLFBnZtu3b5/ADT9AXYLVnDlzMGfOHIHoMc2xY8fw/v17GBsbC/RaAtQtgN++fbvZojDS9zlCQkLo378/+vfvj+XLl2PDhg3Yv38/AgICiJpE9+3bB2dnZzg7OzdJCFZSUkJGRgYR3Y4dO+LDhw8AgK5du+L48eOUSTQxMZGISVhLSwsBAQHIyclp1qhJytg1bdo0AHWFpiEhIU06kQiieISJ1EMA6NevHzGD4o+QlpaGFy9eQFtbm3jyNgC0aNECLVq0QGlpKV69eoXOnTs3+rvTjZubG9q1a4cVK1YAAAIDAxEYGAgul4udO3fCz8+PSGosk+eVIPmR72GS5/N/5f0uKCiApKQkhISEUFBQ8M39SRWWvHjxAs+fP8eQIUOgq6vL9/329PQkos0iGMrLyzF27FiqW8K3EBYWRkRERKPnpb+bNhO69+/fh7KyMlq0aIH79+9/c386zahMadfU1OD8+fPo1KkTunXrxnefp0+f4s2bNzAyMqJ1jsCUNjtmdswkdRvy5s0bTJ06Ffn5+VBXV0daWhq1dpWamoqLFy8Sey7GlDaTY87Ly4OzszNu374NeXl5ZGVlYfz48VBQUEB0dDRatmwJb2/vP0aXSW0mx8zCwsLCNKxJlIWF5bfg0aNHAtU7ceIEnj17hhMnTiA2NhYeHh5o0aIFDA0Nid1wNeThw4c4ceIE4uLi8OHDB7Rs2RIDBgzAmTNnsGnTJqIJpkxqJyUlYdGiRZg0aRIxjeaoqKiAlpaWwHUB0GoU+xH4mVHFxcVhYGAAMzMzDBw4kKh+fWJnw/a2gmLGjBl49+4dgLpFqMzMTPj4+KCmpgY9e/bEypUradN6/PhxswbRhpiZmYHH49Gm+yWqqqrIy8sj9vr8+FpgfUVFBcTExGjT6tGjB2Uk0tDQIH6dbo5604Wgefr0KRYuXAgATcYuKSmJ/Px8IrqFhYWIj48Hj8dDWloalcLt4+ODIUOGCKS44v379/Dy8mr2gSkJrl+/3qyhv6SkBDdu3CCm/enTp0aGPkEVFnTp0oUyeoiJicHT01NgC7VHjhzB7NmzMXHiRGzatAmmpqbQ0NCAs7MznJyc8Pr1ayK6CQkJcHV1hZWVFfU7CQkJWFtbo7y8HBs3biT2YLjeSFZaWophw4aBw+Hgzp074PF4iI6Oxs6dO2nTat26NUpKSqifX7x4gcLCQmhrazfaT0JCAmVlZbTpfo16ww8LOT59+oTOnTs3+lkQ3L9/H7Nnz0ZWVhbfeQKHwxFIMdz9+/fB4/EQFxeH7OxsyMjI4J9//iGqmZ2d3WwirqioKD5//kxEd/Dgwbh8+TKGDx8OJycnuLi4QF9fHyIiIvj48SNcXV1p11y0aBGAulT52NjYJttJGrtIFWl8DxcuXEBRURFGjBgBAMjKysKSJUvw/PlzGBgYYNmyZU26CtBBZmYmSkpKoKKiAqBunh0aGkrpjhkzhnbNehYuXAgxMTHq+/DAgQOUeVJMTAw7duyAvr4+7bqhoaEoLS3FrFmzAAA3btyAk5MTSkpK0LFjR4SGhja6xtHJ3bt3qQXD2tpaREZGYsaMGZg/fz7Wrl2L0NBQIiZRQZ9XxsbG331PxeFwkJiYSIvu2bNnaXmdn4XJ65gg0dfXpwo7+/Xr982/OakxJyUlUdr87qU4HM4vYRKl07j4I51XhISEYGlpiTZt2vy0LlOIi4sjOzv7mwW1DdHT0/uttZnQtbKywqFDh9CrVy9YWVk1e06TKJxhSvvo0aNYt27dV5+ptm7dGu7u7vD09KT1XoMpbXbMgtNlUpvJMdezevVqtG3bFocPH4akpGSjgmVdXd1G4T5/ijaTY16zZg3y8/PB4/Hw999/N9LW19cnVsjLlC6T2kyOmYWFhYVpWJMoCwsLSzN07doVCxYswIIFC5CWlgYej4eEhAQkJCSAw+FQi090miaDg4PB4/Hw4sULCAsLY+DAgVi0aBGMjY1RUVHxw223fhfteoSFhaGoqEhchx8WFhY4d+4ckQWsXxWmzKn1SEpKolOnToxoa2pqUmmhkpKSCA4ORkVFBSoqKmg3tXE4nK+aJQXFsmXLsGjRIsjKyqJv377EWrg9f/4cz58/p36+du0a3r9/32if8vJyxMbG0vr3NzU1pVJN1q1bR9vr/iiLFy9GaWkpNm/e3GTb/PnzISEhgVWrVtGuy+VyqZSwL3n58iVkZWVp1Tt58iRiY2Nx+fJlVFZWomfPnvDw8MDw4cMhIyNDq9a30NbWRkZGBvr37y9Q3ea4efNmo/ajdMPUtZvJ9NTMzEyoqalBWFgYIiIiKCoqAlC3WDphwgQsXboUCxYsoF1XXFwcHTt25LutU6dORFthDh48GBs3bsT69etx8uRJAHWpue3bt4efnx+t8xU1NTVER0fDxMQEQN35zeFwYGho2Gg/EteSH00mpdOU+yPmF4A+04qqquoP6ZIyYzB1LVm+fDkkJCSwZ88edO3aVaBJ8hkZGeDxeODxeHj9+jX++usvDB06FCNGjIC+vv4PLeD/LygoKODu3bt8z9/bt28Tuw+qLyIBAENDQxw4cACJiYkoKyuDgYFBk3OdDpg0edFlKPlf2LJlSyOz8cqVK/H8+XOYm5vjxIkT2LJlC5HW1V5eXlBVVYW7uzsAYMOGDThw4AC6d++O+Ph4lJaWEivMS0tLo3SBugTXsWPHwsPDA8uXL0dgYCCRe+zDhw/DwcGB+nnt2rXo2rUrHB0dERwcjI0bN/Kdj9NBYWEhZdS6d+8e8vPzYW1tDaDuu4VUgr+gzysTE5Nvfl89fvwY165do7VAr2GKOZP8KmZV0vj4+FD35T4+PowVW547d44R3XqysrKQmJiIrKwsvinnDQ2qdH3P/EjnFQ6HQ6w4TZAMHToUp06dgoGBwX9GW9C6ERER1D27oAtnmNI+fvw4xo8fj/bt2ze7T/v27TFhwgRER0fTaqRjSpsds+B0mdRmcsz1XL9+Hf7+/mjbtm2TbhiysrLIycmhXZNpbSbHnJycjFWrVkFZWbmJtry8PNXh6U/RZVKbyTGzsLCwMA1rEmVhYfmtePz4Md6/f4/y8vIm20i2edLW1oa2tjY8PT1x6dIl8Hg8nD17FomJiVBQUKDt4XFAQAA4HA4MDAywdu1atGvXjtpWWVlJi8avqF2PjY0Njh8/zkhrvt69e2Pz5s3Izc2FgYEB8VZi4eHhsLCwgIyMDMLDw7+6L4fDwdSpU2nT5kdZWRmKioogKSkpsOQuOzs77Nu3DwYGBkSNNt+LmJgYrcmW9XTv3r3ZlsENiY+Pp9J/SKCsrAxNTU1MmzYNQkJCEBcXb7Sdw+EgLS3tp3VOnTqFwMBA6jX9/f357icpKUnrIsesWbOoBRY1NbVmF1tIk5KSQqXOfMnQoUOxfv16IrqmpqbYunUrevfuTaVMcjgc5OTkIDQ0FGZmZrTqubm5QUlJCTNnzoSFhQWxpKbvYf78+fDw8ICoqCgMDAyatEwG6GmLuGPHDuzYsQNA3Xtra2vbZBG1oqIC1dXVmDBhwk/r/WowmZ4qJSVFJewpKCjgwYMHlOEkPz+fWLrlmDFjcODAAQwcOLBJu+LIyEiiyWxAXXv3YcOGISMjA/n5+eByuXxNuj+Li4sLJk2aBDMzM0hLSyM9PR39+/dHz549G+13+vRp9O7dm1btLw2Q2dnZ1FilpaWRm5tLmXG+tjDyv/Cl+SUhIQElJSUwMDCgtFNSUtC6dWtar6EeHh6UbnV1Nfbs2QNRUVGYmppCWloaHz9+RGJiIqqqqojP/5jg2bNn2Lx5s8CMfNnZ2YiNjQWPx8PDhw8hIiICQ0NDzJ8/H8bGxkTmfs0xbtw4BAYGok2bNtR9RVVVFc6fP4/Q0FDMmzdPIMfRs2fPJuc33Qja5FVVVfU/3U/8r/9fc7x69QqqqqoA6r4bL168CD8/PwwbNgzdunVDYGAgEZPow4cPqW4cVVVViImJgaurK6ZOnYrt27fj4MGDxEyieXl51LODp0+fIisrC1OmTEGrVq1gaWmJuXPnEtF9//49NefNzs7G/fv3sW/fPujo6KC6uhrLly8nogsAMjIyePbsGXR0dJCcnIwOHTpQJrvS0lJi97aCPq+WLl3a7LaHDx9i27ZtuH79Ojp37gxHR0cix1Df/eNr1Cct0s2vYlYljaWlJfVv0nPbX5W4uDi4u7ujtrYWbdu2bVLAQirFVJCdV34VtLS0sHHjRsyYMQODBg2CjIxMk3tqUs/3mdIWtG7DObagC2eY0n7w4AFmzJjxzf309PQQGRn5R2izYxacLpPaTI65HmFh4Wa/rz5+/EikSwLT2kyOubq6utnXLyoqIlZky5Quk9pMjpmFhYWFaZh3ZLCwsLB8B0+ePMG8efOQkZHRbFtCQbR5EhYWhqGhIQwNDVFWVobExERa20NPmjQJ8fHxVDvAIUOGwMLCQiDplkxq19OiRQukpaVh/Pjx0NfXb2LUJGmWrE8/effuHeLi4ppsp/sz5uvrC21tbcjIyMDX1/er+5Icd1JSEgIDA/Hw4UOq3Y+amhrmzJlDJFWoIa9fv8aTJ08wZMgQ6Orq8jXm0vkgfvXq1bC3t4eCggJWr179zf3p0p4wYQIWLVoEOTk52NvbUy3R6ykrK0NYWBiio6OJGQgBwNvbGzweD0OGDIGSkhKxG11bW1tYWlqitrYWpqamCAwMhJqaWqN9REVFISsrS2tKSevWrZGXlwfg64stpMnLy2u2BZyUlBQ+fvxIRHfhwoW4e/cuRo4cie7duwMAlixZgjdv3kBJSYlqxUkX0dHR0NDQoPU1/1fqk5u8vb2b/UzRcf3u06cP7O3tUVtbi23btsHc3LyJaU1UVBTKysowMjL6ab2v8eDBA2zfvh3p6ekoKCiAlJQUtLW1MWPGDKirqxPV5gfp9FQtLS3cvXsXhoaGGDFiBAIDA/Hx40eIiIjg0KFDxOYqXC4XDx48wNChQ2FkZEQZB5OSklBRUQFtbW2q0IPkd7WSkhItLS2bQ1NTE3v27MHBgwdRVFQEZ2fnRulsAJCbmwthYWHakyliYmKof1+4cAHLly/Hpk2b0K9fP+r3V65cwdKlS2k30DU0v+zatQvy8vLYtWtXo0Tx4uJiTJ8+HdLS0rTpNvycbNiwAWpqaggKCmqUYrlo0SI4Ozs3mxD9vxIZGQlra+sfMh08fvwYeXl5tJ1nioqKAmttD9Sl8nI4HOjq6mLlypUYNmwY32ICQeDg4ICsrCwsW7aMalVtY2MDoG6+SKeJr6Cg4If2p6OYIj8//39qg1v/PfYzmJiYwM7ODqNGjfquY7hx4wYiIiKgqqoKZ2fnn9JuSFVVFXUup6amAgAGDhwIoC6BmtQ88NOnT9Tn+vbt2ygpKaHanWtra2P79u1EdIG6z05mZiZ0dHRw8eJFyMrKolu3bgDqFt5qamqI6IqLi6OkpARA3ffEX3/9hT59+gCouy8oLi4mogvUFXFs2LABKSkpuHDhAqZNm0Zte/DgAWVepQMmzyt+3L17F9u2bUNycjIUFRWxbt06WFhYEEti/p7Ubzqf0/xq77egMTExwbZt2yize0OePHkCJycnWhNWk5OTf/i5U15eHrKysmi9F920aRNMTU2xatUq4nMEpjqv/CrUdxFITk5GcnJyk+0kn+8zpc3kmP8rVFZWftf9jZiYGN+k4N9Rmx2z4HSZ1GZyzPXo6uoiPDwcgwYNouZ79V3TSD6PY1KbyTH36tUL0dHRfOdHsbGx0NLS+qN0mdRmcswsLCwsTMOaRFlYWH4Lli5dCmFhYQQHB0NRUfGXqOJp0aIFRowYgREjRtD2mp6enliyZAlSUlLA4/Fw+vRpxMTEQFpaGkZGRuBwOMRaPzGpXY+fnx+AOqPmrVu3mmwnacAQdCuxR48e8f23IElMTMTs2bPRu3dveHh4QEZGBjk5OYiPj4eTkxO2bNkCU1NTYvpJSUnUjTa/BDq60xrOnTsHa2trKCgofLOVGZ3aI0eOxO3bt7F161ZERESgb9++VNrJu3fvcP36dRQWFmLixIm0Xk++JCEhAR4eHsRShOpp3bo1WrdujfLycri7u6NTp04CSWHR1dWFu7s7lcZa386WHxwOB3v27CFyHHJycrhz5w7fB0Z37tyhvVVzPa1bt8bBgwdx4sQJpKSkQEpKClwuFxMnTsSoUaNoTyH5VQyigODaIurp6UFPTw+1tbUoKCiAo6Mj5OTkiOt+yY0bN2BnZwdZWVmYm5tTxsUzZ85g/PjxCAsLg46ODi1av0p66qxZs6g2PzNnzkRRURF4PB7Ky8thYGAALy8vIrobN26k/s2vXV7DpGQSc5SnT59i+/btuHPnDnJyciArK4vevXtjxowZlAGHLupT85tDWloawcHBtGp+yYYNGzBnzpxGBlEA0NfXx+zZs7FhwwZiBSx79+6Ft7d3k++N1q1bY/r06VixYgWRlLRjx45h3bp1Tcw1QkJCsLGxgYeHR7Pp1P+rXr3JfdiwYejZsyff+6rs7GxcuHABsbGxuH37NtatW0fbMSxevBhr1qyBiooKkWTcL3F3d8fw4cMZuV7zw9PTE7a2tkhJSaFSc/X19WlvNd+vX78f+m6kw5xgYmICKysrWFlZ8TUYNeTz5884c+YMIiIiYGpqCicnp5/SXrFiBTZv3gw/Pz/o6upCS0sLKioqaNu2LcTExFBUVIS3b9/i/v37uHTpEvLy8mBjY4Px48f/lO6XdOnSBSdOnEDv3r0RFRWFPn36oFWrVgCAnJwcYiay9u3b49atW9DV1cWZM2fQtWtXKt2zsLCQaKeIQYMGwc/PD48ePcKxY8cwatQoatvTp0/RsWNHIrq9evVCSEgIhISEEBoaikGDBkFYWBhAXTEiyXN+4cKFaNWqFe7duwd7e/tG3w/379/HP//8Q5sWk+dVQ27duoXAwEBcvnwZXbt2hb+/P/755x/ic/D6DhUNKSoqwqVLl3Dr1i24urrSqvervN9MkZmZ2azJpKysrImZ8Wfx9vYGl8uFlZUVzMzMmj1vq6urcf36dfB4PMTFxWHJkiW03o/m5eXh33//FUgRCVOdVxpSXl6OsWPHwt3d/bs6OQkLCyMiIoKWojVBP3v9FbQFrWtiYvJD+9N5fExpy8vL48GDB99ML71//z7k5eVp0WRamx2z4HSZ1GZyzPW4urrCxsYG5ubmVPHO/v378fTpU7x69QqHDx8mosukNpNjnjdvHqZMmYKJEyfCzMwMHA4HiYmJ2LFjB5KTk4klxjKly6Q2k2NmYWFhYRpOLZNRSywsLCzfSZ8+fRAQEIBBgwYxfSgCpaKiAmfPngWPx8OFCxdQWVmJjh07YvTo0Rg1ahTRqnImtX9Frl27hr59+9L2ei9fvsSCBQswd+7cZg0PycnJCAgIQEBAAJH3e/To0ejatStlzm2Iq6srnj171ijhi+XnOHv2LPbs2YNbt25RCy9iYmLo06cPbG1tYWxsTFR/8ODBWLlypUCvo71798bOnTsF0maqsLAQYWFhyMjIwJkzZ6Cjo8M3nbaebdu2ETmOTZs2ISIiAmvWrKESnIC6xaAlS5ZgypQpmD9/PhFtFsFQUVEBTU1NBAUFYfDgwQLXHz9+PFq1aoUdO3Y0amdaXV0NR0dHfP78GQcOHKBF6/r167h+/TqVnmptbf3V9NR6cwbLz3P+/HnMmjUL7du3p9qQ5+bmIjExEe/fv0dgYCAjnz+S9OrVC1u2bOE7rnPnzmHevHm4c+cOEW1NTU2sWLGikbmpnpiYGCxfvpxvAdPPoqWlBTc3NypNsiGRkZHw8/NDeno6rZr1hpYbN25AREQEioqKlJGuuLgYb9++RW5uLrhcLiwtLWFvb09rgYOFhQVycnJQVFSEdu3aNTFkcDgcnDhxgja9X4nU1FSoq6tTpsGGfP78Gffv34euri4tWkePHv0h81bDdsP/K48fP0ZAQACSkpLQuXNn9OnTByoqKmjTpk2jz9f9+/eRnp5OmbDHjx9PWzHL1atXcfz4caSkpFDFBfWpL6KiotDQ0MCwYcMwcuRIIgnYZ8+exdy5c1FdXQ1hYWFs376dMuAsXrwY+fn5RFI9Q0JCsGXLFqioqODhw4dYvHgxJk+eDKCuoCE9PR379++nXReoS1z28fHBvXv3oK6uDi8vL8pwb2NjA21tbdqNfADw7NkzzJgxA5mZmVBQUEB4eDiV4Fl/3fpWx47fAabPq9TUVAQFBeHKlStQV1eHk5MThgwZQsPIfp61a9eivLwcy5cvp+01mX6/maC8vBylpaWora2Fvr4+wsLCmnQmKC8vx/79+3Hy5EkkJSXRpl1RUYHIyEjs3bsX7969g7y8PLp3795kXvL48WNUVVXB2NgYzs7O3zTw/ijz5s2DioqKQIy+xcXFKCoqEnjnlS/p27cvNm3aBAMDA2IaLMygqqqKVq1awcjI6LvmOkuWLPnttdetW4e4uDhER0c3e9+Sk5MDKysrmJub01qEx5Q2O2Z2zCR1v+TNmzdUsVBBQQFV6Dhnzhx07tyZiCbT2kyO+ebNm/D398fNmzdRXV0NDocDTU1NuLu7U50T/iRdJrWZHDMLCwsLk7AmURYWlt8CGxsb/Pvvv7S3uPydKC4uRnx8PHg8HlJTU1FbWyuwdjRMatdTUlKC06dPY8yYMQLTfPjwIU6cOIG4uDh8+PCB1jEvW7YML168wL59+7663+TJk6GsrEzrwkc9vXr1QlBQEN/kgIsXL8LFxYWYGYNJ3r59i8OHD+PWrVv4+PEjOBwOZGRkoKWlhbFjxxKrvK2nuroa+fn5AIA2bdoIzFS1Z88eXL58GUFBQY2MZSQZP348Ro4cSTRhkB+qqqo4dOgQevXqJVBdoG6ha/bs2UhOTkbLli3Rrl07fPjwAWVlZRg0aBC2bt1KfAExNzcX5eXlTX5fn2D7p1JYWIg7d+6gsLAQXC4XvXr1ApfLJaJlbGyMpUuX/nBSBh307t0bW7Zs4VtgkJycjDlz5uD27du06wYGBmLs2LG/TBrfn87w4cPx999/Y9u2bY1SJmtqauDs7IzXr18jLi6OwSOknzFjxqBFixbYuXNnIxNdSUkJpk2bhoqKChw9epSI9syZM3H//n34+/s3Kmy4du0aXF1doaGhQcTY5e7ujrNnz8LT0xOmpqZUi+QzZ87Ax8cHxsbGWL9+Pe26QN186MqVK7h79y5ycnJQUVEBLpcLJSUlaGlpQU9Pj0j3Bg8Pj2+aHkglZzGNmpoaoqKi+M5P7t27h7Fjx9J6v/Hs2TMcPHgQb9++Rbt27WBmZob+/fvT9vrN8ebNG8TExODKlSu4d+9eo1Q6BQUF9OnTB8OGDYORkRHROWlOTg5ycnJQXl4OLpeLjh07CsTE9ebNGzx48AAqKiqNEmKjoqKgoqICTU1NIroxMTG4e/cu1NXVMWbMGOo8W7ZsGbS0tP7YZyn82oM/fvwYsrKyRIzAXyKoeTcT59XkyZNx48YN9OrVC87OzsTSvP9XUlJSMG/ePFy/fp321/5VrmOCIDAw8LsLKGfNmgUXFxcix3Ht2rVG85Ly8nJISUlR8xITExNIS0sT0S4sLMT8+fPRs2dP9OvXj2+xKYlOGpmZmZCVlWXEYFzfiWHVqlUC166trUVycjLS0tKoe3cdHR0MGjSIeDoxU9qC1N20aRPi4uLw7t076OvrY8SIERgyZAjfIiW6YUo7Ly8PlpaWqKmpwcyZMzFw4EDIy8uDw+EgKysLFy9exI4dO8DhcHD06FFa5wdMabNjZsdMeswszFNWVobCwkJISkqiZcuWf7wuk9pMjpmFhYWFCViTKAsLy2/Bw4cPsWjRIixatAh9+/b97R/C/izZ2dmIi4uDnZ3dH61dWVmJ5ORknDhxAsnJyaioqCBuTn3z5g14PB54PB5evHgBERERDB48GKNHj6bVDGRiYoJZs2Z9M7UnJiYGgYGBSExMpE27noEDB8LR0ZFKmWlIREQEdu7ciYsXL9KqmZeXhw8fPjRJfnj06BGCgoLw/PlzyMjIEEvWPHnyJJYuXYqKigrIyclBXl4etbW1eP/+PbKzsyEuLo61a9c2SoD8U1i1ahXOnj0LDocDXV1dvgsfnp6etGreuXMHbm5umD9/PgwNDYneZOvp6SE8PBwaGhpYvHgxnJ2dGU08vnz5Mq5evYqCggJISUnBwMCAbwt6usjPz8fq1atx+vRpVFVVNdpWW1sLDocjcHO/oKitrcWGDRuwb9++Rgu4YmJimDx5Mtzc3GjX3LVrF5KTk7Fr1y6Ii4vT/vpfo1+/fnB3d+dbNBEdHY0NGzbg6tWrRI8hKysLWVlZUFVVxV9//UVEY/Xq1T+0P93XL6bp1asXAgMD+aY/X7hwAbNmzfrjCjnS09Mxbdo0CAkJoW/fvlR66rVr11BdXY1du3ZBW1ubiPaHDx/g5OSEBw8eoHXr1mjTpg3y8/NRXFwMNTU1BAcHEzFIl5SUYMmSJThz5gwAQEREBFVVVaitrcWQIUOwdu1aKpGP5ffna0UsqampcHR0xM2bN2nRunHjBuzs7FBVVYW2bduioKAANTU1WLZsGd/kWpIUFhZSZp/fNWmPhaUhv8K8WxDnVf09e8uWLb9pYuJwOEhLSyNyHM0RGBiIgwcP4tKlS8S1/uTr2KNHj/Dw4UPU1tZiyZIlcHJyapKQVd854MvEyz+Fd+/eYeHChbh582aTzzrJc3rTpk2YPXs232fceXl58Pb2xtatW2nXBYBjx45h48aNUFdXx6BBgyAjI9Nk7EOHDqVdt7CwEI6Ojrh9+zYkJSWp+X5RURE0NTUREhLy1Y4wv6M2U7p37tzByZMncerUKZSUlGDQoEEYOXIkBg0aRPw6xoT2q1ev4Orqirt37/I9j3v16gU/Pz8iCYBMabNjZsdMeswAMGXKFHh7e0NZWbnJtoyMDHh7eyMiIuKP0mZyzF9b08jMzERgYCCRolqmdJnUZnLMLCwsLEzDmkRZWFh+CyoqKrB69WocPnwYQkJCTQwZTDyQZiHHtWvXcPLkSZw5cwZFRUWQlpbGiBEjMHr0aNrbSgF1D19PnTqFkydPUulrPXr0wL179xAaGkqk/VKPHj2we/du6OjofHW/+gXeu3fv0n4Ma9euxaFDh7BkyRKYmZlBUlKSSo1du3Ytxo0bBw8PD1o1PT09cf/+fRw7doz6XWZmJkaOHImysjKoqKjg/fv3KJ2MqxMAAQAASURBVCgowJ49e2hruQkAz58/x+jRo6GtrQ0vL68mN/pPnz7FqlWrcOvWLRw/fhxKSkq0af8KfMt0y+FwcPbsWVo1+/Tpg8rKSlRXVwMAWrRo0eiBFp3X7p49e2LPnj3Q0tL6alLXn4qLiwtSU1MxZcoUKCsr801/MzU1ZeDIyBMcHIzAwEBMmzYN//zzD2RkZPDx40ecOnUKu3btwpw5czBjxgxaNVetWoWEhARUV1dDT0+P76IaKdPi4sWLkZycDD8/v0bfTykpKXBzc4OhoSF8fHyIaEdFRSEwMBA5OTngcDg4cuQINDQ04OLiAj09Pdja2tKmxe+alZWVBRkZmSafbxLXL6YZO3YsLC0t+SYxR0ZGIjo6GtHR0QwcGVk+fvyI3bt3486dO8jJyYGsrCx69eoFW1tbWlueN8eFCxeaaPMz6tLN8+fPKd127dqhZ8+efBckWH4/bt26RRk/fX19MXny5CYJg+Xl5Th79ixqampoO69tbW1RUFCA7du3Q15eHiUlJVi8eDGuX7+Oa9eu0aLxq5OdnY3s7Gy+KY903mPw49WrV3j58iVfbRKmm4aUlpby1ZWSkiKmmZqaiqioqGbHfPLkSSK6RUVFSEhIQEZGRqNCoXpIzcX+K/PuwMDAH9p/1qxZtB8Dv6KhiooKvHjxAmlpabC3tydSEPZf5dixYxg8eHCTdN4/ncmTJ+PNmzeYPn06FBUV+Z7TDZPm6aJPnz5QUlLC+vXr0bVrV+r3Z8+ehZeXF1q0aIFz587Rrgvgm89WSRljlyxZgqSkJPj5+TVKN798+TLc3NxgZGSENWvW0K7LpDaTYwbqTGRXr15FbGwsTp8+jdraWsycORMODg7ENJnUvnHjBlJTU5GdnQ0AkJOTg56eHrFiw19Bmx0zO2aSfK3Q8e7du/j333/x4MGDP0r7Vx0zie4jTOsyqc3kmFlYWFiY5r8dxcfCwvLb4O3tDR6PhyFDhkBJSYlI60MWZvmytXvLli0xYMAAnDlzBps2bSKykHfixAnweDykpKSgqqoK3bt3x/z58zFixAhISEgQa7MJAK1ataJajn+NgoICYiltCxcuxLt37+Dl5YVly5Y1Sq8aOnQoFixYQLtmeno6rK2tG/1u9+7d+Pz5M3bu3IkBAwagrKwMdnZ22LlzJ61/98jISHTq1AkhISF8K9e7deuGXbt2YfTo0di/f/8fl0pHanHha9jb2xNvF1aPoqIiQkJCMHToUKqV14sXL5rdn3TLTUEbE65duwZPT0+BtRK9f//+D+1Poj1fPYcPH4aTk1OjhWkZGRmoqqpCVFQUUVFRtJtEk5KSqOsIPxM/h8Mhdg3x8PDAs2fP4ODgAAkJCbRt2xZ5eXkoKSlBz549sWjRIiK6u3fvhp+fH+zs7KCvrw97e3tqm56eHuLj42k1iX55zaqqqkKPHj2wfft2op+nX4Vly5ZhwYIFaNmyZZM25OHh4fD392f6EIkgIyMDV1dXxvQHDRokEFPolygrK//RptDVq1fD3t4eCgoK35USTOL6WVFRgfPnz0NNTU2gSeOXLl2ijFYcDgd79+5tso+IiAiUlZXh7e1Nm+6TJ0+wYsUKyMvLAwAkJCSwaNEimJqaIisri/r9n8ibN2/g5uZGFf99WRtPMuWxpKQELi4uVPvreu2G82ES2rW1tQgKCkJUVBRycnL47kNqzBcvXsSMGTOgr6+Pe/fuYdCgQSgrK0N6ejrat29PzJD78uVLjB8/HhUVFSgtLUXbtm1RWFiIqqoqcLlcSEhIEJuLCXrezRQkTJ8/Cr97WHFxcbRv3x7e3t4YO3YsA0f15/KtTjd/Knfu3IG/v7/Azd3Hjx+Hu7s7rKysMHfuXIwdOxZr1qxBTEwMLC0tsXTpUmLaTBXYnTt3Dm5ubo3MkgDQv39/LFiwAH5+fsQMk0xpMzlmoG4Ooq+vTwVuHD16lJojkYYJbR0dnW8GMtRTn6A8e/bsJkVcv5M2O2bB6TKpzeSYm+PmzZuMtbhnSpvJMb969Ypo4d+vpsukNpNjZmFhYREErEmUhYXltyAhIQEeHh6YOHEi04fCQjPBwcFUa3dhYWEMHDgQixYtgrGxMSoqKnD69Gli2u7u7uBwODAwMICHhwe6detGbSsuLiamC9QlicbFxWHIkCFf3S82NhY9evQgcgxiYmLYunUrHj9+jBs3bqCoqAhcLhfa2tpQUVEhopmdnd3ofQbqzFZqamoYMGAAgLq0yUmTJmH9+vW0al+/fh3jxo37amsjMTExjBs3DkePHqVV+7/K7NmzBabl4eGBJUuW4Pz58+BwONi2bVuz+3I4HGKLukwZEyQlJQWa+GJlZfVdBmBBtNzMycmBlpYW3219+vTBjh07aNdkwnRdD5fLRVRUFJKSkpCWltbo2j148GAICQkR0d23bx+cnZ3h7OxMpQPXo6SkhIyMDCK69QjKcP6rMGXKFFRVVWHJkiVYsmQJVcgB1BnKpk6dSu1LIlH/+fPnuHv3Lt6/fw8rKyvIysri1atXkJaWZtuf00xlZSWOHDlCvd/Lli2DoqIi4uLioKKi8keYR8+dOwdra2soKCh88/pJymQvJiaGhQsXYteuXQI1ic6aNYsyWqmqqiIqKgq9e/cmrpufn4/27ds3+l29MTQ/P/+PNol6enoiOzsbPj4+UFZWFmhr6A0bNuDjx4/Yv38/JkyYgMDAQHC5XJw4cQJXr14lZvDfvXs3du/ejWnTpmHTpk1wcnKCsLAwYmNjUVlZiZkzZxLRBYCtW7fC1tYWrq6u0NDQwNy5c6GhoYHMzEw4ODigX79+RHTXrVuH3r17IyAggGrXq6qqiri4OGzatAkBAQFEdAHBz7v/yzA55/6vwlQyMJP8/fff1DxbkHTu3BmRkZHYuXMndd1q3bo1tm3bBhMTE6LaHTp0IPr6zVFaWgoZGRm+22RlZVFaWvrHaTM55ocPH4LH4+HUqVPIycnBgAEDsH79euKfL6a1v5eamhrExMRg0qRJRI10v5I2O2Z2zN/Djh07qGepHA4Htra2TZ7JVVRUoLq6mm/3m5+BKW0mxxwZGYkDBw5Q2q6urk06aVZUVCAzMxNmZma/vS6T2kyOmYWFheVXgjWJsrCw/BZISkoKdDGPRXAEBARQRs21a9eiXbt21LbKykqi2kZGRrh06RIuX76MWbNmwcLCAiNGjICioiJRXQCYMGECXFxcoKysTC3iNaSmpgZBQUGIj4//qtmNDlRUVIiZQr+Ew+E0usH++PEj3r592yR9Tk5O7ruSVn+ErKys7xqniooKMjMzadX+VcjOzsbu3buRnp6OgoICSElJQVtbG7a2tpCTkyOqnZWVhaysLKiqqhJJx+3fvz+Sk5Px6dMnaGtrIzw8nJjB+mswZUxwcHDA3r170b9/f4iIkJ/iR0REENf4Xjp06IDz5883ar1eT3JyMmMLYCQoLy/H2LFj4e7uDhMTE4EusGRnZ6NPnz58t4mKiuLz588CO5b/AoJMYm5IaWkpPD09cerUKXA4HNTU1GDgwIGQlZWFv78/OnbsCHd3d4Ef15/KmzdvMHXqVOTn50NdXR1paWn49OkTgDqTxsWLF7F27VqGj/LnaWjyYdLw06VLF2RlZTGmf/36dUhKSjKm/1/hzp078PX1Jd7WnR8XL17E/PnzKSNwu3bt0KtXL+jq6mLdunUIDw/Hpk2baNc9cuQIZs+ejYkTJ2LTpk0wNTWFhoYGnJ2d4eTkhNevX9OuWc/z588xf/58CAkJgcPhUGaXDh06YPbs2di6dStGjRpFu+6dO3ewZs0aaq5dWVkJYWFhWFhYID8/H6tXr8bBgwdp1wUEP+9mYREUTCUDM83ixYvh6+uLbt26Cbw4p6qqCvn5+aiqqkKLFi0gIiKCli1bCkS7vgNLWloaCgsLweVyoaOjg0GDBhG7D1FTU8O+ffswYMCARs9Ba2pqsHfvXqirqxPRZVJb0LoZGRmIjY1FbGwsXr9+DR0dHTg5OWHo0KHgcrm0av1K2v8rXxZ2/xe02TH/N7R/RrdPnz6wt7dHbW0ttm3bBnNz8yYFiKKiolBWVoaRkdHPHuovoc3kmNu1a0etYTx9+hRKSkpN0kpFRUXRpUuXJh36fkddJrWZHDMLCwvLrwT7JIuFheW3wM7ODvv27YOBgQH7EP4PY9KkSYiPj8fly5cxfPhwDBkyBBYWFtDX1yeuHRwcjMLCQsTHx4PH42Hbtm3Ytm0bNDQ0YGxsTNScYWJigmnTpiEwMBAHDx6Evr4+VdmZlZWFK1eu4OPHj3BwcICxsTFtui9fvsSCBQswd+5cGBoa8t0nOTkZAQEBCAgIoN2craSkhJSUFCo1NCkpCRwOp0nbpZycHNpbd3z69AmtWrX65n5//fXXH2l2evLkCSZNmoTKykr0798fqqqqyM3NxcGDBxEdHY19+/Y1SXmlg6ioKAQGBiInJwccDgdHjhyBhoYGXFxcoKenR2t7agBo1aoV1q5dC1VVVbRu3ZrW1/4eBGlM+LJl7/PnzzFkyBDo6uryNaHQmcymp6dH22v9LFOnTsXy5cuRl5eHYcOGQVpaGrm5uYiPj0dsbCyWL19ORDcvLw9hYWFU+l9gYCC6deuGPXv2oHfv3tDU1KRdU1xcHNnZ2cTSQr+GgoIC7t69y/f7+fbt2wIpsBAEP5pgTupcF2QSc0N8fX1x9epVhISEQEdHp9Hn2NDQELt372ZNojSyevVqtG3bFocPH4akpGSj4gZdXV1s3LiRwaP781iwYAFVxNGzZ0+B6w8cOBBDhgyBlZWVQO51+KWfAMDEiRMb/Z5EGjGTyMnJMfI9CdTNDeTl5SEsLIyWLVuioKCA2mZoaEjs2p6ZmQk1NTUICwtDREQERUVFAAAhISFMmDABS5cuxYIFC4hoi4uLo6amBhwOB7KyspQpBKibl79//56IbkVFBSQkJCAkJAQul4sPHz5Q27p164ZHjx4R0QWAFy9eCHTe/V8jMDDwh/avT2tm+XmYSgZmGh8fH+Tk5MDCwgLt2rVr8hyBw+HgxIkTtOs+evQIbm5ueP/+PXx8fGBsbIzly5fDwcEBNjY2cHd3R4sWLWjXBYDCwkI4Ojri9u3bkJSUpO6hd+7cSaUzkyhsWbhwIezt7TFkyBCYmJhARkYGubm5SExMxMePHxEWFka7JtPagtb9559/0KpVK5iYmMDd3Z0KY3j79i3evn3bZH8NDY0/QpuFhYU+9PT0qOe+HA4HY8eOJR4uwbQ2k2M2NTWFqakp9bOzs7NAApOY0mVSm8kxs7CwsPxKsE4rFhaW34LXr1/jyZMn/8mH8Ey2+xSEtqenJ5YsWYKUlBTweDycPn0aMTExkJaWhpGRUZPkSbrhcrn4999/8e+//yI7OxsnT55EbGwstmzZAgDw9/fH+PHjMXToUNrTD11dXaGrq4uwsDAkJCSgoqICQN1Cm5aWFlavXt2skfN/JSwsDH/99ddXX9fQ0BC7du1CaGgo7eaqyZMnY9GiRSgqKoKMjAwOHDiAzp07N0kAvHTpErp3706rNpNVw78Cvr6+6NSpE8LCwhpV8BcWFsLe3h6+vr7YtWsXrZq7d++Gn58f7OzsoK+vD3t7e2qbnp4e4uPjaTeJAoClpSXtr/m9CNKY8GUaW/218saNG032JdW+91dg/PjxqKysRFBQEHg8HjgcDmpra9G2bVssXboU//77L+2a9+/fx9SpU9G6dWvo6uri+vXr1DW8PrF38+bNtOsCdabEU6dO8U1OJcm4ceMQGBiINm3aUMbIqqoqnD9/HqGhoZg3b55Aj4cUc+bM+e59ORwOHj58SPBoBE9CQgLc3d0xYMAAVFdXN9rWoUOHPzZpmymuX78Of39/tG3btsn7LSsri5ycHIaOjCx5eXnYs2cPbt++jZycHMjKyqJ3796wtbWlvUioIX5+figoKMC4ceMgJSXVpPUnKRNIPYsWLcLRo0dhZ2eHDh06YMyYMRgzZgyR1u//ZdPU/PnzsXPnTujo6EBKSkqg2u3bt6e6ISgqKuLcuXMYNGgQAODmzZtNWtnRhZSUFFXkpqCggAcPHlBG5Pz8fJSVlRHRBQBVVVVkZGSgf//+0NfXx/bt29GmTRuIiIhg8+bNtN/T1aOoqIjMzEzo6upCXV0dkZGRVFFxVFRUow4ldFNf6Aj89+bdgmDPnj2Nfq6srKQ+w+Li4lQL9BYtWkBMTOw/fb2jG6aSgZlGQ0ODkQR/a2traGlpYceOHVTReH0a9MqVK3H58mUkJCQQ0fb19cXr168RGhraqGj78uXLcHNzg6+vL9asWUO7rq6uLg4cOIDt27eDx+OhqKgIXC4X2tramDlzJlHTIFPaTOh++vQJJ06cwMmTJ5vdp7a2lsj9LJPaLCws9MPkPIspbSbHzFQnGSY72PwXx8zCwsLCNKxJlIWF5bcgKSmJMt38Vx7CM9nuU9DaQkJCGDBgAAYMGICVK1fi7Nmz4PF4iImJQW1tLTw8PDB69GiMGjWKaGWXnJwcpk2bhmnTpuH58+c4ceIE4uLi4OHhgZUrVyI9PZ12TUNDQxgaGqK6uppKmpGSkmrSfp4uLl++/F03ulZWVj+c4PE9jBw5EtnZ2di3bx+KioqgoaEBb2/vRgnBubm5SEpKIpK001yiUkP+VDNpeno6NmzY0KTFE5fLhZOTE9zc3GjX3LdvH5ydneHs7NzE/KKkpISMjAzaNQF8VxLw2bNniWgL0pjAZMveL4mJiUFUVBRevnxJLdw2hMT1syGTJ0/GxIkT8eLFCxQWFkJKSgpKSkrEDLtr166FpqYmgoKCwOFwcPz4cWpb7969cerUKSK6AKClpYWNGzdixowZGDRoEGRkZJp83kmkWzo4OCArKwvLli2Dt7c3AMDGxgYAMGHCBEycOJFWvS+TcuuvzaGhoXxNZHTNA0ldG34XPn/+DFlZWb7b6o0CLPQhLCzc7Lzj48ePtBcoNaSmpgaHDx9GQkIC3r9/3+TazeFwkJiYSLvu7du3MW3aNNTU1MDAwACKiorIzc3Fvn37sG/fPoSFhVGtuulGQ0OjUVqroJkwYQImTJiAJ0+eIDo6Gvv378e2bdugr68Pa2trmJqaQlRUlBatX8E0VVhYiAsXLjT7+XJxcSGie+zYMbx//x7GxsZQU1PjmwgXHBxMRLt///5ISUnBkCFDYGtrCw8PD9y5cweioqK4c+cO7OzsiOhqaWnh7t27MDQ0xIgRIxAYGIiPHz9CREQEhw4dIppca2trS6WDLViwADNnzoSTkxOAOtMsiXtKADA3N6fSQufOnQsHBwfo6elRxULr1q0jogswOwcXZJJ9REQEzM3NIS0tjXfv3kFWVpa2a9TXSE1Npf599+5dzJs3D87OzjAzM4OEhARKSkoQHx+P4OBgbNq0ieixMHUdYwqmkoHruXTp0lfnJV8aiOmC5PXia7i5ufEtmjU3N4eOjg7R59znzp2Dm5tbk64+/fv3x4IFC+Dn50fEJAoAPXr0IPbd8KtqC1I3IiJCIDq/mjYLCws5Xr16haNHjzb7zHf79u1/nDaTYy4qKkJCQgIyMjKoQIKGkJofMKXLpDaTY2ZhYWFhEtYkysLC8lvwKxlhBAWT7T6Z1BYTE8M///yDf/75B8XFxVQr+KCgIGzbtk1gVcbKysqYP38+5s+fj5s3byI2NpaonrCwMKSlpYlqAHUJd99jtO3YsSOys7OJHMP06dMxffr0ZrdLS0sjJSWFdt1fYbGcSYSFhfne7AJ17RpJGJOzs7PRp08fvttERUWpxCO6MTExaWKaKyoqwvXr1wEAQ4YMIaILMGtMYIrjx4/Dy8sLlpaWuHnzJqysrFBTU4Nz585BUlJSYGkzQkJC6Nq1q0C07t69i61bt0JUVLSJAbpt27bIzc0lpr148WIAQHJyMpKTk5tsJ5nI4enpCVtbW6SkpCA/Px9cLhf6+vpEWs3zm/spKCjg1q1bTX5PZ7FQhw4daHmd3xUVFRWcPn0aAwYMaLLt/PnzRA1248aNw9ixYzF8+HC0atWKmA4/7t27h+LiYspIVVhYiA0bNuD58+cwMDCAi4sLEdO5rq4uwsPDMWjQIOr16w1OpI1dGzZsQHh4OHR1ddG3b1+BGH8AYMWKFejatSt27tzZqDNBcXExpk+fjpUrVyI6OpqINlMmkC/p3r07Fi9eDDc3NyQlJSE0NBQLFiyApKQkRo4ciYkTJxK5rgqSS5cuYc6cOfj8+TNatGjR5PNF0lz16dMndO7cudHPgsLV1ZUy1I8ePRqtWrVCfHw8ysvL4eXlhfHjxxPRnTVrFnXvNnPmTBQVFYHH46G8vBwGBgbw8vIiogugUYcKOTk5HD16FK9evUJZWRm6dOkCMTExIroNDbeamprg8Xi4ePEiysrK0K9fP2IJpkwi6CT7+qIoaWlpmJiYICoqCr169aLt9b+HVatWwcHBAVZWVtTvJCQkYG1tjfLycqxcuRJHjhwhos3kdYwpmEoGBoBdu3bBz88PHTp0gLKycpP76D+Rr3VVkZOTw86dO4lpl5aWNklUr0dWVpbW4rCamhqcP38enTp1Qrdu3fju8+TJE7x9+5bqKPW7azM55vp2yf8LMTExMDIyalJc/jtos7CwkOHOnTuYPHkyFBQU8PLlS6ioqKC4uBiZmZlo3759o/uuP0WbyTG/fPkS48ePR0VFBUpLS9G2bVsUFhaiqqoKXC4XEhISRIyLTOkyqc3kmFlYWFiYhjWJsrCw/BY8f/4cysrKTB+GQGGy3eev0mq0devWGDt2LMaOHYvs7GzExcUJRPdL+vTp06zR7XejVatWVAvEr1FQUEA0vYoJ/usmUQMDA2zevBlqampQUlKifv/y5UsEBAQQaV2toKCAu3fv8jW53L59m5gBYunSpXx/X1FRARcXF3Ts2JGILsCsMaF+cTg9PR0FBQWQkpKCtrY2bG1tIScnR0w3PDwczs7OcHR0xKFDhzBhwgRoaGigpKQEDg4OAjF7vXjxAqdPn242dcbHx4dWvZYtW6KkpITvtnfv3hFNkWU66bJTp074999/iev8KgVCtbW1SE5ORlpaGgoLC8HlcqGjo4NBgwYx0paSNPXpz6WlpRg2bBg4HA7u3LkDHo+H6OhooovVCgoKWLVqFXx8fDBs2DBYWVlR6VWkWbt2LfT19anvKx8fHyQmJqJ///4ICwuDkJAQESOIq6srbGxsYG5uTqVg79+/H0+fPsWrV69w+PBh2jXrOXnyJGbPni1wg8uzZ88QEBDQyCAK1M37p0+fjvnz5wv0eJiipqYGFy9exPHjx3Hv3j3IyMjAyMgI586dw4EDB7Bs2TKMGzeO6cP8n/H19UXPnj3h4+MjcPP93r17BarXkJYtW6Jly5bUz0OGDCFanFRPly5d0KVLFwB1RZeenp4CWdAqLy/H2LFjqWcHQN28SxAm59TUVKirq1PzTHl5eeqc+fTpE1JTU6Grq0ub3unTp9GvXz9ISkri9OnT39yfRKq7oJPspaSk8ObNG/Tq1YuxbhuPHj1q9t6tU6dOePr0KTFtJq9jTMFUMjAAREZGYtKkSQJbjF+9ejXs7e2hoKDQpIMBP0gdlyDTgRuipqaGffv2YcCAAY0KhmtqarB3716oq6vTpnX06FGsW7cOPB6v2X0kJSXh7u4OT09PjB49+rfXZnLM/yvV1dVYvHgxjhw5InCjJpPaLCwsX2fDhg34559/sGbNGmhoaFD/TU9Px8KFC78aBPK7ajM55nXr1qF3794ICAiApqYmQkJCoKqqiri4OGzatAkBAQF/lC6T2kyOmYWFhYVpWJMoCwvLb4G5uTk0NTVhbW2N4cOH/3HmNX4w2e7zV2w1KicnR6w933+JHj16IC4u7puLlbGxsYy242ShHw8PD0yaNAnm5ubo1q0bZGRkkJubiydPnkBeXp5KJ6STcePGITAwEG3atKEWSquqqnD+/HmEhoZi3rx5tGt+DTExMUyaNAne3t6YPHkyEQ2mjAlPnjzBpEmTUFlZif79+0NVVRW5ubk4ePAgoqOjsW/fvmYTLH6WV69eQUtLC8LCwhAWFqbMkxISEpg+fTp8fHyIXr9jYmKwZMkSiIuLQ0FBgW/KD90MGDAAwcHB0NfXh6SkJKVTVlaGiIiIRqladCPIRep379790P4KCgqEjoQZCgsL4ejoiNu3b0NSUhLS0tLIzc3Fzp07qQeI9X//P4XBgwdj48aNWL9+PU6ePAmgLvmxffv28PPzI5psuXnzZhQWFuLEiRM4duwYJk2ahL///htWVlYYPXo02rVrR0z72bNncHR0BACUlZUhISEBXl5esLKywv79+xEREUHETKmsrIzo6GgEBgaCx+NBWFgY58+fh76+Pvz8/IgmVFRUVEBLS4vY6zfH33//jaKiIr7biouLvyvx/mdgup3Yy5cvER0djZiYGOTl5WHgwIEICAjA4MGDISwsjNraWvj5+SEgIOC3Nom+efMGHh4e/xljFT9yc3P5tib8k74rxcXFkZ2dTSRp+VtMmTKl2WTLjIwMTJkyhdZk9Tlz5uDQoUPo1asX5syZ89V9SaW6CzrJfvDgwVi0aBH8/f2p1MzmkmE5HA4SExNp1Qfq5r0HDx7EwIEDG83pa2trERkZSfR8+i9ex5hKBgbqCpVNTEyIvf6XnDt3DtbW1lBQUPhmcRqdXQsaIuh04IYsXLgQ9vb2GDJkCExMTKjnQ4mJifj48SPCwsJo0zp+/DjGjx+P9u3bN7tP+/btMWHCBERHR9NqmGRKm8kx/wxMFQQwpS0sLIyIiIhGhfR/ujY7ZsHyJ4z58ePHcHR0pOb79fc3WlpamDVrFvz9/TFw4MCf1vmVtJkc8507d7BmzRpqzlVZWQlhYWFYWFggPz8fq1evxsGDB/8YXSa1mRwzCwsLC9OwJlEWFpbfgh07duDo0aNYsWIFlS5kbW3NyMKmoGCy3SeT2ixkmTBhAlxcXKCsrAwnJ6cmLcZramoQFBSE+Ph4bNu2jaGjZCGBgoICTp48iejoaKSlpaGoqAiKioqwsrLCmDFjiKQ9Ojg4ICsrC8uWLYO3tzcAwMbGBkDdZ3HixIm0a36L/Px8gaZ7CgpfX1906tQJYWFhjZIXCgsLYW9vD19fX+zatYuItoSEBLWYJScnh2fPnqFv374A6hIhvie9+GcIDg6GmZkZfHx8GqV3kcTNzQ02NjYwMzND3759weFwsHnzZjx79gwcDkcgBujs7GxkZ2fzNaDQlZz1vQu1tbW1RNvcM4Wvry9ev36N0NBQ9O/fn/r95cuX4ebmBl9fX6xZs0Zgx5OWloYXL15AW1ubSowjwbBhwzBs2DBkZGQgPz8fXC5XYIn+XC4XkydPxuTJk/Ho0SMcOXIEYWFh2LJlCwYMGABra2sYGxvTbkgqKyujrh/p6emoqKigPv8qKip4//49rXoN6dSpE3x9fYm9fnNYWFjg3LlzRI2//HBzc8PKlSshLy/fqCXltWvXEBgYSLQtNtPtxGxsbHDr1i3Iy8tj/PjxsLa2bpL0zeFwYGZmhtDQUGLHIQjU1dWRlZUlML3w8HBYWFhARkYG4eHhX92Xw+Fg6tSpRI6jfjHp9OnTqKqqarSN5HdlTU0NDh8+jISEBL6p6gC5JPKhQ4fi1KlTRLoSfI2vmUlKS0vRokULWvXOnj1LFdIyleou6CT7lStXQktLCy9evEB4eDh0dXWbbU9NioULF2Lu3LkYOnQojIyMqIKdpKQkvHv3jmjCj6CvY0zDZDIwABgZGSEtLU1g85KGxlCmOhgIOh24Ibq6ujhw4AC2b98OHo+HoqIicLlcaGtrY+bMmdDQ0KBN68GDB5gxY8Y399PT00NkZCRtukxqMzlmFiArKwuJiYnIysr6ZlFYw/uR31mbHTM7ZlK6HA4HoqKi4HA4kJaWxrt376g12fbt2+Ply5e06PxK2kyOuaKiAhISEhASEgKXy8WHDx+obd26dcOjR4/+KF0mtZkcMwsLCwvTsCZRFhaW3wJDQ0MYGhqioKCASheaMGECFBUVYW1tjdGjRwv8YTVpmGz3yaQ2C1lMTEwwbdo0BAYG4uDBg9DX16fSN7KysnDlyhV8/PgRDg4OMDY2ZvhoWeiivLwcc+fOhYODA6ZMmYIpU6YITNvT0xNTpkxBSkoKCgoKwOVyoa+vT3SxiV8LyMrKSjx//hz79+9Hv379iGkDwNOnTxEUFES1jIuKioKGhgY2bdoELS0tIimT6enp2LBhQ5PWXFwuF05OTnBzc6Nds54ePXrg8ePHGDhwIIyNjbFt2zbU1tZCREQEISEhxFrk1fPhwwcsX75cYAZRoM4MGxMTg927dyMlJQWdO3dGQUEBLCwsYGdnR7Td/Js3b+Dm5obbt28DaGqSoNOAUltbi1atWsHU1BSGhoZE04N+Rc6dOwc3N7dGBlEA6N+/PxYsWAA/Pz9iJtGFCxdCTEwMa9euBQAcOHAAK1asAFCXirxjxw7ii+hKSkqMpG3U0759e3Tq1AkyMjIoKCjAy5cvMXv2bHTo0AF+fn60Xls6deqECxcuQE9PDydPnoSGhgZ1Hufm5jZpjU6St2/f4vXr11BXVyd6Lenduzc2b96M3NxcGBgY8E3FpatdsoWFRaOfi4uLYWtri9atW6NNmzbIz89HcXExJCUl4efnRyyNmel2YrKysggJCcGAAQO+mnKtpqbGmAmNLpYvXw43NzfIyclBX18fIiJkHz/6+vpCW1sbMjIy3zRdkzSJenp6IjU1FTNmzICysnKTdHNSbNiwgTLx9e3bV2C6QF2izsaNGzFjxgwMGjQIMjIyTT7fdF1Lbt26hZs3b1I/nzx5EmlpaY32KS8vx9mzZ2kvpmiYJslUsqSgk+xFRUUxduxYAEBCQgIcHR2hqqpKq8a3MDU1xZEjRxASEoKzZ88iJycHsrKy6NWrF7Zs2QI1NTVi2oK+jjENk8nAAGBlZYXly5ejvLy82XkJncbFXwFBpwN/SY8ePRAYGEhUA6h7FvM995FiYmJ8TU+/ozaTY/6vExcXB3d3d9TW1qJt27Z8O82QKgpjSpsdMztmkrrKysp48+YN+vXrB01NTYSFhaF79+7UM1+SnUCY0mZyzIqKisjMzISuri7U1dURGRkJAwMDiIiIICoqiliHHaZ0mdRmcswsLCwsTPNnP91gYWH545CSkqIMTg8ePMDatWvh7++PzZs3Y+DAgbC1tSVu/hEUTLb7ZFKbhTyurq7Q1dVFWFgYEhISqAeS4uLi0NLSwurVq4m2SmYRPOLi4khNTSW2IP4tOnfuTLRl7pc01wJSREQEQ4cOJZoSdvnyZcyYMQMaGhqwsLBAcHBwI/0DBw4QOb+EhYWbXVyoqKhokhpMJzNmzKDaks+ZMweZmZnw8fFBTU0NevbsiZUrVxLTBgAdHR08efJE4N9NkpKSmDNnzjdbjtKNp6cnsrOz4ePjA2VlZaLGzbCwMPB4PJw5cwbnzp2DqakpLCwsoK+v/1WD059CaWlps0VIsrKyKC0tJaadlpYGd3d36ueQkBCMHTsWHh4eWL58OQIDA4l85jdt2oT8/Hy+5+2yZcsgLS2NuXPn0q7bkIsXLyI6Ohrnzp1Dq1atMHLkSAQEBEBZWRmvX7/GihUrsGTJEsTFxdGmOXXqVHh6euLIkSMoLCzE+vXrqW3Xr1+HiooKbVoNWbduHaqrq7F06VIAwJkzZzB//nwq2TI0NJRYgn/95+vdu3d830s6DecaGhq/xDWD6XZiW7Zs+a79REVFf/v2xv/++y+qqqqoNn3i4uKNtnM4nCbmvp+hYcoHk4kf165dg6enp8Dbxp48eRKzZ8+Gi4uLQHUBYPHixQCA5ORkJCcnN9lO57Xk0qVLlKGJw+Fg7969TfYRERGBsrIy1cWAJBcuXKCKwpycnKCgoIDU1FR07ty5SUowHTCZZM9U0iJQZ5zftGmTwHUFfR37FWAqGRgA7O3tAQA7d+7Ezp07G80bSCQx5+Xl4cOHD02Mz48ePUJQUBCeP38OGRkZ2NraEiugFnQ6cE1NDc6fP49OnTqhW7dufPd58uQJ3r59CyMjI9rmbvLy8njw4ME3U+3u378PeXl5WjSZ1mZyzP91Nm3aBFNTU6xatQqtW7f+T2izY2bHTJJx48ZRz3wXLFgAe3t7jBo1CkDd99j33uP+TtpMjtnc3Jy6n60P/NDT0wOHw0FtbS3WrVv3R+kyqc3kmFlYWFiYhjWJsrCw/HYUFRXhxIkTOHr0KB48eICePXtiyJAhuHDhAuzs7ODi4oJZs2YxfZj/x96Zx9WU/3/8ddtTKm2SLZOllEhqWiSyRTJSlkFll6SxtM5EiGyVpUSFkjBRGEKIxiDGLsvYkq1SqZS01/390aPz67o3Zr7O55zkPP+q8znd1/l07z3nc87n9Xm9aYHNcp9sarcUmCrrygaN6bx1dXV4//49gAYTNkkjGQe7WFhY4PLly4wb6WtqanDkyBHcvXuXSn7p168fxo0bRyzlSFT6lrS0NFRUVIibVEJCQjB69Ghs2LABtbW1AiZRXV1dHDp0iIiuubk5Nm/eDF1dXYHkvxcvXmDLli1EJ/r69etHJfopKChg+/btqK6upsq2kGbJkiXw8vKCtLQ0LCwsRD4sJZXG9+HDBzx+/BgFBQVQV1dHz549iT+szcjIwPr162lL5foc5ubmMDc3x4oVK3DhwgWcOHECbm5ukJeXh42NDcaMGUM8KZZNdHV1ER8fj4EDBwpcH+vr67F371707t2bmHZRURG1av3p06fIzc2Fs7Mz5OTkYG9vT8yomZycjIULF4psMzIywrZt24hpb968GX/88Qfevn0LExMTrF27FsOHDxcwQnfp0gULFizA1KlTadV2dHRE165dce/ePfTu3VvgWtm4SI0EZ8+eFTCah4aGwsrKCr/88gs2bNiAzZs3Y+fOnUS0mUyqbCkP19kuJ3by5Enk5ORg9uzZQm27du2CpqYmRo0aRfQYmGLmzJktwhjMNAoKCmjXrh3jutXV1VQJRKZh8lzi7u5OPevR0dHBwYMHYWBgwJh+I0VFRXBzc8Pdu3fRoUMH5ObmYvLkydDU1ERSUhJkZWWJmFTZTLIHgLy8PMTGxuLWrVt4//49lJSUYGRkBBcXFyKm2Kbw+XxkZWWhpKQESkpK0NLSIn6O+R7PY0wmA39KXFwckddtjtDQUDx48ABHjhyhtmVnZ2Pq1KmorKxEr1698PTpU7i7u2PPnj0wNjam/RiYTgc+fPgw1q1bh+Tk5Gb3UVBQgLe3N60LHoYMGYLdu3fD1tYWampqIvcpKChATEwMbG1tadFkW5vNPn/vFBUVYdKkSYwbB9nU5vrMLN9bn5teC7S1tXHy5EncuXMHlZWV6NevH1RUVFqdNpt9njFjBvVzv379kJycjIsXL6KyshKmpqbo2bNnq9JlU5vNPnNwcHCwDWcS5eDg+Ga4fPkykpKScO7cOUhLS8POzg5BQUHUqu+5c+ciNjYWERERrcYk2gib5T7Z0M7MzKQSORwcHKCmpoaXL19CRUWFmOGoJZR1ZQNxcXGiN7YcLQcHBwcsX74cHz9+hJWVlUjDJN3l27KysjB79mzk5uZCR0cHKioq+Oeff3DkyBFs374dO3fuJGLAZjN96+nTp1i6dCkACP1/FRQUUFxcTETX19cX06ZNg62tLXr06AFVVVUUFhbiyZMn6NChA5XyRBo+n4/8/Hyi5+tPsbe3B9BQErK5iVw6U2eABpPg5s2bsXfvXoE0SVlZWUybNg2LFi0iZrpv374942UgpaSkMHz4cAwfPhzl5eVITU1FcnIypk6dCjs7uxZjAKObpUuXYubMmRg+fDiGDh1Kfa9SU1Px7t077N69m5i2kpISsrOzMWDAAFy8eBFqampU4k9dXR3q6+uJ6Obn5zebZqOhoYG3b98S0QWAxMRE2NvbY8KECZ9Nn/7hhx8QFBREu76xsbFIA0Bzplk6KCgogKamJgDg1atXyMrKwsaNG9GzZ084OTnBx8eHmHZLSKqsrKxEaWkpFBQUICMjQ1yP7XJikZGRcHBwENkmIyOD6OjoVmMSJfm9+TewsUgJAGbNmoW9e/fCwsKC0dLUdnZ2OH/+PCv3q2ydS9hMjF2zZg2Ki4uRnJyMrl27CiQ+m5mZCSwSoxu2kuyfPHmCadOmoaamBhYWFtDR0UFhYSF+//13JCUlIT4+vtlkwq9l3759iIiIQFFREZUoqaKiAjc3N0yZMoWIJsD+eYwNmEwG/pQvJS7Sza1bt+Do6CiwLTY2FuXl5YiOjsbAgQNRWVmJGTNmIDo6mjaT6NChQ7Ft2zbo6Ogwng78xx9/YPLkydDQ0Gh2Hw0NDUyZMgVJSUm0mUTnzp2LU6dOYfz48XB1dYWlpSU6dOgAHo+H3NxcXLx4EZGRkRATE8OcOXNo0WRbm80+f+9YWlrizp07rIyJ2NLm+sws32OfmyInJwcLC4vvSpvNPnfo0AETJ078bnTZ1GazzxwcHBxMw5lEOTg4vgmGDBmCt2/fon///li5ciVGjRolVOoJaCg5W1paysIR0k9LKPfJNBUVFfD398epU6fA4/FQX18PS0tLqKmpISQkBJ06dRIovUonbJV15eBginnz5gEA9u/fj/379xMv3wY0nKskJSWRkpIiYPh5+fIlXF1dsWLFCiKJIffv38eHDx+o72xJSQk2btyIzMxMmJubY8GCBcRMdp8mkzXlxYsXzaZIfC2ampo4fvw4kpKScPPmTZSWlkJLSwsODg4YP3485OTkiOg2cvHiRYSFheHhw4eoq6tDYmIi9PT04O/vDxMTE4wdO5aYdlBQEOMpPxs2bEB8fDzmzp2LkSNHQlVVFe/evUNKSgqio6NRU1MDX19fItqLFy9GdHQ0BgwYQDwxShSFhYXIyclBTk4O6uvriSWmnTlz5j/tTyLVyNjYGAcOHMCOHTuQnJyM0tJSKCoqwsjICK6urrQb65syaNAgBAcH49GjRzhy5AhV2gpoMKN36tSJiK6ysjKePn2KH3/8Uajt6dOnUFRUJKILAH/++ee/MlUpKSlR5nA6qampQWJiIrVQafny5dDS0sLJkyfRq1cvIon6bdu2RWFhIYCGBXGKioqU2UhKSgpVVVW06r1//x4KCgoQExOjkuQ/B6lzTFpaGsLDw/HPP/9QYxBdXV14eHjQnprVFLbLib18+bJZE5W2tjaysrKI6n8vsLVICQCeP3+OzMxMDB8+HMbGxlQyXFP8/f1p1+3bty82b96MwsJCmJubi9QlnUDOdOn1RqqqqvD69WuR50tS1+kLFy4gMDAQ2traqKurE2jr0KED8vLyiOiyyfr169G5c2fs3r1bYCxQUlKCmTNnYv369USSrxMSEhAYGAhbW1uMHj2aGnOfPHkSgYGBkJSUxIQJE2jX/V5hMhmYbfLy8oSuyWlpadDV1cXAgQMBNCzgmDZtGjZs2ECbbnZ2NqqrqwEwnw788OFD6rnQ5zAxMcH+/ftp01VWVkZcXBw8PT0RGBgodO/O5/NhYGCA4OBgKCsr06bLpjabff5fERMTg7u7O/FFU6S1V65cicWLF1NJcKLGRKTGB2xpc33m+ky37v379zFr1ixs2LCh2fvzCxcuwNvbG3v27KFCfL5lbTb7/OLFCyxZsgS//PLLZ7W3bNmCLVu2oHPnzt+0LpvabPaZg4ODoyXBmUQ5ODi+CWxsbODo6PjFyVl9fX1WEyXohM1yn2yxfv16XL16FVFRURgwYIBACVsrKyvExsYSM4myVdaVg4MpmC7fBjSUxd6wYYNQIlzXrl3h4eFBzES3du1amJmZUSbRoKAgpKamwsLCArt374aYmBgWLFhARHvYsGEICwtD37590bVrVwANiSsFBQXYtWsXRo4cSUQXaFjZ7OzsTKwscnMkJyfDy8sLo0aNwoQJE7Bs2TKqrUuXLjh8+DBRk+j48eOJvXZzHDlyBB4eHpg7dy61TUVFBb169YKMjAx2795N6+fb1dVV4Pe3b9/C2toaurq6QqWmeDwe7QlW+fn5OHnyJJKTk3H//n3o6enBwcEBo0ePJmb8+C8JWSRTjfT19REeHk7ktT+Hj48P6urqcOnSJVhZWQmMCc+ePUtNXtNN4znMwMBAoIRvRkYGtm3bRjTlsKlBtLCwUKThpzF1k25ev36N6dOno7i4GL1798bNmzfx8eNHAMD169dx8eJFKm2eTgYMGICtW7eisLAQu3btwrBhw6i258+fN5vq+r9iZmaGhIQEGBgYwNTU9IsGexLfq9TUVCxcuBB9+/aFr68vVFVVUVBQgJSUFMyfPx9bt24V+D/QiahyYn/99ReqqqoYKScmLS1NmYI/paCggNHkSRK4urrC19cXWlpaQtetTyFxrWqErUVKQIPBqPF7dePGDaF2Ho9HxCTaeI+ck5ODkydPitQldZ1kq/R6dXU1VqxYgWPHjgkZNRsh1ee6ujq0adNGZFtpaSmxtNrKykpERETg9OnTePv2LWU0awqpPt+6dQsbN24UWiyiqKiI+fPnw8vLi4hubGwsnJyc8NtvvwlsHzp0KJSVlbFr1y5aTaIt5TzGFkwnA/fv3x9xcXHQ19eHoaHhF8clt27dok2bx+MJ6L179w5v3ryBi4uLwH7t27cnVg0EYDYduKamBlJSUl/cT0pKSuT55Wvo2rUrDh06hBs3buD69euUmb59+/YwMTGBkZERrXotQZvNPn/K48eP8fbtW5H3V42LSHg8HpHKbExrf/z4ERUVFYiMjERUVJRAG6kF8mxrc33m+ky37p49e2BoaPjZBZxWVlYwMjJCTEwM1q9fT4sum9ps9nn37t1o06bNF7V37tyJXbt2YcWKFd+0LpvabPaZg4ODoyXxbT+B5uDg+G4gWWqxpcJmuU+2OH36NLy9vTFw4EChiZ6OHTsiOzubmDZbZV05OJiC6fJtAKCurt7sRA+Px4OqqioR3WfPnlHmvcrKSpw+fRrLli2Dg4MD9u3bh7i4OGIm0aVLl+LevXsYO3YsZTb59ddf8fr1a3Tr1o3IQ3cA0NXVpYw/n3L//n1MmDCB2APSiIgIuLi4wNfXF3V1dQIm0R49emDPnj1EdD+lpKSEMvkPGjQIioqKqKqqgqSkJO3JsXV1dc2u0NfT02vWrPC/0mhWa6Sp6eXTNjpJSEjAiRMncPPmTWhpaWH06NEICQmhDNAk+Z6SjETRtm3bZk2JBw4cIKa7aNEi3Lp1C5MmTYK2tjbU1dWRn5+PzMxM6OrqYvHixcS0i4uLsXr1apw5cwa1tbUCbaQnelavXg1lZWUcOnQICgoKAqWDjY2NERoaSkT3119/hZeXF4KDg6Gnpyfw/z127BgGDBhAq15QUBCVhMBGCjMAhIeHw9bWFsHBwQLbXVxc4OnpifDwcGIm0U/p0KEDJk2axIgW0PBZioqKgrW1tYDBrLy8HDt37mRlrEYnHz9+pK5/JK9NX4KtRUoAcP78eWKv/TnYvGayVXp927ZtuHz5MtatWwdPT08sX74cbdq0wbFjx/Dq1SuB8SjdGBgYICkpSeTk4okTJ9C/f38iuitXrkRycjLGjBkDbW1tYmZUUYiLizdrGquuroa4uDgR3Tdv3mDIkCEi2wYPHozff/+dVr2Wch5ji5ycnC/uQ+eCnZkzZ1KVNmbOnMnouKRbt25IT0+nFl41mvw/LSdbUFDQYpIev5YOHTrg4cOHXxxvPHjwgPaFSo0MGDDgX49v+Xw+fv31VyxcuJCWzx1b2mz2+cmTJ1i0aBGysrLA5/OF2kneX7Gl7ePjg9zcXCxbtgxaWlqMXivZ0ub6zPWZbq5du/av5mPHjBlDq1mSTW02+3z58uV/NV/g4OBA6yJ2tnTZ1GazzxwcHBwtCc4kysHB0WIpKipCfn6+UHT/o0ePEBERgczMTKiqqsLFxQXW1tYsHSU52Cz3yRbl5eXNlmKuqKggqs1WWVcODjZgKqFtwYIF2LJlC3R1dQXKc7x+/RphYWHEDJOVlZWQlZUF0JA2Ul1djaFDhwIAevXqRdRk37ZtW/z+++84duwY0tPToaSkBEVFRUydOhU//fTTv0ru+F8Q9dC9kbq6OmITt0DD+9ncClxZWVl8+PCBmDYA1NfXY/Pmzdi7dy8qKirA4/GQmJgIRUVFuLu7o2/fvrR/1kaOHIkTJ04ITSICDeaA4cOH06q3d+9eWl/v3xIQEAA5OTnY2tpCV1cXQPMGGB6Ph+nTp9OmzXSSkSjq6+tx6NAhKrHr0/Mmj8dDamoqEe2hQ4di27ZtIktYPXnyBPPnzydiCmrbti0SEhJw9OhRXL16Fe/fv0fPnj3h4uJC9BwGNJRgvn79OubNm8e4+eXatWsICQmBsrKykMlbTU0NBQUFRHTbt2/fbKLhrl27aP9/29vbUz+zkcIMNCSkenp6imz76aefaF/E8eDBg/+0P6myhACwePFiTJ48GcOHD8fIkSMpE/bp06dRU1NDzIzMFE2vVWxdtwD2FimxCZvXTLZKr6ekpMDd3R2jRo2Cp6cnDAwMoK+vj3HjxsHHxwfnz5//bELM17Bo0SI4Oztj6tSpGDlyJDUeiIyMxIULF2gt09yUtLQ0+Pj4YNq0aURe/3OYm5tj8+bN0NXVRbdu3ajtL168wJYtW2Bubk5EV01NDbdv3xb5+nfu3Gn2+dH/Sks5j7GFtbU1oynjTe/RmqukRAonJyf4+PigtLQUqqqqOHDgALp06SL0Wbt06RLtSeMuLi7/yhDL4/Fw8+ZN2nSHDBmC3bt3w9bWttnvTkFBAWJiYmBra0ub7v9KfX09jh49imnTphGrJtDStOnW/e233yAuLo7t27czbqRjSzsjIwMhISGMLTprCdpcn5nle+hzYWEhVXHvc6irqzdbKeNb02azz3l5ef+qrHmnTp1ovbdiS5dNbTb7zMHBwdGS4EyiHBwcLZbQ0FA8ePAAR44cobZlZ2dj6tSpqKysRK9evfD06VO4u7tjz549MDY2ZvFo6YfNcp9s0atXL5w5c0ZkCdU///xTIJWEbr5U1tXS0pKYNluUlZWhvLxc5A1wfn4+5OTkICcnx8KRcZCAjYS2lJQUlJaWwsbGBj169ICKigoKCwvx9OlTqKio4PTp0zh9+jQAesv1de7cGX/99RdMTExw/Phx6OnpQUlJCUDDQx95eXladJpDUlISDg4OcHBwIKpTUFCA/Px86vfnz58LmUGrqqqQlJREdGJDTU0Nz58/h5mZmVDb48ePiU+qbNmyBfHx8fDx8YGZmRlGjhxJtVlbW+PQoUO0m0SNjY2xadMmODk5YdiwYdRnOzU1Fa9evcLixYtx5swZav/GMmr/K58zDJLm48ePOHbsGI4dO/bZ/eg2iTZHRUWFSJN743ecTjZu3IiYmBgYGxvjxx9/ZHRSLTs7u9nErsrKSqJmdykpKUycOBETJ04kpiGKv//+G/7+/hg3bhyjukBDQlpzZvt37941W1aYJKSvVY0wmcIMNJQmzsrKEjnez8rKon0hnIODw78yYpBOqwUAbW1tJCYmYuvWrThz5gzev38PJSUlmJubw93dnZGU5u8BphcpnTlzBqamplBQUBC49jfH144JGnn//j0UFBQgJiaG9+/ff3F/EtdJgL3S62/fvkW3bt0gLi4OaWlplJaWUm1jx47FkiVLsHLlSiLahoaGiIuLQ0hICNavXw8+n48dO3agX79+iI2NJWY2FxcXh5aWFpHX/hK+vr6YNm0abG1t0aNHD6iqqqKwsBBPnjxBhw4d4OfnR0TX0dERERERqK6uho2NDVRUVFBUVIRTp05h165dxKpDfK+ISkwqLS3FpUuXcOfOnWYXedCBs7MzAgICoK2tLdSWlZWFgICAZhfW/C+MHTsWeXl5iI+PR2lpKfT09BAQEAAJif+fLissLERaWhrtBlZbW1toaGjQ+pr/hrlz5+LUqVMYP348XF1dYWlpiQ4dOoDH4yE3NxcXL15EZGQkxMTEMGfOHMaPTxSfWwzbWrXp1H327Bm2bNmCQYMG0faaLV27a9euQs88W7s21+fvQ5tJXQUFBYHnzc2Rn5+Ptm3btgptNvssJyeH4uLiL+73/v17Wp9NsaXLpjabfebg4OBoSXAmUQ4OjhbLrVu34OjoKLAtNjYW5eXliI6OxsCBA1FZWYkZM2YgOjq61ZlE2Sj3WVZWhlu3bqG2thYmJiaQl5fHkydPsG3bNjx79gzt2rXDzz//TGxFuZubG9zc3FBRUQEbGxvweDxkZGQgOTkZSUlJiI6OJqILsFfWlU38/f0hJyeHNWvWCLWFhYWhvLwcISEhLBwZBwnYSGj7+PEjtLS0qMnM6upqtG3blirBSKqE3/Tp0+Hv74/ExESUlJRgw4YNVNu1a9fQq1cvIrpMk5CQgPDwcPB4PPB4PJGTs3w+H+Li4ggICCB2HGPGjEFYWBh++OEHqnQdj8fDkydPsHPnTvz888/EtAHgyJEjWLJkCSZPniyUYNWlSxe8fv2ads3GUrV5eXm4fv16s+0APWXUPmcYJMmjR48Y1xQFn89HREQEEhISmk10JGHsOn78OBYuXMiYAaGqqgoVFRXUxGBZWZmQ8aeqqgqpqan/KuHga2EqdboRBQUFtGvXjshrfwljY2PExMRg0KBBlDGSx+OBz+fj4MGDIk3w/yuurq7w9fWFlpYWXF1dP7svnQsoPoWNFGYAGD16NEJDQyEjI4ORI0dCQUEBHz58QEpKCjZv3ky7OZlOQwkddO3a9bsZX+fm5iI1NRW5ubkir2H+/v60aX36XfrSIqWmqbpfi4eHBw4ePAgDAwN4eHh8dl86jchmZmZISEiAgYEBTE1NGU3/awpbpdfV1NQoY2inTp3w999/UwmAL168IKLZFENDQ8THx6OyshIlJSVQUFCgKhmQ4ueff8Yff/wh0mRPGk1NTRw/fhxJSUm4efMmSktLoaWlBQcHB4wfP57Y4tL58+ejtLQUu3btQlRUFLVdXFwcTk5OmD9/PhHdRp4+fYodO3YgIyMDBQUFUFNTQ9++fTF37lza0yVbAs2lk40fPx5r167FtWvXMHr0aCLa165da/b5QFlZGW7cuEG75pw5cz5rhlRRUUF6ejrtuhMnThQIA2AKZWVlxMXFwdPTE4GBgULXDT6fDwMDAwQHB0NZWZnx4+OgHx0dHRQVFX1X2n5+fli/fj169Ogh0nTeGrW5PnN9ppt+/fohMTHxi9f8pKQk2sf6bGmz2Wd9fX2cPHnyi1WpTpw4QWuIDlu6bGqz2WcODg6OlgRnEuXg4Gix5OXloUePHgLb0tLSoKurSz0Ul5GRwbRp0wQMQK0Fpst9PnnyBLNmzaLMFyoqKtiyZQvc3NwgLi6Ozp0749mzZ/D09ISsrCysra1p1QeAwYMHIzQ0FBs2bMDx48cBACtXroSGhgaCg4NpnaDnAG7cuNGscczKyopY8goHO7CR0MZWiT5HR0d07doV9+7dQ+/evWFqakq1KSkpwdnZmVa9/v37Iy4uDvr6+jA0NPzsJD2dJePs7e1hYmICPp8PFxcXLF++HN27dxfYR1JSElpaWkSNV+7u7nj69ClmzJhBpVTNmTMHRUVFGDx4MObOnUtMG2hY3dvcA9K6ujoiK+1JlPnmaJ7Y2FjExsZi9uzZ2LRpE+bPnw9xcXGcOHECNTU1XzTa/a9UV1cTM7eIIjo6Gtu2bQPQcK6YNWtWs/uSMO8B7KRONzJr1izs3bsXFhYWAilOTODp6UkthGostbpv3z48ffoUL1++xKFDh2jT+vjxI2VoJ7VY4t/ARgozACxduhQ5OTlYtmwZli9fDgkJCdTW1oLP52PEiBFYsmQJrXqNixdaEnw+H1lZWSgpKYGSkhK0tLT+Vdrpt8TJkyfh7e0NPp8PZWVlocVJPB6PVpPop98lJhcpnTt3jirby+T4ICgoiEpKDQoKYu0zxFbpdRMTE9y4cQPW1taYMGECNmzYgOfPn0NSUhKpqakYM2YMEV2gYZLezc0NnTt3hoyMDGRkZKi27OxshIeHN7sA9WuQkZHBzZs3MXnyZJiZmUFBQUGgnXSqu5ycHJydnWm/l/ocPB4Pvr6+mDdvHjIyMlBSUgJFRUUYGBgQX1jy559/wt3dHRoaGkKVA8aPH4/w8HAMHjyY6DG0JKysrLBo0SKsWLGCce3bt29zpkWa6Nq1Kw4dOoQbN27g+vXrVCnV9u3bw8TEBEZGRiwfIQedLF++HD4+PlBTU8OPP/7I6D0WW9pBQUEoKCiAnZ0d1NXVhRL/eDzeF6ukfGvaXJ+5PtOtO3PmTDg5OcHPzw8+Pj5CFQlKS0uxfv16XLlyhfZn/2xps9nnKVOmYMGCBdDW1qaedzalvr4eERERSElJoZ4Zfsu6bGqz2WcODg6OlgRnEuXg4GixNCajNfLu3Tu8efMGLi4uAvu1b9/+X0XEf4swWe4zNDQUqqqqiI6OhpycHDZu3Ah3d3f0798fW7duhZSUFKqqquDm5obo6GjaTaK1tbV4/PgxTExMcP78eWRlZaG4uBiKioqMrMpsNAR8jtZmCiopKWk28UNWVvZflS3k+HZgI6Htr7/+gqWlJSuT1sbGxiITpukuFQc0PEhqNAfMnDmTsf527NgRHTt2BNCQlNa7d2/GyhM3RUpKCtu3b8fVq1eRnp5OnbvNzc2pRCeSaGlp4fLlyyIXEly7dk1owQkdaGpqtjpDT0smMTERCxcuxNSpU7Fp0yYMGzYMenp6cHNzw/z58/Hq1SsiunZ2djh//jxji1SGDRuGjh07gs/n49dff8X8+fPRpUsXgX0kJSWhra0NXV1dIsfAdOr06tWrBX7PzMzE8OHDYWxsLGR+aTw+EmhrayMpKQnh4eFITk6GuLg4/vzzT5iZmSE4OFjoffgamk4osLWYAmAnhRlouGaEhYXh8ePHuHHjBkpLS6GoqAgjI6NWk/T9Ofbt24eIiAgUFRVRxmsVFRW4ublhypQpbB8ebTSeqwMDA2kvxycKNr9LjWOxT38mTdM01PHjxzOm+ylslV5fvHgx9Ryo0RiZkpKCqqoqODk5EU0BP3LkCH7++WfKpNuU4uJiHD16lIhJNDg4GACQk5ODO3fuCLWTNomySbt27USm1ZJkw4YNsLS0xLZt26iUcQDw9vaGm5sbNmzY8F2ZRG/dukX7YvXIyEhERkYCaPj8uri4CN1jVVdXo66urlVdI1sCAwYMwIABA/7Vvo33JgsXLiRWUYCDDNra2ujXrx9mz54NMTExSEtLC7TTuYi5pWjr6emx9qyGLW2uz9+HNpO6AwYMgL+/P9auXUslKnbo0AE8Hg+5ubm4f/8+6urq4O/vT/viAra02ezz0KFDMXv2bISHh+P333+HmZkZdb3Nzc3FlStX8O7dO8yaNYvWOVm2dNnUZrPPHBwcHC0JziTKwcHRYunWrRvS09Op1NC0tDTweDxYWFgI7FdQUMCtKKeBe/fuYfny5dDR0QHQ8OB72LBhmDJlCvUgWFpaGtOmTRMoo0sXYmJimDRpEqKiomBubo5u3bqhW7dutOs0x9ChQ4VutEtLS3Ht2jUA+GIJgm+Rzp07Iz09XaSJ68qVK4xOcnKQh42Etrlz50JDQwP29vYYP368yIlUUtTV1eHu3bt4+/atyBKndCaqNk1aI2FC/Te0hKQ0U1NTgdRWppg+fTqWLVsGCQkJ2NjYAADevn2LO3fuYO/evUQm6a2srGBvbw8HBwdazWOfQ9SkqShITvSwRXZ2NnR1dSEuLg4JCQmqvKyYmBimTJmC3377jbb0wTNnzlA/9+vXD5s2bUJhYSHMzc1FmhZHjBhBiy7QUJKvcRzG4/FgZWXF+BiX6dTp8+fPC/ze+BkXVVKU7uTBT+ncuTPWr19P7PVbGmykMDelV69ejJtCdXR0WCvJDQAJCQkIDAyEra0tRo8eDVVVVbx79w4nT55EYGAgJCUlMWHCBGL6TFJUVIRJkyYxYhBtiZSVleHt27eoqqoSaiNlmmSSc+fOwcTEhHp/2Si9rqamRi3SAhrGgy3BIPny5Uuh5CG6ePToEZHXbemUlJTgr7/+Evmd4vF4xAzBb968ga+vr4BBFPj/8SepVHc2+XTxDtBg0nz+/Dlu3ryJmTNn0qpnaGiImTNngs/nY9u2bbC1tYWGhobAPo0LpIYMGUKrNlu4u7ujffv2//nv2DRq1tfX4+jRo5g2bRpnEv3GCAgIQHJyMoYPH45u3boRXwDYErTXrVvHiE5L0ub6/H1oM607depUGBkZIS4uDjdu3MCDBw8ANAT22NnZwcnJidj9PFvabPbZ09MTxsbG2L17N06fPk3NZUhLS6N///5YvXo1kQVTbOmyqc1mnzk4ODhaCpxJlIODo8Xi5OQEHx8flJaWQlVVFQcOHECXLl2EDG2XLl1Cz549WTpKshw9ehQJCQl48eKFyAmmW7du0aZVWFgo8DC28WcVFRWB/ZSVlSlzBp2IiYmhU6dOKCkpof21/w2//fabyO3V1dVYsGABOnXqxPARkWfChAkICQmBoqIiHBwcoKysjKKiIhw+fBixsbG0l/vkYB62E9pOnDiBxMREHDp0CJGRkRgwYAAmTJiAkSNH0p5C0pQHDx5g4cKFyM3NBZ/PF2rn8XjEDFBlZWUoLy+Hurq6UFt+fj7k5OSaTfD9Wpi8ZjQlJyen2TYxMTHIy8sTTTgdP348SkpKEBYWRiXRLFiwALKysli0aBFGjx5Nu6adnR0OHz6MqKgoDBgwAA4ODrCxsREoN0o3oiZNvxeUlJRQXl4OoCHF9eHDh1S6Z3FxMSorK2nT8vDwENqWk5ODkydPCm0nWXq9MSGupKQET58+RW5uLgYNGgRFRUVUVVVBUlJSyLRAB0ynTn9qEmULZ2dnBAQEiDRNZmVlISAgAHFxcbRoxcTE/Ot9SabCMZnC3Di58m8hZaLz9fUVuSjs8uXLyM/PJ15COTY2Fk5OTkL3HUOHDoWysjJ27drVakyilpaWuHPnDmNJzE0JDw//4j6kzF15eXn49ddfkZ6eLtTWmBxL4rpRU1ODmJgYpKSkIDc3l/g40N3dHQkJCTAwMICuri7186el11sT+/fvx4EDBwA0nJs9PT2FUtGqq6uRnZ2NkSNHsnGIrZJLly7Bw8MD5eXlkJGRETIZkTSJ9urVC2/evBHZ9ubNGyLVCthG1LhMWloaGhoaCAgIoP0aZWJiQi125PF4mDBhwv9koPyW+F+vP2wbNUU9V+Fo+Zw+fRq+vr6YOnXqd6XNwcFBDzo6OggKCvpPf3P9+nXo6emhTZs236Q2m322srKClZUV6urqqAp/SkpKQiXRm5KTkwN1dfWvCgRhS5dNbTb7zMHBwdES4M5kHBwcLZaxY8ciLy8P8fHxKC0thZ6eHgICAgQGYYWFhUhLS2MtuY0kf/zxB5YtWwZ7e3vcvn0bDg4OqK+vx/nz56GgoICffvqJds2mk6ZslM1wdXVFREQE+vfv32IeDEtJSWHatGkICAiAk5MT24dDK9OnT8erV68QGhqK0NBQiIuLU+VGJ0+eTHtKBAfzsJ3Qpq2tDR8fH3h6euLPP/9EUlIS/Pz8sGrVKowZMwYODg7Q19enVRMAVqxYAXl5eezZswfdu3dnNC3B398fcnJyWLNmjVBbWFgYysvLERISQrsuG9eMRqytrb94zejYsSNcXFyInUdnzJiBiRMn4vbt21S5e0NDQ2IJZl5eXli6dCn+/PNPHDlyBP7+/li9ejVGjx4NR0dHGBgY0K45ceJEIq/7LdC/f3/cu3cPVlZWGDNmDMLDw/Hu3TtISEjg4MGDtJqQzp07R9trfQ18Ph+bNm3C3r17UVFRAR6Ph8TERCgqKsLd3R19+/YlYnJiI3W6kaNHj8LKykqkSfX9+/f4888/iRn8r127ho8fP4psKysrE3nd/F/5L2mlJE2iTKYwOzg4/Kt7C5ImOgDN/i8XLlwIb29v4ovV3rx502wS2uDBg/H7778T1WeSlStXYvHixaisrISpqanIxUmkzMB79uwR2lZeXo66ujrIyMhASkqKmEnUx8cHL168gL+/P7S0tBgbg65cuRJHjx6FtbU1LC0tieu2bdsWRUVFANgzDlVWViIiIgKnT59utnIAnecSdXV16r7l6dOn6Natm1Dat6SkJH744Qc4OjrSpvvgwQNoa2tDRkbmXxnuW0NSbVPWr1+PPn36ICgoiPFKJ8uXL8eSJUsgKyuLYcOGoW3btvjw4QPOnj2LmJgYIvd0bMPm4p3WmMxKN9+bUVNcXBxxcXGMVpliW5tuXQUFBUYr+rClvXr1asycOROampoiE5E/hc5nn2xpc33m+kxS93+lrq4Ozs7OSExMZHxMypY2CV1xcXGh4J7mtIcOHUqbNlu6bGqz2WcODg4ONuFMohwcHC2aOXPmYM6cOc22q6ioiEzpaA3ExMTAzc0Nc+fOxcGDBzFlyhTo6emhrKwMs2bNIpJEl5ycTJWora+vB4/Hw/Hjx6mS68DnE+O+lpSUFBQXF2PYsGHo1asXVFVVBdp5PB62b99OTL85iouLmzUOfMvweDwEBATAxcUFV69exfv376GkpARTU1NoaWmxfXgcNNBSEtrExcUxdOhQDB06FHl5efD09MSBAwfw+++/o0ePHnBxcYGDgwNtes+ePcPmzZtZKcF+48YNBAQEiGyzsrLCypUrieiycc1oZOPGjQgNDYWWlhaVhlZUVISzZ8/i5cuXmDNnDu7cuUMZjkgZReXk5DBw4EAiry0KMTExWFtbw9raGkVFRTh27BiVnNu9e3c4ODhg/PjxIo0x3xpVVVXYuHEjxo4dy4pR1d3dHXl5eQAaFpSUlpYiOTkZVVVVMDc3x7Jly2jTYtqA0BybN29GfHw8fHx8YGZmJpBKZm1tjUOHDhGZTH/+/DnjqdON+Pn5ISEhQaRJ9M2bN/Dz8yNmEv0ct2/fFjICfQ0tpVwwkynMdKWwkmTs2LHw9vbGL7/8QkxDTU0Nt2/fFqqMAQB37twRKJ39rfPx40dUVFQgMjISUVFRAm2kzcDXr18X2lZbW4srV65g48aN2LBhAxFdALh79y42btyIYcOGEdMQxdmzZ+Hn58dYWpexsTG8vb2pcouNC7REwePxRBp3v5aVK1ciOTkZY8aMgba2NnFj7LBhwwTeVzc3N0bMLw4ODjh48CAMDAw+a7gn+b2qqqrC/v37YWFhwXgVn9evX8PX15ex8ZmhoaHA/7impga//vorfv31V0hISKC2thYAICEhgenTpxOr1MAW4eHhzaZ55ufn4+DBg7SOP11dXeHr6wstLS24urp+dl+2ngdy0E9ubi5SU1ORm5sr0uDf9F6D7mc6bGmzpTtjxgzEx8fD3Nyc8QWATGqfP38ejo6O0NTU/OJzULoXyLOlzfWZ6zNJ3a+BzQUNbGlzff4+tL+3xTocHBytG84kysHBwdFCefnyJfr37w9xcXGIi4ujrKwMACAvL485c+YgKCgIM2bMoFVT1ARubGys0DZSKaMfP34UWC3NpDHzzJkzQttqamqQmZmJffv2wdTUlLFjYRotLS3OFMpBnMzMTCQmJuLYsWMoLS2FjY0Nhg8fjgsXLiAgIAB3797FqlWraNHS0tJizdhdUlLSrCFTVlaWKmFCN2xcMxq5ceMGLC0thd6/adOmYdmyZXjw4AE2btwIeXl57N+/nxaTqKhz9ucYMWLEV2t+jnfv3iE3NxeFhYWQlJSEuro6tm7divDwcKxfvx5Dhw4lqk8aaWlpJCUlEf8/NscPP/yAH374AUBDwre/vz9jD7/5fD4uXLiAmzdvoqSkBIqKihgwYAAGDRpENHX9yJEjWLJkCSZPnkylfDfSpUsXvH79mohuWloa46nTjXzugWtpaSntZvfIyEjKHMnj8eDi4iL0nlZXV6Ourg5TpkyhVbulwFQKMxuLNv4rWVlZqK+vJ6rh6OiIiIgIVFdXw8bGBioqKigqKsKpU6ewa9cuYiWT2cDHxwe5ublYtmwZo4mazSEhIQFLS0vk5eVhxYoVxFJbu3btSpnImKRNmzaMJoUFBQUhJiYGz58/B4/Hg5ycHLH09uZIS0uDj48Ppk2bxqguAIGk5crKSpSWlkJBQQEyMjK0a8XFxUFbW5v6mQ2kpaWxefNmVlJzevfujdzcXMb0Zs6cyUpVnZbCtm3bMGjQoGZNotu2baPVJPrx40dqnNsaF2ZzCHPy5El4e3uDz+dDWVlZaHxA8l6DLW02+/zq1Ss8efKElQWATGo3Nc8xvVieLW2uz1yfOTg4ODg4ODj+VziTKAcHB0cLRV5enlpd3L59ezx79gw//vgjgIZ4++LiYlr1WkKq0d69e1nT9vDwELldQkICI0aMaBErMengey9X9z2zd+9eKsXzU4KDg9GhQwfa04c+fvyIEydOICkpCRkZGdDS0sKsWbMwbtw4KpXN1tYW5ubmWLlyJW0mUT8/P6xZswa9evWiJlWZonPnzkhPTxeZEnblyhViKThMXzOacvLkSWzevFlkm42NDRYtWoSgoCAMHjwYiYmJtGg2d84WBalUpbKyMiQnJyMpKQn3799H9+7dMX/+fPz0009QVFREWVkZAgMDsWbNmq82ibq7u4ucrGUSQ0ND3LlzhxWzV1lZGcrLy6Guri7Ulp+fDzk5OSJpuSUlJZg7dy7u3r0LBQUFqKiooLCwENHR0ejXrx+ioqKIJcW+f/++2fNXXV0dMRMS0xMPFy5cwMWLF6nfd+/eLZQkX1VVhatXr0JXV5dWbUNDQ8ycORN8Ph/btm2Dra0tNDQ0BPaRlJSEtrZ2syXC6aKqqgqvX79GVVWVUBupsdjRo0dhZWWFdu3aCaUwv3//Hn/++Scrya0kiYmJEdrWuCgsJSUFY8aMIao/f/58lJaWYteuXQLpmuLi4nBycvpiitq3REZGBkJCQhhP1PwSGhoaRO97fXx8sG7dOvTq1YvRErUzZsygkh7FxcWJ6ykqKmLRokUAAB0dHXh5eTGeNC4uLs7qQse0tDSEh4fjn3/+oVI8dXV14eHhASsrK9p0mo672DTc6+rq4tmzZ4wfw4oVK+Dl5YX27dvDzMyMeBrdwoULib5+S+dzC3YKCgpoH/c2fQbI5vNADubYtGkThg0bhsDAQMYXF7ClzWaf09LSICYmBoD5BYBsanNwcHBwcHBwcHBwNA9nEuXg4OBooejr6+Px48ewtLSEtbU1tm3bBj6fDwkJCURFRaFfv35sH2Kr4ty5c0LbpKWloaKi0qqSJFpCuToOdti/f3+zSZJaWlqIiYmh3SRqYWEBoCHF0cvLCwMGDBC5X+/evUWWF/5fCQwMREFBAezs7KCuri70IJ7H4+HYsWO06TVlwoQJCAkJgaKiIhwcHKjS64cPH0ZsbCyWLFlCRJfNa4aYmBgePXpEvd9N+eeff6iJAXFxcdoSlkSds5nEy8sLqampAIBRo0bht99+E/ofy8vLY8qUKfjjjz++Wo9EWfH/ioeHBzw9PSEuLg4rKyuR10clJSUi2v7+/pCTk8OaNWuE2sLCwlBeXo6QkBDaddevX49Xr15h165dAp/vy5cvw8vLC+vXrxd5THSgpaWFy5cvw8zMTKjt2rVr6NGjBxFdpnnx4gVlTOXxeLhx4wakpKQE9pGUlESPHj1oP3+amJhQZhcej9dseVWSVFdXY8WKFTh27JhQYmwjpMZifn5+SEhIEHn9ffPmDfz8/IiYRHV0dJodf/J4PLRt2xY6OjpwcXGBtbU1rdrr168X2iYlJQUNDQ04OzvDzc2NVr1P4fF48PX1xbx585CRkUGlExsYGKBdu3aora1lvBQoKdhK1Pwcr1+/RnR0NNHETTMzM5ibm8PW1pbRMaizszPy8/MxfPhwDBgwgNGkMLYWm/7888/4448/hEzuTJCamoqFCxeib9++8PX1haqqKgoKCpCSkoL58+dj69atxA3ShYWFIhcWaGpqEtH79ddf4eXlBWVlZVhZWUFWVpaIzqdMmjQJtbW1mDt3LsTExCAtLS3QzuPxcPPmTUaOpbWSnJyM5ORkAA3/z/Xr1wudu6qrq3H//n3079+fyDFUVVVhwoQJ8Pb2ZuU7zcEcRUVFmDRpEuNmSTa12ewzm8mDTGoXFRUhPz8fOjo6AtsfPXqEiIgIZGZmQlVVlcj9BVvaXJ+Z02VTm80+c3BwcHBwcLReWsfTZw4ODo5WyLx585CTkwOgwZiRnZ2NoKAg1NfXo0+fPrQl7rU0Hj58iB07duDWrVt4//49lJSUYGRkhHnz5qF3795ENKuqqhATE4OxY8cynoDCNC2hXB0HO+Tk5KBr164i2zp37ozs7GzaNT09PTF27NgvJo707NmT1gfIenp6rJm7p0+fjlevXiE0NBShoaEQFxenjD+TJ0/GzJkzieiyec2ws7PDli1bUFNTgyFDhlDG2HPnzmH79u2YNGkSgP9PMqYDUoms/5bMzEz4+PhgzJgxkJeXb3a/7t27t5pz7eTJkwEAGzduRHBwsMh9SJnZbty4gYCAAJFtVlZWWLlyJRHd8+fPw8vLS8gAbWFhgSVLliA4OJiYSXT69OlYtmwZJCQkYGNjAwB4+/Yt7ty5g7179wqUuiXBy5cv8eLFC5EGlBEjRtCm4+LiAhcXFwCAtbU1IiIihCZAmIAtI/a2bdtw+fJlrFu3Dp6enli+fDnatGmDY8eO4dWrV1i2bBkx7c+lhZWWlhJJ5wUAb29v7N27F1JSUrC2toaysjIKCwuRlpaGqqoq2Nvb49q1a1iwYAGCg4Nha2tLmzbblRPCw8Ph7u6Odu3aCSUNVldXY+HChYiMjGTp6OjFz88P69evR48ePRhPdTc0NBQaB9bW1qKmpgYyMjIIDw8npr1x40bExMRAT08PWlpaQqZ3UiQnJ2P37t3g8Xi4cuUKo6Vs79+/jw8fPlCLGkpKSrBx40ZkZmbC3NwcCxYsoBYMfS1N04BlZWVx8+ZNTJ48GWZmZkL3GzweD9OnT6dF91PCw8Nha2srNB5ycXGBp6cnwsPDiZhEi4uLsXr1apw5c0bIhE16kaeLiwtqamqwePFiAICMjIzA94yUWZPN8u/Ozs5f3Kc1jPNramqoUu98Ph8VFRVC31kpKSn89NNPmD17NpFjkJaWRl5eHm3nCg56ERcXR1xcHC0J2ZaWlrhz547IhXCkYUubzT5/L4SGhuLBgwc4cuQItS07OxtTp05FZWUlevXqhadPn8Ld3R179uyBsbHxN6/N9Zk5XTa12ewzBwcHBwcHR+uFM4lycHBwtCDOnTsHExMTtG3bFv369aNSyRQUFLB9+3ZUV1ejurr6s4aUb5kbN25gxowZUFNTg62tLVXW9ezZs5g8eTJ2797dbBLh1yAtLY2kpCRaTQ8tlZZSro6DeeTl5fHmzRuqBHlTXr9+TVvCY1OmTZtG+2v+G9atW8eKLtAwQRoQEAAXFxdcvXqVMrubmpoSLYnJ5jXDx8cH4uLi2L59O7Zs2UJtl5KSwtSpU+Hp6QkA6N+/P9FkmMuXL+Pu3bsoKCiAmpoa+vbtKzLdlA4OHz78r/aTk5NrNefaoKAg1ibpS0pKmjWsycrK4v3790R0KyoqhEqfN6KmpoaKigoiugAwfvx4lJSUICwsjDKNLViwALKysli0aBFGjx5NRLesrAwLFizAtWvXAPy/kbDpe0/KgMJ00o2rqyt8fX2hpaX1xTLfPB4P27dvp/0YUlJS4O7ujlGjRsHT0xMGBgbQ19fHuHHj4OPjg/Pnz9NatvjChQu4ePEi9fvu3buFPuNVVVW4evUqdHV1adNtSklJCfT19bF161aBz5WPjw8WLlyIyspK7Nu3D4sXL0Z0dDStJlG22blzJ+Tl5YWMa5WVlXB1dcXz58/ZOTACBAUFsZbqLspU1pgYO2jQIGKp1wBw8OBBeHh4EE+l/ZSQkBCMHDkSgYGBjD8rCAoKgrm5OWV+CQoKQmpqKiwsLLB7926IiYlhwYIFtGiJSgPOycnBnTt3hLaTNIk+f/6cGt9+yk8//URbfz/F398f169fx7x586CtrS1kBiYJW2ZNNsu/y8vLC/W5tLQUDx48gIKCAvT19Vk6Mnqxt7eHvb09AMDJyQkrVqxg3NwPNCxCOnXqFMzNzRnX/hag06jZSG5uLlJTU5Gbm4vq6mqh9qaLC+i6p125ciUWL16MyspKmJqailxQrKenR4tWS9FmWvfMmTOUzpkzZ764P53PwtnSvnXrFhwdHQW2xcbGory8HNHR0Rg4cCAqKysxY8YMREdH02qkY0ub6zNzumxqs9lnDg4ODg4OjtYLZxLl4ODgaEG4u7sjISEBBgYG0NXVpX5uREpKirE0EjYIDg6GiYkJIiMjBUotent7Y+7cuQgJCcGBAweIaBsaGuLOnTutxszzX6moqBCZFkZyEpWDWSwsLLBt2zaYm5ujQ4cO1Pa3b98iIiICgwYNokXn3zwIbkprNWdraWkRNYV+Dj6fj/z8fKioqDBiFJCUlISfnx/c3Nzw5MkTyqTZo0cPgXMIqYeVBQUFWLhwIe7cuQNFRUVqgUFJSQn69euHsLAwqKmpEdH+nhg/fjxr2p07d0Z6errISeMrV64QS5bV1dVFfHw8Bg4cCHFxcWp7fX099u7dSyzhnM/no6SkBFOnTsXEiRNx+/ZtFBcXQ1FREYaGhkRLFW7cuBHv3r3Dvn37MGXKFISHh0NRURHHjh3D1atXERISQky7EaZSTD9+/EglPTcmaDHN27dv0a1bN4iLi0NaWhqlpaVU29ixY7FkyRJak3JfvHhBmXF5PB5u3LghdG8hKSmJHj16YMmSJbTpNiUxMRFr164VMt7weDxMnDgRPj4+VFJzY2IdXezduxd5eXkizV3BwcHo0KEDpk6dSqtmU7Zu3Qp3d3e0adMGEydOBNDw2Zs9ezbevn2L+Ph4YtpMw1aqe21tLaytrdGhQwcoKyszri8pKYm+ffsyrvv+/XtMnDiRlcWkmZmZmDdvHoAGw/Pp06exbNkyODg4YN++fYiLi6PNNMl2GnAjioqKyMrKErn4KSsrC4qKikR0//77b/j7+2PcuHFEXv9zsGnWZIuIiAiR24uKiuDm5kZswQ6b7N27lzXt/v37IzQ0FPPmzcOgQYOgqqoqdB1pjc8O2DBqAsDJkyfh7e0NPp8PZWVlxhKoP378iIqKCkRGRiIqKkqgjXQiMlvaTOt6eHjg4MGDMDAwgIeHx2f3bS3aeXl56NGjh8C2tLQ06OrqUtdqGRkZTJs2DRs2bKBFk21trs/M6bKpzWaf/xfExMRgb2+Pdu3afTfabPaZx+PB2NiYWBWYlqbLpjabfebg4OAgAWcS5eDg4GhBtG3bFkVFRQA+XwKytfLPP/9g69atAgZRoGHFvLOz8xcfMH0NHh4e8PT0hLi4OKysrKCioiL0QLq1GSbLysqwYcMGnD59WsCU0BRSD2c5mGfp0qWYNGkSbGxsYGpqCnV1deTn5+Pq1atQVlbG0qVLadER9T3l8Xgiz2l0PhRuWn7yS9CdLNRYRl1GRgYPHjz44v6kkjEuXryIsLAwPHz4EHV1dUhMTISenh78/f1hYmKCsWPHEtFtRFFRkZVV6wEBAXjz5g1iY2NhampKbb9y5Qq8vLywYsUKbNu27at1RJWvbQ5SJTdbAiUlJXj69Clyc3MxaNAgKCoqoqqqCpKSksRKRE6YMAEhISFQVFSEg4MDlJWVUVRUhMOHDyM2NpaYmW3p0qWYOXMmhg8fjqFDh0JVVRWFhYVITU3Fu3fvsHv3biK6NTU1MDc3R0REBAYPHkw0gfdTLl68iMWLF1MmJ3V1dRgYGMDY2Bjr1q1DTEwMNm3aRESb6RTTpkYItkwRampq1BisU6dO+Pvvvykz9IsXL2jXc3FxgYuLCwDA2toaERER0NHRoV3nc1RUVCA3N1dkW05ODmUObtOmDe0pefv378eMGTNEtmlpaSEmJoaoSXTQoEEIDg7GkiVLICsrCysrK8ycORMlJSWIj48nZnhnA7ZS3cXExDBp0iRERUWxkkY3YcIEHDt2jFiSeXNYWVnh9u3brJSyrayshKysLICGtKPq6moMHToUANCrVy+8ffuW8WMizejRoxEaGgoZGRmMHDkSCgoK+PDhA1JSUrB582bKBE43CgoKrExAf0pubi5yc3Oho6ODNm3asH04jKOsrIzZs2dj48aNrdIoWl9fj6tXryIrK0vItEgyodfPzw9AQ+r5hQsXhNpJmgfZgi2jJgBs2rQJw4YNQ2BgINEFaJ/i4+OD3NxcLFu2DFpaWowmIrOlzbTuuXPnqEWy586dI6rVUrR5PJ7APeO7d+/w5s0b6r6nkfbt26O4uLhVaHN95vpMUvdzFBYWIjs7G506dRJalMfj8bB27dpWp81mn6urqxEeHo6JEyeiU6dOAm1iYmLEnmWxpcumNpt95uDg4GAaziTKwcHB0YIwNjaGt7c3evXqBQBYsWJFs2kgPB4Pe/bsYfLwiCMrK4vCwkKRbe/evaMmn0gwefJkAA0JWsHBwSL3aW0PpP38/HD16lU4OjqiW7dujD6c5WCe9u3b4+jRo4iJicHVq1fx4sULKCkpYcaMGZg+fTptJuhPHwTX1dVhxIgR2LFjh9DqZzoRVX6yOeie3HJwcKDSEhwcHJo1EpJMp0hOToaXlxdGjRqFCRMmYNmyZVRbly5dcPjwYeImUabS/z4lPT0dK1asEDCIAoCZmRk8PT2xYsUKWnQ+LbNZV1eH7du3Y+LEiVBXV6dF499SV1eHu3fv4u3btyITZ0gkTNXX12Pz5s3Yu3cvKioqwOPxkJiYCEVFRbi7u6Nv375wd3enXRcApk+fjlevXiE0NBShoaEQFxenEiAnT56MmTNnEtE1NjbGgQMHsGPHDiQnJ6O0tBSKioowMjKCq6srMcN3Y1nkxj4ySVFRETp06ABxcXHIysri/fv3VJuVlRXRJLGWkGLKNCYmJrhx4wasra0xYcIEbNiwAc+fP4ekpCRSU1MxZswYYtqNiaJMY21tjZCQELRp0wZDhgyBvLw8ysrKcO7cOYSEhGDYsGEAgMePH6Nr1660aufk5DT7mp07d0Z2djateqIYMWIEVq9eDT8/P3Ts2BFiYmKIj49H+/btiWt/D4iJiaFTp04oKSlhRV9eXh7Xrl3D5MmTYWZmJlRSlpTBytHREStXrkRlZaVIXYDcIqXOnTvjr7/+gomJCY4fPw49PT3qvqKwsJBoumlNTQ2OHDmCu3fvUkn2/fr1w7hx44je2y5duhQ5OTlYtmwZli9fDgkJCdTW1oLP52PEiBHEFq/MmjULe/fuhYWFhdDCWiZISEhAeHg4CgoKqHGgnp4eFixYABMTEyHDQmumrq4OBQUFbB8G7RQUFGDatGl4+fKlwELPpvdApEyiTJvZWgJsGTWBhjH/pEmTGNfNyMgQGO99D9pM6zZddMT0AiS2tLt164b09HRqcWVaWhp4PJ7Qop2CggLak+bZ0ub6zPWZpC4AREVF4fDhw6ipqYGLiwucnZ0RFhaGyMhI1NXVgcfjYfLkyVi2bBntFSTY0mazz81RVVWF6OhoDBo0SMi42Bp12dRms88cHBwcTMOZRDk4ODhaEEFBQYiJicHz58/B4/EgJyfH+AM7ALh//z4+fPhAJZGUlJRg48aNyMzMhLm5ORYsWEAkLWzIkCEIDg6GhoaGQPJLeno6QkNDYW1tTbtmI0FBQayURGST9PR0BAQEEDeOcbQclJSUaC/d+imfPghuNDmpqakRfUjMZvnJuLg4aGtrUz+zQUREBFxcXODr64u6ujoBk2iPHj2ILipgOv3vUxQUFJot66mgoEDbdfRTc1yjSXTSpEnEjBeiePDgARYuXIjc3NxmE3pJmES3bNmC+Ph4+Pj4wMzMDCNHjqTarK2tcejQIWImUR6Ph4CAALi4uODq1at4//49lJSUYGpqCi0tLSKajejr6yM8PJyohiimTJmC2NhYDBw4ENLS0ozpamhoUAkUWlpaOH/+PAYNGgQAuH37NtFjYTPFdNOmTSguLsaqVauE2pYvXw4VFRX88ssvtOsuXryY+n83mi5SUlJQVVUFJycn2ko0N0deXh5iY2Nx69Yt6ntlZGQEFxcXYqbFFStWwNfXF15eXuDxeALmquHDh2P58uUAAE1NTdqNVvLy8njz5g1+/PFHobbXr19DRkaGVj0AIhPGe/TogfHjx+PMmTNYv3493r17h3fv3gEgZ+RjmsZEuM9BKnHF1dUVERER6N+/P+Pm20Yze25uLu7cuSPUTsokOnv2bAANE5tRUVECYzDS5XunT58Of39/JCYmoqSkRKDU5bVr16gFsHSTlZWF2bNnU4mWKioq+Oeff3DkyBFs374dO3fuxA8//EBEW0pKCmFhYXj8+DFu3LghsIiEVH8B4Pnz58jMzMTw4cNhbGws0gxMKnUwNjYWwcHBmDFjBszMzAQW6JiYmCAlJaXVmURFnb9ramqQmZmJbdu2wcDAgIWjIsu6devQrl07xMXFwcrKCgcPHoSqqiqOHTuGo0ePCpXKpouqqioEBgZi1qxZrFSmYAu2jJoAYGlpiTt37jCeQN21a1fU1tYyqsm2Npt9bkplZSUSExORmZkJNTU12Nvbo0OHDq1C28nJCT4+PigtLYWqqioOHDiALl26CKXKX7p0CT179qRNl01trs9cn0nq7tu3D5s2bYKtrS2UlJQQHh6O9+/fIyYmBt7e3tDT08PNmzcRFhYGAwMDWp9BsqXNZp/79+//2XY+n4/Zs2dDTEyM1spVbOmyqc1mnzk4ODhaEpxJlIODg6MFoaioiEWLFgEAdHR04OXlxcqD57Vr18LMzIx6WBgUFITU1FRYWFhg9+7dEBMTIzJp7evri2fPnmHWrFmQl5enysmWlZWhT58+8PHxoV2zkfHjxxN77ZaKmpoaKw+jOdilpKQEGRkZKCkpgZKSEvr06dOswY7j3xEXFwcvLy/IyckhJycHVlZWjJeCfP36NaysrES2ycrK4sOHD8S02U7/c3FxQVRUFExMTCAnJ0dtLysrQ3R0NJydnYnqM01jyviePXvQvXt3xlKgjxw5giVLlmDy5MlCCZddunTB69eviR+DlpYWcVNoU8rKylBeXi4yKTY/Px9ycnICnzk6yc3NRVZWFgYPHgwTExOoqqoKLWYhYQSxsLBAeno6hg8fThnPMzIyICkpiYyMjGZLddMBmymmycnJzb6+kZERtm3bRsQkqqamRpVkBBrMVqQSuj7lyZMnmDZtGmpqamBhYQEdHR0UFhbi999/R1JSEuLj44kkgMvLyyM8PByZmZnIyMhAQUEB1NXVoa+vj+7du1P7kUigtrCwwLZt22Bubi4wMf327VtERERQhmg6aS5hvNHk7+rqSv3emkrpiupHaWkpcnNz0a5dO6LmzZSUFBQXF2PYsGHo1asXVFVVBdp5PB62b99ORJutRUtsLVICGlJMu3btinv37qF3794Cye5KSkrExmHLly+HpKQkUlJS0KVLF2r7y5cv4erqihUrVhD5v1RVVcHc3BwbN26EtbU1UVPopzSmRwHAjRs3hNpJlqaOj4+Hm5sb3NzchMaB3bp1Q1ZWFm1aa9euxfTp09GhQwdcv34dvXv3Jjbe+hyizt+N5+6+ffsiMDCQ8WMizfXr1+Hv7y8wNtHU1ISrqyv4fD5WrVqFnTt30q4rLS2N69evMzYGaimwZdQEgJUrV2Lx4sWorKyEqakpYwnUfn5+WL9+PXr06EEttGUKtrSZ1t20aRPOnz+P48ePU9sqKirg6OiI58+fU+exPXv2IDExEZ07d/7mtceOHYu8vDzEx8ejtLQUenp6CAgIEEjdLiwsRFpaGu33lGxpc33m+kxS9/fff8fcuXOpoImBAwdi/vz58PDwoMb2RkZGeP/+PQ4cOECrYZItbTb7XFFRARUVFTg4OAg9462srMTOnTsxatQo2sM32NJlU5vNPnNwcHC0JDiTKAcHB0cLpKqqClOnTmVN/9mzZ5g7dy6AhsHx6dOnsWzZMjg4OGDfvn2Ii4sjYhJVVFREQkIC0tLScPPmTYFEjsGDBxNJL/2eWbhwISIjI2FkZCTygTBH64LP52Pjxo2Ij48XKE8tJSUFJycneHl5sXh03zbnz5/HnDlz0LVrV/j5+SEhIYFxk6iamhqeP38ucoLp8ePH0NTUJKbNZvof0FA+ODs7G1ZWVvjxxx+hoqKCwsJC/P3335CTk0NeXh5Wr15N7U9q8pwpnj17hs2bN8PExIRR3ffv3zc7qVVXV0d7OsqDBw+gra0NGRkZkUlOn0JiEtPf3x9ycnJYs2aNUFtYWBjKy8uJmaDT0tIgJSUFALh3755QOykjiKenJyoqKgAA48aNg5ycHJVsuWzZMkyePJl2zUbYTDHNz89vNs1GQ0MDb9++JabNFuvXr0fnzp2xe/dugcUiJSUlmDlzJtavX0/ECNKItrY24+aApUuXYtKkSbCxsYGpqSnU1dWRn5+Pq1evQllZGUuXLqVdk03zHpscPXpU5PbMzEwsWbKE6OK/jx8/olu3bgK/t3aYHhN8irGxscj0P5Lm/oyMDGzYsEHAIAo0JLZ5eHjA19eXiK60tDRkZWUhLi5O5PU/x/nz5xnXbCQvLw+GhoYi2yQlJVFeXk6bVlxcHGxtbdGhQwc4OzsjISGBlcXTos7f0tLS0NDQYDylmCk+fPgAZWVliImJQV5eHoWFhVRbv379iCWJAg0LOS5fvixgNG/tsGXUBBqujRUVFYiMjBR6X0kuXAkKCkJBQQHs7Oygrq4utHCdx+Ph2LFjtOuyqc207uXLlzFkyBCBbXv27EFmZibc3Nwwa9YsZGVlwcPDAzt27BB5r/stas+ZMwdz5sxptl1FRQXp6em06bUEba7PzOmyqc2G7ps3bwSux8bGxuDz+RgwYIDAfj/++CMOHz7cKrTZ7POhQ4ewevVqpKSk4NdffxUIgfjw4QN27tyJ8ePH0562zpYum9ps9pmDg4OjJcGZRDk4ODhaINLS0jh8+LBAKVcmqayshKysLADg1q1bqK6uxtChQwEAvXr1IjpRLiYmhqFDh1J6JLGzs0NISAh69uwJOzu7z+5L8kElW9ja2uLx48cYPHgwdHV1RT6oJJWyw8E8O3bswJ49ezB79myMGjUKqqqqePfuHU6dOoWdO3dCQUEB8+bNY/swv0nat2+P8+fPQ0VFBXw+HwUFBcjJyWl2fxKGzTFjxiAsLAw//PADZRTg8Xh48uQJdu7ciZ9//pl2zUbYTP8DGsx0EhISUFBQEJjIapxkazqhTjJhiSm0tLRYMbxoaWnh8uXLIo3I165doz1x0MHBAQcPHoSBgUGzSXwA2UnMGzduICAgQGSblZUVVq5cSbtmI2wZQWRlZakxIAAMHz4cw4cPZ0SbzRRTZWVlPH36VGQZ8qdPnxJL3K6pqUFMTAxSUlKQm5uLqqoqgXaS5a1u3bqFjRs3CvVNUVER8+fPJ7p4pLy8HEeOHMHNmzdRUlJCLQqzt7dHmzZtiOm2b98eR48eRUxMDK5evYoXL15ASUkJM2bMwPTp06GkpES7JtvmvZaGtrY25syZg7Vr1+KPP/4gorF3714ir/tfqKqqwuvXr4W+0wA5ww+b1NXV4e7du3j79q3AYrRG6EzaaURdXb3ZsQGPxxNKkKWTcePGITExsdkU/9aIpqYm7t27J3IcePfuXVqT3lVUVHD37l0YGBhQqXNMU1VVhQcPHsDCwoL2krUtmU6dOiE/Px8A0L17d/zxxx+U4Ss1NZXIdbIRBwcHLF++HB8/foSVlRVUVFSEvuOt7fzJllETAHx8fJCbm4tly5ZBS0uLseoUenp6zZ67W6s207qvX79Gnz59BLadOXMGmpqa8PDwAADo6+tj9uzZiI2NbTXaHBwc9CEhISEwppeRkQEAoXt1SUlJkfc736I2m33W19fH77//jsTERPj5+aFPnz7w8/MjXkmJLV02tdnsMwcHB0dLgjOJcnBwcLRQDA0NcefOHVYmFjt37oy//voLJiYmOH78OPT09KiHwYWFhZCXl6dNKz8/H4GBgZg4cSIsLS1F7nPx4kUcPHgQK1asgIqKCm3a+vr6lBGCzQeVbBEbG4uoqCioqqqirq7uu0jZ+Z45dOgQ5s+fD3d3d2qbqqoqdHR0ICkpiYSEBFpMomfOnBH4vb6+HjweD3///Teys7OF9idRTpZpXFxcsH79ekRFRYHH4wn8j5tCcqLH3d0dT58+xYwZM6jz9Zw5c1BUVITBgwdT6dAkYDP9D2A3VQkA49cOPz8/rFmzBr169WI0hW/69OlYtmwZJCQkYGNjA6ChRPOdO3ewd+9erF27lla9uLg4qn9sJfGVlJQ0W970U0N0a6SiokLkw29SBgE2U0yHDRuGsLAwGBgYCKSVZWRkYNu2bRg1ahQR3ZUrV+Lo0aOwtraGpaUlYxP0ACAuLi7SzAUA1dXVxFLycnNz4eTkhOzsbOjo6EBFRQVZWVlISUlBbGws4uLimk11pQMlJSWqhBwHO7Rt2xavXr1i+zCIUF1djRUrVuDYsWNCJbkbIWX4OXr0KBISEvDixQuR5+5bt24R0X3w4AEWLlyI3NxckYY+Ho9HxCS6YMECbNmyBbq6ugLlal+/fo2wsLBmx+N0oKCggDt37sDOzg6WlpZQVVUVGA/yeDzaymafOXOGShj89D5LFKTurSZOnIjw8HC0a9eO0qitrcWff/6JXbt2YdGiRbRpjR07FmvWrEFQUBB4PB4mTZr02f1JfKekpaWxefPmVmdK/BKDBw/G5cuXMXr0aMyfPx8LFiyAmZkZJCQk8O7dO3h6ehLTbnwWsX//fuzfv1/gO0XaMMkWbBk1gYYxbkhICIYNG8aYJgCsW7eOUb2WoM20blVVlUAqbXl5OR4/fix0Le7Rowfy8vJajTYHBwd9dOrUCU+ePKEWRImLi+PMmTPQ0NAQ2O/ly5dQV1dvFdps9rkRR0dHjBw5Eps2bcK4ceMwZcoUODk5EdFqCbpsarPZZw4ODo6WAGcS5eDg4GiheHh4wNPTE+Li4s2uoic1ST99+nT4+/sjMTERJSUl2LBhA9V27do19OrVizatmJgYvH79GgMHDmx2n4EDByI0NBQxMTG0PpR2c3OjJpTYfFDJFlFRUZg6dSp+++03iImJsX04HIQpKChA//79RbYZGhoiMjKSFp3GdIBPaXoeaaS1TPRMnz4dQ4YMwfPnzzF//nx4enoyvgJVSkoK27dvx9WrV5Geno7i4mIoKirC3Nwc5ubmRLXZTP9jEkNDQ5GG0KlTpwptJ5n+FxgYyEqZvPHjx6OkpARhYWHU+WLBggWQlZXFokWLMHr0aFr1mi6SYSuJr3PnzkhPTxf5Hbpy5Qo6duxI/BhevnzZrOGHhBGkrKwMGzZswOnTp1FaWipyH1LnbTZTTBctWoRbt25h0qRJ0NbWpsqQZ2ZmQldXl5ip8OzZs/Dz88PUqVOJvP7nMDc3x+bNm6GrqytQmvvFixfYsmULsWtHo6H8xIkT+OGHH6jtz58/h6urK9atW4ctW7YQ0RbFzZs38fz5cxgZGQkcDwl0dHS+uLCgNYyLAIg00dfU1CAzMxOhoaG0p0/HxMTAzs4OqqqqiImJ+ey+dBr4PmXbtm24fPky1q1bB09PTyxfvhxt2rTBsWPH8OrVKyxbtoyI7h9//IFly5bB3t4et2/fhoODA+rr63H+/HkoKCjgp59+IqILACtWrIC8vDz27NmD7t27M2ZySklJQWlpKWxsbNCjRw+oqKigsLAQT58+hYqKCk6fPo3Tp08DoL9CRmhoKICG+6unT58KtdP5GfPw8KCS1Zu7z2qqS+ocMmvWLOTm5mL58uVUynpjpYIpU6bQeh3z9vaGpaUlMjMzsXr1ari4uBCpxPAldHV18ezZs+8qEXrp0qXUz1ZWVti/fz9SU1NRVVUFc3Nzoum5bC0KYxO2jJoA0LVrV9TW1jKuy0Gejh074p9//qEqJFy7dg11dXVCFRPKy8ubXRD5LWpzcHDQx5gxY/DhwweBbV26dBHa79ixYzAyMmoV2mz2uSlt27bF8uXLMWHCBKxatQpJSUmMhBOwpcumNpt95uDg4GAbHp+tui0cHBwcHJ9FR0eH+rm5wSnJScTr16/j3r176N27N0xNTantYWFh6NOnDwYPHkyLjo2NDaZPn/7FdKjff/8de/bswalTp2jRBRr+x4aGhhgzZgxGjRoFZWVl2l77W8DY2Bhbt24VWTKOo/VhY2ODQYMG4ddffxVqCwoKwl9//YWUlJSv1hGVFvo5mDBZMYmfn5+AAZ0pcnJyoKamJnJivra2Fvn5+cQmVysqKlBRUUGdQ8+ePUul/5mbm2Py5Mm0G9GLioqQn58vcK0EgEePHiEiIgKZmZlQVVWFi4sLrK2tadEMCwv7Tw+LSCVY+fr6fvE46E71bMrHjx9x+/ZtyohsaGgoZFRtLcTExCAkJAS//PILHBwcoKysjKKiIhw+fBibN2/GkiVLMHPmTCLaZWVlWLBgAa5duwYAVDpb0/eexDhw4cKFuHr1KhwdHdGtWzeR5xR7e3vadZuSlZWFjIwMFBQUQF1dHX369BEwMZKiuroaR48exdWrV/H+/XsoKSnBzMwMP/30E6SkpIhoDhkyBCtXrqTSl5kkJycH06ZNw9u3b9GjRw+oqqqisLAQT548QYcOHRAfH08k0XPAgAFYtWqVSGP5iRMnEBAQgBs3btCuCzSYX6SkpKhz5IEDB7By5UoADYstIiMjiY6LY2Njhc7fpaWluHz5MvLz8+Hs7EzMvMg0zRli+Xw+OnTogG3btqF379606jUa6T4dG3wKSSPdyJEjMXv2bIwfPx56enpITEyEvr4+gIbEOBkZGeozRyfjxo3DyJEjMXfuXOjp6SEpKQl6enooKyvDrFmzYGNjQ2zRjqGhITZv3sx46fX/mvSyd+9eQkdCluzsbKipqUFKSupf3WeRvrd69eoV0tPT8f79eygqKsLMzIzo4jgnJyesWLGC0fT8RjIyMuDl5YXFixfDyspKYCELBwcdjB07Fm5ublSVBia5cuUK1q9fj5CQEOLfr9WrV2PmzJnQ1NTE6tWrv7i/v7//N6/NZp/Dw8MRHx+PX3/9FWpqali7di1ycnKQlpYmcN8eGhqK69ev48CBA61Cm4ODg3nKysogJSVF7HlJS9RmWvfEiRPIysrC+PHjGV00xZYum9ps9pmDg4ODaTiTKAcHB0cL5fDhw180gZCepGeCPn36ICYmBgMGDPjsftevX8esWbOQkZFBm/bevXtx4sQJ3LlzBxISEjA3N4ednR2GDRv2XUwABAQEQFZWFr6+vmwfCgcD/P7771ixYgXGjBkDGxsbKm0nJSUFJ06cwIoVK75Yyq8l8+DBg/+0PxOlA/l8PvLz86GiogIJCbIB/rq6ukhISBAok9zI/fv3MWHChFaTTgY0TKI8ePAAR44cobZlZ2dj7NixqKysRK9evfD27Vu8f/8ee/bsgbGxMYtH2zp48eIF4wm5jXwufY/H46Ft27bQ0dGh1RQMNHyHV61ahd9//x1AQ7mpxvLBkydPppK0SNBolAsMDMSUKVMQHh4ORUVFHDt2DFevXkVISIjI7/vXYmRkhICAAIwdO5b21/4SHz9+xPLly3Hq1CnU19dDWloaVVVVEBMTg42NDQIDA1td4kxcXBzS09Oxbds2YuXdP8fHjx+RlJSEmzdvorS0FIqKijAyMsL48eOJ/a8NDQ0RHByMoUOHCrWlpqbCy8sLt2/fJqI9ePBgeHt7UwbVIUOGYODAgfD19cWKFSuQk5ODffv2EdH+Et7e3ujYsSN++eUXVvTpRtS9rLS0NNq3b4++ffsSHxexRd++fbFr1y4MGDAAffv2xfbt26lU3suXL2PJkiX4+++/adc1NDTEjh078OOPP0JPTw+7d++mUrtSU1MRFBSE8+fP064LNDyTmDNnDu2J4i2VBw8e4M2bN2jfvj169+7N6MQ0m4vCvkcMDQ1RU1NDjf1kZGQEzmskKwe0BCorK5GYmIjMzEyoqanB3t6eyOKRT8nMzMS9e/fw9u1bODg4QE1NDS9fvoSKigrk5eWJ6zMJk0bNT7Gzs0NBQQFKS0uJV6ewtrZGREQEdHR0vnivxuPxcO7cOVp02dRms8+VlZVYuHAhLl68CABo06YN1qxZg1GjRlH7VFVVYejQoZg8eTKti1vZ1Obg4GCf+vp6DB8+HDt27KC9ckRL1eb6zPWZg4OD41ukdT6V5eDg4GgFjB8/nlG9Bw8eQFtbGzIyMv/KbEWXwUpaWhplZWVf3K+8vJz2CRgnJyc4OTkhOzsbycnJSE5OhpeXF2RlZTF06FDY2dlh4MCBrEzaM0H//v2xZcsWFBQUwMzMDAoKCkL7kChly8EOkydPRk1NDSIiIpCcnAwejwc+nw9lZWX89ttv37RBFAAcHBz+Vcojn88nXub+4sWLCAsLw8OHD1FfX49Dhw5BT08Py5Ytg7GxMRHz1efWfVVXVzM2gV1YWCiyLDbdE9a3bt2Co6OjwLbY2FiUl5cjOjoaAwcORGVlJWbMmIHo6GjOJEoDNjY20NPTg52dHUaNGoX27dszpu3t7Y29e/dCSkoK1tbWUFZWRmFhIdLS0lBVVQV7e3tcu3YNCxYsQHBwMGxtbWnR5fF4CAgIgIuLi0C6pKmpKXHD7MWLF7F48WL07dsXAKCurg4DAwMYGxtj3bp1iImJwaZNm2jXVVNTYy0ZdvXq1UhLS0NgYCBGjhwJeXl5lJWVISUlBUFBQVi9ejWxlNyysjJUV1cLpMofO3YMmZmZMDU1JZYu6ezsjPz8fAwfPhwDBgwQORajM1mokaqqKvzyyy+YNWsWnJ2d4ezsTLtGc/Tv3x/bt2+HiYmJwGftw4cP2LFjB/r3709Mu6ioCOrq6gCAp0+fIjc3F87OzpCTk4O9vT2rBs2xY8fC29u71ZhEmb6XbSmoqamhtLQUANCpUyf8/ffflEn0xYsXxHTl5eVRXV0NAGjfvj2ePXtGmUTr6upQXFxMTNvPzw9r1qxBr169WEl7/BRS497i4mK4u7vj1q1b1P1Ely5dsGXLli+m19LF0KFDm10U9ujRI+KLwmpqanDkyBHcvXsXBQUFUFNTQ79+/TBu3DiRxlW6ePjwIXbs2IFbt25RYzEjIyO4urpCV1eXmO7MmTO/i5KTmzZtwvnz53H8+HFqW0VFBRwdHfH8+XPqPnPPnj1ITEwkVjGjoqIC/v7+OHnyJMTExFBfXw9LS0uoqakhJCQEnTp1gre3NxFttggKCkJBQQHs7OyIGzU/RU9Pj7HPd9NFCqQWLLQ0bTb7LCMjg+joaLx69QolJSXo1q2bkMG6trYWO3bsQNeuXVuNNgcHB/vw+XxkZ2dT9yXfgzbXZ2b5HvvMwcHBQQLOJMrBwcHBAaDBYNVYou9zZiu6DVa9evXC+fPnv1i+/ty5c+jVqxctmp/SsWNHzJs3D/PmzcOTJ09w4sQJnDhxAsnJyWjXrh1sbGwwZswYGBkZEdFnCx8fHwANiSQnTpwQaidtpONgHicnJ0ydOhXPnz9HSUkJlJSU0K1bN9pLgbNBXFwc24cAAJTZfNSoUZgwYQKWLVtGtXXu3BmHDx+mzSSamZmJzMxM6ve///4bb9++FdinqqoKJ06cIDaZBzRMmq9evRpnzpxBbW2tQBspU25eXp7Qyt20tDTo6upi4MCBABomKKZNm4YNGzbQqs0GbJara2T79u04ceIEtm7dig0bNsDIyAh2dnYYMWIElJSUaNdrSklJCfT19bF161aB8YmPjw8WLlyIyspK7Nu3D4sXL0Z0dDRtJtFGtLS0GE9RLSoqQocOHSAuLg5ZWVm8f/+earOyssLChQuJ6C5cuBCRkZEwMjISaVgkyenTp+Hp6QkHBwdqm7y8PBwdHVFVVYXQ0FBiJlEvLy+oq6tTZaDDw8Op9Nbo6GgEBwcTSclLTk7G7t27wePxcOXKFSGTDY/HI/J9lpaWxvXr11kpbe7j44Np06bBysoKpqamVJn7xv4HBQUR01ZSUkJ2djYGDBiAixcvQk1NjbqW1NXVob6+npj2l8jKymJVnxRZWVnIyMigDGV9+vTBDz/8QLtOS0mUNzExwY0bN2BtbY0JEyZgw4YNeP78OSQlJZGamooxY8YQ0dXX18fjx49haWkJa2trbNu2DXw+HxISEoiKikK/fv2I6AJAYGAgKyano0eP4sOHD1TZ+SdPnsDd3R1v3ryBkZERNm/eDBUVFdr0tmzZgocPH2LhwoXQ19fH69evERkZiYCAACQkJNCm8znYXBSWlZWF2bNnIzc3Fzo6OlBRUcE///yDI0eOYPv27di5cyeR7/aNGzcwY8YMqKmpwdbWlqqGcfbsWUyaNAm7d+/+YlWa/xVSY62WxuXLlzFkyBCBbXv27EFmZibc3Nwwa9YsZGVlwcPDAzt27MCaNWuIHMf69etx9epVREdHY8CAAQLnLSsrK8TGxrY6kyiTRs1PWbduHSu6HMzRpUuXZtvk5OSgr68vsI3OlDQ2tTk4ODg4ODg4ODg4Pg9nEuXg4OBooVhbW3/xYSGd5Wji4uKo5I89e/Yw9qDS0dER/v7+MDQ0hL29vch9jh49isOHD/8rY8zX0rNnT/Ts2ROLFy/G3bt3cfDgQfz+++9ISEjAw4cPieszCZ2fH45vBzExMXTv3p3tw6AdExMTtg8BABAREQEXFxf4+vqirq5OwCTao0cP7NmzhzatU6dOITw8HEDDBHxISIjI/RQUFIgZq4AGQ+L169cxb948aGtrE00SaoTH4wlcp969e4c3b97AxcVFYL/27dsTTc9iivPnz8PR0RGamppfTCIhZSobMmQIhgwZgsrKSpw/fx4nT57E6tWrsWrVKgwcOBBjxowhZn5JTEzE2rVrhcYmPB4PEydOhI+PD3x8fDBmzBgsXrz4q7RaitFIQ0OD+uxqaWnh/PnzGDRoEADg9u3bkJaWJqJra2uLx48fY/DgwdDV1RVp9tm+fTsRbWlpaXTq1ElkW+fOnYmWp7537x4CAgIANJhw9u/fj3nz5mHx4sVYu3Ytdu3aRcQkGhISgpEjRyIwMJDxEqoWFha4fPkyTE1NGdXt2bMnjh07hpiYGNy8eRPPnj2DoqIiJk6ciOnTp0NDQ4OY9qBBgxAcHIxHjx7hyJEj+Omnn6i2p0+fNvv5o4uYmBihbTU1NcjMzERKSgqxcygbfPz4EcuXL8epU6dQX18PaWlpVFVVQUxMDDY2NggMDIScnBxtei0lUX7x4sXUubvRhJ2SkoKqqio4OTlhwYIFRHTnzZuHnJwcAICHhweys7MRFBSE+vp69OnTB6tWrSKiC7Bnctq1axcmT55M/R4YGAhJSUn8+uuv2Lt3L0JDQ2k1s126dAkLFy7EzJkzqW3du3fH9OnTUVpaSmxhRUtZFLZ8+XJISkoiJSVFwPzz8uVLuLq6YsWKFUQW7QUHB8PExASRkZEC4wBvb2/MnTsXISEhOHDgAO263xOvX79Gnz59BLadOXMGmpqa8PDwANBgRJ89ezZiY2OJHcfp06fh7e2NgQMHoq6uTqCtY8eOyM7OJqbNFt+LUbOoqAj5+flCqcuPHj1CREQEMjMzoaqqChcXly+WZv9WtNns8//K95gMx8HBwcHBwcHBwfE9wplEOTg4OFooQ4cOFZpsKS0txbVr1wAAw4cPp1WvqcGqsTQdE9jb2+PixYvw8/NDfHw8LC0toampCR6Ph5ycHFy6dAn379/H6NGjMW7cOEaOqba2FhcvXkRycjLOnz8PPp+Pnj17MqLNJB07dmT7EDgYJjc3F6mpqcjNzRX58JWEsex74/Xr17CyshLZJisriw8fPtCm5eLiAnt7e/D5fAwbNgzh4eFCJRclJSWhpqZGdPL+77//hr+/P2PnaADo1q0b0tPTqdTQtLQ08Hg8WFhYCOxXUFAgUD76W4XNcnWfIiMjg9GjR2P06NEoKyvD6dOnsWXLFly4cIGYwamiogK5ubki23JyclBVVQUAaNOmzVeblFuK0cjCwgLp6ekYPnw4ZTzPyMiApKQkMjIyMGPGDCK6sbGxiIqKgqqqKurq6vDx40ciOqIYP348Dhw4AEtLS4H3oNG0SbJ8dUlJCdq1awcAuH//PoqLi+Ho6AigYeHWoUOHiOi+f/8eEydOZNwgCjR81pcvX46PHz/CysoKKioqQp99kiZoPz8/Iq/9OXx8fFBXV4dLly4JJfKePXsWlpaWRPXXr18vtE1KSgoaGhpwdnaGm5sbUX0mWb16NdLS0hAYGIiRI0dCXl4eZWVlSElJQVBQEFavXk3rApaWkiivpqYGNTU16vfp06czktjbr18/KnVPQUEB27dvR3V1Naqrq4mfX9gyOWVnZ1OLXIuKinDz5k3s2LEDgwYNgrKyssjv29eQm5uLvn37Cmzr168f+Hw+cnNziZlEW8qisIyMDGzYsEEoHa5r167w8PCAr68vEd1//vkHW7duFVooIi4uDmdnZ8rESBeurq7w9fWFlpYWXF1dP7svyYUzTFJVVSXw+S0vL8fjx4+F7u169OiBvLw8YsdRXl4ucP5sSkVFBTHd7wm2qlOEhobiwYMHOHLkCLUtOzsbU6dORWVlJXr16oWnT5/C3d0de/bsgbGxMS26bGqz2WcODg4ODg4ODg4ODo7PwZlEOTg4OFoov/32m8jt1dXVWLBgAdGkG11dXSQkJMDAwECo7f79+5gwYQKtpojQ0FAYGRkhNjYWO3bsEGjr0qULli1bhilTptCm1xx///03Tpw4gdOnT6OkpAQdO3aEs7MzxowZ06rL3fz111+4d+8e3r59i/nz50NTUxPXr19Hly5d0L59e7YPj4MmTp48CW9vb/D5fCgrKzNW0pYtjh49ioSEBLx48YIykDXl1q1bRHTV1NTw/PlzmJmZCbU9fvwYmpqatGm1bduWSvk7d+4c1NXVGUnx/BQFBQXKXMUUTk5O8PHxQWlpKVRVVXHgwAF06dIF5ubmAvtdunSpVZr8WwL37t3DyZMncerUKeTn56Nbt27EtKytrRESEoI2bdpgyJAhlNno3LlzCAkJwbBhwwA0fMe6du36VVotxWjk6elJTYiPGzcOcnJyVBrdsmXLBNLT6CQqKgpTp07Fb7/9BjExMSIazaGoqIiHDx9ixIgRGDJkCFVSNi0tDdXV1TAyMqKSGHk8Hq3GK1VVVTx79gwDBgzAhQsX0LFjRyqRraKigliKqZWVFW7fvi3ymkGaefPmAQD279+P/fv3CxlzSZqg2aJt27bNmqiYSKJ79OgRcY2WwunTp+Hp6QkHBwdqm7y8PBwdHVFVVYXQ0FBaDW0tJVFeFDdv3sTz589hZGREpBx3c9TV1aGwsBBycnKslTMmiZiYGGpqagA03MdLSEhQychqamp4//49rXp1dXVC4+zGa0NtbS2tWk1pKYvC1NXVm319Ho8HVVVVIrqysrIoLCwU2fbu3TvIysrSqvfx40cqxZLJhTJs0rFjR/zzzz/UYvFr166hrq5OaPF4eXk5rQnQn9KrVy+cOXOGWgTYlD///FOoPPW3CltGTYC96hS3bt2iFl81Ehsbi/LyckRHR2PgwIGorKzEjBkzEB0dTathki1tNvvMwcHBwcHBwcHBwcHxOTiTKAcHB8c3hpSUFKZNm4aAgAA4OTkR0eDz+c221dXVQVxcnHbNqVOnYurUqcjLy6PSCdq3b0/cpHj//n0kJydTJpd27drB1tYWY8aMQf/+/Ylqs01RURHc3Nxw9+5ddOjQAbm5uZg8eTI0NTWRlJQEWVlZqvQqx7fPpk2bMGzYMAQGBgqVD6aT/zohq6SkRPsx/PHHH1i2bBns7e1x+/ZtODg4oL6+HufPn4eCgoJAeVm6GTNmDMLCwvDDDz9QhgUej4cnT55g586d+Pnnn4noNk0GrqysRGJiIjIzM6GmpgZ7e3t06NCBiC4AzJo1C3v37oWFhQXRctBNGTt2LPLy8hAfH4/S0lLo6ekhICBAQL/RXNY0Ka61UFRUhN27d1MG//DwcPTo0QN79uxB3759qTQxunn27Bl1zXz58iU6dOhAXTM/NSzQyYoVK+Dr6wsvLy/weDxISEigtrYWfD4fw4cPx/LlywEAmpqaWLJkyVdp/Rej0evXr79K63PIysoKGB+GDx9Oe4q8KGpqajBs2DDGDaJAw6KhRkSZdZump9FtErWxscHGjRuRnp6Ov/76C7Nnz6baHj58+NXm4+ZwdHTEypUrUVlZCTMzM5FJdKTSPNkyRNfU1CAmJgYpKSnIzc0VWsjB4/Fw8+ZNVo6Ngz6kpaWbXdTYuXNnxsYLTLN06VJISUlRBtgDBw5g5cqVABru4yMjI4mYwnft2oWKigq4u7sDAG7cuIH58+ejrKwMnTp1wq5du4QSIOmktLQUp0+fRlZWFmPVCnR0dLB//35oaGhg7969MDU1hZSUFICGlHEVFRXaNXfv3i1ghmx8brJr1y6h5Hq6+vzpojA1NTWqn0yyYMECbNmyBbq6ugJl7V+/fo2wsDDqs0c3Q4YMQXBwMDQ0NAQWg6WnpyM0NJT2Ms179+4V+XNrZtSoUdixYweUlZWhpqaG0NBQyMvLY8iQIQL73bx5k9h4CADc3Nzg5uaGiooK2NjYgMfjISMjA8nJyUhKSkJ0dDQxbSZhy6jZqC3qZ9Lk5eUJLbxPS0uDrq4uZQqWkZHBtGnTsGHDhlahzWafOTg4ONiEzcVpbGlzff4+tFvjwksODo7vl9b5VJaDg4OjlVNcXEx7qkFBQQHy8/Op358/fy5kBq2qqkJSUhKtSXifwoQxtJGRI0fi1atXkJWVxdChQzFmzBgMHDiQiAm2JbJmzRoUFxcjOTkZXbt2FUhmMDMzaxWl0zj+n6KiIkyaNImoQRQATE1N/9NNM4mUspiYGLi5uWHu3Lk4ePAgpkyZAj09PZSVlWHWrFlEE1Dc3d3x9OlTzJgxgzLAzpkzB0VFRRg8eDDmzp1Lm9amTZtw/vx5HD9+nNpWUVEBR0dHPH/+nJq43rNnDxITEwUmdL+WT1NPMjMzMXz4cBgbG4s0OZEwB8yZMwdz5sxptl1FRQXp6em06X2p5GRTSJaffPDgAaZPn462bdvC2NgY165dowwZeXl5iI2NxebNm2nXtbOzw7Nnz9CuXTvY2NggKCgIRkZGtOuIQl5eHuHh4cjMzERGRgYKCgqgrq4OfX19dO/endpvxIgRxI+lqKgIp06dwvHjx3H37t1Wl7Q4evRoXLhwgZVkSzZTFpcuXQo5OTncv38fM2fOpFI2gYbv3KhRo4joNppRo6KiEBUVxWiaJ1vJiytXrsTRo0dhbW0NS0tLRhOwra2tvzhGOXfuHNFjYMvkzzTjx4/HgQMHYGlpKfS53r9/P8aPH0+rXv/+/REXFwd9fX0YGhp+8X0mlSh/8+ZNeHt7U79HRUVhwoQJ8PX1xYoVKxAeHk7k/Hro0CHMmjWL+n3t2rXo3r075s6di+3btyM0NJTI2AAAXrx4gcmTJ6O6uhoVFRVQVlZGSUkJamtroaioCHl5eSLjwMWLF8PV1RVjx46FnJwclTQNAKmpqejTpw+tepqamsjIyBC5/c6dOwLbSFVoaLoorKKiQmS1BDoX4H069i0tLYWNjQ169OhBpX0/ffoUKioqOH36NOzt7WnTbsTX1xfPnj3DrFmzIC8vD2VlZRQVFaGsrAx9+vSBj48P7ZrfG7Nnz8bdu3epc1ebNm2wZs0agecGVVVVOHz4MLEkewAYPHgwQkNDsWHDBur+duXKldDQ0EBwcDArY1MSsGXUZBMejydwXX737h3evHkDFxcXgf3at2+P4uLiVqHNZp85ODg42ORz4TOtVZvr8/ehzWafOTg4OOiGM4lycHBwtFDOnDkjtK2mpgaZmZnYt28fVUqNLhISEhAeHk49yPLz8xPah8/nQ1xcvNWkS3br1g0eHh4YOnQoZGRk2D4cxrlw4QICAwOhra1NlVRrpEOHDlSiK0frwNLSEnfu3CE+uRIUFMT6ysqXL1+if//+EBcXh7i4OMrKygA0GM3mzJmDoKAgzJgxg4i2lJQUtm/fjqtXryI9PR3FxcVQVFSEubm5UCn0r+Xy5ctCCS979uxBZmYm3NzcMGvWLGRlZcHDwwM7duzAmjVraNP+dEKr8T2/ceOG0L6kJsqZpqWUnFy7di369euHiIgI8Hg8/PHHH1Rb3759cerUKSK6+vr68PHxgZmZGWuLKbS1taGtrc24bkVFBc6ePYvk5GSkp6ejtrYWvXv3FjlWogsdHZ3PlnVt27YtdHR04OLiQmuKVv/+/bFlyxYUFBQ0m2zJhBmXaSQkJJpNQdu2bRux1Fi20jybkpWVRZmv1dTU0KdPH6Ilsc+ePQs/Pz9MnTqVmEZzDB06VOh7VVpaimvXrgEA8bRetkz+TNHUpKekpIQHDx5gxIgRGDJkCGUoS0tLQ3V1NQYMGECr9syZM6Gmpkb9zNZYtKioCOrq6gCAp0+fIjc3F87OzpCTk4O9vT1++eUXIrpv376lEv7y8vLw4MEDxMfHY8CAAairq8OKFSuI6ALAunXr0LdvX2zZsgX9+vVDVFQUdHR0cPLkSWzatAlbtmwhomtkZIS0tDS8ePECXbp0EbheOTo60p6c2hLMXHw+HxEREUhISEBBQYHIfehcWPDp2FdLSwtaWloAgOrqarRt25aqvkJqnKyoqIiEhASkpaXh5s2bKC0thaKiIoyMjDB48GDak8+bnse+BN2p5mwhIyOD6OhovHr1CiUlJejWrRvk5eUF9qmtrcWOHTuIJokCDcnuNjY2yMrKou6j2Rj7t1aKioqQn58PHR0dge2PHj1CREQEMjMzoaqqSvv9Rbdu3ZCenk4laKalpYHH48HCwkJgv4KCAqFU5m9Vm80+fw3fYzIcBwfH53F2dkZAQIDI63FWVhYCAgKo5xri4uK0Lv5lS5vrM3O6bGqz2WcODg4OtuFMohwcHBwtFA8PD5HbJSQkMGLECNoNN/b29jAxMQGfz4eLiwuWL18ukM4FAJKSktDS0kK7du1o1WaLHTt2sH0IrFJXV4c2bdqIbCstLWU02YmDPCtXrsTixYtRWVkJU1NTYiVt6U6G+l+Ql5enTBft27fHs2fP8OOPPwJo+NwzkdRgampKu5n/U16/fi2UknTmzBloampS1xB9fX3Mnj0bsbGxtGq3hIlypmkpJSfv3buHsLAwSEpKChn8lZWVUVhYSES3sXQuW5SXl+PIkSO4efMmSkpKKIOAvb19s9eyr6Gurg4XL17E8ePHcf78eVRWVkJVVRV1dXUIDQ3F6NGjaddsire3N/bu3QspKSlYW1tT721aWhqqqqpgb2+Pa9euYcGCBQgODoatrS0tuo2JXDk5OThx4oRQO8lkS4D59/lzkE6NraqqwpkzZzB27FgYGBjQ+tr/ho8fP2L58uU4deoU6uvrIS0tjaqqKoiJicHGxgaBgYFEkrfbtGlDa7L1f+G3334Tub26uhoLFixotjw6XbBl8meK9evXi9wuygwdEhJCJenSQVOT98KFC2l73f+KkpISsrOzMWDAAFy8eBFqampUudm6ujrU19cT0ZWWlqYWRV25cgVt2rSBoaEhgIZy5R8+fCCiCwAZGRlYs2YNVQK9pqYG4uLisLOzQ3FxMVavXo3ff/+diLa8vLxANYxGrKysiOixTWxsLGJjYzF79mxs2rQJ8+fPh7i4OE6cOIGampr/lHr/b2gpY18xMTEMHToUQ4cOJa7V3HlMFK3FJNrI54zVcnJyIr9rX4udnR1CQkLQs2dPatvx48dhZWWFbt260a7XEmDLqAkAoaGhePDgAY4cOUJty87OxtSpU1FZWYlevXrh6dOncHd3x549e2BsbEyLrpOTE3x8fFBaWgpVVVUcOHAAXbp0EVpEe+nSJYHPwreszWafv4bvMRmOg4Pj81y7dq3ZxUBlZWUiwwK+dW2uz8zpsqnNZp85ODg42IYziXJwcHC0UESVOpSWloaKigqR1bUdO3akypfFxcWhd+/eQukBHK0LAwMDJCUliZxEO3HiBJUKwtE6+PjxIyoqKhAZGYmoqCiBNtIlbZlGX18fjx8/hqWlJaytrbFt2zbw+XxISEggKiqK9lKuOTk5/2l/TU1NWnSrqqoEzL7l5eV4/Pgxxo0bJ7Bfjx49uGTgVoSsrCxlBPmUnJwcWsuMnjlzhjKVi0o4/xRSCZO5ublwcnJCdnY2dHR0oKKigqysLKSkpCA2NhZxcXHo0KEDLVo3b95EcnIyUlJSUFxcDCUlJYwdOxZ2dnbo0aMHfvzxRyqtjiQlJSXQ19fH1q1bBcZ9Pj4+WLhwISorK7Fv3z4sXrwY0dHRtJlESZfa/hxMvs/N8WlqbF1dHXR1dYmkxkpLSyMpKYm1ZNbVq1cjLS0NgYGBGDlyJOTl5VFWVoaUlBQEBQVh9erVRMzhM2bMwP79+2FhYcFaKvGnSElJYdq0aQgICICTkxMxHbZM/kzBJWsAgwYNQnBwMB49eoQjR47gp59+otqePn1KzIhsYGCAqKgoiImJYdeuXRg0aBD1/Xr16hXat29PRBdoMFnLy8tDTEwMioqKyM/Pp9p69OhB9HPx8OFD7NixA7du3cL79++hpKQEIyMjuLq6QldXl5guWyQmJmLhwoWYOnUqNm3ahGHDhkFPTw9ubm6YP38+Xr16xfYhfvNw5zFmefr0KSorK6nf6+rq4O3tjcTERFoWsLZE2DJqAsCtW7fg6OgosC02Nhbl5eWIjo7GwIEDUVlZiRkzZiA6Opo27bFjxyIvLw/x8fEoLS2Fnp4eAgICICHx/1OTjYvh6F7owZY2m33+Em/evMGrV6/Qu3dvgWcHTKSksanNwcFBP7dv32YtDZktba7P34c2m33m4ODgYALOJMrBwcHRQmk0bLKBiYkJa9oczLFo0SI4Oztj6tSpGDlyJHg8HlJTUxEZGYkLFy5g//79bB8iB434+PggNzcXy5Ytg5aWFmNJsdevX0dCQgJevHiBqqoqofbjx4/Trjlv3jzKuOnh4YHs7GwEBQWhvr4effr0wapVq2jVs7a2/k/mfbrMuB07dsQ///xDpaReu3YNdXV11O+NlJeXE0mDa0pRURH27NmDu3fvUiWL+/btCxcXl1b7UKW+vh5Xr15FVlYWlVzblBkzZhDRHThwILZv3y5QCpzH46GyshJxcXG0pmd5eHjg4MGDMDAwaDbhvBGSRvNGo9qJEycEymA/f/4crq6uWLduHW3lbKdOnQoej4cff/wRM2bMgIWFBTWZRzKJ7VMSExOxdu1aoXMLj8fDxIkT4ePjAx8fH4wZMwaLFy+mRbOqqgqBgYGYNWsWrRPS/xYm3+emfC41NiQkhGhqrKGhIe7cucPK2Pv06dPw9PSEg4MDtU1eXh6Ojo6oqqpCaGgoEZOos7Mz8vPzMXz4cAwYMEBksjndFRP+DcXFxcTKJTfCpMn/e+T169e4dOkSamtrMXjwYHTu3BlXrlxBSEgInj17hnbt2uHnn3/G3LlziR2Dj48P6urqcOnSJVhZWQkYP86ePQtLS0tiuvPmzYOrqys0NTUFrgunTp2iUkVJoKWlhezsbBgbG6N3797Yv38/zM3NISEhgYSEBKirqxPRvXHjBmbMmAE1NTXY2tpCRUUFhYWFOHv2LCZNmoTdu3djwIABRLTZIjs7G7q6uhAXF4eEhARKS0sBNCRtTpkyBb/99huWLFlCTD83NxepqanIzc0VOfZl49zN0fpo7WmCbBk1ASAvL49Kt24kLS0Nurq6VFl0GRkZTJs2DRs2bKBNFwDmzJmDOXPmNNuuoqKC9PR0WjXZ1mazz42sW7cOdXV1VJr+2bNnsXjxYtTW1kJRURG7du0ikhLMtjYHB8fXERkZicjISAANz6BcXFyEnk1VV1ejrq4OU6ZMaRXaXJ+5PpPU5eDg4GhpcCZRDg4OjhZETU0NqqqqhBI8CwoKsHv3bmRmZkJNTQ2TJ08WKjH8tfTv3x9xcXHQ19eHoaHhZw1PPB4PN2/epFWfg3kMDQ0RFxeHkJAQrF+/Hnw+Hzt27EC/fv0QGxvbapMbvlcyMjIQEhKCYcOGMaZ58eJFzJs3D2ZmZrh//z4GDRqEyspK3Lp1CxoaGsRMSP369aPSQhUUFLB9+3ZUV1dTSUd0Ex4eTv1cXl6OkJAQdOnSBSNGjICKigrevXuHM2fO4PXr1/D09KRNd9SoUdixYweUlZWhpqaG0NBQyMvLY8iQIQL73bx5E127dqVN91Pu3r2L2bNno76+Hubm5tDS0kJhYSHi4+MRHx+P3bt3o2/fvsT02aCgoABOTk548eIFeDweNZnZ9NpJyiTq5eWFn3/+GSNHjsSPP/4IHo+HzZs349mzZ+DxeFi0aBFtWufOnaNSM9lMmExPT8eqVasEjIMA8MMPP+CXX35BQEAAbVo9e/bEkydPcP36dYiLi6O4uBjDhg1jPF29oqICubm5IttycnIo032bNm1oM/1LS0vj+vXrrJVOZfJ9BlpGaqyHhwc8PT0hLi4OKysrkRUDSBkHpaWlm0017Ny5s0DSEZ0kJydj9+7d4PF4uHLlitDnl8fjETMaiUpErqmpQWZmJvbt2wdTU1Miuo0wafJngwcPHvyn/em817hx4wbmzJmDyspKiIuLU/c3Xl5e6NatG4YMGYJnz55h06ZNUFNTg729PW3aTWnbtm2z5uoDBw4Q0QSA7t2749y5cyguLka7du0E2nx8fIiey2xtban0r19++QWzZs2CiYkJNT5at24dEd3g4GCYmJggMjJS4Hzl7e2NuXPnIiQkhOj/nA2UlJRQXl4OoKEywcOHD2FmZgagwejeNJGRbk6ePAlvb2/w+XwoKyszeu5mkgcPHkBbWxsyMjL/6pzGPTPh+K+wadTk8XgC48x3797hzZs3cHFxEdivffv2KC4uplWbgx3Onj0rsNgzNDQUVlZW+OWXX7BhwwZs3rwZO3fubHXaHBwcX4ehoSFmzpwJPp+Pbdu2wdbWFhoaGgL7SEpKQltbW+gZ9LeqzfWZ6zNJXQ4ODo6WBmcS5eDg4GhBrFu3DpcuXcLp06epbcXFxbC3t8e7d++gqKiIsrIyHD9+HAkJCbSWUJs5cyY1eTRz5kwiJe2bo6ysDLdu3UJtbS1MTEwgLy+PJ0+eYNu2bQKpL3SVUuX4fwwNDREfH4/KykqUlJRAQUEBsrKybB8WBwG6du2K2tpaRjXDwsLg4uICT09P6Onp4ZdffoGenh6ys7Mxa9Ys4maMpkhJSUFKSorIazc13vr7+8Pc3FzIIODs7Aw/Pz+kp6fDzs6OFt3Zs2fj7t278Pb2BtBgFluzZg3atm1L7VNVVYXDhw9j8uTJtGiKYuXKlejevTuio6MFjHQfPnzAnDlzsGrVKiQlJRHTZ4N169ZBSUkJFy5cgJWVFQ4ePAhVVVUcO3YMR48eRVRUFK16r1+/RufOnQE0TNodPXoUsbGxSE9PR5cuXfD+/XvY2dlhxowZtBrKmqaafy7h/O3bt7h+/TqxFPS6ujpIS0uLbJOWlhYq2/w1HDt2DM+ePcOxY8dw4sQJ+Pr6QkZGBlZWVhgyZAhj4yNra2uEhISgTZs2GDJkCFUK/Ny5cwKG/8ePH9NqArewsMDly5cZPT83wuT7DLSM1NjGc/PGjRsRHBwsch9SCb3jx4/HgQMHYGlpKfC55vP52L9/P8aPH09ENyQkBCNHjkRgYCDj5uvmEpElJCQwYsQI4gYnJk3+bODg4PCvzpF8Pp/29OmwsDAYGBggLCwMMjIyWLt2LXx9fWFrayswJvPy8sLevXuJmUTZ5lODKAD06tWLqGbTRTH9+vVDcnIyLl68iMrKSpiamqJnz55EdP/55x9s3bpVyNAuLi4OZ2fnLyagf4v0798f9+7dg5WVFcaMGYPw8HC8e/cOEhISOHjwIGUYJUFjefvAwECBe43WhoODA5Wi/7lzGonzGMf/w+TzSKZh06jZrVs3pKenU2bUtLQ08Hg8WFhYCOxXUFDQaquBfG8UFBRAU1MTAPDq1StkZWVh48aN6NmzJ5ycnODj49MqtTk4OL4OExMTqtoJj8fDhAkT0L59+1atzfWZ6zMHBwfH9wRnEuXg4OBoQdy4cQM//fSTwLaYmBi8e/cOgYGBmDBhAgoLCzF9+nRERkZi8+bNtGm7u7tTPzcti0eaJ0+eYNasWSgoKADQUG5ny5YtcHNzg7i4ODp37oxnz57B09MTsrKysLa2pk27vr4ef/75Jzp37iy0kr/p8b1584ZRYwgbyMjIQEZGhu3D4CCIn58f1q9fjx49ekBbW5sRzczMTCxevBhiYmLg8XioqKgA0GA2W7hwIcLCwoTOeXTRaLh/+/atUJl7Ho+HPXv2ENFNSUlpthyyra0tFi9eTFv5XhkZGURHR+PVq1coKSlBt27dhAw3tbW12LFjB9Ek0WfPnmHLli1C2m3btsWcOXNoK4Xdkrh+/Tr8/f0Fkrk0NTXh6uoKPp+PVatW0ZqKMXz4cBgaGmLMmDEYNWoUlJWV4eHh0WIMEI1mZboM0J/Sv39/bN++HSYmJgLGhA8fPmDHjh3o378/rXrdu3fHkiVLsGTJEipt8vTp0zh9+jR4PB7i4uIAgGhJ9hUrVsDX1xdeXl7g8XiQkJBAbW0t+Hw+hg8fjuXLlwNo+NzRWVrWwcEBy5cvx8ePH5tNtiSVmsX0+9wSUmODgoJYG18qKiri4cOHGDFiBIYMGUKVak5LS0N1dTWMjIwQExMDoOG6SVfC7Pv37zFx4kTGDaKA6ERkaWlpkZ9zEnzO5D9p0iRaF5KwQeO5kQ0ePXqEdevWUQmt8+fPx4EDB4T+n3Z2dkTLcVdWViIiIoIag4oqyU3KVMbG2LeqqgobN27E2LFjYWBgAADo0KEDJk6cSLvWp8jKyqKwsFBk27t371rlwkd3d3fk5eUBAFxdXVFaWork5GRUVVXB3Nwcy5YtI6ZdVFSESZMmtWqDKNBwHmu8V2bznPY9IarMZ+NCnqa0lopGbBo1G415paWlUFVVxYEDB9ClSxeYm5sL7Hfp0iViBn8OZmnbti11rbx8+TIUFRWpEu9SUlJC44XWos3BwUEfTecMvxdtrs/fhzabfebg4OBgG84kysHBwdGCyM3NFUoHPXfuHLp164YJEyYAaDBRzpw5E2FhYcSOw9nZGQEBASKNZFlZWQgICKDtgXloaChUVVURHR0NOTk5bNy4Ee7u7ujfvz+2bt1KPThyc3NDdHQ0rSbRw4cPY926dUhOTm52HwUFBXh7e8Pf3x/jxo2jTZst/Pz8/tP+dJnZONgnKCgIBQUFsLOzg7q6utAEH4/Hw7Fjx2jVlJaWRn19PXg8HtTU1PDq1SsMGDAAACAnJ4e3b9/SqtfIzp07ERwcjI4dO0JbW5vRyUxxcXE8fPhQaJIHAB4+fAgxMTHaNbt06dJsm5ycHPUgnhRdu3ZFaWmpyLYPHz5QCZitiQ8fPkBZWRliYmKQl5cXMCn069eP9iTR3377DSdOnEBgYCDWrl0Lc3Nz2NnZYdiwYa3SBPEpPj4+mDZtGqysrGBqagpVVVUUFhZSpaqDgoKIaRsZGcHIyAj+/v64dOkSkpOTce7cOaSmpkJTU1Ok6YwO5OXlER4ejszMTNy7dw/5+flQV1eHvr4+unfvTu03YsQIWnXnzZsHANi/fz/2798vlDBJMjWL6fe5JaTGkkrr/DeEhoZSP4sa14eEhFA/02kStbKywu3bt4km3jUHqbTj/4KCgoJIk//p06eJmu2ZoDGR49/w+vVrWrVLSkqgoqJC/d74s6KiosB+ioqK+PjxI63aTVm5ciWSk5MxZswYaGtrC5XkJgVbY19paWkkJSXRfi36NwwZMgTBwcHQ0NAQMDilp6cjNDSU1ucGAHDmzJn/tD+J/8kPP/yAH374AUCDwcbf35+xEu+Wlpa4c+cOK+fuuro63L17t1njNZ3PaZqex/7LOa018fz5c5w5c6ZZwzmd47HvcXKeTaPm2LFjkZeXh/j4eJSWlkJPTw8BAQECicyNC4aYDA/gIMeAAQOwdetWFBYWYteuXQJVcJ4/f44OHTq0Sm0ODg56efnyJQ4fPowXL16INHjv2LGj1Wlzfeb6TFKXg4ODg204kygHBwdHC6KmpkYgzbG0tBTPnz8XKhPcuXPnZlMz6ODatWvNTp6VlZXhxo0btGndu3cPy5cvh46ODgDA29sbw4YNw5QpU6jS0NLS0pg2bRp8fX1p0wWAP/74A5MnT4aGhkaz+2hoaGDKlClISkpqFSbRT40deXl5KC4uhqKiIpUgVVJSgnbt2n32/8Lx7aGnp8d4WpmOjg6ysrJgYWEBMzMz7NixA+3atYOEhAQ2b95MLJ1i//79mDZtGmOTpk0ZO3Ystm7diqqqKgwbNgzKysooKirC2bNnERUVRbTsO1t4eXlh1apV6NChg8Bk6t9//43w8HCiqUZs0alTJ+Tn5wNoSJ38448/MGTIEABAamoqrSXfgYbJRCcnJ2RnZyM5ORnJycnw8vKiErbHjh2LgQMHQlxcnFbdlkLPnj1x7NgxxMTE4ObNm3j27BkUFRUxceJETJ8+nZHrlbi4OKysrGBlZYXKykqkpqZ+dpEJXWhrazOW/gywm5rFxvvcElJjgQaDW0ZGBkpKSqCoqAgDAwMhcxvdPHr0iOjrN4ejoyNWrlyJyspKmJmZUcmPTSGVVgs03G8dOXIEd+/eRUFBAdTU1NCvXz+MGzeOMUPf90pRURFOnTqF48eP4+7du62yTHNaWhpleGcSNse+hoaGuHPnDuOGOl9fXzx79gyzZs2CvLw8NeYuKytDnz59aC9j+1/S25koQ56bm4vc3Fzo6OigTZs2RLWABgP04sWLUVlZCVNTU8bO3Q8ePMDChQuRm5sLPp8v1M7j8Rh7TlNaWooXL16gXbt2rXIRHAAcPXoUv/76K6SlpaGpqSl0XaT7ecL3aBJl26g5Z84czJkzp9l2FRUVpKen067LwQ6//vorvLy8EBwcDD09PYEqL8eOHaMWcbc2bQ4ODvrIyMiAk5MTNDU18eLFC/Tq1QsfPnxAdnY2NDQ0Phtc8K1qc33m+ky6zxwcHBxsw+OLesLCwcHBwcEKP/30E2xsbDB//nwAwMmTJ7F06VJs2bJFIIkiNTUVK1euxMWLF4kch46ODg4ePEiVjGtKXFwcoqKicOnSJdq0EhIS0LdvXwANpZH19fWRlJQkMMlw9+5dTJ48mdbJFiMjI2zZsoUq89Qcly5dwqJFi2g1x7YE/vrrL6xYsQJBQUEwNTWltl+5cgW//fYbAgICYGVlxeIRcnzrXLhwAW/evMHUqVORl5cHV1dX6jusoaGB8PBwIimX/fv3x7Zt21hJuqmtrUVISAgOHDggsAJVWloakydPxtKlS1udCcXOzg75+fkoLS1F27Zt0a5dOxQXF+PDhw9QUFCAuro6tS+JxFo2CAkJQVFREdasWYMLFy5gwYIFaNu2LSQkJPDu3Tt4enpi1qxZRI/hyZMnOHHiBE6cOIE3b96gXbt2sLGxwZgxY2BkZERU+1NOnz6NRYsWtUrDD5M8ePAA2trakJGRwYMHD764P0kj3fdMXV2dQGpsRUUFsdRYPp+PjRs3Ij4+XiAdTUpKCk5OTvDy8qJdk20aF4Y1wmRabVZWFmbPnk0ZqxoXSD169AgaGhrYuXMnldLHNK31PFpRUYGzZ88iOTkZ6enpqK2tRe/evTFu3Dg4OzvTpqOjowMbGxuoqqoCaPgs7du3D6NHjxYo1/vu3TucPn2a2P/ZwsIC69ev/+L9Jd2wOfa9c+cOPD098fPPP8PKygoqKipCRjK6F880Ul9fj7S0NNy8eROlpaVQVFSEkZERBg8eTHt6f3Z29n/an1RycUJCAsLDw1FQUAAej4fExETo6elhwYIFMDExgYuLCxHdnJwcLF26FLdv3xZ6f0meuydMmICqqir4+/uje/fuIu+j6E7OPXnyJM6ePYva2lrY2NjA1tYWERER2LFjB2pqagA0fNe3bt3KiEGXSUaOHInevXsjKCjou6hWwMHxPVNWVgYpKSkqoOF70ebg4PhvODk5oWPHjlizZg309PSoObtbt25h6dKlWLVqFSwtLVuVNtdnrs+k+8zBwcHBNlySKAcHB0cLwtHRkSrtqKqqiu3bt0NFRQWDBg0S2O/vv/+mfQIzMjISkZGRABoma11cXIQe/ldXV6Ourg5TpkyhVbupDpNJhzU1Nf/qgZSUlJTIsmbfOhs3boSHh4eAQRQAzMzMsHDhQmzcuJEzibZS+Hw+8vP/j737DIji+v4G/h06SpNmC4piAVFpgoJRFIgNMSqiWBDBiqIRRAED9gKCLRQL9hZRsSC2hGiMsYtijR0VlaJ0DEWWfV74sH/XXaL5ZWYHl/N5E9g72XMvwuzszrnn5EJPT0+sYgXbPv79ady4MQ4ePIjnz5+jvLwcrVu35uwD4d69eyMtLY2XG+VKSkoIDg7GlClT8ODBA7x9+xYGBgZo164d51Xh+GJubs55S/u6ZtasWaKvHR0d8fPPPyM1NRXl5eVwcHCQybmzXbt2aNeuHQICAnDz5k3s27cPe/fuRWJiIu7du8d5fMI+d3d30SYdd3f3Wq+JuE6kA4BHjx4hLS1NVNnSxsYGbdu25SxeXSLLqrHr16/H9u3bMWHCBPTv3x/6+vp4+/YtTpw4gU2bNkFLSwuTJ0/mJDYA/P333zh06JDEv/WQIUM4S3zhs1rtvHnzoKysjJMnT4pVhXj+/DmmTJmCBQsW8Do/eSEQCHDu3DkcPXoUp0+fRnl5OfT19SEQCLBq1SoMGDCA9ZjNmjXDrVu3JB5LT0+XOJbL9qYjR47EkSNHZJ4kyue1b02V/KioKERHR0s9hqvXKwUFBTg7O8PZ2ZmT5/8YV0mf/8a2bdsQHR0NHx8f2Nvbw9fXVzRmZ2eHkydPcpYkGhwcjKysLISHh8PY2Fhmm94eP36MNWvWyKxS7YEDBxAWFgYzMzM0bNgQc+bMwd27d7Fz506MGDECJiYmePjwIfbv34+EhAT88MMPMpmXrOTm5mLBggWUIEqIHHv58iVevHiBDh06QENDo97EJoT8bx48eIBJkyaJNmDVFESwtraGv78/Vq5cyVkiHV+xac20Zq7XTAghfKMkUUIIqUNGjRqFJ0+eIC4uDlVVVWjWrBlWrVol0YL+yJEjmDRpEquxrays4OvrC6FQiLi4OLi6ukq09VRWVoaJiYmopS5bUlJSkJaWBuBDNRCGYXD06FFcuXJFdMzr169ZjQl8uEF47969z95wuHv3Lqc3E/ny/PnzWqu6aGtr48WLF7KdEOHcuXPnEBMTg3v37kEgEIgqz4SHh8PW1haDBg3iND7DMDA2NuY0BvAh0WrBggWoqKiAg4ODzFvZAh/+hmTddpMvERERfE9B5l6/fg0DAwPRDfJOnTqhU6dOAD5sQHj9+jWaNWvG+Tyqqqpw7tw5pKSk4PTp0xAKhWjXrh1rz29lZfVFmzcEAgFrMWu4ubl98bHyUqF2x44dotbyfCWqVVZWYvbs2fjll18gFApFG2UYhkHfvn2xYsUKVhP86/q/s5qaGgYOHIiBAwdy8vz79++Hn5+fWLtVfX19mJqaQllZGYmJiZwliWZlZcHLywuvXr0SVdXMyMjAyZMnsW3bNuzYsYOT618+Xxtv3bqFFStWSLQNa9myJWbMmIGQkBCeZiYf0tLSkJKSgpMnT6KgoAA6OjoYNGgQ3Nzc0LZtW3Tt2hUGBgacxD59+jQnz/tvqampIS0tDZ6enrC3t5e4BmUYBuPGjWM9Lp/XvsuWLZPpRs9P5eTkICcnR6yCfw1bW1vO45eVlUmNzUX11F27dmHq1KmYOnWqxLVXq1atkJGRwXrMGrdu3cLKlSvh4uLCWQxpjI2N8e7dO5nF27lzJ0aNGoV58+YB+JA0Gh4ejpkzZ4q9Huvp6SElJUXukkS7dOmChw8f8pJwTghhX0REBAQCAX788UcAwK+//oqAgABUVVVBW1sbmzdv5mzDL5+xCSHsYRgGysrKYBgGenp6eP36NaytrQF86BL27NkzuYtNa6Y1c71mQgjhGyWJEkJIHaKoqIgFCxYgJCQEf//9t1hrvBoNGjTAqVOnWN9xa2dnJ7ppyzAMPDw80LhxY1Zj1EZaIsS2bdskHmP75lPv3r2xZcsWuLq61nrD8s2bN9i6dStcXV1ZjV0XtGnTBhs3boStrS0aNmwoery0tBQbN25EmzZteJwdYVtKSgpmz56N/v37w8PDA+Hh4aIxIyMjHDx4kJUk0a1bt8LNzQ36+vrYunXrPx7L1Y3ymqo6CQkJSEhIkGkrW+DDzept27bh+vXrKCwshI6ODmxsbODt7S2z8ypfysvLUVxcDC0tLbENDvLG2dkZiYmJ6Ny5s8TYgwcP4OHhwenv2OXLl3Hs2DGcOnUKRUVFaN68OcaOHYuBAweyWu3R19eXt8QPc3NzXpNO+PBx8hxfiXSrVq3C2bNnsXDhQgwYMAAaGhooLS3F8ePHsXz5cqxevRrBwcGsxauP/84fe/PmjehD6E9ZWVmJqvxzYfny5QCAY8eOiXUoePr0KaZMmYKIiAisXbuWs/hPnjzB7du3kZ2dDXd3dxgYGOD58+fQ09PjrLKQoaFhrb9vDMOIWpWzic9ke1kbPXo0GIZB165d4ePjg+7du4sq1peUlPA8O9moqaT5+vVrqVVM5fHad+jQoZw87+dkZmZi9uzZuHnzJoAP6/wYl2sWCoWIj49HYmIi3rx5I/UYLmLn5OTAyspK6piysjL+/vtv1mPWaNmyJaqqqjh7/tqEhoZi6dKlaN++vWgjDZdevHghtmGgb9++CAsLg42Njdhxtra22LhxI+fzkbXAwEDMnj0bqqqq6N69OzQ1NSWO4SIBmhDCjV9//RUzZswQfb9q1So4Ojrihx9+wIoVK7BmzRps2rRJ7mITQthjYmKCzMxMdOvWDZaWltiyZQvatWsHJSUlbNy4EUZGRnIXm9ZMa+Z6zYQQwjdKEiWEkDpITU2t1uQaJSUlNGrUiNP4H1cz4tr9+/dlFutTkyZNwokTJzB06FBMmTIFPXr0QNOmTcEwDLKysnDu3Dls2LABCgoKmDhxIm/z5EpYWBgmTJgAR0dHdO3aFXp6esjLy8Ply5chEAjowzo5Ex8fD29vb4SEhEAgEIglibZt2xbbt29nJU5kZCRsbGygr6+PyMjIfzyWqxvlfLaKffjwIcaMGYP379+je/fuMDU1RV5eHvbu3YukpCTs2rWLk5bNq1evRkFBARYtWiQxNm/ePOjp6XFa6ebMmTOIjY3FX3/9JUpGMDMzw4wZM2TSel3WPk1E+FhlZSWrlRZr3LlzBykpKThx4gRyc3PRqFEjuLq6YuDAgbUmmf1X06dP5+R5vwRfFWp37NgBV1dX0S7yjyvGytL9+/eRk5Mj9e/n7NmzaNy4MUxNTVmPe+zYMQQGBmL48OGixzQ0NDB8+HCUlZVh06ZNrCaJ1sdKxB9r3rw5fv/9dzg4OEiMnT17ltP2xhcuXMCiRYvEEkQBoHXr1vjhhx8wf/58TuKWlZUhLCwMx48fh4KCAqqrq9GjRw8YGBhg5cqV+OabbzBnzhxOYk+bNg1r166FmZmZ2Af+mZmZiImJ4eQ9EJ/J9rLWrl07PHz4EFevXoWioiIKCgrg4uJSr9qJ8vXels9rX2dnZ8TFxUl9TXr48CH8/Pzw22+/sR43LCwMOTk5WLZsGUxMTDi59qrNtm3bsG3bNkyYMAGrV6+Gn58fFBUVcezYMbx//x5TpkzhJG6zZs1w+/ZtqVUeb968yWnHhtDQUERGRqJt27YySdassXjxYrx58wZubm4wNDSUSFpku8p4WVmZ2AbaBg0aAIBE+3U1NTW8f/+etbh1xZAhQwAACxYsqPW1i8uNcIQQdr1580bU4eTFixfIyMhAVFQU2rVrBy8vL1bf19Wl2IQQ9gwfPlzU4S8wMBC+vr74/vvvAXy4Pvrpp5/kLjatmdbM9ZoJIYRvlCRKCCFEqufPn+PgwYN49uyZ1PZp69ev52FW7NLV1cWOHTsQFBSExYsXS3wILhQK0blzZ0RHR0ut6vq1s7a2xi+//IJt27bh1q1bePr0KQwMDODp6Qlvb2/O2kESfmRmZtaarKeurs5ahaePb47zdaOcz1a2kZGRMDIywpYtW6CtrS16vKioCL6+voiMjOQkATslJaXWhD4bGxvExcVxliSampqK6dOnw8LCAiEhIdDX18ebN29w8uRJ+Pn54aeffpJ5a0ouPHnyBE+ePBF9f/nyZWRnZ4sdU1FRgWPHjrG+27hv37548eIF1NXV4ezsjIEDB+Lbb7+FoqIiq3G+BlxXq12+fDksLS2hp6f3jxVjubZs2TJYW1tLPW/funUL169f/2y15v9FUVGRRNJgjdatW6OoqIj1mPXZuHHjsGDBAuTn56Nfv36iDTsnT57EsWPHsGDBAs5iCwQCqKqqSh1TVVXlrLJlZGQkLl26hISEBHTp0gWWlpaiMUdHR2zbto2zJNGTJ0+iuLgY/fr1Q9u2bUU/70ePHkFPTw+nTp3CqVOnAHxIPFq3bt1/jslnsr2sJScn4/Hjx0hOTsaxY8cQEhICNTU1ODo6onfv3vUmWZYPfF77vnr1CpWVlVLHysvLJa6V2HLr1i1ERkaiT58+nDz/Pzlw4ACmT5+O0aNHY/Xq1XBxcYG5uTmmTp0KPz8/vHjxgpO4w4cPR2xsLBo1aiRad1VVFX7//Xds3rwZM2fO5CQu8OG6RJbJmjXqSsXxujAHWVi2bFm9WSsh9YGmpiby8vIAAOfPn4e2traoxbuKiorUz/vlITYhhD2DBw8WfW1iYoLjx48jPT0d5eXlos/O5C02rZnWzPWaCSGEb5QkSgghRMKtW7fg5eWFZs2a4dmzZ2jfvj1KSkrw6tUrNGnSBC1atOB7iqxp2bIl9u/fj2vXruHq1avIyckBADRu3Bh2dnYSbcXkjb6+PoKCgvieBpEBAwMDPH36VGrlmQcPHoh2+LOloqICUVFRGDRoEC8JVgA/rWyvX7+OqKgosQRRANDW1oafnx9mz57NSdzc3Fw0bdpU6liTJk04u0EPALGxsXB1dRW1WK3h7e2NoKAgxMbGykWS6IkTJxAbGwvgw43ilStXSj1OS0tL1MaZLa1atcKMGTPg7OzMSWLk10BW1Wp1dHSQmZmJzp07/2PFWK7dv38fEyZMkDpmaWmJXbt2cRK3devWOHLkCL799luJseTk5FoTSNlSXFyMU6dOISMjQ2rSUVhYGKfxZc3T0xPv379HfHw8UlJSwDAMhEIhdHV18eOPP2LEiBGcxba2tsa6detgZ2cnluxTUlKC9evXc1ah+NSpU5gzZw6+/fZbiUTU5s2b49WrV5zEBYB3797B2NhYVG2vsrISmpqaorW+e/eOs9j1RZs2bRAYGIjAwECkpaUhJSVFlHzLMIyo4qWtrS3PM+VWRUUFMjMzpSZAmJub8zAjdlVUVKCsrEz0OllaWorCwkKJY1JTU2FoaMjJHBo3bgwFBQVOnvtzXr16BTMzMygqKkJJSQnFxcUAAAUFBYwaNQo//vgjAgMDWY87fvx4ZGVlYd68eaJqzyNHjgQAjBo1CqNHj2Y9Zg2+kjX5qDgeFBQksYkiICBArFqtvCY3DR06lO8pEEJY1KVLF/z000/Iy8vD5s2bxT6Xefr0aa2fIX3tsQkh3GnYsCG6d+9er2LTmutHbD7XTAghskZJooQQQiRERUWhf//+WLp0KczNzUX/vX79OmbNmiWXrde7dOmCLl268D0NQjgzcOBAxMTEoHXr1qJqQwzD4OHDh9i0aZPoBiNbVFVVkZSUxEt1Hz5b2SoqKtZaTamyspKzyo+6urp49OgRunbtKjH26NEjiaRVNj19+rTWZPPvv/8e06ZN4yy2LHl7e2PIkCEQCoVwcXFBbGwszMzMxI5RVlaGgYEB6zfR5aF6938hy2q1vXr1QnBwMFauXAmGYTBt2rRaW9gyDIPU1FRW4n6qsrKy1jamlZWVnCUnTJ06FT/88ANevXqFPn36QF9fH3l5eTh16hTS09Oxdu1aTuICwLNnz+Dp6YnKykqUlZVBV1cXRUVFqKqqgra2NjQ0NOQuSRQAvLy8MHr0aDx9+hRFRUXQ0dFBq1atOE9+Cg4OxpgxY+Do6Ihu3bqJ/q0vXrwIZWVlLFu2jJO4f//9d63V6svKyjiJWWPnzp2cPj8RZ2NjAxsbG4SFheHPP/9ESkoKfvvtN6SmpqJZs2actCDnW2VlJRYsWIDk5ORaq/Fy1ar58OHDSExMrLUTyPXr11mLlZCQgLi4OAAfXgvHjx9f67H+/v6sxf1YQECAqCKxjo4OJzFqo6Ojg7///hvAhxbw9+7dE23EKygoQHl5OWexw8LC4O3tjQsXLqCgoADa2tqwt7fntNU8wE+y5qe4riYP/F+79Y/VVL77lDxvKC4qKsKjR4+QlZWFnj17QltbGxUVFVBWVuYtOZsQ8u/NnTsXs2fPRnR0NMzNzREQECAaS05O5vRzcD5jE0L+mzt37mD8+PFYsWJFrZuyz549izlz5mD79u0wNTX96mPTmmnNXMYlhJC6hpJECSGESHjw4AEmTZok+vC35iaTtbU1/P39sXLlSvTo0YPPKRIWlJeXIz4+HqdOnUJ2drbUxDaubmIS2fP398ejR4/g4+MjupE6ceJE5Ofno1evXpg0aRLrMa2srJCeni7zFph8trJ1cHDAmjVrYGZmhlatWokef/bsGdauXQsHBwdO4rq4uCAmJgadO3cWq9x669YtxMXFoX///pzEBT5USc3IyJBaeTAjI4PTBFVZ0tTUhKamJioqKjBnzhwYGRmhefPmfE+rXpBltdpFixbB2toaT58+xdatW2Frawt9fX1WnvvfMDMzw5EjR+Ds7CwxduTIEc4+qOzTpw9iY2MRFxeHyMhIsaqtsbGxcHJy4iQu8CEBxcLCAmvXroWlpSU2btwIU1NTHD9+HKtXr+Y0QZVvCgoKaNOmjUxjtmvXDsnJydi6dSvS0tLw+PFjaGtrY/jw4Rg3bhyaNGnCSdz27dvjl19+kfqa8fvvv9eajPNfVVRUwMPDQ1TFlMiOoqIiHB0d4ejoiPLycqSmpiIlJYXvaXEiLi4O58+fR0REBIKCgjBv3jw0aNAAycnJePHiBcLDwzmJe+TIEYSHh2PIkCG4ceMG3N3dUV1djdOnT0NLSwvff/89q/FcXFzQvHlzCIVCzJ07F35+fhLdRpSVlWFiYiKxoea/mDJlitj32dnZcHJygpmZmdT25+vWrWMt9sesra1x+/ZtODo6YuDAgYiNjcXbt2+hpKSEffv2Se3c8F9VVFTAwcEBUVFRcHJy4rTSdF0jq2ryAFjvBvC1qa6uxpo1a7Bz506UlZWBYRgcOHAA2tra8Pf3h4WFBWeJ34QQ9jVu3FhUxf1TmzdvrnUz5NcemxDy32zfvh1WVlb/eJ3l6OgIGxsbbN26FZGRkV99bFqz7OLyGZvPNRNCSF1CSaKEEEIkMAwDZWVlMAwDPT09vH79WtSGsUmTJnj27Bm/EySsWLhwIVJSUjBw4ECYmJhAWVmZ7ykRDqmoqGDdunW4dOkSzp8/j8LCQmhra8PBwYGzxMUZM2YgKChIlBygp6cnUWGRi8o/fLayDQkJwZgxY+Dq6oq2bduKKrM9fPgQTZs2RWhoKCdxZ86cievXr2PEiBEwMTGBoaEhcnNz8eTJE5iZmYlVbWDbgAEDsGrVKqipqaFv377Q0tJCSUkJTp48iTVr1mD48OGcxeaDqqoq1q5dy1kiE5Eky2q1ysrK8PDwAPDhXDJp0iRedo5PnjwZfn5+mDRpEoYOHSr6mz548CD+/PNPxMfHsxbrt99+E2s57uzsDGdnZ/z9998oKSmBpqYmGjRowFq82ty6dQtLly4V3TB8//49FBUV4ebmhoKCAixZsgR79+7lfB5cO3z48L86fvDgwZzMA/hwXc/V61Jtpk6diqlTp6KsrAz9+vUDwzC4desWUlJSkJSUhISEBE7iqqqqIicnhyqg8UxNTQ0DBw7EwIEDWX3eX3755V8dz1Wl+5MnT8Lf3x/9+/dHUFAQOnfujI4dO2Lw4MEIDg7G6dOnWU9qA4CtW7di6tSpmDRpEvbt24dRo0bB3NwcpaWlGD9+PBo2bMhqPFNTU9FrI8Mw6NWrFxo1asRqDGnevXsn9v3HiamfjnHJ398fOTk5AD4krhYXFyMlJUWUyMlFMrCqqirU1dU560rwOV/yWsFFgqUsq8kTYO3atdi1axeCg4Nhb2+Pvn37isacnJywf/9+ShIlRE5oaGjUy9iEkM+7cuUKgoODP3vcwIEDWU+i4ys2rVl2cfmMzeeaCSGkLqEkUUIIqWNKS0tx/fp1VFVVwc7ODhoaGnj48CHi4uLw+PFjNGrUCCNHjoSrqytnczAxMUFmZia6desGS0tLbNmyBe3atYOSkhI2btwIIyMjzmIT2Tlz5oyo1SipP7p164Zu3brJJJanpycAICoqSqICYA0uqtXy2cq2WbNmOHr0KJKSkpCWlobi4mIYGxvD3d0dQ4cOZf0mfQ1NTU0kJibi8OHDuHTpEgoLC9GuXTt4e3vj+++/57RKw6xZs/D69WuEh4dj3rx5UFJSQlVVFYRCIfr06YPAwEDOYvPFzMwMjx8/lnmV3PqKr2q1p0+f5uR5v0SvXr2wcuVKrFixAjNnzgTDMBAKhWjSpAmio6PRq1cv1mL5+/sjMTERnTt3hpmZmejrBg0ayCQ5tEZlZSU0NDSgoKAAbW1t5Obmisbatm2L+/fvy2wuXAoJCfnsMR9vqOAqSdTZ2RlxcXFSk6AfPnwIPz8/TtqB9+rVC6tWrcKKFStw9OhRAB82LtX8bnNRga9Gnz59cOLECc42xxD+zJgx44uPZRiGs24J2dnZaNWqFRQVFaGqqori4mLR2KBBgxAYGIiFCxeyHvf58+ewtraGoqIiFBUVUVpaCuBDEsbEiROxbNky+Pj4sB4XkN6emys7d+6UWax/0rp1a7Ru3RrAh414YWFhCAsL4zzu4MGDceDAAU4SjT9H2t9McXExsrKy0KhRIzRu3JiTuLKsJk+AQ4cOITAwEJ6enhKbLVu0aIHMzEyeZkYI+VJTpkxBSEgIjI2NJSpwf4rtqtt8xiaEsCcvLw+GhoafPc7Q0BB5eXlyEZvWLLu4fMbmc82EEFKXUJIoIYTUIQ8fPsT48ePx5s0bAICenh7Wrl2LqVOnQlFREUZGRnj8+DGCgoKgrq7OWcvP4cOH4/Xr1wCAwMBA+Pr6ilrUqaur46effuIk7p07d1BSUiK6OVxUVISoqCg8efIEDg4OmDZtGlX/YZGioiKMjY35ngbhkJWVlUTlztowDIO0tDRW4y9btuyL47OJr1a2NRo2bIixY8di7NixnMb5lIqKCoYPHy7zyp0qKiqIiYnBgwcPcO3aNRQXF0NbWxs2NjZo3769TOciK3PnzsXs2bOhq6sLR0dHqKur8z0lucZntdqcnBxs27YN169fR2FhIXR0dGBjYwNvb2/OEiJqDBgwAAMGDMDTp09FsWuSUtikqamJ/Px8AIBQKGT9+b+UsbExXr16BVtbW3To0AF79uyBg4MDlJSUkJiY+EUf5H4Nrl69+o/j9+/fR1xcHC5duoRvvvmGs3m8evUKlZWVUsfKy8uRnZ3NWex+/fqhX79+yMjIQEFBAbS1tWFiYsJZvBrW1tZYtWoVJk+ejJ49e0JfX1/iOoWrCpOEW1wkNP8vDAwMRImh33zzDS5fvixKSuayG4eGhobo77lx48Z4/PgxunbtCgAQCAQoKCjgLHZ9NHbsWMyfP1/qeSsjIwPz58+vtcXuf6GlpYX09HS4ubmhR48eEucwhmEwbtw41uMCtVfBfvLkCQIDA7+oIs//QpbV5AlQWFhY6+uxQCBAVVWVjGdECPm33r17J0rylmWVbb5jE0LYo6WlJbZptza5ubmijjRfe2xas+zi8hmbzzUTQkhdQkmihBBSh6xatQr6+vpISEhAw4YNERUVBX9/f1hbW+Onn36CiooKKioqMHXqVCQkJHCWJPpxxSITExMcP34cN27cQEVFBSwtLaGnp8dJ3OXLl8Pe3l6UJLps2TKkpqaie/fu2LJlCxQUFOgmAItGjhyJI0eOSE2kI/LB19dX7MahQCDAunXrMHz4cJkk2wwdOpTzGNLw1cr2U3l5eaioqJB4vFmzZjKJL2vt27eX26TQT3l7e+P9+/cICAgA8KF97qc36dlOuq7P+KpW+/DhQ4wZMwbv379H9+7dYWpqiry8POzduxdJSUnYtWsX2rZty0nsj3GRGPoxW1tbzJkzR/T3u2DBglpbADIMg+3bt3MyD1dXV1G10B9++AHjx4+HnZ2dqIpqREQEJ3FlrbYPmu/evYv4+HicOXMGRkZGWL58OQYNGsRq7IqKCpSVlYmSgUtLS1FYWChxTGpqqkyuE1q1aoVWrVpxHqdGTbvks2fP4uzZsxLjXFaYJNxq3rw531MAANjZ2eHatWtwcnKCh4cHVqxYgadPn0JZWRmpqakYOHAgJ3E7duyIBw8eoEePHnByckJcXByEQqGoE4ilpSUncfn26NEjrF+/Hrdu3cKbN29gYGAACwsLTJo0Ce3ateMs7pUrV2pNfiktLcW1a9c4ibtq1SoAwJs3b/Do0SOJcS6TRGtjYmKCiRMnYvny5Thy5Ajrz89XNfn6ytjYGOfPn5da1fvKlSsyue4lhPw3H1fdlnUFbj5jE0LYY2lpiQMHDmDAgAH/eFxSUhKsra3lIjatWXZx+YzN55oJIaQuoSRRQgipQ27fvo158+aJ2j7OmTMHLi4uGDVqlKhVsKqqKsaMGfNFrSrZ0rBhQ5kkEj5+/BiTJk0C8KGC0alTpxAeHg53d3fs3r0bO3bs4CxJtD5WMVVTU0NaWho8PT1hb28PLS0tsXE+bjIRdk2fPl3s+5ok0REjRsDc3Fxm8ygqKsKjR4+QlZWFnj17QltbGxUVFVBWVubk74rPVrYFBQVYsmQJfvnlF4lKK0KhkNUEFGtra+zYsQMdO3b8bNVYLpMWPz1/FhcXY8WKFXJ9/vw0AZtrn2vV9jF5bNvGV7XayMhIGBkZYcuWLWJJCEVFRfD19UVkZCQ2bdrEWXxZWbZsGbZu3YqnT5+CYRg0bNiQlx3zH7dCtrS0REpKCv744w9UVFSgW7dunCb88OnWrVuIi4vDH3/8ARMTE6xYsQIDBgzg5LyZkJCAuLg4AB/OFePHj6/1WH9/f9bj16iursalS5eQkZEhUc2Uy+vPulJtkshOWVmZ1A07Ojo6nMQLCAgQVe2s+T0+efIkKioq4OXlxdl72cmTJ4s6gcyYMQOvXr3CsmXLUF1djU6dOmHRokWcxOXT77//Dn9/fzRp0gQuLi7Q09NDXl4eUlNTMXToUMTGxqJXr14yn9eNGzegq6vLyXPXbKSoazQ1NfHixQtOnpvPavL10bhx4xAeHg4lJSX069cPAJCdnY309HTs3LkTy5cv53mGhJB/KysrC6mpqcjKypLaRSAsLEwuYxNC/ne+vr7w8vJCaGgogoODJd47FRcXIzIyEhcvXmQ9IZyv2LRmWjOXcQkhpK5hhHz2kyOEECLG1NQUiYmJsLCwAABUVVWhY8eOSEpKEkvounnzJjw9PTmtdJOfn4/t27fj5s2bYlU5vL29ObvpYWFhgYSEBNjZ2eHChQuYMGECLly4AB0dHVy7dg3jx4/HzZs3OYk9evRo2Nvbi26IBwcHi6qYnjt3DhMmTJC7KqY1yci1oWpK8kcgEMDc3FzinMKV6upqrFmzBjt37kRZWRkYhsGBAwdgbm6OiRMnwsLCgtMkFABSW9nWJGtyYdq0abh69SrGjh0LExMTKCsrSxzj4uLCSqzY2Fh4eHigcePGiImJ+eyauPpZ18fzp6x5eXn9q+Ppgyx2WFlZISoqSurfbGpqKmbPno0bN27wMDPumJqaYt++fejcuTPfU5F7aWlpiI+Px/nz59G+fXv4+fmhb9++nCag379/H3/99ReEQiHmzp0LPz8/tGjRQuwYZWVlmJiYwMzMjJM5vHnzBl5eXnj27JmoSiwAsXXT9Sf5L4RCIeLj45GYmIg3b95IPYaL37Gqqio8ePAATZs25ez98r9RWVmJysrKWitDf+0GDBiAli1bIi4uTiypvrq6GlOnTsWLFy9w/Phx1uJt2LABGzZsAPAh+fjTKvLAh5+5QCDAqFGjEB4ezlrsuuDTqtMA8P79ezx58gTLly+Hqqoq9u3bx3rcyspKzJo1C7/++isYhpGoJh8dHS3aUM220NBQTJ06FUZGRhJjr169QmxsrFwmTW7duhUxMTFilcfV1dUxY8YMsQ09hJC67/jx45gzZw6EQiF0dXUlPp9iGIazTVR8xiaE/He7d+/G8uXLoaCggI4dO6Jp06ZgGAZZWVm4c+cOBAIB5s6di1GjRslNbFozrZnrNRNCSF1BlUQJIaSO+bRdLR9u3ryJCRMmoLq6Gg4ODjA2NkZeXh527dqFXbt2YcuWLaJEVjYZGRnhjz/+gJ2dHY4ePQpzc3PRbq68vDxOb3DxWcWUL3W1EgmRH2vXrsWuXbsQHBwMe3t79O3bVzTm5OSE/fv3c54k+nEr28rKShw6dAhbtmzBqVOnOIl3+fJlhIWFYfDgwZw8/8c+/tl9WjVWlurj+bOGUChERkYGioqKoK2tjVatWnHy2l0fkz7v3r0LExMTqKmp4e7du589novEd0VFRakVT4AP5xNFRUXWY/KpoqICo0eP5nUOAoEAN2/eRHZ2ttSfvSzOrVy7fPky4uLicPXqVZibmyMuLg7Ozs4yiW1qairaJMQwDBwdHWWezBYREQEdHR2cPXsWjo6O2LdvH/T19ZGcnIzDhw9j48aNnMYXCoU4e/Ys0tLSROfuLl26oGfPnry99yLs2rZtG7Zt24YJEyZg9erV8PPzg6KiIo4dO4b379//q+rc/4aCggJGjBiBjRs3wsHBgZMY0lRUVMDBwQFRUVFwcnISPa6iosJZ8lxd8PLlS4SEhEhUXVZQUMCoUaNYf49hZWUFX19fCIVCxMXFwdXVFU2aNBE7pibJvnfv3qzFffbsGQIDA/HDDz/A0dFR6jFnz57F2rVrsXbtWqkJjWzo1q2b1HOkUChE06ZNRVWq2cZXNXkAOHToEEaOHCn1Z1pQUIDDhw/LZZKoj48Phg8fjhs3bog2W1pZWfFSZZ4Q8t+sXr0aLi4uWLx4scz/hvmMTQj570aPHg0bGxvs2LED165dE30u17hxY7i5ucHLy4uzazG+YtOaac1cr5kQQuoKShIlhJA6JiUlRdQSuLq6GgzD4OjRo7hy5YromJpWclxZuHAh2rRpg4SEBLHEzJKSEkycOBGLFi1CUlIS63HHjRuHsLAwHDhwAEVFRVixYoVo7MqVK5xenJeXl0NdXR0AcP36dVRWVopu2Ldv3x7Z2dmcxSZEXh06dAiBgYHw9PSEQCAQG2vRogUyMzNZjffy5UscP34cWVlZMDIywpAhQ9CoUSNUVFRg586d2LZtG96+fQsbGxtW435MS0sLjRo14uz566L6ev7cvXs34uPjkZ+fL6pOq6enh6lTp9JuYxa4u7uLKlq6u7vXmrxV87Pnoiqcg4MD1qxZAzMzM1GyOfAhYWPt2rWsJwH99ttvsLOz4+0mmqqqKg4ePCiW0C9Ld+/exfTp05GVlQVpDU8YhpGLJFFvb28wDIOuXbvC0dERL168wNatW6Uey2Xr9SFDhgAAioqK8OjRI2RlZaFnz57Q1tZGRUUFlJWVOWl5f/XqVYSFhcHAwED0WLNmzTBlyhQIhUIsWrQImzZtYj0u8GGtkyZNws2bN6GlpSVqT52QkABLS0ts3LgRWlpanMQmsnPgwAFMnz4do0ePFiUomJubY+rUqfDz8+OsLbaCggK++eYbFBUVcfL8tVFVVYW6urpMNy5YWVl9cVI1wzCizzfY1L59e7x8+VLq2MuXL9G2bVtW49nZ2cHOzg7AhzXVVPPn2pYtW9CgQYNaE0QBwNHREZs2bcLmzZuxYMECTuaxbNkyiX9zVVVVNG7cGBYWFlBS4vYWQ/v27evUzdrnz59LtKeUJw0bNsS3337L9zQIIf9Rfn4+RowYwcv7Sz5jE0LYYWpqimXLlv2r/6dmM2yDBg2+yti0ZtnF5TM2n2smhJC6gJJECSGkjtmxY4fEY9u2bZN4jMtKN48fP8batWslKndqampi4sSJCAgI4CTusGHD0LJlS9y+fRsdOnRAt27dRGM6OjoYO3YsJ3EBfquYylJCQgIGDx4sdmP++vXrMDMzEyV5AUBmZiY2btyIxYsX8zFNwjFZVcoqLCwUtXj/lEAgQFVVFWux0tPT4ePjg7KyMtFje/bsQUxMDGbOnInnz5/D2toaUVFRsLe3Zy3up8aPH4+dO3eie/funN8s/TeVsBiGwbp16ziZR305f34sMTERixcvhqurKwYMGAB9fX28ffsWx48fx+LFi6GsrAwPDw/O4ldXV+PSpUvIyMiQWm1RHlpB7tixQ3T+kHZtJAshISEYM2YMXF1d0bZtW+jr6yMvLw8PHz5E06ZNERoaymo8f39/JCYmonPnzjAzMxN9LUtWVlZIT08XJcLI0oIFC6ChoYHt27ejTZs2Ei0J5YlQKMSlS5dw6dKlfzyOyyRRoVCI1atXY+fOnSgrKwPDMDhw4AC0tbXh7+8PCwsLTqp9l5SUQFdXFwoKCtDQ0EBeXp5orCZRkyuRkZF48eIFNm/ejO7du4seP3/+PGbPno3IyEgsXbqUs/hENl69egUzMzMoKipCSUkJxcXFAP6vwuSPP/6IwMBATmJPmTIF8fHxsLa2lkkCYY3BgwfjwIED/5hIyCZfX1/eK+/OmzcPgYGBUFdXh4uLCzQ1NVFSUoJff/0VW7duxcqVKzmLXXNulEVF+fPnz3/Rudjd3R2xsbGsxv7Y0KFDOXvuT/FZTX7Pnj34+eefAXx4DQ4KCoKqqqrYMZWVlXj16hVvm2q4dPjw4VrHGIaBpqYmTE1N0axZM9lNihDyP+vRowfS09M5/QysLsYmhPBDIBBg7NixOHDgACfdfupibFozrZkQQr5GlCRKCCF1SF1p/92yZUvRzbRPlZSUcNbCDABsbW1ha2sr8TjXrZT5rGIqS6tWrULXrl1FSaICgQCjR4+WeIOTn5+PAwcOUJLoV662Kj+jR4+WeJyLKj/GxsY4f/681A+Fr1y5wmqFn5iYGBgYGCAyMhIdOnTAy5cvsXDhQowaNQpKSkqIiYnBd999x1q82jx9+hRPnjzBd999B1tbW6kVycLCwliJ9e7dO1ae57+qL+fPj23btg1eXl748ccfxR53dnaGrq4uNm/ezFmS6Js3b+Dl5YVnz56BYRhRxcWP/6blIUn04yRFPhIWgQ/VDY8ePYqkpCSkpaWhuLgYxsbGcHd3x9ChQ9GwYUNW42lqaiI/Px8ApFbSlIUZM2YgKCgIioqKcHR0hJ6ensTrBVeVsx4/fow1a9bw9u8tK3Xlen/NmjXYtWsXgoODYW9vL5bs4uTkhP3793OSJPrNN98gNzcXANCmTRscOXJE1Jo5NTWV08psp0+fxuzZs8USRAGge/fuCAwMRHR0NCWJygEdHR38/fffAD6cx+/duye6Fi0oKEB5eTlnsU+ePImCggK4uLigffv20NfXFxvnatOOlpYW0tPT4ebmhh49ekBfX1/s3M12wjnX782/xNixY1FVVYW5c+di7ty5UFJSEm1AU1JSElsvF+9zZFVRPicn54s+f/nmm2+Qk5PDWlw+8VlN3tDQEB07dgQAPHr0CK1atYKurq7YMcrKymjdujWGDRvGWty6IiQkRPTz/vha9OPHGIaBi4sLVqxYIbbRmBBS9yxcuBABAQEoLy9Ht27dpH4+xVWyC5+xCSH84euzLD5j05rrR2w+10wIIWyjJFFCCCESZs+ejUWLFqFp06ZiN+ovX76M2NhYhIeHsxaLzyoRH+OziqksSXszQ29w5BffVX7GjRuH8PBwKCkpoV+/fgCA7OxspKenY+fOnVi+fDlrse7fv4/Q0FBYWVkBAExMTLBw4UL0798fixcvlkmCKACcOXNG9DO/du2axDjDMKwlie7cuZOV5/mv6sv582MvX74UJTV9qlevXti7dy9nsSMiIqCjo4OzZ8/C0dER+/btg76+PpKTk3H48GFOq/DVRw0bNsTYsWNl8ntsa2uLOXPmiBKrayprSsMwDLZv3876HDw9PQEAUVFRiI6OlnoMm8kYHzM2Nq4zye/1waFDhxAYGAhPT08IBAKxsRYtWiAzM5OTuL169cL58+cxYMAA+Pn5Ydq0abC3t4eSkhLevn2LoKAgTuICQFlZmUTSXg0DAwOxauTk62VtbY3bt2/D0dERAwcORGxsLN6+fQslJSXs27eP04pW7969Q6tWrcS+l4VVq1YB+LCR5NGjRxLjXFYljo6OxrBhw2BsbMzJ89eGz/c5sqwo37BhQxQUFHz2uMLCQtZbHzo5OX3xz5hhGKSmprISl89q8i4uLnBxcRF9P3XqVE43Sdc1hw4dwsyZMzF48GA4OztDT08PeXl5+PXXX3HkyBEsXLgQL1++REREBFauXMna+1pCCDfevXuHsrIybNiwQeJzAi4S7etKbEIIIYQQQkjtKEmUEEKIhKioKJSUlMDb2xuamppo1KgRCgoKUFJSAi0tLURHR4sSBxiGQXJy8v8ci88qEZ/iq4opIVzh+3d36NChKCoqQkxMDDZs2AAAmDZtGtTV1TFz5kwMGDCAtVh5eXkSN/BqvpdlJcvTp0/LLFZdUt/OnwYGBrhx4wYcHBwkxtLT00XVmrlw9epVhIWFicVo1qwZpkyZAqFQiEWLFmHTpk2cxZcVU1PTf5X8IQ83mJYtW4atW7fi6dOnYBgGDRs2hKampsznwFfSTWhoKJYuXYr27duLkkMIdwoLC2v9OQsEAlFFPrbNmjVL9LWjoyN+/vlnpKamory8HA4ODpy2yzYzM8OuXbvw7bffQlFRUfR4dXU1du7ciQ4dOnAWm8iOv7+/qKLilClTUFxcjJSUFFRUVMDBwYHVDY+f4msDD58Vio8cOYLNmzfDysoKHh4e6Nevn0yqC/J5jSnLivIdO3bE8ePHP7vh7dixY6IKmGxxdnb+7DXBgwcPcPnyZVavHepCNXkArG5o/FpER0fDw8MDEyZMED2mp6eHdu3aQUVFBevXr8f27dtRUFCAXbt2UZIoIXVccHAwsrKyEB4eDmNjYygrK9eL2IQQQgghhJDaUZIoIYQQCebm5qzfYKjNx1Uitm/fLtPEhLpSxZQQeebj44Phw4fjxo0bKCgogLa2NqysrDhJfPr0/FHzvZJS/bjkvXfvHtavX4/r16+jsLAQOjo6sLGxweTJk1lPfElISMDgwYPFEhWvX78OMzMzscSAzMxMbNy4EYsXL2Y1Pt+GDRuG+Ph4VFZWol+/ftDT00N+fj5OnDiBzZs3Y9q0aZzFLikpga6uLhQUFKChoYG8vDzRmKWlpdxUEv243aVAIMD27duhrKwMFxcX6Onp4e3bt0hNTUVVVRVn1dFkTVtbGzNnzgTwIUl29uzZ6Ny5s0znMHToUJnGc3NzE/v+zZs3cHNzg6GhocTrxH/dmETEGRsb4/z581KrKl65cgVt27aVyTw6deqETp06ySTWrFmz4Ovri++++w7Ozs7Q19dHXl4eUlNT8fbtW2zZskUm8yDcat26NVq3bg0AUFFRQVhYmMwSmWJjY+Hh4YHGjRtLjOXm5mLfvn3w9/dnPe7Vq1fRoUMHNGzYUGLs77//xt27d6Vu5mHD2bNn8ccff+DgwYMIDw/HkiVLMGDAAAwdOlRU4V/eyLKi/KhRozBt2jSYmJjAz89PLMEd+JDkHh8fj5MnTyIuLo61uAAkkmA/9tdffyEuLg5XrlxBixYtMGnSJFZj1ygtLUVlZaVYy/fk5GQ8efIE9vb2Yh0M2BYaGoqysjKsWbNGYiwgIAAaGhpy9x4nLS0Nvr6+Usc6dOgg+h3r3Lkz8vPzZTk1Qsj/4NatW1i5cqVYheT6EJsQQgghhBBSu/pxx5wQQsi/EhERIbNYH1eG6Nq1q8ziAnWriinf+GxJTuTX4cOH4ejoiEaNGuHbb78VGyssLMTvv/+OwYMHsxYvKCgIqqqqEo8HBARARUVF9D2XiUaHDx/+7DFsrrnGtWvX4OPjAwMDA7i6uoq1BvT09MSWLVvQpUsX1uKtWrUKXbt2FSWJCgQCjB49GgcOHBBLqM/Pz8eBAwfk7gaqn58fiouLsXnzZrGkTEVFRXh5ecHPz4+z2N988w1yc3MBAG3atMGRI0dEiQqpqanQ0dHhLLYsfZz4GRUVBTMzM8THx0NBQUH0eHBwMKZOnSr6ecgTPqvCAUBRUREePXqErKws9OzZE9ra2qioqICysrLYv8F/ZW5uTtcgPBk3bhzCw8OhpKSEfv36AQCys7ORnp6OnTt3ymUFNVtbW/z8889Yv349UlJSUFxcDG1tbdjY2GDKlCm0IUxOjB07FvPnz5daKTcjIwPz58/nrIV1XFwcevbsWWuSaFxcHCdJomPHjkViYqLUjQVPnz7F2LFjOXsvq6CggF69eqFXr14oKCjAkSNHcOjQIRw4cACtW7eGu7s7vv/+e+jp6XESnw+yrCjv7OyMCRMmIDY2Fnv37oW9vT2aNWsGAMjKysLFixfx9u1bjB8/Hk5OTqzFrc3t27cRFxeHs2fPwtjYGBEREXBzc2P12uBjs2fPhqGhIRYuXAjgQyJ2bGwstLW1kZCQgOjoaFa7U3zswoULCA4OljrWp08frFixgpO4fNLV1cWpU6fQvXt3ibGTJ0+KknXfvXsHLS0tWU+PEPIvtWzZkrPuAHU5NiGEEEIIIaR2lCRKCCHkHwmFQuTm5kJPT4/zanxmZma13ty6c+cOPDw8WL25xWcVUz55e3tLrHX06NFijwmFQllPi8ih0NBQJCYmolGjRhJjL1++RGhoKGsJk0OGDJH6uKyqItcICQmR+vjHf19cJIlGR0fDzs4OGzZsEDtXz5kzB5MmTcLKlSvx888/sxZP2jmiPp03GIZBSEgIJk+ejFu3bqGoqAja2tro3Lmz1N93NvXq1Qvnz5/HgAED4Ofnh2nTpsHe3h5KSkp4+/YtgoKCOI3Ph0OHDiEiIkIiAUFBQQEjR45ESEhIrTfxv2Z///03Dh06hLS0NNHvmI2NDYYMGYIGDRpwErO6uhpr1qzBzp07UVZWBoZhcODAAWhra8Pf3x8WFhasJjjJcmMSETd06FAUFRUhJiYGGzZsAABMmzYN6urqmDlzJqtJN1ZWVl98nc0wDNLS0liL/amOHTsiNjaWs+cn/Lty5QrevXsnday0tBTXrl3jLPY/XQu9efOGs6Sqf4pbVlYGNTU1TuJ+qlGjRhg3bhy6deuGpUuX4urVq1ixYgVWrVoFV1dXBAcHi1WE/Jp8vPlN1hXlg4KCYGtriy1btuDUqVOorKwEAKiqqsLa2hpLliyBo6MjqzE/lZ6ejtjYWJw/fx5t2rTBypUr0b9/f84/Q7l9+zbmz58P4MPv+Z49ezB58mQEBARg+fLl2Lx5M2dJovn5+bVe1+vo6ODt27ecxOXTpEmTsGDBAlG1XF1dXeTn5+O3337DpUuXRMm6ly5dknm1e0LIvxcaGorIyEi0bdtW6uYZeY1NCCGEEEIIqR0liRJCCJHq3LlziImJwb179yAQCETV4cLDw2Fra4tBgwaxHvOfbm4JBAKJ1mr/FZ9VTPnCReUaQmrzT3/TxcXFUlti/q/qSsWzq1evSjxWVFSEP//8E7t370Z0dDQncf/66y/89NNPEsn8ioqKGDt2LGbMmMFJ3Prm8ePH2Lt3L16+fAlDQ0P069eP85vyn5o1a5boa0dHR/z8889ITU1FeXk5HBwcZD4fWSgvL8erV6+kjr169QoVFRUynhH3srKy4OXlhVevXsHU1BR6enrIyMjAyZMnsW3bNuzYsQNNmzZlPe7atWuxa9cuBAcHw97eHn379hWNOTk5Yf/+/TK5lhAKhSgoKECjRo3qzSYePvj4+GD48OG4ceMGCgoKoK2tDSsrK2hqarIax9fXV+zfUSAQYN26dRg+fDgMDQ1ZjfWp6upq/P777zAyMkLbtm2lHvPw4UNRQgz9vsm3GzdusJ6kmJKSgpSUFAAfkpwjIyMl/oYqKytx584dWFtbsxY3PT0dN27cEH1/9OhRiQTriooK/Pbbb2jdujVrcWtTUlKCo0eP4sCBA/jrr79gamqKefPm4bvvvsPZs2exbt06BAQEYPv27ZzPhQsfb37jo6K8o6MjHB0dIRAIUFhYCOBDoiLbn5F86urVq4iPj8fFixfRoUMH/PTTT/juu+84jfmxoqIiUaLmnTt3UFBQgGHDhgH4v+sSrjRu3Bi3bt2Cvb29xNitW7dYrRhbV3h6esLAwADr169HZGQkqqqqoKSkJKroX1Ot1t/fn/NN5ISQ/27ZsmV48+YN3NzcYGhoKHF9wmWXHT5jE0LY8/r1axgYGEBZWVlirKqqCrm5uaIq9woKChgyZAhrm+f5ik1rll1cPmPzuWZCCOEbvZsnhJA66s6dOygpKRF9IF1UVISoqCg8efIEDg4OmDZtGmctvVJSUjB79mz0798fHh4eCA8PF40ZGRnh4MGDrCWJvnnzRqxN7NOnTyVudFRUVCApKUl0Uc4FWVcx5QsliRKunT17FufOnRN9v2XLFujr64sdU1FRgUuXLsHMzEzW0+OctMQaTU1NeHp6oqKiAlFRUdi0aRPrcdXV1ZGXlyd17O3bt1BXV2c9Zn1z7do1+Pj4oKqqCrq6uigsLMT+/fsxb948jBw5Umbz+PRDrE6dOqFTp04AgPfv3+P169ecvl7ywcXFBdHR0VBTU4OLiws0NTVRUlKCX3/9FatWrYKLiwsncV+9eoXS0lK0b98ewIckn82bN4uuxYYOHcpJXOD/Et+PHTsmltzz9OlTTJkyBREREVi7di3rcQ8dOoTAwEB4enpCIBCIjbVo0QKZmZmsx/zYn3/+idjYWNy9e1eUmGBubo5p06ahR48enMaWlbt37/6r49lsgT5lyhSEhITA2NhY9NiDBw9gY2PD6evE9OnTxb6vSRIdMWIE5y3eDx48iIiICFESnzRaWlqYM2cOwsLCOKn2Tbi3YcMGUUVchmGkdk6orKyEQCDAqFGjWI39/v17UeVSoVCIsrIyiffpKioq+P777zFhwgTW4tacL4EPa965c6fEMUpKSjAxMRFVYuTCxYsXceDAAfz2229QVFSEq6srFi1aJFbNf9iwYWjatCmmTJnC2Ty49vHmNz4ryisqKkJPT4/TGDW8vLxw7do1dO7cGRs2bOBlI5K+vj4eP36MLl264OzZs2jevDmMjIwAfKiSy2WioqurK9avXw8jIyOxaqUnTpzA+vXrMXbsWM5i88nZ2RnOzs6orq5Gfn4+dHV1Jc5p2traPM2OEPJvmJub87YBis/YhBD2ODs713rP7P79+2L3zBiGYbWIA1+xac2yi8tnbD7XTAghfKMkUUIIqaOWL18Oe3t7UZLosmXLkJqaiu7du2PLli1QUFBgvY1Zjfj4eHh7eyMkJAQCgUAsSbRt27asVv9ITExEbGwsGIYBwzAIDQ2VOEYoFEJRUZHTm1uyrmJKiLx69uwZTp8+Lfr+2rVrUFFRETtGWVkZbdu2RWBgoKynx6u2bdtizZo1nDx37969ER0djSZNmsDBwUH0+IULF7Bq1SpR1ReuyfNNgJiYGLRu3Rrr169H06ZNUVpaitDQUKxZs0amSaL/9CHWgwcP5GZTw8fmzZuH8vJyzJ07F3PnzoWSkhKqqqogFArx3XffYd68eZzEDQ8Ph6mpKebMmQMAiIqKws8//4x27drh5MmTKCsrw+jRozmJfeHCBSxatEii+lvr1q3xww8/cHZNVFhYWGs7QIFAgKqqKk7iAkBSUhLCwsLQpUsXzJkzB3p6esjLy8OpU6cwadIkLF68WFQ97Gvm7u7+RedKoVAIhmFY/Xv+/fffMXXqVNH3AoEAo0ePFnUMkEdHjhyBp6cnmjRpUusxTZo0wahRo5CUlERJol8pKysr+Pr6QigUIi4uDq6urhL/5srKyjAxMUHv3r1ZjT1kyBAMGTIEwIekugULFsikraq/v79oA6CpqSn27dvHS/tnHx8fWFhYICwsDK6urrUmnBsbG2PgwIGsxy8qKsKjR4+QlZWFnj17QltbGxUVFVBWVuZsU22NRo0ayWUF9xo1HRIePnyIgICAfzyWYRiJSrZs6NevH6KionDhwgX88ccfYonW9+7dQ8uWLVmPWWPatGm4f/8+AgMD8eOPP8LQ0BC5ubkoLy9Hz549Ofs8jk8///wz3NzcoKGhAQUFBYnNnoSQr0tERES9jE0IYc8/3TOrrKyU+MxfHmLTmmUXl8/YfK6ZEEL4RkmihBBSRz1+/BiTJk0C8KHN6qlTpxAeHg53d3fs3r0bO3bs4OxD6czMzFpvdqirq6OkpIS1WEOGDIGdnR2EQiG8vb0xb948tGnTRuwYZWVlGBsbs16Vo65UMSVEnnh7e8Pb2xvAhxaA8fHxMDU15XlW/CsrK8O+ffs4a6sbEhKCx48fY/z48dDQ0ICuri7y8/NRWlqKTp06ITg4mPWY0qp0jR49Wuyxf/rA5Wvz8OFDLFy4UNTiW0NDA8HBwXBxcUFWVhYnrb+lqY8fYmloaOCnn37CkydPcPv2beTm5sLQ0BCdOnXiNBHnr7/+wpgxYwB8aDV0+PBhBAUFYdy4cVi/fj327t3LWZKoQCCAqqqq1DFVVVWJKp9sMTY2xvnz56W2Vr1y5Uqt7brZEBcXhyFDhmDZsmVij3t5eSE0NBTx8fFykSS6Y8cOvqcgRp7O09Lcu3cPkydP/uxxdnZ22LNnjwxmRLhgZ2cHOzs7AB+S1Tw8PNC4cWOZz0NaNU9ZuH//Pi9xASA5ORnt2rX77HHNmzdntfqKUCjE6tWrsXPnTpSVlYFhGBw4cADa2trw9/eHhYUF6100UlJSvigRkmEYjBs3jtXYfKgLXUhmzZqFhg0b4s6dO/D19RV9RgZ8qMzdv39/zmKrqKhgw4YNOH/+PC5evIiioiLo6OjAwcFB6nVGJMPxAABy90lEQVSSPIiIiEBkZCS+++47eHh4iM6rhBBCCKk/njx5gidPnoi+v3z5MrKzs8WOqaiowLFjx0QV3r/22LRmWjOXcQkhpK6hJFFCCKmjysvLRVU4rl+/jsrKSjg7OwMA2rdvL3HxyiYDAwM8ffpU6gffDx48YDVhsnnz5mjevDmADzfNO3ToAA0NDdae/5/UlSqmhMijiooKtGvXjtWk8q+Bm5ubxGPv379HTk4OysvLERkZyUlcbW1tJCYm4syZM0hLS0NxcTG0tbVhY2ODXr16sV5JqS7cNJa1goICiapkNYmhBQUFnCaJ0odYH5iYmMikOluNd+/eQVNTEwBw8+ZNlJaWitqN2tjYYP369ZzFtra2xrp162BnZyeaAwCUlJRg/fr1sLa25iTuuHHjEB4eDiUlJfTr1w8AkJ2djfT0dOzcuZPT9kr5+flwdXWVOubq6ooTJ05wFluWKOFCtt6/f/9FyfMqKiqorKyUwYwI12quUYRCITIyMkStwFu1aiXXFc/58iUJolxYs2YNdu3aheDgYNjb26Nv376iMScnJ+zfv5/169UvTfKnJFH2KCkp1TqPuLg4mcyhe/fu6N69u0xi8e3cuXM4evQokpKSMHbsWBgZGcHd3R1DhgzhJfGeEEIIIbJ34sQJxMbGAvhwXbty5Uqpx2lpabH+GRFfsWnNtGYu4xJCSF1DSaKEEFJHGRkZ4Y8//oCdnR2OHj0Kc3Nz6OjoAADy8vI4TaQcOHCgqK3uxxVZHj58iE2bNnHWVlfWN835rGJKiLxTVVXF1atX5eIG6b9hbm4ukYCgoqKCJk2aoE+fPpwmuCkoKMDZ2Vm0oYBLdeGmcX1CH2J9UFFRgczMTFRUVEiMcdEqu0mTJkhPT4etrS1+/fVXtGnTRlQNuKioCGpqaqzHrBEcHIwxY8bA0dER3bp1g76+PvLy8nDx4kUoKytLVNtky9ChQ1FUVISYmBhs2LABwId2q+rq6pg5c6YoSZYLFhYWuHv3rtREjHv37qFTp06cxa7v+Eqck0Xcpk2b4t69e599n3H37l2ZVYQm3Nu9ezfi4+ORn58PoVAIhmGgp6eHqVOnYtSoUXxPT+4cO3YMJ0+eRFZWlsRrNMMwSE5OZj3moUOHEBgYCE9PT4nq2i1atEBmZibrMfft24fOnTuz/rzky+Tl5Um9BuS668sff/yB27dvIzs7G35+fmjWrBmuXr2KFi1ayF3ipJaWFkaPHo3Ro0fj/v37SEpKwvbt2xETE4Pu3bvD3d0dTk5OUFZW5nuqhBBCCOGIt7c3hgwZAqFQCBcXF8TGxsLMzEzsGGVlZRgYGLD+np6v2LRmWjOXcQkhpK5hhPLeW4wQQr5SBw4cQFhYGHR0dFBUVIQVK1aIKtQtXrwYGRkZ2LJlCyexKysr8cMPP+DMmTPQ0dFBYWEh9PT0kJ+fj169eiEmJgZKSuzsM7C2tsaOHTvQsWNHWFlZ/ePFN8MwX9Te7X9x5coVmVYxJaQ+mDFjBlq2bIlZs2bxPZV6IycnBzk5OVJvoNra2vIwI/lhamoKdXV1idepv//+W+Jxtl+vSkpKUFxcXG8/xKqsrMSCBQuQnJxca5v1v/76i/W4GzduxE8//YT27dvjr7/+QmhoKLy8vAAAK1euxPXr17F7927W49bIzs7G1q1bJaoDjxs3TqKqLdvevXuH69evo7CwENra2rCyshKraMqFmzdvIjAwEEOGDIGLiwt0dXWRn5+PX3/9FYcPH8aqVavQsmVL0fE1m6e+docPH0ZiYiKePXsm9dx9/fp11mKZmpqiRYsWUFVVFT326NEjtGzZUqLaJpuJXdKu8aWdO2visnn+jIiIwPHjx5GUlAQDAwOpx7x58wbu7u5wdXVFcHAwa7EJPxITEzF//ny4urpiwIAB0NfXx9u3b3H8+HEcP34cixYtgoeHB9/TlBurVq3Cxo0bYW5uDmNjY6mVe7nYwNK5c2ds2LAB9vb2EAgEMDc3R1JSEszNzfHHH3/ghx9+wI0bN1iLZ2pqSkmiPCgoKMCSJUvwyy+/oKqqSmysJgGci2tA4EOF86lTp+LmzZto2rQpsrKycODAAZibmyMkJATq6ur1ouNMTk4OgoKCcPXqVQBAo0aNMHLkSEyaNInTDVOEEEII4d+rV69gYGDwRd055CU2rVm26uOaCSGEb1RJlBBC6qhhw4ahZcuWuH37Njp06IBu3bqJxnR0dDB27FjOYquoqGDdunW4dOkSLly4gIKCAmhra8PBwQEODg6sxvL19RXdsPX19eUtuYVafxLCPnd3d8ybNw/v3r2Do6Mj9PT0JP7Guaj+FxoairKyMqxZs0ZiLCAgABoaGli8eDHrcfmUmZmJ2bNn4+bNmwA+3DT9GJc3UOsLPqunampqQlNTExUVFZgzZw6MjIzQvHlz3uYja3FxcTh//jwiIiIQFBSEefPmoUGDBkhOTsaLFy8QHh7OSdxJkybB0NAQt2/fxqhRozB06FDRWFFREedJRk2aNEFoaCinMWo8fvwYe/fuxcuXL2FoaIh+/fqhR48eMoldY8SIEQCA2NhYsRayNeczT09PsePl4Zx25MgRhIeHY8iQIbhx4wbc3d1RXV2N06dPQ0tLC99//z2r8YYMGSLxWMeOHVmNIQ2f1/iTJk3CiRMnMHToUEyZMgU9evRA06ZNwTAMsrKycO7cOWzYsAEKCgqYOHEiL3Mk7Nq2bRu8vLzw448/ij3u7OwMXV1dbN68mZJEWZSUlIQZM2Zg6tSpMo1rbGyM8+fPw97eXmLsypUraNu2rUznQ7gRFhaGq1evYvLkyTAxMZFpBculS5eioKAAKSkpaNmypdjrpb29PdatWyezuciaUCjEH3/8gaSkJJw5cwZaWloYP348vvvuO5w9exa7du3Co0ePEBMTw/dUCSGEEMKhffv2Yfr06VLH8vPzMX/+fM6uB/iKTWuWXVw+Y/O5ZkII4RtVEiWEEFJv1ZUqpoTIK1NTU7HvP/4b47Lyi6OjI4KDg6W2RT5x4gRWrFiBM2fOsB63Bh8tN729vfHixQvMmDEDJiYmUnfBfvrvQb5OFhYWSEhIqFebG/r27YsJEyZg6NChMDc3x4EDB0Q36oODg6GmpoaFCxfyPMuv17Vr1+Dj44Oqqiro6uqisLAQ1dXVmDdvHkaOHCmzeRw8ePBfJRJKS3j82gwePBh9+/bFpEmTxKrglZaWYvz48ejXrx98fHz4nuZX7/nz5wgKCsLt27clfseEQiE6d+6M6OhotGjRgqcZEjZ16tQJGzZskLq58fz585gyZQpu377N+TyEQiFyc3Ohp6fHWheOuqh79+5YsWIFunfvLtO4Bw8eRHh4OCZOnIh+/fph8ODBiIuLQ3Z2NlasWIHly5dLfS/wv6JKovzo0qULwsLCMHjwYF5iL168GP3795eoVnvlyhVMnjyZ1Wq1dcGLFy+QlJSEw4cPIzc3Fw4ODhg+fDicnZ3FzmO//fYbAgMDRRsUCSGEECKfrKys0KpVK6xYsQJt2rQRPf7bb78hPDwcampqOH36tFzFpjXTmrleMyGE8E1+P6UkhJCv0N27d2FiYgI1NTXcvXv3s8dzUYGPT2PHjsX8+fNhYmIiMZaRkYH58+djx44drMWrK1VMCZFXbP69/hv5+flo1KiR1DEdHR28ffuWs9hf0nKTC7du3UJkZCT69Okjk3iEP2ZmZnj8+HG9ShLNzs5Gq1atoKioCFVVVRQXF4vGBg0ahMDAQE6TREtLS5GdnS21Fbg8XIvFxMSgdevWWL9+PZo2bYrS0lKEhoZizZo1Mk0S/bhSa33x/PlzWFtbQ1FREYqKiigtLQUAaGhoYOLEiVi2bJnMkkRfv34NQ0NDuUxma9myJfbv349r167h6tWryMnJAQA0btwYdnZ2sLGx4XmGhE0GBga4ceOG1CTR9PR00fs/rpw7dw4xMTG4d+8eqqursX//fpibmyM8PBy2trYYNGgQJ3Hz8/OxZcsW3L59G9nZ2YiNjUXbtm2xfft2WFhYwNLSkpO4w4YNQ0pKisyTRIcOHYqioiLExMRgw4YNAIBp06ZBXV0dM2fOZDVBFADu37/P6vORL6OlpVXr+zquCQQCNGjQQOpYcXGxTKuaykqfPn3QuHFjDB06FMOGDau1c0Hr1q0pYZoQQgipB44cOYI5c+bA3d0dP/zwAzw8PLB06VIcPnwYQ4YMkejeIA+xac20Zq7XTAghfJO/T/8JIeQr5u7uLqpO4e7uXmvSIhcV+D5XSfNjXFXVvHLlCt69eyd1rLS0FNeuXWM13setg2trLUAI+d99LoktMzOTk7iNGzfGrVu3pLafvHXrFqfJAXy13GzcuDEUFBRkGpPwY+7cuZg9ezZ0dXXh6OgIdXV1vqfEOQMDA1Fi6DfffIPLly+Lkn+ePXvGWdycnBzMnTsXFy5ckBjjshqyrD18+BALFy5E06ZNAXxIUAwODoaLiwuysrJEj8tKUVERHj16hKysLPTs2RPa2tqoqKiAsrKy3J3nNDQ0UFlZCeDDefzx48fo2rUrgA/JKQUFBTKZh0AggLOzMw4cOCAXic+16dKlC7p06cL3NAgHDh8+DEdHRzRq1AjDhg1DfHw8Kisr0a9fP+jp6SE/Px8nTpzA5s2bMW3aNM7mkZKSgtmzZ6N///7w8PBAeHi4aMzIyAgHDx7kJEn07t27GDduHDQ1NWFra4srV66Izi05OTnYtm0b1qxZw3pcAJg5cyaWLl0KT09P2NvbQ0tLS2ycYRiMGzeOk9g+Pj4YPnw4rl+/jsLCQmhra8PKygqampqcxCOyN378eOzcuRPdu3eX+SaGzp07IykpCY6OjhJjx44dg7W1tUznIwvr1q2Do6PjZ6+3WrVqhZ07d8poVoQQQgjhS4sWLbBnzx4kJCRg9erVWLt2LTQ1NREXFwdnZ2e5jE1rpjVzvWZCCOEbJYkSQkgdsmPHDlEVze3bt8u0suWnlTQFAgHWrVuH4cOHw9DQUGbzqM2NGzegq6vL2fPLuoopIfVVzU36o0eP4ubNm5wkWLm6umL9+vUwMjISqyJ04sQJrF+/HmPHjmU95scsLCw4fX5pAgICkJCQgC5dukBHR0fm8YnseHt74/379wgICAAAqKmpib1+c7WRg092dna4du0anJyc4OHhgRUrVuDp06dQVlZGamoqBg4cyEnc4OBgPHv2DGFhYTA2NpbLilEAUFBQgCZNmog9VpMYWlBQILMk0erqaqxZswY7d+5EWVkZGIbBgQMHoK2tDX9/f1hYWIht8JEHHTt2xIMHD9CjRw84OTkhLi4OQqEQSkpK2LhxI2eV/6QRCoUyi0UI20JDQ5GYmIhGjRrBz88PxcXF2Lx5MzZu3Cg6RlFREV5eXvDz8+NsHvHx8fD29kZISAgEAoFYkmhNVU8uLF++HJaWloiPjwfDMDhy5IhozMLCAidOnOAkLgBcunQJhw4dwrt375Ceni4xzmWSKAA0bNgQPXr04Oz5Cb+ePn2KJ0+e4LvvvoOtra1EEjIAhIWFcRJ75syZGDt2LEaPHo2+ffuCYRikpqZiw4YNOHv2LPbs2cNJXD517NjxHxNE7969K9ebSQghhBAiqaqqCgUFBaiqqoKamhqUlJRktmGdr9i0ZlozIYTIM0oSJYSQOuTjqns1VYRk5dNKmjVJoiNGjOD0Q+ANGzaI2sMxDANvb2+J5NjKykoIBAKMGjWKs3nIuoopIfVJWVkZfv31V6SkpODChQuoqqpChw4dEBoaykm8adOm4f79+wgMDMSPP/4IQ0ND5Obmory8HD179uS0gpQsW25OmTJF7Pvs7Gw4OTnBzMxMooISwzBYt24d53Mi3Pt0U0d9EBAQIKqoWJNocvLkSVRUVMDLy4uzv+mbN28iKioKLi4unDw/Ebd27Vrs2rULwcHBsLe3R9++fUVjTk5O2L9/v9wliU6ePBmvX78GAMyYMQOvXr3CsmXLUF1djU6dOmHRokU8z5CQr8PHSc4MwyAkJASTJ0/GrVu3UFRUBG1tbXTu3JnzttWZmZlSqw4CgLq6OkpKSjiJe/v2bcTExEBZWRkCgUBsTFdXF3l5eZzEBYCFCxeiY8eOvGyoKCoqwh9//IHs7GxUVFSIjTEMw+k1P5GNM2fOiK57pX0mwzAMZ0miVlZW2LFjB1auXInIyEgIhUKsX78elpaW2LZtm1wmS7q5uWHBggXo16+f2OPV1dWIj4/H+vXrcefOHZ5mRwghhBBZu3//PmbPno3s7GwsW7YMTk5OWLBgAcaPH4+RI0dizpw5UFNTk6vYtGZaM9drJoQQvlGSKCGE1FFmZmZITExE586dJcbu3LkDDw8PuWhxamVlBV9fXwiFQsTFxcHV1VWimpWysjJMTEzQu3dvXubIdRVTQuSRQCDAuXPncPToUZw+fRrl5eXQ19eHQCDAqlWrxCp8sk1FRQUbNmzA+fPncenSJRQWFkJHRwcODg5SW9CzSZYtNz9NbG/RokWtY0R+fLqpoz4wMDCAgYGB6Ptx48aJ/R2VlpZyErdly5aoqqri5Lk/p7S0FJWVlWLXH8nJyXjy5Ans7e3RrVs3VuNJ26QDAKNHj5ZZpdpDhw4hMDAQnp6eEklOLVq0QGZmJidx+WRpaSmqFqqlpYV169ahsrISlZWV0NDQkNk8GIZBs2bNoKKiIrOYhHCtUaNGtSZscsXAwABPnz6Ver354MEDNGvWjJO46urqtb4Wvn79mtMq89nZ2QgPD0fbtm05iyHNn3/+iRkzZuDvv/+GmpqaRHIqJYnKh9OnT/MSt7KyEr///jvMzMywa9culJeXo6ioCFpaWnJdXahPnz6YOXMm3NzcMG/ePGhqauLp06cIDg7Gw4cPMXv2bL6nSAghhBAZGjZsGKytrbFhwwbRe5nVq1fDxcUFixYtwvnz53Hq1Cm5ik1rpjVzvWZCCOEbJYkSQkgd9U8tHwUCARQVFWU4G+7Y2dmJKqgyDAMPDw80btxYJrHrShVTQuRJWloaUlJScPLkSRQUFEBHRweDBg2Cm5sb2rZti65du4ole3Gpe/fuMqno+TFZttzcuXMnK89Dvk5CoRAZGRmiCmmtWrWqdxVG8/LysH37dvz888+4evUq688fHByMiIgItG/fHq1atWL9+f/J7NmzYWhoiIULFwIAYmNjERsbC21tbSQkJCA6Opq1ZPu6Up2zsLAQJiYmUscEAgFvCbuypqKiIvNkTQUFBd4ScQhhS0pKyhclsXPZ/nzgwIGIiYlB69atxd7jPnz4EJs2bcLIkSM5ifvtt99i3bp1YhuUGIZBeXk5duzYwWmyrI2NDTIyMmR+zR0ZGYlOnTph2bJlaN68uUxjE/mnoqKCWbNmYdOmTTAyMoKamlq9qCS0aNEiODs7IywsDG5ubhg4cCB27dqFNm3a4ODBg7VepxFCCCFEPs2ePRve3t4Sj7u6uqJLly6cVXTnMzatWXZx+YzN55oJIYRvjPCfspAIIYTI1Js3b5CbmwsAcHd3R0REhERFjoqKCiQlJeHq1av45ZdfOJuLQCCAubk5kpKS5LKNFvChxfyVK1dEVUyHDRv2j1VM5SUxlxAumZqagmEYdO3aFT4+PujevTuUlD7sSyopKYGtrS127twJW1tbVuMWFhZCS0sLCgoKKCws/OzxXFVU6tevHxo3bsxLy01Sf+zevRvx8fHIz8+HUCgEwzDQ09PD1KlT5WpTQ3p6Og4dOoSsrCwYGRnBy8sLxsbGePv2LeLi4nDw4EFUVVVhwIABiIqK4mQOkZGR2L59OwwNDaGpqSk2xjAMkpOTOYn77bffYv78+fjuu+8gFArRvXt3eHh4ICAgAMuXL8e1a9eQlJTESWy+DBo0CD179kRQUJDEdWh0dDSuXLmCffv28T1N1v355584depUre2St2/fztPMCPl6mJqafvGxDMNw1pGjsrISP/zwA86cOQMdHR0UFhZCT08P+fn56NWrF2JiYkTXxWzKycnByJEjUVpaiq5duyI1NRU9evTA48ePwTAM9u3bBz09PdbjAh+6nISEhMDLywsODg4Sr5UAN9fdlpaWiIuLk3lyKpG9/Px8bNmyBbdv30Z2djZiY2PRtm1bbN++HRYWFqKK3Gz7/vvv4ePjg8GDB3Py/HXZ/fv3MXz4cLx//x5mZmbYt28fJ+cuQgghhBBCCCGEyBa9uyeEkDokMTERsbGxYBgGDMMgNDRU4hihUAhFRUXMnz9fJnOSdVWy58+f4+DBg3j27JnEjXIAWL9+PWux+KxiSoi8ateuHR4+fIirV69CUVERBQUFcHFx4bxtrr29PRITE9G5c2d069bts+curpID+Gq5CQD37t3D+vXrcf36dRQWFkJHRwc2NjaYPHkyOnToIPP5EG4kJiZi8eLFcHV1xYABA6Cvr4+3b9/i+PHjWLx4MZSVleHh4cH3NP+zs2fPws/PD0KhELq6urhw4QJSUlKwYsUKBAcHo7i4GK6urpg6dSpnVT6joqKwdetWmJubw9jYWKbVHYuKitCoUSMAHxJwCgoKMGzYMACAk5MT9u/fL7O5yMq4ceMQHh4OJSUl9OvXD8CHc2p6ejp27tyJ5cuX8zxD9m3atAnR0dFo3rw5TExMpCZXcenw4cNITEys9br7+vXrMp2PLAgEAty8eRPZ2dmorKyUGK+PyUDyYt++fejcuTOvc1BRUcG6detw6dIlXLhwAQUFBdDW1oaDgwMcHBw4i9u4cWMcPnwY27Ztw4ULF9CiRQsUFhbCzc0NPj4+nLabr3ltmj9/fq3X31xcd3fo0AFZWVmsPy+pW+7evYtx48ZBU1MTtra2uHLliujcnZOTg23btmHNmjWcxA4MDMSyZctgYmKCTp06cRKjLkpOTsaSJUvwzTffwMXFBVu3boWPjw+WL1+Ob775hu/pEUIIIUTG+Nqww2dsWjOtmes1E0IInyhJlBBC6pAhQ4bAzs4OQqEQ3t7emDdvHtq0aSN2jLKyMoyNjUWJA2yxsrKSelNn9OjREo8zDPNFrfz+rVu3bsHLywvNmjXDs2fP0L59e5SUlODVq1do0qQJWrRowXrMGnWl1SohX7vk5GQ8fvwYycnJOHbsGEJCQqCmpgZHR0f07t2bs8TzZcuWwcjISPQ1X223+Wq5ee3aNfj4+MDAwACurq7Q09NDXl4efv31V3h6emLLli3o0qWLTOdEuLFt2zZ4eXnhxx9/FHvc2dkZurq62Lx5s1wkiW7YsAFmZmaIj49H48aN8e7dO4SFhWHatGkwMDDApk2b0LFjR07nsG/fPsyYMQNTp07lNI40+vr6ePz4Mbp06YKzZ8+iefPmonNcWVmZXFZzGjp0KIqKihATE4MNGzYAAKZNmwZ1dXXMnDkTAwYM4HmG7NuzZw/GjBnDSxurI0eOIDw8HEOGDMGNGzfg7u6O6upqnD59GlpaWvj+++9lPieu3b17F9OnT0dWVhakNdVhGIaSRAkrunXrhm7dusk0ppaWFmbMmIEZM2bINC5f190LFizA7Nmz0bhxY9jb28vl6yIBli9fDktLS8THx4NhGBw5ckQ0ZmFhgRMnTnAWOzo6GoWFhRg+fDh0dHSgr68vNs5lRXm+zJgxA7/++ivGjBmDoKAgqKqqYsCAAZgzZw4GDRqE0NBQuXifQQghhJAvw+eGHb5i05ppzVyvmRBC+EafoBFCSB3SvHlzNG/eHACwY8cOdOjQgfPqezV8fX15S6qqERUVhf79+2Pp0qUwNzcX/ff69euYNWsWJk6cyGl8WVYxJUSetWnTBoGBgQgMDERaWhpSUlJw6tQpnDp1CgzDYMeOHQDAasv5IUOGiL4eOnQoa8/7bwUEBCAkJATKysoybbkZHR0NOzs7bNiwQewm+Zw5czBp0iSsXLkSP//8M+txiey9fPkSvXv3ljrWq1cv7N27V8Yz4saTJ0+wdOlSUYXvhg0bYvbs2Thx4gRmzZrFeYIo8GFjjoWFBedxpOnXrx+ioqJw4cIF/PHHH5gwYYJo7N69e2jZsiUv8+Kaj48Phg8fjhs3bogq8FlZWcm8wqasFBYWwtnZmZfYW7duxdSpUzFp0iTs27cPo0aNgrm5OUpLSzF+/Hg0bNiQl3lxacGCBdDQ0MD27dvRpk0bKCsr8z0lIqdycnKQk5Mj9T0lm9e/NZydnREXFwdTU1OJsYcPH8LPzw+//fYb63EB/q67R4wYgaqqKkyaNAkKCgpQVVUVG+dqYyuRrdu3byMmJgbKysoQCARiY7q6usjLy+Mstrm5uUyuN+uSO3fuYOvWrWJJ7qampkhKSsLatWuxYMECShIlhBBC6hE+N+zwFZvWTGvmes2EEMI3ShIlhJA6qqYNuqxMnz5dpvGkefDggegmDwDRTTVra2v4+/tj5cqV6NGjByex+axiSog8s7GxgY2NDcLCwvDnn38iJSUFv/32G1JTU9GsWTPObljzha+Wm3/99Rd++ukniSpKioqKGDt2rMyrShHuGBgY4MaNG1Lb1qanp8PAwICHWbGvqKgIhoaGYo/VJIzKKkHSw8MDycnJMq8MDACzZs1Cw4YNcefOHfj6+mLy5Mmisbt374rascujhg0b4ttvv+V7GjLRu3dvpKWlwd7eXuaxnz9/DmtraygqKkJRURGlpaUAAA0NDUycOBHLli2Dj4+PzOfFpcePH2PNmjUyf59F6o/MzEzMnj0bN2/eBACJirUMw3ByHfjq1StR1ZNPlZeXIzs7m/WYfKsLm1wJ99TV1UWvT596/fo1J5vvakRERHD23HVVcnKy1I3qysrKCAoK4m1jCyGEEEL4weeGHb5i05ppzVyvmRBC+EZJooQQUodYW1tjx44d6NixY63t32vIY2UMhmGgrKwMhmGgp6eH169fw9raGgDQpEkTPHv2jLPYfFcxJUTeKSoqwtHREY6OjigvL0dqaipSUlI4iVVeXo74+HicOnUK2dnZUm+ac3GDHuCv5aa6unqtH168ffsW6urqMp4R4cqwYcMQHx+PyspK9OvXD3p6esjPz8eJEyewefNmTJs2je8pck5RUVEmcTQ0NHDlyhV4enrC3t4eWlpaYuMMw2DcuHGcxFZSUoK/v7/Usbi4uFoTJr5mO3fuRE5ODoKCgiTGoqOj0bRpU4wePZqHmXHH3d0dCxYsQEVFBRwcHCR+x4APlcy4oKGhIXp9bNy4MR4/foyuXbsCAAQCAQoKCjiJyydjY2O8e/eO72kQDty/f5/vKQAAwsLCkJOTg2XLlsHExAQqKiqcxaqoqEBZWZkoEbW0tBSFhYUSx6SmpkpsumDb1atXkZiYWGtHjqNHj7Iesy5sciXc+/bbb7Fu3Tqx6zCGYVBeXo4dO3bA0dGR5xnKFw0NDVRXV4vOJTo6OqJN3ABgZWXF08wIIYQQwgc+N+zwFZvWLLu4fMbmc82EEMI3ShIlhJA6xNfXV1QBrD5WxjAxMUFmZia6desGS0tLbNmyBe3atYOSkhI2btwIIyMjzmLzWcWUkPpGTU0NAwcOxMCBAzl5/oULFyIlJQUDBw6EiYmJTNvJ8tVys3fv3oiOjkaTJk3EKkxeuHABq1atgpOTEy/zIuzz8/NDcXExNm/ejI0bN4oeV1RUhJeXF/z8/HicHbu8vb2lXguNHj1a7HGuNs6sXLkSAJCVlYX09HSJcS6TRH/88UcsXbpU6lhhYSHGjx+PpKQkTmLzZc+ePbVWrjQ2NsbWrVvlLknU19cXAJCQkICEhASx32uhUMhZ1UEA6NixIx48eIAePXrAyckJcXFxEAqFoutuS0tLTuLyKTQ0FEuXLkX79u1hYmLC93SIHLp16xYiIyPRp08fzmMlJCQgLi4OwIfXo/Hjx9d6bG2bDthw7tw5TJ48Gfb29rhz5w569uyJ8vJyXL9+HU2aNIGtrS1nsYn8mz17NkaOHIm+ffuia9euYBgGa9aswePHj8EwDGbOnMlqvCVLlsDX1xfNmjXDkiVLPnt8WFgYq/H59Pvvv2P79u24ceOG6PMwVVVVWFtbw9vbmxJyCSGEkHqIzw07fMWmNdOaaTMaIUTeMcJPex8RQgghPDl8+DBev36NqVOn4smTJ/D19UVubi6ADzu7fvrpJ87aj3bt2hVr165Ft27d0L17d4SGhooS2M6fP49p06ZJTRAhhNQ93bp1g7+/P8aMGcP3VGSmqKgIEyZMwJ07d6ChoQFdXV3k5+ejtLQUnTp1QkJCArS1tfmeJmFRQUEBbt26haKiImhra6Nz585o1KgR39NiTWxs7L86nssEGD7Y29vDzc0Nc+fOFXs8Pz8f3t7eEAqFnFVj5ouFhQU2btwoqmb5scuXL2Py5Mlydy125cqVzx7DVWv09PR0vH79GgMGDEBxcTGCg4Nx9uxZVFdXo1OnTli1ahWnG7T44Obmhjdv3qC4uBiGhobQ1NQUG2cYBsnJyTzNjsiDfv36ISgoCC4uLpzHun//Pv766y8IhULMnTsXfn5+aNGihdgxysrKMDExgZmZGWfzGD58OGxsbBAUFARzc3MkJSXB3Nwcr169wvjx4+Hn54fvv/+elVhTpkxBSEgIjI2NMWXKlH88lmEYrFu3jpW4hF/FxcXYtm0bLly4gIKCAmhra8Pe3h4+Pj6sV/hxcnJCfHw8TE1NP7vJjmEY/Pbbb6zG58uSJUuwa9cuaGtro2vXrmjatCmADxulLl++jOLiYowZMwY//vgjzzMlhBBCCNecnZ0RFxcHU1NT5OTkYOTIkSgtLUXXrl2RmpqKHj16iDbs7Nu3D3p6el99bFozrZnrNRNCSF1ClUQJIaSOGjt2LObPny+1yk1GRgbmz5+PHTt28DAz7gwePFj0tYmJCY4fPy6qYmBpacnpRTmfVUwJIexSVFSEsbExL7Hfv3+PrVu34uTJk8jKypLacvP69eusx9XW1kZiYiLOnDmDtLQ0FBcXQ1tbGzY2NujVq5dYm0DydXr8+DH27t2Lly9fwtDQEP369ZPrXc3ylvT5b23atAnjxo1DgwYNRFWycnJy4O3tDTU1NWzZsoXfCXJAQ0MDL1++lJokmpmZCTU1NR5mxS2uEkC/hKWlpahaqJaWFtatW4fKykpUVlZCQ0ODt3lxydzcvN51aiCyFRAQgISEBHTp0oXz9nSmpqYwNTUF8CFZrVevXrxsFnny5AkCAgKgoKAAhmFQVlYGAGjevDmmT5+OmJgY1pJE3717B4FAIPqa1A9aWlqYMWMGZsyYwXms06dPS/1anh05cgS7d+/GtGnTMH78eDRo0EBsvKysDJs3b0Z8fDw6d+4MNzc3nmZKCCGEEFl49eoVKisrAQCNGzfG4cOHRRt2WrRogcLCQri5uXGyYYev2LRmWjPXayaEkLqEKokSQkgdZWpqin379qFz584SY7dv38aIESNw7949HmYmn/isYkoIYVdsbCyeP3+OqKgomccOCwvD4cOH4eTkhFatWkltdV/fk9/Iv3ft2jX4+PigqqoKurq6KCwsRHV1NebNm4eRI0fyPT25V1FRgczMTKlJ3+bm5pzFTUtLw4QJEzB16lQMGDAA3t7e0NHRwZYtW0StkOTJnDlzcO3aNezevVtUwQoAsrOzMWrUKHTp0gUrVqzgcYbcefToEdLS0kSVgW1sbNC2bVu+p0UI+ZemTJmCv/76CyUlJTAzM5NarVbeqls6ODggKioK3bt3R8+ePTFz5kwMHToUwIf21TNnzpS7KtCEyBNPT0+0a9cOixYt+sfj5s2bh4cPH2Lv3r0ymhkhhBBC+PBP9yXlNTatWbbq45oJIaQuoUqihBDyFbpx4wZ0dXX5ngYn8vPzsX37dty8eRNv3ryBgYEBLCws4O3tzema+axiSghhl5qaGtLS0uDp6Ql7e3uJZCqGYTBu3DhOYv/6668IDQ3F6NGjOXn+2ly8eBGvX7+Gu7u7xNjBgwfRrFkzdOvWTaZzIuyJiYlB69atsX79ejRt2hSlpaUIDQ3FmjVrKEmUQ5WVlViwYAGSk5NFlcs+9ddff3EW38bGBnFxcZgyZQo2bdqENm3aYOPGjWjYsCFnMfk0a9YsjBgxAv369UO3bt1gaGiI3NxcXLp0Cbq6upg1axbfU2RdZWUlZs+ejV9++QVCoRAqKiqorKwEwzDo27cvVqxYARUVFc7i//nnnzh16hSys7MlkqAZhsH27ds5i02IPHr37p1Yy3dZVru8evUqEhMT8ezZM6mbGo4ePcpJXFNTU2RkZKB79+6wt7fH+vXr0ahRIygpKWHNmjVo164dJ3FJ/fC5Lg0MwyAtLY31uC9fvsT+/fuRnp6Ot2/fgmEY6Ovrw9raGsOGDUOzZs1Yj8mXBw8eYPr06Z89rm/fvkhJSZHBjAghhBBCCCGEEMIVShIlhJA6ZMOGDdiwYQOADx92e3t7S7RErKyshEAgwKhRo/iYIqdu3ryJCRMmoLq6Gg4ODjA2NkZeXh527dqFXbt2YcuWLbCwsJDJXBo2bEiVQwn5SkVHRwMAXr9+LbVyEZdJog0aNICRkREnz/1P1qxZA2dnZ6lj+fn52LdvH1V9+Yo9fPgQCxcuFFVX1NDQQHBwMFxcXJCVlSVWdZGwJy4uDufPn0dERASCgoIwb948NGjQAMnJyXjx4gXCw8NZjffLL79IfdzV1RVnzpyBh4cHzp8/L3q8T58+rMbnW02rp61bt+LSpUt49uwZdHR04OPjg3Hjxsllq6dVq1bh7NmzWLhwIQYMGAANDQ2Ulpbi+PHjWL58OVavXo3g4GBOYm/atAnR0dFo3rw5TExMJCoeyqvi4mKcOnUKGRkZojZjHwsLC+NhVkRe7Ny5k5e4586dw+TJk2Fvb487d+6gZ8+eKC8vx/Xr19GkSRPY2tpyFtvb2xsvX74EAAQGBmLKlCnw8/MDADRp0gSxsbGsxdq6desXH8vl9T6RnYULF4q6NPTo0UNqlwa2HT16FD/++CMqKyvRuHFjNG3aFEKhEBkZGbh06RI2b96M5cuXY8CAAZzPRRYYhgE1miOEEELIx6Tdl5SGiw07fMWmNcsuLp+x+VwzIYTUFZQkSgghdYiVlRV8fX0hFAoRFxcHV1dXNGnSROwYZWVlmJiYoHfv3jzNkjsLFy5EmzZtkJCQAA0NDdHjJSUlmDhxIhYtWoSkpCTO4vNVxZQQwq779+/zFtvHxwd79uxB9+7doaioKLO4jx49wg8//CB1zNzcHOvXr5fZXAj7CgoKJK4HahJDCwoKKEmUIydPnoS/vz/69++PoKAgdO7cGR07dsTgwYMRHByM06dPw9HRkbV4M2bM+MfxkJAQ0dcMw3BaxZQvOjo6CAgI4HsaMnPs2DEEBgZi+PDhosc0NDQwfPhwlJWVYdOmTZwlie7ZswdjxoypV0mRz549g6enJyorK1FWVgZdXV0UFRWhqqoK2tra0NDQqFc/DyI/YmJi4O3tjaCgIJibm+OHH36Aubk5Xr16hfHjx3NaTf7j18HGjRvj4MGDeP78OcrLy9G6dWtWqyFHRkZ+8bGUJCofZN2l4cmTJ5g7dy5sbGwQHh4OExMTsfFHjx5h8eLFCAkJgZmZGVq1aiWTeXGpXbt2+OWXXz67SfrkyZNo3769jGZFCCGEED5Juy8p77FpzfUjNp9rJoSQuoKSRAkhpA6xs7ODnZ0dgA83NTw8PNC4cWOeZyU7jx8/xtq1a8USRAFAU1MTEydO5DRpoC5VMSWEfL3Gjh2L3NxcfPfdd+jSpYtEq3uAmyplDMOgpKRE6lhRUVGtrbIJIbXLzs5Gq1atoKioCFVVVRQXF4vGBg0ahMDAQCxcuJC1eL/99htrz0W+DkVFRWjdurXUsdatW6OoqIiz2IWFhbVWoJZXERERsLCwwNq1a2FpaYmNGzfC1NQUx48fx+rVq7F27Vq+p0i+Qlu3boWbmxv09fU/W+mSq8TFJ0+eICAgAAoKCmAYBmVlZQCA5s2bY/r06YiJicH333/PelwAiI2NFfvcgmEYGBsbAwByc3Oxb98++Pv7sxKLz41ghB+y7tKwZ88eGBkZYePGjVITnNu2bYtNmzZh8ODB2L17t1xsLBg1ahSCg4PRuHFj+Pr6Ql1dXWy8vLwcW7ZsQVJSElasWMHTLAkhhBAiS8OHD0fnzp3rVWxac/2IzeeaCSGkrqAkUUIIqaPYupHyNWnZsqVYAsbHSkpKOL05wHcVU0IIu/7++28cOnQIaWlpKCoqgra2NmxsbDBkyBA0aNCAs7gpKSnYsmULGIbBxYsXJVoiMgzDyc1ECwsL7N69G3369BFrmSIUCrFnzx5KcpcDtbXDGT16tNjj1A6HPQYGBqLrkm+++QaXL1+Gg4MDgA8VCdnWvHlz1p/za1JeXo74+HicOnUK2dnZUluBy1v11NatW+PIkSNSq3clJyfXmkDKht69eyMtLQ329vacxahrbt26haVLl4oSf96/fw9FRUW4ubmhoKAAS5Yswd69e3meJfnaREZGwsbGBvr6+p+tdMlVkqiqqiqqq6vBMAwMDAzw4sULdOnSBQDQsGFDZGdnsx6zRlxcHHr27Cl1c2tubi7i4uLq5WcbhB2y7tJw5coVDB8+/B8r4KqoqGD48OE4ePAg5/ORhUGDBuHmzZuIiYnBjh070LVrVzRr1gwA8Pr1a1y5cgVFRUUYPXo0Bg4cyPNsCSGEEEIIIYQQ8l9QkighhNRhz58/x8GDB/Hs2TNUVFRIjMtb++DZs2dj0aJFaNq0qaiiKgBcvnwZsbGxCA8P5yw2n1VMCSHsysrKgpeXF169egVTU1Po6ekhIyMDJ0+exLZt27Bjxw7O2nOvXLkSffv2xeLFiyXOJ1yaPn06xo4di0GDBmHIkCEwMDBAbm4uDh8+jGfPnmHnzp0ymwthHyVX8MPOzg7Xrl2Dk5MTPDw8sGLFCjx9+hTKyspITU3l9Eb5xYsX8fr1a7i7u0uMHTx4EM2aNeO0fTAfFi5ciJSUFAwcOBAmJiYSSfbyaOrUqfjhhx/w6tUr9OnTB/r6+sjLy8OpU6eQnp7OemXLu3fvir52d3fHggULUFFRAQcHB6mVr83NzVmNz7fKykpoaGhAQUEB2trayM3NFY21bduWqhSS/8nHvzd8/Q6ZmpoiIyMD3bt3h729PdavX49GjRpBSUkJa9asQbt27TiLLRQKax178+aN1HMLmyoqKpCZmSn18xJ5O4fVR7Lu0pCVlfVFLdXbt2+PV69esRaXb+Hh4XBwcMD27dvx+++/izbqqKiowMrKCt7e3nBycuJ5loQQQgghhBBCCPmvKEmUEELqqFu3bsHLywvNmjXDs2fP0L59e5SUlODVq1do0qQJWrRowfcUWRcVFYWSkhJ4e3tDU1MTjRo1QkFBAUpKSqClpYXo6GhER0cD+FCFJTk5mbXYfFYxJYSwa/ny5QCAY8eOiVVhe/r0KaZMmYKIiAjOWsoWFhZi+PDhMk0QBQArKyts27YNUVFRiI6ORnV1NRQUFGBpaYlt27bB0tJSpvMh7KIkUX4EBASgoKAAAESV306ePImKigp4eXlh2rRpnMVes2ZNra3A8/PzsW/fPrmreHjmzBkEBwdjzJgxfE9FZvr06YPY2FjExcUhMjISQqEQDMPAzMwMsbGxrCdkuLu7S1SbTkhIQEJCgsTjDMPIXeVWY2NjvHr1Cra2tujQoQP27NkDBwcHKCkpITExEYaGhnxPkZD/ibe3N16+fAkACAwMxJQpU+Dn5wcAaNKkCWJjY1mNl5KSgpSUFAAf3pdHRkZCU1NT7JjKykrcuXMH1tbWrMb++PkXLFiA5ORkCAQCqcfI2zmsPpJ1l4Z3796hYcOGnz2uQYMG+Pvvv1mLWxc4OzvD2dkZAoFAdP3bqFEjmVRwJYQQQkjd4e/vL7VLwOcIhULMnTsX06dPF1Ul/1pi05plF5fP2HyumRBC6hJG+E9bvgkhhPDGy8sLzZs3x9KlS2Fubo6kpCSYm5vj+vXrmDVrFhYtWoQePXrwPU1WhYSESG2lW5uaRDA2/PHHH1i0aBGWLVsmUcX0xx9/RHh4OBwdHVmLRwjhTpcuXbBo0SIMGDBAYuzYsWOYP38+rl27xknsmTNnol27dpg6dSonz/8lysvLUVRUBC0tLairq/M2D0K+ZlVVVXjw4AGaNm0KXV1dmce3trZGbGysqL39xy5evIjp06dzdh7jS/fu3REZGSm19Xp98Pfff6OkpASamppo0KABJzGuXLnyr47/+JpYHmzduhU5OTkICQlBeno6xo8fj7KyMjAMA6FQiIiICAwaNIjvaZKvnEAgwM2bN5GdnS2qxvexwYMHcz4HoVCI58+fo7y8HK1bt/7H1tn/i0OHDolabV+9ehUdOnSQSKxTUVFB69atMWHChP/pRtznrF69GocPH8bs2bMRFBSEefPmoUGDBkhOTsaLFy/o/buc6N27NywtLWXWpcHU1BT79u1D586d//G4mzdvwtPTkxKRCSGEEEL+P4FAgI4dO+LAgQMyr+jPV2xaM62ZEEK+RlRJlBBC6qgHDx5g0qRJUFBQAABR+zRra2v4+/tj5cqVcpckGhERwVtsPquYEkLYJRAIoKqqKnVMVVW11mpDbBg2bBgWLlyI8vJy2Nvb89K+V01NDWpqapzGIETeKSgoYMSIEdi4caPURE2uMQyDkpISqWNFRUWcnsf4MnLkSBw5cqTeJok2aNCAs+TQGvKW9Plv+fj4iL62tLRESkoK/vjjD1RUVKBbt26ctuQm9cPdu3cxffp0ZGVlSW3DzjAMJ0misbGx8PDwECVjMgwDY2NjAEBubi727dvHalXyIUOGYMiQIQA+bG5dsGABTExMWHv+L3Hy5En4+/ujf//+CAoKQufOndGxY0cMHjwYwcHBOH36NCWJygE+ujR4e3t/dvMy1dwghBBCCJHE5zUSX7FpzfUjNl3/E0LkCSWJEkJIHcUwDJSVlcEwDPT09PD69WtRq7YmTZrg2bNn/E6QY0KhELm5udDT04OSEvcvV+bm5ujYsSPncQgh3LO2tsa6detgZ2cn1vqypKQE69ev56ztJQBMmDABALBx40Zs3LiR0/a9S5Ys+VfHs9mKkRB5p6CggG+++QZFRUW8xLewsMDu3bvRp08fifPInj17YGFhwcu8uKSmpoa0tDR4enpKTbJnGAbjxo3jZ3IsWrJkCXx9fdGsWbMvOo9zfe7OyMjArVu38ObNGxgYGKBTp05o3bo1pzHriqZNm2LEiBF8T4PIkQULFkBDQwPbt29HmzZtJFpjcyUuLg49e/aUWrEzNzcXcXFxrCaJfmznzp2cPO/nZGdno1WrVlBUVISqqiqKi4tFY4MGDUJgYCAWLlzIy9wIexwdHXHjxg3Y29vLJB5XfyeEEEIIIYQQQgghdQEliRJCSB1lYmKCzMxMdOvWDZaWltiyZQvatWsHJSUlbNy4EUZGRnxPkRPnzp1DTEwM7t27B4FAICrhHx4eDltbW85aQPJZxZQQwq45c+ZgzJgxcHR0RLdu3aCvr4+8vDxcvHgRysrKWLZsGWexd+zYwdlzf+r06dNffCzDMJQkSsi/NGXKFMTHx8Pa2pqTVrn/ZPr06Rg7diwGDRqEIUOGwMDAALm5uTh8+DCePXvGW1IOl2oqtr9+/Rrp6ekS4/KSJHr69GkMGzYMzZo1++x5nMtz97t37zBv3jycOHEC1dXVUFVVRUVFBRQUFNCvXz8sXrxYon20PHj//j0OHDiA27dvIzs7G/PmzYOxsTGOHz+O9u3by7waIpEvjx8/xpo1a2Retfefqpq8efNGamV7tsTGxn72GC4S7wwMDESJod988w0uX74sqvwt7xtq6xNZd2mgJFFCCCGEEEIIIYTIM0oSJYSQOmr48OF4/fo1ACAwMBC+vr74/vvvAQDq6ur46aef+JweJ1JSUjB79mz0798fHh4eCA8PF40ZGRnh4MGDnCWJfkzWVUwJIexq3749jh49iq1btyItLQ2PHz+GtrY2hg8fjnHjxqFJkyacxZZlUsC/SRIlhPx7J0+eREFBAVxcXNC+fXvo6+uLjTMMg3Xr1nES28rKCtu2bUNUVBSio6NRXV0NBQUFWFpaYtu2bbC0tOQkLp/u37/P9xRk4uNzN5/n8SVLluDMmTNYvHgx+vbtCw0NDZSWluLkyZNYtmwZlixZguXLl/M2Py5kZmZi3LhxKCgoQIcOHZCWloZ3794BAK5evYpz587J3ZqJbBkbG4t+p7iWkpKClJQUAB9ejyIjI8Uq6ANAZWUl7ty5w2kV/e3bt0s89vfff0MgEEBNTQ0qKiqcJN7Z2dnh2rVrcHJygoeHB1asWIGnT59CWVkZqampGDhwIOsxiezJsksDIYQQQgghhBBCiLyjzBdCCKmjBg8eLPraxMQEx48fx40bN1BRUQFLS0vo6enxNzmOxMfHw9vbGyEhIRAIBGJJom3btpV6A4pNfFUxJYSwp6KiAlFRURg0aBBCQ0P5ng4h5Cv27t07tGrVSux7WbKxscHevXtRXl6OoqIiaGlpQV1dXaZzINw6fPgwHB0d0ahRI4mxwsJC/P7772LvCdh06tQpBAUFwd3dXfSYhoYGhg0bhoqKCqxatUruEiaXLFkCXV1d7N+/H1paWujYsaNozNbWFqtWreJxdkQehIaGYunSpTKpSvv+/XvR65JQKERZWRkUFBTEjlFRUcH3338vSrTjwtWrVyUeq6qqwsWLFxEVFYUVK1ZwEjcgIAAFBQUAIKoyffLkSVRUVMDLywvTpk3jJC6RLVl2aSCEEEIIIYQQQgiRd5QkSgghX4mGDRvi22+/5XsanMrMzISjo6PUMXV1dZSUlHAWu65UMSWE/DeqqqpISkpCnz59ZBbTzc3ti49lGAbJycmczeX58+d49uwZKioqJMZk+TMhRB7UlZbuampqUFNT43sanEhISMDgwYNhYGAgeuz69eswMzMTS4jNzMzExo0bsXjxYj6myZnQ0FAkJiZKTRJ9+fIlQkNDOUsSVVVVxTfffCN1zMjISC6r6V+5cgUrV66Erq4uBAKB2JiBgQHevHnD08yIvFi8eDHevHkDNzc3GBoaSlT2ZPM6cMiQIRgyZAgAwMvLCwsWLOA8MfVLKSkpoUePHsjJycGCBQuwd+9e1mNoa2uLvXaMGzdOlCwKADk5OWjQoAHrcYlsybJLAyGEEEIIIYQQQoi8k79P/QkhRI7k5+dj+/btuHnzJt68eQMDAwNYWFjA29sburq6fE+PdQYGBnj69Cns7e0lxh48eIBmzZpxFpvvKqaEEPZYWVkhPT1dZjcVzc3NxVof8qG0tBTTpk3DlStXAHyoKAVAbF7UipGQr0txcTFOnTqFjIwMVFZWSoyHhYXxMCt2rVq1Cl27dhUl+ggEAowePVpUzb1Gfn4+Dhw4IHdJojXnammKi4vRsGFDzmIPHToUP//8M3r06CHRvnfPnj0YOnQoZ7H5oqioWOvP/O3bt5RQRv4zPq4JKyoqUFRUhKysrDqTJFqjSZMmuH//PifP7e/vj/j4eKkJ7ZmZmfDx8UFqaionsQkhhBBCCCHiFBUVsWPHDrGOPPIem9YsW/VxzYQQwgVKEiWEkDrq5s2bmDBhAqqrq+Hg4ABjY2Pk5eVh165d2LVrF7Zs2QILCwu+p8mqgQMHIiYmBq1btxYldzEMg4cPH2LTpk0YOXIkZ7H5rGJKCGHXjBkzEBQUBEVFRTg6OkJPT0/ihr2Ojg5r8SIiIlh7rv9VVFQU3r59i927d2PUqFGIjY2FtrY2kpOTcenSJaxcuZLvKRLyVRAKhbhw4QL09PRgamoqemzp0qVixzVs2BABAQGczePZs2fw9PREZWUlysrKoKuri6KiIlRVVUFbWxsaGhpykSQqLWHvnxIn5cHZs2dx7tw50fdbtmyBvr6+2DEVFRW4dOkSzMzMOJuHtrY27t27hz59+qB3797Q09NDXl4ezpw5g8rKStjY2GDr1q0APlyPf1yh72tla2uLrVu3omfPnqK23AzDQCgUYt++fVI3qhHyb/BxTaiqqoqcnByJVvN8y8zMREJCAoyMjDh5/oyMDMyaNQtr1qwRu87PyMjAuHHj0KJFC07iEu5ZW1tjx44d6NixI6ysrD6beH39+nUZzYwQQgghpP7JyspCamoqsrKyPruBme2CDXzFpjXTmrmMSwghfKMkUUIIqaMWLlyINm3aICEhARoaGqLHS0pKMHHiRCxatAhJSUk8zpB9/v7+ePToEXx8fEQJXBMnTkR+fj569eqFSZMmcRabzyqmhBB2eXp6AviQOBkdHS31GHmrqnnu3DkEBASINg8YGhqic+fOsLW1RUREBLZu3YrVq1fzPEtC6r7jx49jzpw5Yq1xq6ursWvXLhgYGEBZWRkAkJeXh/bt22PAgAGczCMiIgIWFhZYu3YtLC0tsXHjRpiamuL48eNYvXo11q5dy0lcwr1nz57h9OnTAD4kKF67dg0qKipixygrK6Nt27YIDAzkbB6rVq0Sfb1jxw6J8Y83F8hLkmhQUBBGjhwJV1dXODk5gWEY7N69G48ePcLz58+xf/9+vqdIyP+kT58+OHHiBBwcHGQeW1oSX1VVFd6/fw81NTXExsZyEnfLli0YM2YM5s6di+XLlwMAHj16hHHjxsHU1BRxcXGcxCXc8/X1FVUY9/X15b1jAyGEEEJIfVXzGZlQKISurq7oM7EaDMNwtoGZr9i0Zlozl3EJIaQuoCRRQgipox4/foy1a9eKJYgCgKamJiZOnMhp9Sq+qKioYN26dbh06RIuXLiAgoICaGtrw8HBgfMbXnxWMSWEsGvZsmX17mZifn4+mjZtCkVFRairq6OwsFA05ujoiOnTp/M3OUK+IsnJyRgwYAA6deokMbZ+/XpRC/SoqCgcOXKEsyTRW7duYenSpaLkwffv30NRURFubm4oKCjAkiVLxBJZydfD29sb3t7eAAAnJyfEx8eLqtbKElctoOsyExMTJCUlITY2FikpKVBUVMTvv/8Oe3t7REdHU+VBwori4mKcOnUKGRkZn61GwhZra2usWrUKkydPRs+ePaGvry9xLdynTx/W4wLSk/hUVFTQpEkT9OzZk9Xq/R8zMjLC1q1b4eXlhUWLFsHd3R2+vr6wsrLCTz/9JJF8T74e/v7+oq/pPQwhhBBCCH9Wr14NFxcXLF68GJqamvUiNq2Z1kwIIfKOkkQJIaSOatmyJYqLi6WOlZSUcNa2rS7o1q0bunXrJtOYfFYxJYSwa+jQoXxPQeaaNGmCgoICAICxsTFOnz6Nnj17AgBu3LgBVVVVPqdHyFfjzp07mDdv3mePs7W1xZEjRzibR2VlJTQ0NKCgoABtbW3k5uaKxtq2bSv3CX71JdG/pqIokR0jIyNERkbyPQ0ip549ewZPT09UVlairKwMurq6KCoqQlVVFbS1taGhocFJkmhoaCgA4OzZszh79qzEOMMwnFXR5zOJr3Xr1ti8eTPGjh2L/fv3w8nJCatWrYKioiJvcyKEEEIIIURe5OfnY8SIEbwk0fEVm9YsW/VxzYQQwjdKEiWEkDpq9uzZWLRoEZo2bSqqbAkAly9fRmxsLMLDw3mcnfzhs4opIYT8V927d8eFCxfw3XffwdvbGyEhIbh16xaUlZVx69Yt+Pj48D1FQr4KRUVF0NPTE3tMUVERa9euFasyqKGhIVaxl23GxsZ49eoVbG1t0aFDB+zZswcODg5QUlJCYmIiDA0NOYsta97e3hJJoaNHjxZ7TCgUynpaMvX8+XM8e/YMFRUVEmNsVv+7e/fuvzq+pnIuIeTLREREwMLCAmvXroWlpSU2btwIU1NTHD9+HKtXr8batWs5ifvbb79x8rx1zdatW6U+3r17d1y8eBGdOnXCjh07AHxIjB03bpwMZ0fYMnbs2H91fM2/OSGEEEIIYVePHj2Qnp4Oe3v7ehOb1ixb9XHNhBDCN0Yo73dbCCHkK+Xm5obc3FwUFxdDU1MTjRo1QkFBAUpKSqClpSWWHMAwDJKTk3mc7f/Oysrqi6tFMQyDtLQ0jmdECPnalZeXIz4+HqdOnUJ2drbUVp9cVVPiS1lZmahiFQD8+uuvOHnyJCoqKuDg4ABPT08oKCjwPEtC6j57e3vMmzcP/fv3/8fjTpw4gUWLFuHixYuczGPLli3Izc1FSEgI0tPTMX78eJSVlYFhGAiFQkRERGDQoEGcxJal2NjYf3X8xy1o5UFpaSmmTZuGK1euAPi/ZNiPr43ZfL0yNTX9outuoVDIaeVBWaqpsPglGIbBsmXLOJwNkXcODg5YunQpHB0d0aFDB+zduxeWlpYAPiSyHT9+HHv37uV3kixwc3P74mPZ/KzC1NT0X8WVh3NYfTR16lSx16rbt2/j7du3MDU1hZ6eHvLy8nD//n0YGBigU6dO//paghBCCCGEfJmioiIEBASgU6dO6NatG7S0tCSO4WpzKV+xac20Zi7jEkJIXUCVRAkhpI4yNzdHx44d+Z4G53x9fcVuAAgEAqxbtw7Dhw+XqypZhBDZWbhwIVJSUjBw4ECYmJhAWVmZ7ylxTl1dHerq6qLvv/vuO3z33Xc8zoiQr1OnTp1w4sSJL0oS7dy5M2fz8PX1FX1taWmJlJQUnDt3DuXl5ejWrRvatWvHWWxZkrekz38rKioKb9++xe7duzFq1CjExsZCW1sbycnJuHTpElauXMlqvPpYbe3QoUNo2LAhWrRo8dmKtF+6cY2Q2lRWVkJDQwMKCgrQ1tZGbm6uaKxt27a4f/8+53MoKyuTWpVYR0eHtRjm5ua8/L3I4udH+BcfHy/6+vDhw8jIyMCuXbvEKro/f/4cfn5+cHZ25mOKhBBCCCH1wrt371BWVoYNGzZg48aNYmNcby7lKzatmdYsTxunCSFEGqokSgghpE4RCAQwNzdHUlIS5zu1qIopIfKpW7du8Pf3x5gxY3iJ/+eff4qqmH56k55hGGzfvp3T+Hl5eVKTA5o1a8ZpXELkwdmzZzF58mRMnz4dfn5+EhV4hUIh1q1bh5iYGKxfvx6Ojo6sxn/8+DH27t2Lly9fwtDQEP369YODgwOrMUjd4eTkhICAAAwYMADm5ubYt2+fKPk4IiICOTk5WL16NS9zy8zMhJGRES+x2eTp6YmbN2+ibdu2GDhwIFxdXdG8eXO+p0Xk1LBhwzBmzBgMHjwYPj4+EAqFiI2NhZKSEkJCQnDv3j388ssvrMcVCoWIj49HYmIi3rx5I/UYusFFvkZ9+vTBrFmz0LdvX4mxEydOYNWqVfj11195mBkhhBBCiPzz8vJCZmYmJk6cCGNjY6mFGOzs7OQqNq2Z1sxlXEIIqQuokighhHwFhEIhcnNzoaenByWl/9fencdFXe79H39/HXAXUdx7aOaWhJZoyGaSiJWKVic75p6YuaEdvfO4p7ZoZrncIC6VknbOrZZZOioq0l2adULSTLNM05Oh4sKgWSwyzO+P7vgdwrVm5juMr+df9r2u+Lyvx0OHgflc18VLt7NwiingnSwWixo3bmxK7TfeeEOvvvqqbrvtNjVt2lTVqlVzS12bzaYXX3xR27ZtU2FhYYkxdr8CNy4qKkpPP/20EhIStGbNGoWFhal+/fqSpKysLH366ac6c+aMhg4d6vQG0T179mjw4MEqLCxUzZo1lZOTo3feeUfPPfec+vTp49Ra8AzZ2dmqX7++LBaLKlWqpJycnOKxqKgojR492u15tmzZoo0bN+rLL7/0iu8bq1ev1smTJ7Vp0yZZrVbNnz9fbdq0UWxsrLp27aqaNWuaHRFepHv37sWnXT7zzDMaMmSI2rdvL8Mw5HA49PLLL7ukbnJyspKTk/XUU09p/vz5GjFihCwWizZt2qTLly9r+PDhLqnrbgcPHryp+VwPWPadPn36qht7DcNQVlaWmxMBAADcOvbv36/XXntNMTExt0xt1uxet+KaAcBsdBoBgAfbuXOnEhIS9PXXX8tut+vdd99VUFCQpk2bppCQEPXs2dPsiGXa7z94/61JtHfv3nygBJRhffr00QcffKAOHTq4vfY///lP9e/fX1OnTnVr3alTpyo9PV3Dhg1T06ZNr7j7FcCNGTdunNq2basVK1YoJSVFBQUFkqTy5curbdu2ev75553eICpJCQkJatKkiZYsWaL69evr0qVLmjRpkhYsWECTqJeqV6+ebDabJKlx48ZKS0tTx44dJUl79+5VhQoVXJ4hNzdX27dvl9Vq1e7du1VYWKi77rpLkyZNcnltd2nQoIGGDh2qoUOH6siRI7JarVq5cqVmz56tsLAwDRgwwCX/pnHrGTx4cPGf27RpI6vVqo8//lj5+fkKCwtTixYtXFL33Xff1ejRo9WvXz/Nnz9fMTExCgoK0siRIzVixAj98MMPLqkr6ZqvFeXKlVO1atUUGBioBx54QJUqVfpTtR577LEbugmEDVLe4+6779aCBQsUGBhY4nTrEydOaOHChbrnnntMTAcAAODdbr/99lKHEXh7bdZ8a9Q2c80AYDaaRAHAQ1mtVo0fP15du3bV448/rmnTphWPNWzYUO+99x5NogDwf1asWFH850qVKikjI0NPPPGEwsPD5efnV2KuYRh68sknXZIjJydHnTt3dsnXvpZ//etfmjp1qh555BG31wa80f3336/7779fdru9+HRHf39/WSwWl9U8fPiwZs6cWXxyadWqVTVhwgTFxMTo1KlTxc/hPSIjI7V792516dJFgwYN0sSJE7V//375+vpq//79JRrOnMlut2vnzp3auHGj0tLSlJeXp1q1aslut2vevHnq1q2bS+p6gmbNmulvf/ubRowYoYULFyo5OVkVK1akSRQuUb9+ffXu3dvldTIzMxUYGCiLxSIfHx9dvHhR0q9Nmn379tWUKVM0btw4l9Q+dOiQzpw5o+zsbFWvXl0BAQE6f/68Lly4oJo1a6pSpUpauXKlFixYoLfeekuNGjX6w7VWrlzpxOQoC2bOnKm4uDg99NBDat68efHfr++++04BAQFKTEw0OyIAAIDXmjRpkubMmaPmzZuradOmt0Rt1syaAcDb0SQKAB4qKSmp+MNiu91eokm0efPmeuutt0xM53o3ckIIAPxmzpw5pZ6dPHlS+/btK/XclU2inTp1UkZGhsLDw13y9a/Gz89PNWrUcGtN4FZgsVgUEBDgllo2m0316tUr8ey3xlCbzUaTqBd69tlnlZubK0l65JFHVKVKFaWkpCg/P1/Tpk3TE0884dR6GRkZslqtSklJkc1mk7+/v3r27KkePXqoefPmCg0NVe3atZ1a05PY7Xbt2rVLmzdv1o4dO2SxWNSrVy/16tXL7GgowzzhCnR/f3/98ssvkn49Offrr78ufi9qs9mUl5fn9Jq/+fvf/64ZM2YoISFB7dq1K36+Z88eTZ48WVOmTNHtt9+uYcOGae7cuUpISPjDtdq3b3/Dc0+cOPGH68BzNG3aVNu3b9e6deu0f/9+nT17VoGBgerdu7f+8pe/uOXEbQAAgFvVrFmzdPbsWfXo0UN16tRRtWrVSowbhqENGzZ4VW3WzJpdWRcAPAFNogDgoU6cOHHVE20qVaqkn376yc2JXCM4OPiKDaH9+vUr9dwwDGVkZLgrGoAy5JtvvjE7gqRfr8GcMWOG8vPzFRERUeoUU8k1zQFDhgzRqlWrFBkZKR8f3uIDQFlQqVKlEtcvd+nSRV26dHFZvd/eX4eGhmrw4MElvmd4y88WV5Kenl7cHFtQUKDOnTvr1VdfVYcOHfieiT/NE65Ab9u2rb766itFRUUpNjZWiYmJOnfunHx8fLR27VqXbl6aM2eO4uPjSzSIStK9996rkSNHau7cubJarXr66aevuKnLmbKzs7VlyxZt3LhRX375JdfNe4ny5curT58+6tOnj9lRAAAAbilBQUGmHeZiVm3WfGvUNnPNAGA2fhsOAB6qdu3a+v7776/4gc63336rBg0amJDK+eLi4jzuzbin5QFQdsTFxUmSXn/9db3++uslXk9c2Rzw/fff6+jRo+rSpYtCQkKu2Jw6depUp9cF4FyDBg26oc0zbJzxPufPn1d+fn6p5858z9+iRQsdPnxY6enpslgsstlsiomJUdWqVZ1Ww9NERUXJZrOpY8eOmjFjhqKjozl5Dk7lCVegx8fHKysrS5I0fPhwXbx4UVartXjT0n/eSuJsx44du+L7TkmqXr26fvjhB0lSo0aNXHKiaW5urrZv3y6r1ardu3ersLBQd911lyZNmuT0WgAAAMCt5OWXX77larPmW6O2mWsGALPRJAoAHio2NlYJCQlq0qRJ8bVqhmHo8OHDeuONN7zmFIXRo0ebVptTTAHvcfz4cY0bN07PPPPMVU9h/uijj7Rw4UItXLhQDRs2dEkOsxoFPvzww+LXrT179pQaNwyDJlHAw8XHx5sdAW5ms9n04osvatu2bSosLCwx5oqNBRs2bNCRI0e0YcMGbdq0SRMnTlTFihUVFRWlTp06eeVGqaysLPn4+OiTTz7R7t27rzmX9/v4IzzhCvQmTZqoSZMmkn49dXHq1Klue9/XpEkTvfnmmwoNDS1xMvIvv/yiN998U82aNZMknTlzRrVq1XJKTbvdrp07d2rjxo1KS0tTXl6eatWqJbvdrnnz5qlbt25OqQMAAAAAAAB4E8PhcDjMDgEAKK2goEDPPPOMPvzwQ/n7+ysnJ0cBAQHKzs7W/fffr4SEBK5H/JMSEhJu6sNwmjcAz/Xcc8/p+++/19tvv33NeQMGDFDTpk01Y8YM9wQDAOAqRo0apfT0dA0cOFBNmzaVr69vqTkxMTEuq5+RkSGr1aqtW7cqOztbhmEoJiZGAwcOVEhIiMvqulNiYuJNzef9PpzN3Vegnz59WmfOnFHdunVVt25dl9aSft2cNHToUPn6+io0NFQ1atSQzWbTZ599psLCQr3xxhtq166d5s2bp8uXL2vChAl/uNZvr1kpKSmy2Wzy9/fXgw8+qB49eqh58+YKDQ3VqlWrvOb1CwAAAHC3F198UXFxcWrQoIFefPHF68535uY0s2qzZtbsyroA4GloEgUAD/fZZ59p9+7dstlsql69uiIiIhQREWF2LADwKJ07d1Z8fLweffTRa857//33lZiYqNTUVDclAwDgyu69915NnTpVjzzyiKk57Ha7du3aJavVqh07dig3N1cNGjTQjh07TM0FlFVXuwL9kUce0cCBA11Sc82aNVq8eHHxtfOSVKdOHY0YMUJPPPGES2r+5uzZs1qxYoUOHDigs2fPqnbt2mrdurWefPJJ1a5d22l1WrZsKcMwFBoaqsGDBysyMrJ44+xPP/2kkJAQmkQBAACAPyE6OlpJSUlq2bKloqOjrznXMAyn/t7ArNqsmTW7si4AeBqaRAEAAFDmtWrVSsnJybr33nuvOW/Pnj0aPHiwvvrqK5dlef/997VmzRodP35c+fn5pca/+OILl9TNyspScnKyvvjiC+Xk5Mjf31/t2rXToEGD3HKSFADg5kRHR2v69OmKiooyO0qxvLw8paamymq1asmSJWbHAcqMq12Bfu7cOb322msuvQJ96dKlmj9/vh5++GE9+OCDxXVTUlK0ceNG/e1vf9OwYcNcVt9devbsqcOHD8tisSgsLEw9evRQTEyMqlatSpOoF8rPz9c///lPRUZGqkWLFmbHAQAAAAAAKPO4pxgAAABlXpUqVWSz2a47LycnR5UrV3ZZjg8++EDTpk3To48+qr179+qxxx5TUVGR0tLS5Ofnp4cfftgldQ8fPqz+/fvr8uXLioyMVMuWLXX+/HmtXr1a69at09tvv63mzZu7pDYA4I8ZMmSIVq1aVeI0PLNVrFhRsbGxio2NNTsKUCZc6Qr0nj17lrgC3ZmnaV7JqlWrNGTIEI0fP77E8+joaAUEBGjVqlVe0SS6YcMGHTlyRBs2bNCmTZs0ceJEVaxYUVFRUerUqZMMwzA7IpyoQoUKWrBggYKCgsyOAgAAAAAA4BU841MIAIAkKTg4+IY/2DAMQxkZGS5OBABlQ6tWrbR582Z16dLlmvM2bdqkVq1auSzHihUrNHLkSD399NNau3at+vbtq6CgIF26dElDhgxRlSpVXFJ3zpw5atiwoZYvX67q1asXP79w4YLi4uI0Z84cvfHGGy6pDQD4Y77//nsdPXpUXbp0UUhIiPz8/ErNmTp1qgnJANyofv36XfMKdHf4+eefFRERccWxDh06aPXq1W7J4Q7NmjXTuHHjNG7cuOIG3a1bt2rr1q0yDEMrV66UJE4T9RKBgYE6cuSI2rdvb3YUAACAW0J2drbOnDmjli1blnj+zTffKCkpSUePHlWtWrU0aNCg617ZXVZqs2b31TWztplrBgBPwnXzAOBBEhISSjSJ2u12LV68WH/9619Vp06dUvPj4+PdGQ8APNaOHTs0atQoxcfHa8SIEbJYLCXGi4qKlJSUpEWLFmnRokUu+0E/ODhYS5YsUWhoqIKCgrR8+XKFhoZKklJTUzVr1iylpaW5pO7cuXMVExNTaiw1NVXjx4/X3r17nV4XAPDHXe97kWEY2rFjh5vSAPgjPOEK9NGjR6tRo0alThKVpFdeeUXHjx9XUlKSy+qbzW63a9euXbJardqxY4dyc3PVoEEDXj+9wP79+zV+/HiNHTtWUVFRqlSpktmRAAAAvNrUqVN18OBBrV+/vvhZZmamevbsqby8PN155506ffq0cnJy9NZbbzn15xyzarNm99U1s7aZawYAT8JJogDgQUaPHl3iv39rEu3duzdXbAHANXTu3FlPPfWUEhMTtXr1aoWHh6tBgwaSpFOnTunTTz/VuXPnNGTIEJfuBK1ataoKCgokSXXr1tWRI0eKm0TtdrtsNptL6losluK6v1dQUFCqaRYAYD5XbBoA4F6ecAV6r169NH36dGVnZ6tz584KCAjQ+fPnlZqaqs8++0wzZ87UwYMHi+d72+8WLBaLoqKiFBUVpby8PKWmpspqtZodC04waNAgXb58WWPHjpUkVaxYscS/KW7YAQAAcK4vvvhCvXr1KvEsOTlZv/zyi15//XV16NBBeXl5Gjx4sF5//XWnNtKZVZs1u6+umbXNXDMAeBKaRAEAAOAVnn32WYWEhGj58uXaunVrcdNkhQoV1LZtW7344ouKiopyaYZWrVrp22+/1X333afo6GgtWrRIDodDPj4+WrZsmdq0aeOSuhEREVqwYIECAwN1xx13FD8/fvy4Fi5ceNUrSAEA5sjPz1dERITmzp3LNVZAGWf2FejDhg2TJK1fv17r16+XYRj6z4ujhg8fLklyOBwyDEOHDh1ySQ5PULFiRcXGxio2NtbsKHCCuLg4tzRaAwAA4FdZWVlq3rx5iWcffvihAgMD1aFDB0m/vufu37+/XnnlFa+ozZrdV9fM2mauGQA8CU2iAAAA8Bq/nSJkt9uVk5MjSfL393fbSZrDhg3TyZMnJUljxoxRZmamZs2apaKiIrVu3VrPP/+8S+pOnDhR/fv3V/fu3dW8eXPVqlVL58+f1+HDh1W/fn1NmjTJJXUBAH9MhQoVVKlSJU56BrxMu3bt1K5dO02dOrXEFeipqakuuwL9tyZUwNv8/rYdAAAAuJZhGCU26Zw7d04//vijBg0aVGJe3bp1nX5jllm1WTNrdmVdAPA0NIkCAADA61gsFgUEBLi9bps2bYpPC/Xz89PixYtVUFCggoICVa1a1WV1GzRooI0bN2rdunXKyMjQxYsX1bhxYz322GP6y1/+oipVqrisNgDgj3nkkUf07rvvuvyUawDu584r0Nu3b++Sr3uj3n//fa1Zs0bHjx9Xfn5+qfEvvvjChFTwJg6HQ8eOHdOFCxdUvXp13XHHHZwwCgAA4AJ33HGHdu/eXXyy4ocffijDMBQZGVli3tmzZ1WzZk2vqM2aWbMr6wKAp6FJFADKAH75DQBlV/ny5VW+fHmX16lSpYoGDhyogQMHurwWAODP8/Pz0759+9SjRw/dd999qlWrVon3/YZh6MknnzQvIACncPUV6JcuXVJBQUGJD7I2bNigo0ePKjw8XGFhYS6pK0kffPCBpk2bpkcffVR79+7VY489pqKiIqWlpcnPz08PP/ywy2rj1vCPf/xDSUlJys7OlsPhkGEYCggI0MiRI9W3b1+z4wEAAHiVAQMGaMKECbp48aJq1aql//mf/1GjRo0UERFRYt6uXbvUokULr6jNmlmzK+sCgKehSRQAPEhwcPAVG0L79etX6rlhGMrIyHBXNADADdq3b59SUlJ06tSpUqcpGYahxYsXm5QMAOBJ5s2bJ+nXUwq+++67UuM0iQK4EePHj1edOnU0c+ZMSVJiYqISExNVvXp1vf7663r11VfVrVs3l9ResWKFRo4cqaefflpr165V3759FRQUpEuXLmnIkCGcZo8/Zc2aNXrhhRfUvXt3devWTbVq1dK5c+e0efNmvfDCC/L19dXjjz9udkwAAACv0bNnT2VlZentt9/WxYsXFRQUpOnTp8vH5/+3lJw/f14ffvihRo8e7RW1WTNrdmVdAPA0hsPhcJgdAgDwq4SEhJs6NTQ+Pt6FaQAAN+utt97S7NmzFRAQoIYNG8rX17fUnFWrVjmlVnR09A1/zzAMQ6mpqU6pCwAAAM/RoUMHTZ8+XV26dJHD4VBkZKQef/xxjR07VrNnz9aePXu0bt06l9QODg7WkiVLFBoaqqCgIC1fvlyhoaGSpNTUVM2aNUtpaWkuqQ3v17VrV3Xo0EFTpkwpNfbSSy9p586dSklJMSEZAAAAAABA2cNJogDgQdidBABl2/Lly9W/f39NnjxZ5cqVc2mtzp07X7dJ9Ntvv9W//vWvm9qAAAAAgLLjwoULqlGjhiTpwIEDstls6tWrl6RfNxW98847LqtdtWpVFRQUSJLq1q2rI0eOFDeJ2u122Ww2l9WG9/vxxx/VqVOnK47df//9Wr16tZsTAQAAAAAAlF00iQIAAABOkpubq86dO7u8QVTSFU/U+c2hQ4e0aNEiff7552rUqJGefvppl+cBANy8y5cv691339VXX32l06dP67nnnlPjxo21efNm3XnnnWratKnZEQF4uFq1aunIkSO699579dFHH+m2225Tw4YNJf363vQ/r89ztlatWunbb7/Vfffdp+joaC1atEgOh0M+Pj5atmyZ2rRp47La8H61a9fW3r17FRERUWps3759ql27tgmpAAAAAAAAyiaaRAEAAAAn6dq1qz7++GOFh4ebUv+rr77SokWL9NFHH6lx48Z6+eWX1aNHD7c0rQIAbs6JEyf05JNPymaz6a677lJGRoZ+/vlnSVJ6erp27typ2bNnm5wSgKd76KGHNHfuXO3evVsff/yxnnrqqeKxr7/+WrfffrvLag8bNkwnT56UJI0ZM0aZmZmaNWuWioqK1Lp1az3//PMuqw3v16tXLyUlJamgoEAPPfSQAgIClJ2drS1btujNN9/UqFGjzI4IAAAAAABQZhgOh8NhdggAAADAGxQUFGjKlCkqKipSeHi4/Pz8Ss154IEHnF533759SkxM1CeffKJmzZppxIgR6tq1K9fMA4AHGzZsmLKzs7V06VL5+fmpVatWWrdunYKCgrR582bNmzdPqampZscE4OEKCwu1ZMkSHThwQHfddZdGjBghX19fSdKoUaPUrl07xcXFuS1PQUGBCgoKVLVqVbfVhHdyOByaM2eO3n77bdnt9uLnFotFAwYM0IQJE0xMBwAAAAAAULbQJAoAAAA4yTfffKNRo0YpMzPziuOGYejQoUNOq5eenq6kpCR9+umnxU0BXbp0cdrXBwC4TnBwsF577TVFR0fLbrcrKCiouEk0PT1dTz31lL788kuzYwIo406cOFF8/TxQFtlsNu3fv18XLlxQ9erVdffdd6tGjRpmxwIAAAAAAChTuG4eAAAAcJLJkyercuXKWrJkiRo3blx8ipMrDBgwQHv27NHdd9+tpUuXKioqymW1AADOZ7FYdLV9u+fOnVPlypXdnAiAt/jtSu6NGzfqyy+/dOompd/bt2+fUlJSdOrUKeXn55cYMwxDixcvdllt3Bpq1KjBzzoAAAAAAAB/Ek2iAAAAgJMcPXpUCQkJ6tixo8trpaenS5IOHz6ssWPHXnOuYRjKyMhweSYAwI0LCQnRihUr1LFjR5UrV07Sr6/XDodDa9euVXh4uMkJAZQlubm52r59u6xWq3bv3i273a7AwEBNmjTJZTXfeustzZ49WwEBAWrYsKFLN0jh1rBt2zaFhYXJz89P27Ztu+ZcwzBUvXp1tWjRQv7+/u4JCAAAAAAAUEbRJAoAAAA4SWBgoM6fP++WWvHx8W6pAwBwjWeffVZ9+vRR9+7dFR0dLcMw9I9//EPfffed/v3vf+udd94xOyIAD2e327Vz505t3LhRaWlpysvLU61atWS32/Xaa6+pW7duLq2/fPly9e/fX5MnTy5udgf+jDFjxmjt2rW6++67NWbMmBv6fypWrKgXXnhBPXr0cHE6AAAAAACAsstwXO1uMwAAAAA35dChQ5o4caLGjx+vsLAw+fiwJwsAcHUnTpxQYmKiPvnkE+Xk5Kh69eoKDw/XmDFj1KhRI7PjAfBQGRkZslqtSklJkc1mk7+/vx588EH16NFDzZs3V2hoqFatWqWQkBCX5mjfvr0WLlzIycdwmszMTNWuXVvly5dXZmbmdef//PPPSk5O1ueff67U1FQ3JAQAAAAAACibaBIFAAAAnCQ4OFiFhYUqLCxUuXLlVKFChRLjXPsOAACAP6tly5YyDEOhoaEaPHiwIiMjizcn/fTTTwoJCXFLk+j06dNVuXJlTZgwwaV1gGs5dOiQpkyZovfee8/sKAAAAAAAAB6Lo40AAAAAJ4mLi5NhGGbHAACUAQMHDtT06dPVtGnTUmPHjh3T9OnTtXLlShOSAfB0LVq00OHDh5Weni6LxSKbzaaYmBhVrVrVrTmmTJmiKVOm6L/+678UHh4uPz+/UnMeeOABt2aCd8rNzVV+fn6p5/7+/goMDKRBFAAAAAAA4DpoEgUAAACcZPTo0WZHAACUEZ9//rl+/vnnK45dunRJe/bscXMiAGXFhg0bdOTIEW3YsEGbNm3SxIkTVbFiRUVFRalTp05u27T0/fff64svvlBmZqY2bdpUatwwDB06dMgtWeB9HA6HkpKStGbNGp09e/aKc/j7BQAAAAAAcGNoEgUAAAAAAPAge/fuVc2aNc2OAcCDNWvWTOPGjdO4ceOUkZEhq9WqrVu3auvWrTIMo/gkYldeOT958mRVrlxZS5YsUePGjeXr6+uyWrj1JCcnKzk5WU899ZTmz5+vESNGyGKxaNOmTbp8+bKGDx9udkQAAAAAAIAyw3A4HA6zQwAAAADeYODAgdedw9XBAHDrWrp0qZYuXSrp16tzK1asWOrEv4KCAtntdvXt21fTpk0zIyaAMsput2vXrl2yWq3asWOHcnNz1aBBA+3YscMl9e655x4lJCSoY8eOLvn6uLV1795dvXv3Vr9+/RQUFKR169YpKChIRUVFGjFihO68806NGzfO7JgAAAAAAABlAieJAgAAAE5StWrVUs0+Fy9e1MGDB+Xn56dWrVqZlAwA4AmCg4MVFxcnh8OhRYsWqXv37qpXr16JOb6+vmratKk6depkUkoAZZXFYlFUVJSioqKUl5en1NRUWa1Wl9ULDAzU+fPnXfb1cWvLzMxUYGCgLBaLfHx8dPHiRUlSuXLl1LdvX02ZMoUmUQAAAAAAgBtEkygAAADgJElJSVd8np2drZEjR6pbt25uTgQA8CTt27dX+/btJUmGYejxxx9X3bp1TU4FwBtVrFhRsbGxio2NdVmN6dOna+LEiapdu7bCwsLk48OvmuE8/v7++uWXXyRJDRo00Ndff63w8HBJks1mU15enpnxAAAAAAAAyhSumwcAAADcIDU1VXPnztXWrVvNjgIAAAD8acHBwSosLFRhYaHKlSunChUqlBg3DEMZGRkmpUNZN27cODVp0kTx8fH67//+b61YsUJPPPGEfHx8tHbtWrVv314JCQlmxwQAAAAAACgT2N4NAAAAuIHdbtfZs2fNjgEA8BBFRUV65513tHXrVp0+fVr5+fklxg3DUGpqqknpAOD64uLiZBiG2THgpeLj45WVlSVJGj58uC5evCir1ar8/HxFRERo2rRpJicEAAAAAAAoOzhJFAAAAHCSgwcPlnp2+fJlHT16VIsWLVKjRo2UnJzs/mAAAI8zZ84crVixQiEhIWrWrJl8fX1LzZk8ebIJyQAAAAAAAAAAgDehSRQAAABwkpYtW5Y6Tem3t9v33HOPXn31VTVs2NCMaAAAD9OhQwf16dNHo0aNMjsKAAAAAAAAAADwYlw3DwAAADjJypUrSz2rUKGC6tWrp7p165qQCADgqQoKCtS2bVuzYwDAn7Jp0yalpKTo1KlTys/PLzW+ceNGE1KhrJo0adINzzUMQ7NmzXJhGgAAAAAAAO9BkygAAADgJO3btzc7AgCgjOjRo4fS0tIUHh5udhQA+EPmzZunZcuWKSgoSI0bN1b58uXNjoQybv369apSpYoaNWqk612A9vsbHAAAAAAAAHB1NIkCAAAAAAC42T333KMFCxbo/PnzioiIkJ+fX6k5DzzwgAnJAODGrFu3TmPGjNHIkSPNjgIv0aZNG3355Zey2+2KjY1V9+7dddttt5kdCwAAAAAAoMwzHNfbkgsAAADgqoKDg2/4FBvDMJSRkeHiRACAsqBly5bXHDcMQ4cOHXJTGgC4eZGRkXrllVcUGRlpdhR4kZMnT2rTpk2yWq06fPiw2rRpo9jYWHXt2lU1a9Y0Ox4AAAAAAECZRJMoAAAA8CckJCSUaBK12+1avHix/vrXv6pOnTql5sfHx7szHgDAQ2VmZl53DqenAfBk8+fP15kzZzR79myzo8BLHTlyRFarVVu2bFFmZqbCwsI0YMAARUVFmR0NAAAAAACgTKFJFAAAAHAiu92uoKAgrVu3TkFBQWbHAQAAAFzC4XDopZde0oEDBxQeHi4/P78S44Zh6MknnzQnHLxKfn6+Fi5cqOTkZEVHRysxMdHsSAAAAAAAAGWKj9kBAAAAAAAAAABly2effab169fr559/1r59+0qN0ySKP8Nut2vXrl3avHmzduzYIYvFol69eqlXr15mRwMAAAAAAChzaBIFAAAAAABwg+DgYBmGcUNzDcNQRkaGixMBwB83c+ZMtWrVSlOnTlXjxo3l6+trdiR4gfT0dFmtVqWkpKigoECdO3fWq6++qg4dOsjHh48zAAAAAAAA/gh+qwIAAAAAAOAGcXFxN9wkCgCe7vTp05o2bZqaN29udhR4iaioKNlsNnXs2FEzZsxQdHS0KlSoYHYsAAAAAACAMo8mUQAAAMAFaAICAPze6NGjzY4AAE7Trl07HTt2TJGRkWZHgZfIysqSj4+PPvnkE+3evfuaczlxGwAAAAAA4MbRJAoAAAD8CVe7Orhfv36lnvNBJgAAALzF2LFjNXHiRPn6+ioiIkLVqlUrNcff39/9wVBmxcfHmx0BAAAAAADAKxkOh8NhdggAAACgrEpISLipU0P54BMAAADeoGXLlsV/vtr74UOHDrkrDgAAAAAAAICroEkUAAAAAAAAAHBT3nvvvetulnr00UfdlAYAAAAAAADA1dAkCgAAAAAAAAAAAAAAAAAA4IXKmR0AAAAAAAAAAAAAAAAAAAAAzudjdgAAAAAAAAAAQNmTnp6uNWvW6Pjx48rPzy81vnHjRhNSAQAAAAAAAPhPnCQKAAAAAAAAALgpO3fu1KBBg2Sz2XTgwAHVr19fNWrU0LFjx5Sbm6tWrVqZHREAAAAAAACAaBIFAAAAAAAAANykhIQEDRo0SMuWLZMkPfPMM1q5cqW2bt0qHx8fhYWFmZwQAAAAAAAAgESTKAAAAAAAAADgJh09elQdO3ZUuXLlZBiGcnNzJUm33XabRo8ercWLF5ucEAAAAAAAAIBEkygAAAAAAAAA4CZVqFBBRUVFMgxDtWvX1g8//FA8VqVKFZ0+fdrEdAAAAAAAAAB+42N2AAAAAAAAAABA2dKyZUsdO3ZMkZGRCg8P15IlS1SjRg35+PhowYIFatGihdkRAQAAAAAAAEgyHA6Hw+wQAAAAAAAAAICy46OPPtKPP/6ofv36KSsrS8OHD9ehQ4ckSfXq1VNiYqJatWplckoAAAAAAAAANIkCAAAAAAAAAP4Uh8Ohf//738rLy1OTJk1Uvnx5syMBAAAAAAAAEE2iAAAAAAAAAAAAAAAAAAAAXsnH7AAAAAAAAAAAAM/ncDi0e/duBQQEqGXLlsXPXnrppRLzqlSporFjx5oREQAAAAAAAMDv0CQKAAAAAAAAALiuzZs36+9//7tWr15d/KyoqEhvv/22ateuLV9fX0nS+fPndeedd6pbt25mRQUAAAAAAADwf8qZHQAAAAAAAAAA4Pk2bNigbt26qXXr1qXGlixZorS0NKWlpal///764IMPTEgIAAAAAAAA4PdoEgUAAAAAAAAAXNeBAwcUExNz3XkhISE6ePCgGxIBAAAAAAAAuB6aRAEAAAAAAAAA13XhwgUFBASUeGaxWLRw4UI1atSo+FnVqlWVk5Pj5nQAAAAAAAAArsTH7AAAAAAAAAAAAM9XrVo1nT17ttTzBx98sMR/nz17VtWqVXNXLAAAAAAAAADXwEmiAAAAAAAAAIDrat26tbZs2XLdeVu2bNHdd9/thkQAAAAAAAAArocmUQAAAAAAAADAdfXr10/btm3TokWLVFRUVGrc4XAoKSlJ27dvV9++fU1ICAAAAAAAAOD3DIfD4TA7BAAAAAAAAADA882bN0/Lli1TnTp1FBYWpvr160uSsrKy9Omnn+rMmTMaOnSoxo0bZ3JSAAAAAAAAABJNogAAAAAAAACAm/C///u/WrFihfbu3auCggJJUvny5dW2bVsNHjxYUVFRJicEAAAAAAAA8BuaRAEAAAAAAAAAN81utysnJ0eS5O/vL4vFYm4gAAAAAAAAAKXQJAoAAAAAAAAAAAAAAAAAAOCFypkdAAAAAAAAAAAAAAAAAAAAAM5HkygAAAAAAAAAAAAAAAAAAIAXokkUAAAAAAAAAAAAAAAAAADAC9EkCgAAAAAAAAAAAAAAAAAA4IVoEgUAAAAAAAAAAAAAAAAAAPBCNIkCAAAAAAAAAAAAAAAAAAB4IZpEAQAAAAAAAAAAAAAAAAAAvBBNogAAAAAAAAAAAAAAAAAAAF7o/wFaUIMSlmB+1gAAAABJRU5ErkJggg==\n"},"metadata":{}},{"output_type":"stream","name":"stderr","text":["INFO:root:Running Univariate Analyses...\n","INFO:root:Plotting top significant 40 features.\n","INFO:root:###################################################\n","INFO:root:Significant Univariate Associations:\n","INFO:root:Alkaline phosphatase (U/L): (p-val = 8.425494437393163e-07)\n","INFO:root:Performance Status*: (p-val = 1.8787043290235831e-06)\n","INFO:root:Alpha-Fetoprotein (ng/mL): (p-val = 3.7632257667465082e-06)\n","INFO:root:Haemoglobin (g/dL): (p-val = 6.806983230077955e-05)\n","INFO:root:Albumin (mg/dL): (p-val = 0.0002097286566980117)\n","INFO:root:Symptoms : (p-val = 0.00033485297415731147)\n","INFO:root:Ascites degree*: (p-val = 0.0010580963945994142)\n","INFO:root:Direct Bilirubin (mg/dL): (p-val = 0.0013544764761447027)\n","INFO:root:Aspartate transaminase (U/L): (p-val = 0.0016188344745582482)\n","INFO:root:Ferritin (ng/mL): (p-val = 0.0019988859548087426)\n","INFO:root:Liver Metastasis: (p-val = 0.002993588224869906)\n","INFO:root:Iron: (p-val = 0.009131914019954513)\n","INFO:root:Portal Vein Thrombosis: (p-val = 0.01174304115542567)\n","INFO:root:Sim_Text_Cat_3_Category 2: (p-val = 0.018523191730482835)\n","INFO:root:Gamma glutamyl transferase (U/L): (p-val = 0.019120768577902517)\n","INFO:root:Sim_Cat_4_3: (p-val = 0.01961182235282516)\n","INFO:root:Major dimension of nodule (cm): (p-val = 0.028160240930633438)\n","INFO:root:International Normalised Ratio*: (p-val = 0.03298377968646775)\n","INFO:root:Total Bilirubin(mg/dL): (p-val = 0.033298074732187495)\n","INFO:root:Sim_Cat_4_4: (p-val = 0.0477018318461524)\n","INFO:root:miss_Sim_Miss_0.6: (p-val = 0.05829721364630114)\n","INFO:root:Sim_Text_Cat_4_Category 3: (p-val = 0.07394940686287883)\n","INFO:root:Creatinine (mg/dL): (p-val = 0.09698449209346588)\n","INFO:root:Platelets: (p-val = 0.12125234491493234)\n","INFO:root:Sim_Cat_3_3: (p-val = 0.1362746461432275)\n","INFO:root:Leukocytes(G/L): (p-val = 0.14046840937798746)\n","INFO:root:Sim_Cat_3_2: (p-val = 0.14781154042116523)\n","INFO:root:Total Proteins (g/dL): (p-val = 0.15142678135056728)\n","INFO:root:Sim_Text_Cat_3_Category 3: (p-val = 0.17149034214215209)\n","INFO:root:Encephalopathy degree*: (p-val = 0.18748076972244587)\n","INFO:root:Diabetes: (p-val = 0.20717818281920294)\n","INFO:root:Hepatitis C Virus Antibody: (p-val = 0.2152844001545551)\n","INFO:root:Number of Nodules: (p-val = 0.22760238651984677)\n","INFO:root:Sim_Text_Cat_4_Category 1: (p-val = 0.23188811916693652)\n","INFO:root:Sim_Cor_1.0_B: (p-val = 0.260472440507848)\n","INFO:root:Sim_Text_Cat_3_Category 1: (p-val = 0.3253537508910975)\n","INFO:root:Oxygen Saturation (%): (p-val = 0.33185961027987754)\n","INFO:root:Endemic Countries: (p-val = 0.3741454960813042)\n","INFO:root:Chronic Renal Insufficiency: (p-val = 0.3855402814015594)\n","INFO:root:Packs of cigarets per year: (p-val = 0.393996345956239)\n","INFO:root:Generating Univariate Analysis Plots...\n","INFO:root:Loading Dataset: hcc-data_example\n","INFO:root:Initial Data Counts: ----------------\n","INFO:root:Instance Count = 165\n","INFO:root:Feature Count = 49\n","INFO:root: Categorical = 29\n","INFO:root: Quantitative = 20\n","INFO:root:Missing Count = 826\n","INFO:root: Missing Percent = 0.10216450216450217\n","INFO:root:Class Counts: ----------------\n","INFO:root:Class Count Information\n","INFO:root:\n"," Class Instances\n","0 0 102\n","1 1 63\n","INFO:root:Identifying Feature Types...\n","INFO:root:No textual categorical features, skipping label encoding\n","INFO:root:Running Feature Engineering\n","INFO:root:No Features with high missingness found\n","INFO:root:Not removing any features due to high missingness\n","INFO:root:No non-binary categorical features, skipping categorical encoding\n","INFO:root:Top 10 Correlated Features\n","INFO:root:\n"," Removed_Feature Correlated_Feature Correlation\n","1801 Total Bilirubin(mg/dL) Direct Bilirubin (mg/dL) 0.978124\n","2291 Iron Oxygen Saturation (%) 0.782957\n","1843 Alanine transaminase (U/L) Aspartate transaminase (U/L) 0.727780\n","122 Alcohol Grams of Alcohol per day 0.712681\n","844 Esophageal Varices Splenomegaly 0.629077\n","845 Esophageal Varices Portal Hypertension 0.624371\n","894 Splenomegaly Portal Hypertension 0.617743\n","1943 Gamma glutamyl transferase (U/L) Alkaline phosphatase (U/L) 0.567314\n","1607 Mean Corpuscular Volume Oxygen Saturation (%) 0.545314\n","2341 Oxygen Saturation (%) Ferritin (ng/mL) 0.479226\n","INFO:root:No Features with correlation higher that parameter\n","INFO:root:Running Basic Exploratory Analysis...\n","INFO:root:Processed Data Counts: ----------------\n","INFO:root:Instance Count = 165\n","INFO:root:Feature Count = 49\n","INFO:root: Categorical = 22\n","INFO:root: Quantitative = 27\n","INFO:root:Missing Count = 826\n","INFO:root: Missing Percent = 0.10216450216450217\n","INFO:root:Class Counts: ----------------\n","INFO:root:Class Count Information\n","INFO:root:\n"," Class Instances\n","0 0 102\n","1 1 63\n","INFO:root:Original Categorical Features: ['Gender', 'Alcohol', 'Hepatitis B Surface Antigen', 'Hepatitis B e Antigen', 'Hepatitis B Core Antibody', 'Hepatitis C Virus Antibody', 'Cirrhosis', 'Endemic Countries', 'Smoking', 'Diabetes', 'Obesity', 'Hemochromatosis', 'Arterial Hypertension', 'Chronic Renal Insufficiency', 'Human Immunodeficiency Virus', 'Nonalcoholic Steatohepatitis', 'Esophageal Varices', 'Splenomegaly', 'Portal Hypertension', 'Portal Vein Thrombosis', 'Liver Metastasis', 'Radiological Hallmark']\n","INFO:root:Engineered Features: []\n","INFO:root:One Hot Features: []\n","INFO:root:Final List of Features:\n","INFO:root:['Gender', 'Symptoms ', 'Alcohol', 'Hepatitis B Surface Antigen', 'Hepatitis B e Antigen', 'Hepatitis B Core Antibody', 'Hepatitis C Virus Antibody', 'Cirrhosis', 'Endemic Countries', 'Smoking', 'Diabetes', 'Obesity', 'Hemochromatosis', 'Arterial Hypertension', 'Chronic Renal Insufficiency', 'Human Immunodeficiency Virus', 'Nonalcoholic Steatohepatitis', 'Esophageal Varices', 'Splenomegaly', 'Portal Hypertension', 'Portal Vein Thrombosis', 'Liver Metastasis', 'Radiological Hallmark', 'Age at diagnosis', 'Grams of Alcohol per day', 'Packs of cigarets per year', 'Performance Status*', 'Encephalopathy degree*', 'Ascites degree*', 'International Normalised Ratio*', 'Alpha-Fetoprotein (ng/mL)', 'Haemoglobin (g/dL)', 'Mean Corpuscular Volume', 'Leukocytes(G/L)', 'Platelets', 'Albumin (mg/dL)', 'Total Bilirubin(mg/dL)', 'Alanine transaminase (U/L)', 'Aspartate transaminase (U/L)', 'Gamma glutamyl transferase (U/L)', 'Alkaline phosphatase (U/L)', 'Total Proteins (g/dL)', 'Creatinine (mg/dL)', 'Number of Nodules', 'Major dimension of nodule (cm)', 'Direct Bilirubin (mg/dL)', 'Iron', 'Oxygen Saturation (%)', 'Ferritin (ng/mL)']\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stderr","text":["INFO:root:Generating Feature Correlation Heatmap...\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stderr","text":["INFO:root:Running Univariate Analyses...\n","INFO:root:Plotting top significant 40 features.\n","INFO:root:###################################################\n","INFO:root:Significant Univariate Associations:\n","INFO:root:Alkaline phosphatase (U/L): (p-val = 8.425494437393163e-07)\n","INFO:root:Performance Status*: (p-val = 1.8787043290235831e-06)\n","INFO:root:Alpha-Fetoprotein (ng/mL): (p-val = 3.7632257667465082e-06)\n","INFO:root:Haemoglobin (g/dL): (p-val = 6.806983230077955e-05)\n","INFO:root:Albumin (mg/dL): (p-val = 0.0002097286566980117)\n","INFO:root:Symptoms : (p-val = 0.00033485297415731147)\n","INFO:root:Ascites degree*: (p-val = 0.0010580963945994142)\n","INFO:root:Direct Bilirubin (mg/dL): (p-val = 0.0013544764761447027)\n","INFO:root:Aspartate transaminase (U/L): (p-val = 0.0016188344745582482)\n","INFO:root:Ferritin (ng/mL): (p-val = 0.0019988859548087426)\n","INFO:root:Liver Metastasis: (p-val = 0.002993588224869906)\n","INFO:root:Iron: (p-val = 0.009131914019954513)\n","INFO:root:Portal Vein Thrombosis: (p-val = 0.01174304115542567)\n","INFO:root:Gamma glutamyl transferase (U/L): (p-val = 0.019120768577902517)\n","INFO:root:Major dimension of nodule (cm): (p-val = 0.028160240930633438)\n","INFO:root:International Normalised Ratio*: (p-val = 0.03298377968646775)\n","INFO:root:Total Bilirubin(mg/dL): (p-val = 0.033298074732187495)\n","INFO:root:Age at diagnosis: (p-val = 0.03568323751208702)\n","INFO:root:Creatinine (mg/dL): (p-val = 0.09698449209346588)\n","INFO:root:Platelets: (p-val = 0.12125234491493234)\n","INFO:root:Leukocytes(G/L): (p-val = 0.14046840937798746)\n","INFO:root:Total Proteins (g/dL): (p-val = 0.15142678135056728)\n","INFO:root:Encephalopathy degree*: (p-val = 0.18748076972244587)\n","INFO:root:Diabetes: (p-val = 0.20717818281920294)\n","INFO:root:Hepatitis C Virus Antibody: (p-val = 0.2152844001545551)\n","INFO:root:Number of Nodules: (p-val = 0.22760238651984677)\n","INFO:root:Oxygen Saturation (%): (p-val = 0.33185961027987754)\n","INFO:root:Endemic Countries: (p-val = 0.3741454960813042)\n","INFO:root:Chronic Renal Insufficiency: (p-val = 0.3855402814015594)\n","INFO:root:Packs of cigarets per year: (p-val = 0.393996345956239)\n","INFO:root:Grams of Alcohol per day: (p-val = 0.4403757689353228)\n","INFO:root:Mean Corpuscular Volume: (p-val = 0.44152541128851797)\n","INFO:root:Arterial Hypertension: (p-val = 0.4846830135726744)\n","INFO:root:Smoking: (p-val = 0.4866012581237731)\n","INFO:root:Alanine transaminase (U/L): (p-val = 0.6640569092898103)\n","INFO:root:Hepatitis B Core Antibody: (p-val = 0.6988319455779853)\n","INFO:root:Esophageal Varices: (p-val = 0.7160820783452397)\n","INFO:root:Nonalcoholic Steatohepatitis: (p-val = 0.7260660722826798)\n","INFO:root:Portal Hypertension: (p-val = 0.7348638671146509)\n","INFO:root:Alcohol: (p-val = 0.7374939625243255)\n","INFO:root:Generating Univariate Analysis Plots...\n"]}],"source":["from streamline.runners.dataprocess_runner import DataProcessRunner\n","dpr = DataProcessRunner(data_path, output_path, experiment_name,\n"," exploration_list=exploration_list, plot_list=plot_list,\n"," class_label=class_label, instance_label=instance_label,\n"," match_label=match_label, n_splits=n_splits,\n"," partition_method=partition_method,\n"," ignore_features=ignore_features,\n"," categorical_features=categorical_feature_headers,\n"," top_features=top_features,\n"," categorical_cutoff=categorical_cutoff, sig_cutoff=sig_cutoff,\n"," featureeng_missingness=featureeng_missingness,\n"," cleaning_missingness=cleaning_missingness,\n"," correlation_removal_threshold=correlation_removal_threshold,\n"," random_state=random_state, show_plots=True)\n","dpr.run(run_parallel=False)"]},{"cell_type":"markdown","metadata":{"id":"BJBtvpO-CxMU"},"source":["## Phase 2: Scaling and Imputation\n","After cell runs, you will see:\n","* No output other than code progress updates"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":12676,"status":"ok","timestamp":1685752488622,"user":{"displayName":"ryan urbanowicz","userId":"09525282221743790591"},"user_tz":420},"id":"xRPCoPEG-FZD","outputId":"640c399a-05f6-49d3-dfe4-1a0404bd7b10"},"outputs":[{"output_type":"stream","name":"stderr","text":["INFO:root:Preparing Train and Test for: hcc-data_example_custom_CV_2\n","INFO:root:Imputing Missing Values...\n","INFO:root:Scaling Data Values...\n","INFO:root:Saving Processed Train and Test Data...\n","INFO:root:hcc-data_example_custom Phase 2 complete\n","INFO:root:Preparing Train and Test for: hcc-data_example_custom_CV_0\n","INFO:root:Imputing Missing Values...\n","INFO:root:Scaling Data Values...\n","INFO:root:Saving Processed Train and Test Data...\n","INFO:root:hcc-data_example_custom Phase 2 complete\n","INFO:root:Preparing Train and Test for: hcc-data_example_custom_CV_1\n","INFO:root:Imputing Missing Values...\n","INFO:root:Scaling Data Values...\n","INFO:root:Saving Processed Train and Test Data...\n","INFO:root:hcc-data_example_custom Phase 2 complete\n","INFO:root:Preparing Train and Test for: hcc-data_example_CV_0\n","INFO:root:Imputing Missing Values...\n","INFO:root:Scaling Data Values...\n","INFO:root:Saving Processed Train and Test Data...\n","INFO:root:hcc-data_example Phase 2 complete\n","INFO:root:Preparing Train and Test for: hcc-data_example_CV_2\n","INFO:root:Imputing Missing Values...\n","INFO:root:Scaling Data Values...\n","INFO:root:Saving Processed Train and Test Data...\n","INFO:root:hcc-data_example Phase 2 complete\n","INFO:root:Preparing Train and Test for: hcc-data_example_CV_1\n","INFO:root:Imputing Missing Values...\n","INFO:root:Scaling Data Values...\n","INFO:root:Saving Processed Train and Test Data...\n","INFO:root:hcc-data_example Phase 2 complete\n"]}],"source":["from streamline.runners.imputation_runner import ImputationRunner\n","ir = ImputationRunner(output_path, experiment_name,\n"," scale_data=scale_data, impute_data=impute_data,\n"," multi_impute=multi_impute, overwrite_cv=overwrite_cv,\n"," class_label=class_label, instance_label=instance_label,\n"," random_state=random_state)\n","ir.run(run_parallel=False)"]},{"cell_type":"markdown","metadata":{"id":"kuAxzygTETa2"},"source":["## Phase 3: Feature Importance Evaluation\n","After cell runs, you will see:\n","* No output other than code progress updates"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"2EF0mLemYKom"},"outputs":[],"source":["feat_algorithms = []\n","if do_mutual_info:\n"," feat_algorithms.append(\"MI\")\n","if do_multisurf:\n"," feat_algorithms.append(\"MS\")"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":4957,"status":"ok","timestamp":1685752493571,"user":{"displayName":"ryan urbanowicz","userId":"09525282221743790591"},"user_tz":420},"id":"u1X2jWFXETAw","outputId":"760158c6-1b05-43c6-e499-99524d919291"},"outputs":[{"output_type":"stream","name":"stderr","text":["INFO:root:Loading Dataset: hcc-data_example_custom_CV_2_Train\n","INFO:root:Prepared Train and Test for: hcc-data_example_custom_CV_2\n","INFO:root:Running Mutual Information...\n","INFO:root:Sort and pickle feature importance scores...\n","INFO:root:hcc-data_example_custom CV2 phase 3 mutual_information evaluation complete\n","INFO:root:Loading Dataset: hcc-data_example_custom_CV_0_Train\n","INFO:root:Prepared Train and Test for: hcc-data_example_custom_CV_0\n","INFO:root:Running Mutual Information...\n","INFO:root:Sort and pickle feature importance scores...\n","INFO:root:hcc-data_example_custom CV0 phase 3 mutual_information evaluation complete\n","INFO:root:Loading Dataset: hcc-data_example_custom_CV_1_Train\n","INFO:root:Prepared Train and Test for: hcc-data_example_custom_CV_1\n","INFO:root:Running Mutual Information...\n","INFO:root:Sort and pickle feature importance scores...\n","INFO:root:hcc-data_example_custom CV1 phase 3 mutual_information evaluation complete\n","INFO:root:Loading Dataset: hcc-data_example_custom_CV_2_Train\n","INFO:root:Prepared Train and Test for: hcc-data_example_custom_CV_2\n","INFO:root:Running MultiSURF...\n","INFO:root:Sort and pickle feature importance scores...\n","INFO:root:hcc-data_example_custom CV2 phase 3 multisurf evaluation complete\n","INFO:root:Loading Dataset: hcc-data_example_custom_CV_0_Train\n","INFO:root:Prepared Train and Test for: hcc-data_example_custom_CV_0\n","INFO:root:Running MultiSURF...\n","INFO:root:Sort and pickle feature importance scores...\n","INFO:root:hcc-data_example_custom CV0 phase 3 multisurf evaluation complete\n","INFO:root:Loading Dataset: hcc-data_example_custom_CV_1_Train\n","INFO:root:Prepared Train and Test for: hcc-data_example_custom_CV_1\n","INFO:root:Running MultiSURF...\n","INFO:root:Sort and pickle feature importance scores...\n","INFO:root:hcc-data_example_custom CV1 phase 3 multisurf evaluation complete\n","INFO:root:Loading Dataset: hcc-data_example_CV_0_Train\n","INFO:root:Prepared Train and Test for: hcc-data_example_CV_0\n","INFO:root:Running Mutual Information...\n","INFO:root:Sort and pickle feature importance scores...\n","INFO:root:hcc-data_example CV0 phase 3 mutual_information evaluation complete\n","INFO:root:Loading Dataset: hcc-data_example_CV_2_Train\n","INFO:root:Prepared Train and Test for: hcc-data_example_CV_2\n","INFO:root:Running Mutual Information...\n","INFO:root:Sort and pickle feature importance scores...\n","INFO:root:hcc-data_example CV2 phase 3 mutual_information evaluation complete\n","INFO:root:Loading Dataset: hcc-data_example_CV_1_Train\n","INFO:root:Prepared Train and Test for: hcc-data_example_CV_1\n","INFO:root:Running Mutual Information...\n","INFO:root:Sort and pickle feature importance scores...\n","INFO:root:hcc-data_example CV1 phase 3 mutual_information evaluation complete\n","INFO:root:Loading Dataset: hcc-data_example_CV_0_Train\n","INFO:root:Prepared Train and Test for: hcc-data_example_CV_0\n","INFO:root:Running MultiSURF...\n","INFO:root:Sort and pickle feature importance scores...\n","INFO:root:hcc-data_example CV0 phase 3 multisurf evaluation complete\n","INFO:root:Loading Dataset: hcc-data_example_CV_2_Train\n","INFO:root:Prepared Train and Test for: hcc-data_example_CV_2\n","INFO:root:Running MultiSURF...\n","INFO:root:Sort and pickle feature importance scores...\n","INFO:root:hcc-data_example CV2 phase 3 multisurf evaluation complete\n","INFO:root:Loading Dataset: hcc-data_example_CV_1_Train\n","INFO:root:Prepared Train and Test for: hcc-data_example_CV_1\n","INFO:root:Running MultiSURF...\n","INFO:root:Sort and pickle feature importance scores...\n","INFO:root:hcc-data_example CV1 phase 3 multisurf evaluation complete\n"]}],"source":["from streamline.runners.feature_runner import FeatureImportanceRunner\n","f_imp = FeatureImportanceRunner(output_path, experiment_name,\n"," class_label=class_label,\n"," instance_label=instance_label,\n"," instance_subset=instance_subset,\n"," algorithms=feat_algorithms,\n"," use_turf=use_TURF, turf_pct=TURF_pct,\n"," random_state=random_state)\n","f_imp.run(run_parallel=False)"]},{"cell_type":"markdown","metadata":{"id":"2udkSXOYEx21"},"source":["## Phase 4: Feature Selection\n","After cell runs, for each target dataset and each feature importance algorithm you will see:\n","* Top feature importance scores\n","* A barplot of top feature imporance score ranking"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"executionInfo":{"elapsed":6984,"status":"ok","timestamp":1685752500545,"user":{"displayName":"ryan urbanowicz","userId":"09525282221743790591"},"user_tz":420},"id":"Nip62hw-EZ5K","outputId":"2d53ff77-b92b-4f42-ba35-99a5a7f1f060"},"outputs":[{"output_type":"stream","name":"stderr","text":["INFO:root:Plotting Feature Importance Scores...\n","INFO:root: Feature Importance\n","28 Alpha-Fetoprotein (ng/mL) 0.122190\n","24 Performance Status* 0.102941\n","44 Iron 0.080971\n","38 Alkaline phosphatase (U/L) 0.078554\n","42 Major dimension of nodule (cm) 0.075015\n","46 Ferritin (ng/mL) 0.071803\n","0 Symptoms 0.070594\n","33 Albumin (mg/dL) 0.065591\n","29 Haemoglobin (g/dL) 0.059914\n","4 Hepatitis B Core Antibody 0.055815\n","INFO:root:Saved Feature Importance Plots at\n","INFO:root:/content/DemoOutput/demo_experiment/hcc-data_example_custom/feature_selection/mutual_information/TopAverageScores.png\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stderr","text":["INFO:root: Feature Importance\n","29 Haemoglobin (g/dL) 0.123375\n","38 Alkaline phosphatase (U/L) 0.089321\n","24 Performance Status* 0.074267\n","0 Symptoms 0.060058\n","20 Liver Metastasis 0.055325\n","26 Ascites degree* 0.053220\n","37 Gamma glutamyl transferase (U/L) 0.045130\n","45 Oxygen Saturation (%) 0.042915\n","36 Aspartate transaminase (U/L) 0.039828\n","33 Albumin (mg/dL) 0.036499\n","INFO:root:Saved Feature Importance Plots at\n","INFO:root:/content/DemoOutput/demo_experiment/hcc-data_example_custom/feature_selection/multisurf/TopAverageScores.png\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stderr","text":["INFO:root:Applying collective feature selection...\n","INFO:root:hcc-data_example_custom Phase 4 Complete\n","INFO:root:Plotting Feature Importance Scores...\n","INFO:root: Feature Importance\n","30 Alpha-Fetoprotein (ng/mL) 0.122169\n","26 Performance Status* 0.121332\n","1 Symptoms 0.106487\n","40 Alkaline phosphatase (U/L) 0.076862\n","48 Ferritin (ng/mL) 0.069531\n","31 Haemoglobin (g/dL) 0.063325\n","23 Age at diagnosis 0.058108\n","44 Major dimension of nodule (cm) 0.055360\n","46 Iron 0.050169\n","35 Albumin (mg/dL) 0.046063\n","INFO:root:Saved Feature Importance Plots at\n","INFO:root:/content/DemoOutput/demo_experiment/hcc-data_example/feature_selection/mutual_information/TopAverageScores.png\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAAxQAAAP6CAYAAAAJzRtjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1QUZ9vA4R9LEZQmCIodjWxUQIpKFyUqFowlMVZs2Gvs3URjgr2BRmOvkVjfiBGTWNDXlteoUWNiEmOPKEoPorDs94eH/VwXdhELxNzXOR7ZmafNvSvOPc8zs0ZqtVqNEEIIIYQQQhSBorgHIIQQQgghhPjnkoRCCCGEEEIIUWSSUAghhBBCCCGKTBIKIYQQQgghRJFJQiGEEEIIIYQoMkkohBBCCCGEEEUmCYUQQgghhBCiyCShEEIIIYQQQhSZJBRCCCGEEEKIIpOEQgghRIl06tQplEolp06dKu6hFCgkJIQJEyZoXv8TxvxPER4eTnh4+Cvv58iRI7Rt2xY3NzeUSiVpaWmvvM/XRalUEhUVVdzDEP8CklAIIcQb6PLlywwfPpwmTZrg5uZGUFAQvXv3ZuPGjS+9r+XLl/P999+/9HYLa+fOnSiVSpRKJadPn9bZr1arCQ4ORqlUMmDAgGIY4esRHh6OUqmkefPm+e4/duyYJk5xcXFF6qO43+v8hISEFPl9TU5O5sMPP8Tc3Jxp06YxZ84cLCwsXvIIX634+PgSmTScPn2avn37EhQUhJubG40bN2bgwIHs2bOnuIcmXgFJKIQQ4g1z5swZ3nvvPX799Vc6duzItGnT6NixIwqFgg0bNrz0/lasWFEiTjJLlSpFbGyszvYffviBhIQEzMzMXvkYGjRowPnz52nQoMEr7ys/pUqV4vr165w/f15n3549eyhVqtQLtV9S3uuX5cKFC/z999+MGDGCjh070rZtW0xNTYt7WM8lPj6e6OjofPedP3+eQYMGveYRwb59++jevTsPHjygR48eTJ06lXfffZfU1FS++uqr1z4e8eqZFPcAhBBCvFzLly/HysqK7du3Y21trbXvwYMHL6UPtVrNo0ePMDc3fyntvQzBwcHExcUxZcoUTEz+/7+32NhY6tatS0pKyisfg0KheOGT9hdRtWpVcnJyiI2Nxd3dXbP90aNHfPfddzRu3Jj9+/cX2/hKmqSkJACsrKxeWpuZmZmULl36pbX3IorrsxgdHc1bb71FTEyMTiL/sn4HFUZJ/D31ppIZCiGEeMPcuHGDt956SyeZALC3t9d6nZOTw9KlS2natCmurq6EhISwYMECHj9+rFUub1nJ0aNH6dChA+7u7mzduhWlUklmZia7du3SLKd5+p6Cu3fvMnHiRPz9/XF1daV169Zs375dZ1wJCQkMHjwYDw8P/Pz8+Oyzz3TGYEjr1q1JSUnh2LFjmm2PHz9m//79tGnTJt86ubm5rFu3jtatW+Pm5oa/vz/Tpk0jNTVVq5xarWbZsmU0atSIevXqER4ezu+//67TXn73UJw+fZrhw4fTuHFjXF1dCQ4O5rPPPiMrK0ur7oQJE/D09OTu3bsMHjwYT09PfH19mT17NiqVqtBxCAsL45tvviE3N1ez7eDBg2RlZdGiRQud8hMmTCAkJERne1RUFEqlUvNa33td2DYAduzYQY8ePfDz88PV1ZVWrVqxZcuWQh+fIbdu3UKpVLJ69WpiYmI0n+333ntPa+YmPDyc8ePHA/D+++/rfHb37dun+az7+PgwZswY7t69q9VX3nt248YN+vXrh6enJ2PGjAGexGvGjBns27ePVq1a4e7uTqdOnbh8+TIAW7dupVmzZri5uREeHs6tW7e02i7M52bChAls3rxZ01/enzz53UNx6dIl+vbti5eXF56envTs2ZNz585plclbRvjjjz8SGRmJr68vHh4eDBkyRJOE6XPjxg3c3NzynRV89ndQbm4u69evp02bNri5ueHr60tERAQXLlzQlHnR31MAaWlpfPrppwQHB+Pq6kqzZs344osvtP6dAOzdu5cOHTrg6emJl5cXbdq0Yf369QaP+d9OZiiEEOINU6lSJc6ePctvv/2Gi4uL3rJTpkxh165dhIaG0rt3b86fP8+KFSu4cuUKS5cu1Sp79epVRo8eTadOnfjggw9wdnZmzpw5TJkyBXd3dz744APgyVVygPv37/PBBx9gZGREt27dsLOz48iRI0yePJmMjAx69eoFQFZWFj179uTOnTuEh4fj6OjIf/7zH06ePPncx+3h4cHevXsJDg4Gntxwm56eTqtWrfK9f2TatGns2rWLDh06aE7qNm/ezKVLl/jyyy81y18WL17M559/TnBwMMHBwfz888/06dOH7Oxsg+OKi4sjKyuLLl26YGtry/nz59m0aRMJCQksWbJEq6xKpSIiIgJ3d3fGjRvHiRMnWLNmDVWqVKFr166FikNYWBhRUVGcOnUKPz8/4Mksja+vr87J3PPQ914/jy+//JJatWoREhKCiYkJhw4dYvr06ajVarp161bk8T0rNjaWv//+m06dOmFkZMSqVasYNmwY33//PaampgwcOBBnZ2diYmIYPnw4lStX1hzPzp07mThxIm5ubowaNYoHDx6wYcMGzpw5w+7du7WS9ZycHCIiIvD29mb8+PFaV8NPnz7NwYMHNe/dF198wcCBA+nbty9btmyha9eupKamsmrVKiZNmqS1JLEwn5tOnTpx7949jh07xpw5cwzG5Pfff6dbt26UKVOGvn37YmJiQkxMDOHh4WzatIl69epplZ85cybW1tYMHTqU27dvs379embMmMGiRYv09lOxYkVOnDhBQkICFSpU0Ft28uTJ7Ny5k0aNGvH++++jUqk4ffo0P/30E25ubsCL/556+PAh3bt35+7du3Tu3BknJyfOnj3LggULSExMZPLkycCT+4xGjRqFn5+fJjH8888/OXPmDD179jQY3381tRBCiDfKf//7X3Xt2rXVtWvXVnfq1Ek9Z84c9dGjR9WPHz/WKvfLL7+oXVxc1JMnT9baPmvWLLWLi4v6xIkTmm1NmjRRu7i4qI8cOaLTn4eHh3r8+PE62ydNmqQOCAhQJyUlaW0fOXKk2tvbW/3w4UO1Wq1Wr1u3Tu3i4qL+5ptvNGUyMzPVzZo1U7u4uKhPnjyp93h37NihdnFxUZ8/f169adMmtaenp6bt4cOHq8PDwzXH0L9/f029//3vf2oXFxf1119/rdXekSNHtLY/ePBAXbduXXX//v3Vubm5mnILFixQu7i4aB37yZMndcacN5anrVixQq1UKtW3b9/WbBs/frzaxcVFHR0drVW2Xbt26vbt2+uNgVqtVnfv3l3dunVrtVqtVnfo0EE9adIktVqtVqempqrr1q2r3rVrl2Z8+/bt0+q3SZMmOu0tWbJE7eLiorWtoPf6edrILx59+vRRv/POOzrH071794IOV+PZ9/XmzZtqFxcXdcOGDdUpKSma7d9//73axcVFffDgQc22pz87eR4/fqz28/NTh4WFqbOysjTbDx06pHZxcVEvXrxY67hdXFzU8+bN0xmXi4uL2tXVVX3z5k3Ntq1bt6pdXFzUAQEB6vT0dM32+fPnq11cXLTKFvZzM336dJ0YPz2GJUuWaF4PHjxYXbduXfWNGzc02+7evav29PRUd+vWTScuvXr10vrMf/bZZ+ratWur09LS8u0vz7Zt29QuLi7qunXrqsPDw9WLFi1S/+9//1OrVCqtcidOnFC7uLioP/nkE5028vp9Gb+nli5dqvbw8FBfvXpVa/u8efPUtWvXVv/1119qtVqtnjlzptrLy0udk5Oj9/iELlnyJIQQb5iAgAC2bt1KSEgIv/76K6tWrSIiIoJGjRpx4MABTbn4+HgAevfurVW/T58+WvvzVK5cmaCgoEKNQa1W8+233xISEoJarSYpKUnzJzAwkPT0dH7++WfgySyCg4OD1nIcCwsLzVXw59GyZUsePXrEoUOHyMjI4PDhwwUud4qLi8PKyoqAgACt8dWtW5fSpUtrli0dP36c7OxsunfvjpGRkaZ+Ya9YPn3FOjMzk6SkJDw9PVGr1Vy6dEmnfJcuXbRee3t76yyHMaRNmzZ89913miVfxsbGNG3a9LnaeFWejkd6ejpJSUk0bNiQmzdvkp6e/tL6adWqFTY2NprX9evXB+DmzZt66128eJEHDx7QpUsXrXsQGjduTI0aNTh8+LBOnWffszx+fn5UrlxZ8zpvBqB58+ZYWlpqtufd7/L02J73c2OISqXi2LFjNG3alCpVqmi2Ozo6EhYWxo8//khGRoZWnbwZxjz169dHpVJx+/ZtvX29//77rFq1Ch8fH86cOcOyZcvo1q0bzZs358yZM5py3377LUZGRgwdOlSnjbx+X8bvqbi4OLy9vbG2ttb6t+7v749KpeJ///sfANbW1jx8+FBr2aQoHFnyJIQQbyB3d3eio6N5/Pgxv/76K99//z3r1q1jxIgR7N69m7feeovbt2+jUCh0lq04ODhgbW2tc9Lw9ImRIUlJSaSlpRETE0NMTEyBZQBu375NtWrVtE5cAJydnQvdXx47Ozv8/PyIjY0lKysLlUpFaGhovmWvX79Oenq6ZlnQs/JuHv3rr78AqF69uk5fT5+wFuSvv/5iyZIlHDx4UOfejGdP4EqVKoWdnZ3WNhsbG516hrRq1YrZs2dz5MgRvv76axo3bqx1AlucfvzxR6Kiojh37hwPHz7U2peenv7SbpB2cnLSep33Xhn6nom89zu/z1+NGjX48ccftbaZmJgUuKzn2THkvQfPls875qfH9jyfm8JISkri4cOH+R5XzZo1yc3N5c6dO9SqVUuzvWLFilrl8pZ6Fea7OoKCgggKCuLhw4f8/PPPfPPNN2zdupWBAweyb98+7O3tuXHjBo6Ojtja2hbYzsv4PXX9+nUuX75c4L/1vN9FXbt2Zd++ffTr14/y5csTEBBAy5YtadSokcHj/beThEIIId5gZmZmuLu74+7uTvXq1Zk4cSJxcXFaVwSfPZEvyPM8KSXvRsd3332X9u3b51vm2Zt1X5awsDCmTp3K/fv3adSoUb43p+eN0d7ennnz5uW7/9kT+6JQqVT07t2b1NRU+vbtS40aNShdujR3795lwoQJOjeEGhsbv3Cf8OSqc8OGDVm7di1nzpzR+z0FBb3/z3MjeGHbuHHjBr169aJGjRpMmDABJycnTE1NiY+PZ926dTrxeBEFxVKtVr+0PuDJvzGFIv8FHwWNwdDYnvdz86oUdFzPE0MLCwvq169P/fr1KVu2LNHR0Rw5cqTA3wsFeZHfU7m5uQQEBNC3b9986+RdLLC3t2f37t3897//5ciRIxw5coSdO3fSrl07Zs+e/Vzj/beRhEIIIf4lXF1dAbh37x7w5Cbm3Nxcrl+/Ts2aNTXl7t+/T1paGpUqVSpyX3Z2dpQpU4bc3Fz8/f31lq1UqRK//fYbarVa66Th6tWrReq7WbNmfPTRR5w7d46FCxcWWK5q1aqcOHECLy8vvclS3lXaa9euaS0VSUpKMjhz8Ntvv3Ht2jVmz55Nu3btNNtfx5KKsLAwpkyZgrW1td4rrNbW1vlecc67Ul8YhW3j4MGDPH78mM8//1zr6ndJ+mbxvHFdvXpV54r21atXda7avwrP87kp7Im2nZ0dFhYW+f67+vPPP1EoFDozKi9b3u+gxMRE4Mm/wf/+97+kpKQUOEvxMn5PVa1alczMTIO/i+BJghgSEkJISAi5ubl8/PHHxMTEMHjwYKpVq1aIo/x3knsohBDiDXPy5Ml8ryDmrTWuUaMGgOZJSM8+EnHt2rVa+w0pXbq0zsmksbExoaGh7N+/n99++02nztOPnmzUqBH37t3T+vbmhw8fFvkLsMqUKcPHH3/MsGHD8n2UaZ6WLVuiUqlYtmyZzr6cnBzNMfn7+2NqasqmTZu04lqYR0nmXeF9up5arX4lXzD4rBYtWjB06FA++ugjvV/qV7VqVdLT0/n111812+7du8d3332nUza/9/p52si7Mv90PNLT09mxY0fhD+wVc3V1xd7enq1bt2o9ljQ+Pp4rV67QuHHjVz6G5/nc5H2zt6FlSMbGxgQEBHDgwAGte3Lu379PbGws3t7eL21Z3IkTJ/Ldnvc7KG/ZVfPmzVGr1fl+MV/esb+M31MtW7bk7NmzHD16VGdfWloaOTk5wJNvTn+aQqHQzKQ+72Os/21khkIIId4wM2fO5OHDhzRr1owaNWqQnZ3NmTNn2LdvH5UqVaJDhw4AvP3227Rv356YmBjS0tJo0KABFy5cYNeuXTRt2hRfX99C9Ve3bl1OnDjB2rVrcXR0pHLlytSrV4/Ro0dz6tQpPvjgAzp27Mhbb71FamoqP//8MydOnOCHH34Antz4uXnzZsaPH8/PP/+Mg4MD//nPf17oy6gKs5yiYcOGdOrUiRUrVvDLL78QEBCAqakp165dIy4ujsmTJ9OiRQvs7Ozo06cPK1asYMCAAQQHB3Pp0iWOHDlC2bJl9fZRo0YNqlatyuzZs7l79y6Wlpbs37+/UGvQX5SVlRXDhg0zWK5Vq1bMmzePoUOHEh4eTlZWFl9++SXOzs6aG+fzFPReF7aNvBgPHDiQzp078/fff7Nt2zbs7e01V62Lm6mpKWPGjGHixIl0796d1q1bax4bW6lSJc3jjl+l5/nc1K1bF3jy7z4wMBBjY2Nat26db7sffvghx48fp2vXrnTt2hVjY2NiYmJ4/PgxY8eOfWnjHzx4MJUrV6ZJkyZUqVKFhw8fcvz4cQ4dOoSbmxtNmjQBwNfXl7Zt27Jx40auX79OUFAQubm5/Pjjj/j4+NC9e/eX8nsqIiKCgwcPMnDgQNq3b0/dunV5+PAhv/32G/v37+fAgQPY2dkxZcoUUlNT8fX1pXz58vz1119s2rSJ2rVra82OCF2SUAghxBtm3LhxxMXFER8fT0xMDNnZ2VSsWJGuXbsyaNAgrXsKZs6cSeXKldm1axfff/895cqVY8CAAfk+daUgEyZMYNq0aSxatIisrCzat29PvXr1KFeuHNu2bWPp0qV89913fPnll9ja2vLWW29pnvEOT66wrlu3jk8++YRNmzZhbm5OmzZtaNSoUYFrnl+WGTNm4OrqytatW1m4cCHGxsZUqlSJd999Fy8vL025Dz/8EDMzM7Zu3cqpU6dwd3dnzZo1DBgwQG/7pqamLF++nJkzZ7JixQpKlSpFs2bN6NatG23btn2lx1ZYeevaZ82axdy5c6lcuTKjRo3i+vXrOglFQe91YduoUaMGS5YsYdGiRcyePZty5crRpUsX7OzsmDRp0us+9AJ16NABc3NzVq5cybx58yhdujRNmzZl7NixBd6T8zI9z+emefPmhIeHs3fvXr7++mvUanWBCUWtWrXYvHkz8+fPZ8WKFajVatzd3Zk7d67Od1C8iJkzZ3LgwAH27dvHvXv3UKvVVKlShYEDB9KvXz+tb7KPjIxEqVSyfft25syZg5WVFa6urnh6emq19yK/pywsLNi4cSMrVqwgLi6O3bt3Y2lpSfXq1Rk2bJjmpvh3332Xr776ii1btpCWloaDgwMtW7Zk2LBhBd5PIp4wUr/su5OEEEIIIYQQ/xqSbgkhhBBCCCGKTBIKIYQQQgghRJFJQiGEEEIIIYQoMkkohBBCCCGEEEUmCYUQQgghhBCiyCShEEIIIYQQQhSZJBRCCCGEEEKIIpMvthNCvNHUajW5ufJ1OwVRKIwkPgZIjPST+BgmMdJP4mNYccRIoTDCyMioUGUloRBCvNGMjIxIS8skJye3uIdS4piYKChbtozERw+JkX4SH8MkRvpJfAwrrhjZ2ZXB2LhwCYUseRJCCCGEEEIUmSQUQgghhBBCiCKThEIIIYQQQghRZJJQCCGEEEIIIYpMEgoh3jBff/01nTt3xtPTE09PTzp16sTu3bu1ykyYMIGwsLDXMp6dO3eiVCpJSkoCIC0tjaioKP7444/X0j9Q6KdUCCGEEOL5SUIhxBvkk08+Ydy4cdSsWZPFixezZMkSatWqxYQJE/jkk0+KZUyNGzcmJiYGa2tr4ElCER0d/VoTCoVCEgohhBDiVZHHxgrxhjhw4ACbNm1i6NChDBs2TLM9KCgIR0dHli5dSkBAACEhIa91XHZ2dtjZ2b3WPoUQQgjx+sgMhRBviPXr12NjY0OfPn109kVERGBjY8P69eu1tsfHxxMWFoabmxsdOnTg3LlzOnV37txJmzZtcHNzIygoiIULF6JSqTT709LSmDJlCkFBQbi5uREcHMzIkSO16uctebp16xbvvPMOACNGjECpVKJUKrl16xYdOnRg9OjROv3PnTuXwMBArT6FEEIIUXJIQiHEGyAnJ4ezZ8/i4+NDmTJldPaXKVMGHx8fzp49S05ODgCJiYlMnz6diIgIFi1ahJmZGRERETx48EBTb+3atUyZMoXAwECWL19Ov3792LBhAwsXLtSUiYyM5PDhw4waNYrVq1czbtw4zMzM8h2no6Mj0dHRAIwaNYqYmBhiYmJwdHSkY8eOfP/996Snp2vKq1Qq/vOf/9C+fXuMjY1fSqyEEEII8XLJkich3gDJyck8fvwYJyenAss4OTnx6NEjUlJSAEhJSWHRokX4+fkB0LBhQ4KDg1m3bh2jR48mIyODJUuW0LdvX0aNGgVAQEAApqamzJo1i4iICMqWLcuFCxcICwujffv2mr5at26d7xjMzMyoXbs2ANWqVcPDw0Ozr02bNsyePZs9e/bQtWtX4MkMSmJiIu+9916RYwNP7qEwMZHrJ88yNlZo/S10SYz0k/gYJjHST+Jj2D8hRpJQCPEvZWVlpUkm8l77+/vz008/AXD27FkyMzNp0aKFZlYDwN/fn6ysLH7//XcaNmxInTp12LVrFw4ODgQFBeHi4lKk8VhaWtKyZUt27NihSSh27txJ/fr1qV69etEPFLC0NH+h+m86a2uL4h5CiScx0k/iY5jESD+Jj2ElOUaSUAjxBihbtixmZmbcuXOnwDJ37tyhVKlS2NraAuR7o7S9vT1XrlwBnsx6AFozD8+2BzB16lRsbGxYu3Ytc+bMwcnJif79+2uSgufxwQcf0LlzZ3799VccHR05fPgwM2bMeO52npWRkUV2ttyD8SxjYwXW1hakpT1Epcot7uGUSBIj/SQ+hkmM9JP4GFZcMbK2tij0rIgkFEK8AUxMTPD09OSHH34gMzOT0qVLa+3PzMzkhx9+wNPTExOTJ//s874X4mkPHjzAwcEBABsbGwCio6OpUKGCTtnKlSsDT2Y2Jk+ezOTJk7l8+TIbNmxg+vTpuLi4UL9+/ec6Dk9PT2rVqsWOHTuoWLEiZmZmtGjR4rnayE9urpqcHPmPqiAqVa7ExwCJkX4SH8MkRvpJfAwryTEquYuxhBDPpWfPnqSkpLBmzRqdfWvWrCElJYWePXtqtqWnp3PixAmt18ePH6devXrAk5N7CwsLEhIScHNz0/lTtmxZnX6USiUTJ04E0Mx0PMvU1BSAR48e5bu/Y8eO7Nmzh+3bt9OqVSud5EgIIYQQJYvMUAjxhnjnnXfo3r070dHRJCQkaK7sf/vtt3z11Vd0795d6zsobG1tmTx5MsOHD8fKyoqVK1eiVqs1SYe1tTXDhw9n7ty5JCQk0LBhQ4yNjbl58yYHDhwgKioKCwsLOnfuTLNmzahVqxbGxsbs3r0bU1PTAmcnHBwcsLa2Zu/evVSuXBkzMzOUSqXmyVBt27Zl3rx5JCcn8+mnn77iqAkhhBDiRUlCIcQbZOrUqdSrV48tW7ZovtzOxcWFWbNm0a5dO62yDg4OjBkzhjlz5nDjxg1q1arF6tWrKVeunKZMnz59KF++PGvXrmXTpk2YmJhQtWpVGjdurJlp8PLyYvfu3dy6dQuFQoGLiwvLly+nZs2a+Y5RoVAQGRnJggUL6NWrF48fP+bAgQOaJVS2trY0bNiQhIQEradACSGEEKJkMlKr1eriHoQQQuTJyMggKCiIYcOG5fslfUWRkpIpN2Xnw8REQdmyZUhO/rvErsstbhIj/SQ+hkmM9JP4GFZcMbKzKyM3ZQsh/lkyMjK4cuUKW7ZswcjIiA4dOry0tuW6iRBCCPHqSEIhhCgRfv75Z3r06IGTkxOzZ8/WPN5WCCGEECWbJBRCiBLBx8eHy5cvF/cwhBBCCPGc5LGxQgghhBBCiCKThEIIIYQQQghRZJJQCCGEEEIIIYpMEgohhBBCCCFEkUlCIYQQQgghhCgySSiEEEIIIYQQRSYJhRBCCCGEEKLIJKEogaKiolAqlQQFBZGbq/sV6507d0apVDJhwoRiGJ1hSUlJzJo1i9DQUNzc3PDy8qJ79+5s27YNlUpV3MMrNqdOnUKpVHLhwoVX0v6aNWt4++23uXPnTr77L1++jFKpZPv27YVqLzw8nAEDBrzMIRYbIyOj4h6CEEII8caShKKEMjU1JTk5mf/9739a22/fvs25c+coXbp0MY1Mv+vXr9O+fXtiY2P54IMPWLlyJYsWLcLd3Z3IyEgOHTpU3EN8Y7Vu3RojIyP27t2b7/69e/diZmZGaGjoax5Z8VMoJKEQQgghXhX5puwSytTUFD8/P/bu3YuPj49m+969e6lVqxYKRcnMBceMGYNKpWLHjh2UL19es71Ro0Z0796d9PT0F2o/KysLc3PzFx3mP5parSY7OxszMzOt7eXLl6dBgwbExsbSt29fnXp79+6lcePGWFlZva6hCiGEEOJfoGSelQoAwsLC2L9/P9nZ2ZptsbGxhIWF5Vv+ypUrDBo0CG9vbzw8POjfvz83btzQKrNmzRree+89vL298fPzY8CAAVy9elWrzIQJEwgLC+PUqVO0a9cODw8P3n//fS5evKh3vKdPn+b8+fMMGDBAK5nIU7FiRZRKpeb1//73Pzp37oy7uzs+Pj5MnDiRlJQUzf5bt26hVCrZuXMnU6ZMwcfHh44dOwL/vxxn9+7dNG3aFHd3d8LDw/nzzz916sfFxWmN49NPPyUkJETzOi0tjSlTphAUFISbmxvBwcGMHDlSq87du3cZN24c/v7+uLu706JFC9avX6/Zr1QqWb16tVaddevWaR1vfp7n/YiPj+fdd9/Fzc2NgwcP5ttemzZt+OWXX7hy5YrW9rNnz3Lr1i3atGkDQEpKChMnTsTHxwd3d3c6d+6sMxv2rLxxPC0tLU3zHuUJCQlhxowZrFu3juDgYDw9PZkwYQKPHz/ml19+oXPnzprP1OXLl7XaU6vVrF69mtDQUFxdXXnnnXdYt26d3nEJIYQQonjJDEUJ1qRJEyZPnsyxY8do3Lgxf/zxB5cvX2bp0qV88803WmVv3rxJ586dqVWrFrNmzcLIyIjly5fTq1cv4uLiNFezExIS6N69OxUrViQjI4OtW7fSuXNn9u/fj62traa9xMREZs6cSf/+/bGysmL+/PkMHTqU7777DlNT03zH+8MPPwAQFBRk8NguXrxI79698fHxYfHixdy/f5/58+fzxx9/sHXrVoyNjTVlFyxYQHBwMPPnz9e6p+Tnn3/mxo0bjB49GoBFixbRt29freMtjMjISI4ePcro0aOpVKkSiYmJHDlyRLM/OTmZTp06ATBy5EgqV67M9evXdZK1oijs+3Hv3j1mzpzJoEGDcHJyomLFivm2FxoayvTp04mNjWXEiBGa7bGxsVhZWdG4cWNUKhX9+vXj5s2bjBkzhnLlyrFx40Z69+7N1q1bcXV1feHjOnDgALVq1WLGjBncvHmTWbNmYWpqyrlz5+jVqxflypVj3rx5jBgxgm+++UYz4/bpp5+ybds2Bg4cSL169Thz5gzz5s2jVKlSdOnS5YXHJYQQQoiXTxKKEszCwoKQkBDNUpXY2Fg8PT2pUqWKTtno6GhsbGxYu3YtpUqVAsDLy4t33nmHbdu20a1bNwAmTZqkqaNSqQgICMDPz4/9+/drTpoBUlNT2bRpE7Vq1dKMpUePHvz000/Ur18/3/HevXsXoMCT3actX74cBwcHli9frklQnJyciIiIID4+XmsG4e233+bTTz/VaePBgwds2rSJ6tWrA1CnTh1atGjBzp076dy5s8Ex5Llw4QJhYWG0b99es61169aan9etW8eDBw/Yt28flStXBsDPz6/Q7evzPO/HypUrqVevnt72rK2tCQ4OZu/evZqEQqVSERcXR/PmzTEzM+PAgQOcP3+eVatWaZK/wMBAmjdvzooVK4iKinopx7Zs2TJNYvfDDz/w1VdfsXLlSho1agRAbm4uAwcO5LfffuPtt9/mxo0bbNq0ienTp2uO3d/fn6ysLJYuXUqnTp2KvNRPoTDCxEQmZJ9lbKzQ+lvokhjpJ/ExTGKkn8THsH9CjCShKOHCwsIYPXo0WVlZfPPNN4SHh+db7tixY7Rq1QpjY2NycnKAJyeXderU0VqqdO7cORYvXsylS5e0lhddu3ZNqz1HR0dNMgHw1ltvAf+fNLyo06dPExYWpjXbERgYiLW1NT/++KNWQtG4ceN826hVq5YmmQCoVq0ab7/9Nj/99NNzJRR16tRh165dODg4EBQUhIuLi9b+EydO4Ovrq0kmXqbCvh+2trYGk4k8YWFhfPjhh1y4cAE3NzdOnjzJ/fv3NcudTp8+jaWlpdZMkqmpKc2aNSM2NvaFjwmgQYMGWrNE1atXR6FQ4Ovrq7UN4M6dO7z99tscP34cgObNm2s+w/AkqVi5ciV37tyhUqVKRRqPpeW/+74bQ6ytLYp7CCWexEg/iY9hEiP9JD6GleQYSUJRwgUGBmJqasrixYu5desWLVu2zLdccnIy69ev11rXnyfvpP2vv/6iT58+uLq6Mn36dBwdHTE1NWXAgAE8evRIq461tXW+bTxb7ml5903cuXOHatWq6T2utLQ07O3tdbbb29uTmpqqsy0/BdVPTEzU2/ezpk6dqpndmTNnDk5OTvTv35+uXbsCT+43eDq5elme5/0oV65codsNCQmhTJkyxMbG4ubmRmxsLI6Ojpqb+wuKfbly5XRiX1T5fX7Mzc21koxnP1PJycmo1WqtpONpL5JQZGRkkZ39731kcUGMjRVYW1uQlvYQlUr3EdVCYmSIxMcwiZF+Eh/DiitG1tYWhZ4VkYSihDM1NaV58+asW7cOPz+/Ak8sbWxsCA4O1pwEP61MmTIAHD16lMzMTKKjozUnfDk5OS/tJLJhw4YA/Pe//zWYUNjY2PDgwQOd7Q8ePMDGxkZrW0HfIVBQ/bfffhtAs/Tr6Zva4ckJ9dOsrKyYPHkykydP5vLly2zYsIHp06fj4uJC/fr1sbW15d69e3qPx8zMzGA/z3qe9+N5vkehVKlSNG/enG+++YaRI0fy3Xff8f7772uWCxUU+/v37+vE/mn5HePL+uzkjcvIyIgtW7bke5+Os7NzkdvOzVWTkyP/URVEpcqV+BggMdJP4mOYxEg/iY9hJTlGJXcxltDo2LEjTZo0oUePHgWW8fPz4/fff6dOnTq4ublp/alRowbw5JGrRkZGmJj8fx65b98+reUlL6J+/fq4u7uzfPnyfE/A79y5o3mqj7e3NwcOHNDq+9ixY6SlpeHt7V2o/n7//XeuX7+ueX39+nV+/fVXzdIge3t7TE1NtZ549PjxY71PM1IqlUycOBFAU8/Pz4+TJ0/y119/FVivQoUKOk9WylvCU5BX+X6EhYVx79495s6dS3p6uma5EzyJfUZGBv/9738123Jycvj+++/1xr5ChQokJCTw999/a7YdO3bshceaJ+++lJSUFJ3PsJubG5aWli+tLyGEEEK8PDJD8Q/g7u7OsmXL9JYZPnw477//PhEREXzwwQeUK1eO+/fv88MPP1C/fn3CwsI0S0kmTpxI586d+f3331m7dq3O8pQXMW/ePMLDw3nvvffo3bs3devW1ZzEb968mdmzZ6NUKhk4cCCdO3dmwIABhIeHa57y5O7uTnBwcKH6sre3Z+DAgQwfPhyAxYsXU758eTp06ACAQqGgWbNmbN68mWrVqlG2bFk2bdqEWq3WuuLfuXNnmjVrRq1atTA2Nmb37t2Ymppqbj7v1asX//nPf+jevTuDBg2iSpUq3Lx5k2vXrjF27FjgydOV1q9fj5ubG87Oznz99dcG7zd5le9H3mzW5s2bqVGjBnXr1tXsa9y4Me7u7owdO5bRo0drnvJ07949lixZUmCbzZs3Z8mSJUyaNIkPPviA33//vdDful0Yzs7OdOvWjXHjxhEREUG9evXIzs7m2rVrnDp1yuC/ASGEEEIUD0ko3hDVqlVj27ZtLFq0iOnTp5OZmYmDgwMNGjTQfBeCUqkkMjKS6OhoBgwYQO3atVm8eDEffvjhSx3Hrl27WLlyJV9++SV37tzBzMyMOnXqMGnSJJo0aQKAq6sra9asYcGCBQwbNozSpUsTEhLC+PHjtR4Zq0/dunVp3rw5c+fOJTExkXr16jF9+nStdfpTp05l6tSpzJw5kzJlyhAREYGzszMHDhzQlPHy8mL37t3cunULhUKBi4sLy5cvp2bNmgCULVuWL7/8kvnz5zNv3jwePnxIpUqVtJaXDR48mAcPHrB06VKMjIzo1KkTPXr0YNasWQWO/1W+H8bGxrRs2ZKNGzfqfHeEsbExX3zxBXPmzGHu3LlkZmZSt25d1qxZo/eRsW+99RazZs1i2bJlDB48GG9vb+bNm0fbtm1feLx5pkyZgrOzMzExMSxdupQyZcrg7OxMixYtXlofQgghhHi5jNRqtbq4ByHE8woPD6d06dKsWLGiuIci/gFSUjLlpux8mJgoKFu2DMnJf5fYdbnFTWKkn8THMImRfhIfw4orRnZ2ZQp9U7bcQyGEeOPJdRMhhBDi1ZGEQgghhBBCCFFkcg+F+EfauHFjcQ9BCCGEEEIgMxRCCCGEEEKIFyAJhRBCCCGEEKLIJKEQQgghhBBCFJkkFEIIIYQQQogik4RCCCGEEEIIUWSSUAghhBBCCCGKTBIKIYQQQgghRJFJQiHeCFFRUXh6er7yfk6dOoVSqeTChQuvvK/CiIqK4syZM6+0j+HDhzN79myd7fHx8fTr1w9fX1/q1q2Lv78//fv3JzY2ltzcXJ3yMTExNG3aVDNufe/XrVu38PDw4NatWy/lGIyMjF5KO0IIIYTQJQmFEP9g0dHRnD179pW1//PPP3Po0CF69eqltX3BggX079+fUqVKMW3aNNatW8fUqVOxsrJi7NixHDt2TKetQ4cO0bhx40L1W7lyZUJDQ4mKinoJRwEKhSQUQgghxKsi35QthCjQhg0bCAwMpHz58ppthw8fZsWKFQwdOpRhw4ZplW/ZsiU9e/bExET7V8ujR484efIkS5cuLXTf77//Pr1792b8+PHY2dm92IEIIYQQ4pWRGQrxr5CQkMCYMWPw8fHB3d2dbt26cfHiRa0ySqWS1atXa21bt24dSqVSb9tHjhyhXr16LFmyBIDc3FyWLVtGSEgIrq6utGjRgq1bt+rUu3LlCkOHDqVhw4bUq1ePd999l9jYWACGDRtG586ddeps2bIFNzc3UlJSNOOaM2cOSqUSpVLJqVOnAFCr1axevZrQ0FBcXV155513WLdunU5MRowYgb+/P25uboSEhPDZZ59p9mdmZvLtt98SGhqqVW/t2rU4ODgwaNCgfOPh7u5OnTp1tLadOHEChUJBgwYN9IVSi7e3N7a2tuzZs6fQdYQQQgjx+skMhXjjpaam0rVrV0qXLq1ZlrNx40Z69uzJt99+i729fZHb/vbbbxk9ejQffvghERERwJMT/A0bNjBo0CA8PT05fPgwH330ETk5OXTv3h2Aa9eu0alTJ5ycnJg8eTIODg789ttv/PXXXwB07NiRfv368eeff1KjRg1Nfzt27KBZs2bY2toSExNDp06dCA8PJywsDIC33noLgE8//ZRt27YxcOBA6tWrx5kzZ5g3bx6lSpWiS5cuAIwbN4579+4xZcoU7O3tuXPnjlaSde7cOTIzM/H29tZsy8nJ4cyZM4SGhurMQuhz8OBBAgMDMTMzK3QdhUJBvXr1OH78OD179ix0PSGEEEK8XpJQiDfe+vXrSUtLY9u2bZrkwc/Pj9DQUFavXs24ceOK1O7u3buZMmUKkydP1pykJyUlsWnTJiIiIjTLgQIDA0lOTmbp0qV06dIFY2NjoqKiMDU15csvv8TS0hIAf39/TduBgYFUrFiRHTt2MHbsWAB+++03Ll68yKhRowDw8PAAwMnJSfMzwI0bN9i0aRPTp0+nU6dOmrazsrJYunQpnTp1QqFQcOHCBUaNGkWrVq00ddu1a6f5+cKFC5QuXZoqVapotqWkpPD48WOcnJy0YqFWq1GpVJrXCoUCheL/J0Dj4+MZMWLE8wUYePvtt9m8efNz13uWQmGEiYlMyD7L2Fih9bfQJTHST+JjmMRIP4mPYf+EGElCId54x44dw8fHBxsbG3JycgA0y2+K+rSmr776il27djFz5kytk/Dz58+TnZ1NixYttMq3bNmS2NhYrl27Rs2aNTl58iShoaGaZOJZCoWC9957j61btzJy5EhMTEzYsWMHlSpVws/PT+/Yjh8/DkDz5s01xwtPkoqVK1dy584dKlWqRJ06dVizZg3GxsYEBARQrVo1rXYSExMpW7Zsvn08+9Sk/fv3ayUM3bp1Y9q0aQD88ssv3Lt3r9A3ZD+tbNmyJCcnk52djamp6XPXz2NpaV7kuv8G1tYWxT2EEk9ipJ/ExzCJkX4SH8NKcowkoRBvvOTkZM6dO0fdunV19lWtWrVIbX777bc4OTnpnCSnpqYCUK5cOa3tea9TUlI0fzs6Ourt4/3332fZsmXEx8fTqFEjvv76a7p27ap15T8/ycnJqNVqfH19892fl1AsXLiQhQsXsmjRIqZPn46zszOjRo2iefPmwJMbqZ9domRra4uZmRkJCQla2/38/Ni+fTuAzr0VBw8exN3dvUg3Vuf1/+jRoxdKKDIyssjOVhku+C9jbKzA2tqCtLSHqFS6j/oVEiNDJD6GSYz0k/gYVlwxsra2KPSsiCQU4o1nY2NDUFBQvktunj5hNjMzIzs7W2t/Wlpavm3Onj2bWbNmERERwfr16zUzDba2tgA8ePBA68lI9+/f19pva2vLvXv39I67QoUKBAUFsWPHDlQqFcnJyXTo0EH/wfLkeI2MjNiyZUu+J+HOzs4AODo6EhkZSW5uLhcvXuTzzz9n5MiRxMXFUaVKFWxsbEhPT9eqa2JigpeXFydOnEClUmFsbKzp083NDUAnCTl8+DAhISEGx52ftLQ0TE1NC5zJKazcXDU5OfIfVUFUqlyJjwESI/0kPoZJjPST+BhWkmNUchdjCfGS+Pv7c+XKFWrWrImbm5vWn6ef4FShQgWuXLmiVTdv+dCz7O3tWb9+PampqfTt25fMzEwA3NzcMDU1JS4uTqv8vn37sLe3p3r16sCTK/r79+8nIyND79g7duxIfHw8a9aswc/Pj0qVKmntNzU15dGjR1rb8pZEpaSk6Byvm5ubzsm5QqHA3d2dDz/8kJycHK5fvw48STySkpI0x5and+/e3Lt3j+XLl+sdOzxJpC5cuECTJk0Mls3P7du3NQmQEEIIIUommaEQbwyVSqVzIg/wwQcfsGfPHrp3706PHj2oWLEiSUlJ/PTTT5QvX17zpW2hoaGsX78eNzc3nJ2d+frrr7l7926B/ZUvX55169bRvXt3Bg0axBdffIGdnR3du3dn9erVmJmZ4eHhQXx8PLGxsUydOlVzRX/o0KEcPnyYrl270rdvXxwcHLhy5QoPHz6kX79+mj4aN25M2bJlOXv2LAsWLNAZQ40aNThw4AD169fHwsICZ2dnnJ2d6datG+PGjSMiIoJ69eqRnZ3NtWvXOHXqFMuWLSM9PZ2IiAjatm2Ls7Mz2dnZbNy4EWtra80jX728vMjNzeXSpUvUr19fa0z9+/dnyZIl/Prrr7Rs2RJHR0fS09M5ffo0iYmJlClTBngyO+Hk5MTbb79d6PfL3d2dihUrAnDx4kWtp0wJIYQQouSRhEK8MR49epTvsqY5c+YQExPDokWLmDdvHikpKdjb21OvXj2aNWumKTd48GAePHjA0qVLMTIyolOnTvTo0YNZs2YV2GflypVZv3493bp1Y+jQoSxdupRx48ZhZWXF9u3bWb58OZUqVWL69Ola3ytRvXp1tm7dyvz585k+fToqlYrq1avTv39/rfZNTEwICQkhLi5Oa6x5pk2bxmeffUa/fv3Iyspiw4YN+Pj4MGXKFJydnYmJiWHp0qWUKVMGZ2dnzc3ipUqVwsXFhY0bN3Lnzh3Mzc1xdXVl9erVmnsdnJ2dcXFx4ejRo1oJBcDo0aPx9vZm8+bNTJ8+nYyMDGxsbKhbty6fffYZrVu3Bp4kFMHBwc/9frVt25YHDx7w888/a55qJYQQQoiSyUitVquLexBCiPzl5ubStGlTmjRpwtSpU197/xs3bmTDhg18++23Ok92MuTx48f4+PiwaNGiApMKfTZv3sy6deuK1PezUlIy5absfJiYKChbtgzJyX+X2HW5xU1ipJ/ExzCJkX4SH8OKK0Z2dmUKfVO23EMhRAn0+PFjzp8/z/z580lISKBbt27FMo6OHTuSlZXFwYMHn7uumZkZZ8+eLVIykZuby4YNGxgyZMgLJxPw5HsyhBBCCPFqyJInIUqge/fu0bFjR+zs7Jg6darWt2W/Tubm5syaNUvnaU+v2r1792jfvj3vvvvua+1XCCGEEM9PEgohSqDKlStz+fLl4h4GAAEBAa+9zwoVKjBw4MDX3q8QQgghnp8seRJCCCGEEEIUmSQUQgghhBBCiCKThEIIIYQQQghRZJJQCCGEEEIIIYpMEgohhBBCCCFEkUlCIYQQQgghhCgySSiEEEIIIYQQRSYJhRD/EFFRUSiVSs0fX19fevTowenTpwHYuXMnSqWSpKSk52p3586d7Nmzp0hjOnXqFEqlkgsXLjx3veXLlxepz6J4Gd+2LYQQQoj8SUIhxD+Iubk5MTExxMTE8PHHH5OSkkKvXr347bffitzmrl27iI2NfYmjNOyHH35gxYoVr60/hUISCiGEEOJVkW/KFuIfRKFQ4OHhoXnt7u5OSEgIW7duxdXVtfgGJoQQQoh/LZmhEOIfrGLFitjZ2XHr1q1898+bN482bdrg6elJUFAQo0aN4t69e5r94eHh/PDDDxw+fFizlCoqKkqz//Dhw3Ts2BF3d3d8fX356KOPyMzM1DsmtVrN6tWrCQ0NxdXVlXfeeYd169Zp9kdFRREdHU1mZqamz/DwcAASEhIYMWIE/v7+uLm5ERISwmefffYCERJCCCHEqyYzFEL8g2VkZJCSkoKjo2O++x88eMCAAQNwdHQkKSmJtWvXEh4ezt69ezExMeGjjz5i7NixmJubM378eAAqVKgAQFxcHCNHjqRDhw4MGzaMxMRE5s+fT1paGgsXLixwTJ9++inbtm1j4MCB1KtXjzNnzjBv3jxKlSpFly5d6NixIwkJCcTGxrJ+/XoALC0tARg3bhz37t1jypQp2Nvbc+fOHS5evPgyQyaEEEKIl0wSCiH+YXJycoAnV/Nnz56NSqUiNDSUxMREnbKRkZGan1UqFZ6enjRq1IiTJ08SGBjIW2+9haWlJaVLl9ZaSqVWq5kzZw6tWrXi008/1Wx3cHCgf//+DB48mFq1aun0d+PGDTZt2sT06dPp1KkTAP7+/mRlZbF06VI6depEhQoVqFChgs7yLYALFy4watQoWrVqpdnWrl27ooRJi0JhhImJTMg+y9hYofW30CUx0k/iY5jESD+Jj2H/hBhJQiHEP0hmZiZ169bVvLaxsWHatGkEBQWxc+dOnfLx8fF8/vnn/P7772RkZGi2X7t2jcDAwAL7uXr1Krdv32bSpEmaBAagYcOGKBQKLl68mG9Ccfz4cQCaN2+uVc/f35+VK1dy584dKlWqVGC/derUYc2aNRgbGxMQEEC1atUKLPs8LC3NX0o7bypra4viHkKJJzHST+JjmMRIP4mPYSU5RpJQCPEPYm5uzqZNmzAyMqJs2bI4OTmhUOR/xeL8+fMMHjyYd955h379+mFvb4+RkREffPABjx490ttPcnIyAEOGDMl3/507dwqsp1ar8fX1LbCevoRi4cKFLFy4kEWLFjF9+nScnZ0ZNWoUzZs31zteQzIyssjOVr1QG28iY2MF1tYWpKU9RKXKLe7hlEgSI/0kPoZJjPST+BhWXDGytrYo9KyIJBRC/IMoFArc3NwKVfb777/H0tKSRYsWaZKO27dvF6qura0tANOmTcPd3V1nf0H3bNjY2GBkZMSWLVswNTXV2e/s7Ky3X0dHRyIjI8nNzeXixYt8/vnnjBw5kri4OKpUqVKosecnN1dNTo78R1UQlSpX4mOAxEg/iY9hEiP9JD6GleQYSUIhxBsqKysLU1NTrS91y+8L7ExNTXVmLGrUqEGFChW4efMm3bp1K3Sffn5+AKSkpBASElJgOVNTUx4/flzgfoVCgbu7Ox9++CEHDx7k+vXrL5RQCCGEEOLVkYRCiDdUQEAA69ev55NPPqFZs2acPXuW//znPzrlatSowe7duzl48CAODg44OjpSvnx5JkyYwJgxY8jMzKRx48ZYWFjw119/ER8fz8iRI/OdbXB2dqZbt26MGzeOiIgI6tWrR3Z2NteuXePUqVMsW7YMgJo1a5KTk8P69evx9PTE0tISBwcHIiIiaNu2Lc7OzmRnZ7Nx40asra2pU6fOK4+XEEIIIYpGEgoh3lDBwcGMGTOGTZs2sXPnTry8vFixYgWhoaFa5fr168eNGzcYP348aWlpDB06lGHDhtGyZUusra1Zvny5ZmajUqVKBAUFUa5cuQL7nTJlCs7OzsTExLB06VLKlCmDs7MzLVq00JRp0qQJXbt25YsvvuDBgwc0aNCA1atX4+LiwsaNG7lz5w7m5ua4urqyevVq7OzsXk2QhBBCCPHCjNRqtbq4ByGEEK9SSkqm3JSdDxMTBWXLliE5+e8Suy63uEmM9JP4GCYx0k/iY1hxxcjOrkyhb8ouuQ+0FUKIl0SumwghhBCvjiQUQgghhBBCiCKThEIIIYQQQghRZJJQCCGEEEIIIYpMEgohhBBCCCFEkUlCIYQQQgghhCgySSiEEEIIIYQQRSYJhRBCCCGEEKLIJKEQQgghhBBCFJkkFEIIIYQQQogik4RC/ONFRUXh6elZ4P5bt26hVCqJi4t7jaPKn1KpRKlU8uWXX+rsO3bsmGb/rVu3nqvdU6dOsXz58pc1TC1paWlERUXxxx9/vJL2w8PDGTBgwCtpO4+RkdErbV8IIYT4N5OEQrzxHB0diYmJwdfXt7iHAkDp0qX55ptvdLbHxsZSunTpIrX5ww8/sGLFihcdWr7S0tKIjo5+ZQnFRx99xPjx419J23kUCkkohBBCiFdFEgrxxjMzM8PDwwNbW9vX0l9WVpbe/e+88w6nT5/m7t27mm2PHz/mu+++o2nTpq96eCXOW2+9RY0aNYp7GEIIIYQoIkkoxBvv2SVPEyZMICwsTKfcoUOHUCqV/Pnnn5ptO3fupE2bNri5uREUFMTChQtRqVRa+5VKJWfPnqV37954eHgwZ84cveOpXbs21atX15qliI+PR61W07hxY53yarWa1atXExoaiqurK++88w7r1q3T7I+KiiI6OprMzEzNkqnw8HAArly5wsiRIwkODqZevXq0atWKNWvWkJubq9XHF198QbNmzXBzc8PX15devXpx8+ZNbt26xTvvvAPAiBEjdJZkzZs3jzZt2uDp6UlQUBCjRo3i3r17Wm3/+OOPdOvWDW9vbzw9PWnTpg27du3S7H92yVNCQgIjRozA398fNzc3QkJC+Oyzz/TGVAghhBDFx6S4ByDE69a6dWt27drFb7/9houLi2Z7bGwsdevW1VwtX7t2LXPnzqVnz55MmDCBK1euaBKKMWPGaLU5evRoOnXqxIABA7CwsCjUGGJjY+ndu7em72bNmlGqVCmdsp9++inbtm1j4MCB1KtXjzNnzjBv3jxKlSpFly5d6NixIwkJCcTGxrJ+/XoALC0tAbh37x7Ozs60adOGMmXK8MsvvxAVFUVmZiZDhw4FYPfu3SxevJjhw4fj4eFBeno6P/74I3///Tc1atQgOjqaoUOHMmrUKHx8fIAny8gAHjx4wIABA3B0dCQpKYm1a9cSHh7O3r17MTExISMjgwEDBuDt7c2CBQswMzPjjz/+IC0trcDYjBs3jnv37jFlyhTs7e25c+cOFy9eNBhTIYQQQhQPSSjEv46fnx92dnbs3btXk1A8fPiQgwcPak6yMzIyWLJkCX379mXUqFEABAQEYGpqyqxZs4iIiKBs2bKaNjt37kz//v0LPYawsDCioqK4ceMG9vb2HD58mKVLl+osl7px4wabNm1i+vTpdOrUCQB/f3+ysrJYunQpnTp1okKFClSoUAGFQoGHh4fOsfr5+QFPZjq8vb3Jyspi06ZNmmM9f/48SqVSa5bg6aVXtWvXBqBatWo67UdGRmp+VqlUeHp60qhRI06ePElgYCBXr14lPT2dUaNGoVQqNWPS58KFC4waNYpWrVpptrVr105vHUMUCiNMTGRC9lnGxgqtv4UuiZF+Eh/DJEb6SXwM+yfESBIK8a9jYmJCixYt+Oabbxg5ciTwZLnTw4cPad26NQBnz54lMzOTFi1akJOTo6mbdzL/+++/07BhQ832/JYq6VO9enXq1q1LbGwslSpVokyZMvj5+XHo0CGtcsePHwegefPmOuNYuXIld+7coVKlSgX28+jRI1asWMGePXu4c+cO2dnZmn1///03ZcqUoU6dOmzZsoXIyEiaNWtGvXr1MDU1LdRxxMfH8/nnn/P777+TkZGh2X7t2jUCAwOpWrUqlpaWfPzxx4SHh+Pr64udnZ3eNuvUqcOaNWswNjYmICCAatWqFWos+lhamr9wG28ya2vDs2r/dhIj/SQ+hkmM9JP4GFaSYyQJhfhXat26NVu2bOH8+fO4u7uzd+9e6tevT4UKFQBITk4GoH379vnWv3PnjtbrcuXKPfcYwsLC2LFjBxUrVqRly5YYGxvrlElOTkatVhf4hCpDCcXcuXPZtm0bQ4YMwdXVFSsrKw4cOMDnn3/Oo0ePKFOmDB06dODvv//mq6++Yt26dVhZWdGuXTvGjBmDuXnBJ+Lnz59n8ODBvPPOO/Tr1w97e3uMjIz44IMPePToEQA2NjasXbuWJUuWMG7cOFQqFfXr12fKlCmaGYtnLVy4kIULF7Jo0SKmT5+Os7Mzo0aNonnz5vrCqVdGRhbZ2SrDBf9ljI0VWFtbkJb2EJUq13CFfyGJkX4SH8MkRvpJfAwrrhhZW1sUelZEEgrxr+Tt7Y2TkxN79+7F2dmZI0eOMGnSJM1+GxsbAKKjozVJxtMqV678wmNo1aoVc+bM4c8//2Tz5s35lrGxscHIyIgtW7bkO2vg7Oyst4+4uDg6deqktRwrPj5eq4xCoaBnz5707NmTu3fvsnfvXubPn0/ZsmUZMmRIgW1///33WFpasmjRIhSKJ79wbt++rVPO3d2dVatWkZWVxalTp5g9ezZDhgzh+++/z7ddR0dHIiMjyc3N5eLFi3z++eeMHDmSuLg4qlSpovd4C5KbqyYnR/6jKohKlSvxMUBipJ/ExzCJkX4SH8NKcowkoRD/SkZGRrRq1YrY2Fhq1apFbm4uoaGhmv2enp5YWFiQkJBAs2bNXskYKlSoQM+ePUlKSsLLyyvfMnn3G6SkpBASElJgW6ampjx+/Fhn+6NHj7QSEZVKxd69ewtsp3z58vTp04fY2FjN067y6ufNOuTJysrC1NRU60vj9uzZU2Db5ubmBAcHc+PGDT799FMePXqU703oeRQKBe7u7nz44YccPHiQ69evFzmhEEIIIcSrIwmFeCOoVKp8vwnb3d29wDphYWGsXr2axYsXExAQoLW239ramuHDhzN37lwSEhJo2LAhxsbG3Lx5kwMHDhAVFVWopzkZMnHiRL37nZ2d6datG+PGjSMiIoJ69eqRnZ3NtWvXOHXqFMuWLQOgZs2a5OTksH79ejw9PbG0tKRGjRr4+/uzbds23nrrLcqWLcuWLVt0Eo9p06ZhbW2Nh4cH1tbWnDlzhl9//ZUuXboA4ODggLW1NXv37qVy5cqYmZmhVCoJCAhg/fr1fPLJJzRr1oyzZ8/yn//8R6vtw4cPs337dpo2bUrFihW5f/8+mzZtwsvLK99kIj09nYiICNq2bYuzszPZ2dls3LgRa2tr6tSp8yKhFkIIIcQrIgmFeCM8evSIESNG6GyfM2cO3t7e+dapU6cOzs7OXL16VecxsAB9+vShfPnyrF27lk2bNmFiYkLVqlVp3LhxoW9afhmmTJmCs7MzMTExLF26lDJlyuDs7EyLFi00ZZo0aULXrl354osvePDgAQ0aNGDjxo1MnTqVjz76iE8++QQLCwvat29Ps2bNmDJliqaup6cnX331Fdu2bePhw4dUqVKFiRMn0rFjR+DJTEFkZCQLFiygV69ePH78mAMHDhAcHMyYMWPYtGkTO3fuxMvLixUrVmjN9FStWhWFQsGiRYt48OABtra2BAYGap6c9axSpUrh4uLCxo0buXPnDubm5ri6urJ69WqDN3MLIYQQongYqdVqdXEPQgghXqWUlEy5KTsfJiYKypYtQ3Ly3yV2XW5xkxjpJ/ExTGKkn8THsOKKkZ1dmULflF1yH2grhBAviVw3EUIIIV4dSSiEEEIIIYQQRSYJhRBCCCGEEKLIJKEQQgghhBBCFJkkFEIIIYQQQogik4RCCCGEEEIIUWSSUAghhBBCCCGKTBIKIYQQQgghRJFJQiGEEEIIIYQoMkkohBBCCCGEEEUmCYV4raKiolAqlfn++eKLL15KH23btmXChAkvpa3COHXqFEqlkgsXLryU9g4cOECfPn1o2LAhrq6uhISEMG3aNK5evfpS2i+KX375haioKB4+fFjoOkqlktWrV7/CUQkhhBCiJDAp7gGIfx9zc3PWr1+vs93JyakYRvPi6tatS0xMDDVr1nzhtubNm8fKlSsJDQ3lk08+wc7Ojhs3brBjxw5GjhzJ7t27X3zARfDLL78QHR1Nt27dsLCwKFSdmJgYKlas+IpHVjhGRkbFPQQhhBDijSUJhXjtFAoFHh4exT2Ml8bS0vKlHE98fDwrV65k8ODBjBgxQrO9QYMGvPfeexw6dOiF+3gdsrKyMDc3L1HvsUIhCYUQQgjxqsiSJ1EiKZVKVq5cSVRUFP7+/vj4+DBx4kQyMzO1yp05c4YOHTrg5uZGWFgY8fHx+bZ39uxZevTogYeHB97e3owePZoHDx5o9t+6dQulUsnu3buZNm0a9evXx8/Pj7Vr1wKwd+9eQkND8fLyYujQoaSlpWnq5rfkKTc3l7Vr19KyZUtcXV0JCAhg+PDhpKenF3jMa9asoVy5cgwePDjf/U2aNNH8/OjRIyIjIwkMDMTNzY22bdvy3XffaZUPDw9nwIABWtt++eUXlEolp06d0mwzFOudO3cyceJEAPz8/FAqlYSEhGj2KZVKzp49S+/evfHw8GDOnDmadp9d8nT48GE6duyIu7s7vr6+fPTRR1rvaXZ2NrNnz6Zx48a4uroSGBjIwIED9cZNCCGEEMVLZihEscjJydHZZmKi/XHcvHkz3t7ezJo1i2vXrjFnzhzs7e0ZM2YMAImJiURERKBUKlm0aBFpaWlMnz6dzMxMateurWnn7NmzhIeHExwczMKFC3n48CGLFi1i8ODBxMTEaPW5aNEimjdvzuLFi/n++++ZNWsWSUlJ/PDDD4wdO5aMjAxmzpzJ3Llz+eSTTwo8vk8++YSYmBh69uxJQEAAf//9N4cPHyYzMxMrK6t843HmzBmaN2+OqampwfiNGTOGo0eP8uGHH1KjRg3+85//MGzYMJYuXco777xjsP6z9MW6cePGDBo0iM8//5xVq1ZhZWWFmZmZVv3Ro0fTqVMnBgwYUOCSqLi4OEaOHEmHDh0YNmwYiYmJzJ8/n7S0NBYuXAjAihUr2Lp1K2PGjKFWrVokJydz7NgxHj9+/NzHJIQQQojXQxIK8dplZmZSt25dne2bN2+mfv36mtcODg7Mnz8fgEaNGnHp0iX279+vSSjWr1+PkZERK1eu1JykV6hQgV69emm1O3/+fFxdXYmOjtaspXdxcdHMaAQHB2vKenh4MGnSJAB8fX359ttv2bRpEwcPHqRs2bIAXL58me3btxeYUFy9epUvv/ySkSNHas0QhIaGFhiTlJQUHj9+XKh7Dn799Ve+/fZbpk+fTufOnTXxuX37dpETCn2xtrOzo2rVqsCT+0Xs7Ox06nfu3Jn+/fsX2L5arWbOnDm0atWKTz/9VKvf/v37M3jwYGrVqsWFCxcIDAykW7dumjL64lZYCoURJiYyIfssY2OF1t9Cl8RIP4mPYRIj/SQ+hv0TYiQJhXjtzM3N2bRpk872GjVqaL329/fXel2zZk327t2ref3TTz/h4+OjdcXfz88PW1tbzeuHDx9y5swZxo0bh0ql0myvXr06Tk5OXLhwQSuhCAgI0PxsbGxMlSpVMDIy0iQTeXXT0tL4+++/KVOmjM5xnDx5ErVazfvvv68vDPkqzM3DP/74IwAtWrTQ2t6yZUsiIyPJzMykdOnSz9WvoVgb0rhxY737r169yu3bt5k0aZLW7FTDhg1RKBRcvHiRWrVqUadOHVavXk1UVBTBwcG4urqiULz4L1BLS/MXbuNNZm1duBvt/80kRvpJfAyTGOkn8TGsJMdIEgrx2ikUCtzc3AyWs7a21nptamqqtfQlMTGRatWq6dR7+gp6WloaKpWKyMhIIiMjdcreuXNH6/Wzy5FMTU11Ts7zliQ9evQo34QiJSUFExMT7O3tCzo0Hba2tpQqVYq//vrLYNnU1FRMTU21EieAcuXKoVarSU9Pf+6EwlCsDSlXrpze/cnJyQAMGTIk3/1578OgQYNQKBTs2rWL6Oho7Ozs6NatG0OGDHmhJzVlZGSRna0yXPBfxthYgbW1BWlpD1Gpcot7OCWSxEg/iY9hEiP9JD6GFVeMrK0tCj0rIgmF+MdycHDQurE6T1JSkuZnKysrjIyMGDBgAE2bNtUp+/TMw8tia2tLTk4ODx48KHRSYWJigpeXFydPniQnJ0fnfpKn2djYkJ2dTWpqKjY2Nprt9+/fx8jISJMUmZmZkZ2drVU3NTW1CEf04vKSn2nTpuHu7q6z39HREXgy5mHDhjFs2DCuX7/Ojh07iIqKonLlyrRr167I/efmqsnJkf+oCqJS5Up8DJAY6SfxMUxipJ/Ex7CSHKOSuxhLCAPc3d05deqU1hOATpw4QUpKiuZ16dKl8fDw4M8//8TNzU3nT+XKlV/6uHx9fTEyMmLHjh3PVa93794kJiayfPnyfPfnPcHK29sbeHKT89Pi4uKoU6eOZnaiQoUKXL16FbVarSlz7Nix5xpTnrxZmaLeHF2jRg0qVKjAzZs3830fypcvr1OnWrVqjBo1CltbW/78888i9SuEEEKIV09mKMRrl5uby7lz53S229vbU6VKlUK307NnT7Zs2UK/fv3o168faWlpREVF6SwFGjduHD179uTDDz+kdevWWFtbk5CQwPHjx+nQoQM+Pj4veETanJ2d6dy5M4sXLyY1NRU/Pz+ysrI4fPgww4YNy/fkGSA4OJi+ffsSFRXFH3/8QevWrSlbtiy3bt1ix44dpKenExwczNtvv03z5s2ZNWsWWVlZODs78/XXX3P27FmWLVumaS80NFRz83jTpk05c+YM+/fvL9Ix5X1p3+bNm2natCnm5uYolcpC1zcyMmLChAmMGTOGzMxMGjdujIWFBX/99Rfx8fGMHDkSZ2dnBg8eTN26dalTpw4WFhYcOnSI1NRUfH19izRuIYQQQrx6klCI1y4rK4tOnTrpbH///fe1ngBkiKOjIytXrmTmzJmMGDGCqlWrMm3aNM0jSPN4eXmxZcsWoqKimDhxItnZ2VSoUAFfX99878F4GaZNm0blypXZtm0b69evx9bWlgYNGuR7z8XTxo4di6enJ5s3b2bSpEk8fPgQR0dHAgMDiYiI0JSbO3cuCxYsYOXKlaSkpFCjRg2WLFmi+X4IePK0prFjx7Jp0yZ27dpFo0aNmD59us5TsAqjTp06DBs2jG3btrFq1SqcnJw4ePDgc7XRsmVLrK2tWb58OXv27AGgUqVKBAUFae7B8PLyYt++faxduxaVSoWzszPz5s3TuWlcCCGEECWHkfrp9RBCCPEGSknJlJuy82FioqBs2TIkJ/9dYtflFjeJkX4SH8MkRvpJfAwrrhjZ2ZUp9E3Zcg+FEOKNJ9dNhBBCiFdHEgohhBBCCCFEkUlCIYQQQgghhCgySSiEEEIIIYQQRSYJhRBCCCGEEKLIJKEQQgghhBBCFJkkFEIIIYQQQogik4RCCCGEEEIIUWSSUAghhBBCCCGKTBIKIYQQQgghRJFJQiGEEEIIIYQoMkkoitm7776LUqnk9OnTOvtOnTqFUqnkwoULr6RvpVLJ6tWrX0nb+dm5cyd79ux5bf2VJLdu3UKpVBIXF1fcQymS4cOHM3v2bM3rCRMmEBYWlm/ZTz/9lJCQEJ3tGRkZuLq6cvr06ULFo3fv3nz++ecvPnjAyMjopbQjhBBCCF2SUBSj33//ncuXLwMUy4l2TEwMbdq0eW397dq1i9jY2NfWX0ni6OhITEwMvr6+xT2U5/bzzz9z6NAhevXq9ULtHDt2jDJlyuDp6Vmo8gMGDGDNmjWkpqa+UL8ACoUkFEIIIcSrIglFMdqzZw8KhQIfHx/i4uLIzs5+rf17eHjg6Oj4WvssDJVK9dpj8aqZmZnh4eGBra1tcQ/luW3YsIHAwEDKly//Qu0cPnyYwMBAjI2NC1Xe19cXa2trdu3a9UL9CiGEEOLVkoSimKjVamJjY/H19aV3796kpKRw9OhRg/XWrFnDe++9h7e3N35+fgwYMICrV69qlclbjnLq1CnatWuHh4cH77//PhcvXtQq9+ySp/DwcAYMGEBcXByhoaF4enrSo0cPbty4oVXv8ePHLFiwgCZNmuDq6krLli0NzrCEh4fzww8/cPjwYZRKJUqlkqioKK1+d+3aRWhoKG5ubvz666/cu3ePiRMn8s477+Du7k7z5s1ZsGABjx8/1jmOlStXEhUVhb+/Pz4+PkycOJHMzExNmbS0NKZMmUJQUBBubm4EBwczcuRIzf7n6euLL75g4cKF+Pn5Ub9+febMmYNarebEiRO0bdsWT09PevbsyZ07dzT18lviExISwowZM9i8eTNNmjTB29ubwYMHk5SUpCmTmZnJjBkzCA0NpV69eoSEhDBt2jTS09O1xnXgwAE6dOiAp6cn9evXp0OHDsTHx2uV2blzJ23atMHNzY2goCAWLlyISqXS+75lZmby7bffEhoaqrecIbm5ucTHx+e7FEqfFi1asHv37hfqWwghhBCvlklxD+Df6syZM9y+fZshQ4YQGBiIra0tsbGxBk+4EhIS6N69OxUrViQjI4OtW7fSuXNn9u/fr3X1OzExkZkzZ9K/f3+srKyYP38+Q4cO5bvvvsPU1LTA9n/55ReSkpIYM2YMKpWKWbNmMXbsWGJiYjRlRowYwZkzZxgyZAg1a9YkPj6esWPHYm1tTXBwcL7tfvTRR4wdOxZzc3PGjx8PQIUKFTT7L168yO3btxkxYgTW1tY4OTnx4MEDbG1tmThxItbW1ly7do2oqCgSExOJjIzUan/z5s14e3sza9Ysrl27xpw5c7C3t2fMmDEAREZGcvToUUaPHk2lSpVITEzkyJEjmvrJycnP1VfDhg2ZM2cOP/30E1FRUeTm5nLs2DEGDRqEqakpM2fOZPLkyaxZs0bv+3nw4EGuX7/OtGnTSE5OJjIykk8++YSFCxcCkJWVhUqlYuTIkdjZ2XHnzh2WL1/O4MGD2bhxIwA3btxgxIgRtG7dmtGjR5Obm8uvv/6qtVRo7dq1zJ07l549ezJhwgSuXLmiSSjyYpSfc+fOkZmZibe3t97jMOT8+fOkpqYSFBT0XPU8PT1ZtWoVSUlJ2NnZFbl/hcIIExO5fvIsY2OF1t9Cl8RIP4mPYRIj/SQ+hv0TYiQJRTGJjY2lVKlSNG/eHFNTU0JDQ/n666/5+++/KVOmTIH1Jk2apPlZpVIREBCAn58f+/fvp1OnTpp9qampbNq0iVq1agFgYWFBjx49+Omnn6hfv36B7aenp7N7927NyVtmZiYTJ04kISGBChUqcPLkSQ4ePMjq1asJDAwEICAggMTERKKiogpMKN566y0sLS0pXbo0Hh4eOvtTU1PZvn07Tk5Omm3lypXTJB8AXl5eWFhYMGHCBKZNm4aFhYVmn4ODA/PnzwegUaNGXLp0if3792tOli9cuEBYWBjt27fX1GndurXmZ6VSWei+HB0dmTt3LgBBQUEcPHiQdevWsXfvXmrWrAnA3bt3+eSTT0hLS8Pa2rrAeKvVaj7//HPMzMwAuH37NitWrCA3NxeFQoGdnR3Tp0/XlM/JyaFy5cp07dqVq1ev4uzszKVLl8jOzmbq1KlYWlpqxpUnIyODJUuW0LdvX0aNGgU8ec9MTU2ZNWsWERERlC1bNt/xXbhwgdKlS1OlSpUCj6EwDh06hJeXl95Y5Oftt98GniQkjRs3LnL/lpbmRa77b2BtbWG40L+cxEg/iY9hEiP9JD6GleQYSUJRDHJycoiLiyM4OBgrKysA2rRpQ0xMDN999x3t2rUrsO65c+dYvHgxly5dIiUlRbP92rVrWuUcHR01yQQ8OaGHJye6+rz99ttaV4Lz6uUlFMeOHcPW1hZfX19ycnI05fz9/fn4449RqVSFXiP/NBcXF61kAp6cbK9fv56vvvqKW7du8ejRI82+mzdv4uLiotX/02rWrMnevXs1r+vUqcOuXbtwcHAgKChIq+6L9uXs7Mz9+/c1yQRA9erVgSdx03cS3aBBA00ykTfu7OxsHjx4gIODAwC7d+9m3bp1XL9+XWsZ17Vr13B2dkapVGJsbMyYMWP44IMPaNCggeZzBXD27FkyMzNp0aKFznuWlZXF77//TsOGDfMdX2JiYoHJxvM4fPgwbdu2fe56eX0nJia+UP8ZGVlkZ+tf3vVvZGyswNragrS0h6hUucU9nBJJYqSfxMcwiZF+Eh/DiitG1tYWhZ4VkYSiGBw7doykpCSaNGlCWloa8OSE2sHBgdjY2AITir/++os+ffrg6urK9OnTcXR0xNTUlAEDBmidAAM6J7F5y5yeLfcsQ/WSk5NJSUmhbt26+dZPTEzUWspUWOXKldPZtn79embPnk3fvn3x8fHB2tqaCxcuMGPGjEId79P3P0ydOhUbGxvWrl3LnDlzcHJyon///nTt2vWl9PWy4p2XXOTV++677xg/fjydOnVi5MiR2NrakpiYyJAhQzRlnJ2dWb58OStWrGDo0KEoFAoCAwOZNm0aFStWJDk5GUBrduZpT9/r8axHjx5pJTx5jI2NC7z/Ijc3FxOT///VcufOHX799VfNMq7nkdd3VlbWc9fVHpOanBz5j6ogKlWuxMcAiZF+Eh/DJEb6SXwMK8kxkoSiGOTdwDxx4kQmTpyotS85OZkHDx5gb2+vU+/o0aNkZmYSHR2tORHNycl5KY/VLCwbGxvs7Oz44osv8t1f1HXu+X1PQFxcHCEhIYwePVqz7cqVK0Vq38rKismTJzN58mQuX77Mhg0bmD59Oi4uLtSvX/+l9vUyxcXFUbt2bWbMmKHZ9sMPP+iUa9SoEY0aNSIjI4MjR44QGRnJxIkTWb9+PTY2NgBER0fnm+xVrly5wP5tbGx0bgCHJ+/z/fv3861z7949rc/BoUOHqFatGjVq1Cj4QAuQ1/c/8elYQgghxL+FJBSv2cOHDzlw4ABNmzalR48eWvvu37/PqFGj+OabbwgPD9epm5WVhZGRkdbV33379mktY3nV/P39WbVqFaamppr17YVlampq8Ir907KysnRuIH8Z39ehVCqZOHEi27dv58qVK9SvX/+V9fWinndclpaWtGrVivPnz2u+88PT0xMLCwsSEhJo1qzZc/Xv7OxMUlISmZmZlC5dWrO9QYMGfPHFF/zvf/+jQYMGmu0ZGRmcOnVK636ew4cP06RJk+fqN8+tW7c04xBCCCFEySQJxWt24MABMjMzCQ8Px8fHR2f/qlWriI2NzTehyPtStIkTJ9K5c2d+//131q5d+9w3ur6IgIAAmjRpQt++fenbty9KpZKHDx/yxx9/cP36dT799NMC69aoUYPdu3dz8OBBHBwccHR01PvdBv7+/mzYsIFNmzZRvXp1vv76a65fv16kcXfu3JlmzZpRq1YtjI2N2b17N6amppob1F9mXy+Tv78/M2bMYOnSpXh6ehIfH8+JEye0ymzdupVz584RFBSEg4MDt27d4uuvvyYgIAB4sqxq+PDhzJ07l4SEBBo2bIixsTE3b97kwIEDREVFad10/jQvLy9yc3O5dOmS1s38gYGB1K9fn6FDhzJkyBBq1arFvXv3WLVqFQqFQvP5ffjwISdPnqR37975tv/TTz/pbCtXrpymr4sXL1K6dGlq1679/METQgghxGshCcVrFhsbS8WKFfNNJgDatWvHZ599pvPdD/DkynpkZCTR0dEMGDCA2rVrs3jxYj788MNXPGptS5Ys4YsvvuDLL7/k9u3bWFlZUatWLTp06KC3Xr9+/bhx4wbjx48nLS2NoUOHMmzYsALLDxkyhOTkZJYsWQJAaGgoU6ZMYeDAgc89Zi8vL3bv3s2tW7dQKBS4uLiwfPlyzY3UL7Ovl6lz587cunWLTZs2aZ6sNX/+fD744ANNGaVSyaFDh4iMjCQlJQUHBwdat27NiBEjNGX69OlD+fLlWbt2LZs2bcLExISqVavSuHFjvY8RdnZ2xsXFhaNHj2olFAqFghUrVrBkyRLWrl3LvXv3sLS0xNfXl6ioKM0XJh4/fhwzM7MCnyyW32N1/fz8WLduHQBHjhyhWbNmRbrR/2m5ueoXqi+EEEKIghmp1Wr5n1YIUaCNGzeyYcMGvv3223zvddFn6tSppKWlsXjx4ufuNzU1lYCAANauXau1rKookpP/LrE3shUnExMFZcuWkfjoITHST+JjmMRIP4mPYcUVIzu7MoV+ylPJ/YYMIUSJ0LFjR7Kysjh48OBz1/3kk0+KlEzAk0TGy8vrhZMJIYQQQrxaklAIIfQyNzdn1qxZZGdnv9Z+bW1tmTJlymvtUwghhBDPT+6hEEIYlHeD9+vUvXv3196nEEIIIZ6fzFAIIYQQQgghikwSCiGEEEIIIUSRSUIhhBBCCCGEKDJJKIQQQgghhBBFJgmFEEIIIYQQosgkoRBCCCGEEEIUmSQUQgghhBBCiCKThEKIf5gDBw7Qp08fGjZsiKurKyEhIUybNo2rV68CoFQqWb16dZHbj4qKwtPT82UNt0T0ZWRk9Mr7EEIIIf6t5IvthPgHmTdvHitXriQ0NJRPPvkEOzs7bty4wY4dOxg5ciS7d+8mJiaGihUrFvdQC6Vjx44EBwe/8n4UCkkohBBCiFdFEgoh/iHi4+NZuXIlgwcPZsSIEZrtDRo04L333uPQoUMAeHh46G1HpVKRm5uLqamp1na1Wk12dvZLH7c+FSpUoEKFCq+1TyGEEEK8XLLkSYh/iDVr1lCuXDkGDx6c7/4mTZoAukuewsPDGTBgALt27SI0NBQ3Nzd+/fVXJkyYQFhYGPHx8bz77ru4ublx8OBBTb3Lly/TpUsX6tWrR1hYGEePHtXqLzc3l2XLlhESEoKrqystWrRg69atWmUSEhIYMWIE/v7+uLm5ERISwmeffabZ/+ySp+zsbGbPnk3jxo1xdXUlMDCQgQMHkp6eXvTACSGEEOKVkhkKIf4BcnJyOHPmDM2bN9eZWSiMixcvcvv2bUaMGIG1tTVOTk4A3Lt3j5kzZzJo0CCcnJyoWLEiv//+O9nZ2YwZM4YePXowePBgVq5cyfDhwzl48CBly5YFYM6cOWzYsIFBgwbh6enJ4cOH+eijj8jJyaF79+4AjBs3jnv37jFlyhTs7e25c+cOFy9eLHCcK1asYOvWrYwZM4ZatWqRnJzMsWPHePz4cRGiJoQQQojXQRIKIf4BUlJSePz4cZHvjUhNTWX79u2aROLp7StXrqRevXpa2/MSirz7G5ydnXnnnXc4cuQIbdu2JSkpiU2bNhEREcGwYcMACAwMJDk5maVLl9KlSxeMjY25cOECo0aNolWrVpq227VrV+A4L1y4QGBgIN26ddNsCw0NLdIxP02hMMLERCZkn2VsrND6W+iSGOkn8TFMYqSfxMewf0KMJKEQ4h+kqE8rcnFx0UkmAGxtbXWSCQCFQoGfn5/mdeXKlTE3N+fu3bsAnD9/nuzsbFq0aKFVr2XLlsTGxnLt2jVq1qxJnTp1WLNmDcbGxgQEBFCtWjW946xTpw6rV68mKiqK4OBgXF1dUShe/BeopaX5C7fxJrO2tijuIZR4EiP9JD6GSYz0k/gYVpJjJAmFEP8Atra2lCpVir/++qtI9cuVK/dc283NzTEzM9PaZmpqyqNHj4AnMxv51c97nZKSAsDChQtZuHAhixYtYvr06Tg7OzNq1CiaN2+eb7+DBg1CoVCwa9cuoqOjsbOzo1u3bgwZMuSFHv2akZFFdraqyPXfVMbGCqytLUhLe4hKlVvcwymRJEb6SXwMkxjpJ/ExrLhiZG1tUehZEUkohPgHMDExwcvLi5MnT5KTk4OJyfP90y3oZLyoJ+m2trYAPHjwgPLly2u2379/X2u/o6MjkZGR5ObmcvHiRT7//HNGjhxJXFwcVapU0WnXzMyMYcOGMWzYMK5fv86OHTuIioqicuXKepdKGZKbqyYnR/6jKohKlSvxMUBipJ/ExzCJkX4SH8NKcoxK7mIsIYSW3r17k5iYyPLly/PdHx8f/9rG4ubmhqmpKXFxcVrb9+3bh729PdWrV9farlAocHd358MPPyQnJ4fr168b7KNatWqMGjUKW1tb/vzzz5c5fCGEEEK8RDJDIcQ/RHBwMH379iUqKoo//viD1q1bU7ZsWW7dusWOHTtIT09/LV8SB2BnZ0f37t1ZvXo1ZmZmeHh4EB8fT2xsLFOnTsXY2Jj09HQiIiJo27Ytzs7OZGdns3HjRqytralTp06+7Q4ePJi6detSp04dLCwsOHToEKmpqfj6+r6W4xJCCCHE85OEQoh/kLFjx+Lp6cnmzZuZNGkSDx8+xNHRkcDAQCIiIl7rWMaNG4eVlRXbt29n+fLlVKpUienTp9O5c2cASpUqhYuLCxs3buTOnTuYm5vj6urK6tWrsbOzy7dNLy8v9u3bx9q1a1GpVDg7OzNv3jz8/f1faKy5ueoXqi+EEEKIghmp1Wr5n1YI8UZLTv67xK47LU4mJgrKli0j8dFDYqSfxMcwiZF+Eh/DiitGdnZlCn1TttxDIYQQQgghhCgySSiEEEIIIYQQRSYJhRBCCCGEEKLIJKEQQgghhBBCFJkkFEIIIYQQQogik4RCCCGEEEIIUWSSUAghhBBCCCGKTBIKIYQQQgghRJFJQiGEEEIIIYQoMkkohBBCCCGEEEVWIhOK+Ph4+vXrh6+vL3Xr1sXf35/+/fsTGxtLbq58LTvAhAkTCAsLe+56O3fuZM+ePa9gRC8uKioKT09PvWV++eUXoqKiePjw4Wsa1fNJSUlhyJAhNGjQAKVSyffff1/cQ3opLl++jKenJ0lJSQDcunULpVJJXFycTtm0tDSUSiU7d+7U2bdgwQJ69uwJGP4M//jjj/j4+JCRkfHC4zcyMnrhNoQQQgiRvxKXUCxYsID+/ftTqlQppk2bxrp165g6dSpWVlaMHTuWY8eOFfcQ/9F27dpFbGxscQ+jyH755Reio6NLbEKxdu1aTp06xaxZs4iJiaFBgwbFPaSXYtGiRXTo0AE7O7sXaufQoUM0adKkUGW9vb2pVasWa9aseaE+ARQKSSiEEEKIV8WkuAfwtMOHD7NixQqGDh3KsGHDtPa1bNmSnj17YmJSooYsSrCsrCzMzc1fa59Xr15FqVTyzjvvvHBbxTH+/Ny8eZNDhw7lO+PwPG7fvs1vv/1G48aNC13n/fffZ/bs2QwaNAhTU9MX6l8IIYQQr0aJmqFYu3YtDg4ODBo0KN/97u7u1KlTR/P68OHD9O7dGz8/P7y8vOjYsSNHjhzRqrNz506USiUXLlygT58+1KtXj9DQUI4fP05ubi4LFy7E398ff39/5s+fr7WkKm8JzqVLl+jUqRPu7u60b9+eS5cu8ejRIz766CMaNGhAo0aNWLdunVa/Z8+eZeDAgQQGBuLh4UHbtm3ZvXt3oeJw+vRp2rVrh5ubG23atOHYsWO0bduWCRMmFFinoOVC9evXJyoqCoDw8HB++OEHDh8+jFKpRKlUava9ylhevnwZpVKpM7ukUqkICgpizpw5hYrLzp07mThxIgB+fn4olUpCQkK0xnb27Fl69+6Nh4eHpt01a9bw3nvv4e3tjZ+fHwMGDODq1atabectvzl16hTt2rXDw8OD999/n4sXL2qV2759O61bt8bd3R0fHx+6dOnC+fPnAVAqlezfv5/Tp09r4pvn7Nmz9OjRAw8PD7y9vRk9ejQPHjzQ7M9bQrRz506mTJmCj48PHTt2LPR7k5aWxpQpUwgKCsLNzY3g4GBGjhypVSYhIYExY8bg4+ODu7s73bp10zm+/OzevZsqVapo/dsrisOHD+Ps7Ez16tULXadp06akp6cTHx//Qn0LIYQQ4tUpMZf7c3JyOHPmDKGhoYWehbh16xZNmjShT58+KBQKjhw5Qv/+/Vm/fj0+Pj5aZcePH0/nzp3p3bs3X3zxBUOHDqV9+/ZkZGQwe/ZsfvrpJ6KionBxcaFNmzaaetnZ2YwfP55evXpRrlw55s2bx9ChQ/Hy8sLe3p5FixZx4MABIiMjcXd3x8vLC4C//voLLy8vunTpgpmZGWfOnGHKlCmo1Wrat29f4DHdu3ePfv36UadOHRYtWkR6ejoff/wx6enp1K5duwiR/X8fffQRY8eOxdzcnPHjxwNQoUKFVx5LpVJJvXr12LFjBwEBAZp2jh49yr1793jvvfcKNf7GjRszaNAgPv/8c1atWoWVlRVmZmZaZUaPHk2nTp0YMGAAFhYWwJMT6e7du1OxYkUyMjLYunUrnTt3Zv/+/dja2mrqJiYmMnPmTPr374+VlRXz589n6NChfPfdd5iamvK///2PyZMn06dPH4KDg8nKyuL8+fOkp6cDEBMTw7x58/j777/56KOPNO2ePXuW8PBwgoODWbhwIQ8fPmTRokUMHjyYmJgYrfEvWLCA4OBgrYSsMO9NZGQkR48eZfTo0VSqVInExEStpCM1NZWuXbtSunRpzRLCjRs30rNnT7799lvs7e0LjPvx48cN3ttSGAcPHiz0cqc8lpaWvPXWWxw/fpymTZu+8BiEEEII8fKVmIQiJSWFx48f4+TkpLVdrVajUqk0rxUKBQrFk4mV7t27a7bn5ubi4+PDH3/8wVdffaVzEty9e3e6du0KQPny5WnTpg0XL17UnNAFBQVx8OBB4uLidBKKMWPGEBwcrOln4MCB1KtXT3O13NfXl7i4OOLi4jQJRevWrbWOoUGDBty9e5eYmBi9CcW6deswNjZmxYoVWFpaAlC5cmW6detWmDDq9dZbb2FpaUnp0qXx8PDQ2veqY9mxY0c++eQTUlNTsbGxAWDHjh14enpSs2bNQo3fzs6OqlWrAlC3bt181/N37tyZ/v37a22bNGmS5meVSkVAQAB+fn7s37+fTp06afalpqayadMmatWqBYCFhQU9evTgp59+on79+pw/fx5bW1tNMgZoLd/x8PDA2toaIyMjrfjOnz8fV1dXoqOjNTcHu7i4EBYWRnx8vOazBfD222/z6aefao2/MO/NhQsXCAsL0/psPf0ZXL9+PWlpaWzbtk2TPPj5+REaGsrq1asZN26cTizhyWf34sWLL3wyn5mZyQ8//KDz3hTG22+/zU8//fRC/SsURpiYlKgJ2RLB2Fih9bfQJTHST+JjmMRIP4mPYf+EGJWYhCLPs09j2b9/PyNGjNC87tatG9OmTQOeXHleuHAhx48fJzExEbVaDTw52XzW01fG85Zc+Pr6apVxdnbWWQqjUCjw8/PTqevv76/ZZmxsTNWqVUlISNBsS01NJSoqigMHDnD37l1NUvT0FfH8XLhwAR8fH00yAU+WLRmq96JedSxbt25NZGQksbGxdOvWjaSkJA4dOsTHH3/8Uo8jv/X5586dY/HixVy6dImUlBTN9mvXrmmVc3R01CQT8CQBA7h79y4AderUISUlhQkTJtCmTRu8vLw0syAFefjwIWfOnGHcuHFaiXH16tVxcnLiwoULWglFfuMvzHtTp04ddu3ahYODA0FBQbi4uGi1cezYMXx8fLCxsSEnJwd48tlu0KABFy5cKHD8qampPH78+IVvxj5+/Djm5uZ4e3s/d92yZcuSmJj4Qv1bWhb/vSglmbW1/s+xkBgZIvExTGKkn8THsJIcoxKTUNja2mJmZqZ1Ug5PrqJu374dQOveitzcXAYNGkR6ejrDhw+nWrVqWFhYsGTJEu7cuaPTvpWVlebnvGUy1tbWWmVMTU15/Pix1jZzc3OtZTV5N4Y+3V7e9kePHmleT5gwgbNnzzJkyBDNzMCXX37Jvn379MYhMTEx3zXmL3pCp8/riGXp0qUJCwtj+/btdOvWja+//hpTU1Natmz5Uo+lXLlyWq//+usv+vTpg6urK9OnT8fR0RFTU1MGDBig9X4VdAyAppyfnx9z5sxhw4YNREREUKpUKUJDQ5k0aVKBCV9aWhoqlYrIyEgiIyN19j8b32eXHhX2vZk6dSo2NjasXbuWOXPm4OTkRP/+/TUzScnJyZw7dy7fBDFv1ic/ecf+7NKyvGWJ+T3GOS9xenrp4sGDBwkKCirSQxXMzMx03qvnlZGRRXa2ynDBfxljYwXW1hakpT1EpZJHcudHYqSfxMcwiZF+Eh/DiitG1tYWhZ4VKTEJhYmJCV5eXpw4cQKVSoWxsTEANjY2uLm5AdonNdevX+fSpUssXbpUazlGVlbW6x14Ph49esThw4eZMGEC4eHhmu1btmwxWNfBwUHzrP+n5bftaaVKlSI7O1trW3Z2NpmZmQb7fF2x7NixIzExMfz666/s3LmTli1bUqZMmZfax7OOHj1KZmYm0dHRmoQhJyeH1NTUIrXXtm1b2rZtS1JSkubeGRMTEz777LN8y1tZWWFkZMSAAQPyXTZUtmxZrdfPztAV9r2xsrJi8uTJTJ48mcuXL7NhwwamT5+Oi4sL9evXx8bGhqCgIK3ZvjzPJgtPy0uU0tLSdLYrFIp8Zw7u3bsH/H9ypFarOXLkSIHLqgxJS0t74Rm63Fw1OTnyH1VBVKpciY8BEiP9JD6GSYz0k/gYVpJjVKIWY/Xu3Zt79+6xfPlyg2Xzrlg+/SjJ27dvc/bs2Vc2vsJ6/Pgxubm5WmPLyMjg4MGDBuu6ublx8uRJrS/zOn36tNZSnfyUL1+e7Oxsbty4odl28uRJrWU2oDuTAq8vlm5ubtSuXZuZM2dy+fLlQt+M/bS8MT47k1SQrKwsjIyMtK6M79u3T7Psp6js7Ozo2LEjAQEB/PnnnwWWy7tf5c8//8TNzU3nT+XKlfX2U5T3RqlUau7vuXLlCvBkid6VK1eoWbOmzhiefhrVs0qVKkXFihW5deuW1nZzc3Pc3Nw4cOCATp3vv/+eUqVKaS4EXLhwgaSkJBo1aqT3WAty+/ZtnJ2di1RXCCGEEK9eiZmhgCfrx/v378+SJUv49ddfadmyJY6OjqSnp3P69GkSExM1V7Rr1KhBhQoVNE/DyczMZMmSJTg6OhbzUTy5Wuzm5sbKlSuxs7PDxMSEL774AktLS4MzDb169eLLL79kwIABREREkJaWxtKlSylbtqzeb/tt1KgRpUuXZsqUKfTr14+EhAQ2bNhAqVKltMrVqFGD3bt3c/DgQRwcHHB0dHytsezYsSMzZszA2dm5SOvp827g3rx5M02bNsXc3FzvCXHevR0TJ06kc+fO/P7776xdu1ZneVNhLFmyhJSUFBo2bIi9vT2//fYbR48epVevXnrrjRs3jp49e/Lhhx/SunVrrK2tSUhI4Pjx43To0EHnpvenFfa96dy5M82aNaNWrVoYGxuze/duTE1NqV+/PvDkc7Vnzx66d+9Ojx49qFixIklJSfz000+UL19e7zF4eXnx888/62wfNmwY/fv3Z+jQobRt25ZSpUpx8uRJ1q1bR79+/TQxPnToEJ6envnOMmRkZOT7bds+Pj6a2ZuLFy/Su3fvAscnhBBCiOJVohIKePLYT29vbzZv3sz06dPJyMjAxsaGunXr8tlnn2meXGNmZkZUVBQzZsxgxIgRODk5MWjQIE6ePFmoZ+u/avPnz2fatGlMmDABW1tbwsPDyczMNPitv46OjqxcuZKZM2cyfPhwqlatyuTJk5kxY4bOfRtPK1u2LEuWLGH27NkMGTKE2rVrM2fOHK0lVwD9+vXjxo0bjB8/nrS0NM2XCL6uWDZr1owZM2YUaXYCntx8PGzYMLZt28aqVatwcnLSO/OjVCqJjIwkOjqaAQMGULt2bRYvXsyHH3743H27ubmxfv169u3bR0ZGBhUqVCAiIqLA703J4+XlxZYtW4iKimLixIlkZ2dToUIFfH19qVatmt66hf2ce3l5sXv3bm7duoVCocDFxYXly5drErCyZcsSExPDokWLmDdvHikpKdjb21OvXj2aNWumdwyhoaGMGTOGjIwMrYcFBAUFsWrVKj7//HPGjRtHdnY21atXZ+LEiVpPpjp8+DCtWrXKt+07d+7kuwxr8+bN1K9fn59//pmkpCRCQ0P1jtGQ3Fz1C9UXQgghRMGM1HmPjBEl1rVr12jZsiWfffaZ3kfO/hNs376djz76iMOHD+Pg4FDcwxGFkJ2dTZMmTRgzZgzt2rV7rrp3796lUaNG7N27V/PUrOcxe/Zsfv75ZzZs2PDcdZ+WnPx3iV13WpxMTBSULVtG4qOHxEg/iY9hEiP9JD6GFVeM7OzK/PNuyhb/b/78+SiVShwdHbl58yYrVqzAwcGB5s2bF/fQiuzWrVtcv36dZcuW0bJlS0km/kFMTU3p168fGzZseO6Eonz58ly+fLlI/WZkZLB9+3aWLVtWpPpCCCGEeD0koSiBsrOzmTdvHvfv38fc3JyGDRsybty4V/5EpFcpOjqa2NhYPD09mTBhQnEPRzynLl26kJGRQVJS0it9hPHT/vrrL0aMGEGDBg1eS39CCCGEKBpZ8iSEeOPJVHr+ZKmBYRIj/SQ+hkmM9JP4GPZPWPJUoh4bK4QQQgghhPhnkYRCCCGEEEIIUWSSUAghhBBCCCGKTBIKIYQQQgghRJFJQiGEEEIIIYQoMkkohBBCCCGEEEUmCYUQQgghhBCiyCShKMGioqLw9PR87n2vy6lTp1i+fLnO9mfHduvWLaKiorh7965OfaVSyYULF15oHEqlUuuPv78/AwcOLPQ3NKvVanbt2kXXrl3x9vbG1dWV0NBQZs2apTPm4jRz5kyUSiVLly4tchu//PILUVFRPHz4UGv7zp07USqVJCUlAU/eM6VSSVxc3AuNWZ9169ahVCpfWftPMzIyei39CCGEEP9GklCIIvvhhx9YsWKFzvaOHTuyfv16zevbt28THR3NvXv3tMrVrVuXmJgYatas+cJjCQ8PJyYmhq1btzJ16lQSEhKIiIggLS1Nbz21Ws3o0aOZNGkSzs7OzJ07lzVr1tCzZ0+OHz/OjBkzXnhsL4NKpWLfvn0AxMbGFrmdX375hejoaJ2EonHjxsTExGBtbf1C4yypFApJKIQQQohXxaS4ByDePBUqVKBChQoGy1laWuLh4fFS+nRyctJqy9nZmbZt23L27FmCg4MLrLdlyxb27t3Lp59+yvvvv6/Z3rBhQzp16sR///vfFxqXSqUiNzcXU1PTF2rnxIkT3L9/H39/f44fP87PP/9M3bp1X6jNp9nZ2WFnZ/fS2hNCCCHEv4fMULxBHj9+zIIFC2jSpAmurq60bNmSPXv2aJWZMGECYWFhxMfHExYWhpubGx06dODcuXNa5Xbv3k2XLl1o2LAhDRo0IDw8nPPnz2v2R0VFER0dTWZmpmapUXh4uGZf3pKnU6dO0aNHDwDef/99Tdm8fc8uedq+fTutW7fG3d0dHx8funTpotVvYZUpUwaA7OxsveXWrl1L3bp1tZKJPMbGxlrJSEpKChMnTsTHxwd3d3c6d+7M//73P6064eHhDBgwgF27dhEaGoqbmxu//vorAIcPH6Zjx464u7vj6+vLRx99RGZmZqGOJzY2ljJlyjBr1ixMTU113ld4svRr5cqVREVF4e/vj4+PDxMnTtT0sXPnTiZOnAiAn58fSqWSkJAQzb6nlzzlefjwIZMmTcLb25uGDRsSGRlJTk6OVpnLly8TERGBh4cH3t7eDB8+nL/++kurTEZGBuPGjcPT0xNfX1/mzJmDSqXS7M/OziYgIICFCxfqHNeHH36Y7/sjhBBCiJJBZij+AZ49gQPIzc3V2TZixAjOnDnDkCFDqFmzJvHx8YwdOxZra2utE+PExESmT5/OsGHDsLa2ZuXKlURERPDtt99ib28PPFlD365dO6pWrcrjx4/Zu3cv3bp14+uvv8bZ2ZmOHTuSkJBAbGysZnmTpaWlzpjq1q3LtGnTmDFjBpGRkdSoUaPA4/zf//7H5MmT6dOnD8HBwWRlZXH+/HnS09MNxig3N5ecnBzUajV3795l7ty5lC1bFh8fnwLrJCQkcPPmTQYOHGiwfZVKRb9+/bh58yZjxoyhXLlybNy4kd69e7N161ZcXV01ZS9evMjt27cZMWIE1tbWODk5ERcXx8iRI+nQoQPDhg0jMTGR+fPnk5aWlu9J9NMePXrEt99+S7NmzShfvjyBgYHs3buXcePGoVBoXxPYvHkz3t7ezJo1i2vXrjFnzhzs7e0ZM2YMjRs3ZtCgQXz++eesWrUKKysrzMzM9Pa9YMECAgMDWbRoEZcuXWLJkiWYmpoyZswYAO7cuUP37t2pUqUKc+fO5dGjRyxcuJDu3bvz9ddfaz4TkyZN4ujRo4wZM4bKlSuzZcsWraVbpqamtG/fnt27dzNixAjNcaWkpHDgwAEmT55s8D0SQgghRPGQhKKEy8zMLHBpS+nSpTU/nzx5koMHD7J69WoCAwMBCAgIIDExkaioKJ0r7YsWLcLPzw94srwnODiYdevWMXr0aACGDh2qKZ+bm0tAQADnz59n165djBo1SrOsSaFQ6F22ZGlpyVtvvQVArVq1cHNzK7Ds+fPnsbW1Zfz48ZptjRs3LrD80+bNm8e8efM0r21tbYmOjsbKyqrAOnk3XDs5ORls//Dhw5w/f55Vq1YRFBQEQGBgIM2bN2fFihVERUVpyqamprJ9+3ZNu2q1mjlz5tCqVSs+/fRTTTkHBwf69+/P4MGDqVWrVoF9Hzx4kL///puwsDAA2rRpw6FDhzh16pTmPXy6zfnz5wPQqFEjLl26xP79+xkzZgx2dnZUrVoVeJLoFWaJU9WqVYmMjAQgKCiIrKws1q5dS79+/bCxsWHdunXk5OSwZs0abG1tAahduzatW7dm165dhIeH88cff/Dtt98yc+ZMzUxDXuye1rFjR1atWsXRo0c1n9c9e/agUCg0x15UCoURJiYyIfssY2OF1t9Cl8RIP4mPYRIj/SQ+hv0TYiQJRQlnbm7Opk2bdLZ/9dVXWld4jx07hq2tLb6+vlozGv7+/nz88ceoVCqMjY0BsLKy0joRtbKywt/fn59++kmz7cqVKyxYsICzZ8/y4MEDzfZr1669zMPTUqdOHVJSUpgwYQJt2rTBy8sLCwuLQtXt0aMH7777LgBJSUls2bKFwYMHs3HjRt5++229dQvzBKDTp09jaWmpSSbgyVX1Zs2a6dwk7eLiopWkXL16ldu3bzNp0iSt96Zhw4YoFAouXryoN6GIjY3F3t4ef39/AEJCQihdujR79uzRSSjyyuSpWbMme/fuNXh8BWnWrJnW69DQUJYtW8Zvv/1GgwYNOH36ND4+PppkIq/Pt99+mx9//JHw8HAuXLiAWq3WasvY2JimTZuybt06zbZq1arRsGFDduzYoUkodu7cSWhoaL6zX8/D0tL8heq/6aytC/fv7N9MYqSfxMcwiZF+Eh/DSnKMJKEo4RQKRb5X9Q8fPqz1Ojk5mZSUlAJnMxITEzU3Sud3Zdre3p4rV64AT9a79+nTBzs7OyZMmEDFihUpVaoUU6ZM4dGjRy94RAXz8/Njzpw5bNiwgYiICEqVKkVoaCiTJk3SOmHNT4UKFbTi5OfnR6NGjVi2bBlLlizJt0758uUBdNb75yctLU2zHOxp5cqVIzU1VWfb05KTkwEYMmRIvm3fuXNHb7/x8fG0bduWv//+W7M9KCiI7777jo8//lhr2dKzT2kyNTXl8ePHBbZvyLOflbxjS0xM1Iyvdu3aOvXs7e01cUlMTMTU1BQbGxudMs/64IMPmDBhAklJSdy7d49Lly4xYcKEIo8/T0ZGFtnZKsMF/2WMjRVYW1uQlvYQlUp3GaWQGBki8TFMYqSfxMew4oqRtbVFoWdFJKF4Q9jY2GBnZ8cXX3yR7/6nTwyfvfEW4MGDBzg4OABw7tw5EhISWLFihdbV/fT09EI9velFtG3blrZt25KUlMSBAweIjIzExMSEzz777LnaMTMzo0qVKvz+++8FlqlQoQJVq1blv//9LyNHjtTbno2NjdZMTZ779+/rnCg/O+ORlwxNmzYNd3d3nTYcHR0L7Hf//v1kZ2ezfft2tm/frrP/8OHDOkuHXqZnPyv3798H0HxWCorLgwcPqF69uqZsdnY2qampWrHKr17z5s355JNP+Prrr7l16xZVq1alYcOGL3wcublqcnLkP6qCqFS5Eh8DJEb6SXwMkxjpJ/ExrCTHqOQuxhLPxd/fn6SkJExNTXFzc9P58/RV7PT0dE6cOKH1+vjx49SrVw+ArKwsAK1HnZ45c4bbt29r9VnYq9957TzP7IadnR0dO3YkICCAP//8s9D18jx69IgbN25QtmxZveV69erFxYsX2bVrl86+3Nxcjhw5AoC3tzcZGRlaj5HNycnh+++/x9vbW28fNWrUoEKFCty8eTPf9yZvpiQ/e/bsoVKlSmzYsEHnT7ly5fJ92pM+ee9FYWctvvvuO63X+/fvx8LCAhcXF+BJXE6ePKk1S/Pnn39y+fJlTVzyZo6ebkulUvH999/r9GdmZkbbtm3Ztm0be/bsoUOHDvKldEIIIUQJJzMUb4iAgACaNGlC37596du37/+xd9/xNZ7/48dfORlknUTM2BEcJUtCM+2RWjVKzZi1N6HUaFGlNklqj5gNpWY/9qhSOmjRokaLqBEZkohExvn94Zf760hyThYJfT8fD486932t+518Pu73ua/rutFoNDx9+pTr169z69YtncXAtra2TJo0iREjRmBtbc3KlSvRarX06tULADc3NywsLJg2bRoDBgzgwYMHBAUFZbjxdXR0JCUlhdDQUGrXro2VlVWmuzhVrlwZY2Njtm/fjomJCcbGxplO41qyZAkxMTG8++67FC9enL/++ouTJ0/Su3dvg9d/7949ZevbqKgoNm3aRExMDF26dNFbr1u3bvz6669MmjSJc+fO0aRJEywsLLh58yZff/015cqVo379+jRs2BAXFxfGjRvH2LFjlV2eHj58mOWUqnRGRkZMmDCBwMBAEhISaNiwIebm5vz777+cOHGC0aNH4+DgkKHegwcP+Pnnnxk8eHCmu1W1bt2azZs3ExcXp3fx+YvSXyK4adMmmjZtStGiRfW+rfr27dtMnDiRli1b8ueff7JixQp69eqlPGno3bs3O3bsoG/fvgwePJikpCQWLVqEvb097du3B6Bq1ao0a9aML774gqSkJGWXp6y29P3www8JDQ3F2NiYDh06ZOu6hBBCCFFwJKF4iyxZsoQVK1awZcsW7t69i7W1NdWqVctwU1ayZEkCAwOZM2cOt2/fplq1aqxevVqZH1+iRAkWL17MnDlzGDJkCJUrV2batGmsWrVKp51GjRrRrVs3VqxYQWRkJHXr1mXDhg0ZxmVnZ8fUqVNZtWoVu3fvJiUlhatXr2Yo5+zsTGhoKP/73/+Ij4+nTJky9OvXj8GDBxu89g0bNih9q9VqHB0dCQkJoWnTpnrrGRkZMX/+fPz8/Ni2bRv79u3j2bNnlCtXjsaNG9O3b1/g+SLiFStWMGfOHObOnavsvrVmzRqdLWOz0qJFC9RqNcuWLVOeKpQrV4569eplWHORbt++faSlpdGuXbtMz7dv355169Zx4MCBbL+noWbNmgwfPpxt27axatUq7O3tOXr0aJblR48ezU8//cTIkSMxNjamW7duOtPD7O3t2bBhA3PmzCEwMBCVSoWvry8TJkzQWUj9xRdfMH36dObNm4eZmRnt27fn3XffZc6cORn6rFq1KpUrV6ZixYp6n97kRFqaNl/aEUIIIURGRlqtVv6l/Q+ZMGECly5dyrAzkRCFxe3bt2nevDmLFy/G398/X9qMjn5SaOedFiQTExXFillKfPSQGOkn8TFMYqSfxMewgoqRnZ2lLMoWQrxZoqOj+fvvvwkJCaFs2bI0adKkoIckhBBCiGyQRdlCiELh2LFjdOvWjfDwcObOnYuJiXzfIYQQQrwJZMqTEOKtJ4/SMydTDQyTGOkn8TFMYqSfxMewN2HKkzyhEEIIIYQQQuSaJBRCCCGEEEKIXJOEQgghhBBCCJFrklAIIYQQQgghck0SCiGEEEIIIUSuSUIhhBBCCCGEyDVJKIQQQgghhBC5JgmFyFcajcbgnx07duht4+zZsyxbtixX/YeHh6PRaNi/f7/eco0bN1bGU7NmTZo0acKnn35KVFRUrvp92eHDh9m0aVOu6mb3GvLTl19+yYgRI3JdPywsjKZNm2Z5PjY2NsPPPiAggIEDB2ZZZ/fu3bRo0YLU1NRcjyudkZFRntsQQgghRObkVbQiX4WFhel87ty5MwEBAbRu3Vo5VrFiRb1t/PTTT6xZs4ZBgwa9kjGm8/f3p2/fvqSkpPDbb78RHBzMX3/9xaZNm1Cp8pZrHz58mEuXLtG9e/cc1y1VqhRhYWFUrlw5T2PIrgcPHrB58+ZcJ0Dw/C3XDRs2zL9BAa1atWLx4sXs3LmTDz74IE9tqVSSUAghhBCviiQUIl+5ubllOGZvb5/p8YJWokQJZVx16tQhKSmJJUuW8Mcff+Ds7JyhfGJiIkWLFn3l4zIzM3ut8QoLC6NSpUo4OTnlqn5SUhJnzpwhJCQkX8dlbGxM+/bt2bBhQ54TCiGEEEK8OjLlSbxWaWlpfPXVVzRu3BgnJyfee+89vv76a+V8UFAQwcHBJCQkKFOSAgICALhx4wajR4+mQYMGuLq60rJlS9asWUNaWv68hj79hjo8PBx4Pn1rxYoVzJ07F19fX7y9vYHnN9CzZs3Cz88PZ2dn2rZty6FDh5R2JkyYwLfffsu1a9eUa5gwYYJy/vz58/Ts2RM3Nzc8PDwYO3YskZGRyvnMpjw1btyY6dOns2nTJho1aoSHhwdDhgzRmaKVnJzMl19+ScOGDXFycsLPz49BgwYRFxen97p37tyJv79/huOHDh3C398fZ2dnPvzwQ/744w/q1KlDUFCQTrkff/wRlUpF3bp1lWNbt26lcePGuLq60qtXL27duqV3DFlp0aIFly9f5sqVK7mqL4QQQohXT55QiNdqzpw5rF+/nsGDB1O7dm2OHz/Op59+SkpKCj169KBTp07cv3+fvXv3EhoaCoCVlRUADx8+xMHBgTZt2mBpacnly5cJCgoiISGBYcOG5Xls6YlEqVKllGPr16/H1dWVmTNnkpKSAkBgYCAnT55k1KhRVKlShV27djF8+HBCQkJo0qSJcqN/8+ZN5s2bB4CdnR3wPJkICAigQYMGLFy4kKdPn7Jo0SKGDBmSYbrYy44ePcqtW7eYOnUq0dHRzJo1ixkzZrBw4UIAli9fztdff01gYCDVqlUjOjqaU6dO8ezZsyzbvHXrFnfv3sXd3V3n+J9//snIkSNp1KgRn3zyCXfv3mX06NGZtnX06FH8/PwwMzMDnk9/mjJlCh06dKBly5b88ccfjBw5Uu+1ZcXR0REbGxtOnTpFjRo1ctWGEEIIIV4tSSjEaxMVFcXGjRvp168fw4cPB8DPz4/o6GhCQkLo2rUrZcqUoUyZMqhUqgzTfry9vZWnBFqtFg8PDxITE9m4cWOuEgqtVktKSgopKSn8/vvvLFu2jAoVKlCrVi2ljI2NDcHBwcqi3itXrnDw4EGmTZtGly5dAKhfvz53795VEoqKFStiZ2fHv//+m+Ea5s+fj5OTk06b1atXp3Xr1pw4cYIGDRroHe/SpUuVG/e7d++yfPly0tLSUKlUXLx4ET8/P511G5k9eXjRxYsXgedPY160fPlyypcvT1BQkLKexNLSkvHjx2do48SJEzoJw9KlS6lTpw6zZs0CoF69eiQlJfHVV1/pHUtWNBoNv//+e67qplOpjDAxkQeyLzM2Vun8V2QkMdJP4mOYxEg/iY9hb0KMJKEQr82FCxdITk7mvffe0zneokUL9u7dyz///IOjo2OW9ZOSkli+fDl79uzh3r17JCcnK+eePHmCpaVljsazefNmNm/erHx2dnZmxowZOusk6tevr7ND0K+//gqQ6TXMmjWLhIQELCwsMu3v6dOnnDt3jvHjx+vsXFS5cmXs7e25ePGi3oSibt26SjIBz7+9T05OJjIykpIlS1KzZk1Wr15NUFAQDRo0wMnJyeDi8oiICFQqFcWKFdM5fvHiRZo2bapTv0mTJhnqX758mYcPHyoLslNTU/njjz8YN26cTjl/f/9cJxTFihUjIiIiV3XTWVm9+rUvbzK12rygh1DoSYz0k/gYJjHST+JjWGGOkSQU4rV5/Pgx8Hwx9IvSP8fExOitP3fuXLZt28bQoUNxcnLC2tqaI0eOsHTpUpKSknKcULRo0YJ+/fphampKmTJlsLW1zVCmePHiGa7B1NQ0Q9kSJUqg1WqJi4vLMqGIjY0lNTWVWbNmKd/ev+jevXt6x6tWq3U+pycXSUlJAAwePBiVSsW3335LcHAwdnZ2dO/enaFDh2a5bWpSUhImJiYZzkdERCjTtNJZWVlRpEgRnWNHjx7FxcVFKRsVFUVKSkqGui//zHPC1NRUucbcio9PJDk579vPvm2MjVWo1ebExj4lNTV/1iK9bSRG+kl8DJMY6SfxMaygYqRWm2f7qYgkFOK1Sb8Jj4yMpHTp0srxR48e6ZzPyv79++ncuTMDBgxQjp04cSLX47Gzs8t0N6cXvXyjbWNjQ3JyMo8fP8bGxkY5/ujRI4yMjLC2ts6yLWtra4yMjBg4cGCm72x4+SlBTpmZmTF8+HCGDx/OrVu32L59O0FBQZQvX5527dplWsfGxoZnz56RlJSkkyyULFkywzs54uPjM9zYHz9+nMaNGyuf7ezsMDExyVA3/WecG3FxcQZ/NwxJS9OSkiL/UGUlNTVN4mOAxEg/iY9hEiP9JD6GFeYYFd7JWOKt4+zsjKmpaYYXtv3vf/+jePHiynsXTE1NM138m5SUhKmpqfI5NTWVffv2vdIxv8zDwwMgwzXs37+fmjVrKk8nMvtW3cLCAjc3N27evImzs3OGP+XLl8+3cVaqVIkxY8Zga2vLzZs3syzn4OAA/N+C9HTOzs4cP35cZwetw4cP65R59OgRFy9epFGjRsoxY2NjatasqbPrFcCBAwdyfS13795VximEEEKIwkeeUIjXxs7Ojh49erB69WrlXQsnTpxg7969TJkyBWNjY+D52oCUlBRCQ0OpXbs2VlZWVKlSBR8fH7Zt20bVqlUpVqwYmzdv1ruD0atQo0YNmjdvzuzZs0lMTMTBwYHdu3dz/vx5nTUCjo6ObN++nb1791KpUiWKFStG+fLlGT9+PL169WLUqFG0atUKtVrN/fv3OX36NB06dMDT0zPXYxsyZAi1atWiZs2amJubc+zYMR4/foyXl1eWdVxcXDAxMeHSpUs661cGDhxIx44dGT58OB9++CH//vsva9asoUiRIspTm+PHj2Nvb59h96VBgwYxZMgQJk6cqOzytGvXrkz7j4iIyPSN4A0bNqRo0aIkJCRw8+ZNhg4dmpuQCCGEEOI1kIRCvFbjx4/H2tqab775hmXLllGuXDmdHZMAGjVqRLdu3VixYgWRkZHUrVuXDRs2MGXKFD799FNmzJiBubk57du3p1mzZkyePPm1XsPcuXNZsGABK1euJCYmhipVqrBkyRKdqT8dO3bkwoULzJgxg5iYGNq3b8/s2bNxd3dn8+bNBAUFMXHiRJKTkylTpgxeXl5UqlQpT+Nyd3fnf//7H2vXriU1NRUHBwfmzZuHj49PlnUsLCyoV68e33//PW3btlWO16xZk0WLFjF//nyGDRtGtWrVmD17Nj179lSmdR0/fjzTReRNmjRh2rRpLFu2jH379uHq6sqiRYvo1KlThrJZbSl74sQJypQpww8//EDRokWpX79+bkIihBBCiNfASKvVagt6EEKIgnP06FHGjh3L6dOnMTfPegeJH3/8kd69e7Nhwwbc3Nzw9PRk0aJFenemyqsRI0ZgaWmZ6SL2nIiJSZBF2ZkwMVFRrJgl0dFPCu283IImMdJP4mOYxEg/iY9hBRUjOztLWZQthMieRo0a4eDgwLZt2+jZs6dy/LPPPsPb2xtbW1uuX7/OV199Rc2aNalTpw4qlYrz58+/0nHduXOHEydOsGfPnjy3Jd+bCCGEEK+OJBRC/McZGRnx2WefcfXqVZ3jsbGxypQtKysr6tWrx8cff2zw3Rb55cGDB0yfPp2KFSu+lv6EEEIIkTsy5UkI8daTR+mZk6kGhkmM9JP4GCYx0k/iY9ibMOVJto0VQgghhBBC5JokFEIIIYQQQohck4RCCCGEEEIIkWuSUAghhBBCCCFyTRIKIYQQQgghRK5JQiGEEEIIIYTINUkohBBCCCGEELkmCYUoMEeOHKFv3768++67ODk50bhxY6ZOncrff//92sYQGxtLUFAQ169f1zkeHh6ORqNh//79OWrv7NmzaDQaLl68mJ/DNOjq1avUrl2bqKio19ovwN9//41Go+Hff//Nskzbtm2ZMGGC8jkoKIjatWtnWT48PBw3NzfCw8PzZYxGRkb50o4QQgghMpKEQhSIefPmMWTIEKysrJgxYwZr165l6NChXL9+ndGjR7+2ccTGxhIcHJwhoShVqhRhYWF4eXnlqL1atWoRFhaGo6Njfg7ToEWLFtGhQwfs7Oxea78Ax44dQ6PRULZs2Xxrs3z58vj7+xMUFJQv7alUklAIIYQQr4pJQQ9A/PecOHGClStXMmTIEEaOHKkcr1u3Lh988AHHjh3Lsm5iYiJFixZ95WM0MzPDzc0tx/WsrKxyVS8v7ty5w7Fjx9ixY8dr7TfdsWPHaNSoUb6327FjR/r06cPHH39cIImSEEIIIbJHnlCI127NmjWUKFGCIUOGZHr+xZtTjUbDihUrmDt3Lr6+vnh7ewOg1WpZvXo1/v7+ODk50aRJE9atW6fTzo0bNxg9ejQNGjTA1dWVli1bsmbNGtLSnr+2Pjw8nCZNmgAwcuRINBoNGo2G8PDwTKc8NW7cmOnTp7Np0yYaNWqEh4cHQ4YM0ZlmlNmUJ41Gw8qVKwkKCsLHxwdPT08mTpxIQkKCznjv379PYGAgnp6euLi40L17dy5dumQwnjt37qRChQrUrFlTOZY+/p07dzJ16lTq1KmDt7c3a9euBWDfvn34+/vj7u7OsGHDiI2N1Wnz2rVrdO/eHWdnZ5o3b87u3bsZMmQIAQEBOuViY2M5d+6czs/s3LlzdOjQAWdnZ1q3bs2JEycMXkNmPDw8sLW1Zc+ePbmqL4QQQojXQ55QiNcqJSWFc+fO0bx5c0xNTbNVZ/369bi6ujJz5kxSUlIAmDlzJtu2bWPQoEG4urpy7tw55s2bR5EiRejatSsADx8+xMHBgTZt2mBpacnly5cJCgoiISGBYcOGUapUKYKDgxk2bBhjxozB09MTeD7d6eHDh5mO5ejRo9y6dYupU6cSHR3NrFmzmDFjBgsXLtR7DZs2bcLDw4PZs2fzzz//MGfOHIoXL05gYCAAjx8/plu3blhYWDBlyhSsra3ZsGEDvXr14uDBgxQvXjzLtk+fPp3leoRFixbRvHlzFi9ezOHDh5k9ezZRUVH89NNPjBs3jvj4eD7//HPmzp3LjBkzgOdPgfr27YtarWbu3LkAhISEEBsbS8WKFXXaP3nyJDY2Nri4uAAQERFBv3790Gg0LFq0iNjYWKZNm0ZCQgLvvPOO3hi9TKVS4erqyunTp+nVq1eO6gohhBDi9ZGEQrxWMTExPHv2LEfz7W1sbAgODlYW1t6+fZuNGzcybdo0OnfuDICPjw+JiYmEhITQuXNnVCoV3t7eOk80PDw8SExMZOPGjQwbNgwzMzPlJrdSpUrZmqqk1WpZunQpZmZmANy9e5fly5eTlpaGSpX1A7+SJUsyf/58AOrXr8+ff/7JgQMHlIQiNDSU2NhYtm3bpiQP3t7e+Pv7s3r1asaPH5/leC5dukTTpk0zPe/m5sYnn3wCgJeXFwcPHmTjxo0cPXqUYsWKAc8XdH/zzTdKQrF9+3YiIyPZsmUL5cuXB8DJyYnmzZtnSCiOHTtG/fr1lWsPDQ3FyMiIlStXYm1tDUCZMmXo3bu3nqhmrUaNGmzatClXdV+kUhlhYiIPZF9mbKzS+a/ISGKkn8THMImRfhIfw96EGElCIQpETnbdqV+/vk7506dPA9C8eXPliQU8TypWrlzJvXv3KFeuHElJSSxfvpw9e/Zw7949kpOTlbJPnjzB0tIyx+OuW7eukkwAODo6kpycTGRkJCVLlsyyno+Pj85nR0dH9u3bp3w+deoUnp6e2NjYKNekUqmoW7eu3h2jHj9+zLNnz7JcY+Dr66v83djYmAoVKmBkZKQkEwCVK1cmNjZWicmlS5eoXr26kkzA80XSNWrU0Gk7NTWVkydPMn36dOXY77//jqenp5JMwPPEyNbWNstr0KdYsWJER0eTnJyc7SdambGyevXrbt5karV5QQ+h0JMY6SfxMUxipJ/Ex7DCHCNJKMRrZWtrS5EiRfRuMfqyl6f7REdHo9Vqs9yBKT2hmDt3Ltu2bWPo0KE4OTlhbW3NkSNHWLp0KUlJSblKKNRqtc7n9OQiKSkpR/VMTU159uyZzjX99ttv1KpVK0Pdl58KvCi93xeTnBe9eGOf3q+FhUWGY+ltWVpa8vDhw0wTFDs7O53rPH/+PE+ePNFJWiIiIqhUqVKmdXPjxfjmJaGIj08kOTk11/XfVsbGKtRqc2Jjn5KamlbQwymUJEb6SXwMkxjpJ/ExrKBipFabZ/upiCQU4rUyMTHB3d2dM2fOkJKSgomJ4V/Bl59m2NjYYGRkxObNmzO9yXRwcABg//79dO7cmQEDBijncrtA+FWzsbGhXr16OrtepcsqWQCUb/5fXlSdF6VKleLy5csZjkdFRekkYceOHaNu3bpYWVkpx0qWLElkZGSmdXMjNjYWU1NTnT5yIy1NS0qK/EOVldTUNImPARIj/SQ+hkmM9JP4GFaYY1R4J2OJt1afPn2IiIhg2bJlmZ43dNOfvi4iJiYGZ2fnDH/Sbz5f/lY7NTVVZ5oR6H47X5B8fHy4ceMGjo6OGa5Ho9FkWa9IkSKULVs2314AB8/XS1y9epU7d+4ox8LDw7ly5YpOuePHj2fYLtbFxYWzZ88SFxenHPvxxx+JiYnJ1Vju3r2rJIhCCCGEKJzkCYV47Ro0aMBHH32kvKG6VatWFCtWjPDwcLZv305cXBwNGjTIsr6DgwPdu3dn/Pjx9OvXD1dXV5KTk/nnn384e/YsX331FfD8Jn3btm1UrVqVYsWKsXnzZp1pRvD8G3W1Ws2+ffsoX748ZmZmem/gX5XevXuzZ88eevToQc+ePSlbtixRUVH8/vvvlC5dWu+iZnd3d/744498G8sHH3zAsmXLGDRoEMOHDwcgODiYEiVKKE+L7ty5w/Xr1zMkFL169WLz5s3079+f/v37K28iz2wNRWpqaqZvIndxcVEW7V+6dAkPD498uzYhhBBC5D9JKESBGDduHLVr12bTpk188sknPH36lFKlSuHn50e/fv0M1p88eTIODg6EhYUREhKCpaUlDg4OvPfee0qZKVOm8OmnnzJjxgzMzc1p3749zZo1Y/LkyUoZlUrFrFmzWLBgAb179+bZs2ccOXLklVyzPsWKFSMsLIxFixYxb948YmJiKF68OK6urjRr1kxvXX9/fwIDA4mPj8/z1CCAokWLsmbNGj799FMCAwMpXbo0Q4YMYefOncqajGPHjuHo6EiFChV06pYqVYqVK1fy+eefM3LkSCpWrMjUqVMz3VY3KSkp0ylec+bMoW3btkRGRvLHH38wZsyYPF+TEEIIIV4dI61Wqy3oQQghci85OZlGjRoRGBhIu3btXkkfMTExNG3alN69ezNs2DD69u1LjRo1stzONj9s2rSJdevWcfDgwRztCpaZmJgEWZSdCRMTFcWKWRId/aTQzsstaBIj/SQ+hkmM9JP4GFZQMbKzs5RF2UL8V5iamtK/f3/Wr1+fbwnFihUrKFGiBOXKlSMiIoI1a9aQmprKBx98ADx/2/mrlJaWxvr16xk6dGiekwl4/r4OIYQQQrwaklAI8Rbo2rUr8fHxREVF5XqL1hepVCqWLl3KgwcPMDY2xtXVldDQUOzt7fNhtIY9fPiQ9u3b8/7777+W/oQQQgiRezLlSQjx1pNH6ZmTqQaGSYz0k/gYJjHST+Jj2Jsw5Um2jRVCCCGEEELkmiQUQgghhBBCiFyThEIIIYQQQgiRa5JQCCGEEEIIIXJNEgohhBBCCCFErklCIYQQQgghhMg1SSiEEEIIIYQQuSYJhXjlgoKC0Gg0dO/ePcO5mTNn0rhx49c6noCAAAYOHPha+8yJZ8+eMXHiRLy8vNBoNKxbty7Tcq8rrocPH0aj0RAeHp6jekFBQdSuXTtfxpBX+fG2bSGEEEJkThIK8dr88ssvnD17tqCHUejt2rWLXbt28cknnxAWFkarVq30lpe4GqZSSUIhhBBCvCqSUIjXwsLCAhcXF7766quCHsorl5iYmKf6N2/epFSpUrz//vu4ublRsmTJLMv+l+IqhBBCiMJJEgrx2gwZMoQzZ85w7ty5LMvs2LEDjUZDVFSUzvG2bdsyYcIE5fOECRNo3bo1p0+fpk2bNri4uNCjRw/Cw8OJiYlh5MiRuLu707RpU7777rtM+9q5cydNmzbFxcWFgIAAbt68qXNeq9WyevVq/P39cXJyokmTJhmmH6VP67lw4QKdO3fG2dmZTZs2ZXl9d+/eZcSIEXh4eODm5ka/fv24evWqcr5x48asWbOGe/fuodFosjXVKDtxzU7fAMnJycycOZN3330XDw8PPvnkE548eaJT5uzZs2g0Gi5evJhhHAEBAXrHEBsby2effYafnx9OTk506NCBH374QafMr7/+Svfu3fHw8KB27dq0adOGb7/9Vm+7QgghhCg4JgU9APHf0ahRI2rWrElISAirV6/Oc3sRERHMnj2bwYMHY2Jiwueff05gYCDm5ubUqVOHDz/8kK1btzJu3DhcXV0pV66cUvePP/7g9u3bjB07FoBFixbx0UcfsX//fszMzIDn6xC2bdvGoEGDcHV15dy5c8ybN48iRYrQtWtXpa3k5GTGjh1L7969GT16NLa2tpmONz4+noCAAFQqFdOmTaNIkSIsXbqUHj16sHv3buzt7QkODmblypX8/PPPBAcHA1CqVCm9cchOXLPTN8CCBQvYsmULw4cPp2bNmuzbt4/58+dn7wdiwLNnz+jTpw+RkZGMGjWK0qVLs3v3bgYOHKgkkvHx8QwcOBAPDw8WLFiAmZkZ169fJzY2Nl/GIIQQQoj8JwmFeK0GDx7M8OHDuXDhAi4uLnlq6/Hjx2zcuJFq1aoB8PDhQ2bMmEH//v0ZOnQoAM7Ozhw6dIjDhw/Tq1cvpW5kZCQbN26kcuXKANSsWZP33nuPHTt20KVLF27fvs3GjRuZNm0anTt3BsDHx4fExERCQkLo3LkzKtXzB3zJycmMHj2ali1b6h3vjh07+Pfff9m3bx+Ojo4A1K1bl0aNGhEaGsqECROoWbMmJUqUwMzMDDc3t2zHwlBcs9N3TEwMmzdvpn///sqi9Xr16tGjRw8ePHiQ7bFkZc+ePVy5coVdu3ZRtWpVpf1bt27x1VdfsXjxYv7++2/i4uIYM2YMGo0GAG9v7zz3rVIZYWIiD2RfZmys0vmvyEhipJ/ExzCJkX4SH8PehBhJQiFeq2bNmlG9enVCQkJYvnx5ntoqVaqUkkwASnLg4+OjHFOr1djZ2XH//n2dutWqVVPKA1SqVIkaNWrw+++/06VLF06fPg1A8+bNSUlJUcr5+PiwcuVK7t27p/PEo0GDBgbH+8svv1CtWjXlhh7A1tYWHx8ffv311+xddBYMxTU7ff/1118kJibSrFkznbrNmzfn559/ztP4AE6dOkX16tWpXLlyhpju3r0bgIoVK2JlZcVnn31GQEAAXl5e2NnZ5blvK6uieW7jbaZWmxf0EAo9iZF+Eh/DJEb6SXwMK8wxkoRCvFZGRkYMGjSIMWPG8Mcff+SpLbVarfPZ1NQUAGtra53jZmZmJCUl6RwrXrx4hvaKFy9OREQEANHR0Wi1Wry8vDLt+8WEwtzcHEtLS4PjjY2NpUSJEpn2e+3aNYP19TEU1+z0nX7tL8cms3q5ER0dzZ9//kmtWrUynDM2NgbAxsaGtWvXsmTJEsaPH09qaip16tRh8uTJyhOL3IiPTyQ5OTXX9d9WxsYq1GpzYmOfkpqaVtDDKZQkRvpJfAyTGOkn8TGsoGKkVptn+6mIJBTitWvRogVBQUF89dVXlC1bVudckSJFgOfTiF6U33PoIyMjMz1Wo0YN4PmNrZGREZs3b1YSlRc5ODgof8/uOw5sbGz4+++/M+3XxsYmu0PPkr64Zqfv9N2kIiMjKV26tFLm0aNHOnX0/Yz0xcLGxgaNRsPMmTP1XoeLiwurVq0iMTGRs2fP8uWXXzJ06FAOHz6st54+aWlaUlLkH6qspKamSXwMkBjpJ/ExTGKkn8THsMIco8I7GUu8tVQqFYMGDeLIkSMZdhlKv5F9ccelGzducO/evXwdw7Vr17h165by+datW1y5cgVXV1fg/+btx8TE4OzsnOGPlZVVjvv08PDgr7/+0rm2x48fc/r0aTw8PPJ4Rfrjmp2+q1evTtGiRTl06JBO3YMHD+p8LlOmDPD855IuKirK4BMnHx8f7ty5Q6lSpTKN6cuKFi1KgwYN6Nq1K+Hh4RmeMgkhhBCicJAnFKJAtGnThpCQEM6ePauzFsHV1RV7e3u++OILxo4dS3x8PCtWrMhy56TcKl68OIMGDWLEiBEALF68mNKlS9OhQwfg+ROI7t27M378ePr164erqyvJycn8888/nD17NlfvfejQoQPr1q1j4MCBjBo1StlpycTERGfBeF5kFdfs9G1ra0uXLl1YuXIlRYsWVXZ5un37tk4fZcqUwdXVlZCQEKytrTExMWHlypUZppq9rF27dnz99df07NmTvn37UrlyZeLi4vjzzz+VnbKOHz/ON998Q9OmTSlbtiyPHj1i48aNuLu7K09GhBBCCFG4SEIhCoSxsTEDBgxg8uTJOsdNTU0JDg7ms88+Y+TIkVSsWJFPPvmE2bNn52v/tWrVonnz5sydO5eIiAhcXV2ZNm2asmUswOTJk3FwcCAsLIyQkBAsLS1xcHDgvffey1WfVlZWbNiwgdmzZzNlyhTS0tJwd3dn48aNyrateZVVXLPb99ixY0lNTWXVqlWkpaXRrFkzxo4dy/jx43XamzdvHpMnT2bixImUKFGCUaNGsW/fPuLi4rIcm5mZGevXrycoKIhly5YRERGBra0tNWvWpFu3bsDzRdkqlYpFixYRGRmJra0tfn5+jBkzJl/iI4QQQoj8Z6TVarUFPQghhHiVYmISZFF2JkxMVBQrZkl09JNCOy+3oEmM9JP4GCYx0k/iY1hBxcjOzjLbi7JlDYUQ4q0n35sIIYQQr44kFEIIIYQQQohck4RCCCGEEEIIkWuSUAghhBBCCCFyTRIKIYQQQgghRK5JQiGEEEIIIYTINUkohBBCCCGEELkmCYUQQgghhBAi1yShEEIIIYQQQuSaJBRCCCGEEEKIXJOEQmRLUFAQtWvXzvG51+Xs2bMsW7Ysw/GXxxYeHk5QUBAPHjzIUF+j0XDx4sU8jUOj0ej88fHxYdCgQVy9ejVP7WbX559/jkajISQkJNdtXL58maCgIJ4+fapzfMeOHWg0GqKiovI6zNfOyMiooIcghBBCvLUkoRBvhZ9++only5dnON6pUydCQ0OVz3fv3iU4OJiHDx/qlKtVqxZhYWE4OjrmeSwBAQGEhYXx9ddfM2XKFO7fv0+/fv2IjY3Nc9v6pKam8r///Q+AvXv35rqdy5cvExwcnCGhaNiwIWFhYajV6jyNsyCoVJJQCCGEEK+KSUEPQIhXqUyZMpQpU8ZgOSsrK9zc3PKlT3t7e522HBwcaNu2LefPn6dBgwb50kdmfvzxRx49eoSPjw+nT5/mjz/+oFatWvnWvp2dHXZ2dvnWnhBCCCHeDvKEQrwSz549Y8GCBTRq1AgnJydatGjBnj17dMpMmDCB1q1bc+LECVq3bo2zszMdOnTgt99+0ym3c+dOunbtyrvvvkvdunUJCAjgwoULyvmgoCCCg4NJSEhQphoFBAQo59KnPJ09e5aePXsC0LFjR6Vs+rmXpzx98803tGrVChcXFzw9PenatatOv9llaWkJQHJyssGyx48fp1OnTri4uODl5cWnn35KQkJCtvrZu3cvlpaWzJ49G1NT0wzxhudTslauXElQUBA+Pj54enoyceJEpY8dO3YwceJEALy9vdFoNDRu3Fg59/KUp/v37zNw4EBcXV1p0KAB69atY+bMmUqdF8sFBgbi6emJi4sL3bt359KlSzplGjduzPTp09m0aRONGjXCw8ODIUOGvJFTrIQQQoj/EnlCIXIkJSUlw7G0tLQMx0aOHMm5c+cYOnQojo6OnDhxgnHjxqFWq3W+pY+IiGDatGkMHz4ctVrNypUr6devHwcPHqR48eLA83UP7dq1o2LFijx79ox9+/bRvXt3du/ejYODA506deL+/fvs3btXmd5kZWWVYUy1atVi6tSpTJ8+nVmzZlGlSpUsr/Pnn39m0qRJ9O3blwYNGpCYmMiFCxeIi4szGKO0tDRSUlLQarU8ePCAuXPnUqxYMTw9PfXW279/P6NHj6ZDhw4MHz6ciIgI5s+fT2xsLAsXLtRbNykpiYMHD9KsWTNKly6Nn58f+/btY/z48ahUut8bbNq0CQ8PD2bPns0///zDnDlzKF68OIGBgTRs2JDBgwezdOlSVq1ahbW1NWZmZpn2qdVqGTJkCI8ePWLatGlYW1uzevVq/v33X50+Hz9+TLdu3bCwsGDKlClYW1uzYcMGevXqpfNzBjh69Ci3bt1i6tSpREdHM2vWLGbMmGHw+oUQQghRcCShENmWkJCQ5RQaCwsL5e9nzpzh6NGjrF69Gj8/PwB8fX2JiIggKChIJ6GIiYlh0aJFeHt7A/Duu+8q33SPHTsWgGHDhinl09LS8PX15cKFC3z77beMGTNGmdakUqn0TluysrKiatWqAFSrVg1nZ+csy164cAFbW1s+/vhj5VjDhg2zLP+iefPmMW/ePOWzra0twcHBWFtbZ1lHq9UyZ84cWrZsycyZM5XjJUuWZMCAAQwZMoRq1aplWf/o0aM8efKE1q1bA9CmTRuOHTvG2bNnldi+2Ob8+fMBqF+/Pn/++ScHDhwgMDAQOzs7KlasCDxPwPRNcfr+++/5448/2LRpE3Xq1AHAy8uLBg0a6KyzCA0NJTY2lm3btinJg7e3N/7+/qxevZrx48frxGHp0qVKEnP37l2WL19OWlpahsQoJ1QqI0xM5IHsy4yNVTr/FRlJjPST+BgmMdJP4mPYmxAjSShEthUtWpSNGzdmOL5161adRcCnTp3C1tYWLy8vnScaPj4+fPbZZ6SmpmJsbAyAtbW1zg2vtbU1Pj4+/P7778qxGzdusGDBAs6fP09kZKRy/J9//snPy9NRs2ZNYmJimDBhAm3atMHd3R1zc/Ns1e3Zsyfvv/8+AFFRUWzevJkhQ4awYcMGatSokWmdv//+m7t37/LJJ5/oxOzdd99FpVJx6dIlvQnF3r17KV68OD4+PsDz6UMWFhbs2bMnQ0KRXiado6Mj+/bty9a1vejixYuo1WolmYDn07u8vb35448/lGOnTp3C09MTGxsb5dpUKhV169bNsKtW3bp1dZ6IODo6kpycTGRkJCVLlszxGNNZWRXNdd3/ArU6e7/b/2USI/0kPoZJjPST+BhWmGMkCYXINpVKlem3+sePH9f5HB0dTUxMTJZPMyIiIpSF0pl9A168eHFu3LgBQHx8PH379sXOzo4JEyZQtmxZihQpwuTJk0lKSsrjFWXN29ubOXPmsH79evr160eRIkXw9/fnk08+wdbWVm/dMmXK6MTJ29ub+vXr89VXX7FkyZJM60RHRwMwdOjQTM/fu3cvy/5iY2M5ceIEbdu25cmTJ8rxevXqcejQIT777DOdm/SXd2kyNTXl2bNneq8pMw8fPsz05/fysejoaH777bdMfx/Sn4ZkNbb0cef1Zx0fn0hycmqe2ngbGRurUKvNiY19SmpqxqmLQmJkiMTHMImRfhIfwwoqRmq1ebafikhCIfKdjY0NdnZ2rFixItPzL95wZrbg9sVvo3/77Tfu37/P8uXLdb7dj4uLy9buTXnRtm1b2rZtS1RUFEeOHGHWrFmYmJjwxRdf5KgdMzMzKlSowLVr17Isk56kTJ06FRcXlwznS5UqlWXdAwcOkJyczDfffMM333yT4fzx48dp3rx5jsacHaVKlcr05/fyMRsbG+rVq8fIkSMzlM1qfUZ+S0vTkpIi/1BlJTU1TeJjgMRIP4mPYRIj/SQ+hhXmGElCIfKdj48Pq1atwtTUNMspPuni4uL48ccflWk5cXFxnD59mu7duwOQmJgIPP8WPd25c+e4e/euzhSg7H7Lnt5OTr7xtrOzo1OnTnz//ffcvHkz2/XSJSUlcfv2bb3vuKhSpQplypThzp07yrVn1549eyhXrhyzZs3KcG7MmDHs2bMnRwlFeowMxdPZ2ZnY2Fh+/vln6tatC8CTJ0/48ccfdZ40+Pj4sHv3bhwdHXXW2gghhBDi7SAJhch3vr6+NGrUiI8++oiPPvoIjUbD06dPuX79Ordu3dJZdGxra8ukSZMYMWIE1tbWrFy5Eq1WS69evQBwc3PDwsKCadOmMWDAAB48eEBQUBClS5fW6dPR0ZGUlBRCQ0OpXbs2VlZWme7iVLlyZYyNjdm+fTsmJiYYGxtnOo1ryZIlxMTE8O6771K8eHH++usvTp48Se/evQ1e/71795Stb6Oioti0aRMxMTF06dIlyzpGRkZMmDCBwMBAEhISaNiwIebm5vz777+cOHGC0aNH4+DgkKHegwcP+Pnnnxk8eHCmu0i1bt2azZs3ExcXp3dR+IvSE59NmzbRtGlTihYtqmyv+6L69etTq1Ytxo4dy5gxY1Cr1axatQpLS0udN1P37t2bPXv20KNHD3r27EnZsmWJiori999/p3Tp0tmKqRBCCCEKL0koxCuxZMkSVqxYwZYtW7h79y7W1tZUq1aNDh066JQrWbIkgYGBzJkzh9u3b1OtWjVWr15NiRIlAChRogSLFy9mzpw5DBkyhMqVKzNt2jRWrVql006jRo3o1q0bK1asIDIykrp167Jhw4YM47Kzs2Pq1KmsWrWK3bt3k5KSwtWrVzOUc3Z2JjQ0lP/973/Ex8dTpkwZ+vXrx+DBgw1e+4YNG5S+1Wo1jo6OhISE0LRpU731WrRogVqtZtmyZco7JMqVK0e9evWUeLxs3759pKWl0a5du0zPt2/fnnXr1nHgwAE6duxocOzwfEH68OHD2bZtG6tWrcLe3p6jR49mKGdkZMRXX33F1KlTmTp1Kmq1mp49e/L3339z+fJlpVyxYsUICwtj0aJFzJs3j5iYGIoXL46rqyvNmjXL1piEEEIIUXgZabVabUEPQvw3TZgwgUuXLunsECXebM+ePaNVq1bUqVMn0ylYBSUmJkEWZWfCxERFsWKWREc/KbTzcguaxEg/iY9hEiP9JD6GFVSM7OwsZVG2EOLVCwsLIy0tDQcHB2JjY5UnUgsWLCjooemQ702EEEKIV0cSCiFErhUpUoQVK1Zw9+5dAGrUqMHy5cv1vjRQCCGEEG8XmfIkhHjryaP0zMlUA8MkRvpJfAyTGOkn8THsTZjyVHjf4S2EEEIIIYQo9CShEEIIIYQQQuSaJBRCCCGEEEKIXJOEQgghhBBCCJFrklAIIYQQQgghck0SCiGEEEIIIUSuSUIhhBBCCCGEyDVJKP4jgoKC0Gg0aDQaatSogYeHB23atGH69OncuHEjQ/nGjRszffr01za+w4cPs2nTpmyVnTBhgnItGo0GNzc33n//fbZt26ZT7uzZs2g0Gi5evKgc02g0rF69WvkcEBDAwIED8+cieB7n2rVrGyyX3/1evXqV2rVrExUVlW9tZtfff/+NRqPh33//zbJM27ZtmTBhgvLZUJzCw8Nxc3MjPDw8X8ZoZGSUL+0IIYQQIiN5U/Z/SNGiRQkNDQXgyZMn/PXXX4SFhbF161ZmzpxJ27ZtlbLBwcGo1erXNrbDhw9z6dIlunfvnq3yFSpUYN68ecDzazl06BCTJ0/GwsKCVq1aAVCrVi3CwsJwdHTMsp1PP/0Uler159X53e+iRYvo0KEDdnZ2+dZmdh07dgyNRkPZsmXzrc3y5cvj7+9PUFAQX375ZZ7bU6kkoRBCCCFeFUko/kNUKhVubm7KZ19fX7p168aAAQOYNGkS7u7uVKhQAYCaNWvqbUur1ZKcnIyZmdmrHHKWihYtmuFafvvtNw4ePKgkFFZWVjplMlO1alWDfSUmJlK0aNG8DDdX/WbXnTt3OHbsGDt27Mi3NnPi2LFjNGrUKN/b7dixI3369OHjjz8ukERJCCGEENkjU57+44oUKcKUKVNITk7WmTL08pSnCRMm0Lp1a06cOMH777+Ps7MzR48eBeD8+fP07NkTNzc3PDw8GDt2LJGRkTr9PHv2jIULF9KkSROcnJyoX7++MgVmwoQJfPvtt1y7dk2ZxvTi9JjssrS0JCUlRfmc2ZSnl7089Sh9Ks6FCxfo3Lkzzs7ObNq0Kcu2hgwZQkBAQIZ2L1y4QMeOHXF2dqZFixYcO3YsW/1evXqVrl274urqSuvWrTl58qTB6965cycVKlTQSQLDw8PRaDTs3LmTqVOnUqdOHby9vVm7di0A+/btw9/fH3d3d4YNG0ZsbKxOm9euXaN79+44OzvTvHlzdu/enem1xsbGcu7cOZ2E4ty5c3To0AFnZ2fldyY3PDw8sLW1Zc+ePbmqL4QQQojXQ55QCKpWrUrp0qU5f/683nIPHz7k888/Z/Dgwdjb21O2bFnOnz9PQEAADRo0YOHChTx9+pRFixYxZMgQwsLClLrDhw/nzJkzDBw4EDc3N6Kiojh48CDw/KY8KiqKmzdvKtOYsvONdHrykJCQwMGDBzl37ly+TI9JTk5m7Nix9O7dm9GjR2Nra8vjx49zVH/06NH07duX8uXLs2XLFoYNG8aOHTvQaDR66wUGBtKzZ0+GDBnCypUrGTFiBEePHqVYsWJZ1jt9+nSW6xEWLVpE8+bNWbx4MYcPH2b27NlERUXx008/MW7cOOLj4/n888+ZO3cuM2bMAJ4/kenbty9qtZq5c+cCEBISQmxsLBUrVtRp/+TJk9jY2ODi4gJAREQE/fr1Q6PRsGjRImJjY5k2bRoJCQm888472Y4hPH+i5urqyunTp+nVq1eO6gohhBDi9ZGEQgBgb2/Po0eP9JZ5/PgxK1euxNXVVTk2adIknJycCA4OVha+Vq9eXflmukGDBpw6dYrjx48zf/58WrdurdRN/3vFihWxs7Pj33//NThFKd21a9eoVauWzrG+ffvy/vvvZ6u+PukJQcuWLZVjZ8+ezVH9wYMH07FjRwD8/Pxo3rw5y5cvZ8GCBXrrBQYG0qBBAwAcHBxo0qQJ33//vc76lhdptVouXbpE06ZNMz3v5ubGJ598AoCXlxcHDx5k48aNOknK1atX+eabb5SEYvv27URGRrJlyxbKly8PgJOTE82bN8+QUBw7doz69esr60FCQ0MxMjJi5cqVWFtbA1CmTBl69+5tMG6ZqVGjRrYX6+ujUhlhYiIPZF9mbKzS+a/ISGKkn8THMImRfhIfw96EGElCIYDnN6aGdsKxtbXVSSaePn3KuXPnGD9+PKmpqcrxypUrY29vz8WLF2nQoAE//vgj5ubmytqG/FCxYkXl5jwxMZFffvmFkJAQLC0tGTZsWJ7bT7+pz61mzZopfzc2NqZp06YcPnxYbx2VSoW3t7fyuXz58hQtWpQHDx5kWefx48c8e/Ysyyc6vr6+OuOoUKECRkZGOk88KleuTGxsLE+ePMHS0pJLly5RvXp1JZlIH0uNGjV02k5NTeXkyZM6U+N+//13PD09lWQCwNvbG1tbW73XnpVixYoRHR1NcnIypqamuWoDwMoqf9fAvG3UavOCHkKhJzHST+JjmMRIP4mPYYU5RpJQCADu379P5cqV9ZYpUaKEzufY2FhSU1OZNWsWs2bNylD+3r17AMTExFCyZMl83bqzSJEiODs7K5/r1q1LZGQky5Yto0ePHrm+gQUwNzfH0tIy1/VNTU2xsbHROVa8eHEiIiL01itatGiGRe6mpqYkJSVlWSf9XFaL41+8sU9vz8LCIsOx9LYsLS15+PBhpgmKnZ2dzljOnz/PkydPdJKWiIgIKlWqlGnd3Ei/rqSkpDwlFPHxiSQnpxou+B9jbKxCrTYnNvYpqalpBT2cQklipJ/ExzCJkX4SH8MKKkZqtXm2n4pIQiG4du0aDx48oH379nrLvZwQWFtbY2RkxMCBAzOdcpP+LbitrS0RERHZegqSF1WqVCE5OZlbt27lKaHIbIxFihQBnk9LelFsbGyG8snJyTx+/FgnqYiMjKRkyZK5HlNW0q/z5UXVeVGqVCkuX76c4XhUVJROonXs2DHq1q2LlZWVcqxkyZIZFuSn182N2NhYTE1NdfrIjbQ0LSkp8g9VVlJT0yQ+BkiM9JP4GCYx0k/iY1hhjlHhnYwlXoukpCRmzJiBmZkZnTp1ylFdCwsL3NzcuHnzJs7Ozhn+pE+Z8fHx4enTp/zvf//Lsi1D38Rnx7Vr1wD0LmDOrTJlygDovAQwKiqKP/74I9Pyhw4dUv6emprK4cOHdaaL5ZciRYpQtmzZfHsBHDxfL3H16lXu3LmjHAsPD+fKlSs65Y4fP55hu1gXFxfOnj1LXFyccuzHH38kJiYmV2O5e/cuDg4OuaorhBBCiNdDnlD8h6SlpfHbb78Bz3dGSn+x3Z07d5g9e7bOnPnsGj9+PL169WLUqFG0atUKtVrN/fv3OX36NB06dMDT0xMfHx8aNGjAJ598wu3bt3F1dSUmJoYDBw6waNEiABwdHdm+fTt79+6lUqVKFCtWTO94EhMTlWtJX0Oxbds2fH19Mywczg9lypTB1dWVkJAQrK2tMTEx0Vl4/CJTU1OWLl1KUlKSssvT/fv3CQkJyfdxAbi7u2eZ2OTGBx98wLJlyxg0aBDDhw8Hnr/osESJEsrTmDt37nD9+vUMCUWvXr3YvHkz/fv3p3///sTGxhIUFJTpE6PU1FT279+f4biLi4vykrxLly7h4eGRb9cmhBBCiPwnCcV/SGJiIp07dwaeP10oX7483t7eBAcH632btD7u7u5s3ryZoKAgJk6cSHJyMmXKlMHLy0tnLn1QUBDBwcGEhYURHBxM8eLFdebed+zYkQsXLjBjxgxiYmJo3749s2fPzrLfO3fuKNdiampKuXLl6NevH/3798/VdWTHvHnzmDx5MhMnTqREiRKMGjWKffv26Xwbnz6eBQsWMG3aNP766y/Kly/PkiVLMixqzi/+/v4EBgYSHx+f56lB8Hwtx5o1a/j0008JDAykdOnSDBkyhJ07dyoJ1LFjx3B0dFRehJiuVKlSrFy5ks8//5yRI0dSsWJFpk6dysKFCzP0k5SUxMiRIzMcnzNnDm3btiUyMpI//viDMWPG5PmahBBCCPHqGGm1Wm1BD0IIkXvJyck0atSIwMBA2rVr90r6iImJoWnTpvTu3Zthw4bRt29fatSowfjx419JfwCbNm1i3bp1HDx4MM9rb2JiEmRRdiZMTFQUK2ZJdPSTQjsvt6BJjPST+BgmMdJP4mNYQcXIzs5SFmUL8V9hampK//79Wb9+fb4lFCtWrKBEiRKUK1eOiIgI1qxZQ2pqKh988AEAa9asyZd+spKWlsb69esZOnRovizkl+9NhBBCiFdHEgoh3gJdu3YlPj6eqKioXG/R+iKVSsXSpUt58OABxsbGuLq6Ehoair29fT6M1rCHDx/Svn37fHlRoRBCCCFeLZnyJIR468mj9MzJVAPDJEb6SXwMkxjpJ/Ex7E2Y8iTbxgohhBBCCCFyTRIKIYQQQgghRK5JQiGEEEIIIYTINUkohBBCCCGEELkmCYUQQgghhBAi1yShEEIIIYQQQuSaJBRCCCGEEEKIXJOEQoi32Pvvv49Go+GXX37ROX727Fk0Gg0XL17M1/7Cw8PRaDTs37+/ULUlhBBCiFdHEgoh3lLXrl3j6tWrAOzZs6eAR1OwjIyMCnoIQgghxFtLEgoh3lJ79uxBpVLh6enJ/v37SU5OLughFRiVShIKIYQQ4lWRhEKIt5BWq2Xv3r14eXnRp08fYmJiOHnypN46aWlprF27lhYtWuDk5ISvry8jRowgLi5OKfPzzz/TpUsXXFxc8PT0ZOLEicTExGRoKykpienTp1O3bl38/Pz48ssvSUlJ0SmT3baEEEIIUbhJQiHEW+jcuXPcvXuX1q1b4+fnh62tLXv37tVbZ8aMGcydO5eGDRuybNkypk6diqWlJQkJCQBcunSJPn36YGlpyeLFiwkMDOTYsWP079+f1NRUnbYWLVqESqVi0aJFdOnShTVr1rBt2zblfE7aEkIIIUThZlLQAxBC5L+9e/dSpEgRmjdvjqmpKf7+/uzevZsnT55gaWmZofzff//Nli1bGD16NAMHDlSO+/v7K39ftmwZJUuWZNmyZZiamgJgb29Pv379OHHiBI0bN1bKuri4MHnyZAB8fX05e/YsBw4coGvXrjluKz+oVEaYmMj3Jy8zNlbp/FdkJDHST+JjmMRIP4mPYW9CjCShEOItk5KSwv79+2nQoAHW1tYAtGnThrCwMA4dOkS7du0y1Dlz5gxarZaOHTtm2e4vv/xC69atlQQAwM/PD7Vaza+//qqTBPj5+enUdXR05MyZM7lqKz9YWRXN1/beNmq1eUEPodCTGOkn8TFMYqSfxMewwhwjSSiEeMucOnWKqKgoGjVqRGxsLADVq1enZMmS7N27N9OEIiYmBhMTE4oXL55lu7GxsZmeL168OI8fP9Y5lp7IpDM1NeXZs2e5ais/xMcnkpwsU6leZmysQq02Jzb2KampaQU9nEJJYqSfxMcwiZF+Eh/DCipGarV5tp+KSEIhxFsmfYvYiRMnMnHiRJ1z0dHRREZGZqhja2tLSkoKkZGRWSYVNjY2mdaNjIzExsYmR2PMz7ayIy1NS0qK/EOVldTUNImPARIj/SQ+hkmM9JP4GFaYY1R4J2MJIXLs6dOnHDlyhKZNm7J+/XqdPwsWLCAlJYXvvvsuQz0vLy+MjIzYvn17lm17eHhw5MgRnd2aTp06RWxsLB4eHjkaZ362JYQQQoiCJU8ohHiLHDlyhISEBAICAvD09MxwftWqVezdu5cxY8boHHdwcKBLly4sXryYx48f4+3tTWJiIsePH2f48OGULl2aQYMG0aVLFwYOHEhAQACPHj1i/vz5uLi40KBBgxyNMz/bEkIIIUTBkoRCiLfI3r17KVu2bKbJBEC7du344osvuH37doZzU6dOpXz58mzbto3Q0FBsbW2pW7eusiuUk5MTa9asYcGCBQwfPhwLCwsaN27Mxx9/jLGxcY7GmZ9tCSGEEKJgGWm1Wm1BD0IIIV6lmJgEWZSdCRMTFcWKWRId/aTQzsstaBIj/SQ+hkmM9JP4GFZQMbKzs8z2omxZQyGEeOvJ9yZCCCHEqyMJhRBCCCGEECLXJKEQQgghhBBC5JokFEIIIYQQQohck4RCCCGEEEIIkWuSUAghhBBCCCFyTRIKIYQQQgghRK5JQiGEEEIIIYTINUkohBBCCCGEELkmCYUQQgghhBAi1yShEJkKCgpCo9Eofzw9PenatSsnTpzItz7WrVuHRqNRPp89exaNRsPFixdz1M6ECRNo3bp1vo3rRbkdkyHh4eFoNBr279+vt1zjxo2ZPn16js/lpN/ctPOqaDQaVq9eXdDDEEIIIUQOSEIhslS0aFHCwsIICwtjxowZJCUlMWjQIM6dO/dK+qtVqxZhYWE4Ojq+kvZzozCOSeSckZFRQQ9BCCGEeGuZFPQAROGlUqlwc3NTPru6utKgQQN27tyJu7t7vvdnZWWl019hUBjH9DZKTEykaNGir6x9lUoSCiGEEOJVkScUIttKly6NnZ0d//77r3Ls4cOHTJw4kSZNmuDi4kLz5s1ZsGABz54906kbHx/P+PHjqV27Nl5eXsyZM4fU1FSdMplNL0pKSmLWrFn4+fnh7OxM27ZtOXTokMGxXr16lX79+uHm5oaHhwcjRozQGTdAXFwcgYGB1K5dG29vbxYsWMCaNWsMTsNKS0tj7dq1tGjRAicnJ3x9fRkxYgRxcXEA3Lhxg9GjR9OgQQNcXV1p2bIla9asIS0tLRtRzr386jd9Ctnp06dp06YNLi4u9OjRg/DwcGJiYhg5ciTu7u40bdqU7777Tqfu8ePH6dOnD97e3ri7u9OpUye+//57nTI7duxAo9Fw/vx5+vTpg5ubG3PmzMl0LHfu3KFp06Z89NFHJCYm5iwgQgghhHgt5AmFyLYnT57w+PFjypcvrxyLjo7G1taWiRMnolar+eeffwgKCiIiIoJZs2Yp5T755BNOnjxJYGAg5cuXZ/Pmzezdu9dgn4GBgZw8eZJRo0ZRpUoVdu3axfDhwwkJCaFJkyaZ1rl37x49evSgQoUKzJ07l6SkJBYuXEiPHj3YvXs3VlZWAEycOJEzZ84wbtw4ypUrx9atW/njjz8MjmnGjBmEhYXRq1cvfH19efLkCcePHychIQFra2sePnyIg4MDbdq0wdLSksuXLxMUFERCQgLDhg0z2P7LtFotKSkpBsvlZ78RERHMnj2bwYMHY2Jiwueff05gYCDm5ubUqVOHDz/8kK1btzJu3DhcXV0pV64c8HyNRqNGjejbty8qlYrvv/+eAQMGEBoaiqenp04fY8eOpXPnzgwcOBBzc/MMY7h58ya9e/fG1dWV+fPnY2ZmlqNrEEIIIcTrIQmF0Cv9Rvbhw4fMnTsXS0tLevbsqZzXaDR8/PHHymd3d3fMzc2ZMGECU6dOxdzcnOvXr3Pw4EE+//xzOnbsCICfnx/NmzfX2/eVK1c4ePAg06ZNo0uXLgDUr1+fu3fv6k0o1q1bR0pKCmvWrMHW1haAd955h1atWvHtt98SEBDA9evXOXToEF9++SXt2rUDoF69erRo0ULvmP7++2+2bNnC6NGjGThwoHLc399f+bu3tzfe3t7A82TAw8ODxMRENm7cmKuEYvPmzWzevNlgufzs9/Hjx2zcuJFq1aoBz3/+M2bMoH///gwdOhQAZ2dnDh06xOHDh+nVqxcAPXr0UNpIS0vD09OT69evs3Xr1gwJRZcuXRgwYECm/V+5coW+ffvi5+fHrFmzMDY2ztH4X6ZSGWFiIg9kX2ZsrNL5r8hIYqSfxMcwiZF+Eh/D3oQYSUIhspSQkECtWrWUz8bGxnz11VdUqVJFOabVagkNDWXr1q2Eh4eTlJSknLtz5w7Vq1fn4sWLaLVamjVrptNW06ZNWbduXZb9//rrrwC89957OsdbtGjBrFmzSEhIwMLCIkO9X375BU9PTyWZAHB0dKRGjRr8+uuvBAQEKFOYXkxKVCoVjRo1Yu3atVmO6cyZM2i1WiUxykxSUhLLly9nz5493Lt3j+TkZOXckydPsLS0zLJuZlq0aEG/fv0yHB88ePAr67dUqVJKMgFQuXJlAHx8fJRjarUaOzs77t+/rxy7f/8+Cxcu5PTp00RERKDVagF0fo/SNWzYMNO+L168yLJly2jZsiWfffZZviyotrJ6desz3gZqdcYnREKXxEg/iY9hEiP9JD6GFeYYSUIhslS0aFE2btyIVqvln3/+Yf78+Xz88cfs2bOHUqVKARAaGsqXX37JRx99hKenJ2q1mosXLzJ9+nQluYiIiMDU1BQbGxud9osXL663/8ePH2NqaqqTGACUKFECrVZLXFxcpglFbGws77zzTobjxYsX5/Hjxzpjsra21iljZ2end0wxMTGYmJjoHfvcuXPZtm0bQ4cOxcnJCWtra44cOcLSpUtJSkrKcUJhZ2eHs7NzhuMvTwHKz37VarXOZ1NTU4AM8TIzM1N+zmlpaQwePJi4uDhGjBhBpUqVMDc3Z8mSJdy7dy9DHyVKlMi07x9//JGnT5/SsWPHfNudKT4+keTkVMMF/2OMjVWo1ebExj4lNfXVrvF5U0mM9JP4GCYx0k/iY1hBxUitNs/2UxFJKESWVCqVciPr4uKCg4MDH374ISEhIUybNg2A/fv307hxY8aOHavUu3Hjhk47JUuWJDk5mcePH+skFZGRkXr7t7GxybTeo0ePMDIyynBz+2K9zNqOjIxUvmlPH1NcXJxOO1FRUXrHZGtrS0pKCpGRkVkmFfv376dz584603ny8/0dWSmoftPdunWLP//8k5CQEJo2baocz+li6n79+nHp0iU++ugj1q9fr7NIPrfS0rSkpMg/VFlJTU2T+BggMdJP4mOYxEg/iY9hhTlGhXcylih0nJ2dadWqFTt27CAiIgJ4frOY/u11uj179mSoB+jszpSamsrhw4f19ufh4QGQ4eVv+/fvp2bNmpk+nUivd+bMGeVpBDxf4Hv16lWlTScnJwCOHDmilElLS+PYsWN6x+Tl5YWRkRHbt2/PskxSUpJOTFJTU9m3b5/edvNDQfX7Yv+Azhju3r3L+fPnc9SOsbEx8+fPp3bt2vTp04ebN2/m6ziFEEIIkb/kCYXIkSFDhvDdd98RGhpKYGAgPj4+rF+/no0bN1K5cmV2797NrVu3dOpUrVqVZs2a8cUXX5CUlKTs8vTiHP/M1KhRg+bNmzN79mwSExNxcHBg9+7dnD9/nq+++irLer1792bHjh307duXwYMHk5SUxKJFi7C3t6d9+/YAVKtWjWbNmvH555/z9OlTypYty9atW0lMTNQ7zcbBwYEuXbqwePFiHj9+jLe3N4mJiRw/fpzhw4dTunRpfHx82LZtG1WrVqVYsWJs3rw5wza6r0JB9ZuuSpUqlClThvnz55OWlkZCQgJLlixRpsflhKmpKUuWLGHQoEH07t2bTZs2UaFChVcwaiGEEELklTyhEDlSpUoVWrZsyZYtW4iLi2Po0KG0adOGJUuWMGbMGIoUKcLkyZMz1Pviiy9o3Lgx8+bNY/z48Tg4OCg7A+kzd+5cOnXqxMqVKxkyZAh//fUXS5YsoXHjxlnWsbe3Z8OGDdjY2BAYGMiUKVOoUaMGGzZsULaMTR9Tw4YNmTNnDuPHj6dChQq0b98+y6lU6aZOncro0aM5fPgwgwYN4rPPPtNZ9DxlyhTq1q3LjBkzmDRpEtWrV2fQoEEGrzWvCqrfdGZmZgQFBWFmZsbIkSNZsmQJgwcP5t133811eyEhIVSsWJFevXplug5DCCGEEAXPSJu+DYsQgu7du6NSqdiwYUNBD0Xko5iYBFmUnQkTExXFilkSHf2k0M7LLWgSI/0kPoZJjPST+BhWUDGys7OURdlCGHLgwAHu3btH9erVefr0KXv37uWXX34hJCSkoIcm8pl8byKEEEK8OpJQiP8sCwsLdu3axT///ENycjJVqlRh7ty5OjsUCSGEEEII/SShEP9Z9erVo169egU9DCGEEEKIN5osyhZCCCGEEELkmiQUQgghhBBCiFyThEIIIYQQQgiRa5JQCCGEEEIIIXJNEgohhBBCCCFErklCIYQQQgghhMg1SSiEEEIIIYQQuSYJhRDirWdkZFTQQxBCCCHeWpJQCFHIBQUFodFo0Gg01KhRAw8PD9q0acP06dO5ceOGTtnGjRszffr0HLV/9uxZNBoNFy9ezLfxnjt3Ll/ayg9arRZr66KoVJJUCCGEEK+CvClbiDdA0aJFCQ0NBeDJkyf89ddfhIWFsXXrVmbOnEnbtm0BCA4ORq1WF+RQCQ4OxsLCAnd39wIdRzojIyOMjY1QqYxIS9MW9HCEEEKIt44kFEK8AVQqFW5ubspnX19funXrxoABA5g0aRLu7u5UqFCBmjVrFtwghRBCCPGfJFOehHhDFSlShClTppCcnMy2bduAjFOezp8/z6BBg/Dz88PNzY22bduyc+fOTNuLiopi2LBhuLm54efnx7JlyzKUuXHjBoMHD8bDwwM3NzcGDBjA7du3lfMajQaAOXPmKNO0zp49CzyferR69Wr8/f1xcnKiSZMmrFu3Tqf9+/fvM3LkSHx8fHB2dqZx48Z88cUXeQmTEEIIIV4xeUIhxBusatWqlC5dmvPnz2d6/t9//8Xd3Z2uXbtiZmbGuXPnmDx5Mlqtlvbt2+uUnTJlCq1atSIoKIjTp0+zcOFCbGxs6Nq1KwB37tyhS5cuVKtWjdmzZ2NkZMSyZcvo3bs3+/fvx8zMjLCwMDp37kxAQACtW7dWxggwc+ZMtm3bxqBBg3B1deXcuXPMmzePIkWKKH2MHz+ehw8fMnnyZIoXL869e/e4dOnSqwqfEEIIIfKBJBRCvOHs7e159OhRpudatWql/F2r1VK3bl0ePHhAWFhYhoTCy8uLjz/+GIB69eoRGRnJ0qVL6dy5MyqViuDgYGxsbFi7di1FihQBwN3dnSZNmrBt2za6d++uTMuyt7fXmaJ1+/ZtNm7cyLRp0+jcuTMAPj4+JCYmEhISovRx8eJFxowZQ8uWLZW67dq1y2uIADA2lgeyL0uPicQmaxIj/SQ+hkmM9JP4GPYmxEgSCiHecFqtNsttUR8/fkxQUBBHjhzhwYMHpKamAmBra5uhbLNmzXQ++/v7s2vXLu7fv0/ZsmU5deoULVu2xNjYmJSUFADUajU1a9Y0+BTh9OnTADRv3lypC8+TipUrV3Lv3j3KlStHzZo1WbNmDcbGxvj6+lKpUqVsx8EQtdo839p620hsDJMY6SfxMUxipJ/Ex7DCHCNJKIR4w92/f5/KlStnem7ChAmcP3+eoUOHUrVqVaysrNiyZQv/+9//MpS1s7PT+VyiRAkAIiIiKFu2LNHR0YSGhiq7Tb3I1NRU7xijo6PRarV4eXllej49oVi4cCELFy5k0aJFTJs2DQcHB8aMGUPz5s31tp8dsbFPSU1Ny3M7bxNjYxVqtbnERg+JkX4SH8MkRvpJfAwrqBip1ebZfioiCYUQb7Br167x4MGDDNOXAJKSkjh+/DgTJkwgICBAOb558+ZM24qKitL5nD6NqmTJkgDY2NjQoEEDunXrlqGupaWl3nHa2NhgZGTE5s2bM00+HBwcAChVqhSzZs0iLS2NS5cusXTpUkaPHs3+/fupUKGC3j4MSU1NIyVF/rHKjMTGMImRfhIfwyRG+kl8DCvMMZKEQog3VFJSEjNmzMDMzIxOnTplOP/s2TPS0tJ0buDj4+M5evRopu0dOnRIZ9rTgQMHKFWqFGXKlAHA29uba9euUbNmTYyNjbMcl6mpKUlJSTrHvL29AYiJiaFx48YGr02lUuHi4sKoUaM4evQot27dynNCIYQQQohXQxIKId4AaWlp/PbbbwAkJCQoL7a7c+cOs2fPpnz58hnqWFtb4+zszMqVK7Gzs8PExIQVK1ZgZWWV4WkEwJkzZ/jyyy/x9fXl1KlT7Nq1i6lTp6JSPX/cOWLECDp27Ei/fv348MMPKVGiBI8ePeKnn36iTp06yq5OVapU4ciRI9SpUwdzc3McHBxwcHCge/fujB8/nn79+uHq6kpycjL//PMPZ8+e5auvviIuLo5+/frRtm1bHBwcSE5OZsOGDco6DSGEEEIUTpJQCPEGSExMVHZHsrCwoHz58nh7exMcHIyjo2OW9ebPn8/UqVOZMGECtra2BAQEkJCQwJo1azKUnT59OmFhYWzZsgVLS0tGjhxJ9+7dlfOVKlVi27ZtyvqGhIQESpYsSd26dZX3TwBMnTqVL774gv79+5OYmMj69evx9PRk8uTJODg4EBYWRkhICJaWljg4OPDee+8Bz9+rUb16dTZs2MC9e/coWrQoTk5OrF69OsP6jpzQarWkpWnlLdlCCCHEK2Kk1WrlX1khxFstJiaB5OTUgh5GoWNioqJYMUuio58U2nm5BU1ipJ/ExzCJkX4SH8MKKkZ2dpbZXpRdeDe0FUKIfCLfmwghhBCvjiQUQgghhBBCiFyThEIIIYQQQgiRa5JQCCGEEEIIIXJNEgohhBBCCCFErklCIYQQQgghhMg1SSiEEEIIIYQQuSYJhRBCCCGEECLXJKEQQgghhBBC5JpJQQ9ACCFetey+6TM/paVpSUuTF+oJIYR4+8kTiv+43bt306VLF2rXrk3t2rXp3LkzO3fuLOhhvXJPnz4lODiYli1b4urqiqenJx988AELFy7McVs7duxgz549r2CUhl2+fJmgoCCePn2aYUwajYaoqKjXOp5NmzbxwQcfKJ+fPHnC2LFj8fDwoG3btly4cEGnfHJyMu+99x6HDh3K0FafPn1YunRpnsek1WpRq80pVszytf6xtbVApTLK8/iFEEKIwk6eUPyHzZgxQ7kBHDJkCEZGRhw4cIAJEyZw8eJFpkyZUtBDfGVGjBjBhQsXGDhwIO+88w6xsbFcvHiRw4cPM3r06By19e2332JhYUGbNm1e0WizdvnyZYKDg+nevTvm5ubK8YYNGxIWFoZarX5tY3n69ClLly7V+b1Zvnw5169fZ9GiRXz77beMGjWKAwcOYGpqCkBoaCj29vY0a9YsQ3sDBw5k+PDhdOvWDRsbm1yPy8jIiHmbfiX8QVyu28ip8qWtCezugUplJE8phBBCvPUkofiPOnLkCBs3bmTYsGEMHz5cOV6vXj1KlSpFSEgIvr6+NG7cuABH+WrcunWL77//ni+//JJ27dopx/39/RkzZkzBDez/S0xMpGjRonlqw87ODjs7u3waUfZ89913JCcn06RJE+XYqVOnGDRoEPXq1eOdd97B19eXW7duUbVqVSIiIli5ciWbNm3KtD0vLy/UajXffvstvXv3ztPYwh/EcePu4zy1IYQQQojMyZSn/6jQ0FBsbGzo27dvhnP9+vXDxsaG0NBQAOLj42nUqBEjRozQKTd16lQ8PT158OABR48eRaPR8M8//+iUefz4MS4uLjo3jV9//TWNGjXC1dWVPn368Oeff6LRaNixY4dO3R07dtCmTRucnZ2pV68eCxcuJDU1Vee8RqPhzz//5KOPPsLNzY3mzZsbnLL1+PHzG8uSJUtmOKdS6f5PYt68ebRp04batWtTr149xowZw8OHD5XzAQEB/PTTTxw/fhyNRoNGoyEoKAiAxo0bM336dJ32Dh8+jEajITw8HIDw8HDl2idPnoynpyedOnUC4Pjx4/Tp0wdvb2/c3d3p1KkT33//vc71T5w4EQBvb280Go2SAGY25SkmJoaJEyfi6emJi4sLXbp04eeff9YZX0BAAAMHDmT//v34+/tTu3Ztevbsye3bt/XGFGDnzp00adIEE5P/+57i2bNnSnKU/t9nz54psW3bti1Vq1bNss333nvvPzEFTwghhHiTSULxH5SSksL58+fx9PTE0tIyw3lLS0s8PT05f/48KSkpWFlZ8cUXX3Dw4EHl5u7EiROEhYXx6aefUrp0aRo0aEDp0qXZvn27Tlt79+4FUKYDHTlyhE8//RRfX1+Cg4Px9vZm1KhRGcawdu1aJk+ejJ+fH8uWLaN///6sX78+0zUOgYGB+Pn5ERISwjvvvMOECRO4ceNGltdfpUoVLCwsmD17NseOHePJkydZlo2MjGTgwIEsX76cSZMmcffuXQICAkhJSQHg008/pWbNmri7uxMWFkZYWJiSEOTEggUL0Gq1zJ8/n3HjxgHPk41GjRoxZ84cgoKCcHd3Z8CAAZw9exZ4Pq1p8ODBAKxatYqwsDCCg4MzbT81NZX+/ftz7NgxAgMDWbx4MRYWFvTp04dLly7plL18+TKrV68mMDCQWbNmcfv2bWVMWUlMTOT8+fO4u7vrHHd2dmbr1q1ER0ezfv16rK2tqVy5Mr/99hs//PCDztOxzNSuXZvLly+/9rUgQgghhMg+mfL0HxQdHc2zZ8+wt7fPsoy9vT1JSUnExMRQokQJvL296dGjB59//jkajYZJkybRunVrWrZsCYCxsTEdOnRg+/btjBo1CmNjYwC2b99Os2bNlLn8S5cuxcvLi88//xx4PsUqJSWFxYsXK33Hx8ezZMkSPvroI2UKkq+vL6ampsyePZt+/fpRrFgxpXz37t3p3r078PwG9MSJExw4cIAhQ4Zkem1WVlbMnDmTyZMnM2jQIIyNjalRowbNmjWjV69eWFhYKGVnzZql/D01NZXatWtTv359zpw5g5+fH1WrVsXKygoLCwvc3Nyy/TN4WY0aNZg5c6bOsR49eih/T0tLw9PTk+vXr7N161Y8PT2xs7OjYsWKANSqVUvvFKfjx49z4cIFVq1aRb169QDw8/OjefPmLF++XHmqAhAXF8fOnTuV9hISEpg4cSL379+nTJkymbZ/+fJlkpOT0Wg0OseHDh1K37598fLywtTUlC+++AJzc3M+//xzRo0ahbW1tcG4AFy4cIGGDRvqLVsYFcTuUjmRPr7CPs6CJDHST+JjmMRIP4mPYW9CjCShENkWGBjIqVOn+PDDDylWrBhTp07VOd+xY0eWLVvGyZMnadiwIVeuXOGPP/5Qvt1OTU3l8uXLjB8/XqdekyZNdBKK8+fPk5CQwHvvvac8CQDw8fEhMTGRa9eu8e677yrH/fz8lL9bWFhQtmxZ7t+/r/daWrZsia+vL8eOHePs2bOcOXOGRYsWsXv3brZv364kFSdOnGDp0qVcu3aN+Ph4pf4///yj029eZXazfP/+fRYuXMjp06eJiIhAq32+uLdWrVo5bv+XX37ByspKSSYATE1NadasmfIUKV2NGjV0kpP0KUn6EoqIiAiADElNuXLl+O6777hz5w4lSpTAysqKbdu2odVq6dixI7///jvTpk0jPDwcDw8PZs6cqdNGeuKY3v6bRq02N1yoEHhTxlmQJEb6SXwMkxjpJ/ExrDDHSBKK/6BixYphZmbGvXv3sixz7949ihQpgq2trXKsaNGiNG3alBUrVtC6desMO++UL18eX19fvvnmGxo2bMj27dspX748Xl5eAERFRZGSkpLhprN48eI6n6OjowFo3759lmN70cvfcpuamirz9PWxsbGhXbt2tGvXDq1Wy5IlS/jqq6/45ptv6NmzJxcuXGDIkCE0adKE/v37U7x4cYyMjPjwww9JSkoy2H5OvByDtLQ0Bg8eTFxcHCNGjKBSpUqYm5uzZMkSvT+3rMTGxmboA6BEiRLKmpJ0L+8Mlb4jk75rTj9nZmaW4ZyxsTGVK1cGnj/9WLRoESEhISQnJzN8+HB69uxJt27dCAwM5PPPP2fBggVK3fT2EhMTs3GVhU9s7FNSU9MKehhZMjZWoVabF/pxFiSJkX4SH8MkRvpJfAwrqBip1ebZfiqSp4QiPj6euLg4nakzDx484Ouvv+bZs2f4+/vj4uKSly7EK2BiYkLt2rX56aefSEhI0JniA8+nuPz000/Url1bZ4HtlStXWLt2LTVr1mTjxo188MEHODo66tTt1KkTgYGBPHjwgD179hAQEICR0fO9+O3s7DAxMckwHz4yMlLnc3qiEhwcnOk34uXLl8/9xWfByMiIfv368dVXXynrLw4fPoyVlRWLFi1SFmvfvXs3222amZmRnJysc+zlm/cX+3/RrVu3+PPPPwkJCaFp06bK8dzeWNvY2GSIM8CjR4/ytCXri+3D88Qls8Xu6YKCgvDz88PNzY0rV67w4MEDunbtioWFBZ06dWLChAk65ePinm/1+mJi+yZJTU0jJaXw/wP5poyzIEmM9JP4GCYx0k/iY1hhjlGeJmNNnTqVkSNHKp/j4+Pp3LkzS5cuZe3atXTv3l1ZQCoKl169ehETE8OaNWsynFuzZg0xMTH06tVLOfbs2TPGjx+Pi4sLYWFhVKtWjfHjx+tMSYLn05fUajVjx47l8ePHdOjQQTlnbGzMO++8w5EjR3TqHD58WOdz7dq1MTc35/79+zg7O2f48+L6idyIj4/P9MY8fYeq9BvixMRETE1NdW72M3uBnampaabf3pcpUybD4vBTp05la4zp7aU/HYDnycz58+cz9A0YfCLj4eFBfHw8P/zwg3IsJSWFw4cP4+Hhka0x6ePg4ACg7F6VmRs3brBr1y4CAwN1jqf/LF5+Od+L7aW3L4QQQojCJ09PKH799Vc6d+6sfN61axcPHz7k66+/pmrVqvTu3ZulS5fi6emZ54GK/NWkSRN69OhBcHAw9+/f57333gPg4MGDbN26lR49eui8g2LJkiXcuXOHXbt2YWZmxpw5c2jfvj1Lly7V2anH1NSUdu3asXr1avz8/DIs/B48eDBDhgxh8uTJvPfee/z555/KzlHpTwHUajUjRoxg7ty53L9/n3fffRdjY2Pu3LnDkSNHCAoK0nmJW079/fffDB48mPbt2+Ph4YGFhQXXr19n5cqVWFtbK1OtfH19CQ0NZcaMGTRr1ozz58+za9euDO1VqVKFnTt3cvToUUqWLEmpUqUoXbo0/v7+fPbZZwQHByuLxX/77bdsjbFKlSqUKVOG+fPnk5aWRkJCAkuWLKFUqVI65dKfEG3atImmTZtStGjRDAuj4fkaDRcXF8aNG8fYsWMpUaIEGzZs4OHDhyxZsiSHEcyoQoUKlCxZkj/++IMGDRpkWmbmzJn0799fSdiqVKlCqVKlmDVrFu3atWP58uXK9Lh0ly5dwsLCgnfeeSdP4ytfWv/i7/z2uvsTQgghClKeEoro6GhKly6tfD569CgeHh7Kbjft2rXLchtLUfCmTJmCq6srmzdvVpKC6tWrM3v2bJ0Xvp07d47Vq1fz6aefKrsKOTo6MmbMGObOnUvDhg1xdnZWyjdr1ozVq1fzwQcfZOizSZMmfPbZZyxfvpzdu3fj6urKZ599Rt++fbGyslLK9e3bl9KlS7N27Vo2btyIiYkJFStWpGHDhjrf2udGpUqV6Ny5M6dOnWLbtm08efKE0qVL4+XlxaBBgyhXrhwADRo0IDAwkI0bN7Jjxw7c3d1Zvnw5/v7+Ou3179+f27dv8/HHHxMbG6u8LLBTp07cvn2bLVu2sG7dOlq2bMmYMWMYO3aswTGamZkRFBTE9OnTGTlyJPb29gwePJgzZ87obPNas2ZNhg8fzrZt21i1ahX29vYcPXo0Q3vGxsasWLGCOXPmMHfuXBISEqhVqxZr1qzByckpT/FM99577/H9999nurvWoUOHuHv3rs5TLzMzMxYvXsy0adMYPnw4derUYdKkSTr1vv/+e5o1a6bsGpYbWq2WwO55fwqTU6mpafKWbCGEEP8JRtr0rWNywc/PT3kRVmJionJDNmjQIAC2bNnCl19+me1vZcXbYfHixWzevJmTJ09mukj3Zdu2bWPy5MkcOXLklayPEK/HlStXaN++PYcPH1aSsrx4/Pgxvr6+rF27lrp16+aprYJY7JeWpi30CYWJiYpixSyJjn5SaOflFjSJkX4SH8MkRvpJfAwrqBjZ2Vm+nkXZtWvXZvPmzVSpUoWTJ0+SlJREkyZNlPP//POPzhMM8Xa7efMmf//9Nxs3bqRbt26ZJhMxMTEEBwfj5eWFpaUlFy9eZNmyZTRp0kSSiTdcjRo1aNy4MevXr1fe4J0XGzZswN3dPc/JBBTuhWxCCCHEmy5PCUVgYCB9+/ZVpsv06dOHatWqAc/fObB//36dfe/F2+3TTz/lt99+o169egwcODDTMiYmJty5c4e9e/cSFxdHsWLFaNu2bYaFuuLNNG7cuAyL7nPL1taWyZMn50tbQgghhHh18jTlCSA5OZkbN25gZWWl8w1zfHw8Z86coUaNGvLNsxCiQMmj9MzJVAPDJEb6SXwMkxjpJ/Ex7K2f8gTPd/WpUaNGhuNWVlY6++cLIYQQQggh3j55eg8FPH8SsWLFCvr160e7du24cOEC8Hyu/Nq1a7l161aeBymEEEIIIYQonPL0hOL+/fv06NGD+/fvU6lSJW7evMmTJ0+A5/Ofv/76a+7evSvzoIUQQgghhHhL5SmhmDNnDk+ePGHnzp3Y2dnh4+Ojc75p06YcP348L10IIYQQQgghCrE8TXk6deoUAQEBVK1aFSMjowznK1SowL179/LShRBCCCGEEKIQy1NCkZiYiJ2dXZbn06c/CSGEEEIIId5OeZry5OjoyM8//0yXLl0yPX/48GFq1qyZly6EECLPsrvtXUF4E96oLYQQQuiTp39le/XqxXfffceKFSuIj48HQKvVcuvWLcaNG8dvv/1G796982Oc4gUnTpygf//+eHl5UatWLXx8fBgwYAB79+4lLe3t3sP52bNnTJw4ES8vLzQaDevWrTNY5/3330ej0fDLL79kOHf27Fk0Gg0XL17M13GGh4ej0WjYv39/oWrrdapTpw5BQUEFPQy0Wi1qtTnFilkWyj+2thaoVBmnjAohhBBvijw9oWjbti3//vsvixcvZtGiRQB89NFHaLVaVCoVo0ePlndR5LMFCxawfPlymjVrxtSpUylZsiSPHj3i8OHDjBs3Dhsbm7f67eS7du1i165dzJ49m4oVK1KuXDm95a9du8bVq1cB2LNnD3Xq1HkdwxSFiJGREfM2/Ur4g7iCHkoG5UtbE9jdA5XKSJ5SCCGEeGPl+cV2gwcPpm3bthw8eJBbt26RlpZGxYoVad68ORUqVMiPMYr/7/jx4yxfvpxhw4YxfPhwnXMtWrSgV69emJhk/SNNTU0lLS0NU1PTVz3UV+bmzZuUKlWK999/P1vl9+zZg0qlom7duuzfv5/Jkye/0ddfUN70353wB3HcuPu4oIchhBBCvJVyPeXp6dOndOjQgS1btlC2bFl69+7Np59+yrRp0+jXr58kE6/A2rVrKVmyJIMHD870vIuLi86alYCAAAYOHMi3336Lv78/zs7OXLlyhYcPHzJx4kSaNGmCi4sLzZs3Z8GCBTx79kynPY1Gw4oVK1i4cCHe3t7UqVOHOXPmoNVq+fHHH2nbti21a9emV69eGXbzWrFiBc2aNcPZ2RkvLy969+7NnTt39F7f3bt3GTFiBB4eHri5udGvXz/l6QJA48aNWbNmDffu3UOj0aDRaAgPD8+yPa1Wy969e/Hy8qJPnz7ExMRw8uRJvWMASEtLY+3atbRo0QInJyd8fX0ZMWIEcXH/9w13+tohFxcXPD09mThxIjExMRnaSkpKYvr06dStWxc/Pz++/PJLUlJSdMpkty1D0n9ec+bMwcvLi9q1azNhwgRlOmK62NhYPvvsM/z8/HBycqJDhw788MMPOmWy+t3JyuHDh3nvvfdwdnamY8eOygsuX3T8+HH69OmDt7c37u7udOrUie+//145HxUVhZOTE1u3bs1Qt1OnTowcOTKnIRFCCCHEa5DrJxTm5uaEh4dnul2syH8pKSmcO3cOf39/vU8hXnbp0iXu3r3LyJEjUavV2NvbExkZia2tLRMnTkStVvPPP/8QFBREREQEs2bN0qm/adMm3n33XebMmcPvv/9OUFAQaWlpnDp1isGDB2Nqasrnn3/OpEmTWLNmDQA7d+5k8eLFjBgxAjc3N+Li4vj111/17voVHx9PQEAAKpWKadOmUaRIEZYuXUqPHj3YvXs39vb2BAcHs3LlSn7++WeCg4MBKFWqVJZtnjt3jrt37zJ06FD8/PywtbVl7969NG7cWG/MZsyYQVhYGL169cLX15cnT55w/PhxEhISsLa25tKlS/Tp0wdPT08WL17Mo0ePmD9/PtevX+frr7/G2NhYaWvRokU0adKERYsWcf78eYKCgqhYsSJdu3ZVfj7ZbSs7NmzYQK1atfjyyy8JDw9n3rx5JCUlsXDhQuD5GpQ+ffoQGRnJqFGjKF26NLt372bgwIHs2LEDjUajtJXZ705mLl++zIgRI6hfvz4TJ04kPDycUaNGZUhQw8PDadSoEX379kWlUvH9998zYMAAQkND8fT0xM7OjmbNmrF9+3Y+/PBDpd61a9e4cOECI0aMyFEshBBCCPF65GnKU7169fjhhx+y3OVJ5J+YmBiePXuW4aZOq9WSmpqqfFapVKhU//fg6fHjx3zzzTc69UqUKMHHH3+sfHZ3d8fc3JwJEyYwdepUzM3NlXOlSpVi7ty5wPOf99GjR1m3bh379u3D0dERgAcPHjBjxgxiY2NRq9VcuHABjUbDwIEDlXYMraXZsWMH//77r067devWpVGjRoSGhjJhwgRq1qxJiRIlMDMzw83NzWDM9u7dS5EiRWjevDmmpqb4+/uze/dunjx5gqWlZaZ1/v77b7Zs2cLo0aN1xu/v76/8fdmyZZQsWZJly5YpU4Ds7e3p168fJ06c0ElYXFxclDfF+/r6cvbsWQ4cOKAkFDlpKzvMzMwICQlREpEiRYowefJkhg0bhqOjI3v27OHKlSvs2rWLqlWrAs9/rrdu3eKrr75i8eLFSluZ/e5kZsWKFdjb22fod9KkSTrlevToofw9LS0NT09Prl+/ztatW/H09ATgww8/pHfv3ty4cUP5Pdi+fTv29vb4+vrmKBZvkoLahSq938K8C1ZBkxjpJ/ExTGKkn8THsDchRnlKKIYMGcLIkSMZN24cnTt3pkKFChQpUiRDOVtb27x0I17w8hOhAwcO6EwF6d69O1OnTlU+V69ePdMkJDQ0lK1btxIeHk5SUpJy7s6dO1SvXl35/PLbzx0cHHj06JFyswdQuXJlAO7fv49araZmzZps3ryZWbNm0axZM1xdXQ3Ovf/ll1+oVq2aTru2trb4+Pjw66+/6q2bmZSUFPbv30+DBg2wtrYGoE2bNoSFhXHo0CHatWuXab0zZ86g1Wrp2LGj3rG2bt1a55r8/PxQq9X8+uuvOkmAn5+fTl1HR0fOnDmTq7ayo1GjRjpPNd577z0mTZrExYsXcXR05NSpU1SvXp3KlSvrTL3y8fFh9+7dOm1l9ruTmd9//53GjRtn2u+L7t+/z8KFCzl9+jQRERFotc8XIdeqVUsp4+XlRYUKFfjmm2/4+OOPSUlJYffu3XTu3FknUX7bqNXmhgu9xf2/CSRG+kl8DJMY6SfxMawwxyhPCUWrVq0AuH79Onv37s2y3OXLl/PSjeD5zbWZmRn379/XOe7t7c0333wDkOnaihIlSmQ4FhoaypdffslHH32Ep6cnarWaixcvMn36dJ3kAkCtVut8NjU1zfQYoNTt0KEDT548YevWraxbtw5ra2vatWtHYGAgRYsWzfT6YmNjMx1r8eLFuXbtWqZ19Dl16hRRUVE0atSI2NhY4PkNcsmSJdm7d2+WCUVMTAwmJiYUL148y7ZjY2MzPV+8eHEeP9Zd+JuezKQzNTXVmQqUk7ay4+W2rKysKFKkCA8fPgQgOjqaP//8U+cmPt3L06sy+3lkJiIiIst+06WlpTF48GDi4uIYMWIElSpVwtzcnCVLluisvzEyMqJTp06sX7+esWPHcvz4caKioujQoUO2xvKmio19Smrq69/y2dhYhVptXmD9vwkkRvpJfAyTGOkn8TGsoGKkVptn+6lInhKKoUOHyhqK18TExAR3d3d+/PFHUlNTlZs/GxsbnJ2dgefTXV6W2c9n//79NG7cmLFjxyrHbty4kW9jValU9OrVi169evHgwQP27dvH/PnzKVasGEOHDs20jo2NDX///XeG45GRkdjY2OR4DHv27AFg4sSJTJw4UedcdHQ0kZGRmd7I29rakpKSkuX59LFGRkbmy1jzs630ei+Kj48nKSlJWWtiY2ODRqNh5syZBtvK7v+2S5YsmWW/6W7dusWff/5JSEiIzvS3xMTEDO116NCBJUuWcPz4cb755hs8PT3f+k0eUlPTSEkpuH9IC7r/N4HESD+Jj2ESI/0kPoYV5hjlKaF4eetS8Wr16dOHgQMHsmzZsixvzLMjMTExwxSk9Bvw/Fa6dGn69u3L3r17uXnzZpblPDw8OHDgADdv3qRKlSrA8zn8p0+fpnPnzjnq8+nTpxw5coSmTZvSs2dPnXOPHj1izJgxfPfddwQEBGSo6+XlhZGREdu3b2fAgAFZjvXIkSNMmDBBWSB/6tQpYmNj8fDwyNFY87MtgGPHjjFx4kQl4dy/fz9GRkZK0unj48OJEycoVaoUpUuXznH7mXFxccm03xelJxcv/t7dvXuX8+fPK1Pm0pUsWZKGDRuyatUqLl68mGGjACGEEEIULnl+D4V4fRo2bMiAAQNYsmQJV65coUWLFpQqVYq4uDh++eUXIiIislxs/CIfHx/Wr1/Pxo0bqVy5Mrt37+bWrVv5Ns6pU6eiVqtxc3NDrVZz7tw5rly5oixEzkyHDh1Yt24dAwcOZNSoUcouTyYmJvTq1StH/R85coSEhAQCAgKUxb4vWrVqFXv37s00oXBwcKBLly4sXryYx48f4+3tTWJiIsePH2f48OGULl2aQYMG0aVLFwYOHEhAQICyM5OLiwsNGjTI0Vjzsy14vovT0KFD6dq1q7LLk7+/v7I2pV27dnz99df07NmTvn37UrlyZeLi4vjzzz9JTk7WeWqVXQMGDKBjx446/a5evVpnylOVKlUoU6YM8+fPJy0tjYSEBJYsWZLlLl0ffvghAwYMQK1W6yyIz63ypa0NFyoAhXVcQgghRE7kKaFI37pTHyMjozx9my50jR07Fg8PDzZt2sS0adOIj4/HxsaGWrVq8cUXXyjrWvQZOnQo0dHRLFmyBHi+g9HkyZMZNGhQvoyxdu3abN26lW3btvH06VMqVKjAxIkT6dSpU5Z1rKys2LBhA7Nnz2bKlCmkpaXh7u7Oxo0bs7Uw+EV79+6lbNmymSYT8Pym+osvvuD27duZnp86dSrly5dn27ZthIaGYmtrS926dZVkzcnJiTVr1rBgwQKGDx+OhYUFjRs35uOPP87xNq/52RY8f39EVFQU48eP59mzZ8ob1dOZmZmxfv16goKCWLZsGREREdja2lKzZk26deuW4/4AatasyeLFi5k3bx7Dhg2jWrVqLFy4kH79+un0GxQUxPTp0xk5ciT29vYMHjyYM2fOcOnSpQxt+vn5YW5uTqtWrTLd6CEntFotgd1z/rTndUlNTZO3ZAshhHijGWnTt1rJhRo1amTdsJERWq0WIyMjWZQtxGug0WgYP368zo38m+rHH3+kd+/ebN++HScnpzy3V5gX+6WlaQssoTAxUVGsmCXR0U8K7bzcgiYx0k/iY5jESD+Jj2EFFSM7O8vXsyg7szfnpqWlcffuXTZv3szPP//MypUr89KFEOI/5MGDB9y+fZu5c+fi7u6eL8kEFO6FbEIIIcSbLt83dlepVFSoUIGPP/6YSpUq8fnnn+d3F0KIt9TWrVuVhfTy/x1CCCHEm+GVLsquW7cu8+bNe5VdCCH+v6tXrxb0EPJs+PDhsnucEEII8YZ5pa+evXTp0lv9dlshhBBCCCH+6/L0hGLnzp2ZHo+NjeWXX37h4MGDenf2EUIIIYQQQrzZ8pRQTJgwIctzxYoVY8CAAbJlrBBCCCGEEG+xPCUUR44cyXDMyMgItVqNlZVVXpoWQgghhBBCvAHylFAYGRlhZ2dH0aJFMz2fmJhIVFQUZcuWzUs3QgghhBBCiEIqTyummzRpwqFDh7I8f/ToUZo0aZKXLoQQQgghhBCFWJ6eUBh6yXZycrLs8iSEKHDZfdPnm6wg37gthBDivy3HCUV8fDyxsbHK55iYGP79998M5WJjY/nuu+8oWbJk3kZYSL3//vtcvXqVTZs2UadOnYIeTqZ27NiBqakpbdq0yXHdy5cvc/jwYT766CPMzc3zZTxBQUH4+vri7u6eL+29SXbs2MHEiRP58ccfsbOzK+jh5EhSUhLNmzdn2rRpNGzYEIDGjRvTsGFDpk6dmqF827Zteeedd5g9e7bO8R9++IFhw4Zx9uxZ9u3bpzce8fHxNG7cmKVLl+Lh4ZGn8Wu1WtTq/PkdLsxSU9OIiUmQpEIIIcRrl+OEYt26dYSEhADP11B88cUXfPHFF5mW1Wq1jBo1Kk8DLIyuXbumvERsz549hTah+Pbbb7GwsMh1QhEcHEz37t3zLaEIDg7GwsLiP5lQNGzYkLCwMNRqdUEPJce2bNmCWq1WkoncOnbsGN7e3hQpUsRgWSsrK3r06MHChQvZuHFjnvo1MjJi3qZfCX8Ql6d2CrPypa0J7O6BSmUkCYUQQojXLscJha+vLxYWFmi1WubOnUurVq2oVauWThkjIyPMzc2pVasWzs7O+TbYwmLPnj2oVCrq1q3L/v37mTx5MqampgU9LEViYmKWC+XfBG/6+DNjZ2f3xj2ZgOdfCqxfv56ePXvmua3jx48zcODAbJf/4IMPCAkJ4cqVK9SoUSNPfYc/iOPG3cd5akMIIYQQmcvxxOLatWvTt29f+vXrx7Bhwxg4cCB9+/bV+dOnTx+6dOnyViYTWq2WvXv34uXlRZ8+fYiJieHkyZM6ZZKTk/nyyy9p2LAhTk5O+Pn5MWjQIOLinn9DevbsWTQaDSdOnGDYsGG4ubnh5+fHsmXLdNq5ceMGo0ePpkGDBri6utKyZUvWrFlDWlqaUiY8BXWH4wABAABJREFUPByNRsOOHTuYPHkynp6edOrUiYCAAH766SeOHz+ORqNBo9EQFBQEPL+x69OnD97e3ri7u9OpUye+//57pc306TkA3t7eaDQaGjdurJy/f/8+gYGBeHp64uLiQvfu3bl06ZLeuGk0GgDmzJmjjOfs2bPKuRUrVjB37lx8fX3x9vYG4Pz58wwaNAg/Pz/c3Nxo27Zthpcppsfy1KlTjB07ltq1a9OoUSNWrlypU+7atWv0798fT09PXF1d8ff31ymTk75OnjzJyJEjqV27Ng0bNmTPnj0ArF+/noYNG/Luu+8yadIknj17phNTjUZDVFSUzs9t165dTJ8+nbp16+Ln58eXX35JSkpKjn4HAFasWEGzZs1wdnbGy8uL3r17c+fOHeX8s2fPWLBgAY0aNcLJyYkWLVoo49bnp59+4u7du/j7+xssq8+1a9e4e/dujp5ylCtXDhcXF3bs2JGnvoUQQgjxauVpUfawYcPyaxxvjHPnznH37l2GDh2Kn58ftra27N27V+eGe/ny5Xz99dcEBgZSrVo1oqOjOXXqlM4NJsCUKVNo1aoVQUFBnD59moULF2JjY0PXrl0BePjwIQ4ODrRp0wZLS0suX75MUFAQCQkJGWK/YMECGjRowPz580lLS6Ns2bKMGzeOokWL8vHHHwNQpkwZ4PnNbKNGjejbty8qlYrvv/+eAQMGEBoaiqenJw0bNmTw4MEsXbqUVatWYW1tjZmZGQCPHz+mW7duWFhYMGXKFKytrdmwYQO9evXi4MGDFC9ePNO4hYWF0blzZwICAmjdujUAVatWVc6vX78eV1dXZs6cqdxQ//vvv7i7u9O1a1fMzMw4d+4ckydPRqvV0r59e532P/30U9q2bUtISAiHDx9m3rx5aDQa6tevD8CgQYMoUaIEM2fOxMrKitu3b3P//n2lfk76+uyzz2jfvj0ffvghW7duZfz48Vy5coVr164xbdo07ty5w+zZs6lQoQKDBg3K8ncJYNGiRTRp0oRFixZx/vx5goKCqFixYo5+B3bu3MnixYsZMWIEbm5uxMXF8euvv/LkyROln5EjR3Lu3DmGDh2Ko6MjJ06cYNy4cajVaho0aJDl+E6fPo29vT329vZ6r8OQY8eOUbNmTUqVKpWjerVr1+b06dN56lsIIYQQr1aeEop0v/76K3/++SdxcXEZvjk1MjJ6q96WvXfvXooUKULz5s0xNTXF39+f3bt38+TJEywtLQG4ePEifn5+dO/eXamX2Te8Xl5eys1+vXr1iIyMZOnSpXTu3BmVSoW3t7fybb1Wq8XDw4PExEQ2btyYIaGoUaMGM2fO1DlmZWWFhYUFbm5uOsd79Oih/D0tLQ1PT0+uX7/O1q1b8fT0xM7OjooVKwJQq1Ytnak6oaGhxMbGsm3bNiV58Pb2xt/fn9WrVzN+/PhM45Y+Bnt7+wzjAbCxsSE4OBgjIyPlWKtWrZS/a7Va6taty4MHDwgLC8twk9+8eXOGDx+ujOf48eMcOHCA+vXrExUVRXh4OJMmTVISPy8vL536OenrvffeU+Lv4uLCoUOH2LdvH4cOHVKmvv3000/s37/fYELh4uLC5MmTgefTCc+ePcuBAweUhCI7vwMXLlxAo9HoTCdq2rSp8vczZ85w9OhRVq9ejZ+fn9JXREQEQUFBehOKS5cuKU+X8uLYsWM0atQox/Vq1KjB+vXriY+Pl5dlZkNOd7NKL/9f2AUrtyRG+kl8DJMY6SfxMexNiFGeEoqYmBgGDhzIhQsX0Gq1GBkZKVvJpv/9bUooUlJS2L9/Pw0aNMDa2hqANm3aEBYWxqFDh2jXrh0ANWvWZPXq1crNmpOTU6bb5zZr1kzns7+/P7t27eL+/fuULVuWpKQkli9fzp49e7h37x7JyclK2RcTGCBHU0nu37/PwoULOX36NBEREcrP7OW1MJk5deoUnp6e2NjYKE8S0teTXLx4MdtjeFn9+vV1kgl4/jQkKCiII0eO8ODBA1JTUwGwtbXNUD/9Rhme/+45OjoqTyCKFStGuXLlWLBgAY8fP8bb21t5WpObvnx9fZW/W1tbY2dnR506dXTW0VSuXFmZ0qXPi+MGcHR05MyZM8rn7PwO1KxZk82bNzNr1iyaNWuGq6urzlhOnTqFra0tXl5eOtOpfHx8+Oyzz0hNTcXY2DjT8T18+BAnJyeD16FPdHQ0v//+O5MmTcpx3WLFiqHVaomMjJSEIhtyu5vVf2EXrLySGOkn8TFMYqSfxMewwhyjPCUUc+bM4erVq8yfPx8XFxeaNm3K6tWrKV++POvWreO3337LMJf9TXbq1CmioqJo1KiRsnVu9erVKVmyJHv37lUSisGDB6NSqfj2228JDg7Gzs6O7t27M3ToUJ2b5pcX6ZYoUQKAiIgIypYty9y5c9m2bRtDhw7FyckJa2trjhw5wtKlS0lKStJJKLKaavSytLQ0Bg8eTFxcHCNGjKBSpUqYm5uzZMkS7t27Z7B+dHQ0v/32W6bJR/pTjdzIbPwTJkzg/PnzDB06lKpVq2JlZcWWLVv43//+l6FseoKXztTUVFmzYmRkxOrVq1m4cCHTp08nISGBWrVqMXHiROrWrZvnvszMzDLs3mRqapphiltmMhv3i/Wy8zvQoUMHnjx5wtatW1m3bh3W1ta0a9eOwMBAihYtSnR0NDExMVkmjBERERkSrHTPnj3LdMMBY2NjJel6WVpaGiYm//d/LSdOnKB48eLZSlhflj7VLjExMcd1/4tiY5+SmppmuOD/Z2ysQq02z3G9/xKJkX4SH8MkRvpJfAwrqBip1ebZfiqSp4Ti+++/p3PnzrRs2ZLo6Gjg+bfVlSpV4tNPP2XYsGF88cUXLFiwIC/dFBrpi1gnTpyoLFpOFx0dTWRkJMWLF8fMzIzhw4czfPhwbt26xfbt2wkKCqJ8+fJK0gEoC3TTPXr0CEB5d8f+/fvp3LkzAwYMUMqcOHEi07G9/O1+Vm7dusWff/5JSEiIzrSY7N6w2djYUK9ePUaOHJnhXPrNX268PP6kpCSOHz/OhAkTCAgIUI5v3rw5V+07ODiwZMkSkpOTOX/+PAsWLGDQoEF8//33mJiY5Gtf+Sk7vwMqlYpevXrRq1cvHjx4wL59+5g/fz7FihVj6NCh2NjYYGdnx4oVKzLtQ9/uUzY2Nkpi9nKd9N/Xlz18+FAnQTx+/DgNGjTI9u/oi9IT98yeFImMUlPTSEnJ+T82ua33XyIx0k/iY5jESD+Jj2GFOUZ5mowVGxurLKxN/7b8xYWgvr6+/PDDD3npotB4+vQpR44coWnTpqxfv17nz4IFC0hJSeG7777LUK9SpUqMGTMGW1tbbt68qXPu0KFDOp8PHDhAqVKllG+Lk5KSdL4dTk1NZd++fdkes6mpKUlJSTrH0j+/2O7du3c5f/58hrpAhm/ZfXx8uHHjBo6Ojjg7O+v8MTTXPrPxZOXZs2ekpaXpjDM+Pp6jR49mq76+Mbz77rsMGDCA+Ph4Hj58+Mr6yg85/R0oXbo0ffv2RaPRKL9vPj4+REVFYWpqmuFn5uzsrDcRdHBwIDw8PMPxunXr8tNPP2VINn755RdiYmKUd7MkJyfzww8/5Gr9BDz/3bS2tn5rX5AphBBCvA3y9ISiVKlSyreUZmZmFC9enCtXrijffD948CBX30oWRkeOHCEhIYGAgAA8PT0znF+1atX/Y+/e43o8/weOvypFqU8n5TDn8CGKkMghCtkwh405RVvOx1EsQ4ZtkbNiiEiOY2bKlpnTzJw2zWEHM5tDTQ4dVHKoT/3+6Nf99dH5YML7+Xh4fN33fd3Xfd3vzz3f+33f13XdRERE4OHhwdixY2ncuDG2trYYGhpy+PBh7t27l2Mg8MmTJ1mwYAFt27bl+PHjfPXVV/j5+SnjLZydndm5cyf16tXD3NycrVu3FqobTba6deuyZ88eDh06hJWVFdbW1tStW5cqVaoos0GlpqayYsWKHLPv2NjYALBlyxY6d+5MhQoVUKvVeHp6Eh4ezpAhQxg6dCjVqlUjPj6ec+fOUblyZTw9PfNtz8GDB2nZsiWGhobUqVMnz37xJiYm2NnZERwcjIWFBeXKlWPt2rUYGxvneLNTkD/++IMFCxbwxhtvUKNGDVJSUlizZg2vvfYaNWvWRE9Pr9SOVdoKcw34+fmhUqlo1qwZKpWKs2fP8scffygDu9u2bUunTp0YPnw4w4cPR61W8+DBA/766y+uXbuWYzD/k5o3b84333xDWlqaVmIzdOhQdu3axaBBgxg+fDjW1tZcvnyZlStX0rJlS2WcyU8//cTjx49xdnbOtf7Dhw9rdd0DqF+/vnL9Xbx4EQcHh1zHIAkhhBCibChRQuHo6MiPP/7ImDFjAHj99ddZv349enp6ZGRkEBoaSvv27Uuloc9bREQE1apVyzWZAOjduzeffvop169fV27CNmzYgEajoU6dOixatCjHTdXcuXPZsWMH27Zto2LFikyaNElrZqhZs2Yxe/Zs5s2bh6GhIX369KFLly7KrEAFGTFiBNevX+eDDz4gKSmJ8ePHM2HCBAIDA5k7dy6TJk2iatWqjBkzhpMnT2p9S8LW1pYJEyawc+dO1q1bR9WqVTl06BDm5ubs2LGDZcuWsWjRIhITE7G0tKRp06Y5Bpk/zc/Pj08//ZQRI0bw8OFDNm3alGc8ARYvXoyfnx++vr6YmZnh4eFBamoqISEhhTr/bFZWVlSqVIk1a9Zw69YtTExMaNmyJQsXLlQGI5fWsUpbYa4BBwcHPv/8c3bu3MmDBw+oUaMG06dPp1+/fkqZFStWsHbtWrZt26Y89a9fvz59+/bN9/hubm7MnTuX06dPaw1Gt7a2Zvv27SxdupRPP/2UlJQUrK2t6dWrFxMnTlQSgCNHjuDk5JTn19Y//PDDHOsmTZrE2LFjSUtL48SJE0ydOrVIMctN9comBRd6gb3s5yeEEKJs08nMnuKnGC5dusSPP/7I4MGDMTAw4N69e0yaNEmZpcbR0ZHFixcXee75l92pU6eUJ7wv48f/xMtlwoQJGBsb4+/vX+R93d3dGTp0qFaiXFhHjhzB29ub77//PsdbjKLInm3uZafRZJCYmEpGRuH/SS9XThdz84okJNwvs/1ynzeJUf4kPgWTGOVP4lOw5xUjC4uK/82g7OwvHmczNTVl48aNJCUloaurK9M8CvESGDt2LAMHDsTb21uZiayw9u/fX+zjhoSE8O6775YomYCsAf+vwuwhGRmZRUomhBBCiNJSKh+2e9rTU2gKIV5cjRo14sMPP+TmzZtFTiiK6/79+7Rq1SrfMTlFUZZnxhBCCCFedCXq8gTw77//snr1ak6dOkVCQgIrV67E0dGR+Ph4Vq1aRd++fbG1tS2t9gohRJHJq/TcSVeDgkmM8ifxKZjEKH8Sn4K9CF2eSjR1yl9//UWfPn345ptvqF69OsnJycqXeC0sLPj555/ZvHlzSQ4hhBBCCCGEKMNK1OVp4cKFmJiY8PnnnwPkmMXIxcUl1y8NCyGEEEIIIV4OJXpDcebMGQYOHIiFhUWus6hUq1aNW7duleQQQgghhBBCiDKsRAlFZmYmFSpUyHN7fHx8vl/hFUIIIYQQQrzYSpRQ2NracvTo0Vy3paens2/fPpo2bVqSQwghhBBCCCHKsBIlFCNHjuTYsWPMnj2by5cvAxAXF8ePP/7Ie++9x99//83IkSNLpaFCCCGEEEKIsqfE08bu2bOHTz/9lOTkZOWLtJmZmRgbG/PRRx/Ro0eP0mqrEEIUy6vwYbsnFfYjdzJdY8EkRvmT+BRMYpQ/iU/BXoRpY4s8y9OSJUt44403aNiwIQC9e/ema9eu/Pjjj1y9epWMjAxq1qxJu3bt5EvZL4knv4aeF39/f/r27Zvn9lOnThEVFcXo0aOLfPzo6Gjc3NxYvnw53bp1y7Ocq6srMTExyrKZmRlqtZqJEyfSsmVLZX1gYCAhISFERUUpbRs6dCi7du3Czs4OyDrnadOm4eXlVeT25sbDwwMjIyPWrFmTb7mSHPfIkSP4+fnx3Xff/edjl3744QfGjx/PqVOnKF++fK5lWrZsybBhw5gwYQIAvr6+XLx4kYiIiFzL//zzz4wdO5aDBw+W6N+SzMxMVCrDYu//ItJoMkhMTJUvZwshhPhPFDmhWLt2LfXr11cSioSEBJydnQkJCWH48OGl3kDx/O3YsUNr+Z133sHDw0Pr7VPNmjXzreP06dOEhIQUK6EoCnd3d9577z0gq/tdaGgow4cPZ+/evUob+/Xrh4uLS7717Nixg2rVqj3TtpbmcTMzM1m6dCmenp7PZSKEw4cP06ZNmzyTieJo0aIF9evXJyQkhIkTJxa7Hh0dHRZt+ZnoW8ml1rayrHplE3wGt0BXV0cSCiGEEP+JEn2HIlsJe02JMq5Zs2Y51lWtWjXX9c9bpUqVtNrVsmVLnJycOHbsGIMHDwagSpUqVKlSJd96Cjo3jUZDRkYG+vr6JW1ykY6bl1OnTnH58mV69+5dqu0prCNHjjBq1KhSr/ftt99mwYIFjBkzpkSxjr6VzJWYe6XYMiGEEEJkK9GgbCEAMjIyWLVqFa6urjRp0oRu3bqxfft2ZXtgYCBBQUGkpqaiVqtRq9V4eHgAcOXKFSZPnoyLiwtNmzbljTfeICQkhIyM0ukjaGhoiJ6envIF9+z2ODg45LufWq1m/fr1yrKHhwejRo3iyy+/xN3dHTs7O/74448862rZsiWBgYE51u/Zs4fOnTtjb2+Ph4cHf//9d6GOGxkZibu7Ow4ODgwdOpTr16/nqNfR0RELCwtl3alTp1Cr1Rw7doxJkybh4OBAx44dCQ8PB2DTpk107NiRVq1aMWPGDB4/fqxV508//UTv3r2xs7OjZ8+eHD9+nF69euHr66tV7vLly8TExNCxY0dl3XfffUe3bt2ws7Pj7bff5vz583mFOl+dO3cmOTk5z9nkhBBCCPH8lcobCvFqCwgIYNOmTYwZMwYHBweOHDnC7NmzSU9PZ8iQIfTr14/Y2FgiIiIIDQ0FUPrE3759mzp16tCzZ08qVqzI77//TmBgIKmpqYwfP77IbcnMzFSSh/j4eD777DP09PS0bnaL6+LFi8TExDBp0iRUKhVVq1Yt0v6//vor169fx9vbG4Bly5YxfPhwIiMj8+2m9PvvvxMfH4+Pjw8ajYb58+czdepUra5oP/74I2+99Vau+3/00Uf06dOH/v378/nnnzNt2jT++OMPLl++zJw5c7hx4wbz58+nRo0aSpe027dvM2LECGxtbVm2bBnJycl89NFHJCcn06hRI636Dx8+jK2tLdbW1kp7J06cSIcOHZg+fTrR0dG8//77ORKWwjA2NqZevXr8+OOPdO7cucj7CyGEEOLZK1ZCERMTw6+//gpAcnJWv+Rr166hUqlyLd+4ceNiNk+UdfHx8WzevBkvLy9lsG27du1ISEhg5cqVDBw4UOlipKurm6NLT5s2bWjTpg2QlQy0aNGChw8fsnnz5mIlFFu3bmXr1q3KcoUKFViwYAG1atUq/kn+v3v37rFr164iJxLZ4uLi2Lx5M7Vr1wayvuPSrVs3du/ezYABA/LcLzk5mT179ihvH1JTU5k+fTqxsbFUqVKF27dvc+vWrTwHz3fr1k2Jpb29PQcOHGDfvn0cOHBA6UZ0+vRpIiMjlYRi48aN6OnpsWbNGiX5q169utJt7EmHDx+mU6dOyvLatWupWrUqK1euRE9PD4Dy5cszY8aMooRL0bBhQ86dO1esfV9lhZmZI7tMYWfxeBVJjPIn8SmYxCh/Ep+CvQgxKlZCsXz5cpYvX661bs6cOTnKZU8j+/vvvxevdaLMO3/+PGlpaTlmX3r99deJiIjg6tWr2NjY5Ln/o0ePWLNmDeHh4dy8eZO0tDRl2/3796lYsWKR2vP6668rMyTdu3ePiIgIpk2bhkqlom3btkWq62kNGjQodjIBUL9+fSWZAKhVq5Zys5xfQtGwYUOtrkz16tUDUBKKO3fuAGiVedKT521iYoKFhQUtW7bUGpNQu3ZtTp06pSxfuHABJycnrdmVWrZsiZmZmVbdCQkJnDt3TitZOHfuHK6urkoyAVlJTXETCnNzc+UcReEVZWarV20WrOKQGOVP4lMwiVH+JD4FK8sxKnJC4e/v/yzaIV5Q9+5lDXStVKmS1vrs5cTExHz3X7hwITt37mTcuHE0adIEExMTDh48yGeffcajR4+KnFBYWFgoU79C1s30b7/9xuLFi0ucUDx9jkVlaWmZ67qCbpaffvOXnQg8evRI63/z6jZlYmKitWxgYJBrnU92Sbpz545W8pPt6aTl6NGjWFpaar2FvHPnTo5zNTY2LvYMUAYGBso5isIrzLc39PR0UakMX7nvdBSFxCh/Ep+CSYzyJ/Ep2POKkUpl+Oy+Q9GnT58iN0i8vLKfWMfFxVG5cmVl/d27d7W25yUyMpJ33nlH64vqpTkAV0dHh7p163Lo0KFSqetp5cuX13qrApCWlkZqamqOsnFxcbmuy56CubhMTU0BSEpKKlE9T7KysiI+Pj7H+qfXHTlyBBcXF63YWFlZ5TjXlJSUYicFSUlJBV5HIieNJqPQH0AqStlXlcQofxKfgkmM8ifxKVhZjlHZ7YwlXgh2dnbo6+sTGRmptf6bb77B0tJSecr99BPwbI8ePdLqeqPRaNi3b1+ptS8zM5MrV65gbm5eanU+qXLlyqSlpWnNunTy5Ek0Gk2OspcvX+batWvK8rVr1/jjjz9o2rRpidpQvXp19PX1iY6OLlE9T7Kzs+PkyZOkpKQo63766SetN05paWn88MMPWuMnIGucxuHDh7Vi8PT1URQxMTHUqVOn2PsLIYQQ4tmSWZ5EiVhYWDBkyBDWr1+PgYEBzZo14+jRo0RERDBr1iylH72NjQ3p6emEhobi4OCAsbExdevWxdnZmZ07d1KvXj3Mzc3ZunVrsWYDynb37l1++eUX4H9jKP78808mT55cGqebQ4cOHTAyMmLmzJmMGDGC2NhYNm3alGv3HktLS0aPHq18pG358uVUrlw53y+MF0b58uVp0qSJMlFCafD09GTbtm2MGjUKLy8vkpKSWLlyJebm5srbiJ9++onHjx/j7Oyste/IkSN5++23GTduHAMHDiQ6Opr169fnGpOUlJRckw0nJyclCbx48SLvvvtuqZ2bEEIIIUqXJBSixKZNm4aJiQm7du1i9erVvPbaa8yZM0droHGnTp0YNGgQa9euJS4uDkdHR8LCwpg1axazZ89m3rx5GBoa0qdPH7p06cLMmTOL1Zb9+/ezf/9+ACpWrEitWrX45JNP8pxStaTMzc1ZsWIFCxYsYNy4cTRq1IiAgADlOxtPaty4MV27dmXhwoXcuXOHpk2bMmfOnFL5srW7uzsbN25UJkIoKWtra4KDg/n444+ZOHEiNWvWZMaMGcydO1cZk3HkyBGcnJwwNNQeJGZra8vy5ctZtGgR48ePp379+ixdulQZLP+kmzdvMmnSpBzrt2zZQsuWLfn111+Jj4/H3d29ROdTvbJJwYVeEq/SuQohhCgbdDLlM9dCvPDi4+NxcXEhJCQER0fHZ3KMq1ev8vrrr/Ppp5/Sp08f3N3dGTp0aK5TyZaWBQsW8Ouvv7Jp06Zi11FaSdaLRKPJIDExlYyM/P95L1dOF3PziiQk3C+z/XKfN4lR/iQ+BZMY5U/iU7DnFSMLi4rPblC2EKLssbCwYODAgYSGhpZaQrF48WLUajXW1tbcuHGDNWvWYGVlRdeuXQGUN0HPSkpKCrt27WLVqlUlqkdHR+eVmz0kIyOzwGRCCCGEKC2SUAjxkhg9erQyBqU0ulGlpaWxaNEi7t69S4UKFWjVqhXTpk0r8lS+xfXvv/8yadKkUkmQyvLMGEIIIcSLTro8CSFeevIqPXfS1aBgEqP8SXwKJjHKn8SnYC9ClyeZNlYIIYQQQghRbJJQCCGEEEIIIYpNEgohhBBCCCFEsUlCIYQQQgghhCg2SSiEEEIIIYQQxSYJhRBCCCGEEKLY5DsUQoiXXmGnvXsVyEfvhBBClDZJKESpCwwMJCgoSFk2NzenQYMGTJw4kZYtW5a4/qSkJEJDQ3n99depV69ekff38PDAyMiINWvW5FkmMDCQkJAQoqKiirTteTt16hRRUVGMHj36ubVh9+7dTJ8+nRMnTmBhYfHc2pEtMzMTlcrweTejzNBoMkhMTJWkQgghRKmRhEI8ExUqVCA0NBSA2NhYVq1ahaenJ7t376ZBgwYlqjspKYmgoCDq169frITiZXb69GlCQkKea0LRsWNHduzYgUqlem5teJKOjg6LtvxM9K3k592U5656ZRN8BrdAV1dHEgohhBClRhIK8Uzo6urSrFkzZdne3h5XV1e2b9+On59fset9+PBhKbTu5fP48WPKlSsb/zlbWFiUiTcTT4q+lcyVmHvPuxlCCCHES0k6Fov/RLVq1bCwsCA6OhqAjIwMVq1ahaurK02aNKFbt25s375da5/AwEAcHBw4f/4877zzDnZ2dmzZsgU3NzcAJk2ahFqtRq1WK/UuWrSInj174uDgQPv27ZkyZQq3b99+pufWt29fvL29c6xfuHAh7dq1Q6PREB0djVqt5ssvv+TDDz+kRYsWtGrVCn9/f9LT07X2i42NxcfHBycnJ+zt7Rk8eDAXL17UKuPq6srcuXMJDg6mU6dO2Nvb8/HHHxMUFERqaqoSFw8PD2WfK1euMGbMGFq0aEGzZs0YOXIk169f16pXrVYTHBxMYGAgzs7OODk5MX36dFJTU5UySUlJzJw5k/bt22NnZ4eLiwuTJ09Wtu/evRu1Wk18fLyyLjExkenTpyvnNGDAAM6cOaN1bA8PD0aNGkVkZCTu7u44ODgwdOjQHG0UQgghRNlSNh5pipdeSkoKiYmJWFtbAxAQEMCmTZsYM2YMDg4OHDlyhNmzZ5Oens6QIUOU/dLS0vD29sbT05PJkydjZmZGUFAQ48ePZ8qUKTg5OQEo9cbFxTFq1Cisra2Jj49nw4YNeHh4sG/fvmI9wX/6Zh+ykqEn9evXj/nz55OcnIyJiQkAGo2Gr776ij59+qCnp6eUXbJkCe3atWPZsmX89ttvrFixAn19fXx8fAC4d+8egwYNwsjIiFmzZmFiYkJYWBjDhg3j22+/xdLSUqnr22+/pVatWsyYMQNdXV0aNWrEo0ePiIiIULqbGRsbA3Djxg0GDBhA/fr1mT9/Pjo6OqxevRpPT08iIyMxMDBQ6t2yZQstWrRg/vz5XL16lYCAACwtLZU2+vv7c+zYMby9vXnttde4c+cO33//fZ4x1Gg0jBgxghs3buDj40OlSpUICwvj3XffZfv27TRp0kQp+/vvvxMfH4+Pjw8ajYb58+czdepUduzYUbgfTAghhBD/OUkoxDOTfTMeGxvLggUL0Gg0uLu7Ex8fz+bNm/Hy8mLChAkAtGvXjoSEBFauXMnAgQOVm/C0tDQmT57MG2+8odSbfZNcq1YtrW5VkHWzm02j0eDg4ECHDh04efIk7dq1K1L7U1NTady4ca7bjIyMlL/37NmTBQsWEB4ezqBBgwA4evQod+7c4a233tLar2bNmkob27dvz8OHD9mwYQMjRozA1NSU0NBQkpKS2Llzp5I8tGnTBnd3d9avX8+0adOUutLS0ggODtZqS5UqVXJ0NwMICgrC1NSUDRs2UL58eQCaN2+Om5sbO3fuZPDgwUpZKysrFi9eDECHDh347bff2L9/v5JQXLhwgR49etCnTx9ln+7du+cZxyNHjnD+/HnWrVtH+/btgazfu2vXrqxZs4bAwEClbHJyMnv27FG6TKWmpjJ9+nRiY2OpUqVKnscQRZM969XT/ytykhjlT+JTMIlR/iQ+BXsRYiQJhXgmnr4ZNzU1xc/Pj/bt23PkyBHS0tLo1q2b1j6vv/46ERERXL16FRsbG2W9i4tLoY979OhRPvvsMy5fvkxKSoqy/urVq0VOKCpUqMDmzZtzrP/888+JiIhQlo2NjXn99df54osvlIRi9+7dtGzZktq1a2vt26VLF61ld3d3Vq1axZ9//omjoyPHjx/HyckJU1NTJSHT1dXF0dGRCxcuaO3r5OSklUzk5/jx47zxxhvo6ekp9apUKmxtbXN0p3J2dtZatrGxYd++fcqyra0tX375JVZWVrRv377AQfY//fQTxsbGSjIBoK+vT5cuXbTiCNCwYUOt8RfZg+4loShdT896JbNgFUxilD+JT8EkRvmT+BSsLMdIEgrxTGTfjOvo6GBubk7VqlXR1c3KrO/dyxocW6lSJa19spcTExOVdYaGhlSsWLFQxzx//jxjx47Fzc2NESNGYGlpiY6ODv379+fRo0dFPgddXV3s7OxyrD9y5EiOdf3792fAgAH88ccfWFtbc+TIEebOnZuj3NODlbPP+c6dOwAkJCTwyy+/5PpmpGbNmlrLT3Z/KkhCQgKhoaFKV6gn6evray0/PTuTvr4+jx8/VpZnzZqlvO0ICAigatWqjBw5UkmmnpaUlJRrWytVqqRcC/kdGyjW7yfylpT0AI0mAz09XVQqQ2VZ5CQxyp/Ep2ASo/xJfAr2vGKkUhkW+q2IJBTimcjrZhzAzMwMyBrvULlyZWX93bt3tbZD1pSfhfXdd99hbGzMsmXLlOQlJiamiC0vHgcHB+rXr88XX3xBtWrVMDAwyPEGBtAaqAz/O2crKysg601O+/btmTRpUo59nxznAEWLjampKS4uLrne9Bc2YctmYmLCjBkzmDFjBpcuXWLTpk3MmTOHBg0a5PqdEVNTU+Li4nKsv3v3LqampkU6tigdGk0G6ekZeS6LnCRG+ZP4FExilD+JT8HKcozKbmcs8dKys7NDX1+fyMhIrfXffPMNlpaWOboJPS2vp9YPHz5EX19f60Y7PDy8dBpdCP369SM8PJxdu3bxxhtv5Nod6cCBA1rL+/fvx9DQUOk25OzszJUrV7CxscHOzk7rj1qtLrANT79NyNamTRsuX76Mra1tjnrr1q1bzDPOmhVq+vTpQNYsUrlp0aIFKSkp/PDDD8q69PR0vvvuO1q0aFHsYwshhBCibJA3FOI/Z2FhwZAhQ1i/fj0GBgY0a9aMo0ePEhERwaxZs7RmRcqNlZUVKpWKffv2Ub16dQwMDFCr1bRt25bQ0FDmzZtHly5diIqK4quvvvqPzgp69erFokWLSEhI4JNPPsm1zPXr15k+fTpvvPEGv/32G2vXrmXYsGHKk3pPT0/Cw8MZMmQIQ4cOpVq1asTHx3Pu3DkqV66Mp6dnvm2wsbEhPT2d0NBQHBwcMDY2pm7dukycOJG3334bLy8v+vfvT6VKlbh79y6nT5+mZcuW9OjRo9DnOWDAALp06UL9+vXR09Njz5496Ovr5/kV9I4dO2Jvb8/UqVPx9vZWZnm6ffs2K1asKPRxhRBCCFE2SUIhnotp06ZhYmLCrl27WL16Na+99hpz5sxhwIABBe6rq6uLv78/S5YswdPTk8ePH3Pw4EFcXFzw8fFh8+bN7N69m+bNm7NmzRrc3d3/gzPK6qrVqlUrYmNjc8yylG3y5MmcPn2aSZMmoaenx6BBg7S+4WBubs6OHTtYtmwZixYtIjExEUtLS5o2bZpjQHduOnXqxKBBg1i7di1xcXE4OjoSFhZGrVq12LlzJ8uWLWPOnDmkpqZiZWWFo6Njod58PKl58+bs2bOH6OhodHV1adCgAatXr9YaSP8kPT091q5dS0BAAAsXLlQG7IeEhGhNGfssVa9s8p8cp6yTOAghhHgWdDIzMzOfdyOEeBmkpKTQvn17JkyYwHvvvae1LTo6Gjc3N5YvX57r2Arx7GRmZhZpvMnLTqPJIDExlYyMTMqV08XcvCIJCffLbL/c501ilD+JT8EkRvmT+BTsecXIwqKiDMoW4r+SkpLClStX2Lp1Kzo6OvTt2/d5N0k8QUdHR2YPeUJGRiYZGfIcSQghROmRhEKIEvr1118ZOnQoVatWZcGCBVqzVImyoSzPjCGEEEK86CShEKKEnJycuHTpUr5lqlevXmAZIYQQQogXkUwbK4QQQgghhCg2SSiEEEIIIYQQxSYJhRBCCCGEEKLYJKEQQgghhBBCFJskFEIIIYQQQohik4RCCCGEEEIIUWwybawQ4qVX2C99vmqy41LS+MjH8oQQ4tUmCYV4ab355ptcunSJLVu20LJly1Kv38PDAyMjI9asWQPAqVOniIqKYvTo0aV+rKL45JNPOHjwIIcOHXqu7Sip6Ohopk+fTlhYWInqyczMRKUyLKVWvZxKGh+NJoPExFRJKoQQ4hUlCYV4KV2+fFn5kFx4ePgzSShmz56Nru7/nuyePn2akJCQ555QvOiCg4N56623tNadOXOGlJQUOnXqVOT6dHR0WLTlZ6JvJZdWE8UTqlc2wWdwC3R1dSShEEKIV5QkFOKlFB4ejq6uLo6OjkRGRjJz5kz09fVL9Rj16tUr1fpeVA8fPqRChQqlVl/lypUZPnw4Li4uJCcn88EHH5CcnIy3t3ex64y+lcyVmHul1kYhhBBC/I90LBYvnczMTCIiImjdujXvvvsuiYmJHDt2TKtMWloaCxYsoGPHjjRp0oR27doxevRokpP/9xQ7KSmJefPm0aFDB5o0aYKrqyuLFy9Wtnt4eDBq1CgAAgMDCQoKIjU1FbVajVqtxsPDQyl75coVxowZQ4sWLWjWrBkjR47k+vXrWm3atWsX3bt3x97eHicnJwYOHMj58+fzPddbt24xevRomjZtSvv27QkODs61XGxsLD4+Pjg5OWFvb8/gwYO5ePGiVpnHjx/z8ccf06pVK1q2bImfnx/h4eGo1Wqio6OBrG5IarWa3bt3M3PmTJycnOjXr5+y/5IlS+jUqRNNmjTh9ddfJzw8PEdboqKiGDp0KM2aNaNFixZ4e3sTFxenbH/zzTfZtGkTR48e5ffff8fGxoZVq1ZhY2OTbyyEEEII8XzIGwrx0jl79iwxMTGMGzeOdu3aYWZmRkREBK6urkqZNWvWsH37dnx8fKhfvz4JCQkcP36cx48fA1k3x8OGDVPqadCgAbGxsfz888+5HrNfv37ExsYSERFBaGgoAMbGxgDcuHGDAQMGUL9+febPn4+Ojg6rV6/G09OTyMhIDAwMOHPmDDNmzOC9997DxcWFhw8fcv78ea0EJzdjx47l1q1bfPTRR5iYmBAcHMzNmzcpV+5//2nfu3ePQYMGYWRkxKxZszAxMSEsLIxhw4bx7bffYmlpCcDixYvZvn07EydOpFGjRuzfv18rgXrSkiVLcHFxYfHixWRkZAAwadIkzp49y7hx47CxseHo0aNMnToVlUqFi4sLkJVMeHh44OLiwtKlS3nw4AHLli1j7Nix7NixA4Cvv/6a9evX4+Ligkaj4a+//mLChAlMmTKFOnXq5P/jCyGEEOI/JwmFeOlERERQvnx5unbtir6+Pu7u7uzdu5f79+9TsWJFAC5cuEC7du0YPHiwsp+7u7vy9z179vDbb7+xfft2HBwclPV9+vTJ9ZhVqlShSpUq6Orq0qxZM61tQUFBmJqasmHDBsqXLw9A8+bNcXNzY+fOnQwePJjz589jZmbGBx98oOzXsWPHfM/z+++/5+LFi2zcuJE2bdoA4OTkhIuLC2ZmZkq50NBQkpKS2Llzp5I8tGnTBnd3d9avX8+0adNITExk27ZtjBkzhpEjRwLQvn17PD09uXnzZo5jN2zYkE8++URZPnnyJIcOHWL9+vW0a9cOgLZt23Lnzh0CAwOVhGLx4sU0adKEoKAgdHR0AGjQoAE9evTg6NGjuLi4EB0dTXBwMKmpqfz0008EBARw+vRp/vnnH0koyrCXdSat0poJ62Ul8SmYxCh/Ep+CvQgxkoRCvFTS09OJjIzExcUFExMTAHr27MmOHTs4cOAAvXv3BsDW1pb169crN7tNmjTRGmB94sQJbGxstJKJ4jp+/DhvvPEGenp6pKenA6BSqbC1tVW6Hdna2pKYmIivry89e/akefPmGBrmP/PO+fPnMTExUZIJABMTE5ydnfntt9+0ju/k5ISpqaly/OzxJRcuXADgzz//5NGjR7i5uWkdw83NjRMnTuQ49tPJzvHjxzEzM6N169bKMQCcnZ356KOP0Gg0PH78mLNnzzJt2jQ0Go1Spnbt2lStWpULFy7g4uKiJDSpqalKmVatWuUbC/H8vewzab3s51dSEp+CSYzyJ/EpWFmOkSQU4qVy/Phx4uPj6dSpE0lJSUDWE3ArKysiIiKUhGLMmDHo6ury5ZdfEhQUhIWFBYMHD2bcuHHo6OiQmJiItbV1qbQpISGB0NBQpSvUk7IHirdp04aAgAA2bdqEl5cX5cuXx93dnQ8//FDrbcOTbt++jYWFRY712W8hnjz+L7/8QuPGjXOUrVmzJgB37twBwNzcPN+68jtGYmJirsfIrl9HRweNRoO/vz/+/v45yjz9JqR69eolnjJW/HeSkh6g0WQ872aUOj09XVQqw5f2/EpK4lMwiVH+JD4Fe14xUqkMC/1WRBIK8VLJHgQ8ffp0pk+frrUtISGBuLg4LC0tMTAwYMKECUyYMIFr167xxRdfEBgYSPXq1enduzdmZmbKtLMlZWpqiouLC4MGDcqxLbsLFkCvXr3o1asX8fHxHDx4EH9/f8qVK8enn36aa73W1tbEx8fnWP/kAOfs47dv355JkyblKGtgYACAlZUVkBWjypUr51lXtuzuSk8ew8LCgrVr1+Za3sLCgvT0dHR0dBg1ahSdO3fOUebpZEa8WDSaDNLTX96bgZf9/EpK4lMwiVH+JD4FK8sxkoRCvDQePHjAwYMH6dy5M0OHDtXadvfuXaZMmcLXX3+tNfsSQK1atZgyZQo7duzg77//BrK66nz99decO3eOpk2bFur4+vr6yqDuJ7Vp04bLly9ja2uLnp5egfVYWFjQr18/vv/+e6U9ubGzsyM5OZkTJ04o3Z6Sk5P58ccftd5qODs7s3fvXmxsbDAyMsq1rvr161O+fHm+++47GjZsqKz/7rvvCmxv9jHWrVuHvr6+1v5PMjAwoFmzZvz999/Y2dkVql4hhBBClH2SUIiXxsGDB0lNTcXDwwMnJ6cc29etW0dERAQeHh6MHTuWxo0bY2tri6GhIYcPH+bevXu0bt0ayHpbsHXrVkaOHMn48eOpX78+t27d4qeffmLevHm5Ht/Gxob09HRCQ0NxcHDA2NiYunXrMnHiRN5++228vLzo378/lSpV4u7du5w+fZqWLVvSo0cPVqxYQWJiIq1atcLS0pI///yTY8eO4enpmef5dujQgcaNGzN16lR8fHwwMTFh7dq1yuxS2Tw9PQkPD2fIkCEMHTqUatWqER8fz7lz56hcuTKenp6Ym5szcOBAVq9eTfny5WnUqBGRkZFcvXoVQGt8SW7atm1Lp06dGD58OMOHD0etVvPgwQP++usvrl27pgzgnjZtGsOGDeP999+ne/fuqFQqYmNj+fHHH+nbt2+uv5sQQgghyjZJKMRLIyIigmrVquV5U9q7d28+/fRTrl+/TvPmzfnmm2/YsGEDGo2GOnXqsGjRIpydnYGsp+kbN25k6dKlrFmzhsTERKpUqUL37t3zPH6nTp0YNGgQa9euJS4uDkdHR8LCwqhVqxY7d+5k2bJlzJkzh9TUVKysrHB0dEStVgNZbxtCQ0P55ptvSElJoUqVKnh5eTFmzJg8j6ejo8OqVauYPXs2fn5+qFQqPDw8uHv3LgcPHlTKmZubs2PHDpYtW8aiRYtITEzE0tKSpk2b0qVLF6Wct7c36enprF27loyMDLp06cLIkSOZO3euMsA9PytWrGDt2rVs27aNmJgYTExMqF+/Pn379lXKNG/enK1btxIYGMj06dNJS0ujSpUqtG7dmlq1ahV4jOKqXrng9ovikdgKIYTQyczMzHzejRBClE1Tp07l559/5tChQ8+7KcWWmZmZY8yHKF0aTQaJialkZLx8/3dSrpwu5uYVSUi4X2b7Lj9PEp+CSYzyJ/Ep2POKkYVFRRmULYQomtOnT3P27FkaN25MRkYGR44cITw8HF9f3+fdtBLR0dGR2UPyUFozh2RkZL6UyYQQQojCkYRCCAGAkZERR44cITg4mEePHvHaa6/h6+ub7ziOF0VZnhmjLJD4CCGEKAlJKIQQADRp0oTt27c/72YIIYQQ4gVTdr/hLYQQQgghhCjzJKEQQgghhBBCFJskFEIIIYQQQohik4RCCCGEEEIIUWySUAghhBBCCCGKTRIKIYQQQgghRLHJtLFCiJdeYb/0+arJjktpxEc+bieEEK8uSSj+A4GBgYSEhBAVFVWkbf+VU6dOERUVxejRo7XWP9226OhovvzyS/r370/lypW19h86dCi7du3Czs6u2O1Qq9Vay5aWltjb2zN58uQc256Wnp7Otm3b2LlzJzdu3KBcuXJUrVqVli1b4uvri4GBQbHb9aTExERmzJjB6dOnSUpKYuXKlXTu3LlU6i4NH3/8MWFhYUycOJFx48YVq47ff/+d7777juHDh2NoaKis3717N9OnT+fEiRNYWFiUVpOfuczMTFQqw4ILvsJKIz4aTQaJiamSVAghxCtIEgrB6dOnCQkJyZFQ9OvXDxcXF2U5JiaGoKAgOnbsqJVQNG7cmB07dmBjY1Pitnh4eNCjRw8yMzOJjY1lzZo1eHl58fXXX6NSqfLc7+OPP2b37t2MHDmS5s2b8+DBA37//Xf27t3Lw4cPSy2h2LBhA6dOnWLBggVYWlpSp06dUqm3NGg0Gr755hsAIiIiSpRQBAUFMXjwYK2EomPHjuzYsSPf36Es0tHRYdGWn4m+lfy8m/LSql7ZBJ/BLdDV1ZGEQgghXkGSUIg8ValShSpVqhRYztjYmGbNmpXKMatWrapVV506dejVqxdRUVFayc2THjx4wK5duxg9ejTjx49X1ru5uTF+/HgyM0t+g/Pw4UMqVKjAP//8g1qtxs3NrcR1lrYTJ05w9+5dnJ2d+fHHH/n1119p3LhxqdVvYWHxQr2ZeFL0rWSuxNx73s0QQgghXkrSsbgMevz4MUuWLKFTp040adKE119/nfDwcK0yvr6+9OjRg6NHj9KjRw/s7Ozo27cvv/zyi1a5PXv2MHDgQFq1aoWjoyMeHh6cP39e2R4YGEhQUBCpqamo1WrUajUeHh7KNgcHB+B/3ZoA3n77baVs9ja1Ws2FCxeUenft2kX37t2xt7fHycmJgQMHah23sCpWrAhAWlpanmUePHhAWloa1tbWuW7X0dEBsrpsqdVqIiMjtbZ/8sknuLq6Ksu7d+9GrVYTFRXFu+++S7NmzQgICECtVrN//35++uknrfPP7i7Wrl07mjVrRq9evdizZ0+OdiQlJTFv3jw6dOhAkyZNcHV1ZfHixVpljhw5Qr9+/bC3t6d169bMnj2b1NTUggNF1luJihUrMn/+fPT19XNcM5DVrSw4OJjAwECcnZ1xcnJi+vTpyjGyuzUBtGnTBrVarcQmOy7x8fFKfbGxsYwaNYqmTZvi4uLCxo0bc8Qzu5yPjw9OTk7Y29szePBgLl68qFXG1dWVuXPnsmXLFjp16kSLFi0YO3as1vGEEEIIUfbIG4r/UHp6eo51GRkZOdZNmjSJs2fPMm7cOGxsbDh69ChTp05FpVJpPaW/c+cOc+bMYcKECahUKoKDg/Hy8uLbb7/F0tISyLqJ7t27NzVr1uTx48fs27ePwYMHs3fvXurUqUO/fv2IjY0lIiKC0NBQIOuNw9MaN26Mn58fc+fOxd/fn7p16+Z5nmfOnGHGjBm89957uLi48PDhQ86fP09ycsFdTjIyMkhPTyczM5Nbt26xcOFCzM3NcXJyynMfCwsLqlWrxmeffUbFihVp164dpqamBR6rIN7e3rzzzjuMGjUKQ0ND3nzzTRYtWsT9+/eZPXu2Uu7ff/+lefPmDBw4EAMDA86ePcvMmTPJzMykT58+QFaSOGzYMGJiYhg3bhwNGjQgNjaWn3/+WaknMjKSyZMn07dvXyZMmMCdO3dYvHgxSUlJLF26NN+2Pnr0iG+//ZYuXbpQuXJl2rVrx759+5g2bRq6utrPDbZs2UKLFi2YP38+V69eJSAgAEtLS3x8fOjYsSNjxozhs88+Y926dZiYmOTZXSwzM5OxY8dy9+5d5syZg4mJCevXr+fff//VOua9e/cYNGgQRkZGzJo1CxMTE8LCwhg2bJjWtQpw6NAhrl27hp+fHwkJCfj7+zNv3rwCz18IIYQQz48kFP+R1NTUPLufGBkZKX8/efIkhw4dYv369bRr1w6Atm3bcufOHQIDA7USisTERJYtW0abNm0AaNWqlfKU2NvbG0CrC1BGRgZt27bl/PnzfPnll0yZMkXp1qSrq5tvtyVjY2Pq1asHQP369fMdfH3+/HnMzMz44IMPlHUdO3bMs/yTFi1axKJFi5RlMzMzgoKCMDExyXe/+fPnM2XKFKZMmYKOjg5169bFzc2Nd999t9jddAYMGMDIkSO11qlUKnR0dLRi1b17d+XvmZmZODo6cuvWLXbs2KEkFHv27OG3335j+/btylsfQNmemZlJQEAAb7zxBp988omy3crKipEjRzJ27Fjq16+fZ1sPHTrE/fv36dGjBwA9e/bk8OHDnDp1Srk+nqwz+81Ihw4d+O2339i/fz8+Pj5YWFhQs2ZNICuJzC9233//Pb/++itbtmyhZcuWALRu3RoXFxetcRahoaEkJSWxc+dOJXlo06YN7u7urF+/nmnTpmnF77PPPlOSmJiYGNasWUNGRkaOxEiUPS/jbFqlORPWy0jiUzCJUf4kPgV7EWIkCcV/pEKFCmzevDnH+s8//5yIiAhl+fjx45iZmdG6dWutNxrOzs589NFHaDQa9PT0ADAxMdG6WTQxMcHZ2Zlz584p665cucKSJUuIiooiLi5OWX/16tXSPD0ttra2JCYm4uvrS8+ePWnevLnW4N78DB06lDfffBOA+Ph4tm7dytixYwkLC6Nhw4Z57ufk5MSBAwf4/vvvOXHiBCdPnmTt2rXs3r2b3bt3aw0iL6zCJkH37t0jMDCQgwcPcuvWLTQaDZCVDGU7ceIENjY2WsnEk/755x9iYmL48MMPtX73Vq1aoaury8WLF/NNKCIiIrC0tMTZ2RnI6j5kZGREeHh4joQiu0w2Gxsb9u3bV6hzfdKFCxdQqVRKMgFZXdTatGnDr7/+qqw7fvw4Tk5OmJqaKuemq6uLo6OjVjc5AEdHR603IjY2NqSlpREXF4eVlVWR2yj+Wy/zbFov87mVBolPwSRG+ZP4FKwsx0gSiv+Irq5urk/1jxw5orWckJBAYmJinm8z7ty5owyUzu3psaWlJVeuXAEgJSWF9957DwsLC3x9falWrRrly5dn5syZPHr0qIRnlLc2bdoQEBDApk2b8PLyonz58ri7u/Phhx9q3WTnpkqVKlpxatOmDR06dGDVqlWsWLEi332NjIzo1q0b3bp1A2Dnzp3MnDmTkJAQZVxAUVSqVKlQ5Xx9fYmKimLcuHHUq1cPY2Njtm3bpsy4BFlvk/Ia4wFZvzuQ58xMN2/ezHPfpKQkjh49Sq9evbh//76yvn379hw4cICPPvpI6yb96Vma9PX1efz4cf4nmYvbt2/neg0+vS4hIYFffvkl12s6+21IXm3LbvezvF5F6UlKeoBGk7Mb54tMT08XlcrwpTy30iDxKZjEKH8Sn4I9rxipVIaFfisiCUUZY2pqioWFBWvXrs11+5M3a7kNVn3ySe4vv/yiTL365NP95OTkQs3eVBK9evWiV69exMfHc/DgQfz9/SlXrhyffvppkeoxMDCgRo0aXL58ucht6NevH4sWLVISrPLlywM5B3gnJSUVue5sjx494siRI/j6+iqD2QG2bt2qVc7MzIxLly7lWU92ouXn54e9vX2O7fklI/v37yctLY1du3axa9euHNuPHDlC165dCzqVIrO2ts71Gnx6nampKe3bt2fSpEk5ypbWdL6ibNBoMkhPfzlvCF7mcysNEp+CSYzyJ/EpWFmOkSQUZYyzszPr1q1DX18/3y4+kJUYnDhxQunSkpyczI8//sjgwYOBrKlOIesJdLazZ88SExOj1X2msE+os+spytNiCwsL+vXrx/fff8/ff/9d6P2yPXr0iOvXr+f7jYu0tDRSU1NzDMSOi4sjOTlZSbAsLS3R19dXEgzIGix95syZIrfryf0zMjK0YpySksKhQ4e0yjk7O/P1119z7tw5mjZtmqOeunXrUqVKFW7cuKH8foUVHh7Oa6+9hr+/f45tU6ZMITw8vEgJRfa5FHRN2NnZkZSUxJkzZ3B0dATg/v37nDhxQutNg7OzM3v37sXGxkZrvJAQQgghXg6SUJQxbdu2pVOnTgwfPpzhw4ejVqt58OABf/31F9euXdMasGtmZsaMGTOYOHEiJiYmBAcHk5mZybBhwwBo1qwZRkZGzJkzh5EjR3Lr1i0CAwNzjCewsbEhPT2d0NBQHBwcMDY2znUWp9q1a6Onp8cXX3xBuXLl0NPTy7Ub14oVK0hMTKRVq1ZYWlry559/cuzYMTw9PQs8/5s3bypT38bHx7NlyxYSExMZMGBAnvskJyfj7u5Or169aN26NaampkRHRxMSEoKuri4DBw4EsrqddenShS1btlCrVi3Mzc3ZvHkzmZmZytSyRWViYoKdnR3BwcFYWFhQrlw51q5di7GxsdaT+l69erF161ZGjhzJ+PHjqV+/Prdu3eKnn35i3rx56Ojo4Ovri4+PD6mpqXTs2BFDQ0P+/fdfjh49yuTJk3P9iN6tW7c4c+YMY8aMyXUmrB49erB161aSk5MLHNieLTt527JlC507d6ZChQq5fqm8Q4cONG7cGG9vb6ZMmYJKpWLdunVUrFhRK56enp6Eh4czZMgQhg4dSrVq1YiPj+fcuXNUrly5UNeFEEIIIcouSSjKoBUrVrB27Vq2bdtGTEwMJiYm1K9fn759+2qVs7KywsfHh4CAAK5fv079+vVZv3690ve/UqVKLF++nICAAMaOHUvt2rWZM2cO69at06qnU6dODBo0iLVr1xIXF4ejoyNhYWE52mVhYYGfnx/r1q1j7969pKen59qNx87OjtDQUL755htSUlKoUqUKXl5ejBkzpsBzDwsLU46tUqmwsbFh5cqVdO7cOc99jI2NGTFiBMeOHSMyMpJ79+5RqVIl7OzsmD9/vlbf/VmzZjFr1iw+/vhjKlasiJeXF3Xq1OHgwYMFti0vixcvxs/PD19fX8zMzPDw8CA1NZWQkBCljIGBARs3bmTp0qWsWbOGxMREqlSpojVD1Ouvv45KpWL16tXKNyRee+012rdvn+d4jn379pGRkUHv3r1z3d6nTx82btzI/v37efvttwt1Pra2tkyYMIGdO3eybt06qlatmuONC2R932PVqlX4+fnh5+eHSqVi6NCh/PPPP/z+++9KOXNzc3bs2MGyZctYtGgRiYmJWFpa0rRpU7p06VKoNpVU9cqFS6ZE8Uh8hRDi1aaTWRqfERb/OV9fXy5evKg1Q5QQz9vjx4/p3r07LVu2zLUL1vNQkjdQovA0mgwSE1PJyHi5/i+lXDldzM0rkpBwv8z2XX6eJD4FkxjlT+JTsOcVIwuLijIoWwjx7O3YsYOMjAzq1KlDUlKS8lZtyZIlz7tpCh0dHZk9JA+lOXNIRkbmS5dMCCGEKBxJKIQQxVa+fHnWrl1LTEwMAA0bNmTNmjX5fvjweSjLM2OUBRIfIYQQJSFdnoQQLz15lZ476WpQMIlR/iQ+BZMY5U/iU7AXoctT2f2GtxBCCCGEEKLMk4RCCCGEEEIIUWySUAghhBBCCCGKTRIKIYQQQgghRLFJQiGEEEIIIYQoNkkohBBCCCGEEMUmCYUQQgghhBCi2OTDdkK8IPbu3cumTZv4559/yMzMpHLlyjRv3pwpU6ZgaWn5n7TB19eXixcvEhERkWcZDw8PjIyMWLNmzX/SpsIo7Dzar5rsuPyX8ZEvagshxMtHEgohXgDBwcEsXrwYT09PJk6cSGZmJpcvXyY8PJzbt2//ZwlFYcyePRtd3bJzA5+ZmYlKZfi8m1Gm/Zfx0WgySExMlaRCCCFeIpJQCPECCAsLo0+fPvj6+irrXFxcGD58OBkZZevLovXq1XveTdCio6PDoi0/E30r+Xk35ZVXvbIJPoNboKurIwmFEEK8RCShEOIFkJSUhLW1da7bnnwb4OrqSseOHalZsyYbNmwgKSkJd3d35s6dy5UrV5gzZw5//PEH9erV45NPPkGtViv7Pnr0iCVLlrBv3z7u3btH3bp1GT9+PF26dMmzXRkZGcyaNYvvvvuOdevWYWdnl6PLU2BgICEhIWzfvp2PPvqI3377jRo1avDBBx/Qvn17pa7Hjx8TEBDA3r17ycjI4I033sDR0REfHx8OHjxI9erVix2/6FvJXIm5V+z9hRBCCJG3stMvQQiRp8aNG7N9+3Z27tzJnTt38i178OBBfvjhB+bOnYu3tzcRERHMmzePadOm0a9fP5YvX86jR4+YNGmS1tsNHx8fduzYwfDhw1m5ciX16tVjwoQJHDx4MNfjpKen4+Pjw9GjRwkLC8POzi7PNqWlpeHj40Pfvn0JCgrCwsKCiRMnkpCQoJRZvHgx27dvZ/jw4SxdupSMjAwWL15cxEgJIYQQ4r8mbyiEeAHMnj2b8ePHM3PmTACqV69Op06d8PT0zPXJ/apVqzAwMADg9OnTfP755wQHB9OhQwcg683C6NGj+fPPP2nYsCF//PEH3377LXPmzGHAgAEAdOjQgZiYGFauXImbm5tW/Y8fP2bSpEn88ccfbN68mdq1a+fb/uyEwsXFBYA6derg5ubG999/T69evUhMTGTbtm2MGTOGkSNHAtC+fXs8PT25efNm8QMnyqQXaZD88xi4/iKR+BRMYpQ/iU/BXoQYSUIhxAugQYMGREREcOLECX744QfOnDlDWFgYu3fvZsuWLTRq1Egp6+joqCQTALVr10ZXV5fWrVtrrQO4efMmDRs25OeffwagW7duWsd9/fXX8ff3JzU1FSMjIwAePnzIqFGj+Pfff9myZQvVqlUrsP26urq0adNGWa5evToVKlTg1q1bAPz55588evQoR+Li5ubGiRMnChMi8QJ5EQfJv4ht/i9JfAomMcqfxKdgZTlGklAI8YIwMDDAxcVFecp/7NgxRo0axcqVKwkKClLKqVQqrf309fWpUKGCVpKhr68PZI2bALh37x76+vqYmZlp7VupUiUyMzNJTk5WEor4+HhiY2MZNGhQoZIJIMfxs9uQffzsblzm5uZaZcrS7FWi9CQlPUCjKVuTCeRFT08XlcrwhWrzf0niUzCJUf4kPgV7XjFSqQwL/VZEEgohXlDt27enYcOGXLlypcR1mZqakpaWxr179zA1NVXW3717Fx0dHUxMTJR11apVY/z48UyZMgVzc3PGjBlT4uNbWVkBkJCQQOXKlZX1cXFxJa5blD0aTQbp6S/WjcOL2Ob/ksSnYBKj/El8ClaWY1R2O2MJIRR3797Nse7hw4fcvHmTSpUqlbj+Fi1aABAZGam1PjIyEltbW+XtRLZu3boxf/58VqxYwcaNG0t8/Pr161O+fHm+++47rfVPLwshhBCi7JE3FEK8AHr27EmnTp1o164d1tbW3Lp1i82bN5OQkMCwYcNKXH/Dhg3p2rUr8+fP5+HDh9SpU4e9e/cSFRXFqlWrct3nzTff5NGjR/j5+VGhQgVlMHdxmJubM3DgQFavXk358uVp1KgRkZGRXL16FaBMfShPCCGEENokoRDiBTB+/HgOHz7M/PnziY+Px9zcHLVazcaNG7UGW5fEwoULWbJkCcHBwSQmJlK3bl1WrFiBq6trnvv069ePR48eMWfOHCpUqEDv3r2LfXxvb2/S09NZu3YtGRkZdOnShZEjRzJ37lytLlfFUb1yyfYXpUN+ByGEeDnpZGZmyudKhRBl0tSpU/n55585dOhQsevIzMxER0enFFslSkKjySAxMfWF+VJ2uXK6mJtXJCHhfpntu/w8SXwKJjHKn8SnYM8rRhYWFWVQthDixXL69GnOnj1L48aNycjI4MiRI4SHh+Pr61uienV0dGT2kDw8j5lDMjIyX5hkQgghROFIQiGEKBOMjIw4cuQIwcHBPHr0iNdeew1fX188PT1LXHdZnhmjLJD4CCGEKAlJKIQQZUKTJk3Yvn37826GEEIIIYpIpk4RQgghhBBCFJskFEIIIYQQQohik4RCCCGEEEIIUWySUAghhBBCCCGKTRIKIYQQQgghRLFJQiGEEEIIIYQoNkkohBBCCCGEEMUmCUUZFBgYiIODQ5G3/VdOnTrF6tWrc6x/um3R0dEEBgZy69atHPur1WouXLhQ4rbEx8czf/583N3dsbOzo3nz5gwZMoSdO3ei0Why3Wf06NF07do1zzrDwsJQq9Vcv34dX19fevToUeJ2lpYxY8agVqvZs2dPseso7O9Xmr9TXj755BNcXV2fWf3Z9PR0KVdO/jz9R09P95WJj66uzjO/zoQQ4lUlH7YTRXb69GlCQkIYPXq01vp+/frh4uKiLMfExBAUFETHjh2pXLmysr5x48bs2LEDGxubErXj2rVrDB06FI1Gw7vvvkvjxo15/PgxJ0+exN/fH3Nzczp37pxjvx49euDt7c358+ext7fPsX3fvn00a9aMmjVrMnbsWFJTU0vUztKSmJjIsWPHAIiIiKB3797Fqqewv9/LIjMzE5XK8Hk3o0x7FeKj0WSQmJhKRkbm826KEEK8dCShEKWmSpUqVKlSpcByxsbGNGvWrMTH8/HxQaPR8MUXX2glLB06dGDIkCEkJyfnup+bmxtGRkZERETkSCiio6OJiopi5syZANSsWbPAdjx8+JAKFSqU4EwKZ//+/aSlpeHs7MyJEyeIi4vD0tKy1Oov7O/3otHR0WHRlp+JvpX79SBeftUrm+AzuAW6ujqSUAghxDMgCcVL4PHjxwQFBREeHs6dO3eoUaMGY8eOpWfPnkoZX19fLl68yNSpU1m4cCHXrl2jfv36+Pn5ad3c79mzhx07dnDlyhUyMzNp2LAhU6dOVW68AwMDCQoKAkCtVgPQqlUrwsLCCAwMJCQkhKioKE6dOsXQoUMBePvtt5X6L126pGzbtWsXdnZ2AOzatYsNGzZw48YNDA0NqVu3LtOnT8/1DQLATz/9xPnz55k5c6ZWMpGtWrVqecbL0NAQNzc3vvnmG3x9fdHV/V/Pv3379qGnp8cbb7yhFbeIiAgAdu/ezfTp09m+fTsrVqwgKiqKvn378t577+Hm5sby5cvp1q2bUt8nn3zCwYMHOXToEABJSUkEBARw9OhREhMTsbCwoHnz5ixdujTP9maLiIigVq1a+Pr68uabb/L111/j4eGhbI+OjsbNzY2AgADOnTtHeHg45cuXp2fPnnh7e1OuXLlC/35Pio+PZ/z48fzwww8YGxszZMiQHG83zpw5w+LFi/ntt98wNDTE1dWVDz74ADMzM6XMrVu3mD17NidOnEClUinXx5PH6dChA35+fvTv319rW79+/ahWrRrLly8vME65ib6VzJWYe8XaVwghhBD5k4SiDEtPT8+xLiMjI8e6SZMmcfbsWcaNG4eNjQ1Hjx5l6tSpqFQqrS4sd+7cYc6cOUyYMAGVSkVwcDBeXl58++23ypPu6OhoevfuTc2aNXn8+DH79u1j8ODB7N27lzp16tCvXz9iY2OJiIggNDQUyHrj8LTGjRvj5+fH3Llz8ff3p27dunme55kzZ5gxYwbvvfceLi4uPHz4kPPnz+f5hgGyuu0AtG/fPs8y+enZsyfh4eGcOnWKNm3aKOsjIiJwdnYu8Mm/t7c377zzDqNGjcLQsPDdRfz9/Tl27Bje3t689tpr3Llzh++//77A/WJjYzlz5gxjx45FrVbToEEDIiIitBKKbMuWLcPNzY1ly5YRFRVFYGAgNWvWZODAgYX+/Z40a9YsunfvTmBgID/++CNLly7F1NSUgQMHAnDx4kXeffddnJycWL58OXfv3mXx4sX89ddfbN++HT09PQDGjh3LrVu3+OijjzAxMSE4OJibN29SrlzWP0MWFhZ06dKFL774QiuhuHz5MufPn2fixImFC7IQQggh/lOSUJRRqampNG7cONdtRkZGyt9PnjzJoUOHWL9+Pe3atQOgbdu23Llzh8DAQK2EIjExkWXLlik30K1atcLFxYWNGzfi7e0NwPjx45XyGRkZtG3blvPnz/Pll18yZcoUpVuMrq5uvt2WjI2NqVevHgD169dX3kTk5vz585iZmfHBBx8o6zp27JhneUAZ6J3fm4j8tG3bFgsLC/bt26fE488//+TPP//Ey8urwP0HDBjAyJEjleXo6OhCHffChQv06NGDPn36KOu6d+9e4H4RERFkZmYqA8R79uzJ4sWLuX79eo5uWfb29kqXrbZt23Lq1Cn279/PwIEDC/37Pal169bKb9O+fXvi4uL47LPPeOedd9DV1WX16tVYWVmxevVq9PX1AahatSpeXl4cPXoUV1dXvv/+ey5evMjGjRuVeDs5OeHi4qL1FqN///54enpy5coVZYzNF198QdWqVWnbtm2h2itEXrIHoRdnn+Ls+yqQ+BRMYpQ/iU/BXoQYSUJRRlWoUIHNmzfnWP/5558r3W8Ajh8/jpmZGa1bt9Z6o+Hs7MxHH32ERqNRnhCbmJhoPY03MTHB2dmZc+fOKeuuXLnCkiVLiIqKIi4uTll/9erV0jw9Lba2tiQmJuLr60vPnj1p3rx5kZ76F0e5cuXo1q0b+/btw8/PDwMDA/bt24ehoSFdunQpcP+CEp682Nra8uWXX2JlZUX79u1p0KBBofaLiIigcePGypue7t27s2TJEsLDwxk3bpxW2ezEMpuNjQ0nT54sVnuBHPFwd3fnq6++IjY2lmrVqvHTTz/Ro0cPJZnIboNKpeLnn3/G1dWV8+fP53n9/fbbb8q61q1bU6NGDXbt2sUHH3xAeno6e/fuVZIXIUqiJIPPX4WB6yUh8SmYxCh/Ep+CleUYSUJRRunq6ub6VP/IkSNaywkJCSQmJub5NuPOnTvKQFsLC4sc2y0tLbly5QoAKSkpvPfee1hYWODr60u1atUoX748M2fO5NGjRyU8o7y1adOGgIAANm3ahJeXF+XLl8fd3Z0PP/xQ6+n1k7LHTdy8eZNatWoV67g9evRg69atHDt2DDc3NyIiInB1daVixYoF7lupUqViHXPWrFmYmpqyYcMGAgICqFq1KiNHjmTQoEF57nPlyhV+//13JkyYQFJSEpB1M96kSRMiIiJyJBQmJiZay/r6+jx+/LhY7YWc1032ud+5c4dq1aqRlJSUaxcxS0tL7t3LGrdw+/btPK+/J+no6NCvXz82bdqEt7c3R44cIT4+nr59+xa7/UJkS0p6gEaTs9tofvT0dFGpDIu176tA4lMwiVH+JD4Fe14xUqkMC/1WRBKKF5ypqSkWFhasXbs21+1P3sTFx8fn2B4XF4eVlRUAv/zyC7GxsaxZs4aGDRsqZZKTk5/57D+9evWiV69exMfHc/DgQfz9/SlXrhyffvppruVbtWoFwA8//FDshKJ58+a89tpr7Nu3D0tLS6Kjo5kxY0ax6ipfvjwAaWlpWuuzE4BsJiYmzJgxgxkzZnDp0iU2bdrEnDlzaNCgAS1btsy17r179wJZA+IDAwNzbP/111/zTChLw9PXzd27dwGU68bU1FTrbVa2uLg4TE1NAbC2ts7z+nta3759WbFiBUeOHGHXrl04OTlRo0aNEp+HEBpNBunpxfs/45Ls+yqQ+BRMYpQ/iU/BynKMpA/BC87Z2Zn4+Hj09fWxs7PL8cfAwEApm5yczIkTJ7SWf/zxR5o2bQpkTX8KaHVdOXv2LDExMVrHLOwT7+x6ivJ2w8LCgn79+tG2bVv+/vvvPMu1bNkSe3t7Vq9eze3bt3Nsv3nzJpcuXcr3WDo6OvTo0YNDhw7x+eefY2ZmVuxB3paWlujr6ytveyBr9q0zZ87kuY9arWb69OkAWvs9Lfu7GJs2bdL6s379evT19QkPDy9SW4v6xuLAgQNay/v378fa2lpJMlu0aMHBgwe1utwdP36cpKQkWrRoAYCdnV2e19/TrKys6NixI+vWrePYsWO89dZbRTo/IYQQQvy35A3FC65t27Z06tSJ4cOHM3z4cNRqNQ8ePOCvv/7i2rVrfPLJJ0pZMzMzZsyYwcSJE5VZdjIzMxk2bBgAzZo1w8jIiDlz5jBy5Ehu3bpFYGBgjmlZbWxsSE9PJzQ0FAcHB4yNjXOdxal27dro6enxxRdfUK5cOfT09HLtxrVixQoSExNp1aoVlpaW/Pnnnxw7dgxPT898z33RokV4eHjw1ltvaX3Y7syZM2zZsoUFCxYoU6PmpUePHqxZs4bdu3fzzjvvaCVTRaGrq0uXLl3YsmULtWrVwtzcnM2bN5OZmYmOzv++0DtgwAC6dOlC/fr10dPTY8+ePejr6+f5diIqKoobN24wZswYnJyccmzv2LEj+/btY9q0aYVua2F/v2wnT55kwYIFtG3bluPHj/PVV1/h5+enjGkYPXo0AwYMYNSoUXh4eCizPNnb2yuTAnTo0IHGjRszdepUfHx8MDExYe3atXnOMNW/f39GjhyJSqXC3d290OcmhBBCiP+eJBQvgRUrVrB27Vq2bdtGTEwMJiYm1K9fP0e/cysrK3x8fAgICOD69evUr1+f9evXK33iK1WqxPLlywkICGDs2LHUrl2bOXPmsG7dOq16OnXqxKBBg1i7di1xcXE4OjoSFhaWo10WFhb4+fmxbt069u7dS3p6eq5vDezs7AgNDeWbb74hJSWFKlWq4OXlxZgxY/I971q1avHll18SHBzMtm3buHnzJgYGBtja2vLhhx/SqVOnAmPXoEED1Go1ly5d0vpuR3HMmjWLWbNm8fHHH1OxYkW8vLyoU6cOBw8eVMo0b96cPXv2EB0dja6uLg0aNGD16tV5fjU8IiICQ0PDPG+qe/fuzYEDBzh16lShuwUV9vfLNnfuXHbs2MG2bduoWLEikyZNYvDgwcr2Jk2aEBISwpIlS5gwYQJGRkbKdyiyJwTQ0dFh1apVzJ49Gz8/P1QqlZJ8PBmfbO3atcPQ0JDu3bsr3clKonplk4ILiZeW/P5CCPFs6WRmZspnQ18BT3+gTYiy7MSJE3h6evLFF1/QpEmTEtX19Fsi8WrSaDJITEwt8peyy5XTxdy8IgkJ98ts3+XnSeJTMIlR/iQ+BXteMbKwqCiDsoUQL55bt25x/fp1Fi5cSPPmzUucTEDW2xGZPSR3r9LsKhkZmUVOJoQQQhSOJBRCiDLj888/Z9WqVTRq1IiPP/641OotyzNjlAUSHyGEECUhXZ6EEC89eZWeO+lqUDCJUf4kPgWTGOVP4lOwF6HLk0wbK4QQQgghhCg2SSiEEEIIIYQQxSYJhRBCCCGEEKLYJKEQQgghhBBCFJskFEIIIYQQQohik4RCCCGEEEIIUWySUAghhBBCCCGKTT5sJ4R46RV2Hu1XTXZcJD7/I1/UFkKIopOE4gUWGBhIUFBQrtu8vb0ZOXLkf9yiwvP19eXixYtERESUqbqKa+PGjdSpUwcXFxet9a6urnTs2BE/P7//rC29evWiUaNGzJ8//z875rOwe/duYmJimDBhQonqyczMRKUyLKVWvZwkPv+j0WSQmJgqSYUQQhSBJBQvuAoVKhAaGppjfdWqVZ9Da15dmzZtomPHjjkSClE09+7dY9euXQwdOlRZl5mZyc6dO3FycqJWrVpFrlNHR4dFW34m+lZyaTZVvISqVzbBZ3ALdHV1JKEQQogikITiBaerq0uzZs2edzPEK+zhw4dUqFChVOoyMDDg4cOHDB48mIYNG5KUlMTQoUOxtbWla9euxa43+lYyV2LulUobhRBCCKFNOs6+AtRqNcHBwQQGBuLs7IyTkxPTp08nNTVVq9ytW7eYNm0azs7O2Nvb061btxxvP3bv3k3Pnj2xs7Ojffv2LF26FI1Go7VdrVbzyy+/MHToUJo2bYqrqyu7du3KtW2nTp2id+/eNGvWjLfffpuLFy9qbQ8JCeGtt96iRYsWtGnThlGjRvHPP/8UeM6XLl3Cy8uLZs2a0aJFCyZOnMi///6bIy5r164lICCA1q1b4+DggK+vLykpKUqZ1NRU5s6di7u7u3Iufn5+JCf/72m3q6srMTExbNmyBbVajVqtZvfu3VrH2rJlC506daJFixaMHTuW+Ph4ANLS0mjbti1Lly7NcQ7vv/8+b7/9dr7nefbsWfr27YudnR09evTg6NGjuZaLiopi6NChSjy8vb2Ji4vTKhMbG8uoUaNo2rQpLi4ubNy4kU8++QRXV1elTPbvGxUVxbvvvkuzZs0ICAhQ9vfx8cHJyQl7e3sGDx6c4/fMriOva8jQ0JBx48bxySefEBkZycGDBxk/fjzTp0/HzMws31gIIYQQ4vmQNxQvgfT09BzrypXT/mm3bNlCixYtmD9/PlevXiUgIABLS0t8fHwASEhI4J133gFg8uTJVK9enWvXrnH9+nWljg0bNrBw4UKGDRuGr68vV65cUW4Gs+vJNmXKFN555x1GjBjB119/zYwZM7C2tqZDhw5KmTt37vDxxx8zcuRITExMWLx4MePHj+fAgQPo6+sDWTepQ4YMoVq1aqSkpLB9+3YGDBjA/v3787zBvHnzJkOGDKFGjRosXLiQR48esXTpUoYMGcLevXsxNjZWyoaFhdG4cWMWLFhAdHQ0ixYtUspD1tN3jUbD5MmTsbCw4ObNm6xevZqxY8cSFhYGQFBQECNHjqR58+a89957ANSsWVM5xqFDh7h27Rp+fn4kJCTg7+/PvHnzWLp0Kfr6+vTp04c9e/YwadIkdHWzcvzExEQOHjzIjBkz8vrZuXPnDl5eXqjVapYtW0ZSUhJz5swhNTWVRo0aKeWioqLw8PDAxcWFpUuX8uDBA5YtW8bYsWPZsWMHkNWtaOzYsdy9e5c5c+ZgYmLC+vXr+ffff5U2Pcnb25t33nmHUaNGYWhoyL179xg0aBBGRkbMmjULExMTwsLCGDZsGN9++y2WlpaFuoYePnxIaGgohw4dwt3dneTkZIKCgjhy5AhjxoxBpVLlGQ8hhBBCPB+SULzgUlNTady4cY71W7ZsoWXLlsqylZUVixcvBqBDhw789ttv7N+/X0kENm7cSFxcHN988w3Vq1cHoE2bNsr+KSkprFixguHDhzNlyhQA2rZti76+PvPnz8fLywtzc3OlfK9evRg1ahQA7du358aNG6xcuVIrobh37x6bN2+mfv36QNbT6aFDh3Lu3Dml7R9++KFSXqPR0LZtW9q0acP+/fuVBOhpGzduJD09nZCQECXpaNSoEd27d+fLL7/Ew8NDKWtgYMDKlSvR09MDoHz58sycOZPx48djY2ODhYUFc+bMUcqnp6dTvXp1Bg0axD///EOdOnWwtbXFwMCASpUq5dr9LDMzk88++wwDAwMAYmJiWLNmDRkZGejq6tKvXz/WrVvHsWPHlDEY4eHh6Orq0qNHj1zPESA0NBQdHR2Cg4MxMTEBoEqVKnh6emqVW7x4MU2aNCEoKAgdHR0AGjRooLzRcHFx4fvvv+fXX3/Vum5at26Ni4tLrjfxAwYM0Br0v2LFCpKSkti5c6eSPLRp0wZ3d3fWr1/PtGnTCnUN6ejoUK5cOTZv3kx4eDgxMTEsXbqUzz//nPj4eEkoxH/iyVmvZCas/El8CiYxyp/Ep2AvQowkoXjBVahQgc2bN+dYX7duXa1lZ2dnrWUbGxv27dunLJ84cYLWrVsrycTToqKiSE1NpVu3blpvRJydnXn48CGXL1+mVatWyvouXbpo7d+1a1cCAgLQaDTKzbu1tbWSTADUq1cPyOp6le2XX35h+fLl/PbbbyQmJirrr169mms7AX766SecnJy03mDY2NjQsGFDfv75Z62EolOnTkp7ALp168aMGTO4cOECNjY2AOzZs4eNGzdy7do1rW5iV69epU6dOnm2I5ujo6OSTGS3JS0tjbi4OKysrKhVqxatWrXiiy++UBKK3bt34+7urvU25Wnnzp3DyclJSSYg6yb+yfN+8OABZ8+eZdq0aVpd02rXrk3VqlW5cOECLi4uXLhwAZVKpZWEVqxYkTZt2vDrr7/mOHbHjh21lo8fP46TkxOmpqbK9aGrq4ujoyMXLlwACn8NeXl5adWto6OTZ/IoxLOQ26xXMhNW/iQ+BZMY5U/iU7CyHCNJKF5wurq62NnZFVju6Se7+vr6PH78WFlOTEzUurl/WkJCAgB9+vTJdfvNmze1lrOfUmerVKkSaWlpJCQkUKlSpTzbBPDo0SMA/v33X9577z2aNGnCnDlzsLa2Rl9fn1GjRillcpOUlKTV5efJNt27dy/HuicZGxtTvnx5bt++DcCBAwf44IMPeOedd5g8eTJmZmbcuXOHcePG5duGJz19ntnJxZP79+/fH19fX+Lj47l9+za//fYbvr6++dZ7586dXGc9srCwUP6elJSERqPB398ff3//HGWzf7fbt29r7ZdbXU/K/g2zJSQk8Msvv+T6tiy7+1dRr6G+ffvmWk6IZy0p6QEaTQaQ9URQpTLUWif+R+JTMIlR/iQ+BXteMVKpDAv9VkQSCgGAmZmZchOdG1NTUyBrvECVKlVybH/6zUZcXByVK1dWlu/evYu+vr5Wt6iCHDt2jNTUVIKCgpSb8vT09BxJQW5tfXrAcXabateunWPdk1JSUnj06BHW1tYAREZG0qhRI+bOnauUOX36dKHPobC6du3KvHnz2Lt3L9HR0dSsWVPrjU9urKyscj3P7AHfACYmJujo6DBq1Cg6d+6co2z272Ftba21X2515cfU1JT27dszadKkHNuyE6iiXkNCPC8aTQbp6RkFrhP/I/EpmMQofxKfgpXlGElCIYCsrjIhISH8+++/VKtWLcd2BwcHDA0NiY2NzdGdKTcHDhzA1tZWWf72229p3LixVveigjx8+FDpU5/tm2++yXUQ+pNatGjB559/zr1795Sb2L///ptLly7x1ltvaZU9fPgw06dPV9oVGRmJjo6O8tbn4cOHypuTbOHh4TmOqa+vX+g3FrkxMDCgV69e7Ny5k7t37+Lp6amMd8iLvb0927ZtIzk5Wen2dOLECa2uYUZGRjRr1oy///473zdZdnZ2JCUlcebMGRwdHQG4f/8+J06cKNS4BWdnZ/bu3YuNjQ1GRka5linqNSSEEEKIF4MkFC+4jIwMfvnllxzrLS0tqVGjRqHr8fT05KuvvmLIkCGMGTOGGjVqcOPGDa5evcrUqVNRqVRMnDiRhQsXEhsbS6tWrdDT0+PGjRscPHiQwMBADA3/17fvq6++okKFCtja2vL1119z5swZ1q5dW6Rza926NQDTp09nwIABXL58mQ0bNhR4g+vp6cnu3bt57733GDNmDI8ePWLZsmVUrVo1R3ebx48fM27cOAYOHKjM8uTu7q6Mn3B2dmbu3LmsXLkSBwcHjh49yokTJ3Ics27dupw8eZLjx4+jUqmoXr16kd7GQFa3p9DQUPT09ArV3WfYsGFs3bqVESNGMGLECJKSkggMDMwx+9W0adMYNmwY77//Pt27d0elUhEbG8uPP/5I3759cXJyokOHDjRu3Bhvb2+mTJmCSqVi3bp1VKxYscDEBrJiHh4ezpAhQxg6dCjVqlUjPj6ec+fOUblyZTw9PYt8DZWm6pVNCi4kXnlynQghRPFIQvGCe/jwYa4DVt9++20++eSTQtdjbm7Otm3bWLx4MYsWLeLBgwe89tprDBo0SCnz3nvvUblyZTZs2MDmzZspV64cNWvWpGPHjjme4i9evJglS5awcuVKLC0tmTdvXpG/Iq1Wq/H39ycoKIhRo0bRqFEjli9fzvvvv5/vflWrViUsLIyAgAB8fHzQ1dWlbdu2+Pr65hjk7OHhQXx8PNOmTePx48d06dIFPz8/ZfuAAQOIjo5m8+bNrF+/nnbt2rF48WL69++vVc+UKVP46KOPmDBhAvfv38ff37/IYwDq1atH7dq1qVmzplZ3sbxYW1sTHBzMxx9/zKRJk6hZsyZ+fn45vmnRvHlztm7dSmBgINOnTyctLY0qVarQunVrZQyGjo4Oq1atws/PDz8/P1QqFUOHDuWff/7h999/L7At5ubm7Nixg2XLlrFo0SISExOxtLSkadOmWm8jinINlZbMzEx8Brd4JnWLl49GkyFfyRZCiCLSyczMlH85RanZvXs306dP58SJE3kO6C0r1Go106ZNyzGr0PNy/fp1unbtyvLly3F3d3/ezeHx48d0796dli1b5jqg+0Uig/1yJ4Mhc8rIyNRKKMqV08XcvCIJCffLbN/l50niUzCJUf4kPgV7XjGysKgog7KFeFEkJCTwzz//sHLlSqpVq4abm9tzaceOHTvIyMigTp06JCUlsW3bNmJiYliyZMlzaU9pKssD2coCiY8QQoiSkIRCiOfs8OHDfPjhh9SqVYuFCxfm+Mr5f6V8+fKsXbuWmJgYABo2bMiaNWsKNS2xEEIIIV5d0uVJCPHSk1fpuZOuBgWTGOVP4lMwiVH+JD4FexG6PJXdb3gLIYQQQgghyjxJKIQQQgghhBDFJgmFEEIIIYQQotgkoRBCCCGEEEIUmyQUQgghhBBCiGKThEIIIYQQQghRbPIdCiHES6+w0969arLjIvHJ3ZNfzBZCCJE3SSheUYGBgQQFBSnL5ubmNGjQgIkTJ9KyZcsS15+UlERoaCivv/469erVK/L+Hh4eGBkZsWbNmly3jx49mr///ptvv/021+1hYWF8/PHHHDhwgJo1axZ4PFdXVzp27Iifn1+R25rt6Zjm5rXXXuPQoUMFnt/zVhrxKKxnHYvMzExUKsNnUvfLQuKTO40mg+Tkh8+7GUIIUeZJQvEKq1ChAqGhoQDExsayatUqPD092b17Nw0aNChR3UlJSQQFBVG/fv1iJRQF6dGjB97e3pw/fx57e/sc2/ft20ezZs0KlUwABAUFoVKpStSmfv360b59e2V5586dREREKDEGMDAwKNExXkazZ89GV/fZPSHX0dFh0Zafib6V/MyOIV4+1Sub4DO4Bbq6Os+7KUIIUeZJQvEK09XVpVmzZsqyvb09rq6ubN++vURPph8+fPZP9Nzc3DAyMiIiIiJHQhEdHU1UVBQzZ84sdH22trYlblOVKlWoUqWKsnzs2LEcMS6phw8fUqFChVKrryx4Fgnn06JvJXMl5t4zP44QQgjxKpKOs0JRrVo1LCwsiI6OBiAjI4NVq1bh6upKkyZN6NatG9u3b9faJzAwEAcHB86fP88777yDnZ0dW7Zswc3NDYBJkyahVqtRq9VKvYsWLaJnz544ODjQvn17pkyZwu3bt4vUVkNDQ9zc3Pjmm2/IyND+DP2+ffvQ09PjjTfeALLevvj4+ODk5IS9vT2DBw/m4sWLWvu4uroyd+5cZdnX15cePXpw6tQpevfuTbNmzXj77bdz7FdSkZGRuLu74+DgwNChQ7l+/bqyLTo6GrVaze7du5k5cyZOTk7069cPgMTERKZPn66c04ABAzhz5oxW3R4eHowaNYqIiAi6du1K06ZNGT16NPfu3SMmJgYvLy8cHBzo3r07p06dyrV969ato3379jRt2pQxY8bk+J0K046ff/6ZwYMH06JFCxwcHOjZsydffvlljnZmi42NZdKkSTg7O2NnZ4erqyuffvpp8QIshBBCiGdO3lAIRUpKComJiVhbWwMQEBDApk2bGDNmDA4ODhw5coTZs2eTnp7OkCFDlP3S0tLw9vbG09OTyZMnY2ZmRlBQEOPHj2fKlCk4OTkBKPXGxcUxatQorK2tiY+PZ8OGDXh4eLBv3z7KlSv8JdmzZ0/Cw8M5deoUbdq0UdZHRETg7OyMpaUl9+7dY9CgQRgZGTFr1ixMTEwICwtj2LBhfPvtt1haWuZZ/507d/j4448ZOXIkJiYmLF68mPHjx3PgwAH09fWLFNvc/P7778THx+Pj44NGo2H+/PlMnTqVHTt2aJVbsmQJLi4uLF68mIyMDDQaDSNGjODGjRv4+PhQqVIlwsLCePfdd9m+fTtNmjRR9v3tt99ISEhg2rRppKSk8PHHHzNr1ixiYmLo3bs37777LmvWrGHChAkcPnyYihUrKvseOHCA1157jY8++oikpCQWLVrEhAkTlPYVph0pKSmMGjWKFi1asGTJEgwMDPjrr79ISkrKMy7Tpk3j9u3bzJw5E0tLS27evFnqiZwQQgghSo8kFK+49PR0IOup8IIFC9BoNLi7uxMfH8/mzZvx8vJiwoQJALRr146EhARWrlzJwIED0dPTA7ISismTJytvBACMjY0BqFWrVo4uP/7+/srfNRoNDg4OdOjQgZMnT9KuXbtCt71t27ZYWFiwb98+JaH4888/+fPPP/Hy8gIgNDSUpKQkdu7cqSQPbdq0wd3dnfXr1zNt2rQ867937x6bN2+mfv36QNZbkaFDh3Lu3LlSGbienJzMnj17sLCwACA1NZXp06cTGxur1XWqYcOGfPLJJ8rywYMHOX/+vPL2ALJ+m65du7JmzRoCAwOVsikpKaxevVo5xqVLlwgJCeGjjz5i4MCBQFai17NnT06cOEHnzp2Vfe/fv09wcDAmJiZAVpcuT09Pjh07Rvv27Tly5EiB7fjnn39ITk5mypQpqNVqAK3kLzcXLlxgypQpWtdT7969ixZcIUpJ9hgKmQkrdzJTWMEkRvmT+BTsRYiRJBSvsNTUVBo3bqwsm5qa4ufnp9wspqWl0a1bN619Xn/9dSIiIrh69So2NjbKehcXl0If9+jRo3z22WdcvnyZlJQUZf3Vq1eLlFCUK1eObt26sW/fPvz8/DAwMGDfvn0YGhrSpUsXAI4fP46TkxOmpqZK8qSrq4ujoyMXLlzIt35ra2slmYD/9fW/detWoduYn4YNGyo3+k/W/3RC0bFjR639fvrpJ4yNjbUGgOvr69OlSxciIiLyPUbt2rUBcHZ2zrEuNjZWa18nJyclmYCsRMDMzIxz587Rvn37QrWjZs2aGBsb89FHH+Hh4UHr1q212pMbW1tbQkJC0NPTo23bttSqVSvf8kI8S8bGWWOWZCas/El8CiYxyp/Ep2BlOUaSULzCKlSowObNm9HR0cHc3JyqVasqs+3cu5c1gLVSpUpa+2QvJyYmKusMDQ21usrk5/z584wdOxY3NzdGjBiBpaUlOjo69O/fn0ePHhX5HHr06MHWrVs5duwYbm5uRERE4OrqqrQnISGBX375RStxylbQDFBPz/qU3c2pOO0sSf1Pd8tKSkrKtatWpUqVlN+toGM8mShkzzxV0HEBLCwsuHPnTqHbYWpqyoYNG1ixYgXTpk1Do9HQsmVLZs6cqbyxeNrSpUtZunQpy5YtY86cOdSpU4cpU6bQtWvXXMsL8SylpDzE2LgCSUkP0GgyCt7hFaOnp4tKZSjxyYfEKH8Sn4I9rxipVIaFfisiCcUrTFdXFzs7u1y3mZmZAVnjHSpXrqysv3v3rtZ2yJqWs7C+++47jI2NWbZsmZK8xMTEFLHl/9O8eXNee+019u3bh6WlJdHR0cyYMUPZbmpqSvv27Zk0aVKOfV+UKVyfjq+pqSlxcXE5yt29exdTU9NSO25ux4iPj8fKyqpI7bC3t2fdunU8fPiQU6dOsWDBAsaNG8d3332X63Gtra3x9/cnIyODixcv8tlnnzF58mQiIyOpUaNGKZ2dEIWT/XE7jSaD9HS52cmLxKdgEqP8SXwKVpZjVHY7Y4nnys7ODn19fSIjI7XWf/PNN1haWirdZPKS19P2hw8foq+vr3WTHB4eXux26ujo0KNHDw4dOsTnn3+OmZmZVhccZ2dnrly5go2NDXZ2dlp/8npCXta1aNGClJQUfvjhB2Vdeno63333HS1atCi145w6dYrk5P99u+HEiRMkJibStGnTYrWjQoUKuLi4MHDgQKKjowt806Orq4u9vT3vv/8+6enpXLt2rZTOTAghhBClSd5QiFxZWFgwZMgQ1q9fj4GBAc2aNePo0aNEREQwa9YsZUB2XqysrFCpVOzbt4/q1atjYGCAWq2mbdu2hIaGMm/ePLp06UJUVBRfffVVidrao0cP1qxZw+7du3nnnXe0ZmDy9PQkPDycIUOGMHToUKpVq0Z8fDznzp2jcuXKeHp6lujYz0PHjh2xt7dn6tSpeHt7K7Mr3b59mxUrVpTacSpWrMiIESMYMWIEycnJLFq0CHt7eyVhK0w7jhw5wq5du+jcuTPVqlXj7t27bN68mebNm1O+fPkcx0xOTsbLy4tevXpRp04d0tLSCAsLQ6VSlehbIdUrmxRcSIgnyDUjhBCFJwmFyNO0adMwMTFh165drF69mtdee405c+YwYMCAAvfV1dXF39+fJUuW4OnpyePHjzl48CAuLi74+PiwefNmdu/eTfPmzVmzZg3u7u7FbmeDBg1Qq9VcunSJnj17am0zNzdnx44dLFu2jEWLFpGYmIilpSVNmzZVBm6/aPT09Fi7di0BAQEsXLhQGVwfEhKiNWVsSXXp0oUqVaowe/ZskpKScHZ2Zs6cOUVqR82aNdHV1WXZsmXExcVhZmZGu3btmDJlSq7HLF++PA0aNCAsLIybN29SoUIFmjRpwvr16wsczJ2XzMxMfAaX3psb8erQaDKULk9CCCHyppOZmSn/WgohXmoy2C93MhgyfxkZmejq6mBuXpGEhPtltu/y81SunK7EpwASo/xJfAr2vGJkYVFRBmULIUS2sjyQrSyQ+OQt+zsUQggh8iaDsoUQQgghhBDFJgmFEEIIIYQQotgkoRBCCCGEEEIUmyQUQgghhBBCiGKThEIIIYQQQghRbJJQCCGEEEIIIYpNEgohhBBCCCFEsUlCIYQQQgghhCg2+bCdEOKlV9gvfb5qsuMi8clbdmx0dOQDd0IIkZdXLqEIDAwkJCSEqKioIu136tQpoqKiGD169DNqWclt3LiROnXq4OLiorXe1dWVjh074ufn91zaderUKYYOHcquXbuws7PLs5xarQayzqNNmzbK+qSkJBwdHfH396dv377PvL2lQa1WM23aNLy8vADw8PDAyMiINWvWPPNjb9y4EX9/fy5dupRnmezfJJuhoSE1atTg7bffZsiQIejp6RXpmLt370ZfX5+ePXtqrS/JeUdHRzN9+nTCwsKKvO+TMjMzUakMS1THy07iUzATkwokJqaSkZH5vJsihBBlziuXUBTX6dOnCQkJKdMJxaZNm+jYsWOOhCIoKAiVSvWcWlV0q1at0kooXgazZ89GV7fsPQX29/enbt26JCcns2fPHj799FMePXrEyJEji1TPl19+iZGRUY6EojjnHRwczFtvvaW17syZM6SkpNCpU6ci1QVZT5YXbfmZ6FvJRd5XCIDqlU3wGdwCXV0dSSiEECIXklA8Jw8fPqRChQr/ybFsbW3/k+OUBicnJ06dOsVPP/1Ey5YtS73+/zLuT6pXr95/fszCqF+/vvLWqG3btvz222988cUXRU4o8lKc865cuTLDhw/HxcWF5ORkPvjgA5KTk/H29i52O6JvJXMl5l6x9xdCCCFE3sreI9P/WHR0NGq1mq+++oq5c+fi6OhIu3btWLBgAenp6UBWN6mgoCBSU1NRq9Wo1Wo8PDyUOq5cucKYMWNo0aIFzZo1Y+TIkVy/fl3rOGq1mrVr17Jw4ULatm2rPIF3dXVl7ty5bNmyhU6dOtGiRQvGjh1LfHy8sm9qaipz587F3d2dpk2b4urqip+fH8nJ/3vi6urqSkxMDFu2bFHauHv3bq1jPOnbb7+lV69e2NnZ0a5dO/z9/Xn06JGy/dSpU6jVao4fP463tzcODg506tSJ4OBgrXqyu4G1a9eOZs2a0atXL/bs2VPs38PFxYXGjRuzcuXKAstu374dd3d3mjRpgqurK6tWrSIjI0PZvnv3btRqNVFRUbz77rs0a9aMgIAA5dyOHTvGpEmTcHBwoGPHjoSHhwP/e9PTqlUrZsyYwePHj5U6b9++zfTp03Fzc8Pe3p6uXbuyZMkSrTK58fDwYNSoUcpybGwskyZNwtnZGTs7O1xdXfn000+19inMdZWSksK0adNwcHCgdevWBAQEoNFoCoxdbnR1dVGr1dy8eVNr/aJFi+jZsycODg60b9+eKVOmcPv2ba1zO336NEeOHFGuvcDAwFzPG7LeNgwYMAB7e3ucnJyYPn06iYmJyvY333yTTZs2cfToUX7//XdsbGxYtWoVNjY2xTovIYQQQjxb8obi/y1btgw3NzeWLVtGVFQUgYGB1KxZk4EDB9KvXz9iY2OJiIggNDQUAGNjYwBu3LjBgAEDqF+/PvPnz0dHR4fVq1fj6elJZGQkBgYGyjE2bdpE06ZN+eSTT5RkBeDQoUNcu3YNPz8/EhIS8Pf3Z968eSxduhTIeqqu0WiYPHkyFhYW3Lx5k9WrVzN27Filf3lQUBAjR46kefPmvPfeewDUrFkz13M9ePAgEydOpHv37nh7e/P333+zdOlSbt68yYoVK7TKzp49m169erFy5Uq+++47Fi1ahFqtpkOHDgD8+++/NG/enIEDB2JgYMDZs2eZOXMmmZmZ9OnTp1i/xdixYxk3bhy//PILzZo1y7VMWFgYH3/8MR4eHnTs2JGoqCiCgoKUJ9pP8vb25p133mHUqFEYGhry8OFDAD766CP69OlD//79+fzzz5k2bRp//PEHly9fZs6cOdy4cYP58+dTo0YNpatbQkICZmZmTJ8+HZVKxdWrVwkMDOTOnTv4+/sX+hynTZvG7du3mTlzJpaWlty8eZOLFy8q2wt7XX344YccO3YMHx8fqlevztatW4mIiChKuLX8+++/VK9eXWtdXFwco0aNwtramvj4eDZs2ICHhwf79u2jXLlyzJ49m6lTp1KhQgUl9lWqVMm1/osXL/Luu+/i5OTE8uXLuXv3LosXL+avv/5i+/bt6Onp8fXXX7N+/XpcXFzQaDT89ddfTJgwgSlTplCnTp1in5sQQgghng1JKP6fvb09M2fOBLK6fpw6dYr9+/czcOBAqlSpQpUqVdDV1c1xgxsUFISpqSkbNmygfPnyADRv3hw3Nzd27tzJ4MGDlbKmpqYEBQXlmC0kMzOTzz77TLlJjImJYc2aNWRkZKCrq4uFhQVz5sxRyqenp1O9enUGDRrEP//8Q506dbC1tcXAwIBKlSrleRP+ZJubNWvG4sWLAejQoQOGhob4+flx6dIlZXA0QNeuXZkwYQIAbdq04ciRI+zfv19JKLp37651Ho6Ojty6dYsdO3YUO6Fwc3NDrVazcuXKHG9EADQaDStXrqR79+7Kb9auXTvS0tIICQlh5MiRmJubK+UHDBig1YXn1KlTAHTr1o3x48cDWb//gQMH2LdvHwcOHEBfXx/IGjsTGRmpJBRqtVorYWnevDmGhob4+vri5+eHoWHhBrdeuHCBKVOm8MYbbyjrevfurfy9MNfVX3/9xbfffsvHH3/M22+/rcSha9euhWoDQEZGBunp6SQnJ7N7927Onz/PkiVLtMo8mShpNBocHBzo0KEDJ0+epF27dtSrVw9jY2OMjIwKvPZWr16NlZUVq1evVmJctWpVvLy8OHr0KK6urkRHRxMcHExqaio//fQTAQEBnD59WrnWhXheZDasnGSmsIJJjPIn8SnYixAjSSj+X7t27bSWbWxsOHnyZIH7HT9+nDfeeAM9PT3lrYNKpcLW1lbriTNk3bjnNvWgo6Oj1psMGxsb0tLSiIuLw8rKCoA9e/awceNGrl27RmpqqlL26tWrRbrJun//Pr///nuOp/hvvPEGfn5+/Pzzz1oJxZNx0dHRwcbGhtjYWGXdvXv3CAwM5ODBg9y6dUvpbmNmZlboNj1NR0eHMWPG8P7773PhwgVq1aqltf3vv/8mISGBbt265TiHNWvWcP78ea2B6R07dsz1OG3btlX+bmJigoWFBS1btlRudAFq166tJCCQlTSFhoby+eefEx0drdVN7MaNGzRo0KBQ52hra0tISAh6enq0bds2xzkW5rq6cOECmZmZdOnSRdlPT0+Pzp07s3HjxkK1o3///lrLI0eO1EpyAI4ePcpnn33G5cuXSUlJUdZfvXo1x383Bfnpp5/o0aOHVozbtWuHSqXi559/xtXVVUn+nrzOW7VqVaTjCPEsyGxYeZPYFExilD+JT8HKcowkofh/JiYmWsv6+voF9ouHrC4woaGhSleop+t4kqWlZa51PD0DU3ZykX2zeuDAAT744APeeecdJk+ejJmZGXfu3GHcuHFaN7SFkZycTGZmZo62mJiYYGBgwL1793Ksf/qcnhy74evrS1RUFOPGjVOeVG/bto1vvvmmSO16mru7O/Xq1WPVqlUsWLBAa1t2G58+h+zlp8+hUqVKuR7j6XMzMDDI8Vs8fR2EhoayYMEChg8fjpOTEyqVigsXLjB37twi/RZLly5l6dKlLFu2jDlz5lCnTh2mTJmivF0ozHV1584d9PX1MTU11dqe13WWmwULFmBjY0N8fDxr1qwhODgYR0dH5Q3U+fPnGTt2LG5ubowYMQJLS0t0dHTo379/ka89yJoCOLf2WVpa5vjdqlevXuIpY4UoTUlJD9BoMgou+ArR09NFpTKU2ORDYpQ/iU/BnleMVCrDQr8VkYSihExNTXFxcWHQoEE5tlWsWFFrubgfRoqMjKRRo0ZaA6tPnz5drLpMTEzQ0dHRGvQNWYnG48ePc9yc5ufRo0ccOXIEX19frUHqW7duLVbbnqSrq8vo0aOZOnUqf/zxh9a27LcfT59DXFwcQJHOoagiIyNxdXXVmnHoypUrRa7H2toaf39/MjIyuHjxIp999hmTJ08mMjKSGjVqFOq6srKyIi0tjXv37mmdc3YcCsPGxkaZ5ally5Z069aNBQsW0L59e3R0dPjuu+8wNjZm2bJlyvSvMTExRT7fbKamprm2Ly4u7pn+bkKUBo0mg/R0ueHJjcSmYBKj/El8ClaWY1R2O2OVMXm9sWjTpg2XL1/G1tYWOzs7rT9169YtlWM/fPgwx9uO7BmJnm5jQU+NK1asSKNGjYiMjNRan/1GoUWLFoVu1+PHj8nIyNBqW0pKCocOHSp0Hfl54403qFWrVo4Zn+rUqYOFhUWu56Cvr4+9vX2pHD83hf0tCktXVxd7e3vef/990tPTuXbtGlC46yo7EThw4IBSn0aj4bvvvitWWypWrMjEiRP566+/lDqyz/fJZLi41x5kXV8HDx7UmpTg+PHjJCUlFenaE0IIIUTZIW8oCsnGxob09HRCQ0NxcHDA2NiYunXrMnHiRN5++228vLzo378/lSpV4u7du5w+fZqWLVvSo0ePEh/b2dmZuXPnsnLlShwcHDh69CgnTpzIUa5u3bqcPHmS48ePo1KpqF69utbg5Gzjx49n3Lhx+Pj48Oabb/LPP/+wdOlS3N3dtcZPFMTExAQ7OzuCg4OxsLCgXLlyrF27FmNj4xxvD4pDT0+PUaNGMX369Bzrx44dy8cff4yFhQUuLi788ssvBAcHM2zYsFzPubQ4OzuzadMmNm/eTO3atdm7d6+SBBRWcnIyXl5e9OrVizp16pCWlkZYWJgyRgIo1HVVr149unTponyMLnuWp7S0tGKfX+/evVm9ejXBwcF06dKFtm3bEhoayrx58+jSpQtRUVF89dVXOfarW7cue/bs4dChQ1hZWWFtbU3lypVzlBs9ejQDBgxg1KhReHh4KLM82dvb5/ggY2mqXtmk4EJC5EGuHyGEyJ8kFIXUqVMnBg0axNq1a4mLi8PR0ZGwsDBq1arFzp07lb7wqampWFlZ4ejoWKSb8/wMGDCA6OhoNm/ezPr162nXrh2LFy/OMaB2ypQpfPTRR0yYMIH79+/j7+9P3759c9Tn5ubG8uXLWblyJWPHjsXMzIz+/fsX68Nhixcvxs/PD19fX8zMzPDw8CA1NZWQkJBin++T3nzzTVauXEl0dLTWeg8PD8qVK8fGjRvZtm0bVlZWjB8//pl/yXzcuHEkJCQo0+u6u7szc+bMIh23fPnyNGjQgLCwMG7evEmFChVo0qQJ69evx8LCAqDQ19Wnn37K3LlzWbRoEQYGBvTp04dWrVoREBBQrPPT19dn9OjRzJw5k1OnTuHi4oKPjw+bN29m9+7dNG/enDVr1uDu7q6134gRI7h+/ToffPABSUlJjB8/Xpkd7ElNmjQhJCSEJUuWMGHCBIyMjHB1deWDDz5AT0+vWG0uSGZmJj6D5e2HKBmNJkO+ki2EEHnQyczMlH8hhRAvNRnslzsZDFmw7BglJqaSlla8j0a+zMqV08XcvCIJCffLbN/u501ilD+JT8GeV4wsLCrKoGwhhMhWlgeylQUSn4LJszchhMibDMoWQgghhBBCFJskFEIIIYQQQohik4RCCCGEEEIIUWySUAghhBBCCCGKTRIKIYQQQgghRLFJQiGEEEIIIYQoNkkohBBCCCGEEMUmCYUQQgghhBCi2OTDdkKIl15hv/T5qsmOi8Qnb88yRhkZmWRkyAfzhBAvPkkoxAvtzTff5NKlS2zZsoWWLVtqbTt16hRDhw5l165d2NnZAaBWq5k2bRpeXl7Po7kKDw8PjIyMWLNmTanUd+nSJQYMGMDBgwexsLAolToL659//qFbt24cPnyYatWq5VqmV69eNGrUiPnz5wMQGBhISEgIUVFRuZaPjo6mR48eREREUL169RK1LzMzE5XKsER1vOwkPgV7FjHSaDJITEyVpEII8cKThEK8sC5fvsylS5cACA8Pz5FQlGWzZ89GV7f0nnguW7aMvn37/ufJBMDhw4dRq9V5JhPFUb16ddzd3QkMDGTBggUlqktHR4dFW34m+lZyKbVOiJKrXtkEn8Et0NXVkYRCCPHCk4RCvLDCw8PR1dXF0dGRyMhIZs6cib6+/vNuVqHUq1ev1Oq6ceMGhw8fZvfu3aVWZ1EcPnyYTp06lXq9b7/9Nu+++y4ffPBBiROl6FvJXIm5V0otE0IIIcSTpOOseCFlZmYSERFB69ateffdd0lMTOTYsWOF2lej0RAQEEDr1q1xcHDA19eXlJQUZfvu3btRq9XEx8dr7derVy98fX2VZV9fX3r06MGPP/5Iz549sbe3Z8iQIURHR5OYmMikSZNo3rw5nTt35uuvv9aqy8PDg1GjRinLgYGBODg4cOnSJQYOHEjTpk3p0aNHoc5pz5491KhRA1tbW2VddHQ0arWaPXv24OfnR8uWLWnTpg0bNmwAYN++fbi7u9O8eXPGjx9PUlKSVp2XL19m8ODB2NnZ0bVrV/bu3cvYsWPx8PDQKpeUlMTZs2e1EoqzZ8/St29f7Ozs6NGjB0ePHi3wHHLTokULzMzMCA8PL9b+QgghhPhvSEIhXkhnz54lJiaGHj160K5dO8zMzIiIiCjUvmFhYfz9998sWLAAHx8f9u/fz6xZs4rVjjt37jB//nzGjBnDokWLuH79Oj4+PkyePJkGDRoQGBhI48aNmTp1KjExMfnWlZaWho+PD3379iUoKAgLCwsmTpxIQkJCvvv9+OOPODg45Lpt2bJlVKhQgeXLl9OtWzfmz5/P4sWL2bRpE1OnTsXPz4+TJ0+ycOFCZZ+HDx/y3nvvkZiYyMKFC5kyZQrBwcH8+uuvOeo/duwYpqam2NvbK/Hw8vLCwMCAZcuW4eXlxZw5c7h161ZBocxBV1eXpk2b8uOPPxZ5XyGEEEL8d6TLk3ghRUREUL58ebp27Yq+vj7u7u7s3buX+/fvU7FixXz3NTAwYOXKlejp6QFQvnx5Zs6cyfjx47GxsSlSO+7du8fmzZupX78+ALdv32bevHmMGDGCcePGAWBnZ8eBAwf47rvvGDZsWJ51ZScULi4uANSpUwc3Nze+//57evXqles+mZmZXLx4kc6dO+e6vVmzZnz44YcAtG7dmm+//ZbNmzdz6NAhzM3NgawB3bt27WLevHkAfPHFF8TFxbFt2zZlQHSTJk3o2rUrNWvW1Kr/8OHDdOjQQRkPEhoaio6ODsHBwZiYmABQpUoVPD098w9kHho2bMiWLVuKta8QL4IXfYYtmSmsYBKj/El8CvYixEgSCvHCSU9PJzIyEhcXF+WmtWfPnuzYsYMDBw7Qu3fvfPfv1KmTkkwAdOvWjRkzZnDhwoUiJxTW1tZKMgFQu3ZtAJydnZV1KpUKCwsLYmNj861LV1eXNm3aKMvVq1enQoUK+T7dv3fvHo8fP85zjEHbtm2Vv+vp6VGjRg10dHSUZCK7zUlJSUoydvHiRRo0aKA1u1L16tVp2LChVt0ajYZjx44xd+5cZd25c+dwcnJSfheANm3aYGZmlu+558Xc3JyEhATS0tJemPExQhTFyzLD1styHs+SxCh/Ep+CleUYSUIhXjjHjx8nPj6eTp06KX3/GzRogJWVFREREQUmFJaWllrLxsbGlC9fntu3bxe5LSqVSms5+6b3yRtqyHor8ujRo3zrqlChAgYGBjnqy2+/7G1P75ft6Xbo6+tjZGSUa5sfPXpExYoVuX37dq4JioWFhVZboqKiuH//vlbScufOHWrVqpXrvsWRfV6PHj2ShEK8lJKSHqDRZDzvZhSbnp4uKpXhC38ez5LEKH8Sn4I9rxipVIaFfisiCYV44WQP0p0+fTrTp0/X2paQkEBcXFyOpOFJcXFxWsspKSk8evQIa2trIKsLFGR1QXrS0wOXy4LsJ/+l2TZra2t+//33HOvj4+O1upMdPnwYR0dHjI2NlXVWVlY54pu9b3EkJSWhr6+vdQwhXiYaTQbp6S/+TdTLch7PksQofxKfgpXlGJXdzlhC5OLBgwccPHiQzp07s2nTJq0/S5YsIT09PceMSk87fPgwGo1GWY6MjERHR0f5+F3lypUB+Pvvv5UyV65c4ebNm8/gjEqmfPnyVKtWjejo6FKrs0mTJly6dIkbN24o66Kjo/njjz+0yh05ciTHdLH29vacOnWK5OT/ffPhxIkTJCYmFqstMTEx1KlTp1j7CiGEEOK/IW8oxAvl4MGDpKam4uHhgZOTU47t69atIyIiIsf0pk96/Pgx48aNY+DAgURHR7No0SLc3d2V8RNNmzalatWqfPrpp3h7e5OSksLatWuLPQ7gWWvevHmuMzAV11tvvcXq1asZPXo0EyZMACAoKIhKlSqho6MDZH374q+//sqRUAwbNoytW7cyYsQIRowYQVJSEoGBgbnGTqPREBkZmWO9vb298pG8ixcv0qJFi1I7NyGEEEKUPkkoxAslIiKCatWq5ZpMAPTu3ZtPP/2U69ev51mHh4cH8fHxTJs2jcePH9OlSxf8/PyU7fr6/9fencfVmP6PH39VSlFJssdYO1lKi6zRYslYxjAYhmzZxjoIGSbbzEh2ZQmTfYZZMGRk7Mww1sYyg4/BDIXQnpQ6nd8ffp2v47QvCu/n49Hj4Vznuq77ut/nlPM+93Vdtz6BgYHMnj2bCRMmULNmTT7//HP8/PwK/XwKg4eHB97e3iQmJhbK1CBDQ0OCg4OZNWsW3t7eVK5cmdGjR7N79271moyjR49St25datSoodG2UqVKrFu3ji+//FIdO19fX5YuXap1nJSUFCZMmKBV7u/vT/fu3YmKiuKvv/5i0qRJBT4ny8omOVcS4jWS96QQ4m2io1KpVMU9CCFE/qWmpuLm5oa3t3eOC9LzKzY2lvbt2zN48GDGjh3L0KFDsba2ZurUqUVyPIBt27axceNGfv31V/WVkfxQqVQFai9EUVEq04mNTSI9/c39b7hUKV3Kly9LTMzTEju3u7hJjLIn8clZccXI3LysLMoW4l2hr6/P8OHD2bx5c6ElFGvXrsXCwoLq1avz+PFjgoODUSqVfPTRRwAEBwcXynGykp6ezubNmxkzZkyBkwEdHR3ZPSQLsrtKzooyRunpqjc6mRBCiAySUAjxFujXrx+JiYlER0fne4vWl+nq6rJ69WoiIyPR09OjSZMmbNq0iapVqxbCaHP26NEjevTowQcffFAo/ZXknTFKAolPziRGQgiRNZnyJIR468ml9MzJVIOcSYyyJ/HJmcQoexKfnL0JU55k21ghhBBCCCFEvklCIYQQQgghhMg3SSiEEEIIIYQQ+SYJhRBCCCGEECLfJKEQQgghhBBC5JskFEIIIYQQQoh8k/tQCCHeernd9u5dkxEXiU/WSmqM5KZ4QoiSRBIKIUS+BQQEEBwcTFhYWHEPJUsqlQpTU6PiHkaJJvHJWUmLkVKZTmxskiQVQogSQRIKIcRbTUdHh0XbLhAemVDcQxGiUFhWNsG7vyO6ujqSUAghSgRJKIQQRSY5ORlDQ8PiHgbhkQnciogr7mEIIYQQb6WSNSlUCPHGCg8PR6FQsHPnTmbOnEnz5s3p3bs3ALGxsUyfPp3mzZtja2tL3759OXfunEZ7T09PRo4cSWhoKB4eHtjb2zNw4EDu3r1bHKcjhBBCiFySKxRCiEK1ZMkSXFxcWLx4Menp6SiVSoYPH869e/fw9vbGwsKCLVu2MGTIELZv307jxo3Vba9du0Z0dDTe3t4olUr8/PyYMmUKO3bsKMYzEkIIIUR2JKEQQhQqa2trvvrqK/Xjw4cPc/nyZdavX0+bNm0AcHZ2pmPHjgQFBREQEKCum5CQwO7duzE3NwcgKSmJ6dOn8/DhQ6pUqfJ6T0SIEq4k7DxVUnfBKkkkRtmT+OTsTYiRJBRCiELl6uqq8fj8+fMYGxurkwkAfX19OnToQEhIiEZda2trdTIBUK9ePQBJKITIREnaeaokjaWkkhhlT+KTs5IcI0kohBCFqkKFChqP4+PjtcoALCwsiIvTXChtamqq8VhfXx+AlJSUQh6lEG+++PhnKJXpxToGPT1dTE2NSsRYSiqJUfYkPjkrrhiZmhrl+qqIJBRCiEKlo6Oj8bhcuXJERUVp1Xvy5AnlypV7XcMS4q2jVKaTllYyPoCVpLGUVBKj7El8claSY1RyJ2MJId4Kjo6OJCYm8ttvv6nL0tLSOHToEI6OjsU4MiGEEEIUBrlCIYQoUq6urtja2jJlyhQmT56s3uXp0aNHrFixoriHJ4QQQogCkoRCCFGk9PT0WLt2Lf7+/ixcuJCkpCQaNWpEcHCwxpaxRcmysslrOY4Qr4O8n4UQJY2OSqVSFfcghBCiqKhUKq11HUK86ZTKdGJjk0hPL97/wkuV0qV8+bLExDwtsXO7i5vEKHsSn5wVV4zMzcvKomwhhIAXi8Rl95DMye4qOSupMUpPVxV7MiGEEBkkoRBCvPVK8s4YJYHEJ2cSIyGEyJrs8iSEEEIIIYTIN0kohBBCCCGEEPkmCYUQQgghhBAi3yShEEIIIYQQQuSbJBRCCCGEEEKIfJOEQgghhBBCCJFvklAIIYQQQggh8k3uQyGEeOvl9k6f75qMuEh8svYuxEhukieEKKh3JqEICAggMDCQSpUqcfz4cXR1Nf9z6Nu3L2FhYfTo0QM/P79c9xseHk67du1Yvnw5nTp1KuxhZ2v06NEkJCSwZcsW4MU5BgcHExYW9lrHUVBnzpxh4MCB/Pjjj9jY2BT3cDT4+/uzZ88enjx5gqenJzNmzCiWcTRt2pRBgwYxbty4XLcpivfm+PHjqV69OtOmTSuU/rJz4cIFRo8ezeHDhzE2Ns53PyqVClNTo0Ic2dtH4pOztzlGSmU6sbFJklQIIfLtnUkoAPT19YmJieHcuXM0b95cXR4REcGff/5JmTJl8txnpUqV2LFjB7Vq1SrEkeZP7969cXFxKe5h5FmjRo3YsWMHdevWLe6haDh16hTffPMN06dPp0mTJlSqVKm4h1Ss/vrrL44ePcqhQ4dey/EcHR2pX78+wcHBjB8/Pt/96OjosGjbBcIjEwpxdEK8HSwrm+Dd3xFdXR1JKIQQ+fbOJRQtW7Zk3759GgnFvn37qF+/vtZVi9wwMDDAzs6uUMaXnJyMoaFhvttXqVKFKlWqFMpYXidjY+NCi2Fhun37NgADBw7M13vjbbN582acnZ2pXLnyaztmr169WLBgAZ9++in6+vr57ic8MoFbEXGFODIhhBBCZHjnPiV17dqVAwcOkJqaqi4LCQmha9euWnVv3brFxIkTcXFxoUmTJnTu3Jng4GDS09PVdcLDw1EoFISGhqrL0tPTWbVqFe7u7jRu3JhOnTqxfft2jb4DAgKwt7fn8uXLfPzxx9jY2LBt27Ysx33r1i0GDBiAjY0N7du3Z9euXVp1MvrMcObMGRQKBSdPnmTChAnY29vj6urK3r17gRcfEF1dXWnWrBkzZszg+fPnGv09fPgQb29vmjdvjq2tLf379+fq1asaddzd3Zk7dy7btm3Dzc0NR0dHRo8eTXR0tLpOamoqCxYswNXVlcaNG+Ps7MyoUaNISEjQGOeVK1fUbVJSUpg/fz7Ozs7Y2NjQvXt3Dh48qHFsHx8funbtypkzZ/jwww+xs7OjV69eWmPMTGxsLNOnT1efW9++fTl37pz6eU9PT+bNmwdAgwYNUCgUnDlzJtO+MuJ+48YN+vXrR5MmTejatSsnT57UqJeb9wXAoUOH6NSpEzY2NvTq1YvLly9r1cmI+6vtFAoF4eHh2Z77zp076datGzY2NrRp04alS5eiVCqzbZOUlMSvv/6Kh4eH1nNhYWEMHToUBwcH7O3t6d27N7///jvwf78fu3fvxtfXl6ZNm9KyZUs2bNgAvEjmPTw8cHBwYOzYscTHx2v03b59exISEjh+/Hi24xNCCCFE8XnnEgo3NzeeP3+u/sDzzz//cOPGDTp37qxV99GjR9SuXZtZs2axdu1a+vTpw8qVK1m1alW2x/D39ycwMJAePXqwZs0anJ2dmTVrFlu3btWol5qayuTJk/nggw9Yt24drVu3zrS/lJQUhg4dypMnT/D392fy5MmsXbtW4wN4dmbPnk39+vUJDAykSZMmTJ06lYULF/Lbb78xZ84cxo8fz88//0xwcLC6TVxcHJ988gnXr1/niy++ICAgACMjIwYNGkRUVJRG/0eOHOHIkSP4+voyY8YMzp07p/4wDhAUFMT27dsZPnw4wcHBfPHFF1SqVEkrgXmZt7c3O3bsYNiwYaxcuZJ69eoxbtw4Dh8+rFHv8ePHfPnll3h5ebFs2TJSUlIYO3asRsL4KqVSyfDhwzl69Cje3t4sX76cMmXKMGTIEHUyMmvWLAYNGgTAjh072LFjB40aNcqyz9TUVLy9venZsyeBgYGYm5szfvx4YmJi1HVy8764du0a48ePp1atWuq6n332WbaxyosNGzYwc+ZMnJ2dWbNmDcOHD2fz5s0sXbo023Z//vknSUlJODo6apRfuHABT09Pnj9/zpdffklAQADt2rXj/v37GvWWLVuGoaGhej2Hn58fixcvZvPmzUyZMgVfX1/++OMPFi5cqNHO2NiYevXqcerUqUI5fyGEEEIUvndqyhOAkZER7u7u7Nu3D1dXV0JCQrC3t6dGjRpadVu2bEnLli2BFws7HR0dSU5OZuvWrYwdOzbT/qOjo9m6dSteXl7qBbTOzs7ExMSwcuVK+vXrh56eHvDiQ+jEiRMzTWZetnPnTh49esT+/fvVazUaNmxIp06dcrV2o1OnTurx2tracvDgQfbt28fBgwfV00jOnj1LaGgoo0aNAmDTpk3Ex8fzww8/UKFCBXU8PDw8+Oabb5g6daq6f5VKxerVqzEwMABerEkJCgoiPT0dXV1drly5grOzM/3791e3yeyb7gzXr1/n119/Zc6cOfTt2xeAtm3bEhERwcqVK2nXrp26blxcHFu3bqV+/frAi9d34MCBXLp0iaZNm2ba/7Fjx7h8+TLr16+nTZs2wIvXqGPHjgQFBREQEEC9evWoVq0aQK6mY2UkFBlrWGrXrk27du04ceIE3bt3z/X7Yu3atVStWpWVK1eq3yelS5culMXgiYmJrFixgmHDhjFp0iQAWrdujb6+Pn5+fnh5eVG+fPlM2165coUyZcpo/Z4sXLiQ9957j02bNqnH6+zsrNXezs6Ozz//HIAWLVrw66+/snXrVo4cOaI+5o0bN/jxxx81klEAa2trLl26VLCTF0JkK7+7WL0Lu2AVlMQoexKfnL0JMXrnEgp4Me1p8uTJJCcn88svv+Dp6ZlpvZSUFIKCgti7dy8PHjzQ+Nb76dOnlC1bVqvN5cuXSU1N1dpV5/333yckJIR///1XY/FxbhZRX758mfr162skD++99x7W1tY5tgU0rnyYmJhgbm5O06ZNNeak16pVS2NKz++//07z5s0pV64caWlpAOjq6uLk5KR1ZcTJyUmdTADUrVuX1NRUoqKiqFixIg0bNuSbb74hICAAFxcXGjdunO2ahAsXLgBkGsP58+eTlJSkXkBfqVIldTIBUK9ePQAiIyOz7P/8+fMYGxurkwl4sb6mQ4cOhISEZNkuO7q6uurkE8DS0hJDQ0P1OHL7vrh06RLu7u7qD+fwIg6FkVCEhYWRlJREp06d1K8pQKtWrUhOTubmzZs0a9Ys07aPHz/WSjaePXvGpUuXmDRpksZ4M/Pye1BPT48aNWqgo6Oj0WetWrWIj4/X+t0qX748jx8/ztO5CiHypqC7WL3Nu2AVFolR9iQ+OSvJMXonEwpnZ2f09fVZvnw54eHhvP/++5nWW7hwIT/88ANjxoyhcePGmJiYcPjwYVavXk1KSkqmCUVc3IuFnxYWFhrlGY9jY2PVZUZGRpn28apHjx6prxK8rEKFCqSkpOTY3sTEROOxgYEBpqamGmX6+voa02piYmL4888/M53mU7NmTY3Hr/aVkVxkjO3TTz9FV1eXXbt2qacD9e/fnzFjxqCjo6PVf1xcHPr6+piZmWmUW1hYoFKpSEhIUCcUmZ3Hy8fOTHx8fKbxtLCwUL9+eWVoaKiRVGWMJWMcuX1fPH78WGtsxsbGlC5dOl/jelnG9KsePXpk+vyDBw+ybJuSkqJ1fvHx8aSnp+dq96tX34P6+vpau6q9/Nq9/HthYGCQq/e5ECL/4uOfoVSm51zxFXp6upiaGuW7/btAYpQ9iU/OiitGpqZGub4q8k4mFPr6+nTs2JGNGzfSsmVLrQ95GUJDQ/n4448ZMWKEuiynxaEZH4KjoqI0dsN58uSJxvNAph+mM1OpUiX++usvrfKoqKgC7c+fnXLlytGmTRsmTJig9dyrHyxzYmBgwLhx4xg3bhz//fcfP/30EwEBAVhaWvLhhx9meuzU1FTi4uIoV66cuvzJkyfo6OhofTjNq3LlymmtA8no/+XjFabcvi8qVqyoNbbExEStD9QGBgZa60RySoYyzi0wMDDT3cAsLS2zbZuxiD6DiYkJurq6PHr0KNvjFlR8fLxWcimEKFxKZTppafn/oFLQ9u8CiVH2JD45K8kxKrmTsYpY7969cXNzY+DAgVnWSUlJ0ZgWpFQq2bdvX7b92tjYoK+vr7HrE8D+/fupUKFCvu5XYWNjw82bN/nvv//UZf/99x/Xr1/Pc1+51apVK27dukXdunWxsbHR+FEoFPnu97333mPSpEmYmZmpt2V9VcbC31djGBoaSsOGDfN1v5BX+09MTOS3335Tl6WlpXHo0CGtRceFJbfvC1tbW44ePaqx69KrbeDFFsG3bt3SKMvYaCAr9vb2GBkZ8fDhQ63X1MbGJsv1E/BiTUh0dDRJSUnqsjJlymBnZ8fPP/+c4y5RBREREUHt2rWLrH8hhBBCFMw7eYUCXnxwy2m3platWvHDDz9Qr149ypcvz7fffpvjbjvm5uYMGDCAb775Rn2PiuPHjxMSEsIXX3yR41zzzPTs2ZPVq1czcuRI9RWDFStWZHllpTAMHjyYvXv3MmDAAAYOHEi1atWIjo7m0qVLVK5cmcGDB+e6r9GjR9OoUSMaNmyIkZERR48eJS4ujhYtWmRa39ramo4dO+Ln50dycjK1a9dmz549hIWF5fia5Yarqyu2trZMmTKFyZMnY2FhwZYtW3j06BErVqwocP+Zye37YsSIEfTq1YsxY8bQr18/wsPD+eabb7SmPHl4eDB79mwCAwOxt7fn+PHj/Pnnn9mOwdTUlPHjx7Nw4UIePnxIs2bN0NPT4969exw+fFi9k1dmHBwcSE9P5++//9ZY7D558mQGDx7M4MGD+eSTTyhXrhx//fUX5cuXp1evXgUL2v939epVhgwZUih9CSGEEKLwvbMJRW588cUXzJo1i3nz5mFkZESPHj3o0KEDM2fO1Kr78vSlqVOnYmJiwo8//siaNWuoXr26xo5FeWVoaEhwcDCzZ89mypQpVK5cmdGjR3P48GGtaSiFpXz58uzYsYNly5axaNEiYmNjqVChAk2aNKFDhw556svBwYH9+/ezYcMGlEoltWvXZtGiRbRq1SrLNgsXLmTJkiWsW7eO2NhY6tSpw4oVK3B3dy/oqal3U/L392fhwoUkJSXRqFEjgoODady4cYH7z0pu3hcNGzZk+fLlLFq0iLFjx1K/fn2WLl2Kl5eXRl+9e/fm7t27fPfdd2zcuJHOnTszadIkJk+enO0Yhg4dSuXKldmwYQNbt26lVKlS1KxZE1dX12xvHFe7dm2srKw4efKkRkLRtGlTNm/ezLJly5g+fTq6urrUr1+fzz77LH9BesVff/1FdHR0truC5YZl5YJNkxPibSW/G0KIwqCjUqlUxT2IN9mNGzf44IMP2LRpU5bfuAvxNtiyZQubN2/m119/zfX6n4JasGABf/31F5s3b853HyqV6rWNV4g3kVKZTmxsEunpef84UKqULuXLlyUm5mmJndtd3CRG2ZP45Ky4YmRuXlYWZb8Of//9N1u3bqV06dJYWVkV93CEKFK9e/dm7dq1HDlyRONeIEUlMTGRH3/8scDT3HR0dGT3kCzI7io5exdilJ6uylcyIYQQGSShKIAZM2YQFxfH3LlzMTc3L+7hCFGkDA0N8fPzK7Jpdq+6f/8+EyZMwMnJqcB9leSdMUoCiU/OJEZCCJE1SSgKYNeuXcU9BCFeq5dvUFfUrKys5MqfEEII8QZ4Z7eNFUIIIYQQQhScJBRCCCGEEEKIfJOEQgghhBBCCJFvklAIIYQQQggh8k0SCiGEEEIIIUS+SUIhhBBCCCGEyDfZNlYI8dbL7Z0+3zUZcZH4ZE1i9H/kBnhCiKxIQiHeeB988AE3btxg27ZtNG3atLiHk6mdO3eir69Pt27d8tX+0KFDjBkzhsOHD2NpaUl4eDjt2rVj+fLldOrUqZBH+3p5enpSpkwZgoKCiqR/lUqFqalRkfT9tpD45Exi9OLmfrGxSZJUCCG0SEIh3mg3b97kxo0bAOzdu7fEJhS7du2iTJky+U4oXlWpUiV27NhBrVq1CqW/4jRr1ix0dYvu218dHR0WbbtAeOTrucO3EG8jy8omePd3RFdXRxIKIYQWSSjEG23v3r3o6uri5OREaGgoM2fORF9fv7iHVeQMDAyws7Mr7mEUinr16hX5McIjE7gVEVfkxxFCCCHeRTIpVLyxVCoVISEhtGjRgiFDhhAbG8vJkye16t28eZP+/ftjY2NDx44d2bNnD6NHj8bT01Oj3q1bt/j0009xdHTEzs6OESNGcPfu3RzHsWjRIrp164a9vT1t2rRh0qRJPHr0SP28p6cnZ8+e5dixYygUChQKBQEBAVn2l5qayldffUWzZs1wdHTk888/5+nTpxp1wsPDUSgUhIaGqst2795Nv379aNasGU5OTnh6enL58mWt/g8ePIiHhwc2Njb06dOHv/76i6ZNm2qMydPTk5EjRxIaGoqHhwf29vYMHDhQKx6xsbFMnz6d5s2bY2trS9++fTl37pxGnQsXLtC/f38cHR2xt7enW7du7Nq1S+tYGR4+fMiECRNo1aoVNjY2uLu78/XXX2cZLyGEEEIUL7lCId5YFy9eJCIigjFjxuDs7IyZmRkhISG4u7ur6yQnJzN06FBMTU1ZuHAhACtXriQ+Pp6aNWuq6927d4++fftSv359/Pz80NHRYc2aNQwePJjQ0FAMDAyyHEdUVBQjR46kUqVKREdHs2HDBjw9Pdm3bx+lSpVi1qxZTJkyBUNDQ6ZNmwZAlSpVsuxvyZIlfPfdd4wbN46GDRuyb98+Fi9enGM8wsPD+fDDD6lZsybPnz9n37599O/fnz179lC7dm0A/v77byZMmICbmxuff/45ERERTJw4kefPn2v1d+3aNaKjo/H29kapVOLn58eUKVPYsWMHAEqlkuHDh3Pv3j28vb2xsLBgy5YtDBkyhO3bt9O4cWMSExMZOXIkjo6OLFmyBAMDA/755x/i4+OzPI+pU6fy6NEjZs6cSYUKFXjw4AFXr17N8fyFEEIIUTwkoRBvrJCQEEqXLk3Hjh3R19fHw8ODPXv28PTpU8qWLQvATz/9RFRUFN999x2WlpYANG7cmI4dO2okFIGBgZQrV44NGzZQunRpABwcHGjXrh0//PAD/fv3z3Ic8+fPV/9bqVRib29P27Zt+eOPP3B2dqZevXoYGxtTpkyZHKcpxcbG8u233zJ8+HD1t/Zt2rRhwIABREZGZtt27Nix6n+np6fTunVrLl++zK5du5g0aRIAQUFBWFpaEhAQoF63ULZsWaZOnarVX0JCArt378bc3ByApKQkpk+fzsOHD6lSpQrHjh3j8uXLrF+/njZt2gDg7OxMx44dCQoKIiAggDt37pCQkMCkSZNQKBQAtGzZMtvzuHLlCpMmTaJz587qsg8//DDbNkKI1+PV3a5kF6ycSYyyJ/HJ2ZsQI0koxBspLS2N0NBQXFxcMDExAaBbt27s2LGDgwcPqj+AXr16FSsrK3UyAWBpaYm1tbVGf7///judO3dGT0+PtLQ0AExNTWnYsGGO344fP36c1atXc/PmTRITE9Xl//77L87Oznk6r//9738kJyfToUMHjfKOHTtqTSV61a1bt1iyZAlhYWFERUVpjCPDlStXaN++vcYi6Hbt2mXan7W1tTqZgP9b65CRUJw/fx5jY2N1MgGgr69Phw4dCAkJAaBmzZoYGxsze/ZsPD09adGihUafmWnYsCHBwcHo6enRunVr3nvvvWzrCyFen6x2u5JdsHImMcqexCdnJTlGklCIN9Lvv/9OdHQ0bm5u6ukzVlZWVKxYkZCQEHVC8ejRo0w/wJqbm5OSkqJ+HBMTw6ZNm9i0aZNW3ewWeV++fJnRo0fTrl07hg8fToUKFdDR0aFPnz4a/efW48ePAahQoYJGuYWFRbbtEhMTGTp0KObm5vj4+FCtWjVKly7NzJkzNcbx+PFjrXgYGxurr8q8zNTUVONxRhwy+ouPj9caZ8ZY4+JeLIDOuOqzYsUKpk6dilKppGnTpsycOVN9xeJVS5cuZenSpSxbtow5c+ZQu3ZtJk2aRMeOHbONgRCi6MXHP0OpTFc/1tPTxdTUSKtc/B+JUfYkPjkrrhiZmhrl+qqIJBTijbR3714Apk+fzvTp0zWei4mJISoqigoVKlCpUiWuXbum1T46Olo9LQpefPB1cXHhk08+0ar7cr1XHTp0CGNjY5YtW6b+1j8iIiJf5wRQsWJF4MW6jMqVK6vLnzx5km27P//8k4cPHxIUFKRx9SUhIUFjvUbFihWJjo7WaJuYmJiv5KdcuXIaV0JeHmu5cuXUj21tbVm/fj3JycmcOXOGBQsWMGbMGA4dOpRpv5UqVWL+/Pmkp6dz9epVVq9ezcSJEwkNDaVGjRp5HqcQovAolemkpWl/oMmqXPwfiVH2JD45K8kxKrmTsYTIwrNnzzh8+DDt27dn8+bNGj9LliwhLS2NX375BXixXuLGjRvcu3dP3T48PJzr169r9NmyZUtu3rxJw4YNsbGx0fipU6dOlmNJTk5GX18fHR0ddVlGsvMyfX39XH1ot7KywtDQkIMHD2qU//rrr9m2S05OVh8nQ8ai9ZfZ2Nhw7Ngx0tP/7w9SVh/sc+Lo6EhiYiK//fabuiwtLY1Dhw7h6OioVd/Q0BAXFxf69etHeHh4jvHQ1dXF1taWzz77jLS0NP777798jVMIIYQQRUuuUIg3zuHDh0lKSsLT05PmzZtrPb9+/XpCQkLw9PTko48+Ys2aNYwaNYpx48YBLxZgW1hYaCQB48ePp1evXnh5edGnTx8sLCx48uQJZ8+epWnTpnTt2jXTsbRu3ZpNmzYxb948OnToQFhYGD///LNWvTp16rB7926OHDlCxYoVqVSpksYViAxmZmb07duXdevWYWhoqN7lKafta+3s7ChTpgxz5sxhxIgRREZGEhAQoHWMkSNH0qtXL8aNG0efPn24f/8+wcHBlC5dWiMeueHq6oqtrS1Tpkxh8uTJ6l2eHj16xIoVKwA4duwYP/74I+3bt6datWo8efKErVu34uDgkOk0q4SEBLy8vOjevTu1a9cmNTWVLVu2qNezCCGEEKLkkYRCvHFCQkKoVq1apskEvNgR6Ouvv+bu3bvUrFmT4OBgZs2ahbe3N5UrV2b06NHs3r1bvZgb4L333uOHH35Qz9tPSkqiYsWKODk5ZTnXH8DFxQVvb2+2bt3Kzp07cXBwICgoCA8PD416w4cP5+7du0ybNo34+HjGjh2rTnBeNXnyZJRKJevXryc9PZ0OHTowefLkTHdiymBhYcHy5cvx9/dn9OjR1KpVizlz5rB+/XqNeg0bNmTZsmUsXryYsWPHqrfJHThwoEY8ckNPT4+1a9fi7+/PwoULSUpKolGjRgQHB9O4cWPgxaJsXV1dli1bRlRUFGZmZjg7O6t3nXpV6dKlsbKyYsuWLTx48ABDQ0MaN27MN998k+Ni7uxYVs7buQkhNMnvkBAiOzoqlUpV3IMQ4nWKjY2lffv2DB48WGOr1XfV6dOnGTx4MFu2bKFZs2bFPZxCp1Kp8nz1RQihTalMJzY2ifT0//vYUKqULuXLlyUm5mmJndtd3CRG2ZP45Ky4YmRuXlYWZQuRYe3atVhYWFC9enUeP35McHAwSqWSjz76qLiHVixmz55Ny5YtMTMz459//mHVqlU0bNiQpk2bFvfQioSOjo7sHpIF2V0lZxKj/5OertJIJoQQIoMkFOKtp6ury+rVq4mMjERPT48mTZqwadMmqlatWtxDKxbx8fHMmzeP2NhY9X0kpk2bpnFvirdNSd4ZoySQ+ORMYiSEEFmTKU9CiLeeXErPnEw1yJnEKHsSn5xJjLIn8cnZmzDl6e39SlIIIYQQQghR5CShEEIIIYQQQuSbJBRCCCGEEEKIfJOEQgghhBBCCJFvklAIIYQQQggh8k0SCiGEEEIIIUS+yX0ohBBvvdxue/euyYiLxCdrEqPs5Tc+cpM8Id4uklCIQhcQEEBwcDBhYWF5eu5tcebMGQYOHMiPP/6IjY1Nrtv5+Phw9epVQkJCsq3n7u6Oq6srvr6+BR0qAMeOHcPX15dDhw5hYGCQ5/Z37tyhU6dOHD16lGrVqmVap3v37jRo0AA/Pz8g5/dBeHg4Xbt2JSQkBEtLyzyP6WUqlQpTU6MC9fG2k/jkTGKUvbzGR6lMJzY2SZIKId4SklAI8YYJDAzE1NS0UPpSqVQsXbqUwYMH5yuZADh69CgKhSLLZCI/LC0t8fDwICAggAULFhSoLx0dHRZtu0B4ZEIhjU4IURCWlU3w7u+Irq6OJBRCvCUkoRDiDdOwYcNC6+vMmTPcvHmTDz/8MN99HD16FDc3t0IbU4ZevXoxZMgQpk2bhrm5eYH6Co9M4FZEXCGNTAghhBAvk0mhotgtWrSIbt26YW9vT5s2bZg0aRKPHj3Sqnfs2DF69+6Nra0tLVq0YNasWSQlJamfP3PmDAqFgpMnTzJhwgTs7e1xdXVl7969AGzevBlXV1eaNWvGjBkzeP78uUb/N27cwMvLCzs7OxwdHRk/fjz379/XqJOQkIC3tzf29va0bNmSJUuWEBwcjEKhyPYcU1JSmD9/Ps7OztjY2NC9e3cOHjyYad3jx4/TtWtXbGxs6NmzJ3/++afG8+7u7sydO1f92MfHh65du3LmzBk+/PBD7Ozs6NWrF1evXs12TAC7d+/GyclJ6wP7zZs36d+/PzY2NnTs2JE9e/YwevRoPD09NerFx8dz8eJFjYTi4sWL9OzZExsbG7p27crx48dzHEdmHB0dMTMzU79+QgghhCiZJKEQRSYtLU3rJz09XateVFQUI0eOJCgoiBkzZhAREYGnpydpaWnqOqGhoXz66adYWVkRGBjIlClTOHjwIDNmzNDqb/bs2dSvX5/AwECaNGnC1KlTWbhwIb/99htz5sxh/Pjx/PzzzwQHB6vbPHjwgAEDBhATE8PChQuZM2cOf/31FwMGDCAxMVFdb/r06Rw7dowpU6bg5+fHrVu32Lx5c46x8Pb2ZseOHQwbNoyVK1dSr149xo0bx+HDhzXqPX78mDlz5uDl5cWyZcswMDDAy8uLqKiobPt//PgxX375pbpdSkoKY8eOJTU1Ndt2p06dwsHBQaMsOTmZoUOHEhsby8KFC5k0aRLr1q3jr7/+0mp/8uRJypUrh62trXocXl5eGBgYsGzZMry8vJgzZw6RkZE5xuhVurq6NGnShFOnTuW5rRBCCCFeH5nyJIpEUlISjRo1yvS5MmXKaDyeP3+++t9KpRJ7e3vatm3LH3/8gbOzMyqVCn9/fzp37sxXX32lrluxYkVGjBjB6NGjqV+/vrq8U6dOjB07FgBbW1sOHjzIvn37OHjwIPr6+gCcPXuW0NBQRo0aBcDGjRtJS0sjODgYMzMzABo0aECXLl3YtWsXnp6e/PPPPxw8eJAFCxaopwi1adOG999/P9tYXL9+nV9//ZU5c+bQt29fANq2bUtERAQrV66kXbt26rqxsbEsW7aMli1bAtCsWTNcXFzYuHEjkydPzvIYcXFxbN26VR0HIyMjBg4cyKVLl2jatGmmbR49ekRkZKTW1ZWffvqJqKgovvvuO/WC6MaNG9OxY0dq1qypUffo0aO0bdsWXd0X301s2rQJHR0d1q1bh4mJCQBVqlRh8ODB2cYoK9bW1mzbti1fbYUQJdu7snOW7BSWPYlPzt6EGElCIYqEoaEhW7du1Sr//vvvtXYxOn78OKtXr+bmzZsaVwP+/fdfnJ2duXPnDhEREXz++ecaVy2aNWuGrq4uV69e1UgoWrdurf63iYkJ5ubmNG3aVJ1MANSqVYszZ86oH58/f57mzZurkwmAunXrYm1tzYULF/D09OTKlSsAGgmArq4ubm5ubNiwIctYXLhwAXiR6Lzs/fffZ/78+SQlJamTLBMTE3UykfG4VatWXLp0Kcv+ASpVqqQRg3r16gFke2Xg8ePHAFrTna5evYqVlZXG7kqWlpZYW1tr1FMqlZw8eVJj+tWlS5do3ry5OpkAaNmypUZc86J8+fLExMSQmpqq8foJId5879rOWe/a+eaVxCdnJTlGklCIIqGrq5vplqnHjh3TeHz58mVGjx5Nu3btGD58OBUqVEBHR4c+ffqQkpICQExMDABjxozJ9FgPHjzQePzyh1kAAwMDrV2R9PX1NdZQxMfH06BBA62+K1SoQFzci8W8jx8/Rl9fX6v/nBYMx8XFoa+vr/Wh2sLCApVKRUJCgjqhyKyvChUqcOvWrWyPkdn5AeoYZibjuVd3d3r06FGm4zA3N9foLywsjKdPn2okcI8fP+a9997LtG1+ZIwtJSVFEgoh3jLx8c9QKrWnwb5t9PR0MTU1emfON68kPjkrrhiZmhrl+qqIJBSiWB06dAhjY2OWLVumnjYTERGhUSfjg7ivr696rv7LKlWqVOBxlCtXLtN1ClFRUdSqVQt4McUqNTWVhIQEjaQiOjo6x75TU1OJi4ujXLly6vInT56go6OTY19RUVFUrFgxr6eUo4yxxMfHa5RXqlSJa9euadWPjo6mbNmy6sdHjx7FyckJY2NjdVnFihUzjWNOMcpKfHw8+vr6GscQQrwdlMp00tLenQ+Q79r55pXEJ2clOUYldzKWeCckJyejr6+Pjo6OuuzVXX3q1KlDlSpVuHfvHjY2Nlo/lStXLvA4HB0d+eOPP9RXIwBu377NjRs3cHR0BF6sIwA0FlKnp6dz9OjRHPuGFwvLXxYaGkrDhg011pQkJCRw+vRpjcenTp2iSZMm+TyzrFlaWqKvr094eLhGeePGjblx4wb37t1Tl4WHh3P9+nWNeseOHdPaLtbW1pYzZ86QkPB/93w4ffo0sbGx+RpjREQEtWvXzldbIYQQQrwecoVCFKvWrVuzadMm5s2bR4cOHQgLC+Pnn3/WqKOjo4OPjw/e3t4kJSXh6uqKkZER9+/f5/jx40ycOLHAHzoHDx7Mzp07GTp0KJ9++ikpKSksW7aMqlWr0qNHDwDq169Phw4d+PLLL3n27BnVqlXj+++/Jzk5WSMhepW1tTUdO3bEz8+P5ORkateuzZ49ewgLC2PVqlUadc3MzJgxYwbjx4/HxMSEdevWoVKpGDRoUIHOLzOlS5emcePGWrs3ffTRR6xZs4ZRo0Yxbtw44MXN9CwsLNTnee/ePf755x+thGLQoEF8++23DB8+nOHDhxMfH09AQECmayiUSqVWkgUvkpKMm+RdvXpVnZAJIYQQomSShEIUKxcXF7y9vdm6dSs7d+7EwcGBoKAgPDw8NOq9//77mJqasmbNGvUVjOrVq9OmTRssLCwKPI6qVauyZcsW/P398fb2RldXl9atW+Pj46Mx3ebrr79m7ty5+Pv7Y2BgQI8ePahfv36OOxEtXLiQJUuWsG7dOmJjY6lTpw4rVqzA3d1do17FihXx9vbG39+fu3fvUr9+fb755ptCOcfMeHh4sHHjRlQqlTpZMDQ0JDg4mFmzZuHt7U3lypUZPXo0u3fvVk/POnr0KHXr1qVGjRoa/VWqVIl169bx5ZdfMmHCBGrWrImvry9Lly7VOnZKSgoTJkzQKvf396d79+5ERUXx119/MWnSpAKfp2Vlk5wrCSFeC/l9FOLto6NSqeS+90IUQP/+/dHV1WXLli3FPZQ8i46OxsXFheDgYJycnLKsFxsbS/v27Rk8eDBjx45l6NChWFtbM3Xq1CIb27Zt29i4cSO//vprtleAcvJysiSEKBmUynRiY5NIT3/7P4KUKqVL+fJliYl5WmLnvxcniU/OiitG5uZlZVG2EEXhwIEDPHjwACsrK549e0ZISAjnz59n5cqVxT20fDE3N6dfv35s2rRJI6FYu3YtFhYWVK9encePHxMcHIxSqeSjjz4C0LgpYFFIT09n8+bNjBkzpsDJgI6OjuwekgXZXSVnEqPs5Tc+6emqdyKZEOJdIQmFEHlQpkwZfv75Z/79919SU1OpU6cOCxcupH379sU9tHwbNWoU3377Lc+fP1dv06qrq8vq1auJjIxET0+PJk2asGnTJqpWrfpaxvTo0SN69OjBBx98UCj9leSdMUoCiU/OJEbZk/gI8W6TKU9CiLeeXErPnEw1yJnEKHsSn5xJjLIn8cnZmzDlSbaNFUIIIYQQQuSbJBRCCCGEEEKIfJOEQgghhBBCCJFvklAIIYQQQggh8k0SCiGEEEIIIUS+SUIhhBBCCCGEyDdJKIQQQgghhBD5Jje2E2+lgIAAAgMDtcrr169PSEhIkR3X09OTMmXKEBQUBMCZM2cICwtj1KhRWuMLDg4mLCysUI6bkpJCx44dmTNnDq6uroXSZ2bu3LlDp06dOHr0KNWqVct3Pzt37mT69OmcPn0ac3NzrecTExNxd3dn9erVODo6FmTIALneR/tdkxEXiU/WJEbZK2nxkTtwC1E8JKEQby1DQ0M2bdqkVVaUZs2aha7u//3HevbsWYKDg7USit69e+Pi4lJox/3uu+8wNTUt0mQC4OjRoygUigIlE7lhbGzMgAEDWLp0KVu3bi1QXyqVClNTo0Ia2dtJ4pMziVH2Skp8lMp0YmOTJKkQ4jWThEK8tXR1dbGzsyvUPpOTkzNNSjLK69Wrl6t+qlSpQpUqVQplTCqVis2bNzNw4MBC6S87R48exc3NrciPA/DRRx+xcuVKrl+/jrW1db770dHRYdG2C4RHJhTi6IQQJY1lZRO8+zuiq6sjCYUQr5kkFOKddezYMVauXMmNGzcoU6YMHh4eTJs2jTJlygAvpisNHDiQoKAgdu7cyW+//YaTkxNffPEF7dq1Y/78+Vy8eJGDBw9SqVIl9u7dqzHl6eVpVwqFAoBmzZqxZcsWrSlPGccKDg5m586dHDlyBDMzMz755BOGDx+e7XmcPXuWiIgIPDw8NMrd3d1xdXWlbt26rF+/nvj4eJo3b86XX36pMc3o5s2bzJ49m8uXL1O1alXGjh1LaGgoCQkJbNmyRV0vPj6eixcvMnnyZOD/pi39+OOPLF26lAsXLlClShVmzZpFixYtWL58OT/88APwIjmYOHGixtWbnFSvXh1bW1t27tzJ559/nut2mQmPTOBWRFyB+hBCCCFE5iShEG+1tLQ0jcd6enro6OgQGhrKxIkT6dmzJ+PGjePx48csXryY+Ph4li5dqtHmiy++4IMPPmDlypUaH4iXLFmCi4sLixcvJj09XevYvXv35uHDh4SEhKinXhkbG2c73lmzZtG9e3dWrlzJoUOHWLRoEQqFgrZt22bZ5tSpU1StWpWqVatqPXfkyBH+++8/fH19iYmJYf78+cybN099jsnJyQwdOhRTU1MWLlwIwMqVK4mPj6dmzZoafZ08eZJy5cpha2urUT5t2jT69u3LkCFDWLt2LWPHjqVHjx4kJiayYMECLl26REBAAFZWVnTr1i3b83+Vvb09p06dylMbIYQQQrxeklCIt1ZSUhKNGjXSKPP39+eDDz7A39+fzp0789VXX6mfq1ixIiNGjGD06NHUr19fXe7u7s6UKVPUj8PDwwGwtrbWaP+qjGlNeZl61bFjR8aNGwdAy5YtOXbsGAcOHMg2obh69ar6CsirVCoVq1evxsDAAICIiAiCgoJIT09HV1eXn376iaioKL777jssLS0BaNy4MR07dtRKKI4ePUrbtm21rjIMGDCATz75BIDKlSvTrVs3rl69yo4dOwBo06YNR44cITQ0NM8JhbW1NZs3byYxMTHHZEwIIaDkLBDPUNIWrpc0Ep+cvQkxkoRCvLUMDQ21FvTWqFGDO3fuEBERweeff65xBaNZs2bo6upy9epVjYQiq4XORbEA2tnZWf1vHR0d6taty8OHD7Nt8+jRIxo3bpzpc05OTupkAqBu3bqkpqYSFRVFxYoVuXr1KlZWVupkAsDS0lJrzYJSqeTkyZPMnTtX6xitW7dW/7tWrVoAtGjRQqNO7dq1uXPnTrbnkZny5cujUqmIioqShEIIkSslZYH4q0rquEoKiU/OSnKMJKEQby1dXV1sbGy0ym/dugXAmDFjMm334MEDjccVKlTItF5W5QVhYmKi8VhfX5+EhOwXEz9//hx9ff1MnzM1NdV4nJFcpKSkAC+Skcy2bTU3N1fXAQgLC+Pp06cayUNmY87o/9Xj6uvr8/z582zPIzMZ/SUnJ+e5rRDi3RQf/wylUnsaanHR09PF1NSoxI2rpJD45Ky4YmRqapTrqyKSUIh3jpmZGQC+vr5a6wEAKlWqpPFYR0cn036yKn/dypUrl2PSkZVKlSpx7do1rfLo6GjKli2rfnz06FGcnJxe+1WC+Ph44P9eMyGEyIlSmU5aWsn7YFpSx1VSSHxyVpJjJAmFeOfUqVOHKlWqcO/ePfr371+kx8rvN/N5Ubt2bW7fvp2vto0bN2b37t3cu3ePGjVqAC/WiFy/fl3jhnLHjh3j448/LpTx5kVERAQmJiZUrFjxtR9bCCGEELkjCYV45+jo6ODj44O3tzdJSUm4urpiZGTE/fv3OX78OBMnTqR27dqFcqy6deuSlpbGpk2bsLe3x9jYmDp16hRK3xkcHBzYv38/qampWU59yspHH33EmjVrGDVqlHoxeGBgIBYWFuorMPfu3eOff/4pkvtPHD16VONKCLy4m3ndunWBFwvO7e3t87TdrBBCCCFeL0koxDvp/fffx9TUlDVr1rB3717gxX0P2rRpg4WFRaEdx83NjU8++YS1a9cSFRWFk5OTxr0dCkO7du2YO3cuZ8+ezXSNQ3YMDQ0JDg5m1qxZeHt7U7lyZUaPHs3u3bvVayOOHj1K3bp11VcwClNm95eYMGECo0ePJjU1ldOnT2vssJVflpVNcq4khHijye+5EMVHR6VSye0khXjDjRs3DmNjY+bPn1/gvmJjY2nfvj2DBw9m7NixDB06FGtra6ZOnVoII829Y8eOMXnyZE6cOKF1FSMvVCpViVnvIoQoWkplOrGxSSXqTtmlSulSvnxZYmKeltj578VJ4pOz4oqRuXlZWZQtxLtk9OjR9OvXj8mTJ+f5CsvatWuxsLCgevXqPH78mODgYJRKJR999BEAwcHBRTHkHAUHBzNkyJACJRPwYoqb7B6SOdldJWcSo+yVtPikp6tKVDIhxLtCEgoh3gINGjTg888/58GDB3lOKHR1dVm9ejWRkZHo6enRpEkTNm3alOmdt1+Xp0+f0qxZMwYPHlwo/ZXknTFKAolPziRG2ZP4CPFukylPQoi3nlxKz5xMNciZxCh7Ep+cSYyyJ/HJ2Zsw5Um2ThFCCCGEEELkmyQUQgghhBBCiHyThEIIIYQQQgiRb5JQCCGEEEIIIfJNEgohhBBCCCFEvklCIYQQQgghhMg3SSiEEEIIIYQQ+SYJRQnywQcfoFAoOH/+vNZzZ86cQaFQcOXKFXWZQqHgm2++KfBxX+3H09OTkSNHFrjfwlYSx1VYrwFAQEAAFy9eLJS+Ctu2bdvUd84G2LlzJwqFgujoaK26hw4dQqFQEB4ervVc3759WblyJQDu7u7MnTs3y2OuXr2aIUOGFMLoX9zNt1Qp+Xn1J2N/cYmPxEjik/cfXV2dQvn7JMTbQO6UXULcvHmTGzduALB3716aNm1abGOZNWsWurqSa75ugYGBlClTBgcHh+IeioZnz56xevVqvvjiiwL1Ex0dzaVLl/D19c1V/f79+7N+/Xr++OMPWrRoke/jqlQqTE2N8t3+XSDxyZnEKHvvYnyUynRiY5NIT5f7AwshCUUJsXfvXnR1dXFyciI0NJSZM2eir69fLGOpV69esRxXlEy//PILqamptGvXrkD9HD9+nIoVK9KwYcNc1Tc1NaVjx45s3ry5QAmFjo4Oi7ZdIDwyId99CCHEyywrm+Dd3xFdXR1JKIRAEooSQaVSERISQosWLRg4cCCjRo3i5MmTuLu756mfe/fuMWTIEGrVqkVgYCDx8fEsXbqUs2fP8vjxY6pUqUKnTp0YO3YsBgYGWfbj6elJmTJlCAoKAl5MxQkODmb79u3Mnj2bv//+mxo1ajBt2jTatGmj0Xbnzp1s2LCBf//9FzMzM3r27Mn48ePR09PL8ngZ/W/atIm5c+dy48YNLC0tmTp1Km5ublr1Q0NDWbp0KY8ePcLGxoYvv/ySmjVrqp+PjY1lwYIFHDlyhGfPntGwYUMmT56Mk5OTus6FCxdYsmQJ169fJz09HUtLS4YOHUqPHj00YvD+++8TGBjIo0ePaNKkCXPmzKFOnToa40lPTycgIIDvvvsOpVKJu7s7X3zxBWXKlAHg0aNHOb4OCoUCAH9/f/z9/QHYvHkzzZs3Jzg4mH379vHvv/9iYGCAra0tPj4+1K5dWz2Gmzdv4u/vz+XLl0lOTqZKlSr06tWL4cOHq+uEhYWxdOlSLl++jJ6eHq6urnz++edUqFAhy9cGYPfu3bRr145SpQr25+Lo0aO4urrmqU2nTp0YPXo00dHRmJub5/vY4ZEJ3IqIy3d7IYQQQmRN5rWUABcvXiQiIoKuXbvi7OyMmZkZISEheerj9u3b9O/fnwYNGrBq1SoMDQ2JiYnBzMyM6dOns379eoYNG8auXbuYNWtWnseYmpqKt7c3PXv2JDAwEHNzc8aPH09MTIy6zoYNG5g5cybOzs6sWbOG4cOHs3nzZpYuXZqr/idOnEiPHj0IDAzkvffeY+zYseppYBmuXbvGN998g7e3N/Pnz+fu3btMmTJF/bxSqWT48OEcPXoUb29vli9fTpkyZRgyZAhXr14FIDExkZEjR2JsbMySJUtYtWoVffr0IT4+XuNYf/31F0FBQUyePJkFCxbw6NEjhg0bxvPnzzXqbdu2jX///Rc/Pz/GjBnD3r17WbVqlfr53LwOO3bsAF4kMjt27GDHjh00atQIgIcPHzJgwABWrVrFl19+SXp6On379iU2NlbdftSoUcTHx/PVV18RFBSEl5cXz549Uz8fFhaGp6cnJiYmLF26lHnz5nHlyhVGjx6d7euSnJxMWFhYgadhpaam8ttvv2WaIGbH3t4epVLJ2bNnC3R8IYQQQhQduUJRAoSEhFC6dGk6duyIvr4+Hh4e7Nmzh6dPn1K2bNkc21+/fp2hQ4fi7OzM/Pnz1VcDFAoF06ZNU9dzcHDAyMgIHx8ffH19MTLK/ZzXjITCxcUFgNq1a9OuXTtOnDhB9+7dSUxMZMWKFQwbNoxJkyYB0Lp1a/T19fHz88PLy4vy5ctn2/+nn35Kr169AHB2dqZjx44EBQWxZMkSdb2EhAR2796t/rY6KSmJ6dOn8/DhQ6pUqcKxY8e4fPky69evV189ebmvgIAA7ty5Q0JCApMmTVJfGWjZsqXWmKKioti6dSu1atUCoGHDhnTq1ImdO3fSt29fdb2KFSuyePFiANq2bcvff//NgQMH8Pb2zvXrYGdnB0DVqlXV/87w+eefq/+tVCpp3bo1LVu25MCBA3z88cdER0cTHh7OjBkz1Fe1Xp0itHjxYho3bkxgYCA6Oi8WElpZWdG1a1eOHz+ufl1fde3aNVJTU9Vxyq9z586hVCozjXN2TE1NqVatGpcuXaJTp04FGoMQQhS2jEXpuamTm7rvIolPzt6EGElCUczS0tIIDQ3FxcUFExMTALp168aOHTs4ePAgH374Ybbtr1y5wpo1a+jcuTOzZ89Wf1iEF1OpNm3axPfff094eDgpKSnq5+7du4eVlVWux6mrq6vxYdDS0hJDQ0MiIyOBF9+AJyUl0alTJ9LS0tT1WrVqRXJyMjdv3qRZs2bZHqNDhw7qf+vp6dG+fXsOHTqkUcfa2lpj6kvGeo+MhOL8+fMYGxtrTMXS19enQ4cO6qs+NWvWxNjYmNmzZ+Pp6UmLFi0ynU5Tv359dTIB8N5772Ftbc2lS5c0EopWrVpptKtbty779u1TPy7o6/Dnn3+yfPly/v77b42rEv/++y8A5cuXp3r16ixZsoS4uDhatmxJlSpV1PWePXvGxYsXmTp1KkqlUl1eq1YtqlatypUrV7JMKB4/fgxQoOlG8GK6U8uWLTE0NMxzWzMzM/U4hBCiJMnLYvR3ceF6Xkh8claSYyQJRTH7/fffiY6Oxs3NTT3lxsrKiooVKxISEpJjQnH69GmePXtGr169NJIJgE2bNrFgwQKGDRtG8+bNMTU15cqVK8ydO1fjQ21uGBoaaq270NfXV/eTMfUpYw3Cqx48eJBt//r6+pQrV06jrEKFClofJE1NTbXaAepxxMfHZ7omwMLCgri4F3Poy5Urx4YNG1ixYoX6Q3bTpk2ZOXOmxjfxmfWT2zG9PC2qIK/D/fv3GTp0KI0bN2bOnDlUqlQJfX19Ro4cqW6ro6PDN998w9KlS5k7dy5JSUk0atSI6dOn4+TkRHx8PEqlkvnz5zN//nytY2T32mQc49XXPuMqWHp6ulabjKTl5U0Fjh07hpeXV7bnmhUDA4M8v1+FEOJ1iI9/hlKp/XfwZXp6upiaGuWq7rtI4pOz4oqRqalRrq+KSEJRzPbu3QvA9OnTmT59usZzMTExREVFZbto1svLi6tXrzJs2DA2b96s8YE4NDQUd3d3Jk+erC67detWIZ/BCxnJQGBgoMa34xksLS2zbZ+amkpcXJxGUhEVFUXFihXzPI6oqCit8idPnmj0bWtry/r160lOTubMmTMsWLCAMWPGaFwRyayfqKgorK2t8zSmgrwOJ0+eJCkpicDAQHXikpaWpk6OMtSuXZsVK1aQmppKWFgYS5YsYdSoUZw4cQITExN0dHQYOXIk7du31zpGdlPRMmIWHx+v8VpkXLF48uQJFhYWGm0ePXqErq4uZmZm6nO9e/duntdPZEhISKB+/fr5aiuEEEVJqUwnLS13H/DyUvddJPHJWUmOUcmdjPUOePbsGYcPH6Z9+/Zs3rxZ42fJkiWkpaXxyy+/ZNuHnp4eixcvxt7eniFDhnD79m31c8nJyVpbz2YkMIXN3t4eIyMjHj58iI2NjdZPdh9aMxw8eFD9b6VSyaFDh2jSpEmexuHo6EhiYiK//fabuiwtLY1Dhw7h6OioVd/Q0BAXFxf69eunNR3p5s2b/Pfff+rH//33H9evX8/zmHL7Orx8xefltjo6Oho7LO3fv19jWtmrfTRr1owRI0aQmJjIo0ePKFOmDHZ2dty+fTvT1ya7ZC9jJ6lXb1LXpEkTDAwMtKakwYsb29na2lK6dGngxXSnhg0bUrly5SyPk5X09HTu37+vsaOVEEIIIUoWuUJRjA4fPkxSUhKenp40b95c6/n169cTEhKCp6dntv3o6+uzYsUKRo0axeDBg9m2bRs1atSgVatWbN68Wb2weM+ePRofkAuTqakp48ePZ+HChTx8+JBmzZqhp6fHvXv3OHz4MAEBAdkuAtfX12f16tWkpKRgaWnJd999x8OHD9V3Vc4tV1dXbG1tmTJlCpMnT8bCwoItW7bw6NEjVqxYAbyYfvPjjz/Svn17qlWrxpMnT9i6dSsODg7qD8HwYnrTqFGjGD9+PADLly+ncuXK9OzZM09jyu3rUKdOHQ4fPkzTpk0xMjKidu3a6sXV06dPp2/fvty8eZMNGzZoTLO6fv06CxYsoHPnztSoUYPExESCgoKoXr26ejvdqVOnMmjQID777DO6dOmCqakpDx8+5NSpU/Ts2TPT9x9AjRo1qFixIn/99ZfGOgtTU1OGDh3KqlWrSEpKokWLFqSkpPDzzz9z9uxZ1q5dq66b3Xaxd+/eJTQ0VKNMV1eXjh07AnDnzh2SkpKK9UaPQgghhMieJBTFKCQkhGrVqmX5Ye7DDz/k66+/5u7duzn2ZWBgwMqVKxk+fDiDBg1i27ZtjBkzhpiYGPUHaQ8PD2bOnMmoUaMK9TwyDB06lMqVK7Nhwwa2bt1KqVKlqFmzJq6urjnepE9fX58lS5YwZ84c/ve//2FpacmKFSvyPL1IT0+PtWvX4u/vz8KFC9XrCYKDg2ncuDHwYlG2rq4uy5YtIyoqCjMzM5ydndW7U2Vo1KgRHTt2ZOHChTx+/Fh9H4rs7uGRmdy+Dr6+vnz99dcMHz6c5ORk9X0o5s+fT2BgICNHjqRBgwYsX76czz77TN2uYsWKWFhYEBQURGRkJCYmJjRt2pSFCxeq1zo4ODjw7bffEhAQwPTp00lNTaVKlSq0aNGC9957L9vxd+rUiRMnTmhtMfvZZ59RsWJFduzYwZYtWyhVqhSNGjVi3bp1ODs7AxAXF0dYWJjGLlcvO3nyJCdPntQo09PT4++//wbgxIkTVK9eHRsbmxyinD3LyiYFai+EEC+TvylCaNJRqVRyi0dRrDJubBcWFlbcQ1F79eZ+77Lr16/To0cPDh06RPXq1fPUdu/evfj5+fHbb79pbRqQGx999BFubm6MHTs2z20zqFSqfB1bCCGyo1SmExublOOdskuV0qV8+bLExDwtsfPfi5PEJ2fFFSNz87KyKFsIUTisra1xd3dn8+bNWhsH5KRbt25069YtX8c9d+4c9+7dY+DAgflqn0FHR0d2D8mC7K6SM4lR9t7l+KSnq3JMJoR4V0hCIYTI0ZQpUzh8+PBrPWZiYiILFizQ2pY3P0ryzhglgcQnZxKj7El8hHi3yZQnIcRbTy6lZ06mGuRMYpQ9iU/OJEbZk/jk7E2Y8iTbxgohhBBCCCHyTRIKIYQQQgghRL5JQiGEEEIIIYTIN0kohBBCCCGEEPkmCYUQQgghhBAi3yShEEIIIYQQQuSbJBRCCCGEEEKIfJMb2wkh3nq53Uf7XZMRF4lP1iRG2ZP45ExilL3XER+5q3nRkxvbCVFE9uzZw+bNm7lz5w4qlYrKlSvj4ODApEmTqFChQnEPTy08PJxdu3bRp08fKleuXNzDKXQqlQodHZ3iHoYQQohiolSmExub9MYmFW/Cje3kCoUQRWDdunUsXryYwYMHM378eFQqFTdv3mTv3r08evSoRCUUERERBAYG4urq+lYmFDo6OizadoHwyITiHooQQojXzLKyCd79HdHV1XljE4o3gSQUQhSBLVu20KNHD3x8fNRlLi4uDBs2jPT01/ftgnghPDKBWxFxxT0MIYQQ4q0kE/qEKALx8fFUqlQp0+d0dV/82vn5+eHq6qqVYBw/fhyFQsE///wDgLu7O3PnzmXjxo24uLhgb2+Pj48Pz58/59q1a/Tt2xc7Ozt69erFjRs3NPpSKBSsXbsWf39/WrRooW6bmJgIwJkzZxg4cCAAvXr1QqFQoFAo1O0jIiIYP348jo6O2NnZ4eXlpXWMgozvxx9/pEuXLtja2tK8eXP69evH5cuX8xpuIYQQQhQjuUIhRBFo1KgR27dvx9LSEldXVypWrKhVp3fv3mzYsIHff/+dNm3aqMt/+ukn7OzsqFevnrrs8OHD1K9fn7lz53Lv3j38/PzQ19fnzz//ZPDgwVhYWLBo0SImTJjAL7/8ok5a4MXVkkaNGrFgwQLCw8NZtGgRKSkpLF26lEaNGuHr68vcuXOZP38+derUUbdLTEzE09MTXV1d5syZQ+nSpVm9ejUDBgxgz549VK1atUDjO3fuHDNmzGDo0KG4uLiQnJzM5cuXSUiQqUlCCCHEm0QSCiGKwKxZsxg7diwzZ84EwNLSEjc3NwYPHoylpSUAdevWxdHRkZ9++kmdUMTExHDkyBF8fX21+ly1ahUGBgYAnD17lu+//55169bRtm1bANLT0xk1ahT/+9//sLa2VrczMDBg5cqV6OnpAVC6dGlmzpzJ2LFjqVu3rjpxqV+/PjY2Nup2O3fu5P79++zbt4+6desC4OTkhJubG5s2bdKYzpWf8V2+fBkzMzOmTZum7sPV1TU/4RZCCCGy9SbvsvUm7BQmCYUQRcDKyoqQkBBOnz7Nb7/9xrlz59iyZQs7d+5k27ZtNGjQAIA+ffrwxRdfEBsbi5mZGXv37kVfX5/OnTtr9Ofk5KT+sA5Qq1YtdHV1adGihUYZwIMHDzQSCjc3N3UyAdCpUydmzJjBlStX1IlCZs6fP0/9+vU16piZmdGqVSsuXLhQ4PE1bNiQ2NhYfHx86NatGw4ODhgZGWU5HiGEECK/TE3f/P9fSvI5SEIhRBExMDDAxcUFFxcXAE6ePMnIkSNZuXIlgYGBwIsP91999RV79uxh4MCB7Ny5Ew8PD4yNjTX6MjU11Xisr6+PoaGhxod4fX19AFJSUjTqvrqjlLGxMaVLl+bRo0fZjj8+Ph4LCwut8goVKnDz5s0Cj69ly5b4+/uzefNmvLy8KF26NB4eHnz++eeYmZllOzYhhBAiL+Ljn6FUvpmboujp6WJqavTaz8HU1Ei2jRWipGnTpg3W1tbcunVLXWZoaEi3bt3YuXMnjo6OXLt2TT1NqrBERUVpPE5MTCQlJSXLReMZypUrx507dzLtr1y5coUytu7du9O9e3eio6M5fPgw8+fPp1SpUnz99deF0r8QQggBL+5F8Trv4VAUSvI5lNzJWEK8wZ48eaJVlpyczIMHD7S+9e/Tpw/Xrl1j/vz51KpVi6ZNmxbqWI4ePYpSqVQ/Dg0NRUdHR71eIqsrG46Ojvzvf//j9u3b6rK4uDhOnTqFo6NjoY7R3Nyc3r1707p1a43jCSGEEKLkkysUQhSBbt264ebmhrOzM5UqVSIyMpKtW7cSExPDoEGDNOpaW1tjY2PDuXPnmDx5cqGP5fnz54wZM4Z+/fqpd3ny8PBQr42oVasWenp6/PTTT5QqVQo9PT1sbGzo2bMnGzduZOTIkXz22WfqXZ5KlSqldQ75sWLFCmJjY2nWrBkVKlTgf//7HydPnmTw4MEF7vtVlpVNCr1PIYQQJZ/8/X89JKEQogiMHTuWo0eP4ufnR3R0NOXLl0ehULBx40aNhcoZOnTowN9//82HH35Y6GPx9PQkOjqaqVOn8vz5czp06KCxi5S5uTm+vr6sX7+ePXv2kJaWxo0bNzA2NmbLli34+fnxxRdfkJ6ejoODA1u3btXYMja/bGxs2LRpE/v37ycxMZEqVarg5eXFp59+WuC+X6ZSqfDuX7hXVIQQQrw5lMp0uUt2EdNRqVQSYSGKWf/+/TExMWHNmjWF2q9CoWDq1Kl4eXkVar9vmjd5MV5RKq6Ffm8SiVH2JD45kxhl73XEJz1d9UYnFKVK6VK+fFliYp6+1jUU5uZlZVG2EG+CK1eucOHCBc6fP8+GDRuKezhvrZK8kK0kkPjkTGKUPYlPziRG2ZP4vNkkoRCiGPXq1QsTExNGjx5Nq1atins4QgghhBB5JgmFEMXoxo0bb3T/QgghhBCybawQQgghhBAi3yShEEIIIYQQQuSbJBRCCCGEEEKIfJOEQgghhBBCCJFvklAIIYQQQggh8k0SCiGEEEIIIUS+ybaxQoi3Xm7v9PmuyYiLxCdrEqPsSXxyJjHKnsQnZ1nFqCTdAVxHpVKVjJGIN0pAQACBgYHqx+XLl8fKyorx48fTtGnTQjlGbGwsM2bM4OzZs8THx7Ny5Urat29fKH2/zf78808CAwO5du0aCQkJWFhY0LhxY7y8vGjSpAkAhw4dIjIykv79++e5//DwcHbt2kWfPn2oXLlyYQ9fzcfHhx49etC8efMC9aNSqdDR0SmkUQkhhBAlg1KZTmxsUpElFebmZXOd6MkVCpFvhoaGbNq0CYCHDx+yatUqBg8ezM6dO7Gysipw/xs2bODMmTMsWLCAChUqULt27QL3+ba7cOECAwcOpE2bNsyZM4eyZcvy33//cejQIS5fvqyRUFy9ejVfCUVERASBgYG4uroWekJx8eJFoqKi6NChg7rs6dOnbNmyBS8vL/T19fPcp46ODou2XSA8MqEwhyqEEEIUG8vKJnj3d0RXV6dEXKWQhELkm66uLnZ2durHtra2uLu7s337dnx9ffPdb3JyMoaGhty5cweFQkG7du0KPNaMPt923333HdWrV2flypXo6ekB0LJlS/r27Ut6enoxjy5n1apV4/vvv+enn34iJSWFY8eOsWDBAnr27FmgqwzhkQnciogrxJEKIYQQIoNMWBOFplq1apibmxMeHq4u27lzJ926dcPGxoY2bdqwdOlSlEqlxvMKhYKwsDCGDBmCnZ0d/v7+KBQKDhw4wPnz51EoFCgUCnWbX3/9le7du2NjY4OzszPz588nJSVF/fyZM2dQKBQcO3aM8ePH4+DgwIQJEwgPD0ehULB79258fX1p2rQpLVu2ZMOGDQDs27cPDw8PHBwcGDt2LPHx8eo+k5KSmDt3Lh4eHjRp0gR3d3d8fX1JSND81tvd3Z25c+eybds23NzccHR0ZPTo0URHR2vUi4+PZ968ebRt25bGjRvj7u7O4sWLNeocO3aM3r17Y2trS4sWLZg1axZJSUnZvgbx8fGYm5urk4mX6eq++HX38fFh165d3Lx5Ux1bHx8fAMLCwhg1ahTOzs7Y2dnRvXt3du/erRHbgQMHAtCrVy+N1ybjtXz1XLt3767uH+DmzZsMHz6c5s2b06RJEzw8PFi3bh0AVapUwc/Pjy5dunD69GkOHDjAmjVrGDBgAKVKyfcfQgghREkk/0OLQpOYmEhsbCyVKlUCXkxZWrhwIYMGDcLHx4dbt26pEwpvb2+NtpMnT+bjjz9m5MiRGBkZ8cEHH7Bo0SKePn3KrFmz1PUOHz7M+PHj6dKlC5MnT+b27dssXbqUBw8esGLFCo0+v/jiCz744ANWrlyp/jANsGzZMjp27Mjy5cs5dOgQfn5+REdHc/bsWaZMmUJiYiJffvklCxcuZN68ecCLKxxKpZKJEydibm7OgwcPWLNmDaNHj2bLli0axz1y5Aj//fcfvr6+xMTEMH/+fObNm8fSpUsBeP78OYMGDSIiIoIxY8ZgZWXFw4cPuXDhgrqP0NBQJk6cSM+ePRk3bhyPHz9m8eLFxMfHq/vJTKNGjVi1ahXLli2jW7du1K1bV6tORoJz+/ZtFi1aBIC5uTkA9+/fx8HBgX79+mFgYMDFixeZOXMmKpWKHj160KhRI3x9fZk7dy7z58+nTp06WY4lK6NGjcLCwoKvvvoKY2Nj7t69y8OHDwGIjIxk+fLlREdH07JlSxQKBaNGjaJ379706dMn00RJCCGEEMVLEgpRIGlpacCLNRQLFixAqVTi4eFBYmIiK1asYNiwYUyaNAmA1q1bo6+vj5+fH15eXpQvX17dT9++fRkxYoRG36ampujo6GhMqwoMDMTOzk79bX7btm0xMjLC19eXGzduaFzJcHd3Z8qUKerHGVdO7Ozs+PzzzwFo0aIFv/76K1u3buXIkSPqMd24cYMff/xRnVCYm5szZ84cjfO2tLTkk08+4c6dOxrrO1QqFatXr8bAwAB4seYgKCiI9PR0dHV12b17N3///Tfbt2/H3t5e3a5Hjx7q9v7+/nTu3JmvvvpK/XzFihUZMWIEo0ePpn79+pm+Hl5eXly6dInVq1ezevVqzMzMcHZ2pl+/furF8jVr1sTc3Jz79+9rxBagS5cuGufh5OREZGQkO3bsoEePHhgbG1OvXj0A6tevj42NTabjyEp0dDTh4eHMmDEDd3d34MVrkCE8PBxXV1c6duyIj48Pbm5ujBs3ji1btqBUKiWhEEIIIV5SUnbHkoRC5FtSUhKNGjVSPy5Xrhy+vr60adOGkydPkpSURKdOndRJB0CrVq1ITk7m5s2bNGvWTF3u6uqa4/GePn3KtWvXmDZtmkZ5586d8fX15cKFCxoJRVZ9tm7dWv1vPT09atSogY6OjkaCU6tWLeLj43n69Clly5YFYPfu3WzcuJH//vtPY+rRv//+q5FQODk5qZMJgLp165KamkpUVBQVK1bk9OnT1K1bVyOZeNmdO3eIiIjg888/14hds2bN0NXV5erVq1kmFMbGxgQHB3P58mWOHTvGhQsXOHDgAPv27WPevHn07t0703YZ4uLiCAgI4PDhw0RGRqqnp5mZmWXbLrfKly9P9erVWbJkCXFxcbRs2ZIqVaqon3d0dNRqU7ZsWUaNGlUoxxdCCCHeJqamRsU9BEASClEAhoaGbN26Vf1hvGrVquqpRTExMcD/fev+qgcPHmg8trCwyPF4CQkJqFQqKlSooFFuYmKCgYEBcXGai25frfdy/Zfp6+tTpkwZrTKAlJQUypYty8GDB5k2bRoff/wxEydOxMzMjMePHzNmzBiN9Rvw4srKyzKSi4x6L08Ly0xG7MaMGZPp86/GLjO2trbY2toCcO/ePTw9PVm0aFGOCYWPjw9hYWGMGTOGevXqYWxszHfffcf+/ftzPGZu6Ojo8M0337B06VLmzp2rTkqnT5+Ok5OTRl0/P79COaYQQgjxtoqPf4ZSWTSbrpiaGsm2saLo6erqZjnlpVy5csCLKUovfwOdwdLSMs/HMzExQUdHR2vRb0JCAs+fP1cfM0Nh3nsgNDSUBg0aMHfuXHXZ2bNn89WXmZkZN27cyPZ5AF9fX3VS8LLskpHM1KhRg06dOrFhwwaePHmSZfKWsauSj48Pnp6e6vJvv/02V8cpXbo0AKmpqRrlLy9uB6hduzYrVqwgNTWVsLAwlixZwqhRozhx4oT6apAQQgghcqZUppOWVvy7OJaMiVfirWNvb4+RkREPHz7ExsZG6+fl6UW5VbZsWRo0aEBoaKhGeca355lNlyksycnJWvdA2Lt3b776atWqFbdu3eLSpUuZPl+nTh2qVKnCvXv3Mo1ddvd+ePLkSabl//77LwYGBuqrJ/r6+lpXVp4/f056errGeSYmJnLkyBGNei9fvXlZxrhu376tLrt161aWV1T09fVp1qwZI0aMIDExkUePHmV5XkIIIYQoueQKhSgSpqamjB8/noULF/Lw4UOaNWuGnp4e9+7d4/DhwwQEBGBklPd5f2PHjmXMmDF4e3vzwQcfcOfOHZYuXYqHh4fG+onC1qpVK+bOncvKlSuxt7fn+PHjnD59Ol99de/enW+//ZYRI0YwduxY6tevT2RkJOfPn2fevHno6Ojg4+ODt7c3SUlJuLq6YmRkxP379zl+/DgTJ07M8iZ/M2fORKlU0rFjR2rVqkViYiIHDhzg6NGjDBo0SD39qm7duvz000+EhITw3nvvUb58eSwtLbGxsWHdunWYm5tTqlQp1q5di7GxscZVoVq1aqGnp8dPP/1EqVKl0NPTw8bGhiZNmlC1alW+/vprJk+eTGJiImvXrtVYf3H9+nUWLFhA586dqVGjBomJiQQFBVG9enVq1qyZr3jmhmVlk5wrCSGEEG+Ikvb/miQUosgMHTqUypUrs2HDBrZu3UqpUqWoWbMmrq6u+brjMUC7du1Yvnw5K1euZPTo0ZiZmdGnTx8mT55cyKPX1LdvX8LDw9m6dSvffPMNzs7OLF68mD59+uS5LwMDAzZu3MjSpUsJCgoiNjaWKlWqaOyw9P7772NqasqaNWvUV0KqV69OmzZtsl1v0r9/f3bv3k1QUBCPHz/G0NCQmjVr8tVXX2msZ+nVqxeXL19m3rx5xMbG0qNHD/z8/Fi8eDG+vr74+PhgZmaGp6cnSUlJBAcHq9uam5vj6+vL+vXr2bNnD2lpady4cQN9fX0CAwOZPXs2EyZMoGbNmnz++ecaayEqVqyIhYUFQUFBREZGYmJiQtOmTVm4cGGR7eCkUqnw7l90V6+EEEKI4qBUppeIu2QD6KhUqpIxEiGEKCJFuWjtTaanp4upqZHEJxsSo+xJfHImMcqexCdnWcUoPV1VpAmFuXlZWZQthBAZSsqitZJK4pMziVH2JD45kxhlT+KTs5IcI1mULYQQQgghhMg3SSiEEEIIIYQQ+SYJhRBCCCGEECLfJKEQQgghhBBC5JskFEIIIYQQQoh8k4RCCCGEEEIIkW+SUAghhBBCCCHyTRIKIYQQQgghRL7Jje2EEG+93N7p812TEReJT9YkRtmT+ORMYpQ9iU/OchOjor5rdk50VCpV8R1dZOuDDz7gxo0bbNu2jaZNm2o8d+bMGQYOHMiPP/6IjY1NrvvMb7u88PHxYdeuXVrlrq6uBAUF5aqPa9eucejQIYYNG4aRkVFhD7FQbNy4kdq1a+Pi4pLntjt37mT69OmcPn0ac3PzQhlPr1696NGjB/379y+U/jKTmJhIixYt2Lhxo9Z7Mi9yeh+mp6fz/vvvM2bMGD744IOCDBmVSoWOjk6B+hBCCCFKMqUyndjYpEJNKszNy+Y60ZMrFCXUzZs3uXHjBgB79+4t0Ie34lCjRg0WLVqkUWZqaprr9teuXSMwMJD+/fuX2IRi8+bNuLq65iuhcHV1ZceOHXmKSXYOHjxIREQEH330UaH0l5Xff/+dsmXLYm9vX6TH0dXVZcSIEQQEBNC5c2dKlcr/nyodHR0WbbtAeGRCIY5QCCGEKBksK5vg3d8RXV2dYrtKIQlFCbV37150dXVxcnIiNDSUmTNnoq+vX9zDyjVDQ0Ps7OyKexh5lpycjKGhYZEfx9zcvNCuTABs2rSJLl26FPnYjx07hrOzM3p6ekV6HIDOnTvz5ZdfcuzYMdq3b1+gvsIjE7gVEVdIIxNCCCHEy2TCWgmkUqkICQmhRYsWDBkyhNjYWE6ePJljO4VCwdq1a/H396dFixbY29vj4+NDYmKiVt34+HgmT56Mvb09bm5urFu3TuP5sLAwRo0ahbOzM3Z2dnTv3p3du3cX1imyc+dOunXrho2NDW3atGHp0qUolUr1c9OnTwegZcuWKBQK3N3d1W1v3LiBl5cXdnZ2ODo6Mn78eO7fv5/nWJw5cwaFQsGxY8cYP348Dg4OTJgwAYCIiAjGjx+Po6MjdnZ2eHl5qa8YAbi7uxMREcG2bdtQKBQoFAp27tyZq/PLeF6hUBAdHQ1AeHg4CoWCn3/+mblz5+Lk5ISzszMLFiwgLS0t21jeu3eP8+fP06lTJ41yT09PRo4cSWhoKB4eHtjb2zNw4EDu3r2rUe/hw4eMHDmSJk2a4OLiwsaNG/nqq680Yg4vpiEdP35cXZ4Rv5MnTzJhwgTs7e1xdXVl7969wP9dwWnWrBkzZszg+fPn2Z7Hq4yMjHBxccl0+pwQQgghSg65QlECXbx4kYiICMaMGYOzszNmZmaEhIRofcDLzJYtW2jUqBELFiwgPDycRYsWkZKSwtKlSzXqzZo1i+7du7Ny5UoOHTrEokWLUCgUtG3bFoD79+/j4OBAv379MDAw4OLFi8ycOROVSkWPHj1ydR6vfhDOmLayYcMGFi5cyKBBg/Dx8eHWrVvqD9ze3t64urry6aefsnr1atavX4+JiQkGBgYAPHjwgAEDBlCjRg0WLlyoPrcBAwawZ88ejI2N8xyLL774gg8++ICVK1eiq6tLYmIinp6e6OrqMmfOHEqXLs3q1avVx6hatSqBgYGMGDECBwcHhg4dCkDNmjVzdX7ZWbZsGe3atWPZsmWEhYUREBBAzZo16devX5Zt/vjjD0qVKoWtra3Wc9euXSM6Ohpvb2+USiV+fn5MmTKFHTt2AC+S19GjR/PkyRPmzJmDiYkJ33zzDffv30dXV/P7hsuXLxMXF0ebNm00ymfPnk2PHj3o06cP33//PVOnTuX69evcvHmTOXPmcO/ePfz8/KhRowajRo3K9vxfZW9vz4oVK0hPT9cajxBCCCFKBkkoSqCQkBBKly5Nx44d0dfXx8PDgz179vD06VPKli2bbVsDAwNWrlypnpJSunRpZs6cydixY6lbt666XseOHRk3bhzw4irAsWPHOHDggDqh6NKli7quSqXCycmJyMhIduzYkauE4ubNmzRq1EijbNu2bVhbW7NixQqGDRvGpEmTAGjdujX6+vr4+fnh5eWFubm5+sN5o0aNNKYGbdy4kbS0NIKDgzEzMwOgQYMGdOnShV27duHp6ZnnWLi7uzNlyhT1482bN3P//n327dunrufk5ISbmxubNm3Cx8eHhg0bYmBggIWFhcbUrsTExBzPr3z58lnGzdbWlpkzZ6rbnTlzhgMHDmSbUFy5coVatWqpk66XJSQksHv3bnUMk5KSmD59Og8fPqRKlSqcOHGCv/76S2Phf4sWLXBxcdFa33H06FEcHBy0yjt16sTYsWPV4z948CD79u3j4MGD6ml6Z8+eJTQ0NM8JhbW1NYmJidy6dYv69evnqa0QQgjxLinOnbLkK78SJi0tjdDQUFxcXDAxMQGgW7duPHv2jIMHD+bY3s3NTWN+e6dOnVCpVFy5ckWjnrOzs/rfOjo61K1bl4cPH6rL4uLi+PLLL3Fzc6NRo0Y0atSIHTt2cOfOHXUdpVJJWlqa+udlNWvW5Mcff9T4adCgAWFhYSQlJdGpUyeNtq1atSI5OZmbN29me37nz5+nefPm6mQCoG7dulhbW3PhwoV8xcLV1VXrGPXr19dIOszMzGjVqpXWMV5V0PN7+XXJOLeXX5fMPHr0KMskxdraWiMhq1evHoC6zytXrmBqaqqx6L9s2bK0bNlSq69jx47h5uamVd66dWv1v01MTDA3N6dp06Yaa35q1arFgwcPsj2PzGSc1+PHj/PcVgghhHiXmJoaUb582UL7yUuCIlcoSpjff/+d6Oho3NzciI+PB8DKyoqKFSsSEhLChx9+mG37ChUqaDw2NjamdOnSPHr0SKM8I1nJoK+vT0LC/+2C4+PjQ1hYGGPGjKFevXoYGxvz3XffsX//fnWdDh06EBERoX58+PBhLC0tgRdXAzLbDjQmJgYgy6scOX3ojI+Pp0GDBlrlFSpUIC4uTqvsZVnF4tV68fHxWFhYZHqMnBKCgp5fZq9LTmsPnj9/nunVCdDeWSvjQ35KSgrwIhnJbHH4q2UPHjzg+vXrWtPFMhuzgYFBpsfN6xqKjL7gxWJ5IYQQQmQtPv4ZSmV6ofVnamok28a+qTIWtE6fPl29MDlDTEwMUVFRWh+AXxYVFaXxODExkZSUFCpVqpTrMaSkpHDs2DF8fHw0phB9++23GvVWr16t8SExN8coV64cAIGBgVSpUkXr+YyEJLv2r54jvDjvWrVqaZW9LKtYvHqPgnLlymlciXm5v4zxZzc+yP/55Ue5cuU0Eru8qFSpknph+MteLTt69CjvvfcederUyddx8isjqX75ipQQQgghtCmV6aSlFV5CkReSUJQgz5494/Dhw7Rv356BAwdqPPfkyRMmTZrEL7/8ovEh/1VHjx5l+vTp6qk+oaGh6Ojo5Okmds+fPyc9PV1jykpiYiJHjhzRqKdQKHLdZwZ7e3uMjIx4+PAhHTp0yLJexrFf/Vbb0dGR77//nri4OPWH99u3b3Pjxg2tezDkNxaOjo4cOHCA27dvqz9Ax8XFcerUKT7++GONMWZ805/X8ytMtWvX5syZM/lqa2NjQ3x8POfOncPJyQmAp0+fcvr0aY2rDFlNdypqGYnSq8miEEIIIUoOSShKkMOHD5OUlISnpyfNmzfXen79+vWEhIRkm1A8f/6cMWPG0K9fP/XORh4eHhrrAXJiYmKCjY0N69atw9zcnFKlSrF27VqMjY0z/TY7L0xNTRk/fjwLFy7k4cOHNGvWDD09Pe7du8fhw4cJCAjAyMhIPd5t27bRvn17DA0NUSgUDB48mJ07dzJ06FA+/fRTUlJSWLZsGVWrVtWaZpTfWPTs2ZONGzcycuRIPvvsM/UuT6VKlWLQoEHqenXq1OGPP/7g999/x9TUFEtLS8qXL5+r8ytMDg4OrFy5Ur3QOi/atm1Lo0aNmDx5MpMmTcLU1JT169dTtmxZ9ZWbZ8+e8ccffzBkyJBCHTe82KHq1asrlpaWNG7cGICrV69St27dAt+zw7KySc6VhBBCiDdQSfg/ThKKEiQkJIRq1aplmkwAfPjhh3z99dda9xF4maenJ9HR0UydOpXnz5/ToUMHfH198zyWxYsX4+vri4+PD2ZmZnh6epKUlERwcHCe+3rV0KFDqVy5Mhs2bGDr1q2UKlWKmjVr4urqqr4y0bBhQ8aNG8cPP/zA+vXrqVq1KkeOHKFq1aps2bIFf39/vL290dXVpXXr1vj4+GhsGVuQWBgbG7Nlyxb8/Pz44osvSE9Px8HBga1bt1K1alV1vUmTJjF79mzGjRvH06dPmT9/Pj179szV+RWmZs2aYWZmxokTJ+jTp0+e2uro6LBq1Sp8fX3x9fXF1NSUgQMHcufOHa5duwbAqVOnMDAwKJK7tb96N3WAXr168dVXXwFw4sQJPDw8CnQMlUqFd3/HAvUhhBBClGRKZXqx3SUbQEelUhXf0UWhUigUTJ06FS8vr+IeSrF712Lh5+fH33//zebNmwvc1/Pnz+nSpQtNmzZl/vz5fPHFF8THx7N8+fJCGGnu3bx5k+7du3PgwAFq1KhRoL4Ke6Ha20JPTxdTUyOJTzYkRtmT+ORMYpQ9iU/OchOj9HRVoScU5ua53+lJrlAI8RYYOnQoHTt25Pr161hbW+ep7Y4dO0hPT6d27drEx8fz3XffERERwZIlSwCYN29eUQw5R8HBwXTv3r3AyQQU70K1N4HEJ2cSo+xJfHImMcqexCdnJTlGklAI8RaoVKkS8+fPz9cal9KlS7N27Vr1WgZra2uCgoLytJC/sKWnp/Pee+/luE2yEEIIIYqfTHkSQrz1YmKelthvdYpTqVK6lC9fVuKTDYlR9iQ+OZMYZU/ik7PiilFepjxJQiGEeOvJvNys6enpSnxyIDHKnsQnZxKj7El8clYcMdLV1dG6V1dWJKEQQgghhBBC5FvurmMIIYQQQgghRCYkoRBCCCGEEELkmyQUQgghhBBCiHyThEIIIYQQQgiRb5JQCCGEEEIIIfJNEgohhBBCCCFEvklCIYQQQgghhMg3SSiEEEIIIYQQ+SYJhRBCCCGEECLfJKEQQgghhBBC5JskFEIIIYQQQoh8k4RCCCGEEEIIkW+SUAghhBBCCCHyTRIKIUSJd+vWLYYMGYKdnR2tW7fG39+f58+f59hOpVKxdu1aXF1dsbW15eOPP+bPP//UqhcZGcm4ceOwt7enWbNmzJgxg8TExCI4k6JTlDE6deoUEydOxN3dnSZNmtC5c2fWr19PampqEZ1N4Svq91CG9PR0evbsiUKhIDQ0tBDPoOi9jhgdO3aMvn37Ymdnh5OTE56enjx8+LCQz6RoFHV8zp8/j6enJ05OTjRv3pxhw4Zx7dq1IjiTopPfGG3bto2RI0fSokWLbH933vS/1UUZn+L+Oy0JhRCiRIuLi2PQoEGkpqYSEBDAxIkT+f777/Hz88ux7bp161ixYgWDBw8mKCiIihUrMnToUO7du6euk5qayrBhw/j3339ZvHgxs2fP5rfffmPy5MlFeVqFqqhjtH37dp4+fcr48eNZu3YtH374IQEBAfj6+hblaRWaoo7Py7Zv305kZGRhn0KRex0x+vnnnxk7dizNmjVjzZo1+Pn50bhxY1JSUorqtApNUcfn9u3beHl5UaZMGRYvXsxXX31FXFwcgwcP5vHjx0V5aoWmIDH6+eefiYmJwcXFJcs6b/rf6qKOT7H/nVYJIUQJtmbNGpWdnZ0qJiZGXbZ9+3ZVgwYNVA8fPsyyXXJyssrBwUG1ePFidVlKSorKzc1NNWvWLHXZ3r17VQqFQnXr1i112cmTJ1VWVlaqS5cuFeq5FJWijlFUVJRW29WrV6sUCkWmz5U0RR2fDFFRUapmzZqpfvzxR5WVlZVq//79hXkaRaqoYxQTE6NycHBQbdu2rSiGX+SKOj5BQUEqGxsb1bNnz9Rld+/eVVlZWal27dpVmKdSZPIbI5VKpVIqlSqVSqW6d+9elr87b/rf6qKOT3H/nZYrFEKIEu3EiRO0bNkSMzMzddn7779Peno6v//+e5btLl68SGJiIu+//766zMDAgA4dOnDixAmN/hUKBXXq1FGXtW7dGjMzM44fP164J1NEijpG5ubmWm0bNGiASqV6I749Ler4ZFiyZAnNmzenefPmhTr+16GoY7R//37S09Pp1atXkYy/qBV1fFJTUzEwMHYaxE0AABh8SURBVKB06dLqMhMTk8I9iSKW3xgB6Orm/HH0Tf9bXdTxKe6/05JQCCFKtNu3b2v8BwJgampKxYoVuX37drbtAK22devW5f79+yQnJ2fZv46ODrVr1862/5KkqGOUmYsXL2JgYIClpWUBRv56vI74XL58mZCQEKZOnVqII399ijpGly5donbt2uzevRs3NzcaNmxI9+7d34gPglD08enSpQtKpZJly5YRExNDZGQk8+fPp2rVqrRr166Qz6Zo5DdGBen/TfpbXdTxyczr/DstCYUQokSLj4/H1NRUq7xcuXLExcVl2+7Vb/zgxR9wlUqlbhsfH5/pN4E59V+SFHWMXvXvv/+yefNm+vbtS9myZQs2+NegqOOTnp7OnDlzGDJkyBuRYGWmqGP0+PFj7ty5w/Lly5kwYQLr1q2jevXqjB49mps3bxbuyRSBoo5PrVq12LhxIz/++CMtWrSgbdu2nDt3jg0bNrwxVyryG6O89P8m/60u6vi86nX/nZaEQgghRK4lJiYybtw4LC0tmThxYnEPp0T44YcfePLkCSNGjCjuoZRYKpWKpKQk5s6dy4cffkjr1q1Zvnw5lStXZt26dcU9vGJ3584dxo0bR+vWrdmwYQNr1qyhevXqDB8+nCdPnhT38MQbpjj+TktCIYQo0UxNTUlISNAqj4uLo1y5ctm2e/78udYOMvHx8ejo6KjbmpqaZrrtYE79lyRFHaMMz58/Z8yYMcTFxbF27VrKlClTOCdQxIoyPk+fPmXJkiV8+umnpKamEh8fr34/JScnvzFbWr6O3zOAFi1aqOvo6+vj5OTEP//8UxinUKSKOj5Lly7FwsICf39/WrVqhZubG2vWrCE+Pp7NmzcX7skUkfzGKC/9v8l/q4s6PhmK6++0JBRCiBKtTp06WvNLExISePz4sdZ81FfbwYtv/l52+/ZtqlWrhqGhYZb9q1Qq7ty5k23/JUlRxwheTOvx9vbmr7/+Yt26dVStWrUQz6BoFWV8YmJiiI2NZdasWTg5OeHk5ET37t0BmDZtGh4eHoV8NkWjqN9D9erVy7KPN2Hb2KKOzz///IO1tbVGnbJly1KzZk3u3r1bGKdQ5PIbo4L0/yb9rS7q+EDx/p2WhEIIUaK1bduWU6dOER8fry4LDQ1FV1eX1q1bZ9nOwcEBY2Nj9u/fry5LTU3l119/pW3bthr9X79+nX///Vdddvr0aWJjY7Pd87skKeoYAcyZM4ejR4+yatUqFApF4Z9EESrK+FSsWJHNmzdr/CxZsgSAcePGERAQUERnVbiK+j3k5uYGvPjdyvD8+XPOnTtHo0aNCvNUikRRx6datWpcu3YNlUqlLktMTOS///6jevXqhXw2RSO/McpL/2/y3+qijg8U89/pIt+YVgghCiA2NlbVunVr1YABA1QnT55U/fjjj6qmTZuq5syZo1Fv4MCBqvbt22uUBQUFqRo3bqzauHGj6tSpU6px48ap7O3tVXfv3lXXef78uapr166qrl27qo4cOaLat2+fysXFRTVixIjXcn6FoahjtHr1apWVlZVqwYIFqrCwMI2fhISE13KOBVHU8XlVdnvFl1SvI0bjxo1TtWjRQvXDDz+ojh07phoxYoTKxsZGdf369SI/v4Iq6vgcPHhQZWVlpZo0aZLq+PHjqoMHD6r69eunsrW1Vd25c+d1nGKBFSRGly9fVu3fv1+1bds2lZWVlcrPz0+1f/9+1ZkzZ9R13vS/1UUdn+L+Oy0JhRCixPvnn39UgwYNUtna2qpatmyp8vPzU6WkpGjUGTBggMrNzU2jLD09XbVmzRpV27ZtVY0bN1b17t1bdfHiRa3+Hz58qBo7dqzKzs5O1bRpU9X06dPfiA/KLyvKGA0YMEBlZWWV6c8ff/xR5OdWGIr6PfSyNzGhUKmKPkZPnz5VzZs3T9WiRQtV48aNVR9//LHq/PnzRXpOhamo4/PLL7+oPvroI5WDg4OqefPmqiFDhqj+/PPPIj2nwpbfGE2bNi3Tvy8DBgzQqPem/60uyvgU999pHZXqpetrQgghhBBCCJEHsoZCCCGEEEIIkW+SUAghhBBCCCHyTRIKIYQQQgghRL5JQiGEEEIIIYTIN0kohBBCCCGEEPkmCYUQQgghhBAi3yShEEIIIYQQQuSbJBRCCCFELu3cuROFQkF4eHiRHufJkyeMHz+e5s2bo1Ao2LhxY5Ee73Xy8fHB3d29uIfxWmV2zgqFgoCAgGIakRCFSxIKIYQQRSbjA7hCoeD8+fNaz6tUKlxcXFAoFIwcOTJfxzh+/HiJ+2AWEBCAQqEgOjo6X+3nz5/PyZMnGTFiBP7+/rRp06aQR1i0IiMjCQgI4Nq1a8U9FLXw8HD1e3HVqlWZ1pk8eTIKhQJ7e/vXPLrX6/z58wwbNow2bdpgY2ODq6sro0aNYu/evcU9NPGGKlXcAxBCCPH2K126NCEhITRt2lSj/OzZszx8+BADA4N89338+HG2bdvGuHHjCjrMEuOPP/6gXbt2eHl5FfdQ8uXRo0cEBgZSvXp1GjRooPHcvHnzUKlUxTSyF+/Fffv2MXr0aI3ypKQkjhw5QunSpV/LOC5fvoyent5rOdbL9u/fz8SJE2nQoAEDBw6kXLlyhIeHc+7cOb7//nu6dev22sck3nySUAghhChyLi4uhIaGMnPmTEqV+r//ekJCQmjUqBGxsbHFN7gSKCoqClNT00LrLyUlBX19fXR1i39igr6+frEe38XFhV9//ZXr169jbW2tLj98+DCpqak4Oztz5syZIh/H60pcXhUYGEi9evXYsWOHViIfFRX12sahUqlISUnB0NDwtR1TFJ3i/8sihBDirdelSxdiY2P5/fff1WXPnz/nwIEDmX4jeubMGRQKhdYHu4xpKzt37gRezE3ftm0bgHo6i0KhyFMfANevX8fHx4d27dphY2ND69atmT59OjExMYUTAMDT05OuXbvyzz//4OnpSZMmTWjTpg3r1q1T18mYIqZSqdi2bZvG+QDcu3eP8ePH06xZM5o0aUKfPn04duyYxnEyznvfvn0sXbqUNm3a0KRJExITE/Hx8cHe3p779+8zcuRI7O3tadOmjTqGN27cYODAgdjZ2eHm5qY1BSY2NpYFCxbQrVs37O3tcXBwYNiwYVy/fl3j+L169QJg+vTp6nN4+TV7dT1BUlISfn5+uLi40LhxYzw8PPjmm2+0rmQoFArmzp3LoUOH6Nq1K40bN6ZLly6cOHEi16+DnZ0dlpaWWue2d+9enJ2dMTMzy7Td8ePH+eSTT7Czs8Pe3p4RI0Zw8+ZNrXoZY7OxsaFr164cPHgw0/5eXUMRERHB7Nmz8fDwwNbWlubNmzN+/Hit9ToZ75ELFy4wf/58WrRogZ2dHWPGjMnVFLu7d+9iY2OT6VXBChUqaDxOT09n06ZNdOvWDRsbG1q0aIGXlxdXrlxR10lLS2PlypW0b9+exo0b4+7uzpIlS3j+/LlGX+7u7owcOZKTJ0/Ss2dPbG1t2b59OwDx8fF89dVX6te/Q4cOrF27lvT09BzPR5QMcoVCCCFEkatevTp2dnbs27cPFxcXAE6cOEFCQgKdO3dmy5Yt+er3448/5tGjR/z+++/4+/vne3ynTp3i3r179OzZk4oVK3Lz5k2+//57/vnnH77//nt0dHTy3ffL4uLiGDZsGB06dOD999/nwIEDLFq0CCsrK1xcXHBycsLf35+pU6fSunVrunfvrm775MkT+vbty7Nnz/D09KR8+fLs2rWLTz/9lBUrVtChQweNY61atQp9fX28vLx4/vy5+sqAUqlk+PDhNG3aFG9vb/bu3cvcuXMxMjJi6dKldOvWjY4dO7J9+3amTZuGnZ0dNWrUAF4kNIcOHaJTp05YWlry5MkTduzYwYABA9i3bx+VK1embt26jB8/nhUrVvDxxx/j6OgIgIODQ6YxUalUfPrpp+pEpEGDBpw8eRJ/f38iIyP5/PPPNepfuHCBX3/9lU8++YSyZcuyZcsWxo8fz9GjRylfvnyuXoeuXbuyZ88evL290dHRITo6Wv0eOnnypFb93bt34+Pjg7OzM97e3jx79ozvvvuOTz75hF27dmFpaQnAb7/9xrhx46hXrx6TJ08mJiaG6dOnU6VKlRzHdOXKFcLCwujSpQtVqlQhIiKC7777joEDB7Jv3z6MjIw06n/55ZeYmpoyduxYIiIi2LRpE3PnzmXZsmXZHqdatWqcPn2ahw8f5jiuGTNmsHPnTtq2bUuvXr1QKpWcP3+eS5cuYWNjA8DMmTPZtWsXHh4eDBkyhMuXLxMUFMStW7dYuXKlRn937txh8uTJfPzxx/Tp04fatWvz7NkzBgwYQGRkJH379qVq1aqEhYWxZMkSHj9+zIwZM3KMnSgBVEIIIUQR+emnn1RWVlaqy5cvq7Zu3aqyt7dXPXv2TKVSqVTjx49XeXp6qlQqlcrNzU01YsQIdbs//vhDZWVlpfrjjz80+rt3757KyspK9dNPP6nL5syZo7KystI6dl76yBjTy0JCQlRWVlaqc+fOaZ3PvXv3sj3vFStWqKysrFRRUVHqsgEDBqisrKxUu3btUpelpKSoWrdurRo3bpxGeysrK9WcOXM0yr766iut8SQmJqrc3d1Vbm5uKqVSqXHe7dq10zqvadOmqaysrFRr1qxRl8XFxalsbW1VCoVCtW/fPnX5rVu3VFZWVqoVK1ZojDfjOBnu3bunaty4sSowMFBddvnyZa0YvzwGNzc39eODBw+qrKysVKtWrdKoN27cOJVCoVD9999/GnFp1KiRRtm1a9dUVlZWqi1btmgd69VxWllZqdavX6/63//+pxHLrVu3quzs7FRJSUmqadOmqezs7NTtEhMTVU2bNlXNnDlTo7/Hjx+rHB0dNcq7d++uat26tSo+Pl5d9ttvv6msrKw0zjnjXF6ObWbvwbCwMK33TMZ7cPDgwar09HR1+ddff61q0KCBxrEz88MPP6jj6OnpqVq2bJnq3LlzWq/r6dOnVVZWVqp58+Zp9ZFx3IzYz5gxQ+N5Pz8/lZWVler06dPqMjc3N5WVlZXqxIkTGnVXrlypsrOzU925c0ejfNGiRaoGDRqo7t+/n+35iJJBpjwJIYR4Ld5//31SUlI4evQoiYmJHDt2rMQsAH15HndKSgrR0dE0adIEgL/++qvQjlOmTBmNqw4GBgbY2Nhw7969HNseP34cW1tbjYXtZcuW5eOPPyYiIoJ//vlHo/6HH36Y5fz03r17q/9tampK7dq1MTIy4v3331eX16lTB1NTU42xGRgYqNdhKJVKYmJiKFOmDLVr1+bvv//O8Rwyc+LECfT09PD09NQoHzp0KCqVSms6U6tWrahZs6b6sbW1NcbGxrmKYYb69eurp4XBi7U87dq107oKAC+uXsXHx9OlSxeio6PVP7q6ujRp0kQ9pe7Ro0dcu3aNHj16YGJiom7funVr6tWrl+OYXn6tUlNTiYmJoWbNmpiammYa2z59+mhcOWvatClKpZKIiIhsj9OrVy/Wr19P8+bNuXjxIqtWraJ///507NiRixcvquv9+uuv6OjoMHbsWK0+Mo57/PhxAIYMGaLx/NChQzWez2Bpaam1Y1loaCiOjo6YmppqxLdVq1YolUrOnTuX7fmIkkGmPAkhhHgtzM3NadmyJSEhISQnJ6NUKvHw8CjuYQEv1gYEBgbyyy+/aC1MTUhIKLTjVKlSRWv6VLly5bhx40aObe/fv69Ocl5Wp04d9fNWVlbq8oxpOK8qXbo05ubmGmUmJiaZjs3ExIT4+Hj14/T0dDZv3sy3335LeHg4SqVS/VxWaw9yEhERQaVKlTA2NtYor1u3rvr5l1WtWlWrj3LlymmMMze6du3Khg0bGDx4MGFhYYwaNSrTev/++y8AgwYNyvT5jHHfv38fgPfee0+rTm4SruTkZIKCgti5cyeRkZEa60cyew9Wq1ZN43HGIv7cxKFNmza0adOGZ8+e8ddff/HLL7+wfft2Ro0axf79+6lQoQJ3796lUqVK2b6uERER6OrqaiR4ABUrVsTU1FTrtcvsPfnff/9x48YNWrZsmekx8rv1sni9JKEQQgjx2nTt2pUvvviCJ0+e0LZt2yx3MspqzUJeFmnmpY/PPvuMsLAwvLy8aNCgAWXKlCE9PZ1hw4YV6hanr3Ob0KyuTmQ1hqzKXz7/NWvWsHz5cj766CMmTJhAuXLl0NXV5euvv35tW8HmZpy50bVrV5YsWcLMmTMxMzOjdevW2fbr7+9PxYoVcz2evJo3bx47d+5k0KBB2NnZYWJigo6ODhMnTsz03LLasSsvcTAyMqJp06Y0bdqU8uXLExgYyIkTJ+jRo0eexp7bNUaZvSfT09Np3bo1w4YNy7RNrVq18jQWUTwkoRBCCPHadOjQgVmzZvHnn3+ydOnSLOtlJBqvfjOb2XSOrD7M5LaPuLg4Tp8+zbhx4zSmd2R8M11SVKtWjTt37miV3759W/18UTtw4ADNmzfn66+/1iiPj4/XWBCdl0Xs1atX5/Tp0yQmJmpcpcg4r+rVqxdw1JmrVq0aDg4OnD17ln79+mlsZ/yyjAXpFSpUoFWrVtn2By++cX9VZq/bqw4cOMCHH36Ij4+PuiwlJaVQr5Blp3HjxgA8fvwYgJo1a/Lbb78RGxub5VWK6tWrk56ezn///ae+ogQvNhCIj4/P1WtXs2ZNkpKSso2tKPlkDYUQQojXpmzZssyePZtx48ZpbR36surVq6Onp6c1f/q7777Tqpsx7/3VqR657SOrb5g3bdqU9YkUAxcXFy5fvkxYWJi6LCkpie+//57q1avnap5+Qenp6Wl9A75//34iIyM1yrJ6TTLTtm1blEqleuvaDBs3bkRHR4e2bdsWcNRZ++yzzxg7dqzW+o2XtWnTBmNjY4KCgkhNTdV6PmNKTqVKlWjQoAG7du3SSAJ+//13rfUtmcnsfbhlyxaNaWWF4fTp05mWZ6x3qF27NgAdO3ZEpVIRGBioVTfjPZCxY9urvysbNmzQeD4777//PmFhYZnurhUfH09aWlqOfYjiJ1cohBBCvFa5mU5hYmJCp06d2Lp1Kzo6OtSoUYNjx45leuOtRo0aAS+20XR2dkZPT48uXbrkug9jY2OcnJxYv349qampVK5cmd9//11r///iNmLECPbt28fw4cPx9PSkXLly7N69m/DwcAICAl7LTetcXV1ZuXIl06dPx97env/973/s3btX/S1+hozFxNu3b6ds2bKUKVMGW1tbrXrw4v4EzZs3Z+nSpURERKBQKPj99985fPgwgwYN0pqfX5iaNWtGs2bNsq1jbGzM7NmzmTp1Kj179qRz586Ym5tz//59jh8/joODA76+vgBMmjSJkSNH8sknn/DRRx8RGxvL1q1bqV+/PklJSdkex9XVlZ9//hljY2Pq1avHn3/+yalTp/K9NiUro0ePxtLSEjc3N2rUqMGzZ884deoUR48excbGBjc3NwBatGhB9+7d2bJlC//99x9t2rQhPT2dCxcu0Lx5cwYMGIC1tTU9evRgx44dxMfH4+TkxJUrV9i1axft27enRYsWOY7Hy8uLI0eOMGrUKHr06EGjRo149uwZ//vf/zhw4ACHDx/WWvMjSh5JKIQQQpRIM2fOJC0tje3bt2NgYECnTp2YOnUqXbt21ajXsWNHPD092bdvH3v27EGlUtGlS5c89bF48WLmzZvHt99+i0qlonXr1qxbt05rR5riZGFhwfbt21m4cCFbt24lJSUFhULBmjVrcHV1fS1jGDVqFM+ePWPv3r388ssvNGzYkKCgIBYvXqxRT19fHz8/P5YsWcLs2bNJS0tj/vz5mSYUurq6rF69mhUrVvDLL7+wc+dOqlevztSpU9W7BRW3bt26UalSJdauXcs333zD8+fPqVy5Mk2bNqVnz57qem3btmX58uUsW7aMxYsXU7NmTebPn8/hw4c5e/ZstseYMWMGurq67N27l5SUFBwcHNiwYUOWawvy68svv+Tw4cPs37+fR48eoVKpqFGjBqNGjWL48OEaU7/mz5+PQqHgxx9/xN/fHxMTExo3boy9vb1Gf5aWluzatYtDhw5hYWHByJEjM90dKjNGRkZs2bKFoKAgQkND2b17N8bGxtSqVYtx48Zp7JglSi4d1etaRSWEEEIIIYR468gaCiGEEEIIIUS+SUIhhBBCCCGEyDdJKIQQQgghhBD5JgmFEEIIIYQQIt8koRBCCCGEEELkmyQUQgghhBBCiHyThEIIIYQQQgiRb5JQCCGEEEIIIfJNEgohhBBCCCFEvklCIYQQQgghhMg3SSiEEEIIIYQQ+SYJhRBCCCGEECLfJKEQQgghhBBC5Nv/A/YPPa2HBOS/AAAAAElFTkSuQmCC\n"},"metadata":{}},{"output_type":"stream","name":"stderr","text":["INFO:root: Feature Importance\n","31 Haemoglobin (g/dL) 0.104576\n","40 Alkaline phosphatase (U/L) 0.102908\n","26 Performance Status* 0.082454\n","1 Symptoms 0.066788\n","21 Liver Metastasis 0.062477\n","47 Oxygen Saturation (%) 0.057565\n","46 Iron 0.054272\n","28 Ascites degree* 0.051462\n","39 Gamma glutamyl transferase (U/L) 0.042375\n","44 Major dimension of nodule (cm) 0.039364\n","INFO:root:Saved Feature Importance Plots at\n","INFO:root:/content/DemoOutput/demo_experiment/hcc-data_example/feature_selection/multisurf/TopAverageScores.png\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stderr","text":["INFO:root:Applying collective feature selection...\n","INFO:root:hcc-data_example Phase 4 Complete\n"]}],"source":["from streamline.runners.feature_runner import FeatureSelectionRunner\n","f_sel = FeatureSelectionRunner(output_path, experiment_name,\n"," feat_algorithms, class_label=class_label,\n"," instance_label=instance_label,\n"," max_features_to_keep=max_features_to_keep,\n"," filter_poor_features=filter_poor_features,\n"," top_features=top_features,\n"," export_scores=export_scores,\n"," overwrite_cv=overwrite_cv,\n"," random_state=random_state,\n"," show_plots=True)\n","f_sel.run(run_parallel=False)"]},{"cell_type":"markdown","metadata":{"id":"8e9Bk0SxFPIZ"},"source":["## Phase 5: Modeling\n","After cell runs, you will see:\n","* No output other than code progress bar completion"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":106808,"status":"ok","timestamp":1685752607344,"user":{"displayName":"ryan urbanowicz","userId":"09525282221743790591"},"user_tz":420},"id":"0hOuYSGfE5jB","outputId":"80457bca-a44f-479a-c01a-336bb04454f1"},"outputs":[{"output_type":"stream","name":"stderr","text":["100%|██████████| 18/18 [01:27<00:00, 4.87s/it]\n"]}],"source":["from streamline.runners.model_runner import ModelExperimentRunner\n","model_exp = ModelExperimentRunner(\n"," output_path, experiment_name, algorithms=algorithms,\n"," exclude=exclude, class_label=class_label,\n"," instance_label=instance_label, scoring_metric=primary_metric,\n"," metric_direction=metric_direction,\n"," training_subsample=training_subsample,\n"," use_uniform_fi=use_uniform_FI, n_trials=n_trials,\n"," timeout=timeout, save_plots=False,\n"," do_lcs_sweep=do_lcs_sweep, lcs_nu=lcs_nu, lcs_n=lcs_N,\n"," lcs_iterations=lcs_iterations,\n"," lcs_timeout=lcs_timeout, resubmit=False)\n","model_exp.run(run_parallel=True)"]},{"cell_type":"markdown","metadata":{"id":"d0sJWBScIDc4"},"source":["## Phase 6: Statistics Summary and Figure Generation\n","After cell runs, for each target dataset you will see:\n","* ROC and PRC plots of CV folds for each algorithm\n","* An ROC and PRC plot comparing average algorithm performance across CV partitions\n","* Boxplots for each metric comparing algorithm performance (across CV partitions)\n","* Top feature importance boxplots for each algorithm (across CV partitions)\n","* Histogram of feature importance for each algorithm\n","* Composite feature importance plots"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000,"output_embedded_package_id":"1FU3LQ2_69L36bskTcenO0sUjBFtLyoaG"},"executionInfo":{"elapsed":55528,"status":"ok","timestamp":1685752662870,"user":{"displayName":"ryan urbanowicz","userId":"09525282221743790591"},"user_tz":420},"id":"Nwcdh3W3IHc3","outputId":"4942dc7e-a5c5-4b22-c4b9-0f8c0796bc08"},"outputs":[{"output_type":"display_data","data":{"text/plain":"Output hidden; open in https://colab.research.google.com to view."},"metadata":{}}],"source":["from streamline.runners.stats_runner import StatsRunner\n","stats = StatsRunner(output_path, experiment_name,\n"," algorithms=algorithms, exclude=exclude,\n"," class_label=class_label, instance_label=instance_label,\n"," scoring_metric=primary_metric,\n"," top_features=top_model_features, sig_cutoff=sig_cutoff,\n"," metric_weight=metric_weight, scale_data=scale_data,\n"," plot_roc=plot_ROC, plot_prc=plot_PRC,\n"," plot_fi_box=plot_FI_box,\n"," plot_metric_boxplots=plot_metric_boxplots,\n"," show_plots=True)\n","stats.run(run_parallel=False)"]},{"cell_type":"markdown","metadata":{"id":"oqfgPhzBL0Xb"},"source":["## Phase 7: Dataset Comparison (Optional: Use only if > 1 dataset was analyzed)\n","Assuming STREAMLINE was run on more than 1 dataset. After cell runs, for each evaluation metric you will see:\n","* Boxplots comparing perfomance across analyized target datasets"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Qv7O5jc3LzvG"},"outputs":[],"source":["#@title Function to check length for more than one dataset case\n","def len_datasets(output_path, experiment_name):\n"," datasets = os.listdir(output_path + '/' + experiment_name)\n"," remove_list = ['metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n"," 'jobsCompleted', 'logs', 'jobs', 'DatasetComparisons', 'UsefulNotebooks',\n"," experiment_name + '_ML_Pipeline_Report.pdf']\n"," for text in remove_list:\n"," if text in datasets:\n"," datasets.remove(text)\n"," return len(datasets)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"executionInfo":{"elapsed":13112,"status":"ok","timestamp":1685752675980,"user":{"displayName":"ryan urbanowicz","userId":"09525282221743790591"},"user_tz":420},"id":"H_frEMK4KhPI","outputId":"28be9e17-3e25-4932-c76b-2a588a55a321"},"outputs":[{"output_type":"stream","name":"stderr","text":["INFO:root:Running Statistical Significance Comparisons Between Multiple Datasets...\n","INFO:root:Generate Boxplots Comparing Dataset Performance...\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAAyQAAALnCAYAAAB4AYOqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC5LklEQVR4nOzdeXxTVfrH8U+2Nk3TdIOWbkCLG+CCOoriCm4oiqLI4ALjhsoM6Kg4iuuIP0RHxxU33HAbcWZUVHB3HBBEBGSURVFoKXTf26RJuiT5/VEbqW2hdCGhfN+vV1+9ufece5+0hObJOc+5hkAgEEBERERERCQEjKEOQERERERE9l1KSEREREREJGSUkIiIiIiISMgoIRERERERkZBRQiIiIiIiIiGjhEREREREREJGCYmIiIiIiISMEhIREREREQkZJSQiIiIiIhIy5lAHsC8LBAL4/YFQhyHdxGg06PcpEsb0Gu09jEYDBoMh1GGISDdRQhJCfn+AioraUIch3cBsNhIfH01NjZvGRn+owxGR39BrtHdJSIjGZFJCItJbaMqWiIiIiIiEjBISEREREREJGSUkIiIiIiISMkpIREREREQkZFTULiIiIvsMn89HQ0NDqMMQ6dUsFgsmk6nD7ZWQiIiISK8XCAQoLCykqqqKgFZ/FulRBgPExcWRkpLSoSW6lZCIiIhIr1dYWEhlZRUxMXFERkYCWjZYpGcEqKuro7KyCoDU1NRd9lBCIiIiIr2az+ejqqopGYmJiQ11OCK9XkSEFYCqqiqSk5N3OX1LRe0iIiLSqzU0NBAI8MvIiIjsCZGRkQQCdKhmSwmJiIiI7CM0TUtkz+n4600JiYiIiIiIhIwSEhERERERCRkVtYuIiIjsJWbNupsPPngfgIyM/rz55tsYjU2fL7/99r/529/uA+COO/7K2WeP7fS5v/76226MetemTp3C2rVrgo8NBgNRUVGkp2cwcuQpTJr0B8xmyx6NSfYcjZCIiIiI7IW2b9/G559/GuowekQgEMDtdvPTT5t49tmnePTRv4c6JOlBYTdCUlxczCOPPMLSpUtxOp1kZGQwYcIEJk+eHPwEYGdycnJ46qmnWLFiBVVVVTgcDgYPHsz111/PoYceCsCBBx6403PMmTOH888/H4BJkybxzTfftNnuySef5NRTT93NZygiIiLSPebPf4FTTz29Qzef25W77rqHu+66pxui6pq3315ESkoK33yzkj//+U8EAgE++eRjZsy4NdShSQ8Jq4SkvLyciRMnUlBQENy3ZcsW5syZQ05ODvfcs/MXyerVq5kyZQput7vFOZctW8bo0aODCcmu2Gy2zj0BERERkT3EZDKxZctmvvxyCSeeeHK77Z566gm++eZriooKcTpdREVZ2X//A7n44ks54YSTgu1+O2Xr888/5fbbbwHgb397hBNP/LXt+eefQ0FBPkOGHMyLL74CwLZt23jppedYtWolVVVVxMfHM2LE8Vx99R9JTEzcredmMBgYPvwY4uLiqaysoL6+LnjM6XTy4IP3s2nTD5SXl+HxeImNjeWww4YxZcq1ZGUNYtWqlUyfPhWAW2+9g/POOz/Y/5JLJrBly2YGDdqP11//JwDl5WW88MJzfPXVMsrKSrHb7Rx11HCuvnoqGRn9g30/++wT/vGP18jL24bX6yU+PoEDDjiQSy6ZxLBhR+zWc5RfhdWUrSeeeCKYjMyePZsVK1YwcuRIABYsWMD333/fbt/6+npmzJiB2+0mLi6Oxx9/nDVr1vDVV1/x5JNPcsABBwTbbtq0qdVXVlYWAA6Hg5NOOqnV+adNm9aqj0ZHRERE9m6BQAC/3xeSr0Ag0KXYTznlNKBplGRnPvnkI3788Qeqqqrw+RpxuVysXbuGv/zlRlau/LrdfscffyJ2ux2Azz//JLh/48YNFBTkA3DWWWMA2Lz5Zy6//FI+/HAxZWVlNDY2UlpayrvvvsOVV06msrJyt55bIBBg9epvqK6uAmiRcDmdTj755ENyc7ficrnw+RqpqCjniy8+59prr6KiooKjjhrOgAEDAVi06N1g323btrFly+ZfYj8bgNLSUi677FLefvtfFBUV0tjYSFVVFZ9++jFXXjmZbdtyAVi37jvuvHMmGzeup6amhvr6eoqLi/jyyyVs2LB+t56ftBQ2IyR+v59FixYBkJmZyfjx4wG45ppr+OKLLwB477332h3l+OSTTygsLATg5ptv5owzzgDAbrfvMnFYsWIF2dnZAIwbN46oqKiuPyHZp9TX15GXV4nV6kDr3IuI7B0CgQBbtvyI210bkuvbbHYGDTqw09OtJkyYyPLly9i4cQMrV65ot93119/IoEH706dPHywWC5s3/8zUqVfh9Xp5661/Mnz4MW32i4yMZNSo03jvvXdYtuxL6uvriYiICNatmM1mTj31dAAeffTv1Na66Ncvhb/97WEGDszk++//x/XXT6OoqJDXXpvP9Ok3dOh5nX/+2S0ep6amccMNNwcfOxwxzJnzIEOHHkxcXDw+n49PPvmIOXPupaammk8++ZCJEy/hggsm8PDDf2P9+nXk5GSTmZnFf/7TFLvJZGb06LMAmDfvaUpLS7Db7Tz44CMMHXoIOTnZTJ8+lZqaap555knuu+9vfP/99wQCAWy2aF599Q369k2ipKSYb79dQ1JSUoeem7QtbBKS7du343Q6AYKjFb/d3rhxY7v9d6zz+PnnnznttNMoKiqif//+XHXVVYwbN67dvm+88QbQNDx40UUXtdnm1Vdf5dlnn8VisTB06FCmTJnS5kiK9F55edtxOmvaOdpIIODDYDASCJjb/eMSE+MgPT2j54IUEZHdtPd+iGS3x3DBBRfyyisvMX/+C5x22ug220VGRvLAA//Hzz//hNPpbDEyk5u7dafXOOusMbz33jvU1rr4+uuvOPHEk/nPfz4D4NhjjyMuLh6v1xNcIauoqJDJk1u/l1q9elUnnyUUFORz++238NRT84Cm511YWMhLL73A9u25eDyeFu1zc5tGNMaMOZtnnpmL2+3m/fff5brrbuA///kcgGOOOYbExD4ArFixDACXy8XUqVPajT0lJQUAj8fNCy88x+DBgxk0aH/OOONMIiMjO/38JIwSkoqKiuB28/Dgb7fLy8vb7d88OgIwf/784PbmzZu59dZb8Xq9bSYbJSUlfP550z/OY489lszMzDbPX11dDUBDQwOrVq1i1apVPPTQQ5xzzjm7eGY7ZzaH1aw5aUdlZQVjx56B3+9v83hmZib33HMPZrOZV155no8++qjNdiaTif/+dznx8Qk9Ga6I/IbJZGzxXQSaPogcNOhAAoG2/2/v+esbu1yMftFFl/LPf77B2rXfkpSU3Or4hg3r+ctfbqSxsbHN/nV1dW3ub3bYYYeTkpJKYWEBn3/+KX369KWwsGl6/ZlnNo1k1NQ48fl8Oz1PTU17H+i19vbbi0hNTSU/P4+bb76B7OwtfPvtatavX8fBBx/CG2+8xuOPP9xu/+bnFB1t54wzzuKdd/7Nhx8u5txzx/HTTz8CcNZZv75/q6ys2kXsTe8BTz55FOeccy4ffLCYDz54P1hvExMTw1//+n8cd9wJHX6O0lLYJCTt2TGL39mLdscXwsEHH8y8efMoKirikksuwePxMHfuXCZOnNjqHP/617+CL9K2EpbRo0fzxz/+kcGDB2MwGHj11Vd54oknAHjkkUe6lJAYjQbi46M73V/2nPj4aJYtW9buf6jbt2/n008/5cwzz2Ty5MlMmzYNs7n1y8vhcDBggEZIRELF4dCUXGnJYDBgMJhCHUanxcfHc+6543jzzTf47LNPWh1fuvSL4PucGTNuZezY84iIiOCMM0YF6zN2xmAwMHr0Wbz00vN8+eVSHI5YoOlN+PHHN70BdzgcmEwmfD4fxxxzLI8++mSr83SmXiYtLZ1jjx1BdvYWoGmk5OCDDwmO0ERGRvLUU89x0EGD2bo1h0sumdDqHOPHT+Cdd/5NZWUF990365d4Y1sU88fHx1FWVsaAAQN58823243daDRy++13c/31N/LTTz+xbVsuCxa8ztatOTzyyENKSLogbBKShIRfPzFunroFUFtb22ab34qLiwtun3vuuSQmJpKYmMhRRx3F0qVLKSsro6ysjL59+wbb+Xw+/vnPptUVkpOTGTVqVKvzXnLJJS0eT5s2jffff5+tW7eSn59PRUXFTuPaGb8/QE2Ne9cNJSw4HH1wOPq0eczvN7JhwwbGjj2XhoZ6PB4v++8/pM2kpLIyNHOVRfZlJpMRhyOKmhoPPl9oPg2X7uNwRGm0aweXXPIH3n773zQ0NLQ6Vl//6z6bzYbP5+PVV+d3KBlpduaZY3jppedxu2t5++1/A00F9REREQBYrVYOP/wIVq9excqVX7Nw4VvB6WM//LCBRYveY/jwYznzzDG79bzy8/NYseKr4OPmKVb19fW/7DFgs9lwuZw8//yzbZ5j0KD9OPzwI1i79lu+++5/AJx22unB2KFp6tn7779Lbu5WnnvuGX7/+4uJiLDw888/8dFHH5Cc3I/Jky9nzZpVbNq0iWOPHcFBBw1m//0PYPnyL9m6NYeqqt0r2peWwiYhycjIwOFwUFNTQ05OTnB/c7E5wJAhQ9rtP3jwYBYvXrzTa1it1haPv/jiC4qKigCYMGFCqzePfr+/zXufdMda380aG/WHsTfw+5s+PbFaozEYDNTX17FtWzYZGYO69d+LiHSNz+fX/7vS6yQlJTFmzDksXNj60/3jjz+BN954DYBZs+5i1qy7iI2NIyYmpsUHwDvTv/8Ahg49mA0b1uPzNY22NE/Xanb99Tdx7bVXUVvr4v77Z3P//bNbHP/d747u8PP5bVE7wH777c9hhw375TmdyKZNP1JX5+Wii5oWQUpPT2/3fBdcMIG1a3+98/yO07UApkyZytdfr6C0tIQXXpjHCy/Ma3H8yiuvBprKAx5//OE2p4sdc8yIjj05aVPYfLxgNBoZM6Ypc87JyeGtt96ioqKCZ5/9NeMdO3YsAKNGjeLAAw9k0qRJwWOjR48OJhTvvvsu5eXlbNiwgVWrmgqRBg8eTExMTItrNhezWywWJkxoPcy3adMmLr/8cpYsWYLL5aK6upq5c+cGE6aBAwd2enREeieDwUh6eiYGgwGXq4by8uJQhyQiIvuASZMuw2Rq/TnzkUcexcyZd5Kenk5kZCQHH3wIjz32JNHR9jbO0r4dRzfS0tKDyUGz/fc/gJdeeo0zzxxD3759MZnMJCQkcsghhzF16jSOPXb337CbzWbS0tIZP/73zJ37TPB93h/+cAUTJ15MfHwCNpuNUaNOZdasOe2e5+STRwZHVzIzsxg69OAWx5OSkpg//zUuuOBC+vVLwWw2ExcXx+DBQ7j88quCywMPGTKUs846m4yM/thsNiIjraSnZ3DJJZOYOfPO3X5+8itDoKuLYHej8vJyxo8f3+LGiM0mTpwYvDHiqFGjyM/P5+ijj+bVV18Ntpk7d26wvmNHFouF5557jmOPPTa4Lzc3lzPOOINAIMDo0aN57LHHWvX74YcfOO+889qM1Ww289RTT3VppS2fz09Fhabv9AZ5ebncdddMZs2aQ3r6ACoryygs3AbAgAH7Ex0ds4sziEhPMpuNxMdHU1lZqxGSXiAhIXq3pmx5vV62bMmmT59+RERoNaR9TVVVJePHn4vL5eK6627k4osvDXVI+4T6+jrKyooYNCir1Syl3wqbERKAxMREFixYwHnnnUdCQgIWi4VBgwYxc+ZM7r777l32nzZtGvfddx+DBw8mIiICu93OCSecwGuvvdYiGYGmGy0252IXX3xxm+fLyMhgxowZHHXUUfTt2xez2Ux8fDynnHIKb7zxhpb9lXbFxSUSG9s0epafv5XGxtbzekVERKTnlJSUMGHCOMaNOxuXy0VcXBznnnteqMOSNoTVCMm+RiMkvcdvR0gA/H4f2dmbqK/3Eh0dQ//++6meRCRENELSu2iERDqioKCA888/G7PZzKBB+3Hzzbdy8MFt32Bbut/ujJCETVG7SG9jNJrIyMgkO3sTtbVOysqK6Ns3JdRhiYiI7BNSU1P5+utvd91QQi6spmyJ9DaRkVGkpDTdd6S0tBCXq+M3hhIRERHZFyghEelhcXGJxMUlAk31JA0N9bvoISIiIrLvUEIisgf065dBZGQUPl8j+flbO3XHWhEREZHeSAmJyB5gNDbdn8RoNOJ2uygpab20tYiIiMi+SAmJyB4SGWklJaU/AOXlxTid1SGOSERERCT0lJCI7EGxsQnEx/cFoKBA9SQiIiIiSkhE9rDk5DSsVhs+n4+8vBwCAd0TQUREOmbWrLs55pgjOOaYI1izZvUevXbzdWfN2vXNqne0Zs1qnnvuGZ577hmcTmeLY88990zwvAUFXZ/O3Hyu5q8RI37HmWeews0338CPP/7Q5fPvbRYtei9k/152hxISkT3s13oSEx5PLcXFqicREZHe69tvV/PCC/N44YV5rRKSnub3+6msrOTLL5fwxz9OoaAgf49eXzpGN0YUCYGIiEhSUweQl5dNRUUJNpsdhyMu1GGJiIi0qyduMjhlyrVMmXJtt5+3X78UFi5cTHV1NffeezfLli3F7Xbz0UcfcMUVU7r9ervi9Xp3ebfynnD22WM5++yxe/y6u0sJiUiIOBxxJCQkUVFRQkFBLlZrFBERkaEOS0REeoH6+npee+1lPvnkIwoK8jGbLRx44EFccskkjj/+xGA7v9/P888/y8KFb+PxuBkx4nguuuhSrrrqDwBceeXVwYThmGOOAOCss87hrrvuAeCbb1Yyf/4LZGdvpra2lri4OAYN2o9x48Zz0kkjOe+8MRQVFQavd/75ZwO/JgzPPfcML7wwD4C3315EamoqABUVFcyf/wJfffUlxcXFREVFkZU1iOnTb2Do0IM7/HOIjY3l3HPHsWzZUgCKi4taHC8vL+OFF57jq6+WUVZWit1u56ijhnP11VPJyOgfbFddXcXf//4gy5YtITIyknPOOY/U1DTuv///AHjyyXkceeTvWLNmNX/609UAzJhxK1u3ZvPZZ5/g8/n49NMlAKxatZLXXnuZjRs34PV6SUlJZfToMUye/AfMZgsAHo+HefOeZunS/1JWVorFYiE5uR9DhhzMTTf9BavV2qE2ixa9x//9319bxAjgcjl58cXnWbLkC0pKmn6+Q4cewmWXXclhhw0LPu/m39/hhx/JxIkXM2/e0+Tl5dG/f3+uv/5Gfve7ozv8u9gZJSQiIZScnIbHU4vHU0teXg4DBx6A0aiZlCIi0nmNjY3ccMO0FjUD9fX1rF27hrVr1zBjxi2MH/97AF588TlefPG5YLvPP/+U77//X4euU1hYwM03/5m6urrgvtLSUkpLS0lPz+Ckk0Z2Kv7S0lKuuuoPLZKHhoYG/ve/teTkZO9WQgKw462/4uMTWlzniismUVpaEtxXVVXFp59+zMqVK3j++Zfp338AADNn/oVvv236ebrdbl555SX69u270+vOm/c0NTVNK2ra7XagqaZj9ux7WtyPbNu2XObNe4oNG77noYcew2Aw8Pjjj/DOO/8Otqmrq8Pl2syWLZv505+mY7VaO9SmLbW1Lq6++gqys7cE9zU0NLBixXK++eZr5sx5iBNPPKlFn59+2sStt84Ixv3zzz/xl7/cyDvvLCY2NnanP4eO0DsfkRAyGAykp2diMpnwet0UF2tuq4jInhQIBKivrw/JV0/dJPeTTz4KJiMnnTSSjz76nPnzXychIRGAJ598HKfTicvl5B//eBWA+Ph45s9/jcWLPyUjY0CHrvPDDz8Ek5GXXnqNL79cycKFi5k16z4OO+xwABYuXMyVV14d7PP224v4+utvWbhwcbvnnTfv6WAyctppZ/Duux/w6adL+NvfHiY9PX23fhbV1dW89947QFMN58knj2pxndLSEux2O08//RxLl37Nyy//A4cjlpqaGp555kmgaUSjORk55JDDWLToY159dcEuf391dXXcd9+DfPHFcp599kXcbjePPvoQgUCAY489jvfe+5D//vcrpk6dBsDy5cv46qtlAMGk8JRTTuOLL5bz6adLePHFV7nyyilYLBEdbtOWBQv+EUxGxo+fwKefLmHu3GeIjLTi8/l46KH78ftbLrhTW+viiium8NlnS7j88quApsRsxYrlO/8FdJBGSERCzGKJIDV1INu3b6GyshSbLZrY2IRddxQRkS4JBALMm/ck27blhuT6AwYMZMqUP2IwGLr1vDu+Sbzmmj8SFxdPXFw8Y8eex/z5L+DxePjf/74lJiYGt9sNNE3DOuigIQBcfvmVwTfgO5OSkhLcnj//BYYNO5ysrEEcd9wJREdHdyH+pjfldrud22+/O/hJ/4knntzhcxQVFQanmAE4HLH8+c83cdBBg1tdx+VyMXVq67qS1atXAbBu3ffBfZdffiV9+vSlT5++nHPOebz00vPtxnDWWWMYNeoUAAYN2o+VK1fgcrl+ufZyxo49s81rHnfcCfTr148tWzbz/ff/46WXniczM4uDDhrMlClTg2070qYtzf8+jEYjU6dOJzo6mt/97mhOPnkkH3/8ISUlxWRnb2G//fYP9klISOTKK6/GaDRy+umjg8/7t1PgOksJiUgYiImJJTExmfLyYgoLt2G12oiM3PPFbyIi+5ruTgbCQVVVVXA7OTm5ze2qqkq8Xm/wcVJScpvbOzN48BAuu+xK3njjdZYs+YIlS74Amm4EfOONN3PuueM6FX9lZVP8/fqldFsheGNjA3V13hb7mq/TnubpVqWlpcF9ffsmBbeTkpJa9dnRfvsd8JvrVe4yzuZrTp9+A0VFRWzZsplXXnkpeHzIkKE89thTxMTEdKhNW5r/fdjt9haJY3Jyvx3atIw1LS09OKU8MvLXetf6+u65n5oSEpEwkZSUisdTi9vtIi8vm8zMg1RPIiLSgwwGA1Om/JGGhoaQXN9isfRIQhQXFxfcLikpITOzqX6huLg4uD82Nh6H49c3rGVlv77p3rHdrlx77Z+47LIr+Omnn9i+fRsLF77FunXf8/DDDzJmzDmYzebdfo7x8XGUlZVRVFRIXV1dizfAHdWvXwrvvLOIn3/+iRkz/kxJSTEPPng/++9/AAcffGiL6wwYMJA333y71Tmap2TtWCtSVlbK/vs3JRq7+jn9Nu74+Pjg9h//OJ3Jky9v95oDB2by+uv/JD8/j5ycbH788Qdeeul5Nm7cwL///SaXX35Vh9q0JS4ujry87bhcLtxuNzab7Zfn8+toR2xsXIs+ZvOOKUP3/5vVux2RMGEwGEhLG4jJZKauzktR0fZQhyQi0usZDAYiIiJC8tXVZGTjxvWsWLG8xVd1dTXHHDMi2GbevKeprq7ip5828f777wJgtVoZNuxw9ttvf2y2pk/IP/yw6c178+pWHbF588+8+OJzbNu2jaysLEaNOpX99z8QgLo6b3A6WEyMI9gnO3vzLs87YsQJQNNUqvvum0VJSTG1tS6WLVvK2rVrOhQbNP1uDzjgQG688WagaUWxJ554NHj82GOPAyA3dyvPPfcMNTU1eL0e1q37jgcfnMOrr84HaLHq1KuvvkxFRQU///xT8OfZUYcccliwuP2NN15jzZpV1NfXU1FRwWeffcK1115JYWHhL9eZz3//+x9MJhPDhx/LKaecRkREU11I8+hFR9q0pfnfh9/v5+mn5+JyOVmzZlVwhCspKZlBg/bbrefWVRohEQkjFksEaWkD2bZtM1VV5dhsduLiEkMdloiIhKEnn3y8jX3zOOOMM1m06F3Wrv2WL774nC+++LxFmz/+8TocjqYk4ZJLJvHcc89QVlbGpEkTAejTp0+w7c6SpurqaubNe5p5855udWzo0IOD1xgyZEhw/4wZfwbgjDPO5J57Zrd53quvvpaVK1dQXFzExx9/yMcffxg8dscdf+Xww49sN6a2nHzyKIYMGcrGjRv47rv/sXLlCoYPP5YpU6by9dcrKC0tCd64cUfNxfhHHnlUcEnfb79dzVlnnQp0/OfUzGaz8ec/38Ts2bOorKzkT3+6pt22X321nLVrW/9+AYYPH9HhNm2ZOPFiPv30Y3Jzt/Kvfy3gX/9aEDxmMpm46aa/7PEZGhohEQkzdruDvn2bCgULC7fj9XpCHJGIiOxNzGYzjz76JFdeeTUDBgzEYrFgs9kYNuxw/va3h5kwYWKw7eWXX8UVV0whPj4Bq9XKSSeN5JZbbg8edzjaX9I1IyOD8847n6ysQdjtdiIiIkhJSeW8887nb397ONjukEMOY+rUaSQn9+vQG90+ffry0kuvMWHCRaSlpWOxWIiJiWHYsMPJzMzq1M/kmmv+GNx+9tmmBCopKYn581/jggsupF+/FMxmM3FxcQwePITLL7+Ks846O9jnvvv+xumnjyYqKoq4uDguvngSF17468+xOfnalbPPPpfHH3+KY445FofDgcVioV+/fowYcTwzZ94ZnB42Zsw5DB9+DH379sViseBwxHLIIYdy771zGDHiuA63aYvdHsNzz81n4sRLSE1Nw2w2ExMTwzHHHMvcuc90ernmrjAEemrNOdkln89PRUVtqMOQbpCXl8tdd81k1qw5pKd3bLnEnQkEAmzbtpnaWicREVaysg7EaDR1Q6Qi+yaz2Uh8fDSVlbU0Nvp33UHCWkJCNCZTxz9T9Xq9bNmSTZ8+/XQD2t/Iz8+jrq6OrKxBQNPyrrNnz+I///kMgNdee7PFakv7qo0bN5CcnExiYtOoSEFBPn/+8zS2bcslPj6BRYs+xmTS3+kd1dfXUVZWxKBBWbtcnEBTtkTCUHM9SXb2j9TXeyks3EZq6sBeuRqMiIiEzsaNG7jzzpnYbNHY7XYqKsppbGwE4IILLlQy8ov331/IO++8RVxcHCaTmYqKcgKBAEajkRtvvFnJSBcpIREJU2azhbS0geTm/kx1dSU2Wwzx8X123VFERKSDBg7M5JhjRvDTT5soLy8nKsrKfvvtzznnnMeYMeeEOrywceSRR/Hzzz+xbVsuTmcVcXHxHHroYVx00aUMG3Z4qMPb6ykhEQlj0dExJCWlUlJSQFHRdqKibFittlCHJSIivcT++x/Ao4/ODXUYYe/UU0/n1FNPD3UYvZaK2kXCXGJiMna7g0AgQF5eDj6fL9QhiYiIiHQbJSQiYc5gMJCaOhCz2UJ9fR2FhbloLQoRERHpLZSQiOwFzGYz6elNSx3W1FRRWVm6ix4iIiIiewclJCJ7CZstmuTkdACKivLxeLRktIiIiOz9lJCI7EUSEvoSExMLNNeTNIY6JBEREZEuUUIishdpqicZgMUSQUNDPfn5qicRERGRvZsSEpG9jMnUVE9iMBhwuaqpqCgJdUgiIiIinab7kIjshaKibCQnp1NUtJ3i4nyioqKx2eyhDktERHrYrFl388EH7wNNo+YWi4WYGAfp6ekcf/yJjBt3AXZ7TI9df+rUKaxdu4Z+/VJYuHBxh/vtGPfXX3/bU+G1UlBQwPnnn92htm+/vYjU1NQejkjaohESkb1UfHwfHI54APLycmhsbAhxRCIisicFAgHq6+spLy/ju+/+x5NPPs6ll04kJyc71KGJ7BaNkIjspQwGAykp/fF63dTX15Gfn0v//oMwGAyhDk1ERPaAJ5+cx2GHHUZubi4vvfQ8n332CUVFhdx00/W8/vo/iYqK6vZrPv30c53qd9dd93DXXfd0czS7lpqa2mJEZtGi9/i///srAFdeeTVTply70/4NDQ2YTCaMRn2G35OUkIjsxUwmE+npmeTkbKK2toaysmL69u0X6rBERGQPMZstDBq0H//3f/dTXFzEunXfU1CQz/vvv8uECROBpjfV//jHq3z88Yfk5+dhMpkYPHgIl112JUcdNbzF+b79dg2vv/4y69evp7bWRUJCIocdNox7750DtD1la/v2bTz77FN8991aqqqqiI6OJiOjP8cffyJ/+MMVQPtTtnJzt/LCC/NYvXoVNTXVxMfHM3z4sVx11TX065cCtJx2dcUVU7BYLLzzzlu4XC4OOeQQbrnlji5PtdrxGpdffhUGg4H3319IWVkZn3zyX2JiYvjxx4289NILfPfdWlwuF337JjFy5ClcddU12Gy24Llqa1289NILLFnyBUVFhVitVg49dBhTplzLQQcN7lKcvZUSEpG9nNVqo1+/DAoLt1FaWoDNFk10dM/NHxYR6V0CgDtE17YB3Teq/fvfX8y6dd8DsGLFciZMmIjP5+PGG69j1aqVLdquWbOab79dw6xZ93HaaWcA8MEHi7j33rtbrN5YUlLMp59+HExI2jJjxp/Jzd0afFxVVUVVVRW1tbXBhKQtP//8E9dccwVu968//9LSUhYteo/ly7/khRdebZVo/POfb+ByuYKPV678mrvvvp3nnntpJz+Z3fPWW/+ipqa6xb6VK79mxozraWj4dXp0YWEB//jHq3z77WqeffZFIiMjcbvdXH31FWzZsjnYrqGhgeXLv2TVqpU8/vjTDBt2eLfF2lsoIRHpBeLiEnG7XVRXV5Cfn0NW1mDMZkuowxIRCXMBYmJOw2z+OiRXb2w8FqfzE7orKenff0Bwu7CwAIBPPvkomIzcfPNMxow5m5oaJ7ff/hfWrfueRx/9O6NGnUp9fT0PP/w3AoEAZrOZ2267i5NOOpmamho+/PCDdq9ZXV0VTEauv/5Gxo//PTU1NWze/DM//fTjTuN99NGHgsnI3Xffy4knnsTChe/wxBOPUFlZyTPPPMmsWbNb9Kmrq+PBBx/hsMMO5/bbb2HVqpWsW/cdJSUlJCUl7fbPrC1OZw233HIbp59+JqWlJURFWXnwwTk0NDRw4IEH8X//dz/Jyf34/PNPueeeO/nxxx94//2FjB//exYs+AdbtmzGZDJx331/49hjj6OoqIgbb5xOXt52Hnvs77z00mvdEmdvooREpBdoqifJwOt1U1fnJS8vhwED9lc9iYjILvWe/yf9fn9wu/n//xUrlgf3PfjgHB58sOVIR3l5GTk52ZSXlwVHHsaMOYezzmqavhQdbeeKK65q95p2ewzR0XZqa1188slHeDxesrKyOPjgQxg+/Jh2+3m9Hv73v7UADB48hDPPHAPAxRdfyptv/oOSkmK+/vqrVv1OPPFkTjjhJABOPnlUMNkqLi7stoRk+PBjGDduPADR0Zls25ZLXt52ADZt+pELLzyvVZ/Vq1cxfvzvWbFiGQA+n49bbrmpVbsffthIba2L6GitjLkjJSQivYTR2FRPkp29CbfbRWlpIUlJWr5QRKR9hl9GKHrHlK3t27cFt1NSmv7/r6ys3GW/mpqaFu0GDszs8DVNJhN33HE3Dz54Pz/8sJEfftgINCVE55xzHrfddmc713Ti8/kASEpKDu43GAwkJSVRUlJMTU11sE2z9PSM4HZkZERwu76++1aa3G+/A1o87ujPcHfaKiFpSQmJSC8SGRlFamp/8vO3UlZWhM1mx253hDosEZEwZgCiQx1Et3jzzX8Et0eMOA6A+Pj44L7Fiz8hMbFPiz6BQACDwcDKlSuC+3asB+mIkSNP4aSTRrJly2a2bctl2bKlfPjhYt577x3GjDmHww4b1qqPwxGDyWTC5/NRWvrrDX4DgQAlJSW/tHFgMpla9DObd3zr2jOjW5GRkS0e7/gzHDfuAm655fZWfZrrbuLj48nL247NZuOTT75oNX26+ectLWkNM5FeJjY2gbi4pj84+flbaWioD3FEIiLSUxobG9iyZTN33jmT9evXAZCWls7ZZ48F4NhjRwTb3n//bAoLC2hoaCAnJ5v581/gzjtnAnDoocOIiWlaEGXx4vf58MPF1NbWUlxcxEsvPb/TGB566AH+97+1JCb24cQTT+boo3+dqlVV1faIgdUaxWGHNRV3b9y4gY8//pDa2loWLHidkpJiAI45ZkSbffe0/v0HkJ6eDjQV/v/3v//B6/VQXV3NsmVLmTHjz6xd27Ry2LHHNiWCbrebBx+8n/Lycurq6ti06UeeeuoJHnnkoZA9j3CmERKRXqhfv3S83lq8Xg95eTkMHHiAPpEREell/vSnq1vtS0lJ5aGHHsVqbboHyemnn8nixYtYvfobvvxyCV9+uaRF+8MPPxKAqKgobrjhZu69924aGhq4556WU60uv7z9OpJ///tN/v3vN1vtt9vtHHzwIe32u/76G7n22ivxeDzcfXfLUYe4uDiuvfZP7fbd026++TZuuuk66urquPXWGa2OX3TRpUDTSmeff/4pW7Zs5t133+Hdd99p0e6ss87ZI/HubZSQiPRCRqPxl3qSH/F4aikpKSA5OS3UYYmISDezWCw4HLGkp6dzwgkncd5552O3/7r0u8lk4pFHnuCNN17j448/JC9vOyaTmaSkJA4//AhGjx4TbHvWWWfTr18Kr7/+MuvWrcPtriUhIZFDDz1spzFMmnQZ3367mvz8PFwuF7GxcQwZMpQrrpjSaorYjg488CBefPFVXnhhHmvWrKampob4+DiOPrrpPiRdvbdIdxo+/Bief34+8+e/yHffrcXpdBIfn8CAAQM44YSTOeiggwCIjo5m3rwXmT//RZYs+YLCwgKsVivJyf343e+OZswYJSRtMQR2XGxa9iifz09FRW2ow5BukJeXy113zWTWrDmkpw/YdYc9pKamkry8HAAyMgYRExMb4ohEQsNsNhIfH01lZS2Njf5dd5CwlpAQjcnU8VnnXq+XLVuy6dOnHxERkbvuICJdVl9fR1lZEYMGZWG1WnfaVjUkIr2YwxFPQkJfoKmepL6+LsQRiYiIiLSkhESkl0tKSsNqteH3+8jLyyEQ0KfDIiIiEj6UkIj0cs31JEajCa/XTXFxfqhDEhEREQkKu6L24uJiHnnkEZYuXYrT6SQjI4MJEyYwefJkjMZd5085OTk89dRTrFixgqqqKhwOB4MHD+b666/n0EMPBeDtt99m5syZbfY/5ZRTeOqpp1rsW7JkCU8//TQ//vgjRqORYcOGcd111zFs2LAuP1+RPSEiIpK0tAFs355NRUUpNpsdhyN+1x1FREREelhYJSTl5eVMnDiRgoKC4L4tW7YwZ84ccnJyuOeee3baf/Xq1UyZMgW3+9c7rpaXl7Ns2TJGjx4dTEh2x6JFi5gxYwY71v4vX76cVatW8eKLL3LUUUft9jlFQiEmJo7ExCTKy0soKMjFarWpuFNERERCLqymbD3xxBPBZGT27NmsWLGCkSNHArBgwQK+//77dvvW19czY8YM3G43cXFxPP7446xZs4avvvqKJ598kgMOOKBVn7S0NDZt2tTia8fREa/Xy7333ksgECA1NZVPPvmEf//738TExFBfX89f//rX7v0BiPSwpKQ0oqKi8fv95OVl4/ernkRE9iVaWFRkz+n46y1sEhK/38+iRYsAyMzMZPz48SQkJHDNNdcE27z33nvt9v/kk08oLCwE4Oabb+aMM87AbreTmJjIqaeeymGH7XwN7bYsXbqUqqoqAC666CIGDBjAIYccwllnnQXA5s2b2bhx426fVyRUDAYD6emZmExmvF4PxcV5oQ5JRKTHWSwWDAaoq9NKgyJ7Sl1dHQZD0+tvV8Jmytb27dtxOp0AZGVlBffvuL2zN//ffPNNcPvnn3/mtNNOo6ioiP79+3PVVVcxbty4Vn1KSkoYPnw4tbW1pKWlcdZZZzF16lQiIiIA2LBhQ5tx7Li9YcMGhgwZsjtPVSSkLJYI0tIGsG3bFiory7DZ7MTGJoQ6LBGRHmMymYiLi6OysgqAyMhIwBDSmER6rwB1dXU4nVXEx8dhMpl22SNsEpKKiorgtt1ub3O7vLy83f7NoyMA8+fPD25v3ryZW2+9Fa/Xy0UXXdSiT0NDQ3AEZOvWrTz11FN8//33vPDCCwBUVlYG20ZHR7e5vWPcnWE2h80glXSB0WgIft8bfqdxcfF4vSmUlBRSWLiN6OhorNaoUIcl0mOab6K3OzfTk94lJSUFgKqqKn75/FNEeojBAPHxccHX3a6ETULSnh2LyQ2G9j/N8Pl8we2DDz6YefPmUVRUxCWXXILH42Hu3LlMnDgRg8HAgAEDmD17NsceeyyJiYl899133HjjjZSVlbFs2TJWrlzJ8OHDOxTfzmLaFaPRQHx89K4bStgrL28qDo+OjtxrfqdxcftTX++hqqqKvLwcjjjiiA59iiGyN3M4lHjvqwwGA6mpqSQnJ9PQ0BDqcER6NYvFslvvKcImIUlI+HXKiHOHjy5qa2vbbPNbcXFxwe1zzz2XxMREEhMTOeqoo1i6dCllZWWUlZXRt29fjjzySI488shg++HDhzN58mQefvhhANatW8fw4cOJj/91WVSXy9VmTDu22V1+f4CaGveuG0rYq62tC36vrKzdRevwkZIyAJfLhdvtZsOGH8jIyAx1SCI9wmQy4nBEUVPjwefTYg57O4cjqtOjXSaTSR++iISZsElIMjIycDgc1NTUkJOTE9yfnZ0d3N5ZrcbgwYNZvHjxTq9htVqBpgL6397TZMeRjubtoUOHBve1F9OObTqjsVF/GHsDvz8Q/L43/U4NBhNpaZnk5v5MZWU5UVF24uISQx2WSI/x+fx71WtURGRfEDaTaY1GI2PGjAGa3vy/9dZbVFRU8OyzzwbbjB07FoBRo0Zx4IEHMmnSpOCx0aNHYzY35Vfvvvsu5eXlbNiwgVWrVgFNCUtMTAwAU6dO5ZVXXqGgoIC6ujpWrlzJyy+/HDzXEUccAcCJJ54YHHl54403yM3NZd26dXzwwQcA7Lfffipol71edHQMffs2zfEsLNyG1+sJcUQiIiKyLwmbERKA6dOns2TJEgoKCrjttttaHJs4ceJOb2yYkZHB1KlTeeKJJ1i/fj0jRowIHrNYLNxyyy3Bx0VFRcyePZvZs2e3Os/ZZ5/N4YcfDjSNqNx5553MmDGDgoICTj/99GC7iIgI3YdEeo0+ffrhdtdSW1tDXl42mZkHaUqDiIiI7BFhlZAkJiayYMECHn74YZYuXYrT6aR///5MmDCByZMn77L/tGnTSElJ4dVXX2XLli1ERERw+OGHM23aNIYNGxZsd91117F48WLWrVtHSUkJBoOBrKwsLrjgglYrcZ199tnExMTw9NNP8+OPP2I0Ghk2bBjXXXddi3OK7M0MBgNpaQPIzv6R+vo6Cgu3kZY2sEuLNoiIiIh0hCGw4zJWskf5fH4qKvaeAmhpX15eLnfdNZNZs+aQnj4g1OF0mtvtYuvWnwDo1y+DhIS+IY5IpHuYzUbi46OprKxVDUkvkJAQrSWcRXoRvZpFJMhms5OUlAZAcXEeHo9WgRMREZGepYRERFpITEzCbo8lEAiQl5fd4h4/IiIiIt1NCYmItNBcT2KxRNDQUE9BQS6a2SkiIiI9RQmJiLRiMplJT88EDDidVVRUlIY6JBEREemllJCISJuioqLp1+/XehK3WwswiIiISPdTQiIi7YqP70tMTBwA+fk5+HyNoQ1IREREeh0lJCLSLoPBQGrqACyWSBoa6snP36p6EhEREelWSkhEZKdMJhPp6ZkYDAZcrhrKy4tDHZKIiIj0IkpIRGSXoqJs9OuXAUBJSQG1ta4QRyQiIiK9hRISEemQuLhEYmPjgaZ6ksbGhhBHJCIiIr2BEhIR6RCDwUBKSn8iIiJpbGxQPYmIiIh0CyUkItJhRqOJ9PQsDAYDtbVOysqKQh2SiIiI7OWUkIjIbrFao0hJ6Q9AaWkhLldNiCMSERGRvZkSEhHZbXFxicTFJQKQn7+VhgbVk4iIiEjnKCERkU7p1y+DyEgrPl8j+fk5qicRERGRTlFCIiKdYjQaSU/Pwmg04na7KC0tDHVIIiIishdSQiIinRYZaQ3Wk5SVFeF0Voc4IhEREdnbKCERkS6JjU0gPr4PAAUFW2loqA9xRCIiIrI3UUIiIl2WnJyO1RqFz+cjL0/1JCIiItJxSkhEpMt+rScx4fHUUlycH+qQREREZC+hhEREukVERCSpqQMAqKgowemsCm1AIiIisldQQiIi3cbhiCMhIQmA/Pxc6uvrQhyRiIiIhDslJCLSrZKTU4mKsuH3N9WT+P3+UIckIiIiYUwJiYh0K4OhqZ7EZDLh9bpVTyIiIiI7pYRERLqdxRJBaupAACorS6murgxtQCIiIhK2lJCISI+IiYklMTEZgMLCXOrqvCGOSERERMKREhIR6TFJSanYbHb8fr/qSURERKRNSkhEpMcYDAbS0gZiMpmpq/NQVLQ91CGJiIhImFFCIiI9ymKJIC1tIABVVeVUVZWHNiAREREJK0pIRKTH2e0O+vTpB0Bh4Xbq6jwhjkhERETChRISEdkj+vZNITo6hkCguZ7EF+qQREREJAwoIRGRPaK5nsRsNlNX56WwcDuBQCDUYYmIiEiIKSERkT3GbLaQlpYJQHV1hepJRERERAmJiOxZ0dExJCWlAlBUtB2v1x3iiERERCSUlJCIyB6XmJiM3e4gEAiQl5eDz6d6EhERkX2VEhIR2eMMBgOpqQMxmy3U19dRWJirehIREZF9lBISEQkJs9lMenpTPUlNTRWVlWUhjkhERERCQQmJiISMzWYnOTkNgOLiPDye2hBHJCIiInuaEhIRCamEhCRiYmJ3qCdpDHVIIiIisgcpIRGRkGqqJxmAxRJBQ0M9BQWqJxEREdmXKCERkZAzmZrqSQwGA05nNRUVJaEOSURERPYQJSQiEhaioqJJTk4HoLg4H7fbFeKIREREZE9QQiIiYSM+vg8ORxwAeXk5NDaqnkRERKS3U0IiImHDYDCQkjKAiIhIGhsbKCjYqnoSERGRXk4JiYiEFZPJFKwncblqKC8vDnVIIiIi0oOUkIhI2LFabfTrlwFASUkBtbXOEEckIiIiPcUc6gB+q7i4mEceeYSlS5fidDrJyMhgwoQJTJ48GaNx1/lTTk4OTz31FCtWrKCqqgqHw8HgwYO5/vrrOfTQQwH4z3/+w+LFi1m/fj2lpaWYTCb69+/PxRdfzLhx41pc59Zbb+Wdd95p81ozZ87ksssu65bnLSItxcUl4na7qK6uID8/h6yswZjNllCHJSIiIt0srBKS8vJyJk6cSEFBQXDfli1bmDNnDjk5Odxzzz077b969WqmTJmC2+1ucc5ly5YxevToYELy+uuvs2zZshZ9169fz2233cb69eu5++67u/FZiUhnNNWTZOD1uqmr85Kfv5X+/ffDYDCEOjQRERHpRmE1ZeuJJ54IJiOzZ89mxYoVjBw5EoAFCxbw/ffft9u3vr6eGTNm4Ha7iYuL4/HHH2fNmjV89dVXPPnkkxxwwAHBtpGRkVx22WUsWrSI7777jsceewyzuSk3e+ONNygvL291/nHjxrFp06YWXxodEelZRmNzPYmR2lonpaWFoQ5JREREulnYJCR+v59FixYBkJmZyfjx40lISOCaa64Jtnnvvffa7f/JJ59QWNj0ZuXmm2/mjDPOwG63k5iYyKmnnsphhx0WbPu3v/2NmTNnsv/++2O1Whk9ejQnnHACAIFAgG3btvXEUxSRToiMjCIlpamepKysCJerJsQRiYiISHcKm4Rk+/btOJ1NhatZWVnB/Ttub9y4sd3+33zzTXD7559/5rTTTuOQQw5hzJgxrWpA7HZ7q/51dXXB7eTk5FbHP/30Uw477DAOO+wwxo8fz8KFC3f9pESkW8TFJRIXlwhAfv5WGhrqQxyRiIiIdJewqSGpqKgIbu+YMOy43dZUqmbNoyMA8+fPD25v3ryZW2+9Fa/Xy0UXXdRm31WrVvH1118DMGLECFJTU1u1cbl+vWv0unXruOWWWyguLm4xgtMZZnPY5ITSBUajIfhdv9OekZ4+AK/XjdfroaBgK1lZB6qeRDrMZDK2+C4iIuEjbBKS9ux4U7Sdvfnw+XzB7YMPPph58+ZRVFTEJZdcgsfjYe7cuUycOLHVOb7//nv+9Kc/4ff7SU5OZs6cOS2OH3vssZxxxhkccsghWK1WPvzwQ+666y78fj9PPfUUkydPJioqqlPPzWg0EB8f3am+El7KyyMBiI6O1O+0B0VFHcy3335Lba2LqqqSFiOoIh3hcHTu/2sREek5YZOQJCQkBLebp24B1NbWttnmt+Li4oLb5557LomJiSQmJnLUUUexdOlSysrKKCsro2/fvsF23377LVOmTMHlcpGUlMT8+fPp169fi/Oee+65LR5feOGFfPTRRyxbtgyv18vPP/8cXL1rd/n9AWpq3LtuKGGvtrYu+L2ysnYXraUr0tIGsG1bNtu3b8dkisThiAt1SLIXMJmMOBxR1NR48Pn8oQ5HusjhiNJol0gvEjYJSUZGBg6Hg5qaGnJycoL7s7Ozg9tDhgxpt//gwYNZvHjxTq9htVqD29988w3XXHMNbrebtLQ0Xn75ZTIyMlq0bx6d2dnITFenjDQ26g9jb+D3B4Lf9TvtWXZ7HPHxfamsLGXbthyysg4iIiIy1GHJXsLn8+s1KiISZsLm4wWj0ciYMWOAppsbvvXWW1RUVPDss88G24wdOxaAUaNGceCBBzJp0qTgsdGjRweX7n333XcpLy9nw4YNrFq1CmhKWGJiYgBYvnx58H4lAwcO5B//+EerZASaRmouvPBCPvzwQ6qqqnC5XPzrX//iq6++AprqW3ZcTlhE9ozk5DSsVht+v4/8/BwCAb3BFBER2VuFzQgJwPTp01myZAkFBQXcdtttLY5NnDhxp1OjMjIymDp1Kk888QTr169nxIgRwWMWi4Vbbrkl+PiZZ57B6/UCsHXrVk466aQW55ozZw7nn38+0FTA/uc//7nNa/7lL38hMlKfzIrsaUajkfT0TLKzf8TjcVNcXEC/fumhDktEREQ6IWxGSAASExNZsGAB5513HgkJCVgsFgYNGsTMmTM7dPf0adOmcd999zF48GAiIiKw2+2ccMIJvPbaaxx77LG7HY/NZuPOO+/k+OOPp1+/flgsFhwOB8cddxzPP/88v//97zvzNEWkG0RERJKWNgCAiooSamqqQhuQiIiIdIohsOMyVrJH+Xx+KipUAN0b5OXlctddM5k1aw7p6QNCHc4+pagoj4qKEoxGk+pJpF1ms5H4+GgqK2tVQ9ILJCREq6hdpBfRq1lE9mrJyWlERUXj9/vIy8vG79ebTRERkb1JWNWQiIRKcXFhsK6os/0BCgryu7ykqNVqJTk5pUvn2JcYDIZf6kl+wOv1UFycR0pK/1CHJSIiIh2kKVshpClb4aG4uJCZM28KdRgtzJnzdyUlu8nlqmbbti0ApKUNJDa2/fsWyb5HU7Z6F03ZEuldNEIi+7zmkZEpU/5Iampap85hMhkxGBoJBMxdGiEpKMjnueee6tJozb7Kbo+lT59kysqKKSzchtVqIzLSuuuOIiIiElJKSER+kZqaxoABmZ3qq09fw0Pfvqm43bW43S7y8rLJzDwIo1GfooqIiIQz/aUWkV7DYDCQlpaJyWSmrs5LUdH2UIckIiIiu6CERER6FYvFQnp600hXVVU5VVXlIY5IREREdkYJiYj0OtHRMfTt27QoQGHhNrxeT4gjEhERkfYoIRGRXqlPn35ER8cQCAR+uT+JL9QhiYiISBuUkIhIr9RUTzIQs9lCfX0dBQXb0CrnIiIi4UcJiYj0WmazhbS0pnqSmppK1ZOIiIiEISUkItKrRUfbSUpKBaCoaDsejzvEEYmIiMiOlJCISK+XmJiM3e74pZ4kB59P9SQiIiLhQgmJiPR6zfUkFksEDQ11FBTkqp5EREQkTCghEZF9gslk/qWexIDTWUVlZWmoQxIRERGUkIjIPsRmiyY5OQ2AoqJ8PJ7aEEckIiIiSkhEZJ+SkNCXmJg4oLmepDHUIYmIiOzTlJCIyD7FYDCQmjrgl3qSevLzt6qeREREJISUkIjIPsdkMpGenoXBYMDlqqG8vCTUIYmIiOyzlJCIyD4pKspGcnI6ACUl+bjdrhBHJCIism9SQiIi+6z4+D44HPEA5OXl0NjYEOKIRERE9j1KSERkn2UwGEhJ6U9ERCSNjQ2qJxEREQkBJSQisk/bsZ6kttZJWVlRqEMSERHZpyghEZF9ntUaRUpKfwBKSwuprXWGOCIREZF9h7kznX788UfWrFnDli1bqKysxGAwEB8fT1ZWFkcccQSDBw/u7jhFRHpUXFwitbVOqqsryMvLYdCgwZjNllCHJSIi0ut1OCEpLy/nH//4BwsXLqSgoIBAIIDFYiE2NpZAIEBNTQ0NDQ2/zMlOYdy4cVx00UX06dOnJ+MXEek2KSn98Xrd1NV5ycvLYcCA/TEYDKEOS0REpFfrUELy4IMP8o9//IPo6GhGjx7NiBEjGDp0KMnJyS3aFRcXs2HDBpYvX84///lPXnzxRS699FJuuummHgleRKQ7GY1G0tOzyM7+EbfbRWlpIUlJqaEOS0REpFfrUEKyevVqHnzwQU455ZSdflqYnJxMcnIyo0aN4o477uDzzz/n+eef77ZgRUR6WmSkldTU/uTnb6WsrAibLRq7PTbUYYmIiPRaHUpI3nzzzd0+scFg4NRTT+XUU0/d7b4iIqEUG5uA2+2isrKM/PytZGUNxmKJCHVYIiIivVKHV9n64osv8Pl8PRmLiEjYSE5Ox2qNwufzkZeXo/uTiIiI9JAOJyRTp07l+OOPZ9asWaxdu7YnYxIRCbmmepJMjEYjHk8tJSX5oQ5JRESkV+pwQjJr1iz2228/FixYwMUXX8wpp5zCo48+ypYtW3oyPhGRkImIsJKaOgCA8vISnM6q0AYkIiLSC3U4IZkwYQKvvvoqX3zxBTfffDOxsbE888wznH322YwbN46XXnqJ4uLinoxVRGSPczjiSUjoC0B+fi719XUhjkhERKR32e07tScnJ3PFFVfw9ttv8+GHHzJ16lTcbjcPPPAAI0eO5A9/+ANvvfUWLperJ+IVEdnjkpPTsFpt+P3N9ST+UIckIiLSa+x2QrKjzMxMrrvuOj7++GP++c9/MmnSJLKzs7njjjs4/vjjuytGEZGQMhia60lMeL1uiotVTyIiItJdupSQ7Cg9PZ2MjAz69etHIBCgrk7TGkSk94iIiCQtbSAAFRWl1NRUhjYgERGRXqJD9yFpT21tLZ9++invv/8+K1eupLGxkbS0NK655hrGjh3bXTGKiISFmJhYEhOTKS8vpqAgF6s1iogIa6jDEhER2avtdkLS0NDAkiVLeP/991myZAler5fY2FjGjx/POeecw5FHHtkTcYqIhIWkpFTcbhceTy15eTkMHHggRmO3DTaLiIjsczqckKxYsYJFixbx6aef4nQ6iYiIYOTIkYwdO5YTTzwRs7lLgy0iInsFg8FAenom2dk/4vV6KCrKIzW1f6jDEhER2Wt1OIu4/PLLMRqNDB8+nLFjx3Laaadht9t7MjYRkbBksUSQljaQbds2U1VVRnS0ndjYhFCHJSIislfqcEJy6623ctZZZ5GUlNST8YiI7BXsdgd9+vSjrKyIgoJtWK1RREZGhTosERGRvU6HE5LLLruM0tJS5s2bR15eHvHx8Zx++ukMHTq0J+MTEQlbffum4Ha7cLtd5OXlkJl5IEajKdRhiYiI7FU6nJBs376dCy+8kKqqquC+5557jgceeIBzzjmnJ2ITEQlrv9aT/EBdnZfCwu2kpg7AYDCEOjQREZG9RoeXhpk7dy61tbXccccdLFq0iCeffJJ+/fpx//334/frrsUism8ymy2kpWUCUF1dQVVVeYgjEhER2bt0eIRkzZo1/P73v+fSSy8FYL/99sNsNnPttdeyZcsW9t9//x4LUkQknEVHx9C3byqlpQUUFW0nKsqG1WoLdVgiIiJ7hQ6PkBQVFbWqFxkyZAiBQIDKSt2xWET2bX36JBMd7SAQCJCXl4PP5wt1SCIiInuFDickjY2Nre410vy4O//wFhcXc+uttzJixAgOOeQQzjrrLObPn9/haWE5OTncfPPNHH/88Rx88MGMGDGCK6+8ku+//77T11myZAkTJ05k2LBhHHHEEVxxxRX873//646nKyK9hMFgIC1tIGazhfr6OgoLtxEIBEIdloiISNjbrbsZrl+/nsjIyODj2tpaDAYDa9aswel0tmp/+umn71Yw5eXlTJw4kYKCguC+LVu2MGfOHHJycrjnnnt22n/16tVMmTIFt9vd4pzLli1j9OjRHHroobt9nUWLFjFjxowWbyyWL1/OqlWrePHFFznqqKN26zmKSO9lNptJT89k69afqKmpxGazk5DQN9RhiYiIhLXdSkhefvllXn755Vb7586d22qfwWDghx9+2K1gnnjiiWCSMHv2bEaNGsVtt93GF198wYIFC7jggguCScVv1dfXM2PGDNxuN3FxccyaNYvjjjuOuro61q5dS9++fXf7Ol6vl3vvvZdAIEBqairz58+npqaGyy+/HKfTyV//+lcWL168W89RRHo3m81OcnIaxcX5FBfnERUVTVSU6klERETa0+GE5JVXXunJOPD7/SxatAiAzMxMxo8fD8A111zDF198AcB7773XbkLyySefUFhYCMDNN9/MGWecAYDdbufUU0/t1HWWLl0aXOb4oosuYsCAAQCcddZZvPnmm2zevJmNGzcyZMiQbvs5iMjeLyEhCbfbhdNZTV5eNllZB2Ey7dbnPyIiIvuMDv+FPProo3syDrZv3x6c9pWVlRXcv+P2xo0b2+3/zTffBLd//vlnTjvtNIqKiujfvz9XXXUV48aN2+3rbNiwoc3jO25v2LBBCYmItGAwGEhNHUB29o80NNRTUJBLenqW7k8iIiLSht36yK6uro7PP/+cvLw84uLiOPnkk0lKSuqWQCoqKoLbdru9ze3y8vbX928eHQGYP39+cHvz5s3ceuuteL1eLrroot26zo6rh0VHR7e5veP5OsNs7vC6AtJDTCZj8Htnfx87niPUsUh4MJsjGDBgEFu2/IjTWU1VVRl9+yaHOqx9Vne9RkVEpPt1OCFpLgTPy8sLFnhHRUXx5JNPMmLEiB4LcMdi8p19urjjSl8HH3ww8+bNo6ioiEsuuQSPx8PcuXOZOHFil6/zW135xNNoNBAfH73rhtKjysutAMTEWLv8+3A4osImFgm9pt9hA5s3b6aoKI9+/frgcDhCHdY+rauvURER6X4dTkieeuop8vPzueyyyzjmmGPIzc3lqaee4q677uKzzz7rciAJCQnB7R1X7KqtrW2zzW/FxcUFt88991wSExNJTEzkqKOOYunSpZSVlVFWVrZb14mPjw/uc7lcbbbdsc3u8vsD1NS4d91QepTT6Q1+r6ys3UXrtplMRhyOKGpqPPh8HVuiuqdikfASFRVLbGw81dWVrF+/gf33H9JqCXXped31GpXw4HBEabRLpBfp8F/FZcuWce6553LLLbcE9/Xp04ebbrqJ7OzsFnUVnZGRkYHD4aCmpoacnJzg/uzs7OD2zmo1Bg8evMsVr6xWK4mJiR2+zo43gmyv7W9vFrm7Ghv1hzHUmt+c+Hz+Lv8+unqO7oxFwke/fv3xeNzU19exbVs2GRmDVE8SInptiYiEnw5/vFBYWMiRRx7ZYt+RRx5JIBDYaW1HhwMxGhkzZgzQ9Ob/rbfeoqKigmeffTbYZuzYsQCMGjWKAw88kEmTJgWPjR49Ovip47vvvkt5eTkbNmxg1apVQFPCEhMTs1vXOfHEE4MjL2+88Qa5ubmsW7eODz74AID99ttPBe0isksmk4n09EwMBgMuVw3l5cWhDklERCRsdHiEpL6+vsVNEQEiIiKApru4d4fp06ezZMkSCgoKuO2221ocmzhxYrtL/kLTCMvUqVN54oknWL9+fYu6FovF0mJkp6PXsVqt3HnnncyYMYOCgoIWN3qMiIjgr3/9a1eerojsQ6xWG/36ZVBYuI2SkgKioqKJjo4JdVgiIiIht1sTmfPz81sshdtcg5Gbm9tmoebuTmdKTExkwYIFPPzwwyxduhSn00n//v2ZMGECkydP3mX/adOmkZKSwquvvsqWLVuIiIjg8MMPZ9q0aQwbNqxT1zn77LOJiYnh6aef5scff8RoNDJs2DCuu+66FucUEdmVuLhE3G4X1dUV5OdvJSvrIMxmS6jDEhERCSlDYMflpXbioIMOanPOcyAQaLW/ed/u3ql9X+Pz+amoUOFyqOXm5nDPPbdz992zGTAgs1PnMJuNxMdHU1lZ26X56d0Ri4Q3v99HdvYm6uu9REfH0L//fqon2QO66zUq4SEhIVpF7SK9SIdHSObMmdOTcYiI7BOMRhMZGZlkZ2+ittZJWVkRffumhDosERGRkOlwQtJ8p3MREemayMgoUlIyKCjIpbS0kKioaOx23Z9ERET2TRrvFBEJgbi4ROLiEgHIz99KQ0N9iCMSEREJjQ4lJM8++2yLGwN2lMvlarGcroiI/KpfvwwiI6Pw+RrJz99KB0v6REREepUOJSSLFi1i5MiR/PWvf2XlypX4fL522zY0NPDVV19x5513cvLJJ7No0aJuC1ZEpDcxGo2kp2diNBpxu12UlBSEOiQREZE9rkM1JO+99x7vv/8+L774IgsWLCAiIoL999+f9PR0YmNjCQQCVFdXk5eXx88//0xjYyMHHHAAd955Z/AmgyIi0lpkpJWUlP7k52+lvLwYm81OTExsqMMSERHZYzqUkBgMBsaOHcvYsWPZuHEjn332Gf/73//47rvvqKqqAiAuLo6srCymTJnCKaecstv3IBER2VfFxibgdruorCyjoGArWVmDsVgiQh2WiIjIHrFbN0YEGDJkCEOGDOmJWERE9lnJyel4PG68Xjd5eTkMHLg/BoPWHRERkd5Pf+1ERMLAr/UkJjyeWoqLVU8iIiL7BiUkIiJhIiIiktTUAQBUVJRQU1MV2oBERET2ACUkIiJhxOGIIyEhCYCCglzq6+tCHJGIiEjPUkIiIhJmkpPTiIqKxu/3kZeXg9/vD3VIIiIiPUYJiYhImDEYDKSnZ2IymfB63RQX54c6JBERkR6jhEREJAxZLBGkpg4EoLKylOrqitAGJCIi0kOUkIiIhKmYmFgSE5MBKCzcRl2dN8QRiYiIdL/dvg8JQCAQ4M033+Tf//4327dvp6amplUbg8HAxo0buxygiMi+LCkpFY+nFrfbRV5eNpmZB2E06rMkERHpPTqVkPztb39j/vz5DB48mLFjxxIbG9vdcYmICE0f7qSlDSQ7+0fq6rwUFW0PLg0sIiLSG3QqIVm4cCGnn346jz32WHfHIyIiv2GxRJCWNpBt2zZTVVWOzWYnLi4x1GGJiIh0i06N+3u9XkaMGNHdsYiISDvsdgd9+6YAUFi4Ha/XE+KIREREukenEpJjjz2WdevWdXcsIiKyE3369CM6OoZAwP/L/Ul8oQ5JRESkyzqVkNx999189913PPPMM1RWVnZ3TCIi0obmehKz2UJ9vZfCwm0EAoFQhyUiItIlnaohGT16NIFAgMcee4zHHnuMyMjIVqu+GAwG1qxZ0y1BiohIE7PZQlraQHJzf6a6uhKbLYb4+D6hDktERKTTOpWQnHHGGRgMhu6ORUREOiA6OoakpFRKSgooKtpOVJQNq9UW6rBEREQ6pVMJyf3339/dcYiIyG5ITEzG7XbhctWQl5dDZuZBmEymUIclIiKy23R3LRGRvZDBYCA1tbmepI7CwlzVk4iIyF6pUyMkAC6Xi/nz5/Pf//6XgoICAFJTUzn55JO57LLLsNvt3RakiIi0ZjabSU/PYuvWTdTUVGGzlZKQkBTqsERERHZLp0ZIiouLOe+885g7dy5ut5sjjjiCI444Ao/Hw9y5cxk3bhwlJSXdHauIiPyGzRZNcnI6AEVF+Xg8tSGOSEREZPd0aoTkoYceoqysjGeffZaTTjqpxbElS5bw5z//mb///e888MAD3RKkiIi0LyGhL263E6ezmry8HLKyDsJk6vQAuIiIyB7VqRGSL7/8kj/84Q+tkhGAk046iUmTJrFkyZIuByciIrvWVE8yAIslgoaGevLzVU8iIiJ7j04lJB6Ph8TExHaP9+nTB4/H0+mgRERk95hMTfUkBoMBl6uaigpNmxURkb1DpxKSQYMGsXjxYurr61sda2hoYPHixQwaNKjLwYmISMdFRdmC9STFxfm43a4QRyQiIrJrnZpkPGXKFG644QYuvPBCLr74YgYOHAhATk4OCxYsYNOmTTzyyCPdGaeIiHRAfHwf3G4XNTWVv9STDMZsVj2JiIiEr079lTrzzDPxeDz8/e9/5+677w7etT0QCJCYmMh9993H6NGjuzVQERHZNYPBQEpKf7xeN/X1deTnb6V//0HB/6dFRETCTac/Njv//PMZO3Ys69evb3EfkoMPPlifxomIhJDJZCI9PZOcnE3U1tZQVlZM3779Qh2WiIhIm7qUOZjNZoYNG8awYcO6KRwREekOVquNfv0yKCzcRmlpATZbNNHRMaEOS0REpJUOJSSrVq0C4KijjmrxeFea24uIyJ4XF5eI2+2iurqC/PzmehJLqMMSERFpoUMJyaRJkzAYDHz33XdEREQEH7cnEAhgMBj44Ycfui1QERHZPU31JBl4vW7q6rzk5eUwYMD+qicREZGw0qGE5JVXXgEgIiKixWMREQlvRmNTPUl29ibcbhelpYUkJaWGOiwREZGgDiUkRx999E4fi4hI+IqMjCI1tT/5+VspKyvCZrNjtztCHZaIiAjQyRsjtmf79u1s2bKlO08pIiLdIDY2gbi4PgDk52+loaH1jW1FRERCoVMJySuvvMINN9zQYt/MmTM5/fTTOfvsszn//PMpLy/vlgBFRKR79OuXjtUahc/XSF5eDoFAINQhiYiIdC4h+de//kViYmLw8Zdffsk777zDhAkTuOOOO8jLy2Pu3LndFqSIiHSd0WgkPT0To9GIx1NLSUlBqEMSERHp3H1ICgoKGDRoUPDxhx9+SHp6Ovfccw8AZWVlvPvuu90ToYiIdJuICCupqQPIy8uhvLwYm81OTExsqMMSEZF9WKdGSH47zL98+XJOPPHE4OO0tDTKysq6FpmIiPQIhyOehIS+QFM9SX19XYgjEhGRfVmnEpKBAwfy2WefAU3TtUpKSlokJEVFRTgcWsFFRCRcJSWlYbXa8Pt9v9ST+EMdkoiI7KM6lZBceeWVLF++nKOOOoqpU6cyaNAgjj/++ODxlStXctBBB3VbkCIi0r1+rScx4fW6KS7OD3VIIiKyj+pUDcmYMWOIi4tjyZIlOBwOLr74YszmplNVVVURGxvLueee2+mgiouLeeSRR1i6dClOp5OMjAwmTJjA5MmTMRrbz6Hy8vI45ZRT2jwWExPD6tWrd9mu2SuvvMLw4cMBGDVqFPn5bf+xXrhwIYMHD+7I0xIRCSsREZGkpQ1g+/ZsKipKsdnsOBzxoQ6rU7Zty6WsrASPx4PH497he9N2XZ2XAQP6M2TIYfh87Y8GxcQ4SE/P2IORi4hIpxISgOOOO47jjjuu1f64uLgurbBVXl7OxIkTKSj4dfWXLVu2MGfOHHJycoKF8z3NZrPtkeuIiIRSTEwciYlJlJeXUFCQi9VqIyIiMtRhBfn9fjweN05nDU5nDTU1Nb9sO4P7qqurcLmcGAyGnZ5r8+af+etf/7rTNiaTic8+W0Z8/N6ZmImI7I06nZD0lCeeeCKYjMyePZtRo0Zx22238cUXX7BgwQIuuOACDj300F2e5/PPPyc9Pb3NY+np6WzatKnFPq/XywknnEBNTQ2ZmZkccsghrfrNmTOH888/vxPPSkQkfCUlpeF21+Lx1JKXl83AgQfudDS6OwQCAbxeTzCpcDqdOyQbv365XE58Pt8uz2cwGDAYDERGWomKshEVFdXiu9fr4a23/smjj84lOTml3fPExDiUjIiI7GEdSkhGjRqF0Wjkww8/xGKxMGrUqF1+EmUwGIKF7x3l9/tZtGgRAJmZmYwfPx6Aa665hi+++AKA9957r0MJye5atGgRNTU1AFx00UXdfn4RkXBlMBhIT88kO/sHvF4PxcV5pKT07/T56urqWiQVbSUaTmcNjY2NHT5ndLSdmJgYYmIc7X5FR0djMpna7J+Xl8sHH7zPfvvtT3r6gE4/NxER6X4dSkiOPvpoDAZD8BOz5sfdbfv27TidTgCysrKC+3fc3rhxY4fOdeGFF1JTU0N8fDwnnHACf/7zn0lOTm63/RtvvAFAVFRUu6MgDzzwAHfddRdRUVEMGzaMP/7xjxx++OEdikdEJJxZLBGkpQ1k27YtVFaWYbPZiY1NaNGmvr6+zcRix+lTTmcN9fX1Hb5uVJTtl4SiZbLhcOyYaNiDdYoiItL7dOh/+Pvvv3+nj7tLRUVFcNtut7e5XV5evlvnKi0t5e2332b58uUsXLiQhISEVm3XrVvH+vXrATj77LOJiYlp85xVVVUANDQ0sHTpUlasWMFLL73EUUcd1aGY2mI29+y0CNk1k8kY/N7Z38eO5wh1LCK7q7GxMTiSUVPjoqiogO+//x6zOQK3uzY4wuH1ejt8zshIazCpaPt7LDExMVgslh58Zr8yGg3B73ptiYiEl73iI6cdb8S4s5EZm83GTTfdxMiRI8nIyCA/P5/bb7+dtWvXUlxczOuvv8706dNb9WseHYG2p2tNnDiR3/3udxxwwAF4vV4ef/xx3nzzTRoaGnj88cd59dVXO/W8jEYD8fHRneor3ae83ApATIy1y78PhyMqbGIR8fl81NTUUF1dTVVVFdXV1S2+mvfV1tZ2+JwRERHExsYSGxtLXFxccHvHfQ6HA6vV2oPPbPeVlzcV6kdHR+q1JSISZjqVkCxatIhly5a1O1Iyc+ZMTjjhBM4666zdOu+OoxfNU7eAFn8s2xrh2PHY1VdfHXw8aNAgbrnlFiZOnAg0jYT8Vk1NDR988AEAhx12GEOHDm3VZsdz2u127rrrLt577z08Hk+b5+wovz9ATY270/2lezid3uD3ysqOvzHbkclkxOGIoqbGs9MlRfdELNL7+f1+XC5Xq/qM5u2m702Jxo4f6OyM2WwOjl5ER9vx+RqIjIykT5++DBy43y+jGjFERlp3OWXX4/Hh8YTXv9/a2rrgd7229n4OR1SXR6RFJHx0KiGZP38+Q4YMafd4ZGQkL7/88m4nJBkZGTgcDmpqasjJyQnuz87ODm7v7Lp+v7/VyjA7/uFs64/o22+/jcfjAeDiiy/u8Dmbz9XVWprGRt0dOdSaEwifz9/l30dXz9GdscjepyNL3DqdNdTWuvD7O/bvw2g07rIYPCbGQVRUVIv/z2prneTm/gzwy8hHIgA+XwDoWJITTvz+QPC7XlsiIuGlUwlJTk4OF1xwQbvHDzroIBYvXrzb5zUajYwZM4Y33niDnJwc3nrrLUaOHMmzzz4bbDN27Fjg15sVHn300cEpU48++igNDQ2cd955ZGZmsn379hajOEcccUSray5YsABoun/KmWee2er4f/7zH95//30uvvhiDj30UGpra3n88cdxu93tnlNEZEfdvcQtNH0YYrfbd5lo2Gy2Ti3hGx0dQ9++KZSWFlJYuA2r1YbV2rUpiSIiIm3pVEISCARaTKn6rZqa3VvOcUfTp09nyZIlFBQUcNttt7U4NnHixJ0u+evxeHjllVd48cUXWx3LysrikksuabFvxYoVwZGYCy64gMjItm8G9tFHH/HRRx+12t9csyIi+66eW+K2Oaloe3RjZ0vcdpc+ffrhdtdSW1tDXl42mZkH9fg1RURk39OphGTIkCEsWrSIyy67jIiIiBbH6uvref/99xk8eHCnAkpMTGTBggU8/PDDLF26FKfTSf/+/ZkwYQKTJ0/ead/zzz8fn8/HN998Q1FREV6vl9TUVE455RSmTp3aYrUu+LWY3WAwtHvvkWHDhjFt2jS+/PJLtm/fHlxKePjw4fzpT39qsSSxiPQezUvculzOnSYavXmJW4PBQFraALKzf6S+vo7Cwm2kpQ3skWXfRURk39Wpv3pTpkzh2muvZfLkyVx99dXsv//+APz000/MmzePzZs38/TTT3c6qOTkZB544IGdtvnPf/7Tat/gwYO56667Onydxx9/fJdt+vTpw/Tp09tcnUtE9j7NS9y2dw+N5q/dW+I2ss1RjB0TDbt9zy1x253MZgvp6Zls3foTNTWVREfbiY/vG+qwRESkF+lUQnLSSScxe/ZsZs+ezZ/+9Kfg/kAgQHR0NPfeey8nn3xyd8UoIrJLPp/vl9GMthOM5q/m+q+OsFgsOByx2O3tj2jY7THtTvfsLWw2O0lJaZSU5FNUlIfVGk1UlC3UYYmISC/R6XkB559/PqeffjrLli1j+/btAPTv35/jjjuu1dQoEZHO8vv91NbW7jTJaFp5aveXuN1ZjUZMjIPIyEhNT/pFYmISbrcLl6uavLxssrIGq55ERES6RZcmKtvtdkaPHt1dsYjIPuS3S9y2N7LhcvX8EreyazvWkzQ01FNQkEt6eqZ+jiIi0mWdTkh8Ph8fffQRK1eupLy8nOuuu44DDzwQp9PJihUrOOKII+jTp093xioie4G9cYlb6RiTyUx6eiY5OT/hdFZRUVFKYmJSqMMSEZG9XKcSkpqaGq666iq+//57bDYbHo+HSy+9FGhaCvf//u//OO+887jxxhu7NVgRCa3evMStdExUVDT9+qVRVJRHcXE+UVHR2GzRoQ5LRET2Yp1KSB566CF+/vlnXnjhBQYPHsyIESOCx0wmE2eccQZLlixRQiKyl6ivrw8ub7uvLnErHRcf35faWhdOZxX5+TlkZR2EyaTfo4iIdE6n/oJ8/vnnTJo0ieOOO47KyspWxwcOHMg777zT5eBEpGs6tsStE6/X0+Fz9uYlbqVjDAYDqakDyM720NBQR37+VjIyBqmeREREOqVTCYnT6SQ9Pb3d442NjR2eGy4iu68nl7jdManYF5e4lY4xmUy/3J9kEy5XDeXlxfTp0y/UYYmIyF6oUwlJ//792bBhQ7vHly9fzqBBgzodlMi+yu/3YzQaKSsrxev1aolbCWtRUTb69cugsHAbJSUFREXZiY7Wsu8iIrJ7OpWQjB8/noceeojhw4dzzDHHAE1D+PX19Tz55JN8+eWXzJo1q1sDFdmbBQIB3G73TkczmqdPpaWl8d57b+3ynFriVsJBXFwibreT6urKYD2J2azpeiIi0nGdSkj+8Ic/sHnzZm688UYcDgcAM2bMoKqqisbGRn7/+99z4YUXdmugIuHM7/ezadMm8vOLqKqqbrNuo6PTGAOBADZbNPHx8VriVsKewWAgJaU/Ho+b+vqmepL+/fdTEiwiIh3WqYTEYDAEl/b9+OOPyc3Nxe/3079/f84880yOOuqo7o5TpEfFxMRQX1+Hy+XsVP9vvvmKb79d1e5xm80GNE1xiY6OxmazEx1tw2aLJjra/su+aFwuJ88//wxXXjmVAQMyOxWLyJ5mNJpIT88iJ+dHamudlJUV0bdvSqjDEhGRvcRuJyQej4ebb76Z008/nbFjx/K73/2uJ+IS2WN8Ph8XXnghpaUFlJYWdOocVqulxfLXu6Ox0Ut1tZfq6nIALrzwQi0KIXsdqzWKlJT+FBTkUlpaSFRUNHa7I9RhiYjIXmC3E5KoqCi++uorTjzxxJ6IR2SPM5lM/Otf/2LatBtISUnr5DkMOBxR1NR48Pk6VmzelsLCfObOfYQbb7y10+cQCZWmehIXVVXl5OdvJStrsJZ/FhGRXerUlK0jjzyStWvXMmHChO6ORyQknE4nERGR2O0xnepvNhuJi4smELDQ2OjvdBwREZE4nZ2bNiYSDvr1y8DjqaWuzkt+fg4DBuyvehIREdmpTlXE3nXXXaxZs4ZHHnmEoqKi7o5JRET2UkajkfT0LIxGI263i9LSwlCHJCIiYa5TIyRjx47F5/Mxb9485s2bh8lkIiIiokUbg8HAmjVruiVIERHZe0RGWklJ6U9+/lbKyoqIioomJiY21GGJiEiY6lRCcsYZZ2gIXkRE2hUbm4Db7aKysoyCguZ6kohddxQRkX1OpxKS+++/v7vjEBGRXiY5OR2Ppxav10NeXg4DBx6gD7NERKSV3UpI6urq+Pzzz8nLyyM+Pp6TTjqJpKSknopNRET2Ys31JNnZP+Lx1FJcnE+/fumhDktERMJMhxOS8vJyJk6cSF5eHoFA07KmUVFRPPnkk52+/4KIiPRuERGRpKYOIC8vm4qKEqKj7cTExIU6LBERCSMdXmXrqaeeIj8/n8suu4xnn32W2267jcjISO66666ejE9ERPZyDkccCQlNo+n5+bnU19eFOCIREQknHR4hWbZsGeeeey633HJLcF+fPn246aabyM7OJisrq0cCFBGRvV9ycioejwuPxx2sJzEaO7XyvIiI9DId/mtQWFjIkUce2WLfkUceSSAQoLy8vNsDExGR3sNgaKonMZlMeL1uiovzQx2SiIiEiQ6PkNTX1xMZGdliX/O9RxobG7s3KhER6XUslghSUweyffsWKitLsdnsxMbG77JfcXEhXq+3S9cuLm66QWNBQT4+n7/T57FarSQnp3QpFhERaWm3VtnKz89nw4YNwcdOpxOA3NxcHA5Hq/ZDhw7tYngiItKbxMTEkpiYTHl5MYWFuVitUURGWtttX1xcyMyZN3Xb9Z95Zm6XzzFnzt+VlIiIdKPdSkgee+wxHnvssVb777nnnhaPA4EABoOBH374oWvRiYhIr5OUlIrHU4vb7SIvL4fMzAPbrSdpHhmZMuWPpKamdfqaJpMRg6GRQMDc6RGSgoJ8nnvuqS6P1oiISEsdTkjmzJnTk3GIiMg+wmAwkJY2kOzsH6mr81BUtJ3U1AE77ZOamsaAAZmdvqbZbCQ+PprKyloaGzs/ZUtERLpfhxOScePG9WQcIiKyD7FYIkhLG8i2bZupqirHZrMTF5cY6rBERCQEtOaiiIiEhN3uoE+ffgAUFm6nrs4T4ohERCQUlJCIiEjI9O2bQnR0DIGAn7y8HPx+X6hDEhGRPUwJiYiIhExzPYnZbKauzkth4XYCgUCowxIRkT1ICYmIiISU2WwhLa2pYL26uoKqKt1sV0RkX6KEREREQi46OoakpFQAioq24/W6QxyRiIjsKUpIREQkLCQmJmO3OwgEAuTl5eDzqZ5ERGRfoIRERETCgsFgIDV1IGazhfr6OgoLt6meRERkH6CEREREwobZbCY9vamepKamksbGuhBHJCIiPU0JiYiIhBWbzU5ychoA9fUekpOTQxyRiIj0JCUkIiISdhISkoiJiQVg7NixBAL+EEckIiI9RQmJiIiEnaZ6kgEYDEZiY2Opq3OrnkREpJcyhzoAkXCRm7u1031NJiO5uY0EAmZ8vs5/kltQkN/pviK9jclkJjIyGperEoCKihISEzV9S0Skt1FCIvu85qVF589/LsSR/MpqtYY6BJGwYDKZ+e9//8upp55KcXE+UVHR2Gz2UIclIiLdSAmJ7POysvbjjjtmYTKZOn2O4uJCnnlmLtdeO43k5JQuxWO1Wrt8DpHe5H//+x9nnHEmPl8DeXk5ZGUNxmzWny8Rkd5C/6OL0JSUdIXJ1FSOlZqaRnr6gO4ISUR2EBkZTWOjh/r6OgoKtpKRMQiDwRDqsEREpBuoqF1ERMKewWAgPT0Tg8GAy1VDeXlxqEMSEZFuooRERET2ClarjX79MgAoKSmgttYZ4ohERKQ7hOWUreLiYh555BGWLl2K0+kkIyODCRMmMHnyZIzG9nOovLw8TjnllDaPxcTEsHr16uDjJ554grlz57bZdvLkydx+++0t9i1cuJCXX36ZLVu2YLVaOfroo7nhhhsYNGhQJ56hiIh0RlxcIm63i+rqCvLzt5KVdRBmsyXUYYmISBeEXUJSXl7OxIkTKSgoCO7bsmULc+bMIScnh3vuuWePxzRv3jz+/ve/Bx/X1dXx6aefsnLlShYsWKCkRERkDzEYDKSkZOD1uqmr85Kfv5X+/fdTPYmIyF4s7KZsPfHEE8FkZPbs2axYsYKRI0cCsGDBAr7//vsOnefzzz9n06ZNwa8dR0d2dPTRR7dot2nTphajI4WFhTz++OMADB06lKVLl/Lcc89hNpupqanh/vvv78rTFRGR3WQ0mn6pJzFSW+uktLQw1CGJiEgXhFVC4vf7WbRoEQCZmZmMHz+ehIQErrnmmmCb9957b4/G9NFHH9HQ0ADAlVdeSXJyMieeeCLHHHMMAMuWLaOiomKPxiQisq+LjIwiJaWpnqSsrAiXqybEEYmISGeFVUKyfft2nM6mIsWsrKzg/h23N27c2KFzXXjhhQwdOpTjjz+emTNnUlzc9oos69at44gjjuCQQw7hnHPOYf78+fj9v95pe8OGDW3GkZmZCTQlUZs2bepQTCIi0n3i4hKJi0sEID9/Kw0N9SGOSEREOiOsakh2HGmw2+1tbpeXl+/WuUpLS3n77bdZvnw5CxcuJCEhoUU7j8cT3P7pp5+YM2cO2dnZzJo1C4DKyspui6ktZnNY5YTSSUajIfhdv1OR7tN8jx+Tydjmays9fQBerxuv10NBwVaysg5ss55kx/P0VCwiItI5YZWQtCcQCAS3d1a4aLPZuOmmmxg5ciQZGRnk5+dz++23s3btWoqLi3n99deZPn060FQP8sgjj3DkkUcSExPDV199xU033YTX6+Wf//wnU6ZMISMjo8sx7YzRaCA+PrpTfSW8lJdHAhAdHanfqUg3Ki+3AhATY233tRUVdTDffvsttbUuqqpKWoxm/5bDEdWjsYiIyO4Lq4Rkx9GL5qlbALW1tW22aav/1VdfHXw8aNAgbrnlFiZOnAg0Tc9qNmrUqBZ9Tz31VM4991zefPNNAoEA69evJyMjg/j4+C7FtDN+f4CaGnen+kp4qa2tC36vrKzdRWsR6Sin0xv8vrPXVlraALZty2b79u2YTJE4HHEtjptMRhyOKGpqPPh8/rZP0k2xSM9zOKK6NNolIuElrBKSjIwMHA4HNTU15OTkBPdnZ2cHt4cMGdJuf7/f3+o+JTuOXuy43VbbtvoNHTqU999/H4CcnJzg9ZvjMxqNHHjggbt8bu1pbOzcH0YJL35/IPhdv1OR7tOcPPh8/p2+tuz2OOLj+1JZWcq2bTlkZR1ERERkm+fr7Gu0o7GIiMjuCauPF4xGI2PGjAGa3vC/9dZbVFRU8OyzzwbbjB07Fmga4TjwwAOZNGlS8Nijjz7KAw88wKZNm6ivr2fLli0tluU94ogjgtsTJ07krbfeorS0FI/Hw2effca7774LgMlk4rDDDgNg9OjRWCxNN9164YUXKCkpYenSpXz99dcAHH/88Z0eIRERke6TnJyG1WrD7/eRn59DIKCkQURkbxBWIyQA06dPZ8mSJRQUFHDbbbe1ODZx4kQOPfTQdvt6PB5eeeUVXnzxxVbHsrKyuOSSS4KPs7OzW52/2ZQpU0hJSQEgJSWF6667jr///e9s2LCBE044IdjO4XBw66237tbzExGRnmE0GklPzyQ7+0c8HjfFxQX065ce6rBERGQXwi4hSUxMZMGCBTz88MMsXboUp9NJ//79mTBhApMnT95p3/PPPx+fz8c333xDUVERXq+X1NRUTjnlFKZOndpiZaw77riDTz75hB9//JHS0lIsFgsHHXQQF198MWeffXaL81599dX07duXV155hS1btmC1Wjn66KO54YYbdJd2EZEwEhERSVraALZvz6aiogSbzd6qnkRERMJL2CUkAMnJyTzwwAM7bfOf//yn1b7Bgwdz1113dega5513Huedd16HYxo3bhzjxo3rcHsREQmNmJg4EhKSqKgooaAgF6s1CrO586triYhIzwqrGhIREZHukJycRlRUNH6/j7y87BY3vBURkfCihERERHodg8FAenomJpMJr9dDYeH2UIckIiLtUEIiIiK9ksUSQVraQADKy0spKSkJbUAiItKmsKwhERERaRYTE0N9fR0ul3PXjVsxYrfHUlVVzubNm0lPz8TnC3Qqjvr6OmJiYjrVV0RE2qeEREREwpbP5+PCCy+ktLSA0tKCLp3L5XJRWlrapXNceOGF+Hy+Lp1DRERaUkIiIiJhy2Qy8a9//Ytp024gJSWtC+cx4HBEUVPj6fQISWFhPnPnPsKNN+r+UyIi3UkJiYiIhDWn00lERCR2e+enS5nNRuLiogkELDQ2dm7FrYiISJzOzkwbExGRnVFRu4iIiIiIhIwSEhERERERCRklJCIiIiIiEjJKSES6gdHoZtiwUgwGb6hDEREREdmrqKhdpIPy8rbjdNa0eSw5+T7uvXcldXWnUFQ0noKCC2hoSGjVLibGQXp6Rk+HKiIiIrLXUEIi0gGVlZWMHXsGfn/bq/MceWQ9c+ea6N+/hgEDXiQ5+UX+/W8b8+ZFs2WLJdjOZDLx2WfLiI+P31Ohi4iIiIQ1JSQiHRAfH897733c7giJyWQkP78Ot3sZqamv4XBs5NJL3Vx6qZvy8uPIy7uY6urDiYmJVTIiIiIisgMlJCIdtLOpVmazkfj4aCorj6Cu7k9UVn6NzfY4EREfkJi4nMTE5TQ0DMPjmU5dXT/A0u65RERERPYlKmoX6XYGGhuPpabmDSorV+PxXEkgYMVi+R8Ox5UkJBxGVNRcDIa2R1tERERE9iVKSER6kM+3Py7XI5SX/0Bt7e34/X0wmfKw228jIWEI0dF3YDTmhTpMERERkZBRQiKyBwQCibjdt1BevhGn8wkaGw/AaKzBZnuchIRDiYm5CrP5u1CHKSIiIrLHKSER2aOseL1/oLLyG6qr/0l9/YkYDI1Yrf8kPv4EYmPPJiLiY6Dt1bxEREREehslJCIhYaS+fjTV1YuorFyK13shgYCJiIilxMZeSHz8cKzWlwHdaFFERER6NyUkIiHW2DgMp/MFKiq+x+2ejt8fg9m8iZiY6SQmDsVmewCDoTzUYYqIiIj0CCUkImHC78+gtnY2FRUbcblm4/OlYzSWEh09m8TEIdjtN2AybQ51mCIiIiLdSgmJSJgJBGLxeKZTUfEdNTXP09AwDIPBQ1TUC8THH4nDcTFm8wogEOpQRURERLpMCYlI2LJQVzeBqqolVFUtpq7uDAyGAJGRi4iPP4O4uFOIiHgHaAx1oCIiIiKdpoREJOwZaGg4gZqaf1FRsQqP5w8EApFYLKuJjf0DCQlHEBX1NOAKdaAiIiIiu00JichexOc7EJfrCcrLN1Bb+xf8/gRMpq3Y7beQmDiE6Oi/YjQWhjpMERERkQ5TQiKyFwoEknC77/jlRouP0Ng4CKOxCpvtYRISDiYm5lpMpvWhDlNERERkl5SQiOzVbHi9V1JZuYbq6jdoaDgWg6EBq/UfJCSMIDb2XCyWz1EBvIiIiIQrJSQivYKR+voxVFV9TGXlf/B6zycQMBIR8QVxceOIjx9BZOTrQH2oAxURERFpQQmJSC/T2Pg7nM75VFT8D7d7KoFANGbzBhyOqSQkHExU1MMYDJWhDlNEREQEUEIi0mv5/QOprX2A8vKNuFz34POlYDIVYbf/9ZcC+L9gNG4NdZgiIiKyj1NCItLLBQLxeDw3UFGxjpqaZ2hsPBiDoRab7RkSEobhcEzGbF4V6jBFRERkH6WERGSfEUFd3cVUVi6nqmoh9fWnYDD4iYxcSHz8KcTFnU5ExPuAL9SBioiIyD5ECYnIPsdAQ8MoqqvfoaJiBV7vJQQCFiyWr4mNvYT4+COxWp8D3KEOVERERPYBSkhE9mE+31CczqepqFiP230Tfn8cZnM2MTE3kZg4BJvtXgyGklCHKSIiIr2YEhIRwe9Pobb27l9utPggPt9AjMYKoqMfJDFxCHb7NEymH0MdpoiIiPRCSkhEZAd2vN5rqKhYS3X1qzQ0HIXBUE9U1CskJByNwzEei2UJutGiiIiIdBclJCLSBhP19edSVfU5lZWfUld3DoGAgcjIT4iLO4e4uBOJjHwTaAh1oCIiIrKXU0IiIjvV2DicmprXqaj4Fo/nKgKBKCyW73A4ppCQcChRUY9jMFSHOkwRERHZSykhEZEO8fsH4XI9THn5Rmpr78TvT8Jkysduv4OEhCFER9+G0bg91GGKiIjIXkYJiYjslkAgEbf7ZsrL1+N0Pklj40EYjU5strkkJBxKTMzlmM3fhjpMERER2UsoIRGRTrLi9U6isnIl1dX/pr7+ZAwGH1brW8THn0xs7FlERHwI+EMdqIiIiIQxJSQi0kUG6utPp7r6PSoqluH1/p5AwExExDJiY39PfPxRWK0vAZ5QByoiIiJhSAmJiHQbn+9QnM7nqKhYh9t9PX6/A7P5Z2JiricxcSg22xwMhrJQhykiIiJhRAmJiHQ7vz+N2tp7qajYiMt1Hz5fBkZjGdHRc3650eKfMZl+DnWYIiIiEgaUkIhIjwkEHHg806io+I6amhdpaDgcg8FLVNSLxMf/DodjIhbLcnSjRRERkX2XOdQB/FZxcTGPPPIIS5cuxel0kpGRwYQJE5g8eTJGY/v5U15eHqecckqbx2JiYli9enXw8cKFC/n888/ZuHEj5eXlWK1WsrKyuOKKKzj11FNb9J00aRLffPNNm+d98sknW7UXkbaYqasbT13dBVgsXxEV9TiRkR8SGfkBkZEf0NBwBB7PdOrqziUM/1sSERGRHhRWf/nLy8uZOHEiBQUFwX1btmxhzpw55OTkcM8993TLdZ555hlycnKCjz0eD2vWrGHNmjXcfPPNXHXVVd1yHRH5LQMNDcfR0HAcJtNPREU9idX6BhbLt1gsl+Pz9cfjmYrXO5lAICbUwYqIiMgeEFZTtp544olgMjJ79mxWrFjByJEjAViwYAHff/99h87z+eefs2nTpuDXjqMj0DRiMn36dD799FPWrl3LnXfeGTz2zDPP0NjY2Oqc06ZNa3HOTZs2aXREpAt8vgNwuR775UaLM/H7EzGZtmG3z/zlRot3YTTmhzpMERER6WFhk5D4/X4WLVoEQGZmJuPHjychIYFrrrkm2Oa9997rlmu99NJLTJs2jf79+2Oz2bj00ks54IADAHA6nVRUVHTLdURk1wKBPrjdMykv34jT+RiNjfthNFZjsz1KQsIhxMRcjcm0LtRhioiISA8Jm4Rk+/btOJ1OALKysoL7d9zeuHFjh8514YUXMnToUI4//nhmzpxJcXFxi+N2u71Vn7q6OgAiIyOJi4trdfzVV1/l4IMP5vDDD+fSSy9lyZIlHYpFRDoqCq/3ciorV1Nd/Sb19cdhMDRitS4gIeE4YmPPxWL5FBXAi4iI9C5hU0Oy46jEjgnDjtvl5eW7da7S0lLefvttli9fzsKFC0lISGiz/bvvvktubi4AY8eOJSIiolWb6upqABoaGli1ahWrVq3ioYce4pxzzulQTO0xm8MmJ5QuMJmMLb5LVxjx+8dQWzsGr/dbrNbHsVjeISLiCyIivsDnG4zXex319ROAyFAHKz1sx9dWV/6/7I7XaHfFIiIiLYVNQtKeQODXT0MNBkO77Ww2GzfddBMjR44kIyOD/Px8br/9dtauXUtxcTGvv/4606dPb9Xvv//9L3fccQcABxxwALfeemuL46NHj+aPf/wjgwcPxmAw8Oqrr/LEE08A8Mgjj3QpITEaDcTHR3e6v4QfhyMq1CH0Mif88pULPAY8h8n0A9HRU4mOvgeYDlwLtP1hg+z9ysutAMTEWLvl/8uuvEa7OxYREWkSNgnJjqMXzVO3AGpra9ts01b/q6++Ovh40KBB3HLLLUycOBGAdetaz0H/9NNPueGGG2hoaGC//fbjpZdeajWd65JLLmnxeNq0abz//vts3bqV/Px8KioqdhrXzvj9AWpq3J3qK+HFZDLicERRU+PB5/OHOpxeqA9wLwbDTUREzMdqfQqjsQC4nUBgNnV1l1JXNw2/P2tXJ5K9jNPpDX6vrKzdRev2dcdrtLtika5zOKI0Ii3Si4RNQpKRkYHD4aCmpqbFkrzZ2dnB7SFDhrTb3+/3t7pPyY4jKr8dXVm8eDF/+ctfaGxsZMiQIbzwwgutEou2ztnWubqisVFvXnsTn8+v32mPctDQcB21tdcSGfk2UVFzsVi+x2qdR2Tkc9TXn4PbPZ3GxuGhDlS6SXPy0F2vra6cp7tjERGRJmHz8YLRaGTMmDEA5OTk8NZbb1FRUcGzzz4bbDN27FgARo0axYEHHsikSZOCxx599FEeeOABNm3aRH19PVu2bOH+++8PHj/iiCOC2wsXLuTmm2+msbGRww8/nFdeeaXNUY5NmzZx+eWXs2TJElwuF9XV1cydOzeYMA0cOLDToyMi0hUR1NVNpKrqS6qq3qOu7jQMhgCRke8RH38acXGnEhHxLuALdaAiIiKyC2EzQgIwffp0lixZQkFBAbfddluLYxMnTuTQQw9tt6/H4+GVV17hxRdfbHUsKyurxdSrxx9/HJ+v6Y3K2rVr+d3vftei/SuvvMLw4U2fsH711Vd89dVXrc5pNptbxSgie5qBhoaTaWg4GZPpB6Ki5mK1vonF8g2xsZPw+Qbidv8Jr/dSQHP+RUREwlHYjJAAJCYmsmDBAs477zwSEhKwWCwMGjSImTNncvfdd++07/nnn88ll1zC/vvvT0xMDBaLhQEDBnDFFVfw5ptvtrnU765kZGQwY8YMjjrqKPr27YvZbCY+Pp5TTjmFN954g5NOOqmzT1VEupnPNxiX60nKyzdQWzsDvz8ek2krMTE3k5g4GJttFkZjUajDFBERkd8wBHZcxkr2KJ/PT0WFCiN7A7PZSHx8NJWVtZpbHjZqsVpfx2Z7EpOpaZplIBCB1zsBj2caPl/7NWkSPnJzc7jnntu5++7ZDBiQ2enzdMdrtLtika5LSIhWUbtILxJWU7ZERLpPNF7v1Xi9VxIR8QE22+NYLCuJinqNqKjXqK8/Fbd7Og0NJwPdt1CF9Izc3K1d6m8yGcnNbSQQMHd6la2CgvwuxSAiIm1TQiIivZyJ+vpzqK8/B7N5JTbbXCIi3ici4jMiIj6jsfEQ3O5p1NVdALS+KaqEVnO93/z5z4U4kl9ZrdZQhyAi0qtoylYIacpW76EpW3sXozGHqKiniIp6FYOh6V5APl8KHs9UvN7LCATiQhugtJCdvRmTydSlcxQXF/LMM3O59tppJCendPo8Vqu1S/2le2jKlkjvohESEdnn+P2Z1NY+iNs9E6v1JaKinsVkKsRuvwub7W94vZPweP6I3z8g1KEKkJW1X5fP0fzmNTU1jfR0/V5FRMKJPl4QkX1WIJCAx3MTFRXrqKl5msbGIRiNLmy2p0lIOIyYmMswm9eEOkwREZFeTQmJiAiR1NVdQmXlCqqq3qa+fiQGgx+r9W3i40cSGzuaiIgPAE3HExER6W5KSEREggw0NJxKdfW7VFQsx+u9iEDATETEV8TGTiQ+/ndYrS8AnlAHKiIi0msoIRERaYPPdwhO57NUVKzH7b4Bvz8Ws3kzMTE3kJg4BJttNgZDaajDFBER2espIRER2Qm/P5Xa2nuoqNiIy3U/Pt8AjMZyoqMfIDFxCHb7dZhMP4U6TBERkb2WEhIRkQ4IBGLweP5IRcVaqqtfpqHhSAyGOqKi5pOQ8DscjglYLF8CWkldRERkdyghERHZLWbq68dRVfUfKis/pq5uDIGAgcjIj4iLG0Nc3MlERv4LaAh1oCIiInsFJSQiIp1ioLHxWGpq3qCycjUez5UEAlYslrU4HFeSkDCMqKi5GAw1oQ5UREQkrCkhERHpIp9vf1yuRygv30ht7W34/X0wmbZjt99GQsIQoqPvwGjMC3WYIiIiYUkJiYhINwkE+uB230p5+UaczidobDyA/2/vzsOjrA72j9/PTFayJ1ZCQECsElYRwyaLQqCv2lqBCtqigFLcQIpLlaVYkUtxqwtri4hADVJQ2ZSihoIoLxBQBH4G0CJrCAiZ7CHrPL8/IPMyEBBGzEkm38915YI5z2Rygxcx95xznuNw5KlevSmKjW2riIg/KiBgm+mYAADUKBQSALjkQlRcPETZ2WnKzV2k0tIesqxyhYQsUkxMd0VF/UZBQR+LgxYBAKCQAMDPyKHS0puVm/uhsrPXqbh4gGzbqaCgdYqKGqCYmE4KCZknqdh0UAAAjKGQAEA1KC9vp/z8t+RybVdR0SNyuyMUELBbERGPKC6ulerVe1GWlWU6JgAA1Y5CAgDVyO2+QoWFz506aPE5VVQ0ksNxTGFhz506aPFROZ3/NR0TAIBqQyEBAANsO0onTjwil2ub8vJmq6ysnSzrhEJD31JMzPWKjPyDAgI2ioMWAQD+jkICAEYFqqRkoHJyPlNOzocqKfkfWZat4OAPFRPzK0VHJysoaImkctNBAQD4WVBIAKBGsFRW1kN5eYvlcm3WiRNDZNvBCgzcoqioIYqNba/Q0JmSCkwHBQDgkqKQAEANU1HRXAUFU5WV9Y0KC5+U2x0rp3OfwsOfUlxcS4WFPSOHI9N0TAAALgkKCQDUULZ9uYqK/nLqoMXXVF5+lRyOHNWr96piY1srIuJBOZ3/z3RMAAB+EgoJANR49VRcPEzZ2V8qN/ddlZV1kWWVKSRkgWJjb1BU1O0KDFwtNsADAGojCgkA1BoOlZb+Wjk5Hys7+z8qLu4v23YoKGiNoqP7KSbmBgUHp0gqNR0UAIALRiEBgFqovDxJ+flz5XJ9raKih2TbYQoI+EaRkQ8pNra1QkNflWVlm44JAMCPopAAQC3mdjdVYeGLyspKV0HBRFVUNJDTeUTh4c+c2gD/pByOfaZjAgBwThQSAPADth2jEycelcu1Q3l5f1d5eWtZVqHq1fu7YmPbKTJysAICNpuOCQDAWSgkAOBXglRS8gdlZ69XTs5SlZYmy7LcCg5eqpiYZEVH/0pBQSskVZgOCgCAJAoJAPgpS2VlvZSbu0Qu1wYVFw+SbQcqMHCjoqIGKSbmeoWEvCmpyHRQAEAdRyEBAD9XUdFK+fkz5XL9PxUVPS63O1oBAd8rIuJxxcW1VL16k2RZP5iOCQCooygkAFBHuN0NVFj411MHLb6kioqmcjhcCgt7WXFxrRQePlJO5y7TMQEAdQyFBADqnHAVFz8ol2urcnPnq6ysgyyrRKGh8xUb21GRkXcoMPAzcdAiAKA6UEgAoM5yqrS0r3JyVis7+1OVlNwm27YUHPyJoqNvU3R0DwUH/0tSmemgAAA/RiEBAKi8vJPy8lLkcn2lEyf+KNsOVWDgNkVGDldsbFuFhk6RZeWajgkA8EMUEgCAh9t9lQoKXlVWVroKCyfI7b5cTmeGwsP/otjYlgoLGyeH46DpmAAAP0IhAQCcxbbjVFT0Z2Vl/T/l509XeXmiHI581as3TbGxbRURca8CAr4yHRMA4AcoJACA8whRcfE9ys7epNzc91RaepMsq0IhIe8rJuYmRUXdqqCgf0tymw4KAKilKCQAgAtgqbT0V8rNXa7s7M9VXHynbDtAQUFfKCrqTsXEdFRIyFxJxaaDAgBqGQoJAOCilJdfq/z8N+Vy7VBR0Z/kdkcqIOBbRUSMOnXQ4mRZ1nHTMQEAtQSFBADgE7e7oQoLJ8nlSldBwfOqqLhCDsdxhYVNVlxcS4WHj5bT+Z3pmACAGo5CAgD4SWw7UidOjJTLtU15eXNUVnadLKtYoaFzFBOTpMjIuxQYuF4ctAgAqAqFBABwiQSopOQO5eSsVU7Ov1VScossy1Zw8EpFR9+i6OieCg5+X1K56aAAgBqEQgIAuMQslZV1VV7ev+RybdGJE/fKtkMUGPiVIiPvVWxsO4WGTpdl5ZsOCgCoASgkAICfTUXFNSooeOPUQYtj5XbHyek8oPDwsacOWnxaDsdh0zEBAAZRSAAAPzvbvkxFRWOVlZWu/PzXVV7+SzkcuapX73XFxrZWRMT9cjp3mI4JADAgwHSAqhw9elSvvfaa1q1bp/z8fF1xxRUaOHCgBg8eLIfj3B3q0KFDSk5OrvJaRESEtmzZ4jW2Z88evfbaa0pLS1NxcbGuuuoqDRkyRH379j3r85cuXap58+Zpz549CgkJUceOHfXoo4/qqquu+kl/VgCoW0JVXHyfiouHKijoY4WGTlFQ0HqFhCxUSMhClZb2VFHRSJWV9ZZkmQ4LAKgGNa6QZGVl6a677tLhw/83hb9nzx5NnjxZe/fu1cSJEy/J19mzZ4/uuusu5eXlecbS09P11FNP6YcfftD999/vGZ81a5b+9re/eR6XlJTo008/1aZNm7Rw4UJKCQBcNIdKS29RaektCgj4SqGhUxUcvFRBQWsUFLRG5eUtVFT0iEpKBkgKNh0WAPAzqnFLtqZOneopI88995w2bNignj17SpIWLlyo7du3X9DrrF69Wrt37/Z8nDk78sILLygvL08BAQGaNWuWPv/8c7Vq1UqSNGXKFB05ckSSlJmZqSlTpkiSWrVqpXXr1unNN99UQECA8vLy9MILL1ySPzcA1FXl5e2Vn/+2XK5tKioaIbc7XAEBOxUZ+bBiY1urXr1XZFku0zEBAD+TGlVI3G63PvzwQ0nSlVdeqTvuuEOxsbF64IEHPM9Zvnz5T/46LpdLX3zxhSSpc+fOuvHGG3X55ZfrvvvukySVlZVp1apVkqRVq1aprKxMkjRs2DDVr19fPXr0UOfOnSVJX3zxhVwu/kcJAD+V291YhYWTTx20OEkVFQlyOo8qLOzZUwctPi6H43vTMQEAl1iNKiQHDx5Ufv7J20A2a9bMM37679PT0y/otQYMGKBWrVqpW7duGjt2rI4ePeq5tmvXLrnd7vN+nW+++cbr1zOvX3nllZJOlqjdu3dfUCYAwI+z7WidOPEnuVzblZc3S2VlbWVZRQoNfVOxsdcpMvJuBQRsMh0TAHCJ1Kg9JKfPNISHh1f5+6ysrIt6rWPHjumDDz7Q+vXrtXTpUsXGxl7Q16l8TnZ29iXLVJWAgBrVCeEjp9Ph9SuASyFEFRV/UEHB7xUQsFYhIVMVGPiJgoOXKzh4ucrLO6m4eJTKyn4jyXneV3I4LM+vfN8FgJqlRhWSc7Ft2/N7yzr3XVfq1aunxx9/XD179tQVV1yhjIwMjR8/Xlu3btXRo0eVkpKiRx555IK+zqXKdD4Oh6WYmDCfPhc1U2RkqOkIgJ/6zamPbyS9KukdBQRsUnj4IElXSRot6V5JVX9Pzco6uTE+LCyY77sAUMPUqEISGxvr+X3l0i1JKiwsrPI5VX3+6XfHuuqqq/TUU0/prrvukiTt2LHjor9OTEzMT8p0Pm63rby8Ip8+FzWL0+lQZGSo8vJOqKLCbToO4MeaSpoiyxqv4OC/Kzj4LTkceyQ9Irf7aZWUDFNJyYOy7XivzyosLPH8mp1deNaronaJjAxlRhrwIzWqkFxxxRWKjIxUXl6e9u7d6xn//vv/28TYsmXLc36+2+0+65yS02cvKn+fmJgoh8Mht9t9zq9TecetVq1aacWKFZKkvXv3er5+5ec5HA41b9784v6gpykv54dXf1JR4ea/KVAtfqGysgkqKHhMISEpqldvupzOvQoNfUUhIVNUXDxQJ06MVEXFye/Zbrft+ZV/owBQs9SotxccDod+/etfSzr5A//7778vl8ulf/zjH57n/Pa3v5Uk9erVS82bN9c999zjufb666/rxRdf1O7du1VaWqo9e/Z43Za3ffv2kk7OaHTr1k2StGnTJq1bt04//PCD5syZI0kKDAzUzTffLEm6+eabFRgYKEl666239MMPP2jdunXauHGjJKlbt24+z5AAAH6qMBUX3y+X6yvl5qaorKyTLKtUoaHvKDa2s6Ki+iswcI2kC1+SCwCoXjVqhkSSHnnkEX322Wc6fPiwxo0b53XtrrvuUtu2bc/5uSdOnND8+fM9xeJ0zZo106BBgzyPx4wZo6+//lp5eXkaPny413NHjRql+PiT0/0NGjTQqFGj9Le//U3ffPONunfv7nleZGSkxowZ49OfEwBwKTlVWnqbSktvU0DAJtWrN01BQSsUFJSqoKBUNW/eXG3axPz4ywAAql2NKyRxcXFauHChXn31Va1bt075+flq3LixBg4cqMGDB5/3c/v376+KigqlpaXpyJEjKi4uVkJCgpKTk/XQQw953Rnrqquu0sKFC/Xaa68pLS1NxcXFuuqqqzRkyBD17dvX63Xvv/9+/eIXv9D8+fO1Z88ehYSEqGPHjnr00Uc5pR0AaoBDhw4qPz/v1KNwSWMUEnKPGjb8l+LjV6hevd0aPjxMW7Z8p/z8gnO+TkREpBo1uqJaMgMATrLsi7m1FC6pigq3XC42V/qDgACHYmLClJ1dyPp0oJplZ2crObmr53ypM0VHu/Xb357Qzp0B2rw5+Lyv5XQ6lZr6hdcNTVDzxMaGsakd8CMUEoMoJP6DQgKY5T1Dcjan0yGHo0Jut/O8d8JjhqR2oJAA/qXGLdkCAOBi/ViJ4E0DAKi5eHsBAAAAgDEUEgAAAADGUEgAAAAAGEMhAQAAAGAMhQQAAACAMRQSAAAAAMZQSAAAAAAYQyEBAAAAYAyFBAAAAIAxFBIAAAAAxlBIAAAAABhDIQEAAABgDIUEAAAAgDEUEgAAAADGUEgAAAAAGEMhAQAAAGAMhQQAAACAMZZt27bpEHWVbdtyu/nr9xdOp0MVFW7TMQCcA/9G/YfDYcmyLNMxAFwiFBIAAAAAxrBkCwAAAIAxFBIAAAAAxlBIAAAAABhDIQEAAABgDIUEAAAAgDEUEgAAAADGUEgAAAAAGEMhAQAAAGAMhQQAAACAMRQSAAAAAMZQSAAAAAAYQyEBAAAAYAyFBAAAAIAxFBIAAAAAxlBIAAAAABhDIQEAAABgTIDpAEBtlp2drdmzZ2vjxo3Ky8vTp59+qhUrVqiiokLdu3dXXFyc6YhAnZWXl6d169bp8OHDKi0tPev6yJEjDaQCAJyJQgL4KCsrSwMHDtThw4dl27Ysy5Ikff7551qxYoUee+wxDR8+3HBKoG7auHGjRowYoaKionM+h0ICADUDS7YAH73xxhvKyMiQ0+n0Gu/Xr59s29aaNWsMJQMwefJkFRYWyrbtKj8AADUHMySAj9auXSvLsjR79mwNHTrUM962bVtJ0oEDBwwlA3DgwAFZlqWxY8eqR48eCgwMNB0JAHAOFBLARy6XS5LUvn37Kq/n5ORUYxoAp0tMTNTXX3+tX//61+zlAoAajkIC+CgmJkbHjx/X999/7zX+0UcfSRI/BAEG/fWvf9WQIUN0//33a9CgQWrQoIECArz/l9ehQwdD6QAAp6OQAD7q0qWLVqxYoREjRnjGhg8frvXr18uyLHXp0sVgOqBuq1+/vq6++mpt2bJF48ePP+u6ZVlKT083kAwAcCbLZncf4JP9+/frd7/7nQoKCjx32JIk27YVERGh999/X40bNzaYEKi7Ro4cqdWrV59zA7tlWdq5c2c1pwIAVIUZEsBHTZo0UUpKiiZPnqzNmzeroqJCTqdTHTp00NixYykjgEHr16+XJLVr105JSUkKCQkxnAgAcC7MkACXQHFxsXJzcxUdHa3g4GDTcYA6r0+fPjp06JA2b96s8PBw03EAAOfBOSTAJRASEqL69etTRoAaYvTo0ZKkFStWmA0CAPhRzJAAF6FFixYX/Fw2zQLm3HPPPfr222+Vl5en+Ph4JSQkeB1ialmW5s2bZzAhAKASe0iAi0B/B2qHzZs3y7Is2batzMxMHTlyxHPNtm2vG1EAAMyikAAXoV+/fqYjALgACQkJpiMAAC4QS7YAAAAAGMMMCfAT7du3T2lpacrOzlZMTIw6duyopk2bmo4F4JTvvvtOLpdLMTExuuaaa0zHAQCcgUIC+KisrExPP/20li5deta1fv366dlnn1VAAP/EAFPWrFmjZ5991mv/SHx8vCZMmKBevXoZTAYAOB1LtgAfTZ48+Zx36bEsS0OGDNGYMWOqORUASfrqq690zz33yO12n3UzioCAAM2bN0/XX3+9oXQAgNNRSAAfde7cWbm5uWrcuLEGDx6s+Ph4HTlyRPPnz9f+/fsVHR2tjRs3mo4J1En333+/1q1bp5CQEPXp00cNGjRQZmamUlNTdeLECfXo0UOzZs0yHRMAIJZsAT4rKSmRJM2aNUtNmjTxjHft2lU333yzysrKTEUD6rxt27bJsiz9/e9/V+fOnT3jGzdu1NChQ7Vt2zaD6QAAp+OkdsBHXbt2lSSFhYV5jVc+7t69e7VnAnBSUVGRJKl169Ze45WPK68DAMyjkAA+uvfeexUVFaVHH31UGzZs0L59+7RhwwY99thjuvzyy3Xffffp8OHDng8A1Sc+Pl6S9Prrr3vKx4kTJ/TGG294XQcAmMceEsBHLVq0uODnWpal9PT0nzENgNO9+OKLevvtt2VZlhwOh8LDw1VQUCC32y1JGjp0qJ566inDKQEAEjMkgM9s276oDwDVZ8SIEfrlL38p27ZVUVGh3NxcVVRUyLZtNWvWTA8//LDpiACAU9jUDvho5MiRpiMAOIfw8HAtXLhQc+fO1RdffOE5uLRbt24aOnSowsPDTUcEAJzCki0AgN+p3LeVkJBgOAkA4MdQSAAAficxMVEOh6PKvVs33nijHA6H1qxZYyAZAOBMLNkCfFRSUqIZM2Zo1apVyszMPOvcETayA2ZV9X6b2+3W0aNHZVmWgUQAgKpQSAAfPffcc1q8eLGkqn/wAVC9du3apV27dnmNLV261Ovxf//7X0lSYGBgdcUCAPwICgngo9TUVElSw4YNde211yooKMhwIqBuS01N1fTp0z2PbdvW2LFjz3qeZVlq0qRJdUYDAJwHhQTwUeWSj8WLFysmJsZwGgDS/81WVv77rGr2MioqSk888US15gIAnBuFBPDRnXfeqRkzZmjt2rXq16+f6ThAndevXz917NhRtm1ryJAhsixL8+fP91y3LEuRkZFq0qSJQkJCDCYFAJyOu2wBPnK73RoxYoTWrl2rBg0aqEGDBnI6nZ7rlmVp3rx5BhMCddeYMWNkWZYmT55sOgoA4EdQSAAfLV++XE899VSV12zblmVZ2rlzZzWnAnAuW7dulcvlUrt27RQXF2c6DgDgFJZsAT564403uLsWUEPNmjVLK1asUN++fTVs2DBNmDBB7733niQpMjJSc+bMUatWrQynBABIFBLAZy6XS5ZlaerUqerevbuCg4NNRwJwyn/+8x/997//VcuWLXXs2DG99957njcQcnNzNXPmTE2bNs1wSgCAJDlMBwBqqx49ekiS2rRpQxkBapj9+/dLkpo3b65t27bJtm317dtXL730kiRp27ZtJuMBAE7DDAngo1tvvVWbNm3S8OHDNXjwYDVs2FABAd7/pDp06GAoHVC3FRQUSDq5POu7776TZVnq2bOnevXqpSeffFI5OTlmAwIAPCgkgI/+9Kc/ybIs5ebmasKECWddtyxL6enpBpIBiImJ0bFjx5SSkqLVq1dLkpo2bar8/HxJUkREhMl4AIDTsGQL+Als2z7vBwAzrr/+etm2rRdeeEHffPON4uLi1Lx5c+3Zs0eS1LhxY8MJAQCVmCEBfMT5BkDN9eijj2rXrl3au3evwsPD9cwzz0iSPv74Y0lSx44dDaYDAJyOc0gAAH4rJydHkZGRcjhYEAAANRWFBLgEXC6XiouLzxpPSEgwkAYAAKD2YMkW4CO3262pU6dqwYIFysvLO+s6m9oBc5KTk8973bIspaamVlMaAMD5UEgAH82fP18zZ840HQNAFTIyMqoctyxLtm3LsqxqTgQAOBcKCeCjJUuWyLIstWjRQunp6bIsS3369NG6det0+eWX6/rrrzcdEaizzjwDyO12KyMjQ0eOHFFoaKjatGljKBkA4EwUEsBHlSdBT5s2Tb169ZIkTZkyRevXr9fw4cM1atQok/GAOu2f//xnleOLFi3SX//6V911113VnAgAcC7cdgTwUUVFhSQpPj5eTqdTklRYWKikpCS53W5Nnz7dZDwAVRg4cKBCQ0NZbgkANQgzJICPoqOjdfz4cRUWFiomJkZZWVmaNGmSgoODJUmZmZmGEwJ11+HDh88aKykp0bp161RUVKSDBw8aSAUAqAqFBPBR06ZNdfz4cWVkZKh9+/b65JNPtGzZMkknN85ec801hhMCdVevXr3OuXHdsixdeeWV1ZwIAHAuFBLARwMGDFCjRo2Un5+v0aNHa/v27Tpy5IgkKSoqSuPGjTOcEKjbznXMVr169TRmzJhqTgMAOBcORgQukYKCAm3btk2lpaVq3769oqKiTEcC6qxp06adNRYUFKT4+Hj16NFD0dHR1R8KAFAlCgngoy1btigpKemc19977z3dcccd1ZgIAACg9uEuW4CPhgwZopdfflllZWVe48ePH9cDDzygCRMmGEoG4ODBg9q8ebP27NnjNb5nzx5t3ryZTe0AUINQSAAfVVRUaM6cOfrd736nXbt2SZJWrlyp3/zmN/rss88MpwPqtmeeeUaDBw/WN9984zW+c+dODR48WBMnTjSUDABwJja1Az4aPHiw3nnnHX377bcaMGCA2rVrpy1btsi2bYWGhuqJJ54wHRGos9LT0yVJPXr08Brv1q2bbNs+q6gAAMxhhgTw0bhx47RgwQL98pe/VFlZmaeMdOnSRStWrNCgQYNMRwTqrPz8fEmS2+32Gq98XFBQUO2ZAABVo5AAP0FBQYGKiopkWZZs25ZlWSosLFRJSYnpaECd9otf/EKS9Oabb3qNz549W5J02WWXVXsmAEDVuMsW4KMnnnhCH330kSQpJCREN954oz7++GNJUkBAgB566CE9/PDDJiMCdda4ceP0wQcfeA5BvPLKK7V3717t3btXktS/f38999xzhlMCACQKCeCzxMRESdJ1112nF198UY0bN9amTZs0duxYHT58WJZlaefOnYZTAnXTwYMH1b9/f+Xn53ud2G7btiIjI/XBBx+oUaNGBhMCACqxZAvwUWBgoB577DGlpKSocePGkqROnTppxYoV6t+/v+F0QN12xRVXKCUlRZ07d5bD4ZBt23I4HLrhhhuUkpJCGQGAGoQZEsBHu3bt8sySVGXt2rW66aabqi8QgCqVlJQoJydH0dHRCg4OPuv65s2bJUkdOnSo7mgAAFFIgJ8sNzdXW7duVU5Ojvr27Ws6DoCLlJiYKIfD4blVMACgenEOCfATzJkzR1OmTFFJSYksy1Lfvn01dOhQHTx4UM8884y6d+9uOiKAC8B7cwBgDntIAB/9+9//1ksvvaTi4mLZtu35gSY5OVkZGRmeO3ABAADg3CgkgI/mzp0ry7LUp08fr/HKfSNff/119YcCAACoZSgkgI92794tSZo0aZLXeHx8vCTp6NGj1Z4JAACgtqGQAD6qPNsgMDDQa/zAgQMm4gAAANRKFBLAR82aNZMkzZ492zO2fft2jR8/XpJ09dVXG8kFAABQm3DbX8BH7777riZOnOh1CvTpJk6cqIEDB1ZzKgAXa8mSJZKkfv36GU4CAHUThQT4CcaOHev5YeZ0/fv31/PPP28gEYBK2dnZmj17tjZu3Ki8vDx9+umnWrFihSoqKtS9e3fFxcWZjggAEIUE+Mm+/PJLrVu3Ti6XS7GxserevbuSkpJMxwLqtKysLA0cOFCHDx+WbduyLEs7d+7Uk08+qRUrVuixxx7T8OHDTccEAIhCAlSLwYMHy7IszZs3z3QUoE54+umntWjRIgUEBKi8vNxTSDZs2KB7771X7du314IFC0zHBACITe1AtUhLS1NaWprpGECdsXbtWlmW5XXTCUlq27atJO6GBwA1CYUEAOB3XC6XJKl9+/ZVXs/JyanGNACA86GQAAD8TkxMjCTp+++/9xr/6KOPJIkN7QBQg1BIAAB+p0uXLpKkESNGeMaGDx+uZ555RpZlea4DAMyjkAAA/M6IESMUFhamjIwMz1lBX3zxhdxut8LDw/Xwww8bTggAqEQhAQD4nSZNmiglJUWdO3eWw+GQbdtyOBzq3Lmz3nnnHTVu3Nh0RADAKdz2F6gGvXr1kmVZWr16tekoQJ1TXFys3NxcRUdHKzg42HQcAMAZKCQAAAAAjAkwHQCozTZs2KCUlBTt3btXxcXFXtcsy1JqaqqhZEDd06JFiwt+rmVZSk9P/xnTAAAuFIUE8NGaNWs0YsQI2bat0ycaLcuSbduejbQAqgcT/gBQO1FIAB/NmTNHbrdboaGhOnHihCzLUlRUlHJychQZGamIiAjTEYE6pV+/fqYjAAB8wB4SwEcdOnRQQUGBFi9erDvuuEOWZWnnzp168803NWfOHM2ZM+eilpAAAADURRQSwEetW7dWRUWFduzYoTZt2kiSduzYobKyMl133XW67rrr9O677xpOCdRt+/btU1pamrKzsxUTE6OOHTuqadOmpmMBAE7Dki3ARxEREcrJyVFZWZkiIyOVl5en9957T6GhoZKknTt3Gk4I1F1lZWV6+umntXTp0rOu9evXT88++6wCAvhfIADUBHw3BnyUkJCgnJwcHTt2TImJiUpLS9PEiRMlndzYXr9+fcMJgbrrlVde0ZIlS6q8tmTJEkVGRmrMmDHVnAoAUBVOagd8dMMNN6hBgwb69ttvdd9998npdHruuGXbtoYPH246IlBnLVu2TJZlqUmTJpowYYKmT5+uCRMmqEmTJrJtu8qZEwCAGewhAS6R7du3a/Xq1SotLdVNN92kTp06mY4E1FnXXXediouLtWrVKjVp0sQzvm/fPt18880KCwvTl19+aTAhAKASS7YAH1W+w9q3b19JUtu2bdW2bVtJ0sGDB3Xw4EFdccUVhtIBdVvXrl21evVqhYWFeY1XPu7evbuJWACAKjBDAvgoMTFRDoejytOez3cNwM/vyy+/1IgRI3T11Vfr4YcfVoMGDZSZmakZM2Zo//79mjZtmi677DLP8xMSEgymBYC6jUIC+CgxMdFz9sjpSkpKdO2111Z5DUD1uJgzgCzL4s0DADCIJVvARUhNTdXq1au9xsaOHev1+MCBA5J01lIRANWH99oAoPagkAAXYdeuXV535znf3XpatWpVPaEAnGXkyJGmIwAALhCFBLhIle+8Wpbl9bhSVFSUWrdurb/85S/Vng3ASRQSAKg92EMC+Ohce0gAAABw4ZghAXw0efJk0xEAnENJSYlmzJihVatWKTMzU2VlZV7X2cgOADUHMyTAJeByuVRcXHzWOLcSBcx4+umntXjxYklVb3BndhMAag5mSAAf2batKVOmaMGCBcrLyzvrOu/AAuakpqZKkho2bKhrr71WQUFBhhMBAM6FQgL4aN68eZo5c6bpGACqUHnTicWLFysmJsZwGgDA+ThMBwBqqyVLlsiyLLVs2VLSyR+AfvWrXykkJESNGzdW3759zQYE6rA777xTtm1r7dq1pqMAAH4Ee0gAH7Vr104lJSVavXq1evXq5VmTvn79eg0fPlwvvfSSfvOb35iOCdRJbrdbI0aM0Nq1a9WgQQM1aNBATqfTc92yLM2bN89gQgBAJZZsAT6qqKiQJMXHx8vpdMrtdquwsFBJSUlyu92aPn06hQQw5MMPP/TMjmRmZiozM9NzzbZtz5IuAIB5FBLAR9HR0Tp+/LgKCwsVExOjrKwsTZo0ScHBwZLk9QMQgOr1xhtvVHl3LQBAzUMhAXzUtGlTHT9+XBkZGWrfvr0++eQTLVu2TNLJ5SDXXHON4YRA3eVyuWRZlqZOnaru3bt73igAANQ8bGoHfDRgwAD17dtX+fn5Gj16tOLj42XbtmzbVmRkpMaNG2c6IlBn9ejRQ5LUpk0byggA1HBsagcukYKCAm3btk2lpaVq3769oqKiTEcC6qyPP/5Yf/3rX3X55Zdr8ODBatiwoQICvBcFdOjQwVA6AMDpKCQAAL+TmJh43o3rHFwKADUHe0iAizB48OALfi63FQXM4v02AKgdKCTARUhLS7ug24VyW1HArMmTJ5uOAAC4QBQS4CIkJCR4Pc7JyVFRUZECAwMVFRWl3NxclZWVKTQ0VLGxsYZSAujXr5/pCACAC8QeEsBH27Zt07333qtBgwZp5MiRCg4OVmlpqd544w2lpKRo9uzZSkpKMh0TqPNcLpeKi4vPGj/zDQYAgBkUEsBHAwcO1I4dO7RlyxaFhYV5xgsKCpSUlKQ2bdpo8eLFBhMCdZfb7dbUqVO1YMEC5eXlnXWdTe0AUHNwDgngo127dkmS1q9f7zVe+Xj37t3VngnASfPnz9fMmTOVm5vrOR/ozA8AQM3AHhLARwkJCdq/f79Gjx6tNm3aqH79+jp69Kh27Nghy7JYDgIYtGTJElmWpRYtWig9PV2WZalPnz5at26dLr/8cl1//fWmIwIATmGGBPDRqFGjJJ1cGrJ9+3Z9+umn2r59u9xutyTpT3/6k8l4QJ22f/9+SdK0adM8Y1OmTNH06dN16NAhde3a1VQ0AMAZKCSAj2699VbNnTtX119/vZxOp2zbltPpVFJSkubNm6dbbrnFdESgzqqoqJAkxcfHy+l0SpIKCwuVlJQkt9ut6dOnm4wHADgNS7aAn6BTp05KSUmR2+1Wdna2YmJi5HDQ8wHToqOjdfz4cRUWFiomJkZZWVmaNGmSgoODJUmZmZmGEwIAKvGTE3AJOBwOff7551q+fLnpKAAkNW3aVJKUkZGh9u3by7ZtLVu2TIsWLZJlWbrmmmvMBgQAeHDbX+ASSUxMlMPh4FaiQA2wfPlybdiwQf3791dcXJzuu+8+HTlyRJIUFRWlf/zjH2rXrp3ZkAAASRQS4JJJTEyUZVnauXOn6SgAzlBQUKBt27aptLRU7du3V1RUlOlIAIBTWLIFAPA7W7Zs8XocHh6url27qmfPnoqKitJ7771nKBkA4EwUEgCA3xkyZIhefvlllZWVeY0fP35cDzzwgCZMmGAoGQDgTCzZAi6RtLQ0SVLHjh0NJwFQuYTy6quv1ksvvaTExEStXLlSzz77rHJyclheCQA1CIUEAOB3nn/+eb3zzjtyu90KDAxUu3bttGXLFtm2rdDQUD3xxBMaNGiQ6ZgAALFkC/DZCy+8oOTkZM2dO9dr/O2331ZycrJefPFFM8EAaNy4cVqwYIF++ctfqqyszFNGunTpohUrVlBGAKAGoZAAPkpNTdXhw4fVs2dPr/HevXsrIyNDqamphpIBkE7eWauoqEiWZcm2bVmWpcLCQpWUlJiOBgA4DYUE8NEPP/wgSapfv77X+GWXXSZJOnr0aLVnAnDSE088oeHDhyszM1MhISG6+eabJUk7duxQ3759NWPGDMMJAQCVKCSAj4KDgyVJmzZt8hqv3NweEhJS7ZkAnPThhx/Ktm21a9dOy5Yt0+uvv665c+eqQYMGKisr09SpU01HBACcQiEBfNSqVSvZtq0nn3xSs2bNUmpqqmbNmqUnn3xSlmWpZcuWpiMCdVZgYKAee+wxpaSkqHHjxpKkTp06acWKFerfv7/hdACA03GXLcBHqampGjlypCzL8hqvXKs+depU9e7d21A6oG7btWuXEhMTz3l97dq1uummm6ovEADgnCgkwE8wY8YMTZ8+XRUVFZ6xgIAAjRgxQg899JDBZAAkKTc3V1u3blVOTo769u1rOg4AoAoUEuAnysjI0Pr16+VyuRQbG6tu3bopISHBdCygzpszZ46mTJmikpISWZal9PR0DR06VAcPHtQzzzyj7t27m44IAJAUYDoAUNs1bNhQAwcONB0DwGn+/e9/66WXXjprPDk5Wc8995w++ugjCgkA1BBsagd8xMGIQM01d+5cWZalPn36eI1X7hv5+uuvqz8UAKBKFBLARxyMCNRcu3fvliRNmjTJazw+Pl4S5wQBQE1CIQF8xMGIQM1Vefe7wMBAr/EDBw6YiAMAOA8KCeAjDkYEaq5mzZpJkmbPnu0Z2759u8aPHy9Juvrqq43kAgCcjUIC+IiDEYGa64477pBt2/r73//umS258847tW3bNlmWpTvuuMNwQgBAJe6yBfjo7rvv1saNG5WXl6fXXnvNM155MOLdd99tMB1Qt/3+97/X9u3btWTJkrOu9e/fnzvjAUANwjkkwE/AwYhAzfbll19q3bp1nnOCunfvrqSkJNOxAACnoZAAPxEHIwK12+DBg2VZlubNm2c6CgDUSRQS4CfYu3evPvnkEx0+fFilpaVe1yzL0vPPP28oGYALlZiYKMuytHPnTtNRAKBOYg8J4KOVK1fqz3/+s9xu9zmfQyEBAAA4PwoJ4KOpU6d67R0BAADAxaOQAD7KzMyUZVmaOHGibr/9ds+5JAAAALhwnEMC+KjynJFbbrmFMgIAAOAjCgngo3HjxikkJEQvv/yyCgsLTccBAAColbjLFnARkpOTvR67XC4VFxfL6XQqLi5OAQH/twrSsiylpqZWd0QAF6lXr16yLEurV682HQUA6iQKCXAREhMTL/i53EYUAADgx7GpHbgIHTp0MB0BwAXasGGDUlJStHfvXhUXF3tdYwYTAGoOZkgAAH5nzZo1GjFihGzb1un/m7MsS7ZtM4MJADUIm9oBAH5nzpw5crvdCgkJkXSyiERHR8u2bUVGRiohIcFwQgBAJQoJAMDv7Nq1S5Zl6Z///KdnbOPGjXr88cfldDo1bdo0g+kAAKejkAAA/M6JEycknbwRhWVZkqTy8nLdfffdys7O1rPPPmsyHgDgNGxqBwD4nYiICOXk5KisrEyRkZHKy8vTe++9p9DQUEli/wgA1CAUEgCA30lISFBOTo6OHTumxMREpaWlaeLEiZJO7iepX7++4YQAgEos2QIA+J0bbrhBDRo00Lfffqv77rtPTqfTc8ct27Y1fPhw0xEBAKdw218AgN/bvn27Vq9erdLSUt10003q1KmT6UgAgFMoJAAAv7N06VJJUt++fc+6dvDgQUnSFVdcUY2JAADnQiEBAPidxMREORwOpaenX9Q1AED1Yw8JAMAvVfV+W0lJyTmvAQDM4C5bAAC/kJqaqtWrV3uNjR071uvxgQMHJElhYWHVlgsAcH4UEgCAX9i1a5dn74h0chbk9Mena9WqVfWEAgD8KAoJAMBvVC7Fqjyd/cylWVFRUWrdurX+8pe/VHs2AEDV2NQOAPA7iYmJsiyLE9kBoBZghgQA4HcmT55sOgIA4AIxQwIA8Gsul0vFxcVnjSckJBhIAwA4EzMkAAC/Y9u2pkyZogULFigvL++s65ZlcQ4JANQQFBIAgN+ZN2+eZs6caToGAOACcDAiAMDvLFmyRJZlqWXLlpJOzoj86le/UkhIiBo3bqy+ffuaDQgA8KCQAAD8zv79+yVJ06ZN84xNmTJF06dP16FDh9S1a1dT0QAAZ6CQAAD8TkVFhSQpPj5eTqdTklRYWKikpCS53W5Nnz7dZDwAwGnYQwIA8DvR0dE6fvy4CgsLFRMTo6ysLE2aNEnBwcGSpMzMTMMJAQCVmCEBAPidpk2bSpIyMjLUvn172batZcuWadGiRbIsS9dcc43ZgAAAD2ZIAAB+Z8CAAWrUqJHy8/M1evRobd++XUeOHJEkRUVFady4cYYTAgAqcTAiAMDvFRQUaNu2bSotLVX79u0VFRVlOhIA4BQKCQAAAABjWLIFAPALgwcPvuDnWpalefPm/YxpAAAXikICAPALaWlpsizrR59n2/YFPQ8AUD0oJAAAv5CQkOD1OCcnR0VFRQoMDFRUVJRyc3NVVlam0NBQxcbGGkoJADgTe0gAAH5n27ZtuvfeezVo0CCNHDlSwcHBKi0t1RtvvKGUlBTNnj1bSUlJpmMCAEQhAQD4oYEDB2rHjh3asmWLwsLCPOMFBQVKSkpSmzZttHjxYoMJAQCVOBgRAOB3du3aJUlav36913jl4927d1d7JgBA1dhDAgDwOwkJCdq/f79Gjx6tNm3aqH79+jp69Kh27Nghy7LO2m8CADCHJVsAAL+zcuVKPf7442fdUavy8auvvqpbbrnFYEIAQCUKCQDAL23atElTpkzRtm3bVF5eroCAALVr106jRo1Sx44dTccDAJxCIQEA+DW3263s7GzFxMTI4WDrJADUNHxnBgD4NYfDoc8//1zLly83HQUAUAVmSAAAfi8xMVEOh0Pp6emmowAAzsAMCQCgTuD9NwComSgkAAAAAIyhkAAAAAAwhoMRAQB+b/78+aYjAADOgU3tAAAAAIxhyRYAwO+88MILSk5O1ty5c73G3377bSUnJ+vFF180EwwAcBYKCQDA76Smpurw4cPq2bOn13jv3r2VkZGh1NRUQ8kAAGeikAAA/M4PP/wgSapfv77X+GWXXSZJOnr0aLVnAgBUjUICAPA7wcHBkqRNmzZ5jaelpUmSQkJCqj0TAKBq3GULAOB3WrVqpY0bN+rJJ5/UsGHD1KxZM33//fd66623ZFmWWrZsaToiAOAU7rIFAPA7qampGjlypCzL8hq3bVuWZWnq1Knq3bu3oXQAgNOxZAsA4Hd69+6tUaNGyeFwyLZtz0dAQIBGjRpFGQGAGoQZEgCA38rIyND69evlcrkUGxurbt26KSEhwXQsAMBpKCQAAAAAjGHJFgDA73AwIgDUHhQSAIDf4WBEAKg9KCQAAL/DwYgAUHtQSAAAfoeDEQGg9uBgRACA3+FgRACoPbjLFgDA73AwIgDUHizZAgD4HQ5GBIDagxkSAIDf4mBEAKj5KCQAAL+0d+9effLJJzp8+LBKS0u9rlmWpeeff95QMgDA6SgkAAC/s3LlSv35z3+W2+0+53N27txZjYkAAOfCXbYAAH5n6tSpqqioMB0DAHABKCQAAL+TmZkpy7I0ceJE3X777Z5zSQAANQ932QIA+J3Kc0ZuueUWyggA1HAUEgCA3xk3bpxCQkL08ssvq7Cw0HQcAMB5sKkdAOAXkpOTvR67XC4VFxfL6XQqLi5OAQH/t0rZsiylpqZWd0QAQBXYQwIA8AsZGRlVjpeXl+vo0aNeY2ee4A4AMIdCAgDwCx06dDAdAQDgA5ZsAQAAADCGTe0AAAAAjKGQAAAAADCGQgIAAADAGAoJAAAAAGMoJAAAAACM4ba/AGq0Dz74QGPHjvU8DgoKUlRUlJo3b64bb7xR/fv3V3h4+EW/7ldffaX169dryJAhioyMvJSRfZKSkqLQ0FD179/fdBQAAKoVhQRArTBq1Cg1atRI5eXlOn78uNLS0vT8889r7ty5mjFjhhITEy/q9bZu3app06apX79+NaKQvPvuu4qJiaGQAADqHAoJgFqhR48eatOmjefxAw88oA0bNujBBx/Uww8/rJUrVyokJMRgQgAA4Av2kACotbp06aKHH35YGRkZWr58uSRp165dGjNmjJKTk9WmTRt17dpVY8eOVXZ2tufzpk6dqpdeekmSlJycrObNm6t58+Y6dOiQJOn999/X4MGD1aVLF7Vu3Vq33nqrFixYcNbX37Fjh4YNG6ZOnTqpbdu26tWrl9fyMklyu92aO3eufv3rX6tNmza64YYb9PTTTys3N9fznF69eum7775TWlqaJ8s999xzyf++AACoiZghAVCr3X777Xr11Vf1xRdfaODAgfrf//1fHTx4UP3799cvfvELfffdd1q0aJH++9//atGiRbIsS3369NG+ffv04YcfauzYsYqJiZEkxcbGSjq5fOrqq69Wr169FBAQoDVr1mjixImybVuDBg2SJGVlZWnYsGGKiYnR/fffr8jISB06dEiffvqpV76nn35aS5YsUf/+/XXPPffo0KFDSklJUXp6ut59910FBgZq3LhxmjRpkurVq6cHH3xQknTZZZdV498iAADmUEgA1Grx8fGKiIjQwYMHJUl/+MMfdN9993k9p127dnrsscf05ZdfKikpSYmJiWrZsqU+/PBD9e7dW40aNfJ6/jvvvOO1/Ovuu+/WsGHD9Pbbb3sKydatW5Wbm6u33nrLaynZo48+6vn9li1btHjxYr3yyiu67bbbPOOdOnXSH//4R61atUq33Xabevfurddff10xMTG6/fbbL91fDgAAtQBLtgDUevXq1VNhYaEkeRWJkpISuVwuXXvttZKkb7755oJe7/TXyM/Pl8vlUseOHXXw4EHl5+dLkiIiIiRJa9euVVlZWZWvs2rVKkVERKhr165yuVyej1atWqlevXratGnTxf9hAQDwM8yQAKj1ioqKFBcXJ0nKycnRtGnTtHLlSmVlZXk9r7JM/Jgvv/xSU6dO1ddff60TJ06c9RoRERHq2LGj/ud//kfTpk3T3Llz1bFjR/Xu3Vu33XabgoKCJEn79+9Xfn6+unTpUuXXOTMfAAB1EYUEQK125MgR5efnq3HjxpKk0aNHa+vWrRo2bJhatGihevXqye12649//KNs2/7R1ztw4ICGDh2qZs2aacyYMWrQoIECAwP12Wefae7cuXK73ZIky7I0ZcoUff3111qzZo0+//xzjRs3Tm+//bb+9a9/KSwsTG63W3FxcXrllVeq/FqVe1YAAKjLKCQAarVly5ZJkrp166bc3Fxt2LBBjzzyiEaOHOl5zr59+876PMuyqny9//znPyotLdXMmTOVkJDgGT/X8qp27dqpXbt2evTRR7VixQo98cQTWrlypQYMGKDGjRtrw4YNat++/Y/ekvhceQAA8HfsIQFQa23YsEEzZsxQo0aN9Nvf/lZOp7PK582bN++ssdDQUElnL+OqfI3TZ1Py8/P1/vvvez0vNzf3rBmXFi1aSJJKS0slSbfccosqKio0Y8aMs75+eXm58vLyvPKc/hgAgLqCGRIAtcK6dev0/fffq6KiQsePH9emTZu0fv16JSQkaObMmQoODlZwcLA6dOig2bNnq6ysTPXr19f69es954ucrlWrVpKk1157TbfeeqsCAwPVs2dPde3aVYGBgXrwwQd11113qbCwUIsXL1ZcXJyOHTvm+fwlS5bo3XffVe/evdW4cWMVFhZq0aJFCg8PV48ePSRJHTt21J133ql//OMf2rlzp+e19+3bp1WrVmn8+PG6+eabPXneffddzZgxQ02aNFFsbOw5954AAOBPLPtCFlUDgCEffPCB12GDgYGBio6O1jXXXKObbrpJ/fv3V3h4uOf60aNHNWnSJG3atEm2batr164aP368unfvrpEjR+qRRx7xPHfGjBlauHChjh07JrfbrdWrV6tRo0b6z3/+o9dff1379u3TZZddpt///veKjY3VuHHjPM9JT0/XW2+9pa+++krHjx9XRESE2rZtq5EjR6p169Zef4ZFixZp4cKF2rNnj5xOpxo2bKgePXpoyJAhuvzyyyVJx48f1/jx47V582YVFhaqY8eO+uc///kz/+0CAGAehQQAAACAMewhAQAAAGAMhQQAAACAMRQSAAAAAMZQSAAAAAAYQyEBAAAAYAyFBAAAAIAxFBIAAAAAxlBIAAAAABhDIQEAAABgDIUEAAAAgDEUEgAAAADGUEgAAAAAGPP/AQ95Op2a71+BAAAAAElFTkSuQmCC\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAAxkAAALnCAYAAADlDIoiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACy7UlEQVR4nOzdd3zTdeLH8VdW05W0ZRRadhFZiuACF4jiQlFE3MgpioKHe+s5Tu/OO/XO+ykqBzIUnGwBByiKioogUzYtlFGgQEfSpE2zfn9wRDlWW9J+0/b9fDx4kCbf8Q4lbd75fj7frykcDocRERERERGJErPRAUREREREpG5RyRARERERkahSyRARERERkahSyRARERERkahSyRARERERkahSyRARERERkahSyRARERERkahSyRARERERkahSyRARERERkaiyGh2grgmHw4RCuoh6XWI2m/Q9FYlRen3WHWazCZPJZHQMEYkSlYwoC4XCFBR4jI4hUWK1mklLS8Ll8hIIhIyOIyK/o9dn3dKgQRIWi0qGSF2h4VIiIiIiIhJVKhkiIiIiIhJVKhkiIiIiIhJVKhkiIiIiIhJVmvgtIiIitV4wGMTv9xsdQ6TOstlsWCyWCi+vkiEiIiK1VjgcZufOnRQVFRHW2YxFqo3JBKmpqWRkZFTodNMqGSIiIlJr7dy5k8LCIhyOVOx2O6DT4IpEXxifz0dhYREAmZmZx1xDJUNERERqpWAwSFHR/oLhcKQYHUekTouLiwegqKiIJk2aHHPolCZ+i4iISK3k9/sJh/nvEQwRqW52u51wmArNf1LJEBERkVpOQ6REakbFX2sqGSIiIiIiElUqGSIiIiIiElWa+C0iIiJioOeff5ZPP50FQIsWLfnoo2mYzfs/B542bQovvfQ3AP70p+e44oorq7ztn35aGsXUxzZ8+FCWLfsl8rXJZCIhIYHmzVvQu/eF3HLLH7BabTWaSWpOTJWM3NxcxowZw7Jly8jOzib83xNer1y58oiTuh566CFmz54NQKNGjVi4cGGF9rV8+XJee+01li9fTigUokOHDgwfPpxevXpF58mIiIiIVNK2bVv56qt5XHTRJUZHibpwOIzX62XDhvVs2LCeffv28vDDjxsdS6pJTA2X2rhxI5MnT2bTpk2RgnE0ixYtihSMyli8eDGDBg1i4cKFeDweSktLWbZsGXfddVeVticiIiISLRMmjK3Q+6CKeOaZP/PTT0tr/CjG/5o2bTY//vgL//d/b0Yu5DZ37heGZpLqFVNHMtLT0xk2bBhdu3blzTffZOXKlUdc1u/38/zzz2M2m7HZbPh8vgrv59lnn8Xv9+NwOBg/fjwpKSn84Q9/IC8vjxdeeIE+ffoQHx8fjackIiIiUmEWi4Xs7E18990CevY8/4jLvfnm6/z880/s2rUTt7uEhIR42rVrz003DeK8834blfG/w6W++moeTz31GAAvvfQqPXv+tuyAAf3Iy9tBp04nMW7cuwBs3bqV8ePHsHjxIoqKikhLS+Pss8/lzjvvpmHDhpV6biaTie7de5CamkZhYQHl5b+9d3O73bz88t9Zv34t+/btpbS0jJSUFE45pStDhw4jK6stixcv4p57hgPw+ON/on//AZH1b775OrKzN9G27Qm8997HAOzbt5exY8fwww/fs3fvHpKTkznjjO7ceedwWrRoGVn3yy/n8v77k9i+fStlZWWkpTXgxBPbc/PNt9C166mVeo7ym5g6ktGlSxceeOABevfufcw3+RMmTGDTpk1cd911NGrUqML7WL16NdnZ2QD07duXk08+mZYtW3LDDTcA+y8w8t1331X9SYiIiIihwuEwoVDQkD/HewTiwgsvAvYfzTiauXM/Z926tRQVFREMBigpKWHZsl949NEHWbTopyOud+65PUlOTgbgq6/mRu5fs2Y1eXk7AOjb93IANm3ayG23DeKzz+awd+9eAoEAe/bsYebM6dx++2AKCwsr9dzC4TBLlvxMcXERwEElyu12M3fuZ+TmbqGkpIRgMEBBwT6+/vorhg27g4KCAs44ozutWrUGYPbsmZF1t27dSnb2pv9mvwKAPXv2cOutg5g2bTK7du0kEAhQVFTEvHlfcPvtg9m6NReAVatW8PTTT7Bmza+4XC7Ky8vZvXsX3323gNWrf63U85ODxdSRjIratWsXb775Jg0aNODBBx+sVClYs2ZN5HZWVtZhb69evZqLLrooOmGl1jKZ9mG3fwTcBiQZHUdEficcDrNq1QpSU5Np0aKt0XEkhoTDYbKz1+H1egzZf2JiMm3bto8MCaqs6667gYULv2fNmtUsWvTjEZe7774Hadu2HY0aNcJms7Fp00aGD7+DsrIypk79mO7dexx2PbvdzgUXXMQnn0zn+++/o7y8nLi4OL76ah4AVquVPn0uBuDf//4nHk8JTZtm8NJL/6J16zasXLmc++4bwa5dO5k0aQL33PNAhZ7XgAFXHPR1ZmYzHnjgkcjXTqeDF198mc6dTyI1NY1gMMjcuZ/z4osv4HIVM3fuZ9xww81cc811/OtfL/Hrr6vYvDmHNm2ymD9/f3aLxcqll/YFYPTot9izJ5/k5GRefvlVOnc+mc2bc7jnnuG4XMWMGvUGf/vbS6xcuZJwOExiYhITJ35A48bp5OfvZunSX0hPT6/Qc5PDq5Ul429/+xter5c//elPpKSkVGrdgoKCyO0DTf5/b/9+maqwWmPqAJEcxbZtW3G73Yd9LDPzAxo1+jclJRNYv34MwWDcYZdzOBwHHXYVkeg40uuzrKyMH3/8nry87dhsNq6//maO9uGxXqP1Ue29OF9ysoNrrrmWd98dz4QJY7nooksPu5zdbucf//gLGzduwO12H3QEJTd3y1H30bfv5XzyyXQ8nhJ++ukHevY8n/nzvwTgrLPOITU1jbKy0siZoXbt2sngwTcesp0lSxZX8VlCXt4OnnrqMd58czSw/3nv3LmT8ePHsm1bLqWlpQctn5u7/8jD5ZdfwahRI/F6vcyaNZN7732A+fO/AqBHjx40bLh/dMuPP34PQElJCcOHDz1i9oyMDABKS72MHTuGjh070rZtOy655DJdSf441bqS8f333/PFF1/QrVs3BgwYcOwVKihaE6zMZhNpafrUuzYoKCjg8ssvJhQKHfbxzMwgn39upmHDdWzZcjEPPZTK4X5xWSwWli9fToMGDao3sEg9cqTXZ+PGjTn11FOJj48nGAyybNkypkyZctRt6TVav5hMJtq2bU84fPif7dW/f3OVj2IccOONg/j44w9Ytmwp6elNDnl89epfefTRBwkEAodd/1jzVE85pRsZGZns3JnHV1/No1GjxuzcmQfAZZftP+LgcrkJBoNH3Y7L5arI0wH2T/zOzMxkx47tPPLIA+TkZLN06RJ+/XUVJ510Mh98MInXXvvXEdc/8JySkpK55JK+TJ8+hc8+m8NVV13Nhg3rAOjbt19k+cLComNkLwbg/PMvoF+/q/j00zl8+umsyPwVh8PBc8/9hXPOOa/Cz1EOVutKxhtvvAHA9ddfz7p1+/9TlZeXAxAIBFi7di1NmjQ54i+T399fUlISue3xeA67TGWFQmFcLm+V15eaYzLZmTNn7hGPZACsXv0555zzLDfcUMoZZ9zLrl2HFluHw4HJZKew0JhD8yJ10f++PoPBICtWLGPt2v1jpFNSUmnfviObNm3itdfeoGnTzCNuS6/R2sHpTMBiic5IAJPJhMlkicq2jJCWlsZVV13NRx99wJdfzj3k8W+//TpSMB5++HGuvLI/cXFxXHLJBZH5DkdjMpm49NK+jB//Nt999y1O5/5RIQ6Hg3PP3f+m2ul0YrFYCAaD9OhxFv/+9xuHbKcqH9A2a9acs846m5yc/fNj8/J2cNJJJ0eOpNjtdt58cwwdOnRky5bN3HzzdYdsY+DA65g+fQqFhQX87W/P/zdvykET3tPSUtm7dy+tWrXmo4+mHTG72Wzmqaee5b77HmTDhg1s3ZrLhx++x5Ytm3n11VdUMo5DrSsZXu/+N/CPP37oeZWLioro378/TzzxBLfeeuth1+/UqVPkdk5OzmFvd+7c+bgyBgLGfHoilZeR0Zz/Hik9rO3bE3nnnQ8ZMmQtWVn/okGDPgQC3Q9ZTt9zkeg78Prct28vU6Z8QF7edgBOP70Hl1xyOfn5O5k69WOysk6gefNWR92WXqNS29x88x+YNm0Kfr//kMfKy3+7LzExkWAwyMSJEypUMA647LLLGT/+bbxeD9Om7T8aeOGFFxEXt39ocHx8PN26ncqSJYtZtOgnZsyYGhm6tXbtambP/oTu3c/isssur9Tz2rFjOz/++EPk6wPDmw58YAwmEhMTKSlx8/bb/znsNtq2PYFu3U5l2bKlrFixHICLLro4kh32D/uaNWsmublbGDNmFNdffxNxcTY2btzA559/SpMmTRk8+DZ++WUx69ev56yzzqZDh460a3ciCxd+x5YtmykqqtzEdjlYTJUMv98f+dTq9y+qoqIibDYbCQkJldretGnTeOKJJwB499136d69O507d6Zt27ZkZ2fz6aefcu211+J0Ovnwww8BSE1N5bzz1FrlN9OnZ3H11S1IS5uL03kLhYXfEQ4fevhaRKIrHA6zYsVS5syZQXl5OQkJiVx11UA6djy+D4JEaoP09HQuv7wfM2Yc+in8ueeexwcfTALg+eef4fnnnyElJRWHw3HUo/O/17JlKzp3PonVq38lGNx/VOTAUKkD7rvvIYYNuwOPp4S///2v/P3vfz3o8dNPP7PCz+d/J34DnHBCO045pet/n1NP1q9fh89Xxo03DgSgefPmR9zeNddcx7Jlv1374/dDpQCGDh3OTz/9yJ49+YwdO5qxY0cf9Pjtt98JwM6dO3nttX8ddqhWjx5nV+zJyWHFVMlYunQpgwcPPuT+nj17AjBixAhmzpx5yOMXXHABO3bsqPAVv5977jmGDBmC2+1m4MCBkftNJhNPP/20rpEh/8PE1q0v4HBsxWpdR0rKYIqKZgM2o4OJ1FllZaXMnj2DVauWA9C6dRYDBlxPSkqqoblEatItt9zKrFmfRErAAaeddgZPPPE0EyeOZ8+ePbRrdyIPP/w4jz/+cIVLBuw/mnHgNK3NmjWPvOE/oF27Exk/fhLjx49hyZKfKSgoJCUlhWbNmnPuuedx1lmVfxNutVpp0qQpZ511DnfccSdW6/63on/4wxA8nhK++OJzfL4yevQ4m0GD/sCQIbccdjvnn9+bhg0bsW/fXtq0yaJz55MOejw9PZ0JEyYxbtwYFi787ToZGRmZ9OhxduRUt506daZv3ytYtWol+/btJRgM0bhxY3r1Op8hQ+6s9POT35jC0ZrxHAWLFi06bMk4YMSIEdxzzz2H3H+kknG4IxkHLF++nNdee43ly5cTCoXo0KEDw4cPp1evXodsvzKCwRAFBRr3W1ds357LM888wfPPv0irVuWkpvbGbHbh9d6Fx/Oy0fFE6qRt23KZOvVDCgsLMJvNnH/+RZx33vmYzQeP1//96/NYw6Uk9jVokFTpORllZWVkZ+fQqFFT4uJ0JqD6pKiokIEDr6KkpIR7732Qm24aZHSkeqG83Mfevbto2zbrmB/Kx9SRjO7du7N+/fpKrzd//vzD3j9gwIAjnoGqa9eujBs3rtL7kvorGGyH2z2GlJTrSUz8D4HAqfh8h57ST0SqJhQK8d133/DNN/MIhUKkpqYxcOCNtGihAiEi++Xn5zNixF3s2ZNPaWkpqampXHVVf6NjyWHEVMkQiXXl5Zfh8TxGUtI/cDjuIxjsRCBwitGxRGq94uIipk37iC1b9p+E4+STu3LFFf2Jj6/cXDwRqdsCgQBbt+ZitVpp374DjzzyOElJycdeUWqcSoZIJXm9T2C1LsNun4vTOYjCwm8IhxsaHUuk1lq7djUzZ06htNRLXFwcl1/en1NOOfW4rzUgInVPZmYmP/209NgLiuFUMkQqzYzbPQar9Xwsls04nbdTXDwVqL3nZBcxgt/v5/PPZ7NkyU8AZGY2Z+DAGyOntBQRkdpLJUOkCsLhNIqL3yct7ULi4uaTlPQXPJ5njY4lUmvs3r2TyZPfZ8+efADOOacXF1xwceRMMyIiUrvpp7lIFQWDnXG7R+J0DiEx8Z/4/d0oL7/S6FgiMS0cDvPzzz8yd+4cAoEAyckOBgy4jrZtTzQ6moiIRJFKhshx8PkG4vUuIzHxdRyOYRQVtScYbG90LJGY5PF4mDlzMuvXrwXgxBM70L//tZq0KSJSB6lkiBwnj+fPWK0riIv7FqfzJoqKviYcdhodSySm5ORsYtq0D3G73VitVi66qC/du5+tyd0iInWUSobIcbPick0gLa0nVutGHI5huFyTgMpdVEqkLgoGg8yfP5eFCxcQDodp3DidgQNvomnTDKOjiYhINVLJEImCcLgRLtdEUlMvwW6fTWLiv/B6HzY6loihCgr2MWXK++zYsR2A0047k0sv7UdcXJzByURiy/PPP8unn84C4I03RnPaaafX2L579DgVgL59+/HMM3+u8Hq//LKEpUuXAHDDDTfjcDgij40ZM4qxY0cDMG3abDIzM6OS8QCz2UxKSgonndSF22+/kw4dOh7X9mub2bM/4S9/eQ6o+f8vlaGSIRIlgcBplJT8C4djBImJL+D3n4Lff5HRsUQMsWLFUmbPnk55eTkJCQlceeVAOnU6yehYIhIlS5cuiRSJyy+/8qCSUd1CoRCFhYV8990CfvllMZMmfURmZrMa279UjEqGSBSVlQ3Gal1KQsI4nM7bKSxcQCjUxuhYIjWmrKyMOXNmsHLlMgBatWrDNdfcQEpKqrHBROSwquPCdkOHDmPo0GFR327TphnMmDGH4uJiXnjhWb7//lu8Xi+ff/4pQ4YMjfr+jqWsrIz4+Pga3+8VV1zJFVfE/tksVTJEoqyk5B9Yrauw2RaTkjKIwsJ5QKLRsUSq3fbtW5ky5QMKCwswm82cf34fzjuvN2az5ieJREN5eTmTJr3D3Lmfk5e3A6vVRvv2Hbj55ls499yekeVCoRBvv/0fZsyYRmmpl7PPPpcbbxzEHXf8AYDbb78zUgION1zq558XMWHCWHJyNuHxeEhNTaVt2xO4+uqB9OrVm/79L2fXrp2R/Q0YcAXwWwk40nCpgoICJkwYyw8/fMfu3btJSEggK6st99zzAJ07V/xIZ0pKCldddTXff/8tALt37zro8X379jJ27Bh++OF79u7dQ3JyMmec0Z077xxOixYtI8sVFxfxz3++zPffL8But9OvX38yM5vx97//BfhtKNIvvyzhj3+8E4CHH36cLVty+PLLuQSDQebNWwDA4sWLmDTpHdasWU1ZWRkZGZlceunlDB78B6xWGwClpaWMHv0W3377DXv37sFms9GkSVM6dTqJhx56lPj4+Aotc6ThUiUlbsaNe5sFC74mP3//v2/nzidz6623c8opXSPP+8D3r1u307jhhpsYPfottm/fTsuWLbnvvgc5/fQzK/y9OBqVDJGos+NyTSQt7Tys1lU4HPfgdr8N6Cw6UjeFQiG+/34BX389l1AoRGpqGtdccwMtW7Y2OppInREIBHjggRH88suSyH3l5eUsW/YLy5b9wsMPP8bAgdcDMG7cGMaNGxNZ7quv5rFy5fIK7WfnzjweeeR+fD5f5L49e/awZ88emjdvQa9evauUf8+ePdxxxx8OKgR+v5/ly5exeXNOpUoGQDj82+20tAYH7WfIkFsiF/oEKCoqYt68L1i06EfefvsdWrZsBcATTzwamVfi9Xp5993xNG7c+Kj7HT36LVyuYgCSk/effnv27E/461//TPh3obZuzWX06DdZvXolr7zyf5hMJl577VWmT58SWcbn81FSsons7E388Y/3EB8fX6FlDsfjKeHOO4eQk5Mduc/v9/Pjjwv5+eefePHFV+jZs9dB62zYsJ7HH384knvjxg08+uiDTJ8+h5SUlKP+O1SEPl4SqQahUCYu17uEw1bi4yeTkPCW0ZFEqoXLVcy7777NV199TigU4qSTTmHYsPtUMMRQ4XCY8vJyQ/78/o1mNM2d+3mkYPTq1ZvPP/+KCRPeo0GDhgC88cZruN1uSkrcvP/+RADS0tKYMGESc+bMo0WLVhXaz9q1ayMFY/z4SXz33SJmzJjD88//jVNO6QbAjBlzuP32OyPrTJs2m59+WsqMGXOOuN3Ro9+KFIyLLrqEmTM/Zd68Bbz00r9o3rx5pf4tiouL+eST6QD/PWp6wUH72bMnn+TkZN56awzffvsT77zzPk5nCi6Xi1Gj3gD2H3k4UDBOPvkUZs/+gokTPzzm98/n8/G3v73M118v5D//GYfX6+Xf/36FcDjMWWedwyeffMY33/zA8OEjAFi48Ht++OF7gEjRu/DCi/j664XMm7eAceMmcvvtQ7HZ4iq8zOF8+OH7kYIxcOB1zJu3gJEjR2G3xxMMBnnllb8TCoUOWsfjKWHIkKF8+eUCbrvtDmB/2frxx4VH/wZUkI5kiFQTv/8cPJ6/kpz8GElJTxEIdMHvP9foWCJRs27dambMmEJpqZe4uDj69r2Krl1P07UvxFDhcJjRo99g69ZcQ/bfqlVrhg69O+qvg9+/8bvrrrtJTU0jNTWNK6/sz4QJYyktLWX58qU4HA68Xi+wfwhUhw6dALjtttsjb6qPJiPjt9NLT5gwlq5du5GV1ZZzzjmPpKSk48i//412cnIyTz31bOQT+Z49z6/wNnbt2nnQmaaczhTuv/+hg84udWA/JSUlDB9+6DyNJUsWA7Bq1crIfbfddjuNGjWmUaPG9OvXn/Hj3z5ihr59L+eCCy4EoG3bE1i06EdKSkr+u++FXHnlZYfd5znnnEfTpk3Jzt7EypXLGT/+bdq0yaJDh44MHTo8smxFljmcA/8/zGYzw4ffQ1JSEqeffibnn9+bL774jPz83eTkZHPCCe0i6zRo0JDbb78Ts9nMxRdfGnne/zv8rKpUMkSqUWnpMKzWX4iP/xin8w8UFn5LKKQzYEjt5vf7+eKLOSxe/CMAGRnNGDjwRho1OvowA5GaUheLblFRUeR2kyZNDnu7qKiQsrKyyNfp6U0Oe/toOnbsxK233s4HH7zHggVfs2DB1wDY7fE8+OAjXHXV1VXKX1i4P3/TphlRmywdCPjx+coOuu/Afo7kwFCnPXv2RO5r3Dg9cjs9Pf2QdX7vhBNO/J/9FR4z54F93nPPA+zatYvs7E28++74yOOdOnXm//7vTRwOR4WWOZwD/z+Sk5MPKoNNmjT93TIHZ23WrHlkzpzdbo/cX15efsznVBEqGSLVyoTb/RpW61qs1lU4nbdQVPQZYD/mmiKxaPfuXUyZ8gH5+fs/6Tr77J5ceOElWK36dSKxwWQyMXTo3fj9fkP2b7PZqqXkpKamRm7n5+fTps3++QC7d++O3J+SkobT+dub0L17f3sj/fvljmXYsD9y661D2LBhA9u2bWXGjKmsWrWSf/3rZS6/vB9Wq7XSzzEtLZW9e/eya9dOfD7fQW9qK6pp0wymT5/Nxo0bePjh+8nP383LL/+ddu1O5KSTuhy0n1atWvPRR9MO2caB4VC/n3uxd+8e2rXbXx6O9e/0v7nT0tIit++++x4GD77tiPts3boN7733MTt2bGfz5hzWrVvL+PFvs2bNaqZM+YjbbrujQsscTmpqKtu3b6OkpASv10tiYuJ/n89vRyX+9yx/B//cjv7/Wc3JEKl2iRQXTyIUSsVmW0Jy8mNGBxKptHA4zM8//8jo0a+Tn7+L5ORkbrnldi655HIVDIk5JpOJuLg4Q/4cb8FYs+ZXfvxx4UF/iouL6dHj7Mgyo0e/RXFxERs2rGfWrJkAxMfH07VrN044oR2Jifs/yf7ss/1vyA+c1akiNm3ayLhxY9i6dStZWVlccEEf2rVrD4DPVxYZiuVwOCPr5ORsOuZ2zz77PGD/MKa//e158vN34/GU8P3337Js2S8Vygb7v7cnntieBx98BNh/4onXX/935PGzzjoHgNzcLYwZMwqXy0VZWSmrVq3g5ZdfZOLECQAHnW1p4sR3KCgoYOPGDZF/z4o6+eRTIhPAP/hgEr/8spjy8nIKCgr48su5DBt2Ozt37vzvfibwzTfzsVgsdO9+FhdeeFHk4qQHjjJUZJnDOfD/IxQK8dZbIykpcfPLL4sjR6LS05vQtu0JlXpux0u/GURqQCjUBpdrLCkpA0lIGEcgcCplZYONjiVSIR6Ph5kzp7B+/RoA2rXrQP/+10Z+sYpI9LzxxmuHuW80l1xyGbNnz2TZsqV8/fVXfP31Vwctc/fd9+J07n/jf/PNtzBmzCj27t3LLbfcAECjRo0iyx6tCBUXFzN69FuMHn3oCUs6dz4pso9OnTpF7n/44fsBuOSSy/jzn/962O3eeecwFi36kd27d/HFF5/xxRefRR7705+eo1u3046Y6XDOP/8COnXqzJo1q1mxYjmLFv1I9+5nMXTocH766Uf27Mln7NjRkVPpHnBgwvppp50ROT3t0qVL6Nu3D1Dxf6cDEhMTuf/+h/jrX5+nsLCQP/7xriMu+8MPC1m27NDvL0D37mdXeJnDueGGm5g37wtyc7cwefKHTJ78YeQxi8XCQw89WuOnE9eRDJEa4vdfhNf7NADJyQ9itR57Ap6I0TZvzuatt/7N+vVrsFgsXHppP26++VYVDJEaZrVa+fe/3+D22++kVavW2Gw2EhMT6dq1Gy+99C+uu+6GyLK33XYHQ4YMJS2tAfHx8fTq1ZvHHnsq8rjTeeTTk7Zo0YL+/QeQldWW5ORk4uLiyMjIpH//Abz00r8iy5188ikMHz6CJk2aVujNa6NGjRk/fhLXXXcjzZo1x2az4XA46Nq1G23aZFXp3+Suu+6O3P7Pf/aXovT0dCZMmMQ111xL06YZWK1WUlNT6dixE7fddgd9+14RWedvf3uJiy++lISEBFJTU7npplu49trf/h0PFKpjueKKq3jttTfp0eMsnE4nNpuNpk2bcvbZ5/LEE09HhmZdfnk/unfvQePGjbHZbDidKZx8chdeeOFFzj77nAovczjJyQ7GjJnADTfcTGZmM6xWKw6Hgx49zmLkyFFVPvXw8TCFq+tca/VUMBiioMBjdAyJku3bc3nmmSd4/vkXad68Yqf/O7oQTucg7PbZBIPNKCz8lnBYk2Ul9gSDQb7+eh7ff/8N4XCYRo0aM3DgTWRkZBodLSL6r08xUoMGSVgslfvss6ysjOzsHBo1akpcnOa6HbBjx3Z8Ph9ZWW2B/acq/etfn2f+/C8BmDTpo4POMlRfrVmzmiZNmtCw4f6jF3l5O7j//hFs3ZpLWloDZs/+AovFYnDK2FJe7mPv3l20bZt1zAn8Gi4lUqPMuN2jsFh6Y7VuxOm8leLimeilKLGkoGAfU6Z8wI4d2wA47bQzufTSfpFxwSIS29asWc3TTz9BYmISycnJFBTsIxAIAHDNNdeqYPzXrFkzmD59KqmpqVgsVgoK9hEOhzGbzTz44CMqGMdJ72xEalg47MTlep/U1N7ExX1HUtIzeDx/MzqWCAArVy5j9uzp+Hw+4uMTuPLKAXTu3MXoWCJSCa1bt6FHj7PZsGE9+/btIyEhnhNOaEe/fv25/PJ+RseLGaeddgYbN25g69Zc3O4iUlPT6NLlFG68cRBdu3YzOl6tp5IhYoBgsD1u939ISbmZxMSRBAKn4vMNNDqW1GM+n485c2awYsVSAFq1asOAAdeTmpp2jDVFJNa0a3ci//73SKNjxLw+fS6mT5+LjY5RZ6lkiBikvLwfXu9DJCb+E4djBIFAB4LBk4yOJfXQ9u3bmDr1AwoK9mEymTj//D707HlBjZ+JRERE6g6VDBEDeTx/wmpdRlzcfFJSbqaw8BvCYX1yLDUjFAqxcOEC5s+fSygUIiUllYEDb6Rly9ZGRxMRkVpOJUPEUBZcrrGkpZ2PxbIZh2MoLtfH6OzSUt1cLhfTp38UuYhW585d6NdvAAkJCQYnExGRukAlQ8Rg4XBDiovfIy2tD3b7XBITX8TrferYK4pU0fr1a5gxYzJerxebzUbfvlfRrdvpx32lYhERkQNUMkRiQDDYBbf7NZzOO0lK+geBwKmUl19mdCypY/x+P3PnzuHnn38EICMjk4EDb6JRI12rRUREokslQyRG+Hw34PX+QmLif3A4hlJU9DXBoM5lLtGRn7+LyZM/ID9/FwBnnXUeffpcitWqXwMiIhJ9+u0iEkM8nr9hta4iLu4HnM6bKSycDyQbHUtqsXA4zJIli/j881kEAgGSkpK5+urraNeuvdHRRESkDlPJEIkpNlyud0hL64nVug6n825crncAjZWXyvN6PcycOZV161YDcMIJJ3L11deRnOwwOJmI/N7zzz/Lp5/OAsBkMmGz2XA4nDRv3pxzz+3J1VdfU62v2+HDh7Js2S80bZrBjBlzKrze73P/9NPS6op3iLy8PAYMuKJCy06bNpvMzMxqTiSHo5IhEmPC4Sa4XO+SmtoXu30GCQmvUVp6n9GxpJbZvDmbadM+xOVyYbFY6NPnMnr0OEfXvhCJceFwmPLycvbt28u+fXtZsWI5U6dO5tVXX6dNmyyj44lUmEqGSAwKBLpTUvISDscDJCU9SyDQBb+/t9GxpBYIBoN8/fU8vv/+G8LhMI0aNWbgwBvJyGhmdDQRqYA33hjNKaecQm5uLuPHv82XX85l166dPPTQfbz33sfVcprpt94aU6X1nnnmzzzzzJ+jnObYMjMzDzpyMnv2J/zlL88BcPvtdzJ06LCjru/3+7FYLPrQpZqpZIjEqLKyIVitS0lImIjTeRuFhd8SCrU0OpbEsIKCfUyd+iHbt28F4NRTz+Cyy64kLi7O4GQiUhlWq422bU/gL3/5O7t372LVqpXk5e1g1qyZXHfdDcD+N8rvvz+RL774jB07tmOxWOjYsRO33no7Z5zR/aDtLV36C++99w6//vorHk8JDRo05JRTuvLCCy8Chx8utW3bVv7znzdZsWIZRUVFJCUl0aJFS849tyd/+MMQ4MjDpXJztzB27GiWLFmMy1VMWloa3bufxR133EXTphnAwUOehgwZis1mY/r0qZSUlHDyySfz2GN/Ou5hTr/fx2233YHJZGLWrBns3buXuXO/weFwsG7dGsaPH8uKFcsoKSmhceN0eve+kDvuuIvExMTItjyeEsaPH8uCBV+za9dO4uPj6dKlK0OHDqNDh47HlbOuUskQiVkmSkr+idX6KzbbMpzOQRQVfQHoYmlyqJUrlzF79nR8Ph/x8fFceeU1dO7cxehYIgYJA16D9p1INOfRXX/9TaxatRKAH39cyHXX3UAwGOTBB+9l8eJFBy37yy9LWLr0F55//m9cdNElAHz66WxeeOFZwuFwZLn8/N3Mm/dFpGQczsMP309u7pbI10VFRRQVFeHxeCIl43A2btzAXXcNwev97d9/z549zJ79CQsXfsfYsRMPKQ8ff/wBJSUlka8XLfqJZ599ijFjxh/lX6Zypk6djMtVfNB9ixb9xMMP34ff74/ct3NnHu+/P5GlS5fwn/+Mw2634/V6ufPOIWRnb4os5/f7WbjwOxYvXsRrr71F167dopa1rlDJEIlp8bhck0hL64nNthyH4wHc7rfQRHA5wOfzMWfODFas2P8pYsuWrbnmmhtITU0zOJmIUcI4HBdhtf5kyN4DgbNwu+cSrZ/TLVu2itzeuTMPgLlzP48UjEceeYLLL78Cl8vNU089yqpVK/n3v//JBRf0oby8nH/96yXC4TBWq5Unn3yGXr3Ox+Vy8dlnnx5xn8XFRZGCcd99DzJw4PW4XC42bdrIhg3rjpr33/9+JVIwnn32BXr27MWMGdN5/fVXKSwsZNSoN3j++b8etI7P5+Pll1/llFO68dRTj7F48SJWrVpBfn4+6enplf43Oxy328Vjjz3JxRdfxp49+SQkxPPyyy/i9/tp374Df/nL32nSpClffTWPP//5adatW8usWTMYOPB6PvzwfbKzN2GxWPjb317irLPOYdeuXTz44D1s376N//u/fzJ+/KSo5KxLVDJEYlwo1AKXawIpKVcRH/8+fv/plJXdYXQsiQE7dmxnypT3KSjYh8lkolevC+nZ8wIsFovR0UQMVnc+iAmFQpHbJtP+5/Xjjwsj97388ou8/PLBRyT27dvL5s057Nu3N3KE4PLL+9G37/6hQ0lJyQwZcuTfI8nJDpKSkvF4Spg793NKS8vIysripJNOpnv3Hkdcr6yslOXLlwHQsWMnLrvscgBuumkQH330Pvn5u/nppx8OWa9nz/M577xeAJx//gWRArV7986olYzu3Xtw9dUDAUhKasPWrbls374NgPXr13Httf0PWWfJksUMHHg9P/74PbB/zttjjz10yHJr167B4ykhKUmnnP89lQyRWsDv74XH8zzJyX8iOfkxAoGTCQS6H3tFqZNCoRA//PAtX331BaFQiJSUVK655gZatWpjdDSRGGD675GEujFcatu2rZHbGRn7hxkVFhYecz2Xy3XQcq1bV/zng8Vi4U9/epaXX/47a9euYe3aNcD+ktOvX3+efPLpI+zTTTAYBCA9vUnkfpPJRHp6Ovn5u3G5iiPLHNC8eYvIbbv9tzlk5eV+ouWEE0486OuK/htWZlmVjIOpZIjUEqWl92C1LiU+fhpO5y0UFX1LKNTU6FhSw9xuF9OmfUROzv6xwZ06ncyVVw4gISHxGGuK1CcmIMnoEFHx0UfvR26fffY5AKSl/TYccs6cuTRs2OigdcLhMCaTiUWLfozc9/v5FRXRu/eF9OrVm+zsTWzdmsv333/LZ5/N4ZNPpnP55f045ZSuh6zjdDqwWCwEg0H27Mk/KE9+fv5/l3EecrTVav3929HqOQplt9sP+vr3/4ZXX30Njz321CHrHJjHkpaWxvbt20hMTGTu3K+xWm2HLHfgKJP8RufuEqk1TLjdIwkEOmGx7MLpHAyUGx1KatD69Wt5881/k5OzCZvNxpVXXsN1192sgiFSxwQCfrKzN/H000/w66+rAGjWrDlXXHElAGeddXZk2b///a/s3JmH3+9n8+YcJkwYy9NPPwFAly5dcTj2X8RvzpxZfPbZHDweD7t372L8+LePmuGVV/7B8uXLaNiwET17ns+ZZ/42TKqo6PCf7MfHJ3DKKfsnQK9Zs5ovvvgMj8fDhx++R37+bgB69Dj7sOvWtJYtW9G8eXNg/+T4b76ZT1lZKcXFxXz//bc8/PD9LFu2f67bWWftL3der5eXX/47+/btw+fzsX79Ot5883VeffUVw55HLNORDJFaJRmXaxKpqb2x2X4iOflJSkr0w62u8/v9zJv3KYsW7R/L3LRpJgMH3kjjxtEZqywiseOPf7zzkPsyMjJ55ZV/Ex+//+yCF198GXPmzGbJkp/57rsFfPfdgoOW79btNAASEhJ44IFHeOGFZ/H7/fz5zwcPc7rttiPPy5gy5SOmTPnokPuTk5M56aSTj7jeffc9yLBht1NaWsqzzx58dCA1NZVhw/54xHVr2iOPPMlDD92Lz+fj8ccfPuTxG28cBOw/w9dXX80jO3sTM2dOZ+bM6Qct17dvvxrJW9uoZIjUMsHgCbjdo0lJuZ6EhNH4/afi891kdCypJvn5u5ky5QN2794JwFlnnUufPpf9z/ACEalLbDYbTmcKzZs357zzetG//wCSkx2Rxy0WC6+++joffDCJL774jO3bt2GxWElPT6dbt1O59NLLI8v27XsFTZtm8N5777Bq1Sq8Xg8NGjSkS5dTjprhlltuZenSJezYsZ2SkhJSUlLp1KkzQ4YMPWR41u+1b9+BceMmMnbsaH75ZQkul4u0tFTOPHP/dTKO99oX0dS9ew/efnsCEyaMY8WKZbjdbtLSGtCqVSvOO+98OnToAEBSUhKjR49jwoRxLFjwNTt35hEfH0+TJk05/fQzufxylYzDMYV/f+JkOW7BYIiCAo/RMSRKtm/P5ZlnnuD551+kefNWx16hBiUmvkhS0ouEw/EUFc0lEOhqdCSJonA4zJIli/jii9n4/X6SkpK4+urraNeug9HRYkYsvz6l8ho0SMJiqdwo7rKyMrKzc2jUqClxcfZjryAix6W83Mfevbto2zaL+Pj4oy6rj8JEaimv9zGs1mXY7Z/jdA6isHAB4XBDo2NJFHi9Xj75ZCpr1/4KQNu27bj66usjY6tFRERinUqGSK1lxu0ejcVyPlZrDk7nEIqLpwG6RkJttmVLDlOnfojLVYzFYqFPn0vp0eNczGadp0NERGoPlQyRWiwcTsXlep+0tAuIi/uapKQX8HieMzqWVEEwGOSbb77ku+++JhwO07BhIwYOvInMzGZGRxMREak0lQyRWi4Y7ITb/SZO560kJv4Lv78b5eVXGR1LKqGwsICpUz+IXHSrW7fTueyyKw85r7uIiEhtoZIhUgf4fAPwepeSmPgaDsdwioraEwxqgnBtsGrVcmbNmobP5yM+Pp5+/QZw0klHP+uLiIhIrFPJEKkjPJ7nsFpXEBe3AKfzJoqKviYcTjE6lhyBz+fj009nsnz5LwC0aNGKa665gbS0BgYnE6mNdKJMkZpR8ddaTJWM3NxcxowZw7Jly8jOzo5czn3lypWRYQOhUIinnnqKVatWsWvXLkpLS3E6nZx00knccccddO/e/Zj7efzxx5k+ffphH3viiSe49dZbo/acRGqOFZdrPGlpPbFaN+FwDMPleg/QhOFYk5e3nSlTPmDfvr2YTCZ69ryAXr0uxGLRpH2RyrDZbJhM+0t7XNzRT6cpIsfP5/NhMu1/7R1LTJWMjRs3Mnny5KMuEwqFmDZt2kH3FRQU8O2337Jw4UImTZrEqaeeWp0xRWJWONzov1cEvwS7fQ6Jia/g9T5qdCz5r1AoxI8/fsdXX31BMBgkJSWFAQNuoHXrLKOjidRKFouF1NRUCguLAP77gaTJ0EwidVMYn8+H211EWlpqhT4Ui6mSkZ6ezrBhw+jatStvvvkmK1euPGQZs9nMPffcw8UXX0yLFi0oLi7mz3/+M/PnzycYDPLpp59WuGRcffXV/P3vf4/20xAxVCBwKm73qzidd5OY+FcCga6Ul19sdKx6z+12M336R2RnbwSgU6eTuPLKa0hISDQ4mUjtlpGRAUBRURFut8FhROowkwnS0lIjr7ljiamS0aVLF7p06QLAuHHjDruM2WxmxIgRka8TEhK49tprmT9/PlCxwzcidZ3PN4jS0l9ISBiLw3EHhYXfEArp03KjbNiwjhkzPsbj8WCz2bj00n6cdtqZmEz6xFXkeJlMJjIzM2nSpAl+v9/oOCJ1ls1mq9Sw3pgqGZUVDofZuXMnH3/8MbC/cFx1VcVP3Tlv3jw+++wzANq1a8egQYPo379/dUQVqXElJf/Aal2JzbaYlJSbKSz8EkgyOla9EggEmDfvU376aSEATZtmMHDgjTRu3MTgZCJ1j8Vi0bwmkRhSa0vGM888w0cffRT5OiUlhddff50OHSp+2s6SkpLI7VWrVvHYY4+xe/du7rrrruPKZrVqom1dYTabIn/Xvu9rPB7P+zid52C1rsbpvA+vdywar1wz8vN389FH77Fr104Azj77XC6+uK+OtkZR7X59iojUbbW2ZPyv4uJi/vjHPzJhwgROOumkoy571llncckll3DyyScTHx/PZ599xjPPPEMoFOLNN99k8ODBJCQkVCmH2WwiLU2fFtcV+/btP6tZUpK9ln5fTwCmABdgt3+M3X4WcL+xkeq4cDjMwoULmTx5Mn6/n+TkZAYPHnzMn0tSebX/9SkiUnfV2pLx/PPP89xzz5Gfn8/YsWN59913cbvdjBw5klGjRh113f8dUnXttdfy+eef8/3331NWVsbGjRsjc0MqKxQK43J5q7SuxB6Pxxf5u7DQY3CaqjoVu/1FEhMfIRx+mJKSDgQC5xkdqk4qLfUyffoUVq9eBcAJJ7TjmmtuwOl01uL/P7Grbrw+5QCnMwGLRUekROqKWlsyYP8k8KZNm3Lvvffy7rvvArBly5ajrnPg2htHm3B5vJMxA4HQca0vsSMUCkf+rs3f10DgTszmJcTHf0RS0mAKC78lFGpmdKw6JTd3M1OnfkBxcTEWi4ULL7yEs846D7PZXKv/78SyuvL6FBGpi2LqIwO/309BQQEFBQUHnSGiqKiIgoICSktLmTVrFpMmTWLz5s34fD727NnDm2++GVm2RYsWkdvTpk2jffv2tG/fnkWLFgH7TyN57bXX8tlnn1FUVERJSQmTJ0/mhx9+ACA5OZkTTzyxhp6xSE0x4Xb/H35/F8zmPTidgwCf0aHqhGAwyPz5cxk//j8UFxfTsGEj7rjjbs45pxdmc0z9iBUREakxMXUkY+nSpQwePPiQ+3v27AkQOXXtyJEjD7u+3W5n+PDhx9zPqlWruP/++w/72KOPPhq5urhI3ZKIyzWJtLRe2Gy/kJz8CCUlrxkdqlYrLCxg6tQP2bYtF4CuXU+jb9+r9DNERETqvZgqGRVx5plncuGFF7J27Vr27dtHKBQiPT2dM844gyFDhtC+ffujrp+YmMjTTz/N119/zaZNm9i3bx8JCQmcfPLJ3HbbbZx3nsaqS90VCrXG5RpHSsoAEhImEAicSlnZrUbHqpV+/XUFs2ZNo6ysDLvdTr9+Azj55K5GxxIREYkJMVUyunfvzvr16yu0XEUMGDCAAQMGHHSf1Wpl0KBBDBo0qEoZRWo7v/9CPJ5nSE7+M8nJDxMIdCYQOMPoWLWGz+fjs88+YdmyJQC0aNGSa665kbS0BgYnExERiR0xVTJEpGaUlj6IzbYUu30WTuctFBZ+SzicbnSsmJeXt4MpU95n3769mEwmzjuvN+ef30cXABMREfkfKhki9ZIJt/stLJb1WK0bcDpvpbh4JqALxR1OKBTip5++58svPycYDOJ0pnDNNTfQunWW0dFERERikkqGSD0VDjtxud4nNbU3cXHfk5T0DB7Pi0bHijklJW6mT/+YTZs2ANCxY2euvHIgiYmJBicTERGJXSoZIvVYMHgibvcoUlJuJjHxDQKBU/H5rjU6VszYuHE906d/jMdTgs1m45JLruD007sf97V0RERE6jqVDJF6rry8Hx7PwyQlvYLDMYJAoCPB4ElGxzJUIBBg3rzP+Omn7wFo0qQpAwfeRHp6E4OTiYiI1A4qGSKC1/sUNtsy4uK+IiXlJgoLFxAOpxkdyxB79uQzZcoH7NqVB0D37mdz0UV9sdk0X0VERKSiVDJEBLDgco0lLe18LJYtOBx34HJ9DNSfsyaFw2GWLl3MZ599gt/vJzExif79r6V9+45GRxMREal1VDJEBIBwuAHFxe+RltYHu30eiYkv4vX+yehYNaK01Msnn0xjzZpVAGRlncCAAdfjcDgNTiYiIlI7qWSISEQweDJu92s4nUNJSnqJQKAb5eWXGx2rWuXmbmbq1A8pLi7CbDZz4YWXcPbZPTGbzUZHExERqbVUMkTkID7f9Xi9S0lMfAuH406Kir4hGGxndKyoCwaDfPvtfBYs+IpwOEyDBg0ZOPBGmjVrYXQ0ERGRWk8lQ0QO4fH8Bat1JXFxC3E6b6KoaD7hsMPoWFFTVFTI1KkfsnXrFgC6dj2Nvn2vwm63GxtMRESkjlDJEJHDsOFyvUNa2nlYretxOO7G5XoXqP3Xh1i9eiWffDKVsrIy7HY7V1xxNV26dDM6loiISJ2ikiEihxUOp+NyTSQ19TLs9pkkJPwfpaX3Gx2rysrLy/nss09YunQxAM2bt+Caa26kQYOGBicTERGpe1QypM7avXsnZWVlx70NgLy8HQSDoSpvJz4+niZNMo4rixECgTMpKXkFh+M+kpKeIxDogt9/gdGxKm3nzh1MmfIBe/fuwWQycd55vTn//D5YLPXnFL0iIiI1SSVD6qTdu3fyxBMPRW17o0aNPO5tvPjiP2tl0SgruxWr9RcSEt7F6RxCYeECQqFWRseqkFAoxE8/LeTLLz8jGAzidDoZMOAG2rRpa3Q0ERGROk0lQ+qkA0cwhg69m8zMZlXejsVixmQKEA5bq3wkIy9vB2PGvHncR1WMY6Kk5BWs1l+x2ZbidA6iqGgukGB0sKMqKXEzffrHbNq0AYAOHTpx1VUDSUxMMjiZiIhI3aeSIXVaZmYzWrVqU+X1rVYzaWlJFBZ6CASqPlyq9ovH5ZpEWlpPbLYVOBz343aPIlYngm/atJ7p0z+mpKQEq9XKpZf24/TTu2MyxWZeERGRukYlQ0QqJBRqjss1gZSUq4iP/wC//zTKyu40OtZBAoEAX375OT/++B0ATZo0ZeDAG0lPb2pwMhERkfpFJUNEKszv74nH8wLJyU+SnPw4gUAXAoEeRscCYO/ePUyZ8j47d+YBcOaZZ3PxxX2x2WwGJxMREal/VDJEpFJKS/+I1foL8fFTcTpvoajoW0Ih4ya0h8Nhli1bwqefzsTv95OYmMhVV11Lhw6dDMskIiJS36lkiEglmXC7R2K1rsVqXYPTOZiiojlAXI0nKS0tZdasaaxevRKANm3aMmDA9TidKTWeRURERH6jkiEiVZBEcfF7pKX1xmZbRHLy45SU/KtGE2zduoWpUz+kqKgQs9nMBRdcwjnn9MRsNtdoDhERETmUSoaIVEko1Ba3ewxO53UkJLyN338aPt/NNbDfEN9+O59vvvmScDhMWloDBg68iebNW1T7vkVERKRiVDJEpMrKyy/B632CpKS/4XDcTzDYmUCga7Xtr6iokGnTPiI3dzMAp5xyKn37XkV8fHy17VNEREQqTyVDRI6L1/soVusy7PbPcDpvprDwW8LhhlHfz5o1q5g5cyplZaXY7XauuOJqunTpFvX9iIiIyPFTyRCR42TG7R6NxXI+Vms2TudtFBdPI1o/XsrLy/n881n88svPADRr1oKBA2+kQYPoFxkRERGJDpUMETlu4XAKLtf7pKVdQFzcNyQlPY/H8/xxb3fXrjwmT36fvXv3YDKZOPfc8+nd+yIsFksUUouIiEh1UckQkagIBjvicr1JSsofSEz8N35/N8rLr67StsLhMD/9tJB58z4lGAzicDgZMOB6srJOiHJqERERqQ4qGSISNeXlV+P1LiUx8f9wOu+msLADwWDHSm2jpKSEGTMms3HjOgDat+/EVVcNJCkpqToii4iISDVQyRCRqPJ4nsVqXUFc3Dc4nTdRVPQN4XDFLo63adMGpk//iJKSEqxWK5dccgVnnNEDk8lUzalFREQkmlQyRCTKrLhc40lL64nVmo3DcScu1wfAkS+SFwgE+OqrL/jhh28BSE9vwsCBN9GkSdMayiwiIiLRpJIhIlEXDjfE5ZpEaurF2O2fkZj4Ml7vY4dddu/ePUyd+gF5eTsAOOOMs7jkksux2Ww1GVlERESiSCVDRKpFINANt/vfOJ3DSUz8G4FAV8rLL4k8Hg6HWb78Fz79dCbl5eUkJCTSv/9AOnTobGBqERERiQaVDBGpNj7fzZSWLiEhYSwOx1AKC78mFGpLWVkps2ZN59dfVwDQpk1bBgy4HqezYnM3REREJLapZIhItSop+QdW6ypstp9JSRnEr7+O4+OPZ1JUVIjZbKZ374s599xemM1HnrMhIiIitYtKhohUszhcromkpvbEal1NIDCIoqILSUtryMCBN9K8eUujA4qIiEiUqWSISLUrLEzg88+v4YYbRnH66RspL+9KixbPEx8fb3Q0ERERqQYanyAi1Wrt2l95661/s3BhmOnTewJw1lnTcDh+NjiZiIiIVBeVDBGpFuXl5cyaNY0PP5xIaWkpzZo156STxlJWdiMmUxCn81bM5u1GxxQREZFqoOFSIhJ1u3blMWXKB+zZk4/JZOKcc3rRu/dFWK1W3O5/Y7GswWZbgdM5iKKizwENmxIREalLVDJEJGrC4TCLFv3AvHmfEggEcDgcDBhwA1lZJ/xuqQRcrkmkpfXEZltKcvIjlJS8blhmERERiT6VDBGJCo+nhBkzJrNhwzoA2rfvyFVXDSQpKfmQZUOhVrhc40lJGUBCwjsEAqdRVnZrDScWERGR6qKSISLHLTt7A9OmfUxJiRur1crFF1/OmWeehclkOuI6fv8FeDzPkpz8LMnJDxMIdCYQOKMGU4uIiEh1UckQkSoLBALMnz+XhQsXANC4cToDB95E06YZFVq/tPR+bLal2O0zcTpvobDwW8Lh9OqMLCIiIjVAJUNEqmTfvr1MmfIBeXn7zxB1+uk9uOSSy4mLi6vEVky43W9isazDal2P0/kHios/AWzVkllERERqhkqGiFRKOBxmxYqlzJkzg/LychISErnqqoF07Ni5ittz4HK9T2rq+cTFLSQp6Wk8nr9HObWIiIjUJJUMEamwsrJSZs+ewapVywFo3TqLAQOuJyUl9bi2Gwy2w+0eTUrKjSQmvkkgcCo+33XHH1hEREQMoZIhIhWybVsuU6d+SGFhAWazmfPPv4jzzjsfszk61/QsL78cj+cRkpJexuG4h0CgI8HgyVHZtoiIiNQslQwROapQKMR3333DN9/MIxQKkZqaxsCBN9KiRauo78vrfRKbbRlxcV+SknIzhYXfEA43iPp+REREpHqpZIjIERUXFzFt2kds2ZIDwMknd+WKK/oTH59QTXu04HK9TVra+VgsW3A6b6e4eApgqab9iYiISHWIqZKRm5vLmDFjWLZsGdnZ2YTDYQBWrlyJ3W4H9n+q+tRTT7Fq1Sp27dpFaWkpTqeTk046iTvuuIPu3btXaF/Lly/ntddeY/ny5YRCITp06MDw4cPp1atXtT0/kdpk7drVzJw5hdJSL3FxcVx+eX9OOeXUo177IhrC4QYUF79HWlof4uK+IjHxr3i9z1TrPkVERCS6YqpkbNy4kcmTJx91mVAoxLRp0w66r6CggG+//ZaFCxcyadIkTj311KNuY/Hixdx22234/f7IfcuWLeOuu+7ilVde4Yorrqj6kxCp5fx+P59/PpslS34CIDOzOQMH3kjDho1qLEMweDJu9+s4nXeQlPQKgcCplJfrdSkiIlJbRGfGZpSkp6czbNgwRo0aRZcuXQ67jNls5p577mHWrFksX76cBQsWcMEFFwAQDAb59NNPj7mfZ599Fr/fj8PhYMqUKcybN4/MzEzC4TAvvPACZWVlUX1eIrXF7t07+c9/XosUjHPO6cXttw+v0YJxgM93HV7v3QA4HHdhsWys8QwiIiJSNTFVMrp06cIDDzxA7969iY+PP+wyZrOZESNGcOKJJ5KQkEDTpk259tprI4/bbEe/iNfq1avJzs4GoG/fvpx88sm0bNmSG264AYCioiK+++67KD0jkdohHA6zaNEPjB49kj178klOdjB48O1cfHFfrFbjDnh6PC9QXn4uZrMbp/MmTCa3YVlERESk4mKqZFRWOBwmLy+Pjz/+GICEhASuuuqqo66zZs2ayO2srKzD3l69enWUk4rELo/HwwcfvMOnn84kEAhw4okduPvu+2nb9kSjowE2XK4JBIOZWK3rcTiGA2GjQ4mIiMgxxNScjMp45pln+OijjyJfp6Sk8Prrr9OhQ4ejrldQUBC5nZycfNjbv1+mKqzWWt3d6gSLxRz5+3i+H7/fjtFZqkN29kYmT/4Qt9uF1Wrl0ksvp0ePc6p9cnflNMXjeQ+H4xLs9k9ISvo3Pt9DRoeSGGA2myJ/x9prS0Skvqu1JeN/FRcX88c//pEJEyZw0kknVXr9A2eyOl5ms4m0tKSobEuqbt++/cPtHI74qHw/nM6qn7I12lmiIRgMMmvWLObNm0c4HKZp06YMGTKE5s2bGx3tCM4HRgJ3kpj4ZxITewAXGxtJDLdv3/6zDiYl2WPmtSUiIvvV2pLx/PPP89xzz5Gfn8/YsWN59913cbvdjBw5klGjRh1xvQYNfruwV0lJSeS2x+M57DKVFQqFcbm8VV5fosPtLov8XVjoOcbSR2axmHE6E3C5SgkGQ4ZmiZZ9+/by0Ufvs2PHNgDOOKM7ffteSVxcXEzkO7KbSEz8Abt9AqHQjbjd3xIKtTY6lBjI4/FF/o7t/7tSEU5nwnEdNRaR2FJrSwbsnwTetGlT7r33Xt59910AtmzZctR1OnXqFLmdk5Nz2NudO3c+rlyBQNXejEr0HCgEwWAoKt+P49lOtLMcjxUrljJ79nTKy8tJSEjgyisH0qnT/iN/RmerCJfrZVJTV2Gz/UJi4k0UFc0FEo2OJQYJhcKRv2vD/18Rkfokpj4y8Pv9FBQUUFBQcNA1LIqKiigoKKC0tJRZs2YxadIkNm/ejM/nY8+ePbz55puRZVu0aBG5PW3aNNq3b0/79u1ZtGgRsL9AtG3bFoBPP/2UVatWkZuby4cffghAamoq5513Xk08XZEaU1ZWxtSpHzJt2keUl5fTqlUbhg+/P1Iwag87LtdEQqFG2GwrcTjuRxPBRUREYk9MHclYunQpgwcPPuT+nj17AjBixAgARo4cedj17XY7w4cPP+Z+nnvuOYYMGYLb7WbgwIGR+00mE08//fQRT58rUhtt376VKVM+oLCwALPZzPnn9+G883pjNsfUZwwVFgo1x+V6h5SUK4mP/xC//zTKyu4yOpaIiIj8Tq17l3HmmWdy4YUXkpmZid1ux2az0axZM/r378/kyZOPebXvA9uYNGkS55xzDklJSSQkJNCtWzf+85//6GrfUmeEQiG+/fZrxo59i8LCAlJT07jttrvo1evCWlswDvD7z8PjeQGA5OQnsFp/NDiRiIiI/F5MHcno3r0769evr9ByFTFgwAAGDBhw2Me6du3KuHHjKpVPpLZwuYqZNu0jNm/ef+HJk046hSuuuJqEhKqfJSvWlJb+Eat1KfHxU3A6B1NU9C2hUIbRsURERIQYKxkicvzWrVvNjBlTKC31EhcXR9++V9G162kxdu2LaDDhdr+O1boWq3U1TuctFBV9CsQZHUxERKTeU8kQqSP8fj9ffDGHxYv3Dx3KyGjGwIE30qhRY4OTVackiovfIy3tfGy2n0lOfoySkleNDiUiIlLvqWSI1AG7d+9iypQPyM/fBcDZZ/fkwgsvwWqt+y/xUCgLt/ttnM5rSUgYi99/Gj7fIKNjiYiI1Gt1/x2ISB0WDodZvPgnvvhiNoFAgOTkZK6++npOOOFEo6PVqPLyi/F6nyQp6a84HA8QDHYiEDj2SSBERESkeqhkiNRSHo+HmTOnsH79GgDatetA//7XkpycbHAyY3i9j2C1LsNu/xSncxCFhd8SDjcyOpaIiEi9pJIhUgtt3pzN1Kkf4na7sFgsXHRRX3r0OKcOTu6uDDNu93+wWHpjtW7C6byN4uLp6MeciIhIzdNvX5FaJBgM8vXX8/j++28Ih8M0atSYgQNvIiMj0+hoMSEcTsHlep+0tN7ExS0gKenPketpiIiISM1RyRCpJQoK9jFlygfs2LENgNNOO5NLL+1HXJxO2fp7wWAHXK63SEkZTGLi/xEIdMPnO/z1ckRERKR6qGSI1AIrVy5j9uzp+Hw+4uMTuPLKAXTu3MXoWDGrvLw/Xu8DJCa+isPxRwKBDgSDnYyOJSIiUm+oZIjEMJ/Px5w5M1ixYikArVq1YcCA60lNTTM4WezzeJ7Gal1OXNzXOJ03U1T0NeFwqtGxRERE6gWVDJEYtX37NqZO/YCCgn2YTCbOP78PPXtegNlsNjpaLWHF5RpHWlovrNZsHI47cbk+BPTvJyIiUt1UMkRiTCgUYuHCBcyfP5dQKERKSioDB95Iy5atjY5W64TDDXG5JpGaejF2++ckJr6E1/u40bFERETqPJUMkRjicrmYPv0jcnI2AdC5cxf69RtAQkKCwclqr0CgK273qzidw0lMfJFAoCvl5ZcaHUtERKROU8kQiRHr169hxozJeL1ebDYbffteRbdup9fza19Eh893M6WlS0lIGIPDMZTCwm8IhdoaHave2717J2VlZce1PkBe3g6CwVCVtxMfH0+TJhlVXl9ERA6lkiFiML/fz9y5c/j55x8ByMjIZODAm2jUqLHByeqWkpIXsVpXYbP9RErKzRQWfgnUz6ujx4Ldu3fyxBMPRWVbo0aNPO5tvPjiP1U0RESiSCVDxED5+buYPPkD8vN3AXDWWefRp8+lWK16aUZfHC7Xu6SmnofVugaHYwRu93hAR4qMcOAIxtChd5OZ2axK27BYzJhMAcJha5WPZOTl7WDMmDeP64iKiIgcSu9kRAwQDodZsmQRn38+i0AgQFJSMldffR3t2rU3OlqdFgo1xeWaSGpqX+LjpxEInEZp6T1Gx6rXMjOb0apVmyqta7WaSUtLorDQQyBQ9eFSIiISfSoZIjXM6/Uwc+ZU1q1bDcAJJ5zI1VdfR3Kyw+Bk9UMg0IOSkn/gcDxEUtLTBAJd8Pt7GR1LRESkTlHJEKlBmzdnM23ah7hcLiwWC336XEaPHufo2hc1rKzsDmy2X4iPfx+n81YKC78jFGpudCwREZE6QyVDpIYsWbKIVauWEw6HadSoMQMH3khGRtXGosvxMuF2v4rFsgabbfl/rwj+BRBvdDAREZE6QR+filQzl8tFeno6K1cuIxwOc+qpZ3DXXfeqYBguAZdrEqFQA2y2ZSQnPwSEjQ4lIiJSJ6hkiFSjlSuXMXPmZOx2O3FxcVx33c1cddVA4uLijI4mQCjUEpdrPOGwmYSEicTHjzc6koiISJ2gkiFSDXw+H9OmfcTUqR/i9/vx+Xz0738tnTt3MTqa/A+/vzcez3MAJCc/gtX6s7GBRERE6gCVDJEo27FjO6NG/R8rVizFZDLRrdvp5Ofn6+xRMay09D58vv6YTH6czlswmXYbHUlERKRWU8kQiZJQKMT333/D22+/QUHBPlJSUrnttrvo1u10o6PJMZlwu98gEOiAxbITp/MPgN/oUCIiIrWWSoZIFLjdLiZOHMu8eZ8RCoXo1Olkhg+/r8oXGZOaFw47cLneIxRyEhf3A0lJTxkdSUREpNbSKWxFjtP69WuZMWMyXq8Hm83GZZddyamnnoHJZDI6mlRSMNgOt3s0KSk3kJg4ikDgVHy+G4yOJSIiUuuoZIhUkd/vZ968T1m06AcAmjbNZODAG2ncON3gZHI8ysv74vE8SlLSSzgc9xEIdCIY1IR9ERGRylDJEKmC/PzdTJnyAbt37wTgrLPOpU+fy7Ba9ZKqC7zeJ7Fal2O3zyUlZRCFhd8QDjcwOpaIiEitoXdEIpUQDodZsmQRX3wxG7/fT1JSEldffR3t2nUwOppElRm3ewxWay8sli04nbdTXDwFsBgdTEREpFZQyRCpIK/XyyefTGXt2l8BaNu2HVdffT0Oh05NWxeFw2kUF79PWlof4uK+IjHxr3i9zxgdS0REpFZQyRCpgM2bs/n44w9wuYqxWCz06XMpPXqci9msE7TVZcHgSbjdr+N03k5S0isEAt0oL+9ndCwREZGYp5IhchTBYJBZs2bx+eefEw6HadiwEQMH3kRmZjOjo0kN8fmuxetdSmLiGzgcwygqak8weKLRsURERGKaSobIEXg8JXz44bts3ZoLQLdup3PZZVdit9sNTiY1zeN5Aat1JXFx3+F03kRR0XzCYafRsURERGKWSobUWQ6Hg/JyHyUl7iqtv3LlMgoLC2jcuDE9e15AVlY7/P5y/P7ySm2nvNyneRu1nhWXawJpaT2xWjfgcAzH5ZqIrmcqIiJyeCoZUicFg0GuvfZa9uzJY8+evCpv5+yzzwagpKSIlSsXV3k71157LcFgsMrri/HC4ca4XBNJTb0Uu30WCQmvUlr6kNGxREREYpJKhtRJFouFyZMnM2LEA2RkVH3+hMViwulMwOUqJRgMV2kbO3fuYOTIV3nwwcernENiQyBwOiUl/8ThuIekpOcJBE7B7+9jdCwREZGYo5IhdZbb7SYuzk5yctWHKlmtZlJTkwiHbQQCoSptIy7OjttdtSFbEnvKyv6A1bqUhITxOJ1DKCz8llCotdGxREREYooGFIuIVFJJyUv4/adhNhfhdA4CvEZHEhERiSkqGSIilWbH5ZpEKNQYm20lDsd9QNWG04mIiNRFKhkiIlUQCjXD5XqHcNhCfPxHxMf/x+hIIiIiMUMlQ0Skivz+c/F4/gJAcvKT2Gw/GJxIREQkNqhkiIgch9LSuykruxaTKYDTORizueqnTBYREakrVDJERI6LCbf7dQKBkzCb83E6bwF8RocSERExlEqGiMhxS6S4+D1CoVRstsUkJ+uaKCIiUr+pZIiIREEo1AaXayzhsImEhLHEx080OpKIiIhhVDJERKLE778Ir/dPACQnP4jV+ovBiURERIyhkiEiEkVe70P4fJdjMvlwOm/BZNprdCQREZEap5IhIhJVZtzu/xAInIDFsh2n8zYgYHQoERGRGqWSISISZeGwE5frfUKhZOLiFpCU9JzRkURERGqU1egAv5ebm8uYMWNYtmwZ2dnZhMNhAFauXIndbgegsLCQd955h0WLFrFt2zaKi4tJT0/n1FNP5d5776VFixbH3M/rr7/OyJEjD/vY4MGDeeqpp6L3pESkXgoGO+B2v0VKyi0kJr5GINANn+8ao2OJiIjUiJgqGRs3bmTy5MlHXSY3N5e33nrroPu2b9/O9u3b+frrr5k6dSqtWrWqzpgiIhVSXn4VXu+DJCb+C4fjjwQCHQkGOxkdS0REpNrF1HCp9PR0hg0bxqhRo+jSpcsRl+vYsSOvvvoqS5YsYcGCBZxzzjkAuN1u3nnnnQrv78wzz2T9+vUH/dFRDBGJJo/nacrLe2MyeXE6b8JkKjI6koiISLWLqSMZXbp0iZSLcePGHXaZ9u3bM23aNMzm/f3I4XDw4IMPsnDhQmD/kQ4RkdhhweUaR1paL6zWHByOobhcHxFjn/GIiIhEVa37LZeQkBApGAf4fL7I7fT09Apva9WqVZx66qmcfPLJ9OvXjwkTJhAKhaKWVUQEIBxuiMv1HuFwPHb7FyQm/t3oSCIiItUqpo5kVEUoFOKNN96IfH3NNRWfWFlaWhq5vWHDBl588UVycnJ4/vnnjyuT1VrruludY7GYI38fz/fj99sxOovUdt3wel8nKWkoSUl/Jxw+Db//MqNDGSYarwu9PkVEYletLhmhUIgnn3wyMlRqxIgRnH766cdcr3Pnzrz66qucdtppOBwOfvjhBx566CHKysr4+OOPGTp0aIXOUnU4ZrOJtLSkKq0r0bNvXzwADkd8VL4fTmdCzGSR2uwOYAUwkuTkO4DFQDtjIxkkmq8LvT5FRGJPrS0ZgUCARx99lDlz5gAwZMgQ7rnnngqte8EFFxz0dZ8+fbjqqqv46KOPCIfD/Prrr1UuGaFQGJfLW6V1JXrc7rLI34WFnipvx2Ix43Qm4HKVEgxWbShdtLJIXfE8ycm/YLP9SDB4FS7X10Cy0aFqXDReF3p91i1OZ8JxHZUSkdhSK0uG3+/nwQcfZO7cuQDcfffd3HfffRVePxQKHTKv4/dMJtNx5QsENK/DaAfecASDoah8P45nO9HOIrWdFZfrHVJTe2KxrCUh4W7c7vHA8f3cqW2i+brQ61NEJPbE1EcGfr+fgoICCgoK8Pv9kfuLioooKCigtLSU8vJyRowYESkYDz/88BELxqJFi2jfvn3kjFQH3HDDDUydOpU9e/ZQWlrKl19+ycyZMwGwWCyccsop1fgsRaS+C4Wa4nJNJBy2ER8/jYSE142OJCIiElUxdSRj6dKlDB48+JD7e/bsCeyfc3HmmWfyzTffRB575ZVXeOWVVyJfN2vWjPnz5x91Pzk5OTz55JOHfWzo0KFkZGRUIb2ISMUFAt0pKfkHDseDJCU9QyBwCn5/L6NjiYiIREVMHcmoKX/605+48MILadasGXFxcSQlJXHaaafxz3/+kwceeMDoeCJST5SV3U5Z2c2YTCGczlsxm7cZHUlERCQqYupIRvfu3Vm/fv0xl6vIMkfbXv/+/enfv39l44mIRJkJt/tfWCxrsNmW4XQOoqjoCyDe6GAiIiLHpV4eyRARiR0JuFwTCYUaYrMtIzn5QSBsdCgREZHjopIhImKwUKglLtd4wmEzCQmTiI8fZ3QkERGR46KSISISA/z+8/F4/gxAcvKjWK2LDE4kIiJSdSoZIiIxorT0XsrKrsZk8uN03oLJtNvoSCIiIlWikiEiEjNMuN1vEAh0wGLZRUrKYMB/zLVERERiTaXOLrVu3To++OADtm/fTmpqKpdddhl9+vSprmwiIvVQMi7Xe6Sm9sZm+5GkpCfxeF42OpSIiEilVLhkrFu3juuvvx6fzxe579NPP+WRRx5hyJAh1RJORKQ+Cgbb4XaPISXlehIT/0MgcCo+341GxxIREamwCg+XGjlyJDabjbfeeotly5YxY8YMOnTowFtvvYXfr8P5IiLRVF5+GR7PYwA4HPdhta4wOJGIiEjFVbhkrF69mptuuonevXuTkJBAhw4deOKJJygpKWHTpk3VmVFEpF7yep/A57sYk6kMp3MQJtM+oyOJiIhUSIVLxu7du8nKyjrovrZt2xIOh3G5XFEPJiIiZtzuMQSDbbBYcnE6bweCRocSERE5pgqXjFAohMViOXhlsznymIiIRF84nEZx8fuEw4nExc0nKekvRkcSERE5pkqdXWrBggXs3bs38nVpaSkmk4nPP/+cdevWHbSsyWTi1ltvjUpIEZH6LBjsjNs9EqdzCImJ/8Tv70Z5+ZVGxxIRETmiSpWM2bNnM3v27EPu/+ijjw65TyVDRCR6fL6BeL3LSEx8HYdjGEVF7QkG2xsdS0RE5LAqXDK++uqr6swhUi1yc7cc1/oWi5nc3ADhsJVgsGrDAvPydhxXBpEDPJ4/Y7WuIC7uW5zOmygq+ppw2Gl0LBERkUNUuGTk5eXRtm1bGjRoUJ15RKIiGNw/OXbChDEGJ/lNfHy80RGk1rPick0gLa0nVutGHI5huFyTqMT0OhERkRpR4ZIxePBgXnrpJfr161edeUSiIivrBP70p+cPOVlBZe3evZNRo0YybNgImjTJqPJ24uPjj2t9kQPC4Ua4XBNJTb0Eu302iYn/wut92OhYIiIiB6lwyQiHw9WZQyTqsrJOOO5tWCz7PyHOzGxG8+atjnt7ItEQCJxGScm/cDhGkJj4An7/Kfj9FxkdS0REJELH2EVEaqGyssGUlg7BZArjdN6O2bzZ6EgiIiIRlSoZJpOpunKIiEgllZT8A7//DMzmIlJSBgFeoyOJiIgAlTyF7SOPPMIjjzxSoWVNJhNr1qypUigREakIOy7XRNLSzsNqXYXDcQ9u99uAPhASERFjVapknH322bRu3bqaooiISGWFQpm4XO+SktKP+PjJBAKnUVp6t9GxRESknqtUyejfv7/OLiUiEmP8/nPweP5KcvJjJCU9RSDQBb//XKNjiYhIPaaJ3yIidUBp6TDKyq7DZAridP4Bs1kXgRQREeOoZIiI1Akm3O7XCAROxmzeg9N5C+AzOpSIiNRTKhkiInVGIsXFkwiFUrHZlpCc/JjRgUREpJ6q8JyMdevWVWcOERGJglCoDS7XWFJSBpKQMI5A4FTKygYbHUtEROoZHckQEalj/P6L8HqfBiA5+UGs1iUGJxIRkfpGJUNEpA7yeh/E57sCk6kcp/MWTKY9RkcSEZF6RCVDRKROMuN2jyIQaIfFsgOn81YgYHQoERGpJ1QyRETqqHDYicv1PqFQMnFx35GU9IzRkUREpJ5QyRARqcOCwfa43f8BIDFxJHb7FIMTiYhIfaCSISJSx5WX98PrfQgAh2MEFsuvBicSEZG6TiVDRKQe8Hj+RHn5BZhMXlJSbsZkKjQ6koiI1GEqGSIi9YIFl2sswWArLJbNOBxDgZDRoUREpI5SyRARqSfC4YYUF79HOByP3T6XxMQXjY4kIiJ1lEqGiEg9Egx2we1+DYCkpH8QF/eZwYlERKQuUskQEalnfL4b8HrvAsDhGIrFstHgRCIiUteoZIiI1EMez98oLz8bs9mF03kzUGJ0JBERqUNUMkRE6iUbLtc7BIMZWK3rcDrvBsJGhxIRkTpCJUNEpJ4Kh5vgcr1LOGzDbp9BQsJrRkcSEZE6QiVDRKQeCwS6U1LyEgBJSc9is31tcCIREakLVDJEROq5srIhlJbegskUwum8DbN5q9GRRESkllPJEBGp90yUlPwTv78bZnMBTucgoNToUCIiUoupZIiICBCPyzWJUKghNttyHI4H0ERwERGpKpUMEREBIBRqgcs1gXDYTHz8+8THjzU6koiI1FIqGSIiEuH398LjeR6A5OTHsFoXGZxIRERqI5UMERE5SGnpPZSVDcBk8uN03oLZvMvoSCIiUsuoZIiIyP8w4XaPJBDohMWyC6dzMFBudCgREalFVDJEROQwkv87ETwFm+0nkpOfNDqQiIjUIioZIiJyWMHgCbjdowFISBiN3f6+wYlERKS2sBod4Pdyc3MZM2YMy5YtIzs7m3B4/+kTV65cid1uB6CwsJB33nmHRYsWsW3bNoqLi0lPT+fUU0/l3nvvpUWLFhXaV3Z2Nq+++io///wzZWVltG3blj/84Q/079+/up6eiEitU15+GR7PEyQlvYjDcT/BYCcCga5GxxIRkRgXUyVj48aNTJ48+ajL5Obm8tZbbx103/bt29m+fTtff/01U6dOpVWrVkfdRnZ2NjfccAMulyty35o1a3jsscfIz8/nzjvvrPqTEBGpY7zex7Bal2G3f47TOYjCwgWEww2NjiUiIjEspoZLpaenM2zYMEaNGkWXLl2OuFzHjh159dVXWbJkCQsWLOCcc84BwO1288477xxzP3//+99xuVxYrVZGjx7Nd999R+fOnQF47bXX2LVLZ1IREfmNGbd7NIFAFhbLVpzOIUDQ6FAiIhLDYqpkdOnShQceeIDevXsTHx9/2GXat2/PtGnT6Nu3Lw6Hg6ZNm/Lggw9GHs/NzT3qPgoKCvj+++8B6NGjB7169SI9PZ0hQ4YA4Pf7+fzzz6P0jERE6oZwOBWX633C4UTi4r4mKekFoyOJiEgMi6mSUREJCQmYzQfH9vl8kdvp6elHXX/dunWEQiEAsrKyIvf//vbq1aujEVVquUAggM9XitPpNDqKSEwIBjvhdr8JQGLiv4iLm2lwIhERiVUxNSejKkKhEG+88Ubk62uuueaoyxcUFERuJycnH/b275epCqu11nW3emvbtq243e7DPhYKBQiF/AwePJjt23Pxer2HXc7hcNCiRcvqjCkSM4LBgZSVLSM+/v9wOofjcnUgFOpY6e1YLObI31X9mfn7bVRVNHKIiMihanXJCIVCPPnkkyxcuBCAESNGcPrpp1dpWwfOZHW8zGYTaWlJUdmWVK+CggIuv/ziyJGt/+VwOHjooYc48cQTiY+Hr776nAkTJhx05AzAYrGwfPlyGjRoUBOxRWLAK8AqTKb5pKTcDPwMpFRqC/v27R8S63DEH/fPTKczocrrRjOHiIj8ptaWjEAgwKOPPsqcOXMAGDJkCPfcc88x1/v9G8Hff4Lt8XgOu0xlhUJhXK7Df+ItscVksjNnztwjHsnYvwwEgz5CoRC9evWiV6/zsVjiMJl++8TT4XBgMtkpLPQccTsidY3JNBan8zzM5g2Ulw/C43mfyozAdbvLIn9X9bVjsZhxOhNwuUoJBg//YUFN5JDocDoTjuuolIjEllpZMvx+Pw8++CBz584F4O677+a+++6r0LodOnTAbDYTCoXYvHlz5P6cnJzI7QNnmqqqQKBqv+yk5mVkNCcj48iPW61m0tKS2LZtF1u35hAI+AkGy2nSJJMGDdIxmUyAvudSHzWkuHgSqamXEBc3G7//JbzeRyu89oFSEAyGjvv1czzbiGYOERH5TUx9ZOD3+ykoKKCgoAC/3x+5v6ioiIKCAkpLSykvL2fEiBGRgvHwww8fsWAsWrSI9u3bR85IBfuPUpx77rmRx7/99lvy8/MZN24cADabjUsvvbQ6n6bUQsnJDtq27YjDkQqE2b17B1u3biIQ8B9rVZE6KxA4Fbf7VQASE/9KXNxcgxOJiEisiKkjGUuXLmXw4MGH3N+zZ09g/5yLM888k2+++Sby2CuvvMIrr7wS+bpZs2bMnz//qPt5/PHHWb58OS6Xi6FDhx702L333kvTpk2P41lIXWWxWGnevA1FRfvYtWsbHo+b7Oy1ZGa2wuGo3Hh0kbrC5xtEaekvJCSMxeG4g8LCbwiFso69ooiI1GkxdSSjprRt25YPP/yQiy66iJSUFOx2O506deIf//iHrvYtR2UymUhLa0RWVgfs9gSCwQDbtmWza9f2I04gF6nrSkr+gd9/BmZz0X8ngmtug4hIfRdTRzK6d+/O+vXrj7lcRZY51vbatm3LyJEjK5VP5AC7PYE2bdqTn7+DgoI9FBTk4/G4ad68NXZ71c90I1I7xeFyTSIt7Tys1tU4HPfidr8NmIwOJiIiBqmXRzJEosFsNtO0aQtatGiLxWLF5yslJ2cdhYV7o3ZKZJHaIhTKwOV6l3DYSnz8ZBIS3jQ6koiIGEglQ+Q4ORwpZGV1JCnJQTgcZufOrWzfvplgMGB0NJEa5fefTUnJ3wBISvoTNtv3BicSERGjqGSIRIHNZqNlyxNIT28GgNtdRHb2WrzeEoOTidSssrK7KCu7HpMpiNP5B8zmHUZHEhERA6hkiESJyWSiUaMmtGnTnrg4O4GAny1bNpCfn6fhU1KPmHC7/w+/vwtm8x6czkGAz+hQIiJSw1QyRKIsISGJNm06kJKy/8rxe/fuYsuWDZSX642W1BeJuFyTCIXSsNl+ITn5EaMDiYhIDVPJEKkGFouFZs1a06xZa8xmM6WlHnJy1lFcXGh0NJEaEQq1xuUaRzhsIiFhAvHxE4yOJCIiNUglQ6QapaQ0ICurIwkJSYRCQXbs2ExeXi6hUNDoaCLVzu+/EI/nGQCSkx/Gal1scCIREakpKhki1Swuzk7r1ifSqNH+K8kXFe0jJ2cdpaVeg5OJVL/S0gfx+fphMpXjdN6CyZRvdCQREakBKhkiNcBkMpGenkmrVu2wWm2Ul/vYvHk9+/bt1qRwqeNMuN1vEQiciMWSh9N5K+A3OpSIiFQzlQyRGpSU5CArqyMORwoQZvfuHWzdmk0goDddUneFw05crvcJhRzExX1PUtIzRkcSEZFqppIhUsOsVivNm2eRkdECk8mEx+MiO3stJSXFRkcTqTbB4Im43aMASEx8gwYNPjM4kYiIVCeVDBEDmEwm0tIa06ZNB+z2eILBAFu3ZrNr13ZCoZDR8USqRXl5PzyehwFo1eo5Wrd2GZxIRESqi0qGiIHi4xNo06YDaWmNASgoyGfLlvX4fGUGJxOpHl7vU5SXX4jFUsaTTy7BYlHREBGpi1QyRAxmNpvJyGhBixZZWCwWyspKyclZR2HhXk0KlzrIgss1Fp+vGRkZXrKyngB0SmcRkbpGJUMkRjgcqWRldSQpyUE4HGLnzq3s2LGZYDBgdDSRqAqHG7Bp06v4fGZSUr4nMfFFoyOJiEiUqWSIxBCbLY6WLU8gPT0TAJeriJycdXi9JQYnE4mu0tL2vP56FwCSkl4iLm6OwYlERCSaVDJEYozJZKJRo6a0adMem82O31/Oli0b2LNnp4ZPSZ2yYEFzdu++GQCH404slo0GJxIRkWhRyRCJUQkJSWRldSAlpQEAe/bsZMuWDfj95QYnE4me7dsfoLz8HMxmN07nTZhMbqMjiYhIFKhkiMQwi8VCs2atadasNWazmdJSD9nZa3G5Co2OJhIV4bANl+sdgsEMrNb1OBx3AzpiJyJS26lkiNQCKSkNyMrqSHx8IqFQkO3bN5OXl0sopLPySO0XDqfjck0kHLZht88kIeH/jI4kIiLHSSVDpJaIi7PTpk17GjVqAkBR0T5yctZRVuY1OJnI8QsEzqSk5BUAkpKew2abb3AiERE5HioZIrWIyWQiPb0ZrVq1w2q1UV7uY/Pm9ezbl69J4VLrlZXdSmnpYEymEE7nEMzmXKMjiYhIFalkiNRCSUkOsrI64nCkEA6H2b17O9u2ZRMI+I2OJnIcTJSUvILffypmcwFO5yCg1OhQIiJSBSoZIrWU1WqlefMsmjZtgclkoqTERXb2WkpKXEZHEzkO8bhckwiFGmGzrcDhuB9NBBcRqX1UMkRqMZPJRIMGjWnTpgN2ezzBYICtWzexa9d2wuGQ0fFEqiQUao7LNYFw2EJ8/AfEx48xOpKIiFSSSoZIHRAfn0CbNh1IS2sMQEFBPps3r8fnKzM4mUjV+P098XheACA5+XGs1p8MTiQiIpWhkiFSR5jNZjIyWtCiRRYWi4WyslJyctZRVLRPk8KlViot/SNlZddgMgVwOm/BbN5pdCQREakglQyROsbhSCUrqyOJiQ7C4RB5ebns2LGFYDBgdDSRSjLhdo8kEOiExbIbp3MwoCvei4jUBioZInWQzRZHq1YnkJ6eCYDLVUhOzjq83hKDk4lUVhLFxe8RCqVisy0iOflxowOJiEgFqGSI1FEmk4lGjZrSpk17bLY4/P5ytmzZwJ49OzV8SmqVUKgtbvcYwmETCQlvY7e/Z3QkERE5BpUMkTouISGJrKyOpKQ0AGDPnp3k5m7E79ewE6k9yssvwet9AgCH436s1uXGBhIRkaNSyRCpBywWC82atSYzsxVmsxmvt4Ts7LW4XIVGRxOpMK/3UXy+yzCZfDidN2My7TU6koiIHIFKhkg9kprakKysjsTHJxIKBdm+fTN5ebmEQrqmhtQGZtzu0QQCbbFYtpGUdCugExqIiMQilQyReiYuzk6bNu1p2LAJAEVF+8jJWUdZmdfgZCLHFg6n4HK9TzichM32DfAnoyOJiMhhWI0OICI1z2Qy0aRJM5KSHOTl5VJeXsbmzetJT29GgwaNMZlMRkeUesDhcFBe7qOkxF3JNZvj9Y4iOflZ4DPc7nsJBquWobzch8PhqNrKIiJyRKawTjMTVcFgiIICj9ExJEqsVjNpaUkUFnoIBOrmkKJAIEBeXi4lJcUAJCc7ycxshdVqMziZ1GU5OZvIy9uC2Wz8AfVQKERmZmuysk4wOkq91qBBEhaL8f8fRCQ6dCRDpJ6zWq20aJFFYeFedu/eTkmJi5yctWRmtiY52Wl0PKmjLBYLkydPZsSIB8jIaFbFbZhwOhNwuUoJBqv2ednOnTsYOfJVHnxQ198QEYkmlQwRwWQy0aBBYxITk9mxYzM+Xxlbt26iYcN00tMzMZn06aJEn9vtJi7OTnJy1YYrWa1mUlOTCIdtVT7SGBdnx+2u7HAtERE5Fr1zEJGI+PgE2rTpQFpaIwD27ctn8+YN+HxlBicTERGR2kQlQ0QOYjabychoSfPmWVgsFsrKvOTkrKOoaJ+uFC4iIiIVopIhIofldKaSldWRxMRkwuEQeXm57NixhWBVT+MjIiIi9YZKhogckc0WR6tW7WjcOBMAl6uQnJy1eL0lBicTERGRWKaSISJHZTKZaNy4Ka1bt8dmi8PvL2fLlg3s2bNTw6dERETksFQyRKRCEhOTyMrqiNOZBsCePTvJzd2I319ucDIRERGJNSoZIlJhFouFZs1ak5nZCrPZjNdbQnb2WlyuIqOjiYiISAxRyRCRSjGZTKSmNiQrqwPx8YmEQkG2b89h586thEJ186roIiIiUjkqGSJSJXFx8bRpcyINGzYBoLBwL5s3r6OszGtwMhERETGaSoaIVJnJZKZJk2a0bHkCVqsVn6+MzZvXU1CQr0nhIiIi9ZhKhogct+RkJ1lZHUlOdhIOh9m1azvbtmUTCPiNjiYiIiIGUMkQkaiwWm20aNGWpk2bYzKZKClxkZOzjpISl9HRREREpIZZjQ7we7m5uYwZM4Zly5aRnZ0dGW6xcuVK7HZ7ZLn33nuP+fPns2LFCtxuNwBDhw7l4YcfrtB+brnlFn7++efDPvbGG2/Qp0+f43wmIvWTyWSiQYN0EhOT2b59C+XlZWzduomGDZuQnp6ByaTPNUREROqDmCoZGzduZPLkycdc7uOPP2bdunU1kEhEqiI+PpGsrA7s3r2dwsK97Nu3G4/HTfPmrYmLizc6noiIiFSzmCoZ6enpDBs2jK5du/Lmm2+ycuXKwy530UUXcf3112MymXjuueeqvL8RI0Zwzz33VHl9ETkys9lMRkZLkpKc5OXlUlbmJSdnHU2btiAlpQEmk8noiCIiIlJNYqpkdOnShS5dugAwbty4Iy43YsQIABYtWlQjuUSk6pzOVBISEtmxYwtebwl5ebmUlLjIyGiJxWIxOp6IiIhUg3o9QHrixImcdNJJdOvWjUGDBrFgwQKjI4nUSTZbHK1ataNx4wwAXK5CcnLW4vV6DE4mIiIi1SGmjmTUtOLiYgD8fj+LFy9m8eLFvPLKK/Tr1++4tmu11uvuVqdYLOaD/pbjk5HRDKczha1bc/D7y9myZT1NmzajceOmGj5Vz/z+tVXVn5nReH1GI4eIiByqXpaMSy+9lLvvvpuOHTtiMpmYOHEir7/+OgCvvvrqcZUMs9lEWlpStKJKjHA6E4yOUGekpSXRtGlDNm7cSH5+Prt27aC0tISOHTsedBY5qdv27dt/AgCHI/64f2Yez+szmjlEROQ39bJk3HzzzQd9PWLECGbNmsWWLVvYsWMHBQUFNGjQoErbDoXCuFzeaMSUGGCxmHE6E3C5SgkGQ0bHqVOaNGlBXFwieXlbKS4uZvHixTRv3pqUlDSjo0kNcLvLIn8XFlZt2Fw0Xp/RyCHR4XQm6KixSB1S70pGKBTCbD70h1g0h2oEAnozWtcEgyF9X6uB09kAu33/pPCyMi+5udmkpTWiSZPmh32dSt1xoBRE47V1PNuIZg4REflNTP0W9/v9FBQUUFBQgN/vj9xfVFREQUEBpaWlALjdbgoKCiIX4gMoKyuLrHvA66+/Tvv27Wnfvj3bt28HYP369dx2220sWLCAkpISiouLGTlyJJs3bwagdevWVT6KISKVZ7fH06bNiTRsmA5AYeFeNm9eR1lZqcHJREREpKpi6kjG0qVLGTx48CH39+zZE/jtuhZ33333IVfsnjhxIhMnTgT2F4mj+eGHH/jhhx8Oud9qtfLkk09WNb6IVJHJZKZJk+b/vabGFny+MjZvXkeTJs1JS2ukSeEiIiK1TEwdyagJLVq04OGHH+aMM86gcePGWK1W0tLSuPDCC/nggw/o1auX0RFF6q3kZCdZWR1JTnYSDofZtWsb27blEAgEjI4mIiIilRBTRzK6d+9+zKMQQOSIxbHcc889h1zROzk5maFDhzJ06NAqZRSR6mW12mjRoi0FBXvIz99BSUkxOTlradasNUlJDqPjiYiISAXUuyMZIhL7TCYTDRum06ZNe+Li7AQCfnJzN7J79w7C4bDR8UREROQYVDJEJGbFxyeSldWR1NRGAOzbt5vNm9dTXu4zOJmIiIgcjUqGiMQ0s9lMZmZLmjdvg9lsoazMS07OWoqK9hkdTURERI5AJUNEagWnM422bTuSmJhMKBQiLy+XHTu2EAwGjY4mIiIi/0MlQ0RqDZstjlat2tG4cQYAxcUF5OSsxevVlZpFRERiiUqGiNQqJpOJxo0zaN36RGy2OPz+crZsWc/evbs0KVxERCRGqGSISK2UmJhMVlYHnM40APLz88jN3YTfX25wMhEREVHJEJFay2Kx0qxZazIzW2EymfF63eTkrMXtLjI6moiISL2mkiEitZrJZCI1tSFZWR2Ij08gGAyybVsOO3duIxQKGR1PRESkXlLJEJE6wW6Pp3Xr9jRokA5AYeEeNm9eR1lZqcHJRERE6h+VDBGpM8xmM02bNqdlyxOwWKz4fGVs3ryOgoI9mhQuIiJSg1QyRKTOSU520rZtR5KTnYTDYXbt2sb27TkEAgGjo4mIiNQLKhkiUidZrTZatGhLkybNMZlMuN3F5OSsxeNxGx1NRESkzlPJEJE6y2Qy0bBhOq1btycuzk4g4Cc3dyP5+Ts0fEpERKQaqWSISJ2XkJBIVlYHUlMbArB37262bFlPebnP4GQiIiJ1k0qGiNQLZrOFzMxWNG/eBrPZQmmpl5yctRQXFxgdTUREpM5RyRCResXpTKNt244kJCQRCoXYsWMLO3ZsIRgMGh1NRESkzlDJEJF6x2aLo3XrE2ncOAOA4uICcnLWUVrqMTiZiIhI3aCSISL1kslkonHjDFq3PhGbLQ6/38fmzevZu3eXJoWLiIgcJ5UMEanXEhOTycrqgNOZCkB+fh5bt27C7y83NpiIiEgtppIhIvWexWKlWbM2ZGS0xGQy4/G4yclZh9tdZHQ0ERGRWkklQ0SE/cOn0tIakZXVgfj4BILBANu25bBz5zZCoZDR8URERGoVlQwRkd+x2+Np3bo9DRqkA1BYuIfNm9fh85UanExERKT2UMkQEfkfZrOZpk2b07JlWywWKz5fGTk56ygo2KNJ4SIiIhWgkiEicgTJySm0bduRpCQn4XCYXbu2sX17DoFAwOhoIiIiMU0lQ0TkKKxWGy1btqVJk2aACbe7mJyctXg8bqOjiYiIxCyVDBGRYzCZTDRs2IQ2bdoTF2cnEPCTm7uR/Pw8DZ8SERE5DJUMEZEKSkhIJCurA6mpDQHYu3cXW7ZsoLzcZ3AyERGR2KKSISJSCWazhczMVjRr1gaz2UJpqYecnLUUFxcYHU1ERCRmqGSIiFRBSkoaWVkdSEhIIhQKsWPHFnbs2EIwGDQ6moiIiOFUMkREqiguzk7r1ifSqFFTAIqLC9i8eR2lpR6Dk4mIiBhLJUNE5DiYTCbS0zNp1epErFYb5eU+Nm/ewN69uzUpXERE6i2VDBGRKEhKSqZt2444HKlAmPz8HWzdugm/3290NBERkRqnkiEiEiUWi5XmzduQkdESk8mEx+MmJ2ctbnex0dFERERqlNXoACIidYnJZCItrRGJicns2LGZsrJStm3LpkGDxqSnN8Ns1mc7v5ebu6XK61osZnJzA4TDVoLBUJW2kZe3o8r7FxGRI1PJEBGpBnZ7PK1btyc/P4+CgnwKCvbg8ZTQvHlr7PYEo+MZ7sBZuCZMGGNwkv3i4+ONjiAiUqeYwpqZGFXBYIiCAp1Zpq6wWs2kpSVRWOghEKjaJ6UibncxeXm5BIMBTCYTTZu2IDW1ISaTyehohsrJ2YTFYqny+rt372TUqJEMGzaCJk0yqryd+Pj441pfoqNBgyQsFh3pE6krdCRDRKSaORwptG3bkR07tuDxuNm5cyslJS4yM1tisdTfH8NZWScc1/oH3pBmZjajefNW0YgkIiJRoo8MRERqgNVqo2XLE2jSpBlgwu0uIjt7LR6P2+hoIiIiUaeSISJSQ0wmEw0bNqFNm/bExdkJBPzk5m4kPz9P19QQEZE6RSVDRKSGJSQkkpXVgdTUhgDs3buLLVs2UF7uMziZiIhIdKhkiIgYwGy2kJnZimbNWmM2mykt9ZCTs47i4gKjo4mIiBw3lQwREQOlpDQgK6sjCQlJhEJBduzYwo4dWwiFgkZHExERqTKVDBERg8XF2Wnd+kQaNWoKQHFxATk56ygt9RqcTEREpGpUMkREYoDJZCI9PZNWrdphtdooL/exefN69u3brUnhIiJS66hkiIjEkKQkB23bdsThSAXC7N69g61bNxEI+I2OJiIiUmEqGSIiMcZisdK8eRsyMlpiMpnweNxkZ6/F7S42OpqIiEiFqGSIiMQgk8lEWlojsrI6YLcnEAwG2LYtm127thMKhYyOJyIiclQqGSIiMcxuT6BNm/Y0aNAYgIKCfDZvXo/PV2pwMhERkSNTyRARiXFms5mmTVvQokVbLBYrPl8pOTnrKCzcq0nhIiISk6xGB/i93NxcxowZw7Jly8jOzo788ly5ciV2uz2y3Hvvvcf8+fNZsWIFbrcbgKFDh/Lwww9XeF8LFizgrbfeYt26dZjNZrp27cq9995L165do/qcRESixeFIISurI3l5W/B43OzcuZWSEheZmS2xWGLqx7mIiNRzMfVbaePGjUyePPmYy3388cesW7euyvuZPXs2Dz/88EGfAC5cuJDFixczbtw4zjjjjCpvW0SkOtlsNlq2PIF9+/LJz9+B211EdraH5s3bkJiYbHQ8ERERIMaGS6WnpzNs2DBGjRpFly5djrjcRRddxLPPPstzzz1X6X2UlZXxwgsvEA6HyczMZO7cuUyZMgWHw0F5eXmVtikiUpNMJhONGjWhTZv2xMXZCQT8bNmygfz8PA2fEhGRmBBTJaNLly488MAD9O7dm/j4+CMuN2LECG666SaysrIqvY9vv/2WoqIiAG688UZatWrFySefTN++fQH+v717j46qOtg//pyZhCTkOgFJCBggr0C4ihhARKhyadW2r0AF258aUIpaQIqWWsBCRVbFSy/KtVVEUAO+YEVEETUUilKuisASggghQBKQZHIPuZA5vz8w0xmSANqYM8N8P2tlMbPPyeRBV0Ke2Wefra+++koHDhz4TvkBoCmFhYWrQ4dkRUfHSpLy8k7p2LEvVVVVaXEyAECg86mS0RS++OIL92PPkuL52PMcAPBldrtdbdq0V5s27WWz2XT2bJmOHs1QUVGB1dEAAAHMp9ZkNIWCgv/8wxseHl7vY6fT+V99jaCggOtuVyy73eb1J+CrWrRoqcjISB0/flTl5WXKzs5UeXmJ2rS5Wjab3ep43wubzXD/yc9dAPAtAVcyLodhGN/5c202Qw5H+KVPhF+JigqzOgJwGcJ11VUxysrK0vHjx1VQkKeKijJ16dJFkZGRVodrdPn55+86GB4ews9dAPAxAVcyHA6H+3Fpaan7cVlZWb3nfFsul6ni4vLv/PnwLXa7TVFRYSouPquaGnZZhn+IiWmloKBQnTiRqbNnz2rPnj2Kj2+jli3j/qs3UXxNWVml+8+CgrJLnA1fFxUVxqwxcAUJuJLRrVs39+PMzEz346NHj9Z7zndx7hy/jF5pampc/H+FXwkNjVCHDl2Um5ulkpIi5eaeVHFxsdq0aaegoGCr4zUKl8t0/8n3JwD4Fp96y6C6ulpOp1NOp1PV1dXu8cLCQjmdTp09e1aSVFJSIqfT6d6ITzp/a9raz601f/58de7cWZ07d9bJkyclSYMGDVJMTIwkaeXKlcrKytL+/fu1fv16SdI111yjrl27ft9/VQD43gUFBalt2yS1bn21DMNQWVmxjhw5qNLSIqujAQCucD41k/HZZ58pNTW1zvigQYMknb917cMPP6wJEyZo586dXue89tpreu211yRJhw4davBrhIaGaubMmZo6dapycnL0wx/+0H2sWbNm7JMB4IpiGIYcjqsUFhah7OxMVVZW6PjxI4qNbaVWrRJks/nUe00AgCtEQP7r8pOf/ER///vfdd111yksLEzh4eEaMGCAXnvtNXb7BnBFCg0NU4cOyXI4rpIkOZ1f69ixQ6qsrLA4GQDgSmSYbA/bqGpqXHI6WYB4pQgKssnhCFdBQRnXfOOKUVJSqJycLNXU1MgwbIqPb6uYmBZ+tyj85MkszZo1XU8+OVdt27azOg7+S7Gx4Sz8Bq4gfDcDQICJjIxRUlIXhYdHyjRdys09ruzsTNXUnLM6GgDgCkHJAIAAFBzcTImJ16hVqwRJUnFxoY4ezVB5eeklPhMAgEujZABAgDIMQy1bxqtDh84KDg5RdXWVjh37UmfO5IoraQEA/w1KBgAEuLCwcCUlJSs6OlaSdOZMro4d+1LV1VUWJwMA+CtKBgBAdrtdbdq0V5s27WWz2XT2bJmOHDmo4uICq6MBAPwQJQMA4BYdHaukpC4KDW0ul6tGJ09mKicnSy5XjdXRAAB+hJIBAPDSrFmIOnTorJYt4yRJhYX5Ono0QxUV5RYnAwD4C0oGAKAOwzDUqlUbtWvXUUFBwaqqqlRm5iHl53/NonAAwCVRMgAADQoPj1RSUhdFRkbLNE2dPn1SJ04c0blz1VZHAwD4MEoGAOCigoKC1LZtkuLjr5ZhGCotLdaRIwdVWlpsdTQAgI+iZAAALskwDMXGXqUOHZIVEhKqmppzOn78K506dVKm6bI6HgDAx1AyAACXLTQ0TB06JMvhuEqS5HR+rczMQ6qsrLA4GQDAl1AyAADfis1mU+vWV+vqq5Nkt9tVUXFWR49mqLAwn0XhAABJlAwAwHcUGRmjpKQuat48UqbpUk5OlrKzj6mm5pzV0QAAFqNkAAC+s+DgZmrX7hq1apUgSSouLtDRoxkqLy+1OBkAwEqUDADAf8UwDLVsGa8OHTorOLiZqqurdOzYlzpzJpfLpwAgQFEyAACNIiwsXElJXRQdHStJOnMmV1lZh1VdXWVxMgBAU6NkAAAajd1uV5s27ZWQ0E42m03l5aU6cuSgiosLrI4GAGhClAwAQKOLiWmhpKQuCg1tLperRidPZionJ0suF3tqAEAgoGQAAL4XzZqFqEOHzmrRIk6SVFiYr6NHM1RRUW5xMgDA942SAQD43hiGobi4NkpMvEZBQcGqqqpQZuYh5ed/zaJwALiCUTIAAN+7iIgoJSV1UUREtEzT1OnTJ3XixBGdO1dtdTQAwPeAkgEAaBJBQUG6+uokxcdfLcMwVFparKNHD6q0tNjqaACARkbJAAA0GcMwFBt7lTp0SFZISKjOnTun48e/0unTJ2WaLAoHgCsFJQMA0ORCQ8PUoUOyHI6WkqT8/K+VmfmlKisrLE4GAGgMlAwAgCVsNptat05U27ZJstvtqqgo19GjGSoszGdROAD4OUoGAMBSUVExSkrqoubNI2SaLuXkZCk7+5hqamqsjgYA+I4oGQAAywUHN1O7dh111VUJkqTi4gIdPXpQ5eWlFicDAHwXlAwAgE8wDENXXRWv9u07Kzi4maqrq3Ts2Jc6cyaXy6cAwM9QMgAAPqV583AlJXVRVJRDknTmTK6ysg6rurrK4mQAgMtFyQAA+By73a42bdorIaGdbDabystLdeTIQRUXF1odDQBwGSgZAACfZBiGYmJaKCkpWaGhzeVy1ejkyaPKzT0ul4s9NQDAl1EyAAA+rVmzUHXo0EktWsRJkgoK8pSZmaGamnMWJwMANCTI6gAAAFyKYdgUF9dG4eGRysk5psrKClVWVqh79+5WRwMA1IOSAQDwSSdPnlBJSXGdcdO06fxEvEs333yzvvrqsEpKGr7VbWRklNq2vfr7CwoAqIOSAQDwOQUFBfrf//3RRdde9OvXT9XV1frss88u+lp2u13p6Z/I4XA0dkwAQAMoGQAAn+NwOPTOOx/UO5NRy263yWarkctlV01Nw2UkMjKKggEATYySAQDwSZe6xCkoyCaHI1wFBWU6d467TQGAL+HuUgAAAAAaFSUDAAAAQKOiZAAAAABoVJQMAAAAAI2KkgEAAACgUVEyAAAAADQqSgYAAACARkXJAAAAANCoKBkAAAAAGhUlAwAAAECjomQAAAAAaFSUDAAAAACNKsjqAJ6ysrL00ksvac+ePTpy5IhM05Qk7du3TyEhIV7nvv3221q+fLmOHDmi0NBQ9e3bV4888oj+53/+55JfZ9q0aVqzZk29x6ZPn66xY8f+138XAAAAIFD5VMk4fPiwVq9efcnzXnzxRf35z392P6+srNRHH32kHTt26I033risogEAAADg++FTl0u1atVKDz30kP72t7+pZ8+e9Z6Tm5urefPmSZK6deumLVu26KWXXlJQUJCKi4v19NNPX/bXGzFihA4dOuT1wSwGAAAA8N/xqZmMnj17usvF0qVL6z1nw4YNqq6uliSNGzdOcXFxiouL0w033KBPPvlEn3zyiZxOp2JjY5ssNwAAAID/8KmZjMvxxRdfuB8nJSW5H3fo0EGS5HK5dOjQoct6rY8++kjXXnutrr32Wt155516++23GzUrAAAAEIh8aibjchQUFLgfR0RE1Ps4Pz//sl6rtLTU/Xj//v363e9+p9OnT+vBBx/8zvlsNkOxseHf+fPhWwzj/J/R0WH65j4EAHwE359XFpvNsDoCgEbkdyWjIabHvzCGcfEfVP3799ePfvQj9ejRQ6GhoXr//fc1a9YsuVwuLVq0SKmpqQoLC/tOOQzDkN3OD8orjc3md5N+QMDg+xMAfI/f/WR2OBzuxyUlJe7HZWVl7seXWo9xxx136JZbblHLli0VERGhUaNG6cYbb5QkVVRU6PDhw42cGgAAAAgcflcyunXr5n6cmZlZ57HNZlPnzp0b/HzTNL1mPepzqZkQAAAAAA3zqZJRXV0tp9Mpp9PpvoOUJBUWFsrpdOrs2bO69dZbFRwcLEl6+eWX9fXXX2vLli3avn27JOmmm25yz2S89dZb6ty5szp37qwdO3ZIOj/7MWrUKL3//vsqLCxUaWmpVq9erX//+9+Szq/t6NSpU1P+tQEAAIArik+tyfjss8+UmppaZ3zQoEGSpEmTJunhhx/W5MmT9ec//1lffPGFBg4c6D4vKipK06ZNu+TX2b9/v6ZMmVLvsccee6zO7uIAAAAALp9PlYzL9cADD+iqq67Sq6++qiNHjig0NFR9+/bVI488csndvps3b66ZM2dq06ZN+uqrr5Sfn6+wsDD16NFD9913n1dpAQAAAPDtGealFigAAAAAwLfgU2syAAAAAPg/SgYAAACARkXJAAAAANCoKBkAAAAAGhUlAwAAAECjomQAAAAAaFSUDAAAAACNipIBAAAAoFFRMgAAAAA0KkoGAAAAgEYVZHUAwNcUFBRoyZIl2r59u4qLi/XRRx9p3bp1qqmp0cCBA9WiRQurIwIBq7i4WFu2bFFOTo6qqqrqHJ80aZIFqQAAF6JkAB7y8/M1evRo5eTkyDRNGYYhSfr444+1bt06Pfrooxo/frzFKYHAtH37dk2cOFHl5eUNnkPJAADfwOVSgIcXXnhB2dnZstvtXuMjRoyQaZratGmTRckAzJ07V2VlZTJNs94PAIDvYCYD8LB582YZhqElS5Zo7Nix7vGePXtKko4fP25RMgDHjx+XYRiaPn26Bg0apODgYKsjAQAaQMkAPDidTklS79696z1eWFjYhGkAeEpOTtbnn3+uH//4x6yNAgAfR8kAPDgcDuXl5eno0aNe4++9954k8YsNYKE//OEPGjNmjB544AHdfffdat26tYKCvP8Z69Onj0XpAACeKBmAh/79+2vdunWaOHGie2z8+PHaunWrDMNQ//79LUwHBLa4uDh17NhRu3fv1uOPP17nuGEYOnDggAXJAAAXMkxWywFuWVlZ+tnPfqbS0lL3naUkyTRNRUZG6h//+IcSExMtTAgErkmTJmnjxo0NLvI2DEMHDx5s4lQAgPowkwF4aNeundLS0jR37lzt2rVLNTU1stvt6tOnj6ZPn07BACy0detWSVKvXr2UkpKi0NBQixMBABrCTAbQgIqKChUVFSkmJkYhISFWxwEC3rBhw3Ty5Ent2rVLERERVscBAFwE+2QADQgNDVVcXBwFA/ARU6ZMkSStW7fO2iAAgEtiJgMBr0uXLpd9LgtLAevce++9+vLLL1VcXKz4+HglJCR4bZxpGIaWL19uYUIAQC3WZCDg0bMB/7Br1y4ZhiHTNJWbm6tTp065j5mm6XWzBgCAtSgZCHgjRoywOgKAy5CQkGB1BADAZeJyKQAAAACNipkMoB7Hjh3Tzp07VVBQIIfDob59+6p9+/ZWxwLwjcOHD8vpdMrhcKhTp05WxwEAXICSAXiorq7WrFmz9Pbbb9c5NmLECD355JMKCuLbBrDKpk2b9OSTT3qtx4iPj9fMmTM1ePBgC5MBADxxuRTgYe7cuQ3encYwDI0ZM0bTpk1r4lQAJOmzzz7TvffeK5fLVeeGDUFBQVq+fLmuv/56i9IBADxRMgAPN9xwg4qKipSYmKjU1FTFx8fr1KlTevXVV5WVlaWYmBht377d6phAQHrggQe0ZcsWhYaGatiwYWrdurVyc3OVnp6us2fPatCgQXrxxRetjgkAEJdLAV4qKyslSS+++KLatWvnHh8wYIBuvfVWVVdXWxUNCHh79+6VYRj629/+phtuuME9vn37do0dO1Z79+61MB0AwBM7fgMeBgwYIEkKDw/3Gq99PnDgwCbPBOC88vJySVL37t29xmuf1x4HAFiPkgF4uO+++xQdHa1HHnlE27Zt07Fjx7Rt2zY9+uijatWqle6//37l5OS4PwA0nfj4eEnS888/7y4UZ8+e1QsvvOB1HABgPdZkAB66dOly2ecahqEDBw58j2kAeHrmmWf0yiuvyDAM2Ww2RUREqLS0VC6XS5I0duxY/e53v7M4JQBAYiYD8GKa5rf6ANB0Jk6cqGuuuUamaaqmpkZFRUWqqamRaZpKSkrShAkTrI4IAPgGC78BD5MmTbI6AoAGRERE6I033tCyZcv0ySefuDfLvOmmmzR27FhFRERYHREA8A0ulwIA+IXadVAJCQkWJwEAXAolAwDgF5KTk2Wz2epdC/WDH/xANptNmzZtsiAZAOBCXC4FeKisrNSiRYu0YcMG5ebm1tkXg8XegLXqe1/M5XLp9OnTMgzDgkQAgPpQMgAPf/zjH7V69WpJ9f8yA6BpZWRkKCMjw2vs7bff9nr+1VdfSZKCg4ObKhYA4BIoGYCH9PR0SVKbNm107bXXqlmzZhYnAgJbenq6Fi5c6H5umqamT59e5zzDMNSuXbumjAYAuAhKBuCh9nKL1atXy+FwWJwGgPSfWcXa78/6Zhmjo6M1derUJs0FAGgYJQPwcNddd2nRokXavHmzRowYYXUcIOCNGDFCffv2lWmaGjNmjAzD0Kuvvuo+bhiGoqKi1K5dO4WGhlqYFADgibtLAR5cLpcmTpyozZs3q3Xr1mrdurXsdrv7uGEYWr58uYUJgcA1bdo0GYahuXPnWh0FAHAJlAzAwzvvvKPf/e539R4zTVOGYejgwYNNnApAQ/bs2SOn06levXqpRYsWVscBAHyDy6UADy+88AJ3lQJ81Isvvqh169Zp+PDhGjdunGbOnKk333xTkhQVFaWlS5eqW7duFqcEAEiUDMCL0+mUYRiaP3++Bg4cqJCQEKsjAfjGP//5T3311Vfq2rWrzpw5ozfffNP9pkBRUZEWL16sBQsWWJwSACBJNqsDAL5k0KBBkqQePXpQMAAfk5WVJUnq3Lmz9u7dK9M0NXz4cD377LOSpL1791oZDwDggZkMwMPtt9+uHTt2aPz48UpNTVWbNm0UFOT9bdKnTx+L0gGBrbS0VNL5S6MOHz4swzB0yy23aPDgwXrsscdUWFhobUAAgBslA/Dw61//WoZhqKioSDNnzqxz3DAMHThwwIJkABwOh86cOaO0tDRt3LhRktS+fXuVlJRIkiIjI62MBwDwwOVSwAVM07zoBwBrXH/99TJNU08//bS++OILtWjRQp07d9aRI0ckSYmJiRYnBADUYiYD8MD99wHf9cgjjygjI0OZmZmKiIjQE088IUn64IMPJEl9+/a1MB0AwBP7ZAAA/EphYaGioqJkszEZDwC+ipIBNMDpdKqioqLOeEJCggVpAAAA/AeXSwEeXC6X5s+frxUrVqi4uLjOcRZ+A9YZMmTIRY8bhqH09PQmSgMAuBhKBuDh1Vdf1eLFi62OAaAe2dnZ9Y4bhiHTNGUYRhMnAgA0hJIBeFizZo0Mw1CXLl104MABGYahYcOGacuWLWrVqpWuv/56qyMCAevCPWpcLpeys7N16tQphYWFqUePHhYlAwBciJIBeKjdUXjBggUaPHiwJGnevHnaunWrxo8fr8mTJ1sZDwhor732Wr3jq1at0h/+8Af9/Oc/b+JEAICGcGsOwENNTY0kKT4+Xna7XZJUVlamlJQUuVwuLVy40Mp4AOoxevRohYWFcakjAPgQZjIADzExMcrLy1NZWZkcDofy8/M1Z84chYSESJJyc3MtTggErpycnDpjlZWV2rJli8rLy3XixAkLUgEA6kPJADy0b99eeXl5ys7OVu/evfXhhx9q7dq1ks4vLu3UqZPFCYHANXjw4AYXdxuGoQ4dOjRxIgBAQygZgIdRo0apbdu2Kikp0ZQpU7Rv3z6dOnVKkhQdHa0ZM2ZYnBAIbA1t7dS8eXNNmzatidMAABrCZnzARZSWlmrv3r2qqqpS7969FR0dbXUkIGAtWLCgzlizZs0UHx+vQYMGKSYmpulDAQDqRckAPOzevVspKSkNHn/zzTd15513NmEiAAAA/8PdpQAPY8aM0XPPPafq6mqv8by8PD344IOaOXOmRckAnDhxQrt27dKRI0e8xo8cOaJdu3ax8BsAfAglA/BQU1OjpUuX6mc/+5kyMjIkSevXr9dPfvIT/etf/7I4HRDYnnjiCaWmpuqLL77wGj948KBSU1M1e/Zsi5IBAC7Ewm/AQ2pqql5//XV9+eWXGjVqlHr16qXdu3fLNE2FhYVp6tSpVkcEAtaBAwckSYMGDfIav+mmm2SaZp3yAQCwDjMZgIcZM2ZoxYoVuuaaa1RdXe0uGP3799e6det09913Wx0RCFglJSWSJJfL5TVe+7y0tLTJMwEA6kfJAC5QWlqq8vJyGYYh0zRlGIbKyspUWVlpdTQgoF111VWSpJdeeslrfMmSJZKkli1bNnkmAED9uLsU4GHq1Kl67733JEmhoaH6wQ9+oA8++ECSFBQUpF/96leaMGGClRGBgDVjxgy99dZb7o33OnTooMzMTGVmZkqSRo4cqT/+8Y8WpwQASJQMwEtycrIk6brrrtMzzzyjxMRE7dixQ9OnT1dOTo4Mw9DBgwctTgkEphMnTmjkyJEqKSnx2vnbNE1FRUXprbfeUtu2bS1MCACoxeVSgIfg4GA9+uijSktLU2JioiSpX79+WrdunUaOHGlxOiCwXX311UpLS9MNN9wgm80m0zRls9l04403Ki0tjYIBAD6EmQzAQ0ZGhns2oz6bN2/WzTff3HSBANSrsrJShYWFiomJUUhISJ3ju3btkiT16dOnqaMBAETJAOpVVFSkPXv2qLCwUMOHD7c6DoBvKTk5WTabzX3bWwBA02KfDOACS5cu1bx581RZWSnDMDR8+HCNHTtWJ06c0BNPPKGBAwdaHRHAZeA9NACwDmsyAA/vv/++nn32WVVUVMg0TfcvKUOGDFF2drb7zlMAAABoGCUD8LBs2TIZhqFhw4Z5jdeuw/j888+bPhQAAICfoWQAHg4dOiRJmjNnjtd4fHy8JOn06dNNngkAAMDfUDIAD7X33g8ODvYaP378uBVxAAAA/BIlA/CQlJQkSVqyZIl7bN++fXr88cclSR07drQkFwAAgD/hFraAh5UrV2r27Nleuwl7mj17tkaPHt3EqQB8W2vWrJEkjRgxwuIkABCYKBnABaZPn+7+BcXTyJEj9dRTT1mQCECtgoICLVmyRNu3b1dxcbE++ugjrVu3TjU1NRo4cKBatGhhdUQAgCgZQL0+/fRTbdmyRU6nU7GxsRo4cKBSUlKsjgUEtPz8fI0ePVo5OTkyTVOGYejgwYN67LHHtG7dOj366KMaP3681TEBAKJkAN9ZamqqDMPQ8uXLrY4CBIRZs2Zp1apVCgoK0rlz59wlY9u2bbrvvvvUu3dvrVixwuqYAACx8Bv4znbu3KmdO3daHQMIGJs3b5ZhGF43ZpCknj17SuIucADgSygZAAC/4HQ6JUm9e/eu93hhYWETpgEAXAwlAwDgFxwOhyTp6NGjXuPvvfeeJLHoGwB8CCUDAOAX+vfvL0maOHGie2z8+PF64oknZBiG+zgAwHqUDACAX5g4caLCw8OVnZ3t3svmk08+kcvlUkREhCZMmGBxQgBALUoGAMAvtGvXTmlpabrhhhtks9lkmqZsNptuuOEGvf7660pMTLQ6IgDgG9zCFviOBg8eLMMwtHHjRqujAAGnoqJCRUVFiomJUUhIiNVxAAAXoGQAAAAAaFRBVgcAfM22bduUlpamzMxMVVRUeB0zDEPp6ekWJQMCT5cuXS77XMMwdODAge8xDQDgclEyAA+bNm3SxIkTZZqmPCf5DMOQaZruxaYAmgaT7QDgnygZgIelS5fK5XIpLCxMZ8+elWEYio6OVmFhoaKiohQZGWl1RCCgjBgxwuoIAIDvgDUZgIc+ffqotLRUq1ev1p133inDMHTw4EG99NJLWrp0qZYuXfqtLt8AAAAIRJQMwEP37t1VU1Oj/fv3q0ePHpKk/fv3q7q6Wtddd52uu+46rVy50uKUQGA7duyYdu7cqYKCAjkcDvXt21ft27e3OhYAwAOXSwEeIiMjVVhYqOrqakVFRam4uFhvvvmmwsLCJEkHDx60OCEQuKqrqzVr1iy9/fbbdY6NGDFCTz75pIKC+GcNAHwBP40BDwkJCSosLNSZM2eUnJysnTt3avbs2ZLOL/6Oi4uzOCEQuP70pz9pzZo19R5bs2aNoqKiNG3atCZOBQCoDzt+Ax5uvPFGtW7dWl9++aXuv/9+2e12952mTNPU+PHjrY4IBKy1a9fKMAy1a9dOM2fO1MKFCzVz5ky1a9dOpmnWO8MBALAGazKAi9i3b582btyoqqoq3XzzzerXr5/VkYCAdd1116miokIbNmxQu3bt3OPHjh3TrbfeqvDwcH366acWJgQA1OJyKcBD7Tuhw4cPlyT17NlTPXv2lCSdOHFCJ06c0NVXX21ROiCwDRgwQBs3blR4eLjXeO3zgQMHWhELAFAPZjIAD8nJybLZbPXuGnyxYwC+f59++qkmTpyojh07asKECWrdurVyc3O1aNEiZWVlacGCBWrZsqX7/ISEBAvTAkBgo2QAHpKTk917Y3iqrKzUtddeW+8xAE3j2+xRYxgGbwgAgIW4XAoBLz09XRs3bvQamz59utfz48ePS1KdyzQANB3eEwMA/0HJQMDLyMjwuivNxe5S061bt6YJBaCOSZMmWR0BAHCZKBmA/vMOqWEYXs9rRUdHq3v37vr973/f5NkAnEfJAAD/wZoMwENDazIAAABw+ZjJADzMnTvX6ggAGlBZWalFixZpw4YNys3NVXV1tddxFnsDgO9gJgNogNPpVEVFRZ1xbosJWGPWrFlavXq1pPoXgTMLCQC+g5kMwINpmpo3b55WrFih4uLiOsd5pxSwTnp6uiSpTZs2uvbaa9WsWTOLEwEAGkLJADwsX75cixcvtjoGgHrU3phh9erVcjgcFqcBAFyMzeoAgC9Zs2aNDMNQ165dJZ3/peaHP/yhQkNDlZiYqOHDh1sbEAhgd911l0zT1ObNm62OAgC4BNZkAB569eqlyspKbdy4UYMHD3Zf471161aNHz9ezz77rH7yk59YHRMISC6XSxMnTtTmzZvVunVrtW7dWna73X3cMAwtX77cwoQAgFpcLgV4qKmpkSTFx8fLbrfL5XKprKxMKSkpcrlcWrhwISUDsMi7777rnsXIzc1Vbm6u+5hpmu7LqQAA1qNkAB5iYmKUl5ensrIyORwO5efna86cOQoJCZEkr19qADStF154od67SgEAfA8lA/DQvn175eXlKTs7W71799aHH36otWvXSjp/KUanTp0sTggELqfTKcMwNH/+fA0cONBd/gEAvoeF34CHUaNGafjw4SopKdGUKVMUHx8v0zRlmqaioqI0Y8YMqyMCAWvQoEGSpB49elAwAMDHsfAbuIjS0lLt3btXVVVV6t27t6Kjo62OBASsDz74QH/4wx/UqlUrpaamqk2bNgoK8p6Q79Onj0XpAACeKBkAAL+QnJx80cXdbJYJAL6DNRkIeKmpqZd9LrfIBKzF+2IA4B8oGQh4O3fuvKxbX3KLTMBac+fOtToCAOAyUTIQ8BISEryeFxYWqry8XMHBwYqOjlZRUZGqq6sVFham2NhYi1ICGDFihNURAACXiTUZgIe9e/fqvvvu0913361JkyYpJCREVVVVeuGFF5SWlqYlS5YoJSXF6phAwHM6naqoqKgzfuGbBgAAa1AyAA+jR4/W/v37tXv3boWHh7vHS0tLlZKSoh49emj16tUWJgQCl8vl0vz587VixQoVFxfXOc7CbwDwHeyTAXjIyMiQJG3dutVrvPb5oUOHmjwTgPNeffVVLV68WEVFRe79ay78AAD4BtZkAB4SEhKUlZWlKVOmqEePHoqLi9Pp06e1f/9+GYbBpRiAhdasWSPDMNSlSxcdOHBAhmFo2LBh2rJli1q1aqXrr7/e6ogAgG8wkwF4mDx5sqTzl2Xs27dPH330kfbt2yeXyyVJ+vWvf21lPCCgZWVlSZIWLFjgHps3b54WLlyokydPasCAAVZFAwBcgJIBeLj99tu1bNkyXX/99bLb7TJNU3a7XSkpKVq+fLluu+02qyMCAaumpkaSFB8fL7vdLkkqKytTSkqKXC6XFi5caGU8AIAHLpcCLtCvXz+lpaXJ5XKpoKBADodDNht9HLBaTEyM8vLyVFZWJofDofz8fM2ZM0chISGSpNzcXIsTAgBq8ZsT0ACbzaaPP/5Y77zzjtVRAEhq3769JCk7O1u9e/eWaZpau3atVq1aJcMw1KlTJ2sDAgDcuIUtcBHJycmy2WzcFhPwAe+88462bdumkSNHqkWLFrr//vt16tQpSVJ0dLT+/ve/q1evXtaGBABIomQAF5WcnCzDMHTw4EGrowC4QGlpqfbu3auqqir17t1b0dHRVkcCAHyDy6UAAH5h9+7dXs8jIiI0YMAA3XLLLYqOjtabb75pUTIAwIUoGQAAvzBmzBg999xzqq6u9hrPy8vTgw8+qJkzZ1qUDABwIS6XAi5i586dkqS+fftanARA7eWLHTt21LPPPqvk5GStX79eTz75pAoLC7m0EQB8CCUDAOAXnnrqKb3++utyuVwKDg5Wr169tHv3bpmmqbCwME2dOlV333231TEBAOJyKcDL008/rSFDhmjZsmVe46+88oqGDBmiZ555xppgADRjxgytWLFC11xzjaqrq90Fo3///lq3bh0FAwB8CCUD8JCenq6cnBzdcsstXuNDhw5Vdna20tPTLUoGQDp/R6ny8nIZhiHTNGUYhsrKylRZWWl1NACAB0oG4OHrr7+WJMXFxXmNt2zZUpJ0+vTpJs8E4LypU6dq/Pjxys3NVWhoqG699VZJ0v79+zV8+HAtWrTI4oQAgFqUDMBDSEiIJGnHjh1e47ULwENDQ5s8E4Dz3n33XZmmqV69emnt2rV6/vnntWzZMrVu3VrV1dWaP3++1REBAN+gZAAeunXrJtM09dhjj+nFF19Uenq6XnzxRT322GMyDENdu3a1OiIQsIKDg/Xoo48qLS1NiYmJkqR+/fpp3bp1GjlypMXpAACeuLsU4CE9PV2TJk2SYRhe47XXfs+fP19Dhw61KB0Q2DIyMpScnNzg8c2bN+vmm29uukAAgAZRMoALLFq0SAsXLlRNTY17LCgoSBMnTtSvfvUrC5MBkKSioiLt2bNHhYWFGj58uNVxAAD1oGQA9cjOztbWrVvldDoVGxurm266SQkJCVbHAgLe0qVLNW/ePFVWVsowDB04cEBjx47ViRMn9MQTT2jgwIFWRwQASAqyOgDgi9q0aaPRo0dbHQOAh/fff1/PPvtsnfEhQ4boj3/8o9577z1KBgD4CBZ+Ax7YjA/wXcuWLZNhGBo2bJjXeO06jM8//7zpQwEA6kXJADywGR/guw4dOiRJmjNnjtd4fHy8JPaxAQBfQskAPLAZH+C7au/6Fhwc7DV+/PhxK+IAAC6CkgF4YDM+wHclJSVJkpYsWeIe27dvnx5//HFJUseOHS3JBQCoi5IBeGAzPsB33XnnnTJNU3/729/csxp33XWX9u7dK8MwdOedd1qcEABQi7tLAR7uuecebd++XcXFxfrrX//qHq/djO+ee+6xMB0Q2H7xi19o3759WrNmTZ1jI0eO5I5wAOBD2CcDuACb8QG+7dNPP9WWLVvc+9gMHDhQKSkpVscCAHigZAD1YDM+wL+lpqbKMAwtX77c6igAEJAoGcAFMjMz9eGHHyonJ0dVVVVexwzD0FNPPWVRMgCXKzk5WYZh6ODBg1ZHAYCAxJoMwMP69ev129/+Vi6Xq8FzKBkAAAAXR8kAPMyfP99rLQYAAAC+PUoG4CE3N1eGYWj27Nm644473PtmAAAA4PKxTwbgoXYfjNtuu42CAQAA8B1RMgAPM2bMUGhoqJ577jmVlZVZHQcAAMAvcXcpBLwhQ4Z4PXc6naqoqJDdbleLFi0UFPSfqwoNw1B6enpTRwTwLQ0ePFiGYWjjxo1WRwGAgETJQMBLTk6+7HO5JSYAAMClsfAbAa9Pnz5WRwBwmbZt26a0tDRlZmaqoqLC6xgzjQDgO5jJAAD4hU2bNmnixIkyTVOe/3QZhiHTNJlpBAAfwsJvAIBfWLp0qVwul0JDQyWdLxcxMTEyTVNRUVFKSEiwOCEAoBYlAwDgFzIyMmQYhl577TX32Pbt2/Wb3/xGdrtdCxYssDAdAMATJQMA4BfOnj0r6fzNGgzDkCSdO3dO99xzjwoKCvTkk09aGQ8A4IGF3wAAvxAZGanCwkJVV1crKipKxcXFevPNNxUWFiZJrMcAAB9CyQAA+IWEhAQVFhbqzJkzSk5O1s6dOzV79mxJ59dnxMXFWZwQAFCLy6UAAH7hxhtvVOvWrfXll1/q/vvvl91ud99pyjRNjR8/3uqIAIBvcAtbAIBf2rdvnzZu3KiqqirdfPPN6tevn9WRAADfoGQAAPzC22+/LUkaPnx4nWMnTpyQJF199dVNmAgA0BBKBgDALyQnJ8tms+nAgQPf6hgAoOmxJgMA4Dfqe1+ssrKywWMAAGtwdykAgM9KT0/Xxo0bvcamT5/u9fz48eOSpPDw8CbLBQC4OEoGAMBnZWRkuNdiSOdnKzyfe+rWrVvThAIAXBIlAwDg02ovg6rd5fvCy6Kio6PVvXt3/f73v2/ybACA+rHwGwDgF5KTk2UYBjt7A4AfYCYDAOAX5s6da3UEAMBlYiYDAOB3nE6nKioq6ownJCRYkAYAcCFmMgAAfsE0Tc2bN08rVqxQcXFxneOGYbBPBgD4CEoGAMAvLF++XIsXL7Y6BgDgMrAZHwDAL6xZs0aGYahr166Szs9c/PCHP1RoaKgSExM1fPhwawMCANwoGQAAv5CVlSVJWrBggXts3rx5WrhwoU6ePKkBAwZYFQ0AcAFKBgDAL9TU1EiS4uPjZbfbJUllZWVKSUmRy+XSwoULrYwHAPDAmgwAgF+IiYlRXl6eysrK5HA4lJ+frzlz5igkJESSlJuba3FCAEAtZjIAAH6hffv2kqTs7Gz17t1bpmlq7dq1WrVqlQzDUKdOnawNCABwYyYDAOAXRo0apbZt26qkpERTpkzRvn37dOrUKUlSdHS0ZsyYYXFCAEAtNuMDAPil0tJS7d27V1VVVerdu7eio6OtjgQA+AYlAwAAAECj4nIpAIDPSk1NvexzDcPQ8uXLv8c0AIDLRckAAPisnTt3yjCMS55nmuZlnQcAaBqUDACAz0pISPB6XlhYqPLycgUHBys6OlpFRUWqrq5WWFiYYmNjLUoJALgQazIAAH5h7969uu+++3T33Xdr0qRJCgkJUVVVlV544QWlpaVpyZIlSklJsTomAECUDACAnxg9erT279+v3bt3Kzw83D1eWlqqlJQU9ejRQ6tXr7YwIQCgFpvxAQD8QkZGhiRp69atXuO1zw8dOtTkmQAA9WNNBgDALyQkJCgrK0tTpkxRjx49FBcXp9OnT2v//v0yDKPO+g0AgHW4XAoA4BfWr1+v3/zmN3XuJFX7/C9/+Ytuu+02CxMCAGpRMgAAfmPHjh2aN2+e9u7dq3PnzikoKEi9evXS5MmT1bdvX6vjAQC+QckAAPgdl8ulgoICORwO2WwsLwQAX8NPZgCA37HZbPr444/1zjvvWB0FAFAPZjIAAH4pOTlZNptNBw4csDoKAOACzGQAAPwW75MBgG+iZAAAAABoVJQMAAAAAI2KzfgAAH7p1VdftToCAKABLPwGAAAA0Ki4XAoA4BeefvppDRkyRMuWLfMaf+WVVzRkyBA988wz1gQDANRByQAA+IX09HTl5OTolltu8RofOnSosrOzlZ6eblEyAMCFKBkAAL/w9ddfS5Li4uK8xlu2bClJOn36dJNnAgDUj5IBAPALISEhkqQdO3Z4je/cuVOSFBoa2uSZAAD14+5SAAC/0K1bN23fvl2PPfaYxo0bp6SkJB09elQvv/yyDMNQ165drY4IAPgGd5cCAPiF9PR0TZo0SYZheI2bpinDMDR//nwNHTrUonQAAE9cLgUA8AtDhw7V5MmTZbPZZJqm+yMoKEiTJ0+mYACAD2EmAwDgV7Kzs7V161Y5nU7FxsbqpptuUkJCgtWxAAAeKBkAAAAAGhWXSwEA/AKb8QGA/6BkAAD8ApvxAYD/oGQAAPwCm/EBgP+gZAAA/AKb8QGA/2AzPgCAX2AzPgDwH9xdCgDgF9iMDwD8B5dLAQD8ApvxAYD/YCYDAOBX2IwPAHwfJQMA4DcyMzP14YcfKicnR1VVVV7HDMPQU089ZVEyAIAnSgYAwC+sX79ev/3tb+VyuRo85+DBg02YCADQEO4uBQDwC/Pnz1dNTY3VMQAAl4GSAQDwC7m5uTIMQ7Nnz9Ydd9zh3jcDAOB7uLsUAMAv1O6Dcdttt1EwAMDHUTIAAH5hxowZCg0N1XPPPaeysjKr4wAALoKF3wAAnzVkyBCv506nUxUVFbLb7WrRooWCgv5z1a9hGEpPT2/qiACAerAmAwDgs7Kzs+sdP3funE6fPu01duFO4AAA61AyAAA+q0+fPlZHAAB8B1wuBQAAAKBRsfAbAAAAQKOiZAAAAABoVJQMAAAAAI2KkgEAAACgUVEyAAAAADQqbmELoMm99dZbmj59uvt5s2bNFB0drc6dO+sHP/iBRo4cqYiIiG/9up999pm2bt2qMWPGKCoqqjEjfydpaWkKCwvTyJEjrY4CAECTomQAsMzkyZPVtm1bnTt3Tnl5edq5c6eeeuopLVu2TIsWLVJycvK3er09e/ZowYIFGjFihE+UjJUrV8rhcFAyAAABh5IBwDKDBg1Sjx493M8ffPBBbdu2TQ899JAmTJig9evXKzQ01MKEAADgu2BNBgCf0r9/f02YMEHZ2dl65513JEkZGRmaNm2ahgwZoh49emjAgAGaPn26CgoK3J83f/58Pfvss5KkIUOGqHPnzurcubNOnjwpSfrHP/6h1NRU9e/fX927d9ftt9+uFStW1Pn6+/fv17hx49SvXz/17NlTgwcP9rq0S5JcLpeWLVumH//4x+rRo4duvPFGzZo1S0VFRe5zBg8erMOHD2vnzp3uLPfee2+j//cCAMAXMZMBwOfccccd+stf/qJPPvlEo0eP1r///W+dOHFCI0eO1FVXXaXDhw9r1apV+uqrr7Rq1SoZhqFhw4bp2LFjevfddzV9+nQ5HA5JUmxsrKTzly517NhRgwcPVlBQkDZt2qTZs2fLNE3dfffdkqT8/HyNGzdODodDDzzwgKKionTy5El99NFHXvlmzZqlNWvWaOTIkbr33nt18uRJpaWl6cCBA1q5cqWCg4M1Y8YMzZkzR82bN9dDDz0kSWrZsmUT/lcEAMA6lAwAPic+Pl6RkZE6ceKEJOn//b//p/vvv9/rnF69eunRRx/Vp59+qpSUFCUnJ6tr16569913NXToULVt29br/Ndff93r0qt77rlH48aN0yuvvOIuGXv27FFRUZFefvllr8u4HnnkEffj3bt3a/Xq1frTn/6kn/70p+7xfv366Ze//KU2bNign/70pxo6dKief/55ORwO3XHHHY33HwcAAD/A5VIAfFLz5s1VVlYmSV7loLKyUk6nU9dee60k6Ysvvris1/N8jZKSEjmdTvXt21cnTpxQSUmJJCkyMlKStHnzZlVXV9f7Ohs2bFBkZKQGDBggp9Pp/ujWrZuaN2+uHTt2fPu/LAAAVxhmMgD4pPLycrVo0UKSVFhYqAULFmj9+vXKz8/3Oq+2IFzKp59+qvnz5+vzzz/X2bNn67xGZGSk+vbtqx/96EdasGCBli1bpr59+2ro0KH66U9/qmbNmkmSsrKyVFJSov79+9f7dS7MBwBAIKJkAPA5p06dUklJiRITEyVJU6ZM0Z49ezRu3Dh16dJFzZs3l8vl0i9/+UuZpnnJ1zt+/LjGjh2rpKQkTZs2Ta1bt1ZwcLD+9a9/admyZXK5XJIkwzA0b948ff7559q0aZM+/vhjzZgxQ6+88or+7//+T+Hh4XK5XGrRooX+9Kc/1fu1ateAAAAQyCgZAHzO2rVrJUk33XSTioqKtG3bNj388MOaNGmS+5xjx47V+TzDMOp9vX/+85+qqqrS4sWLlZCQ4B5v6NKmXr16qVevXnrkkUe0bt06TZ06VevXr9eoUaOUmJiobdu2qXfv3pe8vW5DeQAAuNKxJgOAT9m2bZsWLVqktm3b6n//939lt9vrPW/58uV1xsLCwiTVvYSq9jU8Zz1KSkr0j3/8w+u8oqKiOjMjXbp0kSRVVVVJkm677TbV1NRo0aJFdb7+uXPnVFxc7JXH8zkAAIGCmQwAltmyZYuOHj2qmpoa5eXlaceOHdq6dasSEhK0ePFihYSEKCQkRH369NGSJUtUXV2tuLg4bd261b3/hadu3bpJkv7617/q9ttvV3BwsG655RYNGDBAwcHBeuihh/Tzn/9cZWVlWr16tVq0aKEzZ864P3/NmjVauXKlhg4dqsTERJWVlWnVqlWKiIjQoEGDJEl9+/bVXXfdpb///e86ePCg+7WPHTumDRs26PHHH9ett97qzrNy5UotWrRI7dq1U2xsbINrOQAAuJIY5uVc0AwAjeitt97y2uAuODhYMTEx6tSpk26++WaNHDlSERER7uOnT5/WnDlztGPHDpmmqQEDBujxxx/XwIEDNWnSJD388MPucxctWqQ33nhDZ86ckcvl0saNG9W2bVv985//1PPPP69jx46pZcuW+sUvfqHY2FjNmDHDfc6BAwf08ssv67PPPlNeXp4iIyPVs2dPTZo0Sd27d/f6O6xatUpvvPGGjhw5IrvdrjZt2mjQoEEaM2aMWrVqJUnKy8vT448/rl27dqmsrEx9+/bVa6+99j3/1wUAwHqUDAAAAACNijUZAAAAABoVJQMAAABAo6JkAAAAAGhUlAwAAAAAjYqSAQAAAKBRUTIAAAAANCpKBgAAAIBGRckAAAAA0KgoGQAAAAAaFSUDAAAAQKOiZAAAAABoVJQMAAAAAI3q/wPZnJ5jfII+gAAAAABJRU5ErkJggg==\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAAxkAAALnCAYAAADlDIoiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAClPElEQVR4nOzdd3hUVf7H8fednsxMSAFCSaErim13LbBWrCv2wuK6uq6KimLXtdddxbaKXbHh6irurg1QF9byEwsWEAuiUpMQUkglM5NpmZnfH4GRSAIpk8wQPq/n4cnN3HPu/d6EgXxyzj3XiMViMURERERERBLElOwCRERERESkd1HIEBERERGRhFLIEBERERGRhFLIEBERERGRhFLIEBERERGRhFLIEBERERGRhFLIEBERERGRhFLIEBERERGRhFLIEBERERGRhLIku4DeKBaLEY3qQeq9hclk6PspkqL0/uxdTCYDwzCSXYaIJIBCRjeIRmPU1vqSXYYkgMViIivLSUNDI01N0WSXIyKb0fuz98nOdmI2K2SI9AaaLiUiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgmlG79FRERkuxeJRAiHw8kuQ6TXslgsmM3mdq8Ap5AhIiIi261YLEZ5eTn19fXEtJqxSLeyWCzk5vanT58+2wwbChkiIiKy3SovL6eurh63OxO73Q5oCVyR7hCJRPD7faxbt47GxkYGDRq01fYKGSIiIrJdikQi1Nc3Bwy3u0+yyxHp9dLS0vF4rNTXbyA3Nxez2dxmW934LSIiItulcDhMLMbGEQwR6Ql2exqxWGyb90ApZIiIiMh2TlOkRFKNQoaIiIiIiCSUQoaIiIiIiCSUbvwWERERSbLbb7+Ft9+eA0B+fgGvvPIaJlPz74Jfe+0/3HPPnQDceOOtHHPMcZ0+9meffZXAqrdtypTJLFmyOP65YRikpaWRl5fPIYccyhln/AmLxdqjNUnP0EiGiIiISApZu7aE9977X7LL6BaxWIzGxkaWL/+JJ598jOnT/57skqSbKGSIiIiIpJiZM58hlqCnC95882189tlXPT6K8UuvvTaXhQsX8+CDj8Uf5DZ//ryk1iTdR9OlRERERFKI2Wxm1aqVfPTRhxx44MFttnvssYf54ovPqKgox+PxkpbmYOTInfjDH/7IAQccFG/3y+lS7733P2644RoA7rnnAQ488Oe2J510LGVl69hllzE8++w/ACgpKeG5557iyy8/p76+nqysLMaN25/zzruQnJycDl2bYRjsu+9+ZGZmUVdXSygUjO/zeDzce+9d/PTTD9TUVOP3B+jTpw977LEnkydfwLBhw/nyy8+5+OIpAFx77Y2ccMJJ8f6nnz6RVatWMnz4CP75z38BUFNTzTPPPMWnn35MdXUVLpeLvffel/POm0J+fkG877vvzuell16ktLSEQCBAVlY2o0btxOmnn8Gee/6qQ9cozTSSISIiIr1KLBYjGo0k5U8iRh8OPfRwoHk0Y2vmz/8vP/74A/X19UQiTXi9XpYsWcxf/nIFn3/+WZv99t//QFwuFwDvvTc//vqyZd9TVrYOgKOPngDAypUr+POf/8g777xFdXU1TU1NVFVV8eabr3POOWdSV1fXoWuLxWIsWvQFGzbUA7QIUR6Ph/nz36G4uAiv10sk0kRtbQ0ffPAeF1xwLrW1tey9974UFg4BYO7cN+N9S0pKWLVq5cbajwGgqqqKs876I6+99m8qKsppamqivr6e//1vHueccyYlJcUAfPfdN9x003UsW7aUhoYGQqEQlZUVfPTRh3z//dIOXZ/8TCMZIiKS8pqamvD5vHi9Hrze5o+NjT6yszPYbbdfJ7s8SSGxWIxVq36ksdGXlPOnp7sYPnyn+HSgzpg4cRKffPIxy5Z9z+efL2yz3aWXXsHw4SPp27cvVquVlStXMGXKuQQCAV599V/su+9+rfaz2+2MH384s2e/zscff0QoFMJms8XvA7FYLBx22BEATJ/+d3w+LwMGDOSee+5nyJChfPvt11x66VQqKsp58cWZXHzx5e26rpNOOqbF54MGDebyy6+Of56R4WbatHvZddcxZGZmEYlEmD//v0yb9lcaGjYwf/47TJp0OiefPJH777+HpUu/Y82a1QwdOoz332+u3Wy2cNRRRwMwY8bjVFWtx+Vyce+9D7DrrruxZs1qLr54Cg0NG3jiiUe58857+Pbbb4nFYqSnO3nhhZfp168/69dX8tVXi+nfv3+7rk22pJAhIiJJEYlEtggOmz76fM3b9fV1+Hw+wuFQm8fxePz06ZPV5n63O4O8vPzuuARJWdv3w/lcLjcnn3wq//jHc8yc+QyHH35Uq+3sdjt33/03VqxYjsfjaTGKUlxctNVzHH30BGbPfh2fz8tnn33KgQcezPvvvwvA2LG/JTMzi0DAH18ZqqKinDPPPG2L4yxa9GUnrxLKytZxww3X8NhjM4Dm6y4vL+e5555h7dpi/H5/i/bFxc0jDxMmHMMTTzxCY2Mjc+a8ySWXXM77778HwH777UdOTl8AFi78GACv18uUKZPbrH3gwIEA+P2NPPPMU4wePZrhw0dy5JG/09Pku0AhQ0REEiYSidDY6IsHBp/Pi8fzc2hoft2Dz+elsbGxQ8eORqMEg0GCwSCBQIBgMEhDQwOzZ8/e6hQVs9nMu+9+TFZW20FEeg/DMBg+fCdisWiSzm/q0ijGJqed9kf+9a+XWbLkK/r3z91i//ffL+Uvf7mCpqamVvsHg8FWX99kjz32YuDAQZSXl/Hee/+jb99+lJeXAfC73zWPODQ0eIhEIls9TkNDQ3suB2i+8XvQoEGsW1fK1VdfzurVq/jqq0UsXfodY8bsxssvv8hDD93fZv9N1+R0ujjyyKN5/fX/8M47b3H88SeyfPmPABx99LHx9nV19duofQMABx88nmOPPZ63336Lt9+eE79/xe12c+utf+O3vz2g3dcoP1PIEBGRrYpGoxuDgzceELYMDl58Pg+NjY0dmpNuMplwOp04nW5cLhculxuXy43T6cLtdtPY6CcWi+JwOLDZ7C1+eKusLOeJJx7hgQceJjd3YJvncLszFDB2MIZhYBjmZJfRJVlZWRx//Im88srLvPvu/C32L1jwQTxgXHXVtRx33AnYbDaOPHJ8/H6HrTEMg6OOOprnnnuajz5aQEZGH6D5B+v992/+oTojIwOz2UwkEmG//cYyffqjWxynM/egDB6cx9ix41i9ehXQPKIxZsxu8ZEUu93OY489xc47j6aoaA2nnz5xi2OccspEXn/9P9TV1XLnnbdvrLdPixves7Iyqa6uprBwCK+88lqbtZtMJm644RYuvfQKli9fTklJMbNm/ZOiojU88MB9ChmdpJAhIrIDikaj+P2NLYJDy2lLP7/m8/k69IOEYRhbDQ5Opyv+elpaevyBYx3ldrtIT09nxIiR5OUVduoYIqns9NP/xGuv/YdwOLzFvlDo59fS09OJRCK88MLMdgWMTX73uwk899zTNDb6eO21/wDNN53bbDYAHA4He+31KxYt+pLPP/+MN954NT5164cfvmfu3Nnsu+9Yfve7CR26rnXrSlm48NP455umN4VCm6ZFGqSnp+P1enj66SdbPcbw4SPYa69fsWTJV3zzzdcAHH74EfHaoXna15w5b1JcXMRTTz3B73//B2w2KytWLOe//32b3NwBnHnmn1m8+Et++uknxo4dx847j2bkyFF88slHFBWtob6+Yze2y88UMkREeolYLIbf7/9FaGg7OESj7Z9OYhjN/+lvHhyaw8LmQaL5Y3q6s9PBQUR+1r9/fyZMOJY33tjyt/D7738AL7/8IgC3334zt99+M336ZOJ2u/F4PO06fkFBIbvuOobvv19KJNI8KrJpqtQml156JRdccC4+n5e77rqDu+66o8X+3/xmn3Zfzy9v/AYYMWIke+yx58ZrOpCffvqRYDDAaaedAkBeXl6bxzv55IksWfLzsz82nyoFMHnyFD77bCFVVet55pkZPPPMjBb7zznnPADKy8t56KH7W52qtd9+49p3cbIFhQwRkRQWi8UIBALbHG3YdP/DtuZP/1JaWvoWow1tBQezefuefiKyPTrjjLOYM2d2PARs8utf7811193ECy88R1VVFSNHjuKqq67l2muvanfIgObRjE3LtA4enBf/gX+TkSNH8dxzL/Lcc0+xaNEX1NbW0adPHwYPzmP//Q9g7NiO/xBusVjIzR3A2LG/5dxzz8Niaf5x9E9/Ohufz8u8ef8lGAyw337j+OMf/8TZZ5/R6nEOPvgQcnL6UlNTzdChw9h11zEt9vfv35+ZM1/k2Wef4pNPfn5OxsCBg9hvv3HxpW532WVXjj76GL777ltqaqqJRKL069ePgw46mLPPPq/D1yfNjFiiHicpcZFIlNra5CydJ4llsZjIynJSV+ejqSk5NxFK7xOLxQgGg9scbdgUHNq6sbMtDkdai5DQPPqwKTD8PArhdLri/7lvj0pLi7n55uu4/fZpmi7VS2RnOzGb2z8KFggEWLVqNX37DsBm0ypAO5r6+jpOOeV4vF4vl1xyBX/4wx+TXdIOIRQKUl1dwfDhw3A4HG22237/dxERSTEtg8PmAWJTcPj5/ofW5lhvjd1u3+Zow6bXt+fgICKyLevXr2fq1POpqlqP3+8nMzOT448/IdllyS/ofyIRka0IhULbnKa06fOfb1psH5vN1u7gYLVau+kKRUS2L01NTZSUFGOxWNhpp525+uprcTpdyS5LfkEhQ0R2OOFwuMXIwtaCw7bWmv8lq9X6i2lKP4eFn1dWag4Wm6+CIiIi7TNo0CA+++yrbTeUpFLIEJFeoampKR4cfD7Pxuc4bBkavF4PgUCgQ8e2WCytjja0FRwS8SAuERGR7ZlChoikrEgkgs/n2xgQfnmDdMvg4Pf7O3Rss9ncyk3RrQUHF3a7Q8FBRESkAxQyRKRHRaPRXwSH1kOD1+ulsbFjq7SZTKYtgkNb9zo4HGkKDiIiIt1EIUNEuiwajdLY2LjN0YZNwaHjT49u/Wbo1oKDHgInIiKSfAoZItKqaDSK3+/f5miD1+uhsbEzT492biU4bHrNTXp6uoKDiIjIdkYhQ2QH0vz0aP82Rxs2fd6R4AC0CA5tL8naHBz09GgREZHeSyFDZDvX/PTowC+WY/W2EhqatyORSIeOn5aWvs1pSk6nG6fTqeAgItJJt99+C2+/PQeARx+dwa9//ZseO/d++/0KgKOPPpabb76t3f0WL17EV18tAmDSpNNxu93xfU899QTPPDMDgNdem8ugQYMSUuMmJpOJPn36MGbM7pxzznnsvPPoLh1/ezN37mz+9rdbgZ7/+9JeChkiKSgWixEKhVo8v2FrS7I2NTV16PgOR1qrweHnlZV+/lxPjxYRkdZ89dWieJCYMOG4FiGju0WjUerq6vjoow9ZvPhLXnzxFQYNGtxj55dt008PIj1oW8Fh8/sfwuFwh45tt9u38SyHn4ODnh4tIiKbdMeD7SZPvoDJky9I+HEHDBjIG2+8xYYNG/jrX2/h448X0NjYyH//+zZnnz054efblkAggMPh6PHzHnPMcRxzzHE9ft6OUMgQ6aJwONzqPQ1b3uvgIRQKdejYNput3Q+BU3AQEen9QqEQL774PPPn/5eysnVYLFZ22mlnTj/9DPbf/8B4u2g0ytNPP8kbb7yG39/IuHH7c9ppf+Tcc/8EwDnnnBcPAa1Nl/rii8+ZOfMZVq9eic/nIzMzk+HDR3Diiadw0EGHcMIJE6ioKI+f76STjgF+DgFtTZeqra1l5sxn+PTTj6isrCQtLY1hw4Zz8cWXs+uuY9r9dejTpw/HH38iH3+8AIDKyooW+2tqqnnmmaf49NOPqa6uwuVysffe+3LeeVPIzy+It9uwoZ6///1ePv74Q+x2O8ceewKDBg3mrrv+Bvw8FWnx4kVcdNF5AFx11bUUFa3m3XfnE4lE+N//PgTgyy8/58UXn2fZsu8JBAIMHDiIo46awJln/gmLpfn/aL/fz4wZj7Ngwf9RXV2F1WolN3cAu+wyhiuv/AsOh6NdbdqaLuX1enj22af58MMPWL+++eu76667cdZZ57DHHnvGr3vT92+vvX7NpEl/YMaMxyktLaWgoIBLL72C3/xmn3Z/L9qikCGyFbW1taxdu4qKimoaGhq2GG3wej0Eg8EOHdNqtbY6TWlTWNg8SNjt9m66MhER2d40NTVx+eVTWbx4Ufy1UCjEkiWLWbJkMVdddQ2nnPJ7AJ599imeffapeLv33vsf3377dbvOU15extVXX9bi/7eqqiqqqqrIy8vnoIMO6VT9VVVVnHvun1oEgnA4zNdfL2HNmtUdChkAm6+GnpWV3eI8Z599BlVV6+Ov1dfX87//zePzzxfy9NPPU1BQCMB11/0lfl9JY2Mj//jHc/Tr12+r550x43EaGjYA4HK5gOZ7JO6447YWS7SXlBQzY8ZjfP/9t9x334MYhsFDDz3A66//J94mGAzi9a5k1aqVXHTRxTgcjna1aY3P5+W8885m9epV8dfC4TALF37CF198xrRp93HggQe16LN8+U9ce+1V8bpXrFjOX/5yBa+//hZ9+vTZ6tdhWxQyZIdWWroWj6eh1X0NDRt4553Z7Xqmg8ViacezHJr/2Gw2PQRORKQbxWKxDk85TRSr1dpt/8bPn//feMA46KBDuO66G6moqOCKKy6htraGRx99iCOPPBrDgJdeegGArKwsHnjgYfr1y+Wmm66jqqpqm+f54Ycf4gHjuedeZMSIkdTUVPPtt9/Er21roxVtmTHj8XjAOPzwI5k69VLS050sWbKYjIyMDn0tNmzYwOzZrwPNN4EffPD4FuepqlqPy+Xi3nsfYNddd2PNmtVcfPEUGho28MQTj3Lnnffw5ZefxwPGbrvtwbRp91BXV8fll0/d6rmDwSB33nkvY8eOo6xsHY2NjUyffh+xWIyxY3/LddfdSEZGH1555SUef/wRPvnkYz799GN++9sD4kHv0EMP58Ybb6WpqYm1a0v45JMFWK02gHa1ac2sWS/FA8Ypp0zk/PMv4qeffuDKKy8jGAxw3313sf/+B7RYFt7n83LOOedx2mmn889/vsBzzz1NY2MjCxd+wlFHHd2h78kvKWTIDquuro7jjjuyzWVaLRYL++yzDxaLhWAwGP8TCARafB4Oh3nnnQ/Izs5u9TgiItJzYrEYM2Y8SklJcVLOX1g4hMmTL+yWoLFw4Sfx7fPPv5DMzCwyM7M47rgTmDnzGfx+P19//RVut5vGxkageQrUzjvvAsCf/3xO/IfqrRk4cGB8e+bMZ9hzz70YNmw4v/3tATidzi7U/zHQ/Nv/G264Jf4b+QMPPLjdx6ioKG+x0lRGRh8uu+zKFqtLbTqP1+tlypQt79NYtOhLAL777tv4a3/+8zn07duPvn37ceyxJ/Dcc0+3WcPRR09g/PhDARg+fASff74Qr9e78dyfcNxxv2v1nL/97QEMGDCAVatW8u23X/Pcc08zdOgwdt55NJMnT4m3bU+b1mz6+2EymZgy5WKcTie/+c0+HHzwIcyb9w7r11eyevUqRowYGe+TnZ3DOeech8lk4ogjjopf9y+nn3WGQobssLKyspg9e16bIxkAlZXlPPHEI1xwwVRycwe22sbtzlDAEBFJIb11tLi+vj6+nZub2+p2fX0dgUAg/nn//rmtbm/N6NG7cNZZ5/Dyy//kww8/4MMPPwDAbndwxRVXc/zxJ3aq/rq65voHDBiYsJulm5rCBIOBFq9tOk9bNk112nxUp1+//vHt/v37b9FncyNGjPrF+eq2Weemc1588eVUVFSwatVK/vGP5+L7d9llVx588DHcbne72rRm09+P5mnYP4fB3NwBm7VpWevgwXnxkY3Np2h39B7S1ihkyA4tLy9/q/vdbhfp6emMGDGSvLzCHqpKREQ6yzAMJk++sFdOl8rMzIxvr1+/nqFDm+8HqKysjL/ep08WGRk//xBaXf3zD9Kbt9uWCy64iLPOOpvly5ezdm0Jb7zxKt999y33338vEyYci8Vi6fB1ZmVlUl1dTUVFOcFgsFP3HQ4YMJDXX5/LihXLueqqy1i/vpJ7772LkSNHMWbM7i3OU1g4hFdeeW2LY2yaBr35vRfV1VWMHNkcHrb1dfpl3VlZWfHtCy+8mDPP/HOb5xwyZCj//Oe/WLeulDVrVvPjjz/w3HNPs2zZ9/znP6/w5z+f2642rcnMzKS0dC1er5fGxkbS09M3Xs/PoxJ9+mS26NNymfrE/r01bbuJiIiIyPbDMAxsNltS/iQiYCxbtpSFCz9p8WfDhg3st9+4eJsZMx5nw4Z6li//iTlz3gTA4XCw5557MWLESNLTm3+T/c47zT+Qb1rVqT1WrlzBs88+RUlJCcOGDWP8+MMYOXInAILBQHwqltv9830Uq1ev3OZxx407AGiexnTnnbezfn0lPp+Xjz9ewJIli9tVGzR/f0eN2okrrrgaaF5J6+GHp8f3jx37WwCKi4t46qknaGhoIBDw891333DvvdN44YWZAC1WW3rhheepra1lxYrl8a9ne+222x7xG8BffvlFFi/+klAoRG1tLe++O58LLjiH8vLyjeeZyf/93/uYzWb23Xcshx56ODZb830Wm0YZ2tOmNZv+fkSjUR5//BG8Xg+LF38ZH4nq3z+X4cNHdOjaukIjGSIiIiIp5NFHH2rltRkceeTvmDv3TZYs+YoPPniPDz54r0WbCy+8JH4D9emnn8FTTz1BdXU1Z5wxCYC+ffvG224tDG3YsIEZMx5nxozHt9i3665j4ufYZZdd4q9fddVlABx55O+47bY7Wj3ueeddwOefL6SysoJ5895h3rx34vtuvPFW9trr123W1JqDDx7PLrvsyrJl3/PNN1/z+ecL2XffsUyePIXPPltIVdV6nnlmRvzm9E3OOad5Kdpf/3rv+PK0X321iKOPPgxo/9dpk/T0dC677EruuON26urquOii89ts++mnn7BkyZbfX4B99x3X7jatmTTpD/zvf/MoLi7i3/+exb//PSu+z2w2c+WVf2lx03d300iGiIiIyHbAYrEwffqjnHPOeRQWDsFqtZKens6ee+7FPffcz8SJk+Jt//znczn77MlkZWXjcDg46KBDuOaaG+L7MzLaXp40Pz+fE044iWHDhuNyubDZbAwcOIgTTjiJe+65P95ut932YMqUqeTmDmjXD699+/bjuedeZOLE0xg8OA+r1Yrb7WbPPfdi6NBhnfqanH/+hfHtJ59sDkX9+/dn5swXOfnkUxkwYCAWi4XMzExGj96FP//5XI4++ph4nzvvvIcjjjiKtLQ0MjMz+cMfzuDUU3/+OrZ31atjjjmehx56jP32G0tGRgZWq5UBAwYwbtz+XHfdTfGpWRMmHMu+++5Hv379sFqtZGT0Ybfdduevf53GuHG/bXeb1rhcbp56aiaTJp3OoEGDsVgsuN1u9ttvLI888kSnlx7uLCPWnvU5pUMikSi1tb5klyEJUFpazM03X8ftt0/TPRkiKUbvz94nO9uJ2dz+338GAgFWrVpN374DsNn0XKHNrVtXSjAYZNiw4UDzUqV33HE777//LgAvvvhKi1WGdlTLln1Pbm4uOTnNoxdlZeu47LKplJQUk5WVzdy58zCbzUmuMrWEQkGqqysYPnzYVm/g13QpERERkV5m2bLvuemm60hPd+JyuaitraGpqQmAk08+VQFjozlz3uD1118lMzMTs9lCbW0NsVgMk8nEFVdcrYDRBQoZIiIiIr3MkCFD2W+/cSxf/hM1NTWkpTkYMWIkxx57AhMmHJvs8lLGr3+9NytWLKekpBiPp57MzCx2330PTjvtj+y5517JLm+7ppAhIiIi0suMHDmK6dMfSXYZKe+ww47gsMOOSHYZvZJu/BYRERERkYRSyBARERERkYRSyBARERERkYRKuXsyKisreeCBB1iwYAEej4f8/HwmTpzImWee2a41mNesWcNjjz3GwoULqa+vJyMjg9GjR3PppZey++67t2j78ccf89xzz/Hdd9/h9/vJyclhr7324pZbbiEzM7ObrlBEREREpHdLqZBRU1PDpEmTKCsri7+2atUqpk2bxpo1a7jtttu22n/RokVMnjw5/rj7Tcf8+OOPOeqoo1qEjJkzZzJt2rQW/cvLyykvL+eyyy5TyBARERER6aSUmi718MMPxwPGHXfcwcKFCznkkOanE86aNYtvv/22zb6hUIirrrqKxsZGMjMzeeihh1i8eDGffvopjz76KKNGjYq3/fHHH7nnnnsAGD16NK+88grffPMN77//Prfffjtut7sbr1JEREREpHdLmZGMaDTK3LlzARg6dCinnHIKAOeffz4ffPABALNnz95iytMm8+fPp7y8HICrr76aI488EgCXy8Vhhx3Wou1LL71EJBLBMAweeughCgoKABg8eDC///3vE39xIiIiIiI7kJQJGWvXrsXj8QAwbNiw+Oubby9btqzN/l988UV8e8WKFRx++OFUVFRQUFDAueeey4knnhjf//nnnwOQk5PD008/zfvvv4/H42H33XfniiuuYK+9uv7wFYslpQaJpJNMJiP+Ud9TkdSi96f0Jrfffgtvvz0HAMMwsFqtuN0Z5OXlsf/+B3LiiSfjcnXfTIspUyazZMliBgwYyBtvvNXufpvX/dlnX3VXeVsoKyvjpJOOaVfb116by6BBg7q5IvmllAkZtbW18W2Xy9Xqdk1NTZv9N41iQPP9FpusXLmSa6+9lkAgwGmnnQZARUUFANXV1bzyyivxtl988QV/+tOfeOWVVxg9enSnr8VkMsjKcna6v6SOmho7AE6nXd9TkRSj96f0VrFYjFAoRE1NNTU11Xzzzde8+uq/eeCBhxk6dNi2DyCSAlImZLQlFovFtw3DaLNdJBKJb48ZM4YZM2ZQUVHB6aefjt/v55FHHmHSpEkYhtGi7aRJk7j66qt5++23uemmmwgGgzz55JNMnz690zVHozEaGhq33VBSns8XjH+sq/MluRoR2Zzen71PRkYaZrNGpR59dAZ77LEHxcXFPPfc07z77nwqKsq58spL+ec//0VaWlrCz/n44091qt/NN9/GzTdvfWGe7jBo0KAWIydz587mb3+7FYBzzjmPyZMv2Gr/cDiM2Wxu18ql0jkpEzKys7Pj25umTQH4fL5W2/zS5qtBHX/88eTk5JCTk8Pee+/NggULqK6uprq6mn79+pGZmUlVVRUAp512Gi6Xi4kTJ3LnnXfi9/v58ccfu3w9TU3RLh9Dki8ajcU/6nsqklr0/pTezGKxMnz4CP72t7uorKzgu+++paxsHXPmvMnEiZOA5h+UX3rpBebNe4d160oxm82MHr0LZ511DnvvvW+L43311WL++c/nWbp0KT6fl+zsHPbYY0/++tfmlTZbmy61dm0JTz75GN98s4T6+nqcTif5+QXsv/+B/OlPZwNtT5cqLi7imWdmsGjRlzQ0bCArK4t99x3Lueeez4ABA4GWU57OPnsyVquV119/Fa/Xy2677cY119zY5WlOm5/jz38+F8MwmDPnDaqrq5k///9wu938+OMynnvuGb75Zgler5d+/fpzyCGHcu6555Oenh4/ls/n5bnnnuHDDz+goqIch8PB7rvvyeTJF7Dzzp2fAdNbpUzIyM/PJyMjg4aGBtasWRN/ffXq1fHtXXbZpc3+o0eP5q23tj6H0OFwxNtuChlbayciIiLboxiQrBkF6UDbMy864/e//wPffde8wubChZ8wceIkIpEIV1xxCV9++XmLtosXL+KrrxZz++13cvjhzYvgvP32XP7611tazA5Zv76S//1vXjxktOaqqy6juLgo/nl9fT319fX4fL54yGjNihXLOf/8s1s8UqCqqoq5c2fzyScf8cwzL2wRHv71r5fxer3xzz///DNuueUGnnrqua18ZTrm1Vf/TUPDhhavff75Z1x11aWEw+H4a+XlZbz00gt89dUinnzyWex2O42NjZx33tmsWrUy3i4cDvPJJx/x5Zef89BDj7Pnnl2/p7c3SZkxIpPJxIQJE4DmB+q9+uqr1NbW8uSTT8bbHHfccQCMHz+enXbaiTPOOCO+76ijjsJiac5Mb775JjU1NXz//fd8+eWXQHOw2LQ07THH/Hyj0Msvv4zP5+Pf//43fr8fgH322acbr1RERES6Twy3+3CysnKT8sftPoLmkJM4BQWF8e3y8ual/ufP/288YFx99XX83/99wuzZ/2W33XYnFosxffrfiUQi+P1+7r//HmKxGBaLhZtvvp333lvA66/P5bzzLmzznBs21McDxqWXXsFHH33OW2/9jwcffIzf/W7CVuudPv2+eMC45Za/8t57C7j44ssBqKur44knHt2iTzAY5N57H2D+/P+Lj8J89903rF+/vp1fpW3zeBq45prree+9j5g161XS0hzce+80wuEwO+20M//+9xssWPAZt9zyVwB+/PEH5sx5A4BZs15i1aqVmM1m7r777yxY8Bn/+tcb5OXlEwqFePDBvyeszt4iZUYyAC6++GI+/PBDysrKuP7661vsmzRpUpvL10LzSMiUKVN4+OGHWbp0KePGjYvvs1qtXHPNNfHPjz32WN544w0+/fRTZs2axaxZs+L7cnNzmTx5cgKvSkRERHpWYkcSki0a/Xk64Kb7Uxcu/CT+2r33TuPee1uOSNTUVLNmzWpqaqrjIwQTJhzL0Uc3/6LV6XRx9tnntnlOl8uN0+nC5/Myf/5/8fsDDBs2jDFjdmPfffdrs18g4Ofrr5cAMHr0LvFA8oc//JFXXnmJ9esr+eyzT7fod+CBB3PAAQcBcPDB4+MBqrKynP79+7d5vo7Yd9/9OPHE5kckOJ1DKSkpprR0LQA//fQjp556whZ9Fi36klNO+T0LF34MNN8DfM01V27R7ocfluHzeXE6XVvs21GlVMjIyclh1qxZ3H///SxYsACPx0NBQQETJ07kzDPP3Gb/qVOnMnDgQF544QVWrVqFzWZjr732YurUqey5557xdiaTiccff5zHH3+cOXPmsH79evr06cOBBx7IZZddRr9+/brxKkVERKT7GHg88+lN06XWri2Jbw8c2DzNqK6ubpv9GhoaWrQbMmRou89pNpu58cZbuPfeu/jhh2X88EPzYwQMw+DYY0/g+utvauOcnvgCO/3758ZfNwyD/v37s359JQ0NG1oswgOQl5cf37bbbfHtUChMoowYMarF5+39GnakrULGz1IqZEDzSMLdd9+91Tbvv/9+m/tOPvlkTj755G2ex+FwcPnll3P55Zd3uEYRERFJZQbQe5Y1fuWVl+Lb48b9FoCsrKz4a2+9NZ+cnL4t+sRiMQzD4PPPF8Zf2/z+ivY45JBDOeigQ1i1aiUlJcV8/PEC3nnnLWbPfp0JE45ljz323KJPRoYbs9lMJBKhqurnqU6xWCw+9SkjIwOz2dyi36Yp7826ZyTKbre3+Hzzr+GJJ57MNdfcsEWfTfexZGVlUVq6lvT0dObP/wCLxbpFu62tgrojSrmQIZIolZXlBAKBLh8DoKxsHZFI51evcTgc5OYO7FItIiKy42hqClNcXMzMmc+wdOl3AAwenMcxxzTfnzp27Djmz/8vAHfddQdXXHE1ffv2o7R0LR9++AErV67gb3+7i9133xO3243H4+Gtt+awxx57ceCBB+P1enj77bn8+c9tT5m67767GT/+MIYMGcqQIUMJhUK8807zIjv19a3/Zt/hSGOPPfbiq68WsWzZ98yb9w77738gs2e/zvr1lQDst9+4Vvv2tIKCQvLy8igtLeXtt+ey775j2W+/sQSDIb777hveeOM1/vCHM/jVr37N2LG/5bvvvqWxsZF7772L8867EJfLRVHRGt57738EAgGuuOLqZF9SSlHIkF6psrKc667bcs5kZz3xxCNdPsa0aX9X0BARkW266KLztnht4MBB3HffdByO5mdkHHHE73jrrbksWvQFH330IR999GGL9nvt9WsA0tLSuPzyq/nrX28hHA5z220tpzltLWT85z+v8J//vLLF6y6XizFjdmuz36WXXsEFF5yD3+/nlltajg5kZmZywQUXtdm3p1199fVceeUlBINBrr32qi32n3baH4HmFb7ee+9/rFq1kjfffJ0333y9Rbujjz62R+rdnihkSK+0aQRj8uQLGTRocKePYzabMIwmYjFLp0cyysrW8dRTj3V5VEVERHYcVquVjIw+5OXlccABB3HCCSfhcrnj+81mMw888DAvv/wi8+a9Q2npWsxmC/3792evvX7FUUf9vALU0Ucfw4ABA/nnP5/nu+++o7HRR3Z2DrvvvsdWazjjjLP46qtFrFtXitfrpU+fTHbZZVfOPnvyFtOzNrfTTjvz7LMv8MwzM1i8eBENDQ1kZWWyzz7Nz8no6rMvEmnffffj6adnMnPms3zzzRI8Hg9ZWdkUFhZywAEHs/POOwPgdDqZMeNZZs58lg8//IDy8rKNsxQG8Jvf7MOECQoZv2TENl80WRIiEolSW6unzyZTcfEabrvtBm655Q4KC9t/o9svWSwmsrKc1NX5Ov2wr0TVIiItlZYWc/PN13H77dPIyyvcdgdJednZzg498TsQCLBq1Wr69h2AzWbfdgcR6bJQKEh1dQXDhw/b6rPlUuY5GSIiIiIi0jsoZIiIiIiISEIpZIiIiIiISEIpZIiIiIiISEIpZIiIiIiISEIpZIiIiMh2TgtliqQahQwRERHZLlmtVgwDgsFgsksR2WEEg34Mw8BqtW61nR7GJyIiItsls9lMZmYmdXX1ANjtdsBIak0ivVUkEsHv9xEI+MjKysJsNm+1vUKGiIiIbLcGDhwIQH19PR5PkosR6eUsFguDBw+mT58+227bA/WIiIiIdAvDMBg0aBC5ubmEw+FklyPSa1ksFsxmM4bRvtFChQwRERHZ7pnN5m1O3xCRnqMbv0VEREREJKEUMkREREREJKEUMkREREREJKEUMkREREREJKEUMkREREREJKEUMkREREREJKEUMkREREREJKEUMkREREREJKEUMkREREREJKEUMkREREREJKEUMkREREREJKEUMkS2wjBqgUiyyxARERHZrliSXYBId3G73YRCQbxeT6f6m0ylZGT8kfr6ffB47iHSyawRCgVxu92d6ywiIiKyHVLIkF4pEolw6qmnUlVVRlVVWReOdO/Gj192qZ5TTz2VSGdTioiIiMh2RiFDeiWz2cy///1vpk69nIEDB3f6OA7Hm6Sl3UcsZsfjeZZIpKDDxygvX8cjjzzAFVdc2+k6RERERLYnChnSa3k8Hmw2Oy5X56cqWSxnkJn5GvAuLtel1NfPA8wdOobNZsfj6dyULREREZHtkW78FtkqA3iGWCwDq/UL0tIeSXZBIiIiIilPIUNkmwpobLwLAKfzb5jNPya5HhEREZHUppAh0g6h0BkEg0dgGEHc7guApmSXJCIiIpKyFDJE2sXA632YaDQTq/Ur0tMfSHZBIiIiIilLIUOknaLRgXi99wCQnn4XZvN3Sa5IREREJDUpZIh0QDD4e4LBYzCMMG73FCCU7JJEREREUo5ChkiHGHg804lGs7FavyU9/d5tdxERERHZwShkiHRQLNYfr/d+ANLT78NiWZLkikRERERSi0KGSCcEgycRCJyEYUQ2rjYVTHZJIiIiIilDIUOkk7zevxON9sNi+QGnc1qyyxERERFJGZZkFyDSnYqLi7rU32w2UVzcRCxmIRKJbrG/vv56Roy4nLS06RQX74XPt/sWbcrK1nWpBhEREZHtjUKG9EqRSASAmTOf6vZzXXHFYA45ZB1u9wXceOOBhELmVts5HI5ur0VEREQkFShkSK80bNgIbrzxdszm1n/gb6/KynKeeOIRLrhgKrm5A1ttYzY3EAqdRF5eFY8+2pfS0qu2aONwONrsLyIiItLbKGRIrzVs2IguH8Nsbr5tadCgweTlFbbZzu9/DJvtVHJzX8ThOJ1weFyXzy0iIiKyvdKN3yIJEAodid9/BoYR2/iQPl+ySxIRERFJGoUMkQTx+e4kEsnDbF6Dy3VLsssRERERSRqFDJEEicX64PE8AkBa2gys1g+TXJGIiIhIcihkiCRQODwev/8cANzuizCMhiRXJCIiItLzFDJEEszr/SuRSCFmcwlO503JLkdERESkxylkiCScC4/nMQDS0p7Dan03yfWIiIiI9CyFDJFuEA4fQGPjBQC43VMxjPrkFiQiIiLSgxQyRLqJz3crTU3DMZvLcLmuTXY5IiIiIj1GIUOk26Tj8TxBLGbgcLyEzfZOsgsSERER6REKGSJbEYvFutS/qWlf/P6LAXC5LsEwahJRloiIiEhKsyS7AJFkKi1di8fT+jKzsViMaDTAMcccw8qVK/B4vK22c7szyMvLb/McPt+N2GzzsFh+wuW6Go/n2YTULiIiIpKqFDJkh1VXV8dxxx1JNBptdX9mZib3338/O++8M0uXLuWaa64kGAxu0c5sNvPuux+TlZXVxpkceDxPkJl5GA7HfwgGjycUOj6BVyIiIiKSWhQyZIeVlZXF7Nnz2hzJADCZYkQiIcaMGcNzz80ErBiG0aKN252xlYDRrKnp1zQ2Xo7TeR9u9+XU1v6WWKxvAq5CREREJPUoZMgObWvTnAAsFhMmUxPffvsd0WiEtDQrBQUjMJvNHT5XY+M12O3vYLF8j9t9OQ0N/wCMbfYTERER2d7oxm+RbejTpw/Dho3EZDLj9/soKVlJJBLpxJHsG1ebsmC3v4nd/p+E1yoiIiKSChQyRNohPd1FYeHPQaO4eAWRSFOHj9PUtAeNjVcD4HJdiclUkehSRURERJJOIUOkndLS0hkyZCRms5lAoJHi4hU0NXU8aDQ2XkU4vCcmUz0u16VA15bJFREREUk1ChkiHeBwpFNYOAqz2UIg4N8YNMIdPIp147QpG3b7O9jtL3VLrSIiIiLJopAh0kEOR9rGEQ0LwWDngkYksgs+3/UAuFzXYjKt645SRURERJJCIUOkE+z2NIYMGYXFYiUYDFBUtJxwuGNBw++/hHD415hMG3C7p6JpUyIiItJbKGSIdJLd7qCwcCQWi5VQKEhx8XLC4VAHjmDB43mSWMyBzfYeDsfz3VariIiISE9SyBDpArvdwZAho7BabYRCQYqKVnQoaEQio/D5bgbA6bwek6mku0oVERER6TEKGSJdZLPZKSwcidVqIxwOUlS0nFAo2O7+fv8UwuH9MJm8uN0XAdHuK1ZERESkByhkiCSAzWbfOKJhJxwOUVy8ogNBw0xDw+PEYunYbB/icDzdrbWKiIiIdDeFDJEEsVptDBkyEputOWgUFS0nGAy0q280Ohyv9zYAXK6bMZlWdWepIiIiIt1KIUMkgaxWG4WFo7DZHDQ1hSkuXtHuoBEITCYUOhDDaCQj40I0bUpERES2VwoZIglmtVoZMmQkdntz0Gge0fC3o6cJj+dRolEXVutC0tIe6/ZaRURERLqDQoZIN7BYrBQWjsRuTyMSaaKoaAWBwLaDRjRaiM93BwBO5+2YzSu6u1QRERGRhFPIEOkmm4KGw9EcNIqLlxMING6zXyBwFqHQeAwjgNt9PhDp/mJFREREEkghQ6QbWSyWjUEjnUgkQlHRCvz+bQUNA4/nEaLRDKzWRaSlPdQjtYqIiIgkikKGSDczm5uDRlqak2g0QnHxCvx+31b7RKN5eL13A+B03oHZvKwnShURERFJCIUMkR5gNpspKBjRImg0Nnq32icY/APB4FEYRgi3+wIg3DPFioiIiHSRQoZIDzGbzRQWjiA93UU0GqWkZCU+39aChoHX+xDRaCZW69ekp9/fY7WKiIiIdIVChkgPMpnMFBQMJz3dvVnQ8LTZPhodgNd7HwDp6XdjNn/bU6WKiIiIdJpChkgP2xQ0nE43sVhz0PB6G9psHwyeSjB4HIbRREbGBUCo54oVERER6QSFDJEkMJlM5OcPx+XKIBaLsXbtqq0EDQOP5wGi0RwslqWkp9/do7WKiIiIdJRChkiSmEwm8vKG4XL1iQcNj2dDq21jsX54PA8AkJ5+PxbL4p4sVURERKRDFDJEkqh5RGMobvemoLEaj6e+1bah0AkEAidjGJGNq00FerRWERERkfZKuZBRWVnJtddey7hx49htt904+uijmTlzJtFotF3916xZw9VXX83+++/PmDFjGDduHOeccw7fftv6DbMrV65kzJgx7LTTTuy00068/PLLibwckW0yjOYRjYyMTKA5aDQ01LXa1uu9j2i0PxbLTzidd/ZonSIiIiLtlVIho6amhkmTJvH6669TU1NDKBRi1apVTJs2jdtuu22b/RctWsRJJ53E7NmzqaqqIhwOU1NTw8cff8xPP/3Uap/bbruNcFjPH5DkMgyDwYOHkpGRBUBp6Ro2bNgyaMRiOXg8zU8AT0t7CIvl8x6tU0RERKQ9UipkPPzww5SVlQFwxx13sHDhQg455BAAZs2a1eZoBEAoFOKqq66isbGRzMxMHnroIRYvXsynn37Ko48+yqhRo7boM3v2bL744gvS09O754JEOqA5aAyhT59sANatW8OGDbVbtAuFjiYQOA3DiG6cNtXYw5WKiIiIbF3KhIxoNMrcuXMBGDp0KKeccgrZ2dmcf/758TazZ89us//8+fMpLy8H4Oqrr+bII4/E5XKRk5PDYYcdxh577NGivdfr5Z577sHhcHD22Wd3wxWJdJxhGAwaVEhmZg4A69YVUV9fs0U7r/duIpFBWCyrcDq3PconIiIi0pMsyS5gk7Vr1+LxND+UbNiwYfHXN99etmxZm/2/+OKL+PaKFSs4/PDDqaiooKCggHPPPZcTTzyxRfvp06dTVVXFpZdeyoABAxJ1GXEWS8rkN+kCs9nU4mNPyc8fgslkUFtbTVlZMSaTQXZ2381aZNPY+Chu94mkpz9OJHIcTU0H9GiNIslmMhnxj/o3V0QktaRMyKit/XlaiMvlanW7pmbL3+husmkUA2DmzJnx7ZUrV3LttdcSCAQ47bTTAPjxxx956aWXGDJkCOeee258BCVRTCaDrCxnQo8pyZWRkdbj58zK2oWVK1dSVlZGaWkRaWlWBg0atFmLE4Bzgadxuy8EvgVcrR1KpFeqqbED4HTa9W+uiEiKSZmQ0ZZYLBbfNgyjzXaRSCS+PWbMGGbMmEFFRQWnn346fr+fRx55hEmTJgFw6623EolEuOmmm7DZbAmvORqN0dCgefK9gdlsIiMjjYYGP5FI+1Y4S6ScnIGEQk1UV69nxYoV+HxB+vbtv1mL28nImIfZvIZA4HL8/uk9XqNIsvh8wfjHujpfkquRRMjISOvxkWMR6R4pEzKys7Pj25umTQH4fL5W2/xSZmZmfPv4448nJyeHnJwc9t57bxYsWEB1dTXV1dWsWLGCJUuWsOeee5KTk8MPP/wQv9kcoKKigp9++omddtqpS9fT1NTzP5BK94lEokn7nvbrN5hYDGpq1lNWVkIkEiUnZ1PQcOHxPEpm5nE4HE8TCBxLOHxIUuoU6WnRaCz+Uf/mioiklpT5dUF+fj4ZGRlA87MuNlm9enV8e5dddmmz/+jRo7d5DofDQWNj8wjD119/zQknnMAJJ5zAww8/HG/zxBNPcPrpp3e4fpHuYhgG/fsPJicnF4DKylKqqyvj+8Phg/H7zwXA7Z6KYTQkpU4RERGRTVImZJhMJiZMmAA0h4xXX32V2tpannzyyXib4447DoDx48ez0047ccYZZ8T3HXXUUVgszQMzb775JjU1NXz//fd8+eWXQHMIcbvdPXU5IgnVHDQG0bdv8yIF69evo6qqIr7f672dSGQIZvNanM7rk1WmiIiICJBCIQPg4osvjt/Yev311zN27Fg++OADACZNmsTuu+/eZt/8/HymTJkCwNKlSxk3bhwnnXQSfr8fq9XKNddcA8Bhhx3GTz/91OLPtGnT4se59dZbWbRoUXddokinbQoa/foNBKCqqoyqqk0LHrjweJ4gFjNIS/sHNtu85BUqIiIiO7yUChk5OTnMmjWLE044gezsbKxWK8OHD+e6667jlltu2Wb/qVOncueddzJ69GhsNhsul4sDDjiAF198kbFjx/bAFYh0v379BtK/f3MYr6oqZ/36MmKxGOHwOPz+5qDtcl2CYWz5xHARERGRnmDENl++SRIiEolSW6uVTnoDi8VEVpaTujpfyt1YWl1dyfr16wDIycmlf/9BGEaArKzfYrGsJBCYhMczI8lVinSf0tJibr75Om6/fRp5eYXJLkcSIDvbqdWlRHoJvZNFtlN9++aSm5sHQE1NJZWV64jFHBunTZlwOGZhs72V5CpFRERkR6SQIbIdy8npz4AB+QDU1q6nsrKUcHhv/P5LAXC7L8Ew2n6IpYiIiEh3UMgQ2c5lZ/dj4MACAGprq6ioWIvXey1NTTtjMlXhcl2Z5ApFRERkR6OQIdILZGX1jQeNurpqysvX09DwBLGYGYfjNWy215NcoYiIiOxIFDJEeomsrL4MGtR882t9fQ1r1+bQ2Ng8iuF2X45hrE9meSIiIrIDUcgQ6UUyM3MYPHgI0Bw0Vq78PeHwbphMtbjdlwNaTE5ERES6n0KGSC/Tp082eXlDAaiv97Bq1U3EYlbs9jnY7f9KcnUiIiKyI1DIEOmFMjKy4kGjsrI/5eXnAeByXY3JVL61riIiIiJdppAh0ktlZGSRnz8MMFix4kR8vtGYTPW4XJegaVMiIiLSnRQyRHoxtzuT/PxhGIaVZcv+QjRqxW6fh93+z2SXJiIiIr2YQoZIL+d29yE/fzh+/zCKis4GwOW6FpOpNMmViYiISG+lkCGyA3C5MsjPH05p6e9paNgFk6kBl+siNG1KREREuoNChsgOwuXKoKBgJ3766XoiERt2+wfY7c8kuywRERHphRQyRHYgTqeb/v3HU1R03sbPbwBWJ7coERER6XUUMkR2MOnpLiyWa9mwYXfMZj92+9lEIuFklyUiIiK9iEKGyA4oPT0Dn+9JIhEHGRlfEQxOIxKJJLssERER6SUUMkR2UFbrrmzYcAsAeXkPU1HxHpFIU5KrEhERkd5AIUNkBxaJTCEQOACzOcjQobdSXPwjTU0KGiIiItI1ChkiOzQTPt/jRKMu+vRZSt++L1BcvIKmJt2jISIiIp2nkCGyg4tGC/D5pgEwdOgzmM0/KmiIiIhIlyhkiAiBwJkEg4djMoXYeee7CAa9FBUtJxxW0BAREZGOsyS7ABFJBQZe78NYrfvidv9AYeG/KS4+jeLi5RQWjsRqtSW7QOmFKivLCQQCXeoPUFa2jkgk2qVaHA4HubkDu3QMERH5mRGLxWLJLqK3iUSi1Nb6kl2GJIDFYiIry0ldnY+mpq79ELM9sNtfIiPjAmIxK9988ywbNuRjtdoZMkRBQxKrsrKc6667MtlltDBt2t8VNJIsO9uJ2axJFiK9gUYyRCQuGDyNYHA2dvvb7LLLPSxe/CihUJCiouYRDZvNnuwSpZfYNIIxefKFDBo0uFPHMJtNGEYTsZilSyMZZWXreOqpx7o0qiIiIi0pZIjIZgw8ngexWhdis33HmDFzWLr0JEKhIMXFKxQ0JOEGDRpMYeHQTvXd0UYaRUS2JxqTFJEWYrFcvN77AXC5HmDEiEZsNjvhcIiiouUEg/ptr4iIiGydQoaIbCEYPIlg8AQMo4msrIspLCzEZnPQ1BSmuHiFgoaIiIhslUKGiLTCwOO5n2i0LxbLMjIz/86QISOx25uDRvOIhj/ZRYqIiEiKUsgQkVbFYn3xeB4EIC3tARyObygsHIndnkYk0kRR0QoCAQUNERER2ZJChoi0KRQ6lkDgVAwjitt9ARZLE4WFI3E4moNGcfFyAoHGZJcpIiIiKUYhQ0S2yuu9l0hkABbLcpzOv2GxWDYGjXQikQhFRSvw+xU0RERE5GcKGSKyVbFYNl7vpmlTj2CxLMRsbg4aaWlOotEIxcUr8Pv1AEoRERFp1u6QsX79eo466iimT5++1XYPPPAAv/vd76ipqelqbSKSIkKh3xEInI5hxHC7pwA+zGYzBQUjWgSNxkZvsksVERGRFNDukPGPf/yDDRs2MHny5K22mzx5Mhs2bOCFF17ocnEikjq83ruIRAZjsazG6bwVALPZTGHhCNLTXUSjUUpKVuLzKWiIiIjs6NodMj788EMmTJiA0+ncajuXy8UxxxzD+++/3+XiRCR1xGJ98HgeASA9/Ums1gUAmExmCgqGk57u3ixoeJJZqoiIiCRZu0NGSUkJO+20U7vajhw5kpKSkk4XJSKpKRw+FL//bADc7oswjOYwsSloOJ1uYrHmoOH1NiSzVBEREUmidocMk8lEOBxuV9twOIxhGJ0uSkRSl8/3VyKRQszmYpzOm+Kvm0wm8vOH43JlEIvFWLt2lYKGiIjIDqrdIaOgoIDFixe3q+1XX31FQUFBp4sSkdQVi7nxeB4FIC3tWazW9+L7TCYTeXnDcLn6xIOGx7MhWaWKiIhIkrQ7ZBx++OHMmzePJUuWbLXd119/zX//+18OP/zwLhcnIqkpHD6QxsbzAXC7p2IYPweJ5hGNobjdmRuDxmo8nvokVSoiIiLJ0O6QcdZZZ5Gbm8vZZ5/NjBkzqKysbLG/srKSGTNmcPbZZ5Obm8tZZ52V6FpFJIX4fLfS1DQMs3kdTud1LfYZhom8vKFkZGQCzUGjoaEuKXWKiIhIz7O0t6HL5WLmzJlMnTqV+++/nwceeAC3243T6cTn8+HxeIjFYowaNYpHHnkEl8vVnXWLSNI58XieIDPzSNLSXiQUOpZQ6HfxvYZhMHjwUKCIhoY6SkvXMHgw9OmTlbySRUREpEe0O2QA5Ofn89prrzFv3jzee+891qxZg9frJS8vj6FDhzJ+/HiOPPJILJYOHVZEtlNNTfvh908lPf1hXK5LqKv7nFgsO76/OWgMwTAMNmyoZd26NUCMPn2y2z6oiIiIbPc6nAbMZjNHH300Rx99dHfUIyLbGZ/vRmy2eVgsy3G5/oLH83SL/YZhMGhQIYZhUF9fw7p1RcRiMTIzc5JUsYiIiHS3dt+TISLSujQ8nseJxUw4HP/CZpuzRQvDMBg4sIDMzL4AlJUVU1dX3dOFioiISA9p90jGmWee2eY+wzCw2+0MGjSIgw46iEMOOSQhxYnI9qGpaW/8/stJT/87bvel1NaOJRbr26JNc9DIxzCgrq6a8vISIEZWVr/kFC0iIiLdpt0ho7a2dqsP2PP7/Xz66ae88sor7L///jz22GNYrdaEFCkiqc/nuxab7R0slmW4XFfi8Ty/RRvDMBgwIB/DMKitraK8fC2xGGRnK2iIiIj0Ju0OGXPnzt1mm0AgwKxZs7jrrrt4+umnmTJlSpeKE5HtiX3jalPjcTheJxQ6jmDw5C1aGYZBbm4ehmFQU7Oeioq1xGIxcnL6J6FmERER6Q4JvSfD4XBw1llnMWHChHaFEhHpXZqa9qSx8SoAXK4rMIzKVtsZhkH//oPJyckFoLKylOrq1tuKiIjI9qdbbvz+1a9+RWlpaXccWkRSXGPj1YTDu2My1eF2XwrEWm3XHDQG0bfvAADWr19HVVVFD1YqIiIi3aVbQobf78dsNnfHoUUk5VnxeJ4kFrNit7+N3T6rzZabgka/fgMBqKoqo6qqvKcKFRERkW6S8JARi8V4//33GTVqVKIPLSLbiUhkVxobrwPA5foLJlPZVtv36zeQ/v0HAVBVVc769WXEYq2PgIiIiEjqa/eN3/X19VvdHwwGWb16NS+//DJLlizh3nvv7WptIrIda2y8DJvtLazWxbjdU9mw4VWg7RXq+vYdgGEYVFauo7q6glgsRv/+g7a6qp2IiIikpnaHjP32269d/9lbLBYuvfRSjjnmmC4VJiLbOwsezxNkZe2PzfYuDscLBAJtP28H2HgjuEFlZSk1NZXEYjFycwcraIiIiGxn2h0yLrrooq3+R2+z2Rg8eDBjx44lOzs7IcWJyPYtEtkJn+8mXK4bcTqvIxQ6mGi0YKt9cnL6YxgGFRVrqa1dD8TiS96KiIjI9qHdIePiiy/uzjpEpJfy+y/Cbp+L1frZxmlTb7Ct28Gys/thGAbl5SXU1lYRi8XiD/ETERGR1JfwG7/D4TDvvvsul1xySaIPLSLbJTMez2PEYmnYbP+Hw/Fsu3plZfVl4MDmUY+6umrKy0t0M7iIiMh2ot0jGdvyxRdfMGfOHObPn8+GDRtIS0tL1KFFZDsXiYzA57sVl+saXK6bCIUOJRodus1+WVl9MQyDsrJi6utrABg4sEAjGiIiIimuSyHjxx9/ZM6cObz11ltUVlbSt29fjjzySMaPH8/YsWMTVaOI9AJ+//nYbHOx2T7C7b6QDRveoj2DqZmZORiGwbp1RdTX1xCLxRg0qFBBQ0REJIV1OGSUlZUxd+5c5syZw8qVK8nOzmbfffflnXfe4aabbuKII47ojjpFZLtnwuN5lKyscdhsn5CW9jh+/0Xt6tmnTzaGYVBauoYNG2qJxWIMHjxEQUNERCRFtfuejFmzZnH66adz6KGH8vTTT7P77rvzzDPP8NFHH3HppZdqrrSIbFM0OgSf728AOJ23YTavaHffjIws8vKap1g1NNRRWrpG/+6IiIikqHaPZNx6663k5eXx8MMPc9BBB2G1WuP79NtEEWmvQODP2O1vYrN9gNs9hfr6eYC5XX0zMrLIzzdYu3YNHk89paWrycsbimEkfA0LERER6YJ2/888ZswYSktLufXWW7n77rtZsmRJd9YlIr2WgcfzKNFoBlbrF6SlPdyh3m53Jvn5wzAMA49nA2vXriEajXZTrSIiItIZ7Q4Z//nPf5g3bx4TJ07ko48+4rTTTmP8+PHcd999/PDDD91Zo4j0MtFoHl7vXQA4nX/DbP6xQ/3d7j7k5w/HMAy83g2Ulq5W0BAREUkhHZpjUFhYyCWXXMK8efN45ZVXOOSQQ3jttde49NJLMQyDefPm8dVXX2metIhsUzB4OsHgERhGCLf7fKCpQ/1drozNgkYDa9euUtAQERFJEZ2eyLzHHntw00038dFHH/Hkk08yYcIE3n//fU4//XTGjRvHddddl8g6RaTXMfB6HyYazcRqXUJ6+v0dPoLLlUFBwQgMw4TP56GkZCXRaKQbahUREZGO6PLdkmazmYMOOoj77ruPTz/9lLvuuotdd92VOXPmJKI+EenFotGBeL33ApCefjdm83cdPobT6aawcAQmk4nGRi8lJauIRBQ0REREkimhS7KkpaVx/PHH8/TTT7NgwYJEHlpEeqlgcCLB4DEYRpiMjAuAUIePkZ7uoqBg5GZBY6WChoiISBJ127qP2dnZ3XVoEelVDDye6USj2Vgs35Gefk+njpKe7qSwcCQmkxm/30dJyQoFDRERkSTR4vIiknSxWH88ngcASE//OxbLV506Tlpac9Awm834/Y0UF68gEunYDeUiIiLSdQoZIpISQqETCQROwjAiuN0XAMFOHSctLT0eNAKB5qDR1KSgISIi0pMUMkQkZXi9fyca7YfF8iNO552dPo7DkU5h4SjMZguBgH9j0AgnsFIRERHZGoUMEUkZsVgOHs9DAKSlPYjF8kWnj+VwpDFkyEjMZgvBoIKGiIhIT2p3yIhGo8yYMYM33nhjq+3eeOMNZsyY0dW6RGQHFQpNIBCYhGFEN06b8nf6WHZ7GkOGjMJisRIMBigqWk44rKAhIiLS3dodMt544w2mT5/OyJEjt9puxIgRTJ8+ndmzZ3e5OBHZMXm9dxOJDMRiWYnTeXuXjmW3OxgyZCQWi5VQKEhx8XLC4Y4vkysiIiLt1+6QMWfOHA466CB23XXXrbYbM2YM48eP3+aIh4hIW2KxLLzehwFIS3sMq/XTLh3PZnMwZMgorFYboVCQoqIVChoiIiLdqN0hY9myZYwdO7ZdbffZZx++//77ThclIhIKHYHffyaGEds4bcrbpePZbHYKC0ditdoIh4MUFS0nFOrcClYiIiKyde0OGY2NjTidzna1dTqdNDY2drooEREAn+9OIpE8zOYiXK5bunw8m83OkCGjsNnshMMhiotXKGiIiIh0g3aHjJycHIqLi9vVtri4WE/8FpEui8Uy8HgeBSAt7Sms1v/r8jGtVhuFhSPjQaOoaDnBYKDLxxUREZGftTtk/OY3v+HNN9/E79/6Si+NjY28+eab7LPPPl0uTkQkHD4Ev/8cANzuizCMhi4f02q1bRzRcNDUFKa4eIWChoiISAK1O2Scc845VFdXc95551FZWdlqm8rKSi644AKqq6s5++yzE1akiOzYvN6/EokMwWxei9N5Y0KOabFYGTJkJHZ7c9AoKlpOIND55XJFRETkZ5b2Nhw9ejS33nort956K4ceeih77703o0aNwul04vP5WL58OV9++SWxWIybb76Z0aNHd2fdIrJDceHxPEZm5tGkpc0kGDyWcPjwLh/VYrFSWDhq40hG8wP7CgtH4HCkJ6BmERGRHVe7QwbAqaeeysiRI3nkkUf47LPPWLhw4c8HsljYd999mTp1KnvttVfCCxWRHVs4vD+NjVNIT38ct/ti6uo+IxbL7PJxLRYLQ4aMpLh4BYHApqAxUkFDRESkCzoUMgD23HNPnn76aQKBAMXFxXi9XlwuF4WFhTgcjni7Ta+LiCSKz3cLNtt8LJZVuFzX4vE8kZDjms0WCgtHUly8kkCgkaKi5qCRlqagISIi0hkdDhmbOBwOdtpppy1er6mp4fnnn+fll1/myy+/7PBxKysreeCBB1iwYAEej4f8/HwmTpzImWeeicm07VtI1qxZw2OPPcbChQupr68nIyOD0aNHc+mll7L77rsD8P777/PWW2+xdOlSqqqqMJvNFBQU8Ic//IETTzyxXecRkWRIx+N5gszMI3E4XiIYPI5Q6OiEHHlT0CgpWYnf74tPnUpLa9/S3SIiIvKzDoWMmpoa3njjDUpKSujTpw9HHHEEY8aMAZrDweOPP87rr79OMBjs1OpSNTU1TJo0ibKysvhrq1atYtq0aaxZs4bbbrttq/0XLVrE5MmTWzyjo6amho8//pijjjoqHjL++c9/8vHHH7fou3TpUq6//nqWLl3KLbd0fT1+EekeTU374vdfTHr6g7jdl1Bbuy+xWE5Cjt38C4cRLYJGQcEI0tM1KisiItIR7f6V/apVqzjmmGO47777eOWVV5gxYwYTJ07krbfe4u233+aoo47i3//+N+PHj+c///kP//jHPzpczMMPPxwPGHfccQcLFy7kkEMOAWDWrFl8++23bfYNhUJcddVVNDY2kpmZyUMPPcTixYv59NNPefTRRxk1alS8rd1u56yzzmLu3Ll88803PPjgg1gszXnr5ZdfpqampsO1i0jP8fluoKlpZ0ym9bhcVyX02GazmcLC5mARjUYpKVmJz9e1p42LiIjsaNo9kvHggw/S2NjILbfcwm9+8xtKS0uZNm0ad955Jx6Ph0MOOYSrrrqK/Pz8ThUSjUaZO3cuAEOHDuWUU04B4Pzzz+eDDz4AYPbs2fHRiF+aP38+5eXlAFx99dUceeSRALhcLg477LAWbe+5554W94scddRRvPHGG3zwwQfEYjFKSkrIyUnMb0ZFpDs48HgeJzPzMByOVwkGjycUOiFhRzeZzBQUDKekZDWNjR5KSlZSUDAcp9OdsHOIiIj0Zu0OGYsWLeK0005j0qRJAIwYMQKz2czkyZM58cQTmTZtWpcKWbt2LR6PB4Bhw4bFX998e9myZW32/+KLL+LbK1as4PDDD6eiooKCggLOPfdcTjzxxPj+1m5IDwaD8e3c3NzOXcRmLBbd19EbmM2mFh8llexNIHAFaWn34nZfTkPD/sRi/RN4fBPDho2kqGglXm8DJSWrGDJkBG53RgLPsePa/L3V2X8vE/X+TEQtIiLSUrtDRn19/RY3eu+8884AW4wUdEZtbW18e/MQsPn21qYxbRrFAJg5c2Z8e+XKlVx77bUEAgFOO+20Vvt++eWXfPbZZwCMGzeOQYMGdbj+zZlMBllZulm0N8nISEt2CdKqvwHzMJm+JTPzKuA/gJHQM2Rl7cH3339PbW0txcUr2XXXXcnOzk7oOXZENTXNqxG63Y4u/3vZ1fdnImsREZFm7Q4Z0Wg0ft9CvPPGz9PTu2+Zx1gsFt82jLZ/eIhEIvHtMWPGMGPGDCoqKjj99NPx+/088sgjTJo0aYtjfPvtt1x00UVEo1Fyc3O7PCIDEI3GaGho3HZDSXlms4mMjDQaGvxEItFklyOtMJufwO0+EMN4Da93JuHwxISfY9CgITQ1RWloqGfp0qUUFg4nIyMz4efZkXg8gfjHujpfp46RqPdnImqRxMjISNPIsUgv0aHVpZYuXYrdbo9/7vP5MAyDxYsXx6c6be6II45o97E3/83g5sfy+XyttvmlzMzM+Pbxxx9PTk4OOTk57L333ixYsIDq6mqqq6vp169fvN1XX33F5MmT8Xq99O/fn5kzZzJgwIB217w1TU36gbQ3iUSi+p6mqKamMZjNf8HpvJP09Cuoq9ufaDQx7+PNDR48hFisCI+nnqKiVeTnD8Xtzkz4eXYUm0JBIt5bXT1GImsREZFmHQoZzz//PM8///wWrz/yyCNbvGYYBj/88EO7j52fn09GRgYNDQ2sWbMm/vrq1avj27vsskub/UePHs1bb7211XNs/rDAL774gvPPP5/GxkYGDx7M888/3+mb1kUkuRobr8RmewerdQku1yU0NLxCoqdNGYaJvLyhrFu3hoaGetauXU1e3lAyMrISeh4REZHeoN0hozNL0naEyWRiwoQJvPzyy6xZs4ZXX32VQw45hCeffDLe5rjjjgNg/PjxrFu3jn322YcXXngBaF4havr06TQ1NfHmm28yYcIEKioq4g8EHD16NG5388own3zyCRdeeCGBQIAhQ4bw/PPPJ2wEQ0SSwYrH8wRZWQdgt/8Xu/0lgsHTE34WwzAYPHgoUERDQx2lpWsYPDhGnz66R0NERGRz7Q4ZnXm4XkddfPHFfPjhh5SVlXH99de32Ddp0qQ2l6+F5pGQKVOm8PDDD7N06VLGjRsX32e1Wrnmmmvinz/xxBMEAs1zcIuKijjooINaHGvatGmcdNJJibgkEekhkchofL4bcLluweW6hnD4YKLRwQk/T3PQGIJhGGzYUMu6dUUAChoiIiKb6dB0qWAwyHvvvUdpaSmZmZkcfPDB9O+fuCUjc3JymDVrFvfffz8LFizA4/FQUFDAxIkTOfPMM7fZf+rUqQwcOJAXXniBVatWYbPZ2GuvvZg6dSp77rlnwuoUkdTk91+M3T4Hq3URbvdFbNjwOomeNgXNQWPQoEIMw6C+voZ164qIxWJkZur5OiIiItCBkFFTU8OkSZMoLS2Nr/iUlpbGo48+2mLUoKtyc3O5++67t9rm/fffb3PfySefzMknn7zV/pumWIlIb2PB43mSrKzfYrO9j8Mxk0Dgz91yJsMwGDiwAMMwqKurpqysmFgsRlZW3245n4iIyPak3evEPfbYY6xbt46zzjqLJ598kuuvvx673c7NN9/cnfWJiHRIJDISn6/53yWn8wZMpuJuO5dhGAwYkE9WVvOqdeXlJdTVVXXb+URERLYX7R7J+Pjjjzn++ONb3NvQt29frrzySlavXt3iydwiIsnk90/ZOG1q4cZpU7PpwO9UOqQ5aORhGAa1tespL19LLAbZ2f223VlERKSXavf/uuXl5fz6179u8dqvf/1rYrHYVp/ELSLS88w0NDxOLJaOzbYAh+Opbj2bYRjk5g4mJ6f5HrWKirXU1Kzv1nOKiIiksnaHjFAo1OJBfAA2mw2ApqamxFYlItJF0egwvN7bAXC5bsFkWtWt5zMMg/79B5OTkwtAZWUp1dWV3XpOERGRVNWh1aXWrVvH999/H/9805O5i4uLycjI2KL9rrvu2sXyREQ6LxA4F7t9NjbbAjIyLqS+/m3A3G3naw4agzAMg+rqCtavX0csFqNfPz2HR0REdiwdChkPPvggDz744Bav33bbbS0+j8ViHX7it4hI4pnweB4lK2ssVutC0tIex++f2q1n3DxoVFWVU1VVBsTo129gt55XREQklbQ7ZEybNq076xAR6RbRaCE+35243ZfgdN5GKHQEkciobj9vv34DMQyD9evLqKoq3zii0fyaiIhIb9fukHHiiSd2Zx0iIt0mEPgTdvub2Gzv4XafT339/+jgQG6n9O07AMMwqKxcR3V1BbFYLD7KISIi0pt1z5qOIiIpxcDjeYRotA9W62LS0h7qsTPn5OSSm5sHQE1NJZWV6+IPNBUREemtFDJEZIcQjQ7G670LAKfzTszmZT127pyc/gwYkA9Abe16KitLFTRERKRXU8gQkR1GMPgHgsHfYRgh3O4LgHCPnTs7ux8DBxYAUFtbRUXFWgUNERHptRQyRGQHYuD1Pkg0monV+jXp6X/v0bNnZfVl0KBCAOrqqikvL1HQEBGRXkkhQ0R2KNHoALze5nCRnn4PFss3PXr+zMyceNCor6+hrKxYQUNERHodhQwR2eEEg6cQDB6PYTRtnDYV7NHzZ2bmMHjwEAA2bKhV0BARkV5HIUNEdkAGHs8DRKN9sVi+Jz397h6voE+fbPLyhgLNQWPduiIFDRER6TUUMkRkhxSL9cXjeQCA9PQHsFgW93gNGRlZ5OUNAwwaGuooLV2joCEiIr2CQoaI7LBCoeMJBE7BMCIbp00FeryGjIxM8vOHYhgGHk89paWricWiPV6HiIhIIilkiMgOzeu9l0gkF4vlJ5zOO5JSg9udSV7esI1BYwNr164hGlXQEBGR7ZdChojs0GKxHLze5ieAp6U9hMXyeVLqcLv7kJ8/HMMw8Ho3UFq6WkFDRES2WwoZIrLDC4V+RyDwBwwjtnHaVGNS6nC5MjYLGg2sXbtKQUNERLZLChkiIoDXexeRyCAsllU4nbclrQ6XK4OCghEYhgmfz0NJyUqi0UjS6hEREekMhQwRESAWy8TjeRiA9PTHsVo/TlotTqebwsIRmEwmGhu9lJSsIhJR0BARke2HQoaIyEbh8OH4/WcB4HZfCHiTVkt6uouCgpGbBY2VChoiIrLdUMgQEdmMz3cHkUgBZnMRLtdNSa0lPd1JYeFITCYzfr+PkpIVRCJNSa1JRESkPRQyREQ2E4u58XgeBSAt7Rms1veTWk9aWnPQMJvN+P2NFBevVNAQEZGUp5AhIvIL4fBB+P2TAXC7p2IYG5JaT1pa+sagYSEQaKS4eAVNTQoaIiKSuhQyRERa4fXeTiQyFLO5FKfz+mSXg8OxedDwbwwa4WSXJSIi0iqFDBGRVjnxeB4nFjNIS3sBm21esgvC4UhjyJCRWCwWgkEFDRERSV0KGSIibQiHx+H3XwiAy3UJhlGX5IrAbk+jsHAUFouVYDBAUdFywmEFDRERSS0KGSIiW+Hz3UxT00jM5nJcrr8kuxwA7HbHxhENK6FQkOLi5YTDoWSXJSIiEqeQISKyVWl4PE8Qi5lwOF7BZpub7IIAsNkcDBkyCqvVRigUpKhohYKGiIikDIUMEZFtaGraG7//MgDc7ksxjJrkFrSRzWansHAkVquNcDhIUdFyQqFgsssSERFRyBARaQ+f7zqamkZjMlXhcl2Z7HLibDY7Q4aMwmazEw6HKC5eoaAhIiJJp5AhItIu9o3Tpsw4HK9ht7+W7ILirFYbhYUj40GjqGg5wWAg2WWJiMgOTCFDRKSdmpr2orHxKgBcriswjPVJruhnVqtt44iGg6amMMXFKxQ0REQkaRQyREQ6oLHxasLh3TGZanG7LwNiyS4pzmKxMmTISOz25qBRVLScQMCf7LJERGQHpJAhItIhto3TpqzY7XOx219JdkEtWCxWCgtHYbenEYk0UVy8gkCgMdlliYjIDkYhQ0SkgyKRMTQ2XguAy/UXTKbyJFfUksViYciQkTgcChoiIpIcChkiIp3Q2Hg54fBemEz1uFwXk0rTpgDMZguFhSNxONKJRCIUFa3A71fQEBGRnqGQISLSKRY8nieJxezY7fNxOF5MdkFb2BQ00tKcRKMRiotX0NjoS3ZZIiKyA1DIEBHppEhkZ3y+GwFwOq/FZFqb5Iq2ZDabKSgYEQ8aJSUraGz0JrssERHp5RQyRES6wO+fSji8DyaTB7d7Kqk2bQqag0Zh4QjS011Eo1FKSlbi8yloiIhI91HIEBHpEjMez+PEYmnYbB/gcDyb7IJaZTI1j2g4ne7NgoYn2WWJiEgvpZAhItJFkchIfL5bAHC5bsRkWpPkilpnMpnIzx+O05lBLNYcNLzehmSXJSIivZBChohIAvj9FxAK/RbD8OF2XwREk11Sq5qDxjBcrgxisRhr165S0BARkYRTyBARSQgTHs9jxGJObLaPSUt7MtkFtclkMpGXNwy3u088aHg8G5JdloiI9CIKGSIiCRKNDsXr/SsATuetmM0rklxR25qDxlDc7syNQWM1Hk99sssSEZFeQiFDRCSBAoFzCIUOwTD8uN1TgEiyS2qTYTQHjYyMTKA5aDQ01CW7LBER6QUUMkREEsrA43mEaNSN1foFaWmPJrugrTIMg8GDh5KRkQVAaekaNmyoTXJVIiKyvVPIEBFJsGg0H59vGgBO518xm39MckVb1xw0htCnTzYA69YVKWiIiEiXKGSIiHSDQOAMgsEjMIwgbvcFQFOyS9oqwzAYNKiQzMwcoDlo1NfXJLkqERHZXilkiIh0CwOv9yGi0Uys1q9IT5+e7IK2yTAMBg4sICurLwBlZcXU1VUnuSoREdkeKWSIiHSTaHQQXu/dAKSnT8NsXprkirbNMAwGDMgnK6sfAOXlJdTWViW5KhER2d4oZIiIdKNgcBLB4AQMI7xx2lQo2SVtU3PQyCM7uz8AFRVrqa1dn+SqRERke6KQISLSrQw8ngeJRrOxWr8lPf2+ZBfULoZhkJs7mJycTUGjlJqayiRXJSIi2wuFDBGRbhaL9cfr/TsA6en3YbF8ndyC2skwDPr3H0zfvrkAVFauo7paQUNERLZNIUNEpAcEgycTCJyIYTThdp8PBJNdUrsYhkG/foPo23cAAOvXr6OqqiLJVYmISKpTyBAR6SFe7/1Eo/2wWH7A6ZyW7HLarXlEYxD9+g0EoKqqjKqq8iRXJSIiqUwhQ0Skh8RiOXg80wFIS5uOxfJlcgvqoH79BtK//yAAqqrKWb++jFgsluSqREQkFSlkiIj0oFDoWAKBiRhGdONqU/5kl9QhffsOIDd3MADV1RUKGiIi0iqFDBGRHub13kskMgCLZQVO51+TXU6H5eTkkpubB0BNTSWVlesUNEREpAWFDBGRHhaLZeH1PgRAWtqjWCwLk1xRx+Xk9GfAgHwAamvXU1lZqqAhIiJxChkiIkkQCh2F3/9HDCNGRsYFgC/ZJXVYdnY/Bg4sAKC2toqKirUKGiIiAihkiIgkjc83jUgkD7N5DS7XLckup1OysvoyaFAhAHV11ZSXlyhoiIiIQoaISLLEYn3weB4BIC1tBlbrh0muqHMyM3PiQaO+voaysmIFDRGRHZxChohIEoXD4/H7zwbA7b4Iw/AkuaLOyczMYfDgIQBs2FCroCEisoNTyBARSTKf769EIoWYzSU4nTcmu5xO69Mnm7y8oUBz0Fi3rkhBQ0RkB6WQISKSZLGYG4/nMQDS0p7Dan03yRV1XkZGFnl5wwCDhoY6SkvXKGiIiOyAFDJERFJAOHwAjY0XAOB2T8Uw6pNbUBdkZGSSnz8UwzDweOopLV1NLBZNdlkiItKDFDJERFKEz3cLTU3DMJvLcLmuS3Y5XeJ2Z5KXN2xj0NjA2rVriEYVNEREdhQKGSIiKcOJx/MEsZiBw/FPbLZ3kl1Ql7jdfcjPH45hGHi9GygtXa2gISKyg1DIEBFJIU1N++H3XwyAy3UJhlGb5Iq6xuXKoKBgBIZhwuttYO3aVQoaIiI7AIUMEZEU4/PdQFPTKMzmSlyuq5NdTpc5nW4KCoZjGCZ8Pg8lJSt1M7iISC+nkCEiknLSNk6bMuFw/BubbXayC+oyp9NNYeEITCYTjY1eAgEvVqs12WWJiEg3UcgQEUlBTU2/obHxCgDc7sswjOokV9R16ekuCgpGYjKZiEabOOWUUzSiISLSSylkiIikqMbGa2hq2hWTqRq3+3Jg+/+BPD3dSWHhSMBg8ODBBAIeIpGmZJclIiIJppAhIpKy7BunTVmw29/Ebn812QUlRFqaE4fDhd/vJxqNUFy8UkFDRKSXUcgQEUlhTU170NjYfPO3y3UlhlGZ5IoSw2y28K9//QswCAQaKS5eQVOTgoaISG+hkCEikuIaG68iHN4Dk6kOt/sSesO0KYCqqirS0tyYzRYCAT/FxctpagonuywREUkAhQwRkZRn3Thtyord/g52+8vJLihhTCYzQ4aMxGKxEAwGNo5oKGiIiGzvFDJERLYDkciu+HzXA+ByXYPJtC7JFSWO3Z5GYeEoLBYrwWCAoqLlhMMKGiIi2zOFDBGR7YTffynh8K8xmTbgdk+lt0ybArDbHRtHNKyEQkGKi5cTDoeSXZaIiHSSQoaIyHbDsnHalB2b7T0cjn8ku6CEstkcDBkyCqvVRigUpKhohYKGiMh2KuVCRmVlJddeey3jxo1jt9124+ijj2bmzJlEo9F29V+zZg1XX301+++/P2PGjGHcuHGcc845fPvttwk9j4hIMkQiO+Hz3QyA03k9JlNJkitKLJvNTmHhSKxWG+FwkKKi5YRCwWSXJSIiHZRSIaOmpoZJkybx+uuvU1NTQygUYtWqVUybNo3bbrttm/0XLVrESSedxOzZs6mqqiIcDlNTU8PHH3/MTz/9lLDziIgkk99/IeHwfphMHtzui4De9csRm83OkCGjsNnshMMhiotXKGiIiGxnUipkPPzww5SVlQFwxx13sHDhQg455BAAZs2atcVoxOZCoRBXXXUVjY2NZGZm8tBDD7F48WI+/fRTHn30UUaNGpWQ84iIJJ+ZhobHicXSsNk+xOF4JtkFJZzVaqOwcGQ8aBQVLScYDCS7LBERaaeUCRnRaJS5c+cCMHToUE455RSys7M5//zz421mz57dZv/58+dTXl4OwNVXX82RRx6Jy+UiJyeHww47jD322CMh5xERSQXR6HC83uaRV5frJkym1UmuKPGsVhtDhozCbnfQ1BSmuHiFgoaIyHbCkuwCNlm7di0ejweAYcOGxV/ffHvZsmVt9v/iiy/i2ytWrODwww+noqKCgoICzj33XE488cSEnKe9LJaUyW/SBWazqcVHkVTS1HQB4fBcrNYFZGRciNf7X1Lod0dbtfl7a2v/XlosdoYP34nVq5fHH9g3bNhOOBxpCXt/trcWERFpv5QJGbW1tfFtl8vV6nZNTU2b/TeNYgDMnDkzvr1y5UquvfZaAoEAp512WpfP0x4mk0FWlrNLx5DUkpGRluwSRNrwPLAbVuunZGU9A1yW5Hrap6bGAYDb7WjXv5eZmXvx7bff4vV6WbNmObvvvjsuV/P7sqvvz47WIiIi25YyIaMtsdjP68AbhtFmu0gkEt8eM2YMM2bMoKKigtNPPx2/388jjzzCpEmTunye9ohGYzQ0NHbpGJIazGYTGRlpNDT4iUR618210lv0w2a7A6fzUmKx62hoOIhodNS2uyWZxxOIf6yr87WrT0HBCNasWY7f38jXX3/DiBE7MWBA3y6/PztTi3SPjIw0jRyL9BIpEzKys7Pj25umMwH4fL5W2/xSZmZmfPv4448nJyeHnJwc9t57bxYsWEB1dTXV1dVdPk97NTXpB9LeJBKJ6nsqKaup6Sys1jex2d4nPf186uvnA+Zkl7VVm0JBx95bJgoKRlBcvJJAoJGVK3/E6dyDSMTUpfdn52oREZGtSZmQkZ+fT0ZGBg0NDaxZsyb++urVP9/MuMsuu7TZf/To0bz11ltbPYfD4SAnJ6dL5xERST0GHs8jZGXth9X6JWlpD+H3X57sorbJ7XYTCgXxej3bbryZvn0HUFGxlkDAz+LFiyksHE5XQlUoFMTtdne6v4iIbCllQobJZGLChAm8/PLLrFmzhldffZVDDjmEJ598Mt7muOOOA2D8+PGsW7eOffbZhxdeeAGAo446iunTp9PU1MSbb77JhAkTqKio4MsvvwSaQ8im/0Taex4Rke1FNJqH13s3GRlTcDrvIBQ6ikhkdLLLalMkEuHUU0+lqqqMqqqyLh3r22+/6nI9p556aotptyIi0jUpEzIALr74Yj788EPKysq4/vrrW+ybNGkSu+++e5t98/PzmTJlCg8//DBLly5l3Lhx8X1Wq5VrrrkmIecREUlVweAfCAbfxG7/L273BdTXvwtYk11Wq8xmM//+97+ZOvVyBg4c3MljgMvlwOsNEonEtt2hDeXl63jkkQe44oprO30MERFpKaVCRk5ODrNmzeL+++9nwYIFeDweCgoKmDhxImeeeeY2+0+dOpWBAwfywgsvsGrVKmw2G3vttRdTp05lzz33TNh5RERSk4HX+xBW6z5YrUtIT7+fxsZrtt0tSTweDzabHZerc1OVLBYTWVlODMPXpXspbDZ7i3v0RESk61IqZADk5uZy9913b7XN+++/3+a+k08+mZNPPjkh5xER2d5EowPweu8jI+Nc0tPvJhj8HZGIRmdFRKRnaZ04EZFeJhg8lWDwWAyjiYyMC4BQsksSEZEdjEKGiEivY+DxTCcazcFiWUp6ukZtRUSkZylkiIj0QrFYPzye+wFIT78fi2VxkisSEZEdiUKGiEgvFQqdSCBwEoYRwe2eAgSSXZKIiOwgFDJERHoxr/fvRKP9sVh+xOm8M9nliIjIDkIhQ0SkF4vFcvB4HgIgLe0hLJbPk1yRiIjsCBQyRER6uVDoaAKB0zCMKG73BUBjsksSEZFeTiFDRGQH4PXeRSQyEItlFU7n7ckuR0REejmFDBGRHUAsloXH8wgAaWmPY7V+kuSKRESkN1PIEBHZQYTDh+P3/wnDiG1cbcqb7JJERKSXUsgQEdmB+Hx3EInkYzYX4XLdnOxyRESkl1LIEBHZgcRiGXg8jwKQlvY0Vuv/JbcgERHplRQyRER2MOHwwfj95wLgdl+EYTQkuSIREeltFDJERHZAXu/tRCJDMJvX4nTekOxyRESkl1HIEBHZIbnweB4nFjNIS3sem21+sgsSEZFeRCFDRGQHFQ7/Fr9/CgAu18UYRl2SKxIRkd5CIUNEZAfm891MU9MIzOZyXK5rk12OiIj0EgoZIiI7tPSN06ZMOBwvY7O9neyCRESkF1DIEBHZwTU17YvffwkAbvclGEZNkisSEZHtnUKGiIjg811PU9POmEzrcbmuTHY5IiKynVPIEBERwIHH8wSxmBmH4zVstteTXZCIiGzHFDJERASApqZf0dh4BQBu9xUYRlWSKxIRke2VQoaIiMQ1Nl5DU9NumEw1uN2XAbFklyQiItshhQwREdmMjYaGJ4jFLNjtc7Db/53sgkREZDukkCEiIi1EIrvR2HgNAC7XVZhM5UmuSEREtjcKGSIisoXGxisIh/fCZKrH5boETZsSEZGOUMgQEZFWWDeuNmXDbp+H3f5SsgsSEZHtiEKGiIi0KhIZjc93AwAu1zWYTKVJrkhERLYXChkiItImv/8SwuG9MZkacLunomlTIiLSHgoZIiKyFeaN06Yc2Gzv43A8l+yCRERkO6CQISIiWxWJjMTnuwUAl+sGTKai5BYkIiIpTyFDRES2ye+fQig0DsPw4XZfBESTXZKIiKQwhQwREWkHEx7PY8Ri6dhsH+FwzEh2QSIiksIUMkREpF2i0WF4vX8FwOW6BZNpVZIrEhGRVKWQISIi7RYInEModBCG4ScjYwoQSXZJIiKSghQyRESkA0x4PI8SjbqxWj8jLe2xZBckIiIpSCFDREQ6JBotwOe7EwCn83bM5p+SXJGIiKQahQwREemwQOBMQqHDMIwgbvcFQFOySxIRkRSikCEiIp1g4PE8TDTaB6t1MWlpDya7IBERSSGWZBcgIiLbp2h0MF7v3WRkXIDTeSeh0FFEIrt26BjFxUWdPr/ZbKK4uIlYzEIk0vnndpSVret0XxERaZ1ChoiIdFoweBrB4Gzs9rdxuy+gvv59wLrNfpFI86pUM2c+1c0Vtp/D4Uh2CSIivYYRi8ViyS6it4lEotTW+pJdhiSAxWIiK8tJXZ2PpiY94VikNYZRSXb2PphMdfh819HYeF27+q1evRKz2dzp81ZWlvPEE49wwQVTyc0d2OnjQHPA6OoxpOuys52YzZrJLdIbaCRDRES6JBbLxev9OxkZZ5Oefi+h0O9oatpzm/2GDRvRpfNu+mF00KDB5OUVdulYIiKSWPp1gYiIdFkweDLB4AkYRhNu9xQgmOySREQkiRQyREQkAQw8nvuJRvtisXxPevrdyS5IRESSSCFDREQSIhbri8czHYD09PuxWBYltyAREUkahQwREUmYUOg4AoFTMYzoxof0+ZNdkoiIJIFChoiIJJTXey+RSC4Wy3KczjuSXY6IiCSBQoaIiCRULJaN1/sQAGlpD2OxfJbkikREpKcpZIiISMKFQr8jEDgdw4htnDalZweJiOxIFDJERKRbeL3TiEQGY7Gsxum8LdnliIhID1LIEBGRbhGLZeLxPAxAevoTWK0fJbkiERHpKQoZIiLSbcLhw/D7/wyA230hhuFJckUiItITFDJERKRb+Xx/IxIpwGwuxum8KdnliIhID1DIEBGRbhWLufF4HgMgLe1ZrNb3klyRiIh0N4UMERHpduHwgfj95wHgdk/FMDYkuSIREelOChkiItIjvN7baGoahtm8DqfzumSXIyIi3UghQ0REeogTj+dxYjGDtLQXsdn+m+yCRESkmyhkiIhIj2lqGovffxEALtclGEZtkisSEZHuoJAhIiI9yue7iaamUZjNFbhcf0l2OSIi0g0UMkREpIelbZw2ZcLh+Bc225xkFyQiIgmmkCEiIj2uqWlv/P7LAHC7L8MwapJbkIiIJJRChoiIJIXPdx1NTbtgMlXhcl2R7HJERCSBFDJERCRJ7Hg8TxCLWXA4XsdufzXZBYmISIIoZIiISNI0Ne1JY+NVALhcV2AYlUmuSEREEkEhQ0REkqqx8SrC4d0xmepwuy8DYskuSUREukghQ0REksyGx/MksZgVu/0t7PZZyS5IRES6SCFDRESSLhLZlcbG6wBwua7BZCpLckUiItIVChkiIpISGhsvIxz+FSZTPS7XxWjalIjI9kshQ0REUoRl47QpO3b7/3A4Xkh2QSIi0kkKGSIikjIikZ3w+W4CwOm8DpNpbZIrEhGRzlDIEBGRlOL3X0Q4vC8mkwe3eyqaNiUisv1RyBARkRRjxuN5nFgsDZvtAxyOZ5JdkIiIdJBChoiIpJxIZAQ+360AuFw3YTKtSW5BIiLSIQoZIiKSkvz+8wmF9scwfLjdFwLRZJckIiLtpJAhIiIpyoTH8yixmBOb7RPS0p5IdkEiItJOChkiIpKyotGheL1/A8DpvA2zeUWSKxIRkfZQyBARkZQWCJxNKHQIhuHH7Z4CRJJdkoiIbINChoiIpDgDj+cRotEMrNYvSEt7JNkFiYjINihkiIhIyotG8/H5pgHgdP4Ns/nHJFckIiJbo5AhIiLbhUDgjwSDR2AYQdzu84GmZJckIiJtUMgQEZHthIHX+zDRaCZW6xJyc59NdkEiItIGhQwREdluRKMD8XrvAWDAgMcZMqQhyRWJiEhrLMkuoDWVlZU88MADLFiwAI/HQ35+PhMnTuTMM8/EZGo7F5WWlnLooYe2us/tdrNo0aL45+FwmFmzZvH6669TWlpKOBxmwIABHH744Zxzzjn06dMn4dclIiIdU1q6Fo/nl0FiDLvsciB9+y7g0ku/4uuvf8Dj8bZ5DLc7g7y8/O4tVEREWjBisVgs2UVsrqamhlNOOYWysrIt9k2aNInbbrutzb4dCRk33XQT//rXv1ptu+uuu/Kf//xnq4FmayKRKLW1vk71ldRisZjIynJSV+ejqUlPGxbpSXV1dRx66G+JRrd87/XtG+GDD6rIzo5y5JF9WbrU1uZxzGYz7777MVlZWd1ZriRAdrYTs1mTLER6g5QbyXj44YfjAeOOO+5g/PjxXH/99XzwwQfMmjWLk08+md13332bx3nvvffIy8trdV8sFuPNN98EID09nZdffpn+/ftz7rnn8v333/P999/zww8/sOuuuybuwkREpEOysrKYPXteKyMZzYqLV1Ffv4Sbbz6VSKTt35e53RkKGCIiPSylQkY0GmXu3LkADB06lFNOOQWA888/nw8++ACA2bNntytkbI1hGJjNZgBGjhzJzjvvDMDYsWP5/vvvAQgEAl06h4iIdN3WpjlZLLuRlXU6WVkaaRQRSTUpFTLWrl2Lx+MBYNiwYfHXN99etmxZu4516qmn0tDQQFZWFgcccACXXXYZubm58f2///3vee6551ixYgU//vgj/fv359NPPwUgOzubXXbZpUvXYrFouLc32DRsr+F7kdSj96eISOpKqZBRW1sb33a5XK1u19TUdOhYVVVVvPbaa3zyySe88cYbZGdnA3DNNddgGAbPPvssxx9/fLzf6NGj+dvf/kZaWlqnr8NkMsjKcna6v6SejIzO/30Qke6l96eISOpJqZDRls3vTTcMo8126enpXHnllRxyyCHk5+ezbt06brjhBpYsWUJlZSX//Oc/ufjiiwF4+umnefbZLddYr66u5ocffmDMmDGdrjcajdHQ0Njp/pI6zGYTGRlpNDT4iUQ0HUMklej92ftkZKRpZEqkl0ipkLFplAGIT5sC8Pl8rbZprf95550X/3z48OFcc801TJo0CYDvvvsOaB7lePDBBwEYMmQITz31FFlZWdx6663MnTuXG2+8kWHDhvHrX/+609ei+cG9SyQS1fdUJEXp/SkiknpS6tcF+fn5ZGRkALBmzZr466tXr45vb+1eidaWOdx85GPTdklJCeFwGIADDjiAgoIC3G43xx13XLztZ5991smrEBERERHZsaVUyDCZTEyYMAFoDhmvvvoqtbW1PPnkk/E2m4LA+PHj2WmnnTjjjDPi+6ZPn87dd9/NTz/9RCgUYtWqVdx1113x/b/61a8A6NevX/y1jz76iJKSEjweD7Nnz46/vinsiIiIiIhIx6TUdCmAiy++mA8//JCysjKuv/76FvsmTZq01eVr/X4///jHP1q912LYsGGcfvrpAAwePJgjjzySefPmUVRUxOGHH96ibVZWFkcffXQCrkZEREREZMeTciEjJyeHWbNmcf/997NgwQI8Hg8FBQVMnDiRM888c6t9TzrpJCKRCF988QUVFRUEAgEGDRrEoYceypQpU1qsUnXvvfey8847884771BSUkJTUxN9+/Zl3333ZerUqeTk5HT3pYqIiIiI9EpGbPOlmyQhIpEotbW+bTeUlGexmMjKclJXp4d9iaQavT97n+xsp1aXEukl9E4WEREREZGEUsgQEREREZGEUsgQEREREZGEUsgQEREREZGEUsgQEREREZGEUsgQEREREZGEUsgQEREREZGEUsgQEREREZGEUsgQEREREZGE0hO/u0EsFiMa1Ze1tzCbTUQiepqwSCrS+7N3MZkMDMNIdhkikgAKGSIiIiIiklCaLiUiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgmlkCEiIiIiIgllSXYBIqmmrq6Op59+ms8++4yGhgb+97//MWfOHCKRCAcccAA5OTnJLlFkh9XQ0MCCBQsoKysjFAptsX/q1KlJqEpERH5JIUNkMzU1NUycOJGysjJisRiGYQDw0UcfMWfOHK644gomT56c5CpFdkyfffYZF110EY2NjW22UcgQEUkNmi4lspkHH3yQdevWYTabW7x+4oknEovF+OCDD5JUmYhMmzYNn89HLBZr9Y+IiKQOjWSIbOb//u//MAyDp59+mrPOOiv++u677w5ASUlJkioTkZKSEgzD4LrrruPAAw/EarUmuyQREWmDQobIZmprawH41a9+1er++vr6HqxGRDa388478/XXXzNhwgTdGyUikuIUMkQ2k5WVRXV1NatXr27x+ltvvQWgH2xEkuiWW27hT3/6E+eddx6nn346AwcOxGJp+d/Y3nvvnaTqRERkcwoZIpsZO3Ysc+bM4aKLLoq/NnnyZD755BMMw2Ds2LFJrE5kx5abm8vIkSNZtGgRN9xwwxb7DcNg2bJlSahMRER+yYjpbjmRuOLiYk4++WS8Xm98ZSmAWCyG2+3m1VdfpaCgIIkViuy4pk6dynvvvdfmTd6GYfDDDz/0cFUiItIajWSI/H979x5VdZmocfx5uQSkclEnEQ2dVhpeMELEzEsmOic70wk5ZTOnQstxatRxrHEcxdHRXGlZa6ZEcaYxgwrtqJOZ5VhhOpZHRc3QFdLVCyI6IoKAcpH9O38Ye/YWMGsx/Pae/f2sxVrt97fFJ9eyePZ7c9GtWzdlZ2dr0aJF2rNnj+rr6+Xv768BAwZo1qxZFAzARjt27JAkxcXFKSEhQcHBwTYnAgA0h5kMoBnV1dUqLy9XeHi4goKC7I4D+LxRo0bp+PHj2rNnj9q2bWt3HADAFXBPBtCM4OBgderUiYIBeIhp06ZJkjZu3GhvEADAt2ImAz6vV69eV/1eNpYC9nnooYf0+eef69y5c4qMjFRUVJTbxZnGGGVlZdmYEADQgD0Z8Hn0bMA77NmzR8YYWZal4uJinTx50vnMsiy3wxoAAPaiZMDnjRkzxu4IAK5CVFSU3REAAFeJ5VIAAAAAWhQzGUATjhw5otzcXJ09e1YRERFKTExU9+7d7Y4F4BtffPGFSktLFRERoZ49e9odBwBwGUoG4KKurk5z587Vm2++2ejZmDFj9OSTTyoggL82gF22bt2qJ5980m0/RmRkpObMmaMRI0bYmAwA4IrlUoCLRYsWNXs6jTFG48aN08yZM1s5FQBJ+vjjj/XQQw/J4XA0OrAhICBAWVlZ6t+/v03pAACuKBmAi1tvvVXl5eWKjo5WamqqIiMjdfLkSb3yyis6evSowsPDtWvXLrtjAj7p5z//ubZv367g4GCNGjVKnTt3VnFxsXJycnThwgUNGzZML774ot0xAQBiuRTgpqamRpL04osvqlu3bs7xwYMH684771RdXZ1d0QCfl5eXJ2OM/vSnP+nWW291ju/atUvjx49XXl6ejekAAK648RtwMXjwYElSmzZt3MYbXg8dOrTVMwG45Pz585Kkvn37uo03vG54DgCwHyUDcPHwww8rLCxMjz/+uHbu3KkjR45o586deuKJJ3TdddfpkUce0YkTJ5xfAFpPZGSkJOn55593FooLFy7ohRdecHsOALAfezIAF7169brq9xpjlJ+f/y9MA8DVM888o5dfflnGGPn5+alt27aqrKyUw+GQJI0fP16//e1vbU4JAJCYyQDcWJb1nb4AtJ7JkyfrxhtvlGVZqq+vV3l5uerr62VZlm644QZNmjTJ7ogAgG+w8RtwMWXKFLsjAGhG27Zt9frrryszM1MfffSR87LMIUOGaPz48Wrbtq3dEQEA32C5FADAKzTsg4qKirI5CQDg21AyAABeISYmRn5+fk3uhbr99tvl5+enrVu32pAMAHA5lksBLmpqapSRkaHNmzeruLi40b0YbPYG7NXU52IOh0OnTp2SMcaGRACAplAyABdPPfWU1q5dK6npH2YAtK6CggIVFBS4jb355ptur7/88ktJUmBgYGvFAgB8C0oG4CInJ0eS1KVLF91888265pprbE4E+LacnBwtW7bM+dqyLM2aNavR+4wx6tatW2tGAwBcASUDcNGw3GLt2rWKiIiwOQ0A6Z+zig1/P5uaZQwLC9P06dNbNRcAoHmUDMDF/fffr4yMDG3btk1jxoyxOw7g88aMGaPExERZlqVx48bJGKNXXnnF+dwYo9DQUHXr1k3BwcE2JgUAuOJ0KcCFw+HQ5MmTtW3bNnXu3FmdO3eWv7+/87kxRllZWTYmBHzXzJkzZYzRokWL7I4CAPgWlAzAxVtvvaXf/va3TT6zLEvGGB06dKiVUwFozv79+1VaWqq4uDh16NDB7jgAgG+wXApw8cILL3CqFOChXnzxRW3cuFHJycmaMGGC5syZo3Xr1kmSQkNDtXLlSvXp08fmlAAAiZIBuCktLZUxRunp6Ro6dKiCgoLsjgTgGx988IG+/PJL9e7dW6dPn9a6deucHwqUl5dr+fLlWrp0qc0pAQCS5Gd3AMCTDBs2TJIUGxtLwQA8zNGjRyVJN910k/Ly8mRZlpKTk7V48WJJUl5enp3xAAAumMkAXNx1113avXu3Jk6cqNTUVHXp0kUBAe5/TQYMGGBTOsC3VVZWSrq0NOqLL76QMUZ33HGHRowYoRkzZqisrMzegAAAJ0oG4OJXv/qVjDEqLy/XnDlzGj03xig/P9+GZAAiIiJ0+vRpZWdna8uWLZKk7t27q6KiQpLUrl07O+MBAFywXAq4jGVZV/wCYI/+/fvLsiw9/fTT+vTTT9WhQwfddNNN+uqrryRJ0dHRNicEADRgJgNwwfn7gOd6/PHHVVBQoMOHD6tt27aaN2+eJOndd9+VJCUmJtqYDgDginsyAABepaysTKGhofLzYzIeADwVJQNoRmlpqaqrqxuNR0VF2ZAGAADAe7BcCnDhcDiUnp6uVatW6dy5c42es/EbsE9SUtIVnxtjlJOT00ppAABXQskAXLzyyitavny53TEANKGoqKjJcWOMLMuSMaaVEwEAmkPJAFysX79exhj16tVL+fn5MsZo1KhR2r59u6677jr179/f7oiAz7r8jhqHw6GioiKdPHlSISEhio2NtSkZAOBylAzARcONwkuXLtWIESMkSUuWLNGOHTs0ceJETZ061c54gE979dVXmxxfs2aNfv/73+snP/lJKycCADSHozkAF/X19ZKkyMhI+fv7S5KqqqqUkJAgh8OhZcuW2RkPQBPGjh2rkJAQljoCgAdhJgNwER4erpKSElVVVSkiIkJnzpzRggULFBQUJEkqLi62OSHgu06cONForKamRtu3b9f58+dVWFhoQyoAQFMoGYCL7t27q6SkREVFRYqPj9d7772nDRs2SLq0ubRnz542JwR814gRI5rd3G2M0Q9/+MNWTgQAaA4lA3Bx3333qWvXrqqoqNC0adN04MABnTx5UpIUFhamtLQ0mxMCvq25q52uvfZazZw5s5XTAACaw2V8wBVUVlYqLy9PtbW1io+PV1hYmN2RAJ+1dOnSRmPXXHONIiMjNWzYMIWHh7d+KABAkygZgIu9e/cqISGh2efr1q3Tvffe24qJAAAAvA+nSwEuxo0bp2effVZ1dXVu4yUlJXr00Uc1Z84cm5IBKCws1J49e/TVV1+5jX/11Vfas2cPG78BwINQMgAX9fX1Wrlypf77v/9bBQUFkqRNmzbpxz/+sf7+97/bnA7wbfPmzVNqaqo+/fRTt/FDhw4pNTVV8+fPtykZAOBybPwGXKSmpuq1117T559/rvvuu09xcXHau3evLMtSSEiIpk+fbndEwGfl5+dLkoYNG+Y2PmTIEFmW1ah8AADsw0wG4CItLU2rVq3SjTfeqLq6OmfBGDRokDZu3KgHHnjA7oiAz6qoqJAkORwOt/GG15WVla2eCQDQNEoGcJnKykqdP39exhhZliVjjKqqqlRTU2N3NMCn/eAHP5Ak/eUvf3EbX7FihSSpY8eOrZ4JANA0TpcCXEyfPl3vvPOOJCk4OFi333673n33XUlSQECAfvGLX2jSpEl2RgR8Vlpamt544w3nxXs//OEPdfjwYR0+fFiSlJKSoqeeesrmlAAAiZIBuImJiZEk3XLLLXrmmWcUHR2t3bt3a9asWTpx4oSMMTp06JDNKQHfVFhYqJSUFFVUVLjd/G1ZlkJDQ/XGG2+oa9euNiYEADRguRTgIjAwUE888YSys7MVHR0tSRo4cKA2btyolJQUm9MBvu36669Xdna2br31Vvn5+cmyLPn5+em2225TdnY2BQMAPAgzGYCLgoIC52xGU7Zt26bhw4e3XiAATaqpqVFZWZnCw8MVFBTU6PmePXskSQMGDGjtaAAAUTKAJpWXl2v//v0qKytTcnKy3XEAfEcxMTHy8/NzHnsLAGhd3JMBXGblypVasmSJampqZIxRcnKyxo8fr8LCQs2bN09Dhw61OyKAq8BnaABgH/ZkAC7+9re/afHixaqurpZlWc4fUpKSklRUVOQ8eQoAAADNo2QALjIzM2WM0ahRo9zGG/ZhfPLJJ60fCgAAwMtQMgAXn332mSRpwYIFbuORkZGSpFOnTrV6JgAAAG9DyQBcNJy9HxgY6DZ+7NgxO+IAAAB4JUoG4OKGG26QJK1YscI5duDAAc2ePVuS1KNHD1tyAQAAeBOOsAVcrF69WvPnz3e7TdjV/PnzNXbs2FZOBeC7Wr9+vSRpzJgxNicBAN9EyQAuM2vWLOcPKK5SUlK0cOFCGxIBaHD27FmtWLFCu3bt0rlz5/T+++9r48aNqq+v19ChQ9WhQwe7IwIARMkAmrRv3z5t375dpaWlat++vYYOHaqEhAS7YwE+7cyZMxo7dqxOnDghy7JkjNGhQ4c0Y8YMbdy4UU888YQmTpxod0wAgCgZwPeWmpoqY4yysrLsjgL4hLlz52rNmjUKCAjQxYsXnSVj586devjhhxUfH69Vq1bZHRMAIDZ+A99bbm6ucnNz7Y4B+Ixt27bJGON2MIMk9evXTxKnwAGAJ6FkAAC8QmlpqSQpPj6+yedlZWWtmAYAcCWUDACAV4iIiJAkff31127j77zzjiSx6RsAPAglAwDgFQYNGiRJmjx5snNs4sSJmjdvnowxzucAAPtRMgAAXmHy5Mlq06aNioqKnHfZfPTRR3I4HGrbtq0mTZpkc0IAQANKBgDAK3Tr1k3Z2dm69dZb5efnJ8uy5Ofnp1tvvVWvvfaaoqOj7Y4IAPgGR9gC39OIESNkjNGWLVvsjgL4nOrqapWXlys8PFxBQUF2xwEAXIaSAQAAAKBFBdgdAPA0O3fuVHZ2tg4fPqzq6mq3Z8YY5eTk2JQM8D29evW66vcaY5Sfn/8vTAMAuFqUDMDF1q1bNXnyZFmWJddJPmOMLMtybjYF0DqYbAcA70TJAFysXLlSDodDISEhunDhgowxCgsLU1lZmUJDQ9WuXTu7IwI+ZcyYMXZHAAB8D+zJAFwMGDBAlZWVWrt2re69914ZY3To0CH95S9/0cqVK7Vy5crvtHwDAADAF1EyABd9+/ZVfX29Dh48qNjYWEnSwYMHVVdXp1tuuUW33HKLVq9ebXNKwLcdOXJEubm5Onv2rCIiIpSYmKju3bvbHQsA4ILlUoCLdu3aqaysTHV1dQoNDdW5c+e0bt06hYSESJIOHTpkc0LAd9XV1Wnu3Ll68803Gz0bM2aMnnzySQUE8L81APAE/NcYcBEVFaWysjKdPn1aMTExys3N1fz58yVd2vzdqVMnmxMCvuu5557T+vXrm3y2fv16hYaGaubMma2cCgDQFG78Blzcdttt6ty5sz7//HM98sgj8vf3d540ZVmWJk6caHdEwGdt2LBBxhh169ZNc+bM0bJlyzRnzhx169ZNlmU1OcMBALAHezKAKzhw4IC2bNmi2tpaDR8+XAMHDrQ7EuCzbrnlFlVXV2vz5s3q1q2bc/zIkSO688471aZNG+3bt8/GhACABiyXAlw0fBKanJwsSerXr5/69esnSSosLFRhYaGuv/56m9IBvm3w4MHasmWL2rRp4zbe8Hro0KF2xAIANIGZDMBFTEyM/Pz8mrw1+ErPAPzr7du3T5MnT1aPHj00adIkde7cWcXFxcrIyNDRo0e1dOlSdezY0fn+qKgoG9MCgG+jZAAuYmJinHdjuKqpqdHNN9/c5DMAreO73FFjjOEDAQCwEcul4PNycnK0ZcsWt7FZs2a5vT527JgkNVqmAaD18JkYAHgPSgZ8XkFBgdupNFc6paZPnz6tEwpAI1OmTLE7AgDgKlEyAP3zE1JjjNvrBmFhYerbt69+97vftXo2AJdQMgDAe7AnA3DR3J4MAAAAXD1mMgAXixYtsjsCgGbU1NQoIyNDmzdvVnFxserq6tyes9kbADwHMxlAM0pLS1VdXd1onGMxAXvMnTtXa9euldT0JnBmIQHAczCTAbiwLEtLlizRqlWrdO7cuUbP+aQUsE9OTo4kqUuXLrr55pt1zTXX2JwIANAcSgbgIisrS8uXL7c7BoAmNBzMsHbtWkVERNicBgBwJX52BwA8yfr162WMUe/evSVd+qHmRz/6kYKDgxUdHa3k5GR7AwI+7P7775dlWdq2bZvdUQAA34I9GYCLuLg41dTUaMuWLRoxYoRzjfeOHTs0ceJELV68WD/+8Y/tjgn4JIfDocmTJ2vbtm3q3LmzOnfuLH9/f+dzY4yysrJsTAgAaMByKcBFfX29JCkyMlL+/v5yOByqqqpSQkKCHA6Hli1bRskAbPL22287ZzGKi4tVXFzsfGZZlnM5FQDAfpQMwEV4eLhKSkpUVVWliIgInTlzRgsWLFBQUJAkuf1QA6B1vfDCC02eKgUA8DyUDMBF9+7dVVJSoqKiIsXHx+u9997Thg0bJF1aitGzZ0+bEwK+q7S0VMYYpaena+jQoc7yDwDwPGz8Blzcd999Sk5OVkVFhaZNm6bIyEhZliXLshQaGqq0tDS7IwI+a9iwYZKk2NhYCgYAeDg2fgNXUFlZqby8PNXW1io+Pl5hYWF2RwJ81rvvvqvf//73uu6665SamqouXbooIMB9Qn7AgAE2pQMAuKJkAAC8QkxMzBU3d3NZJgB4DvZkwOelpqZe9Xs5IhOwF5+LAYB3oGTA5+Xm5l7V0ZcckQnYa9GiRXZHAABcJUoGfF5UVJTb67KyMp0/f16BgYEKCwtTeXm56urqFBISovbt29uUEsCYMWPsjgAAuErsyQBc5OXl6eGHH9YDDzygKVOmKCgoSLW1tXrhhReUnZ2tFStWKCEhwe6YgM8rLS1VdXV1o/HLPzQAANiDkgG4GDt2rA4ePKi9e/eqTZs2zvHKykolJCQoNjZWa9eutTEh4LscDofS09O1atUqnTt3rtFzNn4DgOfgngzARUFBgSRpx44dbuMNrz/77LNWzwTgkldeeUXLly9XeXm58/6ay78AAJ6BPRmAi6ioKB09elTTpk1TbGysOnXqpFOnTungwYMyxrAUA7DR+vXrZYxRr169lJ+fL2OMRo0ape3bt+u6665T//797Y4IAPgGMxmAi6lTp0q6tCzjwIEDev/993XgwAE5HA5J0q9+9Ss74wE+7ejRo5KkpUuXOseWLFmiZcuW6fjx4xo8eLBd0QAAl6FkAC7uuusuZWZmqn///vL395dlWfL391dCQoKysrI0evRouyMCPqu+vl6SFBkZKX9/f0lSVVWVEhIS5HA4tGzZMjvjAQBcsFwKuMzAgQOVnZ0th8Ohs2fPKiIiQn5+9HHAbuHh4SopKVFVVZUiIiJ05swZLViwQEFBQZKk4uJimxMCABrwkxPQDD8/P3344Yd666237I4CQFL37t0lSUVFRYqPj5dlWdqwYYPWrFkjY4x69uxpb0AAgBNH2AJXEBMTIz8/P47FBDzAW2+9pZ07dyolJUUdOnTQI488opMnT0qSwsLC9Oc//1lxcXH2hgQASKJkAFcUExMjY4wOHTpkdxQAl6msrFReXp5qa2sVHx+vsLAwuyMBAL7BcikAgFfYu3ev2+u2bdtq8ODBuuOOOxQWFqZ169bZlAwAcDlKBgDAK4wbN07PPvus6urq3MZLSkr06KOPas6cOTYlAwBcjuVSwBXk5uZKkhITE21OAqBh+WKPHj20ePFixcTEaNOmTXryySdVVlbG0kYA8CCUDACAV1i4cKFee+01ORwOBQYGKi4uTnv37pVlWQoJCdH06dP1wAMP2B0TACCWSwFunn76aSUlJSkzM9Nt/OWXX1ZSUpKeeeYZe4IBUFpamlatWqUbb7xRdXV1zoIxaNAgbdy4kYIBAB6EkgG4yMnJ0YkTJ3THHXe4jY8cOVJFRUXKycmxKRkA6dKJUufPn5cxRpZlyRijqqoq1dTU2B0NAOCCkgG4+Mc//iFJ6tSpk9t4x44dJUmnTp1q9UwALpk+fbomTpyo4uJiBQcH684775QkHTx4UMnJycrIyLA5IQCgASUDcBEUFCRJ2r17t9t4wwbw4ODgVs8E4JK3335blmUpLi5OGzZs0PPPP6/MzEx17txZdXV1Sk9PtzsiAOAblAzARZ8+fWRZlmbMmKEXX3xROTk5evHFFzVjxgwZY9S7d2+7IwI+KzAwUE888YSys7MVHR0tSRo4cKA2btyolJQUm9MBAFxxuhTgIicnR1OmTJExxm28Ye13enq6Ro4caVM6wLcVFBQoJiam2efbtm3T8OHDWy8QAKBZlAzgMhkZGVq2bJnq6+udYwEBAZo8ebJ+8Ytf2JgMgCSVl5dr//79KisrU3Jyst1xAABNoGQATSgqKtKOHTtUWlqq9u3ba8iQIYqKirI7FuDzVq5cqSVLlqimpkbGGOXn52v8+PEqLCzUvHnzNHToULsjAgAkBdgdAPBEXbp00dixY+2OAcDF3/72Ny1evLjReFJSkp566im98847lAwA8BBs/AZccBkf4LkyMzNljNGoUaPcxhv2YXzyySetHwoA0CRKBuCCy/gAz/XZZ59JkhYsWOA2HhkZKYl7bADAk1AyABdcxgd4roZT3wIDA93Gjx07ZkccAMAVUDIAF1zGB3iuG264QZK0YsUK59iBAwc0e/ZsSVKPHj1syQUAaIySAbjgMj7Ac917772yLEt/+tOfnLMa999/v/Ly8mSM0b333mtzQgBAA06XAlw8+OCD2rVrl86dO6c//vGPzvGGy/gefPBBG9MBvu2nP/2pDhw4oPXr1zd6lpKSwolwAOBBuCcDuAyX8QGebd++fdq+fbvzHpuhQ4cqISHB7lgAABeUDKAJXMYHeLfU1FQZY5SVlWV3FADwSZQM4DKHDx/We++9pxMnTqi2ttbtmTFGCxcutCkZgKsVExMjY4wOHTpkdxQA8EnsyQBcbNq0Sb/5zW/kcDiafQ8lAwAA4MooGYCL9PR0t70YAAAA+O4oGYCL4uJiGWM0f/583XPPPc57MwAAAHD1uCcDcNFwD8bo0aMpGAAAAN8TJQNwkZaWpuDgYD377LOqqqqyOw4AAIBX4nQp+LykpCS316Wlpaqurpa/v786dOiggIB/rio0xignJ6e1IwL4jkaMGCFjjLZs2WJ3FADwSZQM+LyYmJirfi9HYgIAAHw7Nn7D5w0YMMDuCACu0s6dO5Wdna3Dhw+rurra7RkzjQDgOZjJAAB4ha1bt2ry5MmyLEuu/+syxsiyLGYaAcCDsPEbAOAVVq5cKYfDoeDgYEmXykV4eLgsy1JoaKiioqJsTggAaEDJAAB4hYKCAhlj9OqrrzrHdu3apV//+tfy9/fX0qVLbUwHAHBFyQAAeIULFy5IunRYgzFGknTx4kU9+OCDOnv2rJ588kk74wEAXLDxGwDgFdq1a6eysjLV1dUpNDRU586d07p16xQSEiJJ7McAAA9CyQAAeIWoqCiVlZXp9OnTiomJUW5urubPny/p0v6MTp062ZwQANCA5VIAAK9w2223qXPnzvr888/1yCOPyN/f33nSlGVZmjhxot0RAQDf4AhbAIBXOnDggLZs2aLa2loNHz5cAwcOtDsSAOAblAwAgFd48803JUnJycmNnhUWFkqSrr/++lZMBABoDiUDAOAVYmJi5Ofnp/z8/O/0DADQ+tiTAQDwGk19LlZTU9PsMwCAPThdCgDgsXJycrRlyxa3sVmzZrm9PnbsmCSpTZs2rZYLAHBllAwAgMcqKChw7sWQLs1WuL521adPn9YJBQD4VpQMAIBHa1gG1XDL9+XLosLCwtS3b1/97ne/a/VsAICmsfEbAOAVYmJiZIzhZm8A8ALMZAAAvMKiRYvsjgAAuErMZAAAvE5paamqq6sbjUdFRdmQBgBwOWYyAABewbIsLVmyRKtWrdK5c+caPTfGcE8GAHgISgYAwCtkZWVp+fLldscAAFwFLuMDAHiF9evXyxij3r17S7o0c/GjH/1IwcHBio6OVnJysr0BAQBOlAwAgFc4evSoJGnp0qXOsSVLlmjZsmU6fvy4Bg8ebFc0AMBlKBkAAK9QX18vSYqMjJS/v78kqaqqSgkJCXI4HFq2bJmd8QAALtiTAQDwCuHh4SopKVFVVZUiIiJ05swZLViwQEFBQZKk4uJimxMCABowkwEA8Ardu3eXJBUVFSk+Pl6WZWnDhg1as2aNjDHq2bOnvQEBAE7MZAAAvMJ9992nrl27qqKiQtOmTdOBAwd08uRJSVJYWJjS0tJsTggAaMBlfAAAr1RZWam8vDzV1tYqPj5eYWFhdkcCAHyDkgEAAACgRbFcCgDgsVJTU6/6vcYYZWVl/QvTAACuFiUDAOCxcnNzZYz51vdZlnVV7wMAtA5KBgDAY0VFRbm9Lisr0/nz5xUYGKiwsDCVl5errq5OISEhat++vU0pAQCXY08GAMAr5OXl6eGHH9YDDzygKVOmKCgoSLW1tXrhhReUnZ2tFStWKCEhwe6YAABRMgAAXmLs2LE6ePCg9u7dqzZt2jjHKysrlZCQoNjYWK1du9bGhACABlzGBwDwCgUFBZKkHTt2uI03vP7ss89aPRMAoGnsyQAAeIWoqCgdPXpU06ZNU2xsrDp16qRTp07p4MGDMsY02r8BALAPy6UAAF5h06ZN+vWvf93oJKmG13/4wx80evRoGxMCABpQMgAAXmP37t1asmSJ8vLydPHiRQUEBCguLk5Tp05VYmKi3fEAAN+gZAAAvI7D4dDZs2cVEREhPz+2FwKAp+G/zAAAr+Pn56cPP/xQb731lt1RAABNYCYDAOCVYmJi5Ofnp/z8fLujAAAuw0wGAMBr8TkZAHgmSgYAAACAFkXJAAAAANCiuIwPAOCVXnnlFbsjAACawcZvAAAAAC2K5VIAAK/w9NNPKykpSZmZmW7jL7/8spKSkvTMM8/YEwwA0AglAwDgFXJycnTixAndcccdbuMjR45UUVGRcnJybEoGALgcJQMA4BX+8Y9/SJI6derkNt6xY0dJ0qlTp1o9EwCgaZQMAIBXCAoKkiTt3r3bbTw3N1eSFBwc3OqZAABN43QpAIBX6NOnj3bt2qUZM2ZowoQJuuGGG/T111/rpZdekjFGvXv3tjsiAOAbnC4FAPAKOTk5mjJliowxbuOWZckYo/T0dI0cOdKmdAAAVyyXAgB4hZEjR2rq1Kny8/OTZVnOr4CAAE2dOpWCAQAehJkMAIBXKSoq0o4dO1RaWqr27dtryJAhioqKsjsWAMAFJQMAAABAi2K5FADAK3AZHwB4D0oGAMArcBkfAHgPSgYAwCtwGR8AeA9KBgDAK3AZHwB4Dy7jAwB4BS7jAwDvwelSAACvwGV8AOA9WC4FAPAKXMYHAN6DmQwAgFfhMj4A8HyUDACA1zh8+LDee+89nThxQrW1tW7PjDFauHChTckAAK4oGQAAr7Bp0yb95je/kcPhaPY9hw4dasVEAIDmcLoUAMArpKenq76+3u4YAICrQMkAAHiF4uJiGWM0f/583XPPPc57MwAAnofTpQAAXqHhHozRo0dTMADAw1EyAABeIS0tTcHBwXr22WdVVVVldxwAwBWw8RsA4LGSkpLcXpeWlqq6ulr+/v7q0KGDAgL+uerXGKOcnJzWjggAaAJ7MgAAHquoqKjJ8YsXL+rUqVNuY5ffBA4AsA8lAwDgsQYMGGB3BADA98ByKQAAAAAtio3fAAAAAFoUJQMAAABAi6JkAAAAAGhRlAwAAAAALYqSAQAAAKBFcYQtgFb3xhtvaNasWc7X11xzjcLCwnTTTTfp9ttvV0pKitq2bfudv+/HH3+sHTt2aNy4cQoNDW3JyN9Ldna2QkJClJKSYncUAABaFSUDgG2mTp2qrl276uLFiyopKVFubq4WLlyozMxMZWRkKCYm5jt9v/3792vp0qUaM2aMR5SM1atXKyIigpIBAPA5lAwAthk2bJhiY2Odrx999FHt3LlTjz32mCZNmqRNmzYpODjYxoQAAOD7YE8GAI8yaNAgTZo0SUVFRXrrrbckSQUFBZo5c6aSkpIUGxurwYMHa9asWTp79qzz16Wnp2vx4sWSpKSkJN1000266aabdPz4cUnSX//6V6WmpmrQoEHq27ev7rrrLq1atarR73/w4EFNmDBBAwcOVL9+/TRixAi3pV2S5HA4lJmZqf/8z/9UbGysbrvtNs2dO1fl5eXO94wYMUJffPGFcnNznVkeeuihFv/zAgDAEzGTAcDj3HPPPfrDH/6gjz76SGPHjtX//d//qbCwUCkpKfrBD36gL774QmvWrNGXX36pNWvWyBijUaNG6ciRI3r77bc1a9YsRURESJLat28v6dLSpR49emjEiBEKCAjQ1q1bNX/+fFmWpQceeECSdObMGU2YMEERERH6+c9/rtDQUB0/flzvv/++W765c+dq/fr1SklJ0UMPPaTjx48rOztb+fn5Wr16tQIDA5WWlqYFCxbo2muv1WOPPSZJ6tixYyv+KQIAYB9KBgCPExkZqXbt2qmwsFCS9D//8z965JFH3N4TFxenJ554Qvv27VNCQoJiYmLUu3dvvf322xo5cqS6du3q9v7XXnvNbenVgw8+qAkTJujll192loz9+/ervLxcL730ktsyrscff9z5z3v37tXatWv13HPP6e6773aODxw4UD/72c+0efNm3X333Ro5cqSef/55RURE6J577mm5PxwAALwAy6UAeKRrr71WVVVVkuRWDmpqalRaWqqbb75ZkvTpp59e1fdz/R4VFRUqLS1VYmKiCgsLVVFRIUlq166dJGnbtm2qq6tr8vts3rxZ7dq10+DBg1VaWur86tOnj6699lrt3r37u//LAgDwb4aZDAAe6fz58+rQoYMkqaysTEuXLtWmTZt05swZt/c1FIRvs2/fPqWnp+uTTz7RhQsXGn2Pdu3aKTExUf/xH/+hpUuXKjMzU4mJiRo5cqTuvvtuXXPNNZKko0ePqqKiQoMGDWry97k8HwAAvoiSAcDjnDx5UhUVFYqOjpYkTZs2Tfv379eECRPUq1cvXXvttXI4HPrZz34my7K+9fsdO3ZM48eP1w033KCZM2eqc+fOCgwM1N///ndlZmbK4XBIkowxWrJkiT755BNt3bpVH374odLS0vTyyy/rf//3f9WmTRs5HA516NBBzz33XJO/V8MeEAAAfBklA4DH2bBhgyRpyJAhKi8v186dO/XLX/5SU6ZMcb7nyJEjjX6dMabJ7/fBBx+otrZWy5cvV1RUlHO8uaVNcXFxiouL0+OPP66NGzdq+vTp2rRpk+677z5FR0dr586dio+P/9bjdZvLAwDAvzv2ZADwKDt37lRGRoa6du2q//qv/5K/v3+T78vKymo0FhISIqnxEqqG7+E661FRUaG//vWvbu8rLy9vNDPSq1cvSVJtba0kafTo0aqvr1dGRkaj3//ixYs6d+6cWx7X1wAA+ApmMgDYZvv27fr6669VX1+vkpIS7d69Wzt27FBUVJSWL1+uoKAgBQUFacCAAVqxYoXq6urUqVMn7dixw3n/has+ffpIkv74xz/qrrvuUmBgoO644w4NHjxYgYGBeuyxx/STn/xEVVVVWrt2rTp06KDTp087f/369eu1evVqjRw5UtHR0aqqqtKaNWvUtm1bDRs2TJKUmJio+++/X3/+85916NAh5/c+cuSINm/erNmzZ+vOO+905lm9erUyMjLUrVs3tW/fvtm9HAAA/Dsx1tUsaAaAFvTGG2+4XXAXGBio8PBw9ezZU8OHD1dKSoratm3rfH7q1CktWLBAu3fvlmVZGjx4sGbPnq2hQ4dqypQp+uUvf+l8b0ZGhl5//XWdPn1aDodDW7ZsUdeuXfXBBx/o+eef15EjR9SxY0f99Kc/Vfv27ZWWluZ8T35+vl566SV9/PHHKikpUbt27dSvXz9NmTJFffv2dft3WLNmjV5//XV99dVX8vf3V5cuXTRs2DCNGzdO1113nSSppKREs2fP1p49e1RVVaXExES9+uqr/+I/XQAA7EfJAAAAANCi2JMBAAAAoEVRMgAAAAC0KEoGAAAAgBZFyQAAAADQoigZAAAAAFoUJQMAAABAi6JkAAAAAGhRlAwAAAAALYqSAQAAAKBFUTIAAAAAtChKBgAAAIAWRckAAAAA0KL+H8yVSkFfLj/EAAAAAElFTkSuQmCC\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAAjoAAALnCAYAAACA6O0xAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABmf0lEQVR4nO3deXQUVf7+8ae6E0jIAklUIJAgqOwgIIuogARQFIdNZeIgiDqoSMANFXBkRA9GnRlRAqiMw7B8kSgiq4wLiGRAZFEEBEGBgJBAlCxkIwvp/v3BLz3ELCSd0NVW3q9zOKmuulX9CbHxyb23bhlOp9MpAAAAC7KZXQAAAMClQtABAACWRdABAACWRdABAACWRdABAACWRdABAACWRdABAACWRdABAACWRdABAACW5WN2AbWZ0+mUw8HC1FZhsxn8PAEvxmfUOmw2Q4ZhVKotQcdEDodTaWk5ZpeBGuDjY1NISIAyM3N17pzD7HIA/AafUWsJDQ2Q3V65oMPQFQAAsCyCDgAAsCyCDgAAsCyCDgAAsCyCDgAAsCyCDgAAsCyCDgAAsCyvXEcnJSVFM2fOVEJCgrKyshQREaERI0Zo9OjRstnKz2ajRo3S9u3byz0+bNgwvfLKK67Xhw8f1syZM7V9+3bl5eXpqquu0n333aehQ4eWOnflypVauHChDh8+LD8/P3Xv3l1PPPGErrrqqmp9rwAA4NLxuqCTmpqq6OhoJScnu/YdPnxYsbGxSkxM1PTp092+dr169UpcMzo6WpmZma59+/fv17PPPqtffvlFDz30kGv/vHnz9I9//MP1Oj8/X59//rm2bdum+Ph4wg4AAF7K64au4uLiXCFnxowZ2rp1q/r27StJio+P1549e8o9d/HixTp48GCJP3/84x9dx//whz+4tl955RVlZmbKx8dH8+bN03//+1+1a9dOkjRr1iydOnVKknTy5EnNmjVLktSuXTslJCTon//8p3x8fJSZmVmihwgAAHgXrwo6DodDa9eulSQ1b95cd911l0JDQ/Xwww+72qxevbrS18vOztaaNWskSW3btlXnzp0lSWlpadq8ebMk6frrr1efPn10xRVX6IEHHpAkFRYW6pNPPpEkffLJJyosLJQkPfjgg2rYsKF69+6t66+/XpK0efNmpaWlVefbBgAAl4hXBZ3jx48rKytLktSiRQvX/gu39+/fX+nrrVq1Srm5uZKke+65x7X/wIEDcjgcFb7Pvn37Snz97fHmzZtLOh/ODh48WOmaAACA53jVHJ0Le0YCAwPL3E5NTa309eLj4yVJQUFBuuOOO6r0PsVt0tPTa7Sm3/Lx8aqsCTfZ7bYSXwF4Fz6jtZdXBZ3yOJ1O13ZlH8u+c+dO/fjjj5KkoUOHlpiIXJn3uRQ1/ZbNZigkJMCtc+GdgoP9zS4BQAX4jNY+XhV0QkNDXdvFQ1iSlJOTU2abirz33nuu7QuHrar6PiEhITVW0285HE5lZua6dS68i91uU3CwvzIzz6qoyGF2OQB+g8+otQQH+1e6d86rgk5ERISCg4OVmZmpxMRE1/4jR464ttu2bXvR66Smpuqzzz6TJPXo0aPU7d+tW7eWzWaTw+Eo932K78Bq166da0JzYmKi6/2Lz7PZbGrVqlWVvs8LnTvHB85Kiooc/EwBL8ZntPbxqsFKm82mQYMGSTofJJYvX660tDS98847rjaDBw+WJEVFRalVq1YaNWpUqet8+OGHrjul/vSnP5U6HhoaqptuukmStG3bNiUkJOiXX37R/PnzJUm+vr4aOHCgJGngwIHy9fWVJP3rX//SL7/8ooSEBH399deSpJtuusntHh0AAHBpeVWPjiRNmDBBmzZtUnJysqZOnVriWHR0tDp27Fjh+Q6HQ++//74k6YorrlD//v3LbDd58mR99913yszM1NixY0scmzhxoho1aiRJaty4sSZOnKh//OMf2rdvn3r16uVqFxwcrMmTJ1f5ewQAAJ7hdUEnLCxM8fHxev31112PgIiMjHQ9AuJiEhISlJSUJEkaMWKEfHzK/havuuoqxcfHV+oREA899JAuv/xyLVq0iEdA1GInThxXVlZmmcfsdptstiI5HPYKx/+DgoLVtGnEpSoRAPAbhrMqtxqhRhUVOZSWlnPxhjBdenq6+vW70bX+krvsdrvWr99cYpI7gEvPx8emkJAApafnMEfHAkJDA36fk5EBbxUSEqLVqz8tt0cnJeWk3n57th55JEYNGzYu9zpBQcGEHADwIIIOUEkVDTkFBQWqXr16uvrqa9S0aTMPVgUAqIhX3XUFAABQkwg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsgg6AADAsnzMLgDwBikpJ5WXl1et8yUpOTlJRUWOatXi5+enhg0bV+saAIDzDKfT6TS7iNqqqMihtLQcs8uo9VJSTmrKlKfMLqOE2Nh/EHaAGuTjY1NISIDS03N07lz1fhmB+UJDA2S3V25Qih4d1HrFPTljxz6q8PAmbl3DbrfJMM7J6fSpVo9OcnKS/vnPudXqXQIA/A9BB/j/wsObqFmz5m6dy2+LAOCdmIwMAAAsi6ADAAAsi6ADAAAsi6ADAAAsi6ADAAAsi6ADAAAsi6ADAAAsi6ADAAAsi6ADAAAsi6ADAAAsi6ADAAAsi6ADAAAsi6ADAAAsi6ADAAAsy8fsAn4rJSVFM2fOVEJCgrKyshQREaERI0Zo9OjRstkunssSExM1d+5cbd26VRkZGQoODlabNm302GOPqWPHjpKkVq1aVXiN2NhYDR8+XJI0atQobd++vcx2c+bMUf/+/av4HQIAAE/xqqCTmpqq6OhoJScnu/YdPnxYsbGxSkxM1PTp0ys8f+fOnRo7dqxyc3NLXHPz5s0aOHCgK+hcTL169dz7BgAAgFfxqqATFxfnCjkzZsxQVFSUpk6dqo0bNyo+Pl533nlnuWGloKBAkyZNUm5urho0aKAXX3xRN954o/Lz87Vr1y5dfvnlrrYHDx4sdf5tt92mI0eOKDg4WH369Cl1PCYmRhMmTKih7xQAAHiC18zRcTgcWrt2rSSpefPmuuuuuxQaGqqHH37Y1Wb16tXlnv/ZZ5/p5MmTkqSnn35at956qwIDAxUWFqb+/fvr2muvLffcrVu36siRI5KkYcOGyd/fvya+JQAAYDKvCTrHjx9XVlaWJKlFixau/Rdu79+/v9zzL5xH89NPP2nAgAHq0KGDBg0apBUrVlT43kuXLpUkGYahe+65p8w2ixcvVvv27dW5c2fde++92rRp08W/KQAAYCqvGbpKS0tzbQcGBpa5nZqaWu75xb05krRgwQLX9qFDhzR58mTl5eWVGWJ++eUXbdiwQZLUs2dPNW/evMzrnzlzRpJUWFioHTt2aMeOHfr73/+uP/zhDxf5zirm4+M1WbPWstttrq/u/jwuvIbZtQAoraY+o/j98ZqgUx6n0+naNgyj3HZFRUWu7fbt22vevHk6deqURo4cqbNnz2r27NmKjo4udY1ly5bp3LlzklRmEBo4cKAeffRRtWnTRoZhaPHixYqLi5MkzZw5s1pBx2YzFBIS4Pb5qBmpqX6SpKAgv2r/PIKDqzfsWZO1ACitup9R/P54TdAJDQ11bRcPYUlSTk5OmW1+q0GDBq7tIUOGKCwsTGFhYerWrZsSEhJ0+vRpnT59usSk5KKiIn3wwQeSpIYNGyoqKqrUdUeOHFnidUxMjNasWaOjR48qKSlJaWlpFdZVEYfDqczM3Is3xCWVlZXn+pqennOR1mWz220KDvZXZuZZFRU5TK0FQGk19RmFdwgO9q9075zXBJ2IiAgFBwcrMzNTiYmJrv3Fk4QlqW3btuWe36ZNG3388ccVvoefn1+J1xs3btSpU6ckSSNGjJCPT8m/DofDUebaPRX1LFXVuXN84MxW/I9eUZGj2j+P6l6jJmsBUBqfrdrHawYrbTabBg0aJOn8on/Lly9XWlqa3nnnHVebwYMHS5KioqLUqlUrjRo1ynVs4MCBrqCyatUqpaamat++fdqxY4ek80EoKCioxHsWT0L29fXViBEjStV08OBB3X///dq0aZOys7N15swZzZ492xXErrzySrd7cwAAwKXnNT06kjRhwgRt2rRJycnJmjp1aolj0dHRFS74FxERoXHjxikuLk7ff/+9brjhBtcxX19fPfvssyXaHzt2TFu2bJEk9evXT1dccUWZ1/3qq6/01Vdfldrv4+NTqkYAAOBdvCrohIWFKT4+Xq+//rrrERCRkZGuR0BcTExMjBo3bqzFixfr8OHDqlOnjjp37qyYmBh16tSpRNv4+HjXROc//elPZV4vIiJCkyZN0qZNm3T06FGlp6crKChIXbp00SOPPFLplZYBAIA5DOeFtzXBo4qKHEpLY8Kp2Y4dS9T06c/pr3+doWbNyl5e4GJ8fGwKCQlQenpOtcb/a6IWAKXV1GcU3iE0NKDSk5G9Zo4OAABATSPoAAAAy/KqOTqAWYKCglRQkK/s7KyLNy6D3W7IMAqVlXVWRUXujwYXFOSXujsQAOA+5uiYiDk63uHIkUNKTj5a5ppJZnA4HAoPv1ItWlxtdimAZTBHx1qqMkeHHh3Uena7XcuWLVNMzBNq3LiJm9cwLlh11f3fHU6eTNLs2TP15JOT3b4GAOB/CDqAzj92pE6dugoMdG/YyMfHpgYNAuR0+lbrt8U6deqWeAQKAKB6vKOvHgAA4BIg6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMsi6AAAAMvyMbuA30pJSdHMmTOVkJCgrKwsRUREaMSIERo9erRstovnssTERM2dO1dbt25VRkaGgoOD1aZNGz322GPq2LGjJOmjjz7SlClTyjy/X79+mjt3bol9mzZt0ltvvaUDBw7IZrOpU6dOmjhxojp16lTt7xcAAFw6XhV0UlNTFR0dreTkZNe+w4cPKzY2VomJiZo+fXqF5+/cuVNjx45Vbm5uiWtu3rxZAwcOdAWdqli7dq0mTZokp9Pp2rdlyxbt2LFD8+fPV7du3ap8TQAA4BleNXQVFxfnCjkzZszQ1q1b1bdvX0lSfHy89uzZU+65BQUFmjRpknJzc9WgQQPNmjVL33zzjb766ivNmTNHLVu2LHVOkyZNdPDgwRJ/LuzNycvL00svvSSn06nw8HB99tln+vDDDxUUFKSCggK98MILNfsXAAAAapTXBB2Hw6G1a9dKkpo3b6677rpLoaGhevjhh11tVq9eXe75n332mU6ePClJevrpp3XrrbcqMDBQYWFh6t+/v6699toq15SQkKCMjAxJ0j333KNmzZqpQ4cOuv322yVJhw4d0v79+6t8XQAA4BleM3R1/PhxZWVlSZJatGjh2n/hdkWhYvv27a7tn376SQMGDNCpU6cUGRmpP//5zxo2bFipc3755Rf16NFDOTk5atKkiW6//XaNGzdOderUkSTt27evzDou3N63b5/atm1blW+1BB8fr8matZbdbnN9dffnceE1zK4FQGk19RnF74/XBJ20tDTXdmBgYJnbqamp5Z5f3JsjSQsWLHBtHzp0SJMnT1ZeXp7uueeeEucUFha6emyOHj2quXPnas+ePfrXv/4lSUpPT3e1DQgIKHP7wrqrymYzFBIScPGGuKRSU/0kSUFBftX+eQQH+3tNLQBKq+5nFL8/XhN0ynPhJGDDMMptV1RU5Npu37695s2bp1OnTmnkyJE6e/asZs+erejoaBmGoWbNmmnGjBnq2bOnwsLCtHv3bj355JM6ffq0Nm/erG3btqlHjx6Vqq+imi7G4XAqMzP34g1xSWVl5bm+pqfnuHUNu92m4GB/ZWaeVVGRw9RaAJRWU59ReIfgYP9K9855TdAJDQ11bRcPYUlSTk5OmW1+q0GDBq7tIUOGKCwsTGFhYerWrZsSEhJ0+vRpnT59Wpdffrmuu+46XXfdda72PXr00OjRo/X6669Lkvbu3asePXooJCTE1SY7O7vMmi5s445z5/jAma34H72iIke1fx7VvUZN1gKgND5btY/XDFZGREQoODhY0vm1cIodOXLEtV3RXJg2bdpc9D38/M4PCzgcpf8jv7Bnpni7Xbt2rn3l1XRhGwAA4F28JujYbDYNGjRI0vlQsXz5cqWlpemdd95xtRk8eLAkKSoqSq1atdKoUaNcxwYOHCgfn/MdVKtWrVJqaqr27dunHTt2SDofhIKCgiRJ48aN06JFi5ScnKz8/Hxt27ZNCxcudF2rS5cukqTevXu7eoqWLl2qY8eOae/evVq3bp0k6eqrr67WRGQAAHBpec3QlSRNmDBBmzZtUnJysqZOnVriWHR0dIUL/kVERGjcuHGKi4vT999/rxtuuMF1zNfXV88++6zr9alTpzRjxgzNmDGj1HXuuOMOde7cWdL5HqDnn39ekyZNUnJysm655RZXuzp16rCODgAAXs6rgk5YWJji4+P1+uuvux4BERkZ6XoExMXExMSocePGWrx4sQ4fPqw6deqoc+fOiomJKfG4hokTJ+rjjz/W3r179csvv8gwDLVo0UJ33nlnqTuz7rjjDgUFBfEICAAAfoe8KuhIUsOGDfXqq69W2OaLL74o99idd96pO++8s8Lz+/Xrp379+lW6pj59+qhPnz6Vbg8AALyD18zRAQAAqGkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFkEHQAAYFk+ZhcAAEB1nThxXFlZmeUet9ttstmK5HDYVVTkKLddUFCwmjaNuBQlwiQEHQDA71p6eroGD75VDkf5Aaay7Ha71q/frJCQkBqoDN6AoAMA+F0LCQnR6tWfVtijk5JyUm+/PVuPPBKjhg0bl9suKCiYkGMxBB0AwO/exYabgoICVa9ePV199TVq2rSZh6qCNyDoAP/fsWNH3T7Xbrfp2LFzcjp9Khz/v5jk5CS3zwUAlEbQQa1XVFQkSVqw4J8mV/I/fn5+ZpcAAJZA0EGt16LF1frLX16U3W53+xqVHf+vDD8/v2pfAwBwHkEH0PmwUx12+/klqcLDmzD+DwBehAUDAQCAZRF0AACAZRF0AACAZRF0AACAZXndZOSUlBTNnDlTCQkJysrKUkREhEaMGKHRo0fLZrt4LktMTNTcuXO1detWZWRkKDg4WG3atNFjjz2mjh07SpK++OILffzxx/r+++/166+/ym63KzIyUn/60580bNiwEu8zefJkrVixosz3mjJlisaMGVMj3zcAAKh5XhV0UlNTFR0dreTkZNe+w4cPKzY2VomJiZo+fXqF5+/cuVNjx45Vbm5uiWtu3rxZAwcOdAWdJUuWaPPmzSXO/f777zV16lR9//33+utf/1qD3xUAADCLVw1dxcXFuULOjBkztHXrVvXt21eSFB8frz179pR7bkFBgSZNmqTc3Fw1aNBAs2bN0jfffKOvvvpKc+bMUcuWLV1t69atqzFjxmjt2rXavXu33nzzTfn4nM98S5cuVWpqaqnrDxs2TAcPHizxh94cAAC8W6WDzi+//KKBAwfqjTfeqLDdzJkzddttt5UZFiricDi0du1aSVLz5s111113KTQ0VA8//LCrzerVq8s9/7PPPtPJkyclSU8//bRuvfVWBQYGKiwsTP3799e1117ravvaa69pypQpuuaaa+Tn56eBAweqV69ekiSn06mff/65SrUDAADvVOmhq0WLFunMmTMaO3Zshe3Gjh2rZcuWafHixXr88ccrXcjx48eVlZUlSWrRooVr/4Xb+/fvL/f87du3u7Z/+uknDRgwQKdOnVJkZKT+/Oc/a9iwYa7jgYGBpc7Pz893bTds2LDU8c8//1z/+c9/JEnXXHON7r33Xg0dOrQS31nFfHy8qlMNbrLZDNdXfqaA9+EzWntVOuhs2rRJgwYNUkBAQIXtAgMDdccdd+iLL76oUtBJS0srcY2ytivqJSruzZGkBQsWuLYPHTqkyZMnKy8vT/fcc0+Z5+7YsUNff/21JOmGG25QeHh4qTbZ2dmu7b179+rZZ59VSkpKiR6nqrLZDIWEVPz3id+H1NS6kqSAgLr8TAEvxGe09qp00Pn55581evToSrW95ppr9MEHH7hd1IWcTqdr2zCMctsVP5hRktq3b6958+bp1KlTGjlypM6ePavZs2crOjq61DX27Nmj8ePHy+FwqGHDhoqNjS1xvGfPnrr11lvVoUMH+fn56T//+Y+mTZsmh8OhuXPnavTo0fL393fre3M4nMrMzL14Q3i9nJx819f09ByTqwHwW3xGrSU42N/16J2LqXTQsdlsKiwsrFTbwsLCCkNJWUJDQ13bxUNYkpSTk1Nmm99q0KCBa3vIkCEKCwtTWFiYunXrpoSEBJ0+fVqnT5/W5Zdf7mr37bffauzYscrOztYVV1yhBQsWqFGjRiWuO2TIkBKv7777bn3yySfavHmz8vLy9NNPP7nu5nLHuXMOt8+F93A4nK6v/EwB78NntPaq9EBlZGSkvvnmm0q1/fbbbxUZGVmlQiIiIhQcHCzp/Fo4xY4cOeLabtu2bbnnt2nT5qLv4efn59revn27HnzwQWVnZ6tJkyZ67733SswHks73Jl3Yo1SWqgY6AADgOZUOOgMGDNCnn36qXbt2Vdjuu+++0yeffKIBAwZUrRCbTYMGDZJ0PugsX75caWlpeuedd1xtBg8eLEmKiopSq1atNGrUKNexgQMHum4RX7VqlVJTU7Vv3z7t2LFD0vkgFBQUJEnasmWLa72dK6+8Uu+9954iIiJK1ZSVlaW7775b//nPf5SRkaHs7GwtW7ZMX331laTz84cuvG0dAAB4l0oPXY0ZM0YrVqzQAw88oHHjxmnIkCEl7k5KSUnRqlWr9Pbbb6thw4ZurTEzYcIEbdq0ScnJyZo6dWqJY9HR0RUOEUVERGjcuHGKi4vT999/rxtuuMF1zNfXV88++6zr9dtvv628vDxJ0tGjR9WnT58S14qNjdXw4cMlnZ94XN6k6meeeUZ169at0vcIAAA8p9JBJzAwUAsWLFBMTIxef/11zZw5U0FBQQoICFBOTo6ysrLkdDrVsmVLzZ49u8xbuC8mLCxM8fHxev31112PgIiMjHQ9AuJiYmJi1LhxYy1evFiHDx9WnTp11LlzZ8XExKhTp05VrqdevXp6/vnntXHjRh06dEipqany9/dXhw4ddP/997vW3gEAAN7JcF5sEspvFBUV6dNPP9WGDRuUmJio7OxsBQYGqnnz5oqKitKtt97qGkJCxYqKHEpLY/a/FZw4cUzTpk3Riy/GqmnTZmaXA+A3+IxaS2hoQM3fdVXMbrfr9ttv1+23317lwgAAADyJ5SEBAIBlVbpHp6I5MoZhqG7dugoPD1efPn1cD+IEAAAwU6WDTlpaWoVrxpw9e1ZfffWV3n//fd10002aO3eufH19a6RIAAAAd1Q66BQ/WbwieXl5io+P1yuvvKJ3331X48aNq1ZxAAAA1VGjc3T8/Pw0ZswYDRo0qFLBCAAA4FK6JJORu3TpohMnTlyKSwMAAFTaJQk6Z8+eld1uvxSXBgAAqLQaDzpOp1NffPEFz4ACAACmq/Rk5IyMjAqP5+fn68iRI1q6dKl27dqlv/3tb9WtDQAAoFoqHXSuv/76Cm8vd13Qx0ePPfaY7rjjjmoVBgAAUF2VDjrjx4+vMOjUqVNHTZo0Uc+ePRUaGlojxQEAAFRHpYPOhAkTLmUdAAAANa7GJyMXFhZq/fr1mjhxYk1fGgAAoEqq/PTy8mzfvl1r1qzRZ599pjNnzsjf37+mLg0AAOCWagWdAwcOaM2aNfr444+VkpKiyy67TLfeequioqLUs2fPmqoRAADALVUOOsnJyVq7dq3WrFmjQ4cOKTQ0VD169NB//vMfPf/887rlllsuRZ0AAABVVumgEx8frzVr1ujbb79VUFCQBgwYoClTpuj666/X8ePHtW7duktZJwAAQJVVOui88MILatq0qeLi4tSnTx/5+vq6jlVmfR0AAABPq/RdV+3bt9eJEyf0wgsv6NVXX9WuXbsuZV0AAADVVukenQ8//FDHjh3TqlWr9PHHH+v//u//FB4erttvv10dOnS4lDUCAAC4pUrr6DRr1kwTJ07Up59+qvfff199+/bVRx99pMcee0yGYejTTz/Vt99+K6fTeanqBQAAqDS3by+/9tprde2112rq1KnavHmz1qxZow0bNmjdunVq0KCBbr75ZsXGxtZkrQAAAFVS7ZWR7Xa7+vTpo7///e/66quv9Morr6hdu3Zas2ZNTdQHAADgthpbGVmS/P39NWTIEA0ZMkRpaWk1eWkAAIAqq/FnXRXjCeYAAMBslyzoAAAAmI2gAwAALIugAwAALIugAwAALKvSQcfhcGjevHlauXJlhe1WrlypefPmVbcuAACAaqt00Fm5cqXeeOMNXXPNNRW2u/rqq/XGG29o9erV1S4OAACgOiq9js6aNWvUp08ftWvXrsJ27du3V1RUlFauXKnBgwdXu0AAQO2WknJSeXl51b6GJCUnJ6moyOH2dfz8/NSwYeNq1QLPqnTQ2b9/v8aPH1+ptt27d9ecOXPcLgoAAOl8QJky5akau97bb8+u9jViY/9B2PkdqXTQyc3NVUBAQKXaBgQEKDc31+2iAACQ5OrJGTv2UYWHN3H7Ona7TYZxTk6nj9s9OsnJSfrnP+dWu3cJnlXpoBMWFqZjx45Vqu2xY8dYGRkAUGPCw5uoWbPmbp/v42NTSEiA0tNzdO6c+0NX+P2p9GTkrl27atWqVTp79myF7XJzc7Vq1Sp179692sUBAABUR6WDzoMPPqjTp0/roYceUkpKSpltUlJS9Mgjj+j06dN64IEHaqxIAAAAd1R66KpNmzZ64YUX9MILL6hfv37q1q2bWrZsqYCAAOXk5OjHH3/Ujh075HQ6NW3aNLVp0+ZS1g0AAHBRlQ46knT33Xfrmmuu0ezZs/X1119r69at/7uQj4969OihmJgYde7cucYLBQAAqKoqBR1J6tSpk959913l5eXp2LFjys7OVmBgoJo1ayY/Pz9Xu+L9AAAAZqly0Cnm5+enVq1aldqfmpqqhQsXaunSpdqxY0e1igMAAKiOKgWd1NRUrVy5Uj///LPq16+vW265Re3bt5d0fiLyW2+9pRUrVig/P5+7rgAAgOkqHXQOHz6se++9VxkZGXI6nZKkd999V3/7299kGIaee+45FRQU6JZbbtGDDz7oCkAAAABmqXTQefPNN5Wbm6u//vWv6tq1q06cOKHY2Fi9/PLLysrKUt++fTVp0iRFRERcynoBAAAqrdJBZ+fOnbrnnnsUHR0t6fxTyu12u8aOHathw4YpNjb2khUJAADgjkovGJiRkVFq8nHr1q0lSf3796/ZqgAAAGpApYOOw+GQj0/JDqDi1/Xq1avZqgAAAGpAle66+v7771W3bl3X65ycHBmGoW+++UZZWVml2t9yyy1VLiglJUUzZ85UQkKCsrKyFBERoREjRmj06NGy2S6eyxITEzV37lxt3bpVGRkZCg4OVps2bfTYY4+pY8eObr3Ppk2b9NZbb+nAgQOy2Wzq1KmTJk6cqE6dOlX5+wMAAJ5TpaCzcOFCLVy4sNT+2bNnl9pnGIZ++OGHKhWTmpqq6OhoJScnu/YdPnxYsbGxSkxM1PTp0ys8f+fOnRo7dqxyc3NLXHPz5s0aOHCgK+hU5X3Wrl2rSZMmue40k6QtW7Zox44dmj9/vrp161al7xEAAHhOpYPOokWLLmUdkqS4uDhX+JgxY4aioqI0depUbdy4UfHx8brzzjtL9MpcqKCgQJMmTVJubq4aNGigF198UTfeeKPy8/O1a9cuXX755VV+n7y8PL300ktyOp0KDw/XggULlJmZqfvvv19ZWVl64YUX9PHHH1/yvxcAAOCeSgedS70AoMPh0Nq1ayVJzZs311133SVJevjhh7Vx40ZJ0urVq8sNOp999plOnjwpSXr66ad16623SpICAwNLTJauyvskJCQoIyNDknTPPfeoWbNmkqTbb79d77//vg4dOqT9+/erbdu2Nfb3AAAAak6Vhq7y8/O1YcMGnThxQg0aNNDNN9+sK664okYKOX78uGueT4sWLVz7L9zev39/uedv377dtf3TTz9pwIABOnXqlCIjI/XnP/9Zw4YNq/L77Nu3r8zjF27v27evWkHHx6fS88HhxWw2w/WVnylQc+x2m+trdT5bF17H7FrgWZUOOsXzWk6cOOGar+Lv7685c+bohhtuqHYhaWlpru0LHwZ64XZqamq55xf35kjSggULXNuHDh3S5MmTlZeXp3vuuadK75Oenu7aFxAQUOb2hderKpvNUEhIwMUbwuulpp6fpB8QUJefKVCDUlPPPyw6KMivRj5bwcH+XlMLPKPSQWfu3LlKSkrSmDFjdP311+vYsWOaO3eupk2bpvXr11+yAi+cBGwYRrntioqKXNvt27fXvHnzdOrUKY0cOVJnz57V7NmzXYsdVud9fqsqbX/L4XAqMzP34g3h9XJy8l1f09NzTK4GsI6srDzX1+p8tux2m4KD/ZWZeVZFRQ5Ta0H1BQf7V7p3rtJBZ/PmzRoyZIieffZZ177LLrtMTz31lI4cOVJiOMcdoaGhru0Lb1XPyckps81vNWjQwLU9ZMgQhYWFKSwsTN26dVNCQoJOnz6t06dPV+l9QkJCXPuys7PLbHthG3ecO+feBw7exeFwur7yMwVqTnEoKSpy1MhnqzrXqela4BmVHmQ8efKkrrvuuhL7rrvuOjmdzgqHlCorIiJCwcHBks6vhVPsyJEjru2K5sK0adPmou/h5+dXpfdp166da195bS9sAwAAvEulg05BQUGJxQIlqU6dOpKkc+fOVb8Qm02DBg2SdD5ULF++XGlpaXrnnXdcbQYPHixJioqKUqtWrTRq1CjXsYEDB7pWal61apVSU1O1b98+7dixQ9L5IBQUFFSl9+ndu7erp2jp0qU6duyY9u7dq3Xr1kk6/7wv7rgCAMB7Vemuq6SkpBJ3IhUP/Rw7dszVS3KhqvZ2TJgwQZs2bVJycrKmTp1a4lh0dHS5t5ZL53uExo0bp7i4OH3//fclJkj7+vqWGHKr7Pv4+fnp+eef16RJk5ScnFxipec6derohRdeqNL3BwAAPKtKQefNN9/Um2++WWr/b1csdjqdbq2MHBYWpvj4eL3++uuuRzNERka6Hs1wMTExMWrcuLEWL16sw4cPq06dOurcubNiYmJKPK6hKu9zxx13KCgoiEdAAADwO1TpoBMbG3sp63Bp2LChXn311QrbfPHFF+Ueu/POO3XnnXfWyPsU69Onj/r06VOptgAAwHtUOugUL7gHAADwe8HSjgAAwLIIOgAAwLIIOgAAwLIIOgAAwLIIOgAAwLIIOgAAwLIIOgAAwLIIOgAAwLIIOgAAwLIIOgAAwLIIOgAAwLIIOgAAwLIIOgAAwLIIOgAAwLIIOgAAwLIIOgAAwLIIOgAAwLJ8zC4A+L04ceK4srIyyzyWknJSubm5OnToJ2VlZZd7jaCgYDVtGnGpSgQA/AZBB6iE9PR0DR58qxwOR4XtHn88psLjdrtd69dvVkhISE2WBwAoB0EHqISQkBCtXv1puT06drtNNluRHA67iorKD0NBQcGEHADwIIIOUEkVDTn5+NgUEhKg9PQcnTtXca8PAMBzmIwMAAAsi6ADAAAsi6ADAAAsi6ADAAAsi6ADAAAsi6ADAAAsi6ADAAAsi3V0AABeLSgoSAUF+crOznL7Gna7IcMoVFbWWRUVOd26RkFBvoKCgtyuAeYwnE6nez9xVFtRkUNpaTlml4EawIKBwKVx5MghJScflc3mHQMQDodD4eFXqkWLq80upVYLDQ2Q3V65/ybo0QEAeC273a5ly5YpJuYJNW7cpBrXMRQc7K/MTPd7dE6eTNLs2TP15JOT3a4DnkfQAQB4taysLNWpU1eBge4PG/n42NSgQYCcTl+3e13r1KmrrCz3h89gDu/oCwQAALgECDoAAMCyCDoAAMCyCDoAAMCyCDoAAMCyCDoAAMCyCDoAAMCyCDoAAMCyCDoAAMCyCDoAAMCyCDoAAMCyCDoAAMCyCDoAAMCyCDoAAMCyCDoAAMCyfMwuoCwpKSmaOXOmEhISlJWVpYiICI0YMUKjR4+WzVZ+Njtx4oT69etX5rGgoCDt3Lnzou2KLVq0SD169JAkRUVFKSkpqcx2K1euVJs2bSrzbQEAAA/zuqCTmpqq6OhoJScnu/YdPnxYsbGxSkxM1PTp0z1SR7169TzyPgAA4NLxuqATFxfnCjkzZsxQVFSUpk6dqo0bNyo+Pl533nmnOnbseNHrbNiwQU2bNi3zWNOmTXXw4MES+/Ly8tSrVy9lZmaqefPm6tChQ6nzYmNjNXz4cDe+KwAAYAavmqPjcDi0du1aSVLz5s111113KTQ0VA8//LCrzerVqy/Je69du1aZmZmSpHvuueeSvAcAAPAsr+rROX78uLKysiRJLVq0cO2/cHv//v2Vutbdd9+tzMxMhYSEqFevXnr88cfVsGHDctsvXbpUkuTv719ur82rr76qadOmyd/fX506ddKjjz6qzp07V6qe8vj4eFXWhJvsdluJrwBqxoWfrer8e1kTn9GaqgWe5VVBJy0tzbUdGBhY5nZqamqVrvXrr7/qo48+0pYtW7Ry5UqFhoaWart37159//33kqQ77rhDQUFBZV4zIyNDklRYWKiEhARt3bpV//73v9WtW7dK1fRbNpuhkJAAt86FdwoO9je7BMBSUlP9JElBQX418u9ldT6jNV0LPMOrgk55nE6na9swjHLb1atXT0899ZT69u2riIgIJSUl6bnnntOuXbuUkpKiJUuWaMKECaXOK+7NkcoetoqOjlbXrl3VsmVL5eXladasWXr//fdVWFioWbNmafHixW59Xw6HU5mZuW6dC+9it9sUHOyvzMyzKipymF0OYBlZWXmur+npOW5fpyY+ozVVC6ovONi/0r1zXhV0LuxtKR7CkqScnJwy25R1/kMPPeR6fdVVV+nZZ59VdHS0pPM9N7+VmZmpdevWSZKuvfZatWvXrlSbC68ZGBioadOmafXq1Tp79myZ16yKc+f4n6KVFBU5+JkCNag4lNTUZ6s616npWuAZXjXIGBERoeDgYElSYmKia/+RI0dc223bti33fIej9H94F/YAldUb9NFHH+ns2bOSpD/96U+VvmbxtSrqYQIAAObyqqBjs9k0aNAgSeeDzvLly5WWlqZ33nnH1Wbw4MGSzi/i16pVK40aNcp17I033tCrr76qgwcPqqCgQIcPH9Yrr7ziOt6lS5dS7xkfHy9JatCggW677bZSx7/44gs99thj2rZtm86ePavTp09r+vTpys3NLfeaAADAO3jV0JUkTZgwQZs2bVJycrKmTp1a4lh0dHSFa+icPXtWixYt0vz580sda9GihUaOHFli39atW109R3feeafq1q1b5nU/+eQTffLJJ6X2F88JAgAA3snrgk5YWJji4+P1+uuvux4BERkZ6XoEREWGDx+uoqIibd++XadOnVJeXp7Cw8PVr18/jRs3rsTdW9L/JiEbhlHu2jmdOnVSTEyM/vvf/+r48eOuW9Z79Oih8ePHl7j1HQAAeBevCzqS1LBhQ7366qsVtvniiy9K7WvTpo2mTZtW6feZNWvWRdtcdtllmjBhQpl3awEAAO/mVXN0AAAAahJBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWBZBBwAAWJaP2QUAAHAxx44drdb5drtNx46dk9Ppo6Iih1vXSE5OqlYNMAdBBwDgtYqKiiRJCxb80+RK/sfPz8/sElAFhtPpdJpdRG1VVORQWlqO2WWgBvj42BQSEqD09BydO+feb4sAynbkyCHZ7fZqXSMl5aTefnu2HnkkRg0bNnb7On5+ftU6HzUjNDRAdnvlZt/QowMA8GotWlxd7WsU/08xPLyJmjZtVu3r4feDycgAAMCyCDoAAMCyCDoAAMCyCDoAAMCyvHIyckpKimbOnKmEhARlZWUpIiJCI0aM0OjRo2WzlZ/NTpw4oX79+pV5LCgoSDt37nS9jouL0+zZs8tsO3r0aD333HMl9q1cuVILFy7U4cOH5efnp+7du+uJJ57QVVdd5cZ3CAAAPMHrgk5qaqqio6OVnJzs2nf48GHFxsYqMTFR06dP93hN8+bN0z/+8Q/X6/z8fH3++efatm2b4uPjCTsAAHgprxu6iouLc4WcGTNmaOvWrerbt68kKT4+Xnv27KnUdTZs2KCDBw+6/lzYm3Oh7t27l2h38ODBEr05J0+e1KxZsyRJ7dq1U0JCgv75z3/Kx8dHmZmZeuWVV6rz7QIAgEvIq4KOw+HQ2rVrJUnNmzfXXXfdpdDQUD388MOuNqtXr/ZoTZ988okKCwslSQ8++KAaNmyo3r176/rrr5ckbd68WWlpaR6tCQAAVI5XBZ3jx48rKytLktSiRQvX/gu39+/fX6lr3X333WrXrp1uuukmTZkyRSkpKWW227t3r7p06aIOHTroD3/4gxYsWCCH438r2+7bt6/MOpo3by7pfDg7ePBgpWoCAACe5VVzdC7sGQkMDCxzOzU1tUrX+vXXX/XRRx9py5YtWrlypUJDQ0u0O3v2rGv7xx9/VGxsrI4cOaIXX3xRkpSenl5jNZXFx8ersibcVLzqamWXJAfgWTab4frKv7u1i1cFnfJc+DguwzDKbVevXj099dRT6tu3ryIiIpSUlKTnnntOu3btUkpKipYsWaIJEyZIOj/fZubMmbruuusUFBSkr776Sk899ZTy8vL0wQcfaOzYsYqIiKh2TRWx2QyFhAS4dS68U3Cwv9klAChDampdSVJAQF3+3a1lvCroXNjbUjyEJUk5OTlltinr/Iceesj1+qqrrtKzzz6r6OhoSeeHqYpFRUWVOLd///4aMmSI3n//fTmdTn3//feKiIhQSEhItWqqiMPhVGZmrlvnwrvY7TYFB/srM/Osiop4qCfgbXJy8l1f09N5mPLvXXCw/+/zoZ4REREKDg5WZmamEhMTXfuPHDni2m7btm255zscjlLr7FzY23LhdlltyzqvXbt2WrNmjSQpMTHR9f7F9dlsNrVq1eqi31t5eNK1tRQVOfiZAl7I4XC6vvIZrV28aqDSZrNp0KBBks4HieXLlystLU3vvPOOq83gwYMlne+RadWqlUaNGuU69sYbb+jVV1/VwYMHVVBQoMOHD5e4/btLly6u7ejoaC1fvly//vqrzp49q/Xr12vVqlWSJLvdrmuvvVaSNHDgQPn6+kqS/vWvf+mXX35RQkKCvv76a0nSTTfd5HaPDgAAuLS8qkdHkiZMmKBNmzYpOTlZU6dOLXEsOjpaHTt2LPfcs2fPatGiRZo/f36pYy1atNDIkSNdr48cOVLq+sXGjh2rxo0bS5IaN26siRMn6h//+If27dunXr16udoFBwdr8uTJVfr+AACA53hd0AkLC1N8fLxef/111yMgIiMjXY+AqMjw4cNVVFSk7du369SpU8rLy1N4eLj69euncePGlbhT6i9/+Ys+++wzHThwQL/++qt8fX3VunVr/elPf9Idd9xR4roPPfSQLr/8ci1atIhHQAAA8DtiOC+8fQgeVVTkUFoak+KswMfHppCQAKWn5zD+D3ihEyeOadq0KXrxxVg1bdrM7HJQTaGhAZWejOxVc3QAAABqEkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYFkEHAABYlo/ZBfxWSkqKZs6cqYSEBGVlZSkiIkIjRozQ6NGjZbOVn8tOnDihfv36lXksKChIO3fudL1euXKlNmzYoP379ys1NVV+fn5q0aKFHnjgAfXv37/EuaNGjdL27dvLvO6cOXNKtQcAAN7Dq4JOamqqoqOjlZyc7Np3+PBhxcbGKjExUdOnT6+R93n77beVmJjoen327Fl98803+uabb/T000/rz3/+c428DwAAMJdXBZ24uDhXyJkxY4aioqI0depUbdy4UfHx8brzzjvVsWPHi15nw4YNatq0abnHg4KCNGHCBA0ePFiXXXaZPvroI7300kuSzoegMWPGyMen5F9NTEyMJkyYUI3vDgBwqZw4cVxZWZnlHk9JOanc3FwdOvSTsrKyy20XFBSspk0jLkWJMInXBB2Hw6G1a9dKkpo3b6677rpLkvTwww9r48aNkqTVq1dXKuhczL///W8FBga6Xt977716//339eOPPyorK0tpaWm64oorqv0+AIBLLz09XYMH3yqHw3HRto8/HlPhcbvdrvXrNyskJKSmyoPJvCboHD9+XFlZWZKkFi1auPZfuL1///5KXevuu+9WZmamQkJC1KtXLz3++ONq2LCh6/iFIadYfn6+JKlu3bpq0KBBqeOLFy/WO++8I19fX7Vr105jx45Vnz59KlUPAODSCQkJ0erVn1bYo2O322SzFcnhsKuoqPxAFBQUTMixGK8JOmlpaa7tC4PIhdupqalVutavv/6qjz76SFu2bNHKlSsVGhpaZvtVq1bp2LFjkqTBgwerTp06pdqcOXNGklRYWKgdO3Zox44d+vvf/64//OEPlaqpPD4+3PhmBXa7rcRXAJ515ZXNKjxut9sUHOyvzMyzFQYdWI/XBJ3yOJ1O17ZhGOW2q1evnp566in17dtXERERSkpK0nPPPaddu3YpJSVFS5YsKXOOzZdffqm//OUvkqSWLVtq8uTJJY4PHDhQjz76qNq0aSPDMLR48WLFxcVJkmbOnFmtoGOzGQoJCXD7fHif4GB/s0sAUAE+o7WP1wSdC3tbioewJCknJ6fMNmWd/9BDD7leX3XVVXr22WcVHR0tSdq7d2+pcz7//HM98cQTKiws1NVXX11q7o4kjRw5ssTrmJgYrVmzRkePHlVSUpLS0tIqrKsiDodTmZm5bp0L78Jvi4B34zNqLcHB/pXuQfeaoBMREaHg4GBlZmaWuPX7yJEjru22bduWe77D4Si1zs6FPUC/7Q36+OOP9cwzz+jcuXNq27at/vWvf5UKLGVds6xrVce5c3zgrKSoyMHPFPBifEZrH6+ZUGCz2TRo0CBJUmJiopYvX660tDS98847rjaDBw+WJEVFRalVq1YaNWqU69gbb7yhV199VQcPHlRBQYEOHz6sV155xXW8S5curu2VK1fq6aef1rlz59S5c2ctWrSozF6ZgwcP6v7779emTZuUnZ2tM2fOaPbs2a4gduWVV7rdmwMAAC49r+nRkaQJEyZo06ZNSk5O1tSpU0sci46OrvDW8rNnz2rRokWaP39+qWMtWrQoMQQ1a9YsFRUVSZJ27dqlrl27lmi/aNEi9ejRQ5L01Vdf6auvvip1TR8fn1I1AgAA7+JVQScsLEzx8fF6/fXXXY+AiIyMdD0CoiLDhw9XUVGRtm/frlOnTikvL0/h4eHq16+fxo0bV+Yt5RcTERGhSZMmadOmTTp69KjS09MVFBSkLl266JFHHqmRNX0AAMClYzgvvK0JHlVU5FBaWs7FG8Lr+fjYFBISoPT0HMb/AS/EZ9RaQkMDKj0Z2Wvm6AAAANQ0gg4AALAsgg4AALAsgg4AALAsgg4AALAsgg4AALAsgg4AALAsgg4AALAsgg4AALAsgg4AALAsgg4AALAsnnVlIqfTKYeDv36rsNttKiriGTqAt+Izah02myHDMCrVlqADAAAsi6ErAABgWQQdAABgWQQdAABgWQQdAABgWQQdAABgWQQdAABgWQQdAABgWQQdAABgWQQdAABgWQQdAABgWQQdAABgWQQdAABgWQQdAABgWQQdAABgWQQdAABgWQQdAABgWT5mFwD8nqWnp+vdd9/V119/rczMTH3++edas2aNioqK1KtXL4WFhZldIlBrZWZmKiEhQcnJySooKCh1PCYmxoSq4GkEHcBNqampGjFihJKTk+V0OmUYhiTpv//9r9asWaMnn3xSY8eONblKoHb6+uuvNX78eOXm5pbbhqBTOzB0BbjpzTffVFJSkux2e4n9w4YNk9Pp1MaNG02qDEBsbKxycnLkdDrL/IPagx4dwE1ffvmlDMPQu+++qzFjxrj2d+zYUZL0888/m1QZgJ9//lmGYWjKlCnq3bu3fH19zS4JJiHoAG5KS0uTJHXp0qXM4xkZGR6sBsCFWrdure+++06DBg1irlwtR9AB3BQSEqLTp0/ryJEjJfZ//PHHksQ/roCJ/vrXv+q+++7TQw89pJEjR6px48by8Sn5v7xu3bqZVB08iaADuKlnz55as2aNxo8f79o3duxYbdmyRYZhqGfPniZWB9RuDRs21DXXXKOdO3fqueeeK3XcMAzt37/fhMrgaYaTWVmAW44dO6Y777xT2dnZrjuuJMnpdCooKEjLly9XZGSkiRUCtVdMTIw2bNhQ7sRjwzD0ww8/eLgqmIEeHcBNzZo105IlSxQbG6sdO3aoqKhIdrtd3bp105QpUwg5gIm2bNkiSerUqZO6du0qPz8/kyuCWejRAWpAXl6ezpw5owYNGqhu3bpmlwPUegMGDNCJEye0Y8cOBQYGml0OTMQ6OkAN8PPzU8OGDQk5gJd4/PHHJUlr1qwxtxCYjh4doAratGlT6bZMdgTMM2rUKP3444/KzMxUo0aNFB4eXmJxT8MwtHDhQhMrhKcwRweoAn4vAH4fduzYIcMw5HQ6dfLkSZ06dcp17MJHtsD6CDpAFQwbNszsEgBUQnh4uNklwEswdAUAACyLHh2gmo4ePart27crPT1dISEh6t69u6688kqzywLw//30009KS0tTSEiIWrZsaXY58DCCDuCmwsJCTZs2TStXrix1bNiwYXrxxRdLLTkPwHM2btyoF198scT8nEaNGun5559XVFSUiZXBkxi6AtwUGxtb7l0bhmHovvvu0+TJkz1cFQBJ+vbbbzVq1Cg5HI5SNxH4+Pho4cKFuu6660yqDp5E0AHcdP311+vMmTOKjIzU6NGj1ahRI506dUqLFi3SsWPH1KBBA3399ddmlwnUSg899JASEhLk5+enAQMGqHHjxjp58qTWr1+vs2fPqnfv3po3b57ZZcID6FcH3JSfny9Jmjdvnpo1a+baf+ONN2rgwIEqLCw0qzSg1tu9e7cMw9Dbb7+t66+/3rX/66+/1pgxY7R7924Tq4MnsTIy4KYbb7xRkhQQEFBif/HrXr16ebwmAOfl5uZKktq3b19if/Hr4uOwPoIO4Kb7779f9evX1xNPPKGtW7fq6NGj2rp1q5588kldccUVeuCBB5ScnOz6A8BzGjVqJEl64403XKHm7NmzevPNN0sch/UxRwdwE4+DALzXq6++qn//+98yDEM2m02BgYHKzs6Ww+GQJI0ZM0bPPvusyVXCE+jRAdzkdDqr9AeA54wfP15XX321nE6nioqKdObMGRUVFcnpdKpFixZ69NFHzS4RHsJkZMBNMTExZpcAoByBgYGKj4/XggULtHnzZteCnjfddJPGjBmjwMBAs0uEhzB0BQCwnOJ5cTzzCgQdAIDltG7dWjabrcy5cX369JHNZtPGjRtNqAyextAV4Kb8/HzNnTtXn3zyiU6ePFlq3RwmIAPmKuv3eIfDoZSUFBmGYUJFMANBB3DTjBkztGzZMkll/4MKwLMOHDigAwcOlNj322fRHTp0SJLk6+vrqbJgMoIO4Kb169dLkpo0aaJrr71WderUMbkioHZbv3695syZ43rtdDo1ZcqUUu0MwyixmjmsjaADuKm463vZsmUKCQkxuRoA0v96V4s/n2X1ttavX1+TJk3yaF0wD0EHcNMf//hHzZ07V19++aWGDRtmdjlArTds2DB1795dTqdT9913nwzD0KJFi1zHDcNQcHCwmjVrJj8/PxMrhSdx1xXgJofDofHjx+vLL79U48aN1bhxY9ntdtdxwzC0cOFCEysEaq/JkyfLMAzFxsaaXQpMRtAB3LR69epyl5B3Op0yDEM//PCDh6sCUJ5du3YpLS1NnTp1UlhYmNnlwEMYugLc9Oabb3K3FeCl5s2bpzVr1mjo0KF68MEH9fzzz+vDDz+UJAUHB2v+/Plq166dyVXCEwg6gJvS0tJkGIbi4uLUq1cv1a1b1+ySAPx/X3zxhQ4dOqS2bdvq119/1Ycffuj6xeTMmTN66623NHv2bJOrhCfwUE/ATb1795YkdejQgZADeJljx45Jklq1aqXdu3fL6XRq6NCheu211yRJu3fvNrM8eBA9OoCbbr/9dm3btk1jx47V6NGj1aRJE/n4lPxIdevWzaTqgNotOztb0vlhqp9++kmGYahv376KiorSM888o4yMDHMLhMcQdAA3PfbYYzIMQ2fOnNHzzz9f6jiPgADMExISol9//VVLlizRhg0bJElXXnmlsrKyJElBQUFmlgcPYugKqAan01nhHwDmuO666+R0OvXKK69o3759CgsLU6tWrXT48GFJUmRkpMkVwlPo0QHcxPocgPd64okndODAASUmJiowMFAvvPCCJOnTTz+VJHXv3t3E6uBJrKMDALCsjIwMBQcHy2ZjAKO2IugANSAtLU15eXml9oeHh5tQDQCgGENXgJscDofi4uL03nvvKTMzs9RxJiMD5unXr1+Fxw3D0Pr16z1UDcxE0AHctGjRIr311ltmlwGgDElJSWXuNwzD9YgW1A4EHcBNK1askGEYatOmjfbv3y/DMDRgwAAlJCToiiuu0HXXXWd2iUCt9ds1rBwOh5KSknTq1Cn5+/urQ4cOJlUGTyPoAG4qXnl19uzZioqKkiTNmjVLW7Zs0dixYzVx4kQzywNqtcWLF5e5/4MPPtBf//pXRUdHe7gimIVp6ICbioqKJEmNGjWS3W6XJOXk5Khr165yOByaM2eOmeUBKMOIESPk7+/PsHMtQo8O4KYGDRro9OnTysnJUUhIiFJTU/XSSy+5nnt18uRJkysEaq/k5ORS+/Lz85WQkKDc3FwdP37chKpgBoIO4KYrr7xSp0+fVlJSkrp06aLPPvtMq1atknR+wmPLli1NrhCovaKiosqdcGwYhpo3b+7himAWgg7gprvvvltNmzZVVlaWHn/8ce3Zs0enTp2SJNWvX19Tp041uUKgditvmbh69epp8uTJHq4GZmHBQKCGZGdna/fu3SooKFCXLl1Uv359s0sCaq3Zs2eX2lenTh01atRIvXv3VoMGDTxfFExB0AHctHPnTnXt2rXc4x9++KHuuusuD1YEAPgt7roC3HTffffpb3/7mwoLC0vsP336tB5++GE9//zzJlUG4Pjx49qxY4fraeXFDh8+rB07djAZuRYh6ABuKioq0vz583XnnXfqwIEDkqR169bpjjvu0KZNm0yuDqjdXnjhBY0ePVr79u0rsf+HH37Q6NGjNX36dJMqg6cxGRlw0+jRo/V///d/+vHHH3X33XerU6dO2rlzp5xOp/z9/TVp0iSzSwRqreLnzPXu3bvE/ptuuklOp7NUAIJ10aMDuGnq1Kl67733dPXVV6uwsNAVcnr27Kk1a9Zo5MiRZpcI1FpZWVmSzj/64ULFr7Ozsz1eE8xB0AGqITs7W7m5uSUeFJiTk6P8/HyzSwNqtcsvv1yS9M9//rPE/nfffVeSdNlll3m8JpiDu64AN02aNEkff/yxJMnPz099+vTRp59+Kkny8fHRuHHj9Oijj5pZIlBrTZ06VR999JFrccDmzZsrMTFRiYmJkqThw4drxowZJlcJTyDoAG5q3bq1JKlz58569dVXFRkZqW3btmnKlClKTk6WYRj64YcfTK4SqJ2OHz+u4cOHKysrq8QKyU6nU8HBwfroo4/UtGlTEyuEpzB0BbjJ19dXTz75pJYsWaLIyEhJUo8ePbRmzRoNHz7c5OqA2i0iIkJLlizR9ddfL5vNJqfTKZvNphtuuEFLliwh5NQi9OgAbjpw4ICrV6csX375pW6++WbPFQSgTPn5+crIyFCDBg1cD9290I4dOyRJ3bp183Rp8ACCDlBNZ86c0a5du5SRkaGhQ4eaXQ6AKmrdurVsNpvrlnRYC+voANUwf/58zZo1S/n5+TIMQ0OHDtWYMWN0/PhxvfDCC+rVq5fZJQKoBH7nty7m6ABu+s9//qPXXntNeXl5cjqdrn8o+/Xrp6SkJNcdWQAA8xB0ADctWLBAhmFowIABJfYXz8v57rvvPF8UAKAEgg7gpoMHD0qSXnrppRL7GzVqJElKSUnxeE0AgJIIOoCbitfm8PX1LbH/559/NqMcAEAZCDqAm1q0aCHpf0vKS9KePXv03HPPSZKuueYaU+oCAPwPt5cDblq6dKmmT59eYtXVC02fPl0jRozwcFUAqmrFihWSpGHDhplcCS4Fgg5QDVOmTHH9I3mh4cOH6+WXXzahIgDF0tPT9e677+rrr79WZmamPv/8c61Zs0ZFRUXq1auXwsLCzC4RHkDQAarpm2++UUJCgtLS0hQaGqpevXqpa9euZpcF1GqpqakaMWKEkpOT5XQ6Xc+ee+aZZ7RmzRo9+eSTGjt2rNllwgMIOoAHjB49WoZhaOHChWaXAtQK06ZN0wcffCAfHx+dO3fOFXS2bt2q+++/X126dNF7771ndpnwACYjAx6wfft2bd++3ewygFrjyy+/lGEYJW4WkKSOHTtK4u7I2oSgAwCwnLS0NElSly5dyjyekZHhwWpgJoIOAMByQkJCJElHjhwpsb/40SxMRK49CDoAAMvp2bOnJGn8+PGufWPHjtULL7wgwzBcx2F9BB0AgOWMHz9eAQEBSkpKcq11tXnzZjkcDgUGBurRRx81uUJ4CkEHAGA5zZo105IlS3T99dfLZrPJ6XTKZrPp+uuv1//93/8pMjLS7BLhIdxeDnhAVFSUDMPQhg0bzC4FqHXy8vJ05swZNWjQQHXr1jW7HHgYQQcAAFiWj9kFAL9nW7du1ZIlS5SYmKi8vLwSxwzD0Pr1602qDKh92rRpU+m2hmFo//79l7AaeAuCDuCmjRs3avz48XI6nbqwY9QwDNeS8wA8hwEKlIWgA7hp/vz5cjgc8vf319mzZ2UYhurXr6+MjAwFBwcrKCjI7BKBWoWnj6MszNEB3NStWzdlZ2dr2bJluuuuu1zP0vnnP/+p+fPna/78+VXqSgcA1DyCDuCm9u3bq6ioSHv37lWHDh0kSXv37lVhYaE6d+6szp07a+nSpSZXCdRuR48e1fbt25Wenq6QkBB1795dV155pdllwYMYugLcFBQUpIyMDBUWFio4OFiZmZn68MMP5e/vL0n64YcfTK4QqL0KCws1bdo0rVy5stSxYcOG6cUXX5SPD/8LrA34KQNuCg8PV0ZGhn799Ve1bt1a27dv1/Tp0yWdn5DcsGFDkysEaq+///3vWrFiRZnHVqxYoeDgYE2ePNnDVcEMrIwMuOmGG25Q48aN9eOPP+qBBx6Q3W533YHldDo1duxYs0sEaq1Vq1bJMAw1a9ZMzz//vObMmaPnn39ezZo1k9PpLLOnB9bEHB2ghuzZs0cbNmxQQUGBbr75ZvXo0cPskoBaq3PnzsrLy9Mnn3yiZs2aufYfPXpUAwcOVEBAgL755hsTK4SnMHQFuKn4N8KhQ4dKkjp27KiOHTtKko4fP67jx48rIiLCpOqA2u3GG2/Uhg0bFBAQUGJ/8etevXqZURZMQI8O4KbWrVvLZrOVubpqRccAXHrffPONxo8fr2uuuUaPPvqoGjdurJMnT2ru3Lk6duyYZs+ercsuu8zVPjw83MRqcSkRdAA3tW7d2rV2zoXy8/N17bXXlnkMgGfwOAgUY+gKqIL169eXegL5lClTSrz++eefJalUlzkAz+F3eBQj6ABVcODAgRJ3a1R090a7du08UxSAUmJiYswuAV6CoANUUfFvisUP7fztb47169dX+/bt9Ze//MXjtQE4j6CDYszRAdxU3hwdAID3oEcHcFNsbKzZJQAoR35+vubOnatPPvlEJ0+eVGFhYYnjTECuPejRAWpAWlqa8vLySu3nllXAHNOmTdOyZcsklT0xmd7Y2oMeHcBNTqdTs2bN0nvvvafMzMxSx/mNETDP+vXrJUlNmjTRtddeqzp16phcEcxC0AHctHDhQr311ltmlwGgDMU3CyxbtkwhISEmVwMz8VBPwE0rVqyQYRhq27atpPP/sN5yyy3y8/NTZGSk69EQADzvj3/8o5xOp7788kuzS4HJmKMDuKlTp07Kz8/Xhg0bFBUV5Rrz37Jli8aOHavXXntNd9xxh9llArWSw+HQ+PHj9eWXX6px48Zq3Lix7Ha767hhGFq4cKGJFcJTGLoC3FRUVCRJatSokex2uxwOh3JyctS1a1c5HA7NmTOHoAOYZO3ata7enJMnT+rkyZOuY06n0zW0Besj6ABuatCggU6fPq2cnByFhIQoNTVVL730kurWrStJJf5hBeBZb775Jo+BgCSCDuC2K6+8UqdPn1ZSUpK6dOmizz77TKtWrZJ0vlu8ZcuWJlcI1F5paWkyDENxcXHq1auX6xcQ1D5MRgbcdPfdd2vo0KHKysrS448/rkaNGsnpdMrpdCo4OFhTp041u0Sg1urdu7ckqUOHDoScWo7JyEANyc7O1u7du1VQUKAuXbqofv36ZpcE1Fqffvqp/vrXv+qKK67Q6NGj1aRJE/n4lBzE6Natm0nVwZMIOgAAyyl+Fl15WNCz9mCODlAFo0ePrnRbbl8FzMXv8ZAIOkCVbN++vVK3pXL7KmAuHrqLYgQdoAp++5DOjIwM5ebmytfXV/Xr19eZM2dUWFgof39/hYaGmlQlgGHDhpldArwEc3QAN+3evVv333+/Ro4cqZiYGNWtW1cFBQV68803tWTJEr377rvq2rWr2WUCtV5aWpry8vJK7f/tLy6wJoIO4KYRI0Zo79692rlzpwICAlz7s7Oz1bVrV3Xo0EHLli0zsUKg9nI4HIqLi9N7772nzMzMUseZjFx7sI4O4KYDBw5IkrZs2VJif/HrgwcPerwmAOctWrRIb731ls6cOeNa3+q3f1A7MEcHcFN4eLiOHTumxx9/XB06dFDDhg2VkpKivXv3yjAMusUBE61YsUKGYahNmzbav3+/DMPQgAEDlJCQoCuuuELXXXed2SXCQ+jRAdw0ceJESee7yPfs2aPPP/9ce/bskcPhkCQ99thjZpYH1GrHjh2TJM2ePdu1b9asWZozZ45OnDihG2+80azS4GEEHcBNt99+uxYsWKDrrrtOdrtdTqdTdrtdXbt21cKFC3XbbbeZXSJQaxUVFUmSGjVqJLvdLknKyclR165d5XA4NGfOHDPLgwcxdAVUQ48ePbRkyRI5HA6lp6crJCRENhu/PwBma9CggU6fPq2cnByFhIQoNTVVL730kuu5VydPnjS5QngK/yIDNcBms+m///2vVq9ebXYpACRdeeWVkqSkpCR16dJFTqdTq1at0gcffCDDMNSyZUtzC4THcHs5UENat24tm83GLauAF1i9erW2bt2q4cOHKywsTA888IBOnTolSapfv77eeecdderUydwi4REEHaCGFD9E8IcffjC7FAC/kZ2drd27d6ugoEBdunRR/fr1zS4JHsLQFQDAcnbu3FnidWBgoG688Ub17dtX9evX14cffmhSZfA0gg4AwHLuu+8+/e1vf1NhYWGJ/adPn9bDDz+s559/3qTK4GkMXQE1ZPv27ZKk7t27m1wJgOKh5GuuuUavvfaaWrdurXXr1unFF19URkYGw8y1CEEHAGA5L7/8sv7v//5PDodDvr6+6tSpk3bu3Cmn0yl/f39NmjRJI0eONLtMeABDV4CbXnnlFfXr108LFiwosf/f//63+vXrp1dffdWcwgBo6tSpeu+993T11VersLDQFXJ69uypNWvWEHJqEYIO4Kb169crOTlZffv2LbG/f//+SkpK0vr1602qDIB0/k6r3NxcGYYhp9MpwzCUk5Oj/Px8s0uDBxF0ADf98ssvkqSGDRuW2H/ZZZdJklJSUjxeE4DzJk2apLFjx+rkyZPy8/PTwIEDJUl79+7V0KFDNXfuXJMrhKcQdAA3FS8lv23bthL7iycl+/n5ebwmAOetXbtWTqdTnTp10qpVq/TGG29owYIFaty4sQoLCxUXF2d2ifAQgg7gpnbt2snpdOqZZ57RvHnztH79es2bN0/PPPOMDMNQ27ZtzS4RqLV8fX315JNPasmSJYqMjJR0/tl0a9as0fDhw02uDp7EXVeAm9avX6+YmBgZhlFif/FcgLi4OPXv39+k6oDa7cCBA2rdunW5x7/88kvdfPPNnisIpiHoANUwd+5czZkzR0VFRa59Pj4+Gj9+vMaNG2diZQAk6cyZM9q1a5cyMjI0dOhQs8uBCQg6QDUlJSVpy5YtSktLU2hoqG666SaFh4ebXRZQ682fP1+zZs1Sfn6+DMPQ/v37NWbMGB0/flwvvPCCevXqZXaJ8AAfswsAfu+aNGmiESNGmF0GgAv85z//0WuvvVZqf79+/TRjxgx9/PHHBJ1agsnIgJtYMBDwXgsWLJBhGBowYECJ/cXzcr777jvPFwVTEHQAN7FgIOC9Dh48KEl66aWXSuxv1KiRJNa5qk0IOoCbWDAQ8F7Fd0P6+vqW2P/zzz+bUQ5MRNAB3MSCgYD3atGihSTp3Xffde3bs2ePnnvuOUnSNddcY0pd8DyCDuAmFgwEvNddd90lp9Opt99+29W788c//lG7d++WYRi66667TK4QnsJdV4Cb7r33Xn399dfKzMzUzJkzXfuLFwy89957TawOqN3uuece7dmzRytWrCh1bPjw4dwpWYuwjg5QDSwYCHi3b775RgkJCa51rnr16qWuXbuaXRY8iKADVBMLBgK/b6NHj5ZhGFq4cKHZpeASIOgA1ZCYmKjPPvtMycnJKigoKHHMMAy9/PLLJlUGoLJat24twzD0ww8/mF0KLgHm6ABuWrdunZ5++mk5HI5y2xB0AMBcBB3ATXFxcSXm5gAAvA9BB3DTyZMnZRiGpk+friFDhrjW1QEAeA/W0QHcVLxOzm233UbIAQAvRdAB3DR16lT5+fnpb3/7m3JycswuBwBQBu66AqqgX79+JV6npaUpLy9PdrtdYWFh8vH532iwYRg82BP4HYiKipJhGNqwYYPZpeASIOgAVdC6detKt+V2VQAwH5ORgSro1q2b2SUAqKStW7dqyZIlSkxMVF5eXolj9LjWHvToAAAsZ+PGjRo/frycTqcu/N+cYRiu59HR41o7MBkZAGA58+fPl8PhkJ+fn6TzAadBgwZyOp0KDg7mMS21CEEHAGA5Bw4ckGEYWrx4sWvf119/raeeekp2u12zZ882sTp4EkEHAGA5Z8+elfS/51hJ0rlz53TvvfcqPT1dL774opnlwYOYjAwAsJygoCBlZGSosLBQwcHByszM1Icffih/f39JYn5OLULQAQBYTnh4uDIyMvTrr7+qdevW2r59u6ZPny7p/Hydhg0bmlwhPIWhKwCA5dxwww1q3LixfvzxRz3wwAOy2+2uO7CcTqfGjh1rdonwEG4vBwBY3p49e7RhwwYVFBTo5ptvVo8ePcwuCR5C0AEAWM7KlSslSUOHDi117Pjx45KkiIgID1YEsxB0AACW07p1a9lsNu3fv79Kx2A9zNEBAFhSWb/H5+fnl3sM1sRdVwAAS1i/fn2pJ5BPmTKlxOuff/5ZkhQQEOCxumAugg4AwBIOHDjgmpsjne+1ufD1hdq1a+eZomA6gg4AwDKKh6SKV0P+7RBV/fr11b59e/3lL3/xeG0wB5ORAQCWU/zoB1ZABj06AADLiY2NNbsEeAl6dAAAlpaWlqa8vLxS+8PDw02oBp5Gjw4AwHKcTqdmzZql9957T5mZmaWOG4bBOjq1BEEHAGA5Cxcu1FtvvWV2GfACLBgIALCcFStWyDAMtW3bVtL5HpxbbrlFfn5+ioyMLPPRELAmgg4AwHKOHTsmSZo9e7Zr36xZszRnzhydOHFCN954o1mlwcMIOgAAyykqKpIkNWrUSHa7XZKUk5Ojrl27yuFwaM6cOWaWBw9ijg4AwHIaNGig06dPKycnRyEhIUpNTdVLL72kunXrSpJOnjxpcoXwFHp0AACWc+WVV0qSkpKS1KVLFzmdTq1atUoffPCBDMNQy5YtzS0QHkOPDgDAcu6++241bdpUWVlZevzxx7Vnzx6dOnVK0vnHQEydOtXkCuEpLBgIALC87Oxs7d69WwUFBerSpYvq169vdknwEIIOAACwLIauAACWMHr06Eq3NQxDCxcuvITVwFsQdAAAlrB9+3YZhnHRdk6ns1LtYA0EHQCAJfz2IZ0ZGRnKzc2Vr6+v6tevrzNnzqiwsFD+/v4KDQ01qUp4GnN0AACWs3v3bt1///0aOXKkYmJiVLduXRUUFOjNN9/UkiVL9O6776pr165mlwkPIOgAACxnxIgR2rt3r3bu3KmAgADX/uzsbHXt2lUdOnTQsmXLTKwQnsKCgQAAyzlw4IAkacuWLSX2F78+ePCgx2uCOZijAwCwnPDwcB07dkyPP/64OnTooIYNGyolJUV79+6VYRil5vPAuhi6AgBYzrp16/TUU0+VusOq+PXrr7+u2267zcQK4SkEHQCAJW3btk2zZs3S7t27de7cOfn4+KhTp06aOHGiunfvbnZ58BCCDgDA0hwOh9LT0xUSEiKbjamptQ0/cQCApdlsNv33v//V6tWrzS4FJqBHBwBgea1bt5bNZtP+/fvNLgUeRo8OAKBW4Pf62omgAwAALIugAwAALIsFAwEAlrdo0SKzS4BJmIwMAAAsi6ErAIDlvPLKK+rXr58WLFhQYv+///1v9evXT6+++qo5hcHjCDoAAMtZv369kpOT1bdv3xL7+/fvr6SkJK1fv96kyuBpBB0AgOX88ssvkqSGDRuW2H/ZZZdJklJSUjxeE8xB0AEAWE7dunUlnX/e1YW2b98uSfLz8/N4TTAHd10BACynXbt2+vrrr/XMM8/owQcfVIsWLXTkyBH961//kmEYatu2rdklwkO46woAYDnr169XTEyMDMMosd/pdMowDMXFxal///4mVQdPYugKAGA5/fv318SJE2Wz2eR0Ol1/fHx8NHHiREJOLUKPDgDAspKSkrRlyxalpaUpNDRUN910k8LDw80uCx5E0AEAAJbF0BUAwHJYMBDFCDoAAMthwUAUI+gAACyHBQNRjKADALAcFgxEMRYMBABYDgsGohh3XQEALIcFA1GMoSsAgOWwYCCK0aMDALAsFgwEQQcAYEmJiYn67LPPlJycrIKCghLHDMPQyy+/bFJl8CSCDgDActatW6enn35aDoej3DY//PCDByuCWbjrCgBgOXFxcSoqKjK7DHgBgg4AwHJOnjwpwzA0ffp0DRkyxLWuDmof7roCAFhO8To5t912GyGnliPoAAAsZ+rUqfLz89Pf/vY35eTkmF0OTMRkZACAJfTr16/E67S0NOXl5clutyssLEw+Pv+brWEYBg/2rCWYowMAsISkpKQy9587d67UQzx/u2IyrIugAwCwhG7dupldArwQQ1cAAMCymIwMAAAsi6ADAAAsi6ADAAAsi6ADAAAsi6ADAAAsi9vLAXi1jz76SFOmTHG9rlOnjurXr69WrVqpT58+Gj58uAIDA6t83W+//VZbtmzRfffdp+Dg4Jos2S1LliyRv7+/hg8fbnYpgKUQdAD8LkycOFFNmzbVuXPndPr0aW3fvl0vv/yyFixYoLlz56p169ZVut6uXbs0e/ZsDRs2zCuCztKlSxUSEkLQAWoYQQfA70Lv3r3VoUMH1+uHH35YW7du1SOPPKJHH31U69atk5+fn4kVAvBGzNEB8LvVs2dPPfroo0pKStLq1aslSQcOHNDkyZPVr18/dejQQTfeeKOmTJmi9PR013lxcXF67bXXJJ1/PlKrVq3UqlUrnThxQpK0fPlyjR49Wj179lT79u11++2367333iv1/nv37tWDDz6oHj16qGPHjoqKiioxzCZJDodDCxYs0KBBg9ShQwfdcMMNmjZtms6cOeNqExUVpZ9++knbt2931TJq1Kga//sCaiN6dAD8rg0ZMkSvv/66Nm/erBEjRuirr77S8ePHNXz4cF1++eX66aef9MEHH+jQoUP64IMPZBiGBgwYoKNHj2rt2rWaMmWKQkJCJEmhoaGSzg8jXXPNNYqKipKPj482btyo6dOny+l0auTIkZKk1NRUPfjggwoJCdFDDz2k4OBgnThxQp9//nmJ+qZNm6YVK1Zo+PDhGjVqlE6cOKElS5Zo//79Wrp0qXx9fTV16lS99NJLqlevnh555BFJ0mWXXebBv0XAwpwA4MWWL1/ubNmypXPPnj3ltrnuuuucQ4cOdTqdTufZs2dLHV+7dq2zZcuWzh07drj2vfvuu86WLVs6jx8/Xqp9Wdd44IEHnP369XO9/vzzzy9a144dO5wtW7Z0rl69usT+hISEUvsHDRrkvPfee8u9FgD3MHQF4HevXr16ysnJkaQS83Ty8/OVlpama6+9VpK0b9++Sl3vwmtkZWUpLS1N3bt31/Hjx5WVlSVJCgoKkiR9+eWXKiwsLPM6n3zyiYKCgnTjjTcqLS3N9addu3aqV6+etm3bVvVvFkCVMHQF4HcvNzdXYWFhkqSMjAzNnj1b69atU2pqaol2xSHlYr755hvFxcXpu+++09mzZ0tdIygoSN27d9ett96q2bNna8GCBerevbv69++vP/zhD6pTp44k6dixY8rKylLPnj3LfJ/f1geg5hF0APyunTp1SllZWYqMjJQkPf7449q1a5cefPBBtWnTRvXq1ZPD4dCf//xnOZ3Oi17v559/1pgxY9SiRQtNnjxZjRs3lq+vrzZt2qQFCxbI4XBIkgzD0KxZs/Tdd99p48aN+u9//6upU6fq3//+t95//30FBATI4XAoLCxMf//738t8r+I5QQAuHYIOgN+1VatWSZJuuukmnTlzRlu3btWECRMUExPjanP06NFS5xmGUeb1vvjiCxUUFOitt95SeHi4a395w0ydOnVSp06d9MQTT2jNmjWaNGmS1q1bp7vvvluRkZHaunWrunTpctFb38urB0D1MEcHwO/W1q1bNXfuXDVt2lSDBw+W3W4vs93ChQtL7fP395dUejir+BoX9v5kZWVp+fLlJdqdOXOmVA9RmzZtJEkFBQWSpNtuu01FRUWaO3duqfc/d+6cMjMzS9Rz4WsANYMeHQC/CwkJCTpy5IiKiop0+vRpbdu2TVu2bFF4eLjeeust1a1bV3Xr1lW3bt307rvvqrCwUA0bNtSWLVtc6+NcqF27dpKkmTNn6vbbb5evr6/69u2rG2+8Ub6+vnrkkUcUHR2tnJwcLVu2TGFhYfr1119d569YsUJLly5V//79FRkZqZycHH3wwQcKDAxU7969JUndu3fXH//4R73zzjv64YcfXNc+evSoPvnkEz333HMaOHCgq56lS5dq7ty5atasmUJDQ8ud2wOg8gxnZQatAcAkv33Wla+vrxo0aKCWLVvq5ptvLvWsq5SUFL300kvatm2bnE6nbrzxRj333HPq1auXYmJiNGHCBFfbuXPnKj4+Xr/++qscDoc2bNigpk2b6osvvtAbb7yho0eP6rLLLtM999yj0NBQTZ061dVm//79+te//qVvv/1Wp0+fVlBQkDp27KiYmBi1b9++xPfwwQcfKD4+XocPH5bdbleTJk3Uu3dv3XfffbriiiskSadPn9Zzzz2nHTt2KCcnR927d9fixYsv8d8uYH0EHQAAYFnM0QEAAJZF0AEAAJZF0AEAAJZF0AEAAJZF0AEAAJZF0AEAAJZF0AEAAJZF0AEAAJZF0AEAAJZF0AEAAJZF0AEAAJZF0AEAAJb1/wD0ABSt4E1X9wAAAABJRU5ErkJggg==\n"},"metadata":{}},{"output_type":"stream","name":"stderr","text":["INFO:root:Phase 7 complete\n"]}],"source":["from streamline.runners.compare_runner import CompareRunner\n","if len_datasets(output_path, experiment_name) > 1:\n"," cmp = CompareRunner(output_path, experiment_name, algorithms=algorithms,\n"," exclude=exclude, sig_cutoff=sig_cutoff,\n"," class_label=class_label, instance_label=instance_label,\n"," show_plots=True)\n"," cmp.run(run_parallel=False)"]},{"cell_type":"markdown","metadata":{"id":"SaqYpZViPPVc"},"source":["## Phase 8: PDF Training Report Generator (Optional)\n","Downloads a PDF report of the analysis"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":45566,"status":"ok","timestamp":1685752721536,"user":{"displayName":"ryan urbanowicz","userId":"09525282221743790591"},"user_tz":420},"id":"Z9GVbQOrPb2G","outputId":"b22e60b9-5f13-4ce3-e2eb-e3002c54546e"},"outputs":[{"output_type":"stream","name":"stderr","text":["INFO:root:Starting Report\n","INFO:root:Publishing Univariate Analysis\n","INFO:root:Publishing Model Prediction Summary\n","INFO:root:Publishing Average Model Prediction Statistics\n","INFO:root:Publishing Median Model Prediction Statistics\n","INFO:root:Publishing Feature Importance Summaries\n","INFO:root:Publishing Dataset Comparison Boxplots\n","INFO:root:Publishing Statistical Analysis\n","INFO:root:Publishing Runtime Summary\n","INFO:root:Phase 8 complete\n"]}],"source":["from streamline.runners.report_runner import ReportRunner\n","rep = ReportRunner(output_path, experiment_name,\n"," algorithms=algorithms, exclude=exclude)\n","rep.run(run_parallel=False)"]},{"cell_type":"markdown","metadata":{"id":"jTH3xMl8QchK"},"source":["## Phase 9: Apply Models to Replication Data (Optional)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":16150,"status":"ok","timestamp":1685752737675,"user":{"displayName":"ryan urbanowicz","userId":"09525282221743790591"},"user_tz":420},"id":"vASWHToXSMpX","outputId":"78f78871-441d-4fd0-baeb-dfad2ab003d1"},"outputs":[{"output_type":"stream","name":"stderr","text":["INFO:root:Loading Dataset: hcc-data_example_custom_rep\n","INFO:root:Loading Dataset: hcc-data_example_custom\n","INFO:root:Identifying Feature Types...\n","WARNING:root:New Value found in Binary Categorical Variable, filling with null value\n","INFO:root:Initial Data Counts: ----------------\n","INFO:root:Instance Count = 171\n","INFO:root:Feature Count = 61\n","INFO:root: Categorical = 27\n","INFO:root: Quantitative = 34\n","INFO:root:Missing Count = 1181\n","INFO:root: Missing Percent = 0.11322020899242642\n","INFO:root:Class Counts: ----------------\n","INFO:root:Class Count Information\n","INFO:root:\n"," Class Instances\n","0 0 115\n","1 1 56\n","INFO:root:Processed Data Counts: ----------------\n","INFO:root:Instance Count = 171\n","INFO:root:Feature Count = 69\n","INFO:root: Categorical = 48\n","INFO:root: Quantitative = 21\n","INFO:root:Missing Count = 942\n","INFO:root: Missing Percent = 0.0798372743452835\n","INFO:root:Class Counts: ----------------\n","INFO:root:Class Count Information\n","INFO:root:\n"," Class Instances\n","0 0 115\n","1 1 56\n","INFO:root:Final List of Features:\n","INFO:root:['Symptoms ', 'Alcohol', 'Hepatitis B Surface Antigen', 'Hepatitis B e Antigen', 'Hepatitis B Core Antibody', 'Hepatitis C Virus Antibody', 'Cirrhosis', 'Endemic Countries', 'Smoking', 'Diabetes', 'Obesity', 'Hemochromatosis', 'Arterial Hypertension', 'Chronic Renal Insufficiency', 'Human Immunodeficiency Virus', 'Nonalcoholic Steatohepatitis', 'Esophageal Varices', 'Splenomegaly', 'Portal Hypertension', 'Portal Vein Thrombosis', 'Liver Metastasis', 'Radiological Hallmark', 'Grams of Alcohol per day', 'Packs of cigarets per year', 'Performance Status*', 'Encephalopathy degree*', 'Ascites degree*', 'International Normalised Ratio*', 'Alpha-Fetoprotein (ng/mL)', 'Haemoglobin (g/dL)', 'Mean Corpuscular Volume', 'Leukocytes(G/L)', 'Platelets', 'Albumin (mg/dL)', 'Total Bilirubin(mg/dL)', 'Alanine transaminase (U/L)', 'Aspartate transaminase (U/L)', 'Gamma glutamyl transferase (U/L)', 'Alkaline phosphatase (U/L)', 'Total Proteins (g/dL)', 'Creatinine (mg/dL)', 'Number of Nodules', 'Major dimension of nodule (cm)', 'Direct Bilirubin (mg/dL)', 'Iron', 'Oxygen Saturation (%)', 'Ferritin (ng/mL)', 'Sim_Cat_2', 'Sim_Text_Cat_2', 'Sim_Cor_-1.0_B', 'Sim_Cor_0.9_A', 'Sim_Cor_0.9_B', 'Sim_Cor_1.0_B', 'miss_Sim_Miss_0.6', 'miss_Sim_Miss_0.7', 'Sim_Cat_3_1', 'Sim_Cat_3_2', 'Sim_Cat_3_3', 'Sim_Cat_4_1', 'Sim_Cat_4_2', 'Sim_Cat_4_3', 'Sim_Cat_4_4', 'Sim_Text_Cat_3_Category 1', 'Sim_Text_Cat_3_Category 2', 'Sim_Text_Cat_3_Category 3', 'Sim_Text_Cat_4_Category 1', 'Sim_Text_Cat_4_Category 2', 'Sim_Text_Cat_4_Category 3', 'Sim_Text_Cat_4_Category 4']\n","INFO:root:Running stats on Naive Bayes\n","INFO:root:Running stats on Logistic Regression\n","INFO:root:Running stats on Decision Tree\n"]},{"output_type":"stream","name":"stdout","text":["hcc-data_example_custom_rep phase 9 complete\n"]}],"source":["if applyToReplication:\n"," from streamline.runners.replicate_runner import ReplicationRunner\n"," repl = ReplicationRunner(rep_data_path, dataset_for_rep, output_path,\n"," experiment_name, load_algo=True,\n"," export_feature_correlations=True,\n"," plot_roc=True, plot_prc=True, plot_metric_boxplots=True)\n"," repl.run(run_parallel=False)"]},{"cell_type":"markdown","metadata":{"id":"yzbQBgH4RjQW"},"source":["## Phase 10: PDF Apply Report Generator (Optional)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":23707,"status":"ok","timestamp":1685752761372,"user":{"displayName":"ryan urbanowicz","userId":"09525282221743790591"},"user_tz":420},"id":"R-10eE_nUioQ","outputId":"99f326d3-0fe6-474b-dd93-ea8583d695e8"},"outputs":[{"output_type":"stream","name":"stderr","text":["INFO:root:Starting Report\n","INFO:root:Publishing Model Prediction Summary\n","INFO:root:Publishing Average Model Prediction Statistics\n","INFO:root:Publishing Median Model Prediction Statistics\n","INFO:root:Phase 10 complete\n"]}],"source":["if applyToReplication:\n"," from streamline.runners.report_runner import ReportRunner\n"," rep = ReportRunner(output_path=output_path, experiment_name=experiment_name,\n"," algorithms=algorithms, exclude=exclude, training=False,\n"," rep_data_path=rep_data_path,\n"," dataset_for_rep=dataset_for_rep)\n"," rep.run(run_parallel=False)"]},{"cell_type":"markdown","metadata":{"id":"wyNBJgShRk6w"},"source":["## Phase 11: File Cleanup (Optional)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"fpTJmdhZQR9D"},"outputs":[],"source":["from streamline.runners.clean_runner import CleanRunner\n","clean = CleanRunner(output_path, experiment_name, del_time=del_time, del_old_cv=del_old_cv)\n","# run_parallel is not used in clean\n","clean.run()"]},{"cell_type":"markdown","metadata":{"id":"BarOZn6BLMCG"},"source":["### Download and Open PDF Summary Report(s)\n"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":17},"executionInfo":{"elapsed":14,"status":"ok","timestamp":1685752761373,"user":{"displayName":"ryan urbanowicz","userId":"09525282221743790591"},"user_tz":420},"id":"_6pWkCpKLMQb","outputId":"18fefe7d-89ce-44ef-8d9e-2a52b6978ef1"},"outputs":[{"output_type":"display_data","data":{"text/plain":[""],"application/javascript":["\n"," async function download(id, filename, size) {\n"," if (!google.colab.kernel.accessAllowed) {\n"," return;\n"," }\n"," const div = document.createElement('div');\n"," const label = document.createElement('label');\n"," label.textContent = `Downloading \"${filename}\": `;\n"," div.appendChild(label);\n"," const progress = document.createElement('progress');\n"," progress.max = size;\n"," div.appendChild(progress);\n"," document.body.appendChild(div);\n","\n"," const buffers = [];\n"," let downloaded = 0;\n","\n"," const channel = await google.colab.kernel.comms.open(id);\n"," // Send a message to notify the kernel that we're ready.\n"," channel.send({})\n","\n"," for await (const message of channel.messages) {\n"," // Send a message to notify the kernel that we're ready.\n"," channel.send({})\n"," if (message.buffers) {\n"," for (const buffer of message.buffers) {\n"," buffers.push(buffer);\n"," downloaded += buffer.byteLength;\n"," progress.value = downloaded;\n"," }\n"," }\n"," }\n"," const blob = new Blob(buffers, {type: 'application/binary'});\n"," const a = document.createElement('a');\n"," a.href = window.URL.createObjectURL(blob);\n"," a.download = filename;\n"," div.appendChild(a);\n"," a.click();\n"," div.remove();\n"," }\n"," "]},"metadata":{}},{"output_type":"display_data","data":{"text/plain":[""],"application/javascript":["download(\"download_a092b916-f9ec-474f-8625-97a3646159ac\", \"demo_experiment_ML_Pipeline_Report.pdf\", 1864848)"]},"metadata":{}},{"output_type":"display_data","data":{"text/plain":[""],"application/javascript":["\n"," async function download(id, filename, size) {\n"," if (!google.colab.kernel.accessAllowed) {\n"," return;\n"," }\n"," const div = document.createElement('div');\n"," const label = document.createElement('label');\n"," label.textContent = `Downloading \"${filename}\": `;\n"," div.appendChild(label);\n"," const progress = document.createElement('progress');\n"," progress.max = size;\n"," div.appendChild(progress);\n"," document.body.appendChild(div);\n","\n"," const buffers = [];\n"," let downloaded = 0;\n","\n"," const channel = await google.colab.kernel.comms.open(id);\n"," // Send a message to notify the kernel that we're ready.\n"," channel.send({})\n","\n"," for await (const message of channel.messages) {\n"," // Send a message to notify the kernel that we're ready.\n"," channel.send({})\n"," if (message.buffers) {\n"," for (const buffer of message.buffers) {\n"," buffers.push(buffer);\n"," downloaded += buffer.byteLength;\n"," progress.value = downloaded;\n"," }\n"," }\n"," }\n"," const blob = new Blob(buffers, {type: 'application/binary'});\n"," const a = document.createElement('a');\n"," a.href = window.URL.createObjectURL(blob);\n"," a.download = filename;\n"," div.appendChild(a);\n"," a.click();\n"," div.remove();\n"," }\n"," "]},"metadata":{}},{"output_type":"display_data","data":{"text/plain":[""],"application/javascript":["download(\"download_212cb670-9dd1-4c9d-b4a6-f4d5f240f498\", \"demo_experiment_ML_Pipeline_Apply_Report.pdf\", 581750)"]},"metadata":{}}],"source":["from google.colab import files\n","files.download(output_path + '/' + experiment_name + '/' + experiment_name + '_STREAMLINE_Report.pdf')\n","\n","if applyToReplication:\n"," dataset_name = dataset_for_rep.split('/')[-1].split('.')[0]\n"," #from google.colab import files\n"," pdf_files = []\n"," for dirpath, dirnames, filenames in os.walk(output_path + '/' + experiment_name\n"," + '/' + dataset_name + '/applymodel/'):\n"," for filename in [f for f in filenames if f.endswith(\".pdf\")]:\n"," pdf_files.append(os.path.join(dirpath, filename))\n"," for file_path in pdf_files:\n"," files.download(file_path)"]},{"cell_type":"markdown","metadata":{"id":"RU_qUle17uul"},"source":["# Zip the experiment folder and download."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":17},"executionInfo":{"elapsed":1900,"status":"ok","timestamp":1685752763260,"user":{"displayName":"ryan urbanowicz","userId":"09525282221743790591"},"user_tz":420},"id":"iZoiBH7G7ZIc","outputId":"46af935a-3e6e-4a05-9870-8f332c557076"},"outputs":[{"output_type":"display_data","data":{"text/plain":[""],"application/javascript":["\n"," async function download(id, filename, size) {\n"," if (!google.colab.kernel.accessAllowed) {\n"," return;\n"," }\n"," const div = document.createElement('div');\n"," const label = document.createElement('label');\n"," label.textContent = `Downloading \"${filename}\": `;\n"," div.appendChild(label);\n"," const progress = document.createElement('progress');\n"," progress.max = size;\n"," div.appendChild(progress);\n"," document.body.appendChild(div);\n","\n"," const buffers = [];\n"," let downloaded = 0;\n","\n"," const channel = await google.colab.kernel.comms.open(id);\n"," // Send a message to notify the kernel that we're ready.\n"," channel.send({})\n","\n"," for await (const message of channel.messages) {\n"," // Send a message to notify the kernel that we're ready.\n"," channel.send({})\n"," if (message.buffers) {\n"," for (const buffer of message.buffers) {\n"," buffers.push(buffer);\n"," downloaded += buffer.byteLength;\n"," progress.value = downloaded;\n"," }\n"," }\n"," }\n"," const blob = new Blob(buffers, {type: 'application/binary'});\n"," const a = document.createElement('a');\n"," a.href = window.URL.createObjectURL(blob);\n"," a.download = filename;\n"," div.appendChild(a);\n"," a.click();\n"," div.remove();\n"," }\n"," "]},"metadata":{}},{"output_type":"display_data","data":{"text/plain":[""],"application/javascript":["download(\"download_f8f9ca24-2cca-4e21-9bbc-029bb04c57ed\", \"demo_experiment.zip\", 29582537)"]},"metadata":{}}],"source":["experiment_folder = output_path + '/' + experiment_name\n","!zip -r -q /content/{experiment_name}.zip {experiment_folder}\n","from google.colab import files\n","files.download('/content/' + experiment_name + '.zip')"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"gsb7ISnpNFuF"},"outputs":[],"source":["#Return notebook to original directory to avoid nested STREAMLINE download bug.\n","os.chdir(original_wd)"]}],"metadata":{"colab":{"provenance":[{"file_id":"1kD3UjV9MYGe8qM0Ngj6SDKJaFet42zWG","timestamp":1684343339732},{"file_id":"1aHYHsOQsb8nUyX5ve9gG4pJvxrAM5w6Q","timestamp":1682993124356},{"file_id":"1YRqdGmEQJ9-sNY1aJOrEJ6Ku8GM9jgnW","timestamp":1682977785416},{"file_id":"18uU1KEs7SgFpJyFmot7LBEc85B6vbGU9","timestamp":1682698140203}]},"kernelspec":{"display_name":"Python 3 (ipykernel)","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.9.13"}},"nbformat":4,"nbformat_minor":0} \ No newline at end of file diff --git a/STREAMLINE-Notebook.ipynb b/STREAMLINE-Notebook.ipynb deleted file mode 100644 index 7ec08674..00000000 --- a/STREAMLINE-Notebook.ipynb +++ /dev/null @@ -1,2634 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "s405-rXWFkas" - }, - "source": [ - "![alttext](https://github.com/UrbsLab/STREAMLINE/blob/main/docs/source/pictures/STREAMLINE_Logo_Full.png?raw=true)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "NLQjvYSMFoSj" - }, - "source": [ - "# Jupyter Notebook README\n", - "\n", - "STREAMLINE is an end-to-end automated machine learning (AutoML) pipeline that empowers anyone to easily run, interpret, and apply a rigorous and customizable analysis for data mining or predictive modeling. Currently limited to binary classification in tabular data.\n", - "\n", - "* This notebook runs all phases of STREAMLINE. We recommend users review the STREAMLINE documentation for details.\n", - "\n", - "## Prerequisites\n", - "* This notebook should be located in the root folder of STREAMLINE (i.e. `/STREAMLINE/STREAMLINE-Notebook.ipynb`) after downloading from GitHub as indicated in the installation instructions in the documentation. It is meant to be run from within this STREAMLINE folder. We recommend always downloading the most recent version of STREAMLINE.\n", - "* Make sure that prerequisite packages have been installed before running including git, anaconda, and other required packages obtained by running `pip install -r requirements.txt` (see installation instructions).\n", - "\n", - "\n", - "## What to expect running this notebook 'as-is'?\n", - "* This notebook has been initially set up to run 'as-is' on two 'demo' datasets: (1) `hcc_data.csv`: the original HCC dataset downloaded from the UCI repository and (2) `hcc_data_custom.csv`: a 'custom' datasets which removes the two covariate features from the HCC dataset, and adds simulated features and instances to it to explicitly test aspects of data preprocessing (i.e. cleaning and feature engineering). \n", - "\n", - "* After model training and testing evaluations are complete, the models trained from hcc-data_example_custom.csv are applied to a 'replication' dataset (`hcc_data_custom_rep.csv`) for another round of evaluations. Since no true replication data was available for this example, we simulated a replication dataset by taking the `hcc_data_custom.csv` data and randomly resampling feature values for 30% of instances in the data to add some noise/variation to it.\n", - "\n", - "* Notebook run parameters have initially been set up to run only three of the available modeling algorithms (logistic regression, decision tree, and naive bayes), with 3-fold CV so that it runs completely in about 2-3 minutes (tested on a 3.49 GHz 16-core PC with 64GB RAM).\n", - "\n", - "* As the notebook run completes, the output 'experiment' folder including all output files will automatically be saved to `/STREAMLINE/DemoOutput` including the PDF summary reports.\n", - "\n", - "## Run Instructions for this Notebook\n", - "* **Demo Run:**\n", - " * Leave all run parameter cells (below) unchanged and choose `Restart and RunAll` under the `Kernal` tab in Jupyter Notebook\n", - " * You can optionally change non-essential run parameters in the code-cells below to run the demo with different settings\n", - "\n", - "* **Custom Dataset Run:** \n", - " * Set (`demo_run = False`)\n", - " * Adjust all essential run parameters based on dataset location/characteristics, as well as the desired output folder location and experiment folder name.\n", - " * Adjust all non-essential run parameters to desired settings within notebook code-cells\n", - " * Choose `Restart and RunAll` under the `Kernal` tab in Jupyter Notebook\n", - "* *Before running the STREAMLINE notebook again we generally recommend selecting `Disconnect and delete runtime` under `Runtime` tab in Jupyter Notebook*" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Y-5hwPRCYDZM" - }, - "source": [ - "----------------------\n", - "# STREAMLINE RUN PARAMETERS\n", - "----------------------\n", - "## Essential Run Parameters\n", - "* Run parameters under 'Notebook', 'Target Data', and 'Replication Data' are typically necessary to adjust in order to run STREAMLINE new (non-demo) data\n", - "\n", - "* Additional run parameters below these sections can also be optionally updated to change how STREAMLINE runs, e.g. how many CV partitions to make, or how many modeling algorithms to apply\n", - "\n", - "### Notebook - Run Parameters\n", - "The first parameter below is specific to this Jupypter Notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "JhBZoMAWbDaR" - }, - "outputs": [], - "source": [ - "demo_run = True # leave (True) to run the demo datasets, make (False) to manually update essential run parameters below to run on other datasets" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "3JaK2AXyoSyN" - }, - "source": [ - "### Target Data - Run Parameters (Phase 1)\n", - "* No need to edit unless (`demo_run = False`)\n", - "* Update these parameters to run STREAMLINE on a different folder of datasets. Any folder of datasets to be analyzed should include one or more datasets saved as `.txt`, `.csv` or `.tsv` files. See documentation for dataset formatting requirements.\n", - "\n", - "* All datasets should have the same header names for the class, instance, and match labels (note instance and match labels are optional)\n", - "* When specifying features to be treated as categorical vs. quantitative:\n", - " * If these lists are left empty, STREAMLINE will assign feature type based on the `categorical_cutoff`(under 'General Run Parameters'). I.e. features with more than `categorical_cutoff` unique values will be treated as quanatiative\n", - " * Any binary features need not be specified as they will be assigned as categorical by default\n", - " * User can specify either just categorical or quanatiative feature names, and all other unspecified non-binary features will be assigned to the other feature type by default " - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "FyViM3Q-oTFU" - }, - "outputs": [], - "source": [ - "if not demo_run: # Leave this command as is.\n", - "\n", - " # Folder path to the folder containing dataset(s) to be analyzed (must include one or more .txt, .tsv, or .csv datasets)\n", - " data_path = \"./UserData\" # (str) data folder path\n", - "\n", - " # Folder path: where to save pipeline outputs (must be updated for a given user)\n", - " output_path = './UserOutput' # (str) ouput folder path (folder will be created by STREAMLINE automatically)\n", - "\n", - " # Unique experiment name - folder created for this analysis within output folder path\n", - " experiment_name = 'my_experiment' # (str) experiment name (change to save a new STREAMLINE run output folder instead of overwriting previous run)\n", - "\n", - " # Data Labels\n", - " class_label = 'Class' # (str) i.e. class outcome column name\n", - " instance_label = 'InstanceID' # (str) if data includes instance labels, given respective column name here, otherwise put 'None'\n", - " match_label = None # (str or None) only applies when M selected for partition-method; indicates column name including matched instance ids'\n", - "\n", - " # Option to manually specify feature names to leave out of analysis, or which to treat as categorical vs. quantitative (without using built in variable type detector)\n", - " ignore_features = None # (list of str values or None) list of column names (given as string values) to exclude from the analysis (only insert column names if needed, otherwise specify 'None')\n", - " categorical_feature_headers = None # (list of str values or None) specify 'None' for 'auto-detect' otherwise list feature names (given as string values) to be treated as categorical.\n", - " quantitiative_feature_headers = None # (list of str values or None) specify 'None' for 'auto-detect' otherwise list feature names (given as string values) to be treated as quantitative." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "-TUI02jpqAYW" - }, - "source": [ - "### Replication Data - Run Parameters (Phase 8)\n", - "* Don't edit unless (`demo_run = False`)\n", - "\n", - "* Update these parameters to run STREAMLINE's 'replication' phase where all models trained in the earlier phases are evaluated on the same hold-out replication data (recommended when available)\n", - "\n", - "* Multiple replication datasets (e.g. data collected from different sites) can be included in the replication data folder and STREAMLINE will apply replication analyses to each individually" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "WU5Qg99kqArq" - }, - "outputs": [], - "source": [ - "if not demo_run: # Leave this command as is.\n", - "\n", - " # Turns the replication data analysis phase on or off\n", - " applyToReplication = True # (bool, True or False) leave false unless you have one or more replication datasets to further evaluate/compare all models in uniform manner\n", - " \n", - " # Folder path to the folder containing the replication dataset(s) to be evaluated using previously trained models for a specific target dataset (.txt, .tsv, or .csv datasets))\n", - " rep_data_path = \"./UserRepData\" # (txt) data folder path for replication Dataset(s)\n", - " \n", - " # File path to one of the individual datasets used to train models within STREAMLINE\n", - " dataset_for_rep = \"./UserData/user_data_rep.csv\" # (txt) path and name of an individual dataset used to generate the models being evaluated with replication data" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "2lfjpdkrcGf5" - }, - "source": [ - "--------------\n", - "## Non-Essential Run Parameters\n", - "### General - Run Parameters (Phase 1)\n", - "* Optionally update these general parameters used throughout all/most phases of the pipeline" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "id": "KtyZbhKUXyjF" - }, - "outputs": [], - "source": [ - "# Cross Validation (CV)\n", - "n_splits = 3 # (int, > 1) number of training/testing data partitions to create - and resulting number of models generated using each ML algorithm\n", - "partition_method = 'Stratified' # (str) with options; Stratified, Random, or Group\n", - "\n", - "# Cutoffs\n", - "categorical_cutoff = 10 # (int) number of unique values after which a variable is considered to be quantitative vs categorical if categorical_features_headers or quantitative_feature_headers not specified.\n", - "sig_cutoff = 0.05 # (float, 0-1) significance cutoff used throughout pipeline\n", - "\n", - "# Set Random Seed for Reproducible Analysis\n", - "random_state = 42 # (int) sets a specific random seed for reproducible results" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "60Pbh38acLlj" - }, - "source": [ - "### Data Processing - Run Parameters (Phase 1)\n", - "* Optionally, update these parameters to decide what analyses are run and outputs are produced by STREAMLINE in the exploratory analysis phase" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "id": "mBoYcHI0cgEz" - }, - "outputs": [], - "source": [ - "# EDA outpute file controls (None, outputs all files)\n", - "exclude_eda_output = None # (None, or a list of 'str' values) with possible exclusions: ['describe','univariate_plots','correlation_plots']\n", - "top_uni_features = 20 # (int) number of top significant features to report in notebook for univariate analysis\n", - "\n", - "# Data processing parameters (cleaning and feature engineering)\n", - "featureeng_missingness = 0.5 # (float, 0-1) proportion of missing values above which categorical feature encoding missingness is generated\n", - "cleaning_missingness = 0.5 # (float, 0-1) proportion of missing values at which instance and feature removal is performed\n", - "correlation_removal_threshold = 1 # (float, 0-1) feature correlation at which one out of a pair of features is randomly removed" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "DBQP30iGpV6j" - }, - "source": [ - "### Scaling and Imputing - Run Parameters (Phase 2)\n", - "* Optionally update these parameters to turn specific data preprocessing options on or off" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "2hKlwP7wpWUA" - }, - "outputs": [], - "source": [ - "# Data Transformation (i.e. scaling) - important for running and interpreting built-in feature importance estimates for certain ML modeling algorithms\n", - "scale_data = True # (bool, True or False) perform data scaling (recommended True)\n", - "\n", - "# Missing Data Imputation Options\n", - "impute_data = True # (bool, True or False) perform missing value data imputation (required for most ML algorithms if missing data is present)\n", - "multi_impute = True # (bool, True or False) apply multivariate imputation to quantitative features, otherwise uses mean imputation\n", - "\n", - "# When False, optionally keep the intermediary CV files generated in Phase 1, otherwise overwrite them with new scaled/imputed ones\n", - "overwrite_cv = False # (bool, True or False) " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "20i7JqJH332M" - }, - "source": [ - "### Feature Importance Estimation - Run Parameters (Phase 3)\n", - "* Optionally update these parameters to decide which filter-based feature importance estimation algorithms to apply (currently only mutual information and MultiSURF are options)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "id": "CtQxdYfi34P8" - }, - "outputs": [], - "source": [ - "# Available Filter-based Feature Importance/Selection Algorithms\n", - "do_mutual_info = True # (bool, True or False) do mutual information analysis\n", - "do_multisurf = True # (bool, True or False) do multiSURF analysis\n", - "\n", - "# Additional MultiSURF Options\n", - "use_TURF = False # (bool, True or False) use TURF wrapper around MultiSURF (recommended for datasets with >10,000 features)\n", - "TURF_pct = 0.5 # (float, 0.01-0.5) proportion of instances removed in an iteration (also dictates number of iterations as 1/TURF_pct)\n", - "instance_subset = 2000 # (int) sample subset size to use with MultiSURF (since MultiSURF's compute time scales quadratically with instance count)\n", - "njobs = -1 # (int) number of cores dedicated to running algorithm; setting to -1 will use all available cores when run locally" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "zXlPgkcn6T0A" - }, - "source": [ - "### Feature Selection - Run Parameters (Phase 4)\n", - "* Optionally update these parameters to control how 'collective' feature selection is conducted prior to modeling.\n", - "\n", - " * When `filter_poor_features = False`, all features will be used in the modeling phase.\n", - "\n", - " * When `filter_poor_features = True`:\n", - " * And `max_features_to_keep = None`, all features with a score <= 0 from all active feature importance algorithm will be removed, but the rest kept.\n", - "\n", - " * And `max_features_to_keep = n` (where n is a 'value' less than the total number of features in the dataset), first all features with a score <= 0 from all active feature importance algorithm will be removed, then the top n scoring (non-redundant) features from each algorithm will be kept." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "id": "9I5eaBmU6UEl" - }, - "outputs": [], - "source": [ - "# Turn feature selection on or off\n", - "filter_poor_features = True # (bool, True or False) filter out features with no indication of being informative prior to modeling\n", - "\n", - "# Control maximum number of features to keep out of total features in dataset.\n", - "max_features_to_keep = 2000 # (int or None) maximum features to keep. 'None' if no max\n", - "\n", - "# Controls the feature importance estimation plots generation\n", - "top_fi_features = 40 # (int) number of top scoring features to illustrate in feature importance figures\n", - "export_scores = True # (bool, True or False) export figure summarizing average feature importance scores over cv partitions\n", - "\n", - "# When False, optionally keep the intermediary CV files generated in Phase 2, otherwise overwrite them with new feature selected ones\n", - "overwrite_cv_feat = False # (bool, True or False)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "QmjcXp6y9yDC" - }, - "source": [ - "### Modeling - Run Parameters (Phase 5)\n", - "* Optionally update these parameters to control what modeling algorithms are run, as well as other options relevant to the modeling phase. The 16 Classification algorithms currently available in STREAMLINE include:\n", - "\n", - " * Naive Bayes (NB)\n", - " * Logistic Regression (LR)\n", - " * Elastic Net (EN)\n", - " * Decision Tree (DT)\n", - " * Random Forest (RF)\n", - " * Gradient Boosting (GB)\n", - " * Extreame Gradient Boosting (XGB)\n", - " * Light Gradient Boosting (LGB)\n", - " * Category Gradient Boosting (CGB)\n", - " * Support Vector Machines (SVM)\n", - " * Artificial Neural Networks (ANN)\n", - " * K-Nearest Neighbors (KNN)\n", - " * Genetic Programming, i.e. symbolic classification (GP)\n", - " * Educational Learning Classifier System (eLCS)\n", - " * 'X' Classifier System (XCS)\n", - " * Extended Supervised Tracking Classifier System (ExSTraCS)\n", - "\n", - "The last 3 algorithms above are rule-based ML approaches implemented by our research group. eLCS and XCS are under active development so they have been turned off when using default settings.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "id": "Tc_cuqYo9yTF" - }, - "outputs": [], - "source": [ - "# Machine Learning Algorithms to Run (Setting 'algorithms' to 'None' rather than a list will run all algorithms except those specified in 'exclude')\n", - "algorithms = [\"NB\", \"LR\", \"DT\"] # (list of strings or None) options: [\"NB\",\"LR\",\"EN\",\"DT\",\"RF\",\"GB\",\"XGB\",\"LGB\",\"CGB\",\"SVM\",\"ANN\",\"KNN\",\"GP\",\"eLCS\",\"XCS\",\"ExSTraCS\"]\n", - "\n", - "# ML Model Algorithm to exclude (no need to fill out if 'algorithms' are specified)\n", - "exclude = ['eLCS', 'XCS'] # (list of strings or None) options: [\"NB\",\"LR\",\"EN\",\"DT\",\"RF\",\"GB\",\"XGB\",\"LGB\",\"CGB\",\"SVM\",\"ANN\",\"KNN\",\"GP\",\"eLCS\",\"XCS\",\"ExSTraCS\"]\n", - "\n", - "# Other Analysis Parameters\n", - "training_subsample = 0 # (int) for long running algorithms, option to subsample training set (0 for no subsample) to limit the sample size used to train algorithms that do not scale up well in large instance spaces (i.e. XGB,SVM,KN,ANN,and LR) and depending on 'instances' settings, ExSTraCS, eLCS, and XCS)\n", - "use_uniform_FI = True # (bool, True or False) overides use of any available feature importances estimate methods from models, instead using permutation_importance uniformly\n", - "primary_metric = 'balanced_accuracy' # (str) metric used to optimize hyperparameters: must be an available metric identifier from (https://scikit-learn.org/stable/modules/model_evaluation.html#scoring-parameter)\n", - "metric_direction = 'maximize' # (str) options 'maximize' or 'minimize': must be selected appropriately for the chosen primary metric (generally maximize)\n", - "\n", - "# Hyperparameter Sweep Options\n", - "n_trials = 200 # (int) number of bayesian hyperparameter optimization trials using Optuna\n", - "timeout = 900 # (int or None) seconds until hyperparameter sweep stops running new trials (Note: it may run longer to finish last trial started): must be set to None to ensure STREAMLINE reproducibility\n", - "export_hyper_sweep_plots = True # (bool, True or False) export hyperparameter sweep plots generated with Optuna\n", - "\n", - "# Learning classifier system algorithm options (ExSTraCS, eLCS, XCS)\n", - "do_lcs_sweep = False # (bool, True or False) do LCS hyperparameter tuning otherwise use specified hyperparameter settings below (we recommend leaving this False, as it can take a long time to run)\n", - "lcs_nu = 1 # (int, 0-10) specify LCS nu parameter (higher values place more pressure to generate accurate rules, but easily leads to overfitting in noisy problems)\n", - "lcs_iterations = 200000 # (int, > training data instance count) specify the number of LCS learning iterations to conduct\n", - "lcs_N = 2000 # (int) > 500) specify the maximum rule population size for the LCS algorithm\n", - "lcs_timeout = 1200 # (int) seconds until hyperparameter sweep stops for LCS algorithms (note: evolutionary algorithms often require more time for a single run)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "6zKal9-MB1IH" - }, - "source": [ - "### Post-Analysis - Run Parameters (Phase 6)\n", - "* Optionally update these parameters to control aspects of model evaluation figure generation. Note that all STREAMLINE performance metric evaluations and figures are generated with respect to the hold out testing data in this phase." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "id": "9ZoJ7JVIB1aP" - }, - "outputs": [], - "source": [ - "# Post-analysis output file controls \n", - "exclude_plots = None # (None, or a list of 'str' values) with possible exclusions: ['plot_ROC', 'plot_PRC', 'plot_FI_box', 'plot_metric_boxplots']\n", - "top_model_fi_features = 40 # (int) number of top features in model to illustrate in feature importance figures\n", - "metric_weight = 'balanced_accuracy' # (str, balanced_accuracy or roc_auc) ML model metric used as weight in composite FI plots (only supports balanced_accuracy or roc_auc as options): recommend setting the same as primary_metric if possible" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Replication - Run Parameters (Phase 8)\n", - "* Optionally update these parameters if you're running replication phase to exclude plots " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "# Replication output file controls \n", - "exclude_rep_plots = None # (None, outputs all files) with possible exlusions ['plot_ROC', 'plot_PRC', 'plot_metric_boxplots','feature_correlations']" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "rZHO8BTccGuR" - }, - "source": [ - "### Cleanup - Run Parameters\n", - "* Optionally update these parameters to delete temporary files in output folder (generally recommended to leave these as `True`)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "id": "aWhgkZFTcG-H" - }, - "outputs": [], - "source": [ - "del_time = False # (bool, True or False) delete individual run-time files (but save summary)\n", - "del_old_cv = False # (bool, True or False) delete any of the older versions of CV training and testing datasets if overwrite_cv was set to False" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "oGjuHXOdZFyh" - }, - "source": [ - "-------------\n", - "\n", - "# Most Users - We recommend you do not make code edits below this cell.\n", - "\n", - "--------------" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "WDP9cvFQTN1N" - }, - "source": [ - "# DEMO DATA ANALYSIS SETUP \n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Ej-ZhNo_ZKzX" - }, - "source": [ - "### Demo Data Run Parameters:\n", - "* Set up for Demo Run (never edit the code cell below)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "id": "G46uzad2RJPL" - }, - "outputs": [], - "source": [ - "if demo_run: # Leave this command as is.\n", - "\n", - " # Folder path to the folder containing dataset(s) to be analyzed (must include one or more .txt, .tsv, or .csv datasets)\n", - " data_path = \"./data/DemoData\" # (str) data folder path\n", - "\n", - " # Output foder path: where to save pipeline outputs (must be updated for a given user)\n", - " output_path = './DemoOutput' # (str) ouput folder path (folder will be created by STREAMLINE automatically)\n", - "\n", - " # Unique experiment name - folder created for this analysis within output folder path\n", - " experiment_name = 'demo_experiment' # (str) experiment name (change to save a new STREAMLINE run output folder instead of overwriting previous run)\n", - "\n", - " # Data Labels\n", - " class_label = 'Class' # (str) i.e. class outcome column name\n", - " instance_label = 'InstanceID' # (str) If data includes instance labels, given respective column name here, otherwise put 'None'\n", - " match_label = None # (str or None) only applies when M selected for partition-method; indicates column name including matched instance ids'\n", - "\n", - " # Option to manually specify feature names to leave out of analysis\n", - " ignore_features = None # list of column names (given as string values) to exclude from the analysis (only insert column names if needed, otherwise leave empty)\n", - "\n", - " # Recommended option to manually specify what features to treat as categorical: None for 'auto-detect', otherwise list feature names (given as string values) to be treated as categorical\n", - " categorical_feature_headers = ['Gender','Symptoms','Alcohol','Hepatitis B Surface Antigen','Hepatitis B e Antigen','Hepatitis B Core Antibody','Hepatitis C Virus Antibody','Cirrhosis',\n", - " 'Endemic Countries','Smoking','Diabetes','Obesity','Hemochromatosis','Arterial Hypertension','Chronic Renal Insufficiency','Human Immunodeficiency Virus',\n", - " 'Nonalcoholic Steatohepatitis','Esophageal Varices','Splenomegaly','Portal Hypertension','Portal Vein Thrombosis','Liver Metastasis','Radiological Hallmark',\n", - " 'Sim_Cat_2','Sim_Cat_3','Sim_Cat_4','Sim_Text_Cat_2','Sim_Text_Cat_3','Sim_Text_Cat_4']\n", - "\n", - " # Recommended option to manually specify what features to treat as quantitative: None for 'auto-detect', otherwise list feature names (given as string values) to be treated as quantitative\n", - " quantitiative_feature_headers = ['Age at diagnosis','Grams of Alcohol per day','Packs of cigarets per year', 'Performance Status*', 'Encephalopathy degree*','Ascites degree*',\n", - " 'International Normalised Ratio*','Alpha-Fetoprotein (ng/mL)','Haemoglobin (g/dL)','Mean Corpuscular Volume', 'Leukocytes(G/L)',\n", - " 'Platelets','Albumin (mg/dL)','Total Bilirubin(mg/dL)','Alanine transaminase (U/L)','Aspartate transaminase (U/L)','Gamma glutamyl transferase (U/L)',\n", - " 'Alkaline phosphatase (U/L)', 'Total Proteins (g/dL)', 'Creatinine (mg/dL)','Number of Nodules','Major dimension of nodule (cm)','Direct Bilirubin (mg/dL)',\n", - " 'Iron','Oxygen Saturation (%)','Ferritin (ng/mL)','Sim_Miss_0.6','Sim_Miss_0.7','Sim_Cor_-1.0_A','Sim_Cor_-1.0_B','Sim_Cor_0.9_A', 'Sim_Cor_0.9_B',\n", - " 'Sim_Cor_1.0_A','Sim_Cor_1.0_B']\n", - "\n", - " # Turns the replication data analysis phase on or off\n", - " applyToReplication = True # (bool, True or False) leave false unless you have a replication dataset handy to further evaluate/compare all models in uniform manner\n", - "\n", - " # Folder path to the folder containing the replication dataset(s) to be evaluated using previously trained models (.txt, .tsv, or .csv datasets))\n", - " rep_data_path = \"./data/DemoRepData\" # (txt) name of folder with replication dataset(s)\n", - "\n", - " # File path to one of the individual datasets used to train models within STREAMLINE\n", - " dataset_for_rep = \"./data/DemoData/hcc_data_custom.csv\" # (txt) path and name of an individual dataset used to generate the models being evaluated with replication data" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "JV_tzea2hnFY" - }, - "source": [ - "-------------" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "sgqLm-qZhHc7" - }, - "source": [ - "# STREAMLINE RUN CODE\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "8cbakQ8iF_kl" - }, - "source": [ - "## Notebook Housekeeping\n", - "* Sets up notebook cells to display internal process\n", - "\n", - "* Use `logging.INFO` for higher level output, `logging.WARNING` for only critical information. Comment to hide all text output.\n", - "\n", - "* You can use `run_parallel = True` for phases other than modeling, but the advantage is not significant vs the overhead for small jobs" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "id": "_0Y-6f2x85co" - }, - "outputs": [], - "source": [ - "import logging\n", - "import warnings\n", - "FORMAT = '%(levelname)s: %(message)s'\n", - "logging.basicConfig(format=FORMAT)\n", - "logger = logging.getLogger()\n", - "logger.setLevel(logging.INFO)\n", - "warnings.simplefilter(action='ignore', category=FutureWarning)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "FP4W9tfhRHmd" - }, - "source": [ - "* Housekeeping code allowing notebook to be run again with the same settings, overwriting a previously run experiment with the same name\n", - " * Comment out code cell below to avoid this behavior" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "id": "nMK0OPphGHGZ" - }, - "outputs": [], - "source": [ - "import os\n", - "import shutil\n", - "if os.path.exists(output_path+'/'+experiment_name):\n", - " shutil.rmtree(output_path+'/'+experiment_name)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "wbkz75LgGD9r" - }, - "source": [ - "## STREAMLINE Workflow\n", - "* The code below runs through the analysis phases of STREAMLINE" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Q-k3iBM190S6" - }, - "source": [ - "## Phase 1: EDA and Data Processing\n", - "After cell runs, for each target dataset you will see:\n", - "* An initial EDA data counts summary\n", - "* Notification of features removed (during cleaning) or added (during feature engineering)\n", - "* A processed EDA data counts summary\n", - "* Class balance barplot\n", - "* Feature correlation heatmap\n", - "* Top univariate analysis results" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "ofRidh1S9xgE", - "outputId": "a2eb1a58-461a-4ac6-ca12-150b5c5b226e", - "scrolled": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Note: NumExpr detected 32 cores but \"NUMEXPR_MAX_THREADS\" not set, so enforcing safe limit of 8.\n", - "INFO: NumExpr defaulting to 8 threads.\n", - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data\n", - "WARNING: Warning: Specified 'Match label' could not be found in dataset. Analysis moving forward assuming there is no 'match label' column using stratified (S) CV partitioning.\n", - "INFO: Validating and Identifying Feature Types...\n", - "WARNING: User specified both categorical vs quantitative features; any unspecified binary features will be treated as categorical, and any remaining features will have their feature types automatically assigned based on categorical_cutoff parameter\n", - "WARNING: Following features specified as categorical were not in target dataset: ['Sim_Text_Cat_2', 'Sim_Text_Cat_3', 'Sim_Cat_4', 'Sim_Cat_3', 'Sim_Text_Cat_4', 'Sim_Cat_2']\n", - "WARNING: Following features specified as quantitative were not in target dataset: ['Sim_Cor_0.9_B', 'Sim_Cor_-1.0_A', 'Sim_Cor_1.0_B', 'Sim_Miss_0.6', 'Sim_Cor_0.9_A', 'Sim_Cor_1.0_A', 'Sim_Miss_0.7', 'Sim_Cor_-1.0_B']\n", - "INFO: Running Initial EDA:\n", - "INFO: Initial Data Counts: ----------------\n", - "INFO: Instance Count = 165\n", - "INFO: Feature Count = 49\n", - "INFO: Categorical = 23\n", - "INFO: Quantitative = 26\n", - "INFO: Missing Count = 826\n", - "INFO: Missing Percent = 0.10216450216450217\n", - "INFO: Class Counts: ----------------\n", - "INFO: Class Count Information\n", - "INFO: \n", - " Class Instances\n", - "0 0 102\n", - "1 1 63\n", - "INFO: No textual categorical features, skipping label encoding\n", - "INFO: Running Feature Engineering\n", - "INFO: No Features with high missingness found\n", - "INFO: Not removing any features due to high missingness\n", - "INFO: No non-binary categorical features, skipping categorical encoding\n", - "INFO: Top 10 Correlated Features\n", - "INFO: \n", - " Removed_Feature Correlated_Feature Correlation\n", - "1801 Total Bilirubin(mg/dL) Direct Bilirubin (mg/dL) 0.978124\n", - "2291 Iron Oxygen Saturation (%) 0.782957\n", - "1843 Alanine transaminase (U/L) Aspartate transaminase (U/L) 0.727780\n", - "122 Alcohol Grams of Alcohol per day 0.712681\n", - "844 Esophageal Varices Splenomegaly 0.629077\n", - "845 Esophageal Varices Portal Hypertension 0.624371\n", - "894 Splenomegaly Portal Hypertension 0.617743\n", - "1943 Gamma glutamyl transferase (U/L) Alkaline phosphatase (U/L) 0.567314\n", - "1607 Mean Corpuscular Volume Oxygen Saturation (%) 0.545314\n", - "2341 Oxygen Saturation (%) Ferritin (ng/mL) 0.479226\n", - "INFO: No Features with correlation higher that parameter\n", - "INFO: Running Basic Exploratory Analysis...\n", - "INFO: Processed Data Counts: ----------------\n", - "INFO: Instance Count = 165\n", - "INFO: Feature Count = 49\n", - "INFO: Categorical = 23\n", - "INFO: Quantitative = 26\n", - "INFO: Missing Count = 826\n", - "INFO: Missing Percent = 0.10216450216450217\n", - "INFO: Class Counts: ----------------\n", - "INFO: Class Count Information\n", - "INFO: \n", - " Class Instances\n", - "0 0 102\n", - "1 1 63\n", - "INFO: Categorical Features: ['Gender', 'Symptoms', 'Alcohol', 'Hepatitis B Surface Antigen', 'Hepatitis B e Antigen', 'Hepatitis B Core Antibody', 'Hepatitis C Virus Antibody', 'Cirrhosis', 'Endemic Countries', 'Smoking', 'Diabetes', 'Obesity', 'Hemochromatosis', 'Arterial Hypertension', 'Chronic Renal Insufficiency', 'Human Immunodeficiency Virus', 'Nonalcoholic Steatohepatitis', 'Esophageal Varices', 'Splenomegaly', 'Portal Hypertension', 'Portal Vein Thrombosis', 'Liver Metastasis', 'Radiological Hallmark']\n", - "INFO: \t Engineered Features: []\n", - "INFO: \t One Hot Features: []\n", - "INFO: Quantitative Features: ['Age at diagnosis', 'Grams of Alcohol per day', 'Packs of cigarets per year', 'Performance Status*', 'Encephalopathy degree*', 'Ascites degree*', 'International Normalised Ratio*', 'Alpha-Fetoprotein (ng/mL)', 'Haemoglobin (g/dL)', 'Mean Corpuscular Volume', 'Leukocytes(G/L)', 'Platelets', 'Albumin (mg/dL)', 'Total Bilirubin(mg/dL)', 'Alanine transaminase (U/L)', 'Aspartate transaminase (U/L)', 'Gamma glutamyl transferase (U/L)', 'Alkaline phosphatase (U/L)', 'Total Proteins (g/dL)', 'Creatinine (mg/dL)', 'Number of Nodules', 'Major dimension of nodule (cm)', 'Direct Bilirubin (mg/dL)', 'Iron', 'Oxygen Saturation (%)', 'Ferritin (ng/mL)']\n", - "INFO: Final List of Features:\n", - "INFO: ['Gender', 'Symptoms', 'Alcohol', 'Hepatitis B Surface Antigen', 'Hepatitis B e Antigen', 'Hepatitis B Core Antibody', 'Hepatitis C Virus Antibody', 'Cirrhosis', 'Endemic Countries', 'Smoking', 'Diabetes', 'Obesity', 'Hemochromatosis', 'Arterial Hypertension', 'Chronic Renal Insufficiency', 'Human Immunodeficiency Virus', 'Nonalcoholic Steatohepatitis', 'Esophageal Varices', 'Splenomegaly', 'Portal Hypertension', 'Portal Vein Thrombosis', 'Liver Metastasis', 'Radiological Hallmark', 'Age at diagnosis', 'Grams of Alcohol per day', 'Packs of cigarets per year', 'Performance Status*', 'Encephalopathy degree*', 'Ascites degree*', 'International Normalised Ratio*', 'Alpha-Fetoprotein (ng/mL)', 'Haemoglobin (g/dL)', 'Mean Corpuscular Volume', 'Leukocytes(G/L)', 'Platelets', 'Albumin (mg/dL)', 'Total Bilirubin(mg/dL)', 'Alanine transaminase (U/L)', 'Aspartate transaminase (U/L)', 'Gamma glutamyl transferase (U/L)', 'Alkaline phosphatase (U/L)', 'Total Proteins (g/dL)', 'Creatinine (mg/dL)', 'Number of Nodules', 'Major dimension of nodule (cm)', 'Direct Bilirubin (mg/dL)', 'Iron', 'Oxygen Saturation (%)', 'Ferritin (ng/mL)']\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Generating Feature Correlation Heatmap...\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Running Univariate Analyses...\n", - "INFO: Plotting top significant 20 features.\n", - "INFO: ###################################################\n", - "INFO: Significant Univariate Associations:\n", - "INFO: Alkaline phosphatase (U/L): (p-val = 8.425494437393163e-07)\n", - "INFO: Performance Status*: (p-val = 1.8787043290235831e-06)\n", - "INFO: Alpha-Fetoprotein (ng/mL): (p-val = 3.7632257667465082e-06)\n", - "INFO: Haemoglobin (g/dL): (p-val = 6.806983230077955e-05)\n", - "INFO: Albumin (mg/dL): (p-val = 0.0002097286566980117)\n", - "INFO: Symptoms: (p-val = 0.0006092985105592953)\n", - "INFO: Ascites degree*: (p-val = 0.0010580963945994142)\n", - "INFO: Direct Bilirubin (mg/dL): (p-val = 0.0013544764761447027)\n", - "INFO: Aspartate transaminase (U/L): (p-val = 0.0016188344745582482)\n", - "INFO: Ferritin (ng/mL): (p-val = 0.0019988859548087426)\n", - "INFO: Liver Metastasis: (p-val = 0.002993588224869906)\n", - "INFO: Iron: (p-val = 0.009131914019954513)\n", - "INFO: Portal Vein Thrombosis: (p-val = 0.01174304115542567)\n", - "INFO: Gamma glutamyl transferase (U/L): (p-val = 0.019120768577902517)\n", - "INFO: Major dimension of nodule (cm): (p-val = 0.028160240930633438)\n", - "INFO: International Normalised Ratio*: (p-val = 0.03298377968646775)\n", - "INFO: Total Bilirubin(mg/dL): (p-val = 0.033298074732187495)\n", - "INFO: Age at diagnosis: (p-val = 0.03568323751208702)\n", - "INFO: Creatinine (mg/dL): (p-val = 0.09698449209346588)\n", - "INFO: Platelets: (p-val = 0.12125234491493234)\n", - "INFO: Generating Univariate Analysis Plots...\n", - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data_custom\n", - "WARNING: Warning: Specified 'Match label' could not be found in dataset. Analysis moving forward assuming there is no 'match label' column using stratified (S) CV partitioning.\n", - "INFO: Validating and Identifying Feature Types...\n", - "WARNING: User specified both categorical vs quantitative features; any unspecified binary features will be treated as categorical, and any remaining features will have their feature types automatically assigned based on categorical_cutoff parameter\n", - "WARNING: Following features specified as categorical were not in target dataset: ['Gender']\n", - "WARNING: Following features specified as quantitative were not in target dataset: ['Age at diagnosis']\n", - "INFO: Running Initial EDA:\n", - "INFO: Initial Data Counts: ----------------\n", - "INFO: Instance Count = 169\n", - "INFO: Feature Count = 61\n", - "INFO: Categorical = 28\n", - "INFO: Quantitative = 33\n", - "INFO: Missing Count = 1138\n", - "INFO: Missing Percent = 0.11038898050247356\n", - "INFO: Class Counts: ----------------\n", - "INFO: Class Count Information\n", - "INFO: \n", - " Class Instances\n", - "0 0.0 104\n", - "1 1.0 63\n", - "INFO: Ordinal encoding the following features:\n", - "INFO: \tSim_Text_Cat_2\n", - "INFO: Running Feature Engineering\n", - "INFO: Engineering the following Features for missingness:\n", - "INFO: \t Missing_Sim_Miss_0.6\n", - "INFO: \t Missing_Sim_Miss_0.7\n", - "INFO: Removing the following Features due to Missingness:\n", - "INFO: \tSim_Miss_0.6\n", - "INFO: \tSim_Miss_0.7\n", - "INFO: One-hot encoding the following features:\n", - "INFO: \tSim_Cat_3\n", - "INFO: \tSim_Cat_4\n", - "INFO: \tSim_Text_Cat_3\n", - "INFO: \tSim_Text_Cat_4\n", - "INFO: Top 10 Correlated Features\n", - "INFO: \n", - " Removed_Feature Correlated_Feature Correlation\n", - "3519 Sim_Cor_-1.0_A Sim_Cor_-1.0_B -1.000000\n", - "3807 Sim_Cor_1.0_A Sim_Cor_1.0_B 1.000000\n", - "2449 Total Bilirubin(mg/dL) Direct Bilirubin (mg/dL) 0.978124\n", - "3159 Iron Oxygen Saturation (%) 0.782957\n", - "2513 Alanine transaminase (U/L) Aspartate transaminase (U/L) 0.727780\n", - "93 Alcohol Grams of Alcohol per day 0.712681\n", - "1146 Esophageal Varices Splenomegaly 0.629077\n", - "1147 Esophageal Varices Portal Hypertension 0.624371\n", - "1218 Splenomegaly Portal Hypertension 0.617743\n", - "4599 Sim_Text_Cat_3_Category 1 Sim_Text_Cat_3_Category 2 -0.567977\n", - "INFO: Removing the following Features due to high correlation:\n", - "INFO: Sim_Cor_-1.0_A\n", - "INFO: Sim_Cor_1.0_A\n", - "INFO: Running Basic Exploratory Analysis...\n", - "INFO: Processed Data Counts: ----------------\n", - "INFO: Instance Count = 165\n", - "INFO: Feature Count = 69\n", - "INFO: Categorical = 40\n", - "INFO: Quantitative = 29\n", - "INFO: Missing Count = 826\n", - "INFO: Missing Percent = 0.07255160298638559\n", - "INFO: Class Counts: ----------------\n", - "INFO: Class Count Information\n", - "INFO: \n", - " Class Instances\n", - "0 0 102\n", - "1 1 63\n", - "INFO: Categorical Features: ['Symptoms', 'Alcohol', 'Hepatitis B Surface Antigen', 'Hepatitis B e Antigen', 'Hepatitis B Core Antibody', 'Hepatitis C Virus Antibody', 'Cirrhosis', 'Endemic Countries', 'Smoking', 'Diabetes', 'Obesity', 'Hemochromatosis', 'Arterial Hypertension', 'Chronic Renal Insufficiency', 'Human Immunodeficiency Virus', 'Nonalcoholic Steatohepatitis', 'Esophageal Varices', 'Splenomegaly', 'Portal Hypertension', 'Portal Vein Thrombosis', 'Liver Metastasis', 'Radiological Hallmark', 'Sim_Cat_2', 'Sim_Text_Cat_2', 'miss_Sim_Miss_0.6', 'miss_Sim_Miss_0.7', 'Sim_Cat_3_1', 'Sim_Cat_3_2', 'Sim_Cat_3_3', 'Sim_Cat_4_1', 'Sim_Cat_4_2', 'Sim_Cat_4_3', 'Sim_Cat_4_4', 'Sim_Text_Cat_3_Category 1', 'Sim_Text_Cat_3_Category 2', 'Sim_Text_Cat_3_Category 3', 'Sim_Text_Cat_4_Category 1', 'Sim_Text_Cat_4_Category 2', 'Sim_Text_Cat_4_Category 3', 'Sim_Text_Cat_4_Category 4']\n", - "INFO: \t Engineered Features: ['miss_Sim_Miss_0.6', 'miss_Sim_Miss_0.7']\n", - "INFO: \t One Hot Features: ['Sim_Cat_3_1', 'Sim_Cat_3_2', 'Sim_Cat_3_3', 'Sim_Cat_4_1', 'Sim_Cat_4_2', 'Sim_Cat_4_3', 'Sim_Cat_4_4', 'Sim_Text_Cat_3_Category 1', 'Sim_Text_Cat_3_Category 2', 'Sim_Text_Cat_3_Category 3', 'Sim_Text_Cat_4_Category 1', 'Sim_Text_Cat_4_Category 2', 'Sim_Text_Cat_4_Category 3', 'Sim_Text_Cat_4_Category 4']\n", - "INFO: Quantitative Features: ['Grams of Alcohol per day', 'Packs of cigarets per year', 'Performance Status*', 'Encephalopathy degree*', 'Ascites degree*', 'International Normalised Ratio*', 'Alpha-Fetoprotein (ng/mL)', 'Haemoglobin (g/dL)', 'Mean Corpuscular Volume', 'Leukocytes(G/L)', 'Platelets', 'Albumin (mg/dL)', 'Total Bilirubin(mg/dL)', 'Alanine transaminase (U/L)', 'Aspartate transaminase (U/L)', 'Gamma glutamyl transferase (U/L)', 'Alkaline phosphatase (U/L)', 'Total Proteins (g/dL)', 'Creatinine (mg/dL)', 'Number of Nodules', 'Major dimension of nodule (cm)', 'Direct Bilirubin (mg/dL)', 'Iron', 'Oxygen Saturation (%)', 'Ferritin (ng/mL)', 'Sim_Cor_-1.0_B', 'Sim_Cor_0.9_A', 'Sim_Cor_0.9_B', 'Sim_Cor_1.0_B']\n", - "INFO: Final List of Features:\n", - "INFO: ['Symptoms', 'Alcohol', 'Hepatitis B Surface Antigen', 'Hepatitis B e Antigen', 'Hepatitis B Core Antibody', 'Hepatitis C Virus Antibody', 'Cirrhosis', 'Endemic Countries', 'Smoking', 'Diabetes', 'Obesity', 'Hemochromatosis', 'Arterial Hypertension', 'Chronic Renal Insufficiency', 'Human Immunodeficiency Virus', 'Nonalcoholic Steatohepatitis', 'Esophageal Varices', 'Splenomegaly', 'Portal Hypertension', 'Portal Vein Thrombosis', 'Liver Metastasis', 'Radiological Hallmark', 'Grams of Alcohol per day', 'Packs of cigarets per year', 'Performance Status*', 'Encephalopathy degree*', 'Ascites degree*', 'International Normalised Ratio*', 'Alpha-Fetoprotein (ng/mL)', 'Haemoglobin (g/dL)', 'Mean Corpuscular Volume', 'Leukocytes(G/L)', 'Platelets', 'Albumin (mg/dL)', 'Total Bilirubin(mg/dL)', 'Alanine transaminase (U/L)', 'Aspartate transaminase (U/L)', 'Gamma glutamyl transferase (U/L)', 'Alkaline phosphatase (U/L)', 'Total Proteins (g/dL)', 'Creatinine (mg/dL)', 'Number of Nodules', 'Major dimension of nodule (cm)', 'Direct Bilirubin (mg/dL)', 'Iron', 'Oxygen Saturation (%)', 'Ferritin (ng/mL)', 'Sim_Cat_2', 'Sim_Text_Cat_2', 'Sim_Cor_-1.0_B', 'Sim_Cor_0.9_A', 'Sim_Cor_0.9_B', 'Sim_Cor_1.0_B', 'Missing_Sim_Miss_0.6', 'Missing_Sim_Miss_0.7', 'Sim_Cat_3_1', 'Sim_Cat_3_2', 'Sim_Cat_3_3', 'Sim_Cat_4_1', 'Sim_Cat_4_2', 'Sim_Cat_4_3', 'Sim_Cat_4_4', 'Sim_Text_Cat_3_Category 1', 'Sim_Text_Cat_3_Category 2', 'Sim_Text_Cat_3_Category 3', 'Sim_Text_Cat_4_Category 1', 'Sim_Text_Cat_4_Category 2', 'Sim_Text_Cat_4_Category 3', 'Sim_Text_Cat_4_Category 4']\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Generating Feature Correlation Heatmap...\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAACmEAAAlHCAYAAABgxDTfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzde1zP9///8XsHlWjOw9REFJuaN/rkbMuxTDOnyZbRND7GhoUMM8yhOcs252HOUmi1YRnTlvPxg7SPQw7h4zCHlEL9/vDz/nqvGO/Me+N2vVzel0vv1/P5ej4fr1ft8Mf98nxY5eTk5AgAAAAAAAAAAAAAAAAAAACPxNrSBQAAAAAAAAAAAAAAAAAAAPwTEcIEAAAAAAAAAAAAAAAAAAAwAyFMAAAAAAAAAAAAAAAAAAAAMxDCBAAAAAAAAAAAAAAAAAAAMAMhTAAAAAAAAAAAAAAAAAAAADMQwgQAAAAAAAAAAAAAAAAAADADIUwAAAAAAAAAAAAAAAAAAAAzEMIEAAAAAAAAAAAAAAAAAAAwAyFMAAAAAAAAAAAAAAAAAAAAMxDCBAAAAAAAAAAAAAAAAAAAMAMhTAAAAAAAAAAAAAAAAAAAADMQwgQAAAAAAAAAAAAAAAAAADADIUwAAAAAAAAAAAAAAAAAAAAzEMIEAAAAAAAAAAAAAAAAAAAwAyFMAAAAAAAAAAAAAAAAAAAAMxDCBAAAAAAAAAAAAAAAAAAAMAMhTAAAAAAAAAAAAAAAAAAAADMQwsQ/VkxMjN566y0ZDAYZDAa1bdtWS5cutWhNqampio2NtWgNAAAAAAAAAAAAAAAAAIAnw9bSBQDmiIyM1Oeff65PPvlE3t7eysnJUWJiokaNGqULFy6oV69eFqlr4MCBKleunFq2bGmR/QEAAAAAAAAAAAAAAAAATw4hTPwjLV68WO3atVOHDh2M1ypWrKizZ89qwYIFFgthAgAAAAAAAAAAAAAAAACeHbQjxz+StbW1du3apStXrphcDwkJ0bJlyzRv3jwZDAZlZGQYx7Kzs9WwYUMtWLBAW7du1UsvvaQtW7bI399fnp6eeuutt3Ts2DF9/fXXqlu3rv71r39p5MiRysnJkSRFREQoMDBQM2bMUO3ateXt7a1BgwYpLS1NkhQUFKRt27YpOjpavr6+kqQbN25o8uTJaty4sTw9PdW6dWv9+OOPxpqioqLUtGlTxcXFydfXV15eXnrvvfd07tw5jRo1St7e3qpbt65mzJhhvOfixYv68MMP5ePjIy8vL3Xs2FHbtm37y941AAAAAAAAAAAAAAAAACBvhDDxjxQSEqJDhw6pYcOGev/99zVz5kzt27dPTk5OqlChggICAnTz5k2tW7fOeM+vv/6qS5cu6fXXX5ck3b59W2PHjtXo0aO1fPlyXbx4UR07dtSRI0f07bffql+/flq4cKE2btxoXGP//v3auHGj5syZo2nTpmn79u3q06ePpDshTYPBID8/P0VGRkqS+vXrp1WrVmnw4MFas2aNmjRpol69eik+Pt645pkzZ7RkyRJ99dVX+uabb7R//34FBATI1tZWy5cvV8eOHTVx4kQlJydLkj777DPduHFDCxcuVExMjCpUqKCePXsqPT39L37rAAAAAAAAAAAAAAAAAIB7EcLEP1Lz5s21bNkyNWvWTPv379eECRPUvn17tWjRQjt37lTx4sXl6+urNWvWGO+5e0Jl8eLFjdc++ugjVa9eXVWrVlWzZs10/fp1jRw5Um5uburYsaNKliyp3377zTjfyspKkydP1ssvvywfHx99+umn2rx5s44ePaqiRYuqQIECcnBwUPHixXXkyBHFx8dr2LBh8vX1VYUKFdSrVy81bdpU06dPN6558+ZNDR06VFWqVFHNmjVVp04dOTg4aMCAAapQoYK6d+8uScY6Tpw4oSJFiujFF19U+fLlNXjwYE2dOlU2NjZ/9WsHAAAAAAAAAAAAAAAAANyDECb+sby8vDRu3Dj9+uuvWrNmjT7++GNdv35dISEhunjxotq2batff/1V586dU1pamn788Ue1adPGZI0KFSoYfy5YsKBKliypggULGq/Z29srMzPT+N3V1VWlS5c2fjcYDJJkPKXyXocPH5Yk1axZ0+R6rVq1jGP3q8PZ2VlWVlbGGiQZ6+jVq5fWr18vHx8fdevWTZGRkapUqZJxHgAAAAAAAAAAAAAAAADgySCEiX+cs2fPauTIkTp37pykO6dTenh46P3339f8+fN1/fp1bd++XfXr11epUqUUGxurdevWycnJSQ0aNDBZy9bW1uS7tfWD/5EoUKCAyffs7GxJeqRTKLOzs3Pt+8d1H1RH06ZNtXnzZo0ePVplypTR7Nmz1bx5c5MTOwEAAAAAAAAAAAAAAAAAfz1CmPjHsbOz07Jly0xajd9VuHBhSVLJkiVlY2Oj1q1ba926dVq3bp3eeOONfLfsPnbsmK5du2b8vnv3bklS1apVc811d3eXJO3cudPk+o4dO1SpUiWz9s/KytKYMWN08uRJ+fv76/PPP9f69etlbW2tjRs3mrUmAAAAAAAAAAAAAAAAAMA8tn8+Bfh7KV68uLp166bJkycrLS1NLVq0UOHChfXf//5XX331lXx8fFSrVi1JUtu2bTVr1iwVKFBA/fv3z/fe6enpGjBggPr27auLFy9qxIgR8vf3l7OzsySpUKFCOn36tM6ePatKlSqpUaNGGj58uKQ7rcxjY2MVHx+vyZMnm7W/nZ2d9u7dqx07dmjo0KEqWbKkNm3apOvXrxtbowMAAAAAAAAAAAAAAAAAngxCmPhH6tOnj1xdXbV8+XItWrRIN27cUNmyZeXv76/u3bsb55UvX17Vq1dXdna23Nzc8r1v2bJl5e7urk6dOsnW1latWrVSaGiocbxjx44aOHCgAgIClJiYqEmTJmnixIkaMmSIrl69qsqVKysiIkJNmzY1u4YpU6ZozJgx+ve//61r166pYsWKmjBhgjF4CgAAAAAAAAAAAAAAAAB4MqxycnJyLF0E8FfJyclRs2bN9P7776t9+/b5WisiIkLR0dHasGHDY6oOAAAAAAAAAAAAAAAAAPBPxkmYeCrdvHlTGzZs0JYtW5SWlqaWLVtauiQAAAAAAAAAAAAAAAAAwFOGECaeSgUKFNDnn38uSRo3bpwcHR0tXBEAAAAAAAAAAAAAAAAA4GlDO3IAAAAAAAAAAAAAAAAAAAAzWFu6AAAAAAAAAAAAAAAAAAAAgH8iQpgAAAAAAAAAAAAAAAAAAABmIIQJAAAAAAAAAAAAAAAAAABgBkKYAAAAAAAAAAAAAAAAAAAAZiCECQAAAAAAAAAAAAAAAAAAYAZCmAAAAAAAAAAAAAAAAAAAAGYghAkAAAAAAAAAAAAAAAAAAGAGW0sXAMDybqRft8i+Do6FLLIvAAAAAAAAAAAAAAAAADwOnIQJAAAAAAAAAAAAAAAAAABgBkKYAAAAAAAAAAAAAAAAAAAAZiCECQAAAAAAAAAAAAAAAAAAYAZCmAAAAAAAAAAAAAAAAAAAAGYghAkAAAAAAAAAAAAAAAAAAGAGQpgAAAAAAAAAAAAAAAAAAABmIIQJAAAAAAAAAAAAAAAAAABgBkKYAAAAAAAAAAAAAAAAAAAAZiCECeQhLS1Nr7zyiurWrausrCyTsaCgIIWFhT2WfU6dOiUPDw9t3brVomsAAAAAAAAAAAAAAAAAAB4dIUwgD7GxsSpRooTS0tK0fv16S5cDAAAAAAAAAAAAAAAAAPgbIoQJ5GHlypWqX7++6tSpo6VLl1q6HAAAAAAAAAAAAAAAAADA3xAhTOAPjhw5or1796pevXpq0aKFtm3bpiNHjtx3/smTJ/XBBx+oZs2a8vHxUd++fXXhwgXj+KpVqxQQECAvLy/5+vpq+vTpys7ONllj79696tChg6pVq6bGjRtr5cqVJuMPswYAAAAAAAAAAAAAAAAA4MkihAn8QWRkpBwdHdWwYUM1adJEdnZ2WrJkSZ5zr127pk6dOik9PV3z5s3TvHnzdPr0afXu3VuSNG/ePA0dOlRvvfWW1qxZo759+2rOnDn64osvTNaZN2+eevToobi4ODVo0EBDhgxRSkrKI60BAAAAAAAAAAAAAAAAAHiyCGEC97h165ZiYmL02muvqWDBgnJyclKjRo20evVqZWRk5JofFxena9euadKkSfL09FTVqlU1atQo1axZUzdu3NCsWbP0zjvv6O2335arq6tatWqlDz/8UAsXLtS1a9eM63zwwQfy9fXViy++qL59+yo7O1sHDhxQTk7OQ68BAAAAAAAAAAAAAAAAAHiyCGEC99i0aZPOnz8vf39/4zV/f39dvXpVsbGxueYfPnxYrq6uKlq0qPFa5cqVFRoaquvXr+vChQuqWbOmyT3e3t66efOmjh49arxWsWJF489FihSRJGVmZurSpUsPvQYAAAAAAAAAAAAAAAAA4MmytXQBwN9JVFSUJOnDDz/MNbZ06VK1a9fO5Jqtra2srKzyXCsnJyfP67dv3zbee5e1de48dE5OziOtAQAAAAAAAAAAAAAAAAB4sjgJE/j/Ll26pE2bNqlNmzZatWqVyaddu3bav3+/Dhw4YHJPpUqVdPz4cZO24AcPHpSPj48yMzNVokQJ7dy50+SeHTt2qECBAnrxxRf/tKYSJUrkew0AAAAAAAAAAAAAAAAAwF+DECbw/61evVq3bt1St27d5O7ubvLp0aOHbGxstGTJEpN7WrVqpSJFiqh///5KSkrSf/7zH3322Wdyd3dXuXLlFBwcrIULF2rRokVKSUlRTEyMpk2bprfeektOTk5/WpOVlVW+1wAAAAAAAAAAAAAAAAAA/DXoZQz8f1FRUapbt67c3Nxyjbm4uKhp06aKjY2Vq6ur8XrBggU1Z84cjR07VoGBgbKzs5Ovr68GDBggSerWrZvs7Ow0f/58jRkzRmXKlFFISIjee++9h67rcawBAAAAAAAAAAAAAAAAAHj8rHJycnIsXQQAy7qRft0i+zo4FrLIvgAAAAAAAAAAAAAAAADwONCOHAAAAAAAAAAAAAAAAAAAwAyEMAEAAAAAAAAAAAAAAAAAAMxACBMAAAAAAAAAAAAAAAAAAMAMhDABAAAAAAAAAAAAAAAAAADMQAgTAAAAAAAAAAAAAAAAAADADIQwAQAAAAAAAAAAAAAAAAAAzEAIEwAAAAAAAAAAAAAAAAAAwAyEMAEAAAAAAAAAAAAAAAAAAMxACBMAAAAAAAAAAAAAAAAAAMAMtpYuAIDl/e9GjkX2LXvtmEX2laQCpStYbG8AAAAAAAAAAAAAAAAATwdOwgQAAAAAAAAAAAAAAAAAADADIUwAAAAAAAAAAAAAAAAAAAAzEMIEAAAAAAAAAAAAAAAAAAAwAyFMAAAAAAAAAAAAAAAAAAAAMxDCBAAAAAAAAAAAAAAAAAAAMAMhTAAAAAAAAAAAAAAAAAAAADMQwgQAAAAAAAAAAAAAAAAAAH8bX331lYKCgh445/fff9fHH38sb29veXt7a+jQoUpPTzeZ8/3338vf31+enp5q1aqVfv7558deKyFMAAAAAAAAAAAAAAAAAADwtzBv3jxNnTr1T+d9+OGHOnnypHH+L7/8ouHDhxvHt2zZov79+6tTp05atWqV6tevrw8++EBHjhx5rPU+cyHMoKAghYWF5TkWFhb2p+nZxy0nJ0fR0dG6ePGiJCkqKkoeHh7G8dTUVMXGxhq/+/r6KiIiwqy97q5978fb21vdu3fX0aNH//T+mJgYvfXWWzIYDDIYDGrbtq2WLl1qVi1/tHnzZjVp0kTVqlVTeHj4Y1nTXB07dpSHh4cOHTpk1v2P83cGAAAAAAAAAAAAAAAAAM+Cc+fOqVu3bpoyZYoqVKjwwLm7d+/Wtm3bNGbMGL388suqU6eORowYodWrV+vcuXOSpFmzZqlp06Z655135ObmpoEDB+rll1/W/PnzH2vdto91NTyy7du3KywsTPHx8ZIkf39/NWjQwDg+cOBAlStXTi1btpQkRUZGyt7ePl97JiQkSJKys7N18eJFTZs2TcHBwVq7du19146MjNTnn3+uTz75RN7e3srJyVFiYqJGjRqlCxcuqFevXvmqacKECXJxcdG8efNUqFChfK2VH8eOHdPu3btVoUIFLVmyRCNGjHjkNf6K3xkAAAAAAAAAAAAAAAAA/N01btz4geN3c3J5OXDggIoUKaI1a9boyy+/1OnTp+87d8eOHSpVqpTc3NyM1/71r3/JyspKO3fuVIsWLbRr165cBzb6+Pho/fr1D/k0D4cQpoXl5OSYfHdwcJCDg8N95xcvXjzfe5YqVcr4c+nSpTVs2DA1bNhQv/76q1577bU871m8eLHatWunDh06GK9VrFhRZ8+e1YIFC/Idwrx69ap8fX3l7Oycr3Xya+XKlapQoYLat2+vadOmacCAASpcuHC+1nwcvzMAAAAAAAAAAAAAAAAA92dnCLZ0CZDUIB9RKV9fX/n6+j7U3HPnzqls2bIm1+zs7FS0aFGdOXNGV69eVXp6usqUKWMy5/nnn9eZM2fMLzIPz1w78kdx7do1DR06VLVr11bNmjXVuXNn7d+/3zgeERGhwMBAzZgxQ7Vr15a3t7cGDRqktLQ045zffvtNPXv2lI+Pj6pVq6amTZsajzPdunWrOnfuLOlOAjgqKsqkHXlQUJC2bdum6Oho4x/Xva2tMzIyNHjwYNWrV0+enp5q3bq11q1b98jP6ejo+KdzrK2ttWvXLl25csXkekhIiJYtW2b8nlfr7XtbwG/dulUeHh6aNWuWfHx89Oabb8rDw0OnT5/Wl19+KQ8PD506dUpXr17VsGHD1KhRI7388suqV6+ehg0bphs3bhjXPXnypD744APVrFlTPj4+6tu3ry5cuGAcX7lypfz8/OTl5SU/Pz/Nnz9f2dnZ933G27dva/Xq1apXr56aN2+u9PR0rVmzxmRORESEgoKCNGvWLDVs2FCenp7q3LmzsZ37n/3OpDtt3f38/OTp6al27dpp/vz5Ji3oH+bv7kE1AAAAAAAAAAAAAAAAAIAlxMfHP/DzuGRkZMjOzi7XdXt7e2VmZhpzZn+cc3f8cSKEeR85OTkKCQnR8ePHNWPGDC1fvlzVq1dXYGCgDh48aJy3f/9+bdy4UXPmzNG0adO0fft29enTR9KdX3TXrl3l6OioxYsXKzY2Vn5+fho9erQOHTokg8FgDOetWLFC/v7+JjVERETIYDDIz89PkZGRuWqcMmWKDh8+rJkzZyouLk4NGzZU3759derUqYd+zuvXr2vixIlydnZW3bp17zsvJCREhw4dUsOGDfX+++9r5syZ2rdvn5ycnFShQoWH3u+ujRs3atmyZRo9erQSEhJUpkwZBQcHKyEhQWXLltXAgQO1b98+TZ06VWvXrtWgQYMUFRVlDHxeu3ZNnTp1Unp6uubNm6d58+bp9OnT6t27tyRp2bJlCg8P1wcffKDY2Fj16dNHs2bN0vjx4+9b0+bNm/W///1PzZs3l7Ozs6pXr66lS5fmmrd7925t375dM2fO1Lx585Samqrhw4dL+vPf2U8//aSBAweqXbt2WrNmjdq2basJEyYYxx/27+5BNQAAAAAAAAAAAAAAAADA08zBwUFZWVm5rmdmZsrR0VH29vaSlGtOZmamChYs+FhreSbbkcfExGjt2rW5rmdlZalGjRqSpC1btmj37t1KTEw0tpPu16+fdu3apQULFmjs2LGSJCsrK02ePFmlS5eWJH366acKCQnR0aNHVbRoUXXu3FmdOnUytrTu1auXZsyYocOHD6tq1aoqUqSIpDstq//Yhrxo0aIqUKCAHBwc8mxpfeLECRUuXFgvvviinJyc9NFHH6lWrVrGNe/HYDBIuhP4u5v4HT9+vPEPLy/NmzfXsmXL9O233yohIUGbNm2SJLm6umr06NGqWbPmA/f8o+DgYLm6uhq/29jYyNHR0dgqvV69eqpVq5aqVKkiSXJ2dtbChQt1+PBhSVJcXJyuXbumSZMmqWjRopKkUaNGafXq1crMzNRXX32l7t276/XXX5ckubi4KC0tTcOHD9dHH32U57NGRUXp+eefV61atSRJLVu21KhRo7R7927jO5OkW7du6YsvvjDuGxQUpHHjxkn689/ZnDlz1KJFC7333nuSpAoVKiglJUXffPONpIf/u3tQDQAAAAAAAAAAAAAAAADwNCtTpox+/PFHk2tZWVm6fPmySpcuraJFi8rR0VH/+9//TOb873//y9WiPL+eyRCmr6+vQkNDc10fP368Ll++LEk6cOCApDttwu+VlZVlchypq6urMYAp/V/AMTk5WS1atFCnTp0UFxenpKQkpaSk6NChQ5L0wLbYDyskJEQ9evRQnTp1ZDAYVK9ePbVs2VJOTk4PvG/VqlWS7oQwr169qvj4ePXv3185OTlq1arVfe/z8vLSuHHjlJOTo+TkZG3atEkLFixQSEiI1q9frxIlSjx07fcGMPPSqVMnbdiwQatXr9aJEyeUnJyskydPGu87fPiwXF1djSFESapcubJCQ0N16dIlnT17VlOmTNG0adOM49nZ2crMzNSpU6fk5uZmst+lS5e0YcMGBQYGytr6zgGxfn5+GjNmjJYsWWISwixZsqTJvk5OTrp58+ZDPfeBAwfUrFkzk2u1atUyhjAf9u8uPzUAAAAAAAAAAAAAAAAAwD+Zt7e3xo8fr5SUFJUvX16StHXrVklSjRo1ZGVlpRo1amjbtm1q37698b6tW7c+8oGDf+aZDGEWKlTI+OL/eP1uCDM7O1uFCxdWVFRUrnn39okvUKCAydjdcKWNjY0uXLigDh06qFixYmrcuLHq1KkjT09PNWrU6LE8h8Fg0KZNm/TLL78oMTFRkZGRioiI0OzZs1WnTp373vfHZ/fy8tLevXs1b968PEOYZ8+e1axZs/T++++rdOnSsrKykoeHhzw8PNS4cWP5+/tr+/btatGihaQ74c575RUOfNCpmzk5OerRo4cOHz6sVq1aqXnz5urXr5+GDh1qnGNraysrK6s877/7Oxg0aFCeLdbLli2b61pMTIxu3ryphQsXatGiRSZr/fDDD/rkk0+Mocd7f/+PytbW9oEB3If9u8tPDQAAAAAAAAAAAAAAAADwT3L79m1dunRJTk5OcnBw0CuvvKIaNWqob9+++uyzz5Senq5hw4apdevWxkMVu3btqvfff18vvfSSGjZsqJUrV+rQoUMaNWrUY63N+rGu9hRxd3dXWlqasrKyVL58eeNn1qxZio+PN847duyYrl27Zvy+e/duSVLVqlUVExOjy5cva+nSperZs6eaNm2qK1euSPq/oOL9goQPY+rUqdq5c6caN26sIUOGaO3atXJxccmz1frD+GN48i47OzstW7ZMa9asyTV2t816yZIlJd0Jpd77PrKzs3Xq1KlHquPgwYPatGmTpk6dqtDQUAUEBOjFF1/UiRMnjDVWqlRJx48fN9nr4MGD8vHxUWZmpkqUKKETJ06Y/O4OHDigyZMn57lnVFSU3N3dtXr1aq1atcr4GT58uDIzMxUdHf1Iz3A/VapU0d69e02u3fv9Yf/uAAAAAAAAAAAAAAAAAOBZcebMGdWvX19xcXGS7uTupk2bJmdnZ7377rvq06ePGjZsqM8++8x4T/369TV69GgtWbJEb775prZs2aLp06fn6qKcX8/kSZgPo0GDBqpatar69OmjIUOG6IUXXtDSpUu1cuVKzZ071zgvPT1dAwYMUN++fXXx4kWNGDFC/v7+cnZ2VpkyZZSRkaHvv/9etWrV0tGjRzVmzBhJd9pLS5Kjo6MkKSkpScWKFctVR6FChXT69GmdPXs2Vy/6lJQUrVmzRiNHjtSLL76oPXv2KDU11aR1dl7Onz9v/PnGjRv64YcftGXLFoWFheU5v3jx4urWrZsmT56stLQ0tWjRQoULF9Z///tfffXVV/Lx8VGtWrUk3TnKNS4uTs2aNVPJkiX1zTffmAQlH0bJkiVla2ur77//XsWLF9fly5c1ffp0nT9/3vjeWrVqpa+++kr9+/dXnz59dOvWLY0YMULu7u4qV66cunXrpokTJ+qFF15Qo0aNlJycrOHDh+vVV1/NdYrkgQMHlJSUZLz/XpUqVdLcuXO1dOlSdenS5aHqf9Dv7G4L+W+++Ua+vr7atWuXvv32W+P4w/7dAQAAAAAAAAAAAAAAAMDTauzYsSbfnZ2ddfjwYZNrJUqU0NSpUx+4TuvWrdW6devHXZ4JQpj3YWNjo7lz52rcuHHq27evMjIy5ObmpoiICJNW32XLlpW7u7s6deokW1tbtWrVSqGhoZKkFi1a6MCBAwoPD1daWprKlSun9u3bKz4+Xvv27VNgYKDc3d3VqFEj9enTR/369TO2vL6rY8eOGjhwoAICApSYmGgyNnz4cIWHh6t///66fPmyypUrp9DQUL3xxhsPfLb69esbf7a3t1f58uU1cOBAvfvuu/e9p0+fPnJ1ddXy5cu1aNEi3bhxQ2XLlpW/v7+6d+9unNe3b19duXJFISEhKliwoNq3by9/f//7nrKZl9KlS2vs2LGKiIjQokWLVKpUKb366qvq0qWL4uPjlZOTo4IFC2rOnDkaO3asAgMDZWdnJ19fXw0YMECSFBwcLHt7e3377bcKDw9XiRIl1KZNG/Xt2zfXflFRUXruuecUEBCQa8za2lrvvvuuRowYoS1btjxU/Q/6nTVs2FDDhw/XjBkzNGHCBFWrVk0dO3bUwoULJT383x0AAAAAAAAAAAAAAACA/2NlbWPpEvCMssp5lHQcTERERCg6OlobNmywdCn4h9i2bZtKliypihUrGq9Nnz5dkZGR+vHHHy1W14lLaRbZt+zN838+6S9SoHQFi+0NAAAAAAAAAAAAAACAx8u+ZoilS4CkzJ2zLF3CE2dt6QKAZ8kvv/yi9957T1u2bFFqaqri4+M1f/78Pz29FAAAAAAAAAAAAAAAAADw90M7cuAJ+uCDD3T9+nUNGDBAly5dUtmyZdWlSxd169bN0qUBAAAAAAAAAAAAAAAAAB4R7cgB0I4cAAAAAAAAAAAAAAAA/2i0I/97oB05AAAAAAAAAAAAAAAAAAAAHgohTAAAAAAAAAAAAAAAAAAAADMQwgQAAAAAAAAAAAAAAAAAADCDraULAAAAAAAAAAAAAAAAAAAgP6ysbSxdAp5RnIQJAAAAAAAAAAAAAAAAAABgBkKYAAAAAAAAAAAAAAAAAAAAZiCECQAAAAAAAAAAAAAAAAAAYAZbSxcAwPIK2lomj32tQGmL7CtJ+49csNjejdxKWmxvAAAAAAAAAAAAAAAAAI8PJ2ECAAAAAAAAAAAAAAAAAACYgRAmAAAAAAAAAAAAAAAAAACAGWhHDgAAAAAAAAAAAAAAAAD4R7OytrF0CXhGcRImAAAAAAAAAAAAAAAAAACAGQhhAgAAAAAAAAAAAAAAAAAAmIEQJgAAAAAAAAAAAAAAAAAAgBkIYQIAAAAAAAAAAAAAAAAAAJiBECYAAAAAAAAAAAAAAAAAAIAZCGH+zQUFBSksLCzPsbCwMAUFBT3RenJychQdHa2LFy9KkqKiouTh4WEcT01NVWxsrPG7r6+vIiIizNrr7tr3fry9vdW9e3cdPXo0fw9yH8ePH5eHh4dat25t9ho//fST/vvf/0qStm7dKg8PD506deoxVQgAAAAAAAAAAAAAAAAA+LsghIlHsn37doWFhSkjI0OS5O/vr4SEBOP4wIEDtXnzZuP3yMhIBQcH52vPhIQEJSQk6Oeff9b8+fNlY2Oj4OBgZWZm5mvdvERFRalChQo6dOiQ9uzZ88j3nz59Wj169DCGVA0GgxISElS2bNnHXCkAAAAAAAAAAAAAAAAAwNJsLV0A/llycnJMvjs4OMjBweG+84sXL57vPUuVKmX8uXTp0ho2bJgaNmyoX3/9Va+99lq+17/r9u3bWrVqld555x2tWbNGS5cuVfXq1R9pjT++Hzs7O5P6AQAAAAAAAAAAAAAAADx+VtY2li4BzyhOwnyKXLt2TUOHDlXt2rVVs2ZNde7cWfv37zeOR0REKDAwUDNmzFDt2rXl7e2tQYMGKS0tzTjnt99+U8+ePeXj46Nq1aqpadOmmj9/vqQ7rbU7d+4sSWrcuLGioqJM2pEHBQVp27Ztio6Olq+vryTTduQZGRkaPHiw6tWrJ09PT7Vu3Vrr1q175Od0dHTM97vIS0JCgs6dO6e6deuqRYsWiouL05UrV0zm+Pr6aubMmerdu7cMBoN8fHw0evRo3bp1S6dOnVLjxo0lSZ07d1ZERESuduQZGRkaNmyYfHx8VKNGDQ0ePFgff/yxScv5Xbt26e2335aXl5deffVVDR8+3OR39KAaAAAAAAAAAAAAAAAAAABPDiHMp0ROTo5CQkJ0/PhxzZgxQ8uXL1f16tUVGBiogwcPGuft379fGzdu1Jw5czRt2jRt375dffr0kXQnINi1a1c5Ojpq8eLFio2NlZ+fn0aPHq1Dhw7JYDAYA5UrVqyQv7+/SQ0REREyGAzy8/NTZGRkrhqnTJmiw4cPa+bMmYqLi1PDhg3Vt29fY0DxYVy/fl0TJ06Us7Oz6tatm6938UcrV66Us7OzqlWrJn9/f2VmZio6OjrXvIiICHl7eys6Olq9e/fWggUL9N1336ls2bJasWKFcU5ebdgHDhyoX375RZMmTdLSpUuVlpam2NhY43hSUpK6dOmievXqac2aNRo/frwOHDig4OBgk1M271cDAAAAAAAAAAAAAAAAAODJoR35P0BMTIzWrl2b63pWVpZq1KghSdqyZYt2796txMREYwvwfv36adeuXVqwYIHGjh0rSbKystLkyZNVunRpSdKnn36qkJAQHT16VEWLFlXnzp3VqVMnFS5cWJLUq1cvzZgxQ4cPH1bVqlVVpEgRSXfajP+xDXnRokVVoEABOTg45NmG/MSJEypcuLBefPFFOTk56aOPPlKtWrWMa96PwWCQdCdceePGDUnS+PHjZW9vn+f8h30X97p8+bI2bNigrl27SpIqVqyol156SUuXLlWXLl1M5jZo0MB4Iqirq6siIyO1a9cutW7d2rhfkSJFVKhQIZP7Tp48qbVr12r27NnGAOkXX3yhXbt2GefMmTNHderUUc+ePY3rT5gwQU2aNNG2bdvk4+PzpzUAAAAAAAAAAAAAAAAAAJ4MQpj/AL6+vgoNDc11ffz48bp8+bIk6cCBA5JkbId9V1ZWljIzM43fXV1djQFM6f8CjsnJyWrRooU6deqkuLg4JSUlKSUlRYcOHZIkZWdn5/s5QkJC1KNHD9WpU0cGg0H16tVTy5Yt5eTk9MD7Vq1aJelOCPPq1auKj49X//79lZOTo1atWuWa/7Dv4l5r1qzRzZs3TU739Pf31/jx45WYmKg6deoYr7u5uZnc6+TkpJs3bz7wGSQZT+G8+84lyd7eXp6eniZzUlJSTObcdeTIEWMI09waAAAAAAAAAAAAAAAAAACPDyHMf4BChQqpfPnyeV6/G8LMzs5W4cKFFRUVlWuenZ2d8ecCBQqYjN0NV9rY2OjChQvq0KGDihUrpsaNG6tOnTry9PRUo0aNHstzGAwGbdq0Sb/88osSExMVGRmpiIgIzZ492yTk+Ed/fHYvLy/t3btX8+bNyzOE+bDv4l5357Zt29Z47W7776VLl5rUl9ca97YKvx8bGxtjffeTnZ2tVq1aqUePHrnG7j1d1NwaAAAAAAAAAAAAAAAAAACPj7WlC8Dj4e7urrS0NGVlZal8+fLGz6xZsxQfH2+cd+zYMV27ds34fffu3ZKkqlWrKiYmRpcvX9bSpUvVs2dPNW3aVFeuXJH0fwE/Kysrs2ucOnWqdu7cqcaNG2vIkCFau3atXFxc8my1/jDuFzp82Hdx16FDh3To0CH16NFDq1atMn5Wr16tBg0aKD4+XufPn3+omh70fjw8PGRlZaU9e/YYr928edN4QqYkVa5cWb/99ptJ3bdv39aYMWN05syZh6oBAAAAAAAAAAAAAAAAAPBkEMJ8SjRo0EBVq1ZVnz59lJiYqJSUFIWHh2vlypUmravT09M1YMAAJScnKzExUSNGjJC/v7+cnZ1VpkwZZWRk6Pvvv1dqaqoSEhLUr18/SXdaeUuSo6OjJCkpKUnXr1/PVUehQoV0+vRpnT17NtdYSkqKhg0bpsTERJ0+fVo//PCDUlNT82y9fa/z588bPydPntSsWbO0ZcsWBQQE5Otd3LVy5UoVLFhQwcHBcnd3N/l0795dN2/eVGRk5ANrvOvu+0lOTjYJu0qSi4uL/Pz8NHLkSCUmJurIkSMaOnSozpw5YwxvBgcH69ChQ/r000/13//+V3v37lVoaKiOHTsmV1fXh6oBAAAAAAAAAAAAAAAAAPBk0I78KWFjY6O5c+dq3Lhx6tu3rzIyMuTm5qaIiAiTVtply5aVu7u7OnXqJFtbW7Vq1UqhoaGSpBYtWujAgQMKDw9XWlqaypUrp/bt2ys+Pl779u1TYGCg3N3d1ahRI/Xp00f9+vVT0aJFTero2LGjBg4cqICAACUmJpqMDR8+XOHh4erfv78uX76scuXKKTQ0VG+88cYDn61+/frGn+3t7VW+fHkNHDhQ7777br7ehXQnXBoTE6NWrVqpSJEiudby9vaWl5eXVqxYoe7duz+wTkkqVqyY2rZtqy+++EIpKSlq2rSpyfjIkSP1+eefq3fv3srJydHrr7+u6tWrG9vEV69eXbNnz9aUKVPUpk0bFSxYULVr19bAgQPv20odAAAAAAAAAAAAAAAAeNZZ2dhYugQ8o6xy7tfTGU+diIgIRUdHa8OGDZYu5ZmUmZmpzZs3q3bt2ipcuLDxevPmzRUQEKAPPvjAYrWdv5pukX1tzO9un2/7/2eZZ5akRm4lLbY3AAAAAAAAAAAAAADA06hQ/b6WLgGSridMsnQJTxwnYQJPiJ2dnUaMGCFvb2/17NlTNjY2ioyMVGpqqlq0aGHp8gAAAAAAAAAAAAAAAAAAj8ja0gUAzworKyvNmDFDv//+u9566y29+eab2r17t+bOnSs3NzdLlwcAAAAAAAAAAAAAAAAAeES0IwdAO/InjHbkAAAAAAAAAAAAAAAAjxftyP8ensV25JyECQAAAAAAAAAAAAAAAAAAYAZCmAAAAAAAAAAAAAAAAAAAAGawtXQBAAAAAAAAAAAAAAAAAADkh7W1jaVLwDOKkzABAAAAAAAAAAAAAAAAAADMQAgTAAAAAAAAAAAAAAAAAADADIQwAQAAAAAAAAAAAAAAAAAAzGBr6QIAWF5a1m2L7Oty86xF9pWk2INZFtv7BSd7i+xb+Xkni+wLAAAAAAAAAAAAAAAAPK04CRMAAAAAAAAAAAAAAAAAAMAMhDABAAAAAAAAAAAAAAAAAADMQAgTAAAAAAAAAAAAAAAAAADADLaWLgAAAAAAAAAAAAAAAAAAgPywsraxdAl4RnESJgAAAAAAAAAAAAAAAAAAgBkIYQIAAAAAAAAAAAAAAAAAAJiBECYAAAAAAAAAAAAAAAAAAIAZCGECAAAAAAAAAAAAAAAAAACYgRDmnwgKClJYWFieY2FhYQoKCnqi9eTk5Cg6OloXL16UJEVFRcnDw8M4npqaqtjYWON3X19fRUREmLXX3bXv/Xh7e6t79+46evTon95/69YtzZ8/X23atJHBYJCPj4+6du2qxMREs+p5XCZNmiQPDw/Nnz/frPvT09O1aNEi4/d7/w62bt0qDw8PnTp16rHUetdftS4AAAAAAAAAAAAAAAAAwHyEMP9htm/frrCwMGVkZEiS/P39lZCQYBwfOHCgNm/ebPweGRmp4ODgfO2ZkJCghIQE/fzzz5o/f75sbGwUHByszMzM+96TlZWld999V/Pnz1dQUJCio6M1f/58VapUScHBwVq1alW+ajJXdna2Vq1apQoVKmjp0qVmrTF37lzNmTPH+H3w4MFmB10BAAAAAAAAAAAAAAAAAP9ctpYuAI8mJyfH5LuDg4McHBzuO7948eL53rNUqVLGn0uXLq1hw4apYcOG+vXXX/Xaa6/lec/UqVOVlJSk2NhYlSlTxnh98ODBSk9P1+jRo9W0aVMVKlQo3/U9ioSEBJ09e1ZfffWVevbsqa1bt8rHx+eR1vjj78DJyelxlggAAAAAAAAAAAAAAAAA+IfgJMzH6Nq1axo6dKhq166tmjVrqnPnztq/f79xPCIiQoGBgZoxY4Zq164tb29vDRo0SGlpacY5v/32m3r27CkfHx9Vq1ZNTZs2NbbN3rp1qzp37ixJaty4saKiokzakQcFBWnbtm2Kjo6Wr6+vJNN25BkZGRo8eLDq1asnT09PtW7dWuvWrXvk53R0dHzg+M2bN7VixQq1a9fOJIB510cffaTZs2cbw6OXL1/W8OHD1ahRI3l5eSkwMFA7duwweW8dO3ZUv379VKNGDQ0fPlyStGvXLr399tvy8vLSq6++quHDh5u8y7xERUXJ3d1djRs3lrOzs5YsWWIyfrft96ZNm/T666+rWrVqatmypX766SdjLdOmTdPp06eN7cHzakv/008/qVmzZvLy8lLXrl118uRJ49jt27c1b948NW/eXJ6enmrevLmWL19ucv+OHTvUvn17eXl5qXXr1jp8+LBx7Mcff1SVKlV0+vRpk3s6dOigMWPGPPD5AQAAAAAAAAAAAAAAgKeRlbUNn7/B51lECPMxycnJUUhIiI4fP64ZM2Zo+fLlql69ugIDA3Xw4EHjvP3792vjxo2aM2eOpk2bpu3bt6tPnz6S7oQku3btKkdHRy1evFixsbHy8/PT6NGjdejQIRkMBmOgcsWKFfL39zepISIiQgaDQX5+foqMjMxV45QpU3T48GHNnDlTcXFxatiwofr27atTp0499HNev35dEydOlLOzs+rWrZvnnJMnT+ry5cuqXr16nuPPP/+8vLy8ZGNjo9u3bys4OFg7duxQeHi4oqOjVaVKFXXp0sUkwLp7926VKFFCq1ev1rvvvqukpCR16dJF9erV05o1azR+/HgdOHBAwcHBuU6qvOvy5cuKj49X8+bNJd1p5f7jjz/qwoULueaOGzdOgwcPVlRUlFxcXBQaGqrr168rODhYwcHBKlOmjBISElS2bNk895ozZ46GDh2qyMhI2dvbKzAw0NhCfuzYsfrqq6/Uq1cvxcTEqHPnzhoxYoS+/fZb4/sLDg5W1apVFR0drX//+9/68ssvjWu/+uqrxndx17Fjx7R37169+eabedYDAAAAAAAAAAAAAAAAAHj8aEf+EGJiYrR27dpc17OyslSjRg1J0pYtW7R7924lJiYaW4D369dPu3bt0oIFCzR27FhJkpWVlSZPnqzSpUtLkj799FOFhITo6NGjKlq0qDp37qxOnTqpcOHCkqRevXppxowZOnz4sKpWraoiRYpIutNm/I9tyIsWLaoCBQrIwcEhzzbkJ06cUOHChfXiiy/KyclJH330kWrVqmVc834MBoOkO0HTGzduSJLGjx8ve3v7POdfuXJFkv50XelOe/ADBw4oJiZG7u7uxneyd+9ezZkzR5MnTzbO/fDDD42tv/v37686deqoZ8+ekiRXV1dNmDBBTZo00bZt2/JsMf7dd98pKytLfn5+kqSWLVtq5syZWrlypbp3724yt0+fPqpTp47x5zfeeEPJyckyGAxydHSUjY2NSZv2PxoyZIgaNGggSfriiy/UqFEjfffdd/Lz89OSJUsUFhamVq1aGWs/efKkpk+frnfeeUfLly9XyZIlNWzYMNnY2MjNzU1nzpwxnnJpa2urgIAArV692vj8q1at0ssvv6wqVar86TsHAAAAAAAAAAAAAAAAADwehDAfgq+vr0JDQ3NdHz9+vC5fvixJOnDggKQ7bcLvlZWVpczMTON3V1dXYwBT+r+AY3Jyslq0aKFOnTopLi5OSUlJSklJ0aFDhyRJ2dnZ+X6OkJAQ9ejRQ3Xq1JHBYFC9evXUsmVLY7DxflatWiXpTgjz6tWrio+PV//+/ZWTk2MMEt7rbgD07rt5kOTkZDk5ORkDmNKdoGqtWrW0efNm47USJUqY1Hnw4EGlpKQY39+9jhw5kmcIc+XKlapSpYrc3NwkyfjzsmXLFBISImvr/zsYtmLFisaf7wZib968+afPc1etWrWMPz/33HNydXVVcnKyPDw8dPPmTdWsWTPX/G+++UYXL15UcnKyXnrpJdnY/N/xvHfDvne1bdtWc+fO1d69e+Xl5aU1a9aoW7duD10fAAAAAAAAAAAAAAAAACD/CGE+hEKFCql8+fJ5Xr8bNMzOzlbhwoUVFRWVa56dnZ3x5wIFCpiM3Q1X2tjY6MKFC+rQoYOKFSumxo0bq06dOvL09FSjRo0ey3MYDAZt2rRJv/zyixITExUZGamIiAjNnj3beOpjXv747F5eXtq7d6/mzZuXZwjTxcVFJUuW1O7du3O1TJek48ePa8SIERo4cKBycnJkZWWVa052drZsbf/vz/OPp35mZ2erVatW6tGjR6578zoFNCkpSQcPHpSVlZVeeuklk3VycnK0efNmk/d87+/srvu1Oc/LvQFKSbp9+7bs7OyMa/zxme/+Hdx95j/ude+7kKRKlSrplVde0Zo1a3Tjxg1duHBBLVu2fOj6AAAAAAAAAAAAAAAAAAD5Z/3nU/Aw3N3dlZaWpqysLJUvX974mTVrluLj443zjh07pmvXrhm/7969W5JUtWpVxcTE6PLly1q6dKl69uyppk2bGlt73y+89yimTp2qnTt3qnHjxhoyZIjWrl0rFxeXPFutP4z7hRKtra3Vrl07RUVF6dy5c7nGZ8+erT179qhcuXLy8PDQ1atXlZycbDJn586dqlSp0n33rly5sn777TeTd3379m2NGTNGZ86cyTU/MjJSBQoU0OLFi7Vq1SrjZ8mSJSpQoICWLFny0M/9ML+D//znP8afL126pOPHj6ty5cqqWLGibG1ttWPHDpP5O3bsUKlSpVSkSBFVrVpV+/fvV1ZWlnF8//79ufZo27at1q1bp3Xr1qlx48YqWrToQz8DAAAAAAAAAAAAAAAAACD/CGE+Jg0aNFDVqlXVp08fJSYmKiUlReHh4Vq5cqWx/bUkpaena8CAAUpOTlZiYqJGjBghf39/OTs7q0yZMsrIyND333+v1NRUJSQkqF+/fpJkDOQ5OjpKunOy4/Xr13PVUahQIZ0+fVpnz57NNZaSkqJhw4YpMTFRp0+f1g8//KDU1NQ8W3rf6/z588bPyZMnNWvWLG3ZskUBAQH3vadHjx4qX768OnbsqFWrVunEiRPav3+/Bg8erJUrV2rkyJEqXLiw6tWrJw8PD3388cfaunWrjhw5ouHDhys5OVnvvvvufdcPDg7WoUOH9Omnn+q///2v9u7dq9DQUB07dkyurq4mc7OysvTdd9+pefPmqlGjhtzd3Y0fg8GgVq1aadOmTUpNTX3ge7jL0dFRV65c0bFjx+7bovzTTz9VYmKiDh06pL59+6ps2bLy9/eXk5OTOnTooKlTpyomJkYpKSlatGiRFi9erODgYFlZWSkwMFAZGRn65JNPdOTIEf3000+aNm1arj1atmypa9euKTIyUm3atHmo2gEAAAAAAAAAAAAAAAAAjw/tyB8TGxsbzZ07V+PGjVPfvn2VkZEhNzc3RUREmLT6Llu2rNzd3dWpUyfZ2tqqVatWCg0NlSS1aNFCBw4cUHh4uNLS0lSuXDm1b99e8fHx2rdvnwIDA+Xu7q5GjRqpT58+6tevX67TDzt27KiBAwcqICBAiYmJJmPDhw9XeHi4+vfvr8uXL6tcuXIKDQ3VG2+88cBnq1+/vvFne3t7lS9fXgMHDnxgSLJgwYJauHCh5s6dq1mzZik1NVX29vZ6+eWXNX/+fP3rX/+SdKfN9jfffKPw8HD17t1bWVlZevnllzVv3jxVr179vutXr15ds2fP1pQpU9SmTRsVLFhQtWvX1sCBA3O1Ev/pp5/0+++/6+23385zreDgYEVHR2v58uUPbMt+V7NmzbR8+XIFBARo4cKFec7p2bOnBg0apEuXLsnHx0ezZ8821jV48GAVK1ZMEyZM0IULF1S+fHl9+umn6tChgySpdOnSmj9/vkaPHq0333xTZcuW1b///W8NHz7cZI/ChQurSZMm2rZtm+rVq/endQMAAAAAAAAAAAAAAABPKytrziOEZVjl3K+nNB67iIgIRUdHa8OGDZYuBU+Jzp07y2AwqG/fvvla59iFa4+pokfjcjP3ia1Pyic7sv580l8kxOdFi+xb+Xkni+wLAAAAAAAAAAAAAADwVyvaZIilS4Ckyz9+bukSnjhOwgT+gX788UcdOnRIu3fvVnh4uKXLAQAAAAAAAAAAAAAAAIBnEiFM4B9o1qxZOn78uEaOHKmyZctauhwAAAAAAAAAAAAAAAAAeCYRwnyCevfurd69e1u6DDwFli1bZukSAAAAAAAAAAAAAAAAAOCZZ23pAgAAAAAAAAAAAAAAAAAAAP6JCGECAAAAAAAAAAAAAAAAAACYgRAmAAAAAAAAAAAAAAAAAACAGWwtXQAAAAAAAAAAAAAAAAAAAPlhZW1j6RLwjOIkTAAAAAAAAAAAAAAAAAAAADMQwgQAAAAAAAAAAAAAAAAAADADIUwAAAAAAAAAAAAAAAAAAAAz2Fq6AACW94JDtkX2tbqebpF9JWlE40oW29v6ZoZF9v3xtxsW2VeSmlQuZbG9AQAAAAAAAAAAAAAAgL8KJ2ECAAAAAAAAAAAAAAAAAACYgRAmAAAAAAAAAAAAAAAAAACAGQhhAgAAAAAAAAAAAAAAAAAAmMHW0gUAAAAAAAAAAAAAAAAAAJAfVtY2li4BzyhOwgQAAAAAAAAAAAAAAAAAADADIUwAAAAAAAAAAAAAAAAAAAAzEMIEAAAAAAAAAAAAAAAAAAAwAyFMAAAAAAAAAAAAAAAAAAAAMxDCzENQUJDCwsLyHAsLC1NQUNATrScnJ0fR0dG6ePGiJCkqKkoeHh7G8dTUVMXGxhq/+/r6KiIiIl97JiUlacCAAWrYsKG8vLzUrFkzTZw4UVevXs1zfnp6ugwGg0aNGnXfNf38/DRw4EBt3bpVHh4eOnXqVL5qNEdaWppeeeUV1a1bV1lZWWatsXPnTu3YsUOSdOrUKXl4eGjr1q2SHvy3kx9/1boAAAAAAAAAAAAAAAAAAPMRwvwH2L59u8LCwpSRkSFJ8vf3V0JCgnF84MCB2rx5s/F7ZGSkgoODzd5v/fr1at++vWxsbDR16lTFxsZqwIAB+uGHH/Tuu+8qLS0t1z2Ojo7y9/dXXFycbt++nWt83759Onr0qNq1ayeDwaCEhASVLVvW7BrNFRsbqxIlSigtLU3r1683a41OnTrpxIkTkqSyZcsqISFBBoPhcZYJAAAAAAAAAAAAAAAAAPgHsLV0AfhzOTk5Jt8dHBzk4OBw3/nFixc3e68LFy4oLCxMb7/9tsnJiy4uLvLw8JCfn5++/fZb/fvf/851b7t27RQZGanExETVr1/fZCw6Olqurq7y9vaWJJUqVcrsGvNj5cqVql+/vs6dO6elS5eqZcuW+VrPxsbGYs8CAAAAAAAAAAAAAAAA4A4raxtLl4BnFCdh5tO1a9c0dOhQ1a5dWzVr1lTnzp21f/9+43hERIQCAwM1Y8YM1a5dW97e3ho0aJDJaZK//fabevbsKR8fH1WrVk1NmzbV/PnzJUlbt25V586dJUmNGzdWVFSUSTvyoKAgbdu2TdHR0fL19ZVk2o48IyNDgwcPVr169eTp6anWrVtr3bp1932emJgYZWRkqEePHrnGXFxcNH/+fHXo0CHPew0GgypVqqSYmBiT61lZWYqLi1Pbtm2Nz3RvO3JfX1+NHj1a/v7+8vHx0ZYtW/Jsv/3HVvCrVq1Sy5Yt5enpqQYNGmjUqFEPbDF+5MgR7d27V/Xq1VOLFi20bds2HTlyxGROUFCQwsPD9cknn6hWrVqqUaOGBg4cqOvXr0uS8b0PGjRIYWFhudqRS3das3/88ceqXr26GjRooHnz5pkEaY8cOaIePXrIx8dHNWvW1IcffqjU1FST9zV69GjVqVNHtWrV0oQJE5SdnW0cb926tQYNGmRS988//6xq1arp0qVL931+AAAAAAAAAAAAAAAAAMDjRQgzH3JychQSEqLjx49rxowZWr58uapXr67AwEAdPHjQOG///v3auHGj5syZo2nTpmn79u3q06ePpDshya5du8rR0VGLFy9WbGys/Pz8NHr0aB06dEgGg8EYqFyxYoX8/f1NaoiIiJDBYJCfn58iIyNz1ThlyhQdPnxYM2fOVFxcnBo2bKi+ffsaA5B/tH//flWoUEFFixbNc7xmzZoqUaLEfd9J27ZttX79et24ccN4bePGjUpLS9Obb7553/uWLFmiIUOGaPbs2apRo8Z9592VlJSkIUOGqHfv3lq7dq1Gjx6t1atXa/bs2fe9JzIyUo6OjmrYsKGaNGkiOzs7LVmyJNe8b7/9ViVLltSKFSv0+eefKy4uTvPmzZMkYxv4Tz75RIMHD85zn7Vr16pYsWJauXKl+vfvrylTphhDtadPn9Zbb70lOzs7zZ8/X998840uXryod955xxjMvbvn2LFjtWTJEqWmpmrHjh3G9du0aaO1a9eavOPVq1frtddey9cpqAAAAAAAAAAAAAAAAACAR0MI8z5iYmJkMBhyfe495XHLli3avXu3pkyZoldeeUVubm7q16+fqlevrgULFhjnWVlZafLkyXr55Zfl4+OjTz/9VJs3b9bRo0eVkZGhzp0767PPPpObm5vKly+vXr16SZIOHz4sOzs7FSlSRNKdNuN/bENetGhRFShQQA4ODnkG8E6cOKHChQvrxRdflIuLiz766CN9/fXXxjX/6MqVK3ruuefMfm+tW7dWVlaWNmzYYLy2atUqvfrqqw9s292oUSPVrVtXnp6esrOz+9N9Tp06JSsrKzk7O+uFF15QgwYNNGfOHPn5+eU5/9atW4qJidFrr72mggULysnJSY0aNdLq1auVkZFhMvfu77FChQry9/dXw4YNtWvXLkn/10bdyclJTk5Oee710ksvaciQIXJzc1NAQIA6d+6suXPnSpIWL14sR0dHjR8/XlWqVJGXl5emTp2qixcvas2aNUpLS1NUVJQ++ugjNWrUSJUrV9bo0aNN3l1AQIBu3rypH3/8UZKUlpamH3/8UW3atPnT9wYAAAAAAAAAAAAAAAAAeHxsLV3A35Wvr69CQ0NzXR8/frwuX74sSTpw4ICkO23C75WVlaXMzEzjd1dXV5UuXdr43WAwSJKSk5PVokULderUSXFxcUpKSlJKSooOHTokSSYtqM0VEhKiHj16qE6dOjIYDKpXr55atmx53wBhsWLFTFpjP6rixYvrtdde05o1a+Tv769Lly7p559/Np7meT/ly5d/pH0aNGggg8Ggtm3bytXVVXXr1lXjxo1VrVq1POdv2rRJ58+fNzlJ1N/fX+vXr1dsbKzatWtnvO7m5mZyr5OTk65evfrQtdWsWdPku5eXl6ZPn66rV68qOTlZ1apVMwmalihRQhUqVNDhw4d17Ngx3bx5U56ensZxe3t7Va1a1fi9aNGi8vX11apVq/T666/r+++/l5OTkxo0aPDQNQIAAAAAAAAAAAAAAAAA8o8Q5n0UKlQoz2BgoUKFjCHM7OxsFS5cWFFRUbnm3RuyK1CggMnY3XCljY2NLly4oA4dOqhYsWJq3Lix6tSpI09PTzVq1OixPIfBYNCmTZv0yy+/KDExUZGRkYqIiNDs2bNVp06dPOfHxsbq999/V7FixXKNh4eHy97e3thOPS/t2rXTBx98oN9//12xsbEqXry4GjZs+MA6/3jCp3Sn3fu9bt68afzZ3t5eCxYs0MGDB5WQkKCEhAQtXbpUrVu31pgxY3Ktdfd39OGHH+YaW7p0qUkI82FO4nwQa2vTA2azs7NlZWWlAgUKKCcnR1ZWVrnuuX37dq6/k3vZ2pr+o9q2bVv16NFDFy5c0Jo1axQQEJBrDgAAAAAAAAAAAAAAAADgr0U78nxwd3dXWlqasrKyVL58eeNn1qxZio+PN847duyYrl27Zvy+e/duSVLVqlUVExOjy5cva+nSperZs6eaNm2qK1euSPq/EGJeob2HNXXqVO3cuVONGzfWkCFDtHbtWrm4uGjt2rV5zvfz81OhQoU0Y8aMXGPHjx/X4sWLZWNj88A969evr+LFi+vHH3/Ud999pzfffPNP7/mjAgUKmLwz6U5r9bs2bdqkadOm6aWXXtL777+vBQsW6MMPP1RcXFyutS5duqRNmzapTZs2WrVqlcmnXbt22r9/v/FU08fhj2vt3LlTzs7OKliwoNzd3bVv3z5lZWUZxy9cuKCUlBS5ubnJzc1N9vb22rlzp3H81q1bSkpKMlmzfv36KlWqlFasWKGdO3fSihwAAAAAAAAAAAAAAAAALIAQZj40aNBAVatWVZ8+fZSYmKiUlBSFh4dr5cqVJi2t09PTNWDAACUnJysxMVEjRoyQv7+/nJ2dVaZMGWVkZOj7779XamqqEhIS1K9fP0kyBvUcHR0lSUlJSbp+/XquOgoVKqTTp0/r7NmzucZSUlI0bNgwJSYm6vTp0/rhhx+UmppqbIn+R8WLF9ewYcO0YMECffLJJ9q3b59OnDihmJgYde3aVZUrV1ZwcPAD34uNjY3efPNNLVmyRPv27TM5ZfJh1ahRQ7/++qs2bNigkydPaurUqUpOTjaO29ra6ssvv9S8efN08uRJ7d+/Xz/99FOez7V69WrdunVL3bp1k7u7u8mnR48esrGx0ZIlSx66NkdHRx05ckS///57nuO7du3SuHHjdOTIEa1YsUKLFy9Wz549JUmBgYFKS0tTaGiokpKStG/fPn300UcqVqyYWrZsKUdHR73zzjuaOnWq1q1bpyNHjmjYsGE6d+6cyR7W1tZq3bq1pk+frmrVqqlSpUoPXT8AAAAAAAAAAAAAAAAA4PGgf3E+2NjYaO7cuRo3bpz69u2rjIwMubm5KSIiwqTVd9myZeXu7q5OnTrJ1tZWrVq1UmhoqCSpRYsWOnDggMLDw5WWlqZy5cqpffv2io+P1759+xQYGCh3d3c1atRIffr0Ub9+/VS0aFGTOjp27KiBAwcqICBAiYmJJmPDhw9XeHi4+vfvr8uXL6tcuXIKDQ3VG2+8cd/natWqlcqUKaM5c+aoZ8+eunr1ql544QW1bt1a7733ngoVKvSn76Zdu3aaMWOGfHx85OLi8ghv9Y4uXbro5MmT6t+/v6ysrOTv768uXbpo165dkqR69epp1KhRmjt3riZNmiQHBwc1atRIYWFhudaKiopS3bp1TYKxd7m4uKhp06aKjY3N8968BAcHa/bs2Tp69KgGDx6ca7x9+/Y6fvy43nzzTRUvXlwff/yx8aRKFxcXffvttxo/frzeeust2dnZqV69eho3bpyee+45SdLHH38se3t7jRgxQtevX5efn598fX1z7dOmTRtNnz6dUzABAAAAAAAAAAAAAADwzLN6xE69wONilXO35zX+EhEREYqOjtaGDRssXQqeMtu3b1dISIg2b94sJyenfK2VmXblMVX1aGwvHrfIvpJ0s5TlTg+1vplhkX1//p/l/nXfpHIpi+0NAAAAAAAAAAAAAACefiVbjbV0CZB0IebhDsJ7mnASJvAPc+TIESUnJ2v69Ol688038x3ABAAAAAAAAAAAAAAAAACYx9rSBQB4NMePH9egQYNUpEgR9e3b19LlAAAAAAAAAAAAAAAAAMAzi3bkAGhH/oTRjhwAAAAAAAAAAAAAAODxoh3538Oz2I6ckzABAAAAAAAAAAAAAAAAAADMQAgTAAAAAAAAAAAAAAAAAADADIQwAQAAAAAAAAAAAAAAAAAAzGBr6QIAAAAAAAAAAAAAAAAAAMgPK2sbS5eAZxQnYQIAAAAAAAAAAAAAAAAAAJiBECYAAAAAAAAAAAAAAAAAAIAZaEcOQDZXz1pk32EH7SyyryT18Mmx2N5FHApZZF+3Yrcssq8kXU5Lt8i+RQs7WmRfAAAAAAAAAAAAAAAAPBs4CRMAAAAAAAAAAAAAAAAAAMAMhDABAAAAAAAAAAAAAAAAAADMQAgTAAAAAAAAAAAAAAAAAADADLaWLgAAAAAAAAAAAAAAAAAAgPywsraxdAl4RnESJgAAAAAAAAAAAAAAAAAAgBkIYQIAAAAAAAAAAAAAAAAAAJiBECYAAAAAAAAAAAAAAAAAAIAZCGECAAAAAAAAAAAAAAAAAACYgRAmAAAAAAAAAAAAAAAAAACAGQhh4plx69YtzZ8/X23atJHBYJCPj4+6du2qxMRE4xwPDw9FRUU90rpRUVHy8PB43OWaCAsLU1BQ0F+6BwAAAAAAAAAAAAAAAADg0dhaugDgScjKylLXrl115swZ9e7dWwaDQTdu3NDKlSsVHBysMWPGqHXr1kpISJCTk5Oly81l8ODBun37tqXLAAAAAAAAAAAAAAAAAADcgxAmnglTp05VUlKSYmNjVaZMGeP1wYMHKz09XaNHj1bTpk1VqlQpC1Z5f3/HYCgAAAAAAAAAAAAAAADwd2FtbWPpEvCMIoSJp97Nmze1YsUKtWvXziSAeddHH32kt956Sw4ODvLw8NCYMWPUpk0bhYWFKS0tTenp6dqzZ4+6d++urKws/fLLL3rhhRe0ceNGvfHGG/L09JR0py35119/rbNnz6py5coaNmyYXnnlFUnSjRs3NH36dMXExOh///uf3Nzc1KtXLzVp0kSSdPv2bU2cOFHfffedLl68KGdnZ7377rsKDAyUdKcd+enTp/Xtt99KkubMmaMlS5bo7Nmzev7559W2bVv17NlTVlZWT+KVAgAAAAAAAAAAAAAAAAAkWVu6AOCvdvLkSV2+fFnVq1fPc/z555+Xl5eXbGxyp+HXr1+vunXrauXKlQoICJAk7d69WyVKlNDq1av17rvvGucuXbpUEyZM0MqVK2VnZ6c+ffoYx/r166dVq1Zp8ODBWrNmjZo0aaJevXopPj5ekrR48WL98MMPmjRpktauXat33nlHn332mXbs2JGrpg0bNmj69OkaPny41q1bp9DQUH399ddas2ZNPt4SAAAAAAAAAAAAAAAAAOBRcRImnnpXrlyRJBUpUuSR7y1SpIi6deuW6/qHH35obBG+a9cuSdLo0aNVqVIlSdJ7772nXr166eLFi7p8+bLi4+M1ffp0vfbaa5KkXr166fDhw5o+fboaN26sEydOyNHRUS4uLipVqpTeeecdVaxYURUqVMi194kTJ2Rvby9nZ2e98MILeuGFF/T888/rhRdeeOTnAwAAAAAAAAAAAAAAAACYj5Mw8dQrXry4JOny5cuPfG/58uVzXStRooQxgHmvewOTzz33nKQ7bcgPHz4sSapZs6bJ/Fq1ahnH3n77baWlpalhw4Zq3769Jk+erBIlSqhEiRK59gkICFCxYsXUrFkzBQQEKDw8XNbW1oQwAQAAAAAAAAAAAAAAAOAJI4SJp56Li4tKliyp3bt35zl+/PhxBQcHGwOR93JwcHioa5LybGeek5Nz37qys7Nla3vnMFpXV1etW7dOs2fPlre3t+Lj4/XGG28oOjo6133FixfX6tWrtXjxYjVp0kQ7d+5UYGCgpk2bdt+9AAAAAAAAAAAAAAAAAACPHyFMPPWsra3Vrl07RUVF6dy5c7nGZ8+erT179qhcuXJ/yf7u7u6SpJ07d5pc37Fjh7F9+YIFC7Ru3TrVq1dPAwYMUExMjOrUqaO4uLhc661evVpLlixRzZo19eGHH2r58uVq3759nnMBAAAAAAAAAAAAAAAAAH8dW0sXADwJPXr00ObNm9WxY0d99NFHqlGjhq5cuaKlS5cqKipK48ePV+HChf+SvStVqqRGjRpp+PDhku6cehkbG6v4+HhNnjxZknTx4kV9+eWXcnBwUJUqVXTkyBEdPHhQ7777bq71MjMzFR4erkKFCqlWrVo6e/astm3bJm9v77+kfgAAAAAAAAAAAAAAAABA3ghh4plQsGBBLVy4UHPnztWsWbOUmpoqe3t7vfzyy5o/f77+9a9//aX7T5o0SRMnTtSQIUN09epVVa5cWREREWratKkkqVevXrp165ZGjhypCxcuqFSpUurUqZO6d++ea60OHTroypUr+uqrr3TmzBkVKVJEzZs3V2ho6F/6DAAAAAAAAAAAAAAAAMDflZW1jaVLwDPKKicnJ8fSRQCwrFuphy2y72d7sy2yryT18HGx2N5FHCzzH/0L6bcssq8kFbPQMxct7GiRfQEAAAAAAAAAAAAAwJNVtv00S5cASWdW9LJ0CU+ctaULAAAAAAAAAAAAAAAAAAAA+CcihAkAAAAAAAAAAAAAAAAAAGAGQpgAAAAAAAAAAAAAAAAAAABmIIQJAAAAAAAAAAAAAAAAAABgBkKYAAAAAAAAAAAAAAAAAAAAZrC1dAEAAAAAAAAAAAAAAAAAAOSHlbWNpUvAM4qTMAEAAAAAAAAAAAAAAAAAAMxACBMAAAAAAAAAAAAAAAAAAMAMhDABAAAAAAAAAAAAAAAAAADMYGvpAgBY3lmHchbZd1jNCxbZV5JmHD5vsb1DqhWzyL45srHIvpJ09voti+zreOOURfaVJLuSzhbbGwAAAAAAAAAAAAAAAE8GJ2ECAAAAAAAAAAAAAAAAAACYgRAmAAAAAAAAAAAAAAAAAACAGQhhAgAAAAAAAAAAAAAAAAAAmMHW0gUAAAAAAAAAAAAAAAAAAJAfVtY2li4BzyhOwgQAAAAAAAAAAAAAAAAAADADIUwAAAAAAAAAAAAAAAAAAAAzEMIEAAAAAAAAAAAAAAAAAAAwAyFMAAAAAAAAAAAAAAAAAAAAMxDCfAoFBQXJw8Pjvp/z58+bvXZUVJQ8PDweY7W5hYWFKSgoKF9rnDp1Sp999pl8fX3l5eUlX19fDR8+XOfOnXtMVT689PR0LVq06IFzIiIi5Ovr+4QqAgAAAAAAAAAAAAAAAAA8DraWLgB/DT8/Pw0ePDjPsRIlSjzhah7N4MGDdfv2bbPv37Vrl95//315e3trzJgxKleunFJSUjRhwgQFBgZqyZIlKl269GOs+MHmzp2rqKgovf322/edExwc/MBxAAAAAAAAAAAAAAAAAMDfDyHMp5SDg4NKlSpl6TLM4uTkZPa9WVlZ+vjjj1W3bl1NmTJFVlZWkiRnZ2d5enqqWbNmioiI0Oeff/64yv1TOTk5fzqnUKFCKlSo0BOoBgAAAAAAAAAAAAAAAADwuNCO/Bnm6+urmTNnqnfv3jIYDPLx8dHo0aN169Yt45z169erVatW8vLy0jvvvKPU1FSTNbKysjRu3Dg1aNBABoNBHTp0UEJCgnE8KipKTZs2VVxcnLE1+Hvvvadz585p1KhR8vb2Vt26dTVjxgzjPX9sR37y5El98MEHqlmzpnx8fNS3b19duHAhz2fauHGjUlNT1bNnT2MA867nnntOs2bNUs+ePY3Xdu/erc6dOxvX/uSTT3TlyhWTdxQREWGyTlBQkMLCwiRJW7dulYeHhzZt2qTXX39d1apVU8uWLfXTTz9JutNmfNq0aTp9+rQ8PDx06tQphYWFqVevXgoODlaNGjU0Y8aMXO3Iz507p759+6pWrVry8fFRjx49dPz4ceP4xYsX9eGHH8rHx0deXl7q2LGjtm3bluc7AQAAAAAAAAAAAAAAAJ52VtY2fP4Gn2cRIcxnXEREhLy9vRUdHa3evXtrwYIF+u677yTdaevdu3dvNWvWTKtXr9Ybb7yhmTNnmtw/aNAgbd68WePGjVN0dLT8/PzUo0cPbdy40TjnzJkzWrJkib766it988032r9/vwICAmRra6vly5erY8eOmjhxopKTk3PVd+3aNXXq1Enp6emaN2+e5s2bp9OnT6t37955Ps/+/fvl6OgoDw+PPMc9PT31wgsvSJL27dunoKAgVapUScuWLdPUqVO1b98+BQcHKzs7+5He47hx4zR48GBFRUXJxcVFoaGhun79uoKDgxUcHKwyZcooISFBZcuWlXQn3Fq3bl2tXLlSAQEBJmulp6crKChIt2/f1sKFC/Xtt9+qWLFi6tChg86dOydJ+uyzz3Tjxg0tXLhQMTExqlChgnr27Kn09PRHqhsAAAAAAAAAAAAAAAAAYD7akT+lYmJitHbt2lzXX3vtNU2cONH4vUGDBurcubMkydXVVZGRkdq1a5dat26thQsXqkaNGsbAY4UKFZScnKwFCxZIklJSUvTdd98pMjJSnp6ekqSuXbsqKSlJc+bM0auvvipJunnzpoYOHSp3d3dJUp06dbRnzx4NGDBAVlZW6t69u7788kv99ttvxjl3xcXF6dq1a5o0aZKKFi0qSRo1apRWr16tzMxM2dvbm8y/cuWKnJyccp2CmZe5c+fKw8NDn376qSSpUqVKmjBhggICArR582Y1atToT9e4q0+fPqpTp47x5zfeeEPJyckyGAxydHSUjY2NSXv4IkWKqFu3bnmuFRsbq99//10TJkxQgQIFjM+8detWLV++XL1799aJEyfk7u6uF198Ufb29ho8eLBatWolG5tnM00OAAAAAAAAAAAAAAAAAJZACPMp5evrq9DQ0FzXHR0dTb67ubmZfHdyctLNmzclScnJyapXr57JuMFgMIYwDx48KEnGEOddN2/e1HPPPWdyrUKFCsafCxYsKGdnZ2NQ8m6QMjMzM1e9hw8flqurqzGAKUmVK1fO89kkqVixYrpy5YpycnL+NIiZ1/N5eHjoueee0+HDhx8phFmxYkXjz4ULF5Yk43vMS/ny5e87dvDgQaWlpelf//qXyfXMzEwdOXJEktSrVy/1799f69evV61atVS/fn35+/vnCqUCAAAAAAAAAAAAAAAAAP46hDCfUoUKFXpg0O8uOzu7XNdycnLy/FmS8WTGe8cWLVqkQoUKmcyztra+7315jd+Pra3tQ51qeVeNGjU0ffp0JSUlqWrVqrnG586dq+PHj2vEiBH3DWpmZ2fn+Zx35RWu/LP3+EcODg73HcvOzlaFChX09ddf5xq7G6Jt2rSpNm/erM2bN+vXX3/V7NmzNWXKFC1fvlyVK1e+79oAAAAAAAAAAAAAAAAAgMfn4ZJweCZVrVpVu3btMrm2f/9+4893w37/+9//VL58eeMnKipKK1eufCw1VKpUScePH9e1a9eM1w4ePCgfHx+dPn061/w6derI2dk5zwDjpUuXNHfuXGVlZUmS3N3dtWPHDpM5SUlJSktLM54QWqBAAZO9s7OzderUqUd6hkcJkd6tKzU1VU5OTsZ3Wq5cOU2YMEHbt29XVlaWxowZo5MnT8rf31+ff/651q9fL2tra23cuPGR9gIAAAAAAAAAAAAAAAAAmI8Q5lPqxo0bOn/+fJ6fvNp+5yU4OFhJSUkKDw/XsWPHtGbNGi1atMg4XrlyZb322msaNmyY4uPjdfLkSc2ZM0czZsyQi4vLY3mOVq1aqUiRIurfv7+SkpL0n//8R5999pnc3d1Vrly5XPPt7Ow0atQo/fzzz+rZs6e2b9+ukydPKj4+Xu+++64cHBz08ccfS5K6dOmipKQkjRgxQkeOHNG2bdsUGhqql156SXXq1JF052TNuLg4bd++XceOHdNnn31mEsp8GI6Ojrpy5YqOHTv2wBbldwUEBKhIkSLq1auX9uzZoyNHjmjQoEHatGmTKleuLDs7O+3du1dDhw7Vnj17dOrUKUVFRen69esyGAyPVBsAAAAAAAAAAAAAAAAAwHy0I39Kff/99/r+++/zHJs4caJatmz5p2tUrVpVs2bN0rhx47Rw4UJVrlxZPXr00Pjx441zJk2apEmTJmnYsGG6cuWKXFxcNHLkSLVt2/axPEfBggU1Z84cjR07VoGBgbKzs5Ovr68GDBhw33tq166tpUuXaubMmfr444/1+++/q3Tp0nr11VfVo0cPlSxZUpJkMBg0a9YsTZkyRa1bt1bhwoXVpEkTffzxx8Z25H379tWVK1cUEhKiggULqn379vL3939gq/E/atasmZYvX66AgAAtXLjwT+c7OTlp4cKF+uKLL9StWzfdvn1bVatW1Zw5c4ynj06ZMkVjxozRv//9b127dk0VK1bUhAkTVKtWrYeuCwAAAAAAAAAAAAAAAHhaWFnbWLoEPKOsch4lTQbgqXTqUppF9i1964JF9pWkGUcs96++kGrFLLLv6UzL/c9G1m3LvO+KNlctsq8k2ZV0ttjeAAAAAAAAAAAAAAA8a1yC5lm6BEg6+W0XS5fwxNGOHAAAAAAAAAAAAAAAAAAAwAyEMAEAAAAAAAAAAAAAAAAAAMxACBMAAAAAAAAAAAAAAAAAAMAMhDABAAAAAAAAAAAAAAAAAADMQAgTAAAAAAAAAAAAAAAAAADADIQwAQAAAAAAAAAAAAAAAAAAzGBr6QIAAAAAAAAAAAAAAAAAAMgPKxsbS5eAZxQnYQIAAAAAAAAAAAAAAAAAAJiBECYAAAAAAAAAAAAAAAAAAIAZaEcOQPa2lsljrzltZ5F9JSmwWlGL7W3v5GiRfUtYZ1hkX0m6lZ1jkX1TMopYZF9JKpdxwyL7OhZ0sMi+AAAAAAAAAAAAAAAAzyJOwgQAAAAAAAAAAAAAAAAAADADIUwAAAAAAAAAAAAAAAAAAAAzEMIEAAAAAAAAAAAAAAAAAAAwAyFMAAAAAAAAAAAAAAAAAAAAM9haugAAAAAAAAAAAAAAAAAAAPLDytrG0iXgGcVJmAAAAAAAAAAAAAAAAAAAAGYghAkAAAAAAAAAAAAAAAAAAGAGQpgAAAAAAAAAAAAAAAAAAABmIIQJAAAAAAAAAAAAAAAAAABgBkKYeKbExMTorbfeksFgkMFgUNu2bbV06dK/dM+wsDAFBQXdd9zDw0NRUVF/aQ0AAAAAAAAAAAAAAAAAgMfP1tIFAE9KZGSkPv/8c33yySfy9vZWTk6OEhMTNWrUKF24cEG9evWySF0JCQlycnKyyN4AAAAAAAAAAAAAAAAAAPMRwsQzY/HixWrXrp06dOhgvFaxYkWdPXtWCxYssFgIs1SpUhbZFwAAAAAAAAAAAAAAAHhaWFnbWLoEPKNoR45nhrW1tXbt2qUrV66YXA8JCdGyZcskSb6+vvr222/Vu3dvvfLKK2rYsKFWrFih3bt3q3Xr1nrllVfUsWNHnThxwnj/mTNnFBoaqnr16ql69ep67733dPjw4fvWMXbsWNWqVUt79uyRZNqOPCwsTP3791d4eLjq1KmjV155RT179tT58+eN9584cUIhISEyGAyqX7++5s6dq6ZNm9LSHAAAAAAAAAAAAAAAAACeMEKYeGaEhITo0KFDatiwod5//33NnDlT+/btk5OTkypUqGCcN2HCBDVo0EDfffedXn31VX322WcaNmyYwsLCtHDhQp0/f17jx4+XJKWlpSkwMFDnzp3T119/raVLl8rR0VHvvPOOUlNTc9Uwfvx4RUVFae7cuapevXqedX7//fe6fPmyFi5cqGnTpmnnzp2aNGmSJCkjI0NdunRRdna2lixZosmTJys6OlonT558/C8MAAAAAAAAAAAAAAAAAPBAhDDxzGjevLmWLVumZs2aaf/+/ZowYYLat2+vFi1aaOfOncZ5DRs2VIcOHeTi4qLOnTvr1q1bCgoKUu3ateXp6Sk/Pz8lJydLktasWaPff/9dU6ZMkZeXl6pUqaLx48fLwcFBixYtMtl/8uTJWrFihebNmycvL6/71lm4cGGNGDFCbm5uatCggd544w1jfXFxcbp06ZImTJigKlWqqFatWho/frxycnL+gjcGAAAAAAAAAAAAAAAAAHgQW0sXADxJXl5eGjdunHJycpScnKxNmzZpwYIFCgkJ0fr16yXJ5FRMBwcHSZKzs7Pxmr29vbKysiRJycnJcnV1VfHixU3Gvby8TFqS79mzR9u3b1fx4sVVpkyZB9ZYvnx5FShQwPjdyclJN2/elCQdPHhQFSpUUNGiRY3jHh4ecnJyetRXAQAAAAAAAAAAAAAAAADIJ07CxDPh7NmzGjlypM6dOydJsrKykoeHh95//33Nnz9f169f1/bt2yVJtra5s8nW1nn/o5KTkyMrK6tc12/fvm2yjqOjo5YsWSIHBweNHDnygbXa2dndd8zGxkbZ2dkPvB8AAAAAAAAAAAAAAAAA8GQQwsQzwc7OTsuWLdOaNWtyjRUuXFiSVLJkyUde193dXceOHdPFixeN1zIzM/Wf//xHlSpVMplnMBg0fPhwxcXFad26dWY8hVSlShWlpKTo8uXLxmtHjx7VtWvXzFoPAAAAAAAAAAAAAAAAAGA+Qph4JhQvXlzdunXT5MmTNWnSJB06dEgnT57UTz/9pF69esnHx0e1atV65HVbtWql5557Tn369NG+ffuUlJSk/v37Kz09XW+99Vau+Q0aNFBAQICGDx+u33///ZH3e/3111WsWDH1799fSUlJ2rNnj/r37y9JeZ7ICQAAAAAAAAAAAAAAAAD46+Tuuww8pfr06SNXV1ctX75cixYt0o0bN1S2bFn5+/ure/fuZq353HPPaeHChQoPD1eXLl0kSTVr1tSSJUvk4uKS5z2ffPKJ/P399fnnn2vChAmPtJ+dnZ1mz56tESNGqEOHDipSpIh69Oih//znPypQoIBZzwAAAAAAAAAAAAAAAAD801lZ21i6BDyjrHJycnIsXQSAh3Pq1CkdP35c9evXN147d+6cGjZsqEWLFpl1mqcknb+a/rhKfCQ/p1y2yL6S9KprUYvtXcLJ0SL7XrmeYZF9JelWtmX+U3Mp47ZF9pWkck6WCUY7FnSwyL4AAAAAAAAAAAAAAFhShfcjLV0CJB2b2c7SJTxxtCMH/kEyMzP1/vvva86cOTp58qQOHjyooUOHytXVVa+88oqlywMAAAAAAAAAAAAAAACAZwohTOAfxM3NTRMnTlRMTIxef/11de3aVY6Ojvrmm29oRw4AAAAAAAAAAAAAAAAAT5itpQsA8GhatGihFi1aWLoMAAAAAAAAAAAAAAAAAHjmcRImAAAAAAAAAAAAAAAAAACAGQhhAgAAAAAAAAAAAAAAAAAAmIEQJgAAAAAAAAAAAAAAAAAAgBlsLV0AAAAAAAAAAAAAAAAAAAD5YW1tZekS8IziJEwAAAAAAAAAAAAAAAAAAAAzEMIEAAAAAAAAAAAAAAAAAAAwA+3IAahY2kmL7OtXqbxF9pUk+5TtFts7q3Rli+zrsDfeIvtKUs6/WltkX/vClvvPnG1WmkX2zcy+aZF9Jcm+kJPF9gYAAAAAAAAAAAAAALAETsIEAAAAAAAAAAAAAAAAAAAwAyFMAAAAAAAAAAAAAAAAAAAAMxDCBAAAAAAAAAAAAAAAAAAAMIOtpQsAAAAAAAAAAAAAAAAAACA/rKytLF0CnlGchAkAAAAAAAAAAAAAAAAAAGAGQpgAAAAAAAAAAAAAAAAAAABmIIQJAAAAAAAAAAAAAAAAAABgBkKYAAAAAAAAAAAAAAAAAAAAZiCEiWeCr6+vPDw8jJ9q1arp1Vdf1YgRI/T7778b53l4eCgqKuqh1jx16pQ8PDy0devWfNX222+/aePGjflaAwAAAAAAAAAAAAAAAADw5NlaugDgSQkODlZwcLAk6caNG0pOTta4ceO0fft2LVmyRIULF1ZCQoKcnJyeaF3du3fXm2++qVdfffWJ7gsAAAAAAAAAAAAAAAAAyB9OwsQzw9HRUaVKlVKpUqXk4uKixo0ba+7cuTp16pTmzJkjSSpVqpQcHBwsXCkAAAAAAAAAAAAAAAAA4J+AECaeaS+88IKaNm2q7777TpJpO/KsrCxNmDBBTZo0UbVq1eTj46N+/fqZtC+XpD179iggIECenp5q3769Dhw4YDK+cuVK+fn5ycvLS35+fpo/f76ys7Ml3WmTfvr0aU2bNk1BQUGSpGvXrmno0KGqXbu2atasqc6dO2v//v3G9TIyMjR48GDVq1dPnp6eat26tdatW/eXvSMAAAAAAAAAAAAAAADg787KyorP3+DzLCKEiWeeu7u7Tpw4oevXr5tc/+KLL/Tdd99p1KhRWrt2rcLDw/XLL7/o66+/Npk3e/Zs9ejRQ6tWrfp/7N15eE1X+//xTwZBJEIirZYQU0IROZU2JaZGzXOoGlOCUqUlpaaax5iJGkrMc4mZGtKH0iqlptIkGkNiqJqJIYkkvz/8cr5OQ0WoXfV+Xde+rpy11l73vfc5fdo/7mfd8vT0VIsWLXThwgVJ0rJlyxQSEqJPPvlEGzZsULdu3TRz5kyNHTtWkrRixQrlzZtXQUFBCg0NVWpqqjp06KBTp05pxowZWr58uby9vdW8eXMdO3ZMkjRp0iRFRUXp66+/1saNG1WpUiV1795dZ86ceQ5vCwAAAAAAAAAAAAAAAACQxtboBACj5cyZU5IUHx9vMV66dGlVr15db7/9tiQpX758qlChgqKioizWdenSRbVr15YkDRo0SD/++KMWL16s7t27a+rUqerYsaPq1q0rSXJzc1N8fLwGDx6szz77TM7OzrKxsZG9vb1y5cql3bt368CBA9q9e7ecnZ0lScHBwfrll180f/58jRo1SrGxsXJwcFCBAgXk6Oiozz77TD4+PnJycvpH3xMAAAAAAAAAAAAAAAAAwBJFmHjp3bx5U5Lk4OBgMd6gQQPt3r1b48eP16lTpxQTE6MTJ07Ix8fHYt2Dn21tbfXGG2/o+PHjunLliv744w9NmjRJU6ZMMa9JSUlRQkKCzpw5oyJFiljsldbKvGrVqhbjiYmJSkhIkCR16NBBnTp1Urly5WQymeTn56c6derI0dHxKd8EAAAAAAAAAAAAAAAAAOBJUISJl97Ro0fl7u6uHDlyWIwPGjRIGzduVMOGDVWlShV9/PHHCgsLM7caT2NjY2PxOTk5WVmzZlVKSookqU+fPipfvny6uK+99lq6sZSUFDk4OCg8PDzdnJ2dnSTJZDJpx44d+uGHH7R7926tWLFCoaGhmjVrlsqVK/dkDw8AAAAAAAAAAAAAAAAAyDRroxMAjPTHH38oIiJC9erVsxi/evWqlixZokGDBqlv374KCAhQiRIldOLECaWmplqs/fXXX81/JyYm6tdff1WxYsXk4uIiFxcXxcbGqmDBgubr6NGjmjhx4kPz8fDwUHx8vBITEy3umTlzpiIiIiRJkydP1v79+1W1alV9+eWX2rx5s9zc3LR58+Zn+3IAAAAAAAAAAAAAAAAAAH+LkzDx0rh9+7YuXrwoSbp7966ioqI0ceJE5c+fX23btrVY6+joKEdHR0VERKhkyZK6e/euFi5cqKNHj6pMmTIWa8eNG6dcuXLJ3d1dU6dOVWJiolq2bCkrKyu1b99e48eP1+uvv67KlSsrOjpagwcPVpUqVcwnW+bIkUOnTp3SpUuXVLFiRZUoUULdunXTl19+qddff11Lly7VypUrNXv2bEnS6dOntXbtWg0dOlQFChTQwYMHde7cOZlMpufwFgEAAAAAAAAAAAAAAAAAaSjCxEtj9uzZ5kJGe3t75c2bV9WrV1dQUFC6VuS2traaNGmSRo0apXr16snJyUm+vr4KDg7W9OnTdfv2bfParl27auzYsTpz5oy8vLw0Z84c5cqVS5IUFBSkrFmzasGCBQoJCZGLi4sCAgLUvXt38/2tW7dWSEiIjh8/rrVr12r27NkaM2aMunfvrjt37qhIkSIKDQ01txofPHiwQkJC1LNnT127dk358uVTjx491KBBg3/4DQIAAAAAAAAAAAAAAAAAHmSV+tfeygBeOvfORRkSNzF3QUPiSlLW0z8bFjv51WKGxE09FGFIXElKfbuhIXHvydqQuJJkl3TLkLiptlkNiStJWXM4GhYbAAAAAAAAAAAAAPBy8+y62ugUICkqtKHRKTx3xlWnAAAAAAAAAAAAAAAAAAAAvMAowgQAAAAAAAAAAAAAAAAAAMgEijABAAAAAAAAAAAAAAAAAAAygSJMAAAAAAAAAAAAAAAAAACATKAIEwAAAAAAAAAAAAAAAAAAIBMowgQAAAAAAAAAAAAAAAAAAMgEW6MTAAAAAAAAAAAAAAAAAADgaVhZWxmdAl5SnIQJAAAAAAAAAAAAAAAAAACQCRRhAgAAAAAAAAAAAAAAAAAAZAJFmAAAAAAAAAAAAAAAAAAAAJlga3QCAIyXapvVkLhX7twzJK4k5XXMY1jsVNtsxsT1DTAkriTZXD9nSNzztq8YEleS8t+7bkjc5Fz5DIkrSWev3jIkbr7cOQyJCwAAAAAAAAAAAAAAwEmYAAAAAAAAAAAAAAAAAAAAmUARJgAAAAAAAAAAAAAAAAAAQCZQhAkAAAAAAAAAAAAAAAAAAJAJtkYnAAAAAAAAAAAAAAAAAADA07CytjI6BbykOAkTAAAAAAAAAAAAAAAAAAAgEyjCBAAAAAAAAAAAAAAAAAAAyATakQMAAAAAAAAAAAAAAAAAAEOlpKRoypQp+uabb3Tjxg2VLVtWAwcOVMGCBdOtDQ0N1ZQpUx66T0BAgEaOHClJ8vf319mzZy3m69Wrp7Fjxz6zvCnCBAAAAAAAAAAAAAAAAAAAhpo6daqWLl2qkSNH6tVXX9WYMWPUoUMHrV+/XnZ2dhZrg4KC1KxZM4uxFStWaPr06frwww8lSfHx8Tp37pxmzJihkiVLmtdly5btmeZNO3LgAcnJyVq8eLGaNGkik8kkHx8fNWvWTKtWrVJqaqok6cyZM/L09NSePXv+sTzCw8Pl6elp/nzu3Dlt2LDhH4sHAAAAAAAAAAAAAAAAAEZJTEzU7Nmz1bVrV1WuXFnFixfXhAkTdOHCBW3dujXd+hw5csjV1dV83blzRzNmzFDv3r1VvHhxSVJ0dLRSU1P15ptvWqx1dHR8prlThAn8f/fu3dPHH3+s0NBQNWrUSKtWrdKyZctUu3ZtjRgxQl27dlVycvJzyaV27dratWuX+XOvXr20c+fO5xIbAAAAAAAAAAAAAAAAAJ6nyMhI3bp1S++88455LGfOnHrjjTf0888/P/b+UaNGqVixYvrggw/MY1FRUXJ1dVXOnDn/kZzT0I4c+P+mT5+u/fv3Kzw8XAULFjSPFylSRG+//baaNGmisLAw1a5d+x/PJVu2bM/82FsAAAAAAAAAAAAAAAAA+CdVrVr1b+cjIiIeOv7HH39Ikl577TWL8VdeeUXnz5//2z2PHDmiiIgIzZs3T9bW/3cuZXR0tOzt7dW1a1cdOHBAzs7OCggIUGBgoMW6p8VJmICk1NRULVy4UI0aNbIowExTvHhxNWjQQAsWLDC3JT948KDq16+v0qVL6/3339fRo0ct7lm5cqVq1aolLy8v1apVS/PmzVNKSop5fvXq1apTp45Kly6tihUravjw4UpMTJRk2Y68devW2rt3r1atWiV/f3/NnTtXJpNJd+7cMe+VkpKiSpUqaf78+c/83QAAAAAAAAAAAAAAAAD/dtZWVlz/giuz0mqh7OzsLMazZs2qhISEv7137ty5KlOmjMUpmpJ0/Phx3bx5U7Vr11ZYWJg++OADTZo0SaGhoZnO82E4CROQdPLkSV29elVvvvnmI9eUK1dOK1asMBdhzpo1S4MHD5anp6fmzJmjFi1aaMuWLXr11Ve1bNkyjRs3TgMGDFCZMmV07NgxDR06VBcuXNAXX3yhyMhIffnllxo7dqy8vLwUExOjzz//XLlz51bnzp0t4oaGhqpTp07KmzevBgwYIEkaO3astmzZogYNGkiSfvzxR125ckV169b9h94QAAAAAAAAAAAAAAAAAPy9R510+ThpXYMTExMtOggnJCQoe/bsj7zv9u3b2rp1qwYOHJhubs6cOUpISJCDg4MkydPTU7du3dK0adPUtWvXZ3YaJidhApKuXbsmScqdO/cj16TNXblyRZLUpUsX1a5dW0WKFNGgQYPk4uKixYsXS5KmTp2qjh07qm7dunJzc1ONGjXUvXt3LVy4UAkJCTpz5oysrKyUP39+vf7666pYsaLCwsJUq1atdHFz5cqlLFmyKFu2bHJ2dpazs7P8/f21du1a85q0UzKdnZ2f1SsBAAAAAAAAAAAAAAAAgOcirQ35n3/+aTH+559/Km/evI+8b+fOnUpJSVG1atXSzWXJksVcgJnGw8NDt2/f1vXr159B1vdRhAnofqGjJN28efORa9L+wUsrxvTx8THP2dra6o033tDx48d15coV/fHHH5o0aZJMJpP5GjJkiLkAs2LFijKZTGrcuLFq1KihwYMH6/r163J3d89Qvo0bN9aPP/6oCxcuKD4+Xtu2bVNAQEDmHh4AAAAAAAAAAAAAAAAADFS8eHE5ODhoz5495rEbN27o2LFjFnVaf7V//36VLFlSOXPmtBhPSUmRv7+/pk2bZjF+5MgR5cmT528P63tStCMHJBUsWFCurq7au3evqlev/tA1e/bskaurq6ysrCRJNjY2FvPJycnKmjWrUlJSJEl9+vRR+fLl0+3z2muvyc7OTvPnz9exY8e0a9cu7dq1S0uXLlXDhg01cuTIx+ZboUIFubq6asOGDcqVK5ccHR1VsWLFJ31sAAAAAAAAAAAAAAAAADCcnZ2dWrVqpbFjx8rZ2Vn58uXTmDFjlDdvXlWrVk3Jycm6cuWKHB0dLdqVR0ZGysPDI91+1tbWqlGjhmbNmiV3d3eVLFlSu3fv1qxZs9SvX79nmjsnYQK6X1AZGBioFStW6Pjx4+nmIyMjtXr1arVo0ULW1vf/sfn111/N84mJifr1119VrFgxubi4yMXFRbGxsSpYsKD5Onr0qCZOnChJ2rFjh6ZMmaI33nhDH330kebPn69PP/1UGzduzHC+DRs21JYtW7RlyxY1aNAgXVEoAAAAAAAAAAAAAAAAALwoPv30UzVp0kRffvmlmjdvLhsbG4WFhcnOzk7nz59XhQoV0tVXXbp0ydwF+a8+//xztW/fXuPGjVPt2rU1Z84c9evXT02bNn2meXMSJvD/tWvXTkeOHFGrVq306aefqkKFCpKkXbt2afLkyfL19dVHH32kP/74Q5I0btw45cqVS+7u7po6daoSExPVsmVLWVlZqX379ho/frxef/11Va5cWdHR0Ro8eLCqVKkiOzs72dra6quvvpKDg4OqVq2qa9eu6X//+59MJtNDc8uRI4fOnj2rP/74Q3nz5pV0vyX5zJkzlSVLFvXs2fP5vCQAAAAAAAAAAAAAAAAA+AfY2NioZ8+eD62Fyp8/v6KiotKN/92hd7a2tvr444/18ccfP9M808X5R3cHXiA2NjaaPHmywsPD9c0332jChAlKTU1VsWLF1KNHDzVp0sTcilySunbtqrFjx+rMmTPy8vLSnDlzzFXVQUFBypo1qxYsWKCQkBC5uLgoICBA3bt3lyT5+flp+PDhmj17tiZMmKBs2bKpcuXK6t2790Nza9asmXr16qX69etr9+7dsrGxUcGCBeXt7a2UlBQVKVLkH38/AAAAAAAAAAAAAAAAwL+VlbXV4xcB/wCr1NTUVKOTAPDkUlNTVb16dX300Ud6//33n2qvpD9PPZukntAF2zyGxJWkvHfiDIudnPM1Q+Km2mY1JK4k2Vw/Z0jcM7avGBJXkvLf+9OQuPdy5TMkriRduZNsSNx8uXMYEhcAAAAAAAAAAAAA8O9Rqsd6o1OApF/H1jU6heeOkzCBF0xSUpK+++47/fTTT4qPj1edOnWMTgkAAAAAAAAAAAAAAAAAXkoUYQIvmCxZsmjYsGGSpDFjxsje3t7gjAAAAAAAAAAAAAAAAADg5UQRJvAC2rlzp9EpAAAAAAAAAAAAAAAAAMBLz9roBAAAAAAAAAAAAAAAAAAAAF5EFGECAAAAAAAAAAAAAAAAAABkAkWYAAAAAAAAAAAAAAAAAAAAmWBrdAIAAAAAAAAAAAAAAAAAADwNK2sro1PAS4qTMAEAAAAAAAAAAAAAAAAAADKBIkwAAAAAAAAAAAAAAAAAAIBMoB05ACU7uBoSN/F2iiFxJSnVLodhsWVlzPHX1neuGhJXkm45vGZIXAfjfmJKtTHmN5aYnGpIXEnKZmvMb/v6rTuGxJUkpxzZDYsNAAAAAAAAAAAAAACMx0mYAAAAAAAAAAAAAAAAAAAAmUARJgAAAAAAAAAAAAAAAAAAQCZQhAkAAAAAAAAAAAAAAAAAAJAJFGECAAAAAAAAAAAAAAAAAABkgq3RCQAAAAAAAAAAAAAAAAAA8DSsra2MTgEvKU7CBAAAAAAAAAAAAAAAAAAAyASKMAEAAAAAAAAAAAAAAAAAADKBIkwAAAAAAAAAAAAAAAAAAIBMoAjzJdK6dWv17t37oXO9e/dW69atn3NGGfdvz++v9u/fr3379j2z/fz9/RUaGvrM9gMAAAAAAAAAAAAAAAAAPD2KMIF/QIsWLRQbG/vM9luxYoWCgoKe2X4AAAAAAAAAAAAAAAAAgKdna3QCAB7P2dnZ6BQAAAAAAAAAAAAAAAAAAH/BSZhI5+bNm+rfv7/eeecdlS1bVoGBgTpy5Ih5PjQ0VG3atNH8+fNVoUIFeXt7Kzg4WBcvXtQXX3whk8mkypUra9WqVeZ7kpOTNXfuXNWoUUOlS5dWjRo1tHz5cou4cXFx+uSTT1S2bFn5+vqqe/fuunTpknk+KSlJISEhKleunLy9vdW5c2fz/JkzZ+Tp6ampU6fKz89P/v7+unHjhq5du6bBgwercuXK8vLyUvPmzS3ahGfmWW7cuKGBAweqcuXKKlmypPz8/DRw4EDdvXtXkuTp6SlJ6tOnj7n9+/nz59WjRw/5+fnJ29tb7dq1U1RUlHnPy5cv69NPP5Wvr6+8vLzUrFkz7d271zz/YDvyO3fuqF+/fvLz81Pp0qXVsGFDbdmyJZPfNgAAAAAAAAAAAAAAAPDis7Lm+jdcL6OX9LHxKKmpqerQoYNOnTqlGTNmaPny5fL29lbz5s117Ngx87p9+/Zp3759mjdvniZOnKjNmzerbt26KlGihFauXKlKlSppwIABunr1qiRp1KhRmjp1qrp06aJ169YpMDBQQ4YM0YIFCyTdL/xs0aKFbt++rblz52ru3Lk6e/asunbtao554MABXb9+XYsWLdKMGTN08OBBjR492iL/tWvXat68eZo0aZJy5MihoKAg7du3TyEhIVq1apWKFy+uNm3aWBSVPumz9OrVS4cPH9bkyZO1efNm9enTR+Hh4Vq2bJkkadeuXZKkvn37ql+/foqPj1fz5s114cIFTZs2TUuXLpW9vb1atWqlc+fOSZIGDRqku3fvauHChVq3bp0KFSqkzp076/bt2+m+o0mTJikqKkpff/21Nm7cqEqVKql79+46c+bMU3//AAAAAAAAAAAAAAAAAICMox35S2bdunXavHlzuvHExES9+eab+umnn3TgwAHt3r3b3AI7ODhYv/zyi+bPn69Ro0ZJklJSUjRs2DDlzJlTRYoUUYkSJZQlSxa1bdtWktSmTRstX75cp0+fVpYsWbRkyRL17t1b9erVkyS5u7srLi5O06dPV6tWrbRx40bdvHlTEyZMUK5cuSRJw4cP15o1a5SQkCBJcnV11dChQ2VjY6PChQurdu3a+vHHHy2eo0WLFipatKgkaceOHTp69KjWrVsnDw8PSdKAAQN06NAhhYWFaeLEiU/8LLlz55afn598fHxUvHhxSVL+/Pm1cOFC88mWrq6ukiRHR0c5Ojpq8eLFunr1qsLDw83vdOzYsXrvvfe0aNEi9ezZU7GxsfLw8FCBAgWUNWtW9evXT/Xq1ZONjU267yo2NlYODg4qUKCAHB0d9dlnn8nHx0dOTk5P9FsAAAAAAAAAAAAAAAAAADwdijBfMv7+/urRo0e68bFjx+ratWs6evSoJKlq1aoW84mJieZiSElycXFRzpw5zZ+zZ8+u1157zfw5a9askqSEhASdOHFCSUlJKlu2rMWePj4+mjNnji5fvqyoqCi5u7ubCzAlqVixYha5FihQwKIo0cnJydwCPE3BggXNf0dHR8vR0dFcgClJVlZW8vHx0c6dOzP1LNL9Qs/vvvtOa9asUWxsrKKjoxUXFyd3d3c9THR0tNzd3c0FmGl7enl5mQs3u3Tpop49e2rr1q3y8fFRhQoVVLt2bXPsB3Xo0EGdOnVSuXLlZDKZ5Ofnpzp16sjR0fGh8QEAAAAAAAAAAAAAAAAA/wyKMF8yOXLksChUfHD82rVrSklJkYODg8LDw9OtsbOzM/+dJUuWdPPW1g/vbp+amirpfgHkg1JSUiRJtra2srW1TTf/Vw87FfKvsmXLZhH3YXumpKTI1vb/fvpP+iydOnVSVFSU6tWrpxo1aig4OFj9+/d/ZE6PyiM5OdmcR7Vq1bRz507t3LlTP/74o2bNmqVJkyZp+fLlKlasmMV9JpNJO3bs0A8//KDdu3drxYoVCg0N1axZs1SuXLlH5gEAAAAAAAAAAAAAAAAAeLYeXmmGl5aHh4fi4+OVmJioggULmq+ZM2cqIiIiU3sWLlxYtra22rdvn8X4vn375OrqKicnJxUtWlSnTp3SzZs3zfPHjh2Tr6+vzp49m6m4np6eunHjhqKjoy3G9+/fb25Z/qSOHTumHTt2aPLkyerRo4fq16+vAgUKKDY21lxs+lceHh46efKkLl++bB5LSEjQr7/+qqJFiyoxMVEjR45UXFycateurWHDhmnr1q2ytrbW9u3b0+03efJk7d+/X1WrVtWXX36pzZs3y83N7aFt5gEAAAAAAAAAAAAAAAAA/xyKMGGhYsWKKlGihLp166bdu3fr9OnTCgkJ0cqVK1WkSJFM7eno6KimTZtq8uTJWrdunU6fPq1FixZp8eLFCgoKkpWVlerVqycnJyf17NlTkZGR+vXXXzVo0CB5eHgoX758mYrr5+cnT09Pff7559qzZ49iYmI0ePBgRUdH68MPP8zUnnny5JGtra02bdqkuLg4HTlyRN26ddPFixeVmJhoXmdvb6+YmBhdvXpV9erVU86cOdWtWzcdPnxYkZGR6tmzp27fvq0PPvhAdnZ2OnTokPr376+DBw/qzJkzCg8P161bt2QymdLlcPr0aQ0cOFC7d+/W2bNn9e233+rcuXMPXQsAAAAAAAAAAAAAAAAA+OfQjhwWbGxsNHv2bI0ZM0bdu3fXnTt3VKRIEYWGhj5Vq+t+/fopd+7cGjdunC5duqSCBQtqwIABatq0qSQpe/bsCgsL06hRo9S8eXPZ2dnJ399fX3zxRaZj2traas6cOQoJCVHXrl2VmJiokiVLau7cufL29s7Unq+++qpGjRql0NBQLVq0SK6urqpSpYratGmjiIgIc+vxoKAgzZo1SydOnNC0adO0cOFChYSEqE2bNpKksmXLasmSJXJzc5MkTZo0SSNHjtTHH3+smzdvqnDhwho3bpx8fHzS5TB48GCFhISoZ8+eunbtmvLly6cePXqoQYMGmX1VAAAAAAAAAAAAAAAAAIBMsEp9VA9lAC+Nu7dvGRL33O0UQ+JKklvqVcNip2R3MiSuVaIx37Mk3bbLZUjcJON+YnJKvmFI3Dt2xvy+JOleijH/SWFrbWVIXElyypHdsNgAAAAAAAAAAAAAgP9j6rfJ6BQg6cDwWkan8NzRjhwAAAAAAAAAAAAAAAAAACATKMIEAAAAAAAAAAAAAAAAAADIBIowAQAAAAAAAAAAAAAAAAAAMoEiTAAAAAAAAAAAAAAAAAAAgEygCBMAAAAAAAAAAAAAAAAAACATKMIEAAAAAAAAAAAAAAAAAADIBIowAQAAAAAAAAAAAAAAAAAAMsHW6AQAAAAAAAAAAAAAAAAAAHga1tZWRqeAlxQnYQIAAAAAAAAAAAAAAAAAAGQCRZgAAAAAAAAAAAAAAAAAAACZQDtyAIqLTzEkboEchoSVJN2zecWw2DZ3rhkS1yr5niFxJSnHnUuGxLVKvGVIXEm6YF/AkLjZUlINiStJW09cNSRuFfdchsSVJIfThwyLbVOwjGGxAQAAAAAAAAAAAADAfZyECQAAAAAAAAAAAAAAAAAAkAkUYQIAAAAAAAAAAAAAAAAAAGQCRZgAAAAAAAAAAAAAAAAAAACZYGt0AgAAAAAAAAAAAAAAAAAAPA0rayujU8BLipMwAQAAAAAAAAAAAAAAAAAAMoEiTAAAAAAAAAAAAAAAAAAAgEygCBMAAAAAAAAAAAAAAAAAACATKMIEAAAAAAAAAAAAAAAAAADIBIowXxDx8fEqU6aMypcvr8TExMeuT0pK0ty5c586rr+/v0JDQzO83tPTU+Hh4Zmaf9JY/4TU1FStWrVKly9ffm4xe/furdatWz+3eAAAAAAAAAAAAAAAAACAZ4MizBfEhg0b5OLiovj4eG3duvWx69evX6+RI0c+ddwVK1YoKCjoqfd5Ufz888/q3bu37ty589xi9uvXz/DiUwAAAAAAAAAAAAAAAADAk6MI8wWxcuVKVahQQeXKldPSpUsfuz41NfWZxHV2dlaOHDmeyV4vgmf13p6Eo6OjcuXK9dzjAgAAAAAAAAAAAAAAAACejq3RCeDxYmJidOjQIbVr1063b99W7969FRMToyJFikiSWrduLTc3Nx0/flwnT55U27ZtNXnyZEn323/Pnz9fvr6++t///qfQ0FD9/vvvevXVV1WnTh117txZdnZ25rWdOnXS2rVrlZiYqAULFqh9+/Zq1KiRunbtqtTUVIWFhWnlypWKi4tT1qxZ5ePjoy+//FJubm7P9JkbNmyoEiVKWJzm+f3336tz5876/vvvNXr0aCUmJipPnjxauXKl7Ozs1KBBAwUHB5uf58KFCxo1apR27twpGxsbmUwm9e7dW+7u7pLutwGPj4/X7du3dfDgQXXs2FHjx4+XJFWtWlUjR45UQECAfvnlF40bN05HjhyRs7Oz3n33XX3++edycHCQdL+NerNmzXTkyBHt2rXLnMsXX3whW1tbJScna/z48Vq/fr0uX76s/Pnz68MPP1Tz5s3NeZw9e1YLFiwwf99jxozRgQMHdO/ePfn5+al37956/fXXzd93qVKldP36dW3ZskUpKSmqVq2aBgwY8FIVzAIAAAAAAAAAAAAAAABprKytjE4BLylOwnwBrFixQvb29qpUqZLee+892dnZacmSJRZrwsPDFRgYqCVLlqhJkybq27evJGnXrl0ymUz6/vvv9dlnn+n999/X+vXrNXDgQG3atEk9e/a02GfZsmWaPHmyvvrqKxUuXNhibt68eZoxY4Z69uypzZs3a+rUqTp58qRGjRr1zJ85ICBAmzdv1t27d81ja9as0bvvvitnZ2dJ0pYtW3Tu3DktWbJEw4YN0+rVqzV8+HBJ0u3bt9W6dWslJydr4cKFWrBggXLnzq2mTZvqwoUL5j23bt2q8uXLa+XKlapbt665Lfg333yj2rVrKzIyUm3atJGfn5/Wrl2rsWPH6ujRowoKCrI4NTM0NFRvvfWWVq1apa5du2r+/Plav369JGnx4sX69ttvNWHCBG3evFmtWrXSoEGDtG/fvnTPffbsWX3wwQeys7PTvHnzNGfOHF2+fFmtWrVSfHy8ed2CBQuUJ08effPNNxo2bJg2btyouXPnPrsvAAAAAAAAAAAAAAAAAADwWBRh/svdu3dP69at07vvvqvs2bPL0dFRlStX1po1a3Tnzh3zuhIlSqhevXoqVqyYXn31VTk6OkqSXF1dZWdnp+nTp6tJkyZq3ry5ChQooAoVKmjw4MH69ttvdebMGfM+DRo0UOnSpeXt7Z0ulwIFCmjUqFHy9/dXvnz55Ovrq1q1aikqKuqJnmngwIEymUzprnPnzpnX1K9fX0lJSdq2bZskKT4+Xtu2bVNAQIB5jZOTk8aMGSMPDw9VrVpVn332mVauXKn4+Hht2LBBV69e1bhx41S8eHF5eHho+PDhcnBw0PLlyy32aN++vQoVKqR8+fLJyclJ0v027NmyZVNYWJjKlSunzp07y93dXT4+Pho3bpwOHTqkvXv3mvepWLGiAgMD5e7urlatWql48eL65ZdfJEmxsbGyt7eXm5ub8uXLp1atWmnOnDkqVKhQunezePFi2dvba+zYsSpevLi8vLw0efJkXb58WWvXrjWvK1KkiIKDg1WoUCHVrl1blSpVMscDAAAAAAAAAAAAAAAAADwftCP/l9uxY4cuXryo2rVrm8dq166trVu3asOGDWrSpIkkqWDBgn+7z7Fjx3T48GGtWrXKPJZ2kmNMTIzy58//2H38/f116NAhTZ48WadPn1ZMTIyOHz+uV1999Yme6dNPP1X16tXTjbdu3dr8d65cueTv76/Vq1erbt262rRpkxwdHVWxYkXzmtKlSyt79uzmzyaTSUlJSTp58qSOHTum+Ph4vf322xYxEhISFBMTY/6ckfd2+vRpmUymdHMxMTHy9fWVJHNr+DSOjo5KSkqSJLVs2VLbtm1TpUqVVKpUKfn5+alWrVpycXFJt2d0dLRKlSplbqkuSS4uLipUqJBFsevD4t24ceNvnwUAAAAAAAAAAAAAAAAA8GxRhPkvFx4eLul+4eJfLV261FyEmS1btr/dJyUlRe3bt1ejRo3Szbm6upr//rt9Zs6cqdDQUAUEBOjtt99W69atFRERoQ0bNmToWdK4uLg8tPjR1tby59i4cWN16tRJly5d0tq1a1W/fn2LNVmyZLFYn5KSIkmysbFRSkqKChUqpGnTpqWLY29vb/47I++tXr166tSpU7q5tLbokiyKJtOkFbm6u7try5Yt2rt3r3744QdFRERo+vTpGjlyZLrvIzU1VVZWVun2Sk5Otnjeh8UDAAAAAAAAAAAAAAAAADxftCP/F7ty5Yp27NihgIAArV692uJq0qSJjhw5oqNHjz703r8W8hUrVkwnTpxQwYIFzdeFCxc0evRo3bp1K0P5TJs2TV26dNGgQYP0wQcfyNvbW6dOnTIXGz5rFSpUkKurq7755hvt37/fohW5JB09elTJycnmzwcOHFD27NlVqFAheXh46Ny5c3J0dDQ/b758+TRu3Dj9/PPPj4z5sPd2/Phxi/eWnJyskSNH6vz58xl6jvnz52vLli3y8/PTF198oXXr1qlcuXLauHFjurUeHh46fPiwEhMTzWOXLl3S6dOn051+CQAAAAAAAAAAAAAAAAAwFkWY/2Jr1qzRvXv31L59e3l4eFhcnTp1ko2NjZYsWfLQe9NOe/z111919+5ddejQQVu2bFFoaKhOnjyp3bt3q0+fPrpx44bFSZh/57XXXtMPP/yg33//XSdOnNCECRO0ZcsWi4LBZ8na2loNGzbU9OnTVapUKRUtWtRi/uzZsxo0aJBiYmK0detWTZ48Wa1atVL27NlVv359OTk5qUuXLjp48KBiYmLUp08f7dixQ8WKFXtkzLT3FhkZqVu3bikoKEi//fabBgwYoN9//12HDh1Sjx49dPLkSbm7u2foOS5fvqwhQ4YoIiJCZ8+e1ffff69jx449tMV58+bNFR8frx49eigyMlKHDx/WZ599pty5c6tOnToZf3kAAAAAAAAAAAAAAAAAgH8cRZj/YuHh4SpfvvxDT0B0c3NTtWrVtGHDBsXHx6ebf+edd1SmTBk1a9ZM//vf/1SzZk1NmDBBERERqlevnnr06KFy5cppypQpGc5n9OjRunv3rho3bqxWrVopOjpagwcP1uXLl3XmzJmnetZHCQgI0N27d9OdgilJ3t7esrKyUuPGjTV06FAFBgYqODhYkuTo6KiFCxfKxcVF7du3V5MmTXT27FmFhYX9bRGmh4eHKleurG7dumnZsmXy9vbWrFmzFB0drYCAAH300Udyc3PTnDlzMtwSvEuXLmrSpImGDh2qGjVqaODAgWrRooU6duyYbq2bm5sWLFigGzdu6IMPPlC7du3k6uqqJUuWKGfOnBl8awAAAAAAAAAAAAAAAACA58Eq9Z/qJQ08Az///LM6dOignTt3ytHR0Tzeu3dvnT17VgsWLDAwu/+O43/eNCRugRyGhJUkpdhkMSy2zZ1rhsS1uvfPnFr7b2aVeMuw2BfsCxgSN5utlSFxJWnriauGxK3insuQuJLkeu13w2LbFCxjWGwAAAAAAAAAAAAA+LfxHbLV6BQgac+Aakan8NzZGp0A8DAxMTGKjo7W9OnT1ahRI4sCTAAAAAAAAAAAAAAAAAAA/g1oR45/pVOnTqlPnz5ycnJS9+7djU4HAAAAAAAAAAAAAAAAAIB0OAkT/0pVq1bVwYMHHzk/atSo55cMAAAAAAAAAAAAAAAAAAAPwUmYAAAAAAAAAAAAAAAAAAAAmUARJgAAAAAAAAAAAAAAAAAAQCZQhAkAAAAAAAAAAAAAAAAAAJAJtkYnAAAAAAAAAAAAAAAAAADA07CytjI6BbykOAkTAAAAAAAAAAAAAAAAAAAgEyjCBAAAAAAAAAAAAAAAAAAAyATakQPQKzkM+p+ClARj4kpKtc5iXGzbbMbEzZLdkLj3g6caEtYm6Y4hcSXplcQ/DYmbnC2vIXElyetVR0PiJqcYElaSdNvVw7DYkbFXDYn7VoHchsQFAAAAAAAAAAAAAODfiJMwAQAAAAAAAAAAAAAAAAAAMoEiTAAAAAAAAAAAAAAAAAAAgEygCBMAAAAAAAAAAAAAAAAAACATKMIEAAAAAAAAAAAAAAAAAADIBFujEwAAAAAAAAAAAAAAAAAA4GlYWVsZnQJeUpyECQAAAAAAAAAAAAAAAAAAkAkUYQIAAAAAAAAAAAAAAAAAAGQCRZgAAAAAAAAAAAAAAAAAAACZ8FIWYd67d0/z5s1TQECATCaTfH191bZtW+3evdtinaenp8LDw597fuHh4fL09Mz0/f7+/vL09LS4vLy8VKNGDU2ZMkUpKSnPMNvHCw0Nlb+//yPnn/Z5M+P69etq166dSpcurYoVKyoxMVGff/65vL295ePjo40bN8rT01Nnzpx57F579uzJ8FoAAAAAAAAAAAAAAAAAwH+HrdEJPG+JiYlq27atzp8/r65du8pkMunu3btauXKlgoKCNHLkSDVs2NDQHGvXrq2KFSs+1R5BQUEKCgoyf75x44Y2bdqk0NBQZc+eXe3atXvaNF9oq1ev1p49e7Rw4UK9+uqr+v7777V+/XpNnTpVnp6eeuWVV7Rr1y45Ozs/di+TyZThtQAAAAAAAAAAAAAAAACA/46Xrghz8uTJioyM1IYNG5Q3b17zeL9+/XT79m2NGDFC1apVU44cOQzLMVu2bMqWLdtT7WFvby9XV1fzZ1dXV3Xp0kV79+7Vhg0bXvoizJs3b8rV1VXe3t6SpJ9++knS/VNEraysJMni/f0dOzu7DK8FAAAAAAAAAAAAAAAAAPx3vFTtyJOSkvTNN9+oSZMmFgWYaT777DPNmjXLogDy5MmTatu2rby8vFShQgXNmDHDPBcaGqpmzZopODhYb775pgYPHixJOnDggAIDA1W2bFn5+vqqb9++un79uvk+f39/ff311+aTOH19fTVixAjdu3dPUvr23Ldv39awYcNUoUIFmUwmtWzZUocPH87UO8iaNausrf/va79586b69++vd955R2XLllVgYKCOHDli8YytW7fWzJkzValSJZUuXVqBgYE6ceKEec3x48fVuXNn+fr6qlSpUqpWrZrmzZuXqfwkqXfv3urZs6dCQkJUrlw5lSlTRp07d9bFixfNa1avXq06deqY24kPHz5ciYmJkh7e3vzBluG9e/dWaGiozp07J09PT4WGhqp3796SpOLFi6t3797pWozfu3fP3Fa9TJkyCggI0Pfff59ub+n+aatjxoxRxYoVZTKZ1LRpU+3atcucS3h4uPz9/bVq1SpVq1ZNpUqVUuPGjXXgwAHzmr+L17BhQ/Xp08fi+b7//nuVKlVKV65cyfR7BwAAAAAAAAAAAAAAAAA8mZeqCDMuLk7Xrl0zn374V6+88oq8vLxkY2NjHlu4cKEaNGigDRs2qEWLFho/frx2795tnj9w4IBcXFy0Zs0affjhhzp8+LBat26tokWLatmyZZo8ebIOHz6soKAgpaSkmO8LDQ3VW2+9pVWrVqlr166aP3++1q9f/9C8unfvrv/9738aMWKEVq9erUKFCqldu3ZPVHCXmJio1atX64cfflCDBg0kSampqerQoYNOnTqlGTNmaPny5fL29lbz5s117Ngxi2f8+eef9fXXX2vu3Lk6d+6cueD0zp07atu2rezt7bV48WJt2LBBtWrV0ogRI/Tbb79lOL+/2rRpk65du6aFCxdqypQp2r9/vyZMmCBJioyM1JdffqmuXbtq8+bNGjFihNasWaNZs2ZlaO9+/fopKChIefPm1a5duxQUFKS+fftKknbt2qV+/fqlu2fEiBFatGiRevTooXXr1qly5crq3Lmzfv/993Rr+/Tpo507d2rMmDFatWqVatWqpU6dOmn79u3mNX/++aeWLl2qMWPGaNmyZbK2tlavXr2Umpr62HgBAQHavHmz7t69a95vzZo1evfdd2mJDgAAAAAAAAAAAAAAgJeStbUV17/gehm9VO3I006jdHJyyvA9zZs3V8OGDSVJnTt31uzZs/Xrr7+qXLly5jWffvqpHB0dJUndunWTp6enBgwYIEkqWrSoxo0bp/r162vnzp2qXLmyJKlixYoKDAyUJLm7u2vFihX65ZdfzLHSnDx5Utu3b9esWbNUsWJFSdKAAQOUI0cOXbt27ZFFdzNmzNDs2bPNn+/cuaNChQqpX79+atGihaT7LbgPHDig3bt3m/cJDg7WL7/8ovnz52vUqFGS7p/KOHr0aOXKlUuS1Lp1a40ZM8a8b2BgoFq0aCEHBwdJUpcuXTRjxgxFRUWpRIkSGX7XD3JwcNCQIUOUJUsWFSlSRA0aNNCOHTskSWfOnJGVlZXy58+v119/Xa+//rrCwsLM8R/H0dFR9vb2srGxMbcRT/v+HtZWPD4+XsuXL9eXX36p2rVrS7p/ampKSopu3bplsfb06dNav369VqxYodKlS0uS2rZtq8jISIWFhalKlSqS7p/KOmjQIPP76dixoz755BNdvHhR9vb2fxuvfv36GjNmjLZt26a6desqPj5e27Zt08SJE5/gDQMAAAAAAAAAAAAAAAAAntZLVYSZVmh47dq1DN9TqFAhi885c+ZUQkKC+bOLi4u5gE+SoqOj5efnZ3GPp6encubMqaioKHMRZpEiRSzWODo6KikpKV38qKgoSbI4vdPOzi5dO+q/atasmVq3bq179+7pxx9/1IQJE1SzZk21bNnSvObo0aOSpKpVq1rcm5iYaPGMefLkMRdg/jVXZ2dntWjRQhs3blRkZKROnz5tPgHzwZM/n1TBggWVJUuWh8ZMa/PduHFjubu7q3z58qpatapKlSqV6Xh/5+TJk0pKSkp3gmr37t0l3W9HnibtBNG0Ats0SUlJypkzp8XYg7+BtN9QUlLSY+NJ91var169WnXr1tWmTZvk6OhoLtIFAAAAAAAAAAAAAAAAADwfL1URppubm/LkyaMDBw6YTxh80KlTpzRkyBD16tVLnp6ekmTRmjxNWstoScqWLVu6OSur9MeqpqSkWBQV2tnZ/e2+aWxt739FD9vz7zg5OalgwYKS7hf7OTo6qlevXrK3t1eHDh3MOTk4OCg8PDzd/Q/m97Bc01y6dElNmzZV7ty5VbVqVZUrV06lS5c2F5tm1t/FzJo1q+bPn69jx45p165d2rVrl5YuXaqGDRtq5MiR5nUPfhf37t3LdC4Pfm+Pk/YdLlq0SDly5LCYs7a2tvj8qN9ARuI1btxYnTp10qVLl7R27VrVr1/f/FsBAAAAAAAAAAAAAAAAADwf1o9f8t9hbW2tJk2aKDw8XBcuXEg3P2vWLB08eFD58uXLdAwPDw/t27fPYiwyMlLx8fHpTr/MiLR7jhw5Yh67d++eqlSpog0bNmR4n4YNG6pmzZqaNGmS+XRNDw8PxcfHKzExUQULFjRfM2fOVERERIb2Xbduna5du6alS5eqc+fOqlatmrnt+8OKSp+FHTt2aMqUKXrjjTf00Ucfaf78+fr000+1ceNGSf9XNHnz5k3zPadPn850vLRTOR/8DiSpSZMmmjVrlsVYsWLFJEl//vmnxTsNDw/XypUrn1m8ChUqyNXVVd98843279+vgICAzD4eAAAAAAAAAAAAAAAAACCTXqoiTEnq1KmTChYsqGbNmmn16tWKjY3VkSNH1K9fP61cuVJDhw6Vg4NDpvdv06aNIiMjNWTIEMXExGjv3r3q0aOH3njjDZUrV+6J9ytUqJCqV6+uwYMHa/fu3Tp58qQGDBigxMTEJ95vwIABypEjh/r166eUlBRVrFhRJUqUULdu3bR7926dPn1aISEhWrlyZYYLRvPmzas7d+5o06ZNOnfunHbt2qXg4GBJ99ua/xNsbW311Vdfae7cuYqLi9ORI0f0v//9TyaTSdL91u3W1taaOHGi4uLitH37ds2ePTvT8bJnz65WrVpp0qRJioiIUGxsrCZMmKDff/9d7777rsXaYsWK6d1339XAgQMVERGhuLg4hYWFacaMGXJzc3tm8aytrdWwYUNNnz5dpUqVUtGiRTP9fAAAAAAAAAAAAAAAAACAzHnp+hdnz55dCxcu1OzZszVz5kydO3dOWbNmVcmSJTVv3jy9/fbbT7W/yWTSzJkzNWnSJDVs2FAODg5677339Pnnnz9RW+sHjRw5UqNHj1b37t2VkJCgMmXKaPbs2XJ2dn6ifVxcXNSnTx/16tVL8+fPV5s2bTR79myNGTNG3bt31507d1SkSBGFhoZmuMCzZs2aOnr0qEJCQhQfH698+fLp/fffV0REhA4fPqzmzZtn5pH/lp+fn4YPH67Zs2drwoQJypYtmypXrqzevXtLut92fsiQIZo+fbqWL1+ukiVLqm/fvvr4448zHTM4OFi2trYaNGiQbty4IU9PT3399dcqUqSILl26ZLF2woQJmjBhggYOHKjr16/Lzc1NQ4cOVePGjZ9JvDQBAQGaPn06p2ACAAAAAAAAAAAAAAAAgEGsUv+pntEA/lE///yzOnTooJ07d8rR0fGp9rp+684zyurJZEtJMCSuJCXbZjMsts29u8YEtrIyJq4kGfSvGpubFwyJK0mpNnaGxE3OmdeQuJJ04nqSIXGdstoYEleScmY17lDxyEvG/G/JWwVyGxIXAAAAAAAAAAAAAP5OhZD/GZ0CJO3q9e7jF/3HvHQnYQIvupiYGEVHR2v69Olq1KjRUxdgAgAAAAAAAAAAAAAAAAAyx7jjmwBkyqlTp9SnTx85OTmpe/fuRqcDAAAAAAAAAAAAAAAAAC8tTsIEXjBVq1bVwYMHjU4DAAAAAAAAAAAAAAAAAF56nIQJAAAAAAAAAAAAAAAAAACQCRRhAgAAAAAAAAAAAAAAAAAAZAJFmAAAAAAAAAAAAAAAAAAAAJlAESYAAAAAAAAAAAAAAAAAAEAm2BqdAAAAAAAAAAAAAAAAAAAAT8OK4whhEH56AAAAAAAAAAAAAAAAAAAAmUARJgAAAAAAAAAAAAAAAAAAQCbQjhyAHP84YkjcpFc8DIkrSWdvJhkW280hiyFxo6/dMySuJJ2/mWhIXN98bobElaSLt5MNiZti4G+7mNVlQ+KmWjsaEleSUpON+08p76zXDImbeN2Y37Yk2TnlMSw2AAAAAAAAAAAAAAAPw0mYAAAAAAAAAAAAAAAAAAAAmUARJgAAAAAAAAAAAAAAAAAAQCZQhAkAAAAAAAAAAAAAAAAAAJAJFGECAAAAAAAAAAAAAAAAAABkgq3RCQAAAAAAAAAAAAAAAAAA8DSsra2MTgEvKU7CBAAAAAAAAAAAAAAAAAAAyASKMAEAAAAAAAAAAAAAAAAAADKBIkwAAAAAAAAAAAAAAAAAAIBMMKwIs3Xr1urdu/dD53r37q3WrVs/54yeDU9PT4WHhxudxnNx5swZeXp6as+ePRm+Z+fOnXrvvfdUqlQphYSE/O3v4K+eZO3z1qdPH73zzjtKSkp66PzXX38tk8mk+Ph4+fv7KzQ09DlnCAAAAAAAAAAAAAAAAAB41myNTgAvl3HjxsnNzU1z585Vjhw5ZGVlJRsbmwzdGxoamuG1z1vjxo0VHh6uH374QVWqVEk3v2bNGtWsWVMODg5asWKFsmbN+vyTBAAAAAAAAAAAAAAAAAA8U7Qjx3N148YNmUwm5c+fX7lz51auXLnk6OiYoXufZO3z5uPjo0KFCmndunXp5g4fPqzff/9d77//viTJ2dlZOXLkeN4pAgAAAAAAAAAAAAAAAACesReiCPNhLb4fbOkcHh6uatWqaePGjfL395eXl5fatWunCxcuaPjw4XrrrbdUvnx5zZgxw3x/YmKixo0bZ26N7evrq+DgYF29elXS/7Xa3rRpk95//32VLl1aVatW1YoVKzKc9549e/TGG2/op59+Uu3atVW6dGl98MEHOnnypKZNm6by5cvr7bff1tChQ5Wamirp/mmPbdq00fz581WhQgV5e3srODhYFy9e1BdffCGTyaTKlStr1apV5jgPa9P9YEv3jD7L6tWrVb9+fXl5ecnf31/Tp09XSkqKeT46OlqBgYHy9vZWjRo19NNPP6V75pUrV6pWrVry8vJSrVq1NG/ePPMenp6eOnv2rL766it5enrqzJkz6XL/9ddf1bZtW5lMJpUvX14DBgzQ7du3H/qcv/zyi1q2bCkvLy9VqVJFgwcPVnx8vHne399fX3/9tbp27SqTySRfX1+NGDFC9+7de2y8bdu2qXjx4jp79qzF8zVt2lQjR4586PfduHFjRURE6NatWxbja9asUZEiRfTmm2+a80r77YaGhqpZs2YKDg7Wm2++qcGDBys8PFyenp4We+zZs8f8ziTp1KlTateuncqWLSuTyaR27dopKirqoXkBAAAAAAAAAAAAAAAA/3VW1lZc/4LrZfRCFGFmxPnz57VkyRJNnTpVc+bM0ZEjR1S/fn3Z2tpq+fLlatasmcaPH6/o6GhJ0ujRo7V+/XoNHz5cmzdvVkhIiH744QdNmzbNYt9Ro0apU6dOWr16tcqVK6f+/fsrLi4uw3klJydr1KhRGjFihJYvX67Lly+rWbNmiomJ0YIFCxQcHKyFCxdq+/bt5nv27dunffv2ad68eZo4caI2b96sunXrqkSJElq5cqUqVaqkAQMGmAtGM+rvnmXu3Lnq37+/PvjgA61du1bdu3dXWFiYRo8eLUm6efOm2rRpIwcHB33zzTcaMGCApk6darH/smXLFBISok8++UQbNmxQt27dNHPmTI0dO1aStGvXLuXNm1dBQUHatWuXXnvtNYv704oynZ2dtWzZMk2ZMkV79uzRgAED0j1LZGSk2rRpIz8/P61du1Zjx47V0aNHFRQUZC5ole4XOb711ltatWqVunbtqvnz52v9+vWPjVelShW5uLhozZo15r1OnjypQ4cOqVGjRg99v40aNVJSUpK2bdtmHktKStKGDRvUpEmTR34vBw4cMMf68MMPH7nuQcHBwXrllVe0cuVKffPNN7K2tlaXLl0ydC8AAAAAAAAAAAAAAAAA4NkwtAhz3bp1MplM6a6HtXR+nKSkJPXv31/FixdX2bJlVa5cOWXLlk1ffPGFChUqpI4dO0qSjh8/LkkqXbq0QkJC5Ovrq3z58qlKlSqqUKFCutME27Ztq6pVq6pIkSLq1auXUlJSdOjQoSfK7bPPPpO3t7dKlCih6tWr69atWxo6dKiKFCmiZs2aKU+ePOa8JCklJUXDhg1TkSJFVKVKFZUoUUKFCxdW27ZtVbhwYbVp00aJiYk6ffr0E+XxqGdJTU3VzJkz1apVK7Vs2VLu7u6qV6+ePv30Uy1cuFA3b97Uhg0bdOfOHYWEhKhYsWLy8/NT3759LfafOnWqOnbsqLp168rNzU01atRQ9+7dtXDhQiUkJMjV1VU2Njayt7c3//2g5cuXy8nJSaNGjZKHh4fefPNNDRs2TIUKFUr3LGFhYSpXrpw6d+4sd3d3+fj4aNy4cTp06JD27t1rXlexYkUFBgbK3d1drVq1UvHixfXLL788Np6tra3q169vUYS5evVqlSxZUsWLF3/o+82TJ48qV65s8fvdsWOH4uPj1bBhw7/9bj799FO5ubnJ3d39b9eliY2NVZ48eZQ/f34VLVpUI0aM0LBhwyxOLgUAAAAAAAAAAAAAAAAA/LNsjQzu7++vHj16pBsfO3asrl279sT7PVislz17duXPn19WVvePOM2aNaskKSEhQZLUoEED7d69W+PHj9epU6cUExOjEydOyMfHx2LPIkWKmP92dHSUdL/g82nyypMnj7Jnz24ey5o1qzkvSXJxcVHOnDkt7nnw1Mi/PktGPepZrly5okuXLqls2bIW69966y0lJSXpxIkTio6Olru7u/k+STKZTOa/r1y5oj/++EOTJk3SlClTzOMpKSlKSEjQmTNnLOI/TFRUlEqWLKksWbJY5PDWW2+lW3vs2DGdPn3aIoc0MTEx8vX1TffMac+d9v09Ll7jxo01e/ZsHTp0SF5eXlq7dq3at2//t8/QpEkTdenSRZcvX5aLi4tWrVolf39/OTs7P/IeFxcXi/eaEd27d9eIESO0ZMkSvfPOO6pYsaJq1aola+v/zOG2AAAAAAAAAAAAAAAAAPCvZ2gRZo4cOVSwYMGHjv+1CPPBFtPSwwshHyymk/S3BWmDBg3Sxo0b1bBhQ1WpUkUff/yxwsLCdOHCBYt1dnZ26e79ay6PY2tr+ZofVyj31+fIyD0ZeT+PepZHPU9ycrKk/8v/r+sefK60Exj79Omj8uXLp9vrr63HH8bW1tZcNPs4KSkpqlevnjp16pRu7sGCx7/7/h4Xr2jRoipTpozWrl2ru3fv6tKlS6pTp87f5lW5cmU5Oztrw4YNql+/vnbs2JGubftfZcuW7aHjqamp5vzu3btnMdeyZUvVrFlTO3bsMBcTh4aGavXq1cqTJ8/fxgMAAAAAAAAAAAAAAAAAPBsvxLF5WbJk0c2bN82f4+PjdeXKlUzvd/XqVS1ZskSDBg1S3759FRAQoBIlSujEiRNPXGD5b/DX9yPdb1edUS4uLnJxcdH+/fstxvft26csWbKoQIECKlGihE6ePGnx3o8cOZJuj9jYWBUsWNB8HT16VBMnTsxQHkWLFtWxY8fMxZ+StHXrVlWqVEl37tyxWFusWDEdP37cIlZycrJGjhyp8+fPP7N4jRs31pYtW7RlyxZVrVpVuXLl+ts9bWxs1KhRI3377bf69ttvlSdPHlWoUCFD+aRJK8J98Dt9sPX8pUuXNGTIECUlJSkgIEBjxozR2rVrdfHiRYtW7AAAAAAAAAAAAAAAAACAf9YLUYRpMpm0bNkyHT16VNHR0friiy/SnS75JBwdHeXo6KiIiAidPn1aUVFR6t+/v44eParExMRnmPnz8eabb+rHH3/Ud999p7i4OE2ePFnR0dEZvt/KykpBQUFauHChFi1apNOnT2vdunWaMmWKPvjgAzk6OqpOnTpycXHR559/rsjISO3du1cjRoyw2KN9+/ZasGCBFixYoNjYWG3btk2DBw+WnZ3dQ0+k/KsWLVro6tWrGjhwoGJiYrRv3z6NHTtWfn5+Fu3bJSkoKEi//fabBgwYoN9//12HDh1Sjx49dPLkSbm7u2fouTMSr06dOrp586ZWrFihgICADO3buHFjHTx4UMuWLVNAQMATtwj39vaWtbW1Jk6cqLi4OG3fvl2zZ882z+fKlUvbt2/Xl19+qd9++01xcXFavHixsmTJolKlSj1RLAAAAAAAAAAAAAAAAABA5r0QRZiDBg2Sq6urmjVrpg4dOujtt9+WyWTK9H62traaNGmSoqOjVa9ePbVv31537txRcHCwjh8/rtu3bz/D7P95bdq0UY0aNdSzZ081atRIly5dUps2bZ5oj/bt26tnz56aN2+e6tSpo0mTJqlDhw7q27evJMne3l7z589XlixZ1Lx5c33xxRfq0KGDxR5BQUHq06ePFi1apNq1a2vo0KEKCAjQ0KFDM5TDq6++qtmzZ+vkyZNq1KiRunXrpsqVK2vgwIHp1np7e2vWrFmKjo5WQECAPvroI7m5uWnOnDkZKvjMaDwHBwe99957cnJykp+fX4b2dXd315tvvqnffvtNjRs3ztA9D3Jzc9OQIUO0Y8cO1apVS9OmTTN/D9L93+/MmTNlbW2tNm3aqE6dOvrpp5/09ddfq0CBAk8cDwAAAAAAAAAAAAAAAACQOVapL2L/beA5CgwMlMlkUvfu3Y1O5R+TEmNMG/OkVzwMiStJsXdsDIvt5mBM/Xv0tXuGxJWk8zcTDInrm8/BkLiSdPF2siFxU2Tcv9YLp142JG5qNkdD4kpSqnXmT+Z+Wta3rxoS18j3beeUx7DYAAAAAAAAAAAAAP7d3p34vdEpQNL/ulUyOoXnzrjKAeBfbtu2bfrtt9904MABhYSEGJ0OAAAAAAAAAAAAAAAAAOBfhiJM4BFmzpypU6dOaejQoXrttdeMTgcAAAAAAAAAAAAAAAAA8C9DESbwCMuWLTM6BQAAAAAAAAAAAAAAAADAv5i10QkAAAAAAAAAAAAAAAAAAAC8iCjCBAAAAAAAAAAAAAAAAAAAyASKMAEAAAAAAAAAAAAAAAAAADKBIkwAAAAAAAAAAAAAAAAAAIBMsDU6AQAAAAAAAAAAAAAAAAAAnoa1tZXRKeAlxUmYAAAAAAAAAAAAAAAAAAAAmcBJmAB09ZVShsR1TI43JK4kuVvdNSx2SoqTIXE9ctsZEleSiudIMiRuqoyJK0kFbW8ZEjfZ3tmQuJJ0Jj6PIXHPX000JK4k+eS+Z1jsm/avGhLXzsa4//dY6s1rhsTN6pjLkLgAAAAAAAAAAAAAgH8/TsIEAAAAAAAAAAAAAAAAAADIBIowAQAAAAAAAAAAAAAAAAAAMoEiTAAAAAAAAAAAAAAAAAAAgEygCBMAAAAAAAAAAAAAAAAAACATbI1OAAAAAAAAAAAAAAAAAACAp2FlbWV0CnhJcRImAAAAAAAAAAAAAAAAAABAJlCECQAAAAAAAAAAAAAAAAAAkAkUYQIAAAAAAAAAAAAAAAAAAGQCRZgAAAAAAAAAAAAAAAAAAACZ8J8swvT391eVKlUUHx+fbq53795q3br1c80nNDRU/v7+z2w/f39/hYaGPrM9wsPD5enpmem9UlNTtWDBAjVo0EBeXl4qW7asWrZsqW+//dZi3blz57Rhw4anyvuvrl69qm+++SbD6/fs2SNPT0+dOXPmmeaRGfv379e+ffskSWfOnJGnp6f27NkjSbp9+7YWLVpkXmvE7xYAAAAAAAAAAAAAAAAA8Pf+k0WYknT+/HmNGjXK6DReCLVr19auXbsyff/kyZM1ffp0ffTRR1q/fr2WLl2qcuXKqVu3blq1apV5Xa9evbRz585nkbLZ6NGjtXbt2me65/PSokULxcbGSpJee+017dq1SyaTSZI0e/ZshYWFmdf269fvqQtvAQAAAAAAAAAAAAAAAADPlq3RCfxT3Nzc9M0336hGjRqqWLGi0en8q2XLlk3ZsmXL9P2LFy9Wp06dVKdOHfNYsWLFdOLECc2fP1+NGjV6Fmk+VGpq6j+29/NkY2MjV1dX8+e/Ppejo+PzTgkAAAAAAAAAAAAAAAAA8Bj/2ZMw69evr3Llyql///4PbUue5tq1axo8eLAqV64sLy8vNW/e3NwiWrrfSrx169aaOXOmKlWqpNKlSyswMFAnTpwwrzl+/Lg6d+4sX19flSpVStWqVdO8efMeGfP27dsaNmyYKlSoIJPJpJYtW+rw4cPm+QMHDigwMFBly5aVr6+v+vbtq+vXr1vscfHiRXXt2lXe3t7y9fXVyJEjlZyc/ER7pPlrO/LH5fdX1tbW+umnn3Tnzh2L8QdPb2zdurX27t2rVatWmVuzJyYmasyYMapYsaJMJpOaNm2a7kTOlStXqmHDhvLy8pK3t7dat26to0ePSrrfonvVqlXau3evOf/k5GTNnTtXNWrUUOnSpVWjRg0tX748Xc47duxQvXr1VKpUKdWpU0fbt283z6WmpmrmzJmqWrWqypQpowYNGlictpnW0jwiIkLVq1eXt7e32rRpo5iYGPOaGzduaODAgapcubJKliwpPz8/DRw4UHfv3pUkc759+vRR7969LdqRh4aGasqUKTp79qy5dfpf25GHhYXpvffeU6lSpeTv76+vvvrqP1OQCgAAAAAAAAAAAAAAADwpG2srrn/B9TL6zxZhWllZafjw4bpx44ZGjhz50DXJyckKCgrSvn37FBISolWrVql48eJq06aNjhw5Yl534MAB/fzzz/r66681d+5cnTt3ToMHD5Yk3blzR23btpW9vb0WL16sDRs2qFatWhoxYoR+++23h8bt3r27/ve//2nEiBFavXq1ChUqpHbt2unKlSs6fPiwWrduraJFi2rZsmWaPHmyDh8+rKCgIKWkpJj3WLFihXx8fLRu3Tr17NlTc+fONbf+zugej/J3+T1Mx44dtX37dlWoUEFdu3bV3LlzFRUVJRcXF+XPn1/S/WJWk8mkWrVqacWKFZLuFyDu3LlTY8aM0apVq1SrVi116tTJXBC5detWDRw4UG3atNGmTZs0b9483b17V/369ZN0v8izVq1aMplM5uLNUaNGaerUqerSpYvWrVunwMBADRkyRAsWLLDIef78+fryyy+1bt06ubu7q1u3brp165YkacKECVq8eLF5PjAwUIMGDdKiRYss9hg+fLj69eunZcuWydbWVoGBgbp586ak+63XDx8+rMmTJ2vz5s3q06ePwsPDtWzZMkky59u3b1/z86QJCgpSUFCQ8ubNq127dum1116zmP/uu+80ffp0DR48WFu2bFGPHj00bdq0F7YtOwAAAAAAAAAAAAAAAAC8qP6z7cglKV++fOrZs6cGDRqkmjVrpmtLvmvXLh09elTr1q2Th4eHJGnAgAE6dOiQwsLCNHHiREnSvXv3NHr0aOXKlUvS/VMdx4wZI+l+EWZgYKBatGghBwcHSVKXLl00Y8YMRUVFqUSJEhYxT548qe3bt2vWrFnmfAYMGKAcOXLo2rVrmj17tjw9PTVgwABJUtGiRTVu3DjVr19fO3fuVOXKlSVJ1apV04cffijpfuv1+fPn69dff1WTJk0yvMfDPC4/Z2fndPe0adNGxYoV09KlS/Xjjz9qy5YtkqTSpUtr1KhRKlq0qHLlyqUsWbIoW7ZscnZ21unTp7V+/XqtWLFCpUuXliS1bdtWkZGRCgsLU5UqVZQrVy4NGzZMDRs2NH+f77//vgYOHCjpfovubNmyKUuWLHJ1dVV8fLyWLFmi3r17q169epIkd3d3xcXFafr06WrVqpU55759+8rX11eS9Mknn2jbtm2KiYlR0aJFNXfuXI0ePVrvvvuuJKlAgQI6e/aswsLC1LJlS/MevXv3Nr/LsWPHqkqVKtqwYYOaNWsmPz8/+fj4qHjx4pKk/Pnza+HChYqKipIkc+txR0dHOTo6WpxSmiNHDtnb26drUZ4mNjZWWbNmVf78+fX666/r9ddf1yuvvKLXX3/9kd8rAAAAAAAAAAAAAAAAAODZ+08XYUpSs2bNtHnzZvXv31/r16+3mIuOjpajo6O5AFO6f4Kmj4+Pdu7caR7LkyePuQBTul84l5SUJElydnZWixYttHHjRkVGRur06dPmEzAfdupkWhGet7e3eczOzk59+vQx5+Tn52dxj6enp3LmzKmoqChz0V+hQoUs1jg5OSkhIeGJ9niYx+X3KH5+fvLz81NycrKOHj2q7777TgsXLlT79u21ZcsW2dnZWaw/duyYJCkwMNBiPCkpSTlz5pQkvfXWW3J2dtbUqVN1+vRpnTx5Ur/99tsjT/M8ceKEkpKSVLZsWYtxHx8fzZkzR5cvXzaPPfj+0uLdvXtXv//+uxISEtSrVy+LZ753754SExPN7cQl6e233zb/nStXLrm7uys6OlqS1KJFC3333Xdas2aNYmNjFR0drbi4OLm7u//te8yI+vXra+XKlapevbo8PT3l5+enatWqUYQJAAAAAAAAAAAAAAAAAM/Zf74IM60teb169dK1JU9NTZWVVfo+9CkpKbK1/b9X89cCwgddunRJTZs2Ve7cuVW1alWVK1dOpUuXfmShY9q+D4v7uJyyZMli/mxjY/PQe59kj8zk91eRkZFatmyZ+vTpIzs7O9nY2MjLy0teXl4ymUz66KOPFBUVZT7t8q+5Llq0SDly5LCYs7a2liRt2LBBX3zxherWrSsvLy81adJE0dHRGjJkyENzSdvzr7mnFW0++J2mxfjr/Wl7TJw4UYULF0635sHfwoP7pcWxtrZWamqqOnXqpKioKNWrV081atRQcHCw+vfv/9C8n5Szs7PWrFmjAwcO6IcfftCuXbs0e/Zsde3aVV26dHkmMQAAAAAAAAAAAAAAAAAAj5e+Eu0/KF++fPriiy+0YsUK7du3zzzu6empGzdumE8vTLN//34VLVo0Q3uvW7dO165d09KlS9W5c2dVq1bN3Fo6raDvQUWKFJEkHTlyxDx27949cytrDw8Pixyl+4WO8fHx5nsf52n2eFx+D7N48WJt27Yt3biDg4OsrKzk4uKSbq5YsWKSpD///FMFCxY0X+Hh4Vq5cqUkafr06WrSpIlCQkLUsmVLvfXWW4qLi5P08ILLwoULy9bWNt2z79u3T66urnJycvrbZ39wj3PnzlnktWPHDoWFhVkUbz74jq5cuaLTp0+rZMmSOnbsmHbs2KHJkyerR48eql+/vgoUKKDY2NiH/iYe5u+KYNesWaMlS5aobNmy+vTTT7V8+XK9//772rhxY4b2BgAAAAAAAAAAAAAAAAA8Gy9FEaZ0vy15+fLlzUV80v0W2p6envr888+1Z88excTEaPDgwYqOjtaHH36YoX3z5s2rO3fuaNOmTTp37px27dql4OBgSVJiYmK69YUKFVL16tU1ePBg7d69WydPntSAAQOUmJiocuXKqU2bNoqMjNSQIUMUExOjvXv3qkePHnrjjTdUrly5DOX0NHs8Lr+/Kl68uOrXr69+/fpp5syZ+v3333Xq1Cl9++236tu3rxo1amRuk50jRw6dPXtWf/zxh4oVK6Z3331XAwcOVEREhOLi4hQWFqYZM2bIzc1NkvTaa6/pl19+0dGjRxUbG6u5c+dq4cKFFu/W3t5ef/75p+Li4uTo6KimTZtq8uTJWrdunU6fPq1FixZp8eLFCgoKytDpno6OjmrWrJkmTpyo1atXKy4uTqtWrdKYMWOUJ08ei7WDBw/Wzz//rMjISPXo0UOurq6qWbOm8uTJI1tbW23atElxcXE6cuSIunXrposXL1r8Juzt7RUTE6OrV6+my8Pe3l7Xr1/XyZMnlZSUZDGXkJCgkJAQrV69WmfOnNG+ffu0d+9emUymxz4fAAAAAAAAAAAAAAAAAODZ+c+3I3/QsGHDVK9ePfNnW1tbzZkzRyEhIeratasSExNVsmRJzZ07V97e3hnas2bNmjp69KhCQkIUHx+vfPny6f3331dERIQOHz6s5s2bp7tn5MiRGj16tLp3766EhASVKVNGs2fPlrOzs5ydnTVz5kxNmjRJDRs2lIODg9577z19/vnnj20lnsZkMj3VHn+X36PWlypVSmvWrNG0adOUlJSkAgUK6P3337coZm3WrJl69eql+vXra/fu3ZowYYImTJiggQMH6vr163Jzc9PQoUPVuHFjSVL//v01YMAAtWrVSnZ2dipevLg5r0OHDuntt99Ww4YNtXXrVtWtW1dbt25Vv379lDt3bo0bN06XLl1SwYIFNWDAADVt2jRD706S+vTpI2dnZ02ePFl//vmn8ubNqy5duuijjz6yWPf++++rR48eunHjht555x3Nnz9f2bNnV/bs2TVq1CiFhoZq0aJFcnV1VZUqVdSmTRtFRESY28UHBQVp1qxZOnHihPr162exd/Xq1bV8+XLVr1/fXHiapmnTprp+/bqmTp2q8+fPy8nJSTVq1FCPHj0y/IwAAAAAAAAAAAAAAAAAgKdnlZrR/sgAJEl79uxRYGCgIiIilD9/fqPTeSYu37xtSFzH5HhD4kqSVdJdw2KnZHcyJG6qjZ0hcSXJOvGWIXFTbTJWvP5PsDLomZPtH14w/zz8EZ/0+EX/gPPx6U+efl58chv3n1Hx1vaGxLWzefzJ0v+ULMkJhsTN6pjLkLgAAAAAAAAAAAAAMq729B+NTgGSNnYqb3QKz91L044cAAAAAAAAAAAAAAAAAADgWaIIEwAAAAAAAAAAAAAAAAAAIBNsjU4AeNH4+voqKirK6DQAAAAAAAAAAAAAAAAAAAbjJEwAAAAAAAAAAAAAAAAAAIBMoAgTAAAAAAAAAAAAAAAAAAAgEyjCBAAAAAAAAAAAAAAAAAAAyARboxMAAAAAAAAAAAAAAAAAAOBp2FhbGZ0CXlKchAkAAAAAAAAAAAAAAAAAAJAJFGECAAAAAAAAAAAAAAAAAABkAu3IASj3hcOGxN2bxcOQuJLk7epiWOxs9jkMiXvv7G+GxJWkVBs7Q+Kuu5jdkLiS5FfAyZC4l68mGhJXkorZGxP79TxZDIkrSZfvGfefUq9cijQkbmo2R0PiSpL1neuGxE08fMKQuJJk59fUsNgAAAAAAAAAAAAAgMfjJEwAAAAAAAAAAAAAAAAAAIBMoAgTAAAAAAAAAAAAAAAAAAAgEyjCBAAAAAAAAAAAAAAAAAAAyASKMAEAAAAAAAAAAAAAAAAAADLB1ugEAAAAAAAAAAAAAAAAAAB4GjbWVkangJcUJ2ECAAAAAAAAAAAAAAAAAABkAkWYAAAAAAAAAAAAAAAAAAAAmUARJgAAAAAAAAAAAAAAAAAAQCZQhPkCa926tTw9PR95Xbx48bnkcebMGXl6emrPnj3PJd7T6N27t1q3bv3QuT59+uidd95RUlLSQ+e//vprmUwmxcfHP3HcF+kdAQAAAAAAAAAAAAAAAAAyxtboBPB0atWqpX79+j10zsXF5Tln82Jr3LixwsPD9cMPP6hKlSrp5tesWaOaNWvKwcHhifd+7bXXtGvXLjk5OT2DTAEAAAAAAAAAAAAAAAAA/wYUYb7gsmXLJldXV6PT+E/w8fFRoUKFtG7dunRFmIcPH9bvv/+uoUOHZmpvGxsbvicAAAAAAAAAAAAAAAAA+I+hHflL4PDhw2rRooVMJpPeeustde3aVefOnTPPnz9/Xj169JCfn5+8vb3Vrl07RUVFmed79+6t4OBgjRgxQmXLllW5cuU0atQoJSYmWsQ5dOiQmjZtqlKlSqlq1apauXKleS4xMVHjxo3Te++9p1KlSsnX11fBwcG6evWqeU1sbKw6dOggk8mkChUqaPbs2apWrZrCw8PNa1auXKlatWrJy8tLtWrV0rx585SSkmKe379/v9q2bauyZcuqVKlSqlu3rtavX5/hd9W4cWNFRETo1q1bFuNr1qxRkSJF9Oabb+rGjRsaOHCgKleurJIlS8rPz08DBw7U3bt3JUl79uyRp6enZs6cKV9fXzVq1EixsbHp2pEvWLBANWrUkJeXl2rXrq01a9aY5y5cuKDu3bvLx8dHvr6+6tSpk06dOmWev3z5sj799FP5+vrKy8tLzZo10969ezP8nAAAAAAAAAAAAAAAAACAp0cR5n9cSkqKOnbsqLfeektr167V3Llzde7cOfXt21eSFB8fr+bNm+vChQuaNm2ali5dKnt7e7Vq1cqiUHPLli06d+6clixZomHDhmn16tUaPny4Ray5c+eqU6dO2rhxoypWrKgvv/xSp0+fliSNHj1a69ev1/Dhw7V582aFhITohx9+0LRp0yRJd+7cUZs2bZSSkqIlS5Zo4sSJWrVqleLi4sz7L1u2TCEhIfrkk0+0YcMGdevWTTNnztTYsWMl3S9cDAoKUvHixRUeHq41a9aodOnS6tOnjy5dupSh99WoUSMlJSVp27Zt5rGkpCRt2LBBTZo0kST16tVLhw8f1uTJk7V582b16dNH4eHhWrZsmcVe27dv17JlyzRixAhZW1v+oxYWFqaxY8eqXbt2Wr9+vVq2bKk+ffrohx9+0O3bt9W6dWslJydr4cKFWrBggXLnzq2mTZvqwoULkqRBgwbp7t27WrhwodatW6dChQqpc+fOun37doaeEwAAAAAAAAAAAAAAAPgvsbG24voXXC8j2pG/4NatW6fNmzenG3/33Xc1fvx43bx5U1evXtUrr7yi/Pnzy8rKShMnTtTly5clSWvXrtXVq1cVHh4uZ2dnSdLYsWP13nvvadGiRerZs6ckycnJSWPGjFH27Nnl4eGhP//8U8OHDzfPS9Inn3wif39/SVL37t21ZMkSHT16VAULFlTp0qVVvXp1vf3225KkfPnyqUKFCuYTNzdu3KgrV64oPDxcuXLlMudRv3598/5Tp05Vx44dVbduXUmSm5ub4uPjNXjwYH322WdKTExUly5d1K5dO3PRY8eOHRUeHq5Tp04pT548j32fefLkUeXKlbVu3To1aNBAkrRjxw7Fx8erYcOGkiQ/Pz/5+PioePHikqT8+fNr4cKFFqeHSlJQUJDc3d0lSWfOnLGYmzt3rgIDA9W0aVNJUsuWLXX37l0lJydrw4YNunr1qsaNG6csWbJIkoYPH649e/Zo+fLl6tq1q2JjY+Xh4aECBQooa9as6tevn+rVqycbG5vHPiMAAAAAAAAAAAAAAAAA4NmgCPMF5+/vrx49eqQbt7e3l3S/eLJ9+/YaOnSopkyZovLly6tSpUqqUaOGJCk6Olru7u7mAkxJypo1q7y8vCyKCkuXLq3s2bObP5tMJiUlJenkyZPKnTu3JKlw4cLmeScnJ0lSQkKCJKlBgwbavXu3xo8fr1OnTikmJkYnTpyQj4+PJOnYsWMqVKiQuQBTkjw9PeXo6ChJunLliv744w9NmjRJU6ZMMa9JSUlRQkKCzpw5oyJFiqhx48ZauHChfv/9d506dUq//fabJCk5OTnD77RJkybq0qWLLl++LBcXF61atUr+/v7md9SiRQt99913WrNmjWJjYxUdHa24uDhzwWWav35Oc+XKFf35558qU6aMxXi7du0kSYMHD1Z8fLy5YDVNQkKCYmJiJEldunRRz549tXXrVvn4+KhChQqqXbu2smbNmuHnBAAAAAAAAAAAAAAAAAA8HYowX3A5cuRQwYIF/3ZNjx491KJFC+3YsUO7d+/WoEGDNGPGDK1evVqpqamyskp/DGxycrJsbf/v55F2ImOalJQUSbI4efGvLbclKTU1VdL99tkbN25Uw4YNVaVKFX388ccKCwszt9e2sbEx7/kwaXN9+vRR+fLl082/9tpriomJUfPmzfXGG2/Iz89PVatWVe7cufX+++8/ct+HqVy5spydnbVhwwbVr19fO3bs0NSpU83P06lTJ0VFRalevXqqUaOGgoOD1b9//3T7PKog0s7OTpIe+t7TnrVQoULmVu0PSiuurVatmnbu3KmdO3fqxx9/1KxZszRp0iQtX75cxYoVe6LnBQAAAAAAAAAAAAAAAABkDkWY/3EnTpzQvHnz1LdvXzVv3lzNmzfX/v371aJFC0VGRsrDw0OrV682n/oo3T9x8ddffzW335ako0ePKjk52Vx0eeDAAWXPnl2FChUytzZ/lKtXr2rJkiWaMGGCateubZFbWlFh8eLFtXz5cl27ds18GuaJEyd08+ZNSZKLi4tcXFwUGxur5s2bm/fYuHGjtm7dqpCQEC1ZskQuLi6aO3euef67776T9H/FoBlhY2OjRo0a6dtvv5WdnZ3y5MmjChUqSLp/YueOHTu0fPly80mWSUlJio2NlZubW4b2d3Bw0CuvvKIjR46oatWq5vFPP/1Ur7zyijw8PLRmzRo5OjqaT9+8d++egoODVbNmTb333nsaN26cGjRooNq1a6t27dq6c+eOKlSooO3bt1OECQAAAAAAAAAAAAAAAADPSfqjC/FCuXv3ri5evPjQKyEhQbly5dL69es1YMAAxcTE6OTJk1q5cqWcnJxUuHBh1atXTzlz5lS3bt10+PBhRUZGqmfPnrp9+7Y++OADc5yzZ89q0KBBiomJ0datWzV58mS1atXKokX5ozg6OsrR0VERERE6ffq0oqKi1L9/fx09elSJiYmSpLp16yp37tzq2bOnIiMjdfDgQfXs2VPS/RMjrays1L59ey1YsEALFixQbGystm3bpsGDB8vOzk52dnbKmzev/vjjD+3YsUNnz57Vli1bNGjQIEkyx8moxo0b6+DBg1q2bJkCAgLMp3zmyZNHtra22rRpk+Li4nTkyBF169ZNFy9efKIYH330kebNm6fVq1crNjZWixYtUkREhN577z3Vr19fTk5O6tKliw4ePKiYmBj16dNHO3bsULFixWRnZ6dDhw6pf//+OnjwoM6cOaPw8HDdunVLJpPpiZ4TAAAAAAAAAAAAAAAAAJB5nIT5gtu0aZM2bdr00Lnx48erTp06mjVrlsaNG6emTZsqOTlZ3t7emjNnjhwcHCRJCxcuVEhIiNq0aSNJKlu2rJYsWWJxsqO3t7esrKzUuHFj5cyZU4GBgfr4448zlKOtra0mTZqkUaNGqV69enJycpKvr6+Cg4M1ffp03b59W/b29po1a5aGDBmipk2bysnJSZ06ddKvv/5qboUeFBSkrFmzasGCBQoJCZGLi4sCAgLUvXt3SVJgYKBOnDihL774QomJiXJ3d1dwcLAmT56sw4cPq1KlShl+r+7u7nrzzTe1b98+TZkyxTz+6quvatSoUQoNDdWiRYvk6uqqKlWqqE2bNoqIiMjwiZutWrVSQkKCJk+erIsXL8rd3V0TJkzQO++8I+n+dzJ69Gi1b99eycnJKlGihMLCwsynXE6aNEkjR47Uxx9/rJs3b6pw4cIaN26cfHx8MvyMAAAAAAAAAAAAAAAAAICnY5X6JH2a8VLq3bu3zp49qwULFvxjMc6cOaNTp06Z235L0oULF1SpUiUtWrSI4sJ/WMrvPxkSd28WD0PiSpK3a1bDYmezz2FI3HtnfzMkriSl2tgZEnftxcef1vtP8SvgZEjcy7eTDYkrScXsn+zU4Wcl1SaLIXEl6co94/7/LK9cjTIkbmo2R0PiSpL1neuGxL13/oQhcSXJzq+pYbEBAAAAAAAAAACAF8kHc/canQIkLWvzttEpPHe0I8e/QkJCgj766COFhYUpLi5Ox44dU//+/eXu7q4yZcoYnR4AAAAAAAAAAAAAAAAAAOlQhIl/hSJFimj8+PFat26d6tatq7Zt28re3l5z5swxtyMHAAAAAAAAAAAAAAAAAODfxLgemnhhjBo16rnEqVmzpmrWrPlcYgEAAAAAAAAAAAAAAAAA8LQ4CRMAAAAAAAAAAAAAAAAAACATKMIEAAAAAAAAAAAAAAAAAADIBIowAQAAAAAAAAAAAAAAAAAAMoEiTAAAAAAAAAAAAAAAAAAAgEywNToBAAAAAAAAAAAAAAAAAACeho21ldEp4CXFSZgAAAAAAAAAAAAAAAAAAACZwEmYAHTPtaghcV9NymJIXElKtbYxLPYf128ZEje346uGxJWkuzbZDYnrdDPekLiSlM3GmP+HTXJqqiFxJemObQ5D4mZLvmNIXEnKlS2rYbGtUu4ZE/juTWPiSkp61dOQuLY2xv37qvK47YbE3fF5FUPiAgAAAAAAAAAAAMCLhpMwAQAAAAAAAAAAAAAAAAAAMoEiTAAAAAAAAAAAAAAAAAAAgEygCBMAAAAAAAAAAAAAAAAAACATKMIEAAAAAAAAAAAAAAAAAADIBIowAQAAAAAAAAAAAAAAAAAAMsHW6AQAAAAAAAAAAAAAAAAAAHgaNtZWRqeAlxQnYQIAAAAAAAAAAAAAAAAAAGQCRZgAAAAAAAAAAAAAAAAAAACZQBEmAAAAAAAAAAAAAAAAAABAJlCEiX/EunXr9MEHH8hkMslkMqlx48ZaunRphu8PDw+Xp6fnP5jhi+PMmTPy9PTUnj17jE4FAAAAAAAAAAAAAAAAAPAAW6MTwH/PihUrNGzYMPXt21dvvfWWUlNTtXv3bg0fPlyXLl1Sly5djE4RAAAAAAAAAAAAAAAAAICnRhEmnrnFixerSZMmatq0qXmscOHC+uOPPzR//nyKMAEAAAAAAAAAAAAAAAAA/wm0I8czZ21trV9++UXXr1+3GO/QoYOWLVsmSfL399f06dPVsWNHeXl5qVq1avrmm28euWdiYqLGjBmjihUrymQyqWnTptq1a5d5Pjw8XP7+/lq1apWqVaumUqVKqXHjxjpw4IB5zd27dzVx4kRVrVpVpUuXVsOGDbVt2zaLPapVq6aNGzfK399fXl5eateunS5cuKDhw4frrbfeUvny5TVjxgyL3FauXKlatWrJy8tLtWrV0rx585SSkmKej42NVYcOHWQymVShQgXNnj1b1apVU3h4uPnZxo0bp/fee0+lSpWSr6+vgoODdfXq1XTvITIyUp6envr5558txrt3705xKwAAAAAAAAAAAAAAAAA8ZxRh4pnr0KGDfvvtN1WqVEkfffSRvv76ax0+fFiOjo4qVKiQed1XX32l0qVLa/Xq1WrZsqUGDBigjRs3PnTPPn36aOfOnRozZoxWrVqlWrVqqVOnTtq+fbt5zZ9//qmlS5dqzJgxWrZsmaytrdWrVy+lpqZKkoKDg7V69Wr169dPa9eu1XvvvacuXbooIiLCvMf58+e1ZMkSTZ06VXPmzNGRI0dUv3592draavny5WrWrJnGjx+v6OhoSdKyZcsUEhKiTz75RBs2bFC3bt00c+ZMjR07VpJ0584dtWnTRikpKVqyZIkmTpyoVatWKS4uzhxz9OjRWr9+vYYPH67NmzcrJCREP/zwg6ZNm5buPRQvXlxvvPGGVq9ebR67efOmIiIiFBAQ8ORfFgAAAAAAAAAAAAAAAPAfYGNtzfUvuF5GtCPHM1ejRg0tW7ZMCxYs0K5du7Rjxw5Jkru7u0aMGKGyZctKkvz8/MynNxYuXFiHDh3SvHnzVLt2bYv9Tp8+rfXr12vFihUqXbq0JKlt27aKjIxUWFiYqlSpIklKSkrSoEGDVKJECUlSx44d9cknn+jixYvmQsXp06fr3XfflSR16dJFUVFRmj59uqpWrWreo3///vLw8JAklStXTgcPHtQXX3whKysrdezYUV999ZWOHz8uDw8PTZ06VR07dlTdunUlSW5uboqPj9fgwYP12WefaePGjbpy5YrCw8OVK1cuSdLYsWNVv3598/OVLl1a1atX19tvvy1JypcvnypUqKCoqKiHvt/GjRtr4sSJGjBggLJmzapNmzbJ0dFRlSpVyuQ3BgAAAAAAAAAAAAAAAADIDIow8Y/w8vLSmDFjlJqaqujoaO3YsUPz589Xhw4dtHXrVkmSr6+vxT3e3t4WJ1umOXbsmCQpMDDQYjwpKUk5c+a0GCtSpIj5b0dHR/O6tILGtALQND4+Pho3bpzF2IOndWbPnl358+eXlZWVJClr1qySpISEBF25ckV//PGHJk2apClT/h979x7X8/3/f/zemZQoIcccYxNFltNEmJWzPswpH4thFh+MzWmOmzNFZpHM+bQJ0ZgtY9jG2oaNyYSIyTCniVL9/vDz/novJml7bXO7Xi7vy+X9fh2e98fr9XqHXfbo+ZxnOicrK0u3b99WSkqKjhw5ogoVKpgaMCXJw8PDVJsktWvXTl9++aVmz56tU6dOKSkpSSdOnJCPj0+OeyFJbdq00bRp0xQfH6/AwEBt2LDBNFsnAAAAAAAAAAAAAAAAAOCvQ9cW8tX58+cVFRWlvn37qkSJErKwsJCHh4c8PDzUrFkzBQYG6uuvv5akHE2D2dnZsnzAlLT3lhNfuXKlChUqZLbv98fb2to+9PwHycrKylGHjY3NH2bcf650d6n0Bg0a5Njv5uYmKysr03EPM378eH300Udq3769mjRpoldffVXR0dFKTU194PFOTk5q3ry5YmNj5enpqe+++04TJ078wwwAAAAAAAAAAAAAAAAAQP57Ohdhx5/G1tZWa9euVWxsbI59Dg4OkqRixYpJkr7//nuz/d9++62eeeaZHOdVqVJFknThwgWVL1/e9IqJidH69etzVde95cW/+eYbs+0JCQmqXLlyrsb4PRcXF7m4uOj06dNmdR0+fFjh4eGSpGrVqik5OVlXrlwxnXfixAldv35dkvTrr79q9erVGj9+vEaNGqWOHTuqevXqOnHixB82jwYFBWnv3r3atGmTPD09TfcIAAAAAAAAAAAAAAAAAPDXoQkT+crZ2Vl9+vRReHi4wsLC9OOPP+rMmTP67LPPFBoaKl9fX9My23FxcVqxYoVOnTqlRYsW6ZNPPlGfPn1yjFmlShU1bdpU48aNU3x8vM6cOaPo6GgtWLBAZcuWzVVdlStXlp+fnyZMmKDPPvtMJ0+e1Lx58xQfH6+QkJA8XauFhYX69Omj5cuXa/ny5Tp9+rQ+/fRTTZgwQba2trK1tVXr1q1VtGhRDR8+XEePHtWBAwc0fPhw0/mOjo5ydHRUfHy8kpOTlZiYqLfeekuHDx9Wenr6Q7MbNGigYsWKKSoqSh07dsxT/QAAAAAAAAAAAAAAAACAJ8Ny5Mh3gwcPlru7u9atW6eVK1fq1q1bcnNzU2BgoPr162c6rn379tq+fbumTZsmd3d3hYeHy8/P74FjhoWFKSwsTOPGjdPVq1dVtmxZTZo0SUFBQbmuKywsTLNnz9aYMWN07do1ValSRREREWrRokWerzUkJER2dnZavny5pk2bJhcXF3Xs2FFDhgyRdHdm0EWLFmnixInq3LmznJyc1L9/f/3www+ysbGRtbW15syZo6lTp6pNmzZycnKSr6+vhg4dqsjISN28efOBuZaWlmrbtq3ef/99tWrVKs/1AwAAAAAAAAAAAAAAAADyziL7j9Y8Bv4k/v7+6tChgwYOHGh0KX+qlJQUnTp1So0aNTJtS01NVePGjbVy5UrTrKB5MXLkSGVkZGjmzJlPXGf61YtPPEZenM2wMyRXkko62BiWffV2piG5RS1uG5IrSbesChqS+/W5G4bkSpKPWyFDck9fyzAkV5LKO9kaklsgM82QXEnKsrU3LNvu7CFDcrMtjfsdnjvFqxiSa33xhCG5kuT/4a+G5O56vYkhuQAAAAAAAAAAAEBe9V7zndElQFJ0F2+jS/jLMRMm8Ce6ffu2+vbtq9dff10vvPCCrl+/rvDwcLm7u6tWrVp5GnPv3r06fvy4tmzZopUrV+ZzxQAAAAAAAAAAAAAAAACA3KIJE/gTVapUSbNnz1ZkZKTmzp2rAgUKqH79+nr//fdlY5O3mRjXr1+vnTt3auDAgapZs2Y+VwwAAAAAAAAAAAAAAAAAyC2aMGGIHTt2GF3CX+bFF1/Uiy++mG/jzZ49O9/GAgAAAAAAAAAAAAAAAADknaXRBQAAAAAAAAAAAAAAAAAAAPwT0YQJAAAAAAAAAAAAAAAAAACQBzRhAgAAAAAAAAAAAAAAAAAA5AFNmAAAAAAAAAAAAAAAAAAAAHlgbXQBAAAAAAAAAAAAAAAAAAA8CStLC6NLwFOKmTABAAAAAAAAAAAAAAAAAADygJkwAeiGpb0hucu/O2NIriQNaVjOsGwbg37zIs2igCG5klTAIsuQ3J+v3zYkV5LOF7YzJDcrO9uQXEmyM+hXO365bWtMsCQX46KVWbikIbkWd4z7ubJI/82Q3Cw7B0NyJcnC8oohuU3CdhmSK0k7h/gZlg0AAAAAAAAAAAAAj4uZMAEAAAAAAAAAAAAAAAAAAPKAJkwAAAAAAAAAAAAAAAAAAIA8oAkTAAAAAAAAAAAAAAAAAAAgD2jCBAAAAAAAAAAAAAAAAAAAyAOaMAEAAAAAAAAAAAAAAAAAAPLA2ugCAAAAAAAAAAAAAAAAAAB4ElaWFkaXgKcUM2ECAAAAAAAAAAAAAAAAAADkAU2YAAAAAAAAAAAAAAAAAAAAeUAT5j+cv7+/PDw8TK/q1avLx8dHwcHBSkhIeOLxv/nmm8caZ8SIEQoODs7T/oiICPn7+z92jfntp59+0s6dO/+yvH379snDw0MpKSl/WSYAAAAAAAAAAAAAAAAA/J1kZWVp7ty5ev7551WrVi2FhIQoOTn5ocdv2LDBrHfu3uv+c7Zu3arAwEB5enqqTZs2+vzzz/O9bpow/wVCQkK0Z88e7dmzR7t27dKqVatUqFAh9enTR+fPn3+isbt166bTp0/nU6X/DP369dP333//l+V5e3trz549cnNz+8syAQAAAAAAAAAAAAAAAODvZP78+VqzZo3efvttrV27VhYWFnrllVeUnp7+wOMTExP13HPPmXrn7r3KlCkjSfrqq680fPhwdevWTRs3blSjRo302muvKSkpKV/rpgnzX8De3l6urq5ydXVV8eLFVbVqVU2YMEFpaWnavn270eXhEWxtbeXq6iorKyujSwEAAAAAAAAAAAAAAACAv1x6eroWL16sgQMHys/PT9WqVVNYWJhSU1P1ySefPPCcY8eOqVq1aqbeuXuve31YUVFRatGihXr06KFKlSrpzTff1LPPPqulS5fma+00Yf5LWVtbS7rb4CdJt27dUnh4uJo1ayZPT0+1b99en376qen4mJgY+fv765133pGPj4/69+8vDw8PSdLIkSM1YsQISXeXJ3/55ZdVp04d1ahRQ61bt9aWLVvyvf4lS5bI29tbaWlppm1ZWVlq3Lixli1bZlrCOz4+Xi+88IK8vLzUq1cvsy7l7OxsRUVFqVmzZqpVq5batWun2NhY0/57Y0RFRcnX11cdOnSQn5+fzp49q3nz5pmWTb9+/breeust1atXT3Xq1FHPnj3NZsqMiIhQcHCwoqKi1LhxY3l6eqpnz546ceKE6Zhdu3apY8eOqlWrlurXr68RI0bo6tWrZnXcW448t89qw4YNatGihWrUqKGgoCB99913+fwUAAAAAAAAAAAAAAAAACD3mjVr9oevhzl69Kh+++031atXz7StcOHCeuaZZ/T1118/8JzExERVrlz5gfuysrL07bffmo0nSb6+vkpISMjDlT0cTZj/QqmpqZo4caLs7e3VuHFjSdLQoUO1ceNGjR49WrGxsWrevLlCQ0MVHx9vOu/s2bNKTU3Vhg0b9Prrr2vPnj2SpFGjRmn06NFKTU1VSEiIqlWrppiYGG3atEmenp4aOXKkLl68mK/X0LZtW2VkZJjN5PnFF1/o8uXLat26tWnbO++8o9GjR2vt2rWytrZWz549df36dUlSWFiYVq1apTFjxmjz5s3q2bOnxo8fr5UrV5pl7dy5U2vXrtXkyZO1YcMGlSxZUiEhIYqIiFB2drZeeeUVnTp1SgsWLNC6devk5eWlrl276siRI6YxvvvuO3399ddauHChlixZonPnzmnChAmSpMuXLys0NFRBQUH66KOPNG/ePH399deaPn36A689N8/qwoULWrNmjWbMmKG1a9fK0tJSb775prKzs5/85gMAAAAAAAAAAAAAAAD/MFYWFrz+Bq+8On/+vCTJzc3NbHvx4sX1888/5zj+8uXLunjxor7++mu1bt3atNT4yZMnJUnXrl3TzZs3VbJkyVyN9ySs83U0GGLBggVavHixJOnOnTtKT09XpUqVFB4erlKlSikpKUnx8fGKjIxU06ZNJUmhoaFKTExUZGSkWYfxgAEDVLZsWbPxHR0d5ejoqCtXrig0NFS9e/eWpeXd/t1+/fopJiZGp06dUrFixXJVb0JCgry9vXNsz8jIUPHixSVJzs7O8vf3V2xsrNq1aydJ2rBhg/z9/eXs7Gw6Z8SIEfLz85MkzZw5U02aNFFcXJzatm2rJUuWaPr06aZrLleunM6ePavo6Gh1797dNEZISIjc3d1Nn62srGRvb68iRYroyy+/1Hfffacvv/zSlDt06FB9++23WrZsmaZOnWq679OnT1eRIkUkScHBwZoxY4aku02x6enpKlWqlEqXLq3SpUsrMjJSmZmZOe5Bbp9VRkaGxo8fr+rVq5uew2uvvaZffvnFdA8BAAAAAAAAAAAAAAAA4K90/0Rzj+Peisn3Vn6+x87OzrTi8P2OHTsm6W6v17Rp03Tz5k3Nnz9f3bp10+bNm3Xnzp2Hjnf79u081fgwNGH+C3Tp0sW0dLalpaWKFCkiR0dH0/7ExERJUp06dczO8/Hx0axZs8y23d+M+Htly5ZVUFCQVqxYoePHj+vUqVP68ccfJemBDYUPU6NGDc2cOTPH9uXLl2vHjh2mz0FBQerfv79SU1NVqFAhffrpp5ozZ47ZOc8995zpfZEiReTu7q5jx47p+PHjun37tt58802NHDnSdMy9JtVbt27l6poPHz4sSTmmwk1PTzf7YSxWrJipAVO627iakZEhSapevbpat26t/v37y83NTQ0aNFCTJk3k7++fI+9xnlWlSpXM8iSZMgEAAAAAAAAAAAAAAADgn6JAgQKS7vZl3XsvSbdv31bBggVzHF+vXj3t379fTk5Opm3vvvuumjZtqpiYGHXq1Mk03v0eNt6ToAnzX8DJyUnly5d/7POysrJkbW3+Fbj/C/x7SUlJ6tq1q5555hk1bNhQzZo1U9GiRU1f2NwqUKDAA+u9/wdCkho1aiRXV1fFxcWZGkuff/55s2N+X39WVpYsLS1Ny3KHh4erYsWKObLu73C2s7N7aK1ZWVlycHBQTEzMH47x+47p35s1a5Zee+01ff755/riiy80dOhQ1a5dW8uWLfvD8+6v4/fX+qBMliMHAAAAAAAAAAAAAAAA8E9zbxnyCxcuqFy5cqbtFy5cULVq1R54zu/7zezt7VWmTBmlpqaqSJEisre314ULF8yOuXDhQo4lyp+UZb6Ohr+lqlWrSpK++eYbs+0JCQmqXLlyrsdZvXq1XFxctGTJEr3yyivy8/PTxYsXJf05zX9WVlZq3769tm/fru3bt6tdu3aysrIyO+b77783vb98+bKSk5P17LPPqmLFirK2tta5c+dUvnx502vXrl2Kjo42Laf+KFWrVtWNGzeUnp5uNk5UVFSup849cOCAJk+erIoVK6pXr15auHChJk+erH379unSpUs58qQnf1YAAAAAAAAAAAAAAAAA8E9RrVo1OTg4aN++faZt165d05EjR+Tj45Pj+FWrVsnX19dsReQbN27o1KlTqly5siwsLFS7dm3t37/f7Lx9+/blWKX4STET5lOgcuXK8vPz04QJEyTdXX47Li5O8fHxCg8P/8Nz7e3tlZSUpF9//VUlS5bU+fPntWvXLlWuXFmHDx/W22+/LSnntK35JSgoSFFRUbKxsdHw4cNz7J8wYYImTZokR0dHTZ8+Xa6urnrxxRdVsGBBdenSReHh4SpUqJDq1KmjhIQEzZgxQ6+88sofZhYqVEinTp3SxYsX9fzzz6t69eoaPHiwxowZo1KlSmnNmjVav369Fi9enKtrcHBw0KpVq2RjY6POnTvr1q1biouLk7u7u4oWLWp27JM8KwAAAAAAAAAAAAAAAAD4J7K1tVWPHj00c+ZMOTs7q3Tp0poxY4ZKliypFi1aKDMzU5cvX5ajo6MKFCigpk2bKjw8XG+88YYGDhyoW7duafbs2XJ2dlaHDh0kSS+//LL69u2rZ555Ro0bN9b69ev1448/6p133snX2mnCfEqEhYVp9uzZGjNmjK5du6YqVaooIiJCLVq0+MPzQkJCtGjRIp04cUJz5szRiRMn9MYbbyg9PV3u7u4aOnSo5s6dq0OHDqlx48b5Xnf58uXl5eWlrKwsVapUKcf+Tp06adiwYbp27Zrq1aunZcuWqWDBgpKkkSNHytnZWXPnzjVNIxsaGqq+ffv+YWZwcLCmTZumn376SbGxsVq8eLFmzJihIUOGKC0tTZUqVVJERITq16+fq2uoXLmyIiIiNG/ePK1atUqWlpaqV6+eoqKiHjgjZ16fFQAAAAAAAAAAAAAAAAD8Uw0aNEh37tzRmDFjdOvWLdWtW1fR0dGytbVVSkqKmjVrpilTpqhjx45yc3PT0qVLNXPmTHXt2lXZ2dlq2LChli1bpgIFCkiSGjVqpMmTJ2v+/PkKCwtT5cqVFRkZ+cA+tCdhkf1nrCMN5JPs7Gy98MIL6tu3rzp16mTavm/fPvXs2VPx8fEqU6aMgRX+O1y+ftOQ3HlfnTEkV5KGNCxnWHZ6pjF/7FpZGBIrSSpgacw1f3D0V0NyJalu6cKG5N66k2VIriRVc7YzJPdiWqYhuZLkYm/c77NYX79gSK7FnduG5EpSVgFHQ3Itbv9mSK4ktVidYli2UXYO8TO6BAAAAAAAAAAAAPwDha4/ZHQJkDQvqKbRJfzlmAkTf0sZGRnasWOHvvrqK924cUOtWrUyuiQAAAAAAAAAAAAAAAAAf1NWlgbOToWnGk2Y+FuysbHR22+/LUmaMWOG7O3tDa4IAAAAAAAAAAAAAAAAAABzNGHib2v37t0P3efr66vExMS/sBoAAAAAAAAAAAAAAAAAAMxZGl0AAAAAAAAAAAAAAAAAAADAPxFNmAAAAAAAAAAAAAAAAAAAAHlAEyYAAAAAAAAAAAAAAAAAAEAe0IQJAAAAAAAAAAAAAAAAAACQBzRhAgAAAAAAAAAAAAAAAAAA5IG10QUAAAAAAAAAAAAAAAAAAPAkrCwtjC4BTylmwgQAAAAAAAAAAAAAAAAAAMgDZsIEoF/S7hiS28O7lCG5kpSWkWVYdhGlGROcbdw1W974xZDcxuXLG5IrSVnZ2Ybk/pZuSKwkyeraeWNy7YobkitJt+8Y93NlnZlhSG62hXG/w3PTprAhufaWxv2TeUaQs2HZRvni1CVDchu4uxiSCwAAAAAAAAAAAOCfjZkwAQAAAAAAAAAAAAAAAAAA8oAmTAAAAAAAAAAAAAAAAAAAgDygCRMAAAAAAAAAAAAAAAAAACAPaMIEAAAAAAAAAAAAAAAAAADIA2ujCwAAAAAAAAAAAAAAAAAA4ElYW1oYXQKeUsyECQAAAAAAAAAAAAAAAAAAkAc0YQIAAAAAAAAAAAAAAAAAAOQBTZgAAAAAAAAAAAAAAAAAAAB5QBPmn8zf318eHh6mV/Xq1eXj46Pg4GAlJCQ88fjffPPNY40zYsQIBQcHP3DfyJEjVa9ePWVkZDxw/8KFC+Xt7a0bN248MsfDw0MxMTG5rut+wcHBZvfs9y9/f39Jd+9tREREnjLy25Ncb27s27dPHh4eSklJ+dMyAAAAAAAAAAAAAAAAAACPx9roAp4GISEhCgkJkSRlZ2frypUrmj17tvr06aNt27apZMmSeR67W7dumjJlinx8fJ64zqCgIMXExGjv3r1q0qRJjv2bNm3Siy++KAcHh0eOtWfPHjk6OuapjoiICFMj6M8//6xOnTopIiJC3t7ekiQrK6s8jftP5u3trT179sjZ2dnoUgAAAAAAAAAAAAAAAAAA/x8zYf4F7O3t5erqKldXVxUvXlxVq1bVhAkTlJaWpu3btxtdnomPj48qVKigzZs359h36NAhHT9+XJ06dcrVWK6uripQoECe6ihSpIjpft1rOnRycsqx7Wlia2srV1fXp7IBFQAAAAAAAAAAAAAAAAD+rmjCNIi19d1JSG1tbSVJt27dUnh4uJo1ayZPT0+1b99en376qen4mJgY+fv765133pGPj4/69+8vDw8PSXeXER8xYoSku8uTv/zyy6pTp45q1Kih1q1ba8uWLbmuKygoSPHx8frtt9/Mtm/atEmVKlVS7dq1JUmfffaZOnbsqJo1a6pFixYKDw9Xenq66fj7l+ceMWKEhg8frmnTpql+/fqqVauWBgwYoF9++eVxb1sOv/zyiwYOHCgvLy/5+vpqypQpyszMlPTgeyZJSUlJ6t+/v3x9fVWnTh0NGjRI586dM40ZHBys8PBwvfXWW/L29la9evU0f/58nThxQt27d1fNmjXVtm1bHTp0yKyWEydOqGvXrvL09FTr1q21d+9es/07d+5U586d5e3trUaNGmnq1Km6ffu2af+uXbvUsWNH1apVS/Xr19eIESN09epVSTmXIz906JC6desmb29v1a1bVwMHDjS7BgAAAAAAAAAAAAAAAADAn48mTAOkpqZq4sSJsre3V+PGjSVJQ4cO1caNGzV69GjFxsaqefPmCg0NVXx8vOm8s2fPKjU1VRs2bNDrr7+uPXv2SJJGjRql0aNHKzU1VSEhIapWrZpiYmK0adMmeXp6auTIkbp48WKuauvQoYMyMjLMGkAzMjIUFxen//znP5Kkzz//XP/73//UqVMnbdmyRePGjdPWrVs1fPjwh467detWXblyRStWrNC8efP0zTffKCws7LHv3e99+OGH8vHx0ebNmzV8+HAtWbJEGzZsMO3//T07e/asXnrpJdna2mrp0qV6//33denSJfXo0UM3btwwnbdo0SK5ubkpNjZWwcHBmjNnjvr166eQkBB98MEHsrOz0/jx481qWbp0qdq1a2d6fr1799YPP/wgSfr000/16quvys/PT+vXr9ekSZO0detWDRs2TJJ0+fJlhYaGKigoSB999JHmzZunr7/+WtOnT89xzVlZWerXr5/q1q2r2NhYLVmyROfOndOoUaOe+H4CAAAAAAAAAAAAAAAA/0RWlha8/gavp5G10QU8DRYsWKDFixdLku7cuaP09HRVqlRJ4eHhKlWqlJKSkhQfH6/IyEg1bdpUkhQaGqrExERFRkaqWbNmprEGDBigsmXLmo3v6OgoR0dHXblyRaGhoerdu7csLe/21/br108xMTE6deqUihUr9shaixUrJj8/P23evFnt2rWTdHeGxhs3bqh9+/aSpMjISP3nP/9R165dJUnlypXThAkT9N///lcpKSkqU6ZMjnEdHBw0ceJE2djYqFKlSmrXrp127dr1mHcypxYtWui///2vJKls2bJatmyZfvjhB1PDqGR+z2bMmCF7e3vNnDnTNAvp3Llz5e/vr9jYWHXr1k2SVLVqVQ0YMECSFBISorlz5yowMND0LDp27KjJkyeb1dK1a1d16dJFkjR48GB99dVXWrJkiWbOnKkFCxaoRYsWeu211yRJFStWVHZ2tl599VUlJSUpPT1d6enpKlWqlEqXLq3SpUsrMjLSNKvn/a5fv65ff/1VxYsXV5kyZWRhYaHw8HBdunTpie8nAAAAAAAAAAAAAAAAACD3aML8C3Tp0kXBwcGSJEtLSxUpUkSOjo6m/YmJiZKkOnXqmJ3n4+OjWbNmmW1zd3d/aE7ZsmUVFBSkFStW6Pjx4zp16pR+/PFHSXpgM9/D/Oc//1FoaKguXbokFxcXbdiwQf7+/nJ2dpYkHTlyRIcOHTKbcTI7O1vS3aW+H9SEWb58ednY2Jg+Ozo6KiMjI9c1PUyFChXMPjs5OZkt8S2Z37Njx46pRo0apgZMSXJxcVGFChVMz+H34xYsWFCSzJpf7ezszJZfl+4+r/vVqlVLX331lSm3VatWZvvr1q0r6e7zDwwMVOvWrdW/f3+5ubmpQYMGatKkifz9/XNcs5OTk/r06aNJkyZp3rx5atCggRo3bqyWLVvmOBYAAAAAAAAAAAAAAAAA8OehCfMv4OTkpPLlyz/2eVlZWbK2Nn9EBQoUeOjxSUlJ6tq1q5555hk1bNhQzZo1U9GiRdWpU6fHyvXz85Ozs7Pi4uLUtm1b7dq1S/Pnzzerq0+fPurQoUOOc11dXR845v1Nj/nJysoqx7Z7DaH33H/PsrOzZWGRc9rbzMxMsybR+9/fc2920Yf5/f7MzEzTdT8o915j7L1nPGvWLL322mv6/PPP9cUXX2jo0KGqXbu2li1bliNr2LBh6tatm3bt2qUvv/xS48eP14IFC7Rx48Y/7V4DAAAAAAAAAAAAAAAAAMz9cVcZ/hJVq1aVJH3zzTdm2xMSElS5cuVcj7N69Wq5uLhoyZIleuWVV+Tn56eLFy9KytmY+EesrKzUoUMHbdu2Tdu2bVOxYsXUqFEj0/4qVaroxIkTKl++vOmVmpqq6dOn67fffst1jhGqVq2qQ4cOmc1iefHiRSUnJ6tSpUpPNPbhw4fNPn/77beqUqWKKfdBz1eSKlWqpAMHDmjy5MmqWLGievXqpYULF2ry5Mnat29fjmXGT5w4oXHjxsnFxUVdu3bV3LlztWjRIiUlJeno0aNPdA0AAAAAAAAAAAAAAAAAgNxjJsy/gcqVK8vPz08TJkyQdHf57Li4OMXHxys8PPwPz7W3t1dSUpJ+/fVXlSxZUufPn9euXbtUuXJlHT58WG+//bYk5Vg6+1GCgoIUHR2ttLQ0dezY0WyWx1deeUWDBw9WRESEWrdurfPnz2vMmDEqVarUQ2fC/Lvo2rWrVq9erWHDhmnAgAFKT0/XtGnTVLRo0RzLhT+uJUuWqFy5cqpVq5bWrFmjY8eOmZaT7927t4YMGaJ3331XgYGBOnXqlCZNmqSmTZuqUqVKOn78uFatWiUbGxt17txZt27dUlxcnNzd3VW0aFGznCJFimjLli26deuW+vbtK0tLS61fv15OTk6qWLHiE10DAAAAAAAAAAAAAAAAACD3aML8mwgLC9Ps2bM1ZswYXbt2TVWqVFFERIRatGjxh+eFhIRo0aJFOnHihObMmaMTJ07ojTfeUHp6utzd3TV06FDNnTtXhw4dUuPGjXNdj7u7u2rXrq2EhATNmzfPbN+LL76osLAwLViwQAsWLJCTk5OaNm2q4cOH5+na/0ply5bV8uXLNXPmTL300kuytbVVw4YNNWPGDBUuXPiJxh4wYICWL1+ut956S5UrV9bChQtVoUIFSVJAQIAyMzO1YMECvffee3J2dlbr1q01aNAgSXcbcSMiIjRv3jytWrVKlpaWqlevnqKionIsc+7s7KxFixZp1qxZ6ty5szIzM+Xl5aX3339fDg4OT3QNAAAAAAAAAAAAAAAAAIDcs8h+nHWqAfwrJV64ZkiujaWFIbmS5GBj+eiD/iRFlGZMcHaWMbmSLG/8Ykju2YLlDcmVpCyD/nq9nJZpSK4k1bT91ZDci3bFDcmVpILWxv05VujGz4ZlG+U3BzdDcu0zbxqSK0kHr1oZlm2UjCxj/r5q4O5iSC4AAAAAAAAAAADyx8i4I0aXAElTWj1jdAl/OWbCBAAAAAAAAAAAAAAAAAD8o1kZOBkYnm7GTQUHAAAAAAAAAAAAAAAAAADwD0YTJgAAAAAAAAAAAAAAAAAAQB7QhAkAAAAAAAAAAAAAAAAAAJAHNGECAAAAAAAAAAAAAAAAAADkAU2YAAAAAAAAAAAAAAAAAAAAeUATJgAAAAAAAAAAAAAAAAAAQB5YG10AAAAAAAAAAAAAAAAAAABPwsrSwugS8JRiJkwAAAAAAAAAAAAAAAAAAIA8YCZMADpxOc2Q3KblCxuSK0mHL942LLuIQZd9xaKQMcGSrJwcDMktqXRDciUp3crOkNzS1sb8PEtSdpYx1+xsfceQXEmyun7BsOwbjqUNyS2oDENyjXRZBQ3L9rIz5juWbWvcNRvl+C/XDcuu7OpoWDYAAAAAAAAAAACAJ8NMmAAAAAAAAAAAAAAAAAAAAHlAEyYAAAAAAAAAAAAAAAAAAEAe0IQJAAAAAAAAAAAAAAAAAACQBzRhAgAAAAAAAAAAAAAAAAAA5AFNmAAAAAAAAAAAAAAAAAAAAHlgbXQBAAAAAAAAAAAAAAAAAAA8CStLC6NLwFOKmTABAAAAAAAAAAAAAAAAAADygCZMAAAAAAAAAAAAAAAAAACAPKAJEw/l7++viIiIh+4fMWKEgoOD/8KK7mZ6eHiof//+D9wfFxcnDw+Px6orIyNDS5YsyacK7/rmm2+UkJCQb+M96lkAAAAAAAAAAAAAAAAAAP56NGEiz0aPHm1IY6CNjY327t2rGzdu5Nj30UcfycLC4rHG27Jli6ZMmZJf5UmSunXrptOnT+fbeB9++KFCQkLybTwAAAAAAAAAAAAAAAAAwJOjCRN55ujoqCJFivzluTVq1FCBAgUUHx9vtv3GjRvavXu36tSp81jjZWdn52d5fwpnZ2cVKlTI6DIAAAAAAAAAAAAAAAAAAPehCRN5dm858uzsbDVr1kwzZsww2x8bG6tatWqZZqxcv369AgICVLNmTQUEBGjp0qXKysqSJKWkpMjDw0Pz589Xw4YN5e/vr2vXrj0w18bGRs2aNdPWrVvNtn/66afy8PBQ2bJlzbanpqZqyJAh8vHxka+vr/r3769Tp05JkmJiYjRy5EhJkoeHh/bt26fs7GwtWrRIAQEBqlGjhurUqaN+/frpzJkzpjF37dqljh07qlatWqpfv75GjBihq1evmsaRpJEjR2rEiBGS7i5P/vLLL6tOnTqqUaOGWrdurS1btpjGu3TpkgYNGiRfX1/VrFlTXbp00f79+03771+OPC0tTaNHj1bDhg3l6emp9u3ba/v27Y96XAAAAAAAAAAAAAAAAACAfEYTJp6YhYWF2rdvr7i4OLNZJWNjY9WiRQs5ODho7dq1mjZtml577TXFxcVp8ODBioqK0syZM83Gio2N1dKlSzVnzhwVLlz4oZkBAQE5liT/6KOP1KpVK7Pjbt68qeDgYGVmZmrFihVavny5ihYtqs6dOys1NVWBgYEaNWqUJGnPnj3y9vbW0qVLtWDBAg0fPlwff/yx5s+fr5MnT2rq1KmSpMuXLys0NFRBQUH66KOPNG/ePH399deaPn26aRxJGjVqlEaPHq3U1FSFhISoWrVqiomJ0aZNm+Tp6amRI0fq4sWLkqTx48fr1q1bWrFihTZv3qwKFSpowIABunnzZo5rnzNnjhITE7Vw4UJ99NFHaty4sYYMGaKUlJRcPzMAAAAAAAAAAAAAAAAAwJOzNroA/Dt06NBB7777rr7++ms999xzunjxor788ktFRUVJkubPn69+/fqpdevWkqSyZcvqxo0bmjBhgv73v/+ZxunWrZsqV678yLwGDRrI3t5e8fHxateuna5evaovv/xSkyZN0tGjR03HxcXF6ddff9WsWbNkY2MjSXrnnXe0b98+rVu3TgMHDpSjo6MkydXVVZJUrlw5TZ06Vf7+/pKk0qVLKyAgQHFxcZLuzqyZnp6uUqVKqXTp0ipdurQiIyOVmZlpNo6jo6McHR115coVhYaGqnfv3rK0vNv33K9fP8XExOjUqVMqVqyYTp8+rapVq6pcuXKys7PT6NGj1aZNG1lZWeW49tOnT8vBwUHlypWTo6Oj/ve//8nHx0dOTk65fVwAAAAAAAAAAAAAAADAv4qVpYXRJeApRRMm8kWZMmVUt25dbd68Wc8995y2bNkiV1dX1atXT5cvX9b58+c1Z84czZs3z3ROVlaWbt++rZSUFNnZ2UmSypcvn6u8+5ckb9eunbZv3y4vLy+VKFHC7LgjR47oxo0beu6558y2mZ0tdAABAABJREFU3759W0lJSQ8c29/fXwcPHtTcuXOVnJyspKQk/fTTT6axq1evrtatW6t///5yc3NTgwYN1KRJE1PT5u+VLVtWQUFBWrFihY4fP65Tp07pxx9/lCRT42ZoaKiGDx+uTz75RD4+PmrUqJECAwNN9+V+r7zyivr376/69evL29tbDRs2VKtWrUzNpAAAAAAAAAAAAAAAAACAvwZNmMg3QUFBmjx5st566y3FxsaqXbt2srS0VFZWliRp5MiRatCgQY7z3NzcdOHCBUlSgQIFcp0XGBioV199VTdu3NDWrVsVGBiY45isrCxVqFBB7733Xo599vb2Dxw3KipKERER6tixo5577jkFBwcrPj7eNBOmJM2aNUuvvfaaPv/8c33xxRcaOnSoateurWXLluUYLykpSV27dtUzzzyjhg0bqlmzZipatKg6depkOqZFixbavXu3du/erS+++EKLFi3SnDlztG7dOlWpUsVsPG9vb+3atUt79+7Vl19+qQ8//FARERFatGiR6tevn+v7BwAAAAAAAAAAAAAAAAB4MpZGF4B/j5YtW+rOnTtau3atDh8+rPbt20uSXFxc5OLiotOnT6t8+fKm1+HDhxUeHp7nvHr16qlQoULasGGDEhIS1LJlyxzHVK1aVefOnZOjo6Mpt3Tp0po1a5a+/vprSZKFhflUxO+9955CQ0M1fvx4vfTSS/Ly8tKpU6eUnZ0tSTpw4IAmT56sihUrqlevXlq4cKEmT56sffv26dKlSzlqWL16tVxcXLRkyRK98sor8vPz08WLFyVJ2dnZSk9P15QpU3TmzBkFBgbq7bff1ieffCJLS0vt3Lkzx3hz587VN998o2bNmmnMmDH6+OOPVbZsWX388cd5vpcAAAAAAAAAAAAAAAAAgMfHTJj4Q8nJyfr888/NttnZ2cnX1zfHsQULFtSLL76osLAweXt7q0KFCpLuNjn26dNHs2fPVqlSpeTn56djx45pwoQJatKkiWxtbfNUm7W1tVq0aKHw8HDVrVtXzs7OOY5p27atFi5cqNDQUL3xxhtydHRUZGSkdu3apYEDB0r6vxkxf/jhB1WuXFlubm7au3ev/P39ZWlpqU2bNmn79u0qVqyYJMnBwUGrVq2SjY2NOnfurFu3bikuLk7u7u4qWrSoacykpCT9+uuvKlmypM6fP69du3apcuXKOnz4sN5++21JUnp6umxtbXXw4EElJCTorbfeUrFixbRr1y799ttv8vb2fuAziY2N1aRJk1SuXDkdOHBA586de+CxAAAAAAAAAAAAAAAAAIA/D02Y+EObN2/W5s2bzbaVKFEiR2PmPR07dtT69etNs2DeExISIjs7Oy1fvlzTpk2Ti4uLOnbsqCFDhjxRfYGBgVq3bp1atWr1wP2Ojo5asWKFpk+frj59+igzM1PVq1dXdHS0aZnvevXqqVatWurSpYtmzJih6dOna+LEiQoKClKhQoVUq1YtTZgwQePHj1dKSooqV66siIgIzZs3T6tWrZKlpaXq1aunqKgoWVpamq530aJFOnHihObMmaMTJ07ojTfeUHp6utzd3TV06FDNnTtXhw4dUuPGjTVnzhxNmTJFr776qq5fv66KFStq1qxZ8vHxyXFNEyZM0LRp0zR8+HBduXJFpUuX1rBhw9SuXbsnupcAAAAAAAAAAAAAAAAAgMdjkX1vjWUAT62tR1MNyW1avrAhuZJ0+OJtw7I9C98xJPeKChqSK0lWlhaG5Doo3ZBcSUq3sjMk1y79uiG5kqQsY77b2baFDMmVJKvrFwzLvuFY2pDcgsowJFeS0mRjSO6tTOP+uexyy5jvWLatcX9nGOX0HeP+LKns6mhYNgAAAAAAAAAAwL/FO/HHjC4BkkY3q2p0CX85ZsIEAAAAAAAAAAAAAAAAAPyjGTVBFGBpdAEAAAAAAAAAAAAAAAAAAAD/RDRhAgAAAAAAAAAAAAAAAAAA5AFNmAAAAAAAAAAAAAAAAAAAAHlAEyYAAAAAAAAAAAAAAAAAAEAe0IQJAAAAAAAAAAAAAAAAAACQBzRhAgAAAAAAAAAAAAAAAAAA5AFNmAAAAAAAAAAAAAAAAAAAAHlgbXQBAAAAAAAAAAAAAAAAAAA8CStLC6NLwFOKmTABAAAAAAAAAAAAAAAAAADygJkwAcjbzcGQ3GO/phuSK0k1C1wzLNvixm+G5Do5ljAkV5Iyre0Nyb14y8aQXElKv33HkFwHW2N+niXpZmaWIbklLbINyZWkLPuihmU/jQpYGfOba79lPH3fsbO3rQzJlaQ0g+53aUfjrjn9ygXDsm2LFDcsGwAAAAAAAAAAAPg3YCZMAAAAAAAAAAAAAAAAAACAPKAJEwAAAAAAAAAAAAAAAAAAIA9owgQAAAAAAAAAAAAAAAAAAMgDmjABAAAAAAAAAAAAAAAAAADygCZMAAAAAAAAAAAAAAAAAACAPLA2ugAAAAAAAAAAAAAAAAAAAJ6ElaWF0SXgKcVMmAAAAAAAAAAAAAAAAAAAAHlAEyYAAAAAAAAAAAAAAAAAAEAe0IT5NxAcHCwPDw+zV40aNeTv76933nlHt27deqLxY2Ji5OHhYfrs7++viIiIXJ/v4eGhmJiYJ6rhfhEREfL398+38R5V3x/tf9x7ERwcrBEjRkiS9u3bJw8PD6WkpDxewU/o988TAAAAAAAAAAAAAAAAAGAMa6MLwF0BAQEaPXq06fPNmze1Z88eTZkyRZmZmRo7dmy+ZX344Yeys7PLt/EeV0hIiLp3725YPgAAAAAAAAAAAAAAAAAA+YEmzL+JAgUKyNXV1Wxb+fLl9cMPPyguLi5fmzCdnZ3zbay8KFSokAoVKmRoDQAAAAAAAAAAAAAAAAAAPCmWI/+bs7Ozk6Xl/z2m8+fPa9iwYWrQoIGeffZZ+fn5KSwsTFlZWaZjPvnkE7Vp00Y1a9ZUjx49dO7cObMxf78E986dO9W5c2d5e3urUaNGmjp1qm7fvv3Qmh51/OXLlzVkyBD5+PjI19dXM2bMUM+ePU2Zv1+O/PLly3rzzTfl6+urOnXq6JVXXtGpU6ckSdnZ2Vq0aJECAgJUo0YN1alTR/369dOZM2fydkMfYceOHerSpYu8vb3l6emp//znP/riiy9ydW5wcLDCw8P11ltvydvbW/Xq1dP8+fN14sQJde/eXTVr1lTbtm116NAh0zk//fSTBgwYIF9fX9WoUUMtWrTQ0qVLTfsjIiLUpUsXDR06VLVr19aECRNy5G7fvl01atTQypUrn/wGAAAAAAAAAAAAAAAAAAByjSbMv6k7d+5o586d2rRpk9q1a2fa3q9fP12+fFnR0dHatm2b+vTpo8jISO3YsUOS9O2332rgwIF64YUXTOcuXLjwoTmffvqpXn31Vfn5+Wn9+vWaNGmStm7dqmHDhuXp+KysLPXr10/JycmKiorS4sWLdejQIe3fv/+h1xkSEqJjx47p3Xff1bp162RlZaWQkBDduXNHS5cu1YIFCzR8+HB9/PHHmj9/vk6ePKmpU6fm9dY+1A8//KDXXntNL7zwgmJjY/XBBx/IxcVFw4YNU3p6eq7GWLRokdzc3BQbG6vg4GDNmTNH/fr1U0hIiD744APZ2dlp/PjxkqS0tDS9/PLLsre316pVqxQXF6eAgABNnjxZP/74o2nM7777Ti4uLtq0aZP++9//muXFx8fr9ddf19ixY1niHQAAAAAAAAAAAAAAAE8tK0sLXn+D19OI5cj/JjZv3qyPP/7Y9PnWrVsqVaqUevfurf79+5u2tWvXTi1btlTp0qUl3Z19ceHChUpMTFTz5s21YsUK1a5dWwMHDpQkVahQQceOHdOyZcsemLtgwQK1aNFCr732miSpYsWKys7O1quvvqqkpCRVqlTpsY7/5ZdfdOjQIW3dulUVK1aUJIWHh6tp06YPzP/qq6/0448/mh0/adIkRUdH68qVKypXrpymTp1qmjmzdOnSCggIUFxc3GPd33HjxmnSpEk5tqelpZneW1lZacyYMWbNjD179lRISIguXbokNze3R+ZUrVpVAwYMkCSFhIRo7ty5CgwMVLNmzSRJHTt21OTJk03ZPXv2VLdu3eTg4CBJCg0N1YIFC5SYmKjq1aubxh00aJAcHR0l3W20laRdu3ZpyJAhGj9+vIKCgh7rfgAAAAAAAAAAAAAAAAAAnhxNmH8T/v7+GjZsmLKysnTw4EFNmTJFDRo0UP/+/WVtffcxFShQQD169NC2bdu0dOlSJScn6+jRo7pw4YJpOfJjx46pYcOGZmN7e3s/tAnz2LFjatWqldm2unXrSpISExNzNGE+6vjz58/LycnJ1FApSS4uLqpQocID8xMTE1W4cGGz411dXTVixAjTfTl48KDmzp2r5ORkJSUl6aefflKJEiUeON7DDBo0SC+88EKO7cHBwab31atXl5OTk6KionTy5EmdOnXKNCNlZmZmrnLuv86CBQtKksqWLWvaZmdnZ5pV09nZWd26ddNHH32ko0ePKjk52ZR3//LyLi4upgbM319Tenq62fgAAAAAAAAAAAAAAAAAgL8OTZh/E4UKFVL58uUl3W3kK1mypF5++WVZWVmZLV/dvXt3paWlKSAgQO3atdNbb72VYxnq7Oxss882NjYPzc3OzpaFhfk0sPcaDu81fz7O8VZWVmYNhI9ibW2dY7z7RUVFKSIiQh07dtRzzz2n4OBgxcfHP/ZMmC4uLqb7+/v8e77++muFhITIz89PPj4+atWqldLS0kyzfubGg+61paXlA4+9ePGiOnfurKJFi6pZs2aqX7++PD095efnZ3ZcgQIFHnj+22+/rU8++USjRo3S5s2bTU2fAAAAAAAAAAAAAAAAAIC/Bk2Yf1P16tXTyy+/rOjoaPn7+6tx48bavXu3Dh8+rL1796pYsWKSpCtXrujSpUumxsvq1aublqu+5/vvv39oTtWqVfXNN9/ov//9r2lbQkKCJOWYBTM3xzs5Oen69etmS5lfuXJFycnJD8yvXLmyrl69quTkZFOT5OXLl9WyZUtFRkbqvffeU2hoqPr27Ws6Jzo6OkejaX6Ijo6Wr6+v5s2bZ9q2fPlySTkbW/PD5s2bdeXKFX388cem5s3ExMRc57Vp00b169dXYGCgZs2apTFjxuR7jQAAAAAAAAAAAAAAAACAh3vwFH34W/jf//4nd3d3jRs3Tr/99ptKliwpSYqNjdXZs2eVkJCgAQMGKCMjw7TEdUhIiI4ePapp06bp5MmTio2N1cqVKx+a0bt3b23fvl3vvvuuTp48qc8++0yTJk1S06ZNH9iE+ajjfX195eXlpTfeeEMHDhzQ0aNHNWzYMKWlpT1wxsv69eurRo0aeuONN3Tw4EH99NNPGjlypFxcXOTp6Sk3Nzft3btXx48f14kTJxQWFqbt27ebrjc/ubm5KTExUQkJCUpJSdH69es1Z84cSfpT8kqWLKm0tDRt3bpV586d0549ezR06NDHyitWrJiGDx+uFStW6Ouvv873GgEAAAAAAAAAAAAAAAAAD0cT5t+YnZ2dJk2apJ9//llhYWGqWbOmRo4cqWXLlikgIEAjR45U3bp11bp1ax08eFDS3Zkwo6KitG/fPrVt21ZLlixR//79H5oREBCgmTNnatu2bWrTpo3GjRunVq1aKTw8PM/Hz507VyVLllSvXr303//+V56enipVqtRDl+qeP3++SpUqpd69e6tr166ytrZWdHS0bG1tNX36dN26dUtBQUHq0aOHjh07pgkTJujSpUtKSUl5ovv7e4MGDZKXl5f69++v9u3b64MPPtDkyZNVoEABHTp0KF+zJOnFF19U7969NW3aNAUEBGjy5Mn6z3/+o7p16z5WXqdOneTr66tRo0YpLS0t3+sEAAAAAAAAAAAAAAAAADyYRfafsc4ynlqXL1/WwYMH1ahRI1PTZXp6unx9fTVu3Di1b9/e2ALxQOev/mZI7oXf7hiSK0nVba4alm2Rbsz9znQsYUiuJGXa2BuS++utTENyJSk9M8uQXAdbK0NyJelmhjHXXLKAcf+Usbhz27Dsm1bG/FwVVIYhuZKUbWVrSO6lW8Z8tyWpmLUx9/vsbeP+LEnLMOZnurSjtSG5kmR/54Zh2bZFihuWDQAAAAAAAAAAkJ/m7D1hdAmQ9L+GFY0u4S9n3P9pxL+StbW1hgwZoi5duqhr167KyMgwzWrZuHFjo8sDAAAAAAAAAAAAAAAA8C9kZWlhdAl4SrEcOfJV4cKFFRkZqQMHDqh9+/bq3LmzLl68qGXLlsnZ2dno8gAAAAAAAAAAAAAAAAAAyDfMhIl8V69ePa1Zs8boMgAAAAAAAAAAAAAAAAAA+FMxEyYAAAAAAAAAAAAAAAAAAEAe0IQJAAAAAAAAAAAAAAAAAACQBzRhAgAAAAAAAAAAAAAAAAAA5AFNmAAAAAAAAAAAAAAAAAAAAHlAEyYAAAAAAAAAAAAAAAAAAEAeWBtdAAAAAAAAAAAAAAAAAAAAT8LKwsLoEvCUogkTgO5kZhuS23PeXkNyJWn/8NqGZV8rUMyQXKcbZw3JlSTrO8Zk779qzL2WpEB3e0Ny1yReMSRXklpXdTEk95fbWYbkSpKdtTHPWZKupmUaklvGwdaQXEmyup5qSK6rpXH/ZN6cYszE9TVLOBqSK0n7zl4xJLdhuSKG5EqSa0EHw7JPG3S/vUoXMSQXAAAAAAAAAAAAyG8sRw4AAAAAAAAAAAAAAAAAAJAHNGECAAAAAAAAAAAAAAAAAADkAU2YAAAAAAAAAAAAAAAAAAAAeUATJgAAAAAAAAAAAAAAAAAAQB7QhAkAAAAAAAAAAAAAAAAAAJAH1kYXAAAAAAAAAAAAAAAAAADAk7C0sDC6BDylmAkTAAAAAAAAAAAAAAAAAAAgD2jCBAAAAAAAAAAAAAAAAAAAyAOaMB9Ddna2YmJiFBwcrHr16qlGjRpq3ry5Jk6cqNTUVKPLyzcbN27U888/L09PTy1btuyhx4WFhcnDw0NLly7NsW/fvn3y8PBQSkpKvtQ0YsQIBQcHGz7GnyUiIkL+/v5GlwEAAAAAAAAAAAAAAAAAeAw0YeZSZmamXn31VU2dOlVNmzbV8uXLtX37dr311ls6fPiwgoKCdPHiRaPLzBfvvPOOGjRooG3btqlDhw4PPCYrK0sbN25UhQoVtGbNmr+4QgAAAAAAAAAAAAAAAAAAjEcTZi69//772r17t95//32FhISoSpUqKlWqlPz8/LRkyRLZ2Nho8eLFRpeZL65du6bnnntOpUuXlqOj4wOP2bNnj86fP6/hw4frxIkT2rdv319cJQAAAAAAAAAAAAAAAAAAxqIJMxeys7O1cuVKtW3bVs8++2yO/QULFtSKFSs0ePBgSVJKSoo8PDw0f/58NWzYUP7+/rp27Zp++uknDRgwQL6+vqpRo4ZatGhhtpR3RESEevXqpWXLlqlRo0by8vLS0KFD9csvv+iNN96Qt7e3/Pz8tGHDBtM5p06dUu/evVWnTh15e3urd+/eSkxMfOi1ZGZmasmSJWrZsqU8PT3VsmVLrVu3zqxuSRo1apTp/YPExMSoatWqatasmcqUKaPVq1c/8j4uX75cLVu2VM2aNRUYGKhNmzaZ9v38888aNmyYGjZsKC8vrwdeR0ZGhqZNm6b69evLy8tLAwYMMJt9NDdj/BF/f39FRkaqX79+qlmzplq0aKEPPvjA7Jhvv/1W3bt3V82aNdWkSRNNmDBBN27cMBtj8uTJCgwMlK+vr7766qsHZq1du1YtWrRQzZo1NWDAAF29etVs/x99Vy5fvqwaNWpo48aNZufMnDnzoTOXAgAAAAAAAAAAAAAAAADyH02YuZCSkqJz586pQYMGDz2mdOnSsrW1NdsWGxurpUuXas6cObKxsdHLL78se3t7rVq1SnFxcQoICNDkyZP1448/ms5JSEhQQkKCli5dqvDwcH388cdq3bq1qlevrvXr16tx48YaO3asfv31V0nS0KFDVbx4ca1fv14ffPCBLC0tFRoa+tA6p06dqvnz5ys0NFSbN29Wz549NXHiRC1fvlxubm7as2ePpLtNmPfe/96VK1cUHx+vli1bSpICAwP16aef/uFy7NHR0Zo5c6Z69+6tLVu2qHv37ho5cqT27t2rGzduqGvXrkpNTdV7772nNWvWyN7eXj169NC5c+dMY3z33Xe6evWqVq5cqQULFujAgQOaPn26JOV6jEd599135enpqY0bN6p79+4aO3asPvroI0nS0aNH1atXLzVs2FCxsbGaOXOmDh8+rJCQEGVnZ5vGWL16tcaMGaNFixapdu3aOTLi4uI0ceJE9erVS5s2bZKXl5dWrlxp2p+WlvaH3xVnZ2c1adLErAkzKytLmzdvVseOHXN9rQAAAAAAAAAAAAAAAACAJ2NtdAH/BPeaC52dnc229+/f32wZ7lKlSikuLs70uVu3bqpcubKku7MX9uzZU926dZODg4MkKTQ0VAsWLFBiYqKqV68u6W4z3dtvv63ChQurUqVKql69uqmBU5J69eqldevWKTk5WUWLFtXp06fVsGFDlSlTRtbW1po8ebJOnDihrKwsWVqa99jeuHFDq1ev1ogRI9SmTRtJkru7u86cOaPIyEj16NFDrq6ukiRHR0fT+9/bsmWL0tPTFRAQIElq1aqVFi5cqPXr16tfv34PPGfJkiXq2bOnOnfuLEnq3r27bt26pczMTMXGxurXX39VTEyM6R7PnDlTzZs318qVKzV8+HBJkqurqyZNmiQrKytVrFhRgYGB+uKLLyQp12M8SsOGDU1NrBUrVtTBgwe1dOlSBQYGKjo6WvXr19eAAQNM927WrFlq3ry59u/fL19fX0mSn5/fHzbsLlu2TIGBgerevbskqW/fvjpw4ICOHj0q6W4T5qO+K0FBQRowYIBSU1NVokQJffnll7p06ZJat26dq+sEAAAAAAAAAAAAAAAA/k2sLIyuAE8rmjBzoWjRopLuzgB5vwkTJujWrVuS7i61vWPHDrP95cuXN713dnZWt27d9NFHH+no0aNKTk42zYCZlZVlOs7FxUWFCxc2fS5YsKDc3NxMn+3s7CRJt2/fliQNGTJEkydP1urVq1WvXj09//zzCggIyNGAKUknTpxQRkaG6tSpY7bdx8dH77//vi5duqRixYo98n6sX79e1apVU6VKlSTJ9H7t2rV65ZVXcmRfvnxZFy5cUK1atcy29+7dW5I0fvx4ubu7mzW52tnZqWbNmmbLiZcrV05WVlamz05OTqb7f+zYsVyN8Sj3Ginv8fLy0s6dOyVJR44cUXJysry9vXOcl5SUZDr3/uf+IMeOHVOrVq3Mtnl7e5uaMHPzXWncuLFcXFy0adMm9e3bVxs2bJC/v7/puwoAAAAAAAAAAAAAAAAA+PPRhJkLZcuWlaurq/bv32/WPFeiRAnTeycnpxznFShQwPT+4sWL6ty5s4oWLapmzZqpfv368vT0lJ+fn9k5NjY2OcZ5UEPlPd27d9eLL76oXbt26csvv9Ts2bMVERGhjRs35miovLdktoWFedv3vcY+a+tHfx2OHj2qI0eOyMLCQs8884zZGNnZ2dq9e3eOa7q3TPvvc++v60H7MjMzzWq6vwEzr2M8yu+Pzc7ONt3/rKwstWnTRv37989x3v3Nn/c/9z+q9373P/fcfFesrKzUvn17bd68WT169NCnn36qOXPm5O4iAQAAAAAAAAAAAAAAAAD54uHdfTCxsrJSz549tXHjRtNshb/3888//+EYmzdv1pUrV7RmzRoNGDBALVq00NWrVyXlbMjLrYsXL2rixInKyMhQx44dNWPGDMXGxuqXX37R/v37cxxfsWJFWVtbKyEhwWx7QkKCXF1dH9hI+nsffvihbGxstGrVKm3cuNH0Wr16tWxsbLR69eoc5zg4OKh48eL6/vvvzbYPGjRIb7/9tqpWraqTJ0/q0qVLpn23b9/WDz/8YFrO/VHyYwxJOWr89ttvTc2mVapU0U8//aTy5cubXpmZmZoyZcojn//9qlevrm+++eahubn9rgQFBenYsWNasWKFHBwc1KhRo1zXAAAAAAAAAAAAAAAAAAB4csyEmUt9+vTRkSNH1K1bN/Xt21dNmjSRg4ODqQlu7969CgoKeuj5JUuWVFpamrZu3SofHx+dOHFCU6ZMkSSlp6fnqaYiRYpo586dOn36tF5//XU5ODiYmiRr1KiR43hHR0d17txZc+fOlZOTk2rWrKk9e/Zo1apVGjp06ENnqrwnPT1dW7ZsUcuWLVW7du0c+9u0aaONGzfq3LlzOfb17dtXs2fPlru7u2rXrq3du3crPj5e0dHReuaZZxQZGanBgwdr+PDhsrW11fz583Xz5k299NJLuboXbdq0eeIxJCkuLk41a9ZUo0aN9Omnn+qTTz5RZGSkJCkkJETdu3fX2LFj1bNnT/3222+aMGGCfvvtN7m7u+c6o2/fvnr11Ve1aNEiNW/eXLt379bHH3+s4sWLS8r9d6VChQqqXbu23n33XQUHB//hTKEAAAAAAAAAAAAAAAAAgPxHE2YuWVpaKjw8XFu3btX69eu1bNkyXbt2TcWKFZOPj49WrFihunXrPvT8F198UYcPH9a0adN048YNlS5dWp06dVJ8fLwOHTqkrl27PnZN1tbWioqK0rRp09SrVy+lpaWpevXqWrhwocqVK/fAc0aPHq2iRYtq1qxZunjxosqXL6+xY8eqc+fOj8z77LPP9Ouvv6p79+4P3B8SEqINGzZo3bp1ql+/vtm+Hj166Pbt25o7d65++eUXubu7KywsTPXq1ZMkrVixwnQdklSnTh2tXr1aZcuWzdW9KFy48BOPIUnt27fX9u3bNW3aNLm7uys8PNy0DLiXl5cWLVqkOXPmqGPHjipYsKDq1aunN99807Tkem40adJEs2bNUkREhObMmSMvLy+FhIRoy5Ytkh7vu9KxY0d9++236tChQ67zAQAAAAAAAAAAAAAAAAD5wyI7r2thA/8y/v7+6tChgwYOHGh0Kbk2b9487d2794HLwD+OlMs38qmix9N65ueG5ErS/uE5Z3P9q1y3LmxIrtONs4bkSpLFnVuG5MZeLWZIriQFutsbkrsm8ZohuZLUuqqLIblpGVmG5EqSnbWlYdlXb2caklvGwbjf4bG6nmpIbralcde8+WdjvmM1SzgakitJu0//akhuw3JFDMmVJNeCxn3HTl/L26z8T8qrdBFDcgEAAAAAAAAAwL/Xov3JRpcASX2eK290CX85ZsIE/oESEhJ06tQpLV26VBMnTjS6HAAAAAAAAAAAAAAAAAB4KtGECfwDffbZZ1q5cqWCgoIUEBBgdDkAAAAAAAAAAAAAAACAoSwtLYwuAU8pmjCB/2/Hjh1Gl5Brw4cP1/Dhw40uAwAAAAAAAAAAAAAAAACeapZGFwAAAAAAAAAAAAAAAAAAAPBPRBMmAAAAAAAAAAAAAAAAAABAHtCECQAAAAAAAAAAAAAAAAAAkAc0YQIAAAAAAAAAAAAAAAAAAOQBTZgAAAAAAAAAAAAAAAAAAAB5YG10AQAAAAAAAAAAAAAAAAAAPAkrCwujS8BTipkwAQAAAAAAAAAAAAAAAAAA8oCZMAGo5K2zhuTuG9nAkFxJSriUaVh2A3d7Q3LTbxc0JFeSZFfIkNjGRZwMyZUkWRjzHUu5kmZIriQ5Zt4wJNfB1s6QXEmyuHPTsOzCBY257kwZ99tjdxxKGJJrbeAvzJUubMzPdJayDcmVpB4VjflPlDQ7G0NyJalApnF/dtewvGRI7tXfjPuz26mQgf8mAgAAAAAAAAAAwL8OM2ECAAAAAAAAAAAAAAAAAADkAU2YAAAAAAAAAAAAAAAAAAAAeUATJgAAAAAAAAAAAAAAAAAAQB7QhAkAAAAAAAAAAAAAAAAAAJAHNGECAAAAAAAAAAAAAAAAAADkgbXRBQAAAAAAAAAAAAAAAAAA8CQsLSyMLgFPKWbCBAAAAAAAAAAAAAAAAAAAyAOaMAEAAAAAAAAAAAAAAAAAAPKAJswH8Pf3l4eHh+lVvXp1+fj4KDg4WAkJCfmWExwcrBEjRuTbeI+Snp6u119/XV5eXvLx8dHFixcf6/yYmBh5eHj8SdU9ns8++0zHjx83ugwAAAAAAAAAAAAAAAAAwFOMJsyHCAkJ0Z49e7Rnzx7t2rVLq1atUqFChdSnTx+dP3/e6PLy5PPPP9eWLVs0a9Ysbdy4UcWKFXus8wMDA7Vnz54/qbrcO3v2rPr3769Lly4ZXQoAAAAAAAAAAAAAAAAA4ClGE+ZD2Nvby9XVVa6uripevLiqVq2qCRMmKC0tTdu3bze6vDy5fv26pLszfZYpU+axzy9QoIBcXV3zu6zHlp2dbXQJAAAAAAAAAAAAAAAAAADQhPk4rK2tJUm2traSpPPnz2vYsGFq0KCBnn32Wfn5+SksLExZWVmmc3744Qe9/PLL8vb2VoMGDTR27FjdvHkzx9iZmZkaPHiw/Pz8dOrUKUnSxo0b1apVK3l6eur555/XO++8o/T09IfW9/PPP2vYsGFq2LChvLy81Lt3byUmJkqSIiIiTEufV6tW7aHLoN+8eVNvv/22GjVqJG9vb3Xv3l2HDh2SlHM58suXL2vIkCHy8fGRr6+vZsyYoZ49eyoiIkLS3WbJRYsWKSAgQDVq1FCdOnXUr18/nTlzxjSGh4eHwsLC1LRpUzVs2FAnTpxQenq6ZsyYoeeff17e3t7q3LmzaQbOlJQUNWvWTJLMsqKjo9W8eXPVqFFD/v7+evfddx/arLlv3z55eHgoPj5eL7zwgry8vNSrVy8lJSWZjsnOzlZUVJSaNWumWrVqqV27doqNjc0xRlRUlHx9fdWhQwdlZmaa5SxZskTe3t5KS0szbcvKylLjxo21bNkySVJSUpJeeeUVeXt7q1GjRnr99df1yy+/mI6/du2axo0bJz8/Pz377LNq2LChxo0bp1u3buW6DgAAAAAAAAAAAAAAAADAn4MmzFxKTU3VxIkTZW9vr8aNG0uS+vXrp8uXLys6Olrbtm1Tnz59FBkZqR07dki62zAYHBwsZ2dnrV27VvPmzdO+ffs0duxYs7GzsrL0xhtv6ODBg1qxYoXc3d119OhRjRkzRgMHDtTHH3+syZMna9OmTVq0aNED67tx44a6du2q1NRUvffee1qzZo3s7e3Vo0cPnTt3TiEhIRo1apQkac+ePRo9evQDxxkyZIg+++wzTZ48WRs3blSFChXUu3dvXb58OUfN/fr1U3JysqKiorR48WIdOnRI+/fvNx2zdOlSLViwQMOHD9fHH3+s+fPn6+TJk5o6darZWGvXrtXcuXP17rvvqmLFiho5cqR2796tGTNmaMOGDQoICFD//v21c+dOubm56YMPPpB0t7E0JCREO3bsUGRkpCZMmKDt27dr2LBheu+998yaJh/knXfe0ejRo7V27VpZW1urZ8+eptlCw8LCtGrVKo0ZM0abN29Wz549NX78eK1cudJsjJ07d2rt2rWaPHmyrKyszPa1bdtWGRkZZjOnfvHFF7p8+bJat26t1NRUdevWTWXLltWHH36oyMhI3bhxQ126dDE16r755ps6dOiQ5s6dq48//lgjR45UTEyM1q5dm+s6AAAAAAAAAAAAAAAAAAB/DmujC/i7WrBggRYvXixJunPnjtLT01WpUiWFh4erVKlSunXrltq1a6eWLVuqdOnSkqTg4GAtXLhQiYmJat68udatWycnJydNnTpVNjY2kqS3337brFExKytLI0eO1IEDB7RixQrTWCkpKbKwsFCZMmVUqlQplSpVStHR0XJwcHhgvbGxsfr1118VExMjZ2dnSdLMmTPVvHlzrVy5UsOHD5ejo6MkPXRJ8ZMnT2rnzp1atGiRnn/+eUnS2LFjVahQIV25csXs2P379+vQoUPaunWrKlasKEkKDw9X06ZNTceUK1dOU6dOlb+/vySpdOnSCggIUFxcnNlY7dq1k6enpyQpOTlZW7Zs0Ycffmja9vLLL+vo0aOKjo5WkyZNTNfn5OSkQoUK6fTp07KzszO7V8WLF1epUqUeeJ33jBgxQn5+fqZ71aRJE8XFxalt27ZasmSJpk+fbrqecuXK6ezZs4qOjlb37t1NY4SEhMjd3f2B4zs7O8vf31+xsbFq166dJGnDhg3y9/eXs7OzwsPDVbx4cbOm3PDwcNWrV0/btm1Tx44d1bBhQ/n4+KhatWqSpDJlymjFihWmGU5zUwcAAAAAAAAAAAAAAADwb2dlYXQFeFrRhPkQXbp0UXBwsCTJ0tJSRYoUMTUxSlKBAgXUo0cPbdu2TUuXLlVycrKOHj2qCxcumJYjT0xM1LPPPmtqwJSkunXrqm7duqbPW7duVUZGhipWrGjWHHlvKe6goCC5u7urQYMGatasmWrUqPHAeo8dOyZ3d3dTg6Ik2dnZqWbNmjka9h7m3nFeXl6mbba2tho5cqQk6cCBA6btR44ckZOTk6kBU5JcXFxUoUIF02d/f38dPHhQc+fOVXJyspKSkvTTTz+pRIkSZrnly5c3G1e6u9T4/TIyMlS4cOEH1t22bVutX79eL7zwgjw8PNSwYUO1aNHikU2Yzz33nOl9kSJF5O7urmPHjun48eO6ffu23nzzTdO1S//XjHtvKXBJj2x8DAoKUv/+/ZWamqpChQrp008/1Zw5c0zXmpSUJG9vb7Nzbt++bVoavVu3btqxY4c2bdqk06dP69ixYzpz5kyOXBowAQAAAAAAAAAAAAAAAOCvRxPmQzg5OZk1B/5eWlqaunfvrrS0NAUEBKhdu3Z66623zGZJtLa2loXFH7dYFy9eXLNnz1bv3r01d+5cDRs2TNLdBsply5bpyJEj2rNnj/bs2aM1a9aoffv2mjJlSo5xsrOzH5iVmZkpa+vcPeZ7xz2qZkmysrIyNZs+TFRUlCIiItSxY0c999xzCg4OVnx8fI6ZMAsUKGB6n52dLUlauXKlChUqZHacpaXlA3OcnZ21adMmfffdd9q7d6/27NmjxYsXa+DAgQoNDX1ofb+/L1lZWbK0tDTVEB4ebtZkeo+tra3pvZ2d3UPHl6RGjRrJ1dVVcXFxpkbee7OMZmVlqV69eho3blyO8xwdHZWdna3+/fsrMTFRbdq0UcuWLTV06FC99dZbOY5/VB0AAAAAAAAAAAAAAAAAgPz34K42PNLu3bt1+PBhLV++XIMGDVJgYKAcHBx06dIlUxNf5cqVdeTIEWVmZprO++STT9S4cWOlpaVJujszZq1atTRs2DAtXrxYhw4dkiTt2rVL8+bN0zPPPKO+fftq2bJlGjRokD766KMH1lO1alWdPHlSly5dMm27ffu2fvjhB1WuXDlX11SpUiVJ0vfff2/adufOHdMy3ferVq2arl+/bpqxUZKuXLmi5ORk0+f33ntPoaGhGj9+vF566SV5eXnp1KlTpvvzIFWqVJEkXbhwQeXLlze9YmJitH79ekk5m0Q3bdqk1atXq06dOho0aJDWrVunTp06PfRe3XP/dV6+fFnJycl69tlnVbFiRVlbW+vcuXNmNezatUvR0dEPbQZ9ECsrK7Vv317bt2/X9u3b1a5dO1lZWZmuNSkpSW5ubqYMJycnTZ48WceOHdORI0e0a9cuU3Nu27ZtVa5cOZ0+ffoP7yEAAAAAAAAAAAAAAAAA4K9BE2YelSxZUpIUGxurs2fPKiEhQQMGDFBGRobS09Ml3V1K+tdff9W4ceOUlJSkhIQEzZw5Uw0bNlTBggXNxnvppZdUu3ZtjRw5Uunp6bK2tta7776rJUuW6MyZM/r+++/12Wef5Vi6+p42bdqocOHCGjx4sA4dOqSjR49q+PDhunnzpl566aVcXVOFChX0wgsvaMKECfryyy918uRJjR07Vunp6apfv77Zsb6+vvLy8tIbb7yhAwcO6OjRoxo2bJjS0tJMTZJubm7au3evjh8/rhMnTigsLEzbt2833Z8HqVKlipo2bapx48YpPj5eZ86cUXR0tBYsWKCyZctKkuzt7SXdXYL9+vXrun37tqZNm6aNGzcqJSVFCQkJ2r9//0Pv1T0TJkzQ119/bard1dVVL774ohwdHdWlSxeFh4dr48aNOnPmjDZs2KAZM2aoWLFiubqX9wsKCtLBgwf1xRdfqGPHjqbt3bp10/Xr1zV06FD9+OOPOnr0qF5//XUdOnRIVapUUbFixWRtba2tW7eavgODBw/WL7/88of3EAAAAAAAAAAAAAAAAADw12A58jyqWbOmRo4cqSVLlig8PFwlSpRQYGCg3NzcdPDgQUlSiRIltHjxYs2cOVMdOnRQ4cKFFRgYqKFDh+YYz8LCQpMmTVK7du00b948DR06VO+8844WL16ssLAwFShQQH5+fhoxYsQD6ylcuLBWrFihadOmqVevXpKkOnXqaPXq1abmxdyYMmWKpk+friFDhuj27duqVauWFi9eLGdn5xzHzp07VxMnTlSvXr1kZ2enbt26KSkpSTY2NpKk6dOna+LEiQoKClKhQoVUq1YtTZgwQePHj1dKSorKlCnzwBrCwsIUFhamcePG6erVqypbtqwmTZqkoKAgSVLRokUVFBSk6dOnKzk5WWPGjNHVq1c1f/58/fzzz3JyclLLli1NS7s/TKdOnTRs2DBdu3ZN9erV07Jly0zNsSNHjpSzs7Pmzp2rCxcuqGTJkgoNDVXfvn1zfS/vKV++vLy8vJSVlWWabVSSypYtqxUrVmjWrFnq1q2brKys5OXlpaVLl8rFxUWSNHXqVEVERGjlypVydXVVkyZN1KtXL8XHxzMbJgAAAAAAAAAAAAAAAAAYzCKbTi7kweXLl3Xw4EE1atTI1HSZnp4uX19fjRs3Tu3btze2wD+wb98+9ezZU/Hx8Q9tBM1P2dnZeuGFF9S3b1916tTpT8/LizvnEg3JzXQsYUiuJH1zKdOw7AbuLobkpl9MMSRXkmRpzMTL122KGJIrSQ6WxnzHZn71syG5kjS8ThFDcrOt7QzJlSSLO7cNyzbqujOtjLvfWQb9s9XawpBYSdKBC2mG5BYtaNzvalWwvmFIbppdUUNyJalApjHPWZKsfrtkSO5vhf/8f4c/jFOhgo8+CAAAAAAAAAAA/OOs+s7AvgiYdPM27v8DGYWZMJEn1tbWGjJkiLp06aKuXbsqIyND0dHRsrW1VePGjY0u728hIyNDO3bs0FdffaUbN26oVatWRpcEAAAAAAAAAAAAAAAA/CtZWho4uwqeajRhIk8KFy6syMhIhYeHa+3atbKwsFCdOnW0bNmyBy5d/jSysbHR22+/LUmaMWOG7O3tDa4IAAAAAAAAAAAAAAAAAJCfaMJEntWrV09r1qwxuozH5uvrq8TEv2b57d27d/8lOQAAAAAAAAAAAAAAAACAv56l0QUAAAAAAAAAAAAAAAAAAAD8E9GECQAAAAAAAAAAAAAAAAAAkAc0YQIAAAAAAAAAAAAAAAAAAOQBTZgAAAAAAAAAAAAAAAAAAAB5QBMmAAAAAAAAAAAAAAAAAABAHlgbXQAAAAAAAAAAAAAAAAAAAE/C0sLC6BLwlKIJE4A+uuJkSK6HtXGT8RYvZGVY9lfJlw3JrV2kgCG5kmR5PdWQXDvnoobkSlK2hTF/xb7mW8aQXEnKtsg0KDjLmFxJN60dDMsuaND9vpZu0HOWVNTitiG5FpnphuRKUolChQzJzTYk9a6YM8ak21ldMSRXkioULWhYdkmHUobkZqYb92f37Tu/GZJb3MmYn2cAAAAAAAAAAAD8uViOHAAAAAAAAAAAAAAAAAAAIA9owgQAAAAAAAAAAAAAAAAAAMgDmjABAAAAAAAAAAAAAAAAAADygCZMAAAAAAAAAAAAAAAAAACAPKAJEwAAAAAAAAAAAAAAAAAAIA9owgQAAAAAAAAAAAAAAAAAAMgDa6MLAAAAAAAAAAAAAAAAAADgSVhZGF0BnlbMhAkAAAAAAAAAAAAAAAAAAJAHNGH+A/j7+8vDw8P0ql69unx8fBQcHKyEhIQnHn/jxo16/vnn5enpqWXLluVDxf9s2dnZWr58udq1a6eaNWuqTp066t69u7Zt22Z23Llz5xQXF/dYY3/22Wc6fvx4fparhQsXauzYsfk6JgAAAAAAAAAAAAAAAADg0WjC/IcICQnRnj17tGfPHu3atUurVq1SoUKF1KdPH50/f/6Jxn7nnXfUoEEDbdu2TR06dMiniv+55s6dq8jISPXt21dbtmzRmjVrVL9+fQ0ePFgbNmwwHffmm29q9+7duR737Nmz6t+/vy5dupQvdR4+fFiDBg3S2bNndePGDY0dO1Yff/xxvowNAAAAAAAAAAAAAAAAAHg0mjD/Iezt7eXq6ipXV1cVL15cVatW1YQJE5SWlqbt27c/0djXrl3Tc889p9KlS8vR0TGfKv7nWrVqlfr06aNWrVqpXLlyqlKlikJDQxUYGPhEM4VmZ2fnY5WSm5ub/P399dlnn+mzzz7TM888oxo1auRrBgAAAAAAAAAAAAAAAADg4WjC/AeztraWJNna2kqS0tPTNWPGDD3//PPy9vZW586dtWfPHtPxMTEx8vf31zvvvCMfHx/1799fHh4ekqRRo0aZ3t+6dUvh4eFq1qyZPD091b59e3366ad/OM6+ffv0zDPP6KuvvlJgYKA8PT310ksv6eTJk3rvvffUoEEDPffcc5o0aZKpGTE7O1uLFi1SQECAatSooTp16qhfv346c+aMKcvDw0Pr1q3Tyy+/rJo1a+r555/XggULzO7D3r171aVLF9WqVUuNGzfWrFmzlJmZmat78iCWlpb66quvlJaWZrZ99OjRioiIkCQFBwdr//792rBhg/z9/SVJ58+f17Bhw9SgQQM9++yz8vPzU1hYmLKyspSSkqJmzZpJknr27KmIiAjt27dPHh4eSklJMWWkpKTIw8ND+/btkyRdunRJgwYNkq+vr2rWrKkuXbpo//79kiRnZ2ddvXpV5cqVU/PmzXXkyBGVLl36D68NAAAAAAAAAAAAAAAAAJB/aML8h0pNTdXEiRNlb2+vxo0bS5JGjhyp3bt3a8aMGdqwYYMCAgLUv39/7dy503Te2bNnlZqaqg0bNuj11183NSSOGjXK9H7o0KHauHGjRo8erdjYWDVv3lyhoaGKj49/6DiSlJmZqalTp2ry5Mlat26dLl26pC5duigpKUnLly/X0KFDtWLFClM9S5cu1YIFCzR8+HB9/PHHmj9/vk6ePKmpU6eaXev06dPVvn17bdq0SUFBQZo9e7YSEhIkSQcPHlSfPn3k5eWlmJgYTZ48WR988IHmzp2b63vye/369dPOnTvVqFEjDRw4UEuWLFFiYqJcXFxUpkwZSVJERIS8vb0VEBCgDz/80HTe5cuXFR0drW3btqlPnz6KjIzUjh075Obmpg8++MB0bkhISK6e8/jx43Xr1i2tWLFCmzdvVoUKFTRgwADdvHlTklSrVi1NmjRJY8aMkZ+fX67GBAAAAAAAAAAAAAAAAADkD2ujC0DuLFiwQIsXL5Yk3blzR+np6apUqZLCw8NVqlQpJScna8uWLfrwww/l6ekpSXr55Zd19OhRRUdHq0mTJqaxBgwYoLJly5qN7+joKFdXVyUlJSk+Pl6RkZFq2rSpJCk0NFSJiYmKjIw0zeb4+3Huzdz4v//9T15eXpKkF154QcuWLdOkSZNUsGBBVapUSREREfrpp5/UtGlTlStXTlOnTjXNJFm6dGkFBAQoLi7OrLYOHTqoXbt2kqTBgwdr1apV+uabb+Tj46Nly5apZs2aGjFihCSpUqVKmjRpki5cuPBY9+R+vXr1UpUqVbRmzRp98cUXpuXePT09NXXqVFWuXFlFihSRjY2NChQoIGdnZ926dUvt2rVTy5YtTbNRBgcHa+HChUpMTFTz5s3l7OwsSXJyclKhQoUe+cwl6fTp06patarKlSsnOzs7jR49Wm3atJGVlZUkme61JLNnAwAAAAAAAAAAAAAAADxNLC0sjC4BTymaMP8hunTpouDgYEl3l8suUqSIHB0dTfuPHDki6e5S1/fLyMhQ4cKFzba5u7s/NCcxMVGSVKdOHbPtPj4+mjVr1iPHqVChgul9wYIFVaxYMRUsWNC0zc7OTrdv35Yk+fv76+DBg5o7d66Sk5OVlJSkn376SSVKlDAbs1KlSmafHRwclJGRYaq3QYMGZvtbtGghSdq6dauk3N2T32vYsKEaNmyozMxMHT58WDt27NCKFSvUp08fbd++3bQE/D0FChRQjx49tG3bNi1dulTJyck6evSoLly4oKysrD/M+iOhoaEaPny4PvnkE/n4+KhRo0YKDAyUnZ1dnscEAAAAAAAAAAAAAAAAAOQPmjD/IZycnFS+fPmH7s/OzpYkrVy5Mscsi5aW5qvOFyhQ4LHzs7KyZG1t/nV50Di/P+b32feLiopSRESEOnbsqOeee07BwcGKj4/PMRPm7xsepf+7Xmtra1k8pIv9ce7JPUePHtXatWs1cuRI2draysrKSjVr1lTNmjXl7e2tvn37KjEx0TSz5j1paWnq3r270tLSFBAQoHbt2umtt95S9+7dH3r9v69TujvL6f1atGih3bt3a/fu3friiy+0aNEizZkzR+vWrVOVKlUeOTYAAAAAAAAAAAAAAAAA4M/z8A45/KPca8i7cOGCypcvb3rFxMRo/fr1uR6natWqkqRvvvnGbHtCQoIqV66cfwVLeu+99xQaGqrx48frpZdekpeXl06dOmXWlPgolSpV0vfff2+2bcmSJerQoUOe78mqVav06aef5tju4OAgCwsLubi45Ni3e/duHT58WMuXL9egQYMUGBgoBwcHXbp0yXQ9v28WtbGxkSTduHHDtC05Odn0Pj09XVOmTNGZM2cUGBiot99+W5988oksLS21c+fOR9wZAAAAAAAAAAAAAAAAAMCfjSbMf4kqVaqoadOmGjdunOLj43XmzBlFR0drwYIFKlu2bK7HqVy5svz8/DRhwgR99tlnOnnypObNm6f4+HiFhITka81ubm7au3evjh8/rhMnTigsLEzbt29Xenp6rsfo06ePDhw4oPDwcJ08eVK7du3SggUL1KxZszzdk2rVqqlt27YaPXq0oqKidPz4cZ06dUrbtm3TqFGj1KFDB5UqVUqSVKhQIZ09e1bnz59XyZIlJUmxsbE6e/asEhISNGDAAGVkZJiux97eXpJ07NgxXb9+XVWrVlWhQoX03nvvKTk5WV9//bXCwsJMzZq2trY6ePCg3nrrLR04cEApKSmKiYnRb7/9Jm9v7zzfdwAAAAAAAAAAAAAAAABA/mA58n+RsLAwhYWFady4cbp69arKli2rSZMmKSgo6LHHmT17tsaMGaNr166pSpUqioiIUIsWLfK13unTp2vixIkKCgpSoUKFVKtWLU2YMEHjx49XSkqKypQp88gxqlevrvnz52vu3LlatGiRXF1dFRwcrP79+5uu5XHvyZQpU1SjRg1t2rRJ7733njIyMlSuXDl16tRJ//3vf03HdenSRW+++abatm2rL7/8UiNHjtSSJUsUHh6uEiVKKDAwUG5ubjp48KAkqWjRogoKCtL06dOVnJysMWPGaObMmZo1a5ZatWqlChUqaOTIkerTp48pY86cOZoyZYpeffVVXb9+XRUrVtSsWbPk4+OT19sOAAAAAAAAAAAAAAAAAMgnFtmPs/YzgH+l2CPnDcn1KGZvSK4kWf1uefi/0sWbGYbk1i6SZUiuJFleTzUk95ZzRUNyJcnaoK/YrUzj/lovaJFpTHC2cd/tNNkYlm3U/f71jnETqRe1uG1IrkVm7mfpzm9nMwsZkmvkfyDsP3vNkFw7K+O+2xWKFjQsu6SDMX+OZRr3R7dsDHrUxZ2M+XkGAAAAAAAAAOBpseGHn40uAZI61HAzuoS/HMuRAwAAAAAAAAAAAAAAAAAA5AHLkQMAAAAAAAAAAAAAAAAA/tGsLI1bFRVPN2bCBAAAAAAAAAAAAAAAAAAAyAOaMAEAAAAAAAAAAAAAAAAAAPKAJkwAAAAAAAAAAAAAAAAAAIA8oAkTAAAAAAAAAAAAAAAAAAAgD2jCBAAAAAAAAAAAAAAAAAAAyAOaMAEAAAAAAAAAAAAAAAAAAPKAJkwAAAAAAAAAAAAAAAAAAIA8sDa6AAAAAAAAAAAAAAAAAAAAnoSlhYXRJeApRRMmANUt5WhIbnpmtiG5kvTzjXTDsr/7+ZohuSUKuRiSK0mlnEobknszI8uQXEkqeuuCIbnWjiUNyZWkLEsbQ3Ktbt8wJFeSbhn4TynHKycMyXUuYszPsyTJoL82suyM+XtSkpyzjZm4/sJvdwzJlaRqxQoZkutga2VIriSVKWTcAgUXbxnzg2Vnbdw1F7bMMCR3ZNwRQ3IlaUqrZwzLBgAAAAAAAAAA+LdjOXIAAAAAAAAAAAAAAAAAAIA8oAkTAAAAAAAAAAAAAAAAAAAgD2jCBAAAAAAAAAAAAAAAAAAAyAOaMAEAAAAAAAAAAAAAAAAAAPKAJkwAAAAAAAAAAAAAAAAAAIA8sDa6AAAAAAAAAAAAAAAAAAAAnoSVhdEV4GnFTJgAAAAAAAAAAAAAAAAAAAB5QBMmAAAAAAAAAAAAAAAAAABAHtCEmUfBwcHy8PB46OuXX34xukST4OBgjRgxwvAxHtfNmze1cuVK0+cRI0YoODj4T83ct2+fPDw8lJKS8qfm5JcDBw7oxRdfNLoMAAAAAAAAAAAAAAAAAHgqWRtdwD9ZQECARo8e/cB9Li4uf3E1/z6LFy9WTEyMunfvbnQpfzsZGRkaMGCA6tSpI1tbW0VERCgzM1ODBw82ujQAAAAAAAAAAAAAAAAAeGrQhPkEChQoIFdXV6PL+NfKzs42uoS/rezsbHXp0kXvv/++EhMT5efnp5YtWxpdFgAAAAAAAAAAAAAAAAA8VViO/E/m7++vhQsXauDAgfL29pavr68mT56sO3fumI754Ycf9PLLL8vb21sNGjTQ2LFjdfPmTUl3m+2ioqLUrFkz1apVS+3atVNsbKzp3HvLZ8fHx+uFF16Ql5eXevXqpaSkJLM6fvvtN40aNUo+Pj6qU6eORowYYcqQpB07dqhLly7y9vaWp6en/vOf/+iLL7546HUlJSWpf//+8vX1VZ06dTRo0CCdO3fOtD84OFiTJ0/WG2+8IS8vLzVu3FgLFy40a6z8o8yIiAjNmzdPZ8+eNVsePCMjQ9OmTVP9+vXl5eWlAQMG6OLFi5KkAQMGqGfPnmZ1njhxQh4eHjp69OgDryMhIUGdOnVSzZo11b59eyUmJprtf9T9v/f8unfvrlq1aqlZs2aKjY3VM888o3379pnuxahRo9SpUyf5+Pho48aNkqT169crICBANWvWVEBAgJYuXaqsrCzTuKmpqRoyZIh8fHzk6+ur/v3769SpU5IkW1tbFStWTKdOndKwYcO0d+9eVaxY8aHPCwAAAAAAAAAAAAAAAACQ/2jC/AtERESobt262rBhgwYOHKhly5Zpy5YtkqSUlBQFBwfL2dlZa9eu1bx587Rv3z6NHTtWkhQWFqZVq1ZpzJgx2rx5s3r27Knx48dr5cqVZhnvvPOORo8erbVr18ra2lo9e/bU9evXTfu3b9+uYsWKKSYmRtOnT9dHH32kqKgoSXebCF977TW98MILio2N1QcffCAXFxcNGzZM6enpOa7n7Nmzeumll2Rra6ulS5fq/fff16VLl9SjRw/duHHDdNyqVatUsGBBrV+/XkOGDNG7776b68yQkBCFhISoZMmS2rNnj9zc3CRJ3333na5evaqVK1dqwYIFOnDggKZPny5JCgoK0v79+82aQTdu3Khnn31W1apVy3EdZ86cUUhIiKpXr64NGzbo1Vdf1bvvvmt2zKPuf2pqqv773/+qdOnSWr9+vcaOHauwsDBlZmaajRMTE6OePXtq9erV8vPz09q1azVt2jS99tpriouL0+DBgxUVFaWZM/8fe3ceHePd/3/8NdkQIiSCIIQgKCF2UlKJtmKrtXY3KeVWtLaS2lWtsUZbbmIvqgSxVVU1rd4tRe1iiX3fl5BNJr8//MzXSBCxXO3t+Thnzslcy+f1vq6ZTKanb59PqCTp7t27ateunZKTk7Vw4UItWLBAOXPm1Pvvv6+LFy9KkvLmzatx48apc+fO6tChgzJlypTGuw8AAAAAAAAAAAAAAAAA8LKwHPlzWL16tTZs2JBqe61atTRx4kTL8xo1alhmaPT09NSyZcu0c+dONWrUSEuXLpWzs7PGjBkje3t7SdLIkSO1bds23b17V3PnztW4ceNUq1YtSVLBggV19uxZhYeHq02bNpaMAQMGyN/fX5IUGhqqt956S2vXrlXLli0lSWXKlFHv3r0tY/j5+Wnfvn2SJFtbWw0aNMhqvPbt2ys4OFhXr161NEA+sGjRIjk6Oio0NFQODg6SpKlTpyogIECRkZFq3bq1JKlIkSIaNmyYTCaTvLy8FBMTo/nz56tz587pynR0dJStra3Vku9ubm76/PPPZWtrqyJFiqhu3bqW2TP9/f2VK1curV69Wl26dJHZbFZkZKQ6deqU5uu3dOlS5cqVS0OHDpWtra28vLx0/vx5jR49WpLSdf+//fZbZc+eXV988YXs7e1VtGhRDR48WP/+97+tskqWLKkGDRpYnn/11Vfq0qWL6tevL0ny8PBQbGyshg8fro8//lhr167V9evXNWHCBMv74osvvtDWrVu1dOlS9ejRQ3ny5FGePHkkSQ0bNkzzGgEAAAAAAAAAAAAAAIDXgY3JZHQJeE3RhPkcAgIC1Ldv31TbHR0drZ57eXlZPXdyclJSUpIk6dChQ3rjjTcsjXaSVKlSJVWqVEl79uxRQkKC+vfvr5CQEMv+e/fuKTExUfHx8ZZtlStXtvycI0cOeXp66vDhw5ZthQsXtqrB2dlZZ8+elXS/QdDZ2VkzZ87U8ePHdeLECR08eFCSUs3oKEmHDx9W6dKlLQ2YkuTq6qrChQtbLedduXJlmR76cCtXrpxmzpyp69evP3PmAwULFpStra3VdTy4D3Z2dmrYsKFWrVqlLl266I8//tCVK1csjY5pXUepUqWsxitfvrzl56NHjz71/h84cCDV61exYsVUWYUKFbL8fO3aNV24cEFTpkzRtGnTLNvNZrMSEhJ05swZHThwQLGxsVavqyQlJCSkWmoeAAAAAAAAAAAAAAAAAGAMmjCfQ9asWa2a6x7n4WbFB1JSUiTdbxw0PaYL+8ExkydPVpEiRZ44rp2d9UtpNptlY/N/q80/3Gj4qD///FPBwcHy9/dXxYoVVa9ePcXFxemjjz56bF1p1ZycnGzVjPhoTQ+ux9bW9pkz03Md0v0lycPDw7Vv3z5FRkYqMDBQOXLkeOzxD2pKq+b03H9bW1uZzeYn1iRJmTNntvz84PiQkBBVr1491bHu7u4ym80qXLiwvv7661T7H23yBQAAAAAAAAAAAAAAAAAYw+bph+BlKlq0qA4cOGA1++PGjRtVs2ZNFSlSRHZ2djp37pwKFSpkeURFRSk8PNyqyXLv3r2Wn69du6aTJ0/qjTfeSFcN4eHhqlKliqZNm6YOHTrIz89P58+fl5S6SVGSihcvrj179igxMdGy7cqVKzp58qTVrJ8P1yRJO3fuVIECBeTs7JyuzMc1pz6Jl5eXfH19tW7dOm3evFlNmjR57LElS5bU3r17ra7j4ZrTc/9LlCih/fv3W2Y2laTdu3c/sUZXV1e5urrq1KlTVuPu379fkydPlnT/Hp87d05OTk6W/fnz59eECRP0559/PvN9AQAAAAAAAAAAAAAAAAC8eDRhPof4+Hhdvnw5zUdCQkK6xmjdurWuX7+uoUOHKiYmRtu3b1doaKj8/Pzk5OSkli1bavLkyVq5cqVOnz6tFStWaPz48cqVK5fVOMOHD9eff/6p6Oho9e3bV25ubqpTp066anB3d9ehQ4e0fft2nTlzRsuXL9eUKVMkyapB8YFWrVopNjZWffv2VXR0tPbs2aOPP/5YOXPmVL169SzHbd++XVOnTtXx48e1bNkyffPNN+rUqVO6Mx0dHXXz5k0dP37cqsnxaZo2bapvvvlGDg4OevPNNx97XKtWrRQXF6fPPvtMMTEx2rx5s9Xy4Om5/61bt9bt27c1ePBgxcTE6Pfff9eIESMkPb6J1GQyqVOnTlqwYIEWLFigU6dO6ccff9Tw4cPl4OAgBwcHNWzYUM7Ozurevbt27dqlmJgYhYSEKCoqSsWKFUv3vQAAAAAAAAAAAAAAAAAAvDwsR/4c1q9fr/Xr16e5b+LEiVYNiY+TJ08ezZ49W6GhoWrcuLGyZ8+uunXrqnfv3pLuL1nt4uKiqVOn6tKlS8qbN6+6d++uDz/80Gqc5s2bq2/fvrp165aqVq2q+fPnK0uWLOm6jp49e+rKlSvq2rWrpPuzc44aNUr9+vXTnj17rGa3lCQPDw8tWLBAoaGhatGihRwcHOTn56fx48cre/bsluMCAwN15MgRvffee8qdO7cGDBigVq1apTvznXfe0dKlS9WwYUMtXLgwXdciSUFBQRo5cqQaNWr0xOXL8+TJo3nz5mnUqFFq3Lix3N3d9e9//1vDhw+3HPO0++/q6qpZs2Zp1KhReu+995Q3b161atVK48aNs1qa/VHBwcHKlCmTFixYoLFjx8rV1VVNmjRRr169JN1vAF24cKHGjRunTp06KTk5WSVLllR4eDhNmAAAAAAAAAAAAAAAAADwN2FKSWu9afxjbN26Ve3bt9emTZtUoEABo8uxaNeunfLnz68xY8a88uwzZ87o7bff1vr16+Xp6flSs44ePaqbN2+qQoUKlm07d+5Uq1at9PPPP8vd3f2l5r8o52/cMSQ3Mdm4j5/zsalneX1V/jp/y5DcOkVdDcmVpHyZkg3JvWl+fDP0y5Yz/pIhuQlOeQ3JlSRbm7RnAH7puQmxhuRK0jWl7x88vAxuN44akpucI78huUYy2xv3OiekGDNx/aU79wzJlaQ7Scb8zcjm8Ph/vPOyFchq3AIFV+KN+T6Wyc64a85uk/5Z9l+kYVFnDcmVpNH1ShmWDQAAAAAAAADAq7LhkDH/nx7W3vXObXQJrxwzYeJ/xvnz57Vnzx4tWrRINWrUeOkNmJJ08eJFffjhh/riiy9UqVIlXbp0SaNHj1blypX/MQ2YAAAAAAAAAAAAAAAAAICMoQkT/zOuX7+uAQMGyNPTU9OmTXslmX5+fho4cKBmzJihwYMHy8nJSQEBAerbt+8ryQcAAAAAAAAAAAAAAABg3OqNAE2Y/3BVqlTRoUOHjC4jlQULFrzyzFKlSumvv/565bmtW7dW69atX3kuAAAAAAAAAAAAAAAAAMBYNkYXAAAAAAAAAAAAAAAAAAAA8E9EEyYAAAAAAAAAAAAAAAAAAEAG0IQJAAAAAAAAAAAAAAAAAACQATRhAgAAAAAAAAAAAAAAAAAAZABNmAAAAAAAAAAAAAAAAAAAABlgZ3QBAAAAAAAAAAAAAAAAAAA8DxuT0RXgdUUTJgCduZVoSG4mO+Mm4y3mktmwbK+cxmRnt0kyJFeSkm2NuebLN4x5b0tSDkcnQ3JvxCcbkitJeRIvGpJ7PUteQ3IlKau9cZ9jN1yKGZJrTjEkVpJxn2O2ty8ZkitJe+5kNyTXnGLcC33gcqwhuZXz5zAkV5LyO9kblu1ga8zfje+PXjMkV5Le93Y2JNczV1ZDciVp6Z5zhuS+75PPkFwAAAAAAAAAAIBXieXIAQAAAAAAAAAAAAAAAAAAMoAmTAAAAAAAAAAAAAAAAAAAgAygCRMAAAAAAAAAAAAAAAAAACADaMIEAAAAAAAAAAAAAAAAAADIAJowAQAAAAAAAAAAAAAAAAAAMoAmTAAAAAAAAAAAAAAAAAAAgAywM7oAAAAAAAAAAAAAAAAAAACeh63JZHQJeE0xEyYAAAAAAAAAAAAAAAAAAEAG0IQJAAAAAAAAAAAAAAAAAACQATRh4pnFxsaqbNmyql69uhITE1/YuBEREfL29rY8P3funNauXfvCxs9IDX93a9eu1QcffGB0GQAAAAAAAAAAAAAAAADwXMxms6ZOnaoaNWqobNmyCg4O1smTJx97/JEjR/Thhx+qSpUqqlatmnr27Klz585ZHRMQECBvb2+rR9++fV9o3TRh4pmtXbtWrq6uio2N1caNG1/YuHXr1tWWLVssz/v3769ff/31hY3/v+TKlSvq3LmzDh48KLPZrLFjx2rhwoVGlwUAAAAAAAAAAAAAAAAAGfLVV19pyZIlGjlypL799luZTCZ17tw5zYkCr1+/ro4dOypr1qxauHChZs6cqevXr6tTp05KSEiQdH+ywXPnzmnGjBnasmWL5TF06NAXWjdNmHhmy5cv15tvvqlq1appyZIlL2zczJkzy83N7YWN978sc+bMatKkiaKiorR161a5urqqWrVqRpcFAAAAAAAAAAAAAAAAAM8sMTFRs2fPVo8ePeTv768SJUpo0qRJunjxYpoTBf7444+Ki4vTmDFjVKxYMZUuXVrjx49XTEyMdu7cKUk6fPiwUlJSVL58ebm5uVkeTk5OL7R2mjDxTGJiYrR79275+fmpTp062rZtm2JiYiz7T5w4oQ8++EAVKlSQr6+vPvjgAx06dMiy/+7duxo5cqTefPNN+fr6qk2bNtqzZ48k66XA27Vrp23btmnFihUKCAiQdP8Xbfz48apRo4Z8fX31/vvvW82cmZycrPHjx8vf31+lS5dWnTp1tHjx4idez8aNG9WgQQP5+Piobdu2qaajfVqmJG3ZskVNmjSRj4+P6tWrp2XLlsnb21tnzpyRdH9K21GjRqlu3bqqUqWK/vjjD6WkpGjmzJkKDAxU2bJl9d577ykyMjLVve7cubN8fX315ptvqk+fPrp8+bIkKVu2bLKzs1NiYqI6duyobdu2ydPT86mvHwAAAAAAAAAAAAAAAAD83URHR+vOnTuqWrWqZVv27NlVqlQp/fnnn6mOr1atmr788ktlypQp1b6bN29Kkg4dOiQ3Nzdlz5795RUuye6ljo7/OcuWLZOjo6Nq1qype/fuycHBQYsXL9agQYMkSb1795a3t7eWL1+ue/fuaezYserevbulG7lXr146evSoRo0apUKFCmnmzJn64IMPtGHDBqucsLAwde3aVXnz5tWQIUMkSSEhITpy5IjGjx+vvHnzavPmzerataumTZumt956S4sWLdL333+vSZMmKU+ePNq8ebOGDRumYsWKqWLFiqmuZefOnerRo4c++ugj1a9fX9u3b9fnn39udczTMg8ePKguXbroX//6l0JDQxUdHa1hw4alylq8eLFmzJghJycneXt7a9KkSVq9erWGDBkiLy8v/fnnnxo2bJhu376tNm3a6OLFi2rdurXq1aunAQMGKC4uTmFhYWrZsqVWr14tR0dHeXl5afz48SpRooR++OEH2dravoiXGAAAAAAAAAAAAAAAAAAyJDAw8In7N23alOb2CxcuSJLc3d2ttufOnVvnz59PdXyBAgVUoEABq20zZsxQpkyZVKlSJUn3Z8J0dHRUjx499Ndff8nFxUVNmjRR+/btZWPz4uavpAkT6Xbv3j2tXr1atWrVUpYsWSRJ/v7+WrVqlfr06aMsWbLo1KlT8vPzU4ECBWRnZ6dRo0bp2LFjMpvNOnnypH7++WfNmjVLNWrUkCQNGTJEWbNm1Y0bN6yycuTIIXt7e2XOnFkuLi46efKk1qxZo2XLlqlMmTKSpI4dOyo6Olrh4eF66623dOrUKTk6OsrDw0Nubm5q27atihQposKFC6d5PQsXLlT58uXVo0cPSVLhwoV1+PBhzZ8/X5LSlTl37lyVLl1an376qSSpSJEiunr1qkaOHGmV5e/vr+rVq0u6Pxvo3LlzNW7cONWqVUuSVLBgQZ09e1bh4eFq06aNFi9erNy5c1saUCVp8uTJqlq1qr7//ns1adJERYoUseyrX7/+M76aAAAAAAAAAAAAAAAAwP8OG5PJ6BLwHOLi4iRJDg4OVtszZcpkmdnySebPn69FixYpJCRErq6ukqQjR47o9u3bqlu3rrp3767t27crNDRUN2/e1Mcff/zCaqcJE+kWFRWly5cvq27dupZtdevW1caNG7V27Vo1a9ZMvXr10qhRo7R48WJVrVpVNWrUUFBQkGxsbCzLkpcrV85yvoODg0JCQiRJu3btemz2gQMHJEnt27e32p6UlGSZLrZNmzb68ccfVbNmTZUuXVp+fn4KCgqy/FI96vDhw/Lz87Pa5uvra2nCTE/mgQMHLM2VD6Q162ahQoUsPx89elQJCQnq37+/5dql+02uiYmJio+P14EDBxQTEyNfX1+rcRISEqyWfwcAAAAAAAAAAAAAAACAv4vHzXT5NJkzZ5YkJSYmWn6W7vdLPZgwMC0pKSmaMmWKvv76a3Xp0kUdOnSw7JszZ44SEhKULVs2SZK3t7fu3Lmjr7/+Wj169Hhhs2HShIl0i4iIkCT17Nkz1b4lS5aoWbNmatOmjerUqaOoqCj9/vvvmjhxosLCwrRy5UrZ2d1/u5ky0HWekpIiSfrmm2+UNWtWq30Pfhk8PT31ww8/aNu2bfrtt9+0adMmTZ8+XaNHj1bjxo2fOO4D9vb2z5Rpa2srs9n81Pof/mB4MO7kyZOtZrN8wMHBQWazWVWrVtXQoUNT7XdycnpqHgAAAAAAAAAAAAAAAAD8UzxYhvzSpUsqWLCgZfulS5dUokSJNM9JSkpSSEiI1qxZo08//VQffPCB1X57e3urfjBJKl68uO7evaubN28qZ86cL6T2F7ewOf6nXbt2TVFRUWrSpIlWrlxp9WjWrJn27t2r3bt3a8SIEUpKSlKTJk00fvx4RUZG6vLly9q2bZu8vLwkSXv37rWMe+/ePb311ltau3btE/OLFSsm6f4vVaFChSyPiIgILV++XNL9KWV/+OEH+fn56dNPP9Xq1atVrVo1rVu3Ls0xS5YsqZ07d1pte7i29GSWKFFCu3fvthrj0eePKlKkiOzs7HTu3DmrcaOiohQeHi4bGxsVK1ZMMTExcnd3t+x3dnbWqFGjdPjw4SeODwAAAAAAAAAAAAAAAAD/JCVKlFC2bNm0detWy7Zbt27pwIEDaa5MLEmffvqpvv/+e02YMCFVA6bZbFZAQIC+/vprq+179+5Vrly5XlgDpkQTJtJp1apVunfvnjp16qTixYtbPbp27SpbW1stWbJEP//8swYNGqSDBw/q9OnTWrRokezt7VW6dGkVLlxY77zzjoYPH67ff/9dx48f15AhQ5SYmKhq1aqlysyaNavOnj2rCxcuqFixYqpVq5aGDh2qTZs26fTp0woPD9eMGTPk4eEhSbp69apGjBihTZs26ezZs/rll1904MCBVEt6PxAcHKzo6GiNHTtWx48fV2RkpL755hvL/vRkBgcHa9++fQoNDdXx48f1448/asqUKZIeP+Onk5OTWrZsqcmTJ2vlypU6ffq0VqxYofHjxytXrlySpNatW+v27dvq3bu3Dh48qOjoaPXp00d79uyxNIcCAAAAAAAAAAAAAAAAwP8CBwcHtW3bVqGhodq0aZOio6PVq1cv5c2bV2+//baSk5N1+fJlxcfHS7q/qvO6devUq1cvVa5cWZcvX7Y84uPjZWNjo3fffVezZs3S+vXrderUKX377beaNWuWPv744xdauynl0fWYgTQ0aNBAbm5umj17dpr7P/74Y/3yyy9avHixJk6cqN27dysuLk4lS5bUxx9/rOrVq0uSYmNjNW7cOP3www9KSEhQ2bJlNWDAAJUoUUIREREKCQnRoUOHJEk///yz+vfvr5SUFP3+++9KTEzUpEmTtG7dOt28eVMeHh7q2LGjmjdvLun+9LKTJ0/W2rVrdeXKFbm5ualRo0bq3r27bG1t06z7999/1/jx43XkyBEVK1ZMQUFBCg0NtdQQFxf3xExJ+umnnzRx4kSdOHFChQsX1rvvvquwsDD9+uuvyp07twICAtS4cWP16NHDcs69e/c0Y8YMLV++XJcuXVLevHnVvHlzffjhh5bmzQMHDmjChAnauXOnbG1tVa5cOX366acqXrz4c76aqf156voLHzM9MtkZ1wee38n+6Qe9JGaDPnWz2yQZEywp2TaTIbnHbyQakitJxRyNyb6UnNmQXEnKk3jRkNzrWfIakitJWeyN+xxLTDbmw8SozzDJuM8xmzvXDMmVpD/uZDck12zgfyIcuBxrSG7l/DkMyZWkUm7GfXbfTkg2JHdDjDHfPyXpfW9nQ3Ln7jPusyRnFmO++77vk8+QXAAAAAAAAADA6+nXY1eNLgGSahRxzfC5ycnJmjhxoiIiIhQfH69KlSppyJAhKlCggM6cOaPAwECNHj1aTZo0UXBwsH777bc0x3lwzL179zRz5kwtX75cFy5cUIECBRQcHKz3338/wzWmhSZM4Dns2bNHdnZ2KlWqlGXb6tWr9dlnn+mvv/6SnZ2dgdWlH02YrxZNmK8OTZivFk2YrxZNmK8OTZivFk2YrxZNmK8OTZgAAAAAAAAAALxcNGH+PTxPE+Y/1T+jQwz4m4qOjta4ceM0duxYlSxZUidPnlRYWJjq1av3j2nABAAAAAAAAAAAAAAAAP7pbI2bQwevObrEgOfQvHlzXbp0SaNGjdLFixfl6uqqevXqqWfPnkaXBgAAAAAAAAAAAAAAAAB4yWjCBJ6DyWRS9+7d1b17d6NLAQAAAAAAAAAAAAAAAAC8YkzCCgAAAAAAAAAAAAAAAAAAkAE0YQIAAAAAAAAAAAAAAAAAAGQATZgAAAAAAAAAAAAAAAAAAAAZQBMmAAAAAAAAAAAAAAAAAABABtCECQAAAAAAAAAAAAAAAAAAkAF2RhcAAAAAAAAAAAAAAAAAAMDzsDGZjC4BrymaMAGoZK7MhuQeu5FoSK4kZTMlGZZ9ONaY3Bx2N40JlmSyNebPjVOm7IbkStKpxEwGJacYlCtddMhjSK6b7T1DciUpSQ6GZRv1nw85bx03KFlKdPUyJNfWbOB7zGw2JNfJwbj/TMif3ZjvJfa2xv1HuU1SvGHZDrbGfI555shiSK4kmW3tDckt727c9xKnTLaG5B66dMuQXEnyzm3c/QYAAAAAAAAAAK8XliMHAAAAAAAAAAAAAAAAAADIAJowAQAAAAAAAAAAAAAAAAAAMoAmTAAAAAAAAAAAAAAAAAAAgAygCRMAAAAAAAAAAAAAAAAAACADaMIEAAAAAAAAAAAAAAAAAADIAJowAQAAAAAAAAAAAAAAAAAAMsDO6AIAAAAAAAAAAAAAAAAAAHgetiaT0SXgNcVMmAAAAAAAAAAAAAAAAAAAABnwt2nCHDBggNq1a/dM52zevFlHjx59SRWlX1JSkubOnWt5HhYWpoCAgFdaw9PuX7t27VS+fHmdO3cu1T4j6k0vb29vRURESHo1dQYEBCgsLOyJ+729va0ePj4+evfddzVt2jSZzeZ0Z6WkpGjFihW6evWqJCkiIkLe3t7PVO/ly5dVpkyZZzoHAAAAAAAAAAAAAAAAAPBi/G2aMJ/V2bNn1bVrV0sDm5HWrFmj0aNHW54HBwdr2bJlBlaUtjt37mjQoEFGl5Fhf5f7GhwcrC1btlgeK1asUIMGDRQWFqY5c+ake5w///xTAwYMUFxcnCSpbt262rJlS7rP/+STT7R+/Xo5Oztr9uzZGjJkyDNfCwAAAAAAAAAAAAAAAAAg4/6xTZgpKSlGl2DxaC1Zs2aVi4uLQdU8noeHh3777Td9++23RpeSIX+X++ro6Cg3NzfLw8vLS927d1eVKlW0du3adI/z6Psmc+bMcnNzS/f5TZs21bZt23T58mXFxMSoQYMG6T4XAAAAAAAAAAAAAAAAAPD8/rZNmAEBAfrPf/6jHj16yNfXV1WqVNGoUaN07949nTlzRoGBgZKk9u3bW5aPjomJUefOneXr66s333xTffr00eXLly1jtmvXTp999pmaN2+uihUrauXKlRowYID69eunsWPHqlq1aipbtqy6detmdd6OHTvUsWNHVahQQaVLl1b9+vW1Zs0aSfeXkA4JCZF0f+nsrVu3plo2+/z58+rbt6/8/PxUrlw5ffDBBzp06JBl//PWkF4VK1ZU06ZNNXbs2DSXJX8gPj5ekydPVmBgoMqUKaNGjRrpxx9/tOyPiIhQQECAvvjiC1WsWFFdu3bV1q1bVapUKf3xxx+qW7euypQpoxYtWuj48eP6+uuvVb16dVWuXFmff/65pfkwJSVFs2bNUlBQkEqXLq0KFSqoS5cuOn36dJp1PXpfV65cqXr16qlMmTKqUaOGvvjiCyUmJlr279y5U23atJGPj4/eeustDR8+XLGxsZb9t2/fVv/+/VWxYkVVq1bNakn5jMiUKZNsbP7vV+rIkSPq1q2bqlSpotKlS+vtt9/WvHnzJElbt25V+/btJUmBgYGKiIhItRz5jRs3NHz4cPn7+8vHx0etWrXS9u3bLfs9PT21a9cuDRkyRL///rsKFy78XPUDAAAAAAAAAAAAAAAAAJ7N37YJU7rfdFepUiWtWLFCPXr00Pz587VmzRq5u7vru+++sxwTHBysixcvqnXr1vLw8NCyZcs0ffp0xcbGqmXLlrp7965lzIiICLVv316LFy+Wv7+/JGn9+vW6ceOGFi5cqGnTpmnHjh2aNGmSJOnixYsKDg5WiRIlFBERoVWrVqlMmTIKCQnRlStXVLduXX322WeSpC1btsjX19fqGmJjY9WqVStdvHhRX3/9tZYsWSJHR0e1bdvWqhHyeWp4FiEhIXJyctLAgQMfe0zv3r21cuVKDRw4UJGRkapdu7a6d++uTZs2WY45e/asLl68qBUrVqhPnz6SpOTkZI0ZM0ajRo3S0qVLdfXqVbVs2VIxMTFasGCBevfurYULF+rnn3+WJM2bN08zZsxQv379tGHDBn311Vc6fvy4xowZ89TriI6O1qBBg9SjRw9t2LBBo0aN0qpVqzRr1izL/g4dOsjPz0+RkZEKDQ3V/v37FRwcbGkC/eSTT7Rnzx5Nnz5ds2fP1ubNm3X27Nlnup+SlJiYqJUrV+q3337Te++9J0mKi4tTx44d5ejoqEWLFmnt2rUKCgrSqFGjdPDgQfn6+lqah7/77jvVrVvXaszk5GQFBwdr+/btGjt2rFasWKESJUqoQ4cO2rt3ryQpR44cGjZsmNq0aaO+ffsqW7Zsz1w7AAAAAAAAAAAAAAAAACDj7Iwu4Elq1KhhmS3Q09NTy5Yt086dO9WoUSPLstTOzs7KmjWrZs6cqdy5c2vIkCGW8ydPnqyqVavq+++/V5MmTSRJJUuWTLVsc7Zs2TRixAjZ29vLy8tL7733nqKioiTdb7Dr3r27PvjgA8ssh126dFFERIROnDihihUrysnJSZLSXEo6MjJS169fV0REhKXm0NBQ1a5dW99884369ev33DXkypUr3ffUyclJn3/+uTp37qwlS5aoZcuWVvtjYmK0adMmTZ8+XbVq1ZIkde/eXYcOHdL06dMtM5BKUrdu3eTh4SHp/syOkvTxxx+rXLlykqR33nlH8+fP1+eff64sWbLIy8tLYWFhOnLkiGrVqqWCBQtqzJgxltkt8+fPr6CgoHQt6X3mzBmZTCYVKFBA+fLlU758+RQeHm5pRAwPD1e1atXUrVs3SfffPxMmTFDt2rW1bds2ubm5acuWLZo7d64qVqwoSZowYYLlmp9kxowZmj17tuV5XFycChcurIEDB6p169aWbe3bt1fr1q0tNXXv3l0zZszQoUOHVLJkSTk7O0uSXFxclDlzZquMLVu2aP/+/Vq9erWKFy8uSRoyZIh2796t8PBwTZ48WU5OTqpdu7YkpWriBAAAAAAAAAAAAAAAAF4nNiaT0SXgNfW3bsL08vKyeu7k5KSkpKQ0jz1w4IBiYmJSzUSZkJCgmJgYy/NChQqlOrdQoUKyt7dPM8fDw0NNmzbVwoULdfToUZ04cUIHDx6UdH+2wqc5fPiwPD09LQ2Y0v1lq318fKyWJH+ZNTyqZs2aatq0qcaNG6caNWpY7XtQU4UKFay2V6xYURMmTLDa5unpmWrsh5fEzpIli3LlyqUsWbJYtmXKlEkJCQmS7i85v3v3bk2dOlUnT55UTEyMjhw5ojx58jz1GmrUqCFfX181bdpUnp6eql69ugIDA1W6dGlJ998PJ0+eTPV+kO43ml6/fl2SVKZMGcv2XLlyWZpKn6Rly5Zq166d7t27p//+97+aNGmS6tSpozZt2liOcXFxUevWrbVu3TpFR0fr5MmTltfMbDY/NePw4cNycnKyNGBKkslkUsWKFfXrr78+9XwAAAAAAAAAAAAAAAAAwMv3t27CdHBwSLXtwVLSjzKbzapataqGDh2aat+DmSolpZpx8HE5D8TExKhVq1YqVaqU/Pz8FBgYqJw5c6p58+bpuQSlpKTIlEaXdXJysuzs/u/2v8wa0hISEqLffvtNgwYNUvny5Z96vNlstqpXSvtePnrMg5k70zJz5kyFhYWpSZMmqly5stq1a6dNmzalaybMTJkyaf78+Tpw4IC2bNmiLVu2aMmSJWrUqJFGjx4ts9msBg0aqGvXrqnOdXFx0W+//Wa5rifVnxZnZ2dLM6+Xl5ecnJzUv39/OTo6qnPnzpKkK1eu6P3331fOnDkVGBioatWqqUyZMvL393/q+NLj3zdpvQ4AAAAAAAAAAAAAAAAAAGM8vkPub+7RBrVixYopJiZG7u7uKlSokAoVKiRnZ2eNGjVKhw8fznDO4sWL5erqqrlz56pz587y9/fXlStXJP1fQ2hazXIPFC9eXMePH9fVq1ct2xISErRv3z4VLVr0hdXwrB4sS/7f//5XkZGRVvVK0o4dO6yO3759e7rrTa+vv/5a3bt317Bhw9SiRQuVK1dOJ06cSNc1RUVFadq0aSpVqpQ+/PBDzZ8/Xz179tS6desk3X8/HDlyxPJeKFSokJKTkzV69GidP39epUqVkiTt3LnTMuatW7d06tSpZ76ORo0aqU6dOpoyZYplJtHVq1frxo0bWrJkibp166a3335bN2/elJS+9423t7du3bqV6r27Y8eOF/46AAAAAAAAAAAAAAAAAAAy5h/bhOno6Cjp/rLNt2/fVuvWrXX79m317t1bBw8eVHR0tPr06aM9e/aoWLFiGc7JmzevLly4oKioKJ09e1Y//PCDhg0bJklKTEy0qmXfvn2Kj4+3Or9BgwbKnj27PvnkE+3Zs0fR0dHq16+f7t69qxYtWrywGjKiZs2aatasmVXjYdGiReXv76/hw4dr8+bNOn78uKZNm6ZNmzYpODg4w1lpcXd312+//aajR4/q2LFjmjRpkn744Yd0XZOdnZ2+/PJLzZ07V6dPn9bevXu1efNmy/LjwcHBOnjwoIYMGaKjR49q9+7d6tu3r44fPy5PT08VLFhQderU0YgRI/Tf//5Xhw8f1qeffprh+zlkyBBlzZpVAwcOlNlsVt68eRUXF6f169fr3Llz2rJli3r37i0p9fsmOjpad+7csRrPz89P3t7e6tOnj7Zu3aqYmBgNHz5chw8f1r/+9a8M1QgAAAAAAAAAAAAAAAAAeLH+sU2YOXPmVNOmTTVu3DhNmTJFHh4eWrhwoeLi4tS6dWu1bdtWJpNJ8+bNk6ura4Zz2rdvr6CgIH366aeqX7++vv76a/Xu3Vv58+fXnj17JElVq1ZV2bJl1bJlS23evNnq/OzZs2vhwoVycnJShw4d1Lp1a8XFxWnx4sXy8PB4YTVkVEhIiNzd3a22TZo0SYGBgRo0aJAaNmyon376SWFhYapTp85zZT1q3Lhxio+PV9OmTdW2bVsdPnxYw4cP19WrV3XmzJknnuvn56cvvvhCy5YtU/369dWpUyd5enpq4sSJkqRy5cpp1qxZOnz4sJo0aaIPP/xQHh4emjNnjmXp97Fjx+qtt95Sr1691KZNGxUtWlSlS5fO0LW4uroqJCREe/fu1fz581WnTh198MEHGjt2rIKCgjRq1Cg1a9ZMlSpVsrxmxYsXl7+/vz755BN9++23VuPZ2dlpzpw5KlmypHr06KGmTZvq8OHDmjt3rsqVK5ehGgEAAAAAAAAAAAAAAAAAL5YpJaPrWQP4nxF7N86Q3GM3Mj6T6/Pyzm5YtA7fNia3hN1NY4IlpdjaGZJ7Qca90InJr9+f18y2JkNy3RySDcmVpCQbB8OyjXqPZb953JBcSUp09TIk1+HGaUNyJemXOzkMyXVyMOZzW5LOxyYYkuuZI4shuZLk7WTc34w4kzGfY3svGfP9U5Iq5stqSO4+A6/ZKZOtIbkmY74aSJK8cxv4hR8AAAAAAAAAYIgdp28YXQIkVfDIYXQJr9w/diZMAAAAAAAAAAAAAAAAAAAAIxk3xQ0AAAAAAAAAAAAAAAAAAC+ALdMRwiC89QAAAAAAAAAAAAAAAAAAADKAJkwAAAAAAAAAAAAAAAAAAIAMoAkTAAAAAAAAAAAAAAAAAAAgA2jCBAAAAAAAAAAAAAAAAAAAyACaMAEAAAAAAAAAAAAAAAAAADKAJkwAAAAAAAAAAAAAAAAAAIAMoAkTAAAAAAAAAAAAAAAAAAAgA0wpKSkpRhcBwFhXb981JDfZbNzHj7PtPcOyU2wdDMm1ib9pSK4kpdhnMSQ3TvaG5EpSFlOyIbmXE0yG5EpSbvMNQ3JTMmUzJNdopoRYQ3KNvN9JtpkMyV139LohuZLUxNWYz26j/lZJ0q2s7obknotNMiRXkhxsjfvszuNoZ0iug61x/x4wMdlsSO6pW8a9x4ziZtD7S5JcU24bkuuQM68huQAAAAAAAAAAac854/oi8H988jkbXcIrx0yYAAAAAAAAAAAAAAAAAAAAGUATJgAAAAAAAAAAAAAAAAAAQAbQhAkAAAAAAAAAAAAAAAAAAJABNGECAAAAAAAAAAAAAAAAAABkAE2YAAAAAAAAAAAAAAAAAAAAGUATJgAAAAAAAAAAAAAAAAAAQAbYGV0AAAAAAAAAAAAAAAAAAADPw2QyugK8rpgJEwAAAAAAAAAAAAAAAAAAIANowgQAAAAAAAAAAAAAAAAAAMgAmjCfIDY2VmXLllX16tWVmJhota9du3YaMGBAusd61uPTKyIiQt7e3mk+KlasmO5xrl+/ru++++6F15cRR44c0c8//5zu48PCwhQQEPDcufv371ezZs1kNpufe6yHrVmzRsHBwRk6d+vWrfL29taZM2fS3G82m9W0aVPt3bv3eUoEAAAAAAAAAAAAAAAAAGQATZhPsHbtWrm6uio2NlYbN240upwn2rJlS6rHhg0b0n3+uHHjFBkZ+RIrTL8uXbo8U1NhcHCwli1b9lyZSUlJGjBggPr06SMbmxf7axEVFaWaNWu+0DEfsLGxUd++fRUSEpKqURgAAAAAAAAAAAAAAAAA8HLRhPkEy5cv15tvvqlq1appyZIlRpfzRG5ubqkerq6u6T4/JSXlJVb3cmXNmlUuLi7PNUZkZKRsbW1VrVq1F1TVfWazWVu2bHlpTZiSVK1aNdnb22vVqlUvLQMAAAAAAAAAAAAAAAAAkBpNmI8RExOj3bt3y8/PT3Xq1NG2bdsUExOT5rEPlozetGmT3nnnHZUrV04dOnRIdfydO3f02WefqWLFiqpQoYIGDBigu3fvWvb/9NNPatmypXx9fVWmTBk1a9ZM//3vf1/I9ezcuVNt2rSRj4+P3nrrLQ0fPlyxsbGSpAEDBmjFihXatm2bvL29JUnJycmaO3eu3n33XZUpU0bvvvuuli5d+kzX3K5dO3322Wdq3ry5KlasqJUrV0qSVq5cqYYNG8rHx0cBAQGaPn26ZQnwgIAAnT17VtOmTVO7du0kSbdv39bgwYNVtWpVVahQQe3bt7eaKfPh5cjPnDkjb29vrV+/Xs2bN1eZMmUUGBj41JkyZ8+erXr16lmeR0REKCAgQCtWrNDbb7+t0qVLq2nTpvrrr78sx8TFxWno0KGqUqWKypcvr4EDB6pPnz5Wy87v3btXWbNmVZEiRSy1RUVFqUmTJipTpowaNGigXbt26bvvvlOtWrVUvnx59enTRwkJCel/cSUFBQUpPDz8mc4BAAAAAAAAAAAAAAAAADwfmjAfY9myZXJ0dFTNmjVVu3ZtOTg4aPHixU8854svvtDAgQP17bffys7OTu3bt9ft27ct+3/44QflypVLERERGjdunNatW6eZM2dKkvbt26ePPvpI77zzjiIjI/Xdd9/J1dVVffv2fe5lpqOjo9WhQwf5+fkpMjJSoaGh2r9/v4KDg5WSkqKBAwcqKChIvr6+2rJliyRpzJgx+uqrr9S9e3etXr1a7du314gRI7RgwYJnuuaIiAi1b99eixcvlr+/v+bOnavBgwerRYsWioyMVK9evRQeHq5x48ZZ7nvevHkVHByssLAwpaSkqHPnzjpx4oRmzJihpUuXqly5cmrVqpUOHDjw2GseM2aMunbtqpUrV6patWoaPHiwTp8+neaxJ06c0NGjRy2NnA9cunRJS5Ys0fjx4/Xtt9/KxsZG/fv3t8wa2r9/f/3222+aNGmSlixZotjYWK1du9ZqjKioKPn7+1ttGzFihPr27auVK1cqc+bM+vDDD7V+/XpNnz5dY8aM0YYNG/Tdd9896SVNpVatWjp+/LiOHz/+TOcBAAAAAAAAAAAAAAAAADKOJsw03Lt3T6tXr1atWrWUJUsWOTk5yd/fX6tWrVJcXNxjzxswYID8/f3l7e2t0NBQ3blzx6opr0yZMurdu7cKFiyowMBA+fn5ad++fZIkW1tbDRo0SMHBwfLw8FCJEiXUvn17Xb16VVevXn1qzb6+vqkeD5oOw8PDVa1aNXXr1k2enp6qWLGiJkyYoN27d2vbtm1ycnJS5syZZW9vLzc3N8XGxmrx4sXq2bOnGjRoIE9PT7Vp00Zt27bV9OnTrZYuf9o1lyxZUg0aNFCxYsWUI0cOzZw5U23btlWbNm3k6empBg0aqGfPnlq4cKFu374tFxcX2draytHRUTly5NAff/yhv/76S1OmTFHZsmXl5eWl3r17q1y5cpo/f/5j70fHjh0VGBgoLy8v9e/fX2azWbt3707z2F27dsne3l6enp5W25OSkjRs2DCVK1dOb7zxhrp06aKTJ0/q8uXLOn36tDZs2KChQ4eqevXqKl68uMaNGyc3NzerMX755ZdUS5F37NhR1atXl5eXlxo1aqSbN29q6NCh8vb21jvvvKNSpUrp8OHDT33NH1akSBHZ29s/9hoBAAAAAAAAAAAAAACA/2U2MvH4GzxeR3ZGF/B3FBUVpcuXL6tu3bqWbXXr1tXGjRu1du1aNWvWLM3zKleubPk5R44c8vT0tGqmK1y4sNXxzs7OOnv2rKT7zYrOzs6aOXOmjh8/rhMnTujgwYOS7i8Nvn37dnXu3Nlybr58+ayaHR8s9f2wvHnzSpIOHDigkydPytfXN9UxMTExqlKlitW2Y8eOKSkpSRUqVLDaXrFiRc2ZM8eqKfRp11yoUCHLz9euXdOVK1dSjVupUiUlJSXp2LFjKlu2rNW+/fv3S5ICAwOtticmJj5xyW4vLy/Lz05OTpLuN1Wm5cqVK8qRI4dsbW3TPc6DWTgfvqeZMmVSmTJlLM+vXbuW5v19+H2QJUsWSZKHh4fVOM86+6mtra2cnZ115cqVZzoPAAAAAAAAAAAAAAAAAJBxNGGmISIiQpLUs2fPVPuWLFny2CZMOzvr22k2m2Vj83+TjabV5PfAn3/+qeDgYPn7+6tixYqqV6+e4uLi9NFHH0mSSpcubdVo+WjWw82OjzKbzWrQoIG6du2aap+Li0uqbQ9mujSZrDuTzWZzquynXXPmzJlTjfuo5OTkNMd6MF62bNksr8nDHBwc0hzvcfsel28ymSzXlt5xHryWjztPuj8LZsWKFa3ugZT2dT58zzIqOTn5ie8xAAAAAAAAAAAAAAAAAMCLxXLkj7h27ZqioqLUpEkTrVy50urRrFkz7d271zI746P27t1rNc7Jkyf1xhtvpCs3PDxcVapU0bRp09ShQwf5+fnp/Pnzku43/WXOnFmFChWyPPLnz5/uaypWrJiOHDlidX5ycrJGjx5tyXi44bJIkSKys7PT9u3brcbZvn273Nzc5OzsnKFrdnV1laurq3bs2JFqXHt7exUsWDDVOcWLF1dsbKwSExOt6p85c6Y2bdqU7nvwJHny5NGNGzee2FD5KG9vb5lMJu3atcuy7eEZMqX7M6r6+/u/kBqfJjk5Wbdu3Uq1HDoAAAAAAAAAAAAAAAAA4OWhCfMRq1at0r1799SpUycVL17c6tG1a1fZ2tpq8eLFaZ47fPhw/fnnn4qOjlbfvn3l5uamOnXqpCvX3d1dhw4d0vbt23XmzBktX75cU6ZMkaRnXpr6UcHBwTp48KCGDBmio0ePavfu3erbt6+OHz8uT09PSZKjo6MuXbqk06dPy8nJSe+//76mTp2q1atX6+TJk/rmm2+0aNEiBQcHWzVsPss1m0wmBQcHa+HChfrmm2908uRJrV69WtOmTVOLFi0sy31nzZpVJ06c0JUrV1SjRg2VLFlSn3zyiX7//XedPHlSY8eO1fLly62WCn8eZcuWVXJysqKjo9N9joeHh4KCgvT555/r999/V0xMjAYPHqzz58/LZDIpOTlZv/322wtrwvzzzz/1yy+/WD1OnDhh2R8dHa3k5ORUy7kDAAAAAAAAAAAAAAAAAF4eliN/REREhKpXr55mg5+Hh4fefvttrV271tK8+LDmzZurb9++unXrlqpWrar58+crS5Ys6crt2bOnrly5YlkyvGjRoho1apT69eunPXv2PFfDYbly5TRr1ixNmTJFTZo0UZYsWVS1alX179/fstx2o0aNtHHjRtWvX18bN27UwIEDlTNnTk2YMEFXrlxRoUKFNGTIEL3//vvPdc2dOnWSg4OD5s2bp9GjRytv3rzq3LmzPvjgA8sx7dq109ixY3XkyBFFRkZq9uzZGj9+vHr16qW4uDh5eXkpLCxM1apVy/A9eZiHh4eKFy+uP/74Q6VKlUr3eZ9//rlGjhypHj16KCUlRfXr11e5cuVkb2+vXbt2ycXFRR4eHi+kxgEDBqTa1rVrV/Xq1UuS9Mcff6h48eIvLA8AAAAAAAAAAAAAAAAA8HSmlJSUFKOL+KfbunWr2rdvr02bNqlAgQJGl/NK/K9d83fffad58+ZpzZo16To+ISFBv/76q6pWraps2bJZtr/77rtq2LChPvroo5dVaprq1aunjh07qlmzZhk6/+rtuy+4ovRJNhv38eNse8+w7BRbB0NybeJvGpIrSSn26WtIf9HiZG9IriRlMSUbkns5wfT0g16S3OYbhuSmZMr29IP+B5kSYg3JNfJ+J9lmMiR33dHrhuRKUhNXYz67jfpbJUm3srobknsuNsmQXElysDXuszuPozH/Ls/B1rhFGRKTzYbknrpl3HvMKG4Gvb8kyTXltiG5DjnzGpILAAAAAAAAAJD2n79ldAmQ9IZ7dqNLeOVYjhyQ1LhxY927d0+//fZbuo53cHDQiBEjNHToUMXExOjEiRMKDQ3VuXPn0r0E/Yvy66+/Kjk5WY0aNXqluQAAAAAAAAAAAAAAAADwuqMJE5BkZ2encePGacKECTKbnz4zjslk0owZM3T9+nW1aNFCjRs31l9//aXZs2c/19Lxz8psNmvixIkaO3as7OyMm2UGAAAAAAAAAAAAAAAAMJLJxOPv8HgdsRw5AJYjf8VYjvzVYTnyV4vlyF8tliN/dViO/NViOfJXi+XIXx2WI3+1WI4cAAAAAAAAAF4/By6wHPnfQam8LEcOAAAAAAAAAAAAAAAAAACAdKAJEwAAAAAAAAAAAAAAAAAAIANowgQAAAAAAAAAAAAAAAAAAMgAmjABAAAAAAAAAAAAAAAAAAAygCZMAAAAAAAAAAAAAAAAAACADLAzugAAAAAAAAAAAAAAAAAAAJ6HjcnoCvC6ogkTgHJe3GNIbnI2N0NyJSkhez7Dsu3vJRiSeyY5qyG5kmRrNuabjnMmQ2INlWhOMSzb7sYZQ3Jvu5c1JNdoNo7GvMGz3DhlSK4kHTW5G5Jbu3AOQ3IlKdlkzGe3yaC/VZKU89I+Q3Kzur9hSK4k2cTfNCzbFHfPkNwUB0dDciXJlCmbIbnFdy0yJFeS7MoFGJJruhlvSK4kmS+dNCT39htvG5IrSU6OWQzLBgAAAAAAAADgdcZy5AAAAAAAAAAAAAAAAAAAABlAEyYAAAAAAAAAAAAAAAAAAEAG0IQJAAAAAAAAAAAAAAAAAACQATRhAgAAAAAAAAAAAAAAAAAAZABNmAAAAAAAAAAAAAAAAAAAABlAEyYAAAAAAAAAAAAAAAAAAEAG2BldAAAAAAAAAAAAAAAAAAAAz8NkMroCvK6YCRMAAAAAAAAAAAAAAAAAACADaML8h2vXrp0GDBiQ5r4BAwaoXbt2r7iiF2/r1q3y9vbWmTNnXtjxT7pvz2L+/PkaOXLkM51z6dIl+fr6KjExMc39AQEBCgsLk/T0azGbzWratKn27t37bIUDAAAAAAAAAAAAAAAAAJ4by5HjtRQWFiZbW9vnGuP06dP6z3/+ozVr1jzTeVFRUapataocHByeK1+SbGxs1LdvX4WEhCgiIuKFjAkAAAAAAAAAAAAAAAAASB9mwsRrKUeOHHJycnquMaZNm6a6desqR44cz3TeL7/8In9//+fKfli1atVkb2+vVatWvbAxAQAAAAAAAAAAAAAAAABPRxPma+TIkSPq1q2bqlSpotKlS+vtt9/WvHnzrI7ZvHmzmjRpIh8fH7399tuaPHmy1bLZ3t7eWrNmjdq3b2855qefftJPP/2kd999V+XKlVOnTp107do1yzkxMTHq2rWrqlSpogoVKqhnz546d+6cZX9ycrImTZqkN998U2XLllWPHj30xRdfPHYp9eTkZM2dO1fvvvuuypQpo3fffVdLly5NddzmzZv1zjvvyMfHRx07dtTp06ct+x5ejjwiIkIBAQFasWKF3n77bZUuXVpNmzbVX3/99dh7efHiRa1du1b169e32j5v3jwFBATIx8dHHTp00LRp0xQQEGDZn5SUpP/+97+WJszbt2+rf//+qlixoqpVq6a5c+c+NvNJgoKCFB4enqFzAQAAAAAAAAAAAAAAAAAZQxPmayIuLk4dO3aUo6OjFi1apLVr1yooKEijRo3SwYMHJd2fofHjjz9W8+bNtWbNGg0dOlTr169Xv379rMYaOXKk2rRpozVr1qho0aLq06ePvv76a40fP17Tp0/Xnj17NHPmTEnS2bNn1aJFCzk4OGjevHmaM2eOrl69qrZt2yo2NlaSFBoaqm+//VZDhgxRRESEcufOrQULFjz2WsaMGaOvvvpK3bt31+rVq9W+fXuNGDEi1Tnh4eEaPHiwli1bpkyZMqlVq1aKi4tLc8xLly5pyZIlGj9+vL799lvZ2Niof//+SklJSfP4qKgoZc+eXT4+PpZt33zzjSZOnKhu3bpp1apVqlKlir788kur83bs2KF8+fLJ3d1dkvTJJ59oz549mj59umbPnq3Nmzfr7Nmzj732x6lVq5aOHz+u48ePP/O5AAAAAAAAAAAAAAAAAICMsTO6ADy/1atXa8OGDam2JyYmqnz58pLuN2G2b99erVu3VrZs2SRJ3bt314wZM3To0CGVLFlS06dPV7NmzdSqVStJUsGCBTV8+HD961//0pkzZ1SgQAFJUuPGjfXuu+9Kklq2bKmffvpJvXr1sjQk+vn56fDhw5KkRYsWydHRUaGhoXJwcJAkTZ06VQEBAYqMjFTjxo21aNEihYSE6J133pEkDR48+LGzUMbGxmrx4sUaMGCAGjRoIEny9PTU6dOnNX36dLVt29Zy7KBBg1SjRg1J0rhx4+Tv7681a9aoefPmqcZNSkrSsGHDVLJkSUlSly5d9NFHH+ny5cvKnTt3quN37dql4sWLW20LDw9X+/bt1axZM0nSv//9bx04cED79++3HPPLL7+oZs2akqRjx45py5Ytmjt3ripWrChJmjBhgmrVqpXmtT9JkSJFZG9vr927d6tw4cLPfD4AAAAAAAAAAAAAAAAA4NnRhPk/ICAgQH379k21PTQ0VDdu3JAkubi4qHXr1lq3bp2io6N18uRJywyYZrNZknTgwAHt2bNHK1assIzxYCbImJgYSxPmw01+mTNnliR5eHhYtmXKlMmyhPnhw4dVunRpSwOmJLm6uqpw4cI6dOiQYmJiFB8fr3LlylnVXqFCBUVHR6e6pmPHjikpKUkVKlSw2l6xYkXLLJsPb3sge/bs8vT0tDSHpsXLy8vys5OTk6T7zZlpuXLlilxcXCzPr1+/rrNnz6Z5HY82YQ4ePFiSLLWUKVPGsj9XrlxW9zK9bG1t5ezsrCtXrjzzuQAAAAAAAAAAAAAAAMA/nY1MRpeA1xRNmP8DsmbNqkKFCqW5/UET5pUrV/T+++8rZ86cCgwMVLVq1VSmTBn5+/tbjjebzerUqZMaN26caiw3NzfLz3Z2qd82JlPaH2IpKSlp7ktOTpa9vb1lrMct+53WeGnlPWgkfbg2W1vbVJkPN4M+Kq19j6vLZDJZMh/OfdJ1nDt3ThcuXLDMTvpo7Y+O9aySk5NTXTMAAAAAAAAAAAAAAAAA4OWxMboAvBqrV6/WjRs3tGTJEnXr1k1vv/22bt68Ken/GgeLFSumY8eOqVChQpbHxYsXNW7cON25cydDucWLF9eePXssM2NK9xtCT548KS8vLxUqVEiZM2fWrl27rM7bs2dPmuMVKVJEdnZ22r59u9X27du3y83NTc7OzpZt+/bts/x87do1nThxQsWKFcvQdTwqT548unbtmuW5k5OT8ufP/8TriIqKUvXq1WVvby9JKlWqlCRp586dlmNu3bqlU6dOPXM9ycnJunXrllWzLAAAAAAAAAAAAAAAAADg5WImzNdE3rx5FRcXp/Xr16tixYo6duyYRo8eLUmWBsnOnTvrk08+UVhYmOrXr68LFy5o0KBBypcvX4ab+1q1aqXFixerb9++6tatmxITEzV27FjlzJlT9erVU5YsWdSuXTtNnTpVbm5u8vLy0vLly7Vr1y5Vrlw51XhOTk56//33NXXqVDk7O8vHx0dbtmzRokWL1Lt3b6sZMocMGaIRI0YoR44cGjNmjNzd3VW3bt0MXcejfHx89P3338tsNsvG5n4vc+fOnTV27Fh5eXmpfPny2rx5s9avXy93d3dJ95swa9eubRmjYMGCqlOnjkaMGCEHBwflypVLEydOtGpYfeDPP//UsWPHrLYVLFhQnp6ekqTo6GglJyerbNmyL+T6AAAAAAAAAAAAAAAAAABPRxPma6JOnTrav3+/xo4dq9jYWOXPn1/NmzfXpk2btGfPHrVq1Up16tTRpEmTNGPGDM2YMUPOzs6qVauW+vXrl+FcDw8PLViwQKGhoWrRooUcHBzk5+en8ePHK3v27JKkjz/+WElJSRo0aJDi4uJUq1YtBQYGKiEhIc0xBw4cqJw5c2rChAm6cuWKChUqpCFDhuj999+3Oq5bt24KCQnRtWvXVKVKFc2aNeuJy5E/i1q1amnIkCE6cOCASpcuLel+w+nNmzc1adIkXb9+XZUrV1bjxo21Y8cOJSYmauvWrRoxYoTVOGPHjtW4cePUq1cvmc1mtWjRwmqGzQcGDBiQalvXrl3Vq1cvSdIff/yh4sWLy8PD44VcHwAAAAAAAAAAAAAAAADg6UwpD9aiBgyyceNGVahQQS4uLpZtwcHByps3r0aNGmVgZU/Wr18/OTk5aciQIZKkX375RcWKFbPMfClJgwcP1qlTpzRv3ryXWku9evXUsWNHNWvWLEPnm4/+8YIrSp/kbMYtn56QPZ9h2fbJaTcYv2xnE2wNyZUk24dmqX2VnDPZGJIrSVlMyYbkno0zJFaS5HljvyG5t91fz1mAbYz5tVKWG6eMCZZ0yOT+9INeAvdsxv27paymJENyTfeM+VslSXZXTxiSm+j+hiG5kmQTf9OwbFPyPUNyUxwcDcmVpORM2QzJNf00x5BcSbIrF2BIrikp3pBcSTJfOmlIbvwbbxuSK0lOjlkMywYAAAAAAACAv4Mjl24bXQIkFcvtZHQJr5xx3SnA/xceHq4+ffro4MGDOn36tObOnas//vhDDRs2NLq0J+revbu+//57y8yVq1at0r///W/t2rVLZ8+e1cqVKxUZGan33nvvpdbx66+/Kjk5WY0aNXqpOQAAAAAAAAAAAAAAAAAAazRhwnChoaHKmjWrOnTooPr162v16tWaMmWKqlatanRpT1SoUCF9+OGHmjZtmqT7s16WKFFCH330kerUqaOZM2fqs88+U5MmTV5aDWazWRMnTtTYsWNlZ2fcLF0AAAAAAAAAAAAAAACAkUwmHn+Hx+uIri0YrkCBApZGxn+aDh06WH7OkSOHxowZ80rzbWxstGLFileaCQAAAAAAAAAAAAAAAAC4j5kwAQAAAAAAAAAAAAAAAAAAMoAmTAAAAAAAAAAAAAAAAAAAgAygCRMAAAAAAAAAAAAAAAAAACADaMIEAAAAAAAAAAAAAAAAAADIAJowAQAAAAAAAAAAAAAAAAAAMoAmTAAAAAAAAAAAAAAAAAAAgAywM7oAAAAAAAAAAAAAAAAAAACeh43J6ArwuqIJE4BSMmU1JPdwipshuZLkkmg2LPt6vDGTEOfKYtzkxw62xnzTuRKXbEiuJBU03TQk1yRnQ3IlKSl3cUNy75lTDMmVJCO/w2cx3zUk15QUb0iuJMXbGPPZbeR77GKyrSG5yeYshuRKkk2OUobkOiQaEitJcrV1MCz7jkMOQ3JP3UoyJFeSCtoa81mSXONfhuRK0uW79wzJzZHVmM8wSTqSXMCQ3DIG/s3Yf/6WIblvuGc3JBcAAAAAAAAAgL8LliMHAAAAAAAAAAAAAAAAAADIAJowAQAAAAAAAAAAAAAAAAAAMoAmTAAAAAAAAAAAAAAAAAAAgAygCRMAAAAAAAAAAAAAAAAAACADaMIEAAAAAAAAAAAAAAAAAADIAJowAQAAAAAAAAAAAAAAAAAAMsDO6AIAAAAAAAAAAAAAAAAAAHgeJqMLwGuLmTABAAAAAAAAAAAAAAAAAAAygCZMSQEBAfL29tacOXPS3D9kyBB5e3srLCzsFVeWtu3bt6t79+7y8/NT2bJlVa9ePc2cOVOJiYlGl/ZKBAQEvNDXYtu2bfL29taPP/6Y5v6LFy+qZMmSWr58+VPHGjBggNq1a/fCagMAAAAAAAAAAAAAAAAA/H3RhPn/2dvb6/vvv0+1/d69e/rhhx9kMv09JqxduHChOnToIA8PD/3nP//RmjVr9OGHH2rOnDn697//reTkZKNL/MepXLmyChUqpMjIyDT3R0ZGKkuWLAoKCnrFlQEAAAAAAAAAAAAAAAAA/s7sjC7g76JatWr69ddfdf78ebm7u1u2//HHH3J0dFSWLFkMrO6+Q4cOafTo0almW/Tw8FD+/PnVpk0brV27Vg0bNjSwyn+mpk2b6ssvv9Tt27fl5ORktW/VqlWqV6+eHB0dDaoOAAAAAAAAAAAAAAAAAPB3xEyY/5+Pj4/y5cuXajbMdevWKSgoKNVMmDt37lSbNm3k4+Ojt956S8OHD1dsbKxl/4ULF9S3b19Vr15db7zxhvz9/TVp0iSZzWZJUkREhAICArRixQq9/fbbKl26tJo2baq//vrrsTV+9913yp49u1q1apVqX8WKFTVv3jy99dZblm0rV65Uw4YN5ePjo4CAAE2fPt2Sf+bMGXl7e+urr76Sn5+fAgICdOvWLXl7e2vx4sVq1aqVfHx81KBBA23atMkyZlhYmAICAqyyIyIi5O3tbXm+Z88etW7dWr6+vqpUqZJ69Oihc+fOWfZfu3ZN/fv3V5UqVVShQgV17txZJ06cSPf4j1q+fLkaNWokHx8flStXTu3atdP+/fst+wMCAjRq1CjVrVtXVapU0R9//JFqjEaNGllmPX3Yvn37dOTIETVr1kySdP78efXt21d+fn4qV66cPvjgAx06dCjNuh7c461bt1pt9/b2VkREhOV6O3TooPnz5+vNN99UuXLl1Lt3b12+fFmffvqpfH195e/vrxUrVljOT0lJ0cyZMxUYGKiyZcvqvffee+wsngAAAAAAAAAAAAAAAACAl4cmzIcEBQVZNWEmJibqxx9/VL169ayOi46OVocOHeTn56fIyEiFhoZq//79Cg4OVkpKiiSpS5cuunbtmsLDw/X999+rU6dOmj59un766SfLOJcuXdKSJUs0fvx4ffvtt7KxsVH//v0tYzxq7969KlOmjOzs0p7AtGrVqsqePbskae7cuRo8eLBatGihyMhI9erVS+Hh4Ro3bpzVOZGRkZo3b56mTJliOXfcuHGqX7++Vq5cKX9/f3Xv3l07d+5M1z00m83q0qWLKlWqpMjISM2dO1fnzp3TZ599Jun+8u7BwcE6fPiwvvzySy1dulS2trYKDg7WvXv30pXxsI0bN2ro0KHq0KGD1q9fr3nz5ik+Pl4DBw60Om7x4sUaNGiQZs2apfLly6caJ0+ePKpZs6ZWr15ttX3lypUqXry4ypYtq9jYWLVq1UoXL17U119/rSVLlsjR0VFt27a1ajJ9Vtu3b9f27ds1b948TZ48WRs2bFD9+vVVsmRJLV++XDVr1tSQIUN0/fp1SdKkSZO0aNEiDRo0SKtXr1b79u01bNgwffPNNxmuAQAAAAAAAAAAAAAAAADw7FiO/CFBQUEKDw+3LEn+22+/KWfOnCpVqpTVceHh4apWrZq6desmSfL09NSECRNUu3Ztbdu2zTI74bvvvqv8+fNLktq1a6f//Oc/OnTokGrXri1JSkpK0rBhw1SyZElJ9xs3P/roI12+fFm5c+dOVd+NGzfk4eHx1Ot4MFNi27Zt1aZNG0uNN27c0NixY/XRRx9Zjm3durWKFi1qdX7Tpk0t5/Xt21d//vmnFi5cmGbz4qNu376t69evK3fu3CpQoIBMJpMmT56sq1evSrq/vPvBgwe1fv16FSlSRJL0+eefKzw8XDdu3Hjq+I/KkSOHRo4cqUaNGkmS8ufPr+bNm2vo0KFWx/n7+6t69epPHKtZs2bq0aOHLl68qDx58igpKUlr165V165dJd1vWL1+/boiIiLk4uIiSQoNDVXt2rX1zTffqF+/fs9cv3S/cXXkyJHKnj27vLy8VLJkSdnb26tjx46SpA4dOmjp0qU6efKkMmXKpLlz52rcuHGqVauWJKlgwYI6e/aswsPDLa8bAAAAAAAAAAAAAAAA8DqxeWSlY+BVoQnzIaVLl5aHh4e+//57dezYUevWrVP9+vVTHXfgwAGdPHlSvr6+qfbFxMSoSpUqatu2rb7//nvNmzdPJ0+eVHR0tC5dumRZDvwBLy8vy89OTk6S7jdnpsXFxSVdjYrXrl3TlStXVKFCBavtlSpVUlJSko4dOyZXV1dJUqFChVKdX7lyZavnZcuW1X//+9+n5kqSs7OzOnXqpM8//1zTpk1T9erVVbNmTb377ruSpEOHDil79uyWBkxJcnNz04ABA9I1/qMqVaokFxcXffXVVzp58qSOHz+ugwcPprrPaV3no9566y25uLho3bp16tixo6KiohQbG6uGDRtKkg4fPixPT09LA6YkZcqUST4+Po9dkjw9XF1dLbOQSlKWLFnk7u5ulSFJCQkJOnr0qBISEtS/f3+FhIRYjrl3754SExMVHx+vzJkzZ7gWAAAAAAAAAAAAAAAAAED60YT5iAdLkrdu3VqbNm3Sd999l+oYs9msBg0aWGZIfJiLi4vi4uLUpk0bxcXFKSgoSO+9954GDx6c5iyFDg4OqbY9bjlyX19fLV++XMnJybK1tU21v3///ipTpozq1KmT5vnJycmSZLWceVoNe48ud242m2Vj838r1z9a36PLiPft21etW7dWVFSUfv/9dw0bNkwzZszQypUrZWdnJ9NTus6fNv7D1q5dq08//VT169eXj4+PmjVrpsOHD2vEiBFWx6WnMdHOzk7vvfeeIiMj1bFjR61atUq1a9dWzpw5LXWlVXtycvJjl4h/9HrSarC1t7dPte3h+53WWJMnT7ZqZH0grfcTAAAAAAAAAAAAAAAAAODlSLvT6zUWFBSk3bt3a9myZfLw8LCaqfKBYsWK6ciRIypUqJDlkZycrNGjR+v8+fP69ddftX//fi1YsEA9e/ZU3bp1lS1bNl29evWxDZbp0bRpU8XGxmrRokWp9m3fvl0rV66Uo6OjXF1d5erqqh07dqQ6xt7eXgULFnxizt69e62e79q1S2+88Yak+w2DsbGxVtdx8uRJy8/Hjh3T0KFD5erqqlatWmnq1KmaNWuWYmJiFB0draJFi+rmzZtW51y7dk2VKlXSjh07njr+o6ZPn65mzZpp7NixatOmjSpVqqTTp09Lenwz65M0a9ZMBw4c0P79+/Xzzz+refPmln3FixfX8ePHLUurS/dnp9y3b1+qJd2l/2uujI2NtWw7derUM9f0sCJFisjOzk7nzp2zev9FRUUpPDz8sc2bAAAAAAAAAAAAAAAAAIAXj46tR5QsWVKFChXSxIkTVa9evTSPCQ4O1sGDBzVkyBAdPXpUu3fvVt++fXX8+HF5enoqb968kqTIyEidPXtW27dvV7du3ZSUlKTExMQM1+bl5aWPP/5Yo0eP1rhx4xQdHa3jx49r8eLF+uijj1SrVi01bNhQJpNJwcHBWrhwob755hudPHlSq1ev1rRp09SiRQvLsuePM2/ePK1evVrHjx/X2LFjFR0drX/961+SpPLly+vWrVv6z3/+ozNnzmj16tWKiIiwnJsjRw6tWbNGQ4YMUUxMjI4fP67ly5fL2dlZRYoUUbVq1VS6dGl9+umn2r17t44cOaKQkBC5urqqTJkyTx3/Ue7u7tq5c6f279+vU6dOae7cuVq4cKEkZeheFylSROXLl9eQIUPk5uamatWqWfY1aNBA2bNn1yeffKI9e/YoOjpa/fr10927d9WiRYtUY+XOnVseHh6aM2eOjh49qr1792rw4MHPNVulk5OTWrZsqcmTJ2vlypU6ffq0VqxYofHjxytXrlwZHhcAAAAAAAAAAAAAAAAA8OxowkxDUFCQYmNjVbdu3TT3lytXTrNmzdLhw4fVpEkTffjhh5ZmOwcHB/n4+CgkJETz589XUFCQQkJCVKlSJdWvX1+7d+9+rto+/PBDTZ06Vfv371eHDh3UuHFjLVq0SF27dtXUqVMty2J36tRJ/fr107x581SvXj1NmTJFnTt31mefffbUjBYtWmjOnDlq2LChtm/frvDwcJUoUUKSVLlyZfXq1UsLFy5U3bp1tXLlSvXv399yrouLi2bNmqWzZ8/q/fffV+PGjXXu3DnNmTNH2bJlk42Njb766ivly5dPH3zwgVq1aiU7OzuFh4fLwcHhqeM/avDgwcqVK5fatm2r5s2ba/PmzRo3bpwkZfheN2vWTPv27VPTpk2tlh/Pnj27Fi5cKCcnJ3Xo0EGtW7dWXFycFi9eLA8Pj1TjmEwmjR8/XgkJCWrUqJH69Omj1q1bW5p0MyokJEQdOnTQ1KlTFRQUpC+//FLdu3dXjx49nmtcAAAAAAAAAAAAAAAAAMCzMaU8z/rY+J/j7e2t0aNHq0mTJkaXglco+fTepx/0EkTbFTIkV5Jcstgaln09PtmQ3FwGXrODrenpB70EV+KMudeSVNB005Dcs3I2JFeS8jkkGZIba8psSK4kGfPOvi+b+a4hubY3zhqSK0m7bIz5u+GR3d6QXEmKTzbmq3qy2bj/RLAxGfObZdTfKklyNcUZln3X1tGQ3FO3jPmbIUkFDfqdNujXWZJ0+e49Q3JzZDbu++eRq/GG5JbJncWQXEk6e9uY1/kN9+yG5AIAAAAAAADAo05ejTW6BEgq5JrN6BJeOWbCBAAAAAAAAAAAAAAAAAAAyAA7owsAAAAAAAAAAAAAAAAAAOB5GLTgGkATJqwdOnTI6BIAAAAAAAAAAAAAAAAAAPhHYDlyAAAAAAAAAAAAAAAAAACADKAJEwAAAAAAAAAAAAAAAAAAIANowgQAAAAAAAAAAAAAAAAAAMgAmjABAAAAAAAAAAAAAAAAAAAygCZMAAAAAAAAAAAAAAAAAACADKAJEwAAAAAAAAAAAAAAAAAAIAPsjC4AgPFOZvE0JLeYXZwhuZIUZ+9kWLaryaDrTjEbkyvJbGvM/S5895ghuZJ03snLkNy8jsb9aU8yG5Nta04xJFeS7iQZl30hwcGQ3CJuRQ3JlSRvg/790MZjNwzJlaT3spw2JDfFIYshuZJkzuxsSG6KbWZDciUp1iabYdmOtiZDcs0pxn1+Zjbomm3ibxqSK0lOmY35G33X1tGQXEmq4mrMe+xo7D1DciWpaDZjvu8n3LpmSK4kZcruYlg2AAAAAAAAgL8fZiOEUXjvAQAAAAAAAAAAAAAAAAAAZABNmAAAAAAAAAAAAAAAAAAAABlAEyYAAAAAAAAAAAAAAAAAAEAG0IQJAAAAAAAAAAAAAAAAAACQATRhAgAAAAAAAAAAAAAAAAAAZABNmAAAAAAAAAAAAAAAAAAAABlgZ3QBAAAAAAAAAAAAAAAAAAA8D5PJZHQJeE0xEyYAAAAAAAAAAAAAAAAAAEAG0ISJNAUEBCgsLOyljR8WFqaAgICXNv7THDlyRD///PMLH3f06NGaO3eu1bZt27apZ8+eqlmzpkqXLi0/Pz/17NlTe/bsSXOMd999Vzt37nzqPbpw4YKCgoIUGxv7Ii8BAAAAAAAAAAAAAAAAAJBONGHitdSlSxft3bv3hY75119/afPmzWrTpo1l28yZM9WxY0flyZNHYWFh2rhxo6ZNm6bMmTOrdevW+v33363GOH36tG7cuKGyZcs+NS9v3ryqU6eOxowZ80KvAwAAAAAAAAAAAAAAAACQPnZGFwD8r5gwYYLatGkje3t7SdLu3bs1ceJEffbZZ2rXrp3lOHd3d/n6+io+Pl4TJkzQsmXLLPt+/vln+fn5ydbWNl2Z7du3V82aNfXBBx+ocOHCL/aCAAAAAAAAAAAAAAAAAABPxEyYyJDly5crKChIPj4+CgoK0rx582Q2myVJZ86ckbe3t7Zu3Wp1jre3tyIiItIcb/78+SpdurR+/PFHSVJ8fLwmT56swMBAlSlTRo0aNbLse2Dfvn3q2LGjfH19Vb16dQ0ZMkR3797Vjz/+qBIlSujs2bNWx7///vsaPXq0AgICdPbsWU2bNs3SHHn79m0NHjxYVatWVYUKFdS+fXurmTLj4uI0cOBA+fn5Wer54YcfLPv37t2rHTt2qG7dupZtCxYsUIECBaxmxnzYsGHDFB4ebrUtKipKNWvWTPP4tOTMmVOVK1fWnDlz0n0OAAAAAAAAAAAAAAAAAODFoAkTz+zbb7/V2LFj9dFHH2nt2rX65JNPNHPmTIWGhmZovEWLFik0NFTTpk1T7dq1JUm9e/fWypUrNXDgQEVGRqp27drq3r27Nm3aJOl+o2e7du3k4uKib7/9VtOmTdPWrVs1ZMgQvfXWW3J1ddWqVassGcePH9fu3bvVuHFjLVu2THnz5lVwcLDCwsKUkpKizp0768SJE5oxY4aWLl2qcuXKqVWrVjpw4IAkacqUKTp06JD+85//aN26dapZs6Z69eqlM2fOSJJ+/PFHlS5dWm5ubpbM7du3q2rVqrKxSfvXzMXFRc7Ozpbn8fHx2rFjxzM1YUpSQECAfvrpp2c6BwAAAAAAAAAAAAAAAADw/FiOHM/sq6++UpcuXVS/fn1JkoeHh2JjYzV8+HB9/PHHzzTW0qVLNXbsWH355ZeqUaOGJCkmJkabNm3S9OnTVatWLUlS9+7ddejQIU2fPl2BgYFaunSpnJ2dNWbMGMvy3yNHjtS2bdtkZ2enhg0batWqVerWrZskaeXKlXrjjTdUokQJSZKtra0cHR2VI0cO/f777/rrr7/0+++/y8XFRdL9JtCdO3dq/vz5GjNmjE6dOqVs2bKpYMGCcnJy0scff6yKFStamih37dql4sWLW13blStXLOM9MHPmTH311VdW29auXat8+fJp69atKlq0aKpznsbb21uXL1/W+fPn5e7u/kznAgAAAAAAAAAAAAAAAAAyjiZMPJNr167pwoULmjJliqZNm2bZbjablZCQoDNnzihTpkzpGuvSpUsaNmyY7OzsVKBAAcv2Q4cOSZIqVKhgdXzFihU1YcIEyzFvvPGGpQFTkipVqqRKlSpJkpo2barZs2dr9+7d8vHxUWRkpDp16pRmHfv375ckBQYGWm1PTExUQkKCJKlz587q2rWrqlWrJl9fX/n5+alevXpycnKSdL/h0sfHx+r8nDlz6vr161bb3n//fb3zzjuSpN27d6tfv36WZdyfdSnyh3Mk6fLlyzRhAgAAAAAAAAAAAAAA4LVkYzK6AryuaMLEM3nQMBgSEqLq1aun2u/u7q5Lly5JklJSUizbk5KSUh1rMpk0c+ZMTZkyRSEhIVq0aNFjl+5+kG1nd/8ta2dnJ5Pp8Z+cRYsWVdmyZRUZGan4+HhduXJF9erVe+y42bJlU0RERKp9Dg4OkiRfX19FRUXpt99+0++//65ly5YpLCxMs2bNUrVq1WQymSz35oEKFSrozz//tNrm7OxsmT3zwoULVvt++eUXTZw48bHX9DgPcm1tbZ/5XAAAAAAAAAAAAAAAAABAxj2+4w1Ig6urq1xdXXXq1CkVKlTI8ti/f78mT54sSZbZKWNjYy3nnTp1KtVYbm5u8vPz08iRI7Vv3z7NmzdPkizLeu/YscPq+O3bt6to0aKS7jdZHjhwQMnJyZb9GzduVM2aNRUXFyfp/myYP/zwg3744QcFBgYqR44caV5T8eLFFRsbq8TERKtrmjlzpjZt2iRJmjp1qnbs2KHAwEANGjRIGzZskIeHhzZs2CBJypMnj65du2Y1bvv27XXixAktXbo0zdzz589bfo6JidGdO3dUunTpNI99kge5bm5uz3wuAAAAAAAAAAAAAAAAACDjmAkTj3Xy5En98ssvVtsyZcqkTp06aeLEicqXL5/8/f11+PBhDR8+XG+99ZYcHByUO3dueXh4aM6cOfL09FRcXJxGjx5tmVXyUcWLF1enTp00efJk1apVS0WLFpW/v7+GDx8uSfL09NTatWu1adMmS6Nn69atNX/+fA0dOlQdO3bU9evXFRoaKj8/P2XJkkWSVK9ePY0ePdoya+XDsmbNqhMnTujKlSuqUaOGSpYsqU8++USDBg1Svnz5tGTJEi1fvlyzZ8+23IvIyEh9/vnnKliwoHbt2qVz587J19dXkuTj42Np2HygfPnyGjBggIYPH659+/apYcOGcnd31/nz5xUZGally5apVKlSypEjh7777jvVqFEj1Uyg8fHxqV4DSSpTpoxlGfIDBw4oX758yp0791NfUwAAAAAAAAAAAAAAAADAi0MTJh5r9erVWr16tdW2PHny6JdfflGmTJm0YMECjR07Vq6urmrSpIl69eol6f4y4+PHj9cXX3yhRo0aKV++fOrZs6emTJny2Kxu3bppw4YNCgkJ0TfffKNJkyZp4sSJGjRokG7duqVixYopLCxMb7/9tqWO2bNnKzQ0VI0bN1b27NlVt25d9e7d2zJmtmzZVLt2bW3btk1+fn5Wee3atdPYsWN15MgRRUZGavbs2Ro/frx69eqluLg4eXl5KSwsTNWqVZMkDR8+XGPHjlW/fv1048YN5c+fX3379tV7770nSapdu7amT5+ua9euycXFxZLzr3/9S76+vlq4cKH69euny5cvK1u2bCpdurTGjBmjunXrys7OTr/88ouaNWuW6r5cvXpVnTt3TrV9zpw5luXg//jjDwUGBj7+hQQAAAAAAAAAAAAAAAAAvBSmlJSUFKOLAF6W9u3by9fX19Ig+jK1adNGAQEB+uCDD1561gOXLl1SYGCgVq9eLU9PzwyPc+zK7RdX1DMoYBdnSK4kxdk7GZad5d4dY4JTzMbkSjJnMuZ+2186bEiuJJ138jIk19XRuH9fkWw25ivFPYNyJelOknHZNxOSDcktkt3WkFxJuiebpx/0Emw8dsOQXEl6L8tpQ3JTHLIYkitJ5szOhuSm2Gc2JFeSYm2zGZbtaGcyJDf6WoIhuZJUwiWTIbk28TcNyb0fbsz3g7u2jobkSpJj8l1Dco/Gpb0CxKvgldWg7/sG/ndGpuwuTz8IAAAAAAAAwGvj/A2D+jFgxT1HVqNLeOWM+T/ZwEv2448/KiwsTH/99Zdatmz5SjI/+eQTLV68WImJia8kT5IWLFigBg0aPFcDJgAAAAAAAAAAAAAAAAAgY2jCxP+kmTNnauHChfr888/l7u7+SjIrVaqkt956SwsWLHgleefPn9cPP/ygAQMGvJI8AAAAAAAAAAAAAAAAAIA149YsBV6ib7/91pDcQYMGvbIsd3d3bdiw4ZXlAQAAAAAAAAAAAAAAAH9XJpPRFeB1xUyYAAAAAAAAAAAAAAAAAAAAGUATJgAAAAAAAAAAAAAAAAAAQAbQhAkAAAAAAAAAAAAAAAAAAJABNGECAAAAAAAAAAAAAAAAAABkAE2YAAAAAAAAAAAAAAAAAAAAGUATJgAAAAAAAAAAAAAAAAAAQAbYGV0AAAAAAAAAAAAAAAAAAADPg9kIYRSaMAHoTpLZkFybxOuG5EpSlsz3DMtOsXc0JNf29kVDciXpgtmYa3a/cNyQXElyc/U0JDc2ybivlQ62JkNyr8QlG5IrSQWyGne/k1OMyb4Sn2JIriQ52huT7e6UyZBcSbq75XtDch08SxiSK0k2hd4wJNfsmNOQXEk6eyvJsOxS8THG5OYsYEiuJJ29Y2tIbi5HZ0NyJSn+njGfn04GfTeQpBTZG5J7+ma8IbmSlCdrNkNynW8Z95078kyiYdkNS+U1LBsAAAAAAAAA8PdCAzAAAAAAAAAAAAAAAAAAAEAG0IQJAAAAAAAAAAAAAAAAAACQATRhAgAAAAAAAAAAAAAAAAAAZABNmAAAAAAAAAAAAAAAAAAAABlAEyYAAAAAAAAAAAAAAAAAAEAG0IQJAAAAAAAAAAAAAAAAAACQAXZGFwAAAAAAAAAAAAAAAAAAwPMwmUxGl4DXFDNhAgAAAAAAAAAAAAAAAAAAZABNmHhtBAQEyNvb2/IoWbKkKlasqHbt2mn79u2WY8LCwtI95vXr1/Xdd9+l+/itW7fK29tbZ86cSfc5O3bssNQHAAAAAAAAAAAAAAAAAPj7oAkTr5Xg4GBt2bJFW7ZsUVRUlBYtWqSsWbOqU6dOunDhwjOPN27cOEVGRr6ESv9P69atderUqZeaAQAAAAAAAAAAAAAAAAB4dnZGFwC8So6OjnJzc7M8z507t4YPH66aNWvqhx9+eObxUlJSXmR5AAAAAAAAAAAAAAAAAIB/EGbCxGvPzu5+L7KDg0OqfcuXL1ejRo3k4+OjcuXKqV27dtq/f78kacCAAVqxYoW2bdsmb29vSfebMmfOnKnAwECVLVtW77333hNnynza8Q/GDQkJ0YABAyRJK1euVL169VSmTBnVqFFDX3zxhRITE1/MzQAAAAAAAAAAAAAAAAAApBszYeK1dvHiRY0aNUqOjo6qWbOm/vOf/1j2bdy4UUOHDtXIkSNVqVIlXblyRSNHjtTAgQO1cuVKDRw4UPHx8bpw4YLCwsIkSZMmTdLq1as1ZMgQeXl56c8//9SwYcN0+/ZttWnTJlX+047fsmWL3nzzTX322Wdq0qSJoqOjNWjQIIWGhsrHx0cxMTHq06ePcubMqW7dur2y+wYAAAAAAAAAAAAAAAAAoAkTr5kZM2Zo9uzZkqR79+4pMTFRXl5emjx5svLly2d1bI4cOTRy5Eg1atRIkpQ/f341b95cQ4cOlSQ5OTkpc+bMsre3l5ubm+7evau5c+dq3LhxqlWrliSpYMGCOnv2rMLDw1M1Yabn+AdLpzs5OcnJyUlnzpyRyWRSgQIFlC9fPuXLl0/h4eHKli3bS7tnAAAAAAAAAAAAAAAAAIC00YSJ10rLli3Vrl07SZKNjY1y5MghJyenNI+tVKmSXFxc9NVXX+nkyZM6fvy4Dh48KLPZnObxR48eVUJCgvr376+QkBDL9gfNnvHx8c98fObMma3OqVGjhnx9fdW0aVN5enqqevXqCgwMVOnSpTN0PwAAAAAAAAAAAAAAAID/BTYmoyvA64omTLxWnJ2dVahQoXQdu3btWn366aeqX7++fHx81KxZMx0+fFgjRoxI8/iUlBRJ0uTJk1WkSJFU+x0cHJ7reEnKlCmT5s+frwMHDmjLli3asmWLlixZokaNGmn06NHpui4AAAAAAAAAAAAAAAAAwIthY3QBwN/V9OnT1axZM40dO1Zt2rRRpUqVdPr0aUn/10BpMv1fC32RIkVkZ2enc+fOqVChQpZHVFSUwsPDZWNj/ev2rMdLUlRUlKZNm6ZSpUrpww8/1Pz589WzZ0+tW7fuJd4JAAAAAAAAAAAAAAAAAEBamAkTeAx3d3ft3LlT+/fvl5OTk3766SctXLhQkpSYmKhMmTLJ0dFRly5d0unTp+Xh4aGWLVtq8uTJypo1qypUqKDt27dr/Pjx6ty5c6rxnZyc0nW8o6OjYmJidP36ddnZ2enLL79UtmzZFBgYqBs3bmjz5s3y9fV9ZfcFAAAAAAAAAAAAAAAAAHAfTZjAYwwePFhDhgxR27Zt5eDgoBIlSmjcuHHq1auXdu/ercqVK6tRo0bauHGj6tevr40bNyokJEQuLi6aOnWqLl26pLx586p79+768MMP08xIz/HBwcGaNWuWjh07pq+//lpffPGFZs+erUmTJilz5szy9/fXgAEDXtVtAQAAAAAAAAAAAAAAAAD8f6aUB+sqA3ht7T1/05DckikXDMmVJHNmJ8OyU+wdDcm1vX3RkFxJOpc5vyG57kd+NCRXksxv1DIkNzbF3pBcSXKwNRmSe/HOPUNyJalAVhvDsi/FG/MVzrgrlhztjUk/fC3ekFxJKr1lmiG5Dp4lDMmVJJtCbxiSm5yzoCG5knT4ltmw7FLxMYbkJucsYEiuJJ29l8WQ3FyOxv0byPh7xvzNcLI35ruBJJmSEw3J/flsgiG5klQxXzZDcp1vHjckV5LW3XI1LLthqbyGZQMAAAAAAABI29Xbd40uAZJcnYzpizGSkf8fHQAAAAAAAAAAAAAAAAAA4B+L5cgBAAAAAAAAAAAAAAAAAP9oxq3PhNcdM2ECAAAAAAAAAAAAAAAAAABkAE2YAAAAAAAAAAAAAAAAAAAAGUATJgAAAAAAAAAAAAAAAAAAQAbQhAkAAAAAAAAAAAAAAAAAAJABNGECAAAAAAAAAAAAAAAAAABkAE2YAAAAAAAAAAAAAAAAAAAAGUATJgAAAAAAAAAAAAAAAAAAQAaYUlJSUowuAoCxzId/MyQ3JUt2Q3Il6Wr2IoZlO9uZDcm9lmRc372TgzHZ9in3DMmVpESTnSG5txKMeX9JkptNnCG5yZmyGZIrSSZzsmHZKTa2huQmJhv31fHw1XhDcnM5GvP7LEkep435G22ytzckV5KSTh02JNfOt7YhuZKk5ETDos2OOQ3Jtb192ZBcSbqao6ghuQ7ffmFIriRl9a1qSG7y5bOG5EqSKXNWQ3JTqjY1JFeSJm89Z0hu32LGfYYl5yxoWPbNe8b8N05uZ2Pe2wAAAAAAAMA/wY3Yu0aXAEk5sjkaXcIrx0yYAAAAAAAAAAAAAAAAAAAAGUATJgAAAAAAAAAAAAAAAAAAQAbQhAkAAAAAAAAAAAAAAAAAAJABNGECAAAAAAAAAAAAAAAAAABkAE2YAAAAAAAAAAAAAAAAAAAAGUATJgAAAAAAAAAAAAAAAAAAQAbQhAkAAAAAAAAAAAAAAAAAAJABdkYXAAAAAAAAAAAAAAAAAADA8zCZTEaXgNcUM2HiqWJjY1W2bFlVr15diYmJVvvatWunAQMGSJK2bt0qb29vnTlz5pXWFxERIW9v7+ce58KFCwoKCtKdO3deQFWPl5iYqPLly+vixYtp7n/4np45c0be3t7aunXrY8fr2rWrNm7c+FJqBQAAAAAAAAAAAAAAAAA8Hk2YeKq1a9fK1dVVsbGxf8tmv7p162rLli3PPc6gQYMUHBysrFmzvoCqHm/Hjh0qUKCA8uTJ80LGGzBggD7//HPduHHjhYwHAAAAAAAAAAAAAAAAAEgfmjDxVMuXL9ebb76patWqacmSJUaXk0rmzJnl5ub2XGP88ccf2r9/vxo3bvyCqnq8qKgo+fv7v7DxPD095ePjozlz5rywMQEAAAAAAAAAAAAAAID/x969x/dc//8fv+88Y8acY5lDJnYwhxzGxhAbItTHOUZSDgk5y6ESkxzWgZBhJWHOJFETMSFkQs2ZnM1x571/f/jt/fVuw7yxV+V2vVx2uWyvw/P+eL3e773f79XD8wng/mjCxD3Fx8dr7969CggIUNOmTbVjxw7Fx8ff85wffvhBzz//vHx9fdWtWzedPHnSvO/OpbYzDR06VJ07d5b0f8tvx8TEqHXr1vLx8VGLFi20Z88eLV68WA0aNFDVqlU1cOBAJScnS8q6HLmXl5e++eYbdevWTb6+vqpXr55mzpx5z5q/+OILNWnSRPb29pJuL61eqVIlbd++XaGhofLx8dH//vc/HT16VJ999pnq1Kmj5557Tu+++65MJpN5nFWrVikkJEQ+Pj5q27at5s2bl2Wp9DubMFNSUjR+/HjVrl1b1atX1+TJk5WRkXHPWrMTEhKihQsXKikp6YHPBQAAAAAAAAAAAAAAAABYhyZM3NOSJUvk4uKiwMBANWrUSI6Ojlq4cOE9z5kzZ45GjRqlJUuWyMnJSe3bt1diYuID5Y4bN06DBg3S8uXL5ezsrJ49e2rdunWaMWOGJkyYoPXr12vx4sV3PT88PFytWrXSihUr1KZNG3300UfauXNntscmJibq559/VoMGDSy2p6ena8KECRo/fry++eYbXbp0Se3atVN8fLwWLFigAQMGKCoqSj/++KOk282nQ4YMUdu2bbVy5Uq1adNGkydPthjz1KlTunjxoqpUqSJJeu+997R27VpNmDBBCxcu1JkzZ+5a570EBQXp2rVrVp0LAAAAAAAAAAAAAAAAALAOTZi4q7S0NK1atUoNGjRQnjx55OrqqqCgIK1YseKeTZUjR45UvXr1VKFCBYWHh+vmzZtavXr1A2V369ZNderUUbly5dSqVStdvXpVo0ePlpeXl55//nlVqlRJhw8fvuv5L774olq2bKkyZcqof//+cnNz065du7I9Ni4uTqmpqVlmrJSkN998U1WqVNGzzz6r559/Xjdv3tS7776rcuXKqV27dipcuLD++OMPSbebT5s2baru3burTJkyat++vTp06GAxXkxMjAICAmRvb68bN24oOjpab775poKCgvTMM89o/PjxVi2tni9fPpUqVUp79+594HMBAAAAAAAAAAAAAAAAANahCRN3FRMTowsXLig0NNS8LTQ0VNeuXdOaNWvuel716tXN3+fPn1+enp73bJjMTpkyZczf58mTR5Lk4eFh3ubk5KSUlJS7nl+uXDmLn/Ply6fU1NRsj71w4YIkyd3d/b51FC5c2FxPZh2Zy6LHxcWZZ7jMdOe9kKTNmzcrMDBQknT06FGlpqbKx8fHYrxnn332rtd1L+7u7rp48aJV5wIAAAAAAAAAAAAAAAD/ZrY2fP0Tvp5E9kYXgH+u6OhoSVK/fv2y7Pv666/Vtm3bbM+zs7Oz+Dk9PV2Ojo7mn00mk8X+7Joj7e2zPjVtbXPeM3xn3t1yM9nY3P7tz8jIuG8d96rB3t4+2zEyJScna8eOHXr//ffvekx2mTmVnp6e5d4DAAAAAAAAAAAAAAAAAB4fZsJEti5fvqyYmBi1bt1ay5cvt/hq27atfvvtN8XFxWV77v79+y3GOXbsmJ555hlJkoODg65fv25x/IkTJx7fheRAsWLFJN2u9WFUrFgxy3Lgd/4cGxurMmXKqHDhwpJuz9bp5ORksUx6WlqaDh48aFX+lStXrFrKHAAAAAAAAAAAAAAAAABgHWbCRLZWrFihtLQ09ejRI8vS3r169dKyZcu0cOHCbM995513NG7cOBUoUEATJkxQiRIlzEuaV61aVbNnz9amTZv0zDPPaNmyZTp8+LB8fX0f+zXdjZeXl5ycnBQXF6ennnrK6nFeffVV9erVS3PnzlVwcLB2796tBQsWmPdv3rxZQUFB5p9dXFzUqVMnTZ8+XUWKFFG5cuX0xRdf6Ny5c1nG3rdvn3nZ80xFixZVxYoVJd1uwDxz5oz8/Pysrh8AAAAAAAAAAAAAAAAA8GBowkS2oqOjVadOnSwNmJLk4eGhxo0ba82aNfL09Myy/4033tCwYcN0+fJl1axZU7NnzzYvD961a1edPHlSb7/9tmxsbBQaGqquXbtq9+7dj/uS7srFxUV16tTR9u3b1bhxY6vHCQwM1NixYzVz5kxNnjxZ3t7eateunaKioiTdbsIMDw+3OGfgwIFycnLSuHHjdPPmTYWEhCg4ODjL2B9++GGWbS1atDBvj42NlZubm6pXr251/QAAAAAAAAAAAAAAAACAB2NjMplMRhcBGG3btm3q37+/fvrpJ3PD6IPasWOHChcurLJly5q3zZgxQ0uWLNH333//qErN1quvvipvb2+9+eabVp2fcXjrI64oZ0x58huSK0mX8pe9/0GPiZt9hiG5l1NtDcmVJFdHY7IdTGmG5EpSio0x/87hWrIxzy9JKmKbaEhuulM+Q3IlySYj3bBsk62dIbkp6cZ9dDx8KcmQ3MIuxv27JY+TxrxH2zg4GJIrSaknDhuSa+/fyJBcSVJ6imHRGS4FDcm1u37BkFxJulSgvCG5joveNyRXkvL61zIkN/3CaUNyJcnGOa8huaZabQzJlaSpsWcMyR30jHGvYekFnzYs+2qaMX/jFHUz5rkNAAAAAAAA/Btcv2XM/7OGJVeXPEaXkOuM68gB/kFq166tZ599VsuXL7d6jK1bt6p79+7avn27zpw5o40bN2revHlq2bLloys0G3/++afi4uLUtWvXx5oDAAAAAAAAAAAAAAAAALDEcuTA//f+++8rLCxMzZo1U968Dz6zRO/evXXz5k0NHjxYly9fVokSJdS1a1f16NHjMVT7fyZNmqR33nlHbm5ujzUHAAAAAAAAAAAAAAAAAGCJJkzg/ytZsqTWr19v9fmOjo4aOXKkRo4c+Qirur+ZM2fmah4AAAAAAAAAAAAAAADwT2NjdAF4YrEcOQAAAAAAAAAAAAAAAAAAgBVowgQAAAAAAAAAAAAAAAAAALACTZgAAAAAAAAAAAAAAAAAAABWoAkTAAAAAAAAAAAAAAAAAADACjRhAgAAAAAAAAAAAAAAAAAAWIEmTAAAAAAAAAAAAAAAAAAAACvQhAkAAAAAAAAAAAAAAAAAAGAFG5PJZDK6CADGOnv1piG5+R3tDMmVpHM3Uw3LPnjxliG5jd2uGZIrSb+rqCG5Rj7HijukGJJ7Md3JkFxJKpp6wZDc63mMeX5JUh4H4/49i/3VvwzJtUk15jVMkjLyFjImOD3NmFxJS04ak5vHwbjXT/c8DobkPls4jyG5kmRva2NYdl7bdENyTTbGvX7apCUbkrv1vDH3WpKOJSQaklvS1dmQXElysDPm96rOUy6G5EqSbYoxf9cdSjTu86enm6Nh2VeTjPmdLn58iyG5kmTv39SwbAAAAAAAACAnbiUmGV0CJLnkMe7/DxiFmTABAAAAAAAAAAAAAAAAAACsQBMmAAAAAAAAAAAAAAAAAACAFWjCBAAAAAAAAAAAAAAAAAAAsAJNmAAAAAAAAAAAAAAAAAAAAFagCRMAAAAAAAAAAAAAAAAAAMAKNGECAAAAAAAAAAAAAAAAAABYwd7oAgAAAAAAAAAAAAAAAAAAeBg2NkZXgCcVM2ECAAAAAAAAAAAAAAAAAABYgSbMf6ChQ4fKy8vrnl/3c+bMGa1ZsybHmdHR0fccNyIiwiK/YsWKqlmzpgYMGKDz58/fdRwvLy9FR0ebxwgODs5xTdbUKUnBwcGKiIh4oHHT09P18ssva//+/Q9TXo50795dq1atynbf3+/R/a5l7ty5ev/99x95jQAAAAAAAAAAAAAAAACA+2M58n+gESNGaODAgeaf69atq+HDhys0NDTHYwwZMkQlS5ZUs2bNHlldxYsX15IlSyTdblo8e/asJkyYoNdff11Lly6VJIWGhqpevXrZnh8WFqaOHTs+snruZsmSJXJycnqgc+bMmaPSpUvL29v7MVV1W2Jionbt2qUPP/zwkYzXqVMnNW/eXE2aNFH16tUfyZgAAAAAAAAAAAAAAAAAgJxhJsx/IFdXVxUpUsT8dbdtuc3Ozs6cX7x4cVWpUkWDBw/W/v37dfjwYUmSs7PzXevLmzev3N3dH3ud7u7uyps3b46Pv379umbOnKnu3bs/xqpu27Ztm7y8vFSwYMFHMp6Dg4M6duyoyZMnP5LxAAAAAAAAAAAAAAAAAMAIGRkZmj59uurVqyc/Pz+FhYXp+PHjdz3+ypUrGjhwoGrUqKEaNWpo1KhRunXrlsUx69atU2hoqHx8fNSiRQtt3rz5kddNE+a/1I8//qiXX35Z/v7+qlu3riZMmKDk5GRJUufOnbVjxw4tW7bMvLT12bNnNWjQINWpU0eVK1dWUFCQpkyZooyMjIeqw8XFxeLney0XfudS26dOnZKXl5c+/fRTBQQEKDg4WNeuXbNYvjxTdktyL168WIGBgapSpYr69euny5cvZ3t8RESEOnfurFmzZikwMFA+Pj7q0qWLjhw5Yj5+0aJFKlasmCpWrGje5uXlpdWrV6tLly7y9fVV48aNtWnTJm3atElNmjRRlSpV1KNHD4vc/fv3q2PHjvLz81PDhg21cuVKVapUSbGxseZjYmJiFBgYaJHduHFj+fr66o033tDVq1fvfcOz0bRpU+3Zs0d79ux54HMBAAAAAAAAAAAAAAAA4J/g008/1ddff6333ntPixYtko2NjV599VWlpKRke3y/fv108uRJRUZGavr06dq6davGjh1r3r99+3a9/fbb6tChg5YvX666deuqd+/eio+Pf6R104T5L/T999/r9ddfV1BQkJYuXap3331X69at06BBgyTdbjz09/dXSEiIefnw1157TZcvX9acOXP07bffqkePHpoxY4Y2bdpkdR1XrlzRxx9/LH9/f1WoUMGqMVauXKl58+Zp2rRpyp8/f47Pmz9/vqZOnaqoqCidO3dOYWFhMplM2R7766+/6pdfftHnn3+uyMhInTlzxuKX7fvvv1eDBg2ynPfee++pY8eOWr16tcqXL6+BAwfqs88+06RJkzRjxgzt27dPs2bNkiSdO3dOr7zyikqWLKmlS5fqnXfe0ZQpU5Senm4x5k8//aSgoCBJ0po1azRu3Dh17dpVK1asUJUqVfTll1/m+B5kKlq0qCpVqvRQjyUAAAAAAAAAAAAAAAAAGCUlJUVffPGF+vbtq6CgIFWsWFFTpkzRuXPntGHDhizH//rrr9qxY4c++OADVa5cWbVr19a4ceO0YsUKnTt3TpI0a9YsNW7cWJ06dVK5cuU0ZMgQVa5cWfPmzXuktds/0tGQK2bOnKnGjRurd+/ekqSyZcvKZDLp9ddfV3x8vMqVKycHBwc5OzvL3d1dSUlJatmypZo0aaKSJUtKuj1b5ueff65Dhw6pUaNGOco9c+aM/P39Jd2e+jUpKUlOTk7mRkRrdOjQQeXLl3/g8yZNmmSeuXLixIlq0qSJtm3bpjp16mQ5Ni0tTeHh4SpQoICk29c+adIk83Xs379f7du3z3Leiy++qCZNmkiS2rVrp02bNumtt96Sr6+vJCkgIMC8DPuiRYuUP39+vf/++3JwcFD58uU1atQovf766+bx/vzzTyUnJ6ty5cqSbjeShoaGqmPHjpKknj17as+ePTp48OAD3w8vLy/t3bv3gc8DAAAAAAAAAAAAAAAAgEelYcOG99y/cePGbLcfPHhQN2/eVK1atczb8ufPr0qVKumXX35Rs2bNLI7fuXOnihQponLlypm3Pffcc7KxsdGuXbvUtGlT7d69W0OHDrU4r2bNmtk2dT4MmjD/hQ4fPpzlSVWjRg1J0qFDhyyeWJLk7OysTp066dtvv9W8efN0/PhxHTx4UOfPn3+g5ciLFi2qBQsWSLrdvJiQkKDo6Gh1795dX3zxhZ577rkHvpbSpUs/8Dl58+a1WDrc09NTbm5uOnz4cLZNmIULFzY3YEqSq6urUlNTJUkJCQlKTU2Vu7t7lvPKlClj/t7Z2VmS5OHhYd7m5ORknur2wIEDqly5shwcHMz7q1evbjFeTEyM6tWrJxsbG0nZP47+/v5WNWG6u7vThAkAAAAAAAAAAAAAAIAnls1dVtHFv8PZs2clSSVKlLDYXrRoUf31119Zjj937lyWYx0dHVWgQAH99ddfunbtmm7duqXixYvnaLyHQRPmv5DJZDI38mXKXPba3j7rQ5qYmKiOHTsqMTFRISEhatmypUaNGmWegTGn7O3tszRN+vv7KzY2VlFRUVY1YWY2N97p78uKZzZMZrKzs8tyTkZGhhwdHbPNuNv2v5//d9ndy7/f9ztrul9Da0xMjNq1a2ex7e/XemcT54NIT0+Xra2tVecCAAAAAAAAAAAAAAAAwKNwt5ku7ycxMVFS1l4vJycnXb16Ndvjs+sLc3JyUnJyspKSku46XnJyslU13g1dW/9CFSpU0K5duyy27dy5U5KyzIIpST/99JPi4uK0YMEC9evXT6GhocqXL58uXbqUpQnQGiaT6ZGMI91uQrx+/br55xs3bujy5csWx1y7dk0nTpww/3zo0CFdv35dFSpUeOA8d3d3OTo66sqVK9YXLalixYqKi4uzaBi9c2bKGzduaO/evapbt65527PPPpvlcfztt9+syr9y5YqKFi1q1bkAAAAAAAAAAAAAAAAAYKTMyfwyVybOlJycrDx58mR7/N+PzTzexcVFTk5ODzTew6AJ81+oe/fu+u677/TJJ5/o6NGj+uGHH/Tuu++qQYMG5ibMvHnz6vTp0zp79qx5StWVK1fq9OnT2rlzp9544w2lpqZm+0S8m/T0dF24cMH8dfToUU2YMEEnTpxQy5YtH8m1+fv7a9GiRYqLi9Phw4c1ePDgLDNS2traqn///tqzZ4/27NmjwYMH67nnnsuy/HdO+fr6av/+/Q9Vd4cOHXT9+nWNGjVK8fHx2rZtm8aNGyfp9uyZP//8s7y9vZU/f37zOT179tSGDRs0e/ZsHTt2TAsWLND69euzjH38+HFt3rzZ4is2NtbimLi4OPn5+T3UNQAAAAAAAAAAAAAAAACAETKXFj9//rzF9vPnz2dZUlySihcvnuXYlJQUJSQkqFixYipQoIBcXFxyPN7DYDnyf6GQkBClp6dr5syZ+uyzz+Tu7q7mzZurX79+5mPatWunIUOG6IUXXtC2bds0bNgwRUZGaurUqSpWrJhCQ0NVokQJi9ka7+fs2bMWMzm6uLioXLlymjhxoho1avRIrm3MmDEaO3as2rVrJ3d3d3Xr1k23bt2yOMbd3V0tW7bUG2+8ocTERDVo0EAjR460OrNRo0aKjo5+qLoLFSqk2bNna/z48WrZsqWKFy+u9u3bKzw8XA4ODtq8ebOCgoIszqlfv74mT56siIgITZs2TVWqVFFYWJhWr15tcdyqVau0atUqi23FihXT5s2bJUmXLl3SH3/8oQkTJjzUNQAAAAAAAAAAAAAAAACAESpWrKh8+fIpNjZWTz/9tKTbKyYfOHBAnTp1ynJ8jRo19OGHH+r48eMqXbq0JJkntqtatapsbGxUtWpV7dixQy+99JL5vNjYWFWrVu2R1m5jelTrSAP/UlevXlVwcLAiIyPl4+Nj1Rh//vmnrl69avELunv3brVv314//vijuVP7cZg1a5Z+/PFHffnll1aPcfbqzUdYUc7ld7QzJFeSzt1Mvf9Bj8nBi7fuf9Bj0NjtmiG5kvS7ihqSa+RzrLhDzmcafpQupjsZkitJRVMvGJJ7PY8xzy9JyuNg3KTi9lf/MiTXJtWY1zBJyshbyJjg9DRjciUtOWlMbh4H414/3fM4GJL7bOFHu+TAg7C3tTEsO69tuiG5JhvjXj9t0pINyd163ph7LUnHEhINyS3p6mxIriQ52Bnze1XnKRdDciXJNsWYv+sOJRr3+dPTzdGw7KtJxvxOFz++xZBcSbL3b2pYNgAAAAAAAJATSYnG/PdwWHJ+iKW+p0yZoq+//lrjx49XyZIlNWnSJJ06dUqrVq2SnZ2dLl++LFdXVzk7O8tkMqlDhw5KTk7WmDFjdOvWLQ0fPlw1a9bUBx98IEnasmWLevbsqbfffluBgYFaunSpvvzyS0VHR5tXnH4UWI4cTzw3Nzd1795dkZGRVo9x7tw5denSRcuXL9fp06f166+/6oMPPtBzzz33WBswU1JS9PXXX6t///6PLQMAAAAAAAAAAAAAAAAAHrd+/fqpbdu2GjlypNq3by87OzvNmTNHjo6O+uuvv1S3bl2tXbtWkmRjY6OPP/5YpUqV0iuvvKL+/fsrMDBQY8aMMY9Xt25djR8/XgsXLtSLL76o7du3a8aMGY+0AVNiJkxAkpSamqr27dvrnXfeka+vr1VjfPXVV1qwYIFOnTolV1dXBQcHa9CgQSpQoMCjLfYOs2fP1pkzZ/TOO+881DjMhJm7mAkz9zATZu5iJszcxUyYuYiZMHMVM2HmLmbCzD3MhJm7mAkz9zATZu5iJkwAAAAAAADg7pgJ85/hYWbC/LeyN7oA4J/AwcFBS5YseagxOnTooA4dOjyiinKmR48euZoHAAAAAAAAAAAAAAAA/COZMoyuAE8oliMHAAAAAAAAAAAAAAAAAACwAk2YAAAAAAAAAAAAAAAAAAAAVqAJEwAAAAAAAAAAAAAAAAAAwAo0YQIAAAAAAAAAAAAAAAAAAFiBJkwAAAAAAAAAAAAAAAAAAAAr0IQJAAAAAAAAAAAAAAAAAABgBRuTyWQyuggAxrp8/ZYhuXkcjOsDv56cblh2SroxL7sHLyUakitJF2+lGJJbpbirIbmSVMDZzpDcgnZphuRKku3Ny4bkXnIuakiuJDnY2hiW7XbjtCG5GS4FDcmVJJOtvSG5xxKNe78q7epgSO6tNOP+RLAz6PcqMS3DkFxJKmDMwyxJSsow5n67pBvz+VOSbFKMyTY5OBuSK0nX7fIZkpvX3rj3yYuJxnzet7cz7pqN+q87qRnGvWeUSLtoWHZ6viKG5Jpsjfk7Q5KOXDHm77rKJfIbkgsAAAAAAIB/n+Sb140uAZKc8hrXq2EUZsIEAAAAAAAAAAAAAAAAAACwAk2YAAAAAAAAAAAAAAAAAAAAVqAJEwAAAAAAAAAAAAAAAAAAwAo0YQIAAAAAAAAAAAAAAAAAAFiBJkwAAAAAAAAAAAAAAAAAAAAr0IQJAAAAAAAAAAAAAAAAAABgBZowAQAAAAAAAAAAAAAAAAAArGBvdAEAAAAAAAAAAAAAAAAAADwUU4bRFeAJxUyYAAAAAAAAAAAAAAAAAAAAVniimzBv3LghPz8/1alTRykpKRb7OnfurKFDhz6yrNjYWHl5eenUqVOPbMy/S01NVWRk5GMb30jR0dHy8vIyuowc2bRpk15//XVJ93/cvby8FB0dbbFt9erVCgsLu+v+O7333nv/2cccAAAAAAAAAAAAAAAAAP7pnugmzDVr1qhQoUK6ceOGNmzY8Fiz/P39tWXLFpUoUeKxZaxevVoffPDBYxvfSKGhodqyZYvRZdzXtWvXNHbsWA0ePNjqMWJiYhQYGJijY/v27avZs2fr+PHjVucBAAAAAAAAAAAAAAAAAKzzRDdhLl26VHXr1lXt2rX19ddfP9YsR0dHFSlSRHZ2do8tw2QyPbaxjebs7KwiRYoYXcZ9RUZGytvbW2XKlLHq/IyMDG3ZsiXHTZhubm5q1qyZIiIirMoDAAAAAAAAAAAAAAAAAFjviW3CjI+P1969exUQEKCmTZtqx44dio+Pv+vxmzZtUrt27eTv7y8fHx+1bdtWP//8s3l/586dNXHiRA0fPlzVq1dX1apVNWTIEN28eVNS1mWpg4OD9fnnn6tv377y9/dXzZo1NX78eKWlpZnH3L17tzp27ChfX1/Vr19fY8eO1Y0bN7KtLzo6WsOGDZN0ewnr2NhYRUREqF27dhowYICqVq2qsWPHSrrdfNqqVSv5+vqqSpUq6ty5s+Li4sxj3a+29PR0TZo0SUFBQfL29lbTpk21cOFC8/kpKSmaPHmyGjVqJG9vb9WsWVMDBgzQlStXJEmnTp2Sl5eXYmJi1Lp1a/n4+KhFixbas2ePFi9erAYNGqhq1aoaOHCgkpOTzdd353LkXl5e+uabb9StWzf5+vqqXr16mjlzpnm/yWTS7NmzFRISIm9vb1WrVk2vvfaaTp48aT4mM9/Pz0+1a9fW0KFDdfXqVYvnyKuvvip/f3/VrVtXAwcO1IULF+76HElOTtaXX36pZs2a3fWY+/ntt9+UN29elS1bNsfnhISEaN26dTp79qzVuQAAAAAAAAAAAAAAAACAB/fENmEuWbJELi4uCgwMVKNGjeTo6GjRSHin/fv3q3fv3nr++ee1cuVKLV68WIUKFdKgQYOUkpJiPm7BggUqXLiwFi9erPfee09r165VZGTkXWuIiIhQjRo1tGzZMvXt21fz58/X6tWrJUkHDx5U165dFRAQoJUrV+rDDz9UXFycwsLCsp3xMjQ0VMOHD5ckbdmyRf7+/pKkX3/9VYUKFdKKFSv0yiuvaMOGDRo9erS6du2qdevWad68eUpKStKIESNyXNtXX32lb7/9VlOmTNH69evVqVMnjRkzRjt37pQkhYeHa/Xq1Xr//fe1fv16TZw4UVu3btVnn31mkTFu3DgNGjRIy5cvl7Ozs3r27Kl169ZpxowZmjBhgtavX6/Fixff9f6Fh4erVatWWrFihdq0aaOPPvrIXMO8efM0c+ZMvf3221q/fr0+/fRTHT16VBMmTJAkXb58WX369FGbNm20du1affzxx/rll18UHh4uSTp37pw6dOggDw8PLVmyRDNmzNCNGzfUrl073bp1K9t6du7cqWvXrikoKOiuNd9PTEzMA59fpUoV5c+fXzExMVbnAgAAAAAAAAAAAAAAAAAe3BPZhJmWlqZVq1apQYMGypMnj1xdXRUUFKQVK1YoMTExy/F2dnYaOXKkwsLC5OHhoYoVK6pLly66dOmSLl26ZD6uXLlyGjBggMqUKaPQ0FAFBgZq9+7dd62jXr166tKlizw9PdWpUydVrFjRfPycOXNUu3ZtvfHGG/L09FT16tU1efJk7d27Vzt27MgylrOzs1xdXSVJRYoUkaOjo3lfv3795OHhIU9PTxUoUEDvvfeeWrVqpZIlS8rPz08vvfSSDh06lOPaTpw4IRcXF3l4eKhkyZLq1KmT5s6da16C28fHRxMnTlTNmjVVsmRJ1a9fX3Xr1s2S0a1bN9WpU0flypVTq1atdPXqVY0ePVpeXl56/vnnValSJR0+fPiu9+/FF19Uy5YtVaZMGfXv319ubm7atWuXJOnpp5/WhAkTFBwcrJIlS6pmzZoKCQkx13Du3DmlpKToqaeeUsmSJVWtWjXNmDFDnTt3liQtXLhQRYsW1TvvvKNy5crJ29tbU6dO1cWLF/Xtt99mW8+ePXtUqlQp5c2b964138/mzZtzvBT5nSpUqKC9e/danQsAAAAAAAAAAAAAAAAAeHD2RhdghJiYGF24cEGhoaHmbaGhodqwYYPWrFmjtm3bWhz/7LPPys3NTbNmzdLRo0d17Ngx/f7775JuL82dqVy5chbnubq66tq1a3etI7vjU1NTJUkHDhzQ8ePHzTNa3ik+Pl41a9bM0bUWKlTI3JwpSTVq1JC7u7s+/fRTHT9+XEePHtXvv/+ujIyMHNfWsWNHff/99woMDJS3t7cCAgIUEhKiQoUKSZJatmypbdu26aOPPtKxY8cUHx+vI0eOqHr16hZjZjZtSlKePHkkSR4eHuZtTk5OFjON/t3fa8yXL5+5xuDgYO3du1fTp0/X8ePHFR8frz/++EPFihWTdPsxbd68uXr16qUSJUqoTp06ql+/voKDgyXdvv/x8fFZ7n9ycvJdl62/ePGi3N3dLbbZ29/+Fctu9tLMe555zOXLlx/osb2Tu7u7Ll68+MDnAQAAAAAAAAAAAAAAAP8J2fTnALnhiWzCjI6OlnR7hsi/+/rrr7M0Yf7yyy8KCwtTUFCQqlevrmbNmikxMVG9e/e2OO7O2SdzIrvjM5v1MjIy1KJFC/Xq1SvLMX9v9LsXZ2dni5/XrFmjwYMHq3nz5vL19VXbtm11+PBhjRs3Lse1eXp66rvvvtOOHTu0detWbdy4UTNmzNAHH3ygF198UWPGjNHatWvVqlUr1a9fX6+//rrmzJmjc+fOWYyX2Xx4J1vbnE/Oeq8aZ82apYiICLVu3VrPPfecOnfurI0bN2rNmjXmYydPnqzevXtr8+bN+vnnnzVgwABVrVpV8+fPV0ZGhmrVqqXRo0dnybizqfVONjY2WZpZCxQoIEnZNuMmJCRIktzc3CTdngWzevXqWR6znEhPT3+gewcAAAAAAAAAAAAAAAAAeHhPXBPm5cuXFRMTo9atW6tbt24W++bNm6clS5YoLi7OYvucOXNUs2ZNffzxx+ZtCxYskJT9DIePwjPPPKM//vhDpUuXNm87cuSIwsPDNWDAgGwbAW1sbO477owZM9S2bVuNHTvWvG3jxo2Sbl9LTsaYP3++ChUqpGbNmikgIECDBw9Wt27dtHbtWtWvX18LFy7UlClTLGYaPXLkiFxcXO479qPy2WefqU+fPurZs6d525w5c8yP1549e7R27VoNHz5cZcuWVdeuXbVy5Uq9/fbbunTpkp555hmtXbtWJUqUMDd7JiQkaMiQIerWrZtq1aqVJbNYsWKKiYmx2Obp6SlXV1f98ssvqly5ssW+X375RTY2NvL29pZ0e4bWoKAgq673ypUrFjOLAgAAAAAAAAAAAAAAAAAevyeuCXPFihVKS0tTjx49sixn3atXLy1btkwLFy602F6iRAl9//332rlzp4oXL67Y2FhNmzZNku65XPbDCAsLU8eOHfXOO++oS5cuunnzpsaOHaubN2/K09Mz23Mymxz379+v8uXLZ3tMiRIltHv3bsXFxcnV1VWbNm1SVFSU+VqcnJzuW9ulS5f0ySefyNnZWRUrVlR8fLwOHDigV155Ra6urnJ1ddXGjRtVuXJlJSUlKSoqSnFxcfLz87PuZlihRIkS2rp1q4KDg2Vra6sVK1bou+++U+HChSXdXrr8q6++koODg15++WUlJSVpzZo18vT0VMGCBdWhQwctWrRIAwYMUO/evWVjY6NJkybpwIEDeuaZZ7LN9PX11ZQpU5SQkGCeAdPOzk49evTQtGnT5OjoqICAAKWlpWnPnj366KOP1LFjRxUqVEjp6enaunWrBgwYkGXcw4cPa/PmzRbb3NzczPczIyNDBw8eVKtWrR7dDQQAAAAAAAAAAAAAAAAA3NcT14QZHR2tOnXqZGnAlCQPDw81btzY3IyXqV+/frp48aJ5afDy5ctr/Pjxevvtt7Vv375sx3pYVapU0ezZszVt2jS1bt1aefLkUa1atTRkyJC7Lnteq1Yt+fn5qV27dpo0aVK2x4waNUrvvPOOOnXqJEdHR1WsWFHh4eF66623tHfvXj333HP3ra1Pnz5KS0vTu+++q4sXL6pIkSLq0KGDXnvtNdnZ2WnatGmaMGGCWrRoITc3N9WsWVMDBgzQjBkzdOvWrYe6LzkVHh6ucePGqU2bNsqbN6/8/Pw0duxYjRkzRqdOnVL58uUVERGhjz/+WF999ZVsbW1Vq1YtzZo1S7a2tvLw8FBUVJQmT56sDh06yM7OTlWqVNG8efNUqFChbDNr1KghNzc3xcbGqkmTJubtvXr1kru7uxYtWqQPP/xQGRkZ8vDwUM+ePdWlSxdJt2fmdHd3l4eHR5Zx586dq7lz51psq1q1qrlZOC4uTjdv3lSDBg0e1e0DAAAAAAAAAAAAAAAAAOSAjelxracNPIGmTp2q33//XTNnzsy1zDFjxujWrVsKDw+3eozL13OnOfbv8jjYGpIrSdeT0w3LTkk35mX34KVEQ3Il6eKtxzNr8P1UKe5qSK4kFXC2MyS3oF2aIbmSZHvzsiG5l5yLGpIrSQ62NoZlu904bUhuhktBQ3IlyWRrzL8fOpZo3PtVaVcHQ3JvpRn3J4KdQb9XiWkZhuRKUgFjHmZJUlKGMffbJd2Yz5+SZJNiTLbJwdmQXEm6bpfPkNy89sa9T15MNObzvr2dcdds1H/dSc0w7j2jRNpFw7LT8xUxJNdka8zfGZJ05Ioxf9dVLpHfkFwAAAAAAAD8+yRfTzC6BEhyci1gdAm5zrj/owz8B3Xr1k379+9XfHx8ruRdvnxZ69ev1xtvvJEreQAAAAAAAAAAAAAAAACA/0MTJvAIubm5acyYMXddDv5Ri4iIUI8ePeTp6ZkreQAAAAAAAAAAAAAAAMA/kimDr3/C1xPImDUdgf+wxo0bq3HjxrmSNXr06FzJAQAAAAAAAAAAAAAAAABkxUyYAAAAAAAAAAAAAAAAAAAAVqAJEwAAAAAAAAAAAAAAAAAAwAo0YQIAAAAAAAAAAAAAAAAAAFiBJkwAAAAAAAAAAAAAAAAAAAAr0IQJAAAAAAAAAAAAAAAAAABgBZowAQAAAAAAAAAAAAAAAAAArGBvdAEAjJecbjIk187WmFyj2dvZGJJbIp+TIbmSlJSWYUiuva0x91qS3JVoSG6iTV5DciUpb1qSIblpBr2GSVJBe2Oe25JksnMwJjgjzZhcSTbpKYbkeuZxMSRXks7eSjck18neuNdPg57ZumTQvZYkWxc7w7KNeqzTHPMZkisZ90dwor1x79F2JmPeK88Z+HtVxMWYR9pWxn0uuZ5qTPaNFOM+D2XkKWBYtk16qiG5dtfOGpIrSUcTjHntbjflJ0NyJem38GaGZQMAAAAAAODB2ZiM+++VeLIxEyYAAAAAAAAAAAAAAAAAAIAVaMIEAAAAAAAAAAAAAAAAAACwAk2YAAAAAAAAAAAAAAAAAAAAVqAJEwAAAAAAAAAAAAAAAAAAwAo0YQIAAAAAAAAAAAAAAAAAAFiBJkwAAAAAAAAAAAAAAAAAAAAr0IQJAAAAAAAAAAAAAAAAAABgBXujCwAAAAAAAAAAAAAAAAAA4KGYMoyuAE+o/8RMmDdu3JCfn5/q1KmjlJQUo8uRJF25ckWLFy9+oHN27dqlnTt3PlTuDz/8oD///POhxvgnOnXqlLy8vBQbG2t0Kfd19uxZhYSE6ObNm5IkLy8vRUdHZ3ts586dNXToUItt58+fl7+/v1JSUrLdf6fvvvtOb7zxxqMrHgAAAAAAAAAAAAAAAACQY/+JJsw1a9aoUKFCunHjhjZs2GB0OZKk8PBwrVy58oHO6dChg06cOGF15unTp9WrVy9dunTJ6jH+qUqUKKEtW7bI39/f6FLua+TIkQoLC1PevHmtOj8mJka1atWSo6PjfY99/vnnde3atQd+rgEAAAAAAAAAAAAAAAAAHt5/oglz6dKlqlu3rmrXrq2vv/7a6HIkSSaT6YnIzC12dnYqUqRIjhoTjbR9+3bFxcXpxRdftHqMzZs3KygoKMfHd+vWTVOnTlVaWprVmQAAAAAAAAAAAAAAAACAB/evb8KMj4/X3r17FRAQoKZNm2rHjh2Kj4837z927Ji6d++uatWqyd/fX927d9ehQ4fM+728vLRw4UK1b99evr6+atGihTZu3GjebzKZNHv2bIWEhMjb21vVqlXTa6+9ppMnT1qMMWXKFDVo0EABAQEaMGCAli1bph07dsjLy0uSdO3aNY0ePVpBQUGqXLmyAgICNHr0aCUlJZnHkKRhw4aZl58+d+6c3nrrLVWvXl01a9ZUr169dOzYsWzvw6lTp9SwYUNJUpcuXRQREaHY2Fh5eXlp1qxZqlmzpl588UWlp6dr165d6tatm6pVqyZvb281b95cq1evNo81dOhQvf3225o4caJq164tPz8/vfHGG7pw4YL5mOXLl6tZs2by8fFRvXr19P7771ssBb906VK1atVKvr6+qlKlijp37qy4uDjz/uDgYC1YsEB9+/aVn5+fAgMDtXjxYv36669q1aqV/Pz81K5dO/PMoH9fjrxz586aOHGihg8frurVq6tq1aoaMmSIeQlwSdq0aZPatWsnf39/+fj4qG3btvr5559z/Ny4fv26Ro0apVq1aqlatWrq0qWLfvvtt2zvf6YvvvhCTZo0kb29/T2Pu5vU1FT9/PPPD9SEWa9ePV27dk3r16+3KhMAAAAAAAAAAAAAAAAAYJ1/fRPmkiVL5OLiosDAQDVq1EiOjo5auHChef+AAQNUtGhRLV26VIsXL5atra369OljMUZ4eLiaN2+u5cuXKygoSH369NHu3bslSfPmzdPMmTP19ttva/369fr000919OhRTZgwwWKMRYsWafr06frkk080duxYhYSEyN/fX1u2bJEkDRkyRPv27dP06dO1fv16DRs2TNHR0Vq0aJEkmY8bPny4RowYoVu3bqlz585KT09XVFSUFixYoIIFC+rll1/WuXPnstyHEiVKaPHixZKkiIgIhYWFmff9+OOPWrRokcaPH6+LFy8qLCxMFStWVHR0tFasWCEfHx8NGzZMFy9eNJ+zbt06JSQkKCoqSh9//LF27dqlKVOmSJIOHjyokSNHqm/fvlq/fr3Gjx+vFStWaPbs2ZKkDRs2aPTo0eratavWrVunefPmKSkpSSNGjLCoefLkyapXr55Wr16t+vXra8yYMRo9erSGDh2qqKgoXbhwQR9++OFdH/sFCxaocOHCWrx4sd577z2tXbtWkZGRkqT9+/erd+/eev7557Vy5UotXrxYhQoV0qBBg8zNovd6bphMJr366qs6duyYZs6cqW+++UZVqlRR+/btdeDAgWzrSUxM1M8//6wGDRrcteb72bVrl5566imVKFEix+c4OjqqTp062rRpk9W5AAAAAAAAAAAAAAAAAIAHZ910ff8QaWlpWrVqlRo0aKA8efJIkoKCgrRixQoNHDhQefLk0YkTJxQQEKBSpUrJ3t5e48eP15EjR5SRkSFb29s9qG3atFHHjh0lSYMGDdIvv/yiqKgoVa1aVU8//bQmTJig4OBgSVLJkiUVEhKiNWvWWNTSsmVL+fj4mH92dnaWg4ODihQpIkkKCAhQ9erVVbFiRUlSqVKlFBUVZZ55MfM4V1dXubq6avHixbpy5YomT54sBwcHSdL777+v2NhYffPNN+rbt69Fvp2dndzd3SVJbm5uyps3r3lfWFiYPD09JUknT55Unz591L17d/P1v/baa4qOjtaxY8dUuHBhSVK+fPk0btw4OTg4qFy5cmrZsqViYmIk3Z6V0sbGRqVKldJTTz2lp556SnPmzFG+fPkkSQUKFNB7772nVq1ame/ZSy+9pNGjR1vUHBgYqJdfflnS7dk7Fy1apM6dO6tWrVqSpJCQEH3//fd3ffzLlSunAQMGSJLKlCmjNWvWmJtn7ezsNHLkSPPjmpkRFhamS5cuqUSJEvd8bsTGxurXX3/Vtm3bzPd1wIAB2r17t+bPn5+lCVeS4uLilJqaap7V1BqbN29WYGDgA5/n5eWlZcuWWZ0LAAAAAAAAAAAAAAAAAHhw/+omzJiYGF24cEGhoaHmbaGhodqwYYPWrFmjtm3b6q233tL48eO1cOFC1apVS/Xq1VNISIi5AVGSnnvuOYtx/fz8zMtWBwcHa+/evZo+fbqOHz+u+Ph4/fHHHypWrJjFOaVLl75nrR06dNCmTZu0YsUKnThxQocPH9bJkyfNzZF/d+DAAd24cSNLbcnJyRbLrefEnRkeHh5q06aNoqKi9Oeff+rYsWP6/fffJUnp6ekW15PZ/Cndbg5NTU2VdHv5a39/f7Vp00aenp6qU6eOGjZsKG9vb0lSjRo15O7urk8//VTHjx/X0aNH9fvvvysjI8OirjJlypi/d3Z2lnS7OTWTk5OTxRLnf1euXDmLn11dXXXt2jVJ0rPPPis3NzfNmjVLR48ezfY67/XcyFw6PXOJ90wpKSlKTk7Otp7M5dozmzYz2dvbZ7n2TBkZGRZLl2/evFmjRo266zXfjbu7u8VMpgAAAAAAAAAAAAAAAMATxZR9fw7wuP2rmzCjo6MlSf369cuy7+uvv1bbtm3VsWNHNW3aVDExMdq2bZs++ugjRUREaPny5eZZH+9sgpNkMUvmrFmzFBERodatW+u5555T586dtXHjxiwzYWY2EWbHZDKpV69eOnTokFq0aKEmTZpowIAB92y2y8jIUJkyZfTZZ59l2efi4nLX87Lj5ORk/j4+Pl7t27dXpUqVFBAQoIYNG6pgwYJ66aWXLM5xdHS853jz58/XgQMHtGXLFm3ZskVff/21WrVqpQ8++EBr1qzR4MGD1bx5c/n6+qpt27Y6fPiwxo0bZzHO3++7JIvm2Pu5V42//PKLwsLCFBQUpOrVq6tZs2ZKTExU7969zcfc67mRkZGhfPnymZ9jOcm1sbGRpCwNl25ubrp+/Xq25yQkJMjNzU2SdObMGZ09e1ZVq1a994Vn487nLAAAAAAAAAAAAAAAAAAgd/xrmzAvX76smJgYtW7dWt26dbPYN2/ePC1ZskR79+7VihUr1LNnT7Vu3VqtW7fWuXPnFBgYqB07dphn0Pztt9/My41L0p49e1S5cmVJ0meffaY+ffqoZ8+e5v1z5syRyWS6Z32ZDXnS7VktY2Ji9M0338jPz0+SlJqaqhMnTsjDwyPb8ytUqKAVK1bI1dXVPLNiWlqaBgwYoKZNm1rM/pld5t0sXLhQhQoVUmRkpHnbpk2bJOm+15QpJiZGv/32m/r06aNKlSqpZ8+e+uyzzzRjxgx98MEHmjFjhtq2bauxY8eaz9m4caM5Iyd1Pqw5c+aoZs2a+vjjj83bFixYYK7h4sWL+vTTT+/63KhQoYJu3LihlJQUPfPMM+YxRo4cqYoVK6pTp05ZMjNnR718+bKeeuop83YfHx/98ssvWZ6nFy9e1LFjx8zL2MfExKhOnToWM5Dm1OXLl81L2gMAAAAAAAAAAAAAAAAAcse/tglzxYoVSktLU48ePbIsS92rVy8tW7ZMX3/9tWJjY3XixAkNHDhQ+fLl05IlS+Tg4GBeOlu63bRZtmxZeXt765tvvtHBgwf13nvvSZJKlCihrVu3Kjg4WLa2tlqxYoW+++478yyad+Pi4qLz58/r5MmTKly4sOzt7bVu3Tq5u7srISFBM2bM0IULFyyW23ZxcVF8fLyuXLmiF154QZ9//rn69OmjwYMHy9XVVTNmzFBMTIz69u1710xJOnz4sCpVqpTtMcWLF9fZs2cVExOj8uXLKy4uznyt91r6+0729vb65JNPlC9fPjVs2FAJCQn64Ycf5O/vb75nu3fvVlxcnFxdXbVp0yZFRUWZM+6cmfNxKVGihL7//nvt3LlTxYsXV2xsrKZNm2auoUSJEvrxxx/v+twoWbKknn32WfXv318jR47UU089pa+//lpLly7VF198kW2ml5eXnJycFBcXZ9GE2aNHD73yyiuaMGGCXnzxRfPjPH36dFWoUMG85HlMTIwaNWqUZdxz585p8+bNWbbXq1fP3NAaFxenKlWqPOxtAwAAAAAAAAAAAAAAAAA8gH/t+sXR0dGqU6dOlgZMSfLw8FDjxo317bff6tNPP5Wtra26du2qZs2aafv27fr888/19NNPm4//3//+p7lz5+qFF17Qzp07NWfOHFWsWFGSFB4erqSkJLVp00adOnXS4cOHNXbsWF26dEmnTp26a32tWrVSYmKimjdvLhsbG02YMEGbNm1SaGio3nzzTRUrVkxdu3bVb7/9Zp6BMiwsTFFRURo+fLhcXV0VFRWlQoUKqUePHmrbtq1Onz6tOXPmWMzMeKeCBQuqTZs2Cg8PNzcc/l2XLl0UEhJiXi78s88+04ABA1SyZEnt27cvR/c+ICBA77//vpYsWaLmzZurR48e8vT01EcffSRJGjVqlAoXLqxOnTrppZde0g8//KDw8HBJ0t69e3OU8bD69eunKlWqqFevXmrVqpUWL16s8ePHy9nZWfv27ZO9vb1mzZp11+eGnZ2dvvjiC/n6+uqtt97SCy+8oNjYWEVERKh27drZZrq4uKhOnTravn27xfYaNWooMjJSf/zxh/n+jxs3TtWrV9f8+fPl4OCglJQUxcbGKjAwMMu4P//8s1599dUsX+np6ZJuz6q6e/duczMnAAAAAAAAAAAAAAAAACB32Jhyugb1f5SXl5c++OADtW7d2uhS8B+wbds29e/fXz/99JMcHR1zJXPt2rWaPHmy1q9fL3t76ya3/Svh5iOuKmdcHIzrA09OyzAs26jkS7fSDUqWjiYkGpJbsbCLIbmS9LRjsiG5ifZ5DcmVpLwJxwzJPZvHw5BcSSriZNzHKNublwzJNTk4G5J7O9yYV1CTg3GvJWdTjJm43snexpBcSXKwNSb77I00Q3IlqYiLnWHZTvbGfB4z6nGWJPuUG4bkGvkebdSf/VeTjfvMXcTFmNdPWxn32eB6qjHZCUnG/Z3xdB7jso1i1GdASVp/JZ8hucPm7jQkV5J+C29mWDYAAAAAAAAeXMqVs0aXAEmOBYsbXUKu+9fOhAn8E9WuXVvPPvusli9fnmuZ8+fPV9++fa1uwAQAAAAAAAAAAAAAAAAAWIcmTOARe//99zVnzhzdvPn4Z5dct26dChQooFatWj32LAAAAAAAAAAAAAAAAACApSd+6rxDhw4ZXQL+Y0qWLKn169fnSlZISIhCQkJyJQsAAAAAAAAAAAAAAAD4xzJlGF0BnlDMhAkAAAAAAAAAAAAAAAAAAGAFmjABAAAAAAAAAAAAAAAAAACsQBMmAAAAAAAAAAAAAAAAAACAFWjCBAAAAAAAAAAAAAAAAAAAsAJNmAAAAAAAAAAAAAAAAAAAAFagCRMAAAAAAAAAAAAAAAAAAMAKNiaTyWR0EQCM9eeF64bkOtvZGJIrSYWdjcu2TbpqSG66i7shuZKUkm7MW42Rb3Enr6cakvuMm70huZJkm3LTkNx05/yG5EqSjYHPMZu0ZENyTXYOhuRKksnWzpDcS7fSDMmVpKIZCYbk2qQb8xomSTfzFjMk9+xN4x5no94nJcnLzZh/l3c51bh/D1jQyZjshJQMQ3IlqYBBL92pBv67T6dUYz6XTNuTYEiuJL1VwZjXkvS8hQzJlaTDN435bCBJp64mGZIb7OFiSK4kpdoY87fG/guJhuQaqVZp4/5+BwAAAAAA+DdLuXzG6BIgydH9KaNLyHXGdWoAAAAAAAAAAAAAAAAAAPAoZBg3IQKebCxHDgAAAAAAAAAAAAAAAAAAYAWaMAEAAAAAAAAAAAAAAAAAAKxAEyYAAAAAAAAAAAAAAAAAAIAVaMIEAAAAAAAAAAAAAAAAAACwAk2YAAAAAAAAAAAAAAAAAAAAVqAJEwAAAAAAAAAAAAAAAAAAwAr2RhcAAAAAAAAAAAAAAAAAAMDDsDFlGF0CnlDMhAkAAAAAAAAAAAAAAAAAAGCFB27CNJlMio6OVufOnVWrVi15e3urUaNGGjdunM6dO/c4avxHCg4OVkRERI6Pv3Xrlr788svHWNH9de7cWUOHDr3r/jNnzmjNmjW5WFH24uLi1Lx5c3l7e+vNN980upwHlp6erpdffln79++XdO/7HhERoeDg4CzbmzRpot27d991f6azZ88qJCREN27ceDTFAwAAAAAAAAAAAAAAAABy7IGaMNPT0/X6669rwoQJatCggRYsWKDvvvtOo0aNUlxcnNq0aaOLFy8+rlr/1b744gvNmTPH6DLuaciQIfrpp5+MLkOffvqpbGxstHr1ao0aNcroch7YnDlzVLp0aXl7e1t1/smTJ5WQkCA/P7/7Hlu8eHE1bdpUEyZMsCoLAAAAAAAAAAAAAAAAAGC9B2rCnDt3rn766SfNnTtXYWFheuaZZ/TUU08pKChIkZGRcnBw0BdffPG4av1XM5lMRpfwr3Ht2jVVqlRJnp6eKly4sNHlPJDr169r5syZ6t69u9Vj/PjjjwoICJCdnV2Oju/SpYtWrFiho0ePWp0JAAAAAAAAAAAAAAAAAHhwOW7CNJlM+vLLL/XCCy+ocuXKWfbnyZNHUVFR6t+/v3nbrl271K1bN1WrVk3e3t5q3ry5Vq9ebd4/dOhQDRs2TFOmTFHNmjVVrVo1vfvuuzp79qx69eolPz8/Pf/884qJiTGfExwcrAULFqhv377y8/NTYGCgFi9erF9//VWtWrWSn5+f2rVrpxMnTuS4juxs2bJFrVu3lq+vr5o1a6YlS5bIy8tLp06dynJsdHS0vLy8LLbFxsaaj4+IiNDHH3+s06dPm7elpKRo8uTJatSokby9vVWzZk0NGDBAV65ckSSdOnVKXl5eiomJUevWreXj46MWLVpoz549Wrx4sRo0aKCqVatq4MCBSk5OVmpqqmrXrq2PP/7Yoo6FCxeqTp06Sk1Nvef1du7cWTt27NCyZcvMy18HBwdr/PjxCg0NVc2aNbV9+3Zdu3ZNo0ePVlBQkCpXrqyAgACNHj1aSUlJFtcdExNjXlK8WbNm+uGHH8xZx44dU/fu3VWtWjX5+/ure/fuOnTokDlzx44dWr58uby8vBQbGytJWrp0qUJCQuTr66uQkBDNmzdPGRkZFvfq008/VUBAgIKDg3Xt2jX98ccfeuONN1SzZk15e3urcePGmjdvnrmOxMREjRgxQgEBAfLx8VGrVq303XffmfebTCbNmjVLDRs2lJ+fn1q2bKmVK1fe8z4uWrRIxYoVU8WKFe953L3ExMQoMDAwx8cXLFhQzz33nObOnWt1JgAAAAAAAAAAAAAAAADgweW4CfPUqVM6c+aM6tSpc9djSpYsKUdHR0nSuXPnFBYWpooVKyo6OlorVqyQj4+Phg0bZrFk+apVq3T9+nV98803GjZsmKKiotS2bVs1bdpU0dHRKlu2rIYOHWoxk+TkyZNVr149rV69WvXr19eYMWM0evRoDR06VFFRUbpw4YI+/PDDB6rjTr///rtee+011apVS8uXL1fv3r0VHh6e01uVRVhYmMLCwlS8eHFt2bJFJUqUUHh4uFavXq33339f69ev18SJE7V161Z99tlnFueOGzdOgwYN0vLly+Xs7KyePXtq3bp1mjFjhiZMmKD169dr8eLFcnBw0AsvvJClSXDFihV64YUX5ODgcM8aIyIi5O/vr5CQEC1ZssS8feHChRo5cqRmz56tqlWrasiQIdq3b5+mT5+u9evXa9iwYYqOjtaiRYssxps0aZJGjBih6OhoeXh4aNCgQbp586YkacCAASpatKiWLl2qxYsXy9bWVn369JEkLVmyxFzHli1b5O/vr0WLFmnixInq3bu31qxZo/79+2vWrFnmxzjTypUrNW/ePE2bNk0ODg7q1q2bXFxc9NVXX2nNmjUKCQnR+PHj9fvvv0uSpk2bpkOHDunzzz/X2rVrFRgYqLfeesvcaDtlyhR99dVXGjlypFatWqUuXbpozJgx+vLLL+96H7///ns1aNDgnvf6XpKSkrRr164HasKUbjevbtq0yepcAAAAAAAAAAAAAAAAAMCDs8/pgZkNi+7u7hbbe/XqZZ6tUJKeeuoprVmzRikpKerTp4+6d+8uW9vbvZ6vvfaaoqOjdezYMfMy0/nz59eIESNkZ2en0qVLa/LkyapVq5ZatWolSerQoYN++OEHXbx4UUWKFJEkBQYG6uWXX5Z0eynmRYsWqXPnzqpVq5YkKSQkRN9//70k5biOO0VGRsrb21uDBw+WJJUtW1aXLl3Se++9l9PbZSFv3rxycXGRnZ2d+Rp8fHz0/PPP67nnnpN0u4G1bt265hkhM3Xr1s3c+NqqVSuNGzdOo0ePVunSpeXl5aVKlSrp8OHDkqS2bdsqMjJSv/76q/z9/XXs2DH9+uuvGjt27H1rLFCggBwcHOTs7GzxGAcFBVk03gYEBKh69ermmR5LlSqlqKioLHX3799ftWvXNn/fsmVLHT58WP7+/jpx4oQCAgJUqlQp2dvba/z48Tpy5IgyMjLk7u5uriPzXn366ad67bXX1Lx5c0mSh4eHbty4obFjx+rNN980Z3bo0EHly5eXJF2+fFldunRRhw4dlC9fPklSnz59NHPmTB06dEjPPvusTpw4oXz58unpp5+Wq6ur3nzzTVWvXl1ubm66deuWIiMjFR4ebm6qfPrpp3X69GnNmTNHHTt2zHIPMzIytH//frVv3/6+9/tuYmNjVb58+Sy/Z/fj5eWlCxcu6K+//lKJEiWszgcAAAAAAAAAAAAAAAAA5FyOmzALFiwoSUpISLDYPnbsWPNS1AsWLDDPxufh4aE2bdooKipKf/75p44dO2aegTA9Pd18/tNPPy07Ozvzz3ny5JGHh4f5ZycnJ0lScnKyeVuZMmXM3zs7O0u63Qx45zkpKSkPVMedDhw4kGXGz+rVq2d/Y6zUsmVLbdu2TR999JGOHTum+Ph4HTlyJEvOndeaJ08eScpyfzKv9ZlnnpGPj4+WL18uf39/LVu2TN7e3lmWSn8QpUuXtvi5Q4cO2rRpk1asWKETJ07o8OHDOnnypDw9PS2OK1u2rPn7zCbIzCXR33rrLY0fP14LFy5UrVq1VK9ePYWEhJibZO90+fJlnT17VtOmTbNYaj0jI0PJyck6deqU+TlyZ63u7u7q0KGD1q5dq4MHD+r48ePmxz1zGfNXX31VvXr1Uu3ateXv76+AgAA1a9ZMrq6u2rdvn5KTkzVkyBANGzbMPG5aWppSUlKUlJRkfu5lSkhIUGpqapYGSnt7e3Pm32VkZMje/v9+DR90KfJMmb+fFy5coAkTAAAAAAAAAAAAAAAATx5T9v05wOOW4yZMDw8PFSlSRDt27FCzZs3M24sVK2b+3s3Nzfx9fHy82rdvr0qVKikgIEANGzZUwYIF9dJLL1mMm90y2dk141kUbZ+17Ludk9M67mRnZ3fXprl7MZlMsrGxkXS7We9exowZo7Vr16pVq+VZr0UAAQAASURBVFaqX7++Xn/9dc2ZM0fnzp2zOO5BrlWS2rRpoylTpmjEiBFatWqVunfv/sDXcac7Gw1NJpN69eqlQ4cOqUWLFmrSpIkGDBigUaNGZTkvc1n6O2UuKd+xY0c1bdpUMTEx5kbUiIgILV++PMvMpJmPw7Bhw7I0xkpSiRIldP78+Sy1Xrx4US+//LIKFiyohg0bqnbt2vLx8VFQUJD5GH9/f8XExGjr1q3atm2blixZooiICM2ePVsuLi6SpKlTp1o0lN7r+v5ecyY3Nzddu3Yt22MTEhIsfm82b96sjz766K5j3y/zzoZmAAAAAAAAAAAAAAAAAMDjleMmTDs7O3Xp0kWffPKJ2rdvb16O+k5//fWX+fuFCxeqUKFCioyMNG/LnCUzsxkvN1hTR8WKFbV3716LbX//+U6ZjaTXr19X/vz5JUnHjx+3OCazOVOSrly5ooULF2rKlCkKDQ01bz9y5Ii5+c9azZs314QJExQZGakLFy6Yl/B+FA4cOKCYmBh988038vPzk3R7dssTJ05YzM55LxcvXtSnn36qnj17qnXr1mrdurXOnTunwMBA7dixw+J+SFKhQoVUqFAhnThxwmKZ77Vr12rDhg2aOHFitjmrVq1SQkKC1q9fb358MpdMz3zcp0+frmrVqqlhw4Zq2LChhg0bpmbNmmn9+vUaOHCg7O3tdebMGfNy5JI0f/58/fnnnxo3blyWTHd3dzk6OurKlSsW2318fPTFF18oOTnZPGtnZh07d+5UjRo1JN1uGL5586a8vb1zdC/vdPnyZUkyL+EOAAAAAAAAAAAAAAAAAHj8ctyEKUk9evTQgQMH1KFDB/Xs2VP169dXvnz5dPjwYUVFRWnr1q1q06aNJKl48eI6e/asYmJiVL58ecXFxem9996TJPPy2bnBmjrCwsLUqlUrffjhh2rTpo3i4+M1bdo0SZbNlJmqVKkiW1tbTZ06Vd26dVN8fLy++OILi2NcXFx09epVHT16VKVKlZKrq6s2btyoypUrKykpSVFRUYqLizM3N1rL1dVVjRs31ieffKJGjRpZzLJ4P3nz5tXp06d19uxZFS9ePMv+woULy97eXuvWrZO7u7sSEhI0Y8YMXbhwIcePaYECBfTjjz/qxIkTGjhwoPLly6clS5bIwcEh2+ZDGxsb9ejRQx999JGeeuopBQUF6fDhwxo7dqzq169/1xkpixcvrsTERK1bt07Vq1fXkSNH9MEHH0j6v8f9+PHjWrlypd599109/fTT2rNnj86cOSN/f3+5urqqXbt2mjp1qvLmzatq1app586dmjRpkl599dW7Xp+vr6/279+vVq1ambe1adNGc+fOVe/evfX666+rePHiOnfunKKiovTXX3+pW7dukm7PglmvXr0sM50mJSVp8+bNWbJ8fHzMy5AfOHBATz31lIoWLXqPuw8AAAAAAAAAAAAAAAAAeJQeqAkzs9Fw3bp1Wrp0qebPn69r166pcOHCql69uqKiosyz+nXp0kVHjhzR4MGDlZKSIk9PTw0YMEDTp0/Xvn37FBgY+Fgu6O+sqaNChQr6+OOP9dFHHykyMlJlypRRx44dFRERke3y6R4eHho3bpxmzJihb775RpUrV9bw4cP1+uuvm495/vnn9c033+iFF15QVFSUpk2bpgkTJqhFixZyc3NTzZo1NWDAAM2YMUO3bt16qGtu3bq1Vq1apdatWz/Qee3atdOQIUP0wgsvaNu2bVn2FytWTBMmTFBERIS+/PJLFSlSRPXr11fXrl21cePGHM1wam9vr1mzZmnixInq2rWrEhMT9eyzz+rzzz/X008/ne05YWFhcnJy0oIFCzRx4kQVKlRIrVu31ltvvXXXnKZNmyouLk4TJ07UjRs3VLJkSb300kvauHGj9u3bp/bt22vs2LGaOHGi3n77bSUkJKhkyZIaNGiQWrZsKen2Euju7u6aPn26zp8/r+LFi6tPnz7q2bPnXXMbNWqk6Ohoi20FChTQokWLNG3aNPXv319XrlyRm5ubatSooUWLFplnEd28ebPatm2bZcxLly5l2/g5d+5c8xLt27dvV8OGDe9aFwAAAAAAAAAAAAAAAADg0bMx5eba4P8S+/btk729vSpVqmTetmrVKg0fPly//vqr7O0fqHc11y1fvlxTp07Vpk2bssyqiMfr6tWrCg4OVmRkpHx8fHIl8/z582rYsKFWrVolT09Pq8b488L1R1tUDjnbZZ1ZNrcUdjYu2zbpqiG56S7uhuRKUkq6MW81Rr7FnbyeakjuM27GvUfZptw0JDfdOb8huZJkY+BzzCYt2ZBck13Wf5CSa9m2dobkXrqVZkiuJBXNSDAk1ybdmNcwSbqZt5ghuWdvGvc4G/U+KUlebsb8vXA51bi/Uwo6GZOdkJJhSK4kFTDopTtVxj3OTqnGfC6ZtifBkFxJequCMa8l6XkLGZIrSYdvGvPZQJJOXU0yJDfYw8WQXElKtTHmb439FxINyTVSrdLG/f0OAAAAAADwb5Z6/pjRJUCSQ1FPo0vIdXToZePgwYPq0qWLNm7cqDNnzmjbtm2KiIhQs2bN/tENmHFxcVq1apWmTp2qTp060YBpADc3N3Xv3l2RkZG5lrlgwQK1aNHC6gZMAAAAAAAAAAAAAAAAAIB1/rkdhQZ66aWXdP78eY0fP17nzp1ToUKF1KxZM/Xr18/o0u5pz549Cg8PV/369fXKK68YXc4T69VXX1X79u21b98++fr6Ptasv/76S999950WL178WHMAAAAAAAAAAAAAAAAAAFmxHDkAliPPZSxHnntYjjx3sRx5LmezHHmuYTny3MVy5LmL5chzD8uR5y6WI889LEeeu1iO/MnAcuQAAAAAAADWST131OgSIMmhWBmjS8h1rFcNAAAAAAAAAAAAAAAAAABgBZowAQAAAAAAAAAAAAAAAAAArEATJgAAAAAAAAAAAAAAAAAAgBVowgQAAAAAAAAAAAAAAAAAALACTZgAAAAAAAAAAAAAAAAAAABWoAkTAAAAAAAAAAAAAAAAAADACvZGFwDAeH9dTzEkt2aBZENyJel6egHDsvM5uBiSa5d8w5BcSUqxMeaa3c/sMiRXkvIVrmJIrm3KTUNyjWSbnmpYdqqNcR+lHGxsDMk19DmWZsz7VVFb4/7dklH322TnaEiuJOW9dd6QXDenIobkStK5m8a9jsmg19BCNhmG5EqSktIMib2emteQXElytrMzJNegtypJksneyZDc//kUNyRXkmzO7jQk1+HWFUNyJemmfXnDsp3sjfl8YH90hyG5knS0SA1DcgvlcTAkV5KS0o15v2o1e7shuZK0vEctw7IBAAAAAAAemsnA//+AJxozYQIAAAAAAAAAAAAAAAAAAFiBJkwAAAAAAAAAAAAAAAAAAAAr0IQJAAAAAAAAAAAAAAAAAABgBZowAQAAAAAAAAAAAAAAAAAArEATJgAAAAAAAAAAAAAAAAAAgBVowgQAAAAAAAAAAAAAAAAAALACTZgAAAAAAAAAAAAAAAAAAABWsDe6AAAAAAAAAAAAAAAAAAAAHoaNKcPoEvCEYiZMSTdu3JCfn5/q1KmjlJQUi32dO3fW0KFDJUmxsbHy8vLSqVOnrMo5deqUvLy8FBsbK0kaOnSoOnfu/HDFP6SIiAgFBwcbWsPD3tdMu3bt0s6dOx9RVda7ceOGQkNDdfbsWUlScHCwIiIisj02u+dASkqKqlatqnPnzt33OfLbb7+pbdu2SktLe3QXAAAAAAAAAAAAAAAAAADIEZowJa1Zs0aFChXSjRs3tGHDhlzLHTFixF2b8/DgOnTooBMnThhdhiZNmqTnn39exYsXt+r8Xbt2qVSpUipWrNh9j/Xx8VHZsmU1a9Ysq7IAAAAAAAAAAAAAAAAAANajCVPS0qVLVbduXdWuXVtff/11ruW6urqqQIECuZaHx+/EiRNatmyZunTpYvUYMTExCgoKyvHxYWFhmjVrlq5evWp1JgAAAAAAAAAAAAAAAADgwT3xTZjx8fHau3evAgIC1LRpU+3YsUPx8fE5Onf37t3y9/fXhx9+KOn2MtKTJ09Wo0aN5O3trZo1a2rAgAG6cuVKtuffudR05pLcMTExat68uby9vdWsWTP98MMP5uNNJpNmzZqlhg0bys/PTy1bttTKlSvvWaOXl5cWLlyo9u3by9fXVy1atNDGjRuzHDdr1iwFBQXJ19dXnTt31rFjx8z7EhISNHbsWPP+9u3bWyz7nZiYqBEjRiggIEA+Pj5q1aqVvvvuO/P+zp07a/z48Ro8eLCqVKmiwMBAff755zKZTBY1xMTEqEWLFuZr//HHH837rl27ptGjRysoKEiVK1dWQECARo8eraSkJPN1StKwYcPMy8fv2rVL3bp1U7Vq1eTt7a3mzZtr9erV5jEvXbqkfv36qWbNmvL19VW7du20Y8cO8/6UlBRNmjRJ9erVk7+/v15++WVt2bLlnvd77ty5qlmzptzd3e953L08aBNmxYoVVaxYMS1atMjqTAAAAAAAAAAAAAAAAADAg3vimzCXLFkiFxcXBQYGqlGjRnJ0dNTChQvve97evXv16quv6pVXXtGgQYMkSeHh4Vq9erXef/99rV+/XhMnTtTWrVv12Wef5bieSZMmacSIEYqOjpaHh4cGDRqkmzdvSpKmTJmir776SiNHjtSqVavUpUsXjRkzRl9++eU9xwwPD1fz5s21fPlyBQUFqU+fPtq9e7d5/+nTp7Vr1y7NnDlTUVFRunDhgkaMGCFJSk9PV1hYmHbu3KmJEydq2bJlqlixorp27arffvtNkjRt2jQdOnRIn3/+udauXavAwEC99dZbOnXqlDnjq6++Up48ebR06VK99dZb+uSTT7IsoT1//nzztXl6eqp///7max8yZIj27dun6dOna/369Ro2bJiio6PNjYeZzZHDhw/XiBEjdO7cOYWFhalixYqKjo7WihUr5OPjo2HDhunixYuSpDFjxigpKUlRUVFatWqVypQpozfeeEO3bt2SdLuh86efftKkSZO0bNkyhYSEqFevXhbNoX+3ceNGNWjQ4N4P8j2cOnVKFy9eVJUqVR7ovPr162vTpk1W5wIAAAAAAAAAAAAAAAAAHpy90QUYKS0tTatWrVKDBg2UJ08eSVJQUJBWrFihgQMHmrf9XVxcnEaMGKFu3bqpT58+5u0+Pj56/vnn9dxzz0mSSpYsqbp16+rQoUM5rql///6qXbu2+fuWLVvq8OHD8vLyUmRkpMLDw81Nfk8//bROnz6tOXPmqGPHjncds02bNub9gwYN0i+//KKoqChVrVpVkmRvb69JkybJ1dVVktSuXTtNmTJF0u3mxri4OK1atUoVKlSQJL3zzjvau3ev5syZo6lTp+rEiRPKly+fnn76abm6uurNN99U9erV5ebmZq6hbNmyGjNmjGxsbFSuXDnFx8dr/vz5evXVV83HDB8+XDVr1pQk9e7dW99//73i4+Pl6+urgIAAVa9eXRUrVpQklSpVSlFRUeZ7W6RIEUm3l3h3dXVVQkKC+vTpo+7du8vW9nav8Wuvvabo6GgdO3ZMhQsX1okTJ1ShQgU9/fTTcnJy0ogRI9SiRQvZ2dnp+PHjWr16tZYsWSIfHx9JUrdu3XTw4EHNmTNH9evXz3Kf//rrL507d858n6wRExOjgIAA2ds/2K+ml5eX5s+fr4yMDPP1AgAAAAAAAAAAAAAAAAAerye6CTMmJkYXLlxQaGioeVtoaKg2bNigNWvWqG3bttmeN2jQIKWmpqpUqVIW21u2bKlt27bpo48+0rFjxxQfH68jR46oevXqOa6pbNmy5u/z5csnSUpNTdWff/6p5ORkDRkyRMOGDTMfk5aWppSUFCUlJcnZ2TnbMTObQjP5+fnp559/Nv9cuHBhcwOmJOXPn9+8zPfhw4fl6upq0VhoY2Oj6tWr66effpIkvfrqq+rVq5dq164tf39/BQQEqFmzZhZjPvfcc7KxsTH/XKVKFc2aNctiqfYyZcpY1CDJXEeHDh20adMmrVixQidOnNDhw4d18uRJeXp6ZnvNHh4eatOmjaKiovTnn3/q2LFj+v333yXdnt1Tkvr06aO3335bGzZsUPXq1VW3bl2FhobKyclJBw4ckCR16dLFYtzU1FRzbX934cIFScqyFLm9vb0yMjKyPScjI8Oi4XLz5s1q0qRJtsfei7u7u9LS0pSQkPBQS6EDAAAAAAAAAAAAAAAAAHLuiW7CjI6OliT169cvy76vv/76rk2YvXv31tWrVzV+/HjVqVNHRYsWlXR7eeu1a9eqVatWql+/vl5//XXNmTNH586dy3FNjo6OWbaZTCaZTCZJ0tSpUy0aNe91Xqa/z6r499kS7ezs7nquyWSyaJ68c4zMcf39/RUTE6OtW7dq27ZtWrJkiSIiIjR79mzzrJ5/ryHzeu7Mzm4Gx8xr79Wrlw4dOqQWLVqoSZMmGjBggEaNGnXXuuPj49W+fXtVqlRJAQEBatiwoQoWLKiXXnrJfEzjxo31008/6aefftLPP/+s2bNna9q0afrmm2/M9X355ZfKmzevxdh3m2ky8z5lnpvJzc1N169fz/achIQE84yhycnJ2rFjh95///27XtfdZDZ5MgsmAAAAAAAAAAAAAAAAnkim7CdJAx63J7YJ8/Lly4qJiVHr1q3VrVs3i33z5s3TkiVLFBcXl+25zZs3V+HChbVhwwa98847mjFjhq5cuaKFCxdqypQpFjNrHjlyRC4uLg9db9myZWVvb68zZ86YlyOXpPnz5+vPP//UuHHj7nrub7/9puDgYPPPe/bsUeXKlXOU6+XlpWvXrunw4cMWs2Hu2rVL5cuXlyRNnz5d1apVU8OGDdWwYUMNGzZMzZo10/r1681NmL/99pvFuLt371apUqUsliy/mwMHDigmJkbffPON/Pz8JN2ekfLEiRPy8PDI9pyFCxeqUKFCioyMNG/btGmTpNtNkikpKZo8ebJatmyp0NBQhYaGKjExUXXr1tWPP/5oXm78/PnzFkuPT5kyRTY2Nurfv3+WzGLFikm6/dwqV66cebuPj4927tyZpaE1JSVF+/btMy/JHhsbqzJlyqhw4cL3vSd/d/nyZTk6OqpAgQIPfC4AAAAAAAAAAAAAAAAAwDpP7LR5K1asUFpamnr06KEKFSpYfPXq1Ut2dnZauHDhXc93dnbWu+++qx9++EErVqyQq6urXF1dtXHjRh0/flyHDh3SqFGjFBcXp5SUlIeu19XVVe3atdPUqVO1fPlynTx5UsuWLdOkSZPu27Q3b948rVq1SkePHtXEiRN18OBBvfLKKznKDQgIkJeXlwYOHKjY2FjFx8dr7NixOnz4sHmM48ePa/To0dq2bZtOnz6tb7/9VmfOnJG/v795nJ07d2r69Ok6evSolixZoi+//FI9evTIUQ2FCxeWvb291q1bp5MnT+q3335T//79deHCBYt76+Liovj4eF25ckXFixfX2bNnFRMTo9OnT+u7777TmDFjJN1ufnR0dNTevXs1atQo7dmzR6dOnVJ0dLRu3rwpf39/PfPMM2rQoIFGjx6tjRs36uTJk5ozZ45mzpx518bPokWL6qmnnsrSvNulSxcdO3ZMgwcP1v79+3Xq1Clt27ZNr732mpydnc2zc27evFlBQUFZxk1ISNDmzZuzfCUmJpqPOXDggLlBFQAAAAAAAAAAAAAAAACQO57YmTCjo6NVp04dixkLM3l4eKhx48Zas2aNPD097zpG7dq11bp1a/Oy5NOmTdOECRPUokULubm5qWbNmhowYIBmzJihW7duPXTNw4YNk7u7u6ZPn67z58+rePHi6tOnj3r27HnP8/73v/9p7ty5+uOPP1SxYkXNmTNHFStWzFGmvb295s6dq4kTJ6pv375KSUlR5cqVFRkZqSpVqkiSxo4dq4kTJ+rtt99WQkKCSpYsqUGDBqlly5bmcRo2bKg//vhDLVu2VNGiRTV06FC1b98+RzUUK1ZMEyZMUEREhL788ksVKVJE9evXV9euXbVx40bzDJNhYWGaPXu2jhw5omnTpunIkSMaPHiwUlJS5OnpqQEDBmj69Onat2+fAgMDNW3aNH3wwQd6/fXXdf36dZUtW1aTJ09W9erVJd2e9XLKlCkaPXq0rl69Kg8PD7377rtq06bNXWtt2LChtm/frq5du5q3eXp66uuvv9bHH3+snj176tq1a3J3d1fdunU1YcIE5c+fX9LtJszw8PAsYx4+fNg8W+advvvuO5UuXVqStH379nvWBQAAAAAAAAAAAAAAAAB49GxMJpPJ6CLw+Hh5eemDDz5Q69atDauhc+fOKlmypCZMmGBYDbnl6NGjeuGFF7Rp0yYVKVIkVzL37dunbt26adOmTTla3j07Px259IirypmaBZINyZWk6w4FDMvOp4efHdcaNhlphuRK0lUbF0Ny3c/sMiRXkk4UrmJIbkn7xPsf9B9jcshjWHaqjXH/nsUhw6DXkjTjXruVZsw1y9a4yeNtk64bkmuyczQkV5JkY2NI7EXH3Pnslp1zN1MNy37WNcOQXBuTMbmSJIM+Ex1PzWtIriQVcbEzJNfGoN9nSXKWMY/zuWTjrrnk2Z2G5No4GfNZX5J22Jc3LPtWarohuUFJ+wzJlaQ/itQwJNfOwNeSpHRj3q9GrfndkFxJWt6jlmHZAAAAAAAADyvtzCGjS4Ak+6e8jC4h1z2xy5EDj0OZMmX0wgsvKCoqKtcyIyMjFRYWZnUDJgAAAAAAAAAAAAAAAADAOjRhAo/Y0KFDtX79ev3111+PPWvfvn06duzYfZekBwAAAAAAAAAAAAAAAAA8esatoYlcceiQ8dPsLliwwOgScpWrq6u+/fbbXMny9fVVdHR0rmQBAAAAAAAAAAAAAAAA/1imDKMrwBOKmTABAAAAAAAAAAAAAAAAAACsQBMmAAAAAAAAAAAAAAAAAACAFWjCBAAAAAAAAAAAAAAAAAAAsAJNmAAAAAAAAAAAAAAAAAAAAFagCRMAAAAAAAAAAAAAAAAAAMAKNGECAAAAAAAAAAAAAAAAAABYgSZMAAAAAAAAAAAAAAAAAAAAK9iYTCaT0UUAMNb5qzcNyS2YdN6QXEkyOeU1LDvD0ZjsM7cyDMmVpAJOdobk5ku7ZkiuJJkc8hiSmygHQ3IlySXthiG5iQ6uhuRKknNGsmHZl9ONeawLZVw1JFeSTE4GPdYZ6cbkSrK9dcWQ3CvORQ3JlaR8jsa8ZzhcP2tIriRDn2MmeydDcjNcChqSK0kmW4OeY1dOGpIrSRkGfS4xOeUzJFeSTHbGvE/aZKQZkitJMug/79ikJRmSK0mHkox5bkuSh6tBzzEbG0NyJSlPsjGfS0wOLobkSsa9TyYb9+e7bA16irm6GPf7DAAAAAAA/jvSTsUZXQIk2ZeqbHQJuY6ZMAEAAAAAAAAAAAAAAAAAAKxAEyYAAAAAAAAAAAAAAAAAAIAVaMIEAAAAAAAAAAAAAAAAAACwAk2YAAAAAAAAAAAAAAAAAAAAVqAJEwAAAAAAAAAAAAAAAAAAwAo0YQIAAAAAAAAAAAAAAAAAAFiBJkwAAAAAAAAAAAAAAAAAAAAr2BtdAAAAAAAAAAAAAAAAAAAAD8PGlGF0CXhCMRPmv8zQoUPl5eV1z6/7OXPmjNasWZPjzOjo6HuOGxERkaUGX19fhYSEaObMmTKZTDnOys6VK1e0ePHiHB8fGxsrLy8vnTp16qFy7ycuLk5t27ZVRsaDvYA3adJEu3fvznbf0KFD1blzZ/PPXl5eio6OvutY7733niIjIx8oHwAAAAAAAAAAAAAAAADwaDAT5r/MiBEjNHDgQPPPdevW1fDhwxUaGprjMYYMGaKSJUuqWbNmj6yu4sWLa8mSJeafk5OTFRMTo/fee0+Ojo7q1q2b1WOHh4fr1KlTeumll3J0vL+/v7Zs2SJ3d3erM+8nNTVVQ4cO1fDhw2Vrm/Ne5pMnTyohIUF+fn6PpI6+ffuqWbNmatCggUqXLv1IxgQAAAAAAAAAAAAAAAAA5AwzYf7LuLq6qkiRIuavu23LbXZ2dhY1lCpVSh07dlTt2rW1cuXKhxr7QWfSdHR0VJEiRWRnZ/dQufeycuVK2dnZqXbt2g903o8//qiAgIBHVpubm5uaNWumiIiIRzIeAAAAAAAAAAAAAAAAACDnaML8D/rxxx/18ssvy9/fX3Xr1tWECROUnJwsSercubN27NihZcuWKTg4WJJ09uxZDRo0SHXq1FHlypUVFBSkKVOmPPAy29mxs7OTo6OjpNvLlrdr104DBgxQ1apVNXbsWEnSr7/+qi5duqhatWqqWbOmhg8frqtXr0q6vTz3smXLtGPHDvOS6CaTSbNmzVLDhg3l5+enli1bWjR6/n058uDgYH3++efq27ev/P39VbNmTY0fP15paWmSpPT0dE2aNElBQUHy9vZW06ZNtXDhwnte1xdffJFlJtEtW7aodevW8vX1VbNmzbRkyZIsy6LHxMQoMDDQfB2ffvqpAgMDVaVKFY0YMcL8OD2IkJAQrVu3TmfPnn3gcwEAAAAAAAAAAAAAAAAA1qMJ8z/m+++/1+uvv66goCAtXbpU7777rtatW6dBgwZJut0I6e/vr5CQEPPy4a+99pouX76sOXPm6Ntvv1WPHj00Y8YMbdq0yeo6kpKSFB0dra1bt6pp06bm7b/++qsKFSqkFStW6JVXXtG+ffvUuXNnlS9fXosWLdL06dO1b98+hYWFKSMjQyNGjFBISIh5iXFJmjJlir766iuNHDlSq1atUpcuXTRmzBh9+eWXd60nIiJCNWrU0LJly9S3b1/Nnz9fq1evliR99dVX+vbbbzVlyhStX79enTp10pgxY7Rz585sxzp27Jj+/PNPcxOrJP3+++967bXXVKtWLS1fvly9e/dWeHh4lnuya9cucxPm559/rtmzZ2vw4MGKjo5Wvnz5tHbt2ge+11WqVFH+/PkVExPzwOcCAAAAAAAAAAAAAAAAAKxnb3QBeLRmzpypxo0bq3fv3pKksmXLymQy6fXXX1d8fLzKlSsnBwcHOTs7y93dXUlJSWrZsqWaNGmikiVLSro9W+bnn3+uQ4cOqVGjRjnKPXPmjPz9/c0/37p1S66urnrllVf0yiuvWBzbr18/ubq6SpL69+8vLy8vvfPOO5Kk8uXLa/LkyXrhhRf0008/KSgoSM7OznJwcFCRIkV069YtRUZGKjw8XA0aNJAkPf300zp9+rTmzJmjjh07ZltfvXr11KVLF0mSp6enlixZot27d6tVq1Y6ceKEXFxc5OHhoSJFiqhTp04qW7asypQpk+1Ye/bskYODgzw9Pc3bIiMj5e3trcGDB5vv+6VLl/Tee++Zj4mNjVX58uXl7u4uk8mkBQsWqEuXLmrevLkkadiwYYqNjc3R/f67ChUqaO/evfrf//5n1fkAAAAAAAAAAAAAAAAAgAdHE+Z/zOHDh7Msk12jRg1J0qFDh1SuXDmLfc7OzurUqZO+/fZbzZs3T8ePH9fBgwd1/vz5B1qOvGjRolqwYIEkycbGRs7OzipSpIhsbGwsjitUqJC5ATOz3oCAAItjvLy8lD9/fh06dEhBQUEW+/78808lJydryJAhGjZsmHl7WlqaUlJSlJSUlG19f79uV1dXpaamSpI6duyo77//XoGBgfL29lZAQIBCQkJUqFChbMe6ePGiChQoIDs7O/O2AwcOqE6dOhbHVa9e3eLnO5civ3Llii5cuCAfHx+LY6pUqaL4+Phsc+/F3d1dFy9efODzAAAAAAAAAAAAAAAAgP+EB+h1Ah4lmjD/Y0wmU5bGx/T0dEmSvX3WhzsxMVEdO3ZUYmKiQkJC1LJlS40aNequM0rejb29vUqXLn3f45ydne9bryRlZGTIwcEhy3aTySRJmjp1qsqWLZtlv6OjY7a52W3PHMvT01PfffedduzYoa1bt2rjxo2aMWOGPvjgA7344otZzrOxscnSoGpnZ3ffptXNmzfro48+yraGTNk9RjmRnp4uW1tbq84FAAAAAAAAAAAAAAAAAFiHrq3/mAoVKmjXrl0W23bu3Ckp62yQkvTTTz8pLi5OCxYsUL9+/RQaGqp8+fLp0qVLWRoEH1e9mfVlOnjwoG7cuGGu984mzbJly8re3l5nzpxR6dKlzV8xMTGaM2eOVY2I8+fP13fffaeAgAANHjxYq1atUu3atbV27dpsjy9WrJgSEhIsmi4rVqyovXv3Whx358/x8fG6efOmvL29Jd2eubJEiRJZHqv9+/c/cP3S7Zk1ixYtatW5AAAAAAAAAAAAAAAAAADr0IT5H9O9e3d99913+uSTT3T06FH98MMPevfdd9WgQQNzU2PevHl1+vRpnT17VsWLF5ckrVy5UqdPn9bOnTv1xhtvKDU1VSkpKY+93q5du+rgwYMaN26c4uPjtWPHDg0aNEiVKlVS7dq1JUkuLi46f/68Tp48KVdXV7Vr105Tp07V8uXLdfLkSS1btkyTJk1S4cKFrarh0qVLGjdunDZu3KjTp09r8+bNOnDggPz9/bM93s/PT+np6Tp48KB5W1hYmPbv368PP/xQR48e1ffff69p06ZJut1EunnzZtWrV8+iSfTVV1/Vl19+qcWLF+vo0aOaOnWq9u3blyXv8OHD2rx5s8XXnQ2eGRkZOnjwoPz8/Ky6fgAAAAAAAAAAAAAAAACAdViO/D8mJCRE6enpmjlzpj777DO5u7urefPm6tevn/mYdu3aaciQIXrhhRe0bds2DRs2TJGRkZo6daqKFSum0NBQlShRIsvMjo+Dv7+/Zs2apWnTpqlVq1bKly+fGjVqpIEDB5qXI2/VqpU2bNig5s2ba8OGDRo2bJjc3d01ffp0nT9/XsWLF1efPn3Us2dPq2ro06eP0tLS9O677+rixYsqUqSIOnTooNdeey3b4z08PFShQgVt375dlSpVknR7Rs+PP/5YH330kSIjI1WmTBl17NhRERERcnBw0ObNm9W2bVuLcTp27KiMjAx99tlnunjxourVq6e2bdvq6NGjFsfNnTtXc+fOtdhWtWpVLVy4UJIUFxenmzdvqkGDBlZdPwAAAAAAAAAAAAAAAADAOjam3FhzGviPWbx4sebNm6fVq1dLkvbt2yd7e3tzU6YkrVq1SsOHD9evv/4qe/vH1+88ZswY3bp1S+Hh4VaPcf7qzUdYUc4VTDpvSK4kmZzyGpad4WhM9plbGYbkSlIBJztDcvOlXTMkV5JMDnkMyU2UgyG5kuSSdsOQ3EQHV0NyJck5I9mw7MvpxjzWhTKuGpIrSSYngx7rjHRjciXZ3rpiSO4V56KG5EpSPkdj3jMcrp81JFeSoc8xk72TIbkZLgUNyZUkk61Bz7ErJw3JlaQMgz6XmJzyGZIrSSY7Y94nbTLSDMmVJBn0n3ds0pIMyZWkQ0nGPLclycPVoOeYjY0huZKUJ9mYzyUmBxdDciXj3ieTjfvzXbYGPcVcXYz7fQYAAAAAAP8d6ccf/4RzuD+70k/ear4sRw5Y4cUXX1RaWpq2bt0qSTp48KC6dOmijRs36syZM9q2bZsiIiLUrFmzx9qAefnyZa1fv15vvPHGY8sAAAAAAAAAAAAAAAAAAGSP5cgBK9jb2ys8PFxjxoxR7dq19dJLL+n8+fMaP368zp07p0KFCqlZs2YWy8A/DhEREerRo4c8PT0faw4AAAAAAAAAAAAAAAAAICuWIwfAcuS5jOXIcw/LkeculiPPXSxHnotYjjxXsRx57mI58tzDcuS5nM1y5LmG5chzF8uR53I2y5HnGpYjBwAAAAAAj0L6sT1GlwBJdp5VjC4h17EcOQAAAAAAAAAAAAAAAAAAgBVowgQAAAAAAAAAAAAAAAAAALACTZgAAAAAAAAAAAAAAAAAAABWoAkTAAAAAAAAAAAAAAAAAADACjRhAgAAAAAAAAAAAAAAAAAAWIEmTAAAAAAAAAAAAAAAAAAAACvYG10AAOO52aYakpuRr7AhuZJ0McW4HvTLV9MMyfVyMeZxlqQ/bzoaklvWzc2QXEk6ed2Yx7m0fYIhuZJkcnI1JDdP8hVDco2WlGHM/f78j2RDciWp57MGfXTNMOb3WZLS3EoYklsgMcGQXEkypRrznmGbfN2QXElKK/i0YdkmW2N+r2zSjftckmFjZ0juWSdjfp8lKd1kTK6rgf/uM29akmHZTxqTY17DsisY85YhSbqWbkxufjvjPpdsvuRgSK5/ceMe6IxUY15A7WwMiZUkpRj0nuF09aIxwZIc3Yz771MAAAAAAAD4b6AJEwAAAAAAAAAAAAAAAADw72bKMLoCPKFYjhwAAAAAAAAAAAAAAAAAAMAKNGECAAAAAAAAAAAAAAAAAABYgSZMAAAAAAAAAAAAAAAAAAAAK9CECQAAAAAAAAAAAAAAAAAAYAWaMAEAAAAAAAAAAAAAAAAAAKxAEyYAAAAAAAAAAAAAAAAAAIAV7I0uAAAAAAAAAAAAAAAAAACAh2FjyjC6BDyhmAnzCZCWlqZ58+apdevW8vf3V82aNdWtWzdt27YtV/KvXLmixYsXm3/u3Lmzhg4dmuPzg4ODFRER8ThKs3D27FmFhITo5s2bjzUnJSVFVatW1blz57Ldf+f9OXXqlLy8vBQbG3vX8Xr16qUNGzY8lloBAAAAAAAAAAAAAAAAAHfHTJj/cSkpKerWrZv++usv9e3bV/7+/kpKStLSpUsVFhamDz74QK1atXqsNYSHh+vUqVN66aWXJEkRERGys7PL8flLliyRk5PT4yrPbOTIkQoLC1PevHkfa86uXbtUqlQpFStW7JGMN3ToUHXp0kU1atRQgQIFHsmYAAAAAAAAAAAAAAAAAID7ownzP2769Ok6ePCg1qxZo+LFi5u3jxgxQrdu3dL48ePVuHHjx9p4aDKZLH5+0EZBd3f3R1hN9rZv3664uDjNmDHjsWfFxMQoKCjokY3n6ekpX19fzZ07V2+99dYjGxcAAAAAAAAAAAAAAAAAcG8sR/4flpqaqsWLF6tt27YWDZiZ3nzzTc2ePVvOzs6SJC8vL02ZMuX/sXffYVWX/x/HX2xEEAVxRqCkqAmCWkqmJmbmHuEo0xRHllqOcm/NReagcm9zi+YqKytLU8td5siZey8crHN+f/jjfCVwHced+Xxc17kuzmfcr/fnwOGcg2/vWxUqVFCZMmW0f/9+JSYmKiYmRmXLllV4eLjq16+vNWvWpBln4cKFql27tkJDQxUWFqbGjRtrx44dkm7M0rho0SL9+uuvCg4OlpR2ue24uDhFRkZq0aJFqlSpkooWLarXXntNW7ZssY1/83LksbGxaty4sSZMmKBy5copJCRETZo00f79+23HX758Wb169VLp0qVVokQJNWnSRL///vttH6vJkyercuXKcna+0Ze8YcMGFSlSROvXr1fVqlUVEhKiBg0a6MCBAxozZoxeeOEFPf/88xowYECaJtOlS5eqSpUqCgkJUVRUlKZNm2a77lQ3N2EmJiZq0KBBioiIUMmSJTV8+HBZLJbb1pqRKlWqaPbs2bp+/fo9nwsAAAAAAAAAAAAAAAAAsA9NmP9hhw8f1oULFxQWFpbh/hw5cig0NDTN0uBz587V6NGj9dlnnyl//vzq1q2bfv75Z8XExGjRokWqUqWKWrdurR9//FGS9O2336pPnz5q2rSpvvrqK02bNk3Xr19Xjx49JN2YcbNKlSoKDw9P17yZ6tSpU5ozZ45iYmI0d+5cOTo6qkuXLulm0Ey1ZcsW/fbbbxo/frymTp2qY8eOqV+/fpJuzLrZsmVLHTx4UOPGjdO8efMUFham119/XX/++WeG4127dk2//PKLKlSokGZ7SkqKhgwZokGDBmnevHk6e/asGjZsqH379mnGjBnq2LGjZs6caXssfvjhB3Xp0kVRUVFasmSJXnvtNQ0fPjzNmEeOHNGZM2ds35OBAwdqxYoVGjJkiGbPnq1jx45p48aNGdZ5O+XLl9elS5fsOhcAAAAAAAAAAAAAAAAAYB+aMP/DLl68KEny9va+63Nq1aqlkJAQhYWF6dChQ1q2bJk++ugjlS5dWoGBgWrWrJmqVaumSZMmSbqxtPjAgQNVu3Zt5c2bV8WKFVO9evW0e/duSZKXl5fc3d3l4uIiPz+/DDOTkpLUt29fhYWF6dlnn9Xbb7+tQ4cO6fTp0xken5ycrGHDhqlQoUIqUaKEGjdurE2bNkm6saz4li1bNGrUKBUrVkxBQUHq2LGjwsLCNH369AzH27Fjh5KSktLNWCndmC00LCxMhQsX1iuvvKIrV65owIABCgoKUsOGDZU9e3b99ddfkqRJkybp1VdfVfPmzZUvXz69/vrreuONN9KMt3r1apUpU0bOzs6Kj49XXFyc3n//fZUvX14FChTQoEGDbvk43Y6np6eeeuopbdu27Z7PBQAAAAAAAAAAAAAAAADYx9l0AXh4fHx8JEkXLly463MCAgJsX6fOHNmkSZM0xyQlJSlLliySpOeee04+Pj76/PPPdejQIR04cEA7d+685yW1g4KCbF97eXnZcjKSPXt2Zc2aNc3xqcemLoNesWLFNOckJiYqISEhw/FSmz1TH6+b5cuXz/Z1pkyZlD17dmXKlMm2zc3NzTbujh079Morr6Q5v2TJkpoyZYrt/k8//aTKlStLkg4cOKCkpCSFhISkGa9w4cIZ1nknPj4+OnPmjF3nAgAAAAAAAAAAAAAAAADuHU2Y/2H+/v7Knj27tmzZoqpVq6bbf/DgQfXv319dunSxzQLp7u5u25+6HPgXX3yhzJkzpznX0fHGJKrLly9X586dVb16dYWGhioqKkp79uxR//7976lWV1fXdNtutRx5Rsemslgs8vT0VFxc3F2f5+DgYDv3n5yd0z5FUq87I87OzrdtPk1ISNCvv/6qjz766JbHZJR5t1JSUtIsLQ8AAAAAAAAAAAAAAAA8Maz3Nmkc8KCwHPl/mKOjo6KiohQXF6eTJ0+m2z9x4kRt3bpVefPmzfD8AgUKSJJOnTqlgIAA2y0uLk4LFy6UJI0dO1ZRUVEaOnSoGjVqpOeee06HDx+W9L8mytQmx0ehYMGCio+PV2JiYpqaJ0yYoFWrVmV4Ts6cOSVJ586du6/sQoUKpVsO/Ob7GzZsUL58+ZQ9e3ZJN2b/dHNzsy2lLt1Yan3Xrl125Z8/f96upcwBAAAAAAAAAAAAAAAAAPZhJsz/uNatW+vnn39Ww4YN9f7776t48eK6ePGi5syZo7i4OH388cfy9PTM8NwCBQqoQoUK6tOnj3r37q2CBQvqm2++0bhx42yzOebOnVubN2/Wjh075OXlpe+//14zZ86UdGMJcDc3N3l4eOjUqVM6fPiw/P39H+r1li1bVoULF1b79u3Vs2dP5cmTR3PmzNHChQs1efLkDM8JDg6Wm5ubduzYoTx58tid3bJlS7Vu3VpTpkxRZGSkNm/erBkzZtj2//TTTypfvrztvoeHh958802NHj1afn5+CgoK0uTJkzNsmN2+fXu65dRz5MihQoUKSbrRgHns2DEVK1bM7voBAAAAAAAAAAAAAAAAAPeGJsz/uEyZMmnmzJmaPHmyJkyYoGPHjsnNzU3PPvuspk2bpueff/62548YMUIjRoxQnz59dPHiRfn7+2vAgAF67bXXJEm9evVS79699eabb8rV1VWFChXSsGHD1KFDB23btk3PP/+8ateurW+//VbVq1fXt99++1Cv18nJSZMnT1ZMTIw6dOiga9euKSgoSLGxsYqIiMjwHA8PD73wwgtav369KlWqZHd2uXLl1K9fP40bN07Dhw9X0aJF1bBhQ1tT6k8//aRhw4alOadTp05yc3NT//79deXKFVWpUkWRkZHpxv7444/TbatRo4Zt+4YNG+Tt7a2SJUvaXT8AAAAAAAAAAAAAAAAA4N44WFPXjAaeYOvWrVP79u31888/y9XV1a4xfv31V2XPnl358+e3bRs7dqwWLFig77777kGVmqGWLVuqaNGiev/99+06P+HyhQdb0N1ydDKTK+lMoqOx7HPXk43kBnskGcmVpL3X7Hte3a/83i5GciXp8GUz3+cA58tGciXJ6uZlJNchwdw1m3TUYubxXv7XGSO5ktSqcGYzwRYzz2dJSvHwMZLrdO2CkVxJsjqZec1wvnjUSK4kJWd72li21dHM/8tzSDH3viTF2d1I7rlrBn+XGPrU7+Vq7j13Zut1Y9lPHCdz77lNupRi5vNsFqcUI7mS9PMxM8+r8FyG3gNKshj6/enkYCZXMvea4W29aiZYkqt3dmPZAAAAAADgwbLs+9V0CZDkGHT7SQH/i8z9iwjwLxIREaHChQtr8eLFdo+xdu1aNW/eXOvXr9exY8e0atUqTZs2TbVq1XpwhWZg79692rFjh5o2bfpQcwAAAAAAAAAAAAAAAAAAabEcOfD/PvroI0VHR6tatWrKnPneZ1lo06aNrly5os6dO+vcuXPKnTu3mjZtqhYtWjyEav8nJiZGvXv3lre390PNAQAAAAAAAAAAAAAAAACkRRMm8P/y5s2rlStX2n2+q6urevbsqZ49ez7Aqu5s3LhxjzQPAAAAAAAAAAAAAAAAAHADTZgAAAAAAAAAAAAAAAAAgMeb1WK6AjyhHE0XAAAAAAAAAAAAAAAAAAAA8DiiCRMAAAAAAAAAAAAAAAAAAMAONGECAAAAAAAAAAAAAAAAAADYgSZMAAAAAAAAAAAAAAAAAAAAO9CECQAAAAAAAAAAAAAAAAAAYAeaMAEAAAAAAAAAAAAAAAAAAOzgbLoAAOadSXYxkuvtZq4PPCEl2Vh2sMtlI7lWZ28juZLkn8XMy83JqylGciXpwnUzP2MBHhYjuZLkkJxgJNfibu5n2+XsfmPZ2bJlNZLbsmg2I7mSdDTByUiut5uZXEnyunzKSG6Kp5+RXEk6n2Dm95hDlvxGciVpzNrDxrJfD8tjJDeTs7mPorkt8UZyXZ0yGcmVpCxm3u7rbILVTLAkTyUayT0tLyO5kpTdOclIrtXB3Oe6ZIP/tzjZYub1yunyESO5khSU7SkjuUkWc79LXBwdjOSeuGLubxZWQw935qyeZoIlXbh4xVh2Du/MxrIBAAAAAPhPspjrEcCTjZkwAQAAAAAAAAAAAAAAAAAA7EATJgAAAAAAAAAAAAAAAAAAgB1owgQAAAAAAAAAAAAAAAAAALADTZgAAAAAAAAAAAAAAAAAAAB2oAkTAAAAAAAAAAAAAAAAAADADjRhAgAAAAAAAAAAAAAAAAAA2IEmTAAAAAAAAAAAAAAAAAAAADs4my4AAAAAAAAAAAAAAAAAAID7YbVYTJeAJxQzYf4HREZG6qWXXlJ8fHy6fV27dlXjxo0fav6jyLhbFy9eVPPmzRUSEqKyZcvKksEv1+DgYNWtW1fJycnp9jVu3Fhdu3a9rxru9fGIjY1VZGTkfWUCAAAAAAAAAAAAAAAAAB49mjD/I44fP64hQ4aYLsO4xYsXa8OGDZoxY4bmzZsnR8eMf8R37NihCRMmPOLqAAAAAAAAAAAAAAAAAAD/JTRh/kf4+/tr/vz5+vnnn02XYtTly5fl5+ensLAw5c6d+5bH+fv767PPPtPu3bsfYXUAAAAAAAAAAAAAAAAAgP8SmjD/I2rWrKmIiAj16tUrw2XJUwUHBysuLi7NtsjISMXGxkqS4uLiVKlSJa1YsUKRkZEKDQ1V8+bNdfLkSX300Ud67rnn9MILL2jcuHFpxkhOTtbAgQNVokQJlS5dWp988kma5b5PnjypDh06qGTJkipVqpRat26tgwcP2vZ37dpVbdu2VXR0tIoXL55u/FT79u1T69atVapUKZUoUULvvfeejh07ZhsjNjZWx44dU3BwsO2aMtKiRQsFBASoW7duGS5Lnur48eP64IMPVKZMGYWFhal58+ZpGjetVqs+//xzlStXTmFhYerRo4cSEhJs+48cOaLg4GBt2LAhzbgZfR9SXb58Wb169VLp0qVVokQJNWnSRL///rtt/7Vr19SjRw+VKVNGISEhql27tr755ptbXgMAAAAAAAAAAAAAAAAA4OGgCfM/wsHBQR999JEuXbqkwYMH39dYx48f1+zZs/X5559rypQp+v3331WzZk05Oztr3rx5atiwoT755BPt2bPHds7mzZt15swZzZkzR4MHD9bChQtty6NfvXpVjRs3VkpKimbOnKkZM2YoW7Zsql+/vk6ePGkb49tvv9ULL7yghQsXqmbNmunqOnr0qBo0aCBXV1dNmzZNU6ZM0dmzZ/Xmm28qPj5ePXr0UHR0tHLlyqU1a9YoOjr6ltfo6uqqwYMHa9euXRo/fnyGx8THx+v111/XyZMnNWbMGM2ZM0ceHh568803bY2f48eP18SJE9W5c2fFxcXJ09NTK1assOtxl240dbZs2VIHDx7UuHHjNG/ePIWFhen111/Xn3/+KUkaNWqUdu/erfHjx2vFihUqV66cOnTooCNHjtidCwAAAAAAAAAAAAAAAAC4dzRh/ofkzZtXH374oRYsWHBfy5InJSWpV69eKlSokEqUKKGIiAi5u7urc+fOypcvn95++21J0l9//WU7x8/PT0OHDlWBAgVUoUIFvf/++5ozZ46uXbum5cuX6/z58xo+fLgKFSqkggUL6qOPPpKnp6fmzZtnG8Pb21stWrRQvnz5MlxKfNasWfLw8NDHH3+sQoUKKTQ0VKNHj9bZs2e1ZMkSeXl5ycPDQ05OTvLz81PmzJlve52hoaGKjo7W559/nuGy5EuWLNH58+c1atQohYaGqlChQvr444/l7u6uL774QlarVTNmzFCTJk1UvXp15c+fX926dVPhwoXtfei1fv16bdmyRaNGjVKxYsUUFBSkjh07KiwsTNOnT5ck/f333/L09NTTTz8tf39/vf/++xozZoy8vb3tzgUAAAAAAAAAAAAAAAAA3Dtn0wXgwWrYsKFWrlypXr16admyZXaPky9fPtvXmTJl0lNPPSUHBwdJkpubmySlWXa7aNGitu3SjQbHpKQkHTx4UH/++afi4+P1/PPPp8lISEjQvn37bPcDAgJuW9OePXtUtGhRubq62rb5+voqX758GTZR3o333ntPP/zwg7p165amITQ1LzAwUD4+PrZtbm5uCg0N1e7du3X+/HmdPn1aISEhac4LCwtLc133YseOHZKkihUrptmemJhoe7xbtmyp1q1bKyIiQuHh4SpTpoyqVasmLy8vuzIBAAAAAAAAAAAAAAAAAPahCfM/JnVZ8ho1atxyWXKr1ZrmflJSUrpjXFxc0tx3dLz9pKlOTk5p7lssFkk3lv22WCzKly+fxowZk+48Dw8P29fu7u63zbBarbZG0JulpKSkq/dupS5L3rBhw3TLkt8uz9nZOc1xN7t5X0bHZPR4p7JYLPL09FRcXFyGtUpSeHi4Vq9erbVr12rdunVasGCBYmNjNXHiREVERNxybAAAAAAAAAAAAAAAAOA/y5JiugI8oViO/D8ob9686ty5sxYsWKCNGzem2efi4qLLly/b7sfHx+vcuXP3nblz505b46Ukbdq0Se7u7vL391fBggV17NgxeXl5KSAgQAEBAcqbN6+GDx+u33777a4zChYsqO3btysxMdG27cyZMzp06JCCgoLsrj00NFTNmzfX559/rsOHD6fJO3DggM6ePWvblpCQoD/++EPPPPOMfHx8lDt3bm3atCnNeH/88Yft69Tm0Pj4eNu2v//++7bXGB8fr8TERNtjFRAQoAkTJmjVqlWSpNGjR2vTpk2qWLGievbsqZUrV8rf318rV660+zEAAAAAAAAAAAAAAAAAANw7mjD/oxo2bKgXXnghTVOhdGMWxblz52rHjh3as2ePOnfunOHMjffq+PHj6t69u/766y+tXLlSsbGxatGihVxdXVWzZk15e3urbdu22rp1q/bt26du3bpp9erVKlCgwF1nvP7664qPj9cHH3ygXbt2afv27Xr//feVLVs2VatW7b7qb9eunQICAnT8+HHbtho1aihLlixq3769tm/frl27dunDDz/U1atX1aBBA0k3lgb/4osvNH/+fB04cEAjR47U9u3bbWPkyJFD/v7+mjJlivbu3avff/9dvXr1SrOk+s3Kli2rwoULq3379lq3bp0OHTqkoUOHauHChbZG00OHDqlPnz5at26djh49qq+//lrHjh1TeHj4fT0GAAAAAAAAAAAAAAAAAIB7QxPmf9jAgQOVOXPmNNv69u0rPz8/NWzYUC1bttTzzz//QJr3KlasKCcnJ9WvX1/9+vXT66+/rnfffVeS5OXlpZkzZ8rX11ctWrRQVFSUjh49qkmTJt1TE6a/v79mzJihS5cuqUGDBmrevLn8/Pw0e/ZsZcmS5b7qT12W/OZl1bNkyaKZM2fKy8tLTZs21RtvvKFr165p9uzZ8vf3lyQ1atRIH374ocaMGaNatWrpr7/+UlRUlG0MBwcHxcTEKCEhQbVr11anTp30xhtvKFeuXBnW4eTkpMmTJys0NFQdOnRQzZo1tWHDBsXGxtqWGu/Xr58iIiL04YcfqnLlyho9erQ++OAD1apV674eAwAAAAAAAAAAAAAAAADAvXGwWq1W00UAMOvo+StGcr3dzPWBn7qabCz7KV00kmvN5G0kV5ISHe5/xl17nLuWYiRXkk5dSTKSW8zDzPNZkuTibiTW4pLJSK4kuZzdbyz7crYgI7mZrIlGciXpWILTnQ96CLzdzORKktf1M0ZyUzz9jORK0vkEi5FcBwcjsZKkMesP3/mgh+T1sDxGcjM5m3sfmNv5upHcCzL3epXFxUzu2QQzuZLkp8tGck/Ly0iuJGV3NvP+0+pk6AdMUrLB/1t8OdHM65Xflb+N5ErSYbenjORmcjH3fXZxNPMG4eQVc3+zMPWX4nxZM1415lGITzT3t4Mc3pnvfBAAAAAAALhrKX/+aLoESHIq8pLpEh45ZsIEAAAAAAAAAAAAAAAAAACwA02YAAAAAAAAAAAAAAAAAAAAdjCzPiwAAAAAAAAAAAAAAAAAAA+KJcV0BXhCMRMmAAAAAAAAAAAAAAAAAACAHWjCBAAAAAAAAAAAAAAAAAAAsANNmAAAAAAAAAAAAAAAAAAAAHagCRMAAAAAAAAAAAAAAAAAAMAONGECAAAAAAAAAAAAAAAAAADYgSZMAAAAAAAAAAAAAAAAAAAAOzibLgCAeYcvJRjJzeV41EiuJF13CTCW7ZrrKSO5SSf2GcmVJDe3zEZyc/2+ykiuJF0vUsNI7rVMvkZyJcnJwUyusyxmgiWlZDb3eJ+/nmIkN97R3NvH7B5ORnLPXE02kitJHr8tN5Lr5JfXSK4k+SYnGck9V+RVI7mSFODrYSz76SyuRnLdTu4ykitJ13IEm8m9Zub3tiRl1XUjuTmvnDSSK0ky9Hp1VpmM5EpSDpdLRnIdzx4ykitJR3zDjGX/fdHM88rB72kjuZLkf/mgkVyLYzYjuZIkQ7+6DyaZe29wMcHMe7Fnshj6QCkpi6u5zzgHzlw2kpsvu5eRXAAAAAAAgP8qmjABAAAAAAAAAAAAAAAAAI81a4q5CRHwZGM5cgAAAAAAAAAAAAAAAAAAADvQhAkAAAAAAAAAAAAAAAAAAGAHmjABAAAAAAAAAAAAAAAAAADsQBMmAAAAAAAAAAAAAAAAAACAHWjCBAAAAAAAAAAAAAAAAAAAsANNmAAAAAAAAAAAAAAAAAAAAHagCRMAAAAAAAAAAAAAAAAAAMAORpswIyMjFRwcrClTpmS4v3fv3goODlZsbOw9jXkvx9ura9euaty4sSTpyJEjCg4O1oYNGx56rr02bNig4OBgHTlyxGgdP//8s15++WUVLVpUQ4cOfWS5sbGxioyMvOvj4+LiFBwcfN+58fHxqlq1qk6cOHHfY2Vk4MCBmjp16kMZGwAAAAAAAAAAAAAAAHhsWCzc/g23J5Cz6QJcXFz09ddfq1mzZmm2Jycn65tvvpGDg8M9jbdgwQK5ubk9yBLvKHfu3FqzZo28vb0fae69CA8P15o1a+Tj42O0juHDh8vf319Tp05V5syZjdbyKMTExOiVV15Rrly5Hsr47dq1U7Vq1VShQgUFBAQ8lAwAAAAAAAAAAAAAAAAAQMaML0ceERGhbdu26fjx42m2r1+/Xh4eHsqdO/c9jefj4/PIm/ucnJzk5+cnV1fXR5p7L1xdXeXn5ycnJyejdVy6dEnh4eF66qmnlC1bNqO1PGx///23Fi1apCZNmjy0DG9vb1WrVu2RzP4KAAAAAAAAAAAAAAAAAEjLeBNmaGio8uTJo6+//jrN9hUrVqhKlSrpZsJcuHChateurdDQUIWFhalx48basWOHbf8/lyP/8ccfVb9+fYWHh+vFF1/UkCFDlJCQYNsfHBysESNGqEKFCipTpoz279+frkar1arPP/9c5cqVU1hYmHr06JFmjH8uR964cWONHDlSvXr1Unh4uEqXLq3PP/9c+/fvV6NGjRQaGqqaNWtq+/bttjEuX76sXr16qXTp0ipRooSaNGmi33//3bY/NjZWjRs31oQJE1SuXDmFhISoSZMmaepdvXq16tatq2LFiikiIkJdu3bVxYsXJaVfjvz69esaOXKkKlasqJCQENWuXVvfffedbay4uDhFRkZq0aJFqlSpkooWLarXXntNW7Zsud23U4sXL1bNmjUVGhqqyMhIjR07Vpb/n2Y2ODhYR48e1WeffXbLpdHv5jovXLigfv36qXz58goNDdXrr7+ujRs3phln7ty5qlSpkkJDQ/Xuu+/aHodUwcHBiouLS7PtdkvZJyYmKiYmRmXLllV4eLjq16+vNWvW3PaxmDJlikqVKpVm9tFz586pS5cuKlWqlEqUKKGWLVvq4MGDtmtv2rSppk+frhdffFFhYWHq2LGjTp8+rc6dOys8PFzly5fXokWL0uRUqVJFX3311UNb8hwAAAAAAAAAAAAAAAAATEtISFC/fv0UERGh8PBwvffeezp79uxtz9m8ebMaN26sEiVKqGzZsurRo4cuXLhg25+UlKSiRYsqODg4zW3EiBF3XZfxJkzpRhPZzU2YiYmJ+u6771StWrU0x3377bfq06ePmjZtqq+++krTpk3T9evX1aNHjwzH/e677/TOO++ofPnyWrhwoQYMGKCvvvpKH3zwQZrj5s6dq9GjR+uzzz5T/vz5040zfvx4TZw4UZ07d1ZcXJw8PT21YsWK217TxIkTlTt3bi1ZskSNGzfWqFGj9Pbbbys6Olrz58+Xm5ub+vbtK+lGk2dqM964ceM0b948hYWF6fXXX9eff/5pG3PLli367bffNH78eE2dOlXHjh1Tv379JN1o7mvbtq1ee+01rVixQp9++ql+++03DRs2LMP6OnbsqMWLF6tHjx5asmSJXn75ZbVt21arVq2yHXPq1CnNmTNHMTExmjt3rhwdHdWlSxdZrdYMx5w6dap69eqlBg0aaMmSJerQoYMmTZpkq2HNmjXKlSuXoqOjtWbNmlvOcnq760xJSVF0dLQ2btyooUOHatGiRSpUqJCaNm1qa1pdvny5+vfvr6ZNm+rLL79UWFiYvvjii9t+v+6kW7du+vnnnxUTE6NFixapSpUqat26tX788cdbnrNq1SpVqFDBdj85OVnR0dHas2ePPvvsM82bN09OTk6Kjo5WcnKyJGnjxo3auHGjpk2bppEjR2rlypWqXr26ChcurIULF6pcuXLq3bu3zp8/bxs3LCxMWbJk0erVq+/rGgEAAAAAAAAAAAAAAADg36pv375au3atYmNjNW3aNB0+fFjvv//+LY8/cOCAmjdvrkKFCmn+/PkaMWKEtm/frvfee892zP79+5WUlKQvv/xSa9assd1atWp113U539dVPSBVqlTRpEmTdPz4ceXOnVtr165VtmzZVKRIkTTHZc2aVQMHDlTt2rUlSXnz5lW9evXUp0+fDMcdN26cKlWqpDZt2kiS8ufPL6vVqnfeeUf79u1TUFCQJKlWrVoKCQnJcAyr1aoZM2aoSZMmql69uqQbDXmps17eSsGCBfXuu+9KkqKjozV69GhVrVpVFStWlCTVrVtXgwYNknRj6fUtW7Zo3bp1tlkTO3bsqM2bN2v69OkaMmSIpBtNfMOGDVPWrFkl3ZhxMyYmRpJ08uRJJSYmKk+ePMqbN6/y5s2rsWPHKiUlJV1t+/bt06pVqzR27Fhbk2Dbtm21e/dujR071lZjUlKS+vbtq8KFC0uS3n77bbVp00anT59Wjhw50j1OEyZM0JtvvqlGjRpJkgIDA3XhwgUNHTpUbdq0sS2H7uHhIT8/v1s+dre7zjVr1mjHjh1aunSpChYsKEnq3bu3tm3bpkmTJmnkyJGaPn26qlataqujVatW2rp1q3bt2nXb79mtHDp0SMuWLdOCBQtsPyfNmjXTrl27NGnSJL300kvpzjl+/LhOnjxpq1G68X3euXOnvvrqK1uz74ABAzRp0iRbd7XFYtHAgQOVJUsWBQUFqXDhwnJxcVGzZs0kSU2bNtW8efN06NChNMu5FyxYUNu2bVODBg3sukYAAAAAAAAAAAAAAAAA+Lc6efKkFi9erHHjxqlkyZKSpE8++USvvvqqtm7dqrCwsHTnLF68WDly5FD37t3l4OCg/Pnzq0+fPmrUqJEOHz4sf39/7dmzR15eXipUqJDdtf0rmjCLFi0qf39/ff3112rWrJlWrFhha3i82XPPPScfHx99/vnnOnTokA4cOKCdO3falrv+pz179qSbTfO5556TJO3evdvWhBkQEHDL2s6fP6/Tp0+na9IMCwvTvn37bnlevnz5bF9nypRJkuTv72/b5ubmpsTEREmyLaee2vyYKjExMc2y59mzZ7c1JkqSl5eXkpKSJEmFCxdW9erV1bp1a+XOnVsvvPCCXnrpJUVGRqarbffu3ZKkEiVKpNlesmRJDR8+PM221McoNU+SLfNm586d05kzZ9KN+dxzzykpKUn79+9XsWLF0p2XkdtdZ+oP/c3NjQ4ODipZsqR+/vln2zH//L6Hh4fb3YSZOhtpkyZN0mxPSkpSlixZMjzn9OnTkpRmKfLdu3crS5YsaWZb9fPzU9euXW33fX1904yZKVOmNDOGurm5SVKan4vUnDNnztzTdQEAAAAAAAAAAAAAAADAg/TPHrh/unml5nuxadMmSVKpUqVs2/Lly6ecOXPqt99+y7AJs2bNmqpQoYIcHBzS7btw4YL8/f21e/duPfPMM3bVlOpf0YQp/W9J8jfeeEOrVq3S/Pnz0x2zfPlyde7cWdWrV1doaKiioqK0Z88e9e/fP8MxrVZrugcwdWZIZ+f/Xbq7u/sd6/vnEtw3n58RFxeXdNscHTNe/d1iscjT01NxcXHp9rm6umb4dUaGDx+uNm3a6KefftIvv/yijh07qnjx4po+ffptz7u5jn9eV0aZGS1HfqslyjN6vO/kdteZ0fdUSl/7P+vJ6Pvxz2Myai69+bgvvvhCmTNnTrPvVt/T1BpvznB2ds6w9jvVeauMm6WkpNzVcQAAAAAAAAAAAAAAAMB/kiX9isH47zh58qSyZctmm8QuVY4cOXT8+PEMz7l5AsJUEyZMkJ+fn23myz179ig5OVnNmzfXzp07lStXLr311luqVavWXdf2r2rCHD9+vBYsWCB/f/8MH4CxY8cqKipK/fr1s21L7YzNqDmvYMGC2rRpk9566y3bto0bN0rK+AHOiI+Pj3Lnzq1Nmzbp5Zdftm3/448/MmyYs0fBggUVHx+vxMREFShQwLa9Z8+eKlSokN588807jrF161atWLFC3bt3V/78+dW0aVMtWbJEH374oc6ePZsuT7rRHZy6HLl047Gxt6vX19dXvr6+6R6njRs3ysXFRU8//bRd4/5TcHCwLl26pD179qSZDXPTpk222gsXLpzu+/7777+nGcfFxUWXL1+23Y+Pj9e5c+cyzEz9npw6dSrN0uMjRoyQg4OD2rdvn+6cnDlzSroxQ2jqz9ozzzyjixcv6tChQ7bZV8+dO6fKlStr7Nixd/sQZOj8+fNpZl8FAAAAAAAAAAAAAAAAgEfN3pkujxw5cttZNN9///0MJ/dzc3NLt6rwrQwZMkSrV6/W6NGjbb1/f/31l5ydnfXee+/Jz89PP/74o7p166akpCRFRUXd1bj/mibMwoULKyAgQJ988onefvvtDI/JnTu3Nm/erB07dsjLy0vff/+9Zs6cKenG0t3/7HJt3ry5OnTooM8++0xVq1bVwYMHNWDAAFWoUOGumzAlqWXLlho6dKjy58+vkiVL6ssvv9T27dvTLb1tr7Jly6pw4cJq3769evbsqTx58mjOnDlauHChJk+efFdjeHp6atasWXJxcVH9+vV1/fp1LV++XIGBgcqWLVuaY5955hmVL1/e1swaGBio5cuXa9WqVRo5cqRd1+Dg4KDo6GiNGjVKTz31lF588UVt375dn376qRo0aGBbyvx+lSlTRsHBwerUqZN69uyp7Nmza+bMmdqzZ4/69OkjSWrVqpXeeecdTZw4US+//LJ+/vlnrVy5Ujly5LCNEx4errlz5+q5556Ti4uLRo4cecvZOgsUKKAKFSqoT58+6t27twoWLKhvvvlG48aN00cffZThOTly5FCePHm0Y8cOPffcc5KkiIgIFS1aVJ07d1b37t3l4eGhjz/+WL6+vgoJCdEvv/xi12NisVi0a9cu1a5d267zAQAAAAAAAAAAAAAAAMCknDlzasWKFbfcv3r1aiUmJqbbnpCQoEyZMt127KSkJPXu3VuLFi1Snz599Morr9j2ff3117JYLLYxChcurOPHj2vSpEmPXxOmdGM2zDFjxqhq1aoZ7u/Vq5d69+6tN998U66uripUqJCGDRumDh06aNu2bXr++efTjZeSkqJx48ZpzJgx8vHxUfXq1fXee+/dU12NGjWSxWLRmDFjdObMGZUtW1ZRUVE6cOCA3dd6MycnJ02ePFkxMTHq0KGDrl27pqCgIMXGxioiIuKuxnjmmWcUGxurTz/9VLNmzZKjo6NKly6tCRMmZLhM9YgRI/TJJ5+oZ8+eunTpkgoUKKDY2FhVqlTJ7uto0aKFXF1dNW3aNA0ePFi5cuVSy5Yt1bx5c7vH/CdnZ2dNmTJFQ4cOVbt27ZSYmKhnn31WU6dOVVhYmCTppZde0vDhwxUbG6tRo0YpLCxM0dHRWrZsmW2cvn37ql+/fmrYsKF8fHzUrFkzXb169Za5I0aM0IgRI9SnTx9dvHhR/v7+GjBggF577bVbnlOxYkWtX79eTZs2lXRjWfHPP/9cQ4YMsT0mpUqV0qRJk+641Pzt7NixQ1euXEkzqykAAAAAAAAAAAAAAAAAPC5cXFxuO7Hi7t27deHCBSUmJqbptTp16pRy5cp1y/Pi4+PVtm1bbdy4UcOHD1e1atXS7P/nxI/SjdWaly5dete1O1itVutdH/0YKFeunN544w21bt3adCl4wh04cEA1a9bU999/Lz8/v4eW07dvX129elXDhg2ze4z1hzJeiv1he87xqJFcSdrtEmAsu0iuLEZyk07sM5IrSVa3zGZyt9k3xfWDcLBIDSO5uTK7GMmVJCcHM7nOspgJluR4/aKx7KOWBzPL9L1ycTT0jZbk7e5kJPfM1WQjuZKU+9eZRnKd/PIayZUka3KSkdxzRV41kitJK/46ayy74bM57nzQQ+B2cpeRXEm6liPYSO7ZaylGciUpt/N1I7mOl08ayb0Rbub/nP6pW/+R52Er7GLmfYnj2UNGciXpgG+Ysey/L5p5XhXx8zCSK0nZLx80kmvxyHbng/5jfr9i7vt8McHMe7Eyud2N5EqS1dBrhiQdv2Lms0a+7GY+TwIAAAAA8LAlb1puugRIci5R7c4H2eHkyZMqX768pkyZYpvYcP/+/apSpYrmzp1rm8DvZomJiWrWrJl27dqlzz77TKVLl06z/8KFC3r55ZfVq1cv1apVy7a9a9eu2r9/v+bNm3dXtaWfIvExde7cOf366686e/bsbTtbgUclX758qlmzpmbOfHjNE+fOndPKlSv17rvvPrQMAAAAAAAAAAAAAAAAADApZ86cqlatmnr27KkNGzZo+/bt6tSpk55//nlbA2ZiYqJOnz5tW7Z83Lhx2rRpk/r376+goCCdPn3adktMTFTWrFn1wgsv6JNPPtHPP/+sgwcPavz48VqyZInatWt317X9Z5owlyxZolatWikiIkIvv/yy6XIASTe6oleuXKnjx48/lPFjY2PVokULBQYGPpTxAQAAAAAAAAAAAAAAAODfYMCAAYqIiFDbtm3VvHlz5c+fX6NHj7bt37Jli1588UVt2bJFkrRs2TJZrVZ17NhRL774Yppb6jFDhgxR1apV1atXL9WoUUMrVqzQ6NGjVbZs2buu6z+3HDmAe8dy5I8Wy5E/wlyWI3+kWI780WI58keH5cgfLZYjf7RYjvzRYTnyRx3OcuSPCsuRP1osR/5kYDnyR4vlyAEAAAAA+O9gOfJ/h4e1HPm/mbm/MAEAAAAAAAAAAAAAAAAA8ABYLeYmRMCT7T+zHDkAAAAAAAAAAAAAAAAAAMCjRBMmAAAAAAAAAAAAAAAAAACAHWjCBAAAAAAAAAAAAAAAAAAAsANNmAAAAAAAAAAAAAAAAAAAAHagCRMAAAAAAAAAAAAAAAAAAMAONGECAAAAAAAAAAAAAAAAAADYwdl0AQDMy+pu5leBxdHbSK4kOVmNRWvT4QtGcos5JhrJlaTvTnoayS0RXttIriTls14xkvv3VQcjuZIUmPC3kdyk7EFGciXJ6uJhLPupa2fNBFvMxEqSi0egkVy3pDNGciXp95DXjeRarOZeKLO4OxnJzeNi7v+nVXnG11i2ozXFSK7FI6uRXEk6d93MNf99McFIriRtvppkJNfLLYeRXEnKkdnVSG7BrAb/zBJv5kX6UPYwI7mS2f9Z7OFi5vUqx8mtRnIlyaPRDCO5a+OGGMmVpL8vXjOSWz7AzO8wSdp11szrpEOimc/QkrTsiLkPOYWym/l7SeJFc59xXL2zG8sGAAAAAAB4WGjCBAAAAAAAAAAAAAAAAAA83iwGZ5TBE43lyAEAAAAAAAAAAAAAAAAAAOxAEyYAAAAAAAAAAAAAAAAAAIAdaMIEAAAAAAAAAAAAAAAAAACwA02YAAAAAAAAAAAAAAAAAAAAdqAJEwAAAAAAAAAAAAAAAAAAwA40YQIAAAAAAAAAAAAAAAAAANiBJkwAAAAAAAAAAAAAAAAAAAA70IT5CEVGRio4ONh2K1q0qF566SX1799f58+fT3NscHCw4uLiHmo9P/zwg/bu3XtP9VauXFkTJ05Mc1zjxo3VtWtXSVJcXJyCg4PTjBEbG3tfdd48fkY2bNig4OBgHTly5L5y4uPjVbVqVZ04ceK+xrkblStX1ubNmzPc17VrVzVu3Nh2/04/CwMHDtTUqVMfdIkAAAAAAAAAAAAAAADAY8NqSeH2L7g9iZxNF/CkiY6OVnR0tCTp+vXr2rNnj2JiYvTbb79p9uzZ8vT0lCStWbNGXl5eD62Oo0ePqnXr1po+fbqeeeaZu65327Zt6tmzpzJlyqRGjRpJkmJjY+Xk5JTh+QsWLJCbm9uDv4CbhIeHa82aNfLx8bmvcWJiYvTKK68oV65cD6iyjB0+fFgXLlxQsWLFHsh47dq1U7Vq1VShQgUFBAQ8kDEBAAAAAAAAAAAAAAAAAHfGTJiPmIeHh/z8/OTn5yd/f39VrFhRkydP1pEjRzRp0iTbcX5+fnJ3d39odVit1rs67p/1Vq9eXTVq1NDChQttx2TNmvWWDaM+Pj7KnDnzA6n5VlxdXeXn53fLRtC78ffff2vRokVq0qTJA6wsYz/++KPKlClzX/XezNvbW9WqVbvvGUcBAAAAAAAAAAAAAAAAAPeGJsx/gTx58qhSpUpatmyZbdvNS1B37dpVbdu2VXR0tIoXL65x48ZJurGceN26dRUaGqpKlSpp5MiRSkxMtI1x9epVDRw4UC+++KLCw8PVqFEjbd++XUeOHFHFihUlSU2aNLnn5r1MmTKluX+75cJvXo48NjZWDRs2VMeOHVW8eHH169cv3fLlUsbLi1+9elWdOnVSWFiYypYtq6lTp9oaSf95fGRkpMaPH6927dopPDxcpUqV0qBBg5ScnHzLa5oyZYpKlSplm03zyJEjCg4O1urVq1W3bl2FhISoRo0a2rp1q+bPn68KFSqoePHi6tSpkxISEmzjrFmzxvY9qVatmhYsWJDuWlavXq1y5cpJutEM+/nnn6tcuXIKCwtTjx490ox3t6pUqaKvvvrqkSylDgAAAAAAAAAAAAAAAAC4gSbMf4mCBQvq77//1pUrVzLc/+233+qFF17QwoULVbNmTf300096//33Va9ePS1btkx9+vTRV199pQ8//NB2TocOHfTDDz9o0KBBWrx4sfLly6fmzZvL3d1d8+fPl3SjMTJ1ufG7sX37di1dulQNGjSw6zq3bNkiX19fffnll3rrrbfu+ryVK1cqW7ZsWrhwoT788EONGjVK06ZNu+XxsbGxeu6557Ro0SK1a9dO06dPT9Pk+k+rVq1ShQoV0m3v37+/PvjgAy1evFju7u5q1aqVvvrqK40dO1ZDhgzRypUrbY/lzp079fbbb6t06dJavHix2rRpo2HDhqUZ7/r169q0aZOtCXP8+PGaOHGiOnfurLi4OHl6emrFihV3/bikCgsLU5YsWbR69ep7PhcAAAAAAAAAAAAAAAAAYB9n0wXghixZskiS4uPjM1y+29vbWy1atLDd79Spk6KiovT6669Lkp5++mn169dPb731lo4cOaKkpCT9+OOPmjhxosqWLStJ6t27tzJnzqxLly7ZZnz09va+7XLh48aN0+TJkyVJSUlJSkpKUrFixVS1alW7r/W9996zLV++efPmuzqnSJEi6tmzpyQpKChI+/bt0+TJk9W0adMMjy9btqxtafHAwEAtWLBAmzdvVu3atdMde/z4cZ08eVIFCxZMt69Zs2Z64YUXJEm1a9dW//791adPHwUEBCg4OFhFihTRnj17JElTp05V0aJF1blzZ0lS/vz5dfbsWQ0cONA23oYNG/TMM8/Ix8dHVqtVM2bMUJMmTVS9enVJUrdu3bRhw4a7ekz+qWDBgtq2bZvdDbIAAAAAAAAAAAAAAAAAgHtDE+a/xOXLlyVJnp6eGe4PCAhIc//PP//U9u3btWjRItu21OW59+3bp2vXrkm6MUNiKldXV3Xr1k2S0iyPfTsNGzZU48aNJUnJyck6ePCgRowYoTfeeEMLFy6Uq6vrXY2TytfX19aAeS9KlCiR5n5oaKjGjh2rS5cuZXh8UFBQmvteXl5KSkrK8NjTp09Lkq0x9Wb58uWzfZ26DLu/v79tm5ubm20J+D///NPWsJmqZMmSae7fvBT5+fPndfr0aYWEhKQ5JiwsTPv27cuw1tvx8fHRmTNn7vk8AAAAAAAAAAAAAAAAAIB9aML8l9ixY4cCAwNvOSulu7t7mvsWi0UtWrRQnTp10h3r5+enX375RZLk4OBwX3V5e3unaQANCgqSt7e3GjVqpF9++UUvvfTSPY33z+tIZbVabbUmJyen2+/o6JjmvsVikYODg1xcXDIcL6Pm0NQm1X9Kzc1ov7Nz+qfIP2tJ5eTkJIvFkuG+VD/99JM++eST29aVUebdSElJuWVtAAAAAAAAAAAAAAAAwH+aJcV0BXhC0bH1L3DixAmtWrVKNWrUuOtzChQooP379ysgIMB2O3nypIYNG6YrV67YZoL8/fffbeckJyfrpZde0vLly++7OVPSHRsO70ZqE2XqTKCSdOjQoXTH7dixI839TZs26amnnrLNTnk/cubMKUk6d+7cfY1TqFAhbdu2Lc22m+/v27dPV65cUdGiRSXdmLkyd+7c2rRpU5pz/vjjD7vyz58/rxw5cth1LgAAAAAAAAAAAAAAAADg3tGE+YhdvXpVp0+f1unTp3X48GF99913atGihZ566ik1a9bsrsdp2bKlvvnmG8XGxurAgQNat26dunXrpkuXLsnPz0/58uXTK6+8on79+mndunU6cOCAevfurcTEREVERMjDw0OStGfPnjQNkLer99SpU9q4caMGDRqkHDlyKCIi4r4fj7CwMDk6OmrkyJE6fPiwfvzxR02ePDndcZs3b1ZMTIz27dun+fPna9asWXr33XfvO1+ScuTIoTx58qRr9LxX0dHR+uOPP/Txxx/rwIED+u677zRq1ChJN2bb/Omnn1S2bNk0s1W2bNlSX3zxhebPn68DBw5o5MiR2r59e7qx9+zZo59++inN7eYGT4vFol27dqlYsWL3dQ0AAAAAAAAAAAAAAAAAgLvHcuSP2OTJk21Nhh4eHsqVK5deeeUVRUdH33Ip8oy8+uqrGjFihMaNG6dx48bJ29tbFSpU0Icffmg7ZvDgwRo2bJg6dOighIQEFStWTJMnT5aPj48k6bXXXtOwYcN06NAh9ezZ8471Ojo6Klu2bCpRooQ+/vjjBzILpb+/v/r376+xY8dq3rx5evbZZ9W9e3e98847aY6rV6+eDh48qDp16sjHx0edOnVS3bp17zs/VcWKFbV+/Xo1bdrU7jEKFiyoTz/9VJ988ommTp2qfPnyqVGjRoqNjZWLi4t++uknRUVFpTmnUaNGslgsGjNmjM6cOaOyZcsqKipKBw4cSHPclClTNGXKlDTbihcvrtmzZ0u6MVPolStXVKFCBbvrBwAAAAAAAAAAAAAAAADcGwer1Wo1XQRg2oEDB1SzZk19//338vPzs2uM7du3y9nZWUWKFLFtW7p0qbp3764tW7bI2fnh9Tz37dtXV69e1bBhw+w6f9fJSw+4orsT5HjBSK4k7bdmNZYdn2AxklvM8biRXEn69rKPkdwSuT2N5EpSVusVI7l/J91/g7y9AhP+NpKblD3ISK4kOSZdN5d97YKxbFNccgQayU28eMZIriT9fsnM/5myGPyIkMXdyUhuHk8XI7mSFJ9o5r2BJGVzNZPrFH/aTLCk487ZjeQeupBgJFeSzlxNNJLr5Wbu/33myGzmh7tgVnPXbOp5ddjR10iuaaeuJBnJfT5hp5FcSfJoNMNI7tq4IUZyJenvi9eM5JYP8DaSK0m7zpq55pLeZp5TkrT0iLn3YoWym/m7RQEPM+8NJMnV28x7MQAAAADAkyFx7TzTJUCSa5n6pkt45FiOHJCUL18+1axZUzNnzrR7jF27dqlJkyZatWqVjh07pnXr1ik2NlbVqlV7qA2Y586d08qVKx/Y8uwAAAAAAAAAAAAAAAAAgLvDcuTA/+vatavq1aunhg0bKnfu3Pd8fr169XTq1CkNGjRIJ0+elK+vr6pVq6b33nvvIVT7P7GxsWrRooUCAwMfag4AAAAAAAAAAAAAAAAAIC2aMIH/5+Xlpa+//tru8x0cHNS2bVu1bdv2AVZ1Z3369HmkeQAAAAAAAAAAAAAAAACAG2jCBAAAAAAAAAAAAAAAAAA83iwW0xXgCeVougAAAAAAAAAAAAAAAAAAAIDHEU2YAAAAAAAAAAAAAAAAAAAAdqAJEwAAAAAAAAAAAAAAAAAAwA40YQIAAAAAAAAAAAAAAAAAANiBJkwAAAAAAAAAAAAAAAAAAAA7OJsuAIB5BRIPGck9njmfkVxJCsjkZCz7aiarkdy1p/yM5EqSh4uZ3BNXks0ES3LN4mkk19PBzM+XJKW45TaSezXJYiRXkg5eMBatZ33NPKcdt31tJFeSTrvnMJLrnZJoJFeS3J1djeSevJJgJFeScmQ286LhmmLwmi8fNpZ9wD3QSK6jo6+RXEl6yum6kdy8V7cZyZWk/TmeN5Kb/+o+I7mSlJS1gJFcl7P7jeRK0ke7zLxmSMcM5UrdirkZyw5MOGok90j2YkZyJWlt3LNGcv0ym/vzZRY3Q5/rLFeN5EpSKafjRnIvOgcZyZWkykEOxrLdL/xtJNfhgpn3Q5L0V4KZ390FcngZyQUAAAAAAE8GZsIEAAAAAAAAAAAAAAAAAACwAzNhAgAAAAAAAAAAAAAAAAAea9aUFNMl4AnFTJgAAAAAAAAAAAAAAAAAAAB2oAkTAAAAAAAAAAAAAAAAAADADjRhAgAAAAAAAAAAAAAAAAAA2IEmTAAAAAAAAAAAAAAAAAAAADvQhAkAAAAAAAAAAAAAAAAAAGAHmjABAAAAAAAAAAAAAAAAAADs4Gy6AAAAAAAAAAAAAAAAAAAA7oslxXQFeEIxEybwCHXt2lWNGzc2XQYAAAAAAAAAAAAAAAAA4AGgCRMAAAAAAAAAAAAAAAAAAMAONGECAAAAAAAAAAAAAAAAAADYgSZMwJDIyEgNGjRIVatWValSpbR+/XqlpKRo6tSpqly5skJCQlS5cmXNmzfPds6GDRsUHBys1atXq3r16ipatKiqVaumH374weCVAAAAAAAAAAAAAAAAAMCTydl0AcCTbPbs2Ro3bpy8vLwUHBysIUOG6Msvv1SvXr0UEhKitWvXqn///kpISFDjxo1t58XExKhHjx7y9fXVJ598og8++EA//fSTMmfObPBqAAAAAAAAAAAAAAAAAODJQhMmYFD58uX1wgsvSJLi4+M1e/Zsde3aVTVq1JAkBQYG6vDhwxo7dqzefPNN23nt27dXRESE7etatWppz549Cg8Pf/QXAQAAAAAAAAAAAAAAAABPKJYjBwwKCAiwfb1//34lJSWpRIkSaY4pWbKkzpw5o7Nnz9q25c+f3/a1p6enJCkpKekhVwsAAAAAAAAAAAAAAAAAuBkzYQIGubu72762Wq2SJAcHhzTHWCwWSZKz8/+erq6urunGSj0fAAAAAAAAAAAAAAAAeOJYUkxXgCcUM2EC/xL58+eXs7OzNm7cmGb7xo0b5efnJ29vb0OVAQAAAAAAAAAAAAAAAAAywkyYwL+El5eX6tevr9GjR8vb21uhoaFas2aNZs2apY4dO6abIRMAAAAAAAAAAAAAAAAAYBZNmMC/SI8ePZQtWzYNHz5cZ86cUUBAgHr37q369eubLg0AAAAAAAAAAAAAAAAA8A80YQKP0JAhQ2xff//99+n2Ozs767333tN7772X4fmlSpXS7t2702x76qmn0m0DAAAAAAAAAAAAAAAAADx8jqYLAAAAAAAAAAAAAAAAAAAAeBzRhAkAAAAAAAAAAAAAAAAAAGAHmjABAAAAAAAAAAAAAAAAAADs4Gy6AAAAAAAAAAAAAAAAAAAA7ofVYjFdAp5QzIQJAAAAAAAAAAAAAAAAAABgB5owAQAAAAAAAAAAAAAAAAAA7EATJgAAAAAAAAAAAAAAAAAAgB1owgQAAAAAAAAAAAAAAAAAALADTZgAAAAAAAAAAAAAAAAAAAB2cDZdAADzErIXMJJ7PT7JSK4kWeRgLPtCQrKR3OvJFiO5kpTT09VIblKK1UiuJGWyXDeSe11uRnIl6bzVTHaiwZ9tV2dzv0uMsaQYi/ZyNvOcvmD1NpIrSb4eZnL3nDXzWiVJiYZ+d59LcTGSK0l+juY+lp26kmgk19fD3OPtkBBvJPda/heM5ErSoaNmrtk/r5nPGZJ05IqZ9wf5jKTeUCEou5HcMWv2G8mVJIXlNJftbOa9b95Le43kStKepLxGci1Wc5/rXJwMvd93NfcZJyWzr5FcY4+1JJfka8ayr2d92kiu+8UjRnJNeubdOGPZez+vaywbAAAAAAA8GjRhAgAAAAAAAAAAAAAAAAAebwYnlMGTjeXIAQAAAAAAAAAAAAAAAAAA7EATJgAAAAAAAAAAAAAAAAAAgB1owgQAAAAAAAAAAAAAAAAAALADTZgAAAAAAAAAAAAAAAAAAAB2oAkTAAAAAAAAAAAAAAAAAADADjRhAgAAAAAAAAAAAAAAAAAA2IEmTAAAAAAAAAAAAAAAAAAAADvQhPmIpaSkaNasWYqKilJ4eLhKliyphg0batGiRbJarabLu29Wq1UzZsxQrVq1FBoaqhIlSqhRo0b6+uuv73mcRYsW6ezZsw+p0v/566+/9OOPP9ruBwcHKy4u7qHn7tixQ1FRUbJYLLJarRo4cKBKliypypUra926dWmOnTx5stq3b59ujIEDB2rq1KkPvVYAAAAAAAAAAAAAAADgX82Swu3fcHsC0YT5CCUnJ+udd95RbGys6tSpo0WLFmnu3LmqWrWqBg0apHbt2ikl5fH+QRw9erTGjh2rVq1aadmyZZozZ44iIiLUvn17LVq06K7H+e2339S1a1ddu3btIVZ7w9tvv63ff//ddn/NmjWqWrXqQ81MSkpS165d1alTJzk6Omr16tX67rvvNHPmTDVr1kwffPCBrSn30qVLmjRpkjp06JBunHbt2mnixIk6dOjQQ60XAAAAAAAAAAAAAAAAAJCes+kCniRjx47Vpk2bFBcXp4CAANv2oKAgPf/884qKitKkSZPUqlUrg1Xen1mzZql169aqVq2abVuBAgW0f/9+TZ8+XXXq1LmrcUzOCurn5/fQM5YsWSInJydFRERIujEbZ/HixVWoUCHly5dPffr00fnz5+Xj46MxY8bo1VdfTfMzk8rb21vVqlVTbGysPv7444deNwAAAAAAAAAAAAAAAADgf5gJ8xGxWq2aOXOm6tSpk2EzXaFChVSrVi3NmDFDFotFkyZNUpEiRbR9+3ZJksViUePGjVW3bl2dOXNGRYsW1eLFi9OM8fHHH9uaHK9du6Y+ffqoVKlSKl68uHr06KFOnTqpa9eutuM3b96sRo0aKTQ0VC+99JL69eun+Ph42/7IyEiNHz9e7dq1U3h4uEqVKqVBgwYpOTn5ltfp6Oio9evXp5vBskePHoqNjbXd/+uvv/Tuu++qVKlSKlq0qCpVqqRp06ZJkjZs2KAmTZpIkipWrKi4uDjFxcUpODg4zZgbNmxQcHCwjhw5Iklq3Lixunfvrnr16qlkyZJavHixEhMTNXz4cL388ssqWrSoSpUqpY4dO+r8+fO2azx69Kg+/fRTNW7cWFL65cgXL16smjVrKjQ0VJGRkRo7dqwsFosk6ciRIwoODtZXX32levXqKSQkRBUrVtSCBQtu+RhJN5YXv7lR1d/fX7t27VJ8fLw2bdokT09PZc2aVceOHdPixYvVpk2bW45VpUoVffXVVzpx4sRtMwEAAAAAAAAAAAAAAAAADxZNmI/IgQMHdP78eRUvXvyWx0REROjUqVM6cuSImjVrphIlSqhHjx5KSkrSxIkT9ccff+iTTz5R9uzZ9dJLL6VpwrRYLFq6dKnq1q0rSerSpYvWrl2rESNGaM6cOYqPj9fy5cttx+/atUtNmzZVmTJltGTJEn388cfasWOHoqOj08xCGRsbq+eee06LFi1Su3btNH36dC1btuyW1/D222/rxx9/1Isvvqh27dpp6tSp2r17t3x9ffXUU09JutEg2qxZM3l4eGjWrFlavny5qlSpokGDBmnnzp0KDw+3NWzOnz//npYGj4uLU5MmTTR79myVL19ew4YN07Jly/TRRx9p5cqVGjp0qNauXasxY8ZIkhYsWKBcuXIpOjo6TZNoqqlTp6pXr15q0KCBlixZog4dOmjSpEkaNmxYmuOGDBmi1q1ba/HixYqIiFCvXr10+PDhDGs8ePCg9u7dq8jISNu2SpUq6emnn9bzzz+vd999V/369ZOjo6NGjBihxo0by8fH55bXHBYWpixZsmj16tV3/TgBAAAAAAAAAAAAAAAAAO4fTZiPyIULFyRJ2bJlu+UxqfvOnTsnR0dHDR06VMePH1f37t01evRo9e7dW4GBgZKk1157TRs2bNDJkyclSevWrdPZs2dVvXp1HT58WCtXrlSfPn30wgsvqGDBgho2bFiaZbYnTZqkiIgIvfvuuwoMDFTJkiU1fPhwbdu2Tb/++qvtuLJly6pJkyYKDAzUm2++qUKFCmnz5s23vIamTZtq8uTJeuGFF/TLL79o8ODBqlmzpqKiorR3715JN5owmzRpor59+yooKEgBAQFq27atJGn37t1ydXWVt7e3JMnHx0fu7u53/TgXLlxYNWrUUIECBZQtWzaFhIRo6NChKlWqlPLmzauXXnpJL774onbv3m0b38nJSR4eHsqaNWuasaxWqyZMmKA333xTjRo1UmBgoGrUqKH33ntPM2fO1OXLl23HNmvWTBUrVlRQUJC6dOkii8Wibdu2ZVjj1q1b5eLiYvteSpKTk5PGjh2rNWvW6Ndff1X16tW1c+dObdiwQU2bNtWSJUtUuXJl1axZU7/99lu6MQsWLHjLPAAAAAAAAAAAAAAAAADAw+FsuoAnRWqD382Ne/908eJFSf9rxsyTJ4+6deum7t276+WXX7YtNS5J5cqVk6+vr7788ku1atVKixYtUmRkpLJly2ZrogwPD7cd7+bmppCQENv9P//8U4cOHUpzTKp9+/apVKlSkqSgoKA0+7y8vJSUlHTbay1TpozKlCmjlJQU7dixQ99//71mzpypFi1a6JtvvpGPj4/eeOMNrVixQrt27dKhQ4e0c+dOSbIt822vfy71XqtWLa1bt06ffPKJDh48qH379mn//v0qWbLkHcc6d+6czpw5oxIlSqTZ/txzzykpKUn79++Xr6+vpLSPk5eXlyTd8nE6c+aMsmbNKicnp3T7bp7xMiYmRm3atNGVK1fUv39/LVq0SCdPnlT79u21atUqubm5pTnvzJkzd7wmAAAAAAAAAAAAAAAAAMCDQxPmIxIQECA/Pz/9+uuveuWVVzI8ZsOGDfLz87Mt2y1Jf/zxh5ydnfX777/r4sWLthkinZycVLt2bS1dulRvvvmmvvvuO40aNcq2T7p9Q6PFYlGNGjXUunXrdPtubgR0dXVNt//m5cpvtmvXLs2dO1fdunWTq6urnJycFBoaqtDQUIWHh6tVq1bavXu3cufOrfr16ytbtmyqWLGiIiIiFBISovLly9+y3puzHRwcJEnJycnp9v9z1sy+fftqxYoVql27tl566SW98847mjRpkm0G0TtlZSQlJUWS5Oz8v6fPvTxODg4Od2w2XbNmjY4fP66oqCh9//33ypcvn/z9/eXv7y+LxaKDBw8qODg4TU2OjkxsCwAAAAAAAAAAAAAAAACPEl1bj4iTk5OaNGmiBQsW6K+//kq3f9euXVq8eLHeeOMNWxPlzz//rNmzZys2NlaZMmVSnz590pzz2muvac+ePZo5c6Y8PT314osvSpKCg4Pl4OCgrVu32o5NSkrSn3/+abtfoEAB/fXXXwoICLDdUlJSNHjwYB0/ftzu65w1a5a+++67dNs9PT3l4OAgX19fLV26VBcuXNCcOXP07rvvqlKlSrZZQFMbF1MbLVO5uLhISjuT6KFDh25by/nz5zV79mz17dtX3bt3V926dVW4cGHt37//lg2SN/P19ZWvr682bdqUZvvGjRvl4uKip59++o5jZCRnzpy6cOHCLRsxLRaLYmJi1KlTJzk5OcnBwcHW+CndaD79Z/3nz59Xjhw57KoHAAAAAAAAAAAAAAAAeNxZLRZu/4Lbk4gmzEeoefPmKlu2rN5880198cUXOnTokA4dOqQvvvhCb731lkqVKqVWrVpJki5cuKDu3burXr16ioyM1EcffaSvv/5aS5YssY2XL18+FS9eXJ999plq165ta9709/dXlSpVNGDAAK1bt0779u1Tr169dPz4cVtzY3R0tHbu3KnevXtr79692rZtmz744AMdOHBAgYGBdl1foUKFVLNmTfXo0UMTJkzQ3r17dfDgQX399dfq3r276tSpozx58ihXrly6du2avvrqKx07dkxr1qxRx44dJUmJiYmSJA8PD0k3mlOvXLmisLAwOTo6auTIkTp8+LB+/PFHTZ48+bb1eHl5ycvLS6tWrdKhQ4e0e/du9erVSzt27LDlSFLmzJl18ODBdMt5Ozg4KDo6WjNnzrR9v5YuXapPP/1UDRo0sC07fq+KFSumlJQU7dq1K8P9X375pTw8PPTyyy9Lkp599lnt3btXa9as0aJFi+To6Jjme2SxWLRr1y4VK1bMrnoAAAAAAAAAAAAAAAAAAPZhOfJHyMnJSaNHj1ZcXJzmz5+vESNGyGq1qkCBAvrggw8UFRVla5Ls06ePnJyc1KVLF0lSyZIl9cYbb6h///4qWbKk8uTJI0mqW7euNm/erDp16qTJGjBggAYOHKh27drJarWqevXqCgsLs80oGRYWpokTJ2rUqFGqW7euMmXKpNKlS6tLly4ZLq19twYPHqyiRYvqyy+/1JgxY5SUlKSnn35a9erV01tvvSVJevXVV7Vjxw4NHTpU8fHxyps3r+rVq6dVq1Zp+/btev3111WwYEGVL19e7du3V8eOHRUdHa3+/ftr7Nixmjdvnp599ll1795d77zzzi1rcXZ21qhRozRkyBDVqFFD3t7eKlWqlDp27KixY8fq6tWr8vDwUOPGjTV06FD99ddfaZpcJalFixZydXXVtGnTNHjwYOXKlUstW7ZU8+bN7X6M/P39VbBgQa1fv15FihRJsy8hIUGjR4/W8OHDbdty586tbt26qXPnzsqUKZNiYmLSLLu+Y8cOXblyRRUqVLC7JgAAAAAAAAAAAAAAAADAvXOw3s26zPjX+vTTT7V27VrNnj3bti0hIUE///yzSpcuLU9PT9v2ypUrq2bNmmrTpo2JUnGT+fPna9q0aVq2bNl9j9W3b19dvXpVw4YNs3uMq9eu33cd9jgWn2QkV5LyeLoYyz5xxcx1/3X2mpFcScrpaX9z9/1IMTjLdVFvM+HnrW5Gck1KTDH3VuZiQoqx7ALeZv4vjeOW5UZyJckSXs1I7iVzL1cy9Wts3eFLhpKlojk873zQQ+Dpam6RAL8rfxvL/jUph5FcXw9z78Xy65yR3ATPnEZyJWn90XgjuS/m9TCSK0lHrpj5DZrv+kEjuZL0S1IeI7lj1uw3kitJ06qYe145XT5lJNfqaO7/U/+QlNdIrrebuWt2cXIwklskc+KdD3pYLMlGYhPcsxnJlSTXZHN/L0lyzmQk1/3iESO5knTAKZeR3Cp9vzWSK0l7P69rLBsAAAAAnjTXln1mugRIylT9yetNYznyx9TGjRu1YMECTZs2TU2aNEmzz9XVVf3791efPn20b98+HTx4UB9//LGOHTumV1991VDFuFmdOnWUnJystWvX3tc4586d08qVK/Xuu+8+oMoAAAAAAAAAAAAAAAAAAHeLJszH1A8//KCBAweqZs2aqlKlSpp9Dg4OGjdunM6fP68GDRqoTp062rJliyZPnqygoCBDFeNmzs7OGjZsmIYPHy6Lxf4ZWmJjY9WiRQsFBgY+uOIAAAAAAAAAAAAAAAAAAHfF3Ho+uC8ffvihPvzww1vuL1y4sCZPnvwIK8K9Cg0NVVxc3H2N0adPnwdUDQAAAAAAAAAAAAAAAADgXtGECQAAAAAAAAAAAAAAAAB4vFlSTFeAJxTLkQMAAAAAAAAAAAAAAAAAANiBJkwAAAAAAAAAAAAAAAAAAAA70IQJAAAAAAAAAAAAAAAAAABgB5owAQAAAAAAAAAAAAAAAAAA7EATJgAAAAAAAAAAAAAAAAAAgB2cTRcAwLwDFxKN5GZ1dzKSK0mJKRZj2TO3HDOS26BYbiO5khSfYObxzuXpYiRXkhyvnTKSm80zu5FcSUpyMPO2wtHVwUiuJF1LNve7xPn830ZyLUXKGcmVJKf400ZyVx4x95a5/qXVRnIjwmsbyZUkdyczz2l3R6uRXElKdgs0ll0y8YqR3BMp5v4/oFWuRnJPXEk2kitJAd7uRnKPXTX3OplsMfOcvpg1yEiuJIUb+v35cpGcRnIl6bBDNmPZnr6+RnKzXTfzOUOSjp9LMJL7494zRnIlqWieLEZyc3lmNZIrSVZDL9HZZO41w+qSyVh2YrKZ1yvHrP5GciXpu20njOQu6/OykVxJ6vjlH0ZyP6lV1EguAAAAAABPImbCBAAAAAAAAAAAAAAAAAAAsAMzYQIAAAAAAAAAAAAAAAAAHm+WFNMV4AnFTJgAAAAAAAAAAAAAAAAAAAB2oAkTAAAAAAAAAAAAAAAAAADADjRhAgAAAAAAAAAAAAAAAAAA2IEmTAAAAAAAAAAAAAAAAAAAADvQhAkAAAAAAAAAAAAAAAAAAGAHmjABAAAAAAAAAAAAAAAAAADsQBMmAAAAAAAAAAAAAAAAAACAHWjChF0aN26s4ODgDG8fffTRA88LDg5WXFycJCkpKUlTp0617YuNjVVkZOR9Z+zYsUNRUVGyWCz3PdbNli1bpujoaLvO3bBhg4KDg3XkyJEM91ssFr322mv6/fff76dEAAAAAAAAAAAAAAAA4LFmTUnh9i+4PYmcTReAx1eVKlXUo0ePdNszZcr0wLPWrFkjLy8vSTeaGgcPHqymTZtKkqKjo9WoUaP7Gj8pKUldu3ZV9+7d5ej4YHuTV69erXLlyj3QMVM5Ojrqgw8+ULdu3RQXFydXV9eHkgMAAAAAAAAAAAAAAAAASI+ZMGE3d3d3+fn5pbt5eno+8Cw/Pz+5u7tLkqxWa5p9mTNnlo+Pz32Nv2TJEjk5OSkiIuK+xvkni8WiNWvWPLQmTEmKiIiQi4uLvvzyy4eWAQAAAAAAAAAAAAAAAABIjyZMPDRWq1UTJkxQxYoVVaxYMdWqVUtLliyx7U9danvChAkqVaqU6tSpo7///lvBwcH6/PPPVaZMGUVGRurSpUu25cjj4uLUrVs3STeWKN+wYUOa5ciPHDmi4OBgffXVV6pXr55CQkJUsWJFLViw4La1Tp48WdWqVbPdj4uLU2RkpBYtWqRKlSqpaNGieu2117RlyxbbMdeuXVOfPn1UqlQpFS9eXD169FCnTp3UtWtX2zG///67MmfOrPz589tqW716terWrauQkBDVqFFDW7du1fz581WhQgUVL15cnTp1UkJCwj091lWqVNGkSZPu6RwAAAAAAAAAAAAAAAAAwP2hCRMPzYgRIzRr1iz17NlTS5cuVZMmTdS3b1998cUXaY778ccfNXfuXA0aNMi2FPiSJUs0bdo0jRo1SlmyZLEdW7VqVXXv3l3SjSXKw8PDM8weMmSIWrdurcWLFysiIkK9evXS4cOHMzz24MGD2rt3r62RM9WpU6c0Z84cxcTEaO7cuXJ0dFSXLl1sM3F26dJFa9eu1YgRIzRnzhzFx8dr+fLlacZYvXq1ypcvn2Zb//799cEHH2jx4sVyd3dXq1at9NVXX2ns2LEaMmSIVq5cqfnz59/p4U2jQoUKOnDggA4cOHBP5wEAAAAAAAAAAAAAAAAA7OdsugA8vpYuXaqVK1em2RYeHq7Jkyfr6tWrmjp1qoYNG6YKFSpIkp5++mkdPXpUkyZNUqNGjWznREdHKzAwUNKNmSwl6Y033tAzzzyTLtPd3V1eXl6SbixRfivNmjVTxYoVJd1olpw/f762bdsmf3//dMdu3bpVLi4uthpSJSUlqW/fvipcuLAk6e2331abNm10+vRpJSQkaOXKlZo4caJeeOEFSdKwYcO0efPmNGP89NNPateuXbraUs+pXbu2+vfvrz59+iggIEDBwcEqUqSI9uzZc8try0j+/Pnl4uKibdu2KV++fPd0LgAAAAAAAAAAAAAAAADAPjRhwm6RkZH64IMP0mxzd3eXJO3du1cJCQnq0qWLbflwSUpOTlZiYqKuX79u2/bP5kdJCggIuK/agoKCbF+nNm0mJSVleOyZM2eUNWtWOTk53fU4f/75pySlmYnTzc1NISEhtvvnzp3Tvn37VKpUqTRj3twkmSlTJklK0xzq5uamxMTEO1xhWk5OTvL29taZM2fu6TwAAAAAAAAAAAAAAAAAgP1owoTdMmfOfMtmydQlu0eOHKn8+fOn2+/q6mr72s3NLd3+1GZOe908/j9r+icHBwdZLJZ7Gie1YfNW50k3ZsEsWbJkumtxdk7/tEtdhv1+pKSkZNhICgAAAAAAAAAAAAAAAPzn3aaPB3iY7r/zC8hA/vz55ezsrGPHjikgIMB2W716tSZNmnRfTYcODg4PsFIpZ86cunDhwm0bKv8pODhYDg4O2rp1q23bzTNkStLq1atVvnz5B1nqLaWkpOjSpUu3XaIdAAAAAAAAAAAAAAAAAPBgMRMmHgovLy81bNhQI0eOVObMmVWiRAlt3LhRMTExatmy5X2N7eHhIUn6448/9Mwzz9x3rcWKFVNKSop27dqlIkWK3NU5/v7+qlKligYMGKD+/fsrR44cmjBhgo4fPy4HBwelpKRo7dq16tix433XJ0m//fab9u/fn2bb008/bVvKfdeuXUpJSVGxYsUeSB4AAAAAAAAAAAAAAAAA4M5owsRD061bN/n4+Gj06NE6deqUcuXKpbZt26pVq1b3NW7p0qVVrFgxNWzYUDExMfddp7+/vwoWLKj169ffdROmJA0YMEADBw5Uu3btZLVaVb16dYWFhcnFxUVbt26Vj4+P/P3977s+SeratWu6ba1bt1aHDh0kSevXr1fBggUfWB4AAAAAAAAAAAAAAAAA4M4crFar1XQRgGnz58/XtGnTtGzZsrs6PiEhQT///LNKly4tT09P2/bKlSurZs2aatOmzcMqNUPVqlVTs2bNFBUVZdf5O45fesAV3Z2s7k5GciUps8uDXdb+Xoxed9hIboNiuY3kSlJ8gsVIbi5PFyO5kpQj8ZSRXItndiO5kpTkYOb/djg6mHs+H76caCw7KOmokVyLRzYjuZLkkHTdSO6cI+b+31L9S6uN5J4Pr20kV5Lcncw8p90dDX4scnA0Fu2YeMVI7okUdyO5kpRLZt77/p3iZSRXkkx96ncy96OtxBQzF53Dw9xrhquh35/z/jxtJFeSXgo0977E08XMD3i262Y+Z0jSnKNmPl/tPnnZSK4kFc2TxUjuS4FZjeRK5l4zsrmayZVk9L3Y1WQzD7i7s7lrnrbthJHcCvl8jORK0vj1fxvJ/aRWUSO5AAAAAGDS1fnDTJcASR71Opsu4ZEz+E8iwL9HnTp1lJycrLVr197V8a6ururfv7/69Omjffv26eDBg/r444917Ngxvfrqqw+52rR+/vlnpaSkqHbt2o80FwAAAAAAAAAAAAAAAACedDRhApKcnZ01bNgwDR8+XBbLnWfsc3Bw0Lhx43T+/Hk1aNBAderU0ZYtWzR58mQFBQU9gopvsFgs+uSTTzR06FA5O5ubcQUAAAAAAAAAAAAAAAAAnkR0bQH/LzQ0VHFxcXd9fOHChTV58uSHWNGdOTo6atGiRUZrAAAAAAAAAAAAAAAAAIAnFU2YAAAAAAAAAAAAAAAAAIDHmyXFdAV4QrEcOQAAAAAAAAAAAAAAAAAAgB1owgQAAAAAAAAAAAAAAAAAALADTZgAAAAAAAAAAAAAAAAAAAB2oAkTAAAAAAAAAAAAAAAAAADADjRhAgAAAAAAAAAAAAAAAAAA2MHBarVaTRcBwKyEyxeM5CY5uRnJlSRnWYxln00wk+tisO0+i6uZcIscjORKklOKmW/0FauLkVxJ8rp+xkiu1cHcD/dxh6zGsnNmMvPzfTnZ3PPK0VB01rN7zARLOp2tgJFck/9T63qKmY8npl6rJCnLie3GspOz5zcUnGgmV5KcXY3EWlwzG8mVpJPXzDyvvAw+r0y9Zngkx5sJlnTZydNIborF3J+Vsl0/ZSz7vHsOI7luzuaeV26Goh2vXzQTbFCye1Zj2c7XLxjJPS0vI7mSlJBi7m9EgZd2G8m1uJt7vFM8/Yzk/n3d3N9LPA29JzKVK0leHpmMZQMAAAB4sl2dO9h0CZDk0aCb6RIeOWbCBAAAAAAAAAAAAAAAAAAAsIOz6QIAAAAAAAAAAAAAAAAAALgfVkuK6RLwhGImTAAAAAAAAAAAAAAAAAAAADvQhAkAAAAAAAAAAAAAAAAAAGAHmjABAAAAAAAAAAAAAAAAAADsQBMmAAAAAAAAAAAAAAAAAACAHWjCBAAAAAAAAAAAAAAAAAAAsANNmAAAAAAAAAAAAAAAAAAAAHZwNl0AcC+WLl2qmTNnas+ePZKk/Pnzq169emrYsKEkKTIyUnXq1FG7du0eah3nzp3TxIkTtWrVKh0/flzZsmXT888/rzZt2igwMPCux7l69aoWLVqkRo0a3fU5x48fV0xMjDZs2KDExESFhoaqa9euKlCggB1XAgAAAAAAAAAAAAAAADz+rBaL6RLwhGImTDw2FixYoF69eum1115TXFycFi5cqLp16+qjjz7Sp59+ajsmOjr6odZx8OBB1a5dW1u3blWPHj20fPlyDR8+XGfPnlX9+vW1e/fuux5r8uTJmjRp0l0fn5iYqFatWuns2bMaN26cZs2aJS8vL7311ls6d+6cPZcDAAAAAAAAAAAAAAAAALATM2HisTFr1ixFRUWpfv36tm358+fXiRMnNH36dLVt21Y+Pj4PvY7OnTsrd+7cmjp1qlxdXSVJ/v7+Gjt2rOrUqaMhQ4ZoypQpdzWW1Wq9p+yNGzdqz549+umnn5QzZ05J0rBhw/T888/r+++/V1RU1L1dDAAAAAAAAAAAAAAAAADAbsyEiceGo6OjNm/erIsXL6bZ3rJlS82dO1fSjeXIY2NjJUmxsbFq2rSppk+frhdffFFhYWHq2LGjTp8+rc6dOys8PFzly5fXokWL7rqGHTt2aNu2bWrVqpWtATOVq6urRowYoT59+ti2ff/992rYsKHCw8MVEhKiqKgo/fLLL7b6Pv30Ux09elTBwcE6cuTIHfMLFCig8ePH2xowU1mt1nSPCwAAAAAAAAAAAAAAAADg4aIJE4+Nli1baufOnSpXrpxatWql8ePHa/v27fLy8lK+fPkyPGfjxo3auHGjpk2bppEjR2rlypWqXr26ChcurIULF6pcuXLq3bu3zp8/f1c1/P7775Kk8PDwDPcXLFhQgYGBkqQ//vhDbdq00SuvvKIlS5Zo/vz58vX11QcffKDExERFR0crOjpauXLl0po1a5Q7d+475vv5+al8+fJptk2fPl0JCQkqU6bMXV0DAAAAAAAAAAAAAAAAAODBYDlyPDYqV66suXPnasaMGVqzZo1Wr14tSQoMDNSgQYNUokSJdOdYLBYNHDhQWbJkUVBQkAoXLiwXFxc1a9ZMktS0aVPNmzdPhw4dUrZs2e5YQ+psk1myZLnjsU5OTurZs6caNWpk29akSRNFR0fr7Nmzyp07tzw8POTk5CQ/P7+7egz+6ZtvvtGIESPUuHFjFSpUyK4xAAAAAAAAAAAAAAAAAAD2oQkTj5XQ0FDFxMTIarVqz549Wr16taZPn66WLVvq22+/TXe8r69vmobJTJkypZlx0s3NTZKUkJBwV/k+Pj6SpAsXLih79uy3PbZw4cLy9vbWhAkTdODAAR08eFA7d+6UJKWkpNxV3u3Mnj1bAwYMUNWqVdWtW7f7Hg8AAAAAAAAAAAAAAAAAcG9YjhyPhRMnTmjAgAE6efKkJMnBwUHBwcFq1aqVpk2bpitXrui3335Ld56Li0u6bY6O9v/Ypy5DvnXr1gz3L126VO3bt9f169f122+/qXLlytq2bZsKFiyoNm3aKCYmxu7sm3388cfq27ev3njjDcXExNzXNQEAAAAAAAAAAAAAAAAA7MNMmHgsuLq6au7cucqVK5datmyZZp+np6ck3XFmygfhmWeeUfHixTV+/HiVL18+TZPn9evXNX78eGXNmlXu7u6aNGmSSpUqpU8//dR2zIwZMyRJVqtV0o1m0nsVExOjiRMnqnPnzmrevPl9XhEAAAAAAAAAAAAAAADw+LOmWEyXgCcUTZh4LPj4+KhFixYaOXKk4uPj9eqrr8rT01N79+7V559/rlKlSqlkyZKPpJb+/furcePGatq0qVq3bq3AwEAdPnxYn376qU6dOqWRI0dKknLnzq3vvvtOGzduVK5cubRhwwaNGjVKkpSYmChJ8vDw0MWLF3XgwAE99dRTGc7cebMNGzZo4sSJaty4sWrWrKnTp0/b9nl4eChz5swP56IBAAAAAAAAAAAAAAAAAOnQhInHRvv27RUYGKh58+bpiy++0PXr15U7d25VrVpVb7/99iOro0CBApo/f77Gjx+vPn366PTp0/L19VXp0qU1dOhQ+fv7S5Lee+89nTlzRq1bt5Z0YxbNQYMG6cMPP9T27dsVFBSkV155RfPmzVPNmjU1c+ZMFStW7LbZy5Ytk3RjRs3UWTVTtW3bVu3atXsIVwwAAAAAAAAAAAAAAAAAyIiDNXVdZABPrITLF4zkJjm5GcmVJGeZm4L6bIKZXBdHM7mSlMXVTLhFDkZyJckpxcw3+or19jPqPkxe188YybU6mPvhPu6Q1Vh2zkxmfr4vJ5t7Xjkais56do+ZYEmnsxUwkmvwJUPXU8x8PDH1WiVJWU5sN5adnD2/oeBEM7mS5OxqJNbiam7W+pPXzDyvvAw+r0y9Zngkx5sJlnTZydNIborF3J+Vsl0/ZSz7vHsOI7luzuaeV26Goh2vXzQTbFCye1Zj2c7XLxjJPS0vI7mSlGBwmbLAS7uN5FrczT3eKZ5+RnL/vm7u7yWeht4TmcqVJC+PTMayAQAAADzZLk/va7oESPJq0td0CY+cyX9fBQAAAAAAAAAAAAAAAAAAeGyxHDnw/0qWLKmUlJRb7s+WLZu+//77h5Zfs2ZNHT58+LbHrF27Vh4eHg+tBgAAAAAAAAAAAAAAAADA3aMJE/h/cXFxslpvvYyao+PDnTh27NixSkpKuu0xmTKxjAsAAAAAAAAAAAAAAAAA/FvQhAn8v6efftpofp48eYzmAwAAAAAAAAAAAAAAAADuDU2YAAAAAAAAAAAAAAAAAIDHmjXFYroEPKEe7vrKAAAAAAAAAAAAAAAAAAAA/1E0YQIAAAAAAAAAAAAAAAAAANiBJkwAAAAAAAAAAAAAAAAAAAA70IQJAAAAAAAAAAAAAAAAAABgB2fTBQAwL8nJzUiusyxGciXJ6uhkLNvJMcVIrs+VI0ZyJemK89NGcj2unjKSK0lWBzP/z8Ejs6+RXElyjD9jJDfZN9BIriTltlw1lm1RZiO5F66b+R0mSTkym3nrmpw9n5FcSfJJumwk1yHxmpFcSbI6uRjJdbxs7pqTs+c3lu2QdN1I7lUPPyO5kmS1Wo3kOlgdjORKUm7Hi0Zyz1m8jORKUlYzv0rkkGjuvYGXY6KRXAeruc91Z91zGMvO7GLm/b6zo7nfJVeSzHyvUxzN/S7xMPR9dkky97sk2T2rkVxfq7nPGecTzc1TkJQz2Eywwd/dJxLM/E0u4K8VRnIlKeXsCSO5zqVqGMmVpARrdiO5bpnNvWYAAAAAAJ5szIQJAAAAAAAAAAAAAAAAAABgB2bCBAAAAAAAAAAAAAAAAAA81qwWc6s/4MnGTJgAAAAAAAAAAAAAAAAAAAB2oAkTAAAAAAAAAAAAAAAAAADADjRhAgAAAAAAAAAAAAAAAAAA2IEmTAAAAAAAAAAAAAAAAAAAADvQhAkAAAAAAAAAAAAAAAAAAGAHmjABAAAAAAAAAAAAAAAAAADsQBMmAAAAAAAAAAAAAAAAAACAHZxNF4B/t6VLl2rmzJnas2ePJCl//vyqV6+eGjZsKEmKjIxUnTp11K5du4eSHxkZqaNHj95y//PPP68ZM2bYPX5SUpK++OILNW3a9J7OS05O1hdffKEvv/xSBw4ckKurq4oUKaJWrVopIiLirsexWq1avHixypUrJ19f37s65/r16/rss8+0fPlynT9/Xvny5VObNm1UsWLFe7oGAAAAAAAAAAAAAAAA4L/CmmIxXQKeUDRh4pYWLFiggQMHqnv37nruuedktVq1bt06ffTRRzpz5ozatm2rBQsWyM3N7aHWkJKSIknasmWL2rVrp/nz5yt37tySJBcXl/saf9myZRo8ePA9NWEmJiaqWbNmOn78uNq1a6fw8HBdv35dCxcuVHR0tAYPHqzatWvf1Vi//fabunbtqlWrVt11/sCBA7V27Vr1799fTz/9tL7++mu1bdtWU6dOValSpe56HAAAAAAAAAAAAAAAAADA/aEJE7c0a9YsRUVFqX79+rZt+fPn14kTJzR9+nS1bdtWPj4+D7WGm8f39va2bfPz83sg41ut1ns+Z/To0dq1a5eWL1+uXLly2bb36NFDV69e1aBBg1SpUiVlzpz5gedfu3ZNixcv1uDBg1W2bFlJ0ttvv61169Zp4cKFNGECAAAAAAAAAAAAAAAAwCPkaLoA/Hs5Ojpq8+bNunjxYprtLVu21Ny5cyXdWC48NjZWkhQbG6umTZtq+vTpevHFFxUWFqaOHTvq9OnT6ty5s8LDw1W+fHktWrTogdVotVo1YcIEVaxYUcWKFVOtWrW0ZMkS2/7+/fsrPDzctqT5tWvX9Oqrr6p169aKi4tTt27dJEnBwcHasGHDHfOSkpI0f/58RUVFpWnATPX+++9r4sSJcnd3lyT99ddfevfdd1WqVCkVLVpUlSpV0rRp0yRJGzZsUJMmTSRJFStWVFxc3B3zHRwcNHbsWFsD5s3++X0CAAAAAAAAAAAAAAAAADxcNGHillq2bKmdO3eqXLlyatWqlcaPH6/t27fLy8tL+fLly/CcjRs3auPGjZo2bZpGjhyplStXqnr16ipcuLAWLlyocuXKqXfv3jp//vwDqXHEiBGaNWuWevbsqaVLl6pJkybq27evvvjiC0lS586dlTNnTvXu3VuSNHjwYF25ckWDBw9W1apV1b17d0nSmjVrFB4efse8w4cP68KFCwoLC8twf44cORQaGionJyddu3ZNzZo1k4eHh2bNmqXly5erSpUqGjRokHbu3Knw8HBbA+v8+fNVtWrVO+a7u7vrxRdfVNasWW3btm3bpvXr1+vFF1+84/kAAAAAAAAAAAAAAAAAgAeH5chxS5UrV9bcuXM1Y8YMrVmzRqtXr5YkBQYGatCgQSpRokS6cywWiwYOHKgsWbIoKChIhQsXlouLi5o1ayZJatq0qebNm6dDhw4pW7Zs91Xf1atXNXXqVA0bNkwVKlSQJD399NM6evSoJk2apEaNGsnd3V0xMTFq2LChunfvrkWLFmnKlCm2bC8vL0m66+XNU2ebTF0a/XauXbumJk2a6I033pCnp6ckqW3btho3bpx2796twoULp1liPXX2zHuxf/9+tWnTRkWLFlWDBg3u+XwAAAAAAAAAAAAAAAAAgP1owsRthYaGKiYmRlarVXv27NHq1as1ffp0tWzZUt9++2264319fZUlSxbb/UyZMil37ty2+25ubpKkhISE+65t7969SkhIUJcuXWzLiktScnKyEhMTdf36dbm7uyskJERvv/22PvvsM7311lsqXbq03Zk+Pj6SpAsXLtzVsW+88YZWrFihXbt26dChQ9q5c6ekG82q92vz5s1699135efnp/Hjx8vV1fW+xwQAAAAAAAAAAAAAAAAA3D2aMJGhEydOaMKECWrVqpVy5swpBwcHBQcHKzg4WBUrVlTVqlX122+/pTvPxcUl3TZHx4ez6r3VapUkjRw5Uvnz50+3/+amxB07dsjZ2VkbNmxQYmKi3Q2L/v7+yp49u7Zs2ZLh8uEHDx5U//791aVLF/n6+qp+/frKli2bKlasqIiICIWEhKh8+fJ2Zd/s22+/VadOnRQSEqIxY8akaXwFAAAAAAAAAAAAAAAAADwaD6c7Do89V1dXzZ07V0uWLEm3L3Vp7ezZsz/qstLInz+/nJ2ddezYMQUEBNhuq1ev1qRJk2zNn3PmzNHatWs1adIknThxQqNGjbKN4eDgcE+Zjo6OioqKUlxcnE6ePJlu/8SJE7V161blzZtXS5cu1YULFzRnzhy9++67qlSpkm0589QG0nvNl6Tvv/9e7du310svvaQpU6bQgAkAAAAAAAAAAAAAAIAnnjXFwu1fcHsS0YSJDPn4+KhFixYaOXKkRowYoZ07d+rw4cP64Ycf1LZtW5UqVUolS5Y0WqOXl5caNmyokSNHavHixTp8+LAW/R97dx5WdZ3///9xWA6rICAqJgpuhCmJYmiL+FEnt7LJdbQ0MkFLMjN1GrXMdTQzLcxxsFI0910nHZuyscnKUculvpaTuS+IqCQoHDjn/P7okl/kBkfhpXm/XRfXZe/t8Xwfznmf9zk9eb1WrdKUKVOKGkQPHTqkyZMnKyUlRc2aNdPIkSP1/vvvF43i6evrK0n69ttvlZeXV6LcAQMGqGbNmvrTn/6k1atX6/Dhw9qzZ49GjhypFStWaNy4cfL391fVqlV18eJFbdiwQcePH9fnn3+uIUOGSJJsNlux/O+//165ubnXzc7Oztaf//xn3XPPPRo5cqSys7OVmZmpzMzMEk2RDgAAAAAAAAAAAAAAAAC4eZiOHFc1ePBgRUREaOnSpVqwYIHy8vIUFhamDh06qH///qbLkyT95S9/UXBwsN5++22dOnVKVatWVUpKipKTk2W32zV8+HBFRkaqX79+kqROnTpp/fr1+vOf/6y1a9eqWbNmuvfee/WnP/1JU6ZMUfv27a+b6ePjow8++EDvv/++Zs+erePHj8vLy0v33HOP0tPTdd9990mS2rVrp++++06TJ09WTk6O7rrrLnXr1k2ffPKJdu/erZ49e6pevXpKSEjQ4MGDNWTIEPXt2/ea2Z999pl+/vln7dq1Sy1atCi27r777tP8+fNdfCQBAAAAAAAAAAAAAAAAAKVlcV6aFxnAHSvnwkUjuR4yNwSx083dWHZ2vt1IbqXco0ZyJSk3sIaRXN8LmUZyJclpMTPYtMMvxEiuJHme3GsktzAkwkiuJFkchcayHVY/I7lHcsxduyv7mfn7IW+nzUiuJFkKzLxHW2xmciXJ6e5pJNfN0GMtSQ6fQGPZloKSjQZ/s13wDTWSK0mmPgJbLBYjuZLkY8s2knvGrYKRXEmqaOZSIvccg/efbmbeJy1Oc/cGWVZz975+nmbu9z3czF1LLhSY+V3bHea+uvQ19Hv2LDR3X2L39DWS6+Y0812JJJ01d7uvYE9D11CD1+6T+Wa+kwv7fr2RXEmyZ500kusR/6iRXEly+FcykuvlZ+7+EwAAAMCt4ezfXjZdAiQFPTvJdAnljunIAQAAAAAAAAAAAAAAAAAAXMB05DAmLi5OdvvV/8o9KChImzZtKrd6BgwYoK1bt15zm+XLl6t27dplkj927FitWrXqmtu89dZbl01DDgAAAAAAAAAAAAAAAAAwgyZMGLNy5cprTgXo5la+A7WOGTNGeXnXno4xLCyszPJTUlL01FNPXXObypUrl1k+AAAAAAAAAAAAAAAAAKB0aMKEMTVq1DBdQjFVqlQxmh8cHKzg4GCjNQAAAAAAAAAAAAAAAAC3I8c1ZuQFylL5DjUIAAAAAAAAAAAAAAAAAADwO0ETJgAAAAAAAAAAAAAAAAAAgAtowgQAAAAAAAAAAAAAAAAAAHABTZgAAAAAAAAAAAAAAAAAAAAuoAkTAAAAAAAAAAAAAAAAAADABR6mCwBgXna+w0iuj4fFSK4k+cpuLNtmdxrJLQyqYSRXknxys4zknvOqZCRXkrwNPb99T+41kitJ+VXrG8nNsRl8PTusxrJzzps5by93c9duv+zDRnLzKpq7frp5exnJdff0MZIrSW4XzpoJdpq5H5Kk8+7+xrJ9vALMBDvM3A9JUsDJ3UZyc6vdayRXkmQx8/eXOTZzr6tg5RvJtRRcNJIrSY4KVcwEG7x+VvQ0Fi23glwjufmefkZyJcnUbaCXp7m/IT9v6DoWetHMZ2hJygswcx/o6eZuJFeSfrbZjGV7uJn5er6Cp7n/LeDlYeZ1dT7mESO5klSh8GcjuResgUZyJcn3/HEjufkOc98ReVWoaCwbAAAAAGAeI2ECAAAAAAAAAAAAAAAAAAC4gJEwAQAAAAAAAAAAAAAAAAC3NafD3Mw9uLMxEiYAAAAAAAAAAAAAAAAAAIALaMIEAAAAAAAAAAAAAAAAAABwAU2YAAAAAAAAAAAAAAAAAAAALqAJEwAAAAAAAAAAAAAAAAAAwAU0YQIAAAAAAAAAAAAAAAAAALiAJkwAAAAAAAAAAAAAAAAAAAAX0ISJK1q3bp169Oih2NhYxcbGqkuXLlq8eHHR+latWik1NbXM6zhz5oxef/11tW3bVjExMUpISNCwYcN08ODBMs8uiZkzZ6p3797X3e7s2bN66aWX1LRpUzVt2lSvvPKKLly4UOKco0ePKioqqthPo0aN1LVrV/373/++gTMAAAAAAAAAAAAAAAAAALjKw3QBuPUsX75c48eP14gRI9S0aVM5nU59+eWXmjBhgk6fPq2UlBQtX75cXl5eZVrHwYMH1adPH1WvXl0jR45UZGSkMjIyNHPmTHXv3l3z589XVFRUmdZwLXPnztXbb7+tpk2bXnfbQYMGKT8/X3PnztXPP/+skSNHasyYMZo8eXKpMlNTUxUbGyun06nz58/rww8/1MCBA7V8+XJFR0e7eioAAAAAAAAAAAAAAADAbc1pd5guAXcomjBxmYULF6pr167q3r170bJatWrp5MmTmjdvnlJSUhQcHFzmdQwfPlxhYWGaO3eurFarJCk8PFyzZs3S448/rkmTJmnOnDllXsdvZWRkaOTIkdqxY4ciIyOvu/0333yj//73v1q/fr1q164tSRo7dqz69eunIUOGqEqVKiXODgwMVGhoqCSpcuXKGjRokD788EOtXbuWJkwAAAAAAAAAAAAAAAAAKGdMR47LuLm56euvv1Z2dnax5UlJSVqyZImk4tORp6amKjExUfPmzdODDz6oRo0aaciQIcrMzNTw4cMVGxurhIQErVq1qsQ1fPfdd9q1a5eSk5OLGjAvsVqtmjZtmkaPHl20bP/+/RowYIDi4+PVpEkTDRo0SMePHy9a37t3b40YMULdunVTXFycVq9eXdqHpVhtgYGBWrt2re69997rbr99+3aFhoYWNWBK0n333SeLxaIdO3a4XMclPj4+N3wMAAAAAAAAAAAAAAAAAEDp0YSJyyQlJWnv3r1q0aKFkpOTlZaWpt27d6tChQpXHflx+/bt2r59u9LT0zV9+nRt3LhRjzzyiKKjo7VixQq1aNFCr776qs6ePVuiGvbs2SNJio2NveL6evXqKSIiQpJ07Ngx9ejRQ1arVenp6ZozZ46ysrL05JNPKicnp2iflStXqk+fPlq0aJESEhJK8YgU16pVK02dOlXh4eEl2j4jI0NhYWHFllmtVlWsWFEnTpxwuY7CwkKtXr1a+/fv1x//+EeXjwMAAAAAAAAAAAAAAAAAcA3TkeMybdu21ZIlSzR//nx9/vnn2rx5syQpIiJCEydOVJMmTS7bx+FwaPz48QoICFDt2rUVHR0tT09PPf3005KkxMRELV26VIcOHVJQUNB1a7g0CmdAQMB1t124cKF8fX31xhtvFI2a+fbbb6tVq1Zau3atevXqJUmKjo7Wo48+WrIH4Sa6ePHiZaN5SpKXl5fy8/NLdaykpCS5u7tLkvLy8uRwONSrVy/VrVv3ptQKAAAAAAAAAAAAAAAAACg5mjBxRTExMZoyZYqcTqf27dunzZs3a968eUpKStK//vWvy7YPCQkp1jDp4+NTbPRHLy8vSSpx02FwcLAk6dy5c6pUqdI1t923b58aNGhQrNExJCREkZGR+uGHH4qW1axZs0TZl7z66qtat25d0X/3799fAwYMKNUxJMnb21s2m+2y5fn5+fL19S3VscaPH180BfrFixe1Z88eTZ48WXa7XWPHji11bQAAAAAAAAAAAAAAAAAA19GEiWJOnjyp2bNnKzk5WVWqVJHFYlFUVJSioqLUunVrdejQQdu2bbtsP09Pz8uWubm5Ptv9pWnId+7cqTZt2ly2ft26dfrkk080adIkOZ1OWSyWy7ax2+3F6vL29i5VDS+88IKeeeaZov8ODAws1f6XVK1aVR9//HGxZTabTefOnVOVKlVKdawqVaoUaya9++67lZmZqbffflvDhw+Xv7+/SzUCAAAAAAAAAAAAAAAAAErP9S45/C5ZrVYtWbJEa9euvWzdpQa/641MeTPUqVNHjRs3VlpamgoKCoqty8vLU1pamrKysuTt7a169epp9+7dxUabPH36tA4dOqTatWu7XENISIhq1qxZ9FOxYkWXjtO0aVOdPHlShw4dKlq2detWSVLjxo1dru+3nE7nTTsWAAAAAAAAAAAAAAAAcDtx2h383AI/dyKaMFFMcHCw+vXrp+nTp2vatGnau3evjhw5ok8//VQpKSmKj49XXFxcudQyduxYHT58WImJifrPf/6jI0eO6IsvvlDfvn116tQpvfbaa5Kknj17KicnR0OHDtX333+v3bt364UXXlBQUJA6duxYLrX+mt1uV2ZmpvLy8iRJ9957rxo3bqwXX3xRu3fv1ldffaXRo0frj3/8Y6lHwszOzlZmZqYyMzOVkZGhjRs3Kj09Xa1atVKFChXK4nQAAAAAAAAAAAAAAAAAAFfBdOS4zODBgxUREaGlS5dqwYIFysvLU1hYmDp06KD+/fuXWx1169bVsmXLlJaWptGjRyszM1MhISFq1qyZJk+erPDwcElSeHi45s+frzfeeEM9evSQ1WrVAw88oClTpiggIKDc6r3kxIkTat26tf7617+qc+fOslgsmjFjhsaMGaOnnnpKXl5eateunf7yl7+U+tjPP/980b89PDxUpUoVPfLII3rxxRdv5ikAAAAAAAAAAAAAAAAAAErA4mQOY+COd+xsrpFcHw+LkVxJ8nU3d+k7lWcmu7KPu5FcSXLLzTKSm20NNpIrSd6Gnt++GXuN5EpSftX6RnJzbHYjuZJks5u7luQUmBnG3cvd3LU73HbcSG5exRpGciXJzWLm8Xa35xvJlSS3C2eN5FoKzZ1zdoVwY9k+HmYmRyhwmLt+Vjixy0hubrV7jeRKkpftvJHcwwU+RnIlqYbVzGvaLSfTSK4k2SuUbqaFm8XiNDe1jMPT3HPMreCikdx8Tz8juZJkN3Tt9nAzd/953mbm+R160cx9ryTlBlQ3kutp8Pd85LzNWHawt5kxEip4mnu8zxl6XZl8jlUo/NlI7kVroJFcSfI9b+Y65vALMZIrSV4VKhrLBgAAAPD/O/XGC6ZLgKTKQ98yXUK5YzpyAAAAAAAAAAAAAAAAAAAAFzAdOcpdXFyc7Parj1oWFBSkTZs2lWkNnTp10pEjR665zZYtW+Tr61umdUi3xuMBAAAAAAAAAAAAAAAAACg9mjBR7lauXCmn8+pTWLm5lf0ArbNmzVJBQcE1t/HxKZ9pzW6FxwMAAAAAAAAAAAAAAAAAUHo0YaLc1ahRw3QJqlatmukSitwKjwcAAAAAAAAAAAAAAAAAoPRowgQAAAAAAAAAAAAAAAAA3NacDofpEnCHYp5jAAAAAAAAAAAAAAAAAAAAF9CECQAAAAAAAAAAAAAAAAAA4AKaMAEAAAAAAAAAAAAAAAAAAFxAEyYAAAAAAAAAAAAAAAAAAIALaMIEAAAAAAAAAAAAAAAAAABwgYfpAgCYV8mjwEyw02EmV5JNPsayCx2FRnI9T+0zkitJ9sAwI7neHhYjuZLk4WYm+1CFukZyJSnYbuY1Hehh7lriZjtrLLtShRAjuW4FF43kSpLdu6qR3Hy700iuJJ25aOY9I9jH00iuJOV5hhrJDfE3EitJ8nUz97dxdoeZ57ffuYNGciVpt8/dRnKD8+xGciXJ293PSK6/1UisJOmMofv9gOBII7mS5G7PN5LrlLuRXEk6Z+ijrCT5eJh5XfkU5BrJlaQfLpi5P6jnb+5ezOpu5kKWG1DdSK4keRr6LOuR/7ORXEmq4mvuRtDLw8x9YKGhe0BJOplj5uIdHWjuOyK3i9lGcn0LbUZyJcnpE2gk12I3d85Z5y8YyQ2p4GskFwAAAABQHCNhAgAAAAAAAAAAAAAAAAAAuICRMAEAAAAAAAAAAAAAAAAAtzWHodkbAUbCBAAAAAAAAAAAAAAAAAAAcAFNmAAAAAAAAAAAAAAAAAAAAC6gCRMAAAAAAAAAAAAAAAAAAMAFNGECAAAAAAAAAAAAAAAAAAC4gCZMAAAAAAAAAAAAAAAAAAAAF9CECQAAAAAAAAAAAAAAAAAA4AKaMFEq69atU48ePRQbG6vY2Fh16dJFixcvLlrfqlUrpaamlnkdZ86c0euvv662bdsqJiZGCQkJGjZsmA4ePFjm2ZKUn5+vMWPGqHnz5oqNjdWgQYOUlZV1zX2+++479enTR40bN1bLli2Vmpoqu93uUv7SpUsVFRWliRMnurQ/AAAAAAAAAAAAAAAA8HvitDv4uQV+7kQ0YaLEli9frldeeUVdunTRypUrtWLFCnXu3FkTJkzQjBkzirbp27dvmdZx8OBB/fGPf9TOnTs1cuRIffjhh5o6daqysrLUvXt3/fDDD2WaL0mvvfaatmzZotTUVKWnp+vIkSN64YUXrrr9kSNH9MQTT6hChQpatGiRXn/9dX344YcaPXq0S/krV65UZGSkVq9erby8PFdPAwAAAAAAAAAAAAAAAABwA2jCRIktXLhQXbt2Vffu3RUZGalatWrpiSeeUGJioubNmydJCg4Olp+fX5nWMXz4cIWFhWnu3Llq0aKFwsPDFRcXp1mzZik0NFSTJk0q0/yMjAytXr1ao0aNUlxcnGJiYvTmm29q27Zt2rlz5xX3+eCDD1SxYkVNmzZNUVFRuu+++zRhwgQtX75cx48fL1X+/v379c0332jo0KE6f/681q9ffxPOCgAAAAAAAAAAAAAAAABQWjRhosTc3Nz09ddfKzs7u9jypKQkLVmyRFLx6chTU1OLGjQffPBBNWrUSEOGDFFmZqaGDx+u2NhYJSQkaNWqVSWu4bvvvtOuXbuUnJwsq9VabJ3VatW0adOKjS65f/9+DRgwQPHx8WrSpIkGDRpUrOmxd+/eGjFihLp166a4uDitXr36ujXs2LFDkhQfH1+0LDIyUlWqVNG2bduuuM+BAwcUExNTrOb69evL6XRedZ+rWblypQICAtSyZUvFxcVp0aJFpdofAAAAAAAAAAAAAAAAAG43+fn5GjNmjJo3b67Y2FgNGjRIWVlZ19xnxowZioqKuuynsLCwaJsFCxaodevWiomJUY8ePbRnz55S1UUTJkosKSlJe/fuVYsWLZScnKy0tDTt3r1bFSpUUGRk5BX32b59u7Zv36709HRNnz5dGzdu1COPPKLo6GitWLFCLVq00KuvvqqzZ8+WqIZLT/DY2Ngrrq9Xr54iIiIkSceOHVOPHj1ktVqVnp6uOXPmKCsrS08++aRycnKK9lm5cqX69OmjRYsWKSEh4bo1ZGRkKCgoSF5eXsWWV65cWSdOnLjiPqGhoZetO3bsmCRd90Lwa3a7XWvWrFGbNm3k4eGhjh07avfu3fp//+//lfgYAAAAAAAAAAAAAAAAAHC7ee2117RlyxalpqYqPT1dR44c0QsvvHDNfX744Qc99thj+vzzz4v9eHh4SJJWrVqlKVOmaPDgwVq5cqVq1qypfv366cyZMyWuiyZMlFjbtm21ZMkSPfzww9qzZ4+mTp2qbt26qV27dkWjQ/6Ww+HQ+PHjVbt2bbVs2VLR0dGqVauWnn76adWqVUuJiYmy2Ww6dOhQiWq4NApnQEDAdbdduHChfH199cYbb+juu+9WTEyM3n77bWVlZWnt2rVF20VHR+vRRx9V3bp1FRQUdN3jXrx48bJROCXJy8tL+fn5V9zn8ccf1549e5SWlqb8/HydOnVK48aNk4eHh2w223UzL/nss8+UmZmpDh06SPrld+Lp6anFixeX+BgAAAAAAAAAAAAAAAAAcDvJyMjQ6tWrNWrUKMXFxSkmJkZvvvmmtm3bpp07d151v3379ql+/foKDQ0t9nPJrFmz9OSTT+rRRx9VnTp1NHHiRPn4+Gj58uUlro0mTJRKTEyMpkyZoi+++EJr167VSy+9pNzcXCUlJV1xRMeQkJBiDZM+Pj4KDw8v+u9Lo0lerXnxt4KDgyVJ586du+62+/btU4MGDYo1TIaEhCgyMlI//PBD0bKaNWuWKPsSb2/vKzZO5ufny8fH54r7xMXFaeLEiXrvvffUqFEjdejQQa1bt1ZQUJAqVKhQ4uwVK1aoYsWKat68uSQpKChIzZs317p164qN7gkAAAAAAAAAAAAAAAAAvxeXBgmMj48vWhYZGakqVapo27ZtV9zn4sWLOnz4sOrUqXPF9VlZWTp48KCaNWtWtMzDw0NxcXFXPeaVeJR4S9zRTp48qdmzZys5OVlVqlSRxWJRVFSUoqKi1Lp1a3Xo0OGKTzxPT8/Llrm5ud77e2ka8p07d6pNmzaXrV+3bp0++eQTTZo0SU6nUxaL5bJt7HZ7sbq8vb1LVUPVqlV17tw52Wy2Yg2ep06dUtWqVa+6X+fOnfX444/r1KlTCgoKUmFhoSZOnFjiJtAzZ87o3//+twoKChQTE1O03OFwyOl0as2aNXriiSdKdS4AAAAAAAAAAAAAAAAAcLO0bt36mus/+eQTl46bkZGhoKCgokH/LqlcubJOnDhxxX3+97//yeFw6J///KfGjh0rm82m++67T0OHDlXlypV18uRJSVJYWNhlx/z+++9LXBtNmCgRq9WqJUuWqGrVqkpKSiq2zt/fX5JUqVKlMq+jTp06aty4sdLS0pSQkFCsmTIvL09paWmqWLGivL29Va9ePa1bt65Ys+Tp06d16NAh9erVy+UamjRpIofDoR07dhSNSPnTTz8pIyNDcXFxV9xn48aNWrt2rd555x1VqVJFkvThhx/K19e3qLH0etauXauCggK98847qlGjRtFyh8Ohvn37avHixTRhAgAAAAAAAAAAAAAA4I7ktDtMl4AbcPTo0Ws2cL7wwgvFBsy7xMvL66qzMP/vf/+TJFWoUEFvv/22Tp8+rTfffFN9+vTRqlWrdPHiRUm67LjXOuaV0ISJEgkODla/fv00ffp05eTkqF27dvL399ePP/6omTNnKj4+/qoNiDfb2LFj1bt3byUmJmrAgAGKiIjQkSNHNGPGDJ06dUrTp0+XJPXs2VOLFi3S0KFD9dxzz8lms2ny5MkKCgpSx44dXc6vUqWKOnbsqFGjRmnixIny8fHR6NGjdd9996lRo0aSJJvNpuzsbAUGBspqtapu3br67LPPNHPmTHXq1Enfffedxo0bp+eee05+fn4lyl2xYoViY2OvOAJor169lJqaqh07dqhJkyYunxsAAAAAAAAAAAAAAAAAuMrVkS6rVKmi9evXX3X95s2bZbPZLluen58vHx+fK+7TpUsXtWnTRoGBgUXL6tatq4SEBH366adFA+H99rjXOuaV0ISJEhs8eLAiIiK0dOlSLViwQHl5eQoLC1OHDh3Uv3//cqujbt26WrZsmdLS0jR69GhlZmYqJCREzZo10+TJkxUeHi5JCg8P1/z58/XGG2+oR48eslqteuCBBzRlyhQFBATcUA3jxo3TxIkTlZKSIklq0aKFRo0aVbT+m2++UZ8+fTRv3jzFx8erVq1amjFjhqZOnaq///3vqlq1ql566aUSj1z57bffat++fXrjjTeuuL5Xr16aPXu2Fi9eTBMmAAAAAAAAAAAAAAAAgNuKp6enateufdX1P/zwg86dO1dsVmRJOnXqlKpWrXrV/X7dgCn90uxZsWJFnTx5Us2aNSs6xq+zr3fM37I4nU5nibcG8LuUf/6cmWCnuWGgbR4l71a/2TIvFBrJrZn7k5FcSbIHhhnJzbdWMJIrSR5uFiO5J3IKjORKUrC3u5FcH4vdSK4kuV04ayzb7hdiJNet4KKRXElyunsayc1xmsmVpDMXzTy/g33MvJ4lKa/QzMeTEC8jsZIkp5u5x9vuMPN4e589aCRXkr6VmfuSYB9zfwPp7W7mvuROnPQlwGru9exuL/m0KL8XZ+3mXlc+Hm5mcgtzjeRK0g8XzNwT1fM399Vlji6f2qg8mPo8KUmehrI98n82kitJFzz8jWV7GbqWmLoHlKQfz5p5v4oONPe6cv/5pJFcp6e57z+dVl9DwebuQM+7m7mWhFQw9FgDAAAAt6hjY8pvEDlc3V2j/14mx83IyFBCQoLmzJmj5s2bS5J++ukntW/fXkuWLCmawfjXpk6dqk8++UQffvihLJZfvh+4NO357Nmz1aJFC7Vr107t2rXT4MGDJUmFhYVq06aNevXqpeTk5BLVZuZbHgAAAAAAAAAAAAAAAAAAgBKoUqWKOnbsqFGjRmnr1q3avXu3XnrpJd13331FDZg2m02ZmZlF04u3a9dOR44c0bhx43TgwAFt27ZNzz//vBo3bqyHHnpIktS3b1/NmTNHq1at0o8//qgRI0YoLy9PXbt2LXFtTEeOW0ZcXJzs9quP9hQUFKRNmzaVaQ2dOnXSkSNHrrnNli1b5Ot78/66NCMjQ+3atbvmNvXr19eCBQtuWiYAAAAAAAAAAAAAAAAA3E7GjRuniRMnKiUlRZLUokULjRo1qmj9N998oz59+mjevHmKj4/XPffco3fffVfTp09X586dZbVa1bp1a/35z38uGhmze/fuOn/+vKZPn65z586pQYMGmjNnjoKDg0tcF9OR45Zx+PBhXevp6ObmpvDw8DKt4fjx4yoouPZUvjVq1Ch6Ed4MdrtdR48eveY2Xl5eqlq16k3L/C2mIy9fTEdefpiOvHwxHXn5Yjry8sN05OWL6cjLF9ORlx+mI78zMB15+WI68vLFdOTlh+nIyxfTkZcvpiMvP0xHXr6YjhwAAAC4NTAd+a2hrKYjv5UxEiZuGTVq1DBdgqpVq1bume7u7qpZs2a55wIAAAAAAAAAAAAAAAAAbgxNmAAAAAAAAAAAAAAAAACA25rTcSfO0YRbgZn5TgAAAAAAAAAAAAAAAAAAAG5zNGECAAAAAAAAAAAAAAAAAAC4gCZMAAAAAAAAAAAAAAAAAAAAF9CECQAAAAAAAAAAAAAAAAAA4AIP0wUAMC/PzctIrm9uhpFcSfII8DWWXdXP00iuo9DfSK4kuR342kiutW5zI7mSpEK7kdgwf3PP7QsFDiO5Dg8zrylJsljNPd6Fhv6WxtPd3OPtlnPaSK5fQFUjuZKU52nm9+zn7jSSK0lWdzPnXGAk9RfWgjxj2ab+Ks9eoYqhZKmKw8x1zOpuMZIrmXtNm3qvkqRCh5lztjvNXT9tMvPc9nAz99w+csbc9bNusJnP0TL4nhHs7WMk1+K4aCRXkvwNXbt/tpu757bZzVzHKlj9jORKko/dZiw7t8BqJNdP5s65ko+Z/yVhKcgxkitJTnczv+c8v1AjuZJkdRYayS2wmPtfXv6GzvmZxd8YyZWk9/4UaywbAAAAAG41jIQJAAAAAAAAAAAAAAAAAADgAkbCBAAAAAAAAAAAAAAAAADc1px2M7M3AoyECQAAAAAAAAAAAAAAAAAA4AKaMAEAAAAAAAAAAAAAAAAAAFxAEyYAAAAAAAAAAAAAAAAAAIALaMIEAAAAAAAAAAAAAAAAAABwAU2YAAAAAAAAAAAAAAAAAAAALqAJEwAAAAAAAAAAAAAAAAAAwAU0YaJU1q1bpx49eig2NlaxsbHq0qWLFi9eXLS+VatWSk1NLfM6zpw5o9dff11t27ZVTEyMEhISNGzYMB08eLDMsyUpPz9fY8aMUfPmzRUbG6tBgwYpKyvrmvt899136tOnjxo3bqyWLVsqNTVVdru9xJlbt25VVFRUsZ/GjRurd+/e2rlz5w2eEQAAAAAAAAAAAAAAAACgtDxMF4Dbx/LlyzV+/HiNGDFCTZs2ldPp1JdffqkJEybo9OnTSklJ0fLly+Xl5VWmdRw8eFB9+vRR9erVNXLkSEVGRiojI0MzZ85U9+7dNX/+fEVFRZVpDa+99pp27Nih1NRUWa1WjR49Wi+88II++OCDK25/5MgRPfHEE3rggQe0aNEiZWdn69VXX1VGRobGjx9fquxly5YpLCxMDodD2dnZ+uCDD/TMM89ow4YNqly58s04PQAAAAAAAAAAAAAAAOC24rQ7TJeAOxQjYaLEFi5cqK5du6p79+6KjIxUrVq19MQTTygxMVHz5s2TJAUHB8vPz69M6xg+fLjCwsI0d+5ctWjRQuHh4YqLi9OsWbMUGhqqSZMmlWl+RkaGVq9erVGjRikuLk4xMTF68803tW3btquOSPnBBx+oYsWKmjZtmqKionTfffdpwoQJWr58uY4fP16q/ODgYIWGhqpKlSqqV6+eRo0aJYfDoY8++ugmnB0AAAAAAAAAAAAAAAAAoKRowkSJubm56euvv1Z2dnax5UlJSVqyZImk4tORp6amFjVoPvjgg2rUqJGGDBmizMxMDR8+XLGxsUpISNCqVatKXMN3332nXbt2KTk5WVartdg6q9WqadOmafTo0UXL9u/frwEDBig+Pl5NmjTRoEGDijU99u7dWyNGjFC3bt0UFxen1atXX7eGHTt2SJLi4+OLlkVGRqpKlSratm3bFfc5cOCAYmJiitVcv359OZ3Oq+5TUp6envL09LyhYwAAAAAAAAAAAAAAAAAASo8mTJRYUlKS9u7dqxYtWig5OVlpaWnavXu3KlSooMjIyCvus337dm3fvl3p6emaPn26Nm7cqEceeUTR0dFasWKFWrRooVdffVVnz54tUQ179uyRJMXGxl5xfb169RQRESFJOnbsmHr06CGr1ar09HTNmTNHWVlZevLJJ5WTk1O0z8qVK9WnTx8tWrRICQkJ160hIyNDQUFBl027XrlyZZ04ceKK+4SGhl627tixY5KkrKys62ZeTX5+vv7+979Lktq2bevycQAAAAAAAAAAAAAAAAAApedhugDcPtq2baslS5Zo/vz5+vzzz7V582ZJUkREhCZOnKgmTZpcto/D4dD48eMVEBCg2rVrKzo6Wp6ennr66aclSYmJiVq6dKkOHTqkoKCg69ZwaRTOgICA6267cOFC+fr66o033igagfLtt99Wq1attHbtWvXq1UuSFB0drUcffbRkD4KkixcvXjYKpyR5eXkpPz//ivs8/vjjevLJJ5WWlqannnpK2dnZGjdunDw8PGSz2UqcLUmPPPKILBaLnE6n8vLy5HQ69dJLLyk0NLRUxwEAAAAAAAAAAAAAAAAA3BiaMFEqMTExmjJlipxOp/bt26fNmzdr3rx5SkpK0r/+9a/Ltg8JCSnWMOnj46OwsLCi/740muTVmhd/Kzg4WJJ07tw5VapU6Zrb7tu3Tw0aNCjWMBkSEqLIyEj98MMPRctq1qxZouxLvL29r9g4mZ+fLx8fnyvuExcXp4kTJ2ry5MmaNm2a/Pz8NGjQIO3fv18VKlQoVX5aWpqqVKkiScrNzdVXX32lN998U06nU/379y/VsQAAAAAAAAAAAAAAAAAArmM6cpTIyZMnNW7cOGVkZEiSLBaLoqKilJycrPT0dOXm5mrbtm2X7efp6XnZMjc31592l6Yh37lz5xXXr1u3ToMHDy4aIdJisVy2jd1uL1aXt7d3qWqoWrWqzp07d1kj5qlTp1S1atWr7te5c2d99dVX+ve//60vvvhCXbt21enTp0vdBFqtWjXVrFlTNWvWVP369dW3b1899thjmjNnTqmOAwAAAAAAAAAAAAAAAAC4MTRhokSsVquWLFmitWvXXrbO399fkq47MuXNUKdOHTVu3FhpaWkqKCgoti4vL09paWnKysqSt7e36tWrp927dxdrljx9+rQOHTqk2rVru1xDkyZN5HA4tGPHjqJlP/30kzIyMhQXF3fFfTZu3KiBAwfKYrGoSpUqslqt2rhxo3x9fYsaS2+U0+m8KccBAAAAAAAAAAAAAAAAAJQM05GjRIKDg9WvXz9Nnz5dOTk5ateunfz9/fXjjz9q5syZio+Pv2oD4s02duxY9e7dW4mJiRowYIAiIiJ05MgRzZgxQ6dOndL06dMlST179tSiRYs0dOhQPffcc7LZbJo8ebKCgoLUsWNHl/OrVKmijh07atSoUZo4caJ8fHw0evRo3XfffWrUqJEkyWazKTs7W4GBgbJarapbt64+++wzzZw5U506ddJ3332ncePG6bnnnpOfn1+p8s+cOVM0jXthYaE+//xzrV27Vn/6059cPicAAAAAAAAAAAAAAADgduZwOEyXgDsUTZgoscGDBysiIkJLly7VggULlJeXp7CwMHXo0EH9+/cvtzrq1q2rZcuWKS0tTaNHj1ZmZqZCQkLUrFkzTZ48WeHh4ZKk8PBwzZ8/X2+88YZ69Oghq9WqBx54QFOmTFFAQMAN1TBu3DhNnDhRKSkpkqQWLVpo1KhRReu/+eYb9enTR/PmzVN8fLxq1aqlGTNmaOrUqfr73/+uqlWr6qWXXtITTzxR6uxu3boV/dvT01N33XWXnnnmGT333HM3dE4AAAAAAAAAAAAAAAAAgNKxOJnDGLjjZedeNJLrm5thJFeSCgOqGss2ddX1zD5mJliS5cT/jOTa6zY3kitJctjNxFp9jeRK0oUCM39V5OvpZiRXktzzc4xl2zxLN5LyzeLpsBnJlSS3nNNGcu0G3zOy8s3khniZyZWkApl7TZtitRv6RZvkNPeXqGccZp7gVneLkVxJ8nM3cwNaaPD1XOgwc87ubuZ+z3ZD5+xh8Jz3ns4zll032My1xDfvjJFcScp0DzKSG+pm5jsLSXK6exrJ/dlhJtekCh7mvqK22AuMZefKaiTXT+Y+12UWmBkXorLF3Od3i83MdSyvgrnPslZnoZHcAou5cUc8DZ3zc+t+NJIrSe/9KdZYNgAAAHA1B//8lOkSIClicrrpEsrdnfd/OAEAAAAAAAAAAAAAAAAAAG4CpiPHLSMuLk52+9VHjgsKCtKmTZvKtIZOnTrpyJEj19xmy5Yt8vW9eSPNZWRkqF27dtfcpn79+lqwYMFNywQAAAAAAAAAAAAAAAAA3DiaMHHLWLlypZzXmKfZza3sB26dNWuWCgquPQWRj4/PTc2sVKmSVq9efc1tvLwMzgkKAAAAAAAAAAAAAAAAALgimjBxy6hRo4bpElStWrVyz3R3d1fNmjXLPRcAAAAAAAAAAAAAAAAAcGNowgQAAAAAAAAAAAAAAAAA3NacdofpEnCHKvv5nQEAAAAAAAAAAAAAAAAAAH6HaMIEAAAAAAAAAAAAAAAAAABwAU2YAAAAAAAAAAAAAAAAAAAALqAJEwAAAAAAAAAAAAAAAAAAwAU0YQIAAAAAAAAAAAAAAAAAALjAw3QBAMzbcSLHSG50pVAjuZJkLXAYyw7MOWYktzCwmpFcSfIsuGAkN8fpaSRXkjzcrUZy3R1OI7mS5G4xk5t5odBMsKQqHub+nsUrJ8NMsNPcc8ziMPO7LjD4d0uVrGbO2Wkx9zHh4DmbkdwgL3cjuZIU7ONtLNtu6DVtdZj5PUtSiPOikdwfc83cG0hSJR8zz2+HzN1zB3mYyc6xm7uWmPqcYcnPNZIrSY38go1ln7WbeU37eFcwkitJ3k5DN/x2c9cSU3JsdmPZpu72A9wM/p4thp7bkrEH3Olu8PsSQ79q92PfmwmWZA+720iud26mkVxJcnqa+YzjZTPzHaQkWQrzjeRO72Tm+SVJJ86Zuw8Mq+hnLBsAAAAAroSRMAEAAAAAAAAAAAAAAAAAAFzASJgAAAAAAAAAAAAAAAAAgNua025uhhHc2RgJEwAAAAAAAAAAAAAAAAAAwAU0YQIAAAAAAAAAAAAAAAAAALiAJkwAAAAAAAAAAAAAAAAAAAAX0IQJAAAAAAAAAAAAAAAAAADgApowAQAAAAAAAAAAAAAAAAAAXEATJgAAAAAAAAAAAAAAAAAAgAtowkSprFu3Tj169FBsbKxiY2PVpUsXLV68uGh9q1atlJqaWuZ1nDlzRq+//rratm2rmJgYJSQkaNiwYTp48GCZZ//WyJEj9fLLL193u6NHj6p///5q3Lix7r//fk2ZMkV2u73EOVu3blVUVFSxn8aNG6t3797auXPnDZwBAAAAAAAAAAAAAAAAAMAVHqYLwO1j+fLlGj9+vEaMGKGmTZvK6XTqyy+/1IQJE3T69GmlpKRo+fLl8vLyKtM6Dh48qD59+qh69eoaOXKkIiMjlZGRoZkzZ6p79+6aP3++oqKiyrQGSbLb7XrjjTe0fPlyPf7449fctqCgQM8884wiIyO1ePFiHT58WCNHjpSXl5cGDRpUqtxly5YpLCxMDodD2dnZ+uCDD/TMM89ow4YNqly58o2cEgAAAAAAAAAAAAAAAHBbcjocpkvAHYqRMFFiCxcuVNeuXdW9e3dFRkaqVq1aeuKJJ5SYmKh58+ZJkoKDg+Xn51emdQwfPlxhYWGaO3euWrRoofDwcMXFxWnWrFkKDQ3VpEmTyjRfkvbv36+ePXtq9erVqlat2nW337hxo44fP67XX39d9erVU5s2bTRkyBClp6fLZrOVKjs4OFihoaGqUqWK6tWrp1GjRsnhcOijjz5y9XQAAAAAAAAAAAAAAAAAAC6gCRMl5ubmpq+//lrZ2dnFliclJWnJkiWSik9HnpqaWtSg+eCDD6pRo0YaMmSIMjMzNXz4cMXGxiohIUGrVq0qcQ3fffeddu3apeTkZFmt1mLrrFarpk2bptGjRxct279/vwYMGKD4+Hg1adJEgwYN0vHjx4vW9+7dWyNGjFC3bt0UFxen1atXl6iO//73v4qOjtY//vEPVa9e/brbb9++Xffcc48CAgKKljVr1kw5OTn6/vvvS5R5NZ6envL09LyhYwAAAAAAAAAAAAAAAAAASo8mTJRYUlKS9u7dqxYtWig5OVlpaWnavXu3KlSooMjIyCvus337dm3fvl3p6emaPn26Nm7cqEceeUTR0dFasWKFWrRooVdffVVnz54tUQ179uyRJMXGxl5xfb169RQRESFJOnbsmHr06CGr1ar09HTNmTNHWVlZevLJJ5WTk1O0z8qVK9WnTx8tWrRICQkJJaqjZ8+eGjNmjEJCQkq0/cmTJ1W1atViyy5NHf7rptDSys/P19///ndJUtu2bV0+DgAAAAAAAAAAAAAAAACg9DxMF4DbR9u2bbVkyRLNnz9fn3/+uTZv3ixJioiI0MSJE9WkSZPL9nE4HBo/frwCAgJUu3ZtRUdHy9PTU08//bQkKTExUUuXLtWhQ4cUFBR03RoujcL56xElr2bhwoXy9fXVG2+8UTRq5ttvv61WrVpp7dq16tWrlyQpOjpajz76aMkeBBfl5eVdVrOXl5ekXxopS+ORRx6RxWKR0+lUXl6enE6nXnrpJYWGht60egEAAAAAAAAAAAAAAAAA10cTJkolJiZGU6ZMkdPp1L59+7R582bNmzdPSUlJ+te//nXZ9iEhIcWaD318fBQWFlb036VtRAwODpYknTt3TpUqVbrmtvv27VODBg2KTVseEhKiyMhI/fDDD0XLatasWaLsG+Ht7S2bzVZs2aVz9vX1LdWx0tLSVKVKFUlSbm6uvvrqK7355ptyOp3q37//zSkYAAAAAAAAAAAAAAAAAHBdTEeOEjl58qTGjRunjIwMSZLFYlFUVJSSk5OVnp6u3Nxcbdu27bL9PD09L1vm5ub60+7SNOQ7d+684vp169Zp8ODBRSNEWiyWy7ax2+3F6vL29na5npKqWrWqTp06VWzZpf++1FBZUtWqVVPNmjVVs2ZN1a9fX3379tVjjz2mOXPm3LR6AQAAAAAAAAAAAAAAAADXRxMmSsRqtWrJkiVau3btZev8/f0l6bojU94MderUUePGjZWWlqaCgoJi6/Ly8pSWlqasrCx5e3urXr162r17d7ERKE+fPq1Dhw6pdu3aZV7rrzVt2lT/7//9P+Xk5BQt+/LLL+Xn56e77777pmQ4nc6bchwAAAAAAAAAAAAAAADgduO0O/i5BX7uRDRhokSCg4PVr18/TZ8+XdOmTdPevXt15MgRffrpp0pJSVF8fLzi4uLKpZaxY8fq8OHDSkxM1H/+8x8dOXJEX3zxhfr27atTp07ptddekyT17NlTOTk5Gjp0qL7//nvt3r1bL7zwgoKCgtSxY8cyrdFmsykzM7OoAbRNmzYKDQ3V4MGD9f333+vjjz/WtGnT1Ldv32LTpZfEmTNnlJmZqczMTJ04cULLli3T2rVr1alTp7I4FQAAAAAAAAAAAAAAAADAVXiYLgC3j8GDBysiIkJLly7VggULlJeXp7CwMHXo0EH9+/cvtzrq1q2rZcuWKS0tTaNHj1ZmZqZCQkLUrFkzTZ48WeHh4ZKk8PBwzZ8/X2+88YZ69Oghq9WqBx54QFOmTFFAQECZ1vjNN9+oT58+mjdvnuLj4+Xl5aV3331XY8aMUffu3RUYGKhevXrpueeeK/Wxu3XrVvRvT09P3XXXXXrmmWdcOhYAAAAAAAAAAAAAAAAAwHUWJ3MYA3e8TT9mGsmNruRrJFeSrO4WY9mBOceM5BYGVjOSK0meWT8ZyT1XsbaRXEnycDPzHDP41Fahw8wtxc82c8OZV/GwGct2y/vZTLDBW0eL3czjfbFiDSO5kmR1FhrJdbqZ+1ut/50z83sO8nI3kitJwT7mHm+7ode01WHu+mmxFxjJ/fFi6UbAv5kq+Zh5fpuccCTIw0x6jsPctcTU5wxLfq6RXEly+AUbyz5rDTGSG+hu5t5AknKcnkZyK9hzjORKktPDy0ju8TxzkxeZutu/y/vOnKYq19Drytfd3Oe6c2ZuxRR6bJuZYEn2sLuN5FoKzd1zOz29jeRabBeM5EqSpTDfSK7J7yxyDH4nF1bRz1g2AAAAbm0/pnQ3XQIk1Zmx1HQJ5Y7pyAEAAAAAAAAAAAAAAAAAAFzAdOS4ZcTFxclut191fVBQkDZt2lSmNXTq1ElHjhy55jZbtmyRr+/NG8ExIyND7dq1u+Y29evX14IFC25aJgAAAAAAAAAAAAAAAADgxtGEiVvGypUr5bzGdIhubmU/cOusWbNUUHDtOXF8fHxuamalSpW0evXqa27j5WVm+isAAAAAAAAAAAAAAAAAwNXRhIlbRo0aNUyXoGrVqpV7pru7u2rWrFnuuQAAAAAAAAAAAAAAAACAG0MTJgAAAAAAAAAAAAAAAADgtua0O0yXgDtU2c/vDAAAAAAAAAAAAAAAAAAA8DtEEyYAAAAAAAAAAAAAAAAAAIALaMIEAAAAAAAAAAAAAAAAAABwAU2YAAAAAAAAAAAAAAAAAAAALvAwXQAA8xpX9TOSm1vgNJIrSYE5x4xly+kwEmuxFxjJlaSsgFpGci3mnmJyt5jJzSkw8/ySJH9PM3/bUdWSYyRXkg7lmbl+SlJNNzO3cQ7fICO5kiSLmeeY3W7uYpJhM3MxqerIMpIrScHeZp5j/lZzf5/mYTN3HXN39zSSe6bQ3EfRSvlnjOTW8fIxkitJDs8KRnJN3n+65Z4zkhtgJPUXB9yrGsmN8DX3nuHwNveIWy1m3qOP5Zl7vwr1NXPOOfI3kitJfha7kdy7PPON5EqS5WK2kVynPdBIriTJbjMWbXM3c97+jotGciXJz9PM5+hDlZsYyZUkd4eZ62dFX3cjuZLkU3DeSK7J7yzO2s18xrHlmXmvkqQAg5+js85fMJIbUsHXSC4AAACAWx8jYQIAAAAAAAAAAAAAAAAAALiAJkwAAAAAAAAAAAAAAAAAAAAXMB05AAAAAAAAAAAAAAAAAOC25rA7TJeAOxQjYQIAAAAAAAAAAAAAAAAAALiAJkwAAAAAAAAAAAAAAAAAAAAX0IQJAAAAAAAAAAAAAAAAAADgApowAQAAAAAAAAAAAAAAAAAAXEATJgAAAAAAAAAAAAAAAAAAgAtowgQAAAAAAAAAAAAAAAAAAHABTZjlpFWrVoqKitKcOXOuuP7VV19VVFSUUlNTtXLlSkVFRd2U3NTUVLVq1eqmHKs0Dhw4oCFDhqh58+Zq0KCBWrVqpTFjxuj06dPlWlvv3r0VFRWl8ePHX3F9WlqaoqKi9PLLL0uStm7dqqioKB09erRM6/q1BQsWqHXr1oqJiVGPHj20Z8+e6+7z3nvvFe3TuXNnffXVV+VQKQAAAAAAAAAAAAAAAHBrcjoc/NwCP3cimjDLkaenp/75z39etrywsFAfffSRLBaLJKlDhw76/PPPb0pm3759tXz58ptyrJI6ffq0evbsKQ8PD82ePVsbN27U2LFj9fXXX6t3796y2WzlWpunp6c2btwop9N52br169cXPe6SFBsbq88//1xhYWFlXpckrVq1SlOmTNHgwYO1cuVK1axZU/369dOZM2euus/MmTOVmpqqF154QWvXrlVMTIyeffZZHTlypFxqBgAAAAAAAAAAAAAAAAD8gibMctS8eXPt2rVLJ06cKLb8q6++kq+vb1Hjn7e3t0JDQ29Kpp+fn4KDg2/KsUrqn//8pwoLCzV58mQ1aNBAd911lx588EFNmzZNP/30k/7zn/+Ua23x8fE6ffq0duzYUWz5gQMHdPDgQdWvX79omdVqVWhoqNzd3cu8LkmaNWuWnnzyST366KOqU6eOJk6cKB8fn6s2p164cEGzZ8/WsGHD1KlTJ0VEROiVV15ReHj4ZecHAAAAAAAAAAAAAAAAAChbNGGWo5iYGFWrVu2y0TDXr1+v9u3bF43I+NvpyDdv3qzOnTvr3nvvVfPmzfXyyy8rOzu7aP17772nNm3aFE37/c477xSN+vjrKb+PHj2qqKgobdiwQd26dVPDhg3VunXryxr+0tPT1apVK8XExCgxMVEzZswo1bThFotFubm52rp1a7HltWrV0ocffqhmzZpdtbZL59qwYUM9+uij2rlzp5YtW6b/+7//U+PGjfXSSy8pPz+/xLVIUmhoqOLi4q74uLds2VJ+fn5Fy347Hfnu3bvVq1cvxcbGqmnTpnr++ed1/Pjxou1Xr16tjh07qmHDhnrooYc0YcKEopE+rycrK0sHDx4sejwkycPDQ3Fxcdq2bdsV99m+fbsuXryojh07Fi1zd3fX2rVr9cc//rFEuQAAAAAAAAAAAAAAAACAm4MmzHLWvn37Ys2ANptNH3/8cbGmul87c+aMUlJS1KVLF61fv14zZszQtm3b9Prrr0uSNm3apFmzZmnMmDH66KOPNHToUP3tb3/T2rVrr1rDpEmTNGDAAK1evVrNmzfXK6+8UjSV9YIFC/Tmm2/queee05o1axQfH6933nmnVOfYsWNHVatWTU899ZQee+wx/fWvf9XHH3+snJwc1alTp1jT42+NHTtWQ4cO1erVq+Xt7a3k5GRt2LBBs2bN0qRJk7Rx40YtW7asVPVIvzzuv52SfMOGDVd93CXJ4XCof//+atq0qdauXau5c+fq+PHjGjFihCTp+++/16hRo/T8889r48aNmjhxotasWaN33323RDWdPHlSki6b+rxy5cqXjZZ6ycGDBxUYGKgffvhBPXv2VPPmzdW7d299/fXXJcoEAAAAAAAAAAAAAAAAANw8NGGWs/bt2xebknzLli0KCgoqNiX2r2VkZMhms6latWq666671KRJE82aNUu9e/eWJB0+fFheXl6qXr26qlWrpg4dOmju3Llq2rTpVWt4+umn1bp1a9WuXVt//vOf5XA4tGvXLkm/jKrZp08fde3aVZGRkXr22WfVpk2bUp1jxYoVtXLlSqWkpMjhcGju3LkaOHCgHnjgges2dD799NO6//77Vbt2bf3xj39Udna2Ro8eraioKD388MOqX7++9u3bV6p6JKlt27bKysoqmrJ73759OnHihBISEq66z/nz53X27FlVrlxZ1atX1z333KPp06dr8ODBkn4ZvdNisRQ99g899JDee+89tW/fvkQ1Xbx4UdIvU6D/mpeX11VH+8zJyVFeXp5effVVPf3005o9e7YiIiL01FNPaf/+/SXKBQAAAAAAAAAAAAAAAADcHDRhlrMGDRooPDy8aDTM9evX65FHHrnq9tHR0XrkkUc0YMAAtWzZUiNGjNCBAwdUp04dSVKnTp0UFBSkhx9+WJ06ddLkyZPl5uamatWqXfWYtWvXLvp3hQoVJEkFBQU6e/asjh07pkaNGhXbvkmTJqU+z8DAQD3//PNat26dvvjiC7355pu699579fbbb2vhwoVX3S8yMrLo3z4+PpKk8PDwomVeXl4lnu7710JCQtS0adNij/sf/vCHyxogf3sO/fr107hx43T//ffrpZde0tdff627775bkvTQQw8pNjZWXbp0Udu2bTVmzBhlZ2crIiKiRDV5e3tL0mXnk5+fX3Tuv+Xp6am8vDyNGDFCDz/8sBo0aKCxY8eqZs2a+uCDD0qUCwAAAAAAAAAAAAAAAAC4OWjCNODSlOT5+fn65JNP1KFDh2tuP3XqVG3YsEGJiYk6ffq0hgwZor59+0qSgoODtWbNGi1cuFBt2rTRjh071LNnT82YMeOqx7tS46HT6ZSHh0fRv2/E7NmztWHDhqL/DgkJUceOHZWenq57771Xmzdvvuq+l2r4NTe3m/M07dChgzZu3CiHw6ENGzZc93GXpKFDh2rTpk0aNGiQCgoK9Nprr6lz586y2Wzy8vLSvHnztGrVKnXp0kX79+9XUlJS0XTl13OpUfbUqVPFlp86dUpVq1a94j6XlkdFRRUts1gsql27to4ePVqiXAAAAAAAAAAAAAAAAADAzUETpgGXpiRfvny5wsPDi41M+Vs7d+7UxIkTVatWLSUmJiotLU0TJ07U1q1blZWVpTVr1mjRokVq0qSJBg0apKVLl6pbt25av359qeuqUKGC7rrrLu3cubPY8t27d5fqOLt27dLMmTNVWFhYbLnFYpGfn59CQkJKXdvN8Ic//EFnzpzR4sWLlZ2drfvvv/+a2//0008aPXq0QkJC1LNnT7399tt69913tX//fn3//ffavHmzZsyYofr16ys5OVnz5s3ToEGDSvzYBwcHKzIyUlu3bi1aVlhYqO3btysuLu6K+8TFxclisRT7HTmdTv3444+qWbNmiXIBAAAAAAAAAAAAAACA3xun3cHPLfBzJ7p82EGUuejoaNWsWVNvvvmm+vfvf81t/f39tXDhQnl6eqp79+7Ky8vThx9+qIiICAUFBSk/P1+TJ0+Wn5+f4uLidPLkSf33v/9V06ZNXaotKSlJkydPVu3atdW4cWN9+umn2rBhg8LCwkp8jIEDB6pXr1565plnlJSUpMjISJ06dUobN27Uzp07SzxS5M0WHBys+Ph4TZ06VR07drziqJu/VrFiRf3jH/9QXl6ekpOT5ebmphUrVigwMFC1atXSrl279M4778jf31+tW7fWuXPn9Omnnyo2NrbENfXt21cTJkxQzZo11bBhQ6WlpSkvL09du3Yt2iYzM1O+vr7y8/NTWFiYunTpovHjx8vHx0c1a9bU/PnzdfToUfXq1cvlxwYAAAAAAAAAAAAAAAAAUHo0YRrSvn17/e1vf7vulNh16tRRamqqZsyYoYULF8rNzU3NmjXT7Nmz5ebmpu7duys7O1szZ87UiRMnFBgYqLZt22ro0KEu1dWzZ09lZ2dr2rRpOnv2rO677z49/vjj2rFjR4mPER0drWXLlmnmzJn6y1/+orNnz8rPz09NmzbV4sWLVbduXZdquxnat2+vLVu2qGPHjtfdNjg4WO+++66mTp2q7t27y263q1GjRpozZ478/f31wAMPaMKECXr//fc1bdo0eXt7KyEhQS+//HKJ6+nevbvOnz+v6dOn69y5c2rQoIHmzJmj4ODgom0efPBBpaSk6Pnnn5ckvfbaa5oxY4ZGjRql7Oxs1a9fX++//75q1apV+gcEAAAAAAAAAAAAAAAAAOAyi9PpdJouAreOzz77THXr1i028uUrr7yiw4cPKz093WBlKEvnci4Yyc0tMHf5qZJ33Fi2nGaGXrZXqGIkV5KyHZ5Gci0Wi5FcSfLxMJOdU2BuaG9/Tzcjudb8bCO5knSowM9Ydk03M+ft8A0ykitJsph5juXZzb1f/Wwz85qu6jhnJFeSMt3NPMf8rWaeX5LkU5hrLNvpbuY9+kyhub8HrJR/ykiu0+pjJFeSHF4VjORa7AVGciXJ7eI5Y9mmHFSIkdwIZRnJlSSHT0Vj2RctViO5Z/LsRnIlKdTXzLW7wOC9mJ+bmcfbUphvJFeSLBfNfM5w+gQayZUk2W3Gos+4mznvYF00kitJ+Z5mPkdnXig0kitJ7oa+n6ro7W4kV5J8Cs4byXV6eBnJlaSzdjPvkzaD75MBBj9HmzrtkAq+ZoIBAABQYnuf7mS6BEiKnrPWdAnlztwnJNyS1qxZo2effVY7d+7UsWPHtHr1aq1du1aPPfaY6dIAAAAAAAAAAAAAAAAAALilMB05innllVc0adIkDRw4UD///LNq1KihESNGqHPnzlq/fr1Gjhx5zf379OmjF198sczrHDt2rFatWnXNbd566y21aNGizGu5klu9PgAAAAAAAAAAAAAAAADAjaMJE8VUrFhRkyZNuuK6hIQErV69+pr7BwQElEFVl0tJSdFTTz11zW0qV65cLrVcya1eHwAAAAAAAAAAAAAAAADgxtGEiRLz8/OTn5+f6TIkScHBwQoODjZdxlXd6vUBAAAAAAAAAAAAAAAAAG4cTZgAAAAAAAAAAAAAAAAAgNua0+40XQLuUG6mCwAAAAAAAAAAAAAAAAAAALgd0YQJAAAAAAAAAAAAAAAAAADgApowAQAAAAAAAAAAAAAAAAAAXEATJgAAAAAAAAAAAAAAAAAAgAs8TBcAwDyLxWIkN9DLTK4k2a1VjWXnONyN5NodTiO5kuRvNXPO2fl2I7mSdKHAzOPt7W7udeXpsBnJzfEIMJIrSRXczL2unB6BRnLzHOaeYxcLHUZyg93yjeRKksPT20yuR4iRXEkKkpnnWIHB90k5zTy3TQr2NHfOltw8I7k/+1YxkitJeflmnt9VLpwwkitJBzyrG8mtlX/QSK4kVQ0x8xzLyKtkJFeSfAz+bbG/xcxnjRr5R43kSlK2V00juebuPs19fvf38DKSK0mFgXcZyfW4eMZIriTlewcZy/a0m3mPtuRmG8mVpFz5GMn18TD3nnHmopn3jIreZq5hkpTt5m8k1+DXNPL3NPOOVehu7qQvFprLNvWZ8ouDWUZyJen+CHPf1QAAAAC4PkbCBAAAAAAAAAAAAAAAAAAAcAEjYQIAAAAAAAAAAAAAAAAAbmsO+503+xhuDYyECQAAAAAAAAAAAAAAAAAA4AKaMAEAAAAAAAAAAAAAAAAAAFxAEyYAAAAAAAAAAAAAAAAAAIALaMIEAAAAAAAAAAAAAAAAAABwAU2YAAAAAAAAAAAAAAAAAAAALqAJEwAAAAAAAAAAAAAAAAAAwAU0YZaTVq1aKSoqSnPmzLni+ldffVVRUVFKTU3VypUrFRUVdVNyU1NT1apVq5tyrNI4cOCAhgwZoubNm6tBgwZq1aqVxowZo9OnT5drbb1791ZUVJTGjx9/xfVpaWmKiorSyy+/LEnaunWroqKidPTo0TKt69cWLFig1q1bKyYmRj169NCePXuuuu2l58aVfvr06VNuNQMAAAAAAAAAAAAAAAAAaMIsV56envrnP/952fLCwkJ99NFHslgskqQOHTro888/vymZffv21fLly2/KsUrq9OnT6tmzpzw8PDR79mxt3LhRY8eO1ddff63evXvLZrOVa22enp7auHGjnE7nZevWr19f9LhLUmxsrD7//HOFhYWVeV2StGrVKk2ZMkWDBw/WypUrVbNmTfXr109nzpy54vaXnhu//pk8ebLc3NyUlJRULjUDAAAAAAAAAAAAAAAAtxqnw8nPLfBzJ6IJsxw1b95cu3bt0okTJ4ot/+qrr+Tr61vU+Oft7a3Q0NCbkunn56fg4OCbcqyS+uc//6nCwkJNnjxZDRo00F133aUHH3xQ06ZN008//aT//Oc/5VpbfHy8Tp8+rR07dhRbfuDAAR08eFD169cvWma1WhUaGip3d/cyr0uSZs2apSeffFKPPvqo6tSpo4kTJ8rHx+eqzamXnhuXfqxWq6ZMmaJnnnlGDz30ULnUDAAAAAAAAAAAAAAAAAD4BU2Y5SgmJkbVqlW7bDTM9evXq3379kUjMv52OvLNmzerc+fOuvfee9W8eXO9/PLLys7OLlr/3nvvqU2bNkXTfr/zzjtFoz7+esrvo0ePKioqShs2bFC3bt3UsGFDtW7d+rKGv/T0dLVq1UoxMTFKTEzUjBkzSjVtuMViUW5urrZu3Vpsea1atfThhx+qWbNmV63t0rk2bNhQjz76qHbu3Klly5bp//7v/9S4cWO99NJLys/PL3EtkhQaGqq4uLgrPu4tW7aUn59f0bLfTke+e/du9erVS7GxsWratKmef/55HT9+vGj71atXq2PHjmrYsKEeeughTZgwoWikz+vJysrSwYMHix4PSfLw8FBcXJy2bdtWomPMmDFDXl5eGjhwYIm2BwAAAAAAAAAAAAAAAADcPDRhlrP27dsXawa02Wz6+OOP1bFjxytuf+bMGaWkpKhLly5av369ZsyYoW3btun111+XJG3atEmzZs3SmDFj9NFHH2no0KH629/+prVr1161hkmTJmnAgAFavXq1mjdvrldeeUVHjhyRJC1YsEBvvvmmnnvuOa1Zs0bx8fF65513SnWOHTt2VLVq1fTUU0/pscce01//+ld9/PHHysnJUZ06dYo1Pf7W2LFjNXToUK1evVre3t5KTk7Whg0bNGvWLE2aNEkbN27UsmXLSlWP9Mvj/tspyTds2HDVx12SHA6H+vfvr6ZNm2rt2rWaO3eujh8/rhEjRkiSvv/+e40aNUrPP/+8Nm7cqIkTJ2rNmjV69913S1TTyZMnJemyqc8rV6582WipV5KRkaFFixZp4MCB8vHxKVEmAAAAAAAAAAAAAAAAAODmoQmznLVv377YlORbtmxRUFBQsSmxfy0jI0M2m03VqlXTXXfdpSZNmmjWrFnq3bu3JOnw4cPy8vJS9erVVa1aNXXo0EFz585V06ZNr1rD008/rdatW6t27dr685//LIfDoV27dkn6ZVTNPn36qGvXroqMjNSzzz6rNm3alOocK1asqJUrVyolJUUOh0Nz587VwIED9cADD1y3ofPpp5/W/fffr9q1a+uPf/yjsrOzNXr0aEVFRenhhx9W/fr1tW/fvlLVI0lt27ZVVlZW0ZTk+/bt04kTJ5SQkHDVfc6fP6+zZ8+qcuXKql69uu655x5Nnz5dgwcPlvTL6J0Wi6XosX/ooYf03nvvqX379iWq6eLFi5J+mQL917y8vEo02ufChQtVqVIlderUqUR5AAAAAAAAAAAAAAAAAICbiybMctagQQOFh4cXjYa5fv16PfLII1fdPjo6Wo888ogGDBigli1basSIETpw4IDq1KkjSerUqZOCgoL08MMPq1OnTpo8ebLc3NxUrVq1qx6zdu3aRf+uUKGCJKmgoEBnz57VsWPH1KhRo2LbN2nSpNTnGRgYqOeff17r1q3TF198oTfffFP33nuv3n77bS1cuPCq+0VGRhb9+9LojuHh4UXLvLy8Sjzd96+FhISoadOmxR73P/zhD5c1QP72HPr166dx48bp/vvv10svvaSvv/5ad999tyTpoYceUmxsrLp06aK2bdtqzJgxys7OVkRERIlq8vb2lqTLzic/P79EI1uuWbNGnTt3lqenZ4nyAAAAAAAAAAAAAAAAAAA3F02YBlyakjw/P1+ffPKJOnTocM3tp06dqg0bNigxMVGnT5/WkCFD1LdvX0lScHCw1qxZo4ULF6pNmzbasWOHevbsqRkzZlz1eFdqPHQ6nfLw8Cj6942YPXu2NmzYUPTfISEh6tixo9LT03Xvvfdq8+bNV933Ug2/5uZ2c56mHTp00MaNG+VwOLRhw4brPu6SNHToUG3atEmDBg1SQUGBXnvtNXXu3Fk2m01eXl6aN2+eVq1apS5dumj//v1KSkoqmq78ei41yp46darY8lOnTqlq1arX3Pfbb7/ViRMnrjmdOgAAAAAAAAAAAAAAAACgbNGEacClKcmXL1+u8PDwYiNT/tbOnTs1ceJE1apVS4mJiUpLS9PEiRO1detWZWVlac2aNVq0aJGaNGmiQYMGaenSperWrZvWr19f6roqVKigu+66Szt37iy2fPfu3aU6zq5duzRz5kwVFhYWW26xWOTn56eQkJBS13Yz/OEPf9CZM2e0ePFiZWdn6/7777/m9j/99JNGjx6tkJAQ9ezZU2+//bbeffdd7d+/X99//702b96sGTNmqH79+kpOTta8efM0aNCgEj/2wcHBioyM1NatW4uWFRYWavv27YqLi7vmvjt27FBoaOg1nzsAAAAAAAAAAAAAAAAAgLJ1+bCDKHPR0dGqWbOm3nzzTfXv3/+a2/r7+2vhwoXy9PRU9+7dlZeXpw8//FAREREKCgpSfn6+Jk+eLD8/P8XFxenkyZP673//q6ZNm7pUW1JSkiZPnqzatWurcePG+vTTT7VhwwaFhYWV+BgDBw5Ur1699MwzzygpKUmRkZE6deqUNm7cqJ07d5Z4pMibLTg4WPHx8Zo6dao6dux4xVE3f61ixYr6xz/+oby8PCUnJ8vNzU0rVqxQYGCgatWqpV27dumdd96Rv7+/WrdurXPnzunTTz9VbGxsiWvq27evJkyYoJo1a6phw4ZKS0tTXl6eunbtWrRNZmamfH195efnV7Ts+++/V7169Ur/IAAAAAAAAAAAAAAAAAC/Qw77jc3+C7iKJkxD2rdvr7/97W/XnRK7Tp06Sk1N1YwZM7Rw4UK5ubmpWbNmmj17ttzc3NS9e3dlZ2dr5syZOnHihAIDA9W2bVsNHTrUpbp69uyp7OxsTZs2TWfPntV9992nxx9/XDt27CjxMaKjo7Vs2TLNnDlTf/nLX3T27Fn5+fmpadOmWrx4serWretSbTdD+/bttWXLlhJN4x0cHKx3331XU6dOVffu3WW329WoUSPNmTNH/v7+euCBBzRhwgS9//77mjZtmry9vZWQkKCXX365xPV0795d58+f1/Tp03Xu3Dk1aNBAc+bMUXBwcNE2Dz74oFJSUvT8888XLTt9+rQqVqxYqnMHAAAAAAAAAAAAAAAAANxcFqfTSQswinz22WeqW7dusZEvX3nlFR0+fFjp6ekGK0NZys69aCTX3WIkVpLk6Sw0lp3jcDeSa3eYu9z7W82cc3a+3UiuZO75bTX4wvJRgZHcXKenkVxJshl8XQV5OIzkXnSaeT1L0sVCM493sFu+kVxJyrV4G8n19TB3LXHITHaBwdezT8F5Y9lODy8zwRY3M7mS3M8dNZKbHVDTSK4k5Rm6fla5cNhIriQd8KxuJLdW/kEjuZJ0IaSOkdzsPHP33D6e5q4l/m5mztvUNUwydx0z+NWBTN0dmHp+SZLdzcznK4+LZ4zkSlK+d5CxbJuh0TkCck8YyZWkLJ+qRnJN/l+QMxfNvKarBxj8vsTQc9vN4JuGl6Hv5AoNfpY19T2NJAV7mvlebEemzUiuJN0fEWIsGwAA4Hayq3t70yVA0r1LN5guodyZ+7Yat6Q1a9bo2Wef1c6dO3Xs2DGtXr1aa9eu1WOPPWa6NAAAAAAAAAAAAAAAAAAAbilMR45iXnnlFU2aNEkDBw7Uzz//rBo1amjEiBHq3Lmz1q9fr5EjR15z/z59+ujFF18s8zrHjh2rVatWXXObt956Sy1atCjzWq7kVq8PAAAAAAAAAAAAAAAAAHDjaMJEMRUrVtSkSZOuuC4hIUGrV6++5v4BAQFlUNXlUlJS9NRTT11zm8qVK5dLLVdyq9cHAAAAAAAAAAAAAAAAALhxNGGixPz8/OTn52e6DElScHCwgoODTZdxVbd6fQAAAAAAAAAAAAAAAACAG0cTJgAAAAAAAAAAAAAAAADgtua0O0yXgDuUm+kCAAAAAAAAAAAAAAAAAAAAbkc0YQIAAAAAAAAAAAAAAAAAALiAJkwAAAAAAAAAAAAAAAAAAAAX0IQJAAAAAAAAAAAAAAAAAADgAg/TBQAwz9tpMxPsNBMrSTlOT2PZuQUOI7lVHeeM5EqS083fSK6/1ctIriSdzCk0khvoZe7vKyr8fNhIrm9ILSO5kuTuZu7xthReNJLr5WXm9SxJ3u5m3jgcFl8juZKU9XOBkdwzFiOxkqSqfmY+ouQXmnl/liSnh7nXldXdzHXMw5ZjJFeS9rnfZSS3msHXVSUPM9eSi0ERRnIlKcRu5j3jgCXCSK4kRZwzcy/m5RNoJFeSzjkqGMv+2eluJDcgsJqRXEny9TDznnE+324kV5Jshq4lPxn6PClJflYz5xweEGQkV5KsDkPfi0nyyj9vJPeoR2UjuZIUZugrOeuJ78wESwrNOWckNy/wISO5kmR1N3Pza3eY+8LZVPLFQnPnHGQ1Fi2386eN5MYr20iuJOXnmPm+xMvf3P0+AAAAcDthJEwAAAAAAAAAAAAAAAAAAAAX0IQJAAAAAAAAAAAAAAAAAADgAqYjBwAAAAAAAAAAAAAAAADc1px2p+kScIdiJEwAAAAAAAAAAAAAAAAAAAAX0IQJAAAAAAAAAAAAAAAAAADgApowAQAAAAAAAAAAAAAAAAAAXEATJgAAAAAAAAAAAAAAAAAAgAtowgQAAAAAAAAAAAAAAAAAAHABTZgAAAAAAAAAAAAAAAAAAAAuoAkT5WbdunXq0aOHYmNjFRsbqy5dumjx4sVF61u1aqXU1NQyr+PMmTN6/fXX1bZtW8XExCghIUHDhg3TwYMHS3WcCxcuaMGCBaXa5/Dhw3r22WcVFxenuLg4vfjiizp58mSpjvFrI0eO1Msvv+zy/gAAAAAAAAAAAAAAAAAA13mYLgB3huXLl2v8+PEaMWKEmjZtKqfTqS+//FITJkzQ6dOnlZKSouXLl8vLy6tM6zh48KD69Omj6tWra+TIkYqMjFRGRoZmzpyp7t27a/78+YqKiirRsd5//32tXLlSTzzxRIm2z8/PV2JioqKiorRo0SIVFhZqwoQJ6t+/v1avXi2LxVLi87Db7XrjjTe0fPlyPf744yXeDwAAAAAAAAAAAAAAAPg9ctidpkvAHYomTJSLhQsXqmvXrurevXvRslq1aunkyZOaN2+eUlJSFBwcXOZ1DB8+XGFhYZo7d66sVqskKTw8XLNmzdLjjz+uSZMmac6cOSU6ltNZugv38ePH1bBhQ40ePbroXBMTEzVw4ECdPXu2xOe/f/9+/eUvf9GRI0dUrVq1UtUAAAAAAAAAAAAAAAAAALh5mI4c5cLNzU1ff/21srOziy1PSkrSkiVLJBWfjjw1NVWJiYmaN2+eHnzwQTVq1EhDhgxRZmamhg8frtjYWCUkJGjVqlUlruG7777Trl27lJycXNSAeYnVatW0adM0evToomWbNm3Sn/70J8XGxqphw4bq2rWrvvjii6L6ZsyYoWPHjikqKkpHjx69bn5kZKTeeuutombLo0ePauHChbrnnnsUFBRU4vP473//q+joaP3jH/9Q9erVS7wfAAAAAAAAAAAAAAAAAODmYiRMlIukpCQNHjxYLVq0UHx8vOLi4tSsWTM1bNhQAQEBV9xn+/btCggIUHp6uo4cOaKBAwdqy5YtGjBggAYMGKA5c+bo1VdfVcuWLUvUxLhnzx5JUmxs7BXX16tXr+jf3377rQYOHKhhw4ZpypQpys3N1bRp0zR06FD9+9//Vt++fXXhwgWtX79ey5cvL/Uonn379tWWLVsUGBio9PT0Uk1F3rNnz1JlAQAAAAAAAAAAAAAAAADKBiNholy0bdtWS5Ys0cMPP6w9e/Zo6tSp6tatm9q1a6cdO3ZccR+Hw6Hx48erdu3aatmypaKjo1WrVi09/fTTqlWrlhITE2Wz2XTo0KES1XBpFM6rNX3+mru7u0aNGqW+ffsqPDxcd999t/r06aOsrCxlZWXJz89Pvr6+cnd3V2hoqNzd3Uv+YEgaNmyYli5dqsaNGysxMVEnTpwo1f4AAAAAAAAAAAAAAAAAAPMYCRPlJiYmRlOmTJHT6dS+ffu0efNmzZs3T0lJSfrXv/512fYhISHFGiZ9fHwUFhZW9N9eXl6SpPz8/BLlXxqt8ty5c6pUqdI1t42OjlZgYKBmz56tAwcO6ODBg9q7d68kyW63lyjveseXpGnTpqlly5ZasWKFUlJSbvi4AAAAAAAAAAAAAAAAAIDyw0iYKHMnT57UuHHjlJGRIUmyWCyKiopScnKy0tPTlZubq23btl22n6en52XL3Nxcf8pemoZ8586dV1y/bt06DR48WHl5edq2bZvatm2rXbt2qV69eho4cKCmTJnicrYkHTt2TBs3biy2zMfHR9WrV9epU6du6NgAAAAAAAAAAAAAAAAAgPLHSJgoc1arVUuWLFHVqlWVlJRUbJ2/v78kXXdkypuhTp06aty4sdLS0pSQkFCsyTMvL09paWmqWLGivL299d577yk+Pl4zZswo2mb+/PmSJKfTKemXZtLS2Lt3rwYNGqR//etfqlGjhiTp559/1oEDB9SpU6cbPT0AAAAAAAAAAAAAAADgjuW0O0yXgDsUI2GizAUHB6tfv36aPn26pk2bpr179+rIkSP69NNPlZKSovj4eMXFxZVLLWPHjtXhw4eVmJio//znPzpy5Ii++OIL9e3bV6dOndJrr70mSQoLC9MPP/yg7du36+jRo1qxYoXeeustSZLNZpMk+fr6Kjs7WwcOHFBBQcF1s1u0aKGoqCgNHz5c3333nb799ls9//zzCgoKUpcuXcrsnAEAAAAAAAAAAAAAAAAAZYORMFEuBg8erIiICC1dulQLFixQXl6ewsLC1KFDB/Xv37/c6qhbt66WLVumtLQ0jR49WpmZmQoJCVGzZs00efJkhYeHS5IGDRqk06dPa8CAAZJ+GUVz4sSJGjZsmHbv3q3atWvr4Ycf1tKlS9WpUyd98MEHuvfee6+ZbbVa9e6772ry5Ml65plnZLPZ9OCDD2rSpElFI4ICAAAAAAAAAAAAAAAAAG4fFueluZUB3LHyc7JNl1Ducpye19+ojOQWmBn+uqrjnJFcSXJ6mWk0trl7GcmVpJM5hUZyA73MDXId8vNPRnILQmoZyZWkfKe5x9unMNdIrt3Q61mSLIZuW50Wi5FcSTr68/VH2y4LBk9ZVf3M/J3YBUPvz5JkdTf3gFvdzVzHPGw5RnIl6ceLViO51fzN/Q2kj9NmJNfkvViB3cx7xpk8u5FcSYooOG4k1+ETaCRXks65VTCWbTH0ZhngZubeQJIcHmZe0+fzzb2ubIauJSdyzP2e/azuRnLDA8x9T2N1mHmflCRL3nkjucdk7tod5mvm/tN64jsjuZLkyDlnJDev7kNGciXJ0OVTdoe5/93laehzXY7NW0z6AAEAAElEQVTN3GfZIDMfrSRJ7udPGcl1u2ju/6UUVoo0kuvlb+49AwAAwBXbO7Q2XQIkxa3/xHQJ5Y7pyAEAAAAAAAAAAAAAAAAAAFzAdOT4XYiLi5PdfvWREYKCgrRp06Yyy+/UqZOOHDlyzW22bNkiX1/fMj0GAAAAAAAAAAAAAAAAAKD80ISJ34WVK1fKeY0pSt3cynbQ11mzZqmg4NpTRfn4+JT5MQAAAAAAAAAAAAAAAAAA5YcmTPwu1KhRw2h+tWrVboljAAAAAAAAAAAAAAAAAADKD02YAAAAAAAAAAAAAAAAAIDbmsNx9Vl0gbJUtnM0AwAAAAAAAAAAAAAAAAAA/E7RhAkAAAAAAAAAAAAAAAAAAOACmjABAAAAAAAAAAAAAAAAAABcQBMmAAAAAAAAAAAAAAAAAACACzxMFwDAvFynp5FcT3eLkVxJ8nAai1ZVtwtGcs+4BxnJlSSrzPyu/ez5RnIlKULnjOTaPUON5ErS187qRnLvsbgbyZUknwunjWUfU6CR3AA3h5FcSfL1NPP3Q4UOc28akSe+NJLriGhsJFeSCi1m7kuCLp40kitJuf5hxrJtdjOvaXeLub8HrKtMI7mWc3lGciWpMKSWkVyvvGwjuZLkXWgzkuvvYTWSK0l5fjWM5Lq7mftcF3T+lLHs896VjOTa3b2M5EqS589m3it9/KsYyZWkig4z17FqtoNGciVJhWa+Li70MvN5UpKcHt7Gss94mvmuJszMLbckye3CWSO5tmoNjeSaZDV4L2bqdeX0MPc+WWjoq4PQi8fNBEvK9TR37fb2NXP9zDD43Wuow8xnnGNj+hvJlaS7Rv/dWDYAAABQWoyECQAAAAAAAAAAAAAAAAAA4AKaMAEAAAAAAAAAAAAAAAAAAFzAdOQAAAAAAAAAAAAAAAAAgNua0+40XQLuUIyECQAAAAAAAAAAAAAAAAAA4AKaMAEAAAAAAAAAAAAAAAAAAFxAEyYAAAAAAAAAAAAAAAAAAIALaMIEAAAAAAAAAAAAAAAAAABwAU2YAAAAAAAAAAAAAAAAAAAALqAJE+Vm3bp16tGjh2JjYxUbG6suXbpo8eLFRetbtWql1NTUMq/jzJkzev3119W2bVvFxMQoISFBw4YN08GDB0t1nAsXLmjBggWl2ufw4cN69tlnFRcXp7i4OL344os6efJkqY5x4sQJDRkyRA888ICaNm2qZ555Rv/73/9KdQwAAAAAAAAAAAAAAAAAwI3zMF0A7gzLly/X+PHjNWLECDVt2lROp1NffvmlJkyYoNOnTyslJUXLly+Xl5dXmdZx8OBB9enTR9WrV9fIkSMVGRmpjIwMzZw5U927d9f8+fMVFRVVomO9//77WrlypZ544okSbZ+fn6/ExERFRUVp0aJFKiws1IQJE9S/f3+tXr1aFovlusew2WxKTk5WcHCw/v73v8vLy0vvvPOOnnrqKf3jH/9QcHBwiWoBAAAAAAAAAAAAAAAAfk8cdofpEnCHogkT5WLhwoXq2rWrunfvXrSsVq1aOnnypObNm6eUlJRyaSAcPny4wsLCNHfuXFmtVklSeHi4Zs2apccff1yTJk3SnDlzSnQsp9NZquzjx4+rYcOGGj16dNG5JiYmauDAgTp79myJzn/79u3at2+fPvvsM1WpUkWS9Prrr+u+++7Tpk2b1LVr11LVBAAAAAAAAAAAAAAAAABwHdORo1y4ubnp66+/VnZ2drHlSUlJWrJkiaTi05GnpqYqMTFR8+bN04MPPqhGjRppyJAhyszM1PDhwxUbG6uEhAStWrWqxDV899132rVrl5KTk4saMC+xWq2aNm2aRo8eXbRs06ZN+tOf/qTY2Fg1bNhQXbt21RdffFFU34wZM3Ts2DFFRUXp6NGj182PjIzUW2+9VdRsefToUS1cuFD33HOPgoKCSnQOdevWVVpaWlED5iVOp/OyxxYAAAAAAAAAAAAAAAAAULZowkS5SEpK0t69e9WiRQslJycrLS1Nu3fvVoUKFRQZGXnFfbZv367t27crPT1d06dP18aNG/XII48oOjpaK1asUIsWLfTqq6/q7NmzJaphz549kqTY2Ngrrq9Xr54iIiIkSd9++60GDhyohx9+WGvXrtWyZcsUEhKioUOHymazqW/fvurbt6+qVq2qzz//XGFhYaV6PPr27avWrVvr22+/1YQJE0o0FbkkhYaGKiEhodiyefPmKT8/Xw888ECpagAAAAAAAAAAAAAAAAAA3BiaMFEu2rZtqyVLlujhhx/Wnj17NHXqVHXr1k3t2rXTjh07rriPw+HQ+PHjVbt2bbVs2VLR0dGqVauWnn76adWqVUuJiYmy2Ww6dOhQiWq4NFJkQEDAdbd1d3fXqFGj1LdvX4WHh+vuu+9Wnz59lJWVpaysLPn5+cnX11fu7u4KDQ2Vu7t7yR8MScOGDdPSpUvVuHFjJSYm6sSJE6Xa/5KPPvpI06ZNU+/evXX33Xe7dAwAAAAAAAAAAAAAAAAAgGs8TBeAO0dMTIymTJkip9Opffv2afPmzZo3b56SkpL0r3/967LtQ0JCijVM+vj4FBtx0svLS5KUn59fovxL04CfO3dOlSpVuua20dHRCgwM1OzZs3XgwAEdPHhQe/fulSTZ7fYS5V3v+JI0bdo0tWzZUitWrFBKSkqpjrFo0SKNGzdOHTp00F/+8pcbrgkAAAAAAAAAAAAAAAAAUDqMhIkyd/LkSY0bN04ZGRmSJIvFoqioKCUnJys9PV25ubnatm3bZft5enpetszNzfWn7KVpyHfu3HnF9evWrdPgwYOVl5enbdu2qW3bttq1a5fq1aungQMHasqUKS5nS9KxY8e0cePGYst8fHxUvXp1nTp1qlTHeuONN/Taa6+pV69emjJlyg09LgAAAAAAAAAAAAAAAAAA19C5hTJntVq1ZMkSrV279rJ1/v7+knTdkSlvhjp16qhx48ZKS0tTQUFBsXV5eXlKS0tTVlaWvL299d577yk+Pl4zZsxQYmKiHnjggaIpw51Op6RfmklLY+/evRo0aJAOHz5ctOznn3/WgQMHVLt27RIfZ8qUKZo9e7aGDx+uUaNGlboOAAAAAAAAAAAAAAAAAMDNwXTkKHPBwcHq16+fpk+frpycHLVr107+/v768ccfNXPmTMXHxysuLq5cahk7dqx69+6txMREDRgwQBERETpy5IhmzJihU6dOafr06ZKksLAwffzxx9q+fbuqVq2qrVu36q233pIk2Ww2SZKvr6+ys7N14MABVa9e/Yojd/5aixYtFBUVpeHDh+uVV16R0+nUlClTFBQUpC5dupSo/q1bt+rdd99V79691alTJ2VmZhat8/X1lZ+fnwuPCgAAAAAAAAAAAAAAAHB7c9qdpkvAHYomTJSLwYMHKyIiQkuXLtWCBQuUl5ensLAwdejQQf379y+3OurWratly5YpLS1No0ePVmZmpkJCQtSsWTNNnjxZ4eHhkqRBgwbp9OnTGjBggKRfRtGcOHGihg0bpt27d6t27dp6+OGHtXTpUnXq1EkffPCB7r333mtmW61Wvfvuu5o8ebKeeeYZ2Ww2Pfjgg5o0aVLRiKDX849//EOSNH/+fM2fP7/YupSUFD3//POlfUgAAAAAAAAAAAAAAAAAAC6yOC/NrQzgjnXm/AUjuZ7u5qZSdxi88vkUnDeSe8ZibqRUq5uZ37WfbEZyJcnt4jkjuXb/UCO5krTntJnH+55QHyO5kuSRe9pY9jEFGskN8HI3kitJvp5uRnILDb5p+PzvP0ZyHRGNjeRKUqG1ZH+ccrN5Zh8zkitJuf5hxrJN8XHkGct2u3DWSK6l0Nw5F4bUMpLrlpdtJFeSLIVm7kucHlYjuZJk8zJzb+Bu6F5fkjzOnzKWfd67kpFcbw8z90OS5Hn+pJHcPP8qRnIlySvfzHXMI+ugkVxJkpuZv9kvDKpuJFeSnB7exrLPOq49s05ZqWgmVpK5ezGHX4iRXJNM3ouZel05PbyM5EpSoaGvDryzj5oJlpQbYO7a7e3IN5KbWWBubJtQDzOfcU5P+4uRXEm6a/TfjWUDAIDb1xcJLUyXAEn3b/7MdAnlztw3twAAAAAAAAAAAAAAAAAAALcxpiPH70JcXJzsdvtV1wcFBWnTpk1llt+pUycdOXLkmtts2bJFvr6+ZXoMAAAAAAAAAAAAAAAAAED5oQkTvwsrV66U03n1+T7c3Mp20NdZs2apoKDgmtv4+Fx7utybcQwAAAAAAAAAAAAAAAAAQPmhCRO/CzVq1DCaX61atVviGAAAAAAAAAAAAAAAAACA8lO2wwMCAAAAAAAAAAAAAAAAAAD8TjESJgAAAAAAAAAAAAAAAADgtua0O02XgDsUI2ECAAAAAAAAAAAAAAAAAAC4gCZMAAAAAAAAAAAAAAAAAAAAF9CECQAAAAAAAAAAAAAAAAAA4AKL0+l0mi4CgFn5ueeN5DrcPY3kSpLH+VPGsp2e3kZy7d4BRnIlyeKwG8l1WNyN5EqSR/7PZoKdDjO5Bjm8A41lXyg0dxvln3/GTLCH1UyuzF3H3AryjORK0hm7mffKSgVZRnIlyeFj5jWdZzH33Pa5aO7xNvWaznT6GcmVpFBLrpFck+fs52kxln2n8c0z9P4s6aRbRSO5Ph7m/r7Xx8Pcc9s7+6iR3LzA6kZyJSk738xnjco2c5/fTd2XyOD3Jaa+q8kvNPdZtsDgx2h/q5lrqOfZI0ZyJSnDu5qR3HN5Zr6bkqTs/AIjufUr+RjJlSQvQ/cHbrYLRnJNynM393v2VqGx7COGftWBXua+bzb1v3Ntbw42kitJnn5m/l9KleGpRnIBAMDNseXBh0yXAEkPfP4f0yWUO0bCBAAAAAAAAAAAAAAAAAAAcAFNmAAAAAAAAAAAAAAAAAAAAC7wMF0AAAAAAAAAAAAAAAAAAAA3wmF3mC4BdyhGwgQAAAAAAAAAAAAAAAAAAHABTZgAAAAAAAAAAAAAAAAAAAAuoAkTAAAAAAAAAAAAAAAAAADABTRhAgAAAAAAAAAAAAAAAAAAuIAmTAAAAAAAAAAAAAAAAAAAABfQhAkAAAAAAAAAAAAAAAAAAOACmjBRbtatW6cePXooNjZWsbGx6tKlixYvXly0vlWrVkpNTS3zOs6cOaPXX39dbdu2VUxMjBISEjRs2DAdPHiwVMe5cOGCFixYUKp9Dh8+rGeffVZxcXGKi4vTiy++qJMnT5b7MQAAAAAAAAAAAAAAAAAAN44mTJSL5cuX65VXXlGXLl20cuVKrVixQv8fe3ceV2Wd////yb6LgAikuIBKlBuFYeVoabnVaJNrmoaMqOWSWmEuaeNu6IhLfRzNBVQScUtrykobv1NTjuSCGeroqLnkhiuyn3N+f/TzfIaPG6LwnvRxv9263eJa3s/3dXGdc67r+OL9fvHFFzVp0iTNnTvXvk1cXFy59uPw4cN64YUXtHPnTo0ePVqffvqpZsyYoezsbHXt2lX79u0rdVuLFi3SwoULS719QUGBYmNjJUkfffSRli5dqjNnzqh///6y2WwV1gYAAAAAAAAAAAAAAABwr7FZbfz3X/Df/YgiTFSI1NRUde7cWV27dlXt2rUVFhamnj17KjY2VikpKZIkf39/eXl5lWs/EhISFBISoiVLlqh58+YKDQ1VdHS05s2bp8DAQE2dOrXUbd1u0eOJEyfUoEEDTZo0SXXr1lVkZKRiY2O1d+9enT9/vsLaAAAAAAAAAAAAAAAAAADcHRRhokI4Ojpq+/btunjxYonl8fHxSktLk1RyOvI5c+bYCzSbNWumxo0ba/jw4Tpz5owSEhIUFRWlFi1aaO3ataXuw549e7Rr1y7169dPrq6uJda5urpq5syZGjdunH3Z5s2b1b17d0VFRalBgwbq3Lmz/vGPf9j7N3fuXB0/flwRERE6duzYLfNr166tWbNmyd/fX5J07Ngxpaam6uGHH5afn1+pjuFutAEAAAAAAAAAAAAAAAAAuDsowkSFiI+PV1ZWlpo3b65+/fpp/vz5yszMlI+Pj2rXrn3dfTIyMpSRkaHk5GQlJSVp48aNev755xUZGanVq1erefPmGjt2bKlHgNy9e7ckKSoq6rrr69Wrp1q1akmSfvzxRw0cOFCtW7fW+vXrlZ6eroCAAL355psqLCxUXFyc4uLiFBwcrG+++UYhISG3dT7i4uLUqlUr/fjjj5o0aZIcHBxua/+71QYAAAAAAAAAAAAAAAAAoOwowkSFaNOmjdLS0tS6dWvt3r1bM2bMUJcuXdS2bVv98MMP193HarVq4sSJCg8P11NPPaXIyEiFhYWpT58+CgsLU2xsrAoLC3XkyJFS9eHqKJyVKlW65bZOTk4aM2aM4uLiFBoaqgcffFC9e/dWdna2srOz5eXlJU9PTzk5OSkwMFBOTk6lPxmS3nrrLa1cuVKPPPKIYmNj9csvv9zW/nerDQAAAAAAAAAAAAAAAABA2Tmb7gDuHw0bNlRiYqJsNpv279+vLVu2KCUlRfHx8fryyy+v2T4gIKBEwaSHh0eJESfd3NwkSQUFBaXKvzqF94ULF1SlSpWbbhsZGSlfX18tWLBAhw4d0uHDh5WVlSVJslgspcq7VfuSNHPmTD311FNavXq1Bg0aVOFtAAAAAAAAAAAAAAAAAADKjpEwUe5OnjypCRMm6NSpU5IkBwcHRUREqF+/fkpOTtaVK1e0bdu2a/ZzcXG5ZpmjY9kv2avTkO/cufO66zds2KChQ4cqPz9f27ZtU5s2bbRr1y7Vq1dPAwcOVGJiYpmzJen48ePauHFjiWUeHh6qXr26Tp8+XWFtAAAAAAAAAAAAAAAAAADuDoowUe5cXV2Vlpam9evXX7PO29tbkm45MuXdUKdOHT3yyCOaP3++ioqKSqzLz8/X/PnzlZ2dLXd3dy1cuFAxMTGaO3euYmNj9eSTT9qn+7bZbJJ+LSa9HVlZWRoyZIh+/vln+7JLly7p0KFDCg8Pr7A2AAAAAAAAAAAAAAAAAAB3B9ORo9z5+/urb9++SkpKUk5Ojtq2bStvb28dOHBAH3zwgWJiYhQdHV0hfRk/frx69eql2NhYDRgwQLVq1dLRo0c1d+5cnT59WklJSZKkkJAQffXVV8rIyFBwcLC2bt2qWbNmSZIKCwslSZ6enrp48aIOHTqk6tWrX3fkzv/UvHlzRUREKCEhQe+8845sNpsSExPl5+enTp06lar/d6MNAAAAAAAAAAAAAAAA4F5jtdhMdwH3KUbCRIUYOnSoJk2apG3btqlXr15q166dJk+erCeeeELz5s2rsH7UrVtX6enpCgsL07hx49S+fXuNGjVKNWrU0KpVq+yjSQ4ZMkSNGzfWgAED9MILLyg9PV2TJ0+Wu7u7MjMzJUmtW7dWYGCgOnTooJ9++umW2a6urvrwww9VrVo1/fGPf1Tv3r3l6+urZcuW2UcErYg2AAAAAAAAAAAAAAAAAAB3h4Pt6tzKAO5bBVcuG8m1Ot189NDy5Hz5tLFsm4u7kVyLeyUjuZLkYLUYybU6OBnJlSTngktmgm1WM7kGWd19jWXnFpu7jfIuOGcm2NnVTK7MvY85FuUbyZWkcxYzn5VVirKN5EqS1cPMazrfwdy17ZFn7nybek2fsXkZyZWkQIcrRnJNHrOXi4Ox7PuNZ76hz2dJJx0rG8n1cDb3970ezuaubfeLx4zk5vtWN5IrSRcLzDxrVC009/xu6r5EBr8vMfVdTUGxuWfZIoOP0d6uZt5DXc4fNZIrSafcHzCSeyHfzHdTknSxoMhI7kNVPIzkSpKbofsDx8JcI7km5TuZ+z27q9hY9lFDv2pfN3PfN5v659zCPw81kitJLl5m/i0lKGGOkVwAAHB3/C36cdNdgKSnMr4z3YUKx0iYAAAAAAAAAAAAAAAAAAAAZeBsugPA3RAdHS2L5cZ/zezn56fNmzeXW36HDh109OjN/4L822+/laenZ7m2AQAAAAAAAAAAAAAAAACoOBRh4p6wZs2am07F4OhYvoO+zps3T0VFN59WxsPj5tOC3I02AAAAAAAAAAAAAAAAAAAVhyJM3BNq1KhhNP+BBx74r2gDAAAAAAAAAAAAAAAAAFBxKMIEAAAAAAAAAAAAAAAAAPym2SxW013Afap852gGAAAAAAAAAAAAAAAAAAC4R1GECQAAAAAAAAAAAAAAAAAAUAYUYQIAAAAAAAAAAAAAAAAAAJQBRZgAAAAAAAAAAAAAAAAAAABl4Gy6AwDMyzf0VuBemGskV5IuuVcxln02r9hIbrCLzUiuJHkUXTGSm+/sbSRXkpwczbyu8hzdjeRKkteVU0ZyHZxcjeRKUqXLZo5Zkiw+QUZynXLOGMmVpDwXHyO5bs5uRnIlyd+h0EjuniuVjORKUi0PFyO5lwosRnIlycPZ3PuYis1cY0H55t5LDriEGsmt5mPubyCvFFmN5BYUm7v/9PdwMhNs8PUcZOh+/2S+metLkvwuHzWWLQczr2n3i8eM5ErSvuJAI7l+VUKM5EqSc2GOmeCiPDO5khwtRUZyc4rNvX8Gupn7vLpYYCY7wOB3cvuumMl+KNDTSK4kVXY3c1+SU2juM9rN2cznpMnvxTwczDxTutvMPNNJktXg9yWVXM2c78oFZ43kSpLNycz3zYUjZhvJlSQXS4GR3Jxcc/di3p4exrIBAABwZxgJEwAAAAAAAAAAAAAAAAAAoAwowgQAAAAAAAAAAAAAAAAAACgDpiMHAAAAAAAAAAAAAAAAAPym2Sw2013AfYqRMAEAAAAAAAAAAAAAAAAAAMqAIkwAAAAAAAAAAAAAAAAAAIAyoAgTAAAAAAAAAAAAAAAAAACgDCjCBAAAAAAAAAAAAAAAAAAAKAOKMAEAAAAAAAAAAAAAAAAAAMqAIkxUmA0bNqhbt26KiopSVFSUOnXqpBUrVtjXt2zZUnPmzCn3fpw7d07vvfee2rRpo4YNG6pFixZ66623dPjw4dtqJzc3V8uXLy9zPzIyMhQZGamtW7eWuY3Ro0fr7bffLvP+AAAAAAAAAAAAAAAAAICyowgTFWLVqlV655131KlTJ61Zs0arV6/Wiy++qEmTJmnu3Ln2beLi4sq1H4cPH9YLL7ygnTt3avTo0fr00081Y8YMZWdnq2vXrtq3b1+p21q0aJEWLlxYpn5cvnxZCQkJslqtZdrfYrFo2rRpWrVqVZn2BwAAAAAAAAAAAAAAAADcOWfTHcD9ITU1VZ07d1bXrl3ty8LCwnTy5EmlpKRo0KBB8vf3L/d+JCQkKCQkREuWLJGrq6skKTQ0VPPmzdMf/vAHTZ06VYsXLy5VWzabrcz9ePfddxUaGqrjx4/f9r4HDx7UyJEjdfToUT3wwANl7gMAAAAAAAAAAAAAAABwr7Bayl7LA9wJRsJEhXB0dNT27dt18eLFEsvj4+OVlpYmqeR05HPmzFFsbKxSUlLUrFkzNW7cWMOHD9eZM2eUkJCgqKgotWjRQmvXri11H/bs2aNdu3apX79+9gLMq1xdXTVz5kyNGzfOvmzz5s3q3r27oqKi1KBBA3Xu3Fn/+Mc/7P2bO3eujh8/roiICB07dqzU/fj444+1Y8cOjRo1qtT7/Kd//vOfioyM1CeffKLq1auXqQ0AAAAAAAAAAAAAAAAAwJ2jCBMVIj4+XllZWWrevLn69eun+fPnKzMzUz4+Pqpdu/Z198nIyFBGRoaSk5OVlJSkjRs36vnnn1dkZKRWr16t5s2ba+zYsTp//nyp+rB7925JUlRU1HXX16tXT7Vq1ZIk/fjjjxo4cKBat26t9evXKz09XQEBAXrzzTdVWFiouLg4xcXFKTg4WN98841CQkJK1Ydjx45p0qRJeu+99+Tl5VWqff6vl156SX/6058UEBBQpv0BAAAAAAAAAAAAAAAAAHcH05GjQrRp00ZpaWlaunSpvvnmG23ZskWSVKtWLU2ePFmPPvroNftYrVZNnDhRlSpVUnh4uCIjI+Xi4qI+ffpIkmJjY7Vy5UodOXJEfn5+t+zD1VE4K1WqdMttnZycNGbMGPXs2dO+rHfv3oqLi1N2drZCQkLk6ekpJycnBQYGluocWCwWJSQkqFu3boqOjr6t0TMBAAAAAAAAAAAAAAAA4H5WUFCgqVOn6vPPP1d+fr5+97vfady4cTcczO7tt9++4UzLgwcP1qBBg1RUVKSoqCgVFRWVWD9gwAANGzasVP2iCBMVpmHDhkpMTJTNZtP+/fu1ZcsWpaSkKD4+Xl9++eU12wcEBJQomPTw8Cgx4qSbm5ukX19cpeHv7y9JunDhgqpUqXLTbSMjI+Xr66sFCxbo0KFDOnz4sLKysiT9WkxZFvPmzVNubq4GDx5cpv0BAAAAAAAAAAAAAAAA4H717rvv6ocfftCcOXPk6uqqcePG6fXXX9eyZcuuu/3o0aP1xhtvlFg2Z84cffXVV+rSpYsk6d///reKior08ccflyjm9PT0LHW/KMJEuTt58qQWLFigfv36KSgoSA4ODoqIiFBERIRatWql9u3ba9u2bdfs5+Lics0yR0fHMvfj6jTkO3fu1DPPPHPN+g0bNmjTpk2aOnWqdu/erbi4OLVo0ULR0dF67rnnlJeXp4EDB5Y5f/Xq1Tp9+rRiYmIkSTabTdKvU7U/9thj+vDDD8vcNgAAAAAAAAAAAAAAAADcq06dOqV169bpL3/5i6KjoyVJf/7zn9W2bVvt3LlTjRs3vmYfHx8f+fj42H/+4YcflJ6err/85S8KCgqSJO3fv18+Pj568MEHy9w3ijBR7lxdXZWWlqbg4GDFx8eXWOft7S1JtxyZ8m6oU6eOHnnkEc2fP18tWrQoUeSZn5+v+fPnq3LlynJ3d9fChQsVExOjuXPn2rdZunSppP8tnnRwcLit/KVLl6q4uNj+86lTp9SrVy9NnDjRXpgJAAAAAAAAAAAAAAAAAL9VrVq1uun6TZs2landH374QZJK1FnVrl1bQUFB2rZt23WLMP+T1WrVpEmT1Lp1azVv3ty+fN++fapTp06Z+nQVRZgod/7+/urbt6+SkpKUk5Ojtm3bytvbWwcOHNAHH3ygmJgYe3VyeRs/frx69eql2NhYDRgwQLVq1dLRo0c1d+5cnT59WklJSZKkkJAQffXVV8rIyFBwcLC2bt2qWbNmSZIKCwsl/Trk7MWLF3Xo0CFVr179uiN3/qdq1aqV+NnJyUmSFBQUZK+sBgAAAAAAAAAAAAAAAHD7bFar6S6gHJ06dUp+fn5yc3Mrsbxq1ar65Zdfbrn/l19+qb1792rmzJkllu/fv1/FxcX64x//qKysLAUHB+uVV15Rx44dS903ijBRIYYOHapatWpp5cqVWr58ufLz8xUSEqL27durf//+FdaPunXrKj09XfPnz9e4ceN05swZBQQEqGnTppo2bZpCQ0MlSUOGDNHZs2c1YMAASb+Oojl58mS99dZbyszMVHh4uFq3bq2VK1eqQ4cOWrZsmRo1alRhxwEAAAAAAAAAAAAAAAAA/23KOtLlsWPHbjqK5uuvvy5XV9drlru5uamgoOCW7S9evFht27ZVzZo1Syz/17/+JWdnZw0ZMkSBgYH629/+ppEjR6qoqEidO3cuVd8dbFfnVgZw37p4Jc9IrrvFTK4k5Ti4G8s+m1d8643KQbDXzUdrLU8eRZeN5OY6exvJlSQPa76R3DxHc9e215VTRnKtHr5GciXJ6bKZY5Yki4+ZUZSdcs4YyZWkK741jOS6ORqJlSQ5WAqN5GZdNPeIUMv32geninCp0NxfRgY75hrLVrGZa8wx/6KRXEk64BJqJLeaj7l7sStFZq7vgmJz7yX+Hk5Gct0Kzdz3SpLNxcNI7sl8ByO5klQt/6ixbDkYukEwlStpV3GgkdzIKuaecZwLc8wE28zdl9gczfzN/pliM/eAkhToZu7z6mKxmdd0wIUDRnIlaUvRA0ZyHwr0NJIrSRZDL2mT//QT4GnmvaSg2Nz7p4eDxUywwc8Mq7PbrTcqJ5cLzJxvv8JsI7mSZHMy87oqdPczkitJLpZb/yN6eShyMndte3uaea4DAOBe8mXko6a7AEnPZv1Qpv2Kior0888/33D9li1b9OGHH+of//hHieWdO3dW48aNNWbMmBvu+/PPP+vZZ59VcnKymjZtWmJdQUGBrFarPDz+935s7Nix2rZtmz777LNS9Z2RMAEAAAAAAAAAAAAAAAAAgDEuLi4KDw+/4fp9+/bpwoULKiwsLDEi5unTpxUcHHzTtr/66isFBgbqscceu2bd/53eXJIiIiK0YcOGUvedIkzcE6Kjo2Wx3PgvH/38/LR58+Zyy+/QoYOOHr35CBzffvutPD1v/BfXd6MNAAAAAAAAAAAAAAAAALjXPProo7Jarfrhhx/0+OOPS5L+/e9/69SpU4qOjr7pvj/88IMee+wxOTqWnJnkwoULeuaZZ/TOO++oY8eO9uW7d+9W3bp1S903ijBxT1izZs1Np1f5vy+gu23evHkqKiq66Tb/OWRtebUBAAAAAAAAAAAAAAAAAPeaoKAgPffccxozZowmT54sDw8PjRs3To899pgaN24sSSosLNTFixfl6+tbYrTMvXv3qkuXLte0WblyZT3xxBP685//LH9/f4WGhuqLL77Q+vXr9Ze//KXUfaMIE/eEGjVqGM1/4IEH/ivaAAAAAAAAAAAAAAAAAIB70YQJEzR58mQNGjRIktS8eXONGTPGvn7Hjh3q3bu3UlJSFBMTY19+9uxZVa5c+bptTp06VXPmzNE777yj7OxshYeHa/bs2frd735X6n5RhAkAAAAAAAAAAAAAAAAAAP6reXp6auLEiZo4ceJ118fExGjfvn3XLN+1a9dN2xwxYoRGjBhR5n5RhAkAAAAAAAAAAAAAAAAA+E2zWmymu4D7lKPpDgAAAAAAAAAAAAAAAAAAAPwWUYQJAAAAAAAAAAAAAAAAAABQBhRhAgAAAAAAAAAAAAAAAAAAlAFFmAAAAAAAAAAAAAAAAAAAAGXgYLPZbKY7AcCsy7l5RnJdrYVGciXJofCKsWw5OhuJtTm7GcmVJJuTq5Fcx/yLRnIl6aJTJSO5fpePGMmVJKtXgJFcU9eXJFld3I1lF1rM3MK528y9dzvmmXlNWz39jORKktXJxUiuU94FI7mSZHXzMZJbZPDv00y9niXJzcnBSO7FAquRXEkKtJw3klvgaeZzUpLM/JYlg5e23Ay9pI/lFJsJllTTlm0k16HIzPOkJP3sVt1Ytr+7k5Fcz6JLRnIlSRYz17fNzdtIriTJ0czv+WKxufsSJ0cznxretnwjuZIkB3Pnu8jJzHc1OUXm7sWqXDlmJPeKbw0juZKUa+h8W6zmbsZcDT1neLqYez0XGzrfzobetyVznxmS5HzppJHc826BRnIlycfNzH2JqWtbkjxP7zOSe8gr3EiuJFX7brGRXI8OQ4zkAgBQHjbWe8R0FyCpzf7tprtQ4RgJEwAAAAAAAAAAAAAAAAAAoAwowgQAAAAAAAAAAAAAAAAAACgDM3PiAgAAAAAAAAAAAAAAAABwl9gsNtNdwH2KkTABAAAAAAAAAAAAAAAAAADKgCJMAAAAAAAAAAAAAAAAAACAMqAIEwAAAAAAAAAAAAAAAAAAoAwowgQAAAAAAAAAAAAAAAAAACgDijABAAAAAAAAAAAAAAAAAADKgCJMVJgNGzaoW7duioqKUlRUlDp16qQVK1bY17ds2VJz5swp936cO3dO7733ntq0aaOGDRuqRYsWeuutt3T48OHbaic3N1fLly8vcz8yMjIUGRmprVu33tZ+v/zyi4YPH64nn3xSTZo00R//+Ef961//KnM/AAAAAAAAAAAAAAAAAABl42y6A7g/rFq1ShMnTtSoUaPUpEkT2Ww2fffdd5o0aZLOnj2rQYMGadWqVXJzcyvXfhw+fFi9e/dW9erVNXr0aNWuXVunTp3SBx98oK5du2rp0qWKiIgoVVuLFi3SmjVr1LNnz9vux+XLl5WQkCCr1Xpb+xUWFqpfv37y9/fXX/7yF7m5uen999/XK6+8ok8++UT+/v633RcAAAAAAAAAAAAAAADgt85mub06HOBuoQgTFSI1NVWdO3dW165d7cvCwsJ08uRJpaSkaNCgQRVSQJiQkKCQkBAtWbJErq6ukqTQ0FDNmzdPf/jDHzR16lQtXry4VG3ZbLYy9+Pdd99VaGiojh8/flv7ZWRkaP/+/fp//+//KSgoSJL03nvv6bHHHtPmzZvVuXPnMvcJAAAAAAAAAAAAAAAAAHB7mI4cFcLR0VHbt2/XxYsXSyyPj49XWlqapJLTkc+ZM0exsbFKSUlRs2bN1LhxYw0fPlxnzpxRQkKCoqKi1KJFC61du7bUfdizZ4927dqlfv362Qswr3J1ddXMmTM1btw4+7LNmzere/fuioqKUoMGDdS5c2f94x//sPdv7ty5On78uCIiInTs2LFS9+Pjjz/Wjh07NGrUqFLvc1XdunU1f/58ewHmVTab7ZpzCwAAAAAAAAAAAAAAAAAoXxRhokLEx8crKytLzZs3V79+/TR//nxlZmbKx8dHtWvXvu4+GRkZysjIUHJyspKSkrRx40Y9//zzioyM1OrVq9W8eXONHTtW58+fL1Ufdu/eLUmKioq67vp69eqpVq1akqQff/xRAwcOVOvWrbV+/Xqlp6crICBAb775pgoLCxUXF6e4uDgFBwfrm2++UUhISKn6cOzYMU2aNEnvvfeevLy8SrXPfwoMDFSLFi1KLEtJSVFBQYGefPLJ224PAAAAAAAAAAAAAAAAAFB2FGGiQrRp00ZpaWlq3bq1du/erRkzZqhLly5q27atfvjhh+vuY7VaNXHiRIWHh+upp55SZGSkwsLC1KdPH4WFhSk2NlaFhYU6cuRIqfpwdaTISpUq3XJbJycnjRkzRnFxcQoNDdWDDz6o3r17Kzs7W9nZ2fLy8pKnp6ecnJwUGBgoJyenW7ZpsViUkJCgbt26KTo6ulR9vpUvvvhCM2fOVK9evfTggw/elTYBAAAAAAAAAAAAAAAAAKXjbLoDuH80bNhQiYmJstls2r9/v7Zs2aKUlBTFx8fryy+/vGb7gICAEgWTHh4eJUacdHNzkyQVFBSUKt/f31+SdOHCBVWpUuWm20ZGRsrX11cLFizQoUOHdPjwYWVlZUn6tZiyLObNm6fc3FwNHjy4TPv/Xx999JEmTJig9u3ba+TIkXelTQAAAAAAAAAAAAAAAABA6TESJsrdyZMnNWHCBJ06dUqS5ODgoIiICPXr10/Jycm6cuWKtm3bds1+Li4u1yxzdCz7JXt1GvKdO3ded/2GDRs0dOhQ5efna9u2bWrTpo127dqlevXqaeDAgUpMTCxztiStXr1aBw4cUExMjKKiovT8889L+nWq9r59+95WW9OnT9e7776rHj16KDEx8Y7OCwAAAAAAAAAAAAAAAACgbBgJE+XO1dVVaWlpCg4OVnx8fIl13t7eknTLkSnvhjp16uiRRx7R/Pnz1aJFixJFnvn5+Zo/f74qV64sd3d3LVy4UDExMZo7d659m6VLl0qSbDabpF+LSW/H0qVLVVxcbP/51KlT6tWrlyZOnKiYmJhSt5OYmKgPP/xQCQkJ+uMf/3hbfQAAAAAAAAAAAAAAAAAA3D0UYaLc+fv7q2/fvkpKSlJOTo7atm0rb29vHThwQB988IFiYmIUHR1dIX0ZP368evXqpdjYWA0YMEC1atXS0aNHNXfuXJ0+fVpJSUmSpJCQEH311VfKyMhQcHCwtm7dqlmzZkmSCgsLJUmenp66ePGiDh06pOrVq1935M7/VK1atRI/Ozk5SZKCgoIUFBRUqv5v3bpVH374oXr16qUOHTrozJkz9nWenp7y8vIqVTsAAAAAAAAAAAAAAADAvcRqsZnuAu5TFGGiQgwdOlS1atXSypUrtXz5cuXn5yskJETt27dX//79K6wfdevWVXp6uubPn69x48bpzJkzCggIUNOmTTVt2jSFhoZKkoYMGaKzZ89qwIABkn4dRXPy5Ml66623lJmZqfDwcLVu3VorV65Uhw4dtGzZMjVq1Kjc+//JJ59I+nVUzasjc141aNAgDR48uNz7AAAAAAAAAAAAAAAAAAD4lYPt6tzKAO5bl3PzjOS6WguN5EqSQ+EVY9lyNFP/bnN2M5IrSTYnVyO5jvkXjeRK0kWnSkZy/S4fMZIrSVavACO5pq4vSbK6uBvLLjT0V1zuNnPv3Y55Zl7TVk8/I7mSZHW6+Ujb5cUp74KRXEmyuvkYyS2So5FcydzrWZLcnByM5F4ssBrJlaRAy3kjuQWeZj4nJcnMb1ky+QfHboZe0sdyis0ES6ppyzaS61Bk5nlSkn52q24s29/dyUiuZ9ElI7mSJIuZ69vm5m0kV5LkaOb3fLHY3H2Jk6OZTw1vW76RXEmSg7nzXeRk5ruanCJz92JVrhwzknvFt4aRXEnKNXS+LVZzN2Ouhp4zPF3MvZ6LDZ1vZ0Pv25K5zwxJcr500kjuebdAI7mS5ONm5r7E1LUtSZ6n9xnJPeQVbiRXkqp9t9hIrkeHIUZyAQAoD5+GNjTdBUh67mim6S5UOHNPpAAAAAAAAAAAAAAAAAAAAL9hTEeOe0J0dLQsFssN1/v5+Wnz5s3llt+hQwcdPXr0ptt8++238vT0LNc2AAAAAAAAAAAAAAAAAAAVhyJM3BPWrFkjm+3GUyI4OpbvoK/z5s1TUVHRTbfx8PAo9zYAAAAAAAAAAAAAAAAAABWHIkzcE2rUqGE0/4EHHvivaAMAAAAAAAAAAAAAAAAAUHHKd3hAAAAAAAAAAAAAAAAAAACAexQjYQIAAAAAAAAAAAAAAAAAftNsFpvpLuA+xUiYAAAAAAAAAAAAAAAAAAAAZUARJgAAAAAAAAAAAAAAAAAAQBlQhAkAAAAAAAAAAAAAAAAAAFAGzqY7AMA8t8LLRnJznb2N5EqSp4O5GnSbo6G3XqvFTK6k04Vmsr1cKhnJlSQPJwcjuRbfB4zkStLZIjPXdk6euWu7lmORsexiq5OR3KP55t4//d2rGMn1spn7PRdabEZy3Z3djeRKkmP+RSO5FtfKRnIl6ZzB97HqlVyM5FZyM/j3gEVmrm9nRzP3BpLkcvagkVyrT5CRXEmyuJl51qjuZe7avmSpaiS3coGZ60uSfN3M3A9JUk6h1UhunqOPkVxJqmI9YyT3TLGZzypJumzoWdbVycz1JUmuhj6vfJRvJFeSzjn5Gst2kZn7/dwic9eYzcnVSK7njxuN5EqSl7OZ9zHHyoFGciWpuEqYkVybzc1IrmTwO1+DbGbewiRJFkPPGpUNfWchSWfyzNwHBph7WelCQD0juTWsuUZyJUkBwUZiCzanGMmVJLeWvY1lAwAA3E2MhAkAAAAAAAAAAAAAAAAAAFAGFGECAAAAAAAAAAAAAAAAAACUwf03PwIAAAAAAAAAAAAAAAAA4J5itdlMdwH3KUbCBAAAAAAAAAAAAAAAAAAAKAOKMAEAAAAAAAAAAAAAAAAAAMqAIkwAAAAAAAAAAAAAAAAAAIAyoAgTAAAAAAAAAAAAAAAAAACgDCjCBAAAAAAAAAAAAAAAAAAAKAOKMFFhNmzYoG7duikqKkpRUVHq1KmTVqxYYV/fsmVLzZkzp9z7ce7cOb333ntq06aNGjZsqBYtWuitt97S4cOHb6ud3NxcLV++vMz9yMjIUGRkpLZu3Xpb+/3888969dVXFR0drejoaA0bNkwnT54scz8AAAAAAAAAAAAAAAAAAGVDESYqxKpVq/TOO++oU6dOWrNmjVavXq0XX3xRkyZN0ty5c+3bxMXFlWs/Dh8+rBdeeEE7d+7U6NGj9emnn2rGjBnKzs5W165dtW/fvlK3tWjRIi1cuLBM/bh8+bISEhJktVpva7+CggLFxsZKkj766CMtXbpUZ86cUf/+/WWz2crUFwAAAAAAAAAAAAAAAABA2Tib7gDuD6mpqercubO6du1qXxYWFqaTJ08qJSVFgwYNkr+/f7n3IyEhQSEhIVqyZIlcXV0lSaGhoZo3b57+8Ic/aOrUqVq8eHGp2rqTosd3331XoaGhOn78+G3td+LECTVo0EDjxo2zn6/Y2FgNHDhQ58+fr5BzCAAAAAAAAAAAAAAAAPy3sTCAGQxhJExUCEdHR23fvl0XL14ssTw+Pl5paWmSSk5HPmfOHMXGxiolJUXNmjVT48aNNXz4cJ05c0YJCQmKiopSixYttHbt2lL3Yc+ePdq1a5f69etnL8C8ytXVVTNnztS4cePsyzZv3qzu3bsrKipKDRo0UOfOnfWPf/zD3r+5c+fq+PHjioiI0LFjx0rdj48//lg7duzQqFGjSr3PVbVr19asWbPsxZbHjh1TamqqHn74Yfn5+d12ewAAAAAAAAAAAAAAAACAsqMIExUiPj5eWVlZat68ufr166f58+crMzNTPj4+ql279nX3ycjIUEZGhpKTk5WUlKSNGzfq+eefV2RkpFavXq3mzZtr7NixOn/+fKn6sHv3bklSVFTUddfXq1dPtWrVkiT9+OOPGjhwoFq3bq3169crPT1dAQEBevPNN1VYWKi4uDjFxcUpODhY33zzjUJCQkrVh2PHjmnSpEl677335OXlVap9biQuLk6tWrXSjz/+qEmTJsnBweGO2gMAAAAAAAAAAAAAAAAA3B6KMFEh2rRpo7S0NLVu3Vq7d+/WjBkz1KVLF7Vt21Y//PDDdfexWq2aOHGiwsPD9dRTTykyMlJhYWHq06ePwsLCFBsbq8LCQh05cqRUfbg6CmelSpVuua2Tk5PGjBmjuLg4hYaG6sEHH1Tv3r2VnZ2t7OxseXl5ydPTU05OTgoMDJSTk9Mt27RYLEpISFC3bt0UHR1dqj7fzFtvvaWVK1fqkUceUWxsrH755Zc7bhMAAAAAAAAAAAAAAAAAUHrOpjuA+0fDhg2VmJgom82m/fv3a8uWLUpJSVF8fLy+/PLLa7YPCAgoUTDp4eFRYsRJNzc3SVJBQUGp8q9O4X3hwgVVqVLlpttGRkbK19dXCxYs0KFDh3T48GFlZWVJ+rWYsizmzZun3NxcDR48uEz7X6+PkjRz5kw99dRTWr16tQYNGnRX2gYAAAAAAAAAAAAAAAAA3BojYaLcnTx5UhMmTNCpU6ckSQ4ODoqIiFC/fv2UnJysK1euaNu2bdfs5+Lics0yR8eyX7JXpyHfuXPndddv2LBBQ4cOVX5+vrZt26Y2bdpo165dqlevngYOHKjExMQyZ0vS6tWrdeDAAcXExCgqKkrPP/+8pF+nau/bt2+p2jh+/Lg2btxYYpmHh4eqV6+u06dP31H/AAAAAAAAAAAAAAAAAAC3h5EwUe5cXV2Vlpam4OBgxcfHl1jn7e0tSbccmfJuqFOnjh555BHNnz9fLVq0KFHkmZ+fr/nz56ty5cpyd3fXwoULFRMTo7lz59q3Wbp0qSTJZrNJ+rWY9HYsXbpUxcXF9p9PnTqlXr16aeLEiYqJiSlVG1lZWRoyZIi+/PJL1ahRQ5J06dIlHTp0SB06dLit/gAAAAAAAAAAAAAAAAAA7gxFmCh3/v7+6tu3r5KSkpSTk6O2bdvK29tbBw4c0AcffKCYmBhFR0dXSF/Gjx+vXr16KTY2VgMGDFCtWrV09OhRzZ07V6dPn1ZSUpIkKSQkRF999ZUyMjIUHBysrVu3atasWZKkwsJCSZKnp6cuXryoQ4cOqXr16tcdufM/VatWrcTPTk5OkqSgoCAFBQWVqv/NmzdXRESEEhIS9M4778hmsykxMVF+fn7q1KnT7ZwKAAAAAAAAAAAAAAAAAMAdoggTFWLo0KGqVauWVq5cqeXLlys/P18hISFq3769+vfvX2H9qFu3rtLT0zV//nyNGzdOZ86cUUBAgJo2bapp06YpNDRUkjRkyBCdPXtWAwYMkPTrKJqTJ0/WW2+9pczMTIWHh6t169ZauXKlOnTooGXLlqlRo0bl3n9XV1d9+OGHmjZtmv74xz+qsLBQzZo109SpU+2jigIAAAAAAAAAAAAAAAD3G4vNdA9wv3KwXZ1bGcB9q/DCaSO5uc7mCkc9iy4Zy7Y5uRrLNuVUsZlj9nJxNJIrSW5ODkZyXayFRnIl6WyRmb/tyCmyGMmVpFpeZn7PkpRjdTKSez7f3Pn2dzdzzF4ORUZyJSnfwcz7p7u1wEiuJDkU5RrJzXWtbCRXks7kmntdVa9089Hcy0ux1dxjqFvRFSO5Fjdz974uZw8aybX6lG7E//Jg6nw7WM29nq9YzNyXVL5g5vqSpAuVw41l5xVZjeQ6OZq7/6xSeMZI7mmXQCO5knS50Mxr2tXQ86QkuRq6xqrK3Pc055x8jWW7GDrfFwvMfV6FWs6aCT68y0yuJAdnM/fcjpXNvX8WVwkzkmtzdjOSK0mFDma+FzP3iSE5OphLd5SZZ0rH/ItGciXpjHyM5AaYe1kZe8bxsZr5bkqS9ONmI7G2gnwjuZLk1rK3sWwAwL1pVdDDprsASZ1P7THdhQpnrjoFAAAAAAAAAAAAAAAAAADgN4zpyHFPiI6OlsVy47/g9vPz0+bN5ffXYx06dNDRo0dvus23334rT0/Pcm0DAAAAAAAAAAAAAAAAAFBxKMLEPWHNmjWy2W48/YSjY/kO+jpv3jwVFd18qlIPD49ybwMAAAAAAAAAAAAAAAAAUHEowsQ9oUaNGkbzH3jggf+KNgAAAAAAAAAAAAAAAAAAFad8hwcEAAAAAAAAAAAAAAAAAAC4RzESJgAAAAAAAAAAAAAAAADgN81is5nuAu5TjIQJAAAAAAAAAAAAAAAAAABQBhRhAgAAAAAAAAAAAAAAAAAAlAFFmAAAAAAAAAAAAAAAAAAAAGVAESYAAAAAAAAAAAAAAAAAAEAZOJvuAADzrK5eRnKd5GAkV5IuOPoYy65svWIkN8/F3DEHKc9MsIOTmVxJKrYYiT1V7GokV5LcDZ3u2q75ZoIl/ZzrYSw71M3Mcbt5mTtmU65YXIxlezib+ax0zDlvJFeScr2DjeT6nM4ykitJ3q7mXleXimoayXV1MncfaHM08xjslH/JSK4k5fmHGcl1v3TCSK4kOTq7Gcl1yLtoJFeS5OZvJPbfbrWM5EpSTUuOsWwvdzPP0dkFRmIlSVaPykZyAy1mnqElqaqjmXtuhwJzx2xzMvNMWVy5mpFcSapsNfP8LknO548YyfXxDjSSK0lWdzOfVyfrPGMkV5L8Pcx8YeKWb+65ztQ9twy+nl1tRUZybYbueyXJwWo1lp1v6J83Cwz+u0IVZ0Pn22LudXUuz8z7ZyWruee64uyTRnJteebuPws2pxjLdmvZ21g2AAC49zASJgAAAAAAAAAAAAAAAAAAQBlQhAkAAAAAAAAAAAAAAAAAAFAGTEcOAAAAAAAAAAAAAAAAAPhNs9hM9wD3K0bCBAAAAAAAAAAAAAAAAAAAKAOKMAEAAAAAAAAAAAAAAAAAAMqAIkwAAAAAAAAAAAAAAAAAAIAyoAgTAAAAAAAAAAAAAAAAAACgDCjCBAAAAAAAAAAAAAAAAAAAKAOKMFFhNmzYoG7duikqKkpRUVHq1KmTVqxYYV/fsmVLzZkzp9z7ce7cOb333ntq06aNGjZsqBYtWuitt97S4cOHb6ud3NxcLV++vMz9yMjIUGRkpLZu3Wq0DQAAAAAAAAAAAAAAAABA2Tib7gDuD6tWrdLEiRM1atQoNWnSRDabTd99950mTZqks2fPatCgQVq1apXc3NzKtR+HDx9W7969Vb16dY0ePVq1a9fWqVOn9MEHH6hr165aunSpIiIiStXWokWLtGbNGvXs2fO2+3H58mUlJCTIarXe9r53sw0AAAAAAAAAAAAAAAAAQNlRhIkKkZqaqs6dO6tr1672ZWFhYTp58qRSUlI0aNAg+fv7l3s/EhISFBISoiVLlsjV1VWSFBoaqnnz5ukPf/iDpk6dqsWLF5eqLZvNVuZ+vPvuuwoNDdXx48eNtgEAAAAAAAAAAAAAAADcCyx3UMsD3AmmI0eFcHR01Pbt23Xx4sUSy+Pj45WWliap5HTkc+bMUWxsrFJSUtSsWTM1btxYw4cP15kzZ5SQkKCoqCi1aNFCa9euLXUf9uzZo127dqlfv372AsyrXF1dNXPmTI0bN86+bPPmzerevbuioqLUoEEDde7cWf/4xz/s/Zs7d66OHz+uiIgIHTt2rNT9+Pjjj7Vjxw6NGjWq1PuURxsAAAAAAAAAAAAAAAAAgDtDESYqRHx8vLKystS8eXP169dP8+fPV2Zmpnx8fFS7du3r7pORkaGMjAwlJycrKSlJGzdu1PPPP6/IyEitXr1azZs319ixY3X+/PlS9WH37t2SpKioqOuur1evnmrVqiVJ+vHHHzVw4EC1bt1a69evV3p6ugICAvTmm2+qsLBQcXFxiouLU3BwsL755huFhISUqg/Hjh3TpEmT9N5778nLy6tU+5RHGwAAAAAAAAAAAAAAAACAO0cRJipEmzZtlJaWptatW2v37t2aMWOGunTporZt2+qHH3647j5Wq1UTJ05UeHi4nnrqKUVGRiosLEx9+vRRWFiYYmNjVVhYqCNHjpSqD1dH4axUqdItt3VyctKYMWMUFxen0NBQPfjgg+rdu7eys7OVnZ0tLy8veXp6ysnJSYGBgXJycrplmxaLRQkJCerWrZuio6NL1efyaAMAAAAAAAAAAAAAAAAAcHc4m+4A7h8NGzZUYmKibDab9u/fry1btiglJUXx8fH68ssvr9k+ICCgRMGkh4dHiREn3dzcJEkFBQWlyvf395ckXbhwQVWqVLnptpGRkfL19dWCBQt06NAhHT58WFlZWZJ+LYQsi3nz5ik3N1eDBw8u0/53qw0AAAAAAAAAAAAAAAAAwN3BSJgodydPntSECRN06tQpSZKDg4MiIiLUr18/JScn68qVK9q2bds1+7m4uFyzzNGx7Jfs1WnId+7ced31GzZs0NChQ5Wfn69t27apTZs22rVrl+rVq6eBAwcqMTGxzNmStHr1ah04cEAxMTGKiorS888/L+nXqdr79u1bYW0AAAAAAAAAAAAAAAAAAO4ORsJEuXN1dVVaWpqCg4MVHx9fYp23t7ck3XJkyruhTp06euSRRzR//ny1aNGiRJFnfn6+5s+fr8qVK8vd3V0LFy5UTEyM5s6da99m6dKlkiSbzSbp12LS27F06VIVFxfbfz516pR69eqliRMnKiYmpsLaAAAAAAAAAAAAAAAAAADcHRRhotz5+/urb9++SkpKUk5Ojtq2bStvb28dOHBAH3zwgWJiYhQdHV0hfRk/frx69eql2NhYDRgwQLVq1dLRo0c1d+5cnT59WklJSZKkkJAQffXVV8rIyFBwcLC2bt2qWbNmSZIKCwslSZ6enrp48aIOHTqk6tWrX3fkzv9UrVq1Ej87OTlJkoKCghQUFFSq/t+NNgAAAAAAAAAAAAAAAIB7jcVmuge4X1GEiQoxdOhQ1apVSytXrtTy5cuVn5+vkJAQtW/fXv3796+wftStW1fp6emaP3++xo0bpzNnziggIEBNmzbVtGnTFBoaKkkaMmSIzp49qwEDBkj6dRTNyZMn66233lJmZqbCw8PVunVrrVy5Uh06dNCyZcvUqFGjCjsOAAAAAAAAAAAAAAAAAIB5DrarcysDuG/l514xklskRyO5kpRXZDWWXdlm5nznufgYyZUkd0uemWBHJzO5kmS1GIk9VexqJFeS3J0cjOSaek1J0s9FHsayQ92KjOQWOZs7ZlMKDf7JnIeLmc9K54u/GMmVpFzvYCO53qezjORKks3V3OvqUqWaRnJdDX1mSJKLpcBIroOl0EiuJBW4mrkPdL90wkiuJFl9qhrJdci7aCRXki67+RvJPZdn5r5Xkmq6GnrOkGR19TKSm23mLUySVMXZzP2nyfdPh6J8M7mF5p5xbE5mnimLK1e79UblxMHQ87skOZ//2Uiu1TvQSK4k2ZxuPptQeTlZYO47In8PM9lu+eeN5EqSzcXTWLYxNjPfN9uc3YzkSpKDoWOWpHxDY8wUFJs7Zl9nQ9kGPyd/zjPz/lnLetpIriQV//NTI7m2PHP3n06B5u4D3Vr2NpYNACg/SwIiTXcBkmKzzf27mynmKqAAAAAAAAAAAAAAAAAAAAB+w5iOHPeE6OhoWSw3/ms8Pz8/bd68udzyO3TooKNHj950m2+//Vaenjf+C+C70QYAAAAAAAAAAAAAAAAAoOJQhIl7wpo1a2Sz3XiqUEfH8h30dd68eSoquvm0XB4eN59m8m60AQAAAAAAAAAAAAAAAACoOBRh4p5Qo0YNo/kPPPDAf0UbAAAAAAAAAAAAAAAAAICKU77DAwIAAAAAAAAAAAAAAAAAANyjGAkTAAAAAAAAAAAAAAAAAPCbZrHZTHcB9ylGwgQAAAAAAAAAAAAAAAAAACgDijABAAAAAAAAAAAAAAAAAADKgCJMAAAAAAAAAAAAAAAAAACAMnA23QEA5l2xOBjJdXMyEitJ8nQxWIOeX2wk1snMr1mS5GA1c8wylSvpX3nuRnIDPM39oivbrhjJdSjKN5IrSTWcrcayi10qG8l1vXLWSK4k2Tx8jeQWO5j7wHK++IuRXJubl5FcSXK35BnJzfaPMJIrSQ4O5t67KzkUGcktlKuRXEk6lGvmPrCaj4+RXElyKzLzGW1z9TCSK0kOeReN5B6Xmc8qSQpyNnNtV69k7tnqdK65988rORYjuTUqmXv/dMg187qyOZt5tpKkXI8qRnJPWCobyZUkL0Pfl1y5UGgkV5LqOmQby/7ZrbqRXEuBkVhJUk0XM/clhRZzzzhncs18PxVabObZSpIuOlc2klvJwdx7yRUHM59XTjZz90OuTua+L8nNN3Mvll9s7rvAyjLz5p3j6GkkV5JqeJn5PVutAUZyJSn36b5Gcq8Umbu2H8g/biy78KKZ77pdfc08ZwAAgPLFSJgAAAAAAAAAAAAAAAAAAABlQBEmAAAAAAAAAAAAAAAAAABAGVCECQAAAAAAAAAAAAAAAAAAUAbOpjsAAAAAAAAAAAAAAAAAAMCdsNhM9wD3K0bCBAAAAAAAAAAAAAAAAAAAKAOKMAEAAAAAAAAAAAAAAAAAAMqAIkwAAAAAAAAAAAAAAAAAAIAyoAgTAAAAAAAAAAAAAAAAAACgDO65IswNGzaoW7duioqKUlRUlDp16qQVK1aU2KZly5aaM2dOufWhZcuWioiIuOF/vXr1uqP2i4qKtGTJktver7i4WMnJyXrxxRcVFRWlmJgY9enTR999991ttWOz2bR27VplZ2eXep/c3FxNmDBBzZo1U6NGjdSzZ09t3779dg9BkrR27Vr16NFDTZo0UXR0tLp3767PPvvsttv5+uuvdeDAgTL14b/Ftm3bFBkZabobAAAAAAAAAAAAAAAAAHBfcjbdgbtp1apVmjhxokaNGqUmTZrIZrPpu+++06RJk3T27FkNGjTIvp2bm1u59sNisUiSduzYocGDBys9PV0hISGSJBcXlztq/5NPPtGUKVMUGxtb6n0KCwvVp08f/fLLLxo8eLCioqKUn5+v1atXKy4uTlOmTNELL7xQqra2bdumt99+W5s2bSp1/ujRo5WVlaWkpCQFBgYqOTlZcXFx2rhxo4KCgkrVhs1m07Bhw/Tdd99p8ODBatq0qRwcHPTFF1/ojTfe0KFDh/Taa6+Vqq3jx49rwIABSklJUZ06dUp9HP9Ntm7dqkGDBslqtZruCgAAAAAAAAAAAAAAAADcl+6pIszU1FR17txZXbt2tS8LCwvTyZMnlZKSYi/C9Pf3L9d+/Gf7vr6+9mWBgYF3pX2bzXbb+8yePVt79+7Vp59+quDgYPvy0aNHKzc3V5MnT9azzz4rLy+vu55fXFwsd3d3jRs3TtHR0ZKkYcOGafny5dq+fbvatWtXqnZWrFihL774QqtWrdJDDz1kX/7qq6/KZrPp/fffV8eOHVWtWrW7fgz/TYqLizV16lR99NFHioiI0J49e0x3CQAAAAAAAAAAAAAAADDK8tstB8Jv3D01Hbmjo6O2b9+uixcvllgeHx+vtLQ0+8//OR35nDlzFBsbq5SUFDVr1kyNGzfW8OHDdebMGSUkJCgqKkotWrTQ2rVr71o/bTabFixYoFatWqlRo0bq2LGj1q9fb18/fvx4RUVF6fjx45KkvLw8tW3bVgMGDNCaNWs0cuRISVJERIS2bt16y7yioiKlp6erc+fOJQowr3r99df14Ycfyt3dXZL0r3/9S6+99ppiYmJUv359Pfvss0pOTpb06+iLvXv3liS1atVKa9asuWW+s7OzpkyZoscff1ySdOnSJX3wwQfy8vJS48aNb7n/VampqWrZsmWJAsyrevfurSVLltgLXU+ePKk333xTTzzxhB5++GG1aNFCM2fOlNVq1bFjx9SqVSv7flevhYMHDyo+Pl5RUVFq1qyZ3njjDZ05c8aeYbFYNHPmTPuU6oMHD9akSZNKTC9/8OBBDRgwQDExMXr00Uc1ZMgQnThxwr6+V69eGjVqlLp06aLo6GjNnTtXERER2rZtW4njGTZsmL1o+P/Kzc3Vjz/+qEWLFunll18u9fkDAAAAAAAAAAAAAAAAANxd91QRZnx8vLKystS8eXP169dP8+fPV2Zmpnx8fFS7du0b7peRkaGMjAwlJycrKSlJGzdu1PPPP6/IyEitXr1azZs319ixY3X+/Pm70s+ZM2cqNTVVY8aM0YYNG9S7d2+9++67Wr58uSQpISFBQUFBGjt2rCRpypQpunLliqZMmaL27dtr1KhRkqRvvvlGUVFRt8w7evSoLly4cMOCx6pVq6phw4ZycnJSXl6e+vTpI09PT6WmpurTTz9Vu3btNHnyZGVlZSkqKspetJienq727dvf1rHPmzdPTZo00eLFizV69Gj7FO23UlhYqP3799/wGLy9vdWkSRO5urpKkvr3769z585p4cKF+vzzz9W3b1/NmzdPmzdvVkhIiNLT0yX9WoQbFxenU6dOqUePHgoNDdWqVas0b9485eTkqHv37srNzZUkTZ8+XWlpaRo7dqzWrFmjqlWraunSpfY+HD9+XN26dZOrq6uSk5O1ePFiZWdn6+WXX1ZOTo59uzVr1qh379766KOP1LNnTz300ENat26dff3ly5e1adMmvfjii9c91kqVKmnFihWKiYkp1bkDAAAAAAAAAAAAAAAAAJSPe6oIs02bNkpLS1Pr1q21e/duzZgxQ126dFHbtm31ww8/3HA/q9WqiRMnKjw8XE899ZQiIyMVFhamPn36KCwsTLGxsSosLNSRI0fuuI+5ublasmSJRowYoaefflo1atRQp06dFBsbq4ULF0qS3N3dlZiYqO+//16jRo1Senq6EhMT5efnJ3d3d/n4+EiSAgMD7UWHN3N1ZNCrU6PfTF5enr0oNDw8XDVr1rSPyLhv3z65urqWmGL96uiZpdWuXTutW7dO/fv315gxY/T111+Xar8LFy6U+hjy8/PVsWNHTZgwQZGRkQoNDVWvXr1UtWpV7du3T05OTvYp4319feXl5aWPPvpIVatW1dixYxUeHq769esrKSlJZ8+e1eeff668vDylpqZq6NChat26tcLDw/XOO++UGJUzNTVVnp6emj59uh588EE1bNhQs2fPVnZ2domRTiMjI/X73/9edevWlZ+fnzp16qSNGzeqoKBAkvTZZ5/Jx8dHzZs3L+1pBQAAAAAAAAAAAAAAAAAY4Gy6A3dbw4YNlZiYKJvNpv3792vLli1KSUlRfHy8vvzySwUEBFyzT0BAgCpVqmT/2cPDo8QIjW5ubpJkL5K7EwcOHFBBQYFGjBhhn1ZckoqLi1VYWKj8/Hy5u7urQYMG6t+/v95//3298soratq0aZkzrxYcXi1kvNW2PXr00F//+lft3btXR44cUVZWlqRfi1XvVM2aNSX9Woi4Z88eLV68WE8//fQt96tcubIcHBxKNRqpu7u7Xn75ZX3++edKTk7WkSNHtHfvXp0+ffqGx/DTTz/p4MGD14wsWlBQoIMHD+rgwYPKz8+/ZiTORx99VHv37pUk7d+/X/Xr1y9RGBsQEKDatWtr375915yDq37/+99r2rRp2rRpk9q3b6+1a9eqQ4cOcna+516eAAAAAAAAAAAAAAAAAHBPuWeqvE6ePKkFCxaoX79+CgoKkoODgyIiIhQREaFWrVqpffv22rZtm9q2bXvNvi4uLtcsc3Qsn0FCbTabJCkpKUlhYWHXrP/PAr49e/bI2dlZW7duVWFhYalGvbye0NBQValSRTt27Lju9OGHDx/W+PHjNWLECAUEBKhr167y8/NTq1at9Pjjj6tBgwZq0aJFmbIlKScnR998842eeOKJEsWudevW1ebNm0vVhqurq+rXr6+dO3feMGPgwIF69dVX1ahRI/Xs2VN5eXlq166dOnbsqHfeeUc9e/a8YftWq1VNmzbVuHHjrlnn4+Oj06dPS/rf39/12Gw2OTg4XLPcYrGUuMb+7+ihvr6+euaZZ7R+/Xo1aNBAO3bs0Pjx42+YAwAAAAAAAAAAAAAAAAD473DPTEfu6uqqtLS0EtM+X+Xt7S1JqlKlSkV36xphYWFydnbWiRMnVLNmTft/W7Zs0cKFC+3FnytWrNC3336rhQsX6uTJk5o1a5a9jesV+t2Mo6OjOnfurDVr1ujUqVPXrP/www+1c+dOVatWTRs2bNCFCxe0YsUKvfbaa3r22Wft05lfLUC83fzi4mINGzZMX3zxRYnlmZmZqlOnTqnb6dq1q/72t7/pp59+umbd0qVL9c9//lPVqlXT3//+d+3Zs0dLly7VkCFD1L59e3l7eys7O/uGx1C3bl0dPHhQISEh9t+Jr6+vJk+erP3796tmzZpyd3e/pgg0MzPT/v/16tVTZmamCgsL7cvOnj2rI0eOKDw8/KbH1qlTJ3377bf6+OOP1aBBA9WtW7fU5wUAAAAAAAAAAAAAAAAAYMY9U4Tp7++vvn37KikpSTNnzlRWVpaOHj2qr7/+WoMGDVJMTIyio6NNd1M+Pj7q3r27kpKStG7dOh09elRr165VYmKivUj0yJEjmjZtmgYNGqSmTZtq9OjRWrRokbZt2yZJ8vT0lCT9+OOPys/PL1XugAEDVLNmTXXv3l3r1q3Tzz//rN27d2v06NFavXq1JkyYIG9vbwUHBysvL0+fffaZTpw4oW+++UbDhw+XJHtx4dX8vXv36sqVK7fMrly5srp06aKZM2dqy5Yt+ve//63Jkydr165devXVV0t97jp37qzf/e536tOnj5YvX67Dhw9r7969mj59umbPnq3hw4crNDRUwcHBkqT169fr+PHjysjI0GuvvaaioqJrjmH//v26fPmyevToocuXL2v48OHKysrS3r179cYbbygzM1N169aVh4eHevXqpdmzZ+urr77SoUOHNH369BJFmS+99JJycnL05ptvau/evcrMzNTrr78uPz8/Pffcczc9tieeeEJVqlTRggUL9OKLL5b6nAAAAAAAAAAAAAAAAAAAzLlnpiOXpKFDh6pWrVpauXKlli9frvz8fIWEhKh9+/bq37+/6e7ZjRw5Uv7+/po9e7ZOnz6t4OBgDRo0SP369ZPFYlFCQoJq166tvn37SpI6dOigv/71rxoxYoTWr1+vpk2bqlGjRurevbsSExPVrl27W2Z6eHho2bJlWrRokRYsWKATJ07Izc1NDz/8sJKTk/XYY49Jktq2bas9e/Zo2rRpysnJUbVq1dSlSxdt2rRJmZmZeumll1SvXj21aNFCQ4cO1fDhwxUXF3fL/DFjxsjPz0/vvvuuzp49q4cfflhLlixR/fr1S33eHB0d9f7772vZsmVKT0/XjBkz5OzsrDp16mjOnDl65plnJEkNGzbUyJEjtWTJEiUlJSkoKEjt27dXSEiIdu3aJUny8/NTp06d9N577+nIkSMaM2aMli1bphkzZqhHjx5ycnJS48aNlZycrICAAEnS66+/rqKiIo0ZM0Z5eXl6+umn1apVKxUUFEj6ddr3pUuXavr06erWrZtcXV315JNPKjExscQ07Dc6tg4dOmjx4sW3LNgEAAAAAAAAAAAAAAAAUJLl/58hF6hoDjYbVx9QGl9++aUeffRR+fv725fFxcUpODhYkydPvuP2R44cqaKiIk2fPv2O27pd2ZdzKzxTktycbm9q+3uFa/55I7mF7n5GciXJtfCysWxT/pXnbiQ3wNPJSK4k+dtuPTpyeXAoKt2o0OXB5uxqLLvYvbKRXOcrZ43kSpLNw9dIbp7N3OvK68opI7k2Ny8juZJkczTzd2IXbW5GciXJwcHcPVElxyIjuYWO5t4/j182c8zVfFyM5EqSW5GZz2hZCs3kSpLVaiT2uMx8VklSkJeZa8zgW5iyc4uNZV8pNnON1ahk7v3TKfeckVybs5lnK0nKczSTfSLH3LXt5WJm4qQrRWZeU5JU1yHbWPZRpypGci3mTrdqupi5LzlSZO4Zx8nQfGShxafNBEu64BliJLeSg7n7zysy8xnt5GjuZszV4Pf7F/ItRnLzDd0DSlI1lwIjuTmOnkZyJcnL0czvWVZDuZJyDL2XmLwXeyD/uLFsq1eAkVxXXzP3gABwv5jrG2G6C5A06OI+012ocPfUSJhAeVq4cKFSU1OVkJAgb29vbdq0Sd9//70WLVp0R+1+++23OnDggD755BMtX778LvUWAAAAAAAAAAAAAAAAAFDeKMK8TdHR0bJYbvwXUH5+ftq8eXOF9WfAgAHaunXrTbdZtWqVwsPDyyV//PjxWrt27U23mTVrlpo3b16ubVSE6dOna+rUqYqNjVV+fr7q1KmjWbNmqWnTpnfU7urVq/W3v/1NgwcPVsOGDe9SbwEAAAAAAAAAAAAAAAAA5Y3pyG/Tzz//rJudMkdHR4WGhlZYf06dOqX8/JtPwxoSEiJX1/IZvv7cuXO6fPnm0wxXrVpVHh4e5doG7gzTkVcspiO/PzAdecVhOvKKxXTkFYvpyCsO05FXLKYjr1hMR15xmI68YjEdecViOvKKw3TkFYvpyCsW05FXHKYjr1hMR16xmI684jAdecViOvKKxXTkAHBvYjry/w5MR45bqlGjhukulBAUFGQ039/fX/7+/sbbAAAAAAAAAAAAAAAAAACgohn6G0wAAAAAAAAAAAAAAAAAAIDfNoowAQAAAAAAAAAAAAAAAAAAyoDpyAEAAAAAAAAAAAAAAAAAv2kWm+ke4H7FSJgAAAAAAAAAAAAAAAAAAABlQBEmAAAAAAAAAAAAAAAAAABAGVCECQAAAAAAAAAAAAAAAAAAUAbOpjsAwDyfogtGcnMdKhvJlSQPa76xbDmYqX93P/dvI7mSZHPzMZJrdfM2kitJ9ZwvGMm1OvkayZUkm4OHkdw8FzPXlyRdLLAYyw7OO2ckt8AzwEiuJF3MN3O+A12LjORK0hWvICO5zo4ORnIlycVaaCS3cv55I7mm5br7G8n1LLpiJFeSwm0XjeTaCryM5EpSjnMlM8GOnmZyJXlbcozkVis2c31J0s85Zu4D/dydjORKUnD+cWPZDhYzn1e/5NY2kitJVdzNXGNOl08byZUkn/yjRnIjHM393bzDpUtGci2Vgo3kSpLVu6qx7FBT17eTi5lcSVZD9yXV3M0ds1NRrpFcm9yM5EqSu7OZZ8oci6uRXEnyMXT/abOZ+2c+m6OZ7wIlqeqFfxnJLQ6oZSRXkrItZs63v8zc90qSxdHdTK6DudeVt6HvxXzzTxrJlaRTHtWNZZu6O7g0qKuhZKnO3JXGsgEAuNcxEiYAAAAAAAAAAAAAAAAAAEAZUIQJAAAAAAAAAAAAAAAAAABQBkxHDgAAAAAAAAAAAAAAAAD4TbPYbKa7gPsUI2ECAAAAAAAAAAAAAAAAAACUAUWYAAAAAAAAAAAAAAAAAAAAZUARJgAAAAAAAAAAAAAAAAAAQBlQhAkAAAAAAAAAAAAAAAAAAFAGFGECAAAAAAAAAAAAAAAAAACUwT1XhLlhwwZ169ZNUVFRioqKUqdOnbRixYoS27Rs2VJz5swptz60bNlSERERN/yvV69ed9R+UVGRlixZctv7FRcXKzk5WS+++KKioqIUExOjPn366Lvvvrutdmw2m9auXavs7OxS75Obm6sJEyaoWbNmatSokXr27Knt27ff7iFIktauXasePXqoSZMmio6OVvfu3fXZZ5/ddjtff/21Dhw4UKY+mGS1WvXhhx+qTZs2aty4sZ577jmlp6eb7hYAAAAAAAAAAAAAAAAA3HecTXfgblq1apUmTpyoUaNGqUmTJrLZbPruu+80adIknT17VoMGDbJv5+bmVq79sFgskqQdO3Zo8ODBSk9PV0hIiCTJxcXljtr/5JNPNGXKFMXGxpZ6n8LCQvXp00e//PKLBg8erKioKOXn52v16tWKi4vTlClT9MILL5SqrW3btuntt9/Wpk2bSp0/evRoZWVlKSkpSYGBgUpOTlZcXJw2btyooKCgUrVhs9k0bNgwfffddxo8eLCaNm0qBwcHffHFF3rjjTd06NAhvfbaa6Vq6/jx4xowYIBSUlJUp06dUh/Hf4O//OUvWrx4sf70pz/p4Ycf1vfff68//elPcnZ21h/+8AfT3QMAAAAAAAAAAAAAAACA+8Y9VYSZmpqqzp07q2vXrvZlYWFhOnnypFJSUuxFmP7+/uXaj/9s39fX174sMDDwrrRvs9lue5/Zs2dr7969+vTTTxUcHGxfPnr0aOXm5mry5Ml69tln5eXlddfzi4uL5e7urnHjxik6OlqSNGzYMC1fvlzbt29Xu3btStXOihUr9MUXX2jVqlV66KGH7MtfffVV2Ww2vf/+++rYsaOqVat214/hv8mKFSsUFxdnP281atTQrl27tGrVKoowAQAAAAAAAAAAAAAAcF+y/HbLgfAbd09NR+7o6Kjt27fr4sWLJZbHx8crLS3N/vN/Tkc+Z84cxcbGKiUlRc2aNVPjxo01fPhwnTlzRgkJCYqKilKLFi20du3au9ZPm82mBQsWqFWrVmrUqJE6duyo9evX29ePHz9eUVFROn78uCQpLy9Pbdu21YABA7RmzRqNHDlSkhQREaGtW7feMq+oqEjp6enq3LlziQLMq15//XV9+OGHcnd3lyT961//0muvvaaYmBjVr19fzz77rJKTkyVJW7duVe/evSVJrVq10po1a26Z7+zsrClTpujxxx+XJF26dEkffPCBvLy81Lhx41vuf1VqaqpatmxZogDzqt69e2vJkiX2QteTJ0/qzTff1BNPPKGHH35YLVq00MyZM2W1WnXs2DG1atXKvt/Va+HgwYOKj49XVFSUmjVrpjfeeENnzpyxZ1gsFs2cOdM+pfrgwYM1adKkEtPLHzx4UAMGDFBMTIweffRRDRkyRCdOnLCv79Wrl0aNGqUuXbooOjpac+fOVUREhLZt21bieIYNG2YvGv5PVqtVU6dOve6opf/3ugcAAAAAAAAAAAAAAAAAlK97qggzPj5eWVlZat68ufr166f58+crMzNTPj4+ql279g33y8jIUEZGhpKTk5WUlKSNGzfq+eefV2RkpFavXq3mzZtr7NixOn/+/F3p58yZM5WamqoxY8Zow4YN6t27t959910tX75ckpSQkKCgoCCNHTtWkjRlyhRduXJFU6ZMUfv27TVq1ChJ0jfffKOoqKhb5h09elQXLly4YcFj1apV1bBhQzk5OSkvL099+vSRp6enUlNT9emnn6pdu3aaPHmysrKyFBUVZS9aTE9PV/v27W/r2OfNm6cmTZpo8eLFGj16tH2K9lspLCzU/v37b3gM3t7eatKkiVxdXSVJ/fv317lz57Rw4UJ9/vnn6tu3r+bNm6fNmzcrJCRE6enpkn4two2Li9OpU6fUo0cPhYaGatWqVZo3b55ycnLUvXt35ebmSpKmT5+utLQ0jR07VmvWrFHVqlW1dOlSex+OHz+ubt26ydXVVcnJyVq8eLGys7P18ssvKycnx77dmjVr1Lt3b3300Ufq2bOnHnroIa1bt86+/vLly9q0aZNefPHFa47T0dFRjz/+eIli2mPHjunTTz9Vs2bNSnUuAQAAAAAAAAAAAAAAAAB3xz1VhNmmTRulpaWpdevW2r17t2bMmKEuXbqobdu2+uGHH264n9Vq1cSJExUeHq6nnnpKkZGRCgsLU58+fRQWFqbY2FgVFhbqyJEjd9zH3NxcLVmyRCNGjNDTTz+tGjVqqFOnToqNjdXChQslSe7u7kpMTNT333+vUaNGKT09XYmJifLz85O7u7t8fHwkSYGBgfaiw5u5OkLi1anRbyYvL89eFBoeHq6aNWvaR2Tct2+fXF1dS0yxfnX0zNJq166d1q1bp/79+2vMmDH6+uuvS7XfhQsXSn0M+fn56tixoyZMmKDIyEiFhoaqV69eqlq1qvbt2ycnJyf7lPG+vr7y8vLSRx99pKpVq2rs2LEKDw9X/fr1lZSUpLNnz+rzzz9XXl6eUlNTNXToULVu3Vrh4eF65513SozKmZqaKk9PT02fPl0PPvigGjZsqNmzZys7O7vESKeRkZH6/e9/r7p168rPz0+dOnXSxo0bVVBQIEn67LPP5OPjo+bNm9/yWM+cOaN+/fopICBAr776aqnOJQAAAAAAAAAAAAAAAADg7nA23YG7rWHDhkpMTJTNZtP+/fu1ZcsWpaSkKD4+Xl9++aUCAgKu2ScgIECVKlWy/+zh4VFihEY3NzdJshfJ3YkDBw6ooKBAI0aMsE8rLknFxcUqLCxUfn6+3N3d1aBBA/Xv31/vv/++XnnlFTVt2rTMmVcLDq8WMt5q2x49euivf/2r9u7dqyNHjigrK0vSr8Wqd6pmzZqSfi1E3LNnjxYvXqynn376lvtVrlxZDg4OpRqN1N3dXS+//LI+//xzJScn68iRI9q7d69Onz59w2P46aefdPDgwWtGFi0oKNDBgwd18OBB5efnXzMS56OPPqq9e/dKkvbv36/69euXKIwNCAhQ7dq1tW/fvmvOwVW///3vNW3aNG3atEnt27fX2rVr1aFDBzk73/zl+e9//1v9+vVTUVGRli5dWqoCVQAAAAAAAAAAAAAAAADA3XPPFGGePHlSCxYsUL9+/RQUFCQHBwdFREQoIiJCrVq1Uvv27bVt2za1bdv2mn1dXFyuWeboWD6DhNpsNklSUlKSwsLCrln/nwV8e/bskbOzs7Zu3arCwsJSjXp5PaGhoapSpYp27Nhx3enDDx8+rPHjx2vEiBEKCAhQ165d5efnp1atWunxxx9XgwYN1KJFizJlS1JOTo6++eYbPfHEEyWKXevWravNmzeXqg1XV1fVr19fO3fuvGHGwIED9eqrr6pRo0bq2bOn8vLy1K5dO3Xs2FHvvPOOevbsecP2rVarmjZtqnHjxl2zzsfHR6dPn5b0v7+/67HZbHJwcLhmucViKXGN/d/RQ319ffXMM89o/fr1atCggXbs2KHx48ffMEeSfvjhB7366qsKDAzU0qVLSz2tOwAAAAAAAAAAAAAAAADg7rlnpiN3dXVVWlpaiWmfr/L29pYkValSpaK7dY2wsDA5OzvrxIkTqlmzpv2/LVu2aOHChfbizxUrVujbb7/VwoULdfLkSc2aNcvexvUK/W7G0dFRnTt31po1a3Tq1Klr1n/44YfauXOnqlWrpg0bNujChQtasWKFXnvtNT377LP26cyvFiDebn5xcbGGDRumL774osTyzMxM1alTp9TtdO3aVX/729/0008/XbNu6dKl+uc//6lq1arp73//u/bs2aOlS5dqyJAhat++vby9vZWdnX3DY6hbt64OHjyokJAQ++/E19dXkydP1v79+1WzZk25u7tfUwSamZlp//969eopMzNThYWF9mVnz57VkSNHFB4eftNj69Spk7799lt9/PHHatCggerWrXvDbTMzM9W3b1/VrVtXqampFGACAAAAAAAAAAAAAAAAgCH3TBGmv7+/+vbtq6SkJM2cOVNZWVk6evSovv76aw0aNEgxMTGKjo423U35+Pioe/fuSkpK0rp163T06FGtXbtWiYmJ9iLRI0eOaNq0aRo0aJCaNm2q0aNHa9GiRdq2bZskydPTU5L0448/Kj8/v1S5AwYMUM2aNdW9e3etW7dOP//8s3bv3q3Ro0dr9erVmjBhgry9vRUcHKy8vDx99tlnOnHihL755hsNHz5ckuzFhVfz9+7dqytXrtwyu3LlyurSpYtmzpypLVu26N///rcmT56sXbt26dVXXy31uevcubN+97vfqU+fPlq+fLkOHz6svXv3avr06Zo9e7aGDx+u0NBQBQcHS5LWr1+v48ePKyMjQ6+99pqKioquOYb9+/fr8uXL6tGjhy5fvqzhw4crKytLe/fu1RtvvKHMzEzVrVtXHh4e6tWrl2bPnq2vvvpKhw4d0vTp00sUZb700kvKycnRm2++qb179yozM1Ovv/66/Pz89Nxzz9302J544glVqVJFCxYs0IsvvnjD7YqLi/Xmm28qICBAU6dOVWFhoc6cOaMzZ87o3LlzpT6XAAAAAAAAAAAAAAAAAIA7d89MRy5JQ4cOVa1atbRy5UotX75c+fn5CgkJUfv27dW/f3/T3bMbOXKk/P39NXv2bJ0+fVrBwcEaNGiQ+vXrJ4vFooSEBNWuXVt9+/aVJHXo0EF//etfNWLECK1fv15NmzZVo0aN1L17dyUmJqpdu3a3zPTw8NCyZcu0aNEiLViwQCdOnJCbm5sefvhhJScn67HHHpMktW3bVnv27NG0adOUk5OjatWqqUuXLtq0aZMyMzP10ksvqV69emrRooWGDh2q4cOHKy4u7pb5Y8aMkZ+fn959912dPXtWDz/8sJYsWaL69euX+rw5Ojrq/fff17Jly5Senq4ZM2bI2dlZderU0Zw5c/TMM89Ikho2bKiRI0dqyZIlSkpKUlBQkNq3b6+QkBDt2rVLkuTn56dOnTrpvffe05EjRzRmzBgtW7ZMM2bMUI8ePeTk5KTGjRsrOTlZAQEBkqTXX39dRUVFGjNmjPLy8vT000+rVatWKigokPTrtO9Lly7V9OnT1a1bN7m6uurJJ59UYmJiiWnYb3RsHTp00OLFi29asJmZmakjR45Ikv14r6pWrVqpp3cHAAAAAAAAAAAAAAAA7iWW/3+GXKCiOdhsXH1AaXz55Zd69NFH5e/vb18WFxen4OBgTZ48+Y7bHzlypIqKijR9+vQ7but2FZ47UeGZkpTrWtlIriR5WEs3imx5cLAU3nqjcuB4JdtIriTZ3HyM5FrdvI3kSpJjQY6RXKuHr5FcSZKDmQG28w3+TcnFAoux7GBdMpJb4O5nJFeSLuabOd+BruZ+z3lyMZLr7OhgJFeSXKxmPicd8i8byTUt193/1huVA09LrpFcSXLIu2gk1+bmZSRXknKcb/5HYfcib4uZezEVm3kPk6SfbWbuA/3cnYzkSpLv5aPGsk091/3iVdtIriRVcTdzf+B0+bSRXElyzDdzzy1Hc5MXOeSZOWZLpWAjuZJk9alqLNvR1PXtZOY5Q5Ks7mbuSyzO7kZyJcmpyMy9r0OhuXvuAs8AI7mFFnP/3OVj6P7T5mjuezGbi4exbJdT+4zkFgfUMpIrSecsZt67/Z2KjORK5t67TRZuuBr6Xszp0kkjuZJ0yqO6sWwXQ7fdl0b3MRMsqc7clcayAaCiTPWqa7oLkPT2lX+Z7kKFu6dGwgTK08KFC5WamqqEhAR5e3tr06ZN+v7777Vo0aI7avfbb7/VgQMH9Mknn2j58uV3qbcAAAAAAAAAAAAAAAAAgPJGEeZtio6OlsVy49GQ/Pz8KnRK6AEDBmjr1q033WbVqlUKDw8vl/zx48dr7dq1N91m1qxZat68ebm2URGmT5+uqVOnKjY2Vvn5+apTp45mzZqlpk2b3lG7q1ev1t/+9jcNHjxYDRs2vEu9BQAAAAAAAAAAAAAAAACUN4owb9OaNWt0sxncHSt4uqA//elPys+/+bTKISEh5ZY/aNAgvfLKKzfdpmrVm0/pczfaqAjVq1fX3Llz73q7f/7zn+96mwAAAAAAAAAAAAAAAACA8kcR5m2qUaOG6S6UEBQUZDTf399f/v7+xtsAAAAAAAAAAAAAAAAAAKCiVeywjQAAAAAAAAAAAAAAAAAAAPcIRsIEAAAAAAAAAAAAAAAAAPymWWyme4D7FSNhAgAAAAAAAAAAAAAAAAAAlAFFmAAAAAAAAAAAAAAAAAAAAGVAESYAAAAAAAAAAAAAAAAAAEAZOJvuAADzij38jeR65p0zkitJBe5+xrJPFbgYyXXx8DaSK0mFFpuRXI9iByO5khRktRjJdSjKM5IrSeccfYzkujiaub4kKdgp31j2ZcfKZoINvZ4lKchi5nPD4hhgJFeSCovMnG+ruV+zcqxmHlF8vasYyZUkm8Hz7WEtMpJb6OJlJFeSXC2FRnLzXH2N5EqSh5OZeyJT94CSdCTPw0huTVcjsZKk2hcOGsm1OAcbyZWk/Mo1jGW72IqN5AblnDGSK0mnHaoayc1xMHcv5u4daCQ32M3M86Qkna9k5l7Mv+i8kVxJOm7uMVrVvMxc3w4FOUZyJelMkZlr7IEzPxrJlSSLoWeNrGJz339GWk4ayXU1+FxndTbzvZhV5r7/dJS5+/1sv7pGcv1yTxvJlSR/T0OvaUcnM7mSrIa+MHFyMPe6MvUlUaFfTSO5kuRlsRrL9nAwc99dGGDuO6JLi8caya3UZ7yRXAAAKhIjYQIAAAAAAAAAAAAAAAAAAJQBRZgAAAAAAAAAAAAAAAAAAABlQBEmAAAAAAAAAAAAAAAAAABAGTib7gAAAAAAAAAAAAAAAAAAAHfCYrOZ7gLuU4yECQAAAAAAAAAAAAAAAAAAUAYUYQIAAAAAAAAAAAAAAAAAAJQBRZgAAAAAAAAAAAAAAAAAAABlQBEmAAAAAAAAAAAAAAAAAABAGVCECQAAAAAAAAAAAAAAAAAAUAb3XBHmhg0b1K1bN0VFRSkqKkqdOnXSihUrSmzTsmVLzZkzp9z60LJlS0VERNzwv169et1R+0VFRVqyZMlt71dcXKzk5GS9+OKLioqKUkxMjPr06aPvvvvuttqx2Wxau3atsrOzS71Pbm6uJkyYoGbNmqlRo0bq2bOntm/ffruHIElau3atevTooSZNmig6Olrdu3fXZ599dtvtfP311zpw4ECZ+mCSxWLR7Nmz9fTTT6thw4Z68cUXtXnzZtPdAgAAAAAAAAAAAAAAAID7jrPpDtxNq1at0sSJEzVq1Cg1adJENptN3333nSZNmqSzZ89q0KBB9u3c3NzKtR8Wi0WStGPHDg0ePFjp6ekKCQmRJLm4uNxR+5988ommTJmi2NjYUu9TWFioPn366JdfftHgwYMVFRWl/Px8rV69WnFxcZoyZYpeeOGFUrW1bds2vf3229q0aVOp80ePHq2srCwlJSUpMDBQycnJiouL08aNGxUUFFSqNmw2m4YNG6bvvvtOgwcPVtOmTeXg4KAvvvhCb7zxhg4dOqTXXnutVG0dP35cAwYMUEpKiurUqVPq4/hvMHPmTK1Zs0ZTp05V7dq19cknn2jQoEFKS0tTgwYNTHcPAAAAAAAAAAAAAAAAAO4b91QRZmpqqjp37qyuXbval4WFhenkyZNKSUmxF2H6+/uXaz/+s31fX1/7ssDAwLvSvs1mu+19Zs+erb179+rTTz9VcHCwffno0aOVm5uryZMn69lnn5WXl9ddzy8uLpa7u7vGjRun6OhoSdKwYcO0fPlybd++Xe3atStVOytWrNAXX3yhVatW6aGHHrIvf/XVV2Wz2fT++++rY8eOqlat2l0/hv8mxcXFGj16tJo3by7p1+NftGiRtm7dShEmAAAAAAAAAAAAAAAA7ktW0x3Afeuemo7c0dFR27dv18WLF0ssj4+PV1pamv3n/5yOfM6cOYqNjVVKSoqaNWumxo0ba/jw4Tpz5owSEhIUFRWlFi1aaO3atXetnzabTQsWLFCrVq3UqFEjdezYUevXr7evHz9+vKKionT8+HFJUl5entq2basBAwZozZo1GjlypCQpIiJCW7duvWVeUVGR0tPT1blz5xIFmFe9/vrr+vDDD+Xu7i5J+te//qXXXntNMTExql+/vp599lklJydLkrZu3arevXtLklq1aqU1a9bcMt/Z2VlTpkzR448/Lkm6dOmSPvjgA3l5ealx48a33P+q1NRUtWzZskQB5lW9e/fWkiVL7IWuJ0+e1JtvvqknnnhCDz/8sFq0aKGZM2fKarXq2LFjatWqlX2/q9fCwYMHFR8fr6ioKDVr1kxvvPGGzpw5Y8+wWCyaOXOmfUr1wYMHa9KkSSWmlz948KAGDBigmJgYPfrooxoyZIhOnDhhX9+rVy+NGjVKXbp0UXR0tObOnauIiAht27atxPEMGzbMXjT8f7399tt67rnnJP16bSxZskR5eXmKiYkp9bkEAAAAAAAAAAAAAAAAANy5e6oIMz4+XllZWWrevLn69eun+fPnKzMzUz4+Pqpdu/YN98vIyFBGRoaSk5OVlJSkjRs36vnnn1dkZKRWr16t5s2ba+zYsTp//vxd6efMmTOVmpqqMWPGaMOGDerdu7feffddLV++XJKUkJCgoKAgjR07VpI0ZcoUXblyRVOmTFH79u01atQoSdI333yjqKioW+YdPXpUFy5cuGHBY9WqVdWwYUM5OTkpLy9Pffr0kaenp1JTU/Xpp5+qXbt2mjx5srKyshQVFWUvWkxPT1f79u1v69jnzZunJk2aaPHixRo9erR9ivZbKSws1P79+294DN7e3mrSpIlcXV0lSf3799e5c+e0cOFCff755+rbt6/mzZunzZs3KyQkROnp6ZJ+LcKNi4vTqVOn1KNHD4WGhmrVqlWaN2+ecnJy1L17d+Xm5kqSpk+frrS0NI0dO1Zr1qxR1apVtXTpUnsfjh8/rm7dusnV1VXJyclavHixsrOz9fLLLysnJ8e+3Zo1a9S7d2999NFH6tmzpx566CGtW7fOvv7y5cvatGmTXnzxxZuek/Xr1ysqKkpTpkzRgAEDGAUTAAAAAAAAAAAAAAAAACrYPVWE2aZNG6Wlpal169bavXu3ZsyYoS5duqht27b64Ycfbrif1WrVxIkTFR4erqeeekqRkZEKCwtTnz59FBYWptjYWBUWFurIkSN33Mfc3FwtWbJEI0aM0NNPP60aNWqoU6dOio2N1cKFCyVJ7u7uSkxM1Pfff69Ro0YpPT1diYmJ8vPzk7u7u3x8fCRJgYGB9qLDm7k6MujVqdFvJi8vz14UGh4erpo1a9pHZNy3b59cXV1LTLF+dfTM0mrXrp3WrVun/v37a8yYMfr6669Ltd+FCxdKfQz5+fnq2LGjJkyYoMjISIWGhqpXr16qWrWq9u3bJycnJ/uU8b6+vvLy8tJHH32kqlWrauzYsQoPD1f9+vWVlJSks2fP6vPPP1deXp5SU1M1dOhQtW7dWuHh4XrnnXdKjMqZmpoqT09PTZ8+XQ8++KAaNmyo2bNnKzs7u8RIp5GRkfr973+vunXrys/PT506ddLGjRtVUFAgSfrss8/k4+Njn278Rpo0aaJ169bp7bff1v/8z/8oNTW1VOcSAAAAAAAAAAAAAAAAAHB3OJvuwN3WsGFDJSYmymazaf/+/dqyZYtSUlIUHx+vL7/8UgEBAdfsExAQoEqVKtl/9vDwKDFCo5ubmyTZi+TuxIEDB1RQUKARI0bYpxWXpOLiYhUWFio/P1/u7u5q0KCB+vfvr/fff1+vvPKKmjZtWubMqwWHVwsZb7Vtjx499Ne//lV79+7VkSNHlJWVJenXYtU7VbNmTUm/FiLu2bNHixcv1tNPP33L/SpXriwHB4dSjUbq7u6ul19+WZ9//rmSk5N15MgR7d27V6dPn77hMfz00086ePDgNSOLFhQU6ODBgzp48KDy8/OvGYnz0Ucf1d69eyVJ+/fvV/369UsUxgYEBKh27drat2/fNefgqt///veaNm2aNm3apPbt22vt2rXq0KGDnJ1v/vIMCQlRSEiIHnzwQR0+fFgLFy5Ujx49bnl+AAAAAAAAAAAAAAAAAAB3xz0zEubJkyc1YcIEnTp1SpLk4OCgiIgI9evXT8nJybpy5Yq2bdt23X1dXFyuWeboWD6nxmazSZKSkpK0bt06+3+ffPKJvvjiixIFfHv27JGzs7O2bt2qwsLCMmeGhoaqSpUq2rFjx3XXHz58WHFxcdq3b5/Onj2rDh06KC0tTVWqVFH37t21Zs2aMmdLUk5Ojj7//HNdunSpxPK6devaf1+34urqqvr162vnzp03zHjllVf0/fffKy8vT927d9f//M//yNvbWx07dtTy5csVHBx8w/atVquaNm1a4neybt06bdy4UX/84x/tBZFXf3/XY7PZ5ODgcM1yi8VS4hr7v6OH+vr66plnntH69et19OhR7dix44ZTkRcVFemrr77SL7/8UmJ5vXr1Sn0uAQAAAAAAAAAAAAAAAAB3xz1ThOnq6qq0tLQS0z5f5e3tLUmqUqVKRXfrGmFhYXJ2dtaJEydUs2ZN+39btmzRwoUL7cWfK1as0LfffquFCxfq5MmTmjVrlr2N6xX63Yyjo6M6d+6sNWvWXLdQ78MPP9TOnTtVrVo1bdiwQRcuXNCKFSv02muv6dlnn7VPZ361APF284uLizVs2DB98cUXJZZnZmaqTp06pW6na9eu+tvf/qaffvrpmnVLly7VP//5T1WrVk1///vftWfPHi1dulRDhgxR+/bt5e3trezs7BseQ926dXXw4EGFhITYfye+vr6aPHmy9u/fr5o1a8rd3f2aItDMzEz7/9erV0+ZmZklCmbPnj2rI0eOKDw8/KbH1qlTJ3377bf6+OOP1aBBA9WtW/e62zk5OWn06NFauXJlieW7du26rXMJAAAAAAAAAAAAAAAAALhz98x05P7+/urbt6+SkpKUk5Ojtm3bytvbWwcOHNAHH3ygmJgYRUdHm+6mfHx81L17dyUlJcnLy0uPPvqoMjIylJiYqPj4eEnSkSNHNG3aNA0aNEhNmzbV6NGjNWLECD311FNq0qSJPD09JUk//vij6tSpc83IitczYMAA/f3vf1f37t31+uuv65FHHtHFixe1YsUKrVmzRtOnT5e3t7eCg4OVl5enzz77TNHR0fr3v/+tKVOmSJK9uPBq/t69e+Xn5ycvL6+bZleuXFldunTRzJkzFRgYqNDQUK1YsUK7du3SihUrSn3uOnfurE2bNqlPnz4aMmSInnzySeXn5+uTTz7RwoULNXz4cIWGhtqnLF+/fr3atGmjX375RX/+859VVFR0zTHs379fDz30kHr06KG0tDQNHz5cAwcOlIODgxITE/XTTz+pbt268vDwUK9evTR79mwFBgYqPDxcq1ev1s6dO/XYY49Jkl566SV99NFHevPNN/Xaa6+psLBQ06ZNk5+fn5577rmbHtsTTzyhKlWqaMGCBXr77bdvuJ2jo6Pi4uI0b9481alTRw8//LC++OILbdiwQXPnzi31uQQAAAAAAAAAAAAAAADuJZabzHALlKd7pghTkoYOHapatWpp5cqVWr58ufLz8xUSEqL27durf//+prtnN3LkSPn7+2v27Nk6ffq0goODNWjQIPXr108Wi0UJCQmqXbu2+vbtK0nq0KGD/vrXv2rEiBFav369mjZtqkaNGql79+5KTExUu3btbpnp4eGhZcuWadGiRVqwYIFOnDghNzc3Pfzww0pOTrYXErZt21Z79uzRtGnTlJOTo2rVqqlLly7atGmTMjMz9dJLL6levXpq0aKFhg4dquHDhysuLu6W+WPGjJGfn5/effddnT17Vg8//LCWLFmi+vXrl/q8OTo66v3339eyZcuUnp6uGTNmyNnZWXXq1NGcOXP0zDPPSJIaNmyokSNHasmSJUpKSlJQUJDat2+vkJAQ7dq1S5Lk5+enTp066b333tORI0c0ZswYLVu2TDNmzFCPHj3k5OSkxo0bKzk5WQEBAZKk119/XUVFRRozZozy8vL09NNPq1WrViooKJD067TvS5cu1fTp09WtWze5urrqySefVGJioipVqnTLY+vQoYMWL158y4LN+Ph4ubm5adasWfrll18UFhamOXPmqFWrVqU+lwAAAAAAAAAAAAAAAACAO+dgs1ECDJTGl19+qUcffVT+/v72ZXFxcQoODtbkyZPvuP2RI0eqqKhI06dPv+O2blduXn6FZ0qSc945I7mSVODuZyz71JViI7kujg5GciWp0GLmo8bD2dwxBxWdMZJrc/UwkitJ5xx9jOSavLZ9rLnGsi87ehrLNqVS/lkjuRavACO5knSpyEyus8nPDKuZzwxfNycjuZJk8onMyWrmIityMPf3gK75543k5rmZu/90dTLzmjZ1DyhJpw3dc9d0zTOSK0lOF04YybX4BhvJlaRCN19j2S42M9eYY46Z+yFJOu1a1UhuTpHFSK4kuTs5GskNdjN3zOctZj6j/YvMfD5L0jGZey+pZuh37VCQYyRXkk47VjaS+8CFvUZyJcniXcVIblaxufvPSCcz3/taDZ1rSbI5mnn/tMrc87ujzN3vXyq0Gsn1yz9tJFeSrJ6GXtOO5r4vMfXdgaODudeVU7GZf6+zON961sXyUmgx83qWJA8HM/diZ94bbiRXkirVCjGT22e8kVwA96d33MNNdwGSJuQfNN2FCndPjYQJlKeFCxcqNTVVCQkJ8vb21qZNm/T9999r0aJF/x97dx5XY/r/D/zVokJJRfQxGIVK+4gaQ5YwZB1ZshcipuxjyzKWsRUSZgxClmTSYl9mMnyGjyUzyFAaDTHIvpT2un5/+HW+mizJOeea4fV8PDweus99rtd13+ec+9znPu9zXe/U7vHjx3HlyhXs2bMHW7duVVJviYiIiIiIiIiIiIiIiIiIiIiISNVYhPmWnJ2dUVj46l/FGBkZ4fDhw2rrj5+fH06dOvXadXbs2AELC9VUes+ZMwexsbGvXWf58uVwc3NTaRvqEBwcjIULF8Lb2xs5OTmoX78+li9fDldX13dqNzo6GkeOHEFAQADs7e2V1FsiIiIiIiIiIiIiIiIiIiIiIiJSNRZhvqWYmBi8bgZ3TU31TlM0e/Zs5OS8fmh6MzPVDSvu7++PwYMHv3YdU9PXT1eljDbU4aOPPsLKlSuV3u7SpUuV3iYRERERERERERERERERERERERGpHosw31KdOnVkd6GEGjVqSM03NjaGsbGx9DaIiIiIiIiIiIiIiIiIiIiIiIiI1E29wzYSEREREREREREREREREREREREREb0nOBImERERERERERERERERERERERER/asVCtk9oA8VR8IkIiIiIiIiIiIiIiIiIiIiIiIiIioHFmESEREREREREREREREREREREREREZUDizCJiIiIiIiIiIiIiIiIiIiIiIiIiMpBQwghZHeCiOS69zRLSm5BkbzDj0nBI2nZQqeStGxZNIoKpOSKChWl5AJAeo6GlFwdLTm5AGCgI+e3HTq5T6TkAoDQ0pGWna8t7/ktS6Gkt42s/CI5wfgwX1e5uoZScvUy70jJBYCiSkbSsmV5WlRBWrZBBTnvlVoZ8p5jooKelFyN3GdScgHgcSUzKbmGQs5nKwAo1NWXkquVmyklFwDuFsp5bsukqy3v99RVNPOl5Mo859Z+dF1K7g2d/0jJBQDjitpScmWecxvpyntd3c8ulJJbXUdOLgBAQ87+rpCeJCUXAISmnNdVgcnHUnIBIFNDznt0ocTrzVXz5VxvztA1lpILAE9y5R1LqleS87p6JvH9Sta7VRVJ16YAQDM3Q0puhpacz1YAkFMg5zhWTStXSi4A5Em8zq2bI+fYnacn71qgpoak62IFOVJyAUDXoKq0bCKSY5quhewuEID5uamyu6B2HAmTiIiIiIiIiIiIiIiIiIiIiIiIiKgcWIRJRERERERERERERERERERERERERFQOLMIkIiIiIiIiIiIiIiIiIiIiIiIiIioHbdkdICIiIiIiIiIiIiIiIiIiIiIiInoXhULI7gJ9oDgSJhERERERERERERERERERERERERFRObAIk4iIiIiIiIiIiIiIiIiIiIiIiIioHFiESURERERERERERERERERERERERERUDizCJCIiIiIiIiIiIiIiIiIiIiIiIiIqh/euCHP37t3o06cPnJyc4OTkBE9PT0RGRpZYp02bNlixYoXK+tCmTRtYWlq+8t/AgQPfqf38/Hxs3Ljxre9XUFCA8PBw9OjRA05OTnBxcYGPjw9OnDjxVu0IIRAbG4sHDx68dR8A4OHDh2jevHm5H4PY2Fj069cPTZo0gbOzM7y8vLB///63bufnn3/GlStXytWHf4qEhARYW1vL7gYREREREREREREREREREREREdEHSVt2B5Rpx44dmDdvHqZNm4YmTZpACIETJ07gm2++wf379+Hv769YT1dXV6X9KCwsBACcPXsWAQEBiIqKgpmZGQCgQoUK79T+nj17sGDBAnh7e5f5Pnl5efDx8cHt27cREBAAJycn5OTkIDo6GkOGDMGCBQvQvXv3MrWVkJCAKVOmID4+vlz9nzFjBu7du/fW9xNCYNy4cThx4gQCAgLg6uoKDQ0NHDp0CBMmTMDVq1cxatSoMrV18+ZN+Pn5YdOmTahfv/5b9+Wf4NSpU/D390dRUZHsrhAREREREREREREREREREREREX2Q3qsizIiICPTs2RO9e/dWLDM3N0d6ejo2bdqkKMI0NjZWaT9ebN/Q0FCxrHr16kppXwjx1vcJDQ1FcnIy9u7di5o1ayqWBwYGIisrC/Pnz0e7du1QuXJlleQX2759O65evVqufREZGYlDhw5hx44daNSokWL5yJEjIYTAqlWr0K1bN9SqVeuNbb3LNshWUFCAhQsXYtu2bbC0tMTFixdld4mIiIiIiIiIiIiIiIiIiIiISKrCf285EP3LvVfTkWtqauK3337DkydPSiz39fXF9u3bFX+/OB35ihUr4O3tjU2bNqF58+ZwdHTE+PHjce/ePUyaNAlOTk5o2bIlYmNjldZPIQTWrl0Ld3d3ODg4oFu3bti1a5fi9jlz5sDJyQk3b94EAGRnZ6NDhw7w8/NDTEwMpk6dCgCwtLTEqVOn3piXn5+PqKgo9OzZs0QBZrExY8Zg3bp10NPTAwD88ccfGDVqFFxcXGBra4t27dohPDwcwPPRFwcNGgQAcHd3R0xMTJm3++rVqwgODkZQUBB0dHTKfL9iERERaNOmTYkCzGKDBg3Cxo0bFcWd6enpmDhxIpo1awYbGxu0bNkSy5YtQ1FREf766y+4u7sr7lf8XEhNTYWvry+cnJzQvHlzTJgwocSInYWFhVi2bBmaN28OBwcHBAQE4JtvvikxvXxqair8/Pzg4uKCxo0bY/To0bh165bi9oEDB2LatGno1asXnJ2dsXLlSlhaWiIhIaHE9owbN05RNPx3WVlZ+P3337F+/XoMGDDgrfcjERERERERERERERERERERERERKcd7VYTp6+uLpKQkuLm5Yfjw4VizZg0SExNhYGCAevXqvfJ+Z86cwZkzZxAeHo6QkBAcPHgQnTt3hrW1NaKjo+Hm5oaZM2fi0aNHSunnsmXLEBERgenTp2P37t0YNGgQvv76a2zduhUAMGnSJNSoUQMzZ84EACxYsADPnj3DggUL4OHhgWnTpgEAjh07Bicnpzfm3bhxA48fP4ajo+NLbzc1NYW9vT20tLSQnZ0NHx8fVKpUCREREdi7dy86duyI+fPnIykpCU5OToqixaioKHh4eJRpm/Pz8zFhwgQMHToUNjY2ZbrPi/Ly8pCSkvLKbdDX10eTJk0UxZ0jRozAw4cPERYWhgMHDmDYsGFYvXo1Dh8+DDMzM0RFRQF4XoQ7ZMgQ3LlzB/369UPt2rWxY8cOrF69GpmZmfDy8kJWVhYAIDg4GNu3b8fMmTMRExMDU1NTbN68WdGHmzdvok+fPtDR0UF4eDg2bNiABw8eYMCAAcjMzFSsFxMTg0GDBmHbtm3o378/GjVqhLi4OMXtGRkZiI+PR48ePV66rVWqVEFkZCRcXFzeej8SERERERERERERERERERERERGR8rxXRZiff/45tm/fjvbt2+PChQtYsmQJevXqhQ4dOuDXX3995f2Kioowb948WFhYoFWrVrC2toa5uTl8fHxgbm4Ob29v5OXlIS0t7Z37mJWVhY0bN2Ly5Mlo3bo16tSpA09PT3h7eyMsLAwAoKenh6CgIJw8eRLTpk1DVFQUgoKCYGRkBD09PRgYGAAAqlevXqYRJYtHBi2eGv11srOzFUWhFhYWqFu3rmJExsuXL0NHR6fEFOvFo2e+SWhoKHR1deHr61um9f/u8ePHZd6GnJwcdOvWDXPnzoW1tTVq166NgQMHwtTUFJcvX4aWlpZiynhDQ0NUrlwZ27Ztg6mpKWbOnAkLCwvY2toiJCQE9+/fx4EDB5CdnY2IiAiMHTsW7du3h4WFBWbMmFFiVM6IiAhUqlQJwcHBsLKygr29PUJDQ/HgwYMSI51aW1ujS5cuaNCgAYyMjODp6YmDBw8iNzcXALB//34YGBjAzc2tXPuKiIiIiIiIiIiIiIiIiIiIiIiI1ENbdgeUzd7eHkFBQRBCICUlBUePHsWmTZvg6+uLH3/8ESYmJqXuY2JigipVqij+rlixIszMzBR/6+rqAoCiSO5dXLlyBbm5uZg8ebJiWnEAKCgoQF5eHnJycqCnpwc7OzuMGDECq1atwuDBg+Hq6lruzOKCw+JCxjet269fP+zbtw/JyclIS0tDUlISgOfFquVx+vRpbNu2DbGxsdDS0ipXG1WrVoWGhkaZRiPV09PDgAEDcODAAYSHhyMtLQ3Jycm4e/fuK7fh0qVLSE1NLTWyaG5uLlJTU5GamoqcnJxSI3E2btwYycnJAICUlBTY2tqWKIw1MTFBvXr1cPnyZcWyunXrlmijS5cuWLRoEeLj4+Hh4YHY2Fh07doV2trv3cuTiIiIiIiIiIiIiIiIiIiIiIjovfLeVHmlp6dj7dq1GD58OGrUqAENDQ1YWlrC0tIS7u7u8PDwQEJCAjp06FDqvhUqVCi1TFNTNYOECiEAACEhITA3Ny91+4sFfBcvXoS2tjZOnTqFvLy8Mo16+TK1a9dGtWrVcPbs2ZdOH37t2jXMmTMHkydPhomJCXr37g0jIyO4u7vj008/hZ2dHVq2bFmubACIjY1FVlYWunbtqliWnZ2N77//HuvXr8fZs2ff2IaOjg5sbW1x7ty5l96emZmJL7/8EiNHjoSDgwP69++P7OxsdOzYEd26dcOMGTPQv3//V7ZfVFQEV1dXzJo1q9RtBgYGuHv3LoD/e/xeRggBDQ2NUssLCwtLPMf+PnqooaEh2rZti127dsHOzg5nz57FnDlzXplDRERERERERERERERERERERERE/wzvzXTkOjo62L59e4lpn4vp6+sDAKpVq6bubpVibm4ObW1t3Lp1C3Xr1lX8O3r0KMLCwhTFn5GRkTh+/DjCwsKQnp6O5cuXK9p4WaHf62hqaqJnz56IiYnBnTt3St2+bt06nDt3DrVq1cLu3bvx+PFjREZGYtSoUWjXrp1iOvPiAsS3zZ84cSL279+PuLg4xT9TU1N4eXkhLi6uzO307t0bR44cwaVLl0rdtnnzZpw+fRq1atXCL7/8gosXL2Lz5s0YPXo0PDw8oK+vjwcPHrxyGxo0aIDU1FSYmZkpHhNDQ0PMnz8fKSkpqFu3LvT09EoVgSYmJir+37BhQyQmJiIvL0+x7P79+0hLS4OFhcVrt83T0xPHjx/Hzp07YWdnhwYNGpR5vxAREREREREREREREREREREREZEc700RprGxMYYNG4aQkBAsW7YMSUlJuHHjBn7++Wf4+/vDxcUFzs7OsrsJAwMDeHl5ISQkBHFxcbhx4wZiY2MRFBSkKBJNS0vDokWL4O/vD1dXVwQGBmL9+vVISEgAAFSqVAkA8PvvvyMnJ6dMuX5+fqhbt66i8PH69eu4cOECAgMDER0djblz50JfXx81a9ZEdnY29u/fj1u3buHYsWMYP348ACiKC4vzk5OT8ezZszdmm5iYlCg4rVu3LrS1tWFoaFhqau7X6dmzJ1q0aAEfHx9s3boV165dQ3JyMoKDgxEaGorx48ejdu3aqFmzJgBg165duHnzJs6cOYNRo0YhPz+/1DakpKQgIyMD/fr1Q0ZGBsaPH4+kpCQkJydjwoQJSExMRIMGDVCxYkUMHDgQoaGh+Omnn3D16lUEBweXKMrs27cvMjMzMXHiRCQnJyMxMRFjxoyBkZEROnXq9Npta9asGapVq4a1a9eiR48eZd4nREREREREREREREREREREREREJM97Mx05AIwdOxYff/wxfvjhB2zduhU5OTkwMzODh4cHRowYIbt7ClOnToWxsTFCQ0Nx9+5d1KxZE/7+/hg+fDgKCwsxadIk1KtXD8OGDQMAdO3aFfv27cPkyZOxa9cuuLq6wsHBAV5eXggKCkLHjh3fmFmxYkVs2bIF69evx9q1a3Hr1i3o6urCxsYG4eHhaNq0KQCgQ4cOuHjxIhYtWoTMzEzUqlULvXr1Qnx8PBITE9G3b180bNgQLVu2xNixYzF+/HgMGTJEpfurmKamJlatWoUtW7YgKioKS5Ysgba2NurXr48VK1agbdu2AAB7e3tMnToVGzduREhICGrUqAEPDw+YmZnh/PnzAAAjIyN4enpi8eLFSEtLw/Tp07FlyxYsWbIE/fr1g5aWFhwdHREeHg4TExMAwJgxY5Cfn4/p06cjOzsbrVu3hru7O3JzcwE8n/Z98+bNCA4ORp8+faCjo4PPPvsMQUFBqFKlyhu3rWvXrtiwYcMbCzaJiIiIiIiIiIiIiIiIiIiIiKikwv8/Qy6RumkIwWcfUVn8+OOPaNy4MYyNjRXLhgwZgpo1a2L+/Pnv3P7UqVORn5+P4ODgd27rbd17mqX2TAAoKJJ3+DEpeCQtW+hUkpYti0ZRgZRcUaGilFwASM/RkJKroyUnFwAMdOQMsK2T+0RKLgAILR1p2fna8p7fshRKetvIyi+SE4wP83WVq2soJVcv846UXAAoqmQkLVuWp0UVpGUbVJDzXqmVIe85JiroScnVyH3zzAmq8riSmZRcQyHnsxUAFOrqS8nVys2UkgsAdwvlPLdl0tWWN6lNFc18Kbkyz7m1H12XkntD5z9ScgHAuKKc3+zLPOc20pX3urqfXSglt7qOnFwAgIac/V0hPUlKLgAITTmvqwKTj6XkAkCmhpz36EKJ15ur5su53pyha/zmlVTkSa68Y0n1SnJeV88kvl/JereqIunaFABo5mZIyc3QkvPZCgByCuQcx6pp5UrJBYA8ide5dXPkHLvz9ORdC9TUkHRdrKBss3uqgq5BVWnZRCTHOO16srtAAJYVXJXdBbV7r0bCJFKlsLAwREREYNKkSdDX10d8fDxOnjyJ9evXv1O7x48fx5UrV7Bnzx5s3bpVSb0lIiIiIiIiIiIiIiIiIiIiIiIiVWMR5ltydnZGYeGrf91nZGSEw4cPq60/fn5+OHXq1GvX2bFjBywsLFSSP2fOHMTGxr52neXLl8PNzU2lbahDcHAwFi5cCG9vb+Tk5KB+/fpYvnw5XF1d36nd6OhoHDlyBAEBAbC3t1dSb4mIiIiIiIiIiIiIiIiIiIiIiEjVOB35W7p+/Tpet8s0NTVRu3ZttfXnzp07yMl5/fDdZmZm0NFRzdRNDx8+REbG66cDMDU1RcWKrx5KXhlt0LvhdOTqxenI1YfTkavXhzhtMqcjVy9OR64+nI5cvTgduXpxOnL14XTk6sXpyD8MnI5cvTgdufpwOnL14nTk6sXpyNWH05GrF6cjVy9OR64+nI5cvTgduXpxOnIi+hBwOvJ/Bk5HTm9Up04d2V0ooUaNGlLzjY2NYWz8bh/yldEGERERERERERERERERERERERERkbrJ+/kSEREREREREREREREREREREREREdG/GIswiYiIiIiIiIiIiIiIiIiIiIiIiIjKgdORExERERERERERERERERERERER0b9aoZDdA/pQcSRMIiIiIiIiIiIiIiIiIiIiIiIiIqJyYBEmEREREREREREREREREREREREREVE5cDpyIkLV7DtScoWegZRcAHiiYywt27AoU0puro68/a2tqSElt6BI3ljjZloZcoJFkZxcAMgqkBOrJ+/1XCnvsbTsQq2KUnIz8+Q9x4z0tKTkVtSWcwwDAL0/fpETbFpPTi6AitlPpOQWVTaRkvs8vFBadKaGnpRcfR15vwe8K+n9qkbFqlJyASBfS1dKblpOJSm5ANAw976UXFFBzmsKALSyH0vJ1Xz2QEouAFQz/lha9u0sOedEGhLnUxIVdKTkynyOFVUykpL7H818KbkAUKhZQUqusZa8bb71TM7nDADQ05ZzTpSvKef1DMi7VpNdw1ZKLgDIujylXyjnGiQA6FeQ8xmnqIKcYxgA/JVvKCW3ksTrn7UL7krLzsV/pOQai2dScgFAIy9LSu4zLVMpuQAg6xOlrpa8a4FVnt2Wkpsm8XH+OOOatOx7letIyTWCvGvsQkPOuW+RxOslOfu+k5Kr5zFSSi4REcnDkTCJiIiIiIiIiIiIiIiIiIiIiIiIiMqBRZhEREREREREREREREREREREREREROXAIkwiIiIiIiIiIiIiIiIiIiIiIiIionLQlt0BIiIiIiIiIiIiIiIiIiIiIiIiondRKITsLtAHiiNhEhERERERERERERERERERERERERGVA4swiYiIiIiIiIiIiIiIiIiIiIiIiIjKgUWYRERERERERERERERERERERERERETlwCJMIiIiIiIiIiIiIiIiIiIiIiIiIqJyYBEmEREREREREREREREREREREREREVE5vHdFmLt370afPn3g5OQEJycneHp6IjIyssQ6bdq0wYoVK1TWhzZt2sDS0vKV/wYOHPhO7efn52Pjxo1vfb+CggKEh4ejR48ecHJygouLC3x8fHDixIm3akcIgdjYWDx48OCt+wAADx8+RPPmzcv9GMTGxqJfv35o0qQJnJ2d4eXlhf379791Oz///DOuXLlSrj7IVFRUhHXr1uHzzz+Ho6MjOnXqhKioKNndIiIiIiIiIiIiIiIiIiIiIiIi+uBoy+6AMu3YsQPz5s3DtGnT0KRJEwghcOLECXzzzTe4f/8+/P39Fevp6uqqtB+FhYUAgLNnzyIgIABRUVEwMzMDAFSoUOGd2t+zZw8WLFgAb2/vMt8nLy8PPj4+uH37NgICAuDk5IScnBxER0djyJAhWLBgAbp3716mthISEjBlyhTEx8eXq/8zZszAvXv33vp+QgiMGzcOJ06cQEBAAFxdXaGhoYFDhw5hwoQJuHr1KkaNGlWmtm7evAk/Pz9s2rQJ9evXf+u+yPT9999jw4YNmD17NmxsbHDy5EnMnj0b2tra+OKLL2R3j4iIiIiIiIiIiIiIiIiIiIiI6IPxXhVhRkREoGfPnujdu7dimbm5OdLT07Fp0yZFEaaxsbFK+/Fi+4aGhopl1atXV0r7Qoi3vk9oaCiSk5Oxd+9e1KxZU7E8MDAQWVlZmD9/Ptq1a4fKlSurJL/Y9u3bcfXq1XLti8jISBw6dAg7duxAo0aNFMtHjhwJIQRWrVqFbt26oVatWm9s6122QbbIyEgMGTIEHTt2BADUqVMH58+fx44dO1iESUREREREREREREREREREREQfpMJ/bzkQ/cu9V9ORa2pq4rfffsOTJ09KLPf19cX27dsVf784HfmKFSvg7e2NTZs2oXnz5nB0dMT48eNx7949TJo0CU5OTmjZsiViY2OV1k8hBNauXQt3d3c4ODigW7du2LVrl+L2OXPmwMnJCTdv3gQAZGdno0OHDvDz80NMTAymTp0KALC0tMSpU6femJefn4+oqCj07NmzRAFmsTFjxmDdunXQ09MDAPzxxx8YNWoUXFxcYGtri3bt2iE8PBwAcOrUKQwaNAgA4O7ujpiYmDJv99WrVxEcHIygoCDo6OiU+X7FIiIi0KZNmxIFmMUGDRqEjRs3Koo709PTMXHiRDRr1gw2NjZo2bIlli1bhqKiIvz1119wd3dX3K/4uZCamgpfX184OTmhefPmmDBhQokROwsLC7Fs2TI0b94cDg4OCAgIwDfffFNievnU1FT4+fnBxcUFjRs3xujRo3Hr1i3F7QMHDsS0adPQq1cvODs7Y+XKlbC0tERCQkKJ7Rk3bpyiaPhFRUVFWLhw4UtHLf37856IiIiIiIiIiIiIiIiIiIiIiIhU670qwvT19UVSUhLc3NwwfPhwrFmzBomJiTAwMEC9evVeeb8zZ87gzJkzCA8PR0hICA4ePIjOnTvD2toa0dHRcHNzw8yZM/Ho0SOl9HPZsmWIiIjA9OnTsXv3bgwaNAhff/01tm7dCgCYNGkSatSogZkzZwIAFixYgGfPnmHBggXw8PDAtGnTAADHjh2Dk5PTG/Nu3LiBx48fw9HR8aW3m5qawt7eHlpaWsjOzoaPjw8qVaqEiIgI7N27Fx07dsT8+fORlJQEJycnRdFiVFQUPDw8yrTN+fn5mDBhAoYOHQobG5sy3edFeXl5SElJeeU26Ovro0mTJorizhEjRuDhw4cICwvDgQMHMGzYMKxevRqHDx+GmZkZoqKiADwvwh0yZAju3LmDfv36oXbt2tixYwdWr16NzMxMeHl5ISsrCwAQHByM7du3Y+bMmYiJiYGpqSk2b96s6MPNmzfRp08f6OjoIDw8HBs2bMCDBw8wYMAAZGZmKtaLiYnBoEGDsG3bNvTv3x+NGjVCXFyc4vaMjAzEx8ejR48epbZTU1MTn376aYli2r/++gt79+5F8+bN33q/EhERERERERERERERERERERERUfm9V0WYn3/+ObZv34727dvjwoULWLJkCXr16oUOHTrg119/feX9ioqKMG/ePFhYWKBVq1awtraGubk5fHx8YG5uDm9vb+Tl5SEtLe2d+5iVlYWNGzdi8uTJaN26NerUqQNPT094e3sjLCwMAKCnp4egoCCcPHkS06ZNQ1RUFIKCgmBkZAQ9PT0YGBgAAKpXr16mESWLR0gsnhr9dbKzsxVFoRYWFqhbt65iRMbLly9DR0enxBTrxaNnvkloaCh0dXXh6+tbpvX/7vHjx2XehpycHHTr1g1z586FtbU1ateujYEDB8LU1BSXL1+GlpaWYsp4Q0NDVK5cGdu2bYOpqSlmzpwJCwsL2NraIiQkBPfv38eBAweQnZ2NiIgIjB07Fu3bt4eFhQVmzJhRYlTOiIgIVKpUCcHBwbCysoK9vT1CQ0Px4MGDEiOdWltbo0uXLmjQoAGMjIzg6emJgwcPIjc3FwCwf/9+GBgYwM3N7Y3beu/ePQwfPhwmJiYYOXLk2+xSIiIiIiIiIiIiIiIiIiIiIiKif6XAwEBMmTLljev99ddfGDFiBD755BM0a9YMQUFBKCwsLLHO1q1b4e7uDnt7e/Tp0wcXLlx4q75ov9Xa/wL29vYICgqCEAIpKSk4evQoNm3aBF9fX/z4448wMTEpdR8TExNUqVJF8XfFihVhZmam+FtXVxcAFEVy7+LKlSvIzc3F5MmTFdOKA0BBQQHy8vKQk5MDPT092NnZYcSIEVi1ahUGDx4MV1fXcmcWFxwWFzK+ad1+/fph3759SE5ORlpaGpKSkgA8L1Ytj9OnT2Pbtm2IjY2FlpZWudqoWrUqNDQ0yjQaqZ6eHgYMGIADBw4gPDwcaWlpSE5Oxt27d1+5DZcuXUJqamqpkUVzc3ORmpqK1NRU5OTklBqJs3HjxkhOTgYApKSkwNbWtkRhrImJCerVq4fLly8rltWtW7dEG126dMGiRYsQHx8PDw8PxMbGomvXrtDWfv3L888//8Tw4cORn5+PzZs3l6lAlYiIiIiIiIiIiIiIiIiIiIiI6N+qsLAQwcHB2LFjB7744ovXrpufn4+hQ4eiXr16iIyMxPXr1xEYGAhdXV2MHj0aABAbG4ugoCDFgH9r1qzBsGHDsH//fkXd3Zu8N0WY6enpWLt2LYYPH44aNWpAQ0MDlpaWsLS0hLu7Ozw8PJCQkIAOHTqUum+FChVKLdPUVM0goUIIAEBISAjMzc1L3f5iAd/Fixehra2NU6dOIS8vr0yjXr5M7dq1Ua1aNZw9e/al04dfu3YNc+bMweTJk2FiYoLevXvDyMgI7u7u+PTTT2FnZ4eWLVuWKxt4/kTNyspC165dFcuys7Px/fffY/369Th79uwb29DR0YGtrS3OnTv30tszMzPx5ZdfYuTIkXBwcED//v2RnZ2Njh07olu3bpgxYwb69+//yvaLiorg6uqKWbNmlbrNwMAAd+/eBfB/j9/LCCGgoaFRanlhYWGJ59jfRw81NDRE27ZtsWvXLtjZ2eHs2bOYM2fOK3MA4Ndff8XIkSNRvXp1bN68uUTRMBERERERERERERERERERERER0fsmNTUVU6dOxY0bN/Cf//znjesfPHgQt27dQlRUFKpUqYKGDRviwYMHWLx4Mfz8/KCjo4PVq1djwIAB6NKlCwBg/vz5aNu2LXbs2IHhw4eXqV/vzXTkOjo62L59e4lpn4vp6+sDAKpVq6bubpVibm4ObW1t3Lp1C3Xr1lX8O3r0KMLCwhTFn5GRkTh+/DjCwsKQnp6O5cuXK9p4WaHf62hqaqJnz56IiYnBnTt3St2+bt06nDt3DrVq1cLu3bvx+PFjREZGYtSoUWjXrp1iOvPiAsS3zZ84cSL279+PuLg4xT9TU1N4eXkhLi6uzO307t0bR44cwaVLl0rdtnnzZpw+fRq1atXCL7/8gosXL2Lz5s0YPXo0PDw8oK+vjwcPHrxyGxo0aIDU1FSYmZkpHhNDQ0PMnz8fKSkpqFu3LvT09EoVgSYmJir+37BhQyQmJiIvL0+x7P79+0hLS4OFhcVrt83T0xPHjx/Hzp07YWdnhwYNGrxy3cTERAwbNgwNGjRAREQECzCJiIiIiIiIiIiIiIiIiIiIiOi9d/r0aVhbW2PPnj346KOP3rj+mTNnYGNjU2KWbFdXV2RmZiI5ORkPHjzAtWvXSsxSra2tDWdnZyQkJJS5X+/NSJjGxsYYNmwYQkJCkJmZiQ4dOkBfXx9XrlzBt99+CxcXFzg7O8vuJgwMDODl5YWQkBBUrlwZjRs3xpkzZxAUFARfX18AQFpaGhYtWgR/f3+4uroiMDAQkydPRqtWrdCkSRNUqlQJAPD777+jfv36pUZWfBk/Pz/88ssv8PLywpgxY/DJJ5/gyZMniIyMRExMDIKDg6Gvr4+aNWsiOzsb+/fvh7OzM/78808sWLAAABTFhcX5ycnJMDIyQuXKlV+bbWJiUmoaeG1tbRgaGpaamvt1evbsifj4ePj4+GD06NH47LPPkJOTgz179iAsLAzjx49H7dq1FVOW79q1C59//jlu376NpUuXIj8/v9Q2pKSkoFGjRujXrx+2b9+O8ePH48svv4SGhgaCgoJw6dIlNGjQABUrVsTAgQMRGhqK6tWrw8LCAtHR0Th37hyaNm0KAOjbty+2bduGiRMnYtSoUcjLy8OiRYtgZGSETp06vXbbmjVrhmrVqmHt2rWYMmXKK9crKCjAxIkTYWJigoULFyIvLw/37t0DAGhpaZV5CFwiIiIiIiIiIiIiIiIiIiIiIiJlc3d3f+3t8fHx5W67b9++b7V+eno6atasWWKZqakpAODWrVvQ0tICgFKD4JmamiI5ObnMOe9NESYAjB07Fh9//DF++OEHbN26FTk5OTAzM4OHhwdGjBghu3sKU6dOhbGxMUJDQ3H37l3UrFkT/v7+GD58OAoLCzFp0iTUq1cPw4YNAwB07doV+/btw+TJk7Fr1y64urrCwcEBXl5eCAoKQseOHd+YWbFiRWzZsgXr16/H2rVrcevWLejq6sLGxgbh4eGKQsIOHTrg4sWLWLRoETIzM1GrVi306tUL8fHxSExMRN++fdGwYUO0bNkSY8eOxfjx4zFkyBCV7q9impqaWLVqFbZs2YKoqCgsWbIE2traqF+/PlasWIG2bdsCAOzt7TF16lRs3LgRISEhqFGjBjw8PGBmZobz588DAIyMjODp6YnFixcjLS0N06dPx5YtW7BkyRL069cPWlpacHR0RHh4uKKAdMyYMcjPz8f06dORnZ2N1q1bw93dHbm5uQCeT/u+efNmBAcHo0+fPtDR0cFnn32GoKCgEtXUr9q2rl27YsOGDa8t2ExMTERaWhoAKLa3WK1atXD48OHy7VwiIiIiIiIiIiIiIiIiIiIion+x1eKa7C4Q3lyE+Sp//fXXa+977NgxVK9e/a3azMnJKVW3paurCwDIzc1FdnY2gOezcP99neKasLLQEMXzMxPRa/34449o3LhxidEmhwwZgpo1a2L+/Pnv3P7UqVORn5+P4ODgd27rbeXfuar2TAAQegZScgHgiUYladmGRZlScnN15O1vbU0NKbkFRfLe4nTzMuQEiyI5uQBQWCAlNktP3ijAlfIeS8vO1jWSkpuZJ+85ZqSnJSU3r1DeNuunHpMTbFpPTi4g7ThWVNnkzSupiNDQlJadqfHmUfVVoVIFedt8L0vO+1WNCnJyASBfS1dKbtqTfCm5ANBQ+7GUXFFBzmvqebic46fmswdScgGgwPhjadm3s+Tsbx0tecdPEz052TKfY9DWefM6KiA05f1uvrCCnOslWgU5UnIB4FaunM8ZAKCnLed1ZaAj71gi81qNLLI2Wb9QzjVIABAVKkrJLdKqICUXAG5nyjn3lfnZyiQ7XVp2bpX/SMnVkXXNF4BGXpaU3GeVTKXkAkClAjnHsTyJ36XoPr0lJTdNS97j/HHeX9Ky71WuIyXXSM7HDACA0JR37iuLxuENUnL1PEZKySUi+rfLz8/H9evXX3n7xx9/rBi5EgAGDhyIWrVqYeHCha+8j5+fH/T09BASEqJYlp2dDUdHR6xcuRJmZmbw9PTEvn37YGFhoVhn8eLFOHbsGHbt2lWmvr9XI2ESqVJYWBgiIiIwadIk6OvrIz4+HidPnsT69evfqd3jx4/jypUr2LNnD7Zu3aqk3hIREREREREREREREREREREREf07VKhQoUQhpDLUrFkTKSkpJZbdvXsXAFCjRg385z//USx7Mbt4duuyYhHmW3J2dkZhYeErbzcyMlLrlNB+fn44derUa9fZsWOH0p+gxebMmYPY2NjXrrN8+XK4ubmptA11CA4OxsKFC+Ht7Y2cnBzUr18fy5cvh6ur6zu1Gx0djSNHjiAgIAD29vZK6i0REREREREREREREREREREREdGHq0mTJoiLi0NmZib09fUBACdOnEDlypVhZWUFHR0d1KtXD6dOncKnn34KACgoKMCZM2fQr1+/MuewCPMtxcTE4HUzuGtqqnfqh9mzZyMn5/XT9ZiZmaks39/fH4MHD37tOqamrx/CXhltqMNHH32ElStXKr3dpUuXKr1NIiIiIiIiIiIiIiIiIiIiIiKiD0leXh6ePHkCQ0ND6OjooG3btggJCcHYsWMxceJE/PXXX1i2bBmGDBkCHR0dAMCQIUPwzTffoG7durCzs8OaNWuQk5ODnj17ljmXRZhvqU6dOrK7UEKNGjWk5hsbG8PY2Fh6G0RERERERERERERERERERERERPThOnv2LAYNGoRNmzbBxcUFurq6WLduHWbPno3evXvD0NAQ/fr1w6hRoxT36d27NzIyMhASEoLHjx/D1tYWGzZseKt6NhZhEhEREREREREREREREREREREREdG/xubNm0stc3FxweXLl0ssq1u3LtavX//atoYOHYqhQ4eWuy/qnTubiIiIiIiIiIiIiIiIiIiIiIiIiOg9wSJMIiIiIiIiIiIiIiIiIiIiIiIiIqJyYBEmEREREREREREREREREREREREREVE5sAiTiIiIiIiIiIiIiIiIiIiIiIiIiKgcNIQQQnYniEiu3GcZUnKfFmpJyQWAyhXk1aBr5z6VklukU1lKLgDcyiqSkqutqSElFwB0tORkG+rKe11l5ct5nIsknslcf5InLdtB87aU3DzjelJyZdLOfigt+0qevrRsWfR1Przficl6zwAAWZ8GTYSc808AENp6UnKfCh0puQAg6ylWWSNfTjAAjYJcKblCW1dKLiBvmx9ryPucYZRzV1q25oM0KbnCsIaUXAB4UqWulFyZ75P3swqk5FarpC0lF5D3+Ur3wzsFBABo5j2TkpuhWUlKLgDIekVn5Mm5ZgEABpI+41SQePzUzXkkJVcz+4mUXEDe9RLtnMdScgFAK/OetOxCAznnRBla8q7TVNb6AL/O1ZBz/CyQuKsrCDnnnygqlJMLuddLDCrIea+U+hwrkvOdRpHM6yWHN0jJLXzyQEouAFTuO11aNhHRh+wDvbxFRERERERERERERERERERERERERPRuWIRJRERERERERERERERERERERERERFQOLMIkIiIiIiIiIiIiIiIiIiIiIiIiIioHFmESEREREREREREREREREREREREREZUDizCJiIiIiIiIiIiIiIiIiIiIiIiIiMqBRZhEREREREREREREREREREREREREROXAIkwiIiIiIiIiIiIiIiIiIiIiIiIionJgESYRERERERERERERERERERERERERUTm8d0WYu3fvRp8+feDk5AQnJyd4enoiMjKyxDpt2rTBihUrVNaHNm3awNLS8pX/Bg4c+E7t5+fnY+PGjW99v4KCAoSHh6NHjx5wcnKCi4sLfHx8cOLEibdqRwiB2NhYPHjw4K37AAAPHz5E8+bNy/0YxMbGol+/fmjSpAmcnZ3h5eWF/fv3v3U7P//8M65cuVKuPshUWFiI0NBQtG7dGvb29ujRowcOHz4su1tEREREREREREREREREREREREQfHG3ZHVCmHTt2YN68eZg2bRqaNGkCIQROnDiBb775Bvfv34e/v79iPV1dXZX2o7CwEABw9uxZBAQEICoqCmZmZgCAChUqvFP7e/bswYIFC+Dt7V3m++Tl5cHHxwe3b99GQEAAnJyckJOTg+joaAwZMgQLFixA9+7dy9RWQkICpkyZgvj4+HL1f8aMGbh3795b308IgXHjxuHEiRMICAiAq6srNDQ0cOjQIUyYMAFXr17FqFGjytTWzZs34efnh02bNqF+/fpv3ReZli1bhpiYGCxcuBD16tXDnj174O/vj+3bt8POzk5294iIiIiIiIiIiIiIiIiIiIiIiD4Y71URZkREBHr27InevXsrlpmbmyM9PR2bNm1SFGEaGxurtB8vtm9oaKhYVr16daW0L4R46/uEhoYiOTkZe/fuRc2aNRXLAwMDkZWVhfnz56Ndu3aoXLmySvKLbd++HVevXi3XvoiMjMShQ4ewY8cONGrUSLF85MiREEJg1apV6NatG2rVqvXGtt5lG2QrKChAYGAg3NzcADzf/vXr1+PUqVMswiQiIiIiIiIiIiIiIiIiIiIiIlKj92o6ck1NTfz222948uRJieW+vr7Yvn274u8XpyNfsWIFvL29sWnTJjRv3hyOjo4YP3487t27h0mTJsHJyQktW7ZEbGys0vophMDatWvh7u4OBwcHdOvWDbt27VLcPmfOHDg5OeHmzZsAgOzsbHTo0AF+fn6IiYnB1KlTAQCWlpY4derUG/Py8/MRFRWFnj17lijALDZmzBisW7cOenp6AIA//vgDo0aNgouLC2xtbdGuXTuEh4cDAE6dOoVBgwYBANzd3RETE1Pm7b569SqCg4MRFBQEHR2dMt+vWEREBNq0aVOiALPYoEGDsHHjRkVxZ3p6OiZOnIhmzZrBxsYGLVu2xLJly1BUVIS//voL7u7uivsVPxdSU1Ph6+sLJycnNG/eHBMmTCgxYmdhYSGWLVuG5s2bw8HBAQEBAfjmm29KTC+fmpoKPz8/uLi4oHHjxhg9ejRu3bqluH3gwIGYNm0aevXqBWdnZ6xcuRKWlpZISEgosT3jxo1TFA3/3ZQpU9CpUycAz58bGzduRHZ2NlxcXN56nxIREREREREREREREREREREREVH5vVdFmL6+vkhKSoKbmxuGDx+ONWvWIDExEQYGBqhXr94r73fmzBmcOXMG4eHhCAkJwcGDB9G5c2dYW1sjOjoabm5umDlzJh49eqSUfi5btgwRERGYPn06du/ejUGDBuHrr7/G1q1bAQCTJk1CjRo1MHPmTADAggUL8OzZMyxYsAAeHh6YNm0aAODYsWNwcnJ6Y96NGzfw+PFjODo6vvR2U1NT2NvbQ0tLC9nZ2fDx8UGlSpUQERGBvXv3omPHjpg/fz6SkpLg5OSkKFqMioqCh4dHmbY5Pz8fEyZMwNChQ2FjY1Om+7woLy8PKSkpr9wGfX19NGnSRFHcOWLECDx8+BBhYWE4cOAAhg0bhtWrV+Pw4cMwMzNDVFQUgOdFuEOGDMGdO3fQr18/1K5dGzt27MDq1auRmZkJLy8vZGVlAQCCg4Oxfft2zJw5EzExMTA1NcXmzZsVfbh58yb69OkDHR0dhIeHY8OGDXjw4AEGDBiAzMxMxXoxMTEYNGgQtm3bhv79+6NRo0aIi4tT3J6RkYH4+Hj06NHjtftk165dcHJywoIFC+Dn58dRMImIiIiIiIiIiIiIiIiIiIiIiNTsvSrC/Pzzz7F9+3a0b98eFy5cwJIlS9CrVy906NABv/766yvvV1RUhHnz5sHCwgKtWrWCtbU1zM3N4ePjA3Nzc3h7eyMvLw9paWnv3MesrCxs3LgRkydPRuvWrVGnTh14enrC29sbYWFhAAA9PT0EBQXh5MmTmDZtGqKiohAUFAQjIyPo6enBwMAAAFC9evUyjShZPDJo8dTor5Odna0oCrWwsEDdunUVIzJevnwZOjo6JaZYLx49801CQ0Ohq6sLX1/fMq3/d48fPy7zNuTk5KBbt26YO3curK2tUbt2bQwcOBCmpqa4fPkytLS0FFPGGxoaonLlyti2bRtMTU0xc+ZMWFhYwNbWFiEhIbh//z4OHDiA7OxsREREYOzYsWjfvj0sLCwwY8aMEqNyRkREoFKlSggODoaVlRXs7e0RGhqKBw8elBjp1NraGl26dEGDBg1gZGQET09PHDx4ELm5uQCA/fv3w8DAQDHd+Ks0adIEcXFxmDJlCr777jtERES87W4lIiIiIiIiIiIiIiIiIiIiIiKid6AtuwPKZm9vj6CgIAghkJKSgqNHj2LTpk3w9fXFjz/+CBMTk1L3MTExQZUqVRR/V6xYEWZmZoq/dXV1AUBRJPcurly5gtzcXEyePFkxrTgAFBQUIC8vDzk5OdDT04OdnR1GjBiBVatWYfDgwXB1dS13ZnHBYXEh45vW7devH/bt24fk5GSkpaUhKSkJwPNi1fI4ffo0tm3bhtjYWGhpaZWrjapVq0JDQ6NMo5Hq6elhwIABOHDgAMLDw5GWlobk5GTcvXv3ldtw6dIlpKamlhpZNDc3F6mpqUhNTUVOTk6pkTgbN26M5ORkAEBKSgpsbW1LFMaamJigXr16uHz5smJZ3bp1S7TRpUsXLFq0CPHx8fDw8EBsbCy6du0Kbe3XvzzNzMxgZmYGKysrXLt2DWFhYejXr98b9w8REREREREREREREREREREREREpx3tThJmeno61a9di+PDhqFGjBjQ0NGBpaQlLS0u4u7vDw8MDCQkJ6NChQ6n7VqhQodQyTU3VDBIqhAAAhISEwNzcvNTtLxbwXbx4Edra2jh16hTy8vLKNOrly9SuXRvVqlXD2bNnXzp9+LVr1zBnzhxMnjwZJiYm6N27N4yMjODu7o5PP/0UdnZ2aNmyZbmyASA2NhZZWVno2rWrYll2dja+//57rF+/HmfPnn1jGzo6OrC1tcW5c+deentmZia+/PJLjBw5Eg4ODujfvz+ys7PRsWNHdOvWDTNmzED//v1f2X5RURFcXV0xa9asUrcZGBjg7t27AP7v8XsZIQQ0NDRKLS8sLCzxHPv76KGGhoZo27Ytdu3aBTs7O5w9exZz5sx5aUZ+fj6OHj0KGxubEoXCDRs2RHR09Cv7RkRERERERERERERERERERERERMr33kxHrqOjg+3bt5eY9rmYvr4+AKBatWrq7lYp5ubm0NbWxq1bt1C3bl3Fv6NHjyIsLExR/BkZGYnjx48jLCwM6enpWL58uaKNlxX6vY6mpiZ69uyJmJgY3Llzp9Tt69atw7lz51CrVi3s3r0bjx8/RmRkJEaNGoV27doppjMvLkB82/yJEydi//79iIuLU/wzNTWFl5cX4uLiytxO7969ceTIEVy6dKnUbZs3b8bp06dRq1Yt/PLLL7h48SI2b96M0aNHw8PDA/r6+njw4MErt6FBgwZITU2FmZmZ4jExNDTE/PnzkZKSgrp160JPT69UEWhiYqLi/w0bNkRiYiLy8vIUy+7fv4+0tDRYWFi8dts8PT1x/Phx7Ny5E3Z2dmjQoMFL19PS0kJgYCB++OGHEsvPnz+P+vXrvzaDiIiIiIiIiIiIiIiIiIiIiIiIlOu9KcI0NjbGsGHDEBISgmXLliEpKQk3btzAzz//DH9/f7i4uMDZ2Vl2N2FgYAAvLy+EhIQgLi4ON27cQGxsLIKCghRFomlpaVi0aBH8/f3h6uqKwMBArF+/HgkJCQCASpUqAQB+//135OTklCnXz88PdevWVRQ+Xr9+HRcuXEBgYCCio6Mxd+5c6Ovro2bNmsjOzsb+/ftx69YtHDt2DOPHjwcARXFhcX5ycjKePXv2xmwTE5MSBad169aFtrY2DA0NS03N/To9e/ZEixYt4OPjg61bt+LatWtITk5GcHAwQkNDMX78eNSuXRs1a9YEAOzatQs3b97EmTNnMGrUKOTn55fahpSUFGRkZKBfv37IyMjA+PHjkZSUhOTkZEyYMAGJiYlo0KABKlasiIEDByI0NBQ//fQTrl69iuDg4BJFmX379kVmZiYmTpyI5ORkJCYmYsyYMTAyMkKnTp1eu23NmjVDtWrVsHbtWvTo0eOV62lqamLIkCHYuHEj9u7di2vXrmHNmjXYvXs3AgICyrwviYiIiIiIiIiIiIiIiIiIiIiI6N29N9ORA8DYsWPx8ccf44cffsDWrVuRk5MDMzMzeHh4YMSIEbK7pzB16lQYGxsjNDQUd+/eRc2aNeHv74/hw4ejsLAQkyZNQr169TBs2DAAQNeuXbFv3z5MnjwZu3btgqurKxwcHODl5YWgoCB07NjxjZkVK1bEli1bsH79eqxduxa3bt2Crq4ubGxsEB4ejqZNmwIAOnTogIsXL2LRokXIzMxErVq10KtXL8THxyMxMRF9+/ZFw4YN0bJlS4wdOxbjx4/HkCFDVLq/imlqamLVqlXYsmULoqKisGTJEmhra6N+/fpYsWIF2rZtCwCwt7fH1KlTsXHjRoSEhKBGjRrw8PCAmZkZzp8/DwAwMjKCp6cnFi9ejLS0NEyfPh1btmzBkiVL0K9fP2hpacHR0RHh4eEwMTEBAIwZMwb5+fmYPn06srOz0bp1a7i7uyM3NxfA82nfN2/ejODgYPTp0wc6Ojr47LPPEBQUhCpVqrxx27p27YoNGza8sWDT19cXurq6WL58OW7fvg1zc3OsWLEC7u7u77qLiYiIiIiIiIiIiIiIiIiIiIiI6C1oiOL5mYnotX788Uc0btwYxsbGimVDhgxBzZo1MX/+/Hduf+rUqcjPz0dwcPA7t/W2cp9lqD0TAJ4WaknJBYDKFeQNBKyd+1RKbpFOZSm5AHArq0hKrramhpRcANDRkpNtqCvvdZWVL+dxLpJ4JnP9SZ60bAfN21Jy84zrScmVSTv7obTsK3n60rJl0dd5bwbrLzNZ7xkAIOvToImQc/4JAEJbT0ruU6EjJRcAZD3FKmvkywkGoFGQKyVXaOtKyQXkbfNjDXmfM4xy7krL1nyQJiVXGNaQkgsAT6qUfTYTZZL5Pnk/q0BKbrVK8n43L+vzle6HdwoIANDMe/MsQ6qQoVlJSi4AyHpFZ+TJuWYBAAaSPuNUkHj81M15JCVXM/uJlFxA3vUS7ZzHUnIBQCvznrTsQgM550QZWvKu01TW+gC/ztWQc/wskLirKwg5558oKpSTC7nXSwwqyHmvlPocK5LznUaRzOslhzdIyS188kBKLgBU7jtdWjYR0YfsvRoJk0iVwsLCEBERgUmTJkFfXx/x8fE4efIk1q9f/07tHj9+HFeuXMGePXuwdetWJfWWiIiIiIiIiIiIiIiIiIiIiIiIVI1FmG/J2dkZhYWv/jWQkZERDh8+rLb++Pn54dSpU69dZ8eOHbCwsFBJ/pw5cxAbG/vadZYvXw43NzeVtqEOwcHBWLhwIby9vZGTk4P69etj+fLlcHV1fad2o6OjceTIEQQEBMDe3l5JvSUiIiIiIiIiIiIiIiIiIiIiIiJV43Tkb+n69et43S7T1NRE7dq11dafO3fuICcn57XrmJmZQUdHNUO5P3z4EBkZr59K0NTUFBUrVlRpG/RuOB25enE6cvXhdOTqxenI1YvTkasPpyNXL05Hrl6cjlx9OB25enE6cvXhdOTqxenI1YvTkasPpyNXL05Hrl6cjlx9OB25enE6cvXidOTqw+nI1YvTkasXpyNXH05HTkT04eFImG+pTp06srtQQo0a8i6+A4CxsTGMjY2lt0FERERERERERERERERERERERESkbh/ob4yJiIiIiIiIiIiIiIiIiIiIiIiIiN4NizCJiIiIiIiIiIiIiIiIiIiIiIiIiMqBRZhEREREREREREREREREREREREREROXAIkwiIiIiIiIiIiIiIiIiIiIiIiIionJgESYRERERERERERERERERERERERERUTmwCJOIiIiIiIiIiIiIiIiIiIiIiIiIqBw0hBBCdieISK57T7Ok5FbNviMlFwAKq9SUlp36OF9Kbh3DClJyAUAvU85jrZGfLSUXADSKCqTkFhjVkZILAIVaulJytXOfSskFAI2cDGnZd3XlHMdqPLsmJRcAiiqbyAnWkPe7pSea+lJy9XXkbbOGpI8n+RI/FVVAkbRs7UfXpeQWGH8sJRcAtDLvScl9qldNSi4AVNaS8wTXzHsmJRcA7onKUnKz8iW+nj/An9lWr6QtLVtbQ06uRmGenGCJnhbJ+yyrJelxrpJ5U04wAKEt53Od0KkkJRcANCWdGwAAhJz3jSKDGlJyAQD5OVJiC/XlnYtl5sl5nAslfvWjJ+kAKvFUDFVz70vJFVryzoeuFsi5ZgEAtQ10pORqZz+UkgsAmRWqSsmtrCHn+wwAuJUj50POR0UPpOQCQEZFUym5+rkSn9u6xtKyK2sWygmWdA4IyPseR+Z5ie75fVJyizIeS8mVSa/9UNldICKS6gO8RE9ERERERERERERERERERERERERE9O5YhElEREREREREREREREREREREREREVA4swiQiIiIiIiIiIiIiIiIiIiIiIiIiKgcWYRIRERERERERERERERERERERERERlQOLMImIiIiIiIiIiIiIiIiIiIiIiIiIyoFFmERERERERERERERERERERERERERE5cAiTCIiIiIiIiIiIiIiIiIiIiIiIiKicmARJhERERERERERERERERERERERERFRObx3RZi7d+9Gnz594OTkBCcnJ3h6eiIyMrLEOm3atMGKFStU1oc2bdrA0tLylf8GDhz4Tu3n5+dj48aNb32/goIChIeHo0ePHnBycoKLiwt8fHxw4sSJt2pHCIHY2Fg8ePDgrfsAAA8fPkTz5s3L/RjExsaiX79+aNKkCZydneHl5YX9+/e/dTs///wzrly5Uq4+/FPk5eWhS5cumDJliuyuEBERERERERERERERERERERERfXC0ZXdAmXbs2IF58+Zh2rRpaNKkCYQQOHHiBL755hvcv38f/v7+ivV0dXVV2o/CwkIAwNmzZxEQEICoqCiYmZkBACpUqPBO7e/ZswcLFiyAt7d3me+Tl5cHHx8f3L59GwEBAXByckJOTg6io6MxZMgQLFiwAN27dy9TWwkJCZgyZQri4+PL1f8ZM2bg3r17b30/IQTGjRuHEydOICAgAK6urtDQ0MChQ4cwYcIEXL16FaNGjSpTWzdv3oSfnx82bdqE+vXrv3Vf/ikWL16MlJQU2NjYyO4KERERERERERERERERERERERHRB+e9KsKMiIhAz5490bt3b8Uyc3NzpKenY9OmTYoiTGNjY5X248X2DQ0NFcuqV6+ulPaFEG99n9DQUCQnJ2Pv3r2oWbOmYnlgYCCysrIwf/58tGvXDpUrV1ZJfrHt27fj6tWr5doXkZGROHToEHbs2IFGjRoplo8cORJCCKxatQrdunVDrVq13tjWu2zDP8Uvv/yC/fv3o0GDBrK7QkRERERERERERERERERERERE9EF6r6Yj19TUxG+//YYnT56UWO7r64vt27cr/n5xOvIVK1bA29sbmzZtQvPmzeHo6Ijx48fj3r17mDRpEpycnNCyZUvExsYqrZ9CCKxduxbu7u5wcHBAt27dsGvXLsXtc+bMgZOTE27evAkAyM7ORocOHeDn54eYmBhMnToVAGBpaYlTp069MS8/Px9RUVHo2bNniQLMYmPGjMG6deugp6cHAPjjjz8watQouLi4wNbWFu3atUN4eDgA4NSpUxg0aBAAwN3dHTExMWXe7qtXryI4OBhBQUHQ0dEp8/2KRUREoE2bNiUKMIsNGjQIGzduVBR3pqenY+LEiWjWrBlsbGzQsmVLLFu2DEVFRfjrr7/g7u6uuF/xcyE1NRW+vr5wcnJC8+bNMWHChBIjdhYWFmLZsmVo3rw5HBwcEBAQgG+++abE9PKpqanw8/ODi4sLGjdujNGjR+PWrVuK2wcOHIhp06ahV69ecHZ2xsqVK2FpaYmEhIQS2zNu3DhF0fDLPHz4EFOnTsXcuXNhZGT01vuSiIiIiIiIiIiIiIiIiIiIiIiI3t17VYTp6+uLpKQkuLm5Yfjw4VizZg0SExNhYGCAevXqvfJ+Z86cwZkzZxAeHo6QkBAcPHgQnTt3hrW1NaKjo+Hm5oaZM2fi0aNHSunnsmXLEBERgenTp2P37t0YNGgQvv76a2zduhUAMGnSJNSoUQMzZ84EACxYsADPnj3DggUL4OHhgWnTpgEAjh07Bicnpzfm3bhxA48fP4ajo+NLbzc1NYW9vT20tLSQnZ0NHx8fVKpUCREREdi7dy86duyI+fPnIykpCU5OToqixaioKHh4eJRpm/Pz8zFhwgQMHTq0XFNn5+XlISUl5ZXboK+vjyZNmiiKO0eMGIGHDx8iLCwMBw4cwLBhw7B69WocPnwYZmZmiIqKAvC8CHfIkCG4c+cO+vXrh9q1a2PHjh1YvXo1MjMz4eXlhaysLABAcHAwtm/fjpkzZyImJgampqbYvHmzog83b95Enz59oKOjg/DwcGzYsAEPHjzAgAEDkJmZqVgvJiYGgwYNwrZt29C/f380atQIcXFxitszMjIQHx+PHj16vHJ/BAYGonXr1mjTps1b70siIiIiIiIiIiIiIiIiIiIiIiJSjveqCPPzzz/H9u3b0b59e1y4cAFLlixBr1690KFDB/z666+vvF9RURHmzZsHCwsLtGrVCtbW1jA3N4ePjw/Mzc3h7e2NvLw8pKWlvXMfs7KysHHjRkyePBmtW7dGnTp14OnpCW9vb4SFhQEA9PT0EBQUhJMnT2LatGmIiopCUFAQjIyMoKenBwMDAwBA9erVyzSiZPHIoMVTo79Odna2oijUwsICdevWVYzIePnyZejo6JSYYr149Mw3CQ0Nha6uLnx9fcu0/t89fvy4zNuQk5ODbt26Ye7cubC2tkbt2rUxcOBAmJqa4vLly9DS0lJMGW9oaIjKlStj27ZtMDU1xcyZM2FhYQFbW1uEhITg/v37OHDgALKzsxEREYGxY8eiffv2sLCwwIwZM0qMyhkREYFKlSohODgYVlZWsLe3R2hoKB48eFBipFNra2t06dIFDRo0gJGRETw9PXHw4EHk5uYCAPbv3w8DAwO4ubm9dPsiIyORmpqqGBGViIiIiIiIiIiIiIiIiIiIiIiI5NCW3QFls7e3R1BQEIQQSElJwdGjR7Fp0yb4+vrixx9/hImJSan7mJiYoEqVKoq/K1asCDMzM8Xfurq6AKAoknsXV65cQW5uLiZPnlyiiK6goAB5eXnIycmBnp4e7OzsMGLECKxatQqDBw+Gq6truTOLCw6LCxnftG6/fv2wb98+JCcnIy0tDUlJSQCeF6uWx+nTp7Ft2zbExsZCS0urXG1UrVoVGhoaZRqNVE9PDwMGDMCBAwcQHh6OtLQ0JCcn4+7du6/chkuXLiE1NbXUyKK5ublITU1FamoqcnJySo3E2bhxYyQnJwMAUlJSYGtrW6Iw1sTEBPXq1cPly5cVy+rWrVuijS5dumDRokWIj4+Hh4cHYmNj0bVrV2hrl355/vnnnwgKCkJYWBgqVar0xn1BREREREREREREREREREREREREqvPeFGGmp6dj7dq1GD58OGrUqAENDQ1YWlrC0tIS7u7u8PDwQEJCAjp06FDqvhUqVCi1TFNTNYOECiEAACEhITA3Ny91+4sFfBcvXoS2tjZOnTqFvLy8Mo16+TK1a9dGtWrVcPbs2ZdOH37t2jXMmTMHkydPhomJCXr37g0jIyO4u7vj008/hZ2dHVq2bFmubACIjY1FVlYWunbtqliWnZ2N77//HuvXr8fZs2ff2IaOjg5sbW1x7ty5l96emZmJL7/8EiNHjoSDgwP69++P7OxsdOzYEd26dcOMGTPQv3//V7ZfVFQEV1dXzJo1q9RtBgYGuHv3LoD/e/xeRggBDQ2NUssLCwtLPMf+PnqooaEh2rZti127dsHOzg5nz57FnDlzXpqxb98+PHv2DD4+PoplOTk5+O2333Dw4EHs3bsX//nPf17ZRyIiIiIiIiIiIiIiIiIiIiIiIlKe92Y6ch0dHWzfvr3EtM/F9PX1AQDVqlVTd7dKMTc3h7a2Nm7duoW6desq/h09ehRhYWGK4s/IyEgcP34cYWFhSE9Px/LlyxVtvKzQ73U0NTXRs2dPxMTE4M6dO6VuX7duHc6dO4datWph9+7dePz4MSIjIzFq1Ci0a9dOMZ15cQHi2+ZPnDgR+/fvR1xcnOKfqakpvLy8EBcXV+Z2evfujSNHjuDSpUulbtu8eTNOnz6NWrVq4ZdffsHFixexefNmjB49Gh4eHtDX18eDBw9euQ0NGjRAamoqzMzMFI+JoaEh5s+fj5SUFNStWxd6enqlikATExMV/2/YsCESExORl5enWHb//n2kpaXBwsLitdvm6emJ48ePY+fOnbCzs0ODBg1eut6AAQNw8ODBEvvS1tYWbdq0UexXIiIiIiIiIiIiIiIiIiIiIiIiUo/3pgjT2NgYw4YNQ0hICJYtW4akpCTcuHEDP//8M/z9/eHi4gJnZ2fZ3YSBgQG8vLwQEhKCuLg43LhxA7GxsQgKClIUiaalpWHRokXw9/eHq6srAgMDsX79eiQkJACAYhrq33//HTk5OWXK9fPzQ926dRWFj9evX8eFCxcQGBiI6OhozJ07F/r6+qhZsyays7Oxf/9+3Lp1C8eOHcP48eMBQFFcWJyfnJyMZ8+evTHbxMSkRMFp3bp1oa2tDUNDw1JTc79Oz5490aJFC/j4+GDr1q24du0akpOTERwcjNDQUIwfPx61a9dGzZo1AQC7du3CzZs3cebMGYwaNQr5+fmltiElJQUZGRno168fMjIyMH78eCQlJSE5ORkTJkxAYmIiGjRogIoVK2LgwIEIDQ3FTz/9hKtXryI4OLhEUWbfvn2RmZmJiRMnIjk5GYmJiRgzZgyMjIzQqVOn125bs2bNUK1aNaxduxY9evR45XpVq1YttS/19PRQuXJlxX4lIiIiIiIiIiIiIiIiIiIiIiIi9XivKrbGjh2Ljz/+GD/88AO2bt2KnJwcmJmZwcPDAyNGjJDdPYWpU6fC2NgYoaGhuHv3LmrWrAl/f38MHz4chYWFmDRpEurVq4dhw4YBALp27Yp9+/Zh8uTJ2LVrF1xdXeHg4AAvLy8EBQWhY8eOb8ysWLEitmzZgvXr12Pt2rW4desWdHV1YWNjg/DwcDRt2hQA0KFDB1y8eBGLFi1CZmYmatWqhV69eiE+Ph6JiYno27cvGjZsiJYtW2Ls2LEYP348hgwZotL9VUxTUxOrVq3Cli1bEBUVhSVLlkBbWxv169fHihUr0LZtWwCAvb09pk6dio0bNyIkJAQ1atSAh4cHzMzMcP78eQCAkZERPD09sXjxYqSlpWH69OnYsmULlixZgn79+kFLSwuOjo4IDw+HiYkJAGDMmDHIz8/H9OnTkZ2djdatW8Pd3R25ubkAnk/7vnnzZgQHB6NPnz7Q0dHBZ599hqCgIFSpUuWN29a1a1ds2LDhjQWbRERERERERERERERERERERERE9M+gIYrnZyai1/rxxx/RuHFjGBsbK5YNGTIENWvWxPz589+5/alTpyI/Px/BwcHv3Nbbuvc0S+2ZAFA1+46UXAAorFJTWnbq43wpuXUMK0jJBQC9TDmPtUZ+tpRcANAoKpCSW2BUR0ouABRq6UrJ1c59KiUXADRyMqRl39WVcxyr8eyalFwAKKpsIidYQ97g8U809aXk6uvI22YNSR9P8iV+KqqAImnZ2o+uS8ktMP5YSi4AaGXek5L7VK+alFwAqKwl5wmumffmmRNU5Z6oLCU3K1/i6/m9meuk7KpXkvfbYm0NObkahXlygiV6WiTvs6yWpMe5SuZNOcEAhLacz3VCp5KUXADQlHRuAAAQct43igxqSMkFAOSXbWYnZSvUl3culpkn53EulPjVj56kA6jEUzFUzb0vJVdoyTsfulog55oFANQ20JGSq539UEouAGRWqColt7KGnO8zAOBWjpwPOR8VPZCSCwAZFU2l5OrnSnxu6xq/eSUVqaxZKCdY0jkgIO97HJnnJbrn90nJLcp4LCVXJr32Q2V3gYhIqvdqJEwiVQoLC0NERAQmTZoEfX19xMfH4+TJk1i/fv07tXv8+HFcuXIFe/bswdatW5XUWyIiIiIiIiIiIiIiIiIiIiIiIlI1FmG+JWdnZxQWvvpXMUZGRjh8+LDa+uPn54dTp069dp0dO3bAwsJCJflz5sxBbGzsa9dZvnw53NzcVNqGOgQHB2PhwoXw9vZGTk4O6tevj+XLl8PV1fWd2o2OjsaRI0cQEBAAe3t7JfWWiIiIiIiIiIiIiIiIiIiIiIiIVI3Tkb+l69ev43W7TFNTE7Vr11Zbf+7cuYOcnNdP4WJmZgYdHdVMzfDw4UNkZLx+KlZTU1NUrFhRpW3Qu+F05OrF6cjVh9ORqxenI1cvTkeuRpyOXK04Hbl6cTpy9eF05OrF6cg/DJyO/MPA6cjVi9ORqxmnI1cbTkeuXpyOXH04Hbl6cTpy9eJ05OrD6cjVjNORqxWnI1cfTkdORB86joT5lurUkVfc8jI1aki8YAbA2NgYxsbvdnKsjDaIiIiIiIiIiIiIiIiIiIiIiIiI1O0DHCeBiIiIiIiIiIiIiIiIiIiIiIiIiOjdsQiTiIiIiIiIiIiIiIiIiIiIiIiIiKgcWIRJRERERERERERERERERERERERERFQOLMIkIiIiIiIiIiIiIiIiIiIiIiIiIioHFmESEREREREREREREREREREREREREZWDhhBCyO4EEREREREREREREREREREREREREdG/DUfCJCIiIiIiIiIiIiIiIiIiIiIiIiIqBxZhEhERERERERERERERERERERERERGVA4swiYiIiIiIiIiIiIiIiIiIiIiIiIjKgUWYRERERERERERERERERERERERERETlwCJMIiIiIiIiIiIiIiIiIiIiIiIiIqJyYBEmEREREREREREREREREREREREREVE5sAiTiIiIiIiIiIiIiIiIiIiIiIiIiKgcWIRJRERERERERERERERERERERERERFQOLMIkIiIiIiIiIiIiIiIiIiIiIiIiIioHFmESEREREREREREREREREREREREREZUDizCJiIiIiIiIiIiIiIiIiIiIiIiIiMqBRZhEREREREREREREREREREREREREROXAIkwiIiIiIiIiIiIiIiIiIiIiIiIionJgESYRERERERGVW25uruwuqIQQQnYXiIiIiIiIiIiIiIiI6F9AW3YHiIjon2XRokXo0aMHGjRooPbsx48fo2rVqmrPlS0nJweamprQ0dFBamoqjhw5AicnJ3zyySeyu0ZUbv+k1/PDhw9x+vRp2NjYoHbt2rK7ozIf6rHk/v37yM/PL1Uw95///EdtfcjPz0dycjLMzc1RuXJllWbdunULVapUgb6+Pk6ePIlDhw7hk08+QefOnVWau23bNvTt27fU8jNnziAwMBAHDx5USW6PHj3g6emJzp07w9DQUCUZr+Lp6Yn58+fDyspKLXk//vgjbG1tYWZmppa8f4qtW7fi008/Rb169aChoSG7O2qXlpaG8+fP4/79+9DU1ISpqSns7e3x0UcfvZe5L8rLy4OOjo7a8j40eXl5OHPmTInHuXr16nB0dISzszM0Nd+/32XfuXMH//3vf1+6za1atYKRkZHsLqrUnTt3cO/ePWhpaaF69eqoVq2a2rIfPXoELS0tVKlSRS15sh5r2a8rGeeBMl9XH+JrWvY2/xPOD4iIiIjow5Seng5TU9P38noFEX04NASH9yCit6SuIo+EhIQyr9ukSROlZhe7du0aZs+ejV9//RX5+fmlbk9KSlJJLgAUFRVhz549iuy/H64XLFigktzevXvjwoULsLGxgaenJzp16qS2L1JsbW3Rpk0beHp6okWLFh/EiXZCQgK+/PJLLF++HPXr18fnn38OTU1NZGVlYcmSJejYsaPsLr5XtmzZgi5duqi9kEem7OxsbNy48ZXHkk2bNqkkV+brOSUlBQEBAZg3bx6srKzQsWNH3L9/Hzo6OlizZg1cXV1Vlr179240adIENWvWxLfffot9+/bhk08+QWBgIHR1dVWWK/NYMnr0aCmP87lz5zB58mRcv369xHIhBDQ0NFT6Hn379m0EBgZi7NixsLS0hKenJ65cuQJDQ0Ns3LgR1tbWKsn98ccfMW7cOKxevRp169ZFx44dUbt2bdy+fRtfffUV+vfvr5Jc4Plr+uuvv0bPnj0BPB/9Mjg4GFu2bIGrqys2bNigktzg4GDs2bMHDx8+VBxTmjdvrpZiPRcXF0RFRaFOnToqzwKAmTNnwtbWFpcuXULLli3RunVrteQCQGhoKNq2bQtzc3Po6uqqtRhy0aJFqF69Ok6fPo2uXbvCw8NDLbmzZs1Cly5dYG5uDn19fbUWAxYUFCAuLg7r16/H1atXoa2tDUNDQxQWFuLp06coKipCw4YN4e3tjW7duint2Cor9++2bduGtWvXIj09HQcPHsS6detQvXp1+Pv7qyTvQ/P06VNs2LABERERePr0KT766CMYGxujsLAQDx8+xO3bt2FoaIgBAwZg8ODBMDAwUHofEhMTER8fj8TExFJFRG3btlV6cfuNGzcQGhqK/fv3o0qVKmjYsGGJbb58+TKysrLQuXNnfPnll0r/UU5RUREOHDiAw4cPIzExsUQhpKOjI9zd3dGmTRuVvKbS0tKwYcMGHD58GPfu3VOc62toaMDMzAzu7u4YNGiQ0rc5IyMDkZGROHz4MC5cuIDCwkIAgI6ODuzt7dG2bVv06NFD6c8vWY/1P+F1pe7zQJmvK9mvaRlkbvM/5fzgQ5eVlYWioiLo6+tL68PZs2cRGRmJRYsWSesDERHJFxcXh+joaDx+/BgtWrTAyJEjS5zfPnz4EL169UJ8fLzSsy9evIhTp07B1dUVjRo1QmRkJMLCwnDnzh3Ur18fo0ePRqtWrZSeK5Os/f1P3NeffPIJdu7c+V6c3xPRh4tFmET0VtRZ5GFlZQUNDY03TgWpykKLwYMH49atWxg4cOBLL6J/8cUXKskFnhdZbtq0CVZWVi+9ALd582aVZV+9ehVxcXHYvXs3Hjx4AHd3d/To0QOfffaZSr+U/+9//4udO3ciPj4eBgYG6NatG7744gtYWFioLPNFMoqn+vbti48//hiBgYGIjo5GWFgYDh06hOjoaERFRSEuLk4luQBe27aOjg5q1KgBR0dHaGlpqSRfxigeLVu2xKNHj9C6dWtF0Zi6R91S93ZPmTIF+/btg5ub20uPY6oq6Jb5eh46dCi0tLSwYMECxMfHY+nSpdi5cyciIiJw6tQpREZGqiT322+/xerVq7Fx40ZoaGigb9++6NWrF06fPg03NzcEBgaqJBeQeywZN24cDh8+DAMDA3Tv3l1tj3PPnj2hqamJESNGvPS53bRpU5Vljx49Grdv38ayZcvw22+/YdasWQgLC8OOHTuQnp6O9evXqyT3iy++gJubG8aMGYO1a9ciOjoaBw4cwP79+7Fy5Urs379fJbkAcOjQIUycOBFz5szBRx99hKlTp+Lp06f46quvFIWZqiKEwP/+9z/ExcXhp59+goGBAb744gt0794d9erVU1nuunXrcPToUQwdOhR16tSBnp5eiduVOdrq119/jYyMDBw5cgRt27bF9OnTVVLA8SorV65Efn4+jh07Bh8fH5WPrFps2LBhKCoqwunTp+Hj44MxY8ZAW1s9E3Zs2LABf/75J/73v//hq6++QocOHdSSe/HiRUyZMgUVKlRAhw4d0KZNG5ibmysKGoqKipCcnIwTJ04gNjYWRUVFWLRoEezs7P6VuX+3e/duzJ49G4MHD8a6deuwZ88e/PzzzwgODkZAQAB8fX2VmvcyMkcLVLWffvoJc+fOhb29PTp27IiWLVuWGqH58ePHOHnyJGJiYnDp0iXMmjUL7dq1U0r+r7/+iiVLluDcuXNo1KgRLC0tFUVEjx49wsWLF/HHH3/A2dkZY8eORePGjd85Mzw8HOvWrUOnTp3QsWNHODg4lFpHCIHff/8dMTExOHToEHx9feHt7f3O2QCwZ88eLFu2DE+fPkWzZs1eus2//fYbqlSpgtGjR6NLly5KyX327BkWLlyInTt3omnTpmjdurUiu6ioCA8fPsSlS5dw8uRJ/O9//0PXrl0xZcqUdy7uKSoqwpo1a7B27VrUqFEDrVq1KpVb/GVeeno6hg4dCl9fX6V8ppT1WMt+XRVT53mgzNeV7Nf032VnZyMlJeWlP2hU1g/CZW6z7PODR48e4eeff8aTJ0/w2WefoWHDhiVuz8rKwvr165X+Q42EhIQSxQ59+vQpcQ765MkTBAQEqORHq8nJydi1axeA56P+169fH7NmzUJUVBQAwN3dHQsXLlT5DAvFnj17hl27diEyMhIpKSnQ09PD2bNnlZpx//59xcwJHTp0gImJCdasWYONGzeiqKgI3bt3x8SJE1XyOUBmNqmPrGNJcXbxKMV37txBdHQ07ty5gwYNGqBHjx6oVKmS0jNl4/7+P8OHD8e8efNgamqq1lxVioqKwuzZs9G9e3cAwN69e1G9enWsX79eMTL2/fv30aJFC6V/L/vzzz/D398flStXRnZ2Nvz8/PDdd9+hZ8+eaNCgAc6fP4+9e/di5cqVav3hsirJ2t8y9/XUqVNfedvu3bvRpk0bxXmQqr67IiJSKUFE9Ba8vLzElClTREZGhti4caNo0aKFyM7OFlu2bBHdunVTatZff/1V5n+qYmdnJ3777TeVtf86Li4uYsuWLVKyX3Tq1Ckxd+5c4ejoKFq2bCmWL18u0tPTVZqZkZEhfvjhBzFgwABhY2Mj+vTpI3744QeRkZGhssxVq1YJOzs78euvv4rffvtNWFpaiunTp4v27duLefPmqSzX3t5eXL9+XQghxLBhw8SMGTOEEM+f/3Z2dirLFUKIdu3aCWtra2FpaSmcnZ2Fs7OzsLS0FFZWVsLS0lJYWlqKDh06iNu3bys9+9ChQ8LGxkb88ssv4vr168LGxkZ06NBBODg4qPR5X1RUJH755RcxYcIE4eDgIJo3by6Cg4NFamqqyjJfJGO7P/nkE7Fv3z6VtF0WMl7PTk5O4sqVK0IIIfz9/cWkSZOEEEJcv35dODg4qCy3TZs2in29cOFC0adPHyGEEAkJCaJ58+YqyxVC7rFEiOeP8/bt20Xfvn2FlZWV6N27t9i+fbtKH2dbW1tx6dIllbX/Ok2aNFFkjx8/XowePVoIIcSff/4pHB0dVZZrZ2enOO8ZMGCA4v3p5s2banmcf/rpJ2Fvby+sra3FmDFjxP3791We+XdZWVni+++/Fw4ODsLKykr069dPHDx4UCVZxe+Fxe+Nxf+K/1am77//XsyaNUu4ubmJAQMGiGvXrim1/dfp0KGD6Nq1q7CyshLr1q1TW64QQuzdu1cEBweLzp07iw4dOojExES15NrZ2YnmzZsLKysrsXXrVrVkFvP09BQnTpwo8/r//e9/xRdffPGvzf277t27i5iYGCGEEI6Ojor3rpiYGNGuXTul5xW7du2amDVrlmjRokWJc10rKyvRunVrMW/ePEVfVCE3N1d89913itf2tGnThKOjoxgyZIh4+PCh0nL8/Pze6vjxxx9/iBEjRigl+5tvvhHt27cXmzZtEnfv3n3leg8ePBBr1qwR7u7uYu7cue+cO3fuXPHkyZMyr//gwQMxe/bsd84VQohRo0aJAQMGiPj4eJGXl/fK9fLz88XevXtFnz59hJ+fn1KyO3bsKEJDQ8WjR4/euO6dO3dEcHCw+Pzzz985t2fPnmLy5MkiOTn5jeueP39ejB8/XvTo0eOdc4WQ91jLfF29SJ3ngTJfVzKz/+7nn38Wzs7OJd43Xnz/UBaZ2yzz/OCPP/4QzZo1E46OjsLBwUFYW1uLBQsWlFjn3r17Sj/vjo+PF9bW1sLb21t4e3srPr++eDxVRa4QQhw5ckTY2NiIzz//XHTv3l3Y29uLOXPmCGdnZ/Htt9+KVatWiaZNm6r0OmSxpKQkMXPmTPHJJ58IKysr0axZM7Fy5UqlnpcIIcS5c+dE48aNhZOTk2jatKlo2rSpWLNmjbCxsRGBgYFi2rRpws7OToSGhio1V3a2EM+vx+zcuVPxd2pqqpgzZ44YPny4mDdvnrh69arSMwcPHiyOHz+u9Hb/yWQdS9LT00X37t2FlZWV8PT0FElJScLFxUU0bdpUeHp6ik8++US0a9dO5d+jqNuHuL9Pnz79yn/29vZiz549ir+VxdrausR1qNf9U7bOnTuLH374QfH3jRs3RMeOHUXr1q0V+1dV75M9evQQ3333nRBCiA0bNggrKyuxYcOGEut8//33onv37krN/RD3t6x9LcTzbbayshKdO3cWAwYMKPHP2tpa9OrVS/E3EdG/EYswieit/BOKPM6fPy8uXbqk0sKOYm5ubuLy5csqz3kZR0dHkZaWJiW72Pnz58XcuXNFixYthKOjo5g4caIYNGiQsLe3L3ERSVXu378vvvvuO+Hg4CAsLS2Fo6OjmDt3rkoee1nFUy4uLuLKlSsiNzdXODo6Kvpw7tw50axZM5XlCiHE+vXrRefOnUs8x1NTU4Wnp6fYunWruHPnjvD19RXjx49Xenb37t3F0qVLRWFhoVi9erVo166dKCwsFHv27BEdOnRQet7LZGZmipiYGOHn5yccHBxEnz59xI4dO0R2drbKMmVst7Ozs1qLeV5Fna/nxo0bi+vXr4uCggLh7OwsYmNjhRBCcYFOVWxtbRVFy127dhUrVqwQQjx/j7S3t1dZrhByjyV/d+PGDbFixQrFBdmvvvpKXLhwQek57dq1E+fPn1d6u2Xh6Ogobt68KYQQ4tNPPxWRkZFCCCGuXLkinJ2dVZb72WefiaSkJJGRkSFsbW3F4cOHhRBCnDhxQrRo0UJluS86cuSIcHBwEHv37lVLXrE7d+6ItWvXii5dughLS0vRt29f8cMPP4gVK1aIJk2aqOSLylOnTr32n7KNHj1axMXFifDwcLU+t8+dOydWr14tBgwYIFq0aCH+97//qS1bCCF8fX3F/v37xY8//qiSLyJf5u7du2LTpk3C399ftGjRQsTHx6slV4jnPwhRx33+Kbl/5+DgoPg8+WIR5vXr11XyeTIzM1NMnz5d2NnZiaFDh4otW7aIhIQEkZqaKv744w9x6tQpsWHDBjFixAhhZ2cnAgMDVXJu8s0334imTZuK33//XRw7dkxYW1uL7777TvTu3VtMmTJF6XkybNiwQeTn55d5/dzcXLUXfivboUOH3vo++/fvV0p2eb5gVsaP68pzTqeuAvv33T/hPPBD06lTJ+Hn5yeSkpLU+oNwdZJ5fjB06FAxduxYkZubK/Ly8sTatWuFjY2N4keUQqiu6OD7779X/H3u3DnRvHlz0a1bN8U5gKqKS3r27Fmi4C82NlZYWVmJqKgoxbIDBw4Id3d3pWcL8fy9NzY2VvTu3VtYWVkJGxsb4evrK6ytrVV2/XvAgAFixowZih8rfPfdd6UKPX744QeVXBOTmX3y5Enh6OioGLTit99+E3Z2dqJz585izJgxolOnTsLR0VGcPXtWqbmWlpaiUaNGYunSpSInJ0epbb/OlClTyvxP2WQdS8aNGycGDBggfvrpJzFkyBDRtGlT4efnp7iu/OTJEzFo0CAxduxYpeYKwf2t7v39YoHe33+UoaofaJw+fVo0adJE9OjRQ8TExLz2n7K9+Dm92N27d4W7u7vo3LmzyMjIUNn7pL29vbhx44YQQojs7GxhZWVV6sdf165dU/p19g9xf8va10I8Px+ZO3eu+Oyzz8TPP/9c4raX7Q8ion8bFmES0VuRVeRRVFQkFi5cKGxtbRUfduzs7MS8efNU8uVgsbVr14oRI0aIp0+fqizjVQICAqSMhHnr1i3x3XffiQ4dOghLS8uXjmYWGhqqskKm3NxcsXfvXuHr6ytsbGxEq1atxLJly0RaWpo4ffq06Natm/D29lZ6rqziqdGjR4sRI0aISZMmCUdHR5GRkSEuXbokevbsKcaNG6eyXCGEaNGihfj1119LLT979qxwc3MTQghx8eJFlTzWskdzE+L5h9kNGzaIPn36CGtra9G3b1/Rrl070axZM5UVoMjY7mnTpolly5appO03kfV6Hjp0qJg2bZpYunSpsLGxEQ8ePBDp6enC19dXJaPSFGvbtq343//+J9LS0oSlpaViJOW4uDjRvn17leUKIfdYUiw3N1fs27dP+Pn5CTs7O9G6dWuxbNkyMXXqVGFvby/Wrl2r1LzY2FjRp08fkZyc/NrRp1ShX79+IiQkRERERAgrKytx+/ZtkZubKyZPnqzSX+lOmzZN9OrVS/j4+AhXV1eRm5srjh8/Ltq1a6f4YYwy/X0EyL+PBKnKX4IXi4uLEz4+PqJRo0aK0Yv/XqgXFRWl0hFI1eXixYtKH3mmrHx9fUV8fLw4f/68uHPnjlqz79+/LzIzM9WaKYQQY8eOFceOHRPXr19Xy4+73sa1a9dESEjIe5nr7u4ujhw5IoQoeXE9Li5OJQUHskYL/LsWLVqIY8eOCSGEmD17thg8eLAQ4nlxmqurq9LzXic5OVl89dVXas2U7fz586Jfv37S8gsLC6XkPnr0SO2F9UIIkZOTI+2LM1mPtTpeV+o+D3zR48ePxfnz5186ApQM6nqcbW1txR9//KHynFfJzc0VKSkpIjk5WeTm5krrh6rOD5o0aaKYwaLYwYMHRaNGjcT8+fOFEKop5HnZl/upqanC1dVVDBgwQOTl5amsuMTR0VH8+eefir8LCgpKFUCmp6cLGxsbpWcvWLBANG3aVFhbW4uBAweKyMhIxflRo0aNVPZc/+STT0q0nZubK6ysrERSUpJi2e3bt1VyTUxmdo8ePcTXX3+tOAcoLgh90Zw5c4SXl5dScy0tLUVsbKz47LPPRJs2bURsbKwoKChQasbLTJs2TVhaWorWrVuXGtXs7/+UTdaxxNnZWfFcunHjhrC0tCz1Y8oLFy6Ixo0bKzVXCO5vde/vhIQE0bp1a+Ht7S1SUlIUP8a4ceOGcHR0FKdPn1bJDzROnjwpbGxsREJCglLbfZP27du/dMaZ1NRU0bRpUzFgwABx48YNlbxPtm7dWvG5WQghdu3aVerHZ3v37lXJdfYPbX/L3NfF/vvf/4rmzZuLmTNnKn44wCJMInofaMueDp2I/l1cXFwQFBQEQ0NDAECLFi2QlJSEefPmwcXFRWW5a9asQXR0NCZPngxnZ2cUFRUhISEBq1atQo0aNTBs2DCV5B49ehTnzp2Di4sLTExMoKOjU+L2+Ph4leQCgJ2dHRYvXowTJ07AwsICFSpUKHG7v7+/SnLbtGkDExMTdOnSBStXroSFhUWpdRo1aoSPP/5Y6dmBgYE4ePAg8vLy0KZNG3z33Xdo3rw5NDQ0AAB16tTBiBEjMG3aNKVn16xZE1evXkVeXh4uX76Mr7/+GgBw5swZ1KxZU+l5xWbNmoVZs2bh8uXLCAoKgr6+Pnbu3AltbW1MnTpVZbkAkJGRAX19/VLL9fT08OTJEwBAlSpVkJubq/TsKlWqICMjA5mZmTh37hyGDBkCALh+/TqqVq2q9Lxiubm5OHToEHbu3IkTJ06gWrVq6N69OxYvXow6deoAAGbPno0pU6bg6NGjSs+Xsd1VqlTB+vXrcfToUZibm5c6ji1YsEAluTJfzzNmzMC4ceNw48YNTJs2DcbGxpg7dy6uXLmCdevWKT2vmJeXF8aMGQNdXV1YWlrCyckJW7duRVBQEAICAlSWC8g9lpw5cwY7d+7EwYMHkZOTg7Zt2+K7775Ds2bNFI+3paUlVqxYodT369DQUNy9exfdu3d/6e1JSUlKy/q7yZMnw8/PD48ePYKvry9q1qyJr7/+Gj/99BPCwsJUljtjxgyEhITgxo0b+O6776Cjo4Nff/0V9vb2mDx5stLz5s+fr3gMZQkMDETr1q2xatUquLm5QVNTs9Q69erVQ//+/ZWenZeXh+3bt+Py5csoLCwssfzChQs4dOiQUvMaNWqk+H9OTg40NTWho6OD1NRUHDlyBE5OTvjkk0+Umlns22+/hRCi1PmmOpiYmCj+n5OTgwMHDiA1NRVDhw5FSkoK6tevD2NjY6XnLlu2TOltKsv169exevVqjBkz5r3L7dOnj+JcCwD+/PNP/PLLL1i+fDm8vb2VnrdhwwbUqFGjTOuamppiwoQJKjmePH78WPG56vjx4+jZsycAwMjICDk5OUrPe527d+9i9+7dWLx4sVpzAeD06dOYNGkSjhw5otbcJ0+e4LffflNrZrFffvkFw4cPV+l5yatcuHBBSvbp06elbbOsx1odryt1nwcWi4uLw6xZs5CXlwchRInbNDQ03uvH+eOPP8bDhw9VnvMyZ86cwbhx41BUVISCggJoaWkhODgYzZo1U3tfVHV+oKOjg7y8vBLL2rdvj+nTp2P27NkwMzND586dlZoJAMbGxrhx4wZq166tWGZubo5Vq1bBx8cHkyZNUpynKFt2djYMDAwUf2tpaUFXVxcVK1YssezFzx7KsnHjRpibm2PBggVo1arVSz9XqcKzZ88U3yMAzx93PT09VK5cWbFMW1sb+fn571X2lStXsGzZMsV+Tk1NLXVtZtCgQejWrZvSs1u0aIE2bdpgxYoVmDFjBkJDQ9GjRw94eHjA3Nxc6XkA8M0336BKlSrYtWsXli9frpLPb68i61gCQPH5+aOPPsJnn31W6ppr8Wd6ZeP+Vu/+dnZ2xq5duzBr1iyMHDkSixcvLnFtpmbNmqhVq5bSc11cXODl5YWlS5ciIiJC6e2/Sq9evTBjxgxcu3YN3bp1U3yeNjc3x7fffgtfX1/FdxrK1r17d0yePBmBgYHo2LEjunTporgtPT0dUVFR2LBhg0quWXxo+1vmvi7WokUL7Ny5E4GBgejatSuCgoKkX4cmIlIGFmES0VuRVeSxfft2zJo1C506dVIsa9SoEYyNjZVe1PEiFxcXlRaXvs62bdtgYmKCS5cu4dKlSyVu09DQUFkR5ooVK9C6dWtoaWm9ch13d3e4u7srPfvSpUsYM2YMunbtWuIi2YssLS2xZMkSpWfLKp4qfg6/aPz48Sq5YPB3zs7OCAoKwtKlSxUXgZ8+fYqlS5fCyckJAHDo0CHUq1dP6dktW7bEzJkzoa+vD319fXz22Wf43//+h6+//hqtWrVSel6xTz/9FAUFBWjVqhW+/fZbtGjRotSF508//VRlBdYytvv333+Hg4MDgOdfDqqLzNdz3bp1ERMTU2LZqFGjMG3atNce297V0KFDUa9ePdy4cQNdu3YFABgYGCAwMBC9evVSWS4g91gyYMAANGrUCGPGjEGXLl1QpUqVUus0aNAALVu2VGquqgtbX8fe3h7Hjx9HRkaGYnsHDx6MMWPGwMjISGW5enp6pb4QVOV+6NGjh+L/c+fOxeDBgxUF6+ry3//+941fKDRu3BiNGzdWevb8+fMRExMDGxsbnD9/Hk5OTkhLS8ODBw9UUixWLCEhAV9++SWWL1+O+vXro1evXtDU1ERWVhaWLFmCjh07Kj1TW/v/Lg3cvXsXP/zwA/78808EBgbi9OnTaNiw4Ut/mKNM9+/fh5eXF+7fv4+8vDz07t0b69evx4ULF7Bp0yaV5l+8eBFhYWG4fPkytLW1Ub9+fQwePBj29vYqy/xQ+fr6IiMjA1999RVyc3MxYsQIaGtrw8vLCyNGjFB6XlkKMB8/foykpCR8+umnAKCSH2DVqVMHFy5cwMOHD5GWloYWLVoAAH766Sd89NFHSs/7p8rNzcWdO3dkd4PoX0nd54HFQkJC0K1bN3h7e0NXV1flef8kX331FebOnYtx48a99AeN//nPf1SWPW/ePISEhCjOcWNjYzFr1iz8+OOPKstUt6ZNm2Lx4sUICgpCtWrVFMv79u2LmzdvYtGiRbh165bScz08PDB9+nRMnDgRzZs3V3ye++STTxAcHIxx48bh9u3bSs8tJqu4YM6cOYiJicGoUaNgaGiItm3bolOnTmq57q2ugs9/Unb16tVx4cIFxefnjz/+GLdu3Srxw7tr16698nrZu6pSpQoCAwPh6+uLrVu3Ijo6GqtWrUK1atXQsGFDVK1aVenX47766iv89ttvWLFiBWbNmqXUtl9H1rGkSZMmWLZsGebNm4eqVauW+kHujRs3MHfuXJUVz3N/q3d/6+vrY8mSJdi5cydGjhwJLy8vtZyHTZ06FVlZWSrPedHQoUORn5+PiIgI2Nvbl/hM3bhxY2zcuBETJ05USba/vz/y8vKQmJhY6trXxYsXsWXLFvj5+WHw4MEqyf+Q9rfsfV3M2NgY3333HSIjIzFkyBC1/0iViEgVWIRJRG9FVpHHgwcPYGdnV2q5g4ODSi+MqarQsSwOHz6stqwXPxg3atTotV+MqfIic2xs7BvXMTc3V8mvdmUWTxUXO1y9ehXTpk1TW7HDzJkzMXjwYLi5uaFevXoQQuDatWswMjLCunXrcPz4cSxZskQlI0XJGsWjuCjwZUVSQghoaGigTZs2aN++vUryZWz35s2bVdLum8TGxiI1NRVpaWmKIpb169ejVatWitewql7Pr7rYV3xsU+VxrE2bNiX+Lj6eqIOsY0lcXBysrKxeu06zZs2UfiH0iy++UGp7b3Lr1i2YmZlBQ0OjxHMsMzMTAKCrq4vs7GxkZ2cr9Tm2cuVKDB06FBUrVsTKlStfu64qz1vi4uLg4+OjsvZfxdjYGMnJyUhJSUFRURGA58frvLw8nD9/HvPnz1dZ9k8//YSFCxfCw8MD7du3x9y5c1G7dm2MGzdOJaOlFFu6dCnc3d1hZ2eH6Oho6Ovr49ChQ4iOjsb333+vkiLMYmlpaejduzf09fVx584djBs3Dvv378e0adMQFhamspE4AWDhwoWoX78+du/erTheLFq0COPHj8eiRYuwZs0aleSeOXMGPj4+aNiwIZo3b47CwkL89ttv6NevH8LDw1VS4PuhGz9+PEaOHIkrV65ACAFzc/OXjs6uLuoYLXDYsGEYP348NDU14erqCisrK6xatQqrVq1S6XGMiN4vycnJCA8Px9WrV7F8+XL89NNPqF+/vkqLqJ48eYIhQ4aoZDaUf7rhw4cDeP6DvhcL54qvHSjrfWP8+PEYN25ciZEZs7OzS/wowNTUVO1FAao2adIk+Pr6okWLFlizZo3iBwoAMHHiRAghEBYWpvSiRX9/fzx69AiTJ0/G999/X+Jzart27RAaGqrS61Jnz54tUXgnhEBiYiLS09MBQDEzjbL17t0bvXv3RmpqKmJiYrBr1y7ExMSgatWqKCoqwo0bN1C/fn2VZKenp5eaZefOnTuKH8k+ePBAJbkys/v27Yvp06fj6dOn6NSpE8aOHYuZM2dCT08PDRo0wPnz5zFv3rwSP3xUhr+/XkxNTTFu3DiMGzcOv//+O3777TckJyfj/v37Ss0Fnhe8zp8/HwkJCUpv+3VkHUumTp2KwYMHY/bs2aWunR86dAijR4+GlZWVykbW5f7+P+rY38W6deuGxo0bY/Lkyejdu7dKRi5+kZaWVokRlNVBQ0MDI0eOxMiRI0uNgg48/2H6/v37kZiYqPRsTU3NVxYctmzZEidPnlTpjxk+pP0te1//nZeXF5o2bYp9+/ap7AcKRETqwiJMInprV65cQUpKSqlpBwC8ckrQd/Xxxx/j+PHjpUZfOnbsmEqLaQA5F7lflJCQgNTUVHTu3Bnp6emoW7eu0qeKbNOmTZlPqJX95eTbjKCqqmmTi8konvp7scPYsWPVVuxQu3Zt7Nu3D3v37kVSUhK0tLQwaNAgdOrUCTo6OtDV1cXu3btVUiQnaxSPTZs2vXSqnzt37qBr1644depUidHAlE3WdmdlZWHXrl2KEb4aNGgADw8PlRY8/PLLL/jyyy8xZMgQRRHmvn37sGLFCqxduxbOzs4qy37TMU2Zx7FBgwZh5cqVqFKlCgYOHPja3E2bNikt9+/UfSz5+0Xe1130bdKkiVKzX/Tzzz9j9erVJUavGzp0KNq1a6f0LHd3dxw7dgwmJiavfI4p+wtZAIiJiUH//v1RsWLFUiO8vkiVo2QDQKtWrbBlyxb4+/urtVhq06ZNigIlDQ0NxQVJDQ0NlR5HgOej4zk6OgIAGjZsiEuXLsHc3BwjRozA2LFjMX36iPDYqwABAABJREFUdJXkXrp0CYsXL4a+vj6OHTuGVq1aQU9PD61atcKiRYtUklls4cKFaNu2LebNm6c4bixbtgxTpkzB0qVLsWXLFpVlnzx5EmvWrCkxHaOhoSG++uorDBo0SGW5S5cuRa9evTBz5swSy2fPno2QkBBpP2Z4nz158gRpaWmKL8RfPGaq8j1Dpu7du8Pa2ho3btyAm5sbAMDOzg7r1q2TMrUsEf37/P777+jbty8cHR3x+++/Iy8vD0lJSZg/fz5WrlyJ1q1bqyS3ffv2OHr06AdZhKnKz28vsrW1Rd++fdGhQwf4+/ujatWq+PLLL9G9e3eYm5ujoKDgpVMZ/9vVrFkT0dHR+PXXX9GgQYNSt3/11Vdwc3PD3r17FctycnKgp6f3Trm6urqYN28epk+f/tLPdG3atEF8fDz++9//KpYdO3YMTZo0UcposAEBAaWKLCZMmFDib1UWPVhYWOCrr77ChAkTcPToUURHR+PIkSMYNWoUHB0dMXDgQHh4eCg1s2fPniX+FkJg4MCBJf5W1TbLyh46dChyc3OxePFizJ07F1WqVEFOTg58fX0V63h6eir9muDLCniK2drawtbWVql5f2dhYVHmHwIr4/UMyDuW1K5dGwcOHHjpD8FtbW2xcuVKuLm5lRi8RFnbXIz7+zl17e9iH330ETZv3ozvvvsOT548eel3CarKVrdXHR+1tLQUM6mpiyq/s/mn+Kfsb1n72tzcXOrASEREyvL+v2MRkVKtWbMGS5cufeltGhoaKivC9PHxwcyZM/HXX3/hk08+gYaGBs6cOYOtW7fiq6++UkkmIO8iN/B8ZK2hQ4fi/7F35uFUbf8ff586KI2GBpXSoCQRzQMa1A2NNEhINA+aKFJmJUkq0oSQ0qCoaB5UmtDNcJVKc6KLVCqOYf/+8Jz9cxxN37vX2d1rv57H82if03lbZ09rr/Ve709aWhp4PB6GDh0KPz8/PH/+HPv372e0TF7NgeXs7GwEBgZi0aJF0NbWhpSUFNLT0xEUFIRFixYxpink9evX9O8URSElJQWKiopQV1cHn8/Hw4cPkZ+fT6T8eU3z1I8m90kNvrNpdgCqTYGmpqZ1vta+fXui2pIyOCckJOD69esAqpPsPDw8xAbO37x5Q2zAl+0Uu7dv38LCwgKFhYXo3LkzKisrceTIEezatQsHDx4kUnITqD6O58yZAzs7O3rbsWPHsHXrVvj5+SE6OpqILiB+vlZUVOD58+cICwuDs7Mzo1rt27eny1u1b9+etdJikr6WCA2n3xvgB8C4IbEmFy9exNKlSzF69GgYGxujqqoKycnJWLZsGXbs2MH4fSM8PJxeiSupCVlANBlbkinZtcnNzUV8fDzCw8OhoKAgdh29dOkSEd0DBw5g/vz5WLx4MUaMGIHjx4+juLgYq1atItI3qImioiIKCwvRrl07dOzYEY8ePQIAyMnJEUkOEdK4cWMIBAIIBAKkpKTQJtSCggLiK/L//PNPHDhwQORa1rBhQyxYsADTpk0jqv3582cRA2ZNKioqiOn+9ddf8PLyEttuYWEhNmnLBD9Tmo1EIg9burWJjY2Fq6srBAKB2D2E5D2DbZycnODs7IwePXrQ2/T09FBcXIzFixcjKCiIEZ2fScLJzs5mROt3ITY29ofv+a+1ub7C1r7+Xc4rPz8/2NjYYMWKFfQkrJeXF5o1a0Z0fMrBwQHGxsY4f/48lJWVxZ53mF4s+zud0wMGDKB/LyoqAp/Pp0tXM4mNjQ2mTp2KnTt3wtjYGFZWVpg1axaGDBmC+/fvg8fjoVevXkSe3dnuH0hLS2Pw4MHffH3gwIEiY0RDhgxBXFycSGro/8r3zDHNmzfHuHHj6H/b2dkxokvqmel/oUGDBhgxYgRGjBiB9+/fIy4uDjExMVi1ahWjJkxJPjv/TtpAdYru7NmzkZycjBcvXqCkpARSUlJo27Yt+vXrR+Sc3rhxo8RT3P5XmDyf2bqWSEtL17lIoV27dnUGhzDZ5l+F+76ZpUGDBli8eDEWL15c5+ts7msODg4ODg4OduFMmBwcHL9EeHg4Fi9ejPnz5xMvQV6TSZMmobi4GPv27UNISAgAQEFBAXZ2drCwsCCmy9YgN1CdysPj8XDhwgU6kXH16tWwt7eHr6/vN82w/ws1B5Z9fHzg5eUlkiLWs2dPtG7dGr6+vjAzM2NMFxAtlezv7482bdpg48aN9PFVWVkJFxcXIsam2uYpNmDT7FBYWIitW7ciNTUV5eXlYhPhJAeHJWlw1tbWRnR0NCiKAkVRyM3NFUmT5fF4kJWVJZYuxnaKnY+PD5SUlHD06FHIy8sDqDbyLFu2DJs3b8aWLVsY1wSAp0+fYtu2bWLbp0yZQnwgvOY1TciQIUPQrl077Nq1C8OHD2dMq+ako52dHdq2bUtfV4RUVFQgKyuLMc26kPS15HeYPAoKCsKSJUtEBjytra0RGBiI4OBgxg16NY+ruo6xoqIi+hwjSWlpKRo0aABpaWnk5OTg6tWr0NbWJpqcDABDhw7F0KFDiWrURW5uLqZMmQJpaWmoqakhIyMDBgYGcHR0hI+PD6ytrYlp6+vrw9XVFRs3boSOjg68vb0xevRoJCQkEDOwA9UTFps3b6ZNv7q6unjw4AG8vLyIJ7FXVlbSZd9rUlJSQpfsI0X//v0RFRUlkjBaXl6OoKAgose3nJwcCgsLxZK/CwsLiTzv/EwCPYlEHrZ0axMQEICJEyfC2tqakTSp35nU1FS8evUKQLWpqFevXmJJwjk5Obh58yZjmr+ySIJpfrTYCKhO7maany05SKLNP5NKl5+fz7gu8HPndGlpKeO6P5NMXFxczLguwN6+ZvO8qklmZiZcXV3Fts+YMYPoAreNGzfi8+fPEAgEePPmDTEdIWye03URFRWF4OBg2oioqKgIW1tbxvugzZo1w5o1a2BpaYmAgACMHTsWixcvxpQpU4i29XfpH/wsPzoPf3fd/2XscdSoUYiIiCA6biknJwdra2tYW1vjr7/+ordbWlrCz88Pbdq0+Z8/u65n5x/BhC7b2kIaN25Mp6BLgsmTJ0tM65/C1vnMpnZ9bDOb2vWxzRwcHBwcHBzsw5kwOTg4fony8nJMmDBBogZMIcLBoKKiIlAUBQUFBeKabA1yA9UlVrds2SKyWq5Lly5wdXXFggULiOnm5OSgW7duYts7duyIt2/fEtMFgOjoaBw6dEjk+GrYsCFsbW0xZcqUOlOK/gk1zVOkS51/CzbNDi4uLkhJScGkSZMkvkpakgZnJSUl2vRnaWmJwMBA2tgiCdhOsUtKSkJYWJiIOUxRURFr1qwRKYPENPLy8sjKyhJb8fv48WMi6SE/Q7du3YiaIUeNGoWkpCQxI97r169haWmJtLQ0YtqSvpb87AQQicl/ITk5OQgICBDbPm7cOOzdu5eYLgB8/PgRmzdvhoWFBV0C/c6dO1BRUcGePXuIrXRPTk7G4sWLsW3bNnTr1g1Tp05FgwYN8OXLF2zZsgWGhoZEdAEySb0/Q5MmTegURBUVFTx58gQGBgbo2rUrcSOAvb091qxZg5SUFJibm+PIkSOYOnUq+Hw+0bLgrq6ucHV1RXZ2NjZv3oymTZsiLi4OfD6feBnKYcOGITg4GH5+fvS29+/fY/PmzRg0aBBR7TVr1mDmzJm4e/cuysvL4ebmhqdPn+LTp09Ek8FHjBgBT09PbN26lS7l9uTJE3h7exNZcMVWIg/bSUBCPnz4ABsbm3pR1pbH49FmIh6PV+ezjKysLGxtbRnTZHORxPcWG9VESUmJUd2HDx8y+nm/Qs2qDt+jX79+jGubmJgw/pk/Q7t27X5oxmrfvj169erFuDZb+/p3WHwEAFJSUigpKRHbnpub+80kaSa4fPkygoKCoK+vT0yjJmye07U5evQofHx8YGFhgX79+tHJ+/7+/mjatCnjidnv379Hu3bt4OvriwcPHsDPzw/79++Hvb09sUXgv0v/gOPbFBUV1fmsT4qa12/homlJw5aupLW/fPmC0NBQiT9rs6XLwcHBwcHBwcHBUR/gTJgcHBy/xMSJE3HkyBGiJcC/xatXr/DXX3/VaeggVQadrUFuoHqQrVWrVmLbmzZtiq9fvxLT7dGjByIiIkTSJysqKrB792707t2bmC4A8Pl85Obm0hPgQnJyciArK0tUGwDu3bsHFRUVyMvLIzY2FmfOnIGOjg7mzZtHbNU/m2aHpKQkBAUFsZJsxpbBuWbyKltIOsWuYcOGdZbZkpGRITqwPHnyZLi7u+Pjx4/Q1NQEj8dDRkYGAgICWFmZX1JSgv379zOWZiAkKioKoaGhAKpXOZuamoolYX78+LHOsjhMwua15MOHDwgODkZ2djYqKysBVH8X5eXlePz4MVJTU4notm7dGs+fP0enTp1Etj9//py4sXzjxo1ISUmBtbU1Ll++jNTUVPj6+iI+Ph6+vr7YsWMHEV1/f3+MGjUKvXv3RkxMDJo2bYrz588jJiYGu3fvJmrCBKonxR89ekRPAlIUBYFAgLS0NLpkNtP069cPu3btgouLC9TU1HDkyBHMmzcPKSkpaNKkCRFNIc2aNcPOnTvpf+/ZswdZWVlQVFRE69atienKy8uLHUMrV66UyCIoR0dHWFlZYciQISgrK8PChQvx5s0btGzZkqjxFAC6du2KkydP4uDBg1BSUkJVVRUMDQ1hbm6ODh06ENNdvnw5Zs+ejXHjxqFZs2bg8Xj4+PEjunfvjtWrVzOu978k8vybdWszZswYJCYmSsyEyVZaIADo6OjQZiI1NTXcuHEDioqKRLSEsJXuD7Cz2AgAbG1toa+vD319fbE+AWnCwsLA57MztDps2DBoaWlJPJ1u5cqVRO+BvyNsnlc1MTAwwJYtW7B161Z6W05ODry9vRlN+q9NkyZN0LFjR2Kf/zsTEhICJycnmJub09tGjx6NTp06ITw8nDET5u3bt2Fvb4+CggI0a9YM7u7uMDIyQkhICG7cuAE/Pz/s27cPq1evhpaWFiOaQn6X/gEHR33ky5cvCAwMZMWEyYYuBwfH/4adnR1MTU2hq6srNubMaf93dNnUro9t5uDg4CAJZ8Lk4OD4JebMmYMJEyYgISEBHTp0EBvwJ7WC+vjx41i3bl2dK395PB4xEyZbg9wA0Lt3byQkJGD+/Pki2yMiIqCurk5Md/Xq1bC1tcX169ehrq4OiqKQkZGBr1+/Ijw8nJguUJ1e5uzsjOXLl0NDQwMURSE1NRU7duwQGfQmQXR0NNzd3REaGgoFBQU4OTlh8ODBCAsLQ3l5ObGBKTbNDrKysown0fwskjQ49+zZEzdu3ICCggLU1NS+O1H54MEDRrVrw0aKnY6ODnbu3AlfX1+6DHt5eTmCg4PpFFISLFq0CO/fv4eHhwcqKipAURT4fD4sLS2xdOlSYroAvrmfeTwePD09GdUyMTHB+/fvQVEUgoKCMHbsWDFjWJMmTTBmzBhGdWvzrWtJixYtiF9LPDw8kJSUhGHDhiEhIQHGxsbIyclBVlYWVq5cSUx33LhxcHd3h6urK/r27QuguvSrh4cHxo4dS0wXABITExEUFISuXbsiNDQUQ4cOxfjx49G9e3dYWFgQ083KyoKvry+aNm2KGzduYPjw4WjUqBGGDx9OfD9HRETQRsuaJTl5PB6RhC8hQoPcoUOHMGPGDAQHB2PAgAH4+vUro+lx36K0tBRnz55FTk4ObG1tUVJSQrQUOVB9r/ge/fv3J6bdpk0bxMbG4vTp03jw4AGqqqowY8YMTJw4UayMMglat26N5cuXQyAQQEpKSiLmohYtWuDYsWO4fv06Hj9+DIqi0L17dwwbNox4KrlAIMDRo0fx+PFjlJWVib3OZFL7z5SKFkJyQtbBwQHGxsY4f/48lJWVxfYx0+n0bKUF1qZmsptAICBmqv6VtFy2KgEwjYmJCRITE7Fr1y40bdoUenp60NfXx8CBA4mb1wcMGIDBgwfTJlCmF/t8D0dHRxQXF2Po0KHQ19eHrq4u5OTkiOsaGhpCWVmZbnOfPn0kNlkmLAv+MzA5NvW7nFdr1qzBnDlzMGTIEFAUBRMTE5SUlEBNTY3IogEh8+fPR0BAALy9vSXSF2BrP9dFbm4uhg0bJrZdV1eX0b63u7s7li5dismTJyMlJQWLFy/G6NGjISUlhWHDhmHo0KGIjY3FihUriBreJdkv4eDgqK5Sw0b6L1u6HBwc/xsNGzaEnZ0dmjVrhkmTJmHy5MliISac9r9fl03t+thmDg4ODpJwJkwODo5fYt26dQAALS0t4kmQNdm5cyemT5+OFStWSLSMLVuD3EB1wsTs2bPx559/oqKiAsHBwXjy5AmysrIQEhJCTLdfv344ffo0jhw5gsePHwOoTrSbMWMG8cQLe3t7lJaWwtXVlTZtycjIwMLCgvjq3PDwcKxbtw6DBw/Gtm3boKqqitDQUFy7dg1ubm7E9Nk0O0yaNAkhISHw8PAgbjKojSQNzhs2bKBT8TZs2CDxtJiasJFiZ29vDzMzM4wePRoaGhrg8XhIT09HSUkJ0WTQhg0bwsXFBatWrcKzZ8/A5/OhoqJSZyon09Q1OSQlJYU+ffownqbWuHFj+vrA4/Fga2sr0fujEOG1JD4+HllZWRK9lty4cQO+vr7Q19fHw4cPYWtrCzU1Naxfvx5Pnjwhprtw4UI8evQI8+fPp89riqKgr6+PVatWEdMFqpMjhCb2mzdvYvbs2QCqjwdhGigJGjduDIFAAIFAgJSUFNoUKUzNIcmBAwcwf/58LF68GCNGjMDx48dRXFyMVatWYdSoUcR0VVVVcfHiRXz58gVNmjTB0aNHcfLkSSgpKRE32xYUFMDMzAwFBQUQCASYNm0aQkNDkZGRgfDwcHTr1o2IrtB8IDS6AtXXFx6PhwYNGiAzM5OIrpDGjRtj4sSJ6Nu3L5SVlQGANvGT5tChQ9i3bx/evn2Lc+fOISQkBIqKisT7gQ0aNKANRZLEyckJ58+fh7q6OnGzWO1S0W/fvoWUlBSUlZXB5/Px8uVLlJeXQ0NDg+j3vXHjRnz+/BkCgQBv3rwhpiOErbTAujh06BD27t2LvLw8nDt3Dvv27UOrVq0Y/b5rlsemKAopKSlQVFSEuro6+Hw+Hj58iPz8fCLX7Z9JHRXCZHlnY2NjGBsb04sHExMTsX37duTk5KB///60KZNEou65c+eQmJiIa9euwdfXF+3atYO+vj709PSgo6ND9Bnr7NmzePXqFRITE3Hq1Cm4urqie/fu0NXVhb6+PrEqFrdv30ZKSgquXbuGdevWobCwEEOHDoWenh709PQgLy9PRBeAyD4sKytDQkICevbsiT59+oDP5yMjIwMZGRmYOnUqo7psnlc1adq0KaKjo3Hr1i26vy/c5ySNsJcvX0ZKSgoGDRoEBQUFsfRXpsu1s7Wf66Jdu3bIzMwUSwJNT09nNNm4oKAAOjo6kJaWhpaWFgQCAT5//oyWLVsCqO4HTp48GcbGxoxp1oUk+yUcHBwcHBwcP8fWrVtRUlKChIQExMbGIiQkBJqamjA1NYWRkRHRcd/6qM21uX60mYODg4MkPKrmzA4HBwfHD9DS0sL+/fuJpqfVhTAVUjgRLGkkPcgt5OHDhwgJCaHNeaqqqrCxsWG8/NC3KCoqAp/Pl6jxFQA+f/6MZ8+eAaguTSkJQ1Pv3r1x/vx5KCkpYdq0aRgwYADs7e2Rm5uLsWPHIj09nfjfIGlWr16NM2fOoFmzZujYsaPYIDvJVImSkhLMmTMHaWlpoCgKzZo1ow3OYWFh9GTDfw0tLS2cPn0aysrKmDt3LpSUlODh4YE3b97A0NCQ2HH25s0bHDx4UCThy8zMTCLX1IKCApSXl6N2l5NkeW5PT0/MmjVLImXzkpOToa2tDT6fz2p6HVB9r6qsrKTTWry9vTFmzBjiuhoaGrhw4QKUlJSwbNkyjBgxApMmTUJ2djbmzZuHxMREovo5OTl49OgRKIpCjx49JLJa1tTUFFOnToWSkhLmz5+Ps2fPQkVFBX5+frhz5w6OHj1KRHfZsmUoKytDixYtcP78eVy/fh2vXr2Ci4sLlJWV4e/vT0QXqN7PZ86cgbKyMmxtbTFjxgwYGBjgxo0b8PHxwenTp4lps4W9vT1KSkqwdetWDBkyBCdPnkTz5s2xcuVKNGzYEHv27CGiW9uYVlFRgefPnyMgIACrV6/G4MGDiegC1eaSLVu2IDIyEuXl5Th37hy2bt0KGRkZeHh4EDVjnjp1Cu7u7pg1axb27duH06dP48qVK/Dz88PSpUsxd+5cxrR+l5Tsvn37YtOmTTAwMCCmURfh4eG4cuUKtmzZAgUFBQDAx48fsXr1anTv3p1oirG2tjYCAgIkZngdO3YsK2mBtZHk8S3E398fb968wcaNG+l+fmVlJVxcXMDj8eDl5cWo3o4dO+hz6cOHD4iKisKIESPoflJGRgbOnz8PGxsbrFixglHtuigqKsK1a9dw7do1JCUlQUFBAQkJCcT0KioqkJqaSmvm5+fTKZl6enrES9GXlZXh9u3btP6XL1+gq6sLPT09GBkZEdN98+YNbUS9c+cOunbtSpvaNTU1iemuW7cOTZs2haOjo8j2gIAA5OTkYMeOHUR0JX1e/Q78KEmZpHGfrf0sZP/+/QgODsayZcugo6MDHo+HlJQUbN++HZaWloy13cvLC5cvX4a2tjays7PRoUMH7Nq1i5HP/hXY6pf8Ctra2jh58qTEx4fZ0q2v2v+VNhcXF+Po0aNISUlBbm4uBAIBGjdujLZt26Jfv36YMmUKkfFPtnR/lf/Kfv436NZX7f9qm1+/fk2b1SiKwpgxY2BlZQUNDQ3GtThtrs31pc0cHBwcTMIlYXJwcPwSioqKYmVWJYG6ujqePn3Kmglz8ODBRCe8v4Wamho2b94scd2oqCgEBwejsLAQQPV+t7W1hbW1NXHtL1++4NSpU8jOzgafz4eqqqpEVjwpKCjg3bt3kJKSQmZmJj0x+PDhQ8YnzEaNGoVjx45BTk7uh4kxTKdK1KRhw4YYN24csc//HmyleAgEAoSGhsLQ0BCdOnWCs7MzEhISoKOjAz8/P+KT8myl2LVv3x4ODg7EPr8u7t+/jzVr1uDly5ci2ymKAo/HI2pqiY2NpZMJSWNpaUlP7NeVXieEdJtPnjyJtWvXYtWqVbQJMz8/H7Nnz0ZAQADRiTQlJSW8efMGSkpKUFFRoctaNW7cGB8+fGBUKzc3F0pKSuDxeMjNzaV1ai5OEG4nafS1s7PD0qVLUV5ejnHjxkFFRQUbN25EVFQUgoKCiOm6urrC1dUV2dnZ2Lx5M5o2bYq4uDjw+fxfKpX5v9CkSRNUVFQAAFRUVPDkyRMYGBiga9eujKfZsZWmVpvbt29jz549IotBWrRoAQcHB1hZWRHTbd++vdi2Tp06QVZWFl5eXoiLiyOmHRkZibi4OLi6usLDwwNAdXq1u7s7FBQUYG9vT0w7NDQUzs7OmDx5MkJDQwEAVlZWaNasGYKDgxk1qdVMyWaztGaLFi3QqVMnievu2bMHISEhtAETAG0wtrS0JGrCbNKkiUQWSQhhKy2wNpI8voVER0fj0KFDIgutGjZsCFtbW0yZMoVxs9jSpUvp3xcvXowVK1aItSsyMhIXL15kVPdbyMvLY9KkSZg0aRKqqqpw//59onp8Ph8DBw7EwIED4eDggNzcXFy7dg0XLlyAt7c3UlNTierLyMiIJPrm5OTg+vXriImJIWrCbN++PczNzWFubg6BQIA7d+4gMTERDg4OOHfuHDHd+Ph4nDhxQmy7cJ+TQtLn1e/QJ1qyZAmqqqpQXFxMJ53++eef0NDQIJ6UzdZ+FmJlZYU3b95gw4YNdNp9w4YNMW3aNCxatIgxnXXr1mHYsGF48uQJxowZg9GjRzP22b8CW/0SDo7/IpmZmbC1tYWsrCz69euHbt26QUZGBmVlZXj37h2ioqIQGhqKsLAw9OjR41+vy8HBQR6BQIBLly7h5MmTSEpKgqKiIiZMmIB3795h5syZWLp0KebMmcNp/8t12dSuj23m4ODgIAFnwuTg4PglVq1aBS8vL7i6ukJFRYVoea2aiWIGBgZwdnbGkiVL6tQllfL1vWQcKSkptG3bFhMnTsSiRYsYL3H3LTMFj8ejtceOHYvOnTszqnv06FH4+PjAwsIC/fr1Q1VVFZKTk+Hv74+mTZtiypQpjOrV5O3bt7CwsEBhYSE6d+6MyspKHDlyBLt27cLBgwfRtm1bYtrGxsawt7enVwYPGDAACQkJ8PT0ZLzNkydPpksym5iYMPrZvwKbpgMrKysEBgaKGZwLCwtha2uL2NhYIrp+fn6Ii4uDrq4ukpKScOLECdjZ2eHKlSvw9fUl/p0MHDgQmzdvRosWLQAAurq6ePDgAby8vDBw4EDGdITfb/PmzX9oFCKVeOrl5YUWLVogMDCQeJnk2gwfPhwHDhzAkiVLiBu4L126RJt3SZrBfsSePXuwdu1amJub09u2b9+OqKgo7Nixg6gJc+zYsVi9ejV8fX0xaNAgLF++HH369MHFixcZn8QbNWoUnV73rUlpSRh99fX1kZiYiPz8fKipqQEAjIyMMG3aNKJJnPLy8mKJPytXrpRIucB+/fph165dcHFxgZqaGo4cOYJ58+YhJSWF8QU6kydP/uk0NZJ8/vz5m2ncQkOqJGnTpg2dFE6Kw4cPw8XFBaNHj4anpyeA6mNbWloa3t7eRE2Yz549Q79+/cS29+vXD3l5eYxqTZ48mf6dx+PRbazJly9fcOTIEUZ1a7Nw4UL4+PjAzc1NoovNBAIBvnz5IrZduACLJPPnz0dAQAC8vb0lVlZKWVkZFhYWsLCwEEkLXLlypcTSAiV5fAvh8/nIzc0Vuy/l5ORAVlaWiKaQpKQkrF69Wmy7np4e/Pz8GNX61nMDn89HixYt0KtXL8jLy0NHR4dR3R/Rrl07mJmZwczMDOXl5RLVBqorSnTt2lUiCymFSEtLQ1dXF7q6usS1mjdvjqysLKioqIhsT0lJETGYM42kz6uafSK2ePHiBWxtbTF69GisWbMGQPW1vFWrVti3bx+UlJSIabO1n2vqrF69GsuWLcPTp08BAF26dCFy/xo+fDiGDx/O+Of+Cmz1SwDRxXY1qaioQFZWFp2s27FjR0bNv7Gxsd/tBwqvoSYmJqyVw2TzGsCW9n+hzV5eXhg+fDg2bNhQ5/xJZWUlnJyc4OXlhcjISEY02dT9X2D6fP43aNfHNrOp/V9pc0pKCuLi4nDu3DmUlpbCwMAAwcHBGDJkCH3N6tGjB3bs2MG4Sa0+anNtrh9t5uDg4CAJZ8Lk4OD4JQICApCbm/vN9DwmDQ91JYq5ubmJvY+k0cLJyQn+/v4wNzdH3759AQBpaWk4cOAAzMzM0KJFC0REREBaWprx9JLy8nLEx8ejVatWdEJLVlYW8vLyoKWlhTt37mDXrl0IDQ2l/zYmCAkJgZOTk4iRZ/To0ejUqRPCw8OJmjB9fHygpKSEo0eP0gkLBQUFWLZsGTZv3owtW7YQ0161ahXatm2LV69eYebMmWjYsCEKCwsxbdo02NnZMapVs2SVtLQ0Jk6ciDZt2jCq8S1qDjD/yOjIdLJEYmIiMjIyAFSbrHft2iU2UfXixQvGE9VqcvbsWfj7+6NXr17w8PDAgAEDsGDBAgwdOhTz5s0jpitEUil27du3pxNF60pUkwTZ2dk4cuQIevbsKXHt3NxcxMfHIzw8HAoKCpCRkRF5nUmzZM3vNzAwEM7OzmKTM8XFxXB2diaakPjq1as6J7z19PTg6+tLTBeoTr4qLS3F27dvMX78eBgaGmL58uVo1qwZtm/fzqhWeHg4bWImZSD+WeTk5PD+/XucOXMGUlJS6NKlC7p06UJct6ioCM+ePUNVVRWAatOpQCBAWloaFi9eTEx3+fLlmD17Ng4dOoQZM2YgODgYAwYMwNevX2Fra8uo1u+Spta/f39ERUVh3bp19Lby8nIEBQURNfMI01yFUBSFT58+ITg4mHg60evXr+u8bvfo0QMFBQVEtRUVFetMvr937x5at27NqFZRURFKS0sBVPf3VVVVxdKwHzx4AH9/f6IGpu7du8PPzw9jxoyp83VSzzgjR47E+vXr4eLiAg0NDVAUhdTUVHh6emL8+PFENIVcvnwZKSkpGDRoEBQUFMDniw5LkV7QUDst8OnTp0hMTCSeFijJ41vIuHHj4OzsjOXLl4vs5x07dog865GgdevWuHnzptg16+LFi4z3TWuXKa5NgwYNMHPmTDg7OzOqC3x74aSUlBRatGgBTU1NjBw5ksjk77cWo/D5fLRs2RK9e/fG7NmzGf++v7XAq2abp0yZQtysNH36dLi4uCAnJ0fk+I6KiiJaAUDS51XNPhFbeHt7o1u3biL9vbNnz8LJyQkbN25kvL9fE7b2sxA7OzuEhISgV69etAmQBFOnToW9vf1PL8y8efMm/P39cezYMUb/Drb6JUD1YrukpCR6LFDI69evYWlpibS0NABgJBH+Z/qBWVlZIv3A9evX/2Pd/xWSAQg/oq4qH/9lXSa1Hzx4AG9v72/uv4YNG2L+/PmMj7OzpSvk/fv39PmUn5+PmJgY5OfnQ1VVFSYmJiLjwExXeGBLm80218W8efPg5eUl9ozxX9b+r7fZwsIC6urqWLZsGcaPH4/mzZuLvUdVVZV+xmWS+qjNtbl+tJmDg4ODJJwJk4OD45dYuHChxLTYTBQTEh8fj7Vr12L69On0NgMDA3Tp0gVHjhzBoUOHoKqqCl9fX8ZNmI0aNcIff/wBX19fekV2RUUF1q1bh8aNG8PV1RV+fn4ICAhgdOVqbm4uXcq2Jrq6uti0aRNjOnWRlJSEsLAwkUFXRUVFrFmzhkiJvpo0aNAAlpaWIttq/5sEe/bswR9//EFcR4ijoyN0dXWhoKDw3QlLHo/HuAmzffv28PDwoAc0ExISREqP83g8yMrK1pmawxTFxcV0aklSUhI96CgnJ0cPwpNEUil2NRM92Uo8VVJSYiX1BwCGDh2KoUOHSkQrNTUVr169AlBtcu7Vq5fYpHNOTg5u3rxJ9O9QUlLCnTt36jR3tGrViqi2tLS0iLHBzc2NNmEyPWE0YMCAOn8XUlRUJDZxRwKBQAB7e3tcuHCBvqbxeDyMGDECAQEBxJIphf2SsrIyeqGK0IDRvn17oiZMVVVVXLx4EV++fEGTJk1w9OhRnDx5EkpKShg7diwxXUmmqdVmzZo1mDlzJu7evYvy8nK4ubnh6dOn+PTpEw4cOEBMty5jDUVRaNKkCdEFKUD1cZSeno4OHTqIbE9MTCSeiDR9+nS4u7vT/ZOnT5/i+vXr2LZtG+NGyGvXrsHR0ZE+j+qahKQoivgg77p169CpUydMmjTpm6mrJFi/fj2WLVuGWbNm0ccaRVF0sjFJ+vbty+gCsv+FvLw82sjeqFEjTJs2DbNnzyaqKcnjW4i9vT1KS0vh6uqKiooKUBQFGRkZWFhYiCwKI4GtrS08PT1x//599O7dmzZOXbhwgfFr98OHD+vcTlEU3r9/j+TkZHh6eqJTp06wsLBgVPv169ff1C4uLqZLfYaHhzNuSvxWQqKwbPTdu3dx8uRJHD58mNHqGd8ydQp1d+/ejYiICBw+fJhoH3TRokVo2LAhDhw4QC90UlJSwurVq4majNk8ryS9iFLIvXv3cPToUSgqKtLb5OXlYW9vj5kzZxLRFMLWfhaioKCAT58+Eddxc3ODk5MT+Hw+jI2NMWLECHTu3FnkHH/48CFu376NmJgYVFZWwsfHh/G/Q9L9EmFZZKD6umlqaioyRgQAHz9+RLt27RjV/R36gX///TdSU1Px9u1blJWV0VV5tLW1xYw8NStFMUFeXh6Sk5NRWFgIgUCApk2bQkVFBdra2mL7/dy5cyLn/r9RF6heSPfw4UOx71tNTU1sQRBT2q1atUJ2dvZ3K2VkZGSgZcuW/1jrd9DNz8/HggUL8PDhQ/Tq1QteXl6wtrYGRVFQVlbG6dOnERERgcjISMaDCNjSZrPN37su3LlzB8nJyfS1hOkKcmxp18c2C1myZAksLCy+e94OGTIEQ4YM4bT/xbpsatfHNnNwcHCQhEexuayMg4OD4xcpKSnB06dPISUlBWVlZeLpCpqamjh16pRYgsfLly8xbtw4pKen4+3bt/jjjz+Qnp7OqHa/fv0QHR2Nbt26iWzPycmBmZkZkpOT8fz5c5iYmODevXuM6Y4dOxZ2dnZiSTCnT5+Gv78/Ll++zJhWbQYOHIgDBw5AVVVVZHt2djbMzMzw559/EtMGgCtXrmDXrl3Izs4Gn8+n0x5Gjx5NTNPW1hbDhg0jPvH7uzFy5EgcO3ZMImapmowbNw7Lli1D+/btYWJigtjYWKipqWH//v2IiYnBqVOniP8NeXl5iIqKoo8zVVVVTJ8+nfGJhZrcu3cPKioqkJeXR2xsLM6cOQMdHR3MmzePWJmn2NhYREdHw93dHV26dGGt/Atp7t27R08A1k5vFiIrKwsbGxuiE7ORkZHw9/eHlZUVtLS0wOPxkJGRgfDwcCxevJho2ebvTQhLS0ujTZs26NOnD+OGzI8fP2Lz5s2wsLCgr9d37tyBiooK9uzZQ9QwtmnTJpw5cwaurq7o378/KisrkZycDC8vL4wfPx6rVq0iojt+/Hhoampi7ty5mDZtGkJDQ/Hu3Tu4u7tj5cqVmDhxIhFdNhkzZgxmz56NGTNmiGwPCQlBTEwMEhISiOq/e/cOBw8exIMHD1BVVQVVVVWYm5uLmRSZ5O7du2LbpKSk0L17d8ZLv9cmJiYGvr6+WLBgAbZt24a1a9fixYsXiIyMhJOTk9h+YBp/f3+Eh4ejrKwMQHWim5mZGdauXSs2Kf9PSU5ORlVVFWbNmoUdO3bQKbvA/y8M6d69O9H7l6amJuLi4hg1SH2LiooKsUnmp0+f4vHjxwAAdXV1iZcelRS3b9+Gv78/QkJC0KxZM2hra4ssvlFXV8fRo0cZP8ZqI4nj+927d2Lmjc+fP+PZs2cAqktUS8rwGx8fj8jISGRnZ4PH46Fnz56YN28eKwkWMTExiIiIkEgaTk0KCgowf/58DBgwgC7jLElWrlwJoPrYkxQCgQALFixA+/bt4enpyehn379/n+7n1uT9+/cAIJZkxxS/y3mlpqZW53YZGRm0bdsW586dI6I7aNAg7Ny5UywFPD09HXPmzKmz3/JPYGs/18XGjRsRHR0NfX19dOrUSazCApPPdxUVFYiLi0NYWBiePHkCaWlptGjRgjZ1V1ZWQlVVFVZWVpg8eTKRdERJ9ksA4OvXrwgJCQFFUQgKCsLs2bPF+rpNmjTBmDFjGE/1Zasf+PXrV3h4eCA2NhY8Hg8tW7aEjIwMysrKUFxcTC+IdnV1ZXxhX1VVFdzc3HD06FF63ILP50NOTg4FBQVo0qQJFi9ezPj4JFu6AOhjKzw8vE5DddOmTWFjY4NFixYxrh0VFQU/Pz9YWVlh4MCBaNu2LaSlpSEQCPDu3TvcvXsXYWFhsLOzY7TtbOmuXLkSf//9N6ytrXHw4EFkZmZCR0cHW7duRaNGjfDx40csXboU8vLy2Lp1K2O6bGqz2WZ1dXX6fPreFD+JCnJsadfHNgsZMGAADh069F1zNSnqozbXZsnCpjYHBwcHKbgkTA4Ojl+GDaMaRVHw9fXFgQMH6LQBaWlpTJ8+HWvXriVmIurQoQOuXLkilk5y+fJltG3bFkC1IZOEkYzP56OgoEDMhPnu3Tu6vZWVlWKTqf8UMzMzuLu7o7i4GDo6OuDxeEhJScH27duJJ0Pq6Ohg586d8PX1pQc6y8vLERwcDG1tbaLaFy9exNKlSzF69GgYGxujqqoKycnJWLZsGXbs2IFRo0YR0ZWVlYWvry927doFFRUVsUF9kuV209PT6yyp9eHDB3h6ehJNGBOaeQUCAV6/fo2OHTuCoijiRr05c+Zg5cqVaNCgAQYNGgQ1NTUEBQUhKCgIGzZsIKoNAI8ePYKFhQUaNWoETU1NVFZW4vjx44iKiqKTdZlGaIQMDQ2FgoICnJycMHjwYISFhaG8vJyYMXD79u149+7dNxNZmB6UCgwMhK2tLRo3bozAwMBvvo/H4zGaFqijo0MnMKmpqeHGjRuMJjb8LJaWlhAIBAgPD8fu3bsBVJcCXbFiBeOpT7XZuXMnXr9+jaqqKjRr1gwA8OnTJxFTaufOnREWFkbfO5lg48aNSElJgbW1NS5fvozU1FT4+voiPj4evr6+YqmzTHL69Gl4eXmJGEkMDAzQsGFDuLu7EzNhPn/+HNu2bYOKigp69uyJoqIijBw5EhUVFdi1axdRE2ZmZibc3Nzw+PFjCAQCsddJlSeUZJpabQ4cOIDx48dj+fLlRHVqc/fuXfp6VpOSkhJ4e3sTKakrxNTUFBUVFQgODkZpaSlcXFygoKCAFStWEDdg3r17F0uXLsXChQvx5MkTUBSFLl26EFt0JUyoiIiIgI6ODuN96p9BVVUV+fn5EjE7DBgwAIMHD6ZLcbdp0wZdunRBly5diGvXRNJJbhkZGZgzZw5GjRqFiooKeruvry/atGmD3NxcODs748yZMzA2NmZUuzYrV64kfnwbGhpCWVkZ+vr60NPTg7a2Npo0aQINDQ1GdeoiPj4ew4YNo40sxsbGxL/Tn6VPnz7w8vKSuK6ioiKWLl0KLy8vVkyYFhYWsLOzk6imtLQ05s6d+81S7f8ER0dHFBcXY+jQodDX14euri7k5OSIm/LYPK9qUjv1taKiAi9evICLiwvRREp9fX14eXlh69at9ALlV69eYcOGDdDV1WVcj639XBcXLlyAgoICMjMzkZmZKfIaj8dj9Fmaz+fD1NQUpqamePHiBe7fv4+CggLweDy0adMGmpqaxBdLSLJfAgCNGzemv0Mej1dn/5cUbPUDN27ciDt37mDfvn0YMGCAyBhYeXk5bt++DTc3N2zatInxEug7d+5EcnIyoqKioK6ujtevX8PLywsGBgYwNTXF2bNn4eXlhcaNG8PMzOxfrwsAW7ZswdGjR+Hg4IBBgwahdevWtOn13bt3uHnzJrZu3YqqqirGx8ZmzpwJWVlZ7N69G7t37xaZu6AoCp07d8batWsxderU/4Tu9evXERkZCTU1NfTo0QMGBgZYuHAhGjVqBABo3rw5HBwciCTAs6XNZpsjIiKwevVqdOrUCWvXrqVLnlMUhfHjx2PPnj3EFvuzpV0f2yxERUXlhwm3nPa/X5dN7frYZg4ODg6ScEmYHBwcv0RNo1q/fv1oo9qVK1eIGtV2796NkJAQ2NnZiegGBQVh3rx5mDNnDhHdU6dOwdHREWPHjoW2tjaqqqqQlpaGc+fOwd3dHTo6OrC1tYWBgQHWrl3LqLarqytu3boFNzc3aGlpgaIo3L9/H56entDR0cH69evh4uKC9+/fIyQkhDHdqqoqbNy4EYcOHUJlZSUoigKfz8e0adOwbt06ogkxwpRP4YQGj8dDeno6SkpKEBkZCXV1dWLakydPhoGBgZg5KzAwEFevXsWxY8eI6P5ocopkKekBAwYgLCwMvXr1orddvHgRbm5uoCgKSUlJxLQBwM/PD5GRkSgvL8e5c+ewdetWyMjIwMPDg6gZ8+HDh3j9+jX09PQgLS2Na9eugc/nS6SkwZw5cyArKws/Pz861aCsrAwODg4oKyujzXNMYmhoCAsLC8ycORPbtm3DpUuXcPLkSVy7dg1ubm7E0m1PnDjx3dcnT57MqN7IkSMRExMDOTk5jBw58pvv4/F4uHTpEqPavxvv37+HlJQU8bRoIWFhYTh+/Di2bNmC7t27A6hOV1u9ejVMTExgYGCAdevWoVmzZoyWUh4yZAiCgoKgra0NZ2dnFBYW0otELCwsGC/bVhNtbW2cOHECKioqItufP3+OCRMmMJ6OLaRfv344ceIElJWV4erqio4dO8LW1ha5ubkYP348UlNTiegCwMSJEyEjIwMTExOxBQMA8+d0TdhKU9PX18f79+8xYsQImJqaQldXl9jCn5ycHBQVFQEArKysxBJ5gGojv6+vL9LS0oj8DQBw8uRJ6Ovro0WLFigqKgJFUVBQUCCmV5NBgwYhJCREpF8iKR4+fIhHjx7RJaopioJAIEBaWhrRRRqJiYnw8vLC7Nmz0blzZzEDAJOlzP7++28kJibi2rVruHnzJtq1a0cbinR0dIgkatWFpJPcli1bhkaNGmHTpk30Nh0dHcTFxdFmFhcXF+Tl5WHPnj2Maufm5v70e5matCsvL0dKSgquXbuGxMREFBYWYujQodDT04Oenh7RFHpbW1vcu3cPPXr0oM2+JJ/ffoWXL1/CxMQEKSkpEtd+9eoVjI2NifUNvkdubi7++OMPZGRkSFT3zZs3MDQ0JNLmV69eITExEYmJiUhJSUH37t2hq6sLfX199O7dm3E9gN3z6mfIyMiAvb09sSTMoqIi2NjYIDs7G82bNwdQnUjfq1cvBAcHEyk7z8Z+5pBsv6QuKioqUFhYiMrKSgCi/TGmF2nURJL9wAEDBmDHjh0YOHDgN99z+/ZtrFy5Ejdv3mRUe+TIkfD19UW/fv3obe/evcO4ceNw8+ZN8Pl8nDt3DgEBAThz5sy/XhcAhg4dCg8Pj+/OV1y8eBGenp5ITExkVLsmRUVFyMvLw9evX9GoUSMoKSnVee+4ceMG+vfvX+fz9u+u279/f0RHR9MmGltbWzg4OIj0/bOysjBnzhzGj222tNlsM1C9SNPV1RVpaWnw9fWlE6u1tbVx8uRJosZ9trTrY5sBwNnZGSdOnICamlqdIR4k54/qozbX5vrRZg4ODg6ScEmYHBwcv0RQUBCWLFkiYlSztrZGYGAggoODiZkwDx8+DFdXV5EkDXV1dcjLy2PHjh3ETJjjx49H06ZNERoaCn9/f/D5fPTo0QPBwcHQ1dVFcnIyxo8fTyRJzsnJCatXr4aNjY3IhL+hoSGcnZ1x8+ZNJCcnM27aatCgAZydnbFs2TI8ffoUAIimENWka9euiIuLQ1RUFB4/fgyKojBu3DiYmZkRX/Gfk5ODgIAAse3jxo3D3r17iekuXboUbdu2FTO3VlRUICsri5guAJiYmMDGxgbh4eFo27YtPD09ER8fjwkTJjBuKq6NsBygq6srPDw8AFSnyLm7u0NBQQH29vbEtNXU1NClSxc6gXPw4MESK5WdmpqKw4cPi5SVkpGRwaJFi4ilFb5+/Zo2JSYlJUFPTw8A0K1bNxQUFBDRBMgasuri9OnT9EpkUsbSHyEQCHD48GFkZ2fTE0fC7RkZGTh//jyjesnJydDW1gafz/+h4ZDkhFlYWBgCAgJoAyZQfd9Yt24dli1bBnNzcyxfvpzxkuhfvnyBkpISAODmzZt0Ka3GjRuLfP8k6N69O86ePYsFCxaIbE9ISCCaHKOpqYno6Gg4ODigW7duuHLlCmxtbfHkyRPi17Hnz5/j2LFjRBJ7fwRbaWpXr15FUlISYmNjYWdnh2bNmmHSpEmYPHky4+mBr169woIFC+g+37f6lqampozq1sbLywu9evVCixYtJG4qUVBQqLNMIGkiIiLoCfaaCb48Hk9kspgE8+fPBwC6L1QTpkuZtWrVClOmTMGUKVNQUVGB1NRUXLt2DR4eHsjPz6dTMvX09IgmOks6yS01NRVBQUEi22qvRZ44cSKWLl3KuPbIkSN/aNymKIrRfS0lJYXBgwdj8ODBWLNmDd68eYPExEScPXsW7u7u6Nq1K22QrCsR/58QEhKC0tJS3Lp1C4mJiViyZAkEAgFtnBo2bJjEFojUJikpSWLJbrX5+vWrWHldSZGXl8eKQbC4uJg26zGNsrIyLCwsYGFhgbKyMty+fRvXrl3DypUr8eXLF+jq6kJPTw9GRkaMabJ5Xv0MsrKyePv2LbHPl5eXR0xMDG7duoVHjx7RFXEGDx5MbHEKG/tZiJWV1U+9j8fjITw8nHF9NpFkv6Q2t27dgoODAwoLC8Vea9SoETETJhv9wNoLrWrTpEkTlJaWMq774cMHtGzZUmRby5YtUVJSgvfv36NVq1bQ0NBAXl7ef0IXAEpLS8UWTtZGWVkZHz58YFy7JvLy8j91P7azsxNZKPRv0u3fvz+2bt0KLy8vtGzZUiww4tWrV/D09CSyAJ4tbTbbDABNmzbFli1bEBcXh4ULF8LMzIzIM83vpF0f2wxULyjr27cvgOrFlZKkPmpzba4fbebg4OAgCWfC5ODg+CXYMqoVFhbWudpdS0uL6GAzAIwYMQIjRoyo87X+/fsTM7Y0atQI27dvx+vXr5GVlYWGDRuiR48e6NChAwBAT0+P2CrdsrIynD17Fo8fP4a0tDS6d+8OQ0NDiZTnadeuHRwcHFBSUgIpKSnGVv/+iNatW+P58+d0eS0hz58/p8vrkmDUqFFISkoSGxR7/fo1LC0tiaZdOTo6gs/nw9raGnw+HzIyMti3bx+GDRtGTFPI4cOH4eLigtGjR8PT0xMAYGRkBGlpaXh7exMzYVIUhS1btrCSwAlUD6bXVca3rm1MoaCggHfv3kFKSgqZmZlYsWIFgGoTBOmy2YmJiQgJCcHTp09x+PBhxMTEoGPHjkQmUIYNGwYjIyNMnToVWlpajH/+z7BhwwYcP34cvXr1QlpaGrS1tfHixQsUFhYSKT9kaWmJpKQkKCgowNLSUmTSqCakJ8w+ffpUp6miUaNG9GRG8+bNUVZWxqhu165dcfXqVSgpKeHt27e0wfjIkSPES5gsXLgQixYtwsOHD6GjowMej4eUlBTiJbIXL14MW1tbyMvLw8TEBIGBgTA2Nsbbt29haGhITBcAevfujTdv3rBiwmQLHo+HYcOGYdiwYfj8+TPOnz+P8+fPw8TEBGpqapg6dSqMjY3pcmP/hOHDh+Py5cuoqqqCgYEBjh49KtI34PF4kJWVFZvAZBo2ywANGzYM8+fPh76+Pjp16iTWBySx6AmoLjs/f/58LF68GCNGjMDx48dRXFyMVatWEVtgJoStZGY+n4+BAwdi4MCBcHBwQG5uLq5du4YLFy7A29ubaKpuXX9L165d4ejoCHt7e8YNNR8+fEDbtm1Fti1evFjkXFJSUkJJSQmjukC1sYNt2rdvD3Nzc5ibm6OsrAx37tzBtWvX4ODgQCQ1r1GjRiLPz0+ePMG1a9dw6NAhODo6onfv3tDT08PcuXMZ0/xW4mhVVRU+ffqE5ORkbNu2DY6Ojoxp/gonTpyQeNlqoPr5YteuXRg8eLDEtYXlfUkjIyNDmx+B6iT2xMRExMTEEDHnCZH0eSWk9qIriqLw6dMn7N+//5spw/8r+fn5aNOmDf3vhg0b0n2in/0/TCHp/dy+fXvGP/PfApsVI/z9/aGhoQFLS0ssWbIEfn5+yM3Nxfbt24kmIEm6H6irqws3Nzf4+PjUaQ589eoV3N3d6WdbJtHQ0MD27duxZcsWeuwrPDwczZs3pxNtT548iY4dO/4ndIHqShL+/v7YtGlTnWMWnz9/xpYtW2jzB9uwVbSQCV0nJyfMmjUL7u7u2Lp1q8hr58+fh52dHdTU1Ij0x9jSZrPNNZk4cSL69u2LNWvWYNq0acQXJf8O2vWtzZGRkcQ1OG32ddnUro9t5uDg4CAJZ8Lk4OD4JdgyqqmoqCApKUlsQObGjRuMlW4TEhgYCFtbWzRu3BiBgYHffS/Tk8G5ublQUlICj8ejJ5MaNGggMmkj3M50u4W8evUK5ubmKCkpQefOnVFZWYmIiAjs3LkTe/fupU2gpAgPD0dYWBjy8/PB4/HQoUMHLFq0iGjpIaDaSOzu7g5XV1d68C01NRUeHh4YO3Yso1pRUVEIDQ0FUD3QZWpqKpaE+fHjR2L7uCb29vaQkpLC7t27cejQIYmZ116/fo2ePXuKbe/RowfRdMbIyEjWEjiB6lKrvr6+2L59Oz35X1RUBD8/PwwaNIiIprGxMezt7dG4cWO0bdsWAwYMQEJCAjw9PTFlyhQimkB14tCSJUtgbGyM+/fvo6qqCpWVlVi7di0qKysZT3NbsGABTp48iWPHjqFbt26YMmUKJk6cCDk5OUZ1vsfFixfh4+MDIyMjjBkzBp6enlBWVsaKFStQXl7OuN6lS5dok9aFCxfEriOSol+/fti8eTP8/f3pvsDHjx/h7+8PbW1tANUD0EwnUNnZ2WHp0qUoLy/HuHHjoKKigo0bNyIqKkos9Yxphg8fju3bt2PPnj24evUqKIpC9+7d4e/vz/g9oyZ9+/bFuXPnIBAIICcnh4MHD+LQoUNQUlL66dSe/xVPT08sWLAA6enp6NChg9jxRvo+zTZfvnzBhw8f8P79ewgEAjRo0AC7d++Gv78//Pz8GDG5CO/7ly5dQrt27YilS30PVVVV2NvbY9++fRIvA3ThwgUoKCggMzMTmZmZIq/xeDxiJszc3FxMmTIF0tLSUFNTQ0ZGBgwMDODo6AgfHx/GTfS2trbQ09ODvr7+D5N5JEW7du1gZmYGMzMzIvern4FUkpu8vLyYMah2FYW3b98SWZgyYMCAOrcLBAKRVHRJISMjQ5dPlhTdunVDt27dYGNjg8+fP+PmzZu4du0aoxrfSxylKArNmjXDvHnzMHXqVEZ1ASA2NrbO7VVVVfj48SNSUlJw9epV7N+/n3FtJyenOrdTFIWPHz8iPT0dPB4PR44cYVT3W2MkQt3U1FQ8e/YMhw8fZlS3NnWZbxs1aoSxY8di/PjxqKqqkkjfWJLn1bcWXSkrKzO+CMjGxgZjx46FpaXlDxeAFBYWIiIiAhcuXEBCQgKjfwcb+7m+lTz8Xfol2dnZOHr0KHr06AF1dXXIysrC0tISsrKyCAkJgYGBARFdSfcD169fj6VLl8LQ0BCtWrWCkpISpKWlIRAI8O7dO+Tl5UFbWxsuLi6M6gLA6tWrYWFhgT/++AO9e/dGXl4eMjIy6CTQJUuW4Pr169ixY8d/QhcAXFxcYGNjg6FDh0JdXV3s+/7rr7/QunVr7Nu3j3Ht+oaysjLOnj1b53VbQ0MDgYGB0NPTE+kDl5aWMrKgkS1tNttcmw4dOiAyMhLBwcH48OFDnUEa/zXt+tbmL1++4OTJk8jOzgafz4eqqiqMjIwkUmmgPmpzba4fbebg4OAgBY9ia3kVBwfHv5KAgACcPHlSzKjm7u6OkSNHYt26dUR0Y2Nj4eLiAktLS5HEqaioKDg4ODBaxnfkyJGIiYmBnJwcXcK3Lng8HuOrxHv27IkbN25AQUEBampqdU4mMV2yrjY2NjaQlpbG5s2baTNNUVERVqxYgcaNG2PXrl1EdAFg//792LZtG6ysrKClpYWqqiqkpKQgOjoa9vb2xMo1A9XpnytWrMDly5fp752iKOjr6yMgIACNGzdmTOvr168ICQkBRVEICgrC7NmzxUrUNWnSBGPGjGE8heFbJp379+9DVlZWpJwwyfQeIyMjLFmyBEZGRtDW1sbJkyehrKyMAwcO4ODBg4xP3ggxNjbG8uXLMXr0aBHdixcvwtvbG1euXCGiKyQvLw9mZmb48OEDVFRUwOPx8OzZMzRv3hwHDhxgrORQTaqqqhAVFYVXr15h5syZ6NSpEyIjI1FQUIClS5cSS7g1MzPD2LFjYW1tLfJdh4SE4MSJEzh9+jQR3fT0dMTFxSEhIQElJSUYOXIkpk2bhqFDhxLRq4mGhgbOnz+Pdu3aYcmSJRg7dizGjRuHjIwMLF++nGiyiImJCTZs2MB4Cs7P8OrVK8yaNQvv379H586dQVEUnj9/Djk5Oezbtw9v377FvHnzsHXrVowZM4ZR7ffv3yM/P59ud1paGpo2bcpKip8kcHJygrOzs9ggVHFxMZydnYmaT4ODg7Ft27Y6XyOdtsoWZWVlOH/+POLi4nDr1i0oKipi0qRJMDU1pRcGubu74/Lly4ynk1++fBnZ2dkiqQoCgQBpaWlES19aWlp+9/X/4gr1gQMHIjo6Gp07d4anpydatWqFBQsW4O3btzAyMsKff/7JqF58fDwSExNx48YNNG3alDY+DBw4UGLGvG+Z1ng8HqSkpNC2bVtMnDiRiLn6e0luZWVljBvG7Ozs0K5du+8m0Li6uqKsrAw+Pj6Matfm0KFD2Lt3L/Ly8nDu3Dns27cPrVq1ImYw/tbzJACR/bxo0SLGTd+197OQmscYU4l5d+7cqfPv5/P5aNGiBTp37kzMjPetfpdQu3fv3pgzZw6Rkrbful5LSUnR2qampj8se/urfGuMpKaulZWV2MJdpvne8Q0A0tLSMDY2hpubG6PXVjbPqzdv3tSp2bp1a0Z1gOp0uM2bNyM2NhYDBw7EiBEj0L17d8jLy6OqqgpFRUX466+/cPv2bdy8eRMTJkzAmjVrGJ8oZWs/1yd+h34JAGhra+P06dNo3749nJ2d0b17d8yaNQtv3rzB5MmTcffuXSK6ku4HCvnzzz+RmpqKvLw82qjTtm1b9O/fn+ji6NevXyMyMhLPnz9Hq1atMGnSJPoedf78eaiqqjK+eJJNXQCoqKjA2bNnRb5vGRkZKCkpoX///jAwMPhtrh81x87qg66Ojg6j5df/Ddr1sc1sav9X2vz27VtYWFigsLCQDk158eIFFBQUcPDgQbHKD0xSH7W5NtePNnNwcHCQhEvC5ODg+CUWLlyIR48eYf78+WJGtZUrVxLTnTRpEoqLi7Fv3z6EhIQAqC6xa2dnx7gx7/Lly3X+XpuqqipGdYHqFEjhJAlb5etSU1MRExMjkmwqLy8PR0dHzJgxg6h2WFgYPD09MW7cOHqbgYEBunbtiuDgYKImTBkZGezcuRM5OTl49OgRKIpCjx49iBh5GjduTE+28ng8OnlVEnzL1Cnpklu2trZwd3dHfn4+KIrCrVu3EB0djcjIyG+mujABWwmcQtq2bYv4+HjExcXh8ePHoCgKU6ZMwfjx44mlCTdo0EBskvZHJhsmyM7Ohq+vr9j2MWPGYPv27cR0NTU1oampCScnJ1y9ehWxsbFYsGABWrVqBRMTE5iamkJJSYmItqKiIgoLC9GuXTt07NgRjx49AgDIyckRP77evHkDWVlZohrfQllZGQkJCYiPj8eDBw/QsGFDWFlZwdjYGNLS0pCRkcGpU6fQpUsXxrXl5ORE0k4lWYo+KysL+/fvx+PHjyEtLY3u3btj7ty5jJdRS01NxatXrwBUL0rp1auX2AR3Tk4Obt68yahubSIiIrBs2TLMnj2bSJLAt7h79y60tbXp0nWSZPDgwaioqMDw4cOxc+dO6Orqihl5Bg8ezLjBeuvWrdi9ezdat26Nv//+G23atEFBQQEqKythbGzMqFZt2DRZfquksNC0JS8vT8RI1a9fP+zatQsuLi5QU1PDkSNHMG/ePKSkpIgtkmECY2NjGBsbg6IoZGRkIDExEdu3b0dOTg769+9Pmx9Ips+bmpoiKCgIBgYG9MK6tLQ0nD17FiYmJmjQoAHc3d1RXl7OeHqgJJPcAMDCwgI2NjZQVlbGzJkzxV4/evQoYmJiEB0dzbh2TU6dOoUtW7Zg1qxZdNpS165d4efnBxkZGUbLcwtxcnKCv78/zM3NRfbzgQMHYGZmhhYtWiAiIgLS0tKM61tbW9PPy8J9XdtINWDAAOzYsQPNmzf/R1oDBw78R///n/Dw4UPWtNm6Xn9vjESSeHt7w9fXF0uXLqWNPPfv38f27dsxc+ZMdOzYEYGBgdixYwdWrVrFmC6b55Ukn9mbNGkCNzc32NjYYP/+/QgODqarlQDV53W7du0wcuRIxMXFEUtQZGs/s82bN2+QlpYGgUAg9hrTCyR+h34JUG24vXDhAqytrdG5c2ekpqZi1qxZyMvLI6or6X6gEG1tbbpqhCTp0KHDN8fcmF4w+TvoAtULI8aNGycy1szxe8BmPtC/ufQ7p/376zKt7ePjAyUlJRw9epSuiFRQUIBly5Zh8+bN2LJlC2NanDbX5vrSZg4ODg6iUBwcHBz/A0+ePKESEhKo+Ph46smTJxRFUVRVVRVx3dLSUqqwsJAqKCigcnNzieuNHDmSev/+vdj2vLw8asCAAUS1d+zYQX358kVs+6dPnygvLy9iumPGjKGSkpLEtt+6dYsaPnw4MV2Koqg+ffpQT58+Fduek5NDaWpqEtUWUlhYSOXm5lJv3rwR+SHJly9fqPv371PJycnU3bt3RX7+y0RHR1P6+vpUjx49qB49elBDhgyhQkNDiWoaGhpS8fHxFEVVH28vX76kKIqiIiMjKUNDQ6LaFEVRjo6O1KdPn8S2v3//nlq0aBERzcrKSiouLo5ycXGhnJycKEdHR5EfUujq6tLHcM3v+tKlS5Suri4x3booLi6moqOjqcmTJ1Pq6urEdFxcXKjJkydTDx8+pC5cuEANHz6cSk9Pp3x8fKgxY8YQ06Uoitq7dy9lYWFBXblyhcrJyZHoNUxIWVkZlZOTQwkEAkogEBDXe/r0KWVtbU317t2bUlNTE/shSVJSEqWmpkaZmZlRGzdupLy8vCgTExOqd+/e1K1btxjVSk1Npa+Tampq9O81f7S1takdO3YwqlsbbW1t6tWrV0Q16mLgwIFUZmamxHUpiqL2799PFRUVffc95eXljOvq6+tTBw4coH9/8+YN9f79e8rc3JwKCAhgXK8mtfshwp/k5GTq/v37VF5eHjFt4TH+rR9NTU3KycmJKisrY1T30aNH1NChQ6m9e/dSJSUl1IgRI6i+fftS6urq1JYtWxjV+h6FhYXUiRMnqBUrVlADBgwg2i+ZPXs2tWvXLrHtYWFh1Jw5cyiKoqgTJ05Q48aNY1z79evXYj/5+fmM69Rkz549VM+ePakxY8ZQ69evp7Zu3Uq5urpSRkZGlLq6OhUeHk5Un6IoatKkSdTx48cpihLtFx0/fpwaPXo0Ec2pU6dS0dHRYtuPHz9OmZmZURRFURcvXiTSRzl58iQ1YsQI6vLly9THjx+pjx8/UteuXaNGjx5NhYaGUqmpqdTUqVOp9evX/2OtRYsWUS9evPjp9z99+pRasGDBP9alKKrO53US/6cu/vrrr1/+PxkZGf9Y93+5D5C4d4wbN45KSEgQ237hwgVqwoQJFEVR1M2bNxkfw5D0eWVpafnTP6R5+/YtlZ6eTmVkZFDv3r0jrkdR7O1nNjl27Bilrq5eZ5+f9DNOTSTZL6Go6nGCnj17UlFRUVRubi7Vu3dvau7cuZSenh61dOlSYrq/Sz+wJqWlpdSJEydY0RYIBKyMRbKly7Z2bWr2ETnd/6Z2fWwzm9r/lTb37duXSk9PF9uelpZGfI6yPmpzbZacLtvaHBwcHKTgkjA5ODh+iVGjRiEmJgZdu3YVSQjMz8/HhAkTcOfOHSK6hYWFsLOzQ9++fenEzYEDB6Jnz57Ytm0boyW2EhIScP36dQDVq889PDwgIyMj8p43b94wXloKqE6yKioqAgAEBQVBTU1NrG2PHj3CkSNH4OzszJhuzeQhS0tLrFu3DuvXr0ffvn3RoEED/PXXX3B1dcWyZcsY06yLUaNG4dChQ1i7dq3I9hMnTkBPT4+odnp6OpYvX463b9+KbKcIl3+/evUqHBwcUFJSIrZCUhLlXfPy8hAVFYXs7Gzw+Xyoqqpi+vTpaNeuHVFdAJg+fTqmT5+OoqIiUBQFBQUF4ppsJHCynWK3adMmREREQE1NjfHycN9j/Pjx8Pb2hre3N3g8Hj5//ozExER4enrCyMhIYn9HUVEREhIScObMGWRnZ0NHR4eYlr29PdasWYOUlBSYm5vjyJEjmDp1Kvh8PjZt2kRMFwCdHpacnCxyfyJ9DRNqbNmyBZGRkSgvL8e5c+ewdetWyMjIwMPDg1iCoZubG3Jzc2Fvb08sSfZbbNy4EQsWLBC7L27YsAG+vr44fvw4Y1o6Ojp00paamhpu3LgBRUVFxj7/Zxk3bhzi4+Mxf/58ieoqKCjg06dPEtUUMmvWrB++h89n/pG6oKAA+vr6AKr3eXp6OsaOHYsVK1bA2dmZaH9Mkul1tWEr7UpVVRUXL17Ely9f0KRJExw9ehSnTp1C27ZtMXbsWMZ0foS8vDwmTZqESZMmoaqqCvfv3yemde/ePbi6uoptHzlyJLZu3Qqgej/X9Z5/iqTT1wFg7ty5GDBgACIjI3H9+nUUFBRATk4Offv2hZeXl0SSqJ49e1ZnSep+/foRS/l6+PAhBg0aJLa9b9++9L5VV1cXe/5hgu3bt8Pd3R26urr0Nl1dXbi7u8PV1RWzZ8+Gk5MTli5dCg8Pj3+kZWpqCisrK/Tu3Rvjxo2Dnp6eWJWBjx8/4s6dO4iJiUFmZibc3Nz+kWZN7Tlz5mDSpEk/TOotLy9HbGwsQkNDcebMmX+s7e7uDhUVFdja2qJ79+7ffe9ff/2FsLAwvHz5EkeOHPlHujY2Nvjjjz9gZWWFli1bfve9hYWFiIiIwIULF5CQkPCPdGvz8uXLOiscdOvWDc+ePQMAqKiooLCwkFFdSZ9XNa+ZZWVlSEhIQM+ePdGnTx/w+XxkZGQgIyOD8dTiumjbtq3EywGytZ/ZJDg4GCYmJkTKu/8KkuyXANV9kKNHj6Jhw4ZQUlJCSEgIQkNDMWrUKNjZ2RHTrasfePLkSSgpKUm0H1iTT58+wdHRkfHU05/hw4cPsLKyIj4W+bvosq3NwcHB8TM0bNiwzoo0MjIydaZmc9r/Tl02tetjmzk4ODhIwpkwOTg4fgibpkQh3t7eqKiowMSJE+ltYWFhcHd3h6+vL7y9vRnT0tbWRnR0ND3xnJubK2Ig4fF4kJWVJWKoefXqFRYsWEB/l8KS1bUxNTVlVHfkyJFipp2FCxeKbXNycmJ8ELCm8U0gECAyMhIpKSno27cvGjZsiL/++gv37t0jPqng7u6ONm3aYO3atYybCr6Hn58f+vXrh2XLlkncRPTo0SNYWFigUaNG0NTURGVlJY4fP46oqCgcOnQIqqqqRPXfvXuHQ4cOiZTyNTc3J/r9m5qaoqKiAsHBwSgtLYWLiwsUFBSwYsUKzJgxg4gmj8eDo6Mj/buXl5fYe2RlZWFra0tEPy4uDuvWrauzBCdJli9fjry8PPp6NXnyZFAUheHDh2PFihVEtb9+/YqLFy/i1KlTuHnzJuTk5DB58mRs2LABnTp1IqbbrFkz7Ny5k/73nj17kJWVBUVFRbRu3ZqYLlBdKpotIiMjERcXB1dXV9pIYWBgAHd3dygoKMDe3p6I7p9//onw8HBWyri9ePGizvvhjBkziJa0ravsaVFREV2uhSQKCgoICgrChQsX0LlzZzHz4caNG4noDhs2DPPnz4e+vj46deok1gf9Vl/p30yLFi3w+fNnAECnTp3w5MkTAEC7du2Qn59PVNvHxwdbt27F+vXrRYyQnp6emDFjBrS0tODj4wM/P79/bJyqzf79++Hm5gZDQ0N6m5qaGhQVFbFjxw7ExcVBUVERa9euZbzkaKNGjehBXwUFBVhbWwMAwsPDf8qM+7/yrQUgwhLsd+7cwdixY9G5c2dGdRUUFHDv3j2xe+K9e/cgJycHAPj7778Z65taWVn99HtJ3c+0tLSgpaVF5LN/BkVFRTx9+hTKysoi2+/du0esj9ChQwdcuXKFPp6FXL58mTZSvXz5ksg95O+//65zUVfr1q1p02mbNm0YMdmPHDkS/fv3R1hYGFxdXfHp0yd06NABcnJyoCgKRUVFePPmDZo3b44ZM2bA19eXseeN0NBQrF+/Hlu2bMEff/yBESNGoHv37pCXl6e1MzMzcfv2bcTHx6Nnz54ICQlhRPvQoUPYt28fzM3N0bZtWxHtqqoqFBUV4a+//sLt27fx9u1b2NrawsfH5x/rHjlyBJs3b8bw4cMxcODA7+revHkTEyZM+MfGz7ro2rUrYmJixO4HMTEx9LXtwYMHaNOmDaO6kj6vavav1q1bB2tra/rZUkhAQABycnIY0fvdYGs/s8m7d+9gY2PDigGTrX6JkF69etG/a2lpITg4mIiOkK9fv9J9QGE/sKioCNOnT4esrCxR7e8hLy+PS5cusaLdokULhIeH1xtdtrU5ODg4fgYdHR3s3LkTvr6+9DxleXk5goODiY+J1kdtrs31o80cHBwcJOFMmBwcHD+ETVOikKSkJISHh4ukb6qrq2P9+vWYO3cuo1pKSkr05J+lpSUCAwMZTdr8HsOHD8fly5dRVVUFAwMDHD16VGTwXvhd/yhx4lcJDw8naqL9Hq9fvxb5t3DCv6bRREdHB0+fPiX6dzx+/BjHjx9Ht27diOrU5sWLFwgICJC4LgD4+vpi0KBB8PPzg7S0NIDqdA0HBwf4+flh9+7dxLSzsrJgbm4OeXl59OrVC6WlpTh48CD279+P/fv3Q01NjZi2pBM42U6xKysrE0khkhRSUlLYsmULli1bhqysLFRVVaF79+7EjvXKykrcuHEDp06dwqVLl1BeXg59fX3s2LED+vr6P0wnYoqSkhIkJCTg0aNHaNCgAXr16iVy7yLFgAEDiGt8i8OHD8PFxQWjR4+Gp6cnAMDIyAjS0tLw9vYmZsKUk5NDkyZNiHz2j9DQ0MDdu3fFDExpaWlEr+efPn2Cr68vLCws0K1bN9jY2ODu3btQUVHBnj17xMw9TJKSkkIbmEilttXFhQsXoKCggMzMTGRmZoq8xuPx/pMmzMGDB8PX1xdeXl7Q0NDArl27YG5ujnPnzhE33Eoyva42kk67CgsLw+nTp9GwYUNMnDhRZLHC48eP4ezsjIyMDKImzPLycsTHx6NVq1bo3bs3gOo+Ul5eHrS0tHDnzh3s2rULoaGh6Nu3L2O6VlZW8PDwwPPnz9GnTx9UVVUhLS0NkZGRWLhwIfLy8uDm5sZY/4GN9Esh4eHhsLCwQMOGDX/q/RUVFYiMjMTs2bMZ/TumT58Od3d32jz19OlTXL9+Hdu2bRMzczHFwoUL4ejoiIyMDGhra9P7+dy5c3B3d8ezZ8/g5OSEMWPGMK6toaGBffv2wcvLi/7uKysrsW/fPrqff/fuXXTo0IERvWbNmsHOzg4LFixAcnIy0tLSUFBQAB6PhzZt2kBTUxP9+/f/6ePgZ2nbti327t2L27dvIywsDIsWLUJFRYXIe6SlpTFkyBD4+/tj8ODBjGk3aNAA8+bNg7m5OaKjo3Hp0iWEhYXR+tLS0tDU1ISJiQlMTEwYM542adIEbm5usLGxwf79+xEcHIz8/Hx6PIGiKLRr1w4jR45EXFwcVFRUGNGtzcqVK+n9XfP4zszMRGBgIB48eIA1a9Ywfi6zeV7Fx8fjxIkTYtuFaYX/Rdjaz2yipqaGFy9eEDM6fg82+iWPHz+Gj48PXF1d0bFjR3r7mjVrUFRUBDc3NyLfRWxsLDZu3Ih9+/bRbQWqFySlpaXB09NTZGGQJGnQoAFrfScpKSlWxhbY0mVbuzYmJiasGLDZ0uXg4Pg57O3tYWZmhtGjR0NDQwM8Hg/p6ekoKSlBZGQkp/0f0WVTuz62mYODg4MkPKp27VMODg6O7yBpU6KQfv36ISIiAurq6iLbHz58CHNzc9y7d0+if48kePPmDdq1a8eaObK+MWbMGPj7+0NDQ0OiuuPHj8f69etZGfDT1tbG4cOHxcrXPXz4EBYWFkhJSSGmPX36dHTv3h1ubm70ZKhAIICjoyPevXuHAwcOENNmI4GTTezs7DBw4ECJJGHm5uZCSUkJPB4Pubm5330v0yXvBw8ejOLiYqioqMDU1BSTJ0+WSIn7muTk5GDWrFn4/PkzVFRUUFVVhRcvXqBNmzYIDw8nWr5PIBDg8OHDyM7ORmVlpcj2jIwMnD9/npi2lpYW4uPj0aFDB2hra+PkyZNQVlbGq1evYGRkhIyMDCK6+/btQ0pKCjZv3iyRJOHY2Fj695ycHERERMDc3Bx9+/ZFgwYN6FKfixcvJpZs6+TkhJSUFOzatQtPnz7FypUrsWHDBsTHx0NKSgo7duwgoltfoSiKlX5YXl4eFixYgEmTJsHc3BxmZmZ0ebw1a9YQM2wBQJ8+fRATEyNmHs/JycHkyZORnp6O3NxcGBoaIi0tjVFtExMTDB06VCztasuWLbh69SpOnTqFy5cvY+PGjbhw4cI/0goMDERgYCAGDhwIGRkZ3Lx5E+vWrYOZmRlCQkIQEBAAWVlZIinwNVm3bh1KSkrg6+tLL4ipqKjAunXr0LhxY7i6usLPz482SDJJVFQUQkJC6Pt1u3btMG/ePJiZmeH69euIi4uDi4vLv75/5OPjgytXrsDS0hKGhobf7Bu8f/8esbGxOHToEIYPH461a9cy/rf4+/sjPDwcZWVlAAA+nw8zMzOsXbuW2GKRK1euIDQ0FH/99Rf4fD569OiBefPmQVdXF8nJybhx4waWLFkissiSCTIzM2FtbY3mzZtDQ0MDVVVV+Ouvv/Dp0yfs27cPVVVVsLKyos+7/wqlpaXIzMwUMYD26NFDrDw6KSiKwvv378Hj8ehUW0mQl5eHv//+m25zq1atJKL74MEDhIeH08e3mpoabGxsoKqqioyMDDx8+JBIRQ22zit9fX2sWbMGRkZGItuPHTuG4OBg1pLzSPPgwQPs378fWVlZEt3PbHH27Fls2rQJNjY26NKlC90/ENK/f39i2pLul7x48QLTpk1D69atsXXrVpHFbKdPn8bu3btRUFCAo0ePMmbaB4Bbt27B1tYWJiYmWL58ucgi2RcvXmDv3r04ceIEwsPD6YXi/yXS09ORnJyMt2/foqysDI0bN0bbtm3Rr18/aGpq/ud0fwcEAgFCQ0NhaGiITp06wdnZGQkJCdDR0YGfnx+xezZbuj9LzfGj+qJdH9vMpvZ/qc1v3rzBwYMH8fjxY1AUhe7du8PMzEwibauP2lyb60ebOTg4OEjBmTA5ODj+J54/fy6S8qWkpERUb/HixSgtLUVAQABttCgpKcHq1atRWVlJLLHv+fPncHd3R2pqKsrLy8VeF06Ik6CqqgqnT5+mtWtfrpks+2llZYXAwEA0b978h+UCmS4RKEw04PP5SE5O/ub7eDwe0cHPEydO4PDhw9iwYQM6d+4sMdPFtWvXsHnzZqxYsaLOAXamjWo1GTZsGHbt2iVmPE1PT4eNjQ1RE6ampiZiY2PRpUsXke1PnjyBiYkJ0tPTiejWTuCsrKxEZmYmBAIB8QROgB2j3N69exEYGAhdXV107dpVbDKQyRS5nj174saNG1BQUICamlqd55HQ1MT09dPJyQlTpkxhNCnsV5k9ezb4fD78/PzoxQpFRUWwt7eHrKwsAgMDiWm7ubnh+PHj6NWrF9LS0qCtrY0XL16gsLAQ1tbWWLNmDTFtIyMjLFmyBEZGRiKDjAcOHMDBgweRkJBARNfS0hL3799HZWUlFBQUxK6fTE9E/+z1gcTxLWTIkCEICgqCtrY2nJ2dUVhYiF27diE7OxsWFhbfvY/+L/zITF0TkvcroLq/kJOTg3HjxiEvLw+dOnVi3NxQGxMTE2zYsIH4veFblJWVQUZGBqWlpbh+/TratGmD3r17E+2jWFhYQFlZWSy9bt26dcjJycGRI0cQGxuLvXv3Ij4+nlHtGzduYMGCBdDQ0Kgz7apNmzawsrLC7NmzsWjRon+k9ccff2DixIn05wjbNHbsWAQFBWHs2LFwcXEhnjzar18/REdHiyXo5uTkwMzMDMnJyXj+/DlMTEyILTorLi4Gn8+XaPpNXl4eoqKikJ2dDT6fD1VVVUyfPp3YdeTPP/+Ev78/7t27Bw0NjTpLJz9+/Bg6OjpYtmwZ0WeOr1+/4smTJ6AoCl26dEHTpk1RUFAg0ZR0SfHu3TtER0eLGKeE/fCcnBzk5+djyJAhbP+ZHBz/Gnbu3InQ0FDMmjULGhoaoCgKqampiIqKgoODg0QW3XGQ53v9TpLPGYDk+yWrV6+mn2fq6teXlpbC1tYWnTp1woYNG/6xnhAbGxt069btuwsunJ2dkZ+fj3379jGmyzZFRUVYtmwZkpOT0aZNG7Ru3RoyMjIoKyvDu3fvkJ+fj0GDBmHbtm2Mhi+wpfs7sWHDBsTFxSE0NBTFxcWYO3cu7OzscOXKFXTp0oXRMf7fQfdn+S8Z5H533fqqXR/bzMHBwcHBwcE+XDlyDg6OX+Lz589YsWIFrl+/TpsCeTwejIyMsHHjRjEDBFM4OjrC3Nwcenp6dBma58+fo2XLlggJCSGiCQCurq7Izc2Fvb29RFK2arJp0yZERERATU2N+KRo+/bt6fQVSadvWlpaIikpCQoKCrC0tASPxxMznAJkBptrm8QoioKxsXGd7yU10D1v3jwAwKJFi8T+FtID7IMGDYKvry+2b99Ol7gvKiqCn58fBg0aREwXADp37ozHjx+LmTBfvHhBtOySu7s7xo8fX2cCp5eXF9EETqB6APR7RjkSHDp0CAoKCsjKykJWVpbIa0yX8g0PD6cHzZk2bP8ItgePAeD+/fs4cuSIyMSBvLw8Vq9eDXNzc6LaFy9ehI+PD4yMjDBmzBh4enpCWVkZK1asqHMRAZPY2trC3d0d+fn5oCgKt27dQnR0NCIjI+Hk5ERMd+DAgRg4cCCxz6/Nw4cPJab1Lb58+UIvfLl58yZderFx48Yixm6mGDly5A/7BKTvVyUlJbC1tUVaWhp4PB6GDh0KPz8/PH/+HPv37yeaMPvmzRvIysoS+/xvMWrUKMTExND35kaNGmH06NH0BOWdO3eIaTs6OsLa2hp37typM73u3r17WLduHdatW8e49rBhw3D06FHs378fN27coE1bnp6edNrV6tWrGUm7ysvLEykxaWRkBCcnJ4SHh8PHx0diZV35fD4KCgrEzA7v3r2jz73Kykrw+f986GbDhg1YunSp2DON8DirTXFxMQIDAxnf148ePYKFhQUaNWoETU1NVFZW4vjx44iKisKhQ4egqqrKqB5QPQEWGRmJjIwMXLx4EWlpafjzzz/B4/HQunVrjBw5Ehs2bBCrusAkPXv2RFJSEuTl5UXKnr5+/Rrjx4/Hn3/+SUQ3MTERjx49otM3a8JkH7AuWrduDTs7uzpf69q1q1jiLgfHj5g6dSrs7e1/uv9369YtbNmyBceOHWP072DrvFq0aBEaNmyIAwcOICgoCACgpKQkkWeNxMRE7Nu3D8+ePcPhw4cRExODjh07Er9fCgQCHD16FI8fP67z+/4dngGZhs1EU0n2SwDg7t278Pf3/+bCqkaNGmHx4sWM90WysrLg6Oj43ffMmDGDHq9jEuG458/A9JiKu7s7Pn/+jLNnz0JFRUXs9adPn8Le3h5eXl7YvHnzv14XwC+NR5C8npw9exb+/v7o1asXPDw8MGDAACxYsABDhw4lcpyxrVuzSk5NKioqkJWVRSefduzYkfGFlWxp18c2s6ld39r8rXsHj8eDlJQU2rZti4kTJxJJy66P2lybJafLtjYHBwcHKTgTJgcHxy/h5eWFZ8+eYc+ePXRCzb179+Dp6Ql/f/8fDmL9rygrK+PMmTOIj4/Ho0ePwOfzMWPGDIwfPx6NGjUioglUp6aEh4dDW1ubmMa3iIuLw7p16ySSZlBzoMnOzg5t27YVK4knfJBkmkuXLtHlTyQ92LxhwwbWy71L2qhWE3t7e5iZmWHEiBFQUVEBj8fDs2fP0Lx5cyJmxJoJbcbGxnBxccHff/8tUsp3y5YtWLp0KePaQh48eICNGzfSBkwAkJaWxqJFi2BiYkJMVwgbRrnLly8T+dy6GDBggMjvOTk5+Pz5Mz0AFRoaiuHDh4uZb/8rtG7dGnl5eWIGkpKSEuLlXIuLi9GnTx8AQPfu3ZGVlYUuXbpg/vz5WL58ORHDlBBTU1NUVFQgODgYpaWlcHFxgYKCAlasWIEZM2YQ0yVtHvkd6dq1K65evQolJSW8ffsWenp6AIAjR44QMbOEh4ezfp/09/cHj8fDhQsXMGHCBADVqTn29vbw9fWFv78/Me25c+fC2dkZtra26Nixo1ifk8nUvoSEBFy/fh1AtfnTw8MDMjIyIu958+YN8f2hoaGBhIQEkfQ6U1NTkfS6PXv2EEuv69mzJzZt2lTna7179xYxr/0TysrKRK7L0tLSaNSoEVasWCExAyZQncjp4uICNzc3aGlpgaIo3L9/H56enhg1ahS+fPmC4OBgRtrdoUMHGBsbw8jICOPGjRNLQheSlZWFmJgYnDt3DnPnzv3HurXx9fXFoEGD4OfnRy/gKysrg4ODA/z8/IhVOACYPYZ+hmPHjuHkyZMAqg3rixcvFpuIe/fuHbE+gnCBkaKiothiSaYX4tSmuLgYe/bs+aZxis1nII5/L25ubnBycgKfz8e4ceMwfPhwsSoWDx8+xO3btxETE4PKykr4+Pgw+jeweV4BwPz58zF//ny8f/8eACRSSjYpKQlLliyBsbEx0tLSUFVVhcrKSqxduxaVlZUwNTUlpu3k5ITz589DXV2d2KLv3w3hotSSkhI8ffoUUlJSUFZWlkhitST7JQDw/v17tGnT5rvv6dixIwoLCxnREyIQCH44ltyiRQuUlpYyqgsAgwcPxo4dO9ClSxeJl+C+fv06wsPD6zRCAkCXLl3g5ubGeP+PLV0AaNCgAWJiYtCuXTuiC75/RHFxMf28npSUhClTpgCovoaTOM7Y1h01ahS9+Kgmr1+/hqWlJdLS0gBUz338V7TrY5vZ1K5vbe7ZsyciIyPRs2dPumpDeno67t+/DwMDA7x9+xazZ8/Gtm3bMGrUKMZ066s21+b60WYODg4OknAmTA4Ojl/i0qVLCAoKEll1Mnz4cMjIyGDVqlXETJgA0LRpU0yfPp3Y59eFnJwcmjRpIlFNIWVlZdDV1ZW47s8+SDJFzUGwwMBAODs7iw0uFxcXw9nZmU57YIqapjtPT0/MmjULHTt2ZFTjR9Q0rUmatm3bIj4+HnFxcXj8+DEoisKUKVMwfvx4IsmvdSWdenl5ib3P3d0dZmZmjOsD7CVwCmHTKCfpUr7Xr1/H4sWLYWNjQ08uJCQkYMeOHdi7dy/RUp9ssWbNGri7u8PR0REDBgwAn89HRkYG3N3dMWvWLJHSzkyXXFVUVERhYSHatWuHjh074tGjRwCq72MFBQWMatXF9OnTMX36dBQVFYGiKCgoKBDXBKon2sPDw/Hs2TNs27YNFy9eRLdu3YgnZAr36+PHjyEQCMReJ5UKaWdnh6VLl6K8vBzjxo2DiooKNm7ciKioKMbvkQAkmjT6La5cuYItW7aIlHDq0qULXF1dsWDBAqLafn5+AKqvn6TTqrW1tREdHU3fI3Nzc0Wu0TweD7Kyst80KDKJML1OIBBASkpKpO2k0+sSExMREhKCp0+fSjRpS4ikSyM7OTlh9erVsLGxEfmeDQ0N4ezsjJs3byI5OZkRY6KVlRVGjBiBoKAgmJmZoWXLlujevTvk5ORAURSKiorw4MEDfP78GcbGxjh48CCRfnFqaioOHz4sYqaRkZHBokWLYGFhwbhebXJzc9G8eXM0bdoUt2/fxvnz56Gjo4Nx48YxrmVgYIDU1FT6323bthUzfXTv3p3Y8X3q1Cm4u7tL/BkaABwcHJCeno6hQ4f+J0utc7BDr169cPz4ccTFxSEsLAy+vr6QlpZGixYtQFEUiouLUVlZCVVVVcyaNQuTJ08WWXzHBGyeV0B1knNUVBSys7PB5/OhqqqKadOmEX2W3bFjB1atWgVra2ucO3cOALBixQo0b94cYWFhRE2YV69exdatW2FgYEBM43eDoij4+vriwIEDqKioAEVRkJaWxvTp07F27VqiC3Ik2S8Bqu+Lz58//+7x+/z5c8bvI507d8aff/753X7OvXv3iJxXixYtgqysLLZv347du3ejQ4cOjGt8i0aNGqGiouK77yFhzGNLFwC8vb3RvHlznDx5Etu2bRMb65YUHTt2REZGBoqKivDixQt6vP/ixYtEjwFJ6kZFRSE0NBRA9XXM1NRULODh48ePjI+FsaldH9vMpnZ9bLOQvLw8zJw5U2zewM/PD7m5uQgMDMT+/fuxa9cuxk1q9VGba7PkdNnW5uDg4CAFZ8Lk4OD4JRo2bFinOUtRUZHxFLffoWSIpaUl/P39sXnzZomXI9fV1cX169clkoTJ5oNkamoqXr16BQCIjY1Fr169xEyYOTk5uHnzJuPaNYmNjaXLukqSHx3npMtrNWnShHjpMiFsldX6HRI4hbBhlGOrlO/WrVsxZ84ckTKUx44dw9atW+Hn54fo6GgiumyyaNEiANUJjbUNW5s2bYKvry+x0s36+vpwdXXFxo0boaOjA29vb4wePRoJCQlEyzULefLkCR49elSnIZGUuSQzMxMzZsxAnz59kJmZCYFAgAcPHmDDhg0IDAzEiBEjiOgCwLp16yAjIwMnJyextEKS6OvrIzExEfn5+VBTUwNQXUZ52rRpRIxxv0NfrKioCK1atRLb3rRpU3z9+pWIphBJJrUpKSnRepaWlggKCiKeoPstDh06hH379uHt27c4d+4c9u3bh1atWhFP96qZtHX//n2JJm0JYaq85s/SqFEjbN++Ha9evcKDBw/QsGFD9OjRg54U1dPTQ2JiImN6ysrK8PHxwcqVK3H16lWkpaWhoKAAPB4PHTt2xPjx4zFixAiiE9RNmjSp815R1zamuXDhAlasWIFdu3ahU6dOmDNnDpSVlXH8+HF8+PCB8eeuli1bilwb61psRhI+n8/agq+UlBTs3r2bFf3S0lKcPXsWOTk5sLW1xaNHj9CtWzfWjBeSRiAQ/KcTA4UJzaampnjx4gXu379PX8fatGkDTU1NkYUbJPTZOq8ePXoECwsLNGrUCJqamqisrMTx48cRFRWFQ4cOiaXxM0V2djZ8fX3Fto8ZMwbbt28noimkRYsW6NSpE1GN3409e/YgJiYGa9asQb9+/VBVVYXk5GQEBQWhTZs2mDNnDjFtSfdLRo0aheDgYAwcOLDOPlhFRQV2796NoUOHMqYJABMmTMD27dsxePBgtG7dWuz1d+/eYdu2bcT6ntbW1rhx4wYCAgLoRV+S4I8//oCjoyNcXFzQv39/kXtFRUUFUlJSsH79evzxxx//CV0hDg4OuHfvHnbs2AFXV1ciGj9izpw5WLlyJRo0aIBBgwZBTU0NQUFBCAoKwoYNG/4TuiYmJnj//j0oikJQUBDGjh0rFmzRpEkTjBkzhlFdNrXrY5vZ1K6PbRZy/fp1HD9+XGz7lClTMHnyZADV99Rt27Zx2v9iXTa162ObOTg4OEjCmTA5ODh+idmzZ8PT0xPbtm2jVyKXlJQgICCA8eSS169f/9T7Pn/+zKhuTRITE3H//n0MHDgQCgoKYpMZJE1lvXv3hq+vL27duoWuXbuKJdYxORHO5oMkj8ejE1R5PF6dyYiysrKwtbVlXLsmw4cPx4EDB7BkyRKJTo7WPs4rKirw6tUrfP78GUZGRkS1X716BT8/v2+WCWT6+P7ZFAGmV8D/DgmcQtgwyrFVyvfp06d1PhxPmTKFuLFp06ZNMDExITYR+S0kXVrzy5cvkJWVBQDY29tjzZo1SElJgbm5OY4cOYKpU6eCz+cTT87bs2fPN48jHo9HzITp5+cHGxsbrFixAtra2gCqz+1mzZoRN2E+f/4cx44dk/gxBlSbtmuWntTS0gJQne7G9GKJn+2LkaR3795ISEjA/PnzRbZHRERAXV2dqHZNk4UkTS2RkZH07xUVFcjOzoaCgoJEDNWnTp3Cli1bMGvWLOzbtw9Adfqln58fZGRkiJQJFCLppK3Q0FA0btyY/ndFRQUiIiLQokULkfeRNp8CQOPGjdG7d2+RJFSA+dRkIa1bt8a0adMwbdo0Ip//PQYNGgRfX19s374dLVu2BFBttvbz88OgQYOIau/cuRO2trYYMmQI9u7di3bt2iE+Ph5nzpxBYGAg0cVv3zKqCwQCpKenE0kIt7CwQHBwMLy8vCRuymvTpg0rFSUKCgpgZmaGgoICCAQCTJs2DaGhocjIyEBERATRJF+g7oTurl27Ej+2gWoD/d69e5GXlydRA31iYiL27duHZ8+eSTzBuFOnThI36LF5Xvn6+mLQoEHw8/OjtcvKyuDg4AA/Pz/G0glr06xZM+Tn54ulBj5+/Fjsnsk0CxcuhI+PD9zc3Iiaa38nDh8+DFdXVxgbG9Pb1NXVIS8vjx07dhA1YQqRVL9k7ty5mDRpEiwtLTF//nxoaWmhRYsWKC4uxp9//om9e/fi5cuX8PHxYVTXwsIC58+fh7GxMaZMmYI+ffqgefPmKC4uxv3793H8+HF06tSJ6Dikt7c3srKyiH1+XTg5OcHV1RVz584Fj8eDnJwcpKWlIRAIUFxcjKqqKhgZGWHt2rX/CV0hDRo0wIYNG0QWaEuaSZMmQU1NDa9fv4aenh6A6ufcffv2EU3il6Ru48aN6T4Hj8eDra2tyLMWSdjSro9tZlO7PrZZSNOmTZGTk4POnTuLbH/y5An9d3z+/Fms6gKn/e/SZVO7PraZg4ODgyScCZODg+OXuHr1KjIyMjBq1CioqKiAz+fj+fPn+Pz5Mx48eICTJ0/S7/2nBq6aE9B1kZWVhUOHDiE+Pv4f6XyPgQMHslaK89ChQ1BQUEBWVpbYwByPx2N0MoXNB0kdHR08fPgQAKCmpoYbN26wUrIuNzcX8fHxCA8Ph4KCgliyGSnDbV3HOUVRcHV1FTHZkGD16tX4+++/YWhoKNEkNwD48OEDgoODkZ2djcrKSgDV7S4vL8fjx49FSjf+U2ruu6qqKgDVk/1ycnLg8Xhiqa8kYcMox1YpX3l5eWRlZYlNlj1+/Jh4ultqair279+PXr16wdTUFMbGxhJJlJO0YWvo0KEwNjbG1KlToaWlhZ07d9Kv7dmzB1lZWVBUVKwz3YNJwsPDsXjxYsyfP1+ik9GZmZl1JlnMmDGDeNJq79698ebNG4mbMF+/fo1NmzaJXTsFAgGKiooYn8j7UV9MEqxcuRKzZ8/Gn3/+iYqKCgQHB+PJkyfIyspCSEgIcX1JmlpiY2MRERGBwMBAtGvXDjk5OZg7dy7evn0LHo+HyZMnw8PDg/HSqjUJDQ2Fs7MzJk+eTKekW1lZoVmzZggODiZqwpRk0la7du1w5swZkW2tWrUS6+8x3eeuzf3797FmzRq8fPlSZDup1OTfAXt7e5iZmWHEiBFQUVEBj8fDs2fP0Lx5cxw4cICodk5ODgIDA9GgQQPcuHED+vr6aNCgAbS1tfHmzRui2g8ePICzszOys7Pp/mjt15nG0NAQ06dPR9++fdGqVSuxErYkFxSuWbMGHh4eWLFiBTp06CDW3yZlMPbx8UG3bt1w6tQp2lywadMmrFy5Eps2bcKePXuI6ALV/RJzc3NoaWlJPKGbLQN9zQTjtLQ0VhKMJQ2b51VqaioOHz4s0t+WkZHBokWLGF8UXZPx48fD29sb3t7e4PF4+Pz5MxITE+Hp6Ul84Wj37t3h5+f3zQXB/8X7ZGFhIXr37i22XUtLC2/fviWqLel+iZycHMLDw7F69WosWLBArJqEjo4OIiIiGC8L3rBhQ4SFhWH79u04evQowsLC6NcUFRVhbm6OhQsXEp3sb9OmDdq0aUPs8+tCWloaGzduxPLly3Hv3j3k5+fj69evaNSoEdq2bYu+ffuKjR2Ulpb+4++BLd2adO3a9acXYjCtLURNTY2uZlFeXg45OTl06dKFcZ3fQXfJkiWoqKhAfn6+2LhFWloa0YUabGnXxzazqV3f2mxiYgIXFxe8f/8eWlpaqKqqQlpaGrZv346JEyfi/fv38PX1Rf/+/Tntf7Eum9r1sc0cHBwcJOFMmBwcHL/EkCFDiK7Q/BFlZWWIj49HdHQ0MjIy0KBBA2Ix/8D3k29u375NTBcALl++/M3Xaib6Mc2SJUvw9etXpKWloby8XEyLZGdXaMZkg6FDhzJe4uh/hcfjwcbGBjNnzsSKFSuI6Tx48ABRUVHo1asXMY1v4eHhgaSkJAwbNgwJCQkwNjZGTk4OsrKysHLlSka12rdvD4qiEBISgsjISLx7945+TVFRERYWFpg7d65EzJjNmjWTuFGOrVK+kydPhru7Oz5+/AhNTU3weDxkZGQgICCALiVBiiNHjuDZs2eIjY3F3r174ePjg1GjRsHExARDhw4VmyxlEkkathYuXIiTJ0/i2LFj6NatG6ZMmYKJEyfSBm7SKYFCysvLMWHCBImnAUlJSaGkpERse25uLvGFBJ6enliwYAHS09PrNJeQGvD18vLCs2fPYGhoiJCQENjY2ODZs2e4cOECPDw8iGjWpKKiAoWFhRId5NbR0cHhw4cREhKCTp064f79+1BVVYWzszOdAkoKSZpazp07BycnJxgZGdGTfo6OjigpKcHu3bvRpEkTODs7IyIiArNnz2ZMtzbPnj2rM5GvX79+yMvLI6YLSDZp63v9bEni5eWFFi1aIDAwEM2aNWP7zyHGiRMnYGhoSE+2x8fHIy4uDo8fPwZFUZgyZQrGjx9P/Dto3rw5Pn36hJKSEty/fx82NjYAgJcvX9KpnKTYsGED+Hw+XF1d4eXlBUdHR7x8+RJRUVF1mo+ZwNHREc2bN8eUKVMkmtQi5PHjx2LXK9IG49u3b2PPnj0i7W3RogUcHBxgZWVFRFOIn58fZs+ezUpCN1sGekknGP8OsHleNWnSBAKBQGx7XduYZPny5cjLy6P35+TJk0FRFIYPH050vAIA1q1bh06dOmHSpEmsXMfYQEVFBUlJSWL9oRs3bhAzsAtho1+ioqKCI0eOICsrCxkZGfjw4QPk5OSgo6NDNL1YWloa9vb2WL58OV69eoUPHz5AXl4eysrKdY4XPH36FB07dqyzbDoT7NmzB2ZmZhJZPNqmTRsYGhr+1HuHDBmCuLg4RpJo2dL9VUhov337Fs7Ozli+fDl69OgBU1NTPHnyBC1atMD+/fvRs2dPxrR+B91bt27BwcEBhYWFYq81atSIqEGOLe362GY2tetbm5ctWwaBQABvb2+UlZWBoig0atQIlpaWWLZsGa5evYqvX7/WWfmL0/736LKpXR/bzMHBwUEUioODg+NfQE5ODuXt7U0NGDCA6tGjB6WmpkY5OztTr169kujf8eHDByosLIz6448/KDU1NYlqUxRFFRQUULt27aJGjRpFTOPKlStUv379KDU1NapHjx4iP6Tb/OXLF2rnzp2Ura0tZWVlRVlaWor8kGT37t1UXl4eUY1fITk5merTpw9RjUmTJlF3794lqvEtBgwYQF29epWiKIoyNjamHjx4QFEURa1bt45ycHBgXG/JkiWUhoYG5ezsTJ0+fZpKSkqiEhISKBcXF0pLS4uaP38+45rfori4mEpLS6Pu3r0r9kOCmTNnUrt27aIoiqL69OlDvXz5kqIoinJxcaFmzJhBRJOiKKqiooJyd3enNDQ06OtJr169KB8fH0ogEBDTrYs7d+5Qnp6eVJ8+fSh9fX1q27ZtRM73kydPUn379qW2b99OaWpqUi9fvqTCw8Op3r17U3v27GFcT0haWhrl4eFBDRo0iNLQ0KDs7OyoGzduENOrjZeXF+Xr6ysxPSHr1q2jZs2aRRUVFdHH9pMnT6hx48ZRTk5ORLV37twpdo+UxL2yb9++9LVi0qRJVFpaGkVRFOXv708tWrSImC5FUdTNmzepoUOHUmpqamI/pO9XbDFp0iTq+PHjFEWJXj+PHz9OjR49mlGtmTNnUoGBgfS/s7OzqR49elDbtm2jt505c4YaN24co7q1GTVqFH1/rtnm2NhYov1PiqIoX19fauLEiVRmZialra1NPXjwgLp69So1fPhwauPGjUS12UJDQ4PKyspi+88gTs+ePam+fftSLi4uVHp6Omt/x9q1a6mpU6dSs2fPpgYNGkSVlZVRSUlJ1OjRo6n169cT1e7Tpw99zZ42bRqVnJxMURRFhYWFUdbW1kQ0e/fuTfexJc3o0aOphQsXUlevXqXu3Lkj9kOKPn36UE+fPqV/F17DHjx4QGlraxPTpajqe3Rd2i9evCB+n9TS0qL1amq/fPmS6t27NzHdPn36UC9evKhTV1NTk5gum7B5Xq1atYqytLSk3r9/T28rLCykLC0tqcWLFxPXf/78OXXmzBkqPj6eevz4MXE9iqr+voXnVX3hxIkTVO/evSlfX1/q4sWL1KVLl6hNmzZRmpqaVGRkJFHtf0O/ZOTIkdTr168lrqutrU1f4/6Nn/+/UvPaXh90SWkvXbqUmjJlCvXq1SsqLi6O6tOnD5Wamko5OTlRs2fPZlTrd9CdMmUKNX/+fOrGjRtUnz59qIsXL1IRERFUv379qAsXLhDTZVO7PraZTe362GaKoqivX79SmZmZ1IMHD6ivX78S1eK0uTbXlzZzcHBwkIBLwuTg4PhlEhMT8ejRI5SVlYls5/F4WLx4MWM6FRUVOH/+PKKjo5GcnAwpKSno6+vD0NAQq1evhrW1NTp06MCY3vdIS0vDoUOHcPbsWZSWlqJTp05Yv369RLQB4M6dO4iOjsbFixdRXl4OTU1NYlp+fn7o168fli1bJvFEHnd3dyQkJEBPT6/O5D6S7NmzB3/88YdENQEgMDBQbNunT58QHx9PPJnT1dUVbm5usLS0rDPJjWTq6efPn9G9e3cA1aliDx8+hJqaGiwsLDBv3jxGtWJjY3Hnzh0cPXqULsEjxNDQEDNmzMCsWbMQExNDPK0lNjYWrq6uEAgEYimzpFKB2Crl27BhQ7i4uGDVqlV49uwZ+Hw+VFRUiJb0qov09HScP38e58+fB1B9XKempiIkJASenp6YMGECY1pspRBpampCU1MTTk5OuHr1KmJjY7FgwQK0atUKJiYmMDU1hZKSEhFtAJgzZw4mTJiAhIQEdOjQQSw5JCIigojumjVrMGfOHAwZMgQURcHExAQlJSVQU1PD6tWriWgKiYiIwLJlyzB79myJHtNlZWV036dLly7Izs6GpqYmJk2aBEtLS6La/v7+0NDQgKWlJZYsWQI/Pz/k5uZi+/bt2LhxI1HtM2fOIDw8HI8ePULDhg2hrq6OuXPnYtiwYUR1JZkK+fDhQ7i7u9P/vnXrFng8nkhyWs+ePcXKQzLN9OnT4e7uDkdHRwDVqT/Xr1/Htm3bYG1tTVSbzaQttlBSUkJ5eTnbfwZxrl69iri4OJw8eRKHDx9G9+7dMW3aNIwfP57xlNPvsX79egQEBODVq1cIDg6GtLQ0UlNToampiTVr1hDVrqqqop9vOnfujEePHqFfv34YNWoUdu/eTURTWVmZeELet8jPz0dISIjEE6z69++PqKgorFu3jt5WXl6OoKAg6OjoENVmM6FbUVERT58+Ffu+7927RyxtH5BsgvHvApvnlb29PczMzDBixAioqKiAx+Ph2bNnaN68OQ4cOEBcv1OnTujUqRNxnZqoqqoiPz8fnTt3lqgum0yaNAnFxcXYt28f/byuoKAAOzs7omXngX9Hv6SoqAhVVVUS1609fvNv+3wOdrl9+zbCw8PRoUMHbN26FXp6etDR0YGcnBxMTEz+c7rZ2dk4evQoevToAXV1dcjKysLS0hKysrIICQmBgYHBf067PraZTe362ObS0lKcPXsWOTk5sLW1RXp6Orp16wZ5eXkievVdm2tz/WgzBwcHByk4EyYHB8cv4eXlhQMHDkBRUVGs7CjTJszhw4ejpKQEgwYNwsaNG2FgYICmTZsCABwcHBjT+RZfvnzByZMnER0djezsbPB4PFAUBQ8PD0ydOpVoOVug2oh3/PhxHD58GM+ePQMADBs2DPPnz6/TEMAUL168QEBAALp160ZM41tcuHABmzZt+unyNEyipaWFy5cvEy3xWRfHjx8X2yYlJQVdXV3Gy3LX5vHjx3jy5AmcnZ3FXiNZJhCoHtx/8+YNlJSUoKKiQpeib9y4MT58+MCo1uHDh2FnZydmwBSipqYGOzs7iZgwAwICMHHiRFhbW0NGRoaolhBhKd/Q0FDipXxzc3OhpKQEHo+H3NxcervwgbmoqIjeRrKU2tu3bxEXF4e4uDg8e/YMWlpaWLJkCYyMjOj7yI4dO7BhwwZGTZhslvEFAD6fDwMDAxgYGODDhw84e/YsDh8+jODgYPz111/EdIVGBy0tLYmWCWzatCmio6Nx69YtZGVloaqqCt27d4eurq6YqZxpysrKMH78eImbipWVlfHo0SP62im8TldVVeHz589EtdkaaD527BhcXFwwduxYGBkZoaqqCvfu3cP8+fOxbds2ooPrkjS1lJeXi/StU1NT0bRpU2hoaNDbKioqICUlxahubebOnYtPnz7BwcEBZWVlmD9/Pvh8PszMzDB//nyi2lJSUtiyZQvs7Ozw4MED+pxmo08qKRYtWoQNGzbA3d0dXbp0Ib5/a1NQUIDy8nKxiX+m79GtW7fG3LlzMXfuXGRmZiI2NhY7d+7E5s2bYWBggKlTp2LQoEGMatZFo0aNaIOxkKVLlxLXBaqN88nJyZgwYQI6deqEjIwMANXPfKQMXS4uLnBzc8OyZcvQuXNnsRKqJPtiffr0QXZ2tsRNmGvWrMHMmTNx9+5dlJeXw83NDU+fPsWnT5+Im9QMDAywZcsWbN26ld6Wk5MDb29vDB8+nKg2Wwb68ePHw9vbG97e3uDxePj8+TMSExPh6ekJIyMjYrpC7t27BxUVFcjLyyM2NhZnzpyBjo4O5s2bR2y8hs3zqm3btoiPj0dcXBweP34MiqIwZcoUjB8/nvEFtGpqaj/9HZIcN7Czs8P69esxe/bsOr9vkgtH2cTa2hrW1tYoKioCRVFQUFCQiC7b/RIOjv8q5eXl9OKEW7duYdmyZQCqn+NJlbhnU7dhw4b02JuKigoePXqEwYMHY9CgQdi0aRMxXTa162Ob2dSub20uKCiAmZkZCgoKIBAIMG3aNISGhiIjIwMRERHo2rUrEd36qs21uX60mYODg4MknAmTg4Pjlzh16hTc3d0xffp04lqfPn2CgoIC2rZtiyZNmkhs8O/hw4eIjo7GyZMn8eXLF/Tp0wdr167F2LFjMXz4cOjo6BA1YKanp+PQoUM4c+YMSktLoa6ujpUrVyIgIABr1qwhPhGtoqIiYpSSJA0aNIC6ujor2rKysvD19cWuXbugoqIiZpAjleR2+fJlIp/7MwQGBsLU1BRWVlYSNxKNHTsWq1evhq+vLwYNGoTly5ejT58+uHjxIuPpGk+ePPlhqqiuri4CAgIY1a2LDx8+wMbGBioqKsS1hMTGxsLIyAi+vr4i2798+YL9+/czOjE7cuRIJCUlQUFBASNHjqzzWklRFHGT78iRI6GgoIDx48cjMDCwzod1dXV1xvcDWylEtSkqKkJCQgLOnDmD7Oxs4slPd+/exf79+6GtrU1UpzZWVlYIDAzE4MGDMXjwYHp7YWEhbG1tERsbS0x73LhxiI+PJ25Kq42JiQlWr14NHx8f6Ovrw9LSEu3atUNSUhJ69OhBVJutQe69e/fSCehCrK2tsW/fPmzfvp2oCVOSppbOnTsjMzMTysrKKC0txc2bNzFkyBCR6+iVK1ckcv9YuXIlFi5ciCdPnoCiKHTp0oXe95KAjaQttti+fTvevXuHSZMm1fk6qXvl/fv3sWbNGrFkVUncozU0NKChoQFHR0dcvXoVJ0+exLx589C6dWtMmTIFCxYsIKYNVD/rhYeH49mzZ9i2bRsuXryIbt26YeDAgUR1LSws6IVPY8aMwcSJE9GoUSPcu3cPffr0IaJpY2ODyspKzJ8/X+RaIon9PG3aNLi4uODPP/+EioqK2LP8t475f0rXrl0RFxeHQ4cOQUlJCVVVVTA0NIS5uTnxKhpsJnSzZaBnM8E4Ojoa7u7uCA0NhYKCApycnDB48GCEhYWhvLwcS5YsIaLL5nkFAE2aNIG5uTlRDQDYsGED8YXHP4Pw+PXw8BB7TRLft6QQPrNLS0v/8BmG1PUTYK9fwgFMmDABTZo0qfO10tJSiY/ZcTCLuro6jh49itatW+P9+/fQ19eHQCDA3r17v7lg/N+sq6amhgsXLsDa2hqdO3dGamoqZs2aJZHFyWxp18c2s6ld39rs4+ODbt264dSpUxgyZAgAYNOmTVi5ciU2bdqEPXv2cNr/AV02tetjmzk4ODhIwpkwOTg4fgk+n48BAwZIRCspKQkJCQmIiYlBdHQ0ZGVlMXLkSBgaGhIdDJ40aRK6dOmCpUuXYsyYMWjfvj0xrdqYmJjgwYMH6NatG+bMmQNjY2O67JIkDGJAdcqop6cnVqxYgS5duoglnpJMdhgzZgxOnDiB5cuXE9P4Fk2bNiU6mP0jrl+/juzsbPD5fKiqqmLQoEFo2LAhUc0PHz5g7ty5xCck62Lp0qUoLS3F27dvMX78eBgaGmL58uVo1qwZtm/fzqhWRUXFT32XkphkGjNmDBITE4mbaIqKilBaWgoAcHJygqqqKuTk5ETek5WVBX9/f0aNRP7+/vQqe1LG5Z9hx44dGDFihMh+LysrEzFXjxo1CqNGjWJUl80yvl+/fsXFixdx6tQp3Lx5E3Jycpg8eTI2bNhA3MykqKj4zQkjpklMTKTTw5KTk7Fr1y7IysqKvOfFixd48+YN0b9DQUEBQUFBuHDhQp2pPKTKc8+ZMwd8Ph88Hg+amppYsmQJgoODoaSkhM2bNxPRFMLWIHdeXl6dCWKjR4/Gjh07iGpL0tRiamoKb29v5Ofn4/bt2ygpKcGMGTMAVCeYXLp0CcHBwUT6SDWTi2siTF36+PEjPn78CID5fuDvkrTFFpJKYayNl5cXWrRogcDAQMbT036WmunNWVlZcHFxwbZt24iaMDMzMzFjxgz06dMHmZmZEAgEePDgATZs2IDAwECMGDGCmLapqSlatGiBli1bomvXrti0aRN2794NJSUlrF+/nohmWFgYkc/9GVatWgUAdCndmvB4PKLPXW3atBG5VhYVFUmkjBmbCd0AOwZ6YYLxsmXLRNosiQTj8PBwrFu3DoMHD8a2bdugqqqK0NBQXLt2DW5ubsRMmJI+r5ycnH7qfTweDxs2bGBMl2SZ2l/h0qVLbP8JEsHR0RG6urpQUFAQS2yuCenrJ1v9Eg7A3d39m68NGTIEcXFxEk+X5mCONWvWYMGCBXj//j3mzp2Ltm3bws3NDRcvXqyzr/Rv1507dy6WLFkCaWlpGBsbY/v27Zg3bx6ys7OJp9+zpV0f28ymdn1r8+3bt7Fnzx6R6kMtWrSAg4MDrKysiGjWZ22uzZLTZVubg4ODgxScCZODg+OXsLCwQHBwMLy8vMTMeUzTtGlTTJs2DdOmTUNOTg6OHTuGU6dO4fTp0+DxeNi/fz/mzJnDuJmpT58+uH//Po4ePYrc3Fz88ccfRMt/1yQrKwtdunTBhAkTMHToUNqAKUnmzZsHoLoMkaSTHZo3b47Q0FAkJibWaQAlZWoh/dnf4+PHj7CxsUFmZiaaN2+OqqoqlJSUoFevXggLC0Pz5s2Jaevp6eH27duYMmUKMY1vIS0tLVIG3c3NjTZhMm0+7datG27evImOHTt+8z3Xr1+XSGkDBwcHGBsb4/z581BWVhYznjB1HF67dg2Ojo7g8Xh0mbraUBQFfX19RvSEuLm5oU+fPmjXrh1OnDgBZ2dniaanCRk6dCicnJzQuXNnLFy4EEC1AVZXVxcuLi7E7l+STiGqrKzEjRs3cOrUKVy6dAnl5eXQ19fHjh07oK+vL5EJf6DaaOHl5QVXV1eoqKgQNZC3b98eHh4eoCgKFEUhISFBpJ08Hg+ysrLEE6dSUlKgpaUFABJZaS8kOTkZM2fOpBPFhOV9y8rKcPXqVfTs2ZOYNluD3IMHD0ZCQgIWLVoksv3GjRsSSV+VlKnF0tISRUVF2LVrFxo0aABHR0c64XXjxo04ePAgJk6ciJkzZzKu/a3k4rpguh9YM2krNzcXe/bswfTp06GtrQ0pKSmkp6fj4MGD9LWcKQIDA3/6vaSMPEB1ahwbZGdn48iRI0SvGT/i77//Rnx8PE6ePIkHDx5AW1sb3t7eRDX9/PxgY2ODFStW0NcPLy8vNGv2f+ydezxV2f//XyfSTRdRUSMqSTdFV0UKNUrl0r3cJVMSGoUUySXklohCqEwuJbpOaio1pgu6IEVJKlKDUlSu+/eHn/N1OlLzmbPObtjPx2MeD62z57z2OrZ91l7rtV7v3sRNmAA4knu1tLSgpaXFc41Pnz6xFy++d/Nk6/+HVzx69Iin7/e9vH//Hnv27IG+vj5kZGRgZmaGW7duQVpaGgcPHuSLgaUlobuyshK3b99GaWkpXza9lZaWok+fPhg/fjxu3rwJf39/KCoqYuHChUR1P3/+DHFxcQwdOhSFhYW4evUq3r9/TzyJ/eXLl1BTUwPQvIF31qxZAJqf/crLy3mqReff1cuXL9t9vaSkBKWlpRAUFOSpCbM13/rO5PX35OvXrzFo0CAA+O5N0a3/n/8ire+ZdN0/AfrGJQztQ1EU3afA8C+Rl5dHeno6Pnz4wJ7nNTIygrW1NdeG6Y6gq6amhsTERAgICEBCQgKRkZE4dOgQ1NXVsWnTJmK6dGp3xj7Tqd3Z+lxTU/PVcWVDQwMRzc6szfSZf7p0azMwMDCQgjFhMjAw/CPmz5+PFStWYNKkSRgwYADXgi2pXeojRoyAvb097OzscPXqVZw8eRLJyclISkrCjBkzEBERwTOtuLg4PHv2DMePH8epU6dw9OhRDBw4EJqamgDIpuVduHABSUlJOHr0KPz9/fHTTz9hwYIFmD9/PjHNL6EzvS43N5dtannz5g1xvR+h5JO3tzdqa2tx6tQpyMrKAmiedN+yZQv8/Pza3Q3/b5k6dSo8PDxw/fr1NpPceL2YQtfnrauri3379mHmzJltLrw+efIEwcHBxE1bQLORpqamBnV1dUST+nR0dDBkyBA0NTXByMgIQUFB7IRK4P+Mai3XHK+or69HQUEBBg8ejOTkZGzZsoWn7/+97N69G/fv38fy5cvZbdu3b4evry8CAgJgb29PTJufKUTKysp49+4dpKWlYWlpCV1dXXZyHT8JDAxEaWnpVxf5eWnakpGRYY81Zs+ejZMnTxJdPPgaR44c4bsm0FyCPT09nSvRq7CwEFu2bMHPP/9MTJuuSW4FBQXs378fDx48wJQpU9C1a1fk5OTgzJkz0NXV5TAGkDDLVVdX49y5cygoKECXLl0wduxYaGpqciTr8gpra2tYW1tzta9YsQIrVqwgVnK+9dgvPz8fwcHB2LBhA4cRMiQkhMsIywtaJ20ZGBhgx44dHBsHNDQ0ICMjg5iYGJiZmfFMNykpiePfr169QteuXSEpKQlBQUE8f/4c9fX1GDduHM+vq2XLlsHOzu67y1//9ddf8Pf3x/Hjx3l2DhISEqivr+fZ+30v1dXVuHjxIk6fPo1bt25BREQE2tra8PPz48vms9zcXLi4uHC1r1q1CnFxcTzXo8Psu2TJEqxduxY6Ojrf3IxRX1+P5ORkHDp0COfPn//X2nl5eRgzZsw/+n9yc3Mxbty4f63dwu7du5GZmQljY2NcvnwZWVlZ8PHxwdmzZ+Hj40M0QbmgoABWVlZwd3eHnJwctLW18ffff0NISAgHDx4kumHh4sWLsLW1RVhYGKSkpLB27VpISkoiKSkJVVVVRAz8QPPmEEtLS+zduxcyMjJYvnw5WCwWPn78CD8/P6LzGKKionjz5g26du2K3NxcdvnzR48eQUxMjKdadP5dfW3M2djYiIMHD2L//v2QkZEhuqn0y+/MhoYGVFZWomvXrkQ2xJiamkJTUxMGBgbo169fu8dWVFTg8OHDuHjxIs6dO8fzc6EDQ0NDhISEcCVVV1RUwMzM7JtzKf+UH2FcwsDQESktLYWEhARYLBZH5YHq6moAQLdu3fDp0yd8+vSJp9UG6NL9krFjx7J/njBhAkJDQ4lp/SjanbHPdGp3pj5PmTIFsbGx2L59O7utvr4eISEhxDc+dUZtps/806Vbm4GBgYEULIrZSsfAwPAPWLlyJSoqKjBv3rw2d6eQTIr5ksrKSqSkpCApKQmnT58motHU1IRr164hKSkJV65cQX19PWRlZWFgYIDFixcTWYBv0b1+/TpOnDiBK1eusHf8rF+/HiYmJrSUDSwrK0NCQgLx3YRfo6amhuflbuXk5JCeng5RUVHIycl99TiSCaDTp0/Hvn37MGXKFI7227dvw9bWFunp6UR0AbCTQ9qCxWLx3FRN1+fd1NSEX375BXfv3oWenh4UFBTQr18/VFdX49atWzh+/DhUVFR4Xga9LRQUFBAYGMjzBMr2OHjwIBYtWgQJCQniWr/++ivOnj37XWZ1kqm6M2fOREhICCZOnMjRnpmZCVtbW1y/fp2Y9qdPn/DkyRPU1tZyJVZ8+Xf+b3F0dMTSpUsxadIknr7vP+XkyZPtvk4qUUVPTw+enp7t3k9I8vHjR5w6dQr5+fkQFBTEyJEjsWDBAp6bbqOjo+Ht7Q3g/1Kp20JeXh7x8fE81f4RaO+7qjUkvrcKCwthZGSEmpoaSEtLo6mpCcXFxRg0aBBiYmIgLi7OU70fAT09Paxfvx5z587laL9y5Qp8fHx4Yij5GhMmTMCpU6cgJSXF0f7s2TNoa2vj/v37RHRjYmJw5coV+Pn5cZRg37p1K2RlZbF582ae6j148ACOjo4QFBSElpYW5syZg2HDhnH8bT969Ag3b97EiRMn0NjYCC8vL8jLy/PsHJKTkxEXFwdXV1cMHz6cna5Lij/++AOnT5/G1atXUV9fDxUVFSxduhRz5swhmp78JUpKSjh48CDGjx8PBQUFnDp1CpKSkrh58yY2b96Mv/76i6d6dNy/ysrKsGPHDuTl5eHnn3/GnDlzICsri/79+4OiKFRWViI3Nxc3b97E2bNnMXr0aLi7u/NkEX7FihWQlpaGmZnZNzf6PHjwAFFRUXj+/DkSEhL+tXYLM2bMQEhICBQUFODk5ISKigqEhYUhPz8f+vr6yMjI4JnWl5iZmUFAQAC7d+/GH3/8AX9/f6SkpOC3337DrVu3iBh9W9DV1cWsWbNgbW2N8PBwnDhxAr///jvOnz+P4OBgYvfuVatWQVpaGk5OTjhx4gQiIyORmpqKEydOIDExkedmsdbs2bMHqamp6NGjB9vgfeHCBbi5uWHp0qX49ddfeaZF599VWzx+/BgODg7Iz8+HmZkZLC0tiVeq+ZLq6mrY29tj2rRpPC8TWFNTgz179iA5ORnTpk3j+LybmppQWVmJBw8e4ObNm/jrr7+wePFi2Nvb01KBgVekpaUhJycHQLOB39TUFD179uQ4pri4GFevXuX5fexHGJf8ExQVFWkpzd163MBvSGifOnUKqqqqHJt120JbWxsHDhzg2XMPXbp0aI8ePRp//vknew60red4ElWn6NIFmr+fvLy84OLiwlGNyNbWFpWVldi5cyexjVd0aXfGPtOp3Rn7DDTPTa1ZswYDBw7E06dPMW3aNDx9+hQfPnzA0aNHic6LdkZtps+do88MDAwMJGFMmAwMDP8IeXl5JCQkdMqBz9u3b3Hq1CmcPHkSjx49Qt++fXHr1i3iulVVVUhJScHJkyfx8OFD9OjRA4sXLyaakNiaa9euIS4uDmlpaaAoCnl5eXzRbeHhw4c4duwYzp49i6ysLCIanz59Qrdu3ThSLQoKCvDTTz9xTXzzmsmTJyM+Pp6rFHZhYSH09PSIGQ6+pLKyEhkZGRATE+Oboevjx4/skji8LoH4JY2NjQgNDUVsbCzevn3LbhcTE4ORkRHMzMz4UrpZWVkZR44c4UvaUwuTJ0/GiRMnuEwtJKivr8e1a9fw/v17ODo6Ytu2bV81jZMsdaagoIDjx4+3+Xe1ZMkS3Lt3j4huWloabGxs8PnzZy4DJkkzd2dl2rRpSExM5Jj85BevXr2Cvr4+KioqMGzYMDQ2NqK4uBiioqL47bffeLpY1NDQgDNnzqCpqQnbtm3j+rtqSbadPn06u8QYr/hRSjbThYmJCQQFBeHr68terKusrISdnR169uz5jz6f/woTJkxAcnIy1/cU6fsnACxatAiampqwtLTkaPf29sbt27dx4sQJIrozZ85EZGQk1/NNQUEBDAwMiIz3GxoakJKSgqioKDx58gRCQkLo27cvKIrCu3fv0NjYiJEjR8LQ0BC6uro8NyqqqanhzZs3aGxsbPN1Xn9fycnJQUpKCkuWLIGOjg4GDhzI0/f/Xnbs2IEXL14gICAAampqOHXqFOrq6mBjY4Px48cTKeX7+vVrpKamolu3bpg1axbfzNs3b95EVFQU/vrrL64SXkJCQpgxYwYMDQ2hpKTEM82mpiZERETg4MGDEBcXb9c49erVK5iZmWHt2rVcafz/hokTJ+L3339n65uYmMDQ0BDPnz+Hjo4O7ty5wzOtL1FUVERiYiJGjBgBKysr9OzZE97e3njx4gUWLVpE9P4pLy+P8+fPY8iQITAwMICcnBycnJxQWloKTU1NZGdnE9GdMGECzpw5A0lJSZibm0NCQgK7du1CSUkJ5s+fT0wXaL7eYmNj8eLFC6xZswZSUlI4cuQIysvLYWVlxdPrqgU6/q5a09TUxE6/HDp0KHbv3o3x48cT0foeCgoKYGFhgStXrhB5/+fPnyM6Ohp//PEHXr9+zTYSURSFwYMHQ01NDfr6+pCWliaiz0+ePHkCCwsLUBSFV69eYdCgQRzzEy3jfUNDQyxbtozn+nSPS/4JU6ZMQVJSEs8MiRkZGVBQUOC6Z9TW1uLq1avsSgO//PIL3NzcMGDAAJ7o/hNImDCnTp2KY8eOcc2ZkIYuXTq0b9++DUVFRQgKCuLWrVvtblaeOnXqf163uLgYy5cvx8CBAxEQEAAZGRn2a2fOnMGBAwdQXl6OxMRE/PTTTzzTpVO7M/aZTu3O2OfWvHnzBr/99hsePnyIpqYmjBw5EqtXryam19m1mT53jj4zMDAwkIIxYTIwMPwjtLS0sHv3btp2PP8oPHjwACdPnuSISOcHjx49wvHjx3HmzBncvHmTmE5lZSWOHz+OhIQElJSUQFBQEIsWLYKpqSnHQyYpamtrcfbsWcTFxSEnJwddunTB3LlzERgYyHOt5ORk7N69GxERERwLGGZmZrh//z7c3NyIllEzMjLCyJEjua4lNzc3PHjwgEhiSkhICA4fPoyEhARISUnh7t27MDc3R01NDYDmdM7Q0FB0796d59o1NTU4dOgQzpw5g+fPn7PbpaSksHjxYpiYmBA3ZBYVFeHdu3fo168fpKSk+GK+bOHIkSPIzMyEh4cH35I6zMzMoKysDBMTE+JaqqqqSEhIwKBBgxAcHAwzMzPiv8+2MDU1hZiYGHbv3s1eIKIoCi4uLigqKiJWSnrhwoXs0uBtmeGGDBlCRPdH4MqVK+ykKUFBQcjIyMDMzIwrTY+XREREIC0tDWZmZhg6dCjXPYtkaS1ra2tUVFQgKCiIXRq8vLwc1tbWEBcXh5+fHxHdkydPQktLi29pR22luJWVlWHAgAEci68kUih/BBQUFJCQkICRI0dytD969AirV68mauahi+XLl2Ps2LFwdnZmL9g1NDRg27ZtePXqFbH7J9BcTnfTpk2YNGkSxo8fD4qicOfOHTx8+BDh4eHESvlOmTIFBw4c4CpzdOPGDdjY2BDfdFVcXIx79+6hvLwcLBYLgwYNgry8PNGkJX4nGGdkZPA8Dfp/obq6GmvXrsX9+/dBURR69+6N6upqyMnJISoq6ptlb/8pWVlZWLt2LT59+gQA6NWrF/bu3QtlZWWe6rTH58+fkZuby3F9jRo1iuj4rLq6GnFxcfjjjz+Qk5PDNqsJCQlBXl4eGhoa0NPT4/nGAaC5bPSyZcsgISEBCwsL/P7775CWloavry9u3bqFxMREnmu2MHnyZJw8eRKDBw/G9OnT4eTkBB0dHTx69AjGxsZEn9+VlZURERGBn376CUpKSggKCsKcOXNw8+ZNbN26FdeuXSOiO336dMTGxkJSUhLTpk2Dp6cn5s+fj/v372PDhg1EqzrQCR1/V48fP4ajoyMePnwIU1NTWFlZ8T398kvy8vKwatUqvmwcLSsrw99//83+vOkwwvELNTU1HD9+nP2MwW/oGJe0UFVVheLiYtTW1nK9RmocMXr0aKSnp3N93g8ePMCqVauImsm/FxImzOXLl8PY2BgLFizg2Xv+yLp0a3cGtm7dyk4gbytl//PnzzAzM4OUlBTPNz7Rpd0Z+0yndmfscwtfm2Ovrq7G3r174eTkxHPNzqzN9Jl/unRrMzAwMJCCMWEyMDD8I27dugVvb29YW1tj2LBhXDuFSRoeGP6P+vp6ImUDMzIycOzYMVy8eBH19fUYMWIEioqKcOzYMUyYMIHnel/y9OlTxMXFISUlBVVVVWCxWFiyZAl++eUXIruebty4ATMzM+jp6cHGxgZiYmLs14qLixEeHo6TJ08iJiYGkydP5rk+ANy9exeGhoaQk5ODoqIiWCwWMjMz8ejRI4SHh/M8RSM+Ph4eHh4wNjbGunXrICwsDE1NTXz8+BFRUVEQFhaGlZUVZs6cCWtra55qv3v3DgYGBigpKcHcuXMhKyuLPn364MOHD8jNzcXly5chKSmJ33777avpif91TExMkJmZCYqiICoqynUPJWFisrKywqVLl9CnTx9IS0ujW7duHK8fPnyYZ1ry8vI4evQo5OXlv7qYwQ9yc3NhYGAAERERjB07FiwWCw8ePMC7d+9w6NAhYvez8ePH48yZM3xJHf2RuHTpEqysrDB37lxMnjwZTU1NyMjIwJUrV7Bv3z6oq6sT0W2dWtc63YFUaa3WTJ48GVFRUVzpQ9nZ2TA3Nydq2nrz5g0SEhJQVFSEbdu24fbt25CVleVbogedpfj4zc8//4zt27dDRUWFoz0zMxN2dna4evUqPSdGkMzMTJiZmWHAgAEYM2YMKIpCTk4OPn36hJiYGOJp+Hfu3EFsbCwKCgoANC+Mm5qaEtW1t7dHbm4unJ2dMW7cOFAUhaysLLi5uWH27Nl833TFQJ4bN24gLy8PTU1NkJWVhYqKCpFNOYaGhujVqxdcXV0hICCAXbt2obCwEGfOnOG51o8KRVF4+/YtWCwWREREiOulpaXBysoK9fX10NLSgq+vL3bv3o3Y2FiEhIRAVVWVmPbatWsxaNAgiImJITIyEteuXUN9fT127NiBLl26ICwsjJi2k5MTHj9+DGFhYTx8+BBpaWnIzMzEzp07MX36dOzatYuIrrW1NWpra9G3b1+kpqbi+vXrePHiBZydnSEpKQl/f38iukBzKuSZM2eQlZWF+vp6rhT63bt3E9PmJ01NTQgPD0dISAikpKTg4eHB903RX5aVpygKHz58QHx8PAYMGIDo6Gi+nk9n5vPnz0Q2y/4IJCcnw8XFBXV1dcSrSkRHR8Pb2xvA/z07toW8vDzi4+N5pvu/QuL5y8nJCSdPnoScnFyb80Sk7qF06dKh7ejo+N3H8lKbLt3Zs2fD39+fa2Nba/766y9s374dly9f5pkundqdsc90ane2PhcWFqKyshJA83Plvn372BVaWigoKICPjw/PN8R0Rm2mz52jzwwMDAz8gve1WRgYGDo0pqamaGxshIWFBd8NDwz/B68NmEeOHEFcXBwKCwvx008/wcTEBFpaWhg1ahTGjh2LXr168VSvNQ0NDUhNTUVcXBwyMjLQtWtXqKqqYv78+di6dSuMjY2Jxc6Hh4dDX18f27Zt43pNSkoK7u7uoCgKYWFhiIiIIHIOCgoKiI2NRVRUFP78809QFAVZWVls374dEydO5LleYmIiHBwcsHr1agDNhqFnz57Bzs6ObeBZv349vLy8eG7C3LdvHxoaGnD27FlISEhwvV5WVgZzc3McOnSI59o/CpMmTeJbufcWhIWFoaOjwxetKVOmQF9fH2JiYqAoCkuWLPmqqYFkat64ceNw5swZxMfHo6CgAIKCgli4cCHWrFlDtASqtLQ0/v77705nwgwJCcHGjRs5SggbGxsjODgYoaGhxEyYvDQQ/1MEBATaXADt1q0b6urqiOm2lEASFhbG69evYWNjg/Pnz2Pbtm2IjIxsd0KY4Z9jb28PV1dXODg4YOrUqRAUFEROTg5cXV1hZGSE0tJS9rEdZSPS5MmTcfbsWcTHx+Px48cAmlMRV61axZcS0oqKiny/jnfs2AFra2sYGRlxlDrV1NTE1q1b+XouJHF0dISTkxOEhYXbXZxlsVhE0jt+BAwNDREcHAwlJSWOjU4VFRUwMzPjMhr9Wx4+fIhjx46x/3a2bduG2bNno7q6mm+J6HTDYrH4uiFHVVUVaWlpeP36Ndu8vWDBAixfvpz4ZoUdO3bA1tYWL168wLZt29C/f3+4ubnhyZMnxJ4lW2sHBgbixYsXCA0NhZCQELKysiAvL0/0Pubi4gIXFxfk5+djz549EBYWRkpKCgQFBf+RCeR/wdvbG4cPH4acnFyH/ntavnw5Hjx4AElJSRgYGODp06d4+vRpm8eSeuZzcHDgahMUFISioiJcXFyIaHZmqqqqEBoaivz8fDQ2NgJoHpfU19fj8ePHyMrKovkMyRAYGAhtbW0YGxtzmeN4jb6+Pvr164empiZs27YNjo6OHBuBW8q/k0ph/xF4/vw5e27q77//7vC6dGifPHkSXbp0wZgxY/haIYYu3bdv32LQoEHtHjN06FBUVFR0GO3O2Gc6tTtbn1+8eIFffvmFPUexcePGNo9bsmQJzzQ7szbT587RZwYGBgZ+wZgwGRgY/hFRUVF0nwIDATw8PDB8+HCEhoZizpw5fNVuWYicPn06du/eDQ0NDfYiypYtW4hq5+Xltbmg0JpVq1Zh3bp1RM9DXl4eAQEBRDVaKCwsxIwZM9j/vnnzJlgsFkcqjIyMDIexhFdcvnwZzs7ObRowAUBcXBzW1tYICAjosCbMrz1QkoSfKTABAQFITk7G+/fvERwcDE1NTaIm7vYYMmQINm/eTFyn9d/KypUrsX37djg5OUFaWpqjXDPQcUxaX1JYWIjAwECu9oULFyI8PJyY7tSpU9k/19XV8bUko6KiIvbv3w8fHx/2xoj6+nqEhoZCQUGBmK6Xlxc0NDTg7u7ONqoFBATAwcEB/v7+OHr0KDHtzsiGDRsANN+7v9x85O3tDR8fH2IbkdLS0hAREYGioiLEx8fjxIkTGDp0KF9M9T/99BN+/fVX4jo/CsLCwoiMjERRURE7gXPMmDEdLu315cuXaGpqYv/cWUhLS0NOTg6A5tT/sLAw9OzZk+OY4uJilJSU8Fy7pqaGo8T5oEGD0LVrV1RVVXVo0xgAFBUVYdeuXeyUwi8huXlTRESEI3WzJQG9tLSU6FhMSkoKSUlJHG0bNmzAtm3buMaEvKZ79+5cz7VWVlZENQGgf//+2LdvH0fb5s2b+TImS0lJwfbt27FmzRriWnSSm5sLoNk85Ozs/NXjWCwWsTHCo0ePiLwvQ9vs2rUL6enpUFZWxrlz56ClpYXCwkLk5eXx5fmWLqqqqmBqagppaWniWoKCguy/FxaLBS0trTbvWzU1NUTP49SpU1BVVeVKfvqSoUOHEtmMTwd06dKhvXnzZpw/fx6FhYWYM2cOFixYAFVVVSKVrX4EXXFxcTx79gxDhgz56jHPnj3jqEL1X9fujH2mU7uz9Xn27Nm4fPkympqaoKGhgcTERI7NbS0bBlo/bzLa/z1dOrU7Y58ZGBgY+AVjwmRgYPhHFBQUYOHChZ1u8FNXV4eXL19i6NChoCiK+MQFv7GwsEBKSgo2bNiAkSNHQlNTEwsWLODL5OeHDx8gKioKcXFx9OrVi6+fbV1d3TdLOfXt2xefP3/mufabN28QHByMDRs2QFxcnN3u4uKC+vp6/PrrrxAVFeW5LsBZtjcrKwv9+/fHyJEj2W01NTVEdkuXl5dDVla23WPk5OTw6tUrnmv/SDx48ACRkZHIz8+HoKAgZGRkYGRkRLSsHL/KF/fp0weGhoYAgJKSElhaWtJiMuBneUI1NTUuc5a5uTlf0qJbPuvvgWRq5MCBA/Hs2TOuBNBnz55xJIqQ4NixYwgPD0dZWRkuXLiAiIgIDBgwgLjh2c7ODitXrsTcuXMxbtw4sFgsZGdno7q6mujizt27d3H06FGO60tAQAC//PILli9fTky3s0JX2mp6ejo2btwILS0t3L9/H01NTWhsbMS2bdvQ2NjI7AQnRHl5Od6+fYuFCxeirKwM9fX1HWrM3/reROcC+O3bt6GgoMC3z3bIkCHYtWsXKIoCRVE4d+4cR0p3y+Q+ibTApqYmrhKnAgICbDNsR2bnzp0oLS2FnZ0d8bFAa16+fAlvb2+uBLm6ujpUVlYiLy+PqH5DQwMqKio4tJ8/f4779+8TN9E/evQIBQUF7Ourpd/3798nmm5bWVmJoqKiNnVbp6TzmtraWqioqBB7/x8FxgDZ+fjzzz/h4+MDVVVVPHr0CGZmZpCTk8OOHTvw5MkTuk+PGPPmzUNaWhpf5iFbc/HiRairq3OZMDMzM2Fvb0+0goe7uzvGjh37TRNmSkoKEf2PHz/i1KlT7LmpkSNHYsGCBcTncOjS5bf2unXrsG7dOjx79gznzp3D3r174ejoCA0NDSxcuBBKSkpfrRzzX9RVV1dHaGgopk2bBkFB7mXnhoYGHDhwADNnzuww2p2xz3Rqd8Y+t2wg++OPPzB48GCuZ0uSdEZtps+do88MDAwM/IBFfbkqzcDAwNAOqqqqePv2LebMmYMlS5ZARUWlQw+OKIqCn58fjhw5gvr6ely4cAEBAQHo1q0bdu3aRXzx8NGjR4iJiUFRURH27t2LS5cuYcSIEURK4lAUhevXryMpKQmXL19GfX095OTkkJ+fj2PHjrETRHhNdXU1zp07hxMnTuD+/fvo2bMn1NTUMH/+fFhbWyM5ORkyMjJEtJcsWQJDQ0Noa2t/9ZiUlBRERETg9OnTPNN98+YNVq5cic+fPyM8PBxjx45lv3bo0CFERUWhZ8+eOHbsGM/L961cuRJLly7F0qVL8f79e8yaNQs///wzvL292ccEBAQgKyuL54lqcnJySE9Pb9dcWl5eDhUVFaLpOHSSmZkJExMTyMrKYvLkyWhsbMSdO3dQUFCAmJgYIqXKvyxffP78eezZswfXr18nWr74W2mqJJOIdu/e3W55Ql6aT27fvv3dx7ZObuQF/6TMI8lE1MDAQJw6dQouLi7sazgrKwuurq5QU1PD9u3bieiePn2aXRY6IiICZ86cwZUrV+Dr6wsrKyuYm5sT0W2htLQUsbGxePz4MSiKgqysLFauXEk0PW/KlCmIjY2FrKwsFBQUcOrUKUhKSuL+/fswNzf/R9fj/0prXVL8KAZjuli5ciU0NTVhbGzM8XlHRkbi5MmTOHPmDN2n2KGorq6GmZkZ7t+/DxaLhdTUVHh4eODZs2eIjo7m2CzTkaitrcXp06fx+PFjCAkJQVZWFvPnz29zUYmXTJ8+HZGRkRzjX36hpqaGEydOcKQkkqStsS8/7qE/AvLy8oiJiSGaDt0Wv/zyC4qKiqCpqYnIyEiYmpqiqKgIFy9exK5du4huWLhx4wa2bNnSZhnC7t274+7du8S0Dx8+zDZaslgs9gYkFouFyZMnEzNenz17Ftu2bUNtbS1bt2V+aMiQIbh06RIRXQDYtGkTpk2b1uGTMOniy41m7UHSpNYZGTduHC5evAgJCQlYW1tjzpw50NHRQX5+PtatW4e0tDS6T5EI5eXl0NLSgoyMDCQlJbmuP1LPs5qamvj06RN8fX0xZcoUNDQ0YO/evYiMjISqqipCQ0OJ6ALA8uXLYWxsjAULFhDT+BqvXr2Cvr4+KioqMGzYMDQ2NqK4uBiioqL47bffiI1/6dKlW7uFgoICnD9/HufOncOHDx8wb948aGlpYcqUKf953bdv30JHRweDBw+GhYUFJkyYgL59++Ldu3e4e/cuwsPD8fz5cyQmJrabJvhf0u6MfaZTuzP2uTWXL1/m2GgGgL3xKSYmhohmZ9Zm+sw/Xbq1GRgYGEjAJGEyMDD8I65evYr09HQkJydj06ZN6N27N3R0dKCrq4vhw4fTfXo858iRI0hJSYGLiwt27doFANDQ0ICrqytERUVhZ2dHTDs3NxerV6/GhAkTkJubi7q6Ojx8+BCenp4IDg7medlwFouFWbNmYdasWaiqqsLp06eRlJSEpqYm6OvrQ1NTE/r6+jw3YwoLC2P58uVYvnw5CgsLcfz4cZw+fRpnzpwBi8VCdHQ01q5dS2Q3/OLFixEUFAQlJSUMHDiQ6/U3b95g7969PE+cCgsLg4iICKKjo7mSYUxNTaGjowMjIyOEhYVh27ZtPNVes2YNnJ2dkZ+fj7t376Kurg4GBgYAmvt7+vRpREZGwsPDg6e6DM34+/tj2bJlXKXkXF1dERgYSGSBlK7yxd9auCNptOVnecKvGSsrKyshKCiIPn36ENPmZ6n59li/fj0KCgpgYWHB/p1TFAVVVVWiJY0PHToEJycn6Orq4tChQwCazXu9e/dGaGgoURPm+vXrYWdnhy1bthDTaAtlZWWEhobC19eX3fb27Vvs2bOHyAaN5ORkrrampiZcvHiRa5MALxO+SE1a/1fIz8+Hj48PV/u8efMQFBREwxl1bPz9/cFisXDx4kUsXrwYALB161bY2dnBx8cH/v7+RPVLSkpw//591NXVcb1GKjnvxYsXWL16Naqrq9mL0IcPH8b+/fsRHh6On376iYguAIiKiuLDhw/E3r895s2bh/Lycr6ZMIHm76rWCfMNDQ04fPgwV+oVqQTnrKysryaDk0yNFhERQa9evYi9/9fIzMxEaGgopkyZgmvXrkFDQwPy8vIICAhAWloaUROmv78/xo0bBwMDA2zcuBG+vr4oLS1FUFAQ8THb0aNHYWFhAUtLS8yZMwdJSUl49+4dfv31V6irqxPTDQsLw8KFC2Fubo7ly5fj0KFDePPmDVxdXYmXQx8/fjx8fHxw48YNjBgxgmuDLMnrm5+bZelCV1eXPa6vqqpCbGws5syZAwUFBQgKCiInJwepqakwNTUleh78rHDwoyAhIYGSkhJISEhAWlqanYbao0cPVFVVEdenY1wCNP8ua2pqUFdXh5KSEmI6X5KcnAxPT08YGxvDwMAAt27dwqtXr+Dt7Y1FixYR1R45ciTs7OwQEREBaWlpdOvWjeN1kte3l5cXJCQkOMp/lpeXw9raGnv27IGfn1+H0qVbuwVZWVnIyspi06ZNiIuLg5+fH+Lj44lvROeHroiICGJiYrB161b88ssvXNVhFBUVcfjwYSLP+nRpd8Y+06ndGfvcQkBAAA4cOICBAwfi77//xqBBg1BeXo7GxkZoaWkR0ezM2kyfO0efGRgYGEjCmDAZGBj+ESwWC8rKylBWVkZNTQ1SU1ORmpoKPT09yMnJYdmyZdDS0vpmief/CvHx8XB2dsbcuXPh5uYGAFiwYAGEhITg4eFB1ITp6+sLExMT2NrashNE3N3d0bt3byImzNb07dsX+vr60NfXx6NHj3D8+HGcPXsWZ86cIToxNGLECNjb28POzg5Xr17FyZMnkZycjKSkJMyYMQMRERE81dPX10dqaiq0tLSwdOlSTJw4EX369MG7d+9w7949JCUlQUpKCmZmZjzVTUtLY/8u26J///6wsbGBt7c3z02YixYtQm1tLY4dO4YuXbogMDAQ48aNAwAcPHgQcXFxMDc3bzcd9N/w5UL0l3z8+JGI7o/CgwcP4O7uztWur6+PpUuXEtGkq3zxl+l0DQ0NePbsGaKiouDk5ERMF6C3PGFsbCxCQ0PZKUhiYmIwMzODsbExcW26ykF269YN+/fvR2FhIQoKCkBRFEaNGsXzcvdfUlRUhMmTJ3O1T548GWVlZUS1MzMzuRbJ+IGDgwMMDQ0xY8YM1NbWYv369SgpKUG/fv04Eo15qdcWXxoEWSwWTxdlO+KC+j+hd+/eeP36NYYOHcrR/vjx42+WK/y35OfnY9SoUUQ12uPOnTuQlpZG//79kZycjPPnz0NRURHr1q0jlr5/5coV+Pn5cSQTDh8+HC4uLvjll1+IaLZw4sQJODs7c+z2b4HXf1etcXFxwdixY7Fnzx72eLSyshK2trZwd3dHWFgYEV2g2UxuYWEBVVVVSElJcd1LSRqn7t69i5iYGIwdOxZLliyBlpYW0c0SgwcPxvnz5znaBgwYwJUax2KxiPT74MGD8Pf3R9++fbkMkaQ0WzAwMIC/vz/HNcYPamtr2Sbi4cOHIz8/H/Ly8tDR0WFvPCNFfn4+EhMTMWrUKIwZMwY9e/aEgYEBevbsicjISGhoaBDTLi0txdKlSyEkJAQ5OTnk5ORAQ0MDDg4O8PLyIjYOffbsGfbu3QtpaWmMHj0alZWVUFNTQ0NDA8LCwog9UwLAsWPHICoqiry8PK4y8ySvb35vlqWL1iZaS0tL2Nracm1wOnLkCNG0UwDw9vZut8JBR0RTUxNbt26Fj48Ppk+fDhsbG0ycOBGXLl2ClJQUUW26xiVAcwJSSEgIVFVViWm0Rffu3bFr1y40NjYiOjoagoKCOHToEM+rWLTF8+fP2ZUk/v77b+J6rUlPT0dUVBTHxjoxMTHY29sT3cxIly7d2i3cuXMH58+fR2pqKioqKjBt2jTMnz+/w+hKS0sjISEBeXl5yMnJQVVVFURERKCoqEh8fogu7c7YZzq1O2OfgeawgR07dmDNmjWYPXs2fvvtN/Ts2ROWlpbEKyx0Rm2mz52jzwwMDAwkYUyYDAwM/zMfP35EVVUV3r59i7q6OnTp0gUHDhyAv78/fH19oaSkRPcp/mtevnyJ0aNHc7WPGjUK5eXlRLVzc3Ph4uLC1b5q1SrExcUR1W6NnJwctm/fDnt7e1y5coUvmgICAlBXV4e6ujoqKyuRkpKCpKQkIjpRUVEICgpCYmIioqKi2K+JiYlh9erVWL9+Pc9NxeXl5d+cPB81ahRev37NU90WWsqRf4m5uTksLS2JpQO1tRDdFhISEkT0fwRERERQUVHBlRxcUVEBISEhIpqNjY1sU15rqqurISAgQEQTaDshcsaMGRg8eDDCwsIwe/ZsYtoqKiq4fv0638sTJiYmwsvLC/r6+pg8eTKampqQkZEBf39/CAsLEzPaAt8uB0nShNlC3759MXHiRHZCTUtJelKl58XExPD06VOuCZk7d+60mW7MS3R1deHr6wtLS0tISUkR+/v9kkGDBiE5OZm9KaKpqQmrVq2CtrY2kYXpluQduikrK0NsbCzy8/MhKCiIkSNHYsWKFcSuLbpZtGgRPDw84OHhARaLhZqaGqSlpcHNzY14uUJtbW22QW3hwoVEDWpfEhcXB1dXVxw6dAiioqJwdHSEkpISoqKiUF9fT8xQU1lZiQEDBnC1CwsL49OnT0Q0WwgNDYWenh7s7e35ai7JysrCiRMnOMxx/fv3h4ODA1atWkVU++LFixAVFUVubi5yc3M5XiNtDIyPj0dRURGSk5MRHh4OLy8vqKurQ09PDzNnzuS50ffy5cs8fb9/ytGjR7F+/XpYW1vzXTstLQ337t3DtGnTICoqyvU9Sap8saSkJAoKCtgJci0bCJuamlBTU0NEswUBAQH237G0tDQKCgqgpKSE6dOnE9ko0ZpevXqhoaGBrf3kyRNoaGhgxIgRRBPlunXrxk6glJaWxuPHjzFr1iyMGzcOxcXFxHQB+v6+6NwsSxfp6enYunUrV/usWbM40tlJwM8KBz8KVlZW+Pz5M169eoVFixZh/vz5sLGxQZ8+fbB3716i2nSNS4Dm+9iXG5D4watXr+Ds7IwbN27A0tISubm5WLt2LTZu3Ii1a9eiS5cuxLRJVEL5XgQEBNqc6+zWrVubKaj/dV06tVsbIMvLyzFlyhRYWlpi7ty5RNPZ6dIFgDFjxmDMmDHfPE5dXZ3n6YF0aXfGPtOp3dn6XF5ezt6kICcnh+zsbGhqasLW1hZOTk5En/c6ozbT587RZwYGBgaSMCZMBgaGf0RtbS1SU1ORkpKCGzduQExMDDo6OvDx8WFPlrm6usLBwQFpaWk0n+2/Z8iQIcjOzuYqyZeWlkZ8F07Xrl1RXV3N1V5aWtpukiDJ85k3bx7fdfv37w8TExOYmJgQeX8hISHY2dnBxsYGL168QFVVFfr37w9JSUliiUtiYmIoKSlp1zxSVlbG11KJQLO5hyR0L0T/CMyZMwdubm4ICAhg75J98uQJPDw8iC3Y8bt88beQkZHhSqvhNXSVJ4yMjISjoyNWr17Nbps7dy6kpKQQExND1IRJZznIe/fuwd7eHs+fP+dobzGCkkpQXrFiBXvMAQBPnz7F9evXsXfvXuLJo5cuXUJpaSkuXLjQ5uskU6N79OiBZcuWEXv/H42CggLo6+uje/fukJeXR2NjI5KSkhAbG4tjx45h5MiRdJ8iz7GxsUFZWRmWLFkCoNn0S1EUZs+eDVtbW6La586da9OgpqysTGxc1EJMTAy2b98OJSUl7N27FyNHjsShQ4dw7do17Ny5k9i9e/z48Th37hwsLCw42g8fPvxdiyv/hjdv3sDU1JTvRgdxcXG8efMGMjIyHO0taR4koXs8OGzYMNja2sLW1ha3b99GamoqrKys0LdvX+jp6WHFihXEx8T8oqqqimhqWXtMmzYN06ZN47uunp4etm7dCi8vL6iqqsLAwACDBw9Geno68ZRfOTk5XLx4EcbGxhg2bBiysrJgZGREPJ0baE4BDwsLg7OzM+Tk5JCQkIB169YhMzOTaFl4eXl5xMXFYcuWLZCRkcGVK1dgZmaGJ0+ecI2/eUFpaSkkJCTAYrHYm32+BqmNGvzeLKuqqoqEhAQMGjQIwcHBMDMz4/t80MCBA/HXX39xbSS9dOkSsbKbLdBZ4YAufv/9d2zcuJGdfr5z507Y2Nigd+/eRDdRAvSNSwDAwsICgYGB8PDw4Ku+lpYWxMXFERcXx64SExcXB29vb1y8eBGJiYlE9T9+/IhTp05xbDZbsGAB8c9AUVER+/fvh4+PD/t+XV9fj9DQULbBvCPp0qHt4eHBNkBOmjQJ69evx7x58ziSOElAl+7/QmVlZZubxjuydmfsM53aHaXPffv2ZW8ok5KSwpMnTwA0j3dJhXh0Zm2mz52jzwwMDAwkYUyYDAwM/wglJSU0NDRg9uzZ2L9/P1RUVLh2BSspKRFLtuA3ZmZmcHV1xevXr0FRFG7cuIG4uDgcOXIEjo6ORLU1NDTg5+eHgIAAdlthYSE8PDyIJsh1VgQFBTFs2DC+aM2aNQvR0dGYMmXKV4+Jjo5mlyVi6DjY2NjAxMQECxcuRO/evcFisfD+/XvIysq2mS7CC/hdvrg9qqurER0dTdzcQFd5wtLSUigrK3O1q6ioEP+s6SwH6e7ujr59+yI4OJivJUfNzc3x4cMHbNmyBbW1tbCwsICgoCBWrlzJZabiNaSNra0xNDT87mMPHz5M8EzooaUUo6+vLztJrba2Flu2bIGvry8OHDhAVP/06dOYMmUKxMXFsX//fpw7dw6KiopwcnIiVpK+a9eu8PPzg7W1NfLy8tDU1IRRo0YRL3EFNJfv3bx5M2xtbXHjxg2cPn0adnZ26N69O3R0dLBkyRJiKUUvX76EmpoagObUrVmzZgFoNu+TTKDfvHkzTExMcPfuXTQ0NCA0NBRPnjxBXl4eIiMjiekCzaat4uJivoxBWxuWDAwMsH37duzYsQOTJk1Cly5d8ODBA7i4uNCWMlBXV4fs7GxMnjyZL3rZ2dlITU1FamoqAGDKlCnIyspCZGQk3NzcsHjxYr6cB0kmTZqEnJwc4uVr24Jkoml7rF27FoKCgmCxWJCXl8fGjRsRGhoKCQkJ+Pj4ENU2NzfHxo0bISQkBC0tLQQFBWHdunXIz88nvvGp5Rnj2LFjWLVqFUJDQzF16lR8+vQJZmZmxHQtLS1hZmaG/v37Q09PD8HBwdDS0sKrV6+IlDlVV1fHn3/+CVFRUaipqbW5OYD0JiB+b5Z9+/YtXr9+jUGDBiEkJASrV6/muwnTzMwMbm5uuHfvHsaPHw+KopCVlYWLFy8ST8Kkq8IBnbi7u2Ps2LFsEyYA9OvXjy/a/ByXfMnly5eRmZmJ6dOnQ1RUFIKCnMtWpOaZdXV1sXXrVo5x/cqVK6GkpAR7e3simi28evUK+vr6qKiowLBhw9DY2IiEhASEhYXht99+g7i4ODFtOzs7rFy5EnPnzsW4cePAYrGQnZ2N6upqogmddOnSoX3kyBF07doVM2bMgJiYGO7fv4/79++3eezu3bv/87oMDAzkUFJSgo+PD9zd3TFu3DiEhYVh9erVuHDhAnGDdWfUZvrcOfrMwMDAQBIW1VIvkIGBgeE7iImJweLFiyEiIoLKykpkZmZCTEwMioqK7GMaGhq4Jsv+y8THxyM0NJSdYCEqKoq1a9cSS2Zsobq6GmvXrsX9+/dBURR69+6N6upqyMnJISoqim+TsAy8p6SkBDo6Opg5cyYsLS05UrwePXqE0NBQXLt2DXFxccQTWxj4S3V1NXr27Inr16/j8ePHoCgKsrKyUFZWJppq8enTJ47yxSNHjiRWvrgFOTm5NhdGWSwW3Nzc2AlvHQlNTU1s2rSJq1zwmTNn4O/vTzT9a/LkyTh58iQkJSXh4uKCoUOHwszMDKWlpVi0aBGysrKIaY8fPx4JCQkYPXo0MY32+PTpE548eQKKojB8+HBakltIIicnhy5dumDSpElcydxf0hEXURQUFBAfHw9ZWVmO9kePHkFfXx+ZmZnEtPfv34+wsDBER0eDxWJh1apVWLZsGW7fvo1Zs2bBycmJiG5TUxP27duHAQMGsJN19fT0MHfuXKxfv56I5tfIy8vD2bNnERsbC6A5LUZFRQUuLi6QkJDgqdbs2bOxd+9eDBkyBLNmzUJkZCSUlJRw+fJluLu7E72HPnr0CIcOHWKbXkeOHAlTU1NMmDCBmCbQnHbl7e0NU1NTDB8+nKtkc3sbdv4pX34vt0wFfdlG0rwENF9T27dvR35+fpvJICS1X716hZSUFKSkpKCoqAgTJkzAkiVLOBKn9u3bh9jYWNy8eZPYefCLxMRE7NmzB3p6em1eX7xOyWyd0hccHPzV41gsFiwtLXmq/aPw4MEDCAgIQE5ODhkZGTh06BAkJCSwadMmos/v1dXVEBQUxMePH9G/f39UVFTg9OnTEBcXh6amJjFdAHj9+jXq6uogKSmJwsJCHDt2DBISEjA0NOR5Gubt27ehqKgIQUFB3L59u91jp06dylPtFnbs2IEXL14gICAAampqOHXqFOrq6mBjY4Px48fD09OTp3pmZmbIyMiAmJgYOwn0a+WRSW6GPnv2LI4cOYL8/HywWCyMHj0a69atY5cOJEV4eDiCg4OhoqLC1woHdLJ8+XIYGxtzPVPyA36OS76kve8NgD+/67q6Oo4+NzU1ES1Hbm1tjYqKCgQFBbFNBuXl5bC2toa4uDj8/PyIaQPN5vHY2FiOuamVK1cSr/xEly6/tQ0MDL77WF6aQOnS/V9QUFDAqVOn+PK7/1G0O2Of6dTuKH1+/fo1LCwsoKOjg9WrV2PlypXs52YHBwcYGRn9aw1Gm35dOrU7Y58ZGBgYSMKYMBkYGL6LkJAQHD58GAkJCZCSksLdu3dhbm7OTgBQUlJCaGgounfvTvOZkqGurg7V1dWgKAp1dXU8X3Rujxs3brAXhGVlZdtMHyVBRkYGCgsLsXDhQpSVlUFKSopISbHOyp07d2BnZ4dXr16hR48e6NOnD6qqqvD582cMGTIEHh4etJTwYyCLuro6goKCMHbsWL5rf/z4EUVFRRAQEMCwYcOIJbi1kJSUxGXC7Nq1KyZOnPhNIxmv4Pd9LDo6GqGhobC2toaioiJYLBYyMzMRFBQEAwMDogtHpqamGD16NLZs2YIjR47gypUr7DK+W7duJWommTdvHnx9fSEvL09M42tUV1fj3LlzKCgoQJcuXTB27FhoamoSv74pisLJkyeRm5uLz58/o/UjFYvF4ukC/NmzZ3H+/Hlcv34dcnJyWLBgAebPn4+BAwfyTONHRllZGWFhYezygC1kZ2fD1NSUqAlTXV0ddnZ2mD9/Pry9vXH37l3ExcUhMzMTtra2uH79OhFdf39/JCYmws3NDRoaGgCa7y8HDx6EkZER8aTXsrIynDp1CqdOnUJhYSEmTpwIPT09LFiwAG/fvsX27dvx4cMHnDhxgqe6e/bsQWpqKnr06IHq6mpcvHgRFy5cgJubG5YuXYpff/2Vp3o/AnJycl99jddmyG8ZllpDyrwENC8M19bWYunSpXB3d4eDgwOeP3+O2NhY+Pj4EEnPa2H06NEQFRXFokWLsHTp0jbTZf/44w+Eh4cTKSvMb/h5fQGAmpoaTpw4AREREXaq7de0SZrFsrKykJWVhfr6enw55dkRDVsAfc8Yjo6OcHJy4toA8+7dOzg5OSEkJIQv5/GlcYok/N4s+/79eyQnJ+P9+/cIDg6GiYnJV0vMd8Trm857CV04OTnh5MmTkJOTg7S0NNdzDclNV/z+3vhROHbsGMLDw1FWVoYLFy4gIiICAwYMIP43NXnyZERFRWH8+PEc7dnZ2TA3N8etW7eI6reGn/fRH0GXbu2v8eeff2LKlCnE5zN+FN2OYpD7L+h2Vu2O1ufa2lp069YNnz9/xvXr1zFo0CC+zcV2Rm2mz52jzwwMDAwk6DhRdQwMDMSIj4/HgQMHYGxsDFFRUQDNk+09e/ZEfHw8hIWFYWVlhQMHDtBWvo4UFRUV2LRpEyZNmoTNmzcDAKZNm4bRo0dj7969HOWBSKGkpAQlJSXiOi20LCrcu3cPLBYLM2fOhK+vL549e4bo6Gii5XDq6upw6NAhzJ8/H1JSUnBycmKX/fT19YWIiAgxbX6jqKiI33//HVevXkVubi7evXuH/v37Q0FBATNmzGAMrx2U2tpavpvV6+vr4enpiRMnTqC+vh4A0L17dxgaGsLW1paYrp6eHrH3/hbV1dUwMzPD/fv3+XofMzQ0RElJCTw9PdHY2AgAEBAQwPLly4mn17VXDpJ0isqGDRvg6ekJV1dXDB8+nG/3r8LCQhgZGaGmpgbS0tJoampCQkIC9u/fj5iYGKLfV97e3oiOjsaoUaPQp08fYjoAoKWlBS0tLVRXV+OPP/7AuXPn4O/vjwkTJmDhwoWYN29eh07Hnj59Onx8fBAUFMTuZ2VlJXx9fYmXd33z5g0UFBQAAH/99Rfmzp0LAJCQkMD79++J6Z46dQp+fn6YMWMGu83Y2BjDhg2Dq6srUROmkZERMjIy0L9/f2hrayMoKAjDhw9nv96rVy+sWrUKjo6OPNf+9ddfIS4ujhcvXmDNmjUQEBBARUUFli9fjk2bNvFcrwU6x5/8NI98zVhZWVkJQUFB4veyFnJzcxETEwN5eXmcOHECsrKyWL16NcTFxZGQkEDUhLlv3z7MmTOHI328ZaK/BXV1dairqxM7B37y6NEjvuq1TqslmVzbHgcPHoS/vz/69u3LZVRjsVhEDTWfPn1CdHT0Vw2ghw8fJqbNz2eMrKwsvHjxAgCQnJyMsWPHcpkwCwsL8ddffxE/FzqMU8LCwoiLi+PbZtk+ffrA0NAQQHNFDUtLS1pS3x88eIDIyEjk5+dDUFAQMjIyMDIyIr4wSte9hE6eP3+OSZMmAQD+/vtvvmrz29T6IyQonz59Gn5+fjAyMkJERAQAYMSIEfD19UW3bt1gbm5ORBdonito697drVs31NXVEdF8/PgxvLy82NUzWrC3t0dlZSV27txJpBw9Xbp0a/9TNm3ahJSUFL4bxujSZWBg+DavXr3CgAEDICgoyH5uzc7OxujRo4mHHHRGbabPnaPPDAwMDKRhTJgMDAzfJDExEQ4ODuxyiNnZ2Xj27Bns7OzY6SHr16+Hl5dXhzNhenh4oKGhAdra2uy2qKgouLq6wsfHBx4eHjSeHRn8/f0BABcvXsTixYsBAFu3boWdnR18fHzYr5PA19cXKSkpUFFRQXp6Ok6ePIlNmzbhypUr8PHx6XBlVoWEhDBv3jzMmzeP7lNh4BNr1qyBlZUV1qxZg6FDh3JNuJMo7+Xv74/ff/8d27Ztw8SJE0FRFO7cuYN9+/ahR48e+OWXX3iuCdBravH39weLxeL7faxLly5wcnKCtbU1nj59CgDs8tjl5eUQExMjogsAkyZNwoULF1BXVwcREREcO3YMv/32GyQkJP5ROar/haCgILx58+arZU1JJaa4u7tj9OjR8PX1ZW+KqKyshJ2dHdzd3b9Z0u7fkJycDE9PT76ajYWFhaGtrQ1tbW1UVVUhNTUVv//+Ozw9PTFlyhRoaWnxvLRscnLydx/La+0W7OzssHLlSsyZMwfS0tJgsVgoKipCnz59cPToUSKaLYiLi6OoqAh1dXXIz8/Hzp07AQCZmZlETb7v3r1rM3VdSkoK5eXlxHSB5ussODgYqqqqHEa11kyYMIFdnpyXdOnShet+Rfr+BdA7/hwyZAix9/4WsbGxCA0NRUVFBQBATEwMZmZmMDY2Jqrb1NSEAQMGAACGDRuGgoICTJ48Gerq6jhw4ABR7ZkzZ8LR0RHDhg1jb46YN28eVFRU4Ozs/MOlIXUEbty4gcePH0NISAiysrJQVFQkqnf06FGsX7+elnkJV1dXnDt3DrNmzWJf4/yCn88YLBYLDg4O7J/d3d25junZsyfMzMx4ptkWdBqnAP5vlgWaExA/fvyIuLg4thly5MiRWLBgAVFjZmZmJkxMTCArKwtlZWU0Njbizp07WL16NWJiYtiGQV7RUnadxWKhtLS03WMHDx7MU+0fATrLA/N7XJKUlIQ1a9agR48eSEpK+upxJE2Yhw4dgpOTE3R1dXHo0CEAzZsre/fujdDQUKL3EkVFRezfvx8+Pj7sjYz19fUIDQ1lbwTjJcXFxdDX18fAgQO5TJ5qamo4ePAgVq9ejcTERJ4aH+jSpVv7f4GuooVMsUQGhh+T0NBQhISEIDo6GpMnT2a379+/HxkZGfj1119hamrKaP/HdenU7ox9ZmBgYOALFAMDA8M3mDhxIlVUVMT+94EDByg5OTmqoKCA3fb8+XNq3LhxNJwdWaZOnUo9fPiQqz0nJ4eaPn06DWdEntmzZ1NZWVkURTX/7p8/f05RFEXdu3ePeJ9VVFSoP//8k6IoinJ1daWMjIwoiqKo7OzsDvt5M3QuRo0a9dX/5OTkiGgqKSlRly9f5mpPTU2lVFVViWhSFEV5eHhQU6dOpXJzc6k///yTGj16NBUaGkotX76ccnBwIKZLUfTdx+Tk5KiKigqu9hcvXlATJ04kptua2tpaqrCwkKqvr6fq6ur4opmUlNTuf6SYOHEix1ikhYcPH1IKCgrEdFu0X758SVTje/jw4QN15MgRatKkSUTuIe3ds/hx/2qhurqaio2NpXbu3Em5uLhQsbGx1Pv374lqUhRFRUREUFOmTKGUlZWpxYsXUxRFUUePHqXk5eWpiIgIYrorVqygvL29udoDAwMpPT09Yro/AlevXqUMDAyomTNnUi9fvqT27t1LnTx5kqgmv8efampqVGVlJUVRFDVnzhxKTU3tq/+RIiEhgRo3bhzl5eVFXbp0iUpNTaU8PDyo8ePHU4mJicR0KYqidHR0qJSUFIqiKGr//v3sMcGDBw8oRUVFoto7duyg5s2bR2VkZLDbUlNTqXnz5lFeXl5EtfmFnJwcVV5eTlEUxb4/f+0/klRUVFA6OjrUqFGjqKlTp1KTJ0+mRo0aRRkaGlJv374lpisvL089e/aM2Pu3h6KiInXu3DlatOn6jh41ahT1999/E3v/9tDR0WGPM1uP95OSkqi5c+cS03369CllbGxMjR8/nu9/V6WlpZSamho1YcIESkdHh1q0aBElLy9PzZkzh3r16hUx3VWrVlGurq5c7Tt37qT09fV5rvc99zF+jD/poqSkpN3/eM2PMC75koqKCur333+nMjMziWtNmDCBff9ofS95/vw5NX78eKLaT548oSZPnkypqqpSlpaW1MaNG6lZs2ZRioqK1IMHD3iut2XLFsrU1PSr8wSfPn2iVq9eTTk6OnYIXbq1/xdaX4OdQVdBQYEWXTq1O2Of6dT+L/f5/Pnz1JgxY6j9+/dT1dXVHK99+PCB2r9/PzVmzBjqjz/++LenymjTqEundmfsMwMDAwO/YJIwGRgYvgsWi8X+OSsrC/3798fIkSPZbTU1NejRowcdp0aUxsZGNDU1cbULCgqitraWhjMiT2VlZZvJHcLCwvj06RNR7Xfv3rHTVdPT07F06VIAgIiICD5//kxUm4GBH/C7vBfQnEjZuuRSCyNGjEBVVRUx3d9//x3+/v4YO3Ysdu3ahalTp+KXX37BzJkzsW7dOmK6AH/vY8ePH8epU6cANKcHWFpacpXjfvPmDfEyrxRFwc/PD0eOHEF9fT0uXLiAgIAAdOvWDbt27SJaIlxXV5fYe7fHwIEDUVZWxjEeAZrL0ZP+vFVUVHDlyhXo6+sT1WmLmpoaXL58GefPn0d6ejp69eqFBQsWECnhy+9Stl+jV69e7ER2fmJmZoZhw4bhxYsX7FTd3r17Y/v27Vi2bBkxXSsrK5ibm+POnTuYOHEiWCwWcnJycO/ePYSEhBDTBZrvnz4+PsjNzcXnz5+5UlFIfo+lp6dj48aN0NLSwr1799DU1ITGxkZs27YNjY2NWLJkCRFdfo8/dXV12Sl1urq6HM9Z/CIyMhKOjo4cf1dz586FlJQUYmJi2J8BCfT19eHk5ASgOYVSW1sb3bt3Z1/vJPnjjz8QEhLCoTN37lyIiIjA1tYW9vb2RPX5gaenJ3r37s3+mY7rC2hOhezWrRsuXLgAKSkpAEB+fj7s7e3h7u4OX19fIrqTJk1CTk4OW5OfdOnSBWPGjOG7LkDPMwZA7zihqKiIIzGlhcmTJ6OsrIyY7s6dO1FaWgo7Ozv23xq/8PLygoSEBBITE9G/f38AQHl5OaytrbFnzx74+fkR0X3w4EGbiaf6+vpEvi9iYmLYKfeHDx/m+fv/6KipqbV77+Z1lYHW4xJ+pvy3EBISgsOHDyMhIQFSUlK4e/cuzM3NUVNTAwCYPn06QkND2yzbzQvExMTw9OlTrjLMd+7cwcCBA4lotjBixAikpKQgNjYWjx8/BkVRWLhwIVauXEmkLPTt27fh7+//1bmB7t27w9LSEtu3b+8QunRrM3ybr1Ve6MjanbHPdGr/l/scExMDKyurNitYCQsLY/369aipqcGhQ4egpqb2r7QYbabP/NSlW5uBgYGBHzAmTAYGhm8yatQoZGRkQEpKCu/fv8etW7fw888/cxxz/vx5yMrK0nSG5Jg2bRr8/PwQGBjInmCvrq5GUFAQkbLBPwLjx4/HuXPnYGFhwdF++PBh4otKQ4cORU5ODiorK1FcXAwVFRUAwKVLl36IsjAMDP8WOsqOLlmyBHv37oWvry+7zCZFUYiOjmabikhAp6man/cxDQ0NZGVlsf8tLi7OtUAkKytLrFRzC0eOHEFKSgpcXFywa9cu9rm5urpCVFQUdnZ2RPXT0tIQGRmJp0+fIj4+HidOnMDQoUOJ9tve3h6urq5wcHDA1KlTISgoiJycHLi6usLIyIijfCEvShW2Lm8uIiICLy8v3LlzB9LS0ujSpQvHsRs3bvzXeq1pbbz8888/0aNHD2hoaGD//v2YPn06rRPLQHPZSFLlIOk0BQYHB8PMzIxjwm/x4sWorq6Gh4cH20jGa2bOnIljx47h8OHDSE9Ph6CgIEaMGIHjx49DTk6OiGYLO3bswL1797BgwQK2AYJf7Nu3D7/++iuMjY1x4cIFAICtrS369OmDqKgoYiZMfo8/W98frKyseP7+30NpaSmUlZW52lVUVODt7U1Ue8mSJejbty/69euHESNGwNvbGwcOHICEhAR27NhBVPvjx49tmqZERETw4cMHotr8ovXGCDrMNC1cu3YNsbGxHGbIUaNGYefOnURLis2fPx+7du1Cbm4uhg8fzlVinuS4ZN68eTh58iRsbGyIaXyNlmeMuro6vHz5EkOHDgVFUUQ34bToxcfHIz8/H42NjRztOTk5SE1NJaZNl3Hq7t27iImJIVIq+Fukp6cjKiqKbcAEmj8He3t7oiWTRUREUFFRgeHDh3O0V1RUcP2N8YKpU6e2+XN1dTW6du2Kbt268VzzR+JL42lDQwOePXuGqKgoImPP1uOSadOmYeLEiVz3jtraWly9epXn2vHx8Thw4ACMjY0hKioKAHB0dETPnj0RHx8PYWFhWFlZ4cCBA7C2tua5PgCsWLGC/UwJAE+fPsX169exd+9eGBsbE9FszeDBg7FlyxYAzfdOEn9TLbx9+xaDBg1q95ihQ4eioqKiQ+jSrd3ZqaqqQnFxcZshFi1rKhkZGR1KuzP2mU7tjt7nJ0+ewMPDo91jFi5ciMTExH+lw2jTq0undmfsMwMDAwO/YEyYDAwM32TNmjVwdnZGfn4+7t69i7q6OhgYGABoTvc6ffo0IiMjvzlo+i/i4OCA1atXY9asWRg2bBgA4NmzZ+jXrx8iIyOJaNbV1eHGjRsAACUlJQgJCeHs2bOIjo5GU1MTdHR02J8/CTZv3gwTExPcvXsXDQ0NCA0NxZMnT5CXl0eszy2sXbsWmzdvRpcuXTB9+nTIyckhJCQEISEh8PT0JKpNN60nW1+9egUJCQmaz4iBBHSYicrLy3HlyhWoqalBXl4egoKCyMvLQ0lJCSZMmABDQ0P2sbxMGqHTVM3P+1i/fv2we/du9r+dnJwgLCzMU43vIT4+Hs7Ozpg7dy7c3NwAAAsWLICQkBA8PDyImjDpSq/bsGEDgOaFw9ZpMRRFwdvbGz4+PqAoCiwWiyeJMUlJSRz/HjhwIO7du4d79+5xtLNYLJ6aMDds2ID09HR0794dampqCAkJgZKSEgQF+fso9/LlS3h7e3MYLSiKQl1dHSorK5GXl0dEl9+mwMLCQlRWVgJoTuaRk5Pj0i0oKEBCQgIxEyYATJgwgViiVXv89ddfOHjwIC2bjfLz8+Hj48PVPm/ePAQFBRHTpXv8+ejRI8TExKCoqAh79+7FpUuXICMjg2nTphHTHDx4MHJzc7mSsrOzsyEmJkZMtwUNDQ32z1paWtDS0iKuCQAKCgo4cOAAdu/ezTavUxSFmJgYjB8/ni/nwE/q6uqQmJiIx48fcy0Qslgsotd3nz59UF9fz9XOYrGIVtBoMfJGR0e3qU3ShNmnTx8cOnQIaWlpbRpAW48XeQ1dieienp5ISkrC2LFjcf/+fSgoKKC4uBgVFRXEzUt0GadERETQq1cvYu/fHgICAm2mAXbr1g11dXXEdOfMmQM3NzcEBASwN9m1LJzOmTOHmG4LMTExiIqKwuvXr8FisfDTTz9hw4YNxDe50UVr42kLM2bMwODBgxEWFobZs2cT0zY0NER6ejqH0Rdo/n1v2bKFa0P+vyUxMZE97wo0j0OePXsGOzs79rW2fv16eHl58dSEaWhoiODgYPTp0wfm5ub48OEDtmzZgtraWlhYWEBQUBArV67k2tTJKx4/fgwvLy+4uLhwjMXs7e1RWVmJnTt3suegeYm4uDiePXvW7ubgZ8+e8XwsSJcu3dqdmeTkZLi4uKCuro5r3pNX8zM/mnZn7DOd2p2hzywWi+v9v6RHjx4cG6F4RWfUZvrMP126tRkYGBj4AWPCZGBg+CaLFi1CbW0tjh07hi5duiAwMBDjxo0DABw8eBBxcXEwNzeHtrY2zWfKeyQlJXH+/HmcPXsWBQUFEBQUxKpVq7Bo0SIipXCKiopgamqKV69esfVtbW2xZcsW9kLs7t270dTUBCMjI57rA4CioiISEhIQGRkJKSkp3Lt3DyNHjoSTkxMmTJhARLMFHR0dyMnJ4eXLl5g1axaA5kS7iIgIzJgxg6g2XVRUVGDTpk2YNGkSNm/eDKD5cxg9ejT27t3L9xQqBrLQkTAmJCSEhQsXcrRNmTKFuMGGTlOLoqIi4uPj+X4f+9riel1dHbKzs9ssmcgrXr58idGjR3O1jxo1CuXl5cR0AfrS6/hdnvDy5ct81WutKygoiGHDhqGkpATh4eEIDw9v81iSn4m7uzuKioowf/58REZGwtTUFEVFRbh48SI7fZUE/DYFvnjxAr/88gvb2Ps1Qy2p67qFrKwsZGVlob6+nmtiktdJq63p0aMHBgwYQOz926N37954/fo1lzHw8ePHRL8z6Rx/5ubmYtWqVZg4cSJyc3NRV1eHhw8fwtPTE8HBwcTMLStXroSrqyvevXsHRUVFsFgsZGZmIigoiMhmr9ZJwt+C5PW9efNmGBgYIDMzE2PHjgWLxcKDBw/w7t07HDp0iJguXTg6OiI1NRVjxowhmqzVFhs3boSzszP27NnDrpjx4sULuLm5tVlyjFfQWR47NzeXPc588+YNX7XpSkS/dOkSvLy8sGDBAsybNw9ubm7sOYy2TLi8hA7jFAAYGBjA398fe/bs4Xs5ckVFRezfvx8+Pj5sY219fT1CQ0OJJnPa2NjAxMQECxcuRO/evcFisfD+/XvIyspi69atxHSBZkP13r17YWhoiAkTJqCpqQmZmZnYuXMnqquroa+vT1T/R0JGRobIpqfo6Gh2CjZFUZg5c2abx8nLy/Ncu7CwkGOsdfPmTbBYLKiqqrLbZGRkOCoc8ILbt29z3KM2b96M9evX48mTJ6AoCsOHDye2sbK4uBj6+voYOHAgl3laTU0NBw8exOrVq5GYmMjzzavq6uoIDQ3FtGnT2tzQ19DQgAMHDnz1Gviv6dKt3ZkJDAyEtrY2jI2N+Z5eTJd2Z+wzndqdoc8jR47ErVu32JsS2iI9PZ1r/oTR/m/p0qndGfvMwMDAwC8YEyYDA8N3sXTpUnYp2daYm5vD0tISIiIiNJwVfxAWFsaKFSv4ouXt7Y0xY8YgPj4ePXr0gL+/P+zs7LBu3Tp2WbPw8HAkJSURM2G6ubnByMiozSQifiAnJ8dRarNlMbyj4uHhgYaGBg4Tc1RUFFxdXeHj49MhE2Y7M3QkjNnb26Nfv35802uBblO1nJwc9uzZQ1ynNQ8fPoSTkxPy8/PR1NTU5uukGDJkCLKzs7kWatLS0rjKNPIautLrCgoKsHDhQr5d3+rq6jh+/Djfxzw6OjocSZ90kZmZidDQUEyZMgXXrl2DhoYG5OXlERAQgLS0NCxfvpyILr9NgbNnz8bly5fR1NQEDQ0NJCYmcqQBsVgs9OzZk+h1d/DgQfj7+6Nv375caVu8Tlr9Eh0dHURERMDNzY3v192iRYvg4eEBDw8PsFgs1NTUIC0tDW5ubliwYAFRbbrGn76+vjA1NYWtrS3bQOPu7o7evXsTNWEaGhqipKQEnp6eaGxsBEVREBQUxPLly9kpw7zkyyThr0H6+h43bhzOnDmD+Ph49ga7hQsXYs2aNUTLF9PF1atXERAQwJE8ShI5OTmuZGptbW306tULAgICeP/+PVgsFsrKyohWdqCLI0eO0KZNVyL6u3fvMHHiRACArKws8vLyMHz4cFhYWMDGxgbbt28notvC14xT5eXlxFLN0tLScO/ePUybNg2ioqJcBmcSlQ1asLOzw8qVKzF37lyMGzcOLBYL2dnZqK6uJnr99e3bF8ePH8f169fx+PFjUBQFWVlZKCsrs1OFSREVFQU3NzeOTYUaGhoYMWIEQkNDO40Js7q6GtHR0d8sq/y/oK+vj379+qGpqQnbtm2Do6Mjh8G4Zew7ffp0nmu3vH8LWVlZ6N+/P0aOHMluq6mpIZqg3EKPHj34koodEhKCcePGISwsjCuleNGiRZg7dy7MzMywf/9+nm9eNTc3Z1dXsrCwwIQJE9C3b1+8e/cOd+/eRXh4OJ4/fw4vL68OoUu3dmemqqoKpqamkJaW7jTanbHPdGp3hj4vXboUPj4+UFRU5JiraOHRo0cICgrC+vXrGe3/sC6d2p2xzwwMDAz8gjFhMjAw/CtITAD+SNTV1SE+Pp6j9GZLe05ODlJTU3mqd+fOHRw+fJi9CGhnZ4e4uDiOhbP58+cjJCSEp7qtSU5OhomJCbH3b4/WZZHbgt+pZ/wgPT0dMTExHLu+xowZgx07dsDc3JzGM2MgAR0JY8rKylBXV4eenh5UVFTQpUsXvmnz09Ti6OjILgXu6OjY7rGkykF6enpCUFAQLi4ucHd3h4ODA54/f47Y2FjixnYzMzO4urri9evXoCgKN27cQFxcHI4cOfLNz+PfQld6XXh4OHx8fDBnzhwsWbIEKioqRE1jJSUlbZprSfOjLAjV1tayTb7Dhw9Hfn4+5OXl2YtapKDDFDh48GAAzUaKwYMH892MePToUaxfv56nZRfbo/X4q6GhAXfu3EFaWhqkpKS4vjNIjsVsbGxQVlbGThnV1dUFRVGYPXs2ezMSr2htqlZTU2v3d0zSUJObmwsXFxeu9lWrViEuLo6YbpcuXeDk5ARra2s8ffoUAIimPtGVJNwWQ4YMYafPd3T69u0LKSkpvul5enrSsmlg9OjR+PPPPyEqKsplBP0SXm+IycjIgIKCAgQFBZGRkfHV41gsVodMRBcTE0NFRQUGDx6MoUOHoqCgAEBzyW7SSeyjR49ml01ubZx6+fIlFi1ahLt37xLRnTZtGrtKCb8ZMWIEUlJSEBsbyzZDLly4ECtXriS+6apLly5QVVXlSCjkB+/fv8fYsWO52idNmoSKigq+ngu/+Np9jMVisU3WvERQUJBd2p3FYkFLS4tv6cmjRo1CRkYGpKSk8P79e9y6dYur5Pn58+fZicq8pKysDLW1td88ruW5gFfcvn0b/v7+XAbMFrp37w5LS0siJnYRERHExMRg69atHMn/QPPGCUVFRRw+fLjd0t3/JV26tf8X9PT0iI3H+ak7b948pKWl0WKQo0u7M/aZTu3O0GddXV2kpaVh6dKlUFNTw8SJE9GnTx+8e/cO9+7dw9WrV6GsrExkPq4zajN97hx9ZmBgYOAXjAmTgYGBoR08PT2RlJSEsWPH4v79+1BQUEBxcTEqKipgbGzMc733799zpC316tUL3bt3R58+fdht3bt3/66Jwv+V2bNn4+jRo9i4cSPfJ36+nPSqr6/H8+fPUVBQQOTz/hFobGxs09QjKChI9PfMQA90mIn279+PlJQUWFtbo3fv3tDW1oaurm675R54QUVFBQICAr5aTpfXppaXL1+y/5ZevnzJ0/f+XnJzcxETEwN5eXmcOHECsrKyWL16NcTFxZGQkID58+cT016yZAkaGhoQGhqKz58/w9nZGaKiorC1tcWqVauI6QL0pdddvXoV6enpSE5OxqZNm9C7d2/o6OhAV1cXw4cPJ6bbWZGUlERBQQEkJCQgLS3NNrI0NTWhpqaGp1o/iilwyJAhSEtLQ0REBIqKihAfH48TJ05g6NCh7MVqElRVVRF9/y/5cvzFT9NWa7p27Qo/Pz9s2rQJDx8+RFNTE2RlZSEjI8P1HfJv0dXVRffu3dk/05U227VrV1RXV3O1l5aW8jz16WulPFvS4t6/f4/3798D4L3h4EfiypUrCAsLQ35+PgQFBSEjIwMzMzPMnTuX7lPjOevXr4eXlxd27txJ3KAFNC/g04Gnpyc7tY3fRlADAwOkp6dDVFQUBgYGYLFYbd6vWCxWh0xEV1VVhYuLC3bv3g1FRUV4eHhg7ty5OHfuHMTFxXmud/z4cZw6dQpAs3nG0tKSy8j05s0bjvkTXkMyrfd7GDx4MLZs2cJXzaKiIuzatYv9XPclJK9tdXV1HDt2DNu2beNoP3nyZIetmtLWhsGuXbti4sSJPC9PDTRvxG5JzmWxWDh37txXj+X1+HTNmjVwdnZGfn4+7t69i7q6OvZi+5s3b3D69GlERkYSqRDTVrWn1lAUReTe/fbt228GGgwdOpSYyVhaWhoJCQnIy8tDTk4OqqqqICIiAkVFRaJzRHTp0q3dQl1dHRITE/H48eM253pb/u537NjRIXS3bNkCLS0tpKamQlJSkmtsRmpjNJ3anbHPdGp3lj4HBgbi2LFjOHbsGDsMhsViYdy4cXBxccHSpUuJPft0Rm2mz52jzwwMDAz8gDFhMjAwMLTDpUuX4OXlhQULFmDevHlwc3ODpKQkbG1t25x85gVtlXPi52CztLQUZ8+eRUxMDERFRdGtWzeO10mmAX3tITUoKKjDphxMmzYNfn5+CAwMZC8eVldXIygoiK8lqxnIQbeZaNasWZg1axaqq6tx/vx5nDp1CtHR0Rg3bhyWLFmC+fPnEzFcOzs7IzMzEzo6OhzlzEjRugRfW+X4amtrue5nvKapqYmddDps2DAUFBRg8uTJUFdXx4EDB4hqA8CKFSuwYsUKVFZWgqIoiIqKEtcE2k+vs7W1JabLYrGgrKwMZWVl1NTUIDU1FampqdDT04OcnByWLVsGLS0tttGKF9y9e/e70j074v1bT08PW7duhZeXF1RVVWFgYIDBgwcjPT0do0aN4qnWj2IKTE9Px8aNG6GlpYX79++jqakJjY2N2LZtGxobG9nXPK+ZNGkScnJy+Nbv1uOv0tJSiIuLc30/NTQ0IC8vj+h5qKur48SJE5CSkuLo++vXr7F48WLcunWLZ1qtTTRWVlY8e99/ioaGBvz8/BAQEMBuKywshIeHB2bPns1TrW8lfgLkDAet4XdSYWsuXboEKysrzJ07F1paWmhqakJGRgasra2xb98+qKurE9OmA1lZWfj6+mLevHltvk7ysw4ODm73dV4a2XR1ddk/89sI+scff7A3UZJ8Tv4WdCWi29nZwd7eHpmZmVi9ejUSEhKwbNkyCAoKwtvbm+d6GhoayMrKYv9bXFyca5wnKyvLc6NYcHAwzMzM0KNHj3avbRaLBUtLS55q/wjs3LkTpaWlsLOz48tzXetrtq6uDkeOHEFmZiYmTZoEAQEBPHjwAHfu3MGyZcuInwsdsFgstimyNR8/fkR0dDTPNyg7ODhARUUFoqKicHBwaPe8eP23tWjRItTW1uLYsWPo0qULAgMDMW7cOADAwYMHERcXB3Nzc2hra/NUF2ieZyRZteFriIuL49mzZ+0mLz579oy9SYYUY8aMwZgxY755nLq6Ok+TIunSpVvb0dERqampGDNmDN+SZunU3b17N2pqalBXV4eSkhK+6dKp3Rn7TKd2Z+rzqlWrsGrVKtTV1aGqqgr9+vX7apryn3/+iSlTpvBs/rszajN97hx9ZmBgYCANi+J1pAQDAwNDB2LcuHFITU3F4MGDsXHjRmhqamLhwoXIycmBjY0NzxdaWpfUakFRUREpKSnsBIvy8nKoqKgQWzTj54LZ9/LixQssWbIEt2/f5rs2aV68eIHVq1ejuroaw4YNA9A84dqvXz9ERkay2xj+u/yThU+SO3VbqKioQGJiIsLCwvD582f06NEDS5YsgY2NDU/NmBMnTkRISAhmzpzJs/f8XlqSIIcNG4b169cDaE7qUVFRgbOzM7HJZ11dXZiYmGDx4sUIDQ3F8+fPsXv3buTl5cHAwIBj0ZjXJCcnf/U1ISEhDBo0CBMnTmzT6M8riouLudLr+MXff/+Ns2fP4vfff0d2djYmTpyI8vJy1NTUwNfXF0pKSv9ao8U49K3HJ9IGJjqJjo6GtLQ0Zs+ejfDwcISFhUFCQgJ79uxpswzqf52VK1dCU1MTxsbGUFBQwKlTpyApKYnIyEicPHkSZ86cIaKbmJiIPXv2QE9PD8OHD+e6Z5FMyWxrLAo0j020tbVx//59nuqdO3cO169fB9CcarVgwQKuCdWSkhIUFBTg5s2bPNNt7575JSQ/7+rqaqxduxb3798HRVHo3bs3qqurIScnh6ioKPTr149nWv9kHD116lSe6X5JUlIShwmzoaEBz549w8mTJ+Hg4IDFixcT09bV1YWGhgaXSSo4OBhXr17F8ePHiWnTwaJFi9CjRw/o6Oi0maza2rzIa9TU1Dj+3dDQgMrKSnTt2hUKCgo4dOgQEd32Ep9YLBY8PT2J6P4IxMfHIzQ0FGVlZQAAUVFRrF27FiYmJnw9j7y8PIiJiWHgwIFEdRwdHeHk5MSX6h1qamo4ceIEREREuK7t1rBYLFrNuKSQl5dHTEwMFBQU+KL3vWUHWSwW0UR0flJZWYnPnz8DaDaAHT9+HCIiIhzH5OXlYfPmzcjOziZ2Hh8+fOCL0fZ7eP36NYSEhLg+B14gJyfHTjHmNz4+PsjOzkZ0dDQEBbnzURoaGmBiYoJhw4Zh165dfD+/L2n9DNQZdElpT5o0Cd7e3tDQ0ODZe/7IugoKCggMDISqqipfdenU7ox9plO7M/b5e/hyHZHR7pi6dGp3xj4zMDAw/C8wSZgMDAwM7SAmJoaKigoMHjwYQ4cORUFBAQBAREQE5eXlPNejKIrLsERR1FfTS0hAd3mttnjy5AnPy1D+KEhKSuL8+fM4e/YsCgoKICgoiFWrVmHRokU8TW9joI+2jJV1dXVsU82rV68gISFB9Bzq6upw6dIlJCcn46+//sKAAQNgbGwMPT09vH79Gh4eHrCyskJUVBTPNHv27Em8X1/D09MT9+/fx/Lly9lt27dvh6+vLwICAmBvb09EV19fH05OTgCAefPmQVtbG927d8edO3cwceJEIpot7N+/n12SvWXh7MOHDxymwWHDhiEqKopIeUgAXOl1pKmtrUVqaipSUlJw48YNiImJQUdHBz4+Phg6dCgAwNXVFQ4ODkhLS+OJZkJCApc5jZ9UV1fzxWzwNQwNDfHu3TsAgLm5OSZNmoTx48d/dZcyrygrK0NsbCy7fPDIkSOxYsUK4iWT8/Pz4ePjw9U+b948BAUFEdNtKQcXHR3N9RqJFKLY2Fi2IYqiKCxZsoQrCfP9+/dEPm8FBQXExcWx71OlpaUc1xOLxULPnj15nqjWXtJTa0h83q0RFhZGXFwcbty4gby8PLaJXUVFhet38G8haaz8J3wtqVBOTg4pKSlETZiFhYUIDAzkal+4cCHCw8OJ6dJFcXExUlJSaNnUdfnyZa626upq2NvbY9q0acR06Up8Apo31/n6+n615CevzXm2trbYsWMH+vfvj4yMDCxZsoSWRPRPnz7hyZMnqK2tZd/La2pqUFxcTDQZvOUZ6/r16xzjg+nTp/N801Hr67mta7ujIyIigl69evFNr62qBh2da9euwcHBgf3s1lapbIqiiBs+dHR0EBQUhLFjxxLV+R6+VbL7v4q5uTl0dHRgYGAACwsLTJgwAX379sW7d+9w9+5dhIeH4/nz5/Dy8qL7VBl4SN++fWmp7kCXbq9evdhzMp1FuzP2mU7tztjn74HO9bPOqM30ufNoMzAwMPxTGBMmAwMDQzuoqqrCxcUFu3fvhqKiIjw8PDB37lycO3eOiImFHyl438ODBw8QGRnJXsyQkZGBkZER5OXlieq2lRj44cMHpKenQ1NTk6g2nQgLC2PFihV0nwYDH6ioqMCmTZswadIkbN68GUDzQsfo0aOxd+9eIuWwnJyccOHCBdTV1UFNTQ2hoaFQVlZmp1ANHToUFhYW2LZtG091dXR0EBkZiV27dhFNX2yLy5cvIzg4mMP4OHfuXIiIiMDW1paYCXPJkiXo27cv+vXrhxEjRsDb2xsHDhyAhIQE21RFilWrViEpKQl+fn6QlZUFADx9+hRbt26Fnp4eNDQ0sH37duzZswd+fn7/Wu9b5WRbQyoVUklJCQ0NDZg9ezb279/fpmlJSUmJp6aHwYMH05KY0oK2tjZtC6PFxcUwMzPD3Llz2X9Dv/zyCwYMGICIiAhipuuCggLo6+uje/fukJeXR2NjI5KSkhAbG4tjx45h5MiRRHQBoHfv3nj9+jXXBPvjx4+Jli989OgRsfduCz09Pbx9+xYURSEkJASamppcZotevXoR2RQkISHBTrEyMDBAcHAwX0pD8vsz/hqGhoYIDg6GkpISR2JvRUUFzMzM/lFi5z/BwMCgzXs4i8VC165dIS4uDm1tbaIGqi9RVFQk/l05cOBAPHv2jGsx+tmzZz9M8hcvGTlyJF6/fv3DJOsLCwvD2toaFhYWMDQ0JKJx9epVBAQE8D3xCQC2bt2Kv//+G/Pnz+dLibRLly5h8+bN6N+/PwwNDdkpxvzcLJKWlgYbGxt8/vyZa1GMdDL4+/fvYWZmhpycHPTp0wdNTU2orq7G2LFjERUVhT59+hDTBporlNTX13P1m+QGkYMHD0JbW5vv5jQDAwP4+/tjz549fL9XlpaWtvs66Q05/EJHRwdDhgxBU1MTjIyMuEplt2xKaXnOI0VtbW2n2Aw8ePBgnm92+V5EREQQExODrVu34pdffuEYj1EUBUVFRZ6Xwmagn/Xr18PLyws7d+7ka4IXXboWFhYIDAyEh4cH3zeR0qXdGftMp3Zn7DMDAwMDAwPDfwfGhMnAwMDQDnZ2drC3t0dmZiZWr16NhIQELFu2DIKCgjxP5AHIloT7XjIzM2FiYgJZWVkoKyujsbERd+7cwerVqxETE4NJkyYR03758iVXm5CQEMzMzPheRo0kLQvuffr0+eYCZEcpr8XQjIeHBxoaGqCtrc1ui4qKgqurK3x8fODh4cFzzby8PFhbW2Px4sVfNbaMGjWKJ8a81pSXl+P8+fO4cuUKhg4dypVGRPLarqmpaXOBUEREBB8+fCCmC4Bj0V9LSwtaWlpE9VqIiopCYGAgx8Lc8OHDsX37dlhbW2P16tWwsbGBqakpT/Q8PT2/24RJipbrur0SdWpqanxNkyZNbW1tmyVl+YGHhwdkZGRgZmbGbvv999/h6OiI3bt3E0uG9PHxwfTp0+Hr68u+j9TW1mLLli3w9fXFgQMHiOgCzaV8PTw84OHhARaLhZqaGqSlpcHNzQ0LFiwgptsepaWlPDcc9OjRg52EzmKxYGZmRst19iMmX5H4vNPS0pCTkwMAyMjIQFhYGHr27MlxTHFxMUpKSniq25rRo0fjyJEjGD16NCZPngwAyM7Oxr1796ChoYFXr17BxMQEe/fuhbq6OrHzaM3Zs2eJG3AXLlwIV1dXuLi4sJ9psrKysGvXrg654WvTpk3YsWMHu6zpl2VP+WmybaGlLDkp6Ep8Apo3ncTGxvJto4SUlBQsLS0xduxYUBQFd3f3r5o/SW323LNnD2bOnAlLS0vipscv8fb2xufPn3Hq1Cn2+PfRo0fYsmUL/Pz84OrqSkT33r17sLe3x/PnzznaKYoibjw9ePAgfv75Z2Lv/zXS0tJw7949TJs2DaKiolzPdSRLsKupqbX7zEHy8+Y3Lffkw4cPQ1FRsc1S1aRZs2YNrKyssGbNGgwdOpTLkEnH9wYJ/pdEW3V1dZ6ZI6WlpZGQkIC8vDzk5OSgqqoKIiIiUFRUxIgRI/71+zP8eMjKysLX1/ercxOk7mV06V6+fBmZmZmYPn06RLLZHlUAAQAASURBVEVFue5nJL836NLujH2mU7sz9pmBgYGBgYHhvwNjwmRgYGD4Ah8fH1hYWKBv37748OEDgoOD2TukDx48iLy8PIiJiWHgwIE0nykZ/P39sWzZMjg7O3O0u7q6IjAwkOgCuZWVFSZOnMj30nH8ZsiQIexritnd3rlIT09HTEwMx8T6mDFjsGPHDpibmxPRPHny5DePGT58OIYPH85TXQEBASxcuJCn7/m9KCgo4MCBA9i9ezc7hZOiKMTExGD8+PFEtdPS0hAZGYmnT58iPj4eJ06cwNChQ4mWswWaU4Pb2oHdvXt3VFVVAQD69OnTZnnM/4WvlZPlJ0ZGRt88hpeLl1OmTCFedvtbrFmzBhs3bqRlYfTOnTtITEyEmJgYu61///6ws7PDmjVriOlmZWUhPj6eY2zQrVs3bNiwAfr6+sR0AcDGxgZlZWVYsmQJgObNMhRFYfbs2bC1tSWm+/LlS3h7eyM/Px+NjY0Amu9hdXV1qKysRF5eHjHtjRs3oqGhAa9fv+bSvn//Ps/vZaNHj8aff/4JUVHRbybsklok5PfnPWTIEOzatYudnnbu3DmONKaWtKutW7fyVLc1ZWVlWLNmDbZv387R7uvri9LSUgQHByM6OhphYWE8N2F+aaihKAo1NTV4//490b8roDkNqKCgABYWFuxzaCnv2pJQ3pGwsLAAAOzatYvrNdJmsS9TXCmKwocPHxAfHw8FBQViunQlPgHAsGHD8PHjR77p+fj4YP/+/SgpKQGLxUJpaSnfxynFxcUICQmhxfj6xx9/YN++fRwbkOTk5LBjxw7Y2toSM2G6u7ujb9++CA4O5nsq5IQJE3D58mW+b1CdNm0apk2bxlfNFr7cuNfQ0IBnz54hKioKTk5OtJwTaaZOnYpHjx6hoKAATU1NADjHYp6ensS09+7dCwBwc3Pjeo3098aPTmVlJfv3wSvGjBmDMWPGfPM4XhpAGehh+/btkJKSgo6ODl83u9GlO2nSJKIhDj+idmfsM53anbHPDAwMDAwMDP8dGBMmAwMDwxccPXoUBgYG6Nu3L9TV1dllvVr4ngmy/zIPHjyAu7s7V7u+vj6WLl1KVHvTpk2IjIykpcwqP2mdRPKjlKBn4A+NjY1tTtwLCgryzBwHAMHBwd99bEv6Ga+h89revHkzDAwMkJmZibFjx4LFYuHBgwd49+4dDh06REw3PT0dGzduhJaWFu7du4empiY0NjZi27ZtaGxsZBu5SDB58mTs2bMH/v7+7AXh9+/fw9/fn212SE1NJVaS9Pz584iJiUFBQQEEBAQwZswYmJubQ1lZmac630rDaQ2vd5//CCl9dC6MCgoK4u3bt1zX0KdPn4hpAs1lsOvq6rja22rjNSUlJfDz84O1tTXy8vLQ1NQEWVlZyMjIENV1d3dHUVER5s+fj8jISJiamqKoqAgXL15s00zFS27cuIEtW7agoqKC67Xu3bvz3ITp6enJvmfRlbDL789bRkaGfX9SU1PD8ePH+Vo+GACuX7+OpKQkrvalS5eyk/nV1dXZ9xxeoqury/V77tq1KxQVFYknbHXr1g379+9HYWEhCgoKQFEURo0a1WFTp+hMYXFwcOBqExQUhKKiIlxcXIjp0pX4BAAuLi7YuXMnDAwM8NNPP3GVuuX19T1mzBj2mF9NTQ2hoaHtpoOTQFpaGn///TctJsyGhoY2752ioqKorq4mppufn4+EhASMHj2amMbX6NmzJ3x8fBAWFgZpaWmu5FNSlQZIPS9+D1OnTuVqmzFjBgYPHoywsDDMnj2b/ydFmMOHD7ONliwWi71pg8VisdOrSXHx4kXaynQzfB0SBlAG/lJcXIyUlBRi8zE/mi6d3xt0aXfGPtOp3Rn7zMDAwMDAwPDfgTFhMjAwMHzBoEGDsH37digoKICiKERERHCVCGyhIz50iYiIoKKigisVr6KignhCpaioKPFSwT8iT548QUFBQZuGEtLpeQz8Zdq0afDz80NgYCDbdFJdXY2goCCeLsy2ZawoKyvDgAED2MmQQPNCTke8j40bNw6nT59GQkICCgoKICgoiIULF2LNmjVEU4z37duHX3/9FcbGxrhw4QIAwNbWFn369EFUVBRRE6azszOMjIwwa9YsDBs2DBRF4dmzZxAREUFERATS09Ph5+eHgIAAnmsfP34czs7O0NTUxIIFC9DU1IQ7d+7AwsICe/fu5SjR/m/50rxDURQOHDiAlStXol+/fjzT+VGh01CjqqoKd3d3BAQEsM0WL168gKenJ1RUVIjpTp8+HT4+PggKCmL/jisrK+Hr64vp06cT0wWaN6Ds378f8vLyGDp0KFGt1mRmZiI0NBRTpkzBtWvXoKGhAXl5eQQEBCAtLQ3Lly8npu3v749x48bBwMAAGzduZCcjBgUFETHXtxj+gOaE3Xfv3uHdu3eQlpYG0JwSqaSkRNRYROfn3VIOs7q6Gk+fPkXXrl0hKSnZZrIxLxEWFkZhYSHXguyTJ0/YKTk1NTVcabu8wMrKCk1NTXj37h3bQHX37l2MGzeO51pfcvnyZaipqWHEiBEcxsvnz5/D0dERsbGxxM+Bn9CZmJWRkcH3lECAvsQnAHj8+DGePHnSZjof6Y0SX5bWraysxO3btzFu3Dj89NNPPNUqLS1l/7xy5Ups374dTk5OkJaW5njOAIDBgwfzVLs1Y8eOxbFjx7gSfX/77TeiBkkJCQnU19cTe//2EBYWZuYH/j8yMjJEk8Hp5OjRo7CwsIClpSXmzJmDpKQkvHv3Dr/++ivP06m/xNraGp6enpCTkyOqw/DfgY4NUnTqktIeOXIkXr9+zXczJD91g4ODYWZmhh49erS7MZzFYsHS0rJDaHfGPtOp3Rn7zMDAwMDAwPDfhDFhMjAwMHyBs7Mz/P39cfLkSbBYLK4SgS10VPPSnDlz4ObmhoCAAPbi5JMnT+Dh4YE5c+YQ1VZWVoaFhQVUVVUhJSXFlezQET/vgwcPwt/fv83XWCwWs8jSwXBwcMDq1avZRjkAePbsGfr164fIyEie6Xy5EAs0l+g+evQo0dKM3yol2xrSpcx++uknvpcWzc/Ph4+PD1f7vHnzEBQURFRbUlIS586dw9mzZ/Hw4UMICAjA0NAQWlpaEBISQrdu3XD69Gmel50HgPDwcGzduhXGxsbsNmNjY0RERCAoKIinJkwrKyuutkOHDsHIyIjvZUfpoMVQU1dXh5cvX2Lo0KGgKIov5Uft7e1hamoKTU1N9OnTB0Bz2urYsWPbTDzjFXZ2dli5ciXmzJkDaWlpsFgsFBUVoXfv3sQNU0JCQjwtaf+91NbWsk0zw4cPR35+PuTl5aGjowMDAwOi2vn5+UhMTMSoUaMwZswY9OzZEwYGBujZsyciIyN5+vf8JdnZ2TA3N4eenh7s7e0BAHv27EF9fT2ioqIwcuRIIrp0ft4A4O3tjaNHj6KhoQEURUFISAgrVqzAtm3biC1A6+npwdnZGW/fvsWECRPQ1NSE+/fvIygoCNra2nj79i18fHyIJFMWFxfDzMwMc+fOZf+eLSwsMGDAAEREREBCQoLnmi1YW1sjJCQEs2bNYrdFR0cjMDCwQ5b4NDQ0bPd1Uql5QPNGsqCgIL5XOKAr8QloXpxdsmQJDA0NiRiY26OgoABWVlZwd3eHnJwcFi9ejPLycggJCeHgwYM83bTwZSo5RVEwNzfnaiNtPLWxsYGhoSHu378PRUVFsFgsZGZm4tGjRwgPDyemu2HDBnh6esLV1RXDhw/nawl4popGM9XV1YiOjsagQYPoPhUilJaWYunSpRASEoKcnBxycnKgoaEBBwcHeHl5cTxz8ZqSkpKvbkJn6Jx8aa7v6LqktDdt2oQdO3bAxMQEw4YN43rGJJUGz0/dpKQkrFmzBj169GhzY3gLJExqdGl3xj7Tqd0Z+8zAwMDAwMDw34QxYTIwMDB8gYqKCjvRSU5ODidOnICoqCgt51JaWoo+ffpAWFgYN2/eRGpqKhQVFbFw4UJimjY2NjAxMcHChQvRu3dvsFgsvH//HrKysti6dSsxXaC59JGoqChyc3ORm5vL8VpHNb3GxMTA0tISFhYWxJNGGehHUlIS58+fx9mzZ9kJjatWrcKiRYv4vlhLArpKyQKAo6MjnJycICwsDEdHx3aPJbWA2bt3b7x+/ZorMe/x48fo27cvEc3WdO/evc20zc+fPxM1l5SVlbVZCnDu3LnYt28fMd3OCEVR8PPzw5EjR1BfX48LFy4gICAA3bp1w65du4gaAfr3748TJ07gxo0b7PuXjIwMlJSUiP7di4uL4+zZszh16hS7fPDSpUuxaNEi4ilrixcvxtq1a6GtrQ0pKSmu+zSpjRKSkpIoKCiAhIQEpKWl2SaWpqYm1NTUENFsQUBAgJ3CKC0tjYKCAigpKWH69Onw9vYmqu3j44N58+bB1taW3Xbx4kU4Oztj9+7dOHToEBFdOj/vAwcO4MSJE7C3t8fkyZPR1NSEjIwMhISEYNCgQVi7di0RXWtra9TV1cHDwwOfP38G0PwdYmBgAGtra1y9ehWfPn2Cu7s7z7U9PDwgIyMDMzMzdtvvv/8OR0dH7N69m+imhS1btmDTpk3Yv38/hgwZAgcHB+Tk5MDc3Bzr168npksXX37319fX4/nz5ygoKCBq4gGazc10jG3pSpoCgKqqKpibm/M8efJ78Pb2hpSUFIYPH47z58+joaEBaWlp+O233xAYGIi4uDieaZE07/4TFBQUEBsbi6ioKPz555+gKAqysrLYvn07Jk6cSEw3KCgIb968+eoYgPRGszdv3iAhIQFFRUXYtm0bbt++DVlZWY50347E1zb5sVgsuLm50XBG5OnVqxcaGhoANI/Fnjx5Ag0NDYwYMQIlJSVEtc3NzeHk5AQzMzMMHTqU6z5OMt2Wgf9UVVWhuLgYtbW1XK+1mPMyMjI6jC6d2hYWFgCAXbt2cb1GctMCP3VbbwZv/XNlZSUyMjIgJiaGSZMm8UzvR9DujH2mU7sz9vmfoqenR7yqBqNNvy6d2p2xzwwMDAz/C4wJk4GBgaEdxowZg7///psWE+bFixdha2uLsLAwSElJYe3atZCUlERSUhKqqqqwZs0aIrp9+/bF8ePHcf36dTx+/Ji9mKGsrEx8J3Jb6X0dnfr6eixevJgxYHYihIWFsWLFClRWVkJQUJCdKNcR0NPTo0375cuXaGpqYv9MB4sWLYKHhwc8PDzAYrFQU1ODtLQ0uLm5YcGCBUS1q6qqEBoaivz8fDQ2NgJoNuzV19fj8ePHyMrKIqatpKSEc+fOYcOGDRztf/75JxQUFIjpdkaOHDmClJQUuLi4sBdSNDQ04OrqClFRUdjZ2RHVFxAQgLKyMpSVlYnqfEl2djYkJSWxatUqAM0mrkePHhFLDGkhLCwMABAVFcX1Gsm0aj09PWzduhVeXl5QVVWFgYEBBg8ejPT0dIwaNYqIZgtycnK4ePEijI2NMWzYMGRlZcHIyAhlZWVEdQHgwYMH2L17N8eYSFBQEOvWrSP6/ULn5x0fHw8XFxdoaWmx28aMGYP+/ftj3759xEyYXbp0gb29PaytrVFYWAgBAQFIS0uzzRYaGhrEUk/v3LmDxMREiImJsdv69+8POzs7Ys83LRgaGkJQUJD9fTVq1CicPHmSWMoq3Xxt00lQUBAqKiqIaq9ZswZWVlZYs2ZNm0aejpD49CWzZs3CzZs3sXTpUmIaX+Pu3btITEyEqKgorl+/DlVVVQwaNAhLly5FTEwMT7WmTp3aZvu7d+8gICDAtzL0bm5uMDIyQkBAAF/0WmgrlZ1fFBcXY/ny5RAWFsbr169hY2OD8+fPY9u2bYiMjISioiLPtHx8fGBhYYG+ffuitLQUEhIStGy2a+s+1rVrV0ycOJEWwzM/mDx5MsLCwuDs7Aw5OTkkJCRg3bp1yMzMRK9evYhq+/r6Amg2ofE73ZaBvyQnJ8PFxQV1dXWgKIrjNZK/a7p06db+448/iL33j6QbEhKCw4cPIyEhAVJSUrh79y7Mzc3ZG9umT5+O0NBQIht16NLujH2mU7uz9fnNmze4e/cuJk6ciEGDBiEtLQ1RUVF4/fo1ZGRksGHDBowePZp9/I4dOxhtAigqKiIlJYWrAhNpXTq1O2OfGRgYGHgJY8JkYGBgaAc6S/Hs378fZmZmmDFjBsLDwzF48GCcPXsW58+fR3BwMJFFyk+fPqF79+7o0qULVFVVoaqqisePH2PIkCHEDJitJ/RLS0vbPbYj7rrX1tZGQkICtmzZQvepMPCJ2NhYhIaGshe/xcTEYGZmRjyRqKMzfvx49kS6t7c3xMXF0aVLF76eg42NDcrKythplLq6uqAoCrNnz4aNjQ1R7V27diE9PR3Kyso4d+4ctLS0UFhYiLy8POJl2RUUFLB//348ePAAU6ZMQdeuXZGTk4MzZ85AV1cXwcHB7GM7SqJxRUUFAgICkJWVhfr6eq5FHFKLHfHx8XB2dsbcuXPZ6T8LFiyAkJAQPDw8eG7CVFdXx/HjxyEiIsJVfvRLSPX51KlT2LZtG3799Ve2+fP169cwMTFBYGAg0fLYjx49Ivbe7bF27VoICgqCxWJBXl4eGzduRGhoKCQkJODj40NU29zcHBs3boSQkBC0tLQQFBSEdevWIT8/n6flbNtCWFgYz58/55poLSsrI5qoR+fnXVFRgfHjx3O1T5gwAa9evSKq/fHjR5w6dQr5+fkQFBTEyJEjsWDBAuLJAoKCgnj79i1XUuGnT5+I6rawevVqdO3aFa6urrCxsemwBsz20NXVxZIlS+Dq6kpMY+/evQDQZlJdR0l8+pKpU6fCw8MD169fb9MASnIM1KVLFwgJCaGxsRE3b96Ek5MTAKCmpoZ4ImlERAQOHz6Mv//+GwDw008/wdzcHMuXLyeqm5ycDBMTE6IabaGrq8t3zRa8vLygoaEBd3d3tuEyICAADg4O8Pf3x9GjR3mmdfToURgYGKBv375QV1dHeno6+vfvz7P3/15yc3NhZGTEVWmgI9NSnebYsWNYtWoVQkNDMXXqVHz69IkjRZoEP0rS7Y8IXRU/SBEYGAhtbW0YGxujW7duHV6Xbm2SlUl+FN34+HgcOHAAxsbG7DALR0dH9OzZE/Hx8RAWFoaVlRUOHDgAa2vrDqHdGftMp3Zn6/Pdu3dhamqKT58+QVhYGE5OTnBycsLMmTMxZ84cZGdnY8WKFYiJieH5BvjOqN167vpL6urqcPjwYXaVK14/19Gl3Rn7zMDAwMAvWNSXK4YMDAwMDGwiIiKQlpZGSykeeXl5nD9/HkOGDIGBgQHk5OTg5OSE0tJSaGpqIjs7m6d6ycnJ2L17NyIiIjgWg83MzHD//n24ublh/vz5PNUEmhOX0tPTISoq+tVSUx151/3r16+xePFi9OzZEz/99BNX/5lJ8I5FYmIidu3aBX19fY6yo3FxcXB2diaanKOgoIBTp05xmVs6CvLy8rhw4QIkJCQwevRo2hYKgeaUmocPH6KpqQmysrKQkZFh38dIMW3aNPj4+EBVVRULFy6Er68v5OTksGPHDtTW1hI1EqmpqX3XcSwWi4hRj45r29LSEpmZmdDR0Wkz8YnUBNGECRNw9uxZ/PTTTxz9fvHiBRYsWICcnBye6gUHB8PMzAw9evTAvn372r2GSfV54cKFWL16NVavXs3RHhsbi4SEBKSkpBDR/RalpaUdcnMI0JxIKSAgADk5OWRkZODQoUOQkJDApk2b0K9fP2K67u7uSEtLg6urK+Tl5cFisZCTk4Ndu3ZhypQpRA1jdKGtrY2VK1eyU15b+O233xATE4MLFy4Q0X316hX09fVRUVGBYcOGobGxEcXFxRAVFcVvv/0GcXFxIroAYG9vj8ePHyMgIABSUlIAgBcvXmDLli0YMmQI/Pz8eKr3NQP569evISAgwJHISVdKEb+5cuUKtm7dSqzUJ4BvlswlZQqgSxdofzxEagzUwtq1azFo0CCIiYkhMjIS165dQ319PXbs2IEuXbqwk515zcGDB7F//34YGBhg4sSJoCgKWVlZOHbsGBwdHbFixQoiugDw66+/YsCAAdi4cSNx87ijoyOcnJwgLCwMR0fHrx7HYrHg6elJ7DymT5+Oo0ePQkZGhmMcWFhYiOXLl/M0+X7u3LkYOnQoFBQUEBwcDFNT069uUCa5MDpp0iSkpKR02NTLr/H582d8/PgR/fv3R0VFBU6fPg1xcXFoamry7Rzq6uqYii2tmDJlCpKSkmiZT/laItS/QUFBASdPnoS0tDTP3vNH1qVDm64NjXTpLl26FHp6euzn9uzsbCxfvhx2dnbsdP8rV67Ay8uL5884dGl3xj7Tqd3Z+qyvr49Ro0bB1tYWISEhiImJwbp16zg2+Xt6eiI3Nxe//fYbTzQ7s7aKigrKy8shJiaGrl27crxWVlaGAQMGQEBAgMhzHV3anbHPDAwMDPyCScJkYGBgaAc6S/H06dMHHz58QHV1Ne7duwdTU1MAwPPnz3m+AH7jxg1s27YNenp6kJCQ4HjN2dkZ4eHhsLOzw4ABAzB58mSearfe1dQZDYfbt28H0Gys6dGjB81nw0CayMhIODo6cpiJ5s6dCykpKcTExPDMhJmcnMzV1tTUhIsXL3IZE0mV0+U3gwYNwvbt26GgoACKohAREcH3hUJ1dXWcOHECUlJSbGMJ8H9m61u3bhHRBZqTjmRlZQEAI0aMwKNHjyAnJwd9fX2sW7eOmC4AXL58mf1zZWUlMjIyICYmhkmTJvFcy9DQkKuttrYWdnZ2XGkWJL9T0tPTERISgpkzZxLTaIshQ4YgOzubayE6LS2NyIJg678VuspvvnjxAioqKlzts2bNIp5S+PLlS3h7eyM/Px+NjY0AmseAdXV1qKysRF5eHjHttLQ0FBQUoLa2lus10rvAx44dC6C5tKycnBxCQ0OJ6rXw66+/4sWLFzA1NWWPuymKwrx587B161ai2nR93iYmJnB2dsbLly+hqKgIFouFzMxMxMbGEk1J9/LygoSEBBITE9njgvLyclhbW2PPnj08N0K2xt7eHqamptDU1ESfPn0AAO/fv8fYsWPh4ODAcz1dXd0Ol171vbRlFvvw4QPS09OJG3l+xMSnz58/E9VuPR7iNzt27ICtrS1evHiBbdu2oX///nBzc8OTJ08QERFBTDc2NhY7d+7keJ7Q0NDAiBEjcPDgQaImzNLSUpw9exYxMTEQFRXlGgfycrHu5cuXaGpqYv9MF42NjezzaE11dTXPK5c4OzvD398fJ0+eBIvFwrlz59qsMsBisYh+T86ePRtHjx7li9n2R6J79+7o3r07GhoaUFZWBk1NTaIbJFpz7NgxhIeHo6ysDBcuXEBERATb8NxRqaqqQnFxcZvjwClTpgAA0Y0L34JEZaJ58+YhLS2N72ZIunTp0NbV1WWHOfBzPEqXbmFhIWbMmMH+982bN8FisaCqqspuk5GR+WYVrP+SdmfsM53ana3Pubm52L17N4SFhbF+/XpERUVxPcOtWrWKyLx+Z9ROSUnBjh07UFxcjD179nCUO1dQUMDRo0eJbcSgS7sz9pmBgYGBXzAmTAYGBoZ2oNMUqKqqCmdnZwgLC0NYWBgzZ87EX3/9hZ07d2L27Nk81QoPD4e+vj62bdvG9ZqUlBTc3d1BURTCwsJ4vohz8uRJCAgIYNKkSZg6dSpP3/u/wO3btxEdHc3z0g0MPyalpaXscrqtUVFRgbe3N890vmZi+NKwxGKxOowJk66FwnPnzuH69esAmtOXdu3axbUIXFJSQnziW0JCAiUlJZCQkIC0tDS7jHKPHj1QVVVFRDMkJASHDx9GQkICpKSkcPfuXZibm6OmpgZAc1pPaGgoT8tgtmWuoMPo0bNnT65NC/zAzMwMrq6ueP36NSiKwo0bNxAXF4cjR460m8zEC75WKobFYqFr164QFxfHrFmzeL5RREJCArdu3eKafLtz5w4GDBjAU60vcXd3R1FREebPn4/IyEiYmpqiqKgIFy9ebLPULS91jx49CjExMa4EItJmB4C+0rI9evTAgQMH8OzZM3aJ7BEjRhBfKKXz89bR0cG7d+8QERGByMhIAICoqCg2bdoEfX19Yrrp6emIiori2JghJiYGe3t7mJubE9MFgP79++PEiRO4ceMGCgoKICgoCBkZGSgpKRH5rqTLQP4j0JZZTEhICGZmZkTKONOVvNSaqqoqhIaGcpnn6+vr8fjxY54mBX4vdXV1yM7O5vlmxtZISUkhKSmJo23Dhg3Ytm0bEfNOC+/fv8eECRO42idPntxmKXpeMnPmTL5thjly5EibP39JeXk50fNQVlZGaGgoe7MwALx9+xZ79uzB9OnTeaqloqLC3gQjJyeHEydOsMtv8hN+mm3pJjk5GYcPH0ZwcDAGDx6MwsJCmJub49WrV2CxWNDV1cWuXbuI/k2fPn0afn5+MDIyYs/9jRgxAr6+vujWrRvxMQIdJCcnw8XFBXV1dfiyYBw/KvLQZQDdsmULtLS0kJqaCklJSa7v7N27d/Nck05dOrTp2tBI50bK1p9pVlYW+vfvj5EjR7LbampqiAUQ0KXdGftMp3Zn6rOwsDD+/vtvSEpKok+fPrC1tUWvXr04jnnx4gWR8Vln1O7fvz9CQkIQHx8PY2NjmJmZEQ81oFu7M/aZgYGBgV8wJkwGBgaGdqDTFLhjxw4EBgbixYsXCA0NhZCQELKysiAvLw97e3ueauXl5X0zeWbVqlVEBsL37t1DcnIypKSksGzZMujo6NAyuU8XYmJiXA+SDB2XwYMHIzc3F0OHDuVoz87O5iiH+W9pMeB1JuhaKFRQUEBcXBx7waa0tJSjjAaLxULPnj15arJtC01NTWzduhU+Pj6YPn06bGxsMHHiRFy6dIkjlZNXxMfH48CBAzA2NmZ/zo6OjujZsyfi4+MhLCwMKysrHDhwANbW1jzTJbko80/Q0dFBZGQk8YXQL1myZAkaGhoQGhqKz58/w9nZGaKiorC1teUqZ8xrMjIykJGRga5du2LYsGEAgOLiYnz+/BkSEhJ49+4dunXrhsOHD3NMRP9b1qxZAw8PD7x48QITJkxgl6iOiYmBpaUlz3TaIjMzE6GhoZgyZQquXbsGDQ0NyMvLIyAgAGlpacRMiadPn4arqyvRBLGv8bXSsp6enqAoii/nJC0tDWlpaVRWVuL27dsQFBQkWoaUzs/71KlT0NXVhbGxMSorK0FRFF++uwQEBNo0yHfr1g11dXV80VdWVoaysjLq6+vx6NEjfPz4kfiYuK2k8NZ0lI0pLbRnFiMBXclLrdm1axfS09OhrKyMc+fOQUtLC4WFhcjLy8PmzZuJaufl5WH79u3Iz89vM62QtJHn06dPKCgoQH19PZeRqMXIw2vmzZuHI0eOwNnZmaP9zJkzHMlAJKArlW/06NFIT0/nqi7w8uVLLFq0CHfv3iWm7eDgAENDQ8yYMQO1tbVYv349SkpK0K9fP6LPGi3PltXV1Xj69Cm6du0KSUlJviRT8tNsSycXLlyAo6MjFixYwL6POjg4oLq6GgcOHECvXr3g5OSEw4cPEzHRt3Do0CE4OTlBV1cXhw4dAtBciaB3794IDQ3tkCbMwMBAaGtrw9jYmMvkSxo6DaC7d+9GTU0N6urqUFJSQkznR9GlS7u+vh5//vknpk+fzjZnxcXF4erVqxATE4OJiQlGjBjRIXRHjRqFjIwMSElJ4f3797h16xZ+/vlnjmPOnz/PruDSEbQ7Y5/p1O5sff7555+xfft27Ny5E1OnToWFhQX7terqaqSmpsLf3x/Lli3jmWZn1waAFStWYOrUqbCzs8O1a9fg5eVFROdH0u6MfWZgYGAgDWPCZGBgYGiHb6VKkTSDdO/encsY+f/YO/O4GNf//7+mjUgoW5wUWXIQZV8jcRClIluRkn0pSimitBelRSVFWUqU0iY64ZDllK06VGQXOSQUmpb5/dGj+TUmju/n3NfcTl3Px8PjYa65H/O67mnmnuu+rtf1epPawcrlcv8xqax9+/ZESrilpaUhNzcXp06dQlhYGHx9fTF58mTMnTsXEydObPblAzdv3gwXFxfs2LEDysrKIjXzUETPggUL4OTkhPLycoGyo/7+/jAxMWG7e/+af0o9agzJ1JKGhUIul4vnz5+jZ8+e4PF4AuZIplBQUOCnJpuYmCAoKIhfXlWUrF+/Hl++fMHLly8xe/ZszJgxA5aWlmjXrh38/f0Z1ztx4gTs7OywaNEiAPVG4sePH8Pa2po/mb969Wp4eHgwasL8WXjz5g3S0tJw/vx59OzZUyg9j1SS9qdPnzB//nzMnz9fpIYtABg8eDDq6uqwd+9evvGgvLwcNjY2UFNTw6pVq+Do6AgfHx+EhoYypmtiYgIul4vIyEj+63bp0gVWVlZEkwKB+lL3Dea/3r17o7CwEGpqapgzZw7Ra7aEhARrG4HYLC1bVFSE9evXw8XFBaqqqtDT08Pff/8NKSkp7N+/n/GUrwbYfL9dXFwwcOBAtG/fXsjQQxINDQ3s27cPXl5e/N/G6upqBAcHE09nf/nyJRwcHGBpaYn+/fvD0NAQDx48QPv27XHo0CGBMlRM861NZ61atUK3bt2anQkTqL+OJSUl4f79+5CSkkK/fv0wY8YMSEgwPx3IZvJSA5cvX4aXlxc0NTVRUFAAc3NzqKqqYvv27Xjw4AFRbXd3d0hISGDHjh1wcXGBnZ0dnj59iqNHjwql0TPNhQsXYGNjg4qKCpEaeTp06IBjx47h5s2bGDFiBCQkJJCfn4+cnBxMmTJFYD6FqbmTQ4cO4fTp05CSksKMGTOwdOlSRl73e5w8eRKnT58GUJ+sunbtWqH7itevXxO/B+jatSsSEhKQnJyMe/fuoa6uDgsXLoSenh5xQ6SnpyeOHDmCmpoa8Hg8SElJYf78+bC3tyc6Z9OcS2A35vDhw1i3bh1/g1FRURHy8vKwZs0aTJw4EQBgaWmJoKAgoibMR48eNZnaO3z4cLx69YqYLpu8f/8eZmZmrJTHZtMAmpmZiaCgIOKG+Z9Flw3tt2/fwsTEBI8ePUJycjJUVFSwb98+BAQEQE1NDVwuF0ZGRoiJiWF0EyNbuosXL4ajoyMKCwtx69YtcLlc/j3z69evkZSUhPDwcLi6ujKmybZ2SzxnNrVb2jlbW1vD3t4eiYmJQvMVWVlZ2LZtG+bNm4c1a9YwptnStRvo1asXjh8/jr1790JfXx/V1dXEtH4W7ZZ4zhQKhUISasKkUCiU7/B1Cbeamho8e/YMlZWVmDlzJuN6gYGBMDc3h7S09DfLfjbA5GR0r169cOvWLaF0vsbcvHmTWMlXNTU1qKmpwd7eHufPn0diYiLWrl2LTp06QV9fH4aGhkQTkNjEz88PJSUlmDVrVpPPk05MoYiWJUuW4MWLF3Bzc0NtbS14PB4kJCRgZGREdPJAVLCVetQUPj4+OHz4MKqrq5Geng5fX1+0atUKzs7ORMyYgGDiVE1NDQoLCyEvL49u3boR0WuMlJQUHBwc+I937tzJN2GSMHcXFxdj7Nix/MfXrl0Dh8MRWNDo06cPSkpKGNf+GRAXF//mdZskY8eOxW+//QZ9fX1ihrRvERcXh4iICAGjWIcOHbB582YsW7YM69evh7m5ORYsWMC4trm5OczNzfHu3TtISkqKJHkJABQVFVFUVAQFBQUoKyvzf5Pr6upQWVlJTNfY2BjBwcFwcXERMviShs3Ssp6enlBSUkLv3r2RlpaG6upqXLx4EceOHYOfnx9iYmKI6LL5fisrK6OwsJBIAs73sLa2xoIFCzB16lQMGjQIHA4Hubm5qKioIJ6e6O7ujo8fP0JOTg7p6el48eIFjh07hpMnT8Lb25ufvEWCr5PCa2pq8OTJEzg6OmLx4sXEdNni2bNnWLRoESoqKtCrVy/U1tYiKioK+/btQ1hYGOP3V/+UNNoYUobXyspKfgKNiooKCgoKoKqqCmNjY+LlzfLz8xEZGQk1NTXExcWhX79+WLRoEbp164bY2FjMmDGDmLaPjw+GDx+OjRs3ol27dsR0vubu3bsYOnQoAMHv1/Dhw/H+/Xu8f/+eUb39+/fDz88PY8aMgbi4OLy8vPD69WvY2NgwqvM12traAqXsu3XrJrSJtV+/fiIxcktLS0NXVxeDBw+GlJQUFBUVid3bNBAaGoq4uDjY2tpi+PDhqKurQ3Z2NoKCgtC1a1csX76cUb0fnRfjcDjEU9FFRUFBAZycnPiPr169Cg6Hg8mTJ/PbBgwYgKdPnxLtR6dOnfDw4UMoKioKtN+8eRNdunQhqs0W06ZNw8WLF1kxYbJpAG3btu1354Cbmy4b2kFBQZCSkkJqaip69eqFyspK7N+/H6NGjcKhQ4cAAB4eHggICGB04yxburNnz0ZVVRWio6MhJiYGPz8/DBo0CED973dMTAwsLCygp6fHmCbb2i3xnNnUbmnnLC0tDV9fX9TW1go9N378eFy9ehXt27cXaL98+TJGjBjxr439LVW7MRISEti8eTMmTJiAU6dONVm1g4Qum9ot8ZwpFAqFFBze11ukKRQKhfJdeDweduzYgY4dO8LKyorR19bS0kJcXBw6duwILS2tbx7H4XAYTZGLjIxEVFQUoqOjm5xYff36NRYsWABDQ0ORTXKXlZUhJSUFKSkpyMvLw6hRo4guyrLFqVOnvvu8vr6+iHpCESUNpdyA+nQ1URmKWgpRUVEICwuDlZUVnJ2dkZSUhLy8PDg5OWHevHmwtrZmVC8hIQFRUVEIDAxE9+7dUVxcDAsLC7x8+RIcDgf6+voiKVv97Nkz/PXXX02mFjO9KKyuro6EhAR+qfOVK1ciPz8fWVlZ/GMKCgqwZMkS/Pnnn4xqt2ROnz6NpKQkXL16FV26dIGenh7mzJlDpOT814wYMQLh4eFQU1MTaL9z5w5MTU1x69YtPH36FPr6+gJGhf+F/4t5t3v37v9K63scOHAAYWFh8PDwgLy8PExMTLB+/XpkZWXh8+fPxEyBjx8/xvz58/Hp0yd07txZyNxOMknY1tYWbdu2FSotGxgYiKKiIiLJug1oaGjgxIkTUFFRwfr169GmTRt4enri2bNnmD17Nm7fvk1El83328HBAadOnYKqqiqUlZWFJpNJpu43mB/v378PHo+Hfv36YcGCBULGC6YZOXIkIiMjMWDAAGzevBk1NTXYu3cvHj16BAMDA6KlfL9FXl4erK2tkZ6eLnJtkpiZmUFKSgre3t58Y15ZWRmsrKwgLS2NkJAQRvVUVVV/6DiSyYxTp06Fu7s7hg8fDl9fX1RVVfETKXV1dYldRwBgyJAhOHPmDBQUFGBnZwc1NTUsWrQIz549g5GREa5evUpMe/DgwTh16hT69OlDTONnYObMmVi8eDHfNB0fHw8PDw+RjjW3bt0KBwcHVu7famtr4enpiZiYGH5CTOvWrbF8+XKsWbOG2GY4LS0tbN68GTo6OgLtSUlJCAgIwNmzZxnXY2NejE2GDBmC5ORk/m/whg0bcPXqVfz555/8v2txcTHmz5+PnJwcYv0ICwtDdHQ07OzsYGtrCz8/P7x48QJ79+6FqakpVq9eTUybLd68eQMdHR306dMHioqKQt8jkmMxW1tb/PrrryJJ9P2aw4cPIycnB66uriK9nrGly4a2lpYWXFxc+JtXMzIysG7dOuzZs4cf7HD79m2sXr2a0TECW7rfo7S0FFJSUujYsaNI9H4G7ZZ4zmxqt8RzbgoNDQ0kJiYSv6en2uzqsqndEs+ZQqFQ/hdoEiaFQqH8H+FwODAzM8PixYsZN2FmZmY2+f+vqaurY1TX2NgYZ8+ehY6ODubOnYuhQ4dCVlYW5eXluH37NuLj46GkpARzc3NGdb+HnJwcdHV1IS0tDS6Xi2vXrolMW5RQk2XL4/3793jy5AmqqqoACKadjhgxgq1uEaGgoABFRUX8axaPxwOXy8WdO3fg5uZGTPf48eNwdHTE1KlT+cltM2fOhJSUFFxdXRk1Yaanp2Pr1q2YOXMmPxHHzs4OFRUVCA0NRdu2beHg4ICoqCiipePi4+Oxbdu2Jn8fOBwO4ybM/v37Izs7G0pKSvjw4QOuX7+O3377TeCYtLQ0fhpVcyAhIYH/OfqntC9SSUi6urrQ1dXF27dvkZSUhKSkJISEhGDo0KEwMDDAvHnziOgC9TvOnZycsGfPHr7p89GjR3BxccH48eNRW1uL6Oho9O/f/19raWlp/aORgMfjETXyAMDy5cshISEBDocDNTU1rFu3DsHBwVBQUCBaWtbOzg6ysrKYO3cupKWliek0BRulZRsQExODlJQUamtrce3aNX66b2VlpVDiGJOw+X4/ffoUw4YNAwD8/fffItXu0aMH8fS4pqiuruYnV1y9ehUbN24EUH9/Q6JE9o/Qpk0bvHz5khVtkty4cQNxcXECyYhycnKws7PDwoULGdf7OmmUDaZPn44tW7bAy8sLo0ePhqWlJYYOHYqMjAziGxZ69+6N7Oxs6OrqQklJCXl5eQCAjx8/gsvlEtVWVlZGWVkZUY1vUVJSAllZWcjIyODatWs4e/YsNDQ0iCSGv3jxQiAZUEdHB/b29njz5g06derEuF5TfOu3j8vlIjc3t8lSzkzh7++P1NRUbN++HWpqaqirq0NOTg4CAwNRW1uLDRs2ENF9+/YtBg8eLNQ+ZMgQItfOH50Xa0706tUL+fn5UFRUxJcvX3DlyhWMHTtWYDx8/vx54omJFhYW+PjxI2xsbFBVVYWVK1dCQkICCxYswMqVK4lqs4W7uzsqKyvB5XLx4sULkWrb2NhAR0cHZ8+eFbkBNDMzEzk5ORg9ejTk5eWFxmCkDM5s6bKh/fr1a/Tq1Yv/OCcnBxwOR6CiRZcuXVBRUdEsdL9H165dRab1s2i3xHNmU7slnnNTsJm51RK16Tm3HG0KhUL5v0JNmBQKhfI/8ObNG3z69ImoxpQpUxAXF4cOHToItJeWlkJXVxfXr19nTEtcXBwHDx6Ev78/Tpw4gYMHD/Kf69SpExYtWoTVq1cTXQBvgMvl4vfff0dSUhIuXboEeXl56OvrY+/evcS12eLixYsIDw/Hw4cPcfz4ccTFxaFnz54iKWdGES0JCQnYsWMHuFyu0I0jaTORqImKiuIbLTkcDv98ORwO0cVJAHj+/DkGDBgg1N6/f3+8efOGUa3Dhw9j3bp1/JTgoqIi5OXlYc2aNZg4cSIAwNLSEkFBQURNmPv27cP8+fNhZWUFWVlZYjoNLF68GI6OjigsLMStW7fA5XJhYmICoH7SPykpCeHh4XB1dSXeF1FhZ2eHCRMmQF5eHnZ2dt88joTp9Wvk5eVhamqKxYsX4/jx4/D19YWjoyNRE+b27duxcuVKTJ8+HbKysuDxePj48SOGDBkCR0dHXLp0CTExMQgNDf3XWlFRUQz0mBlMTU35/7ewsICFhQVxzbt37yI2NvaHU+WY1hZladnGDB06FCEhIejUqRM+f/6MiRMnorS0FLt3726yRDpTsPl+ky79/S3Ky8uxf/9+3L9/n78ppDEkv4O//vorTpw4gS5duuDdu3fQ1NQEl8tFWFgY8b9Bdna2wOOG69ihQ4dY+fuTplu3bnj9+rVQOuL79+9/iqQWEqxfvx5fvnzBy5cvMXv2bMyYMQOWlpZo164d0SRfoH5jY4N5fNq0adDT00Pr1q1x8+ZN/nWVFDY2Nti1axesrKzQu3dvSElJCTxPKjX63LlzsLKyQkhICJSUlLB8+XIoKioiPj4e79+/5ydWMkVVVZVAYnCrVq0gLS2Nz58/M6rzPe7duwcHBwcUFhY2ufmJ5P3ciRMn4O7uDk1NTX7bgAED0KVLF+zatYuYCVNZWRlZWVlCZXwvX75MNJG8JWFoaAhXV1eUlpbi2rVrqKio4Jvlq6ur8fvvvyM4OBiWlpbE+7Jp0yasXr0aDx48AI/Ha/aVOzIzMxEUFCTwvRIVbBpAhw0bxt8I1BJ02dCWlZXFu3fvoKCgAAC4du0a+vbtCzk5Of4xjx49Enj8X9alUCgUCoVCoVAo9VATJoVCoXyHwMBAobaPHz8iJSUF48aNY1wvNTUVly5dAlCf8uDs7CxUlvDFixdEykxJSUnB2toalpaWePbsGd6/fw85Obkmd2MzDY/Hw9WrV5GUlIRz587hy5cv0NLSQmBgICZMmAAxMTGi+mySlZWFdevWQUdHB7dv30ZdXR1qa2thb2+P2tpaGBoast1FCoP4+flBT08PpqamQt9tJvmnlL7GkDKLHTlyBCtXrsTatWsxefJkxMfHo7y8HJs3b8aUKVOIaDbQo0cP5Obm4pdffhFov3jxIuMlKwoKCuDk5MR/fPXqVXA4HIGUngEDBuDp06eM6n5NaWkpzMzMRGLABIDZs2ejqqoK0dHREBMTg5+fHwYNGgQA2L9/P2JiYmBhYQE9PT1GdZcsWfLDxzJtImpsSGM77SsnJwenT59Geno6amtrMX36dBgYGBDVlJOTQ2xsLK5fv4579+5BXFwcqqqqGDlyJID6NKQ//vhDIHHtf6XhNb/Hq1evEBsb+0PH/q80NQ4E6o22kpKS6NatGyZOnCi0YebfoqioSDw17VuwZQoE6o2+VlZWePbsGezt7SEnJ4ddu3bh4cOH2LdvHzFdNt9vAKioqEBqaiqKioogJiaGgQMHYvr06UTHCTY2NsjNzcW4ceNElh7XgK2tLVatWoV3797BwsIC3bp1w86dO5GRkYHw8HCi2iYmJgIbQxpQVFSEj48PUW1RUVJSwv+/iYkJtm3bhu3bt2PYsGEQExPDX3/9hR07dvATSJlkwIABuHz5MuTl5aGqqvrde0hSRjUpKSm+ERIAdu7cyTdhiouLE9FswNDQEO3bt0eHDh2goqICT09PhIaGQkFBAdu3byeqvWLFCgAQKklNOjV63759MDc3x9ixYxEWFobu3bsjJSUFaWlpCAwMZNyE+TPg5uYGCQkJ7NixAy4uLvxy90ePHiWakg3Ub1j9+v4GAFRUVFBZWUlMd9myZXB0dMTz58+hoaEBDoeDnJwcHD16lEii8j9dPxrTXDYxmpiYoKysDCEhIRATE4OdnR3GjBkDoN6od+zYMejp6RH5Trm7u2Pjxo1o06YNv01aWrrJ9NPmSNu2bYUMxqKCTQPounXrRK7Jpi4b2mPGjMHhw4fh7u6O69evo6CgQKAPdXV1CAsLY3yTMlu6FAqFQqFQKBQKpR5qwqRQKJTvEB8fL9QmKSmJCRMmYNOmTYzrqaurIyYmhr8wWFJSAklJSf7zHA4Hbdq0gaenJ+PaDUhISAiULSGNu7s7UlJS8PbtW6ioqGDt2rXQ09NrMTtyAwICsHnzZpiamiI9PR0A+El2Bw8epCbMZsb79+9hZmZGvIzY91L6GkMysa+kpARz586FlJQUVFVVkZeXB21tbdjZ2cHDw0MgXY5pzM3N4eTkhNLSUr7JOyYmBocPHxYopcsE1dXVAmlDN27cgIyMDN+QCAA1NTUC13IS/Prrr3j48CHjJtPvMXfuXMydO1eo3cLCAmvXriWSstWjRw/GX/PfUFJSguLiYowYMQKVlZWQl5cnqrd7926kpKTg5cuXGDFiBLZu3Yrp06eLJKkaqL9mNKTXSUpKCpi3RJWq9scffyAmJgYXL14Ej8cjlvoE1KfmZWdnQ1JSkj82evLkCb58+QIFBQWUl5ejVatWiIqKQt++fRnTdXR0xM6dO7Fx40b06tVLqFQe6dSpT58+4fTp0ygsLISEhAT69u2LmTNnEk9BUlJSEhp76+np4dOnT1i4cCFu3rxJRJfN97u4uBhLly5FZWUllJWVUVdXh9jYWOzbtw+RkZHo1q0bEd2cnByEhoYSNTF/CzU1NWRlZeHjx4/8jQNLly7Fxo0biV9HmiozKSkpiS5duhDVFSVaWlpCJrzVq1cLtW3dupXxMaCbmxvfiO/m5kZ8I9+3uHnzJpSVlSEnJ4eEhASkpaVBQ0MDK1asIN4nbW1t/v91dHSgo6NDVK8BthKki4uLERgYCDExMVy+fBmampoQExODuro6kVQ3DofD2ueqgfz8fERGRkJNTQ1xcXHo168fFi1ahG7duiE2NhYzZswgpj1nzhwEBQXBw8ND4P4jPDycSPn3xrrl5eU4cOAA3ywvLy+PDRs2wNjYmHE9Nq8fbLJx48YmDfLz58/H/Pnz0b9/fyK6UVFRWLFihYAJ09zcHO7u7s3q9/FbrFy5En5+fnB1dRV54qeoDaCBgYEwNzeHtLT0NzebAfXX2oZKH/9lXba1169fj4ULF2LkyJGorKzEL7/8gqVLlwIAzpw5g+DgYDx//hyxsbHNQpdCoVAoFAqFQqHUQ02YFAqF8h0yMzNFqqegoMBfQDExMUFgYCDat28v0j6ImhMnTmDmzJmYO3cu8TJtPyOFhYVNJmZMmzaNeMk8iuiZNm0aLl68SNyEyXZKH1C/oFBTUwOgvoTdgwcPoK2tDRUVFeKltgwNDVFTU4Pg4GB8+fIFjo6OkJeXh5WVFb+sG1P06tUL+fn5UFRUxJcvX3DlyhWMHTtWYOHw/PnzRP7mjcuqamtrw8HBAevWrYOysrJQ2tOIESMY1/8WXbt2Jfba7u7uxF77/wKXy4WtrS3S0tIgJiaG9PR0eHp64uPHjwgMDGQkDbIp0tLSYGBgAH19fZEbUrlcLqytrXHu3Dn+ZpGG1Fc/Pz+h0qdMUlZWhpMnTyI2NhYvXryAhIQE9PT0YGZmRkwTAAYPHoy6ujrs3buXvzmkvLwcNjY2UFNTw6pVq+Do6AgfHx9GyrA3YGZmhtraWqxcuVKkiWYA8PLlSxgbG+Pt27fo1asXamtrERsbi5CQEBw7doyYKbAxVVVVSElJQUxMDPLy8iAmJoapU6cS02Pz/XZxccGAAQPg4+PDH/OXlZXB2toaLi4u310s/jd07doVbdu2JfLaPwKHwxFIbhbVBrCG6yaXy8Xz58/Rs2dPoVTM/zqRkZGsmZf09fX5/yedzvwtYmJi4OTkhIiICMjLy2Pr1q0YM2YMDh48iOrqaqIpWFwuFxEREZgxYwaUlJTg4OCA1NRUaGhowMfHh6jJmA1DNVBf8vTjx4+oqKjA7du3+b/LT58+ZTwlGqi/LhsaGgpUyvjy5QtMTEyExr5Nma6ZoK6uDp07dwZQf+0qKirC8OHDMWXKFEbHAg00ToGvra3FjRs3kJ2djcGDB0NcXBx3797Fq1eviFcaMDU1hampKcrKysDj8YhuPGLr+vGzQsp82UBTv4M3b95EVVUVUd2fhczMTOTk5GD06NGQl5cX2oxD6loCiN4AGh8fj8WLF0NaWrrJ0IEGmDYksqXLtraysjKSk5Nx5swZcDgc6Ojo8OcJGsahnp6eUFFRaRa6FAqFQqFQKBQKpR5qwqRQKJQfpKysDDk5OejUqRM0NDSI67FZDlKUZGVlQVpamu1usEa7du1QWloqtPv9/v37zd6A2xKxsbGBjo4Ozp49C0VFRaFFclEbzEpKSoglfA0fPhwhISFwdHSEqqoqYmNjsWLFCuTk5IjE+NGQGEJ6odDQ0BCurq4oLS3FtWvXUFFRwTd6VldX4/fff0dwcDAsLS0Z126qrOrOnTuFjiNtImKTsrIyPHr0CHV1dQDqFxG5XC7u3LnD+CJKY4KDg1FQUIDIyEisWrUKQP0iub29Pby9veHs7ExENyMjg8jr/gi+vr7Izc3Fvn37MGLECNTW1iI7OxsuLi78VGemyc7ORnR0NM6dO4fq6mqoqKiAw+HgyJEjGDJkCON6XxMXF4eIiAiBdO4OHTpg8+bNWLZsGdavXw9zc3MsWLCAUd2DBw8y+nr/Fzw8PKCgoIATJ07wz/vNmzfYuHEjvL29sXv3bmLaDx8+RExMDBITE/H+/XtwOBwYGhpi1apVTZZfZQo23+/bt28jNjZWYMwnJyeHLVu2YNGiRcR0bW1t4ezsDCsrK/zyyy8ChiaAbPonW2WqgfrfiN27d+Pw4cOorq5Geno6fH190apVKzg7OxNPrRYFo0aNYrsLePDgAQCgT58+AOqTV48cOYK6ujrMmTMHWlpaxLQjIyOxbds2jBkzBnv37kXfvn0RERGBP/74Azt37iRqwvTx8UFiYiImTJiArKwsnDp1Chs2bMD58+fh5eVFdJzP5XJx/PhxFBYWora2VqA9Ly8PZ8+eJaKrqakJR0dHyMjIQEZGBuPGjcOVK1ewc+dOTJo0iXE9NsvYNtC7d29kZ2dDV1cXSkpKyMvLAwB8/PgRXC6Xcb2vN918PW8gagOuKCqWbN26FQ4ODpCRkfluFQMOhwM3Nzfi/aE0b4YNG4Zhw4axoi1qA2jjoIHG/y8rK0N2djY6depE5L1gS5dtbaA+NXjx4sVC7cuXL2/yeD8/PyxbtuxfzwezpUuhUCgUCoVCoVCoCZNCoVCaJCgoCFFRUYiNjYWSkhJu3ryJFStWoKKiAgAwZswYBAcHM17+c8CAAbh8+TLk5eVZXaAUJS3ZgAkAs2fPhqurK1xdXcHhcFBZWYmLFy9i165dmDlzJtvdozCMu7s7KisrweVyiadBNvD8+XN4enoKLMo2GNXKyspw9+5dIrqWlpZYtmwZoqOjsXDhQgQHB2PkyJH4/PkzzM3NGddrnArZFA8fPuT/n8lUSBMTE5SVlSEkJARiYmKws7PDmDFjANT/vY8dOwY9Pb0mJ8D/LSRTOf4LpKSkwN7eHlVVVXwzasPvZo8ePYiaMFNSUrBz504Bs8vIkSOxa9cu2NjYMGrCXLJkCQIDAyErKyuQhtQUJMuRJicnw8XFBZqamvw2bW1tiIuLw8nJiVET5uHDhxETE4Pi4mL88ssvWLZsGXR0dNC/f38MHDhQZAl+NTU1qK6uFmqvqqrCly9fAABSUlKMJ+kdPHgQ1tbWrKSTZGVl4eDBgwImi06dOsHW1hYWFhaM69XU1ODs2bOIiYnhl37X1NTEjBkzsGXLFpiamhI1YALsvt9dunTBq1evhMrZV1RUCCRFkuD+/ftYtmyZQJso0j+/LjNbU1ODx48f49SpU7CzsyOmC9RfWxITE7Fjxw7+dVpbWxtOTk6Ql5eHtbU1UX1R8D3D0tcwbQr8+++/sWbNGuTl5YHD4UBDQwOWlpYwMzND9+7dwePxsHbtWnh5eWH27NmMajfw/PlzvskzKysLEydOBFBvCH3z5g0RzQbOnDmDPXv2YODAgXB2dsbIkSOxatUqjBs3DitWrCCq7ebmhvj4eAwcOBB37tyBuro6njx5grdv38LU1JSY7vbt2+Hn54dnz54hODgYUlJSuHHjBtTU1GBra8u43s9gwjQ2NoaDgwOA+ioHenp6aN26NW7evEmkssfPkgIvSp4/f87fYPX8+XOWe0Np7rB5XWHDAPr1fPetW7dgYWGByspKAMDo0aOJzHezpcu29v+VqKgoGBoaitwMyZYuhUKhUCgUCoXSHKEmTAqFQvmK48ePIzQ0FKampvzkNHt7e7Rp0wbHjx+HjIwM1q9fj9DQUGzcuJFRbTc3N36JkJY42d4SsbS0xKtXr2BoaAigvowfj8fDpEmTYGVlxXLvKEyTmZmJoKAgARMTaVxcXPDo0SPMmDED4eHhMDMzw6NHj3Du3DliaX0A0LdvX2RkZODTp09o27YtTpw4gdOnT0NBQQHTp09nXK9xKuTX5WQBCLQxbS7ZuHFjk78HDWmcpErINVWO+tOnT3j06BHExcXRq1cvtGrVioj2z0BISAhmzZoFCwsLGBkZISIiAq9fv4aTkxPWr19PVLupBGMAUFBQwIcPHxjV6tGjBz+lrnv37qyVma2oqICSkpJQe69evVBWVsaolqurK3r37o3g4GBMnjyZ0df+vzB+/Hg4OTlhz549/HN/9OgRXFxcMH78eNTW1iI6Oprx73hOTg5r311xcfEmFyBbtWpFJOFr0qRJqKiowOjRo+Hu7g5tbW1+OUYbGxvG9ZqCzffb1tYWTk5OsLOzw8iRIyEhIYG8vDw4OTlh6dKlKCkp4R/LZDqlu7s7Ro8ejfnz54t8Q9S3ysyqqqoiMTERurq6xLSPHz8OR0dHTJ06Fbt27QIAzJw5E1JSUnB1dW0WJswfNSw1GA+YxMPDAxISEoiOjoa0tDQCAwNhYWEBfX19/pjTw8MDhw8fJmbClJeXx+vXryEpKYn8/Hz+/VRBQQE6depERLOB8vJyvpk7KysLc+fOBQB07NiRb9wnRUZGBjw8PDBz5kxMmzYNu3btgqKiIqysrJrcTMAUrVu3FjJPkx6DsU2DSaVDhw5QUVGBp6cnQkNDoaCggO3btxPXf/DgAYqKipr8TZ4zZw5xfVHQuCpMS6kQwzZs3V+wRWBgIMzNzfm/Vd+CRInqxojaANrUfPfWrVuJz3ezpcu29v8C05v7fnZdCoXyYyQkJPDvWxvz6dMnxMbG8jddGRgY8OdTqPZ/T5dN7ZZ4zhQKhUISDo+OsCkUCkWAuXPnwsDAgF8CMDc3F0ZGRrC2tuaX7Th//jw8PDyQnp5OrB8/OvhkCi6Xi6tXrwKoT/qUkpJCSkoKDh06xC8dZ2Jiwqgm5f/z5MkT3Lt3D3V1dejXrx+/fB+leTF+/HgcPnwYvXr1Epnm8OHDERwcjBEjRkBfXx9OTk5QU1ODr68vHjx4gKCgIJH1hSSNk0WvXbuGoKAg2NvbQ0NDAxISEsjNzYW7uzssLCyazQJlY6qrq+Hm5oa4uDhUV1eDx+NBWloaS5YsabaG7sGDByMxMRG9e/fG0qVLYW5ujokTJ+Ls2bMICQlBfHw8MW0DAwMsWLAARkZGUFdXx+nTp6GoqIjAwEBkZmYS1WaL+fPnY/Lkyfzy6w3s27cP6enpSExMZEzL19cXiYmJKC0tRd++fTF9+nTMnDkTysrKGDhwIBITE0XyO1lWVoaVK1ciPz8fsrKy4PF4+PjxI4YMGYKAgAD89ddfsLKyQmhoKKPlQN3c3PD69WusXbsWSkpKQmNBkqxevRqtW7eGl5cXvzRzdXU1bGxs8OHDB0RERDCqN2TIEMjLy2PixIkYN24cJk6cyDdEiupvzeb7raqqyv//tzYQkEinHDJkCJKTk6GoqMjYa/5bXrx4AR0dHdy+fZuYxpAhQ5CSkoJffvlF4Nr97NkzzJw5k19WuDlz9+5dREdHIyUlBTdv3mT0tUePHo39+/dDTU0NAPDu3TuMGTMGx48fx5AhQwAAjx8/hoGBAePaDXh7e+Ps2bOQlpZGRUUFzp07h/T0dOzatQtz585lNLX5a2bNmoWNGzeiR48eMDAwQEJCAlRVVXHo0CHExcUhKSmJmPagQYNw9uxZdO/eHevWrcP06dMxa9Ys5OXlwdLSkmh6+l9//YXw8HAUFhZCQkICffr0wdKlS/mfAwpz7N+/H3v27GnyOdIpxj8DNTU1yMrKAlB/vWnOm81EiaqqKmbOnCnwfiYlJUFLS0sofb65bBbX0tJCXFwcOnbsyE9PbgoOh8P49ZNNAyhb891szrP/LHP8P0rj8WlL0KVQKN+mrKyMv5FrypQpOHnyJDp27ChwzN27d7Fp0ybk5uZS7f+oLpvaLfGcKRQKRVTQJEwKhUL5iuLiYowdO5b/+Nq1a+BwOALJdX369BFIpmGKxoPPrVu3om/fvkKDz3v37mHPnj2MmjAfPXoEMzMzvHz5EgD4qRk2Njb8Uqvu7u6oq6vD0qVLGdOl/H+UlJSaTBijNC9WrlwJPz8/uLq6imznXlVVFb+Ua+/evVFYWAg1NTXixupHjx7B2dkZN27caDKBh+lFwsapkGFhYXB1deWXBQfqDbA7duyAnZ1dszRh7tmzB2fOnIG9vT2GDh0KHo+HmzdvIiAgANLS0kLGueZAq1at+CYxZWVl3L9/HxMnTsSgQYPw5MkTotrr16+HpaUlioqKUFtbi1OnTuHhw4c4e/YsfH19iWo3xZ9//oktW7bgwoULxDRWr16NNWvWoKCgABoaGuBwOMjJycG5c+fg4+PDqJaVlRUsLS1x6dIlxMfHIyQkBAEBAVBVVQWPxyOS4NYUcnJyiI2NxfXr13Hv3j2Ii4tDVVWVb7gcMmQI/vjjD36KOVNkZGSgpKTkmwuBJE0W1tbWWLBgAaZOnYpBgwaBw+EgNzcXFRUVRNKosrKykJqairi4OMTExKBNmzbQ0tLCjBkzRJbKxOb7HRUVRey1v8fQoUNRWFj4Uy20pqSkEC+B2KNHD+Tm5gqVuL948eJP9V4wTVVVFVJSUhATE4O8vDyIiYlh2rRpjOu8f/8eXbt25T/u2LEjWrdujQ4dOvDbZGRk8PnzZ8a1G9i8eTO6deuGZ8+eYfHixRAXF8fbt29hZGREPKFx+fLl2LRpE8TExDB69GioqqoiKCgIQUFBcHNzI6rdqVMnvH37Ft27d0fPnj1RVFQEoP5vQLIMe05ODpYtW4Z+/frxE6Jv3ryJRYsWITIyUuRldkXFxYsXER4ejocPH+L48eOIi4tDz549id9jREZGYu3atVi5cqVINww08ObNG/5mr8YwmdTcwLFjx/ibmubPn48ZM2Zg0aJF/M92t27dcOjQISgrKzOuzTZ1dXVITk7m30d//X4zbYQcMWIE/v77b4E2dXV1vHv3Du/evWNU62chMzOzyf+XlZUhOzsbnTp1Inb9io+Px+LFiyEtLf3djXskTJhszXezOc/OpjaFQqH8G/744w/Y2dnxN2Y2pOw3hsfjEam21RK16Tm3jHOmUCgUUUFNmBQKhdIEjRd9b9y4ATk5OfTt25ffVllZSaR0H1uDT09PT/z66684fvw4pKWlsWfPHlhbW2PFihWwtLQEUG9qio+PJ2LC/PTpEw4fPox58+ZBTk6O3+7v7w9xcXGYmZmJvFQiSVRVVX/YWNDc0yxaGpmZmcjJycHo0aMhLy8PCQnBoRiJlBpFRUUUFRVBQUEBysrK/M9UXV0dUSPTzp07UVJSAmtra8YNSv9EaWkpunTpItQuKyuL8vJykfZFVCQmJsLNzU2gdPOAAQPQpUsXuLq6NksTppqaGmJiYmBjY4M+ffrg/PnzMDc3x4MHD/jmTCb59OkT2rRpAwCYPHkyAgICEBoaCnFxcYSHh6Nv377w9fXFb7/9xrj2P1FVVYXS0lKiGpMmTYK/vz/279+PCxcugMfjoV+/ftizZw+mT5/OuB6Hw8HEiRMxceJEvH//HklJSYiPj0ddXR2MjY0xffp0GBsb89PVSMHhcDB69GiMHj1a6LmvN8owBZulXFVUVJCQkIBjx47h/v374PF4mDVrFhYsWEDEpCYjIwMjIyMYGRmhuLgYJ0+eRFJSEpKTk8HhcHDo0CEsX76cqMmCzfe7cYJqWVkZJCQkICsrS1zXyMgIjo6OuHXrFpSVlYWumSSNRFpaWkKpn5WVlfjw4QPx5GZzc3M4OTmhtLQUPB4PV69eRUxMDA4fPoytW7cS1WaDhw8fIiYmBomJiXj//j04HA4MDQ2xatUqISMqE/B4PKGxLYfDgZiYGONa30JMTExok5GoqjnMmTMHqqqqeP78OSZOnAigPrX7wIEDAgYQEmhqamLHjh1wd3eHhoYGXF1dMXXqVKSmpqJbt27EdPfs2YN58+bB0dFRoN3JyQl+fn7NspR0VlYW1q1bx0/uraurQ21tLezt7VFbWwtDQ0Ni2tXV1dDV1RW5AfP27duwtbXF06dPBdpJJDUDQHh4OAIDAzF79mxIS0vD19cXcXFx4PF4OHr0KHg8Htzd3eHr64u9e/cyqv0z4OnpiaioKKiqqopk42Zz/J7+CEFBQYiKikJsbCyUlJRw69YtWFhY8OdIRo8ejeDgYLRu3ZpRXTYNoAB7891s6bKtTaFQKP8rc+bMQY8ePfihKP7+/gKbFjkcDtq0aYN+/fpR7f+wLpvaLfGcKRQKRVRQEyaFQqF8Rf/+/ZGdnQ0lJSV8+PAB169fFzJUpKWlNavB582bNxEVFcU3LVlbWyMmJgba2tr8Y2bMmEGkbPHHjx+xdOlS3L9/HyNHjhQwYX7+/BnR0dH4448/EBERIVQK6b+Km5sbfxKwpKQE+/fvx/z586Gurg5JSUnk5ubi2LFjWL16Ncs9pTDNsGHDRJ4IY2BggC1btsDDwwOampowMTFB9+7dkZWVhf79+xPTvXXrFiIjI6Gurk5M41uoqanBz88PHh4e/OtGeXk5vL29GS0Z/DPB5XLRs2dPoXYVFRW8f/+ehR6RZ+3atTA3N4ecnBwMDAwQGBgIHR0dvHz5EjNmzGBcb9y4cdDR0cG8efMwZMgQvkGwJaGtrS0wNhAV7du3h7GxMYyNjVFQUICTJ08iJSUFycnJjC/8DxgwAJcvX4a8vPw/bpogtVFCX1+fyOv+KD169ICNjY3IdVVUVGBrawtra2tcuHABp06dQkJCAuLj4zF27FgcOHCAiC7b7/fRo0cRHByMt2/fAqhPtDM3N2c09f5rGkoyh4eHCz3H4XCImjD19fWFvleSkpLQ0NDAiBEjiOkCgKGhIWpqahAcHIwvX77A0dER8vLy2LRpExYuXEhUW1TU1NTg7NmziImJQXZ2NiQlJaGpqYkZM2Zgy5YtMDU1JWLABOo/O1//bUWVaNuAqBPkvkZVVRWqqqr8x6IaJ1hbW8PW1hY5OTlYtGgRYmNjMW/ePEhISMDT05OY7l9//QUXFxehdmNj4yY3lDYHAgICsHnzZpiamvITlK2srCArK4uDBw8SNWHq6ekhNjZW5L/RLi4uaN++PQIDA0WyuS42Nhaurq6YOXMmAEBHRwdGRkYIDg7m30tv3bqVv2G4uZGYmIht27Zh8eLFbHel2XL8+HGEhobC1NQU8vLyAOo/U23atMHx48chIyOD9evXIzQ0FBs3bmRcny0DKFvz3WzOs7OpTaFQKP+WhvvjqKgoaGhoCG14o9rNQ5dN7ZZ4zhQKhSIK6BWNQqFQvmLx4sVwdHREYWEhbt26BS6Xy0/PeP36NZKSkhAeHg5XV1ci+mwMPj98+CBgfmzbti1at24tkMTTunVrVFVVMa594MABVFZWIjU1VShhydbWFvPnz4eZmRkOHjyIdevWMa7PBgYGBvz/m5iYYPv27QKLVNra2ujTpw8iIyNhbm7ORhcphGDjM7x8+XJISEiAw+FATU0N69atQ3BwMBQUFODl5UVMt2PHjqwZp7dt2wZTU1NMnDgRSkpKAOrLo8vLyxMv/VpeXo7y8nJ+altqairGjBlDLDGvAUNDQ+zduxc+Pj78dBwej4dDhw5BV1eXqDZbDBs2DOnp6eByuejYsSOOHTuG6OhoKCgoYMmSJYzrrV69GqdPn8bJkyfRp08fzJ07F3PmzBEos9rcSEhI+OFjSZfgbEBVVRXbtm2Dra0tzp8/z/jru7m58Q0GjTdNiJrz588jJCQEhYWFkJCQQJ8+fWBubo6pU6cyrvV/SQAkbWACAHFxcUyZMgVTpkxBWVkZEhMTv1uukQlE+X435sSJE/Dw8ICxsTGGDx+Ouro6ZGdnY8+ePZCRkSFmYiooKCDyuj8Cm8mjQH1Z2/nz56OsrAw8Hg/y8vL4888/MWnSJFy4cIHVvjHBpEmTUFFRgdGjR8Pd3R3a2tr8JDXSxi0ejwdDQ0OB5MvPnz/DxMQE4uLiAOpNkiQRdYJcY96+fQtfX99vGkBJJN43cO/ePfj5+fHHgPv378fdu3fRqVOnJtPhmaJjx454+/YtevfuLdD+9u1bImmNP0NFicLCwibvoaZNmwZ/f38img0sX74curq6SE1NxS+//CL0XpC6zyksLERsbCwGDBhA5PW/pqSkRCDpXE1NDRISEvz7OgBQUlJqtqWyq6qqMGHCBLa70aw5ceIE7OzssGjRIgBAbm4uHj9+DGtra6ioqACov/fz8PBg3ITJpgGUrfluNufZ2Z7jp1AoFCYYOXIkCgoKUFRUxL+f4vF44HK5uHPnDtzc3Kh2M9BlU7slnjOFQqGQhJowKRQK5Stmz56NqqoqREdHQ0xMDH5+fhg0aBCA+sWMmJgYWFhYQE9Pj2g/RD34bFgYa4wojAdnzpzBli1bvlniUllZGVZWVggODm42JszG5ObmNpkeoqamhgcPHrDQIwppCgoKEBkZiUePHmHv3r3IyMhAnz59MGrUKGKajdO0LCwsYGFhQUyrARMTE+zZswfe3t4iL0fet29fpKenIzk5Gffv3wcALFq0CDo6OkTLTOXm5sLCwgIGBgawtbUFAHh7e6O6uhoRERFE0xXevHmD8+fPQ0tLi79QeffuXbx48QJDhgwRMCWSNqKKiq1bt8LBwQFdu3YFUJ+it23bNpSXl8PS0pLx9OYVK1ZgxYoVyM3NRWJiIkJDQ7F7925oaWnByMgI48aNY1TvZ8DOzu6HjiOdnNcUkpKSmDZtGuOv2zgV0cDAgBVjdUZGBtavX4+pU6dCR0eHb8zbuHEjAgICMGXKFEb1nj9/zujrMYmcnByWLVuGZcuWEdMQ9fvdmPDwcGzdupVvAgCAqVOnQklJCZGRkcST5EpKSlBcXIwRI0agsrKSbwYgze3bt3H48GEUFRVBXFwcAwcOhKmpqUBpSNI03oBWVVWF0tJSkWmT5OPHj5CXl0e3bt3Qtm1boVLzJPkZ7tXYTJBzdHRETk4O5syZI/Kx74YNGxAeHo6BAwfy23799VfiupMnT8auXbvg6+vLNy49ePAArq6umDx5MuN6bG6OaKBdu3YoLS0VSqC/f/++QBUTEmzbtg0AMGTIEJGWzlVQUEB1dbXI9Kqrq4USACUlJQWuZxwOh7ipmy0mTJiAS5cu0SRMghQXF2Ps2LH8x9euXQOHw4Gmpia/rU+fPigpKWFcm00DKFvz3WzOs/8sc/wUCoXyb4iKiuKvBXI4HP5mLw6Hg+HDh1PtZqLLpnZLPGcKhUIhCTVhUigUShPMnTu3yUVPCwsLrF27lniiGSDawSebpeNevXolULKtKYYOHUpk8vNnoGfPnkhOTsbatWsF2o8fP44+ffqw1CsKKfLz87Fw4UIMHToU+fn54HK5uHfvHtzc3BAYGMjYYmVgYCDMzc0hLS2NwMDA7x5LasH84sWLuH37NkaNGgV5eXmhNBySaUAAICMjg1mzZuHhw4eQlJSEoqIi8cVKLy8vTJs2DVZWVvy2jIwMbN++HR4eHoiIiCCmLSUlhVmzZgm0jRgxgnhpV1Fz48YNPHv2DEB9SuPAgQOFkq6Ki4tx5coVYn1QU1ODmpoatm7digsXLiAhIQGrVq1C586dYWBgAENDQygoKDCm90/fYQB48uQJY3qNYTMt72fge8bqgwcPEjOMBQUFYd26dQJjA1NTUwQGBiI4OJhxU+Dhw4cZfb3/GqJ+vxtTUlKC8ePHC7VPmDCBaAlhLpcLW1tbpKWlQUxMDOnp6fD09MTHjx+Jl5vNzMzEunXroKamhrFjx6Kurg63b9+GgYEBDh48SCfZ/yVZWVlITU1FXFwcYmJi0KZNG2hpaWHGjBnE7+9+BhMmmwlyWVlZCAoKYmVThry8PD5+/ChyXUtLSyxbtgyzZs1Cu3btwOFw8OHDB/Tr1w9btmxhXK9xRQm2mD17NlxdXeHq6goOh4PKykpcvHgRu3bt4pfPJsWff/6JQ4cOQV1dnajO16xZswZubm5wcnJC7969RWrubokMHjwYXl5euHr1KlRUVITe75/hWtscaPybeOPGDcjJyQmM7SsrK4nMH7BpAAXYm+9mc579Z5jj/1FcXV3RqVOnFqNLoVB+jCNHjmDlypVYu3YtJk+ejPj4eJSXl2Pz5s1E5ytaqjY955ZxzhQKhUISasKkUCiU/wMNaVuiQJSDTx6PJ7RYxOPxiCRMfU2HDh3w9u1b9OjR45vHvHv3TuRpIqJiw4YN2LBhA65evYrBgweDx+Ph5s2buHfvHsLCwtjuHoVhfHx8YGZmBisrK/7imYuLC9q1a8eoCTM+Ph6LFy+GtLT0d0u4cjgcYos4o0aNIpru+T14PB68vLxw5MgR1NTUAKhPT5k/fz7s7e2JmRD++usvuLu7CxhOxcXFsWLFCuKLxqIoEfwzwOFwBNIZm0oSbtOmDczNzYn3RUJCAtra2tDW1sb79+9x5swZHD9+HMHBwfjrr78Y0/nRMsxMGj+/x8OHD1FYWAhJSUmoqKigV69ejGscOXIEc+bMEXkp2a9pylh97tw5ODo6wt3dnZixuri4GH5+fkLts2bNEsnYoKamBm/fvkVtbS0AwSR2USeeigI23+/u3bsjPz9fKFEtNzeX6EJocHAwP5l71apVAIAlS5bA3t4e3t7ecHZ2Jqbt6+sLc3NzbN68WaDd09MT3t7eOH78ODHtloCMjAyMjIxgZGSE4uJinDx5EklJSUhOTgaHw8GhQ4ewfPlyfrpvc4PNBLk2bdqI7Lf4a8aPH4+VK1dCU1MTSkpKaNWqlcDzpMb77du3x8mTJ3Hp0iXcv38fPB4P/fr1w/jx45ustME0mZmZKCws5P9eAeD/XkVGRhLRtLS0xKtXr2BoaAigPkGbx+Nh0qRJAuMFEnTq1Alt27YlqtEU/v7+eP369TfHACRKv0dERAgY4GpqahAVFcVPG/306RPjmj8L0dHRkJeXx927d3H37l2B50jev7ck+vfvj+zsbCgpKeHDhw+4fv06fvvtN4Fj0tLSiFWyYMsA+j1EOd/9M+iKWltLS6vJeSgOhwNJSUl069YNenp6jN9rsaVLoVCYpaSkBHPnzoWUlBRUVVWRl5cHbW1t2NnZwcPDQ6ACFtX+7+qyqd0Sz5lCoVBIQk2YFAqF8pMiysEnm+ad0aNHIzY2Fmpqat885vjx4xg8eLAIeyU6pk6diqNHj+LIkSO4fPkyAGDAgAFwdnb+x4RQyn+P/Px87NixQ6h94cKFiImJYUwnMzOT///w8HAiJql/gs3Fof379yMuLg62trYYPnw4v7RsUFAQunbtiuXLlxPRlZGRwdOnT6GoqCjQ/urVK6GSeiR49eoVjh49isLCQkhISKBv376YP38+unfvTlxbVGhoaPDTGVVVVZGVlSWy8rnfoqysDKmpqUhLS0NhYSE0NDQYff3G32c24XK5sLa2xtmzZ/ltHA4HkydPhp+fn1Da7b/B29sb2trakJGRwYABA3D58mVW/s5NGaslJCSIG6u7dOmCx48fQ0lJSaD98ePHxDelXL16FTY2Nnj79q3Qc61bt26WC3Rsvt8LFiyAk5MTysvLoaGhAQ6Hg5ycHPj7+8PExISYbkpKCnbu3CmwWWLkyJHYtWsXbGxsiJownz59yjcvNWb+/Pk4duwYMd2WiIqKCmxtbWFtbY0LFy7g1KlTSEhIQHx8PMaOHYsDBw6w3UXGYTNBbs6cOQgPD4ezs7NIDIiNOXfuHOTl5ZGfn4/8/HyB50ibtsTExKCpqSmQ4iYKfH19ERoaii5duuDvv/9G165d8ebNG9TW1kJHR4eY7osXL7B7925s3LgRd+/eRV1dHfr16yeSKhabN2+Gi4sLduzYAWVlZZF9ztavXy8SnQa6d++OtLQ0gbbOnTsLVVJgy/RMmp9l7N+cWbx4MRwdHVFYWIhbt26By+Xyx12vX79GUlISwsPD4erqyrg22wZQCjsYGhoiKCgI2traGDZsGADgzp07OHPmDAwMDCAmJgYnJydUV1dj3rx5/3ldCoXCLG3btuWHDCgrK+PBgwfQ1taGiooKXrx4QbWbiS6b2i3xnCkUCoUk1IRJoVAoPymiHHzq6+sz+nr/F5YtWwYjIyPIyspi1apVkJWV5T/3/v17hISEIDExEYcOHWKtj6TR0NBg3LRD+TmRlJRERUWFUHtJSQmxpAMTExPs27fvu0ZnUjSkbD169Ah79+5FRkYG+vTpQzwh8/jx49ixY4fAAuyvv/4KOTk5BAQEEDNh/vbbb9i5cyecnJygpqYGDoeDvLw8ODs7Y+rUqUQ0GygqKoKxsTFat24NNTU11NbWIj4+HkePHkV0dDSxsslsMmnSJJSXl7Nizvv8+TMyMjKQlJSEK1euoGPHjtDX14ebm5uQkau54Ovri9zcXAQHB2PEiBGora1FdnY2XFxcEBAQIJRq929o37499u7di5EjR4LH4yEtLe2bqZgkTYFsGatnzZoFJycn7Nixg79YduPGDTg7O2P69OnEdAFgz549GDRoEExMTLBu3Tr4+PigpKQE/v7+zTZxl833e8mSJXjx4gXc3Nz4SW7i4uIwMjLC6tWriemWlpYKpW8C9YaWDx8+ENMFgIEDB+Lq1atCSYz5+flQUVFhXC8wMPAfj3ny5Anjuj8T4uLimDJlCqZMmYKysjIkJib+cMryfw02E+TevHmDtLQ0nD9/Hj179hTanBAVFUVM+3umrbq6OmK6T548wbZt25Cfn48vX74IPU8iIbGBxMREbN++HYsXL8akSZNw7NgxtGnTBmvXrhX63WYSY2Nj/r1VU9dRkvj5+aGkpASzZs1q8nlS77eo54uoCbGe7OxsFBcXY9asWXj16hWUlJRoKXiGmD17NqqqqhAdHQ0xMTH4+flh0KBBAOo3dMbExMDCwgJ6enqMa7NpAKWwx40bN7Bx40asXLlSoF1NTQ1ZWVkICwuDhoYGwsPDGTVDsqVLoVCYZfjw4QgJCYGjoyNUVVURGxuLFStWICcnh3hKekvUpufcMs6ZQqFQSEJNmBQKhfKT0lIGn6qqqti9eze2bt2KqKgo9OrVC7KysigvL8fjx4/Rtm1beHh4YPjw4Wx3lQh1dXVITk7GjRs3UF1dDR6PJ/B8czU8tFS0tbWxe/du+Pr68tuKi4vh6uqKSZMmEdGUkpKChIToh3z5+flYuHAhhg4divz8fHC5XNy7dw9ubm6Mll5virdv3zaZnjtkyBC8fPmSmO7mzZvx7NkzmJmZCZR8mjp1KrZs2UJMF6gvmzx69Gj4+PjwF/2rqqpgY2MDHx8fhIaGEtVngxs3bgiV2yRJbW0tLl++jKSkJPz++++orq6GpqYmAgICoKmpCTExMZH1hQ2Sk5Ph4uIikHSlra0NcXFxODk5MWrC3LRpE9zc3HDq1ClwOJwmy84D9YYakiZMtozVq1evRlFREVauXMm/lvB4PGhqajL6PjdFYWEhTpw4gf79++PXX39FmzZtYGJigjZt2iA8PBza2tpE9dmAzfdbTEwMDg4O2LhxIx4+fAgA6N27N2RkZPDmzRtiJclVVFRw5coVGBkZCbQnJycTT3PT1dWFt7c3Hj16hJEjR0JCQgJ5eXmIjIzE/PnzkZCQwD+Wie/3j5oNm2ui2tfIyclh2bJlWLZsGdtdIQKb5i1xcfFvmuNIM2XKFMTFxaFDhw4C7aWlpdDV1cX169eJ6G7btg1v3rzBxo0b+WWiRcWbN2/4YxJVVVXk5uZi+vTpsLKy4l9XScDWvRUAoub8f+L8+fMICQnhJ+736dMH5ubmxDeatUQqKipgbm6OO3fugMPhYNy4cfDx8cHjx49x6NAhdOvWje0uNgvmzp2LuXPnCrVbWFhg7dq16NixIxFdNg2gFPa4efNmk1VxtLS0+PODI0eObPKY/6IuhUJhFktLSyxbtgzR0dFYuHAhgoODMXLkSHz+/Bnm5uZUu5nosqndEs+ZQqFQSMLhfe32oFAoFMpPwf3797Fs2TKYmppi4cKFmD17Nj58+MAffG7atIntLjLK27dvcfr0aeTn56O8vBxycnJQV1fHjBkziE1+/gy4u7sjKioKqqqqTaZ8HT58mIVeUUhRUVGB5cuX486dO+DxeGjXrh0+fvyIAQMG4ODBg0ILp0zg5+eH2NhY6OnpQUlJSSi9jZSBydTUFEOGDIGVlRXU1dVx+vRpKCoqwtPTE3/++Sfi4uKI6AKAnp4eFixYgIULFwq0Hzt2DJGRkUhPTyemDQCPHj1CYWEhJCUloaKiIpT2RQJ1dXUcP35cqGxZQUEBjI2NkZOTQ7wPosbNzQ2vX7/G2rVroaSkxGg57KYYM2YMysvLoaysDENDQ+jr67NeCl2UqKur49SpU0Kf58ePH0NXVxe5ublEdFVVVXH58mViZrTv8fnzZ1haWuLixYtCxmp3d3dGN8UcOXIEc+bMERgLFBcXo6ioCDweD/379yeSEvg16urqSE5ORo8ePeDg4IB+/fph6dKlePHiBfT19fHnn38S7wNbFBcXo7CwEABE9n4PGDAAWVlZkJOTE2h//vw5Zs+ejVu3bhHRPX/+PCwtLTFv3jzExsZi+fLlePjwIc6ePQtfX1+hsphMoqqq+kPHcTgcoil6lJYFl8tFbm5us9rYl5qaikuXLgEATp06hZkzZwptTnnx4gWKiopw7do1In0YMmQIjh49yjcQiZJx48YhIiIC/fv3h7u7O9q1a4d169ahpKQEM2fOxO3bt4nosnVvxSYZGRlYv349pk6diuHDh6Ourg7Z2dk4f/48AgICMGXKFLa72KxwdnbG3bt34e3tDV1dXZw+fRrV1dWwtraGsrIy9uzZw3YXKYQoLS2FlJRUs54DbalMmTIF69atE0oWTkhIgJ+fHy5cuIA7d+5g7dq1uHz58n9el0KhMM+XL1/w6dMnyMnJ8dfRFBQUiFfvaKna9JxbxjlTKBQKKWgSJoVCoTQBl8vF1atXAdSbLqSkpJCSkoJDhw6hrq4Oc+bM4ZeLIUXfvn2RkZGBT58+oW3btjhx4gSSkpLQrVu3Zjn4lJeXb7aJLN8jMTER27Ztw+LFi9nuCkUEyMjIICYmBlevXsXdu3dRV1eHfv36YeLEiQIGHyYJCQkBABw8eFDoOZIpcvn5+U3upl+4cCFiYmKIaDawbNkyODo64vnz59DQ0ACHw0FOTg6OHj0KGxsbotoA0KtXL/Tq1Yu4TmPatm0LLpcr1N5UW3MhIyMDJSUl3zTVMm3emTRpEubOncsvV9zS6NevH86cOYNVq1YJtKemphL9vP/+++98s2tZWRkkJCQgKytLTK8x0tLSCA0NxePHj/nJT6SM1d7e3tDW1oaMjAzfmKeioiISI2BjVFVVce7cOZiamqJXr164ceMGli5dilevXom0H2wgqvf75MmTOH36NID6xM21a9cKlRd9/fo10c/55MmTERAQgNDQUIiLiyM8PBx9+/YlbsAE6surtmvXjqgGhR1UVVV/eDxLymB79+5dbNu2DYWFhU2W4SZt7C0rK8OjR4/42jweD1wul29wYBJ1dXXExMTwKymUlJQIXEs4HA7atGkDT09PRnUb07FjR5GmkjdmzJgx8PLygouLCwYNGoSQkBAsWrQI6enpQsZ2JmHr3goAAgMDv/v8unXriOgGBQVh3bp1Ap9hU1NTBAYGIjg4mJowGeb8+fPYvXs3FBUV+W29e/fGjh07hMbhlOZF165d2e4ChRBLliyBs7MzHj9+jKFDh6Kurg537tzB4cOHsXr1arx69Qo7d+7EhAkTmoUuhUJhjs+fP6N169b8f0D9Pcf8+fPRpk0bqt1MdNnUbonnTKFQKKShJkwKhUL5ikePHsHMzIxfslZRURFWVlawsbHBqFGjANSnF9bV1WHp0qVE+9K6dWu8evUKOTk5EBMTw7Rp09C9e3eimhTRUlVVRSe7mjlLliz57vOXLl1CeHg4ACAqKopx/YKCAsZf80eQlJRERUWFUHtJSQmkpaWJas+ZMwfl5eU4cOAA/72Vl5fHhg0bYGxszKjWgAEDcPnyZcjLy/+j+YDkwv/o0aPh5eUFf39/fqJqWVkZfHx8MHr0aGK6bLJ+/XqR6rm7u4tU72dj9erVWLNmDQoKCgTMzefOnYOPjw8x3R49euDo0aMIDg7G27dvAQCdOnWCubk5TE1Niek2RllZmXiibfv27bF3716MHDkSPB4PqampTSZkA2RTtiwsLLBu3TpISUlBR0cH/v7+WLFiBQoLC5vVtURLS+uHzGIcDgcZGRmMamtra+PGjRv8x926dRNKUuvXrx/xNLWJEydi4sSJRDWaYs6cOfD398fAgQNFrk0hi5ubG7FNRT+Ku7s7JCQksGPHDri4uMDOzg5Pnz7F0aNH4eXlRVQ7JSUF9vb2qKqqAofDAY/H478fPXr0YNyEqaCgwL93MDExQVBQkMg2KTRgbGyMPXv2wMfHh9F06B/B2toaq1atQnp6OhYtWoSDBw9i3LhxAABbW1tiumzdWwFAfHy8wOOamhqUlZVBUlIS6urqxHSLi4vh5+cn1D5r1iyEhYUR022plJWVoXPnzkLtMjIy+Pz5Mws9olAo/5alS5dCQkIC4eHhCA0NBQB0794dtra2WLBgAS5dugQVFRVs3bq1WehSKBRmSEhIgLu7Ow4cOIDBgwfz2z08PHDnzh3s2rULM2bMoNr/cV02tVviOVMoFIoooOXIKRQK5StWrVoFcXFx7NixA9LS0tizZw+OHz+OFStWwNLSEgAQFhaG5ORkJCYmEutHRUUFNm3ahEuXLvHTLTgcDmbOnAl3d3eiZVdLSkogKysLGRkZXLt2DWfPnoWGhgZmzZpFTLOlsmHDBowaNYomYTZjmprMTEpKgpaWltBiJUmTV0lJCYqLizFixAhUVlYSL6O8fft2PHv2DL6+vtDS0sLp06fB5XJhaWmJwYMHw83Njah+A2VlZeDxeMTO99SpU9DR0YGUlBTi4+O/az74ugQUk7x69QoLFizA+/fvoaysDA6Hg0ePHkFWVhZHjhwRSFKhUP5XMjIysH//fn6J7H79+sHc3JxoQveJEyfg7OwMY2NjgRKYMTExcHR0xNy5c4lpi5KEhAS4ubnhw4cPfPNOU4iiRPNff/0FcXFxqKqqIjs7GxEREVBQUMCGDRv4Ju//OgEBAd+9Xp8+fRpPnz5F9+7dkZmZSawfW7duhYODwzcNtyQpKChAUVFRk4l9JH+jx48fj8jISJGnvFJaBurq6oiMjISamhrmz58PGxsbDB8+HIcOHcLFixebTC9kitmzZ0NNTQ0WFhYwMjJCREQEXr9+DScnJ2zatAl6enrEtEXJ1yb2Fy9eQEJCAp07d4aYmJjAsb///jvx/lRVVaFVq1b48uULLl26hK5du2Lw4MFEDMENSS2NX/v+/fvo0aMHa0ktFRUVsLW1xahRo/5x89//ira2NrZv3w5NTU2B9gsXLmDbtm1ES9gGBgbC3NxcaBNfRUUF9u7dCwcHB2LabGFsbIwJEyZg5cqVUFdXx+nTp6GoqIgdO3bg/v37OHbsGNtdpFAo/4Ly8nJISEiIfPzPli6FQvnfuHr1KszNzWFgYABLS0t06tSJ/9yTJ08QFhaGU6dOITIyEsOHD6fa/1FdNrVb4jlTKBSKqKAmTAqFQvmKkSNHIioqCqqqqgCAyspKDB8+HCdOnMCgQYMAAM+fP8esWbNw+/ZtYv3YunUrcnJy4OjoCHV1ddTV1eHmzZvYtWsXpk6dCjs7OyK6586dg5WVFUJCQqCkpIQZM2ZAUVERL1++hI2NDTULMkxYWBgCAwMxYcIEqKioCJWjJFVSjMIujRdTSMPlcmFra4u0tDSIiYkhPT0dnp6e+PjxIwIDA4mVBK2oqMDy5ctx584d8Hg8tGvXDhUVFVBVVcXBgweJG3levHiBO3fuNFmOm3S6GFtUVlYiMTER9+/f5xvkZs+e3azLvp4/fx4hISH8UtF9+vSBubk5pk6dynbXKAwxffp0LFmyBIsWLRJoP3r0KGJiYpCUlMRSz8ihqqqKrKws4mZ5ijAlJSXYtm0brly5gnnz5sHW1lYkC5XZ2dkoLi7GrFmz8OrVKygpKQmNCZkkKiqKb7RsbPrlcDgYPnw4Dh8+TEw7ODgYSUlJWLx4MXr27CmUAjpixAhi2hTRkpmZicLCQtTW1vLbGoy+kZGRRDSHDBmCM2fOQEFBAXZ2dlBTU8OiRYvw7NkzGBkZ4erVq0R0AWDw4MFITExE7969sXTpUpibm2PixIk4e/YsQkJChFIM/6v8k4m9MSTvZadMmYK4uDihe4rS0lLo6uri+vXrjOp9K6nF3Nyc9aSWoqIirFy5EufPnyfy+n5+fjh9+jR27NiBYcOGAQBu3LgBJycnaGlpYdu2bYzqFRcXo6ysDEB9VYmAgAC0b99e4JiioiJ4eXnhzp07jGr/DNy8eRPLli3DmDFjkJWVhdmzZ+PBgwe4e/cuwsPD+RV6KBTKfwu25qha4twYhdIcMDMzQ58+fWBvb//NYxwcHFBaWooDBw5Q7f+oLpvaLfGcKRQKRVTQcuQUCoXyFR8+fICcnBz/cdu2bdG6dWuB0l6tW7dGVVUV0X78/vvvCAoKEliInDRpElq1aoXNmzcTM2Hu27cP5ubmGDt2LMLCwtC9e3ekpKQgLS0NgYGB1ITJMNHR0ZCXl8fdu3dx9+5dgec4HA41YVL+NcHBwSgoKEBkZCRWrVoFoH4xy97eHt7e3nB2diaiKyMjg5iYGFy9ehV3795FXV0d+vXrhwkTJgil5DBNXFwcHB0dBRb9G+BwOIxONAcGBv7QcRwOh/EylF/Ttm1bvlGturoaBQUFxN9rNsnIyMD69esxdepU6Ojo8BMSN27ciICAAEyZMoXtLv7naZw+9E+fdVK/VyUlJRg/frxQ+4QJE+Dp6cm4XllZmcA4kA0mTZqE8vJyVkyYX758QVhYGPLz8/HlyxehRM6G0rfNkdjYWHh5eUFGRgZhYWGYMGECcc2GDQu3b98Gh8PBuHHj4OPjg8ePH+PQoUPo1q0bEd0jR45g5cqVWLt2LSZPnoz4+HiUl5dj8+bNxK+de/fuBQDs2rVL6DlRJL1SRIOvry9CQ0PRpUsX/P333+jatSvevHmD2tpa6OjoENPt3bs3srOzoaurCyUlJeTl5QEAPn782KT5gElatWrFN08rKyvj/v37mDhxIgYNGoQnT54Q1RYl69evZ007NTUVly5dAlBvKnF2dkarVq0Ejnnx4gXjKZhXr16Fvb09DAwMoKCgIPCco6MjwsLCYG1tjc6dO7OS1NJQlpwUq1ev5hs9G95bHo8HTU1NbN68mXG9Z8+eYdWqVXytb40xDQ0NGdf+GdDQ0MDx48cRHh4OJSUl3L59G3379oWDgwOGDBnCdvcoFMr/gCjnqH4GXQqF8u+5e/fuP67/LVy4ECtWrKDa/2FdNrVb4jlTKBSKqKAmTAqFQmkCcXFxoTYS5az+qQ9NpZd16tQJ1dXVxHSLi4sRGBgIMTExXL58GZqamhATE4O6ujpevHhBTLeBllYKnWSJSwoFAFJSUrBz506BxIyRI0di165dsLGxIWbCbGDMmDEYM2aMQFtkZCSWLl1KTDM4OBgGBgYiSTD70VQj0ibMly9fwsHBAZaWlujfvz8MDQ1RXFwMWVlZHDp0CAMGDCCmzRZBQUFYt26dwPtqamqKwMBABAcHUxMmA8THx2Px4sWQlpb+7med5KaB7t27Iz8/Hz179hRoz83NFShXwxTTp09HQkICunfvzlqp6Bs3bgiZSkSFk5MTUlNTMW7cOHTv3p2VPoiaV69ewcHBAVlZWTA0NMTWrVtF9jffs2cPgPokel1dXQDAli1bYG1tDS8vL/7zTFNSUoK5c+dCSkoKqqqqyMvLg7a2Nuzs7ODh4QFTU1MiuoBoyhNT2CcxMRHbt2/H4sWLMWnSJBw7dgxt2rTB2rVriSbBGxsb88sTT5s2DXp6emjdujVu3ryJoUOHEtMFADU1NcTExMDGxgZ9+vTB+fPnYW5ujgcPHhBNtmWb27dv4/DhwygqKoK4uDgGDhwIU1NT9O3bl3EtdXV1xMTE8DcIlJSUCLy3HA4Hbdq0YXyTRlhYGIyNjZtMalFSUoKLiwt4PB5CQkKIJrUkJCQIPObxePj48SOOHz8OdXV1YrqtWrXCvn37UFxcjKKiIvB4PPTv3x8qKipE9CZNmoTMzEzU1dVBW1sbJ06cENgg0/B3Jl1ZgU1UVVXh7e3NdjcoFApDiHKO6mfQpVAo/x4ulytUNeJr2rdvjy9fvlDt/7Aum9ot8ZwpFApFVFATJoVCoXwFh8MRMlyK2oAJAMuWLcOuXbuwd+9evsmgoqICfn5+MDY2JqYrKyuLjx8/oqKiArdv34aZmRkA4OnTp8Qnub8uhb58+XIoKioiPj4e79+/bzYpnG/fvv3HdCsul4uMjAzMnDlTRL2iNFdKS0uFzEsAoKCggA8fPjCud/DgQSQnJ0NcXBx6enoC39v79+/DwcEBeXl5RE2Yr1+/hpmZmUgmmX8WI7W7uzs+fvwIOTk5pKen48WLFzh69ChOnjwJb29vREREsN1FxikuLoafn59Q+6xZsxAWFsa43pIlS3742OaSFtj4883WZ33BggVwcnJCeXk5NDQ0wOFwkJOTA39/f5iYmDCuV11djaKiInTv3h0JCQmwsbFhXOOf0NfXh4+PD9auXQslJSVISUmJTPvcuXPw8/PD5MmTRabJJidOnICHhwfatWsnsvTLxpw/fx67d+8WMKX17t0bO3bs4KdXk6Bt27aoqakBUJ/Y9+DBA2hra0NFRYX4pqsePXoAqL+vefjwISQlJaGoqEgXhpsZb968gaamJoB6M1Fubi6mT58OKysrODg4YOPGjUR0DQ0N0b59e3To0AEqKirw9PREaGgoFBQUsH37diKaDaxduxbm5uaQk5ODgYEBAgMDoaOjg5cvXzbbe7rMzEysW7cOampqGDt2LOrq6nD79m0YGBjg4MGDjKdCKigo8MdYJiYmCAwMFCpTTYKfJamlqT5ISEhAQ0MDO3bsYFSrpKQECgoK4HA4KCkpAQBIS0sLJDE2tJPYtNHwmr///jukpaXx4cMHKCsrA6hPRP16k19zYuvWrU22czgcSEpKolu3bpg+fTp69eol4p5RKJT/FVHOUf0MuhQK5d/Tq1cv3Lp1q8k5/QZu3rzJv7+m2v9NXTa1W+I5UygUiqigJkwKhUL5Ch6Ph3Hjxgm1TZs2TaT9uHDhAvLy8jBlyhQoKytDQkICjx8/RmVlJe7du4fTp0/zj2UyUUZTUxOOjo6QkZGBjIwMxo0bhytXrmDnzp2YNGkSYzpN0VJKoY8fPx6XL18WMGJu3rwZ9vb2/LYPHz5g8+bNzXbBjiI6VFRUcOXKFRgZGQm0Jycno0+fPoxqBQYGIjAwEKNGjUKrVq3g7u4OcXFxLFiwAOHh4fDz80ObNm3g7u7OqO7XqKqq4smTJ6wtTF26dAmFhYWQkJBA3759MXr06CYTlpnk2rVriIyMxC+//AJfX19MnDgRGhoa6NixIwwMDIhqs0WXLl3w+PFjKCkpCbQ/fvy4ySTpfwud+GGHJUuW4MWLF3Bzc+OXURMXF4eRkRHWrFnDuJ6WlpZACcyvx4SNIVU2OSMjAyUlJUhPTxepLlC/wM/0b8PPSEP65ZUrV2BoaAg7OztWFifLysrQuXNnoXYZGRl8/vyZmO7w4cMREhICR0dHqKqqIjY2FitWrEBOTg7atm1LTBeov6/y8vLCkSNHUFNTAx6PBykpKcyfPx/29vasbH6jME/79u1RWVkJoD4p8MGDBwDqjVWlpaXEdHft2oWlS5fyF3N0dHSIlj9vjIaGBtLT08HlctGxY0dER0fj2LFjUFBQILJp4FtGraYgNfb29fWFubm5UElqT09PeHt74/jx40R0AeDw4cMAgIcPH6KwsBCSkpJQUVEhMv7/WZJaCgoKiL5+Y6ZMmcKfs9DS0mry2szj8cDhcIiOS96+fQsLCwt+khsAeHt7o7q6GhEREejXrx8xbbaorq5GSkoKOnfujMGDBwOoNwK/evUKQ4YMwfXr1xESEoKIiAgMGzaM5d5SKJQfga05KrbnxigUyv+Orq4u/P39MWbMGHTp0kXo+devX2Pv3r0wNDSk2v9hXTa1W+I5UygUiqigJkwKhUL5CtLmoB9l7NixGDt2rMh1t2/fDj8/Pzx79gzBwcGQkpLCjRs3oKamxp/0JgXbpdBFRUP5tMZkZmbC0tJSwJjZ1HGU/x5NLZBWV1fD29tbyOhA4vqzfv16WFpaoqioCLW1tTh16hQePnyIs2fPwtfXl1GtpKQkbNiwgW+MSkhIQFhYGP7++28EBQVh+vTpcHR0FCgnRwIzMzM4OTnh2bNn6N27t1CK3IgRI4jofvjwAWZmZsjPz4esrCzq6upQUVGBgQMH4uDBg5CVlSWiC9R/phqSgK5evcpPmKqrq4OERPMc8s+aNQtOTk7YsWMHfwHyxo0bcHZ2xvTp0xnX+1nGB6JEVVX1hw1RpBbgxcTE+KlpDx8+BFCfFEjKMOfh4YGZM2fiw4cP2Lp1K+zt7YmYer/H+vXrRarXmGnTpiEuLg6Wlpas9UEU6Ojo4NOnT1BUVERtbS1cXV2/eSzJ7/7gwYORmpqKlStXCrRHRUXh119/JaZraWmJZcuWITo6GgsXLkRwcDBGjhyJz58/w9zcnJguAOzfvx9xcXGwtbXF8OHDUVdXh+zsbAQFBaFr165Yvnw5UX2KaBgzZgy8vLzg4uKCQYMGISQkBIsWLUJ6ejrRcWBCQgKWLVtG7PW/h6GhIdzc3KCqqgqg/rdq27ZtxPSeP39O7LV/lKdPnza5MDZ//nwcO3aMqDaXy4W1tTXOnj3Lb+NwOJg8eTL8/PwYTZFuiUktkZGR/HsLNhPevby8MG3aNFhZWfHbMjIysH37dnh4eDTLtP/WrVvjt99+g5eXF/9zXFNTg23btkFaWho7duyAj48P/Pz8+GZkCoXyc8PWHBVbuhQK5d9jbGyMs2fPQkdHB3PnzsXQoUMhKyuL8vJy3L59G/Hx8VBSUiJy/94Stek5t4xzplAoFFHB4VGHB4VCoVB+EsaPH48DBw7gl19+wZgxY+Dv74/Jkyfj2rVr2LJlC/744w+2u8gIqqqqyMrKEjBcqqur4/Tp0/xylG/evMGECROIpkpQRMP/JfmG1CLKH3/8gdDQUNy9exd1dXXo27cvLCws8NtvvzGqM2TIECQkJPB32XO5XAwZMgRt27bFtm3bMGfOHEb1vkXD4ndTkExrcXBwQG5uLnbv3s1PZSkoKICNjQ00NDTg5ORERBcAFi9ejJEjR6JLly5wdnbG+fPnIScnB0dHR7x48aJZLtBVVVXBysoKmZmZfKMgj8eDpqYm/Pz8IC0tTVS/rKwMjx49Ql1dHV+by+Xizp07WLt2LVFtUREfH89/b0tKSrB//37Mnz8f6urqkJSURG5uLo4dO4bVq1c3y4mxwMBAmJubE/8ssU3jzQKVlZU4d+4cBg8ejF69ekFMTEzg2OZiRv4ZfpuBetPOsmXLMGbMGGRlZWH27Nl48OAB7t69i/DwcIwaNYqY9pcvX/Dp0yfIycnh7du3OH36NBQUFIiY2BujpaWFzZs3C6UTJiUlISAgQMBQRfnv8urVK6xatQpz5szBokWLsGDBAv74y9bWFqampkR0N2/ejM6dO2PdunUiT7cdNWoUTpw48V2jHilqa2uJp643xaJFizB79mwsXLhQoD05ORkRERGIj48npu3p6Ym0tDTs2LEDI0aMQG1tLbKzs+Hi4oLZs2cLpXP+GyIjIxEVFYXo6OhvJrUsWLAAhoaGjI8BlyxZ8kPHcTgcREZGMqr9PcrKyohvrAOE50kaePz4MQwMDHDz5k3ifRA1w4cPR0xMjFAyeXFxMRYsWIDs7Oxmff4USnOErTkqtnQpFAozcLlc+Pv748SJE3j//j2/vVOnTjA0NMTq1av/Ma2dav/8umxqt8RzplAoFFFATZgUCoXyE1NQUIDIyEg8evQIe/fuRUZGBvr06cP4gmxjk0FgYOB3j123bh2j2o1xcHDA/fv3ISMjg3v37uHixYvIycnBzp07MXr0aDg7OxPTFiXUhEkRJdnZ2VBXVxdKQ6yqqsKFCxcYNWJ+67NtbW2NxYsXM6bzT/xTci6plJrRo0cjICBAKE3gzz//hJWVFbKysojoAkBubi5WrVqFd+/ewcLCAps2bcLOnTuRnJyM8PBwDBkyhJg22xQXF6OoqAg8Hg/9+/eHiooKcc2UlBTY29ujqqoKHA6HX44RqP98ZWRkEO+DqDExMYGenh7mzp0r0H769GlERkYiLi6OpZ6R5dWrVzh69CgKCwshISGBvn37wsjIiHja1cWLFxEeHo6HDx/i+PHjiIuLQ8+ePYmY2X8WQ2JLpaCgABEREQIbJczMzJrtdXvIkCFISkoSMqo9ffoUOjo6yMvLY6lnFBJUVVWhVatW+PLlCy5duoSuXbti8ODBxMrOL1y4ELdu3QKHw4G8vDxatWol8Pzvv/9ORBcADhw4gIsXL8Lc3Bw9e/YUWjDq3r07Me3x48dDV1cXBgYGQsYtksTExMDb2xuGhoYYOXIkJCQkkJeXh8jISMyfPx99+/blH8v079eECRPg4uICTU1Ngfbz58/DyckJFy5cYEyrtrYWS5YsQVFR0XeTWo4cOcL4QuE/lZ3PycnBs2fPICMjg5ycHEa1G/jw4QO8vb1hbGyMPn36wNzcHNevX4eysjL2798vZJBkkgkTJsDDwwPjxo0TaL927Ro2bdqEK1euENNmi9GjR8PPzw+jR48WaG+odvDnn3+iuLgYCxcuxJ9//slSLykUyv8Ftuao2NKlUCjMUlNTg2fPnuH9+/eQk5ODoqJik/dTDx8+RM+ePRmtiNQStek5t4xzplAoFJJQEyaFQqH8pOTn52PhwoUYOnQobt26hbS0NISGhuLUqVMIDAzE5MmTGdPS0tJCXFwcOnbsCC0trW8ex+FwiC5cffnyhV8K3cLCAkOHDkVAQACePHkCJycnodLN/1WoCZMiSgYMGICsrCyhpJK//voLCxcuRG5uLmNa3/psx8fH89MxmzPDhw/H8ePHhUyAxcXFMDAwwJ07d4jq83g8fPz4kV/2/NGjR+jQoQM6duxIVFfUlJaW4ty5c5CSksLEiRPRrVs3kfdh9uzZUFNTg4WFBYyMjBAREYHXr1/DyckJmzZtgp6ensj7RJohQ4bg9OnTUFJSEmh//Pgx9PT0iH++2aCoqAjGxsZo3bo11NTUUFtbi/z8fHz+/BnR0dEC5hImycrKwqpVq6Cjo4PU1FSkpKTg5MmTCAsLw65du5os/Uqh/BM/mqYGkC09q6enhwULFggl5x07dgyRkZFIT08npk0RHVOmTEFcXBw6dOgg0F5aWgpdXV1cv36diC6bGwobp001XjRq2KhB8r4uOjoaiYmJuH37NgYPHgxDQ0Po6OigXbt2xDSB7ydsNYbE+aurq+PUqVNQVlYWaH/8+DF0dXUZvccBfr6kloqKCnh4eODkyZMYO3YsXFxciBl9t27dipycHISEhODhw4fYtGkT3NzckJKSAklJSQQEBBDRBQAXFxdcvHgRTk5OUFNTA4fDQV5eHpydnTFixAiilQbYYseOHbh69Sp27tyJIUOGgMfj4fbt29i1axc0NDSwfft2ODo64t27dwgPD2e7uxQKhUKhUH4SNDQ0kJiYSHSDDNVmX5dN7ZZ4zhQKhfK/QO3iFAqF8pPi4+MDMzMzWFlZQV1dHUD9BHS7du0YN2FmZmY2+f+vaSi5SorWrVvDzs5OoG39+vVENdmCVPoLhQIAhw4dgqenJ4D6hd+vk0MaUFNTE0l/RL1D8Z+MJqTMJQMHDkR0dDS2bdsm0H7s2DEMGDCAcb23b98KGF45HA7fgAkAvXr1ApfLRWpqKmbOnMm4Phvk5OTAwsICnz9/BgC0bdsWe/fuxfjx40Xaj8ePH2Pv3r1QVlbGgAEDUFZWBi0tLdTU1CAkJKRZmjB79uyJ5ORkoTKbx48fF2nqlijx8vLC6NGj4ePjAykpKQD1qW42Njbw8fFBaGgoEd2AgABs3rwZpqamfEOalZUVZGVlcfDgQeImzIqKCqSmpqKoqAhiYmIYOHAgpk+fLpQoR/nfGDlyJM6cOSOwOeL58+dQUFAgWk64qaSbpKQkaGlpiXSj07Jly+Do6Ijnz59DQ0MDHA4HOTk5OHr0KGxsbETWDwrzpKam4tKlSwDqk5ecnZ2FrhsvXrwgeh80atQoDB06FJKSkgLtDQnwJCFpXv4nFi5ciIULF+Lx48c4deoUwsLC4O7uDm1tbRgaGmLs2LFEdAsKCoi87o/Qr18/nDlzBqtWrRJoT01NJbL5S0pKCtbW1rC0tPyhpBaSZGVlYfv27fjw4QOcnJwwf/58onoXL15EUFAQVFRUEBERgXHjxmH27Nno168fjI2NiWpv3rwZz549g5mZmcD7PHXqVGzZsoWoNlts3boVW7ZsEThnDoeD6dOnw8HBAVeuXEF2djaxcSiFQmGGKVOm4OTJk/zAg+/9VjAZeMCWLoVCYR82M7daojY955ajTaFQKP9XqAmTQqFQflLy8/OxY8cOofaFCxciJiaGmK6oU0t+llLoosbFxUVgUbK6uhre3t78RfCqqiq2ukZpBhgbG6NDhw6oq6uDvb09tm7dKpCEw+Fw0KZNG6ESZ0wQEREBaWlp/uOamhpERUWhffv2AseR/D5/bTSprq7G06dPUVRUBFNTU2K6lpaWWLJkCe7cuSNgLCkoKEBYWBjjeuPHj8fly5cFjJibN2+Gvb09v+3Dhw/YvHlzszFh+vv7Y/To0XBycoK4uDicnZ3h4eGB5ORkkfajVatWfIOHsrIy7t+/j4kTJ2LQoEF48uSJSPsiKjZs2IANGzbg6tWrGDx4MHg8Hm7evIl79+4R+Xx/i7KyMvz5558YOHAg8d3PN27cwPHjx/kGTKD+b79mzRqipoPCwkJ4eXkJtU+bNg3+/v7EdIH65N6lS5eisrISysrKqKurQ2xsLPbt24fIyEhWkmebGx8+fBCaPNbV1SW+o9/d3V2o7cyZM7CxsRFpksCcOXNQXl6OAwcO8BO85OXlsWHDBuJmHgpZ1NXVERMTw/98l5SUCJghG8afDRuFSLBkyZImE+AfPHgAGxsb/Pbbb8S0//zzT/59bWMqKiqwd+9ejBw5kph2A8rKyrCyssK6detw8OBB7Nu3D6mpqVBQUICJiQmWLFlC1OwtSlavXo01a9agoKBAYNx97tw5+Pj4ENOVkJBgLeG/srISHh4eOHHiBMaMGQNXV1eiZe4b+PTpExQUFAAAV65cwbJlywAA0tLSqK2tJaotLS2N0NBQPH78GIWFhZCQkICKiopQAmpzonXr1vD398ezZ89w7949iIuLo3///vjll18AABMnTsTFixdZ7iWFQvkn9PX1+QnJ+vr6IjPss6VLoVAoFAqFQqFQ6qEmTAqFQvkHSkpKICsrCxkZGVy7dg1nz56FhoYGZs2aRVRXUlISFRUVTfbn64WdfwubqSXx8fFYvHgxpKWlER8f/83jOBxOszFhjhgxAn///bdAm7q6Ot69e4d3797x24YPHy7qrlGaCRISEpgzZw4A4NWrV5g+fTq6dOlCXLd79+5IS0sTaOvcubPQ7nrS3+emjCZAvYHv7du3xHTV1dVx9OhRRERE4PLly+DxeOjXrx+2bduGoUOHMq7X1A7QzMxMWFpaChgzm9NO0Xv37iE6Opr/eba3t8ekSZNQUVEBGRkZkfVDTU0NMTExsLGxQZ8+fXD+/HmYm5vjwYMHQulbzYWpU6fi6NGjOHr0KC5fvgwAGDBgAJydnX+4HOn/QlFREdavXw8XFxeoqqpCV1cXb968gZSUFPbv30/ETN5A27ZtweVyhdqbamOSdu3aobS0FD179hRov3//vpChnWlcXFwwYMAA+Pj48LXKyspgbW0NFxeXf9wwQ/nfaE7X6R/B1NQUpqamKCsrA4/HE/jNovx3UVBQ4KdBmpiYIDAwkPg1C2A3Ab64uBhlZWUAgKCgIKiqqgqdc1FREWJjY+Hg4MC4/tfcuXMHCQkJSE1NBZfLxdSpU2FgYIDS0lLs3bsXeXl52LNnD/F+kGLAgAH8DUiTJk2Cv78/9u/fjwsXLvDH3Xv27MH06dPZ7irjNKRfvn//Hjt37sSCBQtEpq2iooILFy5AQUEBL1++xMSJEwEAsbGxUFFREUkfpKSk0KZNG4wYMQKVlZUi0WQLAwMDGBoaYtasWZg2bZrQ8403B1EolJ+XxnNeoqzyxJYuhUKhUCgUCoVCqYeaMCkUCuU7nDt3DlZWVggJCYGSkhKWL18ORUVFxMfH4/3791i8eDExbW1tbezevRu+vr78tuLiYri6umLSpEmMarGZWvKzlEIXJYcPH2a7C5QWxKFDh/Dbb7+JxIT5ve/wz4C+vj4MDQ3h5ORETENNTQ1+fn7EXv9/oTklH1RWVgokNXft2hWSkpJ4//69SE2Ya9euhbm5OeTk5GBgYIDAwEDo6Ojg5cuXmDFjhsj6IWo0NDSgoaEhUk1PT08oKSmhd+/eSEtLQ01NDS5evIhjx47Bz8+PaDr46NGj4eXlBX9/f/7nrqysDD4+PkTNn7Nnz4arqytcXV3B4XBQWVmJixcvYteuXcRTbW/fvo3Y2FgBE5GcnBy2bNmCRYsWEdWmNG94PB5SUlIwadIk/vVaTk4OR48eRdu2baGrqwsxMTGWe0lhiob7nYcPH6KwsBCSkpJQUVEhkiDIZgL8s2fPsGrVKv5Y61ubjAwNDRnXbsy+ffuQmJiIp0+fYtCgQbCyssKsWbMExkbi4uJwdHQk2g/SfG1Y19bWhra2Nku9EQ2VlZXw9PQUSL9sSKUUFRs2bMD69etRXV2NWbNmQVlZGe7u7jh69CiCgoKIanO5XNja2iItLQ1iYmJIT0+Hp6cnPn78iMDAQIHvenNh7NixCAsLg6enJ7S0tGBoaIjx48c3q3s6CqUlkpSUhBEjRqBbt278pGoNDQ04ODgIBSE0B10KhUKhUCgUCqWlQk2YFAqF8h327dsHc3Nz/iRo9+7dkZKSgrS0NAQGBhI1Ydra2mL58uUYO3YseDweDAwMUFFRAVVVVWzZsoVRLbZSS75G1KXQKZSWgLKyMgoLC0WWUvIz8+DBA6JpYzweD6dOnUJ+fj6+fPkipPWthE7Kj1NXVye0ACkuLi5yo/6wYcOQnp4OLpeLjh074tixY4iOjoaCggKWLFki0r6IkszMTBQWFgqUnuRyubhz5w4iIyOJaN66dQsnTpyAvLw8Ll26BE1NTXTt2hVz584lptmAtbU1FixYgMmTJ0NZWRkcDgePHj2CrKwsjhw5QkzX0tISr1694pt29PX1wePxMGnSJFhZWRHTBYAuXbrg1atX6Nu3r0B7RUUFZGVliWqLkv/L97RhjEz53+FyuVizZg2ysrIQGRkpUJY5Ly8PCQkJOHfuHPz8/JptmnBLg8vlwtraGmfPnuW3cTgcTJ48GX5+fowmuTVOgOdwONDR0RFZUtykSZOQmZmJuro6aGtr48SJEwKl0BsMoF/f3zLNkSNHoKuri7lz56JPnz5NHqOiogJra2ui/aAwz+zZs/Hy5UsoKipCQ0MDcXFx3zyWVKUBTU1NXLx4EaWlpfz085kzZ8LIyIj4PWZwcDAKCgoQGRmJVatWAaj/Dbe3t4e3tzecnZ2J6rOBtbU1Nm/ejCtXriAhIQEbNmxAu3btoK+vjzlz5hAxs1MoFLLs27cPISEhOHToEF6+fAl/f3/MmzcP169fh4+PD7G0bLZ0KRQKhUKhUCiUlgw1YVIoFMp3KC4uRmBgIMTExHD58mVoampCTEwM6urqePHiBVFtGRkZxMTE4OrVq7h79y7q6urQr18/TJgwgWhKjKhTGtkshU6htAT69u0La2trHDhwAMrKykLfr+ZoDNy6datQ28ePH5GVlUW0PKGnpycOHTqE/v37NyuzEkWYrVu3wsHBAV27dgVQb2zYtm0bysvLYWlpSTwViA18fX0RGhqKLl264O+//0bXrl3x5s0b1NbWQkdHh5iumJgYpKSkUFtbi2vXrvEXiiorK9G6dWtiugDQrVs3pKSkIDExEffv3wePx8PcuXMxe/ZsoslLkpKS2L17NzZs2IB79+7xx4DfMtYwia2tLZycnGBnZ4eRI0dCQkICeXl5cHJywtKlS1FSUsI/tnv37sT7Q4oePXqwps3hcITGtc19nBsVFYV79+7hyJEjGDZsmMBzHh4emDt3LtatW4djx45h6dKlLPWSwiS+vr7Izc1FcHAwRowYgdraWmRnZ8PFxQUBAQHYvHkzEV19fX0ir/s9Gq6Fv//+O7p3787K9/mPP/6AhMT3p3h//fVX/Prrr8T6wOVyRWJ+TUtL+6H08wZjbnNAQUEBNTU1iI+P/+YxHA6HmAkTADp27IiOHTvyHw8ZMoSYVmNSUlKwc+dOjBo1it82cuRI7Nq1CzY2Ns3ShAnU/z3HjRuHcePG4fPnzzh8+DD27duH/fv3Q0NDA0uXLm2yVDmFQvk5iYuLg6enJzQ0NODp6YmhQ4di165dyMnJgZWVFTEzJFu6FAqFQqFQKBRKS4aaMCkUCuU7yMrK4uPHj6ioqMDt27dhZmYGAHj69CnxNIsGxowZgzFjxhDVGDBgAC5fvgx5eXmoqqp+d+Ho3r17jGqzWQqdQmkJPH36lG94+PvvvwWeq6ysZKNLxHn+/LlQm5SUFMzNzbFs2TJiugkJCXBzc4OBgQExja9p7sadpoiIiIC0tDT/cU1NDaKiooQSnJleiL5x4waePXsGoP5vPXDgQCETQHFxMa5cucKo7s9CYmIitm/fjsWLF2PSpEk4duwY2rRpg7Vr10JRUZGY7tChQxESEoJOnTrh8+fPmDhxIkpLS7Fnzx4MHTqUmG4Dbdu2FVkZ7tLSUpw7dw5SUlKYOHEilJSUoKSkJBLtBtasWQOg/vvT+PrC4/Hg6ekJLy8v8Hg8cDgcxseEooTNDQg8Hg/jxo0TamvKTMHke9zUBoXq6mp4e3ujbdu2Au1Mvz8JCQmws7MTMmA2MHz4cGzcuBExMTHUhNlMSE5OhouLCzQ1Nflt2traEBcXh5OTEzETJpuwae6uq6vD0aNHcf/+fVRVVQk9T/KaFx0djbCwMLx69Qrp6ek4cOAAOnfuTMwQ6OLi8o/HcDicZmPCzMzMZLsLePToEZydnXHjxg1UV1cLPU9yPFBaWoqePXsKtSsoKODDhw/EdH8GXr9+jdOnT+P06dMoKiqChoYG9PX1UVpaim3btiE7O5saqCiU/wivX7+Guro6AODKlSuYOnUqAPLXMrZ0KRQKhUKhUCiUlgw1YVIoFMp30NTUhKOjI2RkZCAjI4Nx48bhypUr2LlzJyZNmsS4HlulEd3c3PiJTqJelP5ZSqFTKM2VptJt7969i+joaKSkpLDQI/KIOtG3gaqqKoGUFlHg4uIikG76taGmqYX4/zLdu3dHWlqaQFvnzp3x+++/C7SRSAPicDiws7PjP27KBNCmTRuYm5szqvuz8ObNG76ZRlVVFbm5uZg+fTo/QWPjxo1EdLdv3w4rKys8e/YM9vb2kJOTw65du/DgwQMcOHCAiCYb5OTkwMLCAp8/fwZQb/7cu3cvxo8fL9J+tNTS22VlZXj06BHq6uoA1JsiuVwu7ty5g7Vr1zKqxZYBtKkNCurq6nj37h3evXtHXLthAfhbjBkzBl5eXkT7QREdFRUVTZrIe/XqhbKyMhZ61LzZunUrzp49i19//VVkpdgBICkpCbt378bSpUv5v8kqKirw8fFBq1atYGFhwbhmVlYW5OXlGX9dyrfZuXMnSkpKYG1tTTQJvClUVFRw5coVGBkZCbQnJyeLJCGcDRITE5GYmIjr169DTk4Oc+bMgb+/P5SVlfnHdOvWDa6urtSESaH8R+jWrRsePXoELpeLwsJC7Ny5E0D9PWC3bt2anS6FQmGW7OxsqKurCyXfV1VV4cKFC/jtt98AAKNGjWK8YkxL1KbnLDpdtrUpFAqFFBxeQ/QYhUKhUIT48uUL/Pz88OzZM1hYWGDo0KEICAjAkydP4OTkJJQa829pKqEmKSkJWlpaxBNqGkhISMDMmTOFFm8+ffqE2NhYmJqaEtGlUChkqaqqQkpKCmJiYpCXlwcxMTFMmzYNvr6+xDTLy8tRXl7OXzBKTU3FmDFjBErZkeL9+/d48uRJkybEESNGENHcsGEDRo4cCWNjYyKv/zUmJiY/fCxbxtTmiqqqaoszAYwbNw4RERHo378/3N3d0a5dO6xbtw4lJSWYOXMmbt++LbK+vH37Fh06dIC4uLjINEmzZMkStG3bFk5OThAXF4ezszOKi4uRnJzMWp9EVVqWbVJSUmBvb4+qqipwOBx+0idQn2yXkZHBcg//+4wfPx5hYWEYMGDAN48pKCiAmZlZs00TbmnMnz8fkydPxqpVqwTa9+3bh/T0dCQmJrLUs+bJsGHD4OnpCW1tbZHq6uvrY8mSJdDX14e6ujpOnz4NRUVFnDp1CsHBwTh79iyjeo0reFBEh5qaGiIjI//RTE+C8+fPw9LSEvPmzUNsbCyWL1+Ohw8f4uzZs/D19eUvyjYnBg0ahMmTJ8PQ0BATJ06EmJiY0DE3btzA+fPnYW1tzUIPKRTK/5Xw8HCEhoaiVatWkJOTQ2JiIo4ePQpvb2+sX7+e2EZOtnQpFAqzDBgwAFlZWZCTkxNo/+uvv7Bw4ULk5uZS7Wagy6Z2SzxnCoVCIQlNwqRQKJTv0Lp1a4HUKwBYv349Mb2mjJVnzpyBjY0N0VKfZWVl+PLlC4B6I2jfvn2FTFL37t3Dnj17GDdhslkKnUJpCTx8+BAxMTFITEzE+/fvweFwYGhoiFWrVuGXX34hppubmwsLCwsYGBjA1tYWAODt7Y3q6mpERESgX79+xLQTEhKwY8cOcLlcfL3fiOkSuoGBgfz/d+zYER4eHrh58yaUlZWFFsyYTmakxkr2mDRpEsrLy1uUCaAhpc7FxQWDBg1CSEgIFi1ahPT0dKGJMqZhw1Qtau7du4fo6Gh06dIFAGBvb49JkyahoqJCqOw9aURdWpZtQkJCMGvWLFhYWMDIyAgRERF4/fo1nJyciI77v2b27NnYv38/FBQURKYpKtTV1ZGSkvJdE2ZSUhL69+8vwl5RSLJ69WqsWbMGBQUF0NDQAIfDQU5ODs6dOwcfHx/i+tnZ2SguLsasWbPw6tUrKCkpQVJSkrguW7Rv377J5FHSPHr0CMOHDxdqHz58OF69esW4Hs0RYIeOHTsyvgH5R5k8eTICAgIQGhoKcXFxhIeHo2/fvs3WgAkAFy9e/OY9xqtXr9CtWzcMGzYMw4YNE3HPKBTK/4q5uTl69eqFZ8+eQVdXFwDQrl07ODg4YN68ec1Ol0Kh/HsOHToET09PAPVj4HHjxjV5nJqaGtX+D+uyqd0Sz5lCoVBEBTVhUigUylcEBgbC3Nwc0tLSAuaapmgui9F//PEH7Ozs+Ok/c+fOFTqGx+Pxy5AyCZul0CmU5kpNTQ3Onj2LmJgYZGdnQ1JSEpqampgxYwa2bNkCU1NTogZMAPDy8sK0adNgZWXFb8vIyMD27dvh4eGBiIgIYtp+fn7Q09ODqampQKluEsTHxws87tKlC27fvi2UCkiiPDaFPW7cuEH8s/WzYWNjg5UrVyI9PR2LFi3CwYMH+ZNkX29YYZIGU3VTBkymTdVsUllZiQ4dOvAfd+3aFZKSknj//r1ITZhslJZlm8ePH2Pv3r1QVlbGgAEDUFZWBi0tLdTU1CAkJAR6enoi6cfz589RU1MjEi1Rs3TpUpiamkJBQQELFy4U2KTA4/Fw9OhRREZGwt/fn8VeUv4tjTfXTZo0Cf7+/ti/fz8uXLgAHo+Hfv36Yc+ePZg+fTqxPlRUVGD58uW4ffs2OBwOxo0bBx8fHzx+/BiHDh0iXnrz9evXiI2NxcOHD+Hg4IA///wT/fr1g4qKClHd1atXw8PDAzt37iS6efNrOnXqhIcPHwpp3rx5k7+pgEn09fVb3PjrZ8DExAR79uyBt7e3yMuR79+/H3p6ejh69KhIddlkxYoV8PPzE/peJSUlYdeuXfjzzz9Z6hmFQvk3aGlpCTweP3488c2MbOpSKJR/h7GxMTp06IC6ujrY29tj69atAuMwDoeDNm3aYPTo0VT7P6zLpnZLPGcKhUIRFdSESaFQKF8RHx+PxYsXQ1paWshc05jmZKiZM2cOevTogbq6OixduhT+/v5o3749//mGQS+J5Dp9fX0Bne+VQqdQKD9GQ3ra6NGj4e7uDm1tbb6Jx8bGRiR9+Ouvv+Du7i7wfRYXF8eKFStgYGBAVPv9+/cwMzPjl0EnSWZmJnENys+Hvr4+fHx8sHbtWigpKbWIks1du3ZFQkICqqqqICUlhWPHjuHSpUvo2rUr0Z3JojRVfw2Xy0VERARmzJgBJSUlODg4IDU1FRoaGvDx8RFKDf831NXVCaWBi4uLo66ujjGNHyEiIgIODg7Q19fnm+WXLFmCdu3aITg4uFmaMFu1asVPyFNWVsb9+/cxceJEDBo0CE+ePBFZP76XBv9fZ/jw4bCzs4O7uzv27duHwYMHQ1ZWFuXl5cjNzUVFRQU2btwotEhM+W/xdUqhtra2yMtj79mzBwBw7tw5fuLTli1bYG1tDS8vL/7zJHjy5AmMjIwgIyOD0tJSWFlZIS0tDfb29ggPD4eGhgYx7X79+sHHxwfTpk1r8nlSGxbmz58PJycn/maMhw8f4tKlS9i7dy/jFTQAummTLS5evIjbt29j1KhRkJeXFxr3/v7778S0Q0NDm23i5bdo06YN5syZA0dHR+jp6eHjx49wdHTEmTNnsGjRIra7R6FQ/gc+fPgAb29vGBsbo0+fPjA3N8f169ehrKyM/fv3E9tAwZYuhUL590hISGDOnDkA6ucKdHR0mpx7rKyspNr/YV02tVviOVMoFIqooCZMCoVC+YrGhprvmWtEvShOmoZynlFRUdDQ0ICEhGh+ItgshU6hNFc+fvwIeXl5dOvWDW3btmWl/KKMjAyePn0qNKn76tUrtG7dmqj2tGnTcPHiRZGYMJvi0qVLKCwshISEBPr27YvRo0dDXFyclb5QyJCRkYGSkhKkp6c3+XxzSWdsigYjZOvWrTF16lR8/vwZbm5usLe3J6InSlP11/j4+CAxMRETJkxAVlYWTp06hQ0bNuD8+fPw8vJqlmYQUZeW/RlQU1NDTEwMbGxs0KdPH5w/fx7m5uZ48OCBSH8/m3uZXWNjY4wYMQInTpxAfn4+Hj9+DDk5ORgaGsLAwIB4UiClZXD+/Hns3r1bYPzZu3dv7NixA6tWrSKq7eHhAW1tbbi4uPANl76+vrCzs8OePXtw5MgRYtrbtm2DkpIS5syZA2lpaWI6X2NhYYGPHz/CxsYGVVVVWLlyJSQkJLBgwQKsXLlSZP2gkGXUqFEYNWoUK9pDhw5FZmYmli1bxoo+G0RFRSEsLAzbtm1DRkYG8vLy0Lp1axw+fLjJMRqFQvn5cXd3R05ODkxNTZGZmYkbN27Ay8sLKSkp8PLyQkBAQLPSpVAozHLu3DlMmTJFyKSWk5MDW1tbohtiWqI2PWfR6bKtTaFQKKSgJkwKhUL5DlOmTEFcXJxAeUgAKC0tha6uLq5fv85OxwgycuRIFBQUoKioiG805fF44HK5uHPnDtzc3BjVY7MUOoXSXMnKykJqairi4uIQExODNm3aQEtLCzNmzBBZ0tZvv/2GnTt3wsnJCWpqauBwOMjLy4OzszOmTp1KVNvGxgY6Ojo4e/YsFBUVhc6ZlHHqw4cPMDMzQ35+PmRlZVFXV4eKigoMHDgQBw8ehKysLBFdiuhZv349210QCVVVVfD29kZycjLExcWhp6cHa2trfinhy5cvw9HREa9evSJmwmTTVH3mzBns2bMHAwcOhLOzM0aOHIlVq1Zh3LhxWLFiBeN6ERERAuaZmpoaREVFCaSTAyCaxC7q0rI/A2vXroW5uTnk5ORgYGCAwMBA6Ojo4OXLl5g5c6bI+hEWFoauXbuKTI8N+vfvj23btrHdDQpB0tLS+Onr36Mh9YJpysrK0LlzZ6F2GRkZfP78mYhmA7du3cKRI0cExp3i4uJYtWoVjIyMiGo/efIEiYmJ6NWrF1Gdpti0aRNWr16NBw8egMfjoXfv3j/0GaD8d2CzAkybNm3g5eWFkJAQKCsrC6WiR0VFsdQzcnA4HJiZmeHBgwc4ffo0JCQkEBgYSA2YFMp/mIsXLyIoKAgqKiqIiIjAuHHjMHv2bPTr1w/GxsbNTpdCoTDLw4cPMXv2bPj4+GDEiBGoqanB3r17ER4eTnzNrCVq03NuGedMoVAoJKEmTAqFQvmK1NRUXLp0CQDw4sULODs7C030vnjxgoiRaevWrUJt1dXV8Pb2Rtu2bQXaSZmIoqKi+EbLBmNkw/9JTPqyWQqdQmmuyMjIwMjICEZGRiguLsbJkyeRlJSE5ORkcDgcHDp0CMuXLydqatq8eTOePXsGMzMzgevl1KlTsWXLFmK6QP31sbKyElwuFy9evCCq1RhPT09UVVXh9OnT/GtWQUEBbGxssHv3bjg5OYmsLxSy6Ovrs90FkbB7927ExMRAV1cXUlJSiImJQbt27bBy5Uq4uLggOjoaPXv2RGRkJLE+sGWqBoDy8nJ+Ol9WVhZ/o0jHjh35Kd5M0b17d6SlpQm0de7cWWjHN4fDIWqGEHVp2Z+BYcOGIT09HVwuFx07dsSxY8cQHR0NBQUFmJiYENevqanB27dv0b17d7x580Zg8xMpoxqFQgoXF5d/PIbD4RD7bA8ePBipqalCKYxRUVH49ddfiWg2UFtb22S1jIqKCuKJ6H379kVpaSkrJszPnz+jqKgI1dXV4PF4AmngDdU2KP99CgoKEBkZiUePHmHv3r3IyMhAnz59iCdkysjItLjfwvz8fNjb2+PVq1dwc3NDXl4e1qxZg3nz5mHLli1Cc4MUCuXn59OnT1BQUAAAXLlyhZ/uKy0tjdra2manS6FQmCUhIQFubm4wNTWFiYkJrl+/jpcvX8LT0xOzZ8+m2s1El03tlnjOFAqFQhJqwqRQKJSvUFdXR0xMDN98WFJSIlCKsMEU6Onpybj28+fPm+zPu3fv8O7dO8b1muLIkSNYuXIl1q5di8mTJyM+Ph7l5eXYvHkzpkyZQkSTrVLoFEpLQEVFBba2trC2tsaFCxdw6tQpJCQkID4+HmPHjsWBAweI6EpLSyM0NBSPHj1CYWEhJCUloaKiIpI0u8zMTAQFBYl8t+Tvv/+OgIAAAdO4qqoqtm/fDisrK2rCbGacP38eISEh/NLzffr0gbm5OfGkV1GSkZEBBwcHLFy4EAAwadIkuLq64uXLlzh58iTMzMywceNGoZIxTMKWqRoAevbsiby8PJSVleHJkyeYMGECgPr35ZdffmFUKzMzk9HX+19pqaVlGydQqqioiCyt8erVq7CxscHbt2+FnmvdunWLM55Q/vtkZWVBXl6eNf1NmzZh2bJluHXrFmpqahAcHIwHDx7g7t27CA8PJ6o9fvx4BAcHw8fHh9/27t07eHt7Y/To0US1N2zYgO3bt2PZsmXo1auX0P00KTPkhQsXYGNjg4qKCv78SQMcDkfAkEn575Kfn4+FCxdi6NChyM/PB5fLxb179+Dm5obAwEBMnjyZmDbJzTY/K/Pnz8ewYcMQGhoKBQUFGBgYQEtLCw4ODrh06dJPM2akUCg/joqKCi5cuAAFBQW8fPkSEydOBADExsbyN/01J10KhcIsrVu3hrOzM2pra3Ho0CFISEggIiICI0eOpNrNSJdN7ZZ4zhQKhUISDu/rWTIKhUKh8DExMUFgYKBQGcjmzKBBg5CWlgZFRUWYm5tj4cKF0NbWxuXLl+Hh4YHk5GSi+qIshU6htFTKysqQmJiI+Ph4JCUlsd0dxhk/fjwOHz4s8jSg4cOH4/jx40KT2cXFxTAwMMCdO3dE2h8KOTIyMrB+/XpMnToVw4cPR11dHbKzs3H+/HkEBAQQ27QgahoSxRpKU9fW1mLw4MFo3749/Pz8iKcfAfWbUfz8/FgpQZOQkIDt27dDTEwM6urqOHToEIKCghAUFAQ3N7dmbZD7/Plziykt+/btW/j6+uLGjRv8JLfGfJ1GyiTz5s2DvLw8TExMsG7dOvj4+KCkpAT+/v5wd3eHtrY2MW0KhWkGDBiAy5cvs2rCBOrvJ8PDw3Hv3j3U1dWhb9++MDMzw5AhQ4jqlpaWYsmSJSgvL8fHjx/Ru3dvvHjxAh06dMCRI0fQo0cPYtqqqqrffI6kGXLWrFlQVFTExo0b0a5dO6HnSZ4zRXSYmppiyJD/196dB9SU//8Df942S1kqhiKVwjVoZE2WSGMkS+TDWIpknRhh7ESUiLE0GXuULbKUiBmEwTAjS5i0ypplCKPQen9/+LlfuVnG3HNP3ft8/JX3OdPzdUyqe+7rvN5fYcKECbC1tcW+fftgZmaGRYsW4c8//8Tu3buVmhcVFYVu3bpBT08PUVFRHzxXHX8XCw0Nhaenp8L096dPn2Lu3LlYvny5OIUR0Wc7ceIExo0bh/z8fLi4uGDJkiUIDAzE1q1bBX2AWKxcIlKue/fuwdfXF2fOnMGoUaNw9epVnDlzBmPHjsXw4cOhpaXFbDXIFTNbE6+ZiEhIbMIkIqJiWrdujYiICFhaWmL+/PmoXr06Ro8ejXv37qFbt264ePGiYNkf2wp98+bNgmUT0X/39pvvUqlU4Y2jtwk5GWfz5s2Ij49HQECAShuHhgwZgnr16ilMUJs/fz7++usvREREqKwWElbv3r3h5OQEb2/vYushISE4fvw4du3aJVJlyiWVShWmmtna2sLPzw89e/ZUSQ1iNVW/kZycjNu3b6NDhw7Q09PDb7/9Bh0dHdjb24tSj9BevnyJOXPmwNLSEmPGjAEAODg4oH379vD19RV06qlYvL29ER8fD1dX1xKbiITc/t3GxgaRkZFo0KABBg0ahLFjx6JNmzbYvXs3du3ahe3btwuWTaRsJf3M0DQvX77E/v37izWA9urVS/DfRz82KVqoZsgmTZpg7969sLa2FuTzU+nQokULREZGwtLSslgT5q1bt9CrVy+l3yN6+3uJWA3GYrt9+zaePHkCQ0ND1K5d+4Ovq4mobHjy5AkePHgg/76WkJAAAwMDwSdSipVLRMrTrFkz1KxZE0FBQWjcuDEAICIiAosWLYK1tTUiIyOZrQa5YmZr4jUTEQmJ+70SEb2jtDQRiaVFixZYvXo1fH19IZVKsXPnTowcORLx8fHQ19cXNFuMrdCJSHkWLFggb2BZsGCBaG8WxcXFIT4+HnZ2djA2NlbYklGoqWY+Pj7w8PBAQkICmjVrBolEgvj4eCQlJWHdunWCZJI40tPTS5xC0717d434fy30NLG3jRo1CsuXL1d5UzUA3Lp1Cw0aNECDBg3kax06dEB+fj6WLVuGCRMmqLQeVQgMDERCQgL69esnX5s1axaWLFmCZcuWYerUqSJWJ4zTp09j5cqVaNu2rcqztbW15V/XFhYWSElJQZs2bWBnZ4dFixapvB5VevToUYmTR01NTUWqiP6r3r17o1y5cqLWUFRUhP379793sq2QWxtPnz4dM2fOxP/+979i60+fPoW3tzdWrlwpWPaHmixfvXolWK6FhQWysrIE+/xUOujq6iI7O1thPTMzExUqVFB6XlJSUokfqzuZTIYNGzZg8+bNePjwoXy9WrVqGDx4MEaMGMFJQERlmKGhIQwNDeV/VtVrarFyiUh5evfujSlTphR7rfXtt9+iTZs2gt+j0cRsXrPqcsXOJiISCidhEhG9Y+/evXBxcYGenh727t37wXN79+6toqpUJzU1FZ6enhg6dCgGDBiAHj164J9//sHLly/h5eWFiRMnCpYt9lboRKQeQkJCPnhcyKlmly9fxsaNG5GSkgKZTIb69etj6NChaNq0qWCZpHpOTk6YPXu2wvZdx48fx6xZs3Dq1CmRKlMuqVSK33//HUZGRvK1tycgqYKnpyfi4+Mhk8lU2lQNAJ06dVLYQvbq1auYNm0a7ty5g0uXLgmWLZZ27dohJCRE4XtWfHw8JkyYgJMnT4pTmIDs7e2xZcsW1K1bV+XZAwYMwDfffIOhQ4di/fr1uHz5MoKDg3H+/HmMGTMGf/75p8prEtqlS5cwdepU3Lp1q9i6TCZT66lmpBqBgYEIDw+HVCotsXFf2TsrnD9/Hrdv3wbwf02Y7+amp6djy5Ytgu4o8ezZM6xatQrJyckoLCwE8PrfVH5+PlJTU3H+/HlBcn/77TcsXrwYEyZMQN26dRWmJbOpWj3Mnj0bt2/fxrJly+Do6Ih9+/YhLy8PPj4+aNKkiXw3E6G8fPkSz58/R6VKlQRp+iwtxo0bh+PHj6NXr15o06YNDA0N8ezZM5w9exbR0dGws7PD6tWrxS6TiD6RWEMeNH24BJG6y8vLK/Y7d1FRkcoe0tDEbF6zZlwzEZGycRImEdE73m6slEgk6Natm8KbCS9evMDOnTtVXZpK1KtXD0eOHMGLFy+gr6+PyMhIxMTEoGbNmujataug2fr6+igoKADweqpGWloanJycYGVl9dEt1oiodPnQJCKJRCLom3VCNll+TJ06dTB+/HhYWFgAAGJjY2Fubi5aPSSM7t27w8/PD3PmzEHz5s0BvG7EmDdvnuA/K1XN39+/2NPI+fn5WLx4scJ0bKGmizVv3lz+d6xqX331Fdzd3bFt2zYYGxvjp59+woYNG9CsWbOPNnuXVTk5OSVuyW1oaIjnz5+LUJHwXF1dsWHDBsybNw/a2toqzR4xYgTGjh0LPT09uLi4IDg4GCNHjkRycjLs7OxUWouq+Pv7o0qVKggJCSnxa43ov4iOjsasWbMwaNAgleRJJBJMmzZN/rG/v7/CORUrVoSXl5egdcybNw+nT59Gu3btEBsbCxcXF6SnpyMxMVHQhyhHjhwJAPjuu++KNXmwqVq9TJ06FcOHD4e9vT1kMhn69OmD7OxsSKVSTJkyRZDMnJwchIaGYv/+/cWa9s3NzdGzZ094enqqVUNmVFQU/vjjD0RGRipswe7s7IwBAwZgyJAh2L17N9zc3ESqkoj+jbd3ihFyEndpySUiYW3fvh3r1q3D/fv38csvv2D9+vWoXr26Su6Ba2I2r1kzrpmISChswiQiekdWVpZ8y67p06ejXr16xbbtAF4/Kbp06VIMHTpUhAqFV758edy/fx/x8fHQ0tJCly5dVDLFQsyt0IlIuRYtWvTBSURCO3HiBFJSUpCbm1tsXSKRwNvbW5DMy5cvY8SIEejTp498u4zFixcjPz8foaGhqF+/viC5pHpjxoxBSkoKRo0aJW86kMlkcHBwwKRJk0SuTnlatmyJv//+u9iara0tnjx5gidPnqikBjFvuC1duhSTJ0+Gu7s7ypUrhwcPHsDX1xf9+/cXrSah2draYs2aNQgMDJQ3JMpkMoSFhaFJkyYiVyeMR48e4eDBgzh27Bjq1Kmj8PBVeHi4YNmOjo6IjIyEtrY2TExMsGHDBoSGhqJz5874/vvvBcsVU3JyMnbu3ImGDRuKXQqpodzcXLRv315lec2aNZNvlyyVSnHq1ClUq1ZNZflvnDp1CkFBQXBwcEBSUhK8vLwglUoxe/ZspKWlCZYbFhb2wQlbpB4MDAwQERGBM2fOIDExEUVFRahfvz7at28vyGSap0+fwt3dHXfv3sXXX3+Nfv36oXLlynj+/Dn++usvrF27FgcPHsS2bdvUppl/x44d+P777xUaMN+QSqX4/vvv2YRJVIbcvXsXa9eu1ZhcIhJOTEwMfvzxRwwZMgTr168HAFhZWWHJkiUoV64cRowYwWw1yBUzWxOvmYhISNyOnIjoHVFRUZg2bRokEol8gsO73jRarFmzRoQKhZWdnY2JEyfi5MmT8sl1byaCBgYGKrwxrUxiboVORMplZ2eHcePGqWwS0dv8/f2xZcsWVKtWTeF7lkQiEWz74sGDB8PS0hKzZ8+W5xYUFMDX1xf3799HaGioILkknvT0dPnW8w0aNICVlZXYJamlpKQkpKSkoKioCMDr38Py8vKQkJAg+BaYMpkM06ZNQ0xMDCIiImBjYyNontiuXr0Kd3d3GBoaolGjRpBIJPjrr7/w9OlThIaG4quvvhK7RKWbPn36B49zgoxydenSBUuWLFH7f0skju+//x6tW7cW5fdPMTVu3BiHDx+GiYkJxo8fj06dOsHV1RXJyckYOXIkTpw4IXaJRJ9s/vz5+P333xEaGgoTExOF4/fv38eIESPg5OSE8ePHi1Ch8rVs2RI7d+6EpaXle8+5desW3NzccO7cORVWRkSfSyqVQktLCzVr1vzgecq+RyVWLhEJp3fv3vDw8EDv3r1ha2uLffv2wczMDHv37sWqVavw66+/MlsNcsXM1sRrJiISEidhEhG9w9XVFbVq1UJRURGGDBmC4OBgVKlSRX5cIpGgYsWKajvRLCAgABkZGVi7di1sbW1RVFSECxcuYP78+Vi6dKl8uzUhiLkVOhEpl6onEb0tJiYGfn5+Kp9W99dffyk0q+vo6GDkyJHo06ePSmshYTx48ACHDx+Gnp4eOnToACsrKzZeCiw8PFzeaPnmAZk3H7do0ULpeSU15EkkEujo6GDSpEnFMtWxOa9x48bYv38/duzYgZSUFOjo6KB79+4YNGgQvvjiC7HLE4SY/x9fvXqFdevW4erVq3j16hXefUZWyCmcYvnuu++wYMEC+Pn5oW7dutDV1RW7JFIjTZo0QVBQEM6cOQMrKyuFry8hpyvn5eVhx44dSE5ORmFhYbH1K1euCPrmkYmJCe7evQsTExNYWFjIp3NWqFABz549U2qWh4cHQkJCULlyZXh4eHzwXHX8HqaJrl69irlz5yI1NRV5eXkKx5W97XxcXBx8fX1LbMAEgJo1a2L8+PFYtmyZ2jRhFhQUyCeQfwgnzxKVHf369cPhw4cBAC4uLnBxcXnvtFt1yCUi4WRkZJR4/6tFixa4f/8+s9UkV8xsTbxmIiIhsQmTiKgELVu2BPD6TYNmzZpBR0dzvl0ePXoUK1eulP8dAEDHjh1Rrlw5TJo0SdAmTEC8rdCJSLnat2+PkydPijKJSEdHB61atVJ5roGBAW7dugUzM7Ni6/fv30f58uVVXg8pV3x8PEaMGIGXL18CAPT19bFixQq0a9dO5MrU25YtWzBq1Ch4e3ujU6dO2LNnD54+fYpJkyahc+fOSs+7c+dOietvJkC+77g6qVWrlsZNH79//z62bt2K5ORk6OjooF69eujfv7/gv4P6+fkhNjYWbdu21Zjfd4ODg/Hw4UO4urqWeFzZzTykWbZv3w5jY2MkJiYiMTGx2DGJRCJoE+aCBQuwZ88eNGrUCAkJCbC1tcXNmzfx+PFjDB06VLBcAOjatSumTJmCoKAg2NnZwcfHB02bNsWRI0dgbm6u1KxatWrJt6A2NTVlU5gGmDlzJsqVK4fp06ejXLlyguc9evToow89S6VS3Lt3T/BaVMXa2hq///476tSp895zTp48yYe/iMqQefPmYc6cOTh79ixiY2MxZMgQGBkZoXv37nBxcYGFhYVa5RKRcKpVq4br168r3G++cOGC4A/LamI2r1l1uWJnExEJRXO6ioiIPkOrVq1E3QJTDNra2qhUqZLCerVq1ZCfny9otphboRORcok5iWjw4MFYtWoV/P39Vfp945tvvsHcuXPh5+cHGxsbSCQSXLlyBfPmzcPXX3+tsjpIGMHBwbCzs4Ofnx+0tbUxb948LFy4EPv37xe7NLWWmZmJvn37Qk9PD1KpFFeuXIGTkxOmTZuGhQsXKr2xZfPmzR88npubq5IGBLEUFRVh//79OH/+PPLz8xUmM6rj9M+UlBQMHjwY5cuXh42NDQoLC7Fnzx5s3boV27dvR7169QTLPnz4MJYvX45OnToJllHajBs3TuwSSI3FxcWJln3kyBEsXLgQ3bp1Q5cuXTB//nyYmZlhwoQJgr+OHjduHF69eoV79+6hR48ecHZ2ho+PDypVqoTg4GClZr39c2DhwoVK/dxUOt24cQO7du0S9Ofh2/Lz8z/6AFv58uXlD0apg969e+Onn35C27ZtFd6ABoC0tDSEhIRgypQpIlRHRJ9LW1sbbdu2Rdu2bTF37lycOnUKBw8ehJubG+rUqYNu3brBxcVF6Q9jiZVLRMLo378//Pz85MNRrl+/jpMnT2LFihWCP+ylidm8Zs24ZiIiIUlk776rQkREch/bAvNjb9SXRWvXrsWJEyewYsUKVKtWDcDr5sipU6eifv36gm73NH36dMTHx8PX11dhK/Svv/5a8CmcRKQ8jo6O7z0mkUhw9OhRwbJv3LiB/v3748WLF6hevbrChB6hsl++fAkfHx+cOHGiWObXX3+NwMBA6OvrC5JLqtGyZUts374d1tbWAF5vTd6xY0ecO3cOBgYGIlenvlq3bo2IiAhYWlpi/vz5qF69OkaPHo179+6hW7duuHjxomDZr169gq+vLywtLTFmzBgAgIODA9q3bw9fX1+1fDgkMDAQ4eHhkEqlJX5dq+PvvsOHD0fFihWxZMkS+f/T3NxcTJ48Gbm5uVizZo1g2S1btsSePXtKbLggok+TmZkJExMTSCQSZGZmfvBcIZsNGjdujF9//RWmpqYYO3Ysunbtiu7du+PKlSvw8fER9HffzMxM1KxZUz6hEgCePn0KAwMDJCYmwsbGRmlZ586d++Rz395dg8quwYMHY/jw4ejYsaNK8qRSKU6fPg1jY+P3nvPo0SO0b99ebaYnFxUVYfTo0bh48SL69OkDW1tbVK1aFdnZ2fjjjz+wa9cutG/fXulN1UQkjry8PERGRmLZsmXIyclR2fcysXKJ6N/z8PBASEgIKleuDABYunQpwsLCkJubC+D1LlDffvstZsyYUew1ALPLVq6Y2Zp4zUREqsImTCKiD+jSpQucnZ1L3AKzb9++avkkzsCBA3HlyhVoaWnBwsICOjo6uHHjBnJychS2G1P2G0mtWrVS2AodAM6cOYNJkybh999/V2oeEamnb7/9Fo8fP0aXLl1QoUIFheNCTuEEgIyMDKSkpEBHRwdWVlbc7klNfPnll/jtt9/kDygAgI2NDQ4ePIhatWqJWJl68/b2hoGBAXx9fREbG4udO3dix44dOHDgABYtWoRTp04Jlu3r64s//vgDAQEBaNGiBYDXkwuXLFkCR0dHTJ06VbBssdjZ2WHcuHEYNGiQ2KWojK2tLXbs2KGw9WlSUhIGDx6M+Ph4wbJnzpyJ6tWrw8fHR7CM0iguLg7JyckoLCyUr73ZaSAsLEzEyqgsatiwIU6dOgVjY2NIpdISt8eWyWSQSCSCNht07NgRP/30k3wavI6ODiZOnIg7d+7AxcUFCQkJgmU3bNgQp0+fhpGRUbH1mzdvomfPnkrNfvN3/LHbyUL/fZPqZGRkYPTo0XBxcUHt2rUV3gh1dXVVap5UKoWXl1eJr+PeePHiBTZu3KhWX2OFhYVYtWoVtm7diidPnsjXq1WrhiFDhsDLy4tvQhOVcQ8ePMDBgwdx6NAhJCQkwNzcHM7OzoIOPBAzl4g+X0kPpbx8+RJpaWmQyWSoW7euYA+Ea2I2r1l1uWJnExGpArcjJyL6AFVvgVka2Nvbw97eXpRsMbdCJyJhnDx5EsnJydDR0UG9evVgZ2cHbW1tQTMTExOxc+dOSKVSQXPex9LSEpaWlqJkk3CKiooUGju0tbVRVFQkUkWawcfHB56enti+fTsGDBiAVatWoVWrVnj58iW8vLwEzY6Li0NISAiaNm0qX/v6669haGiICRMmqGUTZm5uLtq3by92GSqlr6+PvLw8hfWS1pRh+vTp8o9zcnKwZ88e/P7777C0tFRorlDH7d+XLVuGNWvW4IsvvsDff/+NGjVq4NGjRygsLISLi4vY5VEZFBYWhipVqgB4vZOFWBwcHDBnzhwEBgaiWbNmCAgIwNdff43Y2FjUrFlT6Xlbt25FaGgogNdNpm5ubgrfQ/755x+lT/8UcqInlU6HDh3CzZs38fPPPysck0gkSm/CNDU1xcGDBz96nomJiVJzxaatrY2xY8di7NixyMjIwNOnT1G1alWYm5uz+ZKoDHu3AdLMzAzOzs6YO3euoPesxMolIuFUqFABTZo0Ybaa54qZrYnXTEQkBDZhEhF9gL6+PgoKCgAAFhYWSEtLg5OTE6ysrHD37l2RqxOG0BPiPsTT0xPz589X2Ap9+fLlGDx4sGh1EdG/988//2DYsGG4evUqKleujKKiImRnZ6NRo0bYuHGjfLsJIZiZmQnWPPMuR0fHEiculYRvWhP9eyYmJjhy5AhevHgBfX19REZGIiYmBjVr1kTXrl0Fzc7JySnx4RBDQ0M8f/5c0GyxtG/fHidPntSoSZh2dnYICgpCcHAwqlatCgDIysrCkiVLYGdnp/S8O3fuFPvzmymrH9tGWV1ER0dj9uzZGDRoEDp27Iht27ahYsWK8Pb25rbs9FlatWpV4seq9sMPP2Dq1KmIj4/HwIEDsXPnTvzvf/+Djo4OFi1apPS8Pn364MmTJ5DJZFi5ciW6du0KfX39Yufo6+ujS5cuSs391Onfr169UmouiSc8PBzjx4+Hp6cnypcvL3heXFyc4BmlHR/oIyr7Nm3ahEOHDuHy5cswNTWFs7MzZs+ejUaNGqllLhEp3/379+XbM3+Ish+60tRsXrPqcsXOJiISGrcjJyL6ADG3wBRTUlISwsLCkJGRgRUrVuDIkSOwtrZG69atBc0Vcyt0IlKumTNn4vLly/jxxx/lW7wmJSVh8uTJaNasGfz8/ATL/uOPP7Bo0SKMHz8elpaW0NEp/tyRMl+8//TTT5/chClmkzv9dyVtjbhmzRp8++238glcb/D/tfJ07twZwcHBorxpNGzYMFSrVg2BgYHyCb4ymQxz5sxBRkYGNm/erPKahLZu3TqEhISgffv2sLKygq6ubrHj6vi1ff/+fXz77bd49uwZLCwsIJFIkJGRgcqVK2PLli1sDFSyxo0b49ChQ6hduzZGjx4NV1dXdO3aFfHx8Zg5cyZ++eUXsUukMuzly5fYtGkTzp8/j/z8fIUts1U9KTMxMRHVqlWDlpaW/CFDIYSEhHx0+2YhPHv2DKtWrUJycjIKCwsBvP45mZ+fj9TUVJw/f16l9ZAwmjVrhn379qF27dpil0JEVGZIpVLo6urC3t7+o5O9lPkaS6xcIlIuqVT60fvNMpkMEokE165dY3YZzRUzWxOvmYhIVTgJk4joA8TcAlMsV69exYABA9C0aVNcvXoVeXl5uHbtGhYsWICQkBB06tRJsGwxt0InIuU6evQofvrpJ3kDJvD6Bfbs2bMxYcIEQZswhw0bhsLCQowaNarYC3ohXryPGzdOaZ+LSreStkasXr26wkMBEomEb2YoUW5urkqmLpVk4sSJcHd3R3x8PBo1agSJRIK//voLT58+lW8Bq262b98OY2NjJCYmIjExsdgxdf3arlmzJg4cOIDo6GikpqZCJpOhb9++6NGjR4mTUJUtOzsbsbGxSElJgZaWFho1aoSuXbuiXLlygmeLoUqVKsjJyQEAmJubIy0tDcDr77EPHjwQszRSA35+foiNjUWHDh1QvXp1lWY3bNgQp0+fhpGRkXztyy+/xJ07d9CjRw9cvHhRsOw3UzGfPHlS4nGhpofMmzcPp0+fRrt27RAbGwsXFxekp6cjMTEREydOFCSTVK979+44cOAARo0aJXYpRERlxpufvampqUhNTX3vecp+jSVWLhEpX3BwsMJD38xWv1wxszXxmomIVIFNmEREH1CvXj3RtsAUy5IlSzBs2DBMmDABtra2AAB/f39UqlRJ8CZM3vwhUh8FBQXF3oR+w9jYGNnZ2YJmb9y4UdDP/yFJSUlISUlBUVERgNeNn3l5eUhISMCCBQtEq4v+O26NKI5BgwZh3LhxGDRoEOrUqaPQkNmyZUvBshs3boz9+/djx44dSElJgY6ODrp3745Bgwbhiy++ECxXTJr6da6vr4+BAweqPDc9PR1DhgxBTk4OLCwsUFRUhJ07d+Lnn39GWFgYatasqfKahNamTRsEBQXB398fjRs3xurVqzFw4ED88ssvJf7eQPRvHD58GIsWLYKzs7NK8nbt2oV9+/YBeP07n7e3t8IE4YcPH6Jy5cqC1uHo6PjBSSJCTQ85deoUgoKC4ODggKSkJHh5eckfunrTYE1ln7GxMVauXInDhw+XuMtAYGCgSJUREZVeYr2u0tTXc0TqqFmzZjA2Nma2mueKma2J10xEpApswiQi+ojy5cvj/v37iI+Ph5aWFrp06SLYJInS4OrVq5gzZ47C+oABAxARESF4vlhboRORcjVq1Ajbt2/HrFmziq1v27YNDRs2FDS7VatWgn7+9wkPD5c3WkokEvkWmBKJBC1atBClJqKybsWKFQCA+fPnKxxTxbY0tWrVUvtpXo8fP/7ojc+8vDwcOXIE3bp1U1FVwurcuTN27doFQ0PDjzYvvTvtVpn8/f3RsGFDLFmyRD4BICsrCz/88AP8/f0REhIiWLZYJk+ejFGjRuGXX37BwIEDsXHjRrRt2xYAMG3aNJGro7JOS0sLX375pcrynJycim25XbNmTYWHBerXrw9XV1dB63h3m/WCggLcuHEDGzduxMyZMwXLzcnJkU+9t7KyQlJSEqRSKQYPHoyRI0cKlkuqFR8fj6+++goAcP/+fZGrISIiIiIiIiIqvdiESUT0AdnZ2Zg4cSJOnjxZrJmmW7duCAwMhJ6ensgVKp+urm6JU+oyMzNRoUIFQbPF3AqdiJTLx8cHHh4eSEhIQLNmzSCRSBAfH4+kpCSsW7dO6XlRUVGffK5Qb4Rv2bIFo0aNgre3Nzp16oQ9e/bg6dOnmDRpEjp37ixIJpG6E7IB7lPExcUhOTkZhYWF8rU3023DwsJErEx52rVrh1OnThVrxJw0aRJmzJghX/vnn38wadIktWnC7N27t7xRqk+fPqLVcenSJezcubPYFkxGRkaYMmWKKJM5VaFGjRqIiopCbm4u9PT0sG3bNpw8eRI1atSAjY2N2OVRGdelSxfs3bsXPj4+KsmrWrWqfApgXl4e/Pz8YGBgoJLst5X0AJK9vT1MTU2xevVqdOzYUZBcExMT3L17FyYmJrCwsEBSUhIAoEKFCnj27JkgmaR6mzdvFrsEIiIiIo1iamoKLS0tZqt5rpjZmnjNRESqwiZMIqIPCAgIQEZGBtauXQtbW1sUFRXhwoULmD9/PpYuXaqW01qcnJzw448/YtmyZfK19PR0BAQECPbmzRtiboVORMpla2uLrVu3YuPGjTh16hRkMhnq16+PWbNmoWnTpkrP+9TvxxKJRLAmzMzMTPTt2xd6enqQSqW4cuUKnJycMG3aNCxcuBBDhw4VJJdIndWqVUu07GXLlmHNmjX44osv8Pfff6NGjRp49OgRCgsL4eLiIlpdyvbmQaO3xcXFwcfHp1hjZknnlVVjx46Vf9y6dWs0bdpUYQvh3NxcHD9+XNA6vvjiC9y/fx/16tUrtp6dnS349sViu3z5MtLT09G9e3dYWlrC3Nxc7JJIDVSuXBmhoaE4ceIE6tatq/DQpJDbJv/xxx+4fv16qWomtra2RmJiomCfv2vXrpgyZQqCgoJgZ2cHHx8fNG3aFEeOHOG/6TLu3LlzsLW1hY6ODs6dO/fe8zjxn4iIiEj54uLi/vV/07lzZ4SHh//n+2iamM1rVl2u2NlERKrAJkwiog84evQoVq5ciZYtW8rXOnbsiHLlymHSpElq2YQ5depUDB8+HPb29pDJZOjTpw+ys7MhlUoxZcoUQbPF3gqdiJRn/vz5GDJkSLGGbiG9mbwjJn19fRQUFAAALCwskJaWBicnJ1hZWeHu3bsiV0dUtmRlZSE0NBTjx4+Hrq4uevTogRcvXsiP29vbl7hFuTJFR0dj9uzZGDRoEDp27Iht27ahYsWK8Pb2hpmZmaDZpdGHtuwuyzw8PHD69GkYGRkVW09LS8PkyZPxzTffCJY9depU+Pn5Ydq0aWjVqhV0dHRw5coV+Pn5YciQIcjMzJSfa2pqKlgdqpSdnQ0vLy8kJCRAIpGgbdu2WLJkCW7evImNGzeiZs2aYpdIZdjVq1fl2yY/fPhQpdl6enrQ0Sk9t1mzs7OxadMm1KhRQ7CMcePG4dWrV7h37x569OgBZ2dn+Pj4oFKlSggODhYsl4Tn7u6O06dPw9jYGO7u7pBIJCU+jCGRSHDt2jURKiQiIiKit2VlZaGoqIjZap4rZrYmXjMR0ecoPXcHiYhKIW1tbVSqVElhvVq1asjPzxehIuEZGBggIiICZ86cQWJiIoqKilC/fn20b99e8BHxYm6FTkTKFRUVBU9PT7HLUKkWLVpg9erV8PX1hVQqxc6dOzFy5EjEx8dDX19f7PKIyoyHDx/Czc0Nurq6GDRoEExMTHDnzh24ubmhatWqyMzMxK5du+Dq6ormzZsLVsejR4/g4OAAAJBKpbh8+TK6du2KCRMmYObMmRg/frxg2SSsTZs2YdGiRQBeT/hs27ZtiecJPdHuu+++A/B6MufbTa4ymQyLFi1CUFAQZDKZWjW5LF26FBKJBIcPH0bPnj0BAFOmTMEPP/yAoKAgLF26VOQKqSwTc9vknj17Yvjw4ejVqxfMzc1Rvnz5YseFmsQOvP4ZVVKjvEQiEfSBBT09PcycOVP+57lz58qbMJ8+fSpYLgnv6NGjMDQ0lH9MREREREREREQfxyZMIqIP8PT0xPz587FixQpUq1YNwOuJEsuXL8fgwYNFrk5Ybdq0QZs2bVSaKeZW6ESkXB07dsSWLVswduxYGBgYiF2OSvj4+MDT0xPbt2/HgAEDsGrVKrRq1QovX76El5eX2OURlRlr1qxBrVq1sGnTpmJNLEOGDJFPoHzw4AF27NghaBNmlSpVkJOTAwAwNzdHWloagNcTCR88eCBYLglv8ODBqFq1KoqKijBjxgxMnz692INXEokEFStWhJ2dnaB1hIeHC/r5S6Njx47hxx9/LDZNtm7dupgzZw5Gjx4tYmWkLgoKCvD48WMUFhYCeN3UnJeXh4SEBEEbIVevXg0A2Lhxo8IxiUQiaPaCBQsUmjB1dXXRtGlT1K5dW7DcpUuXYuLEicXWqlatipiYGAQEBODs2bOCZZOw3t7mj1v+ERERERERERF9GjZhEhF9wPHjx3HlyhV07twZFhYW0NHRwY0bN5CTk4Nr165h37598nPL8nQADw+PTz5XyDeLxdwKnYiUKzMzEwcOHEBYWBiMjY1Rrly5YsfL8vfM96lXrx6OHDmCFy9eQF9fH5GRkdi3bx9MTEzQtWtXscsjKjN+++03zJ49W2GK2NsGDRoEf39/Qeto06YNgoKC4O/vj8aNG2P16tUYOHAgfvnlF4Wtq8s6dd1q/H10dHTkDVESiQQuLi7Q09NTeR2tWrVSeabYsrKyUL16dYV1AwMDvHz5UoSKSJ2cOXMGkydPxuPHjxWOlS9fXtBGyKSkJME+98f06dNHlNwtW7ZAV1cX48aNA/B6grSvry/i4uJEq4mUo7TcIyIiIiIiIiIiKkvYhElE9AH29vawt7cXuwzBlTTZICYmBo6OjirdQlfMrdCJSLnatm373u1d1Vn58uXljWPGxsYatyU7kTLcv38f9evXL7bWunXrYk2ZDRo0wN9//y1oHZMnT8aoUaPwyy+/YODAgdi4caP8+9q0adMEzVY1f3//Ys3y+fn5WLx4sfz3wNzcXLFKE1zv3r2RlZWFjIwMFBUVASg+Oc/b21upedOnT//kcwMDA5WaXRo0adIEsbGxGDVqVLH18PBwfPnllyJVRepi6dKlaNy4Mdzd3TF27FgsWbIEmZmZCA4OFvXfU2ZmJkxNTZX6OUNCQj753LFjxyo1+43169dj5MiR0NbWRq1atbBgwQJUrlwZGzduVPmuGqRcb98jys3NRWxsLBo2bIimTZtCR0cHV65cwZUrV/C///1PxCqJiIiIiIiIiEoXNmESEX2AUG9WlDYlvSF16NAhTJ48udhWgaoixlboRKRcmvL9820ZGRmYN28ezp8/j/z8fIXj165dE6EqorLHwMBAvg34G2+2eX3j+fPnqFKliqB11KhRA1FRUcjNzYWenh62bduGkydPokaNGrCxsRE0W5Vatmyp0NBqa2uLJ0+e4MmTJ/K1Fi1aqLo0lThw4ABmzJiB3NxcSCQSyGQy+WTQWrVqKb0J886dO5903rv/BtTFxIkT4enpiYsXL6KgoACrVq1CWloaEhMTsWHDBrHLozIuOTkZkZGRaNCgAb788ktUrFgR7u7uqFixIjZs2AAnJyfBsu/cuYNFixYhOTlZYSv0rKwsJCYmKjVvz549n3SeRCIR7PfyZs2aYcOGDRg+fDhycnLg6emJ77//XmECPpU9b98jmjVrFoYOHarwAMry5cuRnp6u6tKIiIiIiIiIiEotNmESEX1EUlISwsLCkJGRgRUrVuDIkSOwtrZG69atxS5NLXCbKyL19ccff+Dq1at49eoVZDKZfF0ikSi9qeVdd+/eRUJCAvLy8hSOCbUV5dy5c5GZmYkffvgBlSpVEiSDSBNYW1vj5MmTsLKyeu85J06cEGxq3oMHD3D48GHo6enBwcEBNWrUAPB60u3XX38tSKaYNm/eLHYJolq9ejW6d++OESNGoF+/fggNDcXDhw/h5+cn32JXmT72952YmIjt27fjwIEDSs8uDZo1a4YdO3YgNDQU5ubmuHTpEurVq4eZM2fiq6++Ers8KuO0tbVhYGAAALCwsEBKSgratGkDOzs7LFq0SNBsf39/ZGRkwNnZGRs2bMCwYcOQkZGBw4cPY968eUrPi4uLU/rn/BSZmZnF/ly9enUEBATghx9+QJUqVYptBa/s6Z8kjgMHDmDv3r0K666uroK9riIiIiKif+fNw6TMVu9cMbM18ZqJiD4HmzCJiD7g6tWrGDBgAJo2bYqrV68iLy8P165dw4IFCxASEoJOnTqJXWKZV1q2Qici5Vq7di2WLl2KSpUqKTQkCt2EuXv3bvj6+sqnEL2bLdSbhRcvXkRYWBhsbW0F+fxEmqJ3795YtGgR7OzsIJVKFY4nJydj3bp1CAgIUHp2fHw8RowYgZcvXwIA9PX1sWLFCrRr107pWVQ63LhxAytWrICFhQUaNmyIrKwsODo6oqCgAKtXr0avXr0EryE3NxcHDhxAREQErly5Ai0tLXTp0kXwXLFIpVIEBQWJXQapIalUisOHD2Po0KGwtLTE+fPnMWTIENy/f1/w7Pj4eKxatQotW7bEb7/9BicnJ9jY2GDZsmU4ceIE+vXrJ1j2u42Rb0gkEujq6sLIyAhaWlpKyXJ0dCzxDTCZTIalS5di2bJl8onCnAKvHipXrozExERYWFgUW4+Pj4exsbE4RRERERFRMdra2szWgFwxszXxmomIPgebMImIPmDJkiUYNmwYJkyYIG+q8ff3R6VKldiEqSSlbSt0IlKOzZs3Y/z48RgzZozKs1etWoU+ffpg6tSp8mlIqmBoaMjmcSIl6NOnD3799Vf07dsXrq6uaNOmDYyMjPDkyROcO3cOUVFR6NSpE7755hulZwcHB8POzg5+fn7Q1tbGvHnzsHDhQuzfv1/pWVQ6lCtXDrq6ugBeT85LTU1Fhw4d0LhxY9y8eVPQ7OvXryMiIgLR0dF49uwZJBIJ3NzcMHr0aNSuXVvQbFUKCQn55HOF2jaZNMOIESMwduxY6OnpwcXFBcHBwRg5ciSSk5NhZ2cnaHZubq78323dunWRnJwMGxsbuLq6wt3dXdDs9zVGvvHm72Pu3LnQ09P7T1lhYWGcQqJh+vfvD19fX6Snp6Nx48aQyWQ4f/48tm7dismTJ4tdHhEREZHae/bsGW7evInc3FyFYy1btgQAnDt3jtllPFfMbE28ZiIiobAJk4joA65evYo5c+YorA8YMAAREREiVEREVDb8888/6NGjhyjZDx8+xLBhw1TagAkA7u7uWLp0KRYvXsztyIn+o59//hmhoaHYtm0bdu3aJV+vXr06xowZgxEjRgiSe+3aNWzfvh1ffPEFAGDGjBno2LEjsrOzVf49hVTDxsYGERERmDx5MqytrXHs2DF4eXkhLS1N3pypTAUFBfj1118RERGBc+fOQVdXFw4ODnB2dsaUKVMwdOhQtWrABF43YWppaaFmzZofPE8ikbAJk/4TR0dHREZGQltbGyYmJtiwYQNCQ0PRuXNnfP/994Jmm5mZISUlBSYmJrCwsJBPgSwqKkJOTo6g2QEBAQgKCsK4cePQokULAMClS5cQHByMQYMGoU6dOggJCcFPP/2ESZMm/aes1q1bK6NkKkO+++47aGtrY8uWLVi5ciUAwMTEBFOmTMHAgQNFro6IiIhIvUVFRWHOnDnIy8uDTCYrdkzo6fOamM1r1oxrJiISEpswiYg+QFdXF9nZ2QrrmZmZqFChgggVCWP69OkKa/n5+Vi8eLHCVLeSJlcSEb2refPmuHjxoiiNJFKpFDdv3oSlpaVKc0+cOIFLly6hdevWMDY2Vpg0dPToUZXWQ1SWaWlpYfjw4Rg+fDhu376Nx48fw9DQEGZmZkrbUrUkOTk5qFq1qvzPNWrUgK6uLp49e8YmTDXl7e0NLy8vGBkZoU+fPggJCYGLiwvu3buHbt26KT3vTVOvnZ0dAgMD4eTkJP/aUteJYv369cPhw4cBAC4uLnBxcYFUKhW5KlJXjRo1kn/csmVL+eQMofXp0wdTpkzBwoUL4eDgAHd3d5iamuL06dNo0KCBoNmbNm3C3Llz4ezsLF+TSqWoVq0afvrpJ0RHR6NatWqYMWPGf27CLOnewfvw3oH6GDVqFEaNGoUnT54AeL0DABEREREJb/ny5ejVqxeGDh2KcuXKMVtNc8XM1sRrJiISEpswiYg+wMnJCT/++COWLVsmX0tPT0dAQAA6duwoXmFKdufOHYU1W1tbPHnyRH6TnYjoY6KiouQfN27cGHPmzEFKSgosLCygra1d7FxXV1fB6hg2bBj8/Pxw+/Zt1K1bV6EZUqg341u3bs3pQEQCMDMzg5mZmUqyioqKFLZZ1dbWRlFRkUrySfWaN2+OX375BXl5eTA0NMS2bduwfft2mJiYCLKF8PPnz2FsbIyaNWtCX19fkGmbpc28efMwZ84cnD17FrGxsRgyZAiMjIzQvXt3uLi4wMLCQuwSqQwrLU2Bw4cPh46ODiQSCWxsbDB27FisWrUKJiYmWLx4sWC5AHDr1i00bNhQYd3a2hoZGRkAAAsLCzx+/Pg/Z5V076AkQk//JHGw+ZKIiIhItZ49e4Zhw4aJ8rpZE7N5zaolZjYRkVDYhElE9AFTp07F8OHDYW9vD5lMhj59+iA7OxtSqRRTpkwRuzyl2bx5s9glEJEamDZtmsLaunXrFNYkEomgTZg+Pj4AXm/NWFK2UNtYcAtVIqKyqUaNGvKPraysMGvWLMGyTp8+jdjYWOzevRsRERGoWLEiHB0d4ezsrNAArE60tbXRtm1btG3bFnPnzsWpU6dw8OBBuLm5oU6dOujWrRtcXFxgamoqdqlUxpSmpsChQ4fKPx4xYgRGjBgheCbw+vvW7t27FaZc7t69G+bm5gCAa9euFfte97k+du8gMTER27dvx4EDB/5zFhERERGRpuvSpQtOnDghSpOaJmbzmlVLzGwiIqFIZDKZTOwiiIhKuzNnziAxMRFFRUWoX78+2rdvL+hWmJqkpMklMTExcHR05FboRPRZ7t69+8HjtWrVEiz7r7/+woYNG5CcnAwdHR1YW1tjyJAhsLGxESyTiJRHKpXCy8sLFSpUkK+tWbMG3377LapUqVLsXDZeq4fHjx9j2bJlOH/+PPLz8/HuLZKjR48Klp2eno5du3YhJiYGjx49gkQigZubG4YPH64xN6Dz8vIQGRmJZcuWIScnR7AHJUhzvd0UeOHCBUGzLl26hM2bNyMlJQXa2tpo1KgRhg4dinr16gmae+rUKYwePRqNGzeGra0tioqKkJCQgKtXryIkJAQ1atSAh4cHPD098d133yk9Pzc3FwcOHEBERASuXLkCLS0tdOnSpdiOIkRERERE9O89evQILi4usLa2hpmZmcLDm0K+Z6aJ2bxmzbhmIiIhcRImEdEnaNOmDdq0aSN2GWqJW6ETqZ+XL1+ifPnyxV40p6amolatWqhYsaLg+R9qsnz16pVgufHx8fD09ET9+vXRrl07FBYW4sKFCxg4cCDCwsLQvHlzwbKJSDlMTU1x8ODBYmvVq1dXaMSTSCRswlQTvr6+iI+Ph6urKypVqqTSbCsrK0ydOhU//PADjh8/jr179yIqKgp79uyBvb091q9fr9J6VOnBgwc4ePAgDh06hISEBJibmwuy/Ttppvc1BQopLi4OY8eOhY2NDezt7VFUVIRLly6hT58+2LhxI1q0aCFYdrt27RAZGYmwsDCcOnUKOjo6kEqlmD9/PurVq4crV65gypQp+N///qfU3OvXryMiIgLR0dF49uyZvJF89OjRqF27tlKzSDw3btzQmAcDiIiIiEqbwMBA5OTkIC8v76ODB5hddnPFzNbEayYiEhInYRIRvcPDw+OTzw0PDxewEiKisicqKgqBgYFYv349mjRpIl/38vJCQkIC5s+fD2dnZ0FrePbsGVatWoXk5GQUFhYCAGQyGfLz85Gamorz588Lkjtw4EBIpVL4+voWW/fz80NaWtpHt28kIiLVa9q0KVauXIm2bduKXQoAICsrC9HR0dizZw9iYmLELkep3m28NDMzg7OzM5ydnSGVSsUuj9SAmE2BPXr0QMeOHRW2BF+0aBEuXLiAHTt2CJqvKgUFBfj1118RERGBc+fOQVdXFw4ODnB2dsaUKVMQFRUFa2trscskJWrXrh1+/vlnTvYnIiIiEoGtrS2WL18OBwcHZqtxrpjZmnjNRERC4iRMIqJ3lDRB7X3bYxMR0f85c+YMZsyYgT59+sDExKTYMV9fX6xbtw4//PADqlevLug0oHnz5uH06dNo164dYmNj4eLigvT0dCQmJmLixImC5f7111/w9/dXWB88eDD69u0rWC4REX2+ihUrKvzMEpORkRE8PT3h6ekpdilKs2nTJhw6dAiXL1+GqakpnJ2dMXv2bDRq1Ejs0kgNfKwpcOjQoSqZynjr1i24ubkprPfv3x/btm0TPF9VOnbsiOzsbNjZ2SEwMBBOTk4wMDAAAEyePFnk6kgIenp60NHhWwhEREREYtDX10edOnWYrea5YmZr4jUTEQmJd1CIiN4RGBiosHbo0CFMnjwZZmZmIlRERFQ2rFu3DoMHD8aMGTMUjpmbm8Pf3x8ymQyrV68WdIvVU6dOISgoCA4ODkhKSoKXlxekUilmz56NtLQ0wXINDQ3x+PFj1K1bt9j648ePoaenJ1guERF9PldXV2zYsAHz5s2Dtra22OWopYULF0JXVxft27eXT8k+duwYjh07pnDu2LFjVV0elXGlpSmwUaNGOHPmjMK2zVevXoWVlZXK6hDa8+fPYWxsjJo1a0JfXx+6urpil0QC69mzJ4YPH45evXrB3Nwc5cuXL3bc1dVVnMKIiIiINMCoUaOwfPlyBAQEyF/nMFv9csXM1sRrJiISEpswiYiIiEgpEhMTMW3atA+eM2DAAIwcOVLQOnJyclC/fn0AgJWVFZKSkiCVSjF48GBBszt16oT58+dj2bJl8jfb09LSEBAQgE6dOgmWS0REn+/Ro0c4ePAgjh07hjp16ig0zYeHh4tUmfowNTUFAKSmpiI1NfW950kkEjZh0r9WWpoCe/bsicWLFyMjIwOtWrWCjo4Orly5grCwMPTv3x9RUVHyc8ty09rp06cRGxuL3bt3IyIiAhUrVoSjoyOcnZ0hkUjELo8EsHr1agDAxo0bFY5JJJIy/fVMREREVNrFxcUhPj4ednZ2MDY2VphQfvToUWarQa6Y2Zp4zUREQmITJhEREREpRV5ensJklHdVqVIFr169ErQOExMT3L17FyYmJrCwsEBSUhIAoEKFCnj27JlguT4+PvD09ET37t1RqVIlSCQS/PPPP6hfvz6mTJkiWC4REX0+bW1tdO/eXewy1FpcXJzYJZAaKy1NgXPnzgXwunH73ebtDRs2yD8u601rBgYG6NevH/r164f09HTs2rULMTEx2L9/PyQSCTZt2oThw4crTASlsuvNaykiIiIiUr3mzZujefPmzFbzXDGzNfGaiYiEJJHJZDKxiyAiKu1sbW2xb98+bkdORPQBbm5u8PDwQK9evd57TnR0NNavX4+YmBjB6vjxxx9x4MABBAUFIT8/Hz4+PvDz88ORI0eQmpqK6OhowbKLiopw8uRJpKamQiaToX79+mjXrh23uCUiKqX27dsHBwcHVKlSRexSiOg/ersp8NGjR5BIJHBzc9OIpsCsrCxkZGSgqKgIACCTyZCXl4eEhAR4e3sLml1YWIjjx49j7969OH78OIqKimBvb4/169cLmkuqdf36dSQnJ0NXVxdWVlawtLQUuyQiIiIiIiIiolKFTZhERJ+ATZhERB8XFhaG8PBwbN++HV988YXC8YcPH+Lbb7+Fm5uboG8G5+XlYfHixbCxsUGPHj0wd+5cREREoFKlSggODkabNm0EyyYiorKlVatW2L59O6ysrMQuhYiUpDQ0BWZlZeHPP/9E48aNUbt2bUGzDhw4gBkzZiAvLw/A6wbMN1NAa9WqhSNHjgia/7asrCxER0djz549gj50RaqTl5eHH374Ab/++qt8TSKRoFOnTli+fDn09PRErI6IiIhI/YSEhMDLywsVKlRASEjIe8+TSCRKv8euidm8Zs24ZiIiVWETJhHRO6ZPn66wFhMTA0dHR+jr6xdbDwwMVFVZRESlXmFhITw8PJCSkoK+ffuiadOmqFy5Mp4+fYpLly5hz549MDc3x5YtWz66bbmyPX36FJUqVVL6REoPD49POk8ikSAsLEyp2URE9N/169cPQ4cORbdu3cQuhYgEoKqmwJSUFIwbNw7+/v6QSqVwdnbGo0ePoKenh7Vr18LOzk6w7B49esDGxgYjRoxAv379EBoaiocPH8LPzw8TJ0784JR6oo9ZtGgRDh48iDlz5qBly5YoLCzEuXPn4O/vjx49emDSpElil0hERESkVhwdHbF7924YGhrC0dHxvedJJBIcPXqU2WU0V8xsTbxmIiJVYRMmEdE73N3dP/nczZs3C1gJEVHZk5eXh+DgYERGRuLZs2fy9WrVqsHNzQ1jxoxRSQNmWloaUlJS5BOB3ubq6qq0nJIa998WHx+P27dvw8DAAPHx8UrLJSIi5Zg5cyb27t0LqVQKCwsLlCtXrthxPnRFRJ/Cy8sL2traCAwMxNGjR7F06VJER0dj27Zt+OOPPxARESFYdpMmTRAdHY26detiyJAh8PLyQocOHfDrr79i9erV2LNnj2DZpP7at28Pf39/ODg4FFs/duwY/Pz8cPz4cXEKIyIiIiIiIiIqZXTELoCIqLRhYyUR0efT09PDDz/8AB8fH9y+fRvPnj2DkZERzMzM5NsiCm3t2rVYunRpicckEolSmzDf15yTnZ2NhQsX4vbt27C3t4e/v7/SMomISHlu3bqF5s2bAwD+/vtvkashorLq4sWLiIyMhLGxMU6ePAkHBwfUqFEDffv2FXwaerly5aCrqwsAsLCwQGpqKjp06IDGjRvj5s2bgmaT+svOzoa5ubnCuqWlJbKyskSoiIiIiEgzZWVlIT4+HtWqVUOzZs2Yraa5YmZr4jUTESkbmzCJiIiISOl0dHRgaWkpSnZYWBi8vb0xatQo6OnpqTz/9OnTmD17Nv755x/4+fmhf//+Kq+BiIg+DR/AIiJl0NLSgp6eHgoLC3H27FnMnDkTAJCTkyP4FHgbGxtERERg8uTJsLa2xrFjx+Dl5YW0tDR5cybR56pfvz4OHTqE0aNHF1uPjY0V7fUeERERkbpbuXIlwsPDsXPnTpibm+PChQsYOXIksrOzAQBt2rTBqlWrBHmtoYnZvGbNuGYiIlXQErsAIiIiIiJlys/PR8+ePVXegJmTk4PZs2fDy8sL5ubm2LdvHxswiYjKgFevXiEqKgpLly7F06dP8eeff3K6FxH9K02bNsXq1asRHByMly9fokOHDnjw4AF+/PFHfPXVV4Jme3t7Y+vWrdiwYQO6d++Ov/76Cy4uLvDx8YGTk5Og2aT+xowZg+DgYPj4+CA8PBybN2/G+PHjERISglGjRoldHhEREZHa2bFjB9asWYP+/fvD2NgYADBjxgxUrFgRBw4cwIkTJ5CTk4M1a9YwuwznipmtiddMRKQqbMIkIiIiIrXSq1cv7Ny5U6WZp0+fRo8ePRAbG4u5c+di48aNMDU1VWkNRET07z169Ajdu3fH3LlzsX79ejx//hyhoaHo0aMH0tLSxC6PiMqI2bNn49q1a9i2bRtmzJgBIyMjrF27FtevX8fEiRMFzW7evDl++eUXdOnSBYaGhti2bRvatGkDb29v+Pr6CppN6q9jx44IDg5GZmYmli5diiVLlsg/7tatm9jlEREREamdyMhITJs2DRMnToSBgQEuX76MGzduwMPDA1ZWVqhRowbGjBmD2NhYZpfhXDGzNfGaiYhUhduRExEREZFaGT58OHr27InY2FjUrl0bEomk2PHw8HClZeXk5GDRokWIjIxEmzZtEBAQABMTE6V9fiIiEtbChQthbW2NmJgY2NvbAwAWLVqEiRMnIigoCGvXrhW5QiIqC8zNzbFnz55ia7169cKLFy8wYMAAXLhwQdD8GjVqyD+2srLCrFmzBM0jzeLk5MSpqkREREQqkp6eLr8/AQBnz56FRCKBg4ODfM3a2hqZmZnMLsO5YmZr4jUTEakKmzCJiIiISK28edP5q6++QoUKFQTN6tGjB+7duwczMzM0a9YMu3fvfu+5Y8eOFbQWIiL6986ePYu1a9cW+3lRpUoVTJ48GR4eHiJWRkRlUW5uLg4cOICIiAhcuXIFWlpa+PrrrwXNvH37NpYsWYLU1FTk5uYqHD969Kig+aR+QkJC4OXlhQoVKiAkJOSD5+rp6aFmzZpwcnJCxYoVVVQhERERkXp7e6jA+fPnYWRkhHr16snXcnJyBLvvrYnZvGbNuGYiIlVgEyYRERERqZU///wTmzZtgq2trUryTExMUFBQoDD96G0SiYRNmEREpdCHbuwWFBSouBoiKquuX7+OiIgIREdH49mzZ5BIJHBzc8Po0aNRu3ZtQbOnTJmCv//+G87OzihXrpygWaQZ9uzZg0GDBqFChQoffI0DAIWFhXj8+DEOHDiANWvWqKhCIiIiIvXVoEEDnDt3Dubm5vjnn3/wxx9/4Jtvvil2zsGDB1G/fn1ml+FcMbM18ZqJiFSFTZhEREREpFaqVasGfX19lWTFxcWpJIeIiITRsmVLbN26tdjWvfn5+Vi5ciWaNWsmYmVEVNoVFBTg119/RUREBM6dOwddXV04ODjA2dkZU6ZMwdChQwVvwASAa9euYevWrWjUqJHgWaQZ3n6N8ymvd/7880+MGjVKyJKIiIiINMagQYPg6+uL5ORkXLx4EXl5eXB3dwcAPHz4EDExMdiwYQMCAgKYXYZzxczWxGsmIlIVNmESERERkVqZNGkS/P39MWfOHFhYWEBbW1vskoiIqJSaOnUqBg0ahD///BP5+fmYO3curl+/jufPn2PLli1il0dEpVjHjh2RnZ0NOzs7BAYGwsnJCQYGBgCAyZMnq6wOS0tLvHjxQmV5RACQl5eHy5cvo0WLFrC2toaPj4/YJRERERGphR49eiA3Nxfbt2+HlpYWli9fjsaNGwMA1q5di4iICIwYMQK9evVidhnOFTNbE6+ZiEhVJDKZTCZ2EUREREREytKlSxdkZmaisLCwxOPXrl1TcUVERFSaPXz4ENu2bcO1a9dQVFSEevXqYeDAgSqZYEdEZddXX30FY2NjdOjQAW3btkWHDh3k24E3atQI0dHRsLa2FryOS5cuYe7cuXB3d0ft2rWhpaVV7HjLli0Fr4HUV2JiImbNmoXk5GQUFRUpHOdrKyIiIiLVefDgAfT09GBoaMhsNc4VM1sTr5mISJnYhElEREREamXv3r0fPN67d28VVUJERKVdSEgIvLy8UKFChWLr2dnZWLFiBWbOnClSZURU2mVnZyM2Nha7d+9GQkICKlasCEdHRzg7O2P8+PGIiopSSRNmZGQk/Pz8UFBQoHBMIpGwSY7+E3d3d+Tm5qJv377w9/fHtGnTcOvWLWzduhVBQUFwdnYWu0QiIiIiIiIiolKBTZhEREREREREpDHS09ORlZUFAPDw8MBPP/2EKlWqFDsnJSUFQUFBSEhIEKNEIipj0tPTsWvXLsTExODRo0eQSCRwc3PD8OHDYWFhIWi2g4MDOnbsCA8PD5QvX17heK1atQTNJ/Vma2uLsLAw2NjYoH///pg8eTJatGiBTZs24cSJE9i4caPYJRIRERERERERlQpswiQiIiIitRISEvLB42PHjlVRJUREVBodP34co0ePhkQiAQC877aIm5sbAgICVFkaEZVxhYWFOH78OPbu3Yvjx4+jqKgI9vb2WL9+vWCZTZs2xf79+1G7dm3BMkhzffXVVzh06BBMTEwwbdo02NjYYODAgbh9+zb69euHM2fOiF0iEREREREREVGpoCN2AUREREREyrRnz55ify4oKEBWVhZ0dXVha2srUlVERFRadOzYEXFxcSgqKoKTkxMiIyNhZGQkPy6RSFCxYkVUrVpVvCKJqEzS1tZG586d0blzZ2RlZSE6Olrhd1Nl69ChA86ePYu+ffsKmkOaqW7dujh37hx69uwJc3NzXLlyBQDw/Plz5OXliVwdEREREREREVHpwSZMIiIiIlIrcXFxCmvZ2dmYOnUqWrduLUJFRERU2piamgIAjh49ClNTU/lUTCIiZTEyMoKnpyc8PT0FzWnVqhUCAgJw8uRJWFpaQken+O1eToGn/2Lw4MGYOXMmAKBLly7o1asXypcvjwsXLqBp06biFkdEREREREREVIpwO3IiIiIi0ggpKSkYNWoUjh07JnYpRERUShQVFWH//v04f/488vPzFbYmDwwMFKkyIqJP4+jo+N5jEokER48eVWE1pI6OHDmCqlWrokWLFjhw4ADWrFkDExMTzJ49G7Vr1xa7PCIiIiIiIiKiUoFNmERERESkERITEzFgwAAkJCSIXQoREZUSgYGBCA8Ph1QqhYGBgcLxzZs3i1AVERERERERERERERGVJdyOnIiIiIjUSlRUVLE/y2QyPH/+HDt27ICtra04RRERUakUHR2NWbNmYdCgQWKXQkT0nzx+/Bi5ubkK66ampiJUQ2VZSEjIJ5/L7e6JiIiIiIiIiF7jJEwiIiIiUitSqVRhTUdHB82aNYOfnx8sLS1FqIqIiEojW1tbREdHo06dOmKXQkT0WX777TdMnz4dWVlZxdZlMhkkEgmuXbsmUmVUVkmlUmhpaaFmzZofPI/b3RMRERERERER/R9OwiQiIiIitZKUlCR2CUREVEa0b98eJ0+e5CRMIiqzAgICYGNjg4EDB6JcuXJil0NqoF+/fjh8+DAAwMXFBS4uLiU+6EZERERERERERP+HkzCJiIiIiIiISCOtW7cOISEhaN++PaysrKCrq1vsOLdZJaLSrmnTptizZw/q1q0rdimkRgoLC3H27FnExsbiyJEjMDIyQvfu3eHi4gILCwuxyyMiIiIiIiIiKnXYhElEREREZZ6Hh8cnnxseHi5gJUREVJY4Ojq+9xi3WSWismD06NFwcXFBjx49xC6F1FR+fj5OnTqFgwcP4ujRo6hTpw66desGFxcXmJqail0eEREREREREVGpwCZMIiIiIirzpk+frrAWExMDR0dH6OvrF1sPDAxUVVlERERERIJ68OAB+vbtC3t7e9SuXRsSiaTYcU70JWXKy8tDZGQkli1bhpycHFy7dk3skoiIiIiIiIiISgU2YRIRERGRWrK1tcW+fftgZmYmdilERERERILw9/fHli1bYGRkhPLlyxc7xom+pCwPHjzAwYMHcejQISQkJMDc3BzOzs4YP3682KUREREREREREZUKOmIXQERERERERESkKh4eHp98bnh4uICVEBH9d1FRUViwYAH69OkjdimkZt5tvDQzM4OzszPmzp0LqVQqdnlERERERERERKUKmzCJiIiIiIiISGPUqlVL7BKIiJRGW1sbLVu2FLsMUiObNm3CoUOHcPnyZZiamsLZ2RmzZ89Go0aNxC6NiIiIiIiIiKjU4nbkRERERKSWuB05EREREam7ZcuWIScnBzNnzoREIhG7HFIDUqkUurq6sLe3R5MmTT547tixY1VUFRERERERERFR6cZJmERERERERERERERl0N9//42YmBgcOnQIderUgY5O8du94eHhIlVGZZWpqSkAIDU1Fampqe89TyKRsAmTiIiIiIiIiOj/YxMmEREREZV506dPV1jLz8/H4sWLoa+vX2w9MDBQVWUREREREQlKJpOhe/fuYpdBaiQuLk7sEoiIiIiIiIiIyhxuR05EREREZZ67u/snn7t582YBKyEiIiIiIiIiIiIiIiIiIk3CJkwiIiIiIiIiIiKiMiorKwsZGRkoKioC8Ho6Zl5eHhISEuDt7S1ydUREREREREREROqPTZhEREREREREREREZdCBAwcwY8YM5ObmQiKRQCaTQSKRAABq1aqFI0eOiFwhERERERERERGR+tMSuwAiIiIiIiIiIiIi+vdWr16N7t2749ChQ6hUqRJ27dqFlStX4osvvsC4cePELo+IiIiIiIiIiEgj6IhdABERERERERERERH9ezdu3MCKFStgYWGBhg0bIisrC46OjigoKMDq1avRq1cvsUskIiIiIiIiIiJSe5yESURERERERERERFQGlStXDrq6ugAACwsLpKamAgAaN26MmzdvilkaERERERERERGRxmATJhEREREREREREVEZZGNjg4iICACAtbU1Tp8+DQBIS0uTN2cSERERERERERGRsLgdOREREREREREREVEZ5O3tDS8vLxgZGaFPnz4ICQmBi4sL7t27h27duoldHhERERERERERkUaQyGQymdhFEBEREREREREREdG/9+DBA+Tl5cHMzAzp6enYvn07TExM4O7uDj09PbHLIyIiIiIiIiIiUntswiQiIiIiIiIiIiIiIiIiIiIiIiIi+gzcjpyIiIiIiIiIiIioDMnKykJoaCjGjx8PXV1d9OjRAy9evJAft7e3x/z580WskIiIiIiIiIiISHNoiV0AEREREREREREREX2ahw8folevXoiNjcWjR48AAHfu3EGnTp3Qu3dvtG7dGrt27cL58+dFrpSIiIiIiIiIiEgzcBImERERERERERERURmxZs0a1KpVC5s2bUL58uXl60OGDIGZmRkA4MGDB9ixYweaN28uVplEREREREREREQag5MwiYiIiIiIiIiIiMpc3m0TAAACU0lEQVSI3377Dd99912xBsx3DRo0CPHx8SqsioiIiIiIiIiISHOxCZOIiIiIiIiIiIiojLh//z7q169fbK1169bFmjIbNGiAv//+W9WlERERERERERERaSRuR05ERERERERERERURhgYGCAnJ6fY2urVq4v9+fnz56hSpYoqyyIiIiIiIiIiItJYnIRJREREREREREREVEZYW1vj5MmTHzznxIkT+PLLL1VUERERERERERERkWZjEyYRERERERERERFRGdG7d2+sWrUKSUlJJR5PTk7GunXr4ObmpuLKiIiIiIiIiIiINJNEJpPJxC6CiIiIiIiIiIiIiD7N6NGjcerUKbi6uqJNmzYwMjLCkydPcO7cOURFRaFTp05YunSp2GUSERERERERERFpBDZhEhEREREREREREZUhRUVFCA0NxbZt25CZmSlfr169Otzd3TFixAhIJBIRKyQiIiIiIiIiItIcbMIkIiIiIiIiIiIiKqNu376Nx48fw9DQEGZmZtDS0hK7JCIiIiIiIiIiIo3CJkwiIiIiIiIiIiIiIiIiIiIiIiIios/Ax6KJiIiIiIiIiIiIiIiIiIiIiIiIiD4DmzCJiIiIiIiIiIiIiIiIiIiIiIiIiD4DmzCJiIiIiIiIiIiIiIiIiIiIiIiIiD4DmzCJiIiIiIiIiIiIiIiIiIiIiIiIiD4DmzCJiIiIiIiIiIiIiIiIiIiIiIiIiD4DmzCJiIiIiIiIiIiIiIiIiIiIiIiIiD4DmzCJiIiIiIiIiIiIiIiIiIiIiIiIiD7D/wM9Tt6sht28iwAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Running Univariate Analyses...\n", - "INFO: Plotting top significant 20 features.\n", - "INFO: ###################################################\n", - "INFO: Significant Univariate Associations:\n", - "INFO: Alkaline phosphatase (U/L): (p-val = 8.425494437393163e-07)\n", - "INFO: Performance Status*: (p-val = 1.8787043290235831e-06)\n", - "INFO: Alpha-Fetoprotein (ng/mL): (p-val = 3.7632257667465082e-06)\n", - "INFO: Haemoglobin (g/dL): (p-val = 6.806983230077955e-05)\n", - "INFO: Albumin (mg/dL): (p-val = 0.0002097286566980117)\n", - "INFO: Symptoms: (p-val = 0.0006092985105592953)\n", - "INFO: Ascites degree*: (p-val = 0.0010580963945994142)\n", - "INFO: Direct Bilirubin (mg/dL): (p-val = 0.0013544764761447027)\n", - "INFO: Aspartate transaminase (U/L): (p-val = 0.0016188344745582482)\n", - "INFO: Ferritin (ng/mL): (p-val = 0.0019988859548087426)\n", - "INFO: Liver Metastasis: (p-val = 0.002993588224869906)\n", - "INFO: Iron: (p-val = 0.009131914019954513)\n", - "INFO: Portal Vein Thrombosis: (p-val = 0.01174304115542567)\n", - "INFO: Gamma glutamyl transferase (U/L): (p-val = 0.019120768577902517)\n", - "INFO: Major dimension of nodule (cm): (p-val = 0.028160240930633438)\n", - "INFO: Sim_Text_Cat_3_Category 2: (p-val = 0.02839459637094445)\n", - "INFO: Sim_Cat_4_3: (p-val = 0.03230524575323043)\n", - "INFO: International Normalised Ratio*: (p-val = 0.03298377968646775)\n", - "INFO: Total Bilirubin(mg/dL): (p-val = 0.033298074732187495)\n", - "INFO: Missing_Sim_Miss_0.6: (p-val = 0.05829721364630114)\n", - "INFO: Generating Univariate Analysis Plots...\n" - ] - } - ], - "source": [ - "from streamline.runners.dataprocess_runner import DataProcessRunner\n", - "dpr = DataProcessRunner(data_path, output_path, experiment_name, \n", - " exclude_eda_output=exclude_eda_output,\n", - " class_label=class_label, instance_label=instance_label, \n", - " match_label=match_label, n_splits=n_splits, \n", - " partition_method=partition_method,\n", - " ignore_features=ignore_features, \n", - " categorical_features=categorical_feature_headers,\n", - " quantitative_features=quantitiative_feature_headers,\n", - " top_features=top_uni_features,\n", - " categorical_cutoff=categorical_cutoff, sig_cutoff=sig_cutoff,\n", - " featureeng_missingness=featureeng_missingness,\n", - " cleaning_missingness=cleaning_missingness,\n", - " correlation_removal_threshold=correlation_removal_threshold,\n", - " random_state=random_state, show_plots=True)\n", - "dpr.run(run_parallel=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "BJBtvpO-CxMU" - }, - "source": [ - "## Phase 2: Scaling and Imputation\n", - "After cell runs, you will see:\n", - "* No output other than code progress updates" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "xRPCoPEG-FZD", - "outputId": "64d9e8d2-65e9-474b-e2a2-0d6251a4d970" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Preparing Train and Test for: hcc_data_CV_0\n", - "INFO: Imputing Missing Values...\n", - "INFO: Scaling Data Values...\n", - "INFO: Saving Processed Train and Test Data...\n", - "INFO: hcc_data Phase 2 complete\n", - "INFO: Preparing Train and Test for: hcc_data_CV_1\n", - "INFO: Imputing Missing Values...\n", - "INFO: Scaling Data Values...\n", - "INFO: Saving Processed Train and Test Data...\n", - "INFO: hcc_data Phase 2 complete\n", - "INFO: Preparing Train and Test for: hcc_data_CV_2\n", - "INFO: Imputing Missing Values...\n", - "INFO: Scaling Data Values...\n", - "INFO: Saving Processed Train and Test Data...\n", - "INFO: hcc_data Phase 2 complete\n", - "INFO: Preparing Train and Test for: hcc_data_custom_CV_0\n", - "INFO: Imputing Missing Values...\n", - "INFO: Scaling Data Values...\n", - "INFO: Saving Processed Train and Test Data...\n", - "INFO: hcc_data_custom Phase 2 complete\n", - "INFO: Preparing Train and Test for: hcc_data_custom_CV_1\n", - "INFO: Imputing Missing Values...\n", - "INFO: Scaling Data Values...\n", - "INFO: Saving Processed Train and Test Data...\n", - "INFO: hcc_data_custom Phase 2 complete\n", - "INFO: Preparing Train and Test for: hcc_data_custom_CV_2\n", - "INFO: Imputing Missing Values...\n", - "INFO: Scaling Data Values...\n", - "INFO: Saving Processed Train and Test Data...\n", - "INFO: hcc_data_custom Phase 2 complete\n" - ] - } - ], - "source": [ - "from streamline.runners.imputation_runner import ImputationRunner\n", - "ir = ImputationRunner(output_path, experiment_name, \n", - " scale_data=scale_data, impute_data=impute_data,\n", - " multi_impute=multi_impute, overwrite_cv=overwrite_cv, \n", - " class_label=class_label, instance_label=instance_label, \n", - " random_state=random_state)\n", - "ir.run(run_parallel=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "kuAxzygTETa2" - }, - "source": [ - "## Phase 3: Feature Importance Evaluation\n", - "After cell runs, you will see:\n", - "* No output other than code progress updates" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "id": "2EF0mLemYKom" - }, - "outputs": [], - "source": [ - "feat_algorithms = []\n", - "if do_mutual_info:\n", - " feat_algorithms.append(\"MI\")\n", - "if do_multisurf:\n", - " feat_algorithms.append(\"MS\")" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "u1X2jWFXETAw", - "outputId": "da2766f7-f978-48f9-c763-399db73858fb", - "scrolled": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data_CV_0_Train\n", - "INFO: Prepared Train and Test for: hcc_data_CV_0\n", - "INFO: Running Mutual Information...\n", - "INFO: Sort and pickle feature importance scores...\n", - "INFO: hcc_data CV0 phase 3 mutual_information evaluation complete\n", - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data_CV_1_Train\n", - "INFO: Prepared Train and Test for: hcc_data_CV_1\n", - "INFO: Running Mutual Information...\n", - "INFO: Sort and pickle feature importance scores...\n", - "INFO: hcc_data CV1 phase 3 mutual_information evaluation complete\n", - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data_CV_2_Train\n", - "INFO: Prepared Train and Test for: hcc_data_CV_2\n", - "INFO: Running Mutual Information...\n", - "INFO: Sort and pickle feature importance scores...\n", - "INFO: hcc_data CV2 phase 3 mutual_information evaluation complete\n", - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data_CV_0_Train\n", - "INFO: Prepared Train and Test for: hcc_data_CV_0\n", - "INFO: Running MultiSURF...\n", - "INFO: Sort and pickle feature importance scores...\n", - "INFO: hcc_data CV0 phase 3 multisurf evaluation complete\n", - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data_CV_1_Train\n", - "INFO: Prepared Train and Test for: hcc_data_CV_1\n", - "INFO: Running MultiSURF...\n", - "INFO: Sort and pickle feature importance scores...\n", - "INFO: hcc_data CV1 phase 3 multisurf evaluation complete\n", - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data_CV_2_Train\n", - "INFO: Prepared Train and Test for: hcc_data_CV_2\n", - "INFO: Running MultiSURF...\n", - "INFO: Sort and pickle feature importance scores...\n", - "INFO: hcc_data CV2 phase 3 multisurf evaluation complete\n", - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data_custom_CV_0_Train\n", - "INFO: Prepared Train and Test for: hcc_data_custom_CV_0\n", - "INFO: Running Mutual Information...\n", - "INFO: Sort and pickle feature importance scores...\n", - "INFO: hcc_data_custom CV0 phase 3 mutual_information evaluation complete\n", - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data_custom_CV_1_Train\n", - "INFO: Prepared Train and Test for: hcc_data_custom_CV_1\n", - "INFO: Running Mutual Information...\n", - "INFO: Sort and pickle feature importance scores...\n", - "INFO: hcc_data_custom CV1 phase 3 mutual_information evaluation complete\n", - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data_custom_CV_2_Train\n", - "INFO: Prepared Train and Test for: hcc_data_custom_CV_2\n", - "INFO: Running Mutual Information...\n", - "INFO: Sort and pickle feature importance scores...\n", - "INFO: hcc_data_custom CV2 phase 3 mutual_information evaluation complete\n", - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data_custom_CV_0_Train\n", - "INFO: Prepared Train and Test for: hcc_data_custom_CV_0\n", - "INFO: Running MultiSURF...\n", - "INFO: Sort and pickle feature importance scores...\n", - "INFO: hcc_data_custom CV0 phase 3 multisurf evaluation complete\n", - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data_custom_CV_1_Train\n", - "INFO: Prepared Train and Test for: hcc_data_custom_CV_1\n", - "INFO: Running MultiSURF...\n", - "INFO: Sort and pickle feature importance scores...\n", - "INFO: hcc_data_custom CV1 phase 3 multisurf evaluation complete\n", - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data_custom_CV_2_Train\n", - "INFO: Prepared Train and Test for: hcc_data_custom_CV_2\n", - "INFO: Running MultiSURF...\n", - "INFO: Sort and pickle feature importance scores...\n", - "INFO: hcc_data_custom CV2 phase 3 multisurf evaluation complete\n" - ] - } - ], - "source": [ - "from streamline.runners.feature_runner import FeatureImportanceRunner\n", - "f_imp = FeatureImportanceRunner(output_path, experiment_name, \n", - " class_label=class_label, \n", - " instance_label=instance_label,\n", - " instance_subset=instance_subset, \n", - " algorithms=feat_algorithms, \n", - " use_turf=use_TURF, turf_pct=TURF_pct, \n", - " random_state=random_state)\n", - "f_imp.run(run_parallel=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "2udkSXOYEx21" - }, - "source": [ - "## Phase 4: Feature Selection\n", - "After cell runs, for each target dataset and each feature importance algorithm you will see:\n", - "* Top feature importance scores\n", - "* A barplot of top feature imporance score ranking" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "Nip62hw-EZ5K", - "outputId": "7f2d432a-ac88-4b23-d37d-ccfbd3cb4ec1", - "scrolled": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Plotting Feature Importance Scores...\n", - "INFO: Feature Importance\n", - "30 Alpha-Fetoprotein (ng/mL) 0.122169\n", - "26 Performance Status* 0.121332\n", - "1 Symptoms 0.077926\n", - "48 Ferritin (ng/mL) 0.072561\n", - "40 Alkaline phosphatase (U/L) 0.072198\n", - "31 Haemoglobin (g/dL) 0.061457\n", - "23 Age at diagnosis 0.058108\n", - "35 Albumin (mg/dL) 0.052770\n", - "46 Iron 0.048957\n", - "44 Major dimension of nodule (cm) 0.047258\n", - "INFO: Saved Feature Importance Plots at\n", - "INFO: ./DemoOutput/demo_experiment/hcc_data/feature_selection/mutual_information/TopAverageScores.png\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Feature Importance\n", - "31 Haemoglobin (g/dL) 0.106311\n", - "40 Alkaline phosphatase (U/L) 0.095767\n", - "26 Performance Status* 0.078628\n", - "47 Oxygen Saturation (%) 0.057034\n", - "28 Ascites degree* 0.055786\n", - "21 Liver Metastasis 0.055732\n", - "46 Iron 0.052026\n", - "39 Gamma glutamyl transferase (U/L) 0.038462\n", - "1 Symptoms 0.033465\n", - "44 Major dimension of nodule (cm) 0.029253\n", - "INFO: Saved Feature Importance Plots at\n", - "INFO: ./DemoOutput/demo_experiment/hcc_data/feature_selection/multisurf/TopAverageScores.png\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Applying collective feature selection...\n", - "INFO: hcc_data Phase 4 Complete\n", - "INFO: Plotting Feature Importance Scores...\n", - "INFO: Feature Importance\n", - "28 Alpha-Fetoprotein (ng/mL) 0.122190\n", - "24 Performance Status* 0.102941\n", - "38 Alkaline phosphatase (U/L) 0.084033\n", - "44 Iron 0.083419\n", - "46 Ferritin (ng/mL) 0.071803\n", - "33 Albumin (mg/dL) 0.066835\n", - "29 Haemoglobin (g/dL) 0.063182\n", - "42 Major dimension of nodule (cm) 0.060912\n", - "4 Hepatitis B Core Antibody 0.055815\n", - "43 Direct Bilirubin (mg/dL) 0.053170\n", - "INFO: Saved Feature Importance Plots at\n", - "INFO: ./DemoOutput/demo_experiment/hcc_data_custom/feature_selection/mutual_information/TopAverageScores.png\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Feature Importance\n", - "29 Haemoglobin (g/dL) 0.122357\n", - "38 Alkaline phosphatase (U/L) 0.089723\n", - "24 Performance Status* 0.071719\n", - "20 Liver Metastasis 0.058686\n", - "26 Ascites degree* 0.054888\n", - "45 Oxygen Saturation (%) 0.047518\n", - "37 Gamma glutamyl transferase (U/L) 0.047229\n", - "36 Aspartate transaminase (U/L) 0.039825\n", - "0 Symptoms 0.036229\n", - "33 Albumin (mg/dL) 0.036112\n", - "INFO: Saved Feature Importance Plots at\n", - "INFO: ./DemoOutput/demo_experiment/hcc_data_custom/feature_selection/multisurf/TopAverageScores.png\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Applying collective feature selection...\n", - "INFO: hcc_data_custom Phase 4 Complete\n" - ] - } - ], - "source": [ - "from streamline.runners.feature_runner import FeatureSelectionRunner\n", - "f_sel = FeatureSelectionRunner(output_path, experiment_name, \n", - " feat_algorithms, class_label=class_label, \n", - " instance_label=instance_label,\n", - " max_features_to_keep=max_features_to_keep, \n", - " filter_poor_features=filter_poor_features, \n", - " top_features=top_fi_features, \n", - " export_scores=export_scores,\n", - " overwrite_cv=overwrite_cv_feat, \n", - " random_state=random_state,\n", - " show_plots=True)\n", - "f_sel.run(run_parallel=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "8e9Bk0SxFPIZ" - }, - "source": [ - "## Phase 5: Modeling\n", - "After cell runs, you will see:\n", - "* No output other than code progress bar completion" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "0hOuYSGfE5jB", - "outputId": "2e687dc2-5566-4ed2-a807-3ed26799ac72", - "scrolled": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|████████████████████████████████████████████████████████████████████████████████| 18/18 [00:00<00:00, 2571.44it/s]\n" - ] - } - ], - "source": [ - "from streamline.runners.model_runner import ModelExperimentRunner\n", - "model_exp = ModelExperimentRunner(\n", - " output_path, experiment_name, algorithms=algorithms, \n", - " exclude=exclude, class_label=class_label,\n", - " instance_label=instance_label, scoring_metric=primary_metric, \n", - " metric_direction=metric_direction,\n", - " training_subsample=training_subsample, \n", - " use_uniform_fi=use_uniform_FI, n_trials=n_trials,\n", - " timeout=timeout, save_plots=False, \n", - " do_lcs_sweep=do_lcs_sweep, lcs_nu=lcs_nu, lcs_n=lcs_N, \n", - " lcs_iterations=lcs_iterations,\n", - " lcs_timeout=lcs_timeout, resubmit=False)\n", - "model_exp.run(run_parallel=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "d0sJWBScIDc4" - }, - "source": [ - "## Phase 6: Statistics Summary and Figure Generation\n", - "After cell runs, for each target dataset you will see:\n", - "* ROC and PRC plots of CV folds for each algorithm\n", - "* An ROC and PRC plot comparing average algorithm performance across CV partitions\n", - "* Boxplots for each metric comparing algorithm performance (across CV partitions)\n", - "* Top feature importance boxplots for each algorithm (across CV partitions)\n", - "* Histogram of feature importance for each algorithm\n", - "* Composite feature importance plots" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "Nwcdh3W3IHc3", - "outputId": "0c762d0f-1576-4995-b0a9-e5016f9041d9", - "scrolled": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Running Statistics Summary for hcc_data\n", - "INFO: Running stats on Naive Bayes\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Running stats on Logistic Regression\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Running stats on Decision Tree\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Generating ROC and PRC plots...\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Saving Metric Summaries...\n", - "INFO: Generating Metric Boxplots...\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiQAAAKJCAYAAACLcTJAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABUw0lEQVR4nO3df3zN9f//8fs5Z5tttsMmhXij1SbKj4VU8mOR6Ieod+9+EioSb0R+regXS0R+5Ed+p0ilNypKqLzJr6FSMfmRH/ltY7/Yj3PO948+zrfz3mi2c/bcjtv1cnE59nw9X8/zOPPEfc/X87yOxeVyuQQAAGCQ1XQBAAAABBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQGmCygtXC6XnE5uansprFYL3zMUC+Yaigtz7dJZrRZZLJa/7UcgKSCn06Xk5AzTZZQaAQFWRUSUVWpqpnJznabLgR9jrqG4MNcKJzKyrGy2vw8kXLIBAADGEUgAAIBxxi/ZnD59WmPHjtW3336r9PR0xcTEqH///mrYsKEkafXq1XrnnXe0d+9eRUREqE2bNurTp4+Cg4MvOGZcXJz++OMPj7Z7771XY8aM8elrAQAAhWM8kDz//PM6deqUxo4dq8jISM2fP1/dunXTp59+qpSUFPXq1Ut9+/ZVmzZttH//fg0bNkynT59WQkJCvuOlp6fr8OHDmjZtmurUqeNuv1iAAQAAZllcLpex7cL79+/XnXfeqQULFig2NlbSn+9madOmje6++24dPHhQycnJmjVrlvucJUuWaOjQodq2bZuCgoLyjLl161Y98sgj2rx5s+x2u9dqdTicbGq9BOc3f6WkZLD5Cz7FXENxYa4Vzp+bWv9+h4jRFZKIiAi9++67uuGGG9xtFotFLpdLZ86cUdeuXWW15n0Rubm5Sk9PV2RkZJ5jSUlJqlixolfDCAAA8C2jgcRut6t58+YebcuXL9eBAwfUtGlT1a5d2+NYdna2Zs+erTp16uQbRiRp165dCg0NVe/evbVt2zZFRkaqY8eO6tSpU77hBgAAmGd8D8lfbdmyRUOHDtUdd9yhuLg4j2O5ubkaOHCgdu/erQ8++OCCY/z2229KS0tTu3bt1KtXLyUmJmrMmDE6c+aM+vTpU6T6AgIINAV1fnmuIMt0QFEw11BcmGu+ZXQPyV+tXLlSAwYMUL169TRt2jSPTajp6enq27evNm7cqPHjx+cJK3+Vk5OjrKwshYWFudveffddTZkyRVu2bCn0KonL5SrQneYAAMClKxErJO+//75GjBih1q1ba8yYMR6bVY8fP66nn35ahw4d0vTp09WkSZOLjhUYGKjAwECPtujoaGVmZurMmTOKiIgoVI1Op0upqZmFOvdyZLNZZbeHKDX1rBwONn/Bd5hrKC7MtcKx20NK/qZWSZo/f75ee+01PfHEExo6dKjHCsaZM2fUuXNnpaena/78+YqJibnoWE6nU61atdI///lPPfvss+727du364orrih0GDmPXdWXzuFw8n1DsWCuobgw13zDaCDZt2+fRo4cqdatW6t79+46deqU+1hwcLASEhJ08OBBzZgxQ5GRkTpx4oT7eGRkpGw2m9LS0pSTk6PIyEhZrVa1adNGM2bMUI0aNVSnTh2tX79eM2bMUHx8vImXCAAACsDoHpKpU6dq3Lhx+R5r3769vvzyS2VlZeV7fNWqVapataoGDx6sTZs2afXq1ZL+3Pw6ffp0LVq0SEePHlXVqlXVtWtXPfTQQ0WqlfuQXBrer4/iwlxDcWGuFU5B70NSYja1lnQEkkvDX1wUF+YaigtzrXAKGkh47xIAADCOQAIAAIwjkAAAAOMIJAAAwDjj9yFB6XH89FmdPZdboL42m0X7T2TIleuQw1GwfdMhwQG6snxIUUoEAJRSBBIUSFpmtoZMWy9fvifLarFoXO/bFB4a9PedAQB+hUCCAgkPDVJC91sKvEJyLCVTU5f8oh7t6+iqiNACnRMSHEAYAYDLFIEEBXYpl1Nstj8/iLDKFWVVtWLY3/QGAFzu2NQKAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwznggOX36tIYNG6ZmzZopNjZWjzzyiBITE93Hd+zYoccff1z169dXixYtNHPmzL8dc/ny5WrXrp1uvPFG3XvvvVqzZo0vXwIAACgi44Hk+eef148//qixY8fqk08+UZ06ddStWzft2bNHKSkp6tKli2rUqKFFixapd+/eGj9+vBYtWnTB8TZs2KAXXnhBjz76qBYvXqymTZvqueee0549e4rxVQEAgEsRYPLJ9+/fr3Xr1mnBggWKjY2VJMXHx2vNmjX6/PPPFRwcrKCgIL388ssKCAhQVFSU9u/fr+nTp+uBBx7Id8zp06erdevWevzxxyVJgwYN0rZt2zR37ly9+uqrxfbaAABAwRldIYmIiNC7776rG264wd1msVjkcrl05swZJSYmqlGjRgoI+P+5qUmTJtq3b59OnTqVZzyn06mtW7eqSZMmHu0333yzx2UgAABQshhdIbHb7WrevLlH2/Lly3XgwAE1bdpU48aNU3R0tMfxK6+8UpJ0+PBhVahQweNYamqqMjMzValSpTznHDlypMj1BgQYv8JValhtVvcj3zf4ku3/5tr5R8BXmGu+ZTSQ/K8tW7Zo6NChuuOOOxQXF6eEhAQFBQV59ClTpowkKSsrK8/5586dk6R8z8mv/6WwWi2KiChbpDEuJ6cyciRJZcuW4fuGYmG3h5guAZcJ5ppvlJhAsnLlSg0YMED16tXT2LFjJUnBwcHKzs726Hc+WISGhuYZ43xYye+ckJCiTSCn06XU1MwijXE5ycjIcj+mpGQYrgb+zGazym4PUWrqWTkcTtPlwI8x1wrHbg8p0KpSiQgk77//vkaMGKHWrVtrzJgx7hWOSpUq6fjx4x59z3991VVX5RmnfPnyCg0Nzfec/72MUxi5uUzAgnL+319Wp8PJ9w3FwsFcQzFhrvmG8Qth8+fP12uvvabHHntMb7/9tsfllkaNGmnLli1yOBzutvXr16tmzZp59o9If26IjY2N1aZNmzzaN27cqJtuusl3LwIAABSJ0UCyb98+jRw5Uq1bt1b37t116tQpnThxQidOnFBaWpoeeOABpaenKz4+Xrt379ann36quXPnqnv37u4x0tLSlJyc7P66S5cu+uKLLzR79mzt2bNHb775pnbs2KHOnTubeIkAAKAAjF6y+eqrr5STk6Ovv/5aX3/9tcexDh066I033tCMGTM0YsQIdejQQRUrVtTAgQPVoUMHd78RI0Zo06ZNWr16tSSpadOmGjlypCZPnqxx48bp2muv1dSpUxUVFVWsrw0AABScxeVyuUwXURo4HE4lJ7M5s6AOnUjXsJmb9Gq3xqpaMcx0OfBjAQFWRUSUVUpKBtf14VPMtcKJjCxboE2txveQAAAAEEgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYFyA6QL+avLkyVq/fr3mzZsnSXriiSe0adOmfPuOGjVK999/f77H4uLi9Mcff3i03XvvvRozZoxX6wUAAN5RYgLJnDlzNGHCBDVq1MjdNnHiROXk5Hj0e/HFF3XgwAG1atUq33HS09N1+PBhTZs2TXXq1HG3BwcH+6ZwAABQZMYDybFjxxQfH68tW7aoZs2aHsfKly/v8fXnn3+utWvX6tNPP1VYWFi+4+3atUsul0uxsbGy2+2+KhsAAHiR8T0kv/zyi8qVK6elS5eqXr16F+yXmZmpN998U507d1ZMTMwF+yUlJalixYqEEQAAShHjKyRxcXGKi4v7234ffvihMjIy9Oyzz160365duxQaGqrevXtr27ZtioyMVMeOHdWpUydZrUXLXwEBxvNbqWG1Wd2PfN/gS7b/m2vnHwFfYa75lvFAUhAOh0Pz5s3To48+qvDw8Iv2/e2335SWlqZ27dqpV69eSkxM1JgxY3TmzBn16dOn0DVYrRZFRJQt9PmXm1MZf+79KVu2DN83FAu7PcR0CbhMMNd8o1QEkk2bNunw4cN66KGH/rbv7NmzlZWV5d5jEhMTo4yMDE2ZMkW9e/cu9CqJ0+lSampmoc69HGVkZLkfU1IyDFcDf2azWWW3hyg19awcDqfpcuDHmGuFY7eHFGhVqVQEkpUrV6pu3bqqVq3a3/YNDAxUYGCgR1t0dLQyMzN15swZRUREFLqO3FwmYEE5/+8vq9Ph5PuGYuFgrqGYMNd8o1RcCNuyZYuaNGnyt/2cTqfi4uI0ZcoUj/bt27friiuuKFIYAQAAvlPiA4nD4dDu3bsVHR2d7/G0tDQlJydLkqxWq9q0aaMZM2Zo+fLlOnDggBYuXKgZM2YUaf8IAADwrRJ/yeb06dPKycnJc0+S80aMGKFNmzZp9erVkqT+/fvLbrfrrbfe0tGjR1W1alXFx8cXaP8JAAAww+JyuVymiygNHA6nkpPZnFlQh06ka9jMTXq1W2NVrZj/TewAbwgIsCoioqxSUjK4rg+fYq4VTmRk2QJtai3xl2wAAID/I5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwLgSFUgmT56sJ554wqNtyJAhiomJ8fjVrFmzi46zfPlytWvXTjfeeKPuvfderVmzxpdlAwCAIgowXcB5c+bM0YQJE9SoUSOP9qSkJPXo0UOPP/64u81ms11wnA0bNuiFF17Q4MGDdcstt+iTTz7Rc889p8WLFysqKspn9QMAgMIzvkJy7NgxPfXUUxo/frxq1qzpcczhcGj37t268cYbVbFiRfevyMjIC443ffp0tW7dWo8//riioqI0aNAg1alTR3PnzvX1SwEAAIVkPJD88ssvKleunJYuXap69ep5HPv999+VlZVV4JUNp9OprVu3qkmTJh7tN998sxITE71WMwAA8C7jl2zi4uIUFxeX77Fdu3bJYrFo7ty5WrNmjaxWq5o3b66+ffsqPDw8T//U1FRlZmaqUqVKHu1XXnmljhw5UuRaAwKM57dSw2qzuh/5vsGXbP83184/ApfieEqmMs/lFqiv1WbV/hMZsrhccjqcBTonNDhAV0aEFqXEy4bxQHIxv/32m6xWq66++mpNnTpV+/fv16hRo7Rr1y7NnTtXVqvnP0Dnzp2TJAUFBXm0lylTRllZWUWqxWq1KCKibJHGuJycysiRJJUtW4bvG4qF3R5iugSUMmfSszRw8vdyunz3HFarRe8Nb6NyYWV89yR+okQHkt69e+vJJ5+U3W6XJEVHR6tixYr617/+pe3bt+e5xFOmzJ9/4NnZ2R7tWVlZCgkp2j9WTqdLqamZRRrjcpKRkeV+TEnJMFwN/JnNZpXdHqLU1LNyFPCnVuC8N3veWuAVkqMpZzX50+3q2fFGVYoo2P8pocEBcubkKiWlYM/hj+z2kAKtYJboQGKxWNxh5Lzo6GhJ0tGjR/MEkvLlyys0NFTHjx/3aD9+/HieyziFkZvLP3YFdX450+lw8n1DsXAw11AIkeHBisy7A+CiKkWEqGrFsAL3Z14WTIm+6Nq/f39169bNo2379u2SpGuvvTZPf4vFotjYWG3atMmjfePGjbrpppt8VygAACiSEh1I7rnnHq1bt05TpkzRgQMH9N1332no0KG655573O+8SUtLU3JysvucLl266IsvvtDs2bO1Z88evfnmm9qxY4c6d+5s6mUAAIC/UaIDScuWLTV+/HitWLFC9957r+Lj43XnnXdq5MiR7j4jRozQgw8+6P66adOmGjlypBYsWKAOHTpow4YNmjp1KjdFAwCgBLO4XC4f7i/2Hw6HU8nJbM4sqEMn0jVs5ia92q3xJV1rBS5VQIBVERFllZKSwbV6+BT/rhVOZGTZAm1qLdErJAAA4PJAIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYFmC4AZh1LztS5bIf3x03JlCQdPpkhh8Pl9fGDg2y6KjLU6+MCAMwgkFzGjiVnasi7G3z6HFOX/OKzsROeaUIoAQA/QSC5jJ1fGXn63tqqUqGsV8e22SyyBAbIlZPr9RWSw6cyNP2zX32ysgMAMINAAlWpUFbVK4V7dcyAAKsiIsoqJSVDublOr44NAPA/bGoFAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYBz3IQFQ4hw/fVZnz+UWqK/NZtH+Exly5ToKfBO+kOAAXVk+pCglAvAyAgmAEiUtM1tDpq2Xy/sfgeRmtVg0rvdtCg8N8t2TALgkBBIAJUp4aJASut9S4BWSYymZmrrkF/VoX0dXRRTss41CggMII0AJQyABUOJcyuUUm80iSapyRVlVrRjmq5IA+BibWgEAgHGXtEKSnZ2tlStX6vDhw/rHP/6h5s2bq0yZMr6qDQAAXCYKHEiOHj2qTp066eDBg3L9326zatWqadKkSYqJifFKMZMnT9b69es1b948d9vq1av1zjvvaO/evYqIiFCbNm3Up08fBQcHX3CcuLg4/fHHHx5t9957r8aMGeOVOgEAgHcVOJCMHTtWqampeuONN3TDDTdo3759euONNzR8+HB9+OGHRS5kzpw5mjBhgho1auRuS0xMVK9evdS3b1+1adNG+/fv17Bhw3T69GklJCTkO056eroOHz6sadOmqU6dOu72iwUYAABgVoEDyffff68BAwaoffv2kqSoqCiVKVNGzzzzjNLS0hQeHl6oAo4dO6b4+Hht2bJFNWvW9Dj24YcfqkmTJnrmmWckSdWrV1e/fv00dOhQvfLKKwoKyrtLfteuXXK5XIqNjZXdbi9UTQAAoHgVeFPr6dOn8wSGunXryuVy6ejRo4Uu4JdfflG5cuW0dOlS1atXz+NY165dNXDgwDzn5ObmKj09Pd/xkpKSVLFiRcIIAAClSIFXSHJzcxUYGOjRFhb251vssrOzC11AXFyc4uLi8j1Wu3Ztj6+zs7M1e/Zs1alTR5GRkfmes2vXLoWGhqp3797atm2bIiMj1bFjR3Xq1ElWK28qAgCgJCo19yHJzc3VwIEDtXv3bn3wwQcX7Pfbb78pLS1N7dq1U69evZSYmKgxY8bozJkz6tOnT5FqCAjwr0Bz/v4NNpvF66/NZrN6PHp3bN/VjdLH+n9zzGqzMh8gSTqanKlzWQW7sd4ljZty1uPR24LLBKhSZMFu7uePvBJILBaLN4a5oPT0dPXt21cbN27UhAkT8lza+avZs2crKyvLvXoTExOjjIwMTZkyRb179y70KonValFERNlCnVtSncrIkSSF20N89trsdu9/Xkhx1I3S4/x8KFu2DPMBOnwiXQMnf+/T55j86XafjT1t8B2qcpne4O+SAslzzz2X70bSHj16eFzOsVgsWrlyZdGrk3T8+HE9/fTTOnTokKZPn64mTZpctH9gYGCeS0vR0dHKzMzUmTNnFBERUag6nE6XUlMzC3VuSZWWetb9mJIS+De9L43NZpXdHqLU1LNyOJxeHduXdaP0ycjIcj+mpGQYrgamHTuRJknq0b6Oqlzh3YBqtVnlslplcTrl9PK/a4dPZmjqkl907ESaQgJ8+0N+cbPbQwq0Wl7gQNKhQ4ciFVQYZ86cUefOnZWenq758+f/7f1OnE6nWrVqpX/+85969tln3e3bt2/XFVdcUegwcl5urncnoGnnPxnV4XD57LU5HE6vj10cdaP0OP8fg9MHcw2lz/l/H66KCPX6RwkEBFgVEVFWKSkZ/LvmAwUOJLfeeqtuv/12lS9f3ofleEpISNDBgwc1Y8YMRUZG6sSJE+5jkZGRstlsSktLU05OjiIjI2W1WtWmTRvNmDFDNWrUUJ06dbR+/XrNmDFD8fHxxVY3AAC4NAUOJAMHDtTChQs9AsnUqVP14IMP6oorrvB6YU6nU8uWLVNOTo46d+6c5/iqVatUtWpVjRgxQps2bdLq1aslSf3795fdbtdbb72lo0ePqmrVqoqPj9dDDz3k9RoBAIB3FDiQnL9d/HkOh0Pjx4/X7bff7rVA8sYbb7h/b7Va9dNPP13SOZIUEBCgZ5991uOSDQAAKNmK9B65/w0pAAAAhcGb9gEAgHEEEgAAYFyRA4mvb4oGAAD8X5FvjPa/N0WTvHtjNAAA4P9K9I3RAADA5aHAgSQhIcGXdQAAgMsYm1oBAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGBdgugAAl4djyZk6l+3w/rgpmZKkwycz5HC4vD5+cJBNV0WGen1cAJ4IJAB87lhypoa8u8GnzzF1yS8+GzvhmSaEEsDHCCQAfO78ysjT99ZWlQplvTq2zWaRJTBArpxcr6+QHD6Voemf/eqTlR0AnggkAIpNlQplVb1SuFfHDAiwKiKirFJSMpSb6/Tq2ACKD5taAQCAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgXIkKJJMnT9YTTzzh0bZjxw49/vjjql+/vlq0aKGZM2f+7TjLly9Xu3btdOONN+ree+/VmjVrfFUyAADwghITSObMmaMJEyZ4tKWkpKhLly6qUaOGFi1apN69e2v8+PFatGjRBcfZsGGDXnjhBT366KNavHixmjZtqueee0579uzx9UsAAACFFGC6gGPHjik+Pl5btmxRzZo1PY599NFHCgoK0ssvv6yAgABFRUVp//79mj59uh544IF8x5s+fbpat26txx9/XJI0aNAgbdu2TXPnztWrr77q89cDAAAunfEVkl9++UXlypXT0qVLVa9ePY9jiYmJatSokQIC/n9uatKkifbt26dTp07lGcvpdGrr1q1q0qSJR/vNN9+sxMRE37wAAABQZMZXSOLi4hQXF5fvsaNHjyo6Otqj7corr5QkHT58WBUqVPA4lpqaqszMTFWqVCnPOUeOHClyrQEBxvObV9lsFvejt1+bzWb1ePTu2L6rG77BXENxsdksspTJ1I+H9+hEdtm/7X8mPUvZuc4CjW2xWlUmKEBZ2blyOQt2TlCAVeXCyvxtvxOnz8pSJvOynmvGA8nFnDt3TkFBQR5tZcr8+QeblZWVb39J+Z6TX/9LYbVaFBHx95O7NDmVkSNJCreH+Oy12e0hXh+zOOqGdzHXUFx+T05Rmbpr9NVpSacNF3OJytS1qGy5uMt2rpXoQBIcHKzs7GyPtvPBIjQ0NE//82Elv3NCQor2j5XT6VJqamaRxihp0lLPuh9TUgK9OrbNZpXdHqLU1LNyOAr2k0RB+bJu+AZzDcWlRmSEukf3Uo6rYD+ElpQVEkmyh5RVxdAwpaRkFKh/aWG3hxRoBbNEB5JKlSrp+PHjHm3nv77qqqvy9C9fvrxCQ0PzPed/L+MURm4BJ21p4XC43I++em0Oh9PrYxdH3fAu5hqKU71q//DJuAEBVkVElFVKSobP5sPlPM9K9IWqRo0aacuWLXI4HO629evXq2bNmnn2j0iSxWJRbGysNm3a5NG+ceNG3XTTTT6vFwAAFE6JDiQPPPCA0tPTFR8fr927d+vTTz/V3Llz1b17d3eftLQ0JScnu7/u0qWLvvjiC82ePVt79uzRm2++qR07dqhz584mXgIAACiAEh1IKlSooBkzZmjfvn3q0KGDJk2apIEDB6pDhw7uPiNGjNCDDz7o/rpp06YaOXKkFixYoA4dOmjDhg2aOnWqoqKiTLwEAABQACVqD8kbb7yRp61u3bpauHDhJZ1z//336/777/dmaQAAwIdK9AoJAAC4PBBIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQGmCwBwebCUydTRs0dkSTvj1XEDbFaluEKUlnZWuQ6nV8c+ejZTljKZXh0TQP4IJAB8LjM3U2XqrtF7+9ZI+0xXc2nK1LUoM7eRpHDTpQB+jUACwOdCA0KV9VMzPXN/tCpfEerVsQNsVoWH+2aF5MjJTL27eJdC63i3ZgB5EUgAFAtXVqgqhVTWP8K9u9IQEGBVRERZpVgylJvr3UDiykiTK+uQV8cEkD82tQIAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjvuQACg2+4+leX1Mm82i/Scz5crJlcPh8urYh09leHU8ABdGIAHgcw7nn0FhzvKdhispnOAgm+kSAL9HIAHgc9dUsevFTg1ls1q8PvaxlExNXfKLerSvo6sivH+L9+Agm66K5NbxgK8RSAAUi2uq2H0yrs32Z8ipckVZVa0Y5pPnAOB7bGoFAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYBz3IQFQ4hw/fVZnz+UWqO+xlExJ0uGTGQW+dXxIcICuLB9S6PoAeB+BBECJkpaZrSHT1st1iR9LM3XJLwXua7VYNK73bQoPDbrE6gD4CoEEQIkSHhqkhO63FHiFxGazyBJgkyvXcUkrJIQRoGQhkAAocS7lckpAgFUREWWVkpKh3FynD6sC4EtsagUAAMYRSAAAgHEEEgAAYFyJ30OyceNGderUKd9jVatW1apVq/K0/+c//9HgwYPztK9YsULVq1f3eo0AAKBoSnwgadCggdauXevRtmvXLj3zzDPq0aNHvuckJSWpcePGGjt2rEd7ZGSkz+oEAACFV+IDSVBQkCpWrOj+OicnRwkJCbrzzjv1z3/+M99zdu3apVq1anmcBwAASq5St4fkgw8+0JEjRzRkyJAL9klKStK1115bjFUBAICiKPErJH+VlZWlqVOnqnPnzrryyivz7ZOcnKyTJ09q8+bNmjdvnk6fPq169eppwIABqlmzZpGePyCg1OW3i7LZLO5Hb782m83q8ejdsX1XN0ofX8414K+Ya75VqgLJkiVLlJWVpSeeeOKCfXbt2iVJstlsGjVqlDIzMzV58mQ9+uij+uyzz3TFFVcU6rmtVosiIsoW6tyS6lRGjiQp3B7is9dmt3v/80KKo26UPr6Ya0B+mGu+UaoCyeLFi3XnnXcqIiLign2aNGmiTZs2qVy5cu62d955Ry1bttSnn36qZ555plDP7XS6lJqaWahzS6q01LPux5SUQK+ObbNZZbeHKDX1rBwO794905d1o/Tx5VwD/oq5Vjh2e0iBVpVKTSBJTk7Wtm3b1L1797/t+9cwIkmhoaGqWrWqjh07VqQa/O221Oc/98PhcPnstTkcTq+PXRx1o/TxxVwD8sNc841ScyFs69atslgsaty48UX7zZ8/XzfffLPOnTvnbktPT9fvv//ORlcAAEqoUhNIdu7cqWrVqikkxPPancPh0IkTJ9wBpGXLlnK5XBo4cKB+++03bd++Xb1791ZkZKQ6dOhgonQAAPA3Sk0gOXnypMqXL5+n/ciRI2ratKmWLVsmSapcubLmzp2rjIwMPfLII3ryyScVHh6u9957T8HBwcVcNQAAKIhSs4fk5Zdfzre9atWqSkpK8mi7/vrrNXPmzGKoCgAAeEOpWSEBAAD+i0ACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAONKRSD5448/FBMTk+fXxx9/nG//lJQU9e/fX40aNVKjRo300ksvKTMzs5irBgAABRVguoCCSEpKUpkyZbRy5UpZLBZ3e3h4eL79//3vfysrK0tz5sxRamqq4uPj9corr2jUqFHFVTIAALgEpSKQ7Nq1SzVr1tSVV175t323bdumTZs2admyZYqKipIkvfrqq3rqqaf0/PPP66qrrvJ1uQAA4BKViks2SUlJuvbaawvUNzExURUrVnSHEUlq3LixLBaLtmzZ4qsSAQBAEZSaFZKKFSvq0Ucf1e+//67q1aurZ8+euv322/P0PXbsmCpXruzRFhQUpPLly+vIkSNFqiMgoFTktwKz2SyylMnUieyjCsxM8+rYVqtVKa4yysjIktPp9OrYJ7IzZCmTKZvN4nd/Jrh0NpvV4xHwFeaab5X4QJKdna3ff/9dISEhGjhwoEJDQ7V06VI9/fTTmj17tm655RaP/mfPnlVQUFCeccqUKaOsrKxC12G1WhQRUbbQ55dEB06fVpm6azR79xppt+lqLk2ZuhZZQ5r53Z8JCs9uDzFdAi4TzDXfKPGBJCgoSJs3b1ZAQIA7aNxwww3as2ePZs6cmSeQBAcHKzs7O884WVlZCg0NLXQdTqdLqan+9U4d51mrsn5qpmcfiFGVK7z7H7vValXZsr5ZITl8MkNTFiXJWdeqlJQMr46N0sdms8puD1Fq6lk5HN6da8BfMdcKx24PKdCqUokPJJLyDRLR0dFau3ZtnvZKlSpp5cqVHm3Z2dk6ffp0kTe05ub61wR0OFxyZYWqYlAlVQnN/x1LhRUQYFVERFmlWDK8/n3LCUqTK+ugHA6X3/2ZoPAcDifzAcWCueYbJf5C2M6dO9WgQQMlJiZ6tP/888/5bnRt1KiRjh49qv3797vbNm7cKEmKjY31bbEAAKBQSnwgiY6O1nXXXadXXnlFiYmJ2rNnjxISEvTDDz+oR48ecjgcOnHihM6dOydJqlevnmJjY9WvXz/99NNP2rBhg4YPH67777+ft/wCAFBClfhAYrVaNXXqVN14443q27evOnTooB9//FGzZ89WTEyMjhw5oqZNm2rZsmWSJIvFokmTJqlq1arq3Lmz+vbtq2bNmunll182+0IAAMAFlYo9JJGRkRo5cmS+x6pWraqkpCSPtgoVKmjChAnFURoAAPCCEr9CAgAA/B+BBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxgWYLgDm7T+W5vUxbTaL9p/MlCsnVw6Hy6tjHz6V4dXxAADmEUguYw7nn0FhzvKdhispnOAgm+kSAABeQiC5jF1Txa4XOzWUzWrx+tjHUjI1dckv6tG+jq6KCPX6+MFBNl0V6f1xAQBmEEguc9dUsftkXJvtz5BT5YqyqloxzCfPAQDwH2xqBQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxAaYLQOlx/PRZnT2XW6C+x1IyJUmHT2bI4XAV6JyQ4ABdWT6k0PUBAEovAgkKJC0zW0OmrZerYNnCbeqSXwrc12qxaFzv2xQeGnSJ1QEASjsCCQokPDRICd1vKfAKic1mkSXAJleu45JWSAgjAHB5IpCgwC7lckpAgFUREWWVkpKh3FynD6sCAPgDNrUCAADjCCQAAMA4AgkAADCuxAeS06dPa9iwYWrWrJliY2P1yCOPKDEx8YL9//Of/ygmJibPr/379xdj1QAA4FKU+E2tzz//vE6dOqWxY8cqMjJS8+fPV7du3fTpp58qKioqT/+kpCQ1btxYY8eO9WiPjIwsrpIBAMAlKtErJPv379e6des0fPhwNWzYUNdcc43i4+N11VVX6fPPP8/3nF27dqlWrVqqWLGixy+bzVbM1QMAgIIq0YEkIiJC7777rm644QZ3m8Vikcvl0pkzZ/I9JykpSddee21xlQgAALygRF+ysdvtat68uUfb8uXLdeDAATVt2jRP/+TkZJ08eVKbN2/WvHnzdPr0adWrV08DBgxQzZo1i1xPQECJzm8lis1m9XgEfIW5huLCXPOtEh1I/teWLVs0dOhQ3XHHHYqLi8tzfNeuXZIkm82mUaNGKTMzU5MnT9ajjz6qzz77TFdccUWhn9tqtSgiomyhz79c2e18Ng2KB3MNxYW55hsWl+tSP53EjJUrV2rAgAGqV6+epk2bpuDg4Hz7nTlzRuXKlXN/nZmZqZYtW6pbt2565plnCv38DodTqalnC33+5cZms8puD1Fq6lk5HNypFb7DXENxYa4Vjt0eUqBVpVKxQvL+++9rxIgRat26tcaMGaOgoAt/3slfw4gkhYaGqmrVqjp27FiR6+AW6JfO4XDyfUOxYK6huDDXfKPEXwibP3++XnvtNT322GN6++23LxpG5s+fr5tvvlnnzp1zt6Wnp+v3339noysAACVYiQ4k+/bt08iRI9W6dWt1795dp06d0okTJ3TixAmlpaXJ4XDoxIkT7gDSsmVLuVwuDRw4UL/99pu2b9+u3r17KzIyUh06dDD8agAAwIWU6EDy1VdfKScnR19//bWaNm3q8WvEiBE6cuSImjZtqmXLlkmSKleurLlz5yojI0OPPPKInnzySYWHh+u999674J4TAABgXqnZ1Gqaw+FUcnKG6TJKjYAAqyIiyiolJYNrrfAp5hqKC3OtcCIjyxZoU2uJXiEBAACXBwIJAAAwjks2BeRyueR08q26FDablffqo1gw11BcmGuXzmq1yGKx/G0/AgkAADCOSzYAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4Agl8IicnR9u3b1dGRobpUgAApUCA6QLgH44cOaL4+Hj17dtXMTExeuCBB7R7926VK1dOc+bM0fXXX2+6RPiRLVu2aMuWLcrJyZHL5fI41qtXL0NVwR8dP35cH330kfbu3av4+Hht2rRJ0dHRioqKMl2a37G4/vdvM1AI//73v3XkyBGNGzdOW7du1fDhwzVz5kx98sknOnr0qGbNmmW6RPiJd999V2PHjlW5cuVUtmxZj2MWi0WrVq0yVBn8zf79+/XQQw8pLCxMx44d0/LlyzV69Gj997//1cyZMxUbG2u6RL9CIIFXNG7cWHPnztX111+v/v37Kzc3V+PHj9e+ffvUsWNHbdu2zXSJ8BPNmjXTAw88oD59+pguBX7u2WefVWRkpF5//XXFxsZq6dKlqlKligYPHqwjR47o/fffN12iX2EPCbwiJydH5cqVkyStX79et956qyTJ6XQqIIArg/CeM2fO6P777zddBi4D27ZtU5cuXWSxWNxtNptNPXr00I4dOwxW5p/4nwJeUbt2bX388ce68sorlZKSoubNmys7O1vTp09XrVq1TJcHP3LTTTdp+/btql69uulS4OccDoecTmee9vT0dNlsNgMV+TcCCbxi0KBB6tGjh1JSUvT000+rUqVKevnll7Vy5UrNnDnTdHnwI23bttWrr76qn3/+Wddcc42CgoI8jrN6Am9p2rSppkyZojFjxrjbUlJSNHr0aDVp0sRgZf6JPSTwGpfLpbS0NNntdknSvn37VL58eUVERBiuDP7kYituFouFpXR4zbFjx9SpUyedPn1aaWlpuuaaa/THH3+ofPnyev/993X11VebLtGvEEjgVZs3b9aePXt0zz336OjRo6pevboCAwNNlwUAhXL27Fl9/vnn2rFjh5xOp6677jq1b99eYWFhpkvzOwQSeEV6erq6deumH3/8URaLRStWrNCIESP0+++/a86cOapUqZLpEuFn9u7dq6SkJAUGBioqKko1a9Y0XRL8VHZ2tg4dOqRq1apJEj9k+QjvsoFXjB07VhaLRV9//bWCg4MlSQMHDlRoaKjefPNNw9XBn2RnZ+vf//632rVrp379+qlXr15q166devbsqezsbNPlwY+4XC6NGTNGjRo1cq/6Dho0SEOGDFFOTo7p8vwOgQRe8c0332jgwIHunyAk6ZprrtHw4cO1fv16g5XB34wbN04//fSTpkyZosTERG3cuFETJ07Ur7/+qokTJ5ouD35k3rx5WrJkiYYPH+7ePN2qVSutXr1a48ePN1yd/yGQwCuSk5NVsWLFPO1hYWE6e/asgYrgrz7//HO98soratmypcLCwlSuXDm1atVKw4cP12effWa6PPiRhQsXatiwYerYsaP7XiTt2rXTiBEj9MUXXxiuzv8QSOAVN954o5YtW5an/b333lPt2rUNVAR/lZ6enu89SGrWrKnk5GQDFcFfHTp0KN/P4YqJidHJkycNVOTfuA8JvOL5559Xly5dtG3bNuXm5mrKlCnavXu3fv31V+5DAq+Kjo7Wl19+qR49eni0L1u2jI2t8Kqrr75aP/30k6pWrerR/t1333lcnoZ3EEjgFbGxsVq4cKFmzZql6tWr64cfftB1112n+Ph41atXz3R58CPPPvusevbsqZ07dyo2NlYWi0WJiYn6+uuvPW5gBRRVt27d9Morr+jYsWNyuVxav369PvzwQ82bN09DhgwxXZ7f4W2/8IpvvvlGzZs3l9XKVUD43sqVK/Xuu+9q165dcrlcio6OVrdu3XTXXXeZLg1+ZuHChZoyZYqOHj0qSapQoYKeeuopdenSxXBl/odAAq+oV6+ewsPD1b59e3Xs2FFRUVGmSwKAIlm6dKmaN2+ucuXKKTk5WS6XSxUqVDBdlt8ikMAr0tPT9cUXX2jx4sXatm2b6tatq44dO+qee+7hjoYoskmTJqlbt24KCQnRpEmTLtq3V69exVQV/F3jxo21YMECfsAqJgQSeN3+/fv12WefacWKFTpw4IBatWqlBx98kA+jQqHFxcVp0aJFioiIUFxc3AX7WSwWrVq1qhgrgz976KGH9OSTT6pdu3amS7ksEEjgdTk5Ofr222/15ZdfatWqVYqIiFBqaqqqVKmi0aNHX/TD0QCgpIiPj9d//vMf1apVSzVq1FCZMmU8jickJBiqzD8RSOA1W7du1ZIlS/Tll18qKytLrVq10gMPPKBbbrlFmZmZGjp0qHbu3Kkvv/zSdKko5c6dOyer1aqgoCDt2bNH3377rRo0aKDY2FjTpcGPPPHEExc9Pm/evGKq5PJAIIFXtG7dWocOHVLt2rX1wAMP6N5771V4eLhHn6+++kovvviiNm/ebKhK+IPNmzfrueee0/jx43XttdeqTZs2slqtyszM1FtvvaW2bduaLhGl2JAhQxQfH8/eNwN4jya8omXLllqyZIkWLVqkRx99NE8YkaRbbrlFX331lYHq4E/Gjh2rO+64w3134LCwMK1du1bx8fGaNm2a6fJQyi1evFhZWVmmy7gsEUjgFUOHDlV0dHS+xw4fPixJstvtioyMLM6y4Id+/fVX9ezZ0x1EWrRooeDgYLVo0UJ79+41XR5KOS4amMOdWuEVf/zxh9544w0lJSXJ4XBI+vMvdnZ2tpKTk/Xrr78arhD+IiQkRNnZ2crOzlZiYqJGjhwpSTp58mS+K3PApTr/QXooXgQSeMVrr72mffv2qW3btpo5c6a6du2qffv26euvv9arr75qujz4kZtvvlmjR49WuXLlJEm33367duzYoddff10333yz4ergD2677bYC9duxY4ePK7m8EEjgFYmJiZoyZYoaNWqkNWvWqFWrVqpbt67GjRun7777Tg899JDpEuEnhg8fruHDhyspKUmjR49WWFiYlixZooCAAD5fBF4xZMgQVtsMIJDAK7KystyfiHnNNdcoKSlJdevW1f333/+3b50DLkVkZKQmTpzo0da/f38FBgYaqgj+5u677+YW8QawqRVeUa1aNe3atUuSVKNGDfdSptPpVEZGhsnS4Ie2bt2q5ORkSX++K6JXr16aNm0aGxJRZOwfMYdAAq/o2LGjBg4c6P7U30WLFmnGjBl6/fXXFRMTY7o8+JEPP/xQjz32mJKSkrRr1y4NGTJEOTk5mj17tt555x3T5aGUI9Saw43R4DVz5sxRjRo11KJFC02fPl1Tp05V5cqVNXr0aF1//fWmy4OfaNu2rR5//HE99thjGj9+vFatWqWlS5dqzZo1evnll7V69WrTJQIoBAIJgFLlxhtv1IoVK1S5cmU99NBDaty4sQYMGKDDhw/rrrvu0k8//WS6RACFwKZWFNn5PSJly5aVJO3bt0+ffPKJXC6X7r33XlZH4FUVKlTQ8ePHFRgYqJ9//ln9+vWTJO3cuVNXXHGF4eoAFBaBBIWWnp6uF198UStWrJDFYlG7du3Uo0cP/etf/5LD4ZDL5dLcuXM1depU3X777abLhZ+4++67NWDAAIWEhKhSpUpq3Lixli1bptdee00PPvig6fIAFBKXbFBow4cP1+bNm9WzZ08FBwdr5syZ+v3339WwYUO99dZbkv68pfyxY8f4VEx4jdPp1AcffKCDBw/qscceU/Xq1TVv3jydPHlS//73v2Wz2UyXCKAQCCQotKZNm2rs2LFq3LixJOno0aNq0aKF3n//fTVs2FCStGvXLj322GN8wi+AUsfpdOrzzz/Xli1blJOTk+cdOAkJCYYq809cskGhJScn6x//+If760qVKqlMmTIe1/EjIyO5Dwm87rvvvtPMmTO1d+9eLVy4UIsWLdI//vEP3X///aZLgx8ZNWqU3nvvPdWqVUthYWGmy/F7BBIUmtPpzHN3TKvVmmfJnEU4eNO6devUq1cv3X333frhhx/kdDrlcDg0dOhQORwOPfDAA6ZLhJ9YsmSJXnzxRT322GOmS7kscGM0FJrFYuGuhih2EydOVP/+/fXGG2+4w2+/fv3Uv39/zZ4923B18CdZWVlsyC9GrJCg0Fwul5577jmPVZKsrCwNGDBAZcqUkSTl5OSYKg9+KikpSW+++Wae9jvvvFMTJkwwUBH81e23367//ve/rJAUEwIJCq1Dhw552q6++uo8bTVq1CiGanC5CA8P17Fjxzz2L0nSb7/9pnLlyhmqCv7oxhtv1Jtvvqn169crKioqzyXqXr16GarMP/EuGwClyujRo7Vu3TqNGDFCTzzxhObPn69jx47p5ZdfVps2bTR48GDTJcJPxMXFXfCYxWLRqlWrirEa/0cgAVCq5OTkaPDgwfriiy8k/fkfg8vlUosWLTR+/Hj35UIApQuBBECp8vvvv6tGjRo6cOCAfv31VzmdTkVHR+vaa681XRr81H//+18lJSUpICBA1113nZo0acIN+HyAQAKgVGnatKkmT56sunXrmi4Ffi41NVVdu3bVzz//LLvdLqfTqfT0dNWpU0ezZ8+W3W43XaJf4W2/AEqVoKAgBQSwHx++N2rUKGVlZWnp0qXatGmTEhMTtXjxYmVnZ7s/HgPewwoJvOrw4cPas2ePGjVqpIyMDFWoUMF0SfAzb7/9tj766CO1b99e1atXV3BwsMdx7tYKb2nSpIkmTpyoRo0aebRv2rRJ/fr107p16wxV5p/4MQNekZ2drUGDBmn58uWyWq366quvNGrUKKWlpWnSpEkKDw83XSL8xNSpUyUp35ugWSwWAgm8Jjc3V5GRkXnaK1SooPT0dAMV+Tcu2cArpkyZop07d2ru3Lnudzl06tRJf/zxh0aPHm24OviTnTt3XvDXjh07TJcHP1KnTh0tWLAgT/v8+fN1/fXXG6jIv3HJBl5x55136uWXX9att96qBg0aaOnSpapWrZrWr1+vF154QWvXrjVdIgBckm3btqlTp06qVauWYmNjZbFYlJiYqJ07d2r69Om65ZZbTJfoV7hkA6/I786ZklS5cmWlpqYaqAj+qlatWhf8DKXAwEBVqlRJ7du3V8+ePfmsJRRJgwYN9MEHH2jWrFlau3atXC6XoqOj9eKLL6p+/fqmy/M7BBJ4RVRUlL7//ns99NBDHu2ff/4594eAVw0ZMkRjx47Vo48+qptuukmS9OOPP+r999/Xww8/rHLlyum9995TUFCQnn76acPVorSrW7eu3n77bdNlXBYIJPCK3r17q2/fvtq1a5ccDof+85//aO/evVqxYoXGjRtnujz4kS+++EJDhw7Vv/71L3dbq1atdM011+ijjz7SggULdN111+nNN98kkOCSDRkyRPHx8QoLC9OQIUMu2jchIaGYqro8EEjgFS1bttTEiRM1bdo02Ww2zZw5U9ddd53GjRunNm3amC4PfmTnzp1q0qRJnvabbrpJw4cPlyTVrl1bR44cKe7S4AcOHTokp9Pp/j2KD4EEXnHw4EE1a9ZMzZo1M10K/FzVqlX1zTff6Mknn/RoX716tSpVqiRJOnDgQL5v1wT+zrx58/L9PXyPQAKvaN26tW666SZ17NhRbdu2VWhoqOmS4KeeffZZDR48WNu3b1eDBg3kdDr1448/6quvvtIrr7yiffv2aciQIbrzzjtNlwo/cPjwYdntdoWFhWnDhg1asWKFYmNjdc8995guze/wtl94xZYtW7R06VJ9+eWXys7OVqtWrdShQwfdeuutpkuDH/rmm280a9Ys/fLLLwoICFBMTIyeeeYZ3X777dq8ebPWrl2rXr16KTAw0HSpKMW+/vpr9evXT1OnTlX16tXVtm1bVatWTUeOHNELL7ygxx57zHSJfoVAAq/KycnRd999p6VLl+q7775TRESE2rdvr379+pkuDQAuSYcOHdSsWTP16dNH06dP16JFi/Tll19q+fLlmjRpkpYvX266RL/CnVrhVYGBgWrVqpWGDx+u3r17Ky0tTTNmzDBdFvzMzp07NWTIED388MM6duyYPvjgA23YsMF0WfAze/bs0UMPPSSr1aq1a9eqefPmslqtatCggf744w/T5fkdAgm8JjMzU4sXL1a3bt3UvHlzffzxx+rWrZtWrlxpujT4kZ9//ln//Oc/dejQIf3888/Kzs7Wjh071K1bN33zzTemy4MfsdvtSktLU3p6un744Qf3JegDBw6ofPnyZovzQ2xqhVf069dP3377rSwWi9q0aaM5c+aoYcOGpsuCHxozZoy6du2qfv36qUGDBpKk119/XeHh4Zo0aZJatmxpuEL4i+bNm2vYsGEKCwtTWFiYbrvtNn3//fd6+eWX1aJFC9Pl+R1WSOAVJ0+e1LBhw7Ru3TolJCQQRuAzP//8c76f6PvII49o7969xV8Q/NZLL72k2NhYhYSEaMqUKQoKCtKWLVtUt25dDRo0yHR5focVEngF79dHcQkMDMz3o98PHz6skJAQAxXBXwUHB2vw4MEebb179zZUjf8jkKDQ7rjjDn3yySeKiIhQXFzcRT/IbNWqVcVYGfxZq1at9NZbb3l8JMGePXs0YsQIltFRZJMmTVK3bt0UEhKiSZMmXbRvr169iqmqywNv+0Wh/fUv7sSJEy8aSPiLC29JT0/XU089pR9//FEul0vh4eFKT09XrVq1NHv2bDYbokji4uK0aNEi9w9aF2KxWPhBy8sIJABKpfXr1+vXX3+V0+lUdHS0br/9dlmtbIsDSisCCbxm586d2rVrl/uDqVwul7Kzs/Xjjz9q5MiRhqvD5WDu3Lnq3Lmz6TLgJ1wulyZMmKCKFSvq0UcflSR17NhRrVu31rPPPmu4Ov/DHhJ4xXvvvecOHRaLRedzrsVi4R038IrZs2fr888/l81mU/v27T1u2/3bb78pPj5e27dvJ5DAa8aNG6ePP/5Yr732mrvtvvvu07vvviur1aru3bsbrM7/sL4Jr3j//ffVvXt3/fTTT4qMjNR3332nJUuWKCoqSnfccYfp8lDKTZo0SaNGjVJYWJjKly+vhIQEffjhh5KkmTNnqmPHjtq/f78SEhIMVwp/snTpUr311ltq1aqVu+3JJ59UQkKCFi5caLAy/8QKCbzi8OHDevDBBxUUFKRatWpp+/btatWqlQYPHqw33ngjz0fFA5fis88+07///W/17NlTkrR48WJNnz5dJ06c0DvvvKO77rpLw4YNU2RkpOFK4U9Onz6typUr52mvXr26Tp48aaAi/8YKCbyibNmyys3NlSTVqFFDu3fvliRFRUXxmQ8osqNHj6pt27bur9u1a6e9e/dq7ty5euONN/T2228TRuB1tWrV0scff5ynfcmSJbruuusMVOTfWCGBVzRs2FBTp07VsGHDVKtWLX300Ud65plnlJiYqLJly5ouD6VcVlaW7Ha7++ugoCAFBwerX79++d61FfCG3r176+mnn9bWrVtVv359WSwWbd++XT/88IPeeecd0+X5HVZI4BV9+/bVunXrtGDBArVr106nTp1S48aNNXjwYHXs2NF0efBT5z/sDPCF2267TQsWLNDVV1+tdevWacOGDapUqZI++eQTNW/e3HR5foe3/cJrzp07p8zMTEVGRurUqVNaunSpKleurLvuust0aSjlatWqpXXr1qlChQrutgYNGmjp0qWqVq2awcoAeAuXbOA1wcHBCg4OliRVqFBBXbp0MVwR/MmsWbM8PqsmNzdX7733nsqVK+fRj7sCw5t27typuXPnat++fRo/frxWrlypqKgoNWnSxHRpfocVEhRap06dCtTPYrFo7ty5Pq4G/uxit/D+K27nDW/6+eef9cgjj6h+/fratm2bli9frmnTpuk///mPJk2apJYtW5ou0a+wQoJCu/rqqy96PDExUQcPHlRYWFgxVQR/tXr1atMl4DI0ZswYde3aVf369VODBg0kSa+//rrCw8MJJD5AIEGhXegmVOnp6XrjjTd08OBB3XrrrXr99deLuTIAKLqff/5Zw4cPz9P+yCOPuG/MB+8hkMCr1q1bp5deekmpqal65ZVX9K9//ct0SQBQKIGBgUpPT8/TfvjwYY/9TPAO3vYLr8jIyNBLL72kbt26qXr16lq6dClhBECp1qpVK7311ltKSUlxt+3Zs0cjRoxQixYtzBXmp9jUiiI7vypy5swZvfDCC3r44YdNlwQARZaenq6nnnpKP/74o1wul8LDw5Wenq5atWpp9uzZKl++vOkS/QqBBIWWkZGhUaNG6eOPP9Ytt9yiESNG5Pu5D4C3nT59WqdPn1aNGjUkScuWLdMtt9yiiIgIs4XBL61fv16//vqrnE6noqOjdfvtt8tq5QKDtxFIUGhxcXE6cuSIqlWrpvvuu++ifbk3BLzlp59+0tNPP62OHTtq0KBBkqSWLVsqJydHs2bNUnR0tOEK4U/Onj2rtLQ0hYeHs2/ExwgkKDTuDQETHn/8cdWsWVMvvfSSgoKCJEkOh0MvvfSSjh49qlmzZhmuEKVdRkaGZs2apc8//1wHDhxwt1evXl333XefunTpQjjxAQIJgFLlQreM//3339WxY0dt3brVUGXwB6dPn9YTTzyhP/74Q61bt1Z0dLTsdrvS0tL0yy+/aNWqVapWrZrmz5+v8PBw0+X6Fd72C6BUCQsL04EDB/IEkqNHj7o/ugAorIkTJyo3N1dffPFFvnvijh49qqefflqzZs1Snz59DFTov9iVA6BUadOmjV5++WV9//33Sk9PV0ZGhjZs2KBXX31VrVu3Nl0eSrnVq1dr4MCBF9ygX6lSJfXp00crVqwo5sr8HyskAEqV/v376+DBg+ratassFou7vXXr1ho4cKDByuAPTp48+bcbo2vVqqUjR44UU0WXDwIJgFIlJCRE06ZN0759+5SUlKTAwEBFRUW53wIMFEVOTs7fXvoLDg7W2bNni6miyweBBECpVLNmTdWsWdN0GQC8hEACoMS7/vrrtXbtWlWoUEG1atXyuFTzv3bs2FGMlcEfzZo166Jv683MzCzGai4fBBIAJd7IkSPdb7G80KdMA95QpUoVLV++/G/7cVdq7yOQACjxOnTo4P69xWJRu3bt3DdFOy8zM1MfffRRcZcGP7N69WrTJVy2uDEagBIvOTlZ586dkyTdcccd+uSTT/J8bs2OHTvUr18//fTTTyZKBFBErJAAKPHWrFmjwYMHy2KxyOVy6cEHH8zTx+VyqXnz5gaqA+ANrJAAKBU2b94sp9Opzp07a+LEiSpXrpz7mMViUWhoqKKjoxUYGGiwSgCFRSABUKps2rRJsbGxCghggRfwJ9w6HkCp0rhxYy1fvlxHjx6VJE2ePFn33HOPhg0bpqysLMPVASgsAgmAUmXy5MmKj4/X4cOHtW3bNk2YMEENGjTQxo0bNWbMGNPlASgkAgmAUmXRokUaNWqUYmNjtWLFCtWvX1+vvfaaRowYoS+//NJ0eQAKiUACoFQ5fvy4GjRoIEn6/vvv1bRpU0l/3qgqNTXVZGkAioBAAqBUqVSpkvbt26cDBw4oKSlJt912myQpMTFRlSpVMlwdgMJimzqAUuXhhx9Wnz59VKZMGcXExKhBgwb64IMPNHr0aPXu3dt0eQAKibf9Aih1Vq9erYMHD+q+++5TRESEli5dqqysLP3zn/80XRqAQiKQAAAA47hkA6DE69SpkyZNmiS73a5OnTpdtO97771XTFUB8CYCCYAS7+qrr5bV+uce/CpVqshisRiuCIC3cckGAAAYxwoJgFJl8eLFFzwWFBSkq666SvXr15fNZiu+ogAUGSskAEqVO++8U4cOHZLT6VR4eLgkKS0tTRaLRef/OatZs6Zmz57NfUmAUoQbowEoVR555BFFRUVp6dKl2rx5szZv3qxly5apTp06GjZsmNasWaNq1app9OjRpksFcAlYIQFQqjRr1kxvv/22YmNjPdp/+OEH9enTR999951+/fVXde3aVRs2bDBUJYBLxQoJgFIlLS1NYWFhedqDg4N15swZSZLdbldWVlZxlwagCAgkAEqVhg0bavTo0UpLS3O3paamauzYse4P3VuxYoVq1qxpqkQAhcAlGwClysGDB9W5c2elpKSoZs2acrlc+v333xUREaEZM2boyJEjeuaZZzRu3DjdeeedpssFUEAEEgClzrlz5/TFF19ox44dstlsqlWrlu6++24FBQXpjz/+UFZWlq655hrTZQK4BAQSAKVSenq69u7dq8DAQFWrVi3ffSUASg9ujAagVHG5XHrzzTf1/vvvKzc3V5IUGBiof/3rXxo6dCi3lQdKKQIJgFLl3Xff1aJFizRo0CA1bNhQTqdTmzdv1jvvvKOrrrpKTz31lOkSARQCl2wAlCpxcXHq37+/7r77bo/2zz77TBMnTtSKFSsMVQagKHjbL4BS5dSpU7rxxhvztNerV09HjhwxUBEAbyCQAChVatSooXXr1uVpX7t2rapUqWKgIgDewB4SAKVKly5dNGzYMB06dEixsbGyWCxKTEzUBx98oBdeeMF0eQAKiT0kAEqdOXPmaMaMGTp58qQkqUKFCuratau6detmuDIAhUUgAVBqJScny+VyqUKFCqZLAVBE7CEBUGpFRka6w8imTZvUokULswUBKDQCCQC/kJWVpWPHjpkuA0AhEUgAAIBxBBIAAGAcgQQAABjHfUgAlHiTJk362z779+8vhkoA+AqBBECJ9+mnnxaoX+XKlX1cCQBf4T4kAADAOPaQAAAA4wgkAADAOAIJAAAwjkACABfBNjugeBBIAEiSnnjiCcXExOjhhx++YJ9+/fopJiZGgwcPdrfFxcV5fH0pPvnkE8XExOipp57K9/jEiRMVExNTqLELY/DgwYqLi3N/vWrVKg0aNMj99caNGxUTE6ONGzcWW03A5YJAAsDNarXqhx9+0JEjR/IcO3v2rL799luvPt+iRYsUHR2tdevW6eDBg14duzB69uzpcc+TOXPm5Pu9AOB9BBIAbrVr11aZMmX05Zdf5jm2evVqlSlTRldddZVXnmvfvn3aunWrBgwYoPDwcH300UdeGbco/vGPf6h27dqmywAuSwQSAG6hoaFq3ry5li9fnufYsmXLdNdddykgwDv3U1y0aJHCw8N1yy236K677tKiRYuUnZ39t+fNnDlTd9xxh+rWrauHH35Yq1evznMZZfv27erWrZtuvvlmxcbGqkePHvrtt9/cx89fevnwww/VsmVL3XrrrVq7dq3HJZsnnnhCmzZt0qZNm/KMv3fvXnXr1k316tXTbbfdpjFjxig3N9d9PCYmRgsWLNDgwYN10003qXHjxnr99dd17tw5jRo1Sk2aNNHNN9+s+Ph4ZWVleePbCZR6BBIAHtq1a6cff/xRhw8fdrelp6drzZo1uueee7zyHA6HQ0uWLFG7du0UFBSkjh076tSpU1q5cuVFz5s0aZLGjBmjtm3bavLkyapXr5769evn0WfDhg165JFH5HQ6NWLECL3++us6cuSIHn74Ye3Zs8ej77hx4zRo0CANGjRI9evX9zg2fPhw1a5dW7Vr19bChQtVp04d97GEhATddNNNmjp1qu68805Nnz5dH374ocf5Y8aMUVBQkCZNmqT27dtr3rx5uv/++3XkyBGNHj1aDz/8sD755BPNmzevEN9BwP9w63gAHlq0aKHQ0FB9+eWX6tq1qyTp66+/VmRkpG666SavPMeaNWt0/PhxPfDAA5Kk+vXr69prr9WCBQvUrl27fM/JzMzU9OnT9dhjj2nAgAGSpKZNm+rs2bNauHChu99bb72latWqacaMGbLZbO5+rVu31sSJE/X222+7+z788MO666678n2+a6+9VmFhYe76/qpTp07q2bOnJKlJkyb65ptvtGHDBj3++OPuPlFRUXr11VclSY0aNdInn3yinJwcjRkzRgEBAbr99tu1evVqbd26taDfNsCvsUICwENwcLDi4uI8Ltt88cUXateunSwWi1eeY9GiRapevbpq1qyp1NRUpaamqm3bttq0aVOeVYzzfvjhB507dy5PgPjrqk1mZqa2b9+udu3aucOIJNntdrVs2TLPu2MK+w6ehg0bun9vsVh09dVXKzU11aNPgwYN3L8PCAhQRESEbrjhBo9LXuXLl1daWlqhagD8DSskAPJo27atnnvuOR06dEhly5bV+vXr1bdvX6+MnZycrG+//VY5OTlq1KhRnuMLFy7U0KFD8z1PkiIjIz3ar7jiCvfv09LS5HK5PNr+2u9///OvUKFCoV5DSEiIx9dWqzXP/UrOr65c7DwA/x+BBEAezZo1U3h4uL766iuFh4eratWquuGGG7wy9pIlS5STk6NJkybJbrd7HHvnnXe0ePFiPf/88woODvY4VqlSJUl/BpNrrrnG3X4+qEhSeHi4LBaLTp48med5T5w4ofLly3vlNQDwPgIJgDyCgoJ0xx13aMWKFQoNDdXdd9/ttbE//fRT1a9fX61bt85zLDk5WX379tXy5cvVoUMHj2O1atVSeHi4VqxY4XHJ5KuvvnL/PjQ0VDfccIOWLVumnj17ui/bpKWl6dtvv1WTJk0uqVar1Sqn03lJ5wAoHAIJgHy1a9dO3bt3l9Vq1YsvvnjRvrt379acOXPytNevX99jQ+hPP/2kXbt2KT4+Pt9x7rjjDpUrV04ffvhhnkASFhamp556ShMmTFBISIgaN26sTZs2acGCBZL+DA+S1L9/f3Xr1k1PPfWUHn/8ceXk5Ojdd99Vdna2evXqdQnfgT/3nmzbtk3r16/n/iSAjxFIAOTr1ltvld1uV+XKlRUVFXXRvtu3b9f27dvztPfq1csjkCxatEg2m+2C76QJCgpS27Zt9eGHH2rHjh15jnfv3l1Op1MLFy7UzJkzVa9ePQ0YMEAJCQkKDQ2VJN1yyy2aPXu2JkyYoOeff15BQUFq2LChRo0apeuuu+4SvgPSY489pp9//llPP/20EhISdOWVV17S+QAKzuLik6MAlAK5ubn6/PPPdfPNN6ty5cru9g8++ECvv/66Nm7cmGdPCoDSg0ACoNS4++67FRQUpGeffVYRERHauXOnxo8fr9atWyshIcF0eQCKgEACoNQ4ePCgxo4dq40bNyo1NVVVqlTRfffdp+7duyswMNB0eQCKgEACAACM406tAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwLj/B5gdpuDY88upAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiQAAAKLCAYAAADGuZNLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABccElEQVR4nO3de5zMdf//8efM7M6eh11hnWmLjavkTDlEtoNOqKsoly6ko0MuNsQVdamtrPYKOR+iA4orJIqLyqXLMSrFrpJE9pBs9mgPM/P7w2V+7XeptWb2bcfjfrvtbXbf8/689/UZH+Pp/XnP52Nxu91uAQAAGGQ1XQAAAACBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGCc8UDicrk0depUderUSc2bN9fAgQN1+PDhc/b/+eef9be//U3t2rVTu3btNHz4cKWlpZXos27dOvXo0UNXX3217rjjDm3evNnXuwEAAC6A8UAyY8YMLV26VJMmTdKyZctksVg0ePBgFRYWnrX/iBEjlJqaqoULF2rhwoVKS0vT448/7nl+27Ztio+P1/3336+VK1eqY8eOeuKJJ3Tw4MGK2iUAAHCeLCbvZVNYWKj27dsrPj5effv2lSRlZWWpU6dOeuGFF3TbbbeV6J+VlaU2bdpo5syZ6tatmyRp48aNevzxx7Vt2zZFRkZq0KBBcjgcSkpK8mzXp08fNW7cWM8991y5a3W73XK5uO3P+bBaLbxmqBAca6goHGvnz2q1yGKx/GG/gAqo5ZySk5OVm5ur9u3be9ocDoeaNm2qnTt3lgokQUFBCg0N1cqVK9W2bVtJ0qpVq9SwYUNVqVJFLpdLu3fv1pgxY0ps165dO23YsOGCanW53DpxIveCxriUBARYFRkZpqysPBUXu0yXAz/GsYaKwrFWPlFRYbLZLvJAcmbtR61atUq016hRQ6mpqaX6BwUF6fnnn9dzzz2n1q1by2KxqHr16nrzzTdltVr166+/Ki8vT9HR0WUa73wFBBg/w1Vp2GzWEo+Ar3CsoaJwrPmW0UCSn58vSbLb7SXag4KCdPLkyVL93W63UlJS1KJFCz300ENyOp1KSkrSE088oSVLlujUqVPnHK+goOCCarVaLYqMDLugMS5FDkeI6RJwieBYQ0XhWPMNo4EkODhY0um1JGe+l6SCggKFhJT+A//ggw/09ttv6+OPP1Z4eLgkadasWeratatWrFihO++80zPeb51rvPPhcrmVlZV3QWNcSmw2qxyOEGVl5cvpZGoTvsOxhorCsVY+DkdImWaVjAaSM6dqMjIyVL9+fU97RkaGYmNjS/X//PPP1ahRI08YkaQqVaqoUaNG+uGHH1S1alWFhoYqIyOjxHYZGRmlTuOUB+cMz5/T6eJ1Q4XgWENF4VjzDaMnwmJjYxUeHq7t27d72rKysrRv3z61bt26VP9atWrp8OHDJU6/5Ofn6+jRo2rQoIEsFotatmypHTt2lNhu+/btatWqle92BAAAXBCjgcRut6tfv35KTEzUxo0blZycrBEjRig6OlpxcXFyOp36+eefPWtDevbsKUl68sknlZyc7Olvt9vVu3dvSdKAAQP0wQcfaOHChTp48KBefvll7d+/Xw8++KCp3QQAAH/A+FLhYcOG6Z577tH48ePVt29f2Ww2zZ8/X3a7XampqerYsaPWrl0r6fSnZd5++2253W49+OCDGjBggAIDA7VkyRI5HA5JUseOHfXCCy9oyZIl6tWrl7Zt26ZZs2YpJibG5G4CAIDfYfTCaJWJ0+niOiTn4czn9TMzcznXCp/iWENF4Vgrn9PXIfnj+Q/jMyQAAAAEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGBcgOkCUHlk/Jqv/FPFZeprs1l0+OdcuYudcjrLdneCkOAA1agaciElAgAqKQIJyiQ7r1BjZ2+VL+98ZLVYlDT0ekWE2n33SwAAFyUCCcokItSuhEc6lHmGJD0zT7NWfaNH72qmmpGhZdomJDiAMAIAlygCCcrsfE6n2GwWSVLty8JUt3q4r0oCAPgJFrUCAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjuNsvAOCSlfFrvvJPFZepr81m0eGfc+UudsrpdJdpm5DggPO6U/qljEACALgkZecVauzsrXKXLVuUi9ViUdLQ6xURavfdL/ETBBIAwCUpItSuhEc6lHmGJD0zT7NWfaNH72qmmpGhZdomJDiAMFJGBBIAwCXrfE6n2GwWSVLty8JUt3q4r0q6ZLGoFQAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYZv3S8y+XS9OnT9e677yorK0utWrXShAkT1KBBg1J9p02bpunTp591nN69eyshIUGS1K1bN/30008lnr/jjjuUmJjo/R0AAAAXzHggmTFjhpYuXaqEhATVrFlTkydP1uDBg7VmzRrZ7SVvSDRw4ED16dOnRNvy5cs1a9YsPfjgg5KknJwcHTt2TLNnz1azZs08/YKDg32/MwAAoFyMBpLCwkItWLBA8fHx6tKliyQpKSlJnTp10oYNG3TbbbeV6B8WFqawsDDPzz/++KNmz56tMWPGKDY2VpJ04MABud1utWzZUg6Ho+J2BgAAlJvRNSTJycnKzc1V+/btPW0Oh0NNmzbVzp07/3D7F198UVdeeaXuu+8+T1tKSoqqV69OGAEAoBIxOkOSlpYmSapVq1aJ9ho1aig1NfV3t927d682btyoRYsWyWr9/7nqwIEDCg0N1dChQ7Vnzx5FRUWpd+/e6t+/f4l+5REQwBrgsrLarJ5HXjf4ku1/x9qZR8BXeF/zLaOBJD8/X5JKrRUJCgrSyZMnf3fb119/Xc2bNy8xuyJJ3377rbKzs9WjRw8NGTJEu3btUmJiok6ePKnhw4eXu1ar1aLIyLA/7ghJ0i+5RZKksLAgXjdUCIcjxHQJ8HO8r/mW0UByZqFpYWFhiUWnBQUFCgk595tLXl6eNmzYoAkTJpR6buHChSooKFB4eLgkqUmTJsrNzdXMmTM1dOjQcs+SuFxuZWXllWvbS1FuboHnMTMz13A18Gc2m1UOR4iysvLldLpMlwM/xvta+TgcIWWawTQaSM6cqsnIyFD9+vU97RkZGZ5Fqmfzn//8Ry6XS3FxcaWeCwwMVGBgYIm2xo0bKy8vTydPnlRkZGS56y0u5s2urFz/+4fB5XTxuqFCODnW4GO8r/mW0ZNgsbGxCg8P1/bt2z1tWVlZ2rdvn1q3bn3O7T7//HM1a9as1MJVl8ulbt26aebMmSXa9+7dq8suu+yCwggAAPAdozMkdrtd/fr1U2JioqKiolSnTh1NnjxZ0dHRiouLk9Pp1IkTJxQREVHilE5ycrIaN25cajyr1aqbb75Z8+bNU8OGDdWsWTNt3bpV8+bN07hx4ypy1wAAwHkwfmG0YcOGqbi4WOPHj9epU6fUpk0bzZ8/X3a7XUePHtWNN96ohIQE9e7d27PN8ePH1bx587OON3LkSDkcDk2ZMkVpaWmqW7euxo0bp3vvvbeidgkAAJwni9vtdpsuojJwOl06cYJFTGV19OccPTN/h54b1FZ1q4ebLgd+LCDAqsjIMGVm5nJeHz7F+1r5REWFlWlRKx+kBgAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgXIDpAmBW+ok8nSp0en/czDxJ0rHjuXI63V4fP9huU82oUK+PCwAwg0ByCUs/kaexc7b59HfMWvWNz8ZOeLg9oQQA/ASB5BJ2ZmZk8B1NVbtamFfHttkssgQGyF1U7PUZkmO/5Gru+/t8MrMDADCDQALVrhamBtERXh0zIMCqyMgwZWbmqrjY5dWxAQD+h0WtAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjDMeSFwul6ZOnapOnTqpefPmGjhwoA4fPnzWvtOmTVOTJk3O+jV27FhPv3Xr1qlHjx66+uqrdccdd2jz5s0VtTsAAKAcjAeSGTNmaOnSpZo0aZKWLVsmi8WiwYMHq7CwsFTfgQMHasuWLSW+nnzySQUHB+vBBx+UJG3btk3x8fG6//77tXLlSnXs2FFPPPGEDh48WNG7BgAAyshoICksLNSCBQs0dOhQdenSRbGxsUpKSlJ6ero2bNhQqn9YWJiqV6/u+crPz9fs2bM1ZswYxcbGSpLmzp2ruLg49evXTzExMRo9erSaNWumRYsWVfTuAQCAMjIaSJKTk5Wbm6v27dt72hwOh5o2baqdO3f+4fYvvviirrzySt13332STp/+2b17d4nxJKldu3batWuXd4sHAABeE2Dyl6elpUmSatWqVaK9Ro0aSk1N/d1t9+7dq40bN2rRokWyWk/nqqysLOXl5Sk6Ovq8xyuLgADjZ7i8ymazeB69vW82m7XEo3fH9l3dqHx8eawBv2X93zFmtVl57/EBo4EkPz9fkmS320u0BwUF6eTJk7+77euvv67mzZuXmA05derUOccrKCi4oFqtVosiI8MuaIyLzS+5RZKkCEeIz/bN4Qjx+pgVUTcqH18ca8BvnXnvCQsL4r3HB4wGkuDgYEmn15Kc+V6SCgoKFBJy7jeXvLw8bdiwQRMmTCjRHhQU5Bnvt/5ovLJwudzKysq7oDEuNtlZ+Z7HzMxAr45ts1nlcIQoKytfTqfLq2P7sm5UPr481oDfys0t8DxmZuYarqbycDhCyjSDaTSQnDlVk5GRofr163vaMzIyPItUz+Y///mPXC6X4uLiSrRXrVpVoaGhysjIKNGekZFR6jROeRQX+9ebndPp9jz6at+cTpfXx66IulH5+OJYA37L9b/A6+JY8wmjJ8FiY2MVHh6u7du3e9qysrK0b98+tW7d+pzbff7552rWrJkcDkeJdovFopYtW2rHjh0l2rdv365WrVp5t3gAAOA1RmdI7Ha7+vXrp8TEREVFRalOnTqaPHmyoqOjFRcXJ6fTqRMnTigiIqLEKZ3k5GQ1btz4rGMOGDBADz/8sJo2barOnTtrxYoV2r9/v55//vmK2i0AAHCejC8THjZsmO655x6NHz9effv2lc1m0/z582W325WamqqOHTtq7dq1JbY5fvy4qlatetbxOnbsqBdeeEFLlixRr169tG3bNs2aNUsxMTEVsDcAAKA8jM6QSJLNZlN8fLzi4+NLPVe3bl2lpKSUav+/AeX/6tmzp3r27OmtEgEAgI8ZnyEBAAAgkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAuADTBcAsS1Ce0vJTZck+6dVxA2xWZbpDlJ2dr2Kny6tjp+XnyRKU59UxAQBmEUguYXnFeQq6ZrMWH9osHTJdzfkJusaivOI2kiJMlwIA8AICySUsNCBUBV911sM9G6vWZaFeHTvAZlVEhG9mSFKP52nOygMKbebdmgEA5hBILnHuglBFh9RS/QjvzjQEBFgVGRmmTEuuiou9G0jcudlyFxz16pgAALNY1AoAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA44wHEpfLpalTp6pTp05q3ry5Bg4cqMOHD5+zf1FRkaZMmaJOnTrp2muvVb9+/bR///4Sfbp166YmTZqU+Bo1apSvdwUAAJRTgOkCZsyYoaVLlyohIUE1a9bU5MmTNXjwYK1Zs0Z2u71U/4kTJ2rTpk1KSEhQvXr1lJSUpMGDB2vdunWKiIhQTk6Ojh07ptmzZ6tZs2ae7YKDgytytwAAwHkwOkNSWFioBQsWaOjQoerSpYtiY2OVlJSk9PR0bdiwoVT/I0eOaPny5UpISNANN9ygmJgYvfDCC7Lb7fr6668lSQcOHJDb7VbLli1VvXp1z1dERERF7x4AACgjo4EkOTlZubm5at++vafN4XCoadOm2rlzZ6n+W7ZskcPhUOfOnUv037Rpkzp06CBJSklJUfXq1eVwOHy/AwAAwCuMnrJJS0uTJNWqVatEe40aNZSamlqq/w8//KB69epp/fr1mjNnjtLT09W0aVONGTNGMTExkk7PkISGhmro0KHas2ePoqKi1Lt3b/Xv319W64Xlr4AA40tuvMpms3gevb1vNpu1xKN3x/Zd3ah8fHmsAb9l/d8xZrVZee/xAaOBJD8/X5JKrRUJCgrSyZMnS/XPycnRjz/+qBkzZuipp56Sw+HQzJkzdf/992vt2rWqVq2avv32W2VnZ6tHjx4aMmSIdu3apcTERJ08eVLDhw8vd61Wq0WRkWHl3v5i9EtukSQpwhHis31zOEK8PmZF1I3KxxfHGvBbZ957wsKCeO/xAaOB5MxC08LCwhKLTgsKChQSUvrNJTAwUNnZ2UpKSvLMiCQlJalLly5677339NBDD2nhwoUqKChQeHi4JKlJkybKzc3VzJkzNXTo0HLPkrhcbmVl5ZVr24tVdla+5zEzM9CrY9tsVjkcIcrKypfT6fLq2L6sG5WPL4814Ldycws8j5mZuYarqTwcjpAyzWAaDSRnTtVkZGSofv36nvaMjAzFxsaW6h8dHa2AgABPGJFOh5p69erp6NGjkk6HlsDAkv9INW7cWHl5eTp58qQiIyPLXW9xsX+92Tmdbs+jr/bN6XR5feyKqBuVjy+ONeC3XP8LvC6ONZ8wehIsNjZW4eHh2r59u6ctKytL+/btU+vWrUv1b926tYqLi7V3715P26lTp3TkyBE1aNBALpdL3bp108yZM0tst3fvXl122WUXFEYAAIDvGJ0hsdvt6tevnxITExUVFaU6depo8uTJio6OVlxcnJxOp06cOKGIiAgFBwerdevWuu666zR69Gg999xzqlq1qqZOnSqbzaa77rpLVqtVN998s+bNm6eGDRuqWbNm2rp1q+bNm6dx48aZ3FUAAPA7jF8YbdiwYSouLtb48eN16tQptWnTRvPnz5fdbtfRo0d14403KiEhQb1795YkTZs2TYmJiRoyZIhOnTqlli1bavHixYqKipIkjRw5Ug6HQ1OmTFFaWprq1q2rcePG6d577zW5mwAA4HcYDyQ2m03x8fGKj48v9VzdunWVkpJSoi08PFwTJ07UxIkTzzpeQECAHnvsMT322GO+KBcAAPgAH6QGAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGBZguAAAAb0o/kadThU7vj5uZJ0k6djxXTqfb6+MH222qGRXq9XErCwIJAMBvpJ/I09g523z6O2at+sZnYyc83P6SDSUEEgCA3zgzMzL4jqaqXS3Mq2PbbBZZAgPkLir2+gzJsV9yNff9fT6Z2aksCCQAAL9Tu1qYGkRHeHXMgACrIiPDlJmZq+Jil1fHBotaAQDARYBAAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMM54IHG5XJo6dao6deqk5s2ba+DAgTp8+PA5+xcVFWnKlCnq1KmTrr32WvXr10/79+8v0WfdunXq0aOHrr76at1xxx3avHmzr3cDAABcAOOBZMaMGVq6dKkmTZqkZcuWyWKxaPDgwSosLDxr/4kTJ2r58uX6xz/+oRUrVqhq1aoaPHiwsrOzJUnbtm1TfHy87r//fq1cuVIdO3bUE088oYMHD1bkbgEAgPNgNJAUFhZqwYIFGjp0qLp06aLY2FglJSUpPT1dGzZsKNX/yJEjWr58uRISEnTDDTcoJiZGL7zwgux2u77++mtJ0ty5cxUXF6d+/fopJiZGo0ePVrNmzbRo0aKK3j0AAFBGRgNJcnKycnNz1b59e0+bw+FQ06ZNtXPnzlL9t2zZIofDoc6dO5fov2nTJnXo0EEul0u7d+8uMZ4ktWvXTrt27fLdjgAAgAsSYPKXp6WlSZJq1apVor1GjRpKTU0t1f+HH35QvXr1tH79es2ZM0fp6elq2rSpxowZo5iYGGVlZSkvL0/R0dFlGu98BQQYP8PlVTabxfPo7X2z2awlHr07tu/qRuXjy2MNlQ/va5WX0UCSn58vSbLb7SXag4KCdPLkyVL9c3Jy9OOPP2rGjBl66qmn5HA4NHPmTN1///1au3atioqKzjleQUHBBdVqtVoUGRl2QWNcbH7JPf16RThCfLZvDkeI18esiLpR+fjiWEPlw/ta5WU0kAQHB0s6vZbkzPeSVFBQoJCQ0n/ggYGBys7OVlJSkmJiYiRJSUlJ6tKli9577z3dfffdnvF+61zjnQ+Xy62srLwLGuNik52V73nMzAz06tg2m1UOR4iysvLldLq8OrYv60bl48tjDZUP72sXH4cjpEyzSkYDyZlTNRkZGapfv76nPSMjQ7GxsaX6R0dHKyAgwBNGpNOhpl69ejp69KiqVq2q0NBQZWRklNguIyOj1Gmc8igu9q83O6fT7Xn01b45nS6vj10RdaPy8cWxhsqH97XKy+iJqtjYWIWHh2v79u2etqysLO3bt0+tW7cu1b9169YqLi7W3r17PW2nTp3SkSNH1KBBA1ksFrVs2VI7duwosd327dvVqlUr3+0IAAC4IF4JJDt37lRe3vmfzrDb7erXr58SExO1ceNGJScna8SIEYqOjlZcXJycTqd+/vlnnTp1StLpQHLddddp9OjR2rVrl7777js99dRTstlsuuuuuyRJAwYM0AcffKCFCxfq4MGDevnll7V//349+OCD3thVAADgAxccSJxOp/r3769Dhw6Va/thw4bpnnvu0fjx49W3b1/ZbDbNnz9fdrtdqamp6tixo9auXevpP23aNLVt21ZDhgzRPffco5ycHC1evFhRUVGSpI4dO+qFF17QkiVL1KtXL23btk2zZs0qcZoHAABcXLyyhsTtdpd7W5vNpvj4eMXHx5d6rm7dukpJSSnRFh4erokTJ2rixInnHLNnz57q2bNnuWsCAAAV69L8sDMAALioEEgAAIBxFxxIbDabFi9erEaNGnmjHgAAcAnyygxJ27ZtFRoaKkn66aefNGTIEG8MCwAALhFlXtTqdDo1depULV++XNLphaN/+9vfZLPZJJ2+OuqcOXM0b968C75MOwAAuLSUeYZkxowZmj17turVq6errrpKCxYs0Ny5cyVJu3bt0u23367p06erZs2amjVrls8KBgAA/qfMMyTr1q3THXfcocmTJ0uSFi5cqDfeeENXXnmlhg8frsDAQI0cOVJ//etfFRjoX9fhBwAAvlXmGZLU1FTdfvvtnp9vv/12HTt2TGPGjFHbtm21bt06DR48mDACAADOW5lnSPLz8xUZGen5uWrVqpKkdu3aadq0abJYLF4vDgAAXBrK/Skbq/X0pv379yeMAACAC3LBl44PCwvzRh0A4JHxa77yTxWXqa/NZtHhn3PlLnZ6buH+R0KCA1SjasiFlAjAyy44kDA7AsCbsvMKNXb2Vl3ALbL+kNViUdLQ6xURavfdLwFwXs4rkNx3332l2u6+++6z9t2/f3/5KgJwSYsItSvhkQ5lniFJz8zTrFXf6NG7mqlmZGiZtgkJDiCMABeZMgcSrr4KoKKcz+kUm+30LG3ty8JUt3q4r0oC4GNeDySfffaZ1qxZU+6CAADApcfrd/v97rvvtHLlSm8PCwAA/JjXAwkAAMD5IpAAAADjCCQAAMA4AgkAADCuzJ+y6d+/f5n6paWllbsYAABwaSpzIHGX8bKJNWvWVM2aNctdEAAAuPSUOZC88cYbvqwDAABcwlhDAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOPKfOl4ALgQ6SfydKrQ6f1xM/MkSceO58rpLNs9t85HsN2mmlGhXh8XQEkEEgA+l34iT2PnbPPp75i16hufjZ3wcHtCCeBjBBIAPndmZmTwHU1Vu1qYV8e22SyyBAbIXVTs9RmSY7/kau77+3wyswOgJAIJgApTu1qYGkRHeHXMgACrIiPDlJmZq+Jil1fHBlBxWNQKAACMI5AAAADjCCQAAMA4AgkAADDOeCBxuVyaOnWqOnXqpObNm2vgwIE6fPjwOfu/9957atKkSamv327TrVu3Us+PGjWqInYHAACUg/FP2cyYMUNLly5VQkKCatasqcmTJ2vw4MFas2aN7HZ7qf4pKSlq27atXnnllRLtUVFRkqScnBwdO3ZMs2fPVrNmzTzPBwcH+3ZHAABAuRkNJIWFhVqwYIHi4+PVpUsXSVJSUpI6deqkDRs26Lbbbiu1zYEDBxQbG6vq1aufdcwDBw7I7XarZcuWcjgcPq0fAAB4h9FTNsnJycrNzVX79u09bQ6HQ02bNtXOnTvPuk1KSoquuOKKc46ZkpKi6tWrE0YAAKhEjM6QpKWlSZJq1apVor1GjRpKTU0t1f/EiRM6fvy4du7cqTfeeEO//vqrmjdvrlGjRqlRo0aSTs+QhIaGaujQodqzZ4+ioqLUu3dv9e/fX1brheWvgADjS268ymazeB69vW82m7XEo3fH9l3d8A2ONVQUjrXKy2ggyc/Pl6RSa0WCgoJ08uTJUv0PHDggSbLZbHrppZeUl5enGTNm6P7779f777+vyy67TN9++62ys7PVo0cPDRkyRLt27VJiYqJOnjyp4cOHl7tWq9WiyEjvXvLatF9yiyRJEY4Qn+2bwxHi9TErom54F8caKgrHWuVlNJCcWWhaWFhYYtFpQUGBQkJK/4G3b99eO3bsUJUqVTxtr732mrp27ap//etfevjhh7Vw4UIVFBQoPDxcktSkSRPl5uZq5syZGjp0aLlnSVwut7Ky8sq17cUqOyvf85iZGejVsW02qxyOEGVl5cvp9O7lvH1ZN3yDYw0VhWPt4uNwhJRpVsloIDlzqiYjI0P169f3tGdkZCg2Nvas2/w2jEhSaGio6tatq/T0dElSYGCgAgNL/mE2btxYeXl5OnnypCIjI8tdr7/dJ+PMjcicTrfP9s3pdHl97IqoG97FsYaKwrFWeRk9URUbG6vw8HBt377d05aVlaV9+/apdevWpfq//fbbateunU6dOuVpy8nJ0Q8//KArrrhCLpdL3bp108yZM0tst3fvXl122WUXFEYAAIDvGA0kdrtd/fr1U2JiojZu3Kjk5GSNGDFC0dHRiouLk9Pp1M8//+wJIF27dpXb7dZTTz2lb7/9Vnv37tXQoUMVFRWlXr16yWq16uabb9a8efO0bt06/fjjj1q2bJnmzZt3QetHAACAbxm/MNqwYcNUXFys8ePH69SpU2rTpo3mz58vu92uo0eP6sYbb1RCQoJ69+6tWrVqadGiRUpMTFTfvn3ldrt1/fXXa/HixZ41KCNHjpTD4dCUKVOUlpamunXraty4cbr33nsN7ykAADgX44HEZrMpPj5e8fHxpZ6rW7euUlJSSrRdddVVmj9//jnHCwgI0GOPPabHHnvM67UCAADfuDQ/7AwAAC4qBBIAAGAcgQQAABhnfA0JgEuDJShPafmpsmSXvgrzhQiwWZXpDlF2dr6KvXyxqrT8PFmC/OuCiMDFikACwOfyivMUdM1mLT60WTpkuprzE3SNRXnFbSRFmC4F8GsEEgA+FxoQqoKvOuvhno1V67JQr44dYLMqIsI3MySpx/M0Z+UBhTbzbs0ASiOQAKgQ7oJQRYfUUv0I7840BARYFRkZpkxLrtcvue3OzZa74KhXxwRwdixqBQAAxhFIAACAcQQSAABgHIEEAAAYx6JW6HB6ttfHtNksOnw8T+6iYjmdbq+OfeyXXK+OBwAwj0ByCXO6TgeF19clG66kfILtNtMlAAC8hEByCbu8tkPj+7eWzWrx+tjpmXmateobPXpXM9WM9P41HILtNtWM4toQAOAvCCSXuMtrO3wyrs12OuTUvixMdauH++R3AAD8B4taAQCAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYZzyQuFwuTZ06VZ06dVLz5s01cOBAHT58+Jz933vvPTVp0qTU12+3WbdunXr06KGrr75ad9xxhzZv3lwRuwIAAMrJeCCZMWOGli5dqkmTJmnZsmWyWCwaPHiwCgsLz9o/JSVFbdu21ZYtW0p81a1bV5K0bds2xcfH6/7779fKlSvVsWNHPfHEEzp48GBF7hYAADgPRgNJYWGhFixYoKFDh6pLly6KjY1VUlKS0tPTtWHDhrNuc+DAAcXGxqp69eolvmw2myRp7ty5iouLU79+/RQTE6PRo0erWbNmWrRoUUXuGgAAOA9GA0lycrJyc3PVvn17T5vD4VDTpk21c+fOs26TkpKiK6644qzPuVwu7d69u8R4ktSuXTvt2rXLe4UDAACvCjD5y9PS0iRJtWrVKtFeo0YNpaamlup/4sQJHT9+XDt37tQbb7yhX3/9Vc2bN9eoUaPUqFEjZWVlKS8vT9HR0WUa73wFBBg/w1VpWG1WzyOvG2w2i+fR28eD7X/H2plH747tu7rhGxxrlZfRQJKfny9JstvtJdqDgoJ08uTJUv0PHDggSbLZbHrppZeUl5enGTNm6P7779f777+v4uLic45XUFBwQbVarRZFRoZd0BiXkl9yiyRJYWFBvG7wHA8RjhCfHQ8OR4jXx6yIuuFdHGuVl9FAEhwcLOn0WpIz30tSQUGBQkJK/4G3b99eO3bsUJUqVTxtr732mrp27ap//etf+vOf/+wZ77fONd75cLncysrKu6AxLiW5uQWex8zMXMPVwLTsrHzPY2ZmoFfHttmscjhClJWVL6fT5dWxfVk3fINj7eLjcISUaVbJaCA5c6omIyND9evX97RnZGQoNjb2rNv8NoxIUmhoqOrWrav09HRVrVpVoaGhysjIKNEnIyOj1Gmc8igu9u4B6M9c//vL6nK6eN0gp9PtefTV8eD0wbFWEXXDuzjWKi+jJ6piY2MVHh6u7du3e9qysrK0b98+tW7dulT/t99+W+3atdOpU6c8bTk5Ofrhhx90xRVXyGKxqGXLltqxY0eJ7bZv365WrVr5bkcAAMAFMRpI7Ha7+vXrp8TERG3cuFHJyckaMWKEoqOjFRcXJ6fTqZ9//tkTQLp27Sq3262nnnpK3377rfbu3auhQ4cqKipKvXr1kiQNGDBAH3zwgRYuXKiDBw/q5Zdf1v79+/Xggw+a3FUAAPA7jC/lHTZsmO655x6NHz9effv2lc1m0/z582W325WamqqOHTtq7dq1kk6f4lm0aJFyc3PVt29f/fWvf1VERIQWL17sWYPSsWNHvfDCC1qyZIl69eqlbdu2adasWYqJiTG5mwAA4HcYXUMinf7ETHx8vOLj40s9V7duXaWkpJRou+qqqzR//vzfHbNnz57q2bOnN8sEAAA+ZHyGBAAAgEACAACMI5AAAADjCCQAAMA4AgkAADDO+KdsAFw6Dqdne31Mm82iw8fz5C4q9lzt0luO/cJtD4CKQiAB4HNO1+mg8Pq6ZMOVlE+w3Wa6BMDvEUgA+NzltR0a37+1bFaL18dOz8zTrFXf6NG7mqlmZKjXxw+221QzyvvjAiiJQAKgQlxe2+GTcW220yGn9mVhqls93Ce/A4DvsagVAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYx91+AQB+xRKUp7T8VFmyT3p13ACbVZnuEGVn56vY6fLq2Gn5ebIE5Xl1zMqGQAIA8Bt5xXkKumazFh/aLB0yXc35CbrGorziNpIiTJdiBIEEAOA3QgNCVfBVZz3cs7FqXRbq1bEDbFZFRPhmhiT1eJ7mrDyg0GberbkyIZAAAPyKuyBU0SG1VD/CuzMNAQFWRUaGKdOSq+Ji7wYSd2623AVHvTpmZcOiVgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhkPJC6XS1OnTlWnTp3UvHlzDRw4UIcPHy7Ttu+//76aNGmio0ePlmjv1q2bmjRpUuJr1KhRvigfAAB4QYDpAmbMmKGlS5cqISFBNWvW1OTJkzV48GCtWbNGdrv9nNv99NNPevbZZ0u15+Tk6NixY5o9e7aaNWvmaQ8ODvZJ/QAA4MIZnSEpLCzUggULNHToUHXp0kWxsbFKSkpSenq6NmzYcM7tXC6X4uPjSwSOMw4cOCC3262WLVuqevXqnq+IiAhf7goAALgARgNJcnKycnNz1b59e0+bw+FQ06ZNtXPnznNuN2vWLBUVFemRRx4p9VxKSoqqV68uh8Phk5oBAID3GT1lk5aWJkmqVatWifYaNWooNTX1rNt89dVXWrBggZYvX6709PRSzx84cEChoaEaOnSo9uzZo6ioKPXu3Vv9+/eX1Xph+SsgwPiSm0rDarN6Hnnd4Esca/gtm83iefT28WD737F25tG7Y/uu7srCaCDJz8+XpFJrRYKCgnTy5MlS/fPy8jRq1CiNGjVKDRs2PGsg+fbbb5Wdna0ePXpoyJAh2rVrlxITE3Xy5EkNHz683LVarRZFRoaVe/tLzS+5RZKksLAgXjf4FMcafuvM8RDhCPHZ8eBwhHh9zIqo+2JnNJCcWWhaWFhYYtFpQUGBQkJK/4FPmjRJDRs2VJ8+fc455sKFC1VQUKDw8HBJUpMmTZSbm6uZM2dq6NCh5Z4lcbncysrKK9e2l6Lc3ALPY2ZmruFq4M841vBb2Vn5nsfMzECvjm2zWeVwhCgrK19Op8urY/uybtMcjpAyzSoZDSRnTtVkZGSofv36nvaMjAzFxsaW6r9ixQrZ7Xa1aNFCkuR0OiVJt99+u+68804999xzCgwMVGBgyT/Mxo0bKy8vTydPnlRkZGS56y0u9u4B6M9c//vL6nK6eN3gUxxr+C2n0+159NXx4PTBsVYRdV/sjAaS2NhYhYeHa/v27Z5AkpWVpX379qlfv36l+q9fv77Ez19++aXi4+M1Z84cxcTEyOVyqXv37vrzn/+sxx57zNNv7969uuyyyy4ojAAAAN8xGkjsdrv69eunxMRERUVFqU6dOpo8ebKio6MVFxcnp9OpEydOKCIiQsHBwWrQoEGJ7c8siq1du7aqVasmSbr55ps1b948NWzYUM2aNdPWrVs1b948jRs3rsL3DwAAlI3xC6MNGzZMxcXFGj9+vE6dOqU2bdpo/vz5stvtOnr0qG688UYlJCSod+/eZRpv5MiRcjgcmjJlitLS0lS3bl2NGzdO9957r4/3BAAAlJfxQGKz2RQfH6/4+PhSz9WtW1cpKSnn3LZdu3alng8ICNBjjz1W4pQNAAC4uF2aH3YGAAAXFQIJAAAwjkACAACMI5AAAADjCCQAAMA445+yAQDA2w6nZ3t9TJvNosPH8+QuKvZcWdVbjv3CbQ8IJAAAv+F0nQ4Kr69LNlxJ+QTbbaZLMIZAAuCik/FrvvJPFZepb3rm6ZteHjueW+b/tYYEB6hGVe/fsRXmXV7bofH9W8tmtXh97PTMPM1a9Y0evauZakaGen38YLtNNaO8P25lQSABcFHJzivU2Nlb5T7PGfFZq74pc1+rxaKkodcrItR+ntWhMri8tsMn49psp0NO7cvCVLd6uE9+x6WMQALgohIRalfCIx3KPENis1lkCbDJXew8rxkSwghwcSGQALjonM/plIAAqyIjw5SZmXvJ3rYd8Ad87BcAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxgWYLgAAAFMyfs1X/qniMvVNz8yTJB07niun012mbUKCA1Sjaki567uUGA8kLpdL06dP17vvvqusrCy1atVKEyZMUIMGDf5w2/fff1+jRo3Sxo0bVbduXU/7unXrNG3aNB05ckQNGzZUfHy8Onfu7MvdAABUMtl5hRo7e6vcZcsWHrNWfVPmvlaLRUlDr1dEqP08q7v0GA8kM2bM0NKlS5WQkKCaNWtq8uTJGjx4sNasWSO7/dx/gD/99JOeffbZUu3btm1TfHy8xowZow4dOmj58uV64okntHLlSsXExPhyVwAAlUhEqF0Jj3Qo8wyJzWaRJcAmd7HzvGZICCNlYzSQFBYWasGCBYqPj1eXLl0kSUlJSerUqZM2bNig22677azbuVwuxcfHq1mzZtq2bVuJ5+bOnau4uDj169dPkjR69Gjt2bNHixYt0nPPPefbHQIAVCrnczolIMCqyMgwZWbmqrjY5cOqLk1GF7UmJycrNzdX7du397Q5HA41bdpUO3fuPOd2s2bNUlFRkR555JES7S6XS7t37y4xniS1a9dOu3bt8m7xAADAa4zOkKSlpUmSatWqVaK9Ro0aSk1NPes2X331lRYsWKDly5crPT29xHNZWVnKy8tTdHR0mcc7HwEBfCiprKw2q+eR1w2+ZPvfsXbmEfAVjjXfMhpI8vPzJanUWpGgoCCdPHmyVP+8vDyNGjVKo0aNUsOGDUsFklOnTp1zvIKCgguq1Wq1KDIy7ILGuJT8klskSQoLC+J1Q4VwOPgkAyoGx5pvGA0kwcHBkk6vJTnzvSQVFBQoJKT0H/ikSZPUsGFD9enT56zjBQUFecb7rXONdz5cLreysvIuaIxLSW5ugecxMzPXcDXwZzabVQ5HiLKy8uV0cl4fvsOxVj4OR0iZZpWMBpIzp2oyMjJUv359T3tGRoZiY2NL9V+xYoXsdrtatGghSXI6nZKk22+/XXfeeaeeffZZhYaGKiMjo8R2GRkZpU7jlAeLmMrO9b+/rC6ni9cNFcLJsYYKwrHmG0YDSWxsrMLDw7V9+3ZPIMnKytK+ffs8n5L5rfXr15f4+csvv1R8fLzmzJmjmJgYWSwWtWzZUjt27NCf//xnT7/t27erVatWvt0ZAABQbkYDid1uV79+/ZSYmKioqCjVqVNHkydPVnR0tOLi4uR0OnXixAlFREQoODi41MXSziyKrV27tqpVqyZJGjBggB5++GE1bdpUnTt31ooVK7R//349//zzFb5/AACgbIwvFR42bJjuuecejR8/Xn379pXNZtP8+fNlt9uVmpqqjh07au3atWUer2PHjnrhhRe0ZMkS9erVS9u2bdOsWbO4KBoAABcxi9t9vhfNvTQ5nS6dOMHizLI6+nOOnpm/Q88Naqu61cNNlwM/xsWqUFE41sonKiqsTItajc+QAAAAEEgAAIBxxm+uh8qD23QDAHyFQIIy4TbdAABfIpCgTLhNNwDAlwgkKDNu0w0A8BUWtQIAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4yxut9ttuojKwO12y+XipTofNptVTqfLdBm4BHCsoaJwrJ0/q9Uii8Xyh/0IJAAAwDhO2QAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJPCJoqIi7d27V7m5uaZLAQBUAgGmC4B/SE1N1bhx4/Tkk0+qSZMmuvvuu/Xdd9+pSpUqev3113XVVVeZLhF+5PPPP9fnn3+uoqIiud3uEs8NGTLEUFXwRxkZGXrnnXf0/fffa9y4cdqxY4caN26smJgY06X5HYv7//5tBsph2LBhSk1NVVJSknbv3q0JEyZo/vz5Wr58udLS0rRgwQLTJcJPzJkzR6+88oqqVKmisLCwEs9ZLBZt3LjRUGXwN4cPH9a9996r8PBwpaena926dZo8ebL+85//aP78+WrZsqXpEv0KgQRe0bZtWy1atEhXXXWVRo4cqeLiYr366qs6dOiQevfurT179pguEX6ic+fOuvvuuzV8+HDTpcDPPfbYY4qKitKkSZPUsmVLrV69WrVr19aYMWOUmpqqN99803SJfoU1JPCKoqIiValSRZK0detWXXfddZIkl8ulgADODMJ7Tp48qZ49e5ouA5eAPXv2aMCAAbJYLJ42m82mRx99VPv37zdYmX/iXwp4RdOmTfXuu++qRo0ayszMVJcuXVRYWKi5c+cqNjbWdHnwI61atdLevXvVoEED06XAzzmdTrlcrlLtOTk5stlsBirybwQSeMXo0aP16KOPKjMzU4MHD1Z0dLQmTpyof//735o/f77p8uBHbr31Vj333HP6+uuvdfnll8tut5d4ntkTeEvHjh01c+ZMJSYmetoyMzM1efJktW/f3mBl/ok1JPAat9ut7OxsORwOSdKhQ4dUtWpVRUZGGq4M/uT3ZtwsFgtT6fCa9PR09e/fX7/++quys7N1+eWX66efflLVqlX15ptvqk6dOqZL9CsEEnjVzp07dfDgQd1+++1KS0tTgwYNFBgYaLosACiX/Px8rVmzRvv375fL5dKVV16pu+66S+Hh4aZL8zsEEnhFTk6OBg0apC+//FIWi0Xr16/X888/rx9++EGvv/66oqOjTZcIP/P9998rJSVFgYGBiomJUaNGjUyXBD9VWFioo0ePql69epLEf7J8hE/ZwCteeeUVWSwWbdiwQcHBwZKkp556SqGhoXr55ZcNVwd/UlhYqGHDhqlHjx4aMWKEhgwZoh49eujxxx9XYWGh6fLgR9xutxITE9WmTRvPrO/o0aM1duxYFRUVmS7P7xBI4BUff/yxnnrqKc//ICTp8ssv14QJE7R161aDlcHfJCUl6auvvtLMmTO1a9cubd++XdOmTdO+ffs0bdo00+XBj7zxxhtatWqVJkyY4Fk83b17d23atEmvvvqq4er8D4EEXnHixAlVr169VHt4eLjy8/MNVAR/tWbNGj377LPq2rWrwsPDVaVKFXXv3l0TJkzQ+++/b7o8+JFly5bpmWeeUe/evT3XIunRo4eef/55ffDBB4ar8z8EEnjF1VdfrbVr15ZqX7x4sZo2bWqgIvirnJycs16DpFGjRjpx4oSBiuCvjh49etb7cDVp0kTHjx83UJF/4zok8Iq//e1vGjBggPbs2aPi4mLNnDlT3333nfbt28d1SOBVjRs31ocffqhHH320RPvatWtZ2AqvqlOnjr766ivVrVu3RPunn35a4vQ0vINAAq9o2bKlli1bpgULFqhBgwb64osvdOWVV2rcuHFq3ry56fLgRx577DE9/vjjSk5OVsuWLWWxWLRr1y5t2LChxAWsgAs1aNAgPfvss0pPT5fb7dbWrVu1dOlSvfHGGxo7dqzp8vwOH/uFV3z88cfq0qWLrFbOAsL3/v3vf2vOnDk6cOCA3G63GjdurEGDBumWW24xXRr8zLJlyzRz5kylpaVJkqpVq6aHHnpIAwYMMFyZ/yGQwCuaN2+uiIgI3XXXXerdu7diYmJMlwQAF2T16tXq0qWLqlSpohMnTsjtdqtatWqmy/JbBBJ4RU5Ojj744AOtXLlSe/bs0TXXXKPevXvr9ttv54qGuGDTp0/XoEGDFBISounTp/9u3yFDhlRQVfB3bdu21ZIlS/gPVgUhkMDrDh8+rPfff1/r16/Xjz/+qO7du+uee+7hZlQot27dumnFihWKjIxUt27dztnPYrFo48aNFVgZ/Nm9996rv/71r+rRo4fpUi4JBBJ4XVFRkT755BN9+OGH2rhxoyIjI5WVlaXatWtr8uTJv3tzNAC4WIwbN07vvfeeYmNj1bBhQwUFBZV4PiEhwVBl/olAAq/ZvXu3Vq1apQ8//FAFBQXq3r277r77bnXo0EF5eXl6+umnlZycrA8//NB0qajkTp06JavVKrvdroMHD+qTTz5RixYt1LJlS9OlwY/85S9/+d3n33jjjQqq5NJAIIFXxMXF6ejRo2ratKnuvvtu3XHHHYqIiCjR56OPPtL48eO1c+dOQ1XCH+zcuVNPPPGEXn31VV1xxRW6+eabZbValZeXpylTpujWW281XSIqsbFjx2rcuHGsfTOAz2jCK7p27apVq1ZpxYoVuv/++0uFEUnq0KGDPvroIwPVwZ+88soruvHGGz1XBw4PD9eWLVs0btw4zZ4923R5qORWrlypgoIC02Vckggk8Iqnn35ajRs3Putzx44dkyQ5HA5FRUVVZFnwQ/v27dPjjz/uCSI33HCDgoODdcMNN+j77783XR4qOU4amMOVWuEVP/30k1588UWlpKTI6XRKOv0Xu7CwUCdOnNC+ffsMVwh/ERISosLCQhUWFmrXrl164YUXJEnHjx8/68wccL7O3EgPFYtAAq/4xz/+oUOHDunWW2/V/PnzNXDgQB06dEgbNmzQc889Z7o8+JF27dpp8uTJqlKliiSpU6dO2r9/vyZNmqR27doZrg7+4Prrry9Tv/379/u4kksLgQResWvXLs2cOVNt2rTR5s2b1b17d11zzTVKSkrSp59+qnvvvdd0ifATEyZM0IQJE5SSkqLJkycrPDxcq1atUkBAAPcXgVeMHTuW2TYDCCTwioKCAs8dMS+//HKlpKTommuuUc+ePf/wo3PA+YiKitK0adNKtI0cOVKBgYGGKoK/ue2227hEvAEsaoVX1KtXTwcOHJAkNWzY0DOV6XK5lJuba7I0+KHdu3frxIkTkk5/KmLIkCGaPXs2CxJxwVg/Yg6BBF7Ru3dvPfXUU567/q5YsULz5s3TpEmT1KRJE9PlwY8sXbpUDzzwgFJSUnTgwAGNHTtWRUVFWrhwoV577TXT5aGSI9Saw4XR4DWvv/66GjZsqBtuuEFz587VrFmzVKtWLU2ePFlXXXWV6fLgJ2699Vb169dPDzzwgF599VVt3LhRq1ev1ubNmzVx4kRt2rTJdIkAyoFAAqBSufrqq7V+/XrVqlVL9957r9q2batRo0bp2LFjuuWWW/TVV1+ZLhFAObCoFRfszBqRsLAwSdKhQ4e0fPlyud1u3XHHHcyOwKuqVaumjIwMBQYG6uuvv9aIESMkScnJybrssssMVwegvAgkKLecnByNHz9e69evl8ViUY8ePfToo4/qvvvuk9PplNvt1qJFizRr1ix16tTJdLnwE7fddptGjRqlkJAQRUdHq23btlq7dq3+8Y9/6J577jFdHoBy4pQNym3ChAnauXOnHn/8cQUHB2v+/Pn64Ycf1Lp1a02ZMkXS6UvKp6enc1dMeI3L5dJbb72lI0eO6IEHHlCDBg30xhtv6Pjx4xo2bJhsNpvpEgGUA4EE5daxY0e98soratu2rSQpLS1NN9xwg9588021bt1aknTgwAE98MAD3OEXQKXjcrm0Zs0aff755yoqKir1CZyEhARDlfknTtmg3E6cOKH69et7fo6OjlZQUFCJ8/hRUVFchwRe9+mnn2r+/Pn6/vvvtWzZMq1YsUL169dXz549TZcGP/LSSy9p8eLFio2NVXh4uOly/B6BBOXmcrlKXR3TarWWmjJnEg7e9Nlnn2nIkCG67bbb9MUXX8jlcsnpdOrpp5+W0+nU3XffbbpE+IlVq1Zp/PjxeuCBB0yXckngwmgoN4vFwlUNUeGmTZumkSNH6sUXX/SE3xEjRmjkyJFauHCh4ergTwoKCliQX4GYIUG5ud1uPfHEEyVmSQoKCjRq1CgFBQVJkoqKikyVBz+VkpKil19+uVT7TTfdpKlTpxqoCP6qU6dO+s9//sMMSQUhkKDcevXqVaqtTp06pdoaNmxYAdXgUhEREaH09PQS65ck6dtvv1WVKlUMVQV/dPXVV+vll1/W1q1bFRMTU+oU9ZAhQwxV5p/4lA2ASmXy5Mn67LPP9Pzzz+svf/mL3n77baWnp2vixIm6+eabNWbMGNMlwk9069btnM9ZLBZt3LixAqvxfwQSAJVKUVGRxowZow8++EDS6X8Y3G63brjhBr366que04UAKhcCCYBK5YcfflDDhg31448/at++fXK5XGrcuLGuuOIK06XBT/3nP/9RSkqKAgICdOWVV6p9+/ZcgM8HCCQAKpWOHTtqxowZuuaaa0yXAj+XlZWlgQMH6uuvv5bD4ZDL5VJOTo6aNWumhQsXyuFwmC7Rr/CxXwCVit1uV0AA6/Hhey+99JIKCgq0evVq7dixQ7t27dLKlStVWFjouT0GvIcZEnjVsWPHdPDgQbVp00a5ubmqVq2a6ZLgZ/75z3/qnXfe0V133aUGDRooODi4xPNcrRXe0r59e02bNk1t2rQp0b5jxw6NGDFCn332maHK/BP/zYBXFBYWavTo0Vq3bp2sVqs++ugjvfTSS8rOztb06dMVERFhukT4iVmzZknSWS+CZrFYCCTwmuLiYkVFRZVqr1atmnJycgxU5N84ZQOvmDlzppKTk7Vo0SLPpxz69++vn376SZMnTzZcHfxJcnLyOb/2799vujz4kWbNmmnJkiWl2t9++21dddVVBiryb5yygVfcdNNNmjhxoq677jq1aNFCq1evVr169bR161bFx8dry5YtpksEgPOyZ88e9e/fX7GxsWrZsqUsFot27dql5ORkzZ07Vx06dDBdol/hlA284mxXzpSkWrVqKSsry0BF8FexsbHnvIdSYGCgoqOjddddd+nxxx/nXku4IC1atNBbb72lBQsWaMuWLXK73WrcuLHGjx+va6+91nR5fodAAq+IiYnRf//7X917770l2tesWcP1IeBVY8eO1SuvvKL7779frVq1kiR9+eWXevPNN9WnTx9VqVJFixcvlt1u1+DBgw1Xi8rummuu0T//+U/TZVwSCCTwiqFDh+rJJ5/UgQMH5HQ69d577+n777/X+vXrlZSUZLo8+JEPPvhATz/9tO677z5PW/fu3XX55ZfrnXfe0ZIlS3TllVfq5ZdfJpDgvI0dO1bjxo1TeHi4xo4d+7t9ExISKqiqSwOBBF7RtWtXTZs2TbNnz5bNZtP8+fN15ZVXKikpSTfffLPp8uBHkpOT1b59+1LtrVq10oQJEyRJTZs2VWpqakWXBj9w9OhRuVwuz/eoOAQSeMWRI0fUuXNnde7c2XQp8HN169bVxx9/rL/+9a8l2jdt2qTo6GhJ0o8//njWj2sCf+SNN9446/fwPQIJvCIuLk6tWrVS7969deuttyo0NNR0SfBTjz32mMaMGaO9e/eqRYsWcrlc+vLLL/XRRx/p2Wef1aFDhzR27FjddNNNpkuFHzh27JgcDofCw8O1bds2rV+/Xi1bttTtt99uujS/w8d+4RWff/65Vq9erQ8//FCFhYXq3r27evXqpeuuu850afBDH3/8sRYsWKBvvvlGAQEBatKkiR5++GF16tRJO3fu1JYtWzRkyBAFBgaaLhWV2IYNGzRixAjNmjVLDRo00K233qp69eopNTVV8fHxeuCBB0yX6FcIJPCqoqIiffrpp1q9erU+/fRTRUZG6q677tKIESNMlwYA56VXr17q3Lmzhg8frrlz52rFihX68MMPtW7dOk2fPl3r1q0zXaJf4Uqt8KrAwEB1795dEyZM0NChQ5Wdna158+aZLgt+Jjk5WWPHjlWfPn2Unp6ut956S9u2bTNdFvzMwYMHde+998pqtWrLli3q0qWLrFarWrRooZ9++sl0eX6HQAKvycvL08qVKzVo0CB16dJF7777rgYNGqR///vfpkuDH/n666/15z//WUePHtXXX3+twsJC7d+/X4MGDdLHH39sujz4EYfDoezsbOXk5OiLL77wnIL+8ccfVbVqVbPF+SEWtcIrRowYoU8++UQWi0U333yzXn/9dbVu3dp0WfBDiYmJGjhwoEaMGKEWLVpIkiZNmqSIiAhNnz5dXbt2NVwh/EWXLl30zDPPKDw8XOHh4br++uv13//+VxMnTtQNN9xgujy/wwwJvOL48eN65pln9NlnnykhIYEwAp/5+uuvz3pH3759++r777+v+ILgt/7+97+rZcuWCgkJ0cyZM2W32/X555/rmmuu0ejRo02X53eYIYFX8Hl9VJTAwMCz3vr92LFjCgkJMVAR/FVwcLDGjBlTom3o0KGGqvF/BBKU24033qjly5crMjJS3bp1+90bmW3cuLECK4M/6969u6ZMmVLilgQHDx7U888/zzQ6Ltj06dM1aNAghYSEaPr06b/bd8iQIRVU1aWBj/2i3H77F3fatGm/G0j4iwtvycnJ0UMPPaQvv/xSbrdbERERysnJUWxsrBYuXMhiQ1yQbt26acWKFZ7/aJ2LxWLhP1peRiABUClt3bpV+/btk8vlUuPGjdWpUydZrSyLAyorAgm8Jjk5WQcOHPDcmMrtdquwsFBffvmlXnjhBcPV4VKwaNEiPfjgg6bLgJ9wu92aOnWqqlevrvvvv1+S1Lt3b8XFxemxxx4zXJ3/YQ0JvGLx4sWe0GGxWHQm51osFj5xA69YuHCh1qxZI5vNprvuuqvEZbu//fZbjRs3Tnv37iWQwGuSkpL07rvv6h//+Ien7c4779ScOXNktVr1yCOPGKzO/zC/Ca9488039cgjj+irr75SVFSUPv30U61atUoxMTG68cYbTZeHSm769Ol66aWXFB4erqpVqyohIUFLly6VJM2fP1+9e/fW4cOHlZCQYLhS+JPVq1drypQp6t69u6ftr3/9qxISErRs2TKDlfknZkjgFceOHdM999wju92u2NhY7d27V927d9eYMWP04osvlrpVPHA+3n//fQ0bNkyPP/64JGnlypWaO3eufv75Z7322mu65ZZb9MwzzygqKspwpfAnv/76q2rVqlWqvUGDBjp+/LiBivwbMyTwirCwMBUXF0uSGjZsqO+++06SFBMTwz0fcMHS0tJ06623en7u0aOHvv/+ey1atEgvvvii/vnPfxJG4HWxsbF69913S7WvWrVKV155pYGK/BszJPCK1q1ba9asWXrmmWcUGxurd955Rw8//LB27dqlsLAw0+WhkisoKJDD4fD8bLfbFRwcrBEjRpz1qq2ANwwdOlSDBw/W7t27de2118pisWjv3r364osv9Nprr5kuz+8wQwKvePLJJ/XZZ59pyZIl6tGjh3755Re1bdtWY8aMUe/evU2XBz915mZngC9cf/31WrJkierUqaPPPvtM27ZtU3R0tJYvX64uXbqYLs/v8LFfeM2pU6eUl5enqKgo/fLLL1q9erVq1aqlW265xXRpqORiY2P12WefqVq1ap62Fi1aaPXq1apXr57BygB4C6ds4DXBwcEKDg6WJFWrVk0DBgwwXBH8yYIFC0rcq6a4uFiLFy9WlSpVSvTjqsDwpuTkZC1atEiHDh3Sq6++qn//+9+KiYlR+/btTZfmd5ghQbn179+/TP0sFosWLVrk42rgz37vEt6/xeW84U1ff/21+vbtq2uvvVZ79uzRunXrNHv2bL333nuaPn26unbtarpEv8IMCcqtTp06v/v8rl27dOTIEYWHh1dQRfBXmzZtMl0CLkGJiYkaOHCgRowYoRYtWkiSJk2apIiICAKJDxBIUG7nughVTk6OXnzxRR05ckTXXXedJk2aVMGVAcCF+/rrrzVhwoRS7X379vVcmA/eQyCBV3322Wf6+9//rqysLD377LO67777TJcEAOUSGBionJycUu3Hjh0rsZ4J3sHHfuEVubm5+vvf/65BgwapQYMGWr16NWEEQKXWvXt3TZkyRZmZmZ62gwcP6vnnn9cNN9xgrjA/xaJWXLAzsyInT55UfHy8+vTpY7okALhgOTk5euihh/Tll1/K7XYrIiJCOTk5io2N1cKFC1W1alXTJfoVAgnKLTc3Vy+99JLeffdddejQQc8///xZ7/sAeNuvv/6qX3/9VQ0bNpQkrV27Vh06dFBkZKTZwuCXtm7dqn379snlcqlx48bq1KmTrFZOMHgbgQTl1q1bN6WmpqpevXq68847f7cv14aAt3z11VcaPHiwevfurdGjR0uSunbtqqKiIi1YsECNGzc2XCH8SX5+vrKzsxUREcG6ER8jkKDcuDYETOjXr58aNWqkv//977Lb7ZIkp9Opv//970pLS9OCBQsMV4jKLjc3VwsWLNCaNWv0448/etobNGigO++8UwMGDCCc+ACBBEClcq5Lxv/www/q3bu3du/ebagy+INff/1Vf/nLX/TTTz8pLi5OjRs3lsPhUHZ2tr755htt3LhR9erV09tvv62IiAjT5foVPvYLoFIJDw/Xjz/+WCqQpKWleW5dAJTXtGnTVFxcrA8++OCsa+LS0tI0ePBgLViwQMOHDzdQof9iVQ6ASuXmm2/WxIkT9d///lc5OTnKzc3Vtm3b9NxzzykuLs50eajkNm3apKeeeuqcC/Sjo6M1fPhwrV+/voIr83/MkACoVEaOHKkjR45o4MCBslgsnva4uDg99dRTBiuDPzh+/PgfLoyOjY1VampqBVV06SCQAKhUQkJCNHv2bB06dEgpKSkKDAxUTEyM5yPAwIUoKir6w1N/wcHBys/Pr6CKLh0EEgCVUqNGjdSoUSPTZQDwEgIJgIveVVddpS1btqhatWqKjY0tcarm/9q/f38FVgZ/tGDBgt/9WG9eXl4FVnPpIJAAuOi98MILno9Ynusu04A31K5dW+vWrfvDflyV2vsIJAAuer169fJ8b7FY1KNHD89F0c7Iy8vTO++8U9Glwc9s2rTJdAmXLC6MBuCid+LECZ06dUqSdOONN2r58uWl7luzf/9+jRgxQl999ZWJEgFcIGZIAFz0Nm/erDFjxshiscjtduuee+4p1cftdqtLly4GqgPgDcyQAKgUdu7cKZfLpQcffFDTpk1TlSpVPM9ZLBaFhoaqcePGCgwMNFglgPIikACoVHbs2KGWLVsqIIAJXsCfcOl4AJVK27ZttW7dOqWlpUmSZsyYodtvv13PPPOMCgoKDFcHoLwIJAAqlRkzZmjcuHE6duyY9uzZo6lTp6pFixbavn27EhMTTZcHoJwIJAAqlRUrVuill15Sy5YttX79el177bX6xz/+oeeff14ffvih6fIAlBOBBEClkpGRoRYtWkiS/vvf/6pjx46STl+oKisry2RpAC4AgQRApRIdHa1Dhw7pxx9/VEpKiq6//npJ0q5duxQdHW24OgDlxTJ1AJVKnz59NHz4cAUFBalJkyZq0aKF3nrrLU2ePFlDhw41XR6AcuJjvwAqnU2bNunIkSO68847FRkZqdWrV6ugoEB//vOfTZcGoJwIJAAAwDhO2QC46PXv31/Tp0+Xw+FQ//79f7fv4sWLK6gqAN5EIAFw0atTp46s1tNr8GvXri2LxWK4IgDexikbAABgHDMkACqVlStXnvM5u92umjVr6tprr5XNZqu4ogBcMGZIAFQqN910k44ePSqXy6WIiAhJUnZ2tiwWi868nTVq1EgLFy7kuiRAJcKF0QBUKn379lVMTIxWr16tnTt3aufOnVq7dq2aNWumZ555Rps3b1a9evU0efJk06UCOA/MkACoVDp37qx//vOfatmyZYn2L774QsOHD9enn36qffv2aeDAgdq2bZuhKgGcL2ZIAFQq2dnZCg8PL9UeHByskydPSpIcDocKCgoqujQAF4BAAqBSad26tSZPnqzs7GxPW1ZWll555RXPTffWr1+vRo0amSoRQDlwygZApXLkyBE9+OCDyszMVKNGjeR2u/XDDz8oMjJS8+bNU2pqqh5++GElJSXppptuMl0ugDIikACodE6dOqUPPvhA+/fvl81mU2xsrG677TbZ7Xb99NNPKigo0OWXX266TADngUACoFLKycnR999/r8DAQNWrV++s60oAVB5cGA1ApeJ2u/Xyyy/rzTffVHFxsSQpMDBQ9913n55++mkuKw9UUgQSAJXKnDlztGLFCo0ePVqtW7eWy+XSzp079dprr6lmzZp66KGHTJcIoBw4ZQOgUunWrZtGjhyp2267rUT7+++/r2nTpmn9+vWGKgNwIfjYL4BK5ZdfftHVV19dqr158+ZKTU01UBEAbyCQAKhUGjZsqM8++6xU+5YtW1S7dm0DFQHwBtaQAKhUBgwYoGeeeUZHjx5Vy5YtZbFYtGvXLr311luKj483XR6AcmINCYBK5/XXX9e8efN0/PhxSVK1atU0cOBADRo0yHBlAMqLQAKg0jpx4oTcbreqVatmuhQAF4g1JAAqraioKE8Y2bFjh2644QazBQEoNwIJAL9QUFCg9PR002UAKCcCCQAAMI5AAgAAjCOQAAAA47gOCYCL3vTp0/+wz+HDhyugEgC+QiABcNH717/+VaZ+tWrV8nElAHyF65AAAADjWEMCAACMI5AAAADjCCQAAMA4AgkAADCOQAIAv4N1/0DFIJAAkCT95S9/UZMmTdSnT59z9hkxYoSaNGmiMWPGeNq6detW4ufzsXz5cjVp0kQPPfTQWZ+fNm2amjRpUq6xy2PMmDHq1q2b5+eNGzdq9OjRnp+3b9+uJk2aaPv27RVWE3CpIJAA8LBarfriiy+Umppa6rn8/Hx98sknXv19K1asUOPGjfXZZ5/pyJEjXh27PB5//PESF2F7/fXXz/paAPA+AgkAj6ZNmyooKEgffvhhqec2bdqkoKAg1axZ0yu/69ChQ9q9e7dGjRqliIgIvfPOO14Z90LUr19fTZs2NV0GcEkikADwCA0NVZcuXbRu3bpSz61du1a33HKLAgK8c4HnFStWKCIiQh06dNAtt9yiFStWqLCw8A+3mz9/vm688UZdc8016tOnjzZt2lTqNMrevXs1aNAgtWvXTi1bttSjjz6qb7/91vP8mVMvS5cuVdeuXXXddddpy5YtJU7Z/OUvf9GOHTu0Y8eOUuN///33GjRokJo3b67rr79eiYmJKi4u9jzfpEkTLVmyRGPGjFGrVq3Utm1bTZo0SadOndJLL72k9u3bq127dho3bpwKCgq88XIClR6BBEAJPXr00Jdffqljx4552nJycrR582bdfvvtXvkdTqdTq1atUo8ePWS329W7d2/98ssv+ve///27202fPl2JiYm69dZbNWPGDDVv3lwjRowo0Wfbtm3q27evXC6Xnn/+eU2aNEmpqanq06ePDh48WKJvUlKSRo8erdGjR+vaa68t8dyECRPUtGlTNW3aVMuWLVOzZs08zyUkJKhVq1aaNWuWbrrpJs2dO1dLly4tsX1iYqLsdrumT5+uu+66S2+88YZ69uyp1NRUTZ48WX369NHy5cv1xhtvlOMVBPwP97IBUMINN9yg0NBQffjhhxo4cKAkacOGDYqKilKrVq288js2b96sjIwM3X333ZKka6+9VldccYWWLFmiHj16nHWbvLw8zZ07Vw888IBGjRolSerYsaPy8/O1bNkyT78pU6aoXr16mjdvnmw2m6dfXFycpk2bpn/+85+evn369NEtt9xy1t93xRVXKDw83FPfb/Xv31+PP/64JKl9+/b6+OOPtW3bNvXr18/TJyYmRs8995wkqU2bNlq+fLmKioqUmJiogIAAderUSZs2bdLu3bvL+rIBfo0ZEgAlBAcHq1u3biVO23zwwQfq0aOHLBaLV37HihUr1KBBAzVq1EhZWVnKysrSrbfeqh07dpSaxTjjiy++0KlTp0oFiN/O2uTl5Wnv3r3q0aOHJ4xIksPhUNeuXUt9Oqa8n+Bp3bq153uLxaI6deooKyurRJ8WLVp4vg8ICFBkZKT+9Kc/lTjlVbVqVWVnZ5erBsDfMEMCoJRbb71VTzzxhI4ePaqwsDBt3bpVTz75pFfGPnHihD755BMVFRWpTZs2pZ5ftmyZnn766bNuJ0lRUVEl2i+77DLP99nZ2XK73SXaftvv//7jX61atXLtQ0hISImfrVZrqeuVnJld+b3tAPx/BBIApXTu3FkRERH66KOPFBERobp16+pPf/qTV8ZetWqVioqKNH36dDkcjhLPvfbaa1q5cqX+9re/KTg4uMRz0dHRkk4Hk8svv9zTfiaoSFJERIQsFouOHz9e6vf+/PPPqlq1qlf2AYD3EUgAlGK323XjjTdq/fr1Cg0N1W233ea1sf/1r3/p2muvVVxcXKnnTpw4oSeffFLr1q1Tr169SjwXGxuriIgIrV+/vsQpk48++sjzfWhoqP70pz9p7dq1evzxxz2nbbKzs/XJJ5+offv251Wr1WqVy+U6r20AlA+BBMBZ9ejRQ4888oisVqvGjx//u32/++47vf7666Xar7322hILQr/66isdOHBA48aNO+s4N954o6pUqaKlS5eWCiTh4eF66KGHNHXqVIWEhKht27basWOHlixZIul0eJCkkSNHatCgQXrooYfUr18/FRUVac6cOSosLNSQIUPO4xU4vfZkz5492rp1K9cnAXyMQALgrK677jo5HA7VqlVLMTExv9t379692rt3b6n2IUOGlAgkK1askM1mO+cnaex2u2699VYtXbpU+/fvL/X8I488IpfLpWXLlmn+/Plq3ry5Ro0apYSEBIWGhkqSOnTooIULF2rq1Kn629/+JrvdrtatW+ull17SlVdeeR6vgPTAAw/o66+/1uDBg5WQkKAaNWqc1/YAys7i5s5RACqB4uJirVmzRu3atVOtWrU87W+99ZYmTZqk7du3l1qTAqDyIJAAqDRuu+022e12PfbYY4qMjFRycrJeffVVxcXFKSEhwXR5AC4AgQRApXHkyBG98sor2r59u7KyslS7dm3deeedeuSRRxQYGGi6PAAXgEACAACM40qtAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOP+H9s+80q9vsZ6AAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Running Non-Parametric Statistical Significance Analysis...\n", - "INFO: Preparing for Model Feature Importance Plotting...\n", - "INFO: Generating Feature Importance Boxplot and Histograms...\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABN4AAAJWCAYAAACHwkqpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3yN9///8edJIgmSELHFrBHUir3VKLWKVkurWlRRq0YoWlv5EGJTm9IqHVZpS4dWqVnV1mhpa0aUhMTKOtfvj/xyvokEOXKuHOFxv93cEtd6vs9Jcs65Xtf7er8thmEYAgAAAAAAAOBQLs5uAAAAAAAAAPAoovAGAAAAAAAAmIDCGwAAAAAAAGACCm8AAAAAAACACSi8AQAAAAAAACag8AYAAAAAAACYgMIbAAAAAAAAYAIKbwAAAAAAAIAJKLwBAAAAAAAAJnBzdgMAAAAeB6+88or27dtn+7/FYlHWrFlVvHhxtW/fXi+99JJcXV0dmvnZZ59pxIgR+uabb+Tv7+/w7R/UnDlzNHfu3Ptud+LECdPaAAAAkBEshmEYzm4EAADAo+6VV17R9evXNWbMGElSfHy8rl27pp07d2rdunVq3ry5QkJCZLFYHJYZHh6uM2fOqFy5cnJ3d3f49g/q4sWLunjxou3/69ev1yeffKKPP/442XaVK1c2rQ0AAAAZgR5vAAAAGcTLyytFMalx48YqXry4Jk+erMaNG6tt27YOy8uVK5dy5cpl2vYPKn/+/MqfP7/t/z/++KMkCm0AAODRwxhvAAAATvbKK68ob968Wrt2bbLl69evV6tWrfTkk0+qUaNGmjNnjuLi4pJt89NPP+nll19WlSpVVK9ePY0ePVrXrl2TlHDraJkyZXTu3DlJCT3ahg4dqrp166pChQp69tlntWHDBtux7tw+8fgvvfSSqlatqpo1a2rIkCEKDQ1Ntk+5cuX066+/6sUXX1SFChXUqFEjLV68ON3Py7lz51SmTBktX75czzzzjGrUqKHPPvtMkvTnn3+qV69eCgwMVGBgoPr27auzZ88m2//q1asaPXq06tSpowoVKuiFF17Qnj170t0uAACAtKLwBgAA4GSurq6qXbu2jhw5Yiusvf/++3r33XdVu3ZtLVy4UC+//LIWL16s0aNH2/bbuXOnXn/9deXMmVMhISEKCgrSt99+qwEDBqSaExQUpJMnT2rcuHFatGiRypUrp+HDh2vv3r2pbr9x40Z1795d+fLl04wZMzRixAj98ssvevHFF3XlyhXbdlarVW+99ZZatmypRYsWqWrVqgoODrb1ZEuvkJAQ9ejRQxMnTlStWrX0zz//qFOnTrpy5YqmTJmiSZMm6ezZs+rcubOtXdHR0Xr11Vf1zTffaNCgQZo7d67y58+v119/neIbAADIMNxqCgAA8BDInTu3YmNjdfXqVXl4eGjBggV68cUX9c4770iS6tWrp5w5c+qdd95Rt27dVKpUKc2ePVsBAQGaN2+e7Tienp6aMWOGwsLCUmTs27dPb775ppo2bSpJqlmzpnLmzJnqpA5Wq1XTpk1TnTp1FBISYlseGBioli1batmyZQoKCpIkGYahN998Ux07dpQkVa1aVdu3b9f333+v+vXrp/u5efrpp/X888/b/j9kyBB5enpqxYoV8vLykiTVrl1bTZs21ZIlSzR8+HBt3LhRx48f17p161SpUiVJUoMGDfTKK68oODhYn376abrbBQAAcD/0eAMAAHiIWCwW/fLLL7p165YaN26suLg427/GjRtLSrj98/bt2/rjjz9sRbREzZs311dffaV8+fKlOHbNmjU1Z84cDRw4UJ999pnCw8M1fPhwVatWLcW2//zzj/777z+1adMm2fIiRYqoSpUqKXrJValSxfa9u7u7cuXKpZs3bz7w85BU6dKlk/3/559/Vs2aNeXp6Wl7bry8vFStWjXt3r1bkrRnzx7lyZNH5cuXt20THx+vp556Sr///rvtdlwAAAAz0eMNAADgIRAWFiZPT0/lzJlTV69elSS98cYbqW576dIlXbt2TYZhyM/PL80ZISEhWrhwobZt26Yvv/xSLi4uqlOnjsaOHavChQsn2zaxDblz505xnNy5c+vo0aPJlnl6eib7v4uLiwzDSHPb7uXONly9elVbt27V1q1bU2ybODnE1atX9d9//6l8+fKpHvO///5Tjhw5HNI+AACAu6HwBgAA4GTx8fHat2+fAgMD5erqKh8fH0lScHCwihUrlmL73Llzy8vLSxaLReHh4cnWxcTEaM+ePapYsWKK/by9vRUUFKSgoCD9/fff+uabbzR//nyNGzdOS5YsSbZtzpw5JUmXL19OcZz//vtPvr6+D/ho08/b21t16tRRt27dUqxzc3OzbVOsWDEFBwenegx/f39T2wgAACBxqykAAIDTrV27VpcuXVLnzp0lSZUqVVKWLFkUFhamChUq2P5lyZJF06dP17lz55Q9e3aVLVtW33zzTbJj7dq1S2+88YYuXryYbPn58+fVsGFDffnll5KkEiVKqGfPnqpTp06KbSWpePHiypMnjzZv3pxs+dmzZ3X48GEFBgY68imwS40aNXTy5EmVLVvW9tw8+eSTWrFihbZv327bJjQ0VH5+fsmewz179mjJkiWpjmsHAADgaPR4AwAAyCDXr1/X4cOHJSVMXhAREaFdu3bp448/Vtu2bfX0009Lknx9ffX6669r1qxZun79umrWrKmwsDDNmjVLFotFAQEBkqQBAwaoT58+euutt9ShQweFh4dr+vTpeuqpp1S2bFkdO3bMll2oUCHlz59fEydO1PXr11WkSBH9/vvv2rlzp3r16pWirS4uLho8eLBGjBihQYMGqV27doqIiNDcuXOVI0eOVHubZZQ333xTnTp1Uq9evdS5c2d5eHjo448/1o4dOzR79mxJUocOHbR69Wp169ZNvXv3VoECBbR7924tXrxYXbp0UZYsWZzWfgAA8Pig8AYAAJBBjh49qhdffFFSQmHLz89PxYsX15QpU1JMYvDWW28pT548+vDDD7VkyRLlyJFDtWvX1uDBg+Xt7S1Jeuqpp/T+++9rzpw56tu3r3x9ffXMM89o4MCBqebPnTtXM2bM0KxZsxQREaECBQqoX79+dx1LrkOHDsqePbvef/999e3bV15eXqpfv74GDx6sPHnyOPCZsU9AQIDWrFmjkJAQDRs2TIZhqHTp0po3b56aNGkiScqWLZvWrFmj6dOna9q0aYqKilKhQoU0ZMgQde/e3WltBwAAjxeL4ahRbwEAAAAAAADYMMYbAAAAAAAAYAIKbwAAAAAAAIAJKLwBAAAAAAAAJqDwBgAAAAAAAJiAwhsAAAAAAABgAgpvAAAAAAAAgAkovAEAAAAAAAAmcHN2AzILwzBktRp27+fiYnmg/dKDTDIzY6azcskkk0wyySQzs2c6K5dMMskkk0wyM3vmg+a6uFhksVjStC2FtzSyWg2Fh9+wax83Nxf5+mZXZORNxcVZTWoZmWRm/kxn5ZJJJplkkklmZs90Vi6ZZJJJJplkZvbM9OTmypVdrq5pK7xxqykAAAAAAABgAgpvAAAAAAAAgAkovAEAAAAAAAAmoPAGAAAAAAAAmIDCGwAAAAAAAGACCm8AAAAAAACACSi8AQAAAAAAACag8AYAAAAAAACYgMIbAAAAAAAAYAIKbwAAAAAAAIAJKLwBAAAAAAAAJnBzdgMeNefOnVVUVKQkydXVRS4u8bJaXRUfb5UkeXv7yN+/sDObCAAAAAAAgAxA4c2BIiIi1LZtc1mt1rtu4+rqqh07dsnX1zcDWwYAAAAAAICMRuHNgXx9fbVp01e2Hm9hYaFauHCuevfup3z5CkhK6PFG0Q0AAAAAAODRR+HNwZLeRurt7aVs2bKpZMlS8vcv6sRWAQAAAAAAIKMxuQIAAAAAAABgAgpvAAAAAAAAgAkovAEAAAAAAAAmoPAGAAAAAAAAmIDCGwAAAAAAAGACCm8AAAAAAACACSi8AQAAAAAAACag8AYAAAAAAACYgMIbAAAAAAAAYAIKbwAAAAAAAIAJKLwBAAAAAAAAJqDwBgAAAAAAAJiAwhsAAAAAAABgAgpvAAAAAAAAgAkovAEAAAAAAAAmoPAGAAAAAAAAmIDCGwAAAAAAAGACCm8AAAAAAACACSi8AQAAAAAAACag8AYAAAAAAACYgMIbAAAAAAAAYAKnF96sVqtmz56t+vXrq1KlSurevbtOnz591+3/+usvvfHGG6pZs6Zq166tAQMG6MKFC8m2ady4scqUKZPs39ChQ81+KAAAAAAAAICN0wtv8+fP19q1azVx4kR9/PHHslgs6tmzp2JiYlJsGxERoW7duil79uxavXq1Fi9erIiICL3++uuKjo6WJF2/fl0XLlzQ+++/r127dtn+jRkzJqMfGgAAAAAAAB5jTi28xcTEaNmyZerfv78aNmyogIAAhYSEKCwsTNu3b0+x/Y4dO3Tr1i1NmTJFpUqV0pNPPqlp06bp1KlTOnTokCTpzz//lGEYCgwMVJ48eWz/vL29M/rhAQAAAAAA4DHm1MLb8ePHdePGDdWqVcu2zMfHR+XKldP+/ftTbF+7dm3NmzdPHh4eKdZdu3ZNknTixAnlyZNHPj4+5jUcAAAAAAAAuA83Z4ZfvHhRklSgQIFky/PmzavQ0NAU2/v7+8vf3z/Zsvfff18eHh6qXr26pIQeb9myZVP//v31yy+/KFeuXOrQoYO6du0qFxen31kLAAAAAACAx4RTC2+3bt2SJLm7uydb7uHhYevBdi+rVq3Shx9+qBEjRsjPz09SwuQLUVFRatmypfr166cDBw4oODhY165d08CBA9PVXjc3+wp3Li4W21d7931Qrq4uyb6SSWZmyHRWLplkkkkmmWRm9kxn5ZJJJplkkklmZs/MqFynFt48PT0lJYz1lvi9JEVHRytr1qx33c8wDM2aNUsLFixQr1699Nprr9nWLV++XNHR0fLy8pIklSlTRjdu3NCCBQvUv3//B+715uJika9vdrv2uXIl4ZbY7Nk97N43vXx87v78kUnmw5rprFwyySSTTDLJzOyZzsolk0wyySSTzMyeaXauUwtvibeYXrp0SUWKFLEtv3TpkgICAlLdJzY2ViNGjNCWLVs0bNgw9ejRI9n6LFmyKEuWLMmWlS5dWjdv3tS1a9fk6+v7QG21Wg1FRt60a58bN6JtXyMibjxQrr1cXV3k45NVkZG3FB9vJZPMTJHprFwyySSTTDLJzOyZzsolk0wyySSTzMyemZ5cH5+sae4l59TCW0BAgLy8vLR3715b4S0yMlJHjx5Vly5dUt1n2LBh2r59u6ZPn65WrVolW2e1WtW0aVN17NhRffr0sS3/7bfflDt37gcuuiWKi7Pvh2+1Grav9u6bXvHxVjLJzHSZzsolk0wyySSTzMye6axcMskkk0wyyczsmWbnOrXw5u7uri5duig4OFi5cuVSoUKFNG3aNOXPn1/NmjVTfHy8wsPD5e3tLU9PT3322WfaunWrhg0bpho1aui///6zHStxm+bNm2vJkiUqVqyYypcvrz179mjJkiUaNWqUEx8pAAAAAAAAHjdOLbxJ0oABAxQXF6d33nlHt2/fVvXq1bV06VK5u7vr3LlzatKkiSZPnqwOHTpoy5YtkqSpU6dq6tSpyY6TuM2QIUPk4+Oj6dOn6+LFi/L399eoUaP0wgsvOOPhAQAAAAAA4DHl9MKbq6urgoKCFBQUlGKdv7+/Tpw4Yfv/smXL7ns8Nzc39enTJ9mtpgAAAAAAAEBGy9h5WgEAAAAAAIDHBIU3AAAAAAAAwAQU3gAAAAAAAAATUHgDAAAAAAAATEDhDQAAAAAAADABhTcAAAAAAADABBTeAAAAAAAAABNQeAMAAAAAAABMQOENAAAAAAAAMAGFNwAAAAAAAMAEbs5uADKvc+fOKioqUq6uLnJxiZfV6qr4eKskydvbR/7+hZ3cQgAAAAAAAOeh8IYHEhERobZtm8tqtaa63tXVVTt27JKvr28GtwwAAAAAAODhQOEND8TX11ebNn2lqKhIhYWFauHCuerdu5/y5SsgKaHHG0U3AAAAAADwOKPwhgeWeCupt7eXsmXLppIlS8nfv6iTWwUAAAAAAPBwYHIFAAAAAAAAwAQU3gAAAAAAAAATUHgDAAAAAAAATEDhDQAAAAAAADABhTcAAAAAAADABBTeAAAAAAAAABNQeAMAAAAAAABMQOENAAAAAAAAMAGFNwAAAAAAAMAEFN4AAAAAAAAAE1B4AwAAAAAAAExA4Q0AAAAAAAAwAYU3AAAAAAAAwAQU3gAAAAAAAAATUHgDAAAAAAAATEDhDQAAAAAAADABhTcAAAAAAADABBTeAAAAAAAAABNQeAMAAAAAAABM4PagO+7cuVO7d+/WpUuXNHjwYB07dkzly5dXoUKFHNk+AAAAAAAAIFOyu/B269Yt9e3bV7t375aXl5du3Lih119/XR999JGOHj2q1atXq1SpUma0FQAAAAAAAMg07L7VdMaMGfrjjz+0YsUK/fzzzzIMQ5I0depU5cuXT7NmzXJ4IwEAAAAAAIDMxu7C27Zt2zR48GDVqlVLFovFtjxPnjzq06ePDh486NAGAgAAAAAAAJmR3YW3yMjIu47jliNHDt28eTPdjQIAAAAAAAAyO7sLb6VKldLmzZtTXfftt98yvhsAAAAAAACgByi89enTRxs3blSvXr20fv16WSwW7d+/XxMmTNBHH32k119/3a7jWa1WzZ49W/Xr11elSpXUvXt3nT59+q7b//XXX3rjjTdUs2ZN1a5dWwMGDNCFCxeSbbNt2za1bNlSFSpUUJs2bfTDDz/Y+zABAAAAAACAdLG78Na0aVNNmzZNJ06c0NixY2UYhqZMmaIvv/xSY8eOVYsWLew63vz587V27VpNnDhRH3/8sSwWi3r27KmYmJgU20ZERKhbt27Knj27Vq9ercWLFysiIkKvv/66oqOjJUk///yzgoKC9NJLL2nDhg2qV6+e+vbtq1OnTtn7UAEAAAAAAIAH5vYgO7Vp00Zt2rTR33//ratXr8rHx0clSpSQi4t9dbyYmBgtW7ZMQUFBatiwoSQpJCRE9evX1/bt29WqVatk2+/YsUO3bt3SlClT5OHhIUmaNm2aGjZsqEOHDql27dpavHixmjVrpi5dukiShg8frl9++UUrV67U+PHjH+ThAgAAAAAAAHazu8ebJG3atEmjRo1SiRIlFBgYqKtXr+q5557T9u3b7TrO8ePHdePGDdWqVcu2zMfHR+XKldP+/ftTbF+7dm3NmzfPVnRL6tq1a7JarTp06FCy40lSzZo1deDAAbvaBgAAAAAAAKSH3T3ePvvsM40cOVItW7a0LfPz85O/v78GDhyoWbNmqVmzZmk61sWLFyVJBQoUSLY8b968Cg0NTbG9v7+//P39ky17//335eHhoerVqysyMlI3b95U/vz503Q8e7m52VendHGx2L7au++DcnV1SfY1Izwuj5PMRy+XTDLJJJNMMjN7prNyySSTTDLJJDOzZ2ZUrt2Ft2XLlun111/X0KFDbcuKFy+uOXPmaNq0aZo/f36aC2+3bt2SJLm7uydb7uHhoWvXrt13/1WrVunDDz/UiBEj5OfnZyvkpXa8xDHgHpSLi0W+vtnt2ufKlYSeedmze9i9b3r5+GTNsKzH5XGS+ejmkkkmmWSSSWZmz3RWLplkkkkmmWRm9kyzc+0uvJ09e1b16tVLdV29evW0Zs2aNB/L09NTUsJYb4nfS1J0dLSyZr37gzYMQ7NmzdKCBQvUq1cvvfbaa5JkuwX1zokZ7ne8tLBaDUVG3rRrnxs3om1fIyJupCs/rVxdXeTjk1WRkbcUH2/NkMzH5XGS+ejlkkkmmWSSSWZmz3RWLplkkkkmmWRm9sz05Pr4ZE1zLzm7C2958+bVkSNHUoyjJklHjx6Vr69vmo+VeIvppUuXVKRIEdvyS5cuKSAgINV9YmNjNWLECG3ZskXDhg1Tjx49bOty5sypbNmy6dKlS8n2uXTpUorbTx9EXJx9P3yr1bB9tXff9IqPt2ZY5uPyOMl8dHPJJJNMMskkM7NnOiuXTDLJJJNMMjN7ptm5dt/E2q5dOy1YsEBr1qxRWFiYYmNjFRYWpjVr1mju3Llq27Ztmo8VEBAgLy8v7d2717YsMjJSR48eVbVq1VLdZ9iwYfryyy81ffr0ZEU3SbJYLAoMDNS+ffuSLd+7d6+qVq1qx6MEAAAAAAAA0sfuHm+9evXSqVOnNGHCBE2cONG23DAMtWjRQv3790/zsdzd3dWlSxcFBwcrV65cKlSokKZNm6b8+fOrWbNmio+PV3h4uLy9veXp6anPPvtMW7du1bBhw1SjRg39999/tmMlbtOtWze98cYbKleunBo0aKBPP/1Ux44d06RJk+x9qAAAAAAAAMADs7vw5ubmphkzZqhPnz46cOCArl27Jm9vb1WtWvWut4fey4ABAxQXF6d33nlHt2/fVvXq1bV06VK5u7vr3LlzatKkiSZPnqwOHTpoy5YtkqSpU6dq6tSpyY6TuE29evX03nvvaf78+QoJCVHJkiW1cOFCPfHEE3a3DQAAAAAAAHhQdhfeEpUqVUqlSpVKdwNcXV0VFBSkoKCgFOv8/f114sQJ2/+XLVuWpmO2a9dO7dq1S3fbMpNz584qKipSrq4ucnGJl9XqahsY0NvbR/7+hZ3cQgAAAAAAgMeL3YU3q9WqTz75RN99951u3bolqzX54HMWi0UrV650WANxfxEREWrbtnmKn0UiV1dX7dixy66JLwAAAAAAAJA+dhfegoODtWzZMvn7+yt//vyyWCzJ1huG4bDGIW18fX21adNXioqKVFhYqBYunKvevfspX76EWWO9vX0ougEAAAAAAGQwuwtvGzduVLdu3TR8+HAz2oMHlHgrqbe3l7Jly6aSJUvJ37+ok1sFAAAAAADw+HKxd4cbN26oUaNGJjQFAAAAAAAAeHTYXXirWrWqDh06ZEZbAAAAAAAAgEeG3beavv766woKClJcXJwqVaqkrFmzptimevXqDmkcAAAAAAAAkFnZXXjr1q2bJGnevHmSlGxyBcMwZLFYdOzYMQc1DwAAAAAAAMic7C68rVq1yox2AAAAAAAAAI8UuwtvNWrUMKMdAAAAAAAAwCPF7sKbJB0+fFj79u1TbGysDMOQlHCb6c2bN3Xw4EGtW7fOoY0EAAAAAAAAMhu7C29r1qzRxIkTbQW3pFxcXFSvXj2HNAwAAAAAAADIzFzs3WH16tWqV6+e9u7dqx49euiFF17Q4cOHNWvWLHl4eKht27ZmtBMAAAAAAADIVOwuvJ07d05dunRRjhw5VKFCBR08eFCenp5q3ry5evXqxeQLAAAAAAAAgB6g8JYlSxZ5enpKkooVK6bTp08rNjZWkhQYGKh///3XoQ0EAAAAAAAAMiO7C29ly5bVd999J0kqWrSorFarDh8+LEm6ePGiQxsHAAAAAAAAZFZ2T67QrVs39evXT9euXdPkyZPVpEkTDRs2TM2bN9fmzZtVtWpVM9oJAAAAAAAAZCp293hr2rSpFi5cqJIlS0qSxo8fr+LFi2vt2rUqUaKE3n33XYc3EgAAAAAAAMhs7O7xJkmNGjVSo0aNJEm+vr5atmyZbR23mwIAAAAAAAAPOMbbkSNHUl134MABPfPMM+luFAAAAAAAAJDZpanH27Jly3Tz5k1JkmEYWr9+vX744YcU2/3yyy9yd3d3bAsBAAAAAACATChNhbeYmBjNnTtXkmSxWLR+/foU27i4uMjb21t9+vRxbAuBJM6dO6uoqEi5urrIxSVeVqur4uOtkiRvbx/5+xd2cgsBAAAAAAASpKnw1rt3b/Xu3VuSFBAQoHXr1qlixYqmNgy4U0REhNq2bS6r1ZrqeldXV+3YsUu+vr4Z3DIAAAAAAICU7J5coWHDhrp+/boZbQHuydfXV5s2faWoqEiFhYVq4cK56t27n/LlKyApoccbRTcAAAAAAPCwsLvwduDAAXXv3t2MtgD3lXgrqbe3l7Jly6aSJUvJ37+ok1sFAAAAAACQkt2zmtatW1fr169XdHS0Ge0BAAAAAAAAHgl293jz8PDQtm3btH37dvn7+8vPzy/ZeovFopUrVzqsgQAAAAAAAEBmZHfh7eLFi6pSpYrt/4ZhJFt/5/8BAAAAAACAx5HdhbcPPvjAjHYAAAAAAAAAjxS7C2+JTp06pX379ikqKkq+vr6qWrWqSpQo4ci2AQAAAAAAAJmW3YU3wzA0ZswYrV+/PtltpRaLRe3bt9ekSZNksVgc2kgAAAAAAAAgs7G78LZkyRJ9+umnGjBggNq2bas8efLo0qVL2rhxoxYsWKBSpUqpW7duZrQVAAAAAAAAyDTsLrx98sknev3119WnTx/bMn9/f/Xt21exsbFav349hTcAAAAAAAA89lzs3SE0NFS1atVKdV3NmjV17ty5dDcKAAAAAAAAyOzsLrwVKlRIx48fT3Xd0aNHlStXrnQ3CgAAAAAAAMjs7C68tW7dWnPmzNEXX3whq9UqSbJardqyZYvmzZunli1bOryRAAAAAAAAQGZj9xhvPXv21IEDBzRkyBANHz5cOXPm1NWrVxUfH68aNWpo4MCBZrQTAAAAAAAAyFTsLry5u7tr+fLl2rlzp/bv369r164pR44cql69uho2bGhGGwEAAAAAAIBMx+7CW6KGDRuqSJEiioyMVK5cuVS4cGFHtgsAAAAAAADI1B6o8LZmzRotWLBAV65csS0rWLCghgwZYvcYb1arVXPnztX69esVGRmpqlWrasyYMSpatOh99+vZs6cqV66s/v37J1vXuHFjnT9/PtmyNm3aKDg42K62AQAAAAAAAA/K7sLbmjVrNGHCBDVp0kRPP/20/Pz8dPnyZX355ZcaMmSI3N3d1bRp0zQfb/78+Vq7dq0mT56sfPnyadq0aerZs6e2bNkid3f3VPe5ffu2Ro0apV27dqly5crJ1l2/fl0XLlzQ+++/r/Lly9uWe3p62vtQAQAAAAAAgAdmd+Ft5cqVeumllzR69Ohky9u1a6fRo0dr3rx5aS68xcTEaNmyZQoKCrKNDxcSEqL69etr+/btatWqVYp9Dh06pFGjRik2NlY+Pj4p1v/5558yDEOBgYGprgcAAAAAAAAygou9O4SFhalJkyaprmvevLn+/vvvNB/r+PHjunHjhmrVqmVb5uPjo3Llymn//v2p7vPjjz+qWbNm2rBhg7y9vVOsP3HihPLkyUPRDQAAAAAAAE5ld4+3ChUq6Mcff1TdunVTrPvll19UpkyZNB/r4sWLkqQCBQokW543b16Fhoamus/AgQPvecw///xT2bJlU//+/fXLL78oV65c6tChg7p27SoXF7vrjMm4udm3v4uLxfbV3n0fFJnmcXV1SfaVzMyfSyaZZJJJJpmZPdNZuWSSSSaZZJKZ2TMzKtfuwlufPn00ePBgXb9+XW3btlXevHl19epVffvtt1qxYoVGjhyZrLda9erV73qsW7duSVKKsdw8PDx07do1e5smSfrrr78UFRWlli1bql+/fjpw4ICCg4N17dq1+xbt7sXFxSJf3+x27XPliockKXt2D7v3fVBkms/HJ2uG5j1Omc7KJZNMMskkk8zMnumsXDLJJJNMMsnM7Jlm59pdeOvRo4ck6ZNPPtGnn35qW24YhiRp3Lhxtv9bLBYdO3bsrsdKnPAgJiYm2eQH0dHRypr1wR708uXLFR0dLS8vL0lSmTJldOPGDS1YsED9+/d/4F5vVquhyMibdu1z40a07WtExI0HyrUXmeZxdXWRj09WRUbeUny8lcxHIJdMMskkk0wyM3ums3LJJJNMMskkM7NnpifXxydrmnvJ2V14W7Vqlb273FXiLaaXLl1SkSJFbMsvXbqkgICABzpmlixZlCVLlmTLSpcurZs3b+ratWvy9fV94PbGxdn3w7daDdtXe/d9UGSaLz7eSuYjlksmmWSSSSaZmT3TWblkkkkmmWSSmdkzzc61u/BWo0YNh4UHBATIy8tLe/futRXeIiMjdfToUXXp0sXu41mtVjVt2lQdO3ZUnz59bMt/++035c6dO11FNwAAAAAAAMAedhfepIRC1i+//KLIyMgU6ywWi/r27Zum47i7u6tLly4KDg5Wrly5VKhQIU2bNk358+dXs2bNFB8fr/DwcHl7eye7FfVuXFxc1Lx5cy1ZskTFihVT+fLltWfPHi1ZskSjRo2y+3ECAAAAAAAAD8ruwtvKlSs1ZcoU25hud7Kn8CZJAwYMUFxcnN555x3dvn1b1atX19KlS+Xu7q5z586pSZMmmjx5sjp06JCm4w0ZMkQ+Pj6aPn26Ll68KH9/f40aNUovvPBCmtsEAAAAAAAApJfdhbfly5erSZMmmjhxonLmzJnuBri6uiooKEhBQUEp1vn7++vEiRN33ffbb79NsczNzU19+vRJdqspAAAAAAAAkNHsnuLz2rVr6ty5s0OKbgAAAAAAAMCjyu7CW7169fTLL7+Y0RYAAAAAAADgkWH3raajR49W165ddf78eVWsWFFZs2ZNsU27du0c0bZMIywsVLdv3051uSRduHBe8fEpp6X19PRUvnwFTG8fAAAAAAAAMp7dhbfvv/9eZ86c0T///KPPP/88xXqLxfJYFd7CwkI1YsSQe26zcOHcu66bPHk6xTcAAAAAAIBHkN2Ft/nz56tmzZoaOHCgcufObUabMpXEnm49e76pggULJVvn6uoiiyVOhuGWosfbhQvntXjx/FR7ygEAAAAAACDzs7vwFh4ervfee0+VKlUyoz2ZVsGChVS0aPFky9zcXOTrm10RETcUF5fyVlMAAAAAAAA8uuyeXKFSpUr6888/zWgLAAAAAAAA8Miwu8fbm2++qSFDhig8PFyVK1eWl5dXim2qV6/ukMYBAAAAAAAAmZXdhbfXXntNkvT+++9LSphMIZFhGLJYLDp27JhjWgcAAAAAAABkUnYX3latWmVGOwAAAAAAAIBHit2Ftxo1apjRDgAAAAAAAOCRkqbC24ULF+w6aMGCBR+oMQAAAAAAAMCjIk2Ft8aNGycby+1+GOMNAAAAAAAAj7s0Fd7ee+89uwpvAAAAAAAAwOMuTYW3Dh06mN0OAAAAAAAA4JHi4uwGAAAAAAAAAI8iCm8AAAAAAACACSi8AQAAAAAAACag8AYAAAAAAACYgMIbAAAAAAAAYII0zWp6p5iYGH3yySfavXu3/vvvP7333nvat2+fypcvr4oVKzq6jQAAAAAAAECmY3ePt/DwcD333HOaNGmSTp8+rSNHjuj27dvauXOnXnnlFf3yyy9mtBMAAAAAAADIVOwuvE2dOlU3btzQ1q1b9fnnn8swDEnSrFmzVKFCBc2ePdvhjQQAAAAAAAAyG7sLb999950GDhyookWLymKx2JZ7eHioe/fu+uOPPxzaQAAAAAAAACAzsrvwFh0drZw5c6a6ztXVVbGxseltEwAAAAAAAJDp2V14q1Chgj788MNU123evFlPPvlkuhsFAAAAAAAAZHZ2z2o6cOBAvfbaa3r22WfVsGFDWSwWbdmyRXPmzNGuXbu0ZMkSM9qJh0BYWKhu376d6nJJunDhvOLjranu6+npqXz5CpjaPgAAAAAAgIeJ3YW3atWqafny5Zo+fbqWLFkiwzC0YsUKlStXTu+//75q1aplRjvhZGFhoRoxYsg9t1m4cO4910+ePJ3iGwAAAAAAeGzYXXjbvXu3KleurLVr1+r27du6du2avLy8lD17djPah4dEYk+3nj3fVMGChZKtc3V1kcUSJ8NwS7XH24UL57V48fxUe8sBAAAAAAA8quwuvA0bNkzDhw9XmzZt5OnpKU9PTzPahYdUwYKFVLRo8WTL3Nxc5OubXRERNxQXl/qtpgAAAAAAAI8buydXcHd3l4eHhxltAQAAAAAAAB4Zdvd469Wrl0aPHq3jx4+rVKlSyp07d4ptqlev7pDGAQAAAAAAAJmV3YW3MWPGSJLmz58vSbJYLLZ1hmHIYrHo2LFjDmoeAAAAAAAAkDnZXXhbtWqVGe2AncLCQlOdrCAsLFRSwoQGqU104OnpycyiAAAAAAAAGcDuwluNGjXMaAfsEBYWqhEjhtxzm4UL59513eTJ0ym+AQAAAAAAmMzuwtuGDRvuu027du0eoClIq8Sebj17vqmCBQslW+fq6iKLJU6G4Zaix9uFC+e1ePH8VHvKAQAAAAAAwLHsLry9/fbbqS63WCxydXWVq6srhbcMUrBgIRUtWjzZMjc3F/n6ZldExA3FxaW81RQAAAAAAAAZw+7C2zfffJNi2c2bN3Xw4EEtWrRI8+bNc0jDAAAAAAAAgMzMxd4dChUqlOJfqVKl1KlTJ3Xr1k0TJkyw63hWq1WzZ89W/fr1ValSJXXv3l2nT59O0349evTQnDlzUqzbtm2bWrZsqQoVKqhNmzb64Ycf7GoTAAAAAAAAkF52F97upXTp0vrjjz/s2mf+/Plau3atJk6cqI8//lgWi0U9e/ZUTEzMXfe5ffu2goKCtGvXrhTrfv75ZwUFBemll17Shg0bVK9ePfXt21enTp2y+/EAAAAAAAAAD8phhbeYmBitW7dOfn5+du2zbNky9e/fXw0bNlRAQIBCQkIUFham7du3p7rPoUOH1L59e/3666/y8fFJsX7x4sVq1qyZunTpoieeeELDhw9X+fLltXLlygd+bAAAAAAAAIC97B7jrXHjxrJYLMmWWa1WRUREKDo6WsOHD0/zsY4fP64bN26oVq1atmU+Pj4qV66c9u/fr1atWqXY58cff1SzZs30xhtvqG3btinacejQoRQTQNSsWfOuhTwAAAAAAADADHYX3mrUqJGi8CZJXl5eeuqpp1SnTp00H+vixYuSpAIFCiRbnjdvXoWGhqa6z8CBA+96vMjISN28eVP58+dP8/Hs4eaWsoOgq6uL7eud65Ous2e/+8lMmenNvRsXF4vtq6OOeT/3e5xkZr5cMskkk0wyyczsmc7KJZNMMskkk8zMnplRuXYX3qZMmXLP9XFxcXJzS9thb926JUlyd3dPttzDw0PXrl2zt2m6ffv2XY8XHR1t9/GScnGxyNc3e4rlV654SpK8vT1TXS9JPj5ZH2i/u8lMmenNvXt7PCRJ2bN7OOyYaXW3x+lIp0+fVmRkpCTp+vXr8vLySpLvo6JFi5rehox4nA9LLplkkkkmmWRm9kxn5ZJJJplkkklmZs80O9fuwluTJk00b948BQQEpFh35MgR9ezZU3v37k3TsTw9EwoyMTExtu8lKTo6Wlmz2v+gPTw8bMdL6kGPl5TVaigy8maK5VFRt21fIyJuJFvn6uoiH5+sioy8pfh4a5r3u5/MlJne3Lu5cSPa9tVRx7yf+z1OR4mICFfDhvVktaae4erqqu+//0m+vrkcmnv27BlFRUX9/96EcZLcZLUakiRvb28VLlzEoXl3yqjnl0wyySSTTDIfpUxn5ZJJJplkkklmZs9MT66PT9Y095JLU+Fty5YtiouLkySdP39eX3/9tY4fP55iuz179ig2NjbNDU28xfTSpUsqUuT/TuovXbqUamHvfnLmzKls2bLp0qVLyZZfunQpxe2nDyIuLuUPIfEHEx9vTXX93dalZb+7yUyZ6c29m8SCkNVqOOyYaeXIx5Eab++c2rTpK0VFRSosLFQLF85V7979lC9fgf+/3kfe3jkd2oaIiAi1avX0PYt9O3bskq+vr8My78bs55dMMskkk0wyH8VMZ+WSSSaZZJJJZmbPNDs3TYW333//XStWrJAkWSwWzZ8//67bduvWLc3hAQEB8vLy0t69e22Ft8jISB09elRdunRJ83ESWSwWBQYGat++ferYsaNt+d69e1W1alW7jwc4i79/YUmSt7eXsmXLppIlS8nf37zbS319fe9b7MuIohsAAAAAAI+SNBXeBg8erFdeeUWGYahp06aaO3euypYtm2wbV1dXeXl5JRuL6n7c3d3VpUsXBQcHK1euXCpUqJCmTZum/Pnzq1mzZoqPj1d4eLi8vb2T3Yp6L926ddMbb7yhcuXKqUGDBvr000917NgxTZo0Kc3tAh5HGV3sAwAAAADgUZemwpu7u7sKFSokSfrmm2+UN29eZcmSxSENGDBggOLi4vTOO+/o9u3bql69upYuXSp3d3edO3dOTZo00eTJk9WhQ4c0Ha9evXp67733NH/+fIWEhKhkyZJauHChnnjiCYe0FwAAAAAAAEgLuydXKFSokA4fPqx9+/YpNjZWhpEw1pZhGLp586YOHjyodevWpfl4rq6uCgoKUlBQUIp1/v7+OnHixF33/fbbb1Nd3q5dO7Vr1y7NbQAAAAAAAAAcze7C25o1azRx4kRbwS0pFxcX1atXzyENAx4W586dVVRUpFxdXeTiEi+r1dU2YYS3t4/tFk0AAAAAAICk7C68rV69WvXq1VNwcLAWLVqkqKgojRw5Ujt37tTbb7+ttm3bmtFOwCkiIiLUtm3zh2K2TwAAAAAAkLnYXXg7d+6c3n77beXIkUMVKlTQnDlz5OnpqebNm+uff/7RqlWr1Lp1azPaCmQ4ZvsEAAAAAAAPyu7CW5YsWWwzjBYrVkynT59WbGyssmTJosDAQC1btszhjQScidk+AQAAAADAg3Cxd4eyZcvqu+++kyQVLVpUVqtVhw8fliRdvHjRoY0DAAAAAAAAMiu7e7x169ZN/fr107Vr1zR58mQ1adJEw4YNU/PmzbV582ZVrVrVjHYCAAAAAAAAmYrdhbemTZtq4cKFOnXqlCRp/PjxGjJkiNauXasKFSpo9OjRDm8kHl9hYaG6fft2qssl6cKF87YZRu/k6elpG4sNAAAAAAAgo9ldeJOkRo0aqVGjRpISBp9nXDeYISwsVCNGDLnnNgsXzr3n+smTp1N8AwAAAAAATvFAhTdJ2rlzp3bv3q1Lly5p8ODBOnbsmMqXL69ChQo5sn14jCX2dOvZ800VLJj898rV1UUWS5wMwy3VHm8XLpzX4sXzU+0tBwAAAAAAkBHsLrzdunVLffv21e7du+Xl5aUbN27o9ddf10cffaSjR49q9erVKlWqlBltxWOqYMFCKlq0eLJlbm4u8vXNroiIG4qLS/1WUwAAAAAAAGeye1bTGTNm6I8//tCKFSv0888/yzAMSdLUqVOVL18+zZo1y+GNBAAAAAAAADIbuwtv27Zt0+DBg1WrVi1ZLBbb8jx58qhPnz46ePCgQxsIAAAAAAAAZEZ2F94iIyPvOo5bjhw5dPPmzXQ3CgAAAAAAAMjs7C68lSpVSps3b0513bfffsv4bgAAAAAAAIAeYHKFPn36qF+/frp69aqeeuopWSwW7d+/X5999pnWrl2r6dOnm9FOIMOEhYWmOhtqWFiopIQZU1ObSVWSPD09lS9fAVPbBwAAAAAAMge7C29NmzbVtGnTNH36dO3cuVOSNGXKFPn5+Wns2LFq0aKFwxsJZJSwsFCNGDHkntssXDj3nusnT55O8Q0AAAAAANhfeJOkNm3aqE2bNvr777919epV+fj4qESJEnJxsfvOVeChktjTrWfPN1WwYPKxDF1dXWSxxMkw3FLt8XbhwnktXjw/1d5yAAAAAADg8ZOmwtvmzZtVv3595cyZM9nyEiVKmNEmwOkKFiykokWLJ1vm5uYiX9/sioi4obi41G81BQAAAAAASJSmLmrDhg3TmTNnki1buHChLl++bEqjAAAAAAAAgMwuTYU3wzCS/T8+Pl6zZs1SWFiYKY0CAAAAAAAAMrsHHpTtzmIcAAAAAAAAgP/DbAgAAAAAAACACSi8AQAAAAAAACZIV+HNYrE4qh0AAAAAAADAI8UtrRv27dtX7u7uyZb17t1bWbJkSbbMYrFox44djmkdAAAAAAAAkEmlqfDWvn17s9sBAAAAAAAAPFLSVHibPHmy2e0AAAAAAAAAHilMrgAAAAAAAACYIM1jvAGPC29vb8XEROv69ahky11dLbJYYhUVdUvx8UaK/WJiouXt7Z1RzQQAAAAAAA85Cm9AEvHx8erYsaP++++C/vvvgt37d+zYUfHx8Sa0DAAAAAAAZDYU3oAkXF1dtX79evXrN0gFChS6Y51FPj5ZFRmZeo+30NDzmjs3RIMHv51RzQUAAAAAAA8xCm/AHaKiouTu7iEvr+S3jbq5uShnzuwyjCyKi7Om2M/d3UNRUVEplgMAAAAAgMcTkysAAAAAAAAAJqDwBgAAAAAAAJiAwhsAAAAAAABgAgpvAAAAAAAAgAkovAEAAAAAAAAmoPAGAAAAAAAAmMDphTer1arZs2erfv36qlSpkrp3767Tp0/fdfuIiAgNGTJE1atXV/Xq1fXuu+/q5s2bybZp3LixypQpk+zf0KFDzX4oAAAAAAAAgI2bsxswf/58rV27VpMnT1a+fPk0bdo09ezZU1u2bJG7u3uK7QcMGKDo6GitWLFCkZGRGjVqlMaNG6f//e9/kqTr16/rwoULev/991W+fHnbfp6enhn2mAAAAAAAAACn9niLiYnRsmXL1L9/fzVs2FABAQEKCQlRWFiYtm/fnmL7X375Rfv27dPkyZNVvnx51a5dW+PHj9fGjRsVFhYmSfrzzz9lGIYCAwOVJ08e2z9vb++MfngAAAAAAAB4jDm18Hb8+HHduHFDtWrVsi3z8fFRuXLltH///hTbHzhwQHny5NETTzxhW1ajRg1ZLBYdPHhQknTixAnlyZNHPj4+5j8AAAAAAAAA4C6ceqvpxYsXJUkFChRItjxv3rwKDQ1NsX1YWFiKbd3d3ZUzZ07b9n/++aeyZcum/v3765dfflGuXLnUoUMHde3aVS4u6aszurml3N/V1cX29c71SdfZs9/9ZKbM9OQ+Lpn34uJisX111DEfxkzp/s8vmWSSSSaZZJL58OSSSSaZZJJJZmbPzKhcpxbebt26JUkpxnLz8PDQtWvXUt0+tXHfPDw8FB0dLUn666+/FBUVpZYtW6pfv346cOCAgoODde3aNQ0cOPCB2+riYpGvb/YUy69cSRg7ztvbM9X1kuTjk/WB9rubzJSZntzHJVOSLly4kGKSEEkKD79k+5o9u0eq+2bLlk0FCxa0K89ZmWlxt+fXTGSSSSaZZJKZ2TOdlUsmmWSSSSaZmT3T7FynFt4SJzyIiYlJNvlBdHS0smZN+aA9PT0VExOTYnl0dLSyZcsmSVq+fLmio6Pl5eUlSSpTpoxu3LihBQsWqH///g/c681qNRQZmbJIERV12/Y1IuJGsnWuri7y8cmqyMhbio+3pnm/+8lMmenJfVwyL14M1bBhg+65zYwZM+65furUEOXPX+Ce2zg7837u9/yagUwyySSTTDIze6azcskkk0wyySQzs2emJ9fHJ2uae8k5tfCWeNvopUuXVKRIEdvyS5cuKSAgIMX2+fPn144dO5Iti4mJ0dWrV5UvXz5JUpYsWZQlS5Zk25QuXVo3b97UtWvX5Ovr+8DtjYtL+UNI/MHEx1tTXX+3dWnZ724yU2Z6ch+XzBs3Egq6PXu+qYIFCyVb5+rqIoslTobhluqLwIUL57V48XzduHHzoc9Mqwf5/SSTTDLJJJPMxz3TWblkkkkmmWSSmdkzzc51auEtICBAXl5e2rt3r63wFhkZqaNHj6pLly4ptq9evbqCg4N1+vRpFS1aVJK0d+9eSVJgYKCsVquaNm2qjh07qk+fPrb9fvvtN+XOnTtdRTfAbAULFlLRosWTLXNzc5Gvb3ZFRNww5UXAGZkAAAAAADwunFp4c3d3V5cuXRQcHKxcuXKpUKFCmjZtmvLnz69mzZopPj5e4eHh8vb2lqenpypVqqTAwEANGjRIY8eO1c2bNzVmzBi1a9fO1uOtefPmWrJkiYoVK6by5ctrz549WrJkiUaNGuXMhwoAAAAAAIDHjFMLb5I0YMAAxcXF6Z133tHt27dVvXp1LV26VO7u7jp37pyaNGmiyZMnq0OHDrJYLJo7d67GjRunV199VR4eHmrRooVGjBhhO96QIUPk4+Oj6dOn6+LFi/L399eoUaP0wgsvOPFRAgAAAAAA4HHj9MKbq6urgoKCFBQUlGKdv7+/Tpw4kWyZn5+fZs+efdfjubm5qU+fPsluNQUAAAAAAAAymtMLbwAeX+fOnVVUVKSkhEkdXFziZbW6Kj7eKm9vH/n7F3ZyCwEAAAAAeHAU3gA4RUREhNq2bS6rNfUJHFxdXbVjxy4mRQEAAAAAZFoU3gA4ha+vrzZt+srW4y0sLFQLF85V7979lC9fAXl7+1B0AwAAAABkahTeADhN0ltJvb29lC1bNpUsWUr+/kWd2CoAAAAAABzDxdkNAAAAAAAAAB5FFN4AAAAAAAAAE1B4AwAAAAAAAExA4Q0AAAAAAAAwAYU3AAAAAAAAwAQU3gAAAAAAAAATuDm7AcDD6PTpf1Msc3V10enTcTIMN8XHW1Osv3DhfAa0DAAAAAAAZBYU3oAk4uPjJUkrVix+4GN4eno6qjkAAAAAACATo/AGJFGiREm98854ubq6plgXFhaqhQvnqnfvfsqXr0Cq+3t6et51HR4O586dVVRUpKSEXowuLvGyWl0VH2+Vt7eP/P0LO7mFAAAAAIBHBYU34A4lSpRMdbmra8KQiAULFpK/f9GMbBIcJCIiQm3bNpfVmvJWYUlydXXVjh275Ovrm8EtAwAAAAA8iii8AXhs+Pr6atOmr2w93u7sxejt7WNK0Y1edgAAAADweKLwBuCxkrTI5e3tpWzZsqlkyVKm9WKklx0AAAAAPL4ovGVS3t7eiomJ1vXrUcmWu7paZLHEKirqluLjjWTrYmKi5e3tnZHNBB57zuplBwAAAABwPgpvmVB8fLw6duyo//67oP/+u2DXvh07drTN3AkgY2R0LzsAAAAAwMOBwlsm5OrqqvXr1+u5515UgQIF71jnIilOkpvi45Pf2vbff5e0fv0aDR78dsY1FgAAAAAA4DFF4S0Tio+PV1RUlFasWPJA+3t6ejq4RQAAAAAAALgThbdMqESJknrnnfFydXW1Lbt4MVQ3btzQlSuX9emnH+u5516Un19uSVL27NmVP38BSQlFt3z5Cjil3QAAAAAAAI8TCm+ZVIkSJW3fR0REqH37VslmTZw0aZzte2ZNxMMiLCxUt2/fvus6Sbpw4XyK26QlisYAAAAAgMyHwtsjIOmsia6uLnJxiZfV6morXjBrIh4GYWGhGjFiyH23W7hw7l3XTZ48neIbAAAAACDToPD2iEicNdHNzUW+vtkVEXFDcXEpew0BzpLY061nzzdVsGChFOtdXV1kscTJMFJODHLhwnktXjz/rr3lAAAAAAB4GFF4A5ChChYspKJFi6dYTtEYAAAAAPCocXF2AwAAAAAAAIBHEYU3AAAAAAAAwATcagrgkcZMqgAAAAAAZ6HwBuCR5ayZVCn2AQAAAAAkCm8AHmHOmEnVWcU+AAAAAMDDh8IbgEdeRs6k6oxiHwAAAADg4UThDQBMkJHFPgAAAADAw4lZTQEAAAAAAAATUHgDAAAAAAAATEDhDQAAAAAAADABhTcAAAAAAADABBTeAAAAAAAAABNQeAMAAAAAAABM4PTCm9Vq1ezZs1W/fn1VqlRJ3bt31+nTp++6fUREhIYMGaLq1aurevXqevfdd3Xz5s1k22zbtk0tW7ZUhQoV1KZNG/3www9mPwwAAAAAAAAgGacX3ubPn6+1a9dq4sSJ+vjjj2WxWNSzZ0/FxMSkuv2AAQN09uxZrVixQrNnz9ZPP/2kcePG2db//PPPCgoK0ksvvaQNGzaoXr166tu3r06dOpVRDwkAAAAAAABwbuEtJiZGy5YtU//+/dWwYUMFBAQoJCREYWFh2r59e4rtf/nlF+3bt0+TJ09W+fLlVbt2bY0fP14bN25UWFiYJGnx4sVq1qyZunTpoieeeELDhw9X+fLltXLlyox+eAAAAAAAAHiMObXwdvz4cd24cUO1atWyLfPx8VG5cuW0f//+FNsfOHBAefLk0RNPPGFbVqNGDVksFh08eFBWq1WHDh1KdjxJqlmzpg4cOGDeAwEAAAAAAADu4ObM8IsXL0qSChQokGx53rx5FRoammL7sLCwFNu6u7srZ86cCg0NVWRkpG7evKn8+fOn6Xj2cnNLWad0dXWRt7e3zp79V/Hxsbp8+bJu3UoYc85iscjTM4tu346VYRiSpKxZsyl37tz6779L8vb2lqurS6rHfVCuri7JvjryuEkfpyTbY73X45T0wI/VGZmpOXv2jKKionTx4gXdvHlTf/990jauoLe3twoXLpKu4z8uz+29MqWUfy9k2vd7e+TILwoPD7f9//Tp07p+/fr/z5SyZHFVbGy8DEPy8vJS0aJFbdvmypVLFStWsSsvtVwyE7ZNmkvmw5+ZNPdhzExPLpmPR6Zk3usfmQ/He8vjkik9Ou8tj0tm0tyHMTM9uWQ+HpmSua9/iZxaeLt165akhOJZUh4eHrp27Vqq29+5beL20dHRun379l2PFx0dna62urhY5OubPcXy0FAXdezYUS4uhi5ePCdJypLl/06Y4+Li5OZmkWT5//+/bduuY8eOypXLO9XjppePT1aHHi+1xyn932O91+OUHuyxOiPzTuHh4WrV6mlZrVbbsgED+tq+d3V11eHDh5UrV64Hznhcntv7Zd6ZS2baM//55x+Fh/8nF5f/yyhe/H4FYcP2XXj4f7p69ZKKFy+e5szUcslMmUvmw5+ZtlznZT5oLplkkvnwZqaWS2bKXDIf/sy05fIeSubjl3knpxbePD09JSWM9Zb4vSRFR0cra9aUhSNPT89UJ12Ijo5WtmzZ5OHhYTvenetTO549rFZDkZE3UywvUKCoIiMTeglJ9+7ZIiXvOeTpmVU+PrkVEXEjXW1LytXVRT4+WRUZeUvx8db775BGdz5OKe09pKQHe6zOyLyTxeKhL774WlFRUXJxsUiKk+QmqzUh09vbWxaLR7oyHpfn9l6Z0r17gpF5bzlz5lWuXHnScRUnj3LmzGv37/GduWQmbJ/86i6ZD3tm0tyHMfNBc8l8fDIlc17/yHx43lsel0zp0XlveVwyk+Y+jJkPmkvm45MpPfjrn49P1jTfaWgxEs+sneDIkSPq2LGjtm/friJF/q/i2LlzZwUEBGjMmDHJtl+8eLFWr16tnTt32pbFxMSoUqVKmjFjhlq0aKHAwECNHDlSHTt2tG0TEhKiHTt26IsvvnjgtsbHWxUebt+LhJubi3x9sysi4obi4hxXBCOTzEct01m5ZJJJJplkkpnZM52VSyaZZJJJJpmZPTM9ublyZU9z4c2pkysEBATIy8tLe/futS2LjIzU0aNHVa1atRTbV69eXRcvXtTp06dtyxL3DQwMlMViUWBgoPbt25dsv71796pq1aomPQoAAAAAAAAgJafeauru7q4uXbooODhYuXLlUqFChTRt2jTlz59fzZo1U3x8vMLDw+Xt7S1PT09VqlRJgYGBGjRokMaOHaubN29qzJgxateunfLlyydJ6tatm9544w2VK1dODRo00Keffqpjx45p0qRJznyoAAAAAAAAeMw4tcebJA0YMEDPP/+83nnnHXXu3Fmurq5aunSp3N3dFRoaqnr16mnr1q2SEsZGmjt3rvz9/fXqq6/qrbfeUoMGDTR27Fjb8erVq6f33ntPH330kdq3b6+ff/5ZCxcu1BNPPOGkRwgAAAAAAIDHkVN7vEkJs0IGBQUpKCgoxTp/f3+dOHEi2TI/Pz/Nnj37nsds166d2rVr58hmAgAAAAAAAHZxeo83AAAAAAAA4FFE4Q0AAAAAAAAwAYU3AAAAAAAAwAQU3gAAAAAAAAATUHgDAAAAAAAATEDhDQAAAAAAADCBxTAMw9mNyAwMw5DVav9T5erqovh4qwktIpPMRyvTWblkkkkmmWSSmdkznZVLJplkkkkmmZk980FzXVwsslgsadqWwhsAAAAAAABgAm41BQAAAAAAAExA4Q0AAAAAAAAwAYU3AAAAAAAAwAQU3gAAAAAAAAATUHgDAAAAAAAATEDhDQAAAAAAADABhTcAAAAAAADABBTeAAAAAAAAABNQeAMAAAAAAABMQOENAAAAAAAAMAGFNwAAAAAAAMAEFN4AAAAAAAAAE1B4AwAAAAAADzXDMJzdBOCBUHgzSUREhCIjI53dDAAA7Pa///1Pf/31V4ZmXr16NUPzANiHv1E8CmJjY/Xbb7/pxo0bzm5KhomOjnZ2Exzmueee0/Hjx53dDDxCYmJiMiTHLUNSHgNRUVFau3atvv32W/3222+Kj4+XJLm7u6tixYpq2rSpOnToIG9vb4dnnz59Wr/++qsuX74sFxcX5c2bVxUrVpS/v7/Ds6SEX84DBw4ky8yTJ48qV66satWqycXl0annZvRze+TIEX3zzTc6cuRIiue2adOmCggIcFjWmjVrVLt2bRUvXlwWi8Vhx00Lq9WqL7/8Ut9++62OHDmi//77T66urrbH2qRJEzVu3Njhv0thYWH64YcfUv3dbdSokXx9fR2aJ0kdOnTQc889p9atWytHjhwOP35qrl+/Li8vrwzJymj79+9P87bVq1c3sSUZx2q1asuWLTp48KBiY2NTXO2dPHmywzMPHjyoFStWqHz58nruuefUqlUr+fj4ODwnqXr16qlx48Z67rnnVL9+/UfqveROt2/flouLi9zd3XXq1Cl9//33qlKligIDA53dtExv9erVatOmTYa93jrLrVu3tGLFiru+LqxatcrhmQ/D32h4eLj27dun8uXLq3DhwqblbN68WdWrV1f+/Pk1f/58bd26VYGBgRo1apQ8PDxMyXycXhcuX76c6u9twYIFHZ4VGhqqUaNG6a233lKZMmX03HPP6eTJk8qRI4dWrFihsmXLOjxTki5cuCAfHx95eXnp559/1tdff63AwEC1bt3alLyPPvpInTt3TrH8wIEDGjVqlL766itTcjP69/b8+fPKli2bKce+0/bt2/Xkk0+qQIECGZInSbNnz1bTpk1VokQJeXh4ZMg52pgxY9SmTRuVKFFCXl5ecnd3Nz0zqYw+30700UcfafHixbp48aK++uorLVmyRHny5FG/fv1MybMY9NdMF6vVqkWLFmnx4sXKly+fGjVqpDJlyihXrlyyWq0KDw/XH3/8ob179+rixYvq0aOHevbsKVdX13TlxsXFacOGDVq2bJn++ecfubm5KUeOHIqPj1dkZKSsVqtKly6t1157Tc8++6xDPhxFRkZq+fLl+vDDDxUZGSl/f3/lypVL8fHxCg8PV2hoqHLkyKEuXbro1VdfNaXImBGc8dwePHhQ06dP1+HDh1WuXDnb71B8fLwiIiL0xx9/6K+//lK1atX01ltvqWrVqunO/N///qc8efJo3759atu2rVq2bJnuY6bFli1bFBISosjISNWpUyfVx3ro0CH5+PhowIABatOmTbozz549q9mzZ2vbtm3y8fFR6dKlk/3unjhxQjdv3lTr1q3Vt29fh36YDw4O1pYtWxQeHm47YalXr56pb6RNmjTR7NmzVb58edMy7sbsD2ABAQGyWCz3vdXAYrHo2LFjDslM6t9//9W4ceNsJ7t3MiNz8uTJWrVqlQICAlItqH7wwQcOz5Skf/75Rxs2bNDmzZt15coVNWnSRB06dFDdunVN+f394YcftHHjRn3zzTfy9vbWs88+q/bt2+uJJ55weNadMvIke//+/erbt69mzZqlkiVLqnnz5nJxcdHNmzc1ffp0PfPMMw7NS7Rhw4a7rnN3d1e+fPlUuXLldH8+cbaGDRsqIiJCTz31lK1AlNEXlzLC22+/ra1bt6pBgwapft4yoyDvjL/RP//8U/3799fEiRMVEBCgZ555RpcvX5a7u7sWLVqkWrVqOTxz/vz5WrhwoVasWCGLxaLOnTurY8eO2rdvnxo0aKBRo0Y5PNNZrwsDBgzI0ELq4cOHNXz4cJ05cybZcsMwTHvfHjBggEJDQxUSEqJDhw5pzJgxWrp0qT755BNdvHhRy5Ytc3jm9u3bNWjQIC1cuFBFixbVM888o8KFCys0NFRBQUF6+eWXHZ755JNPauzYsXr++eclJfRyCw4O1urVq1WrVi0tX77c4ZnO+L1dsmSJdu7cqR49eqhIkSLy9PRMtt6RxdvRo0frySef1NGjR9WwYUM99dRTDjv23cydO1exsbHatWuXunXrZlqhNqnly5fr77//1u7duxUUFKQWLVqYnumM8+2kNm/erHHjxunVV1/VkiVLtGXLFn333XcKDg5W//791bNnT4fmSZIMpMvzzz9vDB8+3Dh+/Ph9t/3111+NwYMHGx06dEhX5u+//260bt3aaN++vfH+++8bf/31lxEfH29bHx8fb/zxxx/GkiVLjFatWhnPPPOMceTIkXRlbt++3WjQoIHRr18/44svvjCuX7+eYpuIiAhj27ZtRs+ePY26desaX3/9dboy7+bmzZvG4cOHjf379xv79u1L9i+9nPHcTpo0yXj66aeNVatWGZcuXbrrdleuXDEWLVpkNGnSxJgwYUK6Mnv06GF069bNKF++vBEcHGzExsam63hp9eabbxpdunQxvvnmGyMmJuau28XGxhpffPGF8eKLLxq9e/dOV+aKFSuMevXqGZMnTzYOHz6c6jZWq9U4cuSIMXbsWKNOnTrG8uXL05WZ2vF37dplDB061KhcubJRv359Y8aMGcbff//t0JxEdevWNU6dOmXKse9l3759RvXq1Y3du3cbly5dMqpUqWJUrVrVKFu2rLF161aHZJw7dy7N/8zQtWtXo2nTpsbKlSuNzz77LMU/M9SsWdNYvXq1KcdOq7179xoTJkwwKleubDRs2NCYNWuWcfHiRVOyoqKijHXr1hldunQxypcvb7z44ovGunXrjKioKFPy5s2bZ1SoUME4ePCgcejQIaNMmTLGO++8Yzz99NPGxIkTHZ7XqVMn4+233zaioqKMFStWGPXr1zdu3bplrF692nj22WcdnpeoWbNmRtmyZY0yZcoY1apVM6pVq2aUKVPGCAgIMMqUKWOUKVPGaNGihREaGurQ3PPnz9t+dnv27DHGjRtnbN682aEZSVmtVuPHH380hgwZYlSqVMmoV6+eERwcnCGviRn5WAMDAx32umqvjPwb7d69u9GzZ0/j8uXLxscff2zUrFnTuHjxojFjxgzjxRdfdHieYRhG48aNbc/tlClTbDn79+836tWrZ0qms14X3nrrLaNixYpG3bp1jWnTphknT540LcswDOO5554zOnbsaOzYscPYu3dvin9mqF69unH06FHDMAxj8ODBxoABAwzDMIy///7bqFy5simZ7dq1M2bMmGHEx8cbCxcuNJo1a2bEx8cbW7ZsMVq0aGFK5ldffWVUqFDB+Pzzz439+/cbTZs2NWrUqGGsX7/elDzDcM7vbeL7VeL7V+K/xP87ypgxY4zBgwcbgYGBxrBhw4zIyEiHHftuWrRoYbRt29YICAgwlixZYnqeYRhGhQoVjHr16hkBAQHGmjVrMiTTGefbd2rXrp3tc3vlypWNM2fOGIZhGJ999pnRrFkzh2YlovCWTr/99pvd+6T3F+e5554z9uzZk+btf/jhB6N9+/bpyuzdu7fx77//pnn7v/76y+jVq1e6MlPz3XffGdWqVUt2opD0xTe9nPHcLl++3K7CV3R0dLpfjL/44gsjODjYaN26tdGiRQuHv5jdzYMUY7dt25auzAkTJhjXrl1L8/ZXrlwxxo0bl67Me7l586bx/vvvG5UqVTICAgKMl156yfjqq68cmjF//nzjmWeeMVavXm388MMPDi9Q342zThyioqKMX3/91Th69KhpxZlEFSpUMA4dOmRqxp0qV65snD59OkMzk/r111+NCRMmGPXr1zcqV65sDB061OjatatRsWJFY+PGjablXr582ViwYIFRqVIlo0yZMkblypWNCRMmOPxnnNEn2RUrVrR9wHv99deNd9991zCMhKJyhQoVHJ6XaNmyZUbr1q2NEydO2JadOnXKeO6554w1a9YYYWFhRs+ePY3Bgwc7LPPrr782ypcvb/z444/GmTNnjPLlyxstWrQwKlWqlCHF5OvXrxufffaZ0bt3b6NSpUrGiy++aHzyySfGrVu3HJ6V0Y+1WrVqdn0uM0NG/I1WqVLFVgzq16+fMWzYMMMwDOPMmTNGpUqVHJaT1JNPPmkrQLdt29aYM2eOYRgJf6MVK1Y0JdNZrwuGkfAe+vHHHxudO3c2AgICjBdeeMH4+OOPTXk/ffLJJ21FsIxSuXJl4/z584ZhGEbt2rWNtWvXGoZhGCdPnjSqVatmSmaFChVsFwC7dOliu4hz/vx5U3+eO3bsMCpWrGiULVvWGDhwoHH58mXTsgzDOb+3qRVszSjevv/++8aYMWOMBg0aGF26dMmQ19vDhw8bCxcuNLp06WLUr1/f2L17t+mZly5dMlatWmX069fPqF+/vvHNN9+YnumM8+07VapUyfa7m7TwdubMGdN+dym8ZYDbt2/bfpiOYLVaM2Sfh1GrVq2M3r17G8eOHTOlh8vj9Nz27NnT2LZtm7F9+3bjn3/+cXZzkkl61eNRERYWZixevNho06aNUaZMGaNz587GunXrjDlz5hjVq1d3aM+aO4vSji5Q301GfwCzWq3GlClTjCeffNJWjK9QoYIxceJE0/4uGzRokKxwkRH69++f4T3eLly4YCxYsMBo0aKFUaZMmVRPxGbPnm3UrFnTobnR0dHGF198YfTs2dMoX7680ahRIyMkJMQ4ffq0sW/fPuPZZ581XnvtNYdmZvRJds2aNY2TJ08a0dHRRuXKlW1Fv8OHDxt16tRxeF6i+vXrGwcPHkyx/JdffjEaNGhgGIZh/PHHHw79mTqj10dSly5dMpYvX268+OKLRtmyZY3OnTsbzZo1M+rUqePwE5qMfqwjR440QkJCHH7c+8nov9GqVasaZ86cMeLi4oxq1aoZn3/+uWEYhnHs2DGHv/4katq0qbF7927j9OnTRpkyZWwXWzZs2GA8/fTTpmQ663XhTmfPnjXmzJljVK5c2ahUqZIRFBT0QJ0M7qZZs2bGr7/+6rDjpcVLL71kzJw50/jwww+NgIAAIzQ01IiOjjaGDx9udOnSxZTMunXrGseOHTOioqKMJ5980vj2228Nw0joCVu/fn1TMhN9//33RqVKlYwvvvjC1BzDeHh+b80yYMAAY8OGDcbKlSsz7Pe2Z8+exjfffGP8+uuvRlhYWIZkvvXWW8auXbuMM2fOmH4B2zAejvPtJk2aGN9//71hGMkLbxs2bDCaNGni0KxETK6QAfbt26c33njDYeMWpGWsktOnT2vDhg0aOHBgmvdJrxMnTmjp0qWaOnWqaRmnT5/WzJkzVbJkSVOO/7A+t/v27dOwYcP0/fffO+yYkydPlqenp7Jnz+6wYzrCjz/+6NC/l7uJiYnR6dOnZbVaVbx4cdMGEt24caM2btyovXv3KleuXGrXrp1mz56tYsWK2bbJnz+/Jk2a5LBxY7755huHHMdeWbNmVUxMjG0Clvfee09SwiDKZoz5uGjRIn366acaPny4qlWrJqvVqv3792vevHnKly+fXn/9dYdnvvLKK5oxY4amTZuWYeNYVqhQQVOnTtWePXv0xBNPKEuWLMnWmzEIbOPGjeXn56c2bdpo7ty5qY7hVK5cuWS/x+mVOPhzTEyMGjdurAULFiQbD7FIkSLq1auXRo4c6bBMKeHv759//lFMTIxOnDihsWPHSkoYkDp//vwOzZKkmjVratq0abbB/+vXr69jx45p4sSJqlmzpsPzEkVFRaU6RqCnp6euXbsmSfLx8XHo7HenTp3S3Llz5eLiol27dqlhw4ZycXFRlSpVdP78eYflJBUdHa2vv/5aGzdu1J49e5Q7d261a9dOU6dOVZEiRSRJ48aN09tvv62dO3c6LDejH6uPj4+WLVumnTt3qkSJEinew8wY480Zf6OVK1fWwoULlTt3bt26dUsNGjRQWFiYZsyYocqVKzssJ6lOnTpp4MCB8vDwUJkyZVSlShWtWbNG06ZNU//+/U3JdNbrQqKYmBh988032rRpk3766Sflzp1bbdu21aVLl/Tyyy+rf//+DnlPffPNN/Xee+9p3LhxKlGiRIr3MzMMHz5cvXv3VkREhHr27Kn8+fNr7Nix2rFjh5YuXWpKZsOGDTV69Gh5eXnJy8tLdevW1e7duzV27Fg1atTIYTmJ497eyTAMDRkyREOGDLEtM+NztTN+b2NiYvTxxx/rxIkTtskME5f/9ttv+vrrrx2W1atXLxUoUMCUydfuZv78+TIMI0P+NhKFhIRkWJb0cJxvv/jii7bPApL0999/68cff9SsWbP02muvOTQrEYW3R9SZM2e0cOFC2y9rRrh06ZI2b95sauGtWLFiCg8PN+34aeGM5zY6OlphYWEOPaafn5/t+9u3b+vLL7/UqVOn1KNHD/35558qWbKkcuXK5dDMh8WBAwc0aNAgWa1WxcXFydXVVcHBwapTp47Ds0aNGqWnnnpK8+bNU4MGDVIdHLR48eIOHWi3UKFCkhI+hJw7d05FihTJkDfxjP4A9vHHH2vMmDFq1aqVbVm5cuWUK1cuzZkzx5TC286dO3X48GHVrFlTfn5+KU52zSh6fvTRR/Lz89PRo0d19OjRZOssFosphbc5c+boqaeeuudA+02aNFGTJk0clnn06FENHDhQbdu2veuMlGXKlNH06dMdlill/En2mDFjNGbMGJ04cULTpk2Tl5eXNm7cKDc3N40YMcLheYmqVaumadOmacaMGbaicWRkpGbMmKEqVapIkr7++msVL17cYZk+Pj6KiorS9evXdfjwYXXv3l1Swvtozpw5HZaTVO3atRUXF6dGjRpp/vz5qQ4aX7t2bYf/rWb0Y/39999VqVIlSQmfvzKCM/5G3333XQ0aNEhnz57VyJEjlStXLk2YMEEnT57UkiVLHJaTVI8ePVS8eHGdPXtWbdu2lSR5e3tr1KhR6tixoymZznpdOHDggDZu3KivvvpKt2/fVtOmTbVgwQLVqVPHdqJbpkwZh72nzp49W5cuXVK7du1SXW9GcahixYr66aefFBUVZZud+9VXX9XAgQNNK6i8++67mjlzps6ePasFCxbI3d1dBw8eVMWKFTV8+HCH5bz33ntOnTzGGb+37733nj777DOVL19ev/76q6pUqaLTp0/rypUrDi+YlCtXzvZ9Rs3e6ub2f+WZS5cuad26dfr77781atQo7du3T6VLlzZ1Qps//vhDS5cu1YkTJ+Tm5qaSJUvq1VdfVcWKFU3LTI3Z59s9e/ZUVFSUgoKCFB0drV69esnNzU2dOnVSr169TMlkVtMMkFE9eB6HzB9++EHTpk3ToEGDUr3Ca8Y05Hd61J7by5cvq1OnTrp8+bJiYmL01VdfadKkSfrtt9+0atWqDJlRMKmMeH7btWund9991zY77Oeff6758+dr+/btDs8KDw/P8AKmYRiaPn26PvjgA8XGxuqrr75SSEiIPDw8NH78eNMKcOHh4RozZozOnj2rfv36qWnTppoyZYp+/fVXzZ49W3ny5HFoXqVKlbR582ZbL5ZEZ86cUatWrfTbb785NE9KmG3qXsyagjwjXLhwIc3bZsRrbUb69ttvbSfZvr6+2rRpk6Kjo007yb5TTEyMab1uE509e1avvvqqIiIiVLx4cRmGoX///Ve+vr5asmSJQkND9cYbbygkJERPP/20QzJHjRqlv/76S15eXjp27Jh27typAwcOaOzYsapVq5bGjx/vkJykVq5cafs53sn4/zMnxsXFJTu5cQRnPFZnOHXqlG7cuGE7CVu2bJkaNWqkEiVKZFgbrly5opw5c2b6GXjvJyNeFwICAlSuXDk999xzatOmja0wldTu3bv16aefOqSg+vnnn99zffv27dOdISW8nxUoUEAWi+W+722PyvvZhAkT9Oqrr6b4TJTRzP69rVevnkaOHKmWLVvq6aef1sKFC1W4cGENGjRI+fPn1zvvvOPwTGfM3nr69Gm98MIL8vLyUlhYmLZt26Zp06bpxx9/1NKlSx1e8JMSCvHdunVT6dKlVa1aNcXHx+vQoUP6888/tXLlStt5U0bIqPPtW7du6eTJkzIMQyVKlEj1zgBHoccbMpU33nhDUkJX9aRXeAwTpyF/1E2ZMkUlS5bU5s2bbT2+/ve//2nw4MH63//+p0WLFjm5hekzePBgDRo0SIULF7Ytu3XrVrJbyPLmzaubN2+akp8rVy4dP35cf/75p6xWq6SE39eYmBj9+uuvttsxHemDDz7Qxo0bNWbMGNvJXtOmTTVu3Dj5+flp6NChDs+UZOtpltTgwYNN+wBWrFgx/fTTTyk+ZO7atcu0D9LOLKzt379fp06dUuvWrXXx4kUVLVrUoUXUxo0bp/nKuaNea+25Im7GrXOJGjdunOz/ib1czJJ4Ffuff/7RyJEjM+QqduHChbV161Z98cUXOnbsmFxdXdW1a1e1atVK7u7u8vDw0ObNmx1aQMmoXh9JrVq1Ss8++2yK5WFhYWrbtq327t3r8KKb5JzHevPmTW3atMnWM6FUqVJq2bKlaScOP/74o/r27avu3bvbCm9bt27VnDlztHjxYlWrVs3hmXcrmiTeBeCo1/quXbtq7ty58vHx0SuvvHLP18JVq1Y5JPNOznhd2LBhgwICAu65TZ06dRx2R4CjCmv306RJE+3atUt+fn53fW9z9LnD3Llz1aNHD2XNmtUpF+k2bNigbt26Ofy4qeW0bNlS7u7u2rBhwz23vVvPxvS4evWq7Tbz0qVL6+jRoypRooR69eqlt956y5TC24wZM9SkSRNVqFBBn376qby8vPT111/r008/1fvvv29K4W3KlClq2rSpJk6caCuyhYSE6O2339aMGTO0evVqh2fOmDFDHTt21OjRo5MtHzdunGbOnKkPPvjA4ZnOdO3aNZ0+fdo2xEbS14Lq1as7PI/CGzIVsz7sPM5+/vlnLVq0SFmzZrUty5Ejh4KCgtS1a1cntswxnnzySXXu3FktWrRQv379lDNnTvXt21ft2rVTiRIlFBcXp1OnTpnWJX7VqlW24prFYlFiJ2OLxWLKSYqUcAvm6NGj1axZM02YMEGSbB+SJk2aZFrhTZJOnjypP//8UzExMSnWOfoDWLdu3TR69GidO3dOgYGBslgsOnDggNasWaOgoCCHZiV1/PhxrVy5Uv/8849mzZqlHTt2qGTJkqaNZ3L9+nX16NFDv/76qywWi+rWravg4GD9+++/WrFihcPGIUv6+nrixAnNnTtXb775pqpUqaIsWbLoyJEjmjdvnt58802H5EnSuXPnbN8bhqEDBw4od+7cKleunNzc3HT8+HGFhYU59JZWKflJ9v1e5xz9vnPnVey33npL27Zt08iRI027ip3I09NTzz33XKrrEm9Rd3Re4vgpicy4fXfr1q368ccfJSUUasaPHy8PD49k25w/f97UW7Iy6rEmCg0NVZcuXXTlyhUVL15c8fHxWrdunRYuXKgPP/zQlPEJQ0JC9Prrr2vAgAG2ZZ988olCQkIUHBystWvXOjzzfhcEHFU0KVSokO2W5EKFCmX47XsZ+bqwf//+e/4/KTNOPr/77jstXLgw2a1sPXr0ULNmzRyWsXLlStvt0Bl17vDZZ5/p5ZdfVtasWfXZZ5/ddTuzhoho1KiRVq9erX79+pnaa+ftt99W/fr15efnl+I1LymLxWJK4S137ty6cuWKChYsqCJFiujPP/+UJPn6+ury5csOz5MSbrOfOnWqvLy8tGvXLjVq1Eienp5q1KiR/ve//5mS+csvv2j16tXJXotcXV3Vu3dvvfDCC6Zk/vHHH5o4cWKK5V26dNHzzz9vSqazbNiwQWPGjFFMTIzuvAHUrM48FN7SKS2FiatXrzo0My23A125csWhmfd6U0504sQJh2ampkaNGrbvw8PD5ebmlmq3+AfljOf2flfFpIQPZGa5ceNGsqJbUnFxcQ7NSktxy9Fj2XXv3l0dO3bU/Pnz1apVK3Xt2lWvvvqq6tSpo8OHD8tisah8+fKmnKRI0urVq9WrVy/17dtXTz31lD777DNdvXpVQ4YMcXgxIdG5c+dUtmzZFMvLlClj2ocSKWGygxkzZqS6zowPYO3atdPVq1e1ZMkS2wDJfn5+GjBggLp06eLQrES///67OnfurMqVK+v3339XTEyMjh07pvfee09z587VU0895fDMGTNmyGKxaPv27baeWMOGDdPQoUM1derUuz7n9kr6+jplyhRNnDgx2YlQ2bJllTdvXk2dOlWdOnVySGbSq6czZsxQvnz5NHnyZFsvyfj4eI0ePdrhJ8F3nmRnJGdcxZYS3rtCQkJ08OBBxcbGpvigadakLBlRqK5SpYrWrl0rwzBkGIYuXLiQrDeoxWJRtmzZHH6C5MweLlOmTFGBAgW0fv1623AGly9f1sCBAzVt2jSHj4UoJQw+PWvWrBTLn3/+edOKG3ceNy4uTv/++6+WL1/usAmJpOQ9agcMGKD8+fOnGBswLi4uxTibjpKRrwuJPfruN9qQGSefO3bsUP/+/dWsWTO1atXKNinSwIEDNWfOHId9Lkr6fpb0+0RmDAPy7bffpvp9Rrlw4YK++OILrVy5Un5+fikuPjjqNf748eOpfp9RGjZsqDFjxmjy5MkKDAzUpEmT1KxZM23dutW0z/IZPXmYlPD5J/FOmaSuX79u2m32vr6+unLlSoqe71euXHHo3SvOON++08yZM/Xss8/qtddeS/G3YhYKb+lUsGDB+54QFCpUSOXLl3dYZlpuB0rsPu0o9rxJm23NmjVasGCB7Q8yd+7c6tGjh0MG1HTGc3uvq2JJFShQwGGZSVWvXl1r1qxJ1jU7NjZW8+bNc3jPi6S9W+7F0T3BvL29NXz4cL3yyiuaOXOmWrRoob59++r55583/Xf2woULev755+Xu7q6AgAD99ttvatq0qd5++21NmTLFlJlzChUqpCNHjsjf3z/Z8p07dya75dbRVq5cqb59+6pXr16mj0uT6LXXXtNrr72m8PBwGYaRbNIQMwQHB6t79+4aNGiQbUD6iRMnytvb27TC23fffafp06cn+9mVKFFCY8aMUe/evR2eJyWM45Ta7NFFihRRaGioKZlr167VRx99lOx3x9XVVT169NDzzz+f6lXYB5X0JNvMW1hT44yr2JI0evRoHThwQO3atcuwGXkzqlBdoEABW4HmlVde0dy5c+86+L8jObOHy08//aTly5cnKx7kzp1bw4cPV8+ePR2alShXrlw6evRoiveRv/76y6EXQZNKrWhSp04dFSxYUAsXLnToDJGJmjRpop9++ilFYebcuXN65ZVX9Ouvvzo8MyNfF5w187kkzZs3T/369VPfvn1ty1577TXNnTtXCxYsMOWCZGRkpKZNm6YuXbrYetft3btXxYoV06JFi0z7XJRRg/Enqlu3rurWrWvKsdMqPDxc+/bt05NPPpniM6ijDB06VMOHD9eBAwf00ksvad26derYsaPc3NxM633mjNlb69WrpwULFig4ONi2LCIiQtOmTVOtWrVMyXzqqac0YcIEhYSE2G5xP3nypCZNmuTQz7fOON++07Vr19S9e3cVK1bMtIw7UXhLp8GDBytv3rwZmumM2y2d+Sad1Pr16zVlyhR16dJF1apVs10pmzFjhry8vNLdDdYZz60zroolNXz4cL388svat2+fYmNjNXbsWP3999+KiopyeM+L5cuXmzK2TlpERESoYMGCmjp1qo4dO6bg4GCtWLFCQ4cONaVYkih79uy2noPFihXTyZMn1bRpUz3xxBM6f/68KZk9evTQuHHjFBYWJsMwtGfPHq1du1YffPCBqbOjxcbGqm3bthlWdJMSBoz/448/dPv27RTrzLjF4ffff9eYMWNSLO/cubMpt1lJCR9kU5uYwsvLS7du3TIls0yZMlq1alWy3mZxcXF6//33VaFCBVMy3dzcdOHChRTjGZ06dUrZsmUzJTPRoUOHVKxYMeXKlUsbNmzQtm3bFBgYqDfeeMPhH/yccRVbSijUzJs3L0NPzJxRqM7IMWic2cPF1dVVnp6eKZZ7eHikequ/I7Rv317jxo1TZGSkKlasKIvFot9++00zZ87MsLG7EpUsWdKhvc/WrFmjZcuWSUo44XvuuedS9HiLjIw0bfzQjHxdSGsv39TeV9Pr1KlTmjlzZorlrVu31uLFix2eJyVcXDlw4IBee+01ffvttzp48KCmTp2qL774QlOnTk0xNq0j3DkYf8eOHU0fjN8ZY9D++eef6t+/vyZOnKiAgAC1bdtWly9flru7uxYtWmRKgcjb21vz58+3/X/RokU6evSocufObdo5uTNmb3377bfVtWtX1alTR9HR0erTp4/Onz+vnDlzmlZgfOutt9StWze1bt1a3t7eslgsioyMVOnSpTVs2DCH5TwMQ0c9/fTT2rlzJ4W3zOSZZ55R4cKF1bBhQzVs2FCVK1dO8UbtaKld/TNbRt+KczdLly7ViBEj9NJLL9mWNWvWTEWLFtXKlSvTXXhzxnPrbE888YQ2bdqkDz/8UAUKFJDVatUzzzyjl156yeFXq2rUqKHatWvb/l7y5cvn0OOn5ueff9bQoUNt3cHHjRunli1baunSpdq1a5eCg4O1ZMkSDRs2TJUqVXJ4frVq1bRw4UKNHj1aAQEBWrdund544w0dOHBA2bNnd3ieJD333HOKi4vTggULdPv2bY0ePVp+fn4aNGiQOnfubEqmJD377LNat26dqeOrJfXZZ5/pnXfeSfVkxayxRbJkyaLr16+nWH7hwoW73rKdXhUqVNDWrVtTTG++atWqZFPdO9KwYcPUo0cP/fjjjypXrpwMw9Bvv/2mW7duaeXKlaZktm7dWqNGjdJbb72lJ598UoZh6ODBg5ozZ06y13xHW7t2rcaNG6dly5bJz89PI0aMUO3atbV8+XLFxsY6/GTGGVexJSlbtmym9Zy+m4wqVJctW9Y2kHpAQECGjAmWmozs4RIYGKj58+dr6tSptttqY2NjtWDBAluR09HefPNNRUREaPz48YqLi5NhGHJzc9Mrr7xi6nh2d7p+/bpWrFjh0M8QHTp0UEREhAzD0Lx589SiRYsU79HZs2d32Iy/d3LW68K1a9e0YMECnThxQvHx8ZISCo+xsbH666+/dPDgQYfm5c2bV//++6+KFi2abPm///5rWk/cnTt3at68eXriiSe0bNky1a1bV23atFHp0qVNG5bCGYPxS8rwybz+97//qWjRoipRooS2bdumuLg47dy5Ux9++KFmzpxp2gXJ27dv68svv9SpU6fUo0cPXb9+3bTbTKWMnzxMkvLly6cNGzZoy5YtOnbsmKxWqzp37qxnn33WtDH8cuTIoU8++UQ//vij/vrrLxmGodKlS6tevXoOvQDwMJxvBwUFqVWrVvr6669VuHDhFJ8bzLgbwmLc795B3FNsbKwOHDigH374QTt37tSVK1dUt25dNWjQQA0aNHD4+AF3iomJ0fr16/XXX3/ZZuRIylG/NA/LzHMVK1bUli1bUsxieObMGbVu3VpHjhxxWFZGPbf2zCRods/DmJgYZcmSxbSuvf/995927typH374Qbt371bBggXVsGFDNWjQQIGBgab09njmmWf02muvqX379jpw4ID69u2rffv22U5UDMPQhg0bNGfOHFN6LPz111/q1q2bXnvtNXXu3Flt2rRRZGSkbt26pR49emjw4MEOz0wqo27BlP5v1sBs2bLJ398/xe+Ro69wNW3aVPXr19egQYNMu83pTu+++67Onj2rkJAQNW7cWJs2bVJMTIzeeustVahQwZQPtocOHVK3bt1Uu3Zt/fTTT2rTpo1Onjypo0ePaunSpabd5nD27FmtW7dOf/31l6SE4kbnzp1Nu6IcExOjiRMn6vPPP7ed1Ht4eKhLly4aOnSoaa9LzzzzjLp06aKXX35Zs2bN0jfffKNNmzbphx9+0NixYx3+uhAWFqauXbvq6tWrioqKUokSJWxXsVevXm3aha6pU6fq2rVrGj9+vKk965KqXbu2Fi1apAoVKqhKlSratGmTChcurJ9//lmDBw/W7t27HZLz+eef22Zn/eyzz+75u2JWz6w7e7g0b97c1B4up06dUqdOnZQ9e3Y9+eSTslgsOnLkiK5fv64PPvjAtKK8lDA27D///CM3NzcVK1Ys1Z53jnK3QqrFYtGECRPuOllIeiQduy+j3O11IUeOHFqzZo1prwtDhgzRTz/9pHr16mnr1q1q1aqVTp06paNHj2rw4MF64403HJo3c+ZMbdq0SWPGjFHVqlUlSQcPHtS4cePUuHFjU2akrFy5sr788kvlz59fTz31lLp166auXbvqzJkzateunQ4dOuTwzEqVKmnLli0qXLiwevbsqQIFCmj8+PE6f/68nnnmGYeeryS632ReZvQGDgwM1Pr16/XEE0+of//+trE0z549qzZt2ujw4cMOz7x8+bI6deqky5cvKyYmRl999ZUmTZqk3377TStXrkx1mIz0ut9Y52ZMQpIoJiZG586ds90S7cjZ7J0lLeObJzKrJ+eQIUP01VdfqWzZsqm+h5nx90KPt3TKkiWLateurdq1a2v48OE6f/68du7cqS+//FLjxo3TE088Yevdkzj1uiONGDFCX3/9tcqVK2dq1d1ZM8/dqWDBgvr9999TFN6OHDmi3LlzOzQro57b9u3b2z5UXrt2TWvWrNFTTz2lKlWqyM3NTb/99pu+/vprde/e3bQ2fPTRR1qyZIlCQ0P11VdfaenSpcqdO7fDX+zy5Mmj559/Xs8//7zi4uJ08OBB/fDDDxo/frzCwsJsveEaNGjgsJ/n5cuXFRgYKHd3d1WqVEkxMTG6ceOGcubMKSnhA0n79u3VqlUrh+TdqVSpUtqxY4du3ryp7Nmza/369dq0aZMKFCigFi1aOCznfh8K/v77b9v3Zn1ASPzAXKlSpQw5YQkLC1P37t0zrOgmJdya/frrr6tOnToyDEMdOnTQ9evXFRAQ4NBu+EkFBgbq448/1tKlS1W0aFEdPnxYpUqV0qhRo0zppZmocOHCGjJkiCkT2aTG3d1d48eP1/Dhw/XPP/9ISuiRa/bv0rlz59S4cWNJCbdjNmjQQFLCrWxmTEbijKvYUsJr4bZt2/Tdd9+pSJEiKd7XzLj1o2nTppo+fbpCQkJsy06dOqVJkyY5dGyupMW0Dh06OOy49sjoHi5PPPGENmzYoA8//NDWM6F169bq1KmTqWN5StKtW7fk5+cnwzAUHh5uW27GbZipXeTMkiWLKleu7NBe+fv377d97qpZs6Z+//33u25rxnto4uvCF198oaNHj2bY68KuXbs0depUNWzYUMePH1ePHj0UEBCgd999VydPnnR4Xp8+ffTnn3+qV69ets++hmGoYcOGGjJkiMPzpIS/le+//14FChRQaGio7TV+3bp1KYY2cBRnDMbvjMm8Env4xsfH6+eff7ZNeHLjxg3TCvJTpkxRyZIltXnzZtWpU0dSQs+7wYMHa+rUqVq0aJHDM1Mb69xischiscjFxeWerxcPyjAMTZ8+XR988IFiY2P11VdfKSQkRB4eHho/frzDCnDO6DF+55iooaGhypIliwoXLiw3NzedOXNGsbGxevLJJ00rvH377beaN2+eGjZsaMrxU0PhzcEKFSqkl156SS+99JJiYmK0d+9e7dy5U0FBQfrqq68cnvf9998rJCRETZs2dfixk3LWzHN36tSpk8aNG6erV68qMDBQFotFBw4c0OzZs/XKK684NCujntukt2f07dtXgwYNSjEw8gcffKAdO3aYkr9582ZNnz5dr776qpYsWSIpYeD24OBgeXh4mDZIc+KH25o1ayooKEgXLlzQDz/8oO3bt2vSpEkOu73h2WefVa9evVSlShWdOHFC9evXtxXdkjKzuOrp6Wn7AOLn56du3bo5PCPph4Kkf4dJr3gmMutWq3379mnFihWm3eZ0p3Llyunvv/82/SQzKS8vL61du1Z79uyxnRyVLl1a9evXN3WYgYCAAE2bNs2046fGzIls7ubmzZvavHmzTpw4ITc3N5UqVUotW7Y09cTTz89Ply5dUpYsWfT7779r0KBBkhJu2XH0BZ1EWbNmVceOHU059t24urqqdevWGZrpjEJ1TEyMli1bpmeeeUZFixbVqFGjtHXrVgUGBio4OFi+vr6m5B49elRTp06Vl5eXdu3apUaNGsnT01ONGjUybTyeQoUKZdit/ZJ0+PBhDR8+XGfOnEm2PPF9x4z3lt9//12vvvpqiguujvbKK6/op59+kp+f3z0nFDPrcUoJz2/+/Pltw6ZMmjRJx44dM7U3zY0bN1S6dGlJCQWq48ePKyAgQF26dHF4bzcpYQzC+fPn69SpU/rzzz9lGIbKlCljWgFMSpiltn///oqNjVXr1q1VrFgxTZ48WWvWrNG8efNMyXTGYPzOmMyrcuXKWrhwoXLnzq1bt26pQYMGCgsL04wZM1S5cmWH50kJQ8gsWrQo2UW5HDlyKCgoSF27djUl8847jhJnV545c6Zp72UffPCBNm7cqDFjxmj8+PGSEi5mjRs3Tn5+fho6dKhDct577z1bMTijJptKeifBypUrbZOIJd6dExkZqWHDhtlem8yQPXt2099X7kThzUTu7u6qX7++6tevb1pGjhw5UoyTYLaMnHnuTl27dtX58+f13nvv2caicHV11QsvvKA333zToVnOeG5/+umnVF/AGzRokGzcD0datmyZRo0apfbt29sGFu7atau8vb21YMEC0wpvdypYsKA6deqkTp06KTY21mHHfeedd1SvXj2dPHlSTz/9tJo1a+awY9+NM24fTnqcn3/+WfPmzdPIkSMVGBgoNzc3HTlyRJMnTzb155k7d27Txq1LlLRnX9OmTTVq1Cj169dPxYoVS3H7nJknK4k9nTPC3W71t1gsypIli/Lnz68WLVqoePHiDss0eyKb1ISGhqpLly66cuWKihcvrvj4eK1bt04LFy7Uhx9+aNr4La1atdLQoUOVNWtW5c+fXzVq1NDWrVs1YcIEhz3OJk2a6JNPPpGvr+99Xx/MGlIgo2dvlZxTqA4ODtbGjRtVv359/fTTT/r88881YMAAfffdd5o6dappz0NG9HDp2rWr5s6dKx8fn/ueYJrRg3HixInKkSOH5s6dm2Ez427YsMGUi1V3+uabb2xFWWdMKLZp0yaNHDlSQ4YMUb169SQl9Oru1q2bZs6cadpF4AIFCuj8+fMqUKCAihUrpuPHj0tK+H2+du2aQzIuXLigAgUKyGKx6MKFC7bjJ+2xnbjcjF6TDRs21M6dOxUWFqaAgABJUsuWLfXCCy+YVvBzxmD8zpjM691339WgQYN09uxZjRw5Urly5dKECRN08uRJ28V8R7tx48Zde8InPn5HS+1W76JFiypbtmyaOHGiNm7c6PDMjz/+WKNHj1azZs00YcIESQm/t+7u7po0aZLDCm9Je4xbLBZbRlI3b97UunXrHJJ3p0WLFmnp0qXJhsTx8fHR4MGD9corr5g2JE+vXr00c+ZMTZo0ydSLu0lReEunu33wyZIli3LkyKGKFSvq+eefN+0H2qdPH02ZMkVjx47NsF4fzpx57sCBAxo2bJgGDhxou3WuRIkSpjy/znhu8+bNq927d6co+O3YscO08T3++ecfVatWLcXyatWq6eLFiw7NutuHjaR/L40bN3b4+AWNGjVy6G1N9+OM24eT/n4sXrxYkyZNSlYYqlevnsaMGaO3337blEkHpITxEiZOnKgxY8akWghzhNR6IowdOzbFdmb1SrhXN/zEItizzz6rN99802E9gGNjY/XFF18oT548thlFjx49qosXL6pSpUrau3evFi5cqGXLltnGzEkvsyeySc2UKVNUoEABrV+/3jY+6uXLlzVw4EBNmzZN06dPd3imlPB7mz9/fp09e1Yvv/yyXF1ddeXKFb3wwgsaMGCAQzLat29v6/WakbdCbtiwwfYhesOGDffc1ozXhcRC0Z2F6itXrqhHjx73bdOD+PLLLzVjxgyVL19e48ePV40aNdS7d2/VrVvXlB48iTKih0uhQoVsBUtnTHp14sQJrVu3TmXLls2wzEaNGmn16tXq16+fqSdHSZ/PuXPnatSoUSnyrl69qlGjRpnSS2rRokUaOXJkstfc2bNna82aNZozZ45phbcWLVpo2LBhmjp1qmrVqqW33npLlStX1o4dOxx28blJkya2W9nuduHBzF6TkuTr66uIiAht27ZNWbJkUYkSJVSiRAlTsiTnDMbvjMm8ihYtmuK2wTfffFMjR440bSzR6tWra82aNcnGA4yNjdW8efNMmcjmXvLly2cbGsPRzp07l+prbZkyZRw6DEZ4eLhtBuMRI0aoVKlSKXqGHzt2TDNmzDCl12RMTIxu3ryZYnni3RZm+fbbb3XgwAHVqlVLfn5+cnNLXhYz4wIMhbd0utsHH6vVqqtXr+r999/XqlWr9PHHHytPnjwOzy9durSCg4PvOsuSGW9gzpp5TkroLr506VKVL1/elDHzknLGc9ujRw9NmDBBhw8fVoUKFWzP7fbt203r8ZY7d+5Ub9c7dOiQwwdRTzpWYFKGYejq1atavny5ypQpo5UrVzrsA3bHjh01dOjQNJ/47N69WzNmzNAnn3zywJnOvn04LCws1Z+dj4+Prl69akqmlDBo8oULF+56O5sj/mac0RMhqREjRmjGjBl66aWXbEWuX3/9VatXr1anTp2UI0cOrVq1Su7u7g7rXejp6anmzZtr6tSptg/tcXFxeuedd5Q1a1aNGTNGwcHBmjlzpsMGg71w4YKt10VS9evXN+22uZ9++knLly9PNilR7ty5NXz4cFN7arq4uKQYqsDRQxckHaPE3d1dzz77bIbM6vz222+rfv368vPz09tvv33X7Rw5C/DOnTv122+/SUroobpw4cIUF+VOnz5tWg+Mq1ev2i4M/vTTT7Yisa+vr+3kwgwZ0cMlaW89Z/RgLFCggEN7pKfFhQsX9MUXX2jlypXy8/OTh4dHsvWOek84ePCgzp49KymhYF2+fPkUn0NOnTrlsAlB7nT27NlU75Bp0KCBpk6dakqmlPB55fbt2woNDVWbNm30zDPP6K233pK3t7dmz57tkIyVK1faCtJm9MS8n5iYGA0dOlTbt29PNvzGU089pZkzZ5pWDAsPD9c///yT6gyjffv2dXjeW2+9pW7duumjjz5S586dtWDBAtWoUcM2mZdZbt68qU2bNmXYEBHDhw/Xyy+/rH379ik2NlZjx47V33//raioKK1evdqUzMQemYkMw1BUVJQWLFhg2t1RhQoV0pEjR1KMZblz506Hdgj54Ycf9Pbbb9suaqd2YTVxHEYzNG7cWO+++65Gjx6drK4wYcIEtWnTxpRMSapatarDLlanFYW3dLrfB5+YmBj17t1bs2fPtnUTdaR33nlHRYsWVbt27TJs9qWhQ4fq9u3bGjNmTIqZ58waADGRn5+foqKiTM1I5Izn9sUXX5SXl5c++OADff3117JYLCpbtqzmz59v2gveiy++qHHjxtlOyv7++2/9+OOPmjVrlsOvbNyvKHD58mX16tVL8+bN0/Dhwx2SOXbsWI0YMUJubm5q1aqVnnrqKRUvXjzZFdfjx4/r559/1qeffqr4+HhNmTLFIdmSc24frlixombOnKkpU6bYrnJevXpV06ZNM3UK7z59+ph27ESpXey4fv26/v77b9vArGb2ivjiiy80cuRIvfjii7ZlTZs2VYkSJbRu3Tp99NFHKlWqlKZOneqwYtGXX36ptWvXJjs5cHNzU8+ePdWpUyeNGTNGzz//vD788EOH5EkZO5FNIldX11QHY/bw8FBMTIwpmYm+++47LVy40HbiULJkSfXo0cOUW9MXLVqk5s2bO/y4qUm8bezO781UqFAhjR8/3naCu3Xr1mS3lVosFmXLls20cXGKFCmi3377TeHh4Tp9+rStmLFjxw6HDsZ/J2f0cDl06JCKFSumXLlyacOGDdq2bZsCAwP1xhtvmDLm7ptvvqn33ntP48aNU4kSJTJkdr26deuqbt26pudYLBbb5yCLxZLqsCnZsmUzrYBRoEAB7d27N9WLoGZcuE/k7u5uGxBfSvjMlFh4c1SPpaSfO1L7DBIeHp7sgoujhYSE6MiRI5o/f76qV6+u+Ph47d+/XxMnTtScOXNMmdQh8bNCdHR0ivF3CxUqZErhLaMm80rKGUNEPPHEE9q0aZM+/PBDFShQQFarVc8884xeeukl017jU+upaRiGsmfPblpv/B49emjcuHEKCwuTYRjas2eP1q5dqw8++MChtyu3a9dOhQoVktVq1auvvqrZs2fbCuXS/71nmzXe2rvvvquBAwfq1VdfTTbhSmJvXLOYXbNIjcVIbeRQONSePXs0YsQIff/99w4/dsWKFbVx40aHju2TmkuXLqXoQZM4nbyUMTPPSQmFzrVr16phw4YqWrRoiiufjvwjyqjn9osvvlC9evWSvchltBkzZmjlypWKjo6WlHBS36lTJ40cOdLUAeNT8/3332vixIkO7Q0WFxenjRs3avny5Tp58qTc3d2VI0cOW0+7+Ph4lSpVSl27dlX79u0d2j3+6aefVrdu3dS5c+dky5cuXapPP/1UW7dudVhWor/++kuvvfaabt++bbsS988//8jPz0+rVq0yZQwVZzAMQ1OnTtXq1attFwHc3d314osvauTIkaaceFasWFGbN29OcYXzzJkzat26tY4cOaLQ0FA1b95cR44ccUhmrVq1NHPmTNWqVSvZ8j179mjgwIHat2+fTp06pc6dO2vfvn0OyVyxYoUWLFiggQMHpjqRjRkfWPr06SNPT09NnTrVdkIfGxuroKAgRUZG2sagdLQdO3aof//+atasWbLx7L777jvNmTPH4bPB9ejRQ/Xq1cuQcauSOnLkSKo9xa9du6YJEyaYciGgcePG+uSTT0w9qb7Thg0b9O6778rFxUVVqlTRihUrNG/ePM2bN0/vvfeeabfaS9LFixe1Zs2aZD0/XnzxRVNec9euXatx48Zp2bJl8vPz07PPPqvatWvr6NGjpl0Ibdy4sS5d+n/snXlYTev7/9+bXeaxHMVBporSxDGWQpwGNBmSSkrGopyolNJIqSglQyOiIhXKkamQsZASRUJKhkIyNK7fH/1a33Z7xznHevY+x6fXdbkunr2te7faa63nuZ/7fr9f0xq7rSHVJshvpKWlceXKFWKbDLw4ePAgAgICYGpqCnl5ebBYLOTm5iI6Ohpr1qwh5mz/rXZvYWFh9O/fHwoKCozNi6qqqrB9+3YYGxvTGxw3btyAhIQE9u3bR0TaRUVFBZ6enlwb2BcvXoSbmxuR9dmcOXMgJycHS0tLLFiwABEREXj9+jXc3Nywfv166OjoMB5TEKxbtw4VFRUICgrikogQExMjkpQ6dOgQ5syZw9d1E6+5lZCQECQlJYlqG8fFxSE0NJSW/hEREcGyZcuIzR9u3rxJa0OTpL6+nivGkydP8OjRIwBN5mmkZZ4EIb/RnnjjA6WlpdDU1GRsEdYSAwMDbNiwgWtBxjRjx47FoEGDoKqqiqlTp0JRUZHvCRmgadLXFiwWi9E2NH6dWwsLC9y+fRtSUlJQVVWFqqoqRo8eTTRmS27evAlFRUXU19fj8ePHoCiKmG7eX6GkpATa2tpErhegqcXp7t27ePv2LVgsFvr37w85OTliN/i4uDh4eHhAW1ubZ/uwpqYmkbjV1dU4deoU/RAbNWoUtLW1iSfI+Vk5tHfvXoSHh2Pt2rUcCZOQkBAsX74cy5YtYzxmsyBz62rQqKgoHD58GGlpabhx4wbs7e0Zm8y7urri2rVr2LJlC+Tl5UFRFO7evQsPDw8oKSnRJfrv3r1DeHg4IzEbGxuxdetWHDlyBA0NDaAoCmw2GwsWLICzszOR+39RUREMDQ3RrVs3yMrKgsVi4d69e6iursbBgweJ3Rf19PSgrq7OVYEQHByM9PT0H2o754W1tTXOnTuHnj17QkJCgmsDiVQr1vjx4xEZGQkZGRl67Ny5c9iyZQsoikJmZiaRuEBT9f+LFy8wePBgUBRFvFLq4cOHePHiBaZOnQphYWFcunQJbDYbkydPJhazsLAQxsbG6Ny5M+Tk5NDQ0IC8vDx8+fKFroRlEk1NTRgbG2Px4sUIDAzE+fPnceLECVy6dAlbtmzhcI1jisTExG++3lKk+0cIDg6GhYUFunTpguDg4Dbfx2KxiFQOCYrw8HBER0fj9evXAJp0f5cvXw5jY2NiMWfNmoUXL16gsbGRNsz4+PEjh5bq0KFDERkZyUj1kqOjI7KysrBnzx48efIE69evh7e3N1JSUiAkJMRVNcoEioqKSExMhISEBMf406dPMXfuXCLzzTFjxiA5ORnDhg3DkiVLYGFhgalTpyItLQ179uzh0kVjgry8PGzZsgWPHj3iWSVOIjE+btw4REZG0vqzzdy7dw+Wlpa4ceMG4zFVVVXx7t07TJs2DQYGBlBRUSGy0dqSlvekllRXVyMwMJCjapQpTpw4AVVVVfTq1QuVlZWgKIrDgIAUDx8+RGFhIc8W6WbToB9FSUkJkyZNote9/JDeaE2z0UprOnXqBDExMZw5c4bxmO2JNz5w//59rFixAleuXGH82BkZGfD09MTSpUsxdOhQruwxU65+dXV1yMrKwqVLl5CRkYGKigpMmTIFU6dOxdSpU/m6m80v+HVuAeDr16+4du0aMjIycOnSJdTW1kJFRQWqqqpQVlYmmgSbOHEirZv3b6CwsBBLlizBtWvXBP1RGCMlJQUHDx5EQUEB3T68fPlyYu3DgoLflUPTp0/HH3/8AW1tbY7xkydPYteuXUhLS2M0XvOxHRwcoKGhAUVFRTQ2NiInJwdnzpyBm5sblJSUYGFhAXV1dWzatImRmF+/fsXGjRvp9vNmNDU14e7ujuvXr8PDwwN79+5tcyLxT2lu4wXIGdm0pKysDDExMXj06BEoioKkpCQMDQ2J7ny2VcX49OlT6OjoICcnh9F432sRIaXdtW3bNiQmJiI6OhpiYmLw8PBASkoK5s6di02bNqF3795E4vr5+eHgwYOoq6vDmTNnsGPHDnTq1Anu7u5EE3D8TvYtW7YMXbt2hZ+fH91eWlNTgw0bNqCmpgZ79+5lNN6YMWOQlpYGcXFxLFiwAOPHj4ednR3KysqgoaFBbPOKH0yfPh0JCQm0C3BbML3h2kxtbS3i4uJQUFDAUd1XW1tLmyOR5N27dxASEuLLBmhkZCSOHz8Of39/upXsyZMn2LhxI/T19aGurg5nZ2f06NGDkeqlyZMnIyQkBIqKinByckJFRQW9WWdsbMzhXM4UCxcuxLRp07By5UqO8d27d+PMmTNEHCnHjRuHxMREDBo0CK6urhg8eDAsLCxQVlaGOXPmIDs7m/GYOjo66NSpE/T19bk2dADmEuMtmTBhAg4dOsS1sVBQUABDQ0PcuXOH8ZjNG0VJSUk4d+4cevToAV1dXejp6TFqmFFUVITKykoATUZBu3bt4qqyKywshK+vL+PzBKBps+zIkSPEnHd5ceDAATq51jL5zmKxMG7cOMZ0hN+8eUOvea9evYoBAwbQxT1KSkrEjDm+RX19PZ49ewYXFxcsXrwYWlpajMdo13jjAwcOHCDmsrJixQoAgLu7O9drTLoDCQkJ0a5k9vb2KC0tRUZGBv7880+4ublh+PDhdNaaadODtpxjW8NisRAdHc1YXH6dW6BJPH3atGmYNm0aAODx48e4dOkSjhw5AgcHB4wZMwZTp04lIjDOT928v0JiYiJkZWUF/TEYRVtbmys5RJKKigrs2LED2dnZqKurQ+v9FVIGBSEhIbCysuKoQDAzM0NwcDBCQ0MZT7xVVFRw7bICgLy8PF6+fMlorGbmzJmD7t27IyIiAgEBAWCz2ZCSkkJoaChUVFRw69YtzJkzh9E2r86dOyMoKAgvXrxAfn4+OnbsCCkpKVrLZOrUqcjIyGAsXjM1NTX4888/8ejRIwgLC0NSUhKamppEWxAGDBiADRs2oLq6GkJCQjwXD0zzyy+/4OnTpzwTb80VIExibW0NMTExrqrB+vp65OfnMx6vGQcHB7DZbJiZmYHNZqNTp04ICwvjaaLBFAcOHEBycjJcXV3pZ6m6ujrc3NwgIiICOzs7xmNSFAV/f3++J/uys7MRFxfHoenWqVMnrF69mkjFkoiICF6/fg0hISHk5eXB1tYWQFO1AskWyYyMDISHh+PJkyeIi4tDQkICBg8ezGhbzqlTp2hDDhKVe9/D29sbx48fh4yMDHJycqCoqIhnz56hoqKCUe3bW7du0W7n30s4MbnZ25LIyEjs3LmTQ79p2LBhcHZ2xrp162BkZAQbGxvGWl0/f/4McXFxAE1mVs0tc126dGmzhflHWbVqFVavXo2HDx9ySCeQNC6Tk5NDbGwsNmzYgBEjRuDixYuwsLDA48ePid2Dnj59imPHjjFeXfstlJSUsHv3bi6JiNDQUCgqKhKJyWKxoKysDGVlZXz69AlpaWlIS0uDvr4+pKWlMX/+fGhra/PUjP07lJSUYOXKlfSGZ1vzOgMDgx+K0xYSEhIoKCjga+Lt0KFDWLFiBdasWYNp06bh+PHjeP/+Pf744w9G5/D9+vXDvHnzMG/ePNTX1yM7OxuXLl2Cu7s7Xr16RVfDTZ06lW8t/2w2G8OHD4eDgwPs7OzaE2//RtoqgacoClVVVcjOzkZxcTHi4uKIxBeUw9/AgQNhZGQEIyMj1NTU4MaNG7h06RI2bNjAeGlmW86xpBGke+KIESMwYsQImJub49OnT7h69SouXbpEJJaysjJWrFjBF928tvrpGxsbUVVVhaysLKSnpyMqKoqxmP+LuLi4ICsrC7q6ukQSB21RVFSEnTt3co3Pnj0b+/fvZzyehIQEMjMzuQwArly5QlTHrmWSvDW//fYbIwuksrIyiIuLg8Vi0W5aHTp04EhKN4+T+FlLSkpgZGSE6upqWjD5wIED2L17N/bv309MwDg6OhqRkZF49eoVWCwWfv31V6xevZqoLtfs2bPh5uYGV1dX2uEqOzsb7u7uRASpZ8yYgczMTK5K8RcvXsDExITIznkzdnZ2EBISwt69e3HkyBHIy8sTiwU0tdq7uLhg5syZtMGUlpYWhIWF4eXlRSTxdvDgQb4n+wCgW7duPNu7SBmDaGtrw87ODl26dIGYmBjGjx+P1NRUeHh48HSlY4LMzExYWVlBW1sbd+/eRWNjIxoaGrBp0yY0NDQwtgBVVlaGlpYW5s+fT/w7yotz585h27Zt0NLSwqxZs+Dh4YFBgwbB1taWUVdXExMTZGZmQkREBCYmJhwVJi1herO3JR8/fuRZWde5c2d8+PABQJMjerMG8I8yfPhwpKenQ1xcHC9fvsTUqVMBAPHx8cQSDGpqaggKCsK+ffuQnp5OV1MHBAQQMx1Ys2YNLCws0LdvX+jr6yM4OBja2tp4+fIlMYmRMWPGoLS0lK+JNzs7OxgaGmLmzJk8JSJI8/nzZ3z48AHv3r1DbW0tOnTogL179yIgIAB+fn6YNGnSPz62mpoaLly4gMbGRqirq+Po0aMcz+1m0wFS1eIjR46EnZ0dwsLCeMpSkKiOLysrw7x58yAsLAxpaWnk5uZCXV0dDg4O2LZtG+Ome0BTwmvChAmYMGECNmzYgLKyMly6dAlnz56Fl5cXkerQb9G1a1dim/ftraY/SFsl8EJCQujVqxfGjBkDU1NTRq2Gm3UCVFVVufQK2vkxBH1u29rxZLFYEBISgpiYGON98Pxs42irDY7NZtPXy7JlyzBu3DjGYv4voqCggJCQEL44wbVEXV0dmzdv5mqhTU9Ph7OzM+Pt9klJSXBxcYGJiQnHLnZMTAw2bNjAWJXJX9UbAphLVI8aNQpXrlyBiIgIpKWleeqXNLukkViQmZubQ1hYGNu3b6eTt5WVlbC1tUWXLl2wZ88exmNGRUUhMDCQFhdvbGxEVlYWYmNjYWdnR0znqKamBra2trhw4QKHo5aqqip27tzJiC5iTEwMbQ5RWloKcXFxroq3qqoqiIqK4vTp0z8cr5m2Ksbv3r3L5VJGQltOXl4eKSkp+PXXX6GoqIgTJ05g0KBBKCkpgZaWFnJzcxmPqa2tDRsbG8ycOZMj5rlz5+Dl5YWLFy8yHhNoWoC+fv0aQUFB9EKssrISNjY26Nmz53fvHX+XxsZGxMTEoKSkBIsXL8aQIUNw8OBBvH37FtbW1kQqUw0NDaGhoQEzMzOOcxseHo7ExEScOnWKkTj79u3DiRMn8PjxY4wYMQLz5s2Djo4O+vTpw8jxv4esrCzS0tIwYMAAWFlZQUNDA7Nnz0Zubi5sbGwYmxeVlpZiwIABYLFYKCkp+aZ2JqlN6OZOioCAAPpeX1VVBTs7O9TV1SEyMhIRERE4deoUI7pkGRkZsLa2Rl1dHbS1teHn54etW7ciJiYGISEhP5UEx6tXr1BbW4tBgwahqKgIR44cgbi4OExNTYlUvRUXF2PlypXQ1tbGr7/+yvV9IrWBxW+JiJqaGqSlpSE5ORnXrl2DqKgodHV1YWBgQG/Eurm54cKFC4x1A7S8VvmFiYnJN18nkdicMGECYmNjMXToUHh4eKBfv35YuXIlXr58CS0tLSKtw9+irq6OWIVo6zU3RVH4+PEjoqKiUFNTg/j4eMZjtife/oOkpKQgIyMDV65cQffu3elE0YQJE4ja1jfT1iIQAJ0c0tHRwerVq/l6g2ICQZ9bGRkZDjFLAFzncPz48di1axd69uxJ/PO0899k8uTJOHToEKNaF3+FnTt34sSJE1yVQ25ubpg+fTqcnZ0ZjxkVFYWwsDC8ffsWQFP7lbm5OSwsLBiLIQi9oZbOUt9zKh0/fjwjMVsiLy+PhIQEjBgxgmP8wYMHWLRoEe7evct4TFVVVWzYsAGzZ8/mGD969ChCQ0OJt5wVFRWhsLAQFEVBSkqK0eqLL1++IDw8HBRFISQkBEuXLuVyQuvWrRtmzZrF6AL7e3pyLSGxe66lpQUrKytoaWlxJGoOHTqEw4cPE3F1FkSyD2hyNDU0NMSHDx8gISEBFouF4uJi9OzZE4cOHSLu0MYPFBUVkZycjMGDB3Od29mzZzNerXnv3j0kJycjNTUV1dXVmD59OhYsWEB8U0lNTQ27du3CmDFj4OvrCzabjfXr1+PFixfQ1tYmUpWqr68Pb29vxnU6v0dJSQmWLFmCd+/eYejQoaAoCk+fPkWfPn0QFhaGly9fYvny5dixYwdmzZrFSMx3797h1atX9M+ak5OD7t27E22py8/PR1RUFId0gqWlJVfFPFM4OjrCycmJq5rw/fv3cHJyQkhICOMxQ0NDERgYyPM1klWT/EZJSQn19fVQU1OjzRVaJxnT0tLg6enJaLfQhQsXeOo+5uTkMCp1JEjWrFmD7t27w8XFBampqYiPj0dcXBxSUlLg4+NDRK9++vTpPPMFLYtOdHR0GE8cN+czWqfCBg0aBD8/PyLV1u2tpj/Iq1ev/nYF0j/5Py1p1ouiKAq5ubnIyMhAUFAQioqK8Ntvv9HJIlKtQI6OjggICICRkRG9uM7JycGhQ4dgaGiIXr164cCBAxAWFiaiSUYSQZ/bbdu2YceOHdi8eTNd9dXsXrho0SLIy8tj27Zt8PPz46k9909obldrTfMNr2/fvow5GH758uVvV4/8k//zLUpLS5GTk8Oz/YfEbmCzayxpYe+W6OrqIjw8HO7u7nwVKF21ahUKCwuxYsUKrsqh9evXE4lpZmaGRYsW4dOnT7TzUrN+DFO0TPh8K/nTnDRngpbJtJs3b37TTYtE4k1MTAyvX7/mSrx9+PCBWNVJVVUVT5OXsWPHoqKigkjMlvTp0wcKCgr0JIzJVt4uXbrQ1ZAsFovn75MEpIwa/ioWFhZwc3PDq1evQFEUrl27htjYWBw8ePBvJQX/DgMHDsS9e/e4ntMZGRlEk19iYmJISUlBcnIyXfkxb948zJkzh0jLf2NjI06dOtWmlieJ332PHj3w6tUrrmTFo0ePuETHmUBOTg5ycnJwdHREeno6kpKSsHLlSvTr1w/6+vowMDBg/H4PNG0CuLq6YuvWrVBSUoKXlxdmzpyJ1NRURpw9eVFaWkrr2vGTQYMGITU1FSkpKXjw4AE6duwIU1NTaGtrQ1hYGJ06dcLJkycZ3cjr06cPx3OEdDvx1atXYWFhAQUFBUyYMAENDQ24ffs2Zs+ejX379mHixImMxMnOzkZJSQmApop8GRkZrsRbUVERrl69yki81hw4cADr1q3D0qVLf1jf7K/y5csXREVFtXkfIlFJvW7dOsydO/ebc5Hp06czligGgB07dmDv3r345Zdf8ObNG/Tv3x9v375FQ0MDMQ1nQXRB2djYYOnSpThy5AgWLVqE0NBQjB8/Hl++fGF0Q7slBgYGCAkJgbq6Okde4c8//4S+vj46dOgANzc31NXVYf78+YzF5bVRLiQkhF9++YWxGK1pr3j7QbS1tfH777/D1NT0uz3eFRUVOHDgAM6ePUtkl7eyshKXLl3CpUuXaM0IEnEWLFgAAwMDLFy4kGM8MTER8fHxOHLkCM6fPw9fX18iVryCgF/ndubMmXBxcYGKigrH+LVr1+Dq6oq0tDTcuXMH1tbWjO06fKuCEQCEhYWhra2NLVu2/HDVn5aWFpYtWwZdXd3vJvPq6uqQlJSEiIgIxlqvEhIS4OLiwlPAl9RuoCBcYzdu3IjTp0+jR48eGDx4MNfvjcREqCW8Koea2yKZpKKiAmvXrsXYsWPpxN6ECRMwatQoBAYGElkIzpgxAwkJCVz3+1evXmHu3Lm4ceMGI3EE4abVMgl/4cIFREREYPPmzRg7diw6dOiA+/fvw8XFBatWrSKSpLazs0Pfvn253GD9/f3x9OlT7Nq1i/GYQFNVjY2NDZemB8lW3i9fvqCwsJDnQoWUiDrQVJUVExODgoICsNlsjBw5EgsXLiSqiRgXF4fQ0FCUl5cDaKpKXbZsGS2qzjQJCQnw9fXFypUrERgYiE2bNuHZs2d0sm/RokVE4vK7wmXr1q04cOAApKWleWp0kWhD2r59OzIzM+Hl5QUTExMcPnwYr169wpYtW/D777/DwcGB8Zit+fDhA/7880/adfT+/fuMx/j48SPs7e0xZcoUGBkZYcWKFbh06RLYbDZ8fHyILLTDwsKQkZEBCwsLDB48mCtxQvIaBf7PBbg5OU1qs7C4uBju7u50oqY1JO63c+bMgbq6OtatW8cx7u3tjaysLEZaaAHg9u3bMDIyAoA29fq6du0Kc3NzRvWTm1FSUsKJEyeIFQfwwsHBAampqZg6dSrPDQZBb/4whZqaGiwtLbF48WKoqanh8OHD6Nq1K9asWYPx48dzfbeYQFBdUF+/fsXnz5/Rt29fVFRU4OTJkxATEyOmh2hubo4JEybQpobNREVFITMzE/v370dSUhLCw8Nx8uRJIp+BX7Qn3n6QT58+Yfv27UhKSsKECRMwbdo0SEpKom/fvmhsbERlZSXu37+P69ev4+rVq5g7dy7s7e2JW4Q3Njbi7t27RNxU5eTkcPLkSS7duufPn2P27Nm4d+8eXr58id9///0/bWffFiTPrYKCAhISErjK7YuKiqCnp4d79+6hrKwMmpqajC22mxcp1tbWHFV2QUFBWLx4MQYPHozg4GDMmjULf/zxxw/FKi8vx+bNm5Gfn4/ff/+d43qhKAqVlZXIy8vD9evXkZKSglGjRsHT05OxCae6ujrtzEv6GmxGW1sbmzdvZmxH9a/wvUoSUhMhfiWlmlm/fj1KS0vh7e1NXzP5+flwc3PDiBEj4OXlxUic1NRUXL58GUDTBoOWlhaXyG1paSkKCwtx/fp1RmKmp6dzuGm19ag2MDBg7OdsnYTnNdFjOhnV8rv66dMnnD17FqNGjcLYsWPRsWNH3L9/H7dv38b8+fOxZcsWRmK2xsDAAMLCwrCwsOA5eWW6ojA9PZ12bm39eyXZDlRYWAhjY2N07twZcnJyaGhoQF5eHr58+YIjR44QF+SurKwERVEQEREhGgfgX7KvZYVLW4m3oqIiHDp0iHFtnIkTJ8La2hqLFy9m9Ljfoq6uDg4ODkhJSQHwf8kFNTU1BAYGEnchrqysRGpqKk6fPk3Pw/gh4A40PVtERUWJVUO0bDElec9tDb9dgJcsWYKysjKYmJjwTNTo6ekxGg9oe91SXFwMHR0dImsVaWlpXLlyhW+OjECTsdbAgQO5EhgkGTt2LDw9PYkZRvxbkJWVxZ9//olff/0VK1euhK6uLjQ0NJCVlQUnJycihSYnT578S11Q0tLSjHVBfYvo6GgsWbKE8eMqKCggOTmZZ15hzpw5yMnJYWzt25buLS9IFCm0t5r+IN26dcOWLVtgbm6OqKgohIaG0m5sQNMDbcCAAZg+fTqSk5MZF+xva4HdXIZ648YNaGhoYOjQoYzF/PXXX3Hx4kUuZ5MLFy7QJfjPnz/ncmz7ryGIcysrK4uwsDB4enrSLYINDQ0ICwujJ2U3b95kdDcrKioKW7Zs4XhoSktLQ1RUFLt27UJycjJERUWxadOmH068iYmJYf/+/bh+/ToiIyOxevVq1NfXc7xHWFgYkydPRkBAwA+5EfHi9evXMDc351vSDeCva2wz/NxhbJmUKi0thbu7O8+kFAm9x8zMTERHR3MkqkePHo3Nmzcz2uauqKiI2NhYjhbElouRZmcrHx8fxmIKwk0rOjqa77qcL1684Ph38+Ty4cOH9JiSkhKePHlC7DM8evQIx48f52qrJYWfnx/GjRuHdevW8dV12NfXFxMnToSfnx9dBVtTU4MNGzbAz88Pe/fuJRL39evXOHLkCIe2kpGREVGd0oULF2LhwoXEk30sFouu8mKxWPD09OR6T9euXYm06NTU1HBVx5NGSEgI/v7+WLduHfLz89HY2AhJSUmi186XL19w7tw5nDx5ElevXkWfPn2gp6cHb29vRo3LWlNdXY3U1FQUFhaiQ4cOkJGRIapBRroSvS347QJ8584dREdHQ1FRkdHjfgtZWVncvHmT6/uSk5ND7Lvb8hnWTGVlJdG1kYiICEJCQnD27FkMHTqUy2CFxNywQ4cOGD16NOPH/bfRq1cvfPr0CQAwZMgQPH78GEBTJeqrV6+IxAwKCoKbmxvHfV5FRYV2YV+6dCkcHR1hbW39w4m3yMhInDp1Ch07doSOjg7Hhs6jR4/g5OSE3NxcIok3ERER3L59m+v6vH37Nt1O/ObNG0bmS6RMav4q7Yk3hhg8eDBcXFzg4uKC8vJyvHnzBiwWC/3790e/fv2Ixa2rq0NKSgr69euHMWPGAGjalSsvL4e8vDxu3LiBPXv2ICIigu6b/lFWrVoFBwcH5ObmQlFREY2NjcjJycGZM2fg5uaG4uJiODo6MtpbLwgEcW4dHBxgZmaGGzduQFZWFo2Njbh//z4+fvyIsLAw3L59G87OzoyK1D9//hyjRo3iGh8xYgSKi4sBABISEoxqLE2cOBETJ07E169fkZeXh7dv39LXi5SUFDHtI2lpaTx79ozRZOn3OHv2LERERJCXl4e8vDyO11gsFpHEG9C02I2Pj0dxcTE2bdqEmzdvQlJSkvGFgyCSUs00NDTw1FVjs9moqalhLI64uDi9KDIxMUFwcDCRNtbWNFd6nj9/ni9uWhMmTCB6fF7wq1rlW4iJieHr1698i/fs2TPs3LmTb4m+ZrKzsxEXF8fRet6pUyesXr2amGNsfn4+jIyM0LdvX8jIyODr1684fPgwoqKiEBUVRUxInl/JPiUlJXqBze8KFxUVFVy+fJl4xVtZWRnExcXBYrHodnQ2mw05OTmO9wDMtUM2NDTgypUrOHnyJM6fP4+6ujqoqqpi165dUFVVZUx3ti2KioqwZMkSfPr0CRISEmhsbER8fDx2796N6OhoIjpvJLQ6/wpxcXFwcXHBzJkz4eHhAaBJFkRYWBheXl6MJ9769OnDZSxDgqSkJPrvzVVZT5484ZBOiIyMxJo1a4jE//jxI3x9fWFsbIwRI0bA3NwcN2/ehISEBPbt20dEbzIrK4vWy2uu9iXNrFmzkJiYCBsbG77EA0BEuuR7TJo0Cb6+vvD09ISsrCz27NkDIyMjnDlzhlgy9c2bNzzvqb/88gv9++3fvz8+fvz4Q3GCg4MRHByMCRMmoFOnTti6dSs6duwIQ0NDhIeHY+fOnejatSuxTX1TU1O4u7vj6dOnUFBQoPMKBw8exKpVq1BeXo4tW7YwstEk6Nbn9lbT/zjOzs6orq6Gr68vPZmur6+Hs7MzunTpAldXV/j5+dFfYKa4ePEiIiIicP/+fbDZbEhJSWH58uVQUVHBrVu3cOXKFVhZWfFVUJ5pBHVuX79+jdjYWOTn54PNZkNaWppeuBQVFeHVq1eYPHkyY/H09fUxZcoUrmo2f39/pKen4+TJk7hw4QK2bt2Ks2fPMhZXEPz555/w8fGBubk5hg0bxqV9RlJbiZ88e/YMCxYsQPfu3fHq1SucPn0a27dvx+XLlxEeHk6kTRrgb1IKaHJf+vr1K3bu3EnvhFVXV2Pjxo1oaGggVsHDb/glom5qaorg4GD07Nnzu+X4TFVn3Lp1C4qKimCz2W0KCQNNCdzmajimSUxMRFxcHLy9vTF06FDiE/o5c+Zg8+bNfF9oKysrY8+ePZCVleUYv3fvHszNzZGVlcV4zIULF0JSUhJbtmyhq7hra2vh4OCA169f49ChQ4zHbJ3sa26pra2tJZrs4zf79+9HcHAwVFRUMHz4cK75FlObOqNGjcKVK1cgIiLSpiYs0+2QkyZNwvv37yEhIQEDAwPo6enxpUW5maVLl4LNZsPPz49+nlVWVsLOzg5du3ZFcHAw4zFra2tp3brWrom5ublIS0tjPCbAfxfgsLAwZGVlYfv27UQrfv/qdU6qjdfR0RFZWVnYs2cPnjx5gvXr18Pb2xspKSkQEhIiplnKb3x8fBATE4Phw4fznFeTSHQIwgG4vLycbjE1MjKCoaEh/b2xt7fn6gJjAmNjYwwaNIirC8rZ2RlFRUWIj49HUlIS9u/fT7f//xN+//136OjoYPXq1QBAH1NDQwMhISHQ0NCAi4sL0WrNmJgYhIeHc2ziLF++HIaGhrh8+TKSk5Ph4uLC+OYZv3Vv2xNv/3HGjRuH2NhYrp3zoqIiGBoa4tatW3j69Cn09fVx+/ZtAX3K/yb/K+f2ypUrWLlyJWRlZTkqGPPy8hAcHIz+/fvD1NQUS5cupW/K/1W+9ZAmbbV+69YtFBUVYfbs2SgvL8eQIUOIJaZXrVqFvn37wtPTkxbbHTBgABwcHPDy5Usii92WPH36lKM9h4TrHACUlJTAyMgI1dXVdBXj06dP0bt3b4SHhxOpbHz69Cnc3Nz4KgzNLxH1lhpVDg4O30xAMTWZlpaWpg1r2rJ2B5i/Pnnp2bX18zL9O7106RK2b98OW1tbngsVUhM+Ozs7vH79GkFBQXSLcmVlJWxsbNCzZ08iyQQ5OTkkJSVxOSI+fvwY+vr6RLSVBJHsa47Bz8TJ9OnT23yNxWLxdGz7J9y8eRNKSkpgs9m4efPmN9/LVDLZ0dER8+bNY6yb4O+iqKiI+Ph4Lt3Dhw8fwsjIiMicb8uWLTh+/DhkZGSQk5MDRUVFPHv2DBUVFTAzM4O9vT3jMYGm6jYrKytoaWlxJN4OHTqEw4cPM24kZmJigrt376KhoQEiIiJc9z+mvreCZvLkyQgJCYGioiKcnJxQUVGBPXv2oKCgAMbGxt/caPo7tDRF+h4kni0mJibffJ1EVfuECRNw9OhRLndlflBTU4NOnTrh69evuHz5Mvr3748xY8YQ2bDLy8uDmZkZevbsybMLqrGxEaampnB2doahoeE/jiMvL4+kpCR6zlxbWwt5eXl069YNzs7ORMy02uL9+/dgs9l8kQQShO5te6vpfxw2m423b99yJYdev35N3wQaGhq4+vx/lIyMDBQWFvJs5yLVOsdvBHFu379/j3379uHRo0c8zy0JDRBlZWUcPXoUUVFRuHLlCl1l5+HhgZEjRyI3NxcbN25k1MJZUAhiQlddXQ0LCwvk5OSAxWJhypQp8PPzw9OnTxEVFUWkZeXOnTs4dOgQx0SgY8eOWLlyJRYsWMB4vGY+ffoEW1tbXL58mUOYX0tLC1u3bv1hV9zWDBo0CKdPn0ZKSgoKCwvBZrOxaNEizJkzh8sRjilcXV1RVlYGOzs7vulzJScnw9nZmXhLWctk2tq1ayEmJsbV0lVfX4/8/HzGYp4/f57W8ODn9ent7c33VpVmli9fDgBYvXo1X0XU7ezsYGhoiGnTpkFCQgIsFgvFxcXo2bMnsWTU0KFD8ejRI67E27Nnz4hprTx48IBulWlGWFgYq1evhr6+PpGYQNN36luJE6a5cOEC48fkRctk2vjx41FUVIRPnz7RraYRERFQU1Pj+h3/CIJuB2pu5Wq98KquriamTXju3Dls27YNWlpamDVrFjw8PDBo0CDY2try3ORhCgsLC7i5ueHVq1egKArXrl1DbGws7QLMNBMmTBCIrAG/+fz5M73pePXqVdrYpUuXLhyJ+R9l+vTp332WkXy2CEIuwtLSEk5OTnx1AG5tHta5c2fMnDkTr169wsSJExk3DwOatAlTU1M5uqAMDAw4uqD27dv3w11QNTU1HPc1YWFhdO7cGba2tsSSbt7e3rC2tuaaR7elW/z+/XsEBwczKrUkCN3b9sTbf5zff/8dLi4u2LJlC+Tl5UFRFO14MmPGDHz+/BmhoaG0RhkTeHp64tChQxAVFeVaSJPUrOI3gji3GzZswL179zBlyhS+OiGNGjWqTQ2uMWPGMPozCpLmhV51dTWePHkCISEhDBo0iOjOSkBAAFgsFs6ePYu5c+cCADZu3Ag7Ozv4+voiICCA8ZhtaZ9VV1dzLEaZxtPTE8XFxdi3bx9dPXn79m14eHggICCAFiFnku7du2PhwoWMH7ctBCEMLQgR9RkzZiAzM5OrteDFixcwMTFhzFW5ZfIlODiYpyvk+/fv4eTkhJCQEEZiAuBIwHh4eGDJkiV82z0XlIi6mJgYUlJSkJycjEePHoGiKMybNw9z5sxhNIncspJDW1sbLi4uePPmDYe2kr+/P6ytrRmL2RJBJPsAwSVO+FlNffnyZaxZswbm5uZ04i01NRW7du3C/v37ibWD8xt7e3u4ubnBwcEB48ePB5vNRm5uLtzc3GhXzmaYWuS/f/8eCgoKAABJSUnk5+dj2LBhWLFiBWxsbBhdcLbEwMAA9fX1CA0NxdevX+Hi4gIRERHY2tpi0aJFjMcTxBqh+Xf36NEj1NbWcr1OIiE1fPhwpKenQ1xcHC9fvsTUqVMBAPHx8Yxq7QrCFKklbVXuNRvRiYmJoX///ozG9PPzo2OT3LwSpHlYM7/88gvWrl2L2tpaCAkJccQaPnw4UcMXJmWNWvPrr79CW1sbWlpamD17NpcERjP5+flISEjAmTNnGDVNAwSje9ueePuP4+joiI0bN8Lc3JzjYtTU1ISTkxOuXr2KW7duMZq1PXnyJNzc3Pi62BUEgji3WVlZ2Lt3L9+1fzIyMhAeHo4nT54gLi4OCQkJGDx4MF/Li/kBRVHw9fXFoUOHUF9fD4qiICwsjIULF2LTpk1EHp4XL16Ev78/h5DusGHD4OrqipUrVzIeD2iqYgwNDaUnJwDw7t07bN++HRMnTiQSE2iqWAoJCeHQylNTU0OnTp3wxx9/MJJ4+zs78CSqJvglDN0Sfomox8TEICIiAkDTtWJgYMBV8VZVVcXobnJ2djZKSkoANOmKyMjIcCXeioqKcPXqVcZitiYpKYmuRuAHghJRB5qc2I2MjIjGMDEx4WoZ5uX26ebm9kPtMS0RdLIP4H/iRBDV1Dt27MCyZcuwdu1aeuzYsWPYsWMH/Pz8EBsby3hMQdAsq2FlZcW1sPfx8YGvry/ji3xRUVFUVFRgwIABGDx4MAoLCwE0PXPevn3LSIy24JcLcDMPHz5EdHQ0iouLERgYiHPnzmHEiBHEKuGcnZ3RqVMnODo6ciVOSLF27VpYW1ujrq4Os2fPhoSEBLZu3YqYmBhGN5EEXT1oZmZGb/S27HRoyfjx47Fr1y7GqkX5tXklSPOwZo4cOYKwsDC8fPkSZ86cQVhYGPr168eXBDbT3XItMTU1xbRp0xASEgJDQ0P07t0bkpKS6NOnDyiKQmVlJR48eIBPnz5BW1sbhw8fZnxztFu3bjwT8bzGmKI98cYwGRkZCAsLQ3FxMV8SGJ07d0ZQUBBKSkrw4MEDdOzYEVJSUvj1118BAFOnTkVGRgajMdlstkAXDvxCEOe2f//+fF/UZ2ZmwsrKCtra2rh79y4aGxvR0NCATZs2oaGhAQYGBsRi85p8DR8+nFhyaN++fUhISIC9vT3GjRuHxsZG3Lp1CyEhIejfvz+WLVvGeMzKykqezsbdu3fHly9fGI8HNLnjmpqaYvLkyaipqcGqVatQWlqKXr16EZ0gdOzYkWfljKioKGMVHy9evPhL72u2fWcaExMTBAQEEBeGbsmYMWPg6+uLa9euERVR19fXx7t370BRFC2o2/p+1K1bN0Ydq1ksFp2QZbFYPBM0Xbt2hYWFBWMxW6OmpoZDhw7BysqKL7oi30sek2qzKykpgZ+fX5tSBky1+gqipV8Qyb7W8DtxIohq6idPniAwMJBrfN68eQKr5CSBIH4WVVVVuLq6YuvWrVBSUoKXlxdmzpyJ1NRUIknUljx+/BiFhYU8F5xMr1/y8vKwaNEiKCgo0KYnDx48gLe3N4KDgzFt2jRG4wFN2qzHjh0jotnUFqqqqsjIyMCrV69ofWEtLS0sWLCA0SolQW9Gbtu2DTt27MDmzZvpitfm7qBFixZBXl4e27Ztg5+fH9zd3RmJ2XINWltby7iMSTOtHe1DQkKItZrz4uTJk/D398eSJUsQFhYGoKnKzc/PD506dWK0AiwiIgJdunSh/11fX48DBw5wmaUxmfAbNGgQtm3bhvXr1yM9PR05OTl4+/YtWCwWBg8ejDlz5mDatGnETB0mTpwIX19fLt1bPz8/YuvQdnMFBsnMzMTKlSuhra2N1NRUpKSk4NixY9i/fz88PDyIJjDevn3L0+2ORJ97aGgoiouL4enpSexm92+Cn+f24sWL2LNnD2xtbfHrr79yVZuQiGloaAgNDQ2YmZlxCOuGh4cjMTERp06dYjwm0DT5MjIygry8PO7cuYPTp09j7969SExMJDb5mj59Ov744w9oa2tzjJ88eRK7du0i4hpmbGwMFRUVrFixguP8urq64tGjRzh8+DDjMQHgy5cvSElJQX5+PiiKwsiRIzF37lyiiYV9+/YhIyMDgYGBdKt0dXU17O3tISkpiXXr1hGL3Ux+fj6OHDmClJQUIgLYghCG5peIekuCg4NhYWHBMREjjbS0NK5cucLXNnsAWLRoEe7cuQMWiwURERGuigimz29rMer6+nqUlJTg06dP0NLSgpeXF6Pxmlm0aBHevHkDTU1NnlUf/G4B+/r1K2NajKWlpfTfm6svKisr0adPH7BYLI5nKal2U1dXV+Tm5mLr1q0oKSmBl5cXgoKCkJqaigsXLuDMmTOMxps2bRr8/f2hpKTE8WzJycnBypUrce3aNUbjAU33Int7e/z+++8c4xcuXICbmxvjm5FAk2uivr4+X5MmLSG5sP/8+TO6du0KAPj48SPs7e0xZcoUGBkZYcWKFbh06RLYbDZ8fHy45i1MsW/fvjaTtCR0wczMzCAvLw9bW1uO762Pjw9u3ryJhIQERuMBTfOwZcuWQU1NjfFj/xPKysoYm89/z9ygJST02GbOnAkXFxcuOYxr167B1dUVaWlpuHPnDqytrXHlyhXG4h45cgT79+9HeXk53yvB6uvrUVBQABEREaJJcT09PZiamkJPT4/jWklMTERoaChja5ZvzTFbQmq+KSjKy8thaGiIDx8+8NS9bdmpxBTtFW8MsmvXLvzxxx8wMzOjJ1i2trbo2bMnIiMjiSTe7t69C3t7ezx//pxjnKSQpqamJhYuXIixY8eiX79+XCXFP8tFKYhzCwCPHj3iansiGbOgoAC+vr5c47NmzUJQUBDj8Zrx8/PD0qVL6ckX0FSh0KNHD2KJt4qKCp56dfLy8nj58iXj8QBg/fr1WLp0Ke7cuUPrqDx+/Bj5+fkIDw9nNFZlZSUiIiKwbt06dOnSBVFRUXRV3aVLl/DgwQN4eHgwGrMl6enpyM3NxYwZMyAhIQE2m42nT5/i06dPePDgAU6cOEG/l8n7RE1NDVJSUhAbG4vc3Fx06NCB0aqslghCGPpbIuqk9s6srKzw5csX5OTk8Nx4aNlOzBQPHz5k/Jh/hSlTpmDKlCl8i8dr8UNRFFxdXWmjCRI8ePAAMTExkJGRIRajNR8+fEBoaCiH0ydFUairq8OjR4+QnZ3NSJyBAweCoiiEh4fj4MGDeP36Nf2aqKgojI2NYWlpybWZxSR2dnawt7dHVlYWjIyMEB8fj/nz59OJE6YRRDW1np4e3NzcUFVVBTk5ObBYLOTm5mLnzp3Q09MjEjM7OxtRUVGQkZGBgYEBtLW1+VJ1wo+F/ZQpU6CtrY358+dDXl4eu3fvpl/bt28f8vPzISoqil9++YWxmK2Jjo7GmjVrsGLFCr5spufl5cHV1ZVrfNGiRcRalT08PLBy5Urcu3eP56Y2ia6kFy9ewMfHh+veV1tbi8rKSsZMigRhbtCSN2/e8EwiNhuUAE3dPB8/fmQsJj8rwZKSknDgwAEEBwdjwIABKCoqgqWlJV6+fAkWiwU9PT24u7sT0U8uLi7mqZs5btw4+twyAb+Mev4NJCYmQlNTE507d+ab7m1L2hNvDCKIBIanpyd69eqF4OBgvrU9OTg4oGfPnpg3bx5fqyH4jSDO7datWzFx4kQsXLiQb+e2R48eePXqFVfv/KNHj7hKjJlEEJMvCQkJZGZmcv2sV65cIVJNCABKSkqIi4tDeHg4hgwZgrt372LkyJFwcnKCvLw8Y3Fev34NAwMDCAkJYfHixRAXF0dpaSkMDAzQu3dvlJWV4dixY9DV1cXYsWMZi9uSyZMnExVjbc2TJ08QGxuL5ORkfPjwASwWCwYGBli5ciXdEs4031p0Xb9+nUhMXlRUVODYsWM4evQozp07x/jx09PTsWHDBlRXV3Ml3UhtAnz58gVRUVHIzs7mmewj1f4lLCwMHR0dxgWg/w4sFgvm5uZYvHgxbG1ticQYOnQoPn/+TOTYbeHu7o7MzEwoKysjNTUV2traKCoqQn5+PtavX89orLVr1yI9PR06OjqYNGkS+vTpgw8fPuD69esIDQ3FnTt3sGfPHkZjtqRHjx58TZyMGTMGqampWLFiBcf4gQMHMHr0aMbjAU3aZ+/evYO7uzutk8pms2FiYkJMPy8+Ph7FxcVISkrC/v37sW3bNsyYMQP6+vqYMmUKEW1Wfi3sV61ahRMnTuDYsWMYMWIE5s2bBx0dHToBT+r32JK6ujrMnTuXbx0sQkJCqK6u5hovKysjNu/9888/8ezZM47rsxkWi0Uk8dZsNqWpqYnw8HCYm5ujuLgYZ8+eZazlkhf19fWoqKjgSvbl5OQQ+TllZWURFhYGT09POvnU0NCAsLAwusX25s2bjM7JIiIi4OTkBD09PVqX1tTUFD169EBoaChj1+eZM2fg6OgILS0tujrbwcEB1dXV2Lt3L7p16wYnJyccOHCAiE6sqKgonjx5wlV5dfv2baLJ+J8ZJycneHl5QVtbG/PmzcOYMWOI695yQLXDGCoqKtTNmzcpiqIoBQUF6vnz5xRFUdT58+cpFRUVIjFlZWWp/Px8IsduizFjxlAPHjzga0xBIIhzKycnR39v+IWvry+lo6ND5eXlUYqKitSDBw+o9PR0Sk1Njdq6dSuxuBMnTqTu3btHURTn9XLt2jVq0qRJRGImJiZSY8aMoXx9falz585R58+fp3x8fCg5OTnq4MGDRGLyC3d3d2rhwoXUly9f6LGW55WiKMrc3JzasGGDID4eY9TV1VEpKSmUiYkJJS0tTY0ZM4aysrKiUlJSKBkZGerRo0d8/TwfPnygIiMjqd9//52SlpYmHu/69euUjY0NJSsrS0lJSVHz588nEkdbW5tauXIl9eDBA+rFixdcf0hgb29PjRkzhlqzZg3l4ODA9YcUY8eOpZ4+fUrs+H+VW7duUQoKCsSOf+fOHUpHR4c6duwYdf36dermzZscf0gwfvx4Kj09naKopu9U89zB2dmZ0XtRYmIi9dtvv7U5N3nw4AE1fvx46tixY4zF5MX79++pnJwcrnNL4vxmZ2dTcnJy1IoVKyhZWVnK0dGRmj9/PiUjI0Ndv36d8Xgtqa6upnJzc6kHDx5wPHP4wY0bNygPDw9KQUGBUlVVpQIDA6ny8nJGY+jq6lLHjx+nKIrzOXr8+HFq5syZjMaiKIrKycmh3N3dqYkTJ1KysrLU2rVrqStXrjAehxeenp6Ur68vX2JRVNO1v2TJEqqyspI+t48fP6Zmz55NOTo6Eok5ceJEavfu3Xz9ro4dO5a+7nV1damcnByKoigqICCAWr16NZGYV69epaZMmUJJS0tz/SH1bMnNzaXGjh1LTZs2jbK2tqbWrFlDqampUWPHjqXu3LlDZWdnUzIyMtSRI0cYiykvL09fky2vz+fPn1NjxoxhLM7ixYup4OBg+t8FBQWUlJQUFRgYSI+dPn2amj17NmMxW7Jv3z5q2rRp1JkzZygFBQUqPT2diomJocaPH0/t3r2bSMyfnVevXlH79u2jZs+eTUlJSVFz5syhDh48SL1//54v8dsr3hhkzpw58PLygpeXF1gsFj59+oSMjAx4eHhAS0uLSExxcXGiNvW8GDRoEFHHj38Lgji3CgoKKCgoINJX3hY2NjYoLy+nW6H19PRAURTU1NSIVV4AgLq6Ovz9/bFjxw56rKioCF5eXsR0OHR1dfH+/XuEhYXRbZ4iIiJYu3YtMetoADh9+jSio6NRWFiIjh07YvTo0bC0tISysjJjMS5duoTNmzd/UzNp8eLFPAXHmSQjIwOFhYVc4u0sFgtr1qz54eOrqamhuroaEydOxNatW6Gurk7r1m3YsOGHj/9XycnJwZEjR/Dnn3/i69evGDJkCDZv3kwk1sePH3H8+HHExcWhuLgYQJNz7YoVK3i2ITDBs2fPsHPnTowYMYLI8Xlx9uxZ+Pj4QFNTk28xgaZW8wsXLvDN2TQ4OJhr7OPHj0hJSSHa8vro0SM8fvwYTk5OXK+RqmL89OkTJCUlATRVDD18+BDS0tIwNjbG8uXLGYsTFxeHtWvX0hUWrZGWlsbatWuRkJBATG83KSkJrq6uqK2t5UuVaHM1dUREBNFq6rKyMoiLi4PFYqGsrIwebxa8rqyspMdIVY43c+/ePaSlpdHaRr/99huys7MRHh4ODw8P2mTiR+FXi1czcnJykJOTg6OjI9LT05GUlISVK1eiX79+0NfXh4GBAcTFxRmPCwDLli3D3LlzkZqail9//ZWrgpDpSmN7e3ssW7YMkydPBkVR0NfXR3V1NaSlpbFx40ZGYzVTU1ODOXPmMKYp+VdjNld5DRs2DAUFBZCTk4Ouru7f0mX7OwQEBEBWVhYmJiawsrKCn58fysrKEBQURMy0R1ZWFqmpqYiNjUV+fj7YbDYMDAxgZGSEvn37oqioCPv27WO0G4JflWAPHz6Em5sb/e9r166BxWJxSOGMGjWKS5KIKSwtLfHx40ds2LABNTU1WLFiBdhsNgwNDbkqndv5a/zyyy+wtLSEpaUl8vLykJSUhN27d2P79u1QV1fH/PnziRkrAO2tpowiiATG6tWr4e3tDTc3NwwbNozL7Y4ELi4u2LJlC9atW4ehQ4dy2Q2TnnjxC0Gc2wULFsDFxQV37tyBhIQEV0wSZeJCQkLw9/fH2rVr8eDBAzQ2NkJSUpL4glsQky+gSdjXzMwMlZWVoCgKIiIixGIBwLFjx+Di4gINDQ1oaWmhsbERt2/fxooVKxAYGAh1dXVG4pSXl9ML3GYmTJjAMdGUkpLCmzdvGInHC09PTxw6dAiioqJcbStMJd4+fvxIC9p269aNL9dlM58/f8aJEycQGxuLgoIC2kXR3d0d8+fPZ7zl6d69ezhy5AhOnz6Nr1+/YvTo0Vi/fj127twJe3t7oteohIQEx4KaH3To0IEvrVWt6dq1K3x9fbFnzx5ISEhwGQ8wvfA8fvw415iQkBBUVFQYb79sSXBwMAwMDGBqasq3BWhzy7u4uDgkJCRoHb8uXbrgw4cPjMV5/Pjxd5OWKioq2LlzJ2MxW7Nz507o6OjAzMyMp3kF0yQlJUFLS4tL4uTz58+IioqCmZkZI3GmT5+OzMxMiIiIYPr06TzvcxRBHdqXL18iOTkZycnJKC4uhry8PKysrKClpUVvuuzatQve3t6MJd4E1eLFZrOhrq4OdXV1fPjwAX/++Sfi4uIQGhqK+/fvE4np7OwMoGkDgh8SJ927d0dsbCyuXbuG/Px8es6poqJCTINx9uzZSElJ4WuyYtCgQSgsLKTvfc3XRmNjIzHX9YKCAhw9ehRSUlIYPXo0unbtChMTE3Tt2hXh4eGMzTdb88svv2Dt2rU8Xxs+fDijLq4AsHDhQri5udGO6E+ePMHly5cRGBjI2H0PaGrDbjmXzc7ORvfu3SErK0uP1dfXE52Hrl+/HqtWrcLjx49BURSGDRvGF/d1QcBPM0OgKWksKysLBwcHpKen48SJE1i+fDl++eUXzJs3DytXrmQ8ZnvijUGaExjr1q3jeJiQXBwFBQXh9evXbSZkSEyCzM3N0dDQgBUrVnBMwEhOvASBIM7tH3/8AQA8RfdJ6VA0M2TIEAwZMoTY8VvDr8lX8+JEWFgYSUlJ33wvifO7f/9+bNy4kWMyYGZmhrCwMAQFBTE2EerevTvXZK61ntHHjx+J6vadPHkSbm5uWLhwIbEYmZmZSE1NRUJCAmJjY9G1a1dMnz4dmpqaRLR+gKZdz9jYWJw4cQKfP3+GgoICNm3aBA0NDaipqUFJSYnx2Pr6+njw4AFGjBiBZcuWQVtbG0OHDgUAosmDZjZs2AAPDw/Y2tpi2LBhXIlUEhOhWbNmITExETY2Nowf+1t0796d6L21NYISMv7w4QMsLS2J6R/yQkNDAxs3boSvry8mTpwIGxsbKCgo4Ny5c4w+b+rr6/+SuDWpewTQdH7Nzc0hISFBLEZlZSW+fv0KAHB0dMTIkSO5DDny8/MREBDA2AI0ICCAfm6Q0ln8FtOnT4eIiAjmzJmD4OBgnov40aNHM3re+bWwb4vKykqkpqbi9OnTKCgogJKSErFYN2/eRFRUFG1yRRpTU1MEBwdj0qRJmDRpEj1eUVEBCwuL787T/gkiIiIICQnB2bNneRYMkKgG09fXx8aNG7Ft2zaoqqrCxMQEAwYMQGZmJqSkpBiPBwAdO3akkzISEhIoLCzEpEmTMHHiRCIGL0CT629cXByHiUTzeG5uLmPOmy3hVyXY0KFDkZeXh0GDBuHr16+4evUqJk+ezPEcuXjxIqP3npZVxS1pLhKoqqpCVVUVgJ+n0EVQZobNtNzwyM/Ph4uLCwIDA9sTb/8Fvn79CjExMQwePBhFRUVIT09HVVUVsYcmKTHbbxEZGcn3mIJAEOeWX65+0tLSf3kBQvqG1zz5qqysxM2bN1FWVsbowtDBwQEqKioQERGhJ9G8IJXYLC8v59k6O3PmTOzatYuxOCNGjMDly5e/ubOYkZFBtKKIzWZj/PjxxI4PNCVJFixYgAULFqCoqAjHjh3DyZMncerUKbBYLERFRWHZsmWMToR0dXUxbNgwWFtbY9asWRg4cCBjx26L/Px8DBs2DHPnzsWUKVPopBu/aG4DXL16Nd82WHr27ImIiAhkZGTwTPaRapUhddzvcfnyZRQUFIDNZmPkyJGYOHEiEWe0ZqZOnYrr169j3rx5xGK0xtraGl+/fsXLly8xZ84caGpqwsbGBj169GDUdGrEiBG4evUql3FOS753f/xRZs2ahYyMDKKJt0uXLsHBwYGutuX1u6QoCqqqqozF3LJlCxQUFDBgwAAkJibCycmJrxUXu3btwrRp0ziujZqaGo6qwhkzZmDGjBmMxRREi9eXL19w7tw5nDx5ElevXkWfPn2gp6cHb29vopuioqKi6NatG7HjA01zj9zcXADArVu3sGfPHnTt2pXjPc+ePUNpaSmR+FlZWXT7NYlWYV4sW7YMbDYbLBYLcnJysLKyQmhoKMTFxbF9+3YiMaWlpXH27FmYmZlh6NChyM7OxpIlS4j+zN7e3jh+/DhkZGSQk5MDRUVFPHv2DBUVFUST1PyoBDMwMICXlxdevXqF69evo7q6GosWLQLQVA13/vx5hIaGMrpZ2FZVMS+Ymofxkr9oCyZdnZsRhJlhS968eYOUlBScOHECDx48gKKiIry8vIjEYlGt6/na+cfcunULa9asQWBgIEaMGAENDQ2wWCx8/vwZ/v7+fNetYZIvX7787RL0f/J//hfJz8//28mQvLw8jlLnv8vx48fpG3tZWRn27duHhQsXQlFREUJCQrh37x4OHz6MVatWwcLC4h/H+RaFhYWwtraGp6cnpKWloaWlhTdv3kBYWBj79u0j2mPPT1auXAk5OTmsXr2aYzwmJgZnz55FVFQUI3GOHz8OHx8fREdH89Q5KigowOLFi+Hl5YXff/+dkZitCQ0NRXFxMTw9PfnmkAY0OWilp6cjMTER6enpaGxsxOTJk2k3uh/F0NAQd+/exbBhwzBlyhT8/vvvtP6PjIwMkpOTGa9sfvbsGY4fP46kpCS8fv0av/76K7S0tKCpqQkDAwMiMVty8+bNb75OIsH6Pd2bgwcPMhZLkJWwVVVVMDc3R15eHnr27InGxkZUV1dDRkYGkZGR6NmzJ6Pxmjl06BD8/f0xdepUnlUfJCbUvHj//j169OjBaJLx8OHDCAkJQWxsLE+N1MePH8PExAQbN26Enp4eY3Fb8vbtW2hra2PEiBEYNGgQ1+KJqQTvrVu30NjYiCVLlmDXrl0cVcwsFgtdu3aFpKQkY+1PioqK2LFjB9TU1DBq1ChkZmbS+m784MuXL3B1dcXQoUOxatUqAICqqipUVFTg4uJC9Fnz5csXogv7hoYGXLlyBSdPnsT58+dRV1cHVVVVzJs3D6qqqsRaL1vSrM/l6uoKCQkJIsn/x48fY8WKFaAoCmVlZRATE+P42Zq/t6amppg/fz7j8QXBrVu3oKCgwHUd1tTUID09ncg87MKFC7CysoKzszOmTZuG33//HRMnTkRBQQHk5eUZ3exoRllZGZs2bYKWlhZmzZqFPXv2YNCgQbC1tYWYmBjdysw01dXVSE1NRWFhITp06AAZGRloaGgw3uYfGBiII0eOoEOHDli+fDmdTHR3d8fhw4eho6ODrVu3Mnattpx7FRQUIDg4GKtXr+ZYn4WEhGD16tUwNDRkJOb06dM5/v3y5UsICQlh0KBBYLPZeP78Oerq6iArK4vY2FhGYrZkzJgxiI+Px6hRoxg/dltUV1fj7NmzOHnyJG7cuIE+ffpAR0cH8+bNI7rR3Z54Y5BFixZBQkICTk5OSEhIQHh4ONLS0pCQkICjR48yVj49f/582NnZYcKECX/p/VevXkVAQACOHTv2j2NqaWlh2bJl0NXV/e7Npa6uDklJSYiIiMDp06f/cUxBIIhzu3DhQkhISMDCwoJLo6s19+/fR2RkJJ4/f474+Ph/HLMlJiYm9M2mJSdOnEB0dDQSEhIYidMaCwsLdOzYEVu3bsX58+cREBCA5ORkHD58GDdu3CByczc1NUVISAjXjgrJFoe9e/di9+7dUFZWxm+//QYhISHk5ubi1KlT0NPTQ//+/en3/ujCd+XKlbhy5Qp0dXUxadIk9O3bF+/evcOtW7eQlJSEadOmISAg4Ed/pDZ5+vQpFi5ciM+fP6Nfv35cC8/z588Ti91MZWUlkpOTcfz4cZw8eZKx4z59+hTHjh3DiRMn8ObNG/zyyy/Q0NDAoUOHcOLECWKVNI2Njbh8+TISEhJw8eJF1NfXAwBWrVqFpUuX8n13sLy8HPHx8W3quZDi06dPjFZlSEtL07pVbQnyA2RE8Z2cnHDv3j34+/vT9/yHDx9iw4YNUFJS4hBzZpLWk+uWsFgsxq5PQSQ1GxsbsXLlSty5cwf6+vpQVFRE7969UV1djRs3buDYsWNQUVEhsvBs5o8//sCZM2cwatQonhp6TCaOAWDfvn2YM2cOMdH9Zv744w+kpKT8pSoMEpWwLi4uuHHjBry8vOgNj7Nnz8LPzw/Tp0+Hvb094zGB/0u61dTUcGkO/fbbb4zEmDRpEt6/fw8JCQkYGBhAT0+PuO5sa2bNmoWysjKONsGWMP07VVNTQ2JiIleLNGmaNVpbVhm31AlkmraS1Pn5+TA0NMS9e/eIxL1//z46duwIaWlp3Lp1CxERERAXF8fatWvRu3dvxuPJysoiLS0NAwYMgJWVFTQ0NDB79mzk5ubCxsaGyLyvqKgIS5YswadPnyAhIYHGxkY8e/YM/fv3R3R0NMTExBiP2ZqCggIAINY2DDS1K69atQozZ87kGL948SJ8fX2JrLGjo6Nx8eJF+Pv7c7S3bty4EZKSkkR0aGfNmgU/Pz/IyckxfuzWnD9/HidPnkR6ejrq6uqgoqKCefPmcVVVk6I98cYg8vLyOHXqFAYNGgRLS0uIi4vD3d0dpaWl0NTUZOwme//+fTg6OoLNZkNbWxvTpk3D0KFDOSZFDx8+xPXr15GQkICGhgZs27bth77Q5eXl2Lx5M/Lz8/H7779j2rRpkJSURN++fUFRFCorK5GXl4fr168jJSUFo0aNgqen53+u/1wQ57axsRFhYWHYt28fxMTEOM5tY2MjKisrcf/+fVy/fh0vX76EhYUFXcLOBPLy8jhx4gRXK8PTp0+ho6ODnJwcRuK0RklJCUePHsXw4cNhbW2Nrl27wsfHByUlJZgzZw7u3r3LSJyWLQ7BwcEwNzfn2eKQnp6OW7duMRKzJd9a7LaEiYVvY2MjIiIicPjwYQ6diH79+sHExASWlpZENY4MDQ1RUVGBWbNm8ax25VdFDUkaGxtx6dIlHD9+HBcvXkRdXR0kJSVhYmKCuXPnEhVV//DhA5KTk5GYmIgHDx6gS5cumDt3LrFETUsuXbqE2NhYZGRkgKIo5OfnE48JNC36jhw5gpSUFGRnZzN+/C9fvqBTp04cG0qFhYX49ddfue4TTDFx4kTs2rWLa/F+8+ZN2NraIjMzk0jcllRWVuLWrVsQFRXF2LFjGT22oJKaDQ0NCA0NRUxMDN69e0ePi4qKYsmSJbCwsCBaQaSoqIidO3cy2ub5LcaNG4eEhATi2qx1dXW4dOkSqqqq4OjoiE2bNrWZ8CdRTThlyhSEhIRAQUGBYzwrKwu2tra4fPky4zEzMjJgY2ODr1+/EnWodXR0xLx58xi/Bv8OiYmJ33yd6d+pvr4+vL29v3lvYJqXL1/C2NgYFRUVGDp0KBoaGvDs2TOIiIjg8OHDjCVqoqKiaC21ZlkGXsjJySEuLo6RmIJGTU0Nu3btwpgxY+Dr6ws2m43169fjxYsX0NbWJrKGWLp0KdhsNvz8/OiK38rKStjZ2aFr165/q3Xy34y8vDySkpK4KrCKiopgYGDA2DqpJVOmTEF4eDjX9VlYWAgTExPcuHGD8ZhJSUmIjY3li5mhtLQ0hgwZAgMDA+jq6hI1y+FFu8Ybg3Tp0gW1tbWora1FVlYWvL29ATS1HzBZlSAjI4Pjx48jOTkZkZGR2L59O4SFhdGrVy9QFIX379+joaEBI0eOxJIlS6Cnp/fDWVwxMTHs378f169fR2RkJFavXk1XXjQjLCyMyZMnIyAggEMw9b+EIM5tc/mykZERYmNjcf78eURGRtLnV1hYGHJyctDX14e+vj7jbUiDBw/GqVOnuBwn4+LiiLaydejQAcLCwmhoaMD169fh5OQEoKmyhUnHvYEDB8Ld3Z2eBKWmpvJscSDlpMpPIfUOHTpg2bJlWLZsGUpKSlBRUYE+ffpg0KBBfGlZyc/PR3x8PF8n1PymQ4cOUFNTg5qaGt69e4cTJ04gMTERmzdvhp+fH5FJSTO9evWCqakpTE1N8fDhQxw7dgynTp0ilnirrKzEsWPHEB8fj9LSUrDZbOjo6MDc3JxIvGZqamqQkpKC2NhY5ObmokOHDlw7vkyQlJSErVu3IiwsDGPGjKHHfXx8kJOTAw8PDyISEfX19Txb9URERFBdXc14vJCQEBw4cADx8fEYMmQI7ty5A0tLS9qMZeLEiQgNDWXsvttSq/Thw4f4/PkzPn78iJ49exKVn+jYsSOsrKxgZWWF4uJivH//Hr1798aQIUP4cv/r1q3bNzXmmEZeXh4XLlzA0qVLicZRV1dHfHw8+vfvj9LSUsyfP5+vMiKfP3/mOYfu06cPPn78SCTm9u3bMWXKFKxZs4ZY6zcgOH3JlpBqvW6L0tJSYpsabbFt2zaIi4vj6NGj9L337du3WLduHbZv3w5/f39G4hgbG6N3795obGzEpk2b4OjoyPHdbZ5vMimlImh9LlVVVbi6umLr1q1QUlKCl5cXZs6cidTUVGKVZ3fv3kV8fDxHm33fvn2xceNGGBkZEYkpCKSkpHDgwAG4uLjQSdz6+nrs3buXY87CJLW1tfj8+TPXeEVFBZF4AH/NDA8ePMhYxfI/ob3ijUHWrVuHmpoa9OrVC2lpabh8+TJKSkrg4uKCQYMGEWvxevbsGe7evYu3b9+CxWKhf//+kJOT46lzwhRfv35FXl4eR0wpKamfTtNNEOcWaNope/fuHVgsFvFy/LNnz2Lt2rUYO3YsxowZA4qicPv2bTx48AD79+8nprW2bNky9O/fH6KioggPD8elS5dQV1eHzZs3o0OHDlyOnEwwffp0HDt2jK/6NP9LaGtrY+vWrXwpF/+3cf/+fSQmJhLTM2mLuro6xncHb926hSNHjuDs2bOoq6vD8OHDUVxcjCNHjtAC1SR48uQJYmNjkZycjA8fPoDFYsHAwAArV65k3Inz2rVrsLCwgL6+PmxsbCAqKkq/9uzZM+zfvx+JiYmIjo6m29uYYsmSJRg5ciTXd8XDwwP3799ntM0+Li4OXl5eMDMzw/Lly9G9e3doaGjg8+fPiIyMRPfu3WFtbY0pU6Zg3bp1jMX99OkTIiIicOrUKQ6nsiFDhmDu3LlYunTpTzdfOHjwILKysuDl5cUX8wFra2ucO3cOPXv2hISEBFe1LVMOpHJycjh06BDk5OQEovFmbm4OUVFRbN26ld7opCgKrq6uKC4uZryFF2jSHDp16hRfnd4FycWLF7Fnzx66DXPEiBGwsLAgsuERFhaGjIwMWFhYYPDgwVwJfxKdMuPGjUNkZCRXsuLevXuwtLQksmGWmJgIbW1t4nq3vLoqysvL0a9fP47CACblBFry8eNH2NvbY8qUKTAyMsKKFStw6dIlsNls+Pj4QFtbm/GYv//+O5ydnaGiosIxnpWVBTs7O6SnpzMeUxBkZWXBwsIC/fr1w+jRo0FRFHJzc/Hly5c29Zx/FHt7e+Tl5cHFxQWysrKgKArZ2dnw8PCAmpoakTkuv6tuBUl74o1BKisr4erqipKSElhZWUFdXR3btm1DTk4OgoKC0K9fP0F/xHba4cnt27cRExODwsJCAE3aFObm5kQrl549ewZbW1uUlJTA1tYWRkZG8PDwwMWLFxEWFoZhw4YRi82Lr1+/Mlpp97/IjRs34OPjg3Xr1vEUb/+vtZ7/r3Hw4EHExsaiqKiINnPQ1taGlJQUMROJ+vp6pKWlITY2Frdu3YKQkBBUVVWhqamJjRs3IikpiUjlrbm5OUaMGIFNmza1+R4nJye8evWKMZOOZu7cuQNTU1NIS0tDSUkJLBYLWVlZePjwIfbv389oxfi8efOgr69PVwHcu3cPCxYsgJ2dHZYtWwagadG9bds2nDlzhpGY79+/h4mJCUpLSzFz5kxISkqiZ8+e+PjxI/Ly8nDhwgUMGjQIhw8fFoiDGSmWLl2KrKwsUBQFERERrvsf04teR0fHb77OVDWVhYUF3ZZcVlYGcXHxNisISSzs8/LyYGJigj59+kBGRgYsFgv379/H+/fvERERQWQzYM6cOXB1dWU86f5v5Ny5c7C2tsbMmTMxbtw4NDY24tatW7h48SJ27drFqFssAI55Jb8csydMmIBDhw5h5MiRHOMFBQUwNDTEnTt3GI8JAK9fv0Z8fDyKi4uxadMm3Lx5E5KSkkTdlYGmtvcTJ04QLxJoi/z8fIiKihJr47tw4QK8vb3h4OCA8ePHg81mIzc3F25ubpg/fz6HccV/fd754sULxMXF4dGjRwCa1meLFi0idm6rq6uxbt06ZGZm0tcnRVHQ0NCAr68vX43TfkbaE2+Eqa2tbf+StvOXKS4uhru7O7Kzs1FXV8f1OokJyb+JiooK9O7dm5jA5YcPHxAaGoqCggJaSJiiKNTV1eHRo0dENKT+l5CRkaHPK78m1O0wh7S0NIYNG4YNGzZg2rRpHK+RSrwpKyujuroaEydOhIaGBtTV1elqIVIxgab2ygMHDnzT0CYvLw/Lly/H1atXGY9/7949REZGorCwEBRFQVJSEmZmZlw6Vj+KoqIiEhMTISEhAaBJkH/Hjh04ceIEvQgtKSmBlpYWrYX5o3h4eODq1au0qHdrysvLYWlpCXV1dUar7ATN91q+/qsal1VVVUhKSkJVVRWCg4OxdOnSNo1OSP2MpaWliIuLQ2FhIdhsNoYPH47FixczuvhsqYt68eJFHDx4EE5OTjydPv/ri/mW6OnpQV1dnUtuJDg4GOnp6T9kHsYLQThmr1q1Cp07d4avry9dIV5XV4cNGzagqqoKERERjMd89uwZFixYgO7du+PVq1c4ffo0tm/fjsuXLyM8PBxKSkqMx2yGdOLt1q1bUFRUBJvN/q42Mom2vm8lb5vH2uedP0ZxcTFdjDF69GjGv0uOjo5wcnJC9+7dv7mJxGKxaOmun4F2jTeGqaysRHFxMRobGwE03QRqa2uRk5PD9VBrp53WbNmyBWVlZbCzs/upKgHaor6+HhUVFRxJsOfPnyMnJ4cxt7uWuLu7IzMzE8rKykhNTYW2tjaKioqQn59PxKnnf43IyEhBf4R2foAVK1YgOTkZq1evxsiRI6GhoQEtLS06aUOCjx8/QkREBGJiYujWrRtRUd2W1NbWfrfCtVevXvj69SuR+HJyctixYweRY7em5cIkOzsbffv25aj8+PTpE6NtnxcuXICLi0ubbptiYmJYt24dduzY8VMl3gSRWONHRU3Pnj1hamoKoCkBtmbNGr600rZk4MCBxJ/R06dP51rEtzYk+hkX80VFRdi5cyfX+OzZs7F//37G47VMrPGrOMHOzg6GhoaYOXMmZGVlwWKxcO/ePVRXVxNpVQaadOXU1dXh6elJJ9l27NgBBwcHBAQE4NChQ0Ti8gMTExPaQMfExIROdLWG1LXCVBv93yUjIwNhYWEoLi5GXFwcEhISMHjwYCLrFUHz9u1bvHv3DrNnz0Z5eTnjsiYvXrygcyUvXrxg7Lh/h5s3b0JRUZFv806gPfHGKCkpKdi0aRNqamo4su1A06ShPfHWzve4c+cOoqOjoaioKOiPQpxr165hw4YNPAU7O3fuTORBduXKFfj6+kJVVRUPHz6EhYUFpKWlsXnzZjx+/JjxeP9rFBYWYvbs2UQs6/9t1NbW4sWLFxg8eDAoiiL+4H748CGio6NRXFyMwMBAnDt3DsOHD2dUg9HW1hY2Nja4fPkyjh8/jj179mDXrl2QlpYGRVG0GD+TZGZmIjU1FQkJCYiNjUXXrl0xffp0aGpqEnXgHTp0KO7cufNNMfzbt29j4MCBjMV8/fo1goODsXr1ag7RaVdXV9TV1eGPP/6AiIgIY/GAJnHmW7duYciQIaiqqsKNGzc42nAA4PTp09+s/Pu7vH379rvHk5aWxsuXLxmL+W/h/v37CA8P59DKWrJkCRHdy9YVNTY2Njh9+jQ2bdpErKLG2toaVVVVqKqq4vk6iUqwxsZGnDp1iu4EaL3AZ6qlVhCL+eaE5l+B1Of75Zdf8PTpU57O9qQ2gI8cOYL9+/ejvLwcZ86cQVhYGPr160cseT18+HAkJycjJiYGjx49AkVRmD17NgwNDYlVhd25cweHDh3ieI517NgRK1euxIIFC4jE5Bfnz5+n9adJtJd/DxJVkd8jMzMTVlZWtFNrY2MjGhoasGnTJjQ0NMDAwIDvn4kE1dXVsLCwQE5ODlgsFqZMmQI/Pz88ffoUUVFRjBlmtEx4k0p+f4+1a9ciPDwcMjIyfIvZnnhjkD179mD27NmwtLTEggULEBERgdevX8PNzQ3W1taC/njt/Afo06dPmy0cPxsBAQGQlZWFiYkJrKys4Ofnh7KyMgQFBRFz+vr06RO9IBw+fDgePnwIaWlpGBsbY/ny5YzF+TdMpgXB/v374evri2nTpsHAwAAqKipEkyeCgKIo+Pv74+DBg6irq8OZM2ewY8cOdOrUCe7u7kQScHl5eTAyMoK8vDzy8vJQW1uLBw8ewNvbG8HBwVxtoT8Ci8XC1KlTMXXqVHz48AEnT57E8ePH0djYCGNjY2hoaMDY2JgxXaXu3btjwYIFWLBgAYqKinDs2DGcPHkSp06dAovFQlRUFJYtW8Z41d3cuXMRFBSESZMm8WxXe/36NQIDAxmbTL9+/RqGhob4+vUrFi5cyDF5HTJkCCIjI5GdnY0jR44wKly/ePFiuLi4oKCgAHfu3EFtbS1MTEzoz3Ty5EmEh4fDy8uLsZh1dXXfrSbs3Lkzvnz5wljMfwNZWVlYunQpJCUloaysjIaGBty+fRtGRkaIjo7G2LFjGY0niIqa1lVhrSFR3eLj44MDBw5AWlqaaKVdW4v5yspKsNlsIu6mTCb2/ymzZ8+Gm5sbXF1d6e9odnY23N3doaGhwXi8kydPwt/fH0uWLKH1M4cPHw4/Pz906tQJlpaWjMdctWoV7OzssGHDBsaP3RYNDQ10RU9Lqquricmp8IuW39t/w3eYH+zatQt//PEHzMzMaD1UW1tb9OzZE5GRkT9N4i0gIAAsFgtnz57F3LlzAQAbN26EnZ0dfH19iRlF1tTU4OTJk3j06BGEhYUhKSkJTU1NLq1UJhERESHmjN0W7Yk3Bnn69CkCAwMhISGBUaNGobKyEtOnT0d9fT327NkDHR0dInFLS0uRk5OD2tpartdIlb9mZ2e3ufv4X9Ux4QW/z62JiQkCAgKwffv2n77VtKCgAEePHoWUlBRGjx6Nrl27wsTEBF27dkV4eDjU1dUZjykuLo7S0lKIi4tDQkICDx8+BAB06dIFHz58YCzO/8pEpDXp6enIzMxEUlIS1q5dix49ekBXVxd6enp8N8sgxcGDB5GcnAxXV1e4u7sDANTV1eHm5gYRERHY2dkxHtPPzw9Lly6Fra0tXQ3r6emJHj16MJ54a0mvXr1gbGwMY2NjPHz4EMeOHUNKSgpOnTpFZIE9fPhw2Nvb065kiYmJSEpKwvHjxzF58mRGTQ6MjY2RlpYGbW1tzJs3DwoKCujZsyfev3+Pu3fv4vjx4xgyZAgsLCwYibdnzx706dMHUVFRXPd2c3Nz6OrqYsmSJdizZ883DR/+LnPmzEFNTQ2OHDmCDh06YOfOnZCVlQXQpPcWGxsLS0tLYvOT/yUCAgIwf/58uLi4cIy7ublh586djO/qC6KipvVGUX19PZ4+fYrIyEg4OTkRiZmcnAxnZ2csXryYyPHbIiYmBqGhoXRVvqioKCwsLGBmZsZYDFKbjH+HVatWobCwECtWrOAQU1dVVcUff/zBeLyIiAg4OTlBT0+P1lYzNTVFjx49EBoaSiTxlpWVxeX6SxplZWWEhobCz8+PHnv37h22b9/OaKV6UlIS11hjYyPOnj3LtYnD1Lrlf3FzuaCgAL6+vlzjs2bNQlBQELGYUlJSRI7dFhcvXoS/vz9HJeiwYcPg6uqKlStXEolZUlICIyMjVFdXY+jQoWhoaMCBAwewe/du7N+/n3FX+2aUlZWxYsUKqKqqYsiQIVz3CBL5jPbEG4N06tSJrnaQkJDAo0ePMHXqVMjKyuLZs2dEYiYkJMDFxYXWyGoJi8Uikhzat28fAgIC0KtXL67qLBaL9dMk3gRxbjMyMnD37l1MmDABIiIiXNoXpEq6b9++DQkJCfTt2xdJSUk4ffo0lJSUsHz5cmIVSx07dqR3ryUkJFBYWIhJkyZh4sSJ8PHxIRJTQ0MDGzduhK+vLyZOnAgbGxsoKCjg3LlzXG0WP8K/YTItCFgsFpSVlaGsrIxPnz4hLS0NaWlp0NfXh7S0NObPnw9tbe3/tHtsXFwcXFxcMHPmTHh4eAAAtLS0ICwsDC8vLyKJt7y8PLi6unKNL1q0CLGxsYzH44W0tDScnZ1hb2+PixcvEo3VsWNHzJgxAzNmzEBlZSWSk5Nx/PhxxmNERkYiKCgIR48e5dAnFBUVhZGRES3IzQQZGRl0spQXffv2hY2NDXx8fBhNvAFNzqbz5s3jGre0tMSaNWvoliEmiYiI+KZu3OfPnxmPKWju378PT09PrnFjY2Oe5/9HEURFDa+qsMmTJ2PAgAHYs2cP1NTUGI9ZU1MDFRUVxo/7LY4ePYpt27bB2NiYw+kzICAA3bt3J/L7BASjE92pUyfs3r0bRUVFtNmLlJQUMefN4uJinm6x48aNQ3l5OZGYenp68PPzw5o1azBkyBC+6Mo5ODjA1NQUkydPRk1NDVatWoXS0lL07t2b0Tmug4MDz/HWSSIm1y0tN5dramqQmpqKUaNGQUFBgXYYzc3Nxfz58xmJ92+gR48eePXqFZc8xaNHj9CrVy8iMXV0dCAjIwMDAwPMnj2bSNVtayorK9GvXz+u8e7duxOrUnd1dYWMjAxH0UllZSVsbW3h6emJPXv2EIl79uxZiIiIIC8vD3l5eRyvkcpntCfeGEROTg6xsbHYsGEDRowYgYsXL8LCwgKPHz8mpv8TGhoKfX192Nvb803s9tChQ1i1atVPJYrMC0Gc2wkTJmDChAl8idVMbGws3NzcEBERARERETg6OmLSpEmIjIxEXV0dsUSqtLQ0zp49CzMzMwwdOhTZ2dlYsmQJsYkX0KRP8/XrV7x8+RJz5syBpqYmbGxs0LNnTwQGBhKLW15ejpiYGFr3Z+TIkVi4cOFP5YzWms+fP+PDhw949+4damtr0aFDB+zduxcBAQHw8/PDpEmTBP0R/xEvXrzAqFGjuMalpKTw9u1bIjGFhIRQXV3NNV5WVsaoKP5f/SyzZs3iW7y+ffti6dKlWLp0KePHFhYWhp2dHWxsbFBSUoIPHz6gb9++GDRoEOMbDm/fvv1ucl9KSgqvXr1iNO636N+/P5HjDhgwAKdPn/7u+9oyX/iv0qdPH1RUVHBV91ZUVBBZ6POrouavMGLECOTn5xM5toqKCi5fvszXirfw8HA4OjrCyMiIHps5cyaGDBmC6OhoIok3QetE9+rVCwoKCnQXS7PLK9PzFFFRUTx58oRLW+327duMutS25Ny5cygrK6NbBFtDooK7f//+SEpKoivEGxsbsWjRIujo6DC6pmju3OAnLTeXnZ2dYWZmxpUA3LlzJ4qKivj90YgxZ84ceHl5wcvLCywWC58+fUJGRgY8PDygpaVFJGZqaiqSkpKwf/9+bNu2DTNmzIC+vj6UlZWJFUWMGTMGqampWLFiBcf4gQMHMHr0aCIxs7OzkZCQwLEx2bdvXzg4OGDRokVEYgJNRlD8pj3xxiBr1qyBhYUF+vbtC319fQQHB0NbWxsvX76EpqYmkZivX7+Gubk5Xx2mPnz48FM6uLRGEOdWENWC0dHRcHZ2xqRJkxAYGIiRI0ciIiICly5dwpYtW4h9JktLS1hZWUFYWBja2toICgrC8uXLUVBQQGzR8Oeff8LKyorendqyZQtsbGzQo0cPYhUChYWFMDY2RufOnSEnJ4eGhgYcP34cMTExOHLkCIe74H+dmpoapKWlITk5GdeuXYOoqCh0dXXh6+tL7xK6ubnBwcEBGRkZAv60/4yBAwfi3r17XKXvGRkZxESa1dXV4e/vz+GCWVRUBC8vLyIVJv9rsNlsDB06lGgMUVFRlJaWfnMRW15eTqT6jN8IYjL7b2DatGnw8PDAjh076Gqhx48fw8vLi0g7OL8qar5HdXU1oqKiiCVyx4wZA19fX1y7dg3Dhw/n2sgmMUcpKyuDsrIy17iKigqxcysonei7d+/C3t4ez58/5xgn5eC6cOFCeh4AAE+ePMHly5cRGBjIaBtvSwSls92lS5efquqLFykpKUhMTOQa19XVJbpWPHnyJH777TeIiYlh9+7dSE1NhZKSEpycnIi0FdvY2KC8vJzWctPT0wNFUVBTU4OtrS3j8YCmFs/169fD1tYW165dw8mTJ2FnZ0cb0BkYGHzTIOqfsH79eixduhR37txBfX09QkND8fjxY+Tn5yM8PJzRWM2IiYnh9evXGDFiBMf4hw8fBDInqq2txb1793hW5v4o7Yk3Bhk7dizOnDmD2tpa9OnTB4cPH8aRI0cgLi7+t/rh/w7S0tJ49uwZ8UVDS8aOHYvc3FxGW/P+jfDr3AYHB8PCwgJdunRBcHBwm+9jsVhEdjxfvHiB6dOnA2hy7Zk6dSqAph1sUhU8QJNI89GjR9GxY0eIi4sjPDwcERERmDFjBtauXUskpqenJ2RkZDjKwkk7cDa3tfr5+dFVDzU1NdiwYQP8/Pywd+9eovH5yaRJk1BfXw81NTXs3r0bKioq6NChA9d7BOGCxRQWFhZwc3PDq1evQFEUrl27htjYWBw8eBCOjo5EYtrb22PZsmWYPHkyKIqCvr4+qqurIS0tjY0bNxKJ2Q6zTJ06FVFRUfjtt9/afE9UVBTjAvzt8A8bGxssXboUs2fPRo8ePcBisVBVVQVJSUki1ym/KmpaIi0tzbPSgsVi0a33THPkyBGIiIggPz+fq6qOVDvQgAEDkJeXx7WovXfvHkRFRRmPBwhOJ9rT0xO9evVCcHAwX7SFLS0t8fHjR2zYsAE1NTVYsWIF2Gw2DA0NuapsmEJPT4/IcVvzv6h91rNnT+Tn53MZIGVlZTHu0t3M7t27sWfPHkRFReHly5cICgrC/PnzcePGDfj5+RHRmxQSEoK/vz/WrVuH/Px8NDY2Em3JbgmLxcLkyZPRu3dv9O3bFzExMYiOjkZYWBhUVFTg6urKWAW5kpIS4uLiEBERgSFDhuDu3bsYOXIknJycGDPVAv6vohZo0jd3dnbG5s2bMXbsWHTo0AH379+Hq6sr0e66/Px8ODs7o6CggKdsA4lKWBbVWhm/nX+Mo6MjnJycuCY879+/h5OTE0JCQhiP+eeff8LHxwfm5uYYNmwYVzvDtyb5/5SjR49i+/bt0NfX5xnzZ6mG49e5nT59OhISEtCnTx86AcYLFotFJGGhpqaGwMBADBw4EFOnTkV4eDgmTZqECxcuwNPT86eqXliwYAHMzMyIlYXzQlFREXFxcbSbajMPHz6EsbExsrKy+PZZSBMdHY25c+eiT58+qKysRFZWFkRFRWnHPaBJjJukSxE/iIuLQ2hoKN0WLSIigmXLlhFph2zJtWvX6AmfpKQkz8Qm09y6dQtFRUWYPXs2ysvLMWTIEGLSCT8zpaWl0NXVxZQpU7BmzRqOSteHDx8iNDQUly5dQmxsLN/FlNthhurqanTt2hWXL1/Go0ePQFEU7XBK0sXw8+fPKC4uRseOHTF06FCiIvLHjx/nSrwJCQlBQUGBmAC2IIiKikJoaCjWrVsHJSUlsFgsZGVlISgoiHZiZ5px48YhMTERgwYNgqurKwYPHgwLCwuUlZVhzpw5yM7OZjwm0FRRGB8fz1NCgSRfvnzB48ePQVEUhg0bRrS7hKIoJCYmIi8vD1+/fuUwhWOxWPD29mYkjrS0NDp06ICxY8d+93r4WbSAd+/ejYiICCxZsgSysrKgKArZ2dmIiYnBhg0biLSIz5gxA3Z2dtDU1ISPjw/u3LmD2NhYZGVlwdbWFpcvX2Y8ZmNjI3bt2oV+/frRLej6+vqYOXMmVq1axXi8ZsrLy3HixAmcOHECRUVFUFBQgL6+PrS0tPDu3Ts4Ozvj48ePSEhIIPYZSNB6E6f5mmw9RqLqthkTExPU1NRg3rx58PT0hIODA54/f46YmBj4+voS6Vb8b69+/gVkZ2ejpKQEQJOzjIyMDNfDo6ioCFevXiUS38bGBgDg5eXF9RqpL+vmzZsBNE1MeMX8WRJv/Dq3LRNbgkhyaWtrw87ODl26dIGYmBjGjx+P1NRUeHh4EBMQBpomXVFRUW2645LYDRw5ciTs7OwQFhYGCQkJrgUKiYlQt27deLri8hr7rxISEoIDBw4gPj4effr0wZ07d2BpaUnrkk2aNAmhoaHo3Lnzfz7pBjS1yujp6aG6upoWv+aHXtWkSZP4po1XXV2NZcuW4e7du2CxWJgyZQr8/Pzw9OlTREVFQUxMjPGYtbW1iIiIgKamJoYMGQInJye6fcTPz+8/3YY5cOBA7N27F3Z2dpg7dy66dOmCnj174sOHD/j69SsGDhyIPXv2tCfd/sPo6OggKCgIqqqqUFVVJR6vrq4O3t7eSEhIQF1dHQCgc+fOMDU1Jdb6pK+vT+S4fwV+bgKYmpqitLQU3t7etMFWx44dsWDBAmKLbEHoRANNWovN3x9+UV1djdTUVBQWFqJDhw6QkZGBhoYGsaSxj48PoqKiICUlRVSg3t/fH6dPn8bly5dRW1sLLS0taGpqEtOu+zewevVqdOzYEYcOHaILTMTFxbFx40YOjUQmef36Ne3wfvXqVcycOZOOW1VVRSTmzp07cfToUY7K3rlz52Lfvn3o0KEDkWrNJUuW4NatW+jbty/9fGmpIdqtWzcsWrSI0W4Lfs3D/g0Vn3l5eYiOjoacnBwSEhIgKSkJIyMjiImJIT4+nkjirb3i7Qe5ffs2fWNpFkNtTdeuXWFubk5kh6y0tPSbr7d0nmnn7yHIc3vt2jU8evQIwsLCkJSU5KgYYprGxkbExMSgpKQEixcvxpAhQ3Dw4EG8ffsWa9euJbZT7+DggNTUVEydOpVnewOJJJiJick3Xz948CDjMe3s7PD69WsEBQXRba2VlZW0qcO32ov/C8TFxcHLywtmZmZYvnw5unfvDg0NDXz+/BmRkZHo3r07rK2tMWXKlJ/CkKWiogJr167F2LFjsX79egBNpiijRo1CYGAgMXcrfuPu7o78/Hxs374dc+fOxYkTJ1BXVwc7OztISEggICCA8Zje3t5ITk5GREQE3r9/D0tLS6xduxYXL17EsGHDfooKgdraWqSnpyMvLw/v379H3759oaioiMmTJ7dXEv7HUVZWRnR0NF9aj4CmZEJSUhLWrVtHi+Lfvn0bu3btgpmZGVauXMl4TEEkx6urq2FhYYGcnBywWCykpaXBy8uL6CZAy9hPnjwBALoq6+3bt0TaTbOzs2FhYQFra2vo6+tDQ0MDoqKiePnyJbS0tHg65jJBUlISbbI1bNgw4vehoqIiLFmyBJ8+fYKEhAQaGxvx7Nkz9O/fH9HR0UR+nxMnTsTGjRv5ljiurq7G+fPnkZqaiuvXr0NeXh6zZ8/GrFmziMubCJJ3794BAPFNspkzZ8Ld3R0DBw7ErFmzcOTIESgqKiI5ORm7d+9u00TjR1BTU4O3tzcmT57MMZ6RkQE3NzcihRNr1qyBgYEBVFVV21yLlZeX4927d4xVrAp6HlZZWQk2m80XB1d5eXn8+eefEBcXh4ODA+Tk5GBkZISSkhIsWLAA165dYz4o1Q5jSElJUW/evBH0x2jnP0xFRQWlq6tLSUlJUePHj6fGjRtHSUlJUaamptS7d+8E/fEYRUlJiUpNTRX0xyDOy5cvKVVVVUpBQYHS1dWl9PT0KAUFBWrq1KnU8+fPBf3xfhgDAwMqJiaG/ndOTg4lJSVF7d+/nx67cOECNWvWLEF8PMaxtbWlFixYQD1+/Jgeu3//PrVgwQJq06ZNAvxkzKKmpkZlZ2dTFEVRCgoK9Hf17t271MSJE4nEVFFRoa5cuUJRFEW5ublRS5YsoSiKou7du0csZjvtMMXu3bspTU1N6tChQ9SlS5eomzdvcvxhmkmTJlEXLlzgGk9LS6NUVVUZj0dRFOXl5UWNHz+eysvLo65cuUKNGjWKCg0NpRYsWEA5ODgQienm5kYtXLiQev78OX0vKioqovT09ChbW1siMaWlpamKigqu8ZKSEkpBQYFITIqiqPLycvpeW1RURHl4eFBhYWFUTU0NsZjTpk2jZGRkKGlpaZ5/mMbMzIxatmwZ9f79e3qsoqKCWrp0KbVmzRrG41FU0zPsxYsXRI79Pd6/f0/Fx8dT5ubmlLy8PLVs2TIqMTGRseMnJib+5T8/C2FhYdRvv/1GKSsrU3PnzqUoiqIOHTpEycnJUWFhYURiysvLU0+ePOEaLy4upsaMGUMkpiAQ1Dzs0KFD1JQpU+j7jrKyMhUZGUksHkVRlK6uLpWcnExRVNPzu/kZdv/+fUpJSYlIzP9+z8+/CH5ZOs+YMQPHjh2jNcG+ZSnMlCbYqFGjcOXKFYiIiLQprtsMqV5sfiCIc9sSNzc3dOrUCWfOnKHNKwoKCmBvbw9PT0/4+fkxHhNo2rEJDw/HkydPEBcXh4SEBAwePJho23CHDh2IWVO3RUsxT158y3HwnyImJoaUlBQkJyfTuj/z5s3DnDlz+CJkTJqioiKOHcDr16+DxWJxtFqNGDHiu+f+v0JmZiZXVcvo0aOxefNmWFpaCvCTMUtlZSX69evHNd69e3d8+fKFSMz379/T5zUzM5Nude/Tpw++fv1KJGY77TBFYGAgAPA0GSAh/VFbW8vT0W748OH48OEDo7Ga+fPPPxEQEAAZGRm4u7tj/PjxWLlyJaZMmYLly5cTiXnx4kX4+/tzuEYPGzYMrq6ujFb1HTt2DCdOnADQpC20Zs0aruqv169fE63E6N+/P2pra/HkyRMMHjwY9vb2xCvQ+O34effuXcTHx3NUh/ft25doa6KKigouXrwIY2NjIsf/Fr169cL8+fOhqamJpKQk7Ny5E1euXGFsft3sDvs9fiYpIAsLCwwdOhQlJSWYO3cuAKBHjx5wdnYm5iIrLS2No0ePchnlJCcnc2i2MkllZSV8fX15ahMCZNahgpiHHT16FNu2bYOxsTHGjRuHxsZG3Lp1CwEBAejevTsx2SNjY2PaiGPWrFnQ0dFB586dcfv2bSgoKBCJ2Z54Y5Da2lrExcWhoKCA1oRoHs/NzUVaWhojcfT09NC5c2f6799KDjGFt7c3nSTw9vbmS0xB0PLcCkLL5NKlS4iJieFwjJWSksKWLVtgbm5OJGZmZiasrKygra2Nu3fvorGxEQ0NDdi0aRMaGhpo62ymmTVrFhITE2ktPX7wvWQqqaRxt27diE0o/w20PKfZ2dno27cvx0Tk06dP6NKliyA+GuM0NDTwdD9is9moqakRwCciw5gxY5CamsqlW3LgwAFiCfPBgwcjNzcXlZWVePbsGVRUVAAA586d+6mE29v5OeG3W7OBgQECAwM5HLMpikJUVBS9GGUaQSzK+LUJoK6uzmFgICYmRs8Hm5GUlCSWvKAoCv7+/jh48CDq6upw5swZ7NixA506dYK7uzuxBBy/HD+b+eWXX1BeXs6VrKiurmY0qdlSxqNPnz7Ytm0bbt++DQkJCS5TIhJSQEDT3OfChQs4ffo0MjMz0a1bN1r3jSn4VfTxbyI4OBgWFhYchnRz585FdXU1vLy8iLiaWltbw9LSkk7KsFgs5Obm4u7du0TME4EmTfW7d+9CS0uLbzImgpiHhYeHw9HRkWOdNHPmTAwZMgTR0dHEEm8GBgbo1asXevfujeHDh8PHxwd79+6FuLg4rWfPNO2JNwbx9vbG8ePHISMjg5ycHCgqKuLZs2eoqKiAmZkZY3FaPiD4tVPV8sEsSHFd0rQ8txMmTICCggLXZKempgbp6elE4vfs2ZOnyC2LxSKWuNi1axf++OMPmJmZ0boItra26NmzJyIjI4kl3nr27ImIiAhkZGTwdI0loSPQWsyzvr4eT58+RWRkJJEHNSCYHSt+IiUlhVu3bmHIkCGoqqrCjRs38Pvvv3O85/Tp01yurv9VJkyYAH9/f+zcuZPejKiurkZQUBDjLtK1tbW0xsSkSZMgLCyMlJQUREVFobGxEbq6ut/VLfynrF+/HkuXLsWdO3dQX1+P0NBQPH78GPn5+QgPDycSc9myZVi/fj06dOiAiRMnQlpaGiEhIQgJCWHMda6ddkjBb03dt2/f4uLFi5g+fTrk5OTAZrORn5+P0tJSyMvLw9TUlH4vU0LWgliU8WsToHfv3hzzDicnJ6JOm605ePAgkpOT4erqCnd3dwBNyUA3NzeIiIjAzs6OWGx+dj3Y29vDzc0NDg4OGD9+PNhsNnJzc+Hm5oYlS5ZwVMf/SBfC8ePHOf79yy+/4O7du7h79y7HOIvFYjTx1jLZduXKFXTp0gXq6urYvXs3Jk6cSNTh+FuUlZUR6er4FtT/d6VkgqKiIlRWVgJoMvSSlpbmSkYVFhYiPj6eyHx+ypQpOHLkCA4cOIDMzEyw2WwMHz4cx44dg7S0NOPxgCbjiH379jE+t/wWgpiHlZWVQVlZmWtcRUUFPj4+RGI2o66uTv9dW1sb2traROO1J94Y5Ny5c9i2bRu0tLQwa9YseHh4YNCgQbC1tSXqGPTw4UNER0ejuLgYgYGBOHfuHEaMGIEJEyYQiVdbW4ujR4/i0aNHXBUeTNpyCxpTU1NkZmaib9++HOOPHz/Ghg0buJILTGBlZQUXFxds376dTlSUlJTAw8ODiFAy0NTK6uvryzU+a9YsBAUFEYkJNLnJyMvLA2hq3+AH48eP5xqbPHkyBgwYgD179kBNTY3xmILYseInixcvhouLCwoKCnDnzh3U1tbSyaDXr1/j5MmTCA8P5+kO/F/EwcEBRkZGmDp1KoYOHQoAePr0KXr37s1oQqq4uBjm5uZ4+fIlANDPkg0bNtD39q1bt6KxsRFLlixhLG4zSkpKiI+PR3h4OIYMGYK7d+9i5MiRcHJyoq9bptHV1YW0tDRevHiBqVOnAmhadIeFhXEJGv8M1NbW0hsOL1++5Iszbjvk4Pcmi7CwMGbPns0x9ttvvxFdpAliUSaITYC2Nv5qa2tx7949jBs3jvGYcXFxcHFxwcyZM+l2v4EQtQAAyMZJREFUZS0tLQgLC8PLy4tY4o3fXQ+rV68G0DTfbZmUoSgKPj4+8PX1pRM2P9KFQELs/nusXr0amZmZ6Ny5M6ZPn46QkBBMmjSJb27uL168gI+PD0fnFfX/ndcrKyuRn5/PeMwZM2YgISGByzTi1atXmDt3Lm7cuMFInJKSEqxcuZL+zrSVLCVVLAA0ifH7+/sTO35runTpwrPalySCmIcNGDAAeXl5XNIJ9+7dY9zI5u8Y2pGohG1PvDHI+/fv6Z5gSUlJ5OfnY9iwYVixYgVsbGzg7OzMeMy8vDwsWrQICgoKyMvLQ21tLR48eABvb28EBwdj2rRpjMd0dHREWloaRo8ezVWl9F8nKiqKzq5TFIUpU6bwfJ+cnBxjMVtr5lEUBR0dHXTr1g0dO3ZEVVUVWCwWysvLiVS39OjRA69eveK64T169IhoooiEg+g/ZcSIEUQmJIBgdqz4yZw5c1BTU4MjR46gQ4cO2LlzJ2RlZQEA+/btQ2xsLCwtLaGjoyPgT8oMgwYNwunTp5GSkoLCwkKw2WwsWrQIc+bM4WpL+hF8fHwwevRoxMXFoUuXLggICICdnR2WL19Ot2fv378fx48fJ5J48/DwwJIlS3gm5UkiLS3NsXvcPPH7meDljKurq/vTOeP+r8HvTRZ7e3u+OyQKYlGmpKSEuLg4vm4CPHjwAE5OTigoKOApLUBCluLFixc8nQmlpKTw9u1bxuM1w++uB6aqL79HS81mfnHhwgWw2WwMHToUpaWl2L9/P/bv38/zvSTOg6enJ4qLi6GpqYnw8HCYm5ujuLgYZ8+epasomSA1NRWXL18GAJSWlsLd3R2dOnXieE9paSmjskRqamq4cOECGhsboa6ujqNHj3IURrBYLHTt2pXoPTE7OxvZ2dmoq6vj2lghkaTR1dVFWFgYPDw8+CrxxO95mKGhIdzc3PD+/XsoKSmBxWIhKysLQUFBjK97W1fCtgXTlbDNtCfeGERUVBQVFRUYMGAABg8ejMLCQgBN2gKkHpp+fn4wNzeHra0tFBUVATTdeHv06EEs8Zaeno4dO3ZwlGf+LBgbG6N3795obGzEpk2b4OjoyCGA33xjnzhxImMxBa2ZN2fOHHh5ecHLywssFgufPn1CRkYGPDw8oKWlxWisW7duQVFREWw2G7du3WrzfSwWi8iOMi+qq6sRFRWF/v37Ezm+IHas+M28efN4ajBYWlpizZo1fJ348oPu3btj4cKFRGPcvn0bBw4cwC+//AIAsLOzQ2xsLMd9V1NTk5i2SFJSEpYuXUrk2G3RsjWOF/xasJHGy8sL9fX1HMnoyMhIuLm5wdfX96epDv1fg9+bLMrKypgxYwb09fWhoqLCpVtFCkEkx6WlpbF9+3bicZrx9vYGm82Gq6srPD094eDggOfPnyMmJobYZsTAgQNx7949rpbdjIwMDmMJpuF310NhYSFmz55NPGlcWlrKM2lKEl1dXYHO57OyshAaGorffvsNly5dgrq6OuTk5LBjxw5kZGRgwYIFjMRRVFREbGwsnXwqKyvjkOVpXisx3SbY3Cp7/vx5DBgwgK/net++fQgICECvXr3QrVs3jteYTNK0nAfV19fj9u3byMjIwJAhQ7ju8UzNiQRtLGhqaorS0lJ4e3ujoaEBFEWBzWZjwYIFdIUsUwiiErYl7Yk3BlFVVYWrqyu2bt0KJSUleHl5YebMmUhNTYWYmBiRmHl5eXB1deUaX7RoEWJjY4nE7NWrF4f4/88Em82mNS1YLBa0tbWJV/UJWjPPxsYG5eXl9K6mnp4eKIqCmpoa48YHJiYmyMzMhIiICExMTMBisbh2jQAyDnAAd3Vhy3i8nOiYQFA7Vv8GSCUzBQm/THSqqqo4dnO7deuGzp07c4hPd+7cmZihg5qaGg4dOgQrKyu+6Ry11siqq6vD8+fPUVhYyKhOqqD5X3HG/V+D35ssu3fvRnJyMtatW4cePXpAR0cHenp6HN8rpqmoqMCOHTvarPpgalHm6OhIa6w5Ojp+870k9GDz8vIQHR0NOTk5JCQkQFJSEkZGRhATE0N8fDyj4vjNWFhYwM3NDa9evQJFUbh27RpiY2Nx8ODB756DH4HfXQ/79++Hr68vpk2bBgMDA6ioqPw0c6Nt27YJNH5NTQ2duB02bBgKCgogJyfHuB6suLg4nfQxMTFBcHAwXyu1Bw4ciIyMDISFhaG4uJi4LiEAHDp0CKtWrcK6deuIHL+Z1vMgfqy3BWHa2JIOHTrAyckJ69atw5MnTwA0fX/5qbHJL9oTbwxiZ2cHe3t7ZGVlwcjICPHx8Zg/fz7YbDYxcUAhISFUV1dzjZeVlRET41+1ahW2bduGLVu2EN2FEwRJSUm0pgaLxUJqamqb7yVxc/9e7zmJslchISH4+/tj7dq1ePDgARobGyEpKYkRI0bwTIr9COfPn6eTCYIwFeA1QRcSEoKCggKjwtCC2LFqhz/wy0QHAE8RZn5NiMrKypCSkoLo6GiIiIhwtZGQuH7bWkAHBQWhoqKC8XiC4n/FGfd/DX5vskydOhVTp05FdXU1Tp8+jRMnTiAqKgqysrIwMDCApqYm4wsXFxcXZGVlQVdXl6MbgGlevHhBXyMvXrwgFqctGhsb6STq0KFDUVhYiHHjxmHGjBnYu3cvkZgGBga0ht3Xr1/h4uICERER2NraYtGiRURiAvztegCaumYyMzORlJSEtWvXokePHtDV1YWenh6GDRvGaKw7d+78pYTQzyIFMmjQIBQWFkJcXBwSEhL0BnZjYyM+ffpEJOa3ZGNIGTq01CXMyckhrksIAB8+fCCW1GtJy3lQWVkZxMTEuNYN9fX1jMrjCMK0saWJSkuaNd2qqqpQVVUF4MdMVr5FW8UYzZAoAGFRTK+s2+EgPz8foqKidLsQ02zevBklJSXYsWMHpk+fjhMnTqC2thY2NjYYM2YMEbHbnJwcLF++nL4gWkPii8ovpKWl6Yqsb7nUkKrIammNDTTdXCsrKyEkJARFRUVEREQwHpNfwqj/BlomVlvy+fNnxMfHM5Y4+Tu70yR269shh7KyMjZt2kSb6OzZs4c2PhATE2NMy3PUqFFc5i5KSkpITk6mNzzevn0LFRUVIvciQWwCtEVJSQkMDAxw8+ZNvsUkyZo1a/D161cuZ9yNGzeioaGB2MK+HebhtcnSr18/gWyyVFRU4OjRo9izZw++fv2KLl26wMDAADY2Nowl4BQUFBASEtKm/i2/qKmp4doMYBI9PT0sXboUc+fORWhoKJ4/f46tW7ciPz8fJiYmyM7OJhYbaDLqoCgKIiIiROMATZXFDg4OSElJAQC6E0FNTQ2BgYFEz/OnT5+QlpaGtLQ0XLt2DdLS0pg/fz60tbV/WDO1eVH9vWUuqfm8IAgLC8P+/fuxbds2urPE2toamZmZ+PLlC5FOqNLSUmzbto2vhg6GhobQ0NCAmZkZFBUVceLECQwaNAjh4eFITEzEqVOnGI9pbm4OfX19LkMbkvCaBwJNhl46OjrIyclhJE5SUtJffi9TycfvJb0AMGKy8i2OHz/O8Rnq6+vx9OlTJCYmwsHBAXPnzmU8ZnvFG8N8+fIFjx8/Rk1NDX2z//TpE549e0ZkR8Xe3h7Lli3D5MmTQVEU9PX1UV1dDWlpaWzcuJHxeADg7OyMIUOGQFdXl1hVnaB4+PAh/fdbt24R3dHlBa/e8+rqatjb2zPqUisIYdTWlJSUwM/Pj6c7LsBcRU1lZSW+fv0KoCkhNnLkSC7Nsfz8fAQEBDCWeGtPpv288MtEh5e5C0VRmDVrFiPH/x78TKx9j8ePHzNefStI+OWM2w55BNEW1JLa2lqcO3cOSUlJuHr1Kvr16wczMzPo6+vj1atX8PLygrW1NSIjIxmJ17VrV7677zZXfw0dOhSrVq0C0KQ/pqKiAhcXFyJyIMbGxnBycqJj6ejooHPnzrh9+zZ9/2eaby1+hYWF0b9/fygoKPCshP4RvtX1QJrPnz/jw4cPePfuHWpra9GhQwfs3bsXAQEB8PPzw6RJk37o+PHx8VxJi5+ZZcuWgc1mg8ViQU5ODlZWVggNDYW4uDgxjUQPDw++GDq0hN+6hECTpq67uzvy8vIwbNgwrvsOUwmpmJgYusiCoigYGBhwbeJUVVUxWgXm4ODwl97HYrEY+zn/Dd0+bUk9SUtLIzk5uT3x9m8nIyMDNjY2PG3kSWVsu3fvjtjYWFy7dg35+fn0A5Ok0O6zZ8+QnJxMLxh+VnR1dREUFAQZGRmBfo7u3btj3bp1WLFixXfFx/8qghJGbcnGjRvx5s0baGpqEt1RvXTpEhwcHOidT14mABRFQVVVldhnKC8vR0xMDAoKCsBmszFy5EgsXLiQWPl0O+Tgl4nOvyF5e//+fYSHh9Pf2xEjRmDJkiWMujq3hFel6MePH5GZmQkNDQ0iMQUBv5xx2yEPr+u0traWXpS9fPmSWKLKyckJZ86cQW1tLaZPn47Q0FAoKyvTG2aDBw/GihUrsGnTJsZi6urqIjw8HO7u7owngNrC29sbOTk5HMLwzs7O8PPzw44dO2Bvb894TAMDA/Tq1Qu9e/fG8OHD4ePjg71790JcXBybN29mPB7QpNnX3GLbvOn78eNHjqqtoUOHIjIykohu9JAhQ/iSOK6pqUFaWhqSk5Nx7do1iIqKQldXF76+vrTOnJubGxwcHJCRkfFDsQYMGMCXqkFeVFdXC0SjytTUFO/fvwfQZHA1duxYjBkzhmOOzyT8MnRoCb91CQHQ131UVBTXa0wmpPT19fHu3TtQFIWQkBBoaGhwmTl069aN0U3YlkUn/GL8+PF8j/lXUVJSInafb0+8Mcj27dsxZcoUrFmzhkMAmySmpqYIDg7GpEmTOHaGKioqYGFh8bfKR/8qI0eOxKtXr376xFtNTc2/ZhHU3HLKFIIWRgWaWpJjYmKIJzZ1dXUxcOBANDY2YsmSJQgKCuL4WZuTjJKSkkTiFxYWwtjYGJ07d4acnBwaGhpw/PhxxMTE4MiRIxg5ciSRuO2QgV8mOnp6eowd65+QlZWFpUuXQlJSEsrKymhoaMDt27dhZGSE6OhojB07lvGYvLSchIWFYWFhwXeHVdLwwxm3Hf5SUVGBtWvXYuzYsVi/fj2ApufPqFGjEBgYyPgzNj8/H+vWrcPcuXPbPLaUlBT8/f0Zi/n27VucPn0aFy9exODBg7mqPkhUMVy4cAHBwcEclWYzZ85Enz59YGtrSyTxBoDDQVpbWxva2tpE4jSzaNEiHD9+HP7+/vR85MmTJ9i4cSP09fWhrq4OZ2dnbN++/Yd/p3+lzasZposGJk2ahPr6eqipqWH37t08CwUmTZokEB1gJtHR0eH75v2zZ89gYWGBmTNn0tfFypUr0a9fP4SFhRHZBOCXoUNL+K1LCPAvOdWlSxe644DFYsHCwuJf011GSrOv2WyvNSwWC0JCQhATE4OOjg7ftBhTUlKIrYnbE28M8uzZM4SEhBDfMcrIyEBubi6ApnbIPXv2oGvXrlyfpbS0lEj8tWvXYvPmzVi6dCmGDh0KNpvza/SziJQuXrwY1tbWWLx4MQYPHsyVhCPxc7ZOlFIUhY8fPyIuLg6KioqMxwO+LYxKkqFDh+Lz5898idX8uzpw4ACUlJS4vrMk8fX1xcSJE+Hn50cvUmpqarBhwwb4+fm16zn9xxCEiY4gCAgIwPz58+Hi4sIx7ubmhp07dxK5b1hbW0NBQYG4k7QgaN4k69mz53crl/8NLRjt/H28vLxQX18PHR0deiwyMhJubm7w9fWFl5cXo/ESExO/+55hw4YxKljfsWNHvmocAU1yLbxkP/r06YOPHz8Si5uRkYHw8HA8efKEL66JkZGR2LlzJ8cm4LBhw+Ds7Ix169bByMgINjY2MDc3/+FY3t7eAnMSbU4Wt5b8aMn06dN/uKLnt99+I1bl9Veoqanhe8LEy8sLI0aMgIWFBT32559/wtHREVu3biXShikIQwcbGxuUl5fTJgp6enq0LqGtrS2RmN+CVELKysoK9fX1ePXqFZd+Xk5ODpF70YsXL+Dj48NXzb5Ro0bh4MGDGDVqFMaNGwcAuHfvHu7evQt1dXW8fPkSS5cuRWBgIGbMmMFY3OnTp3PcBymKwqdPn1BVVUXse9SeeGMQCQkJvHnzhnjibeDAgXB3d6dLz1NTUzl2i5oreEhpvK1YsQIAePbu/0wipYGBgQCa9AtaQ+rn5NVnz2azoaSkBFdXV8bijBo1CleuXKFNJPjt6gIArq6u2LJlC0xMTPDrr79y7XiSSGyOHz8eDx8+RGFhIe2Y1vIhRsKMJDs7G3FxcRzJhE6dOmH16tUwNjZmPF47zOPr64sVK1agV69e+PjxI4KDg+nv6759+4ib6AiC+/fvw9PTk2vc2NiYZ7s2E6xduxbh4eECb+8nwcCBA+nvTGtdsHZ+DjIzMxEdHY3hw4fTY6NHj8bmzZthaWnJSIzvmZ60hIROoyBa4BUVFbF3715s3bqVbm+lKArR0dEYM2YMkZgtXRPv3r3LF9fEjx8/8mxN7Ny5Mz58+AAA6NmzJyPOx21pG/GDJUuWfPc9TGyOCmpTuZnFixfDysqKr5v3t2/fxtGjR2lnSADo27cv7OzssHjxYsbjAU3fpY0bN2Lbtm1QVVWFiYkJBgwYgMzMTEhJSRGJWVpaCn9/f6xbt45DZomkLqEgElLXrl3Dhg0beLq6d+7cmUjizdPTk++afeXl5Vi8eDGXRrKfnx/KysoQHByMqKgo7Nmzh9HEm56eHtf6V0hICEpKSsSKiNoTbz9ISztcQ0NDODs7w8nJCRISElz6F0xlw0eMGEGXYE+fPh3Hjh3jq3jof738+69y9uxZYjp5bcEvQwdvb286jqB2Ph89eoTHjx/TAsYtIZXYPHDgAJ1ca6mbwmKx6F0WpunWrRtqa2u5xnmNtfPv5NChQzAxMUGvXr0wY8YMLpep0aNHC/DTkaFPnz6oqKjgqpapqKggVpEmIiJCtIJFkLRMWPwb9PvaYZ6GhgZ6Q6clbDabkWQJ0OTC1pry8nL069ePY87JYrH+VQYpP8L69ethYmKCrKwsyMjIgMVi4f79+3j//j0Rp3cA2LVrF/744w+YmZnhzJkzAABbW1v07NkTkZGRRBJv48aNw/bt2xEQEEDPz6qqqhAQEEB3PKSlpRGReTl9+jSio6NRWFiIjh07YvTo0bC0tISysjIjx29dWfItfpY1hiA279lsNt69e8f1Hfny5QvjsZoRhKGDsbExdu/eDTk5OS6dN1IIIiEVEBAAWVlZmJiYwMrKik5EBQUFEZtHCEKz7/LlyzyfbfPmzaNlV2bMmEFfU0xhbW2NxsZGvH//np7T37lzB7KysozGaUl74u0H4VWmaGlpyTVG6ibb7IJZXV2NJ0+eQEhICIMGDSIq6Pm/slu/bt06/D/2zjyeqvz/469rS2hBm5qilG6jFC2jjRaV0oKaVrIllQqDiFJkT5GIEkVZK1mihWkZaZlowRQibURThiJZ7+8PD+fndtX0nc65JzrPv+rc+7ivT3LvPZ/35/1+vdzd3cFms/mmya9Ah/b+Ubq6uqiqqkJVVRXk5OQAtHZRTp48+YujAN9KQEAAli5dirVr1/LNS+/kyZMwMzODubk5Zs6cifj4eFRVVcHa2prUU5T2qKqqwtvbG/7+/ujduzeA1qRVHx8fqKqqUqLJQC79+/fHjh07oKysDA6Hg6NHj/KM97fRVTa7M2fOxJ49e+Dr60t08BQVFcHNzQ0zZ86kRHPatGkwMzODuro6ZGVleUJXusrPFmj9WRYWFnZYgKdqlI2BWn755Rfs27cPfn5+ROGkpqYG/v7+pJ2ed5R8rqysjJMnT2Lw4MGkaHwKnX5gADB69GgkJycjLi6OCCNZuHAh1qxZQ1mXMR2piU5OTjAwMCDSjjkcDp4+fQpJSUkcPXoUmZmZ2LdvH3x9fUnVPX36NJycnKCpqYkFCxagpaUFd+/ehZmZGQ4cOMDldfdf+bSzhMPh4PDhw1i5ciVxX9TVoKOAqK6uDldXV/j6+hLTVy9evIC7uzumT59Oma6hoSHxZ1NTU9I6fD+HiIgIXy1jAHoKUgUFBTh16hRGjhyJn3/+GWJiYtDX14eYmBhCQ0NJeW9+Ch2efRISEiguLuYpGBcVFRHj2rW1taTvFTvyRDQzM6PUE5EpvH0j34MXi5eXF06ePImmpiZwOByIiIhgxYoVcHBwoKST6UfxpyktLf3s5poq6Ah0yMnJgampKXR1dYkPnr1796KxsRHHjh2jzPy/uroapqamxAc8PygrK8OyZcsgIiICNpuN3NxcaGhowN7eHp6enlw3D2RhY2ODlStXYubMmZCTkwOLxUJJSQl69OiByMhI0vUYyMfJyQn79+/H2bNnwWKxeMb726Cyy6SsrAw9e/aEhIQEbt26hUuXLkFFRYUyvyVLS0sYGRlh4cKF6NGjB1gsFt69ewcFBQXKbAzS0tIgLS2NvLw85OXlcT3WlTp4jhw5gv3793f4GJnpaAz8xd7eHqtXryYKJwDw9OlT9O7dG6GhoTSv7r9Dpx9YGz/99BMRWMEP6EhNHDx4MFJTU5GSkoJHjx5BUFAQa9euhZaWFkRERNCtWzckJyeT6tkHACEhIdi2bRvX/Y+hoSGOHj0Kf39/Ujb3W7Zs4bkWFhYGAwMDygrGdNPWpNDQ0ICXL19iyJAh4HA4lPrO2dnZwdjYGJqamkTI37t376CoqNihlU1nZfHixVi3bh2WLFkCWVlZnn0TFd+hdBSkBAUFiUYaOTk5FBYWYvLkyVBVVaXMU5gOzz5dXV04OTnhn3/+wdixY9HS0oIHDx7A398fS5YswT///ANvb2/Sxz/p8ERkCm/fyOficKuqqiAoKEj52ODhw4dx5swZ2NnZYcKECWhpacGdO3cQGBiI/v37Y926daRrftrx1tjYiOfPn6OwsJCSwgVdmJqawtHRESYmJh36M1BhpElHoIO3tzfmzp3LZSSZlpYGJycneHh4UDbKoaamhlu3blHmF9UR4uLiaGpqAtD6JVZUVAQNDQ3Iy8tTFkYyYMAApKSkICkpCYWFheBwOFi2bBkWLVrEl7Fihm9n+vTpxGkxm83GmTNnIC0tzTf9tLQ0WFlZITg4GLKysli3bh0GDx6M+Ph4VFdXU+Ld0qtXL5w+fRoZGRl4/PgxOBwOkXD6qY0CWXTUzdMVCQ8Ph7m5OczMzLpkkMSPyuDBg3H+/HmkpKQQnVmrVq3CokWLvpuE9P8CHX5g27dvh6OjIyQkJLB9+/YvPpeKkSs6UhOBVt+mjsZYP378SNm0SXl5OWbMmMFzfc6cOTh48CAlmj8CHA4H+/btw4kTJ9DY2IiLFy/C19cX3bp1g4uLCyUFOCkpKZw5cwY3b94kPoOGDx+OyZMn0148J5Pg4GAArYEkn0LV4RUdBSk2m420tDQYGhpi6NChyM7OhoGBAcrLyynRA+jx7LOwsEBDQwPc3Nzw8eNHAK2fhfr6+rCwsMDVq1dRV1fXoe/wt0CHJyJTeCOZo0ePIiIiAn///TeA1lM6U1NTSlpQASA2Nha7du3iijn/+eefISUlhYMHD1JSePvcTY6/v3+HBpCdFR8fHwCtvmv8Gh2mwxPir7/+goeHB9cGUEhICOvXr6f0hnvSpElwc3NDRkZGh+m4VHS3TJgwAcHBwXBycgKbzUZcXBzWr1+PrKwsiIuLk67XRk5ODgYPHoxVq1YBaD1lyc/P7zIJwD8SP//8M/7++2++Ft4OHToEExMTTJkyBSEhIRg4cCBSUlJw/vx5BAQEkH6DUFdXB1FRUQgICEBdXR3q6up4/PgxBg0aRHrRraysDDIyMmCxWFyeqR1BxWEHHTQ2NmLx4sVM0a0LIiEhgRUrVqCyshJCQkJE1wnD/8bLly8Jv7yXL1/yXf9LqYmWlpaUaFZXVyMoKIjHvL2xsRGPHz9GdnY2JbqTJ09GamoqNm3axHX9+vXrhLdcZ+ft27fw9fVFdnY2GhsbCX/fNqgYCz1x4gQSExOxa9cuwgNMQ0MDzs7OkJaWho2NDemaQGuX1LRp00jz5/seyc/P57smHQUpU1NTbN68GSIiItDS0oK/vz/Wr1+PgoICyqxqvuTZ19H4PRkICAjAzs4OFhYWKC4uhqCgIOTk5IgDKw0NDUrGaunwRGQKbyRy5MgRHDp0CPr6+hg3bhw4HA6ys7Ph7u4ODoeDFStWkK759u3bDlOdxo4di1evXpGu9yV0dHSwdOlSODs781WXKugYmaXDE0JCQgLPnz/nafcvLy+n9JQ+LCwMkpKSyM3NRW5uLtdjVI2VtY3PRUdHY9WqVQgKCsKkSZNQV1fH1WpMJklJSXBwcIC1tTVxI1RRUQEjIyP4+flR8mXCQB10jKAXFxcTSarXr1+Huro6BAQEoKysTHqnZkJCAjw8PHD06FGu7xZPT088ePAAe/bswfz580nTmzVrFjIzMyEtLf1ZA24qDzvoYMmSJYiLi4OtrS3dS2EgmcjISAQFBRGHkH369IGJiUmXmgbgB2PGjCGKI15eXhgwYABfw66EhYWxb98+bN26FY8ePeJKTfy0aEMWLi4uyMzMxLRp05CamgotLS0UFxfj4cOHlI7ZKisr49ChQ/jrr78wceJECAsLIzc3F+fOnYOOjg5Xkm5nHfd3cnJCVlYWtLW1+TZpEBsbCycnJ8yZM4c4TF+wYAFERETg5uZGWuFt9uzZOH36NCQlJf81xKKrBFd8ibKyMkoO6egoSM2aNQunTp2CoKAgZGRkEBoairCwMMyePRtbt26lRBPgv2cfAHz48AFJSUkoKCiAkJAQRowYgQULFlDqWU+HJyJTeCORyMhI7N69m6vFtW2M7ciRI5QU3uTk5JCZmcnjQ3H9+nW+dwcUFRVRdkNCB+3HiBsaGvjSnUBHcMW8efOwe/duODs7Q0lJCSwWC7m5uXBxccGcOXMo06VjrGzEiBFIT0/Hhw8fIC4ujlOnTiE5ORkDBgyApqYmJZpHjhyBg4MDVq9eTVzz9/dHZGQkDh48yBTeOhl0jKD37NkT79+/R01NDe7fvw9jY2MAwPPnz0k1pr558yYcHBygq6vLYyrr5OSEkJAQ2NjYoG/fvqSlAEdERBCeSV3FH/TfWLduHRYvXozU1FT89NNPPBulH+Xn0NU4deoUPD09oaenx2X9sX//fkhISJBiq5CQkMBzraWlBWlpaTzp9p3ZK/DfkqSpZvbs2Thz5gxkZWWJDRnQemi2ePFi3L59m3TN69evw9vbG+rq6sjPz4eJiQnYbDZ27tyJoqIi0vXaiI2NhbS0NB49esR1uNGvXz9kZmYSf+/MPpuZmZkIDAzE1KlT+ab58uVLjBo1iuf6yJEj8ebNG9J0dHR0iPuQT0Ms+MXHjx9x4cIFFBcXw8TEBIWFhRg+fDhl79mXL1/Cy8uLpzu0oaEBlZWVePjwISW6dBSk2sL2qqqqwGazERQURLnmtWvXUFhY2GEaNxWfAa9evYKenh7evn2LoUOHorm5GXFxcQgODkZUVBQGDBhAuiZAjyciU3gjkXfv3mHs2LE81ydMmNDh6CAZGBkZwcnJCS9fvoSKigpYLBaysrIQGRlJ2Wl6R34b79+/R2ZmJmXFC7qIjo5GSEgIysvLcfHiRRw9ehR9+/Yl9YOH7tMqa2trvHjxAsbGxoQ2h8PB3LlzKTNR/xINDQ3IyckhbWP/KaKiohAVFUVTUxPKy8uhqalJ2Yc60Hp60tHJiZqaGmWnZAzUQccIurq6OpycnCAhIQEJCQlMnToVN27cwO7duzv05vmvhISEQE9PDw4ODjyPycrKwtXVFRwOB8HBwTh69CgpmmfPnoWgoCDGjx//Wc/UrsaOHTsAtHamtyV2MXR+QkNDsX37dq5Dljlz5kBWVhbh4eGkFN4+txn49Luks4d00JEknZqaioyMDACtnc0uLi48ycqlpaWUFTZqa2uhoKAAAJCXl0d+fj7YbDb09PSwfv16SjQB7kPQyspK3LlzB3369MH48eNJ0+golK2+vh42NjY8P2MqDh7ExMQoSSj8EoMGDUJOTg5PgNi1a9dIDZRo//vfUYgF1bx58wYrV67Emzdv0NDQgOXLlyMsLAy5ubmIiIggUtHJxNXVFSUlJZg/fz5CQ0NhbGyMkpISpKWlEWO9VMDvghTAfwsrV1dXnDx5En369OFpOKGq+O7p6QkZGRmcOnWKKNa+efMGFhYW2Lt3L/bt20e6JkCPJyJTeCORuXPn4sSJE3BycuK6fu7cOairq1Oiqa2tjaqqKhw9epRIzZKWlsbWrVuhp6dHiWZHfhsiIiIwMTGBkZERJZp0kJycjH379sHAwIDYZMrLy8PHxwfdunUj7aSD7tOq7t274/Dhw3j69CnR4isvLw85OTlKdR8+fIgdO3agoKCA8HJpD5kFjISEBERERCAgIAADBw5EcXExTE1N8erVK7BYLOjo6MDFxYUS03gZGRncvn2b50br7t276Nu3L+l6DNRCRzfSzp074efnhxcvXiAoKAgiIiLIzs6GkpISkURMBg8fPvzXU75Vq1aRugm8f/8+EhISICsri19//RXa2tp89c+jgz///BPHjx/vMv5JDK2UlZV16Ks0ffp00hLo6PA2ogM6kqSVlZURExNDTG6UlZVxGeCzWCyIiYlRliYoIyOD0tJSwry97f+6e/fuqK6uJl0vMDAQERERiIuLg6ysLO7duwdTU1PCKF5VVRVBQUGkWI50NM3BzwkPbW1thIaGUnaf1xEmJiZwdnZGRUUFOBwObt68iZiYGJw4ceJfA0P+K+3HgtvDYrEgLCyMAQMGQE1NjdROeU9PTwwfPhzJycmYMmUKgNbx8N9++w1eXl44cuQIaVptZGVlISgoCBMnTsQff/wBDQ0NKCkpwdfXF9euXaOkKEVHQYoOC6vk5GQ4OztT8tqfIzMzE8eOHePqkOzTpw/s7Owo7yps74nY2NiI/Px8YiqKCpjCG4n07t0bUVFRuHv3LiZOnAghISHk5eUhKysLs2fP5vqgJSuFKSkpCTo6OjA0NERlZSU4HA7lm5YTJ05Q+vrfC2FhYXB0dISOjg6R7Ll27Vr06NEDQUFBpH0Y0H1a1YacnBzk5ORQWVmJP//8E0JCQjwndWTi4eEBISEh7Nq1C66urrC3t8fz588RGRlJaifYxYsXsX37dixYsIC4gbS3t0dNTQ0OHz4McXFxODo6IiIigpLC8Zo1a+Dm5oYXL15g7NixxChvW7IhQ+eCjq4sUVFRnoIYFZ8VDQ0N/7rJ6tWrF5E6RQbnz59HTk4Ozp49i5CQEPj6+mLmzJlYtmwZ1NTUulQSWxt9+vShNMyFgR4GDhyIvLw8HuuPnJwcrtS0zsa/deK3h6yufDqSpGVkZIiDFX19fQQGBvI1HENTUxPbtm2Dt7c3VFVVYWlpiXHjxiE9PZ1r3JUMYmNjcfjwYRgaGhI/1+3bt0NMTAyxsbGQkJDAli1bcPjwYVhYWHyzHhXJs/8Lb968wfnz53HlyhUMGTKEp3BCxYHa0qVL0dTUhKCgIHz8+BFOTk6QlpaGlZUVEbRFNnfu3MGdO3cgLCxMGMY/e/YMHz9+hIyMDKqqqtCtWzdERERgxIgRpGjeunULR44c4ere7tWrF2xtbTvsdCSD+vp6Yn8ybNgwFBQUQElJCdra2tDX16dEk46CFB0WVkJCQny/zxUUFOzw3rNbt25oaGigTPfVq1dwdHSEpaUlRo4ciaVLl6KoqAi9evXC8ePHOxwV/1aYwhuJPHz4EOPGjQPAfSo5YcIEVFdXU3Ji5erqCkVFRfTq1Yuv/hf19fVITk7G48ePISIiAgUFBcyfP58nmbIzU1JS0uG444QJE0iNcu7Is+VzUDE6UlhYiC1btsDV1RVsNhtLlizB33//DRERERw5coSy5Jy8vDyEh4dDSUkJZ86cgYKCAlavXo0BAwYgLi6ONAP3EydOYPPmzUSRq7CwELm5udi0aRPU1NQAtIYuBAYGUlJ409fXR0NDA8LDw3H48GEArd4pVlZWlHWlMlDHv51Uk7XBCAgIgImJCbp37/7ZU+w2yDppHTp0KO7du8dTOGjP3bt3Se9UUFJSgpKSEhwcHHDlyhUkJibC3Nwcffr0IUJ7qDwE4DfW1tZwdXXFrl27ICcnx7cODAZqWblyJZydnVFVVcVl/eHv70/ZZpAf0OUb1Ubb/XRDQwNevnyJIUOGgMPhcHWjkU37A+ampiYUFBRAWlqaUluKLVu24OPHj3j16hUWLVqE+fPnw9LSEj169IC/vz+pWqdOnYK9vT0xFp2Tk4OnT5/CxsaGGA3cuHEjPD09SSm80Y2goCAWLlzIV80PHz5gxYoVRMoxPxojxowZg5aWFhw4cIDYE1ZVVcHW1hZKSkrYsGEDnJyc4OPjQ9yPfiu1tbWftUxoamoiReNTBg8ejMLCQqI7tG1CpqWlhejYJBs6ClJ0WFjp6ekhKCgIrq6ufEteV1FRwaFDh+Dt7U18rjc2NiIoKIjSyQAPDw+8f/8eUlJSuHjxIkpLSxEVFYXTp09j7969RNMNmXSdKsl3AB2dYHJycigoKKBkhv5zvHjxAqtXr0ZNTQ1hghgREYFDhw4hJCSky2yQ+vTpgydPnnQ4ItivXz/SdL7WwJEqzxYvLy/Iyspi2LBhOH/+PBobG3Ht2jVERUXBz88PMTExpGsCrV+QbaOWQ4cORWFhISZMmIDZs2eTdkMAtN60t0/avXnzJlgsFmbOnElcGzVqFJ4/f06a5qeYmJjAxMQE//zzD4SFhSlN6WGglk9H7ZuamvDixQvU1tZiwYIFpOnEx8djzZo16N69O+Lj4z/7PDJHHBYvXgx/f39Mnjy5w8+4169f48CBA1i6dCkpep8iLCyMuXPnYu7cuaisrERKSgpSUlJw5MgR/PLLL5TcBNGBn58fysrKPrsR7CrprT8aa9euRWlpKdzd3dHc3AwOhwMhISEsX74cmzZtont5/xk6O/Hb8PHxwYkTJ9DY2IiLFy/C19cX3bp1g4uLC6kFODptKURERODo6Ej8fffu3UThjWy94uJiYiwQaO1aYrFYXLY4w4cPR1lZGam6dEFHx92UKVMwb9486OjoUHaA/SlnzpxBWFgYVyNG7969YW1tDSMjI2zZsgUmJiZYuXIlaZoTJ05EZGQk4V0KtBZNAgMDoaKiQppOe3R1dbFt2zZ4enpCXV0d+vr6GDhwIDIzMzFy5EhKNOkoSNFhYTV//nysWLEC48ePR9++fXkOXajwGrexscHKlSsxZ84cjB49GiwWCzk5OaipqaG0tnLr1i2Eh4fjp59+gq+vL9TU1KCiogJJSUno6upSoskU3kimrKwMPXv2hISEBG7duoVLly5BRUWFspOWESNGwMbGBkePHoWcnByPSSkVXza7du2CoqIi9u7dS8RyV1ZWwsrKCq6urggODiZdkw5WrFgBZ2dnojD25MkTZGRk4MCBA1zJNt8K3Z4t9+7dw6lTpyAtLY2MjAyoq6ujf//+WLZsGcLDwynTHTZsGO7cuYPFixdDVlYWubm5AFqDOshsLW5sbOT6kszOzoaEhARGjx5NXGtqaiL15v1LN6t1dXV49+4d8Xd+pw8zfBsd3QRwOBzs2rULkpKSpOm0N7z+UgJwR/6I/xU9PT1cunQJWlpaWLZsGcaNG4eePXuiqqoK9+/fR3x8PGRlZWFiYkKa5ueQkpLC4sWL0b17dzQ0NODWrVuUa/KLjRs30r0EBgoQEBCAo6MjLCws8OTJEwCt33Nd7aAlPz8fhYWFxGdPW5rggwcP4O7uTrpeREQEEhMTsWvXLsI4XUNDA87OzpCWloaNjQ0pOnTbUgCtB9t//fVXh+P8ZB+8tt9QZ2dnQ0pKimv88EudTJ2BhIQELFiwACIiIv86WULFobaLiwuSk5Oxbt069OvXD0uWLIG2tjbpY8PtaWpqQmNjI8/1+vp64ndKRESE8DEkAzs7O6xZswZ//vknGhsbsXv3bjx58gTv37/HyZMnSdNpz7p16yAkJAQWiwUlJSVs3rwZQUFBkJGRoSy0jI6CFB0WVvb29ujZsyeWLVvGt/e/vLw8EhISEBUVhcePH4PD4WDhwoVYuXIlqUEkn9LY2IhevXoBaG3KaOvubWlpoWyCjym8kUhaWhqsrKwQHBwMWVlZrFu3DoMHD0Z8fDyqq6uxZs0a0jWfP39OJA+1JZ5QTXZ2Ns6cOUMU3YDWTZK9vT1lvgV0YGpqivfv38PW1hb19fUwMzODkJAQVq5cCTMzM7qXRxoCAgIQERFBc3Mzbt26RZy41tbWkmKq+zn09PQIrblz52LJkiUQFRXF3bt3iZFtMhg6dCjy8vIwePBgfPz4ETdu3MCUKVO4vjSvXLlCapjE13jiUJmCycBfWCwWjI2NsWbNGlhZWZH++rNnz8aZM2d4DJErKiqwePFi3L59mxQdQUFBHDt2DP7+/jh16hSOHTtGPNanTx+sXr0aGzdupPRzoaGhAb///juSk5ORkZEBaWlp6Ojo4MCBA5Rp8hsdHR26l8BAEdXV1Xj27BmRetf+833ixIl0LYs0IiIiiOIai8UiNvAsFouyJPLY2Fg4OTlhzpw5xHhVW0HFzc2NtMIb3bYU8fHx2LFjR4eHKWRPPIwcORJ37tyBrKws3r17h9u3b2PevHlczzl//jyRstoZsbe3x/Tp0yEtLf3FyRKqpkkWL16MxYsX4+3bt0hOTkZycjKCg4Mxbtw46Orq4tdffyVdc9q0aXB2dsb+/fuJAl9JSQlcXV0xbdo0NDc3Izo6mtSuMHl5eSQmJiI6OhoyMjJoaWnB/PnzsXr1akonoNo3QJiamlJuwk9HQYoOC6uHDx8iLi4ObDab9Nf+EoMGDYKtrS1fNX/++WecOnUK/fr1wz///AN1dXU0NDQgJCSEsn8/U3gjkUOHDsHExARTpkxBSEgIBg4ciJSUFJw/fx4BAQGUFN7oGG8dMGAAXr9+jeHDh3Ndr66uJrXj43vgt99+w8aNG1FUVAQOh0PJ6fWoUaNw/fp1SEtLg81mf7FgQ0WRZty4cQgODkafPn1QV1cHNTU1VFRUYN++fR16C5DF0qVL0atXL/Tu3Rvy8vLw8vLC4cOHISMjg507d5Kq4+bmhoqKCty6dQs1NTVEgbixsRG///47goKCYGlpSZomHcmXDPTy5s0bfPjwgbTXS01NRUZGBgCgtLQULi4uPB3NpaWlpHsviYiIwMbGBpaWlnjx4gWqq6shJSWFwYMHU+bz1Jb4lpycjLS0NHz8+BGzZs1CQEAApk+f3mGaYWfn2rVrCA0NxZMnTxAbG4szZ85gyJAhlGwAGfhDQkICdu3ahYaGBp6OErIOWej2hD158iTMzMxgbm6OmTNnIj4+HlVVVbC2tsbs2bNJ1wNax/s7MrkeOXIk3rx5Q5oO3bYUhw4dwooVK2BlZUV5qMOaNWvg5OSEgoIC3Lt3Dw0NDYQP4evXr5GcnIzQ0FC4ublRug4qaV+ooHOyRFpaGoaGhlizZg1iY2Ph6+sLJycnSgpvO3fuhJmZGTQ1NdGzZ09wOBy8f/8eY8eOhZOTEzIyMhATE0OqnQsA9O/fn9R76H+DjvRWOgpSdOzxBw8eTGmgQUdUVVXhyJEjePz4MXFo1R6q9lR2dnbYsGED/vnnH5iammLAgAHYvXs30tPTERoaSokmU3gjkeLiYgQEBEBAQADXr1+Huro6BAQEoKysjNLSUsp0a2pqkJqaisLCQggICEBRURGampo8m7Rvof3onL6+Pnbs2IGdO3di/PjxEBAQwF9//YVdu3Z1ehNWDw8PWFhYQExMjLjWvXt3jBkzhjJNd3d3onvQ3d2d7ybGO3fuhJWVFV68eAEHBwdISUlhz549ePLkCQ4dOkSptoaGBvFnLS0taGlpka6hr6+PyspKBAcHQ0BAAPb29pg8eTKA1v/vqKgoLFmyhNTC+NcYsJaXlyMuLo6WlEyG/05HN3zv379HSkoKpk6dSpqOsrIyYmJiiA18WVkZ1zg0i8WCmJgYvLy8SNNsj5CQEJGKRiUeHh5ISUnB27dvIS8vD3NzcyxZsoSvYUH8JjMzE5s3b4aWlhbu37+PlpYWNDc3w8HBAc3NzZR56DFQi5+fH5YsWQJDQ0NS77/aQ7cnbFlZGZYtWwYRERGw2Wzk5uZCQ0MD9vb28PT0JNWGo41BgwYhJyeHp3vm2rVrpI4h0WFL0Z6KigoYGxvzJUl10aJFqK+vR3R0NAQEBODn50f8O48cOYKYmBiYmppiyZIlpOj9L+mWVB5clpWVobi4GBMnTkRtbS3lYQcAkJWVhaSkJFy8eBHNzc3Q1NSkzD9KSkoKcXFxuH37Nh49egRBQUGw2WziPnPs2LH4448/uCaWvhV9ff0O9y3ti2BLliwhteOXjvRWOgpSQGtIR1JSEgoKCiAkJIQRI0ZgwYIFlFkYODk5Yffu3bCwsMDQoUN5Ri6psMextbVFTk4Opk6dytcEcCUlJWRmZuL9+/fE566BgQEsLCwoayRiccgc9P7BmTZtGo4ePYqffvoJkydPhr+/P2bOnIlbt25h27Zt+OOPP0jXLC4uhoGBAWprayEnJ4eWlhY8e/YM/fv3R3h4OGkJTJ92YrUfL2h/rbOPzrXvPmvDxMQEHh4epAYqfO/k5OQgOjoaFy9exN27dynRaGhoQFhYGObPnw9ZWVk4OjoiNTUVKioq8PHx4Uv3ZEFBAQBQZsbaEX/88QdiYmJw7do1cDgcPHz4kG/aDN/OrFmzeK4JCwtDRUUFv/32GxEYQib6+voICAggvCi6EioqKliwYAHhKfcjsHLlSmhqasLQ0BDKyspISkrC4MGDERoairNnz+LcuXN0L5HhP6CsrIyzZ8+SalvwvfHLL78gJiYGQ4cOxZ49e9C3b19s2LABr169woIFC3Dv3j3SNc+cOQNvb29s2LABBw4cgIODA549e4YTJ05g+/btpFmcaGtrw8zMDPPnz8fHjx8xbdo0TJkyhStR9OjRo7hw4QJOnz5NimZ7VqxYgU2bNlFmmv61VFRUQEREhNR7sH9LA28PFd7UDQ0NsLOzw/nz5yEgIICLFy/Cy8sL79+/R0BAAKmFqDb27duHlJQUvHr1ChMnToSuri40NTUptWpo48mTJygoKICwsDCGDRuGYcOGUabl7u6OEydOYNSoUcS4eU5ODu7fvw8NDQ3U1dXh9u3bOHDgAGldsT4+Pnjw4MG/prdWVlaS1t13+/ZteHl58bUg9erVK+jp6eHt27dEmOGzZ88gLS2NqKgoSlKWFRUV0dzcDIB/e3xlZWUcPnz4h2hEYDreSERdXR1OTk6QkJCAhIQEpk6dihs3bmD37t2YMWMGJZqurq4YNWoUfHx8iE1ZZWUlbGxs4Orq+tl23P+V8PBwWuPk+UVHdei7d+922PpKNkVFRQBAjPBmZWXh5MmTaGlpgba2docbfjKpr69HSkoKYmJikJubCwEBAcyZM4cyPR8fHyQmJmL69OnIzMzE2bNnsXXrVly5cgXe3t58SaHiV8GtsrISp0+fRlxcHEpLSyEkJIQlS5bA2NiYL/oM5PGloAOqoGPcgF9kZmZ2agPv/0JBQUGHBtBz587l2uQzdC7mzp2La9eufReFt7KyMko2ghMmTEBwcDCcnJzAZrMRFxeH9evXIysrC+Li4qTrAa12EU1NTQgKCsLHjx/h5OQEaWlpWFlZkeorTIctxZ07d4g/a2howNHREZs3b4acnBxPkim/PAL79+9P+mvSkSranqCgIOTn5yM8PBwbNmwA0NqF5+DggL179xKhHWRy/vx56OrqQkdHB4MGDSL99TuioaEBNjY2SEtL42qQmDlzJvz8/ChJ4ywvL8eaNWu4Uk2B1nv8srIyBAQE4Pjx4wgODiat8EZHequxsTGam5thZmbGt4KUp6cnZGRkcOrUKeLf+ubNG1hYWGDv3r3Yt28f6ZrtvX35Rf/+/Sn7/vgSdNg7MYU3Etm5cyf8/Pzw4sULBAUFQUREBNnZ2VBSUoKdnR0lmvfv30dcXBxXJ4SUlBS2bduG1atXk6bzyy+/kPZaDNz8/fff2LRpE3Jzc8FisaCiogJLS0sYGxtj4MCB4HA4MDc3h7e3NxYtWkS6/pMnTxATE4PExERUV1eDxWJh6dKl2LBhA6XGqBcuXMD+/fuhqKgIFxcXTJo0CRs2bMDUqVOxfv16ynT5yZ07dxAdHY20tDQ0NjZCXl4eLBYLJ0+epNQ/j4E/VFZWIisrC3369IGKigqpr0239yO/+NGKbgDQo0cPVFRUYMiQIVzXHz9+3CW7Gn8UbG1toaWlhUuXLnXoiUh28eHly5fw8vJCQUEB0aHQljBaWVlJSTe1paUljIyMEB0djVWrViEoKAiTJk1CXV0dpWnHK1aswIoVK1BZWQkOh0PJiCAdthRtY3rtD313797N87zOPk3yKZWVlSgpKekwGbct3IJMUlJSsHv3bq69zKRJk7Bnzx7Y2tpSUnhLT08n/TX/DV9fX+Tk5ODQoUOYOHEimpubcefOHbi6uuLgwYOwtrYmXTMjIwPx8fE815ctW0YECc2ePZvUgCQ60lvpKEhlZmbi2LFjXAXGPn36wM7OjrIwiWPHjsHGxgby8vKUvH5H2NnZwcXFBVZWVvjpp594fH2pOEQCeO2dmpqa8PTpU5w9e/arbR3+V5jCG4mIiory/Edt2bKFUs1+/fqhvLycZ4a9pqaGVJ8IutvEuzKenp4QEhJCdHQ0unfvjoCAAJiamkJHR4e4GfD09MSJEydIK7w1NTXh0qVLiImJIXwS1NXVMX/+fGzbtg2GhoaUFt2A1rbwtg/2zMxMLFu2DAAgKSlJfHF2Vk6cOIGYmBgUFxfjp59+gpGREbS0tDBy5EgoKirScrLD8G0EBgYiIiICcXFxkJWVxd27d7F+/XrU1NQAACZPnoygoCDSxkjaez8yn6ldi0WLFsHNzQ1ubm5gsViora3FtWvXsGfPHixYsIDu5TH8Rzw8PFBbW4uGhgZKfX3bcHV1RUlJCebPn4/Q0FAYGxujpKQEaWlplBQSAGDEiBFIT0/Hhw8fIC4ujlOnTiEpKQkyMjLQ1NQkTad9J1hHPHnyhPgzmZ1gFhYWHXoVtxX+yO6S//3330l9vc5ASkoKHBwcUF9fTxQd2za/gwYNoqTw1tFBBwDIyMjg3bt3pOmsXbsWAQEB6Nmz57/62lHhZXfu3Dm4urpyjStraGhAUFAQzs7OlBTeJCQkUFxczOMJW1RURBys1dbWkjpiS0d6Kx0FKUFBwQ5/bt26daPMby4rK4syj9Iv8fjxY560aKotrD7ntchms5GYmIjFixeTrskU3kjmr7/+QmhoKGGCOHz4cBgYGEBJSYkSPTs7Ozg7O8Pe3h6TJk2CkJAQcnNz4ezsDAMDA65QhG+pGL98+fKrnldbW/ufNb4X+D1Sm5mZiSNHjhC/I3v27MHkyZO5DLZXrlyJuLg40jRnzJiBmpoaqKqqwsPDAxoaGoRRJ7/inIcMGYLc3FxUVlbi2bNnmD59OoDWU0Kqi35U4+bmhmHDhiEoKIgrEY2hcxIbG4vDhw/D0NCQ6LRwcHCAmJgYYmNjISEhgS1btuDw4cOkBcy0nRQDrZ9JCxYs4BkT+fDhA6mfC0DrqMrNmzcBtBYTRUREkJKSguPHjxNj723pdwz/DUtLS5SXlxOf8To6OuBwOJgxYwasrKxoXh3Df+Xy5csIDAzkm0dXVlYWgoKCMHHiRPzxxx/Q0NCAkpISfH19ce3aNSxfvpwSXVFRUWIzKC0tzbNZIoP2nWD/5i/Mj04wqmwpOhpB/PDhA0pKSiAoKIihQ4fSsgmmkuDgYCxcuBCmpqZYvnw5wsLC8Pr1azg7O1PWrCAvL48bN27wvCfOnTtH2LuQwaBBg4hunYEDB/J9P1FTU0MUotozdOhQVFZWUqKpq6sLJycn/PPPPxg7dixaWloI/7UlS5bgn3/+gbe3N6kFcjrSW+koSKmoqODQoUPw9vYmQl0aGxsRFBQEZWVlSjR1dHTg4+MDc3NzyMrKUjKe/CkeHh5QVVXFihUrvospCBUVFezcuZOS12YKbySSlZUFIyMjKCgoEBX3u3fvYvXq1QgPD8f48eNJ19y0aRMAYPPmzTw3J15eXvD29ialYvxvHkMPHz5EdHQ0UlJS/rPG94KrqyvXh2tjYyP27t3L06VEVhdKdXU1l6eGpKQkREVFuWKwJSQkUFdXR4oe0JrCKC0tjQEDBkBcXJyylK4vsW7dOvz2228QEBCAqqoq2Gw2AgMDERgYCHd3d76vh0zMzMyQmJiITZs2YcSIEdDU1MSCBQu+C+8fhv+dU6dOwd7enhjfz8nJwdOnT7lOPzdu3AhPT0/SCm+VlZVE5+f27dsxYsQIHrPrR48eYf/+/aQlCZaUlMDY2BivXr0C0JriZWVlBVtbW2JEx8PDAy0tLTAwMCBF80dEWFgY+/btw9atW/Ho0SO0tLRAQUGB1A0gA/8RFxfvsKuGKurr64lDqmHDhqGgoABKSkqUFsdLSkrg4uKC7OzsDke9yCqCte8Eu3XrFgIDA+Hg4AAVFRUICQkhJycHHh4elI1b0UFjYyPc3d1x5swZNDY2gsPhoHv37li7dm2XKsg/ffoUBw4cgJycHEaNGoXKykrMmjULTU1NCA4OJi1JtT1btmyBpaUlCgsL0dzcjLNnz+LJkye4dOkSfH19SdNpvy/w9PQk7XW/FgUFBVy4cIHwsWsjNTWVspRyCwsLNDQ0wM3NDfX19eBwOBAVFcXatWuxfv163Lp1C3V1dXB1dSVNk470VjoKUjY2Nli5ciXmzJmD0aNHg8ViIScnBzU1NZR5/6anp6OsrAwXL17s8HEqDjoqKioQGhpKakr1t5CSkkKZ7QdTeCOR/fv349dff4WTkxPXdWdnZ/j5+VHyJqEydvvf6MiMf+7cubSthwwmTpyIv//+m+uasrIy/vnnH/zzzz+UaHI4HJ50HBaLxTPjTiaZmZlITU3FmTNnEBMTAzExMcyaNQvz58/n2wmdtrY22Gw2Xr58CTU1NQDAmDFjcPToUUyZMoUSzZaWFpw7d47YNHzq/0BWMdXKygqWlpaE90VwcDAOHjwINpsNDofTJTpDfySKi4u5fidv3boFFovF1dkyfPhwrg7jb+WPP/6Avb090fXRNordHg6HQ2p3jZeXF37++WfExsaie/fu2L9/P2xsbLB+/XrCUDwkJATx8fGkFt4+fPiAEydO4Ndff+XyMvH394egoCCMjY2/i1NQspGVle2wO4Ghc2JmZgY/Pz+4ubkRHeRUMnjwYBQWFkJGRgZycnLEhqilpYWy75jdu3ejrKwMNjY2lCRBttG+EywkJARubm6E3xrQOmq2a9cu2NvbQ1tbm7J18JP9+/fjwoULcHBwwLhx48DhcHD37l0cPHgQ3bt35ymmdFa6detGHPbKycnh8ePHUFNTw+jRo/Hs2TPSdD58+AAxMTEAwMyZM3Hw4EEcPnwYgoKCCA0NxYgRI+Dr64t58+aRpvk1/Pnnn9i2bRuuXr1K+mtv3LgRmzZtQn5+PlRUVMBisZCVlYW0tDT4+PiQrgcAAgICsLOzg4WFBYqLiyEoKIi6ujrEx8dDTU0Nd+/ehYaGBum6LBYLqqqqUFVV5XmMzETeNugoSMnLyyMhIQFRUVF4/PgxOBwOFi5ciJUrV1JWpKLaIqsjxo0bh4KCAr4X3mbNmsXTtFRbW4t3795RdtjBFN5I5K+//uqwoq+np9fhpokM2kfvVlZWQkhIiFRvt46gy4yfH9CRHshisXiKXVQXvyQkJLB8+XIsX74cxcXFOH36NJKTk3Hu3DmwWCwcP34c69ato7xDi81mg81mE39vK8BRhZeXFyIiIsBmsynfGLFYLKipqUFNTQ3V1dVITk5GfHw8WlpaoKenB01NTejp6TEhC52E9u/J7OxsSElJcXlr1tbWkloc0tbWxqBBg4juMn9/f64TOBaLBTExMSgoKJCmeffuXURERKBfv34AWk9bY2JiuG6a58+fj8DAQNI0379/DwMDAzx+/BiTJk3iKrzV1dUhOjoaf/zxB8LCwjq1N+K/BWS0pyuZqP9IXL58GVlZWVBVVYW0tDTPgRrZfl66urrYtm0bPD09oa6uDn19fQwcOBCZmZmUjUbeu3cP4eHhlI05dURFRQXxmdSenj17oqqqim/roJrExES4u7tz2VOMGjUK/fr1g5ubW5cpvCkpKSEmJga2trYYPnw4rly5AhMTExQVFZE6fTF16lRoaWnh119/xdixY4n7Mbqpr69HRUUFJa89Y8YM+Pv748iRI7h69So4HA4UFBSwf/9+Uj0YO4LFYqGgoICrGWPOnDmkvT7dgVN0FKSA1kMIflkAAdw2J/xi+fLlcHJywr179yAnJ8fzOUDV4YqOjg7P75GwsDBUVFQoS5FmCm8kIikpibdv32LYsGFc19++fUtpS2pkZCSCgoLw9u1bAK2JJyYmJqSNHwHfhxl/V4XD4WDp0qVcHW51dXXQ19cn4uTbkp+oQF5eHnZ2drCxscHVq1dx9uxZJCQkID4+HlOmTMHRo0cp0X379i18fX0/231GhelwYmIiduzYQWoq2dfQq1cv6OnpQU9PD/n5+Th9+jRSUlJw7tw5ZpPdCRg5ciTu3LkDWVlZvHv3Drdv3+Y5JT9//jypRTDg/03DIyIiiBErKnn37h1X4UtcXByioqJchzmioqKor68nTfPo0aOora1Famoqz2mnnZ0dVqxYAWNjYxw7dgybN28mTZfftE/PKisrw5EjR7BixQooKytDWFgYOTk5iIqKwsaNG2leKcN/Zfz48ZRYinyOdevWQUhICCwWC0pKSti8eTOCgoIgIyMDb29vSjQlJSX5XgBXUlKCn58fPD09Ce2qqirs3buX6/CZbKqqqlBVVUUcQKampmLy5MmUdNMArf6aHY0qy8vLo7q6mhJNOjA3N4eJiQmkpKSgq6uLgIAAaGlp4dWrV5g/fz5pOhs3bkRSUhJOnz6N4cOHY9myZdDW1uaycemKaGhoUNJh9jn41YzRPnDq0zRKfsCvgtT3EGZ45coVBAcHc/nVm5iYkFpIbU9b6EdoaCjPYywWi7LCGx3FVBaHzKzdHxxnZ2dkZ2fD19eX8P0pKiqCtbU1Ro0aRcm8/6lTp+Di4gI9PT1MmDABLS0tuHPnDmJiYuDk5ERap920adMIM35NTU0uM35FRUUkJiYy/jT/kYCAgK9+Lr82npWVlUhMTER8fDySk5Mp0TA3N0dWVha0tbU7HFmh4t+qrKyMxMREvvrwfI7GxkZcuXKl049n/wgkJycTn6f37t3Dw4cPERcXh9GjR+P169dITk6Gr68v3NzcKPGnAYD8/HwUFhYSRXgOh4OGhgY8ePCANE9ENpuNzMxMIkACaH3PJCUlEUWxN2/eYPr06aQVjOfNm4dt27Zh9uzZn31OcnIygoKCkJqaSoom3ejr62PJkiU8389JSUkIDw/HmTNnaFoZA8OXOXr0KLKysrB3715KR03b8/jxYxgaGuLjx49cCYbS0tKIiIj4puCwz5GTkwNTU1Po6urCzs4OQOu4YmNjI8LCwkg/ZAFaN9GvXr2Cj48PcVjP4XCwa9cusFgsODs7k65JFxUVFWhoaMDgwYNRXFyM6OhoyMjIYO3ataR7Dufk5CAxMRGpqamoqanBrFmzsHz5ckydOpVUna8lIyMD69evJ+07NCEh4aufS1YB49+aMRISEijfE/K7MA7wpyD1v/hzUjGllZ6eji1btmDOnDlcdYUrV67g4MGDX7xX64zcv38fJ06cQGFhIQQFBaGoqAhDQ0OuiRYyYQpvJFJdXQ0jIyM8evQIPXr0AIvFwrt376CgoIBjx45xdRKQhaamJtauXUuYfrcRGRmJmJgY0oomY8eOhbS0NNTU1DB16lSoqakRAQRM4Y3hvzBu3DgEBgby9eZn69at+OWXX/je8cbQ+Tl9+jSio6MhICAAU1NTomDq6uqKmJgYmJqakhas8CkRERFEca3N863tzxMmTCDt5mvUqFHIzMzk+q5SUVFBYmIiZYW3sWPHIjU1tcN0vzZevHiBRYsW4f79+6Ro0s3YsWORlJTE4+/29OlTLFmyBA8ePKBpZQzfSn5+PsLDw1FSUoIDBw4gPT0dw4cPJ8JJvpWAgACYmJige/fu/3poR8Xhlb6+Pu7fv4/m5mZIS0vzTHNQ0akOtKY1njt3Do8fPwbQ+lmlpaVFmfejnp4ehg4dip07dxL/xubmZuzcuRPl5eUICwsjXdPa2hqXLl1Cr169oKSkBCEhITx8+BClpaUYO3Ys18+aTn/nb2X79u1wdHTksfuoqqqCo6MjqVYG7WlqasLVq1eRkJCAa9euoW/fvtDV1cXSpUshIyNDiWZHkF14a2/X8iW+NWSvPXQ3Y3ypMH7s2DFKiiY/SkFKR0cHGhoaMDc357oeEBCAq1ev4vTp05Rpl5WVobi4GBMnTkRtbS3XITAVXL58GZs3b4aSkhKRyHv//n3k5+fj2LFjmDBhAumazKgpifTq1QunT59GRkYGYYLYlnDaNjJINmVlZZg2bRrP9enTp8PLy4s0ne/BjJ+hayEmJsbXmx2gNbzB29sbN2/ehLy8PM/JamceZWOglmXLlnXYQWxqagpzc3NKT1lPnjwJMzMzmJubY+bMmYiPj0dVVRWsra1JvdnjcDg8hXAOh0NpV2bv3r3x9u3bLxbe/vnnH7511/CDIUOG4Ny5czw3trGxscwBVicmLy8Pq1atwrhx45CXl4eGhgY8evQI7u7uCAgI4PLu+q/Ex8djzZo16N69O+Lj4z/7PBaLRcn32S+//EJaEfF/QUJCAgsXLsSTJ08gLCyMwYMHUxq48tdff8HDw4Or2CUoKIj169dDV1eXEk0REREsXLiQ69rEiRMp8xriJ9nZ2Xjx4gWA1g4tRUVFnsJbcXExbty4QdkahISEiDHM6upqXLhwAbGxsQgKCsJff/1FisbXTLCQGSABtBb7+c379+8hLS2NAQMGQFxcnPQuxX/D29sbc+fO5TLAT0tLg5OTEzw8PCgpjAcGBmLz5s1c39uGhoYICAhAUFAQZYW3pqYmvH37Fs3NzQC4px2oGMEsLi6Gn58fz/WFCxciJCSEdD2gdczezs4O58+fh4CAAC5evAgvLy+8f/8eAQEBlN3/+fr6wsTEhBh1bcPLywt79+5FbGws6ZpM4Y1kBAQEoK6uTmrS3JcYOHAg8vLyeEbncnJy0KdPH9J0vhczfoaug7a2NkJDQ+Hi4kJZYfpToqOjIS0tjYcPH+Lhw4dcj5G5UTl58iS0tbX5kmzHQC/9+/enXKOsrAzLli2DiIgI2Gw2cnNzoaGhAXt7e3h6epLm50mVX8iXUFVVRVxcHJSUlD77nNjYWIwZM4aPq6KWrVu3YuvWrbh58ybGjBlDpBc+evSIshtbBurx8fGBsbExrKysiPABV1dX9OjRg7TC2+XLl4k/h4aGYujQod/8mv8LdBxOcTgceHt74+TJk2hqagLQaoC9YsUKODg4UHL4KyEhgefPn/P4TpaXl0NUVJR0PYCez19+wWKxYG9vT/y9oyA6MTExmJiYUL6WyspKpKam4vz58ygoKICKigppr/2lYnh7qD50fvLkCQoKCiAsLAx5eXnSPyfobsboqDAuJCREaWGcjoLUzZs3YWtrS3i4t0dUVJSSwlu/fv3w9OnTDjvyqSqABQUFEd3ibSEya9euhYODA/bu3QsXFxdKdJ8/f46lS5fyXF+xYgWioqIo0WQKbyTy7Nkz7NixA3l5efj48SPP41SYqK9cuRLOzs6oqqriio729/f/n+bE/xfoMuNn6Fq8efMG58+fx5UrVzBkyBCekRUqRinab1qoZO/evUTrffskJgaG/4K4uDix4ZSTk0NRURE0NDQgLy+P0tJS0nToSLMyMjLC8uXL0bNnT2zYsIEryKG6uhrBwcFITEzE8ePH+b42qpgzZw4iIyNx8uRJXL9+HUDr6JyLi8tXjw0xfH/k5eVh165dPNdXrVqFmJgY0vX09fVx6NChLxatqYDqcdpPOXLkCM6cOQM7OzuuEa/AwED0798f69atI11z3rx52L17N5ydnaGkpAQWi4Xc3Fy4uLhQZjAOtBb2IiMjCQ+pESNGYMWKFZT42PETFRUVojOrIy9Rqqmrq0N6ejqSk5Nx48YNSEpKQkdHB+7u7jwFhm+BX/eYn6OhoQE2Nja4dOkScY3FYmHmzJnw8/MjLeiP7mYMOgrjdBSk9u/fj9GjR0NfXx+bN2+Gj48PysrK4O/vT1mhfuHChXB2dsauXbuIsKDs7Gy4uLhQloybkpKC3bt3c32HTJo0CXv27IGtrS1lhTdFRUXcvHmT5/c0Ly+P8OonG6bwRiI7duzAmzdvYGFhgV69evFFc+3atSgtLYW7uzvRhiooKIjly5dTno4mKCiI2bNnY/bs2Vxm/AwMX4OgoCDPWAW/uHPnDoqLi7Fw4UKUl5dDVlaW1Fb5Xr164cCBA5g0aRI4HA7Onz//2e43qtJ6GLoOEyZMQHBwMJycnMBmsxEXF4f169cjKyuL7wmDZMNms7Fv3z5s374dERERGDp0KHr27Imqqio8ffoU4uLi8PT0pMRrg05UVFRI7bRgoB9hYWHU1NTwXC8rK6NkLFJERITypONP4cc47afExsZi165d0NLSIq79/PPPkJKSwsGDBykpvFlbW+PFixcwNjbm6uCZM2cOtm3bRroeABQWFkJPTw+ioqJQUlJCc3Mz4uPjERkZiejoaMrMvvnNjBkzUFVVRXnhrbm5GdevX0dycjJ+//13NDY2Ql1dHQcPHoS6ujoEBAQo1acDX19f5OTkICgoCBMnTkRzczPu3LkDV1dXHDx4kGekjgzoaMagozBOR0GqoKAAp06dwsiRI/Hzzz9DTEwM+vr6EBMTQ2hoKCXptRs3bkRhYSHMzMyIzz4OhwN1dXVKfn+A1rCVjkLvZGRk8O7dO0o0AWDx4sXYu3cvSkpKMGnSJAgJCSE3Nxfh4eFYsWIFV3AJWXs1JlyBRMaOHYvIyEiMHj2a79o1NTV48uQJAGDYsGGQkJDAmzdvSB03ZWDo7NTU1MDExAQPHjwAi8XCpUuX4ObmhqdPn+L48eMYMGAAKToJCQlwd3fHu3fvuMzwP4VMs1uGrsvjx49hZGQEQ0NDrFq1CosWLcK7d+9QV1cHExMT/Pbbb3Qv8Zt5+/YtkpKSkJeXh6qqKkhJSUFZWRnz58+n1D+PDlpaWnDu3DlkZ2ejsbGR5/OhK4+cdWV27tyJFy9ewNfXF7NmzUJSUhIaGhpgaWmJMWPGkJY+3Iafnx/i4uKwZMkSyMrK8nR6UHGoY2hoiLFjxxLjtG2Jx15eXvjzzz8pSeQdO3YskpOTeTZmz58/h5aWFnJzc0nXbKOkpIRrZI9KO5V169ZBTEyMK9W0vr4etra2qK+vx+HDhynT5icTJ07E2bNn8dNPP1GqM3nyZCL1cunSpdDR0enykwfTp0+Hq6srj93RlStX4OzsjKtXr/JlHe2bMcgK+WtPXV0dLC0tce3aNZ7CuIeHByUHkvX19bCyssLly5d5ClJ+fn6UHK4oKyvj3LlzGDRoEBwdHaGgoAADAwOUlpZCR0cHf/75J+mabRQXF6OgoAAAMHLkSMo6wABAV1cXK1euxPLly7m+VwICAnD58mXKmnroCCZhCm8kMmPGDISEhPD1VKqjFDoAePnyJRYtWoR79+7xbS0M/w02m/3VnghdrUhTWVmJkpIStLS0AOA2Df3UeJwMXFxc8PDhQ+zduxeLFy9GUlISGhsbYWNjAzk5Oezfv590TTabjevXrzNFcIZv4uPHj/jw4QOkpKTw9u1bJCcnY8CAAZSdtDJQh4eHByIiIsBmszvshCUrpZaBv9TU1GDdunV48OABOBwOevTogffv32PUqFE4duwYevfuTarelzYNVB3qTJgwAadOncLQoUO5NkjPnz/HkiVLKLnnXLJkCVauXIlVq1ZxXY+KikJ4eDguXrxIuiYdKCsrIzY2FgoKClzX8/Pzoaenh6ysLJpWRi7u7u54/fo1zM3NISsrS9r446ds374dy5YtI7qTfgSUlZVx9uxZngLx06dPsXjxYuTk5NCzMIp4+vQpMZZNRWG8I7/m4uJiFBYWgsPhUF6QWrVqFebNmwdDQ0McPXoUOTk58Pf3R3Z2NjZu3Ehp4Y2fXLlyBZaWlvj1118RFxeHdevW4cmTJ7h06RJ8fX0xb948SnTfv3/P9+AuZtSURPT09LB//374+PhQOv5z+vRpJCUlAWgtVJibm/OMyb1+/ZrLK4fh+8Xd3f2HTIZNSUmBg4MD6uvria6wtp/DoEGDKCm8XblyBfv27ePyhRg2bBh27dpFGHqSze+//06cslZWVkJISIh5b3ZCGhoacPPmTQCtJ+kiIiJISUnB8ePH0dLSAm1tbcp8NYFWI93y8nJkZWVBQEAAc+fO7fS+Pz8qiYmJ2LFjB9asWUP3UhhIREJCAjExMbh58yYePnyIlpYWKCgoQE1NjZLveDrSDPk9Tgu0+kA6OTnh5cuXXF7GkZGRsLW1JU2nvR/rvx2IUlHUFBcXR0NDA8/1jq51ZtLT01FWVvbZgilZP9sfsXNYQUEBFy5c4LmfTU1N5XsQCz+Qk5OjtAv1U7/mzMxMyMvLU1psa4+pqSk2b94MERERaGlpwd/fH+vXr0dBQQFUVVVJ05k1a9ZXfUexWCykp6eTptvGzJkzcfDgQRw+fBiCgoIIDQ3FiBEjKC26Aa1d4f7+/lBUVKRM41OYwts38ukva2lpKX755Rf07duXxz/g999/J0VTQ0MD2dnZxN8HDBjAM2KgoKDAeEd1EqhK4PneCQ4OxsKFC2Fqaorly5cjLCwMr1+/hrOzM7Zs2UKJZmVlJfr27ctzXUJCAnV1dZRoDho0CJGRkQgKCiKSifr06QMTExPS0igZqKWkpATGxsZ49eoVAGDw4MGwsrKCra0tYQbr4eGBlpYWGBgYkK5fU1OD3377DRkZGcRYIovFwoIFC3iSvcikrKwMPXv2hISEBG7duoVLly5BRUWFNm/GrkJ9fT2mT59O9zIYSGDt2rVffDwjIwOhoaEAqAkMAlrfp8XFxZg4cSJqa2spHafT0NDAvn374OvrS1wrLi6Gm5sbZsyYQYmmtrY2qqqqcPToUeJnKS0tja1bt0JPT480HXd3d6L7gY4DUVVVVXh7e8Pf35/ojqysrISPjw+pm2y6oer+jqHVn2vTpk3Iz8/nKlKnpaXBx8eH7uV1Oj71a05NTeWrX/OsWbNw6tQpCAoKQkZGBqGhoQgLC8Ps2bOxdetW0nR0dHS++HmXlJSE58+fU3rYq6amBjU1NcpevyPq6+spC+P4HMyo6Tdy8ODBr/5ypiKGffv27XB0dPzsBwFD5+Py5csoKCggwjIAEOOX4eHhNK6MXMaMGYPExEQMGzYMBgYGMDExgZqaGi5duoTg4GBKZvr19PQwffp0mJmZcY3J7Nq1C48fP6YkPvrUqVNwcXGBnp4eVyJbTEwMnJycsGzZMtI1Gchlw4YNEBQUxK5du9C9e3fs378fsbGxWL9+PSwtLQEAISEhOHfuHBITE0nX3759O7KysuDk5ARlZWW0tLTg7t272LNnD+bMmQN7e3vSNdPS0mBlZYXg4GDIyspi/vz5GDx4MF69egVbW1umW+sb2Lp1K3755RfmZ9gF2L59O8+15ORkzJo1i2fygewOnIaGBtjZ2eH8+fMQEBDAxYsX4eXlhffv3yMgIICSEZqOxmlramrAZrMpGaf9lMrKSnA4nC7p1VVeXo6VK1eiuroacnJyYLFYKCkpQc+ePXHy5EmeBEcGho5IT0/HkSNHiHFIBQUFmJiYMLYU/4Ef3a+5rKwMO3bswI0bN/Drr7/Czs6OsnpDfn4+CgsLO7QeItsftY2goCAkJydjzZo1GDJkCE8RbuLEiaRrMoW3LgLVKY0M/MHX1xeHDx9Gv3798Pfff6N///548+YNmpuboaWl1aVOrCZMmICzZ88Sha8hQ4bAxMQEZWVlWLRoEVdXJ1ncvXsXRkZGmDx5MjIzM7Fo0SIUFRXh4cOHCA0N5YqyJgtNTU2sXbsWq1ev5roeGRmJmJgYSoxnGchl0qRJhCcXANTW1hJeR21hOi9fvsTChQtx//59SvQDAwN5bgJu3rwJa2tr3Lhxg3RNHR0dqKmpwcLCAiEhIThz5gwuXLiA8+fPIyAgAOfPnydd80chJCQEAQEBmD59OuTl5Xm+q6k4pGPgH+0PdajkwIEDuHDhAnbv3o0NGzYgKSkJr169goODA6ZMmQIXFxfKtD8dp50+fTqlKZGlpaV48OBBh2OXZHWaBAQEfNXzWCwWJVYYQOt3S2JiIh4/fkwUTRYtWsR3HyKquXLlCoKDgwl/ruHDh8PExISyREqGzk9lZSWPnzk/YbPZyMzM5GvR/+PHjwgJCUFeXh4+fvzIU/ijqosaAOLi4uDt7Q0JCQns2bOH0i79iIgIorjWvsDJYrEwYcIEynxv6fBJZUZNSeb+/fs4ceIECgsLISgoCEVFRRgaGlIWuNB2+nj//n2wWCxMnToVPj4+pKc0MvCHxMRE7Ny5E2vWrMGMGTMQFRUFMTExmJubd7nTTiUlJcTExMDW1hbDhw/HlStXYGJigqKiIsqKxioqKoiNjUVoaChkZWVx//59jBgxAo6Ojhg7diwlmmVlZZg2bRrP9enTp8PLy4sSTQZyeffuHdcNn7i4OERFRbm8+kRFRVFfX0+JvqCgYIcbrz59+qCxsZESzeLiYgQEBEBAQADXr1+Huro6BAQEoKysjNLSUko0gR9jvDU6OhrS0tJ4+PAhHj58yPUYi8ViCm8MX0VKSgp2797NdWA0adIk7NmzB7a2tpQW3iZPnozJkydzXQsPD6dk1P7MmTNwcnLimgJog8VikVZ4+9oueyoLb+Li4sQhXWNjI/Lz8yktaNJBeno6tmzZgjlz5kBLS4uYArCwsMDBgwcxe/ZsupfYqQgICICJiQm6d+/+r8XjzvzdoqmpiYSEBAwcOJCWaa8ZM2agqqqKr4U3Z2dnpKamYurUqXzz9C0vL4ejoyMyMzOxdOlSbN++nfKf88mTJ2FmZgZzc3PMnDkT8fHxqKqqgrW1NaWfB2RZgP0vMIU3Erl8+TI2b94MJSUlTJkyBS0tLbh//z50dXVx7NgxTJgwgXTNthTGtLQ0LF68GACwbds22NjYwNvbm5KURgbqePPmDREDzmazkZOTA01NTVhZWcHR0REWFhY0r5A8zM3NYWJiAikpKejq6iIgIABaWlp49eoVFixYQJkum83G3r17KXv9Txk4cCDy8vIwZMgQrus5OTlM0mknQlBQkOcavzyAjIyMsGfPHhw4cID4nampqYGfnx+pHkft6dmzJ96/f4+amhrcv38fxsbGAIDnz59TNk726XjrunXrMHjwYMTHx6O6urrLjGZevnyZ7iUwdAEqKip4vlcAQEZGBu/evSNV69ixYzh37hwEBQWxZMkSrvfi48eP4ejoiNzcXEoKb0FBQdDV1aV0zAmg/3356tUrODo6wtLSEiNHjsTSpUtRXFyMnj174vjx4xg1ahSt6yOLwMBAbN68mat4aWhoiICAAAQFBZG20f43/8X2UNk5RDXx8fFYs2YNunfv/sXicWc/1GlsbERhYSEGDhyIhIQEUoNVvobs7Gx069aNr5ppaWnw8/PDzJkz+aJ36tQpeHp6okePHggJCeGbF21ZWRmWLVsGERERsNls5ObmQkNDA/b29vD09KTMD3vQoEEAWu+nnzx5AmFhYQwePJjS7xmm8EYivr6+MDExgbW1Ndd1Ly8v7N27F7GxsaRr0pHSyEAdvXr1Qm1tLQBAVlYWRUVFAFqLNxUVFXQujXRUVFRw8eJFNDQ0QFJSEtHR0YiKioKMjAxl6ZAd+fEArTckwsLCGDBgADQ1NUlNf1q5ciWcnZ1RVVXFZXbr7+9PaQomA3mwWCyeIhs/jbevXr2K3NxczJ49G3JychASEsLTp09RW1uLR48eESnXAHkneOrq6nBycoKEhAQkJCQwdepU3LhxA7t376bMRP3QoUMwMTHBlClTEBISgoEDByIlJYUYb+3Mhbe3b9/+60l5Q0MD0tPTKT14YOg6yMvL48aNG1i+fDnX9XPnzmH48OGk6QQEBCAgIAC//PILunXrBg8PDwgKCmLlypUIDQ2Fn58fxMTEKEuRfP36NYyNjWnxMs7IyCDGIUeMGAFVVdUOD2HIwMPDA+/fv4eUlBQuXryI0tJSREZG4vTp09i7dy/CwsIo0eU3xcXF8PPz47m+cOFChISEkKbTtqnu6rQvGNNdPKaSWbNmYcOGDcS919SpUz/7XCpGBHV0dODj4wNzc3PIyspSFmrVHhaLRepn+edo63K7ceMGli5dCnt7e75+3oqLi6OpqQlAa1JtUVERNDQ0IC8vT+mEBYfDgbe3N06ePImmpiZwOByIiIhgxYoVcHBwoOQ+nym8kcjz58+xdOlSnusrVqygxLQdoCelkYE6Jk+eDG9vb7i6umL06NEIDg7G6tWrcfHiRVq9Dahg6dKlcHd3J2bshw0bhh07dlCq2djYiJSUFPTt2xdjxowBADx8+BDl5eUYO3Ysbt++jeDgYISFhWH8+PGkaK5duxalpaVwd3cnRmUEBQWxfPlybNq0iRQNBmrhcDg8N3kcDgdz587li/6UKVMwZcoUvmi1sXPnTvj5+eHFixcICgqCiIgIsrOzoaSkBDs7O0o06Rpv5QfTpk3D9evXuYpv1tbWcHBwIK69e/cO1tbWTOGN4avYsmULLC0tUVhYiObmZpw9exZPnjzBpUuXuFJHv5Xk5GRs3bqV+L5KSEhASEgI/v77bwQGBkJTUxNOTk6U3aOw2Ww8e/aM1AOxf+Pdu3cwNjZGXl4eevbsiZaWFtTU1EBRURHHjh3jshkgi1u3biE8PBw//fQTfH19oaamBhUVFUhKSkJXV5d0Pbro168fnj59CllZWa7rT58+JdXLjqpCMAM9eHp6YsGCBXj37h22b98OBwcHvnofpqeno6ysDBcvXuzwcSqKfXPnzsWZM2eIEC+q0NLSwocPHzB48GA0NzfDzc3ts8+l4n01YcIEBAcHw8nJCWw2G3FxcVi/fj2ysrJ4QorI5MiRIzhz5gzs7Oy4wu8CAwPRv39/rFu3jnRNpvBGIoqKirh58ybk5OS4rufl5UFeXp4SzTFjxiA1NRVmZmZc1yMiIvDzzz9ToslAHTY2NtiwYQMuXryI1atX49ixY8SGn6rNLl2UlpZCTEyMr5qioqKYN28evL29idOqpqYm7NixA927d8euXbvg4+MDPz8/0sw8BQQEiDHhJ0+eAGgtMjJJxJ0Hum/g6RgPERUV5UlL3bJlC6WadIy38ouOcqwuX74MS0tLrmIck3fVueioi7qxsRF79+6lPNV05syZOHjwIA4fPgxBQUGEhoZixIgR8PX1xbx580jTKS8vx/z584m/L1iwANu3b0d4eDg8PT1J81j7HMbGxnB2dsaLFy8wbNgwnk4TKpLnvLy8UF9fj6SkJCgoKABoTd2ztbXFvn374OzsTLpmY2MjevXqBaA1vKLNWqSlpQVCQl1nu7Zw4UI4Oztj165dxAFndnY2XFxcKE3erKysRElJSYepiVR59vEDNpv91Z05nTl5U1hYmBhDLi0txa+//oru3bvzTZ/q+5822n+n1NbWIj4+Hjdu3MDQoUN5/B7J+k5pXy94+fIlKa/5v2BpaQkjIyNER0dj1apVCAoKwqRJk1BXVwcTExPKdGNjY7Fr1y5oaWkR137++WdISUnh4MGDlBTemFRTEomJicHevXuxdOlSTJo0CUJCQsjNzUV4eDhWrFjBFbBA1o0KHSmNDNRTX1+Pbt264ePHj8jIyED//v0xZswYvo63Uc3Ro0dx7do1mJiYdBjjTIWR6IQJExATE8PTul1cXIyVK1fizp07ePr0KXR1dXH37l3S9RkY/iv5+fkIDw9HSUkJDhw4gPT0dAwfPpzUz3i6TZodHR3x+PFjSEhI4NGjR7h27RqysrKwe/duqKqqUmoWTzUdJaJ9mn755s0bTJ8+vVNvjn40/he7ALKT2e7cuQNlZWWeokx9fT2uXr1KWvHtc7+7NjY2fBn/piN5TlVVFQcPHuQp6v3555+wsrJCZmYm6Zpr1qzBpEmT0K9fP7i4uODKlSuQkpKCk5MTSktLKUv24zf19fWwsrLC5cuXiXtaDocDdXV1+Pn5UVJMSUlJgYODA+rr64nUxDbtQYMGIT09nXRNfhEfH0/8W8rKynDkyBGsWLECysrKEBYWRk5ODqKiorBx40ZKixj8pry8HJGRkVyj4MuXL+/0I8Z0fqfQycePH/HhwwdISUnh7du3SEpKgoyMDKXF+LFjxyI5OZnHK/X58+fQ0tJCbm4u6Zpd5wjlO2D37t0AWrvNPjXqDA0NJf5MZgpTW0pjWFgY31IaGahj9uzZOHPmDNHdISoqijlz5qCiogKqqqq4ffs2vQskER8fHwCtm4f2BcW2GyJKYpyFhPDmzRuewtvr16+JNTQ3N3ep02WGzk9eXh5WrVqFcePGIS8vDw0NDXj06BHc3d0REBBAmvEu3SbNdIy3MjB8C3RufNauXYvMzEyeEc+ioiLY2tqS2vXWEfwaf6cjea6pqanD0VlpaWnU1NRQomlnZ4cNGzbgn3/+gampKQYMGIDdu3cjPT2daw/R2enWrRsOHTqE4uJiFBYWgsPhYOTIkZRNBgFAcHAwFi5cCFNTUyxfvhxhYWF4/fo1nJ2d+dbJRBXtx5D19fWxc+dOLFu2jLimoaGB4cOHIzw8vMsU3goLC6GnpwdRUVEoKSmhubkZ8fHxiIyMRHR0NFejC5lcu3YNoaGhePLkCWJjY3HmzBkMGTKE1K7frlRM+18QFRUlGjCkpaVhZGREuaacnBwyMzN5Cm/Xr1+nLEWW2V2SSH5+Pi26bDYb3t7etGgzfDupqanIyMgA0No+7eLiwpOcU1pa2qW63QB6UqTmzZsHJycn7N69G2PHjgWHw8H9+/exZ88ezJ49Gx8+fEBQUBDh/8bA8D3g4+MDY2NjWFlZQVlZGQDg6uqKHj16kFp4+1qT5rZRHbKhY7yVgaEzcfz4cXh5eQHo2HuyDSUlJcrXwq8DKjo6WBQVFREdHc3jOxsVFUVZuqiSkhIyMzPx/v17wkPOwMAAFhYWkJSUpESTn1RUVCAtLQ0iIiJQU1ODvLw8pcW29jx9+hQHDhyAnJwcRo0ahcrKSsyaNQtNTU0IDg7GkiVL+LIOqsnJyYGrqyvPdSUlJSKsrSvg7e0NVVVV+Pj4EKPn9fX1sLW1hY+PDw4fPky6ZmZmJjZv3gwtLS3cv38fLS0taG5uhoODA5qbmzv0eCeDmpoapKamorCwEAICAlBUVISmpibfE1bJ5ntIHTYyMoKTkxNevnzJFX4XGRlJWWouU3jrhEyaNAkXLlzgOo17+fIlZGRkKEtbYqAOZWVlxMTEEN4+ZWVlEBYWJh5nsVgQExMjbra7Cn/++Scx1taempoaHDhwAJMmTSJdc/v27di2bRuMjY2JQiaLxYKmpiaR6HPnzh1KvrQZGP4reXl52LVrF8/1VatWISYmhhLNT7tv26ioqMDixYtJ676le7yVn3S1wxMG/qOnp4fevXujpaUFDg4O2L59O5fBeNv9gqqqKqm6YWFhXN/VTU1NiIiIIDzJ2qDiPfpvGzQqNmWWlpZYu3YtHjx4wLUhy8/PJzV589O0YxaLxRXcMHToUDQ0NCA1NbVTh65kZWXB1NSUCH0TFxfHgQMHMG3aNL7od+vWjbivlpOTw+PHj6GmpobRo0fj2bNnfFkDPxgyZAjOnTvH41kXGxvLl3RMfpGdnY3Y2Fguv8du3bph06ZN0NPTo0Tz4MGDsLa2hqGhIRGwYGVlhZ49e+LYsWOUFN6Ki4thYGCA2tpayMnJoaWlBXFxcTh06BDCw8MxYMAA0jX5RUcHKsnJyZg1axalgQrt0dbWRlVVFY4ePUp0FUtLS2Pr1q2U/R4xhbdOyLt373gMmBcvXozExETCK4ah8yAjI0PcOOrr6yMgIIDnZrarUFxcjMrKSgBAYGAg2Gw2z7+1sLAQcXFxcHR0JF1fVFQU/v7+ePHiBR49egRBQUGMHDkSP/30EwBATU0N165dI123PZWVlfjzzz+hqKjIvF8ZvgphYeEOx5vKyspI9cOho/uW7vFWfuLq6sr18/zUhL++vp6upTF0EoSEhIixpvLycmhqaqJfv36Uag4cOBDnz5/nuta3b1+eEVCq3qOfbtAaGxvx/PlzFBYWwtDQkHQ9oPVANDIyEmFhYbh+/To4HA4UFBSwY8cOjBs3jjSdHyXt2N/fH6qqqnB2doagoCBcXFzg6emJc+fO8UVfSUkJMTExsLW1xfDhw3HlyhWYmJigqKiI66C7s7N161Zs3boVN2/exJgxY8DhcHD37l08evSI1IIx3YiLi6OhoYHnekfXyKKgoKDD6bK5c+fC39+fEk1XV1eMGjUKPj4+xF6psrISNjY2cHV1/dfDyu+ZjoIhLly4AFtbW77ujQwNDWFoaIjKykpwOByuz2IqYApvXQQmI6Nr0Dbb/+TJExQUFEBYWBjy8vIYOnQozSsjhxcvXmDDhg3Exv1zN+lUtWzr6upi6dKlWLhwIebOncvz+KdpaWRQWFiILVu2wNXVFWw2G4sXL8abN28gIiKCI0eOkN6ZwEA9ZWVl6NmzJyQkJHDr1i1cunQJKioqWLhwISV6Ghoa2LdvH3x9fYlrxcXFcHNzw4wZM0jToaP7lu7xVn4xceJE/P3331zXlJWV8c8//+Cff/4hrk2YMIHfS2PopBw/fhzz5s2jvPD2pfclP/hccp+/vz/evn1Lma6SkhL8/Pwoe33gx0k7fvToEaKjo4nfVQcHB8yYMQM1NTV8SXg3NzeHiYkJpKSkoKuri4CAAGhpaeHVq1dcib2dnTlz5iAyMhKRkZG4fv06AGDUqFFwcXH5YkhJZ0NVVRXe3t7w9/cnuvIrKyvh4+ND2T11jx49UFFRweMH9vjxY8qaJe7fv4+4uDiu15eSksK2bduwevVqSjR/BDgcDlJSUjBjxgzi80dKSgqRkZEQFxfH4sWLeRJkyYIpvDEwfEc0NDTAxsYGly5dIq6xWCzMnDkTfn5+lBSG+MmMGTNw+fJltLS0QENDA6dOneIamW7b2H863kYWU6ZMQUhICLy8vDBr1iwsXboU06ZNo3QEzMvLC7Kyshg2bBjOnz+PpqYmXLt2DVFRUfDz86NsVJCBGtLS0mBlZYXg4GDIyspi3bp1GDx4MOLj41FdXU1Jyp+dnR3WrVuHKVOmgMPhQFdXFzU1NWCz2di2bRtpOnR33/JrvJUOflTDZAbqkJOTQ0FBAd98sr43dHR0sHTpUjg7O5P+2hwOB2fPnkVeXh4+fvzIU/j6XDGQKjr7mHptbS3X53r//v0hLCyM6upqvhTexo8fj4sXL6KhoQGSkpKIiopCdHQ0ZGRk/ievqc6AiooKVFRU6F4GpdjY2GDlypWYOXMm5OTkwGKxUFJSgp49e+LkyZOUaC5atAhubm5wc3MDi8VCbW0trl27hj179lDWjdqvXz+Ul5fzhEXU1NRwjaR/K9+D3xq/aGhowKZNm5CZmYnw8HAuW6Pc3FwkJCQgLS0Nfn5+lHTDMoU3imhoaOj0RRIG/uPr64ucnBwEBQVh4sSJaG5uxp07d+Dq6kr4C3R22pJifv/9dwwcOJCvN5Q2NjawtrbGjRs3kJCQgK1bt6JHjx7Q0dGBtrY2JZ2F9+7dw6lTpyAtLY2MjAyoq6ujf//+WLZsGcLDw0nXY6CWQ4cOwcTEhCjiDhw4ECkpKTh//jwCAgIoKbxJSEggJiYGN2/exMOHD9HS0gIFBQVMnz6dslM5fhWKftRwGQaGb2XEiBGwsbHB0aNHIScnx/O+4XdxiN8UFRVR1gnm5eWF48ePY+TIkaRucH9UWlpaeD7DBQUF+dbJvH37djg6OqJ///4AAHl5eezYsQNVVVWwtLREYGAgX9bBDy5fvoyCggI0NzcT1xoaGvDgwYMuc885YMAApKSkIDExEY8fPwaHw8GyZcuwaNEiLs9LMrG0tER5eTkxkaOjowMOh4MZM2bAysqKEk07Ozs4OzvD3t4ekyZNgpCQEHJzc+Hs7AwDAwOUlZURz/2WFE46AmzoIiIiAo8ePcLJkycxfvx4rsc8PT2xbNkybN68GVFRUTAwMCBdnym8kUx0dDRCQkJQXl6Oixcv4ujRo+jbty+pvhcsFovnC4zZlHQNzp07B1dXV6irqxPXNDQ0ICgoCGdn5y5ReGuDrg96FouFqVOnYurUqairq8OJEydw6NAhHDlyBCoqKjAwMOhwDPW/IiAgABERETQ3N+PWrVuEd11tbS0Rnc3QeSguLkZAQAAEBARw/fp1qKurQ0BAAMrKyigtLaVUe/LkyZg8eTJlrz9q1CjCb4jNZn/xe+XRo0ekaP6o4TIMDN/K8+fPiY3Dp2PMtbW1dCyJErZv385z7f3798jMzISmpiYlmgkJCXB3d4euri4lr89APdnZ2Xjx4gWA1v9PRUVFnu664uJi3Lhxg47lUYKvry8OHz6Mfv364e+//0b//v3x5s0bNDc3Q0tLi+7lkYq4uDhfxy2FhYWxb98+bN26FY8ePSIOQKkMrdi0aROAVlue9vdjHA4HXl5e8Pb2BofDAYvF+qZ7sq5+SNOehIQE2Nvb8xTd2pgwYQIsLCwQExPDFN6+d5KTk7Fv3z4YGBjg6NGjAFpPVXx8fNCtWzeYmpqSotNRhDyHw+mwWEDW5oiBP9TU1EBWVpbn+tChQ4lQAoZv5/Xr10hKSkJSUhIKCwuhoqICHR0dVFRUYMeOHbhz5w5p4Q7jxo1DcHAw+vTpg7q6OqipqaGiogL79+8n1aSZgT/07NkT79+/R01NDe7fvw9jY2MArZtgMkek6Wj9d3d3J06L+XUjRvd4KwNDZ6WjrtSHDx8iOjoaKSkpNKyIGl6+fMlzTUREBCYmJjAyMqJEs76+Hr/88gslr/0pP8rBOb+TcVksFuzt7Ym/u7q68jxHTEwMJiYmpOh9DyQmJmLnzp1Ys2YNZsyYgaioKIiJicHc3JwJ8/qPVFRUIC0tDSIiIlBTU4OsrGyH+zQqoGuss7KyEiUlJURHKofDIbomP03M/a90dKDyaeBUG2Tej758+RLKyspffM7kyZM7DNIgA6bwRiJhYWFwdHSEjo4OwsLCALRunnr06IGgoCDSCm8/UmX6R0NBQQEXLlzAhg0buK6npqZ2mYAFOklMTERiYiJu374NKSkpaGtrw9/fH3JycsRzBgwYADc3N9IKbzt37oSVlRVevHgBBwcHSElJYc+ePSgqKiIK9AydB3V1dTg5OUFCQgISEhKYOnUqbty4gd27d5MadEBH1LqOjg7xZxaLhQULFvBYJnz48AFxcXGU6DM+aAwM/zv19fVISUlBTEwMcnNzISAgQGrX9qdUVVWhqqqK+N5MTU3F5MmTISkpSYkeHZ8L06dPx5UrV6Cnp0e51o+QdkxHMq6Kigry8/MBAGw2G5mZmZQnFtLNmzdviIkZNpuNnJwcaGpqwsrKCo6OjrCwsKB5hZ2LrKwsmJqaoq6uDkBrl92BAwcwbdo0vui39x/jl4VVSkoKHBwcUF9fDxaLRXTUAa33pWQV3jo6UOkocIpsJCQk8P79+y8+5+PHj1yHBGTCFN5IpKSkpMNEsgkTJqC8vJw0nfabI4auxcaNG7Fp0ybk5+dDRUUFLBYLWVlZSEtLg4+PD93L6/Q4Ojpi5syZCAwMhJqaWof+WEOHDiXVp0tWVhbx8fFc1zZt2gQHBwcICgqSpsPAH3bu3Ak/Pz+8ePECQUFBEBERQXZ2NpSUlGBnZ0eaDh1R65WVlfj48SOA1tPIESNG8GymHz16hP3798PQ0JAUTTrGWxkYugJPnjxBTEwMEhMTUV1dDRaLhaVLl2LDhg346aefKNHMycmBqakpdHV1ic+7vXv3orGxEWFhYVBQUKBEt7q6Gs+ePeuwCDVx4kRSNAICAog/S0pKwtPTE3fv3oWcnBzPvQJZxaEfJe2Y7mTcGTNmoKqqqssX3nr16kWMmcvKyqKoqAhAa+GzoqKCzqV1Svz9/aGqqgpnZ2cICgrCxcUFnp6eOHfuHN/WwA8Lq/YEBwdj4cKFMDU1xfLlyxEWFobXr1/D2dkZW7ZsIU2HroNWZWVlpKSkYNSoUZ99TnJyMkaOHEmJPlN4I5E+ffrgyZMnPJuiu3fvUh73DrQmrhw5cgQyMjKUazGQR/uN54wZM+Dv748jR47g6tWr4HA4UFBQwP79+ynzMqGT169fIy4uDk+ePIGjoyP+/PNPKCgoUJbSdu3atc/eeJWXl2PAgAEYP378Z2f//yv82DQw8AdRUVGu8RUApN6M0Mkff/wBe3t74pRz2bJlPM/hcDhcHpTfCh3jrQwMnZWmpiZcunQJMTExuHPnDoSFhaGuro758+dj27ZtMDQ0pKzoBgDe3t6YO3cul5l4eno6du7cCU9PT2Lag0wSEhKwa9cuNDQ08IQpfKu3UXs+PSDr168f7t+/j/v37/NokrXpZbp8+UN2djZP+EhXpG1EztXVFaNHj0ZwcDBWr16NixcvQkpKiu7ldToePXqE6OhoYg/v4OCAGTNmoKamhi9pvPyysGrP06dPceDAAcjJyWHUqFGorKzErFmz0NTUhODgYCxZsoR0TX5iYGAAQ0NDyMjIYNWqVVyHKhwOB5GRkQgPD4e/vz8l+kzhjURWrFhBpI8AraeRGRkZOHDgAGndAV/i5cuXaGpqolyHgVw+vZHU0NCAhoYGTavhH8+ePcPy5cshISGBiooKWFlZ4fz583BwcEBoaCglcejr16+Hn58fT3E8OTkZe/bswZ9//km6ZtumoaOiG5mbBgbqCAgIgImJCbp3787VFdERVJ1C8gNtbW0MGjQILS0tMDAwgL+/P5f/TlvQAZldLXSPtzIwdCbaNn2qqqrw8PCAhoYGsQG0tbWlXP+vv/6Ch4cH13tUUFAQ69evpyyIwM/PD0uWLIGhoSGlxRO6u7IYqENHRwc+Pj4wNzeHrKwsX0b26MDW1hZmZma4ePEiVq9ejWPHjhGe4J8eGHZmGhoaEBYWhvnz50NWVhaOjo5ITU2FiooKfHx8SBt7r62t5fLu7d+/P4SFhVFdXc2Xwhu/LKza061bNyLgSk5ODo8fP4aamhpGjx6NZ8+eka7HbyZMmAB7e3t4eHjg0KFDGDNmDHr27Imqqirk5OSgpqYGFhYWmDVrFiX6TOGNRExNTfH+/XvY2tqivr4eZmZmEBISwsqVK2FmZka5/o9i0MrQNfD09ISGhgZcXV2JIpuvry/s7e2xf/9+nDx5knRNMTExaGtrw8nJCUuWLMH79+/h5OSECxcuUJaOxK9NAwN1xMfHY82aNejevTtPV0R7yOyEoIu2DsyIiAioqKhASIja2wQ6xlsZGDor79+/h7S0NAYMGABxcXGuBGB+ICEhgefPn/McXpWXl1OW0l1dXQ1jY2MuL1Z+kZGRgYKCAggJCWHEiBFQVVVlLCI6Ienp6SgrK8PFixc7fLyrHID2798fCQkJqK+vh4iICKKiopCRkYH+/ftDSUmJ7uWRho+PDxITEzF9+nRkZmbi7Nmz2Lp1K65cuQJvb2/SuudbWlp49taCgoJE6ADV8MvCqj1KSkqIiYmBra0thg8fjitXrsDExARFRUV8/76hCj09PUycOBGnTp1CXl4enj59CikpKSxduhS6urqUTV0BTOGNdH777Tds3LgRRUVF4HA4GDZsGF+q4gBv5xRD5+H8+fNf9Xuira1N/WL4xL1793Dy5EmuLzVBQUFs2LABy5cvp0QzIiICISEh2LFjB9LT05GbmwtRUVGcOHGCMg8VOjcNDOTQvhPiS10R/LoZ4weTJk1Cfn4+CgsLO0y2cnd3J0WHjvFWBobOSmZmJlJTU3HmzBnExMRATEwMs2bNwvz58/ly+Dpv3jzs3r0bzs7OUFJSAovFQm5uLlxcXDBnzhxKNOfOnYtr167x9Tv03bt3MDY2Rl5eHnr27ImWlhbU1NRAUVERx44dQ8+ePfm2FoZvp6vYQXwtbYe8oqKimDNnDurq6uDu7g4HBweaV0YOFy5cwP79+6GoqAgXFxdMmjQJGzZswNSpU7F+/Xq6l0cadFhYmZubw8TEBFJSUtDV1UVAQAC0tLTw6tUrLFiwgBJNOhg5ciR27NjBd12m8EYydXV1KCwsRGNjIzgcDtcpCtVeTiEhIejfvz+lGgzU0FHM+aewWKwuVXhrbm7usFBRU1ND2Ykyi8WCsbExioqKkJSUBCEhIQQEBFBqXEzHpoGBOmbPno0zZ85wjR8ArZHzixcvxu3bt0nRoStqvY2IiAiiuNZWFGv7M5nvFzrGWxkYOisSEhJYvnw5li9fjuLiYpw+fRrJyck4d+4cWCwWjh8/jnXr1lH2fWNtbY0XL17A2NiYq9A3Z84cbNu2jRJNW1tbaGlp4dKlSxg8eDBPgZGKzz8vLy/U19cjKSmJ+OzJz8+Hra0t9u3bB2dnZ9I1GaijK4fS1dfXY+/evTh37hwEBQWxZMkS2NjYEN5V169fh5OTE8rLy7tM4a2qqoroSsrMzCQO7CQlJYkOerIICwvjSrhsampCREQE130KQI3NCB0WVuPHj8fFixfR0NAASUlJREVFITo6GjIyMtDX16dE80eCxWHapEjj6tWrsLW1RU1NDaUGsJ/S1NSEt2/form5GQB3V0JXKtR0VX6UmPNPaTNn9vHxwYQJE5CUlAQJCQls2bIFUlJSlBhb5uXlwcHBAeXl5bC3t0dubi5iY2Px66+/Ytu2bTwFDTJ48+YNtLS0MHz4cL5tGhjIJTU1FRkZGQCAs2fPYsGCBTxjw6WlpSgsLMStW7dI0fxfbnCoMOieO3cu5s+fD3Nzc8ycORPx8fGoqqqCtbU1li1bRslN359//smX8VYGhq5Ec3Mzrl69irNnz+Lq1atoaWnBlClTCDNuKigpKUFBQQGEhYUhLy9P6cGStbU1Ll68iFGjRnU4zkrF55+qqioOHjzIc2D+559/wsrKCpmZmaRrMlDLlStXEBwcTIwODx8+HCYmJpR1avILd3d3REVFYfHixRAREUFSUhJMTU1hZmYGV1dXREdHY8iQIXB1de0yYV4LFy6EhYUFBg0aBF1dXSQkJIDNZuP48eM4c+YMkpOTSdH5Wp8vFouF33//nRTNT9m/fz/Cw8MJn+g2CysHBweetGWG7x+m8EYiCxcuxODBg2FhYUGktLVn0KBBpGvevHkTtra2ePv2Lc9joqKiuHfvHumaDOTSPtX0R6KiogJr165FVVUV3r9/j2HDhqG0tBS9e/fGyZMnKXm/KCoqYvz48fDy8iLSfzMyMuDo6AghISFKzJXp2DQwkMurV69gZ2cHDoeDO3fuYNy4cVxeF21dWatWreoyI5GjR4/G+fPnMXjwYJiYmGDVqlXQ0NDA9evX4enpiXPnzlGiy4/xVgaGrkplZSUSExMRHx9P2uaTbpSVleHn58fXz9YJEyYgNjaWx+unuLgYurq6ePDgAd/WwvDtpKenY8uWLZgzZw4mTJiAlpYW3LlzB1euXMHBgwcxe/Zsupf4n5k1axZMTU2xatUqAK1NIG5ubpg8eTJOnz4NIyMjWFhYdKlAiYSEBOzcuRMCAgJQVlbG8ePHERgYiMDAQLi7u3e5ppO6ujq+WVi9ffsWvr6+yM7OJqb32kNVgfFHgTlWJpFnz57Bz88Pw4cP55vm/v37MXr0aOjr62Pz5s3w8fFBWVkZ/P39mU6aTsKPWvtuM4E9d+4cHj16hJaWFqxatQpLliyh7EvF2toaRkZGXF1n06dPR1JSEnbv3k2J5uXLlxEYGNhlCjI/IjIyMoiIiADQ2okWEBDAM2bQ1RAXFydSsuXk5FBUVAQNDQ3Iy8ujtLSUEk1+jbcyMHRVpKSkYGRkBCMjI9Jes/3hIJvN/qKXHBWTHeLi4hgyZAjpr/slFBUVER0dzeMBFBUVhVGjRvF1LQzfTmBgIDZv3gxzc3PimqGhIQICAhAUFNSpC29///03pk2bRvx9+vTpKC0tRVpaGo4dO4ZffvmFxtVRg7a2NkaNGoUXL15ATU0NADBmzBgcPXoUU6ZMoXl15FFXV4ddu3Zh6NCh2LhxIwBAXV0d06dPh5OTEyXFVCcnJ2RlZUFbW7vDJiKGb4MpvJGInJwcKisr+apZUFCAU6dOYeTIkfj5558hJiYGfX19iImJITQ0FBoaGnxdD8P/jo6Ozg+Zdrl9+3Y4Ojri119/5bpeVVUFc3NzBAYGkq5pbGyMFy9e4J9//oGkpCR++uknsFgs9O7dG35+fqTrAfRsGhio40fpUJwwYQKCg4Ph5OQENpuNuLg4rF+/HllZWZSMZAPAyZMnYWZm1uF4a2feGDEwdGbc3d2JDZi7uztfQhzaY2ZmBj8/P7i5ufEtrMzS0hJr167FgwcPoKKiAhaLhaysLOTn5yMkJIQva2Agj+Li4g7v8RYuXNjp/z8bGxshJiZG/F1QUBDdunXD9u3bu2TRDQCeP3+OkSNHYuTIkcQ1NTU1NDY2wtfXl7Cy6ex4eHjgwYMHXIFzO3bsgI+PD3x9fWFnZ0e6ZmZmJgIDAzF16lTSX/t75c2bNx129w0cOJB0LabwRiK2trbYs2cPrKysMGzYMJ5KNBX/gYKCgsSNiJycHAoLCzF58mSoqqrCy8uLdD0G8vmROhOzs7Px4sULAK2t4oqKijw30sXFxbhx4wapuhwOB6GhoThx4gRev35NXO/Tpw/09PRgampKmVcCHZsGBnKhu+ODDiwtLWFkZITo6GisWrUKQUFBmDRpEurq6mBiYkKJZllZGZYtWwYRERGw2Wzk5uZCQ0MD9vb28PT0pMxMmIGB4fO0N6bX1dXlu/7ly5eRlZUFVVVVSEtL83hAUjH6pKysjMjISBw7dgzXr18Hh8OBgoICduzYgXHjxpGux0At/fr1w9OnTyErK8t1/enTp122q2fs2LF0L4EyDAwMeCxp8vLyYG9vj5cvX3aZwtvly5cREBDA9ZkzZ84cSEpKwsrKipLCm5iYGGHF09W5f/8+7Ozs8Pz5c67rHA6HMm9+pvBGIm0Rxps2beLamFH5H8hms5GWlgZDQ0MMHToU2dnZMDAwQHl5OelaDAzfCovFItJ5WCxWh2muYmJipG/st27diqtXr2LJkiWYPHkyJCUlUV1djVu3biEoKAj37t1DcHAwqZpt0LFpYCCX9h0fP0qhfMSIEUhPT8eHDx8gLi6OU6dOITk5GQMGDICmpiYlmnSMtzIwMHw9LS0tOHfuXIf+PywWixIfxvHjx2P8+PGkv+6/MWTIEFhYWBDBEampqTyFG4bOwcKFC+Hs7Ixdu3YRv0vZ2dlwcXGh7PuMn3R0GNiVjffHjh0LfX19REVFQVpaGgcPHkRoaChUVFQQEBBA9/JIo7a2tsPCsKSkJN6/f0+Jpra2NkJDQ+Hi4gJBQUFKNL4XXF1d0atXLwQEBPCtAM8U3kgkPDyc7y34pqam2Lx5M0RERKClpQV/f3+sX78eBQUFUFVV5etaGBj+DRUVFeTn5wNoLRpfv34dffr0oVQzISEBt2/fxqlTp8Bms7kemz9/PlatWgUDAwOcOXMGS5cuJV2frk0DA3m07/hgsVhYsGABT0fzhw8fEBcXx++lUYqoqCjKy8uRlZUFAQEBzJ07l5LO7TboGG9lYGD4ery8vBAREQE2m823Du7NmzfzRac9OTk5MDU1ha6uLtFVsnfvXjQ2NiIsLAwKCgp8XxPDf2fjxo0oLCyEmZkZsU/jcDhQV1eHtbU1zav7dlxdXbksaxobG7F3716e782ucnC4f/9+2NraQl9fH926dUNFRQWcnJywYsUKupdGKsrKyjh8+DA8PDyIIhiHw0F4eDjGjBlDieabN29w/vx5XLlyBUOGDOG5123zO+4KFBQUIC4ujq++nUyqaRfgr7/+gqCgINhsNu7cuYOwsDDIyMhg69at6N27N93LY2CglVWrVkFLSwt6enqffU5kZCRSUlIQFRXFx5UxdBYqKyvx8eNHAMDs2bNx+vRpSEpKcj3n0aNHsLKyQk5ODh1LJJ2amhr89ttvyMjI4Ao5WLBgATw8PCgx9X38+DGMjIxgaGiIVatWYdGiRXj37h0x3vrbb7+RrsnAwPD1qKqqYsuWLVizZg1fda9du4bCwkLU19dzXWexWFyG+WShp6eHoUOHYufOncRnXVNTE5ycnFBeXo6wsDDSNRmop7i4GIWFheBwOBg5ciRPam1nRF9f/6uf25U8ajkcDuzt7ZGcnIyYmBgoKSnRvSTSycvLg76+PiQlJaGoqAgWi4W//voLVVVVCAsLo2ScePv27V98vKsUbwFg7ty58PHx4evvDlN4+0bWrl2LgIAA9OzZE2vXrv3ic7tSlZiB4VtpaGhAbGwsCgoK0NzczHU9NzcXly5dIkVn4sSJiIuLw9ChQz/7nOfPn2Pp0qW4c+cOKZqfkp+fj8LCQrS0tABovWFoaGjAgwcPKBnNYSCXhIQE2NvbE0mbHXU2t52eHz58mIYVks/27duRlZUFJycnKCsro6WlBXfv3sWePXswZ84cYmScbD5+/IgPHz5ASkoKb9++pXy8lYGB4etRVlZGYmIiXwODXF1dcfLkSfTp04en4M9isSjzeEtKSsLgwYO5rj99+hS6urq4e/cu6ZoM5FNRUYG0tDSIiIhATU0NAwYMoHtJDP+RjgpCHA4Hqamp6N+/P1fyeVcqDpWWliI2NhaFhYUQEhKCvLw81qxZg379+tG9tE5PQkICYmJi4OzsjGHDhkFYWJhyTWbU9BsZNGgQMUc/cOBAvo+afvz4ESEhIcjLy8PHjx95EjmYYh/D94q7uzvi4+OhqKiIBw8eQFlZGc+ePcPbt29JNVFvamr6Kp8Cqt67ERERRHGtrXDT9uf2NwoM3y/a2toYNGgQWlpaYGBgAH9/f/Tq1Yt4nMViQUxMrEuNH/3+++8IDAzExIkTiWszZsxAt27dYG1tTVnhjd/jrQwMDF/P9OnTkZGRwdeOt+TkZDg7O/N1jExCQgLPnz/nKbyVl5dDVFSUb+tg+O9kZWXB1NQUdXV1AFo9RA8cOIBp06bRvDKG/8LLly87vN7W9fW5xzs7gwYN4nu3f3l5OSIjI1FQUAAhISGMGDECK1as6HL3Yv7+/nj9+jW0tbU7fJwJV/gOaV9V9/T05Lu+s7MzUlNTMXXq1C73hmDo2qSnp8PT0xMLFizA3LlzsWfPHgwePBhWVlZobGwkTWf48OG4cePGF0/oMzIyKBs5OHnyJMzMzGBubo6ZM2ciPj4eVVVVsLa2xuzZsynRZCCftgJUREQEVFRUeEIyuhqCgoIdms326dOH1Pdne+gYb2VgYPh6xowZA29vb9y8eRPy8vI8HQJU+LEJCQlh0qRJpL/ul5g3bx52794NZ2dnKCkpgcViITc3Fy4uLpgzZw5f18Lw3/D394eqqiqcnZ0hKCgIFxcXeHp64ty5c3QvjeE/8G9jsvX19Vw+d12BL4XZANR09hUWFkJPTw+ioqJQUlJCc3Mz4uPjERkZiejoaIwYMYJ0TbrYsmUL3zWZUdNv5H8ZTWvfOUAWEyZMwN69ezFz5kzSX5uBgUpGjx6NS5cuYeDAgdi8eTM0NTWxcOFC5ObmwtLSkrTxkaioKAQGBiImJobn9BoAioqKoK+vj23btnGZ6JPF6NGjcf78eQwePBgmJiZYtWoVNDQ0cP36deYmsJPyI4wOHzlyBNeuXcOBAweIAJSamhrY2dlBQUEBFhYWpGvSNd7KwMDwdcyaNeuzj1E19hkUFISSkhK4urryrfheV1cHS0tLXLt2jasbfs6cOfDw8GDCXjoBEydORHR0NIYPHw6gdex0xowZuHPnDt+CQRio4ePHj3BycsLQoUOxceNGAIC6ujqmT58OJyenLnNI5+Hh8cUwGyo8+9atWwcxMTH4+PgQP8f6+nrY2tqivr6+y9ip0EXXPrLnA/r6+lzjY5+DxWJR0rLIYrGILxUGhs5Enz598PbtWwwcOBBDhgxBYWEhgNaY7Ddv3pCms3LlSly9ehW6urrQ1dWFsrIyevfujZqaGty+fRunT5/G9OnTKSm6Aa3jDU1NTQAAOTk5FBUVQUNDA/Ly8igtLaVEk4E6fpTR4atXryI3NxezZ8+GnJwchISE8PTpU9TW1uLRo0dISkoinkvWZpuu8VYGBoav4/Lly3zXnD9/PlasWIHx48ejb9++PLYQVBT7unfvjsOHD6OkpITLW0lOTo50LQZqqK2t5QqY69+/P4SFhVFdXc0U3jo57u7uePDgAZYvX05c27FjB3x8fODr60skEXd2EhMTsWPHDr6O9mdnZyM2NpareNmtWzds2rTpiyF1nZXLly936DX+4MEDhIeHk67HFN6+ESq+8P8X5s6dizNnzsDS0pLWdTAw/K+oq6tj165d8PDwgIqKCtzc3DBnzhykpqaSaoArICCAoKAgBAUFITIykuuDtE+fPti0aRNMTExI0/uUCRMmIDg4GE5OTmCz2YiLi8P69euRlZXFnJp3Qn6U0eEpU6ZgypQpfNWkY7yVgYHhfycjI4PL/0dVVfWrvFT/C/b29ujZsyeWLVuG7t27U6LxOYYOHfrFYCaG75eWlhaeIq2goCDRqc7Qebl8+TICAgIwbtw44tqcOXMgKSkJKyurLlN4q6+vx/Tp0/mqKS4ujoaGBp7rHV3r7Pj6+uLw4cPo168f/v77b/Tv3x9v3rxBc3MztLS0KNFkCm/fyKBBg77qeR8/fiRNs32yS21tLeLj43Hjxg0MHTqUCHpooysluzB0LWxsbGBnZ4esrCysXr0acXFx+PXXXyEkJAQvLy9StQQFBbF582Zs3rwZJSUlqKqqQu/evSErK8vzniEbS0tLGBkZITo6GqtWrUJQUBAmTZqEuro6Sgt+DNRQVlaGZcuWQUREBGw2G7m5udDQ0IC9vT08PT1JDQahEyq8mv4NIyMj7Nmzh2e81c/Pr0uetDIwdDbevXsHY2Nj5OXloWfPnmhpaUFNTQ0UFRVx7Ngx9OzZk3TNhw8fIi4uDmw2m/TXbs+sWbO+OmSJ7kN3BoYfmdra2g4P6SQlJfH+/XsaVkQNdITZqKqqwtvbG/7+/kTHaGVlJXx8fKCqqsq3dfCDxMRE7Ny5E2vWrMGMGTMQFRUFMTExmJubd2hNRAZM4Y1EqqurERQUxNWyyOFw0NjYiMePHyM7O5sUnU+TW9rGm8rKykh5fQYGftCjRw8cOnSI+PuRI0fw8OFD9OnTh9JiGL9Pr2VkZJCeno4PHz5AXFwcp06dQnJyMgYMGABNTU2+roXh2/mRRofz8/MRHh6OkpISHDhwAOnp6Rg+fDh++eUXSvToGG9lYGD4ery8vFBfX4+kpCQixTk/Px+2trbYt28fnJ2dSdccPHgwX7otdHR0KEs3Z6CHsLAwri7JpqYmREREcKWSA/QcNDH8d5SVlXH48GF4eHgQnbYcDgfh4eEYM2YMzasjDzrCbGxsbLBy5UrMnDkTcnJyYLFYKCkpQc+ePXHy5EnS9ejkzZs3UFdXBwCw2Wzk5ORAU1MTVlZWcHR0pMTLmAlXIBFra2tkZmZi2rRpSE1NhZaWFoqLi/Hw4UP89ttvWL9+Pd1LZGD4bhg1ahQyMzMhJSXFdf3ly5dYtGgR7t27R9PKyGX27Nnw9/eHoqIi3UthIAFzc3NISEjAyckJqampiIuLQ2xsLFJSUuDl5YXr16/TvURSyMvLw6pVqzBu3Djcu3cP58+fx+HDh3H27FkEBARQEugTEBDw1c9lNkoMDPxHVVUVBw8e5AkL+/PPP2FlZYXMzEzSNW/fvg0vLy9YWFhg6NChPInSAwcOJF2TofPzpSCQ9lAVCsJAHXl5edDX14ekpCQUFRXBYrHw119/oaqqCmFhYRg7dizdSyQFOsJsgNaOwsTERDx+/BgcDgcKCgpYtGhRh12GnZmpU6ciLCwMI0eOhIeHB3r06IHNmzejrKwMCxYswP3790nXZDreSOT69evw9vaGuro68vPzYWJiAjabjZ07d6KoqIgy3ZqaGqSmpqKwsBACAgJQVFSEpqZml4tVZuj8nD59muha4XA4MDc35znBef36NSXjKnRRX18PUVFRupfBQBI/yuiwj48PjI2NYWVlBWVlZQCAq6srevToQVnhjSmmMTB83zQ1NfEclgGAtLQ0ampqKNE0NjZGc3MzzMzMuDrSOBwOZcFlwI+RXt2VoSMIhIE/jB49GufOnUNsbCwRfrJw4UKsWbMG/fr1o3t5pEHX77C4uDhWr15NizY/mTx5Mry9veHq6orRo0cjODgYq1evxsWLFzv8niMDpvBGIrW1tUTrvby8PPLz88Fms6Gnp0dZt1txcTEMDAxQW1sLOTk5tLS0IC4uDocOHUJ4eDipJvUMDN+KhoYG18j1gAEDeIpSCgoK0NbW5vPKqGPNmjXYsmUL1qxZgyFDhvD8ez/tHGD4vhkxYsQPMTqcl5eHXbt28VxftWoVYmJiKNPl93grAwPD16OoqIjo6Gjs2LGD63pUVBRGjRpFieaxY8coed0v8aOkVzMwdFYGDRqE3377je5lkM7bt28hLS39xec0NDQgPT0dCxYsIEVz9uzZOH36NCQlJf/V67IrdYfa2trCzMwMFy9exOrVq3Hs2DFMnToVQGuoDxUwhTcSkZGRQWlpKWRkZCAnJ4f8/HwArbHk1dXVlGi6urpi1KhR8PHxITwLKisrYWNjA1dX1/9pdIeBgWp69+5NBH40NDTA2dm5y8e6HzhwAACwZ88enseoPK1noA5RUVGUl5cjKysLAgICmDt3bpcbdxIWFu6wg6WsrIyyZMH24615eXloaGjAo0eP4O7uTlmXHQMDw9djaWmJtWvX4sGDB1BRUQGLxUJWVhby8/MREhJCieakSZMoed0v8aOkVzMwdFYuX77M5akOgOhIDQ8Pp3Fl38a0adNw/fp1ruKbtbU1HBwciGvv3r2DtbU1aYU3HR0doilAV1eXlNfsDPTv3x8JCQmor6+HiIgIoqKikJGRgf79+0NJSYkSTabwRiKamprYtm0bvL29oaqqCktLS4wbNw7p6emQlZWlRPP+/fuIi4vjMgqVkpLCtm3bfog2UYbOy+3bt/HkyRPKPty+F7rS6RBD62j/b7/9hoyMDK4uiAULFsDDwwMiIiI0r5AcNDQ0sG/fPvj6+hLXiouL4ebmhhkzZlCiScd4KwMDw9ejrKyMyMhIHDt2DNevXyf8f3bs2IFx48aRppOQkPDVz6WiQ/5HSa9mYOiM+Pr64vDhw+jXrx/+/vtv9O/fH2/evEFzczO0tLToXt430ZH1/uXLl2FpaclVjCPTor+9zccvv/yCcePG8dgA1dfX4+rVq6Rpfk/k5OSguLgYCxcuxNChQymr2QBM4Y1UtmzZgo8fP+LVq1dYtGgR5s+fD0tLS/To0QP+/v6UaPbr1w/l5eUYMWIE1/Wampou5ZPF0PUQERHhMUnuigwaNIjuJTCQiJubG0pKSnDkyBEoKyujpaUFd+/exZ49e7B//37K2tP5jZ2dHdatW4cpU6aAw+FAV1cXNTU1YLPZ2LZtGyWadI23MjAwfB179uyBgYEBV0GeCr72c5TFYlFSePuR0qsZGDobiYmJ2LlzJ9asWYMZM2YgKioKYmJiMDc3x+DBg+leHl+gKoF57dq1HQbfFRUVwdbWFvPmzaNElw5qampgYmKCBw8egMViYerUqfDx8cGzZ89w7NgxSuy6uv6ul4+IiIjA0dGR+Pvu3buJwltVVRUlmnZ2dnB2doa9vT0mTZoEISEh5ObmwtnZGQYGBigrKyOe29VGoRg6N4sXL8a6deuwZMkSyMrK8nifdXaft8rKSoSFhcHCwgLCwsJYtGgRPnz4QDw+ZcqUDsdPGb5vfv/9dwQGBnJ5882YMQPdunWDtbV1lym8SUhIICYmBjdv3sTDhw/R0tICBQUFTJ8+HQICApRo0jHeysDA8PUkJCTAyMiIcp02qxa6mDBhAoKDg+Hk5AQ2m424uDisX78eWVlZEBcXp3VtDAw/Om/evIG6ujoAgM1mIycnB5qamrCysoKjoyMsLCxoXmHn4vjx4/Dy8gLQ2knX5nP2KV1tQmn//v1gsVhIS0vD4sWLAQDbtm2DjY0NvL29sX//ftI1mcIbiezfv5/H6LF3795ITk6Gm5sbbt26Rbrmpk2bALS2iX6a9uTl5QVvb2/Kk58YGP4LwcHBADo2TqbqFJtfvH79GkuXLoWwsDDWrFkDGRkZvHz5EkuXLkXv3r1RVlaG06dPQ1tbG+PHj6d7uQz/A4KCgh1Gqvfp0weNjY00rIhaJk+ejMmTJ/NFi47xVgYGhq9nxowZOHnyJDZv3tyl/Vl/lPRqBobOSK9evVBbWwsAkJWVRVFREYDWBpOKigo6l9Yp0dPTQ+/evdHS0gIHBwds376d6z6XxWJBTEwMqqqqNK6SfK5cuYJ9+/ZxdUkOGzYMu3btwoYNGyjRZApvJHLy5EkICwtjy5YtAFor8k5OTrh8+TJlZoURERGUvC4DA9XQfaJNJYcPH8agQYNw/Phxrk4+AwMD4gO+oqICsbGxTOGtk2FkZIQ9e/bgwIED6NOnD4DWdnU/Pz/o6enRvLpvY+3atV/9XCq+e+gYb2VgYPh6ysrKkJKSgvDwcEhLS6Nbt25cj3cVT9OO0quTkpIgIyPTpdKrGRg6I5MnT4a3tzdcXV0xevRoBAcHY/Xq1bh48SLPiGRnhKox0s8hJCRENDuwWCxoaWl1Gb/iL1FZWYm+ffvyXJeQkEBdXR0lmkzhjUSOHj2K9evXQ1BQEIMGDYK7uzt69uyJY8eOUdYxQEfaEwMD1ZSVlXXq0eg//vgDO3fu5Bmfbc+aNWvg6urKx1UxkMHVq1eRm5uL2bNnQ05ODkJCQnj69Clqa2vx6NEjJCUlEc/tbJvQjvwIk5OTMWvWLL6MV9Ex3srAwPD1TJ069bNjSF0NUVFR4jtcWlqaLyO2DAwM/46trS3MzMxw8eJFrF69GseOHSM+l7qC3YerqyvXoUZjYyP27t1L3IfV19dTpq2jo4PKykqUlJSgpaUFQOsUXVtirLm5OWXa/GbMmDFITU2FmZkZ1/WIiAj8/PPPlGiyOGTGYjDgwYMHWLduHWpra2FkZIStW7fynAh+K9u3b//q53p4eJCqzcBAFi9fvoSXlxdXHHjbh3tlZSUePnxI8wr/O2PGjEFaWhqXMeeGDRuwZ88e4nSltLQUmpqayM3NpWuZDP+BgICAr35u+6SozoqysjKSkpJ+GMNiBgYGhpKSEri4uCA7O7tDCwHGuoWBgX7q6+vRrVs3fPz4ERkZGejfv3+n9yHT19f/6ueeOHGCdP2UlBQ4ODigvr4eLBaLsKsCWg9n09PTSdeki7t378LIyAiTJ09GZmYmFi1ahKKiIjx8+BChoaH45ZdfSNdkOt6+kfbhBQDQt29fuLm5wcbGBr169cLbt2+Jx8jq4Hn58uVXPa9t/p2B4XvE1dUVJSUlmD9/PkJDQ2FsbIySkhKkpaXBxcWF7uV9ExISEjzvvzZPuzbev3+PXr168XNZDCTQFYpp3xN0j7cyMDD8b9y+fRt5eXn4+PEj2p/ds1isLtMNsXv3bpSVlcHGxqZDT08GBgb+U1FRgbS0NIiIiEBdXR39+/cH0NqdOmfOHJpXRw5UFNP+F4KDg7Fw4UKYmppi+fLlCAsLw+vXr+Hs7ExYaXUVVFRUEBsbi7CwMMjKyuL+/fsYMWIEHB0dMXbsWEo0mcLbNzJr1qwOZ7E5HA72798PX19f0sMN/u1N+fDhQ0RHRyMlJYUUPQYGKsjKykJQUBAmTpyIP/74AxoaGlBSUoKvry+uXbuG5cuX073E/8zw4cORkZEBeXn5zz7n2rVrlLUyM1BLfn4+wsPDUVJSggMHDiA9PR3Dhw+n5HSsq0P3eCsDA8PXc+TIEezfvx89evTgKUhRWXgrLS3FgwcP0NDQwPMYFUFM9+7dQ3h4OJSVlUl/bQYGhv+drKwsmJqaEt5b4uLiOHDgAKZNm0bzyroWT58+xYEDByAnJ4dRo0ahsrISs2bNQlNTE4KDg7FkyRK6l0gqbDYb3t7efNNjCm/fSHh4ON9NEDuivr4eKSkpiImJQW5uLgQEBDB37ly6l8XA8Fnq6+vx008/AWhNkSkoKICSkhK0tbX/p1br7xEdHR14eXlBVVUVbDab5/GCggKEhITAzc2NhtUxfAt5eXlYtWoVxo0bh7y8PDQ0NODRo0dwd3dHQEAAZs6cSfcSOxUd2SFcuHABtra2zHgrA8N3xokTJ2BhYYGNGzfyTfPMmTNwcnIiLCnaQ1UCuqSkJFP4Z2D4jvD394eqqiqcnZ0hKCgIFxcXeHp64ty5c3QvrUvRrVs3CAsLAwDk5OTw+PFjqKmpYfTo0Xj27BnNq/t26LaLYQpv3wjdHQ5PnjxBTEwMEhMTUV1dDRaLhaVLl2LDhg1EUYOB4Xtk8ODBKCws/L/27jys5rT/A/j7tEkLI8sIEaFM68nILmUsCePBkCmm1NhCspTJE6KUJc2QnQzN0Dza6JmyjWpMY4+GsRT5EQYTiZNo/f3h6jyOFoZz+tbxfl1X11X39z7fz6dzXHV8uu/7A319fRgaGkpXhJaVldX7bdKjRo3CoUOHMGbMGIwcORI9e/aEnp4e8vLycPr0acTHx8POzg6DBw8WOlX6h1avXo1JkybB29tbuhoiMDAQurq6LLwRkVJ78uQJhg8fXqsxN27ciFGjRsHX1xc6Ojq1EnPChAlYs2YNVq1axa2mRHXA5cuXsWfPHrRo0QIA4Ofnh/79+0MikdTaz4UPgYWFBaKiojB//nx07NgRycnJcHd3x7Vr16QFufosPDwcKioqMmdwV0UkErHwVhcJ0eigpKQEhw4dQlRUFE6fPg11dXXY2trCwcEBPj4+cHV1ZdGN6rxRo0bBx8cHISEhsLW1xYQJE9CqVSukpaXB2NhY6PTe24YNGxAREYHdu3cjOjpaOt68eXNMmzYNX3/9tYDZ0bu6ePEiFi9eXGl8/PjxiIqKEiAj+anq99nr3bQqsHEP0Yena9euOHfuXK2+x3zw4AEmTZpUq/+5Tk1Nxfnz59G9e3c0bdoUGhoaMtfrW8dqovquoKAAH330kfTrjz/+GOrq6sjPz2fhTY48PT3h7u4OPT09jBo1CuHh4XB0dMRff/2FoUOHCp3eexs7diwOHz4MAHB0dISjo2OVO5MUhYW39yREo4OKCn+PHj0QHByMzz77TPpDZ/78+XKLQ6RIHh4eUFNTg0gkgoWFBWbMmIGNGzdCX18fq1atEjq996aiogIPDw94eHggJycHDx8+RJMmTWBgYAAVFRWh06N3pK6uDolEUmn87t27aNiwoQAZyU9Vv8/EYjHy8vKQl5cnQEZEJLT4+Hjp52ZmZli8eDEyMzNhaGgIVVVVmbmK2PZpYmKCmzdvon379nK/d3W6d+8u+I4WIvqfsrKySkc7qaqqoqysTKCMlFPXrl1x8OBBFBUVoUmTJti9ezf27NkDfX39en8MEAAsXboUixcvxokTJ5CYmIivvvoKenp6GDZsGBwdHWFoaKjQ+KLyV1sSkdy92uggPT1dLve0tLRE06ZN0a9fP/Tu3Rv9+vVDgwYNAACmpqbYt28fOnbsKJdYRET0P/7+/sjJyUFYWBjs7e2xf/9+FBUVYfbs2TA3N8fy5cuFTrHeE4vF2L9/P894I6oD3nY1gDybiL3qwIEDWLFiBSZNmoQOHTpUWn3WrVs3ucckorrFxMQEaWlpaNq0qXSM7xXofRUXF+O3335DUlISfvnlF7Rt2xZDhw6Fo6MjWrVqJfd4LLwpQHWNDsLCwuRyf4lEgsTERMTExCAjIwNaWlqwt7eHg4MDvLy8EB8fz8Ib1Qvnz59HZGQkMjMzoaqqClNTU7i6uqJTp05Cp0ZUJYlEAg8PD2RkZKC8vBy6urqQSCQwMTHBjh07ZLZC0JtVtb21uq6m3N5K9OGpqfCnqGIfAPz555/Yvn07rl69CjU1NXTs2BFfffUVLCwsFBKPiKpnYmICd3d3mZ0FmzdvhpOTExo3biwzVxFnc30oHj58iLCwMJw9exbFxcV4vUykzNvsi4qKsHfvXoSFhaGgoEAhv1tYeJMjIRodXL9+HdHR0UhISEBubq40poeHh8KXSxK9j6NHj2LGjBmwsLCApaUlysrKcP78eVy5cgU7duzAp59+KnSKRNU6fvw4Ll26hLKyMnTu3Bl9+/blFuJ38E+2LkRGRiowEyKqSWFhITQ1NWW2e2VlZaF169bQ0tJSWNw7d+7UeL1169Zyj3nmzBm4ubmhc+fO+PTTT1FaWor09HRkZmZi586d6Nq1q9xjElH17O3t32qeSCRS6uKQonl6euLMmTMYOXJklY1llLGoef/+fSQlJeHAgQPIyMhAu3btpIuZ5I2Ft/f0pkYHtbX6rLS0FCkpKYiLi0NKSgrKysrQq1cvbNu2TeGxid7F8OHD0b9/f8ydO1dmfMWKFUhPT8dPP/0kUGZERERUIT4+HsHBwdi2bRvMzc2l4+7u7sjIyMCyZcvg4OBQ63k9f/4cmpqacr/vl19+CRMTEyxatEhmPCAgANeuXeMfAYhIKVlZWWH9+vXo3bu30Kko1OvFNgMDAzg4OMDBwUGhzRbYXOE91ZVGB6qqqhgwYAAGDBiAR48eYd++fYiNja21+ET/1K1btzB69OhK4+PGjcPu3bsFyIioahMnTnzrubt27VJgJkREtev48ePw8/PDqFGjoK+vL3Nt0aJF2Lp1K+bNm4fmzZsrZKV6fn4+Nm7ciKtXr6K0tBQAUF5ejuLiYmRlZeHs2bNyj/nnn38iMDCw0riLiwvGjBkj93hERHWBlpZWpZ/zyuT777/HgQMH8Mcff6BVq1ZwcHCAv78/TE1NayU+C2/v6enTp2jatClatmwJbW1tqKurC50S9PT04ObmBjc3N6FTIaqWqakpjh8/XmlL9MWLF2FkZCRMUkRVqGorU3XnkBERKZOtW7fCxcUFfn5+la61a9cOgYGBKC8vx6ZNmxSyy2Lp0qVIS0tDnz59kJiYCEdHR1y/fh2XLl3CnDlz5B4PAJo0aYKHDx+iQ4cOMuMPHz6s1NyBiEhZjBw5Etu3b8fSpUsrda1WBiEhIVBXV0ffvn2lq7eTk5ORnJxcaa4ittWy8Pae0tLSpI0OoqKiZBodvN72mIj+Z8SIEVi1ahVu3LgBGxsbqKmp4cKFC9i5cyfGjRuH+Ph46dyRI0cKlidRVYf6HzhwAPPnz2c3LSJSapcuXcKCBQtqnDN+/HhMnjxZIfF/++03rFy5Era2trhy5Qrc3d1hYmICf39/XLt2TSEx7ezssGzZMoSFhUn/EHjt2jUEBQXBzs5OITGJiISWm5uLpKQkJCcno23btpX+0FDfd3VUdCrNyspCVlZWtfNEIpFCCm88402O2OiA6O297R56RXYtI3pXbGNPRB8Ca2trxMfHo23bttXOycnJweeff4709HS5xzczM8Phw4ehr68PLy8v2NnZYeTIkbh69SomT56M1NRUucfMz8+Hm5sbLl++DF1dXYhEIjx58gSdO3fGjh07oKenJ/eYRERCq6rT/KvYXf79cMWbHBkZGcHX1xfz5s2TNjqIj49HbGwsGx0QvebKlStCp0BEREQ1aN++Pc6dO1dj4S09PV0h3UUBQF9fH3fu3IG+vj4MDQ2l7x0aNmyI/Px8hcRs3LgxoqOjcezYMWRlZaG8vBydO3dGnz59lHL7FRERAPTs2RO2trZo3Lix0KkoJRbeFICNDoj+uUePHuHUqVMwMzNDmzZthE6HiIjogzdixAisXbsWPXv2RIsWLSpdf/DgAb777rsqmyXJw5AhQ+Dj44OVK1eiR48emD17NqysrHDkyBG0a9dOITEBQEVFBba2trC1tVVYDCKiuiQwMBCmpqYsvCkIC28KxkYHRFXLzMzEzJkzERgYCBMTE4wYMQK5ubnQ0NDAli1b0KNHD6FTJCIi+qC5uLjg0KFDcHR0xJgxY2BlZYVGjRrh8ePHOH/+PGJjY9GuXTu4u7srJP7MmTPx/Plz/PXXXxg+fDgcHBwwe/Zs6OrqYu3atXKL87bdq0UiEXbu3Cm3uEREdYWhoSGuXr3KJncKwjPeiEgQ7u7uUFVVRXBwMH755ResWbMG+/btw+7du3Hy5ElERUUJnSIRgKrPvKiuqynPvyAiZVNUVIS1a9di7969Mts7mzVrhtGjR2PatGnQ1NSstXweP34MXV1duW77fNPZRmfOnEFOTg50dHRw5swZucUlIqorFi5ciLi4OJiYmMDQ0BANGjSQuc73uO+HhTciEoS1tTX27t0LIyMjzJw5E1paWlixYgVycnIwfPhwnD9/XugUiQAAEyZMeOu5kZGRCsyEiEg4JSUlyMnJQX5+PvT09GBgYACRSKTwuNeuXUNmZiaKiooqXVN013OJRIKQkBBER0ejV69eCAwMlHbGIyJSJm96v8v3uO+HW02JSBAqKirQ0NBAaWkpTpw4gYULFwIACgoKavUv50RvwjcaRESAmpoa2rdvX6sxt2zZgjVr1lR5TSQSKbTwlpaWBn9/fzx58gQBAQEYN26cwmIREQmN73cVi4U3IhKElZUVNm3ahGbNmqGwsBD9+vXD/fv3ERoaCktLS6HTIyIiIoHt3LkTnp6emDJlCjQ0NGolZkFBAUJCQrB371707NkTQUFBXOVGRB+E58+f48CBA8jOzsakSZOQmZmJjh07Qk9PT+jU6j0W3ohIEP7+/vD29kZOTg78/Pygp6eHZcuWITs7Gxs2bBA6PSIiIhJYcXExRowYUWtFt4pVbvn5+ViyZAmcnJxqJS4RkdByc3Ph5OSE3NxcFBUV4YsvvkBERAQuXLiAnTt3omPHjkKnWK/xjDciqjP++OMP7NmzBwcPHkR6errQ6RAREZGAgoKCoKGhgfnz5ys0TkFBAVasWCGzyk1fX1+hMYmI6pJ58+ZBIpEgLCwMvXr1wv79+9GoUSPMmTMHqqqq2LJli9Ap1mtc8UZEgnrx4gV+/vlnREVF4cKFC1BRUcHAgQOFTouIiIgE5uHhgREjRiAxMRFt2rSp1Mxh165dcokzfPhw/PXXXzAwMIC1tTViYmKqnTtjxgy5xCQiqktOnDiBLVu2oGHDhtKxxo0bY/78+Zg4caKAmSkHFt6ISBDZ2dmIiorCvn37kJ+fD5FIhNGjR2Pq1Klo06aN0OkRERGRwP79738DACwtLWX+M6gI+vr6KCkpQWxsbLVzRCIRC29EpJQKCgqq/TlbUlJSy9koHxbeiKjWlJSU4NChQ4iKisLp06ehrq4OW1tbODg4wMfHB66uriy6EREREQDg1KlT+P777yEWixUa5+jRowq9PxFRXdetWzf8+OOP0j94AC/P2Vy/fj2sra0FzEw5sPBGRLWmf//+kEgk6NGjB4KDg/HZZ59BR0cHABR+fgsRERHVL82aNYO2trbQaRARKT1fX184Ozvj1KlTKC4uxpIlS5CdnY2nT5/ihx9+EDq9ek9F6ASI6MPx9OlT6OnpoWXLltDW1oa6urrQKREREVEdNXfuXAQGBuL69esoLS0VOh0iIqVlZGSE/fv3w97eHr1794aKigocHBwQHx8PExMTodOr99jVlIhqjUQiQWJiImJiYpCRkQEtLS3Y29vDwcEBXl5eiI+PZ6tqIiIiAgAMGjQId+/erbbodvny5VrOiIhIOYWHh8Pd3b3SOW8SiQTfffcdFi5cKFBmyoGFNyISxPXr1xEdHY2EhATk5uZKmyt4eHjA0NBQ6PSIiIhIYHFxcTVe/9e//lVLmRARKZ/r16/j0aNHAICJEydi3bp1aNy4scyczMxMrFy5EhkZGUKkqDRYeCMiQZWWliIlJQVxcXFISUlBWVkZevXqhW3btgmdGhERERERkVJKSUnB1KlTIRKJAADVlYZGjx6NoKCg2kxN6bDwRkR1xqNHj7Bv3z7ExsYiISFB6HSIiIhIQOHh4TVenzFjRi1lQkSknO7evYuysjJ89tln2Lt3L/T09KTXRCIRtLS08NFHHwmXoJJg4Y2IiIiIiOoce3t7ma9LSkrw6NEjqKurQywWIyIiQqDMiIiUy507d9CqVSvp6jeSLzWhEyAiIiIiInrd0aNHK41JJBL4+vqie/fuAmRERKSc9PX1kZCQgLNnz6K4uLjSttPg4GCBMlMOXPFGRERERET1RmZmJqZMmYLk5GShUyEiUgrBwcHYtWsXTExMoKOjU+l6ZGSkAFkpD654IyIiIiKieqNiyykREcnHvn378O9//xvOzs5Cp6KUWHgjIiIiIqI6Jz4+Xubr8vJyPH36FD/99BPEYrEwSRERKaEXL16gb9++QqehtLjVlIiIiIiI6hwTE5NKY2pqarC2tkZAQADat28vQFZERMpn1qxZ6N69O1e8KQhXvBERERERUZ1z5coVoVMgIvogmJubY+XKlTh+/DiMjIygrq4uc33GjBkCZaYcuOKNiIiIiIiIiOgDZW9vX+01kUiEX375pRazUT4svBERERERUZ0wceLEt567a9cuBWZCREQkH9xqSkREREREdULr1q0rjSUkJMDe3h7a2toCZERERPR+uOKNiIiIiIjqLLFYjP3798PAwEDoVIiIlAZXGNcerngjIiIiIiIiIvqAVLXCmBSDhTciIiIiIiIiog9IcHCw0Cl8MFSEToCIiIiIiIiIiEgZsfBGRERERERERESkANxqSkREREREdcI333xTaay4uBirVq2q1NWU26SIiKg+YOGNiIiIiIjqhNu3b1caE4vFyMvLQ15engAZERERvR9ReXl5udBJEBERERERERERKRue8UZERERERERERKQALLwREREREREREREpAAtvRERERERERERECsDCGxEREdE/wONxiYiIiOhtsfBGRERE9dKCBQtgbGxc7ce+ffvkGq+oqAjBwcFISEiQ630V5fbt2+jfvz8ePXoEALC3t4exsTHmzp1b7WPGjh0LY2NjrFu3rrbSfKOqXmcTExOIxWJ8/vnn2LVrl0Linjx5EsbGxjh58mS1c+zt7bFgwQK5x/7Pf/6DKVOmyP2+REREVPvUhE6AiIiI6F01b94c4eHhVV5r27atXGM9ePAA33//PYKDg+V6X0UoLy+Hn58fvvrqK+jp6UnHVVRUcPToUbx48QINGjSQeczt27eRkZFR26m+lddf5/LycuTm5iIqKgpBQUHQ0NCAk5NTrecVHh4OHR0dud93zJgx2L17N2JiYjB69Gi535+IiIhqDwtvREREVG9paGjAyspK6DTqnMOHD+PKlSvYunWrzLi1tTXOnDmD1NRUDBo0SOZaYmIiunTpgsuXL9dmqm+lute5f//+GDhwIKKjowUpvH3yyScKua+KigomT56MoKAgDBs2rFKRlIiIiOoPbjUlIiIipXfkyBGMGjUK5ubm6N27NwIDA/Hs2bNKc7788kuIxWKYmZlhyJAh+OGHHwC8XA02YMAAAMA333wDe3t7AC+3QVZ8XuH27dswNjZGbGwsgP9tWYyKioKdnR169eqF3377DQBw5swZuLi4wNLSEjY2NvD19ZVuDQWAsrIyfPfdd7C3t4eZmRns7e2xZs0aFBcX1/j9bt68GYMGDapUsDEwMICZmRmSkpIqPSYxMRGOjo6Vxl+8eIGVK1fC1tYWZmZmGD58OBITE2XmPH/+HKGhoRg0aBDMzMxgbW0NNzc3mSLeggUL4OrqipiYGAwePBhmZmYYMWIEUlNTa/xeaqKurg5NTU2ZsdLSUmzZsgXDhg2DhYUFrKys4OTkhOPHj0vnrFu3DgMHDkRKSgqGDx8OMzMzDB48GHFxcdXGKioqwqRJk2BjY4M///wTgOxW04rXPSkpCbNmzYJYLEa3bt2wcOFCFBQUSO9TXFyM1atXo1+/frCwsIC7uzvi4+NhbGyM27dvS+cNGDAAz58/R3R09Ds/P0RERCQ8Ft6IiIioXispKan08WoDhISEBHh6eqJDhw5Yv349ZsyYgf3792P69OnSeSkpKfD09ISpqSk2bNiAdevWoXXr1li2bBnS09PRokUL6VbHadOmVbu9tSZhYWHw9fWFr68vrKyscPr0abi6ukJTUxPffvst/Pz8cOrUKUycOBHPnz8HAGzduhU//vgjPD09ERERgfHjx2Pbtm3YtGlTtXGys7Nx8eJFDBkypMrrQ4cORUpKijRGxWOuXLmCoUOHyswtLy+Hp6cnoqKi4Obmho0bN0IsFsPb2xvx8fHSeT4+PoiOjsbkyZMRERGBBQsWIDMzE97e3jKvxcWLF7F9+3bMmjUL69evh5qaGmbNmoX8/Pw3Pn+vvr5FRUW4e/cuVq5ciRs3bmDkyJHSeatXr8b69esxbtw4bNu2DUuXLkVeXh68vLxkiq1///03li5diokTJ2LLli1o06YNFixYgOvXr1cZ29vbGxcuXEBERARMTU2rzXPx4sVo3bo1NmzYAA8PD8TExMi8XosWLcLOnTvh4uKC9evXo1mzZvD39690nwYNGsDOzq7enClIREREVeNWUyIiIqq37ty5U2URxMvLS1pYW716Nfr27YvVq1dLrxsaGsLV1RWpqano378/rl27hpEjR2LhwoXSOWKxGN27d8fp06dhbW2NLl26AHh5dty7bDF0cnKSKYaFhoaiffv22Lx5M1RVVQEAlpaWcHR0RExMDJydnXHq1CmYmppKz/mysbFBw4YNazxX7MSJEwAACwuLKq87ODhg1apVSE1NxeDBgwG8XO0mFovRunVrmbm///47jh07hrCwMGlRrm/fvigsLMTq1asxbNgwlJWVoaCgAP7+/tI5NjY2KCgoQEhICP7++2+0aNECAPD06VPExsZKz9/T0tKCi4sLTpw4Ic2lKtW9zoaGhli8eDHGjx8vHXvw4AG8vb0xYcIE6ZimpiZmzpyJq1evQiwWAwAKCwsRFBSEnj17Su9lZ2eH1NRUGBkZSR9bVlaGBQsW4OTJk4iIiICZmVm1eQKAra0tfH19AQA9e/ZEWloaUlJSMHfuXNy6dQtxcXHw9fWFm5ub9PnMzc2VroJ8lbm5ORITEyGRSBRylhwREREpHgtvREREVG81b94cGzdurDT+8ccfA3i5kuvevXuYMmUKSkpKpNe7desGHR0dpKWloX///vDw8AAAPHv2DLdu3cKNGzdw4cIFAHjjts63ZWxsLP28sLAQGRkZcHd3R3l5uTQ3AwMDGBkZIS0tDc7OzujevTtCQ0Px5ZdfYuDAgejXrx9cXFxqjJOTk4NGjRqhUaNGVV5v1aoVrKyskJSUJFN4c3Z2rjT3+PHjEIlEsLW1lXn+7O3tsX//fmRlZaFLly7Yvn07gJdFr5s3byI7OxvJyckAZJ8/PT09maYXLVu2lD4fNXn1dc7Ly8PmzZtx69YtLF++HF27dpWZGxoaCgB49OgRbt68iRs3buDo0aOVcgEgc25cRS6vb0FevXo1Ll68iOnTp1dbzKzunhX3vXPnDoCX247Ly8srrUYcNmxYlYW31q1bo7S0FPfu3UPHjh3fGJuIiIjqHhbeiIiIqN7S0NCAubl5tdcfP34MAAgICEBAQECl6w8ePADwskizePFiHDlyBCKRCO3atZMWdF7dKvk+mjZtKv38yZMnKCsrw9atWys1QAAgPZvNw8MD2traiImJwYoVKxASEoLOnTvDz89PulLrdRKJBA0bNqwxFwcHB3z77bcoLCzEzZs38X//939Vbk19/PgxysvLYW1tXeV9Hjx4gC5duuDYsWNYvnw5srOzoa2tDWNjY2hrawOQff5ez0skEgF4uaqsJq+/zt26dcPYsWMxefJk7N27Fx06dJBeu3DhAgICAnDhwgVoamqiY8eO0pV8r7+Wr+ajoqJS5Zzs7GzY2Nhg165dGDdunLRAV53Xv0cVFRXpPSvO73v13wIANGvWrMp7aWlpAXi5UpCIiIjqJxbeiIiISGlVrPry8fGBjY1NpeuNGzcGAMybNw/Xr1/Hjh07YG1tDQ0NDRQWFmLv3r013l8kEqG0tFRm7PUVU1XR1taGSCSCq6trlQ0NKoo3KioqcHZ2hrOzMx4+fIjU1FRs2rQJM2fOxO+//w4NDY1Kj23SpMkbCzVDhgxBSEgIUlNTcfnyZfTo0aNSMQgAdHV1oaWlhV27dlV5n3bt2uHWrVvw9PTEgAEDsHnzZumKth9//BHHjh1743PxLho2bIjly5dj7Nix8PPzw549eyASiSCRSODh4QFjY2P897//hZGREVRUVJCamoqDBw++U6zAwED06NEDDg4OWLJkSY3n671JxUrMhw8fQl9fXzr+8OHDKudXnH3XpEmTd45JREREwmJzBSIiIlJaHTp0QNOmTXH79m2Ym5tLP1q2bInQ0FBcunQJAHD27FkMHjwYPXr0kBazfv31VwD/W41VcQ7bq7S1tZGXl4cXL15Ix9LT09+Yl46ODj755BNkZ2fL5NWpUyeEh4fj5MmTAF6eCxcYGAjg5SqpUaNGwdnZGU+fPoVEIqny3q1atcKzZ89qbFjw8ccfo2vXrjh06BCSkpKqLP4BL89qe/bsGcrLy2XyzMrKwvr161FSUoKLFy/ixYsXmDJlisw20oqim7xWDL7O3NwcY8eOxblz56TdSLOzs/H48WNMnDgRnTp1kq5ie/21/CeaNWuGpk2bYs6cOUhOTq7U0fWf6Nq1K1RVVXHo0CGZ8de/rnDv3j2oqqpKC3ZERERU/3DFGxERESktVVVVeHt7Y9GiRVBVVYWdnR2ePHmCDRs24P79+9ID+y0sLJCQkABTU1O0bNkS586dw+bNmyESiaTnj+nq6gJ4ee6ZkZERLC0tYWdnh8jISPj5+eGLL75AVlYWIiIiqizSvW7OnDmYPHky5s6dixEjRqC0tBQRERHIyMjAtGnTALzcUhkREYFmzZpBLBbj/v372LFjB2xsbKCnp1flfXv37g3gZQHQzs6u2vgODg4IDg6GSCTCwIEDq5xja2uLbt26Yfr06Zg+fTqMjIzwxx9/YN26dejTpw/09PRgamoKNTU1rFq1CpMmTUJRURFiY2ORkpIC4O1WAL6r2bNnIykpCaGhoRg4cCDat28PHR0dbNq0CWpqalBTU8PBgwcRHR0N4M1nydVk3LhxiIuLQ2BgIHr16oWPPvroH9/DwMAAo0ePxpo1a1BcXAwTExMcPnxYeh5eRaGwwtmzZ/Hpp5++ceswERER1V1c8UZERERK7YsvvkBoaCjS09MxdepULFmyBG3atEFkZCQMDAwAACEhIbC0tMSyZcvg6emJI0eOICAgAH369MGZM2cAvFyl5ubmhiNHjsDDwwNFRUXo3bs3fH19kZ6ejq+//ho///wzwsPD36rw1qdPH2zfvh337t3DrFmz4OPjA1VVVezYsUN6QL+XlxemTp2KmJgYeHh4ICQkBH369MHatWurva+BgQFMTU2RmppaY/whQ4agrKwMffv2rbYRg4qKCrZs2QJHR0ds3rwZ7u7uiIqKgqurK8LCwgC83G4aGhqK+/fvY9q0aVi0aBEAIDIyEiKRSPr8KUKTJk3g5eWF3NxcrF27Frq6utiwYQPKy8vh5eUFHx8f3L17Fz/88AO0tbXfKxeRSISAgADk5+cjODj4ne/j7+8PJycnREREYPr06bh375600FpxphsAvHjxAqdOnary7D0iIiKqP0Tlilr/T0RERESCOHjwIPz8/HDs2DGZYg4J6/Hjx/j111/Rt29fmXPbVqxYgdjYWOkWYwCIi4tDaGgojhw5Ak1NTSHSJSIiIjngijciIiIiJTNo0CB06tQJu3fvFjoVekXDhg0RFBQEb29vJCcn4+TJk9i4cSMiIyMxYcIE6byKbcczZsxg0Y2IiKie44o3IiIiIiV069YtuLi4ID4+vtrz4Kj2Xb58Gd9++y3Onz+PwsJCtG3bFk5OTnB2doZIJAIAREVF4fDhw9i+fbvA2RIREdH7YuGNiIiIiIiIiIhIAbjVlIiIiIiIiIiISAFYeCMiIiIiIiIiIlIAFt6IiIiIiIiIiIgUgIU3IiIiIiIiIiIiBWDhjYiIiIiIiIiISAFYeCMiIiIiIiIiIlIAFt6IiIiIiIiIiIgUgIU3IiIiIiIiIiIiBWDhjYiIiIiIiIiISAH+H0DrA0kY9OxHAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Generating Composite Feature Importance Plots...\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAACH4AAATWCAYAAABZ4PNdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdZ5hV1f024OfMDDAoIFgpgmLHgl1BjTW2aCzYS4zE3jVGYzSaxH+iqDGxlyR20cSuMTEWYotgVMQKFkAjCthAlF7mvB/UCbxYhjND2eG+r2suh33W2r/nHEQ+zONepXK5XA4AAAAAAAAAAIVTNb8DAAAAAAAAAABQGcUPAAAAAAAAAICCUvwAAAAAAAAAACgoxQ8AAAAAAAAAgIJS/AAAAAAAAAAAKCjFDwAAAAAAAACAglL8AAAAAAAAAAAoKMUPAAAAAAAAAICCUvwAAAAAAAAAACiomvkdoGjK5XLq6srzOwYzqaoqFeL3pCg5k+JkLUrOpDhZi5IzkXVuKErOpDhZi5IzKU7WouRMipO1KDmT4mQtSs6kOFmLkjORdW4oSs6kOFmLkjMpTtai5EyKk7UoOZPiZC1KzqQ4WYuSM5F1bihKzqQ4WYuSMylO1qLkTIqV9X9dVVUppVJpfscA5pDixxyqqytnzJgJ8zsGX6ipqUq7dovm008nZvr0uvkd52sVJWdSnKxFyZkUJ2tRciayzg1FyZkUJ2tRcibFyVqUnElxshYlZ1KcrEXJmRQna1FyJrLODUXJmRQna1FyJsXJWpScSXGyFiVnUpysRcmZFCdrUXImss4NRcmZFCdrUXImxclalJxJsbIuDBZffNFUVyt+QNE46gUAAAAAAAAAoKAUPwAAAAAAAAAACkrxAwAAAAAAAACgoBQ/AAAAAAAAAAAKSvEDAAAAAAAAAKCgauZ3AAAAAAAAAAAWTuVyOTNmzMj06dPndxRYYDRr1izV1dUNXq/4AQAAAAAAAMA8VS6X88knn+SDDz5U+oD/T6mUtG3bNh06dEipVPrW9YofAAAAAAAAAMxTo0aNytixY1Nbu2hat243R083gP9t5UyZMiVjx36SJOnYseO37lD8AAAAAAAAAGCemTFjRj75ZFxat26b1q3bzu84sMBp3rw2SfLJJ59kmWWW+dZiVNW8CAUAAAAAAAAASTJt2rSUy+W0aNFyfkeBBVaLFi1SLn/+5+XbKH4AAAAAAAAAACxQSg1e6agXAAAAAAAAABYYpVIpVVUN/6F3U6mrK6dcLs/zudBYih8AAAAAAAAALBBKpVIWW6x5SqV5/6Pscnl6xo2bOkflj9122ymjR4+q/3V1dU3atm2b9dffIEcccXQ6dVq2STN+Oe/3v780PXtu2qA9PXqslyT585/vzPLLd23SPDO7//778utf//Ib1/z857/MzjvvMtcyLKwUPwAAAAAAAABYIFRVlb4ofRyQZMg8nNwtpVLfVFVNy4wZc/7Uj7XW6p62bdtl8uTJefPN1/PQQ//IM888neuuuzkdOnRsspQbb9wjY8eOzeKLL9HgPZtvvmWSZJFFFm2yHF+lffv29bMmT56cZ555Okmy2Wabp6qqqn4NTU/xAwAAAAAAAIAFzJAkg+Z3iAb70Y8Oq38Cx+TJk3LyySdk4MDnctllF+c3vzmvyeb87GdnzvGe88//XZPN/yYbbLBRNthgoyTJyJEj06vXzkmS3/zmvLRo0WKeZFhYKX4AAAAAAAAAQBOprW2ZQw45IgMHPpcnn3w8U6dOTfPmzfPZZ5/l4osvzBNPPJ4pU6Zk9dXXyLHHnpA11lizfu9LL72Yq666PK+++kqaN2+WNdZYK8cdd2JWXHGlJLMf9TJq1MhcdtnFGTTo+Ywf/1kWX3yJbLvt9jniiKNTU/N5HeCrjnoZOPC5XHvtHzJkyOdPVVlnnXVz5JHHZJVVVq1//ZhjDs+6666f3XbrlT/+8aqMGTMm3bp1y09+clq6dl2hos/my0JI+/Ydsv32O+Suu+5Ix46dcv31ffPBB+/noosuzL///XSSctZdd/2ccMKP06XLcvX777nnrvTte2NGjRqZ9u3bZ/fd98oBB/ygoiz/S6rmdwAAAAAAAAAA+F+yyiqrJEmmTp2ad975T8rlcn784+Ny//33ZbHFFstaa62Vl156Mcccc3jeeec/SZLXX38txx57RJ5//rmssMIK6dChU55+un+OOebwjBs37ivnnHnmz9Kv38Np165d1l9/w0ycOCE33XR9rr76iq/N9vTT/XPccUdm4MDnsvzyXdOxY8f07/+vHH5477z22uBZ1r755uvp0+fXad++Q5JyBg58Lhdc0KfRn8/774/OX/5ya1ZaaZWss866mTx5co4++vA8+mi/dOrUKSuvvEr69/9Xjjzy0Iwb90mS5K677kifPr/Oxx9/nPXX3yCTJk3OpZf+Ptde+6dG5yk6T/wAAAAAAAAAgCbUsuUi9d9PmDAhzz33TF5++aWstNLKueGGW1JdXZ277roj559/Tm69tW9++tPT07fvjZk6dWp22WX3nH7650e6nH32LzJp0sSMHPleFltssdnmvPPOO0mSk076SdZff8MMHz4szz33bLp1W/1rs11yye9TV1eXww8/Oj/60aFJkvPOOyd3331HLr30olx++R/q144fPz5//ON1WWuttfPIIw/l5z8/La+++nKjP59yuZwzzvhFtt12+yTJfffdk/feezebbrpZLrzwkiTJ5Zdfkptuuj733ntPDjro4Fx//TVfXL863bqtnnHjxmXXXXfMLbfcmB/84Idp1qxZo3MVleIHAAAAAAAAADShyZMn1X/fsmXLvPzyi0mSoUPfzKabbjjL2i+LFG+88XqSpEePTepfO+usX33jnAMPPChXXHFpjj32yLRp0yZrr71uNt30O1lttW5fuX7cuHEZPnxYkmSXXXatv77rrrvn7rvvyIsvvpByuTxL9rXWWjtJ6o+bmTJlyjdmaqh11lmv/vvXX//8yJmnnvpX/dE0X3r11ZczduzYfPDB+0mS3r0PnO1eb7/9VlZeeZUmyVVEih8AAAAAAAAA0ISGDfu8XFFdXZMuXbrk+eefS5IsueSSWX31NWdZ27ZtuySpL1zMmDG9/rUpU6akRYsWXzvnoIN6p2fPTfPEE4/lhRcGZeDAZ/Pkk4/n/vvvzZ/+dMNs66uqqubofdTWtqz/vqamaesFrVq1mu3eyy67bFZYYaVZ1i2/fNdZZm+66Waprp41S6lUatJsRaP4AQAAAAAAAABNZOrUqenb98YkyZZbbpXa2pb1ZYbmzVvk7LN/k9ralvnnP/tl8OBXsuGGGydJVlll1fznP2/nqaeerD8C5fTTT82gQQNz8sk/zU47fX+WOWPGjMk111ydDz/8ML/85a9zyCGH5+OPP8pOO22XV155OZ9++mnatGkzy57WrVunS5fl8s47/8l9991bf9TLvffenSRZZ511ZylRzM1CxcwllC8/n3btlsi5516Q6urq3H33Hfnggw+y2Wabp3Xr1llqqaXz4YcfZM8990nPnptmzJgx+eMfr0rXritk+eWXn2s5i0DxAwAAAAAAAAAa4dpr/5i7774z06dPz5tvvp4PP/wwiy3WNsccc3ySZMMNN0q3bqtnyJDB2XvvXunUqVNefvmlzJgxI927r5MkOeCAH+Sxx/6Zf/zj7xk+fHhqaqozePCradu2bTbeuMdsM9u1a5dXX30lr702JPvuu0dWXHGlvP32W0mSbt1Wn6308aUjjzw2Z5xxav7whyvyr389kalTp2To0DdTW1ubY489Ye58QN9i++13zLXX/jEvv/xi9t13j7Rt2y6vvPJSampqssUWWyZJDjro4Fx44fk59dQfZ+2118nw4cMzZszH2XLLrbP33vvOl9wLCsUPAAAAAAAAABYw3Qo17+WXX0qSVFdXp23bdtlxx51y6KFHpGPHTkk+f3LGhRdekssuuzj9+z+ZwYNfTdeuK+Tggw/J5ptvkSRZbbXVc8klV+Tqq6/IkCGD06JFi/TsuWmOPvq4LLnkUrPNLJVKueiiy3L11Vfkqaf+leeeeybt2i2e739/txx55NFfm3XrrbfJxRdfkRtuuCZDhgxOkvTsuWmOOurYrLLKqo36HCpVW1ubyy+/OpdddnEGDnw2H374QdZcc60cccTRWW211ZMke+21b8rl5M47b8uLL76QxRZbLHvvvV+OPvq4+ZJ5QaL4AQAAAAAAAMACoa6unHJ5ekqlvvN8drk8PXV15Tnac889f2vw2sUXXzxnnfWrb1yz7rrr56qrrmnwvLZt2+WnPz3jG+/59NPPz3Zto402zkYbbfy1e9Zff4PZ9nXu3OUr7/VVOnbs+JVrv+56kiy7bOf06fPbb7zv3nvvu9A/3eOrKH4AAAAAAAAAsEAol8sZN25qqqqmzfPZn5dO5qz4AQsCxQ8AAAAAAAAAFhjlcjkzZihgQENVze8AAAAAAAAAAABURvEDAAAAAAAAAKCgFD8AAAAAAAAAAApK8QMAAAAAAAAAoKAUPwAAAAAAAAAACkrxAwAAAAAAAACgoBQ/AAAAAAAAAAAKSvEDAAAAAAAAgAVGqVRKdXXVPP8qlUpznHW33XZKjx7rZcCAp+bCJ9F08x5++MEMGza00feZ2VFHHZYePdab5WuLLXpm9913zm9/e14mTpxY8b0XRPfff1969Fgvhxxy0PyOMpua+R0AAAAAAAAAAJLPSx+tW9emunreP8Ngxoy6fPbZ5JTL5Xk+u6E23rhHxo4dm8UXX6LBe0488Zg8/fSAXH75Hxp1n6+z8sqrpEOHjkmSiRMn5qWXXsgdd/wlEydOyFlnnd3o+y8o2rdvn8033zJduiw3v6PMRvEDAAAAAAAAgAVCVdXnT/u47rrrMnr06Hk2t3379undu3eqqkqZMWPBLX787GdnzvGeYcOGNcl9vs7uu++ZXr32rP/1I488lJ///LQ8+OA/cuqpp6e2trbJZs1PG2ywUTbYYKP5HeMrKX4AAAAAAAAAsEAZPXp0RowYMb9jNJmBA5/Ltdf+IUOGDEmSrLPOujnyyGOyyiqr1q95+eUXc9FFF+bNN99Ix46dcuKJJ+fss3+RMWM+ztNPP5/k8yNaRo8eld///tL07LlpRo0amcsuuziDBj2f8eM/y+KLL5Ftt90+RxxxdGpqarLbbjvlww8/SJIcc8zh+d73vp+zzvrVbPdJkieffDzXXfenDB36ZhZZZJGsv/6GOe64E9O+fYc5eq9fPhFjxozpmTJlcmprazN16tRceeVlefDBBzJ+/GdZccWVcthhR2WTTTado/ffo8d6SZKTTz4111zzh9TWtkzfvrelrq4uF198YZ544vFMmTIlq6++Ro499oSsscaaSZJx48bl8ssvyYABT+WTT8ambdu22WyzzXPssSdm0UUXTZI89tg/c8MN1+Y///lPkmT55bvmRz86NJtttnmSz496+fWvf5k11lgz11xzY5Jk+vTpueWWm3L//fdl1KiRWXzxJbLNNtvm8MOPTG1tyyTJ2Wf/In//+1/zk5/8NMOGDcvDD/8jLVsuki233DonnPDj1NQ0vrYx75+PAwAAAAAAAAALiaef7p/jjjsyAwc+l+WX75qOHTumf/9/5fDDe+e11wYnST7++KOccMKxefXVV7L00sukbdu2+elPT8748Z99473PPPNn6dfv4bRr1y7rr79hJk6ckJtuuj5XX31Fks+PdGnRokWSpHv3dbLqqqt95X2eeurJnHrqjzN48Kvp1m31LLZY2/Tr93COP/7oTJ8+rUHvs1wu57PPPsvtt/85SbLssstmscXaJknOPvus3HrrzWnWrFnWWWe9DB8+PD/5yQl5/vmBFb3/Sy+9KF27rpA11lgziyyySH784+Ny//33ZbHFFstaa62Vl156Mcccc3jeeefzEsdvf9sn9913d1q0aJENN9w4SXL33Xfm3HP/L0ny1lvDc8YZP83QoW9m9dXXyCqrrJIhQ17NT3/6kwwbNvRr3/PZZ/8iV1xxaT766MOsvfY6mTJlcm655aYcf/wxmT59+ixrr776ijzzzNNZbrnl8+GHH+T22/+cBx98oEGf7bfxxA8AAAAAAAAAmEsuueT3qaury+GHH50f/ejQJMl5552Tu+++I5deelEuv/wPueOO2zJx4oSstdbaufLKP6ampiZ33PGX/Pa3533jvd95550kyUkn/STrr79hhg8flueeezbduq2e5PMjXfr3fyoffvhBjjji6Ky//gZfeZ/rr78m5XI5RxxxdHr3PjTTp0/PT396chZZZJG8//776dRp2a/NcP755+T888+Z5Vrr1q3rj5MZMeKdPPLIQ2nXbvH8+c93pmXLlhkw4KmcdNJxufHG67LeeuvP8fs/9NAjctBBvZMkzz7777z88ktZaaWVc8MNt6S6ujp33XVHzj//nNx6a9/89Ken1xdAfvSjw7LddjtkzJiP8/DDD2WllVZOkrz77ojMmDEjq63WLb/4xf9lqaWWyoMPPpAZM2akdes2X5lhyJDBeeihB9KiRW2uv75vunRZLuPGfZIDD9w3L730Qh566B/53vd2rl+/9NLL5Prr+6ZZs2Y56aTjMmDAU3nllZez007f/9rPtqE88QMAAAAAAAAA5oJx48Zl+PBhSZJddtm1/vquu+6eJHnxxRdSLpfz1lvDkySbb75F/dEf222347fe/8ADD0qSHHvskdl++61y1VWXp0WLFllttW5zlPONN95IkvTsuUmSpKamJhdeeHH+7//O/cbSR5KsvPIq2XDDjetz9+ixSe64496sv/6GX9z79STJ2LFjstVWm6ZHj/Vy0knHJUleffXlJJnj97/OOuvVf//6668lSYYOfTObbrphevRYr76I8uX999//B6mqqsrZZ5+V7bbbMr/5za9SVVXKmmt+fhTMBhtslNVW65ZXX30l3//+9tl7793zwguD0rFjpyy99NJfmWHQoOe/yLJO/fE2iy3WNltuufUsr39p3XXXS7NmzZIkK664UpJk6tQpX/se54QnfgAAAAAAAADAXFBV1bBnMcyYMSNJUi7P2f0POqh3evbcNE888VheeGFQBg58Nk8++Xjuv//e/OlPN8xp3EyfPqP++8mTJ6e2tvZb9+y++57p1WvPvPrqKznmmMPz9NP9c801f8yPf3xKktQXOVq1apX11pv1iSOlUil1dXVz/P5btWpV//2X919yySWz+uprzrKubdt2SZLtt98xa6yxZh577J8ZNGhgXn755fz730/njjtuS9++f0nLli3zpz9dn/79n8rTTw/ISy+9kHvuuTN3331HTj319PTqtedsGaqqSt+YsVSa9fXa2pazZZ7T3++v44kfzHdVVaXU1FRV9FVd/fm/wtXVle2vqan61j+QAAAAAAAAAJVo3bp1/dMg7rvv3vrr9957d5JknXXWTalUygorrJgkefLJxzN9+vQkyd/+dt833nvMmDG54IJz88c/XpX99jswl156ZW6//Z4kySuvvJxPP/00yX/LJ3V1M77uVll55c+PPHnqqSe/WFuXww47ONtuu0WeffbfDXqva6yxZn7841OTJLfddmsefPCBJKl/b+VyctppP8/55/8u++57QDp27JTtt/9eqqqq5vj9z1yoWWGFz5+e0bx5i5x99m9y/vm/yw477JQuXZbLNttsm6lTp+aii36b3/3ugmy33Q658MJLcv/9D2bRRVvlvffezX/+85/07/+v/N///TLDhg3Nqaf+LDff/JccddSxSZIBA5762vebJC+88EL9UTLjxn2Sxx77Z5Jk3XXXnWX9/18EaUqe+MF8VVVVyuKL16ZUaty/im3atPz2RV+jXJ6eMWMmp66uiepUAAAAAAAAwELlt789L4ssssgs17p0WS6/+c15OfLIY3PGGafmD3+4Iv/61xOZOnVKhg59M7W1tTn22BOSJL167Zm//OWWvPzyi9lvvz3Ttm27vPnm6984s127dnn11Vfy2mtDsu++e2TFFVfK22+/lSTp1m31tGnTJknStm3bvP/+6Pz2t+dl002/k+OPP2m2e/3whz/KKaeclOuu+1Oee+7ZTJgwPsOHD8uyy3bOWmut3eDPYZdddsuAAU/l0Uf75cILz8sGG2yYzp27ZKuttsmjj/bL/vvvmRVXXCmvvvpKJk+enI4dO1X8/r+04YYbpVu31TNkyODsvXevdOrUKS+//FJmzJiR7t3XSfPmzTNq1Kj07/+vHHTQfunWbY2MGjUyEyaMzzLLtM9yyy2fGTNm5J//fCTTpk3Lk08+kVatWuXFF19Ikmy8cY+vnLvWWmvnO9/ZIk8++XgOPviArL76mhk27M2MHTs23buvk2233aHBn1tjKX4wX1VVlb4ofRyQZMh8SNAtpVLfVFWVFD8AAAAAAABgAdG+fftCzXvvvXe/9rWtt94mF198RW644ZoMGTI4SdKz56Y56qhjs8oqqyZJllmmfS666LL87ne/zVtvDUuLFi1y3nm/ywknHJ1mzZp95X1LpVIuuuiyXH31FXnqqX/lueeeSbt2i+f7398tRx55dP26Qw45Ir/73fkZPXpUxo375Cvv9Z3vbJE+fX6b6677U157bXBatWqVbbbZNsccc3yDjnuZ2Wmn/TyvvPJyPvzwg5x//rk577wLc+aZv8pSSy2dRx99JC+99GI6dOiYvffeL3vuuXfF73/mz+HCCy/JZZddnP79n8zgwa+ma9cVcvDBh2TzzbdIkvzqV7/Jn/50dR59tF8GDnw2rVu3yTbbbJsjjzwmtbW1WX31NXLRRZfnuuv+mDfeeD3Tpk3Lsssum91337M+41c555zzc/PNN+SBB/6WF18clLZt22X//X+Qww47sv44l3mhVC431akxC4cZM+oyZsyE+R3jf0ZNTVXatVs0yXpJBs2HBOsmeT5jx07I9Ol1c23Kl+9zbs9pCkXJWpScSXGyFiVnIuvcUJScSXGyFiVnUpysRcmZFCdrUXImxclalJxJcbIWJWci69xQlJxJcbIWJWdSnKxFyZkUJ2tRcibFyVqUnElxshYlZyLr3FCUnElxshYlZ1KcrEXJmRQr68Jg8cUXTXV11bcvbKTJkydn2LDhWXLJ9mnevMUsr5VKpbRuXTtPcvz/Zsyoy2efTc78+BH6wIHP5qWXXsySSy6ZHXfcKTU1zfLWW8Oz3357pn379rnnnr/P80zz0sL+/r/K1KlT8tFHo7Piiit8a/nGEz8AAAAAAAAAWCCUy+V89tnkVFWV5vnsurryfCl9JEmpVJWrr74iSXL77X/J4osvkcGDX0mSbLHFVvMl07y0sL//xlL8AAAAAAAAAGCBUS6XM2PGwnVwxXrrrZ/TTz8rt912a/7zn7czbNiwLLnkktlpp11y5JHHzO94c93C/v4bS/EDAAAAAAAAAOazXXbZLbvsstv8jjHfLOzvvzHm/cFIAAAAAAAAAAA0CcUPAAAAAAAAAICCUvwAAAAAAAAAACgoxQ8AAAAAAAAAgIJS/AAAAAAAAAAAKCjFDwAAAAAAAACAgqqZ3wEAAAAAAAAA4EulUilVVaV5PreurpxyuTzP50JjKX4AAAAAAAAAsEAolUpp06Y2VVXz/vCKurq6fPrp5Dkqf+y2204ZPXpUfvjD3jnqqOPqrw8c+FyOOebwrLvu+rnyyj826F73339ffv3rX2aNNdbMNdfcOMf5G+qoow7LoEEDZ7nWrFmzLLXU0tl5513Tu/chKZXmffGGyil+AAAAAAAAALBAqKoqpaqqKkOGDMnEiRPn2dxFFlkk3bp1S1VVKTNmzPlTP/r2vSk77LBTunZdoeIM7du3z+abb5kuXZar+B5zYuWVV0mHDh1TLpczceKEvPTSi/nDH67IjBnTc9hhR86TDDQNxQ8AAAAAAAAAFigTJ07M+PHj53eMBps+fXrOP/+cXHnlnyq+xwYbbJQNNtioCVN9s9133zO9eu1Z/+t77rkzffr8Jv36Paz4UTDz/vk4AAAAAAAAAPA/pKqqKoMGPZ/777/va9cMGzY0J554TLbbbst85zsbp1ev7+eaa/5Q//r999+XHj3WyyGHHJQk2WefXunRY7088shD9Wv+85+306PHetlmm80zadKkJMk999yVvfbaLZtttlH23HOX9O17U0XvYcqUqUmSTp061V/74IP387OfnZIdd9wmm222Ub7//R3y+99fkGnTpuXjjz/OpptulB491svIkSPr99x44/Xp0WO9/PSnJydJpk6dmosv/l2+971ts/nmPdK794Hp3/+p+vVTp07NJZf8PrvttlM237xHvve9bXPmmT/LRx99WNH7WBgpfgAAAAAAAABAI+y++x5Jkssuuyjjxo2b7fWpU6fmxBOPydNPD0j79h2y9trr5sMPP8gf/3hVnnji8a+85y677J4keeCB++uv/f3vf02SbLfdDmnZsmXuuuuO9Onz63z88cdZf/0NMmnS5Fx66e9z7bXf/uSRu+++I6ee+uOccspJOeyw3vn97y9I+/btc+yxJ9avOfXUH+fRR/uldes22WCDDTN+/Gf5y19uzV133ZElllgim2yyaZLMUk559NFHkiTf+97OSZKzzz4rt956c5o1a5Z11lkvw4cPz09+ckKef35gkuRPf7o6t9xyU+rq6rLBBhulZcuWefjhB+uLI3y7QhU/pk2blj59+qRnz57p3r17evfuneHDh3/l2ksvvTSrrrrqV36ddtpp8zg5AAAAAAAAAP+r9t33gKy00sr55JNPctllF8/2+uTJk3PIIYfn+ON/nBtvvDWXXXZVdt3182LH22+/9ZX33Hnn76d58+Z5+umnM2bMmNTV1eUf/3ggSer3Xn/9NUmSyy+/OhdffEVuueX21NbW5pZbbsy0adO+MfObb76RJ554LE8++XhefvnFJEmpVJXRo0cl+byssueee+eww47Mn/98Zy666PIceugRs2T+/vd3TZI88siDSZKRI0dmyJDBWWyxttl0080yYsQ7eeSRh9Ku3eL585/vzCWXXJE+fS5IXV1dbrzxuiTJO+/8J8nn5Zlzz70gN954a4499oT88IeHZMaMGd/62ZPUzO8Ac+Kiiy7Kddddl3bt2qVr167p379/Dj300Pztb39Ly5YtZ1m7wgorZJtttpnl2tNPP50JEyakW7du8zI2AAAAAAAAAP/Dqqtr8tOfnp7DD/9R7r//3nTs2HGW19u0aZOtt942Dz/8YM466/QMGTI4I0a8kySZOnXKV95zscXaZsstt85DD/0jDz30QFZYYaW8//7orLLKallttW4ZO3ZsPvjg/SRJ794Hzrb/7bffysorr/K1mU899fT06rVnyuVyJkwYn7vuuiNXXHFpTjvtlNx1131ZYokl893vbpdHHnk4v/nNr/Laa0MyfPiwWTJvsslmWXzxJfLGG6/nnXf+kyeeeCzJ508kqalpljfeeD1JMnbsmGy11aazzH/11ZeTJHvttW8GDHgqV199Ra6//pp067Z6NtqoZ9ZYY81UV1d/4+fO5wpT/JgyZUpuvfXWlEql3HbbbenSpUsOOOCAPPfcc3n44Yezyy67zLJ+p512yk477VT/6wEDBqRfv37ZYost8sMf/nBexwcAAAAAAADgf9haa62d3XbrlbvvvjPXX3/tLK+9//7oHHnkoRkz5uPsuec+2W67HfL00wNyxx1/Sblc/tp77rbbHnnooX/kkUceSteuQ7+41itJUlPz3x/3b7rpZqmunvXH/6VSqUG5S6VSWrVqnR/84ODceON1GT9+fF588YVsvHHPHHXUYRk69I3sumuvHHLIERkx4j+58srL8mXkmpqa7LjjTunb98Y8/PCDeeqpJ5MkO+208ywZW7VqlfXW22C2uXV1dVl//Q1yxx335bHH+mXgwOfy8ssv5YUXBuXPf+6bvn1vy1JLLdWg97EwK8xRL6+//nomTJiQDh06pEuXLkmSnj17Jkmef/75b9w7ZcqUnHXWWWnevHnOPPPMuZ4VAAAAAAAAgIXP0Ucfn8UXXyJTpkye5fojjzycUaNGZq21uue4407Mppt+p/6Ik2+y3nrrZ7nlls+rr76SRx/tl9ra2my//Q5JktatW2eppZZOkuy55z45//zf5bTTfp4lllgyG2ywUZZffvk5yv7++6MzefLnudu0aZN///vpvPHGa+nYsWNOPfVn2XrrbfLuu+/Otu/L417uuefODB78alZYYcWsttrqSZIVVlgxSVIuJ6ed9vOcf/7vsu++B6Rjx07ZfvvvpaqqKldffUXOO+83WXPN7unT57e5//4Hs/zyXfPpp+PqnwrCNyvMEz9GjhyZJGnXrl39tS+/Hz169Dfuve+++/LOO+9k3333TefOnedeSAAAAAAAAAAWWq1bt84JJ/w4v/jFGbNc79SpU5LkueeezeGH/yiffDK2vvgxadKkb7znrrv2yiWX/C7jx4/PzjvvkkUXbVX/2kEHHZwLLzw/p57646y99joZPnx4xoz5OFtuuXX23nvfb7zv3Xffkaef7p8kmTJlcgYPfjXTp0/Pcsstn3XWWS/Dhn3+hJF33303Bx98QMrlcv3RLZMmTay/z/LLd81aa3XPyy+/lCT53vd2rn+tc+cu2WqrbfLoo/2y//57ZsUVV8qrr76SyZMnp2PHTvXv/1//eiLPP/9cundfO2PHjs3bb7+VVq1aZfXV1/zG98DnClP8+LJZNPPjapo1azbLa1/nhhtuSJIcfPDBTZKlpqYwD0pZ4FVXLxif5dzO8eX9F5T3+02KkrUoOZPiZC1KzkTWuaEoOZPiZC1KzqQ4WYuSMylO1qLkTIqTtSg5k+JkLUrORNa5oSg5k+JkLUrOpDhZi5IzKU7WouRMipO1KDmT4mQtSs5E1rmhKDmT4mQtSs6kOFmLkjMpVlbmrUUWWaSw87bffsfcf/99efbZf9df23LLrdO796G577578uabr6dr1xVz5JHH5KqrLs8LL3zzCRc77bRzrrrqskydOjW77LL7LK/ttde+KZeTO++8LS+++EIWW2yx7L33fjn66OO+Neebb76RN998I0lSXV2dRRZZJFtssVVOPPHk1NTUZNVVV8tPfnJabr75+rz99ttZdtllc+KJJ+fii3+Xl19+MTNmzEh1dfUXGXfJyy+/lOrq6my//fdmmXPmmb/KUkstnUcffSQvvfRiOnTomL333i977rl3kuS4407M4osvnr/97a8ZNGhQFlmkZXr23DRHHHFUll566W//wEmp/E0HBi1AHnjggZx44olZY401ctdddyVJ+vbtm7PPPjtbbbVVrrrqqq/c99JLL2WvvfaaZV9jlMvlBp+FxJxYL8mg+TB33STf/B9SAAAAAAAAoOlMnjw5w4YNz5JLtk/z5i1mea1UKqVNm9pUVc37MlBdXV0+/XRyCvIj9AXKb3/bJ3fccVt69OiZiy66fH7H+Z8wdeqUfPTR6Ky44gqpra39xrWFeeLHMssskyQZN25c/bWxY8cmSTp06PC1+/71r38lSbbaaqsmyVFXV86nn0789oU0SHV1Vdq0aTm/Y+TTTydlxoy6uXb/L9/n3J7TFIqStSg5k+JkLUrORNa5oSg5k+JkLUrOpDhZi5IzKU7WouRMipO1KDmT4mQtSs5E1rmhKDmT4mQtSs6kOFmLkjMpTtai5EyKk7UoOZPiZC1KzkTWuaEoOZPiZC1KzqQ4WYuSMylW1oVBmzYt5/vTV8rlcj79dHKqqub9/4xfV1dW+phDf/zjVXn11Zfz738/nSTZe+/953OihVNhih/dunVLbW1t3nvvvYwYMSKdO3fO009//i/P+uuv/7X7/v3vzx+f07179ybLMn26v3T+18yYUTdPfl/n1ZymUJSsRcmZFCdrUXImss4NRcmZFCdrUXImxclalJxJcbIWJWdSnKxFyZkUJ2tRciayzg1FyZkUJ2tRcibFyVqUnElxshYlZ1KcrEXJmRQna1FyJrLODUXJmRQna1FyJsXJWpScSbGyMveVy+XMmKGAUQSfffZZnn9+YJZZZpnst9+B2WSTTed3pIVSYYofLVu2zD777JMbbrgh++yzT5ZZZpkMHjw4yy67bLbddtsMGDAgN910U7p27ZpTTjmlft97772XJFl55ZXnV3QAAAAAAAAA+J/z4x+fkh//+JRvX8hcNX+f0zOHTj311Bx66KFJkqFDh2aTTTbJn/70p7Ro0SKjRo1Kv3798uyzz86y5+OPP06SLL744vM8LwAAAAAAAADA3FSYJ34kSU1NTU455ZRZnujxpV69eqVXr16zXR80aNC8iAYAAAAAAAAAMM8V6okfAAAAAAAAAAD/+8oNXqn4AQAAAAAAAMA806xZs5RKpUyZMml+R4EF1pQpU1Iqff7n5dsU6qgXAAAAAAAAAIqturo6bdsulrFjx2batGlp2XLRVFdXz+9YsIAoZ8qUKfnss0/Srl3bBv3ZUPwAAAAAAAAAYJ7q0KFDFllkkbz//gcZO3bi/I4DC5RSKWnXrm06dOjQoPWKHwAAAAAAAADMU6VSKW3bts1iiy2WGTNmZPr06fM7EiwwmjVrNkdPwVH8AAAAAAAAAGC+KJVKqampSU2NH11DparmdwAAAAAAAAAAACqj+AEAAAAAAAAAUFCKHwAAAAAAAAAABaX4AQAAAAAAAABQUIofAAAAAAAAAAAFpfgBAAAAAAAAAFBQih8AAAAAAAAAAAWl+AEAAAAAAAAAUFCKHwAAAAAAAAAABaX4AQAAAAAAAABQUIofAAAAAAAAAAAFpfgBAAAAAAAAAFBQih8AAAAAAAAAAAWl+AEAAAAAAAAAUFCKHwAAAAAAAAAABaX4AQAAAAAAAABQUIofAAAAAAAAAAAFpfgBAAAAAAAAAFBQih8AAAAAAAAAAAWl+AEAAAAAAAAAUFCKHwAAAAAAAAAABaX4AQAAAAAAAABQUIofAAAAAAAAAAAFpfgBAAAAAAAAAFBQih8AAAAAAAAAAAWl+AEAAAAAAAAAUFCKHwAAAAAAAAAABaX4AQAAAAAAAABQUIofAAAAAAAAAAAFpfgBAAAAAAAAAFBQih8AAAAAAAAAAAWl+AEAAAAAAAAAUFCKHwAAAAAAAAAABaX4AQAAAAAAAABQUIofAAAAAAAAAAAFpfgBAAAAAAAAAFBQih8AAAAAAAAAAAWl+AEAAAAAAAAAUFCKHwAAAAAAAAAABaX4AQAAAAAAAABQUIofAAAAAAAAAAAFpfgBAAAAAAAAAFBQih8AAAAAAAAAAAWl+AEAAAAAAAAAUFCKHwAAAAAAAAAABaX4AQAAAAAAAABQUIofAAAAAAAAAAAFpfgBAAAAAAAAAFBQih8AAAAAAAAAAAWl+AEAAAAAAAAAUFCKHwAAAAAAAAAABaX4AQAAAAAAAABQUIofAAAAAAAAAAAFpfgBAAAAAAAAAFBQih8AAAAAAAAAAAWl+AEAAAAAAAAAUFCKHwAAAAAAAAAABaX4AQAAAAAAAABQUIofAAAAAAAAAAAFpfgBAAAAAAAAAFBQNU11o7q6urz22msZNWpUxo8fn1133TVJMmLEiHTu3LmpxgAAAAAAAAAA8IVGFz8++eSTXHHFFbnrrrsyYcKE+utfFj+OPfbYTJ8+PWeccUY22WSTxo4DAAAAAAAAAOALjTrqZdiwYdl9991z0003Zfz48SmXyymXy7OsGTlyZIYPH55DDz00d955Z6PCAgAAAAAAAADwXxUXPyZNmpTDDz88o0aNSqtWrXLUUUfliiuumG3dIYcckjZt2qSuri6/+tWv8tZbbzUqMAAAAAAAAAAAn6u4+HHzzTfnvffey9JLL5377rsvJ5xwQnr06DHbuiOPPDK333572rdvn2nTpuWmm25qVGAAAAAAAAAAAD5XcfHjoYceSqlUygknnJAOHTp849ouXbrkxBNPTLlcTv/+/SsdCQAAAAAAAADATCoufrz99ttJks0226xB6zfeeOMkyahRoyodCQAAAAAAAADATCoufkydOjVJ0qJFiwatb968+ecDqyoeCQAAAAAAAADATCpuYSy99NJJkiFDhjRo/fPPPz/LPgAAAAAAAAAAGqfi4kePHj1SLpdz9dVXf+vayZMn59JLL02pVKo/8gUAAAAAAAAAgMapuPhx8MEHp7q6Ov/+979z/PHH57333vvKdS+99FIOOuigvPHGGymVSjnggAMqDgsAAAAAAAAAwH/VVLpxxRVXzE9+8pOcd955efjhh/Pwww+nXbt29a/vu+++effdd/Pxxx/XXzvqqKOy6qqrNi4xAAAAAAAAAABJGlH8SJLevXunVatW6dOnTyZMmJAxY8bUv/bCCy/Uf9+8efMcf/zxOfTQQxszDgAAAAAAAACAmTSq+JEke+21V3bcccfcd999eeaZZ/LOO+9kwoQJqa2tTYcOHbLBBhtkt912y5JLLtkUeQEAAAAAAAAA+EKjix9J0qpVq+y///7Zf//9m+J2AAAAAAAAAAA0QFVjbzBt2rTcc889ufvuu2d77eGHH86PfvSj3HnnnZkxY0ZjRwEAAAAAAAAAMJNGPfFj6NChOeaYY/LOO+9k4403zu677z7L62+++Wb69++fAQMG5KabbspVV12V9u3bNyowzC9VVaVUVZUq2ltdXTXLPytRV1dOXV254v0AAAAAAAAA/O+puPgxbty4HHzwwfn4449TLpe/8okeXbt2Tffu3fPSSy/ltddey6GHHpo777wzLVq0aFRomNeqqkpZfPHalEqNOx2pTZuWFe8tl6dnzJjJyh8AAAAAAAAA1Kv4p9jXXnttPvroo7Rq1Sp9+vTJd7/73dnW7Ljjjtlxxx3z+OOP5+STT86wYcPSt2/f/OhHP2pUaJjXqqpKX5Q+DkgyZD4k6JZSqW+qqkqKHwAAAAAAAADUq7j48c9//jOlUiknnXTSV5Y+ZrbFFlvk2GOPTZ8+ffK3v/1N8YMCG5Jk0PwOAQAAAAAAAABJkqpKN7777rtJkq233rpB679cN3z48EpHAgAAAAAAAAAwk4qLH9XV1UmSZs2aNWh9q1atkiTlsmMqAAAAAAAAAACaQsXFj06dOiVJnnnmmQatHzTo8+Mx2rdvX+lIAAAAAAAAAABmUnHxY8stt0y5XM5FF12UcePGfePa8ePH5/e//31KpVI222yzSkcCAAAAAAAAADCTiosf++yzT1q2bJkRI0Zk9913z913350xY8bMsuaTTz7JX//61+yxxx4ZOnRomjVrlh/+8IeNDg0AAAAAAAAAQFJT6caOHTvmnHPOycknn5xRo0bl9NNPT5K0atUqtbW1mTx5csaPH58kKZfLqaqqyq9//et07ty5aZIDAAAAAAAAACzkKn7iR5LsuOOOufnmm7PyyiunXC6nXC7ns88+y4cffpjPPvus/tpKK62Ua665JrvssktT5QYAAAAAAAAAWOhV/MSPL6233nq57777MnTo0AwYMCDvv/9+xo0bl9ra2nTs2DHrrbde1l577abICgAAAAAAAADATBpd/PjSSiutlJVWWqmpbgcAAAAAAAAAwLdo1FEvAAAAAAAAAADMP03yxI/Bgwfn3XffzaRJk1Iul791/W677dYUYwEAAAAAAAAAFmqNKn4MGDAgZ555Zt57770G7ymVSoofAAAAAAAAAABNoOLix/Dhw3PEEUdk2rRpDXrKBwAAAAAAAAAATavi4scf//jHTJ06NTU1NfnBD36QLbfcMksssUSaN2/elPkAAAAAAAAAAPgaFRc/BgwYkFKplKOPPjpHH310U2YCAAAAAAAAAKABqird+PHHHydJdtttt6bKAgAAAAAAAADAHKi4+NG2bdskSW1tbVNlAQAAAAAAAABgDlRc/Nhggw2SJM8//3yThQEAAAAAAAAAoOEqLn707t07VVVVufjiizNx4sSmzAQAAAAAAAAAQAPUVLqxe/fu+eUvf5lf/vKX2XXXXbP//vune/fuadeuXZo1a/aNezt37lzpWAAAAAAAAAAAvlBx8WPLLbdMklRXV+fdd9/N+eef36B9pVIpgwcPrnQsAAAAAAAAAABfqLj4MXr06KbMAQAAAAAAAADAHKq4+HHuuec2ZQ4AAAAAAAAAAOZQxcWP3XffvSlzAAAAAAAAAAAwh6rmdwAAAAAAAAAAACozT4sf06dPzz//+c+K90+bNi19+vRJz54907179/Tu3TvDhw//xj033nhjtt9++3Tv3j277rprnnzyyYrnAwAAAAAAAAAsSCo+6iVJ6urqcs899+TJJ5/M2LFjM3369JTL5dnWTJs2LRMnTsyoUaMyZcqUDB48uKJ5F110Ua677rq0a9cuXbt2Tf/+/XPooYfmb3/7W1q2bDnb+ssuuyyXXnppWrdunbXXXjvPPvtsjjnmmNx9991ZccUVK8oAAAAAAAAAALCgqLj4MWPGjBx22GEZMGDAbK99Wf4olUrfeG1OTJkyJbfeemtKpVJuu+22dOnSJQcccECee+65PPzww9lll11mWf/pp5/m6quvTqlUys0335zVVlstv/71r/Pggw9m4MCBih8AAAAAAAAAQOFVfNTLvffem/79+6dcLqdFixZZbbXV0qVLl5TL5XTu3Dnrrbdell9++SSflz5KpVJ23XXX3HLLLRXNe/311zNhwoR06NAhXbp0SZL07NkzSfL888/Ptv6ZZ57J1KlTs9xyy2W11VZLkvz85z/Pk08+mb333ruiDAAAAAAAAAAAC5KKn/jx97//PUmy8sor59prr81SSy2V5557LgceeGDWWGONXHTRRUmS0aNH54wzzshTTz2Vl19+OWeffXZF80aOHJkkadeuXf21L78fPXr0bOtHjBiRJGnVqlVOOeWUPPzww+nSpUtOPfXUbLbZZhVl+FJNTcV9Gf4/1dULxmf5bTmKkrMpZywo7/nrFCVnUpysRcmZyDo3FCVnUpysRcmZFCdrUXImxclalJxJcbIWJWdSnKxFyZnIOjcUJWdSnKxFyZkUJ2tRcibFyVqUnElxshYlZ1KcrEXJmcg6NxQlZ1KcrEXJmRQna1FyJsXKCrCgqrj48dprr6VUKuW4447LUkstlSTp3r17ampq8vTTT9eva9++fa688srsscceGTp0aO66667st99+czxv8uTJnweu+W/kZs2azfLazCZOnJgkeeWVVzJq1KistdZaefbZZ3PEEUfkzjvvrH8KyJyqqiqlXbtFK9rLgqtNm5bzO0KDzMucPpOmV5SsRcmZyDo3FCVnUpysRcmZFCdrUXImxclalJxJcbIWJWdSnKxFyZnIOjcUJWdSnKxFyZkUJ2tRcibFyVqUnElxshYlZ1KcrEXJmcg6NxQlZ1KcrEXJmRQna1FyJsXKCrCgqbj4MW7cuCRJt27d6q81b948yy+/fIYNG5b33nsvnTp1qr9+6KGH5qc//WkeeOCBioofLVq0SJJMnz69/tq0adOSJLW1tbOt//JaTU1N7rzzznTo0CGXXXZZLr300tx666351a9+NccZkqSurpxPP51Y0V5mV11dtUD8Rf7pp5MyY0bd175elJxN4cv3Oi9mNUZRcibFyVqUnImsc0NRcibFyVqUnElxshYlZ1KcrEXJmRQna1FyJsXJWpSciaxzQ1FyJsXJWpScSXGyFiVnUpysRcmZFCdrUXImxclalJyJrHNDUXImxclalJxJcbIWJWdSrKwLgzZtWnr6ChRQxcWP5s2bZ/r06WnVqtUs15dbbrkMGzYsQ4cOrS9+JMn666+fJBk2bFhF85ZZZpkk/y2cJMnYsWOTJB06dJhtfceOHZMkiy22WP3r3bt3T/LVR8PMienT/aXzv2bGjLpC/L7Oy5w+k6ZXlKxFyZnIOjcUJWdSnKxFyZkUJ2tRcibFyVqUnElxshYlZ1KcrEXJmcg6NxQlZ1KcrEXJmRQna1FyJsXJWpScSXGyFiVnUpysRcmZyDo3FCVnUpysRcmZFCdrUXImxcoKsKCpuK615JJLJknef//9Wa536dIlSfLmm2/Ocn2RRRZJMmtxY05069YttbW1ee+99zJixIgkqT9S5stSycw23HDDVFdXZ8yYMXnttdeSJEOHDp0lIwAAAAAAAABAkVVc/FhnnXWSJHfeeecs11dYYYWUy+U899xzs1x/4403kiTNmjWraF7Lli2zzz77pFwuZ5999snuu++eZ599Nssuu2y23XbbDBgwIEcffXQuuOCCJJ8XU/bff/+Uy+UccMAB+eEPf5gLL7wwtbW1OfDAAyvKAAAAAAAAAACwIKm4+LHzzjunXC7n5ptvzllnnZXhw4cnSXr06JGqqqo88cQTeeihh5IkH3/8cX0ho2vXrhWHPfXUU3PooYcm+fzpHZtsskn+9Kc/pUWLFhk1alT69euXZ599tn79z372sxxzzDFZZJFF8tJLL2WdddbJjTfemOWWW67iDAAAAAAAAAAAC4qaSjd+5zvfyZZbbpnHHnsst99+e8aPH5/f/e536dy5c7773e/moYceygknnJB27dpl3LhxqaurS6lUyk477VR52JqanHLKKTnllFNme61Xr17p1avXLNeqq6tz/PHH5/jjj694JgAAAAAAAADAgqriJ34kyUUXXZT9998/1dXVWXbZZeuvn3766enUqVPK5XLGjBmTGTNmpFwuZ4MNNsgPf/jDRocGAAAAAAAAAKART/xIktra2px11ln58Y9/nM8++6z+evv27XPvvffmlltuyfPPP5/q6upsuumm2WuvvVJT06iRAAAAAAAAAAB8oUlaGK1atUqrVq1mu3b44YfPtnbq1Klp3rx5U4wFAAAAAAAAAFioVXzUy0EHHZQf/vCHmTp1aoPWf/LJJ9l6662z0047VToSAAAAAAAAAICZVPzEj2eeeSalUikzZsxo0PopU6Zk5MiRadGiRaUjAQAAAAAAAACYybcWP+rq6nL//fenrq7uK1//61//+q1Ht0ybNi39+vVLkiyyyCIVxAQAAAAAAAAA4P/3rcWPqqqqvPTSS+nbt+8s10ulUpLkF7/4xRwN3GKLLeZoPQAAAAAAAAAAX62qIYtOOumkLL300imXy/VfX5r52td9VVdXZ4kllshOO+2U008/fa69GQAAAAAAAACAhcm3PvEjSRZddNE8/vjjs1xbbbXVUiqV8vzzzzu+BQAAAAAAAABgPmhQ8eOrdOzYMaVSKdXV1U2ZBwAAAAAAAACABqq4+LHuuuumVatWeffdd7Piiis2ZSYAAAAAAAAAABqgqtKNTz/9dG677ba88847TZkHAAAAAAAAAIAGqrj48dlnnyVJ1l577SYLAwAAAAAAAABAw1Vc/PjyeJfXXnutycIAAAAAAAAAANBwFRc/TjvttNTU1OT000/Pv//976bMBAAAAAAAAABAA9RUunHEiBHZbbfdcvvtt+fggw9OmzZtstpqq6Vt27Zp0aLF1+4rlUo577zzKh0LAAAAAAAAAMAXKi5+/PznP0+pVEqpVEq5XM64cePyzDPPfOOecrms+AEAAAAAAAAA0EQqLn507NixKXMAAAAAAAAAADCHKi5+/POf/2zKHAAAAAAAAAAAzKGq+R0AAAAAAAAAAIDKVPzEj/9fuVzOa6+9lpEjR2bixIlp2bJlOnXqlFVWWSXV1dVNNQYAAAAAAAAAgC80uvgxYcKEXHnllbntttvy2Wefzfb6Iosskt133z0nnXRSFl100caOAwAAAAAAAADgC4066mXkyJHZc889c8011+TTTz9NuVye7WvChAnp27dvevXqlXfffbepcgMAAAAAAAAALPQqfuLH9OnTc+SRR+att95Kkmy99dbZYYcdsuKKK6Zly5YZP358hg8fnn/84x957LHH8s477+TEE0/Mn//859TUNNkJMwAAAAAAAAAAC62KGxh33HFH3njjjdTU1OTCCy/M9ttvP9ua7t27Z7fddssjjzySE088Ma+++mr+/ve/Z5dddmlUaAAAAAAAAAAAGnHUy9///veUSqUccsghX1n6mNl3v/vdHHLIISmXy7n33nsrHQkAAAAAAAAAwEwqLn688cYbSZJdd921Qeu/XDd06NBKRwIAAAAAAAAAMJOKix/jx49Pkiy55JINWv/lurFjx1Y6EgAAAAAAAACAmVRc/GjXrl2S5O23327Q+i/XLbbYYpWOBAAAAAAAAABgJhUXP9Zee+0kyfXXX9+g9dddd90s+wAAAAAAAAAAaJyKix977rlnyuVyHnjggZx33nmZPn36V66bPn16+vTpkwceeCClUil77LFHxWEBAAAAAAAAAPivmko3brnlltl6663zz3/+M9dff33++te/ZquttsqKK66YRRZZJBMnTsywYcPy6KOP5uOPP06SbL311tlqq62aLDwAAAAAAAAAwMKs4uJHkvzud7/LSSedlEcffTQfffRR7rjjjtnWlMvlJJ+XPi644ILGjAMAAAAAAAAAYCaNKn7U1tbmyiuvzKOPPprbb789zz77bD777LP619u0aZP11lsv++yzjyd9AAAAAAAAAAA0sUYVP7601VZb1Rc7JkyYkPHjx2fRRRdNq1atmuL2AAAAAAAAAAB8hSYpfsxs0UUXzaKLLtrUtwUAAAAAAAAA4P/TJMWP999/Pw8//HD69++f0aNHZ/z48WnXrl06deqUzTffPN/97nc9/QMAAAAAAAAAoIk1qvhRLpdzySWX5LrrrsuUKVPqryXJO++8k5deeikPPPBAzj333Pz0pz9Nr169Gp8YAAAAAAAAAIAkjSx+nH766bnnnntSLpdTKpWy0korZfnll09tbW0mTpyYt956K8OHD8+4ceNyxhln5JNPPsmPfvSjpsoOAAAAAAAAALBQq7j48c9//jN33313SqVSttpqq5xxxhlZdtllZ1v31ltv5de//nWeeuqp/Pa3v03Pnj3TrVu3RoUGAAAAAAAAACCpqnTjzTffnCTZYostcsUVV3xl6SNJunbtmj/84Q/p0aNH6urqct1111U6EgAAAAAAAACAmVRc/HjjjTdSKpVy7LHHplQqfePa6urqHH/88UmSgQMHVjoSAAAAAAAAAICZVFz8mDBhQpKkc+fODVq/4oorJkk+/vjjSkcCAAAAAAAAADCTiosfyy+/fJJkyJAhDVr/zjvvJGl4UQQAAAAAAAAAgG9WcfFjv/32S7lczvnnn59JkyZ96/orrrgiSbLHHntUOhIAAAAAAAAAgJlUXPzYe++9s/vuu2fw4MHZf//989xzz33luvfeey/HH398HnvssWy66aY56KCDKg4LAAAAAAAAAMB/1VS68eSTT06StGzZMq+99lp+8IMfZKmllsrKK6+c1q1bZ8qUKRkxYkSGDx+ecrmcJHn99dez9dZbf+X9SqVSHn300UrjAAAAAAAAAAAsdCoufvztb39LqVSqL3UkyQcffJAPPvjga/d89NFHX/taqVSqNAoAAAAAAAAAwEKp4uLHbrvtpqwBAAAAAAAAADAfVVz86NOnT1PmAAAAAAAAAABgDlXN7wAAAAAAAAAAAFRG8QMAAAAAAAAAoKAqPuolSerq6vKPf/wj/fv3z/vvv58pU6Z8655SqZQbbrihMWMBAAAAAAAAAEgjih+TJk3KIYcckkGDBiVJyuVyg/aVSqVKRwIAAAAAAAAAMJOKix+XXXZZnn/++STJMssskzXXXDOtWrVKVZXTYwAAAAAAAAAA5oWKix8PPfRQSqVSdthhh1xwwQWpqWnUqTEAAAAAAAAAAMyhih/PMXr06CTJscceq/QBAAAAAAAAADAfVFz8aNu2bZJkiSWWaKosAAAAAAAAAADMgYqLHxtvvHGS5MUXX2yyMAAAAAAAAAAANFzFxY+jjjoqLVq0yAUXXJBx48Y1ZSYAAAAAAAAAABqgptKNK664Yn73u9/l5JNPzs4775w99tgja6yxRlq1avWte3v27FnpWAAAAAAAAAAAvlBx8SNJSqVSFltssYwePTpXX311g/cMHjy4MWMBAAAAAAAAAEgjih///ve/c9xxx2XGjBlJknK53GShAAAAAAAAAAD4dhUXP/7whz9k+vTpad68efbcc89ssMEGWXzxxVNVVdWU+QAAAAAAAAAA+BoVFz9effXVlEqlnHnmmdlrr72aMhMAAAAAAAAAAA1Q8eM5pkyZkiTZcsstmyoLAAAAAAAAAABzoOLiR5cuXZIkn376aZOFAQAAAAAAAACg4Soufuy2224pl8u5+eabmzIPAAAAAAAAAAANVHHx4wc/+EHWXXfd/PnPf06fPn3y8ccfN2UuAAAAAAAAAAC+RU2lG6+66qqst956GTx4cG644YbccMMN6dChQ9q2bZuWLVt+7b5SqeQpIQAAAAAAAAAATaDi4sdll12WUqmUcrlcf23kyJEZOXLkN+4rlUqVjgQAAAAAAAAAYCYVFz823HDDpswBAAAAAAAAAMAcqrj4cdNNNzVlDgAAAAAAAAAA5lDV/A4AAAAAAAAAAEBlFD8AAAAAAAAAAApK8QMAAAAAAAAAoKBqGrJom222abKBpVIpjzzySJPdDwAAAAAAAABgYdWg4sd7773XZANLpVKT3QsAAAAAAAAAYGHWoOLHhhtuOLdzAAAAAAAAAAAwhxpU/Ljpppvmdg4AAAAAAAAAAOZQ1fwOAAAAAAAAAABAZRQ/AAAAAAAAAAAKSvEDAAAAAAAAAKCgFD8AAAAAAAAAAApK8QMAAAAAAAAAoKAUPwAAAAAAAAAACkrxAwAAAAAAAACgoBQ/AAAAAAAAAAAKSvEDAAAAAAAAAKCgFD8AAAAAAAAAAAqqpiluMnXq1PTr1y8DBw7M6NGjM2HChFx33XVJkptvvjlrrrlm1llnnaYYBQAAAAAAAADAFxpd/Pj73/+ec845Jx9//HGSpFwup1Qq1b9+ww035N133833v//9/N///V9atGjR2JEAAAAAAAAAAKSRR73cfPPNOfnkk/PRRx+lXC5niSWWmG3Nhx9+mHK5nL/+9a856aSTGjMOAAAAAAAAAICZVFz8GDZsWM4999wkyXbbbZeHH344Dz744Gzr/v73v+e73/1uyuVyHn300Tz00EOVpwUAAAAAAAAAoF7FxY/rr78+M2bMyKabbppLLrkknTt3nuWIly917Ngxl156abbYYouUy+XcddddjQoMAAAAAAAAAMDnKi5+DBgwIKVSKUceeeS3ri2VSjn88MOTJC+//HKlIwEAAAAAAAAAmEnFxY8PPvggSbLyyis3aP0KK6yQJBk3blylIwEAAAAAAAAAmEnFxY/a2tokycSJExu0/tNPP02SLLroopWOBAAAAAAAAABgJhUXP7p27ZokeeKJJxq0/oEHHphlHwAAAAAAAAAAjVNx8eO73/1uyuVyLrnkkrz77rvfuHbQoEG5+uqrUyqVsvXWW1c6EgAAAAAAAACAmdRUuvHAAw/MLbfcktGjR2ePPfbID37wg6y22mr1r//nP//JiBEj0q9fv9xxxx2ZNm1allxyyey///5NEhwAAAAAAAAAYGFXcfGjZcuWueqqq9K7d++MGTMml19+eZKkVColSXbYYYf6teVyOa1atcrll1+eVq1aNTIyAAAAAAAAAABJI456SZJVV1019957b3bdddfU1NSkXC7P9pUkW2+9de66666svfbaTRIaAAAAAAAAAIBGPPHjS0sttVTOO++8/PznP8/zzz+fESNGZPz48amtrU3Hjh2z3nrrZckll2yKrAAAAAAAAAAAzKTi4sf555+ftm3bplevXllyySXTunXrbLHFFk2ZDQAAAAAAAACAb1Bx8eNvf/tbPvjgg3Tq1Ck77bRTU2YCAAAAAAAAAKABqirdOGbMmCRJjx49miwMAAAAAAAAAAANV3Hxo1OnTkmSd999t8nCAAAAAAAAAADQcBUXP44//viUy+WceeaZGTFiRFNmAgAAAAAAAACgAWoq3diuXbvst99+ufXWW7PDDjtk1VVXzWqrrZa2bdumRYsW37j3hBNOqHQsAAAAAAAAAABfqLj40bt375RKpZRKpcyYMSNDhgzJkCFDGrS30uLHtGnTcuGFF+bee+/NhAkTsv766+fMM8/MCius8JXrBw0alH333Xe262eeeWYOPPDAijIAAAAAAAAAACwoKi5+JEm5XP7K7+eWiy66KNddd13atWuXrl27pn///jn00EPzt7/9LS1btpxt/eDBg5Mkq6yySjp37lx/febvAQAAAAAAAACKquLix2uvvdaUOb7VlClTcuutt6ZUKuW2225Lly5dcsABB+S5557Lww8/nF122WW2PV8WP44++ujsuOOO8zQvAAAAAAAAAMDcVjW/AzTU66+/ngkTJqRDhw7p0qVLkqRnz55Jkueff/4r93x59MyAAQNy0kkn5cILL8wHH3wwbwIDAAAAAAAAAMxljTrqZV4aOXJkkqRdu3b11778fvTo0bOtnzZtWt54440kyV/+8pf663fffXfuvffeLLHEEhVnqakpTF9mgVddvWB8lt+Woyg5m3LGgvKev05RcibFyVqUnImsc0NRcibFyVqUnElxshYlZ1KcrEXJmRQna1FyJsXJWpSciaxzQ1FyJsXJWpScSXGyFiVnUpysRcmZFCdrUXImxclalJyJrHNDUXImxclalJxJcbIWJWdSrKwAC6qKix8DBgyoeOiXT+qYE5MnT06S1NT8N3KzZs1meW1mn376abbYYotMmzYtp5xyStq2bZvjjjsugwYNyqWXXppf/vKXFWWvqiqlXbtFK9rLgqtNm5bzO0KDzMucPpOmV5SsRcmZyDo3FCVnUpysRcmZFCdrUXImxclalJxJcbIWJWdSnKxFyZnIOjcUJWdSnKxFyZkUJ2tRcibFyVqUnElxshYlZ1KcrEXJmcg6NxQlZ1KcrEXJmRQna1FyJsXKCrCgqbj40bt375RKpTneVyqVMnjw4Dne16JFiyTJ9OnT669NmzYtSVJbWzvb+iWWWCKXX375LNcOPvjgDBo06GuPhmmIurpyPv10YsX7mVV1ddUC8Rf5p59OyowZdV/7elFyNoUv3+u8mNUYRcmZFCdrUXImss4NRcmZFCdrUXImxclalJxJcbIWJWdSnKxFyZkUJ2tRciayzg1FyZkUJ2tRcibFyVqUnElxshYlZ1KcrEXJmRQna1FyJrLODUXJmRQna1FyJsXJWpScSbGyLgzatGnp6StQQI066qVcLjd4balUSlVV5f+RWGaZZZIk48aNq782duzYJEmHDh1mWz9x4sS89957SZKVV145yX/LIzNmzKg4R5JMn+4vnf81M2bUFeL3dV7m9Jk0vaJkLUrORNa5oSg5k+JkLUrOpDhZi5IzKU7WouRMipO1KDmT4mQtSs5E1rmhKDmT4mQtSs6kOFmLkjMpTtai5EyKk7UoOZPiZC1KzkTWuaEoOZPiZC1KzqQ4WYuSMylWVoAFTcXFjxtvvPEbX588eXI++eSTDBo0KPfcc0+aNWuWyy+/PBtuuGFF87p165ba2tq89957GTFiRDp37pynn346SbL++uvPtv65557LYYcdlmWWWSZ///vf06pVqzz66KNJknXXXbeiDAAAAAAAAAAAC5KKix8bbbRRg9btsssuOfjgg7PffvvlmGOOyb333vuVT+j4Ni1btsw+++yTG264Ifvss0+WWWaZDB48OMsuu2y23XbbDBgwIDfddFO6du2aU045JT179swaa6yRV199NTvvvHOWWWaZvPDCC2ndunWOOOKIOZ4PAAAAAAAAALCgmScHNC233HI5/vjj8+mnn+bqq6+u+D6nnnpqDj300CTJ0KFDs8kmm+RPf/pTWrRokVGjRqVfv3559tlnkyTNmjXLH/7wh/Tq1SvTp0/Pa6+9lo033jg33nhjOnfu3CTvCwAAAAAAAABgfqr4iR9zaosttkiSPPHEExXfo6amJqecckpOOeWU2V7r1atXevXqNcu1JZdcMueee27F8wAAAAAAAAAAFmTz5IkfSVJV9fmojz76aF6NBAAAAAAAAAD4nzbPih+PPPJIkmSxxRabVyMBAAAAAAAAAP6nVXzUS11d3beumT59esaOHZt//OMfufDCC1MqlbLRRhtVOhIAAAAAAAAAgJlUXPxYY4015mh9uVxOdXV1evfuXelIAAAAAAAAAABmUnHxo1wuz9H6Vq1a5ec//3nWXHPNSkcCAAAAAAAAADCTiosfxx577LeuqaqqyiKLLJIuXbpk4403zqKLLlrpOAAAAAAAAAAA/j9ztfgBAAAAAAAAAMDcU1XpxmeffTbPPvtsg498mTp1au65555cd911lY4EAAAAAAAAAGAmFT/x4wc/+EGqqqoycODAtGzZ8lvXT5o0Kaeddlratm2b3r17VzoWAAAAAAAAAIAvVPzEjyQpl8splUoNWvvCCy8kSSZPntyYkQAAAAAAAAAAfOFbn/hRV1eXww47LG+//fZXvv69733vW8sf06ZNy0cffZRSqZTllluuoqAAAAAAAAAAAMzqW4sfVVVVOfTQQ7/yeJZyuZyRI0c2eFh1dXWOOeaYOUsIAAAAAAAAAMBX+tbiR5L07Nkz//d//5f333+//tpll12WUqmUww8/PM2aNfvmITU1adu2bTbccMOsuOKKjUsMAAAAAAAAAECSBhY/kmSvvfaa5deXXXZZkuTII49My5YtmzYVAAAAAAAAAADfqsHFj//fueeemyRp0aJFk4UBAAAAAAAAAKDhKi5+7L777k2ZAwAAAAAAAACAOVRx8WNmkyZNyrhx4zJt2rTZXqurq8u0adMyceLEvP3223n44Ydz6aWXNsVYAAAAAAAAAICFWqOKH0OGDMk555yTgQMHplwuN1UmAAAAAAAAAAAaoOLixwcffJCDDz44n3766RyVPpZbbrlKRwIAAAAAAAAAMJOKix833XRTxo0bl1KplO9+97vZaKONMnTo0Nx2223Zcssts80222Ts2LF5+umn079//5RKpRx11FE5/vjjmzI/AAAAAAAAAMBCq6rSjf/6179SKpWy22675bLLLstBBx2UQw45JEkybty47LXXXjn88MNz7bXX5je/+U3K5XKuueaajBgxosnCAwAAAAAAAAAszCoufrz33ntJkn333bf+2nLLLZfWrVvnlVdeybRp0+qv77HHHtl1110zZcqU3HzzzY2ICwAAAAAAAADAlyoufkycODFJ0rlz51mur7jiipk+fXqGDh06y/W99torSfL0009XOhIAAAAAAAAAgJlUXPxo3bp1kmTq1KmzXO/SpUuSZNiwYbNc79q1a5L/PikEAAAAAAAAAIDGqbj4seyyyyZJ3njjjVmuL7fccimXy3nttddmuT558uRZ/gkAAAAAAAAAQONUXPzo0aNHyuVyLrvssnz22Wf111dZZZUkySOPPJJyuVx//fHHH0+StGnTptKRAAAAAAAAAADMpOLix3777Zeampq8/PLL2WGHHdK3b98kyXe+8520bds2//nPf3Lcccfl8ccfz7XXXpsLLrggpVIp3bt3b7LwAAAAAAAAAAALs4qLHx07dswvfvGLJMmYMWPqj3apra1N7969Uy6X069fvxx55JG54IILMmnSpJRKpRx88MFNEhwAAAAAAAAAYGFX05jNe+21V1ZdddVce+219Ue8JMnhhx+esWPH5sYbb0xdXV2Szwshp512Wnr06NG4xAAAAAAAAAAAJGlk8SNJunfvnosuumiWa6VSKaeddlp69+6dF198MVVVVdlggw3Stm3bxo4DAAAAAAAAAOALjS5+fJNlllkm22233dwcAQAAAAAAAACw0Gqy4sdHH32UQYMGZdSoURk/fnyOPvroJMnzzz+fbt26pWXLlk01CgAAAAAAAACANEHx45133sl5552XRx99NOVyuf76l8WPs846Kx999FF+8pOfZM8992zsOAAAAAAAAAAAvtCo4sfAgQNzxBFHZMKECbOUPkqlUv337733XiZNmpQzzzwz77//fo455pjGjAQAAAAAAAAA4AtVlW785JNPcswxx2T8+PHp1KlTfv3rX+fuu++ebd3ZZ5+dLl26pFwu5/LLL88rr7zSqMAAAAAAAAAAAHyu4uLH9ddfn08++SRdu3bNXXfdlT333DPLLbfcbOu+//3v589//nNWWmmllMvl9O3bt1GBAQAAAAAAAAD4XMXFj0cffTSlUiknnHBC2rRp841rF1988Zxwwgkpl8t55plnKh0JAAAAAAAAAMBMKi5+jBgxIkmywQYbNGj92muvnST58MMPKx0JAAAAAAAAAMBMKi5+lMvlz29Q1bBbfLm+pqam0pEAAAAAAAAAAMyk4uJHhw4dkiQvvPBCg9YPGDAgSdKpU6dKRwIAAAAAAAAAMJOKix+bbbZZyuVyLrvsskydOvUb144ZMyaXXHJJSqVSevbsWelIoIGqqkqpqamq6Ku6+vP/LFRXV7a/pqYqVVWl+fwJAAAAAAAAACwcKj53pXfv3vnLX/6SIUOG5KCDDsrJJ5+clVZaaZY1kydPzqOPPpoLL7wwI0eOTLNmzXLQQQc1OjTw9aqqSll88dqUSo07VqlNm5YV7y2Xp2fMmMmpqys3KgMAAAAAAAAA36zinwx36NAh55xzTk455ZS8+OKL9YWOUunz/9P/O9/5TsaOHZsZM2akXP78h79nnnlmll122SaIDXydqqrSF6WPA5IMmQ8JuqVU6puqqpLiBwAAAAAAAMBc1qhHAuy0005p165dzjzzzLz33nuzvPbhhx/Wf7/kkkvmjDPOyI477tiYccAcGZJk0PwOAQAAAAAAAMBc1LizIJJssskmefjhh/Pkk0/mmWeeyYgRIzJ+/PjU1tamY8eOWX/99bPNNtukefPmTZEXAAAAAAAAAIAvNLr4kSRVVVXZYostssUWWzTF7QAAAAAAAAAAaICq+R0AAAAAAAAAAIDKNKj4seGGG2bjjTfO5MmT53YeAAAAAAAAAAAaqEFHvXz22WcplUopl8tf+fr06dNzyy23JEkOOuigpksHAAAAAAAAAMDXalDx49tMnTo155xzTqqqqhQ/AAAAAAAAAADmkQYd9dJQX/dEEAAAAAAAAAAAml6TFj8AAAAAAAAAAJh3FD8AAAAAAAAAAApK8QMAAAAAAAAAoKAUPwAAAAAAAAAACkrxAwAAAAAAAACgoBQ/AAAAAAAAAAAKqmZOFo8aNSq1tbWzXZ80adIsa8rl8jfep2PHjnMyFgAAAAAAAACArzBHxY+ddtrpa18rlUpJkq233vob71EqlTJ48OA5GQsAAAAAAAAAwFdocPHj257iAQAAAAAAAADAvNWg4sexxx47t3MAAAAAAAAAADCHFD8AAAAAAAAAAAqqan4HAAAAAAAAAACgMoofAAAAAAAAAAAFpfgBAAAAAAAAAFBQih8AAAAAAAAAAAWl+AEAAAAAAAAAUFCKHwAAAAAAAAAABaX4AQAAAAAAAABQUIofAAAAAAAAAAAFpfgBAAAAAAAAAFBQih8AAAAAAAAAAAVV09gbjBgxIv369cu7776bSZMmpa6u7hvXl0qlnHPOOY0dCwAAAAAAAACw0GtU8ePKK6/M5ZdfnhkzZszRPsUPAAAAAAAAAIDGq7j48eSTT+biiy/+741qatK6des0b968SYIB//uqqkqpqipVtLe6umqWf1airq6curpyxfsBAAAAAAAA5reKix99+/ZNkrRr1y7nnntuNt100zRr1qzJggH/26qqSll88dqUSo07capNm5YV7y2Xp2fMmMnKHwAAAAAAAEBhVfwT1xdffDGlUilnnHFGttxyyyaMBCwMqqpKX5Q+DkgyZD4k6JZSqW+qqkqKHwAAAAAAAEBhVVz8mDBhQpKkZ8+eTRYGWBgNSTJofocAAAAAAAAAKKSqSje2b98+STJ16tQmCwMAAAAAAAAAQMNVXPzYfPPNkySPPvpok4UBAAAAAAAAAKDhKi5+HHHEEWnTpk0uvvjivPbaa02ZCQAAAAAAAACABqipdOPkyZPzi1/8ImeccUb23HPPbLbZZll77bXTrl271NR882333HPPSscCAAAAAAAAAPCFiosf2223Xf335XI5jz/+eB5//PFv3VcqlRQ/AAAAAAAAAACaQMXFj3K5/I2/BgAAAAAAAABg7qq4+NGvX7+mzAEAAAAAAAAAwByquPjRqVOnpswBAAAAAAAAAMAcqprfAQAAAAAAAAAAqEyTFj/K5XLq6upm+Zo+fXomTZqUjz/+OAMHDkyfPn2aciQAAAAAAAAAwEKr4qNekmT06NG56KKL8uSTT2bs2LEpl8sN2nfaaac1ZiwAAAAAAAAAAGlE8ePTTz/N/vvvn1GjRjW48JEkrVq1qnQkAAAAAAAAAAAzqbj40bdv34wcOTJJsvrqq2fDDTfMu+++m379+mXDDTfM+uuvn7Fjx+bf//533n777ZRKpfzoRz/KCSec0GThAQAAAAAAAAAWZhUXPx577LGUSqVsscUWufLKK1MqlfLGG2+kX79+qa6uzoknnpgkKZfLufTSS3PFFVfk9ttvz8EHH5ylllqqqfIDAAAAAAAAACy0qird+PbbbydJDjnkkJRKpSTJyiuvnJYtW+aFF15IXV1dkqRUKuX444/Plltumc8++yy33HJL41MDAAAAAAAAAFB58WPChAlJkuWXX77+WqlUyoorrpgpU6Zk+PDhs6w/8MADUy6X88QTT1Q6EgAAAAAAAACAmVRc/Fh00UWTfH6Uy8yWW265JMnQoUNnub7KKqskSUaMGFHpSAAAAAAAAAAAZlJx8aNDhw5J/nvky5e6dOmScrmcN954Y5brXxZEJk6cWOlIAAAAAAAAAABmUnHxY4MNNki5XM4f/vCHTJs2rf76SiutlCR57LHHZln/zDPPJPnvk0IAAAAAAAAAAGiciosf++67b0qlUp566qn06tUr//jHP5Ik3/nOd7LIIotkyJAh+fWvf51hw4blwQcfTJ8+fVIqlbL66qs3WXgAAAAAAAAAgIVZxcWPlVZaKcccc0zK5XKGDh2axx9/PEnSpk2b7LPPPimXy+nbt2923nnnnHjiifn444+TJPvtt1/TJAcAAAAAAAAAWMhVXPxIkmOPPTYXXXRR1lxzzXTu3Ln++kknnZRtt9025XK5/qtUKuWwww7Ldttt1+jQAAAAAAAAAAAkNY29wQ477JAddtgh5XK5/lrz5s1z6aWX5oUXXsigQYNSVVWVTTfdNCuttFJjx/E/q9tCNhcAAAAAAAAAGq/RxY8vlUql2a6ts846WWeddZpqBP+jyuUZKZX6ztf5AAAAAAAAAFBETVb8qKury2uvvZZRo0Zl/Pjx2XXXXZMkI0aMmOUYGPj/lUrVue+++/LRRx/N89lLLrlkdtlll3k+FwAAAAAAAACaQqOLH5988kmuuOKK3HXXXZkwYUL99S+LH8cee2ymT5+eM844I5tsskljx/E/6tVXX82IESPm+dzOnTsrfgAAAAAAAABQWFWN2Txs2LDsvvvuuemmmzJ+/PiUy+WUy+VZ1owcOTLDhw/PoYcemjvvvLNRYQEAAAAAAAAA+K+Kix+TJk3K4YcfnlGjRqVVq1Y56qijcsUVV8y27pBDDkmbNm1SV1eXX/3qV3nrrbcaFRgAAAAAAAAAgM9VXPy4+eab895772XppZfOfffdlxNOOCE9evSYbd2RRx6Z22+/Pe3bt8+0adNy0003NSowAAAAAAAAAACfq7j48dBDD6VUKuWEE05Ihw4dvnFtly5dcuKJJ6ZcLqd///6VjgQAAAAAAAAAYCYVFz/efvvtJMlmm23WoPUbb7xxkmTUqFGVjgQAAAAAAAAAYCYVFz+mTp2aJGnRokWD1jdv3vzzgVUVjwQAAAAAAAAAYCYVtzCWXnrpJMmQIUMatP7555+fZV8lpk2blj59+qRnz57p3r17evfuneHDhzdo7zXXXJNVV101p512WsXzAQCA/8fen8fnWdf54v/rupLQpMRuE7+0QIDCDFKdAx4KyuaCgxuMkUXFAVkqeBwVZVRg1Dl65oyjo6OOghtzRAHZFJGlI4KigqKUHURTFsECESg/QorQjZLe9+8PbGynLOmdO0mv5vl8PPpoe92fz/V+5e5DYtNXPhcAAAAAABuThosfe+yxR+r1ev7zP//zedeuXLkyX/7yl1MUxdAjXxrxpS99Kaeffnrq9Xpmz56da665Jscee2xWrFjxnPvuueeenHzyyQ3PBQAAAAAAAADYGDVc/Dj66KPT0tKS6667Lh/4wAfywAMPPOO62267LUceeWTuuuuuFEWRww8/vKF5Tz75ZM4777wURZHzzz8/l1xySXbbbbc88MADueKKK5513+DgYE466aQ8+eSTDc0FAAAAAAAAANhYNVz82GGHHXLCCSekXq/niiuuyH777Zf99ttv6PW3v/3t2WeffXLooYfmN7/5TZLkPe95T170ohc1NO/OO+/MsmXLMmvWrGyzzTZJkj333DPJnx8j80xOPfXU/Pa3v81LXvKShuYCAAAAAAAAAGysGi5+JMm8efPyyU9+MpMnT069Xs/AwMDQa7feemv6+/tTr9fT1taWE044Ie9///sbnvXggw8mSaZPnz50bc2vFy9e/Ix7Fi5cmFNPPTW77rprDjvssIZnAwAAAAAAAABsjFpHeoO3vvWteeMb35j58+fn+uuvz/33359ly5alvb09s2bNym677ZYDDzwwXV1dI5qzcuXKpwO3/jlyW1vbOq+tbdWqVfnHf/zHtLa25jOf+UxuuummEc1fW2vriPoyrKWlZeN4L58vR1VyDnfNWNiU3tNmzdhYPuZnU5WciayjoSo5k+pkrUrOpDpZq5IzqU7WquRMqpO1KjmT6mStSs5E1tFQlZxJdbJWJWdSnaxVyZlUJ2tVcibVyVqVnEl1slYlZyLraKhKzqQ6WauSM6lO1qrkTKqVFWBjNeLiR5J0dnbmsMMOG9VTNSZNmpQkGRwcHLr21FNPJUna29vXW3/yySfnrrvuyj/90z9l2223bVrxoyyLTJ++eVPuxcZjypSO8Y4wLFXJmVQn61jm9J40n6zNV5WcSXWyViVnUp2sVcmZVCdrVXIm1clalZxJdbJWJWci62ioSs6kOlmrkjOpTtaq5Eyqk7UqOZPqZK1KzqQ6WauSM5F1NFQlZ1KdrFXJmVQna1VyJtXKCrCxaUrxYyxsscUWSZI//vGPQ9eWLFmSJJk1a9Z66y+77LIkyac+9al86lOfGrp+0UUX5aKLLsqdd97ZUI5arZ7HH1/e0F7W19JSbhSfyB9/fEVWr6496+tVyZlUJ2tVcjbDmo91LGaNRFVyJrKOhqrkTKqTtSo5k+pkrUrOpDpZq5IzqU7WquRMqpO1KjkTWUdDVXIm1clalZxJdbJWJWdSnaxVyZlUJ2tVcibVyVqVnImso6EqOZPqZK1KzqQ6WauSM6lW1olgypQOp69ABVWm+DFnzpy0t7fngQceSF9fX7q7u3PttdcmSebOnbve+r333juPPvro0O8feuihLFy4MLNmzcqLX/ziEWUZHPRJZ1OzenWtEn+uVcmZVCfrWOb0njSfrM1XlZxJdbJWJWdSnaxVyZlUJ2tVcibVyVqVnEl1slYlZyLraKhKzqQ6WauSM6lO1qrkTKqTtSo5k+pkrUrOpDpZq5IzkXU0VCVnUp2sVcmZVCdrVXIm1coKsLEZVvFjzpw5TRtYFEUWLly4wfs6Ojpy6KGH5swzz8yhhx6aLbbYIgsXLszWW2+d1772tVmwYEHOOuuszJ49OyeeeGI++clPrrP/wgsvzEc/+tHsscce+cxnPtOsDwcAAAAAAAAAYNwMq/hRr9dHO8ewnHTSSWlra8tFF12Uu+++O3vttVc+8YlPZNKkSXnooYfy05/+NLvssst4xwQAAAAAAAAAGBPDftRLURRJkq6uruy3336ZOnXqqIV6Nq2trTnxxBNz4oknrvfawQcfnIMPPvhZ9z7f6wAAAAAAAAAAVTOs4se+++6bX/3qV1m1alUeeeSRXHDBBdl7771zwAEH5G/+5m8yefLk0c4JAAAAAAAAAMB/M6zix9e//vUsXbo0P/7xj3PppZfmuuuuy1VXXZWf//znmTRpUvbdd98ccMABeeUrX5nNNttstDMDAAAAAAAAAJANeNRLZ2fn0ONSBgYGctlll+WHP/xhbr755lx22WW5/PLLs/nmm+e1r31tDjjggOy1114py3I0swMAAAAAAAAATGjDLn6sbcaMGTn88MNz+OGH5+GHH84Pf/jDXHrppfntb3+biy66KBdffHGmT5+eN7zhDdl///2z2267NTs3AAAAAAAAAMCE11DxY21bbLFF5s2bl3nz5qWvry8/+MEP8sMf/jC/+93vcu655+a8887LFltskf333z8HHHBAXvKSlzQjNwAAAAAAAADAhNfUZ7F0d3fnPe95T/7rv/4rl156ad7znvdk2223zeLFi3P66afnLW95S17/+tc3cyQAAAAAAAAAwITV1OLH2nbYYYccf/zxOeOMM/K2t70tSVKv13P//feP1kgAAAAAAAAAgAllxI96eSYPPfRQfvSjH+Xyyy/Pbbfdlnq9nnq9niTZeuutR2MkAAAAAAAAAMCE07Tix+LFi3P55Zfn8ssvz69//eskGSp7zJo1K294wxvyxje+MTvvvHOzRgIAAAAAAAAATGgjKn48/PDDufzyy3PZZZetd7LHC1/4wrz+9a/P/vvvn1133bUpYQEAAAAAAAAA+LMNLn6sKXusOdlj7bLHjBkz8rrXvS77779/dt999xRF0fTAAAAAAAAAAAA8bVjFj4cffjg/+tGPcvnll+fWW29dp+wxderUobLHy1/+8pRlOaqBAQAAAAAAAAB42rCKH69+9auHfl2v1/OCF7wg++23X974xjdmr732SmvriJ4YAwAAAAAAAABAA4bV2KjX60OPbXnRi16UV7ziFWlra8stt9ySW265ZYOHHn/88Ru8B2A8tbSUaW1t7ESjsnz6v59tbS1paWnsHoODtaxeXWtoLwAAAAAAALDp2uCjOu66667cddddIxqq+AFUSVkWmTatY8SPsursbG94b61Wy5Ily1Or1UeUAQAAAAAAANi0DLv4Ua/7x0ZgYirLImVZZv78+env7x/z+V1dXenp6UlZFoofAAAAAAAAwDqGVfy44447RjsHwEavt7c3fX19Yz63u7s7PT09Yz4XAAAAAAAA2PiN7LkFAAAAAAAAAACMG8UPAAAAAAAAAICKUvwAAAAAAAAAAKgoxQ8AAAAAAAAAgIpS/AAAAAAAAAAAqCjFDwAAAAAAAACAilL8AAAAAAAAAACoKMUPAAAAAAAAAICKUvwAAAAAAAAAAKgoxQ8AAAAAAAAAgIpqHc6iG264oalDd99996beDwAAAAAAAABgIhpW8eOII45IURRNGVgURRYuXNiUewEAAAAAAAAATGTDKn4kSb1eH9a6lpaWTJ48OatWrcqTTz45dL0oirS1tW14QgAAAAAAAAAAntGwih8//elPn/H6eeedl9NOOy1TpkzJsccem9e+9rXZbrvthk4HeeSRR/Lzn/88X/va1/Lwww/n+OOPzzHHHNO89AAAAAAAAAAAE9iwih9bbbXVetduuummfOtb38oWW2yRc8899xnXvPCFL8xb3vKW7Lfffnn729+ez3/+89l+++2z7777jjw5AAAAAAAAAMAEVza68f/9v/+Xer2eE0444RlLH2ubNm1aTjjhhNTr9XzrW99qdCQAAAAAAAAAAGtpuPhx6623Jkn23nvvYa2fO3dukuT2229vdCQAAAAAAAAAAGtpuPgxODiYJFm1atWw1j/xxBNJkpaWlkZHAgAAAAAAAACwloaLH9tuu22S5PLLLx/W+gsuuCBJsv322zc6EgAAAAAAAACAtTRc/DjggANSr9dz8skn5xe/+MVzrv3+97+fb37zmymKIoccckijIwEAAAAAAAAAWEtroxvf/va35/zzz899992Xd7/73dljjz3yyle+Mt3d3eno6MiKFSvy+9//Pj/5yU/ym9/8JvV6PbvuumsOPPDAJsYHAAAAAAAAAJi4Gi5+bL755jnttNNy7LHH5r777su1116ba6+9dr119Xo9SbLbbrvlK1/5SlpbGx4JAAAAAAAAAMBaRtTC6O7uzg9+8IOcc845+cEPfpDe3t6hokeSlGWZuXPn5pBDDslBBx004rAw/uZMsLkAAAAAAAAAbMxGfPxGW1tbjj766Bx99NFZunRpHn744Tz++OOZOnVqtthii2y++ebNyAnjrl5fnaI4Z1znAwAAAAAAAMDamvrclc7OznR2djbzlrDRKIqWzJ8/P/39/WM+u6urKz09PWM+FwAAAAAAAICNW9OKH7fddltuvvnmPPTQQ1m2bFn+9V//NUnyox/9KDvvvHNmzZrVrFEwbnp7e9PX1zfmc7u7uxU/AAAAAAAAAFjPiIsft9xyS/7v//2/ufPOO9e5vqb48cUvfjEPPPBAjj322HzgAx9IURQjHQkAAAAAAAAAQJJyJJt//OMf54gjjsidd96Zer2esixTr9fXWfPggw/mqaeeyqmnnpr/83/+z4jCAgAAAAAAAADwZw0XPxYvXpyTTjopg4OD2XnnnXP66afn6quvXm/dGWeckZe+9KWp1+v53ve+lwULFowoMAAAAAAAAAAAT2u4+PGtb30rK1euzM4775yzzjore+65Z9rb29dbt+uuu+bMM8/MS1/60iTJd77znYbDAgAAAAAAAADwZw0XP66++uoURZHjjjsum2222XOunTRpUo477rjU6/XceuutjY4EAAAAAAAAAGAtDRc/HnrooSTJX//1Xw9r/Ytf/OIkycDAQKMjAQAAAAAAAABYS8PFj5aWliTJ4ODgsNavWLEiSZ7xcTAAAAAAAAAAAGy4hosf3d3dSZLrr79+WOuvuuqqdfYBAAAAAAAAADAyDRc/Xv3qV6der+fkk0/O448//pxr77///nz5y19OURR55Stf2ehIAAAAAAAAAADW0nDx4+ijj87UqVPzhz/8IYccckguvvjiLFq0aOj1p556KosWLcppp52Wt771rXnssccyefLkHHnkkU0JDgAAAAAAAAAw0bU2unHatGk5+eST8/d///fp6+vLRz/60SRJURRJkp133nlobb1eT2traz7/+c9nxowZI4wMAAAAAAAAAEAyghM/kmSPPfbI+eefn9122y31ev1Zf+y0004566yzsu+++zYrNwAAAAAAAADAhNfwiR9r7Ljjjjn77LNzzz335LrrrktfX1+WLl2a9vb2bLnllpk7d+46p38AAAAAAAAAANAcIy5+rLHDDjtkhx12eM41q1evzkMPPZStt966WWMBAAAAAAAAACashh/18prXvCb77bdfnnzyyWGtHxgYyC677JIjjjii0ZEAAAAAAAAAAKyl4RM/HnzwwRRFkVqtNqz1y5cvz+DgYB599NFGRwIAAAAAAAAAsJbnLX7UarV885vffNaTPU499dS0tbU95z2eeuqpXH311UmSqVOnNhATAAAAAAAAAID/7nmLH2VZZtWqVfnKV76SoiiGrq/59f/7f/9vWIPq9XqS5I1vfGMjOQEAAAAAAAAA+G+G9aiX//W//ld+9atfZfHixUPX1jzqZdasWc+5tyiKtLa2Ztq0aXn5y1+e4447bmSJAQAAAAAAAABIMsziR1tbW84999x1ru20005JkksvvTQdHR3NTwYAAAAAAAAAwHMaVvHjmey+++5JkpaWlqaFAQAAAAAAAABg+Boufpx11lnNzAEAAAAAAAAAwAYqxzsAAAAAAAAAAACNafjEjzUuvvjiXHHFFbn//vuzbNmy1Gq151xfFEWuvPLKkY4FAAAAAAAAAJjwGi5+1Ov1vOc978nPf/7zod8PR1EUjY4EAAAAAAAAAGAtDRc/zjvvvFx11VVJkvb29uy6667p6upKS0tLs7IBAAAAAAAAAPAcGi5+XHzxxUmSF73oRTn99NMzY8aMZmUCAAAAAAAAAGAYykY3Llq0KEVR5CMf+YjSBwAAAAAAAADAOGi4+DE4OJjk6RM/AAAAAAAAAAAYew0XP2bPnp0k+f/9//5/TQsDAAAAAAAAAMDwNVz8OOCAA1Kv13Puuec2Mw8AAAAAAAAAAMPUcPHjiCOOyJw5c/K9730vp556alavXt3MXAAAAAAAAAAAPI/W4Sw66aSTnvH6jBkzUq/Xc/LJJ+eb3/xm/vqv/zrTpk1LW1vbs96rKIp89rOfbSwtAAAAAAAAAABDhlX8mD9/foqieMbXiqJIvV7PE088kWuvvfY571Ov1xU/AAAAAAAAAACaZFjFjy233HK0cwAAAAAAAAAAsIGGVfz42c9+Nto5AAAAAAAAAADYQOV4BwAAAAAAAAAAoDGKHwAAAAAAAAAAFTWsR708k4svvnjDh7W2ZtKkSZkxY0a23377TJ8+vdHxAAAAAAAAAAATXsPFj4985CMpimJEw+fMmZOPfOQjednLXjai+wAAAAAAAAAATEQNP+plu+22y3bbbZckqdfrQz86Ozvz//1//19e8IIXrHP9mX4sXLgwRx99dC644IJmfTwAAAAAAAAAABNGw8WPyy+/PHvvvXfq9XpmzJiRj3/84/nlL3+ZG264IT//+c9z/fXXZ8GCBfm3f/u3bLXVVimKIocddlh+8Ytf5Ic//GH+/d//PTvttFNqtVo++clP5t57723ihwUAAAAAAAAAsOlruPjxk5/8JGeffXa23HLLXHTRRTn88MPT1dW1zprp06fnoIMOyve///1su+22Oe+883LnnXdm++23T09PT77zne9k5513zqpVq/Ld7353xB8MAAAAAAAAAMBE0nDx49vf/naKosgJJ5yQLbbY4jnXTps2LSeccELq9XpOP/30oevt7e35+7//+9Tr9fzyl79sNAoAAAAAAAAAwITUcPFj4cKFSZI99thjWOt33XXXJMltt922zvU5c+YkSR5++OFGowAAAAAAAAAATEgNFz/K8umty5cvH9b6NetWr169zvW2trYkycqVKxuNAgAAAAAAAAAwITVc/Nhmm22SJPPnzx/W+ksvvTRJ0t3dvc71u+++O0nS1dXVaBQAAAAAAAAAgAmp4eLHm970ptTr9Xz961/PZZdd9pxrf/azn+WrX/1qiqLI61//+qHrg4ODOfXUU1MUxdCjYAAAAAAAAAAAGJ7WRjceeuihueCCC/K73/0uH/rQh3L22WfnNa95Tbbddtt0dHRkxYoVuffee/OLX/wiN9xwQ+r1erbZZpu8853vTJJcffXV+dd//dfcf//9SZK/+7u/a85HBAAAAAAAAAAwQTRc/Ghvb8/pp5+ed7/73ent7c1NN92Um2++eb119Xo9SfLiF784X/va19LR0ZEk+cUvfpH77rsvSfLud787c+fObTQKAAAAAAAAAMCE1HDxI0m6urpywQUX5MILL8zFF1+cW265JYODg0Ovl2WZF7/4xTn00ENzyCGHpKWlZei1yZMn56CDDsqb3vSm7LXXXiOJAcCflGWRsiwa2tvSUq7zcyNqtXpqtXrD+wEAAAAAAIANM6LiR5IURZFDDjkkhxxySFasWJHFixfnscceS0dHR7beeut0dnY+474PfvCDIx0NwFrKssiMGe0pipH9p33KlI6G99brgxkYWKn8AQAAAAAAAGNkxMWPtXV0dGT27NnNvCUAw1SWxZ9KH4cnuX0cEsxJUZyTsiwUPwAAAAAAAGCMDKv4UavVkjx9ukdRFOtca0RZNv4YAQCez+1JbhnvEAAAAAAAAMAYGFbx4yUveUmSZJtttsmPfvSjda5tqKIosnDhwob2AgAAAAAAAADwZ8MqftTr6x/Z/0zXAGC4WlrKtLY2dgJUWT59+lRbW0taWhq7x+BgLatXN356FQAAAAAAAGwMhlX8OO6445IkU6dOXe8aAGyosiwybVrHiB/91dnZ3vDeWq2WJUuWp1ZTZAQAAAAAAKC6Nqj48XzXAGA4yrJIWZaZP39++vv7x3x+V1dXenp6UpaF4gcAAAAAAACVNqziBwCMht7e3vT19Y353O7u7vT09Iz5XAAAAAAAAGi2phU/+vv7c8stt+Shhx7K0qVL8973vjdJcvPNN2fOnDnp6Oho1igAAAAAAAAAANKE4sf999+fz372s7nyyitTr//5uPw1xY9PfOIT6e/vzwknnJC3vOUtIx0HAAAAAAAAAMCfjKj4cdNNN+Xd7353li1btk7poyiKoV8/8MADWbFiRT7+8Y/n4Ycfzvve976RjAQAAAAAAAAA4E/KRjc+9thjed/73pelS5dmq622yr/+67/moosuWm/dv/zLv2SbbbZJvV7PV7/61fz2t78dUWAAAAAAAAAAAJ7WcPHjjDPOyGOPPZbZs2fnwgsvzFve8pZsu+22661705velO985zv5y7/8y9Tr9ZxzzjkjCgwAAAAAAAAAwNMaLn5ceeWVKYoixx9/fKZMmfKca2fMmJHjjz8+9Xo9119/faMjAQAAAAAAAABYS8PFj76+viTJbrvtNqz1u+yyS5LkkUceaXQkAAAAAAAAAABrabj4Ua/Xn75BObxbrFnf2tra6EgAAAAAAAAAANbScPFj1qxZSZJbb711WOsXLFiQJNlqq60aHQkAAAAAAAAAwFoaLn7ss88+qdfr+cpXvpJVq1Y959qBgYGccsopKYoie+65Z6Mj89RTT+Uzn/lM9txzz+y8886ZN29efv/73z/r+vvvvz9///d/n1133TV77bVXPvzhD6e/v7/h+QAAAAAAAAAAG5OGix/z5s3LpEmTcvvtt+fII4/MDTfckCeffHKdNStXrsxll12Wt73tbXnwwQfT2tqaI488suGwX/rSl3L66aenXq9n9uzZueaaa3LsscdmxYoV661dtWpV5s2blyuvvDLbbrttXvCCF+QHP/hB5s2bl6eeeqrhDAAAAAAAAAAAG4sRPerl05/+dIqiyK9//esceeSR2WuvvVIURZLkFa94RXbbbbd86EMfyh/+8Ickycc//vFsvfXWDc178sknc95556Uoipx//vm55JJLsttuu+WBBx7IFVdcsd762267LQMDA9l9991z0UUX5ZJLLklnZ2fuuuuu3H777Y1+2AAAAAAAAAAAG42Gix9JcsABB+S0007LlltumXq9vs6PRx55JIODg6nX6+nq6soXv/jFvO1tb2t41p133plly5Zl1qxZ2WabbZJk6LExN99883rrd9ttt9x888059dRTkyRPPPHE0IkkU6dObTgHAAAAAAAAAMDGonWkN9hrr71yxRVX5Oqrr87111+fvr6+LF26NO3t7dlyyy0zd+7c/M3f/E0222yzEc158MEHkyTTp08furbm14sXL37GPUVRpLOzM1//+tdzxhlnZHBwMO9///uz7bbbjihLa+uI+jKspaVl43gvny9HVXIOd81Y8J42n/e0+cYix5oZG8vH/GyqkjOpTtaq5Eyqk7UqOZPqZK1KzqQ6WauSM6lO1qrkTGQdDVXJmVQna1VyJtXJWpWcSXWyViVnUp2sVcmZVCdrVXImso6GquRMqpO1KjmT6mStSs6kWlkBNlbDKn4sWLAgc+fOfdbyRlmWedWrXpVXvepVTQ23tpUrVyZJWlv/HLmtrW2d157Nz3/+8zz22GOZPHlynnrqqaxevTotLS0N5SjLItOnb97QXjZeU6Z0jHeEYalKzqQ6WauSM6lO1qrkTMY2a1Xel6rkTKqTtSo5k+pkrUrOpDpZq5IzqU7WquRMqpO1KjkTWUdDVXIm1clalZxJdbJWJWdSnaxVyZlUJ2tVcibVyVqVnImso6EqOZPqZK1KzqQ6WauSM6lWVoCNzbCKH/PmzUtHR0fmzp2bffbZJ3vvvXf+6q/+arSzrWPSpElJksHBwaFrTz31VJKkvb39Off+53/+Z1atWpX3vOc9OfXUUzNlypQcc8wxDeWo1ep5/PHlDe1lfS0t5Ubxifzxx1dk9eras75elZxJdbJWJWdSnaxVyZlUK+tIrflYx2LWSFQlZ1KdrFXJmVQna1VyJtXJWpWcSXWyViVnUp2sVcmZyDoaqpIzqU7WquRMqpO1KjmT6mStSs6kOlmrkjOpTtaq5ExkHQ1VyZlUJ2tVcibVyVqVnEm1sk4EU6Z0OH0FKmjYj3pZsWJFfvWrX+VXv/pVkqSrqyt777330I8ZM2aMWsgk2WKLLZIkf/zjH4euLVmyJEkya9asZ9zz2GOPpVarDWV705velN/85je57rrrGi5+JMngoE86m5rVq2uV+HOtSs6kOlmrkjOpTtaq5EzGNmtV3peq5Eyqk7UqOZPqZK1KzqQ6WauSM6lO1qrkTKqTtSo5E1lHQ1VyJtXJWpWcSXWyViVnUp2sVcmZVCdrVXIm1clalZyJrKOhKjmT6mStSs6kOlmrkjOpVlaAjc2w6lr//u//nre97W3ZbrvtUq/XU6/X88gjj+SSSy7JSSedlH322ScHHXRQPv/5z2fBggVZtWpV04POmTMn7e3teeCBB9LX15ckufbaa5Mkc+fOXW/9d7/73bz85S/Phz/84aFrt912W5LkhS98YdPzAQAAAAAAAACMtWGd+NHT05Oenp4kycDAQG644YahH7/73e9Sq9Vy++2354477sg3v/nNtLe3N/2xMB0dHTn00ENz5pln5tBDD80WW2yRhQsXZuutt85rX/vaLFiwIGeddVZmz56dE088Ma973evyta99Lddcc03e9KY3pa2tLb29vZk8eXLe+c53jjgPAAAAAAAAAMB4G/ajXtaYMWNGXv/61+f1r399kuSJJ57IjTfeOFQEuf3227NixYr88pe/bPpjYU466aS0tbXloosuyt1335299torn/jEJzJp0qQ89NBD+elPf5pddtklSTJ9+vR8+9vfzhe+8IVcf/31qdfr2XfffXPiiSdmhx12aGg+AAAAAAAAAMDGZIOLH//dC17wguy7777Zd999kyTLly/PrbfemhtuuCE33nhjfvOb3ww9FuaSSy5JWZbp7e1tLGxra0488cSceOKJ67128MEH5+CDD17n2rbbbptTTjmloVkAAAAAAAAAABu7ERc//rvJkydnr732yp577pl77703v/nNbzJ//vxcc801qdVqqdVqzR4JAAAAAAAAADAhNbX4sXDhwlx33XW57rrrctNNN2Xp0qVDr9Xr9bS3t+dlL3tZM0cCAAAAAAAAAExYIyp+DAwM5Oqrr87VV1+dX/3qV3nssceSPF3ySJKiKLLjjjtm7733zite8YrMnTs3m2222YhDAwAAAAAAAACwgcWPWq2WW2+9Nb/4xS9y9dVX5/bbbx8qeaz5uaurK3vuuWf23nvv7LPPPunq6mp+agAAAAAAAAAAhlf8+P73v59f/OIXWbBgQZ544okkfy56tLW1Zdddd80+++yTffbZJ3PmzBm9tAAAAAAAAAAADBlW8eOf/umfUhTFUNlj++23HzrR4+Uvf3na29tHNSTQiPEqYSl/AQAAAAAAAIyVDXrUy4wZM3LMMcfkoIMOyowZM0YrEzBC9frqFMU54zofAAAAAAAAgNE3rOLHmtM+BgYG8vnPfz5f+MIXstNOOw093mXXXXdNa+sGdUiAUVQULZk/f376+/vHfHZXV1d6enrGfC4AAAAAAADARDSstsa1116bX/3qV7n66qvzy1/+Mo888kgWLlyY22+/Pd/4xjfS0dGRl7/85UNFkG233Xa0cwPPo7e3N319fWM+t7u7W/EDAAAAAAAAYIwMq/gxderU7L///tl///2TJHfcccdQCeTmm2/O8uXLc+WVV+aqq65Kkmy11VZDJZA99tgjnZ2do/YBAAAAAAAAAABMVA09n2WnnXbKTjvtlHe9611Zvnx5rr322qEiSF9fX/7whz/ku9/9br773e+mpaUlL33pS4eKIH/913/d7I8BAAAAAAAAAGBCaqj4sbbJkyfnNa95TV7zmtckSe67776hEshNN92UJ554IjfeeGNuuummnHzyyZk2bVoWLFgw4uAAAAAAAAAAABPdiIsf/922226bbbfdNu94xztSr9dz44035owzzsiVV16ZWq2Wxx57rNkjAQAAAAAAAAAmpKYWP+r1eu68887cfPPNufXWW/Pb3/429957b+r1eur1+tMDW5veNQEAAAAAAAAAmJBG1MJYvnx5fv3rX+emm27KLbfckl//+tdZtmxZkgwVPYqiyIte9KLsueee2XPPPbP77ruPPDUAAAAAAAAAABtW/Fi8eHFuvvnmoR933XVXVq9eneTPRY8k2XrrrbPXXntljz32yB577JEZM2Y0NzUAAAAAAAAAAMMrfnz4wx/OzTffnMWLFw9dW7voMWPGjOyxxx5Dp3psvfXWzU8KAAAAAAAAAMA6hlX8uPTSS9f5/eTJk7PbbrsNneqx0047jUo4ANgYlGWRsiwa2tvSUq7z84aq1eqp1erPvxAAAAAAAIAJaVjFj9bW1uyyyy5DJ3rssssuaW3doKfEAEAllWWRGTPaUxQj+7w3ZUpHQ/vq9cEMDKxU/gAAAAAAAOAZDetfsa6//vpMnjx5tLMAwEanLIs/lT4OT3L7GE+fk6I4J2VZKH4AAAAAAADwjIZV/FD6gKfNnDlzQs0F1nZ7klvGOwQAAAAAAACsw/NaYJhqtVrmzZs3rvMBAAAAAAAAYG2KHzBMZVlm0aJFWbFixZjP7ujoyOzZs8d8LgAAAAAAAAAbN8UP2AADAwNZunTpmM/t7OxU/AAAAAAAAABgPeV4BwAAAAAAAAAAoDGKHwAAAAAAAAAAFaX4AQAAAAAAAABQUa3jHQCAZpszweYCAAAAAADAxKX4AbAJqddXpyjOGdf5AAAAAAAAwNgZVvHjyCOPbNrAoihy5plnNu1+APxZUbRk/vz56e/vH/PZXV1d6enpGfO5AAAAAAAAMJENq/hx/fXXpyiK1Ov19V4rimLo18N5fe3fA9B8vb296evrG/O53d3dih8AAAAAAAAwxoZV/DjwwAOfsbCxZMmSXHXVVUmSqVOnZp999sns2bPzghe8IKtWrUpfX19++ctf5sEHH0xra2ve8Y53ZMaMGU39AAAAAAAAAAAAJqphFT8+85nPrHdt5cqVeetb35qiKHLUUUflgx/8YCZNmrTeunq9ntNPPz2f+9zn8tOf/jTf//73R54aAAAAAAAAAICUjW487bTT8rvf/S4HHnhgPvKRjzxj6SN5+lEv73znO3PkkUemr68vX/nKVxoOCwAAAAAAAADAnzVc/PjBD34wdNrHcBx66KFJkp/85CeNjgQAAAAAAAAAYC0NFz8eeuihJMmsWbOGtX7GjBlJkkcffbTRkQAAAAAAAAAArKXh4sdf/MVfJEnuueeeYa2/7bbbkiRbbLFFoyMBAAAAAAAAAFhLw8WPnXfeOfV6PV/60pcyODj4nGuXLVuWz33ucymKIi972csaHQkAAAAAAAAAwFoaLn4cddRRSZIbbrghRx99dG6++eb11tTr9fziF7/I29/+9vzud79La2tr3vnOdzaeFgAAAAAAAACAIa2Nbvyf//N/5gMf+EBOOeWU3HTTTTn88MMzefLkdHd3p729PStWrMj999+flStXpl6vJ0k+9alPZfvtt29aeAAAAAAAAACAiazh4keSvPe9783MmTPzH//xH+nv78+yZctyxx13rLeuu7s7//Iv/5I999xzJOMAAAAAAAAAAFjLiIofSXLwwQfngAMOyLXXXptrr702Dz30UJ544olMnTo1s2bNyite8Yq87GUvS1k2/FQZADZRM2fOnFBzAQAAAAAAoNlGXPxIkkmTJuVVr3pVXvWqVzXjdgBMALVaLfPmzRvX+QAAAAAAAFB1TSl+AMCGKssyixYtyooVK8Z8dkdHR2bPnj3mcwEAAAAAAKDZmlL8WLhwYf7whz9kxYoVqdfrz7v+wAMPbMZYACpuYGAgS5cuHfO5nZ2dih8AAAAAAABsEkZU/FiwYEE+/vGP54EHHhj2nqIoFD8AAAAAAAAAAJqg4eLH73//+7z73e/OU089NaxTPgAAAAAAAAAAaK6Gix/f+MY3smrVqrS2tuaII47Iq1/96vzFX/xFNttss2bmAwCGqaWlTGtr2dDesiySJG1tLWlpaeweg4O1rF5dG9baKmUFAAAAAADYmDVc/FiwYEGKosh73/vevPe9721mJgBgA5VlkWnTOlKWjRUh1ujsbG94b61Wy5Ily1OrPfdJYFXKCgAAAAAAsLFruPjx6KOPJkkOPPDAZmUBABpUlkXKssz8+fPT398/5vO7urrS09OTsiyGVfyoSlYAAAAAAICNXcPFj2nTpqW/vz/t7Y1/ty0A0Fy9vb3p6+sb87nd3d3p6enZoD1VygoAAAAAALCxaviM9d122y1JcvPNNzctDAAAAAAAAAAAw9dw8WPevHkpyzInn3xyli9f3sxMAAAAAAAAAAAMQ8OPetl5553zz//8z/nnf/7nvPnNb85hhx2WnXfeOdOnT09bW9tz7u3u7m50LAAAAAAAAAAAf9Jw8ePVr351kqSlpSV/+MMf8u///u/D2lcURRYuXNjoWAAAAAAAAAAA/qTh4sfixYubmQMAAAAAAAAAgA3UcPHj3/7t35qZAwAAAAAAAACADdRw8eOggw5qZg4AAAAAAAAAADZQOd4BAAAAAAAAAABozJgWPwYHB/Ozn/1sLEcCAAAAAAAAAGyyGn7US5LUarVcfPHFufrqq7NkyZIMDg6mXq+vt+app57K8uXL89BDD+XJJ5/MwoULRxQaAAAAAAAAAIARFD9Wr16dd73rXVmwYMF6r60pfxRF8ZzXAAAAAAAAAABoXMPFj0suuSTXXHNNkqS9vT2zZ8/O8uXLc99996W7uzsvfOELs2TJktx7772p1+spiiI9PT15+9vf3rTwAAAAAAAAAAATWdnoxh/+8IdJkr/6q7/KFVdckYsuuiif+tSnkiQveclLcu655+ayyy7LlVdemb333jv1ej2/+c1v8uIXv7g5yQEAAAAAAAAAJriGix933HFHiqLI+9///rzwhS9Mkuy8885pbW3NtddeO7Ru5syZ+frXv56/+qu/yqJFi3LhhReOPDUAAAAAAAAAAI0XP/74xz8mSebMmTN0bbPNNst2222XP/7xj3nggQfWuX7sscemXq/nsssuG0FcAAAAAAAAAADWaLj4sdlmmyVJOjs717m+7bbbJknuvvvuda7PnTs3SXLPPfc0OhIAAAAAAAAAgLU0XPzo6upKkjz88MPrXN9mm22SJL/73e/WuT558uQkfz4pBABgY1eWRVpby4Z+tLQ8/X+zWloa29/aWqYsi3F+BwAAAAAAgI1da6MbX/rSl+b+++/P97///fzTP/3T0PXtt98+9Xo9N954Y4499tih63fddVeSpK2tbQRxAQDGRlkWmTGjPUXR8P9dSpJMmdLR8N56fTADAytTq9Wfd+2agkkj1hRM2tpahgorG2pwsJbVq2sN7QUAAAAAABrX8L9k/O3f/m0uueSSnH322XnyySdz9NFHZ/vtt88ee+yRsizzi1/8Ij/+8Y/zute9Lo8++mg+97nPJUlmz57dtPAAAKOlLIs/lT4OT3L7OCSYk6I4J2VZPG/xoyyLTJvWkbJs+DC3JElnZ3vDe2u1WpYsWT6skgoAAAAAANA8DRc/XvGKV+TVr351rrrqqnzve9/L0qVL8x//8R/p7u7Ofvvtlx//+Mc5/vjjM3369Pzxj39MrVZLURQ54IADmpkfAGCU3Z7klvEO8ZzKskhZlpk/f376+/vHfH5XV1d6enqGVVIBAAAAAACaa0Rnl3/pS1/Kv//7v+f888/P1ltvPXT9Yx/7WHp7e/PAAw9kYGBg6Pruu++eo446aiQjAQB4Fr29venr6xvzud3d3enp6RnzuQAAAAAAwAiLH+3t7fnEJz6RD33oQ3niiSeGrs+cOTOXXHJJzj333Nx8881paWnJ3nvvnbe+9a1pbR3RSAAAAAAAAAAA/qQpLYzOzs50dnaud+1//a//1YzbAwAAAAAAAADwDMrxDgAAAAAAAAAAQGMUPwAAAAAAAAAAKkrxAwAAAAAAAACgohQ/AAAAAAAAAAAqSvEDAAAAAAAAAKCiFD8AAAAAAAAAACpK8QMAAAAAAAAAoKIUPwAAAAAAAAAAKkrxAwAAAAAAAACgolqHs+grX/lKU4ced9xxTb0fAAAAAAAAAMBENOziR1EUIx5Wr9dTFIXiBwAAAAAAAABAEwyr+LHllls+4/V6vZ6HHnpo6PddXV3Zfvvt84IXvCCrVq1KX19f7rvvvtTr9bS2tublL395UwokAAAAAAAAAAAMs/jxs5/97Bmvn3DCCfnBD36Ql770pfnoRz+aXXbZZb01fX19+fSnP50rr7wybW1t+frXvz6yxAAAAAAAAAAAJEnKRjdefPHFQ6WPb3/7289Y+kiS7u7ufO1rX8s+++yTn//85znzzDMbDgsAAAAAAAAAwJ81XPw499xzUxRFPvjBD2azzTZ7zrVFUeS4445LvV7PhRde2OhIAAAAAAAAAADWMqxHvTyT3/3ud0mSnXbaaVjrZ8+enSS5//77Gx0JAEDFtbSUaW1trHtclkWSpK2tJS0tjd1jcLCW1atrw1pbpawAAAAAAExcDRc/Jk+enJUrV+aRRx7J1KlTn3d9X19fkmTKlCmNjgQAoMLKssi0aR0py4YPnUuSdHa2N7y3VqtlyZLlqdXqz7muSlkVVAAAAAAAJraGix877LBDBgYGcvbZZ+ef//mfn3f9qaeemqIo8uIXv7jRkQAAVFhZFinLMvPnz09/f/+Yz+/q6kpPT0/KshhW8aMKWatUUAEAAAAAYHQ0XPx4+9vfnuuvvz7f/e5384IXvCDHHXdcJk2atN66xx9/PJ/+9Kfzk5/8JEVR5KijjhpRYAAAqq23t3foNLix1N3dnZ6eng3as7FnrUpBBQAAAACA0dNw8eONb3xj5s+fn6uuuiqnnXZazj333Oy+++7ZZptt0tHRkeXLl+f3v/99brrppjz55JNJksMOOyx77rln08IDAAAbf0EFAAAAAIDR03DxoyiKfOlLX8o///M/55JLLsmyZcvy85//fL119Xo9ra2tede73pUPfOADIwoLAAAAAAAAAMCfNVz8SJL29vZ85jOfyRFHHJFLL7001157bRYvXpzHH38806ZNy6xZs/KKV7wib37zm7Pttts2KzMAAAAAAAAAABlh8WONl7zkJXnJS17SjFsBAAAAAAAAADBM5XgHAAAAAAAAAACgMU058ePRRx/NRRddlJtuuimLFy/OsmXL8uMf/zhJ8h//8R/Zaaedsv/++zdjFAAAAAAAAAAAfzLi4sdpp52WL3/5y1m1alWSpF6vpyiKodd/8IMf5Bvf+EbOO++8nHLKKZk+ffpIRwIAAAAAAAAAkBEWP77whS/ktNNOS71eT3t7e170ohfl17/+9TprVq5cmXq9nhtvvDHvec97ct55561TDAGoipkzZ06ouQAAAAAAAMDGr+Hix69//et84xvfSFEUOeqoo/KBD3wgSTJ37tx11v3kJz/JF7/4xZx11ln59a9/nQsvvDCHHHLIyFIDjLFarZZ58+aN63wAAAAAAACA/67h4sdZZ52VJPnbv/3bfPSjH02SLF++fL11kydPzj/90z/l8ccfzyWXXJL/+q//UvwAKqcsyyxatCgrVqwY89kdHR2ZPXv2mM8FAAAAAAAANn4NFz9uvPHGFEWRI444YljrjzzyyFxyySW54447Gh0JMK4GBgaydOnSMZ/b2dmp+AEAAAAAAAA8o7LRjY8++miSZLvtthvW+q222ipJxuUfTQEAAAAAAAAANkUNFz8233zzJMljjz02rPWPPPJIkuQFL3hBoyMBAAAAAAAAAFhLw8WPv/qrv0qSXHHFFcNaf9FFFyVJdtxxx0ZHAgAAAAAAAACwloaLH/vvv3/q9Xq++tWv5je/+c1zrv3Rj36UM888M0VR5HWve12jIwEAAAAAAAAAWEtroxvf+ta35txzz83vfve7HHbYYfnbv/3b7LTTTkOvX3PNNenr68tPf/rTXH311anX69luu+3y1re+tSnBAQAAAAAAAAAmuoaLH62trfnGN76RefPmZdGiRbn44ouTJEVRJEmOOeaYobX1ej2zZs3Kqaeems0222xkiQEAAAAAAAAASDKC4keSzJw5MxdeeGG+8Y1v5Pzzz09/f/96azbffPMcfPDBed/73pdp06aNZFyeeuqpfOELX8gll1ySZcuWZe7cufn4xz+e7bff/hnX/+EPf8gXv/jFXHvttVm5cmXmzJmTD33oQ9l1111HlAMAANhwLS1lWlsbe9pkWT5dMG9ra0lLS2P3GBysZfXqWkN7AQAAAAA2ViMqfiRJR0dHPvCBD+QDH/hA7rnnntx///1ZunRpOjo6MmvWrOy0005paWlpRtZ86Utfyumnn57p06dn9uzZueaaa3Lsscfm0ksvTUdHxzprV6xYkWOOOSb33ntvdthhh2y55Za54YYbcvTRR+fCCy/MX/7lXzYlEwAA8PzKssi0aR0py8ZKG2t0drY3vLdWq2XJkuWp1eojygAAAAAAsDEZcfFjbTvssEN22GGHZt5yyJNPPpnzzjsvRVHk/PPPzzbbbJPDDz88N954Y6644or09PSss/6aa67Jvffemx133DGXXHJJyrLM+9///vz4xz/OxRdfnBNOOGFUcgIAAOsryyJlWWb+/PnPeFLgaOvq6kpPT0/KslD8AAAAAAA2KQ0XP77yla+ko6Mj73jHOzJp0qTnXb98+fLsuuuuKcsyCxcu3OB5d955Z5YtW5Ytt9wy22yzTZJkzz33zI033pibb755veLHjjvumM997nOZOnXq0HcVbrHFFkmSRx99dIPnAwAAI9fb25u+vr4xn9vd3b3e3xkAAAAAADYFIyp+FEWRSy+9NF/96lcza9asYe2r1xv77roHH3wwSTJ9+vSha2t+vXjx4vXWd3d3p7u7e+j3/f39ufTSS5Mkc+fObSjDGo0+l5z1Nfp89mZ7vhxVyTncNWPBe9p83tPmq0rWquRMNq2sVck53DVjwXvafN7T5hvtHGvuv7F8vM+lKlmrkjORdTRUJWdSnaxVyZlUJ2tVcibVyVqVnEl1slYlZ1KdrFXJmcg6GqqSM6lO1qrkTKqTtSo5k2plBdhYjfhRLwsXLswhhxySU045JbvttlszMj2jlStXJklaW/8cua2tbZ3Xns3AwECOOeaYDAwMZLvttsub3vSmhnOUZZHp0zdveD8bpylTOsY7wrBUJWdSnaxVyZlUJ2tVcibVyVqVnImso6EqOZPqZK1KzqQ6WauSMxm7rN6T5qtKzkTW0VCVnEl1slYlZ1KdrFXJmVQna1VyJtXJWpWcSXWyViVnIutoqErOpDpZq5IzqU7WquRMqpUVYGMz4uLH9OnTMzAwkKOPPjof+9jHcthhhzUj13rWPE5mcHBw6NpTTz2VJGlvb3/WfY888kiOPvro3H333Zk6dWpOOeWUYT2a5tnUavU8/vjyhvezrpaWcqP4RP744yuyenXtWV+vSs6kOlmrkjOpTtaq5Exk3VBVyZlsWlmrkjOpTtaq5Eyqk7UqOZNqZR2JNR/naM9phqpkrUrORNbRUJWcSXWyViVnUp2sVcmZVCdrVXIm1clalZxJdbJWJWci62ioSs6kOlmrkjOpTtaq5EyqlXUimDKlw+krUEEjLn6cc845OeGEE7Jw4cJ88pOfzO23357/83/+zzonczTDFltskST54x//OHRtyZIlSfKsj5lZsmRJjjrqqNxzzz2ZMWNGvvWtb+VFL3rRiLMMDvqks6lZvbpWiT/XquRMqpO1KjmT6mStSs6kOlmrkjORdTRUJWdSnaxVyZlUJ2tVciZjl9V70nxVyZnIOhqqkjOpTtaq5Eyqk7UqOZPqZK1KzqQ6WauSM6lO1qrkTGQdDVXJmVQna1VyJtXJWpWcSbWyAmxsRlzXmjVrVs4777y84Q1vSL1ezwUXXJAjjjgi/f39zcg3ZM6cOWlvb88DDzyQvr6+JMm1116bJJk7d+566+v1eo4//vjcc889mTZtWs4+++zMmTOnqZkAAAAAAAAAAMZTU47lmDRpUr70pS/lK1/5Sr761a/m1ltvzVve8pZ8+ctfzv/4H/8jSVIUxYhmdHR05NBDD82ZZ56ZQw89NFtssUUWLlyYrbfeOq997WuzYMGCnHXWWZk9e3ZOPPHE/PSnP811112XJJk6dWq+8IUvDN1rt912yzvf+c4R5QEAADZNLS1lWlsb68iX5dN/72lra2n4WNTBwZqjbQEAAACAYWvq81iOO+647LjjjvnHf/zHLF68OO94xzvyf//v/82BBx6YSZMmjfj+J510Utra2nLRRRfl7rvvzl577ZVPfOITmTRpUh566KH89Kc/zS677JIkueKKK4b23XfffbnvvvuGft+MLAAAwKanLItMm9aRshzZ4Yidne0N763ValmyZHlqtfqIMgAAAAAAE0NTix9J8rrXvS7d3d153/velwcffDAf/ehHc+edd+Yf//Ef09bWlsHBwYbv3dramhNPPDEnnnjieq8dfPDBOfjgg4d+/9nPfjaf/exnG54FAABMPGVZpCzLzJ8/v+mPrxyOrq6u9PT0pCwLxQ8AAAAAYFiaXvxIkjlz5uSCCy7I+973vtxyyy0544wzct9996W1tXVExQ8AAICx0Nvbm76+vjGf293dnZ6enjGfCwAAAABU18jOL34OM2bMyLe//e0cdNBBqdfrufLKK7NixYrRGgcAAAAAAAAAMOGMWvEjSdra2vJv//ZvOemkk0b8jGwAAAAAAAAAANbV8KNevv3tbydJ2tvbn3ftO9/5zvzlX/5lTjvttNTrnlMNAAAAAAAAANAMDRc/Xvayl23Q+le+8pV55Stf2eg4AAAAAAAAAAD+G89fAQAAAAAAAACoqGGd+PHqV786SdLd3Z2zzjprnWsbqiiKXHnllQ3tBQAAAAAAAADgz4ZV/Fi8eHGSZNKkSetd21BFUTS0DwAAAAAAAACAdQ2r+HHQQQclSf7iL/5ivWsAAAAAAAAAAIyPYRU//u3f/m1Y1wAAAAAAAAAAGDvleAcAAAAAAAAAAKAxih8AAAAAAAAAABU1rEe9nHzyyU0devzxxzf1fgAAAAAAAAAAE9Gwih9f//rXUxRF04YqfgAAAAAAAAAAjNywih9JUq/XRzMHAAAAAAAAAAAbaFjFjzvuuGO0cwAAAAAAAAAAsIHK8Q4AAAAAAAAAAEBjFD8AAAAAAAAAACpqWI96eT733HNPlixZksHBwdTr9XVeq9freeqpp7Js2bLcd999ueKKK3LhhRc2YywAAAAAAAAAwIQ2ouLHL3/5y3ziE5/IQw891Kw8AAAAAAAAAAAMU8PFj/vuuy/ve9/7smrVqvVO+Xg27e3tmTt3bqMjgU3SnAk2FwAAAAAAAKB5Gi5+nHXWWXnyySfT2tqaww8/PC972cvS29ubr33ta9l///3z1re+NUuWLMmCBQty4YUXplar5aijjsoHP/jBZuYHKqxeX52iOGdc5wMAAAAAAABUWcPFjwULFqQoihx++OH56Ec/miR5yUtekq997Wu59957s+eeeyZJ9t9//7zhDW/Iu9/97px22ml54xvfmJ122qk56YFKK4qW/PKXv8zjjz8+5rOnTJmSffbZZ8znAgAAAAAAADRTw8WPhx9+OEny5je/eejazJkzM3369Nx5551ZuXJl2tvbkyR777133v72t+fss8/Oueeem3/5l38ZYWxgU1Cr1ca1fFGr1cZtNgAAAAAAAEAzNFz8WLlyZZJk1qxZ61z/y7/8y9x444256667svPOOw9d7+npydlnn52bbrqp0ZHAJqYsyyxatCgrVqwY89kdHR2ZPXv2mM8FAAAAAAAAaKaGix9Tp07NwMBAli9fnunTpw9d7+7uzo033ph77rlnneJHd3d3kuShhx4aQVxgUzMwMJClS5eO+dzOzk7FDwCg8lpayrS2lg3tLcsiSdLW1pKWlsbuMThYy+rVTlEDAAAAgPHUcPFj9uzZGRgYyG9/+9tstdVWQ9e322671Ov1LFy4MAcddNDQ9SeeeCJJsmrVqhHEBQAAIHm6uDFtWkfKsrHSxhqdne0N763ValmyZHlqtfqIMgAAAAAAjWu4+LHXXnvlxhtvzBe/+MX8j//xP7LlllsmSV70ohclSa644oqccMIJmTRpUpLk0ksvTZJ1TgcBgOqYM0FmAlAVZVmkLMvMnz8//f39Yz6/q6srPT09KctC8QMAAAAAxlHDxY+/+7u/y2mnnZb77rsvb3jDG/Kud70r73//+7P33ntn1qxZWbx4cY488si8+c1vzj333JPvfOc7KYoiu+++ezPzA8Coq9dXpyjOGbfZAPBcent709fXN+Zzu7u709PTM+ZzAQAAAIB1NVz8mD59er74xS/mH/7hH7JixYo8+uijT9+wtTXvfe978/GPfzy33XZbbrvttiRJvV5Pa2trjj322OYkB4AxUhQt4/Ld1Gu+kxoAAAAAAACeTcPFjyR51atelR/+8Ic5++yzs+OOOw5df+tb35qVK1fmlFNOyRNPPJEkeeELX5hPfvKTefGLXzyyxAAwDsbju6l9JzUAAAAAAADPZ0TFjySZNWtWTjzxxPWuH3HEEXnb296Wu+++Oy0tLdlxxx1TluVIxwEAAAAAAAAA8CcjLn48l0mTJuUlL3nJaI4AAAAAAAAAAJiwRrX4AQAAAGVZpCyLhva2tJTr/NyIWq2eWq3e8H4AAAAA2JiNqPixePHinHrqqbnmmmvy8MMPZ9WqVc+7pyiKLFy4cCRjAQAAqIiyLDJjRnuKYmTfdzBlSkfDe+v1wQwMrFT+AAAAAGCT1PBX3vr6+nLooYdmyZIlqdd98QwAAID1lWXxp9LH4UluH4cEc1IU56QsC8UPAAAAADZJDRc/Tj755AwMDKQsy7zhDW/IS1/60nR2dqYsGz9+FwAAgE3V7UluGe8QAAAAALDJabj4ce2116Yoihx33HF573vf28xMAAAAAAAAAAAMQ8PHczz++ONJkkMOOaRpYQAAAAAAAAAAGL6Gix8zZ85MkhRF0bQwAAAAAAAAAAAMX8PFj7/5m79Jklx11VXNygIAAAAAAAAAwAZouPjxnve8JzNnzsznP//53HLLLc3MBAAAAAAAAADAMLQ2unHKlCn59re/nWOOOSaHHXZY/uf//J958YtfnM7Ozud9/Mvxxx/f6FgAAAAAAAAAAP6k4eJHknz3u9/Ngw8+mCS55ZZbhn3yh+IHAAAAG6OWljKtrY0djlmWT38TRFtbS1paGrvH4GAtq1fXGtoLAAAAwMTUcPHj/PPPz2mnnZaiKFKv15uZCQAAAMZcWRaZNq0jZdnwU1GTJJ2d7Q3vrdVqWbJkeWo1f88GAAAAYHgaLn585zvfSZLMnDkz//iP/5jddtstf/EXf/G8j3kBAACAjVFZFinLMvPnz09/f/+Yz+/q6kpPT0/KslD8AAAAAGDYGi5+3HvvvSmKIp/61Key1157NTMTAAAAjJve3t709fWN+dzu7u709PSM+VwAAAAAqq3h82vb2tqSJDvttFPTwgAAAAAAAAAAMHwNFz/WFD7uvffeZmUBAAAAAAAAAGADNPyolyOOOCLXXXddTjnllHzzm99MS0tLM3MBAAAAz6GlpUxra2Pfz1GWRZKkra0lLS0bfo/BwVpWr64Ne9aaeRtqTbZGMq5Rq9VTq9Ub3g8AAACwsWu4+LHffvvlqKOOyplnnpm/+7u/y9FHH52dd94506dPT0dHx3PuLcvGv2ADAAAAE11ZFpk2rWPEf7/u7GxvaF+tVsuSJcuft1BRlkVmzGhPUTT85YckyZQpz/11hudSrw9mYGCl8gcAAACwyWr4Ky9HHnlkkmTSpEn5zW9+kw9/+MPD2lcURRYuXNjoWAAAAJjwnj5Fo8z8+fPT398/prO7urrS09OTsiyGVfx4uvRxeJLbxyTfuuakKM4ZVlYAAACAqmq4+HH99dc3MwcAAACwgXp7e9PX1zemM7u7u9PT07OBu25PcstoxAEAAACY8Boufrzvfe9LUTT2jF4AAACAjU1LS5nW1sYen1OWT3+NpK2tJS0tjd1jcLCW1atrDe0FAAAAJq6Gix/vf//7m5kDAAAAYNyUZZFp0zpSlo2VNtbo7GxveG+tVsuSJcs9lgYAAADYIA0XP0444YR0dnbmiCOOyA477NDMTAAAAABjqiyLlGWZ+fPnp7+/f8znd3V1paenJ2VZKH4AAAAAG6Th4seCBQsyMDCQV73qVYofAAAAwCaht7c3fX19Yz63u7s7PT09Yz4XAAAAqL6Gzy994oknkiS77LJL08IAAAAAAAAAADB8DRc/1pzycccddzQtDAAAAAAAAAAAw9dw8eMjH/lIWltb87GPfSzXXXddMzMBAAAAAAAAADAMrY1u7Ovry4EHHpjvfe97OfroozNlypTstNNOmTZtWiZNmvSs+4qiyGc/+9lGxwIAAAAAAAAA8CcNFz/+9//+3ymKIkVRpF6v549//GOuv/7659xTr9cVPwAAAAAAAAAAmqTh4seWW27ZzBwAAAAAAAAAAGyghosfP/vZz5qZAwAAAAAAAACADVSOdwAAAAAAAAAAABrT8Ikf/129Xs8dd9yRBx98MMuXL09HR0e22mqr7LjjjmlpaWnWGAAAAAAAAAAA/mTExY9ly5bl61//es4///w88cQT670+efLkHHTQQfngBz+YzTfffKTjAAAAAAAAAAD4kxE96uXBBx/MW97ylnzzm9/M448/nnq9vt6PZcuW5ZxzzsnBBx+cP/zhD83KDQAAAAAAAAAw4TV84sfg4GD+/u//PosWLUqSvOY1r8kb3vCG7LDDDuno6MjSpUvz+9//Ppdffnmuuuqq3H///fmHf/iHfOc730lra9OeMAMAAAAwobS0lGltbex7ecqySJK0tbWkpaWxewwO1rJ6da2hvQAAAEDzNdzAuOCCC3LXXXeltbU1X/jCF/L6179+vTU777xzDjzwwPzkJz/JP/zDP6S3tzc//OEP09PTM6LQAAAAABNRWRaZNq0jZTmiQ1zT2dne8N5arZYlS5anVquPKAMAAADQHA0XP374wx+mKIocc8wxz1j6WNt+++2XY445Jv/5n/+ZSy65RPEDAAAAoAFlWaQsy8yfPz/9/f1jPr+rqys9PT0py0LxAwAAADYSDRc/7rrrriTJm9/85mGtf/Ob35z//M//zN13393oSAAAAACS9Pb2pq+vb8zndnd3+4YeAAAA2Mg0fC7o0qVLkzz9nR7DsWbdkiVLGh0JAAAAAAAAAMBaGi5+TJ8+PUly7733Dmv9mnVTp05tdCQAAAAAAAAAAGtpuPixyy67JEnOOOOMYa0//fTT19kHAAAAAAAAAMDINFz8eMtb3pJ6vZ7LLrssn/3sZzM4OPiM6wYHB/OZz3wml112WYqiyCGHHNJwWAAAAAAAAAAA/qy10Y2vfvWr85rXvCY/+9nPcsYZZ+S//uu/su+++2aHHXbI5MmTs3z58txzzz258sor8+ijjyZJXvOa12TfffdtWngAAAAAAAAAgIms4eJHkvzHf/xHPvjBD+bKK69Mf39/LrjggvXW1Ov1JE+XPj73uc+NZBwAAAAAAAAAAGsZUfGjvb09X//613PllVfme9/7Xm644YY88cQTQ69PmTIlu+66aw499FAnfQAAAAAAAAAANNmIih9r7LvvvkPFjmXLlmXp0qXZfPPN09nZ2YzbAwAAAAAAAADwDJpS/Fjb5ptvns0337zZtwUAAAAAAAAA4L8pxzsAAAAAAAAAAACNGdaJH4cffnjTBhZFkbPPPrtp9wMAAAAAAAAAmKiGVfy46aabUhRF6vV6Q0OKokiS1Ov1oV8DAAAAAAAAADAywyp+7L777g0PePDBB/PAAw8MFT4UPwAAAAAAAAAAmmNYxY+zzjprg29cr9dzxhln5OSTTx46LWSrrbbKpz71qQ2+FwAAAADV09JSprW1bGhvWT79zUNtbS1paWnsHoODtaxeXWtoLwAAAFTFsIofG+ree+/NRz/60dx6661D1w477LCccMIJmTx58miMBAAAAGAjUpZFpk3rSFk2VtpYo7OzveG9tVotS5YsT63W2OOLAQAAoAqaXvw4/fTTc/LJJ+fJJ59MvV5Pd3d3PvWpT+VlL3tZs0cBAAAAsJEqyyJlWWb+/Pnp7+8f8/ldXV3p6elJWRaKHwAAAGzSmlb8WLRoUT760Y/m17/+der1eoqiyDve8Y58+MMfTkdHR7PGAAAAAFAhvb296evrG/O53d3d6enpGdZaj6QBAACgykZc/KjX6/nWt76VL3/5y0OnfGyzzTb59Kc/nd12260ZGQEAAABgVHgkDQAAAFU3ouLH73//+3zsYx9b55SPI444Ih/+8IfT3t74X3YBAACATcmcCTaXKvFIGgAAAKquoeJHvV7PN7/5zXz5y1/OqlWrUq/Xs+222+ZTn/qUUz4AAACAIfX66hTFOeM6H4ajCo+kSdYUVYqGZq15FE2jj6RJklqtrqACAACwkdng4sc999yTj33sY7nttttSr9dTlmWOPPLIfOhDH8qkSZNGIyMAAABQUUXRMu4nKcCmoiyLzJjRnqIY2dObp0zpaHhvvT6YgYGVyh8AAAAbkWH/LbFer+cb3/hGvvrVrw6d8rHddtvl05/+dHbdddfRzAgAAABUWFVOUoCNXVkWfyp9HJ7k9nFIMCdFcY7H0gAAAGxkhlX8uOeee/KRj3wkv/3tb1Ov19PS0pIjjzwyH/zgB7PZZpuNdkYAAAAAYMjtSW4Z7xAAAABsJIZV/DjwwAMzODiYer2eoigye/bsPProo/nf//t/b/DAoijy2c9+doP3AQAAAMBomTlz5oSaCwAAwKZjWMWPp556KkVRpCiKJE+fAHLPPfds8LA1xRHFDwAAAAA2FrVaLfPmzRvX+QAAANCoYRU/ttxyy9HOAQAAAADjoizLLFq0KCtWrBjz2R0dHZk9e/aYzwUAAGDTMazix89+9rPRzgEAAAAA42ZgYCBLly4d87mdnZ2KHwAAAIxIOd4BAAAAAAAAAABojOIHAAAAAAAAAEBFDetRLwAAAAAAw9XSUqa1tbHvOSvLIknS1taSlpbG7jE4WMvq1bWG9gIAAFSN4gcAAAAA0DRlWWTatI6U5cgOG+7sbG94b61Wy5Ily1Or1UeUAQAAoAoUPwAAAACApinLImVZZv78+env7x/z+V1dXenp6UlZFoofAADAhKD4AQAAAAA0XW9vb/r6+sZ8bnd3d3p6esZ8LgAAwHgZ2XmLAAAAAAAAAACMG8UPAAAAAAAAAICKUvwAAAAAAAAAAKio1vEOAAAAAAAwXlpayrS2Nvb9cWVZJEna2lrS0tLYPQYHa1m9utbQXgAAgETxAwAAAACYoMqyyLRpHSnLkR2M3NnZ3vDeWq2WJUuWp1arjygDAAAwcVWq+PHUU0/lC1/4Qi655JIsW7Ysc+fOzcc//vFsv/32z7nv/vvvz/7775+pU6fmV7/61RilBQAAAAA2ZmVZpCzLzJ8/P/39/WM+v6urKz09PSnL4nmLH04mAQAAnk2lih9f+tKXcvrpp2f69OmZPXt2rrnmmhx77LG59NJL09HR8Yx7Hn744bz3ve/NU089NcZpAQAAAIAq6O3tTV9f35jP7e7uTk9Pz/OuczIJAADwXCpT/HjyySdz3nnnpSiKnH/++dlmm21y+OGH58Ybb8wVV1zxjH9BOuecc3LKKafkscceG/vAAAAAAABNUKWTSQAAgLFXmeLHnXfemWXLlmXLLbfMNttskyTZc889c+ONN+bmm29+xuLHF7/4xbS0tORd73pXvvGNb4x1ZAAAAACAptnYTyYBAADGx8jOBhxDDz74YJJk+vTpQ9fW/Hrx4sXPuOf9739/fvSjH+UVr3jF6AcEAAAAAAAAABhjlTnxY+XKlUmS1tY/R25ra1vntf/uqKOOGpUsra2V6cts9FpaNo738vlyVCXncNeMBe9p83lPm68qWauSM9m0slYl53DXjAXvafN5T5vPe9p83tPmq0rWquRMNq2sVck53DVjwXvafN7T5tuU3tPk6UfTNJq5LIskyaRJrWlra+yxMqtX10b9kTRrPr6N5c/mucjafFXJmVQna1VyJtXJWpWcSbWyAmysKlP8mDRpUpJkcHBw6NpTTz2VJGlvbx+zHGVZZPr0zcdsHmNjypSO8Y4wLFXJmVQna1VyJtXJWpWcSXWyViVnIutoqErOpDpZq5IzqU7WquRMqpO1KjmT6mStSs6kOlmrkjORdTRUJWdSnaxVyZlUJ2tVcibVyTrcnPV6PUVRjGjW5MmTGt7bjPnDVZU/u0TW0VCVnEl1slYlZ1KdrFXJmVQrK8DGpjLFjy222CJJ8sc//nHo2pIlS5Iks2bNGrMctVo9jz++fMzmbepaWsqN4hP544+vyOrVtWd9vSo5k+pkrUrOpDpZq5IzkXVDVSVnsmllrUrOpDpZq5IzqU7WquRMqpO1KjmT6mStSs5E1g1VlZzJppW1KjmT6mStSs6kOlmrkjOpTtaq5Ez+nHX+/Pnp7+8fo2R/1tXVlZ6enmFlHYk1H+doz2kGWZuvKjmT6mStSs6kOlmrkjOpVtaJYMqUDqevQAVVpvgxZ86ctLe354EHHkhfX1+6u7tz7bXXJknmzp07plkGB33S2dSsXl2rxJ9rVXIm1clalZxJdbJWJWdSnaxVyZnIOhqqkjOpTtaq5Eyqk7UqOZPqZK1KzqQ6WauSM6lO1qrkTGQdDVXJmVQna1VyJtXJWpWcSXWybkjO3t7e9PX1jXKi9XV3d6enp2fM3tOq/Nklso6GquRMqpO1KjmT6mStSs6kWlkBNjaVKX50dHTk0EMPzZlnnplDDz00W2yxRRYuXJitt946r33ta7NgwYKcddZZmT17dk488cTxjgsAAAAAwEaspaVMa2tj39Fclk8/SqatraXh74oeHKz5znYAAJqiMsWPJDnppJPS1taWiy66KHfffXf22muvfOITn8ikSZPy0EMP5ac//Wl22WWX8Y4JAAAAAMBGrCyLTJvWkbIc2VH2nZ3tDe+t1WpZsmR5arX6iDIAAEClih+tra058cQTn/FEj4MPPjgHH3zwM+57+ctfnjvvvHO04wEAAAAAUAFlWaQsy8yfPz/9/f1jPr+rqys9PT0py2JYxQ+nkwAA8FwqVfwAAAAAAIBm6e3tTV9f35jP7e7uTk9Pz7DWOp0EAIDno/gBAAAAAAAbqaqdTgIAwNhT/AAAAAAAgI1cFU4nAQBgfIzsbDgAAAAAAAAAAMaN4gcAAAAAAAAAQEUpfgAAAAAAAAAAVJTiBwAAAAAAAABARbWOdwAAAAAAYEPMmWBzAQAAeC6KHwAAAABQEfX66hTFOeM6HwAAgI2L4gcAAAAAVERRtGT+/Pnp7+8f89ldXV3p6ekZ87kAAAA8N8UPAACA/2bmzJkTai4A1dLb25u+vr4xn9vd3a34AQAAsBFS/AAAAFhLrVbLvHnzxnU+AAAAAMBwKX4AAACspSzLLFq0KCtWrBjz2R0dHZk9e/aYzwUAAAAAqkvxAwAA4L8ZGBjI0qVLx3xuZ2en4gcAAAAAsEEUPwCAcTFz5swJNRcAAAAAAGA0KH4AAGOuVqtl3rx54zofAAAAAABgU6D4AQCMubIss2jRoqxYsWLMZ3d0dHiMAgAAAAAAsMlQ/AAAxsXAwECWLl065nM7OzsVPwAAAAAAgE1GOd4BAAAAAAAAAABojOIHAAAAAAAAAEBFKX4AAAAAAAAAAFSU4gcAAAAAAAAAQEUpfgAAAAAAAAAAVFTreAcAAAAAAOD5zZw5c0LNBQAAhkfxAwAAAAAqxD/+T0y1Wi3z5s0b1/kAAMDGSfEDAAAAACrCP/5PXGVZZtGiRVmxYsWYz+7o6Mjs2bPHfC4AADA8ih8AAAAAUBH+8X9iGxgYyNKlS8d8bmdnpz97AADYiCl+AAAAAECF+Md/AAAA1qb4wUbBs2kBAAAAAAAAYMMpfjDuPJsWAAAAAAAAABqj+MG482xaAAAAAGA8OIkYAIBNgeIHGwXPpgUAAACATUcVChVOIgYAYFOh+AEAAAAAQNNUpVDhJGIAADYVih8AAAAAADRNlQoVTiIGAGBToPgBAAAAAEBTKVQAAMDYKcc7AAAAAAAAAAAAjVH8AAAAAAAAAACoKI96AQAAAAAAmqKlpUxra2Pfc1qWRZKkra0lLS0bfo/BwVpWr641NBsAoMoUPwAANhEzZ86cUHMBAADYuJRlkWnTOlKWIztsvLOzvaF9tVotS5YsT61Wf96141lQSZRUAIDmUvwAANgE1Gq1zJs3b1znAwAAMHqqUPYvyyJlWWb+/Pnp7+8fxVTr6+rqSk9PT8qyeN7ix3gXVJINK6kAADwfxQ8AgE1AWZZZtGhRVqxYMeazOzo6Mnv27DGfCwAAMFFUrezf29ubvr6+UUrzzLq7u9PT0zOsteNZUEk2rKQCADAcih8AAJuIgYGBLF26dMzndnZ2Kn4AAACMImX/0TEeBZVkw0oqAADDofgBAAAAAAAbOWV/AACezcgeYAcAAAAAAAAAwLhx4gcAAABjYM4EmwsAAAAAY0PxAwAAgFFVr69OUZwzrvMBAAAAYFOl+AEAAMCoKoqW/PKXv8zjjz8+5rOnTJmSffbZZ8znAgAAAMBYUfwAAABgVNVqtXEtX9RqtXGbDQAAAACjTfEDAACAUVWWZRYtWpQVK1aM+eyOjo7Mnj17zOcCAECztLSUaW0tG9pblkWSpK2tJS0tjd1jcLCW1auVqQFgY6b4AQAAjJmZM2dOqLn82cDAQJYuXTrmczs7OxU/AACorLIsMm1aR8qysdLGGp2d7Q3vrdVqWbJkeWq1+ogyAACjR/EDAAAYE7VaLfPmzRvX+QAAAFVSlkXKssz8+fPT398/5vO7urrS09OTsiwUPwBgI6b4AQAAjAmP+wAAAGhMb29v+vr6xnxud3d3enp6xnwuALBhFD8AAIAx43EfAAAAAADNpfgBAPCc5kywuQAAAAAAQJUofgAAPIt6fXWK4pxxnQ8AAAAAAPBcFD8AAJ5FUbRk/vz56e/vH/PZXV1dnqELAAAAAAA8L8UPAIDn0Nvbm76+vjGf293drfgBAAAAAAA8r3K8AwAAAAAAAAAA0BjFDwAAAAAAAACAilL8AAAAAAAAAACoqNbxDgAAAAAAMJ5mzpw5oeYCAACbFsUPAADGlC+qA7Ax83kKJp5arZZ58+aN63wAAICRUPwAAGDM+KI6ABszn6dgYirLMosWLcqKFSvGfHZHR0dmz5495nMBAIBNi+IHAABjxhfVAdiY+TwFE9fAwECWLl065nM7Ozv9bx8AABgxxQ8AAMaUL6oDsDHzeQoAAAComnK8AwAAAAAAAAAA0BjFDwAAAAAAAACAilL8AAAAAAAAAACoKMUPAAAAAAAAAICKUvwAAAAAAAAAAKgoxQ8AAAAAAAAAgIpS/AAAAAAAAAAAqKjW8Q4AAABA42bOnDmh5gIAAAAA61L8AAAAqKharZZ58+aN63wAAAAAYHwpfgAAAFRUWZZZtGhRVqxYMeazOzo6Mnv27DGfCwAAbJxaWsq0tpYN7S3LIknS1taSlpbG7jE4WMvq1crpAExMih8AAAAVNjAwkKVLl4753M7OTsUPAAAgydPFjWnTOlKWjZU21ujsbG94b61Wy5Ily1Or1UeUAQCqSPEDAAAAAGi6mTNnTqi5ABNZWRYpyzLz589Pf3//mM/v6upKT09PyrJQ/ABgQlL8AAAAAACaqlarZd68eeM6H4Cx19vbm76+vjGf293dnZ6enjGfCwAbC8UPAAAAAKCpyrLMokWLsmLFijGf3dHR4XFkAADAhKL4AQAAAAA03cDAQJYuXTrmczs7OxU/AHhOLS1lWlvLhvaWZZEkaWtrSUtLY/cYHKxl9WqnUwHQPIofAAAAAAAATAhlWWTatI6UZWOljTU6O9sb3lur1bJkyfLUavURZQCANRQ/AAAAAAAAmBDKskhZlpk/f376+/vHfH5XV1d6enpSloXiBwBNo/gBAAAAAADAhNLb25u+vr4xn9vd3Z2enp4xnwvApk3xAwAAAAAAaJqZM2dOiJkw2lpayrS2NvZImrIskiRtbS1paWnsHoODtaxeXWtoLwBjS/EDAAAAAABoilqtlnnz5o3bbNhUlGWRadM6UpaNlTbW6Oxsb3hvrVbLkiXLPZIGoAIUPwAAAAAAgKYoyzKLFi3KihUrxnRuR0dHZs+ePaYzYTSVZZGyLDN//vz09/eP+fyurq709PSkLAvFD4AKUPwAAAAAAACaZmBgIEuXLh3TmZ2dnYofbJJ6e3vT19c35nO7u7vT09Mz5nMBaIziBwAAAAAAANCwlpYyra2NPZamLIskSVtbS1paGrvH4GAtq1d73BMwcSl+AAAAAAAAAA0pyyLTpnWkLBsrbazR2dne8N5arZYlS5Z7LA0wYSl+wCZq5syZE2ouAAAAAAAw9sqySFmWmT9/fvr7+8d8fldXV3p6elKWheIHMGEpfsAmqFarZd68eeM6HwAAqkqJGgAAYMP19vamr69vzOd2d3enp6dnzOcCbEwUP2ATVJZlFi1alBUrVoz57I6OjsyePXvM5wIAQDMoUQMAAABQNYofsIkaGBjI0qVLx3xuZ2en4gcAAJWlRA0AAABA1Sh+AAAAwFqUqAEAAACoknK8AwAAAAAAAAAA0BjFDwAAAAAAAACAivKoF4BNzMyZMyfUXAAAAAAAAJjIFD8ANiG1Wi3z5s0b1/kAAAAAAADA2FH8ANiElGWZRYsWZcWKFWM+u6OjI7Nnzx7zuQAAAAAAADCRKX4AbGIGBgaydOnSMZ/b2dmp+AEAAAAAAABjrBzvAAAAAAAAAAAANEbxAwAAAAAAAACgohQ/AAAAAAAAAAAqSvEDAAAAAAAAAKCiFD8AAAAAAAAAACpK8QMAAAAAAAAAoKIUPwAAAAAAAAAAKqp1vAMAAAAAAAAA1TZz5swJNRdgY6L4AQAAAAAAADSsVqtl3rx54zofYCJT/AAAAAAAAAAaVpZlFi1alBUrVoz57I6OjsyePXvM5wJsTBQ/AP7/7N13VFRX2/fx7yAgqFgRwd5QVIooxYISBRt2jb1Egi22WGNiYo0mRmM3CfbeYuyKGtEodgQUbKAg2MWCIr3O+wcvJ4wUyf3eN+ecvPuz1rMenJln5fcwnJl99r72tQVBEARBEARBEARBEARBEARB+H8SExNDfHx8kf93S5UqJQo/BEH4/56e3AH+ibS0NBYuXEjz5s2xtbXF09OTBw8e5Pv6+Ph4vvnmGxwdHbG3t2f8+PG8fPmyCBMLgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiD876iq8GP58uVs2rQJrVZLrVq1uHTpEsOHD8+3bdR3333H/v37KVmyJGZmZvz555+MHTsWrVZbxMkFQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRD++1RT+JGSksKuXbvQaDT8/vvvHDp0CAcHB54+fcqpU6dyvf7FixecOHGCEiVKcOTIEY4ePUrVqlUJCQkhKChIhv8PBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQ/rtUU/gRFhZGQkICFhYWVK9eHYDmzZsD5FnIERQUhFarpVGjRpiYmGBgYICTk1O+rxcEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQVAbjVYl556cOHGCL7/8kkaNGrF//34AduzYwbx582jTpg3e3t46r9+wYQOLFi2iffv2rFq1CoBFixaxYcMGBg8ezMyZM/+jHFqtlsxMVfzKVEGjAT09PVJTU2U5gkej0WBoaEhmZiYF/efVkjPrterIqpacWa9VR1a15Mx6rfqyxsXFkZ6eXjQB/y99fX1MTEwUnxP+s6xKf//F77Tw/s2fU0p//9WSE9Tz/qslZ9Zr1ZFVLTmzXqu+rGKMUrB/8+eUmn6nSs+qlvc+67XqyKqWnFmvVUdWteTMeq06sqolZ9ZrRdbCUMtYCv7d36dKzwnqyaqWnKCuzynh4/T0NGg0GrljCILwD+nLHaCwkpOTgawvmmwGBgY6z/2/vL6wNBoNxYqJD7v/NkNDQ1n/+3p6hWt+o5acoJ6saskJ6smqlpygrqwmJib/wyQFU0tO+He+/+J3Wnj/xs8ptbz/askJ6nn/1ZIT1JNVLTlBXVnFGKVw/o3vv5p+p2rJqpb3HtSTVS05QT1Z1ZIT1JNVLTlBZC2sf+N3FKgnq1pygnqyqiUnqOtzShAE4d9GNZ+AxYsXB9CpakxLSwPAyMgo39dnZGTker2xsfH/LKcgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCEJRUU3hR6VKlQCIjY2VHnv79i0AFhYW+b7+3bt3uV5vbm7+v4opCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIJQZFRT+NGgQQOMjIx4+vQpjx8/BuDKlSsANG3aNNfrGzduDMDt27eJj48nPT2dgICAfF8vCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIKgNhqtVquVO0Rh/fDDD2zZsoUKFSpQqVIl7ty5Q9WqVfHx8SEoKIht27ZRq1Ytpk2bBsDYsWPx9fWlSpUqFC9enAcPHmBvb8+uXbvQaDQy/38jCIIgCIIgCIIgCIIgCIIgCIIgCIIgCILw/0Y1HT8AvvrqK4YPHw5AeHg4LVq0YP369RQvXpznz59z+vRprl27Jr1+0aJF9O3bl7i4OJ4/f0779u1ZvXq1KPoQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBOFfQVUdPwRBEARBEARBEARBEARBEARBEARBEARBEIS/qarjhyAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgvA3UfghCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIKgUqLwQxAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQaVE4YcgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIJKicIPQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAElRKFH4IgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCColCj8EQRAEQRAEQRAEQRD+ocTERLkjCIIgCIIgCIIgCIIgAKDRarVauUMIgiCvsLAw7t69y5s3byhWrBgVK1akUaNG1KxZU+5oqpKQkEBMTAzVqlWTO8q/xrVr10hOTqZVq1ZyR/koHx8f0tPT6datm9xRBKFQ0tPTSU9Px8jIiLCwMK5cuYKzszNWVlZyRxMEQRD+PxcXF0doaKjO/YmVlRVGRkZyR9Ph5uaGnZ0dS5culTtKgc6cOYOrqyvFihWTO0qhKPn+VI1j/oULF9KzZ0/q168vd5RCiYmJISUlhQ+nKytXrixTorwp+e+0IHFxcZiYmMgdQ7XUdj2pjVarRaPR8OrVK4KDg7G1tcXMzEzuWIIg/I89e/ZM5/u0YsWKckcSBEFQLX25AwjCP/HgwQMuXrzInTt3iImJQU9Pj4oVK2JtbU3Lli2pUqWK3BEBiI+Px9/fXyenmZkZjRo1okmTJhgbG8sdkdevX7Njxw7++OMPXr9+nedrqlatSq9evejXrx/ly5cv4oR/02q1XLhwId/3vlWrVjg4OMiWL9usWbPIzMxkxowZXLx4kR49esgdqUBquJ58fX2JiorC0NCQY8eOMW/ePLkj5SsiIoLr168DcOTIEdatWydzon+X2NhY9u7dS3BwMHXq1MHNzY1ixYrRsGFDuaOp0oMHDxg+fDgzZszAysqKPn36kJaWhr6+PuvWraNZs2ZyRyQ+Pp6jR4/m+TnVqFEjWrduTYcOHRSzCKiG7/5se/bsoXHjxlhaWjJt2jT8/PxwcXFhwYIFlChRQu54OpSeVW1/p2qhhjGKWr19+xY9PT3KlCnD+fPnOX/+PC1btsTV1VXuaKSmpnL48GH27t3LrVu3yMzM1Hm+WLFiODg40KtXLzp27IihoaFMSf+WkJDAq1ev5I7xUWPGjKFChQp06dKFHj160KBBA7kj5aKW+1M1jvk3b97Mli1bqF+/Pj179qRr166y3t/nJygoiK+//prHjx/nek6j0XDnzh0ZUulSy99ptoyMDFasWEHbtm1p2LAhQ4cOJTg4GBsbG3777TcqVKggaz41Usv1BOoaT7169Yrx48czatQobG1t6dKlC+/fv6d06dJs2rRJMff9r1+/ZunSpQQHB+cqUNNoNPj6+sqYTr3mz59P06ZN6dSpk9xRPurJkyfcvHmTlJSUXM8pfR5YaS5fvszevXu5dOkSsbGxOs+ZmprSunVrevXqRdOmTWVKKAiCoE6i44egCmfPnmXdunUEBQUB5Nr5odFo0Gg0ODs7M3z4cFq2bClHTEJDQ9m4cSMnTpwgLS0tz5zGxsZ4eHjg6elJnTp1ZMm5efNmVq1aRUJCAiVKlKBRo0bUqlWLMmXKAFkLrJGRkYSGhkq7QcaMGYOnp2eR5tRqtezcuZONGzfy7NmzXL/PbBqNhmrVqjF8+HD69OmDRqMp0pwAN2/e5PHjxyxcuBADAwOqVKnC1q1bizxHYajletqwYQMpKSmsX78egMGDBzN58mRZsnzMvHnz0NPTY8+ePZQoUYLJkyfTr18/uWP9R5S4AywqKorBgwfz5s0bIGt3raWlJRs2bGD9+vU4OTnJnPBvapkIGj16NOfOnWP69Om8ffuWNWvW4OLiwsWLF3F0dJT18ysxMZFVq1axZ88ekpKSCvzsL1GiBIMHD2bUqFGyFQGo5bs/28aNG1m8eDGzZ8/GxMSEKVOmSDk9PT356quvZM2Xk5Kzqu3v9ENKXfxXyxglL2roonTjxg28vLz4/vvvqVOnjs7k9PLly+nQoYNs2Xx9fVmwYAEvXrxAq9VSuXLlPO9Pnj17hkajoXLlykyfPp327dvLlhlgx44dLFq0iPHjx+Pg4ICJiQl6en+fqFurVi0Z0/3Nw8ODBw8eAFnXUb169ejZsyddunTB1NRU5nTquT9V65h/9uzZnD59mtevX6PRaChWrBguLi707NmTtm3bYmBgIHdEAPr160dwcHC+z4eGhhZhmtzU8nea05IlS1i/fj3ffvstxYsXZ+bMmUDW50CfPn0UubEiPDyc0qVLY2Zmxp49e6Si3wEDBsgdDVDH9aTG8dSUKVPw8fFh2rRppKSksGLFCurUqUNERASffPIJ3t7eckcE4IsvvuDs2bN5jv01Gg13796VIZX6NWnSBCsrK3bu3Cl3lAL9/vvvzJs3j4yMjDyfV9L77+bmlu9zhoaGmJqa0r59e4YMGVKEqbLcunWLOXPmcPv2bbRaLfr6+lStWlX6Pn337h1Pnz4lPT0djUZD48aNmTFjBjY2NkWeVRAEQY1E4YegeGPGjOHMmTMYGBjg5ORE48aNqV27NqVLlwb+vrm+desW/v7+JCcn4+rqWuQ3BQsWLGDnzp1kZGRQo0YN7O3t88x5+/Zt7t+/j76+Pv379+e7774r0pwA1tbWdOjQgR49etCsWbN8b0wzMzMJCgri6NGjHDp0SNrZVFR69erFnTt3MDU1pW3btgW+9+fPn+fx48dYWVlx8ODBIs0JYGVlhb6+Punp6TRs2JCdO3cqcnevWq4ngI4dO1K6dGlCQkKwtLRk2bJl1K1bt8hzFIaXlxdGRkacPXsWCwsL5s6dq4jJk49Ryw6w0aNH4+fnh5eXF+vWrcPd3Z1WrVoxZ84c7O3tFTU5oJaJoObNm2NqasrBgwfp378/MTExnD59mv79+xMZGcnVq1dly+bq6kp0dDR2dnY6n/05JwGyv0/PnTtHYGAg5cqV4/z580WeVU3f/dk6duxIdHQ069evZ/v27Zw5c4atW7cyduxYjI2NOXXqlGzZPqTkrGr6O/2QUhf/1TRG+dCHXZQ8PDwU10UJYOjQoVy7do05c+YQGRnJ5s2b6devH/v27aNBgwbs3btXtmxWVlY0btyYHj160LZt23zbusfExODn58exY8ekXcxysrKyyrfoXCkdCrKFh4dz/PhxTpw4QUREhM6CZffu3WnXrh36+vI0hVXL/alax/yQtfDr7+/PiRMnOHXqlLRoXbp0aTw8PBg0aJDs91r29vYYGRmxZs0a6tevn+vvUe6jitTyd5pT27ZtSUhIYPv27SxbtoyrV69y8uRJ+vXrR2ZmJn/99Zds2fJy9uxZxo0bx4IFC6hatSqDBg0Csj5PZ8+eTf/+/WVOmEXJ15Nax1MuLi6UKFGCAwcOMGrUKB4+fMj58+fp1asX0dHRXLx4UdZ82ZycnEhOTmbChAnUq1cv1+dA8+bNZUqWN7V0fRk9ejS3bt3iwIEDij7io1OnTkRGRlKuXDmqVauW63tKSXNT2WPUgpb+NBoNkyZNYuTIkUWYDBo2bIiZmRldu3albdu2WFtb57qW0tLSCAsL49y5cxw7doyoqChFjasFQRCUTBz1IijekydPmDt3Lp07d6ZUqVIFvjY1NRVfX1+2bNlSROn+dvToUby8vOjRowe1a9cu8LUvXrzgyJEj7NixQ5bFn7NnzxZqZ5eenh4ODg44ODgwceLE/32wD5iZmTF58mRcXFzyfY29vT29evUCICQkhE2bNhVVPB3nz58nMDCQVatWAdCnTx8OHTqks+NPCdRyPQGcOHGCzZs3Y2RkRPXq1Rk7dizHjx9X3O8UsrqTrFq1irS0NOzs7Fi0aBEHDhxQZNacli9fzvr16zEzM+P+/fvcuHEDyOpgs2LFCsXsAPP396dJkyZMmTJFaqfdr18/Dh48qJhCimyBgYEYGBjkOxGkFImJiVSuXJmUlBTu3r1Lx44dATA2NiYtLU3WbO3atWPgwIH5fpeamZlhZmaGs7Mzn3/+OdHR0Wzbtq2IU2ZR03d/tufPn+Pk5ETTpk358ssvsbGxwc7OjoYNG8pa8JMXJWdV09/ph5YuXUpiYiJxcXEcOHAArVYrLf6vX79etsIPNY1RPrRo0SKeP38utX5OTU2Vuij9+uuviin8CA0NxcbGhn79+tG9e3dq167N3LlziYyMlP37dN++fTRq1Oijrytfvjw9evSgR48eREREFEGyj8tvQl1pe2zq1q3L+PHjGT9+PH5+fsycOZPo6GjOnTvHuXPnsLCw4Ndff5WlS41a7k/VOuYHpN391tbW2Nrasnz5cqKjo4mNjWXXrl3s3buXxYsXy9pmv1q1apQvXx5bW1vZMhRELX+nOb1+/ZrmzZtjaWlJYGAgjRs3xtTUlDp16nDlyhVZs+Xl119/JTMzE319fY4cOYKenh4TJ07k119/ZefOnYop/FDy9aTW8dT79++lxd+bN29KXejKly9PZGSkzOn+VqJECRo2bMjw4cPljlKgj3V92bt3r6K6vhQvXpw3b97Qpk0bqlatiomJiU6x3+7du2VM97cXL15Qo0YNDh48qKijXPOyc+dORo4cSd++fenatSsA+/fv548//mDRokUYGhoyceJE9u3bV+SFH8uXL8fd3b3A8ZOBgQHW1tZYW1szduxY/Pz8ijChIAiCuonCD0HxDh8+/NHXJCYmkpmZSalSpfDw8MDDw6MIkuk6d+5coc+ZNjc3Z8SIEbK1/CzMZMWkSZN4+PAh+/fvB6Bs2bL/41S5FWbHQVRUFMnJyVhZWWFra8uyZcuKIFluFStWxNfXl9atW/PFF19w/fp1RU4AquV6ypmlQ4cODBo0iKdPnyryd5qtUqVK1KlTBw8PDz777DNFZ8127NgxSpcujbOzM8uWLaNkyZLSDjAl7ErPptFoSExM1HlMq9USExNT6M/doqKWiSBzc3NCQkL4+eefycjIoHnz5pw9e5bAwEDZjyL5p0URlSpVYurUqf+jNAVT03d/thIlShAXF0dYWBivX7+md+/eZGZm8vDhQ6lbhVIoOWth/k79/f2Ji4vDzc1N1r/TDyl18V9tY5ScgoODqVu3LkOGDKF///5UqVKF9evX079/f8LCwuSOJ0lLS6NMmTLExsZy//59evbsCSijQCG/oo8XL15w+/ZtIGt3oIWFhfSc3N9XIP/RE//E69evOX78OD4+PgQHB5OZmQlA48aNefz4Mc+ePWPevHmy7FZVy/0pqHPMn5KSwpkzZ/Dx8cHPz4/U1FS0Wi3m5uZ0796dsLAwzp49y6pVq2Qt/Pj6668ZN24cPj4+tGjRItfxaHKP+9X0d5qtdOnSvHjxgqtXrxIbG0vTpk1JSkri3r17iunumFNERARNmzalc+fOrFq1inr16jFy5EiuXr0qa+eUnJR+Pal1PGVqakpYWBibNm0iNTUVZ2dnbt++TVBQEJUrV5Y7nmTYsGF4e3vz4sULzM3N5Y6Tp5xdX1q0aPHRri/Dhw+XvevLyZMngayjE6OionSek+M47/w0adKE+Ph4xRd9APz444/Url1b53jUb7/9lsDAQDZv3syOHTto0qQJ/v7+RZ6tMEc1bty4kejoaL755hsAWrdu/b+OJQiC8K8hCj+Ef4WBAwdy7949WVt+FWYSYtCgQYSHh0u7VOVqpVsYkZGRipqozs/EiRNlf++z/fzzz6SlpWFgYCDtTlAjJVxP2caMGSP9/GELyuxzk5Wib9++0s+lSpXi9evXhISEUKJECaytrT+620YOatkB1rJlS06dOsXo0aMBuH//PoMGDeLRo0e0a9dO5nS61DARBNCzZ0+WL1/Ozp07KVu2LO7u7sycOZPU1FQGDhwodzxJXFwcq1ev5u7du6SmpuZ6Xu6dP2r87re2tubChQsMHDgQjUZDmzZt+Prrr3n06BFdunSRNduH1JQ1Lz/88ANhYWGyd1L4kJIX/z9GSWOUnJTcRSmnqlWrEhQUxLfffotWq6Vly5bs3buXoKAgRZ6ZvXfvXubOnUtGRoZ0/vfMmTPp16+f3NE+KikpiWvXrilmkvqzzz4jICCAzMxMtFotFStWpEePHvTu3ZuaNWuSlJREr169FPd5lZNS7k/VOOZv3rw5SUlJaLVaDAwM6NChA71798bFxUVaUBs8eDA3b96UNefMmTPRarVMmTIl13NKOzopP0r5O83WtGlTTp48ybBhw9BoNLi5uTF16lSio6MV+1lqYGDAq1eviIqKku5L4uLiFNNJUS3XU0GUOJ7q0KEDmzZtYvny5RQvXpx27doxe/ZsEhMTdY4llFtYWBiZmZm0b9+eGjVqUKJECZ3CBLnvT0GdXV9+/PFHWf/7hTVixAgmTJjAnDlzaNGiBcbGxjrvf0Edq4taWFgYtWrVyvV4Zmam9PmUkJCgqMKanA4fPkxYWJhU+CEIgiAUnnJXnQXhH1LDZHVCQgLv37+XO8a/jpLe++zJiDt37rBo0SICAwMBcHR0ZNq0aTRo0EDOeIWmpN8pQEZGBitWrKBt27Y0bNiQoUOHEhwcjI2NDb/99puidiulp6czd+5c9u/fT2ZmJm5ubjRt2hQfHx/WrVsn+66vnNSyA2zGjBncuXOHs2fPAvDw4UMePnyIhYUF06ZNkzfcB9QwEQRZZ+iWLVuWhw8f0rt3b8qUKYODgwOOjo706dNH7niSGTNm4Ovrm+dnklInKD6ktO/+qVOnEhoayuvXr+nXrx+NGzdm3759mJuby96O/ENqyqomalv8/5DSxiig7C5KOQ0ZMoRZs2bh6+tLtWrVaNOmDd9++y2ZmZmK7FS1evVq+vXrh6urK8WKFeP27dusWrVKUYuV4eHhfPXVVzx48ICUlJRczyulkOLq1avo6+vj5uZG7969cXV11elUYWxsjKWlJbGxsTKmVBc1jfkTExOxsrKiV69edOvWLc9s9evXlz3z06dP831OiZ/9ajB9+nRevHhBVFQUXl5e1K9fHzMzMxo2bKjIsVStWrUICAhg/PjxaDQaXFxc8Pb2JiQkhObNm8sdD1DP9fQxSrumJk2ahL6+Pg8fPmTw4MGYmZlRv359atSooagxyoEDB6Sf79+/r/OcUu5P1dj1JbsQXemyi+j27NnDnj17dJ5TWoFijRo1uHfvHlOmTKFdu3ZotVpOnTolFYT4+Phw48aNjx5ZKwiCIKiPKPwQBEH4LwsNDWXQoEEkJSVJj126dImBAweya9cuWc7NVrvly5ezfv16zMzMuH//Pjdu3ADg5s2brFixgnnz5skbMIdVq1axd+9eKleuzLNnzwB4/PgxN2/eZNGiRfzwww8yJ/ybWnaAmZubc+TIEY4ePcrdu3fR19fH0tKSbt26Ubx4cbnj6VDDRFC2D8/IHjp0qExJ8nfhwgWKFy/OyJEjqVSpkiraqStd/fr18fPzIyEhQdoB9vnnn/PNN9/kaqkuNzVlVRO1Lf6rgVq6KPXt2xcLCwsePnxIhw4dMDY25pNPPqFz5864ubnJms3Ly4vJkyfrHPmi0WjIzMxEo9Eo7js02w8//JDvJL+jo2MRp8nf9OnT6d69O+XLl8/3Nd9//72iuukpnZrG/Pv27cv3OKVsM2fOLKI0+Tt9+rTcEf51KleunGtxcvz48QV+Fshp1KhRTJw4kRs3bmBtbU3r1q05fvw4BgYGOt1A5ZTX9aTVanW+p5RwPamNoaFhrm4/SixOUktnio9RYteXgIAA1q5dS3BwME5OTnTr1o2XL18yaNAguaNJlHTs0MdMnjxZOj7Nx8cHyPqsKlasGJMmTSIyMhJAUR11BEEQhP8OUfghCILwX7Zs2TKSkpLo37+/1Ao4uxp8+fLlsp6bqVbHjh2jdOnSODs7s2zZMkqWLMnJkyfp168f58+flzuejkOHDlGtWjWOHTuGra0tkHVe9dmzZ6WOFUqhph1gxsbGiupEkR8lTwRNmTIFGxsbhg0blmcL7ZyWLFlSRKkKVq5cOWrWrKmYiV61ioyMpGTJkpiZmUkTPACvXr2Sfo6OjgbIsx1sUVJTVrVS8uK/Wo0ePZpy5coRFRWl6C5KAK1ataJ58+ZERETw7t07OnfuTLFixeSORWpqKp9++int27dn4sSJ1KpVi1GjRjF//nx2794tHfUyY8YMuaPqCAkJoUaNGuzevRs3Nze2b99OYmIin3/+OfXr15c127Vr16Sfra2tiYiIICIiIs/XOjo6UqZMmaKK9q+gpjF/o0aN+Ouvv4iIiCAlJUXa6Z+YmEhgYGCuwgC55DzaMzo6Go1Gg5mZmYyJ/h1iY2PZu3cvwcHB1KlTBzc3N168eEHDhg3ljpZLu3btOHz4MI8ePaJZs2bo6+vTpUsXhg4dqpiuZI0aNeLXX38lNTVVumfu1asXbdq0YcKECfKGUzk1LPyrpTNFYSip64ufnx9ffPEFGRkZaDQatFotgYGBbNmyhWLFiuXatCKXM2fOyB2h0Nq0acO+ffvYsGEDERERZGRkYGlpyWeffYaNjQ2nTp1i4cKFovBDEAThX0gUfgjC/4cuXLjw0dckJCQUQZJ/p4CAAKysrJgzZ4702Ny5c7lx44bOBKxQeK9fv6Z58+ZYWloSGBhI48aNMTU1pU6dOly5ckXueDrevHmDk5MThoaG0mOGhoZUqVKFkJAQGZPlppYdYC9evGD+/PncvXs3Vxt1jUajqOIfJU8EHTt2jJSUFIYNG8axY8fyfZ1Go1FM4ccXX3zBggULOHLkCK6urhgZGek8n/M6E/Ln4eGBu7s7q1atolOnTvnunFdCe1o1ZVWzVq1a0apVK+nf3bp1kzGN+h08eJCaNWvqdMsaOnQoR44cYe/evYoq/vD29mbjxo3ExcXh5uZG8+bNuXr1Kj///LOsn6nbtm3j3LlzrFixgq5du9KjRw/GjRtH69atpeNSGjRooLMwrAQpKSlUrVqVcuXK0ahRI27dukXfvn1xcHDA19eX7777TrZsQ4YMKXSnFLmPpFHj/amaxvy//PILq1evljtGoZw7d4758+fz5MkTAKpXr86MGTNwdXWVOZk6/06joqIYPHgwb968Af7uTLFhwwbWr1+Pk5OTzAlzq1Onjs4xaUp473Nau3YtK1eulLo6JScnc/fuXUJDQzEyMmLkyJEyJ1QntSz8Azx//pzVq1cTEBAAgJOTE2PHjsXc3FzmZOq1cuVKDA0NWblyJSNGjADAzc2NPXv2sGXLFkW9/5A1RxkSEkKJEiWwtraWulMqjZWVFYsXL87zuXbt2hVxmr+lpqZ+9DVKKkwSBEFQG1H4ISje0qVLP/qanLtA5VKYXTLv3r373wcphOHDh390EvDDVpVy+NiOdEBqq6s0eR0/oYQjKdRyPX2odOnSvHjxgqtXrxIbG0vTpk1JSkri3r17VKhQQe54OmrVqsW1a9f4888/AYiPj2fPnj0EBgYq8pgfNewAmz59Ov7+/nne+Mn9OZUXpU4EjRs3Tjq/dezYsYr83X3I1taW4sWL89VXX+V6TgkL/2r57tdqtTrXT36TKEqYXFFL1sJMPj58+LAIkvxzSi2mU+sYBbJ2+bdr1w5nZ2fpMa1Wy/bt23nw4IFiCj82bdrE8uXLMTY2lh67f/8+f/75J0uWLOGbb76RMV3W4p6rqytHjx5l1apVdOjQgQEDBjBq1CjKlSsna7b8mJubc+vWLe7du4etrS0HDhygTp06hIWFkZiYKGs2MzMzne/6V69ekZmZibGxMXp6eiQkJGBsbKyIXfRquT/NSU1j/gMHDmBgYECfPn3YsWMHgwcP5sGDB1y6dInJkyfLHU/i7+/PmDFjyMjIkB57+PAhY8eOZdOmTbIfn6TGv9OFCxcSExPD8OHDWbduHZD1uZWWliYdUSY3FxcXXF1dWbBgAS4uLvm+TikF/3v37sXExISpU6cCYGRkxB9//MHnn3/Ovn37ZC/8UOt4Si0L/0+ePKFfv37ExMRI9yMPHz7kr7/+Ys+ePYorUFWLe/fu4ejoqFOY7ujoiK2tLdevX5cxma709HTmzp3L/v37yczMxM3NjaZNm+Lj48O6desoW7as3BF1BAQEcOPGDZ1uX9nGjRsnUyqws7OT7b8tCILw/wNR+CEo3tq1a1Vxcz179mxV5AT1nElY0I70nJTwO82pUaNGXLt2jTVr1tC7d28A/vjjD0JCQmjWrJms2dRyPX2oadOmnDx5kmHDhqHRaHBzc2Pq1KlER0fr7K5VggkTJjB+/Hi+/PJLNBoNV69e5erVq2i1WmkCQynUsgPsxo0blC5dmhkzZlCpUiX09PTkjpQvJU8E5byxHz9+vGw5/olvvvmG2NjYPJ+Te+Ef1PPdHxoamufPSqSWrDdu3CjU6+R+7/Myffp0rl69mudzcuZV2xjF29ubFStWSP/29fWlQYMGuV6npOMzdu3aRcWKFTl69KhUpDJhwgR8fX05fvy47IUf2bp06UKnTp3Ys2cPv/32G3v37sXT0xNPT09KliwpdzwdvXv3Zvny5Zw5c4Y2bdqwYcMGBg8eDECTJk1kzebn5yf9/Mcff/D999/z22+/0aJFC+n5cePGKaLjj1ruT3NS05g/OjoaR0dHZs6cyYULF2jVqhXfffcdHTt25MyZM7IvVGdbtWoVGRkZTJkyRefI1KVLl7Jy5Uq2bdsmaz41/p36+/vTpEkTpkyZIhV+9OvXj4MHD8re6Sfb69evpfH+69ev832dUr7/X7x4gZOTk87CpbW1NTY2Noro8Kq28VQ2tSz8L1myhDdv3vDJJ5/ozPedO3eOpUuXKqZzptqULl2ayMhIkpOTpcdiYmK4d++eoop/V61axd69e6lcubK0EfHx48fcvHmTRYsW8cMPP8ic8G/5dfvKvv7lLPwo7FyO0j6nBEEQ1EIUfgiK16NHD1V80cu9++SfUMuZhGrZkf6hsWPH4unpyfLly1m+fLn0uJ6eHqNGjZIvGOq5nj40ffp0Xrx4QVRUFMOHD6d+/fqYmZnRsGFD6VxdpXB3d8fb25s1a9Zw9+5d9PX1sbS0ZMSIEbRp00bueDrUsAMMwMLCgkqVKtG9e3e5o3yUmiaC3r59i56eHmXKlOH8+fOcP3+eli1bKqqdckREBBUrVmTZsmWKLPpR03d/QeLi4jAxMZE7RqEoJeuPP/4od4T/2I0bNyhTpoziiunUNkbx9PRk9+7dvHjxQmpJ/iE9PT2pCEAJnj17RrNmzXSKUcqXL0/dunUJCgqSMRkEBwcze/ZsHj58SM2aNZkzZw4DBw6kV69ebNmyhQ0bNrBjxw5GjRrFsGHDZM2a0+jRoylVqhRWVlY4ODgwYcIE1q1bR/Xq1XWOfZTbL7/8gr29vVT0AdC6dWvs7e3x9vbm008/lTGdeu5Pc1LTmL9EiRJSBzJra2sCAgJwdXWlfPnyiiqyvHXrFo0bN9YpnBk5ciRnzpzh1q1bMibLosa/U41Gk6v7kFarJSYmRjFHJm7dulVa2N26davMaT7O1NSUW7du8ezZM6kYKCoqipCQEEUsUKttPJVNLQv/ly5dombNmvz222/S79nNzY1OnToV6jiooqDGri9dunRh8+bNuLu7o9Fo8Pf3p0OHDsTHxzNkyBC540kOHTpEtWrVOHbsGLa2tkBW57+zZ89y9uxZecN94MCBA2i1WiwtLalbty76+spZBjx9+rTcEQRBEP7VNFolbJcUhAI8fvyYatWqyR3j/wt5nbGnlMkAtTl//jw//fQT4eHhANSsWZPJkyfTvn17WXP9m66nmJgYypcvL3cMVWvSpAkNGzZk+/btWFlZ4e7uzurVqxkwYAChoaGK2Vlz5swZJk6cyJgxY3B1dcXIyEjn+Vq1asmULDdnZ2fKlSvH8ePHpYmgzMxMOnXqxLt37/LdZV/Ubty4gZeXF99//z116tShR48e0s6P5cuX06FDB7kjAjBgwAD09PTYsWOH3FHylJqaqrrvyYyMDFasWEHbtm1p2LAhQ4cOJTg4GBsbG3777TdFHZ+lpqxq0rFjRypVqsSWLVvkjqJ6MTExxMXF0aFDB1q2bMns2bOl5zQaDWXLllVEoVK2Dh068ObNG7Zs2ULv3r355JNPGDx4MF988QXVqlXDx8dHtmxdu3bFyMiIGjVq8PDhQ5KTkzly5Ij0/Pv371mzZg07d+5UzPhETRo3bkzJkiU5evSotID28uVLunXrRkpKiuy/0zZt2uDs7IyTkxNOTk5UrVpV1jz/Nl5eXly6dInp06dTvHhxfvrpJ+zt7bl8+TIVK1ZUxPEZkHU8orm5OYcPH9Z5vGvXrrx8+VIx42g1mTBhAqdOncLV1ZWzZ89So0YNKlSowPXr12nXrh0rV66UO6Lq/Pzzz6xfvx5DQ0Nq1qxJRkYGDx8+JCMjA09PzzyPqBQ+buHChWzevBlTU1PevHmDiYkJWq1WWvifMWOG3BEBsLe3x9raOlcHosGDB3P79m3Zv08BrKysCt31RSmdf1JTU5k+fTrHjx/Xebx9+/b89NNPOscUysnGxgYnJyc2bNigM4c2ZMgQQkJCCA4OljuixN7enho1anDgwAFVFoMJgiAI/znllPoJQj7atWuHhYWFNBHk6OioioXrzMxMXrx4kevsdFDWImVoaCjffPMNYWFhuXYqajQa7ty5I1MyOHjwYKFf26NHj/9Zjv9Eq1ataNWqFbGxsejp6Slm0l+t11N+LVMjIiIA5e26f/jwIZs3byY4OBhra2s6depEcnKy4nb/qWEHGEDJkiUxMDBgxYoVOm31Qf7PqQ+lpqZSsWJFnRtrPT09KlasyMuXL2VMpmvp0qUkJiYSFxcn7QTp168f+/btY/369Yop/Pjiiy/48ssvmTNnDi4uLrmKfgo6B7woODg4YGdnJy1U2dvbK+raycvy5ctZv349ZmZm3L9/Xzqy5ObNm6xYsYJ58+bJGzAHJWfNq21uXjQaDWPHjv0fp/lnvvrqKyZOnIi3t7eiiun+SXt0pXzvly9fnvLly3P69GmMjY0VX5Dq5eXFrFmz+PTTT9FoNJw7d45z586h1WoZNGiQrNmePHnC4cOHqVatGo8fP851/Ejp0qWZNm2aorp9ZFPDuM/JyQk/Pz86duyIvb09Wq2WoKAg4uPjcXd3lzseDRo04OzZsxw8eBCNRoO5ubn03erk5KTY+xU1vPeQ1T1x+PDhlCxZkg4dOrBu3TouX74MQJ8+fWRO97cmTZpw7tw5Zs2aJXXO27dvH+Hh4XzyySfyhoM8j/PKi5LuT2bMmMGdO3eknegPHz7k4cOHWFhYMG3aNHnD5ePChQtUr16d6tWrs3TpUvz8/HBxcWHy5MmK6FI2YcIEHj9+zMmTJ7l37570ePv27RXRjVSN4ymAyZMnEx0dLS38v3//Hsj6vU6aNEnOaDosLS0JCgri6NGjdOnSBYDDhw8TFBQkdYCQmxq7vhgaGrJs2TImTZrEnTt30NfXp169elSvXl3uaDpq1arFtWvX+PPPPwGIj49nz549BAYGYmVlJXM6Xa6urjx48ECRfwtDhw4t1Os0Go3YrCAIgvAfEB0/BMXbvHkzgYGBBAQE8PbtW1VMBF25coVJkyZJ7VRzUtIkAMCnn35aYNtUOVu/FqZKPZvcVeqRkZGULFkSMzMzIiMjC3ytnIU/arye4ON/C3K//zmFhITw2WefkZSUhEajwc3NjZo1a7Jx40aWL18ue9eXnNSyA6xjx45ERUXl+7ySWlT37duX27dv89NPP+lMBH399dfY2tqye/dumRNmcXJyombNmvz+++90796dtLQ0fHx8GDp0KHfv3lXE+dRQ8LWvhO/TBQsWEBgYSGhoKFqtFgMDA2xtbaXP0yZNmiiuEKRt27YkJCSwfft2li1bxtWrVzl58iT9+vUjMzOTv/76S+6IEiVnVdMY5UNXr15lzJgxuQr/QN7rSs2/U4CAgADWrl1LcHAwTk5OdOvWjZcvX8peUPGhXbt24e3tTXR0NACVKlVi5MiRsuccNmwYQUFBlCtXjrdv3+Lg4MDGjRtlzVQYahn3PXnyhC+++IL79+/rPN64cWNWr16NqampTMl03bt3D39/f65du0ZAQABv3rzRuV9xdnamV69ecscE1PPeZ0tNTSU5OZnSpUvz4sULjh8/TrVq1RRR+JMtNDSU/v3762ye0Wq1GBoasnv3bho2bChjOv7Rop6S7k+SkpI4evSozpFE3bp1o3jx4nJHy+XgwYN88803zJ8/H1NTU+moXI1Gw8SJE2U/OjenyMhI6R6gQYMGitngpfbx1KNHjxS98H/y5Em+/PJLNBqNdA1lf2YtXbqUTp06yRkPUE+n32fPnhX6tdnHKsnN19eX8ePH53pcq9WybNkyRbz/2U6cOMGsWbOwt7enWbNmGBsb63w29OvXT7ZsH36ffnhsZva/ldSVRhAEQU1Exw9B8YYNGybt7Lp//740EXTx4kUOHTokTQQ5OzuzcOFCecP+X/Pnz+ft27d5Pqe0Wqt79+5RsWJFli1bpqhz3iGrLV3OQWlwcDAajYZatWqh0WiIiIjAyMhIEZNqHh4euLu7s2rVKjp16qTYhUo1Xk8AZmZm0u9Uq9WSmppKbGwsxsbGWFtby5xO1+LFi0lLS2POnDnS2e62trbo6enh7e2tiL/XbGrZAfb8+XOqVavGtm3bqFSpkiJ3LGTz8vLiyy+/ZNq0aXz33XfA3xNBn332mZzRdKSlpVGmTBliY2O5f/8+PXv2BJT3HaWUCZ78fPvtt0DWTp9r167h7+9PQEAAa9as4bfffpMKQZydnfOcIJLD69evad68OZaWlgQGBtK4cWNMTU2pU6cOV65ckTueDiVn7dKli/RZlJ6ezp9//knJkiVp0qQJGo2GgIAAMjMzFXUmdbbZs2eTkJCQ53Nyfgbk/K6HrLPHMzMzMTY2Rk9Pj4SEBIyNjbGxsZEtY378/Pz44osvyMjIkCYqAwMD2bJlC8WKFaN///5yR5QMGDCAAQMGEBMTg4GBgWK60i1evBhvb28ePXpEjRo1FLW4VxC1jPuqVq3KoUOHuHjxIpGRkejp6VG3bl2aNWsmdzQd9erVo169egwePBjI6u6X/d16+fJlDh8+rJjCD7W899kMDQ2lYlRzc3M8PT1lTpSblZUVu3fvZtmyZQQEBKCnp4etrS0TJkyQvegDkHZ4A1y/fp0ZM2YwfPhw2rVrh56eHj4+PuzatYsNGzbImDI3Y2NjRXV2KcjGjRvR19fH1NSUEydOoK+vz6JFi5gzZw4HDx5U1HdDrVq1FFPskZOax1NRUVE8efKEjh07ArBmzRrc3NyoW7euzMn+1qFDB+bNm8eSJUuIjY0FwMTEhLFjxypm0V8tnX7d3NwK9Tq551Fzcnd3x9vbmzVr1ugU040YMUJx3b4mTpyIRqPBz88PPz+/XM/LWfjx/fffSz+/evWKX375BXt7e9q2bYuenp7UUUlJ3UgFQRDURBR+CKpiaWmJpaWltCMtIiKCa9euce3aNalVqRI8evRINYuUdevWxdjYGAcHB7mj5LJr1y7pZ29vb+7fv8/u3bupU6cOkFW0MmDAAEXcbGu1Wp3FkvwWTpS0qKqW6wnI8ybl8ePHDBw4UDGTv9lu3ryJo6Mj/fv3lyaB27dvj729PTdv3pQ33AfMzc05cuQIx44dk3bVKHEHmLOzMzExMZibm8sd5aPUMBEEWQtAQUFBfPvtt2i1Wlq2bMnevXsJCgpS1CTgmTNn5I5QKKVKlaJNmzbSZE9CQgKBgYHSZ+ratWsVU/iRvdP36tWrxMbG0rRpU5KSkrh37x4VKlSQO54OJWf9+eefpZ9/+OEHypYty5EjR6SjPl69ekW3bt3yPPJPbkotpsv5Xf/HH3/w/fff89tvv9GiRQvp+XHjxuU6AkQJVq5ciaGhIStXrmTEiBFA1mT2nj172LJli6yFHxcuXCj0a+U8PqtMmTLMnDnzH/3fZGRkUKxYsf9RosJR07hPT08PR0dHSpYsiUajUcRC+sfUqVOHOnXqMGDAACCrSFkplP7eq/FYEsgq/lizZo3cMfKUs/PAl19+ia2trc4RFA0bNiQgIIAFCxawd+9eOSIC0L9/f5ycnJg8efJHv3+U0o0w2+PHj3F0dMTV1ZW5c+fSqFEjPDw8OHDgAAEBAXLHA7LmTebNm0dwcHCucZ4Srie1jqcCAgIYMWIEzZs3x8XFBa1Wy6+//oq3tzfr1q1T1Jxl37596dGjB+Hh4ejp6VG7dm1FdXn8+uuvCQwM5Ny5c4o+Qq0w86PFixeX/b7vQ66urri6usod46OUdJTTh3IWI44ePZrq1auzdetWaTPq4MGD6dy5MydOnKBz585yxRQEQVAtUfghqFr2RJCSdtEB2NnZkZSUpIpFylmzZuHp6cnMmTPzPOddzgngnLZt24a1tbVU9AFZO8Ksra3ZunUrI0eOlDGdbitXJbV1/SeUej3lp1q1ari4uODt7U2PHj3kjiMpXrw4L1680LmJTUlJ4fHjx5QoUULGZLmtXr2a2rVr8+mnn+o8vmnTJuLj4xWzUN2tWze+++47Ro4cScuWLXN9Tsm5U+FDjx8/VvxEEMCQIUOYNWsWvr6+VKtWjTZt2vDtt9+SmZnJ8OHD5Y6nI3vnV/b3kRJ3fn2oZMmStG7dmtatWwOQnJwsc6K/NW3alJMnTzJs2DCpNf3UqVOJjo5W1LUE6sl64MABGjVqJBV9AFSsWBFLS0v279/P9OnTZUyXmxqK6bJ3fWUvUgC0bt0ae3t7vL29c31vye3evXs4OjrSqlUr6TFHR0dsbW25fv26jMlg+PDhhSrukXuxytXVlb59+9KrVy9q1KhR4GufPXvG0aNH2bVrl+zHU6lp3Ld7924WL14sHfNUqlQppk6dqojP06VLl+Z6TKPRoKenR8mSJalTpw4uLi4f/dsoSkp/7wu74UDujQkXLlzA1NQUKyurjxaqKWVuArIW/ytXriy1ooesYrSYmBhevHgha7YbN25IxzfduHEj39cppfAzJwMDA9LS0nj8+DHPnj2jQ4cOALx8+VIR1xXAvHnzuHr1ap7PyX09fUhN46nly5eTlJSEpaUlkNWh8tNPP2Xnzp2sWLGCbdu2yZYtNTWVYsWKUaxYMVJTU6XHc96PZj+uhPt+tXT6vX37tvTzX3/9xcSJE5k9ezbu7u5SF6UffvjhHxcG/y+tXr063+cMDQ2pWLEiLi4uVKxYsQhT5U3Oa+afuHz5Mg0aNNDpQK6vr0+ZMmX+UQG7IAiC8DdR+CEoXn6L0MWKFZMmgfr376+oSaC5c+fSv39/vLy8aNWqFcbGxjrPK2FyLduzZ89IT0/njz/+4I8//tB5Tu4J4JySk5O5desWDx48oHbt2kDWJPutW7cUN2GRvZju4eGh8/imTZtISEhg3LhxMiVT5/UEWefn5pSZmcnz58+5ePGi1FVBKdq2bcvBgwelozNCQkLo0qUL0dHRiihQiYmJkRahV69eTcuWLWncuLH0fEZGBocPHyYqKkoxhR9Tp06VWlSeP38+1/NK+kzN7kK0bds2Re+k7du3LxYWFjx8+JAOHTpgbGzMJ598QufOnQvdcrUoKH3n15QpU/J8PPsztW7dunTu3JmyZcsWbbACTJ8+nRcvXhAVFYWXlxf169fHzMyMhg0bMnHiRLnj6VBLVj09Pa5fv87ly5dp3rw5AOfOnePGjRuKWaTISQ3FdG/fviU1NZW3b99Srlw5IGvRJywsTJFdVEqXLk1kZKROkVdMTAz37t2T8stF6UdmZevYsSPr1q1j7dq11KlTBzs7O2rVqkXp0qXJyMjgzZs3vHjxgmvXrvHo0SP09PQUcXSB0sd92f7880+pK0WpUqXQarXExcUxZ84cypcvT7t27WTNt3bt2o/e09WtW5ctW7boFNnJSenvvVqOJcnOtGrVqgIL1ZQ0NwFZmyZCQ0P57LPPaNOmDZmZmfj6+vL48WPZjyL98ccfsbCwkH5WE0tLS4KCgvD09ESj0dC6dWsWLFjAvXv3FHOMwq1btyhZsiTz58+nXr16GBgYyB0pX2oaT929e5emTZtKXXQMDQ2ZOXMmYWFhsm+usrOzk452trOzy/d1Svucgtydfh88eCAVgsjd6Tdn17bFixfTpEkTnbHdgAED8PHxYcmSJYq5/levXp3v91R2IaCxsTFr166VZa4ivyKlvCihSAmgQoUKBAcHs2LFCtzd3cnMzOT48eOEhIRQtWpVueMJgiCokkartHJkQfiAlZVVgc9rNBqMjIzYuXNnoduZ/q9t3bqVH374Id/B4N27d4s4Uf7atGnD8+fPMTY2pmzZsrkyK6XN/pQpUzh27Bj6+vrUqlULrVZLZGQkmZmZ9OzZkx9++EHWfDkX09u2bUvLli11zizMyMhgwoQJREVFybrzU43XE+Tfqlir1dK0aVN27NhRxInyFxcXx4gRI3LtrrK2tmbt2rWyT1bv3LlT+tvMuUPtQxUqVFBMdf2QIUMKfF5JOxlatWpF1apVdY6qUpuIiAid7kpyGjx4MAEBAYwaNYpJkyaRmprKTz/9xM6dO3FwR5J+RQABAABJREFUcJD9vS/MZ2qFChXYtWuXItrp5icmJkb2z6bCUmLWuXPnsmvXLmmiT6vVkpycjFarxdPTU3EdP6ysrNBoNPl+ByhhnDpy5Ej8/PwoU6YM9vb2aLVagoKCiI+PlybelWThwoVs3rwZU1NT3rx5g4mJCVqtlvj4eIYMGcKMGTPkjqgKoaGhrFmzhlOnTpGenq7z95k9bWFkZESnTp3w9PSkXr16ckWVKH3cl613796Ehoby888/S0fP+fj4MHXqVBo1aiTrsRSQ1ZY+r8+jzMxMEhISCAoK4u3bt/Tr108qYJGbWt57gJ49e2JkZJRrfNq/f38yMjJkff/btm2Li4sL8+bNo23btgW+VilzE5C1Q3n06NGkpKRIf7tarZZSpUqxceNGbG1tZU6YZcOGDVIHKjW4du0aI0eOJCkpCVdXV7y9vZkxYwa+vr5s27bto2PvotC+fXuqVq3Kxo0b5Y7yUWoaTzVt2pTKlStz5MgRncc9PDx48eIFQUFBMiXLGju7u7uzevXqj/4Nyl2kkp9nz57p/Lt06dKUKlVKpjS52draYmpqyokTJ6SChISEBDw8PHj37h3BwcEyJ8yyadMmfvnlF8qVK8cnn3wCwOnTp6UxyvPnzzl58iROTk5s3bq1yPM1aNBAurYLmtNVUpHStm3bWLBgQa5xoFar5ccff5QKbAVBEITCE4UfguIdOHAgz8ezJ4FOnz7N1atXadu2Lb/++msRp8tby5YtefPmDTVq1KBixYq5Bi9yL1TlZG9vT9WqVdm3b59iqn3z8u7dO7766iud80oh6yZw/vz5su+oVctiuhqvJ8h7cdXIyAgbGxvmzZtHrVq1ZEiVt8TEREqUKMHly5e5c+cO+vr61KtXT9oFLreMjAy6du3KgwcPpIW/D5UpU4YpU6bQt29fGRKq26ZNm1iyZAl9+vTBwcGBUqVK6exkUUqL6ujoaBYsWEBERAQpKSnS30FiYiKxsbGKmQRo2rQpVlZWuYq7Bg8eTFhYGNeuXZMpWZb8Wr1mf6ZeuHCBiIgIunTpws8//1zE6fIXHx/P1q1bCQgIQKPR4OjoyODBgxU1+ZdNDVlTUlJYuHAhe/fuJT09HcjaQfXZZ5/x5Zdfoq+vrCaLaiime/LkCV988QX379/Xebxx48asXr1aamGvFKmpqUyfPp3jx4/rPN6+fXt++umnXN3/hIIlJCRw+fJlwsLCePPmDQCmpqZYW1vj4OAg+7g/L0od92Wzs7PD1tY21/U9ZMgQgoODCQkJkSlZ4cTExNCpUyeMjY05e/as3HEA5Y/5c7K1taVy5cocP35c51iSTp068eLFC8W//0r1/PlzduzYQVRUFHp6etStW5fBgwcrquinSZMm1KpVi3379skdpdDevXvHy5cvsbS0RKPREBwcjJmZmdTFRG5Hjx5l1qxZbN68WfEFNWoaT40ePZpz587h4uJCy5YtSU9Px8/Pj2vXrtGqVSvWrl0rW7anT59ibGxM+fLlefr0aYGvrVKlShGlKlhQUBCLFy/G29ubMmXKSIXf2WrUqMGRI0cU07Fm0KBBBAUFUb16dVq1akVmZiYXLlzg8ePHODs7s3nzZrkjAvDdd9/h5+fHiRMnpPHo+/fv8fDwoGPHjnz33Xf06tWLhw8fEhgYWOT51FqkdPz4cTZt2kRUVBQajQZLS0tGjRqlc4ymIAiCUHii8ENQvczMTNq1a0dCQgJXrlyROw6QdaZ3zZo1Zd85VRhTpkwhLCyMQ4cO6SxOKtWDBw+IjIyUJlaUsoP637KYrsTrSW3c3Nyws7PL86xypdBqtWRkZGBtbY2bmxsrV66UntPT01Pc8Ukf7k75kJLa2H84oZKTknZVjB8/nlOnTuX5XM2aNTlx4kQRJ8qbknd+FUZSUpLUPl8pHXTevn3LwIEDiYqKkr6rNBoNtWrVYseOHbIfS5GTkrOmpqbmKphNTEyUjqCoUaMGxYsXlyndv0NmZiYXL17UGfc1a9ZM7lgFevTokc4CcPXq1eWOpKOgo7w0Gg2+vr5FmObfYeHChfTs2ZP69evLHaVAzZs3p3Tp0hw/flw6Qz174T8+Pp5Lly7JnPDjvLy8uHr1Krdu3ZI7CqCOMX+2nj17EhoaiqOjo86xJDdu3MDa2lqx8xYpKSlERkZSu3ZtRWxSWblyJc7Oztjb2ysiT2EMHDiQly9f4uPjo5rMkHXcY3bRr4ODA02bNpU7kmTo0KGEhoYSFxeHsbGxTjGiRqPJ82hSOallPBUREcHAgQOJjY3V6aJTunRpduzYgaWlpcwJ1ePevXv069eP5ORkNm/ejLOzc64iAI1Gw48//qiIo8kgq+Pg8OHDpYLfbFWqVGHDhg3UrFlTnmAfaNKkCba2trkKUYYNG8bt27elrkUXL17k9u3bRZ5PLUVKV65coUmTJqr6XhIEQVATZW0/E4T/gJ6eHrVr15b9bMKcunXrxrlz54iPj1fUjtS82Nvbc/r0aXr27EmzZs1ynfM+efJkmZJlHUPj7OyMo6MjTk5OVKtWjdq1a1O7dm3ZMuWnWLFiHDt2TFWL6XlR4vUE8M0332BtbS2dS5pt0aJFxMbGsmDBApmS5ZaQkMCrV6/kjlEgjUaDvr6+ToV/fHw8qampitqhlu1jC1VKKaYAZRWhFMTf3x9zc3NWr17NwIED+eWXX4iJiWHGjBl07txZ7ngSR0dHzp07x4gRI3R2fkVGRqpi94exsTENGjRQ1Gfq0qVLiYyMpGHDhnTr1g2AQ4cOcffuXZYtW8a8efNkTvg3JWdt2rQpdnZ2ODk54eTkRJMmTShRooQiWpAXRmZmJkeOHNHppNK5c2dpQVgOgwcPlsZ92ROBrVq1Uuy1nte52ebm5pibm+d6jVImNQuaAFbDOFWJNm/ezJYtW6hfvz49e/aka9euihxLtWjRAh8fH0aPHi0t8hw4cIDHjx/j4eEhb7hCiomJyXWvKic1jPmzffXVV4wePRp/f3+pW1r2sSQzZ86UOd3fEhISmDVrFp9++ik2Njb07NmTJ0+eYGFhwZYtW2Tf9PHbb7/x22+/YWBggK2tLU5OToovBLG0tOT69eu0bt2aRo0aYWJiorPhZ8mSJTKmyy0jI4Np06bl6qDl4eHB4sWLZR2nZPP395d+TkxMJDExUfq3Er5L1TaeylanTh0OHz7Mjh07CA0NRavV0qBBAwYOHKgztlKCPXv20LhxYywtLZk2bRp+fn64uLiwYMECRXQl27BhA0lJSTg5OekUIbds2ZJ58+axY8cONm7cyIkTJxRT+NGgQQP+/PNPDh8+rNNFqWvXror6fDUyMiIoKIjz589L15Sfnx9BQUEYGxtz584dAgMDZdugkLOYw9DQkIoVK+b5uuPHj8ta+DFs2DAMDQ2l79Ls+2klvdeCIAhqJjp+CKqXmZmJu7s7SUlJillYWbFiBZs2baJUqVLY2dnlmqBS0s11zgWKD8/R1mg0sp7zPmbMGIKCgnj37h0ajQZzc3NpcsXR0VH2iZ//RFxcHCYmJnLHyJeSrqfw8HDevn0LZLWhbtq0KRMnTpSez8jIYN68eTx79izX2dpy2rFjB4sWLWL8+PE4ODhgYmKiM0GlpGNpAI4cOYK3tzcPHjzAzc2Ntm3bcv/+faZPny53NEl+C6nFixenQoUKijrvWy1sbGxo1qwZ69ato3///vTv358ePXowdOhQnj17pphd3/+GnV+dOnXizZs3OpPEcnJxccHAwIATJ05IHSmSk5Pp2LEjaWlpXLx4UeaEf1Ny1gULFhAYGChNTOdcBFL6xFVycjJeXl4EBQXpdFJp2rQp69evl21htXv37ty/f1/n9+ns7IyTk5MiF9UKOjc7JyUVKOYc22m1WlJTUwkJCWH79u0sX76cFi1ayJhOnWbPns3p06d5/fo1Go2GYsWK4eLiQs+ePWnbtq1iWqg/ffqUTz/9lLdv3+b6Pt23b5/s91V5FVJBVsaEhAT279/Pzz//jJ2dHXv27CnidHlT25j/+fPn7Ny5U2fXv9KOJZk9eza///67dB+ycOFCSpUqRXx8PB4eHrJ3V3n//j3Xrl2T/ic0NJTMzExFjwEKKkiVe74nL97e3ixfvhxjY2OpK8WVK1dITk5m0qRJjBw5UuaEfHRM7+TkVERJ8qa28ZTabNy4kcWLFzN79mxMTEyYMmUKkHU9eXp68tVXX8mcENzd3UlISODs2bPSPVTOI0BSU1Np3bo1+vr6iulKqRY//fQTmzZtQqPRSPdMycnJQNZxNdWrV+eHH35QxHeWu7s7mzZt0hnj3b59mx9++IGgoCBZP/99fX11vkvVdj8tCIKgdKLwQ1C8/AahmZmZJCYmcvDgQc6dO4erqyve3t5FnC5varq5/vrrrwvclfDjjz8WYZq83bt3T9qdFBAQwJs3b3IVgvTq1UvumJL4+Hh++eUXIiIiSElJkRZVEhMTCQ8Pl7VIQU3Xk4+Pj3QTnV2I9CGtVkuVKlU4ffp0UcfLl1qO+oCsnfPZE6sajQY3NzfMzc3ZsWMH48ePZ8yYMTInzJKRkSH9nHOhatKkSfz000+0bt1axnQQGRlZ6NcqZRGgTZs2pKWlsW/fPtavX8+jR4+YN28eAwYMICYmRlHFVNHR0ezcuZO7d+8qbudXfu999mfqgQMH2LlzJ87OzmzZsqWI0+XN1tYWe3v7XHk+++wzbty4QXBwsEzJclND1vj4eK5du4a/vz8BAQHcuXNHZxHI2dmZ8ePHyx1TR/aEZaVKlaSjiE6dOsXLly/5/PPPmTZtmmzZ4uLidBbV7t69m+eimhJalP+T7i5KOkM7LxMmTCApKYl169bJHUWVtFot/v7+nDhxglOnTklFIKVLl8bDw4NBgwZRt25duWPy8uVLvL29CQgIQE9PD1tbW0aMGCF70QcUvpBq0aJFdO3a9X+cpnDUNOZXi9atW6PRaPj999+ZMWMGt2/fxs/Pjx49ehAXF6e4IzTi4+MJDAyUxgC3b98mPT0dQ0NDQkJC5I4HwKpVqwqc7xk3blwRpvm49u3b8/btW/bv3y99Nj169IhevXpRvnx5/vzzT5kTqoNaxlNLly6lbt26dOvWrcBFco1Gw6RJk4owWf46duxIdHQ069evZ/v27Zw5c4atW7cyduxYjI2N8z1OtSjZ2dnh4ODAhg0bpMcmTJiAnZ0dXl5eQNbxaf7+/ty8eVOumDqSkpLYuHEjwcHBOvOokPX+K+VeOj09naVLl7Jt2zbS0tKArA1Jffv2Zdq0aXh7exMYGMjPP/+cb7eNomJlZUXFihXZsGEDZcuWZdmyZRw6dIjMzExFzaPGx8cTEBCgcz+dkZGBgYEBdnZ2bNu2Te6IgiAIqiMKPwTFK2hCBbIm2gwNDdmxYwc2NjZFmCx/Sr+5VvtZehERETqFIK9evVJUMc0333zDgQMHgKwblJwfs6VKlSIgIECuaKq7nry8vAgPD+fly5cYGhpStmxZ6Tk9PT3KlSvHuHHjaNu2rXwhP/CxhSAlLf506dKFV69esWvXLjw8PHB3d2fixIkMHDgQExMTxdwI5ufrr78mLCxMut7kosZd3wsXLmTz5s2MGzcOGxsbRo0aJX02NGjQgP3798uWLTU19R9/P2VkZOi0rS4qhXnvNRoNa9euxcXFpQgSfVy3bt2Iiopi06ZN0nnpAQEBeHp6UqdOHQ4ePChvwBzUlDVbQkICgYGB0kT77du3FTOhmq1NmzakpKRw/PhxypQpA8Dbt2/p3LkzhoaGnD17Vt6AOSQkJBAQECCN+W7dukVGRoYixn0fOzc7JzlbKX+MVqtl8ODB3Llzh+vXr8sdR9USEhL4888/Wb58OdHR0dLj+vr6LF68mE6dOsmYTtk+Nn62sLBg+PDhuY59lJOaxvxqYWNjQ8uWLfnll1+k4169vb0ZOXIkV69eVUTBZ0GSkpIICgrC399fMYvUz549w8jIKFdnl4cPH5KUlKS4I+psbGxwdHRk48aNOo97enoSEBCgmDFVQEAAa9euJTg4GCcnJ7p168bLly8V9RmVk1LHUzm7UOQ3V6WEbsQ5ZR/1uG7dOlxcXKhZsybbt29X1OdUs2bNqFixIkeOHMn3NV26dOH9+/f4+fkVYbL8TZs2jaNHj5LXMpWS3v9sKSkpPHz4kIyMDKpXr07JkiXljpTL999/z44dOzAxMSEjI4PExERMTEwYNWoUQ4cOVeyaQGJios799K5du+SOJAiCoDr6cgcQhI+pXLlyrsc0Gg36+vqYmJhQp04dhg4dSqNGjWRI97d9+/bh5OREtWrVFLez80M5z9JTY8vHOnXqUKdOHQYMGABkTVooiZ+fH+XKlWPOnDlMmTKF77//nufPn7Ny5UrZi37Ucj1ly96h0LZtW1xcXJg3b57MiT5OTZO8Dx8+xNnZmdq1a0uP1a1bl0aNGslaoPShD9t/Z2Zm8vz5c65fv87z589lSvW3wtbQKqnWdsqUKWg0GmxsbHB1daV3797s27ePMmXKMGPGDFmzubq60rdvX3r27EnNmjULfO2zZ884evQou3bt4q+//iqagDnk957m/Ez18vJSTNEHZLWgnT17NkOGDKFGjRpA1meBVqulX79+MqfTpaas2UqWLEnr1q2lTkTZrX+V5PXr1zg4OEhFHwDlypWjfv36BAYGypgst5IlS+Lq6oqrqyuQtaimlOKE/Io54uPjSU1NVdTxCdn69++v8++MjAxevXpFdHQ0FhYWMqXK25MnT7h58yYpKSm5nlPKefSQNfF/5swZfHx88PPzIzU1Fa1Wi7m5Od27dycsLIyzZ8+yatUq2Qs/QkJC2Lx5M1FRURQrVoy6devi5eWliG4keRUb57xHMTY2liFVwdQ05leL8uXLExkZydGjR0lMTMTJyYno6Ghu3rxJpUqV5I6no6Di0/r16+Pv70/jxo1ln2Nxc3PD3d2dVatW6Tz+7bff8ujRI8Us+marWLEid+/e5d27d9Kmj5iYGO7evYuZmZm84f4vPz8/vvjiCzIyMqSNPoGBgWzZsoVixYrl+q5VAqWOp3r06IG1tbX0c0GblJSiRIkSxMXFERYWxuvXr+nduzeZmZk8fPhQZ2wtJysrK/z9/bl8+TLNmzfP9fzZs2cJDw9X1AaqixcvoqenR9++falXrx76+spZskpNTaVYsWIUK1ZMmpvSaDQ6cxXZj8v9mZ/TzJkzqVKlCosXL0ar1eLo6MiqVat0NtQpwbNnz3I9lj3vP3ToUNLS0hRzdKIgCIJaiI4fgvBfkl2dbm5uLhVTODo6KqJ17ofUeJbe0KFD833O0NCQihUr0q5dO0XcuFhbW9OiRQvWrl1L7969+fzzz+ncuTP9+/fn/fv3+Pj4yB3xXyUiIoI6derIHUOV2rZtS0pKCocPH6Zly5a4u7szefJk+vTpQ7ly5fD19ZU7IlBwVwUrKyvZO378W7x9+xYjIyMSEhIwNTWVLcfcuXPZs2cPWq2WOnXqYGdnR61atShdujQZGRm8efOGFy9ecO3aNR49eoSenh59+vRhzpw5smVWm2XLlrFhwwbS09OBrA5KgwYN4ttvv5U5WW5qyOrm5pbvc4aGhpiamtK+fXuGDBlShKny17FjR169esWBAweoXr06AFFRUfTq1YtKlSpx/PhxmRNmdU/LT/a4z83NrdAdl4rCkSNH8Pb25sGDB7i5udG2bVvu378vHammBPnt7NbT02PevHl8+umnRZwob7///jvz5s3TOeotJyXt+mzSpAlJSUnS/ZSbmxu9e/fGxcVFWsAaPHgwN2/elHUXsI+PD1OnTkWr1eoULerr67N69Wo++eQT2bIBvHr16h+3RI+NjVXMIpvw3/Hdd9/xxx9/oNFo0NPT48SJE8yfPx8/Pz+GDx8uHQOqBB/rpAlZRQzr16+nXr16RZQqy86dOzlx4gQA/v7+lCtXDktLS+n5zMxMbty4gYGBgSIW/3NavHgxGzZsoGLFitLczpkzZ3j9+rXsx9Fl+/TTT4mIiGDlypWMGDECd3d3PvvsM0aOHIm5ubkixlHZ1DSeCggIwNbWVlHzkHkZMWIEFy5coESJEiQmJrJr1y527tzJkSNH6NKlC4sXL5Y7In/++ScTJkygRIkSfP755zRv3pzy5csTHR2Nn58fO3fuJCUlhbVr19KqVSu54wLQokUL6tSpo8hjPRo0aCAV0BV0rSihw+uePXtyPXbq1CkuXLiAvr4+Y8eOlYrTlbKR4mPfp/r6+nzyyScsWLCA0qVLF2EyQRAE9RKFH4Li/fnnn7i7u6Onp1fo/5vz588X+eA1NDRUOo/u2rVrvH37VioEyS6myO4IoiRqOUsveyBY0EeWRqNh3rx59OnTpwiT5ebi4kLx4sU5duwYP/74IwkJCfz44490796dZ8+ecePGDdmyqeV6+lB0dDQLFiwgIiJC57zPxMREYmNjZb+5yqmgG0EDAwNpAXDy5MmyT2p4e3uzfPly9PX1ycjIkP63Vqtl7NixsneoyZbfQlXlypVZtmwZdnZ2RZxI/XJOXuQ0YMAAXr58KfsxP6GhoaxZs4ZTp06Rnp6uMxGQff0bGRnRqVMnPD09i3xCPdutW7ekXWqFpZRitdevX3P9+nWp84vSdtLmpPSshR2jTJo0iZEjRxZhsrytXbuWpUuXYmxsLB2hExgYSHJyMhMnTmTUqFEyJ9SdAMz+vX7472LFirFixQrc3d3lCZnDoUOHpAIPjUaDm5sb5ubm7Nixg/HjxzNmzBiZE2bJq1DSyMgIa2trRd2jdOrUicjISMqVK0e1atVy7frcuXOnTMlys7KywsrKil69etGtW7c8d1F+//33REdHs3r16qIP+H917NiRqKgounTpQrt27dDT0+PUqVMcPnyYunXrcvToUdmyQVbhfMeOHenVqxfOzs75Ht+Wnp7O9evXOXr0KIcPH5Z10VpNY/5jx47h6OiomI4J+YmNjWXu3LlERUXx+eef06VLF3744QeeP3/OkiVLZP895vTTTz+xd+9eNBoNjo6OAFy9epXMzEw++eQTnj59SkhICK6urqxZs6ZIs718+ZIOHTqQlJRU4PikXbt2ue4F5JacnMzw4cMJCAjQyW5tbc3WrVspUaKEzAnB1tYWR0dHNmzYoHNUyWeffcb169cJCQmRO6JETeMpZ2dnLCwsFHmUY05hYWEMHz6c169f069fP+bMmcPMmTO5cOEC27dvV8zxftnHfOR3fI6np6eiipOXLVvGwYMH8fHxUdyxKR8eSVQQubuBFXRkEqDznFIKqfv27UtERAQJCQmYmJgAEBcXh76+PmXLluX9+/ekpaXx6aef8v3338ucVhAEQR1E4YegeA0bNqRSpUp069YNd3d3GjVqlGvROiMjg+DgYC5duoSPjw9RUVGyLwSHh4dz9epVqRDk9evXaDQaLCwsOHPmjKzZCqLUs/TOnTvHlClTaNWqFZ07dway2qtevHiRb7/9lpSUFBYuXEitWrU4fPiwrFm/+eYbDh48yOjRo6lXrx6TJk3C2NiY5ORkatasKesOELVeT+PHj+fUqVN5PlezZk1pR5MStGzZkri4uFzHk+Sk0Wjw9PTkq6++KsJkuWm1WpYsWcK2bdukVurFixdn4MCBTJs27R8VCP0vPX36NNdjxsbGimyjr2QHDx7k6tWrQNbiX+XKlXF2dpaez8zM5NSpU9IuQCVISEjg8uXLhIWF8ebNGwBMTU2xtrbGwcFB9slfKysr7O3t6dWrF25ubvn+TUZHR3P58mWOHj3KpUuXZP9MVZvIyEgiIyMpVqwYderUoWrVqnJH0hEUFMTIkSPp27cvXbt2BWD//v388ccfLFq0CENDQyZOnIiZmRknT56UOW3W9/xXX33FsWPHdB5v27YtK1euVERr5UOHDvH9999jaWlJhw4dgKyFy/DwcMaMGcPbt2/ZvHkz1tbW/P777zKnzTon/dWrV+zatQsPDw/c3d2ZOHEiAwcOxMTERPZiOrWxt7fHzMyMgwcPKvKIj5xu376tmCMSC2Jra0vdunXZv3+/zuO9evUiIiJC1m4kAOvXr+eXX34hOTkZExMTGjZsmGe3rxs3bpCcnIyxsTFffPEFI0aMkC2zmsb8Dg4OWFhYcOTIEVlz/CdSU1MVVfCRbfHixezbt48jR45I3WqePXtGjx49GDZsGGPGjKFLly68fPkSf3//Is93+fJlnjx5wsyZM2nYsKF0TC5kdXkqX748LVq0oHjx4kWe7WMyMzP5888/CQgIQE9PDzs7O9q3b6+YVv8uLi4YGhri4+ND48aNcXd3Z968eXTu3BlDQ0POnTsnd0SJmsZT7dq1o0yZMvzxxx+y5igMrVZLQkICpUqVArLuVSpVqiT7vemHjh49yubNm7l9+zZarRY9PT0aN27MsGHDaN++vdzxdKxYsYIdO3ZgaGiItbU1JUqU0ClSWLJkiWzZnj59Ks0/5TU3lZPchT//pMOkUjZ6Hjp0iJkzZ7Jq1SrpOKpTp04xZcoUli5dioODg3SPff78eTmjCoIgqIYo/BAULyQkhDlz5nDnzh00Gg0GBgZUq1YNExMTMjMzef36NW/evJHOU7axseG7775T3A7wyMhI/P39uXbtGj///LPccSR5naWXzdDQkDJlyijiBvuzzz4jJiZGZ7JKq9XSuXNnqlevjre3N0OGDCEkJET2icv4+HhmzJhBx44d6dChAyNGjODSpUsYGBiwZMkSWW+w1Ho9OTs7Y2xszOrVqxk4cCC//PILMTExzJgxg9GjRzN+/HhZ8+V04cIFxo4dy/Tp0+nSpQuQtQC4YsUKfv31VypWrMigQYMoWbKkYorAkpKSCA8Px8DAgOrVqytuwkL474iMjKRr1646HTTyGgY6OzuzZcuWoo6nSsePH+fHH3/k5cuX6OnpUaVKFWrVqqXzmRodHc3jx48BMDc3Z9q0aXh4eMiWOSIignnz5hEcHCwVfGVTQnvanN69e8f06dNznT/v4eHBvHnzFLMbrE+fPmg0mlwT5r169cLY2JgdO3bg5eWFv78/N2/elCllbrdu3ZJ21NrZ2dG4cWO5I0nGjx9PWFgYPj4+UiFKamoqHTt2pGnTpixevJgBAwYQGhqqiDb1NjY2ODs7s379ep1dgZ6engQEBMj6vhfU5j0njUbDDz/88D9OUzheXl7Ex8fn2a5a+M8MHjyYhIQEna4v2fdSZmZmbN68Wb5w/9fr16/ZvHkzBw8e5PXr13m+xsLCgt69ezNgwAAqVKhQxAl1qWnM3717dzIzM1VR+BEQEMCNGzd0ujxmU0o3QsgaLzds2JBNmzbpPO7p6cm9e/e4ePEio0aN4sKFC9y+fVumlFnF3hYWFjRr1ky2DP82CxcuZPPmzZiamvLmzRtMTEzQarXEx8czZMgQZsyYIXdEiZrGU7/99hurVq3CxcUFBwcHSpUqpdP9SSnHUkDWhrnw8HBp3iyn7A5ASpKWlkZsbCxly5ZVRIF3XgrqpKHRaBTTneLgwYNYWFjobKCBrCKbpKQk2TtQq5GbmxtVq1bNNQc1dOhQXr58yYkTJxg1ahQXL17k1q1bMqUUBEFQF2V+2wtCDra2tuzfvx8/Pz/279/P5cuXiYiI0HmNqakpLVq0oE+fPooYZF+7di3Px2vXro2VlRVPnz6VvQo4W9u2bVVxlt7169dp2LChzmMajYbSpUtz+fJlIGvnSmZmphzxdJQqVYqVK1dK/96wYQN37tzB3Nxc9g4FaryeIOvG2tbWFmtraxo2bMibN2/o0aMH+/bt49ChQ4oq/Pjxxx+xtbVl4MCB0mPDhg3j5MmTLFq0iAMHDmBrayv93cotMTGRw4cPExUVRbFixbC0tMTDw0P2nXX9+/cv9Gt37979P0zy71GrVi0WLFjAgwcPWLNmDTVr1qRjx47S89m7/+QsSlCbTp064ebmxr59+9i/fz+3b9+Wijyy6evr06RJE/r06aOIa2vevHlS55cPKa0e/Pvvv+fcuXPo6+tTq1YtNBoNDx48wMfHB0NDQ3788Ue5IwJZLZ9r1aqV6/HMzExpwT8hIaHA8VZRWr16NbVr18bDw0PnqKJNmzYRHx+viO/U8+fPY2NjozM5bWhoSJUqVfD19QWgRIkSpKWlyRVRR8WKFbl7967UmQjgwYMHhISEyH400YEDB3Ta5efV8l2r1Sqq8GPEiBFMmDCBOXPm0KJFC4yNjXWuHxcXFxnTqceFCxeknzt06MDChQuZPn067u7upKWlcfToUV6/fs3MmTNlTPk3U1NTpk6dytSpUwkNDSU0NDRXty8lHJWWTU1j/tatW7Nhwwa6du2Kvb09JiYm0oJq9lFkSvDLL7/keSRS9meUkgo/sr/jw8PDqVu3LgD379+XjvmIiooiJCREalsvl549e/LkyROOHz+eq+AXoEePHkUfqgApKSls2bKFoKAgkpKSdMamGo1GEcXpkydPJjo6Wurk+v79ewDat2+vmGspm5rGUytWrECj0eDn55fnrn6lFH6cPn2ar7/+mvj4+FzPKaWIftOmTXz66afS50/28WP5SU1NZf/+/f9oDua/bezYsYq5VyrI119/Tbt27XQKP7RaLdu2bePBgweKK/zILvrMLvZ3dHSkc+fOiunuC1mFvxkZGaSkpEhdqJKTk3n06BFv374lPj6ehw8fyj6PIgiCoCai8ENQjdatW9O6dWu0Wi0vXryQdgFVrFgRc3NzmdPpGjJkyEcHrA0aNODXX3+VPbutre1Hz9Lz9fWlbNmysp6lZ2ZmRnBwsNQxQ6vV8ueff3Ljxg2qVKnCuXPn8Pf3l72g5tGjR8THx1O7dm2MjIyArJu/Ro0aER4ezujRo9m7d6+sGUFd1xNkTfbevXuX6OhobGxsOH78OM2bN+fJkyfExMTIHU/H48ePSU9PlyYoIetmKyYmhufPn5ORkcHr168VsdPi7t27jBgxQmehCrIWBdeuXUvt2rVlSkahjxpRw+SAknTv3h3ImvzJXvgV/t8YGhoyYMAABgwYwLt37wgPD5c+U01NTWnYsKGiuujcunWLkiVLMn/+fOrVq6eIrl75+euvvzAxMWH37t3SYt+DBw/o378/f/75p2IKP2rUqMG9e/eYMmUK7dq1Q6vVcurUKakgxMfHhxs3bsj6mRoTE0NycjKQ9RnfsmVLnQ4fGRkZUhGgEgo/ypQpQ1BQELt375Y6pZ08eZLAwEAqVKhAQEAA/v7+BU5iF6W+ffuyfPlyXF1d0Wg0nDt3jjNnzkhnqMtp9OjR0s8JCQns3LmTqlWr4uLiImWNiYlR1GLVsGHD0Gg07NmzJ1fXD6UsqqjB8OHDc42TDh8+rHMsplarxcvLS3G/UysrqwJ3/yqBmsb869atA7IKE8LDw6XHs7Mr5fo/cOAAWq0WS0tL6tatq4jfXX7c3d05cOAAPXr0oGbNmmi1Wh4+fEhGRgZdu3bl4sWLvH37lk8++UTWnL///jvz5s0jIyMjz+eVVvgxe/ZsDh06lGcxslLu+wwNDVm2bBmTJk3izp076OvrU69ePapXry53tFzUNJ5Syqajj1m5ciVxcXHo6elRrlw5RX5OrVy5kpUrV+Lm5oa7uzuNGzfWmefTarXSMVSXLl3izJkzpKamylr4oYT7j/x4e3uzYsUK6d++vr40aNAg1+vKlClTlLE+Kjk5GS8vL4KCgqTP1L1797Jnzx7Wr18vzVnLrUmTJly5coUuXbrQqlUrtFotFy5cIDo6GgcHB44fP05UVJTsnagFQRDURHmjE0H4CI1Gg4WFBRYWFnJHyVenTp04f/48SUlJ0u6P7GMU6tevz8uXL7lz5w4//fQTy5YtkzXroEGDmDlzJmvWrMl1lt6cOXOks/TOnj0ra87Ro0fz3XffsX79etavX6/z3IgRIwgPD0er1cp2jEpMTAxffvklAQEBAJiYmDBnzhxpUXXt2rWsXr1aETspclLD9QRZuxQ3b97M3r17cXFxYdSoUdIkWl43XHKysrLi5s2bDB48mLZt26LVajlz5gyPHj2iQYMGHDp0iLt37ypiMnv+/Pm8fv2aGjVqSAtAFy5cICoqirlz58q6o0opC7r/VuPGjSM9PZ3k5GSMjIwICwvjypUrODs7K+JvU63Kli2Lg4OD3DEKVKFCBapWrUqnTp3kjvJRxsbG1KtXT2eHd+3atWnQoAEPHjyQMZmuyZMnM27cOHx8fPDx8QGyJlSLFSvGpEmTiIyMBORdXDlx4oROAe+lS5dwc3PL9Tq5j07INmjQIJYuXcrcuXOZO3eu9LhWq6V///7cunWLtLQ0WrduLWPKv40aNYr4+Hi2bdtGeno6aWlpFC9enIEDB/LFF1/Imm3ixInSz9OnT6dSpUocPnxY2lE3efJkPDw8FLXwX7lyZbkjFFpAQAC2traK3IWopt+jGqlpzN+jRw/FLJoX5M2bN1hZWUmdipTs22+/JTExkZMnT+oU07Rt25aZM2eyYcMGqlatyldffSVjyqyd/+np6ZQrV45q1aopcpE6p1OnTlGsWDGGDBlCzZo1FbMrPTU1lWLFilGsWDFSU1OBrCMccy6mZz+upO8DNY2ntm3bJneEQnn48CHm5ubs3buXihUryh0nT0ePHmXhwoUcO3aMY8eOAWBkZESpUqXIzMzk3bt3UrdkjUZD+/btZf+sAoiNjWXv3r0EBwdTp04d3NzcKFasWK7uz0XN09OT3bt38+LFC50uejnp6ekxePBgGdLlb8WKFQQGBlKpUiXatWsHZH3GBgYGsmrVKqZNmyZzwiwzZ87Ey8uLx48fs3PnTulxU1NTZs2axZ9//om+vr5OMbsgCIJQMI1WaT2dBeFfYOPGjaxevZpdu3ZRv359AG7evMmQIUP45ptv6NmzJx4eHiQmJnLp0iVZs6rpLL1z586xZs0aIiIiyMjIwNLSks8//5x27dqxb98+Xrx4wejRo3XOAS0qX3/9NQcPHtR5zMjIiJMnTzJ//nx8fX3RarU0aNBA52xtoXDS0tJYunQpzZo1w9XVlW+//ZZ9+/ZRpkwZfvnlF0UttF6/fh0vLy8SExN12qkbGxuzbt06AgICWL58OQsWLKB3796yZrW1tcXU1BQfHx+p2j85OZnOnTvz+vVrgoODZc0n/O88ePCA4cOH880339CgQQM8PDxIS0tDX1+fdevWiXPA/8WOHj3KrFmz2Lx5M7a2tnLHKdDatWtZt24de/bskbplhISE8NlnnzFu3Di8vLxkTvi3sLAw1q9frzNG+eyzz7CxseHUqVMkJCTIWviRvQP5wYMH+U5YlilThilTptC3b18ZEua2Y8cO1q5dS3R0NJDV/e3zzz9n2LBhbN68mXv37vHtt99SsmRJmZP+LSkpSSr2rl69uqK6/QDY29tjY2PD1q1bdR4fNGgQoaGhBAYGypRMvZydnbGwsMh1HyD8+6lpzK8WEydO5MGDBzpdaZTu8ePHhIeHS9/9NWrUALKO01TCd4C9vT1mZmYcPHgQY2NjueN8VIsWLahduzbbt2+XO4qOBg0a4O7uzqpVqwrceKLErlRqGk/Fxsby8OFDUlNTpbFqYmIi165dY+rUqTKny9K/f38MDAxUUagSERHB/v37uXjxIvfv35c6/+jr69OwYUNatmxJ7969qVq1qsxJs47HGjx4sNSN1s3NDUtLSzZs2MD69etxcnKSNV9MTAxxcXF06NCBli1bMnv2bOk5jUZD2bJlZT/a60Nt2rQhJSWF48ePS91I3r59S+fOnTE0NJR9g2dOKSkpHDlyhIiICNLT06lXrx5dunTB2NiY0NBQSpQoociuSoIgCEolCj8E4X/AxcUFS0tLNm3apPP4sGHDePToEWfOnFFMMYWdnR3lypXj5MmTOmfpdezYkbdv33Lx4kU+/fRTXr58SVBQkKxZlczV1ZWEhAQ2bdpEzZo12bRpE7/++isNGzbkzp07aDQaPD09mTRpkqLb6qvJ27dvMTIyIiEhQRGtSXN6/fo127dv58GDB6Snp2NpacmAAQMwNzfn6tWr6OnpKaKVaYcOHahUqVKuBaABAwYQFxfH0aNHZUqW2/Pnz1m9erXUVcfJyYmxY8cq8mgiNRg9ejTnzp1j+vTpvH37ljVr1uDi4sLFixdxdHTM9TchJ6Xu/FGroUOHEhoaSlxcHMbGxjqLEhqNJs8ztYvShy2Gb968iUajoXbt2qSnpxMVFUWpUqVwd3fnhx9+kCmlOmm1WjIyMrC2tsbNzY2VK1dKz+np6Sl2d3VCQgIZGRmULl1a7ij5cnNzw8XFRWc3LYCXlxfPnz+XOsHIzcXFhbdv3zJ37lzc3d3JzMzk+PHjLFiwgAoVKsh+/X/o6dOnBAUFodFoaNKkiSI7WLRr144yZcrwxx9/yB0ll7x2qOdHSTvU1UQtY35Qx3jqxIkTzJo1C3t7e5o1a4axsbHOd1O/fv1kTJe/vK4vpVxTXl5exMfH5zo2S6myN1AdPXqUcuXKyR1HYmVlhbu7O6tXr/5oF5/Q0NAiSvXPKH085evry8SJE/M9luju3btFnChvd+7cwdPTk+HDh9OiRYtcn1O1atWSMV3Bso9JLleunOLG/aNHj8bPzw8vLy/WrVuHu7s7rVq1Ys6cOdjb2+t0gpDT06dPMTY2pnz58nJH+SgbGxscHBxyrU14enoSGBhISEiITMng1atX/7hjTmxsrOKO0xEEQVAqUfghCP8D9vb2GBkZcezYMWkw+ObNG7p06UJycjInT56kX79+xMfHc+3aNVmzenp6cuXKFapWrapzlt6TJ09wcHCgW7duzJw5Ezs7O9knC0JDQwkNDSUlJSXXc3JPAtna2uLs7Cydn5yYmEiTJk3QaDSUL1+exYsX06JFC1kzqlnOHTY5DRgwgJcvX3L69GmZkqlPzonJs2fPMmXKFGbPnk27du1IT0/n0KFDrFixgtWrV9OqVSsZk/7tyZMn9OvXj5iYGJ1d6qampuzZs4cqVarImE6dmjdvjqmpKQcPHqR///7ExMRw+vRp+vfvT2RkJFevXpU7IqD8nT9qVNBktUajkX1StbAt8eXO2rVrV4YOHYqHh8dHd0impqbi6+vLli1bZB9LfSghIQE9PT1F7gKOiYkhIiIiz3Gfi4uLDIl0+fr6Sos7q1evpnbt2tIRfwCZmZns3r2bhIQExXTQWrFiBb/99luuyX6tVsuUKVMYMWKETMly+/nnn9m0aZPUirxYsWJ4eXkxadIkmZPp+u2331i1ahUuLi44ODhQqlQpne6Dct6jqHmHuvDfpZbxlJWVVYGLkXKPUXIKDQ3lm2++ISwsLFcXLSVdU1euXGHChAl4eHjkuUithO/TKVOmSD9rtVp8fX0xMTGhcePGUlfKbEuWLCnqeIDuYu/Tp08LfK3S7k2VPp7K1rNnT+7evYulpSX379/Hzs6Op0+f8vr1a/r378+cOXPkjggUfNSwkq79D2m1WjQaDa9evSI4OBhbW1vMzMzkjiVp0qQJDRs2ZPv27TqFVgMGDCA0NJTr16/LHRHIGt8fPnyY4OBgUlJSdD7/NRqNojYmdOzYkVevXnHgwAGpW0ZUVBS9evWiUqVKHD9+XLZs1tbWdOzYkV69euHs7Jxv5+709HSuX7/O0aNHOXz4sGL+DgRBEJRO2Yc7CkIB4uPjSU1NVWSVrYuLC6dOnaJDhw40adIErVbL9evXiY+Px9XVlb/++ovnz58rYoJFLWfpbdmyhYULF+b7vNyFH6mpqVLHFEDaQV2iRAl2795NtWrV5IpWKEq8ng4ePCgtPmu1Wm7fvs0333wjPZ+ZmUlYWJi0IKAkAQEBrF27luDgYJycnOjWrRsvX75k0KBBckfDzs4u12MzZ85k5syZ0r+NjIyYO3cuvr6+RRktX0uWLOHNmzd88sknUqvsP/74g3PnzrF06VLZJgDVLDExkcqVK5OSksLdu3fp2LEjAMbGxqSlpcmc7m8LFy4kJiaG4cOHS4V15ubmpKWlsXz5csXs/FETJXVzycuPP/4od4RCqVy5MjNnzuT777+nRYsW2NraUqtWLUqXLk1GRgZv3rzhxYsXXLt2jaCgIFJSUhRxfnq2Xbt2sXbtWl68eAGAhYUFX3zxBX369JE5WRYfHx++/vrrPD+PlDKpXqlSJcaPHw9kZYqMjOSXX37ReY1Wq8Xa2lqOeHkaP348JUuWZNOmTdICsIWFBaNGjcrVbUdOe/bsYf369ejp6WFpaQlAeHg4a9eupUqVKoo5jgiyimk0Gg1+fn55dkyR8x5Fq9VKCxIF7fdR4l6ghw8fsnnzZoKDg7G2tqZTp04kJyfTpk0buaPpUPKYPye1jKeU0h2lML777rt8C1GUdE0NGzYMjUbDnj17chWfKuX79NixY7kee/PmTa7NHRqNRrb7vpzFHNk/x8fHU6pUKQAiIyMV2elBDeOpbFFRUdKGMxcXF6ZNm0adOnXo3LmzdEyNEqjt+/TVq1eMHz+eUaNGYWtrS5cuXXj//j2lS5dm06ZNiun6pNFoSExM1HlMq9USExOjmA5KAD/88AM7duwAcr/fSiv86NWrF0uXLqV79+40bdoUgMDAQJKTk2U9ghSyjnb75ZdfOHbsGCYmJjRs2DDPe+kbN26QnJyMsbExY8aMkTWzIAiCmojCD0F1jhw5gre3Nw8ePMDNzY22bdty//59pk+fLnc0ycyZM4mOjiYkJIRz585Jj9evX585c+awd+9eTExMmDx5sowps9SuXZsTJ05w+PBhqUVtzrP0ss+El/ssvfXr16PVaqlevTpmZmaKa0uYnyZNmii66EPJ15OdnR3fffcd6enpaDQanj9/zoEDB3K9ztnZWYZ0+fPz8+OLL74gIyMDjUaDVqslMDCQLVu2UKxYMdkXVgozGZGUlPTRnUxF6dKlS9SsWVNnl7KbmxudOnXiwoULMqdTJ3Nzc0JCQvj555/JyMigefPmnD17lsDAQOrUqSN3PIm/vz9NmjRhypQp0kJFv379OHjwoKJ2fWZTwwKQEopOC9KzZ0+5IxTKmjVrOHPmDN7e3pw9e5azZ8/m2UUBsn7nXl5euLq6yhE1lzVr1rB8+XKd74Nnz54xa9Ys3r17p4iuD0uXLiU1NRUjIyNFtqOGrPbJEydOJDw8nCNHjmBubq6zaKmnp0f58uVlL07OSU9Pj+HDhzN8+HDi4+PRaDQf7Vgjh23btlG8eHG2bNlC48aNAbh+/TqfffYZ27ZtU1Thh5IXqk+fPi1181FTd7yQkBA+++wzkpKS0Gg0VK5cmYsXL7Jx40aWL19O+/bt5Y4IKH/Mn5NaxlPbtm2TO0Kh3bt3j4oVK7Js2TIqVaqEnp6e3JHypMQjsj40btw4uSP8I+/fv2fChAlYWFhIBcuDBw+mVq1arF69mrJly8obMAc1jKdyyt5MZW1tzY0bN3BwcKBBgwaK2uWv1KN88rNw4UKCg4OJjIwkNDSU2NhY6tSpQ0REBCtXrsTb21vuiAC0bNmSU6dOSZsO79+/z6BBg3j06BHt2rWTOd3fTp06hVarpXXr1tSrVw99feUurXl5eREWFsaxY8d05s3atm2Ll5eXjMlg+PDh9OjRg82bN3Pw4EGuXLnClStXcr3OwsKC3r17M2DAACpUqCBDUkEQBHVS7reTIOTh0KFDfP3111KLOsg6X3HHjh2YmJgopvrTzMyM33//ncuXLxMRESEVU2Qf9fHpp5/i6ekp7Q6QW/HixfPd4VnYluv/a/Hx8djY2LB37165o+QrPDycpUuX6jz2+PFjncc0Go1iWlQr/XqqVasWCxYs4MGDB6xZs4aaNWtKXQng7wWVnG3VlWDlypUYGhqycuVKafHMzc2NPXv2sGXLFtkngdU08Z8tNTWVihUr6kxU6enpUbFiRV6+fCljMvXq2bOntMOzbNmyuLu7M3PmTFJTUxk4cKDc8SRq2fkD6lkAytk56UOGhoZUrFgRNze3AtsYF5W0tDR27drF3bt3dY6pyiZ3t5+2bdvStm1bIiIiuHDhAmFhYVIXBVNTU6ytrXFxcVFcAei2bdvQ09Nj5syZ0vfqqVOnmDNnDlu3blVE4cerV6+wtLRk3759irvWcxo1ahQA+vr6NGzYkCFDhsic6OMyMzM5cuQIAQEBaDQaHB0d6dy5s6IWLR89ekSTJk2kog/IOkrT3t5eUYs/oOyF6pw71K9du4aFhUWugumjR4+SlJSkmG4/AIsXLyYtLY05c+ZIrf1tbW3R09PD29tbMYUfSh/z56Sm8RRkFf8EBwdToUIFmjZtSpkyZXId+SG3unXrYmxsjIODg9xRCnTmzBm5I3xUzsKPY8eO4ejoqKgjKD60ePFirly5IhX+JScnA1k76ZcuXcq8efPkjKdDLeMpyJr/uX79Or6+vjRu3JidO3eSlpbGtWvXFHf9Q9YRFBEREejp6VG7du18j6qQ29WrV6lWrRr9+vVj1KhRVKxYkWPHjtGrVy9u3rwpdzzJjBkzuHPnDmfPngWyOn89fPgQCwsLpk2bJm+4HBITE2ncuDFr166VO8pHFStWjCVLluDp6SmN++3s7HTG13IyNTVl6tSpTJ06VTra/cN7aSVtShIEQVATUfghqMq6desoXbo0u3btkhZ7+/fvz+HDh9m3b5/sC9Ufat68Oc2bN8/1uIWFhQxp8paUlMTGjRvzPZ9wy5YtMqb7W4cOHbh27RpxcXGYmJjIHSdPDx8+lHZQZYuKipIeyy6wUErhhxqup+7duwNgYGBA7dq1FVfkkZd79+7h6OhIq1atpMccHR2xtbVVxGJFYc8cjoiI+B8nKTxLS0uCgoI4evQoXbp0AeDw4cMEBQVha2srczp1Gj16NGXLluXhw4f07t2bMmXK4ODggKOjo6IWf9Sy8wfUswB04MABqYgq+zv/w3//9ttvrFixAnd3d3lC/l/z5s3jjz/+APJupSt34Ue2OnXqqGpSKiEhgaZNm+r8Tfbp04cjR44oZgK4RYsWPH78WFHFCAXJ3vEbExOjM55OTEzk2rVrDBgwQM54kuTkZLy8vAgKCpIy7t27VzpaRSkLK2XKlCEyMpKUlBRp929ycjJRUVGK2kmdLT09nVOnThEcHEyVKlVo2bIlJUuWpFKlSnJHk3z99de0a9dOp/BDq9Wybds2Hjx4oKjv/ps3b+Lo6Ej//v2lwo/27dtjb2+vmM8oUP6YPye1jKcSEhIYP348ly9fBrLGUU+ePGH37t1s27at0PcxRWHWrFl4enoyc+ZMXF1dc31+uri4yJRM3WbPno2FhQVHjhyRO0q+/vrrL6pUqSJ1SjAyMsLX15euXbtKi9ZKoabx1JgxY/jyyy95+vQpHh4eeHt7s3LlSrRarez3JB/y9vZm48aNxMXF4ebmRvPmzbl69So///yz4gps3r9/j7W1NQYGBty8eVPqQFi+fHkiIyNlTvc3c3Nzjhw5wrFjx7hz5w4GBgZYWlrSrVs3Rf1OPTw8uHz5MhkZGYot9vmQtbW1oo6ezIuVlZViNp4KgiD8G4jCD0FVHj58iLOzM7Vr15Yeq1u3Lo0aNSIgIEDGZLpev37N0qVL8y2m8PX1lTGdrlmzZnH06NE8j39QUhvI6dOn07FjRzp27IidnZ3Utjib3Is/amlNn5Narqd3794xcuRI6Wbv0qVL3L17F3Nzc9q1a6eom0CA0qVLExkZKe38gayFoHv37lGuXDkZk+UWHR3NggULiIiIyLVQFRsbq5gzf728vPjyyy+ZNm0a3333HQApKSkAfPbZZ3JGU7UPCxGGDh0KoKgCO7Xs/AH1LAD99NNPfP/991haWtKhQwcga3dleHg4Y8aM4e3bt2zevJm1a9fKPsnq4+ODnp4ePXr0UHQbdbVxc3MjMDBQZ1E9Li6OBw8eKKbAcu7cuXTt2pUePXrQvHnzXOM+JRyXmFNAQAATJkzg7du3eT6vlMKPFStWEBgYSKVKlaTF3lOnThEYGMiqVasU87napk0bfv/9d/r370+nTp2ArM+Dly9fKqpAAbJ2U3/++eeEh4cDWdfX+/fv2bJlC1u3bpV1Etvb25sVK1ZI//b19c2zm1OZMmWKMtZHFS9enBcvXujcn6akpPD48WNKlCghYzJdahrzq2U8tXjxYi5dukTjxo25ceMGALGxsTx79oyffvqJlStXyhswh2fPnpGens4ff/whFalm02g0irmPcnNzy/c5pc1NQdYmhczMTLljFCg2NpamTZvqHJVmbGxM5cqVpb9bpVD6eOrQoUO0a9eOEiVK4O7uzh9//IGxsTHVq1dn9erVbN++nWrVqjFhwgRZc+a0adMmli9frvO7vH//Pn/++SdLliwpsLuiHExNTQkLC2PTpk2kpqbi7OzM7du3CQoKUsRRUFFRUaxevZq5c+dSsmRJvvvuO5256D179vD7778rZn66Xr16HD9+nF69euHo6IixsbFONrmvqZxevHjB/PnzuXv3rjR/lk2j0XD+/HmZkgmCIAj/a6LwQ1CVihUrcvfuXan1F8CDBw8ICQlR1I6qmTNncvbsWcUXUwBcvHgRPT09+vbtq+jzCZcsWUJsbCyQu12pEnb9Zu/0VBOlX0+pqanMmDEDHx8fdu/eja2tLTNmzODAgQPSa+rWrcuWLVsoX768jEl1denShc2bN+Pu7o5Go8Hf358OHToQHx+vuBbw8+fP59SpU3k+V7NmzaIN84GcC5IdOnRg3rx5Op8DJiYmjB07VloQEv6Z+Ph4fvnllzyLfsLDwxUzaZm98+fo0aPcvXsXfX19aedP9t+HUqhlAcjX15fy5cuzbds26Tt/4MCBdOzYkXv37rF48WKuX7+uiPOrjY2NsbW1ZcGCBXJH+Vextrbm9OnTdOvWjVatWpGamsrZs2d59+4dJUqUkI6ok7NL2bZt24iNjSU2NlanA1V29zQlTaoC/Pzzz8TExFCmTBliY2OpVKkSb9++JTU1VeeYOrmdOHGC8uXLc/jwYWmxf+zYsXTu3Jljx44pZgF48uTJ+Pv7c/fuXemzSKvVUqVKFSZOnChvuA8sXLiQ8PBwOnXqhI+PD5DVqe79+/csXryYDRs2yJbN09OT3bt38+LFC+kIsg/p6ekxePBgGdLlr23bthw8eFAqrA8JCaFLly5ER0fTo0cPecPloKYxv1rGU6dOnaJu3brs3r1bKpqaNm0af/31F1evXpU5na7sI4mMjY0pW7as4uZ5sj19+jTf55SYuXXr1mzYsIGuXbtib2+PiYmJtKteKd1Ta9SoQUBAAMeOHcPFxYWMjAz++usvAgMDqVWrltzxdCh9PDV9+nTmzJlD27Zt6datGy4uLtL77eLiosjOObt27aJixYocPXpU6qI1YcIEfH19OX78uOIKPzp06CAVqxQvXpx27doxe/ZsEhMTZf9Offr0KYMGDSImJoaBAwfSpEkTQLfT461bt/D19VVMd6rvv/8ejUbD+/fvuXfvnvS4Uq6pnKZPn46/v78q1iYEQRCE/y5lrvAKQj769u3L8uXLcXV1RaPRcO7cOc6cOYNWq8XT01PueJLAwEAMDAyYMGEC9erVw8DAQO5IBWrSpAmzZ8+WO0aBjh07hr6+Pt27dxe7fv9LlH49rV+/nqNHj0r/9vf3Z//+/dK5lG/evCE8PJxff/1V6gKhBJMnTyY6Oprjx48DWa01IatFtRImqnLy9/fH3Nyc1atXM3DgQH755RdiYmKYMWMGnTt3ljVbixYtaNeuHV26dKFFixb07duXHj16EB4eLp2jq7RuL2qyYMECDh48KE1Q5JwMKFWqlIzJcjM2NlbcDu+8qGUB6Pz589jY2OgUehoaGlKlShVp12eJEiVIS0uTK6JkyJAhrF+/nqCgIGkiUPh/t3DhQiBrx/ejR4+AvydYt2/fLv1bzgWW3bt3o9FocHZ2VsW47969e9SvX599+/bRsmVLVq1aRdmyZenVq5ei7gNev36Ng4ODToeHcuXKUb9+fQIDA2VMpqts2bLs37+fXbt2ERAQgJ6eHnZ2dvTr109x3SkuXLhAo0aNWLp0qVT4MXLkSE6cOEFwcLCs2YoXL87+/fuJi4ujQ4cOtGzZUueeT6PRULZsWcV0+co2Y8YMIiMjpSLUly9fAllFa0opTgJ1jfkhazzVrVs37Ozs0NPTo3r16oobS8fFxVG3bt1cj5uYmPD8+XMZEuXv3bt3WFpasm/fPsX9HnPatGmT9LNWqyU1NZWQkBC2b9/O8uXL5QuWj+xjcu/fvy91UgL5xyU5eXp68u233zJ16lSdx7VareK6USp9PFWqVCni4+M5duwYPj4+lClTBg8PD7p06aLYsf+zZ89o1qyZznikfPny1K1bl6CgIBmT5W3SpEno6+vz8OFDBg8ejJmZGfXr16dGjRoMHz5c1mwbNmzgzZs31K1bV+f32bRpU7788kv27t0rHf+ilMKPHj16qKZo4saNG5QuXZoZM2Yo8voXBEEQ/ndE4YegKqNGjSI+Pp5t27aRnp5OWloaxYsXZ+DAgYwZM0bueJISJUrQsGFD2QfRhdGnTx8OHjxIQkKCTqtKpSlbtiw1atQQu37/i5R+PR09ehQDAwPWrl2Lra2tVNzRoEEDdu/eTVxcHO7u7pw7d05RhR+GhoYsW7aMSZMmcefOHfT19alXrx7Vq1eXO1ouiYmJ2NraYm1tTcOGDXnz5g09evRg3759HDp0iPHjx8uWLSEhgUOHDnHo0CEqVKiAh4cHXbt2xcbGRrZM/yZ+fn6ULVuWOXPmMGXKFL7//nueP3/OypUrGTdunKzZPjyCpiC7d+/+Hyb5Z9SyAFSmTBmCgoLYvXs37du3B+DkyZMEBgZSoUIFAgIC8Pf3x9TUVOak0K1bNzZu3MigQYMoWbIkRkZG0nOiPe1/Tg0TlgYGBjg4OLB582a5oxRKRkYG5cuXR19fH2tra0JCQhg8eDB2dnZcvnxZ7niSKlWqEBISwqNHj6RxSVRUFMHBwVSpUkXmdLpKlCiBl5cXXl5eckcpUEpKSp7FPRkZGXnusCxq5cuXp3z58pw+fRpjY2NFdcnLj4mJCbt37+by5cs6Y+nmzZvLHU2Hmsb86enpLF++nK1bt0qFnYaGhgwbNowJEyZIO+zl1rBhQwICAqRihZxH6CptEbht27aEhYUp5neXn7yum08++YTw8HA2bdpEixYtZEiVPzUcodu7d2+Sk5Px9vbm1atXQFY31dGjRyuuWF3p46nLly9z6dIlTpw4wZkzZ3j37h07d+5k165dVK5cmS5dutCtWzfq1Kkjd1RJlSpVuHHjBrdv3wayPl8vXLhAYGAg1apVkzldboaGhkyZMkXnMaV0T7t48SKlSpVi27ZtOh0yy5Urh5OTE1ZWVpw+fVox3Ujh7wL6vMTHxxdhko+zsLCgUqVKdO/eXe4ogiAIQhEThR+Cqmg0GqZOncrYsWMJDw/HwMCA6tWrK+qsX4Bhw4bh7e3NixcvMDc3lztOgfT09EhKSqJDhw5YW1tTokQJncUAuY9QyTZixAiWL19OSEgItra2csf5V1D69fTkyROaNm0qTVZdunQJjUYjVfqbmJhgbW1NQECAnDGBrF0fH9LX19f5W81+jRLOUc1mamrK3bt3iY6OxsbGhuPHj9O8eXOePHlCTEyMrNmWLl3KyZMn8fPz4/Xr12zbto1t27ZRvXp1unbtSpcuXWQ/jkbNYmNjadGiBR06dGDt2rUYGhoyZswY/Pz8+P333xk2bJhs2Qo7saO0hWu1LAANGjSIpUuXMnfuXObOnSs9rtVq6d+/P7du3SItLY3WrVvLmDLLV199JR3vFB8frzOZprT3P/uYpNTU1FyLvY6OjjKlyltBE5ZKMXDgQHbv3s2zZ88U9b2Zn+xFgGvXrmFnZ8eePXsoXbo0wcHBilj8z9arVy+WLl1K9+7dadq0KZDVqTA5OVn2dt9Lly6lbt26dOvWTTpuKC9K2fGdrWnTply6dIn58+cD8PjxY6ZMmcK9e/cUtaBqYWHB4cOHCQ4O1jniDbJ+pz/88IOM6fLWvHlzmjdvTkpKCpGRkaSmpsreWUGtY/7FixezdetWtFqtdK+XmJjI2rVrSUtL46uvvpI5YZapU6fy+eefs2jRIjQaDcHBwdy4cQN9fX1ZC9LzYm9vz+nTp+nZsyfNmjXTKU4FFNXu/0NarZY3b95w584duaPk4uLigqOjI2ZmZnJHKdCgQYOkIyq0Wi0VKlSQO1KelD6eMjAwwNXVFVdXVzIyMrh8+TInTpzg9OnTPH36lLVr17J27VqsrKx0jvyVk5eXF7NmzeLTTz+VOueeO3cOrVbLoEGD5I6Xp4CAANauXUtwcDBOTk5069aNly9fyp43OjqaJk2a6BR9NGzYULp/Ll26NI0bN1bEnF9BgoOD2bNnDydOnFBU15evvvqKiRMn4u3tjaura67vKSUdTRUeHk7p0qUxMzNjz549+Pn54eLiwoABA+SOJgiCoEoarZJmogShENLT00lPT8fIyIiwsDCuXLmCs7OzdAasEnzzzTecPn2a5ORkatSokauYQkk7lAv6vWk0Gu7evVuEafLn6enJjRs3SE5OplSpUjpnEYtdv/85JV9P9vb22NjYsHXrVh48eICHhwcajYbt27dLixWffvopT58+lX03bYMGDQr1Oo1Go6gJtoULF7J582bGjRuHjY0No0aNkj6rGjRowP79+2VOmLWT9ty5c5w4cYJz586RkJAAZP0ura2t6dq1K0OHDpU5pfq4uLhQvHhxjh07xo8//khCQgI//vgj3bt359mzZ7Luqvknk3pK3BWY3Yr61atXBAcHY2trq7jJ6x07drB27Vqio6MBMDMz4/PPP2fYsGFs3ryZe/fu8e2338reCczW1hZjY+N829M6OTnJlEzX6dOn+frrr/Pc5aW0z/1soaGhhIaGkpKSovO4RqOhb9++MqX627fffsuxY8cAqFmzZq6JSiWNpQF+//13Zs2axbRp02jZsiW9e/cmMzMTrVZL69atWbt2rdwRgawuFF999ZX0u83Wtm1bVq5cqXMEVFGzsrLC3d2d1atXY2VllWdxV/bnq1LuTyDrOILBgwdLRWrZSpYsyfbt2ws9Rvxfmz9/Pjt27ADIVYyktN9pQkKCtKhmY2NDr169ePz4MRYWFmzZskXWHdVqHfM7OzuTnJzM6tWradWqFZC10/6LL77AyMiIK1euyJzwb6GhoWzYsIG7d++ir6+PpaUln3/+uWKupWw575dzfl4p7XPqw056GRkZvHr1iujoaCwsLDhz5oxMyfLm4OCAhYUFR44ckTuKjsjISEqWLImZmRmRkZEFvlZJi6lqG09lS0pKYsmSJezYsUNx1xTArl278Pb2lu6lKlWqxMiRI2UvpMiLn58fX3zxBRkZGWg0Gtzc3KhatSpbtmxh9uzZ/6jb5n+bk5MTVatWLXDeqWfPnrx8+ZKLFy8WYbKPi4+P59ChQ+zZs4f79+8r8u/06tWrjBkzhsTExFzPKWmccvbsWcaNG8eCBQuoWrWqdB1pNBrZ/0YFQRDUSnT8EFTlwYMHDB8+nG+++YYGDRrQp08f0tLS0NfXZ926dTRr1kzuiIDuotX9+/d1nlPaDtWxY8cqLlNeci7sx8XFERcXJ/1bDfmVSOnXU82aNblx4waXLl1i3759QNaRP/b29gAcOnSIW7du0bhxYxlTZilMDWXx4sUVtxNoypQpaDQabGxscHV1pXfv3uzbt48yZcowY8YMueMBWb+39u3b0759e1JTUzl//jw+Pj74+Phw8+ZNbt++LQo//gOtWrXi4MGDrFmzhmbNmjFp0iSpYFHuTipKLOYojFevXjF+/HhGjRqFra0tXbt2JTY2ltKlS7Np0yYaNmwod0RJ9i7FhIQEMjIyKF26tPScnN1ePlSrVi3Kli2r+Pa0K1euJC4uDj09PcqVKyfr4nlhbNmypcCuH0oo/Mj+3oesRcCclDju69u3LxUrVqRSpUpYWVkxf/58Nm7cSLVq1Zg5c6bc8STFihVjyZIleHp6EhAQgEajwc7OThFjqR49emBtbS39rMT3OS+WlpYcOXKEnTt36ixUDxw4UFFFf6dOnZIKkerVq6foz6lFixbh4+ODjY0NYWFhPHr0iFKlSvHs2TOWLVtWYEeY/zW1jvm1Wi329vZS0QdkdVRp3LixYhZ+AK5du0a5cuVYvHixzuP+/v6cO3cOV1dXmZLlppbPqfyKufX09BRxvOuHqlSpQmZmptwxcvHw8MDd3Z1Vq1bxf9h7z7Aozvd9/9wFVCyoRMVewaBSFMUKNkDU2Cv2XhJ7+2jsNbGLNWAvsWAlFmzYWxREQCOoFLFhRUG6wP5f8GfCSpHkmzjP5jfnq2VmjiNX1p2Zp1z3dbdp0ybHf3uRNlNBt8ZTqampXLt2jZMnT+Lt7U1sbKz0zBUtSblXr1706tWLqKgoDAwMKFKkCElJSbx9+1aIdpmZWbNmDfny5WPNmjUMGzYMAAcHBzw8PNixY4esm+pVq1bl3r17BAcHZ1t8FhAQwMOHD2nQoIEM6rLHz8+P/fv3c/r0aRITE6XfqJmZmXDrUnPmzJEKpz5HpDrwDRs2kJaWhr6+PseOHUOtVjN+/Hg2bNjAnj17FOOHgoKCwt9A3Nm+gkI2LF26lMjISJ4/f869e/dITk7Gzs6Oa9eusWHDBtk3qjP4+eef5ZaQZ0SLTM2JnTt3yi0hV3Sx+kv0+6lbt24sWLBA6u2uUqno378/arWasWPHcvbsWVQqlRCTgIz+rgAXLlxg/PjxzJkzB0dHR9RqNV5eXvz0009Cbf5AerTq1KlTpb8XLVrE5MmTKVq0aJbKehHw9/fnypUrWkYwkSasusSMGTOIi4vDzMyMVq1a0bhxY65fv46BgYEwPX8BPD09cz0vd2uCzCxevJiAgADCw8MJDg7mw4cPVKtWjdDQUNasWYObm5vcEiWio6OJiIjQaksSHx+Pj48PkydPllndn8ycOZORI0eyadMm7O3ttdK+QJyKyoiICEqXLs2BAwcoWbKk3HK+yObNm9FoNFSsWJFSpUoJt/APujWWzqBFixbS586dOwttYrOwsJBMFqKQ2YykC+2IMlOqVCnGjx9PXFwcarUaQ0NDuSVlIT4+ntq1awuTPpMbFy5coFSpUrRp04bp06dTrFgxLl++TKdOnfDx8ZFVm66O+du3b8/JkyeJiorC2NgYgOfPn3P//n0hzH4Z9OvXDycnJ9auXat1fM2aNYSGhsqe8pgZXXlOZfc+LVCgABYWFrKm5+RE06ZN2bJlC+3bt6dOnToUKVIEPT09QN5WXxqNRmvemdMcVLS5qejjqbS0NG7evImXlxdnzpwhJiYGSP8eixQpgrOzM+3btxcm5Q/S1/4yTEAZz1OAAQMG8ObNG86dOyejuqw8fPgQW1tbLeOfra0tVlZW3LlzR0Zl0LVrV/z9/Rk+fDgTJ06kUaNGFC9enFevXnH58mXJENCtWzdZdcbExODp6cmBAwcICQkB0n+j+fPnJykpSTIBi0ZkZCQVKlRg165dmJiYCDnnAwgNDaVu3bp89913rF27lurVqzN8+HBu3rwp+29UQUFBQVdRjB8KOkVAQACmpqb069cPFxcXypUrx+bNm3FxceHBgwdyy5MQeaEXYOTIkfTv3z/PfacDAgLYsWPHV6+uevPmjbSBkteJXnR0NEWLFv03ZWVLXif4Ii0EiH4/9enTh/fv37N7927S0tLo0aMH33//PZBesapWqxkxYoQQG78Zi1GQ3kPbxsaG7t27S8d69eqFl5cXK1as0NoYkoOrV69SokQJzM3NuXr1aq7X2tnZfSVVOePn54eXlxenTp3i3bt3QPp9VKhQIZycnGjfvr3MCnWTwoULs2bNGunvLVu2cP/+fUqXLi1Uleq0adNyXaAQ4f7P4ObNm1SoUIGePXsyYsQISpYsyYkTJ+jSpQt3796VW56Et7c348ePJzU1NdvzIhk/Bg0aRFpaGitXrswyBhHJSGlubo6BgYFOmD4gPZrY0tKSAwcOyC1Fi+TkZPLlywfkfSydmpqq9Q7+muR1XCznRhWkt6DMCyqVip9++ulfVpM3HBwcsLOzY968eVrHhwwZQmRkJF5eXjIpy569e/eyceNGXr58CUDZsmUZOXKk1lhQbtq2bcuNGzdkvWfyyvv372nSpAklSpTgzp071K9fn3z58lG+fHlu3rwpqzZdGvNnplChQiQkJNC6dWtsbGz49OkTfn5+fPr0iWfPnjFp0iTp2hUrVnxVbVu3bpXaEEH6XMXBwUH6Oy0tjcjISIoUKfJVdWWHrqyjZEb0tanP2bRpE5CenJuxwQp/ttCR63164sQJKXXi8+QM0dCl8ZS9vT1RUVFA+r9xvnz5aNasGe3bt6d58+bS/4fceHp6Su8fjUbDH3/8oTW+SktL4+HDh0Km1RgZGREeHk5iYqJ0LCoqiocPH1K8eHEZlUH37t25cOEC58+fz3a8qtFoaNOmDW3btpVB3Z80bdqUpKQkNBoN+vr6NGzYkHbt2uHo6Ei9evWETVFr0KABUVFRwiXmZIeBgQFv3rzh8ePH9O7dG0hP+zYwMJBZmYKCgoJuIuabSUEhB+Lj4ylbtixJSUkEBQXRunVrAAwNDfn06ZOs2tq3b0///v1p27YthQoVyvXa5ORkvL292bFjBx4eHl9J4Z9ERkYyZMgQSpUqhYODA9bW1lSpUgUjIyNSU1N59+4dL1++xMfHhxs3bvD8+XPMzMy+us4WLVrQunVrunTpQoMGDXKciKakpHDnzh2OHz/O0aNHZXEEnzlzRvp8584dpk+fztChQ3FycpKqv/bu3cuWLVu+uracEPl+ymD06NGMHj062+Nz586VxeTzJSIjI/n06ZPWgktcXBxPnjzhw4cP8ooD6Xe5du1ahg4dKmxM7ZIlSzh58qTUNzdjkm1nZ0eHDh1wcHDIUv2vkHc+31RTqVTUqlVLuE21OnXqSL9RjUZDcnIyERERaDQaWrVqJbM6bWJiYrCwsMDAwIC7d+9KceTGxsZf7AX+NVm/fj0pKSmYmZnx6NEjrK2tef78OW/fvhUiQSkzKSkpOZ4TyUg5e/ZsBg0axKZNm2jcuDGGhoZaz1ZRkkkycHZ2xsfHh48fPwqxkZZBs2bN6NGjB507d/5iy6kXL15w/Phx9u7dy4ULF76OwM/YuHGj1vMpu/ep3BtVoN2C8nM+1yyn8cPb21vaTHv+/Dk+Pj6sW7dOOp+WlkZQUFCOkdVy4e7ujqurq9Yz6fnz58yePZsPHz5IsepyU716dU6ePEmXLl2wtbXN8pyaOHGijOq0yXhvHj9+nPj4eOrXr8+rV6+4e/cuJiYmcsuTEH3Mn5mMpJeEhAQuXryode7UqVPSZ5VK9dWNH926dcPd3Z3o6GhUKhUJCQk8f/48y3Vt2rT5qrqyQ1fWUT7n/v37LF26lNu3bwPp1f5TpkzJc2rp10TUFjpDhgyhWrVqbNmyhf79+1OvXj3Gjh0rt6xs0aXx1Lt371CpVNSrV48OHTrQunVrocamGVhbWzNz5kxSUlJQqVRERkZmO74SqSVJBu3atWP79u04OjqiUqm4desWzs7OxMbG0q9fP7nlsW7dOjZt2sSvv/7KmzdvpONlypShX79+DBo0SEZ16SQmJqJSqcifPz9jx46lZ8+eFC5cWG5ZX6RDhw7MnDmT4cOH06RJEwoUKKB1vmfPnjIp06ZKlSr4+voyZswYVCoVdnZ2uLm5ERgYSKNGjeSWp6CgoKCTKMYPBZ2idOnSBAYGsnz5clJTU2nUqBEXL17k9u3bVKtWTVZtZcuWZdasWSxYsIBGjRrlugjg5+dHUlISTZs2lUXr4cOH2bNnD1u3bmXPnj3s3bs32+s0Go3Um1yOzaDx48ezfv16Tpw4QZEiRahZs2a236m/vz+JiYkYGhrK1qe2YsWK0udx48ZhZWWltchfs2ZNfH19WbRokTAVtiLfT19CZH2Wlpb4+fnRvn177O3tSUtL4+rVq7x+/VqIhYCyZctKlR1ly5aVWU3ObNu2Tfpcp04dOnToQJs2bShWrJh8onQcXdxUy+79FBMTQ7du3YRYSM9MiRIlePDgAdu2bSM5OZkGDRrwxx9/4OfnJ9S99vjxY6ytrfHw8MDOzo4pU6ZQrVo1vvvuO8loJQqiV1Rm0LVrVwDhk0kymDp1Kq1bt6Z169ZYW1tnaUvxtTf9MmjdujWbNm1i48aNVKtWLdex9JMnT1Cr1bImKoi6OfU5OcW8P3nyhG3btkkVjKampl9ZmTYmJiZSC0qVSkV4eDjr16/Xukaj0QjXombXrl2o1WpmzZolmajPnj3L3Llz2blzpzDGjwULFqBSqYiJieHhw4fS8QxzkkjGD3t7ew4ePMi0adPQ09PDyclJMtLIHfeeGdHH/JkZNWqUsM8rIyMjdu/ezevXrxk8eDA2NjZa7WhVKhXGxsZUr15dRpXp6Mo6SmaCg4Pp06cPCQkJ0rHr16/Tu3dv9u7di7m5uYzqsiJqC523b99iZGRESEgIt27dQl9fP0djt9yGX10aT02aNIn27dsLn0hQpUoVFi1aRFhYGO7u7lSuXFl65wOo1WqMjY1lT6bIjokTJ/Lq1StOnjwJILXTadWqlRAtXjOSfIcNG8azZ894//49xsbGQrWicnR05OLFiyQlJbF8+XLWrFlD06ZNhTAk5sbkyZNRqVRcvnyZK1euZDkvivFjxIgRjB8/Hn9/fywsLGjatCknT57EwMBAtjV+BQUFBV1HpRGpXE5B4Qu4ubnh6uoKQLFixTh9+jSzZs3izJkzLFiwQPY43fPnz0uuVMhaRZdxu9WvX58hQ4ZI1cBykZKSwvXr17l69SoPHjyQ2iiUKFECCwsLmjRpIru79u3bt2zfvh1PT0/evn2b7TVlypSha9eu9OrVS4gWBVZWVpQtW5aTJ09Kv4HU1FTatGnDy5cvpd+H3Ih+P+kqQUFBDB06VLqfMihXrhxbtmz5YtXN1yQ5OZnHjx8TFxeHoaEhVapUESZFo23btnTo0IF27dpRvnx5ueX8J7h79+4X+7hnbKodPHjwK6n6e0ybNo1bt25x/vx5uaVILFmyhG3btknVQGfOnGHOnDlcuHCBSZMmCbP5V6dOHSwtLdm5cycjR46kXr16DB06lCFDhvDHH3/w+++/yy0xC8+fP8fPzw+VSoWNjY1QRhrgi5smohlYZs6cmeM9rlKpCAoK+sqK/iQ4OBh3d3fOnj0rVVVmkDGOLlCgAG3atGHQoEGybwQmJCTg7e3Ny5cvKVu2LA4ODlmq6UQjJSWFTZs24e7uTmJiIgUKFOD7779nyJAhskdVu7u7ExISwrFjxyhdujS2trbSuYxNlZ49ewo1lsr8TM1M//79uXv3rjC9yb/UOi0ng5AcREdHM2/ePB4/fszgwYNp164dP/30E5GRkaxYsUKY6H9dGvPrCps3b8bGxgYbGxu5peSKLqyjZDBixAguXbqEi4uLNA/w8PDAw8OD5s2b4+bmJrNC3WhF6uzszJMnT4CcU75AHMOvro2ndIkBAwbQs2dPIU0eufHkyRPu37+Pvr4+1atX1ypeU/gyUVFRHDlyhIMHD0qmr4z7qmTJkqxfvx5LS0s5JWbhS4kuu3bt+kpKvkxoaChPnjyhYcOGGBoacunSJYyNjYX7ThUUFBR0BcX4oaBz7Nu3j4iICLp27YqpqSk7d+5EpVIJEVGXQWhoaI6LAHZ2dkI5l3WJ4OBggoODs3ynoqU/dO7cmeDgYGxtbWnRogVpaWl4e3tL7mVREj9AN+4nXSQuLo5jx44RHh6OWq3G1NSU9u3bC7NQHRkZybJlyzh37hzJycnScT09PVq1asXkyZOF21hV+GfQtU21zxd/U1NTefnyJStXriQpKQl/f395hGVDcnIya9euJSIigr59+1K/fn1cXV1JTExk6tSpwlTadunShUePHrFq1SpCQkLYv38/3bt355dffqFAgQLcunVLbolaLF++nG3btkk9s/X09BgyZIisrTN0nTp16vDp0yc6duyIiYkJarVa63x2Lda+NnFxcdy4cSPbsXS9evUoWLCgzArTx/sDBgzQ2vQtX748u3btErZy9datW8ybN4+wsDA0Gg12dnbMmTNHuLnJjz/+SM2aNXViPDp58mRu377NqVOnJPPsx48fadOmDc2aNWPRokUyK/wysbGxwkeWZ26nIhKij/l1DRsbG6pUqcKhQ4fklvKfoW7dulSoUAFPT0+t4x07duTZs2dS+xc5MTc3l1qRmpubC2mqOH/+PHPmzJGKkXJbShfJ8KsL4yldo0GDBpQpUybLPSUqObUmmjp1Km/evGHr1q0yKdNd/Pz8OHDgAKdOnSIhIUF6ZtWqVUuYApoPHz5QsGBBaTxy7do1goODKV26NE5OTso4RUFBQeE/jmL8UPjPIFqfcoX/d7lx4wYjR44kKSlJq/d74cKF2bp1K1ZWVjIr/DLK/fTf5enTp/Ts2ZP379/nuGBlbGzM/v37laSN/zC6sqmW0+KvRqMRpkoxL+RWGfi18fb2Zty4cfzvf/+jRYsWdOjQQWr10LZt2yytSuTEw8ODOXPmSJtpACEhIWg0GubNm/fFBBuF7GnRogWVKlVi+/btckvRaYYOHcrVq1cpWLAgZmZmPHz4kISEBJydnVm9erXc8rR4//49S5Ys4bfffkOj0VCiRAmmT58ufLVqVFSU9HwCiI+Px8fHh169esms7E+2b9/O6tWrKVWqFPb29iQnJ3Px4kWioqLo1auX1EpJpVIJZ1gLCAjAw8ODU6dO4efnJ7ccLS5cuEBoaGiWf//bt2/j4eEhszqFf4vevXvz+vVrvLy8lE2pf4i6detiamqa5b7p0aMHoaGhQhg/WrZsiZ2dHfPnz6dly5a5XitX2l9mg5y5uTmOjo5aLTMV/t+hVatWGBkZCbPBnx0+Pj48f/4cSE/8qlmzJv3795fOp6amsn79et69e0dAQIBcMnWeuLg4Tpw4waFDhwgICJA9ORHSjbLTp0/Hy8uLffv2YWVlxYwZMzh8+LB0jampKTt27MDY2FhGpX8SGhrK/PnzCQgIICkpSeucKClKCgoKCrqGYvxQ0CliY2NZv359totAISEhQlX+Kvy/TWRkJLt37+bx48fShlXfvn2FGViD7t5PsbGxJCcnC/Vd6hKTJk3ixIkTNGjQgNGjR1OjRg0KFixIfHw8jx49YsuWLXh7e9O5c2ehYr8V/h0CAwMJCAjgm2++oW7duhQtWlSoNgXZLf4aGhpiaWnJ5MmTKVGihAyqsiclJYV9+/Zl+0z19/fn0qVLMiv8k6CgIAwNDalcuTJXr17l119/pUKFCowdO1Yo01+7du14+vQpO3bsoHbt2gDcuXOHAQMGUKlSJY4dOyabNhcXF+rXr8/EiRNxcXHJ9dp9+/Z9JVV5Y8+ePbi6urJ582ZhzahpaWkcPXpUWgDMPGVVqVT89NNPMqpLp379+mg0Go4fP46JiQnh4eF069aNAgUKcO3aNbnlSRw4cIDly5cTExODWq3GxcWFCRMmCJ3w4Ovry9ixY3n//n225+VeVM9M5lZPmQ3fn/8twmYApI+jf/vtNzw8PHj06JFQ2jJYv359rhuqImlV+GeZM2cO+/fvp2jRotSqVYsiRYqgp6cnnV+xYoWM6nST/v374+Pjw/jx4+natSsABw8exNXVlYYNGwplAo2Pj8fQ0FDLLB0TE4ORkZGMqtJxcnLC1NSUX375hR9//JEKFSrwww8/yC1LQQZ++eUX1q5di52dHfXq1aNw4cJaz6mePXvKqC6da9euMWTIkFwLDzQaDdWqVePEiRNfUdl/l0ePHnHo0CGmTZsmq44NGzawZs0aAPbv309iYiL9+/dHpVJhbW3Nu3fvePbsGX369GHmzJmyas1gwIAB3Lx5M8fzIqUoKSgoKOgKivFDQaf48ccf8fT0lBaoMv98CxcujK+vr4zqFBR0C127n44dO4abmxthYWE4ODjQsmVLHj16xNSpU+WWplPY2dmRlpbGhQsXpEjyzCQnJ+Po6IhGo+HKlSsyKFT4GsTFxTFmzBhu3LgBgIODA1ZWVuzbt49du3ZRrlw5mRXqHj/99BO7du3K9pmqVquVSpW/gZWVFTY2Nlk2JQYMGMCdO3cIDAyURxja1Z6ZN34/R7QNVYBBgwbh7+9PYmIihQsX1noXqFQqIZ79CxcuZPfu3UDWOHVRvtNatWrRsGFDtmzZIh0bOHAgvr6+3Lt3T0Zl2uQWm58ZkSrqXFxc8Pf3p2jRokRHR2NiYsL79+9JTk6mdevWuLq6yi1RYtq0aXlOdJLTUOvn58f+/fs5ffo0iYmJ0n1lZmZG//796d69u2zaPsfR0ZHXr1/TvXt3du/eTd++fQkLC+P69etMnDiR4cOHyy1R4V9C196nusDNmzcZNGhQtu/SLVu20KhRI5mUabNnzx5WrlzJr7/+qvU7WLhwIVeuXGHu3LmyarWwsKBWrVps376dOnXq4ODgwKpVq7K9VkmryTuZ285+CVG+14xxVU6JjqI8p2bPnk1ISAh+fn4ULVpUq0V2RovXIUOGYG1tLaNKhX+atm3b8vTpUzZu3EijRo2YOXMmBw8epGbNmhw+fJiPHz/i6OiIkZERZ8+elVsukJ5MBenP++rVq2NgYKB1vmLFinLIUlBQUNBp9OUWoKDwV7h8+TLFihVj7ty5TJo0iQULFhAZGcmaNWuE6EeuoJCBr68vGzduJCAggPr169OhQwdev35Nnz595JYmoUv302+//ca0adO0Jtf3799n9+7dFClSRKm2+Qt8+PCBBg0aZGv6gPQFlRo1aghVrTx69GhsbGwYPHiw3FL+Myxbtozr169Tu3ZtKd0nOjqaFy9esGTJEqlKRA5evHiR52vLli37Lyr5a5w+fRpDQ0NGjx7NsmXLmDhxIhEREUJU/kyaNAlLS0sGDhzIpEmTcr1WpGraokWLEh4eTlJSkvTMSkxM5PHjxxQrVkxWbT///DNlypSRPusSGYYvSG/t9vHjR+lvUVoSnT17Fo1GQ9OmTalevTr6+uJNW1NTU7MkJBUsWJDU1FSZFOVMXmo9RKoHefjwId9++y2HDh2iSZMmrF27lmLFitGlS5csi8Fys3jxYrkl5EhMTAyenp4cOHCAkJAQIP3fOX/+/CQlJWFmZiZrclJOvHr1CltbW2bNmsXVq1ext7dn5syZtG7dmvPnzyvGjzwSHh6e52urVKnyLyrJO6NGjRLmPfRfoUGDBri7u7NkyRLpOVC5cmUmTpwojOnjwoULzJ8/H5VKha+vr5bx48KFCzx//pwRI0bw66+/ypZUVrJkSQIDA7GxsQHSW85kt2EukolSF8ir6UCk79XW1lZuCXli/vz5APTr14969eoxbtw4mRUpfA2ePXtG3bp1pef79evXUalUODk5AVCkSBEsLCyEKvT75ptvKF++PG3atJFbioKCgsJ/BvFW0BQUciE6OprGjRvj7OzMxo0byZcvHz/88AOXL19m//79DBw4UG6JOsvnPbQzEGlTTVe4fPky33//PampqVIlwO3bt9mxYwd6enpfjIT/WujS/bRp0yaMjIzYu3ev1I/excWFo0ePcujQIcX48RdISUn5YisPfX19oTaubty4QXR0tGL8+Ac5e/Yspqam7Nu3T1pcnTJlChcuXMg1ZvNr4ODgkKfrRFoABHj37h2NGjVi8ODBeHp6UqVKFYYPH879+/c5fPiwVl/lr82JEydISkpi4MCBucb5qlQqoYwfLVq0YP/+/bi4uEgLQV5eXlIluJx07tw528+6wM6dO+WW8EXi4+OpXbs2GzdulFtKrkRFRXH16lWtvyE9YjvzmNrOzu6ra8tAF+ORU1NTMTY2Rl9fHwsLCwIDA+nbty/W1tZaxiWF3GnatKk0v9PX16dhw4a0a9cOR0dH6tWrJ6ShCtINVB8+fACQNieaNWuGsbGxUL/n9+/fU7x4cbll5EjGnOlLiDSeGjNmjNwS/jKit00EsLe3x97enujoaNRqtVBt/QC2bt0KwLBhw6R2NBkcOHCAxYsXc/ToUTZu3JhrG6h/kx9++IF58+aRkpKSJdkvMyKZKHWBvH5fIn2vu3btklvCX6JWrVo4OzvLLUPhK6Gnp0daWhoAYWFhvHjxApVKRf369aVroqOjKViwoFwSszB27Fhmz55NYGCgsG1IFRQUFHQNMWf6Cgo5UKxYMUJDQ0lMTMTCwoILFy7QqlUrYmJi/lKF8NcgPj6ekJAQkpOTs0xSRHKI+/n5MW3aNJ4+fZrlnEiLQJCeouHv75+tQUWkhIo1a9aQL18+1qxZw7Bhw4D0jUwPDw927NghjPFDl+6niIgIGjRoQNWqVaVjpqam1KpVSyinegYhISEYGRlRqlQpPDw8uHz5MnZ2dvTq1UtuaUDWjarPeffu3VdU82WcnZ05d+6cMhH8B/n48SOmpqZZjhcpUoTIyEgZFP1JXhb28ufPzzfffPMV1OQdIyMjnj9/DqQvsN24cQMnJydUKhWPHz+WVdvo0aOl56cuVdNOnDiRW7duERQUJG32aTQaypUrx/jx4+UV9xmBgYFs376dx48fo6enh6mpKUOHDtWKVRaF2NhYmjVrptWPXDTatm3LjRs3SE1NFVqnv7+/NNbLzNChQ6XPoo2ndYFy5crh7++Pj48P1tbWeHh4YGRkREBAgFCbP6KTmJiISqUif/78jB07lp49e1K4cGG5ZX0RCwsLrl+/zvbt26lXrx5Llizh3r17+Pn5UbJkSbnlSTRt2pTmzZvTqVMnmjVrJpyRRhc3VCF93rd9+3YCAgKwsLCgTZs2JCYm0qJFC7mlaZFd28Rnz54J1TYx4xma0SKjaNGiPHjwgIIFC1KhQgWZ1f3J/fv3qVq1KhMnTsxyztjYmMWLF+Pn5ydri7/u3bvTvn17oqKiaNmyJU2aNJESFUTn2bNn3L17l6SkpCznOnXq9PUFZeLcuXOy/vf/LikpKZw9e5aAgADKlStHkyZNKFSoECYmJnJLy8L27dvZsWMH1atXp0uXLrRv3x5jY2O5ZSn8S1SuXBl/f3+uX7/OoUOHgPS13zp16gDpacr37t2jdu3aMqrUZv/+/ejr69OzZ08MDQ21TCmitCFVUFBQ0DXEmpkqKHwBe3t7PD09cXd3p2HDhkyYMIFz586RmJhI5cqV5ZYnce7cOaZNm0ZsbGyWc6It/i5ZsoQnT55ke06kRaD169dnW92R0fpDJOPHw4cPsbW1xd7eXjpma2uLlZUVd+7ckVGZNrpyP0F6tGpQUJCWISEsLIzAwEDhJtcXL15k9OjRLFq0iPLlyzNnzhwgPQ5WpVIJYfzJaaMqg5z61cpFREQEHz9+pGfPnhgYGFC4cGHUajWgTAT/LjVr1sTX15dt27YB8PbtW1auXElAQIAUYSwXf/zxh/T5woULjB8/njlz5uDo6IharcbLy4uffvqJWbNmyagyK/Xq1ePs2bNs2LCB+vXrM2PGDK5du8aTJ0+kliBykfkdqUvVtMWKFePw4cPs3bsXX19f1Go11tbW9OzZk6JFi8otT8LLy4vJkyej0WiksdPdu3c5duwY69ato3nz5vIK/IwffviBb775hnbt2tGpUydq1Kght6QsVK9enZMnT9KlSxdsbW0xNDTUei9ltzn0tVFS8f49Bg4cKFX+tWrVCnd3d6ZOnSq1/1HIG46Ojly8eJGkpCSWL1/OmjVraNq0qfBR2lOnTmXo0KEUKlQIZ2dnNm3aJG2uy532lJmMjT9vb2+KFSsmPVNr1aoltzRAN9N+AgMDGTBgAAkJCahUKsqWLcu1a9fYunUrrq6utGrVSm6JEiK3TUxLS2PixImcPn2aHTt2aFV6u7u7c/r0aUaNGiVMamZKSkqupi61Wk25cuVkX0spUKAAZcuWZefOnRgbGwth7vkS+/fvZ/78+Tmmecpt/Mjrd5i5LaHcvHnzhsGDB0utkxwcHIiJiWHHjh3s3LlTq1WRCPTs2ZNz587x4MEDFi9ezLJly7Czs6Nz5860bNlSuBZ6uoDIrb27devGggULGDJkCJC+Xta/f3/UajVjx47l7NmzwqxLZnDr1i3pc3x8PPHx8dLfIq1LKigoKOgSivFDQaeYMWMGcXFxmJmZ0apVKxo3bsz169cxMDAQqvJzzZo1fPz4EbVaTfHixYWr/snMw4cPKV68OO7u7nz77bfCaj1y5AgajQYzMzNMTU2F1QnpVd/h4eEkJiZKx6KioqTvWhRyu58mTJggtzwtevTogaurK82aNUOlUnHp0iXOnz+PRqNh0KBBcsvTYsOGDaSlpaGvr8+xY8dQq9WMHz+eDRs2sGfPHtknWLq4UXX79m3pc3JyshSlD8pE8O8yefJkBg8ezNKlS1GpVAQEBODv74++vr7sxoDM1f3Lli3DxsZGa6OnV69eeHl5sWLFCqGqP2fMmMHz588pU6YMbdq0YefOnQQFBQHkarT6Gnh6eub5WrkXgDOzcOFC6taty5AhQ6TFKxFZs2YNaWlptGvXDicnJ9RqNWfPnuXo0aMsX75cOONH1apVCQsLkxaozczM6NKlC+3ataNEiRJyywNgwYIFqFQqYmJiePjwoXQ8w5gogvHj/Pnzckv4z9KjRw9KliyJiYkJ5ubmLFy4kK1bt1KhQgXhTH8is27dOqKiojhy5AgHDx4kPDxcMiqoVCrevXvH3bt3sbS0lFuqFuXLl8fb25vExESMjIzYs2cPJ0+epEKFCjg6OsotT+LKlSucPn2aU6dOcfv2bXbt2sWvv/6KqakpnTt3pl27dpQqVUpumVokJiZy//59VCoVNWvWJH/+/HJL0mLZsmV8+vSJuXPnMnfuXACsrKxQq9W4ubkJZfwQuW3izp07OXXqFCqViqdPn2oZPyIjI0lNTWXt2rVUrlw5zy2B/k0qVqzIH3/8wbt377JN9Hv79i1//PGHMEaLzJuU2SFSUdK2bdtISUmhePHiVKhQQeh1tNjYWNavX09oaKhWym9GmnKGwUpuFi9eTEhICG3atMHLywsAAwMDYmJiWLZsGVu2bJFZoTbz5s1j7ty53Lp1i1OnTnH27FkuXrzIpUuXMDIyom3btvTp0yfbNFCFrIje2rtPnz68f/+e3bt3k5aWRo8ePfj++++B9HUWtVrNiBEjhJrz60IbUgUFBQVdQ6URqaRfQeEvotFouH//PqVLlxYq8r127doUK1aMAwcOCBVHmx0dOnTA2NiY7du3yy0lV+rUqUOlSpU4cuSI8Bu9ixcvZvv27ZQoUYJ3795RpEgRNBoNsbGx9OvXj+nTp8stMVtEvZ8gXduKFSvYtWuXFFGaP39+evfuzZQpU6T0BxGoW7cuNWvWZNeuXbRu3ZoCBQrg6enJkCFDuHPnDn5+fnJL1Dm+tLiWeTFTIe8EBwezZcsWgoKC0NfXx8zMjMGDBwtV/W9lZUWJEiU4deqUFFMdFxdH27Zt+fDhAwEBATIrzEpycjL58uUjLi6Oa9euUaFCBdm/U3Nz8zy/OzPMKiJgY2PDt99+y969e+WWkitWVlaYmppy+PBhreNdunQhNDRUyN9pSEgIJ0+e5NSpU4SGhqJSqdDT08POzo6OHTvi5OQk6+bAtGnTcv3N/vzzz19RjcLXJsP0JXoyRWYyTElv3rwhICAAKysr4Tb9/fz8OHDgAKdOnZISFSC9PdnBgwdlVvcnDg4OWFtbs3LlSrml5Jl3795x6tQpNm7cyOvXr4H0lILWrVszd+5cihQpIrNC2LdvH8uWLZMqaQsVKsSUKVPo2bOnzMr+pHbt2tSpU4dt27Zhbm6Oo6Mj69ato1+/fty9e1eYjV9If/fXqVOHHTt2aGnt2bMnDx8+lDWdokOHDoSEhPDLL7/QrFmzLOc9PDyYM2cONjY27NmzRwaF2ri7u7Nq1Spq1qzJ5MmTsbKyolChQnz8+BF/f39WrVpFcHAwo0aNEsJU8aVxtUhj6Tp16lCqVCk8PT0xNDSUW06u/Pjjj3h6ekrv08zbFYULFxamxW+DBg2oUKECBw8e1Lr3u3TpwpMnT4TRmR1xcXGcOXMGV1dXXr16JR3X19dn2bJlOjXukotu3boRGhoqtfZ2dHRkwIABDB8+nNKlS3Py5Em5JeZIaGgoJUqUECo5U0FBQUHh30Fcq6+CQjY4ODhgZ2fHvHnzgPRK71q1ajFkyBAiIyMlt7XcmJubY2BgILzpA9IX1kePHo2XlxeNGzfW6qUHSBttctOsWTPCwsKEN31Aevz4q1evpAF/TEwMAK1atRIuSSOjeiI5OVmaWIeFhREWFoatra3M6v5EpVIxefJkRo0aRUhICAYGBlSsWDHL71UUDAwMePPmDY8fP6Z3795AejypEqP598jN2CFS7KuuYW5uzrJly+SWkSuWlpb4+fnRvn177O3tSUtL4+rVq7x+/ZoGDRrILS9bYmNjpSo1CwsLAF68eCFr2k6dOnW03p8BAQGoVCqqVKmCSqUiNDSUAgUKCFVJC+n3/r1793jz5o3QYyorKyvi4uK0jmk0GhITE6V+yqJhamrKmDFjGDNmDJcvX2bWrFm8evWKS5cucenSJcqUKcOGDRtki6tevHixLP/d/yKdO3fGwsKCBQsWsG7dOqpWrSpEhXduHD58mPv37+vEBsSbN28YM2YMI0aMwMrKinbt2hETE4ORkRHbtm2jZs2ackuUsLGxwcbGhpkzZ3LixAkOHTpEQECAVos1EYiLi+PNmzdyy8gzDx48wMvLi5MnT/L69Ws0Gg358+cnKSkJLy8vUlNTcXV1lVXjmTNnpASNwoULS0UJc+fOxdjYGCcnJ1n1ZZA/f35evnypteGblJTE06dPhZv3idw28fHjx1hbW2dr+oD01g/79+8nNDT0KyvLnkGDBnHu3DkCAwOzTXjTaDTUrFmToUOHyqAuK+3atZPG1RqNhuTkZB48eMDbt2/p16+fzOq0sbGxITY2VnjTB6QnKRQrVoy5c+cyadIkFixYQGRkJGvWrBHC8JNBUlJStus6qampQrXLziApKYnz58/j5eXF5cuXpbW/0qVL07FjRx48eMDFixdZu3atToy75EZXWntnR7Vq1eSWILFy5UpMTU3p0KFDrkZflUol3Dq6goKCgi6gGD8UhMfb21vqT/v8+XN8fHxYt26ddD4tLY2goKAsC+5yMnv2bAYNGsSmTZto3Lhxlr7kVapUkVGdNrNmzUKj0TBp0qQs51QqFffv35dBVVZat27N7NmzGTFiBA0bNszynYpUqZQvXz5WrVrFhAkTuH//Pvr6+lSvXp2KFSvKLU2Lc+fOMW3aNGJjY7OcE+nfPgMfHx9evXpFu3btAJg7d67UokYkqlSpgq+vL2PGjEGlUmFnZ4ebmxuBgYE0atRIbnk6ia7EvopO5nfnlxBlcW3mzJkMHTqUiIgIIiIipOPlypWTNjBEwc/Pj2nTpvH06dMs5+R+pmZOzHBzc+PRo0fs27dPWvx5+PAhvXr1Emp8AukbQO/evaNFixaUL1+eIkWKaLUC2rdvn2zarl69Kn12dnZm8eLFTJ06FUdHRz59+sTx48d5+/atsG0p3r59y8mTJ/Hy8iIgIIC0tDQgvdr66dOnvHjxgvnz53/VSuDw8HAKFSpEqVKlCA8Pz/Va0X6rIhMSEoKRkRGQ/h5wcnIS3vihK6YvSDcpBQQEEB4eTnBwMNHR0VSrVk2qBnVzc5NbYhYKFSpEjx496NGjB48ePeLQoUNyS9JizJgxLF26lM2bN1OvXj2KFCmile4nyv2/fv16vLy8CAsLk8am1tbWdO3albZt2xIeHs7w4cO5du2azErTExX09PRYvny5tLHn5eXF5MmT2bhxozDGj5YtW+Lp6Unnzp0BCAwMpF27drx69UqoWHoQu22igYGB9F7P7Zrk5OSvpCh38uXLx86dO3F1deXgwYNa6xOGhoZ06tSJSZMmUaBAARlV/sny5cuzHPv06RPdu3cnNTVVBkU5M2zYMMaOHcvcuXOzXZu0s7OTUZ020dHRNG7cGGdnZzZu3Ei+fPn44YcfuHz5Mvv372fgwIFySwTSE16vX7/OwoULAXj69CmTJk3i4cOHwq1NATRq1IiEhAQ0Gg0GBgY4OzvTtWtX7OzspN9C3759uXv3rsxKdQNdae0tOhs3bsTR0ZEOHTqwcePGbIs8M9J/FOOHgoKCwl9HafWiIDx3796lR48euV6TUVUrSkRtbpHucm/+fM6XKjkzTDdyo0txmhmIHvmc4e5Xq9UUL148S6T7pUuXZFKWFW9vb8aNG0eTJk3YuHEjqampWFtbo9FoWL16tVD9vs+ePcv48eNJTU3FwsKCffv28eOPP3Lq1Cm2bt0qVJKKrqArsa+i8/lz9PMhYMZ3q1KphHqmxsXFcfToUR4/foxarcbU1JT27dsLk0iVQc+ePXNt6SHK+7RJkyZUr15dqlDNYMCAAYSGhmoZGuQmtzGK3L/TvLTP0Wg0qNVqocZ9kP5v7evrS1paGhqNhpIlS9KpUye6du1K5cqVSUhIoEuXLrx8+fKrVq7VqFEDR0dH1q5dm+v3K9pYWnTs7Ox49+4dxYoV4/379+TPnz/bthMqlYorV67IoDAr48aN48yZM+jp6Qln+vocOzs7ChYsyJEjRxgxYgQRERFcuXKFLl268OrVKyE2/XUNXbn/M95R33zzDR06dKBbt25ZqmnHjh3LtWvXuH37thwSJaytrbGysmLXrl1ax/v160dAQACBgYEyKdPm48ePDBs2LIup28LCgo0bN2JsbCyPsBwQtW1inz59CAgIYM+ePVhZWWU5HxgYSO/evalVqxYeHh4yKMyZtLQ0wsPDiY6OplChQlStWlVnUjMnT57M77//LtxYWheep5D+Ps2fPz8nTpzg559/Ji4ujp9//pmOHTvy4sULYYo9Hj16RN++fYmOjtY6XqhQIX799VfZ7//PMTc3x9zcnC5dutChQweKFSuW5ZoFCxbw6tWrv1Qo8v8qutraWzSmTZuGhYUFffv2VVp8KigoKPwLKIkfCsJjaWnJ+PHjCQkJ4dixY5QuXVpr41StVmNsbCxU4kNufirRvFbnzp2TW0Ke0KXN8s8jn9u3b090dLRwkc8RERGULl2aAwcOCF9NuWHDBgCaNm0KpN9HEydOZOXKlbi7uwtl/HBycuLo0aM8efKEhg0boq+vT7t27ejfvz+WlpZyy9NJdCX2VVcoXLgwdevWpUaNGlobaaJSqFAhevXqxatXr1CpVEIZ6DKTUeXj7u7Ot99+m8VMJwqJiYncu3ePsLAwqlatCqRrv3fvnnDt1ERe5JGzdc//lZs3b6Kvr4+DgwNdu3alWbNmWtX0hoaGmJmZZVnQ/rfRaDRa4+ScxsyijaVFp1evXqxdu5b379+jUqlISkoiKSkpy3Ui3f+nT58GICUlhcePH2udE0knpLd0tLCwwMDAgLt370qtFYyNjb+YXKOQM7pw/zdv3pxu3brRvHnzHN/5/fr1Y/DgwV9ZWVYKFizI69evSUtLk573qampvHr1isKFC8us7k+KFCnCvn37uHHjhlZypqipiaK2Tezduze3b99myJAh9O7dGysrKwoVKkRsbCz+/v54eHiQmppKr1695JaaBbVaLVQ7guz43CyTmprKy5cvOXv2rHBzK10ar9rb2+Pp6Ym7uzsNGzZkwoQJnDt3jsTERCpXriy3PAkzMzOOHTvGnj17tExfvXv3FnKeeujQIWrVqqV1LKPYIwNREwpFRJdae4tM5raeSotPBQUFhX8eJfFDQaf48ccfqVmzpnB9MxUUMjNp0iS8vLyYMmUKSUlJrF69Wop8bt68uTCRzy4uLhgYGGSp/BKROnXqYG1tzfbt27WODxw4kMDAQPz8/OQRlgtv374lMDCQggULYmFhIdSiqq5hYWFB48aN2bhxI127dmXw4MF89913uLi4EBMTg5eXl9wSdQJ7e3vevHkDpG+cFS5cmHr16tGgQQMaNGggXHVSBpcuXWLhwoU8e/YMgIoVKzJ9+vQc+5bLRYcOHTA2Ns7ynBKNSZMmceLECfT19alSpQoajYbw8HDS0tLo3LkzP/30k9wSFf5FPnz4wL59++jRowfGxsZcv36doKAgypQpg6Ojo5SkEx0dnaW9goLuEhERwevXr+nXrx9169Zl3Lhx2V5Xv379r6wse44cOZLr+Yw2ECLQsmVLNBoNLi4uuLq6MnPmTGrXrk2/fv0oU6YMJ06ckFuigoI0P7W3t5daphw5coSrV6/Stm1bVqxYIa/Az3j69CkhISGSCaB8+fJyS8pCWloaR48eJSAgQKsVJaSPs+UeTy1cuJBff/01x/j8bt26Sa0qFP4aOaVoaDQaOnTowNKlS2VQpfvExsYyffp0WrdujbOzM8OGDeP69esYGBiwYsUKWrVqJbfELMTFxaFWqzE0NJRbSq5s2LCB5ORkxo8fD6SPo1q0aMHYsWPlFabDPHnyROjW3rpGSkoKZ8+eJSAggHLlytGkSRMKFSqEiYmJ3NIUFBQUdBLF+KGgk0RFRWlNruPj4/Hx8RGyYkFEJk2ahKWlJQMHDmTSpEm5XivnIlBycjJ6enro6el9sf+sSJH/uhL5fP/+fQYNGsTQoUOz7fcqSv9sgAYNGmBkZMSpU6ekKprk5GRat25NbGwst27dklnhn6SkpDBv3jwOHz5MWloaDg4O1K1bFy8vLzZt2pRttKZC7uhK7KsuEBoayu+//86NGze4deuWVKGiUqkwMjLC1taWBg0aCGOwvHXrFoMGDcrSL1tfX59t27YJlQZ1/fp1Ro8ezcKFC2ncuDEFCxbUOi/Ke+rDhw/873//4/Lly1rH27Zty8KFC7PolhONRsPJkye5ffu21Js6AxE2VT7H19cXX19fVCoVtra22NjYyC1JIjk5menTp+Pl5cW+ffuwsrJixowZHD58WLrG1NSUHTt2CBWln5CQwJMnT9DX16dChQrC3Ee6ypEjRyhTpgwNGzaUW8p/hiVLlrBt2zZUKhX58+fnzJkzzJkzhwsXLjBp0iSGDRsmt0SdRXQT9dOnT5k3bx63b98mMTFR65xoLRSeP39Ot27dpOQfSH/HGhkZcejQISpUqCCzwnRiY2OZNWsWp06d0jr+3XffMX/+fKHGKAsXLmT37t1A9u0TRWibeP78efbt28e9e/eIiYmhUKFC1KxZkx49etCmTRu55eks2c2TDA0NsbS0ZMiQIUL9TnUZjUbD/fv3KV26NN98843ccrTYu3cvGzdu5OXLl0B6ssrIkSPp3r27zMqysnHjRlauXImtrS27du0iMTGR2rVro1KpmDBhAsOHD5dbos7x+PFjnj17hp2dHQDu7u44ODhgamoqszLd5M2bNwwePJiQkBAAHBwcqFGjBjt27GDnzp1fbFGvoKCgoJAVxfihoFP4+voyduxY3r9/n+15OSfXLi4u1K9fn4kTJ+Li4pLrtXL3pTY3N8fR0ZF169blOoCSe8Eic6/33CrRRVtYs7KyonHjxqxZswZbW1uaNWvGmjVrGDp0KLdv3+bOnTtySwTQqe80o0rN1NSUBg0akJqayo0bN4iIiKB169asWrVKbokSq1atwt3dnbJly/LixQscHR0pVaoUe/bsoUuXLsJtVOoCP/74I56enowcOZLq1aszYcIEDA0NpdjXjJhNhb9GWloa9+7d49KlS+zatUvLBCLCYjWkL6z6+PgwadIkevToAaTHK2devBIFBwcHoqKismz+gHjPVICwsDDCw8NRq9WYmpoKs+mTmSVLlkgJKqJuqkB6xPeUKVOyPIvatm3LsmXLhEjN2LBhA2vWrAFg//79JCYm0r9/f1QqFdbW1rx7945nz57Rp08fZs6cKbNaSEpKYsmSJezfv18yfuXLl4+BAwcyZswYYVsp6QKRkZGsW7cOX19fID3lY9SoUZQuXVpmZX+SW495lUrFqFGjvqKa3ElOTmbt2rVERETQt29f6tevz+rVq0lISGDq1KlCtaa5evUqFStWpGLFiqxcuZLLly9jZ2fHxIkThXhOZaArJur+/fvnaj4PDg7+imq+zOvXr3Fzc8PX1xe1Wo2VlRXDhg0T6v0/bdo0PD090dPTk9rRhYeHk5qaKlwqWbNmzXj16hVNmzalevXqWd5LGZX1CgpfGzs7O5o1a8aiRYukjensUKlUXLly5Ssq+zK6UPXv7u6Oq6trtnOTiRMnCmf4dHJy4sOHD2zevBlra2sA7t27x+DBgylevLjUXk8hb/j6+jJs2DAaNWrEhg0b0Gg01K5dG7VazaZNm6hXr57cEnWOjPXeNm3a4OXlhaOjI1ZWVqxcuZImTZqwZcsWuSUqKCgo6BzKipmCTrF8+XKioqIoWrQo0dHRmJiY8P79e6nyX078/f0pUaKE9DknRFj8Gz16tLSQMmrUKCE0ZUfmXu+5edRE86+VKFGCBw8esG3bNpKTk2nQoAF//PEHfn5+QvVY1aXv9H//+x8BAQE8evSIkJAQSV+5cuWYOnWqzOq0+e2336hQoQInTpzAysoKSF/EvHjxIhcvXpRXnI4yY8YM4uLiMDMzo1WrVjRu3FiKfVX6qP49goKCuHbtGjdu3OD27dskJSVJ50SqqL137x61a9fWWkAbPnw458+f5969ezIqy8rz589zPCfaMxWgatWq0lhAVDLSKJycnKhcubJQG5OZ2bRpE15eXhgaGkpJCr///jteXl58++23QlTSHT9+HAMDAzZu3IiVlZVk7qhRowb79u3j48ePODo6cunSJSGMH4sXL2bv3r0AFCxYEJVKRVxcHBs3biQ5OVm4d7+u8OzZM3r27ElUVJT0XIqIiODChQt4eHhQrlw5mRWms27dulznJyIZPwICAujYsaNWlee4ceO4efMmly9fFqYtmaenJz/++CMLFy4kPDycjRs3AvDgwQOKFCnCiBEjZFb4J2vXruXAgQOSiRrS0zXu3r3L0qVLhdn89/f3p3DhwixfvpxKlSpJqYSiUqpUKWbPni23jFw5c+YMRYoUYc+ePZiZmQHpRlUXFxdOnz4tzL89pKfO1q5dW7qXFP7fIiUlhZSUFAoUKMCDBw/4/fffadCggRCV6W/fviU6Olr6nBOirQNmV/UfExMjXNX/rl27UKvVzJo1S1qHPnv2LHPnzmXnzp3CGT9evnxJ/fr1JdMHpLfStbS0xMfHR0ZluomrqysJCQnSO+rTp09069aNPXv2sHr1aqEKU3SFq1evUqtWLVauXCm1cR4+fDinTp0iICBAZnUKCgoKuoli/FDQKR4+fMi3337LoUOHaNKkCWvXrqVYsWJ06dIFAwMDWbX9/PPPlClTRvosMqNHj5Y+jxkzJttrkpKS+Pjx49eSlC3nzp2TemWeO3dOVi1/BWdnZ7Zt24arqyv58+fHycmJOXPmEB8fL/VUFgHRqtByw8TEhKNHj3Ls2DGCg4PRaDTUqFGDdu3aUahQIbnlafHu3Tvq16+vFUefL18+ypUrR2BgoIzKdJfChQtLleoAW7ZsETb2VWQOHDjA9evX+f333/nw4YO06Ve4cGEaNGhA/fr1qV+/PrVq1ZJZ6Z8YGBgQHx+f5XhcXJxwLR906T2lK6SlpWFtba11/4vI4cOHKVKkCIcPH5Yqp588eUKXLl04ePCgEMaPZ8+eUbduXRo1agSktyZSqVQ4OTkBUKRIESwsLKQUCLnx8vKiQIECrF+/niZNmgBw48YNvv/+ew4fPqwYP/4mK1as4N27dzRv3pyuXbsCcPDgQS5dusTKlStlbfGYmXbt2mm1o0hOTubBgwe8fftWmFZkGfTr1w8nJyfWrl2rdXzt2rWEhoZy48YNmZRps3XrVvT19SlRogSnTp1CX1+fpUuXMnfuXDw9PYUyfuiKibpMmTKUKlWK5s2byy0lTwQEBGTbOg201wfkxNDQkOrVq0sbapBuVK1Zs6a0GSwKbdu25caNG6Smpgpv+lH4ZwkLC2Po0KH8+OOP1KhRg+7du/Pp0yf09fXZtGmT7O3Udu7cSfHixaXPusLixYsJCQmRqv4hfS4YExPDsmXLhKn6j4uLo27dulpJz927d+fYsWPcvXtXRmXZU6JECe7du8eLFy+kQrTHjx8TGBgo/U4U8k5QUBB169aVCpDy5cvHrFmzePDggU6tsYpEUlJStns6qampQhbQKCgoKOgCivFDQadITU3F2NgYfX19LCwsCAwMpG/fvlhbW8u+qNa5c+dsP4tO5nYqmRkwYABv3ryRdSMrc9WhKBWIeWHChAno6+tLkc+lSpXi22+/pVKlSgwdOlRueTpLwYIF6dmzp9wyvkiVKlXw8fHhzJkzQHqvag8PD27fvi1MlYouEB4enuv5ggULEhMTQ0xMDFWqVPlKqnSbWbNmoVKpKFSoEE2bNpWMHhYWFsJVfGVgY2PDpUuXmD17trRJeejQIUJCQoTbaNGl95Su0LFjR86dO0dycrJwRp/MREZGYmtrqxWXX7FiRSwtLYUxUujp6ZGWlgakb1i8ePEClUpF/fr1pWuio6OF6UuflpZG7dq1JdMHQKNGjbC2tlYWVf8PXL9+ncqVK/PLL79Iz30HBwfatGnD1atXZVb3J8uXL89y7NOnT3Tv3l1q/SMnW7duZffu3dLfV69excHBQfo7LS2NyMhIihQpIoe8bHn69KnUgnLevHnUqlWLtm3bcuTIEWGeUxnoiol68uTJTJs2DV9fX+Gj3Tdt2sTKlSuzHNdoNKhUKmGMH7169WL79u2EhoZSrVo1IN2wEhAQwNixY2VWp0316tU5efIkXbp0wdbWFkNDQ63x9MSJE2VUp/BvsnTpUiIjI3n+/Dn37t0jOTkZOzs7rl27xoYNG2Q3fmQe22X+LDq6UvXv4OAgJWbmz58fgI8fPxIWFkbbtm1lVpeV7777js2bN9O6dWsqV65MamoqERERpKam0r17d7nl6SQZLXIzExUVJcQYVRepW7cu169fZ+HChUD6mHXSpEk8fPiQxo0by6xOQUFBQTdRjB8KOkW5cuXw9/fHx8cHa2trPDw8MDIyIiAgQDgXaEREBNu3bycgIAALCwvatGlDYmIiLVq0kFsanp6e3Lx5E0hf7Pnjjz/48ccfpfNpaWk8fPhQ2iAQgY8fP7Ju3TqCgoJITk7Ocn7fvn0yqMqefPnyMWnSJK1jovT4dXFxoX79+kycOFGrQiE7RPpOExIS2Lp1KwEBASQlJWnd7yqVih07dsioTpuxY8cyZswYxo0bh0ql4ubNm9y8eRONRiNc7KfI5HXRRKVScf/+/X9ZzX+LuLg4Ll++zOXLl7M9L9J3On78eH7//XcOHDjAgQMHgPT3Vr58+XJMrPqaTJo0CUtLSwYOHJjluf85olTSi07mjSl9fX3evXtH586dadKkCQUKFNC6VpRNlZIlSxIUFMSHDx8oVqwYkL74FxQURKlSpeQV9/9TuXJl/P39uX79OocOHQKgWLFi1KlTB0ivsM9orSQCXbt25dixY7x//16qRnz+/DlBQUHKIvX/geTkZEqWLKm1OalWqylZsiSvX7+WUdmXMTAwwNTUlCNHjnzxeftv061bN9zd3YmOjkalUpGQkJBtu682bdrIoC57DAwM+PTpE0+fPuXFixc4OzsD8Pr1a2EMXxmIbKK2s7PT+jspKYl+/fpRuHBhaQMQ0sdSV65c+drycmTHjh1oNBosLCyoVKmSsK3Tnj17RmpqKh07dqRKlSp8+vSJJ0+eoFarOX36NKdPn5aulXuuumDBAlQqFTExMTx8+FA6nmGmEWWMovDPExAQgKmpKf369cPFxYVy5cqxefNmXFxcePDggdzysnDq1Cm2bdvG48eP0dPTw9TUlOHDh2d5nsmNrlT9W1hYcO7cOTp06IC9vT3JyclcvHiRDx8+ULBgQWkuo1KphGhLO3bsWJ4+fcrp06e1nlWtWrUSZp1Sl7C1teXSpUsMGzaMJk2akJKSwuXLlwkPD8fe3l5ueTrJ1KlT6devH7/++iuQnvb+4MEDChUqxOTJk2VWp6CgoKCbKMYPBZ1i4MCBzJ49m8DAQFq1aoW7uztTp05Fo9HQtGlTueVJBAYGMmDAABISElCpVJQtW5Zr166xdetWXF1dadWqlaz6rK2tmTlzJikpKahUKiIjIzly5EiW6xo0aCCDuuyZPn063t7e2U74RKhUX7lyJaampnTo0CHbaqrMyLkI5O/vT4kSJaTPOSHCd5qZ2bNnc/z4cWH//TPj6OiIm5sb7u7uBAUFoa+vj5mZGcOGDRPC+KUr5HVxR6RFIF0gL9+XSN+pubk5+/btY9WqVfj6+qJWq7GysmLs2LHUrFlTbnmcOHGCpKQkBg4cyIkTJ3K8TqVSCWP88PT0pEyZMlne8cePHychIUH2TfWNGzdqPdc1Gg2hoaGEhYVpHRNpU6VNmzZs2bKF9u3b07JlSwDOnz9PdHS0lFQjN926dWPBggUMGTIESP9N9u/fH7VazdixYzl79iwqleqLptB/k8yb+SkpKXz48IHWrVtjY2NDSkoKt2/fRl9fX+j0F9ExMzPDz8+P48eP065dOwCOHj2Kn5+f1FJDBDw8PLT+Tk1N5eXLl5w9e1aIlgpGRkbs3r2b169fM3jwYGxsbLTMiCqVCmNjY6pXry6jSm0y/u0HDRqESqWiadOmLFq0iIcPHwo3PhXZRP327dtsj3/8+FGrTapo85O4uDhq1KjBwYMH5ZaSK56entLnR48eSZ/T0tK05q4ifL+dOnUSQkdeiImJ4enTp1I7R09PT+zs7KR1AYW/Rnx8PGXLliUpKYmgoCBat24NpLcq+vTpk8zqtNm1axc//fST1vzu1q1b+Pj4sHDhQmHGqaA7Vf+LFy8G0ov9njx5Avw5f87YuM6Yq4hg/MiXLx+rV68mPDxcq22ykpr695gyZQp37tzhypUrUlqeRqPByMiIKVOmyKxON6levTrHjh1jz549WmuovXv3FqaIQkFBQUHXUGlEWt1XUMgDFy5cwMTEhJo1a3LkyBG2bt1KhQoVmDVrFmXKlJFbHpDe6/nOnTvMnDmTuXPn4ujoSIcOHZg4cSLVq1fn8OHDckvkt99+IywsDHd3dypXrixNViG98s/Y2Ji2bdtibGwso8o/qVOnDhqNhuHDh2NiYpKlSknu9jrm5uY4Ojqybt06zM3Ns10Eypj8BQUFyaAwnSNHjlCmTBkaNmyYrdknM3J/p5lp3Lgx0dHR9OjRg+rVq6Ovr+1blHujMjMvXrygQIECWe6diIgIEhISZK9UVFBQ+OdYt24dVatWpW3btqxduzbXDQBRYtTNzc1xcnLSavGm0WhwcXEhLCwMHx8fGdXBtGnT8ryR8vPPP//LavJGYmIiQ4cOxdfXF5VKJS3+WlhYsHPnTmGq6detW8fu3btJS0ujR48ektFiwoQJnDlzhhEjRsgapZ/X96PcYyld5vTp09JmekY6QVJSEpBuYhYloSK3sXSHDh1YunSpDKqy59atWxQvXhwzMzO5peSKj48Pw4cPJyEhgWbNmuHm5iYZ63ft2iXc+PTy5cu4ubkJZ6K+detWnq8VqcXCpEmT+OOPPzh16pTcUnLlS/PTzIg0VxWZR48eMWDAAGxtbVm9ejWQ3krR0NCQrVu38u2338qsUPdwdnYmJiaGNm3asHfvXhYuXMg333zD2LFjqVat2l/6Hf/btGzZksjISIYPH46TkxNqtZqzZ8/yyy+/UL58eby9veWWKPHo0SP69u1LdHQ0gDSmLlSoEL/++is1atSQWWE6ujhXgfTkPD8/P1QqFTY2NpQtW1ZuSTrLq1ev2L17t5aRpnfv3pQuXVpuaTqJ6IUpCgoKCrqIYvxQUPgXqF27NnXq1GHbtm1ahoB+/fpx9+7dXJMWvjaZN61EpmXLllSuXJmtW7fKLSVbpk2bhoWFBX379v3iRFCkyZ+u0LhxY6pVq8auXbvklvJFsttUBejbty9PnjzJsb2GgoJC9jx79oy7d+9Km5OZ6dSp09cXpIO4ublJi/0ZJsTsKFq0KL///vvXlPafIS0tjTNnzkjJNNbW1rRq1SrbyGrRCA0NpUSJEhQtWlRWHevWrcvztaIYqXSR/fv3s2LFCmljpUiRIowaNYqBAwfKKywT/fr1y3LM0NAQS0tLhgwZIoyZKgORW3xm5sOHD7x+/RozMzNUKhUBAQGUKlVKiOKJ77//nm+//Zbx48fnuAEgGj4+PhQvXhxTU1Ot47du3ZIMNnKSOTknOjqadevWUbduXZo3b56ldVrPnj2/trxsefDggdBGhPDwcAoVKkSpUqUIDw/P9VpRqumHDRvGlStX6Ny5Mz///DPJycmMHTuWixcv0rx5c9zc3OSWqHO4ubnh6uoKpLfNO336NLNmzeLMmTMsWLBAqE1Ka2tratasyd69e7WO9+7dm6CgIO7cuSOTsux5/fq18FX/qampQqSP/RWWL1/Otm3bpHbeenp6DBkyRIhEkv8Suc2zFXJG9MIUBQUFBV1EMX4o6BQajYaTJ09y+/ZtEhIStOIKVSoVP/30k4zq/qRBgwYYGxvj5eVFjRo1cHR0ZMWKFTg7O5OcnMz169dl1aeLCxYHDhxg0aJFLFiwgGbNmmVZrFJiv/8e586dIygoiOTkZK3josRSZrBq1So8PT3x8vKiUKFCcsvJwp49e6QKuuwqPzPiiQ0MDIRbXNEF+vfvn+M5lUrFjh07vqIaha/J/v37mT9/PqmpqdmeF63qPzg4mODg4GxNKnJuqiQlJeHs7MzLly+1Eikyo1ar+eGHH2TfUHdwcMDOzo558+bJqkNB4b9McnIyISEhqNVqqlatqoyj/w983uLTwcFBMquL0OJTV7C2tsbW1pbNmzfnaKIWjdzM3mFhYbLP+T9Pzsl492e3KSXKeKpGjRqYm5vTuXNn2rVrJ0z6aAYZaztr167NMZkI0r/j+/fvf2V12VO/fn3Kly+fJXW2e/fuPHnyhJs3b8qkTLfZt28fERERdO3aFVNTU3bu3IlKpcrWuCgnI0eO5PHjx5w8eVL6vSYnJ9O6dWssLCxYs2aNzAp1jyZNmtC+fXs6deokXFpWdnh4eDBnzhzUarVkVAwJCUGj0TBv3jx69Oghs0LdIiUlhX379hEaGkpSUpL0bo2Pj8ff359Lly7JrFA3UApTFBQUFP5d9L98iYKCOCxdupTt27cDZNm0EMn40bJlSzw9PaX40cDAQNq1a8erV6+EqE5u27attGCRW9KHSAsWVlZW5M+fn//9739Zzomg80sGmsyIYqZZuXIlmzZtynJcpH6kGajVahISEnB2dsbCwoKCBQtqTQxWrFghozpwdHRk2bJl0qL/+/fvs42CFq3yU1fILVZbqaj4b7Nt2zZSUlIoXrw4FSpUyNLmSSR27Ngh9XzODjmNH/nz5+fw4cN8/PgRZ2dnmjRpwpw5c6TzKpWKYsWKUaRIEdk0ZvD8+XPevXsnt4wvktEmJS/I/Y7SRTw9PXM9L8J4WpfJly8fNWvWlFtGjuRkABsyZAiRkZF4eXnJpCwry5Yt49OnT8ydO5e5c+cC6fMWtVqNm5ubMMaP3CLyRZhLFShQgBs3btCtWzcgfezn4uKS7bX79u37mtK02Lp1K7t375b+vnr1Kg4ODtLfaWlpREZGCvE+tbW1lVvCX6ZQoUIEBQURHBzM0qVLadq0KZ06daJFixZCJGhpNBqtdaic6uhEqq9LTk7ONp0gNTU1W6OyQt74/PmUW6HC1yZz2o+FhQVXrlxhwIABtGzZkk+fPnH69GliY2OFae+WQW7fYb58+ShZsiROTk60bNnyK6rKyrt379ixYwc7duygevXqdO7cmfbt2/PNN9/Iqisndu3aRf78+dmxYwe1a9cG4M6dOwwYMIBdu3Ypxo+/yNKlS9m1a5e0bpr5ef95S3KFnBk0aBD79u37YmFK3759ZVCnoKCgoPsoiR8KOkWDBg2IiYnBycmJypUrZxlUjR8/Xh5hn/Hx40eGDRuWpaWLhYUFGzdulL1yJXP7mS851IODg7+Sqtzp0qVLrguScuvMa79RERZWM2jQoAHR0dE0bNgQExOTLPeTSC1pcvudqlQqIarUbty4wbNnz5g1a5bU4zMDtVqNsbExjRs3Jn/+/DKq1E0OHDig9XdycjKBgYF4e3uzYMEC4VtVKfx96tSpQ6lSpfD09MTQ0FBuOblib2/PmzdvqFixIqVKlcpiShKlVdXz588xNDTMdiwiQjxt5jGKyOS1wk+Ud5SukVslNYhTna7wz+Ht7S2N57NrRZmWlsa+ffuIi4sjICBALplZ0JUWn6LP+ebPn8+ePXsActwAyDgn5/2fsRYRHR2dq84ePXowf/78r6xO9/n06RPXr1/n5MmTnDt3jo8fP6JSqTAyMqJdu3Z07NgRKysruWXqFP369cPX15fu3btjb29PSkoKFy9e5OjRo9SrV0+Y8akukZCQwNatWwkICNCq+Acx0ii/lPaT8bdarRZmbQr+1J1dkV/m/4f58+fL2k4nMDCQkydPcubMGZ4/fw6Avr4+dnZ2dOrUiZYtWwqVpGZlZYWNjY1URJnBgAEDuHPnDoGBgfII01GaNWvGx48fGT16NMuWLWPChAlERERw6NAhpk+fLpQJTHSioqJ0ojBFQUFBQRdRjB8KOoWtrS3VqlWTtcrnr3Djxg3u37+Pvr4+1atXp1GjRnJL0lmsra0xMjJi1apV2ZoUypUrJ5OydP5KxKPcC6sZ1K9fn2+//VYnFnvWrl2b6waQ3K0JMnPkyBHKlClDw4YN5Zbyn2f48OEULlyYlStXyi1F51i4cCF169YVrtLrc4YMGUJsbKxW5Zqo1KlTB1NT0yxGJdEQPZ7W3NycypUrf7FKXu5kqr9iTBHpHaUr9OrVS2uDIjk5mYiICDQaDa1atRLKnKrwz3D37t0vVp1qNBosLCw4ePDgV1L1ZURv8ZnBkydPpM8Z91RgYCArVqzAzc1N9s10jUbDjRs3eP36NdOmTaNmzZo5tkzISNWUi5CQEF6/fs3gwYOxsbFhzJgx0jmVSoWxsTHVq1eXUWHO+Pr64uvri0qlwtbWFhsbG7kl5UhKSgrnzp3jp59+4tWrV9I7wdramlWrVlGmTBmZFeoGfn5+DBw4kE+fPknHNBoNBgYGbNu2jXr16smoTjeZMmUKx48fz9b4Jbc5DfhL7WZEWgu6dOkSkyZNwt7enu+++w5IT4C7du0aM2bMICkpicWLF1OlShWOHj0qs9p07t69y6lTp/jtt9+kxMIiRYrQq1cvRo8eLURSkb29PWq1mjNnzkhFSImJiTg7O6PRaLh8+bLMCnULCwsLGjVqxKZNm+jQoQNjxozBycmJzp07o9FovphaqJCV3ApTFBQUFBT+HuLmZSsoZEPHjh05d+4cycnJQjmoP+fHH3/EwsKCPn36aJk9li5dSnR0NIsWLZJRnTZdu3bF1taWadOmyS0lV2rWrIlarRZ2YUIUM8dfoXPnzpw4cYKnT59SoUIFueXkSuYFVRG5evUqJUqUwNzcnJIlS5KSksLVq1ezvdbOzu4rq/tvc/HiRbkl6CSHDx/m/v37whs/hg0bxtixY5k7dy6NGzfG0NBQywQm0v3k7OyMj48PHz9+FLoyRRfiaSMiIrJtRZaBCC3JFDPHv8vevXuzHIuJiaFbt26YmZnJoEjh38bS0pLx48cTEhLCsWPHKF26tFarioz0NDnbZmWH6C0+M6hYsWKWY2ZmZty4cYPFixdLaRtyoVKpaNy4MQDPnj3LkvgiEqamppiamrJz506KFy+uE8+k1NRUpkyZwsmTJ7WOt23blmXLlgnz/of01I8rV67g5eXF+fPniY+PB8DExISoqCj8/f2ZNWsWmzdvllXn27dvWblyZY6pD97e3jKq+xMbGxv27dvHli1bCA4ORqPRUKNGDQYPHkytWrXklqeTXLt2DbVaTY8ePahevbpwrShFMnP8FbZu3UqZMmVYtWqVdMzBwYHvvvsOb29v3NzcOHXqlDAJFdHR0QQHB/PHH3/w/v176RkQExPDxo0b+fDhQ5aWdXLQokUL9u/fj4uLizT39/Ly4vXr17Imp+gqRkZGUtJLrVq1uHHjBk5OTqhUKh4/fiyvOB2lXLly3L9/n4kTJ3L79m0gvfB38uTJQremVFBQUBAZJfFDQXgyV3InJyezZ88eKlSoQJMmTShQoIDWtRMnTvza8iRCQkJ4//49kO6wr1u3rlbrmdTUVObPn8+LFy+EifyF9NQHc3Nzdu7cKbeUXLl8+TLjxo2jY8eO2NnZZfm3F2nzLzdCQ0OpVq2a3DKA9Fi9Nm3akJiYSOXKlbO0URAtWefhw4dShXoGcXFx3L59W/bEB3Nzc5ycnFi7dm2u8fQitfrRJSZNmqT1d2pqKi9fviQgIIBvvvkmR5ONQs6MHDmSe/fuceTIEUqWLCm3nBzRpfvp/fv3tG7dGn19faytrbM8U1esWCGTMm1Ej6c1NzenbNmyNGjQ4IvXipL6kFtlV758+ShRogS1a9cW2rSsK0ybNo1bt25x/vx5uaXoJLpi+P7xxx9zTXwQCdFbfOZGfHw8ffr0ISwsTKj2OZD+TlWr1RQtWpQrV65w5coVmjRpQrNmzeSWpsWFCxeyTdC6ffu2UGllbm5uuLq6YmhoKKUS/v777yQmJjJhwgSGDx8us8J0pk+fjre3Nx8/fkSj0ZAvXz4cHR3p2rUrjRs35vXr1/Tq1YsPHz7g5+cnq9bvv/+eixcvCpv6oPDv0bhxY6pVq6YTBosXL17ker5s2bJfScmXsbKyombNmlnWoVxcXAgKCiIgIIABAwbg5+fH3bt3ZVKZPu738vLi+vXrpKamotFoMDExoVOnTnTp0oWgoCCmT59O/vz5uXHjhmw6M/jw4QMuLi48fvxYK02vXLlyHDhwQOhxioiMHTuWs2fPMmbMGMqUKcOMGTOoUKECT548oUyZMsoc5W8QHBxMr169SEhI0DpuaGjI3r17/1LCtoKCgoJCOmLZkhUUsmHjxo1Z+lOGhoYSFhamdUylUslq/Hj48KHW5qSfn1+WzZOMwbVI9OrVi507d3Ly5Enq1atHkSJFtCp+RNmkGD58OCqVCg8PjyyLaKJt/r169YpFixZluwgYHR0tjNbZs2cTHR0NwIMHD7TO5dZWRQ48PDyYO3dujuflNn6ULVuW4sWLS58V/llOnDiR47m+fft+RSX/HfLnz8+7d+9o0aIF5cuXp0iRIujp6UnnRTF+6dL9tGLFCumZ+vmCj0qlEsb48e7dOxo1asTgwYPx9PSkSpUqDB8+nPv373P48GHZjR+QnvIliqkjL0ybNu2L782SJUuyefNmYeP/ReNzQ1+G4e/ChQtaBlCFv8bTp08pVKiQ3DK+SMb9HxUVlWUs7ePjQ69eveSUp4Wenh779u0TvsXn5yb5tLQ0Pn78SEpKCpUqVZJJVfb4+/szZMgQFixYQLVq1Rg+fDgajYZdu3bh6uqKs7Oz3BIBWL9+/V9q+yUnhw8fpkiRIhw+fFhKenzy5AldunTh4MGDwhg/Dh8+DECNGjXo2rUr7du3p2jRotJ5ExMTLCws+P333+WSKHH79m0MDAwYO3Ys1atXF6KlQwYeHh6UL1+eJk2afNGAJFqKki7QvXt3PD09iYuLE/6d6uDgkOM50dbRSpUqRUBAACtWrKBVq1ZoNBrOnDmDv78/5cqV49KlS9y6dUv2NdUM86y+vj5OTk507dpVaqcCUKlSJY4fP861a9fklClRrFgxDh8+zN69e/H19UWtVmNtbU3Pnj21nq8KeWP69Ok8f/6cMmXK0KZNG3bu3CkZ/YYNGyazOt1k1apVJCQk4OLiIrV9zFj7d3V1xc3NTWaFCgoKCrqHYvxQEJ5OnToJtwmdHW3btuXQoUNSz998+fJRrFgx6bxaraZ48eLCRYMfO3aMpKSkbE0zIk0EdWnzb+HChZw9ezbbc5UrV/66YnLhypUrGBoaMmzYMExMTISK+P2cHTt2oFKpaNq0KRcvXqRVq1aEh4fz6NEjIRYqM2/yKg7/f57snpsFChTA0tIyT6kAClk5ffo0kN4//fNIUpHeubp0P504cQJ9fX06duwo9DNViaf95xk0aBAHDhxApVJJrSlu3rxJWloazZs35/nz5wQGBrJixQrc3d1lVqsbDB06NNtnkUajoXnz5l9f0H8EXTF8+/r6MnbsWClN8XNEMn60b98ea2trVq5cKZzZIzNv377N9rihoaFwCTArV64kPj6ejx8/cuTIETQaDT179uTQoUNs3rxZGOPHkSNHMDAwoHv37uzevZu+ffsSFhbG9evXZS1IyY7IyEhsbW212ntWrFgRS0tLfH19ZVSmTd++fenWrVuu1b3jxo1j+vTpX1FV9hQsWJCaNWsydOhQuaVkYc6cOTg5OdGkSRPmzJmT69heMX78ddRqNQkJCTg7O2NhYUHBggW1vmNRzN5Atok0kF4E8M0333xlNbkzcuRIZs6cyebNm7O0cho2bBghISFoNBpatWolk8J0zMzM6Nq1Kx07dpSKfz6nXbt2fPfdd19ZWfbEx8dTsGBBhgwZwpAhQ7TOBQYGYmVlJZMy3eHo0aOULVuWevXqUbp0aQ4dOiS1oP/111+5du0aFSpUoEaNGnJL1Ul8fX0xNzfXKvabN28e/v7++Pj4yCdMQUFBQYdRjB8KwrN48WK5JeSZLVu2AOm9nu3s7Jg/f77Mir5MbtGPInWC0qXNv1u3blG6dGnWrVtH7969Wb9+PVFRUUyfPl2YyR9A6dKlKVu2LD/88IPcUr7I8+fPqVu3Lm5ubrRs2RIXFxfq1q1LmzZthOnxmpmYmBiePn0q9U329PTEzs6OEiVKyKxMN8nO+JGR9KTw99ClNAVdoVixYlSqVIlFixbJLSVX6tWrx9mzZ9mwYQP169dnxowZXLt2TYqnlZuyZcvqXOSwWq1GX1+fY8eOSa2TXrx4QadOnTAzM2PVqlW0a9eOO3fuyKxUd8jO8GtoaIilpSWTJ0+WQdF/A10xfC9fvpyoqCiKFi1KdHQ0JiYmvH//nuTkZFq3bi23PC3i4uJ48+aN3DK+SHZtPQsUKICpqSkFCxaUQVHOBAcHY2lpSc+ePenYsSNVq1Zl3rx5hIeHC9U+49WrV9ja2jJr1iyuXr2Kvb09M2fOpHXr1pw/f14Ic3oGJUuWJCgoiA8fPkjFKVFRUQQFBVGqVCl5xWVi5syZX7xGlLapAwcOxM3NjZcvX1K6dGm55Whha2uLqamp9Fnhn+WXX36RPl+8eFHrnEgpfwB//PGH9Fmj0ZCcnExgYCATJkzINVFVDrp160bJkiVxd3cnNDSU1NRUzMzMGDx4ME5OThw6dIgxY8YwcuRIWXUeO3bsi9eINFbp378/W7Zs0Ur3ePXqFcuWLePkyZNavxGF7Fm0aBG1a9emXr161KhRA0dHR9auXQtAoUKFZDcj/RfInz9/no4pKCgoKOQNxfihoHMkJydz7NgxQkJCUKlUVK9enbZt2wpToQZ/mhQSExO5f/8+KpWKmjVrCjlo8fb2VjZP/2Hi4+OxsrLCwsKCmjVr8u7dOzp16sShQ4f47bffGDNmjNwSAZg0aRJTp07Fy8sLe3v7LL9Pke4pAwMDUlJSgPSe6Xfu3KFx48ZUrFhRuInqo0ePGDBgALa2tqxevRqA+fPnY2hoyNatW/n2229lVqibbNiwgeTkZMaPHw9Aly5daNGiBWPHjpVXmI7SuXNnuSX85xg2bBiurq7CV07NmDFD6HhaXTJ6ZnDw4EFq1qwpmT4g3bhQq1Ytdu/ezQ8//EC5cuUIDw+XUaVusWPHDq3KdIV/Bl0xfD98+JBvv/2WQ4cO0aRJE9auXUuxYsXo0qWLUO0UAMaMGcPSpUvZvHlztikqVapUkVHdn+zcuRMbGxsGDx4st5Qv8unTJ8n08+jRI2nMItJvFNITHz58+ACkz098fX1p1qwZxsbGBAcHyyvuM9q0acOWLVto3749LVu2BNLft9HR0XTt2lVWbXmtkBbJnAbprVLT0tJo1aoVlSpVypL6IGfbxF27dmX7WeGfYdSoUTqzhpa5lSektydp2LAhzZo1Y9WqVTRt2lQmZdnTrFkzmjVrlu05OZ9VeW2FqVKp2LFjx7+s5q9x7949evfuzdatWylatCibN29my5YtJCQkULhwYbnl6QQJCQkEBQWxe/duNBoNz549y7GNlpKi9NepVasWPj4+uLu7S/f5wYMHCQwMpGHDhjKrU1BQUNBNFOOHgk4RGhrKsGHDiIyMBP6s+F6/fj2bNm0Sqo3Gvn37WLZsGfHx8UC6C3jKlCnCDQLHjRuHra2tcBG/n5PbgpBoi0AlSpQgKCiIV69eYWlpycmTJ2nUqBHPnj0jKipKbnkSK1asIC0tjUmTJmU5J9p3Wr16dfz9/Tl8+DA2Nja4ubkRGRnJrVu3hOtLunTpUqKioqTqyeTkZOrXr8/FixdZtWqV0p/yb7Bx40bWrFkjVawlJiYSFBREcHAwBQoUEKqiUpfw9fVl48aNBAQEUL9+fTp06MDr16/p06eP3NJ0krNnz/Lp0yd69uxJ4cKFtcx0KpWKK1euyKjuT0xMTJR42n+YtLQ07t69S0hIiFRh++jRIymR6vHjxwQGBlKkSBE5ZeoUvXr1okqVKsqG1T/MuXPn5JaQJ1JTUzE2NkZfXx8LCwsCAwPp27cv1tbW3LhxQ255WixYsCDHCm+RxtM3btwgOjpaJ4wf5cuXx8/PjxkzZqDRaGjSpAkHDhzAz88PS0tLueVJWFhYcP36dbZv3069evVYsmQJ9+7dw8/PT8sIKAJjxowhICAAX19f9u/fL5loLCwsGDVqlKza8mroEc34c+TIEenzo0ePtM6JZgpIS0vj5cuXJCUlZTknijlNlxClkCcvJCcna/2dlpZGZGQkd+7ckdZVReLhw4eEhoZq/Vbj4uLw9fVl1apVsum6detWlmMqlSrLc0m0ex+gRYsWXLhwARcXFzQaDS9fvkRfX59evXrp1G9ZTmrWrIm/vz8LFy5EpVIRHBycY2KOaGv+usCoUaMYNGgQrq6uuLq6SsfVajUjRoyQT5iCgoKCDqMYPxR0innz5vHixQsqVKggucCvXLlCREQE8+bNY9u2bTIrTOfMmTPSILBw4cJoNBpiY2OZO3cuxsbGODk5ySswE0+fPqVQoUJyy/giuS30iLYI5OzszPbt2zlw4AB2dnaMGDFC6kcv0qZaREREjudE+04nTpzIsGHDSExMpG3btvzyyy8cPHgQQJg+3xkEBARQs2ZNqZVGvnz5cHNzo3v37krM/9/kwIEDFClSRIr3L1CgAAcPHmTw4MEcOnRIMX78DS5fvsz3339PamqqtGh1+/ZtduzYgZ6eHi4uLrJpi42N1cnqo8ybkR8/fuTjx4/S3yIuAmakOinxtP93HB0dOXLkCJ06daJy5cpoNBoiIiJITU2lffv2XLt2jffv30tjAYUvo1KppKQvhX+OcuXKAZCSkkJoaChqtZqqVatmqQiWm3Llykl9va2trfHw8MDIyIiAgADhxqiQ87hZJK3Ozs6cO3dO+FQqgH79+jF79my8vb2pUKECLVq0YMaMGaSlpTF06FC55UlMnTqVoUOHUqhQIZydndm0aZM0FujevbvM6rQpUKAAO3fu5OzZs/j4+KBWq7G2tqZVq1ayp+icOXNG6++5c+dy48YNTp8+LZOivKErbRN///13JkyYIKXTZEYkc5ro5FTdnx0ibfxaW1vneM7c3PwrKvkyHh4eubafkdP4sWDBAq2/9+zZQ3BwcJbjIrJhwwYWLVrEr7/+ikqlwtramsWLFyumr7/A4sWLWbduHW/evOHmzZsUK1YMMzMzuWX9Z2jQoAHu7u4sWbKEkJAQACpXrszEiRNp1KiRzOoUFBQUdBOVRqTVCAWFL2BlZUWJEiU4ceIEhoaGACQlJdG2bVvevn1LQECAzArT6dq1K8HBwSxfvpw2bdoA4OXlxeTJk6lVqxYHDhyQWeGfrFq1ip07d/LTTz9lG08sSruPJ0+eSJ8z9yZdsWIFbm5uQi1gfvr0iZUrV0oRmjNmzODQoUMULVqU9evXU69ePbklAvD8+fNcz2dsDojC27dvSU1NxcTEhKCgIA4dOkT58uXp06eP7AuWmalduzZmZmZZ7vMuXboQFhaGv7+/PMJ0GEtLS+rXr8+WLVu0jg8ZMgQfHx+pql4h73Tr1o3Q0FDWrFnDsGHDcHR0ZMCAAQwfPpzSpUtz8uRJ2bQ5OTlhamrKL7/8wo8//kitWrXo27evbHrySnaVYJmpX7/+V1Ki8LWJjY1lxowZWTapWrZsyZIlS9iyZQvHjx9n48aNVK1aVSaVusW2bdtYsWIF3bt3p169ehQuXFjLnGBnZyejOt3Gzc2NrVu38vHjRxwcHGjUqBE3b95k+fLlwoz79+/fz+zZs5kyZQpNmjSha9eupKWlodFoaNq0KRs3bpRbos7Rp08f7ty5g0ajwcDAgMKFC0tzPpFSqTLIKO5wdnamZMmSHD16lEKFCuHg4CC3NC2Sk5NJTEzEyMiIly9fcvLkSSpUqICjo6Pc0rIls7k2PDxcyI2/UaNGcf78eakNncL/jXbt2kkbadkhWlsiUTE3N8+zkVuk325O5o6yZcuyatWqXI0hX5u2bdvy+PFjmjZtysWLF2nVqhXh4eE8evSI4cOHM3HiRLklSoj+nLp69WqWYzt37uTy5csUKlSIOXPmYGxsDChj6r9KgwYNcHZ2Zv78+XJL+c/g6+uLlZUV+fLlIzo6GrVarSRlKigoKPwfURI/FHSKsmXLUrJkScn0AZA/f35MTEyEWagECAkJwcbGRjJ9QPokZu/evcKYUzI4duwYSUlJ2U6iRKoAqVixYpZjZmZm3Lhxg8WLF7Nnzx4ZVGWPgYEBU6dOlf5etGgRkydPpmjRolqmGrnJzdgRGhr6FZXkjRIlSkifa9SowcyZM2VUkzOWlpb4+voye/Zs7O3tSUlJ4eLFiwQFBQlj+tE1SpQowb1793jx4gVly5YF/mydULx4cZnV6SYPHz7E1tYWe3t76ZitrS1WVlayJ9NERkZibGxMQkICR44cISYmhh49emR7rUjv/tyMHZnTPxT+exQuXJjVq1fz9OlTQkJCSE1NxczMjEqVKgEwfPhwxo8fL69IHWPJkiWoVCr27dvHvn37tM6JND7VNbZt24arq6vWXOrRo0ecOXOGFStW8OOPP8qo7k969OhByZIlMTExwdzcnIULF7J161YqVKjArFmz5JaXJxISEvDx8aFp06ZySwHg9u3b0ufk5GSt9pMiplLZ29trjVE6dOggo5qcyZcvH69eveL27duo1WqcnJwoX7683LKyEBMTw9ixYylTpoyUVNGvXz8qV67MunXrKFasmLwCdQQPDw/Kly9PkyZNvpgAIUrqw5MnT6hQoQK7du3CxMREyPtdF8hoOapreHt7Z/k3NzQ0lDb9ReL58+fUrVsXNzc3WrZsiYuLC3Xr1qVNmzZKocdfZOjQodne6yqVivj4eGm9UhlT/3UKFSqkzO3/YUaNGkWZMmXw9PQUrpW3goKCgq6iGD8UdIqJEycyadIk9u/fT6tWrfj06ROenp4EBgayZs0arf6Vcm4GFSxYkNevX5OWliZt9KempvLq1Svh4utfvHiR4znRA4Hi4+MJDQ0lLCxMbilZCA4OJjg4ONs+uqIsAr169YpFixZJPVQz/r3j4+OJjo4WagL48uVLFi5cSFBQUJbvVLQqxQkTJjBw4EAOHDggpX5kVFeOGzdOZnW6yXfffcfmzZtp3bo1lStXJjU1VWqjIFqUtq5gZGREeHg4iYmJ0rGoqCgePnwou5mmZMmSBAYGYmNjA8D58+ezrUYTbaEqNjaW9evXZ/tMDQkJUdJ+/ia+vr74+/trfacZjB49WiZV2aNWq4mNjUWlUmklURUsWFBGVbpJhslP4Z9l7969lCxZkuPHj9OgQQMAxo4di7e3NydPnhTG+AHpPekz6Ny5M507d5ZRTc6EhITwv//9j7CwsGzH/aJUA+/cuVNuCXnm7du3rFy5koCAgCzPfpVKhbe3t4zq/iQ2NpZZs2Zx6tQprePfffcd8+fPF+rZv2zZMn7//Xdp8zoxMVFq87dy5UqlcjmPzJkzBycnJ5o0acKcOXNyNVGIMue3trYmISGB0qVLyy1Fp9m1a5fcEv4W48aNw9bWlmnTpskt5YsYGBhIbf4sLCy4c+cOjRs3pmLFivzxxx8yq9MtlHH0v0dCQgJv376VW8Z/CiMjI/T1lS1KBQUFhX8S5amqoFMsWbIEPT095syZw5w5c7TOjRo1Svos92ZQ48aN8fLyYuTIkXTq1AmAI0eO8PTpU9q2bSubruw4d+6c3BLyxOfxg2lpaXz8+JGUlBSpolYUduzYweLFi3M8L8oi0MKFCzl79my25ypXrvx1xXyBqVOncvPmzWzPiVa1ZGNjw759+9iyZQvBwcFoNBpq1KjB4MGDqVWrltzydJKxY8fy9OlTTp8+zcOHD6XjrVq1Uqro/ybt2rVj+/btODo6olKpuHXrFs7OzsTGxtKvXz9Ztf3www/MmzePlJQUVCpVjiZE0cyJixYtwtPTE41Gk0W3aKZPgJSUFEJDQ1Gr1VStWlWrjYYorF+/nnXr1mU5nvEdi2T8WL58Odu2bSMtLQ0APT09hgwZwoQJE2RWppucP39ebgn/SV68eEHDhg21qumMjY0xNTXFz89PRmXpvH37luPHj9OmTRtMTEx48eIFK1euJDg4mNKlSzNs2DDJsCIKP/30U47zTpEqxHWp3disWbO4ePFitu95kcb9Cxcu5OTJk+jp6UltvMLDwzlx4gT58uXjp59+klnhn1y4cIFy5crh5uYGQIECBfD29qZ9+/ZcvHhRVm2fJ2dktCPdv39/lt+A3PNoW1tbTE1Npc+6wLx583BxcWHIkCHY29trJT6B/N+pwr/L06dPKVSokNwy8kT16tXx9/fn8OHD2NjY4ObmRmRkJLdu3ZI9BSA8PFzr7/j4eCA9hfTz55QILbSUcfS/x+jRo1m6dCmbN2/Otl26CP/+ukaXLl1Yu3Ytw4cPz7bFp/KeUlBQUPjrqDSirZorKORCTv0ps0POXqXPnz+nW7duvH//Xlqc0mg0GBkZcejQISpUqCCbtpwQfQMop397Q0NDVq1aRfPmzb+uoFywt7fnzZs3VKxYkVKlSmVZoBSlWqRBgwYYGhqybt06evfuzfr164mKimL69OmMHDmSMWPGyC1RwtramgIFCjB9+nRMTEyytMzRpcVshb9PeHi4lplGmVT/fZKTk5k6dSonT57UOt6qVSuWLFmSZVH4a5OYmEhUVBQtW7akSZMmOVai5tay6mvTpEkT0tLSmDt3LpMmTWLBggVERkayZs0apk2bxsCBA+WWKOHm5sbWrVv5+PEjDg4ONGrUiJs3b7J8+XKh2uc4Ojry7NkzzMzMMDU1zVIJtGzZMpmUaePh4cGcOXNQq9XShlBISAgajYZ58+bl2KpIQZvk5GT09PTQ09PTSvHLDpF+p7qEs7Mz7969Y8eOHXTt2pXmzZvTt29fvv/+eypUqICXl5ds2h4/foyLiwvR0dF4eHhgZmZGu3btePHihbSpoq+vz/bt24VqnVevXj2++eYb9u3bh4ODA7/++ivx8fEMHjyYHj16yNqacNKkSVhaWjJw4EAmTZqU67UrVqz4Sqq+TP369UlMTGTs2LFUr15dK0EJoFGjRjIp08bGxgY9PT327NmDmZkZAGFhYbi4uJCamqrVXkduLC0tqVu3Ltu3b9c63r9/f/z9/WVto2Bubp5lvpxh8PwcURJ0dImdO3fy008/5WiaUr7T/zarVq2SfgPZbVKLNJ7y9fVl2LBhTJkyBUdHR9q3b090dDQALi4uzJ07VzZtNWrUyNN1chchKvz7ZPfOykD59/97ZHynyrtfQUFB4Z9DSfxQ0Cl0JZ2iXLly/Pbbb7i5ueHr64tarcbKyophw4YJafrQhQ2g7OKJCxQogKmpqVAxupAe+2tpaSm1+RCV+Ph4rKyssLCwoGbNmrx7945OnTpx6NAhfvvtN6GMH2XKlMHExISOHTvKLSVPhISEYGRkRKlSpfDw8ODy5cvY2dnRq1cvuaXpNFWqVKFKlSokJSURHh5OcnKyMM8oXSNfvnysWrWKCRMmcP/+ffT19alevToVK1aUWxqQ/nwvW7YsO3fupHjx4kIZPHIiOjqaxo0b4+zszMaNG8mXLx8//PADly9fZv/+/cIYP7Zt24arq6uWuefRo0ecOXOGFStWCNXq4d27d5ibm3PkyBGhqrw/Z9euXeTPn58dO3ZQu3ZtAO7cucOAAQPYtWuXYvzII9bW1jg6OrJ27dps2ztloCyq/n2GDBnC7Nmz6datGyqVikuXLnHp0iU0Gg19+vSRVdvq1av58OEDlSpVonjx4hw9epTnz59jYGDAjBkziIiIYNu2bWzatEko40dSUhLly5enePHi1KpVi3v37tGjRw/q1auHt7e3rMaPEydOkJSUxMCBAzlx4kSO16lUKqGMHwULFqRmzZoMHTpUbim5YmhoSPXq1SXTB0DVqlWpWbMmISEhMirLSqVKlfD19eXEiRPY2dmRmprKhQsXuH37tuxGal1Jzvic/v37U69ePcaOHat1fOrUqbx584atW7fKpEwbd3d3ACpWrEjJkiWFHk8p/PMcO3aMpKQkJk6cmOWcaOOpevXqcfbsWVJTUylVqhTbt2/n0KFDlC9fXvYxSl5rZkWsrc3NtCLab0BX0JVEUl1BV8cBCgoKCiKjGD8UdIrsNn4+fvxIkSJFZFCTM1u2bMHW1pbZs2fLLeWL6MoGUOZEh9jYWPT09GSvSM8JZ2dnfHx8hPxtZqZEiRIEBQXx6tUrLC0tOXnyJI0aNeLZs2dERUXJLU+L//3vf4wfPx43NzeaNWtGgQIFtM7LvWCZmYsXLzJ69GgWLVpE+fLlpbZU58+fR6VS4eLiIrNC3SMuLk7aqLK0tKRLly48ffqUMmXKsGPHDiENdaKTUYns4OAgjNkjO+rXr8/9+/cZOHCgVDlra2vLlClT8lx59bUoVqwYoaGhJCYmYmFhwYULF2jVqhUxMTG8ePFCbnkSe/fupWTJkhw/flxqmTB27Fi8vb05efKkMO99gGbNmhEWFib8JsWTJ0+wsbGRTB8AderUoU6dOty5c0c+YTqGRqORFkxzWzhVFlX/Pj169CA1NRU3NzdevXoFgImJCcOHD5d9U8XHxwcTExOOHTtGvnz58Pb2RqVS4ejoKI2dLl++LGsyQXaULl2ae/fu8fDhQ6ysrDhy5AjVqlXjwYMHUhS8XIwePVpqQTJq1Cjhn6UZDBw4EDc3N16+fEnp0qXllpMjvXr1Yvv27YSGhlKtWjUAAgICCAgIyGIGkJtBgwYxY8YMJk+erHVco9EwYMAAmVSlI0oaZl7w8fGRWtHcunWL2NhYrXF0amoqPj4+vHv3Ti6JWUhOTtaJohSFf4fc5iAijqdKlCghfa5Ro4as5snMyJko/X9FGVP/s+jyb0FUdGkcoKCgoKArKMYPBZ0iNTWV1atX07JlS2rWrEn//v0JCAjA0tKSX375hW+++UZuiUB6T/oqVapw6NAhuaV8EV3ZANJoNGzdupVt27ZJCylly5ZlxIgRwlXSTp06ldatW9O6dWusra2zGFREqahzdnZm+/btHDhwADs7O0aMGCG1zBFtQ7VQoUIYGBiwevVqVq9erXVOtCqFDRs2kJaWhr6+PseOHUOtVjN+/Hg2bNjAnj17FOPH32Dp0qV4eXlhaWnJgwcPePLkCYULF+bFixesWrWKlStXyi1R57h+/To3btygWLFidO7cmW7dukmbQyIRHBxMnz59SEhIkI5dv36d3r17s3fv3r/UAu7fxt7eHk9PT9zd3WnYsCETJkzg3LlzJCYmUrlyZbnlSbx48YKGDRtq9co2NjbG1NQUPz8/GZVlpXXr1syePZsRI0bQsGFDDA0NtTYuRen3W7RoUcLDw0lKSiJ//vxAeruix48fU6xYMXnF6RDnzp2Txky6kvKni/Tq1YtevXoRFRWFgYGBMCblDx8+0LhxY/Lly0dKSgq+vr4ANG7cWLqmbNmyPH36VC6J2dK1a1dcXV05f/48LVq0YMuWLfTt2xdIbwUiJxUqVJDG9iIl+X2JBw8ekJaWRqtWrahUqRIFCxbUevbv27dPRnV/8uzZM1JTU+nYsSNVqlTh06dPPHnyBLVazenTpzl9+rR0rdyau3btSmJiIm5ubrx58waAkiVLMnLkSLp37y6rNl0iOTmZadOmoVKpUKlUBAUFZVkv0Wg0khFIBDp06MClS5eIjY2lcOHCcstR+Mro0ngqKiqK1atX4+fnR0JCgpYpQaVS4e3tLaM63eXMmTPSZ41GQ3JyMoGBgaxYsQI3NzcZlSn8v05CQgLe3t68fPmScuXK0bJlyyxFfgoKCgoKfw/F+KGgU7i6urJ582ZKlSrFo0eP8Pf3B+Du3busXr2a+fPnyyvw/8fc3JzXr1/rRBsCXdkAWrNmDW5ublqTv+fPnzNnzhw+fPjA8OHDZVSnzYoVK6RepOfPn9c6J1KU8qRJk1CpVFhaWtKsWTO6du3KoUOHKFq0KNOnT5dbnhZz5swhLi4u23OiVSmEhoZSt25dvvvuO9auXUv16tUZPnw4N2/eVCq//yYXLlygVKlStGnThunTp1OsWDEuX75Mp06d8PHxkVueTjJnzhx+++03/P39JVNd3bp16dGjB61btxbm3bVq1SoSEhJwcXGRTH4eHh54eHjg6uoq1GLVjBkziIuLw8zMjFatWtG4cWOuX7+OgYEBEyZMkFueRLly5fD39+ePP/4AICUlhatXr3L79m3h0nPGjx+PSqXi8uXLXL58Oct5UYwfLVq0YP/+/bi4uNCmTRsAvLy8eP36tbKh9hfInOynC+2ddJWXL1+ye/duHj9+jJ6eHqampvTu3RtjY2NZdRUuXJjIyEgArl27RkJCAiqVioYNGwLw6dMnHj58SMmSJeWUmYWRI0dSuHBhzM3NpbYPmzZtomLFilLqm1xMnTqVuXPn0rJlSzp06ICdnR16enqyasoLR44ckT4/evRI65xIqSWenp7S58w609LSpHUKEEdznz596NOnD1FRUWg0GmGKZnSJJk2a0KNHD0JCQvDz86No0aJaJg+1Wo2xsTFDhgyRUaU2RkZGvH37VipK+XxTTZS1CdGxs7PL03UqlYorV678y2ryji6Np2bOnMmFCxeyXd8R5Tmqi2SX7mlmZsaNGzdYvHgxe/bskUGV7uLg4JDjOcWglHdCQ0MZMGCAVkJW+fLl2blzJ2XKlJFRmYKCgsJ/A5VGtB0zBYVcaNmyJXFxcfz666+sWrWKmzdvcvr0aXr27ElaWhoXLlyQWyKQvqG2f/9+ihYtSq1atShSpIjWIptIk2tnZ2fevXvHjh076Nq1K82bN6dv3758//33VKhQAS8vL7klAukT7ffv3zNnzhycnJxQq9WcPXuWOXPmULx4ca5evSq3RIk6derw6dMnOnbsiImJCWq1Wuv86NGjZVL2Zd6/f0/RokWzaJYba2trSpUqxa5duzAxMRF64l+3bl2sra1ZsmQJ9vb29O7dm9mzZ9OjRw8iIiK4efOm3BJ1DktLS5o0acL69euxtbWlfv36uLm5SYaagIAAuSXqLBERERw+fBgvLy+ePn2KSqXCyMhImN9p3bp1qVChgtbmCkDHjh159uyZ1P5FRDQaDffv36d06dJCba7s37+f2bNnZ3mOajQaZs2aJXu7h8z069cv1/OixMJ++PABFxcXHj9+LH2vGo2GcuXKceDAAdk31HWFSZMm5flakcbSusSNGzf4/vvvSUpKkjZWVCoVhQsXZtOmTVrtir42I0eO5NKlS3z33Xf4+/vz/PlzatWqxcGDBwkMDGTdunVcuXKFNm3aKElfeaRevXrExsYC6f/ORYsWpW3btrRr1072NJLcyGz8yI7OnTt/JSW58yWdmZFDc3h4eJ6vFaltpq7Qr18/6taty/jx4+WWkiu5peNlpJYofJm8pgyK8J26uLhQv359Jk6c+MW0UbnTiDKTMQaZMmUKlSpVymJUbNSokQyq/pvEx8fTp08fwsLClLWUv4jyTP1nGDp0KFevXqVgwYKYmZnx8OFDEhMTadWqVZaUZwUFBQWFv46S+KGgU7x9+5ZGjRphZmbG7du3qV27NiVKlKBatWr8/vvvcsuT8PDwANI3Aq5du6Z1TqTEB4AhQ4Ywe/ZsunXrhkql4tKlS1y6dAmNRiPU5k9cXJxUjZ5Bt27dOHr0qFS1LArFihWjUqVKLFq0SG4pX+T9+/eo1WqKFi3KlStXuHLlCk2aNKFZs2ZyS9OiQYMGREVFCd3nO4MqVarg6+vLmDFjUKlU2NnZ4ebmRmBgoLJY8TcxNjYmPDyc48ePEx8fT/369Xn16hV3797FxMREbnk6TaVKlWjTpg1paWl4eHgQExNDTEyM3LK0yGid8aVjIpCSkkJKSgoFChTg4cOH+Pr60qBBA6GMHz169CA1NRU3NzdevXoFgImJCcOHDxfqvQ/iGDu+RLFixTh8+DB79+7F19cXtVqNtbU1PXv21EpUU8idEydO5Ok60cbSusTSpUtJTEykXr16tGzZErVazblz5/Dx8WHRokUcOHBANm2jR4/m5s2bHD9+HAADAwOmTZsGwNq1a7ly5QqGhoaMHDlSNo3ZsW7duhzP5cuXj5IlS2JnZydLUsmNGze4fv06p06d4vz583z48IE9e/awd+9eypYtS/v27Wnfvr1QbSlAHGPHlxBdZ9u2bfN0nWhtM3WFnMYoCQkJ+Pj40LRp06+sKHtGjRoldNGErrBz5065JeQZf39/SpQoIX3OCdF+F8WKFaNChQrCzUd0nc/TatLS0vj48SMpKSlUqlRJJlW6y7Zt26TPmVvn/Prrr7i6usonTMcIDAykSJEiHD9+HBMTE8LDw+nWrZvU6lFBQUFB4f+GYvxQ0CmMjIx4+fIlN2/eJDo6mrp165KQkMDDhw+F2lTRpcm1rmwAOTs7c+vWLa32OdHR0YSFhUmx6qIwbNgwXF1dCQwMxMrKSm45OeLv78+QIUNYsGAB1apVY/jw4Wg0Gnbt2oWrqyvOzs5yS5To0KEDM2fOZPjw4TRp0iRLRK0ocf8AI0aMYPz48fj7+2NhYUHTpk05efIkBgYG/PDDD3LL00ns7e05ePAg06ZNQ09PDycnJ2bPns2HDx/o1q2b3PJ0krdv33Ls2DE8PT15+PAhkB5P3aJFiy9Whn1NatWqhY+PD+7u7nTt2hVAqv7OiP8XhbCwMIYOHcqPP/5IjRo16N69O58+fUJfX59NmzYJpbdXr1706tWLqKgoDAwMKFKkiNySJJKTk9HT00NPT4/k5ORcrxWlJRFAwYIFGTJkiFDx7rqGLo2fdZWQkBCqVKnCzp07pXS3/v370759ex48eCCrNgsLCw4ePMihQ4dIS0ujU6dOUlVlpUqVyJ8/P2PHjqV69eqy6vycdevW5fi71Wg0qFQqDA0N2bhxI/Xq1fuq2gwMDGjWrBnNmjUjNTWVGzducOrUKc6dO8fz589xd3fH3d0dc3Pzv5Re8TW4cOECoaGhWuk08fHx3L59WyqyEIH79++zdOlSKYHM1taWKVOmUKNGDZmV5b0dphIC/PcIDQ1lypQphIWFkZSUlOW8KFXfY8aMkVvCf4L69evn6ToR7qeff/5ZapXw888/y6wm74wcOZIVK1YQERGhGBL+Qd6+fZvtcUNDQ8lgq5B3sivmat68OSEhIWzbto3GjRvLoEr3iIuLo2HDhlIhV5UqVbC0tFSMHwoKCgr/EEqrFwWdYty4cZw+fVpaXPP09GTNmjWcP3+enj17MnfuXHkF6jiibQBljnGOj49n7969VKhQATs7O1JSUrh8+TKxsbGMGzdOKJPKoEGD8Pf3JzExkcKFC2tVpovU87V///74+Pgwd+5cwsPD2b59Oz179uTQoUPUqFFD1qrPzzE3N0elUkkL6J8jysJaBqGhoTx58oSGDRtiaGjIpUuXMDY2xtLSUm5pOkl0dDTz5s3j8ePHDB48mHbt2vHTTz8RGRnJihUrhNr81RUsLCxITU1Fo9FQpkwZunbtSvfu3YVLULl58yaDBg3KsoiqUqnYsmWLUCk6GW0Kpk6dyvv373F3d8fOzo5r165ha2srTKXg521zMpMvXz5KlChB7dq1ZbuvatSogaOjI2vXrs1140ykCuVPnz6xd+9egoKCsjWrKOkUCqLQuXNn8ufPnyXavUuXLujp6Qk19tMVtm3bxvr16ylevDjNmzcH4Ny5c7x//56ePXsSGRnJ6dOnqV+/vjDvgYSEBFasWMHu3bulsbVIY+n169drJal8Pv4XRWtwcDC9evUiISFB67ihoSF79+7Nc2uI/9f5K4ZjkdpSDB48mOvXr2d7ztbWVqjUsoiICLZv305AQAAWFha0adOGxMREWrRoIbc0nSQlJYV9+/Zla07z9/fn0qVLMivUHT6//zPG9lWrVs1S7CPn/Z/XFnMqlYoJEyb8y2r+Grdu3cpyrECBApiamlKwYEEZFP330Gg09O3bl/v373Pnzh255egE5ubmODg4sH79eunYDz/8wIULF4QZ5ykoKCjoMkrih4JOMXXqVF6+fMnjx48ZMmQI3377LaVKlaJmzZrC9VZ9+PAhW7Zs4dGjR6jVaszMzBg6dKgQUbo//vgjtWrVom/fvlrHRetBv3HjRq1FPo1Gw+PHj4mIiJD+Bli4cKFQxo8bN25Inz9+/MjHjx+lv0WqZA0ODsbS0pKePXvSsWNHqlatyrx58wgPDxduoG1rayu3hL9EtWrVtO71Ro0a4eXlxc8//8yePXtkVKabFC1aNMtiy+TJkxXDx/+BtLQ0mjVrhouLC02bNpUqv0WjQYMGuLu7s2TJEkJCQgCoXLkyEydOFMr0ARAQEICpqSn9+vXDxcWFcuXKsXnzZlxcXGSvpM/MtGnTvvguKlmyJJs3b5alsl6j0Ujv99z86SJ51+fPn8/BgweBrLqUtiR55+rVq5QoUQJzc3OuXr2a67Wfx1Yr5Ex4eLj0uX///syaNYvVq1fj5ORESkoKR48e5dmzZ2zZskVGlbpLaGgoBQsW5LfffpM2UMaMGUPbtm1JSUlh9erVdOnSRfbWlKmpqVy7do2TJ0/i7e1NbGys9LwSrZXikSNHMDAwoHv37uzevZu+ffsSFhbG9evXmThxotzyJFatWkVCQgIuLi5SO1IPDw88PDxwdXXFzc1NZoVfxtfXl/3797N06VLZNOTWiiIzIs2jIT2mvlKlSuzbtw8HBwd+/fVX4uPjGTx4MN9++63c8iQCAwMZMGAACQkJqFQqypYty7Vr19i6dSuurq60atVKbok6x9KlS9m1a5dkSss89hNhTvVXUpHkTk7N6f4PDg7W+lvu+//ztcnsyPg9iGb8yJxWExsbS3JysnBrv7rE52al1NRU3rx5w6tXr6SkHYW8ERUVpTXni4qKAuDatWtaz1Vl3qegoKDw11GMHwo6RdmyZbNMYsaMGSPcoPX8+fOMHTtWqqYGuHfvHseOHWP9+vU0a9ZMVn1Hjhzh48ePWsYPBwcH7OzsmDdvnozKtOnUqZPsE7y/gyjVfF/i06dPFC1alOjoaB49eiT1qRZpMy2DcePGYWVlpXMb/Y8ePcLDw4Njx44RExMjtxydJbeEAkh/Vij8NS5cuCBcukdO2NvbY29vT3R0NGq1WphUqs+Jj4+nbNmyJCUlERQUROvWrYH0yt9Pnz7JrO5PBg0axIEDB1CpVJKp7ubNm6SlpdG8eXOeP39OYGAgK1aswN3d/avrO3fuHIaGhtJnXcDLywu1Wk2nTp0wMTERYtFfFxk6dChOTk6sXbuWoUOH5jgGFCntRRdo27ZtlmNubm5am9IajYaePXsq3+vfwMvLCysrK62qWSMjI0xNTfntt9+YOXMmJUqUkMUAmJaWxs2bN/Hy8uLMmTPSWFSj0VCkSBGcnZ1p3759nlsYfC1evXqFra0ts2bN4urVq9jb2zNz5kxat27N+fPnGT58uNwSgXTThLm5uVbq6Lx58/D398fHx0c+YV/gw4cPeHp6sn//fskYJqfxQ5daUWQmKSmJ8uXLU7x4cWrVqsW9e/fo0aMH9erVw9vbm5kzZ8otEYBly5bx6dMn5s6dK/1WraysUKvVuLm5KcaPv8Hp06cxNDRk9OjRLFu2jIkTJxIREcGhQ4eEaJ0xZ86cPK+jyW380JX7X1fXJjM4duwYbm5uhIWF4eDgQMuWLXn06BFTp06VW5rOkZNZSa1WK62d/yL+/v4MGzYsy/GhQ4dKn5V5n4KCgsLfQzF+KOgcsbGx7Ny5E19fX2nTom/fvhQuXFhuaRLLly8nJSWF7777DmdnZwC8vb05evQoy5cvl934kR3Pnz/n3bt3csvQYvHixXJL+Fvs3LkTGxsbBg8eLLeUXClfvjx+fn7MmDEDjUZDkyZNOHDgAH5+fsK1JBk1ahRlypT5ogFABJKSkjhx4gT79+8nICAASF9g19fXp02bNjKr002+lFCgGD/yxsqVKzE1NaVDhw7s3r07x+tErFSC9OQXkSldujSBgYEsX76c1NRUGjVqxMWLF7l9+7YQaV8ZqNVq9PX1OXbsGCVLlgTgxYsXdOrUCTMzM1atWkW7du1ki6ktV65ctp9FrlAzNDTEysqKRYsWyS1FpylbtizFixeXPiv8M+TV0JuWlvYvK/lvUqBAAfz8/Lhy5Qr29vYAXP7/2Lv3uJ7v///jt1cqQiKEkjEipFA5ZqaSsxlDcxoWM6Y5n4aZsTlsztvCnI/Jacxh5HwahYqRFHLOIcuh87v3749+vea9ytrnq56vtz2v/3zevV6vy+Vzv1i93+/X6/l4Ph5Hj3Lu3DksLCy4dOkSZ8+eVX+3C1KzZs3U3ZN6vR5zc3OaN29Ohw4dePfddzVbUF20aFH+/PNPIHM0XWhoKM2bN8fa2jrbLnDRXh7p+apjWnD69Gk2bdrE/v37SUtLU98b6tevLzRX1uYDY1O+fHkuXrxIVFQUzs7ObNu2japVq3LlyhUSExNFx1NduHABd3d3fH191cIPHx8f6tWrx4ULF8SGM1KPHz+mcePG9O/fn+3bt1OlShUGDhzIpUuX2Lp1K3369BGaz5i6pRrL37+xPpsE+OWXX7IVeFy6dIl169ZhaWkpixX+pZyKlYoUKYKTkxP29vYCEhknea8nSZKUv2Thh2RUnjx5Qo8ePbhx44b6oOLkyZPs2LGDdevWCXmglpPbt29Ts2ZNg9bePj4+xMTEcPXqVYHJjMs/tfl+mZZav506dYqEhATNF3707t2byZMnExwcjL29PS1atOCLL74gIyPDoMJaC0qUKIGpqbY/siIjI9m0aRM7d+40aJ8NmYuXGzduVBdZpX+nXr16auGHXq8nNTWV2NhY9Hq93KX2LyxZsgRvb286duyYa7tarbaoNQbvv/8+8+bNY/369ZQsWRJvb28mTZpEamoqPXr0EB1PtXnzZmrVqmXwfmRra0vt2rVZt24dgwcPxs7OzmA8hEjGsEOtd+/e/Pzzz5w7d074ApoxO3jwYI6vpf8brS2Uv2nee+89VqxYwcCBAylSpAgAycnJAHTr1o3Q0FBevHghpPD/8ePHKIqCm5sbHTt2pHXr1prtmvUyJycnTp48ycqVK3Fzc2PmzJlcvHiRc+fOaeq7dO3atQkJCWHx4sV06dIFyPyMjYiIoFGjRoLTZYqPj2fbtm0EBQVlG5dqY2PDTz/9RO3atUVGzObQoUPExMSQkpKiZk1MTOTs2bP/aoRFfuvSpQvz5s3j4MGDtGjRgmXLlqkdVbX0XaBw4cLcv3/f4N40JSWFW7duGXQqkvKuRIkS3LlzB8h8Hzh16hQtW7ZEURRu3LghNhywZs0a0RH+Z1oemf2yhIQEYmNjSU1NNXifCgkJYdSoUYLTGVq6dClWVlZs2LBB7QLn6+vLjh072LJliyz8+JeMpVhJ6+S9niRJUv7S9iqaJP3NnDlzuH79OrVq1aJjx45AZvXy5cuXmTt3LlOnThWcMJOTk1O2XR56vZ7k5GTq1asnKJXxeVWb75dprfVbq1atOHDgABERETg7O4uOk6tu3bpRoUIFYmNjadWqFRYWFrz77ru0a9cOLy8v0fEMdO7cmYULFzJw4EDc3NwoXrw4hQoVUs+LblHarVs3dcdUVvvsli1b0r59e/r370+JEiU09aDa2GzYsCHbsadPn/LBBx/g4OAgIJFx6tSpE05OTuprY25Xq0WDBg2iZMmSxMbG0qVLF6ysrHBzc8Pd3Z2uXbuKjqfKyMjgwoULREdHU61aNSBzLFVERAQAN27cICIiQhOLgy/vUMv6fdXiDrWOHTuyfPlyevbsSbFixdTFX8jMfezYMYHpjF9qaipXr17FysqKihUrio7zxkhNTc12TGsdIOLj4w0Wf7NoaZfgyJEjURSFNWvWkJSUBGQutHbr1o3Ro0cTEBBAw4YNGT9+vJBsHTp0oHz58gX+//1/MXbsWPz8/ChWrBitWrVi6dKlnDp1CkBTn6dDhgyhX79+zJs3j3nz5qnHTUxM+OSTT8QF+/+GDx9OcHAw6enp6PV6TExMcHd3p3379kyaNInSpUtrrujjhx9+YNGiRerPWQXJWjRo0CCKFy+Oo6Mjbm5u+Pv7s3TpUipVqmQw/kc0T09Ptm/fri5WRkRE0L59e+Li4mTXxP+Rm5sb+/fv58cff6RBgwZ88cUXnDhxgps3b1KhQgXR8UhNTaVQoUIUKlQox8/6l2npc1/rI7OzBAcHM2zYMHQ6XY7ntVb4ERsbS8OGDXn77bfVY9WqVaN27dqEhoYKTGZcHj16xK+//kqbNm0oV64cd+/eZc6cOURGRlK+fHkGDBhAw4YNRceUJEmSJAAUfV57v0qSBnh4eGBmZsbevXvVFqrJycm0bt2atLQ0Tpw4IThhpsOHDzN8+HC8vLzw8fEhLS2NnTt3cvz4cSZMmEClSpXUa0V0qnB0dKRevXoMGTJEPebn55ftGIjtpOHp6Znna7VULdyzZ0/Onz+PXq/HzMyM4sWLY2JiAsgFoP+Vo6MjiqLk+vDv8uXLAlL9JSufubk5w4cPp2fPnpiZmannatasybZt24RmfBONGzeOM2fOaOrvX5K0bvz48Wzbtg1TU1MqV66MXq8nNjYWnU5Hhw4dcHFx4euvv+bdd98lICBAaNb27dvz8OFDdYeat7c3w4YNo0ePHlhaWnLgwAGh+bL07t2bkJCQHM8piiL8M8qYbN++nT179mBvb8/gwYO5e/cun376KY8ePQKgSZMmzJs3TxOFScYoMjKS8ePHc+XKlWzFFFoqpD537hzjxo3j1q1b2c5pKefLUlJS1PfSSpUqUaxYMdGRjFZiYiKmpqYkJydTokQJ7t+/r74veHt7i45n4NixY8ycOZPo6GgAKleuzIgRIzTRke7l+5NBgwbRpUsXbGxs1HNavD/x9vbmwYMHdO3alXXr1tGrVy+uXbvGyZMnGTFiBAMHDhQd0eg8e/aMAQMGEBYWZnDcycmJJUuWaHKEntbFxcUxePBgevXqRZs2bfjwww/V73pffvklH374odB8NWvWxNvbm4ULF1KzZs1cr9Pa52nbtm25du1ajiOzHRwc2Llzp+CEmd5//30uX76Mg4MDV69excXFhTt37vDo0SODkUpa4enpSUpKCjt27KBp06Z4e3szYsQIunbtSqlSpQgODhYdUfNu3LiBr68vCQkJBAYG4uDgQPv27bl79676fdrU1FTtVCZJkiRJosmOH5JRefr0KfXq1TOYm1ukSBHeeuutbDeyIg0aNAhFUdi1axe7du0yOPf111+rr0XeaIWFhTFgwACDLDkdE3kjaKyLuWfPnlVfp6amqrO1AU3tWHr06BFz5swhPDw8225KRVE0dQOo9Tm1pUuX5vHjx6SkpDBz5kz27t1Lu3btaN26tehob4S/j33S6XTcv3+fQ4cOkZKSIijVm2n48OHExsaydetW0VGMTlJSEsuXL8/1PXXVqlUC0/3liy++IDExkd9++01dqAJo0aIFkyZNYtmyZVSsWJExY8YITJnJWHaohYeHY2VlxYQJEyhXrpxa7Cn9Oxs3buSrr75SizxDQkLQ6/U8fPhQvebkyZN88803Oc7Xlv7ZxIkTcy1E0tJ+kJkzZ3Lz5s0cz2khZ067qRVFoXLlygbXgLZ2UxuLrCLEOXPmAFC+fHn69esnOFXOmjVrRrNmzUhISMDExERTRWmmpqakp6eTmprKkiVLiI6Opl27djRr1kx0tFzFxcXh7u7OpEmTOH78OM2aNWPixIm0bt2agwcPaq7wIzY2lpUrVxIeHo6TkxNt2rQhOTmZFi1aiI6msrS0ZOPGjZw6dYpLly5hampK9erVady4sehoRqtcuXJs2bKF1NRUzM3NWbt2LSdOnMDe3v6VhRYFRa/Xq5+Vr/rM1MLn6cuMZWT2jRs3cHFxITAwEA8PD0aPHk3VqlVp164dcXFxouNl061bN+bNm0fz5s1RFIUjR45w8OBBMjIyNPvZqjXz58/nzz//5K233qJUqVLs2LGDO3fuYGZmxhdffEFsbCwrVqxg6dKlsvBDkiRJ0gRZ+CEZlcqVK3P+/HnOnj2Lq6srAKGhoZw7d05TMx+11H44J1rPl1epqans3r2boKAg1q1bJzqOavXq1aIj5MmkSZM4fPhwjjf8WipQAe3PqT1y5AiHDh1iy5YtHDt2jLCwMMLDw5kxYwaQuSCc9WBI+vdyG/uk1+t59913Cz7QG+z69etcuXJFdAxVTEwMU6dOVYspXia6OPHvJk+ezK+//qr599TixYszf/58bt26RXR0NDqdDgcHB9566y0ABg4cyLBhw8SG/P/Kli3L5cuXefz4sXrs2rVrREREUK5cOYHJDFWpUoWSJUvy3nvviY5i1NasWYOiKAwcOJDk5GRWrVqFoij06tULf39/YmJi6N+/P0ePHhUd1WhFRUVRtmxZ5s6dq+kipaioKEqVKsXixYupUaMGpqbaemzh4uKi7qZ2cXHJ9TqtfU4ZixcvXhgUfGnJ9evXX3k+qzsRZH42iHTs2DF++eUXtmzZwtWrV9m1axe7d+9Wi1PS09OF5stJ0aJF+fPPP4HMjhShoaE0b94ca2trIiMjxYb7m4iICD766COSkpJQFAVbW1tOnDjB8uXLmTdvnia6vryscePGstjjNXv+/Lla7J01TvPu3bvCn7cdOHAACwsL9bWxMKaR2VmbEZ2cnAgLC8PNzY2aNWty/vx5wcmy++STT3j+/Dlr1qwhPT2dtLQ0ChcuTM+ePTUzNlPrQkJCKFeuHDt37sTc3Jzg4GAURcHb2xtfX18Ajh49qo5OlSRJkiTRtPUERZL+Qc+ePfnyyy/p3bu3ukARGxuLXq+ne/fugtP9ReudKrSe759cvXqVwMBAdu7cydOnT0XHyaZBgwbq67i4OBRFUdvqasnZs2cxMzPD39+f6tWrq6NJtCojI4OdO3cSGhqKoii4u7vTrl07TSxamJqa0rJlS1q2bElcXBxbt25l27Zt6m7V2NhY3nnnHTp37qyJXfTGJqeHZxYWFtSpU0dzM3Sl12vq1KmcPn06x3Na26V24sQJTExM6NatG9WrV9fcQuXf2dvbY29vD2QWUm7fvp1Nmzaxfv16wcn+ktsONb1er6kdahMnTmTQoEEsXbqUZs2aGXSmA/GLf8bi1q1b1K9fn+HDhwOZD1kvX77M0KFDKVGiBPXq1cPFxUVT3V6MTbVq1bCwsND8bkR7e3usra1xdnYWHSVHxrqb2lgMHTqUWbNm8fPPP+Pm5oalpaXB932R76lt27bN03VaKPopVaoUffv2pW/fvoSHhxMUFMSePXvU++fo6Gjat2/Phx9+SM+ePYVmzeLk5MTJkyfVdvkzZ87k4sWLnDt3jrJly4qOZ2D27NmkpaUxZcoUdbSDs7MzJiYmBAQECC38yGvXCS38nhojrY8js7Ozy/G11g0cOJDhw4czatQog5HZsbGx9OzZ06ALqMiR1FWqVOH8+fMEBwdTt25d1q9fT1paGiEhIRQpUkRYrtwoisKoUaMYMmQI0dHRmJmZUalSJb744gs++OAD2ekzD/7880+aNGmCubk56enp6r1IkyZN1GtsbW1zfE+QJEmSJBEUvXwaIRmZuXPnsmzZMnWHiomJCT179uSLL74QnCy70NBQg0Xq+vXri45ktFJSUti1axebNm0iPDwcyHyYampqSps2bZg9e7bghIaOHDnCtGnTuH37NgCVKlViwoQJNG/eXHCyv7z77rtUrlyZlStXio7yj5KTk/n44485d+6c+hBdURRcXV35+eefNXmDDXD69Gk2bdpEcHAwKSkpKIqSa4t1SdKCTp06ceXKFc38nmZ195o2bVqOBWqVKlUSEStHTZo0oWrVqprvUPSynAoptfLfHjI/57///nvWrFmjdnwpXLgwPXr0YPTo0Zoo/IPMhaqMjIxcu72IXgAwFjVr1qRFixb8+OOPAAwePJhDhw4Z/E4OGTKEgwcPaur31JiEhYXRr18/2rdvT/PmzbN9fxK5kPKykydP8tlnnzFt2jSaNGlC0aJFDc6L7qB2584dLCwssLa25s6dO6+8VguLbrdv36ZChQoUKlRIPXbv3j1KlChBsWLFBCbLmaOjY66dskS/pzo6Oub5Wq11qIDMLoS7d+9m8+bN6s50Ld2fREVF4efnx9ChQ2nVqhWdOnXi7t27QOZngr+/v+CEf6lbty716tVjxYoVODo64u3tzaJFi+jduzcXLlwQOorY2H9Pta579+7qM6mcaOHf9Nq1axw6dAh7e3tatmzJn3/+yeTJkzlx4gQlS5ake/fufPLJJ6JjGnjVe//LRH8OBAcH8/nnnzNmzBhatGhBx44d1c4vbdu2VceUaZ3W7vu1rFGjRpQtW5adO3dy5MgRPvnkExRFYd++fdjb25OWloa3tzempqZG1WVHpJEjR+b52pfHP0mSJEl5o+2tiJKUg+HDh9O7d2/Onz+PoijUqVNHU+2+AXQ6HaNHj2bPnj0Gx9u2bcvs2bM1s1BhDCIjI9m0aRM7d+7k+fPnBosqdnZ2bNy4UXO7f86cOcPgwYPR6XTqsdjYWIYMGcKKFStwd3cXmO4vffv2JSAggPv371O+fHnRcV5p/vz5nD17lnLlytGyZUsA9u/fz9mzZ1m4cCGjR48WnDBnDRs2pGHDhjx79owdO3awZcsW0ZGM2u+//050dDSKolC9enXN/C1J+ad06dJUrFiRNm3aiI7yj7p27cr27dt58eKFJhfSsvxTIaVoPj4+dOjQgfbt21OlSpUcd6j9fRFYtFe1y5c19nmn1+sNviNraUTSm+Lu3bukp6ezefNmNm/ebHBO9ELKyyZNmoRer8/xobAWcua0m/r58+cUL14cyBwHopVOP7NmzWLVqlWsX7/eYCzNwoUL2bdvHxMnTqRTp07iAuYit/dO0e+pWljQ/b+wsLCgS5cudOnShWvXrhEUFMSOHTtEx1JVr16d4OBgkpOTKVGiBOvXr2fPnj3Y29vj7e0tOp6BwoULc//+fYPfyZSUFG7duiX8e8q+ffvU1+fPn2fChAn4+fnRsmVLTExM2L17Nxs2bGDZsmUCUxovrY8jO3PmDJ988gnJyclA5nPIFy9ecPjwYQASExOZN28eGRkZfPrppwKTGhI9IievvL292bx5MxYWFlSqVIlFixaxdu1a7O3t+fzzz0XHk/JB3bp1OXLkCKNGjSIsLAxFUahduzb29vZERESwaNEiHjx4oIl7aWOxa9euPF2nKIos/JAkSfofyI4fkpQPAgICmDdvHhYWFjRq1AjIXLBMTk5m+PDhDBw4UHBC49CtWzcuXLgAZD7ks7S0pGXLlrRv357+/ftTs2ZNtm3bJjhldr179yYkJISRI0fSrVs3AAIDA5kzZw7u7u6a2Q0+fvx4Dhw4QHJyMm+99RZFixY1WGTZuHGjwHSGWrRoQUpKCnv27MHKygqAJ0+e0K5dO8zNzdWHGNKb6cGDBwwdOjTbzNR69eqxYMECypQpIyiZcXm5PW5uvvrqK27fvq2ZnT+//vorkydPZuXKlZpt+Z9l/vz5rFu3DnNzc5ycnLK9p4p+YGEshZQv7/arVasWHTt2pG3btprIJuUvR0dH6tWrx5AhQwBYtGgR4eHh/Pzzz+rva9YxrbxHGZsWLVpw7949LCwsKFmyZLbiGq2Mg/yn3epaWnx/+vQp/v7+VKhQgW+//RaApk2bUqVKFRYtWkTJkiWFZdu2bRvjx48HMkdS9erVSz3XunVrbty4gYmJCT///LNBu3Lp/y4mJoaqVauKjpEn6enpmlu4Ngbjx49n+/bt1KhRg8jISGxsbChcuDC3b9+mU6dO6vuBaO+//z5FihRhw4YNBsd9fX3R6XQEBQUJSma8OnbsiLW1tWY7p/bq1YvQ0FDq1atHeno6Fy5cQFEU6tevT79+/YiJiWH+/PlUqFBBdif4H2zfvp0KFSrQsGFDg+M7d+4kOTmZrl27Ckr278iOH3l38eJFevfuTVJSEgBmZmasWLECNzc3BgwYwLFjx7CwsCAwMJDq1asLTmscFi1alOdrP/vss3xMIkmS9GaShR+SUbl16xZfffUVZ8+eVavXs2hh91cWHx8fnjx5wtatW7G3twfg5s2bdO7cGWtra4MdGFLushZ/zM3NGT58OD179lTb/Ds6Omq28KNevXrUqFEjW+GEr68vV65cUdvqivaqh+paavkLUKdOHdzc3FixYoXB8X79+nH27NlsBQHSm2Xw4MEcPHgQS0tLdfTH+fPnefr0Kd7e3ixcuFBwQuOQl/a5er1eU3//ffr0ITIykmfPnmFhYWGwg1JRFI4dOyYwnSEtv6caUyHlkiVL2LdvHxcvXgQy/+1MTExo1KgRHTp0wNvbW91VrzWPHj0iIiKCokWL4uTkpNmcWmWM71HGpl69elSsWJEtW7YIH5fyKsYwPiXLpEmTCAoKUou7k5OT8fLyIj4+nq5duzJ16lRh2bp27crFixf58ssv8fX1NTiXnp7OwoULWbx4MU2bNtXUzv/x48fj5OREz549DY7PmjWLhIQEpk+fLiiZobi4OKZPn05MTIza5h8yd9MnJCRo5tmE1nl4eNC8eXOmT5/+ynFTWvve9+zZMwYMGJBtpIuTkxNLlizB2tpaTLC/cXZ2xtbWlj179qifsTqdjjZt2nD//n15H/0/0Po4sqzP+p07d6LT6WjZsiX37t0jODhY/fz09fXljz/+UO8PtETrI7MdHR1p2bKlwTMIvV6Pr68v165dIyQkRGC6vJOFH/9OTEwMW7ZsISMjg06dOqn3/tOmTeP+/fv4+/vLog9JkiRJM2RZv2RUvvjiC86cOZPjOS3VMN27dw93d3e16AOgUqVK1KlTh9DQUIHJjEvp0qV5/PgxKSkpzJw5k71799KuXTtat24tOtormZmZkZiYmO34ixcvhD8EeJlWdiHlhZ2dHREREdy8eZNKlSoBcOPGDcLDwzX18F/KHydPnqR06dL88ssvaneP+Ph4OnbsmKcuFlImY2mf+7KXP/MTExMN3lu1NgZiyJAhmsuUJSIiItdCSq0ZOHAgAwcO5O7du/z222/89ttvhIeHc+LECU6ePMmUKVN49913ad++vWbavqenp/PVV1+xdetWMjIy8PLywtXVld27d7N06VKhO/6NiTG+RxkbT09Prly5QqFChURHeaWXv9s9f/6c1NRUzSyi/t2hQ4ews7MjICAAgCJFihAcHEyHDh2Ed6SLjo6mZs2a2Yo+AExNTRk+fDgHDhzQRAeV6Ohonjx5AmR2Krl586bBAopOp+Pw4cPcvXtXM4Uf06ZNY//+/Tmeq1y5csGGMWKPHj0iISFBfZ0brX3HKlSoEBs3buTUqVNcunQJU1NTqlevTuPGjUVHM1C1alUiIyP56KOPaNGiBRkZGQQHB3Pr1i2cnJxExzNKWh9HlpycTMWKFYHM39MaNWpw7949KlSooF5TqlSpV44qFEHLI7MDAgKYP3+++nNwcDA1a9bMdl1Wd1rR8vKM5MWLFwWQ5M1RtWpVxowZk+34xIkTBaR580RFRamFtFlevHjB2bNnmTNnjsBkkiRJxkkWfkhGJSwsjOLFi/Pdd9/x1ltvafahZdmyZbl8+TJ//vmn+rA/Pj6ey5cvY2NjIzacETly5AiHDh1iy5YtHDt2jLCwMMLDw5kxYwYASUlJpKamaqqYAqB+/focOXKEyZMn06VLFwC2bNlCdHQ07777rthwL3n//fdFR8izzp07M2fOHN577z2140NW5x8tziWXXi9ra2sqVapkMNLF2tqat99+m9u3bwtMZly00sL/31i9erXoCHk2dOhQ0RFyZYyFlLa2tvTr149+/foRFxenFoGcO3eOvXv3sm/fPuEP1rMsXLiQoKAgbG1tuXv3LpDZpe7ChQvMmjWLb775RnBC42CM71HGpl69ehw4cID333+fRo0aUaRIEYPzI0aMEJQsu507dxIQEMC1a9fw8vLC09OTq1evMnbsWNHRDCQkJODq6kqxYsXUYxYWFtja2mbrBCDC33ei/12pUqW4detWAaXJXVRUlMEi6rlz5+jTp4/BNXq9XlMF32fOnKF8+fIsWrSIHj168MMPPxAfH8+ECRNo166d6HgsXbqUihUr0qZNG+7evUuRIkU0WUC1evVqSpUqpb42Fh06dMDFxYU5c+ZortjjZWPGjGHQoEGcOXNG7USg1+spXrw4kyZNEpzOOL2qK5UWNqTp9XqDZ6VZBRMvF06ILKLIzdKlS9m9e3e2kdm7d++mRo0aQkdm9+vXj40bN3L//n0URcnxv7OJiYnBSDWR/Pz88txFT5JECwwMZMqUKbmel4UfkiRJ/54s/JCMSoUKFbCxsdHU4nlO2rRpw7Jly+jQoQOenp5A5sPshIQEtRBA+mempqa0bNmSli1bEhcXx9atW9UdYACxsbG88847dO7cOcfKa1GGDRvG77//TlBQkDozV6/XY25urrmFwUOHDuXYnvjs2bMEBgYKTveXjz/+mCtXrrBr1y6D3Quenp58/PHHApNJBcHPz4+ZM2dy4sQJmjZtCsDu3bs5f/68ZnZ9SvmjQYMGoiP8K1rdqWKshZRZ0tLSSElJMej4ooUH61l++eUX7O3t2bVrF87OzgCMGzeOw4cPC9/xLyIMmfEAANBHSURBVEkvmzZtGpD5XnX16lX1eNbDf60Ufvzyyy9qgUfWosSlS5dYt24dlpaWDB48WGQ8A2+99RahoaHs2rULDw8PdDodhw4d4uzZs1SpUkVotrfffpuLFy8SGxvLW2+9le18bGwsFy5c0ER3irZt26qF8g8ePMDc3NygW5KJiQmlSpXS1Jz3xMREnJ2dcXJyolatWjx+/JhOnTqxZcsWfvnlF+H3fQEBAbi7u9OmTRs8PT2zjSbQipe/6+3btw9XV1fatGkjMFHevHjxgocPH4qO8Y8aN27M3r17WbduHTdu3MDExIRq1arRq1cvTRYCGYMDBw6IjvCPMjIySEtLQ6/Xk5GRAaD+nHVea7Zu3YqlpWWOI7M3b94stPCjcOHCbN26lWfPntGqVSuaNm3Kl19+qZ5XFIWSJUtiaWkpLOPLZBc9yZisWrUKRVF45513OHz4MD4+Ply/fp2rV68K/buXJEkyZopeS09NJekf7N+/n3HjxrF48WLc3NxEx8lVcnIyfn5+6lzKrD8zJycnVq9e/Y87r6RXO336NJs2bSI4OJiUlBRNznqPjIxk7ty5hIaGYmJigrOzM/7+/ri4uIiOpvrhhx9YtGiR+vPfK/5F/5teu3aNcuXKGeygvHjxovp35eLiQt26dcUFlApM7969uXjxIsnJyVhYWKDT6UhNTVUXAbJobfa39HpcunSJWbNmcfbsWQDc3d0ZPXp0ju11RfqnnSqi31Oz5FRIqSgKVlZWmiqkvH//Pnv37mX37t3q/PGszyk3Nzc6dOhAt27dBKfMVKdOHRo0aMCyZctwdHTE29ubRYsW0bt3byIiIggPDxcdUZKAzIKkV+3u1MoYwPbt2/Pw4UM2bNhA27Zt8fb2ZtiwYfTo0QNLS0tNLbpt2bKFL774Itu/q16v5+uvv6Zr166CksG6dev4+uuvsbW15dNPP6VOnToUK1aM58+fExYWxtKlS7l37x5jx46lb9++wnL+naenJx4eHkydOlV0lFdq0aIFaWlpbNmyhZ9//pmbN28ydepUPvzwQ+Lj44V3fHFxcaFIkSJ06dKF5cuXU7lyZXx8fLJdpygKw4cPF5Awu/r16+Po6Mj69etFR/lH69atY9asWQwdOhQ3NzcsLS0NuiiILvySCoYWx5E5OjrmuZODVu5PIPP7tLu7O8uXLzc43q9fP0JDQ9X7AdEGDRrEe++9ZxQFapJkDFxcXHB2dmbNmjV4enoybdo0tQi0UqVKrFy5UnRESZIkoyM7fkia5+HhYfBzSkoKvXv3pnjx4hQuXFg9rqUFvyJFirB69Wr2799PSEgIJiYmuLi44OPjg5mZmeh4Rq9hw4Y0bNiQZ8+esWPHDrZs2SI6UjaOjo4sXrxYdIxX2rZtG2ZmZnTt2pV169bRq1cvrl27xsmTJzWx47Nfv35Uq1aNZcuW0adPH9zc3PD395eziP+DstoSAwY7/nU6ncEscNmq9M0TGRlJz549SUpKUo+dPHmSHj16sGHDBhwdHQWmM2QsO1XKlSvHp59+yqeffmpQSPnnn3+yYsUK4YUfa9euZffu3YSFhaHX69XiWQcHBzp06ECHDh0MZpRrQZUqVQgJCWHfvn1A5iJAYGAgZ8+e1dTvqCRldfnRutjYWBo2bMjbb7+tHqtWrRq1a9cmNDRUYLLsunTpQnJyMgEBAeru/7JlyzJo0CChRR8APXr04OTJkxw4cIDJkydnO6/X6/Hw8Mg2UkU0Yxn71KpVK1auXElQUBAeHh588sknamdSLRSnNmjQgGPHjrFixQoURSE2NpalS5caXJNVUKmVwo8GDRpw8eJFHj58SNmyZUXHeaWvv/4aRVH4/vvvs51TFEUz4+gyMjLYsWMH4eHhBl0+ITOnHEf3v9H6OLK87PHU2r2zsYzMPnPmDE+fPpWFH5L0mpiZmZGeng5kbpg9f/48TZo0oVKlSvzxxx+C00mSJBknWfghad7Li3ove/bsGc+ePVN/1tJNy/bt26lQoQKtWrWiVatW6vFff/2VpKQk4Q8B3xSWlpb07NmTnj17io7C3bt383ytVtouxsXF4e7uzqRJkzh+/DjNmjVj4sSJtG7dmoMHDwpfqHz8+DFWVlZER0dz5swZTE1NuX79eo7Xyh1VbzZjmvctvV5z584lKSkJX19ftbtDYGAggYGBzJs3j4CAAMEJ/3Lnzh1cXV0JCAjA09MTX19fdadKRESE6Hg50mIhZdYoCsgc8deuXTs6dOhAjRo1BKZ6NX9/f4YOHcrnn3+OoiicPn2a06dPo9frGTBggOh4kqR6uZAyJ+7u7gWU5NWyFn8eP36sHrt27RoRERGUK1dOYLKcZd2PxMfHo9frKV26tOhIQOb98aJFi1i7di0bN24kJiZGPVepUiW6detGv379DLoUSHk3cuRIFEWhTp06NG/enC5durBlyxasrKyYMGGC6HjMmDGD1atX8/DhQ7Zu3YqtrS0NGzYUHeuVChcuzOPHj2nRogUVK1bE0tKSQoUKqec3btwoMF12uS2ua6mx8jfffMO6deuA7Llk4cf/RuvjyLTUFevfMJaR2cZUoCblr8ePH3P27FmsrKxwd3eX36f+R9WrVycsLIytW7dSv359AgICuHfvHmfOnMHKykp0PEmSJKMkR71ImnfmzJk8X/vyfFiRHB0ds83Q1ev1+Pr6cu3atX986CoZn7y209TS7p+GDRtiZ2fH1q1bGTlyJLa2towcOZIePXoQGRnJuXPnhOZr1aqVOobg72NoXqalf1Mpf3z22WfUr1+f/v37i44iFTBXV1fs7e3Zvn27wfH33nuP27dvq+NftMDNzQ0HBwc2bNiAv78/NWrUYMiQIfTt25c//vhDfvbnkbu7O61bt6ZDhw6a+V6XF0eOHGHx4sVcvnwZU1NTHBwcGDBgAC1atBAdTZJU//R9VSst3wMCApg3bx6mpqbodDr1f/V6PUOGDOGzzz4THdEoJSUl8fTpU4oVK0bx4sVFx3kjPXnyBCsrK80t/vTu3RtXV1eGDRsmOsorvapLlhbHuxqD5s2bExcXxzvvvEP16tUxNTXc/6f13wktMqZxZMbEWEZmf/755+zbt49ChQoZRYGa9HosWrSIvXv3Ym9vz+jRo7lz5w7+/v4kJycDULVqVZYuXaq5zpTGIDQ0lAEDBjB69Gi8vb3p0KEDCQkJAPj6+r5ynK4kSZKUM9nxQ9I8Y3noHxAQwPz589Wfg4ODc2zxKqtV30yv6uLx6NEjUlNTCzBN3jg5OXHy5ElWrlyJm5sbM2fO5OLFi5w7d04TOxfGjh3Ll19+yaNHjwxu/P9O1i+++U6dOkVCQoIs/PiPenms26uOiSZ3qrweJ06cwNzcXHSMf6158+Y0b95cdAyjNnLkyDxfm1Nrfemf2djYqIUfer2e1NRUEhISsLCw0NQovU8++YTnz5+zZs0a0tPTSUtLo3DhwvTo0YNPP/1UdDyjZWFhgYWFhegYb5S4uDjCwsIMRtJl6dSpU8EHysWaNWuAzMWVrEVVd3d36tevLziZoW+//VZ0hDxJTEzMtgj97NkzLC0tBSXKXWJiInXr1mXJkiWio7wxjGkcmTExlpHZv/32GwDp6encuHHD4JyWOlFLr89PP/3EokWLAIiOjubKlSuYmJiQlJSEpaUlSUlJxMTE8O2337JgwQLBaY2Pm5sb+/fvR6fTYWNjw6pVq9i8eTP29vaa6PAtSZJkjGThh2R0jh49ypIlS4iOjkZRFBwcHBg0aBBNmjQRmqtfv35s3LiR+/fv57pIbWJiQq9evQSkk/JbTrOonz59ynfffUdQUBAApUuXZty4cQUdLVdjx47Fz8+PYsWK0apVK5YuXcqpU6cANDGOyNPTU23x6ejoiLe3t3qzJf23tGrVigMHDhAREYGzs7PoOFIBql27NiEhISxevFht8bt582YiIiJo1KiR4HSGRowYwYABA0hOTqZt27b89NNPbN68GcBg7Jv0asZY9AFw6NAhYmJiSElJUb8DJiYmcvbsWQIDAwWnMw67du3K03WKosjCj//R0aNHsx27desWPXr0oHPnzgIS5UxRFEaNGsWQIUOIjo7GzMyMSpUqaWa3ryRB5njXiRMnotPpcjyvpcKPjIwMRo0axZ49ewyOt23bltmzZ2umQ8n7778vOsI/WrduHXPnzmXt2rUGHUrmzZvHsWPH+Oqrr2jcuLHAhIbatm3LqVOn0Ol0Bl0JpP+dsY0jMyYmJibZRmZrjbEUqEmvz5YtWzA3N2fixIkkJyfzzTffoCgKI0eOZMCAAdy9e5dOnTpx+vRp0VGN0qJFi3j77bdp27YtkPn8d+LEiSxfvpyAgADZ6U+SJOl/IEe9SEYlKCiIyZMn5zqbVPSDgvj4eJ49e0arVq1o2rQpX375pXpOURRKliypyV0g0uv3yy+/MGvWLOLj44HMQopRo0ZRokQJwcn+kpiYiKmpKcnJyZQoUYL79++zZ88e7O3t8fb2Fh3PwJAhQ6hXrx5+fn6io0gC9OzZk/Pnz6PX6zEzM6N48eLqA2pFUTh27JjghFJ+OX36NP369cvxc3/ZsmWaerAOmR2edDod5cqVIzIyks2bN1OxYkV69uypqZ1q0uv1ww8/GBQm/n08mWxNnzf/prhTPgB8vcaPH8/58+fZu3ev6CgArxyNZW5uTpkyZbCzsyvARIZ+//13ypcvT+XKlYVleNPMmTMnT9cpisLw4cPzOU3eeHp6cvfuXWxsbLC1tc1WPLF+/XpBybLLGp9kYWGhFs7+/vvvJCcnM3z4cAYOHCg44V9CQ0NZsmQJ4eHhNGjQgI4dO/LgwQNN7Po9dOgQn376KYqi8MUXXxhs6vHy8uLOnTuYm5uzdu1azRSrr1u3jvnz51OhQgXc3d2xsLAw+I4yYsQIgemMkxxHln8CAwOpW7cuDg4OjB49mqNHj+Lh4cH06dNl8ackTJ06dXB1dWXlypUAfPjhh4SFhRESEqKOzvv44485ffo0Fy9eFJjUeMTHx6tjcjw9PWnatClff/21el6n0+Hv78+NGzc4f/68qJiSJElGSxZ+SEbF09OTe/fu4efnR+vWrQHYv38/AQEB2Nvbs3//fsEJM925cwcLCwusra1FR5EK2PXr15kyZQpnzpxBr9dTvXp1vvrqK+rVqyc6WjZeXl64uLjk+UGrSK6urtSuXZvVq1eLjiIJIOd9/7cdO3aMmTNnEh0dDUDlypUZMWIEPj4+gpMZ6tKlC+7u7prq7CQVDG9vbx48eEDXrl1Zt24dvXr14tq1a5w8eZIRI0ZoakFN+m+7fv26wc8ZGRncu3ePCRMmkJCQQHh4uKBkhhwdHf+xXXrNmjX58ccfKV++fAGl+kvTpk2pVasWS5cuxcvLCw8PD7766qsCz/Emyct/86yiOq1873NxcaFChQrs2LFD892qfHx8ePLkCVu3bsXe3h6Amzdv0rlzZ6ytrdm3b5/ghJmOHj3Kp59+ik6nQ1EUvLy8qFixIqtWreLLL7/E19dXaL7evXsTEhLCwIED+fTTTw1GJ8XHxzNjxgx27NihqU6VWX9bfy9K1drfkzHR6/V8//33rFmzhpSUFAB1HNmoUaM01Vnl7t27FClSJNuzydjYWJKSkl55n13Qli9fzuzZs/nyyy+xtLRURwAqikK/fv0YM2aM4IR/uXTpErNmzeLs2bMAuLu7M3r06BzHfUvGz9HRES8vL3744QcABg8ezKFDhwzeP4cMGcLBgwfle2oerV+/Xi30+Pvn08tKly7N8ePHCzKaJEnSG0GOepGMSnx8PHXr1jWYAV67dm3OnDnDH3/8ITCZITs7O0JDQxk3bpwmd6pIr19qaio//fQTy5YtIy0tjSJFivDZZ5/Rt29fTd34v+zFixc8fPhQdIw8kaM+/ttkwc9/W7NmzWjWrBkJCQmYmJhotnPWrVu3KFasmOgYkgBxcXG4u7szadIkjh8/TrNmzZg4cSKtW7fm4MGDsvDjfxQVFaWOz8ny4sULzp49axRFq1qU1UL57/R6Pa6urgWcJndt2rTh2LFjJCUlUa1aNQB15EuNGjV48OABly5dYubMmcydO7fA8z19+pTY2FiOHDnCnTt3iIqKyvWhtIeHRwGny7tnz55p5jO1U6dO/1j4oTUNGzbk4cOHmi/6ALh37x7u7u5q0QdApUqVqFOnDqGhoQKTGVqwYAHm5uYsWLCAAQMGAJmbFQIDA1m1apXwwo9Lly7x9ttv59glw9ramhkzZnDu3DkiIiIEpMuZMf5tad2rxpFpbW+ll5cX3t7eLFy40OD4F198wc2bN3McASfKpk2bKFKkCA4ODqxdu5bChQuzevVqhgwZwv79+zVT+BEZGUnPnj1JSkpSj508eZIePXqwYcMGTRXTSK/Py++j8j31/6579+6sXbuWa9euqcWJf2dlZYW/v7+AdJIkScZPFn5IRqVBgwbExsYaVIOmpqYSFxdHs2bNBKf7y993quj1es6ePcuqVasoVKiQ8AcW0uvXvn17bt26hV6vp1ChQrRu3ZqkpCR++ukng+sURWHIkCGCUhoaOnQos2bN4ueff8bNzQ1LS0uDFsVVqlQRmM5QbGwsz549o3v37nLUx39QgwYN1NdxcXEoioKNjY3ARFJ+un79OsWKFcPGxibb7nTIHKeSRUvvUx9++CGrV69mz549Ob6nGsPCkBYYY7v/okWL8ueffwLg5OREaGgozZs3x9ramsjISLHhjFRgYCBTpkzJ9bws/Pjf5PRQtUiRItSpU4epU6cKSJSzOnXqcOTIEbZu3UqNGjUAuHDhAr1796Zz5868//77tG3bVtgs9bfffpuoqCgGDRqEoiiEhYWpi9QvUxSFS5cuCUiYnU6nY/78+Xh6elKrVi369OlDeHg4derU4aeffqJ06dJC882YMUPo/39evVzg07JlS77++msmTJiAp6cnRYoUMbhWS0U/ZcuW5fLly/z555+ULFkSyNxUc/nyZU19p46KisLd3d3g2Y67uzvOzs6aaPWenp5O2bJlcz1vYmKCnZ2dJrJmMZa/LWNx8+ZNnj9/zttvv42FhQV16tRRz0VHRzN+/HiCgoIEJszcSZ81uk2v1xMaGkqfPn3U8xkZGYSFhWluDOW9e/do0KABrq6ufP7559SpUwcXFxdq1aol7PM+J3PnziUpKQlfX1+6desGZH5vDQwMZN68eQQEBAhOKOWHO3fuEBgYqL6GzGKlrO/WWcekvClUqBC7du1Cp9Ph5OSEl5cXCxYsUM+bmJjIAhtJkqT/A1n4IRmVdu3aMWXKFPr06YOnpydpaWns3buXuLg4PvjgA/VLGGRWj4qi9Z0q0ut38+ZN9bVOp2P79u3AXw/YX26vqpXCj6+//hpFUfj++++zndPSg2pAbaEJmcVe8fHx6s/yZuC/4ciRI0ybNo3bt28DmbsUJ0yYQPPmzQUnk163tm3bqjvT2rRpk+vfuNbep3bu3ElKSkqOu0C1llXLlixZkud2/1op/HBycuLkyZOsXLkSNzc3Zs6cycWLFzl37twrF4ik3K1atQpFUXjnnXc4fPgwPj4+XL9+natXr8oOKv8HxlKItHz5clxcXNSiD8gsBqlbty6LFy+me/fuVK1alRMnTgjJN3XqVGbMmMHDhw+5c+cOhQsX1vyIz3nz5vHzzz9jY2PD1atXCQsLAzILaubPn6+pwp+s4p527dpp7t/Vz88v22fUtm3b2LZtm8ExrX3ut2nThmXLltGhQwc8PT0BOHjwIAkJCXTp0kVwur+UKFGC69evk5ycrB6Lj48nKiqKUqVKCUyWqVKlSvzxxx88fvw4x2KpR48e8ccff2BnZycg3V9CQkIoVaqU2jEpJ4cPH+bmzZsGBQFS7uLj4/n888/VDjmWlpZMmTJF7aS1ZMkSFi1aRFpamsiYQOYIwtmzZ5OUlISiKDx58oQzZ85ku65FixYC0uWuaNGiPHv2jCtXrvDo0SO6dOlCRkYGsbGxWFlZiY6nCg0NxdHR0aBA+auvviIsLIyQkBBxwaR8FRkZafDfXK/X8+WXXxr8LJ9N/juKomBqampwfyI3ekmSJL0esvBDMipjx45FURRCQkLUG66shfWXK0NBbOGH1neqSK/fZ599JjrC/yS3VqRaa1EqR338t505c4bBgwej0+nUY7GxsQwZMoQVK1bg7u4uMJ30uun1eoP3IGN5n7p7926u57SWVcuMsSX52LFj8fPzo1ixYrRq1YqlS5dy6tQpALp27So4nXG6c+cOrq6uBAQE4Onpia+vL66urrRp00ZTLfSl/PHixQsiIyOJj49XF/4fP37MlStXSE5O5sGDB0RFRWFhYSEkn4uLCxs2bAAy5757eHiwaNEiIVnyateuXZQoUYKGDRsyd+5cihUrxm+//Ub37t011znv0qVLXL58mZkzZ9K8eXPef/993n33XUxNxT++srW1FR3hfzJ06FDCw8MJDQ012KHs5OSkmU0JkNlFc+XKlXh7e6MoCmfOnKFVq1Y8f/6c3r17i45H+/btmTt3LgMGDGDUqFE4OztTrFgxnj17RlhYGHPnzuXFixf07dtXaM7evXvTsmVLdbzHt99+S0hICFu3blWvCQoK4uDBg7LwI49mzZplsKj/9OlTJkyYgKurK9OmTSM4OBi9Xk/NmjUFpsxkY2PDjz/+yO3bt5k0aRI1a9akR48e6nkTExOsra1p0qSJwJTZOTk5cfz4cXr06IGiKLRo0YJx48Zx8+ZN2rdvLzqegcKFC+fpmPRmkM+b8p/c6CVJkvR6ib9zlqR/wVi+bGl9p4r0+hlj4Yex7PoEw1Efz58/JzU1VXM7AKX8s3DhQnQ6HSNHjjRopzpnzhwWLFjAmjVrBCeUXqeX35uM6X3qwIEDoiO8EYyxJXn16tUJDg4mOTmZEiVKsH79evbs2YO9vT3e3t6i4xklMzMz0tPTgcyFgPPnz9OkSRN1t7WUd3ld1FMUhVWrVuVzmrzx8PBg//79tGrVivr166PX6zl//jzPnz+nefPmHDp0SG0JL1rW51RycjKXLl1CURRq1aqluQWgR48e0bhxYxwcHDh79ix169alTJkyVK1ald9//110PANz5sxh7969HDt2jAMHDnDw4EGsrKxo37497733nsFohYJ28OBBYf/f/xdFihRh9erV7N+/n5CQEExMTHBxccHHx0dT4x5GjBhBXFwce/bsATIX1wF8fHwYNmyYwGSZ+vXrx4EDB4iIiODjjz/Odl6v11OrVi38/PwEpMueJcvt27e5fPmywDTG79SpUxQvXpwVK1ZQuXJlVqxYwY8//sinn36qvvf3799fM93oGjduDICpqSkVKlSgUaNGghP9s1GjRhEZGcmjR4/o3r07devWZcuWLZQvX14Tf/9ZateuTUhICIsXL1Y7Jm3evJmIiAij+HeW/j35vCl/yY1ekiRJr5+il1sQJem1mzFjBitXrqRMmTI8fvwYS0tL9Hq9ulNlwoQJoiNKEuPHj8fJyYmePXsaHJ81axYJCQlMnz5dULKc7dy5k4CAAK5du4aXlxeenp5cvXqVsWPHio4m5bN69epRo0YNNm7caHDc19eXK1euyE5K/zHPnj3D0tJSdIxsFi1axNtvv622fM6yYsUKXrx4YZQFglqQkJBAbGwsqamp6iJGYmIiISEhjBo1SnA6Kb/06NGDsLAwpk2bxtOnTwkICMDb25utW7diZWWldlSR/pmjo2Ou57K662S1p9bKwuCDBw/47LPPsnV3qVGjBosXLyYoKIjVq1ezdOlS6tatKybkSzZu3Mjs2bNJTEwEoFixYowePVpoB8q/8/DwoHTp0kyYMIGPPvoIf39/+vXrp45UO3TokOiI2SQnJ3P48GH27t3LkSNH1E0Vb7/9Nh999JFaDCzarVu3iI6OxsTEhKpVq1KxYkXRkYzezZs3uXTpEqamplSvXp1KlSqJjqRKTk5m3rx5bN68mefPn6vHLSws6NSpEyNHjqR48eICE2a+73t7e6udiIYMGcLBgwcN3uNzOiblztnZmYYNG7J06VIg87to/fr1URQFa2trZs+erbkOGll++eUXEhIS1ELQTz75BB8fH02Necqi1+t58eKF+jd0/fp1ypUrR9GiRQUn+8vp06fp169fto6OiqKwbNkytehGkqS86d27NyEhITlu9HJ3d5eFN5IkSf8D2fFDkvLBq3aqaGUHgPTfFB0dzZMnT4DMedQ3b96kevXq6nmdTsfhw4e5e/eupgo/fvnll2wFHpcuXWLdunVYWloyePBgQcmkgmBmZqYuprzsxYsXmJubC0gkFRSdTsf8+fPx9PSkVq1a9OnTh/DwcOrUqcNPP/2U43z1ghQfH68uRC1atAgPDw+DRUidTseOHTu4ceOGLPz4HwQHBzNs2DCD3T8vE1n44eXllafrFEUhODg4n9O8eUaMGMGAAQNITk6mbdu2/PTTT2zevBmAVq1aCU5nXHIbl3fu3DkCAgJISUkB0NRChY2NDZs2beLUqVPExMSQnp5O9erV1UW1Dz74gH79+glfXAXYt2+fOvO9ePHiarH/lClTsLa2pmXLlmID/n+urq789ttv9O3bF0VR8PLyYtSoUcTFxWmqQOVl5ubmlChRgqJFi2JmZkZSUhIAMTExfPnll9y9e1foLvDnz58zadIk9u7da3C8Xbt2TJ06VVMLlcaiT58+uLm54e/vb1DsMXbsWB4+fMjy5csFpstUpEgRxo0bx5gxY7h+/ToJCQkUK1aMt99+W1PdU6TXKzU11aCTU9bfd9GiRdm4cSP29vaior1SUFAQkydPplGjRvTp04fU1FSOHz/O0aNHycjIED6SMCQkhFKlSlGtWjUg83vzy5/tVapU4fDhw9y8eVMzY4kaNmzI4sWLmTlzJtHR0QBUrlyZESNGaOq7lCQZi4sXL1K3bl0GDBigHhs4cCAHDx7k4sWLApNJkiQZL1n4IUn5wNzcnLlz5zJ8+HDN7lSR/puioqIYOXKk+vO5c+ey3UDr9Xrs7OwKOtorLV26FCsrKzZs2KDupvf19WXHjh1s2bJFFn684erXr8+RI0eYPHmyujNpy5YtREdH8+6774oNJ+WrefPm8fPPP2NjY8PVq1cJCwsD4MKFC8yfP5+pU6cKzbd3716+/vpr9ecTJ07kWBAgukDFWP3www+kp6fj4ODA1atXcXFx4c6dOzx69AhfX1+h2e7cuZOn67I6Kkj/jpubG/v370en02FjY8OqVavYvHkz9vb22TqVSa/293EoT58+Zfbs2WzZsoWMjAzKlCnDuHHjaN++vaCE2a1Zs4YOHTrQuHHjHBdRKlSoICBVzhYvXkyhQoX47rvvaNOmDQC7d+9m1KhRLFmyRDOFH2PHjuX+/fvcuHEDPz8/atSogY2NDbVq1dJUC32A0NBQdu3axb59+4iPj0ev11O4cGHatWtHly5duHz5MnPnzmXLli1Cs0+bNo09e/ZQqFAh3n77bSBzd/quXbswNzfnm2++EZbNmISEhKifqWfOnOH58+cGz010Oh0hISE8fvxYVMQcZXV4kf7b6tevr9miD4BVq1Zhbm7Ohx9+CGRuqJgzZw5jx45l9erVwgs/evfuTcuWLVm4cCEA3377LSEhIWzdulW9JigoiIMHD2qm8AOgWbNmNGvWjISEBExMTDTZjVKSjIXc6CVJkvT6ycIPSXpNtm/fToUKFWjYsKF6rFKlSrLYQ9KUtm3bqgvmDx48wNzcnJIlS6rnTUxMKFWqlOZ2psfGxtKwYUP1oSpAtWrVqF27NqGhoQKTSQVh2LBh/P777wQFBREUFARkFiiZm5szdOhQwemk/LRr1y5KlChBw4YNmTt3LsWKFeO3336je/fuHDt2THQ8unfvztq1a7l27RqKomRr+QtgZWWFv7+/gHTG78aNG7i4uBAYGIiHhwejR4+matWqtGvXjri4OKHZVqxYYfDzggULCAsL08Ru5DfB30cnOTo6MnHiRJYvX05AQIDmvqcYi+3btzNr1iy1+1v37t0ZNWqU5hYspk+fzsyZM3n33Xfp1KkT7777Lqam2nx0ER0dTf369dWiD8j8vr1hwwbCw8MFJjNka2tLYGCgwbGhQ4dibW0tKFHuevXqpX6m1qpViw8++IAOHTqov6dNmjQhNDSUkydPCs25b98+LC0tWb9+PQ4ODgBcu3YNX19ffvvtN1n4kUepqamMGzcORVHUkVPjx483uEav18sii3/p8ePHHD9+XH0NmQXKWd9VtVZIYwyio6OZM2eOwbFbt24ZHFMURVNdfm/duoWbmxs+Pj5AZr5WrVqxadMmzp49Kzhdppfvn27fvq3Z8UNJSUkEBwdz//59bG1t8fLywsrKSnQsSTJ6cqOXJEnS66fNpyeSZITGjRuHt7e3QeHH+PHjqV27Nr169RKYTCoIqampeb5WdMXysmXLAPD09MTDw0P4jvm8KFu2LJcvXzZ4QHXt2jUiIiIoV66cwGRSQXB0dGTjxo3MnTuX0NBQTExMcHZ2xt/fn1q1aomOJ+WjR48e0bhxYxwcHDh79ix169alTJkyVK1ald9//110PAoVKsSuXbvQ6XQ4OTnh5eXFggUL1PMmJiay48P/UVZbbScnJ8LCwnBzc6NmzZqcP39eaK6/dyFYu3ZtjselvPv76KSmTZtmG520c+dOOTrpfxATE8OUKVMIDQ1Fr9dTo0YNvvrqK4N/Xy3x8PDg999/Jzg4mAMHDmBlZUX79u3p1KkTTk5OouMZKFq0KA8ePCAjIwMTExMg83c1Li5O+Cia48ePU6ZMGRwdHdUF4Nx4eHgUUKp/ZmVlRceOHfnggw+oUaNGjtc0a9YMd3f3Ak5myMLCgurVq6tFHwBvv/02tWrVUtv/S/+sadOmdOvWjejoaM6dO4eVlZVBkYeJiQnW1tZ8/PHHAlMan7CwMIO2+QB+fn7qa71eL7+j/kuxsbEsXbrU4NiNGzfUY1n/ploq/LC0tOTq1as8f/5c/UxKSEjgypUrchzVvxATE8NHH31k8DyqYsWKrF69WlNdyCQxnj17prkiamMiN3pJkiS9frLwQzJKjx49IiIigqJFi+Lk5CT8oVputm3bxrNnz2Thx3+Ai4tLnq5TFIVLly7lc5q8OXjwoOgIedatWzfmzZtH8+bNURSFI0eOcPDgQfR6Pf369RMdTyoAjo6OLF68WHQMqYCVKFGC+/fvc/r0aRISEnB1dSUpKYmoqCjNjE9RFAVTU1MiIyNFR3njVKlShfPnzxMcHEzdunVZv349aWlphISEUKRIEdHxpNfs76OTTp48KUcnvQZz585l+fLlpKenY2Jigq+vL3379qVQoULcvXvX4FpbW1tBKQ39/PPPPH36lODgYPbu3cupU6dYt24d69ato2rVqnTq1IkuXbpQqlQp0VFp0qQJu3fvZtCgQXTq1AnIvAe8deuW2rFGFD8/P7WFvp+fX66LvFq6P4HMghUzM7NXXtOjR48CSpO7Dz/8kJUrVxITE6MWKoSHhxMeHq7JTl/R0dGUKFECGxsbAgMDOXr0KB4eHuoICJGyNiJ07tyZ5s2b8/nnnwtOZNy08l7+Jnn//fdFR/ifeHp6smnTJnx8fHBxcUGn0xEeHs7Tp0/54IMPRMczGt9++y2PHj2iaNGiODg4EBUVxe3bt5kxYwbz588XHU8qQDqdjvnz5+Pp6UmtWrXo06cP4eHh1KlTh59++knep+TR3bt3KVKkCNbW1nKjlyRJUj6QhR+SUUlPT+err75i69atZGRk4OXlhaurK7t372bp0qUGIyskqSDl1N7//3KdZOiTTz7h+fPnrFmzhvT0dNLS0ihcuDA9evRg8ODBouNJ+SRrd7ePj4/BjqSsHcuid3pK+c/V1ZXffvuNvn37oigKXl5ejBo1iri4OLp37y46npTPBg8ezOeff86dO3do27YtAQEBLFiwAL1ej7e3t+h40msmRyflj8WLF6sL/hkZGaxfv57169dnu05ri/8lSpSgc+fOdO7cmYMHD/LVV18RFxdHdHQ033//PQEBAfzwww8G3RZFGDFiBCdPnuTo0aPqCDK9Xk+JEiUYNmyY0Gy2trZqcYwxLQQnJyfz3Xffcfny5Ry7Km7cuFFAquxu376NTqfjvffeo0qVKqSlpXHz5k1MTEz47bff+O2339RrRWc+fPgwn332GdOnT6dixYp8+eWXQOZGAEVR8PX1FZovy59//smNGzdExzB6xrTBw1h8++23oiP8T0aPHk1kZCQREREcOnRIPV6nTh1Gjx4tMJlxiYiIwNLSkl9//ZVy5cpx/fp1PvjgAzl2+D9o3rx5/Pzzz9jY2HD16lXCwsIAuHDhAvPnzzeKjspa4OXlhbe3NwsXLgTkRi9JkqTXTRZ+SEZl4cKFBAUFYWtrq+5Qu3XrFhcuXGDWrFlyjq4kzIEDB0RHeKMpisKoUaMYMmQI0dHRmJmZUalSJdme9A2WnJxM//79OX/+PGXKlDFoQb5s2TIOHz5M586dmTZtmmxT/AYbO3Ys9+/f58aNG/j5+VGjRg1sbGyoVauW8AU1Kf95e3uzefNmLCwsqFSpEosWLWLt2rXY29sL3w3897EJWa2fT5w4ka1gQUsjFLRMjk7KH8a04P+yiIgIdu/ezd69e4mLi0Ov11OkSBG8vb25evUqV65cYebMmWzdulVoTjs7O3755RcCAgIMdikOGDAAe3t7odleXvw1poXgCRMmEBwcnGPxl5beA7Zv366+vnr1qvo6IyNDXQgCbWT+8ccfycjIwNTUlJ07d2JiYsKwYcP48ccfWb9+vWYKP5KSknj06JHoGJL0xrC0tCQwMJCTJ09y+fJl9Ho9NWvWpGnTppp4b4LM79BZ36tz+j798ngVUV68eEGjRo3UMcNVqlShTp06svDjP2jXrl2UKFGChg0bMnfuXIoVK8Zvv/1G9+7d1QJg6Z/p9Xq5MVKSJCkfycIPyaj88ssv2Nvbs2vXLpydnQEYN24chw8f5vDhw2LDkfmQ5++7knI6Zm5uXpCxpAJgZ2eXp+uePXuWz0neLElJSQQHB3P//n1sbW3x8vKiTp06omNJBWDx4sWcO3cOCwuLbH835ubmmJiYsHXrVurUqaOZh9XS62dra0tgYKDBsaFDh2JtbS0okVSQtm/fToUKFahZsyaQWUDh4eHBzp072bNnD127dhWWLbexCX5+fgY/a62LgtblNDopLi4ORVGwsbERmMx4GdOCf5aWLVty+/Zt9YFwnTp16NKlC+3bt6d48eLo9Xq6dOlCTEyM4KSZbGxsmDx5sugYrzR+/HicnJzo2bOnwfFZs2aRkJDA9OnTBSXL7vjx4xQuXJiBAwdSrlw5TExMREfKkTF1AIiJicHV1ZV27dqxcOFCqlevzsCBAzl9+jTnz58XHU/12WefMWvWLH7++Wfc3NywtLQ0+O9fpUoVgekkyTgpikLDhg0pU6YMJiYmvP3225op+gAICwtjwIABBsde/j6t1+uF59XpdNnGTBYtWhSdTicokSTKo0ePaNy4MQ4ODpw9e5a6detSpkwZqlatyu+//y46niRJkiQBsvBDMjKPHz+mQYMGBoUT5ubm2NnZERERITBZpkOHDuHi4qL+rChKjsfkAsCb7fnz5/zwww/ExMSQkpKiPrROTEwkOjraYAeYlLuYmBg++ugjgx0eFStWZPXq1VSoUEFgMqkg7NmzB1NTU9atW5dtruf8+fM5cuQIgwYNYtOmTbLw4w13+/ZtLly4QEpKSrZznTp1KvhAUoEZN24cLVu2NBjloNfr1XEgIgs/jLWLgjE5cuQI06ZN4/bt2wBUqlSJCRMm0Lx5c8HJpPx269YtSpUqRceOHfnggw9wcHAwOK8oCpUqVRKUznhER0fz5MkTALZt28bNmzepXr26el6n03H48GHu3r2rqcKPUqVKUblyZc2Pc3z//fdFR/hXzMzMePjwITdu3KBHjx5A5qYEMzMzwcn+8vXXX6MoCt9//322c/I5iiT9bwICAli+fDnPnj3Dy8uLxo0bc/r0ab777jvhm9KM6ft0fHy8Qce/+Ph4IHu3P9np781WokQJ7t+/z+nTp0lISMDV1ZWkpCSioqIoXbq06HhGJSQkJE/P8kSPy5MkSTJGsvBDMipVqlQhJCSEffv2AZkL7IGBgZw9exZHR0fB6chTmzLZyuzNN336dLZv367uTHj5v3nx4sUFJssuNDSUJUuWEB4eToMGDejYsSMPHjzIthtQhG+//ZZHjx5RtGhRHBwciIqK4vbt28yYMYP58+eLjiflszt37lC/fv1sRR9ZmjdvTr169YiKiirgZFJB2rRpE1OnTs11N5XWCj9iY2NZuXIl4eHhODk50aZNG5KTk2nRooXoaEYjICDA4D0+ODhY7fjxMisrq4KMlY0xdlEwJmfOnGHw4MEGf/uxsbEMGTKEFStW4O7uLjCdlN8WLFiAp6cnpqbZH1ekpKRQuHBh5s2bV/DBjExUVBQjR45Ufz537hx9+vQxuEav1+e5c2FB+fTTT5k+fTo7d+6kefPm2XZZi16ofJmW76VeVqVKFUJDQxk6dCiKouDh4UFAQAARERE0btxYdDwDuT0vkc9RJOnfW7FiBfPmzcPCwkL9G7p69Sr79u3j+++/Z/z48ULzGdP36Zw6k4BhdxJZoPbmc3V15bfffqNv374oioKXlxejRo0iLi6O7t27i45nVJ4+ffqPGyNFd/uRJEkyVrLwQzIq/v7+DB06lM8//xxFUTh9+jSnT59Gr9fn+AW8IB04cEDo/7+kHUePHqVkyZJMmTKFkSNH8vXXX3Pv3j0WLFjAZ599Jjqe6ujRo3z66afodDq1QOXs2bOsWrWKQoUKCe+iEBERgaWlJb/++ivlypXj+vXrfPDBB3KO6n9E0aJFef78+SuvSU5OLqA0kigrVqwgPT2dUqVKYW9vn+MioFZERETw0UcfkZSUhKIo2NracuLECZYvX868efPw8fERHdEo9OvXj40bN3L//v1sxZNZTExM6NWrl4B0UkFZuHAhOp2OkSNH0q1bNwACAwOZM2cOCxYsYM2aNYITSvnp0KFDNGvWLNt7/sWLFxkzZgy7d+8WlMy4tG3bli1bthAdHc2DBw8wNzenZMmS6nkTExNKlSqlqfsTAGdnZwoXLsyYMWOyndPSoprW76Ve9sknnzBs2DDCwsJwcnLinXfeYc+ePZiZmWmqs8rLY74kScuePn3KrVu3qF27NpA5ntDDw4MyZcoITmZow4YNlC1bll9//VXtoOfv709wcDB79uwRXvhhLIypM4mUv8aOHcv9+/e5ceMGfn5+1KhRAxsbG2rVqsWwYcNExzMqNWvWpHfv3qJjSJIkvZG0+/RcknLg7e1NQEAAixcv5vLly5iamuLg4MCAAQOE76bNbafU2rVruXTpEt98800BJ5JESUhIoEmTJrRq1YolS5Zgbm7O4MGDOXr0KJs2baJv376iIwKZuynNzc1ZsGCBWjjl5eVFYGAgq1atEv6w8sWLFzRq1Ihy5coBmTvV6tSpIws//iOcnJw4deoUR44cybGt/+HDh7l8+TINGjQQkE4qKPfv3+ett95i+/btWFhYiI7zSrNnzyYtLY0pU6YwZcoUIHPxysTEhICAAFn4kUeFCxdm69atPHv2jFatWtG0aVO+/PJL9byiKJQsWRJLS0uBKaX8dvHiRerWrWtQ2D1w4EAOHjzIxYsXBSaTCsK2bds4d+4cs2fPxtnZGb1ez08//cSPP/6YawcoKWfLli0DwNPTEw8PD6ZOnSo40T8bP348CQkJOZ7TUtcHrd9Lvaxly5bs2LGDmzdv0qhRI0xNTWnfvj19+vShTp06ouO9UmpqKrt37yYoKIh169aJjiNJXL16lY8++gh3d3e1S93UqVOxsLBg+fLl1KhRQ3DCv9y9e5dGjRoZdMqztramWrVqnDt3TmAy42JMnUmk/GVra0tgYKDBsaFDh2JtbS0okfGytbU1urF5kiRJxkIWfkhGp3nz5kY12/vUqVMcPHhQFn78h5QsWZKYmBiSk5NxcnLi0KFD+Pj48PTpU+7evSs6nioqKgp3d3eaNWumHnN3d8fZ2Znz588LTJZJp9Nla+1ctGhR+cD/P6J///6cOHGCIUOG0Lp1a5ydnSlWrBjPnj0jPDyc/fv3A2imkErKH/Xr1+f58+eaL/oAuHDhAu7u7vj6+qqFHz4+PtSrV48LFy6IDWdkrK2tsba25t133+W9996jUqVKoiNJBczMzIzExMRsx1+8eKGpMQ9S/qhVqxaXLl2iR48efPzxx5w+fZrw8HD0ej2tW7cWHS+b9PR00tPTKVKkCFeuXOH333+nYcOGmhhFmsWYFq1iYmIoW7Ysc+fOpVy5cpiYmIiOlCOt30v9XdWqValatSqpqamkpqaqI15SU1M1+b569epVAgMD2blzJ0+fPhUdR5JUs2bNIj4+nqJFiwKZf0MNGjTg8OHDzJ07l4CAAMEJ/2JnZ0dYWBh//PEHkPl5dfz4cc6ePYu9vb3gdJJkHI4fP06ZMmVwdHTk+PHjr7zWw8OjgFJJkiRJUu5k4YdkdEJDQwkLCyMlJSXbjh+ttamV/puaNWvG9u3bWbx4MY0aNWL48OEcOHCA5ORkKleuLDqeqkSJEly/ft1gXEZ8fDxRUVGUKlVKYLK/xMfHG9xYxcfHA3DixAmDv395c/Xmadq0KWPGjOG7777j119/ZdeuXeo5vV6PoigMHTpUeLcnKX8NGDAAf39/pkyZQpMmTbCwsDCY86qlv/3ChQtz//59g/emlJQUbt26pT4Ylv6dM2fO8PTpU9q0aSM6ilTA6tevz5EjR5g8eTJdunQBUEdWvPvuu2LDSfkuKCiIJUuW8MMPP7BkyRIAypQpw5dffom3t7fgdIauXbuGn58fEyZMwNHRka5du5KWloapqSlLly6lUaNGwrL5+vrSoEEDRowY8Y/dJzZu3FhAqf5ZrVq1MDExwc3NTXSUVzKGe6kskZGRjB8/nitXrmR7hqKl8TkpKSns2rWLTZs2ER4eDmR+7zc1NZXfBSTNCA8Pp1atWnz77bcAmJubExAQQNeuXTVX9PXxxx8zefJkPvjgAxRF4ciRIxw5cgS9Xk/Pnj1Fx5Mko+Dn50fLli1ZuHAhfn5+Bs8jXqalz1Ote//999VRWZIkSdLrJws/JKPyww8/sGjRomzHsxYBZeGHpAVffPEFL168wMHBAR8fH5o0acLJkycxMzNj+PDhouOp2rdvz8qVK/H29kZRFM6cOUOrVq14/vy5ZuYshoWFGbR5z+Ln56e+ljdXb67+/fvTpEkTNm3axIULF3j69CnFihWjVq1adOvWDWdnZ9ERpXzWt29fFEUhMDAwW0tVrf3te3p6sn37drVdaUREBO3btycuLo5OnTqJDWekGjRowMWLF3n48CFly5YVHUcqQMOGDeP3338nKCiIoKAgIPP7vrm5OUOHDhWcTspvSUlJ3L9/H51Opy5SJycn8+TJE8HJsps1axb37t3j9u3bXLhwgdTUVDw8PDhx4gQ//vij0MKPsLAwypQpo77OTW4LGKJ8+umnfP7550yZMgUPD49sHQC1UvRpDPdSWSZOnMjly5dzPKeF8TmRkZFs2rSJnTt38vz5c4NMdnZ2bNy4UX4PkDQjNTWVQoUKZTuu0+lISUkRkCh33bp1Q6fTERAQQFxcHADlypVj4MCBsvBDkvLI1tZWLei0tbUVnObNkFU4J0mSJOUPRa+FuzxJyiNvb29u376Ng4MD1apVw9TUsHZp9uzZgpLlbvfu3Vy7dk0WpfyH6fV6Ll26RPny5SldurToOKrU1FTGjh3Lnj17DI77+PgwY8YM4TvUPT0983ytMbWvliQp7/7pfUBLf/vPnj1jwIAB2RbXnJycWLJkiZz7+z/4/PPP2bdvH4UKFaJixYpYWloaPGjX0g516f/u7t27FClSRP1biYyMZO7cuYSGhmJiYoKzszP+/v64uLgITirlt+bNm/PgwQO1aDomJobNmzejKAqNGjVixYoVoiOqGjduTJkyZdi+fTu+vr7Ex8dz4MABfH19uX79OqdPnxaWbdu2bVSoUIFGjRqxbdu2V16rpRnrjo6ORrGb9lX3UjNnztTUmDpnZ2esrKxyHZ9jZ2cnKFnmwnTWSDy9Xo+lpSUtW7akffv29O/fn5o1a/7j768kFaTevXsTGhpK165dadasGenp6Rw+fJgdO3bg5ubGmjVrREdU7dq1C3d3d2xsbIiPj8fMzAxLS0vRsSRJkiRJkqR8JAs/JKNSr1493nrrLbZt26a5nUl5ldWdRHqzJSYmEh0dTWpqarZdVO7u7oJS5ezmzZtcunQJU1NTqlevTqVKlURHkiRJMlqnTp0yeE9t3Lix6EhGy9HRMddziqLkuntZMk41a9bE29ubhQsXio4iCebo6IiDgwPff/891atXBzIL/SZNmkR8fLym/vZdXFxo1KgRc+fOpUGDBrRu3ZrvvvuOfv36ER4ezrlz50RHBLIXVmWJjY0lKSnple+3Bc2Yij7BOO6lOnfujIWFBevWrRMdJZusQh9zc3OGDx9Oz549MTMzU8/Jwg9Ja86dO0ffvn1JS0tTj+n1eszMzFixYoWmxlS5ublRoUIFdu7cKTqKJL0Rxo8fj5OTU7aOObNmzSIhIYHp06cLSiZJkiRJf5GjXiSj0rx5c65du6b5won09HQ2btxITEwMKSkp6sJ/YmIiYWFhHDlyRHBCKT8dOHCAcePG8fz582zntLRLrU+fPri5ueHv72/wgHLs2LE8fPiQ5cuXC0wnSZL0l0ePHhEREUHRokVxcnKiePHioiPlqnHjxrLY4zWRLWD/W/R6vSZGDkji9erVizFjxmBubq4e8/T0pG7dukyePFlgsuzKly9PREQE3333HTqdjsaNG3P48GHOnj1L1apVRcdTeXl55VhY9cUXX3Dz5k2OHj0qKFl2WivseJUbN25w+/ZtWrduDcDixYvx8vKiWrVqgpMZmjx5Mv369WPSpEk0b95cU+NzSpcuzePHj0lJSWHmzJns3buXdu3aqf+mkqQ19evXZ+PGjSxbtozIyEj0ej01a9akf//+1K5dW3Q8A3Z2dmRkZIiOIUlGLTo6Wh03uG3bNm7evKkWJkPmmKfDhw9z9+5dWfghSZIkaYLs+CEZlb179zJ58mTq1atHo0aNsLCwMCgC6d69u8B0f/nmm29Ys2aN2t3j5f81MTHRzMK/lD/ee+89rly5gomJCaVKlco2kkhk4U9ISAh37twBYNy4cdSqVYs+ffqo53U6HT/88AOPHz8mPDxcVExJkiQgs5Dyq6++YuvWrWRkZODl5YWrqyu7d+9m6dKllCxZUnREVUxMDFOnTiU8PDzbfG8tFf1JklY5Ojri7e3NokWLREeRBNPr9Vy/fp2nT59iaWlJlSpVso2m0IqAgADmzZsHQMmSJfntt9+YNGkS+/bt4+uvv6Zr167Csq1fv569e/cCcObMGUqVKoWDg4N6PiMjg7CwMMzMzDh//ryomLmKj4/PtokiJCSEDz/8UHCyTKGhoQwYMIDGjRvz448/otfrqVu3LiYmJixdulRTu/53797N2LFjSU9Pz3ZO9HeU9PR0Dh06xJYtWzh27Bg6nQ5FUTAxMUGn01G5cmV27NhhUAgmSVLefP/99yxbtoyqVatSr149g7GJiqIwfPhwwQklSft2797NyJEjgdy7eOv1euzs7Dhw4EBBx5MkSZKkbGThh2RUXjXvF9BM29/mzZvz7NkzPvvsM2bPns3w4cOJjY1ly5YtTJgwwWChXXrz1K1bl5IlSxIUFETZsmVFxzFw4sQJPv7441f+Hen1eqpWrcquXbsKMJkkSVJ2c+fOZfHixdja2nL37l28vb2xsbFh/fr1dO7cmW+++UZ0RNVHH33E6dOncz0fGRlZgGneHJcuXWLWrFmcPXsWyByXNnr0aGrWrCk4mfS6OTo6YmVlRZUqVf7x2o0bNxZAIqmgpaamsnDhQjZu3GjQOa9YsWJ0796dzz//XJOLvxs3biQ2NpYuXbpQrVo1Vq9ejaIo9O7dW2iuBw8e0KpVK5KSktRNCDlp2bKlpkYshYaG4u/vr+6u/Tut3PP36tWL0NBQPvnkE4YPH05qaiozZ85k/fr1uLm5sWbNGtERVS1atODevXtYWFhQsmTJbPeCWumyEhcXx9atW9Ud1ZC5OG1lZUXnzp0ZM2aM4ITSf1VgYCAVK1akadOmBAYGvvJarWxIA8OxiS//3WctXmvl/VSStO7jjz8mOjqaBw8eYG5ubrABJWvT32efffaP4+okSZIkqSDIwg/JqPzTwzOtPFxxcnKicePGLF26lI4dOzJ06FBatmzJ+++/j16vZ/v27aIjSvnI19cXMzMzzfw+/t3kyZOJjo7m3LlzWFlZGbShNjExwdramo8//hgXFxeBKSUpu7/v/Mxia2srKJGU3959913MzMzYtWsXzs7OeHt7M2fOHFq3bk1ycjInT54UHVHl6uoKwLRp06hevbo6nz7LyyO1pLyJjIzkww8/JCkpyeC4hYUFGzZsMHiYLRm/rALvf7o9lQsVb6b09HT69+9PSEhIjr8DiqLg6urKypUrs3XTE+nhw4e5Fnrv2bOHNm3aFHAiQ6dOneL27dtMmjSJWrVqGXTLyPre36RJEwoXLiwwpSFfX1/CwsKwsrIiISGBcuXK8eTJE1JTU2ndurXaYUU0V1dXHB0dWbduncHxXr16ceXKFUJCQgQly65evXpUrFiRLVu2aLJ4KienT59m06ZNBAcHk5KSIt/7JaEcHR3VIjlj2ZAGmV1eX5VVjlWUpH/H09MTDw8Ppk6dKjqKJEmSJOVKO09MJCkPtLqQ/nclSpRQx2nUrl2bU6dO0bJlSxRF4caNG2LDSfkua4by0qVLadKkSbaRRHnZyZqfsm5QevfujaurK8OGDROaR5L+yblz5xg3bhy3bt3Kdk50e2opfz1+/JgGDRoYLFKYm5tjZ2dHRESEwGTZlS5dmooVKwpf5HuTzJ07l6SkJHx9fenWrRuQueMyMDCQefPmERAQIDih9LrVrFlTeJcESYz169dz5swZbGxsGDZsGI0aNaJMmTLExcVx9OhRfvzxR86ePcvatWvp27ev6LiqDz/8kBUrVmBvb68e++OPP/jmm284d+6c8M+Exo0bA2BqakqFChVo1KiR0Dx5ERUVRY0aNdiyZQtNmzZl4cKFlCxZks6dO2crqhTt6dOn2Y7Fx8ej0+kEpMmdp6cnV65cUUc8GIOGDRvSsGFDnj17xo4dO9iyZYvoSNJ/mLu7O9WqVVNfG4sZM2aIjiBJbxStdMiSJEmSpFeRHT8kzUtNTaVQoUIUKlSI1NTUV16rld0r/v7+7N+/n6FDh1KhQgW++OIL7O3tuXnzJhUqVJBfFN9wr2o/bwyL1ElJSYSEhPDOO++IjiJJQGa73PDw8FzPyxEab66OHTty48YNvvvuO/z9/WnUqBFt2rThq6++wtHRka1bt4qOqPr111+ZPHkyK1euxNnZWXScN4Krqyv29vbZOqW999573L59Wx3/Ir0ZHB0d8fb2ZtGiRaKjSAJ07dqVyMhItmzZQvXq1bOdv3DhAh9++KFaEKAVjo6OlC1blmXLllGyZEnmzp3LL7/8QkZGhuZmvUdFRRETE0NKSop67MWLF4SGhjJ37lyByQy5uLhQv359VqxYwccff0yLFi3o1asXH3/8MVeuXOH48eOiIwIwaNAgjhw5goeHB02bNiU9PZ2jR48SEhJCs2bNWLJkieiIqrVr1/Ldd99RqVIlGjVqRJEiRQzOjxgxQlAySZJet+PHj1OmTBkcHR3/8f3Sw8OjgFJJkvHy9fWlQYMGjBgxAl9f31deK8dRSpIkSVogO35Imufi4oK3tzcLFy585egJLS2of/HFF9y5c4cKFSrQpk0bVq9erbZ7HDBggOB0Un57VT2dlmrtYmJiGD16NNeuXTN4AJxFSy1Kpf+2qKgoSpUqxeLFi6lRo4amWrxL+cvf35+hQ4fy+eefoygKp0+f5vTp0+j1es19nm7atAlTU1O6d++OhYUFRYsWVc8pisKxY8cEpjNeOY0f0NJIAkmSXo+YmBgcHR1zLPoAqFOnDo6OjsTExBRwslfr2bMn69ato2fPnuh0OhITE7G0tOSTTz6hT58+ouOpAgMDmTJlSq7ntVT4YWdnR1hYGCEhIbi4uBAYGEiJEiUIDw/X1L3U6NGjOX/+PMeOHVMXV/V6PSVKlGD06NGC0xmaNm0akPmd+urVq+pxvV6Poiiy8EOS/gdaHUPq5+enjqXx8/PLddSLlp6hSpKWhYWFUaZMGfV1bl41VkmSJEmSCpJcOZE0T6/XqzdSxrKgXq5cObZs2UJqairm5uasXbuWEydOYG9v/8puENKbwVi6D0yfPj3XG31jal8qvfns7e2xtraWXRT+g7y9vQkICGDx4sVcvnwZU1NTHBwcGDBgAC1atBAdz8CZM2fU14mJiSQmJqo/y4dA/5vatWsTEhLC4sWL6dKlCwCbN28mIiLCKMYVSP/O+++/T+3atUXHkATJyMj4x8JOU1NTTd3zAUyaNAk7Oztmz56NXq/H3d1dHU2iJatWrUJRFN555x0OHz6Mj48P169f5+rVqwwcOFB0PAN9+/Zl8uTJRERE4OPjw+LFixk7dix6vV5THQmrVq3Kjh07WLduHZGRkej1emrWrEmPHj0oX7686HgGOnXqJL+LSNJrovUxpLa2tpQqVUp9LUnS/823335LhQoV1NeSJEmSpHVy1IukeXfu3MHCwgJra2vu3Lnzymvt7OwKKFXePHnyhOTkZM3tAJAKRnJyMpcuXUJRFGrVqqW5Hcpubm6ULl2ajRs34uXlxdq1a0lMTKR///5069aNiRMnio4oSQCcPHmSzz77jGnTptGkSRODTgqgnTFf0n/by4UfOWnQoEEBJXlznD59mn79+mX7HqUoCsuWLaNx48aCkkmS9Lq1a9eOO3fusHv37hzvlWJjY+nQoQNvvfUWO3fuFJDwL4GBgdmO7d+/n+PHj2NqasqQIUOwtrYGMsfVaYGLiwvOzs6sWbMGT09Ppk2bhqurK23atKFSpUqsXLlSdEQDhw4doly5ctSqVYtt27axfPly7O3tmTx5suaKKiRJ+m+RY0gl6b/r7t27FClSRP2elyU2NpakpCQcHR0FJZMkSZKkv8jCD0nKBxEREYwbN47r169nO6eFHQBS/tu4cSOzZ89Wd3wXK1aM0aNHa+bhL2S2zG7QoAHLli2jd+/edOjQgW7dutG/f3+uXbvG4cOHRUeUJAC8vLyIj48nOTk52zn5nvrmO3DgAJcvXyY1NTXbOdma/M137NgxZs6cSXR0NACVK1dmxIgR+Pj4CE4mSdLrNHfuXBYvXoyDgwMTJ07E3d0dExMTMjIyOHnyJNOnT+fGjRsMGTKEzz77TGhWR0fHHLsnZD1aefmcVkYnurm54eDgwIYNG/D396dGjRoMGTKEvn378scffxASEiI6oiokJIRSpUpRrVo1g+OnT58mOTmZ5s2bC0pmKCMjgx07dhAeHp5t3IOiKHzzzTcC02UXFRVFTEyMwYjPFy9ecPbsWebMmSMwmSQZl3r16lGkSJFcx5AWKlRIULLs0tLSuHHjBs+fP8fCwoIqVapobkOSJBmTmjVrquPoX9arVy9u3rzJ0aNHBSWTJEmSpL/IUS+S5o0cOTLP137//ff5mCTvvvrqK65du5bjOVlr9ebbt2+fOkO7ePHi6PV6nj9/zpQpU7C2tqZly5ZiA/5/5cuX5+LFi0RFReHs7My2bduoWrUqV65cMRhRIEmivarbk3xPfbPNmTOHpUuXZjuulZn0c+bMoVq1anTs2PGViyaKojB8+PACTPbmaNasGc2aNSMhIQETExMsLS1FR5IkKR/4+fmxd+9erl69St++fSlUqBAlS5bkzz//RKfTodfrqVKlCv369RMd1ShHIlavXp2wsDC2bt1K/fr1CQgI4N69e5w5cwYrKyvR8Qz07t2bli1bZltUWbhwITExMZw6dUpQMkPffPMN69atA7J/H9Va4UdgYKB6f5oTWfghSXlnDGNI7927x+zZszlw4IBB8XyhQoXw8fFh5MiRmuuYLElatX79evbu3Qtkft6HhobSp08f9XxGRgZhYWGYmZmJiihJkiRJBmTHD0nz8tomTVEUzeyoqlOnDpaWlqxatYq33norW8W/lnYASK9fly5diIyM5LvvvqNNmzYA7N69m1GjRlG7dm2CgoIEJ8wUEBDAvHnzGDZsGG5ubvTq1UvdoVi/fn31QaYkiWZsY76k16dhw4YkJCTQqFEjypUrh4mJicF50TN2HR0d8fb2ZtGiRa/cAa6l7yjGICkpieDgYO7fv4+trS1eXl4UKVJEdCxJkvJZfHw8kydP5uDBg2RkZKjHFUXB09OTqVOnUrp0aYEJjVdoaCgDBgxg9OjReHt706FDBxISEgDw9fV9ZVFAQVi+fLl67/HyqNcsGRkZ3Lt3D0tLS810J2nevDlxcXG88847VK9ePduu/2HDhokJloO2bdty48YN3nnnHQ4fPoyPjw/Xr1/n6tWrDBw4UHghrSQZE62PIb116xbdu3fnyZMnuW6SsLa2ZtOmTVSsWLGA00mS8Xnw4AGtWrUiKSkJRVFy/bvKqWhVkiRJkkSQHT8kzRPdyvd/8fbbb1O8eHEcHBxER5EEiI6Opn79+mrRB2Q+bNuwYcMrZ8EWtEGDBlG8eHEcHR1xc3PD39+fn3/+GXt7e+EPfyXpZa8q7Hj27FkBJpEKml6vx93dnZUrV4qOkqNOnTrh5OSkvs6p8EP6d2JiYvjoo494/PixeqxixYqsXr2aChUqCEwmSVJ+s7a2ZtGiRcTHx3Px4kUSEhIoXrw4tWvXxsbGRnS8XIWEhBAXF0f79u0BmDJlCj4+PjRp0kRwsr+4ubmxf/9+dDodNjY2rFq1is2bN1OxYkV69uwpOh4ffPABixcvJiEhAUVRSEpKyrHw9+X7K9ESExOpW7cuS5YsER3lH925cwdXV1cCAgLw9PTE19cXV1dX2rRpQ0REhOh4kmRUJk2ahF6vz7E7sRbGkM6bN4/4+HgaNmzIZ599Rs2aNSlatCiJiYlcvXqVZcuWERwczA8//CC8iF6SjIGNjQ0//vgjt2/fZtKkSdSqVYsPP/xQPW9iYoK1tbWmvvdJkiRJ/22y44ckvSYvt08MDQ1l6NChTJo0CS8vr2wzNEXvAJDyV+PGjSlRogR79uxRd6frdDratGnD8+fPOXnypOCEme7evUuRIkUMdtMB3Lhxg+Tk5Dx325Gk/Pb8+XN++OEHdS551leXxMREoqOjCQsLExtQyjfffvstu3btYsOGDdjb24uOIxUAPz8/jh8/TtGiRXFwcCAqKork5GR8fHyYP3++6HiSJEkGgoOD+fzzz2natClLlixBp9Ph4uKCXq9n/vz5eHt7i45oICUlhdjYWExMTKhUqZKm7kujo6N58OAB/fv3p379+gwdOlQ9pygK1tbWVK9eXWBCQ19++SWnTp1iz549mu/o6ebmhoODAxs2bMDf358aNWowZMgQ+vbtyx9//KGZLiqSZAz+6TlJZGRkASXJmYeHBxkZGRw6dCjbs0jIfHbp7e2NXq/n2LFjAhJKkvHatm0bFSpUoFGjRqKjSJIkSVKuZMcPyehERUWpi39ZXrx4wdmzZ4XOpnVxccl2bPz48dmOaWEHgJS/mjRpwu7duxk0aBCdOnUCMm8Obt26Rdu2bcWGe4mnp2eOrQgnTpzIzZs3OXr0qKBkkmRo+vTpbN++XR2Z8XLNavHixQUmk/LbJ598wvbt22nfvj2VK1fGwsLC4PzGjRsFJctZVjFSampqthaw7u7uglIZl4iICCwtLfn1118pV64c169f54MPPiA0NFR0NEmSpGx+/PFHAN555x0gs1PViBEjmDNnDosXL9ZM4Ud6ejrz5s1j9erVpKWlAZmbEfr27Yu/v78mCheqVatGtWrVWL16NaVKldJ898zq1auzZ88eOnfujLu7OxYWFgadv7Q0PqV69eqEhYWxdetW6tevT0BAAPfu3ePMmTNYWVmJjidJRuXAgQOiI7zSn3/+ScOGDXMs+oDM9/6aNWty4sSJAk4mScbv/fffJyoqij179mRblwgNDWXu3LkC00mSJElSJln4IRmVwMDAV46gEFn4kdfmObLJzptvxIgRnDx5kqNHj6o7KPR6PSVKlBA+63n9+vXs3btX/Tk0NJQ+ffqoP2dkZBAWFoaZmZmIeJKUo6NHj1KyZEmmTJnCyJEj+frrr7l37x4LFiwwynFgUt5NnjyZhIQEAK5cuWJwTmtjVQ4cOMC4ceN4/vx5tnOy6DPvXrx4QaNGjShXrhwAVapUoU6dOrLwQ5IkTbp+/Tru7u706tULAFNTU/r378/Ro0c1NUJj9uzZrF69Gr1eT9GiRYHMYsUlS5aQlpbGmDFjBCf8y927d7l79y5//PFHjuezCutF+/rrr1EUhadPnxIVFaUezypU1lLhx4gRIxgwYADJycm0bduWn376ic2bNwPQqlUrwekkybi8PIY0Li4ORVE0NY4sPT2dIkWKvPIaU1NTdDpdASWSpDfHP61LyMIPSZIkSQtk4YdkVFatWoWiKLzzzjscPnwYHx8frl+/ztWrVxk4cKDQbFqv+pcKjp2dHb/88gsBAQGEhoZiYmKCs7MzAwYMED6qwNvbm9mzZ5OUlISiKDx58oQzZ85ku65FixYC0klSzhISEmjSpAmtWrViyZIlmJubM3jwYI4ePcqmTZvo27ev6IhSPjl27BgWFhYMGDCAcuXKqeOztGjBggU8e/YMExMTSpUqhamp/Jr9v9DpdNkeVhctWlQ+nJYkSZPMzc25c+cOOp1O7ZqRmprKzZs3NfU5sH37dszNzVm0aBHNmjUD4NSpU3z66ads3bpVU4Uf48aNe2Vxp1YKPzp16qS5ItTcuLm5sX//fnQ6HTY2NqxatYrNmzdTsWJFevbsKTqeJBmdI0eOMG3aNG7fvg1ApUqVmDBhAs2bNxecLFN8fDzHjx/P9fzjx48LMI0kvTm0vC4hSZIkSVm08yRCkvLgzp07uLq6EhAQgKenJ76+vri6utKmTRvhO6pervp/2YsXLzAxMcnWnl56s9nY2DB58mTRMbKxsbHhxx9/5Pbt20yaNImaNWvSo0cP9byJiQnW1tY0adJEYEpJMlSyZEliYmJITk7GycmJQ4cO4ePjw9OnT7l7967oeFI+Kl++PLa2tgwePFh0lH8UGxtL+fLlCQoKomzZsqLjGLW/P6yOj48H4MSJEwad0zw8PAo8myRJ0ss8PDzYvXs3nTp1omHDhuh0Ok6dOsW9e/do3bq16HgqvV5PvXr11KIPgMaNG1O3bl3NdaSqV6+eWlCh1+tJTU0lNjYWvV6Pj4+P4HR/mTFjhugIedalSxfc3d0ZN24cAI6OjkycOFFwKkkyTmfOnGHw4MEGRcmxsbEMGTKEFStWaGK8Y1hYGAMGDMj1fFZnIkmS/h0tr0tIkiRJUhZZ+CEZFTMzM9LT0wFwcnLi/PnzNGnShEqVKuXaClaUDRs2sGTJEu7fvw+Ara0tgwYNomvXroKTSfkhMDCQihUr0rRpUwIDA195bffu3QsoVc4aN24MZC6k2dnZ0b59e6F5JOmfNGvWjO3bt7N48WIaNWrE8OHDOXDgAMnJyVSuXFl0PCkfjRw5krFjx7J7926aNWuWbVa1ubm5oGTZOTo6YmZmJos+XoPcHlb7+fmpr+X4HEmStGDMmDGEh4dz9epVoqOj1eI0Ozs7xo4dKzjdXzp06MCePXuIj4/H2toayFy8uHTpEt26dROcztCGDRuyHXv69CkffPABDg4OAhL9JSQkhFKlSlGtWrVcrzl8+DA3b940GKcp2q1btyhWrJjoGJL0Rli4cCE6nY6RI0eq75+BgYHMmTOHBQsWsGbNGqH5bG1thf7/S9KbzJjWJSRJkqT/LkX/8rY5SdK4Hj16EBYWxrRp03j69CkBAQF4e3uzdetWrKysOHXqlOiIACxevJh58+bx9z+vrFm/r6q8l4yTo6MjLVu2ZOHChTg6Or5y98Tly5cLMFnu3NzcqFChAjt37hQdRZJe6fnz50yYMIHWrVvTqlUrBgwYwMmTJzEzM+P777/X1O5P6fVq1aoV9+/fJzU1Nds5rS38X7p0iX79+uHn50eTJk2wsLAw+CyoUqWKwHTGw9PTM8/XHjx4MB+TSJIk5U1iYiI7d+4kMjISvV5PzZo1ad++vaYW2ufMmcOaNWswMzOjfv36pKWlce7cOdLS0vD29lbH1AB8//33ApPmbty4cZw5c0boe//L93wA3377LSEhIWzdulW9ZsiQIRw8eFAz93wAc+fOZfXq1XzzzTe4ublhaWlpMD5PS4W0kqR19erVo0aNGmzcuNHguK+vL1euXOH8+fOCkkmSlN+MZV1CkiRJ+m+THT8ko5JVNJGcnEzbtm356aef2Lx5M5C5OKQVa9aswcTEhEmTJqktfvfv38+UKVNYvXq1LPx4A7m7u6s7v7TQ2jMv7OzsyMjIEB1Dkv5R8eLFWbBggfrzsmXLuHTpEuXLl6d06dICk0n5LTY2NtdzWqtd7tKlC5C5uDZnzhyDc1orUtEyWcwhSZKxKVq0aI4d/Z49e4alpaWARNktWbIEgKSkJA4fPmxwbu/eveprRVGEF368POoLQKfTcf/+fQ4dOkRKSoqgVH95+fvH7du3NVXgkZudO3eSkpLCiBEjsp2T31Ek6d8xMzMjMTEx2/EXL17IIipJesMZy7qEJEmS9N8mCz8ko+Lm5sb+/fvR6XTY2NiwatUqNm/eTMWKFenVq5foeKoXL17g6uqKr6+veqxr167s3LmTCxcuCEwm5ZeX23mKbu2ZV++88w7Lli2jQ4cO1KtXD0tLS3W3n6IoDB8+XHBCSfpLeno6+/fvJzw8HDs7O5o2baq22JTeXAcOHBAdIc9eVYiitSIVSZIk6fV4/vw5P/zwAzExMaSkpKjv94mJiURHRxMWFiY24P83ZMiQV3Yk1BI/P78cs+r1et59992CD/QGuHv3bq7n5HcUSfp36tevz5EjR5g8ebJa+L1lyxaio6Ple5QkveFetS7Rs2dP0fEkSZIkCZCFH5KRiYmJoWrVqurPjo6OTJw4kdTUVFauXGkw+10kLy8vzp49S0pKCoULFwYyd3xdu3aNtm3bCk4n5bc+ffrg5uaGv7+/wfGxY8fy8OFDli9fLiiZoaVLlwKoM8mz6PV6WfghacrDhw/p37+/+nvq5eXF06dPWbVqFatXr8bR0VFwQim/2NnZiY6QZ5GRkaIjSJIkSQVs+vTpbN++Xf3+/PIievHixQUmMzR06FDREfLM1tY22zELCwvq1KnDqFGjBCQyfsZUSCtJWjds2DB+//13goKCCAoKAjKfoZibmxvVe60kSf+bMmXKkJKSQlRUFKampowZM0Z2+5EkSZI0RRZ+SEalZ8+eLFmyBGdnZ/XY/v37mT17Nrdu3dJM4YeTkxMHDhygY8eONGvWjNTUVA4fPsyff/5J0aJF1RbwcnH9zRESEsKdO3cAOHPmDM+fP6dSpUrqeZ1OR0hICI8fPxYVMZtOnToZzc4/6b9txowZREdH06ZNG3bv3g1ktth9+vQps2fPZtmyZYITSq+Tr68vDRo0YMSIEQads3Ly99naWvX3wlVJkiTpzXD06FFKlizJlClTGDlyJF9//TX37t1jwYIFfPbZZ6LjGYiNjWXlypWEh4fj5OREmzZtSE5OpkWLFqKjGZAjv14/YyqklSStc3R0ZOPGjcydO5fQ0FBMTExwdnbG39+fWrVqiY4nSVI+Sk9PZ968eaxevZq0tDQAzM3N6du3L/7+/moXZUmSJEkSSRZ+SEblzz//pF+/fixatIiSJUvyzTffEBoail6vp27duqLjqWbMmAFkPly7efMm8FcL1bVr16o/y8KPN0dqairjxo1DURQUReHy5cuMHz/e4Bq9Xq+phb+s31NJ0rrjx49Tu3Zt5syZoxZ+DBw4kL179xIeHi44nfS6hYWFUaZMGfV1brRWuBYXF8f06dNzbPefkJDApUuXBCeUJEmSXreEhASaNGlCq1atWLJkCebm5gwePJijR4+yadMm+vbtKzoiABEREXz00UckJSWhKAq2tracOHGC5cuXM2/ePHx8fITmS01NzfO1onfVPn78mOPHj6uvAU6cOKF+7mup0P/GjRssWrSIr776imLFilGzZk2D805OTmzatElz36kkSct27dqFu7s7ixcvFh1FkqQCNnv2bFavXo1er6do0aJA5v3+kiVLSEtLY8yYMYITSpIkSZIs/JCMzOjRo/nuu+8YOHAgGRkZ6HQ67O3tGTFiBG3atBEdTyU7Kfz3NG3alG7duhEdHc25c+ewsrIyKPIwMTHB2tqajz/+WGDK7KKiotRFyiwvXrzg7NmzamcaSRItJSUFMzOzbMd1Op2cS/4G+vbbb6lQoYL62lhMmzaN/fv353iucuXKBRtGkiRJKhAlS5YkJiaG5ORknJycOHToED4+Pjx9+pS7d++KjqeaPXs2aWlpTJkyhSlTpgDg7OyMiYkJAQEBwgs/XFxc8nSdoijCCynDwsIYMGCAwbGXO49mbfAQ7c6dO/Ts2ZP4+Hh69OhB/fr1s31vvnjxIsHBwbRs2VJQSkkyPl9++SUVKlRg586doqNIklTAtm/fjrm5OYsWLaJZs2YAnDp1ik8//ZStW7fKwg9JkiRJE2Thh2RUPv74YypWrMiYMWNIS0ujcePGLF26FFNTbf0qy04K/01Tp04FoHfv3ri6ujJs2DCxgf5BYGCg+uA3J7LwQ9IKV1dXTp48ybRp0wC4desWI0eOJCoqiiZNmghOJ71u77//fo6vte7MmTOUL1+eRYsW0aNHD3744Qfi4+OZMGEC7dq1Ex1PkiRJygfNmjVj+/btLF68mEaNGjF8+HAOHDhAcnKypor+Lly4gLu7O76+vur3fx8fH+rVq8eFCxfEhoM8F/KKLvi1tbUV+v//byxbtozHjx9TrVo1rKys1OOurq58/vnnBAUFsXPnTnbt2iULPyTpX7CzsyMjI0N0DEmSBNDr9dSrV08t+gBo3LgxdevWFV6YKkmSJElZtLVaLkk5yGnxuW7dupw+fZrff/+dKVOmYG1tDcCIESMKOp4qq91rXnh4eORjEkm0NWvW5Hg8KSmJkJAQ3nnnnQJOlLNVq1ahKArvvPMOhw8fxsfHh+vXr3P16lUGDhwoOp4kqcaNG0evXr3UUVlRUVFcuXKFYsWKMWrUKMHppNdt0aJFebpOURSGDBmSz2nyLjExEWdnZ5ycnKhVqxaPHz+mU6dObNmyhV9++YWhQ4eKjihJkiS9Zl988QUvXrzAwcEBHx8fmjRpwsmTJzEzM9PUSM/ChQtz//59g8KJlJQUbt26pbYqF+nAgQOiI+TJwYMHRUfIsxMnTlC8eHHWrFlDqVKl1OOlSpWiQYMGODo6cuDAgVeO1ZMkKbt33nmHZcuW0aFDB+rVq4elpSWFChUCkOOcJekN16FDB/bs2UN8fLy6FnHnzh0uXbpEt27dBKeTJEmSpEyKXvSWCUn6B46Ojjm2Sv37r66iKFy+fLmgYmWTW86/00J7Wil/xcTEMHr0aK5du2YwQiWLyN/Tl7m4uODs7MyaNWvw9PRk2rRpuLq60qZNGypVqsTKlStFR5Qk1YMHD1i/fj2XL1/G1NQUBwcHevTogY2Njeho0muW189T0M77KUCLFi1IS0tjy5Yt/Pzzz9y8eZOpU6fy4YcfEh8fLxdWJEmS/gP0ej2XLl2ifPnylC5dWnQc1fjx49m+fTs1atQgMjISGxsbChcuzO3bt+nUqZNRjVaT8qZu3brUr1+f5cuXq8c6d+5Mo0aN1Fb0/fv3JzQ0lIiICFExJcnoODo6qq9fvmfJGvOkpfsTSZJerzlz5rBmzRrMzMyoX78+aWlpnDt3jrS0NLy9vdUiMIDvv/9eYFJJkiTpv0x2/JA0r1OnTpqYkftPjKntq5S/pk+fnmtxj7u7ewGnyZ2ZmRnp6ekAODk5cf78eZo0aUKlSpX4448/BKeTJEM2NjaaH58kvR7t27dXP/fT09PZt28fxYoVo379+iiKQmhoKBkZGfTu3VtwUkOtWrVi5cqVBAUF4eHhwSeffMK7774LQM2aNcWGkyRJkl6rpKQkgoODuX//PnZ2dnh6elKkSBEURaF27dqi42UzYcIErl+/rhYhPnjwAMi8Bxg9erTAZNn16dMn13Pm5uaULVuWli1b4unpWYCpjI+5uTl//vmnwbGtW7ca/PzkyRMsLS0LMJUkGT9jeUYpSdLrt2TJEiDze+Dhw4cNzu3du1d9rSiKLPyQJEmShJGFH5LmzZgxQ3SEPDGmtq9S/oqIiOCtt95i48aNeHl5sXbtWhITE+nfvz81atQQHU9VvXp1wsLC2Lp1K/Xr1ycgIIB79+5x5swZgznQkiTC+PHj83Sdoih88803+ZxGKkjfffed+vqbb76hZMmS7Ny5U22l+vDhQzp27JhjRyWRRo4ciaIo1KlTh+bNm9OlSxe2bNmClZUVEyZMEB1PkiRJek1iYmL46KOPePz4sXqsYsWKrF69mgoVKghMljtLS0s2btzIqVOnuHTpEqamplSvXp3GjRuLjpbNmTNnUBQlxw6fWce2b9/O1KlT6dq1q4iIRuHtt9/m4sWLREZGGnQoyBIeHk5UVBQNGzYUkE6SjJexPKOUJOn1GzJkiCz8kiRJkjRPjnqRNO/48eN5vtbDwyMfk/zfpKamsnv3boKCgli3bp3oOFI+qlOnDg0aNGDZsmX07t2bDh060K1bN/r378+1a9eyVYWLEhoayoABAxg9ejTe3t506NCBhIQEAHx9fZkyZYrYgNJ/2svjPl71VUW2032zubu7U7t27Wyjp/r06cOVK1c4ffq0mGB59OTJE6ysrDAxMREdRZIkSXpN/Pz8OH78OEWLFsXBwYGoqCiSk5Px8fFh/vz5ouMZvSNHjjBy5EiaNWtGu3btgMxCjxMnTvDFF1+QkpLCjBkzqFKlCjt27BCcVruCgoKYNGkSNjY2jBgxgsaNG1OqVCni4uI4evQoP/74I/Hx8Xz//fe0bdtWdFxJMipxcXGEhYWRlJSU7VynTp0KPpAkSZIkSZIk/X+y44ekeX5+fnmqplUUJdfxGiJdvXqVwMBAdu7cydOnT0XHkQpA+fLluXjxIlFRUTg7O7Nt2zaqVq3KlStXSExMFB1P5ebmxv79+9HpdNjY2LBq1So2b95MxYoV6dmzp+h4kgRA8eLFcXV1pUGDBpQqVUp0HKmAmZiYcP78eU6dOqXuSj5y5AhhYWEULVpUcLo3pzhVkiRJyruIiAgsLS359ddfKVeuHNevX+eDDz4gNDRUdDQDXl5eebpOURSCg4PzOU3eLV++nAoVKjB37lz1mJeXF+3atSM4OJiAgAD27t1LRESEwJTa17VrVw4dOsTBgwdz7KSn1+tp06aNLPqQpH9p+/btTJw4EZ1Ol+N5WfghSW+22NhYVq5cSXh4OE5OTrRp04bk5GRatGghOpokSZIkAbLwQzICtra2oiP8aykpKezatYtNmzYRHh4OZD5YMTU1pU2bNoLTSfmtS5cuzJs3j4MHD9KiRQuWLVtGr169AKhfv77gdIbKlClDSkoKUVFRmJqaMmbMGMzNzUXHkiTq1q3LxYsXefbsGUeOHOHo0aNUq1aNhg0b0rBhQ9zd3eVIov+Atm3bsmHDBvr374+FhQV6vZ7k5GT0er0mCtSMvThVkiRJ+vdevHhBo0aNKFeuHABVqlShTp06miv8uHPnTp6u01rL8vPnz1OrVi2DY4qiUKJECU6dOgVkFoZmZGSIiGdUFi1axNKlS1m7di0PHz5Uj1eoUIHevXvTr18/gekkyTgtWLCA9PR0bGxssLW1lZ39JOk/JCIigo8++oikpCQURcHW1pYTJ06wfPly5s2bh4+Pj+iIkiRJkiQLPyTtO3jwoOgIeRYZGcmmTZvYuXMnz58/NxhPYGdnx8aNGylbtqzAhFJBGDRoEMWLF8fR0RE3Nzf8/f1ZunQplSpV4ssvvxQdT5Wens68efNYvXo1aWlpAJibm9O3b1/8/f0pVKiQ4ITSf9nGjRt58eIFISEhnDp1ipMnTxIVFUVUVBRr165FURRq1KhBw4YNGTdunOi4Uj7J+m8bFBSkdkwyNzfno48+4vPPPxcZDTDO4lRJkiTp/0an01GkSBGDY0WLFs1197coK1asMPh5wYIFhIWFsXz5ckGJ8sbGxobw8HC+//57fHx80Ov17Nu3j7CwMOzs7Dhy5AhnzpzBzs5OdFTNMzEx4ZNPPmHAgAHcvn2bJ0+eYG1tjb29vehokmS0Hj9+TOXKldmxY4fcNCNJ/zGzZ88mLS2NKVOmqOOxnZ2dMTExISAgQBZ+SJIkSZqg6F9emZYkI5Samsru3bsJCgpi3bp1wnJ069aNCxcuAJndPSwtLWnZsiXt27enf//+1KxZk23btgnLJ0l/9+2337J69Wr0er06MiExMRFFUejXrx9jxowRnFCSDMXHx7N582Z+/vlndXSWoihcvnxZcDIpvyUmJnLz5k1MTEx46623KFy4sOhIkiRJ0n+Uo6Mj9erVY8iQIeqxRYsWER4ezs8//2xQ/K+lMV9Dhgzh4MGDmv/etHnzZiZOnJitE4ler2fKlCm8ePGC2bNn079/f3m/IklSgRs4cCAPHz6Uz/ck6T+obt26/6+9+46K4nr7AP5dBKQpYE3sBVbsYlc09orG3qIYgw1rjCVqirElaixY0FgSKxpBAQuCBVFRQRAFrIiiWBBRQRAs1Hn/4N357bK7dB2M3885niPT9pl2pz33XlhbW2PHjh2wsrJC165d4eTkBDs7O1y/fh2hoaFSh0hERMQWP+jTdffuXbi4uODo0aPiB0ApXbt2DTKZDPr6+vjhhx8wcuRI6OnpSR0WSSQ4OBihoaFISUlB9vy6qVOnShSVqkOHDkFfXx9OTk5o3749ACAgIACTJk2Cu7s7X6RSsZCUlITAwEBcvHgR/v7+ePTokco5ZWFhIWF09LEYGRnByspK6jDyrbgkpxIRUdEKDQ3F+PHj1YaPGzdO/D+7+SqYwYMHo3z58tiyZQsiIyORkZEBS0tL2Nvbo1u3bnBzc8O0adPg4OAgdahE9Jm4cOGC+P9u3bphyZIl+Omnn9C5c2e1FqCKU8IfERWtkiVL4tmzZyrvpFJSUvD48WOxQh0REZHUmPhBn5SUlBQcO3YMrq6uCAsLA5BV80dXVxe9evWSNLayZcsiLi4OKSkpWLFiBY4fPw5bW1v07NlT0rjo49u4cSOcnJzUhguCAJlMVmwSPwRBgLW1tZj0AQBt2rRBkyZN+JKaJLd27Vr4+/vj5s2byMzMFB+sLSws0LJlS/FfmTJlJI6USF1xS04lIqKiw26+PrwOHTqgQ4cOGscNGjToI0dDRJ+7cePGqbVC5OHhodbqBxP+iP7bOnfujEOHDmHAgAEAsiqB9unTB7Gxsejfv7+0wREREf0/Jn7QJyE8PByurq44evQokpOTVTJrK1eujP3796N8+fISRgicO3cOZ86cgZubG86fP4/Q0FCEhYVh+fLlAIB3794hNTWVfYB+Bjw8PCAIAiwtLWFhYQFd3eJZ1Pbt2xfe3t6Ij48XP55HR0fj1q1bGDp0qMTR0edu8+bNkMlkMDY2RrNmzcREj7Jly4rTvH//Hk+fPuUHGCoWinNyKhERFR1fX1+pQ8gT5RrqABAXFwcAuHjxolqLhKyhTkSkHZ83iQgAfvrpJzx48EDs0uX58+cAgAYNGmDOnDkSRkZERPQ/MiH7Ez9RMTN06FBcv34dQNYHlFKlSqFbt27o06cP7O3tUbdu3WLXt2ZsbCzc3d3h4eGBR48eAcjK/Dc1NcXAgQPZhcZ/nLW1NapXrw4PDw+1WiHFyZo1a7Bnzx7o6emhadOmSEtLw9WrV5GWloauXbuiRIkS4rSrV6+WMFL6HFlZWeXp/GGtKpLap5CcSkREnx/eSxEREREVvYCAANy6dQu6urqQy+Vo06aN1CERERGJmPhBxZ7ihZW+vj5++OEHjBw5Enp6euK44pj4oSwwMBCurq7w8fFBSkoKZDIZbt++LXVY9AHNmDED9+/fx5EjR6QOJUdWVlZ5mo7HLEmhc+fOeZ72U6l5S/k3aNAgtGjRAvPmzZM6FI0+xeRUIiL6PPBeioioaL19+xZGRkYqw5KSklCqVCmJIiIiIiIiUlU8+x8gUlK2bFnExcUhJSUFK1aswPHjx2Fra4uePXtKHVqetGrVCq1atUJSUhKOHDkCNzc3qUOiD6xnz55YsGABJk6ciNatW8PQ0FCltt2wYcMkjO5/pkyZUqxbJKHPGz9AEAA8fvwYxsbGUoeh1bVr17QmpxIREUmJ91JEREVn7969cHR0hLOzs0olmrVr1+L8+fNYtGgRa/0T/Qd16dIlT9PJZDL4+Ph84GiIiIhyxxY/qNhLT0/HmTNn4ObmhvPnzyMjIwMymQw6OjrIyMhAjRo1cOTIEejr60sdKhGA3JtVZusZRER54+joiN27d+OPP/5A8+bNUapUKejo6Ijjpb7229jYIC4uDkDWi57GjRuLyant27dnix9EREQFFB8fj5SUFLELtbdv3+Ly5csYMWKExJER0efmzJkzmDRpEmQyGX7++WeMGjVKHNelSxdER0dDX18fzs7OaNSokYSRElFRY2vJRET0qWHiB31SYmNj4e7uDg8PDzx69AhA1o2VqakpBg4ciB9//FHiCIkAOzu7HMfv2bPnI0WSu3v37qF06dKoUKECXFxc4Ofnh3bt2vGFKhEVC507d8azZ8+g6XZVJpPh1q1bEkT1P0xOJSIiKlrBwcGYPn06Xr16pXE8P6oQ0cdmZ2eHy5cvY8KECZg0aRIMDQ3FcfHx8Vi+fDmOHDmCrl27wsnJScJIiaioBQQEqPy9fv16hIaGYvv27WrTstUfIiIqDpj4QZ+swMBAuLq6wsfHBykpKcyspWLj8ePHqFq1qtRh5Ors2bOYOnUqfv/9d1SpUgUjR44EkPUx9bfffsPw4cMljpCIPne51a4JDw//SJHkjsmpREREhTd8+HCEhobC1NQUiYmJqFixIl69eoXU1FT07NkTa9eulTpEIvrMNGvWDBUrVoSXl5fG8ZmZmejevTtSU1Ph5+f3kaMjoo9pypQp8PX15TcIIiIqtnSlDoCooFq1aoVWrVohKSkJR44cgZubm9QhEQEARowYgZo1axarlj002bRpEzIzM6Grq4ujR49CR0cHM2bMwKZNm7Bv3z4mfhCR5E6fPi11CHlWsWJFTJo0CZMmTVJJTk1ISMCOHTuY+EFERJQHERERqFOnDtzc3GBjY4MNGzbAzMwMAwcOhJ6entThEdFnKD09HeXLl9c6XkdHB5UrV0ZISMhHjIqIiIiISB0TP+iTV6pUKYwcOVJsrYBIajKZDOnp6VKHkavIyEg0a9YMtra22LBhA+RyOSZMmIDAwEC+sCCiYqFy5coAgPfv3+PWrVuQyWSoV68eSpYsKXFkOWNyKhERUcFkZGSgTJky0NXVRYMGDXDt2jWMGjUKjRs3VmtunYjoY6hWrRpu3ryJuLg4lC1bVm38y5cvcfPmTfHZhYiIiIhIKkz8ICIqYvb29li9ejUWLVqE5s2bw8TEBCVKlBDHt2vXTsLoVOnp6eHFixeIiorCN998AwBISkpibToiKjb279+PlStX4u3btwAAY2NjzJkzB8OGDZM4stwxOZWIiCh/KleujNDQUFy+fBmNGzeGi4sLSpcujbCwMLCnYiKSQp8+feDo6Ijx48dj9uzZaNSoEYyNjZGUlITQ0FA4OjrizZs3GDNmjNShElERu3DhgsrfcXFxAICLFy+q3ZcUp/e9RET0+ZIJfHImIipSVlZWkMlkGsfJZDLcunXrI0ek2eDBgxEREYF69eohLCwMGzduREREBNauXYs2bdpgx44dUodIRJ+5kydPYvr06QAAExMTCIKAN2/eQCaTYf369ejWrZvEERIREVFRcnV1xYIFCzBnzhzY2Nhg0KBByMzMhCAI+Oqrr7B161apQySiz0xqaipGjRqFa9euaXzXIwgC6tWrh3379sHAwECCCInoQ8npHa+y4vS+l4iIPm9s8YOIqIhVqlRJ6hDyZOLEiZgxYwZCQ0PRoEEDfPXVV/D29oaenh4mT54sdXhERNiyZQtKlCiBVatWoVevXgAALy8vzJ49G1u3bmXiBxER0X/M0KFDUb58eVSsWBFWVlZYunQptm/fjqpVq+LXX3+VOjwi+gzp6+tj9+7dWLt2LQ4ePIjk5GRxnKGhIfr3749Zs2Yx6YPoP+hTecdLRESkwBY/iIg+Y5GRkXj06BFat24NQ0NDnDt3DmXKlEHDhg2lDo2ICI0bN0ajRo2wZ88eleF2dnYICwvDtWvXJIqMiIiIiIg+N5mZmXjw4AESExNhbGyMWrVqsatcIiIiIio22OIHEdEHcu3aNYSFhaFs2bJo1qwZTE1Ni10NkNq1a6N27dri323atIGXlxeWLVuGffv2SRgZERFgZGSE58+fIzMzEzo6OgCAjIwMxMbGwsTEROLoiIiIqKilpaXh33//xe3bt5Gamqo2fvXq1RJERUSURUdHR+UdChERERFRccLEDyKiIvbmzRtMmzYNAQEBAIAuXbrgyZMn2L9/P/bs2YPKlStLHKG6u3fvwsXFBUePHsXr16+lDoeICADQtm1beHl5wcHBAf379wcAeHh44PHjx+jdu7e0wREREVGRW7x4MQ4ePAgAyN5ArUwmY+IHERERERERkRZM/CAiKmIrV66Ev78/mjRpgtDQUABAYmIinj59ihUrVmD9+vXSBvj/UlJScOzYMbi6uiIsLAxA1stVXV1d9OrVS+LoiIiAmTNnwt/fH35+fjh//jyArHKqdOnSmDFjhrTBERERUZHz8vKCjo4O+vfvj4oVK4otfhERERERERFRzmRC9ioURERUKDY2NjA3N4enpyesrKzQtWtXODk5oXfv3oiLi0NgYKCk8YWHh8PV1RVHjx5FcnKySk26ypUrY//+/ShfvryEERIR/c/z58+xefNmBAcHQ0dHB40aNcL48eNRtWpVqUMjIiKiItauXTtYWlpix44dUodCRERERERE9Elhix9EREUsKSkJFhYWasNLlSqFmJgYCSL6n6FDh+L69esAsmrNlypVCt26dUOfPn1gb2+P0qVLM+mDiIqVChUqYMGCBVKHQURERB+BnZ0d/v77b1y9ehVNmzaVOhwiIiIiIiKiTwYTP4iIili9evUQHBws1lJ7+fIl1qxZg7CwMMlfXl67dg0ymQz6+vr44YcfMHLkSOjp6UkaExGRMhcXF1SpUgU2NjZwcXHROp2Ojg5KliyJ6tWro3Hjxh8xQiIiIvpQvv76a2zfvh0jR46EsbExDAwMxHEymUzs+o2IiIiIiIiIVLGrFyKiIhYcHAx7e3ukpaWJwwRBgK6uLrZt24Y2bdpIFpuNjQ3i4uIAZL04bdy4MWxtbdGzZ0+0b98edevWhYeHh2TxERFZWVmhW7du2LBhA6ysrCCTyXKdZ+zYsZg9e/ZHiI6IiIg+JDs7O1y+fFnjOJlMhtu3b3/kiIiIiIiIiIg+DUz8ICL6AMLDw/HPP//g9u3b0NXVhaWlJezt7VG3bl1J40pPT8eZM2fg5uaG8+fPIyMjAzKZDDo6OsjIyECNGjVw5MgR6OvrSxonEX2+7Ozs0Lx5c3z//fews7PLcdoXL14gKioKpUuXRlBQ0EeKkIiIiD6URo0awdDQED/99BMqVqwIHR0dlfEtW7aUKDIiIiIiIiKi4o2JH0RERezy5cswNzeHhYWFyvCgoCC8e/cOHTp0kCgyVbGxsXB3d4eHhwcePXoEIKsWnampKQYOHIgff/xR4giJiHKWkZGBpk2bQkdHByEhIVKHQ0RERIXUr18/mJmZYdeuXVKHQkRERERERPRJYeIHEVERU+6mQNmoUaMQGRmJgIAAiSLTLjAwEK6urvDx8UFKSgqbUSaiYiMxMREPHz5EamoqFLetb9++RXBwMGbNmoUrV67g6dOn6Nu3r8SREhERUWFdvnwZDg4OcHBwQPv27VGyZEmV8TVr1pQoMiIiIiIiIqLijYkfRERFYPv27di7dy8AIDo6GoaGhihTpow4PjMzEzExMShVqpTWPquLg6SkJBw5cgRubm5wd3eXOhwi+sz5+PhgxowZyMjI0DieCWpERET/LQ0aNEBmZiY0vaqSyWS4deuWBFERERERERERFX86uU9CRES5GTx4MJKTkxEdHQ2ZTIZ3794hOjpa/BcTEwMA6NWrl8SR5qxUqVIYOXIkkz6IqFjYuHEj0tPTYWFhAUEQ0KhRI5QtWxaCIGDYsGFSh0dERERFLD09XUz8yP4vMzNT6vCIiIiIiIiIii1dqQMgIvovKF26NPbu3Yvnz5/D3t4eTZs2xbRp08TxMpkMZcqUgVwulzBKIqJPS1RUFBo3bgwXFxe0a9cOc+bMQe3atWFra4vY2FipwyMiIqIiFh4eLnUIRERERERERJ8kJn4QERURCwsLWFhYYPfu3TA3N4elpaXUIRERffJKliwJIKvp99DQUDRv3hx169ZFSEiIxJERERHRh5Samqo2TF9fX4JIiIiIiIiIiIo/Jn4QERWxli1bIjg4GH///TdSUlLU+qeeOnWqRJEREX1aatasiZCQEPj4+KBJkybYt28f0tLScPnyZRgYGEgdHhERERWx8PBwzJ8/H3fu3FF7jpLJZLh165ZEkREREREREREVbzIh+5M0EREVysaNG+Hk5KQ2XBAEyGQy3L59W4KoiIg+PT4+Pvj+++/x448/olOnTvj666/FhLrevXtjzZo1UodIRERERWjw4MG4ceOG1vHsCoaIiIiIiIhIM7b4QURUxDw8PCAIAiwtLWFhYQFdXRa1REQF0bVrVxw8eBCGhoaoVq0anJyc4OzsjKpVq2L69OlSh0dERERFLCIiAuXLl4ejoyMqVqwIHR0dqUMiIiIiIiIi+iSwxQ8ioiJmbW2N6tWrw8PDAzKZTOpwiIiIiIiIPgkDBw6EoaEh9u7dK3UoRERERERERJ8UVkMnIipiHTp0wP3795n0QURUAPPnz8/TdDKZDH/88ccHjoaIiIg+pgULFuC7777Dr7/+ig4dOsDAwEBlfLt27SSKjIiIiIiIiKh4Y4sfRERF7Pjx41iwYAGsra3RunVrGBoaqiSBDBs2TMLoiIiKNysrK7HMzOk2VSaT4fbt2x8rLCIiIvoIvLy8MHfuXKSnp6uNk8lkuHXrlgRRERERERERERV/TPwgIipiyh8tNeGHSiIi7RRlqImJCZo1a4aWLVvC3Nxc47QDBgz4yNERERHRh9SpUyfExMTA0NAQZmZmas9Vvr6+EkVGREREREREVLyxqxcioiLWokULqUMgIvpkNWnSBDdu3EBSUhLOnTsHPz8/WFhYoFWrVmjVqhVatGgBU1NTqcMkIiKiDyAhIQGWlpZwc3ODvr6+1OEQERERERERfTLY4gcRERERFStv3rzB5cuXERAQAH9/f9y9exdAVhPvMpkMderUQatWrTBv3jyJIyUiIqKiNGvWLNy5cweHDx9GiRIlpA6HiIiIiIiI6JPBxA8ioiLw4MGDPE9bs2bNDxgJEdF/T3x8PA4ePIi///4br1+/BpCVBMKus4iIiP5bnJ2dsWrVKlSrVg2tW7eGgYGByviZM2dKFBkRERERERFR8cbEDyKiIlC3bt08TSeTyXDr1q0PHA0R0acvKSkJgYGBuHjxIvz9/fHo0SMo37ZaWlri6NGjEkZIRERERc3Kykr8v0wmE/8vCAKTPomIiIiIiIhyoCt1AERE/wV5zaFjrh0RUc7Wrl0Lf39/3Lx5E5mZmWK5aWFhgZYtW4r/ypQpI3GkREREVNT69++vkvBBRERERERERHnDFj+IiIiIqNiwsrKCTCaDsbExmjVrJiZ6lC1bVm3aSpUqSRAhEREREREREREREVHxwsQPIiIiIio2FIkfuWHXWURERP9NERERiIyMREpKijjszZs3uHLlCtasWSNhZERERERERETFF7t6ISIiIqJig614EBERfb5cXFywcOFCreOZ+EFERERERESkGRM/iIiIiKjY8PX1lToEIiIiksiuXbsgk8nw1Vdf4ezZs+jevTsePHiAu3fvYsKECVKHR0RERERERFRs6UgdABERERERERERUXR0NJo1a4bNmzejUqVKGD58OA4ePIhKlSrh2rVrUodHREREREREVGwx8YOIiIiIiIiIiCSnp6eH9PR0AECDBg0QEhKCkiVLolq1arh586bE0REREREREREVX+zqhYiIiIiIiIiIJCeXyxEaGgp3d3c0bdoUmzdvRkxMDIKCgmBqaip1eERERERERETFFlv8ICIiIiIiIiIiyc2cORMlS5bE+/fv0bt3bwiCgIMHDyIzMxM9evSQOjwiIiIiIiKiYksmCIIgdRBEREREREREREQvX75ERkYGKlasiNu3b8PNzQ1VqlTByJEjoaenJ3V4RERERERERMUSEz+IiIiIiIiIiIiIiIiIiIiIPlHs6oWIiIiIiIiIiCQTFRWF2bNn482bNwCAunXrqvwbMmQIWG+JiIiIiIiISDsmfhARERERERERkSSio6MxcuRIHDt2DHfu3AEACIKg8u/GjRvw8fGROFIiIiIiIiKi4ouJH0REREREREREJIl//vkHcXFxqF27NkxNTcXhzZo1w+7du9G3b18IgoBjx45JGCURERERERFR8aYrdQBERERERERERPR5unjxIkxMTLBnzx6Ym5uLw83NzdGyZUtYWVnh9OnTCA0NlS5IIiIiIiIiomKOLX4QEREREREREZEkYmNj0ahRI5Wkj3r16qFatWoAgNKlS6NJkyaIj4+XKkQiIiIiIiKiYo8tfhARERERERERkST09fWRkJCgMszd3V3l71evXqFUqVIfMSoiIiIiIiKiTwtb/CAiIiIiIiIiIknUqlULERERCA8P1zg+LCwMERERqFOnzkeOjIiIiIiIiOjTwcQPIiIiIiIiIiKSxKBBg5Ceno4JEybg0KFDiI2NRWpqKh4/foy9e/di8uTJyMzMxODBg6UOlYiIiIiIiKjYkgmCIEgdBBERERERERERfZ4mT54MX19fyGQytXGCIKBXr15wdHSUIDIiIiIiIiKiTwMTP4iIiIiIiIiISDKZmZnYtm0bnJ2d8eLFC3H4l19+CTs7O3z33Xcak0KIiIiIiIiIKAsTP4iIiIiIiIiISHKZmZl48uQJXr16hTJlyqBq1apSh0RERERERET0SWDiBxEREREREREREREREREREdEnSkfqAIiIiIiIiIiIiIiIiIiIiIioYJj4QURERERERERERERERERERPSJYuIHERERERERERERERERERER0SeKiR9ERPRZyMjIkDoEIiL6DPH68/nhPqePhccaERERERERESkw8YOIiHJkZ2eHOnXq5Ovf5MmTpQ5blJmZiX379mHZsmVSh1JszZgxA/Xr18e9e/ekDiXP3N3dxePt4cOHUoejQnHOzJs3r0DzjRgx4gNFRh/DgwcP8P3338PGxgYNGjRAu3btsHjxYqnD+k87d+4c7Ozs0LJlSzRs2BCdOnXCoUOHpA4LcXFxmDVrFq5cuSJ1KEXqyZMnYvl74MABqcMpVv6r+/xzpzjeHR0di2yZRXEfc+vWLQwdOrTIYsqPefPmoU6dOrCzsyvQfF999dUHiowodxs2bECdOnXQuXPnIl1uQcuKzp07o06dOpg9e3aRxpMXH6J8+69Svv8JDAyUOhz6SL755hu0aNECMTExUodCRERElCdM/CAiov+0uXPnYtGiRUhOTpY6lGLp8OHD8Pb2xrBhw2BhYSF1OESftLi4OAwfPhzHjx/Hy5cvkZaWhhcvXsDAwEDq0P6z/P39MXHiRAQFBSExMRGpqal4+vQpzM3NJY0rPj4evXr1gqenJwRBkDQW+ji4z+ljOn/+PAYPHowbN25IHQoREdF/1vz585GUlIR58+bx/o6IiIg+CbpSB0BERJ+GSpUqwdPTM0/T6uoWn8vLs2fPpA6h2EpMTMTy5cthbGyMqVOnSh0O0SfP19cXCQkJAICff/4ZvXv3hkwmg76+vrSB/Ye5u7tDEAQYGxvDyckJdevWRWpqquSJH2/fvkViYqKkMXwoenp6qFatGgDAxMRE4miKj//yPv/cKY53qcsVZS9evGA3L0RERB9Yw4YN0bt3bxw7dgyHDh3CgAEDpA6JiIiIKEfF58scEREVazKZDMbGxlKHQUVow4YNiI+Ph4ODA8qUKSN1OESfvBcvXgAAzMzMMHr0aImj+Ty8fPkSAGBjY4O2bdtKHM3noWLFijh16pTUYRB9NDzeiYiIPl9Tp06Ft7c3Vq5ciR49esDIyEjqkIiIiIi0YlcvREREn6HY2Fi4uLhAV1cXI0eOlDocov8ERe1rJsl9PNzmRERERET0odSqVQtfffUV4uLi4OzsLHU4RERERDliix9ERPTRhISEYO/evQgODkZcXBwMDQ0hl8tha2uLwYMHQ09PL8d53d3dceXKFTx//hzv379HqVKlYGFhga5du2LYsGEwMDAQp583bx48PDzEvz08PMS/79y5AwCws7NDUFAQmjZtin///Vfj727YsAFOTk4AgJs3b4rd2AQGBoo1+q9fv44tW7bAxcUFr1+/xpdffokpU6bg66+/Fpfz9OlT7Ny5E+fPn0dMTAxkMhmqVq2KTp06YcyYMVqbD09MTMSePXvg6+uLBw8eID09HWXLlkXjxo0xYMAAdOzYMbfNrtGuXbuQmpqKzp07o0KFCmrjFdvGwcEBvXr1wuLFi3Hjxg0YGhqifv362Lx5s9h9RXx8PPbv34+LFy/iwYMHeP36NUqWLImKFSuiTZs2sLOzQ40aNdR+o3PnzoiOjsbSpUvRr18/7Ny5E15eXnj48CFkMhksLS3Rv39/DBkyJN/dBy1fvhw7duwAAIwcORILFixQGS8IAo4dO4bDhw/j5s2beP36NczMzNC4cWMMHToUHTp0yHH5fn5+cHZ2xu3bt/H69WtUq1YNgwYNwqhRo/IVpzZpaWnYtWsXDh06hEePHsHExATNmjXDyJEj0bp1a5VpnZycsGHDBgDA6dOnUaVKFY3LjI2NRceOHZGZmYm1a9eiV69eeYolNjZWPHYfP34MAChXrhyaN2+OoUOHolmzZmrzKPZt3759sWrVKo3LVZyjFStWhJ+fnzhc+dy6c+cObt++jW3btiEoKAivX7/GF198gZ49e8LBwQFGRkbIyMjAvn374O7ujgcPHqBEiRJo2LAhHBwc1LZVXqWkpMDNzQ3e3t6IiIjAmzdvYG5uDmtrawwaNEjt+Mhe3kRHR6NOnToAgJYtW2LPnj25/qairFFM7+Pjgz179uD27dtIS0tDzZo1MWzYMAwbNgxAVtmwefNm+Pj44NmzZyhdujRat26NGTNmoGrVqhp/ozDHfWZmJo4fP44TJ07g+vXriI+PR2ZmJszMzNCwYUP069cP3bp1g0wm07heinL2woULcHZ2xrVr15CUlIQKFSqgY8eOmDBhAipWrJjrdlJQHGMKymX81KlTMW3aNHFcWloaDh48CC8vL3F/li1bFs2bN4ednR2aNGmi9XdSU1Nx+PBhnD59Grdu3UJCQgJ0dHRQpkwZNGnSBEOGDEGbNm1U5lHsewXF8TxgwAAsX74cT548QZcuXQAAS5cuxZAhQ3Jcx+znkeJ469u3L3744QcsXLgQly9fhp6eHmrXro0NGzagfPny4vTnzp3DwYMHERISgoSEBJiYmKB+/foYMGAAbG1t1fZZbnKKXxHzsmXL0LNnT/z999/w9vZGdHQ0SpUqBWtra0yePBn16tUDkHVt37ZtG0JCQpCcnIyqVavi66+/xrhx49TKfcV1afz48ZgxYwa2b9+OQ4cOITo6Gubm5qhbty7s7e3RokULrbFnZGTg2LFjOHLkCG7evImkpCSYmpqifv36+Prrr7VuD8U+3bFjBxISErB+/Xo8efIEZcqUga2tLbZv364yffZ9riD1eXTv3j3s378f/v7+ePr0KWQyGWrWrImePXvCzs4OhoaGGucryP2b8nGSfTtok5ycjNatWyMtLQ3Tp0/HlClT1KZZuHCheM/m6ekJS0tLlfGCIKBt27aIj4/H/PnzMWbMGJVxBSkDFfvfwcEBP/zwg9r4GzduYPv27bh27RpiY2NRvnx5dO7cGZMnT0ZAQABmzpyJypUrw9fXV+u637p1C9u2bcPly5eRkJCAcuXKoU2bNhg7diwsLCzE6ZSvkdnjW7ZsGQYOHKgyrjDnf0hICHbu3Inr16/j5cuX+PLLL9GnTx+MGzdO6zz5IQgCDh48iH///ReRkZEwMDBAgwYNMGzYMHTv3l1l2kOHDmHu3LkAgD179qBly5Yal5mSkoK2bdsiOTkZc+bMyVOsvP7m7/oLfLx7tbNnz+LAgQMICwtDQkICjI2NIZfL0bt371yfHe/evYvt27cjODgYsbGxKFeuHLp27YpJkyblaR2L+tqZV2/fvsWWLVvg5eWFZ8+ewczMDK1bt8Z3330nXjs1KejzWG7u3r0LFxcXXL58GTExMXjz5g1MTExQvXp1dOzYESNHjoSpqanKPMrl/8mTJ2FoaIitW7fi3LlzePbsGYyNjdG4cWOMHDkSX331ldbfTk5OxqFDh+Dp6YmHDx+Kx22rVq3UykZlr169wq5du3DmzBk8fvwYGRkZ+PLLL9G+fXvY29vjyy+/zPE3XVxcxN/U09ND48aNMWHCBHzxxRf53n7KCnJPWRTbIz4+HgcOHMCJEyfw5MkTvHv3DpUqVUL79u0xduxYte2R2zUP0P4eRbnc+euvv7BkyRL4+vpCJpOhRo0aWLZsmbj8j7U93r17h7Zt2+Lt27cYOHAgli1bpnWZv/76K1xdXWFhYYFjx46pjBs8eDDOnj2LXbt24bvvvsux/CEiIiKSEhM/iIjog8vMzMSff/4pfohXSE1NxeXLl3H58mW4urpi8+bNai8eMzIysHDhQri6uqotNz4+HkFBQQgKCoKbmxv27t2LUqVKfdB10WTZsmXYt2+f+HdUVJTKi99jx45h/vz5SElJUZnvzp07uHPnDvbv34+NGzeiefPmKuMfP36M0aNH4+nTpyrDY2JiEBMTg+PHj6Nv375YuXJlvl4+pqamwt3dHQDQo0ePHKd98uQJRo8ejcTERABZL9RlMpmY9HHu3DnMmDEDb9++VZkvLS0NycnJiIyMxIEDB+Dk5KT1xd7r168xZMgQhIeHqwwPDQ1FaGgofHx8sHXrVpQoUSJP67dhwwbxWBsxYoRa0sfr168xdepUBAYGqgx/8eIFfHx84OPjg6+//hq///67uJ4KGRkZWLRoEVxcXFSGR0REYNmyZfD19VXbz/mVkpKCcePG4dKlSyrDTp48iZMnT2LMmDGYP3++OK5fv35wcnKCIAjw8vLChAkTNC7X09MTmZmZKFWqFDp37pynWK5fv46xY8eK+1/hyZMnePLkCQ4dOoSJEydi5syZBVjT3Hl5eeHHH39EWlqaOOzhw4fYsmULgoKCsH37dvHDmrKAgAAEBQVh48aN6NSpU75+MyoqClOmTMG9e/dUhj9//hwnTpzAiRMn0Lt3byxfvhwlS5Ys+Mrl4I8//sCuXbtUht28eRMLFizAw4cPMWLECLWy4eXLl/D09MTFixfh7u6OSpUqqcxfmONe0SVUWFiYWqyxsbGIjY2Fj49Prh93169fj40bN6oMe/LkCZydnXHkyBHs2bMHVlZWOW+cfIqJicGECRMQERGhMvzZs2fw9PSEp6cnxo8fj1mzZqmVo48fP8a4ceMQFRWlttzo6GhER0fj2LFjaokmH0tiYiLs7OzEBJh3794hISFBTPpITU3FvHnz1F5cv3r1ChcuXMCFCxfg7u6O9evXw8TEpEhje/nyJQYOHIgHDx6Iw1JSUnDq1ClcuHABe/bswc2bN7F48WKx1RYAiIyMhKOjI8LDw7F27VqNy05PT8f48ePh7+8vDlNcF319fTFp0iTMmDFDbb64uDhMnToVV69eVYv13LlzOHfuHFxdXbF+/XqYmZlp/O2TJ0+qfOCIjY3VOm12Up9He/bswfLly5Genq4y/ObNm7h58yY8PDywc+dOlfuwwty/FYSJiQlatGgBf39/XLp0SWPih/K1MSgoSC3xQ/FhHIBK+V+YMjAne/bswe+//w5BEMRh0dHR2LNnD7y9vcVkgZzs378fO3fuRGZmpjgsJiYG7u7u8Pb2xubNm/OdyFjY83/Tpk1Yt26dyrCoqCg4OTnhxIkTWpNM8yozMxM//vgjjhw5Ig57//69GFuvXr2wcuVK8cNa9+7dsWjRIrx9+xaenp5aEz/OnDmD5ORk6OjooG/fvvmOi9ff/PsQ92rv3r3DrFmzcPr0aZXhCQkJ4rPfvn37sHnzZlSuXFktJjc3NyxYsEClvIuOjsauXbtw/PjxHM8nKa+diYmJGDZsmMo9y/Pnz3HkyBF4enpi7ty5KslsCkXxPKaJk5OT+IyhLCEhAQkJCQgLC8OBAwewd+9eteNe4ebNm1i0aBESEhLEYampqTh79izOnj2rNcnvzp07mDp1Kh49eqQyPDo6Gu7u7jh69CiWL1+OPn36qIy/dOkSpk+frvbs8uDBAzx48ACurq74888/NT4Da7vvO3fuHM6fPw97e3uN65gXhb2nLOj2CAoKwowZMxAXF6cyPCoqClFRUXB3d8dff/2FVq1aFXjdNElNTcW4ceNw/fp1cdijR49QvXp1AB93exgaGqJHjx7w8PDAqVOnsGjRIo3X+bS0NJw8eRIAVCrwKHTo0AGGhoZ4+fIlfHx88lyJgoiIiOhjY1cvRET0wa1fv178aNC9e3fs27cPgYGB8PHxwfz581GqVCncunULEydOVPtovnPnTjHpw9bWVqzJ5Ovri61bt8La2hpA1sO/co3bxYsX4+rVq2JrBH379sXVq1fVPvgUhX379qF79+44fvw4fH19sXDhQjEuf39/zJ49GykpKbCyssLGjRvh7++P8+fPw9HRETVq1EBCQgImTJig9uJj4cKFePr0KcqVK4c///wTPj4+CAgIgIuLi1gz8OjRo2ovJnMTEBCAV69eQSaToX379jlO6+npiYyMDDg6OsLf3x87d+7E5MmTAWS1YvL999/j7du3qFGjBhwdHcUY3dzcMHr0aOjq6iIlJQW//fab2ktDhQ0bNiAiIgLfffcdPD09cenSJezcuVOs1XbhwgUcOnQoT+u2c+dOsYWWYcOG4bffflMZn5mZiSlTpiAwMBC6uroYP348PD09ERgYiMOHD8POzg4ymQxHjhzB77//rrb8TZs2iUkf3bp1w8GDB3Hp0iW4uLigY8eOCAwM1PhyPj9u3ryJS5cuoWPHjjhw4AAuXboEZ2dn8ZjauXMn9u7dK05ftWpVNG3aFEDW/tJGMa579+55SlgQBAE//vgjEhMTUaNGDWzcuBFnzpyBv78/du3aJbaSsGXLFoSEhBR0dXM0b948VKhQAevWrROPA8XHnpCQEAwcOBCXLl2Cvb09vL29ERAQgDVr1sDU1BQZGRlYsWJFvn7v1atXGDt2LO7duwc9PT04ODjAy8sLgYGB2L9/v/iS2MvLSyX5RlHeTJw4EQBQqVIlsbzZtm1bvmIICwvDrl270LJlS+zduxf+/v74559/xNp4u3btgr29PZKSkrBw4UL4+fnh3LlzmDZtGnR0dPDq1Sts3rxZZZmFPe7nz5+PsLAwlChRAlOnTsXRo0dx6dIleHt7448//hBf9nt4eKh92FG4ffs2Nm7cCGtra/zzzz/i/HZ2dgCyPowtXbo0z9vp2LFjWst4xX54+/Yt7O3tERERASMjI8yaNQsnTpxAYGAgXF1dxZfj27ZtU9tPGRkZmDp1KqKiomBkZIT58+fD29sbly5dgqenJ3766Sfxg/+mTZvw8OFDcd6rV6+qlMtbt27F1atXsXjx4jyvX174+fnh+fPnWLhwIS5evAhXV1eV4/Lnn38W4xg6dCjc3d0RFBQELy8vTJkyBXp6erh48SJmzpyptXwuKCcnJzx8+BAODg44efIkzpw5g5kzZ0Imk4kf9BYvXoyGDRti165duHTpEtzc3MTz29vbG6GhoRqX7eLiAn9/f7Ru3Rr79+8Xy0hFmfTXX3/hwIEDKvOkpqZiwoQJuHr1KmQyGUaMGIFDhw4hMDAQhw4dEj/OBwYGYvLkyWrJEQr//vsvLC0txdrzq1atwoABA/K0z6U8jzw9PbF06VKkp6ejbt26+Ouvv+Dv74+TJ09i+vTp0NXVxf3799Vq9hbm/k1PTw81a9ZEzZo1VVqgyY3i/iYkJATv3r1TGRcbG6uSTBQUFKQ2v6IFqVq1aokfmApbBmpz+vRpLF26FIIgoH79+tixYwcuXbqEI0eOYMiQIXj58iU2bdqU63K2b9+OL7/8En/++Sf8/Pzg7e2NKVOmoESJEnj37h1++eUXMSmkefPmuHr1KhYtWiTOryj7lD9UFeb8d3d3F5M+WrRogb179+LSpUs4dOgQBgwYgLt37+LMmTN53k6avHjxAkeOHEGTJk2we/duXLp0CQcOHBATALy9veHo6ChOb2RkhK5duwIATpw4ofUcVdzrtGzZMt/JSLz+FsyHuFebOXOmmPTRs2dPuLi4IDAwUExw1tXVRUREBOzt7ZGcnKwyb2BgIH766Sekp6dDLpdj27ZtCAgIgJeXF+zt7fH8+XMcPnxY6/pIee308/NDREQEBg4ciCNHjiAgIABbt25F7dq1kZmZiWXLluHcuXMq8xTV81h2x48fx4YNGyAIAmxsbLBr1y74+fnBz88Pu3fvFludfPr0qdZETQD46aefkJmZiV9//RW+vr64cOECVq5cKd5Dbdy4UeUeCsg6JseOHYtHjx7ByMgIc+bMwalTp3Dx4kVs3LgR1atXR1paGubNm6eSqB0REYGJEyciMTERVapUEctUf39/bN26FQ0bNsT79+8xc+ZMXLlyReU3FYkKUVFRMDAwwI8//ogzZ87g4sWL+PPPP1GuXDn8/fffedp22RXmnrIw2+Px48eYMGEC4uLiULZsWSxatAhnzpyBn58fVqxYgXLlyuHNmzeYPn26WmJIYd24cQPXr1/HtGnTcP78eRw+fBhLliyBgYGBJNujX79+AICkpCS1c0jBz88PCQkJkMlkGhMH9fX1xQQZb2/votpUREREREVPICIiysGoUaMEuVwudOzYUUhOTs71X0ZGhsr8UVFRgpWVlSCXy4UlS5Zo/I3r168LdevWFeRyubBjxw5xeEZGhmBjYyPI5XLhu+++EzIzM9Xmffv2rdCuXTtBLpcLgwYN0hr/3LlztY4bPny41vVfv369IJfLBblcLqSlpYnDL126JA7v3LmzyjiF9PR0oXPnzoJcLhcGDx4svH//Xm2ahIQEcRoHBwdxeFJSklCnTh1BLpcLhw4dUpsvNTVV6NGjhyCXy4WJEydqjV+TxYsXC3K5XOjSpYvWaRTbRi6XC66urhqnWbFihSCXy4X69esLjx490jjN77//Li7n7t27KuM6deokjtu9e7favC9fvhQaNWqkcR3d3NzEeaOiogRBEAQXFxdx2C+//KLxeDl48KA4zYkTJzTGvHPnTnGaGzduiMOfPXsmxvP999+rLT8jI0OYOnWqOK+mYy4nytt82rRpaufS+/fvhUGDBglyuVxo2bKlyvG0f/9+cd579+6pLTsyMlIcHxAQkKd4IiIixHkuX76sNv7169dCixYtNJ7bin07a9YsrcufO3euIJfLhfbt26sMVz63mjRpIjx9+lRl/LNnz4R69eqJ02zatElt2Xv37hXHZ58/J8uXLxfnO3XqlMZpFOePXC4Xzp49qzJOUV506tQpz7+ZfV65XC4MHDhQSE1NVRnv5eUljte2T77//nuN53Zhjvu7d+/muK0FQRBu374tTrNixQqt6zVkyBC19RIEQZg2bZogl8uFOnXqCHFxcZo3kBY5lfHr1q0Ty6jQ0FCN8yvKqAYNGgjPnz8Xh589e1aM+/DhwxrnPXXqlDiNs7OzyrjHjx+L4y5duqR1nLbyVRC0n0eKc0culwuOjo4a5w0ICBCn2b59e67xnzx5Umsc2eUUv3K5rnw9Vxg/frw4vk+fPmrXxYSEBKFhw4aCXC4XnJycVMYpl5Hfffed2nX33bt3wsCBAwW5XC60adNGePv2rThuz5494rw7d+7UuF7//POP1v2pGG5lZSU8ePAg1+2SfZ9LeR69f/9eaNOmjSCXy4UBAwaobBeFHTt2iMsPDAwUBKFw92+F8eDBAzEWPz8/lXEeHh7iNVCxn7MbOnSo2jYsTBkoCP/b/2vWrBGHpaWlCV27dhXkcrnQv39/jdt19erV4rzZrwvK9zE2NjbCy5cv1eZftmyZOM3Nmze1zp9dYc7/d+/eCW3bthXk8qz745SUFLV5le/tRo0apXH52iiXX8OGDVMrAzIyMoRJkyYJcrlcqFevnvDs2TNx3Pnz57VefwUh676kQYMGglwuFw4ePJjnmHj9zf/190Peq/n6+orDf//9d42/7+3trXW9+/btK8jlcqFbt27C69ev1eZV3t7Zz8vCXjs1lRV5oXzt/OOPP9TGv3r1Spymd+/eKuMK+zymLWbFM4etra3GciAjI0MYMGCAIJfLhdatW6uMU74e1qtXT638EgTV/fzPP/+ojFuyZIk475UrV9TmffLkidCsWTNBLpcL8+bNE4ePHDlSkMuzns3j4+PV5ktJSRGGDBkiyOVyoW/fvirjlK+DZ86cUZv38ePHQvPmzbVe53NS2HvKgm4PBwcHQS6XC02bNhWfl5UpX8M3bNggDs/LcaztPYpyuTN79uxisz0yMjKEr776SpDLs57jNZkxY4Ygl8uFkSNHal3vjRs3CnK5XLC2thbS09O1TkdEREQkJbb4QUREefL06VM0bdo013937txRmc/FxQWZmZkwNDTU2kdsgwYNYGtrK06v8ObNGwwaNAh9+vTBxIkTNXZnYmhoiEaNGgHIqq0vhS5dukBXV733tAsXLuDJkycAgFmzZmlsZcHU1BQODg4Aspqnfv78OYCspkaF/6+RpakGjp6eHv7880/s3bs337XIFS1SaOsHWJlMJtPaHYxcLsewYcMwfvx4rX2aKzfFrW3/mJqaYvjw4WrDy5Yti4YNGwKAuB21OXbsmNi6x5AhQ7B48WKNx4uiif4WLVqo9R+vMGrUKLHZaOUuhnx8fPD+/XvIZDLMmTNHbfk6Ojr45Zdf8twljTa6urr49ddfoaOjeptWsmRJzJ49G0BWE8vKtW179eolNlmrqdWPo0ePAgC++OILrc2jZ6dce1vTMViqVCls3LgR+/fvF1uBKWp9+/ZV63e6YsWK4vGmp6eHb7/9Vm0+ResoQFYN8bzIzMyEm5sbAKBr165izeLs5s6dizJlygCASpcPRcne3l6t32jlrqCsra3VuoYCILZ4kH2dC3PcZ2RkwN7eHj169MCIESM0zmtlZYXSpUsDyLkc1rRewP9q+AuCIHZbUliCIIjXE1tbWzRu3FjjdNOnT4eBgQFSU1Ph4eEhDjc2Nsbo0aNha2uL3r17a5xXuVlsqa4/PXv21Dhcsc8rV66s8RwBso5zRYsp2buvKiwjIyOMHDlSbbjycWtnZ6d2XTQ1NUXNmjUBaD93dXR0sGjRIrXrrqKGLpBVZil3BaM4puvWrat1e9jb24v9zu/fv1/jNHXq1EGNGjU0jsuJlOdRQECAWIbPmTMHhoaGavOOGDECcrkc7dq1E7sKKMz9W2HUqFFD3MbK+1CxLgDwzTffAMjaz5GRkeL4V69e4dq1awCg0qVZYcpAba5cuSI2Ma9tu06bNi1PrZ18++23KFu2rNrwbt26if/P3px9Tgpz/l+6dAkvX74EkHXvqqk5/JkzZ8LU1DTP8Wjzyy+/qJUBOjo6mD9/PmQyGdLT01Xuadq2bYsKFSoAgMbW7k6cOIHU1FQYGBjk2pWhNrz+5l9R36sptkHZsmXF+97sevbsKZ7jrq6uYpdhd+/eFZ9FJ0+erLEL0NGjR6N27doalyv1tdPc3ByzZs1SG25mZiZ2h3Lv3j2V7jOK6nlMWWZmJjp27Ij+/ftj8uTJGssBHR0d8VzIaZnt2rUTW3FUZmNjI17HlZ/zBEEQW1OwtbUVWzVUVrlyZQwZMgSNGzcWy6J79+7h8uXLALL2vbm5udp8+vr64vXszp07Kq00Kp6VWrduLbZmoqxKlSoYP3681vXMSWHuKQu6PZKSknD+/HkAWce8ogUsZQ0aNEDPnj3RrFmzD9J9pbZyWIrtodz915kzZ/DmzRuVed68eSM+W2vq5kVBLpeL02fvFpSIiIiouFD/SkVERFSEFM1w16pVCwDUHrIVGjVqhCNHjuD+/ft49eoVzM3NUapUKa0fGwAgPT0dt2/fFj9oaGv2+UOrW7euxuHKfXnL5XKt696gQQMAWS8yQkJC0KNHD5ibm8PCwgL37t3DqlWrEBERge7du6N169YwMjICADHhJb/u378PAOLHtZxUqlRJfKGcXf/+/dG/f3+t88bExODWrVvi39r2T926dTW+jAYgfmDP3ty7sjNnzmDlypXIzMyEtbU1lixZojHpIzk5WYynXr16WvcHADRs2BDR0dEqXQNdunQJQFbCjKb+xIGsF90NGzbU2kVBXlhbW2v9UNSyZUsYGRnh7du3CA4OFj/6li5dGp06dcKJEyfg5eWF77//XmU+xYeTvn37qiWUaGNpaQkzMzMkJCRgzpw5CAwMRNeuXdG8eXPxBXCLFi0Kupp5ou0YL1u2LB48eICaNWuK54My5T7Xs3c/oM2dO3fE/sC1fZwBsl4ad+7cGQcPHsTly5chCILG460wNK238kfB+vXra5xPsd6pqanisMIe93Xq1MHcuXO1zvPmzRuEhoaKx1VO5bC25AvldXv//r3W+fMjMjJS/HhZt25drestk8lQp04dhIWFqax38+bNNX7cU0hMTERwcLD4txTXH11dXVhaWmocp/j4Ua9evRzLz8aNG+PKlSsICQkp0mO5Xr16Gst1RZmumEYTTcexskaNGuX4ccvExATJyckICAhAly5dkJCQgIiICAA5n9tA1sfEO3fuICIiQrwXUabtep8bKc8jRbKEkZGRyocUZSVLlhQ/eikU5v6tsDp06ICoqCjxuqugWJcePXrAy8sLUVFRCAoKEj/iXrx4EZmZmTAzMxM/Khe2DNTmwoULALK2a+vWrTVOo6enh86dO+f6cVj5A7gy5XuBnOLOrjDnv2KbGxkZiR+3szMwMEC7du3y3dWgskqVKon3v9lVrVoVNWvWxP379xEcHIyxY8cCyPpw16dPH2zfvh0+Pj5ISUlR+VipOIY7d+6sch+QH7z+5l9R36spjt9OnTppTDhQ6NmzJ3x9fZGUlITw8HDUr19fpcz46quvNM4nk8nQpUsXlaSx7L8t1bWzQ4cOWtdZORnhypUrYnJ8UT2PKdPR0cHUqVO1js/MzMS9e/fEhA1BEJCRkaEx+V3b8aGvr49SpUrh1atXKtv6zp074v2bpgQMheznRl6fu+vUqYMSJUogIyMDV65cQePGjZGUlISbN28C0H7cAFlJP6tXr9Y6XpvC3FMWdHsEBQUhLS0NAMQutDRZs2ZNjrEXhrZ7Jim2B5DV3cu2bdvw/v17+Pr6qnTncurUKbx79w76+vpak6oB1fcnkZGRYsIwERERUXHCxA8iIsqTypUrw9fXN9/zPX78GABw8+ZNjTUyNHn27Jnah4Pnz5/j4sWLuH//Ph4+fIiHDx/i/v37Ki9YhSLuZzmvFH3QZqdYdwBo06ZNnpYVExMj/n/hwoUYN24c3r9/Dw8PD3h4eEBPTw9NmzZFhw4d0L17d60fv7RJSkoSX4Rpi1tZXqZJS0uDv78/wsPDERUVhcePH+PevXtqtb+07Z+cPhIpXn7mtG+XL18ujr9x4wbu3LkDKysrtemio6PFGoG7du3Crl27cl4xqO4Pxf9z2+a1atUqVOKH4iObJjo6OqhSpQoiIiLw9OlTlXH9+vXDiRMnEBUVhRs3bogfVMLCwsSawjnVYMquZMmSWLBgAebMmYOUlBTs3bsXe/fuhZGREVq0aIEOHTqgW7duYu3bD0HbsaH4yGFsbKxxfEFewCvva201QbOPT05ORlJSktbkqILStN7KCTvaPmhpSuop7HGvLCIiApcvX8aDBw/w+PFjREVF4dGjR8jMzBSnyelc1bY/lT9yKC+rMJRrxy9btgzLli3LdR5t6x0WFobQ0FBxfR88eICnT5+qrKsU1x8TExONH1mSk5PFhMhTp07h1KlTuS6rqI/l3M5dIH/HsTJFbUtNZDIZqlWrhlu3buHZs2cAsmqSK/ZPXs9tQPO9SF6uibn52OeRoiZ91apV85z4BxTd/VtBdOrUCbt27cLt27cRHx+PMmXK4P79+4iNjYWZmRnq1KmDZs2aISoqCpcvXxZbQ/Dz8wMAtG/fXjw3irIMVKZoHSG37ZrTNV1B23GlvNy8lo2FPf+V73VyupbmZb1yktv81atXx/3799Xudfr374/t27fjzZs3OHv2rFij/Pnz52KyUn7udbLj9Tf/ivJeTXEsAvkrr2NiYlC/fn1x+5mYmKgkGman6fgrDtfOnM6LsmXLwtjYGG/evNHYOkthn8e0SUxMxPnz53Hv3j08evRIfAZXtA6V23Lz+5yn3PpLflrYUn7uHjx4cJ7mURwvyvcJ1apV0zp9jRo1xKSRgsrvPWVBt4fyfJpa+/gY8nLP9LG2B5BVqaFevXq4desWjh07ppL4oagk0alTpxzPZ+V1ymurkkREREQfGxM/iIjog0pOTi7UPK9fv8aKFStw+PBhsdaKgrGxMdq0aYMXL16o1GT62LQ1jVrYdW/RogWOHDmCzZs349SpU0hKSkJaWhoCAwMRGBiIP//8E506dcKSJUvy1JQ4AJWXdHmpDZlbs68HDhzAxo0b1V5U6+jooG7duqhRo4bYHKs2mrrJyQ9BENC5c2dcvnwZSUlJ+Pnnn+Hq6qr2QbSw+0PxIlpTc+7KClrLVCG35StqTWavmfnVV1/B3Nwcr169wrFjx8TED0UNWCsrqxw/mGpia2uLGjVqYOvWrTh79izev3+Pt2/f4ty5czh37hx+//13fP311/j111+1vtgvjNy2RVG2tKG8rzXVTFWmHNfbt2+LPPHDwMCgyJZV2OMeyPrgtGzZMrVuF4CsGuk2NjY4c+aM2GKKNoU91/OjKNY7ODgYy5cvV2lSXaFKlSpo166d1i5BPgZt5XN+WgZQlpycXGTHcl6O4YKev7mVsYrfVpTZBT23NW3HnGqf50aq80ixvNzK0+yK4hwqqObNm4sfOAMDA9GrVy+xtY/mzZtDJpOhVatWcHNzEz/2C4IgtsKh3M3Lh1qPhIQEALlv17xcG7W1elYQhT3/i/u9Tp06dWBlZYXw8HAcO3ZMTPzw8vJCZmYmzM3N0a5duwLHxetv/hXlvZry8VuQ8jqvx6+mLmCKw7UzL+fFmzdv1M6Longeyy41NRWOjo7Yv3+/WpJHyZIl0apVK2RmZoqtpGiT3/JN+VjOz/lYmPPt9evXefpNHR0dGBkZicdZfhT0nrKg20N5vvxe/4tKTu8RPvb2UOjXrx9u3bqFCxcuIDExEaampoiPjxfvMXJLHFQuOwpaZhARERF9aEz8ICKiD8rAwADJycmwtbXNd1Oi6enpGDt2rNhfe/PmzdG2bVvI5XLUrl0bNWrUgI6ODmbPnv3BEj8K0+2A4mVE+fLlxY8R+VW9enUsW7YMixcvxtWrV+Hv74+LFy/ixo0bEAQBZ86cwfjx4+Hu7p6vmrxA4WvW79mzB0uXLgWQ1cVJ9+7dUbduXVhYWMDS0hJGRkbw9/fP94vG/OrRowfWrFkDFxcXLF68GDdu3MDu3bvx3XffqUyn/NJr0aJFGD58eL5+R9FHcPaXn9lp654gr3I75hQvmbK/tNbT04OtrS2cnZ3h7e2NH3/8EYIg4Pjx4wAKXgO2fv36WLduHd6/f4/AwEAEBATg4sWLiIiIQEZGBjw8PJCYmIi//vorX8stqi49ioryB4bc9rHyy2WpXqbmVWGP+6dPn2LUqFFITEwUuy2wtraGpaUlLC0tUbFiRQBZiUe5fXj6mJTX+++//0b79u3zNf/169cxZswYpKWlwcjICF27dkXjxo1hYWEBuVyOMmXKID09/YMmfhT0HFF+ET5hwgTMmjWrqEIqFnIrYxXnr6KWsfKH9/yc27l9dMwPKc8jxfGQU7cF2uYr6P1bYenp6cHGxgYnT55EQEAAevXqJXbhoOiuRtG9yosXL8Ta53FxcdDV1VU53wtbBmqj2K65HVO5jS9qhT3/i/u9DpD14S48PBxnz57FmzdvYGxsLNbW7t27d5Em0hTG53r9LYz83ItpShIpzPFbHK6dBTkvPtTz2KxZs3Dy5EkAWV12dOzYEXK5HBYWFqhVqxZ0dXXh6OiYa+JHfimfN/m5D1Lef9euXcu18oIyxXED5H6tLEjZV5h7yoJuD+X5FF2YFKXCPMdJsT0U+vTpg5UrVyItLQ0nT57EkCFD4O3tjfT0dJiZmeXY1Q+g+v6kqLv6JCIiIioqTPwgIqIPqlKlSoiIiBD7ANZGU//Ix48fF5M+5syZg3HjxmmcN3sTtnmVlz6xFTU6C6JSpUoAgPj4eLx9+7ZQH5H09PTQqlUrtGrVCj/88ANiYmLwyy+/4MKFC7h9+zaCg4PRsmXLXJej/AGsoNsNyHrRsm7dOgBZ/ZLv2bNH4wfwwvxGXs2aNQu6uroYMWIEDh06hGvXrmHdunXo2rWrSrcsX3zxhfj/ghyPX375JcLCwvDgwYMc581t2bnR1HyzQnp6utiFhaamiPv16wdnZ2fExMTg5s2bSE1NxYsXL6Cjo4M+ffoUKi4DAwN06NABHTp0AJDVr/GcOXNw8+ZN+Pr6Ijo6GpUrVwbw4c+tD0ERO5C1booWUzS5f/8+gKzzSfllcXFU2ON+8+bNSExMRIkSJeDs7IwmTZponK+4fXT68ssvxf8XZL3Xrl2LtLQ0lCpVCm5ubhqbyS5o+abcGlH2lqwUMjIyVGqg5kfp0qXF1hIKsu7FnXI3PtllZmaK4xXn9JdffgmZTAZBEBAZGZnjshXnNvC/a3hRkPI8UqzHkydPctzf//77L5KSktCgQQO0bdu2UPdvRaFDhw44efIk/P39IQiC+HFRca9TsWJF1KhRA1FRUQgKChK7aGjevLnKR9HCloHaKMqEx48fIzMzU2vybU7H64dQ2PNfUXY+evQIGRkZGruTAj7svQ7wv3NR071Onz59sGrVKqSkpODChQto0qSJWGu8MN28FLXP9fpbGCYmJihdujRev36da3mtPF5RzimO3zdv3iA2NlZMjslOuVsQheJw7czpvHj27JmY0KI4Lz7U81hISIiY9DFy5EgsWLBA43Qf4jlP+f7t0aNHqFevnsbpbt26hRMnTqBq1aqwtbVVuWY/efIkx66Csu+/ihUrQkdHB5mZmSr3Adk9f/4cKSkp+VkdAIW7pyzo9sg+X8OGDTXO5+/vj+DgYFSrVg39+vWDTCYTt8WHeo6TYnsozoty5cqhbdu28PPzw+nTpzFkyBCcPn0aQFZlktwSZOLj48X/f4jWLomIiIiKQv6qBhMREeVTs2bNAGT1Ef/s2TOt0y1YsACtWrXCoEGDxBq3ISEh4vhvvvlG43zv3r1DaGgogPy3YKF4AZDTSyvFsgtCse4ZGRk4e/as1umOHj0Ka2tr2NraIjg4GABw9uxZDBkyBK1atdLYnOyXX36pUhMtr33MKl6oAoV7YXPv3j0xrgEDBmht9UDRbCpQ+BZGcqOjo4PFixejRIkSePfuHX777TeV8WXKlBFfAvr6+mrtizozMxO2trZo37495syZIw5X1CCOiorC3bt3Nc6bnJyMq1evFmo9QkJCtNY28/PzE184Nm/eXG18o0aNULNmTQDAmTNncO7cOQBZNaS1vfzW5uDBg+jfvz86d+6scVvVrl0bkyZNEv9WPgZzO7fS09M1Nu0rJblcLp4bJ06c0Dpdamoqzpw5AwCwtrb+KLEVRmGPe0U5XLduXY0fnQDg6tWrYq27/PYd/6FYWVmJL2QVL3Q1efPmDWxsbNCpUyesWrVKHK44j9u2bau1b3Tl8i37euf0QUi5vNR2jty8eVNrUkhuZDKZeP3x9/fPsfbquHHj0LZtW4wZM6bY7LvcBAcHa63N7e/vL45TJKmZmprC0tISAMQPWdoozv2aNWvmqW96ZTntcynPo6ZNmwLIOtavXLmicRpBEODk5ITVq1fj2LFjAAp3/1YUOnToAJlMhsePH+PcuXN49eoVzMzMUKdOHXEaResfQUFBOH/+PACgU6dOKsspbBmojSIB5d27d1prvAuCIF6Hi5q2462w57/iXuf9+/daW6vLzMwscEt2Cg8ePFDrlkLhzp07YsKMpnudChUqoE2bNgBU73WqV6+u9fySwud6/S0M5eP3zJkzObauoCivjYyMxK4MlWvr+/j4aJ3Xz88vx9+W6toZEBCgdXmnTp0S/9+iRQsAH+55TPkZfMSIERqnyczMRGBgYL6WmxdWVlZiZQlFua7JsWPHsHnzZixZsgS6uroqZUVO931Xr15F48aN0aNHD7EVFBMTE/Famd/jJi8Kc09Z0O1hbW0tXidyms/V1RUbN27Exo0bxelze46Li4vTmDyVV1JsD2X9+/cXfyMuLk68huclcVB5mxRlgjARERFRUWLiBxERfVBDhw4FkPWhd9GiRcjIyFCbJiwsDB4eHkhISICZmZnYb7hy7cl79+6pzZeZmYnFixeLHxo0fSRTPOhrGqdcW1NTVzGenp4afzevunTpgnLlygEAVq1apVJDRCE+Ph7r16/H27dv8fLlS9StWxcAULZsWVy7dg0JCQnYt2+fxuXfvn1bbV3yolatWgCympAuKOUaoNq20cWLF+Hu7i7+XdCPmPlRt25djB49WuPvA/87HiMjI/HPP/9oXMbu3bsRGRmJ58+fw8LCQhzerVs3MTFgyZIlGtfH0dGx0M26Jycni7X3lCUlJWHlypUAsmqya+vDvl+/fgCyPjIoEo4Uw/LDxMQEt2/fRnR0tPghMDvFMSiTyVRaV1Ecj1evXsXz58/V5vvnn3+K9ANhUShRogQGDRoEIOuFsbYXvytXrhRf+g0ZMuSjxVcYhTnuFeVwdHS0xiaVExMTsXjxYvHvj3Ge54Wuri4GDhwIIOvFsLYmzteuXYu4uDg8ffoUVlZW4nBFGffgwQONHzNiYmJUEkWyr7fyS+bs48zMzMSkAh8fH7XlZ2RkwMnJKbdVzJFinyckJIjlRnanTp3ChQsXEBcXh2rVqn0yLX+8ffsWa9eu1Thcsa7Vq1cXP+AB/9set2/fxq5duzQud+fOnYiIiABQsHM7p30u5XnUpUsX8XhbvXq1xg+p//77L16+fAkAsLW1BVC4+7eiUL58edSvXx8AsH79egBZyRbKx6ki8ePixYtiC3HZEz+U16UgZaA2X331lVjzeM2aNRq3686dOwv1cSwnyvdh2X+7MOd/y5Ytxev5n3/+qfFavXPnzlxb7MiNIAhYtmyZ2vDU1FSx2wojIyP07dtX4/yK+5qzZ8/C19cXQPFq7UPhc7z+FpZim8XFxalcZ5X5+PiISbgDBgwQu/epWrWqmJS1adMmjYnxJ06cEBPttf22VNfOhw8fwtnZWW34s2fPsGnTJgBZyVCKhKIP9TyW2zM4ADg5OSEqKipfy80LXV1d8Vw+fPiwxmf02NhYHDx4EEDW85menh4aNWok3sdt27ZNJTaF9+/fY8WKFUhJSUF0dDQaNWokjlM8A1y/fh0HDhxQmzchIUHcB/lVmHvKgm6PChUqiM+Ku3bt0phoFx4eLj7v9O7dWxyueI7z8/PTmAC1bt26QiU8SbE9lHXp0gUmJiZ4//49Vq1ahdTUVFSpUkXlvlEb5fcnincqRERERMUNEz+IiOiDqlevnlhTyNfXF6NHj8aFCxcQHx+PR48ewdnZGePHj0daWhpKliypUtNN+cP2rFmzcPr0aTx//hwxMTE4deoURo0apfIiS9MHd8XHjuDgYNy7d08l+aJr167i/6dOnYrTp08jLi4OkZGRWLNmDebOnVuobhxKliyJn3/+GUDWS9vBgwfj0KFDiI2NRWxsLE6dOgU7OzuxVuOsWbPEGuoNGzYUX1yuW7cOK1aswO3btxEfH48HDx5g586d+P333wFktfKg/OIqN4pWCkJCQgr80kYul6N8+fIAgP3792PTpk14+PAh4uPjce3aNSxduhQTJkxQ+VD0sfq5nz59uvgxZsWKFWLz70BWyzGKJmFXrlyJn376CTdu3EBCQgLu3LmD5cuXY/ny5QCAGjVqwM7OTpzX1NQUP/74IwAgMDAQY8aMweXLl5GQkIDw8HD8+OOPcHZ21tosel6VKFECO3bswM8//4yIiAi8evUKfn5++Oabb3D//n3IZDIsXLhQ6+98/fXXkMlkuHXrFsLDw2FgYIBu3brlO44uXbqgRo0aAIBffvkFmzZtwt27d/Hq1Svcu3cPGzZswJYtWwAAPXv2FI8H4H/nVmpqKsaPH4+AgADEx8fj9u3bWLBgAdasWVMsu0iZNGmS2D3EjBkz4OjoiMjISCQmJiIsLAwzZszA7t27AWQ1B9yzZ08pw82zwhz3NjY2ALJquE2aNAkhISGIj49HVFQU9u3bhwEDBiA8PFycXtH/fHEwZcoUsSyYNWsWVqxYIZ5TN27cwNy5c8X92axZM5WX3or1joiIwOzZs3H79m28evUKkZGR+Pvvv9G/f3+VD0rZ11v5+Pb29sbLly9VmuPv3LkzgKymqGfMmIHw8HDEx8cjICAA3333Hc6dO1eoc6Rr167o2LEjAGDv3r2YPHkygoOD8erVK9y/fx+bNm0SW40yNzfHlClTCvxbUti1axfmz58v7k9/f3+MGjVKPBazl5HDhg0Tu29atmwZFi1ahPDwcCQmJiI8PByLFi0SzwFra2t8++23+Y4pp30u5XlkYGAgXruuXr2K0aNHi2VyZGQk1q9fL36Ab9++Pdq2bQugcPdvQNaHl549e6Jnz55YvXp1gWJXHMM3b94E8L9EDwXF3wkJCcjIyECtWrU0JsIWpgzUpkSJEpg/fz6ArNbhFNtVUU4sW7YMK1asKNB654VyizSK5BvFcVOY879EiRJiMsG9e/cwYsQIscUVxXr9+eefRXKvc+LECUyaNAnXrl3Dq1evEBwcjO+++w5BQUEAgLlz56p026OsW7duMDIywqtXr8QkV21JIlL6XK+/hdG5c2fxGrlr1y7MmDEDYWFhSExMRGRkJBwdHTFjxgwAWYkeM2fOVJn/t99+g56eHl6+fInhw4fDy8sL8fHxePz4sXjsazt+pb52lihRAn/88QdWrVqFqKgoxMfHw9vbGyNGjEB8fDz09fXx66+/itN/qOcxGxsbMaFlyZIlOHLkCJ49e4bY2FicP38eDg4O2Lhxo8o8RfmcN3XqVJQtWxZpaWkYM2YM9u7di5iYGMTGxuLEiRMYPXo0EhISYGRkhOnTp4vz/fbbb9DV1cXr168xbNgwODs748mTJ4iLi8OFCxcwZswYsTXPsWPHqnTzOGDAALHVkN9++w2rV68Wt6WPjw+GDx+OmJiYAiX6FPaesqDbY+7cuTAwMEBCQgKGDx+Ow4cP48WLF4iOjoabmxvGjRuHtLQ0lC9fHvb29uJ8Xbp0AQC8ePECEyZMQFhYGOLj4xESEoLp06fDxcWlUPeoUm0PBQMDA3Tv3h1A1vUTyLp+5GXfKlorMTMzy7E7ISIiIiIp6eY+CRERUeH8/PPPSEtLw8GDBxEcHIyxY8eqTWNsbIw1a9ao1Lju0KEDbG1tcezYMTx69AiTJ09Wm69ChQro0qUL/v33X6SmpiImJkal79dWrVrBy8sLz549E2uxnj59GlWqVEGLFi0wZMgQHDhwANHR0WrLr1GjBmbMmCG+XCyI3r174/Xr11i6dCmio6Mxd+5ctWlkMhmmTJki1jJTWLlyJb799ltERUVh+/bt2L59u9q8NWrUEGvC5pWNjQ127NiBhIQEREZG5qlma3YlSpTAkiVLMHXqVKSnp2PdunVqrVTo6OhgwoQJ2L17N96/f6+x5tWHYGRkhF9++QVTpkxBQkIClixZItYO19fXx9atWzF58mRcu3YNbm5ucHNzU1tGjRo1sG3bNrEpWYUhQ4YgPj4ejo6OCA4OxqhRo1TG169fHxYWFjh8+HCB4//6669x584dHDx4UKytpKCrq4uFCxeqNGWdXeXKldGiRQvxw4miVlN+6enpYf369bC3t8fLly817mMAaNy4MZYsWaIyrG/fvvD09MT58+cRHh6OMWPGqIy3trZGv379sHDhwnzH9SGZmppi+/btcHBwwIMHD7B582Zs3rxZbbqvv/4aixYtkiDCginMcT9x4kScPXsWkZGR8Pf3h7+/v9p8TZo0gZmZGc6ePYuHDx9+0HXJD3Nzc2zfvh2TJk3KsRxt1KgRnJycVGq4zpkzB1euXMGLFy9w7Ngxja3edOzYEQkJCQgNDVVbbwMDAzRp0gShoaHiudyyZUvs2bMHAPD9998jMDAQ0dHROHHihFr3QnZ2dnj37p1aGZBXMpkMq1evxqxZs3D27FmcPn1aY9Pn5cqVw19//ZXvrqCkJJfLoaOjA3d3d7VWnfT19fH777+LyQvKw7ds2YIpU6YgNDQU+/bt09ialo2NDVatWqXWLHhe5LTPpT6PBg0ahJcvX8LR0REhISFqZTKQVS6vWbNGZVhB79+ArBq6Dx48AJD18aggOnTooNL6jSIhVqFcuXKoXbs2IiMjAWhu7QMo/LVfmx49emDGjBlYt26dxu1auXJl1K5dG35+fgU6pnLSoEEDGBkZ4e3bt1iwYAEWLFiAqVOnYtq0aYU+/9u2bYsVK1bgl19+QUREBCZMmKC2Xl27dtXaek5eKM5RX19fscUOZVOnTsXw4cO1zm9oaIgePXrAw8MDgiCgSZMm+Wr97mP5XK+/hbVq1SrMnj0bvr6+8Pb21thqV/369bFu3Tq1e1wLCwts2bIF06ZNw9OnT/HDDz+ojDczM8OoUaM0tqwl9bVz9OjROHHiBLZt24Zt27apjDMyMsLatWvVWif7EM9jlpaWGD9+PLZu3Yq4uDiN3V+VKlUKQ4YMEe+rHj58qJIEXhjly5fH33//jYkTJ+L58+dYvHixSus2it9ft24dqlWrJg5r2rQp1q9fj9mzZ4vPgNmfUYCs57nsCQEymQxOTk5iktXWrVuxdetWlWlmz56N9evX59gFkSaFvacs6PawtLTEpk2bMH36dDx79kxMAlVWoUIFbNu2TSWRY8yYMTh9+jRu3bqFoKAgtXcU3bp1Q506dQrcOp1U20NZ//794e7uLlaCyWuLUYrED+XkKCIiIqLihi1+EBHRB6enp4fff/8dzs7O6NOnDypXrgx9fX0YGBjA0tIS9vb28PLyEmtYKVu9ejUWL14Ma2trGBsbQ1dXF2ZmZrC2tsbMmTPh6ekJBwcH8YPdyZMnVeYfOnQopk2bhkqVKkFPTw/ly5dX6at+6dKlcHR0RJs2bVC6dGkYGBjAwsIC06ZNg4eHR5G8wBo+fDi8vb1hZ2cHCwsLGBkZQU9PD5UrV0a/fv3g6uqKadOmqc33xRdfwMPDA7Nnz4a1tTVKly4NXV1dmJubo3nz5pg/fz6OHDmikuiSF23atEHZsmUBQKVv5vzq1KkTXFxc0KtXL5QvXx66urowMjJCrVq1MHjwYBw8eBCzZs0Sm01V7pv6Q+vatatYW8nb21vlo0L58uWxf/9+rFixAu3bt0fZsmWhq6sLExMTWFtbY968eTh8+LDWF0UTJ06Eq6srevXqhUqVKkFfXx/Vq1fHpEmTsG/fPhgYGBQqdiMjI+zbtw8ODg6oWrWqeNz27dsXHh4eeeqCQPnlVWGaPq9Tpw48PT0xefJk1K9fXzwHy5YtCxsbGyxduhT//vuvWo3cEiVKYMuWLVi0aJF47hoZGaF+/fqYP38+nJ2d8/xh7WOrUaMGjhw5gl9//RUtWrSAmZkZ9PX1UbVqVdja2mLnzp1YuXJlsY1fm4Ie96ampnB1dYWDgwNq164NfX198Zhs164dVqxYgb1796JPnz4AsrrOUu6GSmq1atUS92fLli1hZmYmXkdatWqFpUuXYv/+/ShTpozKfFWqVIGHhwfs7OxQrVo16OnpQV9fH19++SW6dOmCjRs3YsuWLeKH5qtXr6q0LgRkdf3UuXNnlCpVCiVLllSpDfvFF1/g0KFD4nYtWbIkzMzMYGNjg02bNuGXX34p9LqbmJhgy5Yt2LhxI7p164YKFSpAT09PPBenTZsGLy+vfLUYVRyYmJhg//79mDRpEqpWrQp9fX1Uq1YNw4YNw9GjR7WWeeXKlcO+ffuwYsUKtGvXDmXKlIGenh4qVaqETp06wcnJCX///bfasZAf2vZ5cTiPJk6cCA8PDwwcOBCVK1eGnp4ejI2NYW1tjUWLFsHZ2VnszkyhMPdvRaFhw4Zil3nm5uawtLRUm0a5FRBtiR9A4a/92kyaNAl79uxBt27dUK5cOfH+zt7eHh4eHvjiiy8AZLUCV5TKlCmDzZs3o3HjxjAwMICJiYlKq0KFPf/79++Pw4cPY9CgQeJ5VqlSJdjZ2cHd3V3cLwVVokQJbN68GXPmzBHPiTJlyqBr167Yt2+fxvvi7JS7sSuO3bwofK7X38IwNjbGX3/9hU2bNqFLly4oX7682H2FIjFp//79Kt0MKrOxscGxY8fw7bffombNmihZsiTKly+PgQMHwsPDI8cuGqS8dpYvXx7u7u4YOXIkvvjiC/EaNWzYMHh6eqJDhw5q83yo57FZs2Zh3bp1aN26NUqXLo0SJUqgVKlSqF+/PhwcHHDs2DHMmDFDTLzJ/gxeWPXq1YO3tze+//578RlET08P1atXh52dHY4ePSq2HKGsS5cuOHXqFBwcHFC3bl2YmJiIx06PHj2wfft2LF26VGOrL+bm5ti9ezeWLl0Ka2trmJqawtjYGM2bN8fGjRsxfvz4Aq1LUdxTFnR72NjY4MSJExg3bhwsLS1haGiIkiVLwtLSEg4ODjh69Kha4qbiPmv27NmoV68eDA0NYWJigqZNm2LZsmVwcnIqVKtPUm4PhZYtW6JSpUoAshIp89JtS3JystgCmaLcJSIiIiqOZEJhOuYjIiKiT9LatWvx119/oVGjRhr7MaZPm5ubG3766SeULVv2g9Q0JiL62Ozs7BAUFISmTZvi33//lTocojz54Ycf4OXlhdatWxeqhQxSd+nSJXz77bfQ09ODn59foZK2iIjo8yEIArp06YLo6Gj8/PPPGD16dK7zuLi4YMGCBahSpQpOnDjB52siIiIqttjiBxER0Wfo22+/hZGREa5du4aIiAipw6EiduTIEQBZXa7wpRQREVHRCg8Px6xZs+Dk5ITk5GSN0wiCgFu3bgFAnmoTU/4o7nU6duzIpA8iIsqzK1euIDo6Gnp6enluvUNRWWbChAl8viYiIqJijYkfREREnyFzc3N88803AABXV1eJo6GiFBwcLHbhk71PZiIiIio8ExMTeHp6YsOGDTh+/LjGaY4ePYqoqCgAyLHJecq/qKgoeHl5AeC9DhER5V1GRga2bNkCAOjWrVueEgfDw8Nx/fp1fPHFFxgwYMCHDpGIiIioUJiiSkRE9JkaO3Ys3N3dceDAAYwfPx4VK1aUOiQqIA8PD7x8+RIJCQnYt28fBEFA586dUbt2balDIyIi+s+pUqUKrK2tERISgj/++AMJCQno1KkTypQpg+fPn+P48eP4+++/AQAtW7ZEly5dJI740+fr64uIiAikpKTA1dUV7969g5WVFdq3by91aEREVIzFx8dj+/btMDc3x9mzZxEUFASZTIaxY8fmaf4NGzYAAGbMmAF9ff0PGSoRERFRoTHxg4iI6DNVpkwZLFy4ENOnT8e6devwxx9/SB0SFVBERAS2b98u/m1qaopffvlFwoiIiIj+21asWIExY8bg6dOnWLlyJVauXKk2jbW1NdasWQOZTCZBhP8tMTExcHR0FP/W19fHkiVLuG2JiChHBgYG2LZtm8qwb7/9Fg0aNMh13itXrsDHxwcdO3Zkax9ERET0SWBXL0RERJ+xHj16oE+fPvDw8EBERITU4VABNW7cGGXKlIGRkRFsbGzg7OyMypUrSx0WERHRf1b16tVx9OhRzJo1C40bN4aJiQn09PTwxRdfwMbGBitWrMCePXtQvnx5qUP9T7CyskLFihVhYGAAa2tr7NixA40aNZI6LCIiKuaMjIzQtGlT6Ovro1KlSvjhhx8wb968PM27cuVKlC5dGosXL/7AURIREREVDZkgCILUQRARERERERERERERERERERFR/rHFDyIiIiIiIiIiIiIiIiIiIqJPFBM/iIiIiIiIiIiIiIiIiIiIiD5RTPwgIiIiIiIiIiIiIiIiIiIi+kQx8YOIiIiIiIiIiIiIiIiIiIjoE8XEDyIiIiIiIiIiIiIiIiIiIqJPFBM/iIiIiIiIiIiIiIiIiIiIiD5RTPwgIiIiIiIiIiIiIiIiIiIi+kQx8YOIiIiIiIiIiIiIiIiIiIjoE8XEDyIiIiIiIiIiIiIiIiIiIqJP1P8BqxNxsEXj9s4AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: hcc_data phase 5 complete\n", - "INFO: Running Statistics Summary for hcc_data_custom\n", - "INFO: Running stats on Naive Bayes\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Running stats on Logistic Regression\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Running stats on Decision Tree\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Generating ROC and PRC plots...\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Saving Metric Summaries...\n", - "INFO: Generating Metric Boxplots...\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiQAAAKWCAYAAAB58YIOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABcIklEQVR4nO3deVyVdf7//+dZBAFBINy1Mi1xzRV0XMiFLLNpsUmyKEvLSZEarTRL89tUNm2amqKVltYvtcz8pO2u6eSeoqG4mykugAqyczi/PxzPxLghnsMbjo/77ebtnHMtb14XXsLT9/W+3pfF6XQ6BQAAYJDVdAEAAAAEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxdtMFVBROp1NFRUxqezmsVgvfM5QJzjWUFc61y2e1WmSxWC65HYGkhIqKnEpPzzJdRoVht1sVEhKgjIxsFRYWmS4HXoxzDWWFc610QkMDZLNdOpBwyQYAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxtlNF4CK5djJHOXkFl5yO5vNogPHs+QsdMjhcJaobb/KdlUP9rvSEgEAFRCBBCWWmZ2v56f9ImfJ8sVls1osGj+0owL9fTzzBQAA5RaBBCUW6O+jcYM6lKiH5OiJbCUs/E1/v6upaoT4l6h9v8p2wggAXKUIJLgsJb2kYrNZJEm1wwJUt1oVT5YEAPACDGoFAADGEUgAAIBxxi/ZpKWlady4cVq5cqUkqVWrVho1apSuu+46SdJPP/2kadOmaffu3QoKClJUVJSGDRum4ODgC7Y5YMAArVq1qtiy4OBgrV271mPHAQAASs94IBkyZIh+/fVX1a9fX5UrV9by5cv122+/afHixdq6dauGDh0qi8Widu3aae/evZo7d6727dunWbNmyWKxnLfNpKQk2e12RUVFuZZVqcI4BgAAyiujgeSPP/7Q7t27de211+rrr7+W3W7Xbbfdpv379+vf//63Fi9erKKiIj377LMaOHCg0tPTFRUVpXXr1mnv3r1q0KDBOW0eOXJE6enpatiwoaZMmWLgqAAAwOUyGkjq1q2rDRs2KDMzU5UqVVJ2draysrIknbnEEhsbqy5duugvf/mLJCkkJESVK1dWfn6+0tPTzxtIkpKSJEk2m01jxoxRbm6uunfvrp49e5bdgQEAgMti/JKNJAUGBurzzz/XpEmTdPz4cfXp00ft27eXxWJRZGSka7v58+crIyNDfn5+aty48XnbOhtIkpOTlZycLElauHCh4uPjNWTIkCuq025nDHBJWW1W1yvfN3iS7T/n2tlXwFM41zyrXAQSSVqzZo2OHj0qu92uSpUqKTc3V35+/53zYvny5Ro7dqwk6dFHH73gmJDQ0FC1bdtW0dHR6tOnj1asWKHhw4dr6tSp6tOnj2rWrFmq+qxWi0JCAkq179UoLatAkhQQ4Mv3DWUiKIjHDqBscK55hsXp9NRE4JcnIyNDTqdTI0aM0LJly/Tggw9qzJgxkqTvv/9ew4cPV0FBgTp37qyEhATZ7SXPUr1799auXbs0efJkRUdHl6o+h6NIGRk5pdr3avT7sdN6cfoavfJEe11bnQHF8BybzaqgID9lZOTI4SgyXQ68GOda6QQF+ZWoV8l4D8np06eVk5OjatWqSZLuu+8+LVu2zHWL7pIlSzRs2DAVFhaqa9eumjhx4kXDSEpKio4dO6aGDRsqIODM/8x9fM5MR15YeOkpzy+msJATsKSK/vOPtchRxPcNZcLBuYYywrnmGUYvhK1atUpt2rTRI488ooKCM138iYmJkqRq1app9+7dGj58uAoLC9W9e3dNnjzZFS4u5KmnntL999+vefPmSZIOHTqkXbt2yWazqUWLFp49IAAAUCpGe0giIiIUHh6uHTt2qFevXgoLC9OmTZtkt9v15JNPavz48crJOXOZJCsrS/Hx8a594+Li1KRJE40ePVppaWmuzwMGDFB8fLzeeOMNLV26VLt27VJ+fr5iY2NVp04dU4cKAAAuwmgPiY+Pjz744APde++9ysnJ0c6dOxUREaFPP/1UrVq10ooVK1zbrlmzRkuWLHH9SU1NlSStXr262OeePXtq/PjxatSokRITE+Xr66u4uDiNHDnSyDECAIBLKzeDWss7h6NI6elZpsuoMP44flpjPlynlwdE8LRfeJTdblVISIBOnMjiuj48inOtdEJDA0o0qJWbqQEAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAccYDSVpamp555hlFREQoIiJCgwYN0oEDB1zrN2/erL/97W9q3ry5oqKiNH369Eu2uXz5ct15551q1qyZoqOjNX/+fE8eAgAAuEJ20wUMGTJEv/76q+rXr6/KlStr+fLl+u2337R48WLl5+drwIABOn36tJo3b669e/fq7bffVkBAgB588MHztrdjxw4NGTJETqdTzZs3V1JSkkaNGqVrrrlGt9xyS9keHAAAKBGjPSR//PGHdu/erWuvvVZff/21FixYoOuvv17Hjx/Xv//9b33xxRc6ffq07rrrLn3xxRd67733JEkff/zxBdv85JNPVFhYqEGDBmnu3LkaM2bMJfcBAABmGe0hqVu3rjZs2KDMzExVqlRJ2dnZysrKkiQFBwdr06ZNkqTIyEhJUkREhCpVqqQDBw4oLS1N11xzzTlt/u8+HTt2lHTm0o/T6ZTFYvH4cQEAgMtj/JKNJAUGBurzzz/XpEmTdPz4cfXp00ft27fXq6++KkkKCQmRJNlsNgUGBio9PV0pKSnnDSQpKSnF9jn7mp2drZMnT7o+l4bdbnzIjdsdSc9Wbl6h+9s9kVPs1d0q+9pVM9TfI22jYrHZrMVeAU/hXPOschFIJGnNmjU6evSo7Ha7KlWqpNzcXOXm5kqS7Pb/lnn2/dl1/+t/9/nzvnl5eaWuz2q1KCQkoNT7l0eHj5/Wc1P+7dGvMeXLrR5re9rI7qpdrYrH2kfFEhTkZ7oEXCU41zyj3ASSl156SWPGjNGIESM0Z84c2Ww2+fr6SpIcDodru8LCM/+b9/M7/wnh6+urnJwc1z5nt5ekypUrl7q+oiKnMjKyS71/eXT0eKYk6e93NVXtMPeGLavNKqfVKktRkYocRW5t+3BqlhIW/qajxzPlZ+cS3NXOZrMqKMhPGRk5crj5XAP+jHOtdIKC/ErUq2Q8kJw+fVo5OTmqVq2aJOm+++7TsmXLtHbtWtWoUUO7d+/WqVOnJJ0JJhkZGZKkWrVqnbe9GjVqaP/+/a590tPTJUn+/v6qWrXqFdVaWOhdJ6DD4ZQk1QjxV1039zTY7VaFhAToxIkst3/fztbtcDi97u8EpedwFHE+oExwrnmG0Qthq1atUps2bfTII4+ooKBAkpSYmChJqlatmlq2bCnpzOUcSVq/fr0KCwt1/fXXKzQ09Lxt/u8+Z19bt27NgFYAAMopoz0kERERCg8P144dO9SrVy+FhYVp06ZNstvtevLJJ3Xdddfpo48+0oIFC7R3717t3btXkvToo4+62hg9erTS0tIUFxenJk2aKDY2VosWLVJCQoJWr16tpKQkSVL//v1NHCIAACgBoz0kPj4++uCDD3TvvfcqJydHO3fuVEREhD799FNFRkaqZs2a+uijj9SqVSslJSXJ399fw4cPV0xMjKuN1atXa8mSJUpNTZUkNWvWTFOnTlWDBg20bds2Va9eXePGjVPnzp1NHSYAALgE42NIqlWrpnHjxl1wfYsWLTRnzpwLrl+6dOk5y7p06aIuXbq4pT4AAOB53EwNAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMM/60XwA4n2Mnc5STW3jJ7Ww2iw4cz5Kz0CGHw1mitv0q21U92O9KSwTgRgQSAOVOZna+np/2i5wlyxeXzWqxaPzQjgr09/HMFwBw2QgkAMqdQH8fjRvUoUQ9JEdPZCth4W/6+11NVSPEv0Tt+1W2E0aAcoZAAqBcKuklFZvNIkmqHRagutWqeLIkAB7EoFYAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADG2U0XkJ6ernfffVfLly9XRkaGbrjhBg0ZMkTdunVTt27ddOjQofPuN2vWLEVGRp533YABA7Rq1apiy4KDg7V27Vq31w8AAK6c0UDidDoVFxenjRs3qk6dOmratKk2bNigwYMHa+bMmerYsaPS0tJc22dmZmrdunWqUqWK6tWrd8F2k5KSZLfbFRUV5VpWpUoVjx4LAAAoPaOBJDk5WRs3blRISIgWL14sPz8/vf7665o5c6bmzZun8ePHF9v+ueeekyT985//VO3atc/b5pEjR5Senq6GDRtqypQpHj8GAABw5YwGkrCwMFfo8PPzkyTVrFlTkor1jEjSv//9by1cuFAdO3ZUr169LthmUlKSJMlms2nMmDHKzc1V9+7d1bNnT08cAgAAcAPjgeTP4SInJ0dz586VJLVp06bYtpMmTZIkPfXUUxdt82wgSU5OVnJysiRp4cKFio+P15AhQ66oXrvdu8YA22wW16u7j81msxZ7dW/bnqsbFY/1P+eY1WblfIBHefLnGsrBoNazcnNzNXjwYO3du1fBwcGKjY11rUtMTNSmTZvUqlUr3XzzzRdtJzQ0VG3btlV0dLT69OmjFStWaPjw4Zo6dar69Onj6oG5XFarRSEhAaXat7xKyyqQJAUG+Xns2IKC/NzeZlnUjYrj7PkQEODL+YAy4YmfaygngSQrK0uDBg3S+vXr5ePjowkTJig0NNS1fsGCBZKkO+6445Jt9evXT/369XN97t27txISErRr1y5t3bq11IGkqMipjIzsUu1bXmVm5LheT5yo5Na2bTargoL8lJGRI4ejyK1te7JuVDxZWXmu1xMnsgxXA2/myZ9r3iwoyK9EvUrGA0leXp4rjPj5+em9995Thw4dim1z9hberl27XrK9lJQUHTt2TA0bNlRAwJn/Lfn4+EiSCgsLr6jWwkLvOgEdDqfr1VPH5nAUub3tsqgbFUfRf34xFHngXAPOxxM/11AOJkYbO3as1q9fL19fX33wwQfq2LFjsfUpKSn6/fffFRoaqrp1616yvaeeekr333+/5s2bJ0k6dOiQdu3aJZvNphYtWnjkGAAAwJUx2kOyY8cOffnll5KkqlWrasaMGZoxY4YkqX79+nr22WddE6PdeOON521j9OjRSktLU1xcnJo0aaIBAwYoPj5eb7zxhpYuXapdu3YpPz9fsbGxqlOnTtkcGAAAuCxGA8kPP/zgen/s2DEtWbLE9fns4NXU1FRJKjam5M9Wr16tQ4cOKSYmRpLUs2dPjR8/XtOnT1diYqKCg4MVFxenJ5980lOHAQAArpDRQBIfH6/4+PiLbnPbbbe5bt89n6VLl56zrFevXhedqwQAAJQvxseQAAAAEEgAAIBxBBIAAGCc8XlIYJbFN1tHclJkyTzl1nbtNqtOOP2UmZmjQjdPIHQkJ1sWX++apA4ArnYEkqtYdmG2fFus1Kx9K6V9pqu5PL4tLMoubCcp0HQpAAA3IJBcxfzt/spL7KIn7r5JtcL83dq23WZVYKBnekhSUrM1/aud8m/q3poBAOYQSK5yzjx/1fSrpWsD3dvTYLdbFRISoBOWLLdPsezMypQz7w+3tgkAMItBrQAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA444EkPT1dL730kqKiotSqVSv16dNHS5cuda0fM2aMGjVqdM6frKysC7a5fPly3XnnnWrWrJmio6M1f/78sjgUAABQSnaTX9zpdCouLk4bN25UnTp11LRpU23YsEGDBw/WzJkz1aFDByUlJUmSoqKiZLf/t9w/v/+zHTt2aMiQIXI6nWrevLmSkpI0atQoXXPNNbrlllvK4rAAAMBlMhpIkpOTtXHjRoWEhGjx4sXy8/PT66+/rpkzZ2revHlq166ddu7cKX9/f02bNk0Wi+WSbX7yyScqLCzU4MGD9dRTT+nzzz/Xiy++qI8//phAAgBAOWU0kISFhWn8+PGSJD8/P0lSzZo1JUlpaWnas2eP8vLyVLNmTb366qs6ceKEOnTooHvvvVdW6/mvNm3atEmSFBkZKUnq2LGjJGnz5s1yOp0lCjUAAKBsGQ8kvXr1cn3OycnR3LlzJUlt2rRxXa45cuSIZs+eLUlatGiRNm3apNdee+28baakpEiSQkJCir1mZ2fr5MmTrs8AAKD8MBpI/iw3N1eDBw/W3r17FRwcrNjYWK1fv17t27dXy5Yt1b9/fyUnJ2vgwIGaP3++YmJi1KJFi/O2I/13jMmfx5rk5eVdUY12u/ExwG5ls1lcr+4+NpvNWuzVvW17rm54zpH0bOXmFbq/3RM5xV7drbKvXTVD/T3SNioWT/5cQzkJJFlZWRo0aJDWr18vHx8fTZgwQaGhoerZs6d69uzp2q59+/bq2LGjli9frk2bNp03kPj6+ionJ0cOh0OSVFj43x+AlStXLnWNVqtFISEBpd6/PErLKpAkBQb5eezYgoL83N5mWdQN9zp8/LSem/Jvj36NKV9u9Vjb00Z2V+1qVTzWPioWT/xcQzkIJHl5ea4w4ufnp/fee08dOnSQJB0/flxHjhxRnTp1FBoaKulM4JCKB40/q1Gjhvbv369Tp05JOnNbsST5+/uratWqpa6zqMipjIzsUu9fHmVm5LheT5yo5Na2bTargoL8lJGRI4ejyK1te7JueMbR45mSpL/f1VS1w9wbIq02q5xWqyxFRSpy87l2ODVLCQt/09HjmfKzM/7saufJn2veLCjIr0S9SsYDydixY7V+/Xr5+vrqgw8+UNu2bV3rXnvtNX3zzTeKjY3Viy++qNOnT2vDhg2SpFatWp23vZYtW2r//v1as2aN2rVrpzVr1kiSWrdufcUDWgsLvesEdDicrldPHZvDUeT2tsuibrjX2b+zGiH+quvmnga73aqQkACdOJHFuYYy4YmfazAcSHbs2KEvv/xSklS1alXNmDFDM2bMkCTVr19fjzzyiH788UfNnj1b27ZtU0pKitLS0tS1a1e1adNGkjR69GilpaUpLi5OTZo0UWxsrBYtWqSEhAStXr3aNTC2f//+Ro4RAABcmtGROT/88IPr/bFjx7RkyRLXn/Xr16tly5Z6//331apVKyUnJys/P1+xsbF65513XPutXr1aS5YsUWpqqiSpWbNmmjp1qho0aKBt27apevXqGjdunDp37lzmxwcAAErGaA9JfHy84uPjL7pNhw4dXGNKzufP08yf1aVLF3Xp0uWK6wMAAGWDe5cAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMbZS7JRt27dZLFYStSgxWLRTz/9dEVFAQCAq0uJAklERMRFA4nT6dSSJUuUmZmpKlWquK04AABwdShRIHn99dcvuO7gwYMaNWqUMjMz1bFjR73yyituKw4AAFwdShRILuSTTz7R22+/LZvNpn/+85/629/+5q66AADAVaRUgeRsr8j69evVqVMnvfLKK6pZs6a7awMAAFeJyw4ks2fP1jvvvCO73a5XXnlF9913nyfqAgAAV5ESB5KDBw/q+eef14YNG9SlSxf985//VI0aNTxZGwAAuEqUKJDMmjVL48ePl4+Pj8aNG6d77rnH03UBAFAqO1L+0Knc7BJvn5mdr7wCxyW3s1otqlzZR7m5+Soqcpaobd9KNgX6+5Ro26qV/RVeq26JtvVGJQokr732miQpJydHo0aN0qhRoy64rcViUVJSknuqAwDgMuw7dlwTkyaqhFNnlStOp0XP2p5R/erVTJdiRIkCSVxcnKfrAADgilmLKisvsYvu6VpP1ar6lWif8tBDcvxUjhYsOyhr08olatcblSiQLFiwQO+9957Cw8M9XQ8AAFfEmeev5jVv0HU1A93art1uVUhIgE6cyFJhYZFb2z5wJFNf5qW5tc2KpkTPsjl06JDy8/M9XQsAALhK8XA9AABg3BXN1OoO6enpevfdd7V8+XJlZGTohhtu0JAhQ9StWzdJ0k8//aRp06Zp9+7dCgoKUlRUlIYNG6bg4OALtjlgwACtWrWq2LLg4GCtXbvWk4cCAABKqcSBZMiQIfLxufTAnMt52q/T6VRcXJw2btyoOnXqqGnTptqwYYMGDx6smTNnyuFwaOjQobJYLGrXrp327t2ruXPnat++fZo1a9YFH/iXlJQku92uqKgo1zIe+gcAQPlV4kDSpEkThYaGuvWLJycna+PGjQoJCdHixYvl5+en119/XTNnztS8efNUUFCgoqIiPfvssxo4cKDS09MVFRWldevWae/evWrQoME5bR45ckTp6elq2LChpkyZ4tZ6AQCAZ1xWD0mLFi3c+sXDwsI0fvx4SZKf35nbs84+EyctLU1DhgxRly5d9Je//EWSFBISosqVKys/P1/p6ennDSRn50Cx2WwaM2aMcnNz1b17d/Xs2dOttQMAAPcxOoYkLCxMvXr1cn3OycnR3LlzJUlt2rRRZGSkIiMjXevnz5+vjIwM+fn5qXHjxudt82wgSU5OVnJysiRp4cKFio+P15AhQ66oXrvdu8YA22wW16u7j81msxZ7dW/bnqsbnsG5hrLCuVZxGR/UelZubq4GDx6svXv3Kjg4WLGxscXWL1++XGPHjpUkPfrooxccExIaGqq2bdsqOjpaffr00YoVKzR8+HBNnTpVffr0KfVTia1Wi0JCAkq1b3mVllUgSQoM8vPYsQUFlWxiostRFnXDvTjXUFY41yquEgWSe+65RyEhIR4rIisrS4MGDdL69evl4+OjCRMmFBuv8v3332v48OEqKChQ586dL9rT0a9fP/Xr18/1uXfv3kpISNCuXbu0devWUgeSoiKnMjJK/myEiiAzI8f1euJEJbe2bbNZFRTkp4yMHDkc7p1AyJN1wzM411BWONfKn6AgvxL1KpUokIwbN+6KC7qQvLw8Vxjx8/PTe++9pw4dOrjWL1myRMOGDVNhYaG6du2qiRMnym6/cNkpKSk6duyYGjZsqICAMynz7N1BhYWFV1Sru2fmM83hcLpePXVsDkeR29sui7rhXpxrKCucaxWX8QtVY8eO1fr16+Xr66sPPvhAHTt2dK3bvXu3hg8frsLCQnXv3l2TJ0++5K3HTz31lO6//37NmzdP0plZZnft2iWbzeb2QbkAAMA9jI4h2bFjh7788ktJUtWqVTVjxgzNmDFDklS/fn3t379fOTlnurGysrIUHx/v2jcuLk5NmjTR6NGjlZaW5vo8YMAAxcfH64033tDSpUu1a9cu5efnKzY2VnXq1Cn7gwQAAJdkNJD88MMPrvfHjh3TkiVLXJ8bN26s3bt3uz6vWbOm2L4xMTGSpNWrV+vQoUOuzz179tT48eM1ffp0JSYmKjg4WHFxcXryySc9eSgAAOAKGA0k8fHxxXo9SmPp0qXnLOvVq1ex24kBAED5ZnwMCQAAAIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHEEEgAAYByBBAAAGEcgAQAAxhFIAACAcXbTBQC4Olh8s3UkJ0WWzFNubddus+qE00+ZmTkqdBS5te0jOdmy+Ga7tU0A50cgAeBx2YXZ8m2xUrP2rZT2ma7m8vi2sCi7sJ2kQNOlAF6NQALA4/zt/spL7KIn7r5JtcL83dq23WZVYKBnekhSUrM1/aud8m/q3poBnItAAqBMOPP8VdOvlq4NdG9Pg91uVUhIgE5YslRY6N5A4szKlDPvD7e2CeD8GNQKAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOO47RcA4HUOHM10e5s2m0UHUrPlLCiUw+F0a9uH07Lc2l5FRCABAHgNR9GZoPDRtzsMV1I6lX1spkswhkACAPAaN9QO0osPt5XNanF720dPZCth4W/6+11NVSPE/bP3VvaxqUbo1TsrMIEEAOBVbqgd5JF2bbYzIad2WIDqVqvika9xNWNQKwAAMI5AAgAAjCOQAAAA44wHkvT0dL300kuKiopSq1at1KdPHy1dutS1fvPmzfrb3/6m5s2bKyoqStOnT79km8uXL9edd96pZs2aKTo6WvPnz/fkIQAAgCtkNJA4nU7FxcVpzpw5stlsatq0qX777TcNHjxYv/zyi44fP64BAwYoMTFRjRo1UmZmpt5++219+umnF2xzx44dGjJkiPbs2aOmTZvqyJEjGjVqlJYvX152BwYAAC6L0UCSnJysjRs3KiQkRIsXL9Ynn3yi/v37y+l0at68efriiy90+vRp3XXXXfriiy/03nvvSZI+/vjjC7b5ySefqLCwUIMGDdLcuXM1ZsyYS+4DAADMMnrbb1hYmMaPHy9J8vPzkyTVrFlTkpSWlqZNmzZJkiIjIyVJERERqlSpkg4cOKC0tDRdc80157T5v/t07NhR0plLP06nUxaL++9NBwAAV8Z4IOnVq5frc05OjubOnStJatOmjX788UdJUkhIiCTJZrMpMDBQ6enpSklJOW8gSUlJKbbP2dfs7GydPHnS9bk07HbjQ27c6uw99QePn3a9dxerzaoDqdmyFBWpyFHk1raPnsiWdKZ+b/s78VZnzy9P/J3ZbNZir+5t23N1o+Kx/uccs9qsnA8eUG4mRsvNzdXgwYO1d+9eBQcHKzY2Vl9//bUkyW7/b5ln3+fm5l6wnT9v9+d98/LySl2f1WpRSEhAqfcvj45n5kuSZizebriS0qlRLdDr/k68VVpWgSQpMMjPY39nQUF+bm+zLOpGxXH2fAgI8OV88IByEUiysrI0aNAgrV+/Xj4+PpowYYJCQ0Pl6+srSXI4HK5tCwsLJf33Es//8vX1VU5Ojmufs9tLUuXKlUtdY1GRUxkZ2aXevzyqFuijlx5t55Eplo+cyNGUL7dq8L3NVTPE/b8oKvva5We36MQJHkhVEWRm5LheT5yo5Na2bTargoL8lJGRI4ebe+M8WTcqnqysPNcrP3tKLijIr0Q9mMYDSV5eniuM+Pn56b333lOHDh0kSTVq1NDu3bt16tQpSWeCSUZGhiSpVq1a522vRo0a2r9/v2uf9PR0SZK/v7+qVq16RbUWFrr3h115cF2NQI+2XzPEz2NTLHvj34e3OvtkVIfD6bG/N4ejyO1tl0XdqDjOXn4u8sC5hnIwD8nYsWO1fv16+fr66oMPPnANQpWkli1bSpLWrFkjSVq/fr0KCwt1/fXXKzQ09Lzt/e8+Z19bt27NgFYAAMopoz0kO3bs0JdffilJqlq1qmbMmKEZM2ZIkurXr6/Y2Fh99NFHWrBggfbu3au9e/dKkh599FFXG6NHj1ZaWpri4uLUpEkTxcbGatGiRUpISNDq1auVlJQkSerfv3/ZHhwAACgxoz0kP/zwg+v9sWPHtGTJEtef9evXq2bNmvroo4/UqlUrJSUlyd/fX8OHD1dMTIxrv9WrV2vJkiVKTU2VJDVr1kxTp05VgwYNtG3bNlWvXl3jxo1T586dy/z4AABAyRjtIYmPj1d8fPxFt2nRooXmzJlzwfV/nmb+rC5duqhLly5XXB8AACgbxseQAAAAEEgAAIBxxm/7BXD1OHA00+1t2mwWHUjNlrOg0HWbrrscTmOuCaCsEEgAeJyj6ExQ+OjbHYYrKZ3KPjbTJQBej0ACwONuqB2kFx9u65FZgY+eyFbCwt/097uaqkaIv9vbr+xjU41Q97cLoDgCCYAycUPtII+0e/YBeLXDAjw2KzAAz2NQKwAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOLvpAgDgfI6dzFFObuEltzt6IluSdDg1Sw6Hs0Rt+1W2q3qw3xXVB+/BuVY+EEgAlDuZ2fl6ftovcpbsZ74kKWHhbyXe1mqxaPzQjgr09ylFdfAmnGvlB4EEQLkT6O+jcYM6lOh/rTabRRa7Tc5Cx2X9r5VfEJA418oTAgmAcqmk3dx2u1UhIQE6cSJLhYVFHq4K3ohzrXxgUCsAADCOQAIAAIwrN5dsMjIyFB0drZMnTyoxMVG+vr7q1q2bDh06dN7tZ82apcjIyPOuGzBggFatWlVsWXBwsNauXev2ugEAwJUrF4EkMzNTQ4YM0cmTJ4st79ixo9LS0optt27dOlWpUkX16tW7YHtJSUmy2+2KiopyLatSpYrb6wYAAO5hPJB88803evPNN3X48OFz1v3zn/8s9vm5555zLa9du/Z52zty5IjS09PVsGFDTZkyxf0FAwAAtzM+hmTatGk6ceKEhg4detHt/v3vf2vhwoXq2LGjevXqdcHtkpKSJEk2m01jxozRc889p++//96tNQMAAPcy3kPSr18/3XLLLSooKNCkSZMuuN3ZdU899dRF2zsbSJKTk5WcnCxJWrhwoeLj4zVkyJArqtVuN57fKgyrzep65fsGT7L951w7+wp4CueaZxkPJH379pUk/fHHHxfcJjExUZs2bVKrVq108803X7S90NBQtW3bVtHR0erTp49WrFih4cOHa+rUqerTp49q1qxZqjqtVotCQgJKte/VKC2rQJIUEODL9w1lIiiI6blRNjjXPMN4ICmJBQsWSJLuuOOOS27br18/9evXz/W5d+/eSkhI0K5du7R169ZSB5KiIqcyMrJLte/VKCsrz/V64kSW4WrgzWw2q4KC/JSRkSOHg8mq4Dmca6UTFORXol6lChFIzt7C27Vr10tum5KSomPHjqlhw4YKCDjzP3MfnzPT9hYWXnpq4IthZr6SK/rPP9YiRxHfN5QJB+caygjnmmeU+wthKSkp+v333xUaGqq6detecvunnnpK999/v+bNmydJOnTokHbt2iWbzaYWLVp4ulwAAFAK5T6QnJ0Y7cYbbzzv+tGjR2vw4MGuwawDBgyQJL3xxhuKjY1Vnz59lJ+fr379+qlOnTplUzQAALgs5T6QpKamSjozWPV8Vq9erSVLlri269mzp8aPH69GjRq5ZnyNi4vTyJEjy6xmAABweSxOp7Nkz1C+yjkcRUpPZ3BmSf1x/LTGfLhOLw+IUN1qzJILz+EJrCgrnGulExoaUKJBreW+hwQAAHg/AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOPKTSDJyMhQZGSkGjVqpLy8PNfyMWPGqFGjRuf8ycrKumBby5cv15133qlmzZopOjpa8+fPL4tDAAAApWQ3XYAkZWZmasiQITp58uQ565KSkiRJUVFRstv/W+6f3//Zjh07NGTIEDmdTjVv3lxJSUkaNWqUrrnmGt1yyy2eKB8AAFwh44Hkm2++0ZtvvqnDhw+fs66wsFA7d+6Uv7+/pk2bJovFcsn2PvnkExUWFmrw4MF66qmn9Pnnn+vFF1/Uxx9/TCABAKCcMn7JZtq0aTpx4oSGDh16zro9e/YoLy9PQUFBevXVVzV8+HB98cUXKioqumB7mzZtkiRFRkZKkjp27ChJ2rx5s5xOpweOAAAAXCnjPST9+vXTLbfcooKCAk2aNKnYurOXa44cOaLZs2dLkhYtWqRNmzbptddeO297KSkpkqSQkJBir9nZ2Tp58qTrMwAAKD+MB5K+fftKkv74449z1vn7+6t9+/Zq2bKl+vfvr+TkZA0cOFDz589XTEyMWrRocc4+ubm5kv47xuTPY03+PFi2NOx24x1KFYbVZnW98n2DJ9n+c66dfQU8hXPNs4wHkovp2bOnevbs6frcvn17dezYUcuXL9emTZvOG0h8fX2Vk5Mjh8Mh6cw4lLMqV65c6lqsVotCQgJKvf/VJi2rQJIUEODL9w1lIijIz3QJuEpwrnlGuQ4kx48f15EjR1SnTh2FhoZKOhM4pOJB489q1Kih/fv369SpU5Kk9PR0SWd6W6pWrVrqWoqKnMrIyC71/lebrKw81+uJExe+RRu4UjabVUFBfsrIyJHDceHxZcCV4lwrnaAgvxL1KpXrQPLaa6/pm2++UWxsrF588UWdPn1aGzZskCS1atXqvPu0bNlS+/fv15o1a9SuXTutWbNGktS6desS3aVzMYWFnIAlVfSff6xFjiK+bygTDs41lBHONc8o14HkkUce0Y8//qjZs2dr27ZtSklJUVpamrp27ao2bdpIkkaPHq20tDTFxcWpSZMmio2N1aJFi5SQkKDVq1e7Bsb279/f4JEAAICLKdcjc1q2bKn3339frVq1UnJysvLz8xUbG6t33nnHtc3q1au1ZMkSpaamSpKaNWumqVOnqkGDBtq2bZuqV6+ucePGqXPnzqYOAwAAXILFyeQcJeJwFCk9nbEQJfXH8dMa8+E6vTwgQnWrVTFdDryY3W5VSEiATpzIohsdHsW5VjqhoQElGkNSrntIAADA1YFAAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOPspgtAxXLsZI5ycgsvud3RE9mSpMOpWXI4nCVq26+yXdWD/a6oPgBAxUQgQYllZufr+Wm/yFmyfCFJSlj4W4m3tVosGj+0owL9fUpRHQCgIiOQoMQC/X00blCHEvWQ2GwWWew2OQsdl9VDQhgBgKsTgQSXpaSXVOx2q0JCAnTiRJYKC4s8XBUAoKJjUCsAADCOQAIAAIwrN5dsMjIyFB0drZMnTyoxMVG+vr6SpJ9++knTpk3T7t27FRQUpKioKA0bNkzBwcEXbGvAgAFatWpVsWXBwcFau3atJw8BAACUUrkIJJmZmRoyZIhOnjxZbPmqVas0dOhQWSwWtWvXTnv37tXcuXO1b98+zZo1SxaL5bztJSUlyW63KyoqyrWsSpUqnjwEAABwBYwHkm+++UZvvvmmDh8+fM66OXPmqKioSM8++6wGDhyo9PR0RUVFad26ddq7d68aNGhwzj5HjhxRenq6GjZsqClTppTFIQAAgCtkfAzJtGnTdOLECQ0dOvScdbGxsfrnP/+p2267TZIUEhKiypUrS5LS09PP215SUpIkyWazacyYMXruuef0/fffe6h6AADgDsZ7SPr166dbbrlFBQUFmjRpUrF1kZGRioyMdH2eP3++MjIy5Ofnp8aNG5+3vbOBJDk5WcnJyZKkhQsXKj4+XkOGDLmiWu124/mtwrDZrMVeAU/hXENZ4VzzLOOBpG/fvpKkP/7446LbLV++XGPHjpUkPfrooxccExIaGqq2bdsqOjpaffr00YoVKzR8+HBNnTpVffr0Uc2aNUtVp9VqUUhIQKn2vZoFBTEVPMoG5xrKCueaZ1iczsuZCNxz/vjjD3Xv3l2Sit1lI0nff/+9hg8froKCAnXu3FkJCQmy20uepXr37q1du3Zp8uTJio6OLlV9DkeRMjJySrXv1chmsyooyE8ZGTlyOJgYDZ7DuYaywrlWOkFBfiXqVTLeQ3IpS5Ys0bBhw1RYWKiuXbtq4sSJFw0jKSkpOnbsmBo2bKiAgDM9Gj4+Z6YjLyy89JTnF8OMo5fP4Sji+4YywbmGssK55hnl+kLY7t27NXz4cBUWFqp79+6aPHmyK1xcyFNPPaX7779f8+bNkyQdOnRIu3btks1mU4sWLcqibAAAcJnKdQ/J+PHjlZNz5jJJVlaW4uPjXevi4uLUpEkTjR49Wmlpaa7PAwYMUHx8vN544w0tXbpUu3btUn5+vmJjY1WnTh1ThwIAAC6i3AaS/Px8rVixwvV5zZo1xdbHxMRIklavXq1Dhw65Pvfs2VPjx4/X9OnTlZiYqODgYMXFxenJJ58su+IBAMBlKTeDWss7h6NI6elZpsuoMHjaL8oK5xrKCuda6YSGBpRoUGu5HkMCAACuDgQSAABgHIEEAAAYxxiSEnI6nSoq4lt1OWw2K5MHoUxwrqGscK5dPqvVIovFcsntCCQAAMA4LtkAAADjCCQAAMA4AgkAADCOQAIAAIwjkAAAAOMIJAAAwDgCCQAAMI5AAgAAjCOQAAAA4wgkAADAOAIJAAAwjkACAACMI5AAAADjCCRwq7MPjz5+/Lh++uknHTt2zHBFAHBlCgsLlZycrF27dsnhcJgux2tZnGd/gwBX4Pjx4xo6dKgGDRqkFi1aqFevXsrIyFBQUJBmzpypJk2amC4RXqKoqEj/93//py1btigvL09//hFmsVj02muvGawO3iYhIUEzZsxQZmamunfvrg4dOmjt2rV666235OPjY7o8r2I3XQC8w+uvv64tW7Zo37592rFjh06dOqUGDRpoz549mjhxohISEkyXCC/x2muv6dNPP5Uk/e//pwgkcKeZM2dqwoQJ8vPzcy3btWuXfvjhB7399tt6/vnnDVbnfQgkcIu1a9eqXr166tu3rwYNGqRq1app8eLFuvfee7V161bT5cGL/Pjjj3I6nerSpYtuuukm2e38GINnfPbZZ6pWrZoWLVqkyMhISVJ8fLx++uknffvttwQSN+NfMtwiIyNDzZo1U6VKlbR161ZFRUVJkkJDQ7Vv3z7D1cGbZGdnq2XLlpo+fbrpUuDlDh8+rPbt26tq1aquZaGhoWrYsKE2bdpksDLvxKBWuEVYWJiSk5M1c+ZM5efnKzIyUr/99ps2bdqk2rVrmy4PXqRXr15KT09ncCE8rk6dOtq8ebN+++03SWcGt65atUobN25U3bp1DVfnfeghgVv07NnTdb3V19dX0dHReumll5Sdna27777bdHnwIjfddJO+/fZb3XvvvWrXrp38/PxksVhc64cNG2awOniTAQMGaMyYMbrvvvtksVi0YsUKrVixQk6nUw8++KDp8rwOd9nALfLz8zVp0iQdOHBADz30kCIiIjRhwgTl5uZqxIgRxX5hAFciPDxcFotFTqez2Hl19vP27dsNVgdv89lnnykhIUFHjx6VJNWoUUNPPPEEgcQDCCQAKpSRI0deNOCOGzeuDKvB1SI9PV2VKlVSYGCg6VK8FoEEbrNhwwZNnz5dW7ZsUUREhP7617/q2LFj/E8CQIV16tQpff7559qyZYsaNGig7t27y2azMbeSBzCGBG6xcuVKPfnkk3I4HK7u9I0bN+rjjz+WzWZTTEyM6RLhRYqKivT1119rw4YNslgsateune644w5ZrYzTh/vs379fDz30kNLS0iT997Lghx9+qA8++EARERGGK/Qu/OuFW0ycOFE+Pj56//33XZNVde/eXZUrV9bHH39suDp4k9zcXMXGxmrkyJH6/PPPNW/ePD333HN6+OGHlZuba7o8eJHXX39d6enpGjhwoOvnWs2aNVVQUKAJEyaYLc4LEUjgFjt37lTr1q3VuXNn17J27dqpRYsWOnTokMHK4G3effddbdy4UdWrV9dDDz2khx56SNWrV9fGjRs1adIk0+XBi6xbt06tW7fW8OHDXcv69u2rli1bMnjaA7hkA7cICgrSvn37iv0PNT09XTt37lRISIjByuBtvvvuO4WGhur//u//XBNWDRkyRHfccYcWL16sZ5991nCF8BYWi0XZ2dnFljmdTqWnp/McGw+ghwRu0bt3bx0+fFg9evSQxWLRunXr1LNnT508eVI9e/Y0XR68SGpqqho1alRs9syQkBA1atRI6enpBiuDt+nYsaO2b9+uv//975LOPMfmwQcf1O+//+6aSh7uQyCBWwwbNky33367UlNT5XQ6lZGRoczMTEVHR+sf//iH6fLgRerUqaPExET9/vvvrmX79+/Xli1bVKdOHYOVwds8//zzqlOnjpYvXy5JOnDggDZt2qSaNWvSE+cB3PYLt/r999+VlJQku92um266Sddee63pkuBlpk+frnfeeUd+fn5q06aNJGnjxo3Kzc3V008/rUGDBhmuEN4kJydHixcvdv1cu/HGG/XXv/5Vvr6+pkvzOgQSuMXQoUN1zz33KCoqSjabzXQ58GIOh0PPPfecFi9eXGx5t27dNHHiRJ7+C7fp06eP2rVrp5EjR5ou5apAIIFbnJ3OOzg4WHfeeafuvvtuJg6CR23bts01D8nNN9+sli1bmi4JXiYiIkLh4eGaNWuW6VKuCgQSuMX06dP1ww8/aNu2bZLOjE5v2LCh7r33XvXu3VvVqlUzXCEAXJ7x48dr1qxZeu2119S2bVsFBgYWm3yPO23ci0ACtzp06JC+/fZbff/999q6dassFotsNpv+8pe/6OGHH1anTp1Ml4gKKCYmRhERERo2bNglZ/2dM2dOGVUFb9etWzcdOXJE5/s1abFYlJSUZKAq78XFVrhVnTp1FB0drby8PB09elTHjh1TYWGhVq5cqZ9//lkvvPCCHnroIdNlooLZvHmzwsLCXO8vhKdKw50OHz58wXX8X9796CGBWxw+fFjffPONvvnmG9cMhk6nUy1btlSfPn20fft2ffbZZ6pVq5aWLl1quFpUNAsWLFCtWrXUvn17LViw4KLb3nPPPWVUFbzRV199pVq1aikyMvKSs0xzm7l7EUjgFo0bN5Z0JoSEhYXprrvuUp8+fXTDDTe4thk4cKDWr1+vLVu2mCoTAC4qPDxcPXr00OTJk02XctXhkg3cwmq1KioqSn369NEtt9xy3lt/W7Zsqfr16xuoDt5m9+7dCgoKUvXq1TV37lytXLlSnTp10gMPPGC6NAClRCCBW6xcuVLXXHPNededfWR3XFxcGVcFb7R8+XLFxcXp1VdfVd26dfXSSy9JkpYuXSqLxXLJQa/ApRQVFSk/P/+S23GXjXsRSOAWVatW1SeffKI9e/YoLy/PNeArOztbmzdv1ooVKwxXCG8xZcoUFRUVyW636+uvv5bVatXTTz+tKVOm6P/7//4/Agmu2LJly3TzzTdfdBvusnE/Agnc4o033tDs2bNdvSF/fv3zffvAldqzZ4/atGmjO+64Q5MmTdJNN92kJ554QmvXrtWvv/5qujx4gZIMrWT4pfsRSOAW33//vfz8/BQXF6c333xTw4YN04EDBzR//nymXYbbVapUScePH9f+/fvVr18/SVJmZqYqVapkuDJ4g44dO+rll182XcZVh0ACt0hLS1OHDh302GOP6auvvlL9+vX1xBNPKCkpSV9++aUefvhh0yXCS9SvX18bNmzQ0KFDZbFY1KlTJyUkJCgxMVEdOnQwXR68gJ+fH7f0GkBfOtwiKCjIdc9+06ZN9csvv0g6c531wIEDJkuDlxk0aJAcDoc2b96spk2bqkuXLtqzZ48qVaqkwYMHmy4PQCkxDwncIj4+Xj/++KOGDh2qWrVq6YUXXlC9evX0+++/Mxka3G7Pnj36/fff1b59e/n5+WnFihUKDQ1V8+bNTZeGCu7Pk/ChbHHJBm7xwgsv6NChQ6pVq5Zuv/12zZo1yzVj6+OPP264OnibBg0aqEGDBpKkvLw81ahRo9gkfEBpMdOvOfSQwK3y8/Pl4+OjrKwsrV69WvXq1XPN4gq4Q1ZWlsaMGaP77rtPzZs317333quDBw+qVq1a+vjjj1WvXj3TJQIoBcaQwK18fHyUlpam1atXq2rVqmrUqJHpkuBl3njjDX3zzTdKTk7WF198od9//10BAQE6fPiwxo8fb7o8AKXEJRtckcmTJ+u7775TvXr19Oyzz+rQoUOKj49Xbm6upDNd6++//75q1apluFJ4i2XLlql69eq6/fbbNWrUKAUHB2vlypW6++67tX79etPlASglAglKberUqa4HUO3evVvJycmyWq3KyclRYGCgcnJytGfPHo0bN04TJ040XC28xYkTJ9SxY0eFhYXp119/VUREhHx8fFS3bl2tXbvWdHkASolAglKbP3++fHx89OKLLyo3N1evvfaaLBaLhg8frscff1yHDx/W3XffzS8JuFVoaKj27dunRYsWKTs7WxERETp69Ki2bt2qGjVqmC4PXmTPnj16+eWXtWXLFuXl5RVbx9Tx7scYEpTa0aNH1bp1a91///16+OGH1apVK0lyPXG1du3aat68ubKyskyWCS/TuXNnHThwQCNHjpTNZlN0dLTGjBmjkydPqmfPnqbLgxd5+eWXtXbtWuXm5srpdBb7U1RUZLo8r0MPCUqtoKBAAQEBrs8hISGSpCpVqriWVa5cWQ6Ho8xrg/d69tlnlZ2drf379+uxxx5TvXr1dN1116lHjx4aOnSo6fLgRbZt26aAgAC98soruummm3g0gYcRSHBFLBbLed8DnlK1alW98847xZY988wzPAoebnfNNdeobt26uv32202XclUgkOCKHDp0SHPnznW9l6R58+a5noR5dhngTgcOHNBHH32kLVu2qFmzZrr99tuVm5urrl27mi4NXiQ+Pl5jxoxRYmKiWrRoYbocr8fEaCi18PDwc3pFnE5nsWVnP5+dtRW4UomJiXrkkUeUk5Mji8Wi7t276/rrr9eMGTM0YcIE3XrrraZLhJd4+OGHtWPHDmVmZsrPz0/+/v6udRaLRT///LPB6rwPPSQotXbt2pkuAVehN998UwUFBRo7dqzGjh0rSWrRooWsVqsSEhIIJHCbdevWud5nZ2crOzvb9ZlL1O5HIEGpzZ4923QJuApt3bpV7dq1U0xMjCuQ3HrrrWrVqpW2bt1qtjh4lVmzZpku4apCIAFQofj6+urIkSP689XmvLw8HTx4sFiXOnClIiIiTJdwVWEeEgAVSrdu3bR//37XU1kTExPVu3dvHT16VFFRUYarg7dJSkpS//791bx5czVv3lyPPfYYY+I8hEGtACqUzMxMPf7449q8eXOx5c2aNdP06dMVGhpqpjB4nR07duiBBx5QTk5OseV+fn767LPPFB4ebqgy70QgAVChZGdny9/fX7/88ouSkpJkt9t10003qUOHDqZLg5cZNGiQVqxYoZiYGN1///2SpLlz52ru3Lm65ZZblJCQYLhC70IggVsVFhZqz549slqtuuGGG2Sz2UyXBC/TvXt33XzzzedMjga4W5s2bVSvXj199dVXxZbfdddd+uOPP7Rx40YzhXkpBrXCbRISEjRjxgxlZmaqe/fu6tChg9auXau33nqLWTThNllZWTp+/LjpMnCV8PX1LdEyXDkGtcItZs6cqQkTJqigoMC1bNeuXfrhhx/09ttvG6wM3mbo0KFKTEzUBx98oM2bN2vPnj3at2+f6w/gLk2bNlViYqKmTZum1NRUpaamKiEhQYmJiWrevLnp8rwOl2zgFrfeeqtycnK0aNEiRUZGqkePHnr55Zf117/+VVarVStXrjRdIrzE+WYIPotHwsOd1q5dq0cffVT/+2vSYrHoww8/ZNySm9FDArc4fPiwGjVqpKpVq7qWhYaGqmHDhjp58qS5wuCV/vdR8DwSHp4QGRmpadOmqUGDBq5z7LrrrtOECRMIIx7AGBK4RZ06dbR582b99ttvks4Mbl21apU2btyoevXqGa4O3mTHjh2mS8BVpHPnzurcubNOnTolq9WqwMBA0yV5LS7ZwC3mzZunMWPGnPdhe6NHj9aDDz5oqDIAKLl9+/YpICBA1atXv+SYpPr165dRVVcHAgnc5rPPPlNCQoKOHj0qSapRo4aeeOIJwgjcqnHjxhdcV6lSJYWFhenWW2/VsGHDuLsLl61x48bq0aOHJk2axHilMsYlG7hFbm6uHnjgAT3wwANKT09XpUqV6NqER4SGhiozM1P5+fnnrMvPz9fhw4f18ccfy2q16rnnnjNQISqys2NF/vz5QtvBveghgVu0a9dOd955p+6//36mU4ZHrVq1SkOGDNGIESPUu3dvSdKXX36pd999V1OmTFG1atX04IMPKiAgQEuXLjVcLYCSIpDALf7ctdmkSRP17dtXd9xxhwICAgxXBm9zxx13KDQ0VLNnzy62/IEHHlBubq4WLFigxx9/XL/88ou2bdtmqEp4q8zMTHp/PYTbfuEW3377rR5//HHVrFlTv/32m1566SV16tRJL7744jkPQQOuxMGDB3Xs2LFiXeZFRUVKT0/Xnj175HA4lJqaKrudK9K4Mg6HQ++88442b96s/Px8xcTEKCIiQvfff7/S0tJMl+d16CGBWzmdTq1Zs0aLFi3SDz/8oNOnTzP4C251//33a+vWrWrdurW6desmp9OppUuX6tdff1Xjxo310EMPadSoUQoPDz/nGSTA5Xj77bf1wQcf6IUXXpCvr69Gjx4t6cyA1r/97W96+eWXDVfoXeghgVudOHFCu3bt0p49e5SVlSWn08n/VOFWzz//vPz8/LRx40a99dZbevvtt7Vp0yZVrlxZo0aN0rFjxyRJsbGxhitFRbd48WIFBQUpMjJSy5YtU0BAgFatWqXatWvr559/Nl2e1+E3Bdziu+++01dffaVVq1bJ4XDI6XSqfv366tu3r+6++27T5cGLtGrVSj/88IM++eQT7d27V4WFhbrxxhv1wAMPqGbNmnI4HJo9e7batWtnulRUcKmpqerQoYNuvPFGbdy4US1btlRYWJgaNGigNWvWmC7P6xBI4BZPP/20JMnHx0c9e/ZUTEwMvxDgMWFhYa5z7n9FRkaWbTHwWkFBQTpy5IjWrl2rU6dOqU2bNsrJydHOnTt1zTXXmC7P6xBI4BbXX3+9+vbtq3vuuUfBwcGmy4GX27Bhg6ZPn64tW7YoIiJCf/3rX3Xs2DEm4YNbtWnTRt9//7369+8vi8Wi7t2765lnntHRo0fVt29f0+V5HQIJ3OK7774zXQKuEitXrtSTTz4ph8Mhi8Uip9OpjRs36uOPP5bNZlNMTIzpEuElRowYoSNHjmj//v0aOHCgGjVqpOrVq6tJkyYX7KFD6XGXDUrt7C1ww4YNu+QvgTlz5pRRVfB29913n/bs2aOJEyfq8ccfV48ePfTII4/oiSeeUM2aNfXtt9+aLhFeLD09XaGhoabL8Er0kKDUNm/erLCwMNf7C7nQsyCA0ti5c6fatWunzp07u5a1a9dOLVq00K+//mqwMniDVatWKSwsTOHh4Vq1atVFt+3UqVMZVXV1IJCg1MaNG6datWq53gNlISgoSPv27VNubq5rWXp6unbu3KmQkBCDlcEbDBw4UNHR0Zo0aZIGDhzIw/XKEIEEpXbPPfec9z3gSb1799ZHH32kHj16yGKxaN26derZs6dOnz7N3CO4YrVr13YF29q1axuu5urCGBK4zbJly7Rnzx7l5eW5pvXOzs7Wxo0bNXfuXMPVwVvk5+drxIgR54wVufXWW/X666/L39/fUGUArgSBBG7x3nvvafLkya7PTqezWFfn9u3bTZQFL/b7778rKSlJdrtdN910k6699lrTJcELZWRk6ODBg2ratKkk6auvvlKnTp1c4+fgPkwdD7dYsGCBKlWqpH79+snpdOqhhx5Shw4d5HQ69Y9//MN0efAS+fn5OnXqlCTp2muv1W233aYePXro2muvVVpamoYOHWq4QniTXbt26bbbbtP06dNdy15++WXdddddSk5ONliZdyKQwC2OHj2qtm3bavTo0bruuuvUuXNnzZgxQ9dff72WLl1qujxUcNnZ2Xr++efVunVrtW/fXj179tT69etd6xcvXqxevXrpp59+MlglvM0bb7yh9PR012XA/Px8RUREKC0tTePHjzdcnfchkMAt/P39dfLkSUlSs2bNtGHDBklSaGiodu7cabAyeIN33nlHCxYsUGFhoZxOpw4cOKC4uDidOnVKr776qp555hmdOnVKNWrUMF0qvMiWLVvUpEkT112EPj4+SkhIUPPmzbnF3AMIJHCLZs2aafv27froo4/Utm1bzZ49W48++qg2bdqkgIAA0+Whglu2bJl8fX01fvx4ffXVV7r33nt16tQpPfvss/rkk0/kdDp16623auHChaZLhRfJz8+XzWY7Z7nD4VBeXp6BirwbgQRuMWLECFWrVk0BAQG64447FBoaql9++UWS9Le//c1wdajoUlNT1aZNG91+++0KDw/X888/L0n6+eefVblyZb3yyiuaOHGiqlatarhSeJPmzZtr27ZtGjNmjH788Ud9++23GjFihLZv367mzZubLs/rcJcN3CY/P1+5ubmuJ2R+++23qlevnnr06GG6NFRw4eHh6tGjR7E7ucLDw1WpUiV9+umnatGihcHq4K02bdqk/v37q6CgwLXM6XSqUqVKmjlzptq2bWuwOu/DxGhwGx8fH/n4+EiSatasqUcffdRwRfB2ERERhBF4TOvWrTV37lx98MEH2rFjh5xOpxo3bqzHHnvMdRsw3IdAglJ7+OGHS7SdxWLRxx9/7OFq4O0OHTp0zgR76enp5yzjsfBwp8aNG+vtt982XcZVgUs2KLXw8PCLrj/7aHiLxcLEaLgi4eHh5zxT5H8n3zuLcw3udODAAX300UfasmWLmjVrpttvv125ubnq2rWr6dK8Dj0kKLVZs2add/mmTZuUkJDgGoXeoUOHsiwLXqhdu3amS8BVKDExUY888ohycnJksVhUu3ZtrV69WjNmzNCECRN06623mi7RqxBIUGoRERHFPmdkZOjNN9/U/PnzVVRUpLCwMI0cOVK9e/c2VCG8xezZs02XgKvQm2++qYKCAo0dO1Zjx46VJLVo0UJWq1UJCQkEEjfjtl+4xVdffaXbbrtNX3zxhZxOp/r27atvv/2WMAKgwtq6davatWunmJgY17Jbb71VrVq10t69ew1W5p3oIcEV2bNnj8aOHasNGzbI6XSqUaNG+n//7/+pZcuWpksDgCvi6+urI0eO6M9DLfPy8nTw4EGeKu0BBBKU2vjx4zVjxgwVFhbKarUqJiZG/fv3l81m0+HDh4ttW7t2bUNVAkDpdOvWTV999ZXuueceSWfGlPTu3VtHjx7V3XffbbY4L8RdNii18935cD4Wi0VJSUllUBEAuE9mZqYef/xxbd68udjyZs2aafr06QoNDTVTmJeihwSlRq8HTHE4HEpJSVHdunUlSWvWrFHr1q1dE/MB7hAYGKg5c+bol19+UVJSkux2u2666SbuHPQQekgAVCgpKSmumTLfeustSWfu+AoNDdWHH36oOnXqGK4Q3qKgoED79+/X6dOn5efnp/r168vX19d0WV6LHhIAFcq//vUv7du3T9dff72kM4MMa9WqpeTkZL399tt65513zBaICi8lJUVvvvmmlixZovz8fNdym82mW2+9VcOHDyf4egA9JAAqlA4dOig0NFRff/21rNYzMxcUFRXprrvuUnp6ulavXm24QlRkBw8eVN++fXXixAld6NdjaGio5s2b57pkCPdgHhIAFUpWVpZCQkJcYUSSrFarqlSposzMTIOVwRtMmDBB6enpioiI0OzZs7VhwwYlJSVpw4YN+uyzz9SjRw+lp6frvffeM12q16GHBECFct999+m3337TP/7xD3Xq1EmFhYVavny5pkyZoqZNm2r+/PmmS0QF1qlTJxUVFWnZsmXnHS+Sn5+vHj16yOl06ueffzZQofeihwRAhTJ48GBJZ+bB6dOnj/r27aupU6dKkp588kmTpcELnDx5Uo0bN77g4FUfHx81btxYJ06cKOPKvB+BBECF0q1bN02dOlU333yzfH195evrq5tvvllTp05Vjx49TJeHCq6wsFCVK1e+6DZ2u10Oh6OMKrp6cJcNgArnlltu0S233GK6DHip9PR0rVq16oLr09LSyrCaqwdjSACUe6tWrVJYWJjCw8Mv+otCOjMGACitksxA7XQ6ZbFYtH379jKq6upAIAFQ7oWHhys6OlqTJk266C8MHlOAK9WtW7cSb7t06VIPVnL14ZINgHKvdu3aCgkJcb0HPIWQYQ49JAAAwDjusgFQoTz//PP69NNPz1n+xhtv6IUXXjBQEQB34JINgHJv9+7drnkfFixYoN9//1033XSTa73D4dDy5ct1+PBhvfrqq6bKBHAFuGQDoNz75ptvNHz4cEn/vcPhfzmdTtWpU0dLliwp6/IAuAE9JADKvV69emn+/PnavXu3jh07Jh8fHwUHB7vWW61WhYSEKC4uzlyRAK4IPSQAKpRu3bqpU6dOevnll02XAsCNCCQAKrzMzEwFBgaaLgPAFeAuGwAVSlFRkd555x1t3rxZ+fn5iomJUUREhO6//36m9AYqMAIJgApl/Pjxev/997Vt2zYtXLhQmzdvltPp1NatW/Xuu++aLg9AKRFIAFQoixcvVlBQkCIjI7Vs2TIFBARo1apVql27tn7++WfT5QEoJQIJgAolNTVVLVu21I033qiNGzeqZcuWCgsLU4MGDbhkA1RgBBIAFUpQUJCOHDmitWvX6tSpU2rTpo1ycnK0c+dOXXPNNabLA1BKBBIAFUqbNm2UnJys/v37y2KxqHv37nrmmWd09OhRRUVFmS4PQCkxMRqACmXEiBE6cuSI9u/fr4EDB6pRo0aqXr26mjRpoqefftp0eQBKiXlIAFR46enpCg0NNV0GgCtADwmAcm/VqlUKCwtTeHi4Vq1addFtO3XqVEZVAXAnekgAlHvh4eGKjo7WpEmTFB4eft6H60mSxWJRUlJSGVcHwB3oIQFQ7tWuXVshISGu9wC8Dz0kAADAOG77BQAAxnHJBkCF0rhx4wuuq1SpksLCwnTrrbdq2LBh8vHxKcPKAFwJekgAVCihoaGqVKmSnE7nOX/y8/N1+PBhffzxx5owYYLpUgFcBgIJgArlX//6lywWi8aMGaN169Zp3bp1GjlypPz8/DRz5kwtWrRIQUFB+u6770yXCuAyMKgVQIVyxx13KDQ0VLNnzy62/IEHHlBubq4WLFigxx9/XL/88ou2bdtmqEoAl4sxJAAqlIMHD6qwsFBOp9M1H0lRUZHS09OVkpIih8Oh1NRU2e38eAMqEv7FAqhQwsPDtXXrVj300EPq1q2bnE6nli5dqt9//12NGzfWwoULtX37doWHh5suFcBlIJAAqFCef/55DRgwQBs3btSmTZskSU6nU35+fho1apQ2bNggSYqNjTVZJoDLxBgSABVOamqqPvnkE+3du1eFhYW68cYb9cADD6hmzZpau3atrFar2rVrZ7pMAJeBQAIAAIzjtl8AFU5SUpL69++v5s2bq3nz5nrssce0fft202UBuAL0kACoUHbs2KEHHnhAOTk5xZb7+fnps88+YzArUEHRQwKgQhk/frxycnIUExOjL7/8Ul9++aX69u2rnJwcZmcFKjB6SABUKG3atFG9evX01VdfFVt+11136Y8//tDGjRvNFAbgitBDAqDC8fX1LdEyABUHgQRAhdK0aVMlJiZq2rRpSk1NVWpqqhISEpSYmKjmzZubLg9AKXHJBkCFsnbtWj366KP63x9dFotFH374oTp06GCoMgBXgh4SABVKZGSkpk2bpgYNGsjpdMrpdOq6667ThAkTCCNABUYPCYAK69SpU7JarQoMDDRdCoArRA8JgAqratWqrjDyj3/8Q/fee6/higCUFg/XA+AV9u3bp+TkZNNlACglekgAAIBxBBIAAGAcgQQAABjHGBIA5d6qVasuuU1WVlYZVALAU7jtF0C5Fx4eLovFctFtnE6nLBaLtm/fXkZVAXAnekgAlHu1a9c2XQIAD6OHBAAAGMegVgAAYByBBAAAGEcgAQAAxhFIAOAiGGYHlA0CCQBJUmxsrBo1aqSYmJgLbvOPf/xDjRo10siRI13LunXrVuzz5fjiiy/UqFEjDRw48LzrJ02apEaNGpWq7dIYOXKkunXr5vq8ZMkSjRgxwvV57dq1atSokdauXVtmNQFXCwIJABer1arNmzcrJSXlnHU5OTlavny5W7/e/PnzddNNN2n16tU6ePCgW9sujcGDB2vy5Mmuzx999NF5vxcA3I9AAsClSZMm8vX11XfffXfOuqVLl8rX11c1atRwy9fat2+fNm3apGeeeUaBgYGaN2+eW9q9Etdee62aNGliugzgqkQgAeDi7++vqKgoffvtt+es++abb3TbbbfJbnfPfIrz589XYGCgOnTooNtuu03z589Xfn7+Jff78MMP1b17d7Vo0UIxMTFaunTpOZdRtm7dqgEDBigyMlKtW7fW3//+d+3atcu1/uyllzlz5qhr1676y1/+olWrVhW7ZBMbG6t169Zp3bp157S/d+9eDRgwQDfffLM6duyot956S4WFha71jRo10meffaaRI0eqTZs2ioiI0CuvvKLc3Fz961//Uvv27RUZGakXXnhBeXl57vh2AhUegQRAMb169dKWLVt0+PBh17LTp09r5cqV6t27t1u+hsPh0MKFC9WrVy/5+Pjo3nvvVVpamn766aeL7jd58mS99dZbuv322zVlyhTdfPPN+sc//lFsmzVr1uiBBx5QUVGRXn31Vb3yyitKSUlRTEyM9uzZU2zb8ePHa8SIERoxYoRatmxZbN1LL72kJk2aqEmTJpo7d66aNm3qWjdu3Di1adNGCQkJuvXWW/X+++9rzpw5xfZ/66235OPjo8mTJ+uuu+7S7NmzdffddyslJUVvvvmmYmJi9MUXX2j27Nml+A4C3oep4wEUc8stt8jf31/fffedHnvsMUnSjz/+qNDQULVp08YtX2PlypU6duyY+vTpI0lq2bKlGjZsqM8++0y9evU67z7Z2dl6//339eCDD+qZZ56RJHXq1Ek5OTmaO3eua7u3335b9erV0wcffCCbzebaLjo6WpMmTdKECRNc28bExOi2224779dr2LChqlSp4qrvzx5++GENHjxYktS+fXstW7ZMa9as0UMPPeTapkGDBnr55ZclSe3atdMXX3yhgoICvfXWW7Lb7ercubOWLl2qTZs2lfTbBng1ekgAFFO5cmV169at2GWbxYsXq1evXpd8wF1JzZ8/X9ddd53q16+vjIwMZWRk6Pbbb9e6devO6cU4a/PmzcrNzT0nQPy51yY7O1tbt25Vr169XGFEkoKCgtS1a9dz7o4p7R08bdu2db23WCyqU6eOMjIyim3TqlUr13u73a6QkBA1a9as2CWv4OBgZWZmlqoGwNvQQwLgHLfffruGDBmiP/74QwEBAfrll1/09NNPu6Xt9PR0LV++XAUFBWrXrt056+fOnatRo0addz9JCg0NLbY8LCzM9T4zM1NOp7PYsj9v97+//K+55ppSHYOfn1+xz1ar9Zz5Ss72rlxsPwD/RSABcI4uXbooMDBQ33//vQIDA1W3bl01a9bMLW0vXLhQBQUFmjx5soKCgoqte++99/TVV19p2LBhqly5crF1NWvWlHQmmNxwww2u5WeDiiQFBgbKYrEoNTX1nK97/PhxBQcHu+UYALgfgQTAOXx8fNS9e3f98MMP8vf31x133OG2tr/88ku1bNlS0dHR56xLT0/X008/rW+//Vb33HNPsXXh4eEKDAzUDz/8UOySyffff+967+/vr2bNmumbb77R4MGDXZdtMjMztXz5crVv3/6yarVarSoqKrqsfQCUDoEEwHn16tVLgwYNktVq1YsvvnjRbXfv3q2PPvronOUtW7YsNiA0MTFRO3fu1AsvvHDedrp3766qVatqzpw55wSSKlWqaODAgZo4caL8/PwUERGhdevW6bPPPpN0JjxI0vDhwzVgwAANHDhQDz30kAoKCjR9+nTl5+crLi7uMr4DZ8ae/Prrr/rll1+YnwTwMAIJgPP6y1/+oqCgINWqVUsNGjS46LZbt27V1q1bz1keFxdXLJDMnz9fNpvtgnfS+Pj46Pbbb9ecOXO0ffv2c9YPGjRIRUVFmjt3rj788EPdfPPNeuaZZzRu3Dj5+/tLkjp06KCZM2dq4sSJGjZsmHx8fNS2bVv961//0o033ngZ3wHpwQcf1LZt2/T4449r3Lhxql69+mXtD6DkLE6eHAWgAigsLNSiRYsUGRmpWrVquZZ/+umneuWVV7R27dpzxqQAqDgIJAAqjDvuuEM+Pj568sknFRISoh07dujdd99VdHS0xo0bZ7o8AFeAQAKgwjh48KDeeecdrV27VhkZGapdu7b++te/atCgQapUqZLp8gBcAQIJAAAwjplaAQCAcQQSAABgHIEEAAAYRyABAADGEUgAAIBxBBIAAGAcgQQAABhHIAEAAMYRSAAAgHH/P2gfRq4Tas6LAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Running Non-Parametric Statistical Significance Analysis...\n", - "INFO: Preparing for Model Feature Importance Plotting...\n", - "INFO: Generating Feature Importance Boxplot and Histograms...\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Generating Composite Feature Importance Plots...\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: hcc_data_custom phase 5 complete\n" - ] - } - ], - "source": [ - "from streamline.runners.stats_runner import StatsRunner\n", - "stats = StatsRunner(output_path, experiment_name, \n", - " algorithms=algorithms, exclude=exclude, \n", - " class_label=class_label, instance_label=instance_label, \n", - " scoring_metric=primary_metric,\n", - " top_features=top_model_fi_features, sig_cutoff=sig_cutoff, \n", - " metric_weight=metric_weight, scale_data=scale_data,\n", - " exclude_plots=exclude_plots,\n", - " show_plots=True)\n", - "stats.run(run_parallel=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "oqfgPhzBL0Xb" - }, - "source": [ - "## Phase 7: Dataset Comparison \n", - "* Optional: Used only if > 1 dataset was analyzed\n", - "\n", - "Assuming STREAMLINE was run on more than 1 dataset. After cell runs, for each evaluation metric you will see:\n", - "* Boxplots (for each metric) showing the distribution of median CV model performance (one data point for each algorithm) within a single sub-boxplot, run for each target dataset\n", - " * Lines between boxplots show how the median ML algorithm performance changed from one dataset to the next\n", - "* Boxplots (for each algorithm and either ROC-AUC or PRC-AUC) showing the distribution of CV model performances within a single sub-boxplot, for each target dataset " - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "id": "Qv7O5jc3LzvG" - }, - "outputs": [], - "source": [ - "# Function to check target data folder for more than one dataset\n", - "def len_datasets(output_path, experiment_name):\n", - " datasets = os.listdir(output_path + '/' + experiment_name)\n", - " remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", - " 'jobsCompleted', 'logs', 'jobs', 'DatasetComparisons', 'UsefulNotebooks',\n", - " experiment_name + '_ML_Pipeline_Report.pdf']\n", - " for text in remove_list:\n", - " if text in datasets:\n", - " datasets.remove(text)\n", - " return len(datasets)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "H_frEMK4KhPI", - "outputId": "c7299a35-e9c7-4ea2-b9dd-2a8d0e451cad", - "scrolled": true - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Running Statistical Significance Comparisons Between Multiple Datasets...\n", - "INFO: Generate Boxplots Comparing Dataset Performance...\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvIAAAKFCAYAAACuvA01AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB4q0lEQVR4nO3dd3hUZcLG4WdKeg+BhJBCCL1IlbKiKCo2REUsrMKqfMoKlrWXVXRdXcvaVsraZWFRERQsa0EQCwIqXSnSEwJJCOk9mZnz/REYiYSWdnKS331duZKcOXPmmcAkT9685z02wzAMAQAAALAUu9kBAAAAAJw8ijwAAABgQRR5AAAAwIIo8gAAAIAFUeQBAAAAC6LIAwAAABZEkQcAAAAsiCIPAAAAWBBFHgAAALAgp9kBmgLDMOTxcIHb5sJut/HvCTRhvEabD7vdJpvNZnYMoMWiyEvyeAzl5BSbHQP1wOm0KyIiSAUFJXK5PGbHAfA7vEabl8jIIDkcFHnALEytAQAAACyIIg8AAABYEEUeAAAAsCCKPAAAAGBBnOwKAAAandvtVmVlpdkxgCbFx8dHDofjhPenyAMAgEZjGIbS09OVl5cng1VIgWpsNik8PFxt27Y9oaVdKfIAAKDRpKenKzc3TyEh4fLz85PE8pVAFUPl5eXKzc2TJMXGxh73HhR5AADQKNxut/Lyqkp8SEiY2XGAJsfX11+SlJeXp+jo6ONOs+FkVwAA0CgqKytlGDo4Eg+gJn5+fjIMndA5JBR5AADQyJhOAxzdib8+KPIAAACABVHkAQAAAAuiyAMAAJykSy+9SIMH99O//z212vbVq1dp8OB+uvnmG0/4WJ988pEGD+6nCRPG13fMam6++UYNHtyv2tvppw/S6NEX6803X5fBeqCW06SK/BdffKEuXbpo3LhxR91n7dq16tKlyxFv//3vfxsxKQAAgDRnzmzt2rWzTseIiYnRGWecqb59+9dTqmPr1KmzzjjjTJ1++jCdckpvZWXt16uvztDrr7/SKI+P+tNklp/Mzs7WI488ctz9Nm3aJEnq3Lmz4uPjvdsP/xgAAKAxuFwuPfPMP/Tvf79e62MMGDBQAwYMrMdUx3bZZWM0evQY7+cLF76vp556QkuWfKkbb/xzo+VA3TWZIj9lyhTl5uYed79DRX7SpEm64IILGjoWAABoBIZhyDA8pjy2zWY/oato1sRut2vt2jX65JOPNHLkqBr32bFju6ZOfUGbNm1UaWmpWrduo4suulgTJtwkqWpqzeOPP6oePXrqjTdm6aqrRislZbcef/wpnXPOCElSSspuXXXVaAUFBeuTT75QQECAFi78QHPmzFJ6+j7FxMTossuu0DXXHH1Ww9GUl1dIktq1a+fdtn9/pl544VmtW7dGhYWFioiI1PDhZ+uWW/6igoICjRp1gdxulz744BPvhYtmzZqpGTNe0rBhZ+npp59TRUWF/v3vafrii89UVFSo5OSOuvHGm/WHP5wmSaqoqNDLL0/XV18tVk5OtoKDQ9S//wDdfvudiopqfdLPoyVqEkV+4cKFWrx4sXr06KGNGzcec9/NmzdLklasWKFFixYpLi5O48aNU5s2bRojKgAAqGeGYWjHji0qKSk25fEDA4OVnNylVmX+sssu1/vvz9O0aS/q9NOHHXF7RUWF/vKXycrKylLnzl0UGhqm9evX6rXXXlanTl10xhlH3mfUqMs0deoL+uyzT7xF/tNPP5YkjRhxvgICAvTBB/P1zDP/UGBgkPr3H6Dt26t+WSgvL9cNN/zfMTMvWDBfK1cul2EYysvL088/r1dMTIxuueUv3n3uvfdObdmyWQkJierSpavWr1+nuXPfUWxsnK66aqz+8IfT9N1332jx4kUaP/46SdLSpYslSRdeOFKS9NhjU7R48SJFR8eoT59+Wr9+ne6++3ZNm/aK+vXrr9dff0Vvvz1bbdpEa8CAgUpJ2a0vv/xC+/bt1RtvzDrpf4uWyPQin5GRoccff1yJiYm6/fbbddNNNx1138rKSm3dulWSNHfuXO/2BQsW6MMPP1SrVq1qncPpbFKnC6CWHA57tfcAmpaSkiL5+dl4jaIG1lxb/uqrr9H69eu0ffs2TZv2L51//oXVbi8rK9OECTeppKRUf/zjtZKkZ599SvPnv6fdu3fVWORHjrxYr7wyXStXrlROTo7Cw8P1+eefSZIuueQySdLMmW9IkqZPf0XdunVXfn6+LrnkAr399iyNG/cn+fj4HDXztm1btW3b1mrbbDa7MjLSlZTUQRUVFRoz5kplZmbq+uv/T3a7XXPmzNLUqS9q9+5dkqSLL77kYJH/QuPHX6d9+/Zp8+ZNCgsL12mnDdWePalavHiRIiIi9e677ysgIEArVnyvO+64VbNmvaV+/forNTVFUtUvQ3/84zi5XC4tWDBfCQnt5Xa7j3tVUzSBIv/Xv/5VxcXFevnll+V2u4+5b0FBgYYNG6bKykrdc889Cg8P16233qq1a9dq6tSpevTRR2uVwW63KSIiqFb3RdMUGhpgdgSgRUpJSVFBQUGNt5WWlqq0tFQ2m00RERHHPE5oaKgSExMbIiKaIJvNpuTkLpacWuNwOHXffQ/qpptu0CeffOidZnJIaGiohg8/V19++YWmTHlQmzdv0p49qZKkioryGo8ZFhauM88crkWLPteiRZ+pQ4eOyszMUOfOXdW1azfl5uZq//5MSdL11197xP13796lTp06HzXzvfc+qNGjx8gwDBUXF+mDD+Zrxoypuv/+e/TBBx+pVasonXPOCC1e/KWeeOJv2rJls3bu3FEt8x/+MFSRka20deuvSk1N0bfffi2p6i8GTqePtm79VZKUm5ujs846rdrjb9z4syTpiiuu1ooV3+uVV2Zo5sw31K1bdw0cOEQ9evSkxJ8gU4v822+/rWXLlum6667TgAED9MMPPxxz/1atWmn69OnVtl133XVau3at1qxZU+scHo+hgoKSWt8fTYfDYVdoaIAKCkrldpvzAwFoqXJzczRs2FB5PEe+9kaMGKHrrrtOkjRr1ix99tlnxzyWw+HQ119/r4iIyIaIinoSGhpQb39dsdlsstmsWd569eqtSy8drQUL3tfMmW9Wuy0zM0N//vP/KScnW2PGXKURI87XypUrNH/+3GMu93jppZdr0aLPtXjxIiUlbT+4bbQkyen8rb6ddtpQORzV69yJ/lJis9kUHByiceOu06xZb6moqEjr16/ToEFDdPPNN2r79q265JLRmjBhovbsSdG//z1NhyI7nU5dcMFFmjNnlr788gt9//13kqSLLhpZLWNwcLD69RtwxON6PB717z9A8+d/pK+/XqLVq1fp5583aN26tXr33TmaM+c9tW7NPPnjMbXIH/pGPnPmTM2cOdO7/ccff1SXLl20ZMkSxcXFebeXlJRo7969kqROnTpJkvz8/CTpuKP5x+NyUfqaE7fbw78p0MhCQsL10UdfqLCw+oi8YbgluSRJxcWl2rVrl158cZqio9se41ihCgkJ53UMy5g06TZ9883XysnJrrZ98eIvlZ6+TwMGnKpbb/2LDMPQe++9e9zj9evXX4mJ7bVx4y/avXuX/P39dd5550uSQkJC1Lp1G2Vl7deYMVdpyJDTlJOTo9dee1lJSR3Uvn37k8qemZmhsrIySVV/Qfjhh5XaunWL4uLidO+9D8hms+mJJx474n4XX3yJ5syZpYUL31dWVpY6dEhW167dJUkdOiRLkgxDuv/+hxQZGak1a1br22+/1imn9JHdbtcrr8zQtm1bNWHCTbriiqtlGIbGjh2j3bt3aePGn3XmmcNP6nm0RKYW+X79+ikkJMT7eW5urtasWaPw8HD1799fAQHVp0esWrVKN954o6Kjo/Xpp58qODhYS5culST17du3UbMDAI4UF1d9KeC8vGzt21c1D7ZVqzYKCXEpMDBQHTt2UlwcU2fQfISEhOj22+/UI4/8tdr2QyvBrFr1k2666Qbl5eV654aXlpYe85iXXDJaL730vIqKijRy5CgFBQV7bxs//jo999wzuvfeO9W7dx/t3LlTOTnZOvPM4bryyquPedxDJ7tKUnl5mTZt2iiXy6XExPbq06efduyo+gtAWlqarrvuGhmG4Z0qU1r62wyG9u2T1KvXKfr55w2SfjvJVZLi4xN01llna+nSJfrjH8coObmjNm78RWVlZYqNbed9/suWfas1a1bplFN6Kzc3V7t371JwcLC6d+95zOeAKqaebXTHHXdoxowZ3re//OUvkqrWiJ8xY4a2bt2qSZMm6Z///KckaciQIerRo4cyMzM1cuRIXXXVVZo7d65CQkI0ceJEE58JAOD38vNzvCU+IqK12rRpV+t5yIAVnHfeBTr11EHVtp155nBdf/3/qVWrKG3b9quCg0P05z9PliStW3fsacEXXTRSvr6+kqpWsjncFVdcrTvvvFexse20fv062e02XXnlWD366OPHzblt21Z9++3X+vbbr7Vq1U+SpGHDztKLL06T0+lUly5ddffd9ysmJka7d++W2+3WX/5yl2w2m37+eX21WRAXXVS15KbD4dB551U/0ffhh/+mK68cKx8fH23YsF5t2kTr7rvv9/6iceutf9GkSbeqdes2Wrt2rfbvz9SQIadp2rSXWY3wBNmMJnQ93h9++EHjx4/XwIEDNXv2bH3wwQd64IEH1Lt3b7333nuSpAMHDui5557Td999p8LCQvXu3Vv333+/unfvXuvHdbs9yskxZ8kr1C+n066IiCDl5hbzJ3nARAUFeUpLq7raZXh4K7VtmyCbzaa0tBRNmfKAHnvsSUbkm4HIyKCTmiNfVlamHTt2KioqRr6+fg2YDI3l0Ao8gwcP0YsvTj/+HXBcFRXlOnAgQ8nJHeTv73/MfU1fteZwgwYN0q+//ur9fPTo0Ro9enS1faKiovTkk082djQAwAkqLMxXWlrVEnVhYZHeEg+g+XjttZe1cePP+uGHlZKkK6/8o8mJWqYmVeQBANZWVFRwcCTeUGhouGJjEynxQDNUWFioNWtWKzo6WmPHXuu9WisaF0UeAFAviouLtGfPThmGoZCQMLVrl0SJB5qpO++8R3feeY/ZMVo8Lq0HAKizkpJi7dmzXYbhUVBQKCUeABoBRR4AUCelpSVKTd0uj8ejwMBgxcd3kN3OjxcAaGh8pwUA1FpZWalSU7fJ43ErICBICQnJlHgAaCR8twUA1Ep5eZlSUrbJ7XbL3z9QCQkdZbc7zI4FAC0GRR4AcNIqKsoPlniX/P0DlJjYUQ4HJR4AGhNFHgBwUg6VeJerUn5+/kpI6CiHg0XQAKCxUeQBACessrJCKSnbVVlZIV9fPyUmdpLT6WN2LKDRXXrpRRo8uJ9WrPi+ST/el19+oR07ttf5OIe7+eYbNXhwv2pvw4YN0WWXjdSzzz6tkpKSWh+7Kfrkk480eHA/TZgw3uwoR2AIBQBwQlyuSqWkbFNlZbl8fHwp8UAjGjRosHJzcxUZ2eqE7/OXv0zWypUrNH36q3U6ztF06tRZbdvGSpJKSkq0YcM6zZ8/VyUlxZoy5bE6H7+piImJ0RlnnKmEhESzoxyBIg8AOC6Xy6WUlG2qqCiX0+mjxMRO8vHxNTsW0GI88MDDJ32fHTt21Mtxjuayy8Zo9Ogx3s8XL16khx66X1988bnuvfdB+fv719tjmWnAgIEaMGCg2TFqxNQaAMAxud0upaZuU3l5mZxOH7Vv30m+vn5mxwIsYfXqVZo8+SYNH366hg8/XXfeeZu2bv212j4//7xeEyaM1xlnDNbVV1+ulSuX68ILz9Xgwf28+/x+Skx6+j799a/36cILz9UZZwzWpZdepOnTX5LL5fLun5W1X5I0efJNeuyxR2o8jiR99903uuGGcTrjjME6//zh+utf71NGRvpJP9dDI9Zut0vl5WWSpIqKCv3rX897c15//bVavrz6tJ4Tef6HpvDMm/euzj9/uC699CIVFxersLBQjz/+qEaMOEvDhv1BN998ozZu/MV7v/z8fP3jH3/XxRefr9NPH6SLLz5PTz/9hIqLi737fP31V7r++mu9/0Y33DBey5Z96729pqk1LpdLs2a9pSuvvEynnz5Il1xyoV566QWVlZV693nssUc0eHA/zZ8/V08//Q+dc84Zuvji8/Xcc894/53qiiIPADgqt9ut1NQdKisrlcPhVGJiR/n6No9RNjQthmGooqLClDfDMBrkOa1cuVy33vpnrV69Su3bJyk2NlbLly/TTTddry1bNkmSsrMP6Pbbb9HGjb+oTZtohYeH67777lJRUeExj/3www9oyZIvFRERof79T1VJSbFmz56pV16ZIalqCo2fX9Uv3Kec0kddunSt8Tjff/+d7r33Tm3atFHdunVXWFi4liz5UrfdNkkuV+UJPU/DMFRYWKh5896VJMXFxSksLFyS9NhjU/TOO/+Vj4+P+vTpp507d+ruu2/XmjWra/X8p059UUlJHdSjR08FBgbqzjtv1SeffKSwsDD16tVLGzas1+TJNyk1NUWS9OyzT+mjjxbIz89Pp546SJK0YMH7evLJv0uSdu3aqb/+9T5t375N3bv3UOfOnbV580bdd9/d1c4t+L3HHntEM2ZM1YEDWerdu4/Ky8v09tuzddttk48o6a+8MkM//rhSiYntlZW1X/PmvasvvvjshL62x8PUGgBAjTwet/bs2aHS0mI5HA4lJnaUn1+A2bHQDBmGoVdfne4tX40tMbG9brxxkmw2W70e96WXXpDH49FNN03SDTf8nyTp6af/oQUL5mvq1Bc1ffqrmj//PZWUFKtXr976979fk9Pp1Pz5c/Xss08f89ipqamSpDvuuFv9+5+qnTt3aNWqn9StW3dJVVNoli//XllZ+zVx4iT17z+gxuPMnPmGDMPQxImTdP31/yeXy6X77rtLgYGByszMVLt2cUfN8Mwz/9Azz/yj2raQkBDv9J09e1K1ePEiRURE6t1331dAQIBWrPhed9xxq2bNekv9+vU/6ef/f/83UePHXy9J+umnH/TzzxvUsWMn/ec/b8vhcOiDD+brmWf+oXfemaP77nvQ+3/qhhtu1IgR5ysnJ1tffrlIHTt2kiSlpe2R2+1W167d9Mgjf1fr1q31xRefye12KyQktMYMmzdv0qJFn8nPz18zZ85RQkKi8vPzdO21V2vDhnVatOhzXXjhSO/+bdpEa+bMOfLx8dEdd9yqFSu+1y+//KyLLrr4qF/bE8WIPADgCB6PR3v27FRJSZHsdrsSEjrJ3z/Q7Fhoxuq7RJstPz9fO3dWzVEfNeoS7/ZLLrlMkrR+/ToZhqFdu3ZKks44Y5iczqrx1REjLjju8a+9tmqaxy23/FnnnXeWXn55uvz8/NS1a7eTyrl161ZJ0pAhf5AkOZ1OPffcv/T3vz95zBIvVZ3seuqpg7y5Bw/+g+bP/1D9+5968NhVU4hyc3N01lmnafDgfrrjjlslSRs3/ixJJ/38+/T5bbrNr79ukSRt375Np512qgYP7uf9xeLQ8f/4x3Gy2+167LEpGjHiTD3xxN9kt9vUs2dPSVXz37t27aaNG3/RxRefpyuvvEzr1q1VbGw7tWnTpsYMa9euOZilj3c6UVhYuM48c3i12w/p27effHyqFgZITu4oqWoZ3/rAiDwAoBrD8CgtbaeKiwtls9mVkNBRAQGUeDQcm82mG2+cpMrKE5vKUd98fHzq/RcJu/3Exkrdbrck6WRn94wff72GDDlN3377tdatW6vVq3/Sd999o08++VCvv/6fk40rl8vt/bisrOyETlQ9dLLrxo2/aPLkm7Ry5XK98cZruvPOeyTJW8yDg4PVr1/1vwjYbDZ5PJ6Tfv7BwcHejw8dPyoqSt2796y2X3h4hCTpvPMuUI8ePfX1119p7drV+vnnn/XDDys1f/57mjNnrgICAvT66zO1fPn3WrlyhTZsWKeFC9/XggXzde+9D1Y7mfcQu/3Y/1d+/3/J3/+3v2Qeylxfs7kYkQcAeBmGobS0XSoqKpDNZlNCQrICA4OPf0egjmw2m3x9fU15a4i/BoSEhHhHaz/66EPv9g8/XCBJ6tOnr2w2mzp0SJZUdcLpobnV//vfR8c8dk5Ojv75zyf12msva+zYazV16r81b95CSdIvv/ysgoICSb/9MuHxuI92KHXqVDXF5Pvvvzu4r0c33nidzj13mH766YcTeq49evTUnXfeK0l67713vPO/Dz03w5Duv/8hPfPM87r66msUG9tO5513oex2+0k//8N/QerQoWp029fXT4899oSeeeZ5nX/+RUpISNTZZ5+riooKvfjis3r++X9qxIjz9dxzL+mTT75QUFCw9u5NU0pKipYvX6a///1R7dixXffe+4D++9+5uvnmWyTpqGvt9+hR9UvDunXrvFN38vPz9PXXX0mS+vbtW23/hvxrEyPyAABJVSV+797dKizMl81mU3x8soKCQsyOBTRpzz77tAIDq//FKiEhUU888bT+/Odb9Ne/3qtXX52hZcu+VUVFubZv3yZ/f3/dcsvtkqTRo8do7ty39fPP6zV27BiFh0do27Zfa3oor4iICG3c+Iu2bNmsq6++XMnJHbV79y5JUrdu3RUaWjW3Ozw8XJmZGXr22ad12mmn67bb7jjiWH/60w2655479NZbr2vVqp9UXFyknTt3KC4uXr169T7hr8OoUZdqxYrvtXTpEj333NMaMOBUxccn6KyzztbSpUv0xz+OUXJyR23c+IvKysoUG9uu1s//kFNPHahu3bpr8+ZNuvLK0WrXrp1+/nmD3G63Tjmlj3x9fZWenq7ly5dp/Pix6tath9LT96m4uEjR0TFKTGwvt9utr75arMrKSn333bcKDg7W+vXrJFWdMFyTXr166/TTh+m7777Rddddo+7de2rHjm3Kzc3VKaf00bnnnn/CX7e6YkQeACDDMLRvX4oKCnIl2RQX10HBwTWf6AXgN3v3pmnbtq3V3g6N0g4ffrb+9a8Z6t9/gHbv3ql9+/ZqyJDT9Oqrb6lr16qTUqOjY/Tii9PUuXNXZWSkq7S0RE8//bwkeedV/57NZtOLL07TZZddLklatepHud1uXXzxpXr22Re9+02YMFExMW2VkZGu/Py8Go91+unD9NRTz6pLl67asmWTcnNzdPbZ5+qll2ac9Drw99//kFq3bqOCggI988yTkqSHH/6brrxyrHx8fLRhw3q1aROtu+++X1deeXWtn//hX4fnnntJF154sSoqyrVp00YlJXXQ448/pTPOGCZJ+tvfntC11/5JQUHBWr36JxUWFurss8/VtGkvy9/fX92799CLL07XgAGnKi0tVT//vF5xcXG6++77NWbMVUd97H/84xlNnDhJUVGttX79WjmdPvrjH8fpX/+a7p0+0xhsRkOtuWQhbrdHOTnFx98RTZ7TaVdERJByc4vlcnnMjgNYgmEYysjYo9zcA5KkuLgkhYZGNMhjpaWlaMqUB/TYY08qLq7pXSURJycyMkgOx4mPCZaVlWnHjp2KiorhWgQHrV79kzZsWK+oqChdcMFFcjp9tGvXTo0dO0YxMTFauPBTsyM2qJb+/GtSUVGuAwcylJzc4bi/TDG1BgBaMMMwlJmZ5i3x7dq1b7ASD+BINpvdu/b7vHlzFRnZSps2VV3QaNiws8yM1iha+vOvK6bWAEALZRiG9u/fp5ycLElSbGyiwsIiTU4FtCz9+vXXgw9OUceOnZSSsls//fSjAgICNXbstZo06Taz4zW4lv7864oReQBooQ4cyFB2dqYkKSYmXuHhrUxOBLRMo0ZdqlGjLjU7hmla+vOvC0bkAaAFOnAgQ1lZ6ZKk6Og4RUa2NjkRAOBkUeQBoIXJzt6v/fv3SZLatIlVq1Y1X70QANC0UeQBoAXJyclSZmaaJCkqKkZRUTEmJwIA1BZFHgBaiLy8bGVk7JEktWoVrdat25qcCABQFxR5AGgB8vNztG9f1UVqIiNbq02b2Aa9bDgAoOFR5AGgmSsoyNXevbslSeHhUYqOjqPEA0AzQJEHgGassDBfaWm7JUlhYZFq2zaeEg8AzQTryANAM1VUVKC0tJ2SDIWGRig2NpESD9STSy+9SBkZ6d7PHQ6nwsPD1b//AE2cOEnt2sU1yOO98MJUDRly2gndZ/DgfpKkd999X+3bJ9VrnsN98slHevzxR4+5z0MPPaqRI0c1WIaWiiIPAM1QcXGh9uzZIcMwFBISpnbt2lPigQbQq9cpCg+PUFlZmbZt+1WLFn2uH39cqbfe+q/ato2tt8cZNGiwcnNzFRl54hduO+OMMyVJgYFB9ZajJjExMd7HKisr048/rpQkDR16hux2u3cf1D+KPAA0MyUlRd4SHxwcqnbtkijxQAO54YYbvSPkZWWluuuu27V69SpNm/YvPfHE0/X2OA888PBJ3+eZZ56vt8c/lgEDBmrAgIGSpH379mn06JGSpCeeeFp+fn6NkqGlosgDQDNSWlqi1NQd8ng8CgoKUVxcB++IGNC0GZJKTHrsQEl1/2XX3z9AEyZM1OrVq/Tdd9+ooqJCvr6+Kiws1L/+9Zy+/fYblZeXq3v3HrrlltvVo0dP7303bFivl1+ero0bf5Gvr4969OilW2/9i5KTO0o6cmpNevo+TZv2L61du0ZFRYWKjGylc889TxMnTpLTWVXvappas3r1Kr355qvavHmzJKlPn776858nq3PnLt7bJ0++SX379tell47Wa6+9rJycHHXr1k13332/kpI61Oprc6jgx8S01Xnnna8PPpiv2Nh2mjlzjvbvz9SLLz6nH35YKclQ3779dfvtdyohIdF7/4ULP9CcObOUnr5PMTExuuyyK3TNNeNqlaU5ocgDQDNRVlai1NRt8njcCgwMVnw8JR5WYSgk5Fw5nStNeXSXa4gKCxepPsp8586dJUkVFRVKTU1RcnJH3Xnnrfr55w2Kj09QdHS01q5dq8mTb9KsWe8oISFRv/66RbfcMlEVFRXq1q273G6PVq5cri1bNmnu3AUKCws74nEefvgB/fLLz0pO7qguXbpq48afNXv2TEnS5Mm31Zht5crluvPO2+TxeNS9e09VVJRr+fJlWrNmlV5++XV17drdu++2bb/qqaceV48evZSTk63Vq1fpn/98SjNmvFqnr09mZobmzn1H3br1UOfOnVVWVqZJk27S3r1p6tSpswIDA7V8+TJt3rxJ77wzT2Fh4frgg/l65pl/KDAwSP37D9D27ds1deoLKi8v1w03/F+d8lgdRR4AmoHy8lKlpGyX2+1WQECg4uOTZbc7zI4FnITmMf0rICDQ+3FxcbFWrfpRP/+8QR07dtJ//vO2HA6Ht5i+884c3Xffg5ozZ5YqKio0atRlevDBqik0jz32iEpLS7Rv394ai3xqaqok6Y477lb//qdq584dWrXqJ3Xr1v2IfQ956aUX5PF4dNNNk7wF+Omn/6EFC+Zr6tQXNX36byW9qKhIr732lnr16q3FixfpoYfu18aNP9f562MYhv7610d07rnnSZI++mih9u5N02mnDdVzz70kSZo+/SXNnj1TH364UOPHX6eZM984uP0VdevWXfn5+brkkgv09tuzNG7cn+Tj41PnXFZFkQcAi6uoKDtY4l3y9w9QQkJHORyUeFiJ7eCIuLWn1khV8+QPCQgI0M8/r5ckbd++Taeddmq1fQ8V461bf5UkDR78B+9tU6b87ZiPc+214zVjxlTdcsufFRoaqt69++q0005X167datw/Pz9fO3fukCSNGnWJd/sll1ymBQvma/36dTIMo1r2Xr16S5J3ek95efkxM52oPn36eT/+9deqKT7ff7/MOxXokI0bf1Zubq7278+UJF1//bVHHGv37l3q1KlzveSyIoo8AFhYRUW5UlK2y+WqlJ+fvxISOsnh4Fs7rMgmqWFXV2kMO3ZUlWWHw6mEhAStWbNKkhQVFaXu3XtW2zc8PEKSvAXa7XZ5bysvLz/miaLjx1+vIUNO07fffq1169Zq9eqf9N133+iTTz7U66//54j9T3aanb9/gPfjQ3Pu60twcPARx46Li1OHDh2r7de+fVK1xz7ttKFHfH9r6Sfy890eACyqsrJCKSnbVFlZIV9fPyUmdqr3H7gATlxFRYXmzJklSTrzzLPk7x/gLae+vn567LEn5O8foK++WqJNm37RqacOkiR17txFKSm79f3333mnnDz44L1au3a17rrrPl100cXVHicnJ0dvvPGKsrKy9Oijj2vChJuUnX1AF100Qr/88rMKCgoUGhpa7T4hISFKSEhUamqKPvroQ+/Umg8/XCCp6qTXw0txQxbkw3+pOPT1iYhopSef/KccDocWLJiv/fv3a+jQMxQSEqLWrdsoK2u/xoy5SkOGnKacnBy99trLSkrqoPbt2zdYTivgOz4AWJDLVekt8T4+vgdLfMudJwqY5c03X9OCBe/L5XJp27ZflZWVpbCwcO8Jp6eeOlDdunXX5s2bdOWVo9WuXTv9/PMGud1unXJKH0nSNdeM09dff6XPP/9UO3fulNPp0KZNGxUeHq5BgwYf8ZgRERHauPEXbdmyWVdffbmSkztq9+5dkqRu3bofUeIP+fOfb9Ff/3qvXn11hpYt+1YVFeXavn2b/P39dcsttzfMF+g4zjvvAr355mv6+ef1uvrqyxUeHqFfftkgp9OpYcPOlCSNH3+dnnvuGd17753q3buPdu7cqZycbJ155nBdeeXVpuRuKljOAAAsxuVyKSVlmyoqyr0l3sfH1+xYQIv0888b9O23X+uHH1bI4zF0wQUX6c03Zyk2tp2kqpHt5557SRdeeLEqKsq1adNGJSV10OOPP6UzzhgmSeratbteemmG+vTpq5SUXUpL26MhQ07T1KkvKyqq9RGPabPZ9OKL03TZZZdLklat+lFut1sXX3ypnn32xaNmHT78bP3rXzPUv/8A7d69U/v27dWQIafp1VffqrZiTWPy9/fX9Omv6MwzhysvL1fbtv2qnj176YUXpnozXXHF1brzznsVG9tO69evk91u05VXjtWjjz5uSuamxGYcfmZDC+V2e5STU2x2DNQDp9OuiIgg5eYWy+XymB0HqHdud1WJLysrldPpo/btO8vX1zoXXElLS9GUKQ/osceeVFxc4vHvgCYtMjJIDseJjwmWlZVpx46dioqKsdT/W6AxVVSU68CBDCUnd5C/v/8x92VEHgAswu12KyVlu8rKSuVwOJWY2IkyBAAtGEUeACzA43ErNXW7yspK5HA4lJjYSX5+xx6pAQA0bxR5AGjiPB6PUlN3qrS0WHa7QwkJnaotDQcAaJko8gDQhHk8Hu3Zs1MlJYWy2+1KSOhY7cqRAICWiyIPAE2UYRjau3eXiosLZLPZFR/fUYGB1r9gDgCgflDkAaAJOlTiCwvzZbPZFB/fQUFBwce/I2AJLX7BPOAYTvz1QZEHgCbGMAzt25eigoI8STbFxXVQcHDNF3gBrMTHx0c2m1ReXm52FKDJKi8vl81W9Xo5Hq7sCgBNiGEYSk9PVX5+jiQpLi5JISFhJqcC6ofD4VB4eLhyc/MkSX5+fpJspmYCmg5D5eXlKizMU0REuBwOx3HvQZEHgCbCMAxlZqYpLy9bktSuXXuFhoabGwqoZ23btpUk5eXlqbDQ5DBAE2OzSRER4d7XyfFQ5AGgCTAMQ/v371VOTpYkKTY2UWFhkSanAuqfzWZTbGysoqOjVVlZaXYcoEnx8fE5oZH4QyjyANAEZGWlKzt7vySpbdsEhYe3MjkR0LAcDsdJFRYAR+JkVwAwWVZWhg4cyJAkRUfHKSIiyuREAAAroMgDgImyszOVlbVPktSmTaxatWpjciIAgFVQ5AHAJDk5WcrM3CtJat26raKiYkxOBACwEoo8AJggN/eAMjL2SJJatYqmxAMAThpFHgAaWX5+jtLTUyVJkZFt1KZNrGw21tIGAJwcijwANKKCglzt3btbkhQREaXo6HaUeABArVDkAaCRFBbmKS1tlyQpPLyVYmLiKfEAgFqjyANAIygqKvCW+NDQCLVtm0CJBwDUCUUeABpYcXGh9uzZIcMwFBISrnbt2lPiAQB1RpEHgAZUUlKk1NSqEh8cHKq4OEo8AKB+UOQBoIGUlhYrNXW7DMOjoKAQxcV1kM3Gt10AQP3gJwoANICyshKlpGyXx+NRYGCw4uOTZbfzLRcAUH/4qQIA9ay8vPRgiXcrICCIEg8AaBD8ZAGAelReXqaUlG1yu13y9w9UQkKyHA6H2bEAAM1QkyryX3zxhbp06aJx48YddZ+ioiI98MADOvXUU9W3b1/deuut2r9/fyOmBICaVVSUKyVlm1wul/z8/JWQ0FEOh9PsWACAZqrJ/ITJzs7WI488ctz9HnroIX322Wdq27at/Pz8tGjRImVkZOi9995jJQgApqmsrDhY4ivl6+unxMROcjqbzLdYAEAz1GRG5KdMmaLc3Nxj7pORkaHPP/9cgYGB+vjjj/XJJ58oLi5OGzZs0Jo1axopKQBUV1lZqZSUbaqsrDisxPuYHQsA0Mw1iSK/cOFCLV68WD169DjmfmvWrJFhGOrRo4dCQkLk4+OjgQMHem8DgMbmclUqNXWbKirK5ePjq8TETvLx8TU7FgCgBTC9yGdkZOjxxx9XYmKibr/99mPum56eLkmKiIjwbjv0cUZGRsOFBIAauN0upaRsV3l5mZxOH0o8AKBRmT6B869//auKi4v18ssvy+12H3PfsrIySao279THx6fabbXldJr+Ow3qgcNhr/YeaChut0upqdtVXl4qp9Op5OQu8vPzNztWk2e327zv+b4LAHVjapF/++23tWzZMl133XUaMGCAfvjhh2Pu7+fnJ0nVCn9lZaUkKSAgoNY57HabIiKCan1/ND2hobX//wAcj9vt1oYNG1RaWiIfHx/17t1bQUF8DzkR2dlV38eDgvz4vgsAdWRqkf/ss88kSTNnztTMmTO923/88Ud16dJFS5YsUVxcnHd7dHS0JCkvL8+77dAJsjExMbXO4fEYKigoqfX90XQ4HHaFhgaooKBUbrfH7Dhohjwet3bt2q7i4kI5HA61b99JFRVSRUWx2dEsobi43Ps+N5evmdWFhgbwF1DARKYW+X79+ikkJMT7eW5urtasWaPw8HD179//iFH2Pn36SJI2btyooqIi+fv7a9WqVZKk/v371ymLy0Xpa07cbg//pqh3Ho9He/bsUHFxoex2uxISOsrHx5//ayfB4zG87/m6AUDdmFrk77jjjmqf//DDDxo/frw6d+6sGTNmaMWKFZo9e7aSkpJ0zz33KD4+Xuecc44WL16sUaNGyc/PT6mpqerbt6+35ANAQzAMj9LSdqm4uFA2W1WJDwhgaggAwDxN+u9h6enpWrJkiX766SfvtmeeeUZXXnmlCgsLlZ6erhEjRmjatGlcDApAgzEMQ2lpu1VUlC+bzaaEhGQFBgabHQsA0MLZDMMwzA5hNrfbo5wc5mo2B06nXRERQcrNLebP9qgXhmFo377dys/Plc1mU3x8BwUHh5kdy7LS0lI0ZcoDeuyxJxUXl2h2HNRRZGQQc+QBE/HqA4CjMAxD6empys+vOqk+Li6JEg8AaDIo8gBQA8MwlJGxR3l52ZKqSnxISLi5oQAAOAxFHgB+xzAMZWbuVW7uAUlSbGyiQkMjjnMvAAAaF0UeAH4nKytdOTn7JUlt2yYoPLyVyYkAADgSRR4ADpOVla4DBzIkSTEx8YqIiDI5EQAANaPIA8BB2dmZyspKlyRFR7dTZGRrkxMBAHB0FHkAkJSTk6XMzL2SpNat26pVq2iTEwEAcGwUeQAtXm7uAWVk7JEkRUXFqHXrtiYnAgDg+CjyAFq0vLxspaenSpIiI9tQ4gEAlkGRB9BiFRTkat++FElSRESUoqPbyWazmZwKAIATQ5EH0CIVFuYpLW2XJCk8vJViYuIp8QAAS6HIA2hxioryvSU+LCxCbdsmUOIBAJZDkQfQohQXF2rPnp0yDEMhIeGKjW1PiQcAWBJFHkCLUVJSpNTUHTIMQ8HBYYqLo8QDAKyLIg+gRSgtLVZq6nYZhkdBQaGKi0uSzca3QACAdfFTDECzV1ZWopSU7fJ4PAoMDFZ8fAfZ7Xz7AwBYGz/JADRrZWWlSknZJo/HrYCAICUkJFPiAQDNAj/NADRb5eVlSknZJrfbLX//QCUkdJTd7jA7FgAA9YIiD6BZqqgoP1jiXfLzC1BiYkc5HJR4AEDzQZEH0OxUVlYoJWWbXK5K+fn5HyzxTrNjAQBQryjyAJqVQyW+srJCvr5+SkjoJKfTx+xYAADUO4o8gGbD5apUSso2VVSUy8fHV4mJneTjQ4kHADRPFHkAzYLL5fKWeKfT52CJ9zU7FgAADYYiD8Dy3G6XUlO3q7y8TE6nU4mJneTr62d2LAAAGhRFHoClud1upabuUFlZiRyOqhLv5+dvdiwAABocRR6AZXk8Hu3Zs0OlpcWy2x1KTOwoP78As2MBANAoKPIALOlQiS8pKZLdbldiYkf5+weaHQsAgEZDkQdgOYbhUVraThUXF8pmsyshoaMCAoLMjgUAQKOiyAOwFMMwlJa2W0VFBbLZbEpISFZgYLDZsQAAaHQUeQCWYRiG9u7drcLCPNlsNsXHJysoKMTsWAAAmIIiD8ASDMNQenqqCgpyJUlxcUkKDg41ORUAAOahyANo8gzDUEbGHuXlZUuqKvEhIeHmhgIAwGQUeQBNmmEYyszcq9zcA5Kkdu3aKzQ0wuRUAACYjyIPoMkyDEP79+9TTs5+SVLbtgkKC4s0ORUAAE0DRR5Ak3XgQIayszMlSTEx8YqIiDI5EQAATQdFHkCTdOBAhrKy0iVJ0dHtFBnZ2uREAAA0LRR5AE1OdvZ+7d+/T5LUunWsWrWKNjkRAABND0UeQJOSm3tAmZlpkqSoqBi1bh1jciIAAJomijyAJiMvL1vp6amSpFat2qh167YmJwIAoOmiyANoEvLzc7RvX4okKSKitdq0aSebzWZyKgAAmi6KPADTFRTkae/e3ZKk8PBWiomJo8QDAHAcFHkApioszFda2i5JUlhYpNq2TaDEAwBwAijyAExTVFSgtLSdkgyFhoYrNjaREg8AwAmiyAMwRXFxkfbs2SnDMBQSEqZ27ZIo8QAAnASKPIBGV1JSrD17tsswPAoKCqXEAwBQCxR5AI2qtLREqanb5fF4FBgYovj4DrLb+VYEAMDJ4qcngEZTVlaq1NRt8njcCggIUkICJR4AgNriJyiARlFeXqaUlG1yu93y9w9UQkJH2e0Os2MBAGBZFHkADa6iovxgiXfJ3z9AiYkd5XBQ4gEAqAuKPIAGdajEu1yV8vPzV0JCJzkcTrNjAQBgeRR5AA2msrJCKSnbVVlZIV9fPyUmdpLTSYkHAKA+UOQBNAiXq1IpKdtUWVkuHx/fgyXex+xYAAA0GxR5APXO5XIpJWWbKirK5XT6KDGxk3x8fM2OBQBAs0KRB1Cv3G6XUlO3qby8TE6nj9q37yRfXz+zYwEA0OxQ5AHUG7fbrdTU7SorK5XD4VRiYkf5+vqbHQsAgGaJIg+gXng8bu3Zs0OlpSVyOBxKTOwoP78As2MBANBsUeQB1JnH49GePTtVUlIku92hhIRO8vcPNDsWAADNGkUeQJ14PB6lpe1UcXGh7Ha7EhKSFRBAiQcAoKFR5AHUmmEY2rt3l4qKCmSz2RQfn6zAwGCzYwEA0CJQ5AHUSlWJ363CwnxviQ8KCjE7FgAALQZFHsBJMwxD+/alqKAgV5JNcXEdFBwcanYsAABaFIo8gJNiGIbS0/coPz9HkhQX114hIWEmpwIAoOWhyAM4YYZhKDMzTXl5ByRJ7dq1V2hohMmpAABomSjyAE6IYRjav3+fcnKyJEmxsYkKC4s0ORUAAC0XRR7ACcnKSld2dqYkqW3beIWHtzI5EQAALRtFHsBxHTiQoQMHMiRJ0dFxiohobXIiAABAkQdwTNnZ+7V//z5JUps2sWrVqo3JiQAAgESRB3AMOTlZysxMkyRFRcUoKirG5EQAAOAQ04t8dna27r77bg0cOFADBw7UxIkTlZKSctT9165dqy5duhzx9t///rcRUwPNX15etjIy9kiSWrWKVuvWbU1OBAAADuc0O8DkyZO1du1aJSUlyd/fX19//bU2btyo//3vfwoLO3Jt6k2bNkmSOnfurPj4eO/2wz8GUDf5+Tnat6/qF+rIyNZq0yZWNpvN5FQAAOBwphb5tLQ0bd++XQkJCfr444/ldDp1/vnna/fu3Vq+fLkuuOCCI+5zqMhPmjSpxtsB1E1BQa727t0tSYqIiFJ0dBwlHgCAJsjUIh8XF6dVq1apsLBQPj4+KikpUXFxsSQpPDy8xvts3rxZkrRixQotWrRIcXFxGjdunNq04QQ8oK4KC/OVlrZbkhQWFqmYmHhKPAAATZTpU2skKSQkRPPmzdPUqVOVlZWlyy+/XIMHDz5iv8rKSm3dulWSNHfuXO/2BQsW6MMPP1SrVrVf19rpNP10AdQDh8Ne7T1OXFWJ3ynJUFhYpBISkijxqHd2u837nu+7AFA3TaLIS9LKlSuVmZkpp9MpHx8flZWVKSAgoNo+BQUFGjZsmCorK3XPPfcoPDxct956q9auXaupU6fq0UcfrdVj2+02RUQE1cOzQFMRGhpw/J3glZeXp5SUHTIMQ1FRUerWrZvsdkoW6l92tp8kKSjIj++7AFBHTabIP/LII5oyZYruu+8+vfvuu3I4HJoyZUq1fVq1aqXp06dX23bddddp7dq1WrNmTa0f2+MxVFBQUuv7o+lwOOwKDQ1QQUGp3G6P2XEsobi4SLt2bZXH41FISJhiYhKUn19qdiw0U8XF5d73ubnFJqdBXYWGBvAXUMBEphf5oqIilZaWqnXrqitFjhkzRkuXLtUPP/xwxL4lJSXau3evJKlTp06SJD+/qtEdt9tdpxwuF6WvOXG7PfybnoDS0hKlpFSV+KCgELVrlySPR/J4+NqhYXg8hvc9r1EAqBtTf41etmyZ+vfvrz/96U+qrKyUJG3YsEGSvMX+cKtWrdLIkSM1YcIEFRUVSZKWLl0qSerbt28jpQaah7KyEqWmbpPH41FgYLDi4zswnQYAAAsxdUR+4MCB6tq1q7Zs2aILL7xQUVFRWrNmjZxOp26++WatWLFCs2fPVlJSku655x4NGTJEPXr00MaNGzVy5EhFR0dr3bp1CgkJ0cSJE818KoCllJeXKiVlu9xutwICghQfnyy73WF2LAAAcBJMHX7z9fXV66+/rtGjR6u0tFRbt27VwIEDNWfOHA0aNEjp6elasmSJfvrpJ0mSj4+PXn31VY0ePVoul0tbtmzRoEGDNGvWLC4IBZygioqygyXeJX//ACUkJMvhoMQDAGA1NsMwDLNDmM3t9ignh5OumgOn066IiCDl5hYz/7YGFRXl2r17q1yuSvn5+SsxsbOcTtNPlUELkpaWoilTHtBjjz2puLhEs+OgjiIjgzjZFTARP8GBFqKyskIpKdvkclXK19dPiYmdKPE4KZmZ6SorK6vzMSRp3769dVpZyt/fX9HRbeuUBQCsjhF5MSLfnDAiXzOXq1K7d29VRUW5fHz81L59J/n4+JodCxaSmZmuBx64y+wY1Tz55HOUeZMxIg+Yi+E4oJlzuVxKSdl2sMT7KjGxIyUeJ+3QSPyNN05SbGy7Wh/H4bDLZnPJMJy1HpHft2+vXnttRp3/OgAAVkeRB5oxt9ul1NRtKi8vk9Ppo8TETvL19TM7FiwsNradEhOTan1//moGAPWHv4cBzZTb7VZKynaVlZXK4XBS4gEAaGYo8kAz5PG4lZq6XWVlJXI4HEpM7CQ/P3+zYwEAgHpEkQeaGY/Ho9TUHSotLZbd7lBCQif5+weYHQsAANQzijzQjHg8Hu3Zs1MlJUWy2+1KSOiogIBAs2MBAIAGQJEHmgnDMLR37y4VFxfIZrMrPr6jAgODzI4FAAAaCEUeaAYOlfjCwnzZbDbFx3dQUFCw2bEAAEADosgDFmcYhvbtS1FBQZ4km+LiOig4ONTsWAAAoIFR5AELMwxD6empys/PkSTFxSUpJCTM5FQAAKAxUOQBizIMQxkZacrLy5YktWvXXqGh4eaGAgAAjYYiD1iQYRjav3+vcnOzJEmxsYkKC4s0ORUAAGhMFHnAgrKy0pWdvV+S1LZtgsLDW5mcCAAANDaKPGAxWVkZOnAgQ5IUExOniIgokxMBAAAzUOQBC8nOzlRW1j5JUps27RQZ2cbkRAAAwCwUecAicnKylJm5V5LUunVbRUVFm5wIAACYiSIPWEBu7gFlZOyRJLVqFa2oqBiTEwEAALNR5IEmLj8/R+npqZKkyMg2atMmVjabzeRUAADAbBR5oAkrKMjV3r27JUkREVGKjm5HiQcAAJIo8kCTVViYp7S0XZKk8PBWiomJp8QDAAAvijzQBBUVFXhLfGhohNq2TaDEAwCAaijyQBNTXFyoPXt2yDAMhYSEq1279pR4AABwBIo80ISUlBQpNbWqxAcHhyoujhIPAABqRpEHmojS0mKlpm6XYXgUFBSiuLgOstl4iQIAgJrREoAmoKysRCkp2+XxeBQYGKz4+GTZ7bw8AQDA0dEUAJOVl5ceLPFuBQQEUeIBAMAJoS0AJiovL1NKyja53S75+wcqIaGjHA6H2bEAAIAFUOQBk1RUlCslZZtcLpf8/AIo8QAA4KRQ5AETVFZWHCzxlfL19VdiYkc5nU6zYwEAAAuhyAONrLKyUikp21RZWSFfX7+DJd7H7FgAAMBiKPJAI3K5KpWauk0VFeXy8fFVYmIn+fj4mh0LAABYUK2LvNvtVrdu3bRx48b6zAM0W263Sykp21VeXian04cSDwAA6qROI/KGYdRXDqBZc7vdB0t8qRwOpxITO8nX18/sWAAAwMLqPLWGy8cDx+bxuJWaul1lZSXeEu/n5292LAAAYHEnvUzG+PHjJf02Gv/www8rKCjIe/usWbPqKRpgfR6PR6mpO1RaWiy73aHExI7y9w8wOxYAAGgGTrrIt2vXTlJVkf/pp5/UunVrRURE1HswwOo8Ho/27NmhkpIi2e32gyU+0OxYAACgmTjpIv/kk09KklwulxYuXKhbb71VPXr0qPdggJUZhkdpabtUXFwom82uhISOCggIOv4dAQAATlCt58gzNx6omWEYSkvbraKifNlsNiUkJCswMNjsWAAAoJmpU5GPjY2Vry/L5wGHGIahvXt3q7AwTzabTfHxHRQUFGJ2LAAA0AzV+prwdrtdX331VX1mASzNMAylp6eqoCBXkhQXl6Tg4DCTUwEAgOaq3q/sunfvXt1yyy31fVigSTMMQxkZe5SXly2pqsSHhISbGwoAADRrJzwi73a79dJLL2n+/PmSpEsvvVR33nmnHA6HJKmiokKvvvqqXn/9dZWXlzdMWqAJMgxDmZl7lZt7QJIUG5uo0FBWcgIAAA3rhEfkZ8yYoVdeeUXx8fHq1q2b3nzzTb322muSpFWrVmnkyJGaNm2aoqOj9fLLLzdYYKCpycpKV07OfklS27YJCg9vZXIiAADQEpzwiPxnn32miy++WP/85z8lSW+99ZZmz56tTp066fbbb5ePj4/uuusuXXfddfLx8WmwwEBTkpWVrgMHMiRJMTHxioiIMjkRAABoKU54RD49PV0jR470fj5y5Ejt27dP999/vwYOHKjPPvtMN954IyUeLcaBA5nKykqXJEVHt1NkZGuTEwEAgJbkhEfkS0tLq13BNTw8XJI0aNAgTZ06lXXl0aLk5OzX/v17JUmtW7dVq1bRJicCAAAtTa1XrbHbq+46fvx4SjxalNzcA8rISJMkRUXFqHXrtiYnAgAALVGdl58MCuKy82g58vKylZ6eKkmKjGxDiQcAAKapc5FnNB4tRUFBrvbtS5EkRUS0VnR0O/7/AwAA05zUlV2vuuqqI7ZdfvnlNe67efPm2iUCmqDCwjylpe2SJIWHt1JMTBwlHgAAmOqEizxXa0VLVVSU7y3xYWERats2gRIPAABMV+9F/vvvv9cnn3xS60BAU1JcXKg9e3bKMAyFhIQrNrY9JR4AADQJdZ4j/3vbt2/XwoUL6/uwQKMrKSlSauoOGYah4OAwxcUlUeIBAECTUe9FHmgOSkuLlZq6XYbhUVBQKCUeAAA0ORR54HdKS0uUkrJdHo9HgYHBio/v4L1uAgAAQFNBOwEOU1ZWqtTUbfJ43AoICFJCQjIlHgAANEk0FOCg8vIypaRsk9vtlr9/oBISOspud5gdCwAAoEYnvGrN+PHjT2i/jIyMWocBzFJRUX6wxLvk5xegxMSOcjgo8QAAoOk64SJvGMYJ7RcdHa3o6OhaBwIaW2VlhVJStsnlqpSfn//BEn9S10oDAABodCfcVmbPnt2QOQBTHCrxlZUV8vX1U2JiJzmdPmbHAgAAOC7myKPFcrkqlZKyTRUV5fLx8aXEAwAAS6HIo0VyuVzeEu90+igxsZN8fHzNjgUAAHDCKPJocdxul1JTt6u8vExOp1OJiZ3k6+tndiwAAICTQpFHi+J2u5WaukNlZSVyOKpKvJ+fv9mxAAAAThpFHi2Gx+PRnj07VFpaLLvdocTEjvLzCzA7FgAAQK2YXuSzs7N19913a+DAgRo4cKAmTpyolJSUo+5fVFSkBx54QKeeeqr69u2rW2+9Vfv372/ExLCiQyW+pKRIdrtdiYkd5e8faHYsAACAWjN9sezJkydr7dq1SkpKkr+/v77++mtt3LhR//vf/xQWFnbE/g899JA+++wztW3bVn5+flq0aJEyMjL03nvvyWazmfAM0NQZhkdpaTtVXFwom82uhISOCggIMjsWAABAnZg6Ip+Wlqbt27crISFBH3/8sRYsWKD27dsrKytLy5cvP2L/jIwMff755woMDNTHH3+sTz75RHFxcdqwYYPWrFljwjNAU2cYhtLSdquoqEA2m00JCckKDAw2OxYAAECdmVrk4+LitGrVKn3wwQfy8fFRaWmpiouLJUnh4eFH7L9mzRoZhqEePXooJCREPj4+GjhwoPc24HCGYWjv3t0qLMyTzWZTfHyygoJCzI4FAABQL0yfWiNJISEhmjdvnqZOnaqsrCxdfvnlGjx48BH7paenS5IiIiK82w59nJGRUacMTqfppwugHjgcVf+OdrtNGRmpKijIlWRTYmKyQkPDTc0GWNmh15bDYa/T98vDj2N2FgCwuiZR5CVp5cqVyszMlNPplI+Pj8rKyhQQUH1FkbKyMkmS0/lbbB8fn2q31YbdblNEBHOmmwvDMJSZmabc3GxJUvfu3dS6dWuTUwHWlp1dtUxrSIh/vXy/DA2t/YpR9Z0FAKyqyRT5Rx55RFOmTNF9992nd999Vw6HQ1OmTKm2j59f1UV73G63d1tlZaUkHVH6T4bHY6igoKTW90fTYbfblJW1z/vXm/j4JDmdgcrNLTY5GWBthYVl3vd1eT05HHaFhgaooKBUbrfH1Cyou9DQgDr9dQVA3Zhe5IuKilRaWuodMR0zZoyWLl2qH3744Yh9o6OjJUl5eXnebbm5uZKkmJiYOuVwuWr3AwWNLy1tjwoLC2q8zWbzyOOpPPiZU2lp+5SWtu+I/UJCQhUXF9+AKYHm5VDpdrs99fL9si7Hqe8sAGBVphb5ZcuWacKECUpOTtaHH34oHx8fbdiwQZJqnArRp08fSdLGjRtVVFQkf39/rVq1SpLUv3//RssN8+Tm5mrUqPPk8dT8w/uiiy7SlVdeqVmzZmnJkiVHPY7D4dDixcuqnW8BAABgJaYW+YEDB6pr167asmWLLrzwQkVFRWnNmjVyOp26+eabtWLFCs2ePVtJSUm65557FB8fr3POOUeLFy/WqFGj5Ofnp9TUVPXt29db8tG8RURE6KOPvjjqiHxmZrqeeeYZ3Xjjzfq//5t01OOEhIRS4gEAgKWZWuR9fX31+uuv6/nnn9d3332nrVu3auDAgbrrrrvUp08fffDBB1qyZIl69+7tvc8zzzyjp556Sp9//rlycnI0YsQIPfLII1wMqgU51pSYkJBg+fn5qWPHToqLS2zEVAAAAI3L9DnyrVu31pNPPlnjbaNHj9bo0aOrbQsKCtLf//53/f3vf2+MeAAAAECTxKnmAAAAgAVR5AEAAAALosgDAAAAFkSRBwAAACyIIg8AAABYEEUeAAAAsCCKPAAAAGBBFHkAAADAgijyAAAAgAVR5AEAAAALosgDAAAAFkSRBwAAACyIIg8AAABYEEUeAAAAsCCKPAAAAGBBFHkAAADAgijyAAAAgAVR5AEAAAALosgDAAAAFkSRBwAAACyIIg8AAABYEEUeAAAAsCCKPAAAAGBBFHkAAADAgijyAAAAgAVR5AEAAAALosgDAAAAFkSRBwAAACyIIg8AAABYEEUeAAAAsCCKPAAAAGBBFHkAAADAgijyAAAAgAVR5AEAAAALosgDAAAAFkSRBwAAACyIIg8AAABYEEUeAAAAsCCKPAAAAGBBFHkAAADAgijyAAAAgAVR5AEAAAALosgDAAAAFkSRBwAAACyIIg8AAABYEEUeAAAAsCCKPAAAAGBBFHkAAADAgijyAAAAgAVR5AEAAAALosgDAAAAFkSRBwAAACyIIg8AAABYEEUeAAAAsCCn2QGAw2VmpqusrKxO95ekffv2yu321CmLv7+/oqPb1ukYAAAADYUijyYjMzNdDzxwV70c6+WXp9XLcZ588jnKPAAAaJIo8mgyDo3E33jjJMXGtqvVMRwOu2w2lwzDWacR+X379uq112bU6a8DAAAADYkijyYnNradEhOTanVfp9OuiIgg5eYWy+Wq29QaAACApoyTXQEAAAALosgDAAAAFkSRBwAAACyIIg8AAABYEEUeAAAAsCCKPAAAAGBBFHkAAADAgijyAAAAgAVR5AEAAAALosgDAAAAFmR6kc/JydEjjzyiYcOGqW/fvrr88sv11VdfHXX/tWvXqkuXLke8/fe//23E1AAAAIC5nGY+uGEYuuWWW7R69Wq1a9dOPXr00KpVqzRp0iS99dZbGjJkyBH32bRpkySpc+fOio+P924//GMAAACguTO1yP/6669avXq1IiIi9L///U8BAQF66qmn9NZbb+m99947ZpGfNGmSLrjggsaODAAAADQJphb5qKgovfDCC5KkgIAASVJMTIwkKTs7u8b7bN68WZK0YsUKLVq0SHFxcRo3bpzatGnTCIkBAACApsH0In/hhRd6Py8tLdXcuXMlSf379z9i/8rKSm3dulWSvPtJ0oIFC/Thhx+qVatWtc7idJp+ukCL53DYve9r++9x+DHMzgI0J/X1mqiP1yivTwCoYmqRP1xZWZkmTZqknTt3Kjw8XOPGjTtin4KCAg0bNkyVlZW65557FB4erltvvVVr167V1KlT9eijj9bqse12myIigur4DFBX2dn+kqSQEP86/3uEhgY0mSxAc1Dfr4m6vEZ5fQJAlSZR5IuLizVx4kT99NNP8vX11YsvvqjIyMgj9mvVqpWmT59ebdt1112ntWvXas2aNbV+fI/HUEFBSa3vj/pRWFjmfZ+bW1yrYzgcdoWGBqigoFRut8fULEBzUl+vifp4jfL6bDpCQwPq/BdQALVnepEvLy/3lviAgABNnz69xpNcJamkpER79+6VJHXq1EmS5OfnJ0lyu911yuFy1b70oX4c+qHudnvq/O9R12PUZxagOajv10RdjsPrEwCqmP5r9KOPPqqffvpJfn5+ev3113Xaaacddd9Vq1Zp5MiRmjBhgoqKiiRJS5culST17du3UfICAAAATYGpI/JbtmzRBx98IEkKCwvTm2++qTfffFOSlJSUpKFDh2r27NlKSkrSPffcoyFDhqhHjx7auHGjRo4cqejoaK1bt04hISGaOHGimU8FAAAAaFSmFvlFixZ5P96/f7+WLFni/bx3795KTk7WkiVL1Lt3b0mSj4+PXn31VT333HP67rvvtGXLFg0aNEj3338/F4QCAABAi2Jqkb/tttt02223HXOf0aNHV/s8KipKTz75ZEPGAgAAAJo80+fIAwAAADh5FHkAAADAgijyAAAAgAVR5AEAAAALosgDAAAAFkSRBwAAACyIIg8AAABYkKnryAMAmreKigoVFOSrsLBABQX5KikpUu/ePRUaGmV2NACwPIo8AOCEhISEqKKiXEVFhTIMj0pLS1VcXKySkiIVFxerqKhQJSXFKi4uUlFRkUpKilVeXn7EcbZv/1VjxoyV223UKkdFRblCQkLq+nQAwPIo8gCAaiorK1VYWOAdRS8oyFd6+l5deeWVysrap6ysfTXez9/fR/7+4YqMDD/uY6xd+2OdMl5xxRVyu911OgYAWB1FHgBaCMMwVFpaooKCAhUW5qug4LeiXlXaq7aXlJTUeP/t2wPkdP72Y8NmsykgIFBBQUEKCgr2vgUHByswMMi73dfXz3sfh8Om0NAAFRSU1npEPj19r6ZNe0F33nl/re4PAM0FRR4AmgG3233EKHpVMS+oNkfd5XKd0PF8fHwUEhKq0NAwhYSESjL07bdfa/ToK5Wc3EmhoWEKDg6Rw+E4qZxOp13h4UEyDB+5XJ5aPFPJ19dPhYWFtbovADQnFHkAaMIMw1B5ednvRtEPlfN87/bi4mIZxomNcAcGBik0NFQhIWEKDf2trIeGhnm3BwQEyGazee+TkrJLn376iZKSkhUfn9hQTxcAcBIo8gBgEo/Ho6Kiomql/PDR80PvKyoqTuh4Doej2ij678v6oe2HT48BAFgX380BoAH8ftnFmkbRi4qK5PGc2PQSf/+Ag8W8eik/fBQ9MDBQdjuXBwGAloIiDwAnwePxqKSk5Lij6GVlZSd0PLvdruDgkGqj5yEhYQoLC6s2uu7r69vAzwwAYDUUeQA46MhlF38/il71dqLLHvr6+v5u5PzIUfTg4GBG0QEAtUKRB9DsVS27WHqUUfRDJ5EefdnF37PZbAoKCj5iFP23uehVn/v7+zfwMwMAtGQUeQCWduSyizVPdTnRZRedTudRRtF/m+YSEhJ60ssuAgBQ3yjyAJqssrKy342iF/xuRL1uyy4eXtaPtuwiAABNFUUeQKM7tOxizVcXrf2yi7+ff/77UXQfH58GfmYAADQeijyAelXTsouHL7lYUFC3ZRdrGkVn2UUAQEtEkQdwQg4tu3jsUfQClZWVntDxqpZdDD5YzmseRQ8NDWPZRQAAjoIiD6DGZRd/v7pLXZZdrGkUnWUXAQCoG4o80IwdWnax5lH038p6SUnxCR2vatnFoKOMoh/6mGUXAQBoDBR5wKJqWnbxt49/G0WvrKw8oeP9ftnFw08cZdlFAACaHoo80ASVlZX9bhT99yeMFqi4uOgkll0M/N0o+u9Xd2HZRQAArIYiDzSimpZd/P0oeu2XXfytlLPsIgAAzR9FHqgnFRUV1Up5TaPoRUWFJ7Hsov9xprqw7CIAAC0ZRR44jpqWXTxyFP3El1202WwKCQn53cmiLLsIAABODkUeLZrL5aq2Dnp+fr4KC/OVkZGuNm3a6L335qi0tKQell38bRSdZRcBAEB9oMijWTIM4xij6Ce27KKfn5+Kigol/bbsYs2j6L8twejn588JowAAoFFQ5NGkhISEqKKi3FugT9a+fan6/vtvlZ+fL5fLdcx9HQ67QkJC5HQ6FRQUrMDAIAUHV733eNz66qvFGjPmanXq1JVlFwEAQJNDkUeT4Xa7dcUVVygra5+ysvbV+jhdunSplzwXX3yxWrVqrfDwiHo5HgAAQH2iyKPJcDgcmjdvnm655Q61bduuVsew2QyVlRXK5ZL8/ALldNbuv3h6+l5Nm/aC7rzz/lrdHwAAoKFR5NGkFBYWytfXT8HBIbW6v9NpV/v27ZSbWyyX68SWeayJr6+fCgtrN70HAACgMbB0BgAAAGBBFHkAAADAgijyAAAAgAVR5AEAAAALosgDAAAAFkSRBwAAACyIIg8AAABYEEUeAAAAsCCKPAAAAGBBFHkAAADAgijyAAAAgAVR5AEAAAALosgDAAAAFkSRBwAAACyIIg8AAABYkNPsAAAA60hJ2V2n+zscdqWkuGQYTrndnlodY9++vXXKAADNBUUeTU5dikJ9lASJogD8ntvtliTNnPmayUl+4+/vb3YEADAVRR5NBkUBaLo6dOiohx56TA6Ho07HycxM18svT9Of/3yLoqPb1vo4/v7+dbo/ADQHFHk0GfVRFOqrJEgUBeD3OnToWOdjOBxVp2bFxrZTXFxinY8HAC0ZRR5NSl2LAiUBAAC0FKxaAwAAAFgQRR4AAACwIIo8AAAAYEEUeQAAAMCCKPIAAACABVHkAQAAAAuiyAMAAAAWRJEHAAAALIgiDwAAAFgQRR4AAACwIIo8AAAAYEGmF/mcnBw98sgjGjZsmPr27avLL79cX3311VH3Lyoq0gMPPKBTTz1Vffv21a233qr9+/c3YmIAAADAfKYWecMwdMstt+jdd9+Vw+FQjx49tHHjRk2aNEkrVqyo8T4PPfSQPvjgAwUFBalNmzZatGiRJk+eLMMwGjk9AAAAYB5Ti/yvv/6q1atXKyIiQv/73//03//+V9ddd50Mw9B77713xP4ZGRn6/PPPFRgYqI8//liffPKJ4uLitGHDBq1Zs8aEZwAAAACYw2nmg0dFRemFF16QJAUEBEiSYmJiJEnZ2dlH7L9mzRoZhqEePXooJCREkjRw4EClpaVpzZo16t+/fyMlBwAAAMxlepG/8MILvZ+XlpZq7ty5klRjKU9PT5ckRUREeLcd+jgjI6NOWZxO008XQD3w8SnQGWfsVVjYt/Lz6y2Pp60MI0qSw+xoACTZ7Tbve77vAkDdmFrkD1dWVqZJkyZp586dCg8P17hx42rcR5Kczt9i+/j4VLutNux2myIigmp9fzSulJQUFRQU1HhbUNCzuueetZIme7cZhkMuV6QqK1vL5YqSy9VadnucwsO7SWp78C1WUrSa0EsCaJays/0kSUFBfnzfBYA6ahKtpbi4WBMnTtRPP/0kX19fvfjii4qMjDxiPz+/qh8Abrfbu62yslLSb1NzasPjMVRQUFLr+6Px5ObmaNiwofJ4PDXe3rNnhe6801+xsW61aeNW69Ye2e1u+fhkyccn65jHNgybDCPq4Ch+jDyeqrfDP666LVqSbwM8O6D5Ky4u977PzS02OQ3qKjQ0QA4Hf1kBzGJ6kS8vL/eW+ICAAE2fPl1Dhgypcd/o6GhJUl5enndbbm6upN/m1teWy1VzMUTTEhISro8++kKFhTWPyDscdtntbhUUOJSb69Gvv7rk65srX99s+foeOPiWreDgAoWEFMpuz5Ddnim7PVM2m1s2W5bs9ixJG46Zw+OJlMfTVh5PtLfgu92/fXxou+Rf/18EwMI8HsP7nu+7AFA3phf5Rx99VD/99JP8/Pz0+uuva8CAAUfdt0+fPpKkjRs3qqioSP7+/lq1apWkmufUo3mKi4s/6m1Op10REUHKzS0+ZkkwDKn67By3bLZs2e0ZcjgyDhb8379lym7PkM1WKbs9R3Z7jqSNx8zq8YQfNpoffdTyLzHFAAAAnBxTi/yWLVv0wQcfSJLCwsL05ptv6s0335QkJSUlaejQoZo9e7aSkpJ0zz33KD4+Xuecc44WL16sUaNGyc/PT6mpqerbt6+35AO145BhtJHb3UZu9ynH2M8jmy23xqL/2y8Ahwp/mez2PNnteZK2HPPRPZ6QGgr/kR8bRogkWz0+bwAAYFWmFvlFixZ5P96/f7+WLFni/bx3795KTk7WkiVL1Lt3b+/2Z555Rk899ZQ+//xz5eTkaMSIEXrkkUdks1Fu0BjsMoxWcrtbye3ucYz9DNlsed5Sb7enH/Zx9fJvs5XIbi+U3V4oadsxH90wgg6bwhNz1PJvGOGi8AMA0LzZDC6JKrfbo5wcTrpqDk50ak3TYchmKzxK4f99+S888aMa/ocV/Bi53b8v/odO5I0UhR+NKS0tRVOmPKDHHntScXGJZsdBHUVGBnGyK2Ai0+fIAy2bTYYRKrc7VG53p+PsW3xwFD/zYMk/NI3n94U/TzZbmRyO3XI4dh/ziIbhe7Ds1zTK/9svAFVr8fPDGgCApoQiD1hGkDyeZHk8ycfZr9S7Es+hwn9k+c+Q3Z4tm61CDsceORx7jnlEw3DK42lTw/z935f/1uLbCgAAjYOfuECzEyCPp708nvbH2a+ixnn7h6/SUzWHP0s2m0sOxz45HPskrT3qEQ3DLo+ndQ3z96svy+nxREvyqcfnDABAy0ORB1osX3k88fJ4jr6cZ5VK2e1Zxyz8h97bbB45HJlyODIlrT/qEasuvtXqiCk8Ry7RGSPJrz6fNAAAzQZFHsBx+MjjiZXHE3uc/dyy2Q4cXIaz5lV6flua0yWb7YDs9gOSfjnmUT2eiBpX6XG7q0/xkQLr6wkDAGAJFHkA9cQhw4iWyxUtqfcx9vPIZsuptjLPkeW/ak6/zVYhuz1XdnuupM3HfHSPJ6zGEf3fl38puB6fMwAA5qHIA2hkdhlGlNzuKLndPY+xn3Hw4ls1r9Jz+BV4bbZS2e35stvzJW095qN7PME1XmX39+XfMELF0pwAgKaMIg+gibLJMCLldkfK7e52jP0M2WwFNRT+mqb4FHnfpB3HfHTDCPAW/qo5/DWP9htGhCj8AAAzUOQBWJxNhhEmtztMbnfn4+xbVG0k/+hr8efLZiv1rsXvc4wFdgzD73fl/vflv2rEv+riW6zFDwCoPxR5AC1IsNzujnK7Ox5nv5Jqxb6q/Nc0xSdXNlu5HI5UORypxzxi1Vr8NV946/DyX3XxLUe9PWMAQPNFkQeAIwTK40mSx5N0nP3KjzKi//vyf+DgWvx75XDsPeYRDcNxcC3+o520e+itjfgWDgAtGz8FAKDW/OTxJMjjSTjOfpWy2/cfZ1nOdNntWbLZ3HI4qn4ROJaqtfijDi7DeazCHy3Jt96eMQCg6aDIA0CD85HH004eT7vj7OeS3X6ghpN2jyz+NptbNluW7Pas4z66x9PqsCk8MQen8Ry5Yo/kXy/PFgDQOCjyANBkOA+7ou2xeGSzZR+cwnP4KP+RI/42W6Xs9mzZ7dmSNh77qJ7wI+bt11T+paD6esIAgDqgyAOA5dhlGK3ldreW293rGPsZh118q/o0Hofj94W/THZ7nuz2PElbjvnoHk/oYQX/UOE/8mPDCBFLcwJAw6HIA0CzZZNhtJLb3Upud49j7GfIZss/yrz96uXfZiuW3V4gu71A0rZjPrphBB02hafqrU0bP8XGFtXrswSAlspmGIZhdgizud0e5eQUmx0D9cDptCsiIki5ucVyuTxmxwGaHZut8JiF3+PZI6dzv5zOo39P3b49WGvXzlJ0dNuj7hMSEqq4uPiGeAqoR5GRQXI4uD4CYBZG5AEAJ8wwQuR2h8jt7nTEbbm5uTr77NPk8YQpICBE0dEetWnjrva+dWu3vvzSR59+essxH8fhcGjx4mWKiIhoqKcCAJbHiLwYkW9OGJEHzJWWtkeFhQVHvd3hsMtud8vjccjtPvprlBF5a2BEHjAXI/IAgHpzvPLNL9sAUH/4NRoAAACwIIo8AAAAYEEUeQAAAMCCKPIAAACABVHkAQAAAAuiyAMAAAAWRJEHAAAALIgiDwAAAFgQRR4AAACwIIo8AAAAYEEUeQAAAMCCKPIAAACABVHkAQAAAAuiyAMAAAAWRJEHAAAALIgiDwAAAFgQRR4AAACwIJthGIbZIcxmGIY8nhb/ZWg2HA673G6P2TEAHAWv0ebDbrfJZrOZHQNosSjyAAAAgAUxtQYAAACwIIo8AAAAYEEUeQAAAMCCKPIAAACABVHkAQAAAAuiyAMAAAAWRJEHAAAALIgiDwAAAFgQRR4AAACwIIo8AAAAYEEUeQAAAMCCKPIAAACABVHkAQAAAAuiyAMAAAAWRJEHAAAALIgiDwAAAFiQ0+wAQH1ZunSpduzYofLychmGIUkqKSnR6tWrNXfuXJPTAS1XZWWl3nnnHW3evFkVFRVH3P7cc8+ZkAoArM9mHGo8gIVNnz5d06ZNO+rtmzdvbsQ0AA738MMPa/78+ZKk3//IsdlsvD4BoJYYkUezsGDBAvn4+OiKK67QnDlzdO2112rnzp1avny57rzzTrPjAS3ap59+KrvdrksvvVTR0dGy25nVCQD1gRF5NAu9evXSqaeeqjfffFPnnXeeHnzwQQ0bNkznn3++wsPD9e6775odEWixhg4dqk6dOumtt94yOwoANCsMi6BZCAwMVF5eniSpZ8+eWrVqlSQpMjJSW7duNTEZgHHjxumXX37RmjVrzI4CAM0KI/JoFiZMmKDly5frvvvuk5+fn55++mn17dtXK1asUOvWrfXdd9+ZHRFosdLT03XppZeqoKBAQUFB8vf3995ms9l4fQJALTEij2bhvvvuU+vWrRUUFKSLLrpIkZGRWrFihSRpzJgxJqcDWrZ7771X+fn5MgxDRUVFOnDgQLU3AEDtMCKPZqOiokJlZWUKDQ1VRkaGPvvsM8XHx+ucc84xOxrQop1yyikKCAjQgw8+WOPJrgMHDjQpGQBYG0UezcIDDzygnj176pprrqm2/emnn1ZBQYGeeOIJk5IBuOSSSxQeHq7//Oc/ZkcBgGaF5SdhWdu3b1dubq6kquUnU1NT1blzZ+/tbrdb33zzjfbt20eRB0z00EMP6c9//rNee+01nX766fLz86t2e1JSkknJAMDaGJGHZX366ae66667JFVdZMZmsx2xj2EYateunZYsWdLY8QAc1LNnT3k8niMuBiVVney6adMmE1IBgPUxIg/LuvDCC/X+++9r+/bt2r9/v3x9fRUeHu693W63KyIiQrfccot5IQHI5XId9TbGkgCg9hiRR7MwfPhwDR06VI899pjZUQAAABoFRR7N3o4dO5ScnGx2DKDF27t3r9asWSObzaZ+/fopNjbW7EgAYGlMrUGzkJmZqSeeeEI7duxQeXm598/1JSUlys/PZw4uYLJnn31Wb731ljwejyTJ4XBowoQJuuOOO0xOBgDWRZFHs/D444/ryy+/rPG29u3bN24YANXMnTtXr7/+uux2uzp16iSpatWpV199Ve3atdOVV15pckIAsCau7Ipm4ccff1RMTIzmz58vX19fvfbaa3r66aflcDh00UUXmR0PaNFmz54tPz8/vf322/roo4/00Ucfac6cOfLx8dHs2bPNjgcAlkWRR7NQUlKiTp06qWfPnurevbuys7N1ySWXqH///vrwww/Njge0aKmpqerbt6/69Onj3da3b1/17dtXKSkp5gUDAIujyKNZiIqK0ubNm5WZmalevXrps88+U2ZmptLS0nTgwAGz4wEtWlhYmHbt2qXy8nLvtrKyMu3evbvakrEAgJNDkUezcN555+nAgQOaN2+ehg4dqm+++UZnnnmm0tPT1aFDB7PjAS3aWWedpczMTF199dV69dVX9eqrr+rqq6/W/v37deaZZ5odDwAsi+Un0SxUVlbq+eef1+DBgzVs2DD99a9/1fvvv6+wsDBNnz5dAwYMMDsi0GLl5eXp6quv1u7du71XYD501eV58+YpMjLS5IQAYE0UeTRbubm5CgsLk93OH54As5WUlOidd97RqlWrZLfb1bt3b1111VUKCwszOxoAWBZFHpa1cOHCE9730ksvbbAcAI7tp59+UkREhDp27Fht+48//qjS0lINGzbMpGQAYG0UeVhW165dvX+mP57Nmzc3cBoAR9O1a1ede+65mjp1arXt1157rXbs2KEVK1aYlAwArI0LQsGy+vbtW63Ir1+/XjabTUlJSbLZbNqxY4f8/f01YsQIE1MCLdObb76pOXPmeD9ftmyZzj77bO/nHo9H6enpCgkJMSMeADQLFHlY1jvvvOP9+OWXX9a2bdv07rvvKjk5WZK0detWjR07VklJSWZFBFqsMWPG6JVXXlF+fr5sNptKS0u1d+/eI/a74IILTEgHAM0DU2vQLJx22mnq3Lmz3nrrrWrb//SnP2nHjh1atmyZScmAlmv79u3av3+/brjhBvXr10+33nqr9zabzabIyEh17tzZxIQAYG2MyKNZKCsr0y+//KKdO3d6143funWrfvnllxOeRw+gfnXs2FEdO3bUrFmzFBERoU6dOpkdCQCaFYo8moUzzzxT//vf/zRq1CglJSXJMAzt2rVLHo9Hl112mdnxgBZt4MCB3tH5Nm3aaO7cufr22281dOhQjR071ux4AGBZTK1Bs5CXl6d7771X3377bbXtF154oR5//HEFBgaalAzA119/rVtuuUVPPPGE4uLidM0110iqml7zyCOP6OqrrzY5IQBYEyPyaBbCw8P16quvaufOndq1a5fsdrs6duyo+Ph4s6MBLd6MGTPk8XjkdDr18ccfy2636y9/+YtmzJiht99+myIPALXEiDxajMmTJ2vp0qXatGmT2VGAFqV///7q3r27Zs+erfPPP1/+/v5auHChJkyYoLVr12rNmjVmRwQAS+La9WhR+L0VMIePj4+ysrK0e/du9evXT5JUWFgoHx8fk5MBgHVR5AEADSopKUmrVq3SrbfeKpvNpqFDh+rll1/Whg0b1L17d7PjAYBlUeQBAA1q4sSJcrvdWrdunXr06KEzzjhDO3bskI+PjyZNmmR2PACwLE52BQA0qHPPPVcfffSRUlNTNXjwYDmdTo0cOVLjx49Xr169zI4HAJZFkQcANLjk5GQlJyd7Px82bJiJaQCgeaDIAwAa1Nlnn33U22w2mxYvXtyIaQCg+aDIAwAa1N69e496m81ma8QkANC8UOTRYnTs2FEFBQVmxwBanLfeesv7sWEYqqio0IYNG/Tf//5XL774onnBAMDiuCAUmo0PP/xQ+fn5Gj9+vKSqlTJGjBihyy+/3ORkAGpy2223qbS0VK+99prZUQDAklh+Es3CvHnzdP/992vp0qWSpIqKCi1btkwPPfSQ5s2bZ3I6AL9nGIays7O1atUqs6MAgGUxtQbNwn/+8x/5+vpq7NixkqquIvn888/rvvvu06xZs3TFFVeYnBBoua6++upqn7vdbmVlZSkzM1Nt27Y1KRUAWB9FHs3Cnj17NGDAAI0YMUJS1Ql05513nt577z2tXr3a5HRAy7Zu3boat9vtdi4IBQB1QJFHsxASEqJt27apqKhIwcHBkqT8/Hz9+uuvCgwMNDkd0LI9+eSTR2zz9/dXz549FR8fb0IiAGgeKPJoFoYPH6733ntPI0aMUO/eveV2u7V+/XoVFBRozJgxZscDWrTLLrtMUtW8+EPLTR7+SzcAoHZYtQbNQmFhoSZMmKANGzZU296rVy+98cYbCg0NNSkZgIqKCv3tb3+Tn5+fpkyZIqnql+9TTz1Vf//73+Xr62tyQgCwJkbk0SyEhIRo7ty5Wr58uTZv3izDMNStWzeddtppXHAGMNmLL76o999/X3369JEklZWVaf/+/froo48UFRWle+65x9yAAGBRjMij2XC73UpPT1dcXJwkaeXKlerXrx+jfYDJzjzzTLlcLs2bN8+7Ss3+/ft1+eWXy8fHR1999ZXJCQHAmlhHHs1Cenq6Ro4cWe0qkbfddptGjRp1zMvDA2h42dnZ6tKlS7WlJtu0aaNOnTopKyvLxGQAYG0UeTQLTz/9tHbt2qXi4mJJUnl5udq2bavdu3frueeeMzkd0LK1bdtWa9asqbYM5cqVK7VmzRrFxMSYFwwALI6pNWgWhgwZosjISH388cey26t+P/V4PLrkkkuUk5Oj77//3uSEQMv1+uuv69lnn5XNZlNgYKDcbrfKy8slSXfccYduuukmkxMCgDUxIo9mobi4WBEREd4SL1VdbCY4OFiFhYUmJgMwYcIE3XDDDXI6nSouLlZZWZmcTqeuu+46SjwA1AEj8mgWxowZo40bN+qOO+7Q0KFD5XK59PXXX2vGjBnq0aOH3n//fbMjAi1ecXGxduzYIUlKTk5WUFCQ97acnByVlZUpNjbWrHgAYDkUeTQLX331lSZPnnzEdsMwNG3aNJ1zzjkmpAJwoiZPnqylS5dq06ZNZkcBAMtgag2aheHDh+vf//63evfuLT8/P/n5+al3797697//TYkHLIJxJQA4OVwQCs1Gt27ddP3116u0tNS7LT8/XwsXLtSll15qXjAAAIAGQJFHs7Bw4UI99NBDcrvdNd5OkQcAAM0NRR7NwksvvSSXy6U2bdooNja22uo1AAAAzRFFHs1Cdna22rdvr48++ki+vr5mxwEAAGhwDFuiWRg0aJACAgIo8QAAoMVgRB6WtWzZMu/H5557rv7+97/rwQcf1PDhw+Xv719t36FDhzZ2PAAAgAbFOvKwrK5du8pmsx13P5vNxtrUQBM3e/Zsbdq0SU8++aTZUQDAMhiRh2VxBUjAOpYuXaodO3aovLzcu158SUmJVq9erblz52rcuHEmJwQA62FEHgDQoKZPn65p06Yd9fbNmzc3YhoAaD442RUA0KAWLFggHx8f/fGPf5RhGLrmmms0ZMgQGYahO+64w+x4AGBZFHkAQIPKzMzUgAED9PDDDysxMVGnn3663nzzTbVv315fffWV2fEAwLIo8gCABhUYGKi8vDxJUs+ePbVq1SpJUmRkpLZu3WpiMgCwNoo8AKBB9ezZU5s3b9bMmTM1YMAAzZ49W9dff73WrFmjoKAgs+MBgGVR5AEADeq+++5T69atFRQUpIsuukiRkZFasWKFJGnMmDEmpwMA62LVGgBAg6uoqFBZWZlCQ0OVkZGhzz77TPHx8TrnnHPMjgYAlkWRBwA0qAceeEA9e/bUNddcU237008/rYKCAj3xxBMmJQMAa+OCUACAerd9+3bl5uZKqlp+MjU1VZ07d/be7na79c0332jfvn0UeQCoJUbkAQD17tNPP9Vdd90lSTIMQzab7Yh9DMNQu3bttGTJksaOBwDNAiPyAIB6d+GFF+r999/X9u3btX//fvn6+io8PNx7u91uV0REhG655RbzQgKAxTEiDwBoUMOHD9fQoUP12GOPmR0FAJoVijwAwDQ7duxQcnKy2TEAwJKYWgMAaFCZmZl64okntGPHDpWXl+vQ+FFJSYny8/O1adMmkxMCgDVR5AEADerxxx/Xl19+WeNt7du3b9wwANCMcGVXAECD+vHHHxUTE6P58+fL19dXr732mp5++mk5HA5ddNFFZscDAMuiyAMAGlRJSYk6deqknj17qnv37srOztYll1yi/v3768MPPzQ7HgBYFkUeANCgoqKitHnzZmVmZqpXr1767LPPlJmZqbS0NB04cMDseABgWRR5AECDOu+883TgwAHNmzdPQ4cO1TfffKMzzzxT6enp6tChg9nxAMCyONkVANCg7rrrLtlsNvXq1UvDhg3T5Zdfrvfff19hYWF68MEHzY4HAJbFOvIAgEaXm5ursLAw2e38YRgAaosReQBAvVu4cOEJ73vppZc2WA4AaM4YkQcA1LuuXbvKZrOd0L6bN29u4DQA0DwxIg8AqHd9+/atVuTXr18vm82mpKQk2Ww27dixQ/7+/hoxYoSJKQHA2ijyAIB6984773g/fvnll7Vt2za9++67Sk5OliRt3bpVY8eOVVJSklkRAcDyOMsIANCgZs+erZ49e3pLvCR17txZPXv21KxZs0xMBgDWRpEHADSosrIy/fLLL9q5c6d329atW/XLL7+orKzMxGQAYG1MrQEANKgzzzxT//vf/zRq1CglJSXJMAzt2rVLHo9Hl112mdnxAMCyWLUGANCg8vLydO+99+rbb7+ttv3CCy/U448/rsDAQJOSAYC1UeQBAI1i586d2rVrl+x2uzp27Kj4+HizIwGApVHkAQCmmzx5spYuXapNmzaZHQUALIOTXQEATQLjSgBwcijyAAAAgAVR5AEAAAALosgDAAAAFkSRBwAAACyIIg8AAABYEEUeAAAAsCCn2QEAAOjYsaMKCgrMjgEAlsIFoQAADe7DDz9Ufn6+xo8fL0maOHGiRowYocsvv9zkZABgXUytAQA0qHnz5un+++/X0qVLJUkVFRVatmyZHnroIc2bN8/kdABgXRR5AECD+s9//iNfX1+NHTtWkuTj46Pnn39efn5+mjVrlsnpAMC6KPIAgAa1Z88eDRgwQCNGjJAk2Ww2nXfeeerfv7/27NljcjoAsC6KPACgQYWEhGjbtm0qKirybsvPz9evv/6qwMBAE5MBgLWxag0AoEENHz5c7733nkaMGKHevXvL7XZr/fr1Kigo0JgxY8yOBwCWxao1AIAGVVhYqAkTJmjDhg3Vtvfq1UtvvPGGQkNDTUoGANZGkQcANDjDMLR8+XJt3rxZhmGoW7duOu2002Sz2cyOBgCWxdQaAECD83g8SkxM1GmnnSZJWrlypSorK+Xr62tyMgCwLk52BQA0qPT0dI0cOVIvvviid9ttt92mUaNGae/eveYFAwCLo8gDABrU008/rV27dqm4uFiSVF5errZt22r37t167rnnTE4HANbFHHkAQIMaMmSIIiMj9fHHH8turxo/8ng8uuSSS5STk6Pvv//e5IQAYE2MyAMAGlRxcbEiIiK8JV6S7Ha7goODVVhYaGIyALA2TnYFADSozp07a/Xq1Xr11Vc1dOhQuVwuff3111q7dq169OhhdjwAsCym1gAAGtRXX32lyZMnH7HdMAxNmzZN55xzjgmpAMD6KPIAgAb39ddf6+WXX9aWLVskSV27dtXEiRN11llnmZwMAKyLIg8AaHCZmZlat26dSktLj7jt0ksvbfxAANAMUOQBAA1q4cKFeuihh+R2u2u8ffPmzY2cCACaB052BQA0qJdeekkul0tt2rRRbGxstdVrAAC1R5EHADSo7OxstW/fXh999JF8fX3NjgMAzQbDIgCABjVo0CAFBARQ4gGgnjFHHgBQ75YtW+b9OD09XX//+981cuRIDR8+XP7+/tX2HTp0aGPHA4BmgSIPAKh3Xbt2lc1mO+5+NptNmzZtaoREAND8MEceAFDvYmNjzY4AAM0eI/IAAACABXGyKwAAAGBBFHkAAADAgijyAJoEs2f5mf34AACcLIo8gJM2btw4denSxfvWtWtX9e3bV6NHj9bs2bPldrtP6njbt2/X2LFjGyjtsVVUVOjJJ5/Uxx9/bMrjAwBQW6xaA6BWunfvrkceeUSS5Ha7lZ+fr2+++Ub/+Mc/tHr1ar3wwgsntPygJH322Wdau3ZtQ8Y9qv3792vmzJl68sknTXl8AABqiyIPoFaCg4PVp0+fatuGDx+upKQkPfnkkxo+fLhGjRplTjgAAFoAptYAqFfjxo1TmzZt9O6770qSysrK9Nxzz2nEiBHq2bOn+vXrp+uvv16bN2+WJE2dOlXTpk2TJHXp0kVTp06VJOXk5Ohvf/ubzjrrLPXs2VMDBw7U5MmTlZaW5n2sPXv26Oabb9agQYPUu3dvXXXVVfrmm2+q5dm6dasmTpyofv36qV+/fpo8ebL27NkjSUpLS9PZZ58tSXrggQc0fPjwhv3iAABQjyjyAOqVw+HQkCFDtGHDBrlcLt17772aP3++brrpJr355pu6//77tXXrVt1xxx0yDENXXHGFxowZI0maO3eurrjiChmGoYkTJ+r777/XXXfdpTfeeEOTJk3S8uXLNWXKFEmSx+PRxIkTVVJSomeeeUYzZsxQeHi4Jk2apJSUFEnSrl27dPXVVys7O1tPPfWUnnjiCe3Zs0djx45Vdna22rRp4/0l4uabb/Z+DACAFTC1BkC9i4qKUmVlpfLy8lRcXKyHH35YF154oSRp4MCBKi4u1lNPPaWsrCzFxMQoJiZGkrxTdTIzMxUQEKD77rtPAwYMkCQNGjRIaWlp3pH+7Oxs7dixQ3/+8581bNgwSdIpp5yiadOmqby8XJI0bdo0+fv7a+bMmQoODpYkDRkyROecc45ef/113XffferWrZskKSEhQd27d2+cLxAAAPWAIg+gwdhsNr3xxhuSqk4qTUlJ0c6dO7V06VJJUmVlZY33i46O1qxZsyRJ+/btU0pKinbs2KE1a9Z47xMVFaWOHTvq4Ycf1vLly3XGGWdo6NCheuCBB7zHWblypQYNGiR/f3+5XC5JVXP7BwwYoOXLlzfY8wYAoDFQ5AHUu8zMTPn7+ys8PFzfffed/vGPf2jnzp0KCgpSly5dFBQUJOnYa7d/9NFHev7555Wenq7w8HB17dpV/v7+3tttNpvefPNN/fvf/9aXX36pBQsWyMfHR+ecc44effRRhYeHKy8vT59++qk+/fTTI44fGRlZ/08cAIBGRJEHUK/cbrd+/PFH9evXT3v37tXkyZN19tln65VXXlFCQoIkac6cOfruu++OeoxVq1bpvvvu07XXXqsJEyZ4p94888wzWr16tXe/6OhoPfroo3rkkUe0ZcsWff7553rttdcUFhamv/3tbwoJCdEf/vAHXX/99Uc8htPJtz8AgLVxsiuAevXuu+9q//79Gjt2rH755ReVl5dr4sSJ3hIvyVviD43I2+3VvxWtXbtWHo9Ht912m7fEu91u73QYj8ejtWvX6g9/+IM2bNggm82mbt266Y477lDnzp2VkZEhqWo+/vbt29WtWzf16tVLvXr1Us+ePTVz5kx9+eWXkqpOzgUAwIoYkgJQK0VFRVq3bp2kqmKdm5urZcuWae7cuRo1apRGjBihlJQUOZ1O/fOf/9QNN9ygiooKffDBB/r6668lSSUlJZKk0NBQSdInn3yi3r1765RTTpEkPfbYY7r88stVUFCg//73v9qyZYv3ft27d5e/v7/uvfde3XrrrYqKitLy5cu1efNmjR8/XpI0adIkXX311Zo4caLGjh0rPz8/zZ07V4sXL9ZLL70kSQoJCZEkrVixQsnJyerdu3ejfP0AAKgrm3GsSaoAUINx48bpxx9/9H5ut9vVqlUrJSUl6YorrtDFF1/svarr559/rmnTpik1NVVhYWHq06ePxo8fr3Hjxunhhx/WNddco8zMTE2ePFlbtmzRmDFj9Oijj2rOnDl66623lJmZqaioKA0aNEjnnHOOJk+erFdffVXDhg3T7t279dxzz2n16tUqKChQ+/btNW7cOF111VXebBs3btQLL7ygNWvWyDAMde7cWTfddJN3/XhJeuqppzR37lw5nU59//338vX1bbwvJgAAtUSRBwAAACyIOfIAAACABVHkAQAAAAuiyAMAAAAWRJEHAAAALIgiDwAAAFgQRR4AAACwIIo8AAAAYEEUeQAAAMCCKPIAAACABVHkAQAAAAuiyAMAAAAWRJEHAAAALOj/AR+FWz1h19mGAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Phase 7 complete\n" - ] - } - ], - "source": [ - "from streamline.runners.compare_runner import CompareRunner\n", - "if len_datasets(output_path, experiment_name) > 1:\n", - " cmp = CompareRunner(output_path, experiment_name, algorithms=algorithms,\n", - " exclude=exclude, sig_cutoff=sig_cutoff,\n", - " class_label=class_label, instance_label=instance_label,\n", - " show_plots=True)\n", - " cmp.run(run_parallel=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "SaqYpZViPPVc" - }, - "source": [ - "## Phase 8: Replication\n", - "* Optional - depends on availability of replication data" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "vASWHToXSMpX", - "outputId": "b6b0b187-93c5-4685-d94b-45efead5a4a7" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data_custom_rep\n", - "INFO: ------------------------------------------------------- \n", - "INFO: Loading Dataset: hcc_data_custom\n", - "INFO: Validating and Identifying Feature Types...\n", - "WARNING: User specified both categorical vs quantitative features; any unspecified binary features will be treated as categorical, and any remaining features will have their feature types automatically assigned based on categorical_cutoff parameter\n", - "WARNING: New Value found in Binary Categorical Variable, filling with null value\n", - "INFO: Initial Data Counts: ----------------\n", - "INFO: Instance Count = 171\n", - "INFO: Feature Count = 61\n", - "INFO: Categorical = 28\n", - "INFO: Quantitative = 33\n", - "INFO: Missing Count = 1181\n", - "INFO: Missing Percent = 0.11322020899242642\n", - "INFO: Class Counts: ----------------\n", - "INFO: Class Count Information\n", - "INFO: \n", - " Class Instances\n", - "0 0 115\n", - "1 1 56\n", - "INFO: Processed Data Counts: ----------------\n", - "INFO: Instance Count = 171\n", - "INFO: Feature Count = 69\n", - "INFO: Categorical = 40\n", - "INFO: Quantitative = 29\n", - "INFO: Missing Count = 942\n", - "INFO: Missing Percent = 0.0798372743452835\n", - "INFO: Class Counts: ----------------\n", - "INFO: Class Count Information\n", - "INFO: \n", - " Class Instances\n", - "0 0 115\n", - "1 1 56\n", - "INFO: Final List of Features:\n", - "INFO: ['Symptoms', 'Alcohol', 'Hepatitis B Surface Antigen', 'Hepatitis B e Antigen', 'Hepatitis B Core Antibody', 'Hepatitis C Virus Antibody', 'Cirrhosis', 'Endemic Countries', 'Smoking', 'Diabetes', 'Obesity', 'Hemochromatosis', 'Arterial Hypertension', 'Chronic Renal Insufficiency', 'Human Immunodeficiency Virus', 'Nonalcoholic Steatohepatitis', 'Esophageal Varices', 'Splenomegaly', 'Portal Hypertension', 'Portal Vein Thrombosis', 'Liver Metastasis', 'Radiological Hallmark', 'Grams of Alcohol per day', 'Packs of cigarets per year', 'Performance Status*', 'Encephalopathy degree*', 'Ascites degree*', 'International Normalised Ratio*', 'Alpha-Fetoprotein (ng/mL)', 'Haemoglobin (g/dL)', 'Mean Corpuscular Volume', 'Leukocytes(G/L)', 'Platelets', 'Albumin (mg/dL)', 'Total Bilirubin(mg/dL)', 'Alanine transaminase (U/L)', 'Aspartate transaminase (U/L)', 'Gamma glutamyl transferase (U/L)', 'Alkaline phosphatase (U/L)', 'Total Proteins (g/dL)', 'Creatinine (mg/dL)', 'Number of Nodules', 'Major dimension of nodule (cm)', 'Direct Bilirubin (mg/dL)', 'Iron', 'Oxygen Saturation (%)', 'Ferritin (ng/mL)', 'Sim_Cat_2', 'Sim_Text_Cat_2', 'Sim_Cor_-1.0_B', 'Sim_Cor_0.9_A', 'Sim_Cor_0.9_B', 'Sim_Cor_1.0_B', 'Missing_Sim_Miss_0.6', 'Missing_Sim_Miss_0.7', 'Sim_Cat_3_1', 'Sim_Cat_3_2', 'Sim_Cat_3_3', 'Sim_Cat_4_1', 'Sim_Cat_4_2', 'Sim_Cat_4_3', 'Sim_Cat_4_4', 'Sim_Text_Cat_3_Category 1', 'Sim_Text_Cat_3_Category 2', 'Sim_Text_Cat_3_Category 3', 'Sim_Text_Cat_4_Category 1', 'Sim_Text_Cat_4_Category 2', 'Sim_Text_Cat_4_Category 3', 'Sim_Text_Cat_4_Category 4']\n", - "INFO: Running stats on Decision Tree\n", - "INFO: Running stats on Logistic Regression\n", - "INFO: Running stats on Naive Bayes\n", - "INFO: hcc_data_custom_rep phase 9 complete\n" - ] - } - ], - "source": [ - "if applyToReplication:\n", - " from streamline.runners.replicate_runner import ReplicationRunner\n", - " repl = ReplicationRunner(rep_data_path, dataset_for_rep, output_path, \n", - " experiment_name, load_algo=True, \n", - " exclude_plots=exclude_rep_plots)\n", - " repl.run(run_parallel=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "yzbQBgH4RjQW" - }, - "source": [ - "## Phase 9: Summary Report\n", - "* Optional\n", - "* Generates and downloads a PDF report of the analysis\n", - "\n", - "### Testing Data Report\n", - "* Summarizes testing evaluations on all trained models, applied to their respective hold out testing data partitions" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Z9GVbQOrPb2G", - "outputId": "d0ab63be-ebac-4ec5-8bdf-7cf6c26bcf78" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Starting Report\n", - "INFO: Publishing Univariate Analysis\n", - "INFO: Publishing Model Prediction Summary\n", - "INFO: Publishing Average Model Prediction Statistics\n", - "INFO: Publishing Median Model Prediction Statistics\n", - "INFO: Publishing Feature Importance Summaries\n", - "INFO: Publishing Dataset Comparison Boxplots\n", - "INFO: Publishing Statistical Analysis\n", - "INFO: Publishing Runtime Summary\n", - "INFO: Phase 8 complete\n" - ] - } - ], - "source": [ - "from streamline.runners.report_runner import ReportRunner\n", - "rep = ReportRunner(output_path, experiment_name, \n", - " algorithms=algorithms, exclude=exclude)\n", - "rep.run(run_parallel=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Replication Data Report\n", - "Summarizes performance of all trained models when applied to the same replication dataset. This evaluation offers a better way to pick a 'best performing' model, since all models are evaluated on the same set of new, or as-of-yet unseen, data." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "R-10eE_nUioQ", - "outputId": "5663f8bb-0e1f-4936-88aa-fbb764e12aae" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Starting Report\n", - "INFO: Publishing Model Prediction Summary\n", - "INFO: Publishing Average Model Prediction Statistics\n", - "INFO: Publishing Median Model Prediction Statistics\n", - "INFO: Phase 10 complete\n" - ] - } - ], - "source": [ - "if applyToReplication:\n", - " from streamline.runners.report_runner import ReportRunner\n", - " rep = ReportRunner(output_path=output_path, experiment_name=experiment_name,\n", - " algorithms=algorithms, exclude=exclude, training=False, \n", - " rep_data_path=rep_data_path, \n", - " dataset_for_rep=dataset_for_rep)\n", - " rep.run(run_parallel=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "wyNBJgShRk6w" - }, - "source": [ - "## File Cleanup \n", - "* Optional" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": { - "id": "fpTJmdhZQR9D" - }, - "outputs": [], - "source": [ - "from streamline.runners.clean_runner import CleanRunner\n", - "clean = CleanRunner(output_path, experiment_name, del_time=del_time, del_old_cv=del_old_cv)\n", - "# run_parallel is not used in clean\n", - "clean.run()" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "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.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/STREAMLINE_ColabNotebook.ipynb b/STREAMLINE_ColabNotebook.ipynb new file mode 100644 index 00000000..b5711c1d --- /dev/null +++ b/STREAMLINE_ColabNotebook.ipynb @@ -0,0 +1,1928 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4b456bff", + "metadata": { + "id": "4b456bff" + }, + "source": [ + "![STREAMLINE](https://github.com/UrbsLab/STREAMLINE/blob/main/docs/source/pictures/STREAMLINE_Logo_Full.png?raw=true)\n", + "\n", + "# STREAMLINE v1.0.0 Google Colab Notebook\n", + "\n", + "STREAMLINE is an end-to-end automated machine learning workflow that helps users run, interpret, and apply a rigorous tabular-data analysis without hand-building every preprocessing, modeling, evaluation, and reporting step.\n", + "\n", + "This notebook runs the full v1.0.0 pipeline on one of the included UCI demos or on uploaded custom data. It is intentionally explanation-heavy: the top half is the normal editing surface for users, and the phase cells below show exactly how the notebook maps those settings into STREAMLINE runners.\n", + "\n", + "Included demos:\n", + "\n", + "- `demo_binary`: HCC Survival binary classification\n", + "- `demo_multiclass`: Student Dropout and Academic Success multiclass classification\n", + "- `demo_regression`: Auto MPG regression\n", + "\n", + "Custom modes:\n", + "\n", + "- `custom_classification`\n", + "- `custom_regression`\n", + "\n", + "What to expect when running a demo as-is:\n", + "\n", + "- STREAMLINE will clone the latest selected branch, install dependencies, and run phases 1-11.\n", + "- The demo configuration uses 3 CV folds and a compact model list so the notebook finishes in a reasonable Colab session.\n", + "- Normal demo data folders contain deterministic 80% training splits; matching replication folders contain held-out 20% replication splits.\n", + "- At the end, the notebook prints report locations and can download the PDF report(s) and zipped experiment folder.\n" + ] + }, + { + "cell_type": "markdown", + "id": "61d30cf1", + "metadata": { + "id": "61d30cf1" + }, + "source": [ + "## Run Instructions\n", + "\n", + "### Demo Run\n", + "\n", + "1. Leave `RUN_MODE` set to one of the `demo_*` values.\n", + "2. Choose **Runtime > Run all**.\n", + "3. When the run finishes, download the PDF reports and zipped experiment folder from the output cells at the bottom.\n", + "\n", + "You can optionally change non-dataset parameters below, such as the number of CV folds, which phases run, or which modeling algorithms are used.\n", + "\n", + "### Custom Dataset Run: Prompt/Upload Mode\n", + "\n", + "1. Set `RUN_MODE` to `custom_classification` or `custom_regression`.\n", + "2. Leave `USE_DATA_PROMPT = True`.\n", + "3. Choose **Runtime > Run all**.\n", + "4. When prompted, upload one or more target datasets and optional replication datasets.\n", + "\n", + "The prompt flow asks for the essential dataset labels that STREAMLINE needs: outcome/class column, optional instance ID, optional match/group column, and classification type when relevant.\n", + "\n", + "### Custom Dataset Run: Manual Path Mode\n", + "\n", + "1. Set `RUN_MODE` to `custom_classification` or `custom_regression`.\n", + "2. Set `USE_DATA_PROMPT = False`.\n", + "3. Update the `CUSTOM_*` path and label parameters below.\n", + "4. Run all cells.\n", + "\n", + "The notebook defaults are tuned for demo/tutorial runtime in Colab. For fuller research runs, increase `P6_N_TRIALS` and `P6_TIMEOUT` or use a config/CLI run outside Colab.\n" + ] + }, + { + "cell_type": "markdown", + "id": "jLMUvcO5YLzF", + "metadata": { + "id": "jLMUvcO5YLzF" + }, + "source": [ + "--------------\n", + "## Essential Run Parameters\n", + "\n", + "Most users only need to edit this section and the custom-data section when running non-demo data.\n", + "\n", + "`RUN_MODE`, `OUTPUT_PATH`, and `EXPERIMENT_NAME` decide what is analyzed and where outputs are written. Additional phase parameters below can be changed to alter preprocessing, feature engineering, modeling, and reporting behavior.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "hIVqP9gfYLzG", + "metadata": { + "id": "hIVqP9gfYLzG" + }, + "outputs": [], + "source": [ + "# [run] section: choose which built-in demo or custom workflow to run.\n", + "RUN_MODE = \"demo_multiclass\"\n", + "# Supported values:\n", + "# - demo_binary\n", + "# - demo_multiclass\n", + "# - demo_regression\n", + "# - custom_classification\n", + "# - custom_regression\n", + "# Backward-compatible alias: demo_classification -> demo_multiclass\n", + "\n", + "# Colab-only helper for custom modes. Demo modes ignore this.\n", + "# True: upload files and answer prompts during Run all.\n", + "# False: use the manual CUSTOM_* paths below.\n", + "USE_DATA_PROMPT = True\n", + "\n", + "# [run] output_path / experiment_name\n", + "OUTPUT_PATH = \"/content/streamline_output\"\n", + "EXPERIMENT_NAME = \"ColabRun\"\n" + ] + }, + { + "cell_type": "markdown", + "id": "70192a80", + "metadata": { + "id": "70192a80" + }, + "source": [ + "## Custom Data Paths\n", + "\n", + "Used only when `RUN_MODE` is `custom_classification` or `custom_regression` and `USE_DATA_PROMPT = False`.\n", + "\n", + "Target data folders may contain one or more `.csv`, `.tsv`, or `.txt` datasets. All datasets in the same run should use the same outcome, instance, and match column names. Replication data is optional, but when supplied it should have the same feature schema expected by the trained models.\n", + "\n", + "- `CUSTOM_DATA_PATH`: folder containing target datasets\n", + "- `CUSTOM_REPLICATION_PATH`: folder containing optional replication datasets\n", + "- `CUSTOM_DATASET_FOR_REP`: one target dataset file used to align replication evaluation\n", + "- `CUSTOM_CATEGORICAL_FEATURES` / `CUSTOM_QUANTITATIVE_FEATURES`: optional feature-list files or Python lists\n", + "\n", + "If categorical/quantitative feature lists are left as `None`, STREAMLINE uses `P1_CATEGORICAL_CUTOFF` and binary-feature detection to infer feature types.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ed86d1a5", + "metadata": { + "id": "ed86d1a5" + }, + "outputs": [], + "source": [ + "CUSTOM_DATA_PATH = \"/content/my_target_data\"\n", + "CUSTOM_REPLICATION_PATH = \"/content/my_replication_data\"\n", + "CUSTOM_DATASET_FOR_REP = \"/content/my_target_data/my_train_dataset.csv\"\n", + "CUSTOM_CATEGORICAL_FEATURES = None\n", + "CUSTOM_QUANTITATIVE_FEATURES = None\n" + ] + }, + { + "cell_type": "markdown", + "id": "f1bd4bea", + "metadata": { + "id": "f1bd4bea" + }, + "source": [ + "## Custom Labels and Task Controls\n", + "\n", + "Used only for custom modes.\n", + "\n", + "- `CUSTOM_OUTCOME_LABEL`: target/outcome column in your data\n", + "- `CUSTOM_INSTANCE_LABEL`: optional unique row/sample id column; use `None` if absent\n", + "- `CUSTOM_MATCH_LABEL`: optional match/group column for grouped CV or aligned replication; use `None` if absent\n", + "- `CUSTOM_CLASSIFICATION_TYPE`: `Binary` or `Multiclass`\n", + "- model strings use STREAMLINE model ids such as `NB,LR,DT,RF,CGB,ExSTraCS`\n", + "\n", + "For regression runs, `CUSTOM_OUTCOME_LABEL` should identify a continuous outcome and `CUSTOM_REGRESSION_MODELS` controls the Phase 6 model list.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ff10a8c8", + "metadata": { + "id": "ff10a8c8" + }, + "outputs": [], + "source": [ + "CUSTOM_OUTCOME_LABEL = \"Class\"\n", + "CUSTOM_INSTANCE_LABEL = None\n", + "CUSTOM_MATCH_LABEL = None\n", + "\n", + "CUSTOM_CLASSIFICATION_TYPE = \"Binary\" # Binary or Multiclass\n", + "CUSTOM_CLASSIFICATION_MODELS = \"NB,LR,DT\"\n", + "CUSTOM_REGRESSION_MODELS = \"LR,RF\"\n" + ] + }, + { + "cell_type": "markdown", + "id": "dd343c81", + "metadata": { + "id": "dd343c81" + }, + "source": [ + "--------------\n", + "## Global Execution Parameters\n", + "\n", + "These settings affect the full pipeline.\n", + "\n", + "- `RUN_CLUSTER`: `Serial` is recommended in Colab. `Parallel` uses local joblib. `Local` uses local Dask.\n", + "- `N_SPLITS`: number of CV train/test partitions and therefore the number of model evaluations per algorithm.\n", + "- `RANDOM_STATE`: reproducibility control used across phases when supported.\n", + "- `P1_FORCE`: rebuilds the experiment folder when Phase 1 is rerun.\n", + "\n", + "For Colab, prefer `Serial` unless you are deliberately testing local parallel behavior. For small notebook demos, parallel startup overhead can be larger than the saved time.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9a174f2e", + "metadata": { + "id": "9a174f2e" + }, + "outputs": [], + "source": [ + "# [run] execution parameters\n", + "RUN_CLUSTER = \"Serial\" # Serial, Parallel (joblib), Local (Dask), BashSLURM, BashLSF, or a named Dask cluster\n", + "QUEUE = \"defq\"\n", + "RESERVED_MEMORY = 4\n", + "N_SPLITS = 3\n", + "RANDOM_STATE = 42\n", + "\n", + "# Kept as aliases because runner cells use PHASE_* names.\n", + "PHASE_QUEUE = QUEUE\n", + "PHASE_RESERVED_MEMORY_GB = RESERVED_MEMORY\n" + ] + }, + { + "cell_type": "markdown", + "id": "c1e852b3", + "metadata": { + "id": "c1e852b3" + }, + "source": [ + "## Phase Toggles\n", + "\n", + "Toggle any phase on/off during iterative debugging. For a complete fresh run, leave everything `True`.\n", + "\n", + "- `p1`-`p11` correspond to the STREAMLINE v1.0.0 phases.\n", + "- `p11` controls the standard testing-data report.\n", + "- `p11_replication` controls the replication report.\n", + "\n", + "If you skip an upstream phase, make sure its expected output already exists from a previous run.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "545fec1d", + "metadata": { + "id": "545fec1d" + }, + "outputs": [], + "source": [ + "# [phases] section\n", + "PHASE_ORDER = \"p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11\"\n", + "RUN_PHASES = {\n", + " \"p1\": True,\n", + " \"p2\": True,\n", + " \"p3\": True,\n", + " \"p4\": True,\n", + " \"p5\": True,\n", + " \"p6\": True,\n", + " \"p7\": True,\n", + " \"p8\": True,\n", + " \"p9\": True,\n", + " \"p10\": True,\n", + " \"p11\": True,\n", + " \"p11_replication\": True,\n", + "}\n", + "\n", + "# For regression, set True only if you explicitly want to run ensembles.\n", + "ALLOW_P7_FOR_REGRESSION = False\n" + ] + }, + { + "cell_type": "markdown", + "id": "76b6d8e4", + "metadata": { + "id": "76b6d8e4" + }, + "source": [ + "--------------\n", + "### Phase 1 - Data Exploration and Processing Parameters\n", + "\n", + "Phase 1 performs initial EDA, cleaning, feature engineering, feature-type handling, and CV partitioning.\n", + "\n", + "Typical outputs include data-count summaries, missingness summaries, class/outcome summaries, correlation plots, univariate analysis, and saved CV train/test files. Feature type settings matter downstream because categorical features may be one-hot encoded, passed to native categorical models, or passed to ReBATE methods as categorical indexes.\n", + "\n", + "When `P1_CATEGORICAL_FEATURES` and `P1_QUANTITATIVE_FEATURES` are `None`, STREAMLINE infers feature type using `P1_CATEGORICAL_CUTOFF`: non-binary features with more unique values than the cutoff are treated as quantitative, while binary features are treated as categorical by default.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f81157d1", + "metadata": { + "id": "f81157d1" + }, + "outputs": [], + "source": [ + "# [p1] Data Exploration and Processing parameters\n", + "P1_EXCLUDE_EDA_OUTPUT = None\n", + "P1_PARTITION_METHOD = \"Stratified\"\n", + "P1_IGNORE_FEATURES = None\n", + "P1_CATEGORICAL_FEATURES = None\n", + "P1_QUANTITATIVE_FEATURES = None\n", + "P1_TOP_FEATURES = 20\n", + "P1_CATEGORICAL_CUTOFF = 10\n", + "P1_SIG_CUTOFF = 0.05\n", + "P1_FEATUREENG_MISSINGNESS = 0.5\n", + "P1_CLEANING_MISSINGNESS = 0.5\n", + "P1_CORRELATION_REMOVAL_THRESHOLD = 1.0\n", + "P1_SHOW_PLOTS = True\n", + "P1_ONE_HOT_ENCODING = True\n", + "P1_CV_PROVIDED = False\n", + "P1_CV_INPUT_ROOT = None\n", + "P1_ENABLE_PLOTS = True\n", + "P1_PLOT_MISSINGNESS = True\n", + "P1_PLOT_CLASS_COUNTS = True\n", + "P1_PLOT_CORRELATION = True\n", + "P1_CORRELATION_PLOT_MAX_FEATURES = 200\n", + "P1_PLOT_UNIVARIATE = True\n", + "P1_UNIVARIATE_TOP_K = 20\n", + "P1_PLOT_ANOMALIES = True\n", + "P1_FORCE = True\n" + ] + }, + { + "cell_type": "markdown", + "id": "169f78ba", + "metadata": { + "id": "169f78ba" + }, + "source": [ + "### Phase 2 - Impute, Scale, and Balance Parameters\n", + "\n", + "Phase 2 transforms each CV split after Phase 1. Missing-value imputation and scaling are fit on training folds and applied to the corresponding test folds.\n", + "\n", + "Optional SMOTE/SMOTENC oversampling is applied only to training folds and only for classification outcomes. With `P2_SMOTE_METHOD = \"auto\"`, STREAMLINE uses SMOTENC when categorical features are present and standard SMOTE otherwise.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1ecb312", + "metadata": { + "id": "a1ecb312" + }, + "outputs": [], + "source": [ + "# [p2] Impute, Scale, and Balance parameters\n", + "P2_SCALE_DATA = True\n", + "P2_IMPUTE_DATA = True\n", + "P2_MULTI_IMPUTE = False\n", + "P2_OVERWRITE_CV = True\n", + "P2_IMPUTER_ID = None\n", + "P2_IMPUTER_PARAMS = {}\n", + "P2_SCALER_ID = None\n", + "P2_SCALER_PARAMS = {}\n", + "P2_SMOTE = False\n", + "P2_SMOTE_METHOD = \"auto\"\n", + "P2_SMOTE_SAMPLING_STRATEGY = \"auto\"\n", + "P2_SMOTE_K_NEIGHBORS = 5\n" + ] + }, + { + "cell_type": "markdown", + "id": "da387ca3", + "metadata": { + "id": "da387ca3" + }, + "source": [ + "### Phase 3 - Feature Learning Parameters\n", + "\n", + "Phase 3 adds learned representations such as PCA features. Learned transformations are fit within each training fold and applied to the matching test fold, preserving CV separation.\n", + "\n", + "`P3_KEEP_ORIGINAL_FEATURES=True` appends learned features to the original feature set. Set it to `False` when you want downstream phases to use only the learned representation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5b94200a", + "metadata": { + "id": "5b94200a" + }, + "outputs": [], + "source": [ + "# [p3] Feature Learning parameters\n", + "P3_LEARNER_ID = \"pca\"\n", + "P3_LEARNER_PARAMS = {}\n", + "P3_FEATURE_NAMESPACE = \"FL_PCA\"\n", + "P3_KEEP_ORIGINAL_FEATURES = True\n", + "P3_OVERWRITE_CV = True\n" + ] + }, + { + "cell_type": "markdown", + "id": "bcff7f64", + "metadata": { + "id": "bcff7f64" + }, + "source": [ + "### Phase 4 - Feature Importance Parameters\n", + "\n", + "Phase 4 estimates filter-based feature importance within each CV split. These scores are later used for feature selection and reporting.\n", + "\n", + "The demo/config default uses Mutual Information and MultiSWRFDB. Set `P4_MODELS = None` to run every registered feature-importance method. `P4_INSTANCE_SUBSET` limits expensive ReBATE-style methods; leave it as `None` to use all training instances.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a5f8d8f0", + "metadata": { + "id": "a5f8d8f0" + }, + "outputs": [], + "source": [ + "# [p4] Feature Importance parameters\n", + "P4_MODELS = \"mutualinformation,multiswrfdb\"\n", + "P4_MODELS_PARAMS = {\"mutualinformation\": {\"outcome_type\": \"auto\"}, \"multiswrfdb\": {\"n_jobs\": 1}}\n", + "P4_TOP_K = None\n", + "P4_THRESHOLD = None\n", + "P4_KEEP_ORIGINAL_FEATURES = False\n", + "P4_OVERWRITE_CV = True\n", + "P4_INSTANCE_SUBSET = 1000\n" + ] + }, + { + "cell_type": "markdown", + "id": "715b0d7b", + "metadata": { + "id": "715b0d7b" + }, + "source": [ + "### Phase 5 - Feature Selection Parameters\n", + "\n", + "Phase 5 performs collective feature selection before modeling. When `P5_FILTER_POOR_FEATURES = False`, all features continue to modeling.\n", + "\n", + "When filtering is enabled, STREAMLINE removes features that have no evidence of importance across the active FI methods. If `P5_MAX_FEATURES_TO_KEEP` is an integer, STREAMLINE keeps a capped set of top-ranked features from the available FI outputs. `P5_ALGORITHMS = \"auto\"` is recommended because it discovers whichever FI methods were actually run.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3ba0995b", + "metadata": { + "id": "3ba0995b" + }, + "outputs": [], + "source": [ + "# [p5] Feature Selection parameters\n", + "P5_ALGORITHMS = \"auto\"\n", + "P5_N_SPLITS = N_SPLITS\n", + "P5_MAX_FEATURES_TO_KEEP = 2000\n", + "P5_FILTER_POOR_FEATURES = True\n", + "P5_OVERWRITE_CV = False\n", + "P5_SELECTOR_ID = \"default\"\n", + "P5_SELECTOR_PARAMS = {}\n", + "P5_EXPORT_SCORES = True\n", + "P5_TOP_FEATURES = 20\n", + "P5_SHOW_PLOTS = True\n", + "P5_STRICT_DISCOVERY = False\n" + ] + }, + { + "cell_type": "markdown", + "id": "1542f877", + "metadata": { + "id": "1542f877" + }, + "source": [ + "### Phase 6 - Modeling Parameters\n", + "\n", + "Phase 6 trains and evaluates the requested algorithms across CV folds.\n", + "\n", + "- `P6_N_TRIALS` and `P6_TIMEOUT` control Optuna hyperparameter search. The notebook demo default is `50` trials and `300` seconds so Colab runs stay practical; use `200` and `900` for fuller config-style runs.\n", + "- `P6_TRAINING_SUBSAMPLE` can limit expensive models on large datasets.\n", + "- `P6_UNIFORM_FI=True` forces permutation feature importance for all models and can be slow.\n", + "- `P6_CALIBRATE=True` applies probability calibration for classification models.\n", + "\n", + "The demo model lists are intentionally small (`NB,LR,DT` for classification and `LR,RF` for regression). Add more models when runtime is acceptable. If Phase 1 one-hot encoding is disabled, requested models should be native-categorical compatible.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4dcc3e45", + "metadata": { + "id": "4dcc3e45" + }, + "outputs": [], + "source": [ + "# [p6] Modeling parameters\n", + "# None values below use the selected RUN_MODE defaults from CFG.\n", + "P6_OUTCOME_TYPE = None\n", + "P6_MODEL_TYPE = None\n", + "P6_MODELS = None\n", + "P6_MODEL_PARAMS_JSON = None\n", + "P6_CALIBRATE = False\n", + "P6_CALIBRATE_METHOD = \"sigmoid\"\n", + "P6_CALIBRATE_CV = 5\n", + "P6_SCORING_METRIC = None\n", + "P6_METRIC_DIRECTION = \"maximize\"\n", + "P6_N_TRIALS = 50\n", + "P6_TIMEOUT = 300\n", + "P6_TRAINING_SUBSAMPLE = 0\n", + "P6_UNIFORM_FI = False\n", + "P6_SAVE_PLOT = False\n", + "P6_BYPASS_ONE_HOT_FOR_NATIVE_MODELS = False\n", + "P6_NATIVE_CATEGORICAL_MODELS = \"CGB,ExSTraCS\"\n" + ] + }, + { + "cell_type": "markdown", + "id": "4406e61a", + "metadata": { + "id": "4406e61a" + }, + "source": [ + "### Phase 7 - Ensemble Parameters\n", + "\n", + "Phase 7 builds ensemble classifiers from Phase 6 base-model predictions. Hard voting, soft voting, and stacking are available for classification workflows.\n", + "\n", + "Regression ensemble support is intentionally guarded in this notebook by `ALLOW_P7_FOR_REGRESSION`; leave that off unless regression ensemble support is explicitly implemented for the run you are testing.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bee57b4d", + "metadata": { + "id": "bee57b4d" + }, + "outputs": [], + "source": [ + "# [p7] Ensemble parameters\n", + "P7_ENABLED = True\n", + "P7_ENSEMBLES = \"hard_voting,soft_voting,stack_lr\"\n", + "P7_BASE_MODELS = None # None uses the selected RUN_MODE Phase 6 model list.\n", + "P7_META_TRAIN_SOURCE = \"train\"\n", + "P7_CALIBRATE = 0\n", + "P7_CALIBRATE_METHOD = \"sigmoid\"\n", + "P7_CALIBRATE_CV = 5\n" + ] + }, + { + "cell_type": "markdown", + "id": "b484ed61", + "metadata": { + "id": "b484ed61" + }, + "source": [ + "### Phase 8 - Summary Statistics Parameters\n", + "\n", + "Phase 8 summarizes testing-fold model performance and creates post-analysis figures. Outputs may include ROC/PRC plots for classification, regression summaries, metric boxplots, model feature-importance plots, and composite feature-importance summaries.\n", + "\n", + "`P8_MULTICLASS_AVERAGE` controls multiclass ROC/PR aggregation where applicable.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a34404a6", + "metadata": { + "id": "a34404a6" + }, + "outputs": [], + "source": [ + "# [p8] Summary Statistics parameters\n", + "# None metric values use the selected RUN_MODE defaults from CFG.\n", + "P8_SCORING_METRIC = None\n", + "P8_METRIC_WEIGHT = None\n", + "P8_TOP_FEATURES = 40\n", + "P8_SIG_CUTOFF = 0.05\n", + "P8_SCALE_DATA = True\n", + "P8_EXCLUDE_PLOTS = None\n", + "P8_SHOW_PLOTS = True\n", + "P8_INCLUDE_ENSEMBLES = None # None follows whether Phase 7 actually ran.\n", + "P8_MULTICLASS_AVERAGE = \"micro\"\n" + ] + }, + { + "cell_type": "markdown", + "id": "e1a47d16", + "metadata": { + "id": "e1a47d16" + }, + "source": [ + "### Phase 9 - Dataset Comparison Parameters\n", + "\n", + "Phase 9 is useful only when an experiment includes more than one target dataset. It compares model performance distributions across datasets and writes comparison outputs under `DatasetComparisons/`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4acfa74", + "metadata": { + "id": "e4acfa74" + }, + "outputs": [], + "source": [ + "# [p9] Dataset Comparison parameters\n", + "P9_SIG_CUTOFF = 0.05\n", + "P9_SHOW_PLOTS = True\n" + ] + }, + { + "cell_type": "markdown", + "id": "c2a39d49", + "metadata": { + "id": "c2a39d49" + }, + "source": [ + "### Phase 10 - Replication Parameters\n", + "\n", + "Phase 10 evaluates previously trained models on external or held-out replication datasets. This gives a uniform evaluation on the same new data and can be more useful for selecting a final model than comparing only CV test folds.\n", + "\n", + "The included UCI demos use deterministic held-out 20% replication splits rather than independent external datasets.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7a23536a", + "metadata": { + "id": "7a23536a" + }, + "outputs": [], + "source": [ + "# [p10] Replication parameters\n", + "# None path/label values use the selected RUN_MODE defaults from CFG/metadata.\n", + "P10_REP_DATA_PATH = None\n", + "P10_DATASET_FOR_REP = None\n", + "P10_MATCH_LABEL = None\n", + "P10_OUTCOME_LABEL = None\n", + "P10_INSTANCE_LABEL = None\n", + "P10_EXCLUDE_PLOTS = None\n", + "P10_SHOW_PLOTS = True\n" + ] + }, + { + "cell_type": "markdown", + "id": "eab0f21e", + "metadata": { + "id": "eab0f21e" + }, + "source": [ + "### Phase 11 - Reporting Parameters\n", + "\n", + "Phase 11 generates PDF report artifacts for the standard testing-data report and, when available, the replication report.\n", + "\n", + "`P11_REUSE_EXISTING_FIGURES=True` speeds up report regeneration when plots have already been made. Disable it when you want plots regenerated from scratch.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c5799089", + "metadata": { + "id": "c5799089" + }, + "outputs": [], + "source": [ + "# [p11] Reporting parameters\n", + "P11_REPORT_MODES = \"standard,replication\"\n", + "P11_REPORTING_DIR = None\n", + "P11_REPORT_MODE_STANDARD = \"standard\"\n", + "P11_REPORT_MODE_REPLICATION = \"replication\"\n", + "P11_OUTCOME_LABEL = None\n", + "P11_OUTCOME_TYPE = None\n", + "P11_INSTANCE_LABEL = None\n", + "P11_MAKE_PDF = True\n", + "P11_ENABLE_PLOTS = True\n", + "P11_REUSE_EXISTING_FIGURES = True\n" + ] + }, + { + "cell_type": "markdown", + "id": "925d76c6", + "metadata": { + "id": "925d76c6" + }, + "source": [ + "--------------\n", + "## Setup: Install and Import STREAMLINE\n", + "\n", + "This section shallow-clones the selected STREAMLINE branch, installs dependencies from `requirements.txt`, and imports the v1.0.0 phase runners.\n", + "\n", + "Most users should not edit below this point unless they are debugging the notebook itself.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eizsIoApm1yO", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "eizsIoApm1yO", + "outputId": "314c5918-f1d0-4dd1-d0f0-bd8a590f9a70" + }, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import shutil\n", + "import logging\n", + "import subprocess\n", + "from pathlib import Path\n", + "\n", + "REPO_URL = \"https://github.com/UrbsLab/STREAMLINE.git\"\n", + "REPO_BRANCH = \"v3\"\n", + "REPO_DIR = Path(\"/content/STREAMLINE\")\n", + "\n", + "if REPO_DIR.exists() and (REPO_DIR / \".git\").is_dir():\n", + " subprocess.run([\"git\", \"-C\", str(REPO_DIR), \"fetch\", \"--depth\", \"1\", \"origin\", REPO_BRANCH], check=True)\n", + " subprocess.run([\"git\", \"-C\", str(REPO_DIR), \"checkout\", \"FETCH_HEAD\"], check=True)\n", + "elif REPO_DIR.exists():\n", + " shutil.rmtree(REPO_DIR)\n", + " subprocess.run([\"git\", \"clone\", \"--depth\", \"1\", \"--single-branch\", \"--branch\", REPO_BRANCH, REPO_URL, str(REPO_DIR)], check=True)\n", + "else:\n", + " subprocess.run([\"git\", \"clone\", \"--depth\", \"1\", \"--single-branch\", \"--branch\", REPO_BRANCH, REPO_URL, str(REPO_DIR)], check=True)\n", + "\n", + "print(f\"STREAMLINE repo ready at {REPO_DIR}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "haw70pp1Zq6j", + "metadata": { + "id": "haw70pp1Zq6j" + }, + "outputs": [], + "source": [ + "# Queue/memory are configured in the [run] parameter cell above.\n", + "PHASE_QUEUE = QUEUE\n", + "PHASE_RESERVED_MEMORY_GB = RESERVED_MEMORY\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "af8CwJ7encPM", + "metadata": { + "id": "af8CwJ7encPM" + }, + "outputs": [], + "source": [ + "if str(REPO_DIR) not in sys.path:\n", + " sys.path.insert(0, str(REPO_DIR))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0iWjLZ9VnkxX", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0iWjLZ9VnkxX", + "outputId": "2746c949-6f20-47ce-ccbe-63fea8d16b15" + }, + "outputs": [], + "source": [ + "subprocess.run([sys.executable, \"-m\", \"pip\", \"install\", \"-r\", str(REPO_DIR / \"requirements.txt\")], check=True)\n", + "\n", + "import importlib.metadata as importlib_metadata\n", + "\n", + "print(\"Installed dependency versions:\")\n", + "for package_name in [\"numpy\", \"pandas\", \"skrebate\", \"kaleido\"]:\n", + " try:\n", + " version = importlib_metadata.version(package_name)\n", + " except importlib_metadata.PackageNotFoundError:\n", + " version = \"not installed\"\n", + " print(f\"{package_name}: {version}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "lO9VEzkrW1sA", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lO9VEzkrW1sA", + "outputId": "62b12791-124a-46cf-d9a4-a7861436d4ab" + }, + "outputs": [], + "source": [ + "# Show full phase logs in notebook output (INFO/WARNING/ERROR).\n", + "logging.basicConfig(\n", + " level=logging.INFO,\n", + " format=\"%(levelname)s: %(message)s\",\n", + " force=True,\n", + ")\n", + "logging.getLogger().setLevel(logging.INFO)\n", + "print(\"INFO: Notebook logging configured at INFO level (phases 1-10).\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5P8Ja9ZEm_Sj", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5P8Ja9ZEm_Sj", + "outputId": "b7f8aff9-4d1a-4848-9a0a-a4cea23582ed" + }, + "outputs": [], + "source": [ + "from streamline.p1_data_process.p1_runner import P1Runner\n", + "from streamline.p2_impute_scale.p2_runner import P2Runner\n", + "from streamline.p3_feature_learning.p3_runner import P3Runner\n", + "from streamline.p4_feature_importance.p4_runner import P4Runner\n", + "from streamline.p5_feature_selection.p5_runner import P5Runner\n", + "from streamline.p6_modeling.p6_runner import P6Runner\n", + "from streamline.p7_ensembles.p7_runner import P7Runner\n", + "from streamline.p8_summary_statistics.p8_runner import P8Runner\n", + "from streamline.p9_compare_datasets.p9_runner import P9Runner\n", + "from streamline.p10_replication.p10_runner import P10Runner\n", + "from streamline.p11_reporting.p11_runner import P11Runner\n", + "\n", + "print(f\"REPO_DIR: {REPO_DIR}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "70f0410b", + "metadata": { + "id": "70f0410b" + }, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Optional Colab Custom Upload Prompts\n", + "\n", + "This helper is used only for custom modes when `USE_DATA_PROMPT = True`. It creates clean temporary folders under `/content`, uploads files, and fills the same `CUSTOM_*` variables used by manual path mode.\n", + "\n", + "The upload prompt intentionally asks for only essential dataset information. More detailed behavior, such as feature-type lists, modeling algorithms, SMOTE, and plotting options, remains controlled by the parameter cells above.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def collect_colab_custom_inputs(run_mode: str):\n", + " from google.colab import files\n", + " from pathlib import Path\n", + " import os\n", + " import shutil\n", + "\n", + " def clean_folder(path):\n", + " path = Path(path)\n", + " if path.exists():\n", + " shutil.rmtree(path)\n", + " path.mkdir(parents=True, exist_ok=True)\n", + " return path\n", + "\n", + " def optional_text(prompt):\n", + " value = input(prompt).strip()\n", + " return None if value.lower() in {\"\", \"none\", \"na\", \"n/a\"} else value\n", + "\n", + " def yes_no(prompt):\n", + " value = input(prompt).strip().lower()\n", + " return value in {\"1\", \"true\", \"t\", \"yes\", \"y\"}\n", + "\n", + " mode = run_mode.strip().lower()\n", + " target_dir = clean_folder(\"/content/UserData\")\n", + " rep_dir = Path(\"/content/UserReplicationData\")\n", + "\n", + " experiment_name = input(\"Experiment name for this STREAMLINE run: \").strip() or EXPERIMENT_NAME\n", + "\n", + " print(\"Upload one or more target dataset files (.csv, .tsv, or .txt).\")\n", + " old_cwd = os.getcwd()\n", + " os.chdir(target_dir)\n", + " uploaded_target = files.upload()\n", + " os.chdir(old_cwd)\n", + " if not uploaded_target:\n", + " raise ValueError(\"No target dataset files were uploaded.\")\n", + "\n", + " first_target = next(iter(uploaded_target.keys()))\n", + " outcome_label = input(\"Outcome/class column label: \").strip()\n", + " if not outcome_label:\n", + " raise ValueError(\"Outcome/class column label is required.\")\n", + " instance_label = optional_text(\"Instance ID column label, or None: \")\n", + " match_label = optional_text(\"Match/group column label, or None: \")\n", + "\n", + " classification_type = CUSTOM_CLASSIFICATION_TYPE\n", + " if mode == \"custom_classification\":\n", + " classification_type = input(\"Classification type (Binary or Multiclass): \").strip() or CUSTOM_CLASSIFICATION_TYPE\n", + " if classification_type not in {\"Binary\", \"Multiclass\"}:\n", + " raise ValueError(\"Classification type must be Binary or Multiclass.\")\n", + "\n", + " replication_available = yes_no(\"Replication data available? Enter yes or no: \")\n", + " if replication_available:\n", + " rep_dir = clean_folder(rep_dir)\n", + " print(\"Upload one or more replication dataset files.\")\n", + " os.chdir(rep_dir)\n", + " uploaded_rep = files.upload()\n", + " os.chdir(old_cwd)\n", + " if not uploaded_rep:\n", + " raise ValueError(\"Replication was requested but no replication files were uploaded.\")\n", + " default_dataset_for_rep = str(target_dir / first_target)\n", + " dataset_for_rep = input(\n", + " f\"Dataset-for-rep path [{default_dataset_for_rep}]: \"\n", + " ).strip() or default_dataset_for_rep\n", + " else:\n", + " dataset_for_rep = str(target_dir / first_target)\n", + " RUN_PHASES[\"p10\"] = False\n", + " RUN_PHASES[\"p11_replication\"] = False\n", + "\n", + " return {\n", + " \"EXPERIMENT_NAME\": experiment_name,\n", + " \"CUSTOM_DATA_PATH\": str(target_dir),\n", + " \"CUSTOM_REPLICATION_PATH\": str(rep_dir),\n", + " \"CUSTOM_DATASET_FOR_REP\": dataset_for_rep,\n", + " \"CUSTOM_OUTCOME_LABEL\": outcome_label,\n", + " \"CUSTOM_INSTANCE_LABEL\": instance_label,\n", + " \"CUSTOM_MATCH_LABEL\": match_label,\n", + " \"CUSTOM_CLASSIFICATION_TYPE\": classification_type,\n", + " }\n" + ] + }, + { + "cell_type": "markdown", + "id": "98b6068d", + "metadata": { + "id": "98b6068d" + }, + "source": [ + "## Build Mode-Specific Configuration\n", + "\n", + "This cell converts `RUN_MODE` into a concrete configuration dictionary (`CFG`) including paths, labels, task type, feature-list defaults, model defaults, and metric defaults.\n", + "\n", + "For demo modes, these values point to the UCI demo folders shipped with STREAMLINE. For custom modes, they come from either the upload prompts or the manual `CUSTOM_*` cells.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aa6da382", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "aa6da382", + "outputId": "e443df8b-93d8-4314-cc77-c2c19510a01a" + }, + "outputs": [], + "source": [ + "from pprint import pprint\n", + "\n", + "\n", + "def uci_feature_path(repo_dir: Path, filename: str) -> str:\n", + " return str(repo_dir / \"data\" / \"UCIFeatureTypes\" / filename)\n", + "\n", + "\n", + "def mode_defaults(run_mode: str, repo_dir: Path):\n", + " mode = run_mode.strip().lower()\n", + " if mode == \"demo_classification\":\n", + " mode = \"demo_multiclass\"\n", + "\n", + " if mode == \"demo_binary\":\n", + " return {\n", + " \"task_family\": \"classification\",\n", + " \"data_path\": str(repo_dir / \"data\" / \"UCIBinaryClassification\"),\n", + " \"rep_data_path\": str(repo_dir / \"data\" / \"UCIRepBinaryClassification\"),\n", + " \"dataset_for_rep\": str(repo_dir / \"data\" / \"UCIBinaryClassification\" / \"hcc_survival.csv\"),\n", + " \"outcome_label\": \"Class\",\n", + " \"instance_label\": \"InstanceID\",\n", + " \"match_label\": None,\n", + " \"outcome_type\": \"Binary\",\n", + " \"categorical_features\": uci_feature_path(repo_dir, \"hcc_survival_categorical_features.csv\"),\n", + " \"quantitative_features\": uci_feature_path(repo_dir, \"hcc_survival_quantitative_features.csv\"),\n", + " \"p6_models\": \"NB,LR,DT\",\n", + " \"p6_scoring_metric\": \"balanced_accuracy\",\n", + " \"p6_metric_direction\": \"maximize\",\n", + " \"p8_scoring_metric\": \"balanced_accuracy\",\n", + " \"p8_metric_weight\": \"balanced_accuracy\",\n", + " }\n", + "\n", + " if mode == \"demo_multiclass\":\n", + " return {\n", + " \"task_family\": \"classification\",\n", + " \"data_path\": str(repo_dir / \"data\" / \"UCIMulticlassClassification\"),\n", + " \"rep_data_path\": str(repo_dir / \"data\" / \"UCIRepMulticlassClassification\"),\n", + " \"dataset_for_rep\": str(repo_dir / \"data\" / \"UCIMulticlassClassification\" / \"student_dropout_academic_success.csv\"),\n", + " \"outcome_label\": \"Class\",\n", + " \"instance_label\": \"InstanceID\",\n", + " \"match_label\": None,\n", + " \"outcome_type\": \"Multiclass\",\n", + " \"categorical_features\": uci_feature_path(repo_dir, \"student_dropout_categorical_features.csv\"),\n", + " \"quantitative_features\": uci_feature_path(repo_dir, \"student_dropout_quantitative_features.csv\"),\n", + " \"p6_models\": \"NB,LR,DT\",\n", + " \"p6_scoring_metric\": \"balanced_accuracy\",\n", + " \"p6_metric_direction\": \"maximize\",\n", + " \"p8_scoring_metric\": \"balanced_accuracy\",\n", + " \"p8_metric_weight\": \"balanced_accuracy\",\n", + " }\n", + "\n", + " if mode == \"demo_regression\":\n", + " return {\n", + " \"task_family\": \"regression\",\n", + " \"data_path\": str(repo_dir / \"data\" / \"UCIRegression\"),\n", + " \"rep_data_path\": str(repo_dir / \"data\" / \"UCIRepRegression\"),\n", + " \"dataset_for_rep\": str(repo_dir / \"data\" / \"UCIRegression\" / \"auto_mpg.csv\"),\n", + " \"outcome_label\": \"MPG\",\n", + " \"instance_label\": \"InstanceID\",\n", + " \"match_label\": None,\n", + " \"outcome_type\": \"Continuous\",\n", + " \"categorical_features\": uci_feature_path(repo_dir, \"auto_mpg_categorical_features.csv\"),\n", + " \"quantitative_features\": uci_feature_path(repo_dir, \"auto_mpg_quantitative_features.csv\"),\n", + " \"p6_models\": \"LR,RF\",\n", + " \"p6_scoring_metric\": \"neg_mean_squared_error\",\n", + " \"p6_metric_direction\": \"maximize\",\n", + " \"p8_scoring_metric\": \"mean_squared_error\",\n", + " \"p8_metric_weight\": \"mean_squared_error\",\n", + " }\n", + "\n", + " if mode == \"custom_classification\":\n", + " ctype = CUSTOM_CLASSIFICATION_TYPE.strip()\n", + " if ctype not in {\"Binary\", \"Multiclass\"}:\n", + " raise ValueError(\"CUSTOM_CLASSIFICATION_TYPE must be Binary or Multiclass\")\n", + " return {\n", + " \"task_family\": \"classification\",\n", + " \"data_path\": CUSTOM_DATA_PATH,\n", + " \"rep_data_path\": CUSTOM_REPLICATION_PATH,\n", + " \"dataset_for_rep\": CUSTOM_DATASET_FOR_REP,\n", + " \"outcome_label\": CUSTOM_OUTCOME_LABEL,\n", + " \"instance_label\": CUSTOM_INSTANCE_LABEL,\n", + " \"match_label\": CUSTOM_MATCH_LABEL,\n", + " \"outcome_type\": ctype,\n", + " \"categorical_features\": CUSTOM_CATEGORICAL_FEATURES,\n", + " \"quantitative_features\": CUSTOM_QUANTITATIVE_FEATURES,\n", + " \"p6_models\": CUSTOM_CLASSIFICATION_MODELS,\n", + " \"p6_scoring_metric\": \"balanced_accuracy\",\n", + " \"p6_metric_direction\": \"maximize\",\n", + " \"p8_scoring_metric\": \"balanced_accuracy\",\n", + " \"p8_metric_weight\": \"balanced_accuracy\",\n", + " }\n", + "\n", + " if mode == \"custom_regression\":\n", + " return {\n", + " \"task_family\": \"regression\",\n", + " \"data_path\": CUSTOM_DATA_PATH,\n", + " \"rep_data_path\": CUSTOM_REPLICATION_PATH,\n", + " \"dataset_for_rep\": CUSTOM_DATASET_FOR_REP,\n", + " \"outcome_label\": CUSTOM_OUTCOME_LABEL,\n", + " \"instance_label\": CUSTOM_INSTANCE_LABEL,\n", + " \"match_label\": CUSTOM_MATCH_LABEL,\n", + " \"outcome_type\": \"Continuous\",\n", + " \"categorical_features\": CUSTOM_CATEGORICAL_FEATURES,\n", + " \"quantitative_features\": CUSTOM_QUANTITATIVE_FEATURES,\n", + " \"p6_models\": CUSTOM_REGRESSION_MODELS,\n", + " \"p6_scoring_metric\": \"neg_mean_squared_error\",\n", + " \"p6_metric_direction\": \"maximize\",\n", + " \"p8_scoring_metric\": \"mean_squared_error\",\n", + " \"p8_metric_weight\": \"mean_squared_error\",\n", + " }\n", + "\n", + " raise ValueError(f\"Unsupported RUN_MODE: {run_mode}\")\n", + "\n", + "\n", + "if RUN_MODE.strip().lower().startswith(\"custom\") and USE_DATA_PROMPT:\n", + " globals().update(collect_colab_custom_inputs(RUN_MODE))\n", + "\n", + "CFG = mode_defaults(RUN_MODE, REPO_DIR)\n", + "CFG[\"output_path\"] = OUTPUT_PATH\n", + "CFG[\"experiment_name\"] = EXPERIMENT_NAME\n", + "\n", + "# Explicit Phase 1 feature-list parameters override mode defaults when provided.\n", + "if P1_CATEGORICAL_FEATURES is not None:\n", + " CFG[\"categorical_features\"] = P1_CATEGORICAL_FEATURES\n", + "if P1_QUANTITATIVE_FEATURES is not None:\n", + " CFG[\"quantitative_features\"] = P1_QUANTITATIVE_FEATURES\n", + "\n", + "if not Path(CFG[\"data_path\"]).exists():\n", + " raise FileNotFoundError(f\"Target data path not found: {CFG['data_path']}\")\n", + "\n", + "EXP_ROOT = Path(CFG[\"output_path\"]) / CFG[\"experiment_name\"]\n", + "\n", + "print(\"Resolved config:\")\n", + "pprint(CFG)\n" + ] + }, + { + "cell_type": "markdown", + "id": "76c812fb", + "metadata": { + "id": "76c812fb" + }, + "source": [ + "-------------\n", + "# STREAMLINE RUN CODE\n", + "The cells below run STREAMLINE phase-by-phase.\n", + "\n", + "For full runs, execute in order.\n", + "For debugging, toggle phases and rerun only downstream sections." + ] + }, + { + "cell_type": "markdown", + "id": "56b94d2c", + "metadata": { + "id": "56b94d2c" + }, + "source": [ + "## Phase 1: Data Exploration and Processing\n", + "After this cell runs, each target dataset should have:\n", + "\n", + "- initial EDA data counts and missingness summaries\n", + "- notifications for removed features/instances and added engineered features\n", + "- processed-data EDA summaries\n", + "- class/outcome balance plots when applicable\n", + "- feature correlation and univariate analysis outputs\n", + "- CV train/test partitions and feature metadata for downstream phases\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fe6c658b", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "fe6c658b", + "outputId": "47880ffa-61e9-4023-a050-942d42875b3b", + "scrolled": false + }, + "outputs": [], + "source": [ + "if RUN_PHASES[\"p1\"]:\n", + " print(\"INFO: Starting Phase 1 - Data Processing\")\n", + " P1Runner(\n", + " data_path=CFG[\"data_path\"],\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " exclude_eda_output=P1_EXCLUDE_EDA_OUTPUT,\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " outcome_type=CFG[\"outcome_type\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " match_label=CFG[\"match_label\"],\n", + " n_splits=N_SPLITS,\n", + " partition_method=P1_PARTITION_METHOD,\n", + " ignore_features=P1_IGNORE_FEATURES,\n", + " categorical_features=CFG.get(\"categorical_features\"),\n", + " quantitative_features=CFG.get(\"quantitative_features\"),\n", + " top_features=P1_TOP_FEATURES,\n", + " categorical_cutoff=P1_CATEGORICAL_CUTOFF,\n", + " sig_cutoff=P1_SIG_CUTOFF,\n", + " featureeng_missingness=P1_FEATUREENG_MISSINGNESS,\n", + " cleaning_missingness=P1_CLEANING_MISSINGNESS,\n", + " correlation_removal_threshold=P1_CORRELATION_REMOVAL_THRESHOLD,\n", + " random_state=RANDOM_STATE,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " show_plots=P1_SHOW_PLOTS,\n", + " one_hot_encoding=P1_ONE_HOT_ENCODING,\n", + " cv_provided=P1_CV_PROVIDED,\n", + " cv_input_root=P1_CV_INPUT_ROOT,\n", + " enable_plots=P1_ENABLE_PLOTS,\n", + " plot_missingness=P1_PLOT_MISSINGNESS,\n", + " plot_class_counts=P1_PLOT_CLASS_COUNTS,\n", + " plot_correlation=P1_PLOT_CORRELATION,\n", + " correlation_plot_max_features=P1_CORRELATION_PLOT_MAX_FEATURES,\n", + " plot_univariate=P1_PLOT_UNIVARIATE,\n", + " univariate_top_k=P1_UNIVARIATE_TOP_K,\n", + " plot_anomalies=P1_PLOT_ANOMALIES,\n", + " force=P1_FORCE,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 1 - Data Processing\")\n", + "else:\n", + " print(\"INFO: Phase 1 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "99bf26c6", + "metadata": { + "id": "99bf26c6" + }, + "source": [ + "## Phase 2: Impute, Scale, and Balance\n", + "After this cell runs, CV datasets are transformed according to Phase 2 settings:\n", + "\n", + "- missing values are imputed\n", + "- quantitative features are optionally scaled\n", + "- optional SMOTE/SMOTENC balancing is applied to training folds only\n", + "\n", + "The test fold is transformed using objects learned from the training fold to preserve valid CV separation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "84e249c3", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "84e249c3", + "outputId": "541be1b6-990a-485b-8add-25efb413f478" + }, + "outputs": [], + "source": [ + "if RUN_PHASES[\"p2\"]:\n", + " print(\"INFO: Starting Phase 2 - Scaling and Imputation\")\n", + " P2Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " scale_data=P2_SCALE_DATA,\n", + " impute_data=P2_IMPUTE_DATA,\n", + " multi_impute=P2_MULTI_IMPUTE,\n", + " overwrite_cv=P2_OVERWRITE_CV,\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " random_state=RANDOM_STATE,\n", + " imputer_id=P2_IMPUTER_ID,\n", + " imputer_params=P2_IMPUTER_PARAMS,\n", + " scaler_id=P2_SCALER_ID,\n", + " scaler_params=P2_SCALER_PARAMS,\n", + " smote=P2_SMOTE,\n", + " smote_method=P2_SMOTE_METHOD,\n", + " smote_sampling_strategy=P2_SMOTE_SAMPLING_STRATEGY,\n", + " smote_k_neighbors=P2_SMOTE_K_NEIGHBORS,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 2 - Scaling and Imputation\")\n", + "else:\n", + " print(\"INFO: Phase 2 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "bbb3a367", + "metadata": { + "id": "bbb3a367" + }, + "source": [ + "## Phase 3: Feature Learning\n", + "After this cell runs, learned representations such as PCA features are created per CV split. These learned features can replace or augment the original features depending on `P3_KEEP_ORIGINAL_FEATURES`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "83e93fd6", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "83e93fd6", + "outputId": "271eb9ee-a7a3-47a2-c73d-e32fd9e884ea" + }, + "outputs": [], + "source": [ + "if RUN_PHASES[\"p3\"]:\n", + " print(\"INFO: Starting Phase 3 - Feature Learning\")\n", + " P3Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " learner_id=P3_LEARNER_ID,\n", + " learner_params=P3_LEARNER_PARAMS,\n", + " feature_namespace=P3_FEATURE_NAMESPACE,\n", + " keep_original_features=P3_KEEP_ORIGINAL_FEATURES,\n", + " overwrite_cv=P3_OVERWRITE_CV,\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " random_state=RANDOM_STATE,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 3 - Feature Learning\")\n", + "else:\n", + " print(\"INFO: Phase 3 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "5e1e88fe", + "metadata": { + "id": "5e1e88fe" + }, + "source": [ + "## Phase 4: Feature Importance\n", + "After this cell runs, feature-importance scores are saved for each active method and CV split. These outputs feed Phase 5 feature selection, summary statistics, and report tables/figures.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c6de611f", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "c6de611f", + "outputId": "ff56ade9-97f8-451b-f5f1-2b8402082f57", + "scrolled": false + }, + "outputs": [], + "source": [ + "if RUN_PHASES[\"p4\"]:\n", + " p4_model_params = P4_MODELS_PARAMS\n", + " if isinstance(p4_model_params, dict):\n", + " p4_model_params = {k: dict(v) for k, v in p4_model_params.items()}\n", + " if p4_model_params.get(\"mutualinformation\", {}).get(\"outcome_type\") == \"auto\":\n", + " p4_model_params[\"mutualinformation\"][\"outcome_type\"] = CFG[\"outcome_type\"]\n", + " print(\"INFO: Starting Phase 4 - Feature Importance\")\n", + " P4Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " models=P4_MODELS,\n", + " models_params=p4_model_params,\n", + " top_k=P4_TOP_K,\n", + " threshold=P4_THRESHOLD,\n", + " keep_original_features=P4_KEEP_ORIGINAL_FEATURES,\n", + " overwrite_cv=P4_OVERWRITE_CV,\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " outcome_type=CFG[\"outcome_type\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " random_state=RANDOM_STATE,\n", + " instance_subset=P4_INSTANCE_SUBSET,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 4 - Feature Importance\")\n", + "else:\n", + " print(\"INFO: Phase 4 skipped\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85rOps65eEiR", + "metadata": { + "id": "85rOps65eEiR" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "393c1c24", + "metadata": { + "id": "393c1c24" + }, + "source": [ + "## Phase 5: Feature Selection\n", + "After this cell runs, selected feature subsets and informative feature summaries are generated. If filtering is disabled, all features continue to modeling; otherwise STREAMLINE uses the FI outputs to remove weakly supported features.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "447337ed", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "447337ed", + "outputId": "0d860a5a-a3d2-4661-a725-14989c79770f", + "scrolled": false + }, + "outputs": [], + "source": [ + "if RUN_PHASES[\"p5\"]:\n", + " print(\"INFO: Starting Phase 5 - Feature Selection\")\n", + " P5Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " algorithms=P5_ALGORITHMS,\n", + " n_splits=P5_N_SPLITS,\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " max_features_to_keep=P5_MAX_FEATURES_TO_KEEP,\n", + " filter_poor_features=P5_FILTER_POOR_FEATURES,\n", + " overwrite_cv=P5_OVERWRITE_CV,\n", + " selector_id=P5_SELECTOR_ID,\n", + " selector_params=P5_SELECTOR_PARAMS,\n", + " export_scores=P5_EXPORT_SCORES,\n", + " top_features=P5_TOP_FEATURES,\n", + " show_plots=P5_SHOW_PLOTS,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " strict_discovery=P5_STRICT_DISCOVERY,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 5 - Feature Selection\")\n", + "else:\n", + " print(\"INFO: Phase 5 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "3d518662", + "metadata": { + "id": "3d518662" + }, + "source": [ + "## Phase 6: Modeling\n", + "After this cell runs, STREAMLINE trains and evaluates each requested model across CV splits. Outputs include trained model pickles, metrics, ROC/PRC or regression artifacts, Optuna trial summaries, and model feature-importance estimates.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5bf4057", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "f5bf4057", + "outputId": "5ba58730-982a-4ede-cb56-8a790976b5d0", + "scrolled": false + }, + "outputs": [], + "source": [ + "if RUN_PHASES[\"p6\"]:\n", + " print(\"INFO: Starting Phase 6 - Modeling\")\n", + " P6Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " outcome_type=P6_OUTCOME_TYPE or CFG[\"outcome_type\"],\n", + " model_type=P6_MODEL_TYPE,\n", + " instance_label=CFG[\"instance_label\"],\n", + " n_splits=N_SPLITS,\n", + " models=P6_MODELS or CFG[\"p6_models\"],\n", + " model_params_json=P6_MODEL_PARAMS_JSON,\n", + " calibrate=P6_CALIBRATE,\n", + " calibrate_method=P6_CALIBRATE_METHOD,\n", + " calibrate_cv=P6_CALIBRATE_CV,\n", + " scoring_metric=P6_SCORING_METRIC or CFG[\"p6_scoring_metric\"],\n", + " metric_direction=P6_METRIC_DIRECTION or CFG[\"p6_metric_direction\"],\n", + " n_trials=P6_N_TRIALS,\n", + " timeout=P6_TIMEOUT,\n", + " training_subsample=P6_TRAINING_SUBSAMPLE,\n", + " uniform_fi=P6_UNIFORM_FI,\n", + " save_plot=P6_SAVE_PLOT,\n", + " random_state=RANDOM_STATE,\n", + " bypass_one_hot_for_native_models=P6_BYPASS_ONE_HOT_FOR_NATIVE_MODELS,\n", + " native_categorical_models=P6_NATIVE_CATEGORICAL_MODELS,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 6 - Modeling\")\n", + "else:\n", + " print(\"INFO: Phase 6 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "6d9ec8b1", + "metadata": { + "id": "6d9ec8b1" + }, + "source": [ + "## Phase 7: Ensembles\n", + "Optional phase. After this cell runs, ensemble metrics and curves are generated from Phase 6 base models when enabled. The notebook skips this phase for regression unless `ALLOW_P7_FOR_REGRESSION=True`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e761233e", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "e761233e", + "outputId": "4fb6aae9-b0d3-4eb1-ba0a-43d1df815b9c" + }, + "outputs": [], + "source": [ + "print(\"INFO: Evaluating Phase 7 - Ensembles\")\n", + "run_p7 = RUN_PHASES[\"p7\"] and P7_ENABLED\n", + "if CFG[\"task_family\"] == \"regression\" and not ALLOW_P7_FOR_REGRESSION:\n", + " run_p7 = False\n", + " print(\"INFO: Phase 7 skipped for regression (ALLOW_P7_FOR_REGRESSION=False)\")\n", + "\n", + "if run_p7:\n", + " print(\"INFO: Starting Phase 7 - Ensembles\")\n", + " P7Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " n_splits=N_SPLITS,\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " ensembles=P7_ENSEMBLES,\n", + " base_models=(P7_BASE_MODELS or CFG[\"p6_models\"]),\n", + " meta_train_source=P7_META_TRAIN_SOURCE,\n", + " calibrate=P7_CALIBRATE,\n", + " calibrate_method=P7_CALIBRATE_METHOD,\n", + " calibrate_cv=P7_CALIBRATE_CV,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " random_state=RANDOM_STATE,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 7 - Ensembles\")\n", + "elif RUN_PHASES[\"p7\"]:\n", + " print(\"INFO: Phase 7 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "70847b9b", + "metadata": { + "id": "70847b9b" + }, + "source": [ + "## Phase 8: Summary Statistics\n", + "After this cell runs, STREAMLINE creates per-dataset performance summaries and post-analysis figures, including model comparison plots and feature-importance summaries used by the final report.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d9ae7aaf", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "d9ae7aaf", + "outputId": "a8803f4a-1f5a-49e3-ce3e-aa21c125aa1c", + "scrolled": false + }, + "outputs": [], + "source": [ + "if RUN_PHASES[\"p8\"]:\n", + " print(\"INFO: Starting Phase 8 - Summary Statistics\")\n", + " P8Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " outcome_type=CFG[\"outcome_type\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " n_splits=N_SPLITS,\n", + " scoring_metric=P8_SCORING_METRIC or CFG[\"p8_scoring_metric\"],\n", + " metric_weight=P8_METRIC_WEIGHT or CFG[\"p8_metric_weight\"],\n", + " top_features=P8_TOP_FEATURES,\n", + " sig_cutoff=P8_SIG_CUTOFF,\n", + " scale_data=P8_SCALE_DATA,\n", + " exclude_plots=P8_EXCLUDE_PLOTS,\n", + " show_plots=P8_SHOW_PLOTS,\n", + " include_ensembles=run_p7 if P8_INCLUDE_ENSEMBLES is None else P8_INCLUDE_ENSEMBLES,\n", + " multiclass_average=P8_MULTICLASS_AVERAGE,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 8 - Summary Statistics\")\n", + "else:\n", + " print(\"INFO: Phase 8 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "c6659ab3", + "metadata": { + "id": "c6659ab3" + }, + "source": [ + "## Phase 9: Dataset Comparison\n", + "Optional phase, used only when two or more target datasets were analyzed. It compares performance distributions across datasets and saves outputs under `DatasetComparisons/`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "efe4bc4e", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "efe4bc4e", + "outputId": "4d7df6c8-9cd6-4649-bf64-f22a54f91085", + "scrolled": false + }, + "outputs": [], + "source": [ + "def list_dataset_dirs(exp_root: Path):\n", + " ignore = {\"jobs\", \"logs\", \"jobsCompleted\", \"dask_logs\", \"DatasetComparisons\", \"reporting\", \"reporting_replication\"}\n", + " if not exp_root.exists():\n", + " return []\n", + " return [\n", + " p for p in sorted(exp_root.iterdir())\n", + " if p.is_dir() and p.name not in ignore and (p / \"CVDatasets\").is_dir()\n", + " ]\n", + "\n", + "if RUN_PHASES[\"p9\"]:\n", + " print(\"INFO: Starting Phase 9 - Dataset Comparison\")\n", + " ds_count = len(list_dataset_dirs(EXP_ROOT))\n", + " if ds_count >= 2:\n", + " P9Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " outcome_type=CFG[\"outcome_type\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " sig_cutoff=P9_SIG_CUTOFF,\n", + " show_plots=P9_SHOW_PLOTS,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 9 - Dataset Comparison\")\n", + " else:\n", + " print(f\"INFO: Phase 9 skipped - requires >=2 datasets, found {ds_count}\")\n", + "else:\n", + " print(\"INFO: Phase 9 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "1ac8f00a", + "metadata": { + "id": "1ac8f00a" + }, + "source": [ + "## Phase 10: Replication\n", + "Optional phase, used when replication data is available. Trained models are re-evaluated on the same replication dataset(s), giving a uniform external or held-out performance check.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f9e7fd31", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "f9e7fd31", + "outputId": "f33e8e62-30eb-4e5d-a378-9e30a05a3a82", + "scrolled": false + }, + "outputs": [], + "source": [ + "if RUN_PHASES[\"p10\"]:\n", + " print(\"INFO: Starting Phase 10 - Replication\")\n", + " rep_path = Path(P10_REP_DATA_PATH or CFG[\"rep_data_path\"])\n", + " data_for_rep = Path(P10_DATASET_FOR_REP or CFG[\"dataset_for_rep\"])\n", + " p10_match_label = P10_MATCH_LABEL if P10_MATCH_LABEL is not None else CFG[\"match_label\"]\n", + " if rep_path.exists() and data_for_rep.exists():\n", + " P10Runner(\n", + " rep_data_path=str(rep_path),\n", + " dataset_for_rep=str(data_for_rep),\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " outcome_label=P10_OUTCOME_LABEL,\n", + " instance_label=P10_INSTANCE_LABEL,\n", + " match_label=p10_match_label,\n", + " exclude_plots=P10_EXCLUDE_PLOTS,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " show_plots=P10_SHOW_PLOTS,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 10 - Replication\")\n", + " else:\n", + " print(\"INFO: Phase 10 skipped - replication path or dataset_for_rep not found\")\n", + "else:\n", + " print(\"INFO: Phase 10 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "47049373", + "metadata": { + "id": "47049373" + }, + "source": [ + "## Phase 11: Reporting\n", + "After this cell runs, report artifacts are generated:\n", + "\n", + "- standard testing-data report under `reporting/`\n", + "- replication report under `reporting_replication/` when Phase 10 was run\n", + "\n", + "The reports summarize actual run settings, data-processing changes, feature engineering/selection, model performance, and replication results where available.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "721ad303", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "721ad303", + "outputId": "bd8458b8-63ce-45b5-c4b1-2190a03891e7" + }, + "outputs": [], + "source": [ + "# Keep phase logs verbose globally, but reduce report-phase noise.\n", + "_report_logger = logging.getLogger()\n", + "_prev_log_level = _report_logger.level\n", + "if RUN_PHASES[\"p11\"] or RUN_PHASES[\"p11_replication\"]:\n", + " _report_logger.setLevel(logging.WARNING)\n", + "\n", + "p11_report_modes = {m.strip().lower() for m in str(P11_REPORT_MODES).split(\",\") if m.strip()}\n", + "\n", + "try:\n", + " if RUN_PHASES[\"p11\"] and \"standard\" in p11_report_modes:\n", + " print(\"INFO: Starting Phase 11 - Reporting (standard)\")\n", + " P11Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " experiment_path=str(EXP_ROOT),\n", + " reporting_dir=P11_REPORTING_DIR,\n", + " report_mode=P11_REPORT_MODE_STANDARD,\n", + " outcome_label=P11_OUTCOME_LABEL or CFG[\"outcome_label\"],\n", + " outcome_type=P11_OUTCOME_TYPE or CFG[\"outcome_type\"],\n", + " instance_label=P11_INSTANCE_LABEL if P11_INSTANCE_LABEL is not None else CFG[\"instance_label\"],\n", + " make_pdf=P11_MAKE_PDF,\n", + " enable_plots=P11_ENABLE_PLOTS,\n", + " reuse_existing_figures=P11_REUSE_EXISTING_FIGURES,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 11 - Reporting (standard)\")\n", + " else:\n", + " print(\"INFO: Standard report skipped\")\n", + "\n", + " if RUN_PHASES[\"p11_replication\"] and \"replication\" in p11_report_modes:\n", + " print(\"INFO: Starting Phase 11 - Reporting (replication)\")\n", + " P11Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " experiment_path=str(EXP_ROOT),\n", + " reporting_dir=P11_REPORTING_DIR,\n", + " report_mode=P11_REPORT_MODE_REPLICATION,\n", + " outcome_label=P11_OUTCOME_LABEL or CFG[\"outcome_label\"],\n", + " outcome_type=P11_OUTCOME_TYPE or CFG[\"outcome_type\"],\n", + " instance_label=P11_INSTANCE_LABEL if P11_INSTANCE_LABEL is not None else CFG[\"instance_label\"],\n", + " make_pdf=P11_MAKE_PDF,\n", + " enable_plots=P11_ENABLE_PLOTS,\n", + " reuse_existing_figures=P11_REUSE_EXISTING_FIGURES,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 11 - Reporting (replication)\")\n", + " else:\n", + " print(\"INFO: Replication report skipped\")\n", + "finally:\n", + " _report_logger.setLevel(_prev_log_level)\n", + "\n", + "print(\"INFO: Pipeline run complete\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "29b6a5d0", + "metadata": { + "id": "29b6a5d0" + }, + "source": [ + "## Output Summary\n", + "This final check prints the experiment folder and expected report paths before the download cells. If a report path says `exists=False`, verify that Phase 11 ran and that earlier phases completed successfully.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5a72f2e7", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5a72f2e7", + "outputId": "2eaba17d-449b-4b80-93b1-23ad11dc2af5" + }, + "outputs": [], + "source": [ + "exp_root = Path(CFG[\"output_path\"]) / CFG[\"experiment_name\"]\n", + "std_pdf = exp_root / \"reporting\" / f\"{CFG['experiment_name']}_STREAMLINE_Report.pdf\"\n", + "rep_pdf = exp_root / \"reporting_replication\" / f\"{CFG['experiment_name']}_STREAMLINE_Replication_Report.pdf\"\n", + "\n", + "print(f\"Experiment root: {exp_root}\")\n", + "print(f\"Standard report: {std_pdf} (exists={std_pdf.exists()})\")\n", + "print(f\"Replication report:{rep_pdf} (exists={rep_pdf.exists()})\")" + ] + }, + { + "cell_type": "markdown", + "id": "42mKPJhZgyZs", + "metadata": { + "id": "42mKPJhZgyZs" + }, + "source": [ + "### Download and Open PDF Summary Report(s)\n", + "\n", + "Run this cell in Colab to download the generated standard and replication reports when they exist.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "F8E9qufXgi3v", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 71 + }, + "id": "F8E9qufXgi3v", + "outputId": "5a91a334-5aa2-4cf3-d98f-07d526bf018b" + }, + "outputs": [], + "source": [ + "from google.colab import files\n", + "from IPython.display import IFrame, display\n", + "from pathlib import Path\n", + "\n", + "# Define paths based on previous CFG and EXP_ROOT\n", + "exp_root = Path(CFG['output_path']) / CFG['experiment_name']\n", + "std_pdf = exp_root / \"reporting\" / f\"{CFG['experiment_name']}_STREAMLINE_Report.pdf\"\n", + "rep_pdf = exp_root / \"reporting_replication\" / f\"{CFG['experiment_name']}_STREAMLINE_Replication_Report.pdf\"\n", + "\n", + "print(f\"Checking for reports in: {exp_root}\")\n", + "\n", + "# Download Standard Report\n", + "if std_pdf.exists():\n", + " print(\"Downloading Standard Report...\")\n", + " files.download(str(std_pdf))\n", + "else:\n", + " print(\"Standard STREAMLINE report PDF not found.\")\n", + "\n", + "# Download Replication Report\n", + "if rep_pdf.exists():\n", + " print(\"Downloading Replication Report...\")\n", + " files.download(str(rep_pdf))\n", + "else:\n", + " print(\"Replication STREAMLINE report PDF not found (this is normal if replication mode wasn't run).\")" + ] + }, + { + "cell_type": "markdown", + "id": "uIHEL7ssg22O", + "metadata": { + "id": "uIHEL7ssg22O" + }, + "source": [ + "### Zip the experiment folder and download." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "Zg9H2-V0gmpb", + "metadata": { + "id": "Zg9H2-V0gmpb" + }, + "outputs": [], + "source": [ + "import shutil\n", + "from google.colab import files\n", + "from pathlib import Path\n", + "\n", + "# Define the folder to zip and the output name\n", + "exp_root = Path(CFG['output_path']) / CFG['experiment_name']\n", + "zip_filename = f\"{CFG['experiment_name']}_results\"\n", + "\n", + "if exp_root.exists():\n", + " print(f\"Zipping {exp_root}...\")\n", + " # Create a zip archive of the experiment directory\n", + " shutil.make_archive(zip_filename, 'zip', exp_root)\n", + "\n", + " print(f\"Downloading {zip_filename}.zip...\")\n", + " files.download(f\"{zip_filename}.zip\")\n", + "else:\n", + " print(f\"Experiment folder not found at: {exp_root}\")" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/STREAMLINE_Notebook.ipynb b/STREAMLINE_Notebook.ipynb new file mode 100644 index 00000000..72d3861c --- /dev/null +++ b/STREAMLINE_Notebook.ipynb @@ -0,0 +1,4322 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3fa8c944", + "metadata": {}, + "source": [ + "![STREAMLINE](https://github.com/UrbsLab/STREAMLINE/blob/main/docs/source/pictures/STREAMLINE_Logo_Full.png?raw=true)\n", + "\n", + "# STREAMLINE v1.0.0 Jupyter Notebook\n", + "\n", + "STREAMLINE is an end-to-end automated machine learning workflow that helps users run, interpret, and apply a rigorous tabular-data analysis without hand-building every preprocessing, modeling, evaluation, and reporting step.\n", + "\n", + "This local notebook can run one of the included UCI demos or a custom dataset from folders on your machine. It is meant to be run from the STREAMLINE repository root after installing project requirements.\n", + "\n", + "Included demos:\n", + "\n", + "- `demo_binary`: HCC Survival binary classification\n", + "- `demo_multiclass`: Student Dropout and Academic Success multiclass classification\n", + "- `demo_regression`: Auto MPG regression\n", + "\n", + "Normal demo data folders contain deterministic 80% training splits; matching replication folders contain held-out 20% replication splits.\n" + ] + }, + { + "cell_type": "markdown", + "id": "b1bd0fcd", + "metadata": {}, + "source": [ + "## Run Instructions\n", + "\n", + "### Demo Run\n", + "\n", + "1. Set `RUN_MODE` to `demo_binary`, `demo_multiclass`, or `demo_regression`.\n", + "2. Keep `OUTPUT_PATH = None` to write outputs to `/out`, or provide another folder.\n", + "3. Run cells from top to bottom.\n", + "\n", + "The demo settings use 3 CV folds and compact model lists so the notebook can be used as a practical tutorial. You can optionally change non-dataset parameters below, such as phase toggles, CV folds, feature-importance methods, or modeling algorithms.\n", + "\n", + "### Custom Dataset Run\n", + "\n", + "1. Set `RUN_MODE` to `custom_classification` or `custom_regression`.\n", + "2. Update the `CUSTOM_*` paths and labels below.\n", + "3. Optional replication data can be supplied through `CUSTOM_REPLICATION_PATH` and `CUSTOM_DATASET_FOR_REP`.\n", + "4. Run cells from top to bottom.\n", + "\n", + "Target data folders may contain one or more `.csv`, `.tsv`, or `.txt` datasets. All datasets in the same run should use the same outcome, instance, and match column names.\n", + "\n", + "The top parameter cells are the normal editing surface. The phase cells are intentionally explicit so the notebook remains useful for teaching, debugging, and partial reruns.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8390c562", + "metadata": {}, + "outputs": [], + "source": [ + "# [run] section: choose which built-in demo or custom workflow to run.\n", + "RUN_MODE = \"demo_binary\"\n", + "# Supported:\n", + "# - demo_binary\n", + "# - demo_multiclass\n", + "# - demo_regression\n", + "# - custom_classification\n", + "# - custom_regression\n", + "# Backward-compatible alias: demo_classification -> demo_multiclass\n", + "\n", + "# [run] output_path / experiment_name\n", + "EXPERIMENT_NAME = \"JupyterRun\"\n", + "OUTPUT_PATH = None # None -> defaults to /out\n" + ] + }, + { + "cell_type": "markdown", + "id": "199df42a", + "metadata": {}, + "source": [ + "### Repository and Environment Parameters\n", + "\n", + "Use these settings to control local environment behavior.\n", + "\n", + "- `REPO_DIR_OVERRIDE`: explicit repo path if auto-detection fails.\n", + "- `INSTALL_REQUIREMENTS`: install from `requirements.txt` in the current Python environment.\n", + "- `RUN_CLUSTER`: `Serial` is simplest for notebooks; `Parallel` uses local joblib; `Local` uses local Dask.\n", + "- `P1_FORCE`: rebuilds the experiment folder when Phase 1 is rerun.\n", + "\n", + "For small notebook demos, `Serial` is usually easiest to inspect. For larger runs, config/CLI execution is often a better fit.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4a480b33", + "metadata": {}, + "outputs": [], + "source": [ + "REPO_DIR_OVERRIDE = None\n", + "INSTALL_REQUIREMENTS = False\n", + "\n", + "# [run] execution parameters\n", + "RUN_CLUSTER = \"Serial\" # Serial, Parallel (joblib), Local (Dask), BashSLURM, BashLSF, or a named Dask cluster\n", + "QUEUE = \"defq\"\n", + "RESERVED_MEMORY = 4\n", + "N_SPLITS = 3\n", + "RANDOM_STATE = 42\n", + "\n", + "# Kept as aliases because runner cells use PHASE_* names.\n", + "PHASE_QUEUE = QUEUE\n", + "PHASE_RESERVED_MEMORY_GB = RESERVED_MEMORY\n" + ] + }, + { + "cell_type": "markdown", + "id": "94511f53", + "metadata": {}, + "source": [ + "### Custom Data Parameters\n", + "\n", + "Used only for `custom_*` modes.\n", + "\n", + "- target data folder\n", + "- optional replication data folder\n", + "- reference training dataset for replication mapping\n", + "- labels for outcome, instance id, and matching/grouping\n", + "- optional categorical/quantitative feature-list files or lists\n", + "\n", + "If categorical/quantitative feature lists are left as `None`, STREAMLINE uses `P1_CATEGORICAL_CUTOFF` and binary-feature detection to infer feature types.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1ae40704", + "metadata": {}, + "outputs": [], + "source": [ + "CUSTOM_DATA_PATH = \"/absolute/path/to/target_data_folder\"\n", + "CUSTOM_REPLICATION_PATH = \"/absolute/path/to/replication_data_folder\"\n", + "CUSTOM_DATASET_FOR_REP = \"/absolute/path/to/target_data_folder/train_dataset.csv\"\n", + "\n", + "CUSTOM_OUTCOME_LABEL = \"Class\"\n", + "CUSTOM_INSTANCE_LABEL = None\n", + "CUSTOM_MATCH_LABEL = None\n", + "CUSTOM_CATEGORICAL_FEATURES = None\n", + "CUSTOM_QUANTITATIVE_FEATURES = None\n", + "\n", + "CUSTOM_CLASSIFICATION_TYPE = \"Binary\" # Binary or Multiclass\n", + "CUSTOM_CLASSIFICATION_MODELS = \"NB,LR,DT\"\n", + "CUSTOM_REGRESSION_MODELS = \"LR,RF\"\n" + ] + }, + { + "cell_type": "markdown", + "id": "ff33e0d2", + "metadata": {}, + "source": [ + "----------------------\n", + "## Non-Essential Run Parameters\n", + "\n", + "### Phase Toggles\n", + "\n", + "Use toggles to rerun only selected phases during iteration. For a complete fresh run, leave everything `True`.\n", + "\n", + "`ALLOW_P7_FOR_REGRESSION` controls whether the ensemble phase runs for regression workflows. Leave it `False` unless regression ensembles are explicitly supported for the run you are testing.\n", + "\n", + "If you skip an upstream phase, make sure its expected output already exists from a previous run.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a6fe9b8d", + "metadata": {}, + "outputs": [], + "source": [ + "# [phases] section\n", + "PHASE_ORDER = \"p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11\"\n", + "RUN_PHASES = {\n", + " \"p1\": True,\n", + " \"p2\": True,\n", + " \"p3\": True,\n", + " \"p4\": True,\n", + " \"p5\": True,\n", + " \"p6\": True,\n", + " \"p7\": True,\n", + " \"p8\": True,\n", + " \"p9\": True,\n", + " \"p10\": True,\n", + " \"p11\": True,\n", + " \"p11_replication\": True,\n", + "}\n", + "\n", + "# For regression, set True only if you explicitly want to run ensembles.\n", + "ALLOW_P7_FOR_REGRESSION = False\n" + ] + }, + { + "cell_type": "markdown", + "id": "76b6d8e4", + "metadata": {}, + "source": [ + "--------------\n", + "### Phase 1 - Data Exploration and Processing Parameters\n", + "\n", + "Phase 1 performs initial EDA, cleaning, feature engineering, feature-type handling, and CV partitioning.\n", + "\n", + "Typical outputs include data-count summaries, missingness summaries, class/outcome summaries, correlation plots, univariate analysis, and saved CV train/test files. Feature type settings matter downstream because categorical features may be one-hot encoded, passed to native categorical models, or passed to ReBATE methods as categorical indexes.\n", + "\n", + "When `P1_CATEGORICAL_FEATURES` and `P1_QUANTITATIVE_FEATURES` are `None`, STREAMLINE infers feature type using `P1_CATEGORICAL_CUTOFF`: non-binary features with more unique values than the cutoff are treated as quantitative, while binary features are treated as categorical by default.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f81157d1", + "metadata": {}, + "outputs": [], + "source": [ + "# [p1] Data Exploration and Processing parameters\n", + "P1_EXCLUDE_EDA_OUTPUT = None\n", + "P1_PARTITION_METHOD = \"Stratified\"\n", + "P1_IGNORE_FEATURES = None\n", + "P1_CATEGORICAL_FEATURES = None\n", + "P1_QUANTITATIVE_FEATURES = None\n", + "P1_TOP_FEATURES = 20\n", + "P1_CATEGORICAL_CUTOFF = 10\n", + "P1_SIG_CUTOFF = 0.05\n", + "P1_FEATUREENG_MISSINGNESS = 0.5\n", + "P1_CLEANING_MISSINGNESS = 0.5\n", + "P1_CORRELATION_REMOVAL_THRESHOLD = 1.0\n", + "P1_SHOW_PLOTS = True\n", + "P1_ONE_HOT_ENCODING = True\n", + "P1_CV_PROVIDED = False\n", + "P1_CV_INPUT_ROOT = None\n", + "P1_ENABLE_PLOTS = True\n", + "P1_PLOT_MISSINGNESS = True\n", + "P1_PLOT_CLASS_COUNTS = True\n", + "P1_PLOT_CORRELATION = True\n", + "P1_CORRELATION_PLOT_MAX_FEATURES = 200\n", + "P1_PLOT_UNIVARIATE = True\n", + "P1_UNIVARIATE_TOP_K = 20\n", + "P1_PLOT_ANOMALIES = True\n", + "P1_FORCE = True\n" + ] + }, + { + "cell_type": "markdown", + "id": "169f78ba", + "metadata": {}, + "source": [ + "### Phase 2 - Impute, Scale, and Balance Parameters\n", + "\n", + "Phase 2 transforms each CV split after Phase 1. Missing-value imputation and scaling are fit on training folds and applied to the corresponding test folds.\n", + "\n", + "Optional SMOTE/SMOTENC oversampling is applied only to training folds and only for classification outcomes. With `P2_SMOTE_METHOD = \"auto\"`, STREAMLINE uses SMOTENC when categorical features are present and standard SMOTE otherwise.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a1ecb312", + "metadata": {}, + "outputs": [], + "source": [ + "# [p2] Impute, Scale, and Balance parameters\n", + "P2_SCALE_DATA = True\n", + "P2_IMPUTE_DATA = True\n", + "P2_MULTI_IMPUTE = False\n", + "P2_OVERWRITE_CV = True\n", + "P2_IMPUTER_ID = None\n", + "P2_IMPUTER_PARAMS = {}\n", + "P2_SCALER_ID = None\n", + "P2_SCALER_PARAMS = {}\n", + "P2_SMOTE = False\n", + "P2_SMOTE_METHOD = \"auto\"\n", + "P2_SMOTE_SAMPLING_STRATEGY = \"auto\"\n", + "P2_SMOTE_K_NEIGHBORS = 5\n" + ] + }, + { + "cell_type": "markdown", + "id": "da387ca3", + "metadata": {}, + "source": [ + "### Phase 3 - Feature Learning Parameters\n", + "\n", + "Phase 3 adds learned representations such as PCA features. Learned transformations are fit within each training fold and applied to the matching test fold, preserving CV separation.\n", + "\n", + "`P3_KEEP_ORIGINAL_FEATURES=True` appends learned features to the original feature set. Set it to `False` when you want downstream phases to use only the learned representation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5b94200a", + "metadata": {}, + "outputs": [], + "source": [ + "# [p3] Feature Learning parameters\n", + "P3_LEARNER_ID = \"pca\"\n", + "P3_LEARNER_PARAMS = {}\n", + "P3_FEATURE_NAMESPACE = \"FL_PCA\"\n", + "P3_KEEP_ORIGINAL_FEATURES = True\n", + "P3_OVERWRITE_CV = True\n" + ] + }, + { + "cell_type": "markdown", + "id": "bcff7f64", + "metadata": {}, + "source": [ + "### Phase 4 - Feature Importance Parameters\n", + "\n", + "Phase 4 estimates filter-based feature importance within each CV split. These scores are later used for feature selection and reporting.\n", + "\n", + "The demo/config default uses Mutual Information and MultiSWRFDB. Set `P4_MODELS = None` to run every registered feature-importance method. `P4_INSTANCE_SUBSET` limits expensive ReBATE-style methods; leave it as `None` to use all training instances.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a5f8d8f0", + "metadata": {}, + "outputs": [], + "source": [ + "# [p4] Feature Importance parameters\n", + "P4_MODELS = \"mutualinformation,multiswrfdb\"\n", + "P4_MODELS_PARAMS = {\"mutualinformation\": {\"outcome_type\": \"auto\"}, \"multiswrfdb\": {\"n_jobs\": 1}}\n", + "P4_TOP_K = None\n", + "P4_THRESHOLD = None\n", + "P4_KEEP_ORIGINAL_FEATURES = False\n", + "P4_OVERWRITE_CV = True\n", + "P4_INSTANCE_SUBSET = None\n" + ] + }, + { + "cell_type": "markdown", + "id": "715b0d7b", + "metadata": {}, + "source": [ + "### Phase 5 - Feature Selection Parameters\n", + "\n", + "Phase 5 performs collective feature selection before modeling. When `P5_FILTER_POOR_FEATURES = False`, all features continue to modeling.\n", + "\n", + "When filtering is enabled, STREAMLINE removes features that have no evidence of importance across the active FI methods. If `P5_MAX_FEATURES_TO_KEEP` is an integer, STREAMLINE keeps a capped set of top-ranked features from the available FI outputs. `P5_ALGORITHMS = \"auto\"` is recommended because it discovers whichever FI methods were actually run.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3ba0995b", + "metadata": {}, + "outputs": [], + "source": [ + "# [p5] Feature Selection parameters\n", + "P5_ALGORITHMS = \"auto\"\n", + "P5_N_SPLITS = N_SPLITS\n", + "P5_MAX_FEATURES_TO_KEEP = 2000\n", + "P5_FILTER_POOR_FEATURES = True\n", + "P5_OVERWRITE_CV = False\n", + "P5_SELECTOR_ID = \"default\"\n", + "P5_SELECTOR_PARAMS = {}\n", + "P5_EXPORT_SCORES = True\n", + "P5_TOP_FEATURES = 20\n", + "P5_SHOW_PLOTS = True\n", + "P5_STRICT_DISCOVERY = False\n" + ] + }, + { + "cell_type": "markdown", + "id": "1542f877", + "metadata": {}, + "source": [ + "### Phase 6 - Modeling Parameters\n", + "\n", + "Phase 6 trains and evaluates the requested algorithms across CV folds.\n", + "\n", + "- `P6_N_TRIALS` and `P6_TIMEOUT` control Optuna hyperparameter search. The notebook demo default is `50` trials and `300` seconds so Colab runs stay practical; use `200` and `900` for fuller config-style runs.\n", + "- `P6_TRAINING_SUBSAMPLE` can limit expensive models on large datasets.\n", + "- `P6_UNIFORM_FI=True` forces permutation feature importance for all models and can be slow.\n", + "- `P6_CALIBRATE=True` applies probability calibration for classification models.\n", + "\n", + "The demo model lists are intentionally small (`NB,LR,DT` for classification and `LR,RF` for regression). Add more models when runtime is acceptable. The notebook defaults are tuned for demo/tutorial runtime; increase `P6_N_TRIALS` and `P6_TIMEOUT` for fuller local research runs. If Phase 1 one-hot encoding is disabled, requested models should be native-categorical compatible.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4dcc3e45", + "metadata": {}, + "outputs": [], + "source": [ + "# [p6] Modeling parameters\n", + "# None values below use the selected RUN_MODE defaults from CFG.\n", + "P6_OUTCOME_TYPE = None\n", + "P6_MODEL_TYPE = None\n", + "P6_MODELS = None\n", + "P6_MODEL_PARAMS_JSON = None\n", + "P6_CALIBRATE = False\n", + "P6_CALIBRATE_METHOD = \"sigmoid\"\n", + "P6_CALIBRATE_CV = 5\n", + "P6_SCORING_METRIC = None\n", + "P6_METRIC_DIRECTION = \"maximize\"\n", + "P6_N_TRIALS = 50\n", + "P6_TIMEOUT = 300\n", + "P6_TRAINING_SUBSAMPLE = 0\n", + "P6_UNIFORM_FI = False\n", + "P6_SAVE_PLOT = False\n", + "P6_BYPASS_ONE_HOT_FOR_NATIVE_MODELS = False\n", + "P6_NATIVE_CATEGORICAL_MODELS = \"CGB,ExSTraCS\"\n" + ] + }, + { + "cell_type": "markdown", + "id": "4406e61a", + "metadata": {}, + "source": [ + "### Phase 7 - Ensemble Parameters\n", + "\n", + "Phase 7 builds ensemble classifiers from Phase 6 base-model predictions. Hard voting, soft voting, and stacking are available for classification workflows.\n", + "\n", + "Regression ensemble support is intentionally guarded in this notebook by `ALLOW_P7_FOR_REGRESSION`; leave that off unless regression ensemble support is explicitly implemented for the run you are testing.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "bee57b4d", + "metadata": {}, + "outputs": [], + "source": [ + "# [p7] Ensemble parameters\n", + "P7_ENABLED = True\n", + "P7_ENSEMBLES = \"hard_voting,soft_voting,stack_lr\"\n", + "P7_BASE_MODELS = None # None uses the selected RUN_MODE Phase 6 model list.\n", + "P7_META_TRAIN_SOURCE = \"train\"\n", + "P7_CALIBRATE = 0\n", + "P7_CALIBRATE_METHOD = \"sigmoid\"\n", + "P7_CALIBRATE_CV = 5\n" + ] + }, + { + "cell_type": "markdown", + "id": "b484ed61", + "metadata": {}, + "source": [ + "### Phase 8 - Summary Statistics Parameters\n", + "\n", + "Phase 8 summarizes testing-fold model performance and creates post-analysis figures. Outputs may include ROC/PRC plots for classification, regression summaries, metric boxplots, model feature-importance plots, and composite feature-importance summaries.\n", + "\n", + "`P8_MULTICLASS_AVERAGE` controls multiclass ROC/PR aggregation where applicable.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a34404a6", + "metadata": {}, + "outputs": [], + "source": [ + "# [p8] Summary Statistics parameters\n", + "# None metric values use the selected RUN_MODE defaults from CFG.\n", + "P8_SCORING_METRIC = None\n", + "P8_METRIC_WEIGHT = None\n", + "P8_TOP_FEATURES = 40\n", + "P8_SIG_CUTOFF = 0.05\n", + "P8_SCALE_DATA = True\n", + "P8_EXCLUDE_PLOTS = None\n", + "P8_SHOW_PLOTS = True\n", + "P8_INCLUDE_ENSEMBLES = None # None follows whether Phase 7 actually ran.\n", + "P8_MULTICLASS_AVERAGE = \"micro\"\n" + ] + }, + { + "cell_type": "markdown", + "id": "e1a47d16", + "metadata": {}, + "source": [ + "### Phase 9 - Dataset Comparison Parameters\n", + "\n", + "Phase 9 is useful only when an experiment includes more than one target dataset. It compares model performance distributions across datasets and writes comparison outputs under `DatasetComparisons/`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e4acfa74", + "metadata": {}, + "outputs": [], + "source": [ + "# [p9] Dataset Comparison parameters\n", + "P9_SIG_CUTOFF = 0.05\n", + "P9_SHOW_PLOTS = True\n" + ] + }, + { + "cell_type": "markdown", + "id": "c2a39d49", + "metadata": {}, + "source": [ + "### Phase 10 - Replication Parameters\n", + "\n", + "Phase 10 evaluates previously trained models on external or held-out replication datasets. This gives a uniform evaluation on the same new data and can be more useful for selecting a final model than comparing only CV test folds.\n", + "\n", + "The included UCI demos use deterministic held-out 20% replication splits rather than independent external datasets.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "7a23536a", + "metadata": {}, + "outputs": [], + "source": [ + "# [p10] Replication parameters\n", + "# None path/label values use the selected RUN_MODE defaults from CFG/metadata.\n", + "P10_REP_DATA_PATH = None\n", + "P10_DATASET_FOR_REP = None\n", + "P10_MATCH_LABEL = None\n", + "P10_OUTCOME_LABEL = None\n", + "P10_INSTANCE_LABEL = None\n", + "P10_EXCLUDE_PLOTS = None\n", + "P10_SHOW_PLOTS = True\n" + ] + }, + { + "cell_type": "markdown", + "id": "eab0f21e", + "metadata": {}, + "source": [ + "### Phase 11 - Reporting Parameters\n", + "\n", + "Phase 11 generates PDF report artifacts for the standard testing-data report and, when available, the replication report.\n", + "\n", + "`P11_REUSE_EXISTING_FIGURES=True` speeds up report regeneration when plots have already been made. Disable it when you want plots regenerated from scratch.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c5799089", + "metadata": {}, + "outputs": [], + "source": [ + "# [p11] Reporting parameters\n", + "P11_REPORT_MODES = \"standard,replication\"\n", + "P11_REPORTING_DIR = None\n", + "P11_REPORT_MODE_STANDARD = \"standard\"\n", + "P11_REPORT_MODE_REPLICATION = \"replication\"\n", + "P11_OUTCOME_LABEL = None\n", + "P11_OUTCOME_TYPE = None\n", + "P11_INSTANCE_LABEL = None\n", + "P11_MAKE_PDF = True\n", + "P11_ENABLE_PLOTS = True\n", + "P11_REUSE_EXISTING_FIGURES = True\n" + ] + }, + { + "cell_type": "markdown", + "id": "647b80e2", + "metadata": {}, + "source": [ + "-------------\n", + "## Notebook Housekeeping\n", + "\n", + "This setup section resolves paths, optionally installs dependencies, imports phase runners, and prepares logging.\n", + "\n", + "Most users should not edit below this point unless they are debugging the notebook itself. If dependency versions look wrong, restart the kernel after installation and rerun from the top.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "7d5f399e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dependency versions:\n", + "numpy: 2.4.6\n", + "pandas: 3.0.3\n", + "skrebate: 0.8.2\n", + "kaleido: 1.3.0\n", + "INFO: Notebook logging configured at INFO level (phases 1-10).\n", + "REPO_DIR: /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New\n", + "OUTPUT_PATH: /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import subprocess\n", + "from pathlib import Path\n", + "import logging\n", + "\n", + "cwd = Path.cwd().resolve()\n", + "\n", + "if REPO_DIR_OVERRIDE:\n", + " REPO_DIR = Path(REPO_DIR_OVERRIDE).resolve()\n", + "else:\n", + " # Auto-detect repo root by finding a directory that contains \"streamline\"\n", + " if (cwd / \"streamline\").is_dir():\n", + " REPO_DIR = cwd\n", + " elif (cwd.parent / \"streamline\").is_dir():\n", + " REPO_DIR = cwd.parent\n", + " else:\n", + " raise FileNotFoundError(\n", + " \"Could not auto-detect repo root. Set REPO_DIR_OVERRIDE to the STREAMLINE repo path.\"\n", + " )\n", + "\n", + "if str(REPO_DIR) not in sys.path:\n", + " sys.path.insert(0, str(REPO_DIR))\n", + "\n", + "if INSTALL_REQUIREMENTS:\n", + " req = REPO_DIR / \"requirements.txt\"\n", + " subprocess.run([sys.executable, \"-m\", \"pip\", \"install\", \"-r\", str(req)], check=True)\n", + "\n", + "\n", + "import importlib.metadata as importlib_metadata\n", + "\n", + "print(\"Dependency versions:\")\n", + "for package_name in [\"numpy\", \"pandas\", \"skrebate\", \"kaleido\"]:\n", + " try:\n", + " version = importlib_metadata.version(package_name)\n", + " except importlib_metadata.PackageNotFoundError:\n", + " version = \"not installed\"\n", + " print(f\"{package_name}: {version}\")\n", + "\n", + "# Show full phase logs in notebook output (INFO/WARNING/ERROR).\n", + "logging.basicConfig(\n", + " level=logging.INFO,\n", + " format=\"%(levelname)s: %(message)s\",\n", + " force=True,\n", + ")\n", + "logging.getLogger().setLevel(logging.INFO)\n", + "print(\"INFO: Notebook logging configured at INFO level (phases 1-10).\")\n", + "\n", + "\n", + "from streamline.p1_data_process.p1_runner import P1Runner\n", + "from streamline.p2_impute_scale.p2_runner import P2Runner\n", + "from streamline.p3_feature_learning.p3_runner import P3Runner\n", + "from streamline.p4_feature_importance.p4_runner import P4Runner\n", + "from streamline.p5_feature_selection.p5_runner import P5Runner\n", + "from streamline.p6_modeling.p6_runner import P6Runner\n", + "from streamline.p7_ensembles.p7_runner import P7Runner\n", + "from streamline.p8_summary_statistics.p8_runner import P8Runner\n", + "from streamline.p9_compare_datasets.p9_runner import P9Runner\n", + "from streamline.p10_replication.p10_runner import P10Runner\n", + "from streamline.p11_reporting.p11_runner import P11Runner\n", + "\n", + "if OUTPUT_PATH is None:\n", + " OUTPUT_PATH = str((REPO_DIR / \"out\").resolve())\n", + "\n", + "Path(OUTPUT_PATH).mkdir(parents=True, exist_ok=True)\n", + "print(f\"REPO_DIR: {REPO_DIR}\")\n", + "print(f\"OUTPUT_PATH: {OUTPUT_PATH}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "70f0410b", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "98b6068d", + "metadata": {}, + "source": [ + "## Build Mode-Specific Configuration\n", + "\n", + "This cell converts `RUN_MODE` into a concrete configuration dictionary (`CFG`) including paths, labels, task type, feature-list defaults, model defaults, and metric defaults.\n", + "\n", + "For demo modes, these values point to the UCI demo folders shipped with STREAMLINE. For custom modes, they come from the manual `CUSTOM_*` cells.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "aa6da382", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Resolved config:\n", + "{'categorical_features': '/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/data/UCIFeatureTypes/hcc_survival_categorical_features.csv',\n", + " 'data_path': '/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/data/UCIBinaryClassification',\n", + " 'dataset_for_rep': '/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/data/UCIBinaryClassification/hcc_survival.csv',\n", + " 'experiment_name': 'JupyterRun',\n", + " 'instance_label': 'InstanceID',\n", + " 'match_label': None,\n", + " 'outcome_label': 'Class',\n", + " 'outcome_type': 'Binary',\n", + " 'output_path': '/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out',\n", + " 'p6_metric_direction': 'maximize',\n", + " 'p6_models': 'NB,LR,DT',\n", + " 'p6_scoring_metric': 'balanced_accuracy',\n", + " 'p8_metric_weight': 'balanced_accuracy',\n", + " 'p8_scoring_metric': 'balanced_accuracy',\n", + " 'quantitative_features': '/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/data/UCIFeatureTypes/hcc_survival_quantitative_features.csv',\n", + " 'rep_data_path': '/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/data/UCIRepBinaryClassification',\n", + " 'task_family': 'classification'}\n" + ] + } + ], + "source": [ + "from pprint import pprint\n", + "\n", + "\n", + "def uci_feature_path(repo_dir: Path, filename: str) -> str:\n", + " return str(repo_dir / \"data\" / \"UCIFeatureTypes\" / filename)\n", + "\n", + "\n", + "def mode_defaults(run_mode: str, repo_dir: Path):\n", + " mode = run_mode.strip().lower()\n", + " if mode == \"demo_classification\":\n", + " mode = \"demo_multiclass\"\n", + "\n", + " if mode == \"demo_binary\":\n", + " return {\n", + " \"task_family\": \"classification\",\n", + " \"data_path\": str(repo_dir / \"data\" / \"UCIBinaryClassification\"),\n", + " \"rep_data_path\": str(repo_dir / \"data\" / \"UCIRepBinaryClassification\"),\n", + " \"dataset_for_rep\": str(repo_dir / \"data\" / \"UCIBinaryClassification\" / \"hcc_survival.csv\"),\n", + " \"outcome_label\": \"Class\",\n", + " \"instance_label\": \"InstanceID\",\n", + " \"match_label\": None,\n", + " \"outcome_type\": \"Binary\",\n", + " \"categorical_features\": uci_feature_path(repo_dir, \"hcc_survival_categorical_features.csv\"),\n", + " \"quantitative_features\": uci_feature_path(repo_dir, \"hcc_survival_quantitative_features.csv\"),\n", + " \"p6_models\": \"NB,LR,DT\",\n", + " \"p6_scoring_metric\": \"balanced_accuracy\",\n", + " \"p6_metric_direction\": \"maximize\",\n", + " \"p8_scoring_metric\": \"balanced_accuracy\",\n", + " \"p8_metric_weight\": \"balanced_accuracy\",\n", + " }\n", + "\n", + " if mode == \"demo_multiclass\":\n", + " return {\n", + " \"task_family\": \"classification\",\n", + " \"data_path\": str(repo_dir / \"data\" / \"UCIMulticlassClassification\"),\n", + " \"rep_data_path\": str(repo_dir / \"data\" / \"UCIRepMulticlassClassification\"),\n", + " \"dataset_for_rep\": str(repo_dir / \"data\" / \"UCIMulticlassClassification\" / \"student_dropout_academic_success.csv\"),\n", + " \"outcome_label\": \"Class\",\n", + " \"instance_label\": \"InstanceID\",\n", + " \"match_label\": None,\n", + " \"outcome_type\": \"Multiclass\",\n", + " \"categorical_features\": uci_feature_path(repo_dir, \"student_dropout_categorical_features.csv\"),\n", + " \"quantitative_features\": uci_feature_path(repo_dir, \"student_dropout_quantitative_features.csv\"),\n", + " \"p6_models\": \"NB,LR,DT\",\n", + " \"p6_scoring_metric\": \"balanced_accuracy\",\n", + " \"p6_metric_direction\": \"maximize\",\n", + " \"p8_scoring_metric\": \"balanced_accuracy\",\n", + " \"p8_metric_weight\": \"balanced_accuracy\",\n", + " }\n", + "\n", + " if mode == \"demo_regression\":\n", + " return {\n", + " \"task_family\": \"regression\",\n", + " \"data_path\": str(repo_dir / \"data\" / \"UCIRegression\"),\n", + " \"rep_data_path\": str(repo_dir / \"data\" / \"UCIRepRegression\"),\n", + " \"dataset_for_rep\": str(repo_dir / \"data\" / \"UCIRegression\" / \"auto_mpg.csv\"),\n", + " \"outcome_label\": \"MPG\",\n", + " \"instance_label\": \"InstanceID\",\n", + " \"match_label\": None,\n", + " \"outcome_type\": \"Continuous\",\n", + " \"categorical_features\": uci_feature_path(repo_dir, \"auto_mpg_categorical_features.csv\"),\n", + " \"quantitative_features\": uci_feature_path(repo_dir, \"auto_mpg_quantitative_features.csv\"),\n", + " \"p6_models\": \"LR,RF\",\n", + " \"p6_scoring_metric\": \"neg_mean_squared_error\",\n", + " \"p6_metric_direction\": \"maximize\",\n", + " \"p8_scoring_metric\": \"mean_squared_error\",\n", + " \"p8_metric_weight\": \"mean_squared_error\",\n", + " }\n", + "\n", + " if mode == \"custom_classification\":\n", + " ctype = CUSTOM_CLASSIFICATION_TYPE.strip()\n", + " if ctype not in {\"Binary\", \"Multiclass\"}:\n", + " raise ValueError(\"CUSTOM_CLASSIFICATION_TYPE must be Binary or Multiclass\")\n", + " return {\n", + " \"task_family\": \"classification\",\n", + " \"data_path\": CUSTOM_DATA_PATH,\n", + " \"rep_data_path\": CUSTOM_REPLICATION_PATH,\n", + " \"dataset_for_rep\": CUSTOM_DATASET_FOR_REP,\n", + " \"outcome_label\": CUSTOM_OUTCOME_LABEL,\n", + " \"instance_label\": CUSTOM_INSTANCE_LABEL,\n", + " \"match_label\": CUSTOM_MATCH_LABEL,\n", + " \"outcome_type\": ctype,\n", + " \"categorical_features\": CUSTOM_CATEGORICAL_FEATURES,\n", + " \"quantitative_features\": CUSTOM_QUANTITATIVE_FEATURES,\n", + " \"p6_models\": CUSTOM_CLASSIFICATION_MODELS,\n", + " \"p6_scoring_metric\": \"balanced_accuracy\",\n", + " \"p6_metric_direction\": \"maximize\",\n", + " \"p8_scoring_metric\": \"balanced_accuracy\",\n", + " \"p8_metric_weight\": \"balanced_accuracy\",\n", + " }\n", + "\n", + " if mode == \"custom_regression\":\n", + " return {\n", + " \"task_family\": \"regression\",\n", + " \"data_path\": CUSTOM_DATA_PATH,\n", + " \"rep_data_path\": CUSTOM_REPLICATION_PATH,\n", + " \"dataset_for_rep\": CUSTOM_DATASET_FOR_REP,\n", + " \"outcome_label\": CUSTOM_OUTCOME_LABEL,\n", + " \"instance_label\": CUSTOM_INSTANCE_LABEL,\n", + " \"match_label\": CUSTOM_MATCH_LABEL,\n", + " \"outcome_type\": \"Continuous\",\n", + " \"categorical_features\": CUSTOM_CATEGORICAL_FEATURES,\n", + " \"quantitative_features\": CUSTOM_QUANTITATIVE_FEATURES,\n", + " \"p6_models\": CUSTOM_REGRESSION_MODELS,\n", + " \"p6_scoring_metric\": \"neg_mean_squared_error\",\n", + " \"p6_metric_direction\": \"maximize\",\n", + " \"p8_scoring_metric\": \"mean_squared_error\",\n", + " \"p8_metric_weight\": \"mean_squared_error\",\n", + " }\n", + "\n", + " raise ValueError(f\"Unsupported RUN_MODE: {run_mode}\")\n", + "\n", + "\n", + "CFG = mode_defaults(RUN_MODE, REPO_DIR)\n", + "CFG[\"output_path\"] = OUTPUT_PATH\n", + "CFG[\"experiment_name\"] = EXPERIMENT_NAME\n", + "\n", + "# Explicit Phase 1 feature-list parameters override mode defaults when provided.\n", + "if P1_CATEGORICAL_FEATURES is not None:\n", + " CFG[\"categorical_features\"] = P1_CATEGORICAL_FEATURES\n", + "if P1_QUANTITATIVE_FEATURES is not None:\n", + " CFG[\"quantitative_features\"] = P1_QUANTITATIVE_FEATURES\n", + "\n", + "if not Path(CFG[\"data_path\"]).exists():\n", + " raise FileNotFoundError(f\"Target data path not found: {CFG['data_path']}\")\n", + "\n", + "EXP_ROOT = Path(CFG[\"output_path\"]) / CFG[\"experiment_name\"]\n", + "\n", + "print(\"Resolved config:\")\n", + "pprint(CFG)\n" + ] + }, + { + "cell_type": "markdown", + "id": "76c812fb", + "metadata": {}, + "source": [ + "-------------\n", + "# STREAMLINE RUN CODE\n", + "The cells below run STREAMLINE phase-by-phase.\n", + "\n", + "For full runs, execute in order.\n", + "For debugging, toggle phases and rerun only downstream sections." + ] + }, + { + "cell_type": "markdown", + "id": "56b94d2c", + "metadata": {}, + "source": [ + "## Phase 1: Data Exploration and Processing\n", + "After this cell runs, each target dataset should have:\n", + "\n", + "- initial EDA data counts and missingness summaries\n", + "- notifications for removed features/instances and added engineered features\n", + "- processed-data EDA summaries\n", + "- class/outcome balance plots when applicable\n", + "- feature correlation and univariate analysis outputs\n", + "- CV train/test partitions and feature metadata for downstream phases\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "fe6c658b", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: Force flag set: removing existing experiment folder /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun\n", + "WARNING: Specified 'match_label' not found; defaulting to Stratified CV.\n", + "INFO: Validating and Identifying Feature Types...\n", + "WARNING: Both cat/quant lists provided; binaries treated as categorical; remaining auto-assigned.\n", + "INFO: Running Initial EDA:\n", + "INFO: /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Starting Phase 1 - Data Processing\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB4UAAAawCAYAAABrho2bAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3QWUldX6P/A9M0iIiKCIhYiIndgdKHZ3d1376rXj2t2tmNjdjd3dhYFgoiDSIvFfz/79z7kz1Ax54Mzns9ZZM+d93/Pu/e4z3t9vrS/PsytGjRo1KgEAAAAAAABQlipLPQEAAAAAAAAAphyhMAAAAAAAAEAZEwoDAAAAAAAAlDGhMAAAAAAAAEAZEwoDAAAAAAAAlDGhMAAAAAAAAEAZEwoDAAAAAAAAlDGhMAAAAAAAAEAZEwoDAAAAAAAAlDGhMAAAAAAAAEAZEwoDAAAAAAAAlDGhMAAAAAAAAEAZEwoDAAAAAAAAlDGhMAAAAAAAAEAZEwoDAAAAAAAAlDGhMAAAAAAAAEAZa1DqCVC//PTTT+mtt95Kv//+e2ratGlaZpll0mKLLTbFx+3WrVsaPHhw2nTTTaf4WAAAAAAAADAtUSnMVDFkyJB07LHH5lD2tddeS4MGDUqff/552muvvdJuu+2W+vXrN0XHf/7559Njjz02RccAAAAAAACAaZFKYaaK4447Ln3xxRfpiSeeSHPMMUfx+J9//pl23HHHdPbZZ6dzzz3XtwEAAAAAAACTmVCYKe79999PTz75ZLr55ptrBMKhRYsW6fjjj09ffvlljeP//PNPru794Ycf0lxzzZXWXHPN1KxZs3zupZdeSsOHD08LLrhgeuGFF/Lvcb59+/bFzw8cODA9/fTTqU+fPmmNNdYYY07ju3/cMzRq1CjPa/nll09LLLHEFFkbAAAAAAAAmNIqRo0aNWqKj0K9dtZZZ+VQ+JVXXqnT9QMGDEi77rpr/n3llVdO3bt3T19//XW67rrr0sILL5xOO+209Oabb6ahQ4emTp06pe+++y698cYb6cYbb0wrrbRS+vHHH9Muu+ySWrdunZZaaqn04osvphEjRqQFFlggXXvttbXe/+STT86fmXPOOfP71VZbLa233npTdI0AAAAAAABgSlEpzBTXo0ePNN9889U4Fq2kn3vuuRrHdtpppzTrrLOmK6+8MjVu3DjdfvvtqaqqKp87/fTT00knnZTuvffe/L5nz545aG7Tpk1+v/POO6e77747h8IXX3xxrkgufP6AAw5InTt3Lo5Tl/v3798/Pfroo6l58+ZTeHUAAAAAAABgyhIKM8WNHDkyVVRUjPP8r7/+mu677760/vrr51C4W7duuaXzVVddVbymX79+6eOPP06DBg3K79u1a1cMhEOHDh1yxXChvfThhx9eDHxbtmyZ1llnnfTXX3/l93W5f9xbIAwAAAAAAEA5EAozxc0777y5HXN1iyyySH6FDz/8MIfCBb/88ktu9VxdVBoffPDBadiwYfn9LLPMUuN8ZWVlik7ocT7aQ0cQXF20ki6EwnW5f4TTAAAAAAAAUA6EwkxxUQEcrZo/+OCDtMwyy9R6/eyzz54WXHDBdMghh0zwWA0bNkwzzzxz+v3332sc//PPPyfL/QEAAAAAAGB6U1nqCVD+VlxxxbTBBhukY489NvXq1avGuWjbfP3116cGDRqkJk2a5GOrr756uv/++/O+vgURKF977bW5FXVtolX0ww8/nP7555/8PiqHo2V0waTeHwAAAAAAAKYnKoWZKs4777z82myzzdJqq62W2rZtm6t5I6yN9tK33XZbcY/g2A/4nXfeSVtssUVad911U58+ffJ1RxxxRG4TXZujjjoq7bLLLmn77bdPyy+/fG5d3axZs+L5Sb0/AAAAAAAATE8qRsVGrDCVRAD76quvpt9++y1XBi+11FJpySWXHOO62Nv3+eefTz169MiB7qqrrpr3/Q0vvfRSvs9WW21VvH70Y0OGDElPP/106t27dw6G432c33TTTWu9/wsvvJD3H47QGAAAAAAAAKZ3QmEAAAAAAACAMqZXLgAAAAAAAEAZEwoDAAAAAAAAlDGhMAAAAAAAAEAZEwoDAAAAAAAAlDGhMAAAAAAAAEAZEwoDAAAAAAAAlDGhMAAAAAAAAEAZEwoDAAAAAAAAlDGhMAAAAAAAAEAZEwoDAAAAAAAAlLEGpZ4AlKthf/xYknEbzjZPScYFAAAAAABg2qRSGAAAAAAAAKCMCYUBAAAAAAAAyphQGAAAAAAAAKCMCYUBAAAAAAAAyphQGAAAAAAAAKCMCYUBAAAAAAAAyphQmDEMGjQo9e7dOw0bNszqAAAAAAAAwHROKEzRu+++m7bddtu0yiqrpC233DItv/zy6V//+lfq1atXyUPqCy64oKRzAAAAAAAAgOmVUJgsgt+99947bbzxxun9999Pr732WnrhhRfSiBEj0h577FHSquFXXnkl3Xjjjb4pAAAAAAAAmAhCYbLnn38+NWjQIAfAVVVV+VjLli3TiSeemEaNGpU++eSTNHTo0PTjjz/moLi6v/76K7ebDv369Ut//vln8ff+/fsXrxs5cmT6448/8s/q4rq+ffvm3+PnkCFDiudizMK5GLv6udCnT58xAuuJmUPBgAEDcmUyAAAAAAAAlIsGpZ4A04YWLVqkgQMHpocffjhtttlmqaKiIh9v06ZNDozDr7/+mtZbb7106aWXps6dOxc/e9hhh6V27dqlU045JV122WU5dI2g9sMPP8yB7AYbbJA233zzfD5C1wifL7nkkrTyyivnz8dnfvnllzR48OAcPv/9999po402Sqeddlq+x+WXX56D6N122y0fW3XVVdO1116bbrjhhlRZWZmD4phzBNiNGzeeqDl8//336YgjjsjBc5xr1qxZOu6449I666xTku8DAAAAAAAAJheVwmQRmkZAevTRR6e11lornXDCCemRRx7JVcAFc8wxR1pxxRXTQw89VDz2+++/p7fffjttscUWxWNPP/10vt+bb76ZbrrppvT444+ns846K919993pnXfeSauvvno677zzaqx8BM/LLbdc3tf4ueeeSx999FE699xz85wiyI3q5bhmtdVWS9dff33q0qVLDobfeuut9Oijj+afp5566kTPIcLmJZdcMj9LfGaXXXZJV1xxRa6SBgAAAAAAgOmZUJisYcOGed/eqMpddtllU7du3dJ//vOfHMJGOFoQ1bYvv/xysaXzE088kauJl1pqqeI18b4QEkeIPMMMM6Rtt902tW7dOlf2RiDbo0ePGisfnznooIPy+TnnnDPtv//+uWp5bHsZ33HHHWmnnXZKHTt2zO/btm2bDjnkkHx9VAFPzByimvinn35Kv/32W36/++67pwceeKBYMQ0AAAAAAADTK6Ew//tjqKzMbaEvuuii9MYbb6QHH3wwrbvuujkojqrhEOcjYI0wODz22GO5dXN1s88+e433cX2rVq2K76M98/Dhw2tcs8gii+TxCzp06JDbSUfL6uqitXS0ml5ooYVqHF944YVzi+levXpN1ByiGjlaSEeV9KabbpqriH/++Wd/HQAAAAAAAIxVZFOxPWtdRHfa2BJ1Ys9PKqEwWYSvhSrbEBWyiy66aA6I55tvvtxSOTRt2jQHxdGyuWfPnnkP4NFD4Wj1PDH/0VRX+KNv1KjRGBXNsW/w6BXEQ4cOzT/j3MTMIVpHR9vqe+65J7edfvHFF9OWW24pGAYAAAAAAGCsLr744nTYYYel8YmwN66LDrjLL7987nT7xRdf1Pn85CIUJjvqqKPya3QRDrds2TLNPffcNVpIx56/1113XW41Ha2aJ9Wnn35aI+iNvYVjzEK75+rzWXDBBfPev9XFnsLNmjVL88wzzwSPPXLkyPTjjz/myuFogx1trG+//fbUr1+/PC8AAAAAAACo7tprr03XX399qs2tt96au/Ped9996f3338/B77777ps75tbl/OQiFCaLf8UQ1cDHHXdcrpL99ttvczB7wQUXpN9//z3v4Vuwyiqr5FbM9957bw6IJ4fYy/f444/P//Ih/vBvuOGGdOihh+ZzEfZGJXHMJ6474ogjcqVy/Mf21Vdf5f9IrrrqqnTggQfmSuIJ/o+gsjIdfPDBeQ/lCIHj2eM/4plmmikts8wy/kIAAAAAAADI/vjjj7TbbrulLl265O1Ra3PLLbekPfbYI7Vv3z7nWEcffXT6559/0tNPP12n85OLUJgs/tXBAw88kJo0aZKuvPLKHLCec845OTCN0LVFixb/+6OprEybbLJJ/sPccMMNa6zgLLPMkmabbbYax+aaa67cdrogxohj1UVJfNu2bXMwfP/996ezzz47l8eH5ZZbLm211VbphBNOyBXCEUpfffXV+fcIjiMgPvPMM9Pee+890XOIgLl58+bpxBNPzJXCUTkc1cLV9yEGAAAAAACgfvv555/TvPPOmx577LG02GKLjffa3r17p59++il3qi2YYYYZ8ueiKri285NTxahoVA0T6Iwzzkh//vlnuvDCCyd57U477bTUvXv31LVr17L6Hob98WNJxm0424S30AYAAAAAAKhPOnXqNN7z3bp1q/UeUdD466+/5g64YxMdarfeeuv07LPP5iC5ILZ07d+/fy5+HN/52Mp1cmkw2e5EvdCrV6/Us2fP9Mgjj6Qbb7yx1NMBAAAAAACgFg2X2csajWb1lmmKGzp0aLH6t7p4P2zYsFrPT05CYSbIHXfckV555ZW8/+7iiy8+WVZvbO2eAQAAAAAAYErpVodK4EnVuHHj/HP0gDfezzjjjLWen5yEwkyQY445Jr8mpyiNBwAAAAAAgHIy99xz55+xd3Dbtm2Lx+P9QgstVOv5yalyst4NAAAAAAAAgNSiRYvUoUOH9PbbbxdXY9CgQXmv4eWXX77W85OTSmEAAAAAAACAyWDIkCF5r+AIfMM+++yTTj311NSuXbtc/XvBBRekeeaZJ6277rp1Oj+5CIUBAAAAAAAAJlDTpk1Ts2bNahy79dZb8+u1117L77fYYoscEl999dW5CniZZZZJXbp0SVVVVXU6P7lUjBo1atRkvSOQDfvjx5KsRMPZ5vENAAAAAAAARY2W3ddqjObv965P9Yk9hQEAAAAAAADKmFAYAAAAAAAAoIwJhQEAAAAAAADKWINSTwDK1X7P9C7JuNdsOWtJxm3cpElJxgUAAAAAAGD8hMIAAAAAAABQxioqq0o9BUpM+2gAAAAAAACAMiYUBgAAAAAAAChjQmEAAAAAAACAMiYUBgAAAAAAAChjQmEAAAAAAACAMtag1BMAAAAAAAAAppyKyirLW8+pFGaq69KlS9pxxx3TN998M8a56667Lp177rmTZZybb745nX766RP9+ck5FwAAAAAAACgVoTBT1fDhw9ONN96Yevfune66664xzv/www/p66+/nixj9ezZc5LuNTnnAgAAAAAAAKUiFGaqeumll9KAAQPSbrvtlh555JE0dOhQ3wAAAAAAAABMQfYUZqp68MEH04orrpg23XTT3Jr5qaeeSltsscU4r//2229T165dU48ePdKss86att5667TKKqsUz8fxW2+9Nf9s2bJl2nbbbfP9q3vmmWfSk08+mcPotddeO+20006poqKizp8HAAAAAACA6ZlKYaaaP//8M7344oupc+fOOYBdfvnlx9pCuuCLL75I22yzTRo5cmTac88902KLLZYOPvjg1K1bt3z+3XffzeFynN99991T27Zt0z777JOD54IPPvgg3X333Tl4XmuttdLZZ5+d7rjjjjp/HgAAAAAAYHpXUVnlVVlzDeoblcJMNY8++mgaMWJE6tSpU34f4fBpp52Wunfvnjp06DDG9VdeeWXq2LFjviasueaa+VVV9X//oV5wwQW58ve///1v8XwEvFGBvNlmm+VjM844Y75P48aN8/t33nknvfzyy2nnnXeu0+cBAAAAAABgeqdSmKkmKnCXW2653Aa6EApXVlbmSt6x+fDDD9PKK69c41j79u3TfPPNl8Pljz76KK2xxho1zkc1cFQkRzvoMP/88xcD4TD77LPnNtJ1/TwAAAAAAABM71QKM1V89dVX6fPPP8+h7I477vi/P8AGDdLDDz+cjjrqqBrhbfjnn39S06ZNx3q/CHXD6OejMrjw2TDDDDOM8dlRo0bV+fMAAAAAAAAwvRMKM1U88MADOXC98MILc3VwwZdffplOP/309OSTT6Ytt9yyxmfmmWee1LNnz7Her2HDhmnOOedM3333XY3j3377bb7/HHPMMd75TOrnAQAAAAAAYHqhfTRT3PDhw/N+whtvvHFaYYUVcgvpwmunnXbK4e/YWkhvtdVWueV0r1698vvY7/eMM85I1157bX6/zTbbpDvuuCP98MMP+X20fb766qvzPsGzzDJLrfOa1M8DAAAAAABMDyqqqryqaq5BfaNSmCnupZdeSn369EnbbbfdGOeiKnf77bfPFcRff/11jXM77LBD+uKLL9Imm2yS9xLu3bt3atOmTbrkkkvy+X322ScHuptuumneZ/jHH3/MofOZZ55Zp3lN6ucBAAAAAABgelAxKjZYhSkowtYIdDt27DjW84MGDcrh77zzzpuGDBmShg0bljp06FA8H4HyTz/9lGabbbY011xzjfH5wvnWrVvnV0FUGA8ePDgttNBC4z02rs9HYDz6XCbEHne8n0rhmi0XKcm4jZs0Kcm4AAAAAADA+DVd7QhLNJpBr16c6hOhMEwhQmEAAAAAAGBaIBQeU30Lhe0pDAAAAAAAAFDGhMIAAAAAAAAAZaxBqScAAAAAAAAATDmVlVWWt55TKQwAAAAAAABQxoTCAAAAAAAAAGVMKAwAAAAAAABQxoTCAAAAAAAAAGWsQaknAAAAAAAAAEw5FZVVlreeUykMAAAAAAAAUMZUCsMUcnLnDiVZ2z5DR5Zk3NkH9kylMkOreUs2NgAAAAAAwLROpTAAAAAAAABAGRMKAwAAAAAAAJQxoTAAAAAAAABAGbOnMAAAAAAAAJSxisqqUk+BElMpDAAAAAAAAFDGhMIAAAAAAAAAZUwoDAAAAAAAAFDGpqk9hXv27JneeuuttPnmm6eGDRvW+dyUMnLkyFRZ+X+5+Ycffpj69euX1lprrVrPjc+XX36ZPvnkk+L7ioqK1KJFi9SxY8f8c3R//vlneu+999LAgQNT69at0zLLLJMaN248yc/Wt2/f9MYbb+Rn6NSp01Rb03j2WIMNN9wwzTTTTBP8+YlddwAAAAAAAKivpqlK4Q8++CCdeOKJaejQoRN0bkro1atX2n777Yvvf/755/TNN9/Ueq42L7/8cvrvf/+bA814vfPOO+mGG25I66yzTnrmmWdqXHvdddfl43fddVd69dVX03nnnZcD0G7duk3Ssw0YMCBtttlm6cYbb0wvvvhiatBg6v3bgFNPPTWdfvrp6eGHH57gz07KugMAAAAAANRXFZWVXpU116C+maYqhacln332WX4VbLTRRnU6VxdRlXvmmWfWOBZB8cknn5xD4Ahp33333XTRRRel++67Ly2++OLF6y6//PJ05JFH5mB41llnnahni0rd33//PT344IOpVatWaWr59ttvc6VwBLt333132nnnnSfo85O67gAAAAAAAFAfTfeh8EcffZR69OiR5p577rTUUkulGWaYoVhZPHz48NS+ffvcJnnGGWdMq666ao02yUOGDEmff/55rjiNIHbppZdOc845Z/rll1/yZ0aNGpXuvffetMoqq+QQNVoVL7TQQuM8V2hj3Lt371wFHG2OF1544TTPPPPU+hyrrbZauvPOO1P//v1Ty5Yt08cff5znvNhii9W4btddd02//vpr+uOPP3IoHOFxPMfqq69evCaORUV13DNaT4eZZ545de/ePbdsfv311/OxqEyO+8dzj2stqos5ff/992m22WZLK6ywQnGta/suCu6///7UoUOHtN122+VQONYoximI72zEiBFpwQUXTG+++Wb+/lZaaaW8HuP7TgrrHp99++2387EYf9CgQbnteLTHrsvfy7jGBgAAAAAAgOnZdBsK//333+lf//pXbh+87LLL5p8RGF511VWpTZs26dFHH80hZgSoSy65ZG49HG2Lb7755jTvvPPmcHD//ffPIeAcc8yRvv766/y67LLLcoj7ww8/5PtFcBmVuo8//niusD3hhBPGeS7CyWeffTYdc8wxaeWVV86BY/y+yy67pCOOOGK8zxNha4SUhRBykUUWyaHm8ccfn/bZZ58cbodZZpmlRpVxVPvGM1YPheNYhMYRCkeb5tiLOQLqtm3b5vtExW6Iqt3Yxzj2NR7XWqy77rp5HrHW8blY6++++y6HyLfccksOV2v7LkIEro888kjaeuut85rFdxDBcPVQOL6z+F769OmTv7NYk1jvW2+9Na/l+NY99l7ea6+9cqgeQXesUXyPsQdxhMJ1+XsZ19hLLLHEZP7rBQAAAAAAgHoeCkeQ2bhx4xrHIgis7vrrr8+Vok899VRq0qRJDv/+85//5BbMN910UzH0jP16IxyNys/99tsv72kbxz799NN0yCGH1GhhvNNOO6UHHnggB4U77LBDrjodvc1zVP6O61y45ppr0r777psOPPDAYgVqPE8EkBG+hphLVLuGmHdUrj755JM5gCyIUDmC5CuuuCLPKcLXFVdcMYe00WK6cK+6iOrf5557LrVu3Tq/j0rh2Nv4pJNOSk2bNk233377ONcixotnikD2sccey6F0iDWKNYx51eW7iD2R45rOnTvn9/Ezxo3Qu1mzZsVxv/jii1xRHKF4rFNUFd92223p3HPPHe+6X3zxxfn6CHejwvqnn35Km266aVpggQXq/PcyvrEBAAAAAABgejVNhsIR5o7eejjaAFcXAWW7du3yz4IILJ944oncOjlEhWcEwiFaIkfQGeHnwIEDawSgw4YNy8FsjBm/T4po6RzBYgSwUb27zDLL5Fd1EUgWQu74PapT+/btmyuCo3o2qnfDAQcckIPJ2D84gtwXX3wxB7XRuvnaa6/N4WddRCVsIRAem9rWIqqfN99882IgHKLqtq7fRQT8hWC70A57/fXXT126dMnVw9XHn2+++XIoW/jO4juM+dQmwt7DDjusuCYxVuw5HBXPdZnjpIwNAAAAAAAA07JpMhQ+8cQT8x641UW1bVSJFvz44495b9vRK4i32mqr3O44FFoXF0Rr5Ahho7XyP//8ky6//PL00ksv5f1qo9VwtDiOYHBSXHDBBenss8/Or+OOOy4tuuiiOUBdb731itfEvsajV7t+9tlnaZtttsn7ClcPXKOd9LbbbptfMfeoMD7llFNyBWtUPtdFq1atxns+Wi+Pby2iwnb0/YWrq+27iNbNzz//fA5ZCxXSIcLiu+66q0YoHKF6dVVVVfm5xydC/r/++muM4HuuueYqhsJ1+XuZmLEBAAAAAACmdRWVVaWeAiU2TYbCdRFh6UorrZQOPvjgcV4T+8uOHn6GqMSN1swRDkd4G8HtTDPNlI466qjiNRMrwuy45xlnnJH3NI4QNOZ43333jXdv2qigjRAzWj2HaCcd1a6xv21B7Au8/fbb5z2DY8/bEG2kozV1dYXK14LaWk0feeSR412LCFNHX8sJ+S6iTXRUHceextVD2aigfuONN/Kx6nsLT6iYb1QI9+vXr8bxCIrrOkcAAAAAAAAoV5VpOhUtlKN6uHq752+//Ta3bi5Ud77//vu5NXNBtAqOILJ58+b5XLREjvtEqBgB4ltvvZUrZAvtg0cPWwvGdS7GjfA3qm2jyjTGOvroo4vVtuMToeyvv/5abF/89NNPpxNOOGGMdtYxv5hrx44d8/t4lhivIK6PfYwnRG1rsdxyy+UW1tWf+d133837BNflu4gQe/nll8+hc1RIF16XXHJJrhaOltl1Mb7vZJVVVslrVhCV4DHnCfl7AQAAAAAAgHI03VYKRyVrtFveYYcd0iabbJJD1di3NtosR0VtwW677ZZbBH/55ZfphRdeSDfddFM+vsYaa+TfIxAshLmNGjUqVsdGK+I4fsUVV+RrqxvXuRg3wtTYKzfGbNKkSQ6iF1xwwbTqqqsWrxs+fHiNNspR4RrhZFy39dZb52PHHHNM2nvvvfOzrbXWWrkVdlz38ssvpw4dOqQtt9wyXxfnb7755rweUVX8+OOP5+eYELWtxaGHHprnFXsex1x+++23HOSec845tX4XUdEce0Sfd955Y4wbe/rGvr9RFX388cfXOs/xfSdR+R37Lx900EE5gI49hqNiuvC3UNe/FwAAAAAAACg301QoHO2FI7iLPXdrOxf7Az/22GPpoYceSj169Mhtmy+99NK04oorFj+z+OKLp8MOOyzvZxv74z7yyCO5RXNh798IBb/55pu8l+zFF1+cw8HY0zeqSaPVcwSZUXUb4WJU/Rb2rB3fuaiGfe6559JHH32UK3+jAjdehaB2oYUWSptttlmxjXK0dm7atGkOXjt37pyrYUPs4RvzffHFF3OoGvOMquB///vfaeWVVy4+Y1QWR8AcYXDsmxvhaOzh27Nnz3x+2WWXTe3atauxljHXWMsZZpihTmsR18dcouI3qmujnXTsBdy+fftav4sIsSOs3WCDDcb6ne+55555rAiPYx0L309B9WPjW/cFFlggVwLHHGPdo010fA+Fdajt76W2sQEAAAAAAGB6VTFqXP14p3OnnXZa6t69e+ratWupp8JUEMF/hNXV92COMDrabB977LEl+Q6++2NAScZtVFWayufZh/+vVfvUNkOreUs2NgAAAAAATOtabnBaqacwzen71MmpPpmmKoVhYn388ce5snnXXXfNbaljv+Nocx2VyAAAAAAAAFCflW0orPVv/RJtwpdeeun07rvvpu+++y7v4XzuuefmltsAAAAAAABQn5Vt+2goNe2jpx7towEAAAAAYNy0jx5TfWsfXZrNRwEAAAAAAACYKsq2fTQAAAAAAACQUkVllWWo51QKAwAAAAAAAJQxoTAAAAAAAABAGRMKAwAAAAAAAJQxoTAAAAAAAABAGRMKAwAAAAAAAJSxBqWeAJSr+WdrluqXpqWeAAAAAAAAMBYVVVXWpZ5TKQwAAAAAAABQxoTCAAAAAAAAAGVMKAwAAAAAAABQxoTCAAAAAAAAAGWsQaknAAAAAAAAAEw5FZVVlreeUykMAAAAAAAAUMaEwhNp5MiR6e+//57gc1PD8OHD07Bhwyb43OhGjBiRn6Pwquvn6nLPyWFCngUAAAAAAADqK6HwRHr00UfTkksumfr37z9B56aECEdvvvnm4vsLL7wwHXDAAbWeq80NN9yQn2O55ZbLr6WXXjp17NgxHXrooem3336bqLkeddRR+Z6vvvrqBH92Up4FAAAAAAAA6iuhcBno1q1bOu+884rvjznmmHTjjTfWeq4uZpxxxvTJJ5/k1+eff54D759//jkHwxNqwIABeT4RMN9zzz0T/PlJfRYAAAAAAACoj4TCU1m0lh5bBew///yTfx81atQEfT7eFz4bbZnjfaGt8vjOVVfbmNXNPffcaffdd08ffvhh6tu3b52er+Cxxx5LTZo0SbvuumsOeH///fca52Nu8RrbvOr6LNU/F62qx3Z+XN/BuMYGAAAAAACA6VmDUk+gvnj44YfTlVdemX788cfUunXrtO2226b99tsvNWjQIJ111lk5YK2qqkpPP/10aty4cT5/5JFH5vMDBw5M5557bnrttddS7969U0VFRVpmmWXy57799tt07LHH5gA0KnAvvfTS9MYbb6Qvv/wy7bPPPuM817Vr19wC+oQTTkjvvvtuHqdDhw55zLh2fCIwbd68eWrWrFmdnq/gwQcfTGuuuWZae+21U6NGjdIDDzyQ9t9//+L5eJ4///wzf+bZZ5/NIW1ce+aZZ6YPPvhgvM8SunTpkttLR9vuaHO9wAILpI8//rhYlVzbdzCusWeeeeYp8BcBAAAAAAAwdVRUVlnqek6l8CSKStSoXK3+ql5xGl5++eX03//+NwewH330Ubr66qtzQHn55ZcXr3nqqady+Pjmm2/mYPPxxx9PF198cT4XP7t3757uvPPO3Mb5/vvvTz/88EMOOCNkveCCC3KgHOfWWWed4j3Hdy6ccsopOdx9/fXX8yvC1mjJPHqVbOG5hgwZkkPYu+66K51zzjlphhlmqPPzfffdd/lc586dcyC81lpr5bB29LGeeOKJ1LZt27wOd999d3r77bdzi+janiWujXFjXu+8805af/31i2FxXec4rrEBAAAAAABgeiYUnkRRTRphavVXhK3VXXXVVbkqdaWVVsqti9u1a5cOOOCAdMsttxRD0ahcPf7449NMM82UFl988Xw+gslomXzSSSflIDauiSrhBRdcMK2yyirpjz/+mKS5//rrr8UAu2HDhrlKONo6xxgFgwcPLj7X8ssvnzbffPNcfRvBa2HudXm+qAqO/YlXX331/D5C26jYjern6mafffZ00EEH5WrpxRZbLIe/EQLXJoL0nXfeOa222mo5dN5xxx2LY9V1jhM7NgAAAAAAAEzLtI+eRBFqjt5eOCpQjz766OL7b775Jn366ae50ndswWyIELJQeRsWWWSRNGDAgHy+TZs2eQ/fl156KfXo0SNX3X799dc5GJ4U//nPf9Jhhx2WVlxxxRz6rrHGGmnLLbdMs8wyS/GaCHKjdXPBX3/9lW666aZcabvoooumTTfdtNbnizD7kUceSauuumo+FlXHMWaErxF8R5Bbfc/i6qF07EE8tn2Bq4v7xZrEfKqLcD0qoOv6HUzM2AAAAAAAADCtEwpPBVGJGiHxbrvtNs5roi1ydbF3boigONpEX3PNNblKd4UVVkh77LFHuv3221OfPn0maV4R0r7yyis52I7XDTfckG699dZ07733ptlmm22sn4l20xEk33fffblaOELh2p4vWjfH/sURalffrzgqdp9//vn0+++/p1atWhWfd0JVVlbm9SusWUH11tR1+Q4mZmwAAAAAAACY1mkfPRV06NChWLFaPRCNCteCzz//PB8riBbNEZRGlW20OD7wwAPTGWeckdsiL7XUUnlP4YLq1a2jG9+5GD+qddddd93c8vrBBx9MP//8c3r//ffH+zwRsA4dOjS1aNGiTs8X951zzjnzXr7Rjrnwir2Ro311/KyLcT1LhLnt27fPlcDVVX9fl+8AAAAAAACgHFVWVnlV1lyD+kYoPBXEPrUvvPBCuu666/I+wF9++WXezzYC3kI1a+yve8455+Sq2ajevfbaa9O+++6bg9CWLVvmoDaqbX/55ZccDkc76djvNzRt2jRXyUZQHO2dqxvXuQhEo8o3wuC4b5yLFs+xt3C0sq4ugtPCK64966yzclvlrbbaqtbn69+/f96neOutt84VvdUtvPDCaZlllkn33HNPjarecRnfc8Zaxb7LTz/9dOrbt28O0l999dVikFyX7wAAAAAAAADKkVB4IkW74ghQx1a9Ovq51VdfPV1yySXpqaeeSp07d85hZFQBd+nSpXjNEksskatvY0/fCH0PPfTQtPvuu+dzF154YQ6AI8Tda6+98v1PPvnk9P333+dwdtlll81jxGefeeaZ1KBBg2Ir5HGdi4A2gucISCOw7dSpUw5vY06xt27hOaKSN1o+x2v55ZdPW2yxRQ6wu3btmtq2bVvr88WY8YwxxtjssssuOQh/8803a8y7oC7PEjbbbLN0+OGHp/PPPz9tsskm6bPPPsvH4nuoy3dQ29gAAAAAAAAwvaoYpUyy5E477bTUvXv3HLQycSIcjxC7+t7MEaw3atQoB8UAAAAAAAD11RxbX1rqKUxzfr3/sFSfqBSmLESV8G677ZZ69uyZW1Y//vjjuV10VDYDAAAAAABAfdag1BNAm+LJIfZGPvfcc3M76mi13a5du9x2e9VVV/UnBgAAAAAA1GsVlf/rtEr9pH00AAAAAAAAlLE5t72i1FOY5vxy78GpPtE+GgAAAAAAAKCMCYUBAAAAAAAAyphQGAAAAAAAAKCMCYUBAAAAAAAAyliDUk8AAAAAAAAAmHIqKqssbz2nUhgAAAAAAACgjAmFAQAAAAAAAMqY9tEwhQwZOrQka9t70PCSjDvXP7+lUjn5vb9LMu7ZGy9aknEBAAAAAAAmhEphAAAAAAAAgDKmUhgAAAAAAADKWEVlVamnQImpFAYAAAAAAAAoY0JhAAAAAAAAgDImFAYAAAAAAAAoY0JhAAAAAAAAgDImFAYAAAAAAAAoYw3SdOrdd99Nt99+ezrrrLNSkyZN6nxuSvnll1/SnHPOmX9/6KGH0o8//pgOPvjgWs+NT7du3dJjjz1WfF9ZWZlatGiRVl111bT22muPcf2wYcPSc889l95///00ePDgNO+886bNNtsszTXXXGlquf/++9Orr76ajjzyyDTPPPNM8OfHtVZx3969e6cDDzxwss317rvvTv3790/77rvvZLsnAAAAAADAtKaisqrUU6DEpttK4Z9++ik98cQT6Z9//pmgc1PChx9+mDbZZJPi+wUXXDAtu+yytZ6rzbfffptD3nXXXTe/Vl999TTLLLPkwPXCCy+sce0333yTNt1003TDDTfkMHaZZZZJ3bt3T507d64RLE9Jo0aNSldccUV655130j333DPBnx/fWn322Wfprbfemqzz/fjjj/M/IAAAAAAAAIByNt1WCk9Lfv311zRkyJDi+0UXXbRO5+qiQYMGaeONN65xrHHjxumSSy5J//rXv3IldFQFx+9LLLFEOv/883NFcdh2221T27Zt07HHHptD4rnnnjtNSW+88Uau5o3K3qjUPuSQQ9IMM8xQ589P6loBAAAAAAAA9TgU7tu3b24X/MMPP+R2ytFWeb755svnojXx33//ndstP/nkk2nGGWdMW221VVpkkUWKn4+WzK+//nquQo6gs2PHjvkeX375ZbrlllvSyJEj0xFHHJH22muvXOEbbY/XWWedcZ6L4DQqa2O8t99+O1VVVaWFF144V8rW1vI65j1ixIhcCR3XPvroo+nnn39Od955ZzEQLthnn33SgAEDcnBcfS3uu+++9P3336dZZ501bbHFFmmBBRbI5+699948r2hFHc8WlcZrrLHGeNev4IEHHsjrsuWWW6ZLL700Pf/882n99dcvno91Hj58eF7np59+Ov8eaxSvzz//fLxrVRDVws8880yqqKhIW2+9dY3vaHzPFXr06JGfL66r3n67Z8+e6eKLL87jxtwK7rjjjhxS77333rX+fQEAAAAAAMC0arptHz0hfvvtt2KAG+2IBw4cmEPfCHkLrYmvueaadOqpp+aQMYLJ7bbbLr388svFMDP2nY2q3RVXXDE1bdo0nXDCCem6667L4WNU6EZIGS2eZ5999mKr4/GdC9FqOcLIDh06pIUWWiiHunXZa/ill17KgejMM8+c38cevjHvGG90EXDHXGOMEGuwwQYbpA8++CBXD//55585xH3xxRfz+U8++SSdffbZ6b333sufic/Xtn4hjkWr6/XWWy/NMcccaamllhqjhXQ8++WXX56rmeN5o+I59giOVt+1rVVhbqeddlqaf/7583e0/fbbp1deeaVOzxWhc7z//fff89xuvPHG9Oyzz+Zz0W472kjH91wQofuVV15ZXGMAAAAAAACYXk33lcIReEZYW11UzVZ30UUXpcUXXzxXrxbE3rwRAkfFaogQMX6PKtiCc845J1fJRmh4880359CyICpYI4A84IADcnXsbbfdNkab59atW4/zXIiK1whXd9555/x+rbXWyuFkVOpGOBqiYjcqWEMEoVGpG22WI5AuiJbNEcTWxbnnnpvX4uqrr87vI/yOauNTTjmlGKBGtXFc17Bhw/z+mGOOqXX9ouI5qmojFA5RIXzeeeelXr16pTZt2hQ/N2jQoLzvcYsWLYrrGHseb7TRRuNdq0JQG99Dq1atiu9jjNhrubbnivB9pZVWyteHCIg7depUfN7Yjzkqrg8//PC89m+++WausI6gGQAAAAAAYHpWUVlV6ilQYtN9KLzmmmuO0W45qlw//PDD4vuoNm3evHkxXA1//PFHbif8119/5fdRAVs9EI7AMALKuC6qg0MEnNGa+Lvvvkvdu3ef5D16V1tttVyNGm2SI3yO9xGOVheBZVTOFkLhPn365IrWXXfdNbdCXnDBBVOjRo1y++vaxOffeeeddPLJJ9c4HmN27do1r0eIfYgLgXBd1i/ORevoJZdcMs0555zFUDiC2qgWPvLII4ufi5bThUA4xPXx/HUR31EhEA7Rdvquu+7Kc6jtuaJF93HHHVc8F2sWIXxUDofNN988h9VxXXzfEVTH/Zs1a1anuQEAAAAAAMC0aroPhWPP29Fb/MZetbfffnuNADOqSaNStLoddtgh7+UbWrZsWeNcIQyMytaoPI5q2V9++SWHsNGquXqwObHinosuumh66qmnclvk2Pc35hTVz4V5RRX06JWzsVduhOERxB577LGpffv26bXXXhvnOFHFu9hii+Vq4tiHePT1ilA3DB06NP8c/Xxt6xfVy7HncgS+1YPjCF5jjoceemjehznMNNNMNe4RVblRGV0XUZ08tnnHHsHje65obR3PNvr5+A4LoXC0s47v9aGHHsrtp6O19AUXXFCneQEAAAAAAMC0bLoPhesiKnpj/9pxtSUOEfhWF22No1o2WkBHi+gFFlggPfzww8UK2tj7N9olT6poWxyvCLKjOjWC4qhgjcrh8YWjEWgWxo9g/I477kiffvppbqE8+nP9+9//zlW0O+64Y96rN56tup49e+afcW5i1u/666/P63LQQQcVw+ww77zz5r2au3XrNlnaMEeb7OqicjvC5hhnfM8VFeBRYTz6+WjDXV1UC0f76ajYjueJnwAAAAAAADC9q0z1QISZUbEaFa0Fjz/+eA5Ko6VyiP2Bo9o1RCvmW2+9NYetEYZGGBnVuIVA+OOPP06vvPJKrk4NEUzGfQr3qm5c5+J9tDOOvWsLFcHRfjnMOOOM432emGuEvVEtHFZeeeUcJEeg/NNPPxWv69evX/rPf/6T20FH4Bk22WSTdOedd+bq2hAVtF26dEkrrLBCmnXWWSd4/WJf30ceeSSv1WabbZavLbwiOI8wNlpI18X41jHE9/PFF1/k3yMQj/2FI1CPILq254rzd999d16TQqD83HPP1bh/3Cuqis8+++w8/9H3qgYAAAAAAIDpUb1Ivfbff/9cRRttl2Nf2tiXN0LBc845J+/ZG6K18lFHHZXatWuX9w2OIPH4448vfv6yyy7LYXCEoLFHbQSxX3/9dbH1cOxrvNtuu+VXdeM6F+NGVe+BBx6Yll566Rw+v/vuu2n77bdPyy23XPG6YcOG1WjJHPvnRii8++675z1vCy655JJ00kkn5X10l1pqqRywxnwXXnjhvFduIWiOoDaC1Q033DBfF3sjR9XxFVdcMVHrF/sNR3vtCFJHF3PYdtttc/VtXF+b8a1jiGrtqNqONs9fffVVnneE3nV5rkMOOSR9+eWXOeyNlt1xbdyvutlmmy2tssoqOfAvhOgAAAAAAADTu4pqnV6pnypG1XVD12lMVMR++OGHuUK1sF9tbecixI1AN/YLjuCwEJTGfr4RIl511VXpo48+Sk2bNs1Bbex3WxBVst98800ODiOUjHD27bffTuutt16uII5WxRE6xrkBAwbk8xEch/Gdi8rWzz77LFcnx37F0Qq54Ntvv82fK4j5xNwi1IwK3LGJPXJjnlEpGxXC888//1iv+/zzz3M75QjDCxXK4ZNPPsl7G6+44opjfGZs6xfhbMwzwtjq61UQz/fGG2+kJZZYIj97//79i88e4tmrHxvXWsV1UZkdoX2E57E/cMeOHWu0qx7fcxVEUB6V33Eu5haVwdVD+Ouuuy5XPkcr70k15P/v0Ty19R40vCTjzvXPb6lUTn7v75KMe/bGi5ZkXAAAAAAAmBDz7tHVgo2m5827pvpkug2FJ6dCKNy1q/8g6rP4TyEqtaNKeOedd57k+wmFpx6hMAAAAAAAjJtQeEz1LRSuF+2joTbRHvzFF1/MwXC0vAYAAAAAAIByIRROKW299da5hTH1V7S/jhbXK620Um4HDgAAAAAAAOVCKJxSWmyxxUr9PVBiHTp0yC8AAAAAAAAoN0JhAAAAAAAAKGMVlVWlngIlVlnqCQAAAAAAAAAw5QiFAQAAAAAAAMqYUBgAAAAAAACgjAmFAQAAAAAAAMpYg1JPAAAAAAAAAJhyKiqrLG89p1IYAAAAAAAAoIypFIYppPKfoSVZ2zkbDC/JuBVDSvO84Zg126X65MZ3e5Zs7L2Wm7dkYwMAAAAAABNHpTAAAAAAAABAGRMKAwAAAAAAAJQxoTAAAAAAAABAGbOnMAAAAAAAAJSxisqqUk+BElMpDAAAAAAAAFDGhMIAAAAAAAAAZWy6CoX/+eef9MILL6Tffvttgs5NDX379s3jjxw5coLOjc+oUaNS9+7d0xtvvJF/jhgxonhu0KBB+Z6//vrrOD//+uuvp2+//TZ988036YMPPkhTw/fff5/nNXTo0Em+V/V5x/N/9NFHaXL68ssv08cffzxZ7wkAAAAAAADTmukqFB4wYEA64IAD0rvvvjtB56aECHjPPffc9Pbbb+f3v/zyS7rrrrtycDu+c3X19NNPp3XXXTcdeOCB6Zprrkn77rtv2mCDDdKrr76azzdu3DiddNJJ6bLLLhvr53v06JH23HPP9MMPP6T3338/Pf/882lqiDkdcsgh6fHHH5/gz0agv//++xffV5/3nXfemS6++OLJOteuXbumK6+8crLeEwAAAAAAAKY1DUo9genVkCFD0o033phWX331/H6xxRZL1157bbGKd1zn6uKhhx7K4eo555yTNt5443wsAuUIRSMkjoA57rnZZpule+65J51yyimpUaNGNe7x4IMPplatWqU11lgjNWgwdb7mXr165VB+k002yfPaeuutJ+jzURX8yiuvFN9vt912U2CWAAAAAAAA9UtlZUWpp0CJTVeVwhMjKojffPPN9Pnnn6dhw4YVj/fp0ye3Vw6fffZZeuedd9LgwYPH+Pwff/yR3nvvvXxtoTV1tHUuhJfR0virr74qtoiO8HZc5wrto+PzX3zxRa4k7t27d43xou3yGWeckSuDC4FwqKqqSkceeWSab7758r1ChK7xfIX3BTHOww8/nEPjCISrt2GO+cQrxo3xYx3G1kZ59GOxNlG5G880cODAsa51BNHzzjtv2nHHHdOHH36Y71FdtICOY/E9xL1i/EKb6ZhHfA+xNvE8se5ja3sdn405xNzGVnkdVdnRbvvrr78e6xzj2eN89WcofD+jf/8x36nVdhsAAAAAAACmlLKuFL777rtzG+cFF1wwV+9GEHj++een5ZZbLoeKxx57bFpyySVTz549c6VthL6XXHJJWnnllXNYeeihh+YwOT4fIWUEjQcddFB+3XfffXmMCBNnnnnm1KZNm9y+OsLQcZ2LMWMOe+yxR94Dec4558z3j/lcfvnlqbKyMr388ss56N18883HeJ6Kior06KOPFt+3b98+z/+RRx7JraULIvSMcLRQqRvrEGFstEu+/fbb8zz69++fWrRokbbaaqs8h9ib+IYbbijeI66NZ44K5wjVDzvssBxIzzDDDDm8jffxHAUR5kaF8/rrr586duyY5phjjjxuVDEXRAvoQiA922yzpR9//DEH2Lfeemv+fl577bV8n6iEjrlFC+rCvEM8U6xLrOnPP/+cx7jiiitS69atc+X2iSeemF588cW0yCKL5L2U27Ztm9c1KqZj3eN7i/Hnn3/+/LwtW7ZMs846aw7c47uOuW6zzTbF+R5zzDG52nuZZZaZbH+TAAAAAAAAMLVNl5XCEWJG4Fr9FYFidRHgnnnmmTnUjJAxwtRdd901HX744Tl0Df369cvh5FNPPZWD1QgEoxo3KkajOnjGGWfMe/tGK+g4v/fee6cuXbrk8PbSSy/N94j77bzzzsVxx3euEIzGfsAx5k033ZSDz6h4jRCzsBdwVPdGoFkXEepGkBzPUvDAAw/kIDNC47GJCtgY+/7770877LBDrWNEUL7TTjvlkPe2227LzxeVvhHgFrz11lvpp59+Sp07d87h9XrrrZfXPMLa6mJdoxI61uHZZ59NzZs3TzfffHMOt/fbb7+8fvGdLb300mPMI9Ymvp+YR3wvMX602A4XXnhhvvcTTzyR5xj3jsA5gv8Q4XCEyrHud9xxR35fqGSOOay99to51K4+VoTfUW0NAAAAAAAA07PpMhSOVs4R9FZ/VQ/0Cq2MoxI3KkQLwfHcc8+dq18j0Cw44ogjcogZYr/eaCUclbarrrpqDkObNm2az0XlcISHhXbHEysqkr/77rt077335rEilL7mmmtShw4diu2Ro3K1rqLFdASpTz75ZH4fz/vcc8+Ndz/feeaZpxg612Wshg0bpm7duuXw+e+//877FF922WXFdSus9+yzz14Mc6NyOcL3CL2ri2rjFVdcMf8e4XhUSUeldl0svvjiad11182/R2AflcoRDkfVdQTQEVxH1XCYaaaZcnX2q6++mr/zmEeE/rPMMks+H3syr7XWWsV7R/gb+yFH9XJ47LHH0hJLLDHOYB0AAAAAAACmF9Nl++h99tmnxn67IQLWaPtc8MMPP+SK3wiMq1tzzTWLFa4RHEaQWRDvI/iN1sQhgsYImyPE/f3334uB46SIIDPuFRWuJ510Ulp00UXT9ttvn18hWiJH8PrXX3/luYwuzkWwXBCtlCMojUrm2Ms3KmUjrN1www3HOYcJfY5ouR2tmSNkjSrmCHX333//HOiGaP38zDPP5GrfaN8coko3Qt977rmnRkvmCMGri/sV9lquzejV0xFuR5V1fNdRKR37GY/t+qhgjjWP66uL6wsV2vF3EYFx7MUcbaYjFB69yhsAAAAAAACmR9NlKFwXEZZG6BetiMcmKoej6jcCyai0DfF7BJzx2ajkPf3003MlcbQsXmCBBXJV6lFHHTVJ84o9eY8//vj0n//8J3300Ue5qvfUU0/Nc9l9991zhXKIauXq+wQXxHwiGK6+/2+0kI6gPMLPwr6+EXCPS+F5C6pX/BbEGNVD5Ouvvz5X/sb+wtF2OuYa1cGx33K0ZI4APp6teggfe/fGM0ab5oUXXnicY9XV6K2oIzgPc801V67oLrQFH/187E8cQXrsozyu+8Xc4x8aREVxVBBHxfDo//AAAAAAAABgelRROfH5DOVhumwfXRexp24Ekr169Soei9bMUcka7YTD8OHDcyvqgldeeSUHwyuttFJulbzsssumPffcM1fzRgvlwr7FUZ06vrbL4zv3wQcfpG+++SaHkFFpG3veRpviQsVqtLyOMPKKK64YI+SMz8a8Yt/e6lZZZZVcYRx76UZr7PG1jh6bCJCjkrYg1uDTTz8t/h5rFpXYzZo1y3sFR+VwrF2h7XOEw/EMsd9yhPCF13XXXZefM/YArovaWlnHs1UPcqOldbSBjlbS8X1HwF5d7CscleBRIbzCCivkfwhQEN9hBO/Vbb755vl7uOiii9Jqq62WWrZsWad5AwAAAAAAwLSsbCuFIxiNat9o17zffvvl6thoCfzbb7/lSteCaIu877775pbSEcRGW+SojI1A+MILL0w33nhjDlwjgCyEwlGBGtWnUZ0aVbKjV79GVeq4zn322WfpyiuvzPsXx33j/eeff56OOeaY4jXRVjrmHBXA0RI6guIvvvgide3aNW255ZbFVtMF8WwRaEY1b5s2bdLyyy8/QWsVIfPNN9+czj333BzuRivqQvga977zzjvznGPP3mgJHedjf+Zo1x2he+zFe9ppp41x31atWhVbWx999NG1ziNC2AhrY7xCa+rq4lysS6xJBOQRRt900035XNx/hx12yFXda6+9dvrkk0/SHXfckS644IL8DFHhHfM/7rjjcogeFcERhFdvSR3tr9u1a5f3IY79pAEAAAAAAKAcTFehcFTrRmvfse2JO/q52Ks2QtSoUo1q4Hgf+8Zuu+22ObAtuPTSS3PL5YEDB+Zgs1CFu9tuu+UK2qgm7d69ew5aI6yNyt4IQiPAvOyyy/KeuR9//HGuLI3xI4CMIHhc53bZZZcc8kb17dtvv52D4bhukUUWKc4pAucINKPS9a233koffvhhfq6ovo2K13GF4NGmOeY/ehDdoUOHHOaGhRZaKN+/uo4dO+Z21BHeRrXtJptskrbYYotc0VxYo/vuuy+vY7SVjurcM888M69jrE8827haLe+11145YI5QO+ZRfe0LcysciyA+wvEI36MldPV5x+//+te/0qyzzprbeEeL7wiPF1988eJzxfcYxyKMj3WNfxRQaFsdP+MfA9x+++15XaNNdwTWv/76a435xLPfcsstqVOnTmN9HgAAAAAAAJjeVIyKEtl6KFoJH3DAATm0jcpeCBFKxz8GiH8AMKn+HtCvJItaMXJ4ScatHPBbKpWBs7QrybizzDRjSca98d3/a91eCnstN2/JxgYAAAAAYOIs8K8HLN1ovrlqq1SfTFeVwjClRMXzV199lZ5//vn0wAP+hxEAAAAAACgfo3eZpf6pTPVUtCEutHSG7777Ln300UfpqquuyvsyAwAAAAAAQLmot5XCSy65ZN6jF8LOO++cXwAAAAAAAFBulMkCAAAAAAAAlDGhMAAAAAAAAEAZq7ftowEAAAAAAKA+qKysKPUUKDGVwgAAAAAAAABlTCgMAAAAAAAAUMaEwgAAAAAAAABlTCgMAAAAAAAAUMYalHoCUK6e/+nvkoy7bovBJRn3+A9SyRy66siSjDtLSUZNafV5W5Ro5JR+7DuwJOPO03KmkowLAAAAAADlQCgMAAAAAAAAZayisqLUU6DEtI8GAAAAAAAAKGNCYQAAAAAAAIAyJhQGAAAAAAAAKGNCYQAAAAAAAIAy1qDUEwAAAAAAAACmnIrKCss7Gb388svptttuS3379k0dO3ZMBx98cJp55pnHuO6HH35IBx100FjvsdBCC6ULL7wwDRo0KO2www5p1KhRNc4feeSRae21155scxYKAwAAAAAAANQxED700EPTMccck9q1a5cuu+yytN9++6U777wzVVTUDN/nnHPOdNFFF9U41r179xz47rXXXvn9N998k18PPPBAqqqqqvHZyUkozCT7+uuv06233po++OCDNHjw4NSmTZu01VZbpc0337z4x3/xxRfn666++uo63/eCCy5I33777QR9ZkJMzJwAAAAAAACovy677LK08847px133DG/X3jhhdMaa6yRw+I111yzxrUNGzZMCy64YPH98OHDcyC88cYb5ywtRFY1zzzzpEUWWWSKzlsozCR54okn0vHHH5//+ONfOjRt2jS9+eab6fTTT88h8amnnpqv23///dOIESMm6N4RMA8cOHCKfUMTMycAAAAAAADqpwEDBqRPP/00HXHEEcVjs8wyS1psscXSa6+9NkYoPLq77747/fjjj6lLly41Kofbt2+fpjShMBPtl19+SSeccEIukS+UuIdtttkmh8OHH3542myzzdKyyy6bZpxxxmlupafFOQEAAAAAADBt+umnn/Lev6O3do73vXr1Gu9nhw0blrvX7rLLLql169Y1QuHKyspcQdyzZ8/Utm3bXNjYoUOHyTp3oTATrdDbPP54R7f++uuna665plgSX71V87nnnpv++uuv1K9fv/Tll1+mAw88MH333XdjHCuU0cd9nnzyyfyvL9ZZZ5101FFHpcaNG+fzr7zySrrhhhtSjx49UsuWLdN2222XN+MO/fv3T+edd15655138n9MUb4fm3kvsMACY8yptmsBAAAAAAAoH506dRrv+W7duo1xrNDhtpBTFTRq1Cj17du31u67kYPtuuuuNY5HKNysWbN8fKaZZkr3339/bi1977335rxqcqmcbHei3vnwww/Toosumvuhjy6C1bXXXjv/EY/eCnrQoEH5D3qVVVZJ1157bVp55ZXHeiy8//77uSL5iiuuSGeccUZ68MEHiyX18R9PhMcRFHft2jXtvffe6cILL0xXXnllPh+tq3/99dcc+l533XX5P9BC2Dz6nGq7FgAAAAAAYHpVWVHhVVFzDSbGDDPMkH+Ovj1pvB89KB5dZFzRXnr22Wevcfymm27KAfBaa62VlltuuXT22Wfn/YUjs5qcVAoz0eJfM4xeHl9XrVq1GqPCeFzHTjnllBwyt2nTJq277rp5r+Jw1VVX5X8psdtuu+X3cf6PP/7IFcD77LNPrgJeeumlU7t27VJFRUXe5zgqgqOsP95XNyHXAgAAAAAAMH3rNpZK4NoUAt0///wz51IFUSU8ethbXXTLfffdd9M555wzxrmxtYlecsklc3fbyUmlMBOtefPmuaXzxJhnnnnqdGzeeefNgXDBzDPPnIYMGZL++eefXE7fsWPHGtfHv6CI899//3064IAD8r+6WH311dNxxx2XnnnmmbzX8dhC3gm5FgAAAAAAgPpnzjnnzAWNn3/+efHYyJEj0xdffJGD3HGJgsfYMnXVVVetcTy65W6yySbpk08+qXE89haee+65J+vchcJMtMUXXzz/kUc17dj897//TS+99NJYz42thH5sx2LP4tEVqncbNGhQLNMf/foIkjfeeOP03HPP5TbQUdUcYe/222+fK4BHNyHXAgAAAAAAUD9ts8026YYbbki//fZbfh/bokYxY2RN4xIh8lxzzZVatmw5Rsgcedcll1yStz0tbJ/68ssvFzvlTi5CYSbapptumiuFn3zyyTHORUn7nXfeOc7AeFLFfyBRlv/ZZ5/VOB7vIyiO/7DCHHPMkXbeeefcd/3RRx/NIfZbb7011ntOyLUAAAAAAADUP//617/SEksskTp16pRWWWWVdPfdd6crr7wyNWvWLJ/v2rVr2nzzzceoCC5kV6O7/PLL09ChQ9Nqq62WO9qeeuqp6YwzzkgrrbTSZJ23PYWZaO3bt8+VtSeccEIaNmxY2mijjXKl7ptvvpkrbddff/28YfaUsvfee6ezzjorl9rHf3RfffVVuuKKK/I+wzPOOGPabLPNUufOndP++++fg+KPPvooVxDHvKuLsv4tttiiTtcCAAAAAABMbyoqbZc5uTRs2DBddNFFeR/hqO6Nat/qnW8jLxs90D3ooINyHjU2UQR5++23532H4xXhcRRHTm5CYSbJwQcfnP84b7zxxnTSSSflY1H6vuOOO+bQdkruyRvl+fEf3JFHHpkGDRqUGjVqlLbbbrt0+OGH50D3tNNOy68o24//GGNeF154YZp//vlr3GdCrgUAAAAAAICWLVuO0Q46zDrrrPk1erfa2jRv3jy/ppSKUVOqvy/1zogRI3LP9LHtDRz/UiLOR+l8/B7/GmKmmWaqcX5sxwqfGd+x+BOOULj6Z6uLjbv//vvv1LRp03HOqbZrJ8aTX/5fL/mpbd0W/9dzfmo74e3SjBsOXbVtScadp+XY/+amtO69B6RSadKgol6tNQAAAABAOVj8qMdKPYVpzqcXbJLqE5XCTDZRYVu9PL66aOc8tt8nx7GoRh5XIByixH5sZfZju9e4rgUAAAAAAIDpVWWpJwAAAAAAAADAlKMkEgAAAAAAAMpYRWVptgZk2qFSGAAAAAAAAKCMCYUBAAAAAAAAyphQGAAAAAAAAKCMCYUBAAAAAAAAyphQGAAAAAAAAKCMNSj1BAAAAAAAAIApp7KywvLWcyqFAQAAAAAAAMqYSmGYQtaZa4aSrG2fUbOXZNwzVh+USuXSj34tybj/WXOBkoxbVcJ/zvPHkOElGbd17x6pVGaYfb6SjQ0AAAAAAJODSmEAAAAAAACAMiYUBgAAAAAAAChj2kcDAAAAAABAGatQJlrv+RMAAAAAAAAAKGNCYQAAAAAAAIAyJhQGAAAAAAAAKGNCYQAAAAAAAIAy1qDUEygHH3/8cXr00UfHeX7jjTdOSy+99ETd+4knnkgDBw5M2223XZoSnn322fTbb7+lXXbZpc6fGTVqVHrnnXfSBx98kAYPHpzatGmT1l9//dSsWbM0NfXv3z/NPPPMk/XZAAAAAAAAoNyoFJ4Mvvnmm3Trrbem2WefPc0999xjvJo2bTrR937ttddSt27d0pTSvHnzNNtss9X5+l9++SXtsMMO6bjjjsuhbKNGjdIjjzyS1lprrfTqq6+mqeWLL75IG2200WR9NgAAAAAAgHJUUVHhVVFzDeoblcKT0U477TRJAXAprLDCCnW+dtiwYemAAw7I4XfXrl1Tw4YN8/F//etf6fTTT08HH3xweu6556ZKEPvDDz+kvn37TrZnAwAAAAAAgHIlFJ6Knn766TRixIg0//zz5/B0+PDhaZ111klLLrlk8Zo+ffrkVtTxc8011xzjHkOGDEmPPfZYDkXnmmuu3LZ51llnrXH/BRZYID311FOpsrIyt65u27ZtevLJJ9OXX36Z2rdvnzbddNNUVVU11hbLgwYNytf26NEjh7sbbrhhat26dbGVdffu3dM111xTDIQLDj300BzS/vrrr8VQeOjQofkzca+WLVvmyt4IlAv3ikrjqDoeW6vs8a1VVGY/+OCDaeTIkenMM89M22yzTfruu+/yPeJfdsRzrrbaaunPP/+s8WzjW7vw9ttv51eszcILL5zWWGON4joBAAAAAADA9Er76KnorbfeShdddFE67LDD8r6833//fQ5AX3rppXw+3m+yySbplVdeyW2Z//vf/6aXX365+PkIObfYYov08MMP54rkd999Nwetsadx4f6XX355Ovroo9MMM8yQz0dgGtW9zz//fA6JzzrrrHT22WcX7xkhaASwIQLUzTffPN19992pcePG+b5x/88++yyff/HFF9NCCy2U5pxzzrG2ar744ovT4osvnt/37NkzB8r33HNPfpY333wzv3/vvfeKbbEjkB5Xq+zxrVXcL0LmCICjPXeTJk3SG2+8kU499dQ89wiTI9yu/my1rd3NN9+cjjjiiBw+R9gc63TkkUdO1u8fAAAAAAAASkGl8GR0wQUXpAYNai5pVJoee+yxxfe9e/fOYWih+naPPfZI999/f64KjlC1Q4cOqUuXLjnw3H333dO6665b/Oxll12WP3fLLbcUe52ff/756aSTTsphZ/jpp59yeBuhabSzjhbKEdjGdaFFixbpxhtvTCeeeOIY87/iiitywHrnnXcWn+OZZ57J1bshqoAjhK2LCJ5jrrfffnux2vaYY45Jxx9/fDGorc241irWIdYrnjmOFfz999/5GQotvKvvcVzb2j3wwAN5vffbb798brPNNksvvPBCDqTrY195AAAAAAAAyodQeDKKlsRRoVtdVOdW165du2LIGeabb75i6+OoED7qqKOKIWSzZs1yy+TC3rlRJRvtl6OKteDnn3/O7ZILwW20jo5AOEQYPOOMM6bllluueH20du7Xr99Y5x+Vuttuu22NYLtz587F3+N4VNLWJoLUuFeE4dXbL0fV8kMPPZR69epV6z1qW6uxmXfeece5p3Nta7fEEkuka6+9NlcUR9voZZddNu222251micAAAAAAMC0rLJSAVx9JxSejKIyd1yhZMHMM888RmgcIeqwYcPS4MGDcyVvdRHiFkLhqJxdaqmlalTrxu/LL798bpkcxjZ+tIIuiMA5xhub2OO3ECiPTexN/MEHH4zzfLRrjkrnCKKjarf6fr2hcO8BAwakuhjXWo3L6GtXXW1rF62nC3sxRzVxrNk+++yTDjzwQJXCAAAAAAAATNeEwtOIhg0bpllmmSXv61vdH3/8Ufw9qmajGrl6y+TJKfYK/v3338d5vlOnTum+++5L3377bWrfvn2NcxFc77nnnrnSOX5GmP3LL7/UuKbwPsLiCHhj797q6hoWT4y6rF3MO15//fVXfs7zzjsvdezYMa200kpTbF4AAAAAAAAwpdXsbUxJrb/++nnP3KFDhxaD1m7duhXPx/7Ccb56UPz666+niy66aIyAdWKstdZa6dFHH01DhgwpHot2z7Hfblh77bVzW+XjjjsuB6cFURV8wgkn5CB46623LgbI9957b65+DlGNe+utt6bFF188B7Tx+v7779M///xTfNaoNK6raGU9vqrh0Y1v7aIlduwv/NlnnxXbbm+44Yb598mxrgAAAAAAAFBKKoUnowsuuKDGfrwFEYRuvvnmtX7+iCOOyJWqcW1UqL755pt5H9yCQw45JL333nv5fOx7GwFnBKknnXTSGHsXT4z9998/7wW82WabpZVXXjlXLX/88cd5r91C6+krr7wyzzNC3zXXXDPvofzWW2/lttVdunQptnyOa3bfffe06aabphVXXDF9/vnnuT319ddfn89vscUWqWvXrmmHHXZIiy66aHrjjTdy6+m6mn/++fN+xYceemjeq7g241u7+M6aNGmSq4gjGI/fX3755fyMqoQBAAAAAACY3lWMmpByS8bqm2++Sa+++uo4VydaLa+++uo5PP3zzz/TBhtsUDw3+rGoWo1AMgLZ5ZZbLgep/fr1ywFloXI1wuKoso0ANgLXQnA8tvvffvvtOdgstHuOz0Xwu8suu+T3EYxGlW7hM1HRG+d79eqVWrVqlVZdddWx7lP81Vdf5VdUCcdewzHX0YPpeJa4148//phbU6+22mq5TXZBzPWll17K1cJxLoLa2Ps3nrUuaxWB9SeffJL3Be7Tp09uP925c+fi9aM/2/jWLkRb7LhnVGovuOCCuSp6Uvzd///2gp7a/hzVqCTjthw1KJXKpR/1L8m4/1lzgZKM+90fU67Vem36//1/+5dPbYvN0C+Vygyzz1eysQEAAAAAJodlT3rKQo7mvdP/l0HVB0JhmEKEwlOPUHjqEQoDAAAAAEx/ljvl6VJPYZrz7qnrp/rEnsIAAAAAAAAAZUwoDAAAAAAAAFDGhMIAAAAAAAAAZUwoDAAAAAAAAFDGGpR6AgAAAAAAAMCUU1FZYXnrOZXCAAAAAAAAAGVMKAwAAAAAAABQxoTCAAAAAAAAAGVMKAwAAAAAAABQxhqUegIAAAAAAADAlFNZUWF56zmhMEwht389sCRru9NiTUoy7gNf/5NKZdel50z1SfNGVSUbe5YSjd19UMtUKq0HDC7JuLM2m7Ek4wIAAAAAUH60jwYAAAAAAAAoY0JhAAAAAAAAgDImFAYAAAAAAAAoY0JhAAAAAAAAgDLWoNQTAAAAAAAAAKacisoKy1vPqRQGAAAAAAAAKGNCYSab3377LX377bepf//+U228H374YaLPAwAAAAAAQH2gfTST7KWXXkpnnXVWDoObN2+ew9jFF188nXLKKWmBBRaYYivcpUuX9OWXX6auXbuO9fyjjz6avv/++3TmmWdOsTkAAAAAAADAtE4ozCT57rvv0kEHHZROPfXUtPXWW+djgwYNSieeeGLac8890zPPPJOaNGlSklXeZ599SjIuAAAAAAAATEu0j2aSvPzyy6lRo0bFQDg0bdo0/ec//0ktW7ZMX331VT4W1cO//PJL/r1Xr17pp59+Kl7/999/53B5yJAhYx1j2LBhueK3X79+451LfP6LL75If/zxxxjto6uP//PPP6eePXuO9R4xRsxv1KhRqW/fvqlHjx4TuCIAAAAAAADTlorKCq/KmmtQ36gUZpLMPvvsaeDAgem2225L22+/fZphhhny8bnmmis9/PDDxeuuvfbaHMZGi+kIbX/99de0wgorpC233DKde+65+ZoBAwakCy+8MK2zzjr5/fDhw9NFF12Ubr/99tSqVavUu3fvtNZaa+VW1TPNNFONeUR18r777pt/3nzzzWO0l47xIwj+888/8yvmMO+886brrrsuz/Wff/7J7a6j5XSMFaHw0ksvncPre+65x18JAAAAAAAA0y2VwkySzp07p/XWWy+dfvrpadVVV02HHnpoDnELVbnVvfDCC2nvvffOLaUjRH7llVfSNddck4PYqDjeeOON08UXX1y8/sorr0wPPPBAuvfee9Nzzz2Xnn322fTNN9/k1tTjC4RbtGgx1rnGeHvttVd6/vnn83iDBw9ON954Yz4XoXEce/zxx/P5s88+O88TAAAAAAAApndCYSZJgwYN0hVXXJHD2A033DC3bz7ttNNSp06dcrAaFbcF8803Xz4ellxyydSwYcO01VZbpebNm+djUTn8448/Fq+PMHjnnXdOCy64YH7funXrdPDBB6ennnqq2Eo6gt0IhPv06TPeQDi0adMmB89hlllmSausskoOmcN9992Xdt1111w9HFZaaaUcdgMAAAAAAMD0TvtoJouVV145v0LsyRttmSOkXWCBBdK2226bj88666w1//gaNMj7DhdUVVXlltFh6NCh6ffff0/t27ev8ZkIiCNoLuxJ/Omnn6aZZ545fy4C4vGFwhEqVxeh9IgRI/JexFHZPP/889c4H3OPltcAAAAAAAAwPVMpzCT59ttv8/68o1fkRjvpDh06pPfff79G6FtXjRo1Sk2aNMmBbXXRIjrMOOOM+WfsB/zEE0+ktm3bppNPPnm896ysHPufe4TDsRdyhMrVjT42AAAAAAAATI+EwkySCH+POuqosZ6L4LZdu3YTdd+Kioq0yCKLpNdff32MfYGj9XMEz2GeeeZJrVq1yi2r49oHH3xwgseKsHqJJZZIb731Vo3j77zzzkTNHQAAAAAAYFpSWVnhVVlzDeob7aOZJP/+97/THnvskQ466KC0/vrr57A29vt94YUXclXvjjvuONH3jrB59913T3PMMUdae+210yeffJKuv/76dOyxx+bW09XFHsU77bRTOuecc9Lqq6+eZptttgka69BDD817E8f8l19++fToo4+mzz//PC222GITPX8AAAAAAACYFgiFmSQRxj7++OPprrvuSg8//HAOhJs3b573F47wttDmOYLdv//+u8ZnF1pooVz1WxB7Ay+88MLF98suu2zq2rVruuWWW3LYO+ecc6Yrr7wyrbbaasU9gqu3fD7iiCPSF198kedy8MEH1zg/tvGrH4v5xr1vv/329Nprr+Uxttpqq9SjRw9/IQAAAAAAAEzXKkaNGjWq1JOAUvv+++/TTDPNlFtRF0TlcATLZ5xxxkTd88Z3e6ZS2Gmx/z3D1PTQ131Tqaw13//+ccHUNEfzpiUZt8+AmvtfT02laqjx66DhJRo5pdZNS/Pvp2Zt9n//qAYAAAAAYFKtes7zFnE0rx27TqpPVApDSum6665LH330UTr66KNz9XLsXRx7DEfVMQAAAAAAAEzPhMKQUjrppJPSjTfemG6++ebccrpdu3Y5EF500UWtDwAAAAAAMF2rqChVH0imFUJhSCnvfRz7EAMAAAAAAEC5qSz1BAAAAAAAAACYcoTCAAAAAAAAAGVMKAwAAAAAAABQxuwpDAAAAAAAAGWsQplovedPAAAAAAAAAKCMCYUBAAAAAAAAyphQGAAAAAAAAKCM2VMYppC152tRkrWd4Yd3SzJu5/mXTaUy83evlmbgpTqXZNiZ3nswlcyyG5dk2BaNZ0ilMvOQ3iUZ96/K1iUZt3nTJiUZFwAAAACAKUelMAAAAAAAAEAZUykMAAAAAAAAZayysqLUU6DEVAoDAAAAAAAAlDGhMAAAAAAAAEAZEwoDAAAAAAAAlDGhMAAAAAAAAEAZa1DqCQAAAAAAAABTTkVlheWt54TCTJInnngiXXXVVcX3lZWVaaaZZkqLL7542n333dPcc89dPHfdddel77//Pp199tm13veaa65JP/74YzrjjDMmem5vv/12WmGFFSb68wAAAAAAAFAOhMJMkr/++it17949PfzwwzkQHjFiROrTp0+688470+abb55uv/32tNBCC+Vrt9xyyzR06NA63bd37945FJ5Yr7zySjrggAPSZ599NtH3AAAAAAAAgHIgFGayWGCBBVKDBv/7c1pllVVypfAJJ5yQ7rvvvnysVatWU221Bw0alEaNGjXVxgMAAAAAAIBplVCYKSKqhvfaa69crfv111+nBRdcsEb76Ahs77nnnvTaa6+ln3/+OQfKHTt2TP/6179y++mCO+64Iz355JOpoqIi7bjjjmnDDTcsnvviiy/S9ddfn3r06JHbVG+77bZpjTXWSO+8804655xzctXyJptskoPplVdeeZzXh6hgjpbV8dmY+8ILL5z23nvvNMccc/gLAQAAAAAAYLpWWeoJUL5iX+HwySef5J+///57sSX0lVdema6++urcYvrUU09N2223XW45fcUVV9TYE7hbt27pkEMOyWHwcccdl+6999587quvvsoh8fzzz59OOeWUHO4eddRR6YEHHkiLLLJI2mOPPVJVVVW66KKL0hJLLDHe68OZZ56Z3nzzzXTYYYelf//73zmo3nfffUuwagAAAAAAADB5qRRmipllllnyz/79+49xLsLg7bffvthSerHFFkuvv/56+vbbb4vXzDzzzOnyyy9PM844Y1phhRXyPsMRGkeF78UXX5w22mijdPDBB+drl1pqqTRs2LB0wQUXpK222qpY4RsVyqG26z/44IO0+uqr53HC+eefnwPsqGiOKmUAAAAAAIDplawDoTBTzN9//51/Nm7ceIxzbdq0yWFxVAJHO+fvvvsuh8JR5Vuw9NJL50C4YPnll09XXXVV6tOnT/r4449zm+doD10wePDgfC4qkkdX2/VRRXz66afnOUQVcbyWXXZZ/yMJAAAAAADAdE8ozBQTQW/o0KHDGOeeeuqp3A66bdu2uUp40UUXTX/88UcaPnx48ZrqgXBo1KhR/hnXDBw4MO9ZHNW/o2vevPkYx2q7fuedd857Gj/99NN5n+PYeziqhq+99trUpEmTiVwBAAAAAAAAKD2hMFPME088kdtDR8Xv6M4666y09dZbpxNPPLF47IUXXqhxTc+ePWu87969ew6KZ5999hwm//bbb8X20LW1Qajt+hBVyvE6/PDD06effprnFwHxuuuuW+dnBgAAAAAAgGlNZaknQPmJfXjvv//+dPvtt+dq4AYNxvy3B1HtG3v6Fjz00EM5gK1+7JNPPknPPPNM/v2XX37J1bu77bZbDnyjsvfRRx/N7Z7DiBEj0iWXXJL23nvvNHLkyFxVHD+jhXX8HN/1MZddd9013X333cWxC/sgzzPPPFNwpQAAAAAAAGDKUynMZLHFFlsUw9bYo3e22WZL55xzTtp4443Hev3JJ5+cq4SjOjhC5Kjk3WmnndKTTz6ZQ9wQ7Zsvv/zyfJ+4Z+fOndOBBx6Yz2233XapV69e6YADDkgtWrRI/fr1S/PNN186++yz897BSy65ZGrdunXq1KlTOvTQQ8d7fYTW++yzTzrllFPyeLEH8l9//ZXnt/DCC/sLAQAAAAAApmuVlTU7rFL/VIyKRA4mUoSn0Za5oKqqKreMnnnmmce4NoLdoUOHpjZt2uT3URUcn5111llzW+jBgwenH3/8Mc0///ypb9++ORyOYDeONW3aNLVs2XKMe8b9ooo4xov7VBdVwj///HOez0wzzVTr9TFeYY5zzjlnatiw4ST9XXz/x4BUCvP+8WFJxv1r7mVTqcz83aslGbfBUp1LMu7fL96eSmbZsf9Djymt74gZUqnMNuz3kow7uGnrkozbvKl91AEAAACg3HS67JVST2Ga0+3Q1VN9olKYSdK8efP8qosIZ6uL0LUQEIcIhgt7/sa+wQXVrxldVPW2a9durOeihfTo58Z3fVQYRwgNAAAAAAAA5cSewgAAAAAAAABlTCgMAAAAAAAAUMa0jwYAAAAAAIAyVlFZUeopUGIqhQEAAAAAAADKmFAYAAAAAAAAoIwJhQEAAAAAAADKmFAYAAAAAAAAoIwJhQEAAAAAAADKWINSTwAAAAAAAACYcqoqKyxvPScUhilk7qpBJVnbUTPPXpJxBwwbmUpl5lnnTvXK8puVbOiqv34uybgDG8yVSqXVP0NKMm5Vif5/tB/6DCzNwCmltrPOVLKxAQAAAADKmfbRAAAAAAAAAGVMKAwAAAAAAABQxoTCAAAAAAAAAGXMnsIAAAAAAABQxqoqK0o9BUpMpTAAAAAAAABAGRMKAwAAAAAAAJQxoTAAAAAAAABAGbOnMFPF999/nz744IM0ZMiQNM8886SVV145NWzYsMY1b7zxRurXr1/acMMNp8gc3nzzzdS3b9+00UYb5ffDhg0bYw4AAAAAAABQblQKM0UNHDgwHX744WnrrbdOr7zySvrmm2/S5ZdfntZYY430xBNP1Lj22WefTXffffcUm8ugQYNy6By+++67tOWWW06xsQAAAAAAAGBaoVKYKWbkyJHpoIMOSgMGDEhPP/10atWqVfHcgw8+mI488sg0wwwzpPXWW2+qfAudOnUq/v7111/n6mUAAAAAAIByV1VZUeopUGJCYaaYqPx966230lNPPVUjEA5Rpfvuu++m008/PYe1lZX/K1r/7bff0uuvv54qKirS2muvnZo3b14jaH7ttdfSDz/8kOaaa67chrpJkybF8z169Mj3raqqSgsvvHBaZJFFxmgfvcQSS6QXXnghjRo1Kt1www1pqaWWSh999FGeU8uWLYvXxzgRaG+wwQb+SgAAAAAAAJhuaR/NFPPMM8+kRRddNM0333xjPR8hbATA77//fvFYVO/uuOOO6e2330533XVX2myzzVL37t2L7Z932mmndOaZZ+ZjXbp0SZtuumn69ttv8/mHH344t6l+77338v7Fe+65Zw6dC7p165buvPPOvJfwX3/9lUPhP/74IzVu3DhdddVV6ZFHHqkxv9NOOy316tVrCq0OAAAAAAAATB0qhZliIuBt06bNOM/PP//8+WfPnj3Tcsstl3/v3bt3uu+++9Jiiy2WQ9v9998/h8A333xzuuaaa9Lw4cPTo48+mttOh5NOOim/7rjjjnzNfvvtlz8TIlx+/PHH832i6rigffv2aYsttkgvv/xyOuaYY/Kxzp07p4ceeijtscce+f2nn36a5xWhNAAAAAAAAEzPhMJMMRHGNmgw7j+xQrA7YsSI4rFll102B8IhgtztttsuHXzwwWno0KF5X+IImW+99dbi9fHZqDQePHhwmmeeedJtt92WGjVqlNZYY43cOrp6++jxiZD4gQceSF999VVaaKGF0mOPPZZWWmml1Lp160lYAQAAAAAAACg97aOZYiLA/eWXX8Z5vtCaOcLcgtFD2NiLOMLl33//Pf3888/5WLR8Lrxiv+FoEx2h8bnnnps22mijXDG84YYb5r2KI+itixVWWCHNPffcuVo4xnviiSfS5ptvPpFPDgAAAAAAMO2oqqzwqqy5BvWNSmGmmPXWWy8de+yx6aeffsqB6+gieJ1lllmKraND7PVbXYTBlZWVOSyebbbZ0pJLLpkOO+ywcY553HHH5VfsM3zPPffk39u1a5eWWWaZ8c41qpJjf+LYl3jNNddMAwYMyPMHAAAAAACA6Z1KYaaYqNpdYokl0lFHHZUGDhxY49wbb7yRK3r//e9/F9tIh/feey/16dOn+D4qfaONc8OGDdOqq66aHnzwwTRo0KDi+c8//zzdcsstea/huN8PP/xQ3Dc49hcO/fv3H2Nu0dY6KoKri8rgqGw+55xz0rrrrpuaNm06GVcDAAAAAAAASkOlMFNMVVVVuvrqq9ORRx6ZNthggxwSt2zZMge5L730Uj6+/fbb1/hMtIPeaaedctXuhx9+mD755JN0xx135HMRIL/55ptpm222Seuvv34Oj6PaeN99980h7/fff5+D4fhs48aN07PPPpuWXnrptMoqq4wxt2hZHaHwWWedlTp37pyrleeff/4cYseYEWQDAAAAAABAOagYNXq5JEwBH3/8cXr33Xdz1W4Esuuss04OiKt77rnn8t7A8847b3rhhRfSzDPPnAPeaBtdMHjw4PTUU0+lHj16pGbNmuXq4UUXXTSfiz/lqED+6KOP8n0WWmih3AK6UIncrVu39Ntvv+XQOTz//PM5eI65RHgcrrvuutS1a9f04osv5lB7Ugz789dUCpVDarbgnlp+ajRmi/CpZe4h/1chPrU1mGexkoz796ABqVSq/vq/vb2ntu8bzJVKpd0/P5Zk3KEt5ivJuH2GjEil0nbWmUo2NgAAAACUsy26vFnqKUxzHtpnpVSfCIWhmgMPPDAtvPDC4923uK6EwlOPUHjqEQpPPUJhAAAAAGByEQqPqb6FwtpHQ/yH/9BD6f33388VzWeeeaY1AQAAAAAAykZVZUWpp0CJVZZ6AjAtiFbUrVq1SnfeeecYba0BAAAAAABgeqZSGFJKnTp1yi8AAAAAAAAoNyqFAQAAAAAAAMqYUBgAAAAAAACgjGkfDQAAAAAAAGWsQWVFqadAiakUBgAAAAAAAChjQmEAAAAAAACAMiYUBgAAAAAAAChjQmEAAAAAAACAMtag1BOAcvXLyJlKMu4czZuWZNx/Bo9KpTKycfNUn1T8PaBkY/dv1qYk4zYbWcK/rwal+fsaUaJHnqlh6f692IDBQ0oybrMZm5RkXAAAAACYWqoqKyx2PadSGAAAAAAAAKCMCYUBAAAAAAAAyphQGAAAAAAAAKCMCYUBAAAAAAAAyphQGAAAAAAAAKCMNSj1BAAAAAAAAIApp6qywvLWcyqFJ4O///47/f7772nUqFETdG5aMXDgwNSvX79U39TX5wYAAAAAAKB+EQpPBk899VRabbXV0oABAybo3LTioosuSoccckia1g0dOjRdfvnlk+1+N9xwQzrxxBMn2/0AAAAAAABgWiQUZrrx4osvpquvvnqy3e+www5LV1xxxWS7HwAAAAAAAEyLhMIlEu2k+/fvP9aWxvEKgwcPztWx1dVWcRyfHTFixDjPx5gjR44c5/nhw4enQYMGjXdOdRlzcjzHkCFDiu+HDRtW/Ey04473tc2hegvv0a8fV/vocV0LAAAAAAAA06sGpZ5AfXTbbbelq666KoeeVVVVadttt02HH354atSoUW7l3Ldv3xzcvvbaa/mazTffPG222Wa51XEEojPPPHO6+OKL0/LLL1+850033ZS6dOmSA92Kioq01VZbpWOOOSY1bNiweP7666/PAW3cO84ff/zxxfMRuB555JHp1Vdfzb8vt9xy6ZJLLkktW7ZM5513Xvrxxx/TTz/9lH799ddcYbvXXnuNd8yJeY4///wz/fe//01vvfVW/lwE2Issski68MIL87gxjwh+t9hii3T22WenNdZYY7xz6NWrVzrqqKPSV199lWaYYYbUunXrdPTRR+fPhUsvvTR9+eWXqWvXrrVeCwAAAAAAML2qqlQnWt/5C5iM+vTpk8PO6q9CtWzBM888k8PIaFv8wQcfpIceeiiHphGiFjz55JNp1VVXTe+9914Och944IEclt566635WAS2EYoW3HjjjXmv3QsuuCB9+OGH6e67704vvPBCOv300/P5Bx98MAe8559/fj4f9//888/TPffcU7zHF198kZZaaqn0xhtv5M/26NEjXXPNNcXzr7/+ep7D22+/nbbeeutax5yY54jxIrR+7rnn8jhxvwiGo2X0Kqusku8dIXqsV4S1tc0hxmrfvn1699138/0ikI41iCrt0U3ItQAAAAAAADA9EQpPRjvvvHOuYq3+ikrY6iIc3XTTTVObNm1yaBzVwfG5O++8s9jWeZ555knbb799/j3C0Khc3WabbdLcc8+df1977bVzaFu98ninnXZKK6+8cn6/4IILpkMPPTTdf//9OZS+6667cpVuBLQh7hOB8C677FK8R8xnt912S5WVlblKNkLX7t27F8/PNddc+f4x3+bNm9c65sQ8x3HHHZfXZ6aZZsrv55xzzrTsssvmCuKxqW0O8bkI6v/6669cRbzffvulRx99NP8+ugm5FgAAAAAAAKYn2kdPRk899VRuiVzdww8/nNsQF3z77bfp+++/T08//XSN65o1a5Z69+6df49QtiBCyQhQW7Vq9b8vrUGD9M8//xT3wI22ztFmubpFF100t1ru2bNnHi8qX8en+pihSZMmNfYBjlC4oC5jTuhzhKjKfeWVV9LLL7+c5xyvaBtdCH2rq8scok11hMQRhi+22GI56N5hhx3GeNYwIdcCAAAAAADA9EQoPJVF++ODDjoo7bHHHuO9ZnTjqliNoDX2z60erhZC0xCVvY0bNx7j/OiiQnh8IsCdkDEn9DlCtGuOiukIY2Nv4Ah8r7vuulxRPbq6zCEC4hdffDG9//77ueX0Y489lltMRxvrOeaYo8bnOnbsWOdrAQAAAAAAYHqiffRUttBCC6WXXnqpxrFhw4bl4HNi9q+NMLdDhw7pnXfeqXE83kcb5mgLHec/+eSTGucHDRqU+vXrN1HPUJcxJ0aEsAceeGA65phj0sYbb5zatWuXvv766+K6VA+ua5tDtK4urOkKK6yQjjjiiHz/aBH98ccf1/hMXFPXawEAAAAAAGB6o1J4KosWxbF37wUXXJCrYSN4vOyyy3LL4zvuuGOi7nnYYYfl6uMISddaa60cAF911VVp3333zdW0//rXv9Luu++ellpqqbyP72+//ZbbJUfwesghh0yRMSdGtKiO9tHrrLNOXo+bbropffHFF3neIcLeOB5jxX7D45tDVArvtddeOYTff//9c7V07DU844wzFu9XvXq5rtcCAAAAAABMb6oqx93JlfpBKDwZRIg422yzjbUF8+jnohK1S5cu+RUtimMv4dVWWy2Hm4Xgs3nz5jXuMeuss+b7FETgWX1v3jXXXDNdeumlOUS9+eabc7vjCH232GKLfH7ZZZdNV155ZR7zxhtvzPOJFs0RFI9rzDg2yyyz5N9jjqOfr23MiXmOSy65JLeQjmA25rj66quns88+O11++eW5mnq55ZYrBtmHH354Hmt8c7j22mtz4B5BfLSVXnDBBdMtt9xS3Ce4+hxruxYAAAAAAACmVxWjJqZnMVCrH/oMLMkqzdG4NP9J9xqcSmbeir9KMm7D2eYpybjD+v6cSmXgDP/3j0WmtmEjS/d/qlqOKM3f15BGLUoy7vASrnXDqtL8a8VmMzYpybgAAAAAMLXsfdcHFns0N+ywTKpP7CkMAAAAAAAAUMaEwgAAAAAAAABlzJ7CAAAAAAAAUMaqKkuzdRvTDpXCAAAAAAAAAGVMKAwAAAAAAABQxoTCAAAAAAAAAGVMKAwAAAAAAABQxhqUegIAAAAAAADAlFNVWWF5J6Pff/89Pfzww6lv376pY8eOad111x3ntf/8808655xz0qhRo2oc32KLLdKSSy45wfebWCqFAQAAAAAAAOrgu+++S5tsskn67LPPUuPGjdMpp5ySX+Py/fffp9tuuy3NO++8af755y++mjVrNlH3m1gqhQEAAAAAAADq4IILLkirrrpquuiii/L7zp07py233DLtsMMOaZFFFhnj+u7du6dWrVqlPfbYY7Lcb2IJhWEKmalhaQrx/xpes/3A1DJ3s6pUMkMbpvqkYtiQko3dbMTw0gw8ckRpxk0p/dl49pKMO3L4yJKM+9hXf6RS2WCBWUsy7oy/vV+ScavadSzJuAAAAADAxBk2bFh65ZVXigFuWHjhhdOCCy6Ynn322bGGuF9//XVq3779ZLvfxBIKAwAAAAAAANSiZ8+eOcht27ZtjePx/ptvvhnrZ6JSuHXr1umee+5JP/zwQ5pvvvnSpptumltFT8z9JpZQGAAAAAAAAKhXOnXqNN7z3bp1G+NY//7988+mTZvWOB7vf/vtt3GGwn/88UeaddZZ8z7Ct9xyS+rSpUu66667Jup+E0soDAAAAAAAAGWsqqKi1FMoayNHjkyVlWPfVnTPPfdMyyyzTLEVdLzfeOON02WXXZYrhif0fhNLKAwAAAAAAADUK93GUglcmxYtWuSfAwYMqHE83jdv3nysn9lpp51qvG/SpElaffXV00cffZR22223Cb7fxJq8ETMAAAAAAABAGWrTpk2accYZ03fffVfj+LfffpsWWmihMa7v3bt3Ou2009LPP/9c4/igQYPSzDPPPMH3mxRCYQAAAAAAAIBaNGjQIK233np5P+B//vknH3vllVdSr1690oYbbjjG9S1btkxPPvlkuvXWW4vHevTokauUN9poowm+36TQPhoAAAAAAACgDo488si08847p6233jrNP//86aWXXkpHH310rvoNL7zwQnrttdfSiSeemEPf888/Px1xxBHpiy++SLPNNlu+PoLgbbbZpk73m1yEwrW47bbb8pd30kknpfnmm69Oixol3e3bt5/oLyX+NUDPnj3zF16bm2++Of3555/5j+mNN95IXbp0SZdffnkuNa9ufOempkldmym1jgAAAAAAAOWqqrKi1FMoG61bt06PPvpoevnll3Mb6EMOOaRG9hXVwe3atSu+X2211dKzzz6b3nnnndSvX7+09957p0UXXbTO95tchMLjMWLEiHTNNdfkFP/uu+9OxxxzTK0LGl/oPvvskzeHnljLL798jT+G8enevXv69ddfi33JX3311TR8+PAxrhvfuallcqzNlFpHAAAAAAAAqIsmTZqk9ddff6znllpqqfyqbpZZZsnVwRNzv8nFnsLjESFqJPa77rpreuCBB9KwYcNqXdA+ffoUe35PrEj/l1xyyVRuJsfaTIhyXUcAAAAAAACYECqFxyOC4Kg23WyzzdIFF1yQnnnmmbTJJpsUz3ft2jVXEw8ePDh9+eWXOYB87LHH0siRI3Pp98EHH5yWWWaZ9PPPP+drf/jhhzTXXHPlnuCLLLLIWO8RY/3xxx812h5H7/DoPR73iarljh07ph122CE1bNgwTYyYx2mnnZaOP/74GuXn119/fQ6+DzrooHT77benv//+O80xxxzpqaeeyi2nY96xHgUT8lwTszYxhwiR55xzzrz28fs666yTtthii3w+7n/vvffmCuTKysq08MILp2233TbNPPPMY20f/csvv+R7xgbeUbofvdoLoXFtYwEAAAAAAMD0SqXwOPz111/p+eefz6XcrVq1Sssuu2xuIT166+aLLrooB5trr712WmihhdKaa66ZKioq0u67757mnXfe1KtXrxwsDhw4MG2++ea5PDw2i+7WrdtY7zH77LPnfXc/+eST4p7GEWq2bds2bbnllmnBBRdM5513Xrr66qsn+kuPeX3//ffp/vvvLx6LttKx5/Dcc8+d38ccIiSOcTp16pTD4T333DMHpmFCn2ti1ibmEONHaBwBbQTYxx57bA7rw4UXXpjXJ+4b5+NzBxxwQPGZqq9jtKzecMMNcxvtjTfeODVt2jTttNNO6YknnqjTWAAAAAAAADC9Uik8DlHVGtWi6667bn7fuXPndOaZZ6bvvvsuzT///MXrGjVqlP773//mCt4QG0BH8LnGGmvk92eccUZaeeWV0+mnn57fRz/w+EzcK8LWsd0jNpMuiErWO+64o1jRG5/5+uuv02effTbOL/XQQw9NVVVVNY79/vvvxd9jfptuumkOPI866qhcZRutsqNKuHo/86jyvfHGG3MoHuL8+eefn9ciAt8Jfa6JWZv4DmJf55lmmqkYNkcwvdVWW+UNt+MzUV0dVlxxxbwuo0aNyuNUF/NeaaWVcqAeIiCONYqxNthgg1rHAgAAAAAAgOmVUHgcHnzwwdzeOCp3Q4SPZ511VrrnnntyBWlBVLwWQs+xeffdd3NVarRMLoh9in/66afUt2/fWu8RoXBU8UbYGW2PI5SO6tf55ptvnGPuuOOOeUPq6t5888301VdfFd9HZW4EoK+//npabbXVchAdAXjMtSCqowuBcFh99dXTDTfckKttJ/W56ro28ZyFkDbEfL755pvid3LVVVelTz/9NAfN8Yo5ji7aTL///vvp1FNPrXE8njeqoaNquraxAAAAAAAApldVlTWL6ah/hMJjUWg7HK2UqweWM8wwQw6L//3vfxf3823WrNl4F/jPP//M4WWhOra6xo0b13qPt956K/3nP//JwXDstbvooosWWzyPS1TfFvbVrT6P6qLaOQLnhx56KIe/0Sr7iiuuqHFNtHOurhAYDx06dJKfqzCn2u5RPaQO1SuADznkkPwMsefxtddem/dJjgros88+O39X1UPh2Mu4euAbCu+jQri2sQAAAAAAAGB6JRQei9hrN0LJk08+ObdWLoj2xLGP7dNPP53Dx7EZPUicZ555cig5tuCzLk444YQ8brQ9Ltz7wAMPzK2cJ1VUC1988cXpySefzAFphMnV/fjjjzXe9+zZM69L69atJ+q5JvfahNhPOF4hgu1Ym0022SSttdZaxWsiwI89kX/44Ycan43K65hToRocAAAAAAAAytH/Ek+yCCkfeeSRvOdsBIuFtsTxiqrhOeecM919993jXK2oUI2q1LhPiP1oo7r4yy+/LF5z5513piOPPDJfV5u//vorh5aFQPWNN95Ir7zyymQJhTfeeOP0999/p3PPPTcHqdUD8PDRRx/lvYbDwIED8/7CG220Ud73d2Kea3KuTZw/7LDDchBcEN9NaNGixRjXb7HFFnlv5l9++aX4PNE+O1pnt2zZsk7rBQAAAAAAANMjlcKjiRD0999/T9ttt90Yi1VVVZWPX3rppbnF9NhEe+domxyB5z777JP23HPPvJfvtttum8/98ccfOYiNyt/RQ9ixOfzww3M75GgjHUHooEGDUufOndN7772XJlWEp7EHbwSrEZqOLip5Yx/euC6qhhdaaKF03HHH5XMT81yTc23i/Nprr51ba8dewLGHcuy7HPddaqmlxrj+gAMOyN9ZhNrxHLGPcPw855xzJnr9AAAAAAAAYHpQMWrUqFGlnsS0JFoKRwAaFaRjM2DAgPTBBx+kDh065IB2yJAhaYkllqhxTYTK33zzTd63N1oth6hQjXvHXr8RRjZo8H95fFw3+j0ivIx7x365hfvFZ2edddYcgEb1cOx5vNJKK+WWyBGkLr744ql379656naVVVYp3r9gXOeuu+663D46Knari/15u3fvnm644Yb8udhvt3379mOsx4Q814SuzejrMLZj8XvcL/Y5XmCBBfIajeva0KtXr/z9RlVxrOX4rh3bsQnRZ8DgVAojRpbmP+lmjapSqVQN7V+ScRvOUprW4//8OvZ/lDJVVP1vv+6pauT/dRgohT8bl+Z7rr2XxJTx2Fd/lGjklDZY4H//Gz41zfnX1yUZt6pdx5KMCwAAAED9c/Sjn5V6CtOc8zZdLNUnQuF6bPjw4WmbbbZJO++8c67WHVso3LVr15LNb3onFJ56hMJTc7GFwlOLUHjqEQoDAAAAUO6EwmOqb6GwPYXrqdhHOPYUnnHGGcfaOhoAAAAAAAAoD/YUrqd22mmn1KlTp7T00kuP0Wo6RPVwtE4GAAAAAAAApm9C4XqqTZs2+TUuY9s/GAAAAAAAAJj+aB8NAAAAAAAAUMZUCgMAAAAAAEAZq6qsKPUUKDGVwgAAAAAAAABlTCgMAAAAAAAAUMaEwgAAAAAAAABlTCgMAAAAAAAAUMYalHoCAAAAAAAAwJRTVVlhees5oTBMIU0blOZ/YEeWqAFA5bDBqVRGNWiU6pNRjZuVcPCRJRm24p+hqVRaDO1dknFHNWpaknFXmbdFqm8Gt16kJON+3atfKpVl28xSsrEBAAAAgKlP+2gAAAAAAACAMiYUBgAAAAAAAChjQmEAAAAAAACAMmZPYQAAAAAAAChjVZUVpZ4CJaZSGAAAAAAAAKCMCYUBAAAAAAAAytg00z76n3/+SR9//HH6448/0myzzZYWX3zx1KhRo+L53377Lb355ptp0003TZWVUyfL7t27d3rjjTfqNOaQIUPSM888U+NYfGbGGWdMCyywQGrbtm2aWn7++ef0zjvvpM033zy/f+6559Lcc8+dFllkkaky/ogRI9Lbb7+d+vfvn5ZeeunUpEmT/D7Wo0WLFmnw4MFp1VVXrfU+n376afrrr7/qdC0AAAAAAAAwDYfC9913X7rwwgvTnHPOmcPL7777LoeBJ598curcuXO+5vPPP09HH3102mCDDWqExVNS37590yuvvJI22mijWkPhmG/Mb4UVVkitW7fOx0aNGpV++eWX9P7776cddtgh/fe//50q845wPeZSCIXPOuus/AxTKxT+97//nd5999207LLLpllnnTW/n2WWWdL888+f1lxzzfTrr7/WKej99ttvc8AtFAYAAAAAAIDpOBS+44470nnnnZcuu+yytMYaaxSPX3vttemII45It912W1pmmWVKMreFF144XXDBBRP0md133z2tu+66NY498MAD6bjjjksbb7xxWn755VO5e/HFF9NJJ52Uttlmm1yxHFXe9957bzEsr6tCqA0AAAAAAABMp3sKDxo0KJ1//vnpwAMPrBEIh/333z+3Ho5Qsbqovo22wk8//XTq0aNH8XhUn0ab5H79+qVu3brlawoilHzhhRfSSy+9lAYOHFjj+LPPPptGjhyZK1uffPLJ1LNnzxrtox9++OF8vvpnYpyXX345DRgwoE7Puckmm+Sf1edUffxoiz0h8yqIiuoIYJ966qn0zTff1Gkudbl3tPJ+66238nNGtW51UbkbazL6sUcffTR/n3Fu2LBh6csvv0x33nlnXqcQP+P54/Xaa6/V+HxcG88Q84nW0wXjuzaqoatfG+8//PDDPIf4nmPu0b56dGMb6/fff8/zrv4dFO75+uuv12ldAQAAAAAAplVVlRVelTXXoL4paaVwhHexv2y0Nh6b22+/fYxj++67bw7zGjdunPf7Pf7449Ouu+6aA8QTTjghtWzZMrVr1y41a9YsnXvuuenSSy9NN998c+rYsWMOCSNIjiB6rbXWyi2pTzzxxHTDDTekioqKVFVVlVs9x3123nnnHCBWb1l91VVXpWuuuSZX+0aAGIHpRRddNEagPbrPPvss/5xnnnmKx2LMK664Ii233HJ5Db7//vt0zjnn5HvVNq8Ye5999kl9+vRJiy66aP4Z4fkee+yRK5LHp7Z7R7geP2Mdo513BKPzzjtvvn6GGWYYozV1iGPHHHNMDn6j3XYE91988UUOW6OtdohwtWHDhvl7inWNltCxD/Ohhx6aPvnkk/wPAGINok33TTfdlOaYY44c1BaujaD58MMPTx999FG+NtY+9muONZxrrrnSQw89lO8dYy644ILphx9+yPtTd+3aNbfNHt9YM800U25VHt/DjjvuWHyuWKdoX77KKquMd00BAAAAAABgWlbSULhXr145aGzTpk2dP7P66qun/fbbL/8e+xBHUBuhcIgq4WOPPTZtueWW+f0zzzyTQ9xoQR3724bLL788t6WOStLCZyIgPuCAA/L7s88+O1199dU5GK3uvffeKwbMK6+8cj72+OOP5+PVQ+G33347V6uGqMaNPYWjRfaKK66Y1llnnXw8wstolx2VtBHqhnvuuSf95z//yRXQtc0rPh/BZ4SWEbQWnuu6666rNRSu7d533313atWqVbrrrrvyuQh1zzzzzFxN3L59+/Hed7bZZsvttp944on8nUSYHmFwhPdnnHFGatq0aY1q6WgRHqFvXB8hdITJl1xySQ6pR/+HAhHeRtAb6xMhbvzDgNirOMLcLl265Gsi8I35L7nkkrnaOdpX33rrrfn5ahsrWn5HCF0IhaPy+quvvsqhMwAAAAAAAEzPShoKDx8+PFerTogtttii+HvsNRxBaFSRFqywwgrF36M1coSxhUC40JY6AsJouxzhYNh0002L56MKOILfCBWri4B5scUWKwbCIfYIjld1USHbt2/fXHUalbNzzz13Dqo33HDDXJUbHnnkkTT77LOn7t2751eIcxHARkhZWJNxzWullVbKr4KoiI0Auvo61GZc927evHkOT2+88cbUqVOn1LZt27zn85QQa7rVVlsVv4d47gjsxyYqgSOUjtbgBVFNHKHv33//nd/PN998ORAO8Y8NllpqqRwk12WszTbbLP9jg6gkj/tEO+yoLo8qaQAAAAAAAJielTQUjra/EWT++eefqUWLFmOcj3bP/4+9+4COqur6ML4nCQFCCL13EAQp0iwIijRRVJQqIkXFhh3Bgh0EQUEBFbArVpReBWkiIFVQeu+9BggkhJRv7eN35530SUhyksnzW2tWMnPvnHPunYjoP3sfrQrVNr8ODS0dAQH/Ld8zwNWw1aGthDXU9KSVtXqOHnMCwiJFiriPO8Gt5z7Czl682k45JT179jRVp0r3uNXnGto64zoV0lrpqq2W4+89rG2qnXA3uXVpa22tbHX2/NV7mRpJjd2jRw/Tnlorc7X9toainTt3ll69esX5HNKDt/dUHTx40Hz28e+ZhvLO3s6e1+T8fDj3K6W5mjRpYiqkNXzWNtVaUazXDAAAAAAAAAAAAGR3VkNh3StWKzaXLl0ap3LV0a9fP7MXrO4L6y3PymMN+Zw9bT1pCB0SEpLoe5JrjazthFND967VvXYHDhxo1uJUFRcsWNAE09pqOTGLFi1Kdl16P3QvY90HWCuhda9irT7WvX69ldTYGvw+/fTT5qHXq222tW22tlvWSlrnfRq2OiFxRESEpIXeUw3+vaGBsLYOf+qpp1J9Td7MpcG4fj4aBmtrbd1bWau7AQAAAAAAAAAAsjt/v9R17oXvSd/Sz1TSYFRb+up+uKdOnYpzTPeh1bC4Q4cOaR6/YcOGZhxt5+xYuHChae3s2WbaG9pKWPes9VynBoczZ840gWlSdI9abc88YMAAUzGs9Pn69evNvrUODb812NWK1pSsXLnSBM66Z67ux6xhqBMka0vuK6H3S69TXX311SaErVGjhhw+fNi85oTpnuvUfZXTQu+ptvH2pPdlxYoVCc7Ve6b3x7MqXFtDa5vn+FXdaZ1LW5PrmBrWN2vWLE5VOgAAAAAAAAAAAJBdWa0UVq+++qoJHu+55x4Tcmob5M2bN8ukSZPkwQcfjLOHcGrdd999psVy165dpUuXLqbNsO6Vq/sKX3XVVaaNs7e0anT8+PHSvXt3M5YGwfpcw2Vt+5wUDWzffvttc31DhgyRDz74wFzTlClTzPVpe2mtuNX9j7WldOvWrVNcy0033SSDBw+WkSNHmpbIus/u9u3bzbHQ0FC5Ehr+6jp1bbpn76ZNm8zYeg1O0K5z6n68GuhrgLxq1ao0zfXss89Ku3bt5IknnpDmzZuboFn3CB40aFCiVeP686H3X6vKNWCfMGGCqe5NrMo8LXNp+F2tWjVZvXq1jB49Ok3XBAAAAAAAAAAAAGQ11kNh3TP422+/NVXBGi7++++/Joz85Zdf5JprrnGfp69p+Oe5r61WGutruXLlSvS47imrrZZ1n1gNL4OCguTTTz81LZeTGtPzNWd8/V7D3S+//NKEzLrGPHnySN++faVFixbmfXnz5jXn6vvjq1KlirzxxhuyZs0aE0aWKFFCvvrqK1NlvG7dOtO6WANsZ0/hlNalIbe2Q9aqXq0w1pBZWx5rcKvVyxqsewalusexcy9TGlsrs3UfYa081gpgPaYVus7ezHqv9bPRQFz3TK5Zs6bZe3fs2LHu8XQsZ49jbZvtfEaqVq1a7r2cNVzWSl8Nd/U+6Ln6eVWvXj3BuWXKlDH3S39ZYOPGjaZi+d1335VbbrnFHK9Tp455vyfP11Kay9GmTRs5fvy4NG3aNJmfWgAAAAAAAAAAACD7cMUm1/sYyGFeeOEFE9rrXtBXKiI8XGyIETv7AvhfvijW+PlbmTZ3sJ0W45Ghx8Wa2JTbtWcE1+W07V2eLiz9azI2dz4r8+6MyCO2hATa2dWiQB47f4ZsP3VJbGlQrqC1uQEAAAAAAJD5Bi/4r+Ms/ue1FtUkJ7FeKQxkBbrXtFYga8W6VhQDAAAAAAAAAAAAvoJQGBCRs2fPmn2Kdc9prRQGAAAAAAAAAADwFf5+drqMIusgFAZEpF27duYBAAAAAAAAAAAA+Bo7m/cBAAAAAAAAAAAAADIFoTAAAAAAAAAAAAAA+DBCYQAAAAAAAAAAAADwYewpDAAAAAAAAAAAAPgwfz+X7SXAMiqFAQAAAAAAAAAAAMCHEQoDAAAAAAAAAAAAgA8jFAYAAAAAAAAAAAAAH8aewkAGuRAVa+XeFjy5xcq80QVKii07LgVbmbemnWllw/lAOxOLyMXL0VbmrV08RGzZf+6ylXmDLtv5va2qfqfElli/IDvzRtv5Z6pO7lCxJfJslJV5AwsUtTIvAAAAAAAAkNMRCgMAAAAAAAAAAAA+zN/PZXsJsIz20QAAAAAAAAAAAADgwwiFAQAAAAAAAAAAAMCHEQoDAAAAAAAAAAAAgA8jFAYAAAAAAAAAAAAAH0YoDAAAAAAAAAAAAAA+LMD2AgAAAAAAAAAAAABkHH8/F7c3h6NSGNnejBkz5JprrpHz58+neGz37t3m+apVq2T+/Pnm+3/++SfRcRcsWCA1a9aUffv2Zfg1AAAAAAAAAAAAABmFUBjZXkxMjERHR0tsbGyKx/Sr87xp06YSEhIi06dPT3TcyZMnS926daVChQoZfg0AAAAAAAAAAABARiEURo6VK1cuufvuu2X27NkSFRUV59jp06dl8eLF0qFDB2vrAwAAAAAAAAAAANIDoTByNA19z5w5I0uWLEnQdlpD49tvv93a2gAAAAAAAAAAAID0EJAuowDZVPXq1c2+whoCN2vWzP36lClT5I477pCgoCCr6wMAAAAAAAAAALhS/n4ubmIORygMn3HjjTcmeC2xfYbja9eunXzwwQcSFhYmwcHBsnXrVtmyZYu88cYbGbRSAAAAAAAAAAAAIPPQPho+Y9myZbJ+/fo4jyFDhqT4Pt1XODo6WubNm2eeT548WSpVqiQNGjTIhFUDAAAAAAAAAAAAGYtQGD7D399fAgIC4jxcrpTbIRQqVEiaN28u06dPl6ioKJk5c6a0b98+U9YMAAAAAAAAAAAAZDRCYUDEhMArV66U3377TUJDQ+Xee+/lvgAAAAAAAAAAAMAnEAoDInLzzTdL4cKFTbtp/b548eLcFwAAAAAAAAAAAPiEANsLALJK6+m2bdvKV199JR06dLC9HAAAAAAAAAAAgHTj78V2m/BtrtjY2FjbiwCuhP4IR0dHmz2EvTmm+wZrCBx/v+HkxkmLU+cvig0FT261Mm90gZJiy45LwVbmrVkqxMq8fx8IFVsuXo62Mm/t4nnFlv3nLluZNyiXnWYeFWJPiS2xgUF25vUPtDKvX7i9f5Zjc9v5czOwQFEr8wIAAAAAAOR0Y1fstb2ELKf3jRUlJ6FSGNmehrtJBbmJHUvNuQAAAAAAAAAAAEB2x57CAAAAAAAAAAAAAODDCIUBAAAAAAAAAAAAwIfRKxcAAAAAAAAAAADwYX4ul+0lwDIqhQEAAAAAAAAAAADAhxEKAwAAAAAAAAAAAIAPIxQGAAAAAAAAAAAAAB9GKAwAAAAAAAAAAAAAPizA9gIAAAAAAAAAAAAAZBx/F3c3p6NSGAAAAAAAAAAAAAB8GJXCQAYJtPRrNxdL1LAyby6JEVuqxpyxNHOIlVlr57sotsQG5LE0caSdeUWkRkColXmj8pe0Mu++80XEljPnoqzMe22InZ+v0DzFJaf9Oyr2vJ1/nlTu/AWtzQ0AAAAAAADYRqUwAAAAAAAAAAAAAPgwQmEAAAAAAAAAAAAA8GGEwgAAAAAAAAAAAADgw9hTGAAAAAAAAAAAAPBhfn4u20uAZVQKAwAAAAAAAAAAAIAPIxQGAAAAAAAAAAAAAB9GKAwAAAAAAAAAAAAAPoxQGFatWLFCXnvtNTl48GCCYxs3bjTHIiMjExybNWuWOXb06NEkx162bJl88MEHMmDAAPn0009l69atcY7/888/ZoyIiIgE703uGAAAAAAAAAAAAJCdEArDqp07d8rkyZPl/fffT3BMg+KJEyfK5cuX47weGxsrI0aMkIULF8qvv/6a4H3R0dHy1FNPyZtvvim5c+eWKlWqmPC4S5cu8sknn7jP27dvnxk/sdA5uWMAAAAAAAAAAADZib/LxcMV9x7kNAG2FwDky5dP8ubNK8uXL5dGjRqleENWr14thw8flt69e8uECRNMAOzv7+8+vmjRIvnjjz9k8eLFUrRoUffr9evXl5dfflnuvvtuqVChAjceAAAAAAAAAAAAOQKVwsgS+vbtKyNHjpSoqKgUz50yZYrUrVtX2rVrJ8eOHTMBsKcDBw5Irly5JCgoKM7rrVu3loEDB5pjAAAAAAAAAAAAQE5BKIwsoXjx4tKyZUv58ccfkz3v4sWLMmfOHGnVqpWULVtWatWqJb/88kuccxo3bmzC5W7dupnW1MePHzevayvpTp06SenSpTP0WgAAAAAAAAAAAICshPbRyDJ69uwpDzzwgGnvXLhw4UTPmTt3rgmGNRR2qn91f2FtJ+2EvdWqVZMxY8bI0KFDpX///ua1ypUrm/c89NBDUqhQoThjDho0KEH18P79+zPoKgEAAAAAAAAAAIDMRaUwsozAwEB5+umnTcibFK38rVmzpqkSVrfffrvExMSYvYU93XLLLTJ79myZOXOmCYbLlSsnX331lQmcjxw5Eufc2rVrm3bUno/y5ctn0FUCAAAAAAAAAAAAmYtKYWQpTZs2lfHjx8umTZsSHDt48KCsXr1aqlSpIq+99pr79Tx58sikSZNMoOzv7x/nPVWrVjWPBx980Ix5//33mxbV/fr1c59zzz33SEhISIKAeuLEiRlyjQAAAAAAAAAAAJnJz+XihudwVAojy3nllVfkvffeS/D61KlTJSAgQLp37x6nqve+++6TY8eOyaJFi8x5H330kakQjk8rjPX8s2fPZsp1AAAAAAAAAAAAAFkBlcLIcipUqCB16tSR6dOnu1+LjY01oXDz5s2lS5cucc6PjIyUGTNmyK+//iotW7aU8+fPm/2Er732WtM22nH69GnZvXu39OrVK1OvBwAAAAAAAAAAALCJUBhZUu/evc1+wQ5tG33gwAEZMGBAgnO11XPHjh3lyy+/lMOHD0vfvn0lNDRU2rRpI9dcc43Zf1ifb9myxQTC2qIaAAAAAAAAAAAAyCkIhWHVjTfeKK+//nqC1/PlyyejR4+Wbdu2Se7cuc3zwYMHy0033ZToOD179pTy5cvLpUuXzB7Dw4YNM/sG6z7C2i5a9wxu2LChFChQwP2eevXqyaBBg8z58SV3DAAAAAAAAAAAAMhOXLHalxdAujt/MTxH3dVcEmNtbr+LZ6zMG1i0rJV5I08fFltiAyz9ooTLz97PV3iolXmjQkpamffQ+ctiy5nwKCvzXhti55rP+gWLLYH+Livz5om5JLbkzl/Q2twAAAAAAAC2/bTuoO0lZDld69n5f/y22Pu/7AAAAAAAAAAAAACADEcoDAAAAAAAAAAAAAA+jFAYAAAAAAAAAAAAAHwYoTAAAAAAAAAAAAAA+DBCYQAAAAAAAAAAAADwYQG2FwAAAAAAAAAAAAAg4/j5ubi9ORyVwgAAAAAAAAAAAADgwwiFAQAAAAAAAAAAAMCHEQoDAAAAAAAAAAAAgA8jFAYAAAAAAAAAAAAAHxZgewGAr4qIirUyb+H9y63Mu6lwQ7GlUsEiVuYNtDKriN/FM5ZmFonJZ+de/37UJbbULVHUyrwHj120Mm/9AlFiS7m8ua3Me+JyPivzFr90UmyJDQyyMq9f2AmxJXL971bmDWzc2cq8AAAAAAAAnvxc9v4fK7IGKoUBAAAAAAAAAAAAwIcRCgMAAAAAAAAAAACADyMUBgAAAAAAAAAAAAAfRigMAAAAAAAAAAAAAD4swPYCAAAAAAAAAAAAAGQcfxd3N6ejUhgAAAAAAAAAAAAAfBiVwql0/vx52bx5c5LHS5cuLeXKlZOMdvToUTly5IjUq1dPsqLDhw/LiRMnzL3YsWOH1KxZU4KDgxOcFxMTI2vWrJEKFSpIiRIlUjXHvn375OLFi1KjRo10XDkAAAAAAAAAAADgWwiFU2nbtm3So0cPE3Lmy5cvwfG77rpL7rvvPsloc+bMka+//lr+/PNPyYpmzpwpEyZMkJ9//lkefvhheeGFF6RXr14Jzlu+fLk5Pm3atFSHwkuWLDHB8GuvvZaOKwcAAAAAAAAAAAB8C6FwGg0ePJgKVS8ULVpUbr75Zpk+fXqiofDkyZNNwF69evVUfwbdunVL9XsAAAAAAAAAAACAnIY9hTOQtkbetWuXbN26VcLDwxM9JywsTDZs2CC7d+9O0B5a21THxsaa9+tDx0uqVfP69esTnSM0NFQ2btxojl+4cCHB8ePHj5v59diZM2fk77//TtAu+99//5VDhw4lOndK46v27dub9W/fvj3Btc+fP186dOjgfu3kyZNmLL32yMhI9+t79uwxj7Nnz5r5dF1aJbxly5Y4Y54+fVr++ecfOXDgQKJrcY7rdcen8+k6td2159wAAAAAAAAAAABAdkalcAbZv3+/PPLII+b7ggULmqBR20736dPHfc5HH30k33zzjZQvX16OHTsmJUuWlFGjRpn9dbU9tFbRBgUFmSBTA9/8+fPLmDFjpGLFiub9ly5dMtW3GiBHRESYoFSPN2zY0AS8zz33nAmldV9fDY41UB0yZIi0adPGBMzvvvuuTJw40Yyn+xM3btxYli1bJitXrjTjf/755zJ27FhzXMPaUqVKyfDhw816UxrfU7NmzaRQoUKmWrhfv37u12fPnm1Cb225rQHvM888Y4Li4sWLy969e80adf4GDRqY+6RBsa5D74m26D548KAJcb///nu5fPmyDBw40LSt1vVqKHzNNdeYe6z3X8caNGiQTJkyRSpXrmzeq/sx63p1bevWrZOnn35aChcuLLly5TLzv/zyy5nSChwAAAAAAAAAACAj+blc3OAcjkrhNNJqVQ1P4z80qFUaztaoUUN+//13+fXXX2XcuHGydu1aU1mrxo8fL19++aV5XffTXbx4sdlT96mnnnJXBOv+xdddd50ZY+HChSaM7du3r3sNOlbz5s1l1qxZMm/ePKldu7YJldWCBQtMuLpo0SIzl35t1KiRfPbZZ+a4Bs6TJk0y+/5OnTrVhMMrVqxwj63hsJ6rewJrkPrHH39IlSpVzPy6vpTG96Qhqwa/GthqCOzQNbRs2VIKFChgjun7dVwdT+fTEFrvj0ND4a+++sqEyffff3+cOfQ8vU+6Vn389ddfUrp0aXPfnPutY2rYrtet69XP6p133jHH33//fVPRPGPGDLOu9957z6zFc70AAAAAAAAAAABAdkSlcBppWJovX74Er3/44YdSrFgxcblcJjjWsFfDzjp16piKVocGsXfeead5XeXOnVteeOEFadu2rWmfrIKDg031qhOsamDcsWNHU52r8uTJI126dDHf+/n5mUrf7777zjzX8/ThiI6OlrJly7rbVGtwevfdd0vVqlXNc6321aD1hx9+cF9frVq1TPWvUzmsFbsamGoVbkrjx6ctovX6V61aJTfccIOpxNXqXK0OVnptnjR4LlOmjFy8eNH9mo6vwbQKDAyMc76GuRrqOlXUenzo0KFxPi+toNZ59aH0uYb3WmWs90+D5KZNm5oK4latWpkHAAAAAAAAAAAAkN0RCqfR4MGDTSVwUl566SV57bXXpHfv3iagvP7660376CZNmpjjukevtlX2VKlSJfNVWzErrQzWsNihz533qpCQEPH393cf13k04FRa4aoBrlbP6l682mJa209r62Wl7Zq1ytiTE6g6x3WP4E8++STOOXod586dS3H8+PRe6UNbSGsorKG0VvJqYK60aleD2z///NOEttoyW69dg2mHttdOit4TDbaTa+cdFRVl2mR7ql+/vmmFrQHyK6+8Ig888IC5rzfddJM8+uijceYHAAAAAAAAAAAAsiNC4Qyi+9RqFaoGqMuXLzctnnWPYW0ZrcGw7l2r++d6cp47Fci6j7An3TPYqSBWWo2clI8//thUDWslrlbhXnXVVWZfXq1QVhp8xp9fQ2CHrkGrmDX8Tozu1Zvc+Ilp166dWddbb71lwmF9rhW66tVXX5U1a9aYymgNYrUi+I033jB7CDuccxOjLag9q4rj07Ba53vssceSPOfHH3+UEydOmNbZGlpr5bRej1OdDAAAAAAAAAAAAGRH7CmcQbQ18vHjx0342rp1axOiFixYULZu3WqOa+CqraU996zVfW4DAgLM3sBK2zQfPHjQfXzp0qWmGteb6tX58+eb9tQ9e/Y0c2koqq2btc2z0wpaw09P2j7Z4azPM5jWEFlbSWv4mtL4idF21RERESYs14pdDWkduvevjtWpUyd3BbbeQ2d/5ZToPfHcE9mpdnbu97XXXmv2E/a836dOnTJr1gpi/aoBvrb+vvfee02FdGRkZJLtsAEAAAAAAAAAALILfz8XD7+49yCnoVI4jXS/YA0R49Mq3po1a5pK07Vr18rjjz9uwuAlS5aYFsktW7Y052lFrO4frF81HNUAWIPjJ5980lQRKw0w9bm2oNYK1lGjRkm/fv0S7KebGA2WFyxYYMJfrfrVVs+6ZqfdtFbMavj58ssvm9Baq5l1jU676ieeeEJmz54tDz/8sDz44IMmCB4/frypTv7pp59SHD8xel3aMlurpbUNtWe7Zw11J06caPYN1mBZ9x/W0FZDdW88++yzZt/it99+28yhgfzIkSPlueeek+rVq0vfvn1N4Ozcbx3766+/NvPqWjSo1nC4e/fuZq/madOmSfHixeXGG2/0an4AAAAAAAAAAAAgqyIUTiWt1NUQUdsfJ0ZbDWso/Oabb8ovv/wi8+bNMxW2uh+whp7Ovr0lSpQwwfG4cePMXroaHGuI2bRpU/dYRYsWlRdeeMEElBoQf/jhh+7jur9u3bp148ytY9arV898r/sZlypVyrSt1jXr+/r06SMDBgwwexZrIKvr05bP+lXH0vBZg18nwJ00aZJpEf3rr79K3rx5TXjcpUsX08Y5pfH1mFYQx9e1a1cJDQ01VcGeNPD+4osvZMKECea6u3XrZtbw2WefmYpd3W85/n7FFSpUiHPf9f7qevWe6hhDhgyRW265xRyvWrWquR5tEa2htq5Z23m3b9/eHNfKYH1dP1etZq5WrZoZT88DAAAAAAAAAAAAsjNXrGc/XWQZ3377ralk/fPPPzNk/F27dpmvnvvl6l6/+/fvN0ExrtyJc0nvcZyRCu9fbmXeTYUbii2VCqZcPZ8R8gfltTJv1MFNYktMviJW5v39qL1WHnVL/LfPe2Y7eD7Syrz1C0SJLbEB/3WryGwnL9v5HbniUafEltjAuL9olVn8wk6ILTF7N1iZN7BxZyvzAgAAAAAAeJq++Sg3JJ6215SUnIRK4Rzqjz/+kM8//9y0VS5durSsX79epk6dKqNHj7a9NAAAAAAAAAAAAADpiFA4i0qsPXR60r2CtT2zViLr3sgaDOs+vom1fAYAAAAAAAAAAACQfREKZ1G33367eWQUl8sl7dq1Mw8AAAAAAAAAAAD4Lj+XvS36kDX42V4AAAAAAAAAAAAAACDjEAoDAAAAAAAAAAAAgA8jFAYAAAAAAAAAAAAAH0YoDAAAAAAAAAAAAAA+LMD2AgAAAAAAAAAAAABkHH8Xdzeno1IYAAAAAAAAAAAAAHwYoTAAAAAAAAAAAAAA+DDaRwMZ5MTFKCv3tkCZmnbmjfEXWy5Hx0pOcrloFWtzx1q71WdtTSxBuez8/pS/y04/l5jAfGKLX+QFK/MWyRNoZV6/42fEFtf541bmPV6khthSrGyklXlvHbHYyrx/9GlqZV4AAAAAAABkTVQKAwAAAAAAAAAAAIAPo1IYAAAAAAAAAAAA8GF+ljoTIuugUhgAAAAAAAAAAAAAfBihMAAAAAAAAAAAAAD4MEJhAAAAAAAAAAAAAPBhhMIAAAAAAAAAAAAA4MMIhQEAAAAAAAAAAADAhwXYXgDS5vTp0/LVV1/JihUrJCwsTEqUKCHNmzeXrl27SmBgoFdjDB8+XE6cOCHvvfdejvwYcvr1AwAAAAAAAACAnMHfz2V7CbCMUDgbOn/+vHTq1Elq1qwpr776qhQsWFB27dplQs4lS5aYsNgbZ86ckZMnT0pOldOvHwAAAAAAAAAAADkDoXA2NGfOHFMp/OGHH0pAwH8fYZUqVaRYsWLSpUsX+eeff6Ru3bq2lwkAAAAAAAAAAAAgCyAUzoYiIyPl0qVLcuDAAalUqZL7dQ2CFyxYIEWKFDHPP/roI7lw4YKEhITIb7/9JkFBQabCWB+JWbdunXz22Weyd+9eKVOmjDnv9ttvd48VHh5uxvr9998lKirKtKt++umnJVeuXOacNWvWyNdff23er2vQ97dt29b9fl2zvj516lTx8/OT++67T2655RZT4bx161YTbL/yyitStmxZr9ak9Hq//fZbOXv2rDRs2FDKly8vq1evltGjR0t0dLR89913smzZMjl8+LAJ0OvXry99+vSRAgUKuMfYs2eP9OrVy4TsnmH622+/bd7z+uuvp+OnBwAAAAAAAAAAAGQuv0yeD+ngjjvuMOFqu3btpF+/fjJt2jQ5duyYuFwuE6jmzZvXnBcaGio///yzqRweMmSIdOvWTYYOHWqC0vg2btwoDz74oNxwww3y8ccfS4cOHWTAgAHy008/ucf6/vvvTYD67rvvymOPPSbffPONec0JZ/X9derUkREjRpgw+K233nK3stb3//DDD+b9H3zwgQl2NXR9+OGHpVWrVvL++++ba9D3eLumhQsXyvPPP+9+vwa4uj+w7hPsBNE//vijCXw1JH7yySdl5syZZixPGqzny5dPJk+e7H5NA3C9rzfeeCM/swAAAAAAAAAAAMjWqBTOhgoXLiyTJk2Szz//3LSSnjFjhnm9du3a0rdvX2nUqJH7XA2IR44caUJPPX7kyBFTedu9e/c4Y+o599xzjzz00EPmedWqVc3exVo927VrV/NacHCwDBo0SAIDA6VGjRryxx9/yF9//WWCXQ1g7777bnniiSfMuVdffbWp3tUw1plLK5U1CPb39zdBrL5Hw+E2bdqY41o5rOGut2saM2aMCYp79Ohhjuv+yv/++6/Exsaa5xqC69qcqmCdU4Pkffv2JbinGmLr/dSqYL0+Dbn1a9OmTdPxkwMAAAAAAAAAAMh8fi7uek5HpXA2Vbx4cRNgLl261ITC/fv3N4HpI488ImvXrnWfd+2115pA2KHtk0+ePGnCYU+bNm2SuXPnmpbQzkNDW63w1Qpepa2ZNSh1aNiqLaG1lfS2bdtMRa8nrbLV9tVaHawqVKhgAmGlVb25c+eWihUrxgmwtULXmzUdOnTIVBJry2hP1113nft73WP58uXL5v5odbC2jdYgOyYmJtFQOCwszITBSiuK77zzTndrbAAAAAAAAAAAACC7olLYB1SrVs08tGq2devWZs9eDX+V00raoWGsih+MXrx40bSE1srcxCqTlYa4idHKXN0jOH6AmtJzpe9LSnJrcqp/netxeK5R78Mbb7xhKqRr1qxp9i/WEFsf8ZUoUcKE2NOnT5ebbrrJhO3aehoAAAAAAAAAAADI7giFs6HHH39cKleuLC+//HKc1/Pnz29aLHsGwbt3745zzo4dOyQkJERKliwZ53Wt2N27d6/Zkzi1NOzV92m1sFbXOrZs2WKOlSlTJtVjerMmHXfnzp0Jrs8xfPhw00La8z5p1bDuvZwYDZ81RJ4wYYIZW6usAQAAAAAAAAAAgOyO9tHZULNmzeSnn36SKVOmmPbMTuXvn3/+KVu3bpVOnTq5z92+fbu74vXAgQNm31zduzd+hW3Pnj1l1qxZMn/+fPNc2zi/++67Zj/gxNotx6fv1zWtW7fOPN+/f7988sknZp9h3Ys4LVJak37Va9NrVEuWLDHneoa+Z86cMedGR0eb9ekeyIlVCqvbbrvN3BdtUZ1YdTIAAAAAAAAAAACQHVEpnA116dLFtEn+6quvzF7C2t753LlzUqtWLRk7dqxcddVV7nO1cnjOnDkycuRIE4ZqYPzcc88lGLNdu3Zmn+FXXnnFhKoaNmul7KBBg5Jt8ey4//775fjx4/Lwww+bfYcjIiLMmPGrmVMjpTVpFbDuV9y+fXuzb3K5cuVMi2jdW1m988478tprr5m9jvX8OnXqyEMPPSSTJ082IXF8QUFB0qpVK9NCWvcYBgAAAAAAAAAAABLbWnXDhg2mOFHzuSJFikhyIiMjTWFnaGioyfFKly4dZ6zff//dfPWkuZbneVfKFRt/BmQrWj2rgbC2jtZQ09PAgQNNO+Xvv//eBKUa1nruuas/qBqOFi1a1P2aPj958qRpMe3Zhlp/SC9fvizFihVL9jV9fvr0aSlUqJCZL7lzDx8+LAULFnSvW/cQ1jXFbzed1Jo874H+w6T7DL/00ksm/B41apQ5pj/euh49plXAeuzEiRNSqlQpc9/iX79WN69atUq+++47uVKbj54TG67KfdHKvEdi0lYRnh7yB9ppelA4f9x/5jJLeESE2GLr3xgL9561M7GI3FQ2v5V5d51JvKtBRqtd9H9/dmc2v8j/ul9ktpjcdj7jXMf/63Rhgyv6spV5jxepIbYUC4275URmaTE51Mq8f/RpamVeAAAAAACQNS3eddL2ErKcplX+lw+lRlhYmDz66KNy7NgxE9pu3LhR3n77bbn33nsTPX/Tpk3yzDPPmIxLt3ddu3atdOjQQV5//XV3p9+WLVtKixYt4nT67dGjhzRs2FDSC5XC2Zz+ACUWlManoXF8GtzG5+/vLyVKlEjwuoa33rymewh7+/74v92g4XD8YDu5NTkVxAMGDDCh7+bNm2XhwoXy1ltvuc/R456/naGhuLNHcfzr1+B86tSpV1TdDAAAAAAAAAAAAN81cuRIiYqKkt9++83kTjNmzJBXX31VGjVqlGiepQWN2ulWg2O1c+dOEwrXr19f2rRpYwo8dSvWMWPGZOi62VMY2Zb+hsSWLVvk+uuvl8aNG5vW0PqbGbqPcWr17dtXmjRpYn7jQltIAwAAAAAAAAAAAJ60Q+20adPMtqpOd17NpYoXL25C4sSqiqtUqSLdu3d3v6bto+vWrSsrVqwwzzUU1nMyGpXCPuzZZ581LZt91TXXXGMqe3WvYW09rXsra1VxWgwZMsTsP6xjAAAAAAAAAAAAAPFpq2fdnrRatWpxXq9atappIx2fVgB/9NFHCV4/evSo1Kjx31Zr27dvN6Hwnj17ZP/+/VKxYkWpUKGCpDdCYR+WWMtmX5QvXz7zuBK6/zGBMAAAAAAAAAAAQM7QokWLZI8vWLAgwWuhoaHmq25r6ikkJEROnTrl1bwzZ8404bKzB7FWCmtI7LSRXrdunelqO3To0Dh7DF8pQmEAAAAAAAAAAADAh/m5XLaX4BMiIyPN1/ida/W5tpZOiW6L+uabb0qfPn2kevXq5jWtOu7WrZt07tzZPN+1a5d07NhRvv76a3nsscfSbe2EwgAAAAAAAAAAAABylAWJVAKnJH/+/OZreHh4nNd1m1Ot8k3O1q1b5eGHH5YePXrIo48+6n59+PDhcc7TVtKtW7eWRYsWpWso7JduIwEAAAAAAAAAAACAjypfvrz4+fnJwYMH47yu7aArVaqU5Ps2bNggPXv2NGHw888/73797NmzMmfOHAkLC0uw7ak3lcepQSgMAAAAAAAAAAAAACnImzevXH/99TJ//vw4gfC2bdvklltuSfQ9a9euNRXCL730kvkav+10v379ZPr06e7XtAp5yZIlcsMNN0h6on00AAAAAAAAAAAAAHjhhRdekO7du5tAV/cD/uabb+S2226TBg0amOM7duyQPXv2mNdOnTolvXv3Nufly5fPVAU7SpYsKXXr1pVnn31Whg0bJmfOnJFixYrJ+PHjJSgoKE6L6fRAKAwAAAAAAAAAAAAAXrj22mvl119/lQkTJsj69etNeNu+fXv38e3bt8u8efNMKKzhsFPxO3v27DjjaCCsD903uHbt2maP471790rbtm2lU6dOJkROT67Y9G5IDcBYsvuUlTtRr2SQlXlHLT8gtjxYv4yVecsUSt8/kL118HTcvQUyU4E8/lbmnbzlpNjSsHQBK/Meu3DJyryNSwaKLSci7fx8Fc1rZ16/8DNii+uynZ+vc0ElxJaQCDt/jrSfcsjKvOGR0WLL/KebWJsbAAAAAAAk7q+9djKLrOymikUkJ2FPYQAAAAAAAAAAAADwYYTCAAAAAAAAAAAAAODDCIUBAAAAAAAAAAAAwIcRCgMAAAAAAAAAAACADwuwvQAAAAAAAAAAAAAAGcfP5eL25nBUCgMAAAAAAAAAAACADyMUBgAAAAAAAAAAAAAfRvvoNFi/fr0sWLDA/dzlcklgYKCUKVNGmjdvLvnz57+iD+XixYsSFBTk1bnz58+XsLAwuffee2Xr1q3y22+/yZNPPim5c+eOc15yxzJTaq7tSi1evFiOHz8unTp1ypT5AAAAAAAAAAAAgKyISuE02LRpk3z66aeSK1cuE7BqIBwZGSnjxo2TO+64Q/bt25fmD2T79u1y1113eX3+okWLZMaMGeb7bdu2mXVdunQpwXnJHcssqb22KxUQEGA+IwAAAAAAAAAAACAno1L4CjzxxBMmeHT07t1bbrvtNhkzZoy89957aRpz9+7dcvToUfFFmX1tjRs3zrS5AAAAAAAAAAAAsip/l8v2EmAZoXA60qrhatWqyaFDh9yvXb582bSa3rt3rxQpUkRatWolBQsWNMecFtRazartncuVK2daPMfExMiIESOkbdu2UqVKFTly5IisXr1aDh8+bELo+vXrm0da6Ti//PKLdOvWTYoVK5ZoK2qtQNa16/y6Tm35fPvtt0vRokXd52t1tL5Hr6106dKmdXZISEiqri25MXQN0dHRctVVV7nXc+utt5p77Ni4caO5N35+flK9enW5/vrrTTvvxNpHJ/dZeDMXAAAAAAAAAAAAkB3RPjodnT9/XjZv3iw1a9Z0h6/aLnns2LHm2PTp06V169ayYcMGd2j51ltvmePHjh2TM2fOmNBXQ00NmDXo1HPatGkjy5cvN62f165dK/fff7/8+uuvaV6nBrs///yzTJkyJc7rQ4YMkdDQUPP9kiVLZOTIkdKzZ085ceKE/PHHH6Y1toaw6ty5c9KhQwf56quvJDw8XObMmWPWuWXLFq+vLaUxdA3Dhw+XXr16mXB3zZo1cs8995h7ocaPH2+OaWiux1966SXp37+/+3qWLl1q7rk3n0VKcwEAAAAAAAAAAADZFZXCV+Djjz92f69hqganwcHBpq20E7Lmy5fPVOU6e9v26dNHXnnlFZk1a5Z5rpW5n332mbs6tnDhwiYcffLJJ81zDUiHDRsmLVu2dM+lweXChQulc+fOia5Lg0/d59jTjh073N/rMa36nTZtmjz22GPmtXXr1plw1XPP3z179sikSZPkmmuuca/9nXfeMdfzySefSP78+eWHH34wAa8aPHiwvP766+Y93lzbu+++m+IYWnWt7ylTpox5rtXNOn+jRo1MsK33wrmG9u3bm6rj2NhYd7Www5vPIrm5AAAAAAAAAAAAgOyKUPgKaLioYaYGkJUqVTKtjzVA1NBVg8k///zTVK86IaTq0qWL9OjRQw4ePGiea1tlJzRNjFbOqqioKBNa6r68WmFboECBJN+j82s1bpwP2mPvY6UtojXw1MrfWrVqmWBU9+D1bA9dr149dyDsvEcDWA3ANZQuVaqUjBo1yn381KlTZrwLFy54dW3ejFGxYkV3SKu0vbPeA1W1alVTZawV1LfccovUrl1bHn/88QTzePtZJDcXAAAAAAAAAAAAkF0RCl8BrQiOH7Y6NKiMiIiIE7Iq5/nZs2fNV93bNjkHDhyQQYMGybJly0ylq4a0Om5yYatWz8Y/rlXBc+fOdT/XPYkrVKggU6dOlRo1apj9fl999dU47ylZsmSc585aNRQ+evSoXH311XHCZw1Rn3vuObMfrzfX5s0Yzp6/Dg3hNeR1Ko0///xzc11auVyoUCHzmTz44INp+iySmwsAAAAAAAAAAADIrgiFM0iePHlMu2Tdn9aT8zylwNTxwgsvmNBUg0+nivX55583++JeqbZt25p9ebXKVvf0bdGiRZzjWrUbf+3+/v4mTC1evLhUqVLF3Qo6La50DK2Ifvrpp81D9y2eMGGCaROtezpfd9116f5ZAAAAAAAAAAAAZEd+8bbdRM7z30auyBC33nqrTJw4USIjI81zrTr98ccfpXr16gmqcB1aeexZnap7AWto6wTC2kL6r7/+Mu2kr9Q999wjJ06cMEFq69atTXjq6e+//5Z9+/a5166h60033WT2TW7atKlMnjzZVA071qxZI2PGjJGYmBivri0tYzj0uFYHO3sllyhRQjp16mS+16rg9PgsAAAAAAAAAAAAAF9ApXAG6tu3rzzwwAPSrl07s9ew7pWroa62PE6K7murexT379/fVPLqPr6ffvqpHD582AShug+vtn2OX/WaFrrnr7aRXrt2rbz99tsJjmv4+9BDD5lAddu2bWbt48aNc1cra4Cr16Z7KZ88eVIWL14s/fr1M22Xvbm2tIzh0OMXL140ewLfdtttkjdvXlm0aJEJrfWRHp8FAAAAAAAAAAAA4AsIhdOgTp06Zt9bbaWcHG2zPGPGDFmwYIEcPHhQ6tatK82aNTN7Aytt1+zsZ+u5p+63334r//77rxQoUMCEtXrezp07TZtjbZWsYajuAaxVr61atZKwsDDzXt0bWNcVv+I3uWO6Hm29fP311yd4T9WqVc1+xkuXLjXXrHM5a9e1aZWvhrh79uyRatWqmTBXg2Zvry2lMXRtOm/89TqvvfTSS3LHHXfI+vXrTXXw66+/Lk2aNDHBs9IwW1tJe/NZpDQXAAAAAAAAAAAAkF25Yj37+SLH6dWrlzRs2FB69+4d5/WBAwea1szff/+9tbVld0t2x92TObPUKxlkZd5Ryw+ILQ/W/6+9emYrU+i/XyrIbAdP//eLIDYUyJP8L8NklMlbTootDUsXsDLvsQuXrMzbuGSg2HIi0s7PV9G8dub1Cz8jtrgu2/n5OhdUQmwJibDz50j7KYeszBseGS22zH+6ibW5AQAAAABA4v4+8L+tPPGfBuUKSk5CpXAO9dNPP8mqVatk165dMnLkSNvLAQAAAAAAAAAAQAbxT37XTuQAhMI5VKVKlUz7ad3fN3/+/AmO0zoZAAAAAAAAAAAA8A2EwjlUo0aNzCMpN998c6auBwAAAAAAAAAAAEDGoFgcAAAAAAAAAAAAAHwYoTAAAAAAAAAAAAAA+DBCYQAAAAAAAAAAAADwYewpDAAAAAAAAAAAAPgwP5fL9hJgGZXCAAAAAAAAAAAAAODDCIUBAAAAAAAAAAAAwIcRCgMAAAAAAAAAAACAD3PFxsbG2l4E4ItOnLtoZd7zkdFW5g30s7cfQdjlGCvzVi8RYmXeiIsXxJZcJ3ZamfdgcBWxJSLazs9X2CU789bOZ+fPLnXKr4CVeYNy2fkduXznDootsf65rMx7MrCY2FLEFW5l3p3hgVbmjYrJeX/Fr1Pazp8hAAAAAABkB+sPn7W9hCynTg77fwkBthcAAAAAAAAAAAAAIOO47NV1IYugfTQAAAAAAAAAAAAA+DBCYQAAAAAAAAAAAADwYYTCAAAAAAAAAAAAAODDCIUBAAAAAAAAAAAAwIcF2F4AAAAAAAAAAAAAgIzjJy5ubw6XY0Lh06dPy/nz593P/fz8JDAwUIoVK2a+z0zHjh2TXLlySWxsrISHh0vZsmUTPe/ixYty4sQJKV26tDk/uWu7fPmylChRItl5IyMj5ciRI8meU7x4cbMmb8bLaN5eV1YdHwAAAAAAAAAAAMgKckwoPHbsWPn555+lVKlS7tc0/Lx06ZI8/PDD0rt37zSPffz4cfnll1/kmWee8er8559/XmrVqiUVK1aUd955RxYsWCBlypRJcN6nn34qkyZNksWLFyc7ns69c+dO+eCDD5I9b+/evfLUU0+5n588eVKio6PjhKK6nt9//1127Ngh33//vdj0ySefyO7du+Xbb7/NkPG9vW8AAAAAAAAAAABAdpZjQmGlgfC8efPivDZr1ix54YUXpEqVKnLbbbeladyJEyfK3LlzvQ6FHXfddZcMHTpUZsyYIU888UScYzExMTJt2jRp27atBAQk/zF5G2hXq1YtzvU/++yzcubMmQThr4bCOcGV/CIAAAAAAAAAAAAAkF1kbt/kLOjOO+807ZmXLl0a5/WoqCg5evSoabkcv/WztqHW17X98Llz5+Ts2bOmDfG+ffvMV88xtF2znpOYAgUKSIsWLWT69OkJjv31119m/o4dO7pf07H1NR3Xk65D1+V8rw+lga9WA18JbWEdfwxnDg2u4x/Tlti6Fq3CTuw9zve6Nodej75Hq5aTovcwqfuY1JyO0NDQOK3DE7tvKZ0LAAAAAAAAAAAAZFc5qlI4MRruathYtGhRdwj63nvvyeTJkyV//vwmaOzRo4c899xzZu/hfv36Sb58+WTDhg3m2L333muqjS9cuCCPPPKIfP311xIRESGvv/66adecO3duE5zWrFnTtIMuUqRInPnbt28vjz76qGzatMmc45gyZYrUrVvXVDCrzz//3Dzy5MkjYWFhpoL4lVdekaCgINMae+vWrabiV1suHz582KxHW0Drtem4+npq9s7VcFSrlzdu3GjG0Crj0aNHmzFGjhwpe/bskUOHDpm16Pp79eolY8aMMdeva9RgVSuh33jjDbNGnV/3R9Z7pmvVUFgDcb1/AwYMcAe6I0aMkMaNG7vXoYG7jq3r0Gu6/fbbzfn6GWgondycu3btMq26tb23VlvrZ/Hqq69Ky5Ytzdie9y2lcwEAAAAAAAAAAIDsKkdVCmtFqlbz6kMD29WrV0vfvn1NuKjhrHrrrbdk+fLlMnv2bFOtO27cOPnpp59MIOvQ902YMEH+/PNP6d+/v/Ts2dPsD6ytmcuVKycff/yx1KtXz4yj52horHvj6p7G8TVp0sQErZ7Vwhq0zp8/Xzp06GCez5w50wSfP/zwg6lo1mMaIr///vuJXueiRYtMaLxixQr5448/TND5zTffpOpebd++3QSiOp+OoVW18e/B8OHDZdmyZXL//ffLZ599Zu6V7v+r903v399//y1vv/12nLbU99xzjxlTz9WW28OGDTP7Jq9cuVJuvfVW89zT5s2bTUisx/W6//33X/nwww/NsZTm1P2RGzRoYO6DrlPDZQ3mtbI4vtScCwAAAAAAAAAAkJ24XDxc8e5BTpOjQmGtVNVqXn089thj8u6770pwcLAJa8uWLWsqTTXAfeqpp0y4q+rUqSPdunWTH3/80T2OBr7aclrfmytXrgTzfPTRR6aKVyuLVfny5aVChQqJtj/WczQo1Xmd9sn6vcvlkjZt2pjnGgi3bt1a8ubNawJtrZjVClvdyzixlstlypSRTp06me+LFy9ugudt27al6l5pyO20ri5cuLAJZrWa1qHXX79+fXP9eh/Gjx8vXbt2NfdL6f3TPZZ1v2TnuvU+3H333eb7hg0bmvfqHFqlrderc+j1eapcubI8/PDD5vuSJUuaqmQN5DXIT2lODdd1PK1oVg888IC5ZzpXfKk5FwAAAAAAAAAAAMhOclT76FKlSplq3qQcPHjQhKxXX311nNerV69uqm21LbQTiCbn0qVLpvJXq073799vWi3re7USNTFapaxVuFpZrAGuto6+7bbbTNiq9P26961Ww8a/Hg2649Pw1JO2Qo6/D3FKihUrFue5tmfW6/IMnj2vV/c6Tuy+aXir9zWxMTUUdtp2K23bHH+d2rbak7bT1vk0wE1pTm0zrW2/tU21hsu33HKLCfidwN9Tas4FAAAAAAAAAAAAspMcFQqnRPcQVp7hp9L9bv39/SUwMNAdXiand+/epj21VrFq4HvNNdfI448/nuT5lSpVMtXHWuGqFcvr1q2TPn36xAlPtZ2xUzGbEl3rlUqpQtZzDr0v8UNj5ewTrMfSui4NeD05c2j1ckpzarirvwSgrba1JbS24dbAXR+eobbSfZe9PRcAAAAAAAAAAADITnJU++iUaAVwwYIFTYWvJ32uFahOO+j4PF/Xil4NFV977TXTplpbImuoqyFxcvvT6v7BCxcuNBXGWp16/fXXu4/VqFHD7BPs6eLFi6ZaNn5oaoMGyFqxm9h9CwkJMUF3Wm3cuDHONeqYen8KFCiQ7Jz6Wer9iYyMlFq1aplQ/vvvv5ezZ8+a4NeTju/tuQAAAAAAAAAAAEB2Q6VwvHD3+eefl/fff98Ei9dee6388ccfpmr0448/TrbCWNs4r1+/3rRu1mB52rRppsL0zJkz5r26D7A+knLHHXfI4MGDzf7But+xZ6WuVg1r1fHAgQNN5fGpU6dk9OjRki9fPvnmm28kK9A16n6/um9ws2bNZMOGDTJ27FjTktmpsE4LbdutAXvPnj1NBfW4ceNk6NChKc6plcJ6XD8DDef1+eTJk81npXshx//cvT0XAAAAAAAAAAAgu/FLvkEscoAcEwpru+GU9gJW999/v9nLd8KECfLDDz+Y1s7ffvutNGzY0BwvXry4GcvT3XffLUuXLpX+/fubYPeLL76QMWPGyIsvvmjm7Ny5s9kjeMmSJeZ8DY7jj6FzduzYUf78809p165dnGN169aV7777zgTGL730kgmsb775ZhNgOtem64r/vee1x3/N2eNXq5gTu1eJjeHsVVykSJEEbZsbNWpkrltD6lmzZpn9jjVcb9WqVZJjasWvBtsO/V4DXs859fPQ1/Ve6nVrIKwBujdzfvbZZyYk1jBd16v7E//000/ufYw915TSuQAAAAAAAAAAAEB25YpNrqcxgDQ7ce6ilbt3PjLayryBFn/NKOyynTbq1UuEWJk34mLSXQcyWq4TO63MezC4itgSEW3n5yvskp15a+ez82eXOuVXwMq8Qbns7KaR79xBsSXWP+EvhWWGk4HFxJYirnAr8+4MT3vHlCsRFZPz/opfp7SdP0MAAAAAAMgOth47Z3sJWU51S/+P3xb2FAYAAAAAAAAAAAAAH0YoDAAAAAAAAAAAAAA+jFAYAAAAAAAAAAAAAHxYgO0FAAAAAAAAAAAAAMg4Lhd3N6ejUhgAAAAAAAAAAAAAfBihMAAAAAAAAAAAAAD4MEJhAAAAAAAAAAAAAPBhhMIAAAAAAAAAAAAA4MMCbC8AAAAAAAAAAAAAQMbxExe3N4ejUhgAAAAAAAAAAAAAfBiVwkAGCQ608zsXf+4LtTLvnVUKiC1zdp6xMm/1EiFW5t0XFi22VCxS0cq8Jfzs/RZbRIydf1VW8jttZV5XdIzYUji3nbn9Q/dbmfdM/gpiS4jfZSvzxtiZ1jgSncfKvNWiD1iZV2Lt/bMcG2DnXu84bufvXlWL57cyLwAAAAAAQGpQKQwAAAAAAAAAAAAAPoxQGAAAAAAAAAAAAAB8GKEwAAAAAAAAAAAAAPgw9hQGAAAAAAAAAAAAfJjLZXsFsI1KYQAAAAAAAAAAAADwYYTCAAAAAAAAAAAAAODDCIUBAAAAAAAAAAAAwIcRCmcRU6dOlR49eiR5/Ntvv5W33347w+afMWOGdO7cWV588cVEj2/ZssUc79+/f6rG3bBhQzqtMP3Hy+h7CgAAAAAAAAAAAGQFAbYXgP8cP3482cCzVatWEh4enqHz79y5U3bs2CGHDx+W0qVLxzk+bdo083pUVJTXYy5fvlweffRR2bhxY7qsMb3Hy+h7CgAAAAAAAAAAkBX4uWyvALZRKZxNlClTRq666qoMnSNXrlzSuHFjmTNnTpzXY2NjZeHCheZYapw9e1ZiYmLSbX3pPV5m3FMAAAAAAAAAAADANiqFswltdbx3717p0qWLvPnmmzJy5Mg41byDBg2SwoULy5NPPmme79q1S7755hvZt2+fOa9Tp07SsGFDc+yLL76QyMhICQsLk61bt5pjjhYtWshPP/0kDz/8sPu1v//+WypUqCD58uVLsK6k5tH3jBgxQqKjo91tqa+77jrTpvqvv/6SQ4cOmRC6Xr160qtXL8mbN69Zk17n6tWrxd/fX66++mrTUrtIkSLpPp7nPdUW0imdCwAAAAAAAAAAAGRXVApnExp6agBbrVo1OXbsmMyePdt9LDQ0VMaPHy81a9Y0z/U8DWdDQkJMSHzNNdfI448/LrNmzTLHDxw4IGPHjjVVtw888IBUrlzZPVazZs1k8+bNcvDgQfdrOlfLli0TrCm5eapWrSrt27c3Aeurr75q1v3555/Le++9JzfddJM888wzZq4vv/xSRo8ebcbTY3PnzjVr6t69u2kTre2iVXqP53lPvTkXAAAAAAAAAAAAyK6oFM5m/Pz8pG3btjJz5kx55JFHzGva7rlAgQLSpEkT81wrajXEfemll8zzRo0ama9DhgyRO++803yvVb8vv/yyGU8tW7bMfC1YsKDUr1/fjKnja2Xu77//Lr1795Zt27bFWUtK82h1sapbt6752rx5c/O6tm1WWum7bt062b59u3m+cuVKc86tt95qnl977bVmn2NtX63Bc3qO53LFbZ6fmnMBAAAAAAAAAACA7IRQOBu69957TZWsVrlWqVLFtFC+++67TRWt+ueff0wrZW2z7NBW0SdOnJBTp06Z5+XLl3cHwvFpC2kdU0NhDUs1dC1WrFiC87yZx5Pu3xseHi7Lly83bZt3795t2jVrFbDSSuD333/fvHbLLbeYhxMAJyY9x0vt3AAAAAAAAAAAANkF5W8gFM6GNAiuU6eOadPcsWNHs9/uG2+84T5+9uxZ0wL5tttuS/De4OBg8zWx/YEdWv2r1b7aZlpbR2tInBhv5vH0xx9/mKpirUbWVtc1atRwB7hK9zHWCl1t46yV0LpvsraEHjVqlOTOnTtDx0vt3AAAAAAAAAAAAEB2QSicjauFf/zxRxPuXn311VK9enX3Ma0CPn/+fJorXcuWLWvG1HB03rx58tNPPyV6XkrzxG+7PGDAAGndurW888477tc00I6KinI/b9CggXmoNWvWmD1+ly5daoLp9B4vvtScCwAAAAAAAAAAAGQXifcPRpane+nu37/fBMMaEHu67777ZOrUqbJ27Vr3a9pu+sknn5SYmBivxtdq4S+++EIKFSpkKpMTk9I8gYGB5mtkZKQ5dvHixThVtxo4L1myxBzX87RdtbatdjghcMmSJc3X9B7PkZpzAQAAAAAAAAAAgOyGSuEsJCIiIs7+vI633norwWvaMrl58+ayYMECs5+wJ61w3bNnj/To0UPKlStn9vfV8997770k9xGOT6tjR48enWyVbErz1KpVSwoXLixt2rSR3r17S//+/eXtt982wW10dLTkz59f2rVrJ4sXLzYhrF67XuvHH38sefLkMe2rX3jhBdMaWqX3eA5dq7fnAgAAAAAAAAAAANmNKzY2Ntb2IiBy7NgxOXLkSKK34qqrrjL794aHh5vvHcePH5fTp0/HaR3t6dy5cybcDAkJMS2hnepXfU2raT0rgHUsfWjw6vj3339Ni2itFlYHDx401bnVqlXzah4VFhYm+/btkzJlypjAWJ/rOEWLFjUPfb5z504TvubKlUsuX75sxrp06ZJUqFBBgoKC4syVnuMdOnQozj1Nae7UCo+IEBtm7zhtZd47qxQQW37YeNLKvI9cX8HKvNuOnxNbKgbZ+VdGrJ+932GKiInbuj6zBEXY+WfZFetdR4mMEBP0379vMpt/6EEr857Jb+fPEBXid9nKvCcv2/tnOSrGzp9fZSIOWJlXLP6zHBuQx8q8e/2KW5m3avH8VuYFAAAAACA19pw8zw2Lp1LRnPXf9ITCQAYhFM48hMKZh1A48xAKZx5C4cxDKJyJCIUzDaEwAAAAACA72HcqzPYSspwKRYIlJ2FPYQAAAAAAAAAAAADwYYTCAAAAAAAAAAAAAODDCIUBAAAAAAAAAAAAwIcRCgMAAAAAAAAAAACADwuwvQAAAAAAAAAAAAAAGcfl4u7mdFQKAwAAAAAAAAAAAIAPIxQGAAAAAAAAAAAAAB9GKAwAAAAAAAAAAAAAPoxQGAAAAAAAAAAAAAB8mCs2NjbW9iIAX3T2QrjkJOuPXbQ293WlgqzMmydvXivzXrpwXmxxXbbzc73/sp17rS5F2fnXZMngACvzngyPElsqBYRZmdcVbeea90khsaVc7stW5j0bm1ts8fdzWZk3JOKklXkP+xUWWyKiY6zMWyF/LivzBoQetDKvmbtUVWtzAwAAAACyl/2n7fy/t6ysfOFgyUns/B9nAAAAAAAAAAAAAJmC1sHgZwAAAAAAAAAAAAAAfBihMAAAAAAAAAAAAAD4MEJhAAAAAAAAAAAAAPBhhMIAAAAAAAAAAAAA4MMCbC8AAAAAAAAAAAAAQMZxuVzc3hyOSmEAAAAAAAAAAAAA8GE5vlJ4165dsmrVqrg3JSBAQkJCpG7dulKiRIkrusE6dnh4uDRt2lTWrl0rZ86ckRYtWqTqfVcqNfOmZl179+6V5cuXS4cOHSQwMDDOeckdS2nc9Lx2G/cIAAAAAAAAAAAAyEpyfKWwhoFvv/22bNq0SbZs2WIe69atk88++8wEhJMnT76iGzxt2jT56aefzPfHjh2T/fv3e/2+7777TtJDauZNzbr+/fdfc+8iIiISnJfcsZTGTc9r99Zvv/0m3377babOCQAAAAAAAAAAAGSGHF8p7HjjjTckd+7ccW5O//795d1335U2bdpInjx5rvhm33HHHVc8RnaaFwAAAAAAAAAAAIB9hMLJaNmypakUPnjwoFx11VXmtQsXLpiq4sOHD5s209piumzZsu73REVFybJly+T06dNyww03pNii+J9//jGtlgsXLiw33nhjsq2WkztX59V2zWfPnpVrr71WLl68aKqDW7Vqlei8+pqOVaRIEWnUqFGcsVK6xrRKy7hr1qyRmJgYqVq1qrmvfn5+cvPNN0v+/Pll8+bNsm3bNqlSpYrUqVPH67l0TBUcHCzbt2+X2rVrJ5j3wIEDsnTpUnOfK1WqdMXXDgAAAAAAAAAAYIufi3uf0xEKJ0NDWA1LS5UqZZ5rW+knnnhCatasafYa1kBS202PGjVKbrvtNjl58qQ8+OCDcvnyZXPOxx9/LHnz5nWHkdqieOvWrSacDQ0NlaeeesoEzg0bNjTj6Pu++OILqVixYpx1pHSuBtAPPfSQ2Ye3Vq1a8t5777nXrKGw57xhYWHmGjQwvu6668yeygMGDJBx48ZJuXLlUrzGtErruLNnz5aNGzeadet7169fL8OHDzfX8vfff5t7q1Xezz//vDzyyCNezTV9+nRZuXKlCYv1/mno7Gnfvn3So0cPqV+/vnTu3DnN1wwAAAAAAAAAAABkBYTC/2/ChAni7+9vvtfAVUPEGTNmSL9+/SRfvnzmdQ1W+/TpI126dHHfwG7dusmUKVNM2Dhy5EgzxqRJk0wraq02veuuuxKthh06dKicOnVKZs2aZSpWdU4NMl966SX59ddfU3XuiBEj3Hvxagh95MgRM69W0MY3duxYOXTokMycOVNCQkLMa59//rm5Ng2FU7rGxGg1dfzW2xreekrLuA6t+NXPonLlynL06FFp2rSp7N6929xnl8sln3zyifz888/uUNibubSCeMGCBVK8eHH3HPEDYQ2fnZ8JAAAAAAAAAAAAILsiFP5/GiRqa2INTLVtsLaO1sD1mmuucd+s+++/3/19RESE7Nmzx7xHQ1o1b9486d27tzsg1ZBVK1q1lXF8eu4zzzxjQl6VK1cuU+3bq1cvE3ym5tw5c+aYSlkNhJVWCes+yFohG58Goffcc487EFaPPfaY19eYGJ1H1+RJQ1dPaRnXoeG2BsKqZMmSZn/n5s2bm0BYabXviRMnUjWXfjZOIOw4fvy4CYQLFixIIAwAAAAAAAAAAACfQSj8/7QFsRPm/vDDDzJs2DDTCtqTtmnWauA///zTBIgVKlQwQaN+jYyMNG2e4weNpUuXlh07dsR5TYNKbYfstHh2OM+1Ktjbc7Wl9Llz50yb5PjHEwuFNTzVYDUpyV1jUvr37x8nZHaqllesWHFF4zrij60BrxOQKw2HY2NjUzVXsWLFEsyjeyxr+23dq1grnevVq5fi2gAAAAAAAAAAAICszs/2ArIibTWslaha9at77jr69u1rwsIPPvjA7Gere/Vee+215pjuPRwUFCRnzpyJM5YGtvFppWuBAgVMeOnJea7HvD1XA97E5tWAOjEahp49ezbJa0/uGq/ElYzrVASn51yJjVmtWjX55ZdfpFmzZvLaa6+ZoB8AAAAAAAAAAADI7giFk6kc1v1kX3/9dXcV6rp16+Tuu++WBg0amFbNGryuXLlSoqOjzfGbb75ZZs+e7T7/0qVLplo1MTfeeKPZJ9ezwlX3vC1fvnyCPYhTOrdJkyamhbRDw8z58+cnOu91111njnmOtWrVKlm8eLFX15hWGTVues6lbaMDAgLkzTffNPsyjx49Ot3XBgAAAAAAAAAAkNm0Vo6HxLkHOQ3to5NQuHBh6devnwmFJ0yYIJ07d5amTZvK119/bVoRa8CowaxW6TpVuy+++KLZz/aRRx4xQe7cuXMlKioq0fH13Pvuu8/sYavjbtiwQZYsWSJjx45N9bm6n7Aef+KJJ6Rhw4by+++/m2BY2yzHp3sTd+jQwbTG1orYY8eOmesbPny4OZ7SNaZVRo2bEXNp9fVzzz1n7skdd9wh1atXT/c1AgAAAAAAAAAAAJklx4fClStXNoGqVgXH17FjRzlw4IDZt1cra3WfYd0rd+fOnVKkSBH55JNPzHnjx483IWy5cuVk+vTpMnnyZBO2Pv7446ZNsX6v6tevb/YYVnruzJkzzfk6fu3ateXVV1917w18/fXXu1tPp3RulSpVzDENP7WNdJ8+fUzlsK49/ry657FWHU+dOtWMVbRoURMKV6pUyRxP6Ro916Xv0XunrbPji38sNeN6fq8ht15//M/FWa/SimkN7R0pzaXV0nrPPHneI9W9e3fzuf3zzz+EwgAAAAAAAAAAAMjWXLGefYSRLWk7aA1369ata57rR6ohqQaqL7/8su3l5VhnL4RLTrL+2EVrc19XKsjKvHny5rUy76UL58UW12U7P9f7L9u51+pSlJ1/TZYMtvN7WyfDE+9wkRkqBYRZmdcVbeea90khsaVc7stW5j0bm1ts8fez0xMoJOKklXkP+xUWWyKiY6zMWyF/LivzBoQetDKvmbtUVWtzAwAAAACyl6NnL9heQpZTskA+yUlyfKWwL9iyZYv88MMPpnW17ou7dOlSOXnypDz00EO2lwYAAAAAAAAAAADAMkJhH6D7BGuV8Jo1a+TQoUPSvHlz+fDDDyUkJMT20gAAAAAAAAAAAGCZn+0FwDpCYR9x8803mwcAAAAAAAAAAAAAeOIXAwAAAAAAAAAAAADAhxEKAwAAAAAAAAAAAIAPIxQGAAAAAAAAAAAAAB9GKAwAAAAAAAAAAAAAPizA9gIAAAAAAAAAAAAAZByXy8XtzeGoFAYAAAAAAAAAAAAAH0YoDAAAAAAAAAAAAAA+jPbRQAY5EnbZyr2tHHjRyrzF8gVZmTcn8rtwyt7cpw9YmTekVH2xpcjFnVbmjY4uZWXebRf9xZboPMFW5r0qMMzKvJuPXrAyr5nb0rx35t1raWaR00WqW5k3Kn9xK/OWPWLrUxbZn7+qlXldl8OtzBteoKzYkivczjXnyZvXyrwAAAAAACDtqBQGAAAAAAAAAAAAAB9GpTAAAAAAAAAAAADgw/xctlcA26gUBgAAAAAAAAAAAAAfRigMAAAAAAAAAAAAAD6MUBgAAAAAAAAAAAAAfBihMAAAAAAAAAAAAAD4sADbC0Bcly9flsjISMmXL1+WmScqKkouXbrkfu7v7y+5c+cWlyvhruQ6ZkxMjOTJk0eyuuy0VgAAAAAAAAAAgLRKmOggp6FSOIt58cUXpX79+rJkyRJr82hg/OWXX7qfT5gwwZzbpEkT87juuuukdu3act9998nixYvjvHfUqFHy9NNPS3aQndYKAAAAAAAAAAAApBWhcBZy7tw5WbhwoVx//fXyyy+/WJtHj3344YcJXl+9erWsW7dONmzYICtWrJDmzZvLE088IQsWLIgTNnsGyllZdlorAAAAAAAAAAAAkFaEwlnIzJkzJW/evNK9e3dZtGiRHD9+PMlzo6Oj3VW9ERERibZ8Tss8Oq4z3oULF9zzxBccHCyPP/643HPPPTJ48GD3fNqSOan1xMbGpup6dCx9KH1vUmtJ6Xq1RXRicye21qTOBQAAAAAAAAAAALIrQuEsZMqUKXLrrbeah+7ZO2nSpATnfPbZZ3LjjTdKvXr1TKg7ZMgQ6dGjh/v45MmTTQVvnTp15Oabb5aPP/7YBK3ezrNs2TJ54403TACrraL//PPPZNfcqVMnOXTokPz777/m+bBhw+TRRx81358/f1769+9v5tH11qpVSx544AE5cOCAV9czdOhQU837wgsvSN26dc019e7dW0JDQ93v10rnVq1aybXXXis33HCDfPDBB+7rPXLkiDz00ENm7IYNG0rnzp1l1apV7vd6rjWlcwEAAAAAAAAAAIDsilA4i9i1a5esX79ebrvtNgkMDJRmzZqZvXy1ctXx008/yRdffCEjRoyQv//+W9q2bSs//vij+7ju7zto0CAZOHCgbNy4Ub7++muZPXu2CYa9neeWW26R999/X/z9/U2raD2enMqVK5uvO3fuTHTP3v3795vQWVtOT58+3QTIo0eP9up61Jw5c6Rq1aqmdbWOo2v65ptvzDE9V4PjV155xYTSGjBPmzbNvKYGDBggRYoUMeHuypUr5aabbpLXX3890Urg1JwLAAAAAAAAAAAAZCeEwlmEVvgGBQWZ6lzVunVrE6AuXbrUfc53331nKm0bNWokuXLlMlW6GuI6xo4dKx06dDDVruHh4VK6dGl55JFHZNy4ce7Q15t5UiN//vzuVtPxaaiqwa2GrapKlSqmKvjUqVNeXY8qUaKE2bdYA+zq1aubkFoDZqXh8H333SctWrSQgIAAU0387LPPmuphXc/Ro0fl0qVLpnJYjz///PPy+++/i8vlSrDW1JwLAAAAAAAAAACQnfi5ePjFuwc5TYDtBeC//XS1irZx48Zmb1x9aAvjPHnymIBTg1INLPfs2SM1atSIc8u0JbO2fHaqdTdt2iQTJ06Mc46fn58cO3ZMihcvnuI8qaUtolVISEiix9esWWNaUO/du1d2795tKpW1Cteb61FlypSJE8zqXsga3Op+wNqGWs/3VLt2bXNcK5RffvllE+467an1+jQ0L1y4cIJ1puZcAAAAAAAAAAAAIDshFM4CtEr3+PHj5qtTwau0uvePP/4wxwoVKmRaOmuA7MmzvbS2Ou7Xr5/07Nkz0Xm0vXRK82hwnBpbtmwxX+OHs0rbVmt76Hbt2pn9jR977DH5/vvv5eTJkyaoTul6lFbtJkZf1+rh+O939hPWY1qBrIH08uXLzTXr3D/88IMJzYsVKxbnfak5FwAAAAAAAAAAAMhOaB+dBUyZMsW0el67dq3ZM9d56F6/Ws2rwaS2V77qqqvMfsCenFbKSvfe9ayyVRqaaitlDYy9mUelpmWyVhhfffXVprVzfNoeunfv3ma/Xm0NrcGxVgvrWry5nuRoqKztqPVaPOlzbY+t16nXrfPceuutppW1ts7WNtF6zZ50Pd6eCwAAAAAAAAAAAGQ3hMKWnTt3ThYuXGhaFWvQ6UmD1gYNGpiwVitoH3/8cRPCzp4921T1fv311yYEdkLcZ555xlQDjxkzxrSL1lbSWp2rlcOpmSc4ONiEydrq+cyZM+7zdJ9iDU+1ZbQee/PNN2XJkiUyaNCgRK+taNGisnr1ajl8+LBp9azhsIbAOo5K6XpS8vTTT8ukSZPk119/Ne9fsGCBjB492lyvtsRu3769WaPumXz69GkT9ObOndu0mI4vNecCAAAAAAAAAAAA2Qntoy2bN2+eaYXcsWPHRI9369ZNXnvtNVm5cqXceeedEhoaKqNGjZKLFy+aFtD33nuvCV2V7hX8ySefmJbN3377reTPn9+89sEHH8j8+fO9nkcD4mbNmsn9999v9trV92n1rbPnsLZ91sC3bt26Mn78eKlWrZp7HG3brGGqGjFihAwePNgE0Xq+tpDWYFjbSuuewCldj+dYiY3fsmVLGTp0qAmThw8fLiVLlpRnn31WunbtaoLlzz//3Fy7Po+IiDDr1HNLlSoVZyxvzgUAAAAAAAAAAMiuUtMlFr7JFau9c5EtaFipgay2OXZoCKrB5rBhwyS78bXriW/rsXNW5q0ceNHKvLsjg8SWiiH/+xnKTHny5rUy7+Xje8UWv9MHrMx7qlR9saVI6E4r80YXsPNLKWtC/cWWgnns/LN8VWCYlXnnHM15DVvuzPvfL37ZcLpIwq0uMkNwoJ3POfDIZrFlf/6qVuYtHXjZyryRAXb+PqByWfrveVt/BwIAAAAApN3ZC/91ccX/FMiXs/77Nuf938hsrF+/ftKjRw+zL6+2OJ42bZosWrTItD7OjnztegAAAAAAAAAAAICsiPbR2YjueasVtI888ojZ27dSpUoycuRIadSokWRHvnY9AAAAAAAAAAAAQFZEKJyNFC9e3CfaKvvq9QAAAAAAAAAAAABZEe2jAQAAAAAAAAAAAMCHUSkMAAAAAAAAAAAA+DA/l+0VwDYqhQEAAAAAAAAAAADAhxEKAwAAAAAAAAAAAIAPIxQGAAAAAAAAAAAAAB9GKAwAAAAAAAAAAAAAPizA9gIAAAAAAAAAAAAAZBwXNzfHIxQGMsjUzces3Nuu15ayMm+3McvElr9eaGBn4rx57cwbG2vvLw65cluZd9mBc2JLy8rVrMw7despK/O2vbqI2BIaEW1l3rMBBa3MWyZ/pNhSOzjCyrwxlwuLLQViwqzMO2d3jJV5axevKrasPXLeyryXigdbmbeUnWmNHWft/DkSefKSlXkblLPz5zUAAAAAAL6A9tEAAAAAAAAAAAAA4MMIhQEAAAAAAAAAAADAhxEKAwAAAAAAAAAAAIAPIxQGAAAAAAAAAAAAAB8WYHsBAAAAAAAAAAAAADKOn8vF7c3hqBQGAAAAAAAAAAAAAB9GKAwAAAAAAAAAAAAAPizHtY+Ojo6WpUuXyooVK+T48eOSL18+qV+/vtx+++2SJ08eycomTJggS5YskRdffFHKlSsX59jPP/8soaGh0rt373SZ58iRI/Lss8+m6f2ea1m2bJn88ssvcY4HBgZKmTJl5J577pHKlSuneZ3xx/bz85Pg4GCpVauWtG3bVoKCgtI8NgAAAAAAAAAAAOArclSl8LFjx6RLly4yePBgKVCggNx6660mlBw3bpy0adNG9u/fL1lVTEyMjB49WtauXSu//vprguMbN26UNWvWpMtcW7ZskdWrV6f5/Z5r0Xs6d+5cE7rrPdbHLbfcInv27JF7771X/vnnnzTPE3/sVq1aSbVq1UworYGzhv4AAAAAAAAAAABAeouNjZXw8PB0Oz+146VWjgmFNVR97rnnJCAgQKZPny5PPPGE3H333fLggw+akLVkyZIycOBAyaqWL18uJ06ckO7du8vkyZPl8uXLkp3cdtttJrzVh1bxjho1SkqXLi1ff/11uo195513So8ePcznqVXfr732WrqsHQAAAAAAAAAAIDtzuXi44t2DtNLwdsSIEaYT8XXXXWeKILXgMq3np3a8tMox7aP//PNPWbdunQmE47eJzpUrl7z++uty6NAh92valliD5EuXLsm2bdtM6Ni0aVNTQattiw8fPmwCZv2A2rVrJ/7+/qbtclRUlFSsWFFmzJhh2hm3b99errnmGvnxxx9l69atUqVKFRNcOq2N9YPWc3VcPb969eqmyjV+62MNghs0aGCO6Q/GggULzJqSq4rW9ezdu1eKFi1q3lejRg338VOnTplr1ONFihQxP2BXX311nDG02lcrccPCwqRZs2YmfE3N+5PjcrlMC+mzZ8+6Xzt58qSMHz/ejBm/vXRin0dScufOLY8++qhps33gwAF3q+2kPjv93IcPHy4vvPCC+ewc33//vURERJixAAAAAAAAAAAAgO+++06mTJkiEydONBnUsGHDTJb0+++/J7q1aUrnp3a8tMoxlcILFy6UChUqJBlcanCr7YcdmzZtkvfff182bNhg9qjVvWo1ZNV9cnUf4ptvvlkKFy4sb731lnz22WfmPZra6/effPKJSfK1xFsD4J49e5oQVUNIbW08YMAA9zwfffSRaQtds2ZNqVOnjkyaNEmefPLJOGvTUHb+/PlmfVrRXLdu3QT79HrSUFUDVb2GG2+80QSwXbt2lZUrV5rjmzdvltatW5uvN9xwg1y4cEE6duxogmbPFtBDhw4196t48eKmylp/IL19vzetn7V1tN4npXsYawWxtpVu3LixREZGmjF1/+ekPo/kXH/99ear/iKASu6zK1u2rFmLBu+ee0+PHTtWChUq5PU1AQAAAAAAAAAAwLeNGzfOdCLWQtDAwEB56aWXTIdfLbRMy/mpHS+tckylsFaDavWpJw1JtYLXU//+/aVUqVLme63+HTJkiPkAnKpeTes1QFbaflrDzX///df9fq18nTlzpgktNTidNWuWCVb1A3TG0BDYoWGvBri617HS/XZ132A9T8NcNXv2bFMh64TWOu57771n5i5fvnyCa/34449NxauGmo6WLVu6K6T1vddee60Jr1WHDh3MMQ2rtSJY6dzffvutO3zdvn27zJs3z1TWevP++Pr06eO+njNnzph7poGwU4X74YcfmrD7gw8+cL9H933WMXXexD4PXVNSNPRVp0+fNl8rVaqU5GenFdr6XKvInXX+9ddfJuxOriIZAAAAAAAAAAAAOcfx48dN5qg5mWdHYi3+1HxPc7TUnK+FkqkZ70rkmFBYb+D58+fjvKYVom3atDHf79u3zwSTTz/9tDsU1sDVCSBVw4YNTVir1axajbt7927TyljHcWiK7wSpWtKdN29eqV27dpyg89y5c+7nGgKPGTNGduzYYb5v0qSJCX09aQWrVhFrlbDS41rFq3vn9uvXL8G1atvnBx54IM5r2npaaQtmPa5Vsp40/NTfRND7oKpWrRqnGlcDda2E9vb98d1xxx0mfNXAVQNkbQvttHVWq1atkpCQEHn22Wfdr2l1tQa3oaGhiX4eydE23s7n7s1np+2vv/zyS1mxYoU0atTIhPktWrRIsSIZAAAAAAAAAAAA2U+LFi2SPZ5Yh1wNeVWxYsUSFCvq1q6pPT+1412JHBMKa1ir7Y811NRw0gk6nephbR8cn4aUnvQcrfjVvW+1+lerTnU/XU8aAseXXJCp+95q2j9nzhxTBavBdadOnUzoqpWxGmBqC2Rtfe0ZmOq+uRoWa1tnJ/h0XLx4McHaPcNSbY0c/7iG1Ur30E1szRrm6r3z9v3x6X7Euo9vUjQA1j2bb7rppjivd+/e3f2+pK4pMRomK71v3nx2GoLra1otrG2+tTpZf0kAAAAAAAAAAAAgu3PFxtpegk+I+P8cLH42p891a9TUnp/a8a5EjgmFtT3wV199ZVJ9z72DHVpFmpKXX35ZatSoYVocO0HlU089lWQQ6i2tVtaHhq2//fab9O3b1/x2goakGmRrAPz888+7w2wn5NYKY20/rVW4njTo1j16E6Nhr+4RfODAgTivOxW+JUqUSHatV/r+pOiadez0atf8xx9/mCpfrRD29rPTNt7a2luDaa1m1pJ9AAAAAAAAAAAA+J4FiVQCp8TZqjV+YKvPtYNwas9P7XhX4n8po4+rXr262b/29ddfl6VLl8Y5pm2Rde/aggULuiteE6NVprpXrxMqagXvkiVLzGbPaaGVtxpW6v61SiuDNbhUGmjq8WnTppkqWw2NNTB1Hk8++aQpJf/ll18SjKvnapjs7KerPvvsM7OnrhOQ//zzz+Z6VHh4uHzxxRdy4403uvfiTc6Vvj+pMbXyWds6O/TaX3vtNXMfUuPvv/826+ndu7f7HyZvPru77rrLVFnrnsl33nlnspXNAAAAAAAAAAAAyFnK/H8HYqfts0Ofly5dOtXnp3a8K5GjUi+twNWbq0GjhoUaEp44cUK2b99uqm0//fTTZCtdNYjVlsIaKGpQqRs/33zzzSZUTgut/K1bt66pWK1Vq5ZpPa2bRnft2tXsAbxs2TJT8du5c+cE79WycX1dq4Xj7+P74IMPmnH0mnRjau05rhWxen3OdWzdutWEx7rfse5nrNc9YsQIr9Z9pe9PjAb2mzZtkg4dOph7oiGurlv3TvaskE5Mnz59THtrrbTWf0g0WH7ooYfkkUceSdVnV7RoUVMdvHjxYlM1DAAAAAAAAAAAADgKFSpktiRdtWqVXHfddea1CxcuyMaNG6Vbt26pPj+1410JV6w3fZN9jIaC27ZtM6GjhsMayGplrqfNmzebqlGn/bBD2yZr6Kj70eretGfPnpU1a9ZI8+bNZdeuXWZP4Ouvv959vrZ31r1qnTT/6NGjsmHDhjgtrM+cOWNCVg1u9YMvW7aseV3D1j179phK4cTo+1auXGn2JNZ16Ps916tht65XK4r1GuOHq3oPDh48KKVKlTJrdGhQGv86dH06xw033JDi+/UH1VmLzq9hb+vWrU1wmxK9h7qPsu4frIGzU+mb2OfhjO3Qyl4Ndq+66qoEn2dKn52zh/Lnn38uM2bMMI8rNXTRDrGh67WlrMzbftQyseWvFxpYmTewQFEr814+tkds8Q87YWXeaeHlxJaWlQtamXfq1lNW5m179f/2W89soRHRVuYNymWnccr+s+m7J0hq1A6+sq0v0sp12c68KjYwfdvteGvO4dR1PEkvtYvnE1vWHjlvZd6axRP+/S8zlAqOu+dPZtp/zs6fI5FRdv4TskE5O/9OBgAAAABfEBEebnsJWU6evHnT9L6pU6eaDsSDBw82edPw4cNNXqava1dg7bCrOZkGvt6cn9Lx9JIjQ2EgqV8W0Orr9u3bm2rtK0UonHkIhTMPoXDmIRTOPITCmYdQOPMQCmceQuHMQygMAAAAAGlHKJx+obAaP368/Pjjj6aqt169evLSSy+5uxE7W7pqR2BvzvfmeHrIUe2jgaRo62ttG62/cdGxY0duFAAAAAAAAAAA8B2xdrqZ+aouXbqYR2Ief/xx8/D2fG+OpwdCYUDbpbZta/Zx1vbYTitpAAAAAAAAAAAAwBcQCgMiUqVKFfMAAAAAAAAAAAAAfI2f7QUAAAAAAAAAAAAAADIOoTAAAAAAAAAAAAAA+DDaRwMAAAAAAAAAAAA+zBUbY3sJsIxKYQAAAAAAAAAAAADwYYTCAAAAAAAAAAAAAODDCIUBAAAAAAAAAAAAwIcRCgMAAAAAAAAAAACAD3PFxsbG2l4E4ItmbjlmZd7WRS9ZmXdrVAGxpUrB3FbmDcqbx8q8l8LOii2uy+FW5g0LCBFbImPs/Guy8ctzrMy74v07xBZ/l51584cftzLvkYCiYkuUpZ/roFz2fh/R32XnB2zXmQgr85bIl0tsyeVn516HXY6xMm+lfBb/c8rSf8qFuwKtzDt7x2mxpWu9stbmBgAAAID0cOnCeW5kPLnz5ZecJMD2AgAAAAAAAAAAAABkoFg7v0yNrIP20QAAAAAAAAAAAADgwwiFAQAAAAAAAAAAAMCHEQoDAAAAAAAAAAAAgA8jFAYAAAAAAAAAAAAAHxZgewEAAAAAAAAAAAAAMlBsLLc3h8sWofD8+fPjPPfz85OCBQvKNddcI3ny5EmXOS5cuCDLly+XRo0aSb58+a54vF27dsnhw4elUKFCUrVqVcmdO3eGzZVTPrOYmBhZtGiRFClSROrWrZvk8ZIlS0rNmjXTvHYAAAAAAAAAAADAl2SLUPipp56Sq6++WsqWLesO/w4dOiTHjh2T9957T5o1a3bFcxw9etTMM3v2bKlSpUqax1mxYoUMHDhQwsPDpXLlyiYYPnv2rLz44ovSrl07c05YWJhMnjxZateubS0U/uyzz6RUqVLStm3bRJ9nxc9Mg+Vly5bJxIkTZcaMGVKhQoU4x3/88UcZOnSojB8/Pl2uAQAAAAAAAAAAAPAF2SIUVp07d5Zu3brFeU2D1pdfflmWLFkSpxLXFq3+feSRR+SVV16RBx54wISYSkPK/v37S0hIiLRo0UJKlCghY8aMsbrWr7/+Wvr165fk86z6mfXt21f++OMPGTBggFmzQ8PmkSNHymOPPWbCdgAAAAAAAAAAAAD/+S+1zKbuuOMOU4V74MAB92unTp2Sv//+WxYvXix79uxJ8B5t3azVvCtXrpTz588nO75WpWrQ62nr1q3m9f379yc4/+233zaVtt27d3cHwqpLly7StGlTsyZnDdpeWb96rvuvv/4ya9aqWj3uub6krkvP0XMjIyNl1apVsmXLlgTXqu/znEsD2cuXL5tz161bl+B5Su/35l6k5jNLap7Erk0rq7USW+edNWuW+9zBgwebquQnn3zS/Zqu688//zStvGPj9cqPjo6W3bt3y9KlS83cnvdar0sfWj2un//x48e9vj4AAAAAAAAAAAAgq8k2lcKJ2blzpwQEBEjp0qVNkKoVuhoC6n6yGi7+888/cvfdd8uwYcPM+doa+vXXX5eKFSuKy+WSffv2mSD3rrvuSjD2Bx98YNoRf/XVV+b5xYsXTRWqBoWVKlWSHTt2SLFixeSbb76R4OBg2bhxo+zdu9eMlxhtz5xUq+qffvrJtFTW/XY1gKxRo4bMmzdPpk6dalowJ3ddBw8eNGPVq1dPAgMDJSoqyoyn73/11VfNWjWg1iBZ16ah7Jw5c0zQunbtWilcuLAcOXIkznMdK7n3p3QvvP3MVHLzJHVtTZo0kfbt28u7775r9mVes2aNLFy40LSVzpUrlwm4tTLbuWf6ueh8I0aMkOLFi8v27duld+/eEhQUZPYf1tBYQ/exY8fKTTfdZOb4999/TZvvokWLyj333CNdu3a9op9VAAAAAAAAAAAAa2JjuPk5XLYJhbdt22aqRlVERISpGv3hhx9MOKnhnlZ2alipe81qQOm0bX7rrbdMqHrp0iXzVdsXayWvWrRokcydO1fuvPPOJANhDSSVnqfVrboGDR51Da+99poJg2+88UYTMCvdRzg1NCQdNGiQmVODUA00n376afdxDTCTuy7HDTfcIH369DHh+IkTJ0yLZq2e1TGVrltbL9eqVcu8rs+1xXWnTp3cx53nKb1fQ9jk7oW3n1lK8yR2bQ69dq1wfvbZZ8090grh6tWrm2Pff/+9bNiwwXxmhQoVMoH3c889Z8JmbdutYbHu7+zcZw2btZpbw2ANhZUGxb/99puUK1cuzrwAAAAAAAAAAABAdpNtQmGt3NRqTqWVphqQ6h6yzZo1M69pIPjJJ5+4z9cQOE+ePO5AUgPgvHnzmuDToe913u8YNWqUCRO16tUJhJWOdfLkSfn222/l9ttvN2GhBrkODXOVv79/qq5LWyCXL1/eHYpqyKpVrLpvrjfX5dCKWaXVtloJrF91LCeUVVptq4Go5z1ITErv12ri5O6Ft59ZSvPUr18/wbU5ChQoYIJxDXY1QNag2TFp0iRTda3tqB1XXXWVCfk1INZ9nz2dOXPGhMee97NMmTLmuuLPCwAAAAAAAAAAAGQ32SYU7ty5s3Tr1i3ZczRI1WpPbWesVai6x6zS/WS11bG2Ck4p4NPqUw09NUR2qkaV08543LhxMnz4cNOCWtsKaxipgaeOrbT9s7Ycjk8Dx9y5c5u21Z604tZZp0NDYm+vy1GiRIk4e+nqdU6ePDnOONddd50JxlOS0vtTuhfefmbertPz2jy1atXKBMht2rSJM6/eU73X8ce99dZbzX7GWqX89ddfm/2ZtbW0rkHH0VbdKc0JAAAAAAAAAAAAZDfZJhROiYa52kJYH9pSuGrVqrJp0ya5//77zXGtBNU9YlOilay6b6+2MNa20nXr1nUfe/TRR02Vqbaq1j1sv/jiCzl9+rTZp1irWjVs/Ouvv0yVanwani5dutTsI+xJ16XhqKdz5855fV2O+FW0Gqpqq+S08Ob9yd2L9JpH202npVI3JCTEBMZacZ0YrS7WltP6Geuew1oVrG2snarmtMwJAAAAAAAAAAAAZFU+k3wtW7bMVNA67YS1UlQDVaV7wl577bVy+PBhs1esQ0NibVscHh7ufk3H0MrTJk2amH1ytd2w2rx5s6xfv95U+taoUUOeeuopU3mqlaZKK0179OhhKlB1Hk96zpQpU0yr5fhho+6Xq+HnsWPH3K85raO9ua7EaECtldGrVq1yv6ZVxTquVtEm1uba83lK70/pXnjLm3WmhY6rbbmjo6Pdrx05csR81nrPNJzXPYRbt25t7q1Wces+yewdDAAAAAAAAAAAAF/kM5XCDRs2NPsAf/jhh6YN8MqVK00FqwoNDTXHNQTUFsda4aoVqrr3rGrZsmWC8XS/2rvuukvGjh0rzz33nGkL3adPH/PeypUrmwB0wYIFMmzYMPd7tJpXWzx37NjRVPJWqlTJnPf999+blsga7MbXokULqVOnjvTq1Ut69uxpwuHx48ebYxq6pnRduh9vfNr2Wq/1mWeekccff1zy589v2mFv2LBBJk6caM4pUqSIeU0rlfX64z9P7v3e3AtveLPOtNAKYP0M9J5qW2vd//jHH3+UW265xVyb3lNtx60VxRoE6/caDGtraQAAAAAAAAAAAF/jik280BA5R7aoFNbgtFy5csmeo2GftiHWAFArQbXN8pw5c+Tee+91twXWFs5PPPGE/P3337J8+XLTHvrLL780x4KDg808+lVpBam2Qt69e7ecP3/eVMLquWfOnJG5c+eaYFTDWg01HVrFO3r0aHn//ffNezS81aDxvffek08//dS9763nXBr86rgaXmrr6aioKLNOpcF1StfljKWtqz1piKwtkbW984oVK0yltFYrO3vlDh06VPLly2fuRWLPk3u/N/fCm88spXmSujZPzZs3lwoVKsR5TZ9Pnz7djKVVx9qe+5VXXpEBAwa4W4R36NDB/Azs3LlT+vXrZz43bSOtleFa/azVxgAAAAAAAAAAAIAvcMVqv15Yo22NdX/bpk2bul/T1sfaulrbKmtbamRPM7f8ryV4Zmpd9JKVebdGFRBbqhTMbWXeoLx5rMx7KcxeVbvr8v/a7WemsIAQsSUyxs6/Jhu/PMfKvCvev0Ns8XfZmTd/+HEr8x4JKCq2RFn6uQ7KZe/3Ef1ddn7Adp2JsDJviXwJu8lkllx+du512GU7v/FcKZ/F/5yy9J9y4S47/40ye8dpsaVrvbLW5gYAAACA9BB59iQ3Mp7AAvb+/5wNPtM+Ors6d+6c2ZP3vvvukwYNGpg9dj///HPTippAGAAAAAAAAAAAAECOaB/ty3Sf4AkTJpgAeN68eWZ/Xt2bV/c+BgAAAAAAAAAAAIArRaVwFqB72OoDAAAAAAAAAAAASHexdrZdQtZBpTAAAAAAAAAAAAAA+DBCYQAAAAAAAAAAAADwYYTCAAAAAAAAAAAAAODDCIUBAAAAAAAAAAAAwIcRCgMAAAAAAAAAAACADwuwvQAAAAAAAAAAAAAAGSg2htubw1EpDAAAAAAAAAAAAAA+zBUbGxtrexGALzp/MdzKvLN2nLYy7w1lQsSWyBg7f4xdXdzONUeE2/nZUgGndluZN6pIZbEl1uWyMm+UpZ9rf0vXa+aOirAy7wUJlJzmRHiUlXnLh9i71/6XwqzMe9E/yMq8YZH2fvt36YGzVuYNDrTTBKl8gTxiS6ngXFbmPWXpz5Aiee01uioQY+fPkMCCxa3MCwAAAMD3RJ45ansJWU5goZKSk1ApDAAAAAAAAAAAAAA+jFAYAAAAAAAAAAAAAHyYvf5bAAAAAAAAAAAAADJerL2tppA1UCkMAAAAAAAAAAAAAD6MUBgAAAAAAAAAAAAAfBihMAAAAAAAAAAAAAD4MEJhAAAAAAAAAAAAAPBhAbYXkJ1MmjRJhgwZ4n7ucrkkMDBQypQpI507d5aOHTte0fjDhw+X6dOnS0BAgMyePVvy5MkjOcHhw4fl008/lRUrVkhYWJiUKFFCmjdvLg8//LDky5fPfd7MmTPlrrvu8nrc1J4PAAAAAAAAAAAA+CJC4VSIjIyU8+fPm/DS39/f/drvv/8ur7/+uglz77333jR9EFu3bpUvvvhCPvnkE6lXr16OCYTPnDkj9913nzRp0kRGjx4tBQsWlJ07d8q7775r7vMPP/xgwvf58+fLSy+95HXIm9rzAQAAAAAAAAAAfFZMjO0VwDLaR6dB/vz5JSQkxDyKFi0qXbt2NUHutGnTrigcVY0aNTJj5hRz58411cGDBw+WqlWrSrFixcw90IrsNWvWyN9//23Oi4qKStW4qT0fAAAAAAAAAAAA8FVUCqcTrRzOnTu3+/mSJUtk7Nixsm/fPildurRpL92pUydzTAPPs2fPmiBYK4Svv/56U9mqbr31Vrn//vulb9++8scff8hXX30le/bskSJFipgxHnjggUTHePLJJ81c4eHhUqBAARNQa4Vtly5dpEWLFqbydtu2bVK5cmV56623pEqVKu5KZ13nX3/9JYcOHZJcuXJJ/fr1pX///iacfv/9901oq22ctSJaw1Zt7fzyyy+7q5l1nVrlvHfvXrNObaPdo0cPr+6FioiIMNdwzTXXuF+rVauWrF69WvLmzWve/8orr0h0dLQ0bNjQtNm+6aabklz3li1bEpy/dOlSOX78uHz00UfuOQYNGiSnTp2SESNGmHs5dOhQWbVqlfksq1evLk899ZRcffXV6fUjAgAAAAAAAAAAAFhBpfAV0lB16tSppqK1TZs25jX9/umnn5b27dvL5MmT5dlnnzVtoTXgVRrcTpkyxQTA33zzjQkfhw0bZo7NmjXLPNevOsbtt98uEyZMkN69e8uoUaPMOImNoe2XNVzVcy9duiTjx4+XXr16yQcffCBPPPGEPPTQQ/Ljjz9KbGysDBgwwL1+Pa7Vum+++aYJkrVid9myZfLxxx+b4zrmxIkTzZjjxo2TgQMHmuv99ttvzfE///zTrNdZ54svviiff/65md+be3HHHXeYPZk1JH788cdNu+gdO3aYY1qJrWGvVg6//fbbJqxduHChNG7cONl1J3a+3q8LFy7E+ez0tYsXL5rv9XwNiPVe6nXq3Bq0AwAAAAAAAAAAANkdlcJpcOONN7q/16BRq1/79esnbdu2Na9pNaqGnFoxq0qUKCHPPfecCS41qFXaJlkrgh2HDx82X4ODg00F7pgxY0yQ6lQGlypVylS6fvjhh/Loo48mOobSPXl1L12tEtZjWiGs69LQWLVr185UGTs0pH3hhRfcVc5agdu0aVP3epwxX3vtNROyli1bVlq2bGmqeDVs1hC1devW0r17d3Ou3ot58+a535vSvdCq5kmTJpmQec6cOfLOO++Y8ypWrGgCZp1L92p2qpI1rE1p3YmdnxLdx7hOnTrm+vz8/ExwHj9EBigOTtMAAQAASURBVAAAAAAAAAAAALIjQuE00NBTA1INXjWUDAwMjHNcWyH/888/pqLWoa2MtSr16NGj5rmGj0m5fPmyCSkfe+yxOK9rK2StbtV20kmNoa/pupSGm7q2cuXKuY/rerX616Ftoffv329aNGv75927d8vatWtNK2ZH+fLlzfV67qnsXIe2atZw2JO2fPb2XpQsWdIEwxoU6+PIkSOmJfT3339vKow1LPYM4VOz7tTQqmANobWyWAP0W265RVq1apWmsQAAAAAAAAAAALISV2yM7SXAMkLhNNBQVKtRk2sp/cwzz5i9c+PTSmDlVLImRkNdHd8ziHVCXuW8ntgY2m45sfGSoi2ltZr45ptvlpo1a5rqYl2j7iOc3JgOXcuV3gtPWhHdoUMH04r7tttuM220EwuFvVl3SmJi/vcHoLaxbtCggQmFtQ21tqXWNtjazlpDawAAAAAAAAAAACC7Yk/hDFCpUiXZuHGjaV0c/+EEu8nRkFWrczdt2hTn9Q0bNpjKX23RnF50f99HHnlEPv30UxPearvm06dPe/1+bfO8ffv2NN8LbTv9xhtvJHifVhvrezWATyzYTmnd8c/XYNuzQlppVbKn4sWLS5cuXcy+xNOnTzfXtXLlSq/vBQAAAAAAAAAAAJAVEQpnAA0r586dK5MnT5aoqCg5efKk9O/f3+yt61mdmtIY48ePl8WLF5v3aECsQahW0Wrr5PSi1cbaflkrei9duiSfffaZrFq1KkGAmpQHH3zQBKhLly6V2NhYE8z27NlT3n//fa/uhe41PGXKFBk3bpwcO3bMvEerfbVCWENZDWmdkFjbTp87d86sLaV1xz+/Vq1aJpzevHmzWeeMGTPMvshK13HXXXfJqFGjzHjq77//NlXQVatWTbd7DQAAAAAAAAAAANhA++gMoK2PT506JSNHjjRtiLVq9aabbpIRI0Z4VSms2rdvL2fOnJFXX31VQkNDTWvk++67z+yzm56GDBli1qh78eocjRs3NpW3GtLq3sYp0X13+/TpIy+//LIJYLWS+c477zRjeHMv7rnnHhNyf/XVVzJs2DB3ha+2jNb9hLViWtWrV09q1KghjRo1MvckpXXHP19D6DVr1pg21hr23nDDDdKtWzcTLOs6tBX1oEGD5Msvv3S3sf7www9NtTIAAAAAAAAAAACQnblitWwSXtEqUq061dbH3goPDzdVrZ7tjHUMrU4NCgpyv6ZVtBcvXkx0bB1DK189JTaGvqbVsZ6VxOfPnzfzO/sCa2Cq5zltmT2vTQNdpWNcuHDBhK36evwxE5snqXWmdC/i03ugYyR1Tvw5klq3E77HP1/vs/7I6/3Q9+pzz3uo91TvUe7cueVKnb8YLjbM2uF9++/0dEMZ7/+5SG+RMXb+GLu6uJ1rjgi387OlAk7ttjJvVJHKYktsMn9mZaQoSz/X/pau18wd5V2XivR2Qf7790hOciI8ysq85UPs3Wv/S2FW5r3o/7+/Z2SmsEjvutNkhKUHzlqZNzjQzu+7li+QR2wpFfzf3/Ez2ylLf4YUyWvvd5oLxNj5MySwYHEr8wIAAADwPZeP77W9hCwnV/GKkpNQKZwKGj46AaS3EgtJNRhN8EEEBCQZNns7RmKvxQ9/NQx1AmJPntellbTOWrydJ6l1pua48gxovRkjqXUndb7e5+Q+Tw2T0yMQBgAAAAAAAAAAALIK9hQGAAAAAAAAAAAAAB9GKAwAAAAAAAAAAAAAPoxQGAAAAAAAAAAAAAB8GKEwAAAAAAAAAAAAAPiwANsLAAAAAAAAAAAAAJCBYmO5vTkclcIAAAAAAAAAAAAA4MMIhQEAAAAAAAAAAADAhxEKAwAAAAAAAAAAAIAPIxQGAAAAAAAAAAAAAB8WYHsBANJXk3IFrNzSAH+X2LL/ZLiVea8ubmVaORgWZWdiESlWqLKVeSMvx4otBcOPWpk3PKiElXlzx1yQnOZitJ2/DpW4fEJsyRdc1Mq8rkthYktUYLCVeYMunLQyb5hfQbGldvH8Vub1t/TrrkXy2vtPqshoO/9+LBZk55oDLf59MzzWzs/1sAXbxZbXWlSzNjcAAACADBAbw23N4agUBgAAAAAAAAAAAAAfRigMAAAAAAAAAAAAAD6MUBgAAAAAAAAAAAAAfBihMAAAAAAAAAAAAAD4MEJhAAAAAAAAAAAAAPBhAbYXAAAAAAAAAAAAACDjuGJjuL05HJXCAAAAAAAAAAAAAODDfKJS+N9//5Vp06Ylefzuu++WevXqiW2//fabHD9+XHr27Jmm98+YMUPOnTsnDzzwgGSG0NBQKViwYLqsfc2aNTJ79mz3cz8/PwkODpZatWrJrbfeKgEBPvGjCAAAAAAAAAAAAGQ5PlEpvGvXLvnxxx+lXLlyUrly5QSP/PnzS1awevVqmT9/fprfv2LFClm4cKFkhk2bNsmdd96ZbmvfsWOH+YwqVqxoPpOyZctKTEyMvPvuu3LfffeZsBsAAAAAAAAAAABA+vOp8szOnTtLvnz5bC/DJxw4cEDOnDmT7uN27do1TlVwr169pH379vLWW2/JiBEj0n0+AAAAAAAAAAAAIKfzqVA4JdoCOSoqSqpUqSLz5s0z3zdr1kzq16/vPicsLExmzZole/fulSJFikibNm2kdOnS7uMXL16U6dOny759+8zrrVu3luLFi7vHj4yMlEqVKsnvv/8uQUFBpnW1VjDHr2xesGCBnD9/3rRObtCgQZxjWhF86NAhyZUrl1lb06ZNE70eXYuudc+ePWatWtlbsmRJr9eS1Fxa1Ttx4kRTyTtw4EATtie39oMHD8rXX38tjz76qJQqVcp9rt6nCxcuyP3335/kZ1KgQAF54okn5I033pBXXnlFSpQokeJ9VidPnjTHz549a9aQO3duU9388MMPmzbVsbGx5rytW7fKLbfcItddd12KY6Z0HAAAAAAAAAAAIFuKjbG9AljmE+2jvaUtkEeOHCkvvPCCCUEPHz5sAstFixaZ48eOHZO2bdvKlClTTFi5bds2E6Ru2LDBHD99+rTcc889JnAtVKiQrF+/Xu666y75559/3ON/8skn8swzz5iQcufOnWY83U/XoWM+++yzJnDV8bp162YCajVnzhzp2LGj7N+/X4oVK2bW8/jjj8u4ceMSXIuG1nfccYd7rWvXrjXPdQ3erCW5ufLmzWvCWZfLZVo9O9XXSa1dg2i9J5MnT3avT0PZDz/80JybksaNG5vznbWldJ/12vVali1bJnny5JHhw4ebQFmvSWnQrWG2rsff318iIiJSHDOl4wAAAAAAAAAAAEB25VOVwu+9916c1sTKz89PXn/99TgVphpkOhWg2iJZg1WtGP7oo4/M/sO6962GiUr30dVQUY0aNUrKlCkj3377rXu8Dz74wFS5zpgxwzzXoFmrTbUaWfXv318GDx5s5lCXLl2S7777zlT2qqNHj5r3tmrVSgIDA2XMmDHSqFEj9/ihoaGyfPly6dmzZ5zrGjp0qKlm/eGHH8w1OnO9+uqr7pA5ubWkNNfNN99sztPg15Hc2rVKWed66qmnzDENePVea6V1SpzxTpw44dV91u+vvvpq+fLLL01wreu9/fbb44ypVdIff/yxqZBW2p46uTG9+WwBAAAAAAAAAACA7MinQmFtlawVwJ40NPRUsWLFOC2By5cvL7t37zbfayDaqVMndyCsWrZs6f5+yZIlpqpWq1AdGrxu377dtFNW2oLZCWGVhqVasaqVqKpatWruENRZs7Y4Vs2bNzdfdSythtV1afBatGjRONegVbVaJashrxMIqw4dOpi5tPo3pbV4O5en5NauVbbff/+9rFu3TurVq2eCVG3brFW3KXGqiZ37ntx9PnfunCxevFjefPNN92erwe9tt91mqns9P1cnEE5pTL0HKR3XXxYAAAAAAAAAAAAAsiOfCoV171un1XFSQkJC4jzXUNXZf1YDx+RCzOPHj5vAU1sqO/T7Jk2auMfQYNGTtnZWTmis7Y49abAZHR1tvtcWz1qZqi2Ly5YtKzVq1IizPs8qWH14BrTKWbvui5zSWjQY9mYuT8mtvXbt2iaAnjp1qtSqVUvmzp0r77zzjnhDw1fl7Hec3H3WfX+1YrlgwYJxxihcuHCi98Lbz86bzxYAAAAAAAAAAADIjnwqFL5SpUqVcrcwTozunat77Xq2VI4v/vt1r15taR0/oE1M3759TaWu7onrBLi6h++FCxfinKd7BOt5R44cSTRcdap9k1uL7qXszVypodXC2n5ZW09rkHrrrbd69T6t0tXAuWHDhl7dZw2E9VriX1tyUhrTm88WAAAAAAAAAAAgW4r9r2srcq7/9R6GaamsbY89g9GJEyeah9K9cydNmmSqSj0DzWHDhrlbIP/999+ybds2871W0f7000/StGnTOK2Mk6Jtnxs0aOAOaXft2iVLly6VqKioBOdqW+tff/3VXRWs54wbN07q1Knjbo+d3FpSmkvbcGuwm5oq2bZt25o9mocMGWL2+NV9i1Oi837++efy4IMPSnBwsFf3uXXr1ua4VksrrXqeM2dOsvOkNKY3ny0AAAAAAAAAAACQHflUpfB7771nKmHj06D03nvvTfH9jz32mNlXWMPNG264wVSfbtmyRb744gtz/KmnnpK1a9eailhtK3zq1Cnz/K233nLv7attjB9//HFT9artoCMiIuTrr7/2av1du3aVTz/91ASlGuKuWbNGatasmaAiWPXp00ceeughs9brrrtONm/ebOb67LPP3Ockt5aU5tLWybrH7zPPPGP2Wfa20vr666+XlStXJnm/Bw8e7G47rQGs3m+9n88995z7nJTus65JK3r1uH62ekyDcM/9leNLaUxvPlsAAAAAAAAAAAAgO3LF+sCGqRpsariYlEqVKknjxo1l9erVEhoaaqpCHfFf06pQbal84MAB0175pptukrx587rP19u1atUq2bt3r+TPn9+Ex87evgMHDpQdO3bI8OHDzTm6v7EGjE7FbGLzaxirla633Xabef7vv/+aMXTu+vXrm/1/Fy1aZPZL1pBS99TVimalwaqu9eDBg6b9sa5VK3y9WUtKc+l5mzZtko0bN5qKYq0ATmntSgP0CRMmyO+//x7nM9B5NCx2aOCsbax1/2Fde3zJ3WelAbdW8mpVt4biGnBriK9VxzqPXotWU6dmzJSOp9b5i+Fiw9mI//Z5zmwB/i6xZdtJO/e6aZX/WrVntp0n/tuj3IZiQXZ+lygy2t6/qgqGJ9+ePqOcDyphZd7gmIuS0xyPzmNl3hKXk96yIqPFBNv588sVdUlsiQr8ryNJZgu4cNLKvMf9CootZy/Z6bLib+n3+Irktfd7trb+/ZgnwM7f+wIt/n0zxtJfRT5ZccDOxCLyWotq1uYGAAAAkP6iDm3htsYTUKaG5CQ+EQpnFU4Q+/333+fYtXTv3t3sJdyrV68Mm0PbZGug3KZNG3dArBW+WjWtFb9ZBaFw5iEUzjyEwpmHUDjzEApnHkLhzEMonHkIhTMPoXDmIhQGAAAAfAuhcEI5LRT2qfbRsOerr76Sv/76y7SE7tKlS4bOpVXPL7/8ssyaNUsKFixoKrC12lnbaQMAAAAAAAAAAACIi1A4Hd1xxx3SqFGjHLkWbTFdqFAh09paQ9uM1LFjR9MO3Gmn3a5dOzO/7lUMAAAAAAAAAACAeGLtbPeErINQOB3p3rY5dS1169Y1j8xSqlQpufPOOzNtPgAAAAAAAAAAACC78rO9AAAAAAAAAAAAAABAxiEUBgAAAAAAAAAAAAAfRigMAAAAAAAAAAAAAD6MPYUBAAAAAAAAAAAAH+aKjbG9BFhGpTAAAAAAAAAAAAAA+DBCYQAAAAAAAAAAAADwYYTCAAAAAAAAAAAAAODD2FMYyCCnw6Ot3NvjFy5bmTcol7/YUiYkt+QkRfPau9d5YiOtzHvwgktsCQkpamXe8MhYK/MWOHtQbDlRqKqVeQvksfM7cpfylJQcJ5e9v3rmPn/Uyrx/h4dYmTeXX5TYsvlEmJV5rykWbGXeSsF2/s6nzomdvxOcibBzzWuPnBdbWlcpZGXe4Dz2/tz8ctU+K/M+cn0FK/MCAAAAgK+jUhgAAAAAAAAAAAAAfBiVwgAAAAAAAAAAAIAvi4mxvQJYRqUwAAAAAAAAAAAAAPgwQmEAAAAAAAAAAAAA8GGEwgAAAAAAAAAAAADgwwiFAQAAAAAAAAAAAMCHBdheAFLn+PHjcuzYMalevbrkypUrXW/fkSNHJDw8XCpXrpzuH8vp06fl0KFD7uf+/v4SHBwsZcqUMd8DAAAAAAAAAAAgg8TGcmtzOELhbKZ///7y119/yQcffCBt2rRJ17HnzJkje/bskYEDB0poaKgMGzZMBg8enC5jz507V95++22pWbOmeR4dHS2nTp2SqKgoeeKJJ+TBBx9Ml3kAAAAAAAAAAAAAxEUonI1ohfDy5culefPmMn78+HQPhR966CH39ytWrJApU6akWyjs+PXXXyUg4H8/dvPmzZPnn3/eVD0/8MAD6ToXAAAAAAAAAAAAAPYUzlamTZsmxYsXl27dusmqVatk7969Cc6JiYmRAwcOmFbNsUm0AggLC5Pt27ebSt347aN3794t58+fN2OoDRs2yLlz5xK8V7+mZe74WrVqJT169JCPPvpIIiIiEl1nYnM5Lan1Hui8ei27du0yrx8+fNg8dDy9nsjISK/HTOk4AAAAAAAAAAAAkN1QKZyN/B979wEdVdX1YXynV3rvXZqgUqSJVAEBFRRQQRTs2CugYm+AioooItJEQEUBAUFRVDoKAipIL9J7S0jPzLf28Zt5JyHJhJDkJJPnt9asZO69c8+5N0MS/WfvM3v2bFMlfOWVV0rx4sXlyy+/lCFDhrj3b9q0SR5++GHzuVbenjp1Sp599lnp0aOHu2XzyJEjTbWuhssaArds2VLefvtts77vxIkTZcuWLfLoo4+ac+vxL774ogwdOlSaNm1qWlZPmzZNypYtK4cPH5a2bduaVtOFChXyOnZGrrvuOjP2unXrzHw0UM5oLA15n3/+eVm4cKHZHx8fL5dddpk5Tq/t448/NsGuXp+/v7/079/fVEFndE5vYwIAAAAAAAAAAAD5lb/tCSBzNmzYYKpeO3XqJAEBAdKxY0cTEntWwQ4fPtzs//nnn80avsOGDZNZs2a5q3Y///xz+eabb0zrad2vLaKDg4NNuOqpSZMm8tRTT5lx9PUaQuvrtFJZH3r80qVL5ejRo+720t7GzkjFihXNR1fls7exxo0bZ9poL1iwQBYtWmRC7cWLF6c4559//mnCYZ1P3759vZ7T234AAAAAAAAAAIB8y+ng4Ux1DwoYQuF8QgPWYsWKmYpd1blzZ1ONq2vyuiQmJpowdPPmzeb59ddfL5999pn4+fmZ5xp43njjjVK7dm3zPDw83LRt7t27t9fxNVBu3bq1nDlzxrSU1gBXK2nnz58vSUlJXsfOSFhYmPmoFb+ZGevrr782LbRdYbLeEw2kPem+unXrmvFDQ0O9ntPbfgAAAAAAAAAAACC/on10PqBhqVavaovkf/75x2yLiIgwYadW/Xbr1s1s06pWrfDVls2lSpUyIeedd94ptWrVMvv37t0rvXr1ytIcNCTVtYa1vbSnSy65xKzn623sjJw+fdp81JbY3sbav3+/ae1crVq1FPtq1Khh1jJ20RbQFzJ/b/vLlCnj9ToAAAAAAAAAAACAvIhQOB/46aef5OzZs3L8+HGzxq9LyZIl5ffff5fdu3ebkFSDUW0preHv8uXLTWVwnz59ZM6cOVKlShUpXLiwxMXFZWkOISEhcsstt8g999yT5n4NTTMaOyNaYayuuOIKr2M5HA6zZvG5c+dSbI+NjU3xXFtfX8j8ve0HAAAAAAAAAAAA8ivaR+eT1tFacasBq37uekyZMkX8/f3lq6++MmGptj2Ojo6WypUrm3V0x48fLzExMbJt2zZznnr16smaNWtSnFurbnWt4tT0vJ4uvfTSFK2qlavVsrZX9jZ2enTNYb2OZs2amdd6G0s1bNhQfvvttxT7Uz9PLaNz6r3zth8AAAAAAAAAAADIr6gUzuOOHDkiq1atkiFDhpy3T9fNbdOmjanQffzxx+XNN9806/MOGDDAfNTt2pLZtQ7xww8/bNYPHjlypLRv396ce8SIEaY6tnr16inOXaRIEUlOTjZVyroGsbaG1srfp59+2qxLrFXLn3zyiQlyP/zwQ69ju2zatMkEzhq0Hj161Kw7vG/fPrOmr4u3sR555BG5++67pUKFCtKkSROz7q+2fa5fv36699HbOb3tBwAAAAAAAAAAAPIrP6eWaiLPWrBggUycOFE+/fRTKVq06Hn7NTB+66235JlnnjHr3+qxf/31l2kTrc81PK1UqVKKUHbSpElmbV5tP929e3fp0qWL2afbtRX1K6+8YkJbPe/69etl4MCB0rlzZ9m8ebOp6tX1dwsVKiStWrWSfv36mXbOWlWb0diLFi2Sjz/+2D2PwMBAM/7ll19u1jl2rSfsktFYasWKFSZI1mrkq666ylyPHquvGTdunKmA9my1nZlzett/of49ES02HD2XaGXc8KCULbtzU0ign5Vxa5YqZGXc09ExYkuY2Hl/7Yiy8zVWNQvbGft4gp1mHmXPbBdbjhXzvg59TogIsnOv7b2rC6aQ6CNWxv0jtrCVcYNSdX3JTf8cs/M7UL1SkVbGvbS4vd+BzibbGftMfLKVcdcdihJbOtcoZmXcyRsOiS0Rln6/v/vKjJcfAgAAAJA1jl1ruXWp+FdvIgUJoTDynZ07d0pkZKRZx9hFA+hy5crJq6++KnkFoXDuIRTOPYTCuYdQOPcQChcMhMK5h1A49xAK5x5C4dxDKAwAAADkDELh8xW0UJj20ch3JkyYYCqYn3zySVM9vWzZMrNW8pdffml7agAAAAAAAAAAAECeQyiMfOf555+XyZMny4wZM0z76GrVqplAuE6dOranBgAAAAAAAAAAAOQ5hMLId8LCwmTQoEG2pwEAAAAAAAAAAADkC4TCAAAAAAAAAAAAgC9zOmzPAJb5254AAAAAAAAAAAAAACDnEAoDAAAAAAAAAAAAgA8jFAYAAAAAAAAAAAAAH0YoDAAAAAAAAAAAAAA+jFAYAAAAAAAAAAAAAHxYoO0JAAAAAAAAAAAAAMhBTge3t4AjFAZySEKy08q9rVsy1Mq4+6MSxZZK4VKgRMQetzZ2ckQJK+MWCbHz70ltPp1kZdxkR7KVcWMjaogtlQLs3OsECbYybnSivV/ES0btsTLu3tDKYkvlZDs/pwL8/KyMeybe3s/lCoVDrIwbFmSnCVKyf5CVcf8b3M73kcpBsVbGPRRp572ljp6z8zOqa61SYkup8AAr4+49GW1l3MrFI62MCwAAAAC5hfbRAAAAAAAAAAAAAODDCIUBAAAAAAAAAAAAwIcRCgMAAAAAAAAAAACAD2NNYQAAAAAAAAAAAMCXOZJtzwCWUSkMAAAAAAAAAAAAAD6MUBgAAAAAAAAAAAAAfBihMAAAAAAAAAAAAAD4sCyHwvv27ZMuXbrIX3/9lenXrFq1SmzznMO4ceNk8ODBuTLue++9J8OGDTOfz50719y7P/7447zjli9fbvbFxsZKXuI5/5y+bzrWiy++aD7//vvvzf3wfHTv3l369u0ro0aNkujo6Hzx9QcAAAAAAAAAAABsCczqCxMSEmT37t2ZDi+XLl0qgwYNkk2bNoktqefQq1cviY+Pz5Wxjx07JocPHzafnz17Vvbv3y9vv/22TJs2Tfz9/5fNa8ip99XhcEhe4jn/nL5vOtbx48fN51FRUeZ+fPvttxIUFGS2JSUlyebNm2XEiBGybds2+fjjj/P81x8AAAAAAAAAAADId6HwhYqJiRGn05lbw2VqDiVKlLA2l9DQUGnVqpXMnDlTbr75ZslPbNy3atWqSUhIiPt57dq1zR8kvPTSS3LkyBEpU6ZMvvr6AwAAAAAAAAAA5BZnHitGRD4OhT/66CNTdVmkSBFZtGiRJCYmSvv27eW+++4zbZJff/11SU5ONu1/tTVwixYtZOPGjfLJJ5/Iv//+K+XLl5c+ffpIu3btzPk++OADE+JpVe2WLVukf//+cvDgwXTHCAwMNNW1M2bMkJUrV5pjdVujRo3koYcekn/++ee8OWjr6507d8rIkSPNmPp80qRJsmfPHilevLiZT+fOnb1en7exCxUqlOY9u/vuu6Vfv35y7bXXSuHChdO9txnNK737pJXcpUqVkjlz5phKZH3NVVddJe+++645rkaNGvL0009L2bJlzXkuZP7adtl13zSY1XuzZs0aM06dOnXMdenX0yWjr7P69ddfZerUqXLixAmzXb9GmVG0aFHz0VXtm5NffwAAAAAAAAAAAKDArSmcmrb71UDt77//lqFDh8qtt94qY8eONe2RGzRoIPfcc48EBATIhx9+KA0bNjTB5G233Sb16tUzYV2nTp3M67Ry1tVCePLkyVKuXDkZMmSIOUdGY6gxY8bIhAkTTJj35ptvmvPr+TQ4TWsOer5Dhw6Z1y5ZssSsU1u1alV5+eWXTTip43722Wder8/b2BlVC997770yevTodI/xNq/07tOUKVNMyKnhp1YkP/fcc3LHHXdI8+bNzdrA2pL5hRdecI9zIfP3vG+vvfaaCf01YNb7ovPRa3Lx9nX+5ZdfTGirgbVe39GjR82ay96cPHlSJk6cKLVq1ZKKFSvm+NcfAAAAAAAAAAAAyK+ytX10WFiYWec1ODhYLr/8clm1apUsX77chJGlS5c2x2iFqho1apR069ZN7r//fvP80ksvNVWn77zzjvTu3dtdCfrggw+Kn59fpsbQNWI1CNQqT6VVq7pPA9Dw8PDz5uDp/fffl65du8qjjz5qnmtoeO7cORPYagB8MWNnRCtRv/rqK7M27iWXXJKleaV1n7TVsoawWi2rc9F1dzt27Cg9evQw+zUAfeutt9zHZ3X+f/75pwmdGzdubJ5r1a1W6WqbZp2Pt6+zzuuGG26QgQMHuq9vw4YN541z/fXXu69Pq7S1ZfQVV1xh1mV2rcmck19/13rGAAAAAAAAAAAAQIEOhatUqWICUxdttayVn2nRlsJKW/m6xMXFyalTp9yvqVy5coqg09sY2pr49OnTpr2ztgDetWuXLFu2TOrXr5/hvJOSkkx7YW297Klly5Ym1HQFozkxttLK2eHDh5sq16zMK637pBWvGggr/aghcfXq1d37NeDWttMuWZ2/hrBaWbtixQpp3bq1XH311dKsWTP3fDL6Omuwq/u1stdFX9e0aVN3Ba9naKvB7IEDB0x1slYca6itlb8Xew2Zuc9pBfYAAAAAAAAAAABAgQuFNXjMLK3CvOuuu0wVaXprxWpweSFjLFiwQJ599llTCapBoFbzakiolaUZ0apWrTZNfW7Xc92fU2MrbYFcrVo1+eGHH7I0r7TuU1qVrZ4BanbN/5ZbbjHr9moQq1W52spaq4Z1DWGtzs3o66xrFesav55Bu4qIiDjvWL0/et06P20b3bNnT9MaWwPii72GzN5nAAAAAAAAAACAfMmRbHsG8KVQOCNpVfxqm+G0Wvlmla4jqy2Jdf1clx9//DHdOXgGqBUqVDAtnLWFsMvWrVtNla1WoF7s2N488sgjcuedd5rK2+ycV2ZdzPy1ilYfujbw5s2bTYvqlStXmnbV3r7OlSpVkh07dqTYplW+GdE1hHWeuuZv3bp1pV+/fta//gAAAAAAAAAAAEBe9d9irLlAqy4dDodpHawfNfycP3++LF261OzXak5dZ1aDUd2fFfo6bYmslZ36+Oabb0xb44SEhDTn4EmDxenTp8umTZvMcw0yx4wZI9dee62paL3Ysb0pXLiwaaM8adKkbJ1XZmVl/voaXZt42rRp7m3Hjh1zh73K29dZ1+v94osvTACrdJ3mX375xet8NXhu0aKFae/sauFt8+sPAAAAAAAAAAAASEGvFG7YsKGUK1dO2rVrJ48++qjcfPPNZn1YrZCNjIw0bX612vSNN94wrXyz4qWXXjJVoq5QsWbNmmadWA0ltU1x6jl40uMOHz5sQkpdK/js2bOmanTYsGHZMnZm9OrVywSk2TmvzMrK/PXr9MADD8gLL7xgAtTQ0FATympb59q1a5tjtHI3o6/zgAEDTJCsx2kwrsGtrkucmZbNOufrr7/etJAePXq01a8/AAAAAAAAAAAAkFf5ObO4YKpWX+7bt8+01tU1bY8fP262ebbaTb1NPz9y5IiUKFHCrDfruU2rMV1rCbteq1WlGuKld760tiUlJZnKUR1DA8bY2FhT9altjLUVsOccdF98fHyK82kVqYaUnnPMjrFPnTplgsmyZcuawPHkyZNStWrV8+6rhqYnTpyQ6tWrp2h3nNG8MnOfdu/eLaVKlTLBrIqOjjbn07V6XTI7f52f533Tt5Bu0znqfr3Pab1f0vo6u2iYrPdEz6n3QI/Xc0VFRZk5pb4fLjo/HVevQ/fn1Nc/K7YfjRIbykXm2t96pLA/yvv62TmlWmTarcFzWkiEnSryxGN7xZbkiBJWxj0eZ29t7+OxSVbGTc5a04yLViQ0/fXnc1qlMDsXneCfcm373HIu0dIXWURKRmW8VENO2RtaWWypnHjYyrjrE0taGTcqwc73LpvKRoZYGbdqETvfQ2x+HyniiLYy7m8n7f2MKhtp7+tsS6lwO/f7bIKd93Xl4v/9tzIAAADgq5L/+dX2FPKcgHptpSDJcigMIGOEwrmHUDj3EArn4r0mFM41hMK5h1A49xAK5x5C4dxDKJy7CIUBAAAA35K8cbHtKeQ5AZd2kIIk19YUBgAAAAAAAAAAAADkPkJhAAAAAAAAAAAAAPBhhMIAAAAAAAAAAAAA4MMIhQEAAAAAAAAAAADAhxEKAwAAAAAAAAAAAIAPC7Q9AQAAAAAAAAAAAAA5x5mczO0t4KgUBgAAAAAAAAAAAAAfRigMAAAAAAAAAAAAAD6MUBgAAAAAAAAAAAAAfBhrCgM5pHhYgJV7G5PosDJu8VA712s4k6QgcQYGWxvbz2HnXkcGB4ktpYL9rIx7ON7Ov6nyjpNii8MRaWXcYGe8lXFDE86KLclFKlgZt3SAvV89Z2wJszJu31L7rYzrjAgVW06Gl7cy7r6ziXbGjUoQW0qG2fk35fS3M27jcuFiy8FoO++vM3H21vw6GGXn52O1Yna+fyWcPCi2BBe3830TAAAAQMFCKAwAAAAAAAAAAAD4MoedgrKCbOnSpfL555/LyZMnpVGjRvLQQw9J4cKF0zw2OTlZvv76a/npp5/kzJkzUrNmTRk0aJBUqlTJ7D937pzccsst4nQ6U7zuySeflHbt2mVqPoTCAAAAAAAAAAAAAJCNgfAjjzwiQ4YMkWrVqsno0aPl3nvvlRkzZoif3/ndKd9++21ZuHChDB48WMqVKyczZ86UG2+8UebNmydly5aVHTt2mMesWbMkIOB/XSb12MwiFAYAAAAAAAAAAACAbKIhcL9+/eTWW281z+vUqSNXX321CYvbtGmT4tj4+HiZNm2ajBw5Urp06WK2XXbZZfLHH3/Il19+KY8++qhs27ZNKlasKHXr1s3ynPwv8poAAAAAAAAAAAAAACISFRUlGzdulJYtW7rvR9GiRaV+/fqyYsWK8+6RVg5r62jPNtD+/v5SunRpOXz4sHm+fft2qVGjxkXdXyqFAQAAAAAAAAAAACAbHDhwwKz9m7q1sz7ft2/feccHBwfLJZdckmLb0aNH5a+//pJu3bq5Q2ENinUN4b1790qVKlXkvvvuk1q1amV6XoTCAAAAAAAAAAAAAAqUDh06ZLh/8eLF522Li4uTXr16pfsarfiNjo42n4eGhqbYFxISIidPnvQ6L4fDIS+88IJUqlTJrCvsCoULFSok/fv3l8jISPnmm2/MPl17WFtTZwahMAAAAAAAAAAAAODLHMm2Z+ATgoODZdSoURnuDwoKMp8nJ6e85/o8dVCcmlYYv/TSS7JlyxazzrCeT02aNMlUGmsgrJo0aSI7d+6UsWPHyvvvv5+puRMKW7R69WpT+t2nTx/TS9zTkiVL5Ny5c9K1a1ev59H+4/qXBdddd12W5rFr1y756aef0twXHh4ut912W6bOk5CQ4H5z2nIhc1i1apUcP348y/cNAAAAAAAAAAAA+dPiNCqBvdEWzqlbPaemawGrU6dOmWpfF83yXPvSqxB+8cUXTX74+eefS4UKFdz70moT3bBhQ1mzZk3m557pI5Ht3njjDZPgz5o167x9ixYtMqXfmX3TfvXVV1mex7Zt2+Sdd96RI0eOyNmzZ1M8dDHszNC/Rrj++uvFpgudg5b4x8TE5OicAAAAAAAAAAAAUHCUK1dOSpUqJf/880+KwHfz5s0myE2LVhEPHjxY/v77b5kxY4ZUrFjRve/QoUPSvXt3s8+Tri3sGRx7Q6WwJZs2bZKtW7fK7bffbgLdO++8U2y7//77zZs0K7SXub75bLrQObRr1y5H5wMAAAAAAAAAAICCp1evXjJhwgSTRZUpU0bGjRsniYmJ0q1btzSPHzJkiGzcuNFkhoULFz4vZA4MDJT33ntPPvjgA9Pld8GCBbJ06VKZPHlypudEKGzJ7NmzpV69etK7d2/57LPP5LfffpNmzZql2x5a3yg1a9aUX3/91XyxO3bseN6bQlsh67G6gPVVV10lVapUSVGSvm7dOjl48KB54zRq1CjTC097/pXCsmXLZM+ePeYvD1q1amXmokGstp/WPueffPKJdOrUSapWrWr+6mH58uXm+BIlSkjbtm0lIiIiU9ek46iwsDATnjdu3NjMN71zpjeH9Oacun20zicpKUlq165tWnfr51dffXWKsn4AAAAAAAAAAADAmwceeMBkVx06dDDZly59+uGHH0qhQoXM/qlTp8rXX38t3377rWkXPW/ePClZsqT07ds3xXk013rmmWdMGDx06FCT/2kupsupvvbaa9K8eXPJLEJhCzQMnT9/vlmrV/uO16hRwyT/6YXC2h5ae4JrsKshqAacb731lkn/NcRUu3fvln79+kmLFi1k//798uabb8r48ePNcw0/H3zwQWndurWULVvWhKwvv/yyjBgxQnr06JGpOWvQPHDgQNNuWd9gOicdQwNYPz8/iY2NNYGstpzWQPXo0aNyzz33SHx8vJmDvpn1+E8//dSEu96u6ccffzRhbrFixczz4sWLm0d659RFu1PPIaM5axj9888/m4W6NRR2zUdfo/dJ76ceq/PRxboBAAAAAAAAAADyK6cj2fYUCpTg4GAZNWqUycE0p9Jq34CAAPf+rl27ugPdunXrmswrLa4QWYsYp02bJmfOnDGP8uXLmyLQC0EobMEvv/xiFpfu3Lmzea5VrVpCrm8MDT7Ta438xRdfyOWXX26Cz4ceekheeeUV8wZQp0+flunTp0vlypXNcw2IZ86cacLTw4cPy6uvvpqiJH3AgAHy/fffpwiFddFqVyWvy6233mrecLr2sdK/WHC9yV544QUZNmyYmZcGq3pdTz31lNn3xBNPmHnOmTNHQkNDTYWvzlnL3/UcmbmmEydOmPWWNRjOzDlTz0FD5ozmnJoGwRrWa4WxjqPXrn3bCYUBAAAAAAAAAABwoVxFj6lpN1x9qCJFiphHZlzIsakRClugQWe1atWkVq1a5nmXLl1M6KphZ3prC2twqg+llbnadlrXANa/BlBacewKhJVW427bts183rNnT/f2Y8eOya5du0y1beq/INAqWW237EmDV6WVu7qo9cSJE937tDR9w4YN5i8cUtNwVkNcDW+Vv7+/9O/f34TR2sI6M9ek7a9dgXBmz+npQuesXxMNhF3z0QplDYoBAAAAAAAAAACA/IxQOJdp9au2Rdb1hLWNsYsGnV9++WW6obCWgXvSvuJazaoVxyp1ha8GptpCWR05ckSGDx9u1srVkFfDzqioKPfaui4ayJYqVSrN8TV01cBUWzN7zuHuu++WuLi4FMfqcw1dS5cunWK767lrzt6uyfUXEhdyzqzOWRUtWjTFcy3j1/kAAAAAAAAAAAAA+RmhcC6bO3euqcbVlsSeYeXVV18tixYtkt9++y3NtYVTh57Hjx83wa9ncJqexx57zITBGjrr+sX6Oq24dVXkZoaGxRpk67m80YBbA1adoyetUlau6t8LuabMnHPfvn1ZnjMAAAAAAAAAAADgq/xtT6CgmT17trRq1cqsg6tr37oeb775pqnc1eA2LWvXrk3RIlnPc+WVV7oXmM7I5s2bpWPHjqZdtYauR48elZUrV57XKjojV111lRlTW0y7/P333zJp0iQTOGsras+qWtfxrmpl9dVXX5lQ2lUhfKHX5O2c6c0hvTkDAAAAAAAAAAAUCJqL8JAU96CAoVI4F23atEm2bt0qDzzwwHn7IiMj5YYbbpCvv/5aTp48ed7+sLAwuf322836w1u2bDFB75QpUzI17rXXXivjx483lbkahi5YsMC0XU5ddZuRxx9/3FQx33TTTdKpUyfz2u+//95ciwbNunavBrKvvvqqGW/w4MFyyy23SJ8+faR169YmjP3nn39StMy+0Gvyds7Uc/A2ZwAAAAAAAAAAAKAgIBTORbqO73333ScdOnRIc//AgQNNOHz48GFp06aNOd5F1wEeNmyYLF26VNq3by9vv/22ew1crTzW/Z5atmwp1atXN5+//vrr0rZtW9m+fbtZU3fatGmSkJAgc+bMMR/1uHvuuee8NYY9FS9e3LS+/uGHH2TPnj1yySWXyIABA9zj1qlTR8aNGycbNmyQoKAgKVOmjMyfP9+EsPv37zfB76hRo1Ks25vRNWk77dTtpb2dM/UcvM1Z71HNmjXTvYdpbQMAAAAAAAAAAADyGz+nZ79d5EmvvPKKCXSnTp0qvsIXrym1E1ExVsZNdhS8f9JFAv7XUjw3hUQWsTJuwqnDYoszKMzKuLESJLaESaKVcQ/HB1gZt7zj/G4VucUREmlnYD873SP8485aGVc5QgtbGTcxIERsmb3lhJVx+5ZK+UduucUZGCq2nAz/b6mQ3LbvrJ3v15Eh9jrQlAyz8ze+kc44K+MmB6X/R6w57WC0nffXmbjML/mT3aIT7PyOXa2Yne9fZcXez+Xg4na+bwIAAKBgSfxtju0p5DlBzXpIQUIPXQAAAAAAAAAAAADwYbSPzgd8sY2xL14TAAAAAAAAAAAAkBcRCucD6a1BnJ/54jUBAAAAAAAAAADkRU6HveVpkDfQPhoAAAAAAAAAAAAAfBihMAAAAAAAAAAAAAD4MEJhAAAAAAAAAAAAAPBhhMIAAAAAAAAAAAAA4MMCbU8AAAAAAAAAAAAAQA5yJHN7CzgqhQEAAAAAAAAAAADAhxEKAwAAAAAAAAAAAIAPo300kEMi/RKt3NvAkzutjOsILya2xESWtTJuiJVRRU74FbI0skh0jMPKuOFBTrElMCTYzrj+du61/5FdYsu5yldKQRJSqLS1sYO2LrUy7u6yzcWWrrWKWxn3jNgZN8LfXkuo4qf3WhnXUbiylXGL+cWLPZZ+VsScsjKus7Ct375EKkba+U/nSpvmii3+dVtaGdcv5oidcaNPii3RoXb+WyoyPMzKuAAAAADsoFIYAAAAAAAAAAAAAHwYoTAAAAAAAAAAAAAA+DDaRwMAAAAAAAAAAAC+zGFnCSLkHVQKAwAAAAAAAAAAAIAPIxQGAAAAAAAAAAAAAB9GKAwAAAAAAAAAAAAAPoxQuICJjY2Vw4cPi9PpvKB9ecWZM2fk5MmTmTr27NmzGR4bFRWV6XMBAAAAAAAAAAAA+RWhcAGzaNEiadOmjQlEL2RfXjFy5Eh5+umnM3Xse++9J0888US6+ydPniwvvfRSNs4OAAAAAAAAAAAg73EmJ/NITnkPCppA2xMAbHn44Ye5+QAAAAAAAAAAAPB5VArDK4fDYdosp24rre2ZtZ2zio6OlnPnzrn36bGnTp3KsBX16dOnJTExMc19SUlJ5pxKz+utzXNG53K1xtZHeu2jPa9Fx9PnAAAAAAAAAAAAgC+gUhgZ0hbLY8eONcFwcnKy3HTTTfLkk09KaGioac984sQJE+CuWbPGhLjdunWTG264QV544QUTCoeFhcm7774rzZo1M+fTkPjTTz81D32dPnr06CHPPvushISEmHHeeecdmTp1qgQGBkqlSpWkfv36smPHDvnqq69SzM3buZSGu4MGDZLff/9d4uPjzdyef/55M//Ro0fLli1bzFh6LUeOHDHHrF+/3gTDTZo0MdtLlizJuwQAAAAAAAAAAAD5FpXCBdTRo0fl8OHDKR6pq2O///57+eijj2T8+PEm9F2wYIH5+Pbbb6c4pl27diZ0nTBhgsydO1deffVVmT59ujm2efPmMmLECPfxGuB+/PHHMmbMGPnjjz9k1qxZsnz5cnn55ZfN/ilTpsjXX38tM2bMkHXr1plAd/bs2Wleg7dzqU2bNknDhg3NXBYuXCirVq2SUaNGpXm+n376Sdq2bWvOtXjxYtmzZ49MnDjxou81AAAAAAAAAAAAYBOhcAE1cOBA6dOnT4rHBx98cF7oqpW/pUuXNqGx0uO+/PJLUzWstJK3V69e5vMWLVpIUFCQeV62bFlT6dumTRvZvXu3+5waFvft21eaNm1qnteoUcOs7TtnzhzTznnatGnSv39/Ux2sunTpYkLntHg7l6patarcf//94u/vb+Z67733mopjrUhOrXz58nLbbbeZzytUqCBXX321bN68ORvuNgAAAAAAAAAAAGAP7aMLqO+++04KFy6cYtu3334rgwcPdj/ftWuX7Nu3z1TNeipWrJgcO3bMfK6BsScNhUuVKuV+rsGwtnVW2pr54MGDUqdOnRSvqVevngmZtUW0jnfJJZek2F+3bl1ZtmxZim3ezqXnUbVr1xY/Pz/3/lq1apm1hV0ht6dy5cqleK4tpl1zBwAAAAAAAAAAyLcc/xX7oeAiFEa6AgICTJWtVhVndExqniGsp+DgYLPWb2JiYortcXFx5mNERIQJkTXw9ZSQkHDB53KtKazrDqd1Lh0rM9cCAAAAAAAAAAAA5He0j0a6tAr3119/TbFNA1utsk2r/bI3GhZrFbCuP+xJn0dGRppWz1rZu379+hT7Uz/PzLm0VbRrTWHPYFj3a2voIkWKXPD8AQAAAAAAAAAAgPyISmGk69FHHzXr+44YMUJuvPFGOX78uFl3WCtqp06dmqU799hjj5nq4+rVq5u1gv/++2/56KOPzDat/n3ggQfk8ccfN4GvrhU8b948Wbt2rVx22WUXfC6lAfZLL70kd9xxh2zYsEEmTZokr776Kl91AAAAAAAAAAAAFBiEwgVMeHi4lClTRvz9/b3ua9KkiUycOFE+/fRTE7TqGsStWrWSQYMGmf36XNcX9qRrDOt5PNflLVu2rPv5VVddJR9++KE574wZM8w6vi+//LJcd911Zn/Hjh3l9ddfN6GzPvT4m266Sfbu3Wv2a4WvqwW0t3Pp/Hr37m3mo3MuVKjQeftd80/rWtLaBgAAAAAAAAAAAOQ3fs7Ui64CFp04ccKsB6wtoF20eljD4DfffDNffW3io89YGTfw2E4r4zrC7QXoMZH/+8OD3FQkIszKuIdOnxNbohMuvHV8dggPsrfaQZEQO2Ofibdzr8seWiO2RFW+UgqSkEB77+ugrUutjLujbHOxpVS4nb+F9LMyqkiEf7KlkUUCTu+3Mu7xyMpWxi3mFy/W+Nn5PuJ/7oSVcZML2/mdz+a99vttltjiX7ellXH9EmPsjBt9UmyJrdzEyriR4Xb+ewYAAAB2xP80iVufSkjHgVKQUCmMPOW1116Tf//9V1588UUpWrSoLFu2TJYuXSpTpkyxPTUAAAAAAAAAAAAgXyIURp6iYbCuW/zCCy9ITEyMVKtWTSZMmCCNGze2PTUAAAAAAAAAAAAgXyIURp6i1cHPP/+87WkAAAAAAAAAAAAAPsPeYnYAAAAAAAAAAAAAgBxHpTAAAAAAAAAAAADgw5wOh+0pwDIqhQEAAAAAAAAAAADAhxEKAwAAAAAAAAAAAIAPIxQGAAAAAAAAAAAAAB9GKAwAAAAAAAAAAAAAPoxQGAAAAAAAAAAAAAB8WKDtCQC+aluUnXHr+QdYGXdzcnGxpaLDKQVJWKCftbEDLb2/ohOSxZbgmFNWxnX6F7UybmK1ZmJLQoLDyrgB/nb+TfknxFgZ14wdUdjKuAnJ9r5fJxawnxWn4+2NHRlZ2cq4yXa+hYgzNMzOwCJyKt7ORScHl7Ey7pETiWJLjWLBVsYNbnaT2HIy3s7vX5GF7Pzt+p6AimJLeUs/H//ac8LKuC2rlrAyLgAAQIHnsPf/WJE3UCkMAAAAAAAAAAAAAD6MUBgAAAAAAAAAAAAAfBihMAAAAAAAAAAAAAD4MEJhAAAAAAAAAAAAAPBhgbYnAAAAAAAAAAAAACAHOZK5vQUclcIAAAAAAAAAAAAA4MMIhQEAAAAAAAAAAADAh+W5UHjSpEkyYMAAGTt2bJr7lyxZYvZ/8sknuT63o0ePmnEfe+wxefjhh+Xdd9+VgwcPiq974403ZPr06Vl67TfffCN33323xMfHp7l/8eLFctddd0lcXJzX98U777yTpTkAAAAAAAAAAAAABVmeC4V37NghW7dulcmTJ0tSUtJ5+7/44guzf9u2bbk6r59++km6du0q27dvl2uuuUa6desm+/btk86dO5ug2pf9/fffsnv37iy9tm7durJs2TL5+eef09yvX+egoCAJDQ31+r74559/sjQHAAAAAAAAAAAAoCDLc6Gwqlq1qhQtWlRWrVqVYntUVJTs2rVLateunavz0UD0qaeeMtXBb731lgmEu3TpIqNGjZIbbrhBnn76aYmOjs7VOeUX9erVkzp16sjcuXPP27d//35Zs2aN3HTTTVbmBgAAAAAAAAAAABQEgZJHdejQQRYuXCitW7d2b1u0aJF5rlWjqW3atEm+/PJL0+JZQ+V+/fpJpUqVzD6HwyHffvutrF+/Xg4fPiwRERFy1VVXyY033ih+fn4ycuRIE16eOXNGVqxYIcHBwdKjRw9p27atef1nn30mJUqUkP79+5837oMPPmjGS0hIcG/TitaZM2ea1tIVK1Y0c6levbrZN3z4cKlVq5Zs3rzZzPXOO+8016XB6alTp0wQXrJkSbntttvMNlf7Zh2jb9++7jF0W40aNeTmm282gfTnn38uGzdulMjISGnQoIH07t3bXIdnta/O6ciRI1KhQgW59dZbzTwyc35P3u5lWten+zRMP336tAn7XebMmSPFihVz32cNiadNm2ZCeL3fGhY3atQozVbSJ0+elCeffDLFNj3/448/bu5FYmKi+frrXHVevXr1MucaP368qTTXr8d9990nRYoUcZ9Dx9ev9b///ivly5c341966aVpvDsBAAAAAAAAAADyD6fDYXsKsCxPVgq7QmFdb1bDPZcFCxaY7an99ttvJkQtXry4Cf+cTqep4NVgUr388svy8ccfS+PGjU0YWrZsWXn22Wdl3rx57hD3lVdekXXr1pkwWINLDQz1udKgtlmzZuLvf/7tKleunFkzV8dWes4+ffqYsFTnEhsba0JRDVFd4fVLL71kjm/RooV5vY6vIezSpUvN+NpO+ZZbbjFBbnrtm3Xbnj17zOcajq5evdq8VkNzDVZ1DJdff/3VBL6uOYWEhJg57ty5M1Pn9+TtXqZ1fdddd53ZpyG/i36NNBTWr5Ner94frcDWYFfDWA2Lb7/9dpk/f36mWknrti1btpjPtZpcw19tNa7n16/noEGDTKgfFhZm5vPjjz/Kiy++6H793r17pWfPnibc10C9dOnSZnxtGw4AAAAAAAAAAADkZ3m2UviKK66QgIAAWblypbRp08ZUhmrI27RpUxk3blyKY19//XVTkartnVXHjh1N9axWp06cONGEgBoKaoCp2rVrZ86rweL1119vtpUqVcocr8Fvp06dTFtjDQ61uvT48eNmvzdaRauVsgMGDDDtppWuP3z27FlTjTxjxgyzTdtfP/DAAyleq4Gthq0akGpraq3C/eCDD+STTz7JcEwNV5cvXy4jRoww1610zocOHXIf884775gweMiQIe456TVqQHqhMnMv07o+rQbWFtIaJCu9v7oms6t1tN77Vq1ayZtvvumeo34tNCy/9tprL3ieGu6OGTPGrFWsQflXX31lguz777/f7Nf3x3vvvec+XluBa8WzK0zXe6mV1q+99pr7vgIAAAAAAAAAAAD5UZ4NhTUQ1MDx+++/N6HwDz/8YELDwMCUU9ZwT9sBa4vgP/74w71dQ1Vtx6yaNGkiMTExsnbtWtMaePv27WZ/cnKy+/i6deumqATWFs76GhUeHm4qfr3RyloNkHXentq3by/Dhg1zj+dqJe1JX6OBsIsGlBrmeqPXrSGyVuu62mtfffXV7rbLen+2bdsmjz322Hmhe1Zk5l6mdX1aLa1BsQbB2tZ59uzZps21tprW127YsMFUIae+b/oHAGlVLHujc9BAWGlltAbgrnbcSttse64Dre8d/TproO+i7cQ1XNc/SHBVggMAAAAAAAAAAAD5TZ4NhZVWaA4ePNi0dtbW0doiOjVX8Kutk7VCNS2zZs0y1cTakljDX10nVtes9aSBYOqwVatwlQaXrlbLqWmgqevQ6lxdra41cPSkz/W4pKSkNPcrz7VtXZXDnusUp+aam6vKVlsz//zzz6bi9YUXXpC77rrLVCvHx8enO2ZGPM9/ofcyrbE0qNbjtM20Bq8a9uvXVum90SrrtO6b8mwhntn5ahCcmmfontb7SMP11IG+ykpFNQAAAAAAAAAAAJBX5OlQuGXLliZI/fbbb80at1oFm5quWathn7aa1uNT06pWDUkfeughd+tgV7iZXvCZmrYv1mBaq0Z1PE9LliwxLaO1MlfDYw2TtbLVM6DW9Xo1EE0rqHTZv39/iudahVulShXzuV5b6mDUFYYrrXDW9Xj1oeHq1KlTTdtlXRtXz6GBt55f10VOi7fzZ8e91ApvbS+t4XXlypXNPLt37272aZtmbUeduiJY75vezzJlynidr1bzXgytXtZzpvUeAgAAAAAAAAAAyNcc/+v4ioLpf/2S8yANUbWNsq6Xq4Fm6mpeV9io69zq2sGudXQ1cNSKWQ1rNcjUsM+zmlXX9tUAMjMVqKpnz55yySWXyCOPPJJird4tW7aYNWg7d+4sl112mZmfBsja8ljXEVYHDhyQzz//XG644YYMx9D22NqKWekYM2fONC2XVdWqVWX9+vXu+WoQ7QpQNbwdOHCgbNy40R0QaxWvBuWFChUy2/T+aFAcFRVlnmsF8tChQ+W7777zen5PF3sv9Xq0lfWnn35q1gx2zU/p2sLTp08390vp/Rs7dqxpHa7X40nnqy3Dtb2z0vv222+/eR3f29y0pbWujewybdo0eeKJJ8z7CQAAAAAAAAAAAMiv8nSlsOrQoYNZK1fbM6dHA87HH39cunbtaqp1dd1aDS7ff/99szawtlLW8Pbrr7+W06dPm5BRq44zu1atVqZq6Kzn0BbDNWrUMBXM+noNM3V8F107WMNjnbeGl9p2WgPQ1Gv6prUG7p133mmqYrVCVsPlO+64w+zT0FcfnTp1MmvbartlXV9Z6bU0bdpU+vfvLzVr1jQVu7t27ZIXX3zRvQ7uk08+KQ8//LC5hzr3vXv3Sv369U3g6u38ni72XurXRtcR1qrvIUOGpNh37733mnul1c56nFZKa2tqrXhOK6TXAFe/FloJres4t23b1r0GdFZoS+sdO3bIzTffbP4A4MSJEyYMHjlyZIq1pgEAAAAAAAAAAID8xs+Z2R7KuUSDQQ33NDxU+vmGDRukYcOG7jVmtZpTK2E1PPSkYfDhw4dNsKnhpyetvtVH+fLlTati/VyPv/LKK835tCrZ8zVpbVNanaqhqqpWrVq6a/VqsKvBooaWpUqVcm/Xil6tKNYQ2DOQ1JbKzzzzjKl6LV26tJmjJ63u1Tlpq+U6deqY4FerpDV4dlXW6pgaZGqoqWsSpzcnvQf6yOz5NcTV69Tr9XYv07o+Txoe6/HNmzc3raFT033a6lrPqy2dPd8XOkddx1jpdWqltlYo16tXT44ePWoqoV1z1/eNhsouWkmsc3J9LTRI1hBY5+FJz6OBtFYx6/tL/yAgq/4+9F8lc26rl5C5P3bIbpuC/nsv2lCxUPrrReek4oXO716QG05HZ/0PIC5WoqXC+egEe61NKoidf8tH/YtaGbdkWNa/712sswl23mAB/uf/PMoNkc44sSXo6DYr424M/+/nuA2lI/L830Jmqxhb37D1vR1k5w/qbF1yiVB7f0B4Kt7ORSc77Pwn5JFzSWJLjWLBVsYNDrD3/joTb+f3r8hgO9e850yC2FI+0s5/z2w9EWtl3JZV/9d9DAAAALkndu5obncqYdc/IgVJnguFCyJXKKzrFsN3EArnHkLh3EMonHsIhXMPoXDuIRTOPYTCuYdQOPcQCucuQuHcQygMAACA3EAofL6CFgoXrJIJAAAAAAAAAAAAoKBx2OvGiLyBUDgPGDx4sGlVDQAAAAAAAAAAAADZjVA4D9A1cQEAAAAAAAAAAAAgJ/jnyFkBAAAAAAAAAAAAAHkCoTAAAAAAAAAAAAAA+DBCYQAAAAAAAAAAAADwYawpDAAAAAAAAAAAAPgwZ3Ky7SnAMiqFAQAAAAAAAAAAAMCHEQoDAAAAAAAAAAAAgA+jfTSQQ4qFBFi5tyfCa1oZt0qgvb8xcTqdUpCEx520NrYztJCVcYs6z4gtUaElrYxbMtDPyrj+cfbudUhwESvjxiQ6rIx7zBEstpQqU8fKuJX9gsSWVfujrIx7TeRxK+P6Oe28r1Wyfwkr4zqDI6yMey7J3vu6uH+8lXETg8OsjLvucLTYUjLczn86lw1OEFuKBdt5b8c57PxuX6uovZ/L20/b+To3KWqnfWD8OTs/k1VIhJ3/ngEAAADyAiqFAQAAAAAAAAAAAMCHUSkMAAAAAAAAAAAA+DKHva5iyBuoFAYAAAAAAAAAAAAAH0YoDAAAAAAAAAAAAAA+jFAYAAAAAAAAAAAAAHwYoTAAAAAAAAAAAAAA+DBCYQAAAAAAAAAAAADwYYG2JwA7tm7dah7XX399jpz/r7/+ktOnT8vVV18ttjidTvHz87M2PgAAAAAAAAAAQJ7gSLY9A1hGpXABtWTJEnnxxRdz7Pzz5s2T8ePHiy379u2TW2+91dr4AAAAAAAAAAAAQF5BKAyftGnTJlOtDAAAAAAAAAAAABR0tI9GhjZu3Cj//vuvlC9fXho0aCCBgf+9ZdatWyexsbHSqlUr97G6LT4+Xlq0aHHeeQ4ePCirV6+WRo0aSdWqVd3bN2/eLLt375YSJUpI48aN3ef3DHf37Nlj9jdp0sTsP3bsmCxbtkyuueYaKVSokPvYP//8U86ePSu1atWS33//3bSPnjVrljRv3tzMP6PrUSdOnJANGzZIQECA1K5dW8qVK8e7AwAAAAAAAAAAAPkeoTDSlJCQIA8//LAJZTXI3blzpwQFBcmHH34oFSpUkG+++UYOHz6cIhTWbcePHz8vFD5w4ID0799f6tWrJ9ddd53ZpuHto48+Ktu2bTPn37Jlizn/uHHjpFKlShITE2PG19BY9+/atUuSk5Nl8uTJUrhwYXnllVdMKN2vXz/3OMOGDZMuXbpIqVKlZPv27SYU1nBYA96SJUtmeD2LFy+WwYMHS9OmTc32FStWyIABA+SRRx7hHQIAAAAAAAAAAIB8jVAYaZowYYKp7v3hhx8kIiJCHA6HPPXUU/LCCy+YfZnlGQi/++67JnBVI0aMMPu+++47KVq0qAmh77nnHhPMzpgxw4TDGuzOnz9fihcvbgLeMWPGmErea6+9Vjp06CDffvutOxTWY/Xx0UcfmVBZt//xxx8yfPhws3/s2LEZXo/uv+uuu+SBBx4wx+tr9fw6rp+fH+8SAAAAAAAAAACQbzkdybanAMsIhZEmDURr1KhhQlQXbeG8cOFC0yI6M7RqWAPhyMjIFIGw0vNqAKuBsAoODjahrAbDR44ckUWLFknPnj1NIKw0mNVKX5cePXrI3XffbVpPV6tWTebNm2cqgDUQzsr1FCtWTObMmWOqhlu3bm1aWesDAAAAAAAAAAAAyO/8bU8AedP+/fvl5MmTpv2y6xEVFSU33HCDREdHZ+oc2vJZA+EdO3aYNtAucXFx5lyudX5dNJB1hclHjx7NcE3fli1bmjbRGuQqrTjWoDir1/PWW2/J5ZdfLi+//LI5d69eveTnn3/O1HUCAAAAAAAAAAAAeRmVwkiTVs7qesEPPfRQmvu1cldbK3vSsNdTzZo1zTrDeo7nnntOZs2aZaqFQ0NDzbrAp0+fTnH8qVOnzEfdp2sA67rD6QkICDDrEy9YsEDatm1rQmRdTzir16NGjhwpSUlJpkX1zJkzTSWzzr9+/frpvgYAAAAAAAAAAADI66gURpquvPJK05JZ1/p10VbNWpmr6/FqcHv48GH3vsTERBOmetLWzxoC67q9+/btM+sEuzRt2tRU93rS8bRaWFtAa+vm1JW669evl5UrV7qfa5Xv3r17TZjbrl07MyeXwMDAFKF1RtejQbB+1OvR1zVp0kSeeeYZ83ptZQ0AAAAAAAAAAADkZ1QKF2Aahmr1bmq6pu5TTz1lWij369dPunfvLidOnJCvv/7aBLH+/v7SrVs3mTJligwdOlQaNGgg8+fPN4FqWjTo1Qrd9957Tzp37iy1atWSIUOGSJ8+fcw6wlrp+/fff8uPP/4oY8aMMa959NFHzZrCusawBr4azk6fPl3efPNN93nr1KkjtWvXlnXr1snYsWNTjFm6dGkTXut2b9ejbaeXLVsmn3zyiTlGK5m1AlkrnbW6GAAAAAAAAAAAID9zOhy2pwDLCIULqEsuucQEu7q2bmqXXXaZ1KhRw1TWzp4926wJXKhQIXn77bfNertKWyp/8cUXptpX1w7W0Ferhffs2WP2N2zY0Kz56zJgwAA5dOiQGU9D4SpVqpggWUPpbdu2mec6XsWKFc3xZcqUMc+1fbOuR6ztpKdNm2bm7enaa681raM1+PWk42uArNXFumbwpZdemuH1jBgxQn744Qf5888/TRtsPa+G0iEhITlw9wEAAAAAAAAAAIDc4+dMvTAskI889thjUr58eRk8eLDkNftPRlsZNzjAz8q4IYH2utHb+jZWNDLcyrgJx/eLLc7QQlbG9Y89I7ZEhZa0Mm54oJ1/y/5x9u51bHARK+PGJNr5K8lkh71fwUoFJVkZN9YvWGxZtT/KyrjXRB63Mq6f095f/yZHlLAyrjM4wsq455xBYkuEM87KuImBYVbG/XmPvZ9Rl5WJtDJu2WA736+VM8DOezvOYed3oFBL/x2ltp/+3zJHual2WLyVcZ1Bdr6HqJAIO/89AwAAkBdET3vF9hTynMh+L0hBQqUw8qWffvrJtJxetWqVzJ071/Z0AAAAAAAAAAAAgDzLXmkfcBHOnTsnUVFRMnnyZNNqGgAAAAAAAAAAAEDaqBRGvnTDDTeYBwAAAAAAAAAAAICMEQoDAAAAAAAAAAAAPsyZ7LA9BVhG+2gAAAAAAAAAAAAA8GGEwgAAAAAAAAAAAADgwwiFAQAAAAAAAAAAAMCHEQoDAAAAAAAAAAAAgA8LtD0BAAAAAAAAAAAAADnHmezg9hZwVAoDAAAAAAAAAAAAgA+jUhjIIaUD4qzc2+XHnFbGbV34nBQ4kVWtDOsfHyW2nAwqZmXc4vv/EVsialxpZdzY5FAr44YFhYktJ2KTrIxbIdTOX0kejg8QW44l2vkVsGion9hSJNTONcct+cbKuIGlKlgZ14xdv6WVcRPCilsZd9Mhe78DtUyw8/PxWOkrrIzbuZKdn40q2tLfU59MDhJbHHZ+LEuREEs/K5z2qiZ2n4q1Mm6FyMJWxi1ydIvY8kNCRSvjdq5d2sq4AAAAgCcqhQEAAAAAAAAAAADAhxEKAwAAAAAAAAAAAIAPIxQGAAAAAAAAAAAAAB/GmsIAAAAAAAAAAACAD3M6HLanAMuoFAYAAAAAAAAAAAAAH0YoDAAAAAAAAAAAAAA+jFAYAAAAAAAAAAAAAHwYoTCyxYwZM6R27dopHg0aNJAuXbrIpEmTxOl0muOee+45ueuuuzJ1zuTkZJk+fXqm55CT5wYAAAAAAAAAAADyq0DbE4Bv2bRpkwQG/ve2SkhIkEWLFsnTTz8tYWFhcsstt1zQuRYvXiyvvfaa9O3bN9vnmZPnBgAAAAAAAAAAyEucyQ7bU4BlVAojxwQHB0v37t2lSZMmsmDBggt+vcORc9+gcvLcAAAAAAAAAAAAQF5CKIwcl5iYKJGRkedtj4mJMdW61157rVx22WXSuHFjueeee+TQoUPyyy+/yKOPPmraPGsr6p9++sm8ZuHChXLdddeZ1tSdO3eWCRMmmGPSkt6xaZ37+PHj8uCDD8qVV14pzZs3lwEDBsiff/6Z4/cGAAAAAAAAAAAAyGmEwsgxp06dks8++0zWr18vPXr0OG//yJEj5Y8//pBPPvlE1qxZI5MnT5bNmzfLmDFjpF27dvL+++9LQECAbN26VTp27CirVq2SZ555Rh5++GH57bffzOt1LeOxY8eed+6Mjk3r3C+++KJ5/sMPP5iQ+JJLLjGvda2FDAAAAAAAAAAAAORXhMLIVvXr1zfVt/rQ8HX27NmmGrhTp07nHfvSSy+Z/ZUqVTKtprWit3Xr1nL06NE0z61hsa5LrOcKDw831cWPPPKIqQBOHd5eyLFq3759EhQUZI7VquZnn31Wli5dKn5+ftl4dwAAAAAAAAAAAIDcF2hhTPiwTZs2SWBg5t9W//zzjwlf9+zZI7t27TLPmzVrluax27Ztk7Vr18qkSZPO26ctp7N6rHryySflscceM62jdXwNp6+//nopVKhQpq8FAAAAAAAAAAAAyIsIhWGNto0ePXq0WVNYK4xvvPFG+eqrr0zb6bToGsDDhg2T/v37ez23t2P/+uuvFM/btGkjy5YtMwH18uXLzby0nfWXX34pxYsXz+IVAgAAAAAAAAAA2OdMdtieAiyjfTSs0VbO999/v7z11lsyYMAAufLKK2X//v3u/albN9esWdOsFZwZ3o5Nqy20to3u2rWrvPHGGzJ37lzZu3evqTYGAAAAAAAAAAAA8jNCYVhTpEgR2bhxo5w+fVpOnjwpI0eOlPXr10tsbKzZr+v7asXv4cOHJTo6WgYNGiSLFy82FbxRUVGye/dueeCBB0ybZ4cj5V+4eDvW89xnz56VDh06mLWPtUo5Li5OFi1aZNYYrlu3rqW7AwAAAAAAAAAAAGQPQmFYoxXCx44dM62be/XqJTExMTJkyBDZsmWLJCQkSOPGjU31cMeOHeW7776Tdu3ayYgRI+Trr7+WFi1aSN++fU24qxXH/v4p38rejvU898KFC+Xjjz82wXGnTp2kadOmMmfOHBk7dqxUqlTJ2v0BAAAAAAAAAAAAsoOf0+l0ZsuZAKSQcOa4lTuy/Jidf9KtC5+TgiaodFUr4yYd2Cy2nIysbGXc4ruWiS3JNa60Mm6sf6iVccMkUWw5EGfnb9UqhNpZT+VwfIDYEnD+Kgq5omiovWv+62iMlXEbrvjQyriBpSpYGdeMXb+llXETilezMu4fh+z9DtQy4R8r4x4qfYWVcUsFJYkt0RJsZdyEZHv/ue6wNHSREDu/DwSKvfXVFu2JsjLuVZUKWxm3yPEtYstPCRWtjNu5dmkr4wIAAHg6NXYoNySVYoOGS0ESaHsCAAAAAAAAAAAAAHKOIzmZ21vA0T4aAAAAAAAAAAAAAHwYoTAAAAAAAAAAAAAA+DBCYQAAAAAAAAAAAADwYYTCAAAAAAAAAAAAAODDAm1PAAAAAAAAAAAAAEDOcToc3N4CjkphAAAAAAAAAAAAAPBhhMIAAAAAAAAAAAAA4MMIhQEAAAAAAAAAAADAhxEKAwAAAAAAAAAAAIAPC7Q9AcBXxQZGWBm3TdJaK+M6k8uKLcfDy1sZ19YVJxetaGlkkUIBAVbGTarTxsq4KirRaWdgh51hk/2C7AwsIuUi7fytmtNp52tcNFSssXXNu04niC2VC4dYGTe8eRcpaJL3b7UyblCwnd+9WoScE1uSi9e2Mm6gn5+Vcf1jT4stiSGlrIxb6Lt3xJbQeldaGdcRc9bKuOKw9MuXiHRu1M3KuJM3HrMy7t1l7fw3hWpTyc7PisNn7PysKFvEzvUCAAAgbyIUBgAAAAAAAAAAAHyYM9neH0Iib6B9NAAAAAAAAAAAAAD4MEJhAAAAAAAAAAAAAPBhhMIAAAAAAAAAAAAA4MMIhQEAAAAAAAAAAADAhwXangAAAAAAAAAAAACAnONMdnB7CzgqhQEAAAAAAAAAAADAhxEKI0fNmTNHnnrqKTlw4MB5+2bOnCmffvqp+7hPPvkkV78a3377rYwdOzZXxwQAAAAAAAAAAAByG6EwcozT6ZTRo0fLqlWr5Kuvvjpv/4YNG8w+9ddff8nKlStz9atRo0YNadiwYa6OCQAAAAAAAAAAAOQ2QmHkmNWrV8vhw4elb9++8s0330hSUlKeutuXXnqptGrVyvY0AAAAAAAAAAAAgBwVmLOnR0E2e/ZsadSokfTs2VM++OAD+eWXX+Saa67J8DVr166VRYsWiZ+fn9x4441Su3Ztd6vpM2fOyN133+0+VrdFRUXJnXfeadpPJyYmSrVq1eS7774Tf39/6dGjh3m9Vilv2bLFVAZrQB0SEuJuH33w4EEZNGiQ+/VVqlQx4+vn7du3lzZt2uTwXQIAAAAAAAAAAAByFpXCyBHnzp2TH3/8UTp27Cjly5c3bZq/+OKLDF+zceNGef7556VChQoSGxsrffr0kRUrVpzXatpFt/3222/u9tO6PvBbb71lguCjR49Kv379ZODAgbJnzx6pWbOmTJgwQV5++eUU47laVuvrNbh+4403pGrVqiaUvvfee+X777/PgbsDAAAAAAAAAACQe5wOBw9HyntQ0FApjByxcOFCiYmJkU6dOpnnnTt3lrffflv2798vFStWTPM1Wp07efJkKVOmjHvbiBEjZO7cuZka89SpU6b6t1ChQtK9e3dp3LixqRweNmyY2R8UFGSC4/Ro1bFWDBcvXtw8P3TokMybN0+6dOlyQdcOAAAAAAAAAAAA5CVUCiPHWkc3aNDAVAm7QmGHw2FaPqenSZMmKQLhDh06yNatW01YmxnaHloDYRUZGSnh4eFy2WWXufcXLVrUtKBOj1YIuwJhpXPP7NgAAAAAAAAAAABAXkWlMLLdvn375I8//jAh61NPPeXermv5fvPNN/Lwww9LYOD5bz0NbT0VKVLEfEwvyHU6nSmeh4WFnXdMcHBwpuetQbInbSGdegwAAAAAAAAAAAAgvyEURrabNWuWCX3vu+8+8ff/XzF62bJlZfz48fLzzz+720p70nWAPWmraW35XK5cOQkICJDk5OQU+8+ePctXDwAAAAAAAAAAAPCCUBjZSitrdV3fa665Rnr27JliX0JCgmkr/eWXX6YZCq9bt062bNkiderUkbi4OJkyZYp069bNBMLaylnD5NjYWFMRrOv9/vbbb9KoUSO+ggAAAAAAAAAAABlwJDu4PwUcoTCy1erVq+XAgQPy+uuvp9nKuVevXjJu3DjTYjqtNYG1uvjSSy814bC2cx48eLDZpwHzF198IT169JBatWrJP//8I1dccQVfPQAAAAAAAAAAAMALQmFkq2LFisnbb78tzZs3T3P/HXfcIdWrVxeHwyG9e/c2lb9Kw97u3bubdYjXrl0rt912mzRt2tS99nCZMmXk+++/N9XBiYmJJnTWdtMnT550vz4qKirFWHpMgwYN3M8vv/xyefPNN93Pb7jhBmnbtm26r09rGwAAAAAAAAAAAJDfEAojW2nrZ32kp3jx4iaMVVWqVHFvb9iwofvztFpLq9DQUGnTpo37eZEiRdJ8vUvXrl1TPK9QoYJ5uGhFckavT2sbAAAAAAAAAAAAkN/4254AAAAAAAAAAAAAACDnUCkMAAAAAAAAAAAA+DBnssP2FAqcY8eOybfffmuWQm3UqJF07Ngx3WN16dThw4eL0+k8b6lTV2fbCzlfWqgUBgAAAAAAAAAAAIBssmvXLunevbts2rTJLI/64osvmkd6du/eLZ9//rlUrlxZqlev7n4UKlQoS+dLC5XCAAAAAAAAAAAAAJBN3n77bWnVqpWMGjXKPO/UqZP07NlTbrnlFqlbt+55x2/fvl1KlSolAwYMyJbzpYVKYQAAAAAAAAAAAADIBgkJCbJs2TK59tpr3dvq1Kkjl1xyifz4449pvmbbtm1So0aNbDtfWqgUBgAAAAAAAAAAAIBssHfvXhPkVqlSJcV2fb5jx440X6OVwmXKlJGvvvpK/v33X6latapcd911plV0Vs6XFkJhAAAAAAAAAAAAAAVKhw4dMty/ePHi87ZpODt8+PB0XzN06FA5e/as+TwiIiLFPn1+5MiRdEPh48ePS4kSJcw6wlOmTJFPP/1UvvjiiyydLy2EwgAAAAAAAAAAAIAPcyY7bE/BJ/j5+Un16tUz3J8eh8Mh/v5pr+w7cOBAueKKK9zrA+vzbt26yejRo03F8IWeLy2EwgAAAAAAAAAAAAAKlMVpVAJ7ExQUJLfddluGxxQrVsx8jIqKSrFdnxcpUiTN1/Tt2zfF87CwMGndurX8+eefcvvtt1/w+dKS+fgYAAAAAAAAAAAAAJCuSpUqSXh4uOzatSvF9p07d0rt2rXPO/7o0aPyyiuvyMGDB1NsP3funBQuXPiCz5ceKoWBHHIyNsnKvU2q0NjKuOk3RMh58QkFq+1F4LGd1sbeEpJ+W4ycFBls72+YygXEWBn3QFKYlXErOk+JLaedJa2MGxZo5ztYxKmUv8TlKj87/6bqRJYSaxJT/iVlbpkfX1kKmpJlalgZt1pQqJVxIyPsva9D4s9YGbdE/FEr4yYVKSe2BCXa+X1z41UPiS3bT9j5HahOpZRrZOWWM/F2/vtNXWXp5/LAOnbu9a744mJLBb8AK+NGxSdaGbf4qm/EluAWN1kbGwAAwLbAwEC55pprzHrA+lGri5ctWyb79u2Ta6+99rzjixcvLgsXLpTg4GCzJrHas2ePqWR+5plnLvh86c4rW68SAAAAAAAAAAAAAAqwJ598Uvr16yc33XSTWYN4yZIlMnjwYFP1q3755RdZsWKFDBs2zIS+b731ljz++OOyefNmKVmypDleA+BevXpl6nyZQSgMAAAAAAAAAAAA+DCno2B13LStTJkyMm/ePFm6dKlpA/3www9LjRo1UlQHV6tWzf38qquukh9//FHWrFkjp0+flrvuukvq1auX6fNlBqEwAAAAAAAAAAAAAGSjsLAw6dy5c5r7LrvsMvPwVLRoUVMdnJXzZYa9RRoBAAAAAAAAAAAAADmOUBgAAAAAAAAAAAAAfBihMAAAAAAAAAAAAAD4MNYU9nF79+6V/fv3p7vfz89PWrRokW3j7dy5UxISEqRu3bpy4MAB+ffff1OMVaxYMalVq5YEBAS4t+/evdssin3ppZemeL3n9qzYtWuXxMXFpViI29PFnh8AAAAAAAAAAADIDwiFfdzatWtl7ty57uerV6+WKlWqSLly5cxzDWczCoWPHz8ur7zyiowePTpT402cOFEOHz4sEyZMkO+++07ee+89ufLKK82+pKQkE1AnJyeb7Y0bNzbbV61aZcJrDWc9X++5PSs+//xzEwxPnjw5zf0Xe34AAAAAAAAAAID8wJnssD0FWEYo7ONuvPFG83DRqtlbb71VBgwYkOlQ+aeffsry+CEhISlCWafTKY8//rg8+eST8vPPP4u/v7/07ds3zdemtz275PT5AQAAAAAAAAAAgLyANYVhnDhxQtatW5ei3fPJkydl27ZtJshduXKlee5y5MgRc/xff/1lWjRnlraQ7tatmxw6dEhOnTrlbuO8cePG84713K5tpfWhr/nzzz/lzJkz5vnmzZtTvEa3bdmyJcU2rVDWbfrQa0nr/FpRrK/VKuZNmzaZMRITE3l3AAAAAAAAAAAAIN+jUriAi4+Pl5deekm+//57qVmzpuzZs0fq1Kkj77//vuzbt09+/PFHE6R+8skn8sgjj5gw9qGHHjKvK1OmjDleQ+Fx48ZJkyZNMjXm0aNHpVq1alK8eHHzfPr06SawnTp1aorjPLdPmTLFBLgaTBcqVEh69+4tW7dudbeadtH209ryWufjGqtnz56mTbYG2TqutsIuWbJkivNrq+nt27eb4yMiIuTgwYPuKmd9DQAAAAAAAAAAAJBfUSlcwI0aNUqWL18u8+bNk5kzZ8rixYvl3LlzMnToULnsssvkwQcfNC2eNRxt1KiRCY/btGljWkpPmzZNfvnlF6lUqZJ89tlnaZ5fK2+1ylgfOo6+RkPYDz/80FQNXwgNgTX01blqC+zM0OrfQYMGyZw5c0zAHRsbK8OHD0/z2N9//12GDRsms2bNMq2tQ0NDZdKkSRc0RwAAAAAAAAAAACCvoVK4gJs7d67ccccdUrFiRfO8cOHC8sADD5gw2LNdtIsGrJ4SEhKkXLlyEhMTk+b5tXWzVhkrh8Nh2lRrdfFzzz1nAt7w8PBMz1XnWL16dfN5UFBQpl5Tv3596dq1q/k8MjJSBg4cKM8880yawXDVqlWldevW5nOdV7NmzWTv3r2Znh8AAAAAAAAAAEBe5Ex22J4CLCMULsC07bMGv1WqVEmx3dUuWdf9Tes1Wu27ZMkSE+5GRUWZNssavqbF1YLZk7723nvvla+++koGDBiQ6flqu+oLlfratKpZg+q0rq1UqVIpngcGBppKZwAAAAAAAAAAACA/IxQuwLQ9slbERkdHp9h+9uxZd2Vtas8++6ysX7/erC+sQbAGyNpyWdfxzSxtP12hQgXZsWPHBc1X21h7Sqv9tFYue9K1jz1piK1c6xl7Ox8AAAAAAAAAAACQ37GmcAGn6wbrusCedD3dkiVLmqragICA8/b1799fevbsKZdccok4nU5Zt26daQ2dWRpCHzt2zLRrvhgaaGs7ahedy6ZNm1IcowG2ZzCs11q7dm2JiIi4qLEBAAAAAAAAAACA/IJK4QJu8ODBcuutt5oK4Hbt2snff/9t2j2/+eabpjK3WLFipoXyrFmzTICsD237XLZsWRMEf/7553L69GmzFnFa9LUrV650P9djtf10iRIlpE+fPhc192uuuUamTJki7777rjRs2FC+/fZbd5WzZ7trXSNZr3HDhg0yc+ZMGT9+/EWNCwAAAAAAAAAAAOQnhMIFTIsWLaR8+fLu5/Xq1ZNvvvnGBLUa9pYrV858riGratKkiTz22GOycOFCExC/9957MnHiRJk7d66pJr7zzjulaNGiMm7cONO6uWbNmu7WzNoiulGjRvLJJ5+42zNrhW7btm3l5ptvdgfJ2oLaVZHs+XrP7TVq1DivnXXTpk1l7NixZi7airp9+/bSqVMn2b59u9lfvXp1GTRokJn3119/bcabOnWqXHHFFeedX48NDg5Ocf60tgEAAAAAAAAAAAD5jZ9Te+4CyHa7j/+3fnFuKxySsuV3brG5InNUQubbl2enKiXOX3c7NyTv2SC2bAmpbmXcyGB7qx2UC4ixMu6BpDAr41Z0nhJbToeUtDJuWKCd72ChJ3eJNX52/k05IkuJNYlxVob9/mjB+xvMkuFBVsatVjS0wP2MCok/Y2Vcv4RYK+MmFSkntsQk2vl9c/tJO9+7zNgn7PwOVKeknaV+zsQniS1XVQi3Mq5/op1/y//Gh4gtFQrZ+Rl1ICrRyrhVdi4SW4Jb3GRtbAAAkLY9Q+7g1qRSdcQUKUhYUxgAAAAAAAAAAAAAfBihMAAAAAAAAAAAAAD4MEJhAAAAAAAAAAAAAPBhhMIAAAAAAAAAAAAA4MMCbU8AAAAAAAAAAAAAQM5xJju4vQUclcIAAAAAAAAAAAAA4MMIhQEAAAAAAAAAAADAhxEKAwAAAAAAAAAAAIAPIxQGAAAAAAAAAAAAAB8WaHsCAAAAAAAAAAAAAHKOMzmZ21vAEQoDOSQ4wE4hfkiAn5VxA8UhtoSHB0hBstJRydrYW/edsjJuy8rFxJbTgRFWxi0XbmVYkXNS4CQkO62MGyr2OMKKWBnXGRgituyICbYybqdqQVbGPZdk532tgi39LnI23t7vIrYkhNj5txy6Z4OVcQOCw8SWQpbGbRwWZ2lkkTqXlC5Q/x11PDZJbDmdaGfcZIedf1ORdn4kG0HRR62MWy6ylJVxHZd3FVv+OXzWyrj1yha2Mi4AAEB+QPtoAAAAAAAAAAAAAPBhhMIAAAAAAAAAAAAA4MMIhQEAAAAAAAAAAADAhxEKAwAAAAAAAAAAAIAPC7Q9AQAAAAAAAAAAAAA5x+lwcHsLOCqFAQAAAAAAAAAAAMCHEQoDAAAAAAAAAAAAgA8r0KHw6dOnpU2bNnLnnXeety82NlZatWolq1evzpax9FxLly696PO88sor5lzpPW6++WbxFe+//7489NBDtqcBAAAAAAAAAAAA5GsFek3h+fPnS+HChWXlypWyZcsWqVOnjnufw+GQ48ePS0JCQraMNWfOHClSpMhFn+fxxx+XQYMGmc+PHTsmPXv2lDfffFNat25ttgUEBIivuOuuuyQpKcn2NAAAAAAAAAAAAIB8rUCHwrNmzTKVwsHBwfLFF1/ISy+9lGNjlSpVKlvOU6hQIfNQycnJ5qMG29l1/rwkMjLS9hQAAAAAAAAAAADyPWeyw/YUYFmBDYW3b98umzZtkmeffdZU8H788ccyePBgCQ8PT/P4bdu2yaeffio7duyQkydPSunSpU2r5ptuusmEs1dffbU8//zzMnv2bHNsmTJl5MEHH3RX8GprZ63o1Y/ejtXqZJ3Pjz/+KImJidKgQQN57LHHpEKFCpm6trfeekuioqJMe2ytgL7nnnukR48eMmHCBFmxYoUcPHhQAgMDpVGjRvL0009L8eLFZdSoURITE2OC2EWLFpkK3fbt28sTTzxhQvPo6Ghz3jVr1phq5Nq1a5uK5Ro1apgxdZ7ezh8XFyfFihUzVdP+/v7m/ukYw4cPN/PUcw0bNkyqVKnibh+tX6cxY8Z4nZ+38b3NX/3222/mvv/7779Svnx56d27t9xwww0X/V4DAAAAAAAAAAAAbPIvyFXCJUuWNMFhly5dTGj43XffpXms7uvfv7+UKFFC3n33XZk0aZLUr19fnnvuOdm1a5c4nU7TalrX+9WQWMPjqlWrmvVwz549a87hakWdmWP1vEuWLJEXX3xRPvzwQxOk9urVy4TRmaGB8JdffmmubfTo0dK8eXMzbw2htf301KlTZejQofLzzz/LBx984L5GrZbWuem2p556yjyfPHmy2a9V1Pv37zdBre7XYNXVxlpl5vwzZsww5x8/frz06dPHhOR33323uQ8axuoxntXa+vzMmTOZmp+38b3N/88//zTheceOHc05BwwYYELkKVOmXND7CgAAAAAAAAAAAMhrCmSlsFb2zps3zwSAWrFaqVIlqVevnglStTo0tZCQELP+sIbCerzSyt3p06ebqtTKlSubbX379pVOnTqZz7XqWENKDRtdFcCe0ju2bNmyMnfuXPnhhx9MWKy0mnnVqlVmPA2PM0PbSWuw6XLvvfeaauSIiAjzXCth27Zta4JSF21LrUF0UFCQqaDVitzff//dvHbr1q1yxRVXSK1atcyxr732mqlE1pDbz88vU+fXNtcaeOs9vP32203o2rVrV+nQoYPZr8G3Vg2nJ6P5eRvf2/w1LNZwul+/fma/fk1PnTolI0eOlDvuuCNT9xwAAAAAAAAAAADIiwpkKLx06VI5duyYdO7c2b1NP9dq082bN0vdunVTHK8hpFYVa3vhf/75R/bs2WNaTyuH43892KtXr54iAFXx8fFpziG9Y/X8yhVOumgVsbaazqyKFSumeF60aFE5dOiQLFy40MxfK5z1ei6//HL3MRqE6rV6zuvIkSPmc62ifeaZZ0wFs4bc2gJbQ1cNVDN7fg3fXaG6Vupq2O5qFa1CQ0NNi+n0ZDQ/b+N7m79+PTds2GCCZhdtUa33XcfQFt8AAAAAAAAAAABAflQgQ2GtylVPPvmkO6TU1s5KWxK//PLLKY6PjY2VO++8U/bu3WvWBNb1aLXK96677kpxnK5tm1npHauhqAaf2t7aNbesnF8DVk8zZ84019W0aVPT+rp79+4mmNV1ejNz/uuvv14aN24sP/30k1m3V++dVt1qe2Wt4M3M+T0DXZfU15iRjObnbXxv89dAXttJ33jjjeedW9ckBgAAAAAAAAAAAPKrAhcKa8tgXWtWA92BAwem2KetibVN9JAhQ1JsX7x4saki/fXXX90Vo9qOWGn74eykFcSJiYmmOrVhw4bZdt733nvPtJPWtXhdtF12YGDm3wIVKlQwrZT1sXv3brMW8+rVq+Waa67JlvNfjMyMn9H8q1WrZiqxte02AAAAAAAAAACAL3Em/6/zLQqmzJdp+ggNfXVNYW3PrAGg56N///4SHR0t3333XYrXaIWrtok+cOCAea4fX3jhhRQVxtlFq1k1DNaqVw2GNXTeuHGjXHvttfLNN99k+bwajmp7ZW2JrKHz5MmTTSCaXntrT3rtPXr0kI8//tjcO6VttrXK19UG+2LOnx0yGj8z89c/ENDW0/q113seFRVl/kjg1ltvTdEiHAAAAAAAAAAAAMhvClworG2ZtQW0Vo2m1qJFCxMSaoWpJ60k7d27t9x+++2mPbGGx1plWqNGDfcawNlFg8rRo0eblsXt27eXK664wlQ1d+3aVXr27Jnl877++uuydu1aEzpfddVV5vP777/fVMdqkOptThqCa2jaqFEjc46RI0fKiBEjzD242PNnh4zG11DX2/y1vfQTTzwhr776qrnnzZo1k3///VeGDx9+QS2uAQAAAAAAAAAAgLzGz5nd/Y/zuOPHj0tYWJhERESkuV8rhXVd3xIlSphjixQp4l7LVsNNrQwODw83z8+ePWs+Fi5cWI4dO5biWOW5Lb3P0zrWRatc9aHnT4uGnSdOnDjvdXoNWhGr29O6Pr12Pz8/U1Gr7bQ1gNZ1k/X6ihYtmuLY1Nv0+vX+pDenCzm/zj0yMlJCQkLc16sVuiVLljxv/LTmkt62tMbX9YUzM3/953DmzBkzr4ttfX3g1DmxoUiInRA7UCxWVPvZuebQsDAr4y7bdUJs2Xo82sq4LSsXE1tKhv33/SO3FT5/GfZcEXDO3vvrdMh/3/9zW4CflWGl8JnddgbW3yHC7fybcoYUElt2nLXzK2+Nonb+MZ9LsvcrfrClf1Rn4+38LlLY0u9eytK3LwndusTKuI6ql0tB45cYZ23sc+GlrYwbHGDn39Tx2Jz/Y+a89n3TVvdAf1vfvPR3+0Q7v+vGR9hZqirQ4r3edSbRyrj1yqb9/3sAAIDI9kG9uA2p1Br7tRQkBW5NYVfgmB4NA/WhUq8vqyGhZ1DoGSymtRat57b0Ps9om4alrsA0LVrBmtbrXPNPi+c+bYvten1ar0lrm4bPngH0xZxfg/eMrtfzNZmdX3rjZ3b+GiZ7hswAAAAAAAAAAABAflfgQmEAAAAAAAAAAACgIHHYahWDPIPFUgEAAAAAAAAAAADAhxEKAwAAAAAAAAAAAIAPIxQGAAAAAAAAAAAAAB9GKAwAAAAAAAAAAAAAPizQ9gQAAAAAAAAAAAAA5Bynw8HtLeCoFAYAAAAAAAAAAAAAH0YoDAAAAAAAAAAAAAA+jFAYAAAAAAAAAAAAAHwYawoDOSQ+2U5//mSnnb/1CAgIEFuSHE4r44ZaGVUkNNDe3/OUjgyxMm5wgJ/YUtQRZWVcpzPCyrjiSLb3fTPJzvfNUsGWrtnf3q9h/jGnrIzrCAgWW2pG2rnfe6OSrIxbPMzez2Vb37FjEh0F6vcQVTbU0tj+dn4XcQaFWRn3v8Ht3Gunxe+bAf52/jWfibfzc7lUuL2fy36W3l+n4u1834xOsLeWXfGIYlKQBEQdsTb24Wg7/z3T+4l5YsumUddZGxsAACAzqBQGAAAAAAAAAAAAAB9GpTAAAAAAAAAAAADgw5yWupsi76BSGAAAAAAAAAAAAAB8GKEwAAAAAAAAAAAAAPgwQmEAAAAAAAAAAAAA8GGEwgAAAAAAAAAAAADgwwJtTwAAAAAAAAAAAABAznEmO7m9BVy+D4UdDoeMHj1aKlSoIL1795a8Ijo6WiIjI7P9+AULFsg///yT7v5ixYrJXXfdJb7gl19+kaNHj8rNN99seyoAAAAAAAAAAABAvpXv20cvX75cpk2bJq+++qqcPn1a8oJ3331XPvrooxw5PiwsTAoXLmwe/v7+Mn78eBOcurZFRESIrwgNDZXw8HDb0wAAAAAAAAAAAADytXxfKTx79mzp0KGDCYfnzJkjAwYMsD0l+f333+Xyyy/PkePbtWtnHurw4cMybtw46dSpk3Ts2FF8TYsWLWxPAQAAAAAAAAAAAMj38nUoHBUVJYsXL5Y33njDVJV+9dVX54XCsbGxsmjRItm3b5+UK1dOmjVrJhUrVnS3nh41apTcdtttJpjdu3ev1K5d24TMWoXrOua3336THTt2yMmTJ6V06dJyzTXXSMmSJSUpKUnee+896dmzpyxbtsy8JiAgQA4ePGj2ffLJJ3LvvfdmeI6ZM2eed7zavXu3aZ+s2xs0aHBBAelPP/1kPupctmzZYl6rofP+/ftlzZo1cuDAAQkKCpJGjRpJ06ZNzbF6H5OTk6VGjRry888/m3E1fK5Tp477vH/++ae5T3pe3d68eXP3fVKZOX+tWrXM18PPz0+6du1q2n7rPp1n9erV5dprrzX7UrePzsz8Mho/M/NPSEiQ77//Xv79918pX768eR8ULVo00/cdAAAAAAAAAAAAyIvydfvo+fPnm8C1TZs2JkzcuXOnrF271r0/Li7OBIqzZs0yzzUw1CDyjz/+MM/1tdp++Z577jHhrAbIr7/+ugwaNMjsczqdcv/995vW1MePHzeh5MSJE+WGG24wgbQ+19frGr5atfv333+bFs4aOgYHB5s1gr2dQ9sjex6v5s2bJzfeeKO5nrNnz8qwYcPk0UcfNefKjKVLl8pLL70kEyZMkFOnTpkgWoPU6667TtatW2eO2bRpkwnDZ8yYYZ6vWLFC3nnnHbnvvvvkzJkz8tdff5mwW7crbdGt+/Rcul/nNGTIEPeYmTm/rv38yCOPmPv866+/mmt86KGHTIX3uXPn5IUXXpARI0a4z7ly5UrzNc7M/LyN723+uk3P9/nnn5uvkZ5P3yt6HgAAAAAAAAAAACA/C8zvraO1CrZQoULSpEkTKV68uHz55Zfmc1dl6LZt22TDhg2mkli1atXKVIR60spdDXe1arRfv37SuXNnWbBggbRu3dqcSyuRtapXaXDYpUsX2bhxo6lEVe3bt5ehQ4e6zzd9+nRp2LCh9O3b14SNGZ2jW7duJoh0Ha/rImuAPHz4cDMPpaG1toj+9ttvpUePHpm6N9HR0TJ27Fhzb9TChQvN2sVt27Z1H6PnXbJkidx6663muVYs//DDD6ZKVvXv399UX+s904933nmnu5JZ56HVuxpUa2VvfHy81/NrBa6GraVKlTJhtVbqhoSEmGptpdunTJmS4l56ymh+3sb3Nv8PPvhAihUrJlOnTnVXKuvX4Pnnn3f/UQEAAAAAAAAAAEB+5Eh22J4CLMu3ofCuXbtM6Pvaa6+Z51ptq+vqanD63HPPmba/lSpVkrCwMFPJqyHgVVddZapJU9NqYlcbYQ0cr7zySlNt2717d3eIqCGmhpo6ptL2xS7169dPd55FihTJ1DlctIpZg+T169ebymMXrSLWSufMhsKVK1d2B8JKK6mVBuLaSlvbU2vVrAahLtWqVXMHrkpbNet9Vtpu+dNPPzUVvVdffbVcdtllcvfdd1/Q+bV1tAa/Srfr10bvtWc4r/coPRnNz9v43uavraq1vbhWI7scOnTIVAprwO6q4gYAAAAAAAAAAADym3wbCruqN7WNsAat6tixY6ZiVNsR69rCGiBq+2ANAzXs05bBGgZq1W7NmjXd5ypTpkyKc2vFsVbsKq08/vjjj83athpKXnrppWa7ZytnPT4jmTmHi7ah1vVwU59Tg2sNuTMr9et1veSXX35ZVq9ebQLzunXrmlDacw4aYHvSoNy1X8N3bUeta+6OGzfOHXZr4J7Z80dERKQ4v1bkajDs+TyjFtkZzc/b+N7mf+TIERPua/tvF32uj7TCewAAAAAAAAAAACC/yJehsK73O3fuXLniiitSBKXazlkrR7VVsIbCrgrRt99+24SDGiBrOPjUU0+Z4NhF1/r1pAFh1apVTdWurnOrr9E1gHXdXw12tW11Zl3oOTSgTkxMNOvtutpNZ4fHH3/crF+s7ZtdIfhjjz1m1jXODA2qdW1kfej90ns8cuRIadCggan2vdjzXyxv43ubv1YpV6lSxV3VDQAAAAAAAAAAAPiK/3om5zPLly83we2jjz5qQjzPxx133CE7d+6UtWvXmhbMWhXqqkLVKmFd3zf1msLffPONu6JUX6tBrq7nq59rNaqu+6thrvriiy/Mx4yqRwMDA01w7Tqft3N4Ht+4cWNTrarVzS6675NPPpFly5Zl+Z5pWK7ts12BqbZYXrFiRaaqYHX89957T7Zs2WKea1h90003mc9d9/Jizp8dMho/M/PXdaG1+lxbTrtou25da9j1tQEAAAAAAAAAAADyo3xZKaxVtrpmbvPmzc/bp9W42ipag9chQ4aYqmBdL1YDYa0Q1UpSrRD1pGFhv379TEvpH374QW655RZp1aqVCZ51TVrd17RpU3OcrverrYd1X3pc59FW1oMGDfJ6Ds/jX3rpJdMGefDgwbJt2zZznevWrTP7pkyZkuV7ppXH2sJ6//79kpycbNZMrl69eobX4aKhtgajGrhfc801EhoaKr/++qu0bt1aWrZsedHnzw4ZjZ+Z+T/yyCPuNZvbtWsnJ06cMCG8vodc600DAAAAAAAAAADkR05H+st3omDwc2a0iGsepeGoBqka3KZFA1Zdm1dDwLi4OBPuHThwwKxpq9Wk5cqVM8dpFamuGTtmzBgJCQkxaxNreNywYUP3uXRtYQ2SY2NjzZga7C5cuNCcS0NFXae2S5cuJrx10THnzZtnPvbt29e0ME7vHG3btj3v+ICAADl06JCpiD537pw5t87bVWnsEh0dLdOnT5dOnTqZdtcuer1nz5411cmeVq1aJdu3bzeVstoyOSYmxqyxq622NRDVKtnrrrvOfbxW2npu27x5s/z5559mnrVr1zahvFZgZ/X8kyZNMtdVq1Ytd1W1hrWudX71fBrk62tSzyWt+WU0vt47b/PX94Peuz179kihQoWkRYsWUqFCBcmqXcdzp3V2aiXC7PytR3DA/+5lbkuy9MOsUPj/1sTOTWv2nhJbDkXHWxm3XqmUa5LnpsqB56yM6wy2c83+0SmXVMhNR4JKWRm3VHCylXEDzh4WaxxJdoYt9F9HDxuc/nZ+Pu6NDbAybvEwO+OqEEu/ExyKTipwvwOVDbXzO1DAjlVWxk2u0UyssfWfzU57XYsSAu38rhudYOeai4ba+77pZ+n9dSreUaC+xqqypf+sSPSz83tISHTu/KF+WpadtXOzH/5otdiyadT//p8VAAB50d+3drU9hTynwYwFUpDky1A4u7hC4Q8//FA6duxoezrwMYTCuYdQOPcQCuceQuHcQyicewiFcw+hcO4hFM49hMK5i1A49xAK5x5C4dxDKAwAQN5DKHy+ghYK0xcXAAAAAAAAAAAAAHxYgQ6FtU3zk08+aVo6AwAAAAAAAAAAAIAvsrOoSR6h68nee++9tqcBAAAAAAAAAAAA5BhHcoFdTRb/r0BXCgMAAAAAAAAAAACAryMUBgAAAAAAAAAAAAAfRigMAAAAAAAAAAAAAD6MUBgAAAAAAAAAAAAAfBihMAAAAAAAAAAAAAD4sEDbEwAAAAAAAAAAAACQc5zJDm5vAUelMAAAAAAAAAAAAAD4MD+n0+m0PQnAF+09GW1l3PgkO/+kHWLvW0nVcDtjh0QWsTJuTGycFDSJDnvvr5OxSVbGLRdhp5lHQPQxsSU5ooQUJP4J56yNnRRS2Mq4AYkxYssZZ4iVcYsmn7Eyrn/MKbElumg1K+Pui0q0Mm5cor2/tG5YzE8Kkn1xAdbGjgiy8/fUyRZ/B4oMtnPNAf523tdBFv85jVy+18q4z9az8/3LYfF3vl3xoVbG3XTUzv8f6FazmNji9LPzj2r9YXu/Y/tbuubmVYpbGRcAkP9suKmz7SnkOZd/84MUJFQKAwAAAAAAAAAAAIAPIxQGAAAAAAAAAAAAAB9mpzclAAAAAAAAAAAAgFzhTGY12YKOSmEAAAAAAAAAAAAA8GGEwgAAAAAAAAAAAADgwwiFAQAAAAAAAAAAAMCHZXlNYYfDIcePH5fY2FgpXbq0hIWFiS/wdl26f8eOHVKhQgWJiIiQvM5zvlFRUXL27Nl0jw0ODpaqVauKLfv375eAgAApU6aM+Pvz9woAAAAAAAAAAACAlVA4JiZG3n//fZkzZ46EhIRIaGioHDlyRJo1ayZDhgyRGjVqSH6U2evSsPi6666T8ePHy9VXX+31vL///rvs2bNH+vTpIzZ4znfNmjXyyy+/mO1JSUmye/duKV++vDvcLleunDkutyUkJMgdd9wh27Ztk5IlS8q8efNMQA0AAAAAAAAAAAAgl0Ph+Ph46du3rwlNp02bJjVr1jTbT548Ka+99pr069dPFixYIMWLF5f8JCev691335XLL79c8oInn3zSPNThw4elTZs28txzz0nHjh2tzmvTpk2ybt06WbhwoVSvXt3qXAAAAAAAAAAAAHyNI9lpewqw7IJ69I4dO1YOHjxoPrqCU6Vh6fDhw6Vw4cKyevXq81535swZU5UaHR2dYrtWhmqVqIay//77r6nWddFAVoPL1LLyGm/zyOp1aWtmnc+5c+fO26bz0nbIcXFxcvr0aTNuTtwTHUPnntr27dtNu+gLpdXR+khMTJQDBw5IcnKye59u27dvnxw6dCjFa44ePWpe43q9vi41p9Np9mlrbk96b7S9tdJ7cezYMfc+1z3Qjxc7x4zm4Cm9MQEAAAAAAAAAAACfrxTWsPObb76Rm266Kc2KWW33u2jRohTbZs2aJaNGjTL79PUayHXr1k3efvtt075Y2xo//PDD8sUXX5i1ZDUo1crcxYsXyx9//CGnTp2SSy+9VCZNmmTaOWflNd7mkZXrckmrlbRrm46v1cUa/Gpoq8HphAkTsv2ezJw5U2bPni2//vqrex3ezZs3S48ePeSnn3664OrmDz/8UHbu3GnCVp2PtnW+/vrr5emnn5YtW7ZIsWLFTOBaokQJc2y9evXk448/NuG0zlX3aXitFb/jxo0zLam3bt0qjzzyiAnPg4KCTHD77LPPSteuXWX58uUmjFdDhw41877nnntkzJgxMnHiRDOenq9Lly4ybNgwiYyMzNIcM5qDKzDOaEwAAAAAAAAAAADA5yuFNdTUR4MGDVJs37t3r6ludT00HHRVgE6ZMsUEmj///LMJLd966y2zXuyGDRvcr//xxx/lu+++kyVLlki7du1Me+M6derI0qVLTaipYZ7u93Qhr/E2jwu9rguhY9atW1duvPFGEwjnxD3RMFSD5VWrVrlfr+dr3LixVKpUSbJCWzl/8MEHZnxtna0ttcuWLSsrVqyQH374wcxDA2nP9Yf1WG3Brfv0oVXKGrCq119/XVq3bm0CYF3T+NFHH5WpU6eaILZ79+7mfigNuO+991759ttvTSj+9ddfm/ukr9F1mbVqO6tzzGgOKjNjAgAAAAAAAAAAAD5dKXz27FnzMSIiIsV2rXDdtWuX+VxbG2sV6+TJk6Vo0aImaPPUpEkT89GzrXGfPn2kSJEi5vOmTZvK999/LwMHDjTPy5QpI9WqVTMBracLeY23eYSHh1/QdV2MnLgnNWrUMIH2nDlzpFWrVibk1LV577///izPs3z58u6QXO/PE088kWK/ttOuXbt2ijlXrFhRbrjhBvO5VifrXFxtobWFtgbZWt2r8+3du7d5pEeD8/bt25u20BrIK63a1a/JSy+9lKU5epuDtzEDAy9o+W0AAAAAAAAAAAAgz8h00lWyZEnz8cSJEym2jx492v35448/btobu2jb5C+//FI2bdpk1ml17XNVZ3qeV2lbXw3ztLWyi7ZQ9lwzNiuvyWgeWbmui5ET90TDWG1Jra2RtXW0rpl77bXXZnmOGrh60rHmz59vqm+1HbYG0rqtUaNG7mO0SteTzldbO6tXX33V3ENt1VyhQgXTaltbPmu4nRat0NX2zevXr0+xvWrVqu6v04XO0dscvI2pYTwAAAAAAAAAAEB+5Ex22J4C8ksorNWf2sJ45cqVph2yN1pdq8fVr1/frJOrVZsarLVo0SLFcRpwXqgLeY23eVzodXny8/M7L9DVtWqzOpesXJ/SNYlHjBhh1h3WtsraclqD5KxKPf7LL79sWjLfddddZu1lvV8jR46UY8eOuY9xrWecFr1OXV95+/btpr3z3LlzzXm0ajqtFtcaKPfv31/uvvvubJujtzlkZkwAAAAAAAAAAADAp9cUVtqSWIO1NWvWnLcvOjra3W5ZLVu2TM6cOSNjx46VHj16mLV1tTo2dYia0zIzjwu5Lk8aJGoY6mqtrTR09OQZlubUPdFgW9fL1XWGtXW0q41zdtE1iu+55x6z3m/Lli1Na+uNGzdmas4Oh8O0Y46NjZVatWrJgAEDZNKkSaaqecuWLWm+RkNzDbhTfx30PHq+C51jZuaQlTEBAAAAAAAAAACA/OCCFkrVlsTa8ljDt1tvvVXatGlj1nPdsGGDTJw40QSgL7zwgjlW123VMG38+PHmOA3f3nvvPVPhqWFcbsnMPC7kujzpOrMaQH766aem4ldDRD23Z6tnrdjVtWzXrl2bo/dEg+BHH31UihUrZlojZ6eaNWuasPmyyy4zLZl1bWVtt5x6Hea06L0bNmyYCa7vvPNOCQ0NldmzZ5v1lRs3bpzma7TNs34dnnvuOVNZre2bP/74Y9NW+5NPPrngOWZmDlkZEwAAAAAAAAAAAPC5UNhVVavtiTVU++ijj0wQquu7PvjggyaYdAWiuparrnM7c+ZMs86rhnYark2YMEH2799vWi9r1aZnsKjVnRqcetLWvq41drPyGm/zuNDr0gDXcw5vvvmmfPDBBzJ8+HATDGsbYx1PQ2X18MMPm2PeeustmT59erbfE5f27dubAFpbSes6xC6p5+sZaKe1Xa8hdWXs+++/b65RW1TruFqV3KdPHxkzZowkJCRI6dKlTRWuJ89tGq5qEK4BeFxcnGnlPGPGDBPSKr1XOhdXS+gGDRqYe6XVvK+99poUKlRIunTpYip8szpHb3PwNiYAAAAAAAAAAACQX/k5c7OXM3KMhtitWrWSL774wrSlhn17T0ZbGTc+yc4/aYfY+1ZSNdzO2CGRRayMGxMbJwVNosPe++tkbJKVcctFXPDfbWWLgOj/rRef25IjSkhB4p+Qe51TUksKKWxl3IDEGLHljDPEyrhFk89YGdc/5pTYEl20mpVx90UlWhk3LtHeUiMNi/lJQbIv7r8/IrUhIuiCVl7KNskWfweKDLZzzQH+dt7XQRb/OY1cvtfKuM/Ws/P9y2Hxd75d8aFWxt101M7/H+hWs5jY4vSz849q/WF7v2P7W7rm5lX+K3gAAMCbtV07cJNSabIg5bKivs7O/3FGtnGteaxhcJMmTQiEAQAAAAAAAAAAkILD4h+dIm+w86e/yDbaGlnbHUdFRZkW1gAAAAAAAAAAAADgiUrhfE7XxP3qq69sTwMAAAAAAAAAAABAHkWlMAAAAAAAAAAAAAD4MEJhAAAAAAAAAAAAAPBhtI8GAAAAAAAAAAAAfJgz2Wl7CrCMSmEAAAAAAAAAAAAA8GGEwgAAAAAAAAAAAADgwwiFAQAAAAAAAAAAAMCHEQoDAAAAAAAAAAAAgA8LtD0BwFeVDvWzMu6iPdFWxm1ftYhY40iQgiQgKc7a2MmBoVbGjTy6WWwJKVvXyrjnkpxWxi12ap/Y4giz830kOSDEyriBsWfEloBAO9fsZ/H7V1GxM7Z/zCk748afE1siz/xrZdzQoIpWxj2XkCy2+CUnWhnXf/c6K+OWuqSNFDR7zxas33NVSKCdv10PDLb3N/O3XVHeyrj+pzdZGdfvzBGxxVG8kZVxgwLsvL+CD/4ttmwKr21l3BLhQWJLdLzDyrgdRi+zMu7iR1pbGRcAkHWOZDs/q5B3UCkMAAAAAAAAAAAAAD6MUBgAAAAAAAAAAAAAfBihMAAAAAAAAAAAAAD4MEJhAAAAAAAAAAAAAPBhhMIAAAAAAAAAAAAA4MMCbU8AAAAAAAAAAAAAQM5xJju5vQUclcIAAAAAAAAAAAAA4MMIhVMZO3as3HjjjbJ169bzbtZHH30kr732mvl80qRJ8sILL2T5xmfnuTwtWrTIzN/1uOmmm+TWW2+Vp556SlavXu0+7tNPP822MbMiO8bfsGFDts0HAAAAAAAAAAAA8FW0j/aQmJgoU6ZMkcKFC8uXX355Xmh54MABOXz4sPn84MGDsnv37izfeM9zdenSRWJjYyU7nDhxQjZt2iRfffWV+Pv/l/knJCTIjz/+KAMHDpSPP/5Y2rRpc9Hzv1gXO/7KlSvl3nvvlY0bN2brvAAAAAAAAAAAAABfQ6Wwh19//VViYmLk9ttvl7lz52ZbUOtNuXLlpHr16tl6zvr160uDBg3Mo3HjxjJ06FCpU6eOzJgxQ3zB2bNnxeFw2J4GAAAAAAAAAAAAkOdRKexh1qxZ0rx5c+nWrZu8+eabsmDBAtN+OTOmTZsm8+bNk1dffVVq1aplts2ZM0dWrFhhqmIDAwOlUaNGcs8990h4eHiK12r7aK2afeWVV0xb5fj4eClRooRpBa3Vyx06dDBBtavyd/v27TJx4kTZs2ePlC9fXnr37m3m7U3RokXN+TzpnBcuXChRUVHSvn17ueOOO1KMM3nyZDOOzqdXr15y9dVXu6uPJ0yYIGvWrDHHa+Csry1VqpTZr9cRFxcnxYsXN+fXa9Z5duzYMdPjp3f//vnnH3n77bclOTnZtMjWwPvKK6/M8H57m+/F3FcAAAAAAAAAAIC8zJnstD0FWEal8P87efKkLFu2TK655hopVqyYCRm1hXRmfP755yZE1gDSFQiPGzdO3nnnHWnXrp08+eSTpkW0hr9jxozJsJWyfq6BqlYt33333WY+b731lrvCd8eOHdKnTx8TZj7++OMm+HzooYdMZXNG/vjjD1m7dq1pHe257bvvvpP+/fvL9ddfL6NGjZKpU6eafatWrZKePXtKZGSkPPzww3LppZeacWbOnGn2v/HGG/Lzzz+bltQ6z23btpl2zp7XpNer89L70rJlS3MfZs+enanxM7p/tWvXlptvvlkCAgLk5ZdfNgGvt/vtbb5Zva8AAAAAAAAAAABAXkel8P/T8E/bEWtVrurcubO8+OKLsmXLFhM6ZhQIDx8+XN5//333a5WGuTfccIOULVvWPNeQUUNZDR+9flECA+Xdd9+VsLAwE6auW7dOlixZIv369TPBaadOneSJJ54wx2p4rfMeOXKkCVZdNOB0OX36tBw7dsyEvHoOl0KFCsno0aMlODjYvU6vPrSC1jXOM888Y/ZpxaxW22qFrp5Hr6Vt27bSunVrs19DYw22nU6n+Pn5ucfQsLZIkSKmwvjMmTPmPunrvY2f0f3T11WqVMls1/bYmbnf3uab2fsKAAAAAAAAAAAA5DeEwv9PK1ibNm1q2h27QkZt56zVwhoOp2XTpk3y+++/m+pgzwpcpWsEnzt3TpYvX27aEe/atUt+++03U+XqTZUqVUwg7KJzOnHihPn8zz//NKGxtk120XE09D1+/Lh7m85Z2yRr4KnnqlixooSEhKQYp1q1au5AVpUsWdJcU1JSkmzcuFFuueWWFMdrsPvBBx+YMFVbSWsYrtev2/XRsGHDFMdfccUVJhB2adasmXz44Ydy+PDhDMfPyv3zdry3+Xq7rzo3AAAAAAAAAAAAID8iFBYxa9RqRbAGf56hoIaquubt4MGDU4S0Llo5+8ILL5jqWV2L1rMd8eLFi2XIkCGmHXH9+vWlXr16puJYK1O9SWssl7Nnz8qAAQNMVWtqWkHromNqyJmRoKCg87bp/LRCNq15uJ7rWr46Bw19v//+e7P2sYbFWoWr7ZpDQ0PPm4/n613rGqc3flbun7fjvc03s/cVAAAAAAAAAAAAyG8IhUVk1qxZEhERIR999JEJgl02b94szz//vFn3VitNU9OQUdsxazis7Z61ulirX9Wrr74qXbt2NdXGLqtXrzaB6sXQKmJd/9jVNjknaPVuuXLlTLWtp+3bt5t1fHWfuuyyy8xDrV+/3lQWr1ixwt1G+99//03xej1feHi4lClTxuscvN0/zxbVmTne23xz474CAAAAAAAAAAAANvwvAS2gtGp1/vz50r17dxMYaijoevTu3VsqV65sWkhn5Pbbb5eaNWvKsGHD3JWpcXFxKSp1Fy5caFoba4B8MTTI/Pbbb80auUrHGzt2rNx///3uCt/soONMmzZNdu7caZ5rC2UNzTt27GgqZ++8806ZM2eO+3htOa1cgbHSVtALFiwwn2vgOn78eFOJ7dkyOj3e7p+2wtbrdT3P6Hg9ztt8c+u+AgAAAAAAAAAA5DZHsoNHcsp7UNAU+ErhX3/9VU6dOiU333zzeTdHq1FvvfVWGTFihGkvnR6tntUK1T59+sj06dNN9fBzzz1nWksvWbLEhIolSpQw1cba5vhiQkadj66Zq62Oy5cvb9YaLl26tJmjZ5XzxRo4cKDs379fevToYcY5evSoWYdXK3J1nL59+5p1i0ePHm3aQh86dEiefvpp07bZpWrVqiZY1SpqDZXbtWsnTz31VKbG93b/Lr30UtPuu3PnzvLggw9meLzyNt/cuq8AAAAAAAAAAABAbvNzZmaRWx92+PBhEwDqOrRpiY2NlR07dpigUKtRtbJYw04NFXVf9erV3cfqcUqrhlVMTIwcPHjQhJdFixaV6Oho2b17t1nrVkPWtM6lx+s4nudNa5ueS0PbwoULm7m5aEXugQMHvLZBTuucaV2TrrWrx2rL52LFiqU4h1bbus6jFdWutYSVhuTabnrq1Kmyb98+E8TqfbiQ8TO6f7oe8blz58y59fr1Png7PqP5eruvWREXc05sWLQnysq47asWEVuCHBdXgZ9VIZF2rjk+6rTYkhx4/r+b3BBy+B+xJbFsXSvjnkuy8+O52KH1Ykti+UutjJscEGJl3ODT+8SW5EKlrYzrl2DnZ6NN/jGn7Iwbb+9eO0ILWRl3d1BFK+OeiE0UWxoV+a/7TW7z373OyrjnLmkjBc3es3Z+z1XFQgKsjBsSaOePciOD7f0x8KFoO99Hqp7eZGVcZ0Kc2LK1eCMr4+44GWNl3O4he8WWTeG1rYwbHJByubHcFB1vp9po8Oy/rYy7+JHWVsYFAGTdshatuH2ptF61QgqSAl8pXLZsWfNIj4aZaQWsnm2SXVxhsIuun+u5LTIy0n2uChUqpHmutILItLbpuTTsTK148eLm4U1a50zrmjQc1UdatF2zhqveVKpUKUvjZ3T/lK4D7XkPvB2fmfmmd18BAAAAAAAAAACA/Iq+uAAAAAAAAAAAAADgwwp8pTByxt13323aNAMAAAAAAAAAAMAup6NAryYLQmHklItdjxcAAAAAAAAAAABA9qB9NAAAAAAAAAAAAAD4MEJhAAAAAAAAAAAAAPBhhMIAAAAAAAAAAAAA4MMCbU8AAAAAAAAAAAAAQM5xJDu5vQUclcIAAAAAAAAAAAAA4MMIhQEAAAAAAAAAAADAh/k5nU7qxYEcsP9ktJX7GhjgZ2XckjEHxRZHWBEr4wYXLW1l3F3Ho8SWIiEBVsYtlHhabHEGhVsZN9Yv2Mq44YlnxZaEEEv/lhPPWRn3aHKo2FLaYefflNPS92vllxRvZ9zYM1bGPRVWVmwpZOlnReCZQ1bGFadDCprEIhWsjOvvTBZbziXb+R27SNQ+scUZGGJlXEdYUSvjOgOCxBY/R5KdcZMTrYwryQl2xhWRLXERVsatVtTO7/Y2hcScsDKuM9jOf7+ZsYPCrIwbX/B+FZEiEXbuNQDkd782aWF7CnlO27WrpCChUhgAAAAAAAAAAAAAfBihMAAAAAAAAAAAAAD4sEDbEwAAAAAAAAAAAACQc5zJBXDNAaRApTAAAAAAAAAAAAAA+DBCYQAAAAAAAAAAAADwYYTCAAAAAAAAAAAAAODDCIUBAAAAAAAAAAAAwIcF2p4Ast/69evlzz//THe/v7+/3H777RmeIzExUYKCgjI13sqVKyUmJkY6duwoW7dulVWrVrn3+fn5SXBwsFSoUEGaN29uPr8YFzKv33//XU6ePCldunS5qDEBAAAAAAAAAADyM2ey0/YUYBmVwj7o7NmzcuDAAfdj+PDh8tNPP7mfHzx4MMPX7969W2688cZMj/fdd9/JjBkzzOfr1q2TN998U/bv32/G0o9btmyR1157Tbp37y6HDx/O8nVd6LzOnDkjx48fz/J4AAAAAAAAAAAAgC+gUtgHtWnTxjxcpk2bZqp4BwwYkKnXa7Xvzp07L2oOQ4cOlcDA/729oqOjpXPnzjJmzBgTEGfFhc7rmmuuydI4AAAAAAAAAAAAgC8hFC6gnE6naa+8Z88eKVGihFx11VUSGhoq+/btkyVLlpj9kydPlvbt20vlypVN9bG2pNYqYw17r7jiCqlevXqmx4uMjJT69eub8ZSrxXRERIQJey+//HKpVavWBc9Ln69evdocX758eWnWrJk5PnX76N9++02Sk5PlkksukeXLl5s21HrucuXKueeoY/zxxx+mvXadOnXMsQAAAAAAAAAAAEB+RyhcAGlQet9995mPGqJu2rRJXn/9dfn0009NyKrb9aO2f46NjZU1a9bIoEGDpEmTJlK2bFkT4j733HMyatQo6dq1a6bGjIuLM22kO3ToYJ4vXLjQrEUcHh4uNWvWNEGuhsAXMi9dx/juu+82LaKvvPJKmTNnjrzxxhvy8ccfS7Vq1eTHH380Y2oo/MMPP5jAV1tK69rG2or6lVdekc8++8wE3PPnz5cXX3zRhM26ZrGOe/3115vrBAAAAAAAAAAAAPIzQuECSINTDVTnzZtnQlmtoH3ggQfk6aefllmzZknPnj1l2bJl7kB05syZ5nPd7nL77beb16cXCk+dOlX8/PzM56dPnzZrGmugq+Gyy9GjR+WXX34xYbB66qmnLmhe7777rgmbNdANDg4225599ll5/vnn5fPPPz9vTjt27JC5c+dKjRo1xOFwyC233GJaa2soPHHiRLn33ntNKK00kNbz6pxd1wEAAAAAAAAAAABkhmZMf//9t5w6dUouvfRSdx6Wmi7Bql1u01K0aFFT7KjnWrRokfnoqWHDhqaTbmYQChdAixcvlscee8wEryogIEDuuOMOGThwoBw6dOi843v37u3+XNtI79q1y4Sq2oI5PVrNq2GqPsLCwkxFr1YJFypUyH2Mtn/2/AdwofP6/vvvzTmmT5/u3qatn9euXWsqiVPT6mENhF3H1a1b11QMK20jrefRdtZXX321aXWtDwAAAAAAAAAAgPzOkZwyTETO0qD3nnvukSNHjpjQduPGjfLSSy9Jjx49zjs2KipKFixYkGKbFk5qbnbNNdeYUHj//v3yyCOPmKxNl3l1KVmyJKEw0qaVtVqNq22gPZUpU8Z81BbNqR07dkzeeecds6avvjG13bOGrhUrVkz3Ng8dOjTFmzIt+ka9mHlp8FyhQgXz0UUD6P79+6cZChcrVizFcw2dXX9RMXLkSFN5rK2nX331ValataqpUr7hhhsyvAYAAAAAAAAAAADA03vvvSdJSUlmOdWQkBDTJVe73bZo0cKdfblo4eLo0aNTbBszZoz8+eefZulTtX37domMjJSPPvpIsopK4QJG1+7VUvMTJ06k2K7r8irdt2/fvhT7nnjiCRPYjh8/XmrXrm3W3H3yySdNW2ib89Iq48svv9z8ZcTF0grhYcOGmYeumawtswcPHixVqlQxYwAAAAAAAAAAAADeaEHit99+K88884wJhNV1111ngmINiQcMGJDh67Vj79ixY01Bo6vAUkNhVzfcrPK/qFcjX9K/QtA3o5aeu3zzzTemOlYrb7XC17MnufY7v/baa02/cw2ENbhdtWpVitfbmFfLli1lzpw5KaqCt2zZYtYT1vbWmaXH6hrIrtBZg2+tElbZGXwDAAAAAAAAAADAt+3bt88sx3rJJZek2F6rVi3TRtqbt99+Wxo0aCDdunVzb9u2bZsJhXVZVO3s+++//17wvKgULoC0Avbmm2+Wfv36SevWrU3o+8cff5jWyUoDWA1fR4wYYXqVa3/yTz/9VM6dO2cC1Llz56ZZ1Zvb89IKZj2+V69eJrTWquL58+ebNYh1zeDM0mP1H9OkSZPk+uuvNy2of/jhB/MPToNnAAAAAAAAAAAA+JYOHTpkuF/X9E1NCxt//PHHdF+j+ZWr4LBIkSIp9hUuXNhrtqZVwj///PN5baK1Uvjw4cPuNtLr1683Yw0fPtzrcq4uhMIFwO233y716tVzP9cFrXXBau1frgtTt2rVSl5//XXTjlnVrVtXPvjgA/OGUhrC6vE7duwwx2hArG/6r7/+WhISEszr9S8eXFW2Op63UFarguvUqZNi24XOq1SpUuZYfY3+ZYSuR6zBroa56sorrzTtn1WzZs2kevXqKcbz3Pbyyy/L8uXL5a+//jLrJmvpfpcuXSQ4OPgi7z4AAAAAAAAAAIBdzgvosIr06TrBmkulp127diY7UwEBASn26XPPjrhpmT59ulSqVMmcx5NWHd92223Sp08f83znzp2maHLixIly7733Smb4Ob2NDiBL9p+MtnLnAgP8rIxbMuag2OIIS/nXNrkluGhpK+PuOh4lthQJSflDLLcUSrTXyt0ZFG5l3Fg/O3+UEp743x/52PB/7J0HlF1V9YdPeiUBQu9Neq+CUkVQKdIRkN4RAWkiRbpKF0SkN2nSBelNmtKlSe89EBJCepm8//qO687/5ubNZJLc8+5k8n1rvZWZ9ybv3HLuOfvs3977jO1R0bM8bkQl7X7Z1DNUxRwTqnmmahWN19Bp/Jhq2h01tJJ2h/SaK1TFTBXNFV2Hfl5Ju6E24y2qx/Wft5J2O9fK3b5mShjRVI2N3X/Y/7a4qYJa1//te9VoJvSauZJ2a126haroNGF8Ne02jauk3dD0PwdZFbwxuk8l7S4884wXcN5jZLnV5dpKrXs167fYdrdelbQ7ZsYzRUL/PtVcaxGR6Z0Hllql6kNod/zw9eeTfO+bb74ZK9MiHuf3AT744IOjKHzeeefV/X98tu6664Ytt9wy/OpXv5psO0cddVQsI3399de36bjcU1hEREREREREREREREREpAQWWGCBWFGXqrjFvYYXXnjhVsXkgQMHxrLQeYYOHRruvffeMHz4xMmIVLudktxfRWERERERERERERERERERkRLo1atX3OL0wQcfnEgQRvRdZ511Wvx/bHHK/y1uv0rZ6cMPPzzccccdze+NGjUqPP7443Gr1LbinsIiIiIiIiIiIiIiIiIiIiVx6KGHhp133jkKuuwHfMUVV4SNNtoorLLK/8p4v/322+H999+P72WwT/CCCy4YunadWL7t27dvOOigg8IZZ5wRhgwZEmafffZwww03hN69e4e99967zcdkprCIiIiIiIiIiIiIiIiISEmssMIK4cYbb4yiMBnAiLeIuhlvvfVW3HM4z/zzzx823njjut+3zz77hAsuuCCKws8++2zcs5jvRzBuK51qU1JsWkTazCeDJ67t3ii6dulUSbuzjfwsVMWEXv0rabf7zHNU0u57g4aFqujfo0sl7c407ptQFbVuvStpd1Sn7pW023vct6Eqxvao6FkeN6KSdr9s6hmqYo4J1TxTtYrGa+g0fkw17Y4aWkm7Q3rNFapipormiq5DP6+k3VCbEGY0xvWft5J2O9eaQlWMaKrGxu4/7ONQFbWuPSppd0KvmStpt9alW6iKThPGV9Nu07hK2g1NY6tpN4Twxug+lbS78MzV2PZV0mPk15W0W+tezfottt2tVyXtjpnxTJHQv08111pEZHrnvsVXrvoQ2h0bv/VCmJEwU1hEREREREREREREREREpAOjKCwiIiIiIiIiIiIiIiIi0oFRFBYRERERERERERERERER6cAoCouIiIiIiIiIiIiIiIiIdGC6Vn0AIiIiIiIiIiIiIiIiIpKOWlPNyzuDoygskoi+3atJxO899ptK2m3qMyBUxYhOPStpd9ZKWg1h/glfV9RyCP/9duZK2l1iQFVXO4T3hoytpN3Fu3xZSbtNfWcPVdF99JBqGp4woZJmR03oEariDy+NqKTdo1avZryONFXzLI/uN08l7c4yfGCoilpT90ra7TxqaCXtNs0yX6iKWtdqxpF3vxlTSbtL9BwVqqJ7j/6VtDu4T3X9qyq6d+pUSbu9x3wbqqLWpZpxs9a5GpdQNXf4fyzRr5p2h1fkgO3buSlUxRPfVDNHrTJ3r1AVTeOruc/jJ1TTbpW6Qq+hgyppt3v/2SppV0REpCwsHy0iIiIiIiIiIiIiIiIi0oFRFBYRERERERERERERERER6cAoCouIiIiIiIiIiIiIiIiIdGDcU1hERERERERERERERESkA1NrmlD1IUjFmCksIiIiIiIiIiIiIiIiItKBURQWEREREREREREREREREenAKArLFFGr1cLYsWMru2qjR48OI0aMKP1vRURERERERERERERERDoqisLSJh599NGw8847hxVWWCGsssoqYb311gvnnXdecoGY77/ooouaf//zn/8cDj300Db93yn5WxEREREREREREREREZGOSteqD0DaP1dccUU499xzw9FHHx0uvvji0KNHj/D888+Hww8/PPz3v/+dSLQtm0ceeSS2ve+++8bfDzvssDb/3yn5WxEREREREREREREREZGOiqKwtMq7774bzjzzzPD73/8+bL755s3vr7baauH0008Pu+yyS3jsscfCOuusE8s1Q8+ePcO4ceNCt27dJvquMWPGREG5tazgzp07h65d/9ctx48fH0aNGhV//vbbb0OvXr1CU1NTfPXp02ei9rL3u3fv3vx9fN7Wv52S4xQREREREREREREREZmemNBUq/oQpGIUhaVVbr311tCvX7+w6aabTvLZGmusEe6+++6wyCKLxN9/97vfhc8//zy+Pvjgg5hJvNtuu4WbbropnH/++eHrr7+O37XtttuGX/ziF1GUHTp0aDj11FPDv//97zBs2LAoDC+//PLhtNNOCx999FE44YQTooC7wQYbRHH6ySefDG+88Ub461//GkXpQYMGNZe35v+uvfba8f/OMsss4ayzzmrz30JrxykiIiIiIiIiIiIiIiIyveKewtIqr7/+elh66aVjBm89Fl100dCpU6fm38kaPuKII8IzzzwTM4sp//yHP/whvl555ZVwzTXXhAcffDCWhIY//elP4Ysvvgh33HFHePHFF8M999wTvvzyy3DBBRdE0Zb/16VLl/Dcc8/FfYyL3HfffWHZZZeN5azvvPPO8Oqrr8Zy1/Vo7W8nd5wiIiIiIiIiIiIiIiIi0yuKwtIqZO9SfrmtzDPPPGHdddcNvXv3DrPOOmu48MILw5ZbbhmWWWaZ+F2zzTZb2H333aPoOmHChHDssceGq6++ujlbd8EFFwyrr756GDx4cJvam2uuucI+++wTS04vtthisW3E3in928kdp4iIiIiIiIiIiIiIiMj0iuWjpVUGDBgQhgwZMkWicJ533nknvPnmm+H222+f6H32Gx44cGCYe+65w9NPPx1LOlNy+r333gsffvhhWGuttaaqPfYdZj/jKf3bthyniIiIiIiIiIiIiIiIyPSIorC0ysorrxyzaBFPEUjz1Gq1sOeee8YM28022yy+V/wbSksfcsghcW/hepxzzjnhyiuvDNtss03YcMMNY6lqfv/qq6/a1oG7tr0Lt/a3kztOERERERERERERERGR6ZVaU63qQ5CKsXy0tAr7AlM++brrrqu7R++TTz7Zahbtd77znfDEE09M9N748ePDt99+G0Vlvnf//fcPxx13XNhqq63CkksuGbN2+Qzy+xWnZHLHKSIiIiIiIiIiIiIiIjK9oigsrcI+vOz7e8YZZ4TzzjsvvP/+++GTTz6JYu4xxxwT991dddVVW/z/Bx10UBRb//SnP4VPP/00vPzyy2HvvfcOe+21V/x8jjnmCE899VT4+OOPY/no3/72t+GVV14Jo0aNip/37ds3NDU1hbfeeqvN+wxPDZM7ThEREREREREREREREZHpFctHy2ShtPOCCy4Yrr766rDvvvuG0aNHx99PPvnk8OMf/3iiPXp79+490f9dc801w5///Odw6aWXRiG5X79+4Xvf+144+OCDYxbw2WefHf7whz+EHXbYIcw222xhnXXWCaecckoUoMeOHRsFZ8pK77rrruGII44IPXv2bG4j/3NGS59P7m8nd5wiIiIiIiIiIiIiIiIi0yudatbGFUnCN8NHVnJle4/9ppJ2a117hqoY0amatmedaeJAg0Yx7ssPQlX8d9zMlbS7xIDq+td7Q8ZW0u7iXdJVR2iNpr6zh6roPHpoNQ1PmFBJsx9O6B+q4vqXPquk3aNWHxAqo6maZ3lMz1kqabfn8IGhKmpdu1fSbpdvv6yk3aZZ5gtVUevao5J23/q2mnFziZ7/qyZUBWN6VDNmjxpXzbWuku5dqgnK7T3u21AVtS7VjJuhUzXF4zpNGB+qotalWyXtDq9V027fzk2hKp78fHQl7a4yd99QFU0Tqtl+bHxF7Va5LeWATtXYBN37z1ZJuyIiZfGPeZbzYhbY9LNXwoyE5aNFRERERERERERERERERDowlo8WERERERERERERERER6cBMqFVY5kHaBWYKi4iIiIiIiIiIiIiIiIh0YBSFRUREREREREREREREREQ6MIrCIiIiIiIiIiIiIiIiIiIdGEVhEREREREREREREREREZEOTNeqD0BERERERERERERERERE0tFUq3l5Z3DMFBYRERERERERERERERER6cAoCouIiIiIiIiIiIiIiIiIdGAUhUVEREREREREREREREREOjDuKSySiN5jv6nk2r4/vm8l7c7Ts1uoive/HlNJu7PO1LuSdof1miNUxVK9x1XS7hcjxoeqGD1+QiXtdgrVXOvOY4aFqpjQa5ZK2u028M1K2p19tllDVRz5vfkqaferaobrSLcuvSppd5ZvP6uk3XH95w1V8e3YpkraHTNTv0ravf3VL0NVrDx3/0raXWOWiuyBWjV2Lsw1ekgl7Y7oUs09rpJvx1Zje/Xq0SdUxaCx1cTr9+9RTbvVrRxDqHXpXkm74yrq151HDgpVsUD/2Spp98sK145dKkq9GTehmv0hx1dj8kX69q9mzP76mxGVtDv3zNXNUSIi0rFQFBYRERERERERERERERHpwDRVE0ck7QjLR4uIiIiIiIiIiIiIiIiIdGAUhUVEREREREREREREREREOjCKwiIiIiIiIiIiIiIiIiIiHRhFYRERERERERERERERERGRDoyisIiIiIiIiIiIiIiIiIhIB6Zr1QcgIiIiIiIiIiIiIiIiIuloqtW8vDM4ZgpPA//85z/DvvvuG955551JPnv++efjZ2PGjAmpuP7668M555yT5LtHjx4dbrzxxnDUUUeFgw8+OJx++unh1Vdfrfu3Dz74YPjVr34VDjvssHD//fcnvSZ//etfw/nnn9/mvz3vvPOmui0RERERERERERERERGRjoCi8DTwySefhCeeeCL8/ve/n+Szr776KorG48ePD6l4++23w0svvZTke3/yk5+Em2++OaywwgrhRz/6UXx/l112CSeccMJE5/Txxx+HX/7yl2HeeeeNf/fll18mvSZvvPFGeOWVV9r8tymuj4iIiIiIiIiIiIiIiMj0hKLwNNKrV6+w4IILhgceeCB0BEaMGBGzeVdbbbVwww03hB122CH8+Mc/DkceeWT8/Y477ggXXXTRRML4hAkT4v/54Q9/2CGviYiIiIiIiIiIiIiIiMj0jHsKlwDllffYY4+wzjrrhB49erRYynjIkCHhoIMOmui9oUOHhgMPPDCWgiaDdoEFFojCa+fOncPWW28dll9++XDllVfGrNdFF1007LnnnqFv374Tffejjz4a7r333vjzdtttF1ZaaaXmz7744otw7bXXhg8//DDMM888YcsttwxLLLFE/Iz3m5qaYqlovn/TTTcNn376afj666/DMcccE48hz+KLLx7P89JLL43/Pv300+GCCy6In1E+eqONNpqiawIDBw4M1113Xfjggw/CgAEDwlZbbRWWXXbZ5s85rr/97W/xmDbYYIMpuqZFWrsWCNu33HJLePbZZ0OXLl3i+9tss80k11pERERERERERERERERkesNM4RLo379/FBARS6eklHG+FDIlm8nAvfzyy8MPfvCDKEzutddeYeeddw7jxo0L6623Xvj73/8ejj/++Im+g+9kX+HVV189iqqUeH7ooYfiZwi8P/3pT8OgQYNiaeeePXuGn/3sZ7GEM7z55pvhrLPOCu+//35Yc801w6yzzhqefPLJsNxyy4V+/frVPQ+ygUeOHBmeeeaZsNhii4X1118/vs/5r7zyylN0TV5++eV4XGQb872cM8d33333NZ/b9ttvH2q1Wthwww3D7bffHu6+++42X9M8k7sWZ599drjiiividfje974XRfb99tuvxWMXERERERERERERERGZXmiq+WoqXIMZDTOFSwLxcqeddoqZrnPPPfdUfceoUaPCX/7yl9C7d+8otiKCsqcvWbcwduzYcN555030fzp16hSFZARdGDNmTDjjjDOisIzQucYaazTv78s+wXz3SSedFEVm6N69e/y9W7du8ffPP/88ir0tQYZtlnW77rrrxuODtddeO/Tp0yc89dRTbb4mHCdiNsI0kKnMcZx88slRJD733HNjG+xjDJSxzkpUTymTuxaIw7xH9jCstdZaUbRGkOYai4iIiIiIiIiIiIiIiEyvKAqXBKWWDzvssHD66afHzN2pYZFFFolCZbYvL6+ll166+fOZZpopDBs2bKL/Q3ZuJggD5ZqvvvrqWEKZUsiUP2a/3wzKLZM1O3jw4Pg75aozQRgo9Uwp5ZYgaxnItJ2Wa0IbL7zwQrPgm4Hoe9lll8Vy0s8991w49thjmz/jOBGfv/zyyzClTO5akIlMKezXXnstXkPayYRzERERERERERERERERkekZReESWXXVVePewAiQbYEs1Dz1hNa8YFsPyjTnyfbAHT58eLPYicBZJGsLoTnPd77znZgh2xJvvfVWs4A9LdeE/ZPZz7jYfvb7iBEjYtYz2cfF821NFC5e04zJXYtDDjkkls2mbPSf/vSnWKabrGGylid3D0RERERERERERERERETaM4rCJXPkkUfGcs/s7ZuH/XIRQvOQqTqtUO45z4cffhhLQlOueb755ovvZfv+tgWE0Jtvvjlm6SLoFrnuuuuiIIyAOi3XhGOcc845w0cffTTR35IhTLnmeeedN8wxxxyTfJ4/3ym5pm25FpTc5oWw/OCDD4YDDzwwlqymhLWIiIiIiIiIiIiIiIjI9Ernqg+go4HQSdnhv/3tbxO9P//888csWzJ44f33359o/92p5cUXX4wv4LvZXxhhl9LNW2yxRbjtttuas3vhpptuiiJtSyWiEYLZC/hXv/rVRBnDiK/sZ/zwww/H7NkyrgnHd+2114aBAwc2H//FF18cvve978WS2HzO/xk0aFD8/N13341i7dRc09auBed26KGHhkcffTS+jyjNd0O/fv2m6FxFRERERERERERERERE2htmCidgjz32CLfccstE72299dbxPTJPF1544fDJJ5/EUsaUSJ4WllpqqSjgkgmLaLrQQgvFfXyz43jjjTfCNttsE5Zddtnw9ddfh2+//Tbu8Yto3BInnnhimGeeecLee+8dM44RaN98880o7iLirrDCCqVck/322y+KtFwT9k5+77334rX5/e9/Hz//xS9+Ec+JzxdffPGYBb3MMstM1TVt7Vp07do1CtFcR8pnU04aQXz33XcPK6200hSfq4iIiIiIiIiIiIiISHuiqYXtN2XGoVOtpU1YZbIgQpKdWm+fWt6nFPI666wTyxwDGamvvPJKGDduXFh++eXj3rjffPNN/Pntt9+OGa95EfKxxx4LSyyxRBRjgYxahM2snDH/h+9ccMEFw0svvRSzWhFXyXQtHifHwudLLrlkLN0MCL2jR49uUeRFXKWNYcOGRdE5y54t7tVL29l5Tuk1Ad7j/yFAL7roopP8P4Rhzp1zQ8xlv2Gu2eSuKddq7NixzX/b2rUArj/XhPNebLHFYvnqaWHs4M9CFbw//n/7SjeaefpWt/fyW19PW3DF1LLK/DNX0u7gYSNDVfTpNK6Sdr8Y8/9jRqMZNHLiMvWNYoWuX1XS7oSeE+/13ti2+1fSbreBb1bS7rDZFg9V0bNzNeZfRcN1pFtF9XFmGfVFJe2O6z9vqIpvxzZV0u6Y8dX069vf+DJUxcpzVzNurjFLRfZArRo7F+YK31bS7uAu1dzjKhnbVM2zPGeP6lwjg8ZWM0n171FNu92aqjMIal17VNLuN2PrV2tLzYDR1c1RH3aerZJ2q/RydqnI3hw3oZqTHl+NyRdZoH81PqjhFT3Lc8/cp5J2RaTj8dfZlqr6ENodOw96PcxIKAqLJEJRuHEoCjcOReHGoSjcOBSFG4eicONQFG4cisKNQ1F4xkBRuHEoCjcOReHGoSjcOBSFG4eisIiUhaLwpMxoorB7CouIiIiIiIiIiIiIiIiIdGAUhUVEREREREREREREREREOjBdqz4AEREREREREREREREREUlHUzXb0Es7wkxhEREREREREREREREREZEOjKKwiIiIiIiIiIiIiIiIiEgHRlFYRERERERERERERERERKQDoygsIiIiIiIiIiIiIiIiItKBURQWEREREREREREREREREenAdK36AEREREREREREREREREQkHU21mpd3BsdMYRERERERERERERERERGRDoyZwiKJqHXvU8m1/frbcZW0u+j4z0NVjBw3W5iRmGlEdde6U9PYStqd6+0XQlWMXnqzatrtO18l7XbtFKqjNqGSZif0mbWSdoeMbgpV0VRRYGjf7tXFIw4aVc317vvkbZW022XA3KEqZus/oJJ235/3e5W02zShukjr1ebuXUm7o6oZrsO8g9+ppuEQwqd9Fq6k3eEVjV2wSP9ulbTbbVA193lCU/9QFV+M7ldJu3OOrGZd0WnYoFAVn8y+UiXtvjRweCXtrjnfnKEqFhw1sJqGO1W3oKl16VlJu6+NqabdgcOr8Q/AYn2rMUZm7dalknZf++LbUBVLz1XNHCUiImkwU1hEREREREREREREREREpAOjKCwiIiIiIiIiIiIiIiIi0oGxfLSIiIiIiIiIiIiIiIhIB6aq7cSk/WCmsIiIiIiIiIiIiIiIiIhIB0ZRWERERERERERERERERESkA6MoLCIiIiIiIiIiIiIiIiLSgWkXewq///774c033wwDBgwIq6222iSfDx8+PDzxxBOhf//+Yc0112zTd77++uthxIgRYdVVV52qY/r444/Df//73+bfu3TpEvr27RuWWGKJMOuss070t2+88Ub49ttvw+qrrx7aI6mOj/vCNRo9enSYd955w2KLLVb377gPzz//fLyGc801V3j77bfDuuuuG3r16jXR3w0cODD85z//CT/84Q/j304Nr776ahgzZkxYZZVV2vS3HPvU9hERERERERERERERERGR6YF2IQo//PDD4eyzz44i4b/+9a/QvXv3iT6/++67w4knnhgF2VtvvbVN34ngh8g4tYIfIvQJJ5wQNtpoo9CpU6cwfvz4MHjw4Cg2b7fdduE3v/lN6Nz5f4nWr732Wvjkk0/arShc9vFxLc4555xw7bXXhsUXXzzMPPPM8brwL9csL8giCG+22WahR48eYaGFFoqi/qmnnhr233//cMghh0z0vQjCBx98cHjhhRdCnz59purYrr/++jBo0KBw0UUXtelvv/jii3DZZZdNVVsiIiIiIiIiIiIiIiLTA021qo9AqqZdiMJAFu4cc8wRnnzyybD++utP9Nldd90Vxd1hw4a1+fu23XbbUo4L8bNr1/+/TC+//HLYddddQ79+/cIvf/nL+N5WW20V2jNlH9+vf/3r8NJLL4UbbrghLLnkks1C8YUXXhivzZVXXtksxiMWf/rpp+HRRx+NWcLXXHNNvNfPPvtszMaef/75Sz02EREREREREREREREREWnHewr/4Ac/CPfcc89E75H1+eWXX4ZFF110kr9HiKQUMYIjYvI333zT/Bli5HPPPTfR33/44Yfxb1955ZVQq9UmyqTlhXj5+OOPxwzjllh++eXD3nvvHbNLKZ+clWd+5plnmtvNyhJzTP/+97/D2LFj42d8/z//+c94HPV47733wiOPPBJLaU+YMGGic8m+k+/jGMnAzYNgzmccx5AhQyb6LH98k7sWk2uLc/rHP/4RxfJMEAaE8wMPPDAK+scee2x876OPPoqZ3/D000/H4wAyr4844ohw+umnt3id23KseaGe6zp06NCJ3uc8in2A9yhl3RIt3QMRERERERERERERERGR6ZV2kykMG264Ycw0RUTNSkgjEiM0IlLmQWCkBDEli+ecc87wzjvvRDH3L3/5S/j+978fbrrppijwkbWKqEl2K8LocsstF956660w++yzhwsuuCBmr5LxSuniUaNGxWzlzTffvNXj3HjjjcO5554bs105tltuuSUez1//+tfYLkI1pabnnnvu+D7H+JOf/CT8/e9/j99PW8cdd1zYfvvt4/eNGzcuHHnkkVFA5fjYY5njow3Oje9EtEYcX2CBBaLYyjldffXVsaQ2pa5/9atfRZGW60b5Za7NPvvsE78/f3yTuxaTawtBmL2D+b/1+NnPfhb22GOPKOAiTiMGw/333x+ampqa/27FFVeMGcOIzN/73vfqftfkjpV9kvfdd9+Ycfyd73wnlhifZZZZ4t+0VB66pfLSk7sHIiIiIiIiIiIiIiIiItMr7SpTeNlllw0zzTRTzE7N7ydMBnERxDtE1dtuuy2WLb7vvvuiKIroV+SMM86IQiffhUDI37LHLSJgBiIgAvJ1110X9wxujUwk/Oyzz+p+TnbqaaedFi699NL4fYjEWYYtwuzuu+8eLr/88ua/v+qqq2KGLsIp/+fee+8Ns802Wzj++OOb/+bFF18MZ555ZjxGPkdcRqiF8847L4rpfDfnh2iKgFovq7Yt16K1thDf62VtZyAcw7vvvhvWWWed8Itf/CL+TlZwsYz1oYceGkVXMr7rMblj5bwRngkcuOKKK2I/4LynhrbcAxEREREREREREREREZHpkXYlCsMGG2zQXEL6888/j1mgK6200iR/Rzbqfvvt1/z7V199Ffr37x/GjBkzyd8iKu6www5R5IPevXvHDFOyWPl/MN9888UXdO7c+mXJspjJLq0HoikCN5Bti5D5ox/9KHTr1i2+t/jii8cM1gyEbcRUyjUjRj700ENhwQUXDI899lhz6emFFloorLzyys3tc00++eST+HufPn3iNXvwwQdjSes111wzirqUaZ6aa9FaW/ks7nr07Nkz/lvvPhQhE5esa/YZrsfkjpVz3mabbWIgAXAN6T9TQ1vugYiIiIiIiIiIiIiIiMj0SLsqH52VkGZvWoQ4RMH11luvrkiL+HnJJZdE0e6DDz6IYiT72iK45qEkNHvNzj///BO9n/1OmWSYkhLBX3/9dfyXDNp6UC46T5cuXUK/fv2af+d88vvVUqKZ4+d8i9ci2yc3E0YzONfsO8ioPeGEE2IJabKDEXQpH404PDXXorW2KImdicf1QMgHyju3hV122SXstNNOk5TsntyxkqVNGeh55plnks/JZp5SJncPspLUIiIiIiIiIiIiIiIi0xtNdarLyoxFuxOFV1tttSiiIvYi0CEQ1+OII46IewbzL1m5iJD8zF6+eXr16hX3rmX/2TzffPNN/DcTa+tl1bbE888/H/9+lVVWqfv5lHwXkOFMiewDDjigxb9p7TsRcc8///wopLL/LnsI77nnnuHWW2+NJbXLvBbsoXzqqafG6zzrrLNO8vnDDz8cM3pXX3310BbInuYen3322XEv6LYeK20j4maieX4f4gzOo1hCu7g39ZTcAxEREREREREREREREZHpkXZXPhqRkL1o2XMX0Xettdaq+3eU+WVPYTI5EYRHjhwZ9/LNZ+BmIN6yH20eSgTz/7KS0W2FssjsOUu7U5Jd3Bpk9t51112hqamp+b1PP/007m9b73zy8DnnRtYsQuq6664bTjnllPhdWcnnMq/FFltsEf/uuOOOm2Qv4DfffDNcdNFFYe+9947H0la43+wN/Oqrr07RsZIJTcnsDI6HvaYzKCudz2rmmhTbKOMeiIiIiIiIiIiIiIiIiLRn2l2mMJCxSSnkjTbaKO7HWw8yUdmLlv10EfKuv/76uMdvlkma58gjj4wC8i9/+ctYjvqVV16JWbR//OMfJ5vViyiYlXumvDLtcEwIr2VBhjN74+62226xjDLlqa+77rp4HbgGrcGx3XnnneHCCy+M50j27D/+8Y+4H249QX1argVw7gi/7OfMMW+55ZYxa/e1114LN9xwQ9h6663jvr9Tyq9//ev4XVNyrIcffnjcc/jQQw+N50pmef7+s4/zlVdeGU466aSw/PLLhzvuuKPFfaCn5R6IiIiIiIiIiIiIiIiItGfahSi88MILhw022GCizNGNN944bLvtts3vLbXUUhNln1JuGNGOUs4DBgwIRx99dCxbfMUVV8T9iCETORdbbLEoCN54440xk5RM09tuuy0suuii8fNllllmkv2BF1hggXgMZKYCJa0p03zQQQdFkZCM5vyxkZWa/VzcU5is4nnnnbf5d9rPC43sg5sd31NPPRW/67e//W38fy19Z/49rsXf//738NJLL8XyyAjmZ511VrwexeOb3LWYXFvZ8d5+++3hgQceiNef7FsydxGFl1hiiYn+L/eG68i+xNl1RWgtwvuIu08//XTz307uWPkckZh2uW6IwAi62d7IK6ywQrj66qujaM73IiDTJ8hAB8qOZ9nRk7sHIiIiIiIiIiIiIiIiItMrnWrFTVc7CMcee2zc9/aCCy6o+lBkBmXM8In3O24Uzw+auKx3o1i9+6BQFf8ePVsl7a69yIBK2h33xbuhKjo1/S/optE0vf1CqIoPlt6sknbn7fv/wUeNpOvki0ako1ZNuf4uI76upN1POs0SqqKpIuuvb/fqdi4ZPOr/t4hoJAs9eXEl7XYZMHcl7ca2+1czP74/7/cqaffON/8XkFgFB6w6TyXtjqlod5W+g9+ppmG2lumzcCXtDh9b3VY2i/SvxhbpNqia+zyhZ/9QFS+P7ldJuyt0/rySdjsNq27t+MnsK1XS7ksDh1fS7przVdO3YOZRA6tpuA1V8FJR69azknZfG1lNuwOHV+MfgPXm6V5Nw527VNLsu8Oqc98vPVd144iIlM+5/SZO6pMQDv72zRnqMrS7PYWnFbKEyR4l27OYtSoiIiIiIiIiIiIiIiIiMqPR4UThIUOGxFLBm2222VTtbSsiIiIiIiIiIiIiIiIi0pFoF3sKl8mcc84ZTjvttKoPQ0RERERERERERERERESkXdDhMoVFREREREREREREREREROT/URQWEREREREREREREREREenAdLjy0SIiIiIiIiIiIiIiIiLy/zTVal6OGRwzhUVEREREREREREREREREOjCKwiIiIiIiIiIiIiIiIiIiHRhFYRERERERERERERERERGRDoyisIiIiIiIiIiIiIiIiIhIB6Zr1Qcg0lEZOLZLJe3O1beaWI+mHnOGqpirazXXuio6jx5WWdtPh/kraXexlbYIVbFwbUQl7X40olMl7S407rNQFaNmXqCSdjv1nqWSdhcY/EGoigk9+1fSbrf+1dxjmDUMqqTd1767VyXtNk0IldGvRzXz8uy9q2l3j5XmDlXReUw1NkHvMdXMjU19Zw9V0b1zNfPyN6PHhaq49fNvK2l36TmqsTeHDWsKVbHa3D0qabc2rFcl7Q6cc+VQFV1qtUra7dGlmnX6LG8/Eqqi7353VtLuk7f+IVTFoCFjK2l3rfmrGUMGjaxujuo0fnQl7d7+cTVG9pKz9QlVMWZENfZmjz4zVdKuSEenqRpTSNoRZgqLiIiIiIiIiIiIiIiIiHRgFIVFRERERERERERERERERDowisIiIiIiIiIiIiIiIiIiIh0YRWERERERERERERERERERkQ5M16oPQERERERERERERERERETS0VSreXlncMwUFhERERERERERERERERHpwCgKi4iIiIiIiIiIiIiIiIh0YBSFp3NuuummsNxyyzW/VlxxxfD9738/7LfffuE///nPRH972mmnhT322CPZsdRqtXDLLbc0/37ZZZdNdGwrrLBCWG+99cIxxxwTBg8eXPe4jj/++HjsZRzv7373u7D33nu3+Hnq6yEiIiIiIiIiIiIiIiLSHnBP4emc8ePHh7Fjx0YBuEuXLvF3BNdrr7027LzzzuGSSy4Ja665Zvzbww47LEyYMCHZsTz44IPhuOOOC1tvvXX8vampKXTt2jU89dRT8fdx48aFTz75JBxxxBHhV7/6VbjqqqsmOS6On78r43jz31WP1NdDREREREREREREREREpD1gpnAHoXv37qFHjx6hT58+Yf755w9HHXVU2GCDDcIJJ5zQLHwi0PJ3qUAErgfHxatv375hySWXDHvuuWcUiocMGdLqcaU+3tTfLyIiIiIiIiIiIiIiItIeMFO4A7PjjjuGXXfdNbz66qth+eWXj+WS33zzzXD55ZeHk08+OWYUI8y+8cYb4aCDDop//9BDD4ULLrggfPjhh2GeeeYJ2223Xdhpp51Cp06d4nfef//94eKLLw4ffPBBGDBgQNhmm23CXnvtFR577LFw+OGHR2GYUtHnnntui8fVrVu3KBAjYEP+uPJM7nj5bODAgeHCCy9s/j+Un/7666/D+eefH38nU/gPf/hDuOeee+I5cI6UlObn/PdTanrYsGGhd+/e4b777otZxojqlLrOjlNERERERERERERERGR6pKlW9RFI1Zgp3IFZfPHF478In8Vyyvx79913h8033zzuA4wA+swzz4RDDz007LbbbuGBBx4Ixx57bBRMEYHhkUceiWWfEYoRThFq//rXv8ZS1WuvvXYUXylh/dxzz8W9g+vx6aefhhtuuCFmMGdZui2VeZ7c8db7f8X3OJbhw4eHG2+8MQq/7HN80UUXTfK3/Hz77bdHwfq2224L55xzThTAr7zyyhLuhIiIiIiIiIiIiIiIiEh1mCncgenXr1/8lwzYesw555xhq622av6dvX633377sNlmm8XfV1999ZiRe9JJJ4V99tknXHHFFeEnP/lJFIWBTOGHH3441Gq10Llz51iOGSgVnTFy5MiYOQyUsUZ8JRt3rbXWmuLzKR5vW5h77rlj9jBiL/+f80AU3m+//Sb5W87nyCOPjOcy++yzR+H5hRdemOLjFBEREREREREREREREWlPKAp3YEaMGBH/nWmmmep+Pu+88070+1tvvRVF0Ouvv775PQRfsmm/+OKLmHH8gx/8YKL/kwnBLYEAzP7BmSg8aNCgcNVVV4U//vGPYZFFFgkbb7xxm8+neLxtYdlll42CcP73oUOHxrLTReabb74oCGdQ4vrzzz+f4jZFRERERERERERERERE2hOKwh0YRF5Ycskl636ez+iFsWPHxmzhHXbYYZK/pdQzAnBeNG0r+Xbmn3/+cPTRR4e77rorPPnkk1MkChePtx4Iz3koZ50n2xu5npidF49FREREREREREREREREOgqKwh2YW2+9NSy00EIxO7YtLLroouH555+PewrXg8zebH/iemSC6+Tg7xBvs/LWUwsi7qhRoybZs7hXr17Nv7/zzjsTff7KK6+EWWaZJZaKFhERERERERERERERmRFoqtWqPgSpmClP+5R2z+DBg8M555wTs3FPPPHENou1++67b3jggQdi+egxY8aEzz77LBx66KFxH19E3N133z3ccccd4aGHHgpNTU2xpPTPfvaz8Ic//KG5VDTv0z57CbdU0vq8884Lw4cPD1tsscU0necKK6wQRd4XX3wx7lV88803R1E7D6LwpZdeGktgP/fcc+GSSy6pu5+wiIiIiIiIiIiIiIiISEfFTOEOwkorrdS8B3CfPn3CiiuuGK688sqw8sort/k7fvjDH4aTTjopCqeIyYi83//+98MFF1wQy0ZvsMEGsfTzqaeeGg488MAw88wzh0033TQKx9kx0O5aa60Vjj/++Pge4vByyy03UTvLL798bGOxxRabpnPeZJNNwn/+858oViNGr7vuumGXXXYJ7733XvPfrL/++nGfZPYw5nx+/vOfx78RERERERERERERERERmVHoVENFlOkWxFCyZPN76NbbLxf4OzJ+2R+Yn7n1Le2jy9+1tn9wa59nnxWPjYxl2m7rcU3J8fIZ30+b/J/s/2f/p97xFr8/+7ne51PDR4OHhyoYP6GaR3reHk2hKj4aNfHe0Y3iO3PMVEm7TR+8GKri6TB/Je0uNkvPUBUz10ZU0u5H4/6/FH4jWWjcZ6EqRs28QCXtdq/9/1zVSLoO/iBUxYSe/Stpt9vs1dxjGDt0UCXtvja8mhjMpgmhMvr1qGZenr13Ne1WSe/x1dibncZUMzfWulczN8LgztXYfe8NGR2q4oMhE2/V0yiWnqNvJe0OG1Pdema1uXtX0m6XYQMraffLbrOHqqjKBfbfr+pXU0vND4Y/G6qi7353VtLuk7f+r5pdFQwaObaSdteav5o56ulPq7FDYJ3Zqhmzb/+4GiN7ydn6hKpYon81hUZ79KmmX4t0dE7qNW2Jeh2R346aeAvSjo6ZwtM5iMC82kJeLG5JOM5oTRCe3OfZZ209tpaOa0qONyuRnW8z/3/qHe/kvn9ybYqIiIiIiIiIiIiIiIhMD7insIiIiIiIiIiIiIiIiIhIB8ZUSBEREREREREREREREZEOTIU7TUk7wUxhEREREREREREREREREZEOjKKwiIiIiIiIiIiIiIiIiEgHRlFYRERERERERERERERERKQDoygsIiIiIiIiIiIiIiIiItKB6Vr1AYiIiIiIiIiIiIiIiIhIOppqNS/vDI6ZwiIiIiIiIiIiIiIiIiIiHRhFYRERERERERERERERERGRDozlo0USMWZ8NaUYFv3m5Ura/XjACqEqZu45Y8W3PNE0X2Vtfz58dJjRWGJA30ra7depmjGkFnqFqhhd0bj53yHjKml3hTm/E6qi02PXVtLukDV+FqpiljHDK2m3W+dZK2l32Jhq+jXM269bJe327NKpkna7f/7fUBWv91q8knaXGvlBJe2+PdOSoSo6hwmVtPvdpndDVcw01xKVtLv02Gr617i5q3meoOs3n1TS7pHPjKmk3a6dR4Sq+N2q3Stpd67hb1XS7vilNwhVcfnF1fgI5uxTnatz0MixlbTbY/SQStpdv+sXoSqGdq3GJvjxYtXYm72++ShURaf3q5mjHu+9YqiKtRcZUFnbIiKpmbGUFBERERERERERERERERGRGQwzhUVEREREREREREREREQ6ME3VFOmTdoSZwiIiIiIiIiIiIiIiIiIiHRhFYRERERERERERERERERGRDoyisIiIiIiIiIiIiIiIiIhIB0ZRWERERERERERERERERESkA6MoLCIiIiIiIiIiIiIiIiLSgela9QGITCuDBg0K5513Xth9993Dwgsv7AUVERERERERERERERHJ0VSreT1mcMwUlumeoUOHhr/97W/hyy+/rPpQRERERERERERERERERNodisIiIiIiIiIiIiIiIiIiIh0Yy0dLh+POO++M/06YMCG88cYbYb311gtrrLFGGDFiRLjjjjvCBx98EAYMGBA23XTTMM8888S/vfvuu8O4ceNi+ekHH3ww/vyDH/wgrLrqqhWfjYiIiIiIiIiIiIiIiMi0YaawdDieffbZcMopp4S77ror9OnTJ4wfPz689957YeONN47i7+yzzx5effXVsMkmm4Snnnoq/p/nnnsunHvuueGoo44Kffv2DV9//XXYaaedwkMPPVT16YiIiIiIiIiIiIiIiIhME2YKS4dk7Nix4Y9//GPo3bt3/H2fffYJCy64YLj66qtDp06d4nvHHHNMOPbYY8MDDzwQf0cIJksY0Tj7/fbbb48ZwyIiIiIiIiIiIiIiItMrTbWqj0Cqxkxh6ZAgAGeCcK1WC//+979juehMEIYtt9wyfPzxx+Gjjz6Kv1M6OhOEYf755w9Dhw6t4OhFREREREREREREREREykNRWDokM88880RZw7xmnXXWif5mlllmif+y1zDMNNNME33euXPnKCiLiIiIiIiIiIiIiIiITM8oCkuHp0ePHjED+PPPP5/o/c8++yz+O9tss1V0ZCIiIiIiIiIiIiIiIiLpURSWGYIf/vCH4YYbbgjDhw+Pv48fPz5ceeWVYcUVVwxzzDFH1YcnIiIiIiIiIiIiIiIikoyu6b5apP1wyCGHhJdffjlssskmYdVVVw1vvPFGFIYvuuiiqg9NREREREREREREREREJCmKwjLdQ2noE044ISy00ELx98033zwMGzZsor/p379/uOmmm8IzzzwTPvnkk7DVVluFNdZYI3Tt+r9H4Cc/+UkYOnToRP+n3nsiIiIiIiIiIiIiIiLTG021WtWHIBWjKCzTPf369Qs77LBD8+9kAtejc+fO4bvf/W7dz+r9n5a+R0RERERERERERERERGR6wj2FRUREREREREREREREREQ6MIrCIiIiIiIiIiIiIiIiIiIdGEVhEREREREREREREREREZEOjHsKi4iIiIiIiIiIiIiIiHRgmmpVH4FUjZnCIiIiIiIiIiIiIiIiIiIdGEVhEREREREREREREREREZEOjKKwiIiIiIiIiIiIiIiIiEgHRlFYRERERERERERERERERKQDoygsIiIiIiIiIiIiIiIiItKB6Vr1AYiIiIiIiIiIiIiIiIhIOppqNS/vDI6isEgixk2oZoAdO9+K1bQ7fEKoill7dQozEp07VXe+s/TsVkm7I8dV179mmjCyknYHh16VtDus52yhKsaOr2bc7NO9SyXtjqqwX/ft1aeSdvt3re6cvw6zV9LuwhX1r4+GjgpVMbapmmf5sxHjK2l3gR7VPE/w+fAxlbS7RJ/+lbTbOVRnA80/UzVL5697Lhuq4rPPh1fS7vzzfqeSdr8aVs0YAgtPqKbtjZeco5J2T7/vzVAZq85VTbudq7EHOj19a6iKh75YupJ2l5itb6iKL0eMrabhuXpW0uyEPrOGqujVrZril11GDq6k3cF95gtVMWDc6Erave3Fz0NV7HXO45W0++aftqikXRGZsbB8tIiIiIiIiIiIiIiIiIhIB0ZRWERERERERERERERERESkA6MoLCIiIiIiIiIiIiIiIiKSgKampjB8eNu26KnVamHUqFFT/XlrKAqLiIiIiIiIiIiIiIiIdGCaar6aCtegUZxzzjnh4IMPbvVvEHv5u5VXXjmsttpqYYsttgivv/56mz9vC4rCIiIiIiIiIiIiIiIiIiIlc9FFF4VLLrlksn939dVXh9tuuy3cfPPN4YUXXojC79577x1GjhzZps/bgqKwiIiIiIiIiIiIiIiIiEhJDBo0KOyyyy7h0ksvDUsttdRk//6qq64Ku+22W1h00UVD9+7dw5FHHhnGjRsX7rvvvjZ93hYUhRMyYcKE8O6774b//ve/YciQIWF6hrT09957L7z88sth4MCBYXrg448/Dm+++WbVhyEiIiIiIiIiIiIiIiIzEJ999llYYIEFwj/+8Y+wzDLLtPq3X375Zfj000/DCius0Pxet27d4v8jK3hyn7eVrlN5LjIZrrzyypgS3qtXrzDzzDOH999/P6y44orhmGOOCYsttth0df3uvffe8Pvf/z506dIlnssnn3wS5ptvvnDKKaeEpZdeuk3fMXjw4PC73/0unHnmmcmOs9jGI488Ej788MNw3HHHJWtTREREREREREREREREpj9+8IMftPr5Qw891KIe1RKzzjpr/Hf55ZePr7aA6Auzzz77JN9FoubkPm8risIJQCy95557wtlnnx3WXHPN+N7w4cPDGWecEbbddttw3XXXtSlVvD3w1ltvhUMPPTScddZZ4cc//nF8b+zYseH4448Pe+21V7j//vtD3759J/s9zzzzTLj77ruTisLFNkjLFxERERERERERERERmdG5sPZB1Ycw3YnC9WAP30wvqwcJi7179w5TwujRo5uzf/PwO5rc5D5vK4rCJfOf//wn/PWvf421vb/73e82v49weuKJJ8aSxmQL33rrrfEmvvrqqzHrdq655mouOc13zDnnnGGmmWYKb7/9dlhuueVCjx49mr+L7xgxYkRYcsklm9/74osvwtChQ8MiiywSIxQoV53//Jtvvon/b955522OUsi+izZJYafU9fjx48N3vvOdmBUM//rXv2LnzXdwapUfcsgh4YMPPoglpfORDrRLSnzXrl3jsdAhOS7+Dp577rmYKc17dFTayiCrl/rnfP7RRx/F9zhWMpPnn3/+0KdPnylqY9iwYfHhXGKJJZrb4D2+m++de+6523wdREREREREREREREREpOPwUAuZwK2BZvb000+Xehw9e/aM/xYFXn6nvcl93lYUhUvmtttuCwsuuOBEgnCenXfeOey3335xr9vFF188/PnPf45p37fffnsUNxGUyTBGNOZGsmk0mcdbbLFF83ccccQRYaWVVoqi75gxY8Kvf/3r8Oijj0ZxGcGUmuJfffVVuPHGG6PQSennm2++OR4XNcdXW221WGaZUtBXXHFFFFPZ8DoTl/v37x/fRyCdZ555opB68cUXx2OnHDYgWl9//fUTiaoHHXRQ+Prrr8Mcc8wRhddOnTqFCy+8MO5HfOedd4ampqaYcXzYYYfF60Rbl112WfN30AbHQdltNt5+4403Yto7nX2HHXaIERtT0gaba/MdXFMeDM45uz8c7yqrrBKzittyHURERERERERERERERETKhoROQC9Ew8rgdxIfJ/d5W+lc6lFLLLeM2NsS2R68iMIImgiVCJ+XX355FCr/+Mc/xnLNiy66aMxm/f73vx/+/ve/N/9/smbJJM5E4gsuuCC8+OKLsVw1ouj5558fBeIMhOEHHngg3HXXXVF4/uc//xmzjE8++eTmv/n3v/8d22Szaz4nOxYxFDbccMPw05/+NAqtlMLec889o3ibZeVmcIyIrLSNAM2/CMd8z8orrxwOPvjg+L0IyauuumqbegpZ1IjDiLs77rjjNLVx7rnnxuvAd9xxxx0x+gPh/Oijj27TdRAREREREREREREREREpm1lmmSVWr2Wb1Ay0PHQyEj0n93lbURQuGcoVZ9m09chKIPN3QAljhEnE3H322SeWis7vhYv4+9RTTzVvFI24S4ZwpvyTUfzzn/+8ufz0iiuuGDbeeOPm/8/+xWQtU26Zssqvv/56/P3ee++NpZqBqIINNtigucz1GmusEd5///3/dZDOncPpp58ebrrpppitSyYtmcw/+clPwnHHHRczc+HAAw8Mxx57bBS6gX/JsM3Oc2og8zkrL03J6mlpgwzhnXbaKSy00ELxdwT3X/ziF1EczjYEb+06iIiIiIiIiIiIiIiIiJTBqFGjYvXfjL322ismSt59991xm9PDDz886mQkb7bl87Zg+eiSoaxxJjLWg1Tu7O8yttpqqyjevvLKKzFTOBM9AZESgZIMV0Rjsli33HLL+BliKN+XCZ0ZCy+8cMw6zvbppcQ0/+ZhH+DsOGefffaJPqOMdSb25v8+2zsYYfiSSy4JV155Zcx8RiymPDNZyWTvstcwWbgIuYjcUwtZwHmmtg32bqbkNNclD9nY8Pnnn7f5OoiIiIiIiIiIiIiIiIi0FRJGZ5ppponeu/rqq+PrySefbE4SRc/6y1/+ErOA2UYWEZiqtm35vC0oCpfM2muvHYXd4cOHRzG3yOOPPx569OgxUTo35aBfe+21+P5VV10VS0pnIHr++Mc/jmLweuutF9X/TTfdNH7GXrt8Tlt58pmz7Eu89dZbR0G5JcgGbgmE6gEDBsS9hTNmm2228Jvf/CaWW3755ZejKEwGLxnNBxxwQFhmmWVihu/xxx/fvEdvkbzwnVHcILvYkae0jQyuE9eBhyQPeyXns7dbuw4iIiIiIiIiIiIiIiIiU0p+K9OMfffdN77y/OxnP4uvlpjc55NDFaxkEGBnnnnmKOzWarWJPvv000/DhRdeGPfHzSICSA8/6qijwrrrrhvLMt9yyy0T7QkMm2++edyD+Lzzzov7+mZZxoiYlIv+17/+NdHfI5xmkN3Lnrx5yBB+/vnnw4QJEyZ7PgjcRx55ZN3PyKRdbLHF4s/s17vbbrvFzkjmLoIuex1nbRQFXkps5zOquVZvvPFGq8cypW3kWXbZZcNjjz020XvsG0wZ6fnnn3+y10FERERERERERERERERkesVM4ZIhO/iCCy4I++23X9hjjz3CtttuGzeAJhP4sssui/vUHnrooc1/f9ppp4WhQ4eGk08+OWbgbrbZZuGYY46Jewf3798//s2qq64ahUtE0TPPPHOi9g4++OAolFJqmb8jo/idd94JSy21VPz8sMMOi8dw0EEHxTLVZNVyHOxJvMoqq0z2fI444oiw6667xnPZaKON4nF888034ZFHHolCbhaRQBlp9jdmX15EWlLeKW2did8I5ZRi5rzI8qUsNn/DtUK4Zs9fji2fkVxkStsongd7Cp944okx45oMaK7DSSedNEWp9SIiIiIiIiIiIiIiIiLTG2YKJwBBFnF2/fXXD/fee2+4+OKL4x64CLpk3lLyGd5///3w1ltvhVNPPTUKwlmJZLJvb7/99om+E7GYEsjFDaMRgi+//PK4h/C1114bM2gRfymZDIsvvnjMPkYw5e/Ijt1ll12axeUFFlgg/k2e/HtLLrlk3LT6u9/9bqxrTqbzPffcE2uV33DDDc2ll88999yw1lprxWO4//77w3bbbRcFXzKCKQvNce6///7hb3/7WxStyXjm/yDOsjcxAvWvf/3r5sxjhN/icU1pGwjY2XcgPLMfMfsrIwZzva644orm/Zkndx1EREREREREREREREREplc61Yo1jqVdglhMuWgyW/NQcrlfv34TZdjuueeeYd55553kb6WxvPbFt5Vc8kX6VZP5/PHwyZcjT8VcfaspejBT716VtPv4e1+Hqhg5rqmSdrt0nnQf8kaxzhzVtD04VNO/uld4rUeNr8YkGTx6fCXtztu3W6iKvi/eUUm7tZU3CVUxZHw1sZD9ulczLz/64dBQFcvM8b+gwUYzfkI1Y8gCYz4JVfHPkf8LLG006/X5/21gGsn7XVuuKpSa+Weqxt4cNq665foLnw+vpN015u1bSbtfjazGzoWFx1Uzjjw0fEAl7Z5+35uhKu7bdq5qGv7i3UqabRpa3drxgC+Wrqbd7y0cquK1r6oZN7df9H+JIY2m05hqzhfG96vmWe4yshob6Jsu/6smWQUDvnmnknaPeLG6yo53PVjNOb/5py0qaVdEZiwsH93Oeemll2LWKxnHZLoWue666+IewoccckjMBn788cfDCy+8EPcpFhERERERERERERERERFRFG7nPPPMM1H0pdzzIossMsnn7D9MOWXKVY8cOTIsvPDC4eabbw6LLrpoJccrIiIiIiIiIiIiIiIiIu0LReF2zt577x1fLdGjR4+wxx57xJeIiIiIiIiIiIiIiIiISJFqNlcTEREREREREREREREREZGGoCgsIiIiIiIiIiIiIiIiItKBURQWEREREREREREREREREenAKAqLiIiIiIiIiIiIiIiIiHRgFIVFRERERERERERERERERDowisIiIiIiIiIiIiIiIiIiIh0YRWERERERERERERERERERkQ5Mp1qtVqv6IEQ6Im8M/LaSdsdNqOaR7tutuhiT+cd9UUm7Xef+TiXtfjF0RKiKj4eOraTdOft2C1Uxz5jPK2l3fP95Kmn3m3GhMvp171JJu+9+M6aSdpea8Fmoigk9Zqqk3c7jRoWqOODxasbOP3Z5sJJ2O/94/1AVncZX80yN6tyzkna7du4UqmL4uAmVtDtgVDW212fd5gxVMe+oDytpd2CfhUJV9OpaTd8e01TNeqaponUUdO9SzbXuV5GJfeubQ6ppOISw3FwzzVB27vxDXg1V8Uy3xStp99aXq1m/wcKz96mk3Z98Z7YZap6A/l3GV9Ju5xGDK2n33TAgVMVcfbpW0u7l/6nuWd5umWpszj888l4l7Z6/9fKVtCsi1WCmsIiIiIiIiIiIiIiIiIhIB0ZRWERERERERERERERERESkA6MoLCIiIiIiIiIiIiIiIiLSgVEUFhERERERERERERERERHpwCgKi4iIiIiIiIiIiIiIiIh0YBSFRUREREREREREREREREQ6MIrCIiIiIiIiIiIiIiIiIiIdmK5VH4DMeDz22GPh5JNPrvvZrLPOGv72t7+V1tZf/vKX8M4774Szzjor/v7EE0+E73//+3U/ExEREREREREREREREemIKApLwxk5cmT46KOPovg7yyyzTPRZly5dSm1r++23D+PGjYs/P/roo+GAAw4I//3vfyf5TERERERERERERERERKSjoigslTHvvPOG2WefPWkbZB5njBo1KtRqtbqfiYiIiIiIiIiIiIiIiHRUFIWl3fLyyy+Hiy66KHz44YdhnnnmCdttt13YcMMN42fnnntuzDgeOnRoeOONN8Juu+0W/6743ueffx5LRG+77bbhlFNOCU1NTeGHP/xhOPHEE8NLL73UXD76/PPPD6NHjw79+vUL999/fxg/fnzYYIMNwv777x+6detW9aUQERERERERERERERERmWo6T/1/FUnHa6+9Fnbeeeew4oorhjPPPDNsuumm4dhjj23eb/jrr78OV199dVhwwQXDcccdF5Zffvm67w0ePDh8+eWXYYUVVgj77bdfLE996aWXxu/NPgN+vuqqq8Kbb74Zjj/++CgoX3LJJeHaa6/1NouIiIiIiIiIiIiIiMh0jZnCUhns6VvcQ/iaa64Jc845ZzjnnHPC5ptvHvbee+/4/pJLLhmzgM8+++z4/4D9iMnkzVPvPejVq1eYbbbZ4s+IxvXo3bt3+P3vfx+6d+8elltuufD444+HJ598MgrEIiIiIiIiIiIiIiIiItMrisJSGQi8iLh5BgwYEP999dVXwyuvvBKeeuqp5s8o7/zNN980Z/cusMACk3xnvffaCmIxgnBG//79m9sSERERERERERERERERmV5RFJbKmHfeecPss89e9zOygskS3myzzSb5LBOSe/bsOcln9d5rKz169Jjq/ysiIiIiIiIiIiIiIiLSXlEUlnYJWbsfffRRi6Wep4ZOnTqV9l0iIiIiIiIiIiIiIiIi0wudqz4AkXrssssu4a677gqPPPJI/H3s2LHhtNNOC7vuumuYMGHCVF00soibmprCqFGj4r8iIiIiIiIiIiIiIiIiMwJmCku7ZOuttw6fffZZOPTQQ2NZ52HDhoVlllkmnHLKKaFz56mLZVh++eXDfPPNF9Zbb71wyCGHlH7MIiIiIiIiIiIiIiIiIu0RRWFpOOuss064//77w6yzztpqqeeDDjoo7L///uGrr74K/fr1C3379m3+HFF33LhxE/2feu/x/7P32Iv43nvvjd9H2+xbnH124IEHTvJ/670nIiIiIiIiIiIiIiIiMr2hKCwNp3fv3m3eK7hbt25hnnnmmeT9eoJyW97Lfx/lpKf0+0RERERERERERERERESmN9xTWERERERERERERERERESkA6MoLCIiIiIiIiIiIiIiIiLSgVEUFhERERERERERERERERHpwCgKi4iIiIiIiIiIiIiIiIh0YBSFRUREREREREREREREREQ6MIrCIiIiIiIiIiIiIiIiIiIdGEVhEREREREREREREREREZEOjKKwiIiIiIiIiIiIiIiIiEgHRlFYRERERERERERERERERKQD06lWq9WqPggREREREREREREREREREUmDmcIiIiIiIiIiIiIiIiIiIh0YRWERERERERERERERERERkQ6MorCIiIiIiIiIiIiIiIiISAdGUVhEREREREREREREREREpAOjKCwiIiIiIiIiIiIiIiIi0oFRFBYRERERERERERERERER6cAoCouIiIiIiIiIiIiIiIiIdGAUhUVEREREREREREREREREOjCKwiIiIiIiIiIiIiIiIiIiHRhFYRERERERERERERERERGRDoyisIiIiIiIiIiIiIiIiIhIB0ZRWERERERERERERERERESkA6MoLFIxw4cPD1deeWUYO3Zs1YciIiJSKR9//LF3QESme7DtBw8eHGZEWNN89dVX8ecJEyY0rN1arRa++OKL5jYb2fZHH30UXnvttfDll182rM0ZlZEjRzY/W428xzJjMHTo0OifaXT/YtzMxo9G9+uBAweGpqamhrfNdf7mm28a3m6VDBo0KIwZM2aGOWfO8fPPP2+eo3mJiEj7oFPNUVmkUl5//fVwyCGHhPvuu6+yY2AY6NSpUxgxYkT497//HRZccMHwne98p9Q2/v73v4c77rijTX+7+eabh5/+9KchBSy2rrjiivDGG2+E8ePHT/TZbLPNFs4555xk1/jGG28MDz/8cHRmFDn22GPDEkssUXq7jz76aPjvf/8br+l8880XGrmwPf7448MWW2wRVl999di/qurX3Od//etfoXfv3mHVVVdtWLvw5ptvRpFrzTXXDH369EnW5p577hmGDRs2yfscR9euXcMcc8wRfvzjH4eNNtoo6Tnz71NPPRXf++53v5vsvn/wwQfhuuuui+PEMsssE6ogO2eeZ/oXz9eSSy6ZtM3nnnsuXH/99dHZXjTfuL877rhj6W0OGTIkjos8yyuvvHJIDX2ZZ2arrbYKW265ZZhzzjlDIxg3blwYNWpUm/62W7duoVevXg0ZQ3B8c9+XWmqpMP/88ydr86qrrgo9e/aM/ahfv36hkfA8I6Dxb+aUzOCZOuaYY5K2n11vnJPYQIssskhYdNFFk7aZbxeeeeaZOG8yV3Tp0iVJezzLOOcGDBgwyWf0s2uuuSYcdNBBoRHnjEP0iSeeCHPNNVfSMfzBBx8M7777bthss83CPPPMExoF/XiFFVaI82Hfvn1DFeRtoCeffDIexyqrrJK0TWzsE044Ifzzn/8M6623XrjgggviPXj88cfDiSeemLTtyy67LLbHc/zss8/GcWy77bYLf/zjH5Pee9o6+uijoyicsfzyy4fTTjstjiWp+OSTT+K4+c4770wybi688MLhpJNOStIu/enaa6+Nz+/o0aMn+ZzzTnW9OVfWSy+++GLYa6+9wuGHHx7XdIxr2A6NGq8/++yz8Oqrr4aVVlopzD777EnbzbfNHMGzzBhOH0sJa8e//vWvUcwpCldrr7122GeffZK0y/PLPeUe1wuY55hSwXjN+PX++++H008/Pa4xGLfWWmut8MMf/jBZu8y/PK8PPPBAWG211eJzjS1y++23h9///vehc+fOSW2/888/P3z77bfxmaY/77DDDvE5XmCBBZL2r+OOOy7+e9hhh8X+9Kc//Sm2/7Of/Sw06llm3MYnhH9g1llnTdoufjD6FWu4m2++OSy33HJhv/32C7/4xS/iz406Z54tAh/o16xnUsHze+6550bbknZYy9DP9t5773DppZeGmWaaKVnbPDv33ntv9G0WOfTQQ+PYnQL8PldffXWcn4vjJs92Khub82TceOGFF+qOm9hH3bt3T9L2Qw89FK83farom9htt93CD37wgyTtikg5mCksUjHzzjtvXFSz0G00ON5xAGMQ41BgQY1hivPspptuKrUtnFE4/9rySulAwxi7++67w9xzzx2F7/wLJ0oqELBY8OF0X2yxxSZpG8EyBRjc99xzT9hwww3Dz3/+83hf64mHZcMClkUufWqDDTYIZ599dnTMNgJEut133z2eN5xyyilxAbLTTjtFoTolODIOPvjg+DOLH0QtnilE+ZQZQyxmX3755bjoQoz9/ve/HxfWvDfLLLPE+/HrX/86OvLKdg7yTGVOmj//+c9xAcDrl7/8ZUgFghyOhK233jpsuumm4eKLL47ZQY0AZyBj5Ntvvx0XfPvuu2+8xziPyr6+eVhgcl0//fTTOFYVxxCE/xSwiKRNxg+cYjht8s7vssHJi6Pi8ssvj6ICjl+e5dTVNJgXWLC35YUjKxU8s5w3zxbO0e233z4+S8zVjz32WLJ2mYO4t9/73vfiM80iH6E8Ndge9GscoIjexX6dMpjpvffeCxtvvHHMkOFcd9lll3DggQfGMQUHRypwmhx55JFx3MrmjZ133jnOlzhGU8XrMgftuuuu4euvv57o/TvvvDP85Cc/iUFkqcAJSqDHSy+9FH+nTx9wwAHxvew6pABhkKBE7BDu7y233NKcAZYShH3G6eeffz40GpyDnOv9998ff0fUoF8RNHTyyScna5d++6tf/Sr+mxfoll566SgSI3ikAtsWRywBJHl7mnuQ8pyxO7i22GDM/8wjOLv79+8fbYOUYyjXmOvKGFkcN1OKORdeeGE488wz47NVbJdXKscztj3XevHFF49Bahlce0StlOtoAnqzYGXuObY9Y9iPfvSjmB2eCjIosQGyYMsjjjgiikjbbrttDHZIBQFE2HxvvfVWc6B4/pUyWI91GiISa5h6/SulT4Q5ifmfdVQGNt9vfvObugHdZcF9ZW2+//77N7+Hr4D5o60B9VMDc+Mll1wS7ZGZZ565+X2uc8ogHvo163KCxnmGMtZYY40ogqdcz/3jH/+Iojcg/vNcZzY2v6eCZxg/EPPCQgst1Pw+YvBRRx0VUoIfBDEasG0ZUzKbIOUchU+AOSq/ZmJ+Zg2PWJwKbFquKUHx9XxuqfyMme31yiuv1B038T2mvMeIwiS41Bs3UwWWEBTHuMn4SBBcsV1sIRFp55ApLCLV8eGHH9a22Wab2lJLLVX74Q9/WPv5z39e23XXXZtfp556arK2jznmmNpBBx1UGzVqVO3xxx+Px/DGG2/UHnroodoaa6xRGz9+fC01H3/8ce3VV1+tff7558nbGjZsWG3ppZeuDRw4sNZoDjjggNrll19eq4rXX3+9duaZZ9bWX3/92nLLLVc7+OCDaw8//HBt3LhxSdsdMmRI7frrr6/ttNNOtSWXXLK21VZb1a6++ura119/naxN2ttyyy3jfaYd+vXtt99ee+edd2qrrLJKfOZSMHTo0NoKK6xQe/TRR+Pve+21V23fffetffvtt/HfP/3pT7VU/PrXv66dffbZk7x/11131XbZZZf487PPPltbZ511Sm33gQceqG244Ya1jz76qDZmzJjaSiutVLv00ktrn3zySWzrueeeq6WEceOSSy6p/fSnP439izHz1ltvrQ0fPjxZmyeddFJ8nkeMGFF75plnaksssUTtlVdeqT322GO1VVddNV6HFHBePEcTJkyoVcGgQYPis7v99tvHc+bf6667rvbNN98kaY/rSP/lOeIZXn311Wsnn3xyHMtSQB9mnMi/jj/++Hiexfeff/75Wip22223eJ5www031FZbbbXYz6+55prYz1PS1NRU+9e//lU7+uijY1/GDqC/v/TSS8nafOutt2I7PE+N5vDDD68ddthhsa89+OCDtWWWWSbOE3fffXft+9//frJnjWu87rrrxrawszh/5ocvvvgijqeMJSkYPXp0beedd65tsskm8XmmX+2zzz7xeT7uuOPiXJUK7I899tgj2mHYfIsvvnick3ituOKKye//a6+9VjvttNPidV9++eVrhx56aO2f//xnMjuXPrX33nvH86TNHXfccSLbHpsgFYwVW2+9de3LL7+ML+bGO++8Mz5rK6+8crS7U/D222/X1ltvvXju2Ab7779/82cXXnhh7GOp4Hyz5wY7D3sMsAOXXXbZZO1if2APFMG23nTTTZvtwbLBxuK54XlqNDvssEPttttua3i79913X1wjw0UXXVQ744wzmj878sgja1dccUWytlmfZ2u4s846q7bRRhvVBg8eXDv99NPr3v+yuOCCC+I5s5Z677334njCuPXyyy/H+88xpOCRRx6J/Tf1GrEezIcpbY6WYA7G3gHsAmy9DNaUTzzxRJJ2P/3009qaa64ZfTFPPvlknB8ysLmZq1LBvMRYDWuttVacL4D+ht2d6v7fdNNNzc8NzzHPc8Z+++1Xu/nmm2sp+9eNN94Yf8bG596yjvntb39bO+qoo5K1y31kbgba5BnO7G6e5c8++yxJu6yZWD9hdwFjF2sM/CNbbLFF7e9//3stFd/97ndr7777bpyPmZczXnjhhXgcqeA+/vGPf6w1mqeffjra8Kn8AK2BzwWfRKM555xzkj43IpIeM4VF2gGUhdxmm21iZCpR7UR4Z6+U0biUOCHimOxVMkQoDUoJYzIqiK7L9gNLAVl+RONSUoRMkXXXXTdm3/F+Ksjqo4Rvqoy6yWVDpcxEnhyU4KQ8E9lfZCURhcu9pwQYEf+p9kAj8pgyUER9P/LIIzHi+ne/+11sl+xKIgxT9GuigLnPlCwkKnWTTTaJ5UDJKCDyPQVkQhPxu84668TSmE8//XTMZCVbm0zhVO0C15ExpAiRz2RmcTycO2Wbyox251qTMUGGH5nRVD3gOKiAwHVIec5AZQEySYl8JvqbknpEB5PtSGQ/2bxlwzkT4U6/Ytzkni+77LKxT5M5k+2bVDZkjhJdXkUpduDaks14ww03xHKgjCmU2eNakx1GhmuZkG1E9iJZDESac5/JJiWqnz7HmFKvLNjUQh/mu/MvyouRhVV8P2UZbfpXVl6M/rX++uvHfk5mUIr+nIdIcsoXn3rqqbFEJfeXe03bjCVk4tUrFzqtcyPnl6paxuSuNZk59DWuNVkqzBOcK2Mm2VKp2sX+oS0yCmiHa4y9h/2Vatzs0aNHuOiii2KJROZl5kUqH1CSngyWlKX8OGcyG8nQ4FqTvcGcxItn7MMPPwyp7WyyobBDyOSkPTJlsD0pj1/Mni4D+jUZOcyF3Ou8bZ+yFDzXmgwgMu2wgbiv9GmyNhi7Uo0j9CXmqHqZohwL9kcqmHfJIC1CX8f2L3vcyqDf1CvjyxqKDOlUGW+Mm1zTKkqTV7WeoX/Vu8ep+xfbSpDZSAUiYPxi7KQKD/ZuSjuXZ5nqDqylaJey3IxZ2J2s11NVYMLeZJyiH88o/YsxpKVM5JT9i37NfIAvpl67Kat7tTRuspah8lSZNvaUXOtU54yvA1sTewuovsP6nGxG1us8b6ngPtc7Z+xusjtT9S9KY1Mtjm06sHvYpoXzZ26kUk6q8QsbmvtY71lO3a8Zv6oYQxi7sGdTVcuYXNtVnXOV/k0RmXYUhUUqhkUXzjhelFdBKONnnLH8m3KPJBwlWdkYHEeUnAVKv2HMpdozEcOX86LMCE5myq1R8gSjgrI6qUr7scjBKEbUaDQY3pTYTVl+qi2lMik3hmP0P//5T3SS4mygZFZWDjcFGP6U9qM8FvebxRcOae434geiT9n9Ois1S78m2CJzbOAYTNWv888TgjCGMgJL6naBa4ooWwRBONtXmL7H8SEMlAVjRX4MwTmalQrCkZbynDMIXiHQgf6FMIwgTb/mPAkOKHu/9pbGzdT3GWGB/b54jqsCxyglMinxzDjKwp4SgwRgIJSnGluz77/rrrvi3uz0aUqCVlGaNTVZ/2IMo9xc1r/oW/WchmXDM81Ygv1BGUeeL46B4C3mapxJZc5jOCSxN1KWLm7L+MWzlV1rxm6ufyqhujiGcA2yAMDU4ybfjTBMGTvOn/k31d5q7WHczEN52bPOOitupYAYjz1IoAvCCiJ9maUjcQpmtn29F/NVo651fp/qlNeacokEdhaDKXieCNzKl8xMsZbiXIvQLg73VGMndiztFvcOzPY1TlX+nvMlyJU9E6tYz7BmS72lQ73+xZyIw794rSmVnqp/ZfME9xhRCeEoPy+nHLuK65n8uMlckWqOIkCKZzlloHZr/Yt5qfhMNaJ/YQcUQUjjWU4lfPAsI8wVg7M5/9tuu62ScRNbm76F3yRVu//6178m2SqDLS4IAk35LGfPE/M+W+Nkz1TK56m1/vXMM89EkZy1awqK63TWUwSUpLY3WYMjPGel7/OwjUfKfs0YQrBjI7ZLy4MtzXjBvr6NhnMm4LHR4ybbSmFnpUwkEpG0ND78T0TqOtpxcLO4R1TBkEG0w/l+xhlnNDtzyoa9XPh+jEP2iMSggKuuuioacqn2gWBfMbIm2E8ky3rjd8Q7BAayWbO9m8oERxWOIRzd7GFHFkf+2uI4ImMkBRhLL774YhR2WBgUFx7HHntss5FetgDP3ioYbGTysRjA+UmmXT46+LTTTovC7dFHH11a2zj5aZf7yaKEjLfzzjsvRrkTgQxE2xN9j+BTpjOD+8i580xl++iQZYhIihieAr4XpzL9mnMmc5QsDha5PMtEIaeCa0gfYm8zFiU8VzgZ2MuavZTp52TOrrDCCqWOJ4whZImyqPzb3/7WvJ8yjiQW9gS5pIBFPeMI/YuMRtrfaKONorOfY8rGFTLTGc+ysa0M+H6EBa4z1zjrX4zbLIIRSlNA0EaWdc5imiyVPGSCkR1WNiww2U+PvcfIsqP/EHVOhiXOlKw/keFIYBMBH2WDqIADib3VeLY4JgJZWsoamp4vzb3aAAEAAElEQVShfzFHMVcxbrK/MLDf74orrpisXYKDcEByn9m/mmvLuEx/y6prkK3N/cWxVNYzRdYCzwxZm/Rr5uH83ldkpLNPaKpr/Yc//CG2y77CODfgsssui07LVEIS7RIYR/Y9Ge/sqQyMJwSxkF1aZnYK42IRnIFkAdFWtv8oQnE2nqU4Z+Z/Ajmwb7Njor8RZJDKIYp9zbjBXMG8hN3H2MGepGQrZyDU3nrrrbGiSllgV19wwQUxmzRz1PFMc+1xHDKmpbrW7OVHu8yTzFfAXMk14JlKAbYtlSMYI7Is2b/85S8xWAvBI1XfAirfsC8kWVE4wAkeQvjneUq5Bzz2NNeatQv9irUTDn7aJ7szvzdpmSBm0BY2F88vY3R+3ETAok+nYOjQoc02Lve8GGjIeoKM1rJh/cQ8iJ2DbU2wI4GuPLeZDZgC1msEMTMvc285N+Zi7FACbFLOy6xneIYIaGG8uPzyy+P7PNccC8eVyt5kLiYIjPmRuSoP9545OwWMj6zRua8EVWTrxQwCrFNA1jeBywSnM14R2MN4iYCFvZ9q3OTZpSoOQaxUchg0aFDsVwThMYeUuS4vwrnyon9x3bnmBD3cc889MXApVWUi9hFmb3KCsoCxjHmKa409mA9+KPtaE0zD/qucJ3YudgDnjt3HGjnlOh17C1uTuZlAFgJpsYGyMS0FVGPhfOlT+ARYK2Y2P7YRn6WCdeKBBx4YfU4E8xBMxPoBW4RxLRWMjfhj8DcxfnHP8xx66KFJgiF5juhj3M9sPZN/hvBJZJWgygY7OquaVm/cpH+nyGDmOhMchV8Au6NYcYj1DVUhRaT9oigs0g7A4Mc5h0Mjy5ZhYkXgwUDebrvtkrRLe4jRRPHxbxYFi5B24oknhlRgDFP6qrjY4HfeT1Vuje/H6YlIVg8cOKnAEGtN6E4VnYpDjPLQGGs4j9Zaa62JHEcZODWySNIyIPMLhwFGN/2bRUi9IAMcwWUbi7RFBDALajJGWWwDix8WuSw+U8A9RBDGSYVglznkEONZ5KYUhXFGIs7hSMFhQl/HUcg9x9EAfF62kxDnM8IRjgQEfhyjwLVnAZwqsp77y73EAY2jmf5dT8Ah2IQ+X7bzmTGMhS1OwiyYg3Nm3EzlROH+saDkVY9UZfE5Vxb1tEsFC5w59ZwXOIdZgJfJq6++Gp9bri2BNYwnlAfnma6ibGYjoE9xnREIGUuyBTa2wfnnn5+sXYQNshgQOZir6gXP0Le5x5mIWAbMRzjl8gJdnlSZdkBAC2MiQuXvf//75raYN7kPqaDcPG0TSML1RGwHnIQ44clgLQsEm5ac2UWnGA6sVOAYwhlKgAnPcCakELTGuFl0YJUFDjKCxAhiYM5AZKlnA+GML/sYqMqCPYswiOOXAAsqPWATpLSxsQdw1OHY32OPPZoDOBhLEeNT2rrMxwgr2AQ4nRFXuLaI4wjyqeA5QjBDNMQWYDzD/jj77LObbcBUdh+BZ4wfbI2CUMhzhE3CM16vr5UBYzFzLq96pBBl82NKve1KMlKVzsQGom/Rl9jWgIAXxEvuPdc6ZSUNBCvWyQSZMC9zXwn45DnD7k4FIhJBWswNhxxySHP1IZ7l3/72t8nOmWtNkHq90uiQcmsr1oopAhwnB2tDfC7MFwiGXGOeI4RL7P6UYIcg2BFMghDMmIJAyfjV0jNeBvQnninWrsx/CHWMmwR2MF+lHEOwf7BpCTYlaD4TxxHNUpUtZ9wkOI0tUhirub7AXEWwS2aLpYC1IsH3tJkJpNxb7KFsnZ4CSpNjbzA/8jwzjgCB2wR3lL1GzpNt5cUYyZjC/aaENtW9srEsBfSf1ub9VOtHzpGAOF71wAeZCtaKrfWjVLYI40YWvFyPVAlGIlIendhYuMTvE5EphEUlDhuMs9dffz0uPDGUgcUBwgNOjkZCRkMq4yGLcOacbr755omcBxjoCGcsvhCYUkLmGSIDTqrU51tPZCFqkcV86rZxyNFWMUoyNZwXjowyxYNppZH3mb7MAhMxmMVfI/flykpjNXpPG0r48VyxAEh9zkQB41ivl61IvyO6v8zs4PbWv3CGUvmA4IOUzt+sP5G5kLqd/P1DKMIhh4CCQ4GsPsoXp9y3iKAYsgXyIKpQYaAYTMEiOHW5W8xzBKXMiZD6mcIpxj1OVZmkrfYQzzbzFY6sqo6l0TZBo9rl+8kWwHHUXoIqUp8zQjQlMFt6XhnfUsyVnBfiP2MZwUnYtAimCP6IOcyTZWYlt2cbqJHtMm5yz7PM2Ua3zXmXuUWHtC/ya8dG2PaUISXjrBjMSr9mbEHQSVWdRmRGoSqbr9GwxuHFeNJo38SMBvMEPjjsTwJOUwWMFyFrlwpMrJ9IvEhZEl1EOgbOBCIVQwkwJu16oh0LPUrgNprUhjFlhInEpcQcjn7OE+OJCF0yTImwTwXGMJmzCO60S9YKAguld4mQTenoJ9uNbAKMRMoJU9KHTE4yKsmkKAuyvdpaXosSTVn5pjJEFTIK2wKiSplZb3zXKqusEiNP+Zk9fVvigAMOSBahSj8mIpd+RQQu5Zq4H5TaQ1hKtShgEUC0N+ddb583MiuKJX3KAnGW8oyUbaRENRlhRGLjyOL5TgHZGpxTPeGXDEv21SlTFOa86DcIVfyMcNkSZAvxdyng3Mg+I4Aog/KBtJlqX1AEEzKfGFPyYwX3gPd45svs12RosscW5aiJoM+XqE4J4zPXth6Iw8VMPOaRVM4pyuqxpx7lwAhwwHFDBinR9mU6gMkcoIxbWyDjkMz8VGIwFSXIGMmgXCX3v+xsFbJQyMTGKcbPxf1P85A9U1ZlCTJEmPcIcOBngh5aguA4/q5ssD2459gcjYDrTPUIssD5mQoPrT33LWWLTwtktPFsI6Bgo2Sx0Ig7BOhR7SJFeWG+n3ELQRj4l+o/iMJU16BSTypRmHGitf3WqeKCvZQC+hj3mkBXskeYp7GHCHBNmR0NBDzQXrafL85Y1hlkdpYZ1EQWH99HuXl+Jmu1JXbZZZfmsvTTCkFSZJdhS/Jza9UMyi4fzdxIhhnnzc8E77REqvLRVYKNzZzPNikE4z322GMxWI7qA9j5qRzv2NI8r8VsPuwEnnP8B2XZBJwTdjzt8TM2SEuUXT4a2zJbt05uTZqqfHQGcwQ2bbZtCX4B1uupydrNytAi7FBlohEBXFnb7MFK9Tjmq1Slyeu1C6xfESpZn6f0QzF2YQdxjYv7kyPe4adJAc8sSR9U/SkGoALzY6prTkUD7JznnnsuPl9sycJYho+REs9lwZoF26Yt4PdkfCsLkmpYN7IW5meyz1siVfloIJiXOTLvhyKIiPma40v5LOFbxUbAlwoEqFFtkrVUmQEAZHqT9EGlP37GxmsJy0eLtH8UhUUqBgOUvcUQJouTO+XXEFZSgbCB84Z9tzDkiuBISyFuYJhgkCNksMjGOGaRTQmwww8/PGmUPXsoYyhiIOFAAgQPjoEFcKq9Poj2xiDHWEb8zqA8FMdCucqyhBUykPNlINlHlywwjFEcCCwCWPDjIC1TtOP48+3ibEcMxflIKR3uOwIHzrqyS6LzHGUlaviZDJVGl7LhmWWhwUIHpy/OFaB0J4s9yrJne/mUDc8R4wUGej3xN5WohlOdc6WUYL7MKyU62U+YPeDKLElKhhUVBgCHTb0STbxP2fAywcGalenj59acNKnK+TFGU9qMc6YEKJlQOCURmKiugHCZqjQ6ZRMpp5d31iFwUZoVx3uZ15tzpLxao0tOEZjT1j0vU4n+QHAHcwRzMwEIGTxf7H+b7Q9aBlzjtpZ0TRkwxbjJmE1AD04x5igEYhxXOB7K3LOR0nVZmWB+bi3wrsxywjyvmVOGn1vbnzBV5hdCO0EeiJMtlQUtE+zXrN/wc2vXM1X/Qjyjf2Vl98kiZZsSHN/MlQRbpIBzpUwzcyTXnTKRlMOnPeZjxNNUcF75eRfbhCAezhmRobgffVnQDmV8mRPYMzsLAmDOYg6hSlBZAmkR5kHGTsYM2spgvub3MvcvZMzMriE/t/Ysl3mteUayahn83Fq7ZYuyiETZ2oyfW5ufU67hEPgpxc5zVSx2R5/LSqOWDfMuggpzMkFb2b1lHYUoTL8vC0piExiEYIWQhLhQXB/yPvegTBGJ8SqrTMLPrfWvssug5ttKtXdvW4R/1i1sn0EwGuJgJkAzbqfce/Waa65p3meVNTvbXNG3uM6MbalsAoRRREFKV9OfsPEJOkWUxV/CdiIpoP8SUME2Jdj8+F+yQEvWjQQ8pAqiJpiBLdsItChWCUm1DQ8QQMQ4whxYb1uUVGtH+jX7RhPYkPcp4puhn+F7a6nc8ZRCv6lqTcG6LPN/8DPn3RKpguSZk3ieuJfMCxwHthf+H+am2267rTlQsGzwq5Lwgn8gSzQhaJ/KjMxVjG3Tuw0kIomgfLSIVMuJJ55YW3fddWu//vWvaxtttFHtoosuqm255Za15ZdfvvbOO+8ka/eXv/xlbauttqrddNNNtX/84x+TvIYPH15LzYQJE2qjRo2qNYKmpqbaiiuuWBs4cGDt448/rq2//vrNn/3zn/+sbbPNNsnaPuqoo2qXXXZZ/PlnP/tZ7dlnn23+bPXVV6+9//77Sdr97LPPYt/68MMPJ3p/zJgxtW233bZ2zz331FKx9957166++upJ3r/00ktr+++/f62j8d5779XWXnvteG0ffvjh2j777NP82SWXXFL7zW9+k6ztH/3oR7EPN5prrrmm9qtf/Sr+fMopp9SuuOKK5s/22GOP2p133llqe998803ss/Qhnl9+zr/uu+++2lNPPRWf9Y7G3XffHeeFeue255571q677rok7dLesssuW/vkk08m+ezpp5+ubb311qW29/rrr8d72JbXkCFDah2NH//4x7Xnnnsu/rzUUkvVxo0bF39mjmCuqArGtRR89NFHtZVXXrnuvTznnHNqRx99dJJ2Z0S++uqr2k477VRbcsklaxtssEHt5z//eW3XXXdtfmGndDRuvfXWaOvASy+9VNt0003jz19//XVtvfXWS2pjH3nkkbUdd9wx/ozNt9xyy9UuuOCC2u67717beeeda42GZ415M5Vt//bbb8dryljxwAMPTGTnXXjhhbXjjjuulgrmocceeyz+vMoqq9SGDh0af8beZ/5KBfMV17Ue2GRck9QwR3zxxRfx50bbPoMGDWpuOzWPPvpobYUVVohrZGzL4pqVe5FqnbrSSivVPv/88/jCzs944oknol1WNthW2LSMV+eee+5Edu69995be+ihhxp23auC6871ZqxuBDfeeGPtpz/9abyu2CNLL7107ZZbbqm9++67tdVWWy3+m4IRI0ZE38SDDz4Yf//FL34R54hvv/02+mnOPPPMWipYvzFPjR07Nq6fGCuxNXme8B2kgrGauYh1M+MX15e5kfuNbfKvf/0rmQ3EOVaxdmCdxpq50TAPbb/99vFn1uis1TOYk5mbOzL4DVi/NmJuxMZkfhg5cuQkn/32t7+tnXHGGcnaxn/8yCOPTPI+68n8nFU2zLv4VOuBLyyljS0i5WCmsEg7gNLFZKwQqUnZEUpxkMVBVlCqiLIsg4LI1zKzcNoKpeTIhiLTjcy+PERIk3lYNkSWE8FOJGix/CvvpSzVTbmin/zkJ3U/S1kmnKxc+lJxb1+iY3/0ox/FMq38myIKmLLJ9fbDJgq7zKyNyZWlItqeEmCUd0tZAox7TDZQvf0JucdEf6eCZyjlfqutnTNjV6P6NZHs9FfKQ5Jl34iSbpPrX2Tw0r+I/E6Z4UCJXfaorFdWjWecuSMFXOtsb6IiZDEwrpYJ2QmMHW2B7AKyCsq+zmTxZfeSKhLMzWRUcJ2Zm8rMIK33TC2++OJ1nydK+6WCMZuy65SdZTzJsrDIVmGbC6LMU5SD53ozbpKZVITrzVYLjXqW6evsIU32VUrbq9guMBdT+p/SiSnLpXNuLWWXNWJvyuycKW/Hc06WASWVU8H8v8QSS8SfOW/sXq4zVRUo0c0xpLrXZK3yTAFzFZmMZHOQxUuZv0ZD1grnSuUayr+WDRWPyERqyQbKb3vQqHGT+8zYRtZQikwsMnPoV5RJL/ZzynNSQjtFWXRgPjj11FNjxQ7OnWoxVAEgk5X+lXKe4ryp7EDmPVAhhzKRVC1JsUc38OyyN3eZZYvbAlWPGJMZq4p2Vqr1G2XtMxuL55Z+zFxJdh2vjrwHKvYHa0TKoGY2D9UWsEHIbEwF1XC23377uOXAXXfdFfsxmbL8y/1g+5YU5X0pE806ikpP2FusJyj9TjYj62WetZTnTMl9xgrKGmN/MIbzoroZfZvKDynaZRsW1q1k4NMOFcS4z2wxxucptnmib/Es1bM3U0PbjSjJXW9ebmkOSul/Ym3cWgUFfDIp7SAq1bGepHQ28BzjX6RyTIo+DYzRPMv1sqBZz/Bsp4K261UAojIOW5ulmjNYH5Pxv8MOO0xiA91www1ho402ash6SkSmHkVhkXYAkzSTaXFCTQ2OMsTRRovClMbCcUDpGo6haKSkKt9DCROMckoYF0ufIVCnFNUQZXE+Fh1x//nPf+KCsCjalgULLMoYFx1iGGsYp5njoWy4pyy6KNVNKeE8XIeyS48VFyI4Dyj3hRBP4AP7+AD7y6Xa1457iNMTwzwPfe7222+Pgl4q2D+Xcugs4svcN2ZyIOawNybPcx5ENQI/cGiUBWX2KSmGExQhkv0+W7sX/F2qBTaluCgDxkKbnxF0svLWqZxWOGkoj1l8lhE9KAePMysFLJ5ZvFParrinLPsI1SuDNi1w3yjt1hbKHkdwilHiC+dcVsqOPZM5dxbblOLib7LykSmg7/LsFIOImKN43lLBdhGU5sQhhwiMk5+5mGNB0Eq1nzDni9OGLQ6KZbkpIV0vGKFMkYFSb5T1Y65k/0/sA+YvSkem2Nc3m38p8YajhPGDQECCAIE9tBESU5RORIxsbZ/RevvRlwVOKc6VMRKbk600eJaAvXVTCT2MEffff3/8mbL/2IHM0wQVpS7jzNiJAxJnHOLZwQcf3LxFSarSmK1B0APBLanEQsYnnp/iPt2ZDZSVNEw5bhYDSmmXfl+mIEw5SMZn/uXeci/ZDqf4jNO/yizZWIRnif5Lv8r2vWcMZU2BM3Zye7NOLYjQjI8EObCOw9mOiEOQFuJ8qj05CdTK7zvfKFjLMCcw/xfXp8zLKbd5Ypxiz2rWMVxb5grK3rLVEuuZVGs4QJSlrHEmKOTBtk9VTvnPf/5zDKjA9qKsLc8SQbXYJ6zv2LImBbSDKAuMJaxdswAHggNTbXHAtc3aJWCHc8z2kMbeT7l1R75t1uY809m6gleqksb5drnWiErYYNm1TrVHN4I/wR2UoC9zfdrWdTq2JvZPyntab15m3Cjad6yzmDd23333JO0yZha3j6JPsZbHTjjggANCKvCtsZbDr0pwHrYf7eInoV3KwqewwZgL2CYk2zYkD3NXSnGUtv/5z39OErzLe9jBZQrC+LmwgQgoyGyg/LYdwPvYmmVurSAiaVAUFqkAnDJEr7UFRAf2XUkBi0oiu1nMI4gWs1M23HDD6BguGxYA7G9bL4s0JYhlLCb32GOPuLcrCy+yNjDUyI5iAZwKrjMRihiKOHGIYGRRgsOK91NFrbJ/HIs6InAxFHFo4LBDAMBAbusemlMD+4ziEEOsIosBAxGRmGyGVE4jQKRkf0qEDAxXoqw5T0RZjoVFbwoRHnGMrBAcNbSFExjxiIhznDkp96PC2cteuzi/ObdipgaR4Cn20CFrA6GW/k3mF5n/jG0cC8dRDAiYFujHWeAGP7eWlcvCPxUsKjk37jfjBtn4OAZ5rhAACEZIkSlD1DzjMd/Pi3PkejOG8G+q/aqBcZOFNE4UAnlw5rAXPXuhly2QtnU/qrLhnHAeIAzSn7O5CkcZwRZkguE03HHHHaOYxT5cKUCkRDDECUp7ZMoSdIBjOOW4iROFsQuhgchv7i/t4bwh6CPVHIVIxzjCdeWFY4PxjGtMsEO2h3gKyEYiip7MEdoiE4i5kX8ReejvKRxH7O3KPUUkRTBj7zFEUp5r+lm9ALKyQBBFvMGZk2WD8y8OQpyxzJ8pIKCFe41NS5/i/mZZ4IwvnHcKRzCiCn2bfRm5vlQWIDCMPkf7PGspxxTsXBzBOOQ4DuxOxheE/1T7ptOvyb4qOmNZe3CNU4mzOJ8JHmEcQcwhq5JjQUTE7k1pbzJG8QwRBMl1x+7L5ijG7zJhLOQZIpCF8Ym5uPi84gwlKyxVsCljJM5exi1E4EwUpk+xRyfjWCpRmPnh6KOPnmg/bsRhrgF2CPvupsjEYj3DnozYIrRVHC9YZyAulQ3PLkErjFM4wrF1EVlYO2L/sY5MBQLDkUceGddSPEcZK620UnyftWSKyhLMEwTGcc7046KgUHYwYLF/IQzTpzJYSzCm0LdSicII7IxRjNGs27LAUuZqxNrTTjstSbtkFjJWkjWJzYmtj01C0AniVYpqXvlzxs4j+A7/RLbnO+s65upUWf/cT+wfxlKCthmzgPEbWzfV2MW6nLGJZ+e8886L641836Zfp7Kzub7sD44NwlxZFIaxS1JkEjNu0p+YlxEqsTkJqmbtiH3bUhW7aYV1ekvB2awbUwbkMf9jZxFwmB8z8T0izjO+lbWPch7WL/ie8LkhSNOfsLWxQ/B/MW+mgmcIvy5zBoEH3FtsIK4F75cJ/QkblsQivp/zzAJZ8jYQY0jKYGYRKQdFYZEKYKLMR8+RrYIDGEMRBwLRfCxCcDiQNZIKnHI4ExA5KKtcBMdRClGYiL155pknVAELexY/LOJZ2GOYInIQDZ0yiwFDH+GIRR/t0h7CEgZrsexcmeAswHlBu5wrwhWOFBwqZCZh2KWCBR/3Gscr1xsDFSEP0TDlIpcgB4xxBHCEd84XBzBBARjrOPxTZWazmOR8cRR+9NFHcUHPQgTHcMqMN57T1jJFU5Uj5doS0c/iGuckixEcpGTY4aAtMzKV780cB/yMgFcF9C8WWJw7YyiiUpYFjrMhKyNeNlxLxCOeW55nHFc4VHDCc/151lJBJDnnxuLv3nvvjYt9HLBZ/y4TzgsBoy1wD8rKjCcLCNEqH9X8wAMPxPPGmQKMYYydVFlIJQozNuLYxylKIAfZMSys+Z1ArVRwzTMnCdHsWclCSvsybvNs5520ZYIQTZ9GOCSQh/vKc4VzuF5J2DKfZdrF8cmzjKOSc+d1/PHHx/kyxRxJu5SlpB0cRbSTBXrgtGKOSiUKIy5wvognZPoj4iDSkq1NX0sF50xAFuMU15o+nZX/x6FEkFoKQYdnCBsXOxsI3OEZZ07mWmMbpAKbizGE/p0FhTF2Zs81fSwFzAvF4BpsAOYKghBTOfoBUYXnmOA/1jA4frGtCUxLGfDDeIydyX3lGjNesp46++yzkzi9GRd58Qzj3G9JJGM9l+J6U7GE61kv2C/1djgEkdTLeMrKHCNYpxCF6UsEzBAExxxcDNjBTkkxhgBjF+tWxhKCDgh2YO2IDZRyGxPWEoigtI9gmIFohnBHoEdWHr9MGC8ZL8hCbzQt9S9szZT9mjKnXE8EYdblm2++eXz/zjvvjGv1YtZjWeB/YdxChGctl1UdQLjidwSmVLCWQYwkYAnRO6u+w7yVan7KgrVYI2JnUpmHYH1APMPeTrUVD2MG41RLFZ1SVarL7vOWW27Z4uepsrJZOzJusX7k+lIJ6N13340iHvZQCj/f5OA60K+xjRo5hjAvYXuSOJDSBuLF+Ew72LysnfCVpPR9InYT2Ml9xg+FrxlfxAknnJCk6hF+D17YWdghVfl1RWTaURQWqQAm6Sx6DocBTjmcKPmFJQYNxnrKPQQxxillh3jXyJKziN8YqGRkpRTKWgInYEpHYGvCcKOzo4HIUBySLMAQrPi9WKYzFSy8MEZxOLMgot1UC58MMpKzMkk4UYiSzfp36lJcGOFEp2aZho2i7CjQKXH0cz1ZdBRBJMZpmVLUye/JiajA8ay22mpR3EtFsewZwkJG6v7F/k+Urc7aSv0s5UFM4JUaxqkq9hQmg6CY1YXjOT9+ZE4jxI6UkCmSYj+11sAZmO2XSLQ7ztGsj6Uus4toQsYmr0b263y5SPpclp1CJgVzSKoShsUxhDEyq26QskwlfZxSoIzNCIeI4MwdCDmIxdn+oI0453zAY+pxEwc0L8Cxj5DTCHACEpSHsywThXmWKGuIMzYViJXMS/UqZpBRSin8FLY3YwRZXohzWRnSRsG1pk+Rld1IyPKjyhDZ/wTWZNn3/IxwS8WcFIGf9CnGa4IPi6TeDoc1Kw5vAmryzy3ZyYwlqZzDZMVmwZ6pBLp6EMhLoDbnXazIQp+nukImIJYNa7aWgsOxB1P5CBCa6b9V7F3MNWa/arKC8wGtjKV5e7tsWEswDxZLviOacg1SBXgA/h9KvudhfsYOTLmtA2JOtlVKcQzh3mMLpQoqxj9QFGezYOJU15rxI5UQOTmyoOYqQPjF5khpd0wJBEOm3POeMYRsaILF8v4A2mX9ltmDZYMNTQUJAioYN1La8/XA38aL54fnNtWzy1hMcgUBHayTCTBtCfxh/J2ItF8UhUUqhowQHI/FSGMWJ5tttll0NqTcd4OJuhGCMFkDlP3KYCFLVBvO0GKUIhGExT0xyoDFO3sU1YPrzQKEaH+iVMs2GFmEUBapHhhtCLUs/ImcLHsBjlhGqSSM4QzEWfb/SCk84BQj8pjSUJkzmL6O451MnVR76rGQxllFRDlZjVnJwn//+98xI7/MTAKiqzGGiSLnZ7JSWoJyPvlSRmWUmeXcWNTzM9kZLZGqfDRZDDiX64ngfIaglkoUxjFISVCy7ol6Zi9BskxxSuJcSVWyiHJrCLNkLTB+Z/2Lfk7gA466ssDJSgk5yuryc7Y3dkuLYP4uVdkzsrDIXMie5QyyWnHglek4KTpYCSJifCxmxJSZTUA0dz56HMcBr6K4gSM+VSllQFQgSIxxMj8XUIWA8SOVU5KsAZ5jMlTJ7COIiXGa7GEE0zLHLvoRNgHZ/vxc3I+zeI9TVQXgWSbzHhEcZ05WOjErEZ9KnKZd+hXzPuNXNn4ynpDJkWp/cOZknKKZk4zz5vpzz8nU4bxT7YnOOVPRgJL7zJVZ2WbGccbtVAGCZGFTSpnnFgc3wQ8EDqWskpJda7LeyVbBMZiHe5Ay4JOyfmTHFiuy4ORHNM0q5pQNgSQIZKnmodYgMzjl/qotgf3HGMLWIQRcYM+zjmDMRJxnj/YUMF+xVuF55fll7iJIii1EWGtgG5UJAh0CZTZHIZIi0LFWwq6n6hQVB7C/WWulyLijXeamRgrC2RjCHEQwTRGy7hjXUonCzEP0pWKVEMqCpqx6RDYdAXfMC8yLxUo0tFtmlZj8GoIgoWxtxTPEWvHtt9+O2cspxQXGR54hSkXnq9Vg81ImlazpVPvQ8jxhCzAXZoElHA/rWOxN5uYUMEcRrM755feNJhCC/kXWdJlrmjxUguGZKgbTMFcTgMo8VQbY8ayBsaH5ubUSvmWXj8b3Q9/GnuZnAuRboszy0QRntbZezMPznVVDKhP6MiJ/EbYqYfzCb1Em+H3w8WRwrRkvmDNYpzJ/4QfDB5SqMg2B6VQWyK5nakGY8ZmKNKwL+bm4Ps/DGFLW+pGA/2wdwc+trcVTBumLSDkoCotUDI4pjHGcCUXDm4VgVsonBSxiWYSQ5ZdaGMb5SUR9Rv7nen+bAhwXGNw4ITEUERiIpsuclNmev0T14zgrs5w0oj/tspBG3GCBjRMF0ZKFNYIdjgWcascee2xp7WIgsrAich9HIf/i4OBYCDZAaErVx1hokpVCxCSlQHHIcp0RkOjrqfYMQhxDJOTcyNLISgfirGR/7jKdwdy3LOuan1szjMvOzkZszaJA+ZkFWEuUGS2Kk4JrijMBJwIOm+JegSzwaTNVZDTfT7UFHJVA8AzOd4RLjgXHTqo9nNm7kHGCbDf6diZU0t9Y1JcZ7EBfzUr783NV+ygjDuKQw0lYFMrKLltdL1CFZ5cAg7KyglsK2qCENE4FMunoQ8yL+cwU5gucZFTYSCluEFBRHB9xVOL0SLUHKueMMwxnICB0kEXKHmj0+dbm7KmZi7OgDX5urV+n3I+Kfn3SSSdFG4Bzz0rAIsymLJ1IyTXaxmlHJkM2TiLoUEYaR3gKEGoQj7IsHK4tZcERlVJng+MYRXjH0X/UUUfF5w1woDFulp01gu3DXJAPSsvgucb+RehJVXafNnCWkUVRFE94vhHky4R1BIGkPL/My5T/LGYF8T5OylSBWpwTaxkc742qRpPBOSGspMyQrQc2LZk5jJfs0UiWEBlK2PLYn6n2jQbsWdY0lIrEJsHGZ2yhClTZ5Ve5n3kHd7E0J89z9kynyixlLkZIIoO1EaUqmW+xA4D1S709KHk/lSAMVNQiUJpxG1GD/sX8RF/jeU9V7pYgU9rhWaaPF+8pbZcpChfFsOK1JhAgdfUU7EyeXfoZ502pWdrFPiDYARs0BazdsLHwD7Ae53pjF2DzERSact97ArfZm5ygFoRESobT19grm2NKFQBJZQXmfWx6fBKIwYzdTz75ZBxbytxiijVLNi/wc2tjY9kCOO1m4yY/19uqLaNMARG7uq3bNaQo9Q+MGcVjyBIwmBvL3kaMtvLBdsUxhbk4u/epfJ7cY+xogoUaUQkR/0M2NvNza1svlTkv5ytm4Jtg/GDsEJHpk061LDRLRCqDSDoirMkSZeHNYgxBGNGBjLdUe6uQ1UhGEoYozsGiU46SQimFhsyRxQIEITjlfmMZ7ONH6b5i1DXOQ4xVnCwITCyIcM6XBaXWuMfsI5cXjXDI4hxGPMWZxvHhNC3LkcQCC6c3jtdihCAOQ/pWWdG49TLPEIaL+1CyAKVv/eMf/wgpYXpDeCfqPMuOSlkGDaccIj8RoqlK9rQXXnvttVi2kOx/FgTF/VVZcLEgKyvquQjOMZxlOL4hE1YQ0nCk4KDN9kRNBUID/QunIA5KxIVGl9lrBAhIBMjQt1vaNzE1ZFXiREgpCmclsXCSUb2CeZjAmWxPPTIqEbPI+mPsSpWxS8AS81Fx3OR5IwOvraW1Zcr6eJbBgSMHh1oVz3JWqjNlmUqeIxzdVDugH1MxhD0rEQBwaBUDfMoGpxXjJv/iACeYKsW1xq5CkCUbBYcVtizt4LAj0AGxBwcwgZGpIFuTYAMCDrHlCbLg+SU7KsUe4cx9nB/jGGN2vuINdic2Po7DVM5KMlSpSkMAEW1k1zyDY0oVUINwglDGPWWeKgYvkSmWohw88wX2JSWzyX6iogLBHcDcQQWTFPuDE5zH9a6XHY2gxXzFHqmpbSDGTWxtbKAU1WjysBc5ayiyRslkLbbH+qnMKguIdTyrrFFZLyNi5aFvcwzM1Sn36SarjfZ5vhHQ8BNQTYtAm1QlWBEIqeBBqf0qtnmqAgLBuI8EC3HeZMoyP/JcU1Kaa5LiPhOIiK2J4M/cz3iBDwJ7gCB11uhlzxUZjBEE11LRgLkSsZ+gX7IKOS6C1VPAntyMUXw/6zjWa8zJ2Lk77LBD9Fk0opoH63bmqSrKpEvH9I1gizAvYofQt/I+PxJEWqpYOK3gO8TWLfZjMrMJeOG5SkG2Zk51XiKSHjOFRdoBOOFwEJHRQNkcFh0sMhFsUwnCQDutlWlOud8HAimGE4v7fKQ/Yk6qLBkibnGY1VtcEenN8SAKsyBjf7IyYYHH4q6YRUhUP84rnGicP+I8Dp2yRGEWPJTIqbeQJTMMZ0MKWGDhSCFDuF67WRm6VLC4JgM+2yMTcJ5hvKbKMCAzBJE0VfnNybWNk6wIDgYCEhBQy4wGJoqfF21me0UjoiGQ0ndTL7Dz+1PiuOE+Z/uupd6fEsjMwTmJYzYTwSmHTwBGqsyzevso4yQkMpoAjFTjNfeU754RHIM49sl+IVODvp135pOdxPiM6JHSAUwGfr1nmaApPksFNghO93rwLJMxgqiDqNhatkMZ/ZpKD8yJZOakFhoYH3FQZpUW6OvYAziIU5xnBjYG81SxdCLZtJSoLLu0XsYZZ5zRXFqWaP8sAI4AnpQZ8FmGLO1ji2X9iiAIqj6UmVFJ3yH4DJGwmGnOXMWLkok4v8kuLavsMFm6BPiROQpkfSPAX3TRRXHMwAFOxj0VLVJkVWTVbTJnZEtZTymDDvIZo0VSlSEFxqfWBMFU9giBDWQFZZnS2O/YvvRn7IJU2ffY7qyXKMNfBLGYPpZSFGZ9Sn/OMrM4V8YThNPilkBlQRvMzy1lqJZdVpogArLZeK7J4kydqdoSjGFksDYS5iTWp1XYffvuu2+rnzOeprJ1s8o/ZKsyfwDrWGwyRMwUe5Ey7zN2MCbzwuZBVGKuINCVBIFUojBt58+Zc2RepN0sSz7Vtc4qVmB70C7wnBH8iV3CmioFrFWzyg5cd4LjWEMTKEcge6q5kXUrfj7s7OKWEmWXjy7uxd5akDQ2GEkpZYAdTUBeW8dXqjGkgIp0BHO0BEEe+KJS0NocldIGIgiNrVKK6xZ8IvQt7KMUdhDPMUGljd4/WUTKQ1FYpB3AJEoGAS+EjpRibJ4sqgsHEZkbjYr2Rkgh8wtH3HHHHRcX8jhOMJZZDJKRlkJYwQDFaEFEKpbPw5DKHBlEYpdt2OAgoo1iRiUOYLKls7ZxlpbZNgueTDjK31fuNU7TFBkMgOGJY5Io++JilmjGlBmHLO5wbmMAs7jl2hN9TGk9+nw9J1pZ1xrRporSiQgILGjzixxK4RLxjvMQIScFOEpoh+uKI5KIc7IXEEy5Hin2Bs8csTgIyWQgwITAB7LcWJAS4d6SU7oMyBYgkIdrjhhLUAdjCotQsgoIPEgFgQ6MjcwVCCzZXqssQMl4S1ESi/GI0nk4gVP1o/ZES6IGjhNeOJTIoEjhHASeG/oY2YV5EBBTjpucD3MwDjHGbEQWgi0oi854hjMDxxLOurKdhZQEZT5CoMWRQ0Q7thDCFgJmqoolzAXsx0W1FuwRnh/GMRyDiJdlbuWQB1uA/eUIZMEewmmDQ5bMVgSAfGm2siGrEYcYUNECZ1ExAy4FnBvtkPWEHcS4wlxNBifXmWteFvQhRNfWSo9jFyC+s8dcWaIwjm6CC8kUJUAI25YMrFT7yrYEwaQIJ8zNxb0xsU84xrJLN2btct5VkG0l0WgIXMHWJEMH0ZBxlCo8BPaSAUdAXpmwH2YmVrVW0pj9BVPBGo3M1cwGwgnNXorYQAR4tLZH/LTAM11FicqslDK2Xpklk1sCW56Ms7aALZhib0z6dZaVXebWEW2hKO7Tn1knM1bn9x4uGwLvskBi5g7OPQugSbm9AusZfAEZ2bYOXPfU2zrQNueM74d2sfeyNTz+Evp+Cn8M1zrb/xX7Er8L1wBbL2UwDbC1ED6vbB0FnD/ts85Jte0R25LxbBOQVs+WL1a3KAtsreIzxVoZ3xB2fpn+CvpNvi0SE1i7rLbaanGc4nPsM9omUSIV2Hf548DnRR+jbDl+r1Rl0ZmPG2kD0X9ZS2TjZL35ifdZ06YKjON55X5iCzCGFK8tfoNG28AiMmUoCou0AxCsKPdGZCiTdx7ES4TTVFAqGWcchn82uW+yySZRfEhRag1wlOAAJfI5ywzidxahGIlENeKsKxsWdmRxYqDQDgsuIsDZL+iWW26JQg/iKU6NspyEGUTd8mKhg+HEtWVRgjMcRxLR2FwPFqBl7jWHSMj3kbGC44qFD8Il+2KSjYVjJxUsrFh0UU6Z7G+iZFnUY8Sm2u8VyNal/+Qd+vQvrjPOdhYk9TKYpxUEfbJxcbZmmTp5IxxnYVsjaKcUFpk4AckOoV/Tl1iAIubhqEsV6MGCj9KjlEjML3JpF+GBiO+yszeA68q4hfORMZOFNiCAUyqJjM9UIIzh9M0LpIzTLHrJzGG8TuFEwUmEY5J7DGQ34iBDZOF8ESKy/bPLhLkhE+CZpzJBPr/4po+VBc6K4r5I3GMcVFlmdgbjaKq9oYogsJDdidMMcTiVKMzzRMUKStwybtLXESop/5VSvOM+Mz8QXJDPlMDxz7xJFDpiEvYBx1NWFRPmYATYrGwxwTsIKvQpniVslFR76vEs0wZ7NmZwXsybiPIITSm2AsCBQh9CECVIimuOAx7HN/N06moDVcC1pkRmPgOauYq5gmvBXMI2ImXAHNCW72KO5pqXBeMR/RX7meeEbPMUY3Jbgh3oW1xX7EzmYBx1BHTgEKWEYQr4fp7lejCO4ZzGFmPuLDtwjjmQ+14kK5tNMAT3ouyMO+Z+7Ghsd8C2xT4gcAabv+x5grkBuwpxn/kIG7t4nZmTsUdSQaAOx5GvisN1YNzGxmZMTZExhBiNfd8S2N75sbwsEL2xLTlf7FwqSbDGSBX8Sdnctm6nlCqrEUGUdQPnyTNLn8pXumIcSbX1EGvwlir0UMUlFazNWbdybjy3ZK2yZiOT9t///nfcPiQF2NSMUdhAVKIhaIosfEQs5s2UGf+cM3YOcwZBatiYbO9ENS+2XEplizDvM1YyRxFQg/+HMYWgDzJ3mb9SgL3JOEIQIv6YTBTmPElKYJuHVKIw23lxrRtdTYx7zKsIwYj4Z8qs7ICwnX9+mesJli5mInN/85UCy4a5t6UqMtzfMgNN8am19VwY28sMsmGdwtjMGhlbgAz4/JqYMRu7NHUwU2tBhqkTjURk2lEUFqkYhLJsXyCEyGKWcMqMQ5zbiEc46RDMWFzi7KWUIIZFqmg3nH+IcsVSyvzO+/mSv2XDogNnIRlRlHzjeuMExgHNQoxFAhmHWSZNWbDAJIOR682iAAMOoxRDOVuA4NDCoVa2ExrxjPvJOeL4x4Ckr+FQSrlnD0I0mSkISby41pRGQsBLucjFQK9nALNYwRinf6UQhQExoaWSRDglU4EjgUhYhGGcv/Ql9jLMylimgsU1i3ieq/xCkPdwEBKVyz5vKSDqmH2/sn2hgPvLoj4ltFXvHvM88zwNGjQoiSOFTBzEf86bgA7EDMYPxjOeJz5PJUDQd1tyZJR9rmRt1ts3F6dcERzvKfcZZrxkbzPGSsrbMUfi9E6ZhcU9pB2COigzx7jJnMS8nPJcyV7lWS06mXFYEv1OQA+CCmMrjpWyRGFEK86Pvs28iOOMgB4cCTj4ydxIOVfUe5aZpxBXKAObYo4slqnMssIQHDbYYINY0jjVs0yfYg5GVCoGX3AfCD5o5LjJ9c2ydMoShbGr22JH8TfFQMxpBVuaMYMMdOZlAnkQh1Pvj5gH4QSRFCchQRbYPDxTBCPwXqosGeZAHMy0wzjJ+oVASyrGYFuzXyXzFEFk9LMyHbPYG9i6iKGU0c6y/gm6YH5kfYGdgrBT5r6zkM+CoXpK/hnKl8UvA4QaHLBcV8ZiBH7EI7Y3wPnLNU8dKJWt4YrwHBMYiQ2UYu3aUsYbcxeVLFKVOsbGYQ3DebFuRrRiPUU/QzSlr5e5PUtLQY3MV1wDXqm3aGFszLaJqUeq6h2tQeUhBMtUcD8RKhHLgDUUYzjrGHwCzNUpYHxgvmCsAoLWCQJFGMZ3kDLIlSBExijW6th6ZB0SoIbd2ZI4XwaMDzxDWRll2kWA5zpwn1OVamcuZC5mDixmIzOGZOXwU4CtkaI89NSCT4S5hH6XopQygVKMzVkgcx7GzbJKVk8JXH/sbLLUy0r+wF4naLYtUBK9zH26GTtYOwHzAgEt9eYF7kXZtkjeP8B5VVHFQ0TKQVFYpGJwiOJ4prxKqn2YWgJHNxk4RApm4KhkYYRzmNKkKfbUw/HIorq4rxm/4xDeb7/9QsqFLosgXiz8cJ7kHSgYN6myZ3FWkRHEwoBzLUbSUxYuBYjALG6JACYrncVYyr0S8+y4446xFCgOaBxWKbJGi5AZjeO7uODAocJCIFW2Lg5tFrP1Ss8SRYrTLiVZNh0LMEpHEn2dGqLJW4p6ZYFdzOwsE8ZNnBY44HHW/P3vf4/XmQUXwRepMijoX0SZFwMPcEDjNEzlLMvvo8weYzhwMicVY1mqaFwcoll5Ko4BRwpZLKkWmATJkInTFsoSJotQTYD5kYoKOJ1xnuB8R3RohLiD+JpqD7nJbXFQLHfK+SNaZkEBZW9xkDkkMzGL5zrbHxyHYaqKJflnuejsJeORvl3mPrd5eHbJBAeEDM6ZIDV+TlkuEruDLEZEMrbwKIpHKTOUsfu41kXHEQEG2CUISmVCvyqK3kUYz1LA3MMWFjhcDzvssGhPk7mSn5NwupddWrilfSIzsQHbnr5H2e4UYyfPC1spUHknvy86wgpZhQi3COQIs2SbZlvYlLWW4vsIKsqDfUC5ZYIyeeYIyixLFEZA4FnFpi7aGzxr2GHMlQRIlg3zPdm59DOqhGT7kiMa84yndLhnNnZRSGArDwJpUgVAErhb3IInm6M43zKF2XqwfuGZ5cWahqA0bCOERBzziHcpAk7ZToI2sLcRp8n6y6owlV3VKgMxMlU1lKmFwLRUdn1GPhiLe8ke8Y2AsquZ+Iu9iTDbCFg3IdBlgUI8R40Q65iDEOeyymicf7a1E1tNlFmNJg/rM4JoCKwtwrxVZqW2IghnBHviI2gPe68yZ+ATYe/wFPCscp6sp4p+EXx9ba2GUCbM2dicZW7Tx3olK7s+OVLa2Dwv2FcEPuRtW9ZRBOPxXKXw/WHX479WFBaZflEUFqmYLGO00YJwa1kyODg4Hj7HgVQ2RNWfc845cUGLiIZ49NVXX0WDnNI+ZTrD+V7KntIeP+MsaW3Bz9+VRVYyB+ccP+MsawmyODInXtlQ9oxrQLYGhiLObpxzlHhLJapkjklEFLI5s7J+3GucWCkXnTjgcADi9GYRhqOIrEqyw8myTLH/FrDwIUsVR2ARRAYyHes5tKYWMvyzsu95WOzQzyk9my/VlEI0ZCFPVkwxkANHKcJlijLwGZToREjhXHFsAE4G3qMse6q9x8gSxamMyE80Ow4cxGjaZExLtdgnqIT9inFaEFySZWDzfOP4TrmXMeMywTI8Q/QjFvQI4Iccckjs72UudFNlCEwOxqgsKxgRlL7E/WQMQXAgezmVIEyJNYI5EAT5uTWxivK0KUoaU4aM55VnGdGQcRMnNOUL+RlRHKcdWYBlBk4RuY+tQfYqTgv6OXMxASVkCZM5mwrmCF44iWiXsRNnZDZ+pLjOQFsEaVE6EXsHJz9BPWSCM56WmUlQHJc5R4LEGg39msoVjBs40Rgnue5ca4JAys5e5Xt5TY6UpRzp29xbnlky/fNBNAQ7pBKFs30iszmaPo09RhAAfZqs7BS2H+MmInReEAYyV5ivGEP5l/ufCdVlQUBLPfsekQf7msATSpayDmA+m1bnKGsF7Ey+l75LNZ4sY5jMIexr5o2UmY2I6wRUICBxzZnDsLsQEFnHpZpLsYEI+MSupuwr15L1Dc8bz1Ojgk7zzxKiLMHVKdc0gKCEAICtgEjJmoYMeNbyzCVko5cZBEDGKEEVZKoSTJ1BUCLvs91SinmK9QrjVkvQt1LZ2FzHIggbbOFBv0td/Yh7i3iUBVpkYBulEj7YPgzBn+e5WL2CtVyq0tUXX3xxsspZrUGgDnZlvRLk2JkIlSmeZdZrWWAHtiX3mWoaBF7wrLXFZpiWCgsEJmHnMS8X14rYhCkyiTk31m55WGOwhsXGZ8xKBdeZe8yamQBy7BCCP9kGIOX2ZdjQ2Z7VGbTNPMV8XWafZ/3bHrZ8wSfCGEm2MHMUawtsPbbIwzZKFVBDcBoVcRij20Owg4hMOYrCIhXDQp6FBw6SlM7P1rJkiuWhMCqIvC6rlF8RHFM4wBEqcZhgSBDdjmBG9HOZDgUcoFkWUFYquiXKzgrC6M+ynPi5tVJfqbKhuLYY5DgJcRxlUbI4nnHeIKbl94ItE5xmtENmLtedhS6LAcQrMhtTOUQRbhATaIcS6DjtyFzAGVlmZkoG1xdnJ88xr3rl1jj3svfFxBDnOS1Sr4+nEjfYNxGnAs4hHK04/CmBzj5N7MeFEzYFnDfOMMYvFraZKIxgyf1gwZnKYYWDhv186d84j3D0k+WGw6ilfYzKGq+zPVZxCGblqnCEMnekutbA2IGTkOoRmWCVjZdci5ROhUaB44TMcxy8OGfyAVMI7ykhUCUTjPi5tZK2KbKzgT6MQ4w5mWhzMt2Yl7Nxk/mT55trVKY4jqOC4CHaxaGAuAIIWdgCVJpIBc8MzzHtM2YxTiKmYIeUXWI2DxnBBOpklRR4rpkneQ/hNMuULhvmf643InwjyxkDdhjOVxyBiHSAXYJYXHZ5TO4rDrK2UOb+bsWsSe4rTkgC4ZiXysxOaQ2EaJ5ZBAzGE4IsyFhmDsFBmKosKM5WAqTIFi3a0wTGZcGvZVcbyFc6KFaZwObkuWbdQRAdNtq0OkeZC8kS5Z4yT+AQZQ7EJmEtR/+mb9PfcdCmEhgIzmLeQpjMILuT8yOYJ5UozDkT5EBFFmwv1jaMaewZntIGagnuKevWVOfLfMx9RcgiQ5q+REAPQi3PWmZfU52HAOAyRWHmJSpbIZQi+GdwnbG9ybhMEVDM3Fus7MS6jeeJcSzlvFzMIMz2BSdIL+Ue7dxb7GqCO5ivirZWqmo8rFGZBxkfCRgrVvBItUbP1pEEsaQOpgDGX+xJgtOyAPViRjTPMuNJvoJd2RDMylyInwAbjLGcdR3CaUqBnGeqtT3PEaxTgH+p+ExxjRHeCQRNWdKayh2I/wTMc51pF5uEuYMxNBWsXYrnzDjNfEwySuotFqqAsZmS7ATwErDFebKWYI1DZYtUa0euJcHCzIX4OosBnoxt+S02RKT90alWDIMTkYaCsxkHLE4GJlMW93nxEIMdx1IqA4KFJU5wSlBhsFJiBMcwDlEco6lhCEJMSmUMFwVSHGL1HK5E0+G0SrX/Kc4qAgDqZcMQFYszIYWTFocRxjciWdEIZvHLwheHZQooVciiq1iaCMcZmUocW2pYeBIdmrLkGH2HZwknME66YuQzCxHuLdnZqeFZIuI8c9I1ogIBAgNCYbZvIMIDEaosBlNFz1L6i0xpyiay1ytR9JkwTCQ2AhPlKVPAWI3jgHOjbzGG4bCir+HAQyhvZOWH1HvLAYtMHKLMEYhW9HNgrzWCe1LtQ9pIECGZi8n+wUlCHyZjlntN38IhmzLrK+Paa6+NbVexZ18Gog2OSuyRRvSvejS6XTImeJbLLmPc0vjFuVFSud74gsDV0l6O0wpjJo5Y9nUtBv7h9G5EcCIiC6/UpUCza00GUMqqFUXHNzYXzzG2D+NjMXO2ETAmYwNgd2CfMEcS1IFwVy8TryxwAJKljGiEmIHTneAtBBeESuwhMk3JXGEuKQvmJ8ZvxASEURygjOk4+jkWgi4QyrMKBNMCQSRUJMkCWABnP/MG5WYJSMOuTrmuQXznfBCkizAv84zjiE9N3gZKDdlPVJQqzhM4wMkAJ0gvxV7G9Gec2gh29Fnsgnq2LX2CykhlZnXuu+++UWTGJqBfsb7A+Q44/dl2CPusUWAX4Degf2fHUTZUwuEapypD3hKM1fSnLGipUTBOMSazJm50ph3lz6mOg63HeF0cs5jLygyY51ypoMCzyrkWK8Php8AuSrV/M/MzVb3qBZDw/BJcwh7hUv51576zhiRgPHU1CfxMBLW0txL4KWF+Ikg82/KJ55n5gmx4/LzYYSngWcZ/2hIE6jVyjhKRKafjhcmITGfgGMSR0FKkXooFbgbZZjg3EHQQDTkWjAgWe6lLNJE9gZhG1F62CGHBzyIwlfFAZD2GUr2ydUTRcS1SicKUxiRTo3huLLAvvPDC6DRMlblDsEG9qEjuP86UFGT7jdbr17Sbcq/ZzEGI85uMlWIpVvp3mRkFiDfsHYhBTgm7eiXZGwGZG0TiEvwAOOlwGuHgSOl8p9+SlUXpwqzkfOooXNrACYgA3uh9ociyItuNgJ38efIs40AhwCaVKExwCU5uzr0Y04cjI8W4zbOKgMPcQLt5cCSx4OwIkCmBc4yStsyHCMFk4iASIq40ykFJVHej9xPOIGMEYYVrQOAO4weOUuYtxrhU4CwiA55/i1nS3Bcy1FOBQEQJdASzTBhlX2teqcYxBDucYgh0Reh32AOpRGGC0BBKGcOKQg7O2FSiMOMVIhWOqXoVLuh3KcRTSggiSDZCFCa7nkw2xkwyRxFIqwiowLFNtnQWWILNlYmHiJbZ/tWp7BDWFDxT2APY99hGBJuS0YjzkLEEJ2WZINbRnxmzGUu47jifEZ+zrH8E6bZmkLcGdmUxs45MM5yjVM4oc5uQlmA+RqzkWS4KKDiGy84uxI4kcKatNlKK/SKxq+plvGFz83ynWi+Tdca6cXLbKfFMlV3mlz5MJaKiTYCwxTqazxsJzxjPLqJLKlGY9XIVwhy2R8qsydYCK+jXVZRexd5prSpK2VWmGDd5UaGDvtRS/2UuTbFupbIU41O+FHsGWfesocvse/icCOagX/FzvTVrivLRPJ8EYbUFMnZTbenFfWQtwbHQz7PMZQLDCBxPBfeXSikzkijMGIJNgB2ND4QA52yOZH2T+eXKhvkgs+eysvtkh1cVUCwiU46isEjFsIjFUMxEBZwoOHIaMZmyfx+OIxzg+WhvFkYYcDiEU0TzUb745z//+STldGmb7D+cV2UKpJSzZa8e4NxaKu/L+Za9vxqGNveS769XLpnPcDikErFw5mOQkyGdz1TFqcV9L7ukcQaGJ5HelLIh4zzfl3HYpcxGYjH0m9/8JmZf58uypioTnkHWFRl2ZPazL1RRjF5xxRVjYEAKEAq5rmTDcM9ZyJO5zPVHqExZ3peyQfQxHNGQldYjgyGFYzBbVFL+nIwFHLA44SnV+MADD8TzRtwrWyyjxCljJM9yvQwn7jdjd4p92IEADpwLZJ/hXC86a1KJljiNcOxzn4tO19QCfBXglOE55VkiI5pxkgwOsvBxijOm4zRKlQWWlfMrWzSZHAhFzL/0MTILMwhywNFNhY0Umf88T7SJrUFbRaEyZelE7BwELLJ0GJ9pm8oDmUhcZsYQQihBZzhtstKJjM95MqdNa3s5TgsEdSAwINA1onJFHjLo2NKBwKl6gmSq5wkHGdeT+1ksh1o22PAE4eF0brRYk4e5EHG6GMhBv7vqqqti9kgqUZgxgrkfu4/xkuuQlQQFBGJeKaBKB+fNXEnAEn0qe9YAW6gM+M5iwAgCBkFZjRCEAQEJMQcbiHaZtwgI5PnGDip7b0yenbYWl0u1XQnXtlHXNw9zE/Y9GaysXTNYr3OdKSOdqjQn60ay0Fmz8Twh+LNGJvAVG6HR2bRZoE3K7Qewgaj4k7JUdD1Ys7KWwb5r5PYKrFPJpOTZTbV1REvk14YE6vOc8/ym9kERyMKzQ4WpzP8E/IyNtPXWW9fdb3hqQXDN1oWt+YHyz3cZEGiXif383JpPrcygAL4rb+8QUEwlL3wvrFFZMxPowr1OWaqbIFfaYSsv1q7YSBwLW6WwXk4lRjOGsGYlWKhR23ZUDSI461bWrOxbTXAN6xsqQNL3Us1RgI+RwE4qmBB4R3UWfK88Z41ey4rIlKMoLNIOQEhiH6J77703Rjwj8OCUpfwck2qqBTYTOM6jYiYpkX0YcohqKQQORDvOE6M/D85CshgwICltWBZk41AClAU82cCcdx4WPggfZWcoYwwRdcpiHmcUhlE+ChQDDUcSGQZE1ZUFWTGZCA4sthDQcHrjCGTxiVGOwwwhoCww9tn7KgMHFZGKZOxmCzCMU7LBUkaB4zRhMYlx3EgQjXDQ4UygdHbRaZiyLCmlkln05p0oRGPTtzimVKIwzleuNaX1cIwR4EAkNmMX7ZIRlyr6HeGOhQ5iA4EmPGssOln4c95lglhFRj/Z0JSMRMTKC948yyz2GddSlcUiw4pnmPNNubgrQluUMOTFGEY/R2RhnKHULXNIR4R5gUoWvIh+vuuuu+JiG4GU8z799NOTtIsjB0GFuR9BtJgtcfnllydx1pHlhmhJ9H4+2wlHKc8Wi/4UDnmyktmrkEohBHs0EpySOKvy4yZ2AJUkcMQzbpb1PHNuZBGSKcK5Mj9wbfPwHkEWqcoNYwsgbjRaEM6CEAlCqxcclxLsEF7MUQiUPF/58ZMMvLIcwdxjMs+z7+d54p6nrPiTn4uz8RmHPsIgWbJ5eJ/5GIdpKnA84xQkI5w1BM5fbH7K72OjpOSyyy6L7WHjMl9i4+LwppRyI8rCpxLaW+LII4+M95MMfAI+6H/Y2tgIZVesYR/OKqhXMrolGMeL68qyYN3I2iU/VjA3Y+Ni97LGSgFjB+dPZQcCi/AP8B6lw7FDU0FAHLZGcf5AsGPbq5SlyVlDsX4jiIhnqmgDpQqaIpiXimIEtTIPF4Pg9ttvvyi8lA39CnGf4DTaJaAlP0exnik7Az0PgUIEqCEUIkzTPv2Z658quIkS98wHiFes3xCDWc/R7xCMy65MQ38iCYL+S/8pXk9savwwZQcsEUycv4+MT/X8Pazhy6wwRRZ/lslP/2LNwlia9+lxDZgfU/kYGS84L653fhsxfuY4CL5MJQpzLVmzYQfRh4v7gdMfOloWMVvCMVZi57GGYB2J34JxLNV6NQsmYWwkOC1vZ/G8cZ1ZQ9fbOk9E2g+KwiLtAKLqERtwxuJoB4xjMk1ZDJZpNGHw49zPMt7qiXNZqdBUWRWIsy05PRFaWJSVbRyywMDxzHUts3Tw5MjaYsHHQidVlmoeFhx58blYjohjyJxXZWbn1CsXXRTn6FMsqlOWF8YAboQDsN5eSRjkPLOp98spwjND4EMRMkrp9zhJU2T5ISSx8ETAymChhaOdxS+O4VQBAPQ32iBrlwwKFh2p9jAGFjaAqEJkf722sj2sU/RvvheHUSMF4QycjyziEYA5R0qE0rcQQBDMOzo4FHCe8ELExHmYCvpXa+X8UkEwB/e0HinLhGNvMO83WhAG7KB65fqwT5gbERPLHMu5vrwQ5XDEEZDXSLBDsIHINNt4440b2nbm9K2C1my+MjPC8mMz/ZptSVJVyyiCzY4oiihLUCCBaXmnJ8dGxgz9L5V4yfOEExAbFIGD0saAUEngKw5agj9TgPOZ+YhS87SVQZ/jd8T5svszAnz+fhffA2yBFE53gncRf6nuwDXHzmOsaoR9QHv1Akppm3PFzicjrYw9o+uVjG6JouO/LLiv2LoEN+TBBkTYIug3lShMtht2X70sd7YawP5mfi4bgg2K1537S7ApwS6ptjcAzqcKG4jxsbXxKVX/4rpSTplXPVJWS6EPEfRHgMmZZ57Z/D7HQt9mTkkBiQ/YIGQyMi9QtYXgHWxrsgzLXssxJ+EHYi2MXwLxl4QM7F76Otc4dUYpAcVc0+JanbGcNRWBPGUmCOQFeAS6YpIHNjeBiVQmQpwvG86LeaneWMG5ItCngnmotS1DUlWmqRKClhFmsyAaAhLyQQmpINgAnw92QVb5EggK5FkjQC+V3Sci5aAoLFIxCKRMmIgnlC3MRGEcVey5QXR9maIwpYmIpMfZecopp8Torrz4y+IEYwmDLZWBzAKXhQgGRN7higFJlCiidQo4L4RZol8R8LL9TTK4DmRIp4A93Vj0kAVdbz89ylS25JCfmrZ4NRqcX3mDsCpYaOIEJGsg1SK+HvQnxOhGC8LZM8XYUcx44nnCqZZqj1ucwMX97ICxg4Vvyr2j+W6cGOyRSZZ65gAm+pnFSCpwilFxAHEwXyKc8Ys9qYi6T5GJxaIdxwHtVrHvGc9Vo4WkRlLPoV8PSp6ldNIVK1nkoY+lKumHQEnQWNG5jbCF06je/rdlwLPCdWf8anRpUAJWiKQnij6fjXTzzTdHYThVdHv2/Ob3+OIac38RMFNlbpBNyFxw0EEHxfudlYrMwGmYKqOAsQMRiyzlRgYA4Azllc8axr5OXR6T64qwQbYulW8QYvM2NW2XnUGMEAyMT4xTKcSi1kAExsmOKE1Z0EwUxi7CWcl6JpVzkAohrGkI3mIf9HxFETL/yoYys7zqvZ+H7UTKLkmajctUZGGd2GgnN9UUqABEcBzPFqIKtg/iDiIlv3MPyF4nozVFyWhEaUQdsnRTB4Fia2LXZ3t050E4zfajTwGiGdV4ivv3Yq+wfzbjSornnLEkG0+Yl8gGy0qyp4bqHVVAEEMZgQxTSrbfbBXgl6CyA6IOomwG8xZ9LlWQK0E02TqJ88f/BWR1stbBL5ZivYHYzLjF+SFmZWWrsfWwi8oO7qBaGuN/to1YvWAHPsMWS7WuIND01VdfjevkvA1CuwjGqQK3GTMZM1hXFEVnfGEp11GpgnTaMwQOpfR9tAQ2X0sBLdz/lH4gESkHRWGRimFhy6KunmiTajLNFtgYwWQSsMgj0w4DkQVuyixOwGhhoUsUHxHHGMNkOlI6GgOdxUkqMPo5V7JVi4vblOVNKFOJk4Rzw4FRjOYv00lKgAEOmr322iv+3FqkL32BvysDHAcEGVByjJ/JFGkJFibF0mTTAqWv2IMqgxKdLEIwVIsiLeJGimxxRFCydDiOzAndKLjWnNdbb70VHTlcX/bWpdQcmSSpskdwtlI2mv248w5uor0RpGk7FZQipR0cSIjiBFvQJhUXEE9TRD4D340jhXOnJCr3ncU+JdlxfKda6LJXD0EOm2++eTxfnKF5WNjTfhngbCVQheeKn7mmLUHlgeLeqNMjlBojW6ItUKY1n1VRJsxPXE/GknzQAWIWwUyIhynmaLLuKfPGFgDMx4wZlPun8gF9PF/+rUwobYetg+Obfo09kBfrCMIg+68scAYSjAdcX64nzy7niE3A3IGDEhuBrR9SVPfAzmH8IqCGIDhENLJIssA9MvJTjNl8J8JGSw6zlHvu0qe4ztgcCNLFbQUIhkhVNptyp4xnOJoZI3HAIyJyTNMqWrUE1X8IEAIEtCLYfPm9u8sCIZbnKROKmCOxP5kfCZT77ne/G1I6B3mGi+VegePJHP+pxs16wVhZAAAZS2UJWoz/CAttIVWAJgEc2B2M0YyRjQSxl0CHYjlwSpQiipN5iL3COMP4VmaAMXMgYyf/ZjCOMn6WXTI7A1uLORcBpfj8sF1N2cEdXDvmYwQ5+i5riuJ8wPvMTSkDBAk8YH90ArayvblZXzCWlp0pzHYzBA1lP7dG9ndlQAUB+g3zPT9j07dEmeWjEen+8Y9/xCBWfiZYvSVSlo9uadwkY5XnlnkshQ2Er4m9qYHnhxLSBB5gn/CsYf+mgkAdxg9KsnPuzI0IlwTEsX4rMziRLX8I3siCmBGF8+NFtvUQ9nWq4G3Oh7apdMT6kbkYG5jqBwQK8l4q8C9R1pi26ceMaVQ/IJi77DUUe+hSoYI5l58R5FtbB1SRPJES+jLrmUYHtmDPMw9mAWr5sYXxNEVQnIiUi6KwSMVggOKwwplSdBpiNOFgSQWLWxZXZMpkkc4sBMhMzvamSAHfS5k3su1uv/32uBhggYAzFIEpVbuUDXrllVei8UIZxUaCYcT+Ho0o5YK4nUXO83NrDqMyI+xx5GfZzvzcWrtlixo4yPKRii1FLUKK8kxABicL2l133bVZ3Mg7clgckrWSAgRQFrRUAcDZzfVl4Ulp+jL35wYczHknN88VgiTZI0Qks9jE+U+wCwJLCpEU5wHPFM9yvvwnYwi/X3PNNclEYRz5OBUQwrm+LHRxfjJeU74pVRYcmWeUPGtpz6syxzT6T/YM8XNrz3LKkt2NhOtar0RjHpxYBASkDPpAHGPrCPoyTkOyJVhcs6cvc0iqoC3mCgRgqmUQVITDKMvwSxncwVyBGNiSIFj2+EEmSj4ArNguAkCWIZUqmAZxAecNggnCDnurEXix7bbbRgcKDsqsXH2ZMCdVlZGEXdeasypVBhoBalxnHID58tXcY8Zt5okUYhKiN/ZtS6TIUibwECGacYxSmYwb9CmuAeeII5S9YVPt44dzkGA0bPo89HGuRfZcpYDnmkzkor1Du/T7MvtXVdV48hCshd2LHYKtxRoqn/VPX2+t6sS0QHBFvXGEYEvsP4QG7AdEDsSdssqVY2siMtCXEcmweWiLOZmgonvvvTdJcC/zAO0iChLMjPOdrDvsAbKjEcHLhGtHYBDXkiBEsuvzwl1WCh7bs8zy93kIouCaIiBhE9C/6HPYBYybVPsqc7/ZvI3ZyCAHbJxM9OTn1touUxzl2ciuHz+31m6qfX3z42YxUIwgSdYyqdbL2NBUdiC4lkQB/FFHHHFEFN2xe1nLpgBx9sEHH4zPbb48OmMK94H1c9kVa7Isf+YhfCT1KpgRdFHM5C3b58ZzzHhCsCPnuv7668fs8JQV1ehXzP/YJSQCcCzY3CSGIOCWCT6P7Fz4mTGsJRpZRa5R4H8hYIpgB+bcYkIE81SK/sWcSPIJojBzNAHMBCOynuRep7T7RKQcFIVFKgYH5JZbbhkdrxjFLAKJKmRxS8Q/QkMqKJGIkUhmEIIOxgIRyjgoiQ6lpFAqWMimcli0BEY3hnCjBWHAKG7UfnqIj7yABT1Oo3pZDS+//HKrRvOUgliBQZo5PHEQ1TP6WZDUy5yZFoiq5wWULWQxS59uJDjksj0j65G6xB1ZQLxYWOI0SiUesfCY3J7VWV9PFeBB0AxjZz2HGM7a4t5vZUKkc3aPyVDJsp8Yx1mMlZmRlIfnKctwJ7KddlKVQUXoJTAo+7nMTM32Cs9nS88ojmciz7nuOENTlj0j6IDFO2M4WbSIHNx3ourJ0EoJc2O9kqgpIYAmExgYuxCUOI5U5X0RxaqG7D6qpDB+kM3AOSPeEVTEnEnFh7JEYfZta+vzi8iEozYFxSyCRoH4zhiGYEq5XYK3gDGcjE8c4ilEYfoudhdOMuwdqgIh/CPQMmfk9/stAwKxWC9QZSBzahPwyTyBMMqcjEiMPYgTL8U2F4jCOPXJCiKTkL5H9h1OfsTBVKXJAcGO60sGGOMIQiFBoOyfTRBXmVCBhSo8bYH9MVOVdEQobGmripR7WWPj0d+Kzw1BgAiH2D/YSexDX6wIMC1wzRmj6OPZ3MAYytqZ8QWhh3E0BayTEZzZu5qqVpwX154xpexnGVZfffX4L+eLwFHP1sUOZjxJYWcTuMQ6AiEnv5agLxPcisOfLaDKIj9HNdLezO87ys+t7UNaJozH2TqJf6uysQmY4kUgIGIOcwj2CX0ckTZVYBx9mueYNgEbkP7EnMUclaKaFzA+Ic7WGx8Zz7DvU4E9wDnj28MnlMEzjF3CuRf3Gy4LbEuqKWADZKXgywrWmRy77LJLfHGejCWptu3IB7ulCnxrz+CbaW0v9lTPMgI78yLBiFRrI6iZ54u1K4k+qdoVkfJQFBZpB1CKichgMvBwolBKEOMUA67efp1lisI4SxAzMnBEE9VI5h8CX1kLegztO+64o01/SymbFAszIl6JrL7hhhui06qRZPvpsdBv5H56ZFPidKYEWD0HC87ozPlQJjjlEJVwyhWhTfp2KucNTkAcvo0WhXmG28Oeyqn2Ap+avWVZBKaABQcvHL/5xR+OSLKEy45AzoOTjnGasQQnOJkTwMKHFwJi2eUEM3AmMGZTfouqA4zRjCvsyUpWRyq4j0TQ58v64VyhbcqvdtRFH+dNhD3OZsTEVI6qyQUd0C6ZSjjLOiLMCewDz9hNVDn9CtGB5xshKeXer1WQZYUAoiTiQrZfJU7SMoUUgpXaKhClLB+N05ugwyKMHRwjogdZu9gFZY4nOEGZm+t9Z+r9zhDJGKcJsuS5RrTEGUz2DJmAZZZyJhCKLPNsz14EIzKi+D0TH5i7eBEQ2FLFiWmF55UxE3GB8rOIwTzTZH6lFCoRwhGwqECEKElGFOdNoBbBcmVCkEH+WaG8LveXzCvep/IScwbXOkXpVSCAKdt7FeEfRz9Brymf4Qyq4eDsJWiJfoQoiW3CGpa1G05igooJ7ikzk5Vy75RZrTcfIKbwrKeEsYkMfPo1QRXYeakCHzPIIOXZwQ4oCklcf8oOF/cbLgPGD7JI6wWXEniJiFgmrW03VKS1LZFk8uQDV7EtGa8RdFg7EsTDuEm/SllWGKiGk8FaKmUSRAZjMvYmwncxgJvKUykDPkn4IKCI7GhKwvNsM5Zh6zK2pEwc4HllexwqeeQDMgmWW2WVVUptC3unJTK7F7DJyvSHkX2clSSfHPinUm03UBVlB79NCdgdrOFEZPpEUVikHYBRSDQ5r0aC87GeEUr0IE7JMqO8caK01SGUqhwpCwEWQmQoY5wXy61h1JA5nQKEIsRZnJ4sfoqGMIEBLWWYTo3DGaGMaD0W9rwoa5uH9/i7sjM3CGg444wz4s84MOrtO8X7KUpjZuBg51oj/Kd22OTB0YojsiVwWqXavxCHHA5C7nm97G+yp4t70JYFDgWCD3CK0q+An3HQUQFht912K6UdyhHlRXeyNlkEISAhntEmC0LEylSiLOCAY/HDgpKACsr/k12Hk44xNRN3yobvJqIfJ05+WwGcsogBOMXLGkOKcL44UfKiMA4kMsAItsFJ3NHA0U9U/yabbBKzgVJl3rcUdMDczFzBfnPAXJVynzUCC9gjkrGCag71+kCqvaooBYqziH3RyVACnmmCipi7sioQZcOzyzlzjbOMlTyIaimeZ8YNnOBE9hPEko2RZAgjjLcW7T+lIHzWCwprNIxTBNAwdpFNioCFqEFVHJySCEnYX8xlv/nNb0prF2GDDJxigBL3m2yolvZXLgPmBQKoEIMzmwebmjLwVOQpUxRmbMiXvaQvIU7mHe+AUJdSCGdeoG9PichTFgQCZvs4p4QMc17ZPrrYfjj782sXst5w9KcqvwqM0/QxnqGsf1O5hUzODTfcMFm7rGOYG3mRIYTdh0hNti4ZYYA9lu2TXhaMHQT1MlflM91pi+CalHsXYldjY5N1n4mz3G9sspQBedi3BDtwP7FvGc9YxyIqIVCXvbdvBmMy8waCVT7AFr9A2VnCkDJgZEruMfYAfameDUQVFSp8pIDAeeYp1k158R+YJ8osUU7gBmt1nlnEYMZqfm80iLDYd1TIK54z/rAUojTzE+sY1iysTylvy31nDcs4mnL+IJiXQF7OjX7Gs0zQGKW6WUen8n1xfgSVsj7kPmPTYhvwHFNhg/PGFi0DbIu2Bpxh8zG+lAU+jraOI430DTUK/Et50b0I83VZSQP4+Qi2zK8J8bHy/R1lSymRGQlFYZF2Ag4qoo/zEXQ4RVNmyOCswkhgT5H8JE5GGG2XWWaZyEhebYkER0BNAdcUh3tLTsAUe1HlDdDWsp/LjJakz+BcJSIUhxWO72JmNAIHC4OySxXhlGGhiWGKo5+Sp8V7gDM4ZRYvTlcWm4hniCpFpxz7Y6bYE5R7XMzSwHmFsMGiLJ+RXzYINjjGcKbXKwvJNU8lnBFpjDOaZ5f7iyDLnpiUyirTMcl5FctWF/tRliWVcr8gniXuJy8EF84fZxHXHwdtqsUmTgvGZO41mRLZPvA4BXEO4shKIQoTPIIjFMdBsU9xLASWdCRROMu+wUmCcJNqz77Wgg7ISsZZxnNF9DvZbwR8tLZX+rSCqMHzzPhYL4AkVVQ9GW4E8VC5AnElE4W5/vQr+nUqUZhnl+ASHHX1Sr6nyvIj2w2nOtece4zDDigzjJBEFYKyaC/loz/77LM4PmMT5LN2EZEQSXFW4hDHEYyIWpZjCQEeRyFCO+MnczLPFGMaYlYqJz/fjROYtopgC5e9DynjcV7IYL6AYhYh/SFVv6ZUNk5eSmVjAzI/Ii6lFnyYo7B3KR2NaEXfIQsL+zZ1FQuCaMhELvZX+hp9jz6QquITYwjrJcQ7BFMytLjviMJlBx0UYdyib5H9j+1DEFPe7koxjhDggH1F0CulKbnG2EHMlQQDYgelgrkCIZZ/sbmw/yhNTxYva55U4wjbSTAeIjyzrmN9R5Yb/Q7RvcxnGbudCgb5MYw1HRXECBanf/F8cw/KzspuD4FLBP9hb2AD1fMHZNsylQ0BPczRiIXYWUW/T9nZ/wiw9CvWxvh7qEDT0jiJbyLFGIo9S7UB1uKM1cU2mDtSgX1NH6YSDdcenwHHcOWVV5aeNVu87vkqQFlWK4Gn2EXMXSnWrvRpxgnGqiwRgva59ojCBMeVFVDDtSTQoDUYswmAKLtKXT5oeUaENRNzcd4uwhZ7/vnno51dpj+ZvloMpGV+wu/T6AQnEZl2FIVFKoLFFkYRhjEOXxwaRbGShX3KCGQm9WeffTY6qNgTCeOfLA0yDHA+5w0sDNZUGXBcC8RLFieUwCPyGgO9bFjktVTeF0OqzIjFIq1lS3K9y97fDWGOF/cVR2GK61kPogQJNsAYZXGTz1xpFCwusyyOeqQq3801rufY4FrgZChGQpcJ+xHhVE9Zbr4eOBZwhjE+kDWKcMiCkONh/CgzS4bxpz2U52Zhld8fk1L7vFKTlUGtBw4UxvNUjn4cCfX2n0JEIhigI4DDk9J5OGoQCRHuGgXOWBzs9K1DDz00Om+YF3Eg4cBCQGI8zaowpIBnln6dMtuqpX5Nyb56VUlw+qfq19k5I9rhyGg0BJcUg7XIlKYPlLlPZHspH419Rf8qOn9xghOkRqll5i/GGfbOLstmoT2eH6rD4PzESUZbBI3xrKXKashKhPMcF8+ZPl12wCcOXoRARHXaw56mzGs+uBPRFBu/7OxCzpExC0GJIIs8HAtrDDKjUvQv+hV2AedVhEwsqomQ2ZrSEcs6qt58QrBLqhKsjJvYXwRA5gUs+jW/I3ClFIXJbGPszMZnnmHsIO5zmUGI+VK3jGU8y4ihlAWnr3GuiMVU6Ull2zMeE0SC+Jy3sRm7uP88a6lE4byQRCAkYxjQp7EHCLYpa29QbIxi4GUehKWsP9cLopoWWC+QFZ393BrZ36WwBwjQSlk9oqUqSPSrRu0rTF9l7stoLXgX2zSFQEsAIuPFWWedFRoJzxOZ92RHE2zB+IL/pRFb4GRVgICAdcboDOwBBOoUojBrNAIN85XxUpXdxwfUUnAO9hDzBsGPjF1lb8dDX2LrKOwefmb+bQn6P3/XkWDubWmrQIKI6t1/ERFQFBapCARhsr2IlMxg4ZftEUW2DFm8lOYoM2M3Dwv3YgYOWVH1Sr+k2KcUQ5U9ZIjWZFGEc45sjlQlKuuB85HyZ5TRwQn78MMPN6RdFiIs7nEm4NhhcZDiPrMIISoTkYPFCI7KPPkspTJhgUNUNVnoZMoWSzfSn1iYpQDxkKyFRu8p3Nq1IEucUqREBKcABzp9udGicDHymSCXzJmEQ5IsmfXWWy/ZHklZZhBOC8atVBlQ7QEc3JSaLZaHQrSl5CzBNClA2MfZ+uSTT8ayr3kYL1PuwdVIeD5xODMPTa7kOZlh2VxdBtw7BBPmPrI2yJzMYHxOMUbXG0Pq7fmaGoKXcMaSMVwUmrAP8qXSU42bVYjCzP0IOsWy+1wH5gsCiRpdPjrVHvDA2IyAVyxnjEMSoTYTkghiK3NPZWD8IriCV6PAAUcmDM7JvAOeikCImGULdjhi6VOM0ZngTFZjBnY2Qho2dtniGdUiKOvLOEVQIEEI2NOUBSVLhbUOQs8dd9xR6lqCsu+M1dgYiL9sHUI/Qywk2BIhj+cIWzNFdRhAJGPeIOABcQWRElubdQU/F+fMsuAcqehQL6ORcY2xJRUE/9GXuLYEMyGqsL0Ea1bGmny/m1YQEWiPtSpiFusk2i4KxilB4Kff1rOvEYZb2zZmWuFZyoQk5kL6fBZoghCPkFSWKEwQMa8qyAcBNSqIud4xUFmr0bBeouxuo/oz8yCCLOMzWeeISS2tnVKtqbCzy+q3UwL2BiWis8DeRlzvDMZKqkqtvPLK8UWVB7YzY77mXlBxIAWMGwRskdmZt61Yv5NF3FoVu+lpOx7WEpmozs/1ttLKSFlNrL3BupL1ar0ARRERUBQWqQAMMbL6yBDOR8rhFMvKE/Evxhr7zOy9995JjiPV/qatgVGC4I3zCic8AgdGOYt9jJZUZW7z4HilVCVOLIQOjon7kO2FlRIcVTjnuK8sAhFUyAhP5ZRmocF5IZISEVqMFEyV/Q1EPeMQxGFXdPKm3J8TgQyhsr2IwkDEaorAigzKRlNVgHYQD4tZSDgAUpQ1xmFF1hXQLgtu+hzBJan2QOUZom9RajYP15fMOwS1lAt9HHQs5LnWxawoIJuEfarKBjGFhSylmTJHDVnZCGetRWeXAXMQWYw4D3i2GLcJ9uBZI8CpI4BzF2GhLTCelgniBfeR4CSuJwEOOMG5p2ULZC1B2WIcZUcffXSMoC+OFzixUuzVTaYVlR3o14zZBDFlWZ2U8uaapOLII4+MQhaOdhxnxXFzo402SnL9s+xGnunMGYzgQOlXMkhSVh54/fXXo4hFu5kYzb8IHzgNEe5SkO3jh+iNIIowydxx3XXXxeA05hLEHo6ljH5GO4g1ZJAyHjN+pbR36sF4wtjJXsrcY+4rogN9LR/4UQbMt4iv2NWcO9c0P05xHSi5iwhQJoj43EMc7cXyqtxTnMCUDWfu4JkuM3OWcYJSwsUKIgQyMZbw4hgYU1OJwoiUnD99l+ynTKxl7Ka8c6otgBCSWC/hYM9nNtLPEFJTjiEI3kccccRE7SLIU3qVdun3ZY2brB8QnAk8YFsHhHfmRtZsjRJ0uJ+sWYr76zYiMI6gAq4nNkG2TmRrHmxsgriYL8qC9XBbg3U5rnzFnGklnyXbqIzZIgTMEGRy7LHHRnG8UTYQ9zKr0oItVAz0YIwpO6syC+YlYLzeGj01tMncyBjSyHmZa8lciR3UyGpAQMAnQbzYWcxLVDxgCx62tMD/leoeMPcxhmHj86JtkjLwQ1FpIFWVA8DeYdymj6fejgdboN7PMzpUv6LPKwiLSEsoCotUAI5OoiQnZ+TjwMHB0xFAKMK5izMBIxEHAtlRZBUgLEBqQZhslCwrGLEKhwLOI8Thsp38eXDSEOlOO2QF4yTCwcBCf8cdd0y6bzSZmjgNOO9Glo7BsYuDG2dZo6O+6VsIdgiEqfZ3rQciZb29dIgGRsjEYZsKxgmy7XGS1jtnSs2luBY49ykdzQIfgQOnIM5uHFg818XyqNMK54gTgT6Fw59AB8YNFriUOaP8L5lYOIFTLYA4X5zunGe9jKtUDg7GCYKJODfKb7GYx9HPdScTLaVTZ/fdd49jJQEtjGWMnTxnlPHrKCW4mANSzgOtQVlwnHP0KYLBEIgROnAYkZWMEzz1dcbxzhjGPolZico8ZJOkcIgCQRbMj7zo1/RznLIIAcUSlmWCQx97DJG03hYOjG8pnivmZUrqUnKXY6ACAFU1yFrGMZ2qpDFQnYa5AIGBthFx2L4EgZZjSAUOdbJVmCNxRhIciXMS512WCY+gxvg6rTYRGc+I0DhgcfwSBMjWJHfffXepWxpMDsYT2uSVZeHzrCOUpggS4zuLYiB7rWJvEjhGpZiy7U2qdXBOre23SX8j6APnZJmiMMEc2DytQSBCqqo0GQR0YI9QtYS+R6BLimtdXM8gcCAmMH5wD2ibMXzIkCExyIO5OuuHZVa2wN7C9ipCphvPF4E9Zc0V2Blk2/Ms33XXXTHoDgGNtrLKGqnmpTyUm2X/TdZsWWAccyVBNCkzhQmo4H6yjuQ5Yk5EtOR68G+ZIgtzXVu3GkiVQYqvgPmPc2UdydjJXs4IpdzvlPYAYxljCsHM9LUiZMGn6GvMhQQG0jZrxeJaHVGvbFE4I6sWl2URMoYRuM+YVva1JhmAbYbycxNBHjzjxbUUdkFr20BNLTxLBHEgjjKG8Mpfbz5LsR86cH2Zj4Axcu21144ZtKnnCtpl3UiWMjZeVnafPsU+sCmyZpl/aBNfTKO346Ft+nNmR2PfYnMyZq+//vpJt5OoEuanYiUxAhAI4GaeLBvmIPxbGQQ3FN8D+lcjM/JFZMpRFBapAAwWnAZ5WLQzoRfFhXqZaGWBA/KEE06IBkO9dliMlbUAIpr9yiuvjIY+Yne+DFcmCqcAYxvHJ4sRRCMcFuw5QgYQ2Ros9FMJAZS3xcmNMco9RyjD0U/bBx10UBS2Ui4EssUmGZyN3kuERQjXPmXpz9YcG5TOY8GDIF50AlPyLkXWCE6MokOF64CzDkElpaiDWEeGH47w1H0qD88xi8xsIcJ5kvmOoxYnMEJAmRBZzaIOx1geFn/caxwMLPYRAFrbJ2taoNQtDvZUmUctQTANTl+Ew2KWGRksiOGtOebLcB4VtxuQcmGcJsCCFw6zzAlOcAUOOhb2CGgpAh6Yp8j+4dlKKUrWcwLzTBHsUdzLj/eZv5mzU0CwFM8SIkMj58iWyu7jkORcERsIBigbgllw2LC/GE5BxjDOH2EBsbhYwrtsaI9AMc4/qxKT338XkaMMGA/5TmxLHFIIKswLDzzwQEPGMBySiOwIJ9j6jdwSJQN7l/mYQCqEeDJXCUREZCpzSwds27bsFcx6hvuSei1VhPufZcKnCjzF8c21RdDhXzL+EDKx/VLde+w8bJ5ipmi9EqT/1959gMlWVen/PzOj46gzyIhhFAdFQcacRUUBUZQkKkEMgIKAgIJIMoGAIIooQYyIZAUDSlBACaIiCCoICAjDKCiKATNj+o/j//nsefb9nXtuVd/i9t6nuk+v7/PUc/v27edWV9U5e6+93rXe9cDCtqTiemIGd402ku86x2uMwsnjhTzcW/ZFxVMKAdm0u68VGddKPutqtO9av3S8KSIiZhE+upb4pWl3vbGgrTXmKNvaLg3CYXYIKgWRjIuBNcKZjQDrevL+Wl/Evoo7OBIoPq0BYZbDAvGszxjI/i9+J5haM/pEnsKZ2HVtv3KG1EVrfeF8ULKL1OfYfn0zvdaaHaVirnGjlmp3LSsiEWOLw8x6VVzDxUT8NarQphT2SQV3qG1T7izhPuVSp2C5rw5V+7x145RTTklfO0+Id8T3CuasK65zLonmSQ8N1y4nxDZet/2jxugy11O+prrfbyPPLB8UBMHcJUThIJgCZrzphmnPdxCwOYy0ceiatGp3WRCYqppkAzaqG6ZkUE4Qk6DTAaTqV6BGHK09A9X7LNhWkSl5IOmdOzSI4jWRHNKRLABV8VrzkDMOnU4OuA55fc9N9BnrDPL+92lb47lmqjAuPU8vQ+TPsxslOCTYJSQl+msLtdYSImifgnCmvW65nyVWaqDilb3dTLPyHIoU1+h0rCUK5zmkfYvCusHzfPAuOoLa4wdmC0GSQGMGlK9nOkBLJPm5oCxEuyyUKtDSveCwrWu7hv2+NcT+2GcyFDooXT+6zrvoemO9W0sU9pp17PZdNPWABzwgxUEwV091vc4/X9ey3YeEEcGGlWAWd8QG4iOJM24WXWG+FAoPddT5vInCGcl+sa5roNT6ZX0W++QOGAlQ8WZpIWMURFhJ3twZrIhJcr3PGXaKKRQeGinBeSCjMNH+oShgVGf8sjBpl5PrupuwnC2uo0nuXT/TvuZK4l71PhMr2zMyxQc+A11JNWJ/Qm+2zXaOc9YR2yrkrTmeBdYKHbP5PnMtEcQl3K0fpa6tcSjkJTaYjWodJQIYBUDgUpRY61xBGPbQEaUItNa5RkFBLhRaGop6+jrb6fRXYC0eUWTSLQqYDc6p9gh5CfcrUUnBuvc7f6bWUe4atVyXphUDeV7XdN+CMLyfCgHEm85W3IfkagjypUVhsZZHF+uXYhKice333hmxpGvCnUEHtudW/MDdIUMMZgk/qjt9WVFkJ7YahyKpjJxYKScxY0msxXKKziwzdV2LiWY6z99ZvH8EaTlNeRfXsT34UY96VFozXFuXXnppis90bPfpGtNXLkbBXzce81krQCgpzCpUVqA0Cd7/IAjmNiEKB8EUkBAUnAhYxs2BFMzpMhW81EwcCdhqdpdlVFKrgpXkVeGta1iHIRFJwq6WnQvBQkJZYow1lAQdsbKWFVMbhx+VzRL5nl9S0veW1tlQEolJCSlV9BLA3ecWRGbrxpJI/jmUmJstiSBZ1rZL9HUtS788N2caSBA63BEvM5LwBDZdDLUwr4+o4jBWWxh2mHV4t3b5eqZOfwnCUrNuzStWJLO0BKsDSK25mJCIdKC0flq/uklp600pAcA+oNOIxa3EkYdkWZv8fcmdUkgqZwcFX89kAd93Am2h4PpyHRNFJd/t05JJtRL+kn868RXU9JEscR+xQXftEpYe+chHLvEzhJyaFf3WTWuYGYZ9CsPEOV2c4gHFK5IrxDpxkM/8fe97X5XntRdJvlpXJAF1GbKsJArXFKOhQIxjjNesE1qXnWtZkk4HfMk57GKPbpKTEN6HKMzyXUwrvlXIRAgXB3Hy6AuFWURKBVJtcclewiqd2NKdjTob3MNLE3zd4zWwRpQWm+8MCrLE0YSrttjgXmaBT7SsNd9XAl5smdfRfJ0TTGvOVCQGuq6zFbyYU4zvvKrTsA+8drGnc+U3v/nNJJKXFCnbKNqRWM9dhG3R23rqLGN+dCnEuJMWhNcekeO1+4y5ETlDe+1cLBSnlcSZSVFBtiwWD7hvPE8W3wnEtYo9oZuOIO/PPot4nFkUGoyaWV0bY0OcHZzJdf/LjcgVeChsd5/VigcVGdgv7UcQg4hFrGmlbbq9v/Y+8YY4yBmuj9xX15nGOuFcLA+W0aktPnLGlR8sgVhLocUk6OgtNcdb7CMHMsl4jNJrlzXEe2kuOMSa8g/yQfmc6voWeypi6vteq012WugWZekMd94QE5bKD1mfR53ZgiCYn4QoHARTQuDCgpR1ooClHUCp+Ga34SA0qqqyFOwLc7K5LxzaPbx2Fq8CYzZ3ulVUpgpaVLqVSnw72OkQ9j5Ltno+h1uHHBZUElXtju2SEFsFpw5anlfCyOxEgaj3vVaSrI1Dls933Gdc0ypJYmNc11FpYUOXkc9TwO/r3IU1ComrWkUBBAzXk2tOwl3CiGWlan5/rzVf2fMoIpEgUyHbPZA59JdKcrhm8jwxX8/0mkrPO5OgWNr96l6vKWpZr4gLEoGjLLjMTir1Xjs0ExQUd6io9jl37SjdSz7zkteWdcM6mTs0HKgdOIO66AR3DxOCiXWSV4RLolnNWXrQIcLSjsDhubqOChKyJYu3JBwlbHR36ezvir+uQd0rBNRa6FBRQU/YMWahu24SPWp0+RFQrMnWs/xeSBb6nvu7lh2p1ycBLf6S/PZZS8r6PoGlpDDb5corr0z7IGtdxYj2DteU916ytmRxSRbIJv1+SQjeXB04AsHrzA4ifeEMoeNtFH6vfN2Vgp3tJN0gNc4zOlWniUT+uA4/7zWr3VpIvutMV4Dg3iVcKkB1fxFVaha/Wjs8CPLuqxozsrsoZtHl7iwnHpLgJhJaP7zWWgWRhFHCicLL9pmJGO9cJ94rKQqXFlyXBQXczhT2Zh28Yl023QqWstNESTjS2IMz2Ra9vf96Xp9FLcT1HJ7EOQo+uw5qimzGrauzQdGn12lvFHt5ne1r2drqXq9BHt2QzzZGasF97VHLZvinP/1pus4V6uvm9Pq994rICba6Pkc52C0rXBVcy+JJsS6nAwWBpUccLW1fluPq4rNWaG1fLiUKe1+XVliic9n7XNKO3WuxRoj3iJGKh2q5N4yK59triDyBfbAbwztX1FxH+sT5JTuGKJAbNabM9+UAp+EkFwTB/CBE4SCYEhJ/ErAHH3xw6iQl0AqAfY8AIMkgmKpZBSxBR7RUKaorrNsp47BdawaX16UK2MNrVomsu4HVsOQwy+WSCAq9Vg8C9GmnnZaS74JIiWlzjiXeS3fxEmyyZZLnkuwnEOvIec1rXpMqklX016pwFyCOm2XrAOIwWgOvOweqow6hM4m2ywJRLAuVviaejSP/XGncR+ZCSRS1E9wOnYJy11ypatwuDu4zdYaU7ILTad/+uv33mjgse51LmxesGrtmBbD/371rjeojEZrnX3ntukdLdV7PhOtVglmXmWtZomaco4CDZsnkzUJEktseqIvBvarbXKKMONhXB6s1uzvCoua6aa91LVszrddec+2upy4q6u3946jVlS0pKWGXRRuJK8kduAbcd7Wq8FlCWsMg/tJlJ9aUjHbN1UKCuT1H2fPCNeB3Eh+VFBu63au5ALDbVWr9KpUskwRFFoTB2lWM2ycEFQn+F7/4xUtcd3n+bSkUIylinQSxWUkUN8xkkdmmlrghCa2wgYV0GwKHzqVaHbu//OUv0//fLkCA7mTrqKKuPhyRaltVu2e//e1vpz1S4Qrx0GsUS/fV0Wmv0jmpC5owbE8mBvt9nBs59JTGGYkrDLcBThLOrrXjTUKJ99m145xsX2I5yuXI2qHgpYYgnD/n9rWU454+Rw95f2eat17rWvMac3duH+tmG0K/jlKFataUfJ47+uijU6FJrZjMmum5Fae1C2qJmQRb57xS1tX2ZYKwIoccV9kDnWv6FIXzvux1t3FfKS5qjx8o8VzdefMZTQls2p3bWMG394/ZIs7Sla2oRAENa3/FFOOu+5LjvKwh3fOSv49aQ/ooEOwDLoDOZs7scrrcntrraH6Px+UBgyAIEKJwEEwRXRISYoRCSUAHMgGr5IJDWO0EqQ5WoqBZG6NmQAmWa4nCbQSkBAcPgaSAsiaSdOyJ2DVedNFFzWc/+9nUEeTA4CBSC4dp1eYeBETP67OXoBU493U4kRR0GHJIklSpJUh3kRgljEo4+DpbRpWg3T3p6243ZR/oUJVYH9Xx5D2eyWZ5tjgMTAOJTwk7n6fEuuSFSuxalsIcFiQDrY3drkXdDApsrCE1O7McJglYfQjCbSQN2Pf1gc+PINkWFcatTyrc23bpwbKJGwQzFrMSYSrZ+0ZHsofr+5ZbbknJaHuzz7cmkvyun1oFM0uzsG7PtYXEXG1LdIl3Mdeo8SCKAyRja4nCus8V3+WEGVs5jz6KenQHQfL7uOOOW/RvklgK5UoKDqxIPUZ9vw03k3EFbHcWibmuwOxz7tveWDfSxhtvnK4vRReXXHJJshUUf+l0I8qXwp5fclbdnU2ITht2+6w/db2JQRS4mA8uvldsW8vpQLypsGRUQl+8qXu7Zscb1yOxltc8an3L4ydmi3XikEMOSa8zF++WvH4nQazHgUghoGvdWV2h8YknnphmR5fG+2pus/OE9VrRDpH2sMMOa2qioJWoYO3gIGHWaYYoPHSWdnactADlzuJznmkPqvW8+exo/9fZ6T7LnaocrtzjtbBujFoj7J/sfRWJlULcYa1sx1Ti7LYg3Qf2CHuzczMB3v0m7yTmI4TXjjuJ48R+BSfm7tZwCXQ2V7TdHuE17uyoyEJcEiw7RN9cyEHkZ78+qsjRGlLLFTEIgvlPiMJBMGVU4tacGzwTxDmdIbreald7T0pfAqXkXa6K1cUrMc2WrA88rwpOQgBbHXZvDv41YWEnUeMAYpaKrglzodg01UQQKuFPhJakkhxVsWjmWQ0k4xw223Z+7PX8DgSPklWpXSS6JW4c+Lq23KzualR7e3+vuOKKlLzJRSSqjnXBK+hwAB1XfT7b60l3EOupbsWta0tHBbvh0sKprhtJbgU13k9CmtcpgSCp4fNlwVqrmwGuI/OaJBj6FIZd0wpIJINrWNp2cai3N7mnJIdYVI6i7+7OIcIlY5wFaZ/oYpCc9JlnWMtJFpae8ZZxH1uzJZ37TvZDkozdfxY33NOS4q75UcVyy4r/XyJSglI3heQMoaFNTtocf/zxxZ7Xc01qlSeZVCsxqdvNdSRBKBkp5nKtWT/smSW7ZAg1k3avzoX7rjTiSaLk4YcfnhxhfO39ZQ1q76yFBK81xB5ZShRcVoizkt8EhhoxUMb9Yl+2P3rtxuAQIIiXii9qJWGtm9aSUetmrXgzo7PfOYawMMolpGTnmU50a7QiNWJ0aevzSbFOZWGY7epHPvKRsZ14JeIB9xAnMSgGJIiXdlPoIp72cD2Lp52Nn/e856UOzj4Y1c3WZ4ebvZIVuTNVu5CHvbLuSmcan0sNnNvYGYsT8pnK7+N6VySoeL8GhDnFtF0UENW0m1VYqxFA4ak1OsMNyTpacp/y+XXPKe4jhY99ku8txR2uL3GeNYQ1eO3CKk0Aipde+tKXJreDmp+tvdD4G4V+9ghFLaOokXd0j7a7hTWZZAem9ve8D0PDXuncks8YGde5RhTFgSXPNEEQDIe5oQIFQTA1HPrmiiDcB4IjByCCuMQFoVKiQeewxHBN2PSwaRIoE5VY3BKFVY/WSuC0u4K9doIdSzlBe81uNJ2jEpHeZ4fpbN2nIrbWXF1CqMOVilsddxlJOlZvqvodikomn9uosGa/6rDhgMdWkHjK3s+BX6KnJJIHDs4SsQ49hELJQEKe7j7V534Xs29Ldp0pqJBclhTUTSDZ7/kcQnSzOtBLmBEvc1KrJO4ZxRxs2InwROLc/ZatlGri2vaZclqQbO4mG7zmGgKaSl9CCns711a3g5MV7Kh5VcuCRJR7icWr57FW+JyDOhiZ4L6a1HavhqW07mBrBzFD95vP3NotGen71u4aiSTXtGvMc9oHCSrt57Ff1JqnZ4/68Ic/nN5/ln5iIQl4c7wJH+KCUihYEWPoSBYLeC4J9za+Z00pOdvX8ykAmwRCnuurBjqwiNO6VQhJBGIdSuISAm5JMZrQOy2xVwJacr/99+73cvFBqfV6FA984APTNdwnBAbFla5zBZ4+c/tSH0VM7lvrlDjLnqwD3Cgea6V4t3uvlcTrE2P2iXvI9aMAT8wr3nMvib90+Y3qki8F4Yb9as0xHZl23KGAliBrZmVtxK8EhlFxGFHB9ZULHwhMJX8n+67PtL0HEv7t0TVFYbNriVYKDeyNYmyxvDOT8401pRZ9zR2dCYXTXMMIls4Vyy23XIpNuCEpNKo1v9xZjsWuuN77TJB3liROi4+4mtXC9cym3H01qiNZLFQjVyAusefbIwj/Cqlvv/329Jq97+0zvGJg8eGyMs4quG8LYUXUYrvauaY2xEDd/56XCN2H3b743f7vetL80NfZUYHBpPORp1GAWhtxNJcJ3cLOGDq2s5ubRowo4A6CYBwLRwkKgmAJdMNIVAkkFoowLElGKJVkzpW3Dn2SKSqEa83Uc9CRRJF8VoGbMRvL78JauFRHgcSrBD4x2IHAQVMCgyW5v3v9tQRhCSlCMBtuFYkELPO2HKgFqrUEYcK+91HXO8GyjaSk95lNlgMKcbgWbItZUrm2HOZ1sTrw6tAu3VXAVo94ZxZlTrq6vh3+fAZ5XpAiCMJwKSR9FTZIvnavI4lJD581cUlXRY1EkgNnX64CXRysZrKYq1mJq1tmHCXvaUUcxBsJQdeWDpVxYpHXaw5YsOwoZpg0QVWrwt+eYY9od1hKnCgiMmbAHlZLBFC0Mq5wpeu6UBLrpH25bZNuj7K2+EzsFyUF+NyJpTPG/2tPMLubaOj+VVhT+vP1/pkf1y1skSDUxdGmdsJwyy23XPS1NaPWuqHYT+HdJBAAxEel8FkqlurS/Z4igZqisCS/z5PQkxH72JtrdfG6tolJREMJcM+nENJz2jN93rUSk8QLyWcxl7iH24HiLYVNYqCaonC7y9+f3nsQkWraNYqtxXniS/e0a8o6qhOsZnxkjSRc9iEKt1H8Z73UZVf7zKpoY9x5pfveErFKMu3ORvu+vYGQ4ExHHLamKkB11uIiY/RVyTnd3Znc04AYay8wysI9xFXLum3UkaLTWoK84hX3sXiEkGa9dJYUD9gza3bHO696Xg0Co67jWveZ69t63RYMxUCjCuJKFRW1u79zJ2V3tIP1ukbRJazTuqPtk304ZShwUEjiei5ZaHhnPmPnB/uxfIjZ7PIhtZzxrEkZeS5FpqPG34hNhtgxa/3iZmFftj/LwcgZcIxR5BLW0UEQjGNhqEBBEIythNZdScCTnOxaoUqk1EzI9o1DgMMtAdbBK4vCDrY6DARTtURh1dcOla961asWmy3rgECMFriXsrjTFawLRxJO12Lb+osoXAvV8wRZAamDpgRgDrxrz4kmaBB/ie6jIEyyMNJhqkK5VlLUwV53mQdRrWTSpIskjWrqPPdLdb/HQQcdtMjST7W5xGFJsYEtlM6zmURI76/ZhZIpNbsLpoGK/py4M5Ndh6fXWDox2KWdQNFZ4PqSLKkhJDnMm7dKFFZk4jWOs3x36A5ReHZMapUnIVsLnf+jhATXguR4ngdbGmtF7rJzTylAkDSqcV2PioFGvWaFLZ5bYq1Gl6P/n8sB4dl6qiNNDKJrmdNBSZFSN07X8tI+oZiolhVmRoGBpLaEpK9nmkvJ9q5U4pI4puN8Ekqu2wTJmjHWpLimdtppp+SM0oaoZP8SI9a8t1zfYjEPMYCkpNjata0YlTtOaccW77siVwl9Lh6SoRw7JIZdW2LQGolga9Yb3vCGlPx23+oYNcICimxqdbUSinRHe24P8YDXJ/ErAWxeZS0hXCxg9MxNN92UPuuuiEJgqmFDb19QcCD5T/zuJvzFnJ67BAoqpjHnfi51NvpcnSE8XG/yBc7QOldZsyv4KEW3mHcmalkpi3OzYEcYz+5Ozlj2Jnu2AuPSECaz65CHa885ldsFJwAd8rr+asBSVq6n1H0zKZ6vz+ckvLcLpDLd73nPXec1UAyoSGnc3NeSuE8VxrmWlmaVzNmsdKc+1zAFl67d7poiV2N0SE1XL93YXnf3bOoeFxfJXwwpv5lfWy5ksi9fd911KQ6SZ5xNp30QBMMnROEgWMA4fKgkG0ef8zL7QNJb0kRiQRVdG9+rWY0rQB5n4cjGuuRzCwodPnQK6+7Kc6FGHYhKoqLYa1RkIAlHtPS8DkC1kQRj/zkTqrwd6Al5pUVhRQYseiQGMwRh3bw6kWrMHmMLJPBvH+673aSS1O5zImKpJJ1OjUkqfR24dK8MEYdtlpT5vnXtSwATt2rN5ARRxUHbfS2xLjmno0HCu3SnhSSdh89QgYm53EF9JPp1iejGz90MksGS/j4Ldvg1ujesicQUScg2Kvxdb3cmaXtnIQTryFEwZeasa1pXkg4WXa61EmgSsRdddNESVnISd8SVWkkr64ZCAMmx9t5gD/M+c9ioNeagT7y/uUDJ1zPFlKNmky4rOjRHWX0qbBAHSggO4f0dx1lnnZUSol0rRU4qEt5E49pOG2IyxXq6cgh57jHxoQJI+4k5sSXnhVorCbT+tFcpaoLv1TzPiHMJDvZia7QOfA4DRByfwVVXXVVFSPI+sgXVmY12AaI9hDtMLVGYW4w42nOMEtpdWzXiIK85j9qxZ3i0qdWB53lmGmHgbOGzKInruN3FKAbofi+LLH10gCmeYWntIQ7tnqFny6RFPDXxO+TiN/uy+9rZzhnK+ywmqwHLaOe5jOe2RhMoaz4vXE/TnP+eHRag0MDv4xxdMuZzFm074MxETaHS/63QVpOAz1jxWht5k1Kfhb1fcfoka0NpBzfrpQIpgrQGATG99UORpVFaih+dX3VOl3QOsSeJLdyz1kr7VPf1+769aRqd032tX16beFu3NNxLrNnb91oQBEGbEIWDYAHD2nUh4eCukk5SvRv4s3SueTBi4cyGqyuQsnsRyPr3Uqhq1gWkil/CyGsThEuCChprCJRweNURIuEtEahSVXe0g48KftTq/vIcxMql4bBQunuX4K9rwuvOtoEg1KlWdSiSMNpoo42KPq+DDcEmV7tKhLqGJRgyfievmThcCvfQJJ+hn+kmsIYAS0pClU4snbuuJzZznAYIW7r0a6DLS1JfwqTtKvCUpzwldePp5qiRFNUpqcAk6AfXkPtWFycXCZ+tAz2BxTpSy85PgZiElbWMeGOP1Jmcre8f//jHN7WQcCfe6JbNaygRSZehfURHbQ1y4QPRyn1EOCKomMfJ1aOWjSAhiYOHTjR7ZobLxpprrpnWcnP05jvew1Ff9w0Rg2OGRHvGGqr4oqYFrnhH0YHCMJxyyilp3qtrzVpeq9iB8N0uUGsjBrSe1EAMxipSh50iOTE363n7ZXY0AUHYPVZSFDaixNqpyJK7Re5C4xCjILLWe61D2fqkK1kS2jq22WabpfhMvC82KCkKc4fJHYxisVG2+76/7bbbNrUgalirPfocPaTbaRodT66dbley2Na+QTgcNXt4towqwmqfLzIKT/ua2ZmxN5eeyWktnoRRc29L4X3UVee+dc86l+vCF1dfeumlMxYGzAZnNrGHddI+JZbnMEBcUxhX0/peMavijr7HiNkbWZQ/4hGPWOSYpmMZYiB7RCkBSyyrG3baKKCZKZYt6WRhX7I+EZoJsQRZTml9wCnDfqgjt12MZU80qsXvQTTOcXYpxHSeU3zj+pF3ajdDuJ78Pq65oXUJw+u1XjkzuYfknqwjrgW5oRCEgyAYR4jCQbCAYS2sM0XwUGvO11zCgUd3jmSJDh3dkw5DX/7yl1MCS4V/LQS+DgOSdap+ddNK8kvu+H6NGb+qBR0w2QIRpAnEktFeqy6OPBeqtKWeilAHMA/JWAHqmWeemQ7zkqNer0dJW2GVqD4/gsa4wNdr1rVRukJUokDnrENIG++r9933/QxRJXc5lMC96zVLpkg8eq5uIsn1RXwofRhQcbo0wbdvq7u+kKTJ9okZnfkS/ZI3OnlrdMnoBHedSXyzz8uJfUlh9zGbrhqisMTUTEkpyVLJ8KAMLAqJ8LpEJIGJVpKEEhk+4/b829LrthmghGfXGHGDwGKvrDVWATpkVLQTz66++upFiW/zx9xjXnMtUZiQRJQ1j1QhFRFYMsv8+ZrzXontPt8+nEPmCmIBn69CJnujfZgoWNuRRnGWuI+rhniPKCoOE5dkK2XveQ0k5TyPtVu3/QEHHJDESslQSXFFczWQHBVjdu8br9tnIC6sAeGEWwbLRolhZ4tRQoNEbelxC2IswobX533PIp73oXQXZxufYxaqrFXEpLz/6xwu2QEPQor3VTxrn7BWdQVMIoh4pBZiO7F8nyJSxvnFZyr+zDEmEZyLhusqj/coifdznGh52GGHpfuqJPY9Yt0klBZn5wL2R0WWPtPslpILI8VHiqlr4Bxp/I77FuyxrZViEmt1rffa+UzhtvM5FAIqYCLoWE90VdZCAY1zonuKCN7NBYmNauQnFL75HDUnuJeJwtwdxLcEQ+/5uMKmO4v58uyKJ0HxfB5nUhqFYH3hvlGwYm2S93BPjSseEYOVzAGKqZxRx8V29kdnaEXzpYsFc5Gf/JLP0jlioaA4yefosxdfiw2sK95vBSdBEATjCFE4CBYwuVJTECHxy3alZjfQXIDFqkBRclCyUMBESDGLzIGwFhKSOnYloD2v53MAI9g6APY1F0q1aJ4L5bDLopMAUAuHaIGpAwDR0vM6/KnmdFApBau+I488Ml3POim6cyB1nLH3k2gpmQB22NR5rrCAVVIX95ZDr4S4z79kR4FOVcIFmyhJDNXm7eSBCmHPKWlVGknWSRKtbBSHxrjZqyqPXXfE2hqisI70mYSk3//+900NJO+715AkjplnktKT2rIFkyGpT5iE6m5JUGu37jNrZ01cX5I52Yq1xgzOUde1YplR4okiiFrXNQjBimsULdW2mW2j81oMoqq/W4AhMcz2rxQ+S4nfbkcnQaUrPrv2Sq9dulXsyaMS+dZLMZBruxaSz5wyxHpZxBKX+Nyzq0mtLmb/t88ZrjFCnc5V74W9sZYorODP7F72xcQ7a7j7TPwlXhi3j8wWMbT3e2mCb3aOKS3cia9d1wpNsisNwaOmeKmwJJ+jrCdZpCVOK5bq3uOzRfe1IjDroqIKSXD7sbhEDNLHLHYuFkZoODv0KQyzj956663T6/QanaUk/Ykf9hD/1jdELB3TXXF+NnTnYC40FFbqbtOxa92Un2BXbd10jqtJe8wTdwMCVx+ICfL5jfuQ8TR9wGVrJleSWve3z1fXvxhXHsJe7PdwP7v+/XspUdhrmNSevOsIUAqvx77YdvJSDOm6lpcoHXe6dxRHtYVgxWijsG6Wmp+uQMpnubQCZQU8pS3o2ziji0VcT217bM4K8kX5jDUknKHk2jLWk5oFJUEQDIcQhYNgASPxKCEnCUkoJE4STCWTPIYYNIGdnUffEIZV3U4LwqHkkSpcXbyStapH+0ACR3eDhwPDl770paL/v4ScZKsuAc+he1LiSNKIPbdkkoNm6Qpg3Ro6+EYJwm2IOuZ1lsThUsLEHE6JQImTdkW316zqvbT1mOdpzzKeiZqFFtMizyHtWl+ynSUI17KlUkSimCSLVxmCj2ugVhW6e0sSehTEFQ4E2R41mD0q3BWRSJpImOXOWUKeop6aWJetKdbobqe/bktra2nEGfai9kw9eH7XVtsqvTSKk6zffYnBGfZ5OinFXIq2cuGFIh5Cqf2iFIo32onuNt1uQtfbueeeW+y5dXqZQWm/sD9L1BG18r5s3dI9a/+qZZdNLBMPjEpu+33yDMnS6F703DkhqSguW1h6n7vzUEtiD2L7rtuOeMcVR2zveqtp4+3atQ9yIVIw13UTcb21k5alUdDivrInmgue56ASWEo607QhXHBoIbgTOfJnzEbbmllyNEwbMafEuw5p5zduJdbL6667LhVAEMhrrWniHOuEYshRs8KN0KjxftsLvWb21e4nCX5uOQozFfxOo2uWsNPn3rEQ4KrAtYQoawyS4ldrh+vKulKbPHvTGs7lgdhSc8xA93nhddsjn/a0p1UpMs3MtB5bv2tZzubCw+ywIA7LXZ06wrvzdme7H07Tntx6bA9S7CD/kmHrTLg1VkLXbEn3DPkB8Twx2l4kFhlnod0WqmeLOCsXIs503f7qV7+qOr85d6FbR9ooplLEc9ZZZzVDwfvNQUPBXy4Isz/ao7N1ekmXuiAIhkeIwkGwwHHYySKphLOkpI5L4mWeVTmpjdV8QDJSNX87MJe49D2dlzUQHDtY5bmuDryC9Jwc1mlQE8Il6yQJFXMjHY4ksH74wx8W72KY6ZDrfRaoszOu0RnELocltwSZgJhNt043XSkSz6WqjpdllrHDb+lZxiACj7M5rWWHTugdotg7KeznvecKKlxTPledKqqwdWaVtovMPPOZz0yJYAe8fJi2VksES0qOE25rImmX54AFZVDEobhFEQmr2UMPPTR1IRFOR3Wol8KaucsuuyRBkojX7TarlcCRCMxiisRrngemQ0dSVExSC0IK8ag9d6wPFFpYL4h2hBX7oo5wnz0LxZIig4TopNZxSytuurMoYvHe+jzb85m9PnGAh2SwNURMUKPDkQAr4WqfzjFYTqS5x8YJ5rPF65UUJcp7bnFYLqpQ9FHLsrr9uiWc+4T4THR2zY2yBq9ZaEoolADW8dR2v/E++LtroBajOnI48dTu2BXXi3M50OSORu+xdVNRwFZbbVVt/ZppjEGtcUSuL3uEe0u3e54Rbo2xV+rM5nhVGgKGbvBRZzsuRCW7hIP/K6jJnYaEfoUO8hFmz9acDatwmnuDTniF8eyjTzrppEXuC4psa2Gv1NloneKiJUfh3Eiws7bV2i9c2/I9ujbbVt1yJcYScbuo8dzyHgpZnWGJoj5bKCo6//zzq61dUESiIJBAmIsf/el+JoQ7U5VCF7Q4j3NXN++hkEW8LeYT55d2bROzc0QhNnttfRQ22PM4Dorb2yOWRo1hImLWQi7I8zujtjEKxzXtOmt3EM9XFPDKSdiHuJPIeckvKvbQHa8oTb7POjbEUQNBEJQhROEgCFJlpG5hHUISww7cG220UUqmSNaZNTOUeRQqNdnotUVhCQyHAB0sRJ1SOFw4CPi/vae6BswHIj4TjiQoBWpsBGt1bzhUqop0wNYxkWclCdp9piyGah0UJNtZfbm2zBF0INKVI2h1IHNYKY33lGBXcx5kV1RwmJbkHRdwO2y6tyStgvmPBKTEjU4c1caKHnTFEPJqJjIctnXGqDpXAU6Udt0Rix0Aa4nRo8gJFIUHLH6Dctgfcre5BD9hRwec/cn+VQsJSQnXadiB2yeJGB6ua9e5vdIeNakrwbJ2NrLBZ8vtve4W7uje7Y4iKJmwI2CVsu0bB2FSknsaEG3sxW1BuAtRVmeporEaLgsSj9YoncgS+5LsumbsyfZuBQm1EGd6/UQOgjAhS7xNRCoZa45CcZzkoHW62/Wv+KNG/EXMcF3nmLdPjDIg2ohpXU8ZbkilY68TTjgh7fmKOn1NxBgHa04/VxqfK8cSQigROIvC3n8Ci8++VjziTJEhShN28izDmkK49UHnG9zH7iXFFtZu63QtO1LXctd+VtznLONcx440KIfPlnOIz5Wtchb/fQ6ut1qI5+0NBEtnVmIlYdh52XpNfKkRjyh2EOflAkvxiPVZ0af4QLGLdawGuq+tI2uvvXZaxxRRaxBwfnemqTFPGOI7+xBx0PrsvQX3EO91LcHOXijGliuQF1EYpvHBNWYdNce5JMRR7+O4Yga/A1FekY34vkZBjTyFwkP7slhE16i4qFbxjteruMK1I75q7wnWbCM1vC8lxfdRxQ7jclv2kdJz4KfFRz7ykbTvGpNhP3J9KzAghnOJyWMt5CsUJwRBEIwiROEgWMBI4AjKJBNUTDoI6ajUrZI7KlTaER1UvdeatdIXglGJEp05bSRRVNwTW0om6hx2PBebbklJSUiHTHZQLO6IOA5hDn0E2xoBOmszyQvJdUG4v4OA6RDCtqmWKOyAq7gAKhUdRvJcYVZK4+bbzCeICA57Kp693u5Mbodr772K62lahwflcB+zI7V2KvxwCOvLPpDAQ1BQYe7Qq8uydHdfF2KNPWAUDqFx0CyLxCfxSvJTd7CElS7wpdmxzRbrs0Kwab1mAhonC6/b68xWgjVx70xjnl6fKMSaVHiWjC/ZDaVDdpLPUZLO515DFBb/iLeI/xK+fifJSvGuPbumhSH7Qt3QBI4cC9kvCIUzddHMFkVD9gkjM8R6XQvQWnuGc4PPsG9BGIo9Jb+7EAslTRVElnJrIRAq0slfzyRg5J8rjeIZzz3qs3Te6M4LL43uRUIWG3TnKtcZMZqd9ajPoQQS3dYyRS5cWnSPSoD7u84wXWA1sEZk+1n7pJjIe9/H/OaFiDmoPktnRZ2URg9kcZgjVC0UHCjisYbpJnQmt277k0jrHFdDFCZGKhgijirkZllt1JF727Utl1ALYqG90V5BLBVrKtRSiChHVPNsI+bzUNjhvRUrEIpr3lPWTedyBQDeX2uI/JZ73OsvXXTgtc3kqgDXtGvOz5bu5pRjci11x7OIgTjF1ShOyznDt7zlLSnGUkjtvZZnlINybiZS1jxvGGvgtee4K+N94DwwlPF4mi7cv3kMjo5h17j4L+cUraHtQrkgCIIu8z/bEQTBMiNokNR3kGeV1K2EhuSsKveayei+cBCQtBplhSQZyraydOeVoFuCHw5dqnGJiLmrT4W5xAqLwWyXVRLBoQPHqEOW96FWZT1Y6mbrLdW4riPPKQnPTnIoOMQ6zEkmsOpxqMsV7SxBFVN4vbUqroN+YfPmvnZf9S0aSVo54JsflK3ZiRsKTySVaiBZomNhVJeMIoi4rsvCtk/nrIRotrpznUnW6UqrZQGmGMy1pbK/VnfsOFTts86TxMlz5ggLEks6/2pRq/tmFIqgVOxPgiKxUiMWRnW5jaN04R/RZBKB0M8QW2rhes5uNyXFwUlQdEek1R0jVrB2Gr9QM/Et9tR55f7pE+IokTDPt+sTsZcix+59o4PGdV3yM2+P1PH1NEbs6FRW8GEMTBcFoDUT7opdJfvZVrdjeYlpoi3BuAYS+fZGAhJRmKWz61x3IbvyWlbwed3wmnWkE/p1aIvx/Q66tUrOQF3oyE3kYkMFmARiIqVYtOa4EjF1e86t2DoLK+bc1nLjac/XNV5K5zBhPF93NV2ACHRtq25nVvcRlwEdyzUhOisiUfyY8XkTuWrkQyDOEA/lYjDFBs5V1hMjAJzvSgqlPrtJR0yV/pyti6ypidIKLhU0EPnlfRTyKAD0u7361a9uSkPs957aC9gamwUuDjOSTk6sRgFgG/kYowQ8H5cWFtp+B+cqZwrxwhAgcrcLVS699NIUY+b1A+If65drfxoFe0EQzH1CFA6CBYyAXzXd0lCJPQRyx4AZL93uWNV2pSsH2U+1A0+J/RVXXHGJhDtRRRdYDRx4JOgEhF3hgb1gjflb+XDtvXbg9PA7ZCu72ofcvvG5shl10FFdfsstt6QDnqSd76lUjYTRcCBWWUN0/Hc7sGqi84fNPCGWfbUCC2KajmVdZ+7nGmKepNg05hUvVHTFKKiRfCYOZnwGhC0J6BpYtxROrbPOOklQ6BaCscnMM1FLw2qOkwcrQ/uw/VBSVqcl60RWgzXwnEYZ5ERs12bXZ1HqnpK8kfxkz7i0hFjJhJl1Ine5TfJ+lEYiSgwwTazXXFqION3fhaBXa3yHYj+JZolXz0sU9n5ImLru7CHzvevfe9suGhJrSsQqmuoWDBHDFVTVsqz0/poVKP7SXadrRmK8tO0+W0ZnhknwWVtTS2N9Jl74/yW5rd3OdAoQvAe1hFnYm4g5xAbrc4ZI7DP2u9TqwG+fWRQh2Cfc14SemvGY4l3XunE/XKVAHHat2ZNrXdcLEcKG0UMZzjge4gJi1mMf+9gqz6sbWIwlFnCWy/vm5ZdfnmIE8UkNFHQq8NA96Xompok75BAUVteMvxXEe27nVfkC7y8ULVnLaznUcDoSU1q7ONTpEhYjEWV91ueee26VPIF1wnO7bwmkcmD2Ce+5s3zpTmHrobOZpoBxfOMb30h5kZKjeMRy3lfFlt1CKcU7HmJRLmfW1BrOPMTK9n3cJ3JtxtFwaHNNeX/ZZhPAxSdDwb1pnciOIQoCFVa0HUpc0xpiQhAOgmAcIQoHwQJFhWa7s4yliwo63V+ErFpdZ9NEQCQg1BktmSFp5WDgtetQUolcu0tmXHdINxldCgKSwFzVpCCZfY8KbN0TguRaorDkDOFdMs57TBR1APE6Jdq7NstDwKHSIxg2Et1EWZ1/ij66iQvV1w6fpZGElrRhhdpOfrKGcrCXxKo501iiOdtkSrSzgndPh2BcFuMcrNHdTgkdUTXnn0qIzTR7s1aS31xs4tkFF1ywWPJRpbt9w31WSxSWhCVweN2jRLSS1okEfq/P5yv56Tk9almtjkMnEPFIkUmOO/xJuJQEZo9fknZhwzSQ8Bb3SYJKlnVjMknxWtgLiM7Eytzxbr/QCUdIqiUK6/qXDOXOUtvJwTXdPi/MdHYQg9bCPqgb2+vWFSzOdE8r2CvdQarraNLu+5oFgbpUxfdEagViCg3YlRPEa83kzFbdoz5nBWT2CWtLqf2CQDipAG/PmEl8WVasj7qvs2CWRWHnZfc2wThE4bJFYnl2dBvnV24mM418mO26edNNN6VYmnDEQQ2shrmK1Bqh5TqybumCJt5kq1d7tb/Xer35nlHooLiU7S8h0e/hHics1XKJI/qyFXbvZHQq2xPlK7iL1ThbWKPE1hwNFAAodNSZLDcjNisdj8mnbbjhhqm5wnXd3Q+cowinzm4lnacuu+yytEfN5DjjvbZeyn95z2vAOeS4445L1u+5Gz7jvahV5JqvJ6PKFAGICTzf0Cz/FbKIe4zA05FtFrju8DZyu7XOUEEQDIMQhYNggaF6cOedd07VqCrKiQyqYCWcJToExA5DEiq1Zs1OE+KJClxV9A5+EnQOCBLPtaqPpw0BS7JItSrbIHZzAkmJyZrz9FRZs3qTlBWYC8p1KLvehmQf3YYFuUpNc6DaBRhEj1oCfNAv1oyZDtq1ZnARbFS1j+qGybadtSBSqrqWwHDwlAD1nASkmsUlCxFryLhRDt7rWliz8rolqS9x4jlrJ1F05ehmHZV8dI3p4qjFRRddlIRhglJtdP/qjPEwQ1D8sfvuu6c90RgJAnFtW2FITEqMEkmJLeuvv36yKLdH2adL4rVOOpaj1ow3ohKhjHDWJ4Qk3WXmGHfxWde05mSTaHSIhC9hlLDQhpAlBiyBe1RCMnekEBNGJSCJPKW7sLr3siIlFvttrJk+ex21pVCcM2mBTo3u+4y1guiQR9T0hXOjWMB91YaQo7ikpNOB+b0EhUmoMe8VYqtsw+8808beVXt+80LAPdp2tFDAM8oBodS6NQqxtf3Row2htPa+LN8ixm7Dvrp2obE9OttmK5CylosDnGMmdRhZFgh1o3Iu3mfrSvc+KwkhWpEHOHnZp+W8NArYG0uikEAMwEXBNU4I15VrneQIpECQICsvVzoG6K7Po3Cf+dlaGGFhhi/xvVtAXXuMh5hAEYnXp5BHPKQAQrGHWGEIuF6NpMuNHvbmdqyj4MBZQx4wCIJgHCEKB8ECQ1cMUTB3ueUA2WFXNRkLEod9lZOTzr+bTzj0qbodVXkreZPnB5VCh0r7MCloG/W9Wkg+O/Cw4fToE4mhXFHfrohWjTukSs02bK90QbdFYQehd77znal7dIiFFguNbsKoL3SaEWc5G7Q77SXhdbCMEh9KwXpV0gT2BeIVSy7V/scff3yIwgXJYnu761vSzqG+1py1jIIdhTxsjq1Z5pDpWrFu1eoI93olJCXpNt1000XflzRjncjVoxaE6Jrdi+NQ3JGTz8Qy9+9b3vKW1Am19tprJzv4Gp1+EpBEFvMwdZBKOisOUyjnd/HvJdGpmtHBoOhwVCGaz76Wtd20PuM8JzLPfm/jc64ZA+k4mmnObbYaLI2CIR1n3CxGrS3GiNSaEe46VuTQLcpSdEHcsLbUSkLbA1mAsgjP3fe+Jsy7l0vZVXLr0HHWdjVybmEfWdJ6dGlwW7I//ehHP0qCqKSzxLvCUyJTyXOUBH7u2JwW1kr3q+u7+z5buyYZwxTMDCt0Art1k4Cmw7+NNVSnX+1Z5WJancHW6K6DF4v6WmKSoiwdlfIzxO82hER27TU444wz0nk1O0qMy4+Uxj3j9RK12h2y8iEKuWq9z+ywxbdZhPXchMMsHiriZqVdEnGWGI9wZx90ZhOX6CD2mES8vbPY6+wLkxS81LCOhutYx7LXXatgZxziasXLO+20U+qEzlg/CKVf/vKXqxVw9wkR2L7LvUsMrcizXWBrPdERXyvuCoJgGIQoHAQLDEkTNkj5YCUJSGRQzZcTReyEBFK1ZslMkxtvvDHZ1Zh51bZO1K0kgHYgLIXqvUmrXWvYzUIHkI5wyf0+kQydSYQWjBO4hoSEnU4Yyf02EuE61AXuIQrPfyR7dSNJAhOuuokjB7AaXW8SGarOJc+IwhIX1ixz7iQAsuUcHAxL2bZ6je7nLEQrGtp6663T1yr9SwtJCx3dowqHOA5IkBJnJZLYLNes9pYQs++br3rllVcu+r7OHAlJ1oI14gFJC0Vp1k1JQpZvEoPiEjGI+4vQBEIp279SuE8ILGx+pzVvi9CvQ0eSVBGV16pgr4YobO0iauR5Y56TRaWEEbcY70XJjso2xCyfcXd0BFFLwYnO5RpWx65fdpjuH9dWX7iePLeiS/d0hpCmG6uWdTSW1jlaunvVeiWR7171GNfl142NZgvxJs8s9P+Pek9937VVSxB2plJEq5hDwYXPXTxvnyTmlLQztg93HUEkvxXy5DWyD+z7uhq5LMC6ITnt96jZtSzm0o08Dp9/DdcHgrCCT4I3K3KFBvYqwoJiF/adwexw37BvRu7qcy6/5ZZb0nlRYU+NGbNtXFsEac9tr+gW89QqpnFfKx7h6PCUpzxlCRvhWvkBcO16zGMe0/SNz9osenkSTkPONs4Sik7db7XcWxTqKBJyHu/COpyDh7iwNArvxFgefSDHp8PdezrOucHZTkFPrYLiXBCXG1D6xH7onrJuK0bLKHhwzYt7h+IO6NpyH40r6A6CIFgaIQoHwQJDgNiu2JPIgYRvRkCuclAF+NBEYVWpAlWHIJV1rIMEh2x8JA5LMu3qdjjYSkISK/vsJHAQ6M5fkpwjAKi2l1wZGuywJNlHzQUierSFlmD+ImkgacXydVSHSK3ks8SYg367U4KIMup3KHmvez1EBIU0EirEw1x17O9ZYArKICmoU1jigqggoaGwhKhWc04kgcV+aI9sd6VI3rnm/R41EnWSwfaprmA3qruzRHJ01113XSSsEN0VVeiclbjqrt2SlhIuNdCJZI4y5wwFAJ5nnXXWafbZZ59qgqF1wX2cXVEIOaxZ3c8+h9L2vqy/Jau8z/b/UYUq/s1rL5k4PO+885oTTzxxMet98Zj7qBvTWsclD2uw7777pljHvaXQQbKZyGHN1tlaC+K/4kexlq/b4oN4kJBasvNfkl0Rh89bZ5BO0jauLWcKDhMlYeFMKPIarVn777//YvuvONS/l37eNuI6ogZhWEcUodC6QWBwXdUc0TJNCO19j4GxPrnO2hAOFXywSa+Z5Ff4oBCPAO4+ys4d3Cyi2LMs4oxDDjkkudHkAhb3sb3EHO1aLgv2YR3w9uA+cf3aHwlZtYXvLvZERYc1Y8tRiD8UVlg3FdLaH8UBBHmNC6W7OAmknPLgvR5XuFTK1WHaKEwWT+puV5jW7dTVrexeYpndLdQrhXjavaxohjjbJ17fuBiHI4H4e2gQ+bmWcAccVfhn7yrthhgEwTAIUTgIFhgSYpKCmUsuuSQFSA4GGcEEgcuM4SEhESwhphrYa1Z1LkFMsGMzU3OGTbdyUqW5A6gkbQ3roHaQKGFmhp1Dgtfdrn4WsG+zzTZVDgPj5hE5CEqYDQ0JdrNzCGVd+ymJwprV3kF/mFPk2iag9YnZYrXni41CQt/hWoeyBKzuNwKetUVnUI2q+oUO0ajd+d0H1q1x9tQ1kyhea55J2geSY+0ZkDNZco8q8JkNOp+zEKyT0J5BlGTdrFBt1Lzwkki0KjQwV02i0P5/4IEHpu8rkpMgLInXpKBAzKmrkGOJ15zxeiWpxEAlCxAVy6y66qqL/t7+ukvNYjlCFdtID4WH+XdhGVnTujBbOIv7jBBRoOc90dWoAKC0iCWGtkdkm/lxnWc1RrS4f6DLzv5Y+p5dGuLrvIbYF7N1tnvJ+0E0HoJ1o7VLAcckuJdrCHfjrKQVqjnH1DxLQazTjXdc0z7jJzzhCVWfeyGh6JKtMVcQgpXrTjEAdynFJd2ik1IQBfu2uc1riDW0b0EY3k/nGQUezqjdolYFLrUKWzyfz1ReRE6k5oxZOR42zvI8hLOuHbf1Ss5LUeZQYInNsY27gSIehXfiDrE+m2zrZc2xQ3k0mljTPGV5kfb+zA5e8VoNvNavfe1r6bV3Hd046LXj0KHA8YhVtmIA8VCXoY5tC4Jg9oQoHAQLDAl91qePe9zjUmCoo0KVezsZKYFFQBxal7ADn0pUCW44/BHxBKqqwCUta1n7/PKXv0yVkuzzdPqxqCIUYrfddku2nbVwEBpHrS6omTAjUuJwnGg8X9HZpsrZ7DrJbwdeiTTiv24sXSTB/Me6WHrm1CSwtlfUIik6zg6sZnLBHHqFNbmrTjJ0zTXXTNboQTnMUmt392Xs0RI6koeuAR0NJUVESRJCZdc+2DWnkyTPYCuNPZiFnbl27eK0mvuhzkHz7ftElworcB0qxDrC7DQSUzrOP/3pT6evCRyEQvbN4iFFcqXJhSziLoLoqGJDibpR7iLLisTuqOSuhLBYjEBae86wJDfbaO+tGLvr2KMbSidcDYhURDLdyMccc0x63brfdJD4Xg2bbvj8fJYS0RLCebQCUUdhgPf8qKOOKvZ89h6zRyVAvZczda4SmkYlSmcL63eiZC5wsV56rYQUCfDS3ffTYrPNNktzTyfBGbJPq3bXlRnaRuU4y/WJAmrnOW4TQRnsT4SkdhGkfVORjQKyWqIwVxR7tH2xz7Mxwc5ZUfzVdm3rA5bYW2yxxdh/rzlWQw7kc5/7XLqHunOUdYWXdFsTd8g7eJ8VxokPjN+RByPGO68PYcZsG/ud7lCFiIr+rN/2Yq9V0anC5tpjU8QE40aS1CwC8JzOFGJaezKB2EPBnEKyIRbpa/JRlDakwoYgCPohROEgWGAQPc3UIA5L6rP+ZC+TYeOjoq/Pzp0+K2IlqlgJOgRk60QBYg3rxDYsxiSJJEUlzRyGiPO6JiQxWFbVEOHbdrMSkbfffns6HNWYeTopKr6HdvjKSCjojCLgsS9yf7G0c/Ad4iFkISKxoNJcN1Sf17HkjXlbkuDsZR1411133SqJ7i7WKbNmJW48CB6qvBW0dGcqB7PD+6w7Q2GJLhnV3fYpiVJJHJ83gcPn4GdLoZjFdc3ulnBGpDOv8rTTTkvXeq0uLPseC2filcSv61onZS7eKg3r3E996lNJXO8TyUefGatIj5kELDFZDQeP3BmrMxniHraKHrVp295DHKZjmlguJvBnKVG4i/d77733TvdRhoCnMK101yz7ZGMyxNeEoizAt9G969FX96q5t1AMQcTk1FLDLlSSXfGI4g6xj1j3Gc94Rrq/xd7stEvieXJS29e5M2kUtZLf9mKiipnCRCwFt4oBXO+Kbrfeeuuiz2cNMbu4/Z53vweCdMnRDu6frluEAhN7UHet7rtoDVncCeY/4o9RbgO+51xVC+u251a0ZX/onsnty4r2SmMvsC/LBXjerqMXEbPb2TobrFfszwnfLISngWJAcYgiPXtRt8CxVvznMyXCW6MVr+Tzi0IpAuI4AXO+4vzgmuIKU3pE2tIg+uZcIjGeOOssKRdSuyhTnOPsotnDc4v5Pa97uK+5zn0jDlA4EwRBcGcJUTgIFhgOAToWiVYS+wQOYmlGJaGkqQTx0HDokBRzCGJZJEjWrSPJrpKytHViG8l1yROC7KmnnpqC9Dw30Nfe93GWe7PFDDsJnfYsLqIw28hadrRmbrWLDTLsZ82dq5XwnjYOPA66OekeDAPrxK233rro75LcLCHdu11hWAV2jaILySjV3oSNz3/+80kcJuYoaiGkuZdrJb51E1ovrGNdCDm64YMyEJJcQ+0uCZ2G9gtzUj04Euj4KykKS4rlJArRyBxUHfHmwNZ0smDzRhCUMHJdK3xQnOZ6d127vmt2FPSFrvpJR3LUtCK1B7Pm1InTFlQkSGt1YLWxhkjQ+R2ITNZKMVmtLnFxrkIHndBm2ykGkPhXqCVGIUyXTEAT43S5STYThruJWHGoxLTuwpoJ0TwORfEjcZZQ7HezRygQrCEKX3/99Wk/EOPq/jLz172sAIAQMZNouyzoth71dZ+4bu3FeYYfC0eCg+JAxZ5E4pL4LEd1E3a/R0jSFVUKlpRdCEv2or66gi+99NJFBQ4ZnW/EPF2WJV9vMD3E1cY8KQ7rcwyPWF6h5UyFmTWwJygYHzfmoPRrdpbpdub2jc9XR7a9sm8UJ1lHrdvWbzGR9cNe5b2WGxoScj/GpdmP+8a+qFhezJcdkBQUE2Z32WWXas8rpycW8RkvFLhlKK6V7wur6CAI7gwhCgfBAkRCihXYKBzyh4akYK5KFJyyQYVqYMl2r1niTCKnFhKEhFKwsGnPGJMwEyTXwHOyrZbcFyz6kwWshKyODolgCcQah9xuJ1a2P2V7qhhhCLBplKSSkPT1TAcQXX/TSlwGs8P60O5CmWlGZe0KaB2bHg5+bH3f9a53pQ4DnQbWdYno0tZ3rEcl6oiDXYGubxveoaODgoDYhUia96haHTOuIXvkNCAOur48JOzMOrNeKtrSIS2J5Bqcr7RdO66++urkTJLnofZd4KJzoi0Ku6fFRQoEjXcoDTFQrCExaJ+UsCJO7r///kksrJnAUrCSu+vzPDsiFrccs6VZl5csrvAZS8CK68SXCnn6RncuC2drhq4oyVH3kvvn29/+drXRHZK+3lvvs7WE8MBamb2vDiwFL7UKEXHKKaek97y9V0v0Sz7X7CIljGYUl5555pnVCmi4SExCrTmg00Q3dLvbH9YO8Q7nBdd6MP9RnGTUEjGL05Lzsz3T/lHabaCNtaNr9d8mF36URsHSTO5stZ532nmo2iMcRmHPN3eVi0M7R+E6EycoUByaKOy8ygFQoVbfI8MUmcqRGEHk3ConpaiazTFHCc6FNVBgKv4pXZQ1l1HcoOnHax9lh85KXONCEARBlxCFgyAYNKzVVEcSYn0taZSrEyUTiB0etZGANFvOwVbXHdtVSEj6vWrZORON8JGPfGSxYJBl4n//93+nbjCicWkkBVXgSua3O9GHhsrx/Nn5eqbum2ladgezY1TX+zTRbefwp8uNOEgkNA+N4GK906lV6nojIEnsKyQZQsfmXEfhjtmI3WQJcSnb6+rsLNG1onNy0i5vomwN68Q2uhsJKvalG2+8MRVj2EN0Nip4OOKII4rM3NOlOUlyhABTI4lGNJyGKGzP10GhK6aN1ygJTxguKQr/53/+Z1qLfKYSVmadEYJ1YylKI+LU7mjQFcyWPAvCbSSCc0dtabyuce4ztWcKcxUgMhCmFeMdcsghyX7U566wpFYsosDQa8vkES2S/7VHtBx33HEp6dkVda699tpUONWHRXptCL2TFlQOUUjinlFyzmgwd7BGK4iDz1gxt0JmzijEDbao7uMNNtig2u+g61yHv9nruasRhCzdteIG7iW1zur2A/tkexY7EZOLi7WtJHIikziXKFCsISSx2+fgoVioT7t5+RZx9KjxIeIB55yhIQ7gyuI9V1jUHdPh7MgRqDSuY+MzjKVpj5/xtVhBXqqWKCz/5D52vw51XFkXZ8J2sWeX6B4OgmAcIQoHQTBoHKp++9vfJhFFUoo95jjrYgFTrW4C3XsS+RKyOvxyx5BkqWRVreo9CVGJ11H/vwMQa+kaOAyYN1aj62guIembE7/+fOtb3zrtXynoAcUcCivayYyjjjoqJThqVWKr8rZeEIPZdEq0O/B66DTIuAYlNnSKlYAQ7DFtu7mFgrlmioZ01eVEimSp7ga20iCotd0mZiMyTDpbt9beKPmruMF1bR6rxAbhw75o3EPGeyFpWkIU9ronKXColUSRsGKfKFFXy5JyFFxCzBmVZO4iSXf77bcXfT5rkXVLIR5xv+8uFRATuMEQxNvz18WGPoPSIsNcmCmMtnjGjryPjmWdyK5p41nsPzqu2IMqKtKptPnmm1d7btbBXA6665TnZ6tYSxQmHrGM1g1FcMiCTkaxxUyJ2tmgyJRY5NpuC0kKuZx3FGQMDWuYUQPOL21BjdDRjoNmi+KGSQR47/ukYwGC8XTjS2uFh3XUtVxrNEob8bVCMFbprjGfq+uKu4LZt3nkU2kIwQpPCXb2YcWd1k6iljXFSK8ajiGToJCo1HgFXbi6GDNem8I48VDXLY1YWMPu2PtrDZETWm211Xq1J58mMxV0lpw938a9yyVGwUefBXkQ6zmn6wh3X3Xj7De84Q2D6yIWa+Q9yXvrbKcoUEwQgnAQBDMRonAQBINGEpIA206QtRPNbYgs3XlVpVCpOKojWbKyZrAmSedg2U0+CxovuuiiIsLCKASiRFJd0Wy6g2AosEHV7da1iNRJ4FDGprQGZmCy3FLVLaHDfcB91kU3XkmhSYcdsVunmU4JSZV2153fISypyqGLUmW9zjfOFpKhkmY6ZhQigDBaont90003TY9RxUSEBRawNW1XwSLS3mgv0gnMinXU9SSBp+OhBKzsJhXDayXAFWR5zbo2u24am2yySZWOOJ8nAYmY1BZVckK0dAephK/rWIGYziRrl3igT3FY/Od1SzITGaxfrm/rtzW7dOJ5LswUnhZeu+6+Sy65JP3dWINsBW/tMjqkFooPRnVmu7dycrqG04V9WVGLQp1uB1ae7VtLjLYHuJeIoRwf7B1XXXVVKkBVpFYS+4HkchvXuPVEN2Mb13eNc43PkcBubWyvX16vDnifQ6nYh6hglMGkPxvUoc/Ykhgr1lXMdNJJJyW3kgMPPLC55pprmte+9rXVxDOOGuIs9tiucXEBi3/3mzWze3+VWrcm2YdLOn1ZH9ujd2Yaw1MrRpCLUaT/yle+MnXH2jPsDfasc889tznhhBOaoWFkQx7bIIb28P7WFguNFlJQoLCgOxJHrq2mAO/cNFNX/xBdr+zHuq+NUshxvs+Ay5JcY58d+UEQzC9CFA6CYPCwg2IhJwnLRk+CchSlZ2M6TEpESmb72gFzHJLi3arVEkicEIYlQ83uY00qeaaC8r/+679mnIE724SVAFSiTBKW4N628PG1z2VofOYzn0mvS5VmN4Gm8lsHTTC/kUzR7d+dxe0ed/Cu1f234YYbpoTV0g6zM81EWxasF7qwWH+yNR6V6JnUgjiYDMK+RxfJb9ddjc4R+Bx120lS5nWa0KDYoVS3SBf7HsFwaQlXxVzjCrrmI7qR+p4HKsEuGepBeCYmSUJLhhOFFR6UxGgKziw6cq0hujX322+/JNS6lvtwHyDCKqZhPUqclCzTKa3zi2Bb+r2eCzOFvUbvtft5lKAg7nNf18BMYQ+/gxmwxI1aYkobcS43BQn/NhLSkzoDLAvf//73k3DjnuoT3ejEDN3Azi6KxJwjvE62rAofSiKx/IMf/GCJ74/q/lY45xoojXWEeNYtiHKfcWESn4wqcloWCNs1RusE41EMNwklZ8C3sR/lc7jrl3sJjGchHnLoqdFd6Lxs/bI/ezg/uNeIptYz8VHpURPiuVox3TgUhE2jSFw8u+eeey6yhubE430mwjvXWFOMfnL9ZRe3oeF6Mo/bPF/XlMIHRafig0mLX5Z1PrgCuJe+9KWpQMq1rlFBPNgtmCuJs/JCgxuLa9rokHYTik5p5zpFt0EQBKMIUTgIgsGje8FBziFPdaIDXh+WjeapZUskX89Ukdm1TiqJjgEJUYKkan8JMgkkVk41O3aIwoToUQxxxguLRB2kDlzskrqfd1RpDgPJ1lEdSZIMxAb/Xmp9yR1OeY3w93GzAiWGSxe25OSozspx1HjOhYzOOkKKZFUuLFEB7jogsihwGjUfdbaw05NsJxbqRGedSLgjFErsKIYo1VUgMcQyEfn/HNcNo+J/aJ1Y7eQo8czMQmtHHzZvrJwVckjK6ZZ1f0uEiwdG2fzNFnu9hLZHtsB3LbmWiVdspQlL4rJaiHPe/e53p69rdYx2kWgmCIu5iFXiA++99buWuJDR7cTGWnfbKNG75nutII4gzTo7z+WUDLamjCp0KYVryetV4KAY0hqpENP1RhCohXvn0ksvbfqGgKXY0v0LX1vDiRpEMwJIyfEtCuEUvE1CrVjXPfT4xz9+5BrJTcN+Fcxf8ho9LVGYe0i2tHVmJyZar8X2NWeij5vFThSuPYt9GuKkrsXbbrst7QsEyVpFcBnxc7sAzXtqL/YQDzjDjHJdGgpe42te85rk1qH4IGOvIJ4qWK8R+8H/770Xkxx77LHpXnJ+VqA3U2HkssChxf9pXIavuRCNg7OEnxsSYni5Pvk9BQCZPfbYo3ixeBAEwyJE4SAIFgwOd7oG+rKN2XrrrRd9LeBmeTZqlp/kbM2ktwOXKkGPvhKiEnIzCUlDRCe6z7lWF18wNzCjUkdS90ApIWsmZ8mEKAu7SRNl2267bZVrzyGepW/QDzrOCaSsz7gO6EJzXUnyO/DXEIRBPPGc7dmbxCOfPYtdcxtLzdQzo6+9P86EBIf7oBSs1UpaIi4rhEHV/JK/Oim4arCet1/X7HIgqPj/p9FJQZyV0PdQ/HDaaaelGYOSWWbvdi2tS3ZVEggJ0zn+MT5DIlhCtGYCXKc04Z9AKgktQeq9Z7Nca0al7lUFHrVm2Y5DUQNxVjwrKUuotJbp4vR9n/FMlqGzYe21104d4ezK3UcS/xLgupFKd9m1sTaeddZZSTSVdO8WSbmmxQylyTPAXU9eaxaSJPprCEmlE/jLgtjKPjWqeIYAUPNzDupz3XXXTfVtfsYznpEK4Ng3K9rRYWf2aC78MEKlBu5lxVNifeuIPYloZvatzj9jF0pixvo07HPNELYnKZgiDLqXdf9bP2vFtUtjiDbCXRSIib0OPvjg1A2tuAa6ozlQ6USvJQpDrO8hB+dzrlX4aPxJLsj2dS6oHkUfjSF9o9BiVHzFEUARbswWDoJgHCEKB0GwYCDI6n4yZ6NviyAJMtV6eSZkRoeQBJYDUumuXYlIh+x2d4YDkJkjkv+lZyoK+CUiVYP62jy5cTgA+7khoRNdJ1SuLA+GCUFDYoP9OsHKPXXzzTen7jdd4iVnsEp0d+cU6sDSseMw32ZU9/Js1g7V/KVn7wWTiYVEMod7NrT2DEnCRzziESl5U7L7qw2721HihbWMzbAEZcm1slvsQMjSUdm1Bh01p3M2SIRlrNU6ob3Pf/7zn5f42SOPPLKKmwahjEi2/vrrJzEnYz2xb7rvCWol0D3HNs777euZCkckpyctQpkN3BRcaywMdXG6rkt/zhmJwVH2vsQ7Iq11u/Qs5cxBBx2UEvCeh9AA+4PXLA6rJQq7xs1L7hvzbO1Nxmi0xdE11lgjCZXWtbatYWmskzVF/lFYt9hhSrqed955S/w7IamGKKxD2ExG7jQKibxu65XiAyKLjtqhYV20PlkjuQtYM+xLxuFw0KhpRxoMH+MprNlZTFJITaQVH3AhqGGJDsVJ8gCczGC/UuBBGCZOKywqCZGZo8Ik2KNKnWe9Pnstm1v/pzhogw02SKKlPaK2ID2JPblRBzPNop2PiPvGnQ8JhiVnVjs76sIV3/i6G8+34X7l50phXNuorxcKilg0vihUa6P40n1X24UoCIL5S4jCQRAsGH7729+mwEiXhtm6kq4SVRkJhpJJBYKswFR1nmr+UZ1R/s0hpG3pU4KbbropiVf+bwmiDIsqYo8DqANnTlSWQMCZ5zH5up187zKtquDaXQzm5vicHXS7llhEeHMMg/mN7kmdi+6hj33sYykJS9hhj1lasMvzGdvoDvKombggkJkLOAnWmBCFy2HtzCIVMYFILOFvpmPNOexmjBJsiFjEhowiKl3wJdcue233+pUYJK70mZAjln7iE59IHWYKxvrapyRHH/3oRydR9PDDD1/0fQUAa665ZpoFWyqpRZzLa4ivZ9qXawmzGeKNRDvraAIh4UoC0exOMVkNvJcSn90iNfPfXWvnnntuEuhrWFa6nsVZXViH17yXswhutpz9qpvUVyhY4/1WWKKwYNRIAdfdJZdc0vQZ71tT2AqXjq/b6HQnJrmPR60hNSEC5/he7EHoMSZGHD7EPVlBhWJSwt1ee+2VYi8FpoppCE19zK4OhgtBxR7oeoK185xzzqn+vARLHbPWbSg0rTn/U4G6M8Sk70mp2cMKlcSyeT+yXvo7R43aorCYY5KCN8WYQxOFnU85aHRHDxFtXd8liw7k1Oy5+euZ4s2aXdqc27hHKBqyRzhLaQYZ8rgjbkPu7WuuuSblFs2M5sqkWE3hWBAEwTiGl5UPgiBYSnDc7sxpUzqhwI5H4k9ySvJG9Z6Oq3Z1sMORuTolk0mSkSyvHGglBbvCpcTcYYcdln6GrV/JeT7eW50irHkkvBcSur7ZYRFQFAS0Cw5AgA9ReBiwjpZ81SGs4EOCve+EcE10R+auhaBfXEu60O0LEhm6VHICx15SCwk7iYT11lsvJU9YLCsiImzd7373SxbHGSIa8XK+Yy+UKCxtzzhJ58Y4G93SnRs+R/Pk8tfT2pe/9a1vNfvtt1/qmiUIt+11dS8TZ2vAvWNcl4xCLV3LNXAviQnEY915hWKkml0busx0TurcbRcFZg499NAqojCR30xOs5QVl2Rcz6eeeuqi67AG7MglRU8//fQUVyv+NBNUHEZgqXmPi+umsf/7DPN7KvGdx8QMGXuiYjyFa/ZDa1o31g7mHzN1FPYFpxLXVxaF+8I5grX+pCM1ZovxN/anSdDNWQr7Yde2V96Fy0JtxFsKeBYiur2d6RStWy+dWeWk7JViE0XspSD0Eibz133HmyyUPadiwC72aB3/tWaSTxvFrcbjyE1w8PIZKwhVmNj3GScIgvlFiMJBECwYHD76nnOrGwWS6oKzkgLsOHR23XHHHSkQlCgadcjTEUa8dEgqNVvQIVMFv6SUrrNNN900HUa6CdGhIgGrGlnlbVv8D4aHrhSJ5ize6CiUBLe+sHUMgmXF4V2CVOeIjkICDrtZNqW1Zq6Omx1t5EJ2f2jTxz7WB5JjNaxdJyme0vGmMKuNrgbFGLUsds2S6z5nxj6ti0KXOnt8ncwlMRuRIKyDVcdwRpew4rkf/ehHVWycdYl+4AMfSDFRe20Wr7DiVwRRA0IVccHoEN3QGa9TsV4t62iwxLYf6Q4pmdRfGjq+dArvuuuuqUPIvaWYRQerLqUTTjghPaC7dty1uCwcddRRaSaoZCiXC9c68eOb3/xmcgCqlRRlAf+Wt7wl2Rn33anqWnLv6IrqdoGJQd/xjnc0Q8Va5Vyl41GHei0L+KAfSq4Fy4pY5/LLL08FB312FLp27U/Wzz7ikfaIG040RpP0gQKpoH8UoCmkYdWsYMveqPDUfik2sWfWpF0Yp9BUrsRZpvQIM8V2L3/5y9M+zLlDcauvOUr88Ic/TPEAodT9XbNAbZooUIvmgyAI7iwhCgdBsGDQESJ5Mw4VlAcffHCx55OQYwHpoCkJeuONN479WUngUcn3ZU0U6WQcJQi3YdukQrmkqMBqitD82c9+NlVjsiFla+dRakbiXEZHUgjCw8bBUnche0aHatXQ7m3Vue75Qw45pJnvKG545jOfOdHPstsbVZUdLBuuK44OOVlIVJLQkdzYd999q72tLPOGZpu3NAhnxFnFHEvbL0uiaOqDH/xgsoskHupg4N5h9peOjlpzUYmi5o4RzXQVsPkzP1EXr2IyFuU///nPU2JN4Qu3kZIdHKPs9SULrSESejVgyS35uPHGG6fr272lw1BXmC5i36+F+1VXvW5d7zMBkYBHqFboUTMJa/3uUxBu20W2LSNdz6MEu9LxoCLHk08+Of0OCmq8fs8rBtWhXkvo0Y1M+DbvVuFnN8Gu+8/9XuMz3m677dLXksDd11bLjn3a5Lmgzhc+Z/ul4p5NNtlk8F3SQV3cQ86w4nr7ZLf4jZCUC71L20eL7zbaaKO0Xtmj2k4SXMfMNq6B/ck+kffH2sUVirGIdO11rPs9WMcXSkF5H9iXCMDcNJzvXGOlZkUvzY3ngAMOSGK0HJxmAc+vMIGltVxVKcTP8nhGwrRfm69zXEIo3m233VJxYk376mngPNEtDoP7yPnGZ26N6Rb/BkEQhCgcBMGCwSGrOzPPQcT8XV1YbXvMUt1AOSnn65nsAksm7wTbklSTWDm1K4ZLoLNMYOohWUYcZhuoU0dnjAOBBNkQ57qofHW4VwX7uMc9btq/TlAJHW8O1w6VGeKKOY26kQgBpbqFHfCICW0kt32/azHrnip1X0mGqaiehCHey9NEMkzXWUYnY61uxoziIJ+jLr9sb0wUdI1Zr0tbRdt3u5aB/u773eva+1Grk8FzEey+/OUvpyRw91p2DxC1SiNJJXGlkMRz66TUsWP9kLCqJVC7r+1P5qF3P1MuH8RpAjkLOgk7QnUpvL9f+9rXlkiqE6RZl7fnWJdEQuyYY45JMQgxXGchi25Cmo7Wrp1lSXR9eU4P8VC2sdxwww2rFiEYVaLowL3bp3OFpGseWSLxq8DA+0toqJ3gz3bd/lSk5D6C76HW+80lZKZ5mGLiGugq5Cxw0UUX9S7+Twv3kDXZtQ3FeQottthii1RkQYAg6AXBsmCNsjaPo2ZHJWeOce4cuUiwBoQ0+5M4SDxCpHvRi16U7qsalvg6OD1Gfb8NC2IuIiUgFFojFjLyXJoerJGEePkoMZCGhHHjNUpgjRaPgEW6fdjvYN4tNztxZsmxGc5OM4nd4k8OE848M807no9wX9EN7nN1H/uMnSvECM6QebTc/vvvn+7xIAiCzN/9Lbw8giAIUuAqWK1lYSXxKfAelSAinOoyKJV8lvTUAWVGn+TnKCTfBYWq7Gc6BJdAFT+bRvNrBKcCdhXJtSwyp4WZdjoV2I/pFlb53U6EmreXZ+0E8xeFDa7dURXOKnAdcnWClUCHqLVpErbddts0m7MvJN8JeWZXhl1VOdirWUckOBQEdMN0a2nJGYps0ImEEka6rVTz6xphZ2jNYjOnI63kHK7LLrts4vl5LHhPOumkpgZtC/hREJaGNCvctWX90g3VRacwYVjRy3XXXZdcVezZJZOSEnaESpa+ks7ee88hYVuzC35a6Mr40Ic+1Lu1rYSre9r7q3u1W/zHxrvW3EzXmH3o0ksvXUzUIBbrTq/Fm9/85rR2iXnPPPPMVGyhCJTYYL1RnFgD17J1+lnPelbTJwT3rbbaKnVgLRTYojtLscXmiOR68j2dlBw1dH6ZGRkEk8LZR/dgzbVpFFdccUXzyU9+ck45CxHKOH0RiBUGOs+ICRWQzVTUPikK0sQWkyD27MvWeuhwYRHTy0Fxr8u2+woCvv3tb6fP2/dq5H44tViznVmMJVEw/6Y3vSnFCa6tki5T8lni26Xdy84zzh+li12njSJHhSXdYorPfOYzzQUXXJBiUedH50tjzoIgCDLRKRwEQdA0KTglCNcShSUsCIIC5Da6GCTvBOulRGGJMFWBAl/zKHUxttHBoRuIoFPD1q6Lw4DDpdfORluSzmF4aKKw1ykB6zGKodr5LTQIvoobuqKwogAH7ZJV/YpFuu4G46hZ7S1RxBpbJ3wXSfhRIlOwbBDHJLxZ+Y7q8iuRnMsQ9M34tD/lRIquSva6Egkq6QktCockW0p1VVojJy12mPT6XxZyN2Hf2Aftv4TRPjs5PZfPdtTsQuJW7oRyn5d2EbE+uaZ0H4t7CP26h9livuIVryj6XOYy63SfhHXWWaf48+eEqPu49Ny8SbtXzSMfR63uaAUsRDnPL671+bqWWHWLrRVA6pSugUSzDhjFDdazvG5Ihr7rXe9qasHCWEFp36KwJL7X6L2tNS95rmHNzJafXAe8/iwcKcB03QXBncF5eBJnrdIoJCGMzSWs17oNFZwotrCPKnJWGGcN9W+zgSA4ykVLAaJCdUXzik1LxrhBs6hAShdp+70VIxAQFVHlUQQ14iAP95i9ORftuP5Lx5iunUkKZv2M32loiOGNyuiiIEDBp/iMq4n5ynGfBUHQJqLnIAiCpkn2jaXt5VTEqsoUfAlAR3VG+TcdpaU6CzNvfetbUzeIYFDXKvtqSZOf/vSnSbzSufLRj360+kwZNrcqE3PnhqQNwZrAMDQkO7N1otct+U4wi+B7WOjI1dmmkp4VlSQlW0N2sC996UuLHnRnKjLoE5XF7N8JhzqydOroIDXfT/I/KIeqegk5a3ZtrMm6N9tuEeedd16qoM/Waqz3rG06W0rNupWgmtb8YtX0xCNFWL5mwTqOWvbR9gQFWxI17invhWRNyQ7wURB9FRvoMCSEWlvyTGGCndfr/XC/15g75vnYONeGne6kYmytTnCfpX3CqAHvuRm67RhTcrZWBzHBUNynA65PWBWKMXWvtq1W/R6S/q6xWm4WrNFH2ZKKPXVDiclqxLuKLnVaESxr2zgbc9NO+rpXxfk+a+t025lG0YfizyFhxrluJ3GXohKihtfsfbBv9emUEgRD4cYbb0yOHdYxgrD7TLGWuNC6qqOUmKf4s2SMoihREaQ/s120+MC52VkqKAMx0H4wSmzXkT2TW85scK0oAvAZ61Z2LXEokQ+zjtcYszVqPnWXoZqken/F8pwC2/iePIW9Ul5KHBSFF0EQtAlROAiCBYMuvlFJA8HqNddckzoNSsLSjPAqCJNsNVdF8iYjQBOcPepRjyqemJSc0vEl6a+TQMeKYNnBgDi9wQYbVBOEBdyScJJxkoNev3mrBxxwQBKEhzz/TNW516nCWueIylyiuG4VCbrac/WC+rhfHWgloCVRfKa6wHfccccktpTE/cPOdRLcW+1ZtKVw/+r2YnPnYGneqHWEkOUQak7UuFlowbIJpqUr6MehU8X1nLFPeCh86IpMJRNHCpOIopOw2mqrpQRlKQjcWZzz9Uyvq9YcUrGAxI29wRryute9LsUAvv/iF794CXeP0gVjPk/risIWr9E1oLjjmc98ZvPjH/84FQSUmufXft48V7eN9VPykPiuGMEaNtt9UgGLxyRrm66JGuiM0YUPMVgXcZBixBqwBpTY71sU5ipA+B81e9Pvw2GjL+xZhA6uNMRUXTQ1Yl7Xrg4oRR067RR5ttlyyy2LWdPaf9ud1r4ed50P0ZnmsY99bCooNT/Ye52dHsQgXm/f3drBMCBKTjIvWJxb0vnhV7/6VXP++ecv9efsjbPt0h2HfAB7ffeP2ENc3y1EVdyuUEwBWam5ytbn7bffPhWut4ujjKLxfS5J03DZGCLmrMtBGUnTPqu5/sSfRsfUQoe5nIjciBnC9mAxtz3TWbI0O++880Q/x8p6aDi3yWN+5zvfSfFWLtQzTiSf6eRAu46FQRAEIQoHQbBgkLzpHjIkH3XpvuY1r5nRbm9ZUdEOSVgHLSLKKBG1RheD18Ya0aMPiM4OHg4ZEss6Y17+8pcna+6+Z+pNA5+jriCHZodawgck2B2KzHhmFxrMfyQfPVQk+9xriUeupUkTI7VsaO92t7ul/zvbNupgveGGG1KClm2lTqWgHLoLCfCKSEol4JZmJ5y55JJL0p8Ejja33XbbyL1rWbHXTXpdl+7UbV+v7a8J5LrtuFn04e7gPSAWebBPlBwm1B577LFpnu8rX/nKKs/r9Zm9Zm8mlrkGxEB5DbNvTyrY3xkUhokNPJfry7VthqF9kXjJ0lihDQcCbgQ10TnhvfbcunhzAq0kCjtmmslc8/pSVCAxSGCv7QbTxmfLIUcCWLdXGwWKfcSBPltCsIKqP//5z6k4U0d+rf1RnN3tzKll1U24yW40o6xo3VM17fbnAmzIicHtwhGiVekilmDhoHgnF/DMhJEXJR1OxNGTzMCWR+DKUwMFYYQ0YuxMxViKvEvGo+IdI3iIWO95z3sWfV8nKRHTrNkhOor1hUI07lUZMa14QHGB2Jswa69UjKgwrjsOqRTiya74a080QqV0kbyYVjHBpMWmQ8M+KN772Mc+ls4RYkwxmXtMnJvP8+GoEQRBlxCFgyBYMKjgZ3s6Dcy9+uAHP5gOge1ZJsRg8/2OOOKI4tV7BCuBf06qqwo99dRTU3eQ38eBKws9JTAn0MHVnGLvsw6GhdQZK8F9yy23pMOuA20WhR3AWHWagRai8LCoPcNO557HJFhLamCNIBgRa7Kd9Te+8Y2UYLCW/PGPf6zyvAsJhTvZ8kzyhqhCsLJndcUj4kopCz8JOJX8PkvJAkkkyZK2dbX9SVV/yW5wjhmT7sW1ruvMySefnDoYiOPmg1qvdc8QkkqPdRiFfdlnrbuTkCc51+7ertHBSlg6++yz07UGgr9u5VEjLkphrRAbSAC34wLPqfPvuOOOS8UHOoeI9aVFPJ/vGWeckQTDm266KYm2nqvGPGG4b8VZBH9xWH6vFRFZM3Xt1EpMem3iEGuFjsquE43Puka3CNGXgKGwhf2n5+bEI0HNPcb7X7MrmNBvn5IYtZ6KR3NhZi247nhAct3nTZhVCFob17R1yvqR10lrKyvWUt3JcwlxhzV6HM4cpUYcBAuHffbZJ+1NS6NkYRwUQx122GFL/bmahT2TCkSlC3rs9ePmyysosm8Ey45rte1M1/46/3v+TEvmgbqw9hfbiXfkiLpuKdzUShFrf9O86EUvSo8cD3TXjve///3F3u8gCIZDiMJBECwIBEgsott2eipfJRlyR2vX9q0kqvZOPPHElKhRnUlYEax5fonJ0slBSTiJXwG5mTE6f1796lc3t956a+o2MNvNnCC2a6UEBq+HGFqrI2Ou45BLTBl1gHfIveqqq6byewVlMTPRXD8CjjmCXcyDXWWVVaq87ZLqEsAO13kukiIT1vg6l2tVACsg4aZAaGBxq1vC7DGzyHJCPFh2XvWqVy0SjZZGyQ5DVfUKhdj22gdcS+2qfteb7hh7VI3Zuhl7ov3R/ZSva+8HMY2gJalUA90KrOD32muvxZKzkpXu8Um6h5aF3Bn8+c9/vrn00kuTgOQ9PvDAA6sL0V6XBB1xVkcpgVKHuNf/oAc9qJqziM+YhV23UIzjgOIaxQfiIvGYOCXPtJ4txEhiIdFd56gEqOv9ve99b7V5whm2fYofuslQ+My5qNTAGmGdHkfNER6KTFxbulWIteJBhQ7WmdLCQrsr2HWlgMoYB9ewta1mcUUb1tS6+9tW5K5rjg/dZHzprlkFRK4x64aCD/cyUViyfRIL9fmEmEPc1caeoRDASAvveRDcWewD07AqvjOOKTVRPMRCm+NAF64iNRxrFAx9/OMfb17/+tcvUSRnzEBfDmdDRee3x7Qx+oV7iJirOxanphi9EBGDOI8rhOvTISYIgvlPiMJBEAweMxKzFaNZr7la7qijjkqJBMlIQs5nPvOZZvnll6/yO5gdJ4Ej+S9p5nkkrySG/S4lLeYIwQJx1YKSZCwideNI0BGDda8Qkcw6Ix6X6l6VlJMAlKQyS9nrbR8CCNOSlcSlIQrHDrnmtzjUtiG06GKJuavDQMKbVaPutlHJ9fvf//5VnlfnuftaopfI4DqT9JYE1plUS2CAezl3XBG8zR9VVEIsnsT+LpiZUR2aEuA6Gq2ZioZqFC1ZszlY2BcJcfaLdveGvWOjjTZKtvi1kIi0FxIDPYh4BB17phmlH/jAB6o9N0FJ8RT7V/FAxuvVRV1jrAPsj0Rw9uvHHHNMb64axGhFJfb99sxRYooYxPtRKxmrM4WI13U+UExl3EROPOt+nO1MbV1GYjpisDnGBDMxoM+ZqOS6ri0Iw71lXfbYZptt0jVm71BowR2mFjp1c2EF9xL3mH2pZmFHxp7onvLwvDUTv9YNcRerfZ1+te32xxWJsS5eb7310txN67SueAUlYl0d+TXGS7hvrJEEnfa5xT7t7wSXoYnCCmc8ulg/3F8RYwfBncM+JB5RkDVqrd5uu+2qvKXWS+eIrbbaKv3d3qRQy7lCEfWkDknB3EXuw7xq+Y+axVHB/6EoTBGHWDsXb5cqrgyCYNiEKBwEweA5+OCDU1JdFR2Io6roN9xww3QIkYyVpNPNWyv5LTjO3cAOX6yEoXOYWEqkLTULTFLdHLX9999/MaGY+E0QRhaRdK+WtDSW8HzZy16Wks8Sk15rhj0pq86LL744JcRLCuFzAV1WxAy2iZJT3guHXt1oEnhs/oL5D0HBzMu+q7CJGYQqyWbiiuIS65ciDOKs+6smEszWMQ+/hwcWkkV8H+jcfOtb35rEhNw1q5PSZ8zmsLRIqUN4nHWiYoDaEL69PoIkEcs8OR2zWSxvzzwuzTgLQ0VLhEn7WA0h7cUvfnESjGp2bI7Ce0m0agvCGXN1fQa1kPwlzNoXrSVeu5iEZTnbPx1TupVd87PtKNXh7v/yPouvctyDbqdhLRQUWJvtFa4lMZnr233s77rf2841pbnggguaAw44IL3fGe+77tWS3WmEyUktCXUMs64uhRie44/1gjhK9Hct9SkO6/a3ZhGEM+Je4qzrjxOALqnS6JB1L48qZJUI9n4sFBQT+ewVu3BECoJJMWO1j1nnXQif1o1po0hM/sNa2ifOK5w07B3WKvsy9wydjrvuumv10TwLDcWVBHe5pnyuyGgQqOEy5XmcDxVuBfU58sgjF43rEJfIFSji1iCiuLePkRZBEMxPYscNgmDQSMxJyrAjyskTX/v+9ttvv0jQkEiSPKwlCkvC5eQci2GWle2kvK6wUqIw0bsbhHvObnJdQqltd1cCnTAO2A4g3W5gBz2CqaQNa8HddtutGRoSgzo0dJ17b0866aSUCPW+SFwF8x8JV12VfYvC7cISVdd5PrnkkgOfjuFah2/2mBLvnrOLdYttfFBuDeE4oHBJcQkhibWfIgBC15ve9KZBvdWuYZ2cuUuFCKvwwn1GFFZAJeFfA/eLIqVuFwOrYd19JZ1DjGrwf0rQuJ+IWeMgHPq5GnEIoZudH5GyjcSswqaayXdd0RJXRFufu9/nJS95yaJuJEIXJ4bZWqRzUPCZEpwV0Ci+cw312TXhsyZ8565nMZj1k0BInPU6a+F52HIai6IjS+eIjmEdYeY1uxZL4b6dVGQu7XZA9JbMZh/NBUf8rmiG2MIq3DVWG24Go2yLiRruMZ3ENXB9E7/Fm+252LqzFV2WLPacD+jOnq3DQLDwsEa2MYvc+kiktAcr7jjvvPOapzzlKUXjAcVo3YI0exWR1tnZ+ZgtunO7vbMW1stpdRN6PxU6egT10K3rPKGLVH6mW8jLMa8G9kC5NQ0X3DSC+mi2cH7wUACgEUPxuHhT973CzDXWWCM+iiAIFiNE4SAIBo0OWQes9mGOSEzIaHePqKBTYVcLQZhkv84QCSQ2L7rBJA1Zn5WsVFad2Z0T7O+jOvq6FaOzRWKZEDrOHtr7rHPGezFEUVgimEW4RzBMXLcOVoQrHUHde439ao0ueIl3a1cWziRAWaNK6Dh8KyyphaQN4U5SoWsxV7tDeaGhyvv4449fLFHHgUB3p27LoYnCrmvXbu4qIJ5dc801vVzXunUJkpKvBEmWwzqXicLu85Lzm+19ufvF1zMlYhV61MBaZe1itSoZLilNRLKueM2SdzVRSEOoJdaxwM9rCWt8MVmp5LBCLCKhmef+ZCPNylkRwAorrLCouKYmrmX37Fe/+tUkBJvfrHvX9TaquKYkrmNJweyO0+5eJY4rOmnHv7PB/2Om7SQoxiyNGFpHrodiLVaVHp5L95vvb7755tVmdUuoK/BQZNpeLxRfKP5g4VgD5wbrCOtsiV/3std89dVXp3OPMwaBKf+Ofm6+Y53KI4AyiqYUYCruca8HwbJiX1KIZuQUciev606hhbNtLXTNOheLf+xRcA8rolZk3HbdKokuUcWGnKxqjCiZCfcsAd561c1FKBZjgRvMHmdVo0qc3/okz6gmSipeEg+1O8Dt3cTqoCzOMs6R4hIFAd5nRWLyBs6PYqKaI4GCIJh/hCgcBMGgUUlP7HXYkxB18NBRl+djZlTz66aohU4+Fb+sQSVC2TWxdxa8mb02BCtlyRmHu6Ul32p2T/SNBNykMy/Zc5a0Tgymg0QG21MCyqgZXLo7a9zPhI699torddlJND/rWc9q9t1335TkZ/u63377NTWQ3JaA9rw150MG/49R807NBK0hqkwbr0vSQie0giGdBdZU+7ZkKEG8JO05pyzQCSq6VyWr2P0TUIycKN2p63W1v27/vY2EdEkxuku2ZrRmENy9F4Q97h3ZEr42YjHXMhHH76Ery5+l3FIyhFhJMPPfibPE0mxVaQ034oJ1eo250SC+77HHHkkcFAOyylQ0ZB48obJm9+qoebIKiYiHbNNLicKj9sdTTz013Wc50S82FP9yS2nP7i6NTncxljn33nOftyIEHerGqowrVpwNPlfrFXGFiCHx6v1ViKAYtdZcX2sEAcmjzShr+FHfm4+wY//ud7+7xPvgPT/66KOrXdPBwkCMy2Hg/PPPT0Xbmb333jut24qXanTVygMQzgjPvnYtQwG5MU/2xnaBT0kUqntu65S4sxt7GGOSReqSKExSICXm4HrQfd4aYzsWKq5Z1/Y0ENO1nSzaxHmyLIpXxDycDRRd6gx2b1u7coyrWJBAbDRQjH4KgiATonAQBINGEkiFrSpFFcACY4nQrh2lQGqUBVxJcmDMRtohiOVdrWSkTgmHubYllsRc93sbb7xxsefMyRk2bjPZUEqYDeXA5/NrJ7IlDXQBETJ0JSkCUITAxmfc3M5gfqGyXYeh5LPO8L5wz7D/1A2VE1UOdoQGVeC1LHYd3D36sOIMmiRUEfvN/sxrC2FeNx77/SGii1MiA2bS6xR+3/velwppsrVwKRRU5GSrRKivCaJzBUK47vudd965yv9vn7Z2eUiA28P6TA7ZHwlmYjHCP5cUxS4E3FoQwSXGPBSumbcm5tMtofu+ln2lBFy2/nQvE0vFZjrBu7alJVGY95WvfCU9fxtxiHurlk240SWuW5+lrjPxkG47tqhEYutaH7ie89x7zynWrjWjUkGL2X26/BSTKHbwWbMstz/XKvAg9CooXUg4r5Q8swRBG2ujuKDrfiP+FYuw4K8hCnMnUdzx+Mc/Pp0X27CttmfUggW//cC6bS3rUms+OwHLGjnpPPpgdgXF9mTnVsWI3c9Ujkwxc2ncN3mPkn+S+3rAAx6wqFgsRMmy+HwV/YlruaSMyrNxZpIviPc+CII2IQoHQTB4dIqwdtMNJLmuS/g5z3lO+jdJSQHU5ZdfXvXgBUnQI444IommcACToJYQLXnwcng1T24SStsoOnCocp7Jqk43loPuEJAgyNaJriUJK1XdZhpmiGlsm7KVUjC/caAlLvQpCLer+j1yh6UuqNpIpitosY5aVxzq2wl2h8taxS0LER1tV1xxRSoskSj0XrPH1EFCbPjCF76w6Gd1PXbty+cbuiYVarFJhISs6vZse6er0/1Wim233TaJcyz+JUNZqUkED6WbrgtXjnbX00y4t9lIlsbepyCNGHzllVcmocx1yy1FEUTNzuguxEpCsAd7ad2HNZAEzTbRuqIyknXWTPe0BF2NpLviEUVC4l7FaDrAdKCzKBUf1hLgvc4sfruvdc5yxVEc53OeRgyU7aVrQoRngyk2IArXGqlw8803NwceeOBEP8vxYIizOt2vznIXXXRRusZcb65x3eFDKTYNpoNYS9HQqLVcMeYo0bQEzhIKakaNc7JP1Hpe2BcUxSlU7xNF6bVm2QaLY510VhBnsxPuCoIK1GqIwrAfWq858rjOFYjJlYhNOHgMwSVvrsAuemlOfT4DdvFBEARtQhQOgmDw6BbQGWIWlYTgeuuttygJaWaPhJXgtOYBRQJDgkZCmijtkCfh7TD2xje+sWi1LKGyRjXzJBA/JeCI75LurKIdtPOsM6+X6KHbcmiwtZNUbwvCkPxmMciSjMVgML9RyMF5wLVdWxgmpEgWObT7WlJ/HCyhanSfSSiweZVQMKeoi6Ts17/+9eLPu1BRxa2DYhL6FNNqYS62/W/UvD57xllnnVVUFCZOeRDsXNcKK9i/2pd1VnrvhzQn2/5DfJyE0vbNPlsCoWSVogbFYIRgIo7OJHavfV3DeWY1rrrqqpT818VaSyAVVy7NgtxrF4/qMp2tlWLbFp3dJytSbgM6wRSmmT9LpCWe1Uz06zoS83k+z2v0ANtohUUsvLujW+Yj4ln2jDO9DxkFU6XiBP/PpPfyEAVS17gY2vrsLGW90v1ufVHkcdppp4UlabDM2PuNV+DukAVa65dibtdZdn0ojT3IXkCsyY5l9ksxPxeVGoVamVVWWSW9xr5FYYX5Ohs5wwy1IG+uIP9kPJr10b7cJ2Jrz8+xw4gYyH8ZZUEsHmLh0rRQQDJKFBaHyb3JyUUBdxAEowhROAiCBQGLwle+8pVLfF+CRQVjbQTju+yyS7PDDjss+p7Dn85aB1GWygTFPhKiLLJU25s3UjpA1Hll1qruZzPzHHQlKh1wQTBltdedgzYEJOEI/WbndedTE80mTeYFcxv3DoGfPacDWPceYiFpvSl1TWWBytczFXvoHK5lwT9T5/+QBLS5gDEHMPNUJyOBhdCytArw+cZuu+2WigzsTTpxFFmMSmbYN2vAJcMMY3uVe5mdsAItCSvdnATiWt0TfcKqOLtZtLFPSQbbn61XNQpcdCgrKvEZKoyallBFdHWdmcuoyMCMYfh8FdrUSJTpAJYIFV+6xjyX61yhA7FWp4w46PDDD0+JU7OHZwPxd4011kjvs2IH95NYy3MSKftIBophWURmvD7FckRhxQkKi4aA5LbCsElwDZQqBvQ+jrqXR4nWCh+GxgUXXJDiDRb77euZIExcOvfcc4vPgg8WDquvvnqz4447LnJ2Yjuv+MMeShiuZaVsbSSQ2QM4bYn5CNDOz/IW1vRaWJvs0+4fMWY3DlhzzTWr7B3/9V//lV43RwsF+d0z80te8pJUxBTMHrEPa/K+BWFwh7FXKuDJorDrm+sU96mgHEbCWCvEuc7t+RzpnCMOIwoHQRCMIkThIAgWDL/85S+b5ZdfPh1EHPQkgQmkxBQCZi1RBUTRUZW4OpeJhbpWaonCrDjZ9ejQkYTPSXZJcQH7bDtUurAnVOHMJui6665rfve736VksLk23S7aIeH99HCY3WyzzVICz2vXoc4OVqI2mP9IkMyUeCwpkpp5mrF2OdgTrPp+vc9+9rPTmumelvT3+s0j1cVcc91ciHhfiUgSkm18BgQkFfZDgFiiS9I8vXPOOWcJ8dc+7ZqvPWpAgkrXiod92PsuMauDWGfj0K5v7ijmvNmjCYaQkJVQygUJpVDwdtxxxzWHHnpo87WvfS11wXuf+xSHdSuL9fLc6A996EMpAa4jzLxqduy17IXNgPf627GfOE8nr/fEqAkxoATpbEXhLDhL4hPP3D/t4qR2Z6uYr4btPFFBrKnz3/Wk6FH8qfhAYlicPQS8Dg5EM+H+Evfphu8LCWAxvetd993QYk4FeWKgrkhFyNL1zwo3CGbDNttsk2JsYytcb85xT37ykxeJLLVQxKPjXYxtdrHnc5ZWWKM4rtaYEAKSLmii9yguvvjiJIqXxutRxLSQnA6mhZhAsb71sVTB8qRnGfEA0d+fbVxT3e8Fs8MIC53XxpgpHhP7ir8UFWtMiS7hIAjGEaJwEASDR6JEAlDXlUBURa6EL0tpgizhTkeF6vNaHayS3wI280AlATM6DlHLwtDh0mtlj50TojqgiA6qoc1RNn+uNCqcJc2WljgbGjp+XF+uJwkFAiFhT0J0pZVWmvavFxRAJ0HGZ0xQcdiSlK9phWoWp0ffojAk9a0X1lCCBlHYgd7vQthw6AzKIDnH2lgSRyGN60rxklmS1pahVNe7juyLElW6VllETzNp8b3vfS8lZXWbce4gMpTsDLI35H14Joh3rJVrsd9++6Wugfe85z0p7mBzfMkllyTrSk4fJa26OaNIsuvEJlDpZvX84qCf/OQnKdldG/eS1yTBbi6kDiWvXdKZ5b41rQZem2T7KGtMwrDYDGJQ1/9s2WCDDdIaLfZox5ajsI6492oUWLjGXU8wJ9x99b73vS8JK0MZn0HoHSf2er06wRUIcg2pLSbpCj7vvPOSTfvll1+eYhBi/ChnpPmO84QiC4Vp7WIda5iZmQqNgmA2cFUwu5to6Rrz92984xvp37g91HB8MlKJY4V9ib1+22JfkZq4RPxQA4Vvo2YZt9f0GuRCvKA+xEGFYOIdZzVzfNtzhXVr19ib5T/EWe6fbkMAkXJo7kfTxrrBCUdncO4KZtEu/1nrPg6CYBjEChEEweARIBFidVlJHrASlGSXnDSDUxKWbaROkplsUmfbpSwJKDnJFmq55ZZL8z8kZwXGEqcZlX4SSiWQ8FQlSlxg3adzV5eQ90MSsVZCtJ0gy5a3EsMSlRLCQ7V4kwBkxeXhuqo9czaYDgQOCRz3tUMYcYUAwpa01jzvVVddNc3iZsfadxU9McehnpiQkwfswNzHZp6pRg7KoFhJp93jHve4xQ77RDsiy1BE4Yxuc/b61sy+If66fz3shQp3FE3pHC0954415aT7AQGtBnfccUcSvTmGtF+fURYShQo8SorC8Jp1DHtYuyS4dTIqqGGhzO5O5yXRtgaKKnKXrG5lxQhZ0GMRWqvznqggjhN32hfyZ+85raM5SUoQKOESQwgkDoorrR+ut3HXUan4chSSzrlISFGF/WEhwGXA56rYgThZe0Yn4cr96l7y3JL+ijrMktbdOEQI4OIOZxdChjXMa3fdK8Kwd3rAuceaEwSTotiAi4QiyFG8+93vbl74whcWe0MVODiXWzPyWIEuCkFrjpayTxl75HfIziFEYvfatddem2Z3y1eUwHplPAdbaF/ne3UUYR9d9jN2nmifKdrU6ATPKFTjGiKmVmBx/PHHpzhMzK9JISiLgjxrhryis5Wc27rrrlstvg6CYBiEKBwEwaBhlUh4veyyyxZ1/ZironIud8hK1jn4sFGqhYRNdy4QYXZUkO7QVCMhygbK4U4CuHZCFJJTxCKzzViEvva1r21WWWWVZNeoO7u0VeVcQBeSQ4/EbD5gZ9jezdYiMpg+KuvNRmL5mS1JIclvDall2ShJ45C39tprJ/FKcrSNKvAtttii+PM6yOtAuvTSS5Oo1IYoHNd0WRQujXIVYPsmAT40CBnGK1g7++g41+FOGCVOfvOb30x7oK5JxVI1raoJdLXE3knRkSruGCV4SxpJ1NZEMYsOBg8FY7pFJIY9r4KXHJuURBGaopYPf/jD6Xmsk7pkdA0T1BQH1sLzKuQQ84h9CFeKD3TQEATc6yVn6xEDPdgWs2zU7d43PlcxEGHF3tHG/bX77rs3Q8JnqkvXtcRFpKYQKZZvdwW7n1iyE0idbxS1DlUQhmtK8Yq1iojlgSzAi7szQ9wrg7pwzuL8Y/0ixLa7KVHawtm9qkBLXC0uYVndfT6C3Rve8IamFvZdRSyjuoXFY3IjpZB7yeOqfD1TAW33fBMsOwrEPKaBIguftZEsrmcFawqcxT/tjvhg9hDfjQ7Zaqut0rlcvkCTiVynjmEjerprWhAEAUIUDoJg0EiCSpy0bSBZRJtV2LZ69feu4FGSbOUC3YV+H4ej2pazOoQJVSoy2WNLHgnMdUhJyOpgqQXbageAfNh2wPSnSsaDDjpocKKw+TmCcdebbvCuXU/pzrNgOpjZx35ddxvLt/aBjOVvzU7eZz7zmWP/zRpWA8Uj1ilCxqg1sg8L2IWELj7rZNs9AooNCEtDQ+JCAlD3CIGYPWN7T5Q4LNkdrdOHmECgZe9KEC5ZiDWX8d66hzmGmGHYhv2q978vfK66w/fee+/kIlIrCSzxznqdrbHXnEVJxT1E02c961lNLYhXuQCBWMoenSita0YxAtHUWJGZ1vVlgSV7rf1gJhR3iHXZroo9u53xfc4z7APCLAcHXdri3dr2964hyV7d/JLq7JSzUMX9aOgoGtEB1bUiDYISKCrYbLPNehv1o6DDw36sOMpe2DcKpQh3u+22W4o57Y+EaEKxjvxSXcJ49rOfvdjX7b8H9SAUOreOg423zuxahFV4P+j414yRi1vFYR/96EdTERkXAsKwc3wQBEGXEIWDIBg0xIyuOCfhPI1qubPPPjtZV7OLMmNWUlqXiIMYEbEGKjR1NeqSUZ3JJhuse3SulraKzKg6VtWfk53sgnIHhcQOm66hkZO+xPYIvIcLQWnUDHAJcF14uuBriMIEjNz5JflOrPU8tQtLWKIrpDn55JOToNEW89jpSf4H5VDNrTtD8Ux2kpDwJ2IdddRRg3yriXVdkTLTnh1ZArM27XtDE6gmgYDk9Ys5jM4QE1hHuACcc845qailb7K9dE0ktz3a6J4ovW6Ke9j66tL1tSQdCM9t8dke4rn9XGlBGPYnXWcKl/qc080VRqedApbSXXVzCUWV9j6foRnwNeaMjlsLxQAKOFi7WseISjUdDuYSzhHmU5pRHQSlsR+av9o3Yh/FgN/61reSe0Tu2hXbO0+ItWsVURvj4P+2bpuZzMnCnsTlSxzaLmifLc7G8iCTYIxHd88Olg0FaN2iO2dIjiKKxxZiLDxE3F+j3P/EumussUbMFQ6CYCwhCgdBEPSA4FvlrYS/wC0j6a8L6otf/GI1odo8EY82m2yySaqIroXXovvqpz/9aeqGIZjuv//+6d+IxcSzoeF16gYOQXjYEEglJ7vW7+zZORPUnP/FYtc6Yj0h7CjyOOmkk1KXupnGtfCcrDF1FbC5Y4lKdHAAfcc73lHteRciT3va01IXGGty7g7WEy4Lqr3HzQSbzxDG2J5Clz3BhZOGRFUNYUmSVTX9JBgzwa50SHhNCuXcywrUOJaYset603m4UKhRSCPRKrYy083XMyW1xUd+rgbWZbPkiIe63rrdXlwtaliZu28Jl0MWhKH7Rge416vLfSZ0/5XqwlLk6T5VVHnGGWcky2oFpuJpgk53ZMnQ8PqNBBJrd4t9g2C2mEN9wgknpFESCrUVRLZxj9UqABHPG3M1qmhKJ28t2q5pzjbO6hB/EaPtY6WcVMRSk75/bXe3oFxBcRsFgQTDmu/1t7/97dQMoUAujzLLiEs0KATlzjaKh52j3NecarL7Twj/QRDMRETUQRAMHl0Z7W42VbiC4e73alm+5rk9ZuqquiUAZ7bbbruUYLrllluSLVoJLrroojTD1//t6/bc0y5s7/xcDTbeeONUgSxRpRJaZzKr2Te/+c3JTmhoCMAl2R3spzW/J6gPQfQVr3hFWlckTVS+E/HOOuuslNipVRSgg4D9kzlM7bVCl9CWW26Z7mXdBjUgFlm32GUTpiWRiNDeh27iLJjfM8CmgSSGMQdErMwKK6yQCqbsIyW54YYb0giHSegmsYaAe5co6KGYRCfp0OeMcUphn3j77bcvMTtRwt21VwLJ8zxT3tczdUXVdHfwf7NjH0ctu3SW4Ga5SgSb5TxUOGbkObZLo0YhD+Hd/uuhOMs1p9NfUnijjTZKHeIvetGLUvff0ERh4gLLf2eKbvebbqghni2CfvjgBz+Y4noFUx5duAMYP1GaH/zgB6lL2FndNb3zzjune1pXvLn0Jbt1uxhJouDQSBy27NxCFJ0o3nbmKOk0ke2yJ+Evf/lLsecNRqMg0Fp64YUXJge3GriurNXOqN1xEt2/B8t+frJOmE/eLgwT16+99trp30o7LgVBMCxCFA6CYNBIiuQZckujprih+2lc14j5PZI5pVAhmOfX+lqibhw159xK6BOvdAs7EAhQicLE4Te84Q3N0JCsEniz5/S6He7byXav2zy4YH6jW0DC6PDDD08HMEkUFfb77LNP1blM7IQlRc3HlDwicMCB28Fe93ItUTivU7oMu0ggxYGzLDrOc0JfgQ+xVNJmqEKxPdprNoOe2GI/9JrNnNXpaO0sRZ5zv1CQ5GZxK6Ht6zxCYhRcDvzckJBs/8AHPpCcDqzTXQG8VDEe/N863/PXOvzb1Lb6z2yxxRaLvla4pKtSfFvj+b2/Rx555KK/ExLEe8SG7lxj3XdDiP0UYs0Vy2Zro4e1Unc4Mcn8QEVqnCaGhOLZ3Pmk+MCjTc34Jxg+9j7jlsZRywGBhbM4Po8ScF3rhhfXO1dyFxsVe5dg++23Tw9W0eJLHYWEJHuF4pKaHfnmsOts9FpzsZav5QzYR9d0Pwr+rxnCyAdn2hoQ9p0PFSyFg1odxFuK0f0pN+Ae5hxyxx13JEexo48+OhVvcxUZmutREATlCFE4CIJBIwiaCwcLiW32su25cmAfaAadfy+dJMpCDjtD9pBdrr766tQxXfoQkCuLHe7aFtW6kiApPcTOJAkDSalxiamaAnzQLwotPvKRj/T6nApLzDwbhfucrXONJKykjc4yFvRtG1JdlMccc0xyQVBpHpSBu4MEoAM9QWerrbZKxTQO+QcddFBaz4fEj370ozQz+YILLlhMROLkQcByfZUUhbv7lf//hz/84aIKe4ky37/uuuuSmDjfCx6y/Xj+eqYisW7n3RDQhWVmMaeWvjCXUtHQoYceupg1Iyth15cYSIFPTcSbOkRc20RbAoMxANZxSf9SEJvb+9K4PQorrrhiMwRYNk+650nImv1bG/f2hhtumB4S8bq1h4bu99wBnx2fRs1QDIJJ+e53v5v2PbbG9nyC5Dhq2Ue3LZwhH8DGmUjs7J7dJ2ogHlBM4vmdyxW5Wtt0cdbsus9d0Cy7swiuoIqdsHjFfhWUwefL5amNeFeRoHOlbt4ayAUp4vE8uVguKIvxUe5dom871hSXaUQR+3I3k6/Yc8894+0PgmAkIQoHQbDgkEzIoiSLpGuvvTZ1MNRMiLJ/UvnKtpLFsAS4mWCnn356+n63o6JkdyF7uVFzP4kPDmOl5ggSfc2pk+D39Ux2RA4Lfm5ISIaaRRUMD4LcpPP6HMZqdINJFJ188slLWNr63Vg7s5YuCetTyQLJGhA5dB5JirHg1fHFSrq0ve9Ch9Xtbrvtljo0Pv/5z6c/dc1ay3WADU0UZn2mg3PUHmgPIcDUwjVthqAunRtvvDElI+2JEmUvfvGLB1FZz4Y7rw2+1lG4kFCkRfhvx321BWFCoHjStdRO1Cl0MGrAHD+/k8+jBrrLFJYoiOQgkdHdSpBW6FOqc4eoMCruMftVBxzHA50rQ0Jx1KTiUC2r7plQyDLTPOv5jGvKecb5RXcUUZh4xgI+Ci+DO8vxxx+firXZQvtah/04atlH684VSysSt0ewcT7zzDNT15/1m81vLeQfjLDK47OsVyzoFcY97WlPS/dZDRc1r/X5z39+8773va8577zz0ngHjiaKmIx0iLE05fCZdvcrZ1RFDq7nSUchLAvWanGIrnOFcO0YTOHBUPepvsjn9HFzoeXajGzbZZddQhQOgmAsf/e37nClIAiCgVdM6v5RVUcQlvhlWyn5S3CZqYumRKJOEtphyHMSeQTKrPZKWjQRr9jYqnq2xHt0RSrf83MlD7n+v0svvTTN9fK1TpWZumr93HyHeOAwn22/xnH99den94ZFVzD/kCSR7J8ESaWHP/zhxX8H9xRbUPduthYmmukicLj2vCW7ZnQ3ua51t+lCdvAk3lkzWbFaM4kBz372s4s9Z/B/84R1ajjkWy8kDHVUEOd93tb1IUE4c61JgnqtbXQ2SiK9/e1vr/Lcus7MvbcPS1zZN3XHSGQRHEYVU803dD7tt99+E/2sxKFrbWh4TbfeemvqkO0mm3WwlJynZ1YzwVVsNcpuVBHPdtttl56z1CzjLocddlgqHiIAE4clXnPnlU5S74cCvlrXm/8/24KCyCExOVcsl/uk7Z4TzA7XtPjDeUYsRPxWZCsGMnLAHlJTQAuCWhgJ44zIfUeXMGFUJ7z4x789/elPL/Zcl112WRJ7oYPU/PHu2UGOwv1kPECNeyqP8bBfOkMbu5RzBvYKezXROJjfiOEJ/s6o3RnCzpDihGDZEVPJa+acwCjkDB7zmMckd8A+xpcEQTD/iE7hIAgWFAcffHDq2oUOJN0cuuxYq3zwgx9MVau1UI151FFHNbUR9BGfdUA7ZLKA1ZnShggtoSJQLPm8WeglYH3lK19JB4IuuqV9DkMQhR3eTz311MVEYa/b9z70oQ8tlih1EA9ReH5iFnR37rfEu46wrr2suZw1cH/pMtNJ+qUvfSlZcuWCBDNZSwrCf/jDH9I1S7SQECKk6AxWbey5ieQzVScHy47EiYScg7yE3Mtf/vJF4ukQOle76CIkVHmdHma8Es6soxJGNedius7znGYzULlXsFtzP9W0TuwTwmTbBYU4ai+y/3K3INyxKtcpvdNOOzVDw32jyMJ6dvnlly+RFCMulRSFvbc6/MfNn7SWsvGrKb7bG8bFV0YNdPeyUoj7zKe0L7z3ve9NdtGeizOO7+uOnsleer6iw5Adanc2ps+B2KHwM5g99gTvK4eltlClmMdDx2G2lw6CZSHvhwohu30zteyjweI1z4JXnK5w3X7lOUvPyvb/yXcoWPF65QrahemEaOcJ5/RaRRbeR/NsoRjQPs323nnK76LYI5hdAY3Pd9IzR43CJdeWgh1nViL/EMeGTRv3p/PiTKJwdqwJQTgIgnGEKBwEwYJBolkSWGcQJJwloyWlzb5VsVoS9nlmQU6CgG1cEnFZcMjyeNzjHpcCxpod0G3YyhJ9HUg++clPjkys5zmlQ0VidFKr4WB+MKobluWag26NruBRuG8c8gkK3dlAxEOzWUvNXrVOsvNtJ4TMhnJvE8jnwpz2oaJrln20JA2b0lxwcuCBBy4SMIeGjnOFTCeeeGKyk2Z3p2DpE5/4RNX7SwLS/ghitIp7eH4JLTOda4126AsiYO54luRm984tpbs368b2eodGnonuz9rzoV0zOsyXNi9YgSAb3FpwdNB1pauyjSIi40RGFeuVQJKfmKKQo21PTaAW34oJ99lnn2ZIKDh417velWIBn6nXaa/0/uuQDieNciho0THZFaqISCyAb7755oLPFiw0iJI6dLmI9Wkfbf63jt33vOc9i74nHvFQtG6/9iiFmMbYDLz+9a9Pe/9MolINxLIHHXRQikOsnayqFZraKxRVEa2DZUfTwzvf+c6JflZOrMZYEfEmwTkE4Xo86UlPSsV2zuXj8O9+LgiCYBwhCgdBsGAQoEraEewc/tjBqoSFRF7p2V8sAlUcTxrAl7LzYwt10003pecn0rKeGsdaa62Vfq4UunHagtE222yzxM9I4JSefxoEQ4dgdfvttydL0C7nnntuKiwpJQqPmr+pyliXW8n1IlgS3dkcJcxWY6OXE+CKmiZN8sw3COCuaw+WiX1ZgCqaIuiwbGTDRngnaNnHxAl9J0pro3NR18CoYi3J7lGzYec71jLrYm1BOMc2Eu4KeCT0x0GcJdbXQscZ8X/nnXdOxULmkSscOu2001LS3ezsGoijOWWMmlesMNHvMTSMg2G/ah3RwWr++5FHHplicF3CQ1tDpomZwV/4whdGxiesMdddd92p/W7B/Mf9637V+W8d615jJQu3wflHR6x92fV7yCGHjFxfarkPYauttkqdwuOQl6jRRaponYW0PQNiD25Euko32WSTonbZCxHFSEvrauduYT2tJRgShDnvKO7kqhWUhwMLJ0DxrT/bHf+aUlh3Kyg56aST4u0PgmAsIQoHQbBgYL2pgn///fdPlcAOJbqRdN/p+pMgLslrX/va1FnXRvWr+W7dhKHOkVJISkqe5K9n6hLOP1cKIrND7J///OdmzTXXTIeONg7ZEv5hYxMES8faJOGsAybPB88V/pn8/T4q6+PebXp5j3VMdDn22GObIcFJQwJQ4ZR9iH2ivarPmZBEMza+uhvNllXEpJPR/iROGJrdnYS3zmgFByuttNJi/6azsWbyeVqIQ8R3hFodtLUxB1HXu8eoOIeLCtHQ71ULncpsG/0O7Jt9zcrZPSaJWAviu4IK3W3teZB+ByM1hlgMqNA027sS2/M+zI6eoCIe1sUazB73jEJerk5GDbjOFcrphPrud7+7WKdlENxZ7Itcw7p7Yy2sycaxKPgTg3Bx6IrQioeIpbXQKewe6iL2WWGFFZqzzjqrufe9713ludtjl+zN9qmgDN7PcfEOxwVd7yzCzz777GoFago8nU11omtOIFK3Cys0YhjdFiw73EgUpCkgJv6ymxfnK7ZQaCL28v6Xzm8GQTAsQhQOgmBBYQ6obiAHMIk5Bx+VuropSlvqtQ88GYkxnRqluoLHJeZyx6BgX9XtIx7xiCV+TsAoaC8tYgn0PczWG1VZLSnqfa9RfRwEQ8I9omuUq4EOJIIOkbiNymDFLqUt4t3L2U4XDpfd7+XfsabAsRAg3kjOtUUkhUuShm1YG5588snFO1amgUTnN7/5zbQXSuhvvvnmKSnY58xRXbMSKrm63ixhc991CXPZ8OeQCph0+rMUJqjoJlWcJgawVxPydC4NDbOSJT8V4xHtWLK3xX6dLDo6SxYaWKN1YHlI2nFxYM0t5tKFluPPmii0OPTQQ5s++cEPfpAKC3bddde0Hym0dgFmxgAAPE1JREFUUPxBGLV3KGjKRU1PfOITq4odfeH1ZrtZ95OzRJ7xF7Mxy6JgSCHRm970prROZ9xjiqaIWEGwrIg9xNp98bznPS89rrnmmiS+conpG/F8e9xRdlIzE15sVksQ5qSgcGYU4hEF9fbsoBxivaOPPjq9vwpPSzlLzYR9cFyXcJ8FoEPGGDyfpa5gsZazi/ddHPqSl7wkNcAEQRDMRIjCQRAsKHTkdhOfkmef+9znmiHCrk/1cZ4p2LWZlhR/6lOfWuS5dAc7RDrg+voJT3jC2J8lJPm5IcCiR+Iz47WP+l4wf1HJ350T7e8+Y2JpV3gpKSQRMjwcoL///e836623XtMHXhe3gy7d793nPvdpvv71r/fyOw0VnYy77LLLYtcNK0wiUtsOzMxOlffzHYVYl19+eXPmmWemrhz3ElGcva2Ef19sueWWKZHSttnjrmH9Ju5dcMEF1ZKi00LxG6s5Ajwxy/X12Mc+Nllo1yxWmxYKKLw+j1Esbf7vnYUwxS5Rx7lruvu7EKEl/2sIWGI94hhRkh26ruBRVs618PqIwe0CJffPqKRkt+BlvmIWpgILcxNZnurIUVzCkvO8885L8xqDcri22Pzedttt6fxi7R7aGh1MB8WNilZYGStaEcu30YW3NEveZUFsb60g1LHc7RMFU6Nc1RQU2ate9apXVSlCdA+L+/bee+/Fzlk6WMVktebeL1TOOeecFOOxGGYl3Eexo+t6iCNJ5iLiqSEU2QVBMB1CFA6CYND84he/SHZjOrF8LVkzDuKGn5vvOGipDrzuuusWWct2RW/f83MOYKVwmFXFn78mdIxjCJ1uma997WspgdCl+z1Jw2B+4iA9qoPA97uo+H/4wx9e/HeQBP3e977X9AHB4itf+cpEPzukTsqgH4iRLFezTaNrSLV7H8VZOu51wUA3iqRnW3iHYg9imuTo0LA3K+zwYH1rL86ds7o5h+bgQRz1GIfXXBoiKHFB16g1W4GNNZVg+K//+q9NDcwpJkBKDip0VPxIJJYI7lOwy0lg7ytxmlvN0Dru29jrORDl6+iggw5K5wzxr07xsG0sg2vI7FWuKLlDW3GLTsd11llniTU8CO4srN9dY5/85CfTo4vz8gtf+MLib6wiNA4WfQvCMyEO0FlKqK0xF12HtHEdIAyLy4zs4CRmtnKN93khomuUG46ubC4ltWNasbP9jy20r3fcccexPxv20UEQBHODiKCDIBg0Dlm67PLXM1ms1jj4TAPJN+L2tdde21x66aVpll5XvJJAkVAxU7nk87LGzgkcotKoal+JeEJ9/tn5DFvud77znRP97BDnNS4U9thjjyU6gvv+nFnbmZ33q1/9qnpnjHt5aR0RCkuGNnM16AeJv674SCz7wx/+UP25zb3Xcc+9wZwzgkK7I8g1rXvGz82lJG0prr/++iRYWc9y17k/JfDMIdO9PTTMzVOs47rLr1kiXizCKaVWVxJxuC/rPp+bwrM8FsV8zI022igJ033aB3IBkNznROP3IbRceOGFqXjO/O4h8uxnP3vR15LvQ7yHpl1EtMMOO6SYxJrdtobnsMEBypqWBeMgWBaIvgS0vouZFceJQQho5o+7zttFNOL9WsUl3/jGN5YojBIb2S8VytfKi3Du4GrBBl6eQlyy6aabJoF4KLmYaaIgSywg//PWt751rFV3adwjuSg6O4eMI+yjgyAI5gYhCgdBMGhYQb7uda9LX+v8kegdNevXDB3zDUsiySrx2IZYKvHdFZjMnCt54MzJSAdJh4NxgXnpziBVqRKtkq8qrZ/znOcs8TMOKV/96lebIeDwbmZzMGzaSd9p4V41l1KiXRJJwqbN+uuvn2wsa0BYUL3//ve/f9H3br/99tRtaEaVdTYIJmWaFtiSra9+9avT1+4n3XwLqWDHPWvPV9BErLNuKCAzD/aII45ohoYCAJ0ruVtYrKcYTjJc14xZ1rUQ7xFHFR7glFNOSTahfpfXvOY1Rbtnb7311mT3mQt17BHiP59rX6Kw+5qFoa4395juZTzykY9sDjzwwPTa2eIPDV1uXA6sJ921Tff2EF9zX3g/iWWuKbOq2zjXnHHGGc3b3/72JBp//vOfH2xHelAf1w5LcudYLhoZ51nrK/totvCl4ejwrW99a9Fa0oUtvS7PWgWvYvlRRaiTFjwvK/anLAzbu0aNuQqWDfvRxz/+8RTjjHK0avOyl70sXQclIPTm/8vXBOkgCIJgbhOicBAECwZiJWs7idBRosdRRx2VOitKsd122zVXXHHFEt83562L4L3GPD/JbrN73/e+9yVRqd0lo+PQoUyyrhQ//elPU3Imk+2hul3KEqJBENw5RhW0ZGoKs29+85tTN073+RRFWDdj/ldwZ7EXtROvBLTu90DkqtWhYxa2ZORCEYUJosZoKMpy/66++urNnnvumTqRiMX+fWiYw60ryRw9M7olKdmHi390JtXsBvc8krOXXHJJigV1yiqUM3PY9T5qZnvp7nvd331BBGa/yrraNZZFYXbWL3/5y1O38NAEUp8r0dLebI/sipJRMDU7LrvsslRg+5nPfGbkfGzCMGFpgw02SO5Ec6GAL5ifGBFj9NIoxxJFmO95z3uqzSW3N42jZqED+3V7URt7Yo0xEgrFFW50IVwqGLIfsxSGz+EFL3hB8d9hoeCamvRcNlM372xjEvGXOMAargNcYYXRMUEQBMHcIUThIAgGz6GHHpqSVFkM1bXQxfdLd3xK+BGiJ6EruJRCdfPrX//65glPeEI66Pm7r3XJqOJUIVoSndhXXnllsp9ac8010/N0E/yeN6r5g+DO8YxnPCM9RqG7QTK+BopJ3NN5Xnh3NmmpCvOFjtmjXfFz1PeGAmeORz3qUUt8v/s99r4EvRqYd8pJY6FAcL/f/e63aK7tQx7ykGTbyLJStw5r1le84hXN0F5zTkKKs3QOW9MI4S960Yuaiy++eNGIkdJ84QtfSIIVWArrEP7ABz6Q1lOFNiVF4bnQlW8Pck2NEhTca661oUHwN/+S9WxQHoKC9WmUIJxxplDcQ9QLUThYVlgm2wsUUZ988skpxuW+I/ZV8KxjtwbOw4ql7QuKePKaTazlKsaBgONATcvomcTFUgKx2GOUADnqe10npODO4T2tJfZOApFf5/dtt922xL9xqeHuoFgvCIIgmD4hCgdBMHh23nnnZBeoM0RX23777bfEgUylaulO3Zm6+vpC9bGEqM4Ulljs11Q7S4Sryq0xE1SlrwdLrK6g4bCrClv3ssNmEATLzuWXX56q77/0pS81W2655UiRrUS1tzVy1Pwn93cfc2AXAtbjSb43BAhH5o5OmkisBaeM3XbbrXniE5+Y5lGaJdzGv7EtHQreS3t/Hhvx4Ac/uPnud7+bRBf3snmwQ0MXuPUR5jYSxImTPvuarznPLM6JWeJzLsJbeeWVUyFPaYgI7U578Vb3e/C6a8R+ridW5N3X5r04/fTT0302NLy3Ps+gDsSy7hieUdTobAwWFlw0XvziFydnA4KV7nRfi1WMWag5n52rlq74LoTp0sXb4yyjR2HfUtBTAgUbUbQxfC644IKUa9Josdlmm6V4X45NgYPYy5lVkcNnP/vZag0RQRAEweSEKBwEweAxr3e99dZr/vSnP6XkTa1q37masHr4wx+evvbaHWrvuOOOZOMjWGfnp2qzBmbpEeAdPrvdKgQmtkJBENw5JNwl2B2szYtUgCGRxW6t1vrpUK9bQoFN7vInLJknzHkgmB06YSft6JMkn+/c//73L57oXBbcP1mo4qLRpSumzXckmBWO6FJlbczZw/gI3//iF7/YrLLKKs3QIP7qwPr0pz+d5gdzMGHjvOGGG6axHW984xurPC/hlQjtGmOdKPby3Ln7sVSivY15vl2yIN7myCOPTDFxDVF4jTXWSDMMOfLorvvQhz6ULEOJ70PspmWHTWRRwFOzgGWh4jr6yEc+korTxlm9K3wwi3XU9R8Ek8LqPce31jJOLfA9xdU60WuIwvYIM4U5deiQFWcTzHT02qte9apXVbeMHke2cy7Baaed1px99tkT/az1lCV8MP/ghmIsyatf/erFvs+dRXzgIQblonLQQQdN7fcMgiAI/o/5n1kKgiBYSuXvwQcf3Bx++OHN73//++aDH/xgeozCYczPDa1LRmIuV9KbAXrdddclS05Jy5ozBCUAzY/ZeOONm7e85S3NPvvsk6yEjjnmmJTkCYLgztntnnrqqSnJT5BVWGE+pfuM+FATczjNATcfc9VVV00JWs4D1hA2e8HseNKTnhRv4RRgE5lxT+merDljdq6M0yCQQveTdUUST8eG7o6hoUNFsp1tNHbfffckHnGNWWeddZI4XAtW3OxHdToShK2drjMJU8JpSTzPpAWPNRwlMvajE088MYkahHBisMILcbf4c2i4ruyHxGHFU11nAR1RQ5uj3CdcnpzNiAgEMkVqbdjtOuM53+WiiyBYFlhHW7c22mijtB8qoFY47RzLdatWIZs8heKH7C6m8FNBmsId6wsxteTe3HVE6XMvnnQP6N7nwfxArONsuLRz4Stf+cpmr7326u33CoIgCMYTonAQBINGgjfPi/P1TDNWdM8ODck/AbqOGAlKnUEqM81AO+GEE5pddtmlyvOqQr7llluaU045JVWHOiA4DOpO9uenPvWpsI8OgqXA6pUQqytYckiiyuxPySKzDHXh1xaEwepdt9cZZ5yRuhoI0hKwOu9KdhIEwTRmnxGHb7zxxvT3FVdcsXn5y1+euhxqWOxOG92MeZatog5Ci0ff82f7QlfuzTffnNwUQGCqNaO6y+te97okKCi+IzTk95hQKClaktyBM23E2e6dbpfQUOHcIK6eqfswmB1cDdwvrGcVPujWdMYww1o3pXX6ox/9aFhIB7NCgRAB9sILL0xnZB262223XeoU1jlcq3iv3aGMlVZaKXUpE4k5eRGqS6OQxZx7RdvW7Ne//vXpvJFRcLrVVlsVfc7nPe956TGJSF5jvEJQH0U6GhCWdi7kFjTEcSVBEATzkRCFgyAYNA5bEnO4293ulpI3o2b9StrpmBkaAnNdMua4QLWxThldMkSdnCgtjSSNamTz++BATZz23uuaYCkYBMHMmGn2/ve/P1mpHXHEEcnCLkMUrkmeO4o///nPSUzafvvtZ/y5IJhP6ALSNfqiF70oXdsEHslY+5OOB93xQ4GIQhxV/LbCCiss8e/iH4Vi1pshYUzFV77ylZTknwZrr732Yn8Xh5ofqbNR59TQkNC/9NJLk9iQYd/Nnv0FL3hBMzR023vghz/8YeouVHgQVtLlIAIrSNOBbl5lFoJ9n3C15ZZbDrKoN+gXZ1aFzO5h7LbbbkkIlh9wbq0V57qOFS9ZJ41jUcxNsF199dVTjKIIsyRGaRG85QUe//jHp8J59tVGLdifzH5917velRzF2meOmiiWMr9YwThRnkidR18F8yvOVGy4NPzMJLPigyAIgvqEKBwEwYLhl7/8ZfO2t70tHTi6sLkjlOZujiGhU8XDQVclMHGpdgJFwkZHMMstB02HTokc3SMspB1KgyCYmcc+9rGpa0Bnm6TNc5/73JScqp2okdgnlH39619PX48qpMlIgPu5IJhvKJiS+NUNlDHHTsGUbtoddthhEN3C11xzTRK/xTkgkL7zne9MibmcANaNJEE8NMxJPv7445OrgrWqL/7whz8km+5RHcHmKh522GFptuOQkNh3LxET2qIwsYVDzYMe9KBBzqBXUGFEClG4vXcfcsghyd0jmD0KKKzJ2eUgCEqgCGxpHYsKPBQXcRqrUexhfTRH2BgH45U4SbCqPuuss1L8IU4pCecu+z6XlPbr4RiSZ90rpve7GDdRE+cL3dn2SoVD7Pc5tQwxF7OQYH8+EyEIB0EQzB1CFA6CYPA41Bx33HGLAlGze7r4/iabbNIMEd1Bb3/721P3hipOmPFmTiixuBasoiXVL7vsspRoP/LII9NBV2J60tl3QbCQecpTnpI6ZCSuJE7YwCteMbtQYUctEcf/zbIxf82acRzRJRzMV3784x8nS9IuT37yk1NSi4Wh8QfznTe+8Y0p+WuGG3GUXfYnPvGJZOVIxGNNr3t1iDOF2Rl6+JwV2BCG20K/QhudhqUhuL/nPe9JX2dhWMeZxLtuR/HR0Ljuuuua3/zmN82b3vSmxb5PTFEQ+IUvfGFwovBPf/rTFOca6aDQgjsOW2Nd95wGFAAMfU55nxCOTj/99LSO5fNMRjGP+zkIJoXwSXyddF56LccJ66O58Hm9NDbm8ssvT2f0UTmL2ZA7cWcSuInCNfbFXDykkNRYHL+LWEs3NOey/fbbb2ozj4MycEHR7b40huiUEgRBMB8JUTgIgsGjAvcxj3lM86tf/SoJKg4dbczyEZxKBA8Ntq+SvSuvvHJ67bp3vQ8SVeyjWFQ98IEPrHbIzYdZz6Ha+dRTT02H3FqzjINgiEgSKeLYe++9kxWqrr6vfvWrqRP/P//zP5uXvOQlaQZYKYHW/2OOcP5asjUXz3i0Z48OoZMyWJg84AEPSF20nCzasHI0c6+Ped21sd/rYCQC5/mm7ml7sY6he97znqngxBozVGYqQqsl+rPhFHOJdayX3medo6y7CYZ5fR2aG4+CpVH2ke41ovHQ+PznP9884xnPSIJwxnrimiNyKMbM+2cwOwjBHEyMxTGSpnudxRzS4M5y8MEHp0KdSdf0mhixZD1RrCYnYV1ZddVViz8Pt65uQbjnMT4jIx4Q65ccc2B/MBKHRbTiDs8hP6OghgiuSzgE4fkNcX///fef6GejoDgIgmBuEKJwEASDRzLOoYNlMXF0XILQbMyhoRpXYvvoo49e7MAnSbXnnnumg1hNOzY2gqz1CFe6JXRUDDn5HAQ1cQ/phPEg9ijqcA+zwFWEQTSugXv4wAMPTEmrLmEfHcxXdOYYKSFZqSvf/aUr31xdHUFDSFqxiVQMlgVhKJLbZ599kkUj6+ghdzKay+gxrXnChGFdV7oadY7utNNOg7iuRkEQvvbaa1P3rGuuzZe//OU0O3NoWDtYRXcRbyuK9F4E5c4zuv0VuJSesxosTKzFM63H1m1zfQmZG264YXK9qoEzupECxi1ZJ4mx9mYzjhURyWOUgvDaHeFkxEIbgrAO3pIiLcc23cGKWDllyMcEw8K9xBGufV0ZJTEEx50gCIKhEqJwEAQLBkkEXRp77LFHmq2bu938af4b27tzzz23GRJsEx0w24JwhjhbM2HFKpEILMlOmHbI9PustdZaaa6xav8gCJYNh2zd/h7usZpdMgQkCX+CRjcZW7t7IghqIcmrK8csv//+7/9O37NXmmknThgC9t3u/k8EZguvS2rIgnAb8V17dqTkpTWtJGJJVtxtxF+77757sh6VYM9znTnUDC0pTrBbY401mk033TR1ya644orNHXfckUQVexTb36HhM1Sctf3226fPNON1K6aqZTe7EFHgQjQLQTiojb0iz7oVI7CF57pVAwWeYhDCcNtVgDBsXTnppJOaHXfcsdjzrbLKKqnAouuQ0saabW0blTtYVrixGZ3ANYw1tuJWIyyGtg8G/we3HSM0FAEEQRAEc5e/+1vbAzAIgmDgPP/5z0+JO50yX/ziF1OnzPXXX586WQWvtaqAp9nFICklIcmKqv39rbfeOtlm1bLNNqtQlbXnyB0iN95446JZxl0b7yAI5h6S26xOv/Wtb0UyNhgkXEJuvvnmZEdqrxpSJycrbG4g7YK3Ud8bGkT+Qw89NFlfEvhZZXM7aNvef+QjH0lFaiWf84lPfOJEP6so7sorr2yGOLLEDHrXlqJDYsrjH//4NMPyQQ96UDM0FJSuv/76SQB/wQtekIq12LPqLCResktti8XBsnPTTTclu1njM4Zg7R/MLZxXL7744nTvcjbQKat4WuGl3ECtAkixtQIt13UXo54UnXz4wx8u9nwXXXRR88Y3vrE59thjR85+VdBtnrAcwVZbbdWU5jvf+U56reecc04q9Hj4wx+exGcCscLTYDjYG9/ylrc0z3rWs6b9qwRBEARjiE7hIAgWDDrpdGmYyXnf+963+cY3vtHsuuuuyebuDW94wyBt3nSteH0qnAnhEt4OYVdccUVKih555JGLflZylJBbAsK799d7rTs74/DHEuuVr3xliMJBMA+Q2PbQcRgEQ+C73/1u6lqUiFx33XWbJz3pSWlvGir2Y2Jdu4Oj+z2ICYYiiL/5zW9On7Pkd7socNttt01fm6l80EEHpc7WUt1QhF5J/EkYqlBIOGGX7bEQ8JmzdzVTmLCjwMRIBV1wzhVD/ZynJcATg4lHilnblvjQZel9D4LZdAWbf84thBW+ERO1u/2dyz2vjuGuza4CrtLFNMYaGKm1+eabJ7cUI7Wc0xWAXn311WkkDbH4Fa94RVMDRUIeCsTPP//8JBCbvW48zVVXXZU6S+UjRs2mD+YPLMoVS8krPfCBD0yPtjONvfODH/zgVH/HIAiCIEThIAgWEEQNBy6CMB760Ic21113XQpUzeM8/PDDFyUMh4Jkp3ln7ZlnOjce/OAHL/Gz97///Ys9r+TyqLlFkCQraUkVBEE93KuSQ29605tSt5eEWfv+HZKQFAwfyUf7/XLLLZeuYzPPdJBKkA4VXdCj5p52v8fGcQjdw4r/vvrVr6ZOJOtVhlgnGQ1FAMQlxWvPfOYzizyvtbBryUl89/12NxrhcKgWuFx3iKQ+A6+1jS5qQunQYEOu69xn7bONkQp1cE1Ztz0Ut3q0qTlCIxgmH/rQh5r3v//96fxrPyCWsii3Zu+55569/A4KHdZZZ50kRItN7CHOzrqWzc/O4inkMCZ1o5gJDl5PeMIT0pxfnciZ+93vfqlD+DWveU31ghbrJFHaQ3fyGWeckQRp3cLee9bZwfxGfk1hxShKzqsOgiAIlp3IygdBsGBQCeugZa6tYJQwqpNEZbmK1Pa8uaHg0OcBr529ofdBsq72gc+hUgLQ4ZMFl0O2qmfzSdlx5S6lEJWCYO6ie0Elv/XxS1/60hL/TmgxnywI5gMEq5e+9KUp0WrfN9+ONeNQRWFJXh2xk8BqeQjoNjIuoy0Id9GlwhKUlWUpUXiUQMq6up10F3/qWGZnXXqm8bTx2tiNKrwUd3aL/3QNDWUNkezmMuDrLNiMgsDi54LZkwWkICjFD3/4w9Rxbg/gGLLaaqstVsTT136VraOdj7u0v6erVyFbCV70ohelh2KKX/ziF6nYQrwwDXcDovwOO+yQHvbkcCaa/yh8e/vb356+1oWuqEcBsc73KJwKgiCYO4QoHATBgsFBT4XtXnvtlSqD2ROxGLznPe/ZXHDBBc0qq6zSDBGB+Nve9rbUEbPJJps073jHO1I1rsNwra4N3RIqkM0uduh0AHDQlDQE+2p2e3BIuOaaa6r8HkEQzL6LIR/sRxGH+2A+8YMf/KDZe++9F1kTGmXAJUTSaohzKgm9QxW8Z7KZVazSRjLdCI1uIvr222+v9nvsv//+SZzuitEbb7xxc9hhhzXve9/7miHBecfrY8U6ZPcII1k47uSvFT2OI/9cUIZvf/vb6bxm3qvObBCQiFosb3fcccd4q4OJEduaH0yU3W233ZK9rfmnuobtI31gb2JVPQk1BFuisKJPI7RuvPHGRY4HfifuacTiPsluHsH8x3Uk12NOtzUbYgTX1S677DLtXy8IgiAIUTgIgoWG4JQdE57znOckwZJ9lK7h3XffvRkaZgfuvPPOqfqZNVW2c3boeve7350Ov2ZzlUaHyKTdSTFzLQjmLpL7z372s9Ph/qKLLkqiGiFYIvypT31q3L/BvMIeKCnV3qsIN1w0higKL0QIwmY0tunaOsNatuqqq1b5Hbix6AATX3aLExUiDFGoJ87pBh6yIAyd3hlnh0c+8pFpLmiXr3zlK0vMvQ2WnVtuuSV1XivmcG7gNsT5SEe+7jP/FgR3BiIwAdhDETNXB0XT2TqakOUerylU2hOmNVLJHOV99913UYFFd88c2kitoF8UXF544YWp+OLRj350ykl961vfSrOErePmRwdBEATTpX9/kCAIgikigaA6kcBx6623ppk1ulYdAkfN2Z3vsGFy4CQAt7sZHPZe/OIXN1/72teqPK+EDSFJN7ZObN04/r7mmmumJKyv88PPBEEwt90GNtpoo2bXXXdtPv7xjyehg7DhMWpueBDMVUYlP+2Ro74fzE/YgIrrjKsYh84o85PFJDUZdV1ZM4doj2kW509+8pOU9F0o6IAi/o763D/5yU+m6zAoA7cjBa7nnXdeErKcY04//fT0GXB6GFX4EQR3Jj+wzTbbJGFY5zAr/KuvvjrNRH3BC16Qxk3V4rbbbksOC+CoxUbZnOGjjjqqamxijXrZy17WXH755anT3jgNr99aTrDru0s4GA6uW0UHH/jAB5pNN900rd2EYePDDjzwwObUU0+d9q8YBEEQhCgcBMFCgx0UK2UdbuZ8SQjqGD7jjDOaISJBxxZ7VDeuuW+/+93vqj03IdhhWvV+tp+VCCUu1TxcB0FQFmvmQx/60FRE8tWvfrW57LLLms9//vPNb3/72yU64YIgCKbJve51rxR7vPrVr05dKt2kOpvj7bbbLsV/K6+8cpXfQcwlzpT8JFhlfvOb3zSHHHJI87SnPa0ZGt///vfTTMott9yyWW+99dKfhJX80DU0BHyGbMF1CHMeMpLF192HvZLQEpQ7v3E2Yv2vuDSfI7zHznHe7yAogWvKLF8xL2GWA4KRSzWwP9mrWKPjwx/+cBqpZNwT0fYLX/hCUwu2687o9kyCHfto4t173/veVAAaBMuK5gsFcPbCLo997GOTXXkQBEEwfWKmcBAECwrV5Q5b/pRUUJH7zW9+M81++6d/+qfFbOGGgO5nB808yzfDdo2owz67plX3Ax7wgDS/+bnPfW76HltBldhm6R199NHVnjsIgjI41FsjL7nkksW6BqyfxOIDDjig2mzyIKiBUQp5pnAuYOp+DwQfxVPB/GOPPfZofv/73zc77bRT6gDTRUioVSgnuW90hrWrJkQFXTFrrLFGsrdlKc3WWlx2zDHHNENDx/0jHvGI9BgFYWUIsIT+6Ec/mhw0PvOZzyQbTNdT15ZWIVWtooOFiPf5hhtuSF87WxAdfAasu+9973sn96cgqGUvXQt7gjO6AiJwsCDU2rtc82ZoK6autZblonH70ve+9730tXtK8YtCjPa4jSCYFGOGxM8XX3zxEo4sivXEREEQBMH0CVE4CIIFg8ONw9b555+fEgqZ1VdfvXngAx/YnHTSSYMThc1BkpjSNSMhJ0lKpGW5RuypKQo7CJx99tlLzGlkW636OQiCuY8uBmLZqMQQkdgs1iCYL5jlOqlDhkKxYP4m83VwEvt1WuliNc/u6U9/eioKJOIRMWsi9hIDSep7fkVximl0NXYLEIaAESUKhRZKJ6GHYoO73/3uYxPchMuhz1jui8c85jHNW9/61uaFL3xhuo+f8pSnNIceemj6O7cn4y2CYL5hlIEchD1BYcPNN9+8aKwSUa1b1F0STmJsfPfaa6+0nh177LHNz372s0VCdaxdwWzgyPL617++eelLX5quLzO6jVRgz/6e97wn3twgCII5QIjCQRAsGIigkrwqb0cls3796183Q4S9q64UncEOnLpk2BruueeeyTKqBjpiWCZKlo1iiPP0gmCIuIdXWmml5vjjj08H/IzDvW5/NmBBMF/YZZddpv0rBFMQ76YJ8cqc41xkY9Yx61v2oPMd4sEtt9yS7JRnwus1a1jn9JAg8tsbzbu1J2arcl/rSn/lK1+ZbLSD2aN7cb/99ksWt0RhQta2227bfPGLX2ye8IQnNBtssEG8zcG8Q8H2TTfdlBxLOA+w4M9uC1deeWVVh4Xtt98+PdxHCuTdY2uvvXY6wyugu8tdIlUcLDuveMUrUr7nhBNOSAUHigwUInCLMzM7CIIgmD5/97fuoKUgCIIBY66Zg8/OO++8yDJJJf9b3vKW5iEPeUjzute9btq/4mDQoSNR6MBpDhjbbkIxMTrPTQqCYO7DOnqHHXZIXVGSVTruJKt0CZ9yyimpIy4IgiD4f1gbdStbL7tI/JtXOd/hvKPr54Mf/OCi7+mM5kZjFudMPzcE2GA6TxBSbrvtttTtp2uYU45ihHe9612Dsc2eixAcdFr+27/9W/XO/yCohWIHDlrSsvaMzTbbrPnOd76TimjsI+Ms+UtgnJR8CHcNjmrWNF+vu+66i/IkQTBb5NoUGcQ1FQRBMLeI8q8gCBYMv/rVr5KVsUSVhJVDloSCDgZ2SU984hObyy67LP3sfe5zn+bwww9v5mvgrSt6ElRt1rLIfPOb39y8+tWvbs4555zUNaHL8Oqrr06JG1bdQRDMDxR3fOpTn0o2cz/4wQ+ae97zns0LXvCClLD613/912n/ekEQBHMOAqhuYI9tttkmxZ5izXe/+93NEUcc0QwVwsZCcYNRHGUMC/HXueLLX/5yc+SRR6bOP13Ctdx4FvI5ju3opZdemmKQ3Xffvfn617+eRlnUnPsaBDXZf//9m0033TSJsVkAloeoLQjn2a8ZY2JqzS8Oho+iAoX/Yh9fK5haWg5K0ZROdV3qQRAEQf+EKBwEwYJBdaJZwuxs2qgw77L88ss38xWztfbZZ5+JflY1sqrkWvO/2Lp94hOfSAkydlRbb711ev9DSAqC+QNB45BDDmne/va3T/tXCYIgmBfFeb/4xS9ScRwL/kc+8pEpBpL49/fjjjtukaV0MH9R8Ljaaqulrzlp5E5oFpkccojG5lcHZd5rhaaEdrbd7icYCWQsgFEWo85zQTDXUSzdHcWisMbYJ+Of3vve91Z7boUs11577chi8p122ikVgQbBpHk2rnv566W5SLnGr7/++jQKQNFxEARB0D8hCgdBsGAg9L7tbW9bFIhK2EkgSCwMyc6GPbZOlDaXX355miVMBG7z4Ac/uOrvQvx97WtfW/U5giCoB4toNnbsToMgCIKlo+NL1xUBOMdaN9xwQ7Pmmms2T3va01K3YzD/UWhqrjIkw3/0ox81v/3tb5NwySqTtXFQBh3ButA/9rGPpcfvfve79H2iu/uKbXm36DcI5hNGDbDaZyVtTrncBMeBWnCs+OhHP5oKWka5hnH4CoJJcQ3tvffei77OObdxhXM6hX/605+m+dVBEATBdAhROAiCBcUf//jHlIxjhXrf+943zc75yU9+kjprP/ShDy1K4M1nVlpppfToBt944QtfWO15ieusoifBQXf99dev9rsEQVAGXQJPfepTU6cCm0xWX5Ld7Q4HcxSDIAiC/7cuPvCBD2y++tWvJsHq4Q9/eBKtJNmJw8EwIPBvscUWaabw05/+9OZxj3tcsjTWBX7eeecld5ygDDfffHN6X0fFGyuvvHLzy1/+Mt7qYF6iaFtewtx117FRV9tvv33z0pe+tOpM8nPPPTcVkW+44YbVniNY2Gu23Brb/+zsoLCHtbRiqq997WvJ6SG6hIMgCKZHiMJBECwoDj300NT19qY3vSlVmue5PcRi1bK77rrrtH/FeV3hLBk2CapDQxQOgrmPw/x1113XXHTRRc3RRx+9xL9bP3XwBEEQBIvb7u+xxx7NN7/5zTSn8f3vf3+zzjrrpDV1SJ0xkr0cJTJ//vOfR35viBD7DzvssEWFlwcddFCKg50nttpqqyQSB2VQyDuq8JSt9MUXX5zE+SCYT2dmhUK6gs3Idi5+5jOf2TzoQQ9qbrzxxrR31MZz/sd//Ef15wkWJmyhFTkoLDbaTGOCcWLXXHNN2itzAV3NwocgCIJgZkIUDoJgwSBJ9bnPfS7NuZXAyaIwi5udd945JexCFF527na3u6WDbffQ+9znPrf5yle+stj3HQKCIJj76FjYb7/9ZkwqBUEQBItjfvATn/jERcUzumFOP/30JG69/OUvH8zbZSZlfp1tut97znOe0wyRZz/72Yu+Nkv4zDPPnOrvM1S8z5yeiGXOEB7e60984hOp6+x5z3vetH/FIJiI733ve2k+to5JQrDCkrXWWis581xyySVJFO6DLbfcMj03gc64pyAohfzPd7/73dSNbnzGlVde2bzqVa9KRQjc+fLYhSAIgmC6hCgcBMGCQbUi4dJszFtvvXWxf/O9PJ8qWHbufe97L/b33B3S/X4QBPMDoq/CjtyR0+34GtI89iAIgtnCHvEHP/hBmivL1rYtGO65556DeoMf+chHNu985zsnnr87RIjiCk5/85vfpM++Dfvoddddd2q/25Aw3ueEE05o3vGOdyRb9r/+9a/NWWedlSylTzzxxGb55Zef9q8YBBNh7rj1wjzspzzlKc1jH/vYJAj3jXvHaBg2+Mstt9wS8fzZZ5/drLDCCr3/XsEwGjHk3AjCMLf6+uuvT6Kwggix0G677TbtXzMIgmDBE6JwEAQLBlWwkgjXXnttSta1Oe200xZL3s1ndEH/6U9/Wux7/q5qsyt8E3x0SgdBEIzjW9/6VqrsJnR0CfvoIAiC/zcbkvPMf/7nfy7qbjS25F/+5V8G+RaZm7zJJps0C5Urrrii2XHHHVO330Mf+tAlRJUQKsvy7//+782HP/zhdM752c9+luIPYnEQzCdWX331ND/Yw/Ws0OFRj3pU8/znPz+Js31xwAEHJLtqe9Y97nGPJf59GkJ1MAwIwq6fX//61yn/RhzWOfziF7+4uctd7tL8/Oc/n/avGARBEHDw/Fu3pDUIgmDAmInJNto8W5Y2O+ywQ6ry//a3v90cf/zxae7JfOfTn/50EnAmYbPNNkuH0VroKnzyk5+c5scEQTA/MQdTR9gLXvCCJRKwCkt0GQRBECx0tt9++5QE1Qnzxz/+sfnABz6QbJPf8pa3TPtXCypg7IxCgHe/+93x/gZBcKfhwGPEEreBiy66KBVwGzGgk3K99darWritaElOREFLEJSG1f8vfvGL5OTwjW98o3nNa17T7LTTTulrBVTHHntsvOlBEARTJjqFgyBYUBCBV1xxxRSIEixV6K622mrNySefPHIm2nytQJ40QZVtfYIgCEbx+9//vrn99tubww8/vLnrXe8ab1IQBMEYLr/88ub8889PSX3c//73r1p4F0xf0BmKy9BcRNHuF77whYmL1zbYYIPqv1MQlETXpMIhDwVFLNEJxG984xvT3iFvodioBkYamO0aonBQg7e97W2LhF/Fw2YKH3PMMSkuMss6CIIgmD7RKRwEQRAUmx9zzjnnLPY9Fc+6lg855JDFvq9CVLd2EARznzXWWKP50pe+FFZyQRAEYzCmQ1HeVVddteh7v/rVr5Il6De/+c143waIcTS6oXRC3e9+95v2rzNIdyfd2GauEs9mYsMNN2w233zz3n63IKjJDTfckOylFWWa+1sDHcr77rtv87KXvax5yEMeskTh55prrpncgIIgCIIgGCYhCgdBMHih8o477pjoZwmV//zP/1z9dxoqOq8lbibBITMspYNgbt/P7cSsGZm77757qvBuz038u7/7u0gaBUGw4Pnv//7vNFv2yiuvnPF7wXDQ1XfEEUck4Yao0p0HuvXWWzfrrrvu1H6/+c5//dd/pdE+l156aTpfPPe5z01CVZzVgqBMwae1axwXX3zxIteLIAiCIAiGR9hHB0EwaH7yk58kS6ZJYCt94YUXVv+dhsrd7na3lLiZBEJSEARzEzOgCBldvvjFLy7xvfvc5z7N17/+9Z5+syAIgiCYG+heXWuttcb++/LLL9/r7zM0HvawhzUHHnhgsukWZ5x99tnp74985COTQMwyWqFaEAR3nq9+9avN3/72t7H/vrTu/CBoowhuq622muhNuec979mcdNJJ8QYGQRBMmdjpgyAYNPe+972XmK9rZo9Zwm9+85uXCFCD2b/fQRDMb+51r3ulNXLSYpAgCILg/0ZmnHzyyYv9vfs9sOncYost4i2b5yiKevazn90861nPmvavsiDEd4+//OUvyfbWrGHnO3NRCcTsox/0oAdN+1cNgnnDP/zDP0z7VwgGxF//+tc0UuHhD39488QnPnHG6+uf/umfev3dgiAIgtGEfXQQBAuOW2+9NVm6RVdwEARBEARBUKJLRiJ0Eu5xj3uEpfQAeM973pME/te//vXT/lUWJGZ177///s1NN93UbL/99s2ee+457V8pCOYVX/7yl5OQ96c//WmJf9tpp52iYD6YGF3ncmscHYzMWH311ZNbH5vyu9/97vFOBkEQzEGiUzgIgiAIgiBYgttuu6352Mc+llwV2hXfBxxwQHIFkISNau8gCIL/c5u54YYb4q1YQOiIMlf4D3/4QxL6g/oQsM4555zm3HPPTSOCnvCEJzRvetObmvXXXz/e/iC4E5iH/tGPfjTZtI+K5bfbbrt4P4OJMRqMCOyhyEDBwRlnnNG89a1vTQVzHB04a4SrXBAEwdwhROEgCIIgCIJgMW655ZbmFa94RbIDkxj6t3/7t8Uso4877rg04+/4448PYTgIgiBYcCiWuvrqq1Mn1EorrdT867/+62L/vuWWW6ZEeDA7rr/++iQEe/z85z9vnvGMZ6QuxhAYgmDZUVjBgp31ehCURJGBQh2PO+64ozn//PPT+q2o+DGPeUyz3nrrTTx/OAiCIKhHiMJBEARBEATBYrz3ve9tHv3oR6dOgm4Hga4cye5tttmm+cQnPtFsu+228e4FQRAEC64z6vnPf/7Yf/+Xf/mXXn+foWF28MEHH9z89re/bdZee+3mjW98Y1iRBkEh/vEf/7H5j//4j3g/g6r88z//c/PCF76wechDHpK6hD/3uc81N954Y4jCQRAEc4CYKRwEwaD53//931Sh2Ibd2I477ticeeaZi33/7//+71PgGgRBsNDnQrFkPO+885r73ve+M3YZnHjiiUkYDoIgCIKFyu9///u0dy633HLp7OFMEcyOo48+unn/+9/fPOIRj1jq+7nxxhs3L3vZy+ItD4IJ+dSnPpUKLw466KAlXA6CoARXXXXVIrv/22+/vXnqU5+6yGK67UAVBEEQTIfoFA6CYNAQgAWeo3jKU56y2N9XXHHF5sILL+zpNwuCIJi7ye273OUuMwrCeNSjHtX89Kc/7e33CoIgCIK5xHe+851m3333TZ1P/uSiwWlj1VVXbV70ohdN+9eb16y22mrNC17wgol+doUVVqj++wTBkHjSk56U1qqnPe1pqZilW3hx9tlnx30V3GmMVCAEf/GLX0wuD8961rOaPfbYI7k9hHtGEATB3CJE4SAIBg2bGvNyJuGe97xn9d8nCIJgruPQ/j//8z/pMH+ve91rxqIba2wQBEEQLDTMt91hhx2aLbbYIhWWZlZfffVm1113bdZcc83YI2fBWmutlR5BEJTHfNcHPehBzc4779zc4x73WOLfIy8S3Bn+8Ic/NBtttFHzl7/8pVlnnXWa/fffPxUcsCkPgiAI5iYhCgdBMGgccswxCYIgCCafkyiZzbpxr732Gvkz7DH9e9dxIQiCIAgWAiwxiZa6oN7+9rcv+r7983GPe1xz2WWXNeuvv/5Uf8cgCIJR/OhHP2o+9rGPNQ996EPjDQpmjWLiH//4x83yyy+fuoQ9Zio+Pv/88+NdD4IgmDIhCgdBEARBEASLoctps802a379618nO0w2jv/wD//Q/OlPf2quvPLK5qMf/Wiyyzz44IPjnQuCIAgWHLfddluyiR6F8QtGMQRBEMxFVllllSTihSgclOCf/umfmr333nuin73b3e4Wb3oQBMEcIEThIAiCIAiCYIlk0THHHJMO+KeddlqaNeYQ/8c//jH9+xOf+MTmhBNOaO5///vHOxcEQRAsOFZaaaXULcxCus3Pfvaz5utf/3rzkpe8ZGq/WxAEwUwo+HzrW9/avOxlL2se8pCHNHe9610X+3eOB2H9G0yKa+XVr351vGFBEATziL/729/+9rdp/xJBEARBEATB3OOvf/1rssC84YYbUtfTCius0Dz5yU9OncNBEARBsFC544470oga4rB5iuZz3u9+92s++9nPNiuvvHJzyimnpHEMQRAEc4011lijuf3228f++8UXX5wcD4IgCIIgGCYhCgdBEARBEARBEARBENwJfvWrXzVHHHFEElB+/vOfN//2b//WrLvuus1rX/va5p//+Z/jvQyCYM4Wfc7UH3SXu4SpZBAEQRAMmRCFgyAIgiAIgiAIgiAIJuR73/tec8973rP593//9yX+7Stf+Uqz4oorplEMQRAEc5Hvf//7zU9+8pPmf//3f9PficR/+ctfmmuvvbbZdtttm+WWW27av2IQBEEQBJWI8q8gCIIgCIIgCIIgCIIJ+dSnPtU89KEPTbM52xBWPvnJTzZrr712iMJBEMxJPv3pTzf77rvvyG7hhz3sYUkUDoIgCIJguESncBAEQRAEQRAEQRAEwQz85je/aTbYYIP0p+46M4O7c4OJLP/wD/+QhOFHPepR8X4GQTDn2GyzzZrHPOYxzW677dZss802ze67755mCBOKrXGvetWrpv0rBkEQBEFQkRCFgyAIgiAIgiAIgiAIlgJr1R/96EfNZz7zmeb+979/86xnPWuxf7/rXe+aOohXXnnleC+DIJiTrLXWWs3xxx+f1qm3ve1tzUMe8pDUHWxt8+d555037V8xCIIgCIKKhH10EARBEARBEARBEATBUtD968Fi9e53v3vzoAc9KN6zIAjmFcsvv3zz93//9+nrBz/4wWlGOsxI54Twhz/8obnHPe4x5d8yCIIgCIJahCgcBEEQBEEQBEEQBEEwIauuumrz5S9/uXn3u9+dRJTubM6tt966WXfddeP9DIJgzrHKKqs0p556arPXXnulIpdjjz22+dnPftb8+Mc/bv74xz82//iP/zjtXzEIgiAIgoqEKBwEQRAEQRAEQRAEQTAhV1xxRbPjjjs2z3zmM5NddO66a3fiBUEQzEW233779GAVvfrqq6cO4bXXXjvNSt98882bu9wlUsVBEARBMGRipnAQBEEQBEEQBEEQBMGEvP/9729++MMfpk7hIAiC+caf//znVMxiDjq76AsvvDB9zeGgW+QSBEEQBMGwiPKvIAiCIAiCIAiCIAiCCfmf//mfZuWVV473KwiCecnd7na3RV+bH7zRRhtN9fcJgiAIgqA/olM4CIIgCIIgCIIgCIJgQq699tpmjz32aE488cTmfve7X7xvQRDMef6//+//a84888xm4403Tl3Br3/965vf/va3i/79Oc95TrPVVltN9XcMgiAIgqA+0SkcBEEQBEEQBEEQBEEwId///veTwMJq9SEPeUiz3HLLLfbvW2+9dfq3IAiCucCf/vSn5lWvelVz/fXXN49//OObhz3sYc23vvWt5nGPe1zqGv7d737XvOtd72qe+tSnNqutttq0f90gCIIgCCoSonAQBEEQBEEQBEEQBMGkiZS73KVZa621xv778ssvH+9lEARzhpNPPjkJv+edd95i7gYHHHBAc9/73jd9/brXva455phjmkMPPXSKv2kQBEEQBLUJUTgIgiAIgiAIgiAIgmBC1l9//fQIgiCYD1x44YXJLnomu3ui8JZbbtnr7xUEQRAEQf+EKBwEQRAEQRAEQRAEQTADN998c/Ozn/1soveIpfT973//eD+DIJgT3Hbbbc2jH/3oxb636qqrJteDzH/8x380f/3rX5vf//73zb/8y79M4bcMgiAIgqAPQhQOgiAIgiAIgiAIgiCYgRNPPLH5+Mc/PtF7tO+++0bHXRAEc4a73/3uaa5wm+OPP36xvxOE/+d//if9bBAEQRAEwyVE4SAIgiAIgiAIgiAIghnYeeedm1e84hUTvUd5RmcQBMFcYJVVVmm+/vWvNw972MPG/szXvva1ZuWVV16sezgIgiAIguERO30QBEEQBEEQBEEQBMEM3Oc+90mPIAiC+cYmm2zSvPGNb2ye9KQnNY961KOW+HfW+O94xzuarbfeeiq/XxAEQRAE/RGicBAEQRAEQRAEQRAEQRAEwQBZe+21m/XWW6/ZfPPNmw033LB5+tOf3qywwgrNHXfc0Vx99dXN5z73uSQWT+qGEARBEATB/OXv/va3v/1t2r9EEARBEARBEARBEARBEARBUIfTTz+9Oe6445rvfe97i753v/vdr9liiy2a17zmNc1d73rXeOuDIAiCYOCEKBwEQRAEQRAEQRAEQRAEQbAA+PWvf9384he/aJZbbrkkCv/93//9tH+lIAiCIAh6IkThIAiCIAiCIAiCIAiCIAiCIAiCIAiCAROlYEEQBEEQBEEQBEEQBEEQBEEQBEEQBAMmROEgCIIgCIIgCIIgCIIgCIIgCIIgCIIBE6JwEARBEARBEARBEARBEARBEARBEATBgAlROAiCIAiCIAiCIAiCIAiCIAiCIAiCYMCEKBwEQRAEQRAEQRAEQRAEQRAEQRAEQTBgQhQOgiAIgiAIgiAIgiAIgiAIgiAIgiAYMCEKB0EQBEEQBEEQBEEQBEEQBEEQBEEQDJgQhYMgCIIgCIIgCIIgCIIgCIIgCIIgCAZMiMJBEARBEARBEARBEARBEARBEARBEATNcPn/AXH6ajNYy7LqAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running Post-Processing EDA...\n", + "INFO: Categorical: ['HepatitisBSurfaceAntigen', 'Splenomegaly', 'Gender', 'ArterialHypertension', 'LiverMetastasis', 'PortalHypertension', 'PortalVeinThrombosis', 'HepatitisCVirusAntibody', 'Cirrhosis', 'EndemicCountries', 'HepatitisBCoreAntibody', 'EsophagealVarices', 'Smoking', 'Hemochromatosis', 'HIV', 'Obesity', 'Alcohol', 'ChronicRenalInsufficiency', 'RadiologicalHallmark', 'NASH', 'Diabetes', 'Symptoms', 'Miss_Iron', 'Miss_OxygenSaturation', 'Miss_Ferritin', 'AscitesDegree_1.0', 'AscitesDegree_2.0', 'AscitesDegree_3.0', 'EncephalopathyDegree_1.0', 'EncephalopathyDegree_2.0', 'EncephalopathyDegree_3.0', 'PerformanceStatus_0', 'PerformanceStatus_1', 'PerformanceStatus_2', 'PerformanceStatus_3', 'PerformanceStatus_4']\n", + "INFO: Quantitative: ['Hemoglobin', 'GramsAlcoholPerDay', 'InternationalNormalisedRatio', 'MajorDimensionOfNodule', 'GammaGlutamylTransferase', 'Platelets', 'AspartateTransaminase', 'Albumin', 'AgeAtDiagnosis', 'AlanineTransaminase', 'Leukocytes', 'DirectBilirubin', 'MeanCorpuscularVolume', 'Iron', 'PacksCigarettesPerYear', 'AlkalinePhosphatase', 'TotalBilirubin', 'TotalProteins', 'NumberOfNodules', 'AlphaFetoprotein', 'Creatinine']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjYAAAHLCAYAAADbUtJvAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAPeRJREFUeJzt3Qd0VNXaxvE3hUBCSEho0qRK7yAoKoggooAUQXqRpiIqTSkCKrYLF5CqoqAgF1AQBRWkCVcRLEhVQUSaNClJICQEQsq33u03uWnAZDLJzJz5/9bKCnPm5Myegck87P3uvX2Sk5OTBQAAwAJ8Xd0AAAAAZyHYAAAAyyDYAAAAyyDYAAAAyyDYAAAAyyDYAAAAyyDYAAAAyyDYAAAAy/AXL6PrESYlsSaht/D19eHvG7Ao3t/e9Xft4+Nj17leF2w01ERGxrq6GcgF/v6+EhaWX6KjL0tCQhKvOWAhvL+9S3h4fvHzsy/YMBQFAAAsg2ADAAAsg2ADAAAsg2ADAAAsg2ADAAAsw+tmRdkrKSlJEhMTxBv4+fmLry8ZFwDg+Qg2maxzEx0dKXFxMeJNAgODJSQk3O51AgAAcEcEm3RsoSY4OEwCAvJa/oNeg1x8/FWJiYkyt0NDC7m6SQAAOIxgk0pSUmJKqAkODhFvoQFOabgpUCCMYSkAgMeisCKVxMTENB/03sT2nL2lrggAYE0Em0xYffgpM974nAEA1kOwcXK9ysWLF1J6ftKLiDgv0dHRznxIAACQCjU2TvDTTz/IRx8tlt27d0i+fIESF3dZKla8TXr06CP33ts85bzHH39MGjRoKKNHj3fGwwIAgHToscmmDz54T55/fqjUq1dfvvhivaxZ87WsWbNJ7rjjLhk3bpQsWrQguw8BAADsRLDJhh9//F7mz58rQ4eOlJ49+0r+/MHmeGBgoPTv/7i0adNO5s17W06ePGHXENalS5eue86VK1fkwoUL5tzsnAMAgJUxFJUNH3+8WAoXLiJt23bI9P6+fQdK48b3SGhowUzvv3btmrzzzmxZu/ZLczsmJkaKFi0mTz31bMoQ1p49u2XatEly8uRxyZs3ryQmJsmDD7Yx5/j7+9t9DgBYkZ+f9/3/PCkp2Xwhc3zqZWPLhZ07f5amTZuJn59fpufccsst5ut6Zs9+U775ZrPMnbtASpUqLVevXpXp0/8tr732sjRo0Eh0otKoUUPloYfayvvv/8c8zq+/7pUJE8ZI9eo1pEWLByQ2Nuam5wCAFWdyJiclSUhIoHibpMREiboQR7i5DoKNgy5ciJKEhATTY+MInTm1ffuP0q1bTxNqlPa2NG/eUr74YqX8/vs+KVSosOnFKVmydEp4qlGjlnz66eqU65w9e/am5wCA1fj6+oiPr6+cXTld4iNuPNxvJQGFSknR9kPN86fXJnMEGwdpCFHx8dcc+nkNIUuWrDABZuHC+fLXX0fl6NGjcuTI4f+/bryUKVNWqlatLjNmTJGffvpe7rmnqTRseKcZrrKx5xwAsCoNNfF/H3F1M+BGvG9w0km0ULhgwYLy99+nrnuOFvHeqHB45sypMnBgH9mxY7vccksJeeyxgTJ58pspP6s7bs+ePVeGDXve1ONMnz5FOnZsLUOGDJITJ46b8+w5BwAAb0GwyQYtDN69e5dcvnw50/v37NklXbq0l2XLlma4b9++X83xPn36y8yZ78jAgU/K3Xc3kWvX4tOclzdvPunQoZNMmzZbVq/+Wl555V/y559/yNSp/8rSOQAAeAOCTTb07NlHEhKuybvvvpXhPq2/mTfvHQkMDJL772+V4f7IyAjzXQt8008h/9+GnHFy9uyZlOnbOvzVrFkLqV69VsrP23MOAADeghqbbLj11rIyZsyL8sYbL8v582elQ4fOprblxIm/zMJ8v/++3wwthYWFZfjZGjVqS4ECIfLhh+9LeHhhCQgIkM2bN8qqVZ+a+7UX6PTpU9K/f09p376TtG79sOTLl8/MxNqx4yd5+ulh5jx7zgEAwFv4JLvBam7fffedqQ9JrWLFilK69D+zhdShQ4fMDKDKlStLeHi4w4+la7xERsZmep8OA0VEnJZChYpLnjwBdl/z6NEjsnLlJybIREVFmvZpQW+XLj2kWLFb0mypULt2HRk8+Flz+8CB3+X99+fKsWPHJCQkRCpXriqdO3eR8eNHS6NGd5rzfvlljyxf/pEcPXrYLMBXvHhJE2BatvxfL5A959yMo8/dnfn7+0pYWH6JioqVhIQkVzcHgBPlzetvpnqfmD/Sq4qHA24pJ6X6T/G632vh4fntXrPI5cEmNjZW6tevL40aNTK9DTaPPvqoNG/e3MwOGj58uOzcudMEnQMHDsjo0aOla9eubhNsrMCKz51gA1gXwYZg47ZDUQcPHjQLLc2dOzdNsLGZP3++Oeerr76S0NBQ2bx5szz11FPSsGFDKV++vEvaDAAA3JPLi4c1tJQsWTLTUKM+++wz6dSpkwk1qlmzZlKlShX5/PPPc7mlAADA3bk82Pzxxx+mnubMmTPyww8/yPHj/1t7RTeF1PoTratJTW//+uuvLmgtAABwZ24xFLV//37p16+fmT2kgaVp06YyefJks1O10oXwUtNCWw1E2am9yExSko94Oz8/n+u+Pp7GVmjmjZvkAVanWwp4M36vuXGwKV68uCkcfvLJJ81t7bHRoadZs2ZJhw7/7JqdfpNJva2bUDr6ZtCZMpm5csVPzp/3tdSHu7001OkqxqGhQdcdFvRU3rhJHgBr4/eaGwebN954I81tnfnUvn172bRpk/Tq1StlEbrUdI2X4OBghx5PNw2Ljs58peD4+KsmMCUmJnvVNDqlz1mf+8WLlyUuLlGs8j8affNHR8eZ2XAArCNPHj8JDrbWf8Kywtt+r4WEBNrdS+XSYKOBRetq6tatm2a4SXsMdF2bokWLSlBQkJw8eVIaNGiQcr/eLlu2rMOPe73Qoh/u3s6KoU7f/FZ7ToC38/ahGH6vXZ9L/2XkyZNHRo4cKR9//HHKscTERPnvf/9rpnPrNPB77rnHTPG20bqbHTt2mOMAAABu02Pj7+9vFt+bNGmS2VtJh6FWrlwpUVFR8swzz5hzdM2aLl26yIQJE0zPzqJFi6R69erSokULVzYdAAC4IZfX2PTo0UNuu+02WbNmjVlVWMPLlClTUrZN0Kndy5YtkyVLlpienAcffFB69uxpCl1zkxYdu6oKX+uC9AsAALh5sFE67KRf11OpUiV56aWXxFU00BQsGOSyMV0dS71w4XKWwo3ulPHpp8vk6683mO0SmjRpJt269TK9ZAAAWBWfcnYGGw01UxbvkBNnLkluKlWsgIzsUd+0ISvBZuHC+Wan8JEjx5jerWnTJplFEEeOHJ2j7QUAwJUINlmgoebQyYvi7nQ6/OLFH8rYsRPkrrv+KbIeN26iPPPM49K3b38pXLiIq5sIAECO8O75cha1f/9vEhd3WerX/9/wXs2atcwstJ07f3Zp2wAAyEkEGws6ffqkBAYGma0nbHQ4SntqTp066dK2AQCQkwg2FqRDUZlti5A3b94MqzgDAGAlBBsL8vfPY9YFSk+PabgBAMCqCDYWpENOsbExGcLNhQtREhb2z/pAAABYEcHGgqpUqWrWsTl48EDKsb//Pi0XL16UatVquLRtAADkJIKNBRUtWkzuuKOxvPPObFNToxuKzpo1TapXrymVK1dxdfMAAMgxrGOTxcXyPOUxR48eL+PHj5a2be8XX18/KVOmjLz66mSntw8AAHdCsLGDrvir2xroCsCuoI+d1b2iChUqLG+9NU8iIs6bXdLDwwvlWPsAAHAXBBs7aKjQvZo8cRNMDTgAAHgLgo2d2GEbAAD3R/EwAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDNaxsZMuzueJC/QBAOBNCDZ20EATVjBQfP38xBWSEhMl6kKcw+HmrbdmSqFChaRLlx5ObxsAAO6EYGNvb42fn5xdOV3iI05IbgooVEqKth9q2uBIsFm2bIksWfKh9O7dL0faBwCAOyHYZIGGmvi/j4gnOH/+nMyaNU22bftOChQIcXVzAADIFRQPW9SmTRvl0qUYmTdvkRQrdourmwMAQK6gx8ai2rXrKI8+2s3VzQAAIFfRY2NRefPmdXUTAADIdQQbAABgGQQbAABgGQQbAABgGQQbAABgGcyKyuJied7wmAAAeCqCjb17NSUmmhWAXUEfOzt7RU2aNE0CAwOd2iYAANwRwcYOGip0ryZP3QSTBfoAAN6CYGMndtgGAMD9UTwMAAAsg2ADAAAsg2ADAAAsg2CTieRkxwt1PZU3PmcAgPUQbFLx8/Mz3+Pjr4q3sT1nPz/qyQEAnotPsVR8ff0kMDBYYmKizO2AgLzi4+OaKd652VOjoUafsz53X1+yLgDAcxFs0gkJCTffbeHGW2iosT13AAA8FcEmHe2hCQ0tJAUKhEliYoJ4Ax1+oqcGAGAFBJvr0A96X9+A3P3bAAAA2UJBBQAAsAyCDQAAsAyCDQAAsAyCDQAAsAyCDQAAsAyCDQAAsAyCDQAAsAyCDQAAsAyCDQAAsAyCDQAA8O5gs2DBArlw4UKm98XGxsqYMWMkJiYmu20DAADI+WCzePFiuXjxYqb3Xb16VdavXy/R0dFZvm5SUpJMnTpVdu3aleZ4ZGSkzJ8/X15//XX5/PPPzXkAAAAOb4I5cuRI+eKLL1Jut2zZ8rrnFitWTIoWLSpZNW/ePHn33XelXLlyUrduXXPs9OnT0rlzZ6lTp45Ur15dZsyYYYLT7Nmzs3x9AABgbXYHm9GjR0v58uXNnxcuXCjt27eX0NDQDDtiBwcHS9OmTcXfP2sbh+/bt8+EmvQ/N3PmTKlcuXJKkGnXrp20atVKtm7dKnfddVeWHgMAAFib3emjcOHCMnjwYPNnHQrq3r27hIeHO6URV65cMT1Cw4YNkylTpqS5b9OmTTJixIiU2yVKlJD69evLhg0bCDYAACCNrHWr/L8hQ4aY4uA1a9bIpUuXMq15adu2rem9sce///1vE1h69OiRJthERESYIuUyZcqkOb906dJy6NAhR5oOAAAszKFgo8NGffr0uWGBcOPGje0KNt99952sXr3aFAWnZ7t+/vz50xzX29mZdeXvzyx3b+Dn55vmOwDr8PX1EW/G7zUnB5u33npLqlSpImPHjjVFwj4+Gf+BFSxY8KbXiYqKMlPDJ06cmGmxcWbXVcnJyaaex9E3Q1hY2qAEawsJCXR1EwDAqfi95uRgc+TIEXnjjTekatWqkh1z584108O110a/VHx8vHz22WdmNlTPnj3NMR3uSk1v2xOcMpOUlCzR0Zez1W54zv9o9M0fHR0niYksEQBYSZ48fhIcnE+8lbf9XgsJCbS7l8qhYKNFw1rwm1333XdfhvoZ7YnRehud8q2zrnTq+OHDh+XOO+9MOUfra+rVq+fw4yYkeM8/Boh58/N3DliLtw/F8HvNycHmkUcekTlz5kiNGjUkKChIHNWwYUPzldrkyZOlUaNG8tBDD5nbrVu3luXLl0uHDh3MY+3evVv27NkjEyZMcPhxAQCANTkUbI4dOya///673H333VKpUiXJly9jd+CkSZNMb0t2Pfnkk/L999+bYKPr2ej6NU899ZRUq1Yt29cGAADW4lCw+euvv0ygsUlMTHRag7QgWVcZtgkJCTE9Ntu2bTPFxk8//bTcdtttTns8AADg5cFG93PKKbp9Qnp58uQxqxkDAAA4Pdhs3LjR7OJ9Iy1atMiw/gwAAIDbBRutn9HhqOvx8/Mzm1gSbAAAgNsHG90E89q1a2mO6fozur7NrFmzpF+/fnLrrbc6q40AAAA5F2x0nZnMaFFv9erVpWvXrmYXbkdXBwYAAHCE05NHyZIlzfdz5845+9IAAAC5G2z27t0rkZGR1NcAAADPGIoaP368nD17NsPGlLrjtgYb3SrBnp29AQAAXB5sLl68aBbLS78Tt65APGTIkJTNKwEAANw+2MycOdP5LQEAAHBFsFHaY/P222/Lt99+a2pqChQoILVr15YBAwawjxMAAPCc4uELFy7Io48+KkuXLpXixYubmpqKFSuazSr1+M6dO53fUgAAgJzosZk3b57Zv2ndunVp1rS5fPmyvPjii/LGG2+YjSsBAADcvsdGe2aef/75DAv1BQUFycSJE2X//v1y6dIlZ7URAAAg54JNUlKShIeHZ3pfYGCgCTg32yQTAADALYJNpUqVZMWKFZnet2HDBvO9SJEi2WsZAABAbtTY9O/fX9q3by9nzpyR1q1bS9GiRc3aNj/99JMsW7ZMnnjiCbPDNwAAgNsHG+2xmT59uqmn2bx5c8rxgIAA6du3rwk2AAAAHrOOTcuWLc00by0UjoiIMHtDVa1ala0UAACA59TYnD59Wg4cOGD+7O/vLzVr1pR7773XBJzffvstJ9oIAADg/B6bNWvWmGnenTt3NuvVpF/bRmtu+vTpI2PHjs3KZZELfH19zJc38fNz+ub1AACrBJvDhw/Lc889J82bN890k8tVq1bJokWLzDYLlStXlkceecTZbYWDNNAULBjklR/0SUnJZoNWAIB3sDvYLF682ISa622AGRYWJs8884zZ4Xv+/PkEGzcLNhpqpizeISfOeM/CiaWKFZCRPep7XU8VAHgzu4ON1tBocLkZHYrS8HPlyhUTcuA+NNQcOnnR1c0AACDH2D02oVskaK/MzeTNm9ecp+vaAAAAuGWw0UX4jh49etPzYmJiJCoq6rpbLgAAALg82Nxzzz3y4Ycfmn2ibmTBggVSrVo1s/s3AACAWwabDh06yF9//SXPPvus/P333xnu15oanRE1Z84c6devn7PbCQAA4Lzi4dDQUFMUPHjwYLPicJUqVaR06dLi6+sr586dk71790pCQoIJPq1atbL3sgAAAK5ZoK9u3bqycuVKWbhwoXz99deyadMmSU5ONvU37dq1k+7du5ttFQAAADxir6hixYqZ1Yf1S2mwYQE0AADgDrK9FC2hBgAAuAvvW2MfAABYFsEGAABYBsEGAABYBsEGAABYhsPBRhfkmzdvnvTq1UseeOABOXnypLz++utmPRsAAACPCTa6H1S3bt1k2rRpZnPMM2fOmMX5NNT06NFDtm7d6vyWAgAA5ESw0Z6axMREWbdunVmwr0iRIub44sWLpWfPnqbnBgAAwCOCzZYtW2TMmDFmS4XU/Pz8ZMSIEWYvKe3JAQAAcPtgc/XqVcmXL1+m92m4UZcvX85eywAAAHIj2Oh+UPPnzzfDUenp0FTevHnN/lEAAABuvVeUGjBggDz66KNm40vdyTs2NlbWr18vhw8fNsFm1KhRbLUAAAA8o8emcuXKpsdGzZo1SyIiImTKlCkm3AwbNkz69u3r7HYCAADkTI+NatCggXz55Zdy4sQJOXv2rAQFBUn58uUlICDA0UsCAAC4JtjYlCpVynwBAAB4TLAZP3686Zmx1yuvvEIBMQAAcM9gc/HiRYmKirL7wklJSY62CQAAIGeDzcyZMx17BAAAAHevsYmLi5NFixbJpk2bJDIyUkJCQqR+/fpmRlTx4sWd20oAAICcmu6ttTatW7c2vTg+Pj5SpUoVCQwMlBUrVsjDDz8s+/btc+SyAAAAud9j89Zbb0nBggVlyZIlcsstt6TZ9fvFF1+UsWPHmoX6AAAA3L7HZseOHfL888+nCTUqODjY7OytKxCfP3/eWW0EAADIuWCjvTXJycmZ3ufv7282yPT1dejSAAAADnMofWh9zaRJk+TMmTNpjmvYmTFjhtlyITw83PFWAQAA5GSNjW5saQsyGmAOHDggLVq0kHr16kmxYsXk8uXL8ssvv8jff/8td999t9k/qlChQo60CQAAIGeDTXx8vFy9ejXldp06dVKOHz9+3Py5RIkS5ktDTkJCgt2N+PTTT2Xp0qVmAcDbb79dRowYIYULF065X6eUv/feeyZY1ahRQ5577jkpXbq03dcHAADewe5g8+abb+ZIA5YvXy7Tpk0zQ1slS5Y03x977DEzq8rPz0++//57GT58uJltpaHmnXfekT59+sjq1avNFHMAAIBsL9CnU7u3bNkisbGxKYXE+l0X7vvtt99k6NChpvfmZubNmyeDBg2SJk2amNsvvfSSNGvWTH7++Wdp1KiRCTLt27eXDh06mPvfeOMNc7/uLN65c2dHmw8AACzIoWCjC/D16tXLhJvMaM2N9rbY4z//+Y+Ehob+r0H+/zTpypUrcu3aNdm5c6d06dIl5f6AgABT1/PDDz8QbAAAQPZnRWkvi9bYfPHFF+b7a6+9ZnpQ/vWvf5m1bR5//HETbuxRpEgRE1aU9v5MnjxZSpUqZXprtABZa3jSb9Gg1z5x4oQjTQcAABbmUI/NwYMHTc1LpUqVTLHv77//Lp06dZLbbrtNKlSoYIp7e/TokaVrLliwQKZPn24KlF955RWzFo4GHZU3b94052oQ0h4dR/n7e9caO35+3vV8M//7dnjU1SMlJSVfd60pwAp8fX3Em3n77/Ubcfi3fYECBcz38uXLy0cffZRyvFatWiaQaPDQcGKv7t27m6Lgb7/9Vp5++mlJTEyUxo0bm/vSz7DS244WDuubISwsv0M/C89SsEBeSU5KkqCgtMHYG+jz9mGRTMCyQkKYPOPUYKO9MjpbSRfi02Czf/9+U2+jWyro0JEGm0uXLmUp2NiGo5o2bWoWAFy2bJkpGtYVjHVIKjW9nXo6eFb/JxsdfVm8Ldl745sgODCP+XA/u3K6xEd4z9BlQKFSUrT9UImOjpPExCRXNwfIEXny+ElwsP2fMVbjbe/vkJBAu3up7A422oNiKwju1q2b9OvXT3bv3i3jxo0zWywMHjxY2rVrJxs3bpSgoCBTO3MzGoYefPBBs7/UPffck3Jcw5EWEesQlO4cvnfvXjMTykZvpy4ozqqEBO/5xwAxoSb+7yNe91LoLz3+rcOqvH0ohvf39dn9L6NVq1Zy7Ngx82ct7NV6mCNHjpjF+LR4WFcd1l29t23bZupv7KE9PHXr1jXr2Jw7d87UBKxfv17Wrl0rXbt2TRmi0l3ENcxouNLp35GRkdKxY0d7mw4AALyEwzU2999/v/lSt956q2zevNns6l2uXDkJCwuz+zoairTHRq/l4+Nj9pjS29r7o7QoWWdA9e7dW5KSkswMqblz57IXFQAAyMBpU0V0OErXl3GkCFkX3dOAowXHOoyVmoadYcOGyZAhQ8yMKe3lAQAAyIzbzIHVIuH0oSa1PHnymC8AAACnBBst9LWX1snoEBUAAIBbBpvmzZtL/vz2rQFj73kAAAAuCTYjR46UMmXKOO3BAQAAnMm7FwIAAACWQrABAACWYXewadmyJVOtAQCANWpsdMduAAAAd8ZQFAAAsAyCDQAAsAyCDQAAsAyCDQAA8O5gs3z5cjl16pTzWwMAAJDbweaDDz6Q++67T3r16iWffPKJxMTEZKcNAAAArgs2GmYmTZok+fLlkxdffFHuuusuGT58uHzzzTeSkJDgnJYBAADk5F5RNkFBQdKuXTvzFRkZKWvWrJEvvvhCBg0aJIULF5bWrVtLp06dpFKlSo5cHgAAwDXFw+Hh4dKzZ0+ZPn26dO/eXc6fPy8LFy6Uhx9+WIYMGSJnz57N7kMAAADkXI+NzaVLl2Tt2rWycuVK2bFjh/j7+8v9998vHTp0MH+eN2+eDBw4UFatWpWdhwEAAMi5YLNt2zZTZ7Nx40a5evWqVKlSRcaMGSNt27Y1PTg2d955pzRq1EjOnDkjxYoVc+ShAAAAcjbYaMGw9tY8+uij8sgjj0jVqlUzPS8gIEAaNmwoISEhjjwMAABAzgebV199VerVqyd58uS56blz58515CEAAAByp3hYh5f8/Pzk+++/l+jo6JTjy5YtY+E+AADgWcEmNjZWHnvsMenbt69cuHAh5fiiRYvMFPA9e/Y4s40AAAA5F2zee+89s36Nbq1w6623phxfsWKFWb/m5ZdfduSyAAAAuR9sdAhq3LhxUqtWrQzFwiNGjJCjR4+yzQIAAPCMYBMfH29qbDKjx318fOTy5cvZbRsAAEDOBxvtqXn33XdNwElv8eLFEhwcLEWLFnXk0gAAALk73XvAgAHSsWNHs8rwvffeK0WKFDEhZ/fu3fLjjz/K5MmTHW8RAABAbgab0qVLm8LhN998U7788ktTT6NDUNWqVZM5c+ZIixYtHG0PAABA7u8VVbZsWZkxY4b5c1xcnCkcvl7dDQAAgFsHm2PHjslXX31lFuhLTk7OcP+gQYMkLCwsu+0DAADI+U0wtc4mKSlJgoKCxNc3Yw1y9+7dCTYAAMD9g838+fOlVatWMnHiRDMDCgAAwGOne58+fVoGDhxIqAEAAJ4fbEqUKCFnz551fmsAAAByO9j06tXLTPU+fvw4Lz4AAPDsGps1a9bIqVOnzHo14eHhEhgYmOEc3em7ZMmSzmgjAABAzgWbYsWKmVWHbySzsAMAAOB2wWb48OFpbus6NrrxJQAAgMfV2Khz587JhAkTpEmTJmYrBV2wb8iQIbJu3TrnthAAACAng42Gmk6dOpkQU6dOHcmfP7857u/vL88++6ysWrXKkcsCAADkfrCZO3eulCtXTjZt2iQzZ85MWWF4+vTpMm7cOJk2bVr2WgUAAJBbwWb79u0ydOjQlJ6a1Hr27ClXrlyRyMhIRy4NAACQu8FGi4WvXr2a6X2JiYkm2Og+UgAAAG4fbOrVq2cW6NOdvdN7++23pXDhwuYLAADA7ad7Dxo0SDp27CgtW7Y0s6IuXrwoCxYskAMHDsiOHTtk6tSpzm8pAABATu0V9dFHH5mem7Vr15pgs2TJErl06ZLMmDFD2rRp48hlAQAAcr/HRpUtW1beeustSUhIMMEmX758mRYTAwAAuHWwmT179nVnPekKxBpySpUqZbZdoNYGAAC4dbDZv3+/bN682cyA0l6aokWLmkJiDTs6YyooKMjMmtJ1bT744AOzMjEAAIBb1th06NBBQkNDzUJ9O3fuNHU227Ztk6+++koaNmwovXv3lt27d5sC41deecX5rQYAAHBWsFm2bJm88MILcu+996Y5rqsR6zDVokWLxM/PT4YNGya///67xMbGOvIwAAAAOR9sTp8+Lbfeemum92lPTp48eeT8+fMSEBBgbme23g0AAIBbBJvy5cvL0qVLM71vzZo1cu3aNQkPDzc9NREREVKwYMHsthMAACBniocHDBggPXr0kIMHD5pF+rR4OC4uTnbt2iWrV682O3xrr40ORVWuXFkCAwMdeRgAAICcDzY1a9aUDz/8UP7973+brRVs+0KVKVNGXnvtNWnfvr257evrKy+++KJd1zx37pyZVVW6dGkzqyo97fnRc/QxCEoAAMCpC/TVqVNHFi9ebFYbPnv2rBQqVCjDkNPMmTNveh392REjRpgi42LFisnx48elb9++prdHaWjScPTll19KkSJFTPiZOHGiPPTQQ442HQAAWJTDwebYsWNmercWBuvaNZntJxUWFnbT64wfP94UGX/77bemJ0bXyOnWrZuZYaU9P9oz9N1335kp5Rp8Vq1aJc8//7zUqlXLLAIIAACQrWCja9ZonY32puiwkQ45pde9e/ebBhvdjiEmJkaGDBmSMrxUtWpVs7HmN998Y4KNTi3v3LmzCTWqXbt2Mm/ePFm5cqX5OQAAgGwFm/nz50urVq3MkFBwcLDjD+7vb4az0ouKijLDThp6Dh8+LNWrV09zv4afX3/91eHHBQAA1uTv6Do2I0eOzFaouZ69e/fK9u3bzUJ/GnB0mCt9z4/e1sDjKH9/h2a5eyw/P+96vvgHf++wMl9fH/FmvL+dHGxKlChhin6158SZdFE/LRp++OGHpUWLFnLo0CFzXFcxTk1v6zCWo2+GsDB2IYf1hYSwzAJgVby/nRxsevXqZaZ560J9Oj3bGXS202OPPWbCkk4ZV7rBprpy5Uqac/W27b6sSkpKlujoy+JtyZ43gfeJjo6TxMR/lmIArCZPHj8JDs4n3srb3t8hIYF291I5FGx0deFTp06ZXhVdYTizdWV0v6iSJUvadb0zZ86YUKMznTTU2HpodOG/fPnymaGv1PSxr7elgz0SErznHwO8l/7S4986rMrbh2J4fzs52OgMpfvvv/+G59i7iJ6GlD59+kizZs1kzJgx4uPzv3FTnW11xx13mOnebdq0Mcd0m4YdO3bIhAkTHGk6AACwMIeCzfDhw53y4PHx8WbauE4Z1wX39uzZk3KfFiZXrFhRBg8ebLZv0DBVt25dMyNLh78efPBBp7QBAABYh8ML9DnDgQMHUmZWvf7662nuq1atmrz00ktSu3Zts0jfwoULzV5Uup2DLv6nU8UBAABSszsd6IJ7kydPNqv96p9PnDhxw/OXLFly05WBNaToAnw3U69ePfMFAADglGDToEGDlM0p9c+65cGNZLaRJQAAgFsEm9R1Nc6qsQEAAHAmh+bL6ZRsXUwvMzprSde5uXDhQnbbBgAAkDM9NlpTk5iYaP68ceNGue+++0yISU+3Qfjll18yLKoHAADgNsFGF9xbsGBByu2+ffte99zbbrstZTduAAAAtws2Tz/9tFkZ2DY1W6dcFy5cOM05urieTt/WGUypF9oDAABwq2CjgaV169bmz1evXjUrDxcoUCAn2wYAAJAlDq1y17FjRzl27JgsXrxYoqOjJTk5OcM52qMTFhbmyOUBAAByL9hs27bNbIWQlJRk1qvRPZ3S00X8CDYAAMDtg43u19SqVSuZOHFiypYIAAAAHrmOzenTp2XgwIGEGgAA4PnBpkSJEnL27FnntwYAACC3g42uLPzmm2/K8ePHs/PYAAAArq+xWbNmjZw6dUpatGgh4eHhEhgYmOmCfiVLlnRGGwEAAHIu2OiqwrqOzY1kFnYAAADcLtik3t07ISFBYmJizGJ9fn5+zmwbAABAzgcbdfjwYZk8ebJs3bpV4uPjzRYK1atXlyeffNIMUQEAAHhEsNH6mm7duom/v79ZhViHpnRX759++kmeeuopmTNnDuEGAAB4RrB59913pWLFijJv3rw0tTS6tcL06dNl2rRpBBsAAOAZ07137dpldvtOXyCsw1F6/OTJk6YHBwAAwO2DTUBAgBmGyvSCvr6miPjatWvZbRsAAEDOBxstEv7ggw/MJpjpLVmyxGy1ULRoUUcuDQAAkLs1NoMGDZLWrVtL27Zt5cEHHzTFwxcuXDDFw99++628+uqrjrcIAAAgN4ON7hW1cOFCee2112T27NmmaNh2XENN586dHW0PAABA7q9jU6tWLfn444/l4sWLEhERIfnz5zc9NwAAAB5TY7Njxw7Zvn17yu3Q0FApX7686cFZvny5WYkYAADA7YPNe++9J927d5dVq1ZluG/Tpk0ybtw4efbZZ81KxAAAAG4bbPbu3StTp06VAQMGyHPPPZfh/tWrV8ukSZPMFgu6szcAAIDb1tgsXbrUbKOQWahRunZN+/btJTExUWbNmiX9+/d3ZjsBAACc12Nz6NAhadOmzU3P03Bz/vx5iY2NtffSAAAAuRtsrly5IkFBQTc9T3tuChYsSLABAADuG2xKliwpBw4cuOl52luji/UVKlQou20DAADImWDTvHlzmT9/vsTFxd3wPK2vadiwoem5AQAAcMviYa2v0f2hevfuLaNGjZL69eub3bxtjh49KnPnzpXPP/9c3n///ZxqLwAgHV9fH/PlTbzt+SIHgk2+fPlkzpw5MnjwYOnRo4eEhIRIqVKlTLg5d+6cnD17VgoUKGCmfDdq1CgLTQAAZOcDvmDBIPHzc2hPY8C7t1QoW7asrFixwvTKbNy4UU6dOmWmd1eoUMH05HTo0EEKFy6cc60FAGQINhpqpizeISfOXPKaV6delaLS+6Fqrm4GrLBXVGBgoHTp0sV8AQDcg4aaQycvircoVTTY1U2Am6LvEgAAWAbBBgAAWAbBBgAAWAbBBgAAWAbBBgAAWAbBBgAAWAbBBgAAWAbBBgAAWAbBBgAAWAbBBgAAWAbBBgAAWAbBBgAAWAbBBgAAWAbBBgAAWAbBBgAAWAbBBgAAWAbBBgAAWAbBBgAAWIZbBZtTp07JkiVLMhyPi4uTTz/9VN5++23ZsmWLS9oGAADcn9sEGw0vw4cPl08++STN8YiICGnXrp189tlnEhUVJaNHj5YXXnjBZe0EAADuyy2CzaFDh6R79+6ye/fuDPfNnj1bihQpIgsXLpSxY8fKhx9+KKtWrZKff/7ZJW0FAADuy+XB5sSJE6ZHpnz58tK1a9cM969fv15at24tvr7/NLVChQpSt25dWbt2rQtaCwAA3JnLg03+/Pll6dKlMnXqVAkODk5zX2RkpJw/f17KlSuX5rjePnjwYC63FAAAuDt/VzcgLCzMfGUmOjrafC9QoECGMGS7zxH+/i7Pc7nKz8+7ni/+wd+7d+Dv2Tvx9+7GweZGkpOTr3vcx8fHoWv6+vpIWFj+bLYMcH8hIYGubgKAHML720ODTWhoqPkeExOT5nhsbKyEhIQ4dM2kpGSJjr4s3pbseRN4n+joOElMTHJ1M5DDeH97J297f4eEBNrdS+XWwSY8PFwKFy4sR48elTvuuCPl+JEjR6R69eoOXzchwXv+McB76S89/q0D1sT7+/rcvviiZcuWsnLlSrl27Zq5/ccff8iuXbvkgQcecHXTAACAm3HrHhs1ZMgQMw1cv2rUqCHr1q2Tbt26Sb169VzdNAAA4GbcKtjcfffdUrZs2TTHChUqZHpsNmzYYFYenjVrltx+++0uayMAAHBfbhVsUtfRpJ/e3b59+1xvDwAA8CxuX2MDAABgL4INAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDIINAACwDH/xAD///LO8//77cubMGalRo4Y888wzUqhQIVc3CwAAuBm377HZvXu3DBgwQBo0aCCjRo2SU6dOSe/evSU+Pt7VTQMAAG7G7YPNnDlz5KGHHpJ+/fpJw4YNZdasWXL+/HlZs2aNq5sGAADcjFsHm4SEBNm+fbs0btw45Vi+fPmkfv36snXrVpe2DQAAuB+3DjYRERESFxcnxYsXT3Ncbx8/ftxl7QIAAO7JrYuHY2JiUnppUsubN68JPI7w9fWR8PD84k18fP75/tLAOyUhMUm8Rd4AP/O9eNfxkpyYIN7Cx++ft3VoaKAkJ7u6NchpvL95f3sDX9///yDz9GCTJ08e8z0xMTHNcb2dPuzYy8fHR/z87H+BrKRggbzijfzyh4o38vV16w5ZOBnvb+/C+/v63Po3X+HChU0QiYqKSnM8MjJSwsPDXdYuAADgntw62AQFBUnFihVl3759aY7/9ttvUqtWLZe1CwAAuCe3Djaqc+fOsnjxYjl69Ki5/dFHH8nJkyelY8eOrm4aAABwM25dY6N69uwphw4dkjZt2kjBggUlKSlJpk+fLsWKFXN10wAAgJvxSU72jHkTFy9elOjoaDPV29/f7fMYAABwAY8JNgAAAB5fYwMAAGAvgg0AALAMgg0AALAMgg0AALAMgg0AALAMgg0AALAMgg0s58yZMzJmzBhp3bq1bNiwwRybP3++WegRgGfj/Y2bIdjAUi5duiSdOnWSs2fPmg1U4+PjzfG4uDgZPHiwWbkagGfi/Q17EGxgKcuWLZM6deqYHprbbrst5biGmmvXrskvv/zi0vYBcBzvb9iDYANL+fPPP6VJkyYZjvv6+pqd4rUnB4Bn4v0NexBsYCm6UWpmtTQxMTGyb98+KVSokEvaBSD7eH/DHuwmCUvp0KGDdOnSxQSYqKgoU2i4du1amTt3roSEhEjt2rVd3UQADuL9DXuwCSYsZ8uWLTJx4kT566+/Uo7dcccd8uqrr0rp0qVd2jYA2cP7GzdDsIEl6ab1p0+flvPnz0vJkiUZggIshPc3boRgA6+YIurv7y+BgYGubgqAbPj6669vuB5V8+bNpUKFCrzGXo4aG1juf3Jz5syRevXqSePGjeXjjz+Wl19+WfLkySPjx483a9wA8Ezbt2+X//73v2ne7xcvXjT1dDVq1DDve4AeG1jKunXrTH2NrmNTpkwZE240zFSqVElef/118z++8PBwVzcTgBNt2rRJpk+fLitWrDD/iYF3Y7o3LGX37t0ycOBAqVKlivzwww9mUb5nn31WOnfubBbu27t3r6ubCMDJ7rvvPlNHt3PnTl5bEGxgLdotXaBAAfPn7777znRNBwcHm9t58+Z1cesA5OR7X9erAqixgaVUrVpVVq1aZaZ1r169Wp544glzXNez0f/NvfDCC65uIgAH6aa2Bw8eTHMsISHB9MQeOXKEGhsYBBtYyiOPPGLqaHr16mV+yXXt2tUcnzRpkpkxwTo2gOfasWNHmuJh5efnZ5Z0ePfddyUsLMxlbYP7oHgYlp3irUNQusO3OnHihJQqVcrVzQKQDTrVW4v/CTC4EXpsYMnu6etp2bKl2QwTgOdZtGiR2S9q6NChrm4K3BjBBpbsnr6e6tWrE2wAD6UTA3x9mcyLG2MoCgDgETZv3iwjRoyQWrVqmf+ghIaGprn/gQceMGtWwbvRYwPL+emnn8x6NjpbwkbXszl+/Li0bdtWmjZt6tL2AXD8vV2iRAmzB5x+pVe7dm2CDeixgbXo2jX9+/eXIkWKyJUrVyRfvnySmJgokZGRUrNmTXnttdekcuXKrm4mADstWbLEDCFraAHswWAlLNdV3apVK9myZYv07dtXOnToIN9//71MmDBBkpKSCDWAB+4PpbMaAXsRbGC5ad5NmjQx07y1Z8a2hUKPHj3Mhnk32hkYAOD5qLGBpRQuXFji4uLMn3UTzAMHDqTcd8stt8ixY8ekQoUKLmwhgKyKjY01w8k3o2tXBQQE8AJ7OYINLKVGjRoyY8YMadasmZQrV84ce++998xWCz/++KMMHjzY1U0EkEXjx483Xzczbdo0ad26Na+vlyPYwFK0vubnn3+W3377zSyzPmrUKBk7dqypr9EtFbSAGIBn0S1S6tate9Pz7DkH1sc6NrA8nRYaERFhpoHatlgA4BmGDRsmLVq0oCcGdqN4GB5vwYIFZvXhG9XdaCExoQYArI9gA4+3Z88e+fvvv9Mce/nll80u3wA8m256GRgY6OpmwINQYwNLunDhglmgD4Bns6doGEiNHhsAAGAZBBsAAGAZBBsAAGAZTPeGJaaD6q6/QUFBaaZ46+3Ux9QLL7wg9957rwtaCQDIDRQPw+M1bdrUTOm2R9GiRXO8PQAA16HHBgAAWAY1NgAAwDIINgAAwDIINgAAwDIINgAAwDIINgAAwDKY7g24kSNHjsiXX36Z5pjuSq7r8ZQrV07uuusuCQgIcNp+WuvWrTPfq1evLnfffbdTrmsFMTExsm3bNjl27Jh5/UuXLi133HGHhIaGpjnv6NGj4ufnZ+7PCkd/zpkOHz4s33//vVy9elVuv/12qVmzpsvaAjgTPTaAG9EPvNmzZ5sPHZukpCQ5ffq02QywdevWcvLkyWw/jl6zS5cu8t5775kPcf1wwz82bNgg9913nyxatEgiIiLk3LlzsnDhQrOw48cff5zyMv3555/Stm1bOX78eJZeOkd/zpn+85//SLt27WTPnj1y8OBB6dmzp0yaNMll7QGciR4bwA1pgGnRokWaY4899pi0atXKfADNnDkzW9c/e/asCVGvvPKKPProo9lsrXXo6zJ8+HAZOHCgPPPMM2numzVrlrz00ktSu3ZtqVKligmE8fHxWX4MR3/OWQ4dOiSvvfaavPrqq/LII4+k/Hvr37+/6bXTXkHAkxFsAA9RokQJadCggRk+SO3333+XH3/80XxY6nCCDpnY6HH9H7muzrxp0ybJly+fFC9eXLZs2WLu//bbb+XMmTMyYMAACQwMTLne7t275dKlS1KjRg1zPR2Oud71HnjgAXPswIED5oPy66+/Nr1K+jgtW7Y05+iwzq+//mpWiNbz8+fPn+Y56ONp70FcXJz5uWbNmklISIi5b/v27bJ//37p1q2beUwNZHqd+++/P+UcG22Dbq+hPVJ169aVWrVqZXgdb/R67dixwxy/5557Mvxcr169zHe9X8PB8uXLze2VK1ea59u5c+ebPp/r/Zz+ne7atUsGDx6c5jEXLFggpUqVSgm52oP0zTffmAAWFhYmd955p9x6662SFZ988okUKFBAOnTokHJMA40OR2rbCDbwdAxFAR5EP1T1Q8lGe1w6duwoe/fuNUMmI0aMMCHlypUr5n79kJ8xY4b07t3bfIjqh9r1anQSEhJk9OjR0rVrV/PBfOLECRk6dKj5QI+Ojr7u9TS4aPh46623pH379rJ582azV9eLL74o3bt3Nz0f77zzjmmf/qyGH9vQlz6fJ554Qp599lnzeFFRUeY62jOlw29Kr/3uu++aoTMNA9oWvf3ggw+aUKaSk5NlwoQJ0qlTJ/nll19MbUzfvn3ljTfeSPMcb/Z6aQhRc+fONc8htYIFC8rTTz+daVhK/fdzs+eTmR9++EHefvvtDMc//PBD2bhxY8pr37x5cxMcL1++bMKZXvejjz6SrNDnXrlyZfH1TfvrX49pGAM8XjIAt7Fp06bkSpUqJW/YsCHDfX/++WdyjRo1kidMmGBuL1++3Jz7xRdfpJxz8uTJ5Lp16yb/61//Mrdnzpxpzvnkk0/M7aSkJPP9+PHj5vjKlStTfnbOnDnJVapUSd61a1fKsRMnTiTXq1cvefjw4Te8nv6sHp8/f37Kzy5cuNAce/rpp1OO7dmzxxxbv369ub148eLk6tWrJ586dSrlnJiYmOQ6deokv/nmm2mu/cEHH6ScExkZmVyzZs3k6dOnm9vaHj1n69atKeds27bNHPvhhx/sfr3U2LFjzXnVqlVL7tGjh3nOP/74Y/K1a9fS/H3o65T+Me15Ppn93LRp08zfbXrNmjVLHjVqlPlz165dkwcOHJjm/tWrV5vHzIqWLVsmDx06NMPxyZMnm+cMeDqGogA3tHr1ajP8YutJOXXqlClqLV++vKkBUTpsoLfbtGmTZrhKh3pWrFghzz//fMpx23CLbUgpM5999pk0adJE6tSpk3KsZMmSZqhEew5efvnlm15PazVsKlasaL5rr0L6Y7YCaB1O0aJo7SnRXhc9rkNW2quUvrhWC25t9Od0iEZ7ZtSqVavMsFLjxo1TztFhGu2R0eva+3rp89H6Ez326aefytatW02PkRZ0h4eHm9c+9ZBTell5PlmlPWP79u2Tn3/+2QxJqoceeijL19Hhscx67fSY/lvTL39/PhrgufjXC7i5PHnymFoXHWbRabm2IQSdXVOkSBFT1JqahqCLFy+aoRal599yyy03fIzExETzwZu+YNkWRvR+HVq52fVS77Ku05lVoUKFMhzT6ykNEEuWLDH1Hlp/omGgYcOG5rvWyaSmwSL966IfwkrrbvS1SW/QoEEpf7bn9bLt/q4BT7+0nRomtBZp6dKlMm7cOPO4OuSWmaw8n6waNWqUGdbr0aOHCU7aPh2a0nqg9MNKN5I3b165du1apsNoGm4INfB0BBvAQ2ZFpacflLaC39T0f/P6pR9gSnshbIHievSDV78y69GxfSDbPvBudL2bPU5606ZNk/nz55u6FK1/0ToPDQ5abJvejXqbbEEpu6+X1qvoOToV2vZ8tCdIv7R4Wf9eli1bdt1gk5XnY4/Uz0tnYum6Qzt37jTF2FrLpNPPtdhXH/NGr09qGkq1CDm9yMjINMEU8FQEG8BDlSlTxizcpwWtqWnvgg5/pC4yvhkNLbpYnPYypKc9HfrhbCusdSbtBdH1YbTYNnXPQfrCXXtei8yGejSo6PCQ9qTY83ppEa8O9WiASd9zoT1G2ntl6yXKLEjY83wy+zlb71PqcKmhRhdPTE3vq1+/vvnS56GFyVqQrbPBNPjYQ3v/tAg7fZDV2WI3KowGPAWzogAPpbN79ENY//duox+EOlyiH1JZGZ6wXU8/5HVGlI3WiGj9iU7bTj9F2xk0TOi08tR0YTwNA5kNl1yPbbE5na5to/U3ulZLbGys3a+XzvbSnoupU6dmGDrS2VY6JdvWW2OrU7EFHXufT2Y/p7U/+nj6GDZfffVVymwtvU9nlqWf6q+BSHuV0g/T3YgOk+nQm/692nz33XdmyO1G9UOAp6DHBvBQulqsfhhpHYn2SGj9yPr1682HXOpCX3vponT6P/8+ffqYolT9AF67dq0ZTtGC2Jzw1FNPmWna+tja46ABQ9tQtmzZG06PTk8XGdRApovMadu1Z0YLsLVQ2LZeiz2vV7169WTKlCnmtq6Zo8M8wcHBpoZH14/R6+u0c6U9XPo4Ok1bg8HYsWPtej6Z/ZwOO1aqVMmsY6NF0rpOjQY1W7G1hi4NN7a2a1G3hk5t/7Bhw1Jqg+yhj6NF0DodX4OSDsHpa9WvXz+21YAl+OjUKFc3AkDavaL0w7lChQp2vSw6e0rXONEeAP0gTF1Mqmud6KyeIUOGpPkZXQtGtwnQRe7SD2HYej70V4Mu2taoUaM0C/Rldj09psM4qYd5tNhYZ1ppsNAZTErbqB/oGhg0RKRfVE8DgM5m0joS7V15/PHHTWBJf23bsI/u3ZR6ZpD2eGhbtBdDZ3fpKsFZeb1SzxzSc/TvQ3tNNDhom4sVK5bmPB26sy1UaFvA72bPR3tZMvs57dXRNWv++usvM+ynfzc6E057ymz1VrrVhj4/XR9He4e0TfoYjvjjjz9Seq90aIu9omAVBBsAAGAZDEUBgAXoWkNaO3MzTz75JFO6YWkUDwMAAMtgKAoAAFgGPTYAAMAyCDYAAMAyCDYAAMAyCDYAAMAyCDYAAMAyCDYAAMAyCDYAAMAyCDYAAMAyCDYAAECs4v8Aj/5B/jI8MRMAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkoAAAHTCAYAAADYojePAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAOqZJREFUeJzt3Ql0k1X+//FvF6DQNlAQ2XdEXEBRUFBHUdmUVf0JAg4ugIKiwjioICIqgsyAKyoO6oAjgigjIqAgCioqAu46IJvs2IFS6EJZuvzP987/yUnb3C5p2mzv1zk9IcnTJzdJw/PJvd97n6i8vLw8AQAAQCHRhW8CAAAAQQkAAKAI9CgBAABYEJQAAAAsCEoAAAAWBCUAAAALghIAAIAFQQkAAMAi1nYHgOIdPnxYjh07lu+2qKgoSUxMFJfLFZQvYXJysuTm5kq9evUC3ZSIc+rUKfP6JyQkSI0aNYrc9r///a9kZ2dL/fr1JRD0byQlJUWqVq1q2usNf0uIBFGszA347q9//at88MEHXu+rVauW9O3bV+69915zsAkWvXr1koMHD8o333zj0++vXbtWTjvtNGndurXf2xbutmzZIr1795YhQ4bIww8/XOS2119/vfz+++/y/fffV2g4ev/99+Xtt9+WX375xQQ71axZMxk0aJAMHjxYYmJi/Pa3BIQCht4AP9Dg0KBBA/NTp04diY+PN9/GX3/9dRkzZkzYvMbvvPOODB061PR2ILwcPXpUhg8fLg899JAJZzk5OebvulKlSiawPfnkk3L//fcLZ71CpGHoDfCDp59+Wi6++OJ8t23evFlGjBghq1evlu+++04uuOCCkH+tU1NTA90ElJMHH3zQ9BY2btzYBKKrr77ahCQNTKtWrZJJkybJhx9+KGeeeaaMHDmS9wERgx4loJzo0JQOVahff/3V6zZZWVmmzuPkyZNe65/27t1rvunb7svIyDDXtYdH9+M4cuSInDhxotRtLqo9OsTitEV7y/TxS9O7oG1NT093X9+/f795Hg59XH0MpXVf3p53cW109nPgwIFCt+swkrZZXxuHr6+bbqO/a2uDJ33OBevYfA2pmZmZhW7X10yfl9YzeRtK0/v0/SqKBiEN9HXr1pW33npLevToYUKS0qG27t27y+zZsyU6Olrmzp1botdIn7O+tp7vuTf6N3To0CH333JZtwP8jaAElCPnP3WtV/L0448/yp///GfTy3T55ZfLhRdeaGqZ9KDm+O2338y3+gEDBuQ7COrB/JprrjH1T87+tefqjjvuMOGjf//+pnfrvPPOM7UwWhdTnJK05y9/+Yu8+uqr5t86PKNtK0kA+PLLL6VPnz5mn+3bt5c777zTBCS9TXspHNp+fcyPPvpILrnkErnoootkwoQJpWqj0qHBfv36FWqHDh9pm59//nn3baV93bZt22aGp7QNf/rTn0wbRo8enS9sOT777DNTj6TPWbcfN26cT+FV9z1w4EDp2LGjebyCbXvttdfM89KwU5DWDul98+fPL/IxtC5J3X333VK7dm2v25x77rnm/ltuucVrYHPoY/Xs2VPatWtn3id9/l26dDHDtp40QGnPlW536aWXmuemNU/aa+XLdkB5ISgBfqDfdPWArT979uwxw25z5swx3771W/qVV17p3nbdunWmp2n9+vXmW7LOftKeiRUrVsiNN97oPvB36tTJHLz1AK/FtZ7DfBqWNKzovh0apjSEaKBwZtzpgfLmm2+W3bt3W9te0vZovYqzXw1+Wo+lPQxF0aEcDSIa+rSHQmdPrVmzRu666y7T2+Gt10TDke739NNPN2GpNG30RUlfN30OGlo///xz9+uhv6sH7Jtuuilf75iGJB2e0kCjz7tatWry73//29T5lIa+RhrmdOi2evXq+dq2b98+d9G3Wrp0aaHf19CpNFgURfepszU10BRl1KhR5nnVrFnT6/0vvfSSCb8aKPU90tAVGxtrPhP6vv7000/ubTVgapv1NdT3WmeKbt261dT0ff3116XeDigvBCXAD7S3Rb+5648ebLS3Z+rUqaawW7/xO7Pe9MA3ceJEMwyks4g2btxoDlJ6YNUeCj3YTp48OV/diE7jf+GFFyQtLU1+/vln881cv1lrQPCkByf9pq+hasOGDfLVV1+ZgKZDWM8++6zXdpemPc8884zpTVFPPfWUfPrpp0XO5tNA88QTT5gDnB5c9WCv+//HP/5hwp+3Xgm9XXuTNBh98cUXpteptK9ZaZX0dXv00UdND5q+J/pctKfs22+/NUFGe6T09XFMmTLF1PZoj5duq9u9/PLLsn379lK17fjx4+Yx33vvPRMStW2dO3c2bXvuuefMNq1atZJzzjnHvB76N+LQx//444+lTZs20rRp0yIfQ/en4dcWgEpC3yfn8TTA6nukQVnbrT1iyukF0uCk91122WVmO32v9X3VoKXLIThhtKTbAeWJoAT4edab/gfurJGjPR1vvPGGe5q1TrnetWuXGUbQg7+zPo32DOlBWb+B6wHPqevQ+x977DHT06LfoLUnRsOJBhBvNJydf/755t960Js+fbq51PoTb/U0pW1Paei+d+7caXrGtFegcuXKptfiiiuuMMsq2Gio0m0roo0lfd30fdSZYBriunXr5q4L0pCmgfWMM86Q5cuXm7CgvYn6vHUYT4eqnOd91VVXmUBdWtOmTZOzzz7b3ba///3vpndJQ4mGIXXddde5e9gcGlC0Nqm43iRn+DQuLk7KQnsBNdC9++67+YKZzgB1er2coWKnN1F77LRXyJkkoF80NIBrGC3NdkB5YtYbUE6z3v744w9zANaeCh1+0IO89l4oDQt68PSkAUCHmpYtW2Z6Vtq2beveVg+EehBSOrShgawgDWcF26D71ACgBxXt9SjYs+BLe0pKA4PSOpWCPIciPWkbNHRUVBtL+ro5bdDeDT1I22gRubOtBsSCvL0WxbXNCXAOHR7UXhtti7atUaNGJgxpoNI1vZyeRu290fCi9ULFPYYWbHsWuZeF1mFpz8+OHTtMwNXhx02bNuULPk2aNDG1YDrcqWHS6RnT3lj9W9eZd6XZDihP9CgB5UR7PPTgpTUVCxcuNAcQnbHlrbjb4Qx9FOz98TxY6oHCG1sRblJSkrl0HtuTr+0pCaeHx6mtKdimgqFHaW+ZhsryaKO3mqiSvm5Or4s+F6fn0NuPvsfOkKK3lbe9vRZFsT1nZ99Ocbi2VcOnDh1q8bczpV8LwG3Pz6FhSsOW9vZoT1hRdEhUh369Fa8rfUztOdNQM2PGDNO7pHVJnotUOmbNmiU33HCDe/hWA5UOqV177bWyaNGiUm8HlBeCElCOdDhDA5Nz6gqnWNgpxC3IKUp2DtJKf0+HgpzhKF3R2dvsKdvBS3sdlLf6E1/aU1JOKPA2VV/bWtKlBUrbRg1gzlCnJ89i64JtKe5107CrdBab9jLZfpo3b+5+nZ3fL9jLWBq2af3e3lPtYdEwuHLlyhIPuzm07slz9puN1sppUbbWCRWkw5E6O02Hx/R1euSRR0w9mhaUv/nmm4W217ZrLZcOqWn91u23325qrfS9055Y5z0s6XZAeSEoAeVIQ4J+S9dv1Pofvk6xdg5IBXt4tA5DC4T1oKzf8B16YNLeGZ1ersXNOsSkB6yCtJBXa2o86bZ6UNMhCi0sL8iX9pSU0wvmzFjypDPASqq0bdRAqb06zppMjoKvTWleNz0wawDTGiBvQ1ROzZL25Ojwn26rw2BaKO2puCBSkD6WFnB70tl3OhSlz9czKOmwntbKffLJJ+Zx9HXQeqqS+L//+z/zN6oryWvhuTfz5s0zr4kGUu01KkjDmT5fnRmowV5n5ulwqZ7+xCnidmqq9O9ZXy/dXnuKdH9ab6R/F/r66f36vpR0O6A8EZQAPy8PoD9am6EHB13TR7/x6qwdrXvRg4bW1GiA0gOJHqB1qrMeVHV9Gh0+0jWAnN4jHbrQmT1aQ6Mzh7Q3SQ+GekDTGXAF6ZIBOsynwxOej6/T170pbXucYTEdgilule4WLVpIhw4dTOjQ6ff6O1qrMnPmTDOcUlKlbaP26ijt3fjhhx9MrZQeuIsapinuddNp6XqQ1kCkazlpL4nOYNNhJS0o10CghfY6jKXBSofBtL233nqrCXL6vHWWmhb2l4a+3vo8Fi9ebB5PQ6fOPNTAoTMAC26rPTkaZvQ5aBucnrDiaF2YPi8NJPqa6ixCnWWmj6n1RtoGZwLB2LFjvc52dEKb/r3qEhD6vmsv0H333WdmfipnCFNfN631GjZsmKm10m31tdflNPT90tdQ91fS7YDyxElxgXI6Ka5nnYmuduwUUuuUZ1000NvQjC5MqAcVXXdHh2l06EQPikuWLHH3mOhsJ13PRmuV9Ju1rtOjs4o0POisLD1IedIp9Dpk4ay0XPBEpiVtj9IeFZ3y7hyYNbRoiLDRA60e0Av2wmjvhT4vrTNxptXrkgraQ+TtJLClaaOGIw1UBYdk9ECvw0G6HpMW1qvSvG66EreGCW91PDrMqG3QImul7522QdvtSQPjK6+8UuKT4moI1Pddh/U8ae+Rhs2CtT/OSXeV9jqWtEdJ6bCdzrBcsGCB1/s1BOrsRX0ODs+/JW2rrvvlFG570r8V7VXUv1n9vOhjabD01sunj6PhU1cDL+l2QHli1htQBvpt1tsMtCpVqphvu9qjoj1Bnt969cCnM9j0W7H2NugaNrqkgP6Hr0WrzoFZD9Jan6MLNnoOfXXt2tUMlei3de0l8ewt0l4LDR767VuHSDSI6MHLs0Ba2+U8Rmnao3S2kX6711Chz1G3LSooaa+StlHDgQYY3ZdOddcDrPZcePZM6H68nYajtG3UIT+tidFeNw0OWsyswURfNw0X3oqsS/K6afv0uei+dTkCrXnS91UfTwOUtsehdWnaQ6XhSd8nrcfSXi9tq/YKlaSoWx9Pw562S2dVOkOMuiq7hj1vBdLaM6R/M/p4Tt1RSWnw0KCkz1vbrrPWNBxqANVhLv071tPyePL8W9IePV1kVd9rHb7T4U99HXToVGfi6TpUGjK1aFx7V3WFdA36Gvy1TkyHK3X/+lo6sxe1TSXZDihP9CgBYcDpGfE2HBco2mOkw0+6jk7BYnAdntEhJO2dcqZ9B0Iwvm5lofVMt912mwk1nqeHAeA7epQAlAstvNZeHB16HD9+vDnrvPZ06AKS2kOiPQOlXVcI3gOpFnhrD46eIkVfVx32A+AfBCUA5UKHV3S4SYdNdFXxgnRI0anpge90eEqHy5yaLO0la9myJS8p4CcEJSAMaD1LUWd0DxTt4dAZf1qX46x3pLPYtFZHZ4oFWrC+bqWhPUhaq6VF1FqUrrPSAPgPNUoAAAAWrKMEAABgQVACAACwICgBAABYEJQAAAAsCEoAAAAWBCUAAAALghIAAIAFQQkAAMCCoAQAAGBBUAIAALAgKAEAAFgQlAAAACwISgAAABYEJQAAAAuCEgAAgAVBCQAAwIKgBAAAYEFQAgAAsIiVIDBy5Eg5efJkvtsGDhwoXbp08br99u3bZd68eZKcnCznnnuu3HLLLVKtWjWfHjsvL09yc/N8+l2EvujoKN5/IELx+Y/s9z4qKqpE20blaVIIoP3798uVV14pM2bMEJfL5b69RYsW0qBBg0Lbb9u2TQYMGCA33HCDCUlz586VSpUqyVtvvSXR0aXvIMvJyZXDhzPL/DwQemJjoyUpKV5SUzMlOzs30M0BUIH4/Ee2mjXjJSYmOjR6lLZu3Wp6g3r27FmidPf888/Ln/70Jxk/fry5fsUVV5igtWrVKunWrVsFtBgAAESKgNcobdmyRZo3b16ikJSbmytffvmlCUeO6tWrS/v27WXNmjXl3FIAABBpgqJHKTExUZ599llTe6TDbYMHD5ZGjRoV2vbQoUOSkZFR6D79nd9++60CWw0AACJBUASlffv2ydVXXy1nnnmmfPjhh9KnTx+ZP3++tG7dOt+2GpJU1apV892u1zMzM8s0Vo3I44xPl3ScGkD44POPkAlKDz74oDRs2ND8qGuuuUZuvvlmU9w9e/bsfNvGxMS4h+A85eTkSOXKlX2ufNeCXkQulyt/8AYQOfj8I+iDUseOHQvddvHFF8u7775b6PZatWqZy6NHj+a7Xa8nJSX59Pi6NEBa2jGffheh/41S/5NMS8sysx8BRA4+/5HN5aoaGrPedCht9OjRMmrUKDn//PPdtx88eFBq165daPuEhARp0qSJqUe67LLL3Lfr9c6dO/vcDqaGRzYNSfwNAJGJzz+KE9DiDA0+R44ckZkzZ7oXnNy0aZMsWbJE+vfv7/V3+vbta+qXUlJSzHVdFkCDUr9+/Sq07QAAIPwFfOht+vTpcu+990rXrl2lbt26snnzZrMq94033ugOQhqMXnjhBbPe0rBhw+Snn36SHj16SOPGjeX333+Xxx9/3PQ0AQAA+FPAV+Z2irN37Nhheol0Re7TTjvNfZ/OiNNlAy655BKJjY3Nt0J3amqqtGzZ0uf6JMXK3JGLlXmByMXnP7LVLMXK3EERlAKJoBS5+I8SiFx8/iNbzVIEJRaQAQAAsCAoAQAAWBCUAAAAgnXWGwAA/rZ37x5JT0+z3q/1KdHROZKbG1PsgrOJiS5p2LDw+UcRGQhKAICwojOi+/TpXuh0V77S02etWrW2TDOsEboISgCAsKKBZsmSFUX2KCUnH5BZs2bKiBGjpE6desX2KBGSIhdBCQAQdoobKktMTDCLGLdseYY0bMiCxbCjmBsAAMCCoAQAAGBBUAIAALCgRgkRKScnR9atWysZGUckIaGGdOjQycxsAQDAE0EJEWfp0iUyadLDsnv3LvdtjRs3kUmTnpRevfoEtG0AgODC0BsiLiQNHfpnOeuss2XFik8lPT3dXOp1vV3vBwDAQVBCRA23aU9St249ZO7c+dKhw0WSkJBgLvW63j5p0gSzHQAAiqCEiLFu3VdmuO2+++6X6Oj8f/p6/d57/yK7d+802wEAYI4PvAyIFMnJf5jL1q3P9nq/Dr95bgcAAEEJEaNOnbrmcvPm/3i9f9Om/+TbDgAAghIiRseOl5jZbc89N6PQyTL1+vPPPy2NGzc12wEAoAhKiBi6TpIuAbBy5Udyyy0DZf36b8ysN73U63r7pEmTWU8JAODGOkqIKLpO0muv/cvMfuvR42r37dqTpLezjhIAwBNBCRFHw9A11/SUDRu+ZmVuAECRCEqI2GG4yy67XJKS4iU1NVOys/PXLAEAoKhRAgAAsCAoAQAAWBCUAAAALAhKAAAAFgQlAAAAC4ISAACABUEJAADAgqAEAABgQVACAACwICgBAABYEJQAAAAsCEoAAAAWBCUAAAALghIAAIAFQQkAAMCCoAQAAGBBUAIAALAgKAEAAFgQlAAAACxiJcjs2bNHqlevLi6Xy7rN9u3bJScnJ99ttWvXlqSkpApoIQAAiBRBFZR+/fVXGTBggDz++ONy/fXXe93mxIkT0qtXL2ncuLFUqlTJffvw4cOlb9++FdhaAAAQ7oImKB0/flzGjh0rp06dKnK7bdu2SW5urvz73/+W+Pj4CmsfAACIPEFTo/S3v/1N6tevL9WqVStyu61bt0q9evUISQAAIDKC0ueffy4ffvihTJ06tdhtt2zZIi1atJCTJ0+aeia9BAAACMuht9TUVBk/frypS9KC7OJoj9KOHTuka9euEh0dLQcPHpQhQ4bI/fffLzExMT61ITY2KPIiKlhMTHS+SwCRIzo6yn3JMQBBHZQmTpwol19+uQk+JZGXlyeXXnqp+b3KlSvL999/L7fddpvUrFlThg0bVurH1w9JUhK1TpHM5aoa6CYAqGApKVXMZXx8FY4BCN6gtHjxYvnmm2/klVdeMUNqSgu1k5OTZdeuXdKkSZNCv/Pqq6/mu96uXTvp16+ffPDBBz4FpdzcPElLO1aGZ4FQpT1JGpLS0rIkJyc30M0BUIEyM0+4L1NTM3ntI4zLVbXEowkBDUq7d++W008/XR555BH3bVpzNH/+fPnll1/kxRdfzLe93rdz506zNEBcXJz7du1NSk9P97kd2dkcJCOZhiT+BoDIol+SnUs+/wjaoHTvvfean4I9RKNHj7auo3TjjTfKAw88IIMHD3bftm7dOmnbtm25txcAAESWgNcolaTYWwu2W7ZsaWqStB7pueeeM8sDNGrUSBYtWiS//fabTJ48OdBNBQAAYSbogpJO/fc8fYkuHTB79mxZsGCBJCQkyH333Wdql5YtWyYpKSnSqlUrWbhwoTRv3jyg7QYAAOEnKk+nkUV4fcrhwxTyRSKdEqwzHrWQkxoFILLs3btLJk4cJ48/PlUaNiw8cQjhrWbN+BIXc7OADAAAgAVBCQAAwIKgBAAAECrF3IC/7N27R9LT06z36/h0dHSO5ObGFLvgZGKiSxo2bMSbAwARhqCEsKTLSvTp092s9O4Peh7BVavWSlJSkl/2BwAIDQQlhCUNNEuWrCiyRyk5+YDMmjVTRowYJXXq1Cu2R4mQBACRh6CEsFXcUFliYoJUq1ZNWrY8g+nBAACvKOYGAACwICgBAABYEJQAAAAsCEoAAAAWBCUAAAALghIAAIAFQQkAAMCCoAQAAGBBUAIAALAgKAEAAFgQlAAAACwISgAAABYEJQAAAAuCEgAAgAVBCQAAwIKgBAAAYEFQAgAAsCAoAQAAWMTa7gAAINgkJx+Q48eP+2U/av/+fZKTk+uHlonExcVJnTr1/LIvBA+CEgAgJGi4GTfufr/uc9asmX7d39SpMwhLYYagBAAICU5P0vDhd0n9+g3KtK+YmGiJisqWvLxYv/Qoac/U7Nkv+aW3C8GFoAQACCkakpo0aVamfcTGRktSUrykpmZKdrZ/ht4QnijmBgAAsCAoAQAAWBCUAAAALAhKAAAAFgQlAAAAC4ISAACABUEJAADAgqAEAABgQVACAACwICgBAABYEJQAAAAsCEoAAAAWBCUAAACLWAkiOTk5Mm3aNOnWrZu0b9/eut3BgwflnXfekeTkZDn33HPluuuuk9jYoHoqAAAgDARVj9LLL78sc+fOld27d1u32bt3r/Tp00e2bdsmTZo0kVdffVXuvvvuCm0nAACIDEHTDfPTTz/JnDlziu0ZeuGFF6Rt27by9NNPm+s9e/Y0PVCfffaZXHHFFRXUWgAAEAmCokcpKytLxo4da34qV65s3S4vL0/WrFkjXbp0cd9Wp04dufDCC+WTTz6poNYCAIBIERRBaerUqdKsWTMZMGBAkdulpKTIkSNHzJCbp0aNGsmOHTvKuZUAACDSBHzobfXq1bJq1Sr54IMPit02PT3dXFarVi3f7Xo9IyPD5zbExgZFXkQFi46Ocl/yNwAEv5iYaPdlWT+znvsKtrYhuAQ0KB0+fFgmTJggkydPllq1ahW7fVRUlHsIzlNubq7Ps970IJmUFO/T7yK0paRUMZfx8VX4GwBCQEpKnLlMTIzz22fW5aoatG1DcAhoUJo1a5acOnVKVq5caX7UyZMnzdT/Xbt2yZgxY/JtX7NmzXw9Sw69Xr16dZ/akJubJ2lpx3x+DghdmZkn3JepqZmBbg6AYqSnH3dflvUzqz0/GpLS0rIkJyc3qNqG8qfvfUl7EwMalHr06CGtW7fOd9uyZcukefPm0qZNm0Lbu1wuqVevnmzfvl0uueQS9+16vUOHDj63Izu77B8ShB4Nyc4lfwNA8HMCjV766zPrr32VR9sQHAIalC644ALz4+mJJ54ws9g8Z7Z50uUAFi5caBaZTEhIkA0bNpilBR577LEKajUAAIgUQV9xtnbtWnnooYfMEgJq5MiREhcXZxadHDFihNxxxx1miK5gzxQAAEDIz3orSHuGzjvvPPf1unXrykUXXSQxMTHmuvYiLViwQNavXy+pqakybty4QssFAAAAhGVQ0p4iTy1btjQ/njQ0derUqYJbBgAAIk3QD70BAAAECkEJAADAgqAEAABgQVACAACwICgBAABYEJQAAAAsCEoAAAAWBCUAAAALghIAAIAFQQkAAMCCoAQAAGBBUAIAALAgKAEAAFgQlAAAACwISgAAABYEJQAAAAuCEgAAgAVBCQAAwIKgBAAAYEFQAgAAsCAoAQAAWBCUAAAALAhKAAAAFgQlAAAAC4ISAACARaztDgAAgk3VqlXl5MkTkpGRXqb9xMRESVTUKUlPz5KcnLwyt0vbpG1D+CEoAQBCxllnnSUHD+43P8HYNoQfghIAIGRs2rRJunfvJfXqNShzj5LLVVXS0vzTo3TgwD7ZtGme9O5d5l0h3IJSbm6u+Sm041gyGADAv7KysqRy5SqSkJBYpv3ExkZLjRrxkpdXSbKzCx/DSkvbpG1D+PEpzRw7dkyeeuopWbp0qWRmZnrdZuXKldKkSZOytg8AACC0gtJLL71kQlK/fv3k9NNPl+jowpPnkpKS/NE+AACA0ApKX375pUyePFmuvfZa/7cIAAAglNdR0pqk5s2b+781AAAAoR6ULr74Yvn000/93xoAAIBQH3rr0qWLjB49Wv744w9p27at10W2OnfuLPHx8f5oIwAAQOgEpYcfflhSUlLk7bffNj+2WW8EJZSH5OQDcvz4cb/sR+3fv09ycso+PVjFxcVJnTr1/LIvAECIBqW5c+fKqVOnitymfv36vrYJKDLcjBt3v19foVmzZvp1f1OnziAsAUAkByVCEALF6UkaPvwuqV+/rCvzRktUVLbk5cX6pUdJe6Zmz37JL71dAIAQC0qrVq2STp06meE0/bdtoUnPOiaG3lBeNCQ1adKszCvzJiXFS2pqpl9W5gUARHBQmjZtmrz66qsm/Oi/d+/eXeT21CgBAICICUpal1S7dm33v6lRAgAA4S7Wl7qk8qhRysvLkxMnTphZQ8U5cuRIoRPxak9XlSpV/N4uAAAQuXwq5tbepDfffNOcyiQ1NdWEHG/ng6tbt26x+8rJyZHp06ebZQZ0v2eeeaY5PUrr1q29bn/y5Em59NJLTTCKiopy3z5mzBi56aabfHk6AAAA/gtKs2bNMkHoggsukDp16njdJiYmpkT7evnll80q38uWLTNDe1OmTJFhw4bJxx9/7HUhyx07dkh2drYpKHe5XL40HwAAoPyC0po1a+SRRx6RQYMGSVlp0feIESOkXr3/LdI3atQomTdvnmzYsEEuv/zyQttv3brVBCpCEgAACMqgpPTUJf6wZMmSfNfT0tLMpa3eSINSixYtzL91vZqS1DQBAABUWFDq2rWrLFy4UM4555x8dUJloYXcGoJ06K1du3bSvn17r9tt2bJFkpOTzTpN//3vfyUhIUGGDx8ut912W5nW00Fo0EUincuyvm+e+wq2tgEo388Yn3+Ua1DSUNKrVy/zo2HJW6+OnjS3Zs2aJd6nFnMvWrRIdu7caYbibAHs0KFD0rRpU5k6dapUr17d1DfpY2k9ky/F3NHRUWbRQYSGlJT//a0lJsb57X1zuQrXwgVL2wCU72eMzz/K7VxvuuBkpUqVzFR9b+64445SBaUhQ4aYHw1KGni0h0kDUEHvvvtuvuvas9SnTx/Tw+VLUMrNzZO0tGOl/j0ERnr6cfelrqhd1m+U+p9kWlqWX05h4s+2ASjfzxif/8jmclUt8WiCT0FpxYoVZmaaBhkNS77SpQGOHj1qeoacWXLaW9StWzdZvXp1oaDkbK+F3LGxsfnWdfrqq698bgenrwgdTqDRS3+9b/7aV3m0DUD5fsb4/KM4Pg3y6lpG2otTlpDk7EdntunSAJ60BqlGjRqFttdeJt3+/fffz3f7999/b113CQAAwFc+9ShpsbUuNqmLQ5aF1hUNHjxYnn76aTn99NOlQYMGJgStXbvWnFfOCUd6At6kpCSpVq2a9O/fX5555hmzmGWjRo1MXdP69etNjRMAAEDAg1L37t3l3nvvle3bt8t5551nAkzB4uvOnTub1bOLM3bsWLNopZ5oV4fVWrVqJQsWLJA2bdqY+9977z0TjD755BMzw23cuHEmJOlq3ikpKXLGGWfIG2+8IWeffbYvTwUAAMC/QWnSpEmSkZFhCqsLFld7LiRZkqCktUa33367+fFGC7Q9i7R1uE8LxfUHAAAgKGe96XnZilIeJ84FAAAI+qBECAIAAJHAp6DUs2dPs45SUZYvX26KrQEAACIqKF1//fWSmppaaKr/77//bmbDaf2QzlIDAACIuKA0dOhQ6326JtJbb73ldVVtAACAUOL3M3fqsNyOHTvMVH8AAIBQ5vegdOzYMTl+/Lj5AQAAiLihNz2vmgYiT3l5eWZtJV0p+7TTTjOLSAIAAERcUHr00Uets94aN24sU6ZMKWu7AAAAQjMozZ4928xy86SnMImLi5OGDRsWOp0JAABAxASlpk2bmsvk5GRzAls951r16tXlwgsvJCQBAIDIDkpaj6Qnqv3nP/9ZqGfpmmuuMSe4rVKlir/aCAAAEDqz3hYsWGDO93b33XebFbg3btwoH3/8sTz55JPy7bffyhNPPOH/lgIAAIRCj9IHH3wgDz74oAwaNMh9W2Jioinkbtu2rVm5++GHH5aqVav6s60AAADB36OUlZUlbdq08Xpfq1atpEaNGnLkyJGytg0AACD0gpL2Gi1dutTrfT///LOpYTr99NPL2jYAAIDQGHpbs2aNZGZmmn+3bNnSrJW0d+9eU7yti0vqApQ//vijvPHGG2boLTs7W2JiYsqz7QAAAMERlLRQu+Aik6tWrTI/BWmh9+DBg6VJkyb+aSUAAEAwB6XXX3+90FIARalfv76vbQIAAAitoNSoUaPybQkAAECoBiVvJ8ItyiWXXCLVqlXztV0AAAChE5SKOhGuNytXrqRGCQAAREZQ8nYi3KLoTDgAAICICErOiXCLkpGRIe+//745xcnMmTPpUQIAAJF3CpOCtmzZIm+99ZYsWbLErLXkcrkkLi7OH7sGAAAIvaB06tQpU4ekAUlPilulShXp3Lmz9O7dW6644gqpXLmyf1sK/H96DsGTJ09IRkZ6mV6TmJgoiYo6JenpWZKTk1fm11fbxPkNASDCg9KBAwfM0Nq7774rhw4dknr16pnZbW+//bY5zxtQ3s466yw5eHC/+QnGtgEAIjAoff311/Kvf/3LnMpEe4u6du0q1113nXTs2FG6d+9uepSAirBp0ybp3r2X1KvXoMw9Si5XVUlL80+P0oED+2TTpnnSu3eZdwUACLWgNHHiRKlRo4Y89dRTcvXVV0t8fHz5tgywyMrKksqVq0hCQmKZXqPY2GipUSNe8vIqSXZ2bplfb22Ttg0AED6iSzOk8PPPP8vLL78szz//vPz666/l2zIAAIBQ6VHScLRz505Tm7R48WKZM2eOqUnq16+fnDhxonxbCQAAEOzF3LqW0l//+lcZPXq0qVV65513ZMaMGZKTkyPPPPOMCU166hJmvAEAysuuXTvLvI+YmGjZtStb8vJiJSen7EPv+/fvK/M+EEbLA8TGxkqXLl3MT3JysixatMj8fPjhh5KYmGhqmCZMmGD+DQCAP+iXcjVnzuygfUFZQzD8lHnBST1VyV133SUjR440M+O0l2n58uXmNoISAMBfmjdvKRMmPC4xMTFl3ldy8gGZNWumjBgxSurUqee3kOSvfSHMVuZWUVFRZthNf1JTU1l4DwBQLmHJH3ToTdWv30AaNmzil30iPPktKHlKSkoqj90CAAAE5/IAAAAAkYagBAAAYEFQAgAAsCAoAQAAWBCUAAAALAhKAAAAFbk8QGkdPnxYPvroI7P+0kUXXSQdOnQocvvMzEyzqKWuCn7uuedK586dK6ytAAAgcgS8R2n79u1y7bXXyoYNG+TYsWMyatQomTZtmnX7Q4cOSZ8+fWTp0qUmMOmpUh566KEKbTMAAIgMAe9RmjJlijk33JNPPmmuX3bZZXLrrbdK//79pVmzZoW2f+GFF6R+/foyZ84csxr4gAEDpFevXnL99deb3igAAICw6VHSYHT77be7r+tQmtPT5M3HH39seqA0JKmmTZtKu3btZOXKlRXUYgAAECkC3qN022235bv++eefmxMetm7d2mstU0pKSqGeJr2+ZcuWcm8rAACILAEPSg6tUZo/f77pMZo8ebI0bNiw0DZpaWnmMiEhId/t8fHxkp6e7vNjx8YGvGMNpTyRpV6W9X3z3FewtQ1A+YqOjnJf8nlFSASl2NhYueKKKyQnJ0eee+45MwTXqlWrfNvk5eV5/V293RmKKy39kCQlxfv0u6h4KSlx5jIxMc5v75vLVTVo2wagfKSkVDGX8fFV+LwiNIKS1hnpT9++feXmm2+WGTNmyCuvvJJvmxo1apjLjIyMfLfr9erVq/v0uLm5eZKWdqwMLUdFSk8/7r5MTc0s076050dDUlpaluTk5AZV2wCUr8zME+5LPq+Rx+WqWuLRhIAGJQ04s2bNMjPXGjVq5L79jDPOkI0bNxbaPikpSWrXri2///67dOzY0X27Xm/Tpo3P7cjOLvtBEhXDCTR66a/3zV/7Ko+2ASgf+iXZueTziqIEtJBCa410ocl//vOf7tu01uizzz6zLjrZvXt3ee+99+TkyZPm+ubNm+WHH36QHj16VFi7AQBAZAj40Nvf/vY3GTlypOzdu1caNGggq1evNlP+x4wZY+7/9ttvzW333HOPVKlSRe6++24ZOHCgWWdJ65i0+FuH6s4///xAPxUAABBmAh6ULrjgAlmxYoV88cUXZlabrpHk2ZtUuXJlcblc7mLtmjVryuLFi2XVqlXmlCc33HCDqW0CAAAIu6DkFGn37t3b631ae1Sw/qhq1arW7QEAAPyFxV4AAAAsCEoAAAAWBCUAAIBgrlECSmvXrp1lftF0sbFdu7IlLy/WLwtO7t+/r8z7AAAEF4ISQoqe4kbNmTNbglVc3P9OZQIACH0EJYSU5s1byoQJj0tMTEyZ95WcfEBmzZopI0aMkjp16vktJPlrXwCAwCMoISTDkj845/mpX7+BNGzYxC/7BACEF4q5AQAALAhKAAAAFgQlAAAAC4ISAACABUEJAADAgqAEAABgQVACAACwICgBAABYEJQAAAAsCEoAAAAWBCUAAAALghIAAIAFQQkAAMCCoAQAAGBBUAIAALAgKAEAAFgQlAAAACwISgAAABYEJQAAAAuCEgAAgAVBCQAAwIKgBAAAYEFQAgAAsCAoAQAAWBCUAAAALAhKAAAAFgQlAAAAC4ISAACABUEJAADAgqAEAABgQVACAACwICgBAABYEJQAAAAsCEoAAAAWBCUAAACLWAmwkydPyksvvSTLli2Tw4cPS7NmzeTuu++WK6+80uv22dnZ0r59e/N7nh566CEZMmRIBbUaAABEgoAHpWnTpsnatWtlxowZ0rRpU1m+fLkJSm+88YYJRAXt3LlTsrKy5Msvv5QaNWq4b4+JianglgMAgHAX0KG3nJwcee+99+Suu+6Stm3bisvlkptuukk6duwoixYt8vo7W7ZskZo1a8ppp50msbGx7p+oqKgKbz8AAAhvAe1R0l6g9evXF+oNiouLk6NHj3r9na1bt0rLli0rqIUAACCSBXzoTXuDPCUnJ5thtQceeMAalNLS0mTAgAGybds2adCggQwfPlx69+5dhjZQ0x6JoqOj3Jf8DQCRhc8/QiYoeTp16pQJSC1atJAbb7zRGpR0iG7KlClm+E1rmvR3tFfq2muv9enDkpQU74fWI9SkpFQxl/HxVfgbACIMn3+EXFDSeqWxY8eaHqU333xTKleu7HU7DUbR0dHumqSBAwfKxo0bZc6cOT4FpdzcPElLO1bm9iP0ZGaecF+mpmYGujkAKhCf/8jmclWVmJjo0AlK2pN0//33y+7du2XevHlSq1Yt67beZrfpkgIalnyVnZ3r8+8idGlIdi75GwAiC59/lFTAi3NOnDhhlgPQNZS0J6mokJSRkSFt2rQxay552rRpEwXeAADA7wLeozRmzBg5cOCALFy4UKpWrVrktgkJCdK9e3d57rnnTDBq1KiRWUZg9erVZt0lAACAsAlK3333nXzyySem5ujCCy/Md1+HDh1k7ty5JgA99dRT8s0330hiYqI8/vjj8uyzz8rQoUMlNTXVBKYXX3zR6+KUAAAAIRuU2rVrJ7/++qvX+5xi7T//+c8yaNAg9zIC1apVk/Hjx5sfAACAsA1KGoYKrqPkyzYAAABhWcwNAAAQrAhKAAAAFgQlAAAAC4ISAACABUEJAADAgqAEAABgQVACAACwICgBAABYEJQAAAAsCEoAAAAWBCUAAAALghIAAIAFQQkAAMCCoAQAAGBBUAIAALAgKAEAAFgQlAAAACwISgAAABYEJQAAAAuCEgAAgAVBCQAAwIKgBAAAYEFQAgAAsCAoAQAAWMTa7gBC3d69eyQ9Pc16f3LyATl27Jhs27ZV0tMzitxXYqJLGjZsVA6tBAAEM4ISwlJqaqr06dNdcnNzi9129OhRxW4TExMjq1atlaSkJD+1EAAQCghKCEsaaJYsWVFkj1JMTLRER+dIbm6M5OTkFtujREgCgMhDUELYKm6oLDY2WpKS4iU1NVOys4vveQIARB6KuQEAACwISgAAABYEJQAAAAuCEgAAgAVBCQAAwIKgBAAAYEFQAgAAsCAoAQAAWBCUAAAALAhKAAAAFgQlAAAAC4ISAACABUEJAADAIlaCQEZGhqxbt04OHz4szZo1kw4dOhS5fXZ2tnzxxReSnJws55xzjrRp06bC2goAACJHwIPSzz//LHfccYe0aNFCmjRpIi+99JI0bdpU/vGPf0jlypULbZ+eni5DhgyR3NxcadWqlUyfPl0GDBggY8eODUj7AQBA+Ap4UHr00Uele/fuMmnSJHP96NGj0rNnT5kzZ44JUAVpkIqOjpa3337bBKlffvlF+vfvb/bRtm3bADwDAAAQrgJao6RDaDrMNnDgQPdt1atXN7f9+OOPXn9n2bJl0q9fP3dv07nnnivnn3++LF++vMLaDQAAIkNAe5RiY2Nl3LhxhW7fvn27196hI0eOmLokHabzpHVNv/32W7m2FQAARJ6AD7156zHatm2bTJkypdB9OiynEhMT892u1537fBEby+S/SBQTE53vEkDkiI6Ocl9yDEDIBCUt7J4wYYIpzNYhtYK0gFtpjZKnqKj//cH7Qj8kSUnxPv8+Qp/LVTXQTQBQwVJSqpjL+PgqHAMQGkFJi7KHDRsmd955p9x2221et3G5XOYyMzMz3+16PSEhwafHzc3Nk7S0Yz79LkKb9iRpSEpLy5KcnP+FcACRITPzhPsyNTX/MQXhz+WqWuLRhKAISt99952MGDFC7rvvPhk8eLB1u1q1akmNGjVk165dctFFF7lv1+tnnHGGz4+fnc1BMpJpSOJvAIgs+iXZueTzj6IEvDhj/fr1pidp4sSJRYYkx1VXXWXqmJxhuD179pig1aVLlwpoLQAAiCQB7VHSWWyjRo2SBg0ayKFDh8zaSY66detKjx495D//+Y8JU4MGDTJLAtxzzz1m3aShQ4fKeeedJ4sXL5Zu3bpJp06dAvlUAABAGApoUEpJSZG+ffuaf+/bt6/Q0gHO6U30PqcHqX79+rJkyRJ5//33JTU1VcaPHy9du3YNQOsBAEC4C2hQ0vWQHn744SK30Vokz3okVbNmTWvBNwAAQNjUKAEAAAQrghIAAIAFQQkAACCY11ECAMCf9u7dI+npadb7k5MPyLFjx2Tbtq2Snp5R5L4SE13SsGEj3qAIFZWXl/e/VbcieLHBw4dZlTUS6fmd9PQ1uiovC84B4UNnRF999aXu2dJlFRMTI6tWrZWkpCS/7A+BV7NmfGitzA0AgL9ooFmyZEWRPUp6kIyOzpHc3JhiT2GkPUqEpMhFUAIAhJ3ihsroUUZJUcwNAABgQVACAACwICgBAABYEJQAAAAsCEoAAAAWBCUAAAALghIAAIAFQQkAAMCCoAQAAGBBUAIAALAgKAEAAFgQlAAAACyi8vLy8iSC6dPPzY3olyCi6RnEiztzOIDwxOc/ckVHR0lUVFSJto34oAQAAGDD0BsAAIAFQQkAAMCCoAQAAGBBUAIAALAgKAEAAFgQlAAAACwISgAAABYEJQAAAAuCEgAAgAVBCQAAwIKgBAAAYEFQAgAAsCAoIWL9+OOP8t5778nGjRsD3RQAAZCTkyPvvPMOrz2KFJWXl5dX9CZAeNE/+QceeEDWrVsn7du3lw0bNki7du3k2WeflZiYmEA3D0AFmT59urz++uvyn//8h9ccVrH2u4DwtGzZMvnss8/MZe3atSU5OVn69u0rixcvlhtuuCHQzQNQzo4fPy7Tpk2Tt956iy9HKBZDb4g4S5culauvvtqEJFWnTh255pprTHACEP569eolX331lQwbNizQTUEIICgh4mzevFlatGiR7za9vmnTpoC1CUDFufPOO+WDDz6Qs88+m5cdxWLoDRHn6NGjUr169Xy3JSQkmNsBhL8bb7wx0E1ACKFHCRE50yUqKirfbdHRfBQAAIVxdEDEcblccuzYsXy3ZWZmml4lAAA8EZQQcZo1aya7d+/Od5teL1i3BAAAQQkRR2e8ffrpp5KVleWeKrxq1Sq56qqrAt00AECQISgh4tx0000SHx8vN998s7zyyisyZMgQqVatmgwaNCjQTQMABBmCEiJOXFycLFiwQPr16yeHDh0yi03qdQ1PACJH48aNZcCAAYFuBoIcpzABAACwoEcJAADAgqAEAABgQVACAACwICgBAABYEJQAAAAsCEoAAAAWBCUAAACLWNsdABDMtm3bJt9//72kpqZK7dq15cILLzQLCDpyc3PlxRdflE6dOkn79u0D2lYAoYseJQAhZf/+/ea0MwMHDpSNGzfK0aNH5ZNPPpFrr71WHnroITl58qQ7KM2cOVO+++67QDcZQAijRwlAyEhJSZH+/ftL8+bNZfXq1ZKQkOC+T0PT7bffLtnZ2TJ9+vSAthNA+CAoAQgZf//73yUzM1OeffbZfCFJ6fCa9jKtWLHCBKrq1at73ceRI0fkiy++MD1TVapUkQsuuEDatm2bb5t169bJ5s2bTehq2bKlXHrppVKpUqVSbwMg9DH0BiAkZGVlyUcffSRXXnml1KxZ0+s2DzzwgKxZs0Zq1arl9X4NSF26dJHly5dLRkaG/PDDDyZcPf300+b+nJwcGTlypDz44IMmSGngevLJJ6VPnz5m+5JuAyB80KMEICTs3bvXhKWzzjrLuk1MTIz1Pg0448ePl549e8pjjz3mvv3555+X1157Te6880758ccf5dNPP5V33nnH3cs0dOhQmT9/viQnJ5terG+++abYbQCED4ISgJCgRdvK1yCiv6/1Tb169TLXtfdnx44dplfo+PHjcvDgQTMUpxYvXizNmjWTxMREOe200+See+5x76ck2wAIHwQlACEhKSnJXKalpfn0+zpcpzPjdCac9gppMGrQoIH5cXqcdImBW2+9Vd58801ZuHChuX755ZebcFWnTh2zXUm2ARA+qFECEBJ0jSSXyyW//vqrdZudO3eaILR79+5C9/3xxx8yePBg2b59u0yaNEnWrl1rhtD69euXb7tx48bJ559/Lk888YTpKXr55Zela9eu8vXXX5dqGwDhgaAEICTojLIePXqYgmwtoPZG64ZeeOEFU8tUkBaC6+KUU6ZMMQXdukilOnDgQKFttRj8uuuukxkzZsiqVaskPj5e5s2bV+ptAIQ+ghKAkHHfffdJ5cqV5f777y80w+yzzz6TOXPmSN++feXMM88s9LtObZPn0J0Gp0WLFpl/nzp1yqzFpKt5O4tWKn28vLw8d7AqyTYAwkdUnn66ASBE6NDZmDFjzAyzq666ytQu/fbbb2Zdo+uvv14mTpxoep90faNzzjnHhKo77rjDrL80YMAA0xvVu3dvc//HH38sTZs2lfXr18srr7xiAtbNN98s1apVM+siRUVFmSE2rV+aO3euqUHSHqjitgEQPghKAEKSnudty5YtZjabhhMtqm7YsGGR53rTXiANR/v27TO9P+eff76pfdIaI1148pJLLjEz4LR+ac+ePaaXSVcB12Jt7TVylGQbAOGBoAQAAGBBjRIAAIAFQQkAAMCCoAQAAGBBUAIAALAgKAEAAFgQlAAAACwISgAAABYEJQAAAAuCEgAAgAVBCQAAwIKgBAAAYEFQAgAAEO/+H1tru88LoBkEAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk4AAAHTCAYAAADRSZf1AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAR5hJREFUeJzt3Qd4VGX69/E7hVASAgkl9I5KUYrSEQsiVaSIiIgoqHGVIqIIghJWsOyKCssKCriioiAWQBBBRBHEAAroqkEQpYeIJJBCTXmv+9l35p+EITmZTDKZOd/PdXFNZs7JyZNJhvnlKfcTkJWVlSUAAADIV2D+pwAAAIDgBAAAUAD0OAEAAFhEcAIAALCI4AQAAGARwQkAAMAighMAAIBFBCcAAACLgq2eCCB/iYmJcvr06RyPBQQESPny5SU8PLxEPoUJCQmSmZkp1atX93ZTbOfChQvm+Q8LC5OKFSvmee6ff/4p6enpUqNGDfEG/R05ceKElC1b1rTXFX6XYAcBVA4HPOexxx6TTz75xOWxSpUqya233ipjxowxbz4lRZ8+feT48eOydetWtz5/8+bNUrlyZbniiis83jZ/t2fPHrnlllvk7rvvlsmTJ+d57oABA+SPP/6QnTt3FmtYWrFihSxdulR++uknE/RU/fr15c4775ShQ4dKUFCQx36XAF/AUB1QBDRI1KxZ0/yLioqS0NBQ89f6G2+8IePGjfOb53zZsmUycuRI0xsC/3Lq1Cm5//77ZeLEiSasZWRkmN/rUqVKmQA3Y8YMGT9+vLBrF+yGoTqgCLz00kvSrl27HI/t3r1bHnzwQfnyyy9lx44d0rp1a59/7pOSkrzdBBSRJ554wvQm1qlTxwSkrl27mtCkAWr9+vUSExMja9askcsvv1z+9re/8XOAbdDjBBQTHcrSoQ31888/uzznzJkzZp7I+fPnXc6fOnz4sOkJuNSx1NRUc197gPQ6DidPnpRz584VuM15tUeHZBxt0d40/foF6X3QtqakpDjvHz161HwfDvp19WsonTfm6vvOr42O68THx1/0uA47aZv1uXFw93nTc/RzL9WG7PR7zj0Pzt3QmpaWdtHj+pzp96XzoVwNvekx/XnlRYORBvxq1arJu+++Kz169DChSenQXPfu3WX+/PkSGBgoixYtsvQc6fesz232n7kr+jv0119/OX+XC3se4GkEJ6AYOf6T1/lO2f3www8ybNgw0wvVpUsXufrqq81cKH2Tc/j111/NX/2DBw/O8aaob+49e/Y086cc19eerQceeMCEkdtvv930frVo0cLMpdF5Nfmx0p5HH31UFixYYD7W4Rxtm5VA8M0330jfvn3NNa+55hqJjo42gUkf014MB22/fs3PPvtMOnbsKG3btpUpU6YUqI1KhxL79et3UTt0uEnbPHv2bOdjBX3efvvtNzOcpW249tprTRseeeSRHOHLYePGjWY+k37Pev6kSZPcCrN67SFDhkj79u3N18vdtoULF5rvS8NPbjr3SI+99957eX4NndekHn74YalSpYrLc5o3b26ODx8+3GWAc9Cv1bt3b2nVqpX5Oen3f9NNN5lh3uw0UGnPlp7XqVMn873pnCnt1XLnPKCoEJyAIqB/CesbuP47dOiQGaZ78803zV/n+lf8DTfc4Dw3NjbW9ERt27bN/BWtq6u052Lt2rUyaNAgZxDo0KGDeTPXN3ydrJt9WFDDk4YXvbaDhisNJRowHCv69I3zrrvukoMHD16y7Vbbo/NdHNfVIKjzubQHIi869KPBREOg9mDo6qyvvvpKHnroIdMb4qpXRcOSXrdq1aomPBWkje6w+rzp96Ah9uuvv3Y+H/q5+gZ+xx135Og909Ckw1kacPT7LleunHz00UdmnlBB6HOk4U6HeitUqJCjbUeOHHFOIlerVq266PM1hCoNGnnRa+pqUA04eRk1apT5viIjI10ef/XVV00Y1oCpPyMNYcHBweY1oT/XH3/80XmuBk5tsz6H+rPWlah79+41cwK//fbbAp8HFBWCE1AEtDdG/7LXf/rmo71Bzz33nJkorj0CjlV1+kb49NNPm2EjXaX03XffmTctfaPVHgx9850+fXqOeSdaNuBf//qXJCcny3//+1/zl7v+5a2BITt9s9KeAA1Z27dvly1btpjApkNer7zyist2F6Q9L7/8sultUc8//7xs2LAhz9WCGnCeeeYZ84anb7b65q/Xf/31100YdNVroY9rb5MGpU2bNpleqYI+ZwVl9XmbOnWq6WHTn4l+L9qT9v3335tgoz1W+vw4PPvss2ZukPaI6bl63ty5c2Xfvn0FatvZs2fN1/z4449NaNS2XX/99aZts2bNMudcdtll0qxZM/N86O+Ig379zz//XK688kqpV69enl9Dr6dh+FKByAr9OTm+ngZa/RlpcNZ2a4+ZcvQSaZDSY507dzbn6c9af64avLT8giOcWj0PKEoEJ6CIV9Xpf+iOGj3aE/LWW285l3XrEu8DBw6YYQcNA476ONpzpG/S+he6vgE65oXo8WnTppmeGP0LW3tqNKxoIHFFw1rLli3Nx/om+OKLL5pbnb/iaj5OQdtTEHrt/fv3m54z7TUICQkxvRrXXXedKeNwKRqy9NziaKPV501/jrrSTEPdzTff7JxXpKFNA2zjxo3l008/NeFBexv1+9ZhPx3acnzfN954ownYBfXCCy9I06ZNnW375z//aXqfNKRoOFL9+/d39sA5aGDRuU359TY5hlvLlCkjhaG9hBrwPvjggxxBTVeYOnrFHEPLjt5G7dHTXiPHogP9w0MDuYbTgpwHFCVW1QHFtKru2LFj5g1ZezJ0uELf9LV3Q2l40DfT7DQQ6NDU6tWrTc/LVVdd5TxX3xj1TUnpUIgGtNw0rOVug15TA4G+yWivSO6eB3faY5UGCKXzXHLLPnSZnbZBQ0hxtdHq8+Zog/Z+6Jv2peikdMe5Ghhzc/Vc5Nc2R6Bz0OFE7dXRtmjbateubcKRBiytKeboidTeHQ0zOt8ov6+hE8CzT5ovDJ3HpT1Dv//+uwm8OlwZFxeXIwjVrVvXzCXT4VENl46eM+2t1d91XdlXkPOAokSPE1BMtEdE38x0Tsb7779v3lB0RZiryeIOjqGS3L1D2d889Y3DlUtN6o2IiDC3jq+dnbvtscLRA+SYm5O7TblDkNLeNA2ZRdFGV3OqrD5vjl4Z/V4cPYuu/unP2DEE6aoyuKvnIi+X+p4d13ZMNte2ahjVoUadTO4oIaATyi/1/TlouNLwpb1B2lOWFx1C1aFiV5PhlX5N7VnTkDNz5kzT+6TzmrIXzXSYN2+eDBw40DncqwFLh+B69eolH374YYHPA4oKwQkoRjr8oQHKsdWGY/KxY2Jvbo5Jzo43baWfp0NHjuErrTjtanXWpd7MtFdCuZq/4k57rHKEBFelAbStVksZFLSNGsgcQ6PZZZ+8nbst+T1vGn6VrpLTXqhL/WvQoIHzeXZ8fu5eyIK4VBkBVz9T7YHRcLhu3TrLw3QOOm8q++q6S9G5djrJW+cZ5abDl7r6TYfT9Hl66qmnzHw2naD+zjvvXHS+tl3ngukQnM7/GjFihJmrpT877al1/AytngcUFYITUIw0NOhf8foXt74B6JJuxxtU7h4gncehE471TVp7ABz0jUp7b3Q5u06W1iEpfQPLTScG65yc7PRcfZPTIQ2dqJ6bO+2xytFL5lgRlZ2uMLOqoG3UgKm9Po6aUA65n5uCPG/6Rq2BTOcQuRrScsx50p4eHS7Uc3XYTCdeZ5dfMMlNv5ZOCM9OV/fp0JV+v9mDkw4D6ly7L774wnwdfR50PpYVt912m/kd1Ur3OpHdlcWLF5vnRAOq9irlpmFNv19deahBX1f+6fCqbtfimBTumJOlv8/6fOn52pOk19P5Svp7oc+fHtefi9XzgKJEcAKKuByB/tO5HfpmoTWF9C9iXRWk82b0TUTn5Gig0jcWfcPWpdX6Jqv1cXS4SWsQOXqXdKhDVw7pHBxdmaS9TfrmqG9wusIuNy1RoMOCOpyR/evrcnlXCtoexzCaDtnkV0W8YcOG0qZNGxNCdLm/fo7OdZkzZ44ZfrGqoG3UXh+lvR+7du0yc630jTyvYZ38njddBq9v2hqQtJaU9qLoCjkdhtIJ6hoQdOK+Dntp0NJhM23vPffcY4Kdft+6Ck4XChSEPt/6fSxfvtx8PQ2hurJRA4iuMMx9rvb0aLjR70Hb4Ogpy4/OK9PvSwOKPqe6SlFXsenX1PlK2gbHgoTHH3/c5WpKR4jT31ctOaE/d+0lGjt2rFlZqhxDnvq86Vyx++67z8zV0nP1udfyHfrz0udQr2f1PKAosckvUEyb/Gafp6LVmB0Ts3WJtRYxdDWUo4US9U1G6/7osI4Oteib5MqVK509KrqaSuvp6Fwn/ctb6wTpqiUNE7rqS9+0stMl+zrE4agEnXtjVqvtUdrjokvsHW/UGmI0VFyKvvHqG3zuXhrt3dDvS+epOJbxawkH7UFytaltQdqoYUkDVu4hHH3j1+EjrQelE/VVQZ43rRSu4cLVPCAdltQ26KRtpT87bYO2OzsNkK+99prlTX41FOrPXYcBs9PeJQ2fuecOOTYRVtorabXHSekwn67gXLJkicvjGgp1daR+Dw7Zf5e0rVp3zDERPDv9XdFeR/2d1deLfi0Nmq56AfXraBjVauVWzwOKEqvqAA/Sv3ZdrXArXbq0+WtYe1y0pyj7X8X6Rqgr5PSvZu2N0Bo6WsJA3wB0EqzjjVrftHV+jxaQzD5U1q1bNzO0on/Nay9K9t4k7dXQIKJ/neuQigYTfTPLPuFa2+X4GgVpj9LVTPrXv4YM/R713LyCk/Y6aRs1LGig0Wvp0np9w9Wejew9F3odV9uGFLSNOkSoc2q0V06DhE6O1qCiz5uGDVeTtq08b9o+/V702lr+QOdM6c9Vv54GKm2Pg85r0x4sDVP6c9L5XNorpm3VXiMrk8T162n403bpqk3HkKRWjdfw52rCtfYc6e+Mfj3HvCWrNIhocNLvW9uuq+I0LGog1WEx/T3WbYSyy/67pD1+WvRVf9Y63KfDpfo86FCrrvTTOlgaOnUSuva+agV3Df76h4DOM9PhTb2+PpeO1ZHaJivnAUWJHifADzl6TlwN33mL9ijpcJXW8ck9uVyHc3TISXuvHMvMvaEkPm+FofOh7r33XhNysm9nA8B99DgBKBY6kVt7eXSo8sknn5TLL7/c9IRoQUvtQdGeg4LWNYLrgKoTxrWHR7d00edVhwkBeAbBCUCx0OEYHZ7SYRatep6bDkE65gTBfTqcpcNrjjld2ovWqFEjnlLAQwhOgB/S+TB57VjvLdoDoisKdV6Po96SrpLTuT66Es3bSurzVhDaw6RzvXRStk5y11VvADyHOU4AAAAWUccJAADAIoITAACARQQnAAAAiwhOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACwiOAEAAFhEcAIAALCI4AQAAGARwQkAAMAighMAAIBFwVZPtIusrCzJzMzydjPgJYGBAfz8AZvi9W/vn31AQIClcwlOuWhoSkxMK4qfC0q44OBAiYgIleTk05Kenunt5gAoRrz+7S0yMlSCgqwFJ4bqAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACwiOAEAAFjElisAAFvLyMiQ2NjNkpp6UsLCKkqbNh0kKCjI281CCUVwAgDY1qpVKyUmZrIcPHjA+VidOnUlJmaG9OnT16ttQ8nEUB0AwLahaeTIYdKkSVNZu3aDpKSkmFu9r4/rcSC3gKysrKyLHrWxjIxMSUxM83Yz4MXd0ZOS0iQ9PZOfAeDnw3Pt2rU0IWnRovckJCTY+fo/fz5dhg8fInFxcbJ1606G7WwgMjJUgoKs9SXR4wQAsJ3Y2C1meG7s2PESGJjzrVDvjxnzqBw8uN+cB2RHcAIA2E5CwjFze8UVTV0e156o7OcBDgQnAIDtREVVM7e7d//i8nhc3C85zgMcCE4AANtp376jWT03a9ZMyczMOadR78+e/ZLUqVPPnAdkR3ACANiO1mnSkgPr1n1mJoJv27bVrKrTW72vj8fETGdiOC7CqrpcWFVnX6yqA+zHdR2neiY0UcfJPiILsKqO4JQLwcm+CE6AfUsTbN/+LZXDbSyyAMGJyuEAALH7sF3nzl2o4wZLmOMEAABgEcEJAADAIoITAACARQQnAAAAiwhOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACwiOAEAAFhEcAIAALCI4AQAAGARwQkAAMAighMAAIBFwVICvPvuu3L+/Pkcj7Vt21aaNm1qPk5PT5dNmzZJQkKCNGvWTK688soc5+Z3HAAAwC+C06lTp2TatGkycOBACQ0NdT6emppqblNSUuTuu++WzMxMueyyy+TFF1+UwYMHy+OPP27pOAAAgN8Epz179khwcLAJT6VKlbro+KuvviqBgYGydOlSCQkJkZ9++kluv/126d69u1x11VX5HgcAAPCbOU4anOrUqeMyNKnVq1dLv379TChSzZs3l5YtW8qnn35q6TgAAIDf9Djt3btXGjZsKN9//73s27dPatasKe3bt5egoCA5efKkmbekx7OrX7++/Prrr/keBwAA8Lvg9MMPP5jJ4ZUrV5Y5c+ZI1apVZeHChWb+kypfvnyOz9H7eiy/4+4KDvZ6Rxy8ICgoMMctAPvg9Q+fCU7auzR06FDp1auXuZ+cnGyG3nSS94gRI8xjOocpu4CAAHOrE8LzOu6OwMAAiYj4v0nqsJ/w8LLebgIAL+H1jxIfnEaPHp3jfnh4uPTu3VvWrFkjjzzyiHksLS0txzl6PywszJyb13F3ZGZmSXLyabc+F77/F6f+p5mcfEYyMv4XygHYA69/ewsPL2t5tMGrwUkDzrJly8wKuOrVqzsfz8jIMJO9K1WqJBUrVpQDBw6Yuk4Oer9x48b5HndXejpvmnamoYnfAcCeeP0jP16dzFGuXDmZP3++vPXWW87HTp8+LWvXrpXrrrvO3L/xxhvNyjnHsNyhQ4dkx44dctNNN1k6DgAA4CkBWVlZWeJF69evl/Hjx0uPHj2kdu3apoyA9ja9/fbbZpL30aNHTV0m7UFq0aKFLF++XK6++mqZOXOm+fz8jrvz10ZiYs6hP9iDLgrQ+W1JSWn0OAE2w+vf3iIjQy0P1Xk9ODl6iTRAnThxwgSgnj17OusyqcTERFmxYoUkJSWZOk3dunXLMQE8v+MFQXCyL/7jBOyL17+9RfpacCpJCE72xX+cgH3x+re3yAIEJwrWAAAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAAAQnAAAAz6LHCQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACwiOAEAAFhEcAIAALCI4AQAAGARwQkAAMAighMAAIBFBCcAAACLCE4AAAAWEZwAAAAsIjgBAABYRHACAACwiOAEAABgEcEJAADAIoITAACARQQnAAAAiwhOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAgOIKTqmpqfLHH3/IhQsXJD09vbCXAwAA8L/g9Msvv8hdd90lbdq0kR49esjRo0dl8ODBMm/ePM+2EAAAwJeD0759+0xoSklJkejoaImIiDCPd+zYUebMmSOvv/66p9sJAADgm8FJg9FNN90ky5cvl0ceeUTKly9vHh8/frz8+9//lgULFni6nQAAAL4ZnH7++We55557JCAg4KJj1113nQQHB8vx48c90T4AAADfDk6lS5eWhIQEl8fOnDkjycnJEhISUti2AQAA+H5w6tSpkzz33HNmrlN258+fl7///e/SqFEjqVChgqfaCAAAUCIEZGVlZRX0k7RH6fbbb5dDhw5JkyZNTIBq3bq17N27VxITE2XhwoXSrl078UUZGZmSmJjm7WbAC4KDAyUiIlSSktIkPT2TnwFgI7z+7S0yMlSCggKLrscpPDxc3n//fbn33nvl7NmzUqpUKfntt9+kZcuWsnTpUp8NTQAAAB7vcfJn9DjZF39xAvbF69/eIou6x8mVkydPyo4dOyQtjWEuAADgnwLd3Wbl4YcflsOHD5v7cXFx0rVrVxkyZIi5/emnnzzdTgAAAN8MTvPnzzdhqVy5cub+3LlzzSq6WbNmmerh06ZN83Q7AQAAvC7YnU/aunWrTJ06VSIjI83mvps2bZJx48aZPetuuOEGMzlcV97pJPKC+uyzz+SKK66QevXqOR/TaVjbtm0ztaOaNWsmDRs2zPE5+R0HAOBSMjIyJDZ2s6SmnpSwsIrSpk0HCQoK4gmD53qcNBTVqlXLfPz999/L6dOnTWByFMesWLGiW3Od1q5dK2PHjjVzpRz02nfeeac8/fTT5vhtt91mtnWxehwAgEtZtWqltGvXUvr27WXeS/RW7+vjgMeCU1RUlOzZs8d8/Mknn0idOnWkdu3aziBz4sQJ58a/VmlvkfZi5d7GZd68eeaaK1ascO6DpxsJ61ChleMAALii4WjkyGHSpElTWbt2g9m4Xm/1vj5OeILHglOvXr3kqaeekpEjR8qHH34o/fr1cx575plnzHBZmTJlLF9Ph9qefPJJueWWW6Rs2bI5jmkw69+/v/N6V199tbRo0UJWrVpl6TgAAK6G52JiJsvNN/eQRYvekzZt2kpYWJi51fv6eEzMFHMeUOjgNGjQIImOjjar64YPHy7333+/89ixY8ckJiamQNd7++23TY/TY489luPxU6dOydGjR6Vx48Y5Hm/QoIHpUcrvOAAArsTGbpGDBw/I2LHjJTAw51uh3h8z5lE5eHC/OQ8o9ORwpWEpe2ByeOONN0xCT09Pl+Dg/C+vFcdnz55twpPOj8pOg5HKPclc7+/evTvf44UphAb7cRQ/s1oEDYDv+uuv/21U37x5c/N/fu7Xvz7uOI/3BHgkOH311VeyZs0aMwk8MzPTOeSmW7BoaFmyZInUrVs3z2vopsDay6S9V7rnXW4avlTuvwZ0HpR+rfyOuyMwMMDsVwb7Cg/POVwMwP80alTf3B458oe0b9/+otf/7t0/Os/jPQGFDk4rV66Uxx9/XGrWrCnHjx+X6tWrmxATHx9vQlTPnj1NqYL8aO+UDrVpD9GyZcvMY3qd7du3m7HmVq1amcd08nd2Gtb0ePny5fM87o7MzCxJTs55PdiD/qWp/2kmJ58xW+8A8F/Nm7eWOnXqyrRpz8g77yyRUqWCna//CxfS5e9/ny5169Yz5+nG3/Bv4eFlLY82uBWcli9fLg8++KCp3aQVxLVa+IABA8xquokTJ0rlypWdoSa/1XndunWTH3/8X7JXGrwOHTpkeq1uvvlmE6oOHjwobdq0cZ6jxxs1aiRVqlTJ87i70tN507QzDU38DgD+LkBiYmaY1XNDhw6WceMek44d28i3326Xl19+Udat+0wWLnxbsrIC+P8AObg1mUMngHfv3t18rCvoYmNjzceVKlWS559/3gzhWaGr4WbMmJHjX0hIiAlhY8aMMedcf/31pihm9q+tdZ4cdaPyOw4AgCt9+vQ14Sgu7hfp0aOr+UNcb3VxkT6uxwGP9DhpyQDH/CJdwaZDdw4anrTialJSUoFrObmiAUqLWj700EPSsmVL+eCDD+Taa6+VLl26WDoOAMClaDjq2bO3bN/+LZXDUXQ9Tjr3aNGiRWZyt5YC2L9/v7Mgps5z0iE7d8vVay9U9u1WtLCmFrds2rSp/PnnnyYg6Z54Vo8DAJAXfb/q3LmL2aheb9luBXkJyHJj+ZlO6B44cKApO6AFKLXXR8NT27ZtZefOnVKtWjXT8+Or81sSE5kIaEe65FhXz+hEUOY4AfbC69/eIiNDLU8Od6vHqUaNGqaXR9O5lgLQOkxa80I3/9UNdmfOnOnOZQEAAPyvx8mf0eNkX/zFCdgXr397iyxAj5PbBTA3btwoq1evluTkZJfFJnXPuqpVq7p7eQAAgBLH7TpOTzzxhJnLpLWUclfuVo5q4gAAALYOTjrxe+TIkTJhwgTPtwgAAKCEcmtyuNZouvXWWz3fGgAAAH8LTlr0ct++fZ5vDQAAgL8N1UVHR8v48eMlNDRUWrRoYSqJ56ZbpwQEBHiijQAAAL4bnJ599lmzJ9wDDzxwyXPWrVsndevWLUzbAAAAfD846bYoXbt2zfMcT+xTBwAA4PPBadCgQZ5vCQAAgL8EpzNnzkiZMmXMvCX9OL86TeXKlWOOEwAAsGdw6tu3ryxYsMDMW9KPDx48mOf5zHECAAC2DU46Edwxb0k/1q1W8sIcJwAA4G/Y5DcXNvm1p4yMDNm+/VtJTT0pYWEVpU2bDhIUFOTtZgEoJmzya2+RxbHJ7++//y7btm0zVcRdbfI7dOhQqVChgruXB4rNqlUrJSZmshw8eMD5WJ06dSUmZob06dOXnwQAoHDBaf369TJ27FhJT0+/5Dm9e/cmOMEnQtPIkcOkW7fuMmrUWKlcuaL89ddJWb9+nXl84cK3CU8AgMIN1d19990SFRUlkydPlooVK4o/YajOXsNz7dq1lMjISDlx4oQcOvR/Cx5q164jlSpVksTEJNm6dSfDdoCfY6jO3iILMFTn9ia/w4cP97vQBHuJjd1ihud27dopTZs2k7VrN0hKSoq51fv6+MGD+815AAC4HZyuvPJK+fnnn3kG4dPi44+a265du8miRe9JmzZtJSwszNzqfX08+3kAALg1x2n06NGmx+nIkSPSvHlzUxgztzZt2rjc/BcoKU6c+Mvc9u59iwQG5vwbQu/37NlHvvjic+d5AAAEu7uiLiEhQV577bVLnkMBTJR0lSpVNrerV38id955d44OWK2Mv2bNqhznAQDgVnDSCuJNmzaV++67z0ygdaV69eo8uyjRqlevYW43bFgvw4cPkXHjHpOOHdvItm3b5eWXXzSPZz8PAAC3VtX16tVL/vGPf5hhOn/Dqjr7yGtVndZx0sdZVQfYA6vq7C2yqAtg1q5dW/788093PhUoMbQyuBa5dFXHSec2ff75WlPHiQriAIBCBacRI0aYGk4BAQHSokULKVeunPk4u5CQkIseA0oarQyu4Ugrh69b95nz8Tp16lH8EgDgmaG6YcOGya5du+T8+fN+NzmcoTp7Yq86wN4YqrO3yKIequvbt69cf/31eZ4TERHhzqUBr9DhuM6du0hERKgkJaVJenomPwkAgGd6nPLj2MMuONjtPYS9hh4ne6LHCbAvXv+ILOoeJ/XVV1/JmjVrJC0tzdS8UZrBzp49K7t375YlS5b45FAd7LnRr85x0u1Xsq+q04njOgcKgP/i9Y9i2XJl5cqVEh0dLdu3b5eNGzfKb7/9ZsKShqktW7ZIu3btzFJuwBf+09RVdU2aNM2xV53e18f1OAD/xOsfxTZUp6vqdL+6cePGycMPPyxdu3aVAQMGmFo4EydOND1NU6ZMEV/EUJ396jhpSNK96UJCgp1znM6fTzdFMePi4mTr1p2UJAD8DK9/uDtU51aP07Fjx6R79+7m42bNmklsbKz5WKuIP//882YIDyjpYmO3mOG5sWPHu9yrbsyYR+Xgwf3mPAD+hdc/3OVWcNLNex0TwBs0aCA//vij85iGJ12hlJSU5HajgOKQkHDM3F5xRVOXx7UnKvt5APwHr38Ua3Bq1aqVLFq0yNRxaty4sezfv1/27NljjsXHx5shO6oto6SLiqpmbnfv/sV022/e/LW899575lbvx8X9kuM8AP75+neF1z88Osfp6NGjMnDgQPPm8sknn8iYMWNMeGrbtq3s3LlTqlWrJh988IH4IuY42Udee9XVrl3H9J6yVx3gn5jjhGKd41SjRg1ZsWKFDBkyxMwFmT17ttnwd+vWrdKwYUOZOXOmO5cFipX2it5ySz/ZtWunKaPx8sv/Mn8U6K3e18dvueVWek8BP96rUrda0oUg27ZtNatq9Vbv6+MxMdN5/aN4CmD6Mnqc7CPvHqe6UqlSJD1OgC3rONUzoYk6bvYRWYAeJ48Fp5MnT8rvv/8ul19+uYSGhoqvIjjZxzffbJL+/XvLp5+ul1atrpbt27+V1NSTEhZWUdq06SA7dnwnvXt3k48/Xi2dOl3r7eYCKCJUDkdkUVcOT01NlSeeeEImTZoktWrVMrVu7rrrLvO47lG3YMECM3QH+MqqGld71bGqDrAH9qpEQbg1x2n+/PkmLJUrV87cnzt3rlSoUEFmzZolHTt2lGnTprlzWaBYsaoGAFAswUkngU+dOtXMDblw4YJs2rRJ7rnnHunRo4c899xzsnfvXklOTnbn0kCxad++o9mTbtasmc79Fh30/uzZL5m5DnoeAABuBycNRTpEp77//ns5ffq03HDDDeZ+6dKlpWLFimbzX6AkY1UNAKBYglNUVJSz4KXWcapTp47Url3b3NcQpSuUdK4TUNLpqpmFC982xe569Ogq4eHh5laHovVxVtUAAAo9ObxXr17y1FNPmSKX33zzjYwePdp57JlnnjH715UpU8adSwPFTsNRz569L1pVR/V7AIBHgtOgQYNM+YH169fL8OHD5f7778+xAXBMTIw7lwW8hlU1AACvFMDUywUEBIivoo6TfQUHB+YoRwDAPnj921tkUddxUhs3bpTVq1ebieKuspcO2VWtWtXdywMAAJQ4bgWn5cuXmwKYuplvlSpVzH51ueVe3p0XPfenn36SpKQkueqqq1xOLNfJugkJCdKkSRMzOb2gxwEAALwSnHRS+MiRI2XChAmFboCGJZ0jpZsrahD78ccfTY2ofv36mePnz5+Xhx9+WH799VepW7eu/Pe//5VHH31U7r77bkvHAQAAvBqcNOzceuutHmnA888/b6qOL1261EzQ/fDDD2XKlCnSqVMn05v1+uuvy+HDh+XTTz+VsLAw2bx5szzwwAOmQnmjRo3yPQ4AAODVOk4NGjSQffv2eaYBgYESHR3tXPp98803m2rk2vPkGBa87bbbTChSnTt3lqZNm5r6UVaOAwAAeLXHSYPO+PHjJTQ0VFq0aCFly5a96JyQkBBLq+t0i5bsdMhN1axZ0wzfHTp0SC677LIc5zRu3NjMicrvOAAAgNeD07PPPmvqNemQ2KWsW7fOzDmy6sCBA/LFF1/IG2+8ISNGjJArrrjChCKlQ3nZaXVnDVhaSyqv44VZlgr7cSxFtbokFYD/4PWPIg1O/fv3l65du+Z5TkG3XNEtXOLj400I+v333yUxMdFM/Fa5Kzjr8J6WQMjvuDsCAwNMLR/YV3j4xT2oAOyB1z+KrHJ4XtLT0wt8zW7dupl/GoY0mL3wwgtmOFCdOXMmx7l6X+c0lS9fPs/j7sjMzJLk5NNufS58/y9O/U8zOfmMKYQKwD54/dtbeHjZoi+A+dVXX8maNWskLS3NWbNJe3nOnj0ru3fvliVLluQ7VKcBRwtpdujQwTncpnOj2rVrJ9u3bzer6nQela6au+aaa5yfp0N49evXz/e4u6gabW8amvgdAOyJ1z/y49ZkjpUrV5oJ4hpuNPj89ttvJixpmNqyZYsJPpGRkfleR0PS008/bUoR/N8vbYbs2rXLrNzTyeVdunQxe+I56BDejh07zOP5HQcAACgRlcMffPBBGTdunCk+qfOdBgwYICdOnJCJEydK5cqVncNoedG5SU8++aTZFFh7qnQlnW7joteZNWuWOWf06NFmaFArlbdq1UoWL15sbh1zrPI7DgAA4NUeJ11R1717d/Nxs2bNJDY21nxcqVIlU9BSh/Cs0grhb731lhny++677+Taa681xSxr165tjjds2NAUxaxYsaLpSdKQNHfuXGepg/yOAwAAeLXHSes2OSaA65CaDt05aHjSniStLm51ZZ3uT6f/LkXnK02aNMnt4wAAAF7rcdKhsEWLFpkVcFpscv/+/aacgNKSAjrUlrtEAAAAgC17nLRA5cCBA832Jrq1iVYPHzZsmLRt21Z27twpTZo0MUUoAQAAxO49TjVq1JAVK1bIkCFDTLHJ2bNnS/PmzWXr1q1mztHMmTM931IAAAAvC8hyo8S21kmqVauWX07A1hoeiYlp3m4GvEC32tGq8UlJadRxAmyG17+9RUaGWi6A6VaP04QJE8xKOAAAADtxKzidO3dOWrdu7fnWAAAA+Ftw0mKXU6dONVXCExISTGmC3P8AAAD8jVur6tauXStxcXFy7733XvKcdevW5btXHQAAgF8GJ90DTjfi1fpMvXv3NhW+82K1+CUAAIDfrarr1q2bLFiwwO97kVhVZ0+6ufT27d9KaupJCQurKG3adKCIK2AjrKqzt8gCrKpza6gO8CerVq2UmJjJcvDgAedjderUlZiYGdKnT1+vtg0A4AeTwwF/Ck0jRw6TJk2aytq1GyQlJcXc6n19XI8DAODWUN2sWbNM4UsrwsLCTFVxX8NQnb2G59q1a2lC0qJF70lISLCzAOb58+kyfPgQswhi69adDNsBfo6hOnuLLKqhuv79+1s+l1V1KOliY7eY4bl58xZeFPL1/pgxj0rv3t3MeZ065b0YAgBgDwUKTrfddpvlzXvZ5BclXULCMXN7xRVNXR7Xnqjs5wEAUKDg9MADD/j9qjrYR1RUNXO7e/cvcs01bS86Hhf3S47zAADwvUlIgIe0b9/RrJ6bNWumZGZm5jim92fPfknq1KlnzgMAQBGcYFtazFVLDqxb95mZCL5t21azqk5v9b4+HhMznYnhAICCD9UNGjSIeUvwO1qnaeHCt00dpx49ujof154mfZw6TgAAt8oR5KYb+a5YsUI2btwof/75p7zyyivy4YcfSs+ePaVBgwbiqyhHYE9UDgfsjXIE9hZZ1JXDz507J/fdd59s27ZNqlWrZvax08e0BMHChQvN1iytW7d259KA14btOnfu4qzjlJ6ec84TAABuz3F644035NixY/LRRx+ZHicNT2rp0qWmx2n69Ok8uwAAwO+41eP05ZdfypQpU6RZs2Y5Hi9TpoxMnTpV2rVrJ6mpqaZ6OOArQ3WxsZvZ5BcA4PngdPr0aYmIiHB5LCQkREqVKiVpaWkEJ/gENvkFABTpUF2jRo1k8eLFLo99/vnn5rZKlSruXBooVmzyCwAo8lV1P/74owwZMkRatGghvXv3lrlz58qYMWPkjz/+kHfeeUeio6Nl1KhR4otYVWcfbPILwIFVdfYWWYBVdW6XI9iwYYPExMRIQkKC8zEdohs2bJg8/vjjF22a6isITvbxzTebpH//3vLpp+vNliu5/+Pcvn2r2eT3449Xs8kv4OcITvYWWdTlCNSNN94oXbp0kbi4OFPHqVy5ctK0aVOpUKGCu5cEihWb/AIACsqtbiEtQ6BbUwQHB8uVV14pXbt2lQ4dOpjQpJPCX3jhBTOBHPCVTX5dYZNfAIBHgpPOadKil65omPrggw/k1KlT7lwaKDZs8gsAKCjLQ3WTJ0+W9evXm4+Tk5PN3nUBAQEXnXfmzBkpW7asVKpUqcCNAbyxye/IkcPMpr7jxj0mHTu2kW3btsvLL79oNvnV/er0PAAAChScHnroITOPSX388cdmeC53gUudEK6PdevWzdRzAko6NvkFABSEW6vqZsyYYUoOVK5cWfwNq+rsiU1+AXtjVZ29RRZHOYILFy7I999/byaDOy6htzpU9/PPP8uIESMkKipKfA3Byb74jxOwJ/5wQmRRlyPYt2+fDB8+XI4fP+7yeGhoqNx77738JAAAJRpbLqFYVtW9/vrrUrt2bXnrrbdM7Sbd8Pftt9+WJ554QipWrCiTJk2SatX+t9QbAICSiC2X4A63hur69u1rwpHWbtKaTXqJiRMnmmNbt26V6dOnyyeffCK+iKE6+2KoDrAPtlyCu0N1bvU4aVBylBto0KCB/PDDD85j7dq1MzWezp8/786lAQAocrGxW+TgwQMyduz4i7YI0/tjxjwqBw/uN+cBhQ5OdevWlV27djmD0y+//CJnz54199PT083HJ0+edOfSAAAUObZcgrvcmhx+2223yahRo8w+dXqrBS/Hjx8vAwcOlLVr15qCgVWqVHG7UQAAFNeWS7rJd25suQSPlyNYtmyZzJkzx0wQ1/IDEyZMMCUKdMuVZ555RgYMGCC+iDlO9sUcJ8A+mOOEYq/j5JCZmWnGgw8fPiy//vqrXHbZZWbFna8iONkXwQmw56q6m2/u4dxyacuWnFsu6e4C8H+RRR2cPvroI7OtSvny5S86pgUxtSdq9OjRzi1afAnByX8dPnxIUlKSL3lcXzSBgRmSmRlkfg/yUr58uNSq5bt/IADIq45TPYmJmU5ospHIog5OGpoWLFhgJonndu7cOencubOsXLlSqlevLr6G4OSfkpKSpGvXTqaH1BN0Ht/69ZslIiLCI9cD4D1UDkdkUQSnyZMny/r1683HycnJprcpICDgovN0yxWdLL5p0yaf3OiX4GTfHqeEhHiZN2+OPPjgKImKyjv00+ME+BeG6u0tsii2XHnooYecQ28ff/yxdO3aVcLCwnKco3Od9DHtkfLF0AT/lt/QWvnyYeZ3vFGjxlKr1sW9qQAAWA5ONWvWNL1ODtHR0VK5cmWeQQAAYBtuFcDUquDbtm3zfGsAAAD8LTjt2LHD9EB5ik6zOnDggOzcudNs1+LKoUOH5Pvvvzfzq9w5DgAA4JXK4U2aNJENGzbIVVdd5XKCeEEcPXpUxowZI8eOHZMaNWrInj17TGVyHRbUa+sWLk888YSZbK7HNWBNmTLFVClX+R0HAADwanCqU6eO/Pvf/5YVK1ZI/fr1nRv+Zjdx4kRLc6A05Oh57777rplQvm/fPhOcLr/8chk0aJD85z//MZsIf/bZZxIZGWm2dHn00UflmmuuMeUQ8jsOAADg1aE6HVLTUFKmTBmJj4+Xn3766aJ/Og8qP9pbpCvx7rvvPucqvIYNG8q1114rmzdvNvc/+OADuf32200oUt27d5fGjRub0GblOAAAgFd7nBYuXOiZLx4cbApp5vbXX3+Z4pmpqamyf/9+0/uU3RVXXGHCWX7HAQAAvB6clG7oq5OxdYsVRw1NvdUCmLrp74gRIyQqKqrA1/3uu+/MdV9//XVT7Vnlrs5coUIF2bt3b77HC1MIDfYTGBjgvOV3ALAXR/FDq0UQYV9uBSedhzR8+HA5fvy4y+OhoaFy7733Fvi6OkFc5ycNHjxYrrvuOvN1HNtbZKf3tUS+YzjwUsfdoW+aERGhbn0ufNuJE6XNbWhoaX4HAJsKDy/r7SbAH4OT9gbVrl1bZs6cKc8//7wMGDDADJfp8Nhrr70mjz32mFSrVq1A10xISDBhrG3btjJ16lTzmKMy+dmzZ3Ocq71aeiy/4+7IzMyS5OTTbn0ufFta2jnnbVJSmrebA6AYaU+Thqbk5DP5bvIN/6M/e49vuZJdXFycTJo0Sdq1ayft27eXI0eOyLBhw0zoadasmUyfPt2siLPq8OHDpodKNwd+6qmnzIRxVbVqVbMFhl7/6quvdp6v93Vyen7H3ZWezovGjjQ0O275HQDsSUMTr3/kxa3BXJ3L5ChB0KBBA1MOwEHDlBaxtLKqTmndpaFDh0rv3r1NT5MjNCmt49ShQwfZuHGj87GUlBQzB0pDVn7HAQAAPMmtHiftzdm1a5dcdtllJjj98ssvZrhMyxNoiQH9+OTJk6ZHKC96npYiqFixoumt2rJli/NYeHi4NG/eXEaNGiV33HGH6cVq3bq1LFq0yHzdm2++2ZyX33EAAACvBictUKmBRYfs9LZs2bIyfvx4U61bC1Dq5OwqVarkex2d/O3YukXnTeUuKaDBqWnTprJkyRJ5++23ZeXKlabG0z333OOcEJ7fcQAAAE8JyHLUEiigZcuWyZw5c+Stt94y5QcmTJhgShRobaZnnnnGTBj31fHtxEQmBtvR4cMH5OmnJ8nf//6c1KpF1XnATrQEia6o1oUhzHGyn8jI0KKdHK508rf+y8zMNEN3um/dr7/+aobJdMUdAACAv3E7OJ07d06WLl1qNtc9ceKEKTrZpk0bM88IAADAH7m1qk4nfut8pmeffdbsVaehSat4z5s3T3r16uUsXAkAACB273GaO3eumc/0ySefmA11HbTnSesw6b93333Xk+0EAADwzR6nbdu2yeTJk3OEJqW1nV588UX58ccf5dSpU55qIwAAgO8GJy08Wbr0//b1yk1rOTnqOQEAAIjdg1O3bt3kn//8p5nXlJvWY9KeKEdlcQAAAFvPcdLikjoB/MYbb5QuXbpIjRo1JDU11VQT37Nnj7Rq1UrGjRvnPF+H9SpXruzJdgMAAPhGcNq+fbuz4rcGqOyr6LS3SUPU3r17nY/pRHIAAABbBqf58+d7viUAAAD+OMcJAADAjtwOTuvXr3dODj99+rQ8/vjj0r17d3n66aflzJkznmwjAACA7w7VrVmzRh555BETniIiIuS1116TVatWmYnin3/+uWRkZMiMGTM831oAANxw+PAhSUlJvuRx3eA1MDBDMjODzGbveSlfPlxq1WJPVrtyKzgtX75cHnvsMedmvhqahg4dKlOmTJH9+/dL//79ZerUqRISEuLp9gIAUCA6OtK3b3ezKb0n6Mry9es3m44D2I9bwenw4cMmOCkNSnq/R48e5n69evWkfPnyZvuV6tWre7a1AAAUkAaclSvX5tnjlJAQL/PmzZEHHxwlUVHV8+1xIjTZl1vBqVy5cqbkgNqwYYOEhoZKy5Ytzf2srCwzx0nPAQCgJMhvaK18+TDzvtWoUWOpVatusbULNpkcriHplVdekdWrV8uCBQvk+uuvl+DgYOf8p7Jly0qFChU83VYAAADfC07R0dGSmJgojz76qAQGBsro0aOdx15++WW5//77PdlGAAAA3x2q0+1TdIL4gQMHTAXx7Bv+anAKCwszQ3l6CwAAIHav46SrCho0aOAMTVqCQMsTvPTSS2aiuE4OBwAAELv3OGX3119/yfvvv2/+xcfHm/lNvXv3ZsUBAADwO24HJ93o99133zUFL3UT3w4dOsi4cePkpptuMqvsAAAAbB2cdN7SihUrZMmSJbJnzx6pWLGiDBo0SNauXSvTpk2TunVZwgkAAPyX5eA0c+ZMWbx4sZw/f16uvfZaGTVqlNxwww2mOvjmzZuLtpUAAAC+FJw+++wzadiwoTz55JPSqlWrom0VAACAL6+qu+++++Ts2bNyxx13SNeuXWXWrFmmHAEAAIBdWO5xGjx4sPm3a9cuWbZsmbz55pvy6quvSuvWrc0GirrVCgAAgD8LdGe7lRkzZph5TdOnTzf1m1JSUkyomjJlink8PT29aFoLAADgi+UItOSArqjTf7rCTnuhVq5caW51tZ1+HBUV5dnWAgAA+GLl8Owuu+wymTx5smzatMlUDm/SpIlZfQcAAOBPCl05PDstTaBVw/UfAACAv/FIjxMAAIAdEJwAAAAsIjgBAABYRHACAACwiOAEAABgEcEJAADAG+UIAG9ISIg3+yh64jrq6NEjkpGR6YGWiZQpU0aioqp75FoAAO8jOMGnadiZNGm8R685b94cj17vuedmEp4AwE8QnODTHD1N99//kNSoUbNQ1woKCpSAgHTJygr2SI+T9lzNn/+qR3rDAAAlA8EJfkFDU9269Qt1jeDgQImICJWkpDRJT/fMUB0AwL8wORwAAMAighMAAIBFBCcAAACLCE4AAAAWEZwAAAAITgAAAJ5FjxMAAIAvBqfz58/Lvn37XB5LSkqSvXv3yrlz59w6DgAA4FfB6aWXXpLHH388x2OZmZkSExMjN9xwg0RHR0vnzp1l7dq1lo8DAAD4VeXwjIwMefnll+U///mPNGvWLMexd955R7788ksThqKiouSjjz6Sxx57TJo3by41a9bM9zgAAIDf9DjpENuAAQNk+fLl0qlTp4uOL126VG6//XYTipSeW7duXXO+leMAAAB+E5zS0tLk+uuvl08//VSaNm160TGd85S7F0rP++9//5vvcQAAAL8aqqtVq5aMGzfO5bHExETJysqSyMjIHI9HRETI77//nu/xwmz2Ct8QFBTovC3szy37tUpa2wAUrcDAAOctr1eU6OCU3yo7FRQUlONxvZ+enp7vcXfoiyYiItTtNqN4nThRxtyWL1/GYz+38PCyJbZtAIrGiROlzW1oaGler/Dd4BQa+r83m9wlBs6ePWuO5XfcHZmZWZKcfNrtNqN4paScdd4mJaUV6lraM6ShKTn5jGRkZJaotgEoWmlp55y3vF7tJzy8rOXRhhIdnKpWrSplypSR+Pj4HI8fPXpUateune9xd6WnF/5NE8XDEXD01lM/N09dqyjaBqBo6B/Njlter8hLiZ54ERgYKO3atZPNmzc7Hzt9+rTs2LFDOnbsmO9xAAAATyrRPU7qoYcekrvuukuqV68urVq1koULF5r6TD179rR0HADgvxIS4s30DE9cRx09esQjQ/VKR0Sioqp75FooOUpUcKpWrZo0atQox2MtW7Y0hTEXLVokW7duNYUtH3zwQSlVqpSl4wAA/6RhZ9Kk8R695rx5czx6veeem0l48jMlKjhpz5Erbdq0Mf8uJb/jAAD/4+hpuv/+h6RGjcLtFKETgwMC0iUrK9gjPU7aczV//qse6Q1DyVKighMAAAWloalu3fqFeuK0dpOWDdEVdUwOR14ITvB5ZcuWlfPnz0lqakqhrhMUFCABARckJUXLEfxvhU1haJu0bQAA/0Fwgs9r0qSJHD9+1PwriW0DAPgPghN8XlxcnHTv3keqVy/sHIeAbAUwC9/jFB9/ROLiFssttxT6UgCAEoLgBJ935swZCQkpLWFh5Qs9x6FixVDJyirlkTkO2iZtGwDAf5ToApgAAAAlCcEJAADAIoITAACARQQnAAAAiwhOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIvY5BcA4LPKli0r58+fk9TUlEJdJygoQAICLkhKyhnJyMgqdLu0Tdo2+B+CE/zCgQP7C32NoKBAOXAgXbKygiUjI7PQ1zt69EihrwEgb02aNJHjx4+afyWxbfA/BCf4tIyMDHP75pvzpaQqU6aMt5sA+K24uDjp3r2PVK9es9A9TuHhZSU52TM9TvHxRyQubrHcckuhL4UShuAEn9agQSOZMuXvEhQUVOhrJSTEy7x5c+TBB0dJVFR1j4UmT10LwMXOnDkjISGlJSysfKGenuDgQKlYMVSyskpJenrhe5y1Tdo2+B+CE/wiPHmCDtWpGjVqSq1adT1yTQCAf2FVHQAAgEUEJwAAAIsITgAAABYRnAAAACwiOAEAAFhEcAIAALCI4AQAAGARwQkAAMAiCmACAHwae1WiOBGcAAA+ib0q4Q0EJwCAT2KvSngDwQkA4LPYqxLFjcnhAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAABZRORy2cfjwIUlJSb7k8YSEeDl9+rT89tteSUlJzfNa5cuHS61atYuglQCKAq9/eEpAVlZWlseu5gcyMjIlMTHN282AhyUlJUnXrp0kMzPTI9cLCgqS9es3S0REhEeuB6Do8PpHfiIjQyUoyNogHMEpF4KTff/i1BdNYGCGZGYGmd+DvNDjBPgWXv/IC8GpEAhO9hUcHCgREaGSlJQm6eme6ZkC4Bt4/dtbZAF6nJgcDgAAYJHfBKezZ8/KkSNHJCMjw9tNAQAAfsovgtM//vEPadu2rdx2221y3XXXycaNG73dJAAA4Id8PjgtWbJEVq5cKatXr5Zvv/1W/va3v8nYsWMlISHB200DAAB+xueD0+LFi2Xw4MFSu/b/auoMHTpUqlevLsuXL/d20wAAgJ/x6eD0v2KFv0mzZs1yPN68eXPZtWuX19oFAAD8k09XDk9MTDQFDStXrpzjcS1K+McffxRqWSrsx7EU1eqSVAD+g9c/bBGczp07Z26Dg3N+G3r/woULbl0zMDDA1PKBfYWHl/V2EwB4Ca9/+HVwKleunLMUQe5AFRYW5tY1MzOzJDn5tEfaB9/7i1P/00xOPpNv5XAA/oXXv72Fh5e1PNrg08GpatWqEhISIseOHcvxeHx8vNSsWdPt61I12t40NPE7ANgTr3/kx6cnc+hGq1q/KTY2Nkdv044dO6R9+/ZebRsAAPA/Pt3jpKKjo2XEiBFSp04dadWqlcyfP18qVaokffr08XbTAACAnwnIysrKEh/39ddfy5tvvilJSUmmFMHo0aPNMJ479OnQeU6wJx3jZn4TYE+8/u0rMDBAAgIC7BOcAAAAioNPz3ECAAAoTgQnAAAAiwhOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACwiOAH/3w8//CAff/yxfPfddzwngA1lZGTIsmXLvN0MlHABWVlZWd5uBOBN+hKYMGGCxMbGyjXXXCPbt2+XVq1aySuvvCJBQUH8cACbePHFF+WNN96QX375xdtNQQkW7O0GAN62evVq2bhxo7mtUqWKJCQkyK233irLly+XgQMHert5AIrY2bNn5YUXXpB3332XP5aQL4bqYHurVq2Srl27mtCkoqKipGfPniZIAfB/ffr0kS1btsh9993n7abABxCcYHu7d++Whg0b5nge9H5cXJztnxvADqKjo+WTTz6Rpk2bersp8AEM1cH2Tp06JRUqVMjxPISFhZnHAfi/QYMGebsJ8CH0OMH2dCVNQEBAzhdGIC8NAMDFeHeA7YWHh8vp06dzPA9paWmm1wkAgOwITrC9+vXry8GDB3M8D3o/97wnAAAITrA9XVG3YcMGOXPmjHNp8vr16+XGG2+0/XMDAMiJ4ATbu+OOOyQ0NFTuuusuee211+Tuu++WcuXKyZ133mn75wYAkBPBCbZXpkwZWbJkifTr10/++usvU/xS72uYAmAfderUkcGDB3u7GSjh2HIFAADAInqcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIuCrZ4IACXZb7/9Jjt37pSkpCSpUqWKXH311aagoUNmZqb8+9//lg4dOsg111zj1bYC8F30OAHwaUePHjXb5AwZMkS+++47OXXqlHzxxRfSq1cvmThxopw/f94ZnObMmSM7duzwdpMB+DB6nAD4rBMnTsjtt98uDRo0kC+//FLCwsKcxzREjRgxQtLT0+XFF1/0ajsB+A+CEwCf9c9//lPS0tLklVdeyRGalA7HaS/U2rVrTcCqUKGCy2ucPHlSNm3aZHquSpcuLa1bt5arrroqxzmxsbGye/duE8IaNWoknTp1klKlShX4HAC+j6E6AD7pzJkz8tlnn8kNN9wgkZGRLs+ZMGGCfPXVV1KpUiWXxzUw3XTTTfLpp59Kamqq7Nq1y4Stl156yRzPyMiQv/3tb/LEE0+YYKUBbMaMGdK3b19zvtVzAPgPepwA+KTDhw+b8NSkSZNLnhMUFHTJYxp4nnzySendu7dMmzbN+fjs2bNl4cKFEh0dLT/88INs2LBBli1b5uyFGjlypLz33nuSkJBgerm2bt2a7zkA/AfBCYBP0kngyt1gop+v86P69Olj7mvv0O+//256jc6ePSvHjx83Q3dq+fLlUr9+fSlfvrxUrlxZRo8e7byOlXMA+A+CEwCfFBERYW6Tk5Pd+nwd3tOVd7rSTnuNNCjVrFnT/HP0SGlJg3vuuUfeeecdef/99839Ll26mLAVFRVlzrNyDgD/wRwnAD5JazSFh4fLzz//fMlz9u/fb4LRwYMHLzp27NgxGTp0qOzbt09iYmJk8+bNZsitX79+Oc6bNGmSfP311/LMM8+YnqS5c+dKt27d5Ntvvy3QOQD8A8EJgE/SFWs9evQwE7x1QrYrOu/oX//6l5kLlZtOLNdimc8++6yZIK5FM1V8fPxF5+rk8v79+8vMmTNl/fr1EhoaKosXLy7wOQB8H8EJgM8aO3ashISEyPjx4y9awbZx40Z588035dZbb5XLL7/8os91zI3KPtSnQerDDz80H1+4cMHUgtJq444imkq/XlZWljNoWTkHgP8IyNJXNwD4KB1qGzdunFnBduONN5q5T7/++qupqzRgwAB5+umnTe+U1ldq1qyZCVkPPPCAqf80ePBg01t1yy23mOOff/651KtXT7Zt2yavvfaaCVx33XWXlCtXztRlCggIMENyOv9p0aJFZg6T9lDldw4A/0FwAuAXdJ+6PXv2mNVyGlZ0knatWrXy3KtOe4k0LB05csT0DrVs2dLMndI5SloIs2PHjmaFnc5/OnTokOmF0irlOvlbe5UcrJwDwD8QnAAAACxijhMAAIBFBCcAAACLCE4AAAAEJwAAAM+ixwkAAMAighMAAIBFBCcAAACLCE4AAAAWEZwAAAAsIjgBAABYRHACAACwiOAEAAAg1vw/mbEuudYpKo4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: Specified 'match_label' not found; defaulting to Stratified CV.\n", + "INFO: Validating and Identifying Feature Types...\n", + "WARNING: Both cat/quant lists provided; binaries treated as categorical; remaining auto-assigned.\n", + "INFO: Running Initial EDA:\n", + "INFO: /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running Post-Processing EDA...\n", + "INFO: Categorical: ['HepatitisBSurfaceAntigen', 'Splenomegaly', 'Gender', 'ArterialHypertension', 'LiverMetastasis', 'PortalHypertension', 'PortalVeinThrombosis', 'HepatitisCVirusAntibody', 'Cirrhosis', 'EndemicCountries', 'HepatitisBCoreAntibody', 'EsophagealVarices', 'Smoking', 'Hemochromatosis', 'HIV', 'Obesity', 'Alcohol', 'ChronicRenalInsufficiency', 'RadiologicalHallmark', 'NASH', 'Diabetes', 'Symptoms', 'Miss_Iron', 'Miss_OxygenSaturation', 'Miss_Ferritin', 'AscitesDegree_1.0', 'AscitesDegree_2.0', 'AscitesDegree_3.0', 'EncephalopathyDegree_1.0', 'EncephalopathyDegree_2.0', 'EncephalopathyDegree_3.0', 'PerformanceStatus_0', 'PerformanceStatus_1', 'PerformanceStatus_2', 'PerformanceStatus_3', 'PerformanceStatus_4']\n", + "INFO: Quantitative: ['Hemoglobin', 'GramsAlcoholPerDay', 'InternationalNormalisedRatio', 'MajorDimensionOfNodule', 'GammaGlutamylTransferase', 'Platelets', 'AspartateTransaminase', 'Albumin', 'AgeAtDiagnosis', 'AlanineTransaminase', 'Leukocytes', 'DirectBilirubin', 'MeanCorpuscularVolume', 'Iron', 'PacksCigarettesPerYear', 'AlkalinePhosphatase', 'TotalBilirubin', 'TotalProteins', 'NumberOfNodules', 'AlphaFetoprotein', 'Creatinine']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjYAAAG7CAYAAADQcN+uAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAPPVJREFUeJzt3Qd0VMX7//EnDUghIYUE6U06SBMFQRERkSJFULqoFEUUC0oRRVHsFCk2OhhEsCFIE+GriKgIAkqvSg+EEgKB1P95xn/2lwrJsslu7r5f5+SEvXtzd5LsZj/MPDPjkZKSkiIAAAAW4OnsBgAAADgKwQYAAFgGwQYAAFgGwQYAAFgGwQYAAFgGwQYAAFgGwQYAAFgGwQYAAFiGt7gZXY8wOZk1Cd2Fp6cHv2/Aonh9u9fv2sPDI0fnul2w0VBz5sxFZzcD+cDb21OCg/0lJuaSJCYm8zMHLITXt3sJCfEXL6+cBRuGogAAgGUQbAAAgGUQbAAAgGUQbAAAgGUQbAAAgGW43ayonEpOTpakpERxB15e3uLpScYFABR8BJss1rmJiTkjcXGx4k58fQMkMDAkx+sEAADgigg2GaSGmoCAYClUqLDl3+g1yMXHX5HY2LPmdlBQqLObBACA3Qg2aSQnJ9lCTUBAoLgLDXBKw03RosEMSwEACiwKK9JISkpK90bvTlK/Z3epKwIAWBPBJgtWH37Kijt+zwAA6yHYOLhe5fz5c7aen4yio09LTEyMIx8SAACkQY2NA/z++6+yYEGkbNmySYoU8ZW4uEtSufKN0rPnQ9K8+V228wYOfFgaNmwkw4e/5IiHBQAAGdBjc51mzZomL7zwtNSv30CWLFkly5b9IMuWrZFbb71NRo0aJvPmzb7ehwAAADlEsLkOv/22QWbM+Fiefnqo9OrVV/z9A8xxX19fefTRgdKuXQeZPv1DOXr0SI6GsC5cuJDtOZcvX5Zz586Zc6/nHAAArIyhqOvw+eeREhZWXNq375Tl/X379pcmTZpJUFCxLO9PSEiQjz6aIitWLDW3Y2NjJTw8Qp54YohtCGvr1i0yfvzbcvToYSlcuLAkJSXLvfe2M+d4e3vn+BwA1uXp6WE+3ImXF/8vR9Z417uOLRc2b/5D7rjjTvHy8srynBIlSpiP7EyZMkF+/HGtfPzxbClduoxcuXJFJk58V8aOfVUaNrxFdKLSsGFPS5s27WXmzE/N4/z99zZ5+eURUrNmLWnZ8h65eDH2mucAsC4NNMWK+bnlG31ycgozOpEJwcZO586dlcTERNNjYw+dObVx42/SvXsvE2qU9rbcdVcrWbLkG9m1a4eEhoaZXpxSpcrYwlOtWnXkq6++s10nKirqmucAsHaw0VDzXuQmOXIy++FsqykdUVSG9mzgdj1VKIDBZvv27RIeHi7Fi6cPDMePHzdv4pUqVZKAgP9qWZxJQ4iKj0+w6+s1hMyf/6UJMHPmzJB//z0khw4dkoMHD/z/68ZLuXLlpXr1mvL+++/J779vkGbN7pBGjRqb4apUOTkHgPVpqNl/9LyzmwE4nUv1Xf7xxx/SpUsXWbduXbqejRdeeEHat28vo0aNkmbNmsk333wjzqaFwsWKFZMTJ45le44W8V6tcHjSpHHSv/9DsmnTRilRoqQ8/HB/eeedCbav1R23p0z5WJ555gVTjzNx4nvSuXNbGTx4gBw5cticl5NzAABwFy4TbHQ4RQOM1q6kNXv2bNm0aZOsXLlSlixZImPHjjUB599//xVn08LgLVv+lEuXLmV5/9atf8qDD3aUhQs/y3Tfjh1/m+MPPfSoTJr0kfTv/7g0bXq7JCTEpzuvcOEi0qlTFxk/fop8990P8tprb8m+fXtk3Li3cnUOAADuwGWCzZgxY6R27dri5+eX7viiRYvkgQcekNDQ/3adbtOmjRmOWrx4sThbr14PSWJignzyyQeZ7tP6m+nTPxJfXz+5++7Wme4/cybafNYC34xTyP9vQ844iYo6aZu+rcNfd97ZUmrWrGP7+pycAwCAu3CJGpvly5fLr7/+anpkmjdvnq4X5+DBg1KtWrV05+vtv/76S5ytbNnyMmLEaHnzzVfl9Oko6dSpq6ltOXLkX7Mw365dO83QUnBwcKavrVXrJilaNFDmzp0pISFhUqhQIVm7drUsXvyVuV97gY4fPyaPPtpLOnbsIm3b3idFihQxM7E2bfpdnnzyGXNeTs4BAMBdOD3YnDx5Ul555RWZMGGCBAUFpbvv7Nmz5nPGYKC1Lfv27bP7Mb29s+6oSk7OfXV9q1atpUqVqvLNN1/ItGkfytmzZyQkJMQU9I4e/bpERPzfdG+d5RQYGGj7HiZO/EBmzvxYRo8eaY5XrVpd5sz5TF56abjs379X7rmnjRmmWrRogYwZM8oswHfDDaVk5MhXzOOqihUrXfOc3PDy8sj251PQpE5/dcdpsHAf7v781llRVvmbBQsEGx0+GTFihHTo0EGaNGmS6X6dGaQyrhOjBbPZbTSZkxdBcLB/lvddvuwlp0975vrNvXLlSjJ06LBrnjdjxpx0t2vWrCHjxr2f6bzIyIW2f9erV898XE1OzrkWDXX6cw0K8jO9PlYSGOjr7CYAyCMBAdb6e4UCHmw+++wz+fvvv6Vv377y22+/mWMaWA4cOCDbtm2TiIj/pixrL0RaetveKd+6oFNMTNbFvvHxV0zxclJSiiQmpi9itjr9nvV7P3/+ksTF2RcaXfF/shpqYmLizGrMgBWlPs/dVWzsZUlIsMbfLGRPn+M57Z10arDROpKqVavKtGnTbMd0yvLq1aslOjpa3njjDbPv0rFjx6RBgwa2c/R22bJl7X7c7EKLvrm7OyuGOg01VvueAPzff1Z5fcNlgk2/fv3MR1o6pDJgwADp3Lmzud24cWP58ccfzTo2qQXFOv1bZ1EBAAC4VPHwtQwePFi6d+8ub731lgk9s2bNMtO977mHPZAAAEB6LldKrkNOYWFhtts1a9aUyMhIOXPmjHzxxRemB2f69OnZbjwJAADcl8v12GhoyUgX7nvnnXec0h4AAFBwuFyPDQAAgL0INgAAwDIINgAAwDJcrsbGVemKxfrhrHUa9AMAAFwdwSYHNNAUK+bntD1ZdIG5c+cu5Src6HYVX321UH744XtJSIiX22+/U7p37y3e3vzKAQDWxbtcDoONhpr3IjfJkZMXJD+VjigqQ3s2MG3ITbCZM2eG2Sl86NARZg+o8ePfNhuODh06PE/bCwCAMxFsckFDzf6j58XV6VYVkZFzZeTIl+W225qZY6NGjZGnnhooffs+KmFhxZ3dRAAA8gTFwxa0c+d2iYu7JA0aNLIdq127jvj4+MjmzX84tW0AAOQlgo0FHT9+VHx9/SQwMNB2TIejtKfm2LGjTm0bAAB5iWBjQToUVaRIkUzHCxcuLHFxcU5pEwAA+YFgY0He3j6SmJiY6bge03ADAIBVEWwsSIecLl6MzRRuzp07K8HBIU5rFwAAeY1gY0HVqlU369js3bvbduzEieNy/vx5qVGjllPbBgBAXiLYWFB4eITcemsT+eijKaamJiEhQSZPHi81a9aWqlWrObt5AADkGdaxyeVieQXlMYcPf0leemm4tG9/t3h6ekm5cuXk9dffcXj7AABwJQSbHNAVf3VbA10B2Bn0sXO7V1RoaJh88MF0iY4+LR4eHhISEppn7QMAwFUQbHJAQ4Xu1VQQN8HUgAMAgLsg2OQQO2wDAOD6KB4GAACWQbABAACWQbABAACWQbABAACWQbABAACWQbABAACWQbABAACWwTo2OaSL8xXEBfoAAHAnBJsc0EATXMxXPL28xBmSk5Lk7Lk4u8PNBx9MktDQUHnwwZ4ObxsAAK6EYJPT3hovL4n6ZqLERx+R/FQotLSEd3zatMGeYLNw4XyZP3+u9OnzSJ60DwAAV0KwyQUNNfEnDkpBcPr0KZk8ebz88svPUrRooLObAwBAvqB42KLWrFktFy7EyvTp8yQiooSzmwMAgPv02KSkpMjOnTvl7NmzUrt2bQkMTN/D8OOPP0pCQkK6Y1WqVJGyZcvmc0sLjg4dOssDD3R3djMAAHCvYHP+/HkZMGCAnDlzRiIiImT79u3y2muvSbt27cz9sbGxMnDgQGnSpIkUKVLE9nVdunQh2FxF4cKF8/6XBwCAi3F6sHnrrbfEz89PIiMjxdvbWxYtWiQjRoyQW2+9VcLCwmTfvn3i4eEhH374IW/WAADAtWtskpKSTI+MhhrVunVriY+Pl61bt5rbe/fuldKlSxNqAACA6/fYvPPOO+lu796923wuWbKk+bxnzx6pVKmSHDt2TA4ePCilSpWS8uXLO6WtAADAtTk92KT6999/Ze3atTJjxgzp06ePVK9e3dZjs2PHDtOrExISItu2bZPbbrtN3nvvvXQ1N7nh7Z11R1VysnNWFnYlXl4e2f58ChovL890nwErcvfn939/r1zmrSxf6JpmOukGWXOZZ4OGl3/++Uf8/f3l6NGjpphYg0yZMmVM4bAWGKsjR46YwuFJkybJCy+8YN8qwsH+Wd53+bKXnD7tmenNPfUPhy6Wl99SH/N6/nh5ePz3fV8tsGio8/T0lKAgP7sDo6sKDPR1dhMAOFixooUlJTlZ/Pzcb6KEft8enu4daK/GI8XFYt+VK1ekY8eOctNNN5nC4qzocZ0Cvnz58lxfPykpWWJi4rK8Lz7+ikRFHZPQ0BvEx6eQZbZUOHnyhPj6+kpgYFC25yQkxEt09HEJDy8phQpZ4w+FhkENNfr71t87YEWpz/Onx/9P9h89L+7ijnqlZGivhk5ZEd6ZUlejd7e/a4GBvjn+D75Te2zi4uJk/fr10qhRI9vaNTpNuXHjxrJx40bb/Q0aNJDg4GDb1+k5WnRsr8TErJ8MSUlZBwcNFBosCuommLlZoE9/Btn9fAoqffFb7XsCUPBWhHck/q5lz6l9WYUKFTJTuz///HPbseTkZNmyZYtUqFDB3D98+HBZsGCB7X4NNGvWrJFbbrklX9uqwULfHJ3xwc7eAACI6/fYeHl5meCiC/LpFG+d8bR06VI5deqUTJgwwdw/dOhQeeONN8zKw1pv8/XXX8uFCxfkySefdGbTAQCAC3J69dH9998vs2bNMtsp6LCT9sRo7Uy5cuXM/d26dZOZM2dKTEyM/PTTT2bhPg034eHhzm46AABwMS4xK6pevXrmIzsNGzY0HwAAAC7dY+OKXGyiWL5wx+8ZAGA9BJs0tKYnddq3u0n9nr28XKITDwAAu/Auloanp5f4+gZIbOxZc1vXc9ENOK3eU6OhRr9n/d51kT4AAAoqgk0GgYEh5nNquHEXGmpSv3cAAAoqgk0G2kMTFBQqRYsGS1JSorgDHX6ipwYAYAUEm2zoG72n5/9tqwAAAFwfBRUAAMAyCDYAAMAyCDYAAMAyCDYAAMAyCDYAAMAyCDYAAMAyCDYAAMAyCDYAAMAyCDYAAMAyCDYAAMC9g83s2bPl3LlzWd538eJFGTFihMTGxl5v2wAAAPI+2ERGRsr58+ezvO/KlSuyatUqiYmJsefSAAAAeb8J5tChQ2XJkiW2261atcr23IiICAkPD7e/VYADeXm534hrcnKK+QAAd5PjYDN8+HCpWLGi+fecOXOkY8eOEhQUlGlH7ICAALnjjjvE25uNw+FcHh4ekpKcLIGBvm73q0hOSpKz5+IINwDcTo7TR1hYmAwaNMj8Ozk5WXr06CEhISF52Tbgunh6eoiHp6dEfTNR4qOPuM1Ps1BoaQnv+LT5/um1AeBu7OpWGTx4sCkOXrZsmVy4cMEEnYzat29vem8AZ9NQE3/ioLObAQBw1WCzY8cOeeihh65aINykSROCDQAAcP1g88EHH0i1atVk5MiRpkhYaxkyKlasmCPaBwAAkLfB5uDBg/Lmm29K9erV7flyAACAPGHXPFgtGr58+bLjWwMAAJDfweb++++XqVOnyqVLl67nsQEAAJw/FPXPP//Irl27pGnTplKlShUpUqRIpnPefvtts1AfAACASwebf//91wSaVElJSY5sEwAAQP4Fm3Hjxtn3aAAAAK4WbFavXm128b6ali1bir+/f46uFx8fLxs3bpSzZ89K/fr1pWTJkunuT0lJkd9//11OnjwpNWvWlEqVKtnTbAAAYHF2BRutn9HhqOx4eXlJvXr1chRsTp06ZRb78/X1NYFm1KhR8vzzz0vPnj3N/Vqg/Oijj8qZM2ekcuXKMnr0aOnXr5888cQT9jQdAABYmF3BRjfBTEhIyNTrouvbTJ48WR555BEpW7Zsjq41duxYKV++vFn0T+k2DbqT+F133SUlSpSQjz76yISbxYsXmyLlTZs2Sa9evaRFixasowMAAK4/2GQcKkp14403mqGibt26SYcOHcxu3znZXLNdu3a2282aNTPFyH///bcJNkuWLDE9Oqkzrxo0aCA33XSTLF26lGADAACuP9hcTalSpWxDTDmZ7q1DT2lt27bNfNZenPPnz8uxY8dMYEqrYsWKsnPnToe2GwAAFHwODzYaTLQeJqeFw6n27NljhqEWLFggQ4YMMfU0qXU8gYGB6c7V27qOjr28ve1alxAFjKdn5j3M3ImXF89zd8Dv2T3xe3dwsHnppZckKioq08yl2NhYE2y0/iUgICBX1zx+/LgpOi5durSsW7dOOnfuLImJiea+jENauummPp69b3bBwbkLXUBBFBjo6+wmAMgjvL4dHGx0iEinZmcMG1oHM3jwYFPcm1t33HGH+Xj88celS5cu8s4778iIESPMfRm3btCp5rkNTqmSk1MkJoatINyBj4+XBARkXhXbXcTExElSUrKzm4F8+J87b3Lux91e34GBvjnupbIr2EyaNEkcQQPLd999Z3p4QkND/2uQt7dZy0bXtSlevLgZdtIhqZtvvtn2dYcPHzZDVfZKTHSfJ4M7c/euWv2jx3MdsCZe39mz+y+/9ti88cYb0rp1a2nUqJGZnv3ss8/Kjh07cnwN7eGZMGGCzJ8/33ZMp5HrYnzVqlUzt5s3by4rVqyw3X/ixAnZvHmz3HnnnfY2HQAAWJRdPTbnzp2TBx54wISMhg0bSt26dU3Q2bBhg6xatUrmzp1rel2uRWtnXnnlFXnhhRfM8JbW12gBsYab5557zpzz1FNPmaGpQYMGmcf54osvzJTw22+/3Z6mAwAAC7Mr2EyfPl18fHxk5cqV6da00aElXRn4zTfflEWLFuXoWq1atTJbJCxfvtxM7dbAdN9990mhQoXM/WXKlDGL82mg0YJlDTjt27e3p9kAAMDi7Ao22jOjvSwZF+rz8/OTMWPGmHqYCxcuSNGiRXN0PQ02WnScHV2o72r3AwAA2F1jk5ycLCEhIVnep3s+acC51iaZAAAALhFsqlSpIl9++WWW933//ffms85oAgAAcPmhKN1tu2PHjnLy5Elp27athIeHm+Jfnc20cOFCeeyxx8xiewAAAC4fbLTHZuLEiaaeZu3atbbjWvDbt29fE2wAAAAKzF5ROptJF9bTzSijo6PN3lDVq1e3e0VgAACAfK+x0T2ddu/ebVsluHbt2mYRPQ0427dvv+4GAQAA5Euw0cXz7r77brMDd1Zr2/Tp08esRgwAAODSwebAgQPy/PPPm+GnrDa51EX0nnjiCZk3b162M6YAAABcosYmMjLS7AeV3QaYwcHBZvsD3f9pxowZcv/99zuynQAAAI7rsdEamh49elzzvIceesjsxn358uWcXhoAACB/g41ukaC9MtdSuHBhc56uawMAAOCSwUYX4Tt06NA1z4uNjTU7fWe35QIAAIDTg02zZs1k7ty5Zp+oq5k9e7bUqFHD7P4NAADgksGmU6dOpnZmyJAhcuLEiUz3a03Nhx9+KFOnTpVHHnnE0e0EAABw3KyooKAgMyNq0KBBZsp3tWrVpEyZMuLp6SmnTp2Sbdu2SWJiogk+rVu3zullAQAAnLOlQr169eSbb76ROXPmyA8//CBr1qyRlJQUU3/ToUMHM2tKt1UAAAAoEHtFRUREyAsvvGA+lAYbDw+PvGgbAABA3u4VlRGhBgAAWCbYAAAAuAqCDQAAsAyCDQAAsAyCDQAAsAy7g40uyDd9+nTp3bu33HPPPXL06FF54403zHo2AAAABSbY6H5Q3bt3l/Hjx5vNMU+ePGkW59NQ07NnT1m/fr3jWwoAAJAXwUZ7apKSkmTlypVmwb7ixYub45GRkdKrVy/TcwMAAFAggs26detkxIgRZkuFtLy8vOS5554ze0lpTw4AAIDLB5srV65IkSJFsrxPw426dOnS9bUMAAAgP4KN7gc1Y8YMMxyVkQ5NFS5c2OwfBQAA4NJ7Ral+/frJAw88YDa+1J28L168KKtWrZIDBw6YYDNs2DC2WgAAAAWjx6Zq1aqmx0ZNnjxZoqOj5b333jPh5plnnpG+ffs6up0AAAB502OjGjZsKEuXLpUjR45IVFSU+Pn5ScWKFaVQoUK5vtb58+fl559/ljNnzkiFChWkSZMm4un5f5lr9uzZEh8fn+5rGjduLLVr17a3+QAAwILsDjapSpcubT7stWXLFhkwYIAJKeXKlZM5c+aY+pyZM2eaAuVz587Jm2++adbNCQgIsH1dxqADAACQ42Dz0ksvmZ6ZnHrttddyVEA8evRoue+++2TUqFG2xf/uvfde00vz2GOPyZ49e8THx0defPFF8xkAAOC6g40OF509ezanp0tycvI1z9HVim+//XZThJxKe2V0mCt1a4a9e/dK2bJlCTUAAMBxwWbSpEniaN7e3mZBv4z27dsn9erVM//WHhut3dmwYYM5XqpUKWnWrBlBBwAAOK7GJi4uTubNmydr1qwxRb+BgYHSoEEDMyPqhhtusPeyZrq4Tht/9913bT02W7duNdPHw8LCZNasWVK0aFHzOSQkxK7H8PZmU3N34OnpIe7My4vnuTvg9+ye+L07ONhorU23bt3MZy36rVatmhmm+vLLL+Wrr74yBcA1atTI9XU3b94sr7zyiowcOdJcU91xxx3yyCOPSMuWLc1tXTOnY8eOZnq5PXtS6ZtdcLB/rr8OKGgCA32d3QQAeYTXt4ODzQcffCDFihWT+fPnS4kSJWzHtfBXi4E1mGjPS25nRw0cOFCeeuops0N4Kj2Wlr+/vykuXrZsmT1Nl+TkFImJYbsHd+Dj4yUBAVlv/eEOYmLiJCnp2rVuKPj/c+dNzv242+s7MNA3x71UdgWbTZs2mVlKaUNNauGv9qLcfPPNcvr0aTN0lBO//fabDB482KxY3KVLl3RBScNTmzZt0k0pT0hIMNs22Csx0X2eDO7M3btq9Y8ez3XAmnh9Z8+uv/zaW5OSkpJtQbCuP5N2gb2r+eWXX8y07rFjx6YLNam9M1rHo0NbacPO8uXLpUWLFvY0HQAAWJhdPTZt27aVt99+Wz7++GOJiIiwHdew8/7775stF3JS2KtFxzr0pL0xhw4dkk8++cR2nxYgt2/fXl5//XUZMmSInDp1SsqUKSMrV66U4sWLZxqiAgAAyHGw0WGikydP2gLM7t27TUFv/fr1Tbi5dOmS/PXXX3LixAlp2rSp2T8qNDT0qtfUVYW1CFnFxMSkuy8oKMhWPKw9NKmzr5599lnzuNozBAAAkFaO04FuYXDlyhXb7bp169qOHz582Py7ZMmS5kNDji6+dy26Ps3QoUOveZ723qQtKAYAALiuYDNhwoScngoAAOAUdo/naBHvunXrzLoyqYXE+lkX7tu+fbs8/fTTpvcGAADApYPNjh07pHfv3ibcZEVrbry8vK63bQAAAHk/3Xv69OmmxmbJkiXms07VXrp0qbz11ltmbRudsZR2thQAAIDLBhvdv+nxxx+XKlWqmMX4du3aJTfeeKN06tRJJk+eLHPnznV8SwEAAK7B7qVZdSPK1JlN27Ztsx2vU6eOqbu5fPmyvZcGAADIv2BTqVIl2bBhgy3Y7Ny501Zvo9O/NdhcuHDBvhYBAADkdfFwUlKSrSC4e/fuZsdt3bhy1KhRZouFQYMGSYcOHWT16tXi5+dnVgcGAABwyR6b1q1byz///GP+fcstt8jEiRPl4MGDZjE+LR7WVYd1V2/d+0l3+AYAACgw69jcfffd5kOVLVtW1q5dKwcOHJAKFSpIcHCwI9sIAACQIw7bcEmHo3TfKAAAgAI3KwoAAKBA99jce++9OT53xYoVZogKAADAJYPNXXfdJf7+/jk6N6fnAQAAOCXYDB06VMqVK+ewBwcAAHAkamwAAIBlEGwAAIBl5DjYtGrVSgICAvK2NQAAAPlRY/P8889fz+MAAADkOYaiAACAZRBsAACAZRBsAACAZRBsAACAewebRYsWybFjxxzfGgAAgPwONrNmzZIWLVpI79695YsvvpDY2NjraQMAAIDzgo2GmbfffluKFCkio0ePlttuu02effZZ+fHHHyUxMdExLQMAAMjLvaJS+fn5SYcOHczHmTNnZNmyZbJkyRIZMGCAhIWFSdu2baVLly5SpUoVey4PAADgnOLhkJAQ6dWrl0ycOFF69Oghp0+fljlz5sh9990ngwcPlqioqOt9CAAAgLzrsUl14cIFWbFihXzzzTeyadMm8fb2lrvvvls6depk/j19+nTp37+/LF68+HoeBgAAIO+CzS+//GLqbFavXi1XrlyRatWqyYgRI6R9+/amBydV48aN5ZZbbpGTJ09KRESEPQ8FAACQt8FGC4a1t+aBBx6Q+++/X6pXr57leYUKFZJGjRpJYGDgVa+nw1U//PCDqdepUKGC6fXx8fGx3X/x4kVTx6MBqVatWtK8eXN7mg0AACzOrhqb119/XdatWyejRo3KNtSk+vjjj8XX1zfb+zds2CD33HOP/PbbbxIfHy8ffvihKTzWMKO0ZkfrdZYuXWqO6WMOHz7cnmYDAACLsyvY6PCSl5eXCSUxMTG24wsXLsz1wn2vvfaa9OzZ0xQfP/PMM2bxP+0Nmjlzprl/8uTJUrJkSZk9e7YMGzZMPv30UxNyfv/9d3uaDgAALMyuYKM9Jw8//LD07dtXzp07Zzs+b948MwV869atObqOrnnTsWNH6dq1q+2Yro1Tt25d2bFjh7n9/fffS5s2bcTDw8PcLl++vNSrV09WrVplT9MBAICF2RVspk2bZuphtHelbNmytuNffvmlGUZ69dVXc3QdnTmla9+UK1fOdiwlJcWEmhIlSpjHiI6ONnU3aentPXv22NN0AABgYXYVD+sQlNa61KlTJ1Ox8HPPPWcKhnWbhYCAgFxfe8GCBXL06FGzNk7qMFfG6/j7+5vhKnt5e7P3pzvw9Pyvl89deXnxPHcH/J7dE793BwcbLfLVGpus6HEdNrp06VKug41OI3/jjTdM3U2lSpXk4MGDWZ6nvTqpQ1P2vNkFB/vb9bVAQRIYmH3RPoCCjde3g4ON9tR88skn5rP20qQVGRlpAk14eHiue4F0peKXX37Z1N2oYsWKmc8ZN9nU20FBQfY0XZKTUyQm5pJdX4uCxcfHSwICioi7iomJk6SkZGc3A/nwP3fe5NyPu72+AwN9c9xLZVew6devn3Tu3NmsN6NryhQvXtz04mzZssVM237nnXdydb21a9fK888/b3prWrdubTseHBxsrq09N7feeqvtuN6uXbu22Csx0X2eDO7M3btq9Y8ez3XAmnh9Z8+uv/xlypQxhcM6e0mnXuuUbN0+QYefpk6damZG5ZSuXqw7g+t077ShJpWucfP111+b4KR27dplAlRW5wIAAPdm915ROu36/fffN/+Oi4szQ1LZ1d1k59SpUzJ06FCzTs2vv/5qPtKGpwcffFCeeOIJ6d69u1nlWFcd1unfWlisoQoAAMAhweaff/6R5cuXm5lLWsybkU7j1qGkq9FANGjQoCzv8/PzM5917yndZFN7ds6ePWu2cNB1bAAAABy2CabW2SQnJ5sA4umZeUSrR48e1ww2ugaOBqBr0S0ZdINNAAAAhwebGTNmmBqXMWPG2LVWDQAAgMsUDx8/flz69+9PqAEAAAU/2Gixb1RUlONbAwAAkN/Bpnfv3jJhwgQ5fPgwP3wAAFCwa2yWLVsmx44dk5YtW5pZS1rcm5Hu9F2qVClHtBEAACDvgk1ERIRZdfhqsgo7AAAALhdsdKVgR21KCQAA4Ch2b6ajqwbrhpW333671KhRwyzYp5tYrly50mGNAwAAyPNgo6GmS5cuJsTo1gb+/v7muLe3twwZMkQWL15sz2UBAADyP9h8/PHHUqFCBVmzZo1MmjTJtsKwbmQ5atQoGT9+/PW1CgAAIL+CzcaNG+Xpp5+29dSkpRtUXr58Wc6cOWPPpQEAAPI32Gix8JUrV7K8LykpyQQb3UcKAADA5YNN/fr1zQJ9urN3Rh9++KGEhYWZDwAAAJef7q07cnfu3FlatWplZkWdP39eZs+eLbt375ZNmzbJuHHjHN9SAACAvNorasGCBabnZsWKFSbYzJ8/Xy5cuCDvv/++tGvXzp7LAgAA5H+PjSpfvrx88MEHkpiYaIJNkSJFsiwmBgAAcOlgM2XKlGxnPekKxBpySpcubbZdoNYGAAC4dLDZuXOnrF271syA0l6a8PBwU0isYUdnTPn5+ZlZU7quzaxZs8zKxAAAAC5ZY9OpUycJCgoyC/Vt3rzZ1Nn88ssvsnz5cmnUqJH06dNHtmzZYgqMX3vtNce3GgAAwFHBZuHChfLiiy9K8+bN0x3X1Yh1mGrevHni5eUlzzzzjOzatUsuXrxoz8MAAADkfbA5fvy4lC1bNsv7tCfHx8dHTp8+LYUKFTK3s1rvBgAAwCWCTcWKFeWzzz7L8r5ly5ZJQkKChISEmJ6a6OhoKVas2PW2EwAAIG+Kh/v16yc9e/aUvXv3mkX6tHg4Li5O/vzzT/nuu+/MDt/aa6NDUVWrVhVfX197HgYAACDvg03t2rVl7ty58u6775qtFVL3hSpXrpyMHTtWOnbsaG57enrK6NGj7XkIAACA/Fugr27duhIZGWlWG46KipLQ0NBMQ06TJk2y9/IAAAD5F2z++ecfM71bC4N17Zqs9pMKDg629/IAAAD5E2x0zRqts9EhKF2MT4ecMurRowfBBgAAuH6wmTFjhrRu3VrGjBkjAQEBjm8VAABAfq5j079/f0INAAAo+MGmZMmSpmAYAACgwA9F9e7d20zz1oX6ypQp47DG7N+/X1auXCmDBg1Kd/zVV1+V+Pj4dMfatm0rTZo0cdhjAwAANw02urrwsWPHpGXLlmaF4awW4NP9okqVKpXja549e1aefvpps7Bf2mCjPUPz58+XF154QQIDA23Hixcvbk/TAQCAhdkVbCIiIuTuu+++6jm5WW34jz/+kOHDh8uJEyekSpUq6e7T1Y0LFy4sDz/8cJazrwAAAK4r2Dz77LPiKLoeTt++fc0WDWrjxo2Zgo3uGk6oAQAAebZAn6PoIn660J/W6rz33nuZ7t+zZ4+UKFFCFixYIPv27ZPSpUubLRvYWBMAANgdbHTBvXfeeccEC/33kSNHrnq+1sXoudeidTNpa2cy0h6b3bt3S+XKlc31VqxYIdOmTTNBx97CZW9vhrTcgaenh7gzLy+e5+6A37N74vfugGDTsGFDs8pw6r91eOhqUs+9Xn369DGPVatWLduMrK5du5oNOO3Zi0rf7IKD/R3SNsCVBQbmvM4NQMHC69sBwSZtXY0ja2yupX379ulue3l5yR133CFff/21XddLTk6RmJhLDmodXJmPj5cEBBQRdxUTEydJScnObgby4X/uvMm5H3d7fQcG+ua4l8quGpuxY8fKwIEDJSwsLNN9Fy9elMcee0wmT5583XUwsbGx8uabb5pem6pVq9qO647i13PtxET3eTK4M3fvqtU/ejzXAWvi9e2AYKM1NUlJSebfq1evlhYtWpgQk9V6NH/99ZdcvnxZrpfuQ7V582ZzrXHjxpljun7Ot99+a4IVAACAXcFGF9ybPXu27bZO0c7OjTfeaNa6cQQtWH7iiSekc+fOpnh4w4YNctttt5leHAAAALuCzZNPPil16tQx/37jjTdkwIABmYaiPDw8TC9L/fr1zb9zq1WrVlK3bt10x2rXrm22Wdi0aZNER0fL448/LtWrV8/1tQEAgPXlONhoYNH9mdSVK1fMysNFixZ1aGNSg1NWqxg3bdrUoY8FAACsx67iYR0W0hWDIyMjJSYmRlJSUjKdoz06uvgeAACASwebX375Rfr16yfJyclmvZqstjvQRfwINgAAwOWDzYwZM6R169YyZswYM0QFAADgCuxa6OP48ePSv39/Qg0AACj4waZkyZISFRXl+NYAAADkd7DR/ZomTJgghw8fvp7HBgAAcH6NzbJly8wKwC1btpSQkBAzHTurBf1KlSrliDYCAADkXbDRVYV1HZurySrsAAAAuFywSbu7d2JiotmsUhfr0523AQAAClSwUQcOHDD7OK1fv17i4+PNFgo1a9Y0Wx7oEBUAAECBCDZaX9O9e3fx9vY2qxDr0JTu6v3777+bDSunTp1KuAEAAAUj2HzyySdSuXJlmT59erpaGt1aYeLEiTJ+/HiCDQAAKBjTvf/880+z23fGAmEdjtLjR48eNT04AAAALh9sChUqZIahsrygp6cpIk5ISLjetgEAAOR9sNEi4VmzZplNMDOaP3++2WohPDzcnksDAADkb43NgAEDpG3bttK+fXu59957TfHwuXPnTPHwTz/9JK+//rr9LQIAAMjPYKN7Rc2ZM0fGjh0rU6ZMMUXDqcc11HTt2tXe9gAAAOT/OjZ16tSRzz//XM6fPy/R0dHi7+9vem4AAAAKTI3Npk2bZOPGjbbbQUFBUrFiRdODs2jRIrMSMQAAgMsHm2nTpkmPHj1k8eLFme5bs2aNjBo1SoYMGWJWIgYAAHDZYLNt2zYZN26c9OvXT55//vlM93/33Xfy9ttvmy0WdGdvAAAAl62x+eyzz8w2ClmFGqVr13Ts2FGSkpJk8uTJ8uijjzqynQAAAI7rsdm/f7+0a9fumudpuDl9+rRcvHgxp5cGAADI32Bz+fJl8fPzu+Z52nNTrFgxgg0AAHDdYFOqVCnZvXv3Nc/T3hpdrC80NPR62wYAAJA3weauu+6SGTNmSFxc3FXP0/qaRo0amZ4bAAAAlww2Wl+je0P16dNH/vjjD9tqw6kOHTokI0aMkC+++EIGDhyYF20FAABwzKyoIkWKyNSpU2XQoEHSs2dPCQwMlNKlS4uHh4ecOnVKoqKipGjRombK9y233JLTywIAADhnS4Xy5cvLl19+Kd9++62sXr1ajh07ZqZ3V6pUyfTkdOrUScLCwhzXOgAAgLzcK8rX11cefPBB8wEAAGCJTTDzwvbt22Xp0qUybNiwdMcPHz4s8+fPl5MnT0qtWrXMUFjhwoWd1k4AAGCRTTDzyokTJ8w+U7/99lu64wcOHJDOnTvLpUuXpHHjxmafKt3WQQuZAQAAXC7YaL3O/fffb9bAyWr6uAaaV199Vbp27SqzZs2Sv//+22y6CQAA4FLBRntkdP+p3r17m53D09Ip5evWrZPmzZvbjoWEhEjDhg3lf//7nxNaCwAAXJnTg01ERIT88MMP8thjj4mnZ/rm6DTyCxcuSJkyZTKtgnzw4MF8bikAAHB1Ti8e9vf3Nx9ZiY2NNZ8z7lGlM7OuZ5NNb2+n5znkA09PD7f+OXt58Tx3B/ye3RO/dxcONleTui1DxkJhve3j42P3m11wcNZBCrCSwEBfZzcBQB7h9V1Ag43W06jz58+nOx4TE2N2ELdHcnKKxMRcckj74Np8fLwkIKCIuKuYmDhJSmL2oDv8z503Offjbq/vwEDfHPdSuXSw0S0adNuGffv2SdOmTW3HdZfxZs2a2X3dxET3eTK4M3fvqtU/ejzXAWvi9Z09l//L36FDB/nss8/k7Nmz5vaPP/4ou3btMscBAAAKTI+N6t+/v2zevFnatGkjFSpUkJ07d8qoUaOkYsWKzm4aAABwMS4VbDp27Ci33357phlQs2fPNtstaK9N1apVpXjx4k5rIwAAcF0uFWwqV66c7X01a9bM17YAAICCx6WCDfKOTnN3t3Vd3O37BQAQbNzmDb5YMT+3nyUEALA+emzcJNjo1Of3IjfJkZMXxF3UrxYufdrUcHYzAAD5iGDjRjTU7D+afrFDKysdHuDsJgAA8pnLr2MDAACQUwQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGd7i4lJSUqRfv34SHx+f7njPnj2ldevWTmsXAABwPS4fbI4ePSo///yzTJ48WYKCgmzHy5Ur59R2AQAA1+PywWbv3r3i5+cnrVq1cnZTAACAi/MsCMGmUqVKzm4GAAAoAFy+x2bPnj2mx+btt9+W/fv3S6lSpaRPnz5SoUIFZzcNAAC4GO+C0GMTFRUl7dq1k5tvvlmWLVsmHTp0kM8++0xq1qxp1zW9vV2+o8qhvLzc6/vFf/i9uwd+z+6J33sBDjajR482vTQRERHmdosWLUyPzfjx42XGjBm5vp6np4cEB/vnQUsB1xIY6OvsJgDII7y+C3CwqV+/fqZjjRo1koULF9p1veTkFImJuSTulux5EbifmJg4SUpKdnYzkMd4fbsnd3t9Bwb65riXyqWDTWxsrDz++OMyZMgQadiwoe34iRMnpESJEnZfNzHRfZ4McF/6R4/nOmBNvL6z59LFFwEBAZKQkCBTpkyRK1eumGPbtm2Tb7/9Vrp16+bs5gEAABfj0j026t1335VnnnlG7rzzTgkPD5eDBw/Kww8/LJ06dXJ20wAAgItx+WBTpkwZWbRokRw5ckSio6PNNO+0KxADAAAUmGCjPDw8TMDRDwAAgAJZYwMAAJAbBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZBBsAAGAZ3lIA/PHHHzJz5kw5efKk1KpVS5566ikJDQ11drMAAICLcfkemy1btki/fv2kYcOGMmzYMDl27Jj06dNH4uPjnd00AADgYlw+2EydOlXatGkjjzzyiDRq1EgmT54sp0+flmXLljm7aQAAwMW4dLBJTEyUjRs3SpMmTWzHihQpIg0aNJD169c7tW0AAMD1uHSwiY6Olri4OLnhhhvSHdfbhw8fdlq7AACAa3Lp4uHY2FhbL01ahQsXNoHHHp6eHhIS4i/uxMPjv8+v9G8siUnJ4i4KF/Iyn2/o9pKkJCWKu/Dw+u9lHRTkKykpzm4N8hqvb17f7sDT8/+/kRX0YOPj42M+JyUlpTuutzOGnZzy8PAQL6+c/4CspFjRwuKOvPyDxB15erp0hywcjNe3e+H1nT2X/ssXFhZmgsjZs2fTHT9z5oyEhIQ4rV0AAMA1uXSw8fPzk8qVK8uOHTvSHd++fbvUqVPHae0CAACuyaWDjeratatERkbKoUOHzO0FCxbI0aNHpXPnzs5uGgAAcDEuXWOjevXqJfv375d27dpJsWLFJDk5WSZOnCgRERHObhoAAHAxHikpBWPexPnz5yUmJsZM9fb2dvk8BgAAnKDABBsAAIACX2MDAACQUwQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGSwIA0vQVQvWrl1rPg4cOCAXL1406x3poo41atSQDh06SKVKlZzdTAB24PWN3GAdGxR48fHxMnDgQNmyZYvUr19fypQpI76+vmaVal3Uce/evWZ/sZEjR0rv3r2d3VwAucDrG7lFjw0KPN0/LCoqSlavXi2hoaFZnrN+/XoZPHiwtGzZ0qxeDaBg4PWN3KLGBgXezp07pUePHtmGGnXbbbdJ3bp1zbkACg5e38gtgg0KvOLFi8vff/99zb3GdEgqODg439oF4Prx+kZuUWODAu/o0aPSqVMnadiwobRo0ULKlSsnfn5+6WpstDtbe3Q+/fRT8fDwcHaTAeQQr2/kFsEGlnDo0CGZPHmy/PTTTybMpFWqVClp3769DBgwQPz9/Z3WRgD24fWN3CDYwHLTQk+fPi2xsbGmZ0Z7aYoWLersZgFwAF7fyAmCDdxGXFycWdvGx8fH2U0B4GC8vpGK4mG4DV3HZtWqVc5uBoA8wOsbqVjHBm6jY8eOUrZsWWc3A0Ae4PWNVAxFAQAAy6DHBpbAXjIAAEWPDQo89pIBAKSixwYFHnvJANY1YcIEWbduXY7OffbZZ6Vp06Z53ia4NoIN3G4vGTbBBAqOe++9V1asWCHHjx+Xnj17ipeXV7bnhoWF5Wvb4JoINijw2EsGsK5q1arJ3LlzpUuXLmarlCeffNLZTYKLo8YGBR57yQDWp9ulPPXUU7J69Wp6ZnBVBBtYAnvJANZ38OBB00MbEBDg7KbAhRFsYCnsJQMA7o1gAwAALIO9ogAAgGUQbAAAgGUQbAAAgGUQbAAAgGWwQB8Au8TGxsovv/wi//zzj3h4eEiZMmXk1ltvlaCgIJdbCkBXq9X2AbA+emwA5Nr3338vLVq0kHnz5kl0dLScOnVK5syZI82bN5fPP//cZX6i+/btk/bt28vhw4ed3RQA+YQeGwC5EhUVZTYb7N+/v1kJNq3JkyfLK6+8IjfddJNZCt8VepV093cA7oNgAyBXNm3aZMJCs2bNMt3Xu3dv81nvP3bsmHz55Zdy9913Zwo5kZGRZgXZVq1aycaNG2X37t1y//33yw8//GC2yNCNSvW+IkWKmOGuv//+2yyjf88994i/v7+5hn7d9u3b5cEHH5SVK1eawFWxYkW58847zdDT/v37ZdGiRebcb775xly3a9eutjbs2rVLtmzZIhcuXJBatWqZYTQdUku9tj1tUtqD9eOPP5r2BAcHS+PGjaVs2bI8y4B8wgJ9AHJFw4CGCQ0Qr7/+erb79qSGn6ZNm8q4ceNsx0+cOGGGrN566y3p2LGjfPDBB/Lpp59K0aJFTcAICQmRL774QipUqCClS5eWc+fOSdWqVWXVqlXi6+srixcvlsKFC5uv0+EvDQ/h4eFSpUoVE3A0ME2fPl3Onj0rM2fONNfq0KGD3HzzzSbYJCYmyqhRo8yO0a1btzbX0n/feOON5pqBgYF2t+n333+XAQMGmN3kK1WqJEeOHDHXfvnll6Vbt24804D8kAIAuTRy5MiUKlWqpNSoUSOlZ8+eKZMmTUr57bffUhISEtKdN2bMmJQ6deqkXLhwwXbsk08+Salbt25KbGysuT116lRzrRkzZtjOmTNnjjn25JNP2o5t3brVHFu1alW6r9O2pDpx4kRKw4YNU0aMGGFu//nnn+ac9evX287Rr6tWrZq5L9WRI0dS6tevn/Lss89eV5u6deuW0r9//3Q/g++++y4lMjKS5xiQTygeBpBrY8eOlWnTpplhJh2ymTJlihmG0h6a1OEf1alTJ7l8+bLptUi1ZMkSadmyZbrhG9W2bVvbvytXrmw+a49KxmM6LJRW2jqfiIgI0wu0fPnybGtrvv76a7n99tulbt26tmOlSpUyvTn6dVqXY2+bdJhqx44d8scff9jOadOmjfTo0SObnyQARyPYALCLhoOJEyfKr7/+aoZpNGBobYsO82hNi9JhHB0i0qEatXfvXhOEdGgoo7RDWnodFRoamulYUlKS7VixYsVMmElLh4suXbokJ0+ezPQY+rU6Q0prcTLSkKL36/CRvW0aNmyY+Pn5Sc+ePc1wmw5Bab1NcnLyVX+WAByHYAMgVxYsWGALKqlv7rVr15YnnnhCvv32W1OPsnDhQtv9nTt3NsW4WkysvTVaA6MFtRmlhoTc8PbOPP8hNURkdZ/u/q4fqUXC1/q63LZJi6S1zmf+/Pmm8FgLjLXmpl+/fuZxAeQ9gg2AXNEemnfffdcU4WakoUZ7PtK+id93330mIOgbvgYfXVfGnhCTFZ2BlHboSB08eNAsEqgFxRkDjIYWXahPZ0xlteaNj4+Pmf10PfQxGzRoIE8++aR89dVXMmTIEFm/fr3pqQKQ9wg2AHKlT58+cubMGTPTKeMQy19//SV//vmnqXNJpUM3Omz10UcfyfHjx7MchrKXBiid+ZR2xpUOg2kvkYanQoUKmeNpQ5je99NPP5nZXam0Rkanput07oy1PzmlPwv9Hjds2JDuuIYlbYuGPgB5j3VsAORK/fr15b333pNXX31V1qxZY6Y2BwQEmK0LtJ7k0UcfNdPB09IwoefqFGlHL9ynQUbXpNGeFi1S1qLg1IJi7Z3RmpcPP/xQfv75Zxk5cqRZWFB7Tx566CFT2KvhR79O2/bSSy/Z3Q5PT08TbnToSde20YJkDUw6JfyZZ54xPUgA8h7BBkCuaSDQdWx03RYd+tGZT1os++KLL2Yq5lU6NJM6SyojXV9m8ODB6Y5pKNBj+jmV9nrosXr16qU7V4e3/ve//5neGg1caet3NHBpYbOGKp2xlNqD8v7778vWrVvNYoPa66O3b7nlFtvQlb1tGjRokJk1pTVFuo6OHtf7y5cvn8ufMAB7sUAfgDyni91peFi7dq0JG46gi+jpNaldAZAWPTYA8ozWrei6LvpZe3McFWoAIDsEGwB5RvdI0plLn3zyiTRq1Mih185quAgAGIoCAACWwXRvAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAABgGQQbAAAgVvH/AHOauY30yb98AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Updated run parameters in /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/run_params.pickle\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Completed Phase 1 - Data Processing\n" + ] + } + ], + "source": [ + "if RUN_PHASES[\"p1\"]:\n", + " print(\"INFO: Starting Phase 1 - Data Processing\")\n", + " P1Runner(\n", + " data_path=CFG[\"data_path\"],\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " exclude_eda_output=P1_EXCLUDE_EDA_OUTPUT,\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " outcome_type=CFG[\"outcome_type\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " match_label=CFG[\"match_label\"],\n", + " n_splits=N_SPLITS,\n", + " partition_method=P1_PARTITION_METHOD,\n", + " ignore_features=P1_IGNORE_FEATURES,\n", + " categorical_features=CFG.get(\"categorical_features\"),\n", + " quantitative_features=CFG.get(\"quantitative_features\"),\n", + " top_features=P1_TOP_FEATURES,\n", + " categorical_cutoff=P1_CATEGORICAL_CUTOFF,\n", + " sig_cutoff=P1_SIG_CUTOFF,\n", + " featureeng_missingness=P1_FEATUREENG_MISSINGNESS,\n", + " cleaning_missingness=P1_CLEANING_MISSINGNESS,\n", + " correlation_removal_threshold=P1_CORRELATION_REMOVAL_THRESHOLD,\n", + " random_state=RANDOM_STATE,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " show_plots=P1_SHOW_PLOTS,\n", + " one_hot_encoding=P1_ONE_HOT_ENCODING,\n", + " cv_provided=P1_CV_PROVIDED,\n", + " cv_input_root=P1_CV_INPUT_ROOT,\n", + " enable_plots=P1_ENABLE_PLOTS,\n", + " plot_missingness=P1_PLOT_MISSINGNESS,\n", + " plot_class_counts=P1_PLOT_CLASS_COUNTS,\n", + " plot_correlation=P1_PLOT_CORRELATION,\n", + " correlation_plot_max_features=P1_CORRELATION_PLOT_MAX_FEATURES,\n", + " plot_univariate=P1_PLOT_UNIVARIATE,\n", + " univariate_top_k=P1_UNIVARIATE_TOP_K,\n", + " plot_anomalies=P1_PLOT_ANOMALIES,\n", + " force=P1_FORCE,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 1 - Data Processing\")\n", + "else:\n", + " print(\"INFO: Phase 1 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "99bf26c6", + "metadata": {}, + "source": [ + "## Phase 2: Impute, Scale, and Balance\n", + "After this cell runs, CV datasets are transformed according to Phase 2 settings:\n", + "\n", + "- missing values are imputed\n", + "- quantitative features are optionally scaled\n", + "- optional SMOTE/SMOTENC balancing is applied to training folds only\n", + "\n", + "The test fold is transformed using objects learned from the training fold to preserve valid CV separation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "84e249c3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Preparing Train and Test for: hcc_survival_CV_0\n", + "INFO: Imputing Missing Values...\n", + "INFO: Scaling Data Values...\n", + "INFO: Saving Processed Train and Test Data...\n", + "INFO: hcc_survival Phase 2 complete\n", + "INFO: Preparing Train and Test for: hcc_survival_CV_1\n", + "INFO: Imputing Missing Values...\n", + "INFO: Scaling Data Values...\n", + "INFO: Saving Processed Train and Test Data...\n", + "INFO: hcc_survival Phase 2 complete\n", + "INFO: Preparing Train and Test for: hcc_survival_CV_2\n", + "INFO: Imputing Missing Values...\n", + "INFO: Scaling Data Values...\n", + "INFO: Saving Processed Train and Test Data...\n", + "INFO: hcc_survival Phase 2 complete\n", + "INFO: Preparing Train and Test for: hcc_survival_copy_CV_0\n", + "INFO: Imputing Missing Values...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Starting Phase 2 - Scaling and Imputation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Scaling Data Values...\n", + "INFO: Saving Processed Train and Test Data...\n", + "INFO: hcc_survival_copy Phase 2 complete\n", + "INFO: Preparing Train and Test for: hcc_survival_copy_CV_1\n", + "INFO: Imputing Missing Values...\n", + "INFO: Scaling Data Values...\n", + "INFO: Saving Processed Train and Test Data...\n", + "INFO: hcc_survival_copy Phase 2 complete\n", + "INFO: Preparing Train and Test for: hcc_survival_copy_CV_2\n", + "INFO: Imputing Missing Values...\n", + "INFO: Scaling Data Values...\n", + "INFO: Saving Processed Train and Test Data...\n", + "INFO: hcc_survival_copy Phase 2 complete\n", + "INFO: Updated run parameters in /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/run_params.pickle\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Completed Phase 2 - Scaling and Imputation\n" + ] + } + ], + "source": [ + "if RUN_PHASES[\"p2\"]:\n", + " print(\"INFO: Starting Phase 2 - Scaling and Imputation\")\n", + " P2Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " scale_data=P2_SCALE_DATA,\n", + " impute_data=P2_IMPUTE_DATA,\n", + " multi_impute=P2_MULTI_IMPUTE,\n", + " overwrite_cv=P2_OVERWRITE_CV,\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " random_state=RANDOM_STATE,\n", + " imputer_id=P2_IMPUTER_ID,\n", + " imputer_params=P2_IMPUTER_PARAMS,\n", + " scaler_id=P2_SCALER_ID,\n", + " scaler_params=P2_SCALER_PARAMS,\n", + " smote=P2_SMOTE,\n", + " smote_method=P2_SMOTE_METHOD,\n", + " smote_sampling_strategy=P2_SMOTE_SAMPLING_STRATEGY,\n", + " smote_k_neighbors=P2_SMOTE_K_NEIGHBORS,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 2 - Scaling and Imputation\")\n", + "else:\n", + " print(\"INFO: Phase 2 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "bbb3a367", + "metadata": {}, + "source": [ + "## Phase 3: Feature Learning\n", + "After this cell runs, learned representations such as PCA features are created per CV split. These learned features can replace or augment the original features depending on `P3_KEEP_ORIGINAL_FEATURES`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "83e93fd6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Phase 3 starting for experiment 'JupyterRun' with learner 'pca' and namespace 'FL_PCA'.\n", + "INFO: Phase 3 discovered 6 CV train/test pairs across 2 dataset(s): hcc_survival, hcc_survival_copy\n", + "INFO: Phase 3 submitting 6 jobs in mode 'Serial'.\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_CV_0_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_CV_0\n", + "INFO: Running Feature Learning (pca)...\n", + "INFO: Principal components added: 46 (cumulative explained variance: 1.000)\n", + "INFO: Feature learning summary for hcc_survival_CV_0: input=57, PCs=46, keep_original=True, final_features=103, train_shape=(88, 105), test_shape=(44, 105)\n", + "INFO: hcc_survival CV0 phase 3 pca evaluation complete\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_CV_1_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_CV_1\n", + "INFO: Running Feature Learning (pca)...\n", + "INFO: Principal components added: 46 (cumulative explained variance: 1.000)\n", + "INFO: Feature learning summary for hcc_survival_CV_1: input=57, PCs=46, keep_original=True, final_features=103, train_shape=(88, 105), test_shape=(44, 105)\n", + "INFO: hcc_survival CV1 phase 3 pca evaluation complete\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_CV_2_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_CV_2\n", + "INFO: Running Feature Learning (pca)...\n", + "INFO: Principal components added: 46 (cumulative explained variance: 1.000)\n", + "INFO: Feature learning summary for hcc_survival_CV_2: input=57, PCs=46, keep_original=True, final_features=103, train_shape=(88, 105), test_shape=(44, 105)\n", + "INFO: hcc_survival CV2 phase 3 pca evaluation complete\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_copy_CV_0_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_copy_CV_0\n", + "INFO: Running Feature Learning (pca)...\n", + "INFO: Principal components added: 46 (cumulative explained variance: 1.000)\n", + "INFO: Feature learning summary for hcc_survival_copy_CV_0: input=57, PCs=46, keep_original=True, final_features=103, train_shape=(88, 105), test_shape=(44, 105)\n", + "INFO: hcc_survival_copy CV0 phase 3 pca evaluation complete\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_copy_CV_1_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_copy_CV_1\n", + "INFO: Running Feature Learning (pca)...\n", + "INFO: Principal components added: 46 (cumulative explained variance: 1.000)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Starting Phase 3 - Feature Learning\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Feature learning summary for hcc_survival_copy_CV_1: input=57, PCs=46, keep_original=True, final_features=103, train_shape=(88, 105), test_shape=(44, 105)\n", + "INFO: hcc_survival_copy CV1 phase 3 pca evaluation complete\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_copy_CV_2_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_copy_CV_2\n", + "INFO: Running Feature Learning (pca)...\n", + "INFO: Principal components added: 46 (cumulative explained variance: 1.000)\n", + "INFO: Feature learning summary for hcc_survival_copy_CV_2: input=57, PCs=46, keep_original=True, final_features=103, train_shape=(88, 105), test_shape=(44, 105)\n", + "INFO: hcc_survival_copy CV2 phase 3 pca evaluation complete\n", + "INFO: Phase 3 completed: 6 jobs finished.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Completed Phase 3 - Feature Learning\n" + ] + } + ], + "source": [ + "if RUN_PHASES[\"p3\"]:\n", + " print(\"INFO: Starting Phase 3 - Feature Learning\")\n", + " P3Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " learner_id=P3_LEARNER_ID,\n", + " learner_params=P3_LEARNER_PARAMS,\n", + " feature_namespace=P3_FEATURE_NAMESPACE,\n", + " keep_original_features=P3_KEEP_ORIGINAL_FEATURES,\n", + " overwrite_cv=P3_OVERWRITE_CV,\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " random_state=RANDOM_STATE,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 3 - Feature Learning\")\n", + "else:\n", + " print(\"INFO: Phase 3 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "5e1e88fe", + "metadata": {}, + "source": [ + "## Phase 4: Feature Importance\n", + "After this cell runs, feature-importance scores are saved for each active method and CV split. These outputs feed Phase 5 feature selection, summary statistics, and report tables/figures.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "c6de611f", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Phase 4 starting for experiment 'JupyterRun' with models: mutualinformation, multiswrfdb\n", + "INFO: Phase 4 discovered 6 CV train/test pairs.\n", + "INFO: Phase 4 submitting 12 jobs in mode 'Serial'.\n", + "INFO: Phase 4 running model 'mutualinformation' on hcc_survival [hcc_survival_CV_0].\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_CV_0_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_CV_0\n", + "INFO: Running mutualinformation...\n", + "INFO: Sort and pickle feature importance scores...\n", + "INFO: hcc_survival CV0 phase 4 mutualinformation evaluation complete\n", + "INFO: Phase 4 completed model 'mutualinformation' on hcc_survival [hcc_survival_CV_0].\n", + "INFO: Phase 4 running model 'multiswrfdb' on hcc_survival [hcc_survival_CV_0].\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_CV_0_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_CV_0\n", + "INFO: Phase 4 multiswrfdb passing 36 STREAMLINE categorical feature index(es) to ReBATE.\n", + "INFO: Running multiswrfdb...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Starting Phase 4 - Feature Importance\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Sort and pickle feature importance scores...\n", + "INFO: hcc_survival CV0 phase 4 multiswrfdb evaluation complete\n", + "INFO: Phase 4 completed model 'multiswrfdb' on hcc_survival [hcc_survival_CV_0].\n", + "INFO: Phase 4 running model 'mutualinformation' on hcc_survival [hcc_survival_CV_1].\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_CV_1_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_CV_1\n", + "INFO: Running mutualinformation...\n", + "INFO: Sort and pickle feature importance scores...\n", + "INFO: hcc_survival CV1 phase 4 mutualinformation evaluation complete\n", + "INFO: Phase 4 completed model 'mutualinformation' on hcc_survival [hcc_survival_CV_1].\n", + "INFO: Phase 4 running model 'multiswrfdb' on hcc_survival [hcc_survival_CV_1].\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_CV_1_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_CV_1\n", + "INFO: Phase 4 multiswrfdb passing 36 STREAMLINE categorical feature index(es) to ReBATE.\n", + "INFO: Running multiswrfdb...\n", + "INFO: Sort and pickle feature importance scores...\n", + "INFO: hcc_survival CV1 phase 4 multiswrfdb evaluation complete\n", + "INFO: Phase 4 completed model 'multiswrfdb' on hcc_survival [hcc_survival_CV_1].\n", + "INFO: Phase 4 running model 'mutualinformation' on hcc_survival [hcc_survival_CV_2].\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_CV_2_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_CV_2\n", + "INFO: Running mutualinformation...\n", + "INFO: Sort and pickle feature importance scores...\n", + "INFO: hcc_survival CV2 phase 4 mutualinformation evaluation complete\n", + "INFO: Phase 4 completed model 'mutualinformation' on hcc_survival [hcc_survival_CV_2].\n", + "INFO: Phase 4 running model 'multiswrfdb' on hcc_survival [hcc_survival_CV_2].\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_CV_2_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_CV_2\n", + "INFO: Phase 4 multiswrfdb passing 36 STREAMLINE categorical feature index(es) to ReBATE.\n", + "INFO: Running multiswrfdb...\n", + "INFO: Sort and pickle feature importance scores...\n", + "INFO: hcc_survival CV2 phase 4 multiswrfdb evaluation complete\n", + "INFO: Phase 4 completed model 'multiswrfdb' on hcc_survival [hcc_survival_CV_2].\n", + "INFO: Phase 4 running model 'mutualinformation' on hcc_survival_copy [hcc_survival_copy_CV_0].\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_copy_CV_0_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_copy_CV_0\n", + "INFO: Running mutualinformation...\n", + "INFO: Sort and pickle feature importance scores...\n", + "INFO: hcc_survival_copy CV0 phase 4 mutualinformation evaluation complete\n", + "INFO: Phase 4 completed model 'mutualinformation' on hcc_survival_copy [hcc_survival_copy_CV_0].\n", + "INFO: Phase 4 running model 'multiswrfdb' on hcc_survival_copy [hcc_survival_copy_CV_0].\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_copy_CV_0_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_copy_CV_0\n", + "INFO: Phase 4 multiswrfdb passing 36 STREAMLINE categorical feature index(es) to ReBATE.\n", + "INFO: Running multiswrfdb...\n", + "INFO: Sort and pickle feature importance scores...\n", + "INFO: hcc_survival_copy CV0 phase 4 multiswrfdb evaluation complete\n", + "INFO: Phase 4 completed model 'multiswrfdb' on hcc_survival_copy [hcc_survival_copy_CV_0].\n", + "INFO: Phase 4 running model 'mutualinformation' on hcc_survival_copy [hcc_survival_copy_CV_1].\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_copy_CV_1_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_copy_CV_1\n", + "INFO: Running mutualinformation...\n", + "INFO: Sort and pickle feature importance scores...\n", + "INFO: hcc_survival_copy CV1 phase 4 mutualinformation evaluation complete\n", + "INFO: Phase 4 completed model 'mutualinformation' on hcc_survival_copy [hcc_survival_copy_CV_1].\n", + "INFO: Phase 4 running model 'multiswrfdb' on hcc_survival_copy [hcc_survival_copy_CV_1].\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_copy_CV_1_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_copy_CV_1\n", + "INFO: Phase 4 multiswrfdb passing 36 STREAMLINE categorical feature index(es) to ReBATE.\n", + "INFO: Running multiswrfdb...\n", + "INFO: Sort and pickle feature importance scores...\n", + "INFO: hcc_survival_copy CV1 phase 4 multiswrfdb evaluation complete\n", + "INFO: Phase 4 completed model 'multiswrfdb' on hcc_survival_copy [hcc_survival_copy_CV_1].\n", + "INFO: Phase 4 running model 'mutualinformation' on hcc_survival_copy [hcc_survival_copy_CV_2].\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_copy_CV_2_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_copy_CV_2\n", + "INFO: Running mutualinformation...\n", + "INFO: Sort and pickle feature importance scores...\n", + "INFO: hcc_survival_copy CV2 phase 4 mutualinformation evaluation complete\n", + "INFO: Phase 4 completed model 'mutualinformation' on hcc_survival_copy [hcc_survival_copy_CV_2].\n", + "INFO: Phase 4 running model 'multiswrfdb' on hcc_survival_copy [hcc_survival_copy_CV_2].\n", + "INFO: -------------------------------------------------------\n", + "INFO: Loading Dataset: hcc_survival_copy_CV_2_Train\n", + "INFO: Prepared Train and Test for: hcc_survival_copy_CV_2\n", + "INFO: Phase 4 multiswrfdb passing 36 STREAMLINE categorical feature index(es) to ReBATE.\n", + "INFO: Running multiswrfdb...\n", + "INFO: Sort and pickle feature importance scores...\n", + "INFO: hcc_survival_copy CV2 phase 4 multiswrfdb evaluation complete\n", + "INFO: Phase 4 completed model 'multiswrfdb' on hcc_survival_copy [hcc_survival_copy_CV_2].\n", + "INFO: Phase 4 completed: 12 jobs finished.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Completed Phase 4 - Feature Importance\n" + ] + } + ], + "source": [ + "if RUN_PHASES[\"p4\"]:\n", + " p4_model_params = P4_MODELS_PARAMS\n", + " if isinstance(p4_model_params, dict):\n", + " p4_model_params = {k: dict(v) for k, v in p4_model_params.items()}\n", + " if p4_model_params.get(\"mutualinformation\", {}).get(\"outcome_type\") == \"auto\":\n", + " p4_model_params[\"mutualinformation\"][\"outcome_type\"] = CFG[\"outcome_type\"]\n", + " print(\"INFO: Starting Phase 4 - Feature Importance\")\n", + " P4Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " models=P4_MODELS,\n", + " models_params=p4_model_params,\n", + " top_k=P4_TOP_K,\n", + " threshold=P4_THRESHOLD,\n", + " keep_original_features=P4_KEEP_ORIGINAL_FEATURES,\n", + " overwrite_cv=P4_OVERWRITE_CV,\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " outcome_type=CFG[\"outcome_type\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " random_state=RANDOM_STATE,\n", + " instance_subset=P4_INSTANCE_SUBSET,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 4 - Feature Importance\")\n", + "else:\n", + " print(\"INFO: Phase 4 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "393c1c24", + "metadata": {}, + "source": [ + "## Phase 5: Feature Selection\n", + "After this cell runs, selected feature subsets and informative feature summaries are generated. If filtering is disabled, all features continue to modeling; otherwise STREAMLINE uses the FI outputs to remove weakly supported features.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "447337ed", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Phase 5 starting for experiment 'JupyterRun'.\n", + "INFO: Phase 5 discovered 2 dataset(s).\n", + "INFO: Phase 5 discovered algorithms for hcc_survival: multiswrfdb, mutualinformation\n", + "INFO: Phase 5 running on dataset hcc_survival with algorithms: multiswrfdb, mutualinformation\n", + "INFO: Phase 5 running selector 'default' for dataset 'hcc_survival' with algorithms: multiswrfdb, mutualinformation\n", + "INFO: Plotting Feature Importance Scores for multiswrfdb...\n", + "INFO: Feature Importance\n", + " AlkalinePhosphatase 0.059959\n", + " LiverMetastasis 0.041164\n", + " FL_PCA_PC3 0.039757\n", + " FL_PCA_PC9 0.033230\n", + " AspartateTransaminase 0.029609\n", + " AscitesDegree_1.0 0.027907\n", + " PerformanceStatus_3 0.026872\n", + "InternationalNormalisedRatio 0.020335\n", + " GammaGlutamylTransferase 0.019873\n", + " PerformanceStatus_0 0.018781\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Starting Phase 5 - Feature Selection\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Saved Feature Importance Plots at\n", + "INFO: /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival/feature_importance/multiswrfdb/TopAverageScores.png\n", + "INFO: Plotting Feature Importance Scores for mutualinformation...\n", + "INFO: Feature Importance\n", + " AlphaFetoprotein 0.116360\n", + "MeanCorpuscularVolume 0.102160\n", + " Hemoglobin 0.074792\n", + " LiverMetastasis 0.074402\n", + " FL_PCA_PC3 0.074359\n", + " FL_PCA_PC46 0.069643\n", + " AlkalinePhosphatase 0.068312\n", + " PortalVeinThrombosis 0.056656\n", + " Alcohol 0.053930\n", + " FL_PCA_PC4 0.051635\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Saved Feature Importance Plots at\n", + "INFO: /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival/feature_importance/mutualinformation/TopAverageScores.png\n", + "INFO: Applying collective feature selection...\n", + "INFO: hcc_survival Phase 5 complete\n", + "INFO: Phase 5 completed for dataset hcc_survival.\n", + "INFO: Phase 5 discovered algorithms for hcc_survival_copy: multiswrfdb, mutualinformation\n", + "INFO: Phase 5 running on dataset hcc_survival_copy with algorithms: multiswrfdb, mutualinformation\n", + "INFO: Phase 5 running selector 'default' for dataset 'hcc_survival_copy' with algorithms: multiswrfdb, mutualinformation\n", + "INFO: Plotting Feature Importance Scores for multiswrfdb...\n", + "INFO: Feature Importance\n", + " AlkalinePhosphatase 0.059959\n", + " LiverMetastasis 0.041164\n", + " FL_PCA_PC3 0.039757\n", + " FL_PCA_PC9 0.033230\n", + " AspartateTransaminase 0.029609\n", + " AscitesDegree_1.0 0.027907\n", + " PerformanceStatus_3 0.026872\n", + "InternationalNormalisedRatio 0.020335\n", + " GammaGlutamylTransferase 0.019873\n", + " PerformanceStatus_0 0.018781\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Saved Feature Importance Plots at\n", + "INFO: /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival_copy/feature_importance/multiswrfdb/TopAverageScores.png\n", + "INFO: Plotting Feature Importance Scores for mutualinformation...\n", + "INFO: Feature Importance\n", + " AlphaFetoprotein 0.116360\n", + "MeanCorpuscularVolume 0.102160\n", + " Hemoglobin 0.074792\n", + " LiverMetastasis 0.074402\n", + " FL_PCA_PC3 0.074359\n", + " FL_PCA_PC46 0.069643\n", + " AlkalinePhosphatase 0.068312\n", + " PortalVeinThrombosis 0.056656\n", + " Alcohol 0.053930\n", + " FL_PCA_PC4 0.051635\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Saved Feature Importance Plots at\n", + "INFO: /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival_copy/feature_importance/mutualinformation/TopAverageScores.png\n", + "INFO: Applying collective feature selection...\n", + "INFO: hcc_survival_copy Phase 5 complete\n", + "INFO: Phase 5 completed for dataset hcc_survival_copy.\n", + "INFO: Phase 5 completed for experiment 'JupyterRun'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Completed Phase 5 - Feature Selection\n" + ] + } + ], + "source": [ + "if RUN_PHASES[\"p5\"]:\n", + " print(\"INFO: Starting Phase 5 - Feature Selection\")\n", + " P5Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " algorithms=P5_ALGORITHMS,\n", + " n_splits=P5_N_SPLITS,\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " max_features_to_keep=P5_MAX_FEATURES_TO_KEEP,\n", + " filter_poor_features=P5_FILTER_POOR_FEATURES,\n", + " overwrite_cv=P5_OVERWRITE_CV,\n", + " selector_id=P5_SELECTOR_ID,\n", + " selector_params=P5_SELECTOR_PARAMS,\n", + " export_scores=P5_EXPORT_SCORES,\n", + " top_features=P5_TOP_FEATURES,\n", + " show_plots=P5_SHOW_PLOTS,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " strict_discovery=P5_STRICT_DISCOVERY,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 5 - Feature Selection\")\n", + "else:\n", + " print(\"INFO: Phase 5 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "3d518662", + "metadata": {}, + "source": [ + "## Phase 6: Modeling\n", + "After this cell runs, STREAMLINE trains and evaluates each requested model across CV splits. Outputs include trained model pickles, metrics, ROC/PRC or regression artifacts, Optuna trial summaries, and model feature-importance estimates.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "f5bf4057", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Starting Phase 6 - Modeling\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running NB on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival/CVDatasets/hcc_survival_CV_0_Train.csv\n", + "INFO: hcc_survival [CV_0] (NB) training complete. ------------------------------------\n", + "INFO: Running NB on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival/CVDatasets/hcc_survival_CV_1_Train.csv\n", + "INFO: hcc_survival [CV_1] (NB) training complete. ------------------------------------\n", + "INFO: Running NB on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival/CVDatasets/hcc_survival_CV_2_Train.csv\n", + "INFO: hcc_survival [CV_2] (NB) training complete. ------------------------------------\n", + "INFO: Running LR on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival/CVDatasets/hcc_survival_CV_0_Train.csv\n", + "INFO: Best trial:\n", + "INFO: Value: 0.7272727272727272\n", + "INFO: Params: \n", + "INFO: solver: liblinear\n", + "INFO: C: 0.0006580360277501316\n", + "INFO: class_weight: balanced\n", + "INFO: max_iter: 109\n", + "INFO: random_state: 42\n", + "INFO: penalty: l2\n", + "INFO: dual: True\n", + "INFO: LR CV_0 Optuna trials: 50 run, 50 complete, requested=50, timeout=300\n", + "INFO: hcc_survival [CV_0] (LR) training complete. ------------------------------------\n", + "INFO: Running LR on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival/CVDatasets/hcc_survival_CV_1_Train.csv\n", + "INFO: Best trial:\n", + "INFO: Value: 0.8369661527556264\n", + "INFO: Params: \n", + "INFO: solver: lbfgs\n", + "INFO: C: 0.0003630322466779861\n", + "INFO: class_weight: balanced\n", + "INFO: max_iter: 156\n", + "INFO: random_state: 42\n", + "INFO: LR CV_1 Optuna trials: 50 run, 50 complete, requested=50, timeout=300\n", + "INFO: hcc_survival [CV_1] (LR) training complete. ------------------------------------\n", + "INFO: Running LR on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival/CVDatasets/hcc_survival_CV_2_Train.csv\n", + "INFO: Best trial:\n", + "INFO: Value: 0.7710880737196527\n", + "INFO: Params: \n", + "INFO: solver: liblinear\n", + "INFO: C: 0.002445684977900814\n", + "INFO: class_weight: None\n", + "INFO: max_iter: 851\n", + "INFO: random_state: 42\n", + "INFO: penalty: l2\n", + "INFO: dual: False\n", + "INFO: LR CV_2 Optuna trials: 50 run, 50 complete, requested=50, timeout=300\n", + "INFO: hcc_survival [CV_2] (LR) training complete. ------------------------------------\n", + "INFO: Running DT on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival/CVDatasets/hcc_survival_CV_0_Train.csv\n", + "INFO: Best trial:\n", + "INFO: Value: 0.6835016835016835\n", + "INFO: Params: \n", + "INFO: criterion: entropy\n", + "INFO: splitter: random\n", + "INFO: max_depth: 5\n", + "INFO: min_samples_split: 24\n", + "INFO: min_samples_leaf: 5\n", + "INFO: max_features: log2\n", + "INFO: class_weight: balanced\n", + "INFO: random_state: 42\n", + "INFO: DT CV_0 Optuna trials: 50 run, 50 complete, requested=50, timeout=300\n", + "INFO: hcc_survival [CV_0] (DT) training complete. ------------------------------------\n", + "INFO: Running DT on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival/CVDatasets/hcc_survival_CV_1_Train.csv\n", + "INFO: Best trial:\n", + "INFO: Value: 0.7404306220095694\n", + "INFO: Params: \n", + "INFO: criterion: gini\n", + "INFO: splitter: best\n", + "INFO: max_depth: 4\n", + "INFO: min_samples_split: 26\n", + "INFO: min_samples_leaf: 2\n", + "INFO: max_features: None\n", + "INFO: class_weight: balanced\n", + "INFO: random_state: 42\n", + "INFO: DT CV_1 Optuna trials: 50 run, 50 complete, requested=50, timeout=300\n", + "INFO: hcc_survival [CV_1] (DT) training complete. ------------------------------------\n", + "INFO: Running DT on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival/CVDatasets/hcc_survival_CV_2_Train.csv\n", + "INFO: Best trial:\n", + "INFO: Value: 0.700735424419635\n", + "INFO: Params: \n", + "INFO: criterion: gini\n", + "INFO: splitter: best\n", + "INFO: max_depth: 28\n", + "INFO: min_samples_split: 21\n", + "INFO: min_samples_leaf: 16\n", + "INFO: max_features: None\n", + "INFO: class_weight: balanced\n", + "INFO: random_state: 42\n", + "INFO: DT CV_2 Optuna trials: 50 run, 50 complete, requested=50, timeout=300\n", + "INFO: hcc_survival [CV_2] (DT) training complete. ------------------------------------\n", + "INFO: Running NB on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival_copy/CVDatasets/hcc_survival_copy_CV_0_Train.csv\n", + "INFO: hcc_survival_copy [CV_0] (NB) training complete. ------------------------------------\n", + "INFO: Running NB on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival_copy/CVDatasets/hcc_survival_copy_CV_1_Train.csv\n", + "INFO: hcc_survival_copy [CV_1] (NB) training complete. ------------------------------------\n", + "INFO: Running NB on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival_copy/CVDatasets/hcc_survival_copy_CV_2_Train.csv\n", + "INFO: hcc_survival_copy [CV_2] (NB) training complete. ------------------------------------\n", + "INFO: Running LR on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival_copy/CVDatasets/hcc_survival_copy_CV_0_Train.csv\n", + "INFO: Best trial:\n", + "INFO: Value: 0.7272727272727272\n", + "INFO: Params: \n", + "INFO: solver: liblinear\n", + "INFO: C: 0.0006580360277501316\n", + "INFO: class_weight: balanced\n", + "INFO: max_iter: 109\n", + "INFO: random_state: 42\n", + "INFO: penalty: l2\n", + "INFO: dual: True\n", + "INFO: LR CV_0 Optuna trials: 50 run, 50 complete, requested=50, timeout=300\n", + "INFO: hcc_survival_copy [CV_0] (LR) training complete. ------------------------------------\n", + "INFO: Running LR on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival_copy/CVDatasets/hcc_survival_copy_CV_1_Train.csv\n", + "INFO: Best trial:\n", + "INFO: Value: 0.8369661527556264\n", + "INFO: Params: \n", + "INFO: solver: lbfgs\n", + "INFO: C: 0.0003630322466779861\n", + "INFO: class_weight: balanced\n", + "INFO: max_iter: 156\n", + "INFO: random_state: 42\n", + "INFO: LR CV_1 Optuna trials: 50 run, 50 complete, requested=50, timeout=300\n", + "INFO: hcc_survival_copy [CV_1] (LR) training complete. ------------------------------------\n", + "INFO: Running LR on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival_copy/CVDatasets/hcc_survival_copy_CV_2_Train.csv\n", + "INFO: Best trial:\n", + "INFO: Value: 0.7710880737196527\n", + "INFO: Params: \n", + "INFO: solver: liblinear\n", + "INFO: C: 0.002445684977900814\n", + "INFO: class_weight: None\n", + "INFO: max_iter: 851\n", + "INFO: random_state: 42\n", + "INFO: penalty: l2\n", + "INFO: dual: False\n", + "INFO: LR CV_2 Optuna trials: 50 run, 50 complete, requested=50, timeout=300\n", + "INFO: hcc_survival_copy [CV_2] (LR) training complete. ------------------------------------\n", + "INFO: Running DT on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival_copy/CVDatasets/hcc_survival_copy_CV_0_Train.csv\n", + "INFO: Best trial:\n", + "INFO: Value: 0.6835016835016835\n", + "INFO: Params: \n", + "INFO: criterion: entropy\n", + "INFO: splitter: random\n", + "INFO: max_depth: 5\n", + "INFO: min_samples_split: 24\n", + "INFO: min_samples_leaf: 5\n", + "INFO: max_features: log2\n", + "INFO: class_weight: balanced\n", + "INFO: random_state: 42\n", + "INFO: DT CV_0 Optuna trials: 50 run, 50 complete, requested=50, timeout=300\n", + "INFO: hcc_survival_copy [CV_0] (DT) training complete. ------------------------------------\n", + "INFO: Running DT on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival_copy/CVDatasets/hcc_survival_copy_CV_1_Train.csv\n", + "INFO: Best trial:\n", + "INFO: Value: 0.7404306220095694\n", + "INFO: Params: \n", + "INFO: criterion: gini\n", + "INFO: splitter: best\n", + "INFO: max_depth: 4\n", + "INFO: min_samples_split: 26\n", + "INFO: min_samples_leaf: 2\n", + "INFO: max_features: None\n", + "INFO: class_weight: balanced\n", + "INFO: random_state: 42\n", + "INFO: DT CV_1 Optuna trials: 50 run, 50 complete, requested=50, timeout=300\n", + "INFO: hcc_survival_copy [CV_1] (DT) training complete. ------------------------------------\n", + "INFO: Running DT on /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival_copy/CVDatasets/hcc_survival_copy_CV_2_Train.csv\n", + "INFO: Best trial:\n", + "INFO: Value: 0.700735424419635\n", + "INFO: Params: \n", + "INFO: criterion: gini\n", + "INFO: splitter: best\n", + "INFO: max_depth: 28\n", + "INFO: min_samples_split: 21\n", + "INFO: min_samples_leaf: 16\n", + "INFO: max_features: None\n", + "INFO: class_weight: balanced\n", + "INFO: random_state: 42\n", + "INFO: DT CV_2 Optuna trials: 50 run, 50 complete, requested=50, timeout=300\n", + "INFO: hcc_survival_copy [CV_2] (DT) training complete. ------------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Completed Phase 6 - Modeling\n" + ] + } + ], + "source": [ + "if RUN_PHASES[\"p6\"]:\n", + " print(\"INFO: Starting Phase 6 - Modeling\")\n", + " P6Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " outcome_type=P6_OUTCOME_TYPE or CFG[\"outcome_type\"],\n", + " model_type=P6_MODEL_TYPE,\n", + " instance_label=CFG[\"instance_label\"],\n", + " n_splits=N_SPLITS,\n", + " models=P6_MODELS or CFG[\"p6_models\"],\n", + " model_params_json=P6_MODEL_PARAMS_JSON,\n", + " calibrate=P6_CALIBRATE,\n", + " calibrate_method=P6_CALIBRATE_METHOD,\n", + " calibrate_cv=P6_CALIBRATE_CV,\n", + " scoring_metric=P6_SCORING_METRIC or CFG[\"p6_scoring_metric\"],\n", + " metric_direction=P6_METRIC_DIRECTION or CFG[\"p6_metric_direction\"],\n", + " n_trials=P6_N_TRIALS,\n", + " timeout=P6_TIMEOUT,\n", + " training_subsample=P6_TRAINING_SUBSAMPLE,\n", + " uniform_fi=P6_UNIFORM_FI,\n", + " save_plot=P6_SAVE_PLOT,\n", + " random_state=RANDOM_STATE,\n", + " bypass_one_hot_for_native_models=P6_BYPASS_ONE_HOT_FOR_NATIVE_MODELS,\n", + " native_categorical_models=P6_NATIVE_CATEGORICAL_MODELS,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 6 - Modeling\")\n", + "else:\n", + " print(\"INFO: Phase 6 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "6d9ec8b1", + "metadata": {}, + "source": [ + "## Phase 7: Ensembles\n", + "Optional phase. After this cell runs, ensemble metrics and curves are generated from Phase 6 base models when enabled. The notebook skips this phase for regression unless `ALLOW_P7_FOR_REGRESSION=True`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "e761233e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: [P7] hcc_survival CV=0: loading base estimators...\n", + "INFO: [P7] Building ensemble: Hard Ensemble Voting using 3 base models\n", + "WARNING: Failed to compute ROC AUC from hard predictions; setting to None.\n", + "WARNING: y should be a 1d array, got an array of shape (44, 2) instead.\n", + "INFO: [P7] Saved ensemble metrics/curves for HEV CV=0\n", + "INFO: [P7] Building ensemble: Soft Ensemble Voting using 3 base models\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Evaluating Phase 7 - Ensembles\n", + "INFO: Starting Phase 7 - Ensembles\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: [P7] Saved ensemble metrics/curves for SEV CV=0\n", + "INFO: [P7] Building ensemble: StackingLogReg using 3 base models\n", + "INFO: [P7] Building ensemble (stacking): StackingLogReg [meta on train]\n", + "INFO: [P7] Saved ensemble metrics/curves for STK_LR CV=0\n", + "INFO: [P7] hcc_survival CV=1: loading base estimators...\n", + "INFO: [P7] Building ensemble: Hard Ensemble Voting using 3 base models\n", + "WARNING: Failed to compute ROC AUC from hard predictions; setting to None.\n", + "WARNING: y should be a 1d array, got an array of shape (44, 2) instead.\n", + "INFO: [P7] Saved ensemble metrics/curves for HEV CV=1\n", + "INFO: [P7] Building ensemble: Soft Ensemble Voting using 3 base models\n", + "INFO: [P7] Saved ensemble metrics/curves for SEV CV=1\n", + "INFO: [P7] Building ensemble: StackingLogReg using 3 base models\n", + "INFO: [P7] Building ensemble (stacking): StackingLogReg [meta on train]\n", + "INFO: [P7] Saved ensemble metrics/curves for STK_LR CV=1\n", + "INFO: [P7] hcc_survival CV=2: loading base estimators...\n", + "INFO: [P7] Building ensemble: Hard Ensemble Voting using 3 base models\n", + "WARNING: Failed to compute ROC AUC from hard predictions; setting to None.\n", + "WARNING: y should be a 1d array, got an array of shape (44, 2) instead.\n", + "INFO: [P7] Saved ensemble metrics/curves for HEV CV=2\n", + "INFO: [P7] Building ensemble: Soft Ensemble Voting using 3 base models\n", + "INFO: [P7] Saved ensemble metrics/curves for SEV CV=2\n", + "INFO: [P7] Building ensemble: StackingLogReg using 3 base models\n", + "INFO: [P7] Building ensemble (stacking): StackingLogReg [meta on train]\n", + "INFO: [P7] Saved ensemble metrics/curves for STK_LR CV=2\n", + "INFO: [P7] hcc_survival_copy CV=0: loading base estimators...\n", + "INFO: [P7] Building ensemble: Hard Ensemble Voting using 3 base models\n", + "WARNING: Failed to compute ROC AUC from hard predictions; setting to None.\n", + "WARNING: y should be a 1d array, got an array of shape (44, 2) instead.\n", + "INFO: [P7] Saved ensemble metrics/curves for HEV CV=0\n", + "INFO: [P7] Building ensemble: Soft Ensemble Voting using 3 base models\n", + "INFO: [P7] Saved ensemble metrics/curves for SEV CV=0\n", + "INFO: [P7] Building ensemble: StackingLogReg using 3 base models\n", + "INFO: [P7] Building ensemble (stacking): StackingLogReg [meta on train]\n", + "INFO: [P7] Saved ensemble metrics/curves for STK_LR CV=0\n", + "INFO: [P7] hcc_survival_copy CV=1: loading base estimators...\n", + "INFO: [P7] Building ensemble: Hard Ensemble Voting using 3 base models\n", + "WARNING: Failed to compute ROC AUC from hard predictions; setting to None.\n", + "WARNING: y should be a 1d array, got an array of shape (44, 2) instead.\n", + "INFO: [P7] Saved ensemble metrics/curves for HEV CV=1\n", + "INFO: [P7] Building ensemble: Soft Ensemble Voting using 3 base models\n", + "INFO: [P7] Saved ensemble metrics/curves for SEV CV=1\n", + "INFO: [P7] Building ensemble: StackingLogReg using 3 base models\n", + "INFO: [P7] Building ensemble (stacking): StackingLogReg [meta on train]\n", + "INFO: [P7] Saved ensemble metrics/curves for STK_LR CV=1\n", + "INFO: [P7] hcc_survival_copy CV=2: loading base estimators...\n", + "INFO: [P7] Building ensemble: Hard Ensemble Voting using 3 base models\n", + "WARNING: Failed to compute ROC AUC from hard predictions; setting to None.\n", + "WARNING: y should be a 1d array, got an array of shape (44, 2) instead.\n", + "INFO: [P7] Saved ensemble metrics/curves for HEV CV=2\n", + "INFO: [P7] Building ensemble: Soft Ensemble Voting using 3 base models\n", + "INFO: [P7] Saved ensemble metrics/curves for SEV CV=2\n", + "INFO: [P7] Building ensemble: StackingLogReg using 3 base models\n", + "INFO: [P7] Building ensemble (stacking): StackingLogReg [meta on train]\n", + "INFO: [P7] Saved ensemble metrics/curves for STK_LR CV=2\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Completed Phase 7 - Ensembles\n" + ] + } + ], + "source": [ + "print(\"INFO: Evaluating Phase 7 - Ensembles\")\n", + "run_p7 = RUN_PHASES[\"p7\"] and P7_ENABLED\n", + "if CFG[\"task_family\"] == \"regression\" and not ALLOW_P7_FOR_REGRESSION:\n", + " run_p7 = False\n", + " print(\"INFO: Phase 7 skipped for regression (ALLOW_P7_FOR_REGRESSION=False)\")\n", + "\n", + "if run_p7:\n", + " print(\"INFO: Starting Phase 7 - Ensembles\")\n", + " P7Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " n_splits=N_SPLITS,\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " ensembles=P7_ENSEMBLES,\n", + " base_models=(P7_BASE_MODELS or CFG[\"p6_models\"]),\n", + " meta_train_source=P7_META_TRAIN_SOURCE,\n", + " calibrate=P7_CALIBRATE,\n", + " calibrate_method=P7_CALIBRATE_METHOD,\n", + " calibrate_cv=P7_CALIBRATE_CV,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " random_state=RANDOM_STATE,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 7 - Ensembles\")\n", + "elif RUN_PHASES[\"p7\"]:\n", + " print(\"INFO: Phase 7 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "70847b9b", + "metadata": {}, + "source": [ + "## Phase 8: Summary Statistics\n", + "After this cell runs, STREAMLINE creates per-dataset performance summaries and post-analysis figures, including model comparison plots and feature-importance summaries used by the final report.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "d9ae7aaf", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running Statistics Summary for hcc_survival\n", + "INFO: Running stats on Decision Tree\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Starting Phase 8 - Summary Statistics\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running stats on Logistic Regression\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running stats on Naive Bayes\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4kAAAIWCAYAAAD6ach3AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAmoVJREFUeJzt3Qd4U2X/xvFf2SDgAESWgAwBcaIo4kBAHODCvScqr4J7D5youFBwD8Qt4kJfFcStqMhQQBmiIoiIbGRD2/91P/yfvKdpVtskTdrv57pKSXKaPDk5ac+d3zNy8vPz8w0AAAAAADOrwF4AAAAAAHiERAAAAABACCERAAAAABBCSAQAAAAAhBASAQAAAAAhhEQAAAAAQAghEQAAAAAQUul//8XkyZNNy0ZWrlyZnQEAQBFs3LjRcnJybPfdd2e/AUCWo5IYoICor2TS/W3YsCHp95sK2dJW2sk+5RgtX++lbGpreW5nKv6GAgBKB5XEAF9B3HnnnZO2g9esWWPTp0+3li1bWo0aNSyTZUtbaSf7lGO0fL2Xsqmt5bmdU6dOTcr9AABKH5VEAAAAAEB2hMTff//d3n///bjbrVq1yt5++20bNmyYTZkyJS1tAwAAAICyKGND4r///muXXHKJvfPOOzG3++uvv6xnz5721ltv2W+//WZnnXWWPfLII2lrJwAAAACUJRk5JnHmzJl2+eWX2+zZs61BgwYxtx00aJDttNNO9uijj7rLvXr1srPPPtsFx2bNmqWpxQAAAABQNmRcJXHatGnWu3dv22WXXezQQw+Nua1mZvv444/tqKOOCl239957W5MmTWzMmDFpaC0AAAAAlC0ZV0ncaqut7PXXX7d27drZtddea+vWrYu67Zw5c1xQ3GGHHQpc37x5c1eNzFRr1y611asXWabRvl6/fr4tXVrJ1qypZpmKdrJPOUbL13spm9qaTe3MzV1jmSQ3N9ettQgASN1KDhUrVszOkNi4ceOEt125cqX7XqtWrQLXb7HFFm5MY3FojSdNDZ4sa9euLfB9/vzvbO7cPKtUKeN2/f/b0n79dbllPtrJPs10HKPs08y2fv1aW7z4N6tbt+AHrcWlv585OTnF+rm///7bli/Phr89AJDdVJDbbrvt4v6+ztSkkhC/aG/4k6xQoUKx/lCJPsXU2lHJpqqnLF48zapV28X9Py8vL+mPAwBAIjZtWmcLFiy2RYvWJ22HValSpcg/4wPitttu69ZsLO7fbwBA/ELYP//84y7Hm/clq0Ni7dq1Q0tg1K9fP3S9qojh1cWilGG1uHCyqIKogKhJdKpXr24TJkw2ZduVK+dZt269LZOEtzVT0U72Kcdo+XovZVNby3M7NdlccbqY+oBYp06dpLQDABCZ/32voKjfu7G6nmZ1SNQfN4W6P/74w1q0aBG6Xn/4NPlNcegTTH2SmYoXZfP9bv6ENCcnPyWPk9y2ZjbayT7NdByj7NPydIwWpwLoxyBmw98cACgL/O9b/f6NFRIzbnbToqhatartv//+bo1Eb9KkSS40duvWzTJRXt7mLrJmdDUFAEDoYgoAmfX7Nusqid9++61NmTLFzj//fHf5qquuslNOOcXOOeccN8vpO++8YxdeeGGBymKmhcTNoZ2QCAAAACDzZHRI7Nq1a2hWUG/Tpk1u2QtPwfC///2vffjhh7Z69Wp77LHHbM8997RMpblqFBJzcgiJAACUBV999ZU98sgjBSbQ00zrWs7r5JNPLjBvQkmNGDHCfvzxR7vzzjuTum1RfPDBB/b888/H3Obpp592+6A0zJgxw2699VY75JBD7Kyzzipwm84hzzzzTFdsOOiggwr9rF6vs88+23r06BG6ThMNfvLJJ25tbk20tM0221jnzp3tiCOOcMOeikL39dprr9nnn3/ujpMjjzwy5rrgmmxEr6O218RQPXv2tIMPPjh0u+bleOGFF9zrrJnztV64noOfRT/e7YlYsWKF/ec//7GddtrJrr/++kK3X3zxxbZkyZLQZXVhrFmzpu2xxx526qmnFjgOtB76m2++ab///rvbd23btrUTTzzRGjZsaEU1evRoe++991xWUGY46aST3D4N980339jDDz8c8T50DPjC0/fff+9em2XLlln79u2tT58+7nmE0/7U4+i5lWUZHRKDb1Bvv/32c19BGuyeLS+U727K5G0AAJQNOkHWcJennnrKjfdREFi6dKm98cYbLki8+OKL1rp166Q8ls6Bdtlll6RvWxQ6+a9Xr17o8kUXXWRdunSx448/PnRdtWqlt07oyJEj3cQcej10fhgMcgpdeq0WL14c8Wd1m4KYp5DVv39/mzt3rguPvXr1snnz5tnQoUPd6+tf80Tdc8899tFHH9mVV17pwsh1113njhX1iou2/fvvv2/XXHONK4bo+6JFi9z2CrxnnHGGe3yF4fXr19tDDz3kwo5CUbzbE6UgpnD8ww8/2HnnnecmPAlSD7+OHTu6kOb3sdp4//3326effmovv/yy6+Ko56GQqftQOFN7VOjR/tZ7RCE0UQpz9913n1199dXuWBs0aJD99ttvduONNxbadscdd7QrrriiUHB89NFHrV+/fu7y2LFj7dJLL3WXW7VqZY8//rjbT2pXMHiOGTPG7r77brdfy7qMDoll0f+v2uEmrgEAAGXHbrvtFpp5XXwlSyf2wfkTSkIVl0SrLkXZtihUGQ1WR1WV0rprmdCTS5NxKNQouCpgqfoXq1IXz8CBA+3PP/90wVPry3kHHHCACzdPPPGEXXbZZQndl4KWQsfw4cND+0oB9oEHHrATTjihUHVPIUpVq3vvvdcOP/zw0AcSCjAKiV988YX98ssvLvD4ileTJk1cWNdsw5rIMdbtic7mr2NX4VhDurQfVFUMF+n1V3jr27evTZ061X1YoWCqKq4qj1737t3ttNNOsyFDhrjnlQiF38GDB7uA6D+Y0HIOCm6q/oVX7lX51VewMqpAqArivvvu6z7Uuf32293lCy64wG3Tpk0bV52cPHmydejQwX1YoFCpCrrmRCkPCIlplpf3v9lNAQBA2aXqiaom+tKJ8s477+yuVyXqueees19//dWd3B599NGuG6CnCfgUDnT71ltvbUcddZQdeOCBhbqQagkRVWkUAlS9UcVE4cFXesK7m+pxFVBUcVHgOeaYY9wEgPLKK6+46pofxqOAoiB0+umnR+zCF48qSKrOqDvhZ5995ipNOglX9UzPXdUnnbhrokEfgCTe7Yk8rkKAfkYhSvuguCFR++Ptt992ASIYEEXhW/vVX6/uoNFCjj480AcFep0UMFSJ9fS63nTTTfbTTz/ZrrvuWuDnFAg1zCpYudPjqkqq115dIvX6B7tEbr/99u67gm282xMJiToGdeyq4rlu3ToXEjX3RyLHRN26dd13HUui5W702oRTZc5fr/Cq/RGJqtcKmlrPXNVXf+yKgpxmax43bpw7rmNR2FM4V4AVHWsK8Or2GtzPr732mjVq1Mhdfvfdd+3LL7+0YcOGudBeHhAS0yw/f3NIrFCBkAgAQJS/lma2ppR2zv+Wq0qG3XffPXQiqpD4119/2bHHHuuqUJp0T9UeVVZ0Eq7luxTgVB1RhUVVSN2urom33HKL+5n58+e7k2TRCbMqZZdccomr2rz00kuuS6RCngS31eOr0qLwpGqOrle1TeFFXTK1rYKixlHqPhQodTKsKosuFydgqfKkQKOgKRo7pi6J6s6nNuhEX90E1RZ1B4x3eyI03k2BQUORFA5vuOEG91xUQSsqdTdUGAsG+KBgeFUgi9bGLbfc0n1Xl1WFj2DAUgBUBVGvc3hIVHWuadOmoeekwDhq1Cjba6+93Lg/3a6vIIVV3aYPDOLdngh1qVU403GsdivAKyz5Dy1iVfsUUBX0dUyJju9nnnnGvR56bfbZZx/3ujRu3Nh9+eccbT/6Cp72o/ZZsGKoD2T0gYv2Yyw6HvU+GTBgQKhLtKqtOl5Uhdb7TO3baaed3IcaPmAfdthh7tgsTzMxExLTzlcS0//IAABkR0DU3APjSunxO5vZl0kLijrJVNVCFTLRmDB1y9NJqqhap5NVVVNUUVQ1SiFJXSVFJ+P6UlgLp8qUTrT9RCY6kdekLQoT4V0X1T1Pj6vuk/5+FRY0bkyhVXSSrLF2PtTovjRhS3FCor8/jRFT0BF1zVS7tA/8+myqbCm8KqgqVMa6PTzwhFPlTQFG3RBFVcibb77ZVRMTDZlBftxicPxlNAoZ+opFYwr9YuaeQofCz5o1hT8UUSjThIwKzHqNtT/186oyR6JxgBqnp2qyAlNRbw+ngKxQqv2otqgiqmCm/RkeElVpmzhxovu/2qmgpbaqK62fuEYfdujnFdL82EEdG+pqq+eo94neL/G6LWs/6j0THth0XaT9GKTgquqvqvOeKpyqxKtCqg80VKEcNmyYC4UK6JowKLySXB4QEkutkkhKBAAgsrLzN1LhTqHNVy00+YeqLJph0tOJrbrbqZqn7qHBiVOkWbNmEe9bJ7rqCqmuigqb+op2gq2xVeFj5zTZjELDrFmz3GV1rfMBUVQF8rcVh076fYXIt0FBTmPQgvtHYWTmzJlxb48XEhVotK/9xIc6sVcVUCf6mnxG7Umkm6TfxocbvT7JGIem4KvnEk7XRbp/hReNndOybgpRqrTqQ4Rrr702FLi9lStXusqXJkjyITko3u3RZu1VsNTYWlEo075VxXnhwoUFKnmqbvqJa9QudZNWwA8GOe1XPQ99aXZTLWunSXxUsVa1WB9YpGI/ho+v1IcxCn5BqlrfcccdoXXWO3bs6CbX0QcXwQmZyhNCYprl52/+xUNIBAAgkpz/r+SVje6mGl+oKoVfv1kn/uqmGB4EfShTgEx06QhV19SVT7NGqpKjaqFmNNUkIOEzbio8hd+v30aVH4lU5VLbi0vB2FcERUFY1SiN0QynsZAKQLFuj0cBQEHw8ssvD12n7r2qCPoJbHS7gkT4Emviq1C1atVy332XTI2TUwiKFKIUahXWExmTqIqkXv8gjfPTV3BiFU8VO7X99ddfD33IoPCiKp5m2fTdXXWf6rqsEK0qbHgAind7NArXouNKx5QPUzqW1A01OIFNUScuat68ufvShyWqNir0qsu12hpvTKK+6/XTfgvOoqufjbQfPY2t1NjD8DGq/meC7a9Vq5Ybs1mSD0myHSEx7agkAgAQ/29l6ayxl2w6mVc48+PaVF1RVSfaCbUqbxpzlSh1MQ2Oe1TXPXUR1WyUQerWp/GO4ZOSiJ+cI9X03DX+K9pzj3d7LKqmqtqoamn4z6uKqElIfDhQYFclK5zCoPgJXTQuTVVchc/wkKjwrPCkyqtCYiJjEnV/CxYscGHZX+fHjEZa/kEzaioQBYOQLut48t2XVelTANTPqxIW3s043u3RqI06jjSZi9ZyDLrrrruKNIGNX1pEVWuF1PDuu5pFVCFRVeNExiTqgxF9gKHX24/j1P7QvtXrEM348eNdhTN8G7/v9fPBSvqiRYvKZTdTr+jTVSEpu5xKIgAAZZuvLmliGV+1U9e1Dz/80J2wehqjpRNuVfQ0uYeWcPABTmFE3fF0ch1Oa7r5ao8/idb24evYyXHHHecqUj4I/fvvv278YadOneJ240wWPXeFObUjOBupupeqIhfv9lgU5HSCr/GTConBL92vxm/68K3ZLzVrqbq3BqtQ2seaXEjLH3gaO6durBqjpgqaqNqrsZ3al+oOKhqPGP64/ktjTEX/14cACpf+flShU7fGSOMe1X1YodlPROSPFVXQtHSD2qwxdApNCm7hATDe7bHoGNTxqCUlwp+P7lNdozX+M1Hq5qr9r3YEZzjVY2j/6rnquPVjEiN9+dmBtZ2vmGsfyoMPPugCfawPGH7++eeIYVyvtz5o0X34+3v99dddl9pIFf/ygkpi2m3udhHsfgEAALKfTqhVWVFQ0yyKmvpfIUJjsDwFFp34q7qjk1pVQNQFUifP+q7xUgpKCovqYqlwpJNincCG0zZanFxVGFWXVB3TuDN1SQynoKVKon5Gj6tumKrC+Aly0kEn8OpSqID19NNPu4DgF4j3E7/Eul0n8NqX6qIYrG75tRF1XaQxaaqGadF7dd/U5CnaF9rv5557rgvIOifTkhBamkLLIwTH0WkSE4VpzbKqwK+qqyZl0cQvuk8fXBKhx1HXSoV7LQuisKf7C3ZTVRVNr4+20f669dZb3Yybapeev7pZ6lhQV03tJ73m+gBCk9GEV08VsGPdrg8I9F0hUh9ShIduBdFIs8Kqm6smWlJ1Nt4sp57Cn5Zf0XPR/WqWV7VL1bvOnTu7KmNRaCyu1jTU4/tuzdpHvrKp/axKoN5Xno55H9jD6QMCfZij+1P300WLFrnXPNp44PIgJ78knc3LGPVVlqK84eNR/3Z1JdA6QXozvPfeq1arVgOrWnWu7bPP5imhM0V4WzMV7WSfcoyWr/dSNrW1PLezOH9DdZKsk1id8Aa71GUbjdMKduVUxUahRkEiWvVG1RSNV9TJs05Ew7vt6T4VXHTCGpz8RSe66q7qq10KSLofvaa6n9q1a0fdNni/Cp7BCqIqQ6ouBreNdF0k6uaqNfF04u9pLJ0eR+PxwinoqFKqsXFqc/gYuWi365T1ySefdJeDM65qewVrdSNVd8JIdLuCRPC5KMSruqXvanus8WyiQKPnpX0XvmB7UagiqbFuGgOq5xcMpWqnrg+OwVQ4VDt1jKhLrj+m9GFDpHUHxX/AEOt2Pd/Ro0e7sZUKXZ72s7qHKsBGqzLr9dGxoddXr7+O90S7LftJmjTRjJ5PsItnUaidqubqu55P8L2m9mm/6XdcsJKox4rVTr2X1M23RYsWUX8nadZfvW+D78tskujvXSqJabf5jwCVRAAAygadbMcLGOF0srrLLrsU+T4VZoJhTNXHaIuih28b634jnTgnetIf6XkoNPrF1MMpBMUaOxbtdoUpdaEMX09Q28cbxxipm6GqjtEqS5Eo9CeydEQ8CjN+7cBE2qlQHOk1jtf2RI5JfYgQ/py0n7UuYyx+IiaJdRxHO/aLGwzD2xltHwTb50Xb50F+uZZY4n1oUlYwJjHNcnI2dzOtVInupgAAAIlS1VTdNNUFFMmhCWiOOOIIdicKoZKYZjk5fuIadj0AAECiVDXVRD3hS3Wg+J577jn2JyKiklhqlURCIgAAQFEQEJOL/YloCImlVEmsVCmxhUwBAAAAIJ0IiaUUEitWrJzuhwYAAACAuAiJaVahgu9umr1TfQMAAAAouwiJpVRJrFy58GKvAAAAAFDaCImlVEmsWJGQCAAAACDzEBLTKC8v1ypW3BwSq1Rh+mYAAAAAmYd1GNIoN3f9/3Z8JUIiAABlwfvvv29PP/20W8MvFV5++WX74YcfbNCgQQltP3XqVGvbtq1bbquoPxv01Vdf2QMPPFDgOn3YXbt2bdt9993trLPOspo1a1q2Ksm+Ka6PPvrIHnvsMTvvvPPs8MMPL3Db77//bldccYUNHDjQ2rRpU+C2+fPnW79+/eyWW26xXXbZJXT92rVrbdSoUfbll1/a0qVLrX79+nbwwQfboYceahUqFK0WtHr1anvqqads4sSJVqtWLTv11FOtc+fOUbdft26dPfnkk277rbbayk4++WTbZ599Qrdv2rTJXnrpJfv000/dcdOjRw874YQTLCcnx92+bNkye+KJJ+ynn36yevXqueMp+NwS8fPPP9uNN95ohx12mPXp06dQ+0455ZQC1+k9sfXWW9u+++7rbtPam94nn3xi//3vf92+3mKLLWy33XZz29SpU6dIbdLzfvHFF+3zzz93r8GRRx5pRx11VNTt8/LyQttXqVLFevbsab169SqwjV7j9957z9avX+/28bnnnuu2TfT24iAkptGGDatC/69cuUY6HxoAAKSITs51opsq3bp1s7333juhbSdPnuxObBV+dEJclJ8Nt2LFCve8tOC6D4O5ubk2a9Yse/DBB91jKBxnq5Lsm+JSGFi1apXbp+EhUaFG+1u3h4t027x58+yCCy5wof300093AXH69Ol2++2325gxY+z+++8P9WBLxMUXX+xCRt++fW3mzJnuvh999FE74IADIm5/0UUXuaB3+eWX2+zZs13wfeSRR+zAAw90t1977bXueLzuuutc+++44w63/YUXXujC7WmnnWatW7d2j6ugqeP2hRdecB9AJOr11193++TZZ5+1M888s0Aw0rGqfab779Kli7suPz/fhXEF8WnTptm9997rrn/ooYfcfek5KeyuXLnSBdzXXnvNXd+gQYOE26T7/vrrr+3qq692z/e2225z76Uzzjgj6vYff/yx3XDDDe653HrrrbZkyRL3fESvwbBhw9ztW265pd19993uOfgPN+LdXlyExDTatGlt6P9VqmTvJ28AACB9dPKvr0T8+++/rjJRnJ+NZscdd7RtttkmdFkVFgVQnfz/8ccf1rRpU8tGydg3RfHXX3/Zd99950Kcql8zZswoVDFMlMKOqo7bbbedq+bp9ZA999zTdt11V1exU7jr3bt3Qvf3zTff2Pfff++qWaqc7b///i7gPPzwwxFDokKkKs3vvvuuC3r77befez7PPPOMC4kKh6psvf3226HnqOClMKbw+cEHH7jgpCCjap7C+qRJk2z48OEJh8QNGza4Kn7//v3trrvusrFjxxYK3tKoUSPbeeedQ5dVrdQHO3psBatq1aq5CqrCmqp+3v7772+HHHKIC/Q61hN9jV999VVXpdb7RFQ51WMpfAYrl6LwrG1Vse/evbu77p9//nHtUUhcvHixC4EKs6qWSvXq1d1t11xzjTsOYt1e1CpoECExjTZuXOe+65d3xYolKwEDAIDsoU/29Wn/r7/+6rrm6eRdlSzvxx9/dCejqiDoJLlly5au+5sqdsFukerKpu10Ui86QVeFQpUOVUbuvPNOd71OSC+55BLXdS7YpVKPr5/Xd3W7Uzc4dQMsKnUPlDVr1hR4jgoJum+155hjjnEn2ok8R4UDnRDr+el56Ge1j2LdZ6x9kcjt4d1NY71GqgDq5L1Zs2auS6IqbgpP55xzTiigxfPWW29Z3bp17bjjjnMhQFWqAQMGWHEo0Gl/qsoV/vgKQQo87dq1C7U9WlfoI444ws4++2xX+dKHAcFQof2sSvHy5cvd/ghatGiR+67n4ylwKxz6brUKq8EQfPTRR7uwpgpfp06dXNUwGJpUBdOxkShV3/ShiMKRuttqf0YKiZHo+eh8XF8Kahs3bnTHX1DlypXd8eC7x6rb7JAhQyLe3x577OGC/7fffutCmp57cD9ef/317rgOD8AKq9ofwf247bbbuv2g6z/77DPX9VXdh7299trLRo4c6cKtwnas20uCkJhGGzdu/kWan/+/T/gAAEBB+nRcVYLSoO5q/qQwWXTirE/2jz32WNf1TRUXVYEuvfRSNw5LQUXhRV+qAKk6opNKX6FbuHCh684nqjjohF5d/HQyqhNt3ceHH37oAoy68Klbn05Yd9hhB1ed8T/7yy+/uPtXMND4NlUBb7rpJhf0dAKfKHUVVPhq2LChtWjRItT1UeHn+OOPd89rzpw5duWVV7p2nnjiiXGf499//23PP/+8nXTSSW5smSqX8e4z1r7Qaxjv9uB+jfcaqX3qfqgwoGCotimQ637Cx8JF884777jQqZ9RhUohVV0S1baiGj9+vNWoUcPat28f8fZgBVFjFIOhJciHk7lz57qKW5AP07otPCQqiGrc4iuvvOK6aKoqqP2qiqJovyp06kOAESNGuBDWtWtX16VUzz+8+6b2t6qYeq0SpdDdoUMHd6xof6rap2NE74NYFHoVKBVYfYVcH5SoGjdhwgT3Gu2zzz5ufwSr5KoMqitoJNoXfl/pfRH8HaIPVBTk9X4LD4naD3qfah/p2NIHG3peenx1FdZ+1IcbU6ZMcYFV1V2FwPPPP9/9rop3e0kQEkth4ppgNxAAAFAwIGos1W+//VYqu0WhRyeqyQyKgwcPdhNl+KqRqiiirncKO0OHDnVjphSA/O06+VOVJJxOYnVi7Md9KSSo8qWqg8YN+pPanXbayapWLbjcliYJUXVJY6T84+ikXvs8FlWa/Ng2ncQqIDVp0sSNP/Mnonoueo4ahybqPqgTY3UDVMhL5DmqcqMTfV8Z07ax7jPWvtB28W4vymvkz9+0nQ8EOjFXsEkkJKotCgmaeEYUatRNVFVJBeGiUqVJleBEJqdJpFutJq0J75roK1H6UCCcxkHqNdX4QoUahRMdWwq9vmupApOqswosul0hTJf1AYaniqyev44FhZtE94Uqmeruqg8aRMFOr6nClm+Dp3aqmiqqGv7555/WqlUru++++0Lb6HeOqqaqwKlC6X8X6EMNvf76faD9ra94+zH8faef1XWR9qNu0/tIj6P3h95f2rf6QEIUvtWFVcelPrzQ9joG9aGGKuzxbi8JQmIabdzoQ2JuOh8WAICskuxKXmlTt0BVpYLUBU0TTGgSGAUIH4Q8zSqpykw4nUTffPPNrjKn7o76UnUikX2mUKMqYlDjxo3j/pzapgCqypu6ZipAqdtdcFIUPUedgAcrWLqsEKiT8kSeo9oSDG/x7jPevijKvor3GokqSz4giqpQGpuXCHX3VDWuY8eOocCq56uKlg9GiQQ+v41eDwWSZFFAV3gO8pfDQ4+vSl922WVuJk4dUzo2FKgVghXiRcFQoctPeqTv//nPf1xoVJdK/3wUztTVU1VtzcqpinK841lVWYV2VUlFwUrVNwVWVX+DVTR1UfYT1+h56rGDY2xF26tt+tIHCd9++60bU6nwpSqy7jMROn4jFYO0LyPtR3U31WNqNmJVrBUkNcZQj+dDno51dd/dfvvtQ+FVHzKomhzvdn+8FQchMY02bVLXmSp0NwUAIAqdHKqSV5a6m+qkMbxLob+sbniqHoSPH9I4o0jUVVNVQo1FUhXr8ccfdxUYLasQbzkKPVZxujb6iWvUPU8nswptCl9+/KOvHCksRJrqXxWqRJ6juk8GxbpPdeGLty+Ksq9ivUY+LEUa4xWvCis68VcY1rZqU/D56QTfT2DjA2ikipMf++m30eugbpMaJ+kDV5DCkrbVZCiJjEnU/lRFKkghT8IDlWhMparJwWNAIUXdhdXlWT+jwBTcz+ryqn2gXgK+zQptvtKpQKb9oyVc4i2FoQlx9CGFZmL1tC8UusInsAmfuCYehawWLVq4JUAUhLX/FNoSGZOo5+X3m6fXUx9uRNqPqnzqOAhW5XVf+oBi9OjR7r2jLx8ARd1pNX5T1dd4txMSs0Ru7kYXEqkkAgAQne+eVVaoC6iqE0F+LJxOtPWlbnhB4ZeDFHz0pe6YChgaT6gTWJ3wxwq4ehx1ASwJnXDrZFiPrfDop/XXc1QXyGgn40V9joncZ7x9kcjtibxG4WP1ikon+6r6aaZQjVcLBj+Nb9RsmKrAKSgpVKkdwQl/fOVOgap58+busqqiCoEKg5otNEjLKNxzzz3uuSokJjImUZVN7ReFOH8MaQ1CVT/12oVT8NHMqpGq0go9es00qU6QQpwo1KgLqAKdPmzw/Hs+3gdEqohrf2j2ToX+IIVG7c9EJ7DxVUlVPLWMRvjso/vvv7/r1promETtxwULFrig6LumahkO7dNI40e1H7U/gpVPhUl9QOH3o8b/6jX1gVvHjarpPiDGur0kirbKJkpk0yaFRCauAQCgPFF1RSfMCimiE0h1zdMJqIKBxjypoqAxa6LttLRApMCnMWCaLMRThU4n9n4iEH+ircpFOI3j0/36dqh6pkluNMFLUShgqe2alVRd8fxzVBjyJ9SiiTTUfVAVzKI8x+B+i3Wf8fZFvNuL8hqVhIKcgqq6AOqk339pjKVCnPaDTuxVGVPXSD1HH1BF+0xdMrXffbVVgUBj71SBUlXNd3FU8FIlXlVPBVBR+4OPG/zy+0ITt+iY8V0cFc71mH48XjhNQqPqrJb08PtWwU+VNFUB9Ty0DxW8fPDT/tRjajyg9oeOB83SKnr+GkunsB4t0Ab3p8KrKpbhz0fHuNqkCWwSpcqdgqfGKAbXoVy5cqXrcuqrvwp90fajnyxHY2D1f41x1LGmMZd63nqdgzOYeuoGqw8F9Jw87TMd3zr2dLv2qbp5q6Kt+9T71S9TEu/2kqC7adoriQqJjEkEAKCsibQmnSbWUABR1UwnmzopV0VF46d8Vz11a1PVplevXq7SpJM9rXfnlxkI0omxJnfRpCfqrqklLjRTqbYXVfd0H+qiqTAVpJChxdZ14q/qmE7iVZnSCW1RqWug2qs1/xRUFArUjVDjqxRK/LIJWopB1ZmiPEcv3n3G2xfxbg+K9xrFo5/VmEaNuwx28fNrI0arQGm/qCuqJrBRwFHwU+DT//WcFa4U/LR+n9b0C1JbVYFSF0iNnfQzwqrdqi5F6oYajQKQjgNV5zRpih7zoIMOcpOhBI9vHTv60mujipmCuCqKOpb0eOrSq32tL42t0/5Xd01VUlWRVBAU3bequ6qC6nlqfytsKaTqtdXz1mty+umnu8cKXxtRVdJIs3fqZ/R6a6xnsO2xqF3aXxpLqddOr3+FChXcpDB6HdTlNFH6OT1HPbYmhVJI1OyjfrIo0bqOet/pfjVGVsezXj+9j/T89GGBqs6+C6kmnFLw1wRMvpeF9q3/wCDe7cWVk59IZ+pyQn2gpSj9luPRJyP6hay+49Onj7JVqxrYqlWLrGfPos9klWrBtpb0wEol2sk+5RgtX++lbGpreW5ncf6GqnKhk2udMJV0Ta/SpBNqBZBIVFXwXdFUpdAYtEgTZ4gm71A3MVVTFE5UDdFJsyYF0c/65SYUsBQ+9DrqBDf8NVQXNlWfdPKuk9TgzwbboWqDX+8wEp0kq3uqjpNIawGqfbov3e4nsVEY0H2r0hW+FECs56iKpH422E4v1n3G2xexbg/fr7Feo0jbBq/TsazZO9UN1M+mGtyHCgrRulBr/TyF3+AkQro/tVun6XrOscaSahuFbT2WAk68samxKKToNdFzD6986T2u/RKsrGp7/9pECqUKvHqPK9BF6raqn1ew1bEYXGZDz0kVNYUujZkM7hd1NdXxo8lqItHt+jn9XlFXT+3XeLOSBquHel0rVKjg2lvcZST889brFuxi7Nun33fB/eGPUz1upPeN6DhSxVa/UyJNchTv9qL+3s3YSqJ+Iehg1y+4RGZ70vb6BRDrl11p8wOfWScRAICyQyfUkUJfOJ1IBxcX99RVTGFOlSKdmCswjRkzJlQJDF/CQIEs0gm3pxPT4OOEd5eM1o5wmvwiVuiPtB6dKkiqZhb1OYaPb0vkPhPZF7Fuj7Q0RLR9E2nb4HUKgArm4eMX4+1DiTRWTSfvWj8vEQoUCmhFqRxGo1CkQBtJpOeh7WO1U+fwkYJ/8Ocj3a7npEpl+MQr2i/x9qe6s8ZqcywKntHCZ1HEet7B9iV6HEtwcpri3J71YxKVgPULRKVylZfVh1cLwUajT040la76datrhbpSqF9xJvrfhDV0NwUAAJsdeuih9sUXX7gxRDqP0aQbOv9RV7uyoqw/R1XTFIJbtmxZ2k0pEzQmT910SzquDsWXcZVE9WXWWjqaYUmlZw32VF90TWcbqXx+1VVXuT7qn332mftkSn2QNVBX/bsjDRAtTbm5ft2UwuunAACA8kkTfaiqpu5m6r6oalRJugxmorL+HFUF0kQvSA6NS9SMo2VpluNsk3GVxJdfftktJqmAp1KzBhirX7JmtwqnXzTffPONGyjsA6EG06o/drT1YErT/xYpJSQCAID/0TmPgpO6VZal8FSeniOBhv1ZlmRUSNTAVU25q2lxg31027VrZz/++GOh7TWwNFKfePVrj7R9afvfHEGERAAAAACZKaO6myogSng3Uc1I5BfgDNLMRvpUSlMq+8Ge6sM8a9asAjNEFTXIaQKcZNEMY/77pk25tnlysLykPkYq2prJaCf7lGO0fL2Xsqmt5bmdwUW4AQDZLaNCol/4NXyaZV1W+AunmcS0RozW6FFXTnVhGD58uNveLypaVHocTQuebJpOeO3aDaZZsPPyNqXkMZKlKAuQlibayT7NdByj7NPydowWd7p4AEBmyaiQ6Neu0exQ4eExWt91LeaqKqIW6lTXVI1J1PS4WoenuANlkzkzlT6l1R9hdYldvHiCu65ixRy3plCmCbY11no8pY12sk85RsvXeymb2lqe2zl79uyk3A8AoPRlVEj0XUa1dk5wrRBd3nPPPSN2bdEfuTPOOMP69OkTuv6ll16y3XffvVhtUFeZVCyAvPmP8OZuOFr2MZMXWVZbM7l9Hu1kn2Y6jlH2aXk6RulqCgBlR0ZNXKOxh5rxSjOWesuWLXNdM7VuYqQ/SGeeeaa99957oeu0kKkmrTnooIMs0+Tnbw6JOTl+AhsAAAAAyCwZVUkUrYl49dVX27bbbuu6fT744IO28847hxbTXLp0qa1YscKaN2/uLp966qn2yCOPuBlN1d30lltucYuz7rXXXpZpCIkAAJQ9H3/8sT388MN23XXXFfpQe9KkSXbrrbfac8895z4Mj0e9ofQz999/f9Lb+f7779sTTzwRulyhQgXbcsstXZu1/JiG62QTrYn92GOP2fnnn289e/YscNtvv/1ml112md19992Fhvho4fuLLrrIbrvtNtt1111D169evdrefvtt+/LLL12Ron79+nbwwQfb4Ycf7s4xi0JrQWpfT5w40WrVqmWnnHKKHXjggRG3ve+++9xjRnLTTTcV6k03bNgwVxAZPHhw6DqdHz/66KP2008/Wb169ezss88ucq+6adOm2Q033OCe7wUXXFBo6JeGdAVpn+iY7ty5s5122mkFxiR/9NFHroij5erUW2G33XZz26htRbFp0yY334jWQ9fjHXnkkda7d++I277yyiv26quvRrxN++Poo492r+uzzz7r9p/mMNl7773dbZHGU48ZM8aeeuope/311608yriQeOihh7pJZ/RC683aoUMHu/jii0PdWN555x176623bNSoUe6yfjGou8zQoUPd5WOPPdZVFzORD4nqbgoAAMoGfXg9c+ZM98G2Ql5wAj6FhRkzZriT3UT06NHD9t1335S0U0FCbVEQErVp/vz5NmjQIJsyZYoLGdlE+1rhRaEpPCRqfgs9V51Lhot029y5c93QJc2wf/rpp7uAqJ5sd911lwsLem3DJ1aMV/TQsCit961jQ6FURY1IQfHkk08u1H6FWw23atOmTYHrp06d6j5AaNGiReg6zZivAKYwrLXD9SGDnoPClc6jE6Uw5PdneHDSBJHaZ3o+3bp1c9fpfF3DvjSBpMKp/2BD++qNN96wSy65xFq1auXeH3qtFNJGjBjhJppMlO77u+++cx/AKODdcccdtnLlSvehRjgViRRGg1544QUbO3as2w96bv617du3r7usNmt/BT888cvs3XTTTRm5GkG5DYmiTzD0FYkOWn15+lRBB0qkgyVzQyJThAMAUJaoKqeT55dfftnNlVBcqrQUtdpSVMHKmnprKTSpF5dOjHUCnQ0Ubr///nu788477frrr3eBrriTAirMqeqo5dOefPLJUNVQlTjtn+OPP94VKVSISMS4ceNc8Pjiiy/cTPydOnVyEyo+9NBDEUOiQlMwOCnU6LkpaAUnbtSEU1dddVWh10gVYgUnBUtNwKjKo37++eefTzgkbtiwwT744AO3H7RPVQkMD67SsGHDAvtZa5svWrTIPbZCVdWqVe2ZZ55xl3v16hXaTh98HHLIIS646vVK9DVWqFR10Fd8FUx13+pJqOca672jcK6ikiq1mutk9OjR7sMA3acfi619ecwxx7htNeTNHw/XX3+92/eERKS5uyk7HACAskYfWKtboU6OFQ6iUeBQgNBJsALJLrvs4iobtWvXDnU37d+/v/tSpSM46/rAgQPdybHCgvz666/29NNPu+8aeqOueF26dClSu+vUqePaEawcRWujgoq6It54440FukGqR5cqPQoK8dql5cbU5U9zUOiEXCfn6gVWlAqTepWp6qf7VbBTkFC33uIYP36862qpSlp4t1KFxHvuuScUjBS8FN4iOeKII+y8885zIVEVwOAxsN9++7mui8uXL7etttoqZlhTCFJ1MTz06nqtEa77VvdLT0OyOnbsWCA06Vjy648nQsFUVW/16Pv888/d/owUEiPRY+l1VIDTBw56fVUFDVLbFBB9z0DfRTuSPfbYw61eoAqiwpyOveB+VGVSFVVtF4v2l4af6TmJjtc333yzwGRdDRo0cN8XLFgQCol6jRcuXGgXXnih65JcXmVkJbHsqhBaAgMAAETmTzhLqyJY3JlaFbLUrVBjxaKdXGpsokKNQpYqV1o6RF0aVbFQyPnnn3/s999/d2FAgeHdd9911R3RSfxrr73muoeKqiKqcilQqMqlrn/XXnutC5cKq4nQCb1Cj8KNHzMZr43aR/oZHxLVFVEVVHV1TKRdDzzwgH377bd25ZVXunGQOilXLzFVehLZ9zo+1GVW3Qu1vSpUCtfXXHNNsWbrVdVNP9e+ffuItx911FGh/ytwRJv3wodCPX9V3IJ8GNFtsUKi9quOAXVXDVJwU3VPlTF1oQwKryyq66dCpKrDiVJ40uupY0DPUftSx6GfAyRWF2Ydkwpy/vnr51W9035VdV1jXrfffvsCKxeowqkQF4mvnvr9GDwmNGeJAqduixUSFTAV1oPjCfVhiL6CFFbVjbhdu3buso51hdcXX3zRZs2aZeUZIbEUQqJ+uQIAgMgB4IcffnDd50qDqiIa11TcoKjZ1XXS/PPPP4dOPIN00qyTaFXXRCfXer6R1plUNzh1jfMhUdUedefzM7ir+6IqK76qqJN8nWOou+BJJ50U9XzDhx4FcVVM9N1XABNpoyYP0Yn0zTff7OaF0Mm4xvcprCXSLk3mou6DmvBEtJ8UJNWORCaIUfiYN29e6PH0XWPK/vvf/7pwWlSquCkcJXJ+ppCir1i0L8LDiJ8USJXYWMe+ArPG7gV/XkFME8rogwdVT6PRGDsdM9qXCrK6n0QolOo11GP4119BTMeewmKQXndVBP3jaWIavX4Khd69997ruqEqoPmKp9ZkVTdsfUig95aCcqyw7PejjvdIH8bE2o+iNmofBKuQ4VQ91AcWqmLrNdWHMvrgQhXEtm3bEhJj7mEkGSERAICyTifW6i6nE/5wqqbo5FddOXUyr1k4dSIdqaulwpgmAdFMjApVqipqzgbfLVSTzehkOVjp0om7Ko6awVPVm0h8BUehTF1EFWpVddJJu8bMxWujulUqCKiypTZqFktV9XwFKF67TjjhBBdKJ0+ebAcccID7UmUp0Q/R1dVUbfUVPQUStVldJH1ITOS+/DaafTTSBDfFpYCl6mqQvxxrBlm9ztrXvlLsqaKrDwa0j2NRwFYFTGMEFfjOOeccdzneBx6qyupY8Pev/aFxlKou6gOKYDfk4447LjRxjSpwCleaITdI22tiSX3p+FHVWAFeIVcfSlx++eWWCN1/pB4F2pex9qOOaR2vqn5Ho+Ct6rmqkb49+nBDz/3cc89NqH1lHSGxVLqbUkkEACASndCqkpeN3U09ddFT10V1DQyvlih4qVumJtjQNqrCKABqYpNwquTpZF0hTAFNY/g0u6SnaquCmKpH4WJVu8LHuqk7oMKhJi7R93htVJVLVUCNW1QVTxVOVWQSbZeChu5Xj/f111+7sXqqNj7++OMFJmqJRF1etfSFBCeS0Vg/VRd9BVcn+xKp4uQnI1HVWDTGTz8fbeKekSNHuvvTc01kTKL2myps4aFEYo1VVddHvc4aB+lpTKeuVyXOh269Dv/++6+7HFzGQ+HUd6nUhxQKzBq7F6ua5kOiAqZCnafH0D7RzK7BCWjCJ66JR+3WlyrIOqbULVmhLJExiTpWFPjCXzt94BBrP/rlMnyYDafnpvHDGoOo8aYKowqeGierbsH+uF25cqXrjq39rHG40SbVLKsIiWm1uQtFUdfaAQCgPFFIy/a/lRpTpm5swRNvP/FM165d3cmpp4qauhpGoi6DmrxGJ9qqlgWn+Nd16ipY3Fk9PZ0kb7HFFqF9nkgb1S5VH1XVU1VH3UuL0i4FM32pUqWxX6pIfvLJJ+57LBq3qKCg5SSC1VdVAnXir2qigpPCnoKdQpZfa9vT4ylQ+fF2qmQqMKpypsl5glT9VNVUE+QoJCYyJlEhT89FH3T4aqXCq7q0BsflRepGG9yPojGhfskST+Mvta0qwqoWqwKmEBqcuMdX/9SFMhZVL7WPNJunJr8J0pIgqjIHQ2I8aqt+Rt09w9ce1Aynfj3IRMYkaj+qS6iem9+32o/6/RBt/KifiEjBOdIHDro/HSdqi6rZ/vXRsa/XP3wc6NChQ107s2XW32SipJVGOTm+u2l2/+EDAACx6QRVa7KFr7+myoTClg9cqsKpqhLtZF6LuatqpIlkwseYaWIYVXp0Miu6T1XldBKsx0mU2vDHH3+EZoFMpI2q0igcKkgqRARDfbx2KTirG6SnypC2SWR2U53IKzyoa6RCqP9SJVL7SlVXBUa1R8FOyzFofT9P3TnVFlWHNJ7Sv1YKvFonUlVD3zVUFSet9adJbdR1U1TdCj5u8MsHCa11qeep2V1F3T/1//DF6IMUKNVOdZ0N0pi88MdRpVD7Xv9XuNcHB6puqlun6Pmrsquw7quMsfanqt1+NtXgl9qrwKV9liiFPy1Hoi6zOm49VSXVXVoVRdFjRtuPPkirorjDDju4kK79o6qwJoXS/g0f8xmkIBm+H/3YU60nuffee7tKZXiX5PB2NGjQwAVS/T9W5bKsopKYRjk5m3+BFmUxVgAAkJ0URFTZCtKi4PpSt06dpOpkVyfoOlmPFBQVZBTedHtwjJ8oNGoGSs0aqvvRibhCjCaICV9DLrxdnk7kVZlTm3zFLV4bVSFSeFFlTaEqPLzGa5dmMtX9K0Ar5KjqeOmll4bW9FMoUYVR26grbPjaiNFmjtWkKFozUOPfNO5Rk5AofOp6tUNtVxdCtU/3HaSumQpeqhwp4Kjqp8dTZU9VsaKsXakApJCmsamaiVRLNijAXnzxxQVeAwUm7VfRPlIICp8VNRF6nTR7rGbW1fNUKFXAUvdJ7W89bz0/TRwT7KLr10ZUmA6v+on2oboAawKbYDfnWBTw1CVX4wEVxvS66xhScNXz1TGRKP2cxuTqZ1T5U3sV/oKvv56zKsJ6rT0tvxFpP+pDAI2JnTBhQqH3kn4+vOJc3uXkR+vfUA6p37YE+4KXlH7x+gVeP/vsI9tii62sTp3l1r59wYMzEwTbWpwppNOFdrJPOUbL13spm9panttZnL+hqiD5afZjTUSR6XSCrxNTdZ8Mp65yGuvWqlWr0IfEOtlVANEJvbo5Khxogo8WLVq4QKEujsGlB3T/qmoF10sM34+6P1XEYnWL823xVCXR668KXnj33lht9IFC4UkVLI29LGq7VBnSPtP96vGDr79+TrNl6qQ9uPi8Ap7uL9iGcKrGqb3BkKDnosfSKa/GeUaaMTN8P2mfq5Lkq43FsWnTJlehVeAMr0Tp/aeZSn34VBvV7VPVv3iPqRCocK8qW5CqlxoLqdcs2NVSz9vPSKpqrqc1DRXI1aXVj+EMpzbp2FC3Vi04r30Sb1ZST8exPgBQ2NNrHOuDi1jUfu1H7Zfw40jt07ETrELrGFA7wyfU0bIZ0SYo0s/7MareihUrXPfUSO/rbJbo711KWqVSSSzemwQAAGSeWNP5KxyEBwQFnGAI1MmvH7+n0BBetYq3XIBO9BSc4onUlmhitdGHGo1HVPe94rRLwSFa1UwhTiexvsrm6SQ+/EQ+XKQTej2XaDO9lnQ/xaIPBaI9//DxmmpjomNLIx0johCm9TXD6cMATeoTrMoGu7LGEmx/Uce+KqjGm4goEWq/wnO89nnRQl1RjgFRyAwPmuUJYxLTubP/v+9zpUqRP/0CAADIdHfccYd16dLFBSl1VUw2dQlUFS6R4Iv4VGFUF8vwSXGAWKgklsLENRUrUkkEAADZSZO5qIIYrbpTUhrXpsllkByqMGph+2hddIFICIlp5Gc1rVw5dl94AACATKXxa9HGsCULgYb9idJFd9NS6W6avYPzAQAAAJRthMRS6G5aqVLxZ8oCAAAAgFQiJKbJpk3rQpXEypWpJAIAAADITITENNm0aU3o/5Url3w6YAAAAABIBUJiGiuJXuXKdDcFAAAAkJkIiWmyceP/KokVKzK7KQAAAIDMREhMk02b1rvvubm5oaUwAABA9vvoo4/s0EMPta+++qrQbVrEXLctXbq0RI+xatUqe/TRR936hEceeaSde+659sILL9iGDRtC2wwfPtz69+8f9T6Ctz/xxBN2xRVXFPp/NBMnTrRbbrml0PWPP/64e366Pdznn3/ublu5cmWh27755ht32+LFi93lTz75xF32X4cddph7nhdeeKGNGTOm0H0Gv3r27GknnXSS3XPPPbZixYpCj7Vw4UJ76KGH7PTTT7djjjnG+vXrZx9//LGlwl9//WXXXXedexy1fdKkSTG3V3vvvvtu6927t5155pk2atSoArf/8MMPdumll7rbzz//fHv//fcj3o+OLz1mcF+PHTvWHnzwwSQ9M5Q3rJOYJrm5m7ub5uXlpushAQBAGvz77782Z84cF0T23ntvt3i5t2bNGvv999/dh8TFtX79ejv55JOtXr161rdvX9tmm23cferxFHaGDRtmOTk5Lij8+eefUe/niCOOsO7du7v/K5wp0IT/P9rj33jjjfbAAw8UuF7P6cUXX7TatWvbyy+/bB06dCgUbNXOTZs2FbrP1atXF7hN+1CXtej7Flts4a7buHGjC4UKtoMGDXKh0d/na6+9FlqrUe2YNWuWC4nTpk1z4dkbP368C4X777+/23dqq4L7lVdeaccdd5zdcMMNlixqm4Jox44dbcCAAa7tZ511lo0YMcLatGlTaHsFfAXDmjVruv2rY+jmm292t+m5KiDqQ4GLLrrIzjvvPJsxY4bbbtmyZXbqqaeG7mf58uV2wQUX2M8//1xgX3fp0sW9ZgceeKDtscceSXueKB8IiWmtJFa2vLy8dD0kAABIE81gruqXQtPZZ5+d1PtWle23335zwahGjRruurZt21qzZs1c9ei7776zffbZJ+79KFwWxyuvvGJNmjRxjxmkyqkCy2WXXeaqjPr/1ltvbSWh56Qg5ylcff311+65Kzh522+/fYHn07p1axcWr776ahcimzdv7qp0atvRRx/tqnte+/btrX79+q5Cd8ghh9iee+5pyfDGG2+487w77rjDKlasaLvttpv9+uuv9tRTT9n9999faPu33nrLhXNV/PScFeQUdnUM6bkq7CrgKdz6dv/999/2zDPPhELip59+arfffrsL1OEqVarkQqoC9quvvpqU54jyg+6mabJp0+Y3b34+lUQAAMoiVZE++OCDUBfKaFQRUvdOBTwFynfffTfm9mvXrnUVovBqX7t27dzj7bTTThF/zoeNn376KaHuqJEoeOnnDj/88EK3vfnmmy5g6TYFkrfffttSQZW2/Pz8uNtttdVWocqnvPfeey4oqhIXTt1U1c1T4TeS2267rVC3Vv8VrcunutCqiqiA6O27774u5EYL/wcffHCBUKy2KtTJ5Zdf7toRpHD7zz//hC6rUqiuqHfddVfEx+jRo4errk6ePDni7UA0VBLTJDfXh0QqiQAAxKNgFI1OwqtUqZLQtqrwVa1atVjbFpW6mapro07cBw4cGHEbdX8855xzXDdDfU2fPt11TVQAVJfBSLp162bbbbedHX/88a7ypa6T6tZat25d22GHHaIGRIUgdUn1ITJed9RIpkyZYgsWLLCDDjqowPUKXwo51157rVWvXt21SdW+ZFdRv//+exey4oVbjcV7+umnXehr0aKFu07jJFVhDIYwT91zFdKj0WsR7NIZpG6/kcyfP79Qt1K9bqqwqiuqwm7Q7NmzXQVYIVzBs1q1aq7q6dvVqFGjQo+h8ZmqUHrqyqr9r2pytOCsbsD6ud133z3q8wXCERLTHhKpJAIAEI9CRzSdO3d24cdTNWbduv8tNRWkLnxPPvlkgXF5GsMViSpzzz//fInbra59Cle77LJLodsffvhhN1bsqquucpe1jcam3XfffW78mR+PF7Tlllu6sXqPPfaYjR492nVTVMjZddddXZfJTp06RQ2ICpgloYlXGjZs6NoQpCqdujj6MY6qsKltCsGqphWXgrCemw+iCvXHHnus6zYZpIlqFOpFVVZ1w1R3TE2k48eELlmypNjdX1Wx01dRaJylAluQ/9BBzyM8JGocpl4rvX7XX3+961KsDxcUKvVBQjhVaseNG+d+xgt/vEjUTTjeBDpAOEJimuTmbh5ITCURAICyTdU1nfRHCpxTp0514+aC1CVRIfeXX34pUCUK2nbbbV3FURObqPqo6pqCo2Y5fe6550LBTGPgNEZNVSiF6ZJS18Y6deoUul5BVW31QUpj5xSIVE30bfEhLhLffTR8m3vvvdcFZQVFVdZ0/8Hum566ZGriGs1ceuedd7pwrgAenDRIt8fr+ptMeuzwsYF+Ihk9l3B6jgrfer186FcwHjJkiKvI+rAsX3zxhXvt9VyLWhHU6xfsogokgpCYJoREAAAS9+WXX0a9LTw0aAmKaMJDSKzxf7FCTVGoy6MqmKr8RApYwa6ywWqTgqIqckH//e9/CzxfBQdVPPWlGU+1/MPIkSNDwUxjCBUkVJlUJfGaa64p0XPR/YXvbwVRhV114wy2V8FP3RrVrVWTyvhunprhNXzSHFXdJLwraPjENdH4iWvUtfTZZ591XTQVzvW8fbjSPtJtkZ6DaEkRBV2F9HAaC6iqXSTq+hppjKaCfHiVWvtCATFShVjHhqqfwTCoy+qaqlDnA7gmp9H4RI071OtdVHrukSa2AWIhJKaJX/qC7qYAAMSXSDe6VG9bEhrTpolstHRBeAhSxTBo5syZLihofOEjjzxS6ARfyzWo22T4cg3qvqggFKyeaQyelnbQRDKqZmrG1UjdXhOlIKPuj+GzeGo/avbN4GNrVlFNvKJwrO6SLVu2DI29a9y4caHn3LRp04gVtqJSmNLsqhoPuuOOO7r1BEVBTvvzww8/LBSuFHRVeYw2drQ4YxJ33nnnQt06NWmMgl+kDyBUOZw7d26B6zQ2VR8i+El4NFZRFUQF/gMOOMCKQ6+fAixQFMxumib/Wx+JiWsAACjrtFSFugxqjFyQxh2qm6ifbVIVo8GDB1vXrl3dibwqY8Ev0Zg1jXNU+PIzd4oCidbSO/HEEws9viZA2WuvvVywLEkVSePZNNmNn/BH5zNa8F3hU5O0BNuq8YmaJEeTqfjwpglvtPzDvHnzCswCqupntBBWHJrFU+MvFQr9YymQ9+nTx3XT1TITvourlplQNVDV3l69ekW8P7U9/LXwX9EqnRo7qQqrxmuKZpXVDLDRnucpp5zixnD67RctWuSOF81Iq+qy2qyuyQqzxQ2Iog8lIq3TCMRCSEyT3FwfDgmJAACUBwog4ZOVqMp3xhlnuACpcXQKVqr+aaKZaBQ+1P1RE9eoe6QmvlHAUfjR2LxolcJbb73VLdD+xBNPFPs5aPZNVQt9qNXaiAozmmAmWvBRRdHPtqnun6qkKfgoMGrJDC3/ceGFF7rZXZPppptuchW74LIRmthHX+qCqy65++23n2u7/q9AFt71tyQUIFWZ1H5XF1Z1B9br7LumKryqe+7nn38eqjxqJly99joWFHJVCVUFWHQ/qjBHWo5Dkx0lQqFer50+hACKIic/kYVnygl9+uPftMmifvgaYL5qlX65trJ//51rvXqdbpnIt1WfGvrFejMR7WSfcoyWr/dSNrW1PLezOH9DNQbPL3yejG6HpUWzVCo4RVqOQksz6DZVtYLj4nSSr0lXNK4u0ni1aHR/mtxEPxM+zk/j31TxCy6doO6LCgoaJxm8XTN/qiqpmUuD/49EYVS3K8zoPjTuLtrSG6paqgul2hacWVTPV5PIKHCqC2t490uNw9P+0LEQa2yo3y58f3qa5VTjHSPdrnbr+atKmKzxp5H411aV4eCSKrpeQVGPH/zwIC8vz71OqlD6KqVOzzXbaTTa/8GxjHpeuo/w561lSjQxjsaKBrsGo/xal+DvXcYkpol+AWz+fUQlEQCAskSzaOorkuCJf5AqWNEWco8l2v1JeGiUYPAL3h6cUCfS5Drh4/M0MYyfkCbS43gKIr6bbPjzjRZCRaEpvOpanO20LmE0Gufnx/qlUrTXVtdH2jcKrOFjNhUAI20bjcaIRtr+5ZdfdmM0CYgoKrqbpkleni/YUrgFAADZQ+FOQXHo0KGl3RQUgbr8qvIaacwqEE9GVhLV310LhapbQIcOHaxv374xPzXSFMX6pETbq4+++rlnWjefvP8vIObkUEkEAADZRYvZawIbZA/NLvvUU0+ltGstyq6MO2o0mPfiiy92A3j1/fvvv3chMVagVBldM3hpe31qok+7Mm2o5f9CYma1CwAAIB4FDa1NiOyhbsTRukEDWVdJ1DowWlfITxesQfUHHnigqxZGWux0+PDhbhpmP0OWFhrV5SlTprj1ZzKFz6yERAAAAACZLKMqiZqt6+effy4QBvUpiIKiKoaRaKas4ABqv1io1h3KJPn5fgYqKokAABT8G8nfRgDIpN+3GRUSNS2wGh6culkaNGhQYBHWIHVL1bS+mr5ZNDZR00JrbGImhsQKFfhDCACA+BkXtSQHACD1/O/beDPeZlR3U61rI8E1ZURrePgQGK5fv372008/uQVIVVHUWkRabDbedM7RKKQm84+V1q3ZfL+hR8jYP4a+rf57pqKd7FOO0fL1XsqmtpbndurvZ3DdtkRoPTctSeB7/2jSuaLeBwAg8Yyj37f6vRtpndGMDYmVKlUKrSkYpEVgoy32eOONN9qcOXNs4MCBVq9ePXv33XftiiuusOeff9523HHHIrdBi8BqgeFky83dnBI3btyQkvtPJu3PbEA72aeZjmOUfVrejlGtA1dUfl27TBsmAgBlkQJirPVEMzIk+vGEy5Ytc11MPS3eGr7IqPzyyy/29ttv2wsvvGAdO3Z012mW099//90effRRNwlOUan0qimDk0Wf0uqPcE7O5l1drVoVN8YyE/m2NmvWzC3KmqloJ/uUY7R8vZeyqa3luZ2zZ88u1s+pcqi/+ToH0Ae1AIDUUM6JV0HMyJCoILj11lu7yWvatWsXqiLOmDHDDj/88ELb+24y4WlYi75qQpvi/rFKxRqLOTmbh39WqlQx49ZwDKcThkxvo9BO9mmm4xhln5anY7Sk3UR14pLoyQsAILUyauIa/YE59thj7emnnw6FvCeffNJ1P9WyFuHatGnjguV9991nGzZscNdp6QtNZHPwwQdbJsnP37yrK1RgrAUAAACAzJVRlUQ/Ec3cuXOta9eutuWWW7rFW4cOHWo1a9Z0t2usocYdvv76627sw+OPP2433HCDde7c2VUhNXHNueeeayeddJJlEl9J1PMBAAAAgEyVcSFRE9QMGTLEhT3NwKPlMPyENnLooYeGxh9Kq1atbMSIEbZ8+XK3zqK6msab0rV0bO5CU7EiIREAAABA5sq4kOhpptJINLDdT3ATPlOPvjLX5nDIeAsAAAAAmYyyVpq7mxISAQAAAGQyQmLau5tmbPEWAAAAAAiJ6a8kEhIBAAAAZC4qiWmSk7O5klipUpV0PSQAAAAAFBkhMc2VxEqVMnHmVQAAAADYjJCYJhUq+DGJVBIBAAAAZC5CYporiZUrV03XQwIAAABAkRES01xJrFSJkAgAAAAgcxES07WjK/gxidXS9ZAAAAAAUGSExDTIzd0QComVK9dIx0MCAAAAQLEQEtMgP39D6P+VK1dPx0MCAAAAQLEQEtMeErdIx0MCAAAAQLEQEtMcEitVopIIAAAAIHMREtMgL29zSMzLyw3NcgoAAAAAmYiQmAb5+Rvd99zcvHQ8HAAAAAAUGyExDfLyNrnv+fmERAAAAACZjZCYxkqiupsCAAAAQCYjJKZBfn5uge8AAAAAkKkIiWmQl7e5myndTQEAAABkOkJiWvhKImMSAQAAAGQ2QmJaK4l0NwUAAACQ2QiJaQyJZlQSAQAAAGQ2QmIa5Ofn//93KokAAAAAMhshMS02h0QqiQAAAAAyHSExDfLyCIkAAAAAsgMhMQ3+v7cplUQAAAAAGY+QmFZMXAMAAAAgsxES01hJzMkhJAIAAADIbITENMjPz/H/S8fDAQAAAECxERLTGBJzcgiJAAAAADIbITEtCIkAAAAAsgMhMY27Ocf3OgUAAACADFXJMtCaNWvs448/tmXLllmHDh1sp512irjdkiVL7I033oh423bbbWdHHnmkZVJ30woV6G4KAAAAILNlXCXx77//tp49e9qIESNs+vTpdtppp9kTTzwRcdvc3FxbuXJlga+FCxfaAw88YBMmTLDMqyRSSgQAAACQ2TKukjho0CDbcccd7bHHHnOhStXAc8891w477DDbfvvtC2y77bbb2pVXXlnguhtuuMFatGhh1113nWVaSKyQcZEcAAAAAArKqNiyceNGGzt2rB199NGhqlunTp2sSZMm9uGHH8b9+YkTJ9rIkSPt5ptvturVq1vmICQCAAAAyA4ZFRJ///13W79+vasEBjVv3txmzZoV9+fvvfde6969u+29996WWSpu/rdiRu1uAAAAAMjs7qYaUyi1atUqcP0WW2wRui2aSZMm2eTJk+3VV18tURvy8/PdxDnJsnbt2lAWT/Z9J9vmtv7ve6ainexTjtHy9V7KpraW53bqbxxj7wGgbMiokKg/MBL+R6ZChQpx//AoHLZv39523333End51YQ5yZSTszkkrlu3Nun3nQpz5syxbEA72aeZjmOUfVrejtEqVaok9f4AAKUjo0Ji7dq13fdVq1ZZ/fr1Q9frcs2aNWMGu08//dQuvPDCErehcuXK1rJlS0sWfUr711+/hCqkbdu2tUyltuqEoVmzZhk2prMg2sk+5RgtX++lbGpreW7n7Nmzk3I/AIDSl1EhsWnTpi6k/fHHHwXGJeoPmSaziebHH3903VG7du1a4jaoYlmjRo0S30+kSmKVKlWTft+poBMG2ln+9mc2tZV2ls/9mU1tLY/tpKspAJQdGTWTSrVq1Wy//fazt99+O3TdDz/84EKiJqSJZtq0abbVVlu5CW4yUU6On7hm83cAAAAAyFQZVUmUq666yk455RQ777zzXLfPN9980/r06ROqLI4fP96mTp3q1k70VHlUFTJT+UpixYqVS7spAAAAAJBdIVFh8L333rP333/fVq9ebUOGDCmwpMW6devs33//LfAze+65p+2yyy6WqXwlsVKljNvdAAAAAFBARqaWevXq2ZlnnhnxtgMOOMB9BfXs2dMy2f+6m1JJBAAAAJDZMmpMYlnlu5tWqlS1tJsCAAAAADEREtOgQgXf3ZT1owAAAABkNkJiOnZyhc27uXLlaul4OAAAAAAoNkJiGiuJlSvT3RQAAABAGZ+4Ji8vz2bPnm3//POPLVu2zCpXrmzbbruttWrVymrVqmXlXW7uxlAlsWLF6qXdHAAAAABITUj8+uuvbcSIEfbNN9/YihUrCt2uhePbt29vRx55pPXu3dtq1Khh5VFu7rrQ/6tUKZ/7AAAAAEAZDomff/65PfTQQ/bTTz9ZTk6ONW7c2Pbaay+3bEXNmjXd2oZLliyx33//3aZMmWI//vijDR061M4991w77bTTrHr18lVN27hxTej/lSsTEgEAAACUkZC4cuVKGzhwoL311luuQnjrrbda165dXdfSaFRhHDdunL3++ut2//3328iRI23QoEG26667WnmxadPa0P8rVSIkAgAAACgjIfH888+39evX23PPPWedOnVK6Ge23HJLO+yww9zX3LlzXQXy1FNPtQ8++MCaNGli5UFu7vrQ2M2KFSuXdnMAAAAAIDkhsW/fvrb//vuHJmEpqu23395VE08//XSrVq38LAWxceO6UEgEAAAAgDITEg888MCkPOBuu+1m5cnmSmKO5eXllnZTAAAAACCuhMuC/fr1s6eeespNSoPEbdq0wX3Pz6eSCAAAAKAMhUTNVnrfffe5iqIC4xdffEEXygTk5m4OiVQSAQAAAJSpkDh48GC3jMXWW29tY8aMsT59+li3bt3c8hYLFixIbSuzWG7uRvedSiIAAACAMhUSW7ZsaVdffbVbJ/Hpp5+2Xr162bJly2zIkCFuKQyFxo8++sg2bdqU2hZnmU2bfEhkTCIAAACAMjRxjafZTTXLqb5WrVplH374ob3zzjv25Zdfui6odevWtWOOOcaOO+44a9asmZV3ubmbwyGVRAAAAADZoHjrWfy/mjVrujD4wgsv2NixY61///7uOk1wc8ghh7jlLkaNGmUbN26uppVH/xuLSCURAAAAQBkPiUGNGze2iy66yEaPHm2vv/66G784b948u+qqq9ykN+VVbu7m7rdUEgEAAACUq5DoLV++3GbOnGmzZ88OLZehLqrlVV6eX/qCJTAAAAAAlMExiZGsW7fOPvnkE9e19KuvvnLdS2vVqmW9e/e2448/3k16U95DIhPXAAAAACjTIVETsowbN87effddN6vpmjVr3PV77bWXG6d46KGHWrVq1ay8y83NNxVSc3KoJAIAAAAogyFxypQprmL4/vvvh7qT1qtXz0499VRmNI0gPz////9HSAQAAABQhkLic889Zy+99JLNnTvXXa5YsaIddNBBLhh26dLFKlVKSs/VMicvL98qVnT/K+2mAAAAAEBcCSe7kSNHuoDYtGlTO/bYY91aiNtuu22iP15uheatMV9RBAAAAIAyEBK17uFNN91kHTt2tJycnNS2qgzxvU1zcgiJAAAAAMpQSOzXr1/o/4sWLbIFCxbY1ltvbU2aNElV28pYSKS7KQAAAIDMV6SBhL/++qvdcsstNn78+NB1LVq0sBtuuME6d+6civZlvby8zVVXiq8AAAAAylRIXLZsmZ1xxhm2ePFiN0lNo0aN7O+//3bB8fzzz7fhw4fbnnvumdrWZqH8/Bxbv369bdy43tauXVvodk0AVKVKldDlSNt4FSpUsKpVqxZrW61l+b+ZVgtS9+HgciXaNlqX4vBt9dz8WpCRVK9evVjbbtiwwS2zEkn48461rai9/vkkc1vtX+1n0dqgmzZtKtRO7Ut91/3G2rYo9xttW22n7aPRcabjLdK2wbbq+Qe31T7QvoimcuXKoYmrirKtjgUdE9FoO20f3Da8nbG2Lcr9RhN8f+r9o8cuyrbh7Yy0bbz3cip/RwQV9XdEotsm63dEUd/3if4+SfbviHS/74v7OyLWsQEAQMIhccSIES4gNmvWzJ555hlr3Lix+yNzzTXX2OjRo23IkCEuKKIgnUuoq25+/jqrXbvw/lEF9qGHHgpdPvjgg6OeiO6xxx725JNPhi4fccQRtnz58ojbtmvXzp5//vnQ5eOPP951EY5khx12cK+v16dPH/vjjz8ibtugQQO3NmZw259//jnitltttZWNHTs2dFn7YdKkSRG31cnUV199Fbp81VVX2ddffx1xW51EPvXUU6HLGiv78ccfWzRffvll6IRx4MCB9t5770XdVmt+qhu1PPjgg/b6669H3VZLwTRs2ND9/9FHH7UXXnihUDv1Wuq5aeIn7WcZNmxYgdcxnF43vX7yyiuv2MMPPxx12yeeeMI6dOjg/v/mm2/aoEGDom47ePBg22+//dz/P/jgA7v11lsjtlUnlHfffbd1797d3fbpp5/atddeG/V+BwwY4I5F+eabb+zSSy+Nuu3VV19tJ5xwgvv/5MmT7YILLoi6bf/+/d0HUzJjxgz3//B2evqgSl8yZ86c0GNEcvrpp9sll1zi/q8Puo488sio2+p9o99xovea3p/R9OrVy/W0ELVR743wdnrdunWze+65J3R5//33j3q/qfwd8fjjjxfrd4Rei99++y2tvyMUlPV3JpHfETJhwoRS+R0RPEZ1P7F+RwRp/6bzd0T471EAAIIKn71E4f9w64+4AqLoj6pOEPWp6sSJE2NWEMqrZs0aW27ueqtWrUZpNwUAAAAA4srJj9ZnKEzv3r3tp59+cp9E7rTTTgVu0zqJ+gRaFQf/qWk2mjp1qvu+8847J+0+16xZ4yombdq0sRo1amR0d1O1dfr06da8efMCXbUibVua3U3VTlWL2rZt6/ZppnY3VTtVAdNrr8pDJnc3DbZV+zRTu5uGtzPWtkW532R3N129erX98MMPSXnfp/J3hF4vvef1XtLlTO5uWtT3fWl1N033+764vyPC92em/g0FAGR4d1P/h8WfXAXVrFkz9EcHkU8qdMISLXgFJbJNcbYNnrQlsm2i9x08IU3mtsGT4nDhJ6exti3K/ZZkW70vwt8baqffl8Euh5G2Lcr9xgo/PoAVddtgW8Nfe4WURI+HomyrfVLUbWO1syT3mwgFg6Jsmwnv+3jbBn9nF/V3RKKS9TsiE9/3kbZN9/u+uL8jEvx8GABQTiXc3TSRPyixPi0uKn1Cu2TJEitKiNWYSf7wAQAAAEAaQmK6qOvObbfd5gbaa4KGQw891KZMmRLzZx577DHr1KmT9ezZ0/bZZx83oQgAAAAAoAyERM229sUXX7gZ5L7//nvr2rWr9e3b143xieTll1+2p59+2s24+t1337k1G6+//nq3NAcAAAAAIEVjEr3rrruu0CD3P//8M+ptfkrxJk2aJHT/L774oguF2223nbt8+eWX2xtvvOFC49FHH11gW3UtVUDUFOu77rqru07T2Wu5gfHjx1uLFi2K+vQAAAAAoFwrckicNm1akW9LdNFehc1FixYVmBlNg+w1+5qW4AgPidp+/vz5bs0xjYdctmyZbbPNNgXWBwQAAAAApCAkagHe4s5emmgVURPPSJ06dQpcr+Cn8Bhu7ty57rsWddai3KtWrQotsqyFoYtD1clkztLqA3KiQbk0ZUtbaSf7lGO0fL2Xsqmt5bmd+vvplwcBAJSTkNiuXbvUtuT/18iS8Om8VU2MtP6b/+P25JNP2ksvvWQNGjSwsWPHWr9+/axx48ZuMpui0uNo3bBk03pU2SJb2ko72aeZjmOUfVrejtGiLCECAChD3U1FVb0FCxa4hYITrRIWZU2v8MWttXBzpLGOPkyef/75LiBK9+7drXPnzvb2228XKyTqPlu2bGnJoiCrP8LNmjUr0vpmpSFb2ko72acco+XrvZRNbS3P7Zw9e3ZS7gcAkGUhUTOG3nLLLW5SGE+Tw2hGUQWzklL1TxYuXFggfP7zzz+2++67F9q+YcOG7nv9+vULXF+vXj13H8WhrjKRAmlJ6Y9wKu43FbKlrbSTfZrpOEbZp+XpGKWrKQCUwyUwNCnMGWec4QKiun82bdrUqlat6oKjKnkTJkwocWM09rBVq1b27bffhq5bsWKF/fzzz7b33nsX2l4BVYEwGFo1JkIT6Oy4444lbg8AAAAAlDcJh8QRI0a4iWXUNWX06NE2ZswYty7hIYccYps2bbIhQ4YkpUEXXnihWyvxrbfesilTplj//v2tTZs2duCBB4ZCo2Y0dY2vUMEtkfHYY4/Zm2++aTNnzrTbbrvNdYU97bTTktIeAAAAAChPEu5uqiUoxE8K47upDBgwwAXGiRMn2oYNG0o8aL1Xr14udL7yyiu2evVq22OPPezSSy8NdWN57bXX3LqJCqrSu3dvq1mzpr3wwgtuApvWrVvbq6++ao0aNSpROwAAAACgPEo4JPolKJo3b17gei1XoYXvVb1TpdGPEywJrYcYviaip66t+grq0aOH+wIAAAAApKm7qV+CInx5ClElT5K5viAAAAAAIINDoiaEiScvL6+k7QEAAAAAZENIBAAAAACUfYREAAAAAEDRJ67xrrvuukIL7/75559Rb5OBAwdakyZNivpQAAAAAIBMD4laqL6ot61du7aoDwMAAAAAyOSQOGjQoGLPXkoVEQAAAADKWEhs165dalsCAAAAAMieiWv++uuvpDzgihUrbNWqVUm5LwAAAABAKYXEvn372s0332xLliwp1gNt3LjRnn/+eevRo4ctWLCgWPcBAAAAAMiQkHjXXXfZ5MmTrXv37nb77bfb9OnTE/q5+fPn20MPPWRdu3a1+++/3y6++GJr1apVSdoMAAAAAMiEMYlvvPGGPf744zZs2DB78cUXrWHDhrbHHnu40FevXj3bYost3OQ2S5cutd9//90mTJhgc+bMcT9/0EEH2VVXXWUtWrRI1XMBAAAAAKRzCYwqVapY//797cwzz7QXXnjBXn/9dXvvvfeibl+1alU77LDD7LzzzrP27duXtK0AAAAAgExbJ1G23HJL121UX7Nnz7ZJkybZP//8Y8uXL7dKlSq5quKOO+7oqow1atRIfqsBAAAAAJkTEoNatmzpvgAAAAAA5WjiGgAAAABA2UdIBAAAAACEEBIBAAAAACGERAAAAABACCERAAAAABBCSAQAAAAAhBASAQAAAADJWydx1qxZNnv2bNuwYYPl5eVF3KZ79+5Wu3btkj4UAAAAACBTQ6JC4eWXX24fffRR3G3bt29PSAQAAACAshwSX331VRcQK1SoYD169LBWrVpZlSpVIm5bt27dkrQRAAAAAJDpIfHTTz913/v27Wv9+/dPZpsAAAAAANk2cc3y5cvd9y5duiSzPQAAAACAbAyJDRo0cN+XLFmSzPYAAAAAALIxJB5xxBHu+/PPPx91VlMAAAAAQDkZk9i6dWvbe++9bdy4cXbyySdbt27drE6dOpaTk1NoW5bAAAAAAIAyHhIvueQS++WXX9z/f/jhB/cVDUtgAAAAAEAZD4lnnnmmLVu2LKFtWQIDAAAAAMp4SDz++OOT2xIAAAAAQPaGxEg2bNhgVapUKfH9fPfdd/byyy+7SuWee+5pffr0serVq0fcdtWqVXbOOecUuv7SSy+1fffdt8RtAQAAAIDypMQh8fPPP7dhw4a5MYlr1651Ya5p06bWs2dPO+uss4ocGjURzn/+8x835nH77be3Rx55xCZPnuweIxKNi5w2bZq98MILVrFixdD1agMAAAAAII0h8fHHH7cHH3zQ/V+zmtarV8+WL19uM2bMcF9jx4514a1q1aoJ36fu75RTTrGzzz7bXd55552ta9eu9u2339o+++wTMSQ2adLEOnToUJKnAgAAAAAoyTqJP/74ow0ePNiFw379+rlq31dffeWuf+KJJ6x+/fru/0OHDk34PleuXGlTp061/fbbL3Tdtttua23atHH3HcmsWbNshx124MUEAAAAgNIMiSNGjLD8/Hw74YQT7OKLLw6NGVSXzy5duti9997rLr/++uuWl5eX0H3OnTvX3WejRo0KXN+wYUN3WySqJOpnbrrpJjfj6oABA2zevHnFfVoAAAAAUK4Vu7upKnhy6KGHRrx97733tq222spNPrNo0SJXWYxnzZo17nu1atUKXK/LS5YsiRoSt9hiCzvqqKPs4IMPtpEjR9qRRx5pb731ljVr1qzIz0uB07cjGTROM/g9k2VLW2kn+5RjtHy9l7KpreW5nfr7qd5FAIByHBJ9dbBy5cpRt/G3adbTRPiJZ8Irj7m5uVHHNT722GNukhoFUlFX1WOOOcZNeOOrmUWxceNGmz59uiXbnDlzLFtkS1tpJ/s003GMsk/L2zGajBnOAQBZHBI1DlCzimqs4F577VXodk1cowqiuqEmUkUUTXwjmvymQYMGoetVjVSX00h23XXXApcrVKhgu+22mxvbWBwKti1btrRk0ae0+iOsqma0ZTwyRba0lXayTzlGy9d7KZvaWp7bOXv27KTcDwAgi0Ni7969bdSoUfbss89aq1atrFevXgX+UFx11VXu/4cddljCnyw2btzYVQRVyWvbtm2oqjhz5kw75JBDCm3/559/2uWXX2533HGHtW7dOnT9ggULCoTMolBXmRo1aliy6Y9wKu43FbKlrbSTfZrpOEbZp+XpGKWrKQCUHcWeuKZTp0526qmnuq6kV1xxhXXu3NlOOukk69GjhxsTqDGLWufQh8WEGlOhgusq+swzz7jqoWh9xPXr17uwGU4T3GhG1CFDhoS6tH788cf2xRdf2GmnnVbcpwYAAAAA5VaJ1km8+eab3fIUw4cPd9XDxYsXu+tVDTz88MPtkksuCY0VTJSW0/jtt9/c2oh16tRxXWIefvhhq127trv9pZdesg8++MBefPFF96mllti48sor3YyqtWrVcl1cNdOpQiwAAAAAII0hUbQEhr7+/fdfN5ZQE8xobGFxu51optInn3zS5s+fb6tXr3bjJYLdVRUed95559BljR/UTKbqYqqqYvPmzaNOcgMAAAAASHFI9FTF01eyhK+V6GmsYfh4QwVSTWwTbXIbAAAAAECSQ+LYsWNdpa579+6u66e/nAj/MwAAAACAMhISBw8e7Baub9++vQt8/nIi/M8AAAAAAMpISDzzzDPdjKN169YtcDkR/mcAAAAAAGUkJB5//PExLwMAAAAAyvE6iQAAAACAsqfEIXHChAm2YsUK9/9169bZPffc46qMF198sf3www/JaCMAAAAAINOXwNi4caMLgp999pm9++67tuWWW9qAAQPs7bffDm2j25599lnr2LFjstoLAAAAAMjESuKoUaNcCNTi9fXq1bMlS5a4sCj333+/3XDDDS5I3nfffclsLwAAAAAgE0Pip59+6r5fcskltvXWW9snn3xiubm5rqLYs2dPO+2006xWrVo2ZcqUhNdTBAAAAABkaUj866+/3PemTZu671999ZX7vvPOO1tOTo5VqFDB6tSpY/n5+a7KCAAAAAAowyFxiy22cN/Xr1/vvk+dOtV932effULbrF271n2vXr16SdsJAAAAAMjkkNiqVSv3/ZtvvrFZs2bZ/Pnz3eVu3bq577q8cOFCq127ttWvXz9Z7QUAAAAAZGJIPOmkk1yF8OGHH7bjjjvOXXfggQfaDjvs4P5/8803u+/HHnus634KAAAAACjDIbF169b2/PPPW4cOHaxu3brWu3fvAjOZLl682AXEK6+8MlltBQAAAABk6jqJsssuu9hLL70U8bYXX3zRzW4KAAAAACgHlcR4CIgAAAAAUIYriWPHjnXrHXbv3t1NRuMvJ8L/DAAAAACgjITEwYMH2y+//GLt27d3gc9fToT/GQAAAABAGQmJZ555pi1btsxNUhO8nAj/MwAAAACAMhISjz/++JiXAQAAAADZLykT16iiuHbt2tDlb775xlatWpWMuwYAAAAAZEtIXLBggfXp08c6d+5s8+bNC11/55132r777muvvvpqMtoIAAAAAMj0kLhw4ULr3bu3ffHFF9amTRvbeuutC3RFrVq1qg0YMMBee+21ZLUVAAAAAJCpIfGZZ56xpUuXWo8ePWzkyJFWr1690G2a1Obhhx92/x86dKjl5+cnp7UAAAAAgMwMiT/88IP7fvrpp1uFCoXvplOnTm5W03/++cf++uuvkrUSAAAAAJDZITEnJ8d9j1Ul9Nvk5eUV92EAAAAAANkQEnfYYQf3/fPPP494+6xZs2zRokVWo0YNq1+/fvFbCAAAAADI/JB47LHHuu/PP/+8+9qwYUPothkzZtgVV1zh/n/EEUdYlSpVktFWAAAAAECKVSruD+6555524YUX2uOPP+6WvLjrrrvc5DXr16+35cuXu23atm1rV111VTLbCwAAAADIxJAol112me2+++5uPURNZKNJaipVqmStW7e2ww8/3M466yyrXr168loLAAAAAMjckChdunRxX5Kbm2sVK1ZMRrsAAAAAANk0JjESAiIAAAAAlPOQOG3aNLv22mvtkEMOsb322st+/fVXd/3AgQPdBDbFoXGNY8aMsddee81++eWXhH9Oy3G88sorNn/+/GI9LgAAAACUdyUKiS+//LKdcMIJ9tZbb9mcOXNs5cqVrsupjBs3zk4//fQihTzRuMZevXrZM888Y+PHj3f3P2zYsIR+9tlnn7VbbrklFFQBAAAAAGkKiT/99JPdfvvtVqtWLRs+fLi1bNmywO3HHXecC42DBw8u0v0OGjTImjZt6iqC999/vz300EN233332bx582L+nKqWQ4cOLdZzAQAAAACUMCQqxOXl5dm5555r++yzj+Xk5BS4/ZRTTnHrI3766ae2cePGhO5T26mbqdZgrFBhc9MOOOAAa9SokY0ePTrqz2mNRi21cf755xf36QAAAAAAShISZ86c6b7vscceEW9XQGzQoIHrfqoupIlQl1WNR2zRokWB65s3bx56vEhUaaxbt67r3goAAAAAKIUlMDRJjIRXEINWrFhRpPv029euXbvA9TVr1ox6X99884298847NmrUqJhtKcrzWrNmjSXL2rVrC3zPZNnSVtrJPuUYLV/vpWxqa3lup/5+JuPvMAAgi0Niq1atbOrUqTZ58mTr0KFDodsnTpxoy5cvdwGvfv36JQqevutpOAVHzaw6YMAA9xirV6+2klKX1+nTp1uyqUqaLbKlrbSTfZrpOEbZp+XtGFUvIgBAOQ6Jxx9/vL355pv29NNPuzGJQVOmTLFrrrnG/V8zlVaqlNjDaBIcCQ97uuxvC3rggQdcgFR31ueeey409nHs2LG2bt0669GjR5GfV+XKlQtNwlMS+pRWf4SbNWtm1atXt0yWLW2lnexTjtHy9V7KpraW53bOnj07KfcDAMjikKixiP369bMhQ4YUmGhG4wJVQfTVxiuuuCLh+9QfKwXKuXPn2g477BC6/o8//nBhM9xOO+3kPrX06yJu2rTJfV+yZIktXry4WM9LVcwaNWpYsumPcCruNxWypa20k32a6ThG2afl6RilqykAlB3FDoly8cUXu6Cm9QnV7VSznSogNmzY0IW6Cy64wHU3TVS1atVs3333tXfffde6dOnirps2bZr99ttv1q1bt0Lbaw3F8Iqj1m488cQT3ayoAAAAAIA0hcRffvnFttpqKzvooIPcl2Yx/ffff61q1aol6rqipSy0fMZFF13kun2OGDHCzjzzTGvdunVorKPGDJ522mnFfgwAAAAAQJKXwHjwwQftwAMPtEmTJrnLFStWdKGxpGMbFAZVSdx1113d5XvuucdNTuOtXLky1L000njCM844w62rCAAAAABIYyVx4cKFrnqYipnMtL7i+eefH/E2X7mMRG254YYbkt4eAAAAACgvil1J9EFt3LhxyWwPAAAAACAbK4mamEZLTwwePNh++OEH69ixo22zzTau22k4TSITaQkLAAAAAEAZCYma2VST18jHH3/svqLRGENCIgAAAACU4ZB48skn29KlSxPatk6dOsV9GAAAAABANoTEU089NbktAQAAAABkZ0hctGiRLViwwLbeemtr0qRJ8lsFAAAAAMj8kPjrr7/aLbfcYuPHjw9d16JFC7fsROfOnVPRPgAAAABAJi6BsWzZMrdQvQJipUqVrGnTpla1alUXHLWm4YQJE1LbUgAAAABA5oTEESNG2OLFi61Zs2Y2evRoGzNmjH333Xd2yCGH2KZNm2zIkCGpbSkAAAAAIHNC4qRJk9z3fv36WePGjd3/q1evbgMGDLCcnBybOHGibdiwIXUtBQAAAABkTkjUZDXSvHnzQstbbLfddrZx40ZXaQQAAAAAlIOQqBAolStXLnRbzZo13fc1a9Yks20AAAAAgEwNifn5+XG3ycvLK2l7AAAAAADZEBIBAAAAAGUfIREAAAAAEFLJiui6666zGjVqFLjuzz//jHqbDBw40Jo0aVLUhwIAAAAAZHpInDZtWpFvW7t2bVEfBgAAAACQySFx0KBBxZ69lCoiAAAAAJSxkNiuXbvUtgQAAAAAUOqYuAYAAAAAEEJIBAAAAACEEBIBAAAAACGERAAAAABACCERAAAAABBCSAQAAAAAhBASAQAAAAAhhEQAAAAAQAghEQAAAAAQQkgEAAAAAIQQEgEAAAAAIYREAAAAAEAIIREAAAAAkPkhcdOmTbZ8+fKEt9+wYYP9+++/KW0TAAAAAJR1GRcS8/Ly7M4777Tdd9/dunTpYj179rRp06ZF3X7NmjV21VVXWceOHW3//fe3k046yX777be0thkAAAAAyoqMC4lPP/20ffzxx/bhhx/ahAkTXPC78MILXRiMZODAgTZv3jz74osv3PZNmjSxvn37Wm5ubtrbDgAAAADZLuNC4gsvvGDnnHOONWrUyCpVqmRXXHGF60o6ZsyYQtvq+u+//9769etntWvXdtuff/75NmfOHJs5c2aptB8AAAAAsllGhcT58+fbP//8Y7vsskvousqVK1vbtm1t8uTJhbavUqWKjR492jp37hy6btmyZe579erV09RqAAAAACg7KlkGWbx4sftep06dAtfrssJjLKtWrbKpU6faHXfcYYcddpg1b968WG3Iz8+P2rW1ONauXVvgeybLlrbSTvYpx2j5ei9lU1vLczv19zMnJydp9wcAKD0ZFRLXrVsXqh4GqRupupbG8txzz9nnn39uCxYssOOPP77Yf6w2btxo06dPt2RTF9hskS1tpZ3s00zHMco+LW/HqHr4AACyX0aFRN9FdP369QWu1+Utttgi5s9efPHF7ktjETXDqZx11llFboMCasuWLS1Z9Cmt/gg3a9Ys47vAZktbaSf7lGO0fL2Xsqmt5bmds2fPTsr9AABKX0aFRE1WIwsXLnSzlHq6rCUxwqm6uHTpUtt2222tQoXNwyt33HFH23fffe3LL78sVkhU9bFGjRqWbPojnIr7TYVsaSvtZJ9mOo5R9ml5OkbpagoAZUdGTVyjsYeq4o0fPz503cqVK+3nn3926yCG0yQ1Bx54oI0bN67A9X/99Zdts802aWkzAAAAAJQlGRUSRUtYPPXUUzZq1CgXDi+99FJr3bq1C4N+ghpVFqV+/fp29NFH2+23327ffvutzZo1y26++WbXhea8884r5WcCAAAAANkno7qbylFHHeUmjxk+fLitXr3aOnToYPfdd1+oO+lLL71kI0eOtI8++shdVkAcNmyY20YT37Rr187eeecd23777Uv5mQAAAABA9sm4kCjHHXec+4rkggsucF/BmdTCrwMAAAAAlJHupgAAAACA0kNIBAAAAACEEBIBAAAAACGERAAAAABACCERAAAAABBCSAQAAAAAhBASAQAAAAAhhEQAAAAAQAghEQAAAAAQQkgEAAAAAIQQEgEAAAAAIYREAAAAAEAIIREAAAAAEEJIBAAAAACEEBIBAAAAACGERAAAAABACCERAAAAABBCSAQAAAAAhBASAQAAAAAhhEQAAAAAQAghEQAAAAAQQkgEAAAAAIQQEgEAAAAAIYREAAAAAEAIIREAAAAAEEJIBAAAAACEEBIBAAAAACGERAAAAABACCERAAAAAEBIBAAAAAAURiURAAAAABBCSAQAAAAAhBASAQAAAAAhlSwDTZgwwV555RVbtmyZdejQwc4991yrVq1axG3z8/Pt/ffft48//thWrFhhrVu3dtvXrVs37e0GAAAAgGyXcZXEb775xoW8Nm3a2EknnWRjxoyxiy66KOr2gwcPtrvuusv22WcfO+OMM2zevHl29NFH29KlS9PabgAAAAAoCzKukvjggw/aKaecYn369HGXd911V+vatauNHz/eOnbsWGDb9evX27Bhw+zuu++2ww8/3F237777Wo8ePWzEiBF24YUXlspzAAAAAIBslVGVxJUrV9qUKVNs//33D11Xv359V1X88ssvI3Y1ffbZZ61Lly6h6ypXrmwNGza0P//8M23tBgAAAICyIqNCorqKKvg1atSowPW6/McffxTaXuMU99xzT6tRo0bouiVLlthPP/1kbdu2TUubAQAAAKAsyajupqtXr3bfq1evXigMKvzFo4B56623uurjscceW6w26D7WrFljybJ27doC3zNZtrSVdrJPOUbL13spm9pantupv585OTlJuz8AQOnJqJBYsWJF9z03N7fA9bpctWrVuD+vsYkTJ060F198MepsqPFs3LjRpk+fbsk2Z84cyxbZ0lbayT7NdByj7NPydoxWqVIlqfcHACgdGRUS69Wr574vX77cGjRoELo+/HIkAwcOdDOhvvDCC9a8efNit0FjGlu2bGnJok9p9Ue4WbNmhSqkmSZb2ko72acco+XrvZRNbS3P7Zw9e3ZS7gcAUPoyKiQ2btzYttxyS5sxY0ZoTKG6r+jywQcfHPFn8vLy7JZbbrHvv//era0YL0zGo64ywTGOyaI/wqm431TIlrbSTvZppuMYZZ+Wp2OUrqYAUHZk1MQ1FSpUcGscasbSFStWuOuGDx9u69ats8MOOyzizwwYMMDGjRtnL730UokDIgAAAACUdxlVSZT+/fvbr7/+6tZGrFu3rlsW46GHHnIVRlG18MMPP3ThUWsnaj1EzX560UUXFbgfrZfYr1+/UnoWAAAAAJCdMi4k1qxZ05555hmbO3eum+1U4wuDk9AccMABtuOOO7r/6zZVECPZZptt0tZmAAAAACgrMi4kettvv33E61U19OsoaqIbP9kNAAAAAKCMjUkEAAAAAJQuQiIAAAAAIISQCAAAAAAIISQCAAAAAEIIiQAAAACAEEIiAAAAACCEkAgAAAAACCEkAgAAAABCCIkAAAAAgBBCIgAAAAAghJAIAAAAAAghJAIAAAAAQgiJAAAAAIAQQiIAAAAAIISQCAAAAAAIISQCAAAAAEIIiQAAAACAEEIiAAAAACCEkAgAAAAACCEkAgAAAABCCIkAAAAAgBBCIgAAAAAghJAIAAAAAAghJAIAAAAAQgiJAAAAAIAQQiIAAAAAIISQCAAAAAAIISQCAAAAAEIIiQAAAACAEEIiAAAAACCEkAgAAAAACCEkAgAAAAAyOyRu2LDBPv74Yxs5cqT9+uuvCf/c/Pnz7bPPPktp2wAAAACgLMu4kLho0SI74ogj7NFHH7Uvv/zSjj32WBs+fHjcn1u7dq1ddtll9sorr6SlnQAAAABQFlWyDDNo0CBr3LixPfXUU1ahQgVXGbzooousW7du7vpI5s2b5wLi1KlTrUuXLmlvMwAAAACUFRlVSdy0aZONGTPGVQ8VEEWhr2HDhjZ69OiIPzNjxgw7/PDDrX79+ta9e/c0txgAAAAAypaMColz5syxdevWWcuWLQtcv8MOO7gwGEn16tXt6aeftkceecRq1aqVppYCAAAAQNmUUd1Nly9f7r7Xrl27wPU1a9a0FStWRPyZpk2buq9kyc/PtzVr1iTt/jRWMvg9k2VLW2kn+5RjtHy9l7KpreW5nfr7mZOTk7T7AwCUnowKifoDI+F/ZHzX03TYuHGjTZ8+PSVV0myRLW2lnezTTMcxyj4tb8dolSpVknp/AIDSkVEh0XcXXb16dYHrdTldXUkrV65cqLtrSehTWv0Rbtasmesam8mypa20k33KMVq+3kvZ1Nby3M7Zs2cn5X4AAKUvo0Kiuo1WqlTJzVaqcYje3LlzrWfPnmlpg6qYNWrUSPr96o9wKu43FbKlrbSTfZrpOEbZp+XpGKWrKQCUHRUy7Y9Vp06d7N133w1d9/PPP9uvv/5qBx10UKm2DQAAAADKg4yqJMqVV15pp5xyivXv3991+3z11VfttNNOszZt2rjbJ0+e7GY6Pfnkk0u7qQAAAABQ5mRcSFQYVCVx1KhRbizinXfeWaCKuHTpUvv9998j/qyqkMmcmRQAAAAAypuMC4nSqFEj69u3b8TbunXr5r4iOeqoo1LcMgAAAAAo2zJqTCIAAAAAoHQREgEAAAAAIYREAAAAAEAIIREAAAAAEEJIBAAAAACEEBIBAAAAACGERAAAAABACCERAAAAABBCSAQAAAAAhBASAQAAAAAhhEQAAAAAQAghEQAAAAAQQkgEAAAAAIQQEgEAAAAAIYREAAAAAEAIIREAAAAAEEJIBAAAAACEEBIBAAAAACGERAAAAABACCERAAAAABBCSAQAAAAAhBASAQAAAAAhhEQAAAAAQAghEQAAAAAQQkgEAAAAAIQQEgEAAAAAIYREAAAAAEAIIREAAAAAEEJIBAAAAACEEBIBAAAAACGERAAAAABACCERAAAAAJD5ITE/P9/Wrl2bsu0BAAAAAFkQEhX27rvvPttjjz1sr732st69e9uMGTOStj0AAAAAIItC4rBhw+y9996zN9980yZOnGi77babXXDBBbZu3bqkbA8AAAAAyKKQOHz4cDv77LOtefPmVrVqVbv22mttzZo1NmbMmKRsDwAAAADIkpD4119/2d9//+2qgV6VKlWsbdu2NmnSpBJvDwAAAACIrZJlkEWLFrnvdevWLXB9nTp1bOHChSXePp6NGze6MY5TpkyxZNH9yS+//GI5OTmWybKlrbSTfcoxWr7eS9nU1vLcTv0NzeTnDADI0pDoZyetXLlyget1eeXKlSXePh7/xy2Zf+R0X6puZoNsaSvtZJ9mOo5R9ml5PEZ1n4REACgbMiokVq9e3X3fsGFDgevXr19vW2yxRYm3j2f33Xcv8s8AAAAAQFmSUWMSGzVq5L7/888/Ba7X5QYNGpR4ewAAAABAFoVEjS3ULKXff/996LpVq1bZzz//7NZALOn2AAAAAIAs6m4qffr0sTvvvNOaNWtmLVu2tHvvvdcFwYMOOig0DlFrIG699dYJbQ8AAAAAyOKQeOyxx7oxhUOHDrXVq1fbHnvsYU8++aRVrFjR3f7ss8/aa6+9Zl988UVC2wMAAAAAEpeT7+fBBgAAAACUexk1JhEAAAAAULoIiQAAAACAEEIiAAAAACCEkAgAAAAACCEkAgAAAABCCIkAAAAAgMxdJzFbzZs3z3777Tdr2LChtWrVKunbJ8vy5ctt2rRpVq1aNdt9990TXk/yhx9+sEaNGlm9evUsHTZu3Gg//vijrVmzxq19WbNmzZjba43MGTNmuDUzW7dubXXr1rV0mTlzpi1YsMA9rl7PWLTizE8//WRLliyxnXfe2bbZZpu0tXPhwoVuH+k1bNeuXcI/9+uvv7rjpkOHDpYOq1atsqlTp1qFChXcMVqlSpWo2/7999/u2AzXo0cP9/OplJeXZ1OmTLEVK1bYLrvsYltvvXXCx0qLFi2sSZMmli76XTN37lxr3ry5NW3aNOp2Y8eOtU2bNkW87dBDD7VU0/tC748tt9zS7dOcnJyY2y9dutSmT5/u9n2bNm1S/pp769atc7+ftK/0vtDv03jHtJ6Xft/utttuVqlSev/0rly50u2nvffeO+62aufixYutbdu2tu2226alfQCAzENITIIHH3zQXn75Zdtpp53s559/tgMOOMAGDRoU9YSlqNsny6effmpXX3217bjjju5EtUaNGjZs2LC4gUptPOuss1y7DzroIEs1tU2PpxOpLbbYwn7//Xd7+OGHrVOnThG3//zzz+2aa65xIVZhUidvl1xyiZ199tkpbadOEC+77DKbPHmy7bDDDi4w9O3b1y644IKoJ4rnn3++LVq0yBo3buzCzbXXXmsnnniipdrw4cPdPmzfvr398ssvLiQ++uijMQOYKACdc8457gT8iSeeSHk7J06caBdddJE1a9bMPfaGDRvs2WefjRps3nvvPXcMhwfYbt26pfT9pNCs/fLvv/+60K0T8IEDB9phhx0Wcfu1a9e6Y1If0Ojke9KkSe4Y13WppA8lBgwYYKNHj3aPq/fG8ccfb9dff33E7bWdPmgJ+uabb1wISnVIfOedd+y2225zvxf/+OMP22677ezpp5+2WrVqRdz+3XfftZtvvtmFSX3opu0ff/xxq127dkrbOXv2bDv33HOtTp067oMCvZ/13tB7K1rwvu6669x7Xu83bf/II4+41yMd1MYbb7zRPe4rr7wSdTsdo/r9NWfOHPcBhj6o0e/Vk08+OS3tBABkmHyUyLhx4/Lbt2+fP3v2bHf5zz//zN9nn33yR4wYkZTtk+Xff//N79ChQ/5rr73mLq9fvz7/tNNOy7/00ktj/tyXX36Z37Fjx/zWrVvnf/LJJ/npcN555+X369cvPzc3110eMmRIfufOnfPXrVtXaNu1a9e65/Xss88WaHObNm3yp0yZktJ26jEPOuig/GXLlrnL33//fX7btm2jPu4tt9ySf/LJJ+dv2LDBXX7//ffd9nPnzk1pO2fOnOkeZ8KECe7ykiVL8rt165b/yCOPxP1ZHR877rhj/vnnn5+fatovXbp0yR86dKi7rNdfx4GO02iuvvrq/Ouuuy4/3a699lrXLr2P5NVXX83fbbfd3L6N5M4778zv3r17/tKlS93lSZMmuWP0xx9/TGk7R40a5d6/CxYsCB0Lu+66a8Lv5c8//zx/p512yp84cWJK27lw4UL3e3HMmDHu8qpVq/KPOeaY/FtvvTXi9trPeh7+9+aaNWvyDz/88Pzbb789P9WOPvpo91729P/DDjssPy8vr9C2f//9tzsuHnjggdB1TzzxhPu9od9dqabf+3oP6ff3SSedFHPb+++/P/+II45w+17Gjh2b365du/w//vgj5e0EAGQexiSW0Ntvv23777+/6z4mqmYdeeSR7lPxZGyfLPo0W1WFY4891l3WJ9rnnXeeffTRR66rZiRDhgyxCy+80E455RRLF3U3++KLL+yMM84IVYLUTlVuvv7664hVx3333dd69+4dum6//fZzVYXx48entK1vvfWWHXPMMbbVVlu5y3vuuaf7ivZa6hN9fVJfuXJld/nggw9210XqLplMao+qHL7api6uql7GO+Z0uypPqsqlg14vdR/Vay96/VWV1fV//fVXxJ9RVdS/l9JFXaH/+9//2qmnnhqqxJ5wwglWvXp19z4Lp2royJEjXYXUd0lVN1q9r/7555+UtlW/bw455BD3fhB1idbrmcjvG1UUValTJUldvlPp/fffdxVZvSdEPQh0HKhSrPdIpC6Rqnz5yq32vXo5pPo9r+7CvmeFp9+R6pKtyls4VWF1vOi199TDQa+7bkslvWfU7frPP/+07t27J/T7TMex9r3oOFEPCVVsAQDlDyGxhHTCoBOvoJYtW7qTmGRsnyx6XD1OcAyiLusERifakajL0ahRo9xJULqonaIusZ66uqktkfaRxlipG6XGMHk6eVy2bJk7cUwVnfhrv4W/lhpfGu21vPXWW90HBN6sWbNccI83jrGkIh1zaqe6lakLbLQTzDvvvNPuueeeqN39kk37rUGDBgUeT+3UuDR/XAQpPOjkXF1T1eV33Lhx7sOEVNNj+rGvntqosKrupJGChT6I0YcZ2q/qHq3ukTfddFNCJ+8l3afB91JRft+oi7LGBPfr189STe2J9HtRXY61r8L5sbzqiu5pzKX/wCZVdBzq91Gw+3P9+vVdF9dI+1RjAdUFPtitWx8S6T7URTmV9P644oorbMSIEXF/x2gMooJrUX6fAQDKNsYklpDCSPiJiQKLTq50Ilm1atUSbZ8sOnkOBin/uL5NkRx99NHue/gYpVRSO1VBCg8mamu0dobTGDbdhyooqaKxaDoJC9+nOlmM1059sv/xxx+7sXQnnXRSyieE0T4Nn6jGj9vSbeGTAul5aSySxq7ttdde9sYbb6S0fcF2hr83dHKt90SkfapQoAlENOZOQUjbKDSo+qUKb6r4tkR6H0cKqaqO6sOZ119/3VXw1HtA1ePjjjvObrjhhpS1Ux9AKGQV5xjVhyDPP/+8qyKmeoyfaL+FT+IU/P0UPiZV4xbVe+DKK690PQ00Mc93333nxiSmup2R9ke0fapxh7peE0ZpXK/ogwT9/lCATCWNgdRXIvxxG+lYUW8NAED5Q0gsIVXiwifI8JcjdZMq6vbJUlqPW5x2RppxVW1NpJ2fffaZPfbYY3bfffe5iSVS2U4Jb6su6+Q8XiVq/vz57gRMVRLNOqpqRCrbGqmdEqmtzzzzjDuJTfWkKokco7Fee32woslU1IXXn4Cr+qUKnWaOVSUqVe307UqknfqQJTc314UDdVNVJUnVRYVEdTs9/PDDU9JOtUVf4e3Uax/vvTRmzBg3c6i61KZDUX8/adIovWd0nH744YfuPaTw7btyp/v3U7R9qg9Z1IW2T58+LszqOelDF4XedM3EmurfZwCAsilz/kplKVW81L0xSJc1M2ek7o5F3T7V7ZR4y0ukk9qpExZ/0hJsa7x2fvXVV2620VtuuSXlMzH6tiioBOmyH9MTzYEHHuhml3zzzTfdJ/h33HFHytsaqZ0S3lZ1QX3ooYdcN8hPPvnEnYAr0GpmRP0/WvfUVB2jOvFWyIr02qs6qrb6gCgax6agoGMhle2USO+nSO3072vNhupDjCqfnTt3dh9qpIpO8PXYibYzfJbTjh07pm0JhKL+fnrqqafs1VdfdWM99aGGxi5qf2ofp7JCp7aEt9O/n6LtU3WH79+/v6smqkunZkJV9+RUd41N1+8zAEDZREgsIY2H0kl0kKpDuj4Z2ydLtMf14/oyhd8Pwbbqk2xdjtVOBRpVvrQMgSo06Tip0kQb4ftUXUkjtVPd9xSyVJ3x9MGAxqmlesyP2hOpnTpJDe/ipxPgrl27uvGSmkxEX/pZndzq/9EmOUrWa68xe8GKjC6rChdpn6qN4WFQJ9/qoprK6ofv+hjp/RSpnf6YDu9KrsvhJ+Xpet/Hei9pf2u/+klk0iFaO/Ue2X777QttP2HCBDdBVXCs3Wmnnea616by/aT9pg92gh+W6D2jCbci7VO93zU5mCYMu+uuu9wYQYUuPdfghxulTftRx2Oiv88AAGUfIbGEVBX68ssvQ+P2dIKr8WZa+zAZ2yeL7l9/8PVptqeTl0xbMFldBNVtTG3zNNZIJ9OqFESi8HXVVVe52VijrVOXqn2q185T17dvv/3WvcbhFFwUYNUd0lOQ0Xp5qZ6dU+38/vvv3Qm0p/0b6ZjT8aDKR/BLFSWNAdP/U9ktVq+vwrQmoPE0W6hm5gyffEV0LGtSJXU1DB4rep5qc6ooWGttvuAxqrXzVIWNtE/1+ipYqjrn6XhW0En1rKE6FrU+qoKfaP9q4pxIx2jwuah9WvQ9XdQeTeQSDCnav3odIy1Ur+CoiaOCPQ7UhVcSHYdXHHq99AFRcBZb/Q7QmrPRxhbrwyvNEuy99tprrqu5uqJmClWd9f4LPi+9r9TuWMcKAKDsYkxiCWlyDy1QrGnNNdGLKlr69FjjT0QnrJrqXCcQqjzF2z6V4UsVNi3mri+djL344ouu21bwZEcBrTQ/4VYlSIFPX6paackAjTHU/vHT+OvERYFMlQQFBU1eoena1c1MgdHT9O3hs/Ulk8bCqUKgLq6dOnVy3d+0n/0YM4VyjUPr0qWLO9HVJCV6XgqHqpwoNGjR8GBwTAVN4KNJSM4880w3EYmWCdA+1EQqoslf1O1Ry2Sk8gQ7Ho0h1dityy+/3P7zn/+41/jJJ5+0QYMGhcZKqcKlrom77rqr+0Dg5Zdfdl0M9dw0QYgWXz/99NNdqE0lVYR0TOq1VADU4+r95RdI13Gp95hfPkRdoHW8KKQp8GrfK2ymeqFyLdWgpQ0UprUcgmYrVqDREiiibsQTJ050x6+ftERjZiWdS4to6RiFEf9aKvCpcv3SSy+527Wf9X7RbJtql56P3nta1F4T2CjQaMIq/bxmQk4VVdt0fOr11GPq95V+P+l48F02/TIcCrj+Nb722mvd8aLKuI6V+++/P6XDCxKhyX5UjddxofGRCrOaSEtd4fUhiH5nqKdDcEZmAED5kaPFEku7EdlOQVCBSzMr6gRFkz3UrVs31GXq3nvvdcFMJ+Hxtk8lVRN0wqhqi04INQNk8GRaM1ruvffeBdYcFH1ar5Og4HNINZ1oaZyRJqhQGAxO7vHcc8+5AHbjjTe6UKiTyUg0rk5rUKaSXl8FFU0hrzFyOsnyJ3/6cEAfCNx2222h8UeqluhEXYFGgVIn6+lYYkKVIbVTj6+wrRNXHwjVfc6vh6ewEE4n6grsev3TQa+nql3aj7169XIBwtP4TbXbr1On0KWxnVOmTHFBUoE8Xes6al08Pba6G6oqpA99fJjV9XqfaQmRYIVOY+h0rOiDGB0r6RgPrCCo3zcKrQpY+n3jZ+jUhxgK4vrwwocrBXGtjRdsezrotVR41nIm+sBAa/b5oKoeF5deeqn17NkzNGuxPkRQVU6hVvtRVdx0BRp9qKLJffR66/dMsNqmirtoHKJvu37vqnKs/a7fu+n+IE7Ho2YD1j70VDXU7yIFVj9WVvtSH3bpAzcFRX2oGVy+AwBQfhASAQAAAAAhjEkEAAAAAIQQEgEAAAAAIYREAAAAAEAIIREAAAAAEEJIBAAAAACEEBIBAAAAACGERAAAAABASKX//RdAMmhh95kzZ0a8TYtW16pVy1q2bGlNmzbN6B3+wQcf2OrVq+24446LeV0itJD8zz//bEceeWSh25YuXeoWpl+2bJnVqFHD7ZfWrVtbTk6OZbKPPvrIli9fbr1793aLqocvDB9chDzWtsl+rKLQgvANGjSwnXfeuVg/DwAAyqac/Pz8/NJuBFCW3HPPPfbss8/G3W6XXXax+++/37bffnvLRAcffLDNnz/fhbtY18Wzdu1aO+qoo6xXr17Wv3//0PW6nzvuuMM+/fRTC/81tN1229nFF19sxx9/vGUqPacZM2a4DwWqVq3qrluwYIENHDjQ7adgII60baoeqyhefvlle+SRR+y9996zrbfeulj3AQAAyh4qiUCK7Lbbbq5iGLR+/Xp3cj9p0iR3wn/hhRfau+++W6zqUrZQEFZQ7NOnT+i6FStW2Omnn+6CYrVq1axDhw5Wp04dt90vv/xic+bMsRtvvNFWrlxp5557rmUihbP27dsXeO3eeustV53r3r173G1T9VhFceKJJ7qgeOutt9rgwYOLfT8AAKBsISQCKXLYYYfZWWedFbX75amnnmq//vqrff3113bAAQeUyddBz/PFF190ga969eqh61977TUXEPfYYw977LHHbKuttirwcx9++KFdfvnlNnToUDv55JNdN9RMo0pnKrZNxc9Ho9Cp+77kkkvslFNOsY4dO6bkcQAAQHYhJAKlQBVGBcNRo0bZ77//XigkquI4efJk+/vvv90YRoWpWN0BNS5N1cmFCxe6wLXnnnvaFltsEXHbJUuW2LRp09wYQI2RVHfXnXbaySpUSP48Vk899ZQLh0cffXSB6/2YTVUXwwOiHHroofbHH3/Y3LlzXdUxPCQmun80li83N9fdn56v9tGqVausWbNmrrtvpHGPmzZtsp9++snmzZvnQpTGR7Zo0SLuOEFV9fRzMn78ePeadOvWzbbZZptC277//vtubKe6iUbqfqrjQu3Q9kV5LO0TjfFUdTHS/hg7dqzbD8ccc4xVqrT517+23Xbbbe2JJ54gJAIAAIeQCJSCf//91wUWUTfLoHfeecfuvvtud7LvKcydd955bkxfeJh788033ThIhQhPwUv3cdBBBxV4zJtvvtlV6fLy8grch0KTqnatWrVK2nP8559/7L///a8LLzVr1ixwmyZLEe2Drl27Rvz5Cy64IOL1Rdk/ek4KlH/++ac99NBDLkx5CsaqYtavXz90ncb9qQuwugSHdx3Wz2usZPC+tb2CnoLbww8/7LrKysiRI92X9qdCYvi233zzjY0YMcIFXAXY8OrrVVdd5T448CEx0cfSBEB6TpG66SocXnrppe55B8d6Kiwecsgh9sILL9isWbNcKAYAAOUbS2AAKfLjjz/a66+/XuBLXS8V6I444ggXXOrWrWtdunQJ/YzGJ1599dUuAKnSpcle9ttvPxd8dPJ/7733FngMTThy3XXXuYCoalfPnj1doNFldddUldJTl09VsBSKFApUTVIQ0ZhAjQEcMGBAUp//559/bhs3brTOnTsXuk1dSBVkVWk87bTTbPjw4W4yHFX9Yinq/hFVI3W9Kqs9evRwwVmzgaoSp4lfPAVIBVMFxF133dUFMu3PRo0a2Q8//GA33HBDzLbpvhXARN02NQNs+AcAnva9f/0iheDgNkV5LH1XdfTtt98u9DN67fV6aBKccNqH8sknn8R8jgAAoHygkgikiE7K9RVNw4YNXUXIV9kUUhQg1bUyvOufupGqMqQwpbFjTZo0cTOC+lCkypMqad5zzz1nd911lz3//PMu/CkcbLnllu4+LrvsMld58zQ2UKFRXVCTSdUyadOmTaHbFLxUubrpppvs+++/d1+i566Atv/++7uQpCqcV9T94yl4KqgG9/WECRPcmNAvv/wytJ0qdeq+qrGkwUlc9LgPPvig6x6qCmy0brmqYqoqp/CpsBYpjHnqHqvqrYK0qn61a9d21+s1VXDUaxVrQppYj7Xvvvu6ca56PTXZTbALq8Kxgm+4tm3buu/6OVVSAQBA+UZIBNIwu6kCxmeffeZm71RAOPvss10FMbi+nSqPixYtsnbt2rnxePoKUndCdTHU/Whm0OnTp7tQo4pSMCCKbtfP+3FpCoW33XZboTYqAGmMoro9BrtvJoOqk6IwFIm6NWoCG41PVFibOHGiG1OncKkvVQZvueUWVy0szv4JD1XBLq8as6mQ/tdff7mxfwpcPpCqmqbH1eun10pjNq+55hpLNnUlfeCBB2z06NGh7p8aX6g2qdJa3LUPdV8Ke6om+pCofaVqqD4MUAANp+qyxo6G71MAAFA+ERKBNM1uqm6M55xzjgtCCj7hIcCHKnW7VNfQaNR90lcAJVgt8jRuLVL3UVXLFB407k0Ts6jLq0JSKih8qutj+HjEcDvuuKP78kFX4+K0vIOqgupa2rRpU7fYe1H3T1CkiWcUjH2lUSGxcePGLmCpW/Arr7zivnzIPfzww+3MM8+MOMlOcWkyH1Us1YXWh0Tf1dSPRSwOP1mO75qr40xVRP+Y0aTigwIAAJCdCIlAmmiyFnWT1Im6FpHX5eCkLX5SFXX98+PNIvG3aUIWSbTipK6azz77bIHrFHpUgVPwUrUzmdS+SLOHLl682D799FPXJXSfffaJWGFU5a5evXquzZqYRyGxqPsnKNI+itQ2vS7qmqqQ+u2337rnoHD66KOPuqClgO3DZUmpeqeuoePGjQvNSqtZSxVoNd6yuPRcdYzptVZ3Vq2xqMCo4BhrqRXtD3VLVmguy+t2AgCA+AiJQBqp66ImmlEl7IorrrA33njDdthhB3ebliHw4/XuvPPOuPelSW8kODlNtOUOFAIVGhREtCaeFq/X46jKp3FwnTp1ciFR/48UnopD3Rr1+JpEJzi2UMFLz1/7Ql0to43x82HPz9pa1P1TkgqwvtROzRaqyq/GT6rqqvZqDGCyqGL41Vdf2QcffOBmTtUMtNFmdS0KtVGvt8bEKmyrG+kZZ5wRWvYiElURdTwQEAEAALObAmmmroWqoK1Zs6ZAl1AFN40dVJVNVaxwCivqCqnumKJqk8aRqRKl8XpBqn5puQNNXKNgoPGLosqlJnZR904fEB9//HEX5kSVpGRRN1G/FEaQQp4CoLqFqlIY6THVBVbBLBgWi7p/ikr7SD//22+/uctav1BjF7WW47HHHuuu05jSWHzADl9iJBpNTqNJa7QOogKdAlqsCW8SfSxVI7W/ND5T4z7jdTXV66/XIdr4UQAAUL5QSQRKgSZG0RILmqhE1USFEFXbNOOmZibVTJ0aB6fxhgpyCoHqiqiqm6pZolk+VR1SF1ZN1KKqlMKBxj6qi6ZO+jWOLjgmz89wqS6dmlVT4cQvyi5aaD5Y9SuJ3Xff3XV31IQp4TOcXn/99W7yHj1XtUHhVZVFhSRV7FQFVYhUoDzxxBPdzxR1/xSV9pcqnKq2KqipPaLQqf2ptmnW1Vi0nIhoDUS1JdIakUEKoqpaKpzq/+rq6ium8cR7rBNOOMF121XXWb3esbroKmCLJuoBAAAgJAKloHnz5nb++ee7RdIHDRrk1u5TCFIXVIU3hRIFOj/hiKjipKUYNCtncNZOVeoUBPxEK54mzfFdI1URU/DRxCivvvpqge0UihQ4NaumulceeOCBSXmOqpJpYhYtb3HSSScVuE3tUbjVEhgKhb5qGKTAokpjcAxgUfdPUagyq+qr2qxJc4IU4G699da4lTY/lnDSpEnuS/elEBiLPiBQtU9VylhrIxb1sQ499FA3xlJdWONVJ/0SJLGW3QAAAOUHIRFIMp28K5ypehOLxp6pm5/GvukkXyfoqvJpfUNVANVVUBOaKCQpVGr5AoW5Am/gSpXs7rvvdhU2Ve20RITCpkJn+OQnCqMKC1pqYsWKFW5MoyqMqo5p3cAPP/ywwGL2Chx+PGCs66LRhDgKenoe6lob3nZN2qLH1HNXtVET2qjrpCppGiMZafKWou4fTdqiamOkcXaRbuvbt6+ryGlfqiKrCp0qitpWEw3F+3l18VTAVJdYdQfVjKnx2qF1IVVV1T6KFtKK8ljBfaXKou73iCOOsGi0z/U66FgIrj0JAADKr5x89dUCgBTQeEkFIFW0/DIPSA+t96jQ26NHDxsyZEjU7RQyL7zwQrdmY8+ePXl5AAAAIRFAamncpGbOVFdXZs5MLVUN1e1YXVdVZVTXXI1ZVLUyGo1n1XbqshxtplkAAFC+0N0UQEppuQp1c9XkLOFjE5FcGjt5//33h7oNKwDGCoiaIEiT1owcOZKACAAAQgiJAFKqSZMmbjykJsVBaqlSe8MNN7i1MzW7bLzuo1ruQ12Bw2efBQAA5RtjEgEAAAAAIQxAAQAAAACEEBIBAAAAACGERAAAAABACCERAAAAABBCSAQAAAAAhBASAQAAAAAhhEQAAAAAQAghEQAAAAAQQkgEAAAAAJj3f6buBQJ08XlNAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Saving Metric Summaries...\n", + "INFO: Generating Metric Boxplots...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAKFCAYAAAAeb+lCAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAVg5JREFUeJzt3Qd0VFXXxvGdkJAQAqGXkFBDE1RAuiIiIAIKgg0LiIBgwYbiiwUVxQbYQUCkKkVARBEpoqKIoi8dlBp6L4EUQgqQb+3jN3kzSYDJ5E5uJvP/rZU1yZSbm2HIPDlnn3380tLS0gQAAMAm/nZ9YwAAAEUYAQAAtiKMAAAAWxFGAACArQgjAADAVoQRAABgK8IIAACwFWEEAADYKsDeb5+/rVu3TrQnXGBgoN2nAgCAV0lNTRU/Pz9p2LDhZe/LyMglaBChQW3O6XOWkpLCcweP47WGvMJrzbPvoYyMXIJjROTKK69045/BdyUmJsqWLVskKipKQkJC7D4dFGC81sBrLf/atGmTy/dlZAQAANiKMAIAAGxFGAEAALYijAAAAFsRRgAAgK0IIwAAwFaEEQAAYCvCCAAAsBVhBAAA2IowAgAAbEUYAQAAtiKMAAAAWxFGAACArQgjAADAVoQRAABgqwDJJ1JSUuTUqVNStmxZ8ff3d+n+cXFxUqZMmSy37d+/Xy5cuOB0XalSpaRYsWKWnjMAACggYeS9996TKVOmSHBwsPl44403pFWrVtneNyEhQYYNGyaLFi2S0NBQCQsLk9dee02aNWtmbk9OTpYOHTpI+fLlJSDgfz/eI488It27d8+znwkAAHhJGJk9e7Z89dVX8u2330rVqlVl6tSp8sQTT8iSJUukXLlyWe6vwWPNmjXy/fffS+XKlc39+vfvbx5fpUoViY6OlvPnz8uCBQtMWAEAAPmb7WFk+vTpctddd5kgoh544AGZMWOGzJ8/34SMjHTUQ0OGjpxoEFE6CjJr1ixznBdeeEG2b98uFSpUIIgAXurIyTOScDbVpfsmJSXJrsNJEhQWJ8HBKS49JrRIoFQoXTSXZwmgwISRxMREEx6efPJJp+uvvPJKWb9+fZb7Hzt2zNSCVKtWzen6ihUryoYNG8znO3bskBo1apj7nThxQkqXLi2FChXy8E8CwAqxCcky4K1lciEthw/8+YTLd/X395Npr3SQsNCgHJ8fgAIYRmJiYkxoyFyEqsWme/fuzXJ/DR1BQUHyzz//SMOGDdOv37Jliwk2jjCij23Tpo2kpqbKmTNnpE+fPvL444+7VBibWVpaWvqx4ZqzZ886XQKuCvQX+eCpa+VM0jmX7r/74Cn59Nvt0r9LLalWqaRLjykaHCCB/uf5f40c4feauPX+6efnl//DiE67mJPIUGjq+FqDRGZ6vQaLDz/8UIoWLSq1atWSefPmSWxsbProhw7bNmrUyNSWFClSRP78808z3aOFrr17987xOep5aNhBzu3Zs4enDZ6V8v9TMymnJTnWtT8akmNFYo569rRQcPF7LWcKFy6c/8NISEiIUyhx0K8dt2WmUzo6kvLll1/KuXPn5LbbbpNbbrlFfvvtN3P7tGnTnO6vq2y6du1qalDcCSOBgYESFRWV48f5+l8Q+h9W64A0EAIes/u4TuBKeHi41K1WlicaHsPvtZzbuXOny/e1NYzoahlNTUeOHHG6Xr+uVKlSto85cOCAWaJ7//33p1+nq2+0TkRHMQ4dOmQKWHU6x0F7l+joiTt0iOliwQiXpkGE5w6e5Ph/rpe81pAX+L3mOlenaGzvwKpTK40bN5ZVq1Y5NTPTpbvNmzfP9jEDBw6UL774Iv1rbZS2YsUKueGGG0z9ya233mqmbjL666+/TFEsAADIf2xf2jtgwADp16+fWSGjRanjx4+XkiVLmlCh4uPjTaFrZGSkKUC99957Tc1I7dq1pUSJEvLmm29K3bp1pWPHjub2nj17ygcffGBu08doD5PNmzfLnDlz7P5RAQBAfgwjOgIyevRomTRpkgkO9evXN91YHUUvP/zwg4wdO1a+/vpr0zvk7rvvNiMg48aNM6Mo1113nSlQdayUeeaZZ0wImTlzpgkxNWvWNH1IqPsAACB/8kvTtTfI1qZNm8wlUzw5o0uhdQWSjlgxjw9P2rzziDw/9k9565FmUj+qAk82PIbfa559D2XXXgAAYCvCCAAAsBVhBAAA2IowAgAAbEUYAQAAtiKMAAAAWxFGAACArQgjAADAVoQRAABgK8IIAACwFWEEAADYijACAABsRRgBAAC2IowAAABbEUYAAICtCCMAAMBWhBEAAGArwggAALAVYQQAANiKMAIAAGxFGAEAALYijAAAAFsRRgAAgK0IIwAAwFaEEQAAYCvCCAAAsBVhBAAA2IowAgAAbEUYAQAAtiKMAAAAWxFGAACArQgjAADAVoQRAABgK8IIAACwFWEEAADYijACAABsRRgBAAC2IowAAABbEUYAAICtCCMAAMBWhBEAAGArwggAALAVYQQAANiKMAIAAGwVIPnA0aNHZfbs2eayfv36cvvtt0tgYOBF779z505ZuHChxMTESOPGjaVTp05SqFAht48HAAB8eGRk//790rVrV9m3b5/UrFlTpk6dKo888oikpaVle//ly5dLt27d5NChQ1KrVi2ZNm2auf+FCxfcOh4AAPDxkZGPPvpIGjRoICNHjjRf6yhH+/bt5ddff5XWrVtnuf+rr75qwshrr71mvu7evbt06NBBvv76azMCktPjAQAAHx4Z0dGKX375Rdq1a5d+XdmyZeWaa66RH3/8Mcv9ddrl8OHD0rFjx/TrihQpIs2aNTP3z+nxAACAj4eREydOSGxsrFSuXNnp+oiICNm1a1eW+xcuXNhcZp5ySU5ONtMzOT0eAADw8WmahIQEc1m0aFGn60NCQtJvy6hkyZJSr149+fzzz6Vp06YSEBBgQsiKFSvMbTk9nis0+CQmJrr1WF919uxZp0vAU/QPEccl/0/hSfxec+/908/PL/+HEcdJOopPHfRrDRrZefPNN01BaufOnaV69epy4MABUzOyadMmt453OampqbJlyxa3Huvr9uzZY/cpoIA7FJPy7+WhQyJJJ+w+HfgAfq/ljGNGI1+HkVKlSpnL+Ph4p+vj4uIkLCws28fUqVPHLOtdv369CQrNmzeXd955R0qXLu3W8S5HlwRHRUW59Vhf/gtC/8NWrVrV1PQAHrP7uIgck/DwcKlbrSxPNDyG32s5p204XGVrGClevLj5JaIn3LJly/Tro6OjTVFqdoYPHy4333yz0/3XrFkjN9xwg1vHuxwdbdFpHuScBhGeO3hSUFBQ+iWvNeQFfq+5ztUpmnzRZ+SWW24xDcocNR1//vmnmXK59dZbs72/NjqbPHly+te6pFfDxh133OHW8QAAgI/3GRkwYID897//NSFCp0N0lOPZZ581Dc2UFqd+88038vrrr5tEqrf17NlT7rzzTjP1smHDBhkxYoRERka6dDwAAJC/2B5GQkNDZcaMGSY0nDp1Sl555ZX0YKF02qVVq1bpBaj6tdaMrF27VlJSUmTUqFFSokQJl48HAADyF9vDiPL395cmTZpke1uNGjXMR0bBwcFONSE5OR4AAMhfbK8ZAQAAvo0wAgAAbEUYAQAAtiKMAAAAW+WLAlbkf0dOnpGEs6ku3TcpKUl2HU6SoLA4CQ7+t1335YQWCZQKpZ33FAIA+AbCCC4rNiFZBry1TC44b5Z8eT+7vleIv7+fTHulg4SF/ttREwDgOwgjuCwNCOOfb+fyyEj0/pMyeu5mGXhHfakRWdrlkRGCCAD4JsIIXJKTKRSdplGVyhaVqIj/NaQDACA7FLACAABbEUYAAICtCCMAAMBWhBEAAGArwggAALAVYQQAANiKMAIAAGxFGAEAALYijAAAAFsRRgAAgK0IIwAAwFaEEQAAYCvCCAAAsBVhBAAA2IowAgAAbEUYAQAAtiKMAAAAWxFGAACArQgjAADAVoQRAABgK8IIAACwFWEEAADYijACAABsRRgBAAC2IowAAABbEUYAAICtCCMAAMBWhBEAAGArwggAALAVYQQAANiKMAIAAGxFGAEAALYijAAAAFsRRgAAgK0IIwAAwFYBkk8kJSXJyZMnpUKFClKoUKHL3j8lJUVOnTol5cuXz3Lb3r175dy5c07XlSlTRsLCwiw9ZwAAUEDCyIgRI+SLL76QokWLmiDyxhtvSOvWrbO9b1pamowaNcrcv1ixYua6jPdPTk6Wjh07Snh4uAQE/O/He/jhh+W2227Lo58IAAB4TRiZNWuWfPvtt7Jw4UKJjIyU6dOny5NPPilLlizJdtTjq6++kpkzZ8q8efOkRo0aMnXqVHnqqadk0aJFZlQlOjpazp8/L/Pnz5fQ0FBbfiYAAOBFNSMaPu6++24TRNR9990nFStWNGEiO8uXL5c2bdqYIKJ69uwpFy5ckD/++MN8vX37dhNKCCIAAHgHW8NIYmKi7Ny5U+rVq+d0ff369WX9+vXZPkanXk6fPp3+9dmzZ019iJ+fn/l6x44dEhUVZa47fPhwltoRAACQv9g6TRMTE2NGNbS4NKOSJUvK7t27s32MjoT06dNHpkyZIo0aNZKJEyeaUZV27dqlhxF9bNu2bc2xNbg8+OCDZirH3z/n2UtrVDQ0wXVat+O45LmDJ/FaQ17RP3wzXsK190/HQEG+DiOOXyQZC00dX6empmb7mOrVq5ti1ffee09KlCghJ06ckCFDhqRPy+hISLNmzeSVV16R4OBgWb16tfTr18/cV0NMTul5bNmyxa2fz1cdikn59/LQIZGkE3afDgowXmvIa3v27OFJz4HChQvn/zASEhKSvqw3c0jJruZDU1bfvn1NsFi5cqVZTbN582YTMvQY/fv3l0mTJjk9pnHjxtK1a1f55ptv3AojgYGBZtoHObD7uIgcMyua6lYry1MHz+G1hjyiIyIaRKpWrSpFihTheXeBlmG4ytYwUq5cOZOajhw54nS91npUqlQpy/0PHDggf//9tyl6dSzr1fqS22+/3azI6d27t+zfv18iIiIkKCgo/XGlS5eW+Ph4t85Rh5gcoQmucTz3eslzB0/itYa8pkGE32uucXWKxvYCVu0p0rRpU1m1apXTqMjatWulefPmWe6vtST6w+nUTObaE71NR066detmlv9m9Ndff8mVV17pwZ8EAAB4bZ+RAQMGmOmTypUrS8OGDWXChAlmJOOWW24xt8fGxprwUa1aNTN1o0t/tR5Ei1OrVKkiv/76q3z33XcyduxY81eSjo58+OGHUrx4cVPYqsHkn3/+kTlz5tj9owIAgPwYRnRk5JNPPjGrY7TxmU67vPbaa+lFLz///LOMGzdO5s6da8LIiy++KHXq1DEhQ9vBa4jRbqwaZJSumtEQok3RtL18zZo1Zfbs2el9SQAAQP5iexhR119/vfnIjrZwz9jGXZfn3nnnneYjO5e7HQAA5C/5IowAKNgOHU+QxGTrGxAePH4m/TI4+H/NEK0SEhQg4WXZVgLwNMIIAI8HkQFv/+jR7zF67maPHXv8kLYEEsDDCCMAPMoxIvLMvY0kovy/S/Ktov2FtmyLlrq1a5gmh1Y6cDRe3p2x1iMjOgCcEUYA5AkNIlERJSw9pm43kBwbLNXDi9P7AfBitu/aCwAAfBthBAAA2IowAgAAbEUYAQAAtiKMAAAAWxFGAACArQgjAADAVoQRAABgK8IIAACwFWEEAADYijACAABsRRgBAAC2IowAAABbEUYAAICtCCMAAMBWhBEAAGArwggAALBVgL3fHnY6dDxBEpPPWX7cg8fPpF8GB5+2/PghQQESXjbU8uMCAOxBGPHhIDLg7R89+j1Gz93ssWOPH9KWQAIABQRhxEc5RkSeubeRRJQvZumxk5KSZMu2aKlbu4YEBwdbeuwDR+Pl3RlrPTKiAwCwB2HEx2kQiYooYekxExMTJTk2WKqHF5eQkBBLjw0AKHgoYAUAALYijAAAAFsRRgAAgHfWjKSlpcm2bdtk165dcvr0aQkLC5MKFSrIlVdeKYULF7b2LAEAQIGV4zASExMjU6dOlblz58qJEyey3F6sWDG58cYbpV+/flKrVi2rzhMAAPh6GNGRkOnTp8u7774rJUuWlK5du0qjRo2katWqEhoaKvHx8XL8+HFZu3at/Pbbb+Z2/XjxxRdNQAEAAMhVGHnyySdN2Bg3bpw0bdpU/Pz8nG7XKZqaNWtKy5YtZeDAgWYKZ+LEiSaQfPXVVybAAAAAuB1G7rrrLrnuuutcvbvUrl1bRowYIRs2bHD5MQAAwPe4vJrm5MmTpl4kp66++mpGRQAAQO7DyOjRo+X666+XQYMGyR9//GFqSAAAAPIsjHz88cfSo0cPWblypfTu3Vs6dOggEyZMMCMmAAAAHg8jderUkZdeeklWrFgh77//vkRGRsp7770nrVu3lieeeMKEFEZLAACAx/uMaEOzTp06mY8jR47IvHnz5Ouvv5Y+ffpIRESE3HnnndK9e3cpV65cjk8GAAD4nly1g9flvI8++qgsXbpUPv/8c7n22mtlypQp0qZNGzl06JB1ZwkAAAosS/amOX/+vJw5c0bOnj0r586dy9KDBAAAwPK9adTWrVvNFM2CBQtMIat2Y3344YelW7duUrp06dwcGgAA+IgchxHdj0bDh4YQ7bIaFBRkVtZorYh2ZgUAAPBIGFm2bJnMmTPH7DujUzHaYVVX12i79+LFi+fomwIAAOQ4jLzzzjtmKkanYLQ1/FVXXeXqQwEAAHIfRv7zn/9IixYtpGjRomK1AwcOyKxZs+To0aNSv359ueeee8wS4os5fPiwuf+xY8fM/TUcBQYGun08AADgBatp2rVrZ9rAaw+RRo0ape/Gm1t79uwxxzx9+rRcc801MnfuXHnooYcu2kBt//79cuutt5oeJ3oes2fPdrp/To8HAAC8ZGRk1apVMnDgQNNbpEmTJmb04YUXXpC4uDh58MEH3T4BbTOvha/Dhw83X990003Stm1b+emnn8xlZpMmTZLq1aubaSOlOwlrXxPtAKuf5/R4AADAS0ZGvvzyS+ncubP8+OOPMn78eFm4cKFpAz916lS3v7mOVvz6668mTDiUKlXKjGgsX74828doCKpSpUr61xUrVpSQkBDZu3evW8cDAABeEkZ27dplNsgrVKhQ+nX9+/c3S31jY2Pd+ub6WB1ZqVy5stP12lZev192rrzySjNKEx8fb77WqSNtuKYFte4cDwAAeMk0TVJSkhQrVszpOi0a1T1oNACEhYXl+JsnJCSYSx3ZyKhIkSImYGRHm6pFR0ebvXFq1aola9eulWHDhpmQsnv37hwf73J0tCUxMVEKGv33dFxa/fNpJ96Ml95y3vAMXmsoCDz5e62g0vdPVzuyuxxGLly4kO1BdaREb3OHv/+/AzOZH69fZ1wdk5H2Ovn999/lvvvuMyMgGjx02qhx48bpj8nJ8S4nNTVVtmzZIgXNoZgUc6kBLjnWMyuNtJjYG88b1uK1hoLEE7/XCjJXV7Lmqh18bmk9h9KRlYwuNtKiUzNvvfWWDB06VO6++25zna6c6du3r7z99tvy/vvv5+h4rtAQExUVJQVN0CF9jo5JtWrVpHq4tU3r9C8H/Q+r2wPoqJS3nDc8g9caCgJP/l4rqHbu3OnyfXMURnREYseOHVn+gbK7vmXLllmmSzLTaZ9KlSqZx+qOvw76tT4+M12uqyMVderUcbq+Xr16prA2p8dzhY4GXe7n8EbBwf+OMAQHB3vs59P/sFYfOy/OG9bitYaCxBO/1wqqnGyam6Mw8uqrr7p8/dKlS51WvVxMly5dTIMy7eyqoxfabv7vv/9OX7qbuRBVP6ZNmyYjR4400zwaUJYsWSKtWrXK8fEAAID9XA4jr7/+eo4Kd7Sw1RW6ImfNmjVm2bAOvW/evFlefPFFqVGjhrldl+TOmzfPhAlNpB999JEMGjTIFLBGRkbKxo0bpWHDhuY6V44HAAC8NIw0b97cIyegw1060rFp0yY5deqUmYIpX758+u0aKDR4BAQEpE/JfPfdd7J161aJiYkxoy86h+fq8QAAQP6So2ka3bn3k08+MUU8OirRq1cvuf322y2ZV7rYxnsaNjJP92hRqS7lded4AADAS5ueOdrB62iEtoM/d+6caQc/efJkz54hAAAo0AJy2g5+xIgR6V1Yx4wZY9rB52ZvGgAA4NtsbQcPAADgb1U7eAAAAI+GEU+0gwcAAHA5jAAAAHiCre3gAQAAbG8HDwAAfJvt7eABAIBvs70dPAAA8G0uF7BGR0e79Q2OHj0qCQkJbj0WAAAUfC6HkZdffln+85//yMGDB126vzZC0w6t3bt3z9H0DgAA8C0uT9N89tlnphV8+/btpWnTpqY1fMOGDaVy5cpSuHBhSUlJkePHj8u6detkxYoVsnjxYrNj7vTp06Vs2bKe/SkAAEDBDyNFihSRV155Re666y4ZN26c+fz8+fPmNkcYcdAddTW43HTTTdk2SgMAAHBraa+qW7eufPjhh2Ya5o8//pDdu3ebz0NDQ6VixYrSokULCQ8Pz+lhAQCAj8pxGHEICwuTm2++2dqzAQAAPod28AAAwFaEEQAAYCvCCAAAsBVhBAAA2IowAgAAvHM1zapVq2ThwoUSFxcnaWlpWW4fOnQozc4AAIBnwoiGkEGDBkmpUqWkTJky4u+fdYDl3Llz7hwaAAD4GLfCyKxZs6RXr17ywgsv0GEVAADkfc1ITEyM3HHHHQQRAABgTxipWrWq7Nq1K/ffHQAA+Dy3wkj//v3N/jRaxHr27FmffxIBAEAe14y89957cvToUXnggQcuep+lS5dKlSpVcnFqAADAF7gVRm666SZp1qzZJe9TokQJd88JAAD4ELfCyH333Zf++ZEjR+TkyZNSvHhxCQ8Pl0KFCll5fgAAoIBzu+nZ6tWrZdiwYbJ9+/b067TniNaTXGr6BgAAINdhZMeOHdK3b19TE/LMM89I+fLl5dSpU6ag9c0335QiRYrIXXfd5c6hAQCAj3ErjHz22WfSqlUr+fjjj516jfTu3VtmzpwpY8eOlTvvvJM+JAAAwDNLe//55x958MEHsw0bd999t9mvRutIAAAAPBJGQkNDJSUlJdvbzp8/L6mpqdnuVwMAAJCZW4mhYcOGZormzJkzTtfr7r0ffPCBVKxY0WyiBwAA4JGakYceekhuueUWadu2rbRp00bKlSsnsbGxZoXNzp07ZfTo0e4cFgAA+CC3wkjJkiXNzr3vv/++/PDDDxIfHy+BgYFy9dVXy8SJE+Xaa6+1/kxhvcAkOZhwUPxj4iw9bFJSkhxJOiFFTh+Q4KRgS499MCHenDcAoOBwu89IZGSkaQuvtH6kcOHCVp4X8kBAuf0yZsNyz32DA545bEC5Gp45MAAgf4cRLUx1dFfVz7U+xEGLVc+dO+d84AC3cw7yyLljkfJUp44SWa6Y5SMju3fvlmrVqklwsLUjI/uPxcuodZstPSYAwF4uJ4abb77Z9BfRRmf6+b59+y55fzbK8wKpwVIptJJUL2XtPkKJiYlyNjheqpaIkJCQEEuPfSHxtEjqTkuPCQDwkjCiDc0cm9/p51qweilslAcAACwNIxk3x8v4OQAAQG5YVtiRkJAge/fulRo1arhVJ6A9S7Rrq/Yo0ZU52dG6lF27dmV7mxbQVq1a1XweHR1t6loyKlu2rFkFBAAACkAY0eAwdOhQs0lepUqVzM69PXv2lNOnT5s3fa0tqVOnjkvH0kLYt99+2+xpU7x4cRMi3njjDbnxxhuz3FeXEA8aNCjL9VosWbNmTZk/f74kJyebHiiVK1d2CjXaG6Vr167u/LgAACC/hRHtJbJmzRqzO6/65JNPzGjIiBEjTN+RV1991fQhcYWGkIULF8r3338vERER5uunn35alixZIhUqVHC6r45sfPfdd07XLVu2TJ566ikZNmyY+Vqbrl24cEHmzZsnRYsWdefHAwAA+b0d/B9//GHe/LXlu+5D8+uvv5qN83TkYeTIkbJ161YziuEKDR89evQwQUTdc889ZrRFRzlcmRp6+eWXpW/fvqbhmtqxY4eZ6iGIAABQgMOIrqRxhId169aZaRttC690tERX0mhQcGUJqI5k1KtXz+l6/Xr9+vWXffz48eNNP5OHH344/TqdMtK6FW3Etn///otu6AcAALx4mkbrQrSQNCoqykyb6EiG9h9xNLyKiYlxaWmv3k+nVEqXLu10vY64aB3IpWjYmT59ugwcODB9usgxMqLn1r59e9OM7fjx49KrVy9T3+Jo2pYTWtOioamg0X8nx6XVP9/Zs2edLr3lvOEZvNZQEHjy91pBpe+ffn5+ngsjHTp0MAWsOpXy008/yaOPPpp+mxafavFqxoBwMVpsml23Vg0NmTu6ZqY1IfqD3nXXXU7X63W6N45O3+gKGx250SkkDTj9+vXL4U8qZhpqy5YtUtAcivl3xEhDX3KsZ1r579mzxyvPG9bitYaCxBO/1woyV7eKcSuMaF2Hjmpo8ajWewwYMCD9Nn2T0CDgCkd3TsdfThlDyuVqPrTgVVfchIaGOl2vK3kyatiwodx2222yYMECt8KIrsjREaCCJuiQbo53zLRsrx5e3NJj618O+h9Wl1q7Ekrzy3nDM3itoSDw5O+1gkrLMFzlVhjRYRedHtGPzKZNm2amR1xRrlw5CQoKkiNHjjhdf/jw4fSalOycOnVKNmzYIH369HG6XutD9MWiy3oz9jrRURFXC2qz+1mtbmmeHwQH/zvCoM+Tp34+/Q9r9bHz4rxhLV5rKEg88XutoHJ1iiZHBawZm4jp5zqNkt2H1oBcbool43RMkyZNzOocBx0l0WXDLVq0uOjjNm7caL7PNddck+W2O++8U7766iun61atWiVXXXWViz8pAADwqY3yHnnkEbPXjY6E6JTKhAkTzIhJp06d0kdBtAhVp0ocIy5apKpFr5kLX3VuSutDPvzwQzPNExkZaYLJtm3bZPjw4a7+qAAAwJc2ymvcuLF8+umnMnnyZNMwrX79+vLWW2+lF71oDxMNKNpEzVEfoqFEH5edJ5980oQgbaSm7eVr1aols2fPlurVq7v6owIAAF/bKK9ly5bmIzvaSC1zG/fMtSKZ56i6detmPgAAQAFteqa0x8PcuXPNqhqHjz76SDZt2mTVuQEAAB/gVhjRAKKForqEN2MDmNWrV5tlv7/88ouV5wgAAAowt8KIboynm9Zp6NDuqxmX9Q4ePFjefPNNK88RAAAUYG6FEe1qqqFD28Jnpq3XdQWMfgAAAHisZuRiG+FpDxJtPqZ9QAAAADwSRpo2bSoffPCBU/GqY1+Y9957TypUqJClBwgAAIBl7eB1j5fFixdL27ZtTRdUna7R0RDtjHro0CEZN26cO4cFAAA+yK2RER310F1zdeXMsWPHZPny5aaO5IorrpCZM2dKq1atrD9TAABQILk1MqJ0Nc1zzz1nOp5qp1Nt4a6dUV3dJA8AAEC5nRx0f5i+fftKo0aNpE2bNnLw4EG59957TVt3AAAAj4aRPXv2mCmaw4cPm6W8jn1orr76ahk1ahSBBAAAeHaaZvz48XL99deb4KHTMsuWLTPXP//882YDu5deesnsngsARmCSHEw4KP4xcZY+IUlJSXIk6YQUOX1AgpOCLT32wYR4c94A8mkY2bx5s7z99tvZ1oe0b99eXnnlFTl+/Hi2TdEA+J6AcvtlzIblnvsGBzxz2IByNTxzYAC5DyOBgYFy4sSJbG9LTk6WuLg4CQhwuzYWQAFz7likPNWpo0SWK2b5yMju3bulWrVqEhxs7cjI/mPxMmrdZkuPCSB7biWGFi1amJGR6tWrS2RkZPr1qamp8sYbb5hfDLraBgD+/eUQLJVCK0n1Uv/Wl1lFdw8/GxwvVUtESEhIiKXHvpB4WiR1p6XHBGBx07OlS5dKx44dTdGqjpJoONm+fbscOXJEPv30U3cOCwAAfJBbq2l01GP27NnpTc90HxptelazZk2ZPn26XHvttdafKQAAKJDcGhk5evSolC9fXl588UXzAQAAkKcjI08//bRMnTrV7W8KAACQqzCiFey6QR4AAIAtYaRLly7y+uuvy+rVq+XUqVO5PgkAAOC73KoZWbFihWzcuFHuu+8+83WhQoWy3Gfx4sVSuXLl3J8hAAAo0NwKI61bt5YGDRpc8j7Fixd395wAAIAPcSuM6OZ4AAAAeV4zohvide/eXRo1aiRdu3aVr776ypKTAAAAvsvlMLJq1SoZOHCgxMTESJMmTeTcuXPywgsvyOTJkz17hgAAoEBzeZrmyy+/lM6dO8uIESPSC1bHjBlj+o08+OCDnjxHAABQgLk8MrJr1y7p3bu308qZ/v37m31pYmNjPXV+AACggPPPSaOzYsWct/8ODAyUcuXKSVxcnCfODQAA+ACXw4huhufn55fleh0p0dsAAADyrAMrAACALX1Gfv/9d9mxY4fTdWfPns32+pYtW0pISIg1ZwkAAAqsHIWRV1991eXrly5dKlWqVHH/zAAAgE9wOYzoxng6CuIqLWwFAACwLIw0b97c1bsCAAC4jAJWAABgK8IIAACwFWEEAADYijACAABsRRgBAAC2IowAAADvaXoGAO6KPmD97t66geeuI0kSFBYnwcEplh77wNF4S48H4OIIIwA86sKFNHM5es56z32Tn0547NAhQfyaBDyN/2UAPKpW5ZLy7pPXi79/1l2/cyt6/0kZPXezDLyjvtSILO2RIBJeNtTy4wLIh2Fk//79MmPGDDl69KjUr19f7rvvPgkKCspyv7i4OBkyZEi2xyhbtqwMGzYsR8cDkHeBxBN0mkZVKltUoiJKeOR7APCBAtZdu3ZJ9+7dJTExUVq0aCHffPON9OvXTy5cuJDlvsHBwea+GT9uvPFG+fXXX9PDRk6OBwAA7Gf7yMjHH39sQoNjVKNt27bm46effpJ27do53bdw4cJZrnviiSekVq1aMnjw4BwfDwAA+PjISFpamqxYsUJuuOGG9OtKlSoljRs3luXLl1/28X/88YcsXbpUXn75ZQkMDMz18QAAgI+FkePHj0t8fLxERkY6XV+pUiXZvXv3ZR//3nvvyU033SQNGjSw5HgAAMDHpmkSEhLMZUhIiNP1RYoUkTNnzlzysWvXrpWNGzfKiy++aMnxLkZHW7T+pKBxFP7ppdU/39mzZ50uveW84X2Sk5PTL3k9wJM8+XutoNL3Tz8/v/wfRgoVKmQuMxeX6tc67XIpc+bMkbp166aPiuT2eBeTmpoqW7ZskYLmUMy/DaJ0xCg5trBHvseePXu88rzhPRyvh0OHDokkea7XCODJ32sFmdZ65vswovUcKjY2NssS3hIlLr5MT8PFzz//LL1797bkeJeiISYqKkoKmqBDcSJyTCSotASFFbf02PpX6q49B6R61QjLl1QXTtERrmNSrVo1qR5u7XnDC+0+bl4P4eHhUrdaWbvPBgWYjohoEKlataoZbcfl7dy5U1xlaxgpVqyYREREmBO+7rrr0q/ftm2btGrV6qKP09tPnTolrVu3tuR4l6JDTJmnfQqCwoX/Hd7+9BtPjvp47i/VUmGhBfLfBTnjCLt6yesBeUGDCK8117g6RZMvlvZ27dpVZs6caS5Lliwpv/zyi2zdulVGjRp10cf8/fff5pdPzZo1LTmeL6IrJgAgv7A9jDz00EOmGLVTp05m6F3rM1566SWpXr26uV37g8ydO9eECUcaPXDggFSsWFECAgJyfDz8D10xAQD5QUB+GPKaMmWKGe3QqZfatWub1u4OWq+hHVUzFqB27NhRrr32WreOBwAA8hfbw4hDvXr1sr2+cuXK5iMjDRjuHg8AAOQvtu9NAwAAfBthBAAA2IowAgAAbEUYAQAAtiKMAAAAWxFGAACArQgjAADAVoQRAABgK8IIAACwFWEEAADYijACAABsRRgBAAC2IowAAABbEUYAAICtAuz99gDg7MjJM5JwNtWlp+Xg8TPpl8HBp116TGiRQKlQuihPO5CPEEYA5BuxCcky4K1lciEtZ48bPXezy/f19/eTaa90kLDQoJyfIACPIIwAyDc0IIx/vp3LIyNJSUmyZWu01K1TQ4KDg10eGSGIAPkLYQRAvpKTKZTExERJjg2W6uHFJSQkxKPnBcBzKGAFAAC2YmQEAOCTclIsrVOCuw4nSVBYnAQHp7j0GIqlXUcYAQD4HHeLpeXnEy7flWJp1xFGAAA+J6fF0tH7T5pVWwPvqC81Iku79BiKpV1HGAEA+KScFEvrNI2qVLaoREWU8OBZ+SYKWAEAgK0YGQEAFBiHjidIYvI5y4/rTrffnAgJCpDwsqHiqwgjAIACE0QGvP2jR79HTrr95tT4IW19NpAQRgAABYJjROSZextJRPlilh7bdPvdFi11a7ve7ddVB47Gy7sz1npkRMdbEEYAAAWKBhGri0zp9utZFLACAABbMTICACg4ApPkYMJB8Y+Js3ya5kjSCSly+oAEJ1k7TXMwId6cty8jjAAACoyAcvtlzIblnvsGBzxz2IByNcSXEUYAAAXGuWOR8lSnjhJZzvoC1t27d0u1atUsL2DdfyxeRq3z3Codb0AYAQAUHKnBUim0klQvZX0B69ngeKlaIkJCQkIsPfaFxNMiqTvFl1HACgAAbEUYAQAAtiKMAAAAWxFGAACArQgjAADAVoQRAABgK8IIAACwFWEEAADYijACAABsRRgBAAC2yjft4OPj4+X48eMSEREhhQsXvuz9z549K4cPH5aKFStKkSJFnG7bvn27nD9/3um68uXLS6lSpSw/bwAA4OVhJC0tTd544w2ZM2eOlChRwmxGpF+3a9fuoo/59NNPZezYsVKmTBk5evSoPPzww/Loo4+a2/TxXbt2NZsZBQYGpj+mb9++0qVLlzz5mQAAgBeFkenTp8vSpUtl0aJFEh4ebkLJoEGDZMmSJWbUI7Nvv/1WxowZI5MnT5ZGjRrJunXr5P7775cGDRpIy5YtZefOnSbg6HGKFi1qy88EAAC8qGZk1qxZctddd5kgou68806JjIyU+fPnZ3t/DSH33nuvCSKqYcOG0q1bN/nnn3/M1zt27DAhhiACAIB3sHVk5MyZM2Yko169ek7XX3HFFbJhw4Ys909ISDChY8iQIXLu3Dk5cOCAqQUZPny4U71I9erVJTk52dSUVKhQQYKDg/Pk5wEAAF4WRk6dOmWmVEqXLu10vRaa7t69O8v9NXyoPXv2yPPPPy/+/v5y5MgR6dOnj5nacYyMREdHS4cOHSQgIMDcft9998lzzz0nhQoVyvE56vklJia6/TP6Ig2CjkueO3iSFrJnvIRv05pBx6XVv3s8+VpL8uB520nfP/38/PJ/GHG8aWloyEhDg458XOwfbNq0aTJjxgwz6qEjJRo2dGpHp3j0sa1bt5YXX3zRrMrZuHGjPPDAAybw9O/fP8fnmJqaKlu2bHH7Z/RFh2JS/r08dEgk6YTdpwMfoH+gAI7fPfrHbHJsYa95rR3Kg/O2iyurY20PI466DkfIcNCvs6v5CAoKMpc9e/Y0QcQxpdO5c2dZuHChCSPjx493esxVV10lt912m3z33XduhRFdkRMVFZXjx/m03cdF5JipA6pbrazdZ4MCTP9K1TeHqlWrZlniD98TdCjO/O7R1ZTVw4t7zWstyIPnbSctw3CVrWGkXLlyJmDoVEpGWuuhIx2ZVapUyVxmntYpWbKkGQFJSUkxUzRVqlSRkJAQp9u13sQdOsSU8Vi4PEdo1EueO+QFfXPgtYbg4H9HGLRO0FOvB0+81oLz4Lzt4OoUje2rabTmo1mzZrJy5Uqn9Ll27Vpp3rx5lvsXL15crrzySvntt9+crl+zZk16EWyPHj3kq6++crr9999/N0t/AQBA/mN7nxFtWKY1HTqkr8t1P/vsM7NCRqdeVExMjGlsVqtWLVMP8uyzz5rpFh1V0cDy/fffm5oOXVGjc1P9+vWTjz76yKRLHV3RYKJDRW+//bbdPyoAAMiPYeSaa64xAWTKlCmyYsUKqV+/vowcOTK9e6qOgkycONE0RwsNDTUB5IsvvpBJkybJ8uXLzfzd7NmzzXJeNXDgQDNNoyFFg0zNmjVl7ty55n4AACD/sT2MKA0Y2U3LKG3hnrmNuxalfvDBBxedo8ruMQAAIH+yvQMrAADwbYQRAABgK8IIAACwFWEEAADYijACAABsRRgBAAC2IowAAABbEUYAAICt8kXTM+R/R06ekYSzqS7d9+DxM+mXwcGnXXpMaJFAqVA6607NAICCjzCCy4pNSJYBby2TC2k5e7JGz93s8n39/f1k2isdJCz03x1/AQC+gzCCy9KAMP75di6PjCQlJcmWrdFSt04NsyW2qyMjBBEA8E2EEbgkJ1MoiYmJkhwbLNXDi5vdkwEAuBQKWAEAgK0IIwAAwFaEEQAAYCvCCAAAsBVhBAAA2IowAgAAbEUYAQAAtiKMAAAAWxFGAACArQgjAADAVrSDBwAUKNEHYi0/pu65tetIkgSFxUlwcIqlxz5wNF58HWEEAFAgXPj/rcVHz1nvuW/y0wmPHTokyHffkn33JwcAFCi1KpeUd5+8Xvz9/Sw/dvT+kzJ67mYZeEd9qRFZ2iNBJLxsqPgqwggAoEAFEk/QaRpVqWxRiYoo4ZHv4csoYAUAALYijAAAAFsRRgAAgK0IIwAAwFaEEQAAYCvCCAAAsBVhBAAA2IowAgAAbEUYAQAAtiKMAAAAWxFGAACArQgjAADAVoQRAABgK8IIAACwFWEEAADYijACAABsRRgBAAC2IowAAABbBUg+sGfPHpk+fbocPXpU6tevL7169ZLg4OCL3v/EiRPy+eefy+7duyUiIkJ69+4t5cqVc/t4AADAh0dGoqOj5Y477pALFy5ImzZtZPHixdKnTx/zdXY0YHTr1k127NghHTp0kH379kn37t3l1KlTbh0PAAD4eBj56KOP5Nprr5WhQ4eakDFp0iTZsmWL/Pjjj9ne/4MPPpCKFSvKxx9/LJ07d5YPP/xQChcuLHPmzHHreAAAwIfDSFpamqxcuVJuuOGG9OtKlCghjRs3luXLl2e5v45uLFmyRO69914pVKiQuU4vNYC0atUqx8cDAAA+XjNy/PhxiY+Pl8jISKfrK1WqJNu3b89y/4MHD8qZM2ekVq1aMnXqVFm3bp2Eh4ebmpAKFSrIsWPHcnQ8AADg42EkISHBXBYpUsTp+pCQEBM6MnPUhbz66qty1VVXSbt27WTZsmXSpUsXmTdvnqSkpOToeK7Q0ZbExES3Huurzp4963QJ8FqDt0tOTk6/5D3B9fdPPz+//B9GHFMtmYtLz58/b+pALqZevXry0ksvmc9vueUWufvuu2XMmDHy8MMPu3W8S0lNTTU1J8g5XdUE5AVea/C0QzH//rF76NAhkaQTPOEucvW919YwUrp0aXMZGxvrdH1cXJyp9cgsLCzMXLZo0cLp+qZNm8qKFStyfDxXBAYGSlRUlFuP9VU6IqJvDlWrVs0ySgXwWoNX2n1cRI6Z0oC61crafTZeYefOnS7f19YwEhoaKpUrVzbLdK+77rr067dt22YKUjPTWpDixYubPiMZnT59WooVK5bj47lCh5h0mgc5p0GE5w55gdcaPC0oKCj9kt9rrnF1iiZfLO3t2rWrzJw5U2JiYszXP//8s2zdulVuu+22LPf19/eX22+/3RSvOupH9u7dK99//71Z5pvT4wEAAPvZ3oG1X79+ZlVMx44dzbC+rnrRAtVq1aqZ27U/yOzZs+X99983afSpp54yc3ba8Kx27dry999/myBy1113uXQ8AACQv9geRrRN+8SJE83ohY52aMAoVapU+u26jLdHjx7pRTB6f+0rojUJutS3SpUqpiW8q8cDAAD5i+1hxKFOnTrZXq91Ipn7higd9dCPnB4PAADkL7bXjAAAAN9GGAEAALYijAAAAFsRRgAAgK0IIwAAwFaEEQAAYCvCCAAAsBVhBAAA2IowAgAAbEUYAQAAtiKMAAAAWxFGAACArQgjAADAVoQRAABgqwB7vz0AAPY4cvKMJJxNdem+B4+fSb8MDj7t0mNCiwRKhdJFc3WOvoIwAgDwObEJyTLgrWVyIS1njxs9d7PL9/X395Npr3SQsNCgnJ+gjyGMAAB8jgaE8c+3c3lkJCkpSbZsjZa6dWpIcHCwyyMjBBHXEEYAAD4pJ1MoiYmJkhwbLNXDi0tISIhHz8sXUcAKAABsRRgBAAC2IowAAABbEUYAAICtCCMAAMBWhBEAAGArwggAALAVYQQAANiKMAIAAGxFGAEAALYijAAAAFsRRgAAgK0IIwAAwFaEEQAAYCvCCAAAsBVhBAAA2IowAgAAbOWXlpaWZu8p5F9r164VfXoKFy5s96l4FX3OUlNTJTAwUPz8/Ow+HRRgvNbAay3/SklJMe8BjRo1uux9A/LkjLwUb6TuP28EOOQFXmvIK7zW3HvOXH0fZWQEAADYipoRAABgK8IIAACwFWEEAADYijACAABsRRgBAAC2IowAAABbEUYAAICtCCMAAMBWhBEAAGArwggAALAVYQQAANiKjfJgmW+++UbmzJljPv/iiy9k//798t1338kjjzzCswzLnDt3Tn766SfZvn27+TzjxuOlSpWSBx54gGcbHnH+/Hk5ffq0lC5dmmfYYoQRWOKzzz4zH9dff71s3LjRXFe0aFH5/PPPpVKlStKlSxeeaVhi0KBB8uOPP0pkZKQEBQU53RYREUEYgWW2bt0qM2fOlGHDhklCQoL06NFDduzYIQ0bNpRx48ZJiRIleLYtQhhBrl24cEHGjh0r06dPl8DAQHnsscfS/0rVN45vv/2WMAJLnD17VpYtWyazZs2Sq666imcVHjV48GC55pprzOdTpkwxoyL6u27q1Kkyfvx4+c9//sO/gEWoGUGuHTlyREJDQ6VOnTpZbqtVq5YcO3aMZxmWiImJkTJlyhBE4HFnzpwxv7uGDh1qvtapwe7du8uNN94oTzzxhPz111/8K1iIMIJcK168uPmLQd8oMtP/sPrmAVghPDzcTM3o8DngSXFxcRISEiKFChUyv9u2bNkirVq1Mrdlnh5E7jFNg1zTUZG2bdvKo48+Kt26dTNFXuvXrzfz+pMnT5a33nqLZxmW0Hn7Fi1ayD333CPt2rWTChUqiL////6mooAVVilfvrwkJyfLwoULZd26deaPrgYNGpjbFi1aJFFRUTzZFvJLy1iKDuTiTWLEiBFmNY3WkDhCylNPPSU9e/bkeYUlDhw4kF6TlB0tYB0zZgzPNiyxZMkSGTJkiKSmpsqoUaPk5ptvll27dsmdd94pM2bMkNq1a/NMW4QwAsvnWfft2yeFCxc2qx30EgC8lQYR/dApG5WYmChJSUlmFA7WoWYElvYZGTBggLzxxhtSo0YNOXr0qKk8B6ymf5XeeuutZti8efPm0rdvXzOUDljt+++/l/79+8v9999vvj558qR8+eWXPNEWI4zAEtpjRGtDtMDwxIkTTn1GdGkvYJVPPvlE3nnnHWnSpIkZQtcArHUjvXr1orAVluL3Wt5hmga5pjUi+saQsc/I4sWLzW1z5841n+t/aiC3UlJSpFmzZjJhwgRp3Lix020aUDQIjxw5kicaucbvtbzFyAhyjT4jyCs69acjbpmDiOrYsaPpjglYgd9reYswglyjzwjySrly5SQ2NtbM22e2bds2CQsL4x8DluD3Wt4ijMDSPiOrV69O7zPy7rvvygcffGB6jwBW0GZT7du3NwWFv/32mxkp2bt3r2kPr0vL2QMJVuH3Wt6iZgSWoM8I8sqpU6fkmWeekZUrV6ZfV6RIEbM7tBazAlbh91reIYzAEmvXrpVGjRrRZwR52gBNe9oUK1ZMqlevbmpJAE+gf5LnEUaQazp/r625f/nlFzPPClhJ9wVZsGCBPPDAA+Zz3TH1YmgHDytfd6tWrTJT0OxF43nsTYNcCw4ONh+AJ5w9e1bWrFljwoh+vmLFiku2g9f7AVa87l566SV5+eWXTRv4rl27mlVcfn5+PLkewMgILJlXfe6552Tjxo3SsmVLqVixogQE/C/nlixZMr17IQB4C90o76effjKb5enIb9myZU2RtAaTatWq2X16BQphBLm2f/9+Uzx4qb9Wx40bxzMNj9DVW6dPn5bSpUvzDMNj4uPjZenSpTJ//nz566+/5Oqrr5bbb7/dhBMtoEbuEEbglmPHjplW77qqAchLW7dulZkzZ8qwYcPMqFyPHj1Ms7OGDRua0FuiRAn+QWC5zZs3m9qlH374QQ4ePGgK9nUqR2vmdIuCK6+8kmc9F+gzArf/StD/lEBeGzx4cPq8/ZQpU8yoiG7IqEWG48eP5x8EltE+Np9++ql07tzZjIL8/PPP0r17d1m2bJkJxDpK0rt3b9PjBrlDASsAr1piqaNyQ4cONV/rfL6+Odx4442m++qbb75p9ymigNBl4x06dDBLx7WA9fXXXzejIZnpXkm66ga5QxhBrjaS0uVvl32RBQSw5BeWiIuLk5CQEClUqJB57W3ZskWef/55cxvLL2F1B1btIN2mTRspXLjwRe9Xv359s3EjcocwArdpG+4WLVpc9n5ade7YxRfIjfLly5sVDrq6Yd26dSbkNmjQwNy2aNEiiYqK4gmGJbRnja4OnDNnjgnBaWlp6X+EOUbodMsLWIMwglxtWjZkyBCX/sIArODv7y+vvPKKed2lpqbKqFGjJDAwUHbt2mX2p5kxYwZPNCzz0EMPmcJVDcFaP6JtCw4fPmxuu9QKQuQcYQRu0/bbWtgF5CWdx9caEQ0jOmWjKlSoYAqq9a9ZwKo9kDZs2CBff/212W5AR4H186SkJHnwwQelbt26PNEWYjUNAK+joyGOIKJ9RnSJJUEEVtJl4xpy69SpY2pGKlWqZJaVlylTRp566in59ttvecItRBiB228GOnQJ5DV9Q9CpGscbhnbD1Ll97Teiy3wBK2jo0JDrULVqVfPaUzpdo6ttYB3CCNxSuXLlS25YBngKfUaQF7Srqo62OXrX6LJerUvSwmn93aet4WEdwgiAAtFn5IknnjBtugGrDB8+3NSNqDvuuMOMCOsInLaF1+JWWIcCVgBegz4jyEs6GqKt3h2rAnWZ786dO80UtW4ACusQRgB4DfqMwC7btm2Tf/75R8LDw6VWrVr8Q1iMMALL6GZl+nHu3Ln0BkFK2ynrMDqQW/QZQV7su/X222/L6tWrzUoanRKcPXu2fPjhh+n30UZ7EydOpIeShdi1F5Z45513ZNKkSebNQtu/Z+7AyjI4WEl7jGTsM5KYmGj6P7C8F7n12GOPyaZNm+Smm24yNUraUE8bn+lGeQ8//LAcP35cXn75ZenUqZMMGDCAJ9wihBHkWkpKiplb1b8m9D+oBhLAk7755hszf6+++OIL2b9/v3z33Xd0xUSuaPjQje9+/PHH9NYFujuv/rH13//+1xSwql9++cXs5jt9+nSecYvwroFc09UNJUqUkFtuuYUgAo/77LPP5K233jJz9ydOnEjvBvz5558zAodcOXnypNnmImMPpYYNG5rrHEFERURE0NPGYoQR5Jp2KVRHjhzh2YRH6SZlY8eOlSlTpjgNkev0zKBBgwgjyBWd+su8Q6+GkOxGe7XzL6xDAStyTf9T3nrrrXLvvffKnXfeacJJxv+8FLDCKhp4dYmlFhZGR0c73aYrHKZNm8aTDXghwghy7dChQ2beXjnW5GcuYGU1DaxQvHhxMzweExOT5TZteKYtvIHc0N15+/btm/61toTP7jpYizCCXNOwodXngKfpqEjbtm3l0UcflW7duplRufXr15uCw8mTJ5taEsBdWnvUtGlTp+t0ZDe762rWrMkTbSFW08Ayf/zxh6k8P3DggAQHB0u9evXMVttaaAhYRTfHGzFihFlNozUkjpCiO6n27NmTJxrwQoQRWGL+/PkyZMgQad68uZm712FMHTaPjY2VefPmEUhgmbVr15ql5LoMU3dO1YLDyMjILIWHALwHYQS5pn+dXnvttSaM6HbuDjqE/uyzz5p5/mHDhvFMw5Kll+3atTN9HvR1BaBgYGkvLClgVRmDiCpUqJAZNqeeBFbR6T/9AFCwUMCKXNOGZ9qOW6dmihQp4nSbtk4OCgriWYYldM8jbUKlnX5btmwpFStWdNp+QHdSvf/++3m2AS/DyAhyTYsH9Q1Cp2QcoyQ6daM1I9pGmWW9sMqpU6dMnYgGYN1BVVfRLFmyJP3jt99+48mG5VsPaMB1hFzdekAb78Fa1IzAEnv37pV+/fqZNwrdvMyxkdltt90mw4cPd2qlDADesvWAflx//fWyceNGWbx4selxo1tfaI1cly5d7D7FAoMwAks3zNPlvfqXg67Dv+KKK1iLD0vpG8GECRMuervWk+jKmvbt25vXIOAuHd1t0qSJ2QxP/5jS3Xw1jKi5c+eazzWowBrUjMDtXg86DaNTMPq5Dpc7ON4EdBhdP2gHD6voaNuGDRtkzZo1ZjOzGjVqSFJSkmzbts1caiMq7Zb50UcfyZdffum04RmQE2w9kLcII3CLFqaOHj3ahBH9/NVXX73ofWkHD6touNCC1YEDB5ourLpiS8XFxcmTTz5phs11n6QXXnjBbPE+dOhQnny4ha0H8hbTNAC8hu5L06FDB/nzzz+z3LZ69Wr58MMP5fPPPzfz+6+99poZTgfcpTtBa1G+bj2gUzIjR4502npAgy+swcgIAK+ax9cl5Do1qKu4Mjp27JipW3IsAQZySwOtbj2gI7/62rv77rvN6+4///kPQcRijIzAEvpG8O2335oVNTqvr/uE/Pe//zWbmul/ZHqNwCq9e/c2oUNfY46aEX2t6ZvGQw89JD169JDnnntOwsLCzEouILfYesDz6DMCSzz99NNmmFzpZnmrVq2S/v37m+HySZMm8SzDMu+9955ZPq7dfbXxmdYt6XYD99xzjzzwwANmWP3vv/82wRjIzcot3XZAt7XQ3Xzr1q1rwi97IHkGIyPIteTkZPOmsHLlSrO0UpsD1a5d2xQP6nUff/yxzJo1i2caljp8+LBER0ebNwpdReOYttEpGj8/P55t5Iq2KLj55ptNV1+tDdGeSfp7DZ7ByAhy7cSJE6YjpgYRnctfv369aRKkSpcubcIKYHVXzMGDB8u4ceNM91/tzOroikkQgRW0X82KFSvkkUcekXXr1pmVWhpIpkyZYn7nwVqEEeRauXLlJDY2VrZs2WJWL2iDoKZNm5rbdNWD/qcGrKKrGnQlQ3h4ePqbgo6O6CoarVsCrFKqVCm57777zMjusmXLzEjJ/PnzpXXr1vL888/zRFuIMIJcc3Qn1L8a9E1Ce0Dohnk6zDlq1Cjznxmwgq5o0BEQ/et0wIABTm8augyTMAJP0WlAnbLR0V4dfdOiVliHpb2wxIMPPijt2rUzyy5r1aplrtPOq/oXRb169XiWYQm6YiIvaeDQviILFy409W86CqzTNS+//LJUqVKFfwwLEUZgeTt4na7JSNtzs3MvrEBXTOSVAwcOmA3xdBREG+3p9GCzZs2oSfIQwgjcQjt42DVUrr1rtBW8dsXUZZdaMJ2xKyZgBS3I1x5JN910k1lKDs9iaS8Ar6IjcdrgbM6cOaaGxBFStAma9h4BctNbZMGCBaZfjX4+derUi95X65T0frAGYQSWOXnypCnuyvimoRuY6aoHwGp0xYTVDh48KO+8847Z9Vk/f/zxxy9634iICHM/WIMwAkvokl4dJtdCL4c9e/ZI9+7dTRGro6gV8BT9S1a7/+rKLgDehTCCXDt37pxce+21Zhlvq1atnG4bM2aM7Nu3z/y1AeQmaLz55pvy22+/mT1n+vTpYzYtc3RcnTdvnpm60aHzRYsW8UTDEvHx8Wa5uI7wOjZf1KlBHZXT/bjeffddnmmLUMCKXNP/lP7+/lmCiGrTpo289NJLPMvIFe0hsn37drOsUhudaWFh2bJlzWtuyJAh8t1330mjRo3MHjWAVXTjxc2bN0v58uXNqsCKFSuabQiUdmaFdQgjyDWtNNe/FPRDO2FmpJuWsWMvckNrj3RXXv0LVTcqU9WrV5fZs2ebD92gUUOIjpTQCh5W0S0GNmzYIF9//bV5vbVo0cJ8rrtEa18l3TgP1qEDK3JN96XR/UGeeOIJ2bp1q9neXd9Afv31VzO0rkvjgNy8KegoiCOIKN376OeffzZFhhpSevToQRCBpfR3WIUKFaROnTpmp95KlSqZ329lypQxK7fo9mstRkZgCUcb+K5du6ZfV6hQIdMKvlevXjzLcJuGW+35kJGOwOmI28SJE01XTMBqGjq0o7RD1apVTRhp3Lixma7RWjhYhzACS+jyXS0i1P+se/fuNX0foqKizFwr4An6hkAQgafo/lpaED1+/HizD5LWJDm2t9BLHa2DdZimgWV0fnXGjBmyfPlys7pGLV68mGcYHkF9CDxt+PDh5veauuOOO8ymoDoluHTpUlPcCuuwtBeW0P4iuqrhyiuvNMswNYTopma65bYu73WEEyCnoqOjTet3HWnLOHWjw+QZr1M0ooKn2xjs3LnTjPjqDr6wDtM0sKxmRLd216FzR9MpLf7SQi9tREUYgbt09+dOnTplub5+/fpZrmPoHJ4UEBBgClphPcIIck3X36vrrrvO/BWbka6ymT9/Ps8y3KZ1IW+//TbPIPJkp15XO/jqKJyO+sIahBHkmi570x4jGSvPHXRIU4tZAcAbilabNm162akanZbWTsCwDmEEuaZzp1dddZW8+OKLcvvtt5vrtH2ybuuuf9GyVwgAb6AbfervsYvR7Qh0czztvsoO0daigBWW0GLVwYMHy19//WVWOeg+DtoiXivPtR289hwBAG+0f/9+s79W8eLF5ZlnnnHanRzWIIzAUv/884/s3r3bTN1ooVdkZCTPMACvlJiYaPqMrF271vyxpSPA8AzCCCyTmpoqycnJZq8aHRUBPGXjxo1Obwy6nHzXrl2mOyZgBd18cfLkyaaLtC4tp6+NZ1EzglzRHVQnTJggy5YtM5XoSkdF9I1CmwRpe3iCCaykc/Y//PCDLFiwIP06LZ7WJlSffvqpNGnShCccuRrd1SmZK664QqZOnUoBfh5hZARu02W8DzzwgFy4cEHat29vpmR0z5DTp0/Lpk2bzEZ5rVu3Nm8e1IzACtrsTFc7zJkzR2rWrOl025dffikrV640rzfA3doQ3dhT96GpXLnyJe+rfZR0t2hYg5ERuO21116Tq6++WkaOHGmmZjLTPWruv/9+0421c+fOPNPItWPHjpm/VDMHEaWjcdpgD3CXjupq12hXlwHDOoQRuEX7iqxZs0Z+//33bIOIqlKlijzxxBOyaNEiwggsUaJECYmNjTWhJPMmeVu2bDG3A+7SNu/vv/8+T6ANqDKEW06ePGneDHSp26XoDpeHDh3iWYYldFSkXbt20rdvX/n+++/NLtFazDplyhSzJYEWGgLwPoyMwO2VMzqkeTlBQUFmeRxg5fTgq6++Ks8995x5HSodERk0aJApmAbgfQgjALxu47x3333XhBIdddPREi0mZOkl4L0II3Db8ePHZciQIZe8T3x8PM8wckV7iOgyXl25pZ/rcsuLKVWqlLkfAO9CGIFbgoODTYHq9u3bL3vfWrVq8SzDbdpDRIulNWTo5ytWrLjkTqqEEcD70GcEgNc4f/68WcmVXeG01iYdPnxYatSoYcu5AXAfq2kAeI09e/bIXXfdle1turRXi1gBeB+maQDke5988on88ccfZppGRz+y27794MGDEhUVZcv5AcgdwgiAfE87+J46dUri4uJk3759ZkfojHT/o2bNmsk999xj2zkCcB81IwC8hq6m+eabb+TBBx+0+1QAWIgwAsDri1p1c8bSpUvbfSoA3EQBKwCvoi3gX3nlFfN5QkKC6brasmVL6dGjhwklALwPYQSAVxk8eHB6t1Xdk0YDyNixY83WA+PHj7f79AC4gQJWAF5De4zojr1Dhw41X//000/SvXt3ufHGGyUsLEzefPNNu08RgBsYGQHgNXQ1TUhIiBQqVMgUs2pvkVatWpnbdGQEgHdiZASA1yhfvrwkJyfLwoULZd26daYTa4MGDcxtixYtos8I4KUIIwC8hvYT0eJV3aAxNTVVRo0aJYGBgbJr1y6ZNWuWzJgxw+5TBOAGlvYC8DoaRPRDp2wc+9IkJSWZXXsBeB9GRgDka1obsmDBArMbr34+derUi95Xwwi79gLehzACIF/T/WjWrFljQoZ+vmLFioveNyIigjACeCGmaQAAgK0YGQHgNXSaZsKECRe9PTg4WCIjI6V9+/ZSrFixPD03AO5jZASA1zh69Kg8/fTTZtpGl/nWqFHDFK5u27bNXNasWdPcR0PJl19+ae4DIP8jjADwKr169ZImTZrIo48+apqfOZqhPfnkk9KlSxe59dZb5YUXXjAjI45OrQDyNzqwAvAaug+NjoI8/vjj6UFEafOzxx57TObNmycBAQFy//33y4YNG2w9VwCuI4wA8BoXLlwwK2p0t97MdM+alJQU83laWpoNZwfAXYQRAF5D+4g0atRI+vfvL3/99ZecPHlSDh48KPPnz5fhw4fLzTffbMLKZ599JnXq1LH7dAG4iJoRAF63oua5555z6jeinVj79Oljpmp2794tDz30kEyaNEmqVq1q67kCcA1hBIBXOnz4sERHR0vRokXNKprQ0ND0KRo/Pz+7Tw9ADtBnBIDX0Q3xZs6cKfv37zfLeOvVqycDBw6Uhg0bEkQAL8TICACv8sknn8j48ePl9ttvl1q1apkakd9//11WrVolc+bMoVYE8EKEEQBeQ1fLNGvWzHRhbdy4sdNt77zzjpw4cUJGjhxp2/kBcA+raQB4De2uqjUimYOI6tixo+zYscOW8wKQO4QRAF6jXLlyEhsba5b0ZqbN0MLCwmw5LwC5QxgB4DWCgoLMJnjaZ+S3334zIyV79+6VWbNmyYgRI0w7eADeh5oRAF7l1KlT8swzz8jKlSvTrytSpIg88sgjMmDAAFvPDYB7CCMAvNKBAwdk3759ZkO86tWrm1qS8+fPO+1ZA8A7EEYAFAjaAE07sC5evNjuUwGQQ9SMAAAAWxFGAACArQgjAADAVoQRAABgKzbKA5CvHTlyRF588cXL3k/3qAHgnQgjAPK9gIDL/6rSJb41a9bMk/MBYC2W9gIAAFtRMwIAAGxFGAEAALYijAAAAFsRRgAAgK0IIwAAwFaEEcDH/frrr/Lxxx/Lp59+etH7HD161NxHP1JSUsx1v/zyi/n63Llzbn3fmTNnmsfHx8dnuW3v3r3mNv2+ebUDsH4/vXSIi4uTjRs3ZrnPoUOH8uScAF9CGAF83IoVK2TMmDEyevRo2bJlS7b3mT9/vkycONHcJzU1NT2M6Nfnz5/P8ffUN/TXXntNPv/8c3Ps7MKIHvvYsWNil06dOpmf0eHgwYPmnAgjgPUIIwDE399fWrZsKYsWLcr22Vi4cKG0atXKsmdq7ty5UqNGDfOGryMkdouIiJDHH3/cXDrExMTYek6ALyGMADDat28vixcvzvJsREdHS3JystSqVcuSZ+rChQvy9ddfy3XXXSedO3c2x1+1apVLj926datMnTrVBJidO3fK+vXrs0wvaft4HW3R67///ntz7g779+83Uy064jJ79myZNm2a7Nq1y2maRtvK6+d6nn/99Vf65xmtXr3anIeO7OgxHRzHSUxMNNNfeg56rsePHze3b9++XSZPnizTp09nhAXIgDACwLjxxhvNVETmqZrvvvvOBBUrp4V0quPmm2+Wxo0bS6VKlWTGjBmXfdxHH30k3bt3N3Uceo733nuvDB061CmMTJkyRTp06GBC1YkTJ8xj9PtoCFAaHHSq5Z577pENGzbITz/9ZGpWHFMwenk5L7/8srzzzjumnmXJkiVO0zmO4/Tp00cmTJggp06dMtNbGrr0MYMGDTJh6auvvkoPYgDYmwbA/ytZsqQJBzpVU7du3fTnRUcXRo4c6VQ/kdspmqpVq0qDBg3M1127djWBQt/cy5cvn+1j1qxZY+pa3nrrLRNIlAaKO+64Q4oUKWK+/vPPP83tzz//vPTu3dtc9/TTT0vPnj3lsccec5qCatasmbzxxhuSlpYmfn5+5rEOejydshk7dqw0bdrUfJ5R5cqV5ZNPPjFTW/r4bt26mfNv3bp1+n1Kly5tzlfdcsst5pyXLl1qpruCg4PlzJkz0qZNG5kzZ44MGTLEkucV8GaMjABId9NNNzlN1fz9999m9cxVV11lybOkdRg///yzeQN3uO2228yKHH1jvhid1ilXrpy5r4MGprZt2zrdRwPV/fff7xQsBgwYIPv27XOaCmrevLm51CCSU3oOGkQcj9fnJuNUjdJRD4eoqChzqeFDg4gqWrSohIeHM1UD/D/CCIB07dq1M2/cjqkanaLR66wyb948sxpHp2kcS4W//fZbCQsLMzUcF1smvGPHDjOa4ggBDtWrV0//fPfu3VKlSpUsO/w6woCu0HHQIOAuHfXIKCgoyKkuRZUpUyb980KFCpnLUqVKOd1HfxZ3l0UDBQ1hBEA6nSbRv/R1SkOnIHSURGswrKK1Ejo9U7ZsWafrte5Cp2l+/PHHbB+nb+iXW0LsmHLJzFF8mjGkZA4sOeHKaErm0ATg0tz/HwmgQNJiVa3ruOGGG8wUTaNGjSw5rq5A0ZUrWm+RcXrFERiWLVtmClmzCz86ArJ8+fIsgSPjaEe1atVMXYuONmQMG7rqxlHroY93lTtTOADcQ3wHkKVuZM+ePWZViIYGq/7K15oQrZXIrl+Jfg+ts9C6juxWmPTo0cMsj9UpnYzTMj/88EN6aNA6FF298sUXX6TfR5fpanGprthp0qRJjs63cOHCTKMAeYSREQBOtO5Ce4qsXLnSLEu9HB3pyG7aQ1ewOIJMQkKCWQar9Sf6Jp+dW2+91SzN1b4c119/vdNt9evXl4cfflheeOEF07+jePHiZiRFQ4a2bXcUpT777LMyYsQIE2p0JETvq/UcFzvHS6ldu7YsWLDAhKDBgwfn6LEAcoYwAvg4HanQAtKM9E1906ZNZgmsgy5zHThwoAQGBpqvdSmrrl5xhTYZ69u3r+llcjEaOJ555hkTVjQQ6ffSFTQOukxXR210Ga6uktFeHuPGjTP9Qhweeugh01dEQ4gun9W+HnqeWmSqIiMjzXErVKjg9L011Oj1eumgAUaX4uroSsb7ZC5+1efPcZ7Z3UcDmV6XeWTm7rvvltDQUJeeP6Cg80vLySQqANhA6010tEOX6TrCkIaELl26mLDx0ksv8e8CeDHCCIB8b9u2bdKrVy8z8qDTMbqyRgtadWRGO50WK1bM7lMEkAuEEQBeQdu2O1rJ61LfOnXqmGkkltEC3o8wAgAAbMXSXgAAYCvCCAAAsBVhBAAA2IowAgAAbEUYAQAAtiKMAAAAWxFGAACArQgjAADAVoQRAAAgdvo/hIDfKb8AHwQAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running Non-Parametric Statistical Significance Analysis...\n", + "INFO: Preparing for Model Feature Importance Plotting...\n", + "INFO: Generating Feature Importance Boxplot and Histograms...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhcAAAJECAYAAAClwwYRAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAASj5JREFUeJzt3Qm8jeX6//Frm8oQyljIGCVDhgY0qEiZm0RRTjmkUZ0knYajOjkpQ9RpOFFHUWniiEaion6ZUiFTHCEqFDKz/q/v/fut/V9723tbe+2bvdbzfN6v136x11r7Wc+01nM9933d150WiUQiBgAA4EkBXwsCAAAguAAAAN7RcgEAALwiuAAAAF4RXAAAAK8ILgAAgFcEFwAAwCuCCwAA4FUhv4sDkJOBAwfasccea3ffffdh31G9e/e2tm3bWufOneP+m19++cWmTp1q1113XZ6Wk5XHHnvMli1bluGxAgUKWLFixaxatWp26aWXun+DyNc+BFIFwQVwBM2dO9cqVqx4RN7r2muvtcqVK+fqb+69917bvn17huAikeVk5euvv7b169fbww8/nP6YCgT/9NNP9vLLL9tLL71kr776qtWtW9eCxtc+BFIFwQUQUGeffXau/+bAgQNelpOdokWL2rnnnnvQ4xdddJG1bt3annzySXvuuecsaHzuQyAVEFwASWjFihX21ltv2Zo1a6x06dLWpk2bgy7Ks2fPtnfffdf++OMPd7d//vnnu66H+++/33UvZG6K37Jli02YMMGWLFli+/fvt5o1a9rll19uVapUcc8PGjTIFi1a5J674YYb7I477rB69epl2aS/dOlSe/vtt23t2rWuJebKK6+0k08+OeHtPe6449w2fPfddxkeX758ub3xxhv2448/ute0b9/emjVrlqv9oG3p1q2bzZ8/363vOeec49Y3nuUfap/F+5qs9uGhjrH+5k9/+pNt2rTJPvnkE9u9e7c1bdrUunbtakcffXTC+xo4EkjoBJLMuHHjrFOnTu5i2a5dO3fRu+mmm2zw4MHpr1EXQq9evdxFSXf96nK4+uqr7fPPP7dt27a51+j/q1atcv/XsqLP6/Va7vfff+/eR10V0qFDBzvhhBOsQoUKrltE/8+8HJkyZYq7eG7dutUtp0iRInbZZZfZZ599lqft3rx5s8tHifrggw9cHsbGjRutY8eObn10wX322WdzvR/+8pe/WFpamrVo0cLleMSz/Hj2WTyvyWofxnOM9TcPPPCAvfPOO3bBBRe4oOfpp5+2AQMG5Gk/A0eEZkUFcGS0atUq0r1792yfX79+feTUU0+NDB48OMPj48ePj9SuXTsye/bsyMaNGyP16tWLjBo1Kv35AwcOuOXqNd9884177JRTTokMGzbM/X/atGnuue+//z79b3bu3BmZOXOmW17U9ddfH+natWuG945dzo4dOyJNmjSJ3HPPPRlec+edd0YuueSSHLddy23Tpk2Wz7311ltu/Z577jn3+7Zt2yKNGzeO9O3bN8Prxo4dG6lTp05k2bJlce8H/f/KK6/MsJx4lh/PPot3v8buw3iOcfRvOnXqFNm/f3/6a55//vnIySefHNm0aVOO+xrIb7RcAElEzd979+51Td+x1IxfuHBhd7c9Y8YM27Nnj2stiNJdeZcuXbJd7oknnuhe88gjj9gXX3xh+/btc03raoYvX7583Ov31VdfuRYBtVzEuuuuu+yee+5x3QI5USuBuimiPz179nR3/A8++KBrgbj++uvd69QKosTSq666KsPfq4VBSaAfffRRrvZD5i6beJYfzz5LZL/Gc4yjzjzzTDeiJkrvp7wYdcUAyYycCyCJbNiwwf0b7ZKIKlSokMtt0PPHHHOMu+BkHnVSqVKlbJdbq1YtGzp0qI0cOdJd0EuUKOG6CHRhbtmyZdzrF23qz/zexx9/vPs5lJIlS6aPRNEFcvTo0bZr1y43/DU2R2HdunXuXyV3jh07NsMytO16fufOnXHvB3X1xIpn+fHss0T2azzHOErLi1WwYEH376GCOCC/EVwASUT5C6ILZ/T/UWoxKF68uAsudPe6Y8eODBcf/U1O1Levnx9++MFmzZplkydPtj59+thDDz100B18dnQBjOe94h0t0qpVK+vRo4fdeOON7iJfpkyZDO+ju/noY1EKThQszJw5M+79oNaFrLYjp+XHu89yu1/jOcZAqqNbBEgi0RoP33zzTYbHNaLgt99+szp16tgpp5ziHlPiYKzFixfH9R41atRwF/TXXnvN3T2rmT67i3Bmev/oaJHM3SXq1lBSZm7oQvrUU0+54l260Eeb+6P7IRqMRH80ekVBiPZHXvZDPMuPd5/l5jXxHmMg1RFcAElEFzgNZVRTu4YgRu9wdResEREayqiaCcohGDFihBttEL0w/fvf/842QJg+fbobCaGchyg1/etiHlu0SiMp1E2RXc2LBg0aWKNGjVx3QjSQ0BDJUaNGuRYEjXrILV2I//a3v7n10fBROf300+3UU0+14cOHuyJb0a6AIUOGuBEhWo9E9kNUPMuPZ5/Fu19ze4yBVEe3CHCE6a5fyYyZ6WKkIZPPP/+8S5BUUanatWu7IYxly5a1F154IT1JcNiwYXbzzTfbhRde6Go56KKqGghKBjzqqKMOWrYSA1VT4eKLL3Z3xsorUF0GDXFUE37she+vf/2rXXHFFda9e/csL3TKL9B6av20rNWrV7u7dl3kE6UaEOrmmDhxoqsZoaTMZ555xvr372+XXHKJCyJ+/vlnt94aKhrttsjtfohS4HGo5aur5VD7LN79mrlLJp5jDKSyNA0Zye+VAMJU/lt3+FlRjYf69eun/66Ltu6qy5Ur5xIHM1PLgroE1NKgC9THH3/saiDMmTPHJU6qToJKTsfO16HuBxWM0mgFBQRadmbR99XdtS50WS1H/vvf/7rXKZGzatWqh9z2hQsXuvfVxT8ran2YN2+eaz2JfY0KX+lHrSJa52i+RLz74dNPP7Xq1atnSBiNdajlx7PPDvWa7PZhTsdYf6N1jt23aulQobMmTZqQm4GkRnABpBhdCDV0U9Ubo2WldWFVa4ju1seMGWNhwH4AkhfdIkCKUY6Cfvr27evu1HWnr9lGlYyostdhwX4AkhctF0CK0sgCNasroVLFleKpMxFE7Acg+RBcAAAArxiKCgAAvCK4AAAAXhFcAAAAr0I1WmTBggVuxkPNPAgAAOKnOi4qQKcqvYcSqpYLBRaHo2aYlqmpn8NYjyzM2y5sP8ef8z+cn/8wfvYjubiGhqrlItpiEVsF0QdVXFTJX1XYU82BMAnztgvbz/Hn/A/n5z+Mn/1vv/027teGquUCAAAcfknRcqE5ADRNsYrhaLZClTWOTjqkJpiePXu65qdY1157rZtwCAAAJJd8Dy40E2K/fv3cLIsq5/vUU0/Z7NmzbezYsenTF3/55Zf2z3/+00qVKpX+d9lNQgQAAEIeXGiaZrVUaHpnURnjdu3auRkUGzZsaMuXL3ez/2lKZQAAkPzyPbi477773NTOUZr2ODq1sCi4iH0eAAAkt3wPLpo0aZL+f+VXvPTSS1a6dGlr2rSpe0yzPR599NH26KOP2sqVK61SpUp23XXXEXAAAJCk8j24iJo0aZLrItmwYYMNHTrUSpYsmd5y8csvv1jnzp2tRYsW9t5777n/jxs3zho0aJDr91EAoyFEPu3cuTPDv2ES5m0Xtp/jH3sehE2Yz/8wbnskEnFFtFJqVtSNGze66l/Tp0+3IUOG2JNPPunyLJR7oamky5cvn/5ajR4pUKCAjRkzJtdjdDOPOgEAAPEpUqRIXLWikqblokKFCulDTOfNm2cvvPCCCy6U1JmZukwmTJiQcCEtFT3xSZHr6tWrrVq1ala0aFELkzBvu7D9HH/O/3B+/sP42V+xYkXcr83X4GL79u3Wu3dvGzBgQIYgokSJEvbjjz+mP3/nnXem52DITz/9ZBUrVkzoPdWkc7iqqekEC0ultszCvO3C9nP8Of/D+fkP02c/Lc4ukXyv0KkgomDBgjZy5Mj07opFixbZ1KlTrW3btu559dro+V27dqVPPjZ58mS7+uqr83PVAQBAsnaLPP74465l4rzzzrNy5cq5Fovrr7/ebrjhBvf8E0884Z5v2bKle37NmjXWq1cvl9QJAACST74HF+reGD9+vK1fv962bt1qVatWzdB/paGnr7/+untetS+qV6/uWjQAAEByyvfgIkqlv/WT6PMAACA5MCsqAADwiuACAAB4RXABAAC8IrgAAABeEVwAAACvCC48UVnx3FQvAwAgqJJmKGoqU1BRt+6pVqhQwfTHDhyIWIECBBsAgPAhuPC1IwsVtCfGzbO1G7dZ5QrH2F3XNPG1aAAAUgrBhUcKLFau+93nIgEASDnkXAAAAK8ILgAAgFcEFwAAwCuCCwAA4BXBBQAA8IrgAgAAeEVwAQAAvCK4AAAAXhFcAAAArwguAACAVwQXAADAK4ILAADgFcEFAADwiuACAAB4RXABAAC8IrgAAABeEVwAAACvCC4AAIBXBBcAAMArggsAAOAVwQUAAPCK4AIAAHhFcAEAALwiuAAAAF4RXAAAAK8ILgAAgFcEFwAAwCuCCwAA4BXBBQAA8IrgAgAAeEVwAQAAvCK4AAAAXhFcAAAArwguAACAVwQXAADAK4ILAADgFcEFAADwiuACAAB4RXABAAC8IrgAAABeEVwAAACvCC4AAEBwg4s9e/bk6XkAAJD/8j242L9/vz3xxBPWtGlTa9y4sXXt2tWWLl2a4TUvvviinXnmmdaoUSPr0KGDLViwIN/WFwAAJHlw8dxzz9mHH35o77zzjgsaateubb169bJdu3a5599991175pln7Pnnn3fPt2rVynr37m1btmzJ71UHAADJGFxMnTrV+vTpY1WqVLHChQtbv3797Oeff7avvvrKPf/SSy9Zly5drGHDhlakSBG77bbbrGTJkjZx4sT8XnUAAJCMwYVaJi6//PL037dt2+b+VSCh1ovFixfbaaedlv58WlqaCzTmz5+fL+sLAAByVsiShJI1f/jhB3vkkUdcMHH66afbhg0bXE5GuXLlMry2TJky9vXXXyf0PpFIxHbs2GG+171o0aIHPb5z5073fkGmbYz9N2zYfo5/7HkQNmE+/8O47ZFIxN3gp1RwMX78eHvzzTdtzZo1dsstt7gNiOZdqLskln5PdOTI3r17bcmSJeaTAovSpUsf9PiqVatCc+KtXr3awozt5/iHWZjP/7Bte5EiRVIruOjZs6f7WblypV199dUusIh2l2QOJPR7sWLFEnofBSa1atXyss6x65OV6tWrh6LlQh+uatWqZdl6E3RsP8ef8z+cn/8wfvZXrFgR92vzNbg4cOCAbd++3UqUKGEFCvxv+kfNmjWtTZs2Nn36dOvbt68LBpTgGUu/H3/88Qm9p1pEEg1MclpmVsJywkW31fd+TSVsP8ef8z+cn/8wffbT4uwSyfeETrVONG/e3I0YyRw8aESIAgslb86dOzf9uX379rlkTuVkAACA5JOvLReK9lQ0a+jQoVaxYkWrVKmSTZo0yT777DNX/0JU8+L222+3unXruiJbqnmhoKNTp075ueoAACBZcy4GDBhg5cuXt0GDBtnWrVtdES0ld6rFQs4//3x76KGHbPTo0a6SZ7169VzFzrA0QwEAkGryPbhQK4QqbuonO507d3Y/AAAg+eV7ES0AABAsBBcAAMArggsAAOAVwQUAAPCK4AIAAHhFcAEAALwiuAAAAF4RXAAAAK8ILgAAgFcEFwAAwCuCCwAA4BXBBQAA8IrgAgAAeEVwAQAAvCK4AAAAXhFcAAAArwguAACAVwQXAADAK4ILAADgFcEFAADwiuACAAB4RXABAAC8IrgAAABeEVwAAACvCC4AAIBXBBcAAMArggsAAOAVwQUAAPCK4AIAAHhFcAEAALwiuAAAAF4RXAAAAK8ILgAAgFcEFwAAwCuCCwAA4BXBBQAA8IrgAgAAeEVwAQAAvCK4AAAAXhFcAAAArwguAACAVwQXAADAK4ILAABAcAEAAJIXLRcAAMArggsAAOAVwQUAAPCK4AIAAHhFcAEAALwiuAAAAF4RXAAAAK8ILgAAgFeFLAns3bvXFi5caFu2bLHq1atbrVq1Mjw/depU95pY9erVs5o1ax7hNQUAAEkfXKxcudL69OljRx99tJ144ok2b948a9asmQ0dOtQKFixo27dvtzvuuMNatWplRYsWTf+74447juACAIAklO/BxV//+ldr1KiRDRkyxNLS0mzjxo3WsWNHGzdunF177bW2bNkyF2QMHz7cihQpkt+rCwAAkjnnYt++fVa1alUXRCiwkAoVKriWizlz5rjfly9fblWqVCGwAAAgReRry0WhQoXsscceO+jxtWvX2kknnZQeXNSoUcN1n/zwww9WqVIlq1u3bj6sLQAASIlukcxmzpxp3333nd1zzz3ud3WLfPvttzZw4EArU6aMzZ071xo0aGAjR4604sWL53r5kUjEduzY4XWd9+zZkyEfJGrnzp3u/YJM2xj7b9iw/Rz/2PMgbMJ8/odx2yORSHovQ0oFF2qduPvuu+3GG2+0pk2busfq1Kljbdq0sWuuucb9/vPPP9tll11mI0aMcPkauaVRJ0uWLPG63gosSpcufdDjq1atCs2Jt3r1agsztp/jH2ZhPv/Dtu1F4sx9TJrgQl0ePXv2tM6dO1u/fv3SH88cQJQvX94lfE6bNi2h4KJw4cIHDXX10XKRFQ2rDUPLhT5c1apVy7L1JujYfo4/5384P/9h/OyvWLEi7tcmRXCxdOlSu/76661bt252yy23pD+u7ouPPvrIWrRoYWXLls2Qq5EoNekUK1Ysz+uceZlZCcsJF91W3/s1lbD9HH/O/3B+/sP02U+Ls0skKSp0Llq0yI0WuemmmzIEFqLaF48++qiNHz8+Q7eGAo7mzZvnw9oCAICkbrlQgSwV0KpYsaKVKFHCJk2alP6cWirUYqFEzvvvv9+1YmhIql6jIay33nprfq46AABIxuBi3bp1dtZZZ7n/f/bZZxmeU2lvBRfKwahdu7a9//77tnjxYmvbtq1dccUVLhgBAADJJ1+DC40EeeKJJw75OtW1oLYFAACpId9zLgAAQLAQXAAAAK8ILgAAgFcEFwAAwCuCCwAA4BXBBQAA8IrgAgAAeEVwAQAAvCK4AAAAXhFcAAAArwguAACAVwQXAADAK4ILAADgFcEFAADwiuACAAB4RXABAAC8IrgAAABeEVwAAACvCC4AAIBXBBcAAMArggsAAOAVwQUAAPCK4AIAAHhFcAEAALwiuAAAAF4RXAAAAK8ILgAAgFcEFwAAwCuCCwAA4BXBBQAA8IrgAgAAeEVwAQAAvCK4AAAAXhFcAAAArwguAACAVwQXAADAK4ILAADgFcEFAADwiuACAAB4RXABAAC8IrgAAABeEVwAAACvCC4AAIBXBBcAAMArggsAAOAVwQUAAMj/4GLLli1+1wIAAARGoUT+qGvXrnb88cdbp06d7KKLLrLixYv7XzMAABCelovbbrvN/XvvvfdaixYt7K677rLPPvvM9u/f73v9AABAGFou2rVr535+/vlnmzp1qv3nP/+xXr16Wbly5axDhw6uRePkk0/2v7YAACDYCZ3ly5e3nj172ttvv23vvfeeXXDBBTZmzBgXXFx++eU2bdo0f2sKAACC23IRa/v27fb+++/blClT7KuvvrLChQtby5YtrWDBgnb77bdbjx49bMCAAX7WFgAABDO4UG7F7NmzbeLEifbxxx/brl277JRTTrG7777bdYscd9xx7nVLly51LRh9+/a1kiVLZru8xYsXu+6VzZs3W/Xq1e2qq67K8PqffvrJXnvtNdcNU69ePbvyyiutSJEiiaw6AABIxm6RLl26uByLWbNmuf9PmjTJBRrXXXddemAhderUsdKlS9vevXuzXZZaPLp162aRSMQaNWpkX375pbVv3942bdrknl+zZo117tw5PbAYP3683Xjjje71AAAgIC0XCgJ0gVf3h7pBcqJgoEyZMtk+P3ToUNeyoeXJZZdd5lo/Ro8e7VpCnnzySWvSpIkNHjzYPd+mTRtr1aqVzZgxw84///xEVh8AACRby8V9991nrVu3doHFgQMH0h9Xt0ZmJ554YrbL2bdvn/3lL39xAUWUcjXU4vHDDz+41olPP/3UJYpGlS1b1gUbn3zySSKrDgAAknW0yFtvveVaDn788cf0x9S9ceutt9off/wR1zIKFSrkhrRq1EmUulC+/vprl3vx66+/2tatW61q1aoZ/q5KlSou+AAAAAHpFlES5wMPPODyLWK7PPr3728jRoywRx991P7+978ntELPPvusbdu2zeVvaCSKFCtWLMNrihYtmv5cbqk1ZMeOHebTnj173DpltnPnzsDnhmgbY/8NG7af4x97HoRNmM//MG57JBKxtLS0wxdcvPrqq65rRC0VsZQLUb9+fddlMmjQINcykRtKCn3++eftn//8p1WsWNFWr17tHo/teon+nttlx7aMLFmyxHxSYKHE1cxWrVoVmhMveqzCiu3n+IdZmM//sG17kThHaiZ0hdbIjYYNG2b5XIUKFeyYY45xXRoKEHITWCggeeqpp+ycc85xj0VHnqhrJJZ+L1WqVCKr7vJEatWqZb5bLrKirp0wtFzow1WtWrUsW2+Cju3n+HP+h/PzH8bP/ooVK+J+bULBRaVKlezzzz+3unXrHvTcsmXLXLdG7JDUeFpC1J3yr3/9y5o2bZr+uGpd6L20QZrDJEq/n3XWWYmsumvSydzNklfZNROF5YSLbqvv/ZpK2H6OP+d/OD//Yfrsp8XZJZJwcHHFFVdYv3797Pfff3ezompOkd27d9vChQvd0NGOHTvG3XSioapPPPGEjRs3zhXiykzDUl9//XW79NJLXbDxxRdf2HfffefyOgAAQPJJKLhQboWCC7U2vPDCCxmeu/DCC91sqfFYu3atS/zU9O3KtYhVs2ZNu+WWW6x37942Z84cN6pE3RkaSaJy4ieddFIiqw4AAJJ1bhFV6FQZbs0nohwMNQ01aNAgV/kMyn8YMmRIls9Fu1WKFy9ur7zyigsqtmzZ4oKRE044IdHVBgAAyTxxmeYUUdJitA6FRnEo50KU5HKorhElf6pF4lAKFChgjRs3zsuqAgCAZA4uNBLkjjvucK0W2fnwww8PKn4FAACCL6HgYuTIkS5f4v7773fVNdWykJmSPAEAQPgkFFwsWLDAHnroofR6FAAAAHmaW+Soo46yY489NpE/BQAAAZdQcKEJyzRxGQAAgJduEY0QGTt2rC1fvtwNP82qEmWPHj2ynG8DAAAEW8IJnSrxPX/+fPeTlU6dOhFcAAAQQgkFF++//77/NQEAAIGQpyJaGjUyY8YMV6HzrrvuslmzZlnLli3dHCAAACCcEkro1DTi9913n3Xt2tWee+45e+edd2z79u1uunR1h4RtfnsAAJDH4OK1116zjz76yIYOHWrz5s2zKlWquMfHjBnjyn4PGjQokcUCAICwBhdTpkxx1Tnbt2/vJhaLqly5sptyXQGHpmAHAADhk1BwsXnzZqtRo0aWzynfQgGHXgMAAMInoeBC3SDZjRhRkufOnTutbNmyeV03AAAQltEi3bp1s759+9qmTZtc18i+ffts/fr1bpbU4cOHu6TOwoUL+19bAAAQzOBCw00HDBjgEjrffPNN91jPnj0zPAcAAMIp4ToXCibUaqHaFqpzUaxYMWvYsKHVq1fP7xoCAIDgBxcbN260vXv3uv83adIkw3Nr1651/1asWNEKFcpTjS4AAJCCErr6d+/e3dasWZPjaz788EOrWrVqousFAADCFFz079/fVeSMtWfPHlu1apXLwbj11lvt+OOP97WOAAAg6MHFRRddlO1zrVu3dhU6owmeAAAgXBKqc5GTpk2b2pYtW9wwVQAAED7eg4tff/3Vfv/9d9+LBQAAQe4W0cRlW7duPWimVOVhvPfee1a7dm0rU6aMr3UEAABBDy5Gjx6d5WgRVeVs1qyZDRw40Me6AQCAsAQXmldELRWx0tLSrGDBgr7WCwAAhCm4UF5FtIhWPCioBQBAeBy2IlqxKKgFAEB4JBRcPPjgg3b77bdb/fr13QyoapnYsWOHLVy40F555RU7++yz3QRmUSR3AgAQHgkFF2qJ0KRlKpYV68ILL7Rzzz3X+vXrZyNGjLACBbyPdAUAAEkuoav/ggUL7Iorrsi2iNa+ffvcTKkAACB8EgoujjnmGFu8eHGWzy1fvtzVuyhZsmRe1w0AAISlW6RDhw42ePBgV4mzVatWVq5cOff/uXPnuu4Q5WEUK1bM/9oCAIBgBhddu3a1lStX2rBhw2zo0KEHTVx2//33+1o/AAAQhuBCBbPuu+8+69Gjh82ePdtNUqauktNPP93q1q3rfy0BAEDKyNNwjs2bN9uGDRts3bp1bvTIihUrDppzBAAAhEtCwYVKf6vlQt0jzz33nL3zzjsuifOpp55y+RarV6/2v6YAACC4wYVmRf3oo49cvsW8efOsSpUq7vExY8ZYtWrVDqp/AQAAwiOh4GLKlCkuaVNdIcWLF09/vHLlyvbkk0+6gGP37t0+1xMAAAQ5uFCuRY0aNbJ8TvUtFHDoNQAAIHwSCi7UDaJp17Or3rlz504rW7ZsXtcNAACEZShqt27drG/fvm4IqrpGVO57/fr19tVXX9nw4cNdUmfhwoX9ry0AAAhmcKEZTwcMGOASOt988033WM+ePTM8BwAAwimh4CIaTKjVYtasWW6SMpX7btiwodWrV8/vGgIAgOAHF6pt0aBBA2vWrJnrAgEAAMjzUFSVAAcAAPASXFSqVMnWrFmTyJ8CAICAS6hbpHnz5va3v/3Npk6dajVr1rQyZcoc9JprrrnGSpUq5WMdAQBA0IOLsWPH2v79++2LL75wP1lp164dwQUAACGUUHCheUUAAADylHOh1orffvst3pcDAICQiju4ePnll+3333/P8NiwYcOYQwQAAOR9tEjUe++9Z9u2bTNfJk2a5BJBYym348wzz7RGjRpl+Bk3bpy39wUAAElQodO3mTNnumnca9WqleHx1atXu+6Y6dOnW+nSpdMfL1KkSD6sJQAASPrgYteuXfb444/ba6+95mZbzWz58uV27LHHutoaAAAg4N0iPqxbt84WL15sr7zyirVq1SrL4EK1NAAAQGrI95aL6tWr26uvvur+P23atCyDix07dliPHj1s5cqVrgXjz3/+s1100UUJvV8kEnHL82nPnj1WtGjRgx7fuXOne78g0zbG/hs2bD/HP/Y8CJswn/9h3PZIJBL31B+5Ci6UbFmgwP9v7Pj1118Peixq/PjxVrly5UMuM6u/jbVs2TI7+uijbeDAgVa2bFlXFfS2226zUaNGWevWrS239u7da0uWLDGfFFjE5oNErVq1KjQnnnJjwozt5/iHWZjP/7Bte5E48x3jDi6aNm3qplaPddJJJ+V5BQ7l7bfftqOOOsoKFiyYPtX7woULbfTo0QkFF4ULFz4oadRHy0V2rTJhaLnQh6tatWpZtt4EHdvP8ef8D+fnP4yf/RUrVsT92riDi8GDB1t+KFas2EGPKQdj3rx5CS1PTTpZLTMvsmsmCssJF91W3/s1lbD9HH/O/3B+/sP02U/LxWzo+Z7QmZPt27e7FpP333//oK6SGjVq5Nt6AQCAFA0uSpQoYWeffbaNGDHCNT+p+2HChAn28ccfW58+ffJ79QAAQDKOFjmURx55xNXB6NKli2vJOPHEE2348OHWrFmz/F41AACQ7MGFRoHccsstB7VeDBo0yP3s27fPChVKqlUGAACZJNWV+lAjTAgsAABIfkmdcwEAAFIPwQUAAPCK4AIAAHhFcAEAALwiuAAAAF4RXAAAAK8ILgAAgFcEFwAAwCuCCwAA4BXBBQAA8IrgAgAAeEVwAQAAvCK4AAAAXhFcAAAArwguAACAVwQXAADAK4ILAADgFcEFAADwiuACAAB4RXABAAC8IrgAAABeEVwAAACvCC4AAIBXBBcAAMArggsAAOAVwQUAAPCK4AIAAHhFcAEAALwiuAAAAF4RXAAAAK8ILgAAgFcEFwAAwCuCCwAA4BXBBQAA8IrgAgAAeEVwAQAAvCK4AAAAXhFcAAAArwguAACAVwQXAADAK4ILAADgFcEFAADwiuACAAB4RXABAAC8IrgAAABeEVwAAACvCC4AAADBBQAASF60XAAAAK8ILgAAgFcEFwAAILjBxe7du+3777/P8rmff/7ZvvvuO/vjjz+O+HoBAIAUDS6GDBli9957b4bH9u/fbwMHDrSLL77Y+vfvb+ecc45Nnjw539YRAADkrJAlgX379tljjz1mr7zyip166qkZnhs7dqz9z//8j33wwQdWrlw5e/fdd+2ee+6x0047zapUqZJv6wwAAJK05WLz5s3WsWNH+/jjj+3cc8896PkJEyZYly5dXGAh7du3txo1atikSZPyYW0BAEDSBxc7d+60du3aua6OOnXqZHhu+/bttmrVKjvllFMyPK7fv/322yO8pgAAICW6RSpVqmQ333xzls9t2bLFIpGIHXvssRkeL126tK1YsSKh99PyduzYYT7t2bPHihYtmmXgpPcLMm1j7L9hw/Zz/GPPg7AJ8/kfxm2PRCKWlpaWGsHFoS7aUrBgwQyP63cleiZi7969tmTJEvNJgYUCnszU6hKWE2/16tUWZmw/xz/Mwnz+h23bixQpkvrBRYkSJdy/u3btyvC4fo8+l1uFCxe2WrVq2eEIgjKrXr16KFou9OGqVq1alq03Qcf2c/w5/8P5+Q/jZ39FLnoMkjq4UBKnDtpPP/2U4fH169cnPFJETTrFihXztIb/f5lZCcsJF91W3/s1lbD9HH/O/3B+/sP02U+Ls0skKRI6c1KgQAE766yz7NNPP82Q5Dl37lxr0aJFvq4bAABIwZYLUbLn1Vdf7VoxGjVqZC+++KLrblBRLQAAkHySquVCI0cyDzutX7++K661YcMGGz9+vDVp0sRGjx5thQolfVwEAEAoJdUVulu3blk+3rBhQxs6dOgRXx8AAJDiLRcAACD1EVwAAACvCC4AAIBXBBcAAMArggsAAOAVwQUAAPCK4AIAAHhFcAEAALwiuAAAAF4RXAAAAK8ILgAAgFcEFwAAwCuCCwAA4BXBBQAA8IrgAgAAeEVwAQAAvCK4AAAAXhFcAAAArwguAACAVwQXAADAK4ILAADgFcEFAADwiuACAAB4RXABAAC8IrgAAABeEVwAAACvCC4AAIBXBBcAAMArggsAAOAVwQUAAPCK4AIAAHhFcAEAALwiuAAAAF4RXAAAAK8ILgAAgFcEFwAAwCuCCwAA4BXBBQAA8IrgAgAAeEVwAQAAvCK4AAAAXhFcAAAArwguAACAVwQXAADAK4ILAADgFcEFAADwiuACAAB4RXABAAC8IrgAAABeEVwAAACvCC4AAIBXBBcAAMCrQpYCRo4caXv27Mnw2Pnnn29NmjTJt3UCAAAp2nKxefNme/rppy0tLc1KliyZ/lOkSJH8XjUAAJCKLRdLly61woULW79+/axgwYL5vToAACDVWy6WL19u1atXJ7AAACBFFEqF4OLEE0+0Dz74wFasWGGVKlWyNm3aWNGiRfN71QAAQKoGF99++62VKlXKypUrZ//6179cDsa4ceOsfPnyuV5eJBKxHTt2eF1HJZtmFezs3LnTvV+QaRtj/w0btp/jH3sehE2Yz/8wbnskEnH5j/FIiyT51U9BRI0aNaxZs2bpF/LOnTtb3bp17YknnsjVshSkZB514oMCC61Pv2EzbOW6361mpVI24s6Wtnjx4lCdeACAYNNgivr166d+y8U111xz0Ia1bt3aJk+enNDylBxaq1Yt8ym7gEW5Ikkeu+WZgqfVq1dbtWrVQtlVxfZz/Dn/w/n5D+Nnf8WKFXG/NqmDi+3bt9uzzz5rl19+ubtQR+3atcuKFy+e0DLVpFOsWDGPa/m/y8xKWE646Lb63q+phO3n+HP+h/PzH6bPflqcXSJJP1qkRIkSNnXqVBszZkyGuhdTpkxxSZ0AACD5JHXLhfzjH/+wm2++2davX2+VK1e26dOnu26NXr165feqAQCAVAwuzjjjDDcMddasWbZp0yZ77LHHXHJnbppnAADAkZP0wYUcd9xx1qFDh/xeDQAAkOo5FwAAIPUQXAAAAK8ILgAAgFcEFwAAwCuCCwAA4BXBBQAA8IrgAgAAeEVwAQAAvCK4AAAAXhFcAAAArwguAACAVwQXAADAK4ILAADgFcEFAADwiuACAAB4RXABAAC8IrgAAABeEVwAAACvCC4AAIBXBBdACjhwIJLj7wCQTArl9woAOLQCBdLsiXHzbO3GbVa5wjF21zVN2G0AkhbBBZAiFFisXPd7fq8GABwS3SIAAMArggsAAOAVwQUAAPCK4AIAAHhFcAEAALwiuAAAAF4RXAAAAK8ILgAAgFcEFwAAwCuCCwAJS0tLs6JFi7p/ASCK8t/IF5p4S/NlZPc7UkORo46yunXrpv/OcQQgBBfIF0zEFQwFCxRgQjUAByG4QL5hIq5g4DgCyIycCwAA4BXBBQAA8IrgAgAAeEVwAQAAvCK4AAAAXhFcAAAArwguAACAVwQXAADAK4ILAADgFcEFAADwiuAiiWkSqLz8Hu9r8vL6w7WM/HI41v1I7I/My9wfx7mQKlL1mCSLrLZtv4fvlqCI53szVRxIouPG3CIpPLlXPJN/5XaCMB8TiqXypGSHY92PxP6IfY/GJ5e3a9vWTf9dUu04BOGYJIvYbZXM50ei3y1B3T+pvL0Fkui4EVyk+KRQ8UwalduJpXxMRJXKk1kdjnU/Evsj+h6Vy5c4Yu95pKTqMUkWsdsa7/kR1v2T6tYmybbQLQIAALwiuAAAAF4RXAAAAK8ILgAAQPgSOufOnWtjxoyxjRs3Wr169ey2226zMmXK5PdqAQCAVGy5+Prrr61Xr17WtGlTGzBggK1fv96uvfZa27NnT36vGgAASMXg4umnn7a2bdva9ddfb2eccYaNGjXKfv31V5s6dWp+rxoAAEi14GLfvn02Z84ca968efpjRx99tDVp0sRmzZqVr+sGAABSMLjYtGmT7dy5044//vgMj+v3H3/8Md/WCwAAZC8tEokkbRH1lStXui6Rt99+20499dT0x4cMGeJaLiZNmpSr5c2fP9+0uYULF/a6nlpmgQIF7Pfte2zf/gNWqGABK1WiiHs8L9LS0nJc5qGej/c1eXm9ntu/f78VLFjQ/e3hWq8jxcf253WZiSwj9vmjChe0EsUKp/8uh2sfH4njeDjew9cy4zn++S12WyXz+ZHod0uqbH9u90+850MybnvaYf487t27171H48aNU3u0SDQI0AGMpd/VPZJbsRc/n6LL04HM6vG8ONQy43nP3K5Xbl6v5xRYJbKMw7G/fPCx/XlZZqLLyPx85t8Tfd+8rleyvoePZcZ7/PNbVueCj++WVNn+Q0nks5Ks217qMH4etax4l5fUwUXZsmXdhmzZsiXD45s3b7bjjjsu18tr1KiRx7UDAABZSb6wK0axYsWsVq1atnjx4gyPL1q0yBo0aJBv6wUAAFI0uJArr7zSxo0bZ6tXr3a/v/baa7Zu3Tq77LLL8nvVAABAqnWLSPfu3V1iZ/v27a106dJ24MABGzFihFWoUCG/Vw0AAKTaaJFYv//+u23dutUNQy1UKOljIgAAQitlggsAAJAakj7nAgAApBaCCwAA4BXBBQAA8IrgAgAAeEVwAQAAvCK4AAAAXlEwIpfmzp1r77//vi1btsy2bdvm5j4pVaqU1a5d2y6++OLAzl8yffp0V4r9xBNPTH9s+fLl9sQTT9j3339vZcqUsSuuuMK6du2alJP5+LB792579913bfbs2a5K7M6dO90Eetr20047zVWN1Xw4QaOZECdMmGDXXHNNhsfffPNNe/XVV+3XX3+1k08+2W6++eZAl+Vfu3atTZw40b799lvbtGmT7du3z0qUKGFVqlSxFi1auM9/EGvw6HP+yy+/WPPmzdMf2759uw0bNsw+//xz93k/++yz3fE/9thjLai++OIL+/DDD23FihVu+7Xd+u6vU6eOtWvXzurVq5ffq5hUqHORC/fee6/95z//cQFE9erVrXjx4m46W51oq1atsq+//tp9Aet1QXPTTTe5i2erVq3c7z/99JOrmqqgSl86usBo33Tu3NkefPBBC5oNGzbYdddd5wq5abrhihUr2lFHHeUuMJpITxecn3/+2f75z39as2bNLEj++OMPd/FYsGBB+mMqyT948GDr0KGDVapUyRYuXOi+fMeMGWNnnHGGBc2UKVNswIAB7nN/yimnuIuoptretWuXrV+/3ubNm2dVq1Z121+yZEkLkjfeeMN9t/397393v+s779prr7U1a9a47wDdYOmiq/3x9ttvW9GiRS1ItL133nmnffzxx+6zr+Mc/e7XDeYPP/zgzv/evXtbv3798nt1k4eKaOHQZsyYEWnevHlk5cqV2b5myZIlkTPOOCMyZ86cwO3Svn37Rj766KP034cNGxa58cYbM7xm6dKlkQYNGkTWr18fCZr+/fu7fbB79+5sX/Piiy9GzjvvvMiBAwciQbJ9+/bIaaedluGxli1bRqZMmZLhsZEjR0a6d+8eCZo//vgj0qhRo8jEiROzfc22bdvctj/++OORoJkwYULk3nvvTf99/vz5kbPOOiuyefPm9Md27doV6dSpU2T8+PGRoNF5rs/1mjVrsn3NwoULI02aNIksWrToiK5bMgtm+/VhoJlZFaXXqFEj29eoaVhNo999950FnZqI27Rpk+ExtWKoWVzNhkGzZMkSu/HGG61IkSLZvqZnz562Y8cO14QcZPv373fb2Lp16wyPd+nSxTWhB43u0MuVK2edOnXK9jXqHrnhhhtcC1YYPvtnnnlmhi4QteJ17NgxsJ/9Sy+91HV/ZUffe+eff34ovvvjRXARJ325KMDQxGnZ2bNnj/ty0QRrQaT5XaLV4mvWrOn6nWOpi0DdJcpBCOLxP9SFQ3k4Ci50oQkaHXcdf1Hzd+XKlW3Lli0HXYSDeOyVR6MuL/3kRF0jQc050Hmt7zdR7lXmz370+B933HEWxM/+okWL0r/7sqLuMV0fgnr8ExG87KPD5JJLLrFnnnnGevTo4ZJ31Pd6zDHHuOeUc6Ep4dXfqD64zHd0QaA7duWSPPzww671Rh8i9cNeeOGFVq1aNfvmm29cvoESHNWCETTXX3+9S1hT8upZZ53lJtDTtkZzLnTH8sorr1i3bt2sWLFiFiRKXNN2KpdCX7Q6/nrsnnvucTkGCriVb6PZitV6EcTgQi2SV111lds+5VzoIhrNuVBA/dlnn7m8jLFjx1rQFC5c2KZOnWoffPCBu3vXjYU+70roVRK3gi6d+/r+e+eddyxo1GL1wgsv2J/+9Cd3HVDORfQGIppz8dZbb7nck/POOy+/VzdpkNCZC0pafOqpp1zyUubIXV9AF110kd1yyy2BvHsTfYnq7lxN39EfJTCde+657sKr5zV6JKeuo1QfKaQASv9q5EiULrQnnXSSu/gouAjiaBmNGNGXaPS46zzQiBkFFUr4VDO5En7vu+++HLuOUrkr6OWXX7bXX3/dJW/H3sUqyFQSr5KegzpaRonMmT/79evXt7vvvtslfA4dOtQlcuviG0QbN260kSNH2rRp0w5qsVPA3bZtW3f8g9pqnQiCiwTpblUfOH3JaDhSEJsDc0OtN0HsDsiK7uIVaOqiqgupvlx0gQkrfQbUbK4M+rCc67rAqJtA21y+fPlABpTx0udAI0TCsg90Y6kWC533asEloMgawUUuhbXOhaj5U83g6gJSv6uGo+mLNdbw4cPtnHPOsaZNm1qQqMlX3V3RrjDR0Munn37a/vvf/7r6H2o2jQ7VDRLV87j88svdXWrLli0trMJa5yLacqXhx/r+01BbdQ+ptkusGTNmuITOXr16WZB89dVX7jjXrVs3/TG10g4ZMsR1Des7QS026jpVYiv+VzhCTU+Uc6ARAUuXLnV5Bup7Vz+0xvmrz7179+726KOPWlBbalTDYtasWe4uRc3hqnHw5ZdfZnidmkt/++03Cxrl22gfROlLVl8m+mJRd4hyMG677TYbP368BY1yKtQloi6/v/3tb4E8voeifAoFD8o70M1EkyZNXH0X3VSoFWPQoEGugJxaM4NI5/Zzzz3ngiflHWlb1UUYSyOI1GUUNB999JELMGJbrq6++mpbuXKly8fQdeDf//6320eIkd9jYVNF2OtcjBo1ytV52L9/v/td9R40pl91LWbPnp1tPYygaNWqVWT16tXpv6vGx9ChQzO8Rtut479v375IEOtczJ07N3LBBRdETj/99MiIESMiv/76ayQMwl7n4ttvv400a9Ysw/H+4IMPXF2H2M9A5noYQfHII4+4GjZRr7/+euTSSy+N7N27N/2xDRs2uNofQfzuTxQtF3EKe50L3ZFo26L9qso1uOuuu+yvf/2ru6NV9njYmsi1P2KpS0TdZMrHCCLdrb/33nuu2VstNOoiURLbpEmTXDNxUIW9zoW6QXV3HpuoruR1jRDRiBGNpAjbZ1+j5GK7wCpUqOA+D0Gs85GoYHYQHgb6ctGcEmoizi5xKVrnIoh5F0pY1ZdMZtGhh3369AnkMLxY0ToPopyTzEGEuk2UnxDkse4KKlXmWKXQJ0+e7LoLFGCqT16Jbeou1IiKoNa5yJxjFIY6F9l99nUz9dJLL7ncK3UVBZm6QjRiSMOPNRRX5b4z+/HHH+2CCy7Il/VLRgQXcQp7nQtts/JNlG+hanWxE3QpwNBoAQ3DDNq8CrEX1SuvvNJtn75c5KGHHnIJfrpr/fTTT+3JJ59049yDOBQzMyWuqcaBfnT+K6hWLlIQ8zHCXudCLVZKYB04cKD7/otNbFTOiVou9N1wwgknuOGpQaPP86hRo1zOiYJnFZDT8dbwUyWuK/dC+0B5SWrhwf9itEguhL3OhS6kKpSkWgZZjYrQSBLVudB48KCNmlCLle5MojUeomP9FXBqtIBKoWvEyGOPPRa4YclZTVwWNmGvc6HA8f7773czgKqQXmY6N7T9unOPTnAWtO/+zJ99Bda64dD2aqTM448/ftAImjAjuEhQmOtcaAhedkPu1D+tL9ucmo+DKMh1PnSO63wPatCcW2Guc5HTZ1/fh5o9OIgVesP62c8LgotcCnOdC929T58+3T755BPXDaQ7WpUGVl+7mko1VFXdRUGlqpzvvvuuy71RdUrlVyiQ0kVXdyyqUBnbXRQ06vJQeef58+e7ioXaHyp1rmG4p59+ukt4DFrpcwCJIbjIZZ0L1XdQAKGLqO5adFenyFVNpSqocs0117jXBY36lv/85z+7kTDqZ1RtD+VfKODQHYuaTTX+XSWA1TcdNLojUxKjtrVx48ZWsWJFl3cQnVtEOQdK+NPYfzWRB43ObSXt6pxXIKWASoGl7t613Qo4dEerBD/1SwMIN4KLOM2cOdMFDep3zW44qi6uugCpamPQKlT+61//cnftunhklxGvfsc777zT5aQE7Q5e1SkVRCrnJLuETe0b/ahlRy1aQaKCaZpS+o477shy2xRkPfDAAy4XSYlvQaJWSk3SFg/lJAwePNiC5OOPPz6oYFZ2lGul3IsgefHFF93IqHiosJ5KFoDRIoetzkXQgoslS5a4TPGchtppnLf2gVoxghZcaPuVuJXTSBBlzOtLWJUKg5RzosBB4/c1QVV2QZNaLTR5nRLcgkYtMWqt0o2FEls1WiQ76iIK4mgRnc8Kmjt27OhqOmRHQ7SDRjUtFFzo5lGVOXOaRyiIxz9RDEWNU9jrXGj7FTQpQzo76h5Q91AQx/pr+3VscxoNoDtcDckNWnKXAgfl1SjA1kU2bHUeFFBqhJQ+92qV05DjoB3jnOiYapTcjTfe6HKNNKdG0FrmcqJRYCrvrcBZ3/E6F3BodIvEScmLitrV155TnQtlkWvIZtBmiNT2KbDQfApqodDwSyXvKdhScSkNzXr11VddLoaaEYPm888/d3fmOgc0ll13KLqDieZcKPBSxUJ1H6ioVNDomKpVRnUeFDwr2IrNuVCis46/5thQYmsQ6VgraVk1b3QuhI3Ocw251vxJQazlcyiLFi1y+WSqSButdYPsEVzkQtjrXKhYjIrJ6EKrkTKxFGxotIBKQyvRM4h0AdUFVv9qpESU7mhPOukk98WjQmJBHZaoIlEKMtRFpAttlIIMteio/LWakIMsWoVVQXQYaZSQzm8Fl2GkWjcqpBf0iqQ+EFwkKMx1LrTNyitQi42qFCqYClMzsS6sCjTVmqUmc33R5tQPGzQKrBRcR4fiqj9eAQYARJFzkUvUuaDOBXUuwlnnQhNWqctTuTcKrhRkKqhWq12LFi1cMnd2BaaCQC1W0cRG1TzRTYa2X0mcarFSsmuQffHFF67VWsnNurFSC45uLDVCSF3l9erVy+9VTCq0XOQCdS6oc0Gdi3DWuVCX0IABA1yulUaLKMkxOrfI+vXrXTJr1apVXQn8IM6vo+5gDbFv2LChGzGnbVRSp1rv1FWg7Vcu1vDhw91+CRIFURpiryG5SmjWcY7WOFL3sOYU0URmmtCvX79++b26ySPhydpDZsaMGZHmzZtHVq5cme1rlixZEjnjjDMic+bMiQTN888/H+nYsWNk8+bN2b7mk08+iTRq1Cjyyy+/RIKmf//+kb59+0Z2796d7WtefPHFyHnnnRc5cOBAJGjat28fGTp0aLbbtnfv3sjAgQMjvXv3jgTNH3/84c7riRMnZvuabdu2Rbp37x55/PHHI0GzbNmyyGmnnRaZO3dutq9Zv359pFWrVjnuo1Q1ZcoU97les2ZNtq9ZuHBhpEmTJpFFixYd0XVLZsHMPEuCOhdBk9s6F0Hcfg3FO1SdCw1FVT5KkETrXKg40qHqXKjLIGg0X47yatTtkx11DyihNYjbr3Nf3T6qd5EddY1pqGZQt18zQav7KztKaFaRuSB+9yeK4CJO+nJRgKGhl9mJ1rlQTYCg1rnISRjqXOQkDHUuchLUOhcaCaauH/2Ecft17muoubqAsqMuAnWNBXX7NQw1dibczLRv9PkI4vYnipyLOFHngjoX1LkIb52LgQMH2pdffum2XzkXGh0Wzbn46aef7LPPPnN5GWPHjs2x0Fgq0g2VhlhrW3UHr2HXyrlQQqOCabXsTJ061d18qAaEagEFier4qH6NWq1V40Q5F9EbiGjOxVtvveU+C6p1lFPrZpgQXOQCdS6oc0Gdi3DWudi/f78r//3666+71rnYu1gNx9Vkdeo2yqmCa6rfXD3zzDNufiEFU7EUaKhL9Lbbbsux6yCVaXTUyJEjbdq0aa5QYiwF2m3btnXHP4it1okiuEgQdS6oc0Gdi3DWudAwRF1gdKeqUQPa/qAWTsvuTl4/CjBVpThsBbU0DFktFgow1Q1CQJE1ggvPNPZfSW9hbRpTM6kuNGG62GS+8KjWQ5guNrH0pRstix82at1Q10HQSv/HS8GWulDCVFAulo69Pvdh/e7PLJzfgIeRms1feOEFC6u77rrLTU8fVuqT1rj/MFJLzrnnnmthpYTfP/3pTxZWyrd4+OGHLayGDh1q48ePz+/VSBrBLSeXT9T3GLQiMrmhyc2COO1yvPr27RuqUvCxdMem4DKsNN+IhiOHlYqrhXXOFdFkbkEbKZYXdIsAAACvaLnIJeYWYW4R5hZhbhHmFmFuEeYWyRktF7nA3CLMLcLcIswtwtwizC3C3CJxyO/646mCuUWYW4S5RZhbJDvMLcLcIswtkhGjReLE3CLMLcLcIswtkh3mFmFuEeYWyYjgIk7MLcLcIswtwtwiOWFuEeYWYW6R/4+cizgxtwhzizC3CHOLMLcIc4swt0h8CC5ygblFmFuEuUWYW4S5RZhbJBZzi2SN4CJBzC3C3CLMLcLcIswtwtwizC2SNYILAADgFQmdAACA4AIAACQvWi4AAIBXBBcAAMArJi5DaC1btsw++OAD9/9rrrkmy6nSDxw4YM8++6zt37/fOnfubFWqVMnTe7700ktuGRdeeKHNmTPHvvzyS1c/Q5MgHU4bNmywN954I8fX3HrrrV7fc/Xq1VawYME877O82Ldvnz3zzDNWr149V0Ex2SXDPgN8oOUCobV8+XJ76qmn7IUXXkgPMjL76quv7Pnnn3ev+/HHH/P8nmPHjrXp06fbkabgQtuwaNGiI/J+K1assA4dOnjZZ3mhoFDb/cknn1iyS5Z9BvhAywVC7+yzz7b33nvPunXrdtC+mDp1qp1zzjn24Ycfet9Pp59+uvs5ktRicuWVVx7299m+fbvt2bPnsL9PkLDPECQEFwi9iy66yAYOHGibNm2yMmXKZGhS//jjj+3uu+/OMrj4/vvv7X/+53/cRbR+/fp21llnZXg+EonYF1984VoLVGjn4osvzvB8dt0iX3/9tS1cuNB27txpxx9/vGvOL1myZPrfLFmyxAVCagFRM3rZsmWtdevW6a/x4VDbltN6rly5Mr0LZuLEibZu3ToX0GhfLFiwwG666aaDuooqV65srVq1cu+pFqXzzjvPbd/RRx9tbdq0SS9UFM96HYr24dKlS+3yyy+3adOmufXT+us80PvNnj3bvvvuO7df9d4qlBX9Ox3Lq666yrV0/fzzz1ajRg233erKyLz/tH+2bdvmumS0nmlpae65rLaxTp06We6zQ+3r3J4T2m61xqm7r1GjRtagQYOEjj1wKHSLIPR0gdB8AZkDiFmzZlnNmjWzzMV4+OGH7bLLLrNvvvnGfvnlF/vLX/5ivXr1sl27drnnd+/e7X6/4447bP369fbZZ59Zx44d7ffff09fhi4KarLXF73oy1wzr95+++22du1a27Jliys3rqDkp/8ruay/UTeNLnC6CG3dutX9fskll9jGjRu9HMtDbVs865kVBVLKf8iqq0hBnOjC9+STT9q1117rLrBvvvmmu/jGs17x0j7U+iqHRt0lKuv/4IMP2tVXX2233Xaby7HR8rUeCkB0LKN/p/W/9NJL7e2333bBxaBBg1wQoIq90YD0nnvusa5du7qAQPunX79+1qNHD3esstvGo446Kst19XVOKNB94IEH7IorrnAT8P33v/+1nj172uDBg3N17IG4ZZqCHQiNd999N1K7du3IN998Exk2bFikR48eGZ7v379/ZOzYsZGZM2e6182aNcs9/sYbb7jfJ0+enP7adevWRRo1ahT5xz/+4X5/5plnInXr1o2sWLEi/TWvvPKK+7t7773X/f7000+73/fu3et+HzduXOTUU0+NrF+/Pv1vtm/fHjnttNMiw4cPz/A3L774YvprNm/eHKlfv35kxIgR2W7rggUL3N/16dMnMnLkyIN+tm3bFve2xbOe0feL7jPRPq5Xr95B63b++edHBgwY4P6vddHfvfnmm+73AwcOxL1eWdm1a5f7u/vvvz/9seg+HD16dPpj//73v91jt956a/pjCxcudI99+OGHGf4uevxkw4YNkaZNm0YGDhyY/pqTTz7ZbX/U2rVrI40bN47ceeedOW5jVvvM1zmh98q87NmzZ7vHvvzyyzztYyArtFwAZq4Jee7cua5rRHS3qiZmPZ6Zmq/V2tG+ffv0x0444QTXhP7WW2+5u8TJkyfbueee61o+onRnmVPXhaZrvv/++12zt5ahO1W1eBQpUuSgJD8l/sX+nboVdDeaV/FsW27WM1HRpvhoV0I865Vb7dq1S/9/rVq13L+xXVfRx9S6EEutG1EVKlRwLSDK2VErwzvvvOOO+2mnnZb+mkqVKrnWDb1GeRXZbePhPCcmTZrkujiaN2+e/ppmzZq5lonovjsc+xjhRc4FYOb6xStWrOi6RtR3PWPGDPdFq8c0ZDVzVr9mQhw1alSGx9X9oW4PNZer31uJoBk+bIUKWbVq1bLd3/oSHz9+vGt2V96CvszPOOMM92+06yQqc1dN4cKFXZN8XhM6D7VtairPzXomQvkn2u+5Xa/y5cvn6n2UlxAVzZmIzbmJPqYRJ1HK/VBAEat69eq2Y8cOty664Ct3JDMFKlqOgoPstvFwnhM6H7NKHu7du/dh3ccIL4ILIObCGx01olEiSvDLir7UixYtetDjTZs2dT/qP9fdaFZ3ejldfIcNG2ajR492fezq+1aSny4QWdVnyOluNy/i2bbcrGc8Yi/e0W3LnCAZz3rlVub3iIcCxOyOqZanY57VsYm+Jvr3WW3j4TwnMu/jrByOfYzwIrgA/o+CiXHjxrm7z5kzZ7om46wo+bNYsWIHFZ369NNP3SgDdX3obnbVqlUZno/euZ588slZLvfVV1+1li1buuS9KDW1K+HwSDnUth1zzDFxrWdWF7ronXTsBVj75LfffvOyXkeCus3UtVGiRIn0x3ScS5Uq5boQVPxKLQyZqVVA26/ujexktc98nRPaf1l1Wb322muuC0UtJMmyjxEM5FwA/6dJkyau2VsjB/RFe+KJJ2a5b5RNr/wMDVmM0gXyvvvuc8P41OTdpUsX1ze+ePHi9NdohEFOF1J9eWvoYqyXX37ZXUz27t17RI5TPNsWz3oqJ0Biu2rUzaS7Y41WiFJLUTwjEeJZryNBgdGYMWMyFCfTCA2tn1oi9K8uxhopEqWcDeUsKHiNDmvNSlb7zNc50alTJzeUdd68eemPKR/jkUcesT/++COp9jGCgZYL4P/oy1NdIxMmTMixFHb37t1d0KD+at3xqZ9auRrq89bQRNGwRl1g9FolyOkLXMFGTn3Wqneh4YJ//vOfXeuGvtBVl0B5GjkN8fQpnm2LZz11B6+7YA3d/Pzzz+3ee+91uQi1a9d2dS6UfKjcFF3woomTeV2vI0XBhLZZrRDvv/++S96MJnlqn2hfXHfddda2bVsXMOg16s5QYmZOstpnvs4JBbs6H2+44Qa3XnqfKVOmuHNT+RzJto+R+tI0ZCS/VwLIz7lF9MUbTdLTl/dHH33kvnCVbR+9w/vPf/5z0NwiKlykmgW609QFUgmcme/udKeowlH6MtfFVXe1aobObm6R2CJHuoAoo3/+/PnujrJPnz7uAqG/yRz8qPlcTfO6cOQ0t8gFF1xgp5566iH3zaG27VDrqS4AdQ9Ei0SpzoPojls1LdasWeMuzhqNo/2tO/poES3tl1tuuSWh9YpnbpHofo/dh+qu0kiP2OMe/dsWLVpY48aNXX0J1afQMVXCr/ap9qW2PbNoK4G+XvWaM888M0MRrey2Mat95vOcUKuR3lutLAqKGjZsmOd9DGSF4AIA4hANLnSxB5AzwlEAAOAVwQUAxEF1IrLrrgGQEd0iAADAK1ouAACAVwQXAADAK4ILAADgFcEFAADwiuACAAB4RXABAAC8IrgAAABeEVwAAACvCC4AAID59P8ANyQXfnJBGb4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Generating Composite Feature Importance Plots...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Collecting ensemble statistics from /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival/ensemble_evaluation\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAIrCAYAAABPtvtqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAyWBJREFUeJzsnQV0FOf6xp8kG3clhISggeDuVqC0pdShLrRU7y11d7t1gdrtv3qhtKXuLVAo7q6BECTu7v4/zxcm3Sy7YZNskt3s+ztnzqzMzn4zK98zrzrU1tbWQhAEQRAEoY1wbKs3EgRBEARBEPEhCIIgCEKbI5YPQRAEQRDaFBEfgiAIgiC0KSI+BEEQBEFoU0R8CIIgCILQpoj4EARBEAShTRHxIQiCIAhCmyLiQxAEQRCENkXXtm8nCB2D3377DY8++mij2zz88MO49tprYQs8//zzWL16Nf7++2+T2zz99NPYsmULli9f3qL3+uGHH9S+9HFycoKHhwd69eqFG2+8EWeddVaj59nV1RWBgYGYMGEC7rrrLvj6+jZ4Pj8/H1999RX++usvJCUlqe179uyJK664Aueee+4Zx1hUVIT//e9/6vXJycnQ6XTo1q0bZsyYgWuuuUbtTxCE5iPiQxCaQXV1NSoqKvDJJ59g5MiRxn9cOtv5eVVWVqK8vLzRbaqqqtR2ljp3S5YswaBBg9RjNTU1SjAsXLgQd9xxBz744ANMmTLF5HkuLCzEhg0b8Oyzz+LYsWNKKGjExMSofXTp0gX33XcfoqOjUVpait9//x33338/Nm3apF7n4OBgdHx8v+uvvx7sPPHYY48hKipKHffOnTvxn//8B+vWrcNnn31m8vWCIJwZ2/l3FAQrxNnZWa6CLXTu3N3dlSig9YWTO8WHqW15++KLL0Z8fDzef/99JTgoMmixuPPOOxEREaEEi4uLS/1rbr31VvW6F198ERMnTsTZZ59tdFyrVq3CwYMH8fPPP6Nv3771j5933nlqfc8992Dr1q0YM2ZMcw9dEOweER+C0Mpwsjty5AguueQSfPrpp8qMHxYWptwLl156qdqmpKQEb775JtauXYvs7GwEBwdj8uTJyqXg5eVVv6+jR48q6wCvwmktGDZsmLq67927d/17xcXFqYmbboeMjAxERkbigQceUJYYvgctBaGhoWoSnTZtWoOxLl26FF988QXS0tLUxMv3N2XZMWc8TYVigRYLvr859OnTR60TExOV+Pj111+Vm+W1115rIDw0rrrqKhQUFKjjNwXPP6ElxhC6bPbt26fEUGOuqBEjRiiXG89xcz+TlnyWFEcffvghDh06pCw5FGPXXXcdLrvssno3W2xsrHIlrVy5En5+fnjiiSdw++23q/e94IIL6vdVXFysxvCvf/1LfWcFwRJIwKkgtDJ0V+zZswfffPMNXn75ZfVnzytvxjJwIiP846c74J133lFm/VdeeQV//vknXnrppfr9cLK4/PLLlXuEAoFX5j4+PiqOgZOQ9l6cDBmr8N5776nJmO6Bf//733jyySfVxMU4CroSKBIyMzPr95+VlaXcF5yYfvnlFzUxcbI5fPiw0eMyZzxNhRMlxUP37t3N2p5jIF27dlVrijeKtSFDhhjdnoJk/vz5GDhwoMl98rPhdhReb7/9Ng4cOKCEFeG5pPXE0dGxUVcUzwmfa8ln0tzXUQjedNNNGDt2rHI1/fHHH5g6dapyIe3du1dtwzFv27YNZWVlah90R40bNw6dOnXCjz/+2OBY+P60KGmWH0GwBCI+BKEFzJs3T01khsvQoUMbbMc/eV6N9+vXD/7+/rj33nvV1TOFCOFEMHjwYGVt0CZPuh/0AzN5pUvXxIIFC9CjRw91xcurVF610vqgwTgJxiZwG1pYeLVLywqvXHlFzgnmlltuUWOie0Gf119/Xb13586dlQuEVoh3333X6LGbOx5z4ORO0UFBRssEx9cYHPuyZcuUe2bSpEn17pHU1FQ1dk0cNAdaF2g14HFw0uf5GzVqlDp/FFg8v02luZ9Jc15HAUkr0M0334yAgAC1DV1R/L4ZBhRTtDBwd/r06UrY0JW1efNmpKen129D0cPjb8xaJAhNRdwugtACGBhpzC1hGIxIiwAncg1OBHyME4l2tc0sEE4iNO3zKtTb27vB5MxJgZOEp6dngyyR0aNHq6tTDWaNaJYAomWC8ApZQ3Pl6LsWQkJCMGDAgPr7nMA5DsMr4aaOxxR0S2jniZMsLQr9+/dX53T48OGniTz9c0oLCc8nM09oydAfsyWCYmk1oLihpWD9+vXKAkGrCuNBvvzySxVPou8OOxPN/Uya87o33nhDnZ81a9YoC9Tx48eVhY3nhYG3Gm5ubqcJCroGKTZp+aKooQuKnzMFkCBYEhEfgtAGAafG4g84mWrmfFoZGL9AEzj995xEGdBIczitJfS7U5jQFbNixYoG++HErWWFaBOWuWPQh3EmhvCqmBOWtm8Nc8fT2HvSaqFlu/B4tTiKxkQeXREUAbQInXPOOcr1oA+tA4x34Hk1Zf2gS8Scz4yfD61AXChwcnNzlUWH8RcfffSRsl6ZS3M/k+a8jhYQWjp4nLTA0RL33HPPKRcaM3j0hYyhSKago3ikhYfig24bvpep4FxBaC4iPgTBCuAf/Ny5c9XCK1jW3GC8Aa/4OdnSvUGrwtVXX40HH3zQ5D5aAtNXDWEcCC0bhvu2xHiakimkbctl5syZCAoKUnENFDiMZeBYCF0wdGUxTkMTNvpQFDEwkxadV1991eh7nX/++UoI0q2kD91lFD2MyWF2jaGA1OB9S1hfmgPFBcUrRSMtNJpVhMdNsWgOtH6wRg3jaWgB4flqipVHEMxBYj4EwcrgFSl978xOyMnJQV5enspu4FUszf+8rU3EXJhCesMNN7T4fZkxwpgJDU5YNLkbSylti/E0BmMQ7r77blUrRF9EUDgwxoEWCkNRQBj0y8BMulVMwVgKij8KL0MoKmj1YcEyQmHGGBV9iwInbf37bQnHxkwhiit9wcAgVI7JnHHRosTXMoV5//796rsoCJZGxIcgtDO8ImVaLS0IWppnQkKCuupkECpjMQgn2xMnTuCpp55SEyNfR/88g1VZVKulcGLiFS9TOjmhMuuFYkQ/pkKf1h7PmaBViCJk0aJFquAY4aRJMbJ7924VlEkXBF01HB+DSBm7wCv7xiZUHi8tByw0RqsTj4tChqKCz9HqQ6sLYQoqJ3zGgPB9Tp48qawj7VVgjsdPqw2tP6yBwnEz04rZMUSLMWoMHh/jjuhSoyuOQkYQLI24XQShBRgGQuozfvx4FatwJhj4x+2YacLy3Yyx4CTC9Eh9lwYnWsZJ0B3DSY8xDayn8d///leJl5bCDAkGfNJ6wAmVwaec2Pm4MVp7PGeC70ehceGFF+KRRx5RYo3ZHbTUfPvtt6qmCtNSKTy08uovvPCC2r6x6qR06Xz//fdKrDDVmXVZOInzcX4mFDC8TWhB4WfEDBMGejLmhLUyzHVxtAbMPmIMEWt1aGXh6c5jACpFmTlQoH333XeYNWtWvUtLECyJQ2172QcFwYYxx6+vBVHyipjbG8ZAMF6B2xheJTcWLKkPf7qGk6ix99LGyse07flavj/Hx/cyfJ2xMZg6jsbGYwy6c7gv/fGYQhu7Nk5j8HluZ2obc8/nmcZxpn3ob6P/2VrqMzH3daY+D+5Pyyo602fJlFxajhhwqrmYBMGSiPgQBEEQFBQxdM3cdtttCA8PV9YcQWgNJOZDEARBUDB9mDEeTPHV4kQEoTUQy4cgCIJgUTeVIJwJER+CIAiCILQpIm8FQRAEQWhTRHwIgiAIgtCmSJ0PPZgDz/S0xnpMCIIgCIJwOkwDZ3q3YVdvY4jlQw9zyw83BS0H3xbKqdjKWGWcck7lO2pfvyVbGqs9j7O2CXOoWD700Cwe7AJpKZgzzyZUvXr1Mtmh0lqwlbHKOOWcynfUvn5LtjRWex7n/v37zd5WLB+CIAiCILQpIj4EQRAEQWhTRHwIgiAIgtCmiPgQBEEQBKFNEfEhCIIgCEKbIuJDEARBEIQ2RcSHIAiCIAhtilWLj5SUFMTGxpq1bU5ODuLj41FdXd3q4xIEQRAEoQOKj8LCQlx88cW44IILUFVVZXK78vJy3HXXXRg3bhxmzJiByZMnY/PmzW06VkEQBEEQbFx8lJaWKkGRn59/xm3fffddLF++HI6OjvDz80NmZibuueceFBQUtMlYBUEQBEGwcfGxfft2zJkzB5s2bTrjtqwh/+2336rbH374ITZu3Ih+/fohLy8Pf/31VxuMVhAEQRAEmxcfH3/8MeLi4nDDDTeccdukpCTk5uaqnixjx46FTqfDhAkT1HMHDhxog9EKgiAIgtBUrK6x3IgRI3DLLbcgOjoaixYtanTbjIwMtfb19YWTk5O6TdcLofulOdCawoY7lmJ/zFr8dug3xBzQYWS1KzzgAGulpqYG3mXlyNztqtxYtj5Ot96j4Dn8PLSn+1B/bc3YylhlnPZ5Pm1prPY8ztraWjg4ONim+KDwIMXFxWfctrKyUq014aF/W3uuqfB17PRnKXbHbcYRlxocQQX+qCnHgOJyjMovRfeySquUIfxCVOcD1p4zZM44K9JPIME9EjDzx9BanDx5EraCrYxVxmmf59OWxmqv43RxcbFN8dEUtDbAzHjR0G43t0UwXThsMWwpwrt0hsu2b7C/Oh3JFXnY4+2mlk4uPpjo3wtjfLvDS+cGa6CiolxZk0JCQuDi4gpr5YzjrK1B3q8L4VBTjT7dI+Do7t0ew1RXFPxhd+vWDe7u7rBmbGWsMk77PJ+2NFZ7HmdcXJzZ29q0+OjcubNaM7OFlhJPT08kJyerx8LDw5u1T5qMmitcTDG4y0Rc0bcv0sqzsPLYBmxI2I70igJ8l74LP2Xuw6jwIZjeYwL6h0SZbbJqDehuSkYMfKKjLX4O2nqcBas+Q01JAVyqy+Di0QntCX/Y1nw+bXGsMk77PJ+2NFZ7HKdDE+YvmxMfCQkJKCsrU+IiODhYqTaqtwULFmDixIkq7ZaMGTMG1gQ/lJ4BkWq5fshl2JiwA6uObcCx3HhsStihls5eIZjWczwmdxsDXzef9h6yTaPz8kdFSQGqCnPgEhLZ3sMRBEEQ9LDeqEITzJ8/XxUe279/v7r/73//W60XL16s4kWYZjts2DBVdMxacXd2w/SeE/DSjEfw8tmP4uyeE+Guc0NqUQaW7P0Rt//6GN7c9BH2pcWgpramvYdrkzh5Bah1dVFuew9FEARBsBXLBwNHe/fufZopJzIyUpVQ13xUF154Idzc3LB06dJ64UGB0p7ui6bQI6AregRcjesGX4pNibuw6th6HM05iS2Ju9TSyTMI03pOwJRuY+Dn7tvew7UZdN7+ak3LhyAIgmBdWK34oKD47bffTnv87bffPu0xllXnYsu4Obthao9xajmZm4RVxzdgXfxWpBdn4ct9P+Hr/b9geJdBmN5jIgaF9oWjg80ZrdoUsXwIgiBYL1YrPuyZbv7hmDf8Slw7+FJsTtypYkOOZB/HtqQ9agn2DMS0HuMxpftYBLjX1TURGiKWD0EQBOtFxIcV46pzUQKDS0JeMlYd34h1J7cgszgbS/f/gm8O/IZhYQNVpsyQ0H5WXRisrXHyqnO7SMyHIAiC9SHiw0bo6tcFNw67HNcMuhhbknYrt0xMZhx2JO9VS6CHv7KGnNV9nLpt72hulyoJOBUEQbA6RHzYGC46F0zqNlotSQWpWHVsI9ae3ILsklxlCfn24O8Y2nmAsoYM7dwfTo7/VH+1J3Te/2S71NbWwEFiZARBEKwGER82TLhPZ9wwdDauGnQRtilryEYczIjFrpT9amE8iApi7T4eQZ51k7G94OTJzCAHoKYaNSWFp+4LgiAI1oCIjw6Ai5MzJkSOUktKQZoSIWtObkFOaR6+O/gHvj/4J4Z07q/cMowR0dmBNcTBSacER3Vxnkq3FfEhCIJgPYj46GCE+YTiuiGX4cqBF2J78l5Vzv1AxhHsTj2gFn83X5zVYyym9piAEM9AdPSgU4qP6iLW+uje3sMRBEEQTiHio4Pi7OSMcV1HqCWtMKPOGnJiM3LL8vHDoWX48dByDAqNVtaQEV0Gd0hrCOM+2Nm2qlCqnAqCIFgTIj7sgFDvEFwz+BJcMeAC7EjZp6wh+9JjsDftkFrYR+as7mMxrvMwdMx0W6lyKgiCYE2I+LAjdE46jIkYppb0okz8fXwTVp/YhLyyAvwUs1wtke5hON+3AhO6j1TbdwTxIem2giAI1oVtzy5Cs+nkFayyZOYMmKUyY1YeW4+9aTGIL03B+zsXY8mBH1Rxs2k9JqCzd4htp9uK20UQBMGqEPFh5zDWY1T4ELXEZyXhx11/4FDpMWUN+eXwX2rpHxKluvCO6jJExZJ0JLdLTVkxKrISUZGRULfOTERVbhp8hs2A37hL23C0giAI9oOID6GeYI8ATAwcjnl9rsKR/OMqNmR32kFVO4SLt4snJncbo7rsdvEJtRnLBwNOayrKUJGVhMrMBCUwKk6tqwuzjb42f+dyER+CIAithIgP4TRYFZUZMFyyinPw94lNWH18E7JLc/Fb7Cq1RAf3VlVUR0cMVXVGrLuzbQ5OvnaN6e28A+ESHAGX4K7Q+QYje8UnqC7IRk1VBRx1Lm04YkEQBPtAxIfQKKyMevmAWZjdbyb2pB1U1pCdqfsRk3lULZ/u/hqTI0cra0iEb5hVnU0nT5+6Wh+n+ruw0JhzcFe4BFFoRMAlpCucgyLg5OZZ/5ra2lrkrPkStRWlqMrLgEtQeDsegSAIQsdExIdgFuyYy+qoXHJK8pQ15O/jG5FVkoM/jq5WS5+gnsoaMjZimOpB0944ODqhy42voDIvDS6B4WZVOXVwcICzf6iqD1KZkyriQxAEoRUQ8SE0mQAPP8zuPxOXRp+r6oXQGsL6IUeyjqnlf7u/wcTI0SpIld142xOdT6BamoJzwCnxkZvWauMSBEGwZ0R8CC2yhrBnDJfc0nxVM4TWkIzibCyLW6OW3oHd66whXYfDTedqE2eblg/CrBdBEATB8oj4ECyCv7svLu13Hi6OPgcH0o8oa8j25D04mn1CLf/b8y0mRo5SQqSbf4RVn3XdKfFRmZva3kMRBEHokIj4ECyKo4Oj6hnDhbVC2E+GfWVYUXVF3Dq19AyIVCJkfNcRcHN2s7pPwNm/s1pX5qa391AEQRA6JCI+hFbDz81HWUIu7Hs2DmXEKmvI1uQ9OJYTr5ZFe77DBGUNGY8eAZHW53bJy0BtdRUcbLzMvCAIgrUh/6pCm1hDBnTqq5aCskKsObkFq45tQGpRhirrzqW7fwSm95iI8ZEj4OHs3q6fipO3Pxx0LqitqkBVfiacA+osIYIgCIJlEPEhtCk+bt7KEnJBn+k4lHlUiZAtSbtxIjcRH+38Eov3fq/cMXTL0D3D1Ne2xsHBETr/TqjMTFQZLyI+BEEQLIuID6FdoKhgzxguc8uLsO7kViVEkgvTVMYMl0i/cCVCGKjq4eLe5q4XJT5yUoGeQ9v0vQVBEDo6Ij6EdsfH1Quz+kzD+VFTcTgrTsWGbEnchfi8JHyyayk+3/s9xp2yhjB1t02DTvMk6FQQBMHSiPgQrMoawp4xXG4cejnWxddZQxILUlXWDBeWcJ8UMQpB1d5tE3RKy4cgCIJgUUR8CFaJl6snZkZNxXm9z0Jsdl2H3U2JO5GYn4Iv8n+CzsEJoytjcE7UFPQJ6mHx2BBdwKlaHzkpqt9Le8SeCIIgdFREfAhWDSd99ozhMnfoHKyP34YVR9chqTAVG5N2qKWLT6hyyUzuNkaJFkvADrdwcFQxH7lrvkTAWaa74gqCIAhNQ8SHYDN4unjg3N5TMDFsJP7esw4nHdKwLWUPkgvSVM2QL/f9hNERw5QQiQ7u1SJrhc7LH0Hn3oKsP/8PeZt+gIOLO/zHX2rR4xEEQbBXRHwINgdFRZhbCKZFT8a8kVdiQ/x2VSvkZF4SNsRvU0uYdydMozWk+xgV0NocfIbNQE1FKXJWLUbumi/g6OoO3xHnWfx4BEEQ7A0RH4JNw4JkM3pNwtk9J+J4boKKDdmQsB0phekqS+ar/T9jVPgQZQ1hWm9TrSF+Yy5CTXkJ8jZ8h+zlH8PRxQ3eg85qteMRBEGwB0R8CB0CigoWJeNy/ZDLsDFhh8qUOZYbj00JO9TS2SsE03qOV7Ehvm4+Zu/bf9KVqCkvRcH235H52/twcHGDV9+xrXo8giAIHRmrFB8FBQVYtWoV8vPzMWzYMAwaNKjR7ZOSkrBt2zaUlZVhwoQJ6Nq1a5uNVbA+3J3dML3nBLUcz0nAquMblGuG5dyX7P0RX+3/BSO7DFbWkAGd+qjy72cSNoFnz0VtRSkK9/6NjB8XwPFyN3hI8TFBEISOIT4SExNx1VVXITMzs/6x+fPn48477zS6/U8//YSnnnoK5eXl6r6zszOefvppzJkzp83GLFgvPQK6okfA1bhu8KUqVZfWkKM5J1URMy6dPIMwrecETOk2Bn7uvo2WXA+aeTtqKspQHLMJ6d+9itCrnoR7135tejyCIAgdgcYv+dqB1157TQmPXr164YILLlBXne+99x5Onjx52rYZGRl45plnUFFRobY966yzUFlZiWeffVaJGEHQcHN2w9Qe4/Gfsx/GqzMexzm9JisLSXpxlsqSuePXx/D6xv/DntRDqKmtMXriHBydEHLRXfDoNVw1nUv7+kWUp8TJSRYEQbBl8UER8ffff6vbFByvv/46pk6dipqaGqxcufK07Xfv3o3S0lJMnjxZbfvBBx9g0qRJSoD8+eef7XAEgi3QzT8c84Zfif+78GX8a9T1iArsgeraGmxL2oMX172D+b8/hR8O/Ymc0rzTXuvg5IyQS++HW2R/5YZJXfoCKvMz2uU4BEEQbBWrEh+0blA4eHh4oFu3buqxfv3qzNrHjh0zKlYMCQgIUOvDhw+3+ngF28ZN54op3cfihekP4vVznlDVVD2d3ZFZnI2l+3/Bv359HK9u+AC7Ug4oAazh6OyK0DmPwiWkG2pKC1F8cGO7HocgCIKtYVUxHwwwJZ6e/1Sp1G7n5Z1+FTp48GA4OTlh7dq1ePLJJ1W8x2+//dZgX02FpbRLSkpgKWiZ0V9bM7Yy1tYYZ5CLP67oOwuX9D4H21P2Ym3CFsTmnMCO5L1qCXDzw+TI0ZgYMQoB7n7qNc7dBqEi4yTKclKNfmds5Xza0lhlnPZ5Pm1prPY8ztomtKKwKvHBgRNjg9ee04dZLQxGXbBgAb755pt6y0dOTk6zx0DLS0xMDCyNsZgVa8VWxtpa4wyAJy4JmIYsr1zszT+CA4VHkVOWhx+PLMdPR1agh0c4hvj2Rd/CcrC9XV5KApIb+c7Yyvm0pbHKOO3zfNrSWO11nC4uLrYnPry96zqV6l9FFhcXq7Wvr/FMhDvuuAOjR4/G9u3bERERoU7kwoUL4e/v36wx0HrCYFdLQVXJMdGN5O7uDmvGVsbaluOciHGoqK7EztT9WJOwBUeyj+FYSaJa/HQeGB7giTEOZYiOjm7XcbYUWxmrjNM+z6ctjdWexxkXZ34AvlWJD1oyHB0dUVRUhJSUFISFhSE2NlY917Nnz9O2pzBZs2aNslbcdttt6rF58+aptbHJwBxodWHMiaXhh9sa+20NbGWsbTVOvsM07wmYFjUBKQVpWHV8I9ac3IK88iKsCvDE37VlGLLjM0zrMR7DwgZC5+jULuO0BLYyVhmnfZ5PWxqrPY7ToQkVpK1KfDC+Y9SoUdiyZQvuuusuVVyMWS48oGnTpqltvv/+e2RnZ2PWrFkICgrCE088oSwlLDLGWh8bNmxQZp/zzpMeHILlCfMJxXVDLsOVAy/E1pPb8Pu6T3HMwwW7Uw+oxd/NF2f1GIup3cfDy/H0HzTTeBm8qta1NSrLxvA2i55xPy1pjCcIgmDNWJX4II8++iiuv/567N+/Xy3kpptuqrd8LF68WGWyMNiUlpG7774bL730khIlRKfTqdoffE4QWgtnJ2eM7zEOXb5/H5koxJHJF2Bd6n7kluXjh0PL8OOh5XDVuaC6uhq1x0+JDhP1Q4wxqFM05o+Z26Qy8IIgCLaC1YmPvn374o8//lCLVl59/Pjx9c9fdtllqriYJi7mzp2rLCS0fDBegxYSLU1XEFoTWiZ0PoEIyk7GwE5DcNWIq7AjZZ9qbrcvPQZlVXVVd3F6rLRRaPFwcnBEVW21ev1DK17E/eNuRVRQj1Y9DkEQBNi7+CB0p9D6YQxjj1OgcBGEtkbnE4TK7GRUFWTB3UmHMRHD1JJXVoDcwjwcP3YcUb16K5eiJi64NrxNIaO5WZLyU/HGpg+RXJCG/6x7B89PfQBd/brIhysIQofBqoqMCYKtQcsHqSrIbvC4n5uP6hvj5+yNQA9/VRuEj3m7esHTxUOVdnfRuUDnpFNB1vrxHeG+nfHS9IcRHdwbpZVleGn9e0arrQqCINgqIj4EoQU4+QSpNS0flu5F8+D42xDm3QnZJbl4ed17SogIgiB0BER8CAKAguIKrN2VhOz80mZaPiwrPoiXqycem3QnfF29cTIvCW9t+gjVNdXyeQmCYPOI+BDsmpSsIryyeDtueHY5Xv9iJ+a/vgY7YtKbFPNhzO3CirzGqvI2lRCvIDw88V9wcXLGnrRD+GTnUovsVxAEoT0R8SHYLZv3p+Det9Ziw94UVFXXwNPdGYUlFXj24y34/M8YVFfXmC0+qvUsH1X5mUhYOA+ZH86H5+7vULzzD5QlHUFtVWWzxtkrsBvuHjsPDnDAyuMb8PPhFc3ajyAIgrVgldkugtCaUGgs+v0Qflpb1ym5X/cA3HrxQER08sYnvxzAH5tO4puVsYg5kYMHrh2OAB+3M7pdaspLUFNeCkdXdxQeWI/q4rrGhi4l+ShMj0Xhuq/g4OQM17BecA3vA7fwvnDrEgUnT+NtAwwZ2WUwbhg6G//b/S2+3PcTgj0DML7rSIucD0EQhLZGxIdgVzCm45XFOxBzsq754CVTeuH6mdHQOdUZAe+4bDD69wjEu9/uwf5jWbj7zTV48NrhGNQr2Oj+HF3c4ejmiZqyYhX34RIcgZKjO9RzHsPPQ1ZROfyr8lCZGoeakgKUJcaoReu57BwQ9o8YCe8D56AucHAwbpCcGTUVGcXZ+CP2b7y3dbHKoGFGjCAIgq0h4kOwG/bGZqq4jryicni46XDPlUMxduDplXAnDQ1Hjy6+eHnRdsSnFeLJDzbh6nP6Ys60KDg6Ohi1flScEh9OHj4oT67rR+Q59FwkJ6XDPzpa9U+oyk1FWeJh5YIpSzqMyqwkVOakqKVo32r1Gkc3LyVC/CddCdfOpxcXu37wZcgqzsG25D14dcMH+M+0B1XJd0EQBFtCxIfQ4ampqcW3f8fiy2WHUVMLdA/zwSM3jERYkJfJ14SHeOP1uyfh/37Yj5XbE7Bk2WEcOpGD+64eBl8v1wbbOnkHARkJKui0uihXlTR16dQdTt4BAOqCV1nHg1YOLt6Dp6rHqksLUZ4Uq4QIBUl5ylHUlBWhJG6nej70isdOGxdrgswfcyOeW/0WjuacxEvr3sML0x+UMuyCINgUEnAqdPgU2uc+2YIlf9YJj7NHdcVrd01qVHhouLnocPeVQ3H3FUPg4uyEXUcylBuGsSDG4j7KU4+hWHO59B5xxv07uXvDo/dwBJx1DcKuew7dHvgcwRfMV89VZCWafB17xjw08Q5VxCy9OAuvrv8vyqsqzvh+giAI1oKID6HDEpuQi3veWoOdhzPgonNUIuKuK4bC1blhy/szMX1UJN64exK6BHshO78Mj76/AT+uiatPeXXvNlCtC3evQEnsdnXb0wzxYYiDkw7uPYao21V5maipPNUbxghsOPfopH/Dy8VTWUDe2fKZ6pYrCIJgC4j4EDocFAW/bzyBh99dj8zcUnQO8lQuFIqI5tKtsw/evGcSJg3pguqaWnz660H857NtKCqpgFe/8fCfcs2pN6+Bk5c/XIzEa5gDs18Y90HXTWVOaqPbMtbjwQm3QeeoUzEgi/fWdXYWBEGwdkR8CB2K0vIqFVT6wQ/7UFVdi7EDO+Oteyaje5h5Ka2N4eHmrFJv77hskMqO2XowDfe8tRZxiXnwH38pAmfMAxyd4D14msmMlTOhYkMC65rIsWHdmWC2y79H1zVbZBYMF0vBdOHa6iqL7U8QBEFDAk6FDkNCWgFeXrwdielFKivlxln9cNGkng2atrUU7mvmuO6IivBX75WeU4IH31mPmy8agJnjzoP3kGlwdG4YkNpUXIK6oDz5CCqzziw+COt9ZBbnqPofi3Z/B1837xbXACk9uR+pXzwDnW8w/MZeooJkHXTOLdqnIAiChlg+hA7Bml1JuG/hOiU8WBTsxTvG4+LJvSwqPPTpFeGHBfdNwZgBoapoGS0try/ZibLqlv+kNMtHRXaS2a+5qO8MTO85EbWoxdubP8Oyo2taNAYtcJbVWrOWfYiE9/6F/G2/NRqHIgiCYC4iPgSbprKqGv/9fi/e+GInyiuqMbh3EBbeN0UVCmttvNyd8djcUZh34QA4OTpg3Z5k3LdgLU6mFrRov85B4WptruWDUGTdPOxKnNNrshIgn+76Gi+vfx8b4rejrKrpgqEi/YRae/QZDSfvQFQX5SD7r8+Q+N4dyNv8k6rmKgiC0FzE7SLYLBm5pVj47XYVc0GumB6Fq87pq4RAW8FJ/+LJPdE30l81qEvOLMb9C9aquJBxA4xXRT0TLlrMR04KamtrzI8fqSzDlb5RcAvKxs9ZB7ArZb9aXJ1cMDxsIMZHjsSQ0H5wdnI+Y8BuRfpJddt/wmy4BEWgcN9q5G36EVX5Gcj5+3Pkbf4RviNnwWfkTDi5eTbrOAVBsF9EfAg2SWxyKX7+cQuKS6vg7eGM+64ejhHRndptPH27BSg3zFtf7VKpvQu/3oMvl7tB51CNwC0l8PVyg5eHs7KWsIGdt4dL/X0v939uM6hV5xcCOOlQW1Wh3B7OfqaPq7qkECVHt6P48BaUnNgLVFdhLIAezk7Y4+OO/QF+yKquwKbEnWrxcHbHqPAhGN91BAaE9IGT4+lpx2ySx3LxDJ6l8GCsh8+wGSruo+jgeuRt/EEJo9x1S5G39Rf4jjgPvqNmqequgiAI5iDiQ7ApmOa6dGUcflxb18K+d4QfHrl+JEICPNp7aKry6VPzxuD71Uex5M8YZOaVqcdTcxsWJWsMhqhQgNzj7oMQ5OCzJStRFtwP/j5uCPB2RYCvG/ydy+GdsR9I2IXyhIMqvVdD5x8KZ/9OiKysQKfEGMzILkKSuysOd++F3Q7lyCkvwJoTm9Xi4+qFMRHDlBCJ8Ohcv4/yU1YPl6DwBkGmrEPiPegseA2YhOKYzcjd+B0qMxORt/F75G/7HT7DZ8B39IXQeflb6IwKgtBREfEh2Ay5hWUqqHNfXF37+nNGR+C2SwfDWde0omGtCbNs2ANm+siuiE/JQUzscQQEd0ZltQOKSitRVFKJotKKU+tKFKvHKlBYWqliVli3jI8lO3kjxCUHhSkJWHPCC/6ORRjsnIBBLgkI1mWgXM+zlOEQiCT3PsgLGKAEQ89wf/SJ9EdAUYKyTkSc2IeIQwcx3ckZGYPGYr+/L7amH0RBeRFWxK1TS4CbL3q6dYVbnhc6px1X+3Xp1M3oMTo4OsGr/wR49huHkiPbkbvhWxUjkr/lFxTsWIbO1z0Pt7BebXXKBUGwQUR8CDbBwePZePXz7cgpKIerixNmjfDF5ef1tSrhoQ8tFa46P1QXuyM6ujM8PM5smamsqqkXJmVbcoAD8ZjZKRUzalPhWdww+DS+Kgh7KrpiX0VXZNWccnck0dISV7/NoF5BuObcO9F9fBpy136luul22r0Ooc6uuHj4uUga0g9b0g9ha/Ju5JTlI6dsP7av349g6DAwwBOT/AMR0sh4GYvi2Xc0PPqMQumxXcha8SmqctNQFn9AxIcgCI0i4kOwahj8+OOaY1j0xyHVIC6ikxfuuXwgCrNN9z6xVZx1jvD3dlNLUc9eyDgAuBYlQ1UNcXCEW0Q0PPuOgWefUejuHYjhJZXILShDTkGZsgqx9DuDcGPjc3EyNV9ZiPa9uwHD+obgmhn3Ibw6UYkQNrAr2vIz/HetwJWjzseN5zyNHWlH8NfhtThekoTMmkr8HeCJv1M2oOuyE8otM67rcHTyCjYZdOvRazg8Tx5A/tZfUF1cFwAsCIJgChEfgtVCt8TCpbuw5UCauj95aDj+PWcwaqsrEFMX8tFhce81DG5d+8FB51InOKJGqdLr+vh4uqglsvPpgZ4ZOSVY+tcRrNqRiF2HM9Qyun8orp7xCDqVxiF37VLlKsnb8B0KdvyJPsPOg0fQBET2iMS6Lx/EXm83xHp5ICE/GQn7k/HV/p/RO6AbxnUdgbFdhyPA3e+099TGx8qogiAIjSHiQ7BKjifn4+VF25GaXaxKmd9y8QCcN7abusouKen4HVyZvhp23fPNfj0DcNlEb/a03vj6r1is2ZmoysFzGT8oDFee/wQ65R9GzrqlKmi0aNN38HV2R2XaKAwpKsdwR28EXvsKtiXtwcaEHTiQcUQ1sOOyeM/36BfSG+MiRmBMxFB4u9Z1CHbyrBMkYvkQBOFMiPgQrI4VW+NVxVDGQIT4u+Ph60ciqqtkUDSHsCAv3HvVMMye2htLVxzB+r3J2LgvBZv2p2DSkHBcedFzCMnai+y1S4HcNJQeWKte5xoSqTrmTu0xXi15pfnYkrQbG+O340j2cRzMiFXLp7uWYlBotCrn3t/NXb1WxIcgCGdCxIdgNZRVVOH/ftiPldsT1H3W7bjv6mGqJobQMiI6eePB60ZgzvQofLn8MDbvT8Xa3UlYvycJZ42IwEUXPI3iXb/DJ2Erqgsy4d5zaIPX+7n74tzeU9SSWZyNTQk7sSlhB07kJWJ36kG1ODs4ISrUB8MqCxFSVQEXnXxugiAYR8SHYBWkZBbhpUXbVWlyFii99rxoXHZWb5W6KliObp19VEn4uKQ8fLHsMHbEpGPV9kSs2ZmEIT0icOOl5yPcpRzOQXVVVo0R7BmIi6JnqCWlIE25ZbikFKbjoJcbDgL49ueHMLLLYBWsOqhTNHRO8lcjCMI/yD+C0O5s2peChV/vRklZFfy8XFXb+sG9m1eaXDCPXuF+ePrmMTgcn6NEyJ7YTOyMK8behVtw7phumDM9WDXoOxNhPqGYM2AWZvc/HydzE/DHN09hr5cr8lCO9fHb1EL3zejwoRjfdTj6BUfB0VFaSgmCvSPiQ2g32A120e+H8NPaY+p+v+4BeOi6EQj0rYsdEFqfvpEBeP62cdh5KBmf/boP8RkV+G3jCRV3M3N8d2V98vNWyb6NwkDg7gGROL/UEedmZ6N0zn3YXpSMzYk7kVdWgFXHN6jFz81HWUQGh/ZD/5AoeLq0f2VaQRDaHhEfQruQnV+KVxbvQMzJutLjl07phetm0jwvV8XtQXQ3f8ydFoxq1074bvUJHI7PVaJw2eaTmDWhBy49q5dZsTdMt60pKUAPnRcGDLscNwyZjUOZsdiYsBNbknYpIfLXsfVqoWDpHdAdg0L7on9IH/QO7A6XMzS9EwShYyDiQ2hz9sZm4rUvdiC/qAIebjrcc+UwjB34T28RoX2gGBjYMxCjBoSr5nhfLD+sOgZ/9/dR/L7xhOree9GknqoxnimYbsvUXS3jhS6WAZ36qmXesCuwL/0w9qQdxL60GBUjEpt9XC3fHfwDzo46RAX1UEJkQEgUegV0k1gRQeigiPgQ2gxWKP12Vaya1NjDpEeYLx65YSQ6B0lLdmsTIcw0Gt43RNUFYUwIA4G/WnEEv64/jkum9MIFE3vA3VXXpEJjDDodFjZALSSrOAd70w6pGiJM26VVREvh/Ybpvk4u6BPUU7lnuPQMiGyDoxcEwW7Fx+bNm/Htt98iPz8fw4YNw0033QR3d3eT5bd//fVXrF27FsXFxYiKisLcuXMREBDQ5uMWTFNQXIE3v9yprqjJjNGRuPWSgXB1ts7eLEKdCBkzoDNG9QtVdUGYopuYXoTP/4zBz+uOqXiQmeO7wc3ln78RXRMKjQV5BmBazwlq4e9YZctkHMGBjFgcyohVje/2pceohbjpXBEV0B0B1T6qAV60G7OhxE0nCLaI1YmPDRs24JZbbkFNTU39/V27duGTTz4xuv2CBQvwwQcf1N9fvXo1fvvtN/zyyy/w8qqrvCi0L7EJuXh58XZk5pbCReeIOy4bjOmjusrHYiMw3XnC4C4YOzAM63cnKQtISlYxPvvtIH5aG6eqqDJDxsXZSa/KaX6ThU4Xn1C1zOg1GTW1NUjKT623hBzMjEVxRQn2ZRxW269Zvw0ezu7oF9z7lGWkD7r6hcHRQcSIINgCVic+KCYoPC655BKMHTsWzz33nBIg27Ztw6hRo07bfunSpWp9//33o2fPnnjzzTcRFxeHdevWYebMme1wBIIGr2b/2HgCH/9yAFXVtcq98ugNI9E9rGGPEsE2cHJ0wJThEZg4pAtW70zEV3/Fqh4yH/10AD+sjsMV06Mw1t3HIlVOKSK6+nVRy3lRZykxEp+XjN1JB7D95G6kVGSipLIUO1L2qYV4u3gqNw0FTJh3J4T5dFJrrfy7IAjWg1WJj4KCAuzfv1/dfvTRR+Hr64vt27crF8zGjRuNig+i0+lw9dVXK0vHmjVrlPjQLCdC+1BaXoV3v9mDdXvqWsEzoPTuK4Y2Gqwo2AZOTo6YPioSk4dFqGq03/x1BFn5ZXj/+33Y7Z+JKx2AioJci74nxUh3/wh0cg1EZEUIovpEIb08+5Rl5Ahiso6hsKK4gRjRoCihCOl8SpB09g5BZ68QhHqHSHaNILQTViU+EhLqympTdHAhERERap2YaLyF+vz58/Gf//wH5557LkJCQnDw4EH0798f06dPb8ORC/okpBWoaqVJGUXqannurP64aFIPZVoXOg7OOkfV7G/aiAgs3xKvgokTCxwBXyAnIwP/fW8DRkZ3woh+ndC1k7dFP38nRyf0CuymFlZaraqpxvGceBzLiVexI9qSXZKrRAn70XDRxwEOKu4kTImROlFSJ046IcjdX+JJBMFexAcDRomb2z+VFV1dXRs8Z8iYMWPQtWtXnDx5EpmZmeqxKVOmNNhHU10FJSUlsBSlpaUN1taMJca6YW8qPvz5EMora+Dv7Yp7rhiEvpF+Fj1+WzmntjJOS4x12vBQTBgYjG07jwBbfoeXQxkOHc/CwePZ+N/vhxDs54ahUUEY1icI0d0C4ObiZPFxhnuEqkWf8qpypBVnIa0o49Q6E+nFmUgtykBpVZnqU8NlL+qCWjV0jjp08gxCqGcwQr2C69edPIOVJeVMQspWPntbGactjdWex1lbW2v2RYZViQ8np7o/JH2XSXV1db1rxZDKykrcfPPNSE1NxX333adiPhYuXIj33nsPQUFByhXTVLjPmJiGf0SWgOLIVmjOWBnTsWxXHnYcrROJ3Tu54rLxAagtSUVMTGorjNJ2zqmtjNMSYw3yqfvtOjnU4oIhbjiUDpxIL0dmXhlWbEtSS912OgT7OsPPwxHdnTIQWXEU7g6VKOl/Htw83Cw+Th+4wQfhiHIPB9yB2sBalFSXIbcyHzlcKk6tK/ORV1GAqpoqJBemqcUQV0cXBDj7IsDFV639nX0R6FK3Zq2SloyzvbCVcdrSWO11nC4uLrYnPrT0WMZ+aAoqL68ucC0wMPC07Q8cOKCER79+/XDbbbfVCxe6YlauXNks8eHs7IxevXrBUlBV8sPt1q2byXRha6G5Y83ILcVbX+/D8eQ64XHZlO6YfVbPVmsKZyvn1FbGaemxpq/zQm1ZES6f3APOQeEoq6jGweM52B2bpZas/FJ4FKehT+VJDHU9CT/HfyyNK/70xvba/nBzdoKLsyOcdU4qQ4q3mU3j7uIIx9oy9IwIRvcu/ggP8VQWNv5X1JQWorayHE4+QS0aP4Nbs0pykVacifSiTLXWLCfZpbkor6lAanmmWgzdOIHu/spCEuwWAOcyR/SP6IPIwAj4ulrW7WQp7PU72prY8zjj4uLM3taqxAfjOzw8PJTbg+m1rPHBLBfCOA5DtB9zSkoKcnNz4e/vj9jYWPWYt7d3s8bAfXIMloYfbmvstzVoyli3H0rDm1/uQlFpJbw9nHHf1cNVgaq2wFbOqa2M01Jj1Xn5obKsCC415XD38AB3N3GYN0ZHOKAo9AgKDmxATX56/fYVDq7IdfBFp5oMDHGJx4bCviivqLN4mmLrkSIAJ+DtUIrhnskY4Z6ILtVJ6vebf9YjCIvqixB/j2YLYC9PL3QLros306e8qkIJEi2mJLUwo/42U4GzSnPUorEic6Nauzu7oYt3qIop4Vpl5Ph0Uu4ca+j4a2/f0bbAHsfp0ASB3f7fegOrw3nnnYfvv/9euVOCg4MRHx+vsljOPvtstc3jjz+uAlMfe+wxJUi6dOmC5ORkFXAaFhaGQ4cOqe207YXWobq6RlUq/XbVUXU/qqsfHr5+pPrDF+wbVjmtzEpS6baVuWkoOrQRRQc3oDKzLqCcODi7wqP3CHj1mwCPnkNRVZyLxHfvQG/nDHxw93BUOvugorL61FKD8spqtWTlFiEpLhah5YkILTyM8NoUKH2haZXaWmz+/Tcs+y5JWUrCQ7xUsGuEWrzUunOgp8rYaQ6uOpf6FGB9aKktKC9UIiS5IB3xOUmISzuOQpQgszQHpZVliMs5qRbDLB7GlihRoqUIK3EiKcJCx8aqxAd55JFHkJSUhK1bt9YLj1deeaXeJUNXy+HDh5VrhmKFBcb4Gma50EXD2JBbb70Vs2bNau9D6bDkFpbh9SU7sS8uS92fNb47brqwvzKRC4JWaCxrxaeqyVw9jjolNLz6T1DCw9Hln9gOZ98QuIb1RnnKUXhlHIDviHMbnMiq/EwUHd6BwviNGJZVJ3gVFB5B3VEQNBAFBUUIT/kbgzwysbLCUQmX48n5atFH5+SAsOA6IaKESYg3IkK90SXYs9nfYV7x+br5qCU6uDdKOpcgxjEG0dHR0Lk6I03PQpJckIaUgnQVT1JWVa6CX7nsTKkrM6DB+iRdlBhhinCdtYT3gz0DVbaPINgyVic+fHx8sHjxYpw4cUKVV+/duzc8Pf/p/fHCCy8otwx/1ITl1GkpoWCh+OjevbtUNm1FmL3w6ufbkVNQrjIW5l8+BJOGhrfmWwo2hs677kJBCQ8HR7h3G1gnOKJGwcnddMEvz+ixSnwUH96kxAetJsWHt6A4ZjPKUxv6kp0794Z3/3Hw7DtGCRdSmZeBxPf+Rhek45tnzkJmMZCQXohE/SWjSLl0EtIK1VLnFKmDFpTQQM86URLqjfCQOnFC64mbkT425sJOvaasJbll+UgpSFPWEoqR1FOWk6ySHBSWF+Ewl6xjDc+vo07FlTRw4ZyqYcKqr5akuqYW+UXlqgt1Vl6ZWmfnl6m4nexT93MKypSVydfLBWFBXugd4YdR/UOlmKBgW+JDgyLCGAMHDjR61cF4Ea0miGB5+Ef545pjWPTHIdUgjn/QrFbKtSDo4zPiPNSUl8KlUzd49h2rYkDMgdvmrFqMsoQYJH38ACrST+g96wC3rtFw7jEcifBD36GjTvNTO/uFQOcfiqrcNFQkH0ZY7xHKwsH+NBr87mbllZ4uStILUVxWpcrGc2FDPX1C/N1PuW7qFiVKOnnDqwVF8/i/FeDupxZ2/dVHWUSUtaROmCiBomJM0lFRXYmkglS1GOLv7otwn87/LL6ham2symtlVQ0yeS4yy5FblYbC0ho9YVGK7IIy5OSXKQFyJhhUzP5N7P3Dc8c+QLOnReGqGX2ga6aLS+jYWK34EKwHBpMuXLoLWw7U/SFPGRaOf88e3KKrQaHj4uzXCcHn39GM14XAtXMvZeVQwoNWk8j+SpR49BkFnZe/snrWNpIK795tEApz01B6Yi88e4847XkGoIYEeKhFPzCa4ppX8EnpRf8Ik4y6dX5Rhcro4qI1RtQI8HGrjyWhIOkU4AlPdx0cUY3C0mplZXF3N7/2gQab6LGiKxfDTBwWTlOCpPAf9w3XtKLkltYt+9PreuBouDp4wB1+cKrwQVWxB0ry3VCQ7QpUMS2SY2uYudPgnDkAft5uCPJzQ6CvOwJ93RDEtZ87gnzd1DmoqKpBfmE5TqQWYO/RTOyIScc3K2Ox+0gGHr9xlHqdIOgjs4fQKMeS8lRTuLTsEnUFc+vFA3Du2G5WmTYo2D6B58xDwa7lcAuPhmfUSBW82hTcewxC4e4VKD1RV2K9tqoSpfEHUJ4SB6+Bk5QwMga/z3UTqzsGRwU3eI5uB1brNbSW0EpAwcJl79G6+KfT+DFVVfllWwFPN2d4uOvq1m66fx5zc1aCpW7Nx/65ze3Y+ZkXAEUllSgqrVDrwhJPlJVGwLkkFEGl/eBaUoHAkmJkl2ciryobFU75cHQvhoN7ERxdS1FeW4JylADOKQANUX6AeyTPjzMcy73g6RAAf5cgdPLshK6+nREeEIwgJS7cVSqzWQG6naHO3cWTe2LD3mS89+1eHE3MwwML1+Gpm8eIG0ZogIgPwSi8EvxrWwI++GGfMs/S7PzIDSPRO8JfzpjQarh1iVJLc3GPHKCu5Jltk/bdq0qE1FbUVXAsTz2G0MsfafI+fb1c1dK/R8NaQ8Wllco6kpReiIT0IiVI6NIpKatUz9GNQ+i2oEuCS+tDSwbdTJ1VTBYFhL+vDu6+ZXDyKEa1cwFKkIfcykzkluUCukrU6nJRBC7HkFgO7MgA3HPd0CsgEmMjRmCM+1B4Of0Td2cO7ILcK9wPz368RQm3h99dr7LhhvdtmzR8wfoR8SGcBk3FH/6yG6u21/XToXn6vquHwdvDvMp1gtBeOLl7w7VzDyU0So5sVY85evio4NfSk/uUJcRBZ5nmhrRM9I0MUIshdA8dPHQI3XtEodbBuU6QlFWipKzqlDCpEyjqPh8vPbXWEy68zecJrY5eHs6qlo6Xu4u6zXgTLw8XeNNaop5zga+nKwL96twitJo0ZqGsqKrAscx47DiyC/DRIb0kS8WRsAQ9U4P3px9Ryye7lmJIaD+M7zoSI7sMVunG5sDg3dfmT1R9npgZ99wnW3H7pYNUPyBBEPEhNCCroBKffrhNXcnR13vtedG47KzerVatVBAsjf+kK5C39Ve4hfVWGTYUIwlv36rqjpQlxsC9+6A2OemOLFhIF4oH4x2aF/PAANnK6hpV5dXSrk4XnQsifbugxLsA0X2j6wN4K6srVbDr7tSD2JCwHfF5SSoNmIu7zg2jw4diUrfR6BfSW9UpaQyKo2duGYt3v92Dv3ck4v3v9iItqxg3nN9P/lPsHBEfQj1bDqTjw2UZqKiqhZ+XKx68bjgG9Wro/xYEa8ej13C16OPecwiK9q1ByfHdbSY+LAFFv2sb1/Rw1ksNZsfgpPxUJUI2xG9DRnE21pzcrJZAD39MjByFSZGjEe7b2fT+dI6458qh6BzkiS+WHcYPa+KQllOsqiEznkWwT0R8CKiqrsH/fjuEn9fV1RNgF9pHbpAIdaHj4NFjaJ34OLYHgdNuOO15umPg6AgHKd51GhQWVw68EFcMuABHso5h3cmt2Jy4U2Xd/BSzXC2dvULQPyQKUUE90NW3i3oN65to0Gpz5dl9EBrggYVf78GmfanIztuIJ24aDT/vus7lgn0h4sPOYYDcq5/vQMzJun4U46K9cOcVw+HtLalxQsfBvftglbrLEu9VBdnQ+QSipqIMJcd2ozhmE0ridqmKqxF3vAtHV/cOETBelZeO2poauASGWWSfFBB9g3upZe6wy7ErZb8SIrtTD9RXaV15fIPalu6Yzt4hyq2jrCi+XRDp1wWTh4WrINgX/7cNRxJy8cDb6/DC7eNUfIhgX4j4sGOYg//6FztVFD7T++64pD+8HLKb3fdCEKwVJw9vuIb1QnlyLHLXf4OasmKUHNuluuBqVFeWoTz9BNy79oMtUlWQpbJ7Sk/uR2n8QVQXZivBFX7rW3AJsmwVYlo1xkQMU0tJRSkOZR7FoYxYnMhLREJeMgorilUZeS6bEnfWv44VWLv6hmH0OSHYtacMmZku+HLlAdx3xWiLjk+wfkR82CEMYvt6ZSy+WnGYfbjQI8xXpdH6ejggJia7vYcnCK3meqH4KNyzsv4xnV8IPKPHqUm7Iu24qo4KGxEf1aWFqoZJ2Yn9SnBU5qScvlFtDUpPHrC4+NDHw8UdI7oMUot+2fiEvBQk5CchPi9ZCZKkwjSUVJaeKhd/DAgGXIOBLdiKO3/7FV39wpWlpH9Ib/QLjoKjo1wEdWREfNgZLJj05pe7sOtIXaXGGaMjceslA1XgF9MDBaGj4jVgIvJ3/A5HV0/VR8YrehxcQnsod0Lmn/+nxAf7yVgrNZXlKEs4VGfZOLkfFWksP69X+tzBEa6de6peOlxK4nYif9tvBmXqWx/9svFDOv8j5Kqqq1RjPYqR+PxkHE4/iSPp8XBwKVeBrFx2JO/F94cAfzdfTOw2Guf2nowgj9NTmQXbR8SHHXEkPgcvL96h4jyYunfHZYMxfVTX9h6WILQJzgGd0e2+RerK3DBt1dk/VK2tSXzUVlepUvOlpywbZUlHgJq6uh8azkHhqqQ8M3joLnJ0+yd2orqsCGgH8WEKnZOuPotmouoHU4U5j/4O6Crw5L/6Ias8HcdzE1RKLy0nvxxegd+OrMTYiGGY1Wc6OrtJ5l1HQsSHHcA/2982nMCnvx5AVXWtSnljU7juYU0rXS0IHQFj9TI08VGVm472/J1WZiWi5PhelNG6kXAQtRVlDbZx8gk6JTYGwj1yIHTepisOu3aqa85ZkZGghIyDk+X/7murK1GRlayEnaNz07JW3Fx0Kvg0Kw/wrumMUVH96y0ku1IP4M+jq3EwIxYbE3aoJSqgB/q79ECf2j4WPw6h7RHx0cFhlcR3v92L9XuS1f1xgzrjrsuHquqMgiC0r+WD3X9ZeZVZN1yqCxr2iHF091IiQ7lSug+Ezr+z2cXGdP6d4ODirsrLV2YnwyUk0kLWmGN1sSbxB1GWdFgF7Xr0Htms0vXhQe5wL0xE0fZfkbY9FeUpR+HZfwJGnX0jRoUPwYncRPx+ZBU2JmxHbM5xxOI4Nq3eg/P7TMOU7mNVAz7BNhHx0cHjO576cDOOJ+er5lY3XtAfF06s83ELgvAPulMN52rKilQgJ8u0t551I+mU2NiFsoSYBq4UBydnuEX2q7NudBsEl1A2cWxe4CVf59qpm6rqWp52olnio7amWr22LP6AClwtS4o5zRpDSo5uV837mFFkjngpSziI0vhDuC7vIHS+FcBRsO2domDnMgRMuVpZUtjV984xc3H1oIvxa8xfKpU3vTgLn+76Gl8f+BVn95yIc3tNQYAHu+UJtoSIjw5Kdn4pnvy/TUhML1LVSh+dOxL9ujdsjCUIQh2s8eHk5Y/qolxU5qZbVHzUVNC6cUCJjdK4XSol1lD4ePQaBo+eQ+EWOaDJ7ovGcAntXic+0k/AG1PME0c5qadSdvcp909Neclp1hi3rv1VEz8ueZt/RNGBdcjd9ANCZz/UYNuaqgplzSiLP4SyxEMqbkU/vZkTUEmNM/I8umLAuHHI3/qrKoPPrCRaezQoLuZEn4+omghkehTgr5MbkF6UqQqc/Xr4L8zoNRmXD5gFT5e6EvGC9SPiowOSnlOCJz7YiLTsEgT5uuH528chPKR1ruQEoSO5Xig+VLrtGa7gz1jgKzsZrie2Iufgz6hIOQJUG1o3+iux4d5zmIqXaC1rZH3ch8qMMY5DeTFKD29GccphJToMxZGjq0ed2Og2QIkjl5CuDawxfuMuVeKDjfxo/aBYYbwKrToUEYwLabA/d2+4de2nAmSPV4fi6e8SEenuhwljz0JF+kkUHVyv6pToiw8NF0dnTO8+AbOip2NHyj78HrsKMZlxKj5kU8IOXDP4EtV35kw9Z4T2R8RHB4NtvWnxyM4vQ2igB164fTw6BcjVgCCcCR3jPhJjmhX3wSt8WglKju5UFo6q/EzwV1eh7dsvBB49ad0YBrdulrVuNIaLJj7ST9Rn+bCyK60hFBrFx3bDLysR+fovctLBLbxvXQZNt0GqMV9jZeddgiPg0We0Eh/Jnz182vNOnn5KbCgB07UfnIPD68VLaFYxapGMlMwiVX+Ioozig26ZxmANEMaEcNmXFqPcMEzjfX/bYqw6tgE3Db9SuWwE60XERwfiREq+Eh75RRWI6OSN528bi0Bf2y8VLQjWGHRaXVas3CjFsVtVDEeDWAgnHSr9IhAwYBx8o0fDOSCsXWKtXILDAUedskbk/L0Y5SnHjKbs6oIj4dlzsCpD7xYR3WRx5D9hthJe3K+TdyDcI/vXC47GLDsh/u7QOTmgoqpGlQDwj6zLeClLjlV1TcwZRz+PEDwdPhnL4rfgj7JUHMk+jkf+eknFg7AnjZeLlG63RkR8dBAOx+fgmY+2oLi0Ej3DffHsLWPh6yWR4IJgLs7+dUGnyu1iAvaFYXBlcew2FceBmur655y8A+DZeyTcew1DbUgPHIk7gYjoaLicalXfHtDFQ8sELR/5W36pf1zHlN3ug+HYpS/iy3ToO3gEPFowTtfQHoi4fSGjXKHzDTFbaLGVA1P/GZuWnFmE4KjOcPIKQHVRzmlxHwq6tPIzUHj0OEoTDqmia+xhQ1igfVCXnvgrapAq6b4ibh02J+7CdYMvFVeMFSLiowOwPy4Lz32yBWUV1YjuFoCnbx4jqbSC0ESYxmrM8lHB7JTYbSg+sk0FTxoW+fKMGqXcDso9ccqdYE3Vgn1GnIu8jd8rF4xHd1o3BikXEwUCx1kbE2NRy1FTCQvyUuKDrpehfUJUbAljSJjOyxgTBsDSDVN0fB98Tx5AVllBwx04OKpMHgos95QTmH/FU5jec6JyxSQVpCpXzN/HN+Lm4VepAmeCdSDiw8bZEZOOl/63TZktB/cOwhM3joabq3ysgtBcyweDTjnxqXTY2G2ozG7YM8W1SxQ8+4yGR9RIuARa/2TmM2S6WqyVLsFeap2cVazWdNVQfBTsWoHC3StV9ouGknaOTqqMfF3Qan+4RfRVQbGJH8xXnxXrjwzoOxqvnvM4/ohdhW8P/qH6yTy04kWc1/sslRXj7uzWXocrnEJmKRtm494UvP7FDlW1dHT/UDx03Qi4OJsODBMEwTRMr3V081K1PlKXPP3PE446dTWuBEfvkY1WFRWaTpeQOvGxfncyxg3sjD7dBqj7NSUF/wTAdomCU+feSKv2QM8xU+Hle3q/FwbHUnwwRdiz72joHJ1wYd8ZGNd1BBbt/g5bk3ar7JhNiTtww5A5qmy71DxqP0R82Cirtifg7a93o6YWmDSkC+69ehh0TpJeJggtgVaN0mO7VGVQ1t5QLpWeQxv0TBEsy/hBYfhp7TGVqff4B5tw7bl9cc6s+aguzFLBr65desNR56JcREkxMXA0YbWg+GCBMooPfdiY7v7xt2JP6kF8sutrVR9kweaPsep4X8wbfiXCvOssXkLbIuLDBvl9w3F88OP++q60/5o9WFUwFQShZYRcdLcqRc4ASgedtCBoC9jq4c27J+H97/di9c4kLP4jBoeiO+Heqy6Eu6eL2fthmi7jP2j9YGCwzqdhUcUhnfvjjXOfxM8xy1Vxsv3ph/HAshdwYd/puCT6PLjqzH8voeXIpbKN8d3fR+uFx4WTeuDOOSI8BMFSOLF6Z3gfER5tDOPU7r1qGO6cM0R13GYs291vrsHhkzlN+uwoGomh9UPDxckZcwbMwhvnPYWhnfujqqYKPxxahvuWPYcdycZfI7QOIj5sBBYI+vzPGCz6/ZC6f8XZUbj5wgHisxQEoUPA+ItzxkTi9bsnISzIU9X9eOS9DfhpbZz6/zMHZvKQkridjb4m1CsYj0z8Nx4YfxsCPfyRWZyNVzf8F6+u/y8yirMtdkyCaUR82ACs/PfRzwfwzcpYdX/u+f1w7bnRIjwEQehwdA/zxVv3TsbEIV1QXVOLT345iP98tg1FpQ3LtBvDvccQtS6O2YzUL55BefrJRsUOK6S+dd7TuKjvDDg5OKqS7ff9+Sx+OPQnKg3KwguWRcSHDfDL+mP4df1xdfv2Swfhsqm923tIgiAIrYaHmzMevHa4+r9jIP3Wg2l45P0tSM7WCtYbh+m3/lOugYPORXXiTf7kQWT9+SGqSwpNv0bnqnrCvHbOE+gfEoWK6kos3f8LHlj+girdLrQOIj5sgC0H6ooeXT8zGuePr+vVIAiC0JGhZYL/d6/Nn6j6U2XmleHTvzKwbEuCSZcKX+M//lKE374QntFjgdoaFOxajsT/3on87X+gVq/BnyHhvp3x1JR7MH/0jfB180FqYQZeWPs2Fmz+BDml/9QaESyDiA8rp7q6BnFJdV/8MQPqKjAKgiDYC70i/LDgvikYGR2C6hrgs9+P4JXPd6hWEqZw9g1Bp0sfQOdrn4NLSDdVuyV7xSdI+vh+lJzYa/J1FC8Tu43CgvOexrm9p6j77JZ77x/P4vcjq1CtV05f6MDio7KycZ9bdXU1iouLjS5lZXpNnmyY+LRClFdUw9NNV18JUBAEwZ7wcnfG/VcNwjnDfFVZARZYvHfBWhxPbtCP9zTY4K7LvFcRdN5tcHT3RmVWEtK+fA5p377caANBTxcP3DTsCrx89qPoHdANpVVlWLTnOzyy4iUczjzWCkdof1id+KipqcErr7yCYcOGYcCAAZgzZw4OHz5sdNsdO3ao7Ywt119/PToCRxJy1bp3hD8cpZaHIAh2Cq0QY/t645mbRyDY3x2pWcV44O11WLb5ZKOZLQ6OTvAZNgMRd7wLn5Hnq1ogJbHbkfh/dyNn9RLUVpm+yO3uH4Hnpz+IW0dco7rjxucn46m/X1f9YgrKTMeRCDYoPj755BN8+umnynrBL9u+fftw++23o7S09LRtnZycVCdG/UWnq6ub1lHK5sbG14mPqEgp6SwIghAV4YeFdMP064TKqhq8991evPPNHlTRJ3OGOiBBM25C+C1vwr3HYKC6CnmbflQxIY3h6OCI6T0nYMHMZzC1+zj12JoTm3H3n89g5bH1qKlt/H0FGxEfS5YsUeuXXnoJW7ZsQWRkJFJTU/H333+ftu2IESOwe/fu+mX9+vUICalr53zzzTejI1k++nQV8SEIgkC8PVxUE02WHaBB+K9tCXj24y2NxoFouARHIPTKJ+Ez7Bx1vzI33ayT6uPqhdtHXYcXpj2ISL9wFFeU4MMdX+KJla+p4FTBhsUHRUZaWpqyaFxwwQXw8/PDtGnT1HN79uw54+vffPNNpKSk4Nprr8XZZ58NW6ekrBJJGXWmvSgRH4IgCPXQDc2yA4/fNBquLk7YE5upipJl5p5uJTeEF6jOwRHqdnWR+VVU1X9xUA+8fPYjmDt0Dtx1bojLOYnHV76KmMyj8unYam+X9PQ6BUrR4exc11chMDCwwXOmSExMxFdffYWgoCDce++9zR4DfYdsYGQpNHeRMbfRmdh/LBt0ZQb7ucHFqdqi47L0WNsSGaecU/mO2tdvqbGxDujmg2duGoFXluzGydQC3L9wDR6+dii6h/k0ur9ql7pmgRX5Wc36b50SPgaDg6Lxzvb/4XheAp5fsxA3Db4CQwP7GR2nPXz2tbW1Zoc8WJX40DJUtLgN/dvl5eWNvnbRokUqWHXu3Lnw9PRsUYZNTIzlC8ucPGm60p4pNh2oaykd4uPQKmOy5FjbAxmnnFNrR76jbXdO504LwBdrspCZX4EnP9qGOeMDENXF3eR+nPLyQHlSlpvRov/XiwOm4rfKNYgtPokPd3+JCQHDMc5/iN1+9i4uLrYnPlxdXU9Lsa2oqGjwnDG4zQ8//KCEyuzZs1s0BlpcevXqBUtBVckPt1u3bnB3N/1DMMZvu+pcTcP7RyA6OhKtTUvG2pbIOOWcynfUvn5L5o518IBKvPHVPhw4noOl63Nw06y+OHtkuNFtqws7IXPLIjhVFKNv3z5wcGh+FMKAfv3xTczvWHZsDTbk7EReZQFuG3kNvD29YU+ffVxcnNnbWpX4CA0NVev8/HwlKKigMjLqAnm6dOli8nW7du1S2THjx4+Hv3/LAjNpMmLWjKXhh9vU/eYU1gmv7l0CWmVMlhxreyDjlHNq7ch3tG3PKR9+7rbxeO+7PVi1PREf/xKD3MJKXD+z32mlCmpdXZAJB6CmGm6ohpNHy+oo3TTiCoT7dcanu77GgcKjeG/v53ho0h0qRddevqMOTcgytaqA086dOysBwuJhixcvxrFjx7By5Ur13PDhw+tdMxQa3EZj8+bN9dkvHYm8wjpXk5+XaauPIAiC8A/OOkfcfcVQXHNuX3X/+9VxeHXJDlRUNqxO6uCkg5Onr7pdVdi0oFNTzOg1CfeMmgcXB2cczj6GJ1e+jvSiTPl4rF18kBtvvFGtX3vtNcycOVNlwPTs2ROTJ09Wj19xxRWqiBgLjGkkJCSodXR0NDpSJ9u8olPiw1vEhyAIQlOuwK88uw/uu3oYdE51FVGf+GAT8k/9p2o4eQeodbWFxAcZFNIX14TPQoCbL5IL01QmTGxWXWNQwYrFBwNGH3nkEeWHYtbL1KlT8dFHH9Vnv2gmIqbjahQUFKjHWOOjo1BYUqEECPEVy4cgCEKTOWt4BJ67dRw83Z0RczIHD76zHimZRfXP67zq3PRVTUy3PRMhroF4cuLd6O4XgYLyIjy7ZgG2JO6y6HvYOlYV86Fv/dAsIIYsXbrUaFXUjobmcvH2cFZmREEQBKHpDOwVpDrjPvPxllMl2dfjyZtGI7p7gJ7lo66YoyXxd/PFs1Pvw4Itn2JXyn68uekjXDPoElzY9+wOU4G7JbR4VmN6a2xsLDZs2IBff/0Vy5YtUwGghYVS994i8R7ebi39iARBEOyaiE7eeP2uiapDLq3Kj3+wERv2JkN3SnxUFWa3yvu6ObvhofG3qw655It9P+KjHV+iSrrjNt/ysXHjRnzzzTcq2JPZKYbQLcLGcBdeeCEuvfRSm8iesCZyC+tqnvhLvIcgCEKL8fd2w0t3jMfrX+zE1oNpeGXxDtw/sgpdVZVTy1s+NBwdHVWH3FCvYCza/R1WHt+AzJJs3Dv2Fni4WHd6s1WJj7Vr12LhwoU4ePCgMh2Fh4dj5MiRCA4OhpeXl8pEyc7OxokTJ1RTuL179+Ldd9/FvHnzVNlza88ltxYk2FQQBMGyuLnq8OjcUfj4p/34beMJ/LknF7d5A+X52aitqUbhnlVwixwAl8Awi5/6mVFTEeIZiIWbP8XetBg8+ffreHTivxHkWWd9sTfMFh8M6nzxxRfx448/KovGs88+q4JBGwvypEVk06ZN+Pbbb/HGG2/gu+++w6uvvorBgwdbavx24HaRTBdBEARL4eTogFsvGYhOgZ5Y8UedxSM/Iw0rvvgKvRN+hKObJ0KveBxu4X0sftJHdBms4kBeXv8+EvNT8NjKV3DvuJsRHdwb9obZMR+33norjhw5gv/973/4/vvvceWVV54xu8TX1xfnnXcePv30U6xYsUKJlmuuuUb1YREaJ1dqfAiCILQKtNpfPLknHri1rnGpl0MZao5tUbdryooRv+hp/PL1b9i8PxVZeaWqZ4ml6BEQiRenP4yuvl2QV1aAZ1cvwA+H/lTxk/aE2ZaPO+64AxMnTlT+q+bQtWtXZf247rrr4OYmQZTmWj7opxQEQRAsT/ceXXDC0UlVOe3jnKoei68KRKQuG32OLsJnu0/iYGWEskD3CvdD7wg/FbTK2wE+zf9vDvIMwAvTHsDHO5diXfxWLN3/Cw5mxGL+6Lnwc68rfNbRMVt8aEW+WsqQIUMssh97CTgVt4sgCELrwH4uzHipyq+rQqoL6Izw855C4fL34J11ADd7r8GS4gnYWdgdO2LS1aJB8UEx0rurHyYPDUdooGeTM2HuHDMXAzr1wSc7l2J/+mE8uOJFJUAGhXacgpmmMNuMMX/+fFXsi8GkQltaPiTmQxAEobVw8von4NOzz2j07haCQbc8Ba8Bk+CIWlzvuQFvnFeL2y8ZiGkjIxAZ6g22ickpKFNZM0v+PIxbX1qJpz/ajK0HUuuLQ5rLlO5j8dKMRxDhG4b8sgK8sPZtLNn7A6qqq9CRMdvywewVxm0w0+Wss87CnDlzMGHChGa7YQTTVNfUIr+4rqmcWD4EQRBaD1o+yvXEB3FwdELwhfPh4OKGwl0roNv6OcZPvwHnX3mher6svArHU/KRePgwag6txMrMTth1GNh1OAOBvm4YHOmCzuHlZpeYCPfpjJemP4zFe77HimPr8Mvhv3AwPRZ3jb0Jnb1Nx1b+fmQV/j6xCXeNuRGRfsa791orZiuHBQsWqHRZdo2lCLnlllswbdo0lUbL/iuC5SgsltLqgiAIbYGTt3+9BcQ1rFcDl0zQubfCd+zF6n7OykXIXfeNCj5lym50twD0T/4Rfcr24d/ef+HprhtxtncsQkvicPBAAu5+fTVeWbwd++OyzApYddG54OYRV+GB8bepTrjHcuPx0IoXsebEZqOvr6yuxHeH/lBZM29u/AgllaXokJaPXr164aGHHsIDDzygCoz99NNPWLVqFd555x289957ygpy+eWXK6uITmeVVdttrsaHj6cLdE5iWRIEQWgtXEN7qrXXwElKcBhmxQScdS0cXT2Qu+ZL5K7/GjUVJQiYdgNKYrehIv0EHJycUVtbg4CiY5jlfAxw1vsvj3dH6nFvnHDxR0jXSPTqFwWvkDA4+4fC0cPHaJn1UeFD0DMgEu9s+QyHMo/i/W2LsTftEG4ZfjXcnV1RmZmI0viD2FOWheKKEvWa1KIMfLBtiUrbtZXS7U1WCXSzMOuFS1FRkSqn/vPPP2P9+vVYt24dgoKCcMkll2D27NmqOZzQdHILJNhUEAShLaDocA4Mg2vnOhFiCCdz//GXwdHFDdkrPkX+1l9RU16K8tRj6nnf0RfAe8g0VaCsMicF5TmpqMxJg0NVOfwcS9WC2gwg/ggK4legQNuvsxtcQ7sjeNa/4BzQsKhZoIc/nppyD36MWYZvD/6GjQk7cDhhD67MLEbEqYria0N9AC83DA7thwMZR7AlaRf+PLpaFTOzBVpkomBFU4oMLklJSUqE/PLLLyowlcuoUaNUbAhrfWhdaQXzLR8SbCoIgtC60Nrh1iXqjNv5jjwfji7uyPz9vyjcs7LutS7u8B19IZw8vBFw1jXqsZKSEsQcOoQ+3SOgKytAcWYKjh6MRXpCPNzKcxDkWAhfxxI4VpahLDEGqUv/gy5zX1b7oHulMqvOslEWfwDDEw4hoKYESzv5ItsZ+G+QC87W+WB0cSViPOuSEa4dfIlK0/3f7m/x+d4f0Duwu1qsHYv5R1hm/d///rdaWFadFpE//vgDDz74IPr27YuoqDN/uEIduQWnqpt6SY0PQRAEa8F78FQVhJrx0wJVG8R35EwlGk7DwQGO7t5wC+wEty69EThkshIWB49n489NJ7F1fyICkY+bvf5GYG4a0pa+AJ1vMEoTDqKmRLON1NHN2RUPO4Xhe3cHbC9Nw3J/N2z190I1qhDm7KUCTVmw7HDWMWxJ3KW657464zF4u3rBmrF4cEZeXp6qhBoXF1eflisZMc20fPhImq0gCII14RU9Djovf2WdoMvFXOi+GdAzSC25hQPw9V+x+HCLA+71+RNIjUN5alzdds6ucAvvC7fI/nCP7K/cQYwreaC2FmtPbsEnu75GXlXdHDFK51e/79tHXov43CQV//Hu1v/h4Yn/gqNBDEuHEx9lZWX4+++/lctlw4YNqKyshLe3t+pmS7cLg1UF88nTCox5ifgQBEGwNtwiotXSXPy93XDzRQOwJzYTH+ROwzURiYgaMgjukQPgGlYnNgyhwGBNkKigHnh31ULkFGVhBAuOnMLD2R33jb8Fj618FbtTD+KnmOW4tN956HDio7q6WjWN+/XXX/HXX38pPxdhh1vGgJx77rlSRr2lfV2kwJggCEKHROfkqATIsx8X4eWETpg7qD+iawPQA06NTsxh3p3wePRFSPvuVbiFNeyISxfMvGFX4oPtn+PrA78iKrCHqqDaIcQH4zlo4WA8h+ZWCQ4OVg3jJMPFMkhfF0EQhI7P8L4hGNY3RBUn+/jnA+oxF2cnVbaddUS49In0h6+BFVznEwTaPKoKsk7b59Qe43A4Mw5rTm7Gwi2fqvgPfyvsF2O2+GA32y+++AIJCQnqvpOTk6rpQcExZcoUqe3RCuJDLB+CIAgdFwcHBzx83Qj8vvEEDp3IweGTOSgqrVSBqVw0ugR7ou8pMdI3MgBhXoHq8eqiPNRWV57mppk3/Eocz01AQn4yFmz+BE9NuRtObKBni+Lju+++U8IjMjISl112marlERJiuuyr0PzS6gXFkmorCIJgD3i4OWPOtLpsUPaFSc4sUiIk5mQODsfnIDG9CMmZxWpZtT1Rbefp5oTnPZzgxJyXwlw4+zWci111Lrhv3M145K+XEZN5VLlgrh5UV6nV5sTHOeecgyeffFLV7rCVCmq2CIUH+xLxFLPCqSAIgmAfODo6IKKTt1rOHh2pHissqcCR+Nx6QRKbkIvismrkuHog2KlQuV4MxQcJ8wnF7SOvw4LNH6vg0z5BPTE8bCBsTnywq61GZmam6ufCPi8RERGtNTa7drn4errCSUqrC4Ig2DXeHi4YEd1JLaS6ugavLdmJvBN14qO6wHSn+XFdh+NwVhyWHV2j0m9fmfEYQjzrXDbtTZOSgI8dO4brrrtO9XFhCu306dMxc+ZM1etFsAyS6SIIgiCYghel/XsEIrfGU903FnSqz/WDL0OvgG6qD8xbmz5SDelsSnzk5ubi+uuvx7Zt21RwKWM/XF1dlSC59dZbsWPHjtYdqZ0gNT4EQRCExojq6oe8U+Kj8gziQ+ekUw3nPF08cCwnHp/v+QE2JT6++eYbZGVlqWZxy5cvx4oVK7B161YVC1JVVaW62woWzHSR6qaCIAiCEbqH+SK/tk58lGRn4EwEewZi/ui56vayuDXYlND+xgKzxceuXbvqYz/Yx4W4u7vj6aefVgGoO3fuREVFReuN1N7cLlLdVBAEQTACa4G4+Qep26U5ZxYfZFjYQFwcfY66/cH2JaoMu02IDwaZku7dG3bLCwwMRGhoqCqpTsuI0DKkwJggCIJwJvw7d6m7UZzT6HZsaFeRnYyCncsx5WgcepTXoKyqHO9u+QiVNVWw+mwXigvi7Hx6zXkvr7rueVqJdeH03jelpaVGU5RZrM3F5Z+U2szsAlRXlsPduVa9Rh826GOcjYbh841tyzHwS2gMjsvNza3BtqbSqQ23LS8vR01Njclx0DrWnG1pRWMJf2MYHndj2xKOVzseS27L86s1TeTvg+5Hw3Fqnz3329i2TdmvqW25nfY7NQa/Z/y+GdtWf6w8fv1teQ4as2ryP4FxYE3dlt8FfidMwe20/xttW8NxNrZtU/ZrCv3fJ38/fO+mbGvu776x33JTtm3qf4Q+Tf2PMHdbS/1HNPV3b+7/iaX/I9rqdx/erStwEnCoKEJxQR4cnes+d34uVXnpKI0/hDJ2yU05gtqSPPVcVXUNLnZwwPvhfkioyMDvhT9hUP+B1i0+TH3R9GnsC2bP3HLLLQ2+hPqMHz8eCxcurL+/+K27UFJaipN/e8HDreHHM2zYMHz44Yf19y+44ALVRdgY/fr1w+LFi+vvMzuJ6dHG6NGjh4rp0R9vfHy80W07d+6s+vnob3vo0CGj2/r5+WHlypX19+my09x3hvD8sCmhxoMPPmgyi4rfs48++qj+PuvPrFq1CqZYv359/R/Riy++iN9++83ktuxTxBRy8tZbb+Hbb781uS3bDISFhanb77//Pj7//PPTxsk/IR4bi/TxPJPPPvuswedoCD83fn7kq6++wttvv21y2//7v//D8OHD1e0ffvgBr776qsltFyxYoDLVyJ9//olnn33W6Fj5PX355ZdVNhtZvXo1HnnkEZP7peuV30WyefNm3HPPPSa3feihh3D55Zer27t378Ztt91mctu77rpLBbmTw4cPq9uG49Rg0DsXcvLkyfr3MAYz9u6++251Oy0tDRdeeKHJbfm7efjhh9Vt/tbOPvtsk9vOmjULzzzzjLrNMTb2u582bRpeeeWV+vsTJ040uV/D/wiOwZQIaup/xAcffNCs/wh+FsePH2/T/wgKMP3Ywsb+I4h+EkRb/kfof0e5n8b+I/Th+W3Kf0TPHl1QslqH3/cdw5fjx6O2ugo1FSWoKS8D9CwaL1w0FNFdgpBU2wlf7EnHb5u2wk1XhkKXGji9NBvH449iQPRg2GRXW8FyUJkSJycp5CYIgiAYJ7yTD7afCjqtzElp8FwtHFBRq0N5rQ5fF49Bac4IVMEJKRUbUIHdqKl1hXt1CQYV+qJrl4ahFG2FQ605Jo1Tqv7o0aNK0UZFRZn9nC2xf/9+tR440HJmKLqieIXXt29feHh4NGpSZfGYC+/7DvxEPn7ibNV2uS3dLhxrTEyMiuvRN1ka27Y93S4cJ69uo6Oj1Tm1VrcLx8krdn72vFKyZreL/lh5Tq3V7WI4zsa2bcp+Le12KS4uxp49e8z63ben24WfF3/z/C3xvjW7XZr6u28vt0tb/u7/euNJdC0+gIpqILEqEMeqQpDi1AUlvpHw9/NGkJ8HwkJ80SnAC8H+7vD3coaHq6OqpGp4Ptt6Dm2y5ePRRx89baBJSUkmn9PMWPZcCZVfVv4QTE3oGvnFFXDUucLRAegU5Acn3miEM+3PcAxNHa856P/RWXJb/T9bQwz/9Brbtin7bcm2nMwM46E4Tu1c6pvejW3blP02NqlqE3tTt9Ufq+Fnz8nP3O9DU7blOWnqto2NsyX7NQdOOE3Z1tzffVN/y5bcVj9Or6n/EeZiqf8Ia/zdG9u2LX/3w2+4H4f37od7aCQGBftjqp873FzM+w8w0+7QajRZfBw4cKDJzzWmvo1BxUe/X0FBgVJQnTrVlZVtDCq4uLg4lXkzYMAA2CK5BXVXVT5ermcUHoIgCIJ9ExDkh3HTTMcLWTNmiw8GsjU3m6UpVo+cnBzccMMNiI2NVfep/hjQxmAoU0Llqaeewvfff1//2FlnnYV3333X7KtAayGvSLrZCoIgCB0fs2dnLfq+tXnttdeU8AgKCkLXrl2VBeS5557DpEmTjFpAGBFM4UEz14gRI1R8BaPzGYF81VVXwSarm0qBMUEQBKED06TGcvoFx/bt24fExESLDoZWjGXLlqnbTKVkmuHYsWNVUA/LuRvjyy+/VOs33ngDn3zyiUodo+jQUqFsCWkqJwiCINgDTfJLsIkc89jZXE6jZ8+eePzxx1UuekthbQm6dhh0pFlahg4dqmoHMHrYkJSUFCWE6Jqh1YM5376+vvUl320NqW4qCIIg2AO6pna1ZQl1xlJ06dJFFejRutouWrRICYCWwPcgPj4+9Y95e3s3eM5YyXeKj9mzZ9dbYlhIicVompM+xAhgS1Zq1YJtzQm6zcotVmsPt7o0qLamKWNtT2Scck7lO2pfvyVbGqs9j7O2ttbsC39dc7ra0r3B5nIcNKv/scstJ3sKkJag5UvrD15LVTKW+63VKeBEzZQnBppu375dVcpkNbkHHnigyWPgPpn3bmmYjXMmUjLqBFZJfjZiYtrvi2vOWK0BGaecU2tHvqNyTu3tO+piZqqyzhJdbRmPoXW1bUqOtCGennXV2vSL/rBYj37/GH30H2M5WrpqNm3ahBtvvBFr165tlvigFaVXr16wFBRo/HAp2s6Uc1+5kuKjHNF9uiG6ZyDamqaMtT2Rcco5le+off2WbGms9jzOuLg4s7fVWaqrLXsC0DKi1bFvSUpufn6+SrkNCAioV2U8QYbwMbqAGKiqCRH2FSCNVVlsDFpdLFXtTR9+uGfab35RnSWnc5Bvq4zBkmO1BmScck6tHfmOyjm1p++oQxNiLa2qqy2DRVlUjCVaH3vsMYwcObI+y2Xy5Mn1DYBYfGzMmDFK+LAhE1Nr2bDqsssuUw2zyKBBg2BrPV0KS+oEk5+3+RUBBUEQBMHWsLqutuxUOG/ePCUouGi9Y7Ra8a+//rrKfGFXP4oPdtvcu3evqu/BhbBGyL333gtbIv9UgTHW3Pf2aL7rShAEQRCsHasrATp69GjVGpyFw+h+YYvoSy+9tP55WjrYdpjCQ3O9sLX50qVLVeot3UKshmprdT7qa3x4uSgBIgiCIAgdFasTH4SdcdmkzhjGgkiDg4NVIKwt8091U/MbNgmCIAiCLSJdba2EvMK6pnJ+PhLvIQiCIHRsrLKrrT3yj9tFxIcgCILQsbG6rrb2yj+l1UV8CIIgCB0bq+tqa6/Ux3x4S8yHIAiC0LExu6stM0ksATNYioqKLLKvjoR0tBUEQRDsBbPFxx133IGnnnoK2dnZzXojFiljbY4ZM2aoaqhCQ/KK6gJOxe0iCIIgdHTMFh8vvfSSKuI1ffp0PP/882Y3X0tOTsbChQsxdepUvPHGG7jzzjvRu3fvloy5Q5JboLldJOZDEARB6Ng0KeaDhb8++OAD1cRtyZIlqo8Li4BRTLDWBhvDMSiVfVlOnDiBHTt21PdmYcdZVi/t2bNnax6PTVJZVYOi0rry9f4S8yEIgiB0cJqUasuOtXfddRduuOEGfP755/j222/x22+/mdze1dUV5513Hm6++WYMGDDAEuPtkGil1Z0cHeDlfnrvHEEQBEGAvVc4ZQM4uk+4sIXurl27kJGRgby8PNVlllaQPn36KKuILXRHbW9ytQJj3q5SWl0QBEHo8LS4vHqvXr3UIjSff9JsJd5DEARB6PiYHXAqtB5S3VQQBEGwJ0R8WFV1UykwJgiCIHR8RHxYAXmnAk7F7SIIgiDYAyI+rIDcAikwJgiCINgPIj6sALF8CIIgCPaEiA8rQKqbCoIgCPaEiA8rsnxIwKkgCIJgD7S4zkdsbKwqNFZRUYGamhqj27AfjI+PT0vfqkNSUVmN4lOl1SXgVBAEQbAHmi0+KDbuu+8+/PXXX2fclqXVRXw0bvXQOUlpdUEQBME+aLb4WLp0qRIejo6OmDFjhmoux94vxggKCmrJGO2juqmXKxwcHNp7OIIgCIJgveJj9erVan3HHXeoZnNCC8WHjxQYEwRBEOyDZgecsokcmTJliiXHY3dIaXVBEATB3mi2+OjcubNaZ2dnW3I8dkfeqY62/tJUThAEQbATmi0+LrjgArVevHixySwX4cxIR1tBEATB3mh2zEdUVBRGjx6NTZs24aqrrsK0adMQGBhoNGhSUm1Nkyt9XQRBEAQ7o9ni4+6778bRo0fV7T179qjFFJJqaxrpaCsIgiDYG80WHzfccANyc3PN2lZSbc8c8yEFxgRBEAR7odniY86cOZYdiZ1nu0jAqSAIgmAvWLS3C6ueCuZTXlmNkrIqddvPW+p8CIIgCPZBi3u7rF27Fp999pmK+SgtLYW7uzsiIyNx/vnnY+7cuSarngr/xHvonBzh6dbij0IQBEEQbIIWzXgffPAB3nrrLXWbWS7BwcGq+Njhw4fVsnLlSnz++edwdXW11Hg7Zo0PHymtLgiCINgPzRYfe/fuxYIFC5TouPPOOzFv3jxl9aiursb69evx1FNPqW3effdd3H///U3a97Fjx/DTTz8hPz8fw4YNw4UXXqh6yJjiiSeeQFVVnftCY+rUqarnjK30dREEQRAEe6HZ4uObb75BbW0trrjiCiU+NJycnFTJ9ddeew3XX389vv32W9x7772Nigd99u/fj2uvvRZlZXVWga+//hqbN2/GK6+8YnT7xMRE9R6GdOrUyerFxz/BphLvIQiCINgPzRYfsbGxan3uuecafZ4FyPz8/FQ6bmZmphID5kDRQuExYcIEDB8+HP/973+VFeS6665T9UIMOXLkiFqPHz8es2bNqn+8b9++sHbypMCYIAiCYIc0W3xoJdWdnZ1NbqM9Z24WTHFxMbZv365uv/TSSwgJCcHx48fx66+/Ys2aNUbFB2NLCLc9cOAAAgICcPnll6v71k5ugdT4EARBEOyPZouPHj16qMl+w4YNGDlypFFRQIsH40DMtXokJCQoUePt7V0vHnr27KnWJ0+eNPoaTXz8+OOP9Y999dVX+P777xEaGgpbsHxIjQ9BEATBnmi2+Lj00kvxyy+/4NNPP0Xv3r0buDzi4uLw4IMPqtvnnXee2em2hYWFak3BoqHdLioqMvqamJgYtT7nnHNUcCob3SUnJ6tg2JdffrnJx8U4lpKSElgKph/rr/XJzqt7zN3FwaLv2RpjtSZknHJO5TtqX78lWxqrPY+ztrbWaH83i4qPsWPH4pprrsEXX3yhslnoJomIiEBOTg6SkpJU1kvXrl3rRYg5aIPmARi6d0wFrH788ccq6HTSpEn1lpKbb74ZW7dubdZxVVZW1gsaS2LMcpOZUyeo8rNTEROTA2vBlJXJ2pBxyjm1duQ7KufU3r6jLmYaG1pU54PptAzsXLRokbJ2ZGVlqccZaDpz5kzVfI63zUXblrEfGgUFBWrt7+9/2vZ8jkXOmJKriY+wsDC1Zr2R5sA4lV69esFSUFXyw+3WrVsDi4567vtUtR7UvzfCgjzR3jQ2VmtCxinnVL6j9vVbsqWx2vM44+LizN62xWU1GdzJhS4TTvgsKMZiY+aaXvShpYSqiS4IZrH06dMH+/btU8/xtiHc9vXXX1c1Pph1w220gNXu3bs363g4bg8PD1gafrj6+y2rqEJpebW6HRbiBw8304G7bY3hWK0VGaecU2tHvqNyTu3pO+rQhHnfYjW9GSTKpSVQuJx11llYvnw5br31ViUgWOODIkOr2bFw4UKkpqbilltuUS4WxpQw9oSl3BnzQUsIufrqq2ELBcZcdI5wd5XS6oIgCIL9YPasx1LpdHNMnz4dPj4+9ffNQXuNOTz22GOqhsiJEyeQlpamipbxMS1z5e+//1YZLpdccokSH48++qiK+di9e7caE2Hhs8suuww2Ud3UW0qrC4IgCPaF2eKD2SNHjx5VtTYoJLT75qC9xhwoMmjJ2LZtm4rlGDRokApk1bjrrrvU40z1JazrwaBXumdoEYmKirJozEZrIdVNBUEQBHvFbPFxww03qGqlQUFBDe6bg/Yac6GbhRVOjTFt2rTTHqN1ZOjQoWqxFaS6qSAIgmCvmC0+5syZ0+h9oWnkSXVTQRAEwU4xr9ubYHFypa+LIAiCYKe0WHzs2LFDxWAQNoRj91laRdjpds+ePZYYY4dECziVjraCIAiCvdHsHE9WAqXAYMM3Nn7z9fXF008/rTrQavA5ll8fNWqUpcbbYdDPdhEEQRAEe6LZlg9mpFBcsBYHi4plZ2crEULeeOMNPP7440qgsAiYcDq5hac62nqJ+BAEQRDsi2aLj9WrV6s1S6iz9Dnrb7CfCy0g559/Pq699lpVdIwpsObWA7FLt4uPiA9BEATBvmi2+EhJSVHryMhItd6wYYNaDxw4UJVYZSO4wMBA1SSOVhHhH0rLq1BWUVdaXSwfgiAIgr3RbPHh6VnXCK28vO4Kfv/+/Wo9ZsyY+m20Vr3W3FynPa0eri5OUlpdEARBsDuaLT569+6t1uy9wnLoycnJDYqA8X56erqqbNqpUydLjbdjBZt6SWl1QRAEwf5otvi48sorlUXj7bffxuzZs9VjkydPri97/tRTT6k1e6w0p8OtPQSb+kumiyAIgmCHNFt8sIfK4sWLMXz4cFU+/dJLL22Q2ZKVlaWExwMPPGCpsXYYpLS6IAiCYM+0qJc7m76xqZsxlixZorJdhMZqfLjJ6REEQRDsjlYrry7Cw5yOtpJmKwiCINgfZls+Vq5cqep1TJ8+XQWRavfNQXuNUEeeVmBMxIcgCIJgh5gtPhYsWICjR49iwIABSkho981Be41Qh1g+BEEQBHvGbPFxww03IDc3VwWX6t83B+01gmGqrcR8CIIgCPaH2eKDnWobuy+YByu+apYPcbsIgiAI9ohFAk5pAdGqmWqFx4qKiiyx6w5ZWr2i8lRpdYn5EARBEOyQFomP1NRU3HLLLRg/fjwSExPrH//Pf/6DcePGYenSpZYYY4es8eEmpdUFQRAEO6XZ4oOl01lYbN26dejbt6/qbKvvknF1dcXTTz+Nr7/+2lJj7RDkFmhpthLvIQiCINgnzRYfn3zyCXJycjBjxgx89913CA4Orn+Owagsu07effddFecg1CHVTQVBEAR7p9niY8+ePWp93XXXwdHx9N2MHTtWZblkZGQgJSWlZaPsQOQVSI0PQRAEwb5ptvjQmsU1ZtXQtqmpqWnu23Q4ck/FfEiwqSAIgmCvNFt8aN1r165da/T52NhYZGZmwsPDA506dWr+CDtojQ9/LymtLgiCINgnzRYf7FhL2NmWS0VFRf1zhw8fxv33369uX3DBBXBxcbHEWDtWgTEfCTgVBEEQ7JNmd7UdMWIEbr/9dnzwwQcqtfall15SQafl5eXIy8tT20RHR+PBBx+05Hg7UHVTsXwIgiAI9kmzxQe59957MXToUFXPgwGoDC7V6XSIiorCzJkzMXfuXLi7u1tutB2A3FNN5fx9RHwIgiAI9kmLxAeZMmWKWkh1dTWcnJwsMa4OCYNzxfIhCIIg2DsWKa+uIcKjcUrKqlBRVZf5I9kugiAIgr3SYvFx4MABPPLIIzjnnHMwcuRIHDt2TD3+4osvqsBT4fQCY+6uOri5tNjoJAiCIAg2SYtmwC+//BIvvPCCcrdoaLc3bdqEH3/8UW3Tu3fvlo+0A1DvcpGGcoIgCIId02zLx8GDB/H888/D29sbixYtQq9evRo8P3v2bBQUFGDBggWWGGfHCjYV8SEIgiDYMc0WH1999ZWqXDpv3jyMGTOmvpqpxtVXX63qe6xevRqVlZVN2vcXX3yh6oNMmjQJ99xzD9LS0sx63Y4dO9RYOCZrRCwfgiAIgtAC8XHkyBG1HjZsmNHnKTw6d+6s3DBMwTUXNql77rnnVIVUds79888/cfPNN6OqqqrR15WWluKxxx5Dbm4uCgsLYY3katVNpaOtIAiCYMc0W3xoPV0MLR765OfnN3m/H330kVrffffd+OmnnxASEoKjR4+aLOOu8eabbyI+Ph7WjFg+BEEQBKEF4kMLIt29e7fR53fu3KkqnXp5eZnd24W9YE6ePKm65N50002qQiqzaDSXiin4XkuWLEF4eDisGYn5EARBEIQWiI85c+ao9ccff6zSbfXZt28fHn74YXV71qxZquqpOaSkpKi1r68v3Nzqep/Q8qH/nCFlZWXK3cLAV6b8WjNSYEwQBEEQWpBqy1iP+fPn45133lFN5mitINddd119bxdaR7QGc+bAuA2i34hOu02RYYy33npLWUteffVV1VumpdCdVFJSAkuhHRPXuQV1x+DmDIu+R2uM1ZqRcco5le+off2WbGms9jzO2traRkMxLFbn484770T//v3x6aefKvcLs18oPMLCwpTF47bbblNuF3PRhIZ+cKmWKePqenovlF27dqmOumeddRYuuugi1V+mpfD9YmJiYGlOnDhR73bJSk9AVZH1FhmjmLMFZJxyTq0d+Y7KObW376iLmV3smz0DMgjUz89PTfxcmNXCLBOKhOY2k9MsF6wPQgFCd012dnYD94s+P/zwgxI827Ztw+jRo+sLnLEGCe//+uuvRl/XGM7OzqfVLGkJVJX8cEM6R6C6Jlk9NnxwP7g4W18PHG2s3bp1s+qGgDJOOafyHbWv35ItjdWexxkXF2f2ts0WH3R3rFmzRgV60gXDvi4UIy2hS5cu8Pf3V+myy5YtUw3rtCyXIUOGmMy4KS4ubvA4hQstMBQmTYUmIw8PD1ia8qo6t5Snmw5+vt6wZvhFbI1zYGlknHJOrR35jso5tafvqIOZLpcWBZyyBgctDeaaWMwajKMjrrjiCnWbsSK0Xhw/flxly0ydOrU+poSPM8OFgaabN2+uXxj8SugK4v2mWj1ak/xTfV2ktLogCIJg7zRbfNDVovVwsSQMYqXAYLYLLRh9+vTBBx98UK/M6JKhVYPPeXp6IiAgoH5hxguhu4b3tSBYayCvqEKt/aTAmCAIgmDnNNvtwoBSVi5l7xYGeo4aNUpN+HS/GMIy6ZowOOOAdDo88cQTKm22vLxcCQx9Pv/8cyU8jO1vwIAByuLBuA1rI79efJweOCsIgiAI9oSuJZkuDDolq1atUospGPhprvioH5hOZ7Q+iI+PT6OvoQCyRjTx4e8l4kMQBEGwb5otPq666irk5OSYtW1gYCDsnTwt5sNHxIcgCIJg3zRbfFxzzTWWHUkHp97t4lVXuVUQBEEQ7JVmiQ/2YElNTVVpsREREZYfVQe2fPiL5UMQBEGwc5okPo4dO4ZnnnlGFfXS6NmzJx5//HGMHz++NcbXAS0f4nYRBEEQ7Buzc1FZ+Ov6669XwoOBnZGRkaqaKQXJrbfe2mjXWXuHxdDyiiXbRRAEQRCaJD6++eYbZGVlqVKsy5cvx4oVK7B161bV8p6pr2wwJxintKIW1dV11Vj9JdVWEARBsHPMFh9s4qYVAQsPD68vy/r000+rkqqsOFpRUXd1LzSkuKyu54ynuzOcddbX00UQBEEQrFJ8MMiUdO/e/bQ02tDQUNUNlpYR4XSKTokPsXoIgiAIQhPEh9ba3lj1UC8vL7UuKSmRc2qEotK6BndS3VQQBEEQmiA+tA6yjdGcLrL2ZfmQGh+CIAiCYD2d1zowxWVi+RAEQRAEDREfbWj5kBofgiAIgtCMCqePPvpofXt7jaSkJJPPkRdffNGuK6FqMR8ScCoIgiAIzRAfBw4caPJzpaWldn2utVRbCTgVBEEQhCaIj1dffbXZ2Sz2bPUgEnAqCIIgCM0QH/369TN3U0GPmppaCTgVBEEQBD0k4LSVKS6rRM2pLGVfaSonCIIgCCI+Wpu8wrqS816qtLpoPUEQBEGQ2bCVyT/VzdbXy0W+bYIgCIIgbpfWJ6+wXK39RHwIgiAIgkIsH62MWD4EQRAEoSEiPtoo5kOqmwqCIAhCHSI+WhlnnYNadwn2bO23EgRBEISOWeFUaBoXT+oOD4dCTBkWJqdOEARBEMTy0fq4ODuhZ2c36JzEyCQIgiAIIj4EQRAEQWhz5HJcEARBEIQ2RcSHIAiCIAhtiogPQRAEQRDaFBEfgiAIgiC0KSI+BEEQBEFoU6xWfKSnpyM2NhYVFXUVQs9EYmKiWmprT/WvFwRBEATBKrE68VFaWorbb78dkyZNwgUXXKDWa9euNbn9sWPH1HbTp09Xy+TJk7Fp06Y2HbMgCIIgCDYsPt5++22sXr0azs7OCA4ORm5uLh544AHk5eUZ3Z7P0UISGBioFlpM7rzzTmRnZ7f52AVBEARBsDHxUVNTgx9++EHd/uijj7Bu3ToMGDAABQUF+Ouvv07bvqioCN26dcM555yDNWvWYMOGDejduzeKi4tx8ODBdjgCQRAEQRBsSnwkJSUpCwetHqNHj4ajoyPGjx+vnjMmJry8vPDWW28pawktJD///LPah6urK/r06dMORyAIgiAIgk01lsvMzFRrX19fJTy02yQrK6vR137++efKWkLh8t5776FTp07NGgMDVktKSmDJGBb9tTVjK2OVcco5le+off2WbGms9jzO2tpaODjUdXK3KfFRWVmp1k5OTvWPabe150xRVlaGyMhIxMfH49lnn8WiRYsQERHRrDHExMTA0pw8eRK2gq2MVcYp59Take+onFN7+466uLjYnvjw8PBQ6/Ly8gaiQv85Q5iKS5fLE088oe6//PLL+Oyzz5Qr5rXXXmvyGGg56dWrFywFVSU/XMamuLu7w5qxlbHKOOWcynfUvn5LtjRWex5nXFyc2dtalfjo0qWLWufn56tgUsZ0JCcnq8e6du162vb79+/H5Zdfjh49euD3339Xj/Xv31+taQFpDjQZmRI6LYEfbmvstzWwlbHKOOWcWjvyHZVzak/fUQczXS5WF3DKVFkKCfqNaLVYuXIlli9frp4bM2ZMvbKi6KA4YVApBQofW7hwocp2+fDDD9V2ffv2bddjEQRBEATBBsQHmT9/vlovXboU//73v5UVZNSoUfXi4/7778fs2bNV9gt9Sw899JB6/P3338e8efNUzY+QkBD861//atfjEARBEATBBtwuZObMmcoERPFB4TFs2DDccccd9eYcxmMwCNXT01PdnzNnDnx8fPD999+rWBHWBbnlllvg5+fXzkciCIIgCIJNiA8yZcoUtRjjjTfeOO0xFhnjIgiCIAiC9WN1bhdBEARBEDo2Ij4EQRAEQWhTRHwIgiAIgtCmiPgQBEEQBKFNEfEhCIIgCEKbIuJDEARBEIQ2RcSHIAiCIAhtiogPQRAEQRDaFBEfgiAIgiC0KSI+BEEQBEFoU0R8CIIgCILQpoj4EARBEARBxIcgCIIgCB0XsXwIgiAIgtCmiPgQBEEQBKFNEfEhCIIgCEKbIuJDEARBEIQ2RcSHIAiCIAhtiogPQRAEQRDaFBEfgiAIgiC0KSI+BEEQBEFoU0R8CIIgCILQpoj4EARBEAShTRHxIQiCIAhCmyLiQxAEQRCENkXEhyAIgiAIbYqID0EQBEEQRHwIgiAIgtBxEcuHIAiCIAhtiogPQRAEQRDaFBEfgiAIgiC0KSI+BEEQBEFoU3SwQnJycrBixQoUFBRg2LBhGDFiRKPb5+bmYu3atcjOzkbPnj0xadIkODqKrhIEQRAEa8TqxMfJkydx1VVXKQGiceutt+L+++83uv22bdswf/585OXl1T82ZMgQLFq0CG5ubm0yZkEQBEEQzMfqzAOvvvqqEh7R0dGYPXu2smB8/PHHOH78uNHtn3jiCSU8aCG54YYb4OXlhT179ijxIQiCIAiC9WFVlo/y8nKsW7dO3X7nnXcQERGhXC90waxcuVJZQPQ5duwY4uPj4enpiU8//RTu7u4ICgrCG2+8gUOHDrXTUQiCIAiCYDPigy6XyspKeHh4KOFB+vTpo8QHhYYhgYGBePPNN1FRUaGEByktLVXr0NDQNh69IAiCIAg2Jz5o5SC0ZGhot/Pz80/b3s/PD+eff379fbpmvvjiC+h0OsyZM6dZY6itrUVJSQkshSaGtLU1YytjlXHKOZXvqH39lmxprPY8ztraWjg4ONie+ODAif7gjT1mjLi4OMydO1eJlAcffBC9evVq1hhoeYmJiUFrWHVsBVsZq4xTzqm1I99ROaf29h11cXGxPfHh4+Oj1vqWh+LiYrX29fU1+bqDBw/ipptuUoGnzHy5+eabmz0GZ2fnZgsXY1BV8sPt1q1bvWvIWrGVsco45ZzKd9S+fku2NFZ7HmdcXJzZ21qV+OjatSucnJxQVFSExMREFfdx5MgR9RzrdxjjxIkT9cLjoYcewrx581o0BlpYGHNiafjhtsZ+WwNbGauMU86ptSPfUTmn9vQddTDT5WJ14oMnYMyYMdi4caOyYPTv3x+rVq1S6bbTp09X23z11VfIysrCJZdcgi5duuDee+9VwiMkJERZTJglQ6jmLrjggnY+IkEQBEEQrFp8kEcffRTXX3+9irvQYi9uv/12dO/eXd1eunQpDh8+jFGjRimTkbZNRkYG3n333fr9TJkyRcSHIAiCIFghVic+evfujT/++EOl1zJ41LC8+pVXXqksH7R6pKen48477zS6H1o+BEEQBEGwPqxOfBB/f39cccUVRp9j6XWN8PBwDB8+vA1HJgiCIAhChyuvLgiCIAhCx0bEhyAIgiAIbYqID0EQBEEQ2hQRH4IgCIIgtCkiPgRBEARBaFNEfAiCIAiC0KaI+BAEQRAEoU0R8SEIgiAIQpsi4kMQBEEQhDbFKiucWivV1dWorKxs0mvKy8vr12yQZ83YylhlnLZxTp2dnVWXakEQBENEfJhJUVERkpKSUFtbi6ZQU1MDnU6HlJQUq57QbWmsMk7bOKdsr80WCF5eXhbZnyAIHQcRH2ZaPCg8PDw8EBwcrP5Um/JaXk26urpa/VWgrYxVxmn955QiPTMzU/1u2CzSmr9PgiC0PSI+zICuFv6ZUni4u7s3+U+duLm5Wf0fsK2MVcZpG+eUv5eTJ0+q3481f58EQWh7rNe2boU0xeIhCPaO/F4EQTCFiA8bZd68eZg7d279/by8PIwePRofffSRus/neN9w+fzzz9V6y5Yt9a+leXzMmDF46623TL5fcnKy2ub888+vv0omBw4cUPtbtmxZ/WPvvfeeeqykpETdLy0txWuvvYZzzz0XU6dOxb/+9S/ExMSc8Rj/+OMPXHDBBWrhbUPeeeed047vxRdfVPEL7777LmbOnKle+8MPP9S/ho+fc845avm///u/M45Bew33/eGHHzZ4/Pnnn1eP87yMGzdOvd9XX31Vf8wvvPACLrzwQkybNk19Xjt37mz0ffiaJ554Qm1/++23Iz09/bRtaIHjZ8zPgce2cuXKRh83Z5+CIAhtjYgPG6WwsBAFBQX19znhUoCUlZWp+3wuNDQUf/75Z4NlxowZ6jn9yfyvv/5Cbm4uJk+ebPL9OIFzm7i4OKxfv77+8aqqKvW+WraENuHxMS0499///rd6P07W//vf/1QWxDXXXNPoRMhYgQcffBCXXHIJLr30UnU7MTGxwTY333xz/XHdcccd6rgmTpyINWvW4L///a+adKdPn47HHnsMx48fx+bNm5Vgofi599578eabb2LHjh2NnmcKrW+++UYdD4UFz7NGcXGxElg8tu+++w5RUVF45plnlLB6++238eOPP6pjXrRokTpPt9xyS4PzZMgHH3ygPguKt+zsbDV+Q5YsWaJEIp+j8Hn00UfVZ27qcXP2KQiC0NaI+GgGnFTLyqvMWyq4VNetzXxNUzNqTEE/e0BAQIOlU6dOGDFihJqQNAsGb3fp0gVDhw41ebycSEeOHKkyFzgZm8v27duxceNGzJ8/X72+a9eueP3119WVub+/v8nXUeBwwqY1YdasWer2unXrGmzD+Bsek4uLi7JKXH755Up80LqyZ88eZY3g84YwA4PHa45rYMOGDUoknXXWWSoThPcN4XuEhYXhoosuUvcpPrgtA5QZbMn3o5WFx0zhZQqKpiFDhqBv376YNGmSOm8VFRUNtvnll18waNAgjB07Fo888gi2bdum4jRMPW7OPgVBENoaCThtIpyIH353A2JO5rTOJwIgulsAXrlzwhknxiNHjqirXHOfHzZsmLII0Cz/5JNPqgmqX79+ak23gKn3o8WAbpe77roLW7duVRNdRkYGQkJCzngs+/fvV2tOfhqcgDVRwKv1pUuXNniNp6enGiPx9vZWKaAkNTXV6HtQGNESdOeddzZ4D7p6Pv74Y1x99dXo0aOHWihmrr/+erUNrSrDhw9vdPzff/89fHx8lDtnypQp+Pbbb9Ukbux7wYmddOvWTYmstWvXqveYPXu2cr/w/Qlfb2gBoSUoLS1NiRXtuCkOeZ4pXjQSEhKUcLrsssuUiLjvvvuUMDL1uDn7FARBaGtEfNgwvXr1wmeffaZu5+fnq5gKU88T7aqb8Q7PPfeccldwcqJVQZvsTU3AvIqmC4OWE7pguDCGoLGaELS8aM+b2u62227DDTfc0OAxiqBPP/20/nWaKNJ3eehDSwzdScyu0Oemm25S1gCKJlpdaGnhMS9YsEAJGooVHhMXY9DN9PfffyuLBsUSJ/NVq1YhKysLQUFBahtO9BR4dHFwnHTnUOSR3377TQmr5cuXK9FHYcDz/vPPP59m3aIVh/E42nnSjtlwO54DCg1uSxHI9+OYGnv8TPsUBEFoa0R8NBH+gdMqUV7xT9BlY1TXVKOsrBxubq5wcjQv3dDVxcmsTAHNrdLU5319fZV7gu4WuhT69Omjro71A0k1GEfB7ShQGLSowRgHCgdaKYi+KZ+3+d50h2hX+0y51Ld+aNAdYczyoVknGFehTZ6G4oLwKj42NlbFcRgSGBiohBbdH3T/8Mqfk7wm0ngeGHhrSnxQJDBNlDEddJnQWsH7FF633nqr2obHSEFDMUOXlL7I6ty5s4pFoRBgrMurr76Ks88+G08//bRRywc/Kx6vdtz8Dhh+fjwHfn5+iI6OVp8JRRrjcEw9bs4+BUEQ2hoRH82Af+BuruaduupqB6CmCm4uOquqdUBLB6/qGRPwwAMPqMeuuOIKZS35z3/+U7/dr7/+qibKL774ol5IaMGjdMcwfoRWAF5l00LAiY9BnLQ4cCKeMGGCcu0wJkOLGaErhMGbtFiYsnxoLhbuSztvzCphdg1dRC+//LJyX+zdu1c9N3jw4AbCiKLmk08+UYGiDArl89wvb3MfFCEUVgwSpTChFeT9999v4IahyOBx6GfFMGiU++daw9hkTisHxQDHSauRlvlDAWTK8kGLCl013HbXrl3qvSnEeK55n+4lBgXTEsVt6VajNYtuHlOP0ypjbJ+CIAjtiYiPDoyxmBBmXtACwaBMTkKclBjQSfSzZTQ4oTF+gSJDX7hwUqV4YFDnwoULVXYFJ25OqpzQmWZKKECYqvrUU0/VZ9MwNuHZZ59VQZqElglD6CK5//77VaYKXQcMWOVVPQNJOU6txw7dRhQVzOzRoLVjxYoVKr6DFgmKGy0YlBMwY0C042AmDWNe9LNztFgVnr+HHnqogbhgKusrr7yiYl8ag9YNZr7QVcMxsHIo3T/659GQu+++GydOnMCoUaOU1YTnVbNY0K2mZQ4x/oZWKO6T70FXmKnHTe1TEAShPXGoFQfwacGRAwcObHCSOCHzD7x79+7qKrYp0JXB11u6aigDLLUracKPkTEKvILmwueNNcFj8KQWwMltOD5eoRNeWR86dEhlS2hj5T55FW3Yn0ObDOm60KCQoRAwVQWW7hgKiaacQ46Px6aNWUvt5X0eO4+Rqb3GMmf4fhQ/2ms1uA/uU4uB4Xa0ZNDCQKFFaO3hpM/30M9Q4fvxvFEwcWx8ramsHT7PnkDaeTe36Bb3SXeOBsfBMeufa27DcRnus7HH9ffZFt/TlvxuTMHvGLOJKESNiVZrQcYp59Qev6P7TcyhxhDLh42iiQ4NQ1++4fPm7IOBirQ06GNqYtWfCDXO9AVubPIzheFESCHBMWkWGk5qpiY2U+9nKEZoDYmMjKwXHoTWAy6G6GfqkDO5MPheHF9Tqn0ajtvYe5g6tqY+LgiC0B6I+BDqYYXMxopgdVS0KqWCIAhC2yBFxgTYey8Oez1uQRCE9kLEhyAIgiAIbYqID0EQBEEQ2hQRH4IgCIIgtCkiPgRBEARBaFNEfNgoLK7FAlKsIMpCViwyxbbx5LrrrlPFrAyXxYsXqzUrk+qXJ2flUXaabay9Pbdh8S79EuzM6eb+WPFUgwXF+JhW0ZNrFiRjWXEWGWNFU1YYPROsrMoiYVyYAmwMtq1nUS2WR2fLeK0OByu0soga35NVS5uyT2PvweNha3p9WMSLj/O8MFuG54ZVYLVjZpExjouP33jjjaqKamPwNSzUxuZ1N998s9EmeqzoaviZMk8/MTFRVX3ld+HKK6/Evn371Pbx8fGqDDxfx+dZ4l4QBMEaEPFho7Aex+HDh5WgYBlx9vG455576otSsWspy6frL+xpwuf0xQL7trDMuH7fFkNYZpzbcPLSb2tPIWJYzIz1N/iYVruOvU1YbZRVQb/88ktVs4LiiD1lTMHJ9OGHH1bl3jmZsugZm6bpwwqjFATs3sptKRI4wbNQGpurUYCwiiorerIvizn7NITHxy62PB72n9FvbMfjZFoyy8pTyPTv3181jWORNr4nH3vzzTdVRVkWOqMIMKweqw+PZfXq1SrdmeeaXYcN+f3339XnyPeMiIhQlWJZwIvde3l8X3/9tepnw2MjPOfc15IlS9T5NrZPQRCE9sAqxQd7UfBKnpMUW65rVSLPBCffyy+/3GiDNEvCibWmoszspbayvGnbm9F1lJYPFvpiYSz2XGG/EO3Km3DCY1VN/SUkJESV2dYaxRHeplAZOnSoyWP96aef1OtYlIwl1c2FZcvZuI2l0dnplZMlm6vx822sudn69evVZ0irwXnnnadu64se/eJjLCHORXuMnz+v/MeOHav6mDCNltYBc/ZpbBy0DNGCQUsE7xvC88r317oCUxDys2FhMX4uLPvOjrY85sYKfbHHDvvPsMEfm/5t2rSpQbM+wvPP96OYYul3rW8Mj5trjoPPa+eGVh9+J/i5s9iZNfUWEgTBvrG6ImP8E2ardm0C5gTGCpS8mm0MXlWzuyhpzYrx3HfK4sdRnnSk1d7DNbwvwq5/odH6E7ySpvWDvUZmz56t+rOwd4cGJ0H9PiLsu8IGadyOgoDnlQ3faC2gmd8UnATZM4R9STTLAq+itQnfnFK77JqrwUmQEyR54403VIM5wyqpl1xySf1kq1Uj5YSuD4+NIoLdb/mZ8DVaK3ttkqfQ4XMsH6yNpbF9GsK+NhR4LLu+YcMGZQXR+tPoQ4uIJmQoONjQjfc5vgsvvBAXX3xxfUff8ePHn1bI7dprr1XnlD1xtDFSHFH4UBgawo61tGLxuAitP2xkN2TIEDUWWsP0RSj773B/Z/oNCYIg2K3lg+ZzThi8gqX5mhMVJ0r9OAV9eAVPkzUniLaj/YtScUJjDANjGziB023CeAsNTmT6Lhe6AAiv/LU28Hyc50+7ajc1AfOqmvETnEg5idENQ/TbxxvCq2ztStvUdrRuGbqG6FrQ3Bt8nSbA9F0emtuFx8DvCy0LtM7QiqNB4UE3BC06PDfm7FOfnJwc5Qbh+aKVhueZ9zMzM+u3oWWCIogWFlqe2B2YAoAiaNmyZaqBHa0lbGpHlw/dU3zc8JjpmuJYtPOkjc+YiN65c6dysWnN8QjdLhSDPB8UJRyHZjXhPuhmo2j617/+pfrgCIIgtDdWZflgs7KDBw+q2w8++KASHrzy5iTCq3Wa0g1h11FOWLxCZGBka8OJgVYJulLMgZM1r3TZJ8Rcs7eDs6tZVTd79uypJjWegyeeeALvvPNOffdWze1iCB9jACInal758+q5V69eJj8Pmvg5aepf8bOlPK1TWs8RffcAj5XHSYHD8RE2F9Ou/PVhkKgxy8dNN92kbjM+RZuQg4ODG2xHQcpt6RIhtFBQkFAkffjhhyoOhlYICjKeS8ZCnGmf+jBmg8fNNSd1HiOFGi0/tDoRHiPFA4+XY9H/zCgGKCoYbMrvL+MvKGQYd2HM8sHxcWyEbkb9MetDMcPeNpqVh/C3QcsH40BmzJihfg+MZ+HnymOl64cCbPny5So2RLOwCIIgtBdWJT60AEB2WdUmTsYJEP5pGoNBfDS533vvvWpSbQs4MTi4mNels7a6Gg41gKOLGxwt5HPn5MSJjFfjWhAhH2PTM3O6E9L1QlFB1wBFHuE5pECgiNH47bff1ETJYEtNSPAxBnJSFDLTgxM4A0ppPeHkvGPHDhW7wEmPLgYGYlIM0O1DdwIDKik4aFGh5YPdZA3PrSYiKTA0wUbhSdcJJ/MFCxaoiZUZIozvoGWGgZV07+zdu1fFCYWFhSn3Q1BQkHo9M1KM7ZP3aRGg9UzfTcXx8Tg+/vjj+scoiuh60R+zMYF36aWXKjHEcdDFo3UA5ra0fBhaNChM2T2YlhV+jnQz0oLCz5JZNbR20MpFeLzsGKlvTWKcCF9DgcTzzw7E/N3ccMMN6vhfeuklJVAoWthATxAEob2xKvGhpWfqdxPVbmtXhYbQ5MwrcFPPNxVODNo4NDgB0yxOK0ZTg1m1iYZrSwXCsmU9Uzk5ufEKmPvm1S0nGQo3YzEf5H//+5+ydNCKwXPG49SCL5nRoV2Ra2OlhYMBrXQraHD7F198UV3NsxkbhQAFC8UFYRwJsz60Y6VbhPeZDkw4+TETRYsZ0W9Xr8Erc7oOKKx43plSzAmWwkLLrqF7gVYyBiUTWny48LzwNXSPcKzkmmuuUTErxvZJEcV96n+2FDmxsbFKmOl3lOX+6M7ha7TP1dhnyjG88MILKvWVYopigMHQpoJ6yZ133qmyiSiSaMWjm4z7ppuEgkR7Hwa+8lzrvy8FCq1f3D9dRLSy0CrDWB4KRQoZihG6MSmGjI25Nb6n3A/PNY+hMRdXU9DcRtbuPpJxyjm1x+9obW2t2b2yHGpbMzqzifCqjRMFr6YZ4Ed45UmBQXO6fkyDIRQfmimak5Jh23Rz4KRjmGGgwf3RrG2szXp7QmsD/+T1x0VRYWwC4ZW0dtXPbTghcGLULBrHjh1Tk7IGJ2UeN8WO4bnm10Z7LdHOm6mMDo6TrzEmNkyhH6dBeEwcN8ejfb7chvvVjos/JC2TR4Nj0s6P4T4pZDjxU5RowZ18jBY1/ffRjoH75744Ft6nNaex8VPQGZ6/xuA+9d+T78f30s41hQifp7XHEI7b2Pk19Xhrw2OnxdLw8xAEoePC/1taZ23K8qH5uGmm1hRUXl5eg+daG/5JG8ZA8E80JSVFTTrG/vQbg8ehxXy0VfdUc8ZouA1dJ7yCJtpYTe3H2ONNPS/NhZaIxs5pU8dBawotIPqfOfdhSlToC64zwXFS5LTkszc8nsaOrymfV1t9TymUaD2zlGinGKOFiBlFTRF1bY2MU86pPX5H4+LizN7WqsQHLQuaC4VpnYwpoK+aDBgwoE3GwD9ew7gJTiBc9DM4zEWzQHC/1lxngQGaHCuv+K19rJY8p0xD5dIa2Mpn31pj5X74u+Efm6XFKfdpTnxTeyPjlHNqT99RhyZcuFhVqi2vkhgMSeivZpwAXSEM1KPbhdC3zTRcLStGEARBEATbwqrEhyYumLVCEzCD6xhAyb4jWiAlKzvSVG5u1VNBEARBEKwLq3K7aD51pmMyxoKxH6zVoO8vZrYBfVWGcRk0HTEDgzQn2FQQBEEQhLbBamdp1mngYoh+qW596FtmSqEgCIIgCNaN1bldBEEQBEHo2Ij4sFHolmJ9ClbpZBdUljtnmhP7eLDYlOGilSFnlU62lNdgxU4+z9c3Vo+BAcCs3GkMNnfT3oe1VljE7NFHHz2tjLip4+BrWK2V9Sg02Jqe+2N5c/1y7HyM9UcIa36w4Blfy4Je8+bNw549e874nqwWygqxLEXOSqbGYAG3KVOmqIW3CcfH4mE8PgZDs8CaBiuPXnXVVaqqK4uZmXPsLIfP42EhNn1YlE07nywoxuP77LPP6o/5qaeeUmNglg7r4pjqe6TB17AMP8/R3LlzjbYh4PFw7Hw/7b15TKzTwe8Mv2cs4c5qqyQ+Pl6db76Ghd5YI0YQBMFcRHzYKOxoe/ToURXnwrbp7J/CEvOcUFmgjaXTOemwAR3va+W5GS+jVbRjrw9OZExxZlBvY7EynEwNK79qMD2XueLa+7LLKpvPmdNFldsxtZqdc1leXEMrKKYviFjIjI9pdfEovlgmntVAKSJYSpwlxbkvU3DifeSRR5RQ4KTK6qyGEyd7xLDcOiucskIob3OC5znkuWYFURa+Y0M7ij02oWPZd8YhsSjeqlWrGogmUwXIWEGWx/PNN980OE6eay48n+zBw5Tzl19+WYkBChbumwX32EyPqekUjo1V+GV5e3aLXrRokTqHjz/++GnbsB8M34ufH+OsWJuD9U94btn2gO/F7wlFJeHjfE+OnWLQ2D4FQRBsLubDmlEFmaqNV0I12liuqhyocoBTrXn1E1ydXM6YL83y4UxB7ty5syqMxolRq47JRZvMeFu/RLjGxo0bcf/996uy7AzwZaBvS8pqc7za+1AAMWvpTFfDPI8UH6NGjVLlzDmR8bXmsHv3blUDhqXatVgflpenmGqsoBWPm+eGqdvMbWcpdDZr03rXEE2EsVS5dkw8x7T8sIQ761dQNHDNcVMoMPuKnWZZvp7WAcYgNXY++Z5s7MfjZYE3igPNOqXB9+Zy/vnnq8mfmV4ZGRnq+CgO2D+G1iAKisby9NeuXasqDvIYaSVjmXWOX/81vM0xs/cMrU4Uc1qFV74fzwW30SrYch/8/Cg8+TpTlW0FQRCMIeKjifAP96lVr+NI9nG0Fn2CeuK5qfc3KkBuu+02dRXKfiOzZ89W9VG08uBngpMerQZ0I7DzqtZnxVJwgidsKtcYFA+0UsyfP1+5Syg+6IYxFmhsCCdIot+hlZOgJhboKmFjOX04QdJNQVjBVJt809PTG2xH1wMb5dGaQXhutT45WgEuWj8oLig2KEAIhQCPgxM8RU1jJc05uXMMzz//vLJw0P1lKD4I34PChNAiwYBr3qfbiM0AL7zwQjUGQheIoXWKgojHR8uUdtz8DlO8GmsyR/cO980ePYQ9aSi62GSPr6P1RIPfT7py+D1i3yBBEARzEbdLc2ijMumNwUmH/VjYYI3me17J82rUHFiynpMoRQfN9+wI21JiYmJUnAAr0VIUMUbkiiuuaPQ1HDevqjl2Ho/miiCNVdnUrzSr391VH3bM5aSuv9Cto9/bRRN3hk3PNBcLz82nn36qXBJ0r+ine7PTLy0utFxoFg6KLVaKpfVAi9EwBjvY/v333+q1rF9D0aFZQjS4T55PNvWjm4UuIIoi3qe7jC4juofoVqO7jdYPuk0Mj5m9enh82nkydcyEbh268ihYNOheCgkJUe4tfkZ0qdHaQShGeKz8/Hi+LdXcURCEjo9YPpoI/7xplWiS26WsDK5ubmaXrTbH7UK6d++ughvpPuGV9vvvv6+uUumbbwxaBzg50oTPdvJ0V3BpCX379lUTNffLNa+qG7vyZ5wAJzROmrQU6FsEOJFpFgz9Rn+8zfNCwUIrAGGsi7HS+7RCGLN80MpC9DvFspGhPtu2bVPvoVki2FeIj82cOVPFT1Bg8P35HhwPJ2ctaJOWCVpjKMZMQTFBawHXf/75p7qtdRGmRYrwu0LxoLk99GFsy6233qoWxqAwQJUWMManGLN8cHutKJ+2Njxmwm69dOVoHYoJBQ6tQLRGUWTQ/cN+EPy8eezcDwNiKYQZG6JZYQRBEBpDxEczUE3XdOY1yqp2qAZ0tWp7S/XM4AQybdo09aevNYOjNYOTvbH4DkMoTrSug9wP4y5oatcXAc05J/7+/urKmK4TjosBmMxkoSBivAGvojVoWeAVNC0ImuuEEzEDF2kFoDmf8Si8yufkx6tsToS0NnBCZhAmXQEUA5wsOWky2HPJkiXqeChgODkbjpFuHq7p8tHcLswaoRuHLhlajyggGMfBLsuMq2FAKSdbWgbozmGcDYUNJ3XC88YxMViTz3ES5mN8Pd1jDExltogGx8fzr+/CYOYIhRfFoIaxz5LnkrEYFD4cW1ZWlnqcFhRaPgybVPM7wWPhuWXRPvZMovWEMT4ULXSR8RwTtiygkNP/nvJcMIaFnxXPP8fE7w8De/n+/Ey5D372mmtHEAThTIjbxQbhxMHshwMHDtSnRjIYkRMBAwObArM9OAmzpfyZ3C+84tVP39XiJwzhvjgOBp3SFM+rcf00WsKJlpMY96MFVtKFxKt8xn5wMmdmBydXCg0GpdJywQBTQgHBFFVaWOi+4PO0pDBrh/vlttp+tYXHyQwOChym6NI9RJcF4xu07BquOQ66NW655RbVR4ixFYyrYVwG3RUcE9+TY+c517KFmN1D0cHxUkxwW2YW6QsCfmaHDx9W76E/NgaVUrTR2tEYHDf3x/ehgOGYaPni8fP4DI+Z54HWFB4jY0L4HowzIRQlWuYTYWwIBZ8+tKbws+D3jIGxPE7ulyKJLhqKS4oTflbW3MFTEATrwqHW8FLJjmETO6JZBTR41UfzPt0cTe3OqXWK5etao7MpJzguxtJkOfHzylc/E0Hz1+sfBx/jOLktRYKxsWrb6MNtuK2xfdJFou2LV928qmatCQ0tW8TQpaBNhvoTmX7mjrFzyuPn17gp51f72uvHQPC99Y+d23DR4iU4WRvWQjE8v/rxFdwf02DpEtPcRHw992N4jrX35774ntzuTJ0meY6bkmWiPzbt9TyXPNdcMxaFwsKYiODzxs6vqcdb+rsxBb83dGnRvWPNXW1lnHJO7fE7ut/EHGoMcbvYOJxMTAVdGjPbG5sEtMcYD0GXB9GPOWHgKGtjmMLYPjkpahMj4wGYAquPqS+7sYnvTL16TB1/YxjG1Ohnyuhvo78dhVJjabyGY+EPkSmx+lklWiq0sdfpv785oqKp6a2G58nw9Tz3pvZpSmC0hqAWBKHjI+JDqIfpo7SWcILVn1QaCxw1BxbpskfoqjhTurEgCII9IuJDqIeigyb/1nIRCYIgCAKRgFNBEARBENoUER+CIAiCILQpIj4EQRAEQWhTRHwIgiAIgtCmiPiwUdgSntkUiYmJ9Y+xkBQ71DYV7oMFtVgciyXCWSCLhbAIi2GxiJUhLL7FpnSN3TbkhRdeUP1S9GEVUo6b/VMM989j1C+ApX98119/vcolZzYJ1yz9rfVf4eu4LRdW7BwzZow6Bv2CWnw/9irR+rOwYqhhDQ9zSUpKwnXXXafOHwt6GSvWxqq0TFfmWFimneXaCauL8j6LdV177bWqkJt+DQ3ul58H4X5ZjVX/MxcEQbBFRHzYKJyYOKE99thj9QWz+FhzasZxHyw7znocX3/9tZroWSZd26exJmRfffWVmrAJJ21tG/3b+sTHx6t9z5kzp/4xNlJjXRG+B6ua6sP96Bc143HpHx9vs+T53r17Vct49hjh5M4S4tpzLIe+a9cuVeSLx8YKpFppdx4f65fw/VmRlenA2vE0FZaSZ8Gun3/+Wb0nK68awlLmWvdaVlllGXe+hhVEteqsWsVZws+AQoYiRTsPLGc+efJkVeJdEATBlpFU22aifxVtCNNU9Ys1aSW2jaWvsvCTfuEqbtuUMtWcnL788svTSp1z8uKkyOfZg2Tu3LkNLAn6sLIl02vZn4PCgQ3PDAtSsQU7J2vui+3TuT82XGPfEnNgLxRaKdhJV7/HCc8Lr/xZBZU9UViUqymwYBdLuU+ZMkWV+eY+9J8jtOYQVtskbMBHi4d2zliqfM+ePWgOrOLKPjEsx87mayy5rhVq06B4YGnyiy66SJVi1+8+zGZuGnw9+8MQloBnKXb2itGHFh4Wg2O/maaW0hcEQbAWxPLRTDhhmVrY/lwfmvc5ORrbVuuyqsEmaubCstUUOey3YWiKZyt1TsS84ud7UIhoV9eGsAlbbGyscrFQTPB1+kKJ5cDZy4OChBM3q5OasnCYglf9bASnQdHx448/KhHAffM+rQLNgRYgWj8o2gzFC8fI9vWE7hmW/D5+/LhqeqcPj9dQHPI8aO4b/YWdXTUoAihA2G+HcE3hpw+3oahk/x02zGMfFwolfdjwjW4jrSgZG/FR5GkdczV4Dnnu2eRNEATBVhHxYcOwbDeFBWv080pZIyMjA7t371YdUHnlPGvWLHTp0kVZF4zBduzLli1T21OgcHJ89dVX65/n5E13Ah/XOrk2ldTU1AZWD1pkOLlTbNENQTcJxYgWd2GqyJm+RYb9YigGRowYoY6Z7gh2t9V/jn0L6NqgwKLlhq83t4AahQyP23ChBcMQrQy7Ydl2ormKKHzommGn2Hvuuaf+cbqO2P2WaO4uNr3jOTGE1iZadOgmEwRBsFXE7dJMDE3r+hhObnRjmKoaaujeYDxCU2AwIlupG7sSNpwItfu0AGgNwbRGQOHh4SrG4Oabb1adWj/55BM1WRO6hdgSnq4TBnpyAmwqtEDox3Cwqy1hl1ouWnO41atXK9cCLQi0GOhbXwx7wtBKQGuJsfPK55YsWYJPP/1UWXPootCsGxRtx44dO+OYKY5oDTLWWfbiiy9Wt+mq4j5pfSGFhYUq/kQfbsMS9bRa8NzR4sWAV7q7uDDYl8f35ptvml2O3ZjIEQRBsBXE8tFMaOI3tRhr2GVqMWxU1tS25Jz4XnrppQbvSVO95h7gBE5xwitlbSJlfAOv4LnmpMlMC2aD8DYXug24PwY4kqlTp+Lll19W78XW6c2BsQ7Z2dnqNt+DMRAUN5o1gVf/fn5+9YGnzByJi4vDjh07lDWElhlOuLRyGB6/KShUKKjo9qLA0TJM2GmWliHGnNAdwscZ9GkYKGqO5YPniVlH3AePj8/TtUKuvPJK3HvvvUp4UHBwm7y8PPXetEhRlDzwwAMqSJaC5pxzzjnjeeR78HzoN6sTBEGwNUR8dAAYv2AYO8KJlCKE2RGceNlVdvr06fUTNk33XNPCwG2Z4jlp0iQlNJg6umDBAjU5alAY0MpCSwNjJpoKLSecmAmv+jnp092jdXmlCGPKK2NDUlJS1Hsx3ZZCgemyDKrlcURFRTUrm0fLhqHwoXjg+WB2iya8KIQYe2KINj79xdDqwHHRasNz16NHj/rPgpYezdrDNGMKMH4eFB88vwwoPXToUL2bhYKRAauNwddQzBiKMEEQBFvCobY5uZkdFM0FQbeEPvTVM1OCAZ7G2sc3Bicfvt7Szdq4X06C+m4bXhHzPZprkjc2VsP30d6DbhLtcf1tjI2LsG7I7NmzlbigRYWvN2wtr6XTnukYuA2773KcxlrAaxO+/vnm+3FpyflpKkylpTuFFhhjn712vPpwbPrbGp7P559/XllP3njjDYuOtTW+py353ZiC8U0xMTEqlkffBWdtyDjlnNrjd3S/iTnUGGL5sFE4QRhO8Mauyi39Ptp76D9u6rY+DJ6kW4FuFT5vKDwI92vuMRjLTmnsOe092zJWwtS5MDxe/cVw3Pr7oOCi+4mZTIIgCLaMBJwKbQZTgsXQ1nw8PT1VHRBLWtAEQRDaAxEfQpvBK33J0mgZIjwEQegIiNtFEARBEIQ2RcRHExCXgSDI70UQhA7sdmFWBTMF6Oduje2bAlMb6S5gfxOmbDbFdcAsAq1AlrWbzG1lrDJO6z+nFOr8vfC3wt+PIAiCVYsP/gmy4BLrSfDPkKWoeZ+1HiyxfXPgnzErgLL+hX7Lc3NgeieFETMZGst8sAZsZawyTts4pxQe/N1Ys5AVBKF9sDrx8dFHH6my2IR/hGzGdccdd2D58uVGc5Gbun1zYTEu9iBhE7GmwGJaLMrFaplNrV7a1tjKWGWctnFOafEQ4SEIgk2Ijy+++EKtWUSJnWBZmIqFilatWmW042tTt28JjdWWMIXW+ZUVPC1VaKm1sJWxyjjt95wKgtAxsCrbOstqszspLRgsSEVrA0tWE/b+aOn2giAIgiC0P1Zl+UhLS1NrtkXXgtTYjZRQZLR0+zNBlwoD5bQeJJbMkDl69KjV17iwlbHKOOWcynfUvn5LtjRWex5nZWWl2fuyKvHBXhhEv/S2dluLxG/J9mdCO2mW/MJwX8b6j1gjtjJWGaecU2tHvqNyTu3xO+rQhEKSViU+NF+zflCnJjCM+aGbuv2ZOFNHUUEQBEEQOljMR2hoqFrn5+fXWy4010pYWFiLtxcEQRAEof2xOvFB0cDaHZ988olq9/vXX3+p50aOHKnWBQUFyMnJUdYOc7YXBEEQBMG6cKi1sprhrNnx/PPPN3gsKioKP/74o4rnuOiii3D48GEsXrwYo0ePPuP2giAIgiBYF1Y3O1977bUqYGXp0qXKnTJs2DA8+uij9ULCx8cHfn5+9ffPtL0gCIIgCNaF1Vk+BEEQBEHo2FhVzIcg/H975wEsRbU04Hn6V1mKoSRoKUFBkSRJKKKAIEkBS0SCCIIgKIpECRKFIgmSs1ICJgRBQQRFgiBRAckqiARRFIHCEglK2Fdf1+utuXNnd+9ydwb+9/qrmuKyO7tz9pyZ0326+3QbhmEY//2Y8mEYhmEYRqiY8mEYhmEYRqiY8mEYhmEYRqiY8mEYhmEYRqiY8mEYhmEYRqhYMowUsX//fjnIuFqwYMGUn58qyA5L1d7rr7/eKV68eLQacDxOnTrlrF692smVK5dz7733htJOavR88803kja/RIkSUrk40flkuP3rr7+c/PnzO7fccosTFjt37pQqylw3d+7ccc89f/68s23bNuf06dNOgQIFQm3nzz//7OzZs8fJkSOHjGNGC0Bxvxw+fNgpX758wnFIBSdPnnS2bNki9yZ5e6655pqY5x4/ftzZuHFjutfDaCtjuXXrVrnnihYt6mTLli3hZ3766Sdn3759zm233SbjHxa7d+92fvnlF+eOO+5w7rrrLt9zyLqwZMmSmN9Rq1atwKu08hzt2rVLcjkVK1bMufrqq+Oef+jQIZlHGetChQqFVhiT55d7lD6jJliWLFkSzrskx+ReZt79v5DzUHGfUnqkWrVqcfvo4sWLzo4dO6S99KeWMAkE8nwYmWPQoEGRe+65J3q8+OKLkfPnz6fs/FSxePHiSLFixaLXrV27duS3335L+LkJEybI+b169YqEwYEDByJVq1aNtrNkyZKRVatWxTx/y5YtkWrVqkXPL1y4cGT06NGBt/Pvv/+OtGrVKnrdAgUKRMaNGxfz/P3790eqV6+epp1TpkyJhMHkyZMjBQsWjF67RYsWkTNnziT83KFDhyIlSpSQz2zfvj3wdq5bty5SqlSpaDurVKkS2bt3b8zz58yZk+ZZ0iPoth49ejRSp06d6PWKFi0aWbBgQczz//nnn0jPnj3TtLFTp06RCxcuBNpOvr9Lly5prtu/f3/fc8+dO+fbl3rwfpDMnj07UqRIkej16tevHzlx4kTM8/v27SvPnJ7PHLBnz55I0OzcuTNSvnz56HXLli0b2bp1a8zz33nnHbk/9PxatWrJXBAWx48fjz5T/B2LkydPRho3bpxmfpo5c2Zg7TK3Syb58ssvJdU7miz1ZKimy+ph3rx5KTk/Vfzxxx9Onz59nLNnz8qql9UvK7ChQ4fG/dzChQudiRMnOmHSv39/WaXp6hDLS8+ePaPFA91Q46djx46yqr/zzjud0qVLy4p08uTJYq0JkhkzZjhr1qyRVQ/XZVU4YcIEsRT4QRkAVr60s1SpUrLKGDVqlLN58+ZA2/ntt986Y8aMkVUa18XqtX79eqmHFA/O7927t6zywgDrVffu3cXyQYmEnDlzOr/++qvcD/FW9ICFhJW5Hqycg2TYsGHODz/84GTPnl2sHtybtJMVox/cjx9++KE87+XKlXOuvfZaZ/Hixc6CBQsCbef8+fOdTz75RFbczDdYk2bNmuWsWLEi3blXXXVVmj7kUOsM7eX9oMCyxvPB84wlgfHDAjJ27Fjf87/44gtn9uzZMo/ef//9Tp48eWQOGDhwoBM0zEVY3HiO8+bN65w4ccLp0aOHPC9emAsGDRokc1LFihWdW2+9VSw1HTt29D0/1XA/tm3bVp6pRDDPY83BisQY0OZXX33VOXDgQCBtM+Ujk3z88cfyb6tWraTODJOnCu1UnJ8qmGzUPIyi8/bbb8vry5Yt8xUuKCkvvfSSHBTuCwvMrhs2bJBJZe7cuVKjB1MxD/u6devSnc/DgjkRZYq+fffdd526devKe37m+FSiY8nkwnUff/zxuGPJA92oUSP53HvvvefUrFlTXsddFCS0h4mufv36cl1VOBPdcwgpxiIsuBbjj9KB0GT8EZaMI0qIH5iyoUOHDs5jjz0mpRXGjRuX0P2VGVA0Pv/886gCSjsZW56j5cuXpzsfJZN+B4TpzJkznfHjxzuNGzcWRTCMe7Rr164y37Rp0ybm2KNc0Hd6jBgxIqrw83eQysenn34qymelSpWkVAbKGixatMhXSO/du1f+bdmypSjRunj78ccfnSDhWcV1ecMNN8g9yoGihEKB+9UL9wPjz3z/5ptvSr9z/vfffx9zkZIqmNsfeeQRcaNkBL0nuEcZgxo1aogCgpIcBKZ8ZBKd/Fh5AStL9+uZPT9VqIBjkgQ09qxZs8pKAwuIn6WEm7FIkSJO8+bNnbCgH5hsEB6sKvH5EvOh73m5+eabZULl4dbYAOr/QJATOxOl9ltGx7J9+/ayumOlNH36dGft2rUiXFkJhzH23nayokHJ9APL02uvvSYWCI4w0H7DJ864c39yn7otHF70dcb/2WefdapXry4KQZAw7ghlBBBxPu6+9Rv7gwcPyphj9cBChtWJWB9W6Uzwl2PsMzLfTJo0Se4RlLqw28kzzwKEel1YRbyUKVNGlCGEOwsUlCUI61kiHgJrEGPKHBmrT2k/cC8DVgWN89rpo6ykks8++0zm8X79+iWMnTl69KgcYcomUz4yiZpZNbiNCQn+/PNPX4tBsuenCu913ddmYvTCQzVkyBBnzpw54v4IC22n22wer51M/lhnED4agIbShFB/6KGHAmsnD7WOl/apKju8F4+VK1eK2R5T6IABA5y7777bCZJY9xxKnk6OXnDRIWBpZ0aCkoNoZ6Kxx8zOcwMoSAgEVmrDhw+PqaxcjnbqpE6gH1W5Wa2zIm3Xrp0osUHhHl99nuK10w39insYAcvzFTTaHu1TFIvrrrsuZltRUHFzoQjiBsGSSyAtz1OQ+I29Pvd+7SxcuLD8i0KMmwiFHssJxHLRpQoUcSxKTz75ZMJztS3M+7qIi/e7UoEpH5lEBZBGgbtNk37KRLLnpwpMf+7ruv/2uy6TVYMGDUKPytZ2uonXTjfEU7Ro0UKEOmb4IE3v7nZ6xxIBGA9WIZiXeciZQFetWhVYO91t1Xa67wG/tmJyxcWFRUlXdWHgfTYS9Sn99/zzz4twJHaCFTD9yvdgrr9S2qmvIdBxfVauXFkEK67Q119/PdB2el0WGX2WEJS4kXAlZmQXT5B96tdW3C64gniWiKVgJx4ul6CVD795NF47H330UXmGjhw5IhaIN954IyrcL/rMdamkdu3aGZ4Dk/1dqcCUj0yiW6zUfK3xE6wW/bY0JXt+qtDruoM2z5w5I/8G7XcOo51MRk2bNhV3AVYQgqzCaKd7LOO1EyFA24hRadiwoTNt2jSxKuD2GjlyZCht9bbTr62sgLAc8BlWkphu1bpATIau2sJop/v58OtTzicoku2DOnFijgf6+kppp/s14i4QQKyAIUjFk4WDCjp9njL6zGusCHFCl+u5j9enxHmgyHXr1k1iKQiqJe4Lq2eQcR9+Yx+vT5nTifchtg/3FfFhKJ8Qxrb1S+l/VViDlg+mfGQS1Sw1Ilj/VV91Zs9PFd7r8uAeO3ZM/iZq+0pB24lJXVeM2uZY7VSLB+btF154QSLPgwbztZqytX0EncVqJ+bvBx98UNpJ34P6fgmyDBJWhe526r/Ey3gnQFZo7C7iwKJAVD6uLEBgqlAK4x5lxaXX9ns+EDS4MQYPHhx9jfsGEERBt5MgaN1FEO8epe26otT+1jGJFXOT6rZ6xz7eM8/9iJKJuzUsy5e2U58h4jxwSaFA+a3eNQ5EnyHcQ9zPQbszvM9Soj5FcWe3GdYZAr2xJmusR/7/xAtdCZDPg77GAsJ8mtF7JTNYkrFMwk3FipCVLBojMRKA+RfQwtmSx44NfNKJzg+KChUqyLZOTL2sGngAmNzxSRLYSZwC7ULLZeva5YKtfZh5mdhxSbDzgWRjal4FgsywGFSpUkUsRigcKFJ8Ft8/q3XQPg+yT4kEx4JRr149cVeArmw0sQ9bm5m0CKLD8tG5c2cxibLrwR3YFRT0GytDdq8Q+KbR69pOBDb3AxMQ9wLWBDfcFyhPBPMFGXxKYjBMvfQRW5YRgkzebE/kuqzEsBQw5ihy3Kf8TeAuJngEO64XoH+DAoGH4OC5ZisyQdy6dVX7lC3YKJn0GUpq2bJlpR/ZdYIAYpcEkEgrSLhHsQoSkEl/ajCutpMASgJi+T2afGzTpk3yrwZ6hwHtJAgbhZIYKMYU6DesByws2JKOgsFrtJf+ZE7DQsJvRGHifggyhopnlbgIBDTPPfMSQho3GsHECG/dCcVuNtpEzAXKMDE+zAns3MqWLZtsfb6cfP3116Kocf/yjNEegqEJhK5atWr0HtV7JeUElkHkfwQSs9SsWTNNMp6KFStGjh07Ju9PnDhRXhswYECGzg+Srl27prkuSWTWrl0bTdSlCXC8TJs2LdQkYx999FG6BEcjRoyIvq8Jc0iAtWjRophJkbTPg4LkV+6EWBwNGzaMJowjeRyvkQgLdu3aFU3YpUflypUjBw8eDLSdJLhq0KBBmuvSbpK5uRN10V4/SPYUVpKxYcOGpRvHhQsXynuMt7ZdIUmb9/x+/foF3s6VK1fK8+O+bo8ePaLv8xzxGs8V7N69O1K6dOl0z31GkvxlBr6f67ivy/xz6tQpeZ9nhNeYp7zP+/jx4yNhcfHixUjr1q3TtJPEXHrPrVixQl5r0qSJ/P/IkSNpEhHqMXXq1MDbqv3jPqZPny7vnT17Nvoaf5PkrWnTpmnOJZHa8uXLI2FSqFChdEnGmjVrJq8tXbpU/r9t27Y0SSg5GJOgMMtHJsFSgPWCPA9YOUiX3qxZs2iQFqsJVpK6Ak90fpCQMIbV5VdffSVmSnyQRI0DqzPa6ZfuG7Mx74WVWp0gLSwerIIwS7PCxbKgsOplFcxqg3+9K3UlSKuHji0rbSwKuCuwvLDK0W1tunJUUy1WJhJNEcxHBDmr+TByPbAaZDcAvmdMwKzCnnjiCbEMafvow1grXe4Zzgk6cRfgMiMXDcn4MAPXqVNHrg+MN+3k3lXYXku/knSKe4FVWpC7nBSsbowj44l1hlUjFg2Fe5bx1T7jb1xW3CtYw/Lly+c0adIk8D5lRcs9SqyJJuJjvtGdJDwj9Kk75TpzEa8xDmGBW4qtvR988EE00RWxUVp6gnuWNtFvwDyFNY/z2QrKM0Tsj94rQdK6dWuxrpAcEus18xE7S9yJ2vRvDmJ8GHfaSd8y794T0vZ1BSsMVhl3XCH3LJYknfOxwun8hOWZ8WeeCIp/oYEE9u2GYRiGYRgeLODUMAzDMIxQMeXDMAzDMIxQMeXDMAzDMIxQMeXDMAzDMIxQMeXDMAzDMIxQMeXDMAzDMIxQMeXDMAzDMIxQsSRjhpFitm/fHrOkOwm/qAtDkiJN8nWlQjluarxQ2TTeaxmB9NckOKOUvBdSPO/YsUMSr5H8in4hCZO7wuaVyNKlS6UsAUmjNLGcQl0Sd0KneOem+lrJQCpwariEmVDMMMCSjBlGAJlkqbSZCDIKUtE2T548V+QY1KhRQ6rDojTEey0RZB6lAFzdunWdDh06RF/ne6jySXZSb65D6sy0b99eslxeqfCbyFqJsqnVY6nbMWTIEOknt6Lld25Q10oGst5OnDhRsoVqYTbDCAOzfBhGQJCu3FvkipLVCA2K5SFInnvuOUkjfymr4f8voGChgLRp0yb6GoXqmjdvLgoIhboo2EXqac6jYBvFuvr06SOpy0lnfSWC0KfkgHvsSGWONUHTbcc7N6hrJQPp/VFABgwY4IwZM+aSv8cwksWUD8MICGqMtGzZMqYbgjow1PehgmdglSMvM/xO6oqgSLhrslA/AsXjvvvucyZPnpyuxgmVibt06SLVbakvobVIriSwzARxbhCfjwXKDN/dsWNHp2nTpk6ZMmUCuY5heDHlwzAuA1hEUDgoNrZ///50ygcWEgpsUYSMGBGEdDyzOH5/rCkUuEOQU947S5YsvudSNGrnzp0SY0EMCm6fIkWKSBGsVENRLZQOigW60ZgYrCF+xdVq164tpd4pXY6VxKt8ZLR/iJW4cOGCfB+/lz6i1D0F1nB7+cWVnD9/3tm1a5dz6NAhEc7En7gLr8WKw8AKwee0XDljQtGxrFmzpjt38eLFEjuDu8TPDcN9QTs4P5lr0SfE0GAN8euPZcuWST/Ur19fCvcB51JcbOrUqaZ8GKFhyodhXAZOnjwpghC8FY0XLFjgDBs2TISIgpLwzDPPSMyEV0mgEiVxJggnBYHOd1StWjXNNfv16ydWBSpcukEYY2XInz9/yn7j77//7ixatEiEordyL0GOQB9QjdQPKtb6kUz/8JtQVKjoOnbsWBHSCgoXVhcqvyrEVeAKwzXmdaHxeWJR3N/N+SgQKATjxo0TlxHMnTtXDvoT5cN77vr166W6NYoTipHXWtStWzdRSFX5yOi1CNzlN/m5q1A6OnXqJL/bHUuDEkIlViof79mzJ/SKq8b/JrbV1jACYtu2bVLy233ggkBRqFevngjE7NmzOw888ED0M8R/dO/eXQQrK3OCNCnPjkBFqIwYMSLNNQgUfPnll0XxYHVOCXoEJf/HbYFVRcH1wYobYYuwYfWLgCPmghiL/v37p/T3r1q1yjl37pxTsWLFdO/hSkFBwjJCifeZM2dKECtWingk2z+A9YTXsQRRWhyFjN0hWA4I2FRQTFB4UDyKFy8ugp7+zJkzp7N161and+/ecdvGdyPYAfcFO4K8iqVC3+v4+SlX7nOSuRb/Ys2ZP39+us8w9owHwate6ENYsWJF3N9oGKnCLB+GERBM9hyxuP3222UFq1YBhB+KCS4GrwkcdworWYQ0vvncuXPLDhEVtqyUWfkrM2bMcIYOHeq89dZbolQgdG666Sb5js6dO4ulQCH2AmUEV0wqYXUPBQsWTPceAp2Vdt++fZ2NGzfKAfx2BH+lSpVE+GI1UJLtHwWFBgXI3debNm2SmJvVq1dHz8OygBuHWB138CXXHT16tLhJsBjFck9hdcGKgFKDEuAn5BXcRFibUNCwUtx4443yOmOKQsJYxQskjXetChUqSBwR40mQqtuVg9KFQuWlUKFC8i+fw/JjGEFjyodhhLDbBcG1cuVK2c2B4Hn66afF4uHOz4Cl5OjRo07hwoUl3oHDDWZ1TO18DztFvvvuOxGWrIDdigfwPp9Xvz/KxsCBA9O1EcFKDAjmf7cbIxVgTQGErB+Y9wk8Jf4DJWDz5s0Ss4DSwoEl45VXXhHrxqX0j1dYu10/xMSg/B0+fFhiKxDkquiw+ue6jB9jRUxMjx49nFSDS2XUqFHOkiVLom4Q4jdoE5ahS83dwXehRGD9UOWDvsJ6g5KJYuMFaxixOd4+NYygMOXDMELa7YI5v1WrViJgEahe4aLCGvcDLpJY4EZQiwW4V7cKcQF+bhRW9wgl4goIqMT1g/ANApQaXADeeA8vBQoUkEMVKOIO2EaKFQMXC0nHSIKVbP+48QsYReFSywjKR65cuURw4x6bNWuWHKo8Pfzww06LFi18g2MvFYJwsbDgSlLlQ10uGutxKWiQq7qouM+weug1YxGEAmoYsTDlwzBCgiBL3AUIAJJr8X93sKUGQ2ICV3++H/oegZSQ0RWyX/IzhCkWAwQ61plUQvv8dpMcO3ZMEovhGilXrpyvRQRLQ44cOaTNBNSifCTbP278+sivbYwLLhqUnw0bNshvQOmZNGmSCHAUN1VaMgvWBlwk69ati+5SYhcLihLxLJcKv5V7jLHGrUOOEBQRFJJ4W7rpD9xzKGP/zXlnjCsDUz4MI0Qw4RMgysq9a9euzrx585x8+fLJe2x31HiIwYMHJ/wuglXBHVQaa1slygXCCAFHTgeSenEdrBLEGZQvX16UD/5OVVpzzPtcn+BXd+wGAp3fT1/gcogVQ6FKhO7iSbZ/MmOx4qCd7B7BUkV8ClYi2ptsavl4YOFYs2aNpK1nJw07kmLt8kkG2sh4E3OEEoc75amnnopur/UDqwf3gykeRhjYbhfDCBlM7Kz4T58+ncY1gkJAbAZWAVbdXhCCuARwSwCrY/z0rJyJh3DDap1tlQScInCIDwEsLQRk4uZQxWPKlCmiJAAr31ShtWvYcusG5QHFAvcIlg2/a+IKQuC7lZBk+ydZ6CM+v2/fPvk/+TeIDSEXSYMGDeQ1YnbioYqbdytzLAgqJdiUPB4oCgj+eIGqGb0W1hP6i/gX4moSuVwYf8YhVnyOYaQas3wYxmWAgEa2chJgiPUD4YZ1gB0Y7FRh5wZxBsRzoCCgXGCSx0rA6hvY9cFqFlcOAZasohE6xJbgqkCYEKfgjnnQHQ+4NthlgdDTZFVAAi63lSIzlCxZUsz+BDp6d7z06tVLgm75rbQBpQhLCMIXCwNWG5QTFBVSgEOy/ZMs9BcWGaxDKABacwdlhv6kbezCiQfbloEcHrTFL8eJGxQcrCwoPfyNy0ctPIlIdK1GjRqJ+woXEuMdz1WF4gYE2BpGGJjyYRiXgbx58zpt27aV5FHDhw+X3BMIV1wxKAUIOxQFDRQEVshs+WSXhnsXB5YFBIwGSCoEu6qLgBU8ApWAxvfffz/NeQhbFBl2WeBmqFKlSkp+I6t6AirZRtukSZM079EelCa22qJsqJXDDYIQy4g7xiLZ/kkGLElYi2gzwa5uUAyof5LIMqCxGiRP4+C7UC7igeKJdQKrSrzcHslei+RlxLDgyklkTdGtzpmpE2MYyWDKh2GkGIQCQj9Rpkh8+5i7iS1AeDDxY5UgPwcWC0zmBCIifFFW2CbpTTOOS4Vsn1gEsDKwFRUlBmXGG7SIkoMQYksrKcuJGcEiwmqevBdkPnUn+UKQubOmxnotFgSyokDwO3AxedtOsCXX5LdjHSEQFRcCK39iUPyCLpPtn3gF3fzea9eunVgQ6EssSFgUsIBwrmZljfd5XB0oLriGcIuwgyZRO8hrghWIPool/JO5lruvsITwvSS1iwV9zjhwL1htFyMs/hXx1rI2DMNIEcSjIFhZgbtTehvBQ74SlCmyoY4fPz7meSgvJBYj54hfAjLDCAJTPgzDCBTiUthJgcvHdlIEC1YO3G+4cLCK4KIiJgTrSiyIF+I8XHdBFBc0DD/M7WIYRqCwLRZ3D0GV3tgPI7UQmzJy5Mio+wzFIp7iQWAvwaYUpjPFwwgTUz4MwwgUkokRb0IwqxEsWJYogEfuF3YbJXKjsK0Yl5hf/R3DCBJzuxiGYRiGESrm4DMMwzAMI1RM+TAMwzAMI1RM+TAMwzAMI1RM+TAMwzAMI1RM+TAMwzAMI1RM+TAMwzAMI1RM+TAMwzAMI1RM+TAMwzAMI1RM+TAMwzAMwwmTfwP2UMS7MuIrjwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: hcc_survival statistics phase complete\n", + "INFO: Running Statistics Summary for hcc_survival_copy\n", + "INFO: Running stats on Decision Tree\n", + "WARNING: findfont: Failed to find font weight bold, now using 400.\n", + "WARNING: findfont: Failed to find font weight bold, now using 400.\n", + "WARNING: findfont: Failed to find font weight bold, now using 400.\n", + "WARNING: findfont: Failed to find font weight bold, now using 400.\n", + "WARNING: findfont: Failed to find font weight bold, now using 400.\n", + "WARNING: findfont: Failed to find font weight bold, now using 400.\n", + "WARNING: findfont: Failed to find font weight bold, now using 400.\n", + "WARNING: findfont: Failed to find font weight bold, now using 400.\n", + "WARNING: findfont: Failed to find font weight bold, now using 400.\n", + "WARNING: findfont: Failed to find font weight bold, now using 400.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running stats on Logistic Regression\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running stats on Naive Bayes\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Saving Metric Summaries...\n", + "INFO: Generating Metric Boxplots...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAKQCAYAAABNdHpqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAT5RJREFUeJzt3Qd0VNX69/EnoaQQCL2ETpCigA0vgiAIUgQUVFSUq2JBbNgABQVRr4oNUC4q6FWRZgHsICIKKIgiCiIISG+hJrT0QPKuZ/s/8yaQwGTmTHYm+X7WyprJzJmTk5PJzG92eXZIVlZWlgAAAFgSausHAwAAKMIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKtK2v3xhdvKlStFa8KVKlXK9qEAABBUMjIyJCQkRM4///wzbkvLyGloEKFAbf7pOUtPT+fcIeB4rqGg8FwL7HsoLSOn4bSING/e3Ic/Q/GVnJws69atk4YNG0pkZKTtw0ERxnMNPNcKrz///NPrbWkZAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVJe3+eAAA7NgbnySJKRlebZuamipb9qRKWPRRCQ9P9+oxURGlpHqlMn4eZfFAGAEAFDtHEtNk4OgFkpmVzwcuPOj1pqGhITJlVFeJjgrL9/EVN4QRAECxowFh0vDLvW4Z2bwzXibMWiP392kmsbUred0yQhDxDmEEAFAs5acLRbtpVM0qZaRhrfIBPKriiQGsAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMCqklII7NmzR2bPni0JCQnStGlT6d27t5QqVeqMj0tMTJSXXnpJypUrJ0OGDPHcrrcdOXIkx7YtW7aUq6++OiDHDwAAgjiM7Ny5U/r06SOHDx/23DZ//nx5++23z/hYDR0fffSR1KxZ0xNGUlJS5L333pPMzMxTtieMAABQ+FgPI6+99poJIueee65cdtll8r///U9++OEHWbx4sbRv3z7Pxy1btswEkZP9/fffJog0a9ZM+vbt67m9fv36AfsdAABAEI8ZWbRokbkcNWqU3HPPPXLdddfluD03SUlJ8sQTT0hYWNgp961bt85camvJ5s2bZe/evdKmTRvTTQMAAAofq2HkwIEDcuzYMXM9NjY2x+W2bdtO2z2ze/dueeCBB065b/369ebym2++Md01EyZMkF69esmmTZsC9FsAAICg7aZxgkhoaKiEh4eb6xERETnuO9nPP/9sume6detmvl5++eVcw4i2hrRr184MjNUg8sILL5guoPzKysqS5OTkfD+uONNxO9kvAZ5rCHZpaWmeS94TvH//DAkJKfxhxDlIPWCHM/BUA8rJ9Amg3TMVKlQw3Tq5PSFefPFF2bhxoxl/UqJECbn44ovNwNXly5ebfee239PJyMjwdP0gf07XugW4iecaAi0uIf2fy7g4kdSDnHAvlS5duvCHkejoaE8Y0XEgZcqU8bSIlC9f/pTtZ8yYIbt27ZLGjRvLmDFjPGHk0KFDJqTceeedZmCrduF06tTJM3Yke5qNiorK1zHqFOOGDRv6/bsWJ9oiom8O9erV87R0ATzXENS2HhCR/RITEyNN61exfTRBIT/DI6yGkYoVK0qlSpUkPj5eVq9eLa1bt5Y///zT3KeB42ROUNmwYYP5cmjImDVrltxwww0yfvx4E07atm1r9vfbb7+ZbapUqZLvIOK03kRGRvrxWxZfGkQ4d+C5hqLAmTChl7yuecfbLppCMbW3S5cu8sEHH5g6Ic2bNzdTevUXuOKKK8z9kydPNt0uGjQ6d+4stWrV8jxWQ4e2kGgrij5e79PBqvoYHdyq40Z0mrC66aabrP2OAACgEIeRBx980LSKrF27VhYuXGhuu/fee+Xss88213/88UdZsmSJCRY9evQw9UMc2mWjYUS7d5wpwRpCtNVEu2vmzZtnbrv88stlwIABVn4/AABQyMOIDkb9+OOP5ZdffjFTfTWENGrUyHN///79zayZFi1a5PrYZ5991oQRh17XKb0acLZv327GLeT2WAAAUDhYDyOqZMmScskll+R6n07PzUv2FpHstJtHK7rqFwAAKNysV2AFAADFG2EEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFaVtPvjESz2xidJYkqGV9umpqbKlj2pEhZ9VMLD0716TFREKaleqYyfRwkACEaEEZzRkcQ0GTh6gWRm5fNkLTzo9aahoSEyZVRXiY4K4y8CAMUMYQRnpAFh0vDLvW4Z2bwzXibMWiP392kmsbUred0yQhABgOKJMAKv5KcLRbtpVM0qZaRhrfKcYQDAaTGAFQAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhV0u6PBwDAPXEHEiU57bjrp3T3gSTPZXj4Ydf3HxlWUmKqRElxRRgBABSZIDLwhe8C+jMmzFoTsH1PGtap2AYSwggAoEhwWkQG33SB1KpW1tV9p6amyroNm6Vp41gJDw93dd+79h2TMTN+D0iLTrAgjAAAihQNIg1rlXd1n8nJyZJ2JFwaxJSTyMhIV/cNBrACAADLCsVsmoULF8ott9wiPXv2lKFDh0pcXJxXj9uxY4d069ZNbr75Zlf2BwAAimE3zbJly+Tee++VzMxM8/3GjRtl5cqV8tVXX522Xy4rK0sef/xx2bp1q6Snp/u9PwAAUExbRiZNmmSCQ58+fWTGjBlSp04d2blzp8yZM+e0j5s2bZr8+uuvru0PAAAUwzBy/PhxWbFihbl+9913y4UXXii9e/c23+cWNBwaLsaOHSvVqlVzZX8AAKCYhpH9+/dLRkaGuV6jRg1zGRMTYy537dp12u4ZfdyTTz7p9/4AAEAxHjOSkpJiLkuUKCElS/5zKKVKlfJMo8qNdr0sX75cBg0aJE2aNPF7f2ei4cfXxxZXaWlpnkvOHQLJ+Z93LlG8aS0Q59Lt155APtdSA3jcNun7Z0hISOEPI05QOHHihOegtatFlS5d+pTttXXjlVdekaZNm8rAgQNl3759fu3PG9rSsm7dOp8eW1zFJfwzoNjMYko9aPtwUAxs27bN9iGgEL326MSGtCO+vebbeK7FFcBx2+Lte6/VMFKpUiXP9UOHDknFihUlISHBfF+1atVTtv/kk09MatyzZ490797dhA6loaRz584mqORnf97QgNOwYUOfHltsbT2gnWami6xp/Sq2jwZFmH5K1TeHevXqSUREhO3DgWVhcUfNa0/9+vVNcbJgea6FBfC4bdq0aZPX21oNI2XKlDF/WP0Df/fdd3LttdfK4sWLzX3Nmzc/ZXsnfBw+fNh8ObT1Q2uOhIaG5mt/3tDWFart5U9YWJjnknOHgqBvDjzXEB7+TwuDlnEI1PMhEM+18AI4bhu87aIpFFN7dQquGjFihFx00UXy888/mz/GVVddZW4fPny4afVYtGiR3HbbbTJ//nzP19SpU802OqtGv2/cuPEZ9wcAAAoX60XPbr/9dtPN8uGHH0piYqJUrlxZnn32Wc+0XZ0ho60eSUlJUr58efPl0IGqSger1q1b16v9AQCAwsV6GNFAoa0YjzzyiBw5csSM7XBChho9erTpq9NQcbLq1aubFhFn5ow3+wMAAIWL9TDi0K6U3PrKTjfwNHuLiLf7AwAAhYv1MSMAAKB4I4wAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwqqQ/D165cqUsWrRI9u/fL0OGDJGlS5dKhw4dpFy5cu4dIQAAKNJ8ahnJysqSESNGSN++fWXSpEny6aefSmJiokyYMEF69eol27Ztc/9IAQBAkeRTGPnwww/l22+/lTFjxshvv/0mtWvXNre/++67Uq9ePXn66afdPk4AAFBE+RRG5syZIyNHjpSePXtKmTJlPLfXqlVLXnvtNRNQ0tLS3DxOAABQRPkURhISEqRBgwa53qfjRTSg6DYAAAABCSPaLTNv3rw8B7WmpKRI5cqVfdk1AAAoZnyaTXPjjTfKPffcI/Hx8aar5vjx4xIXFyfLly+XcePGmUGspUqVcv9oAQBAkeNTGNHpu4899pgZwDpr1ixzW//+/XPcBwAAENA6Ixo+tFVEa4tonZHIyEg599xzpVmzZr7uEgAAFEM+hRGtLdKiRQtp3bq16ZIBAAAo8Km9ISEhPv9QAAAAv8JIzZo1ZceOHb48FAAAwP9umjZt2shTTz0lc+fOldjYWKlUqdIp2/Tr10+io6O93qfOyElOTvZ6XZv09HTzGB2rcjKtcXLixIkct0VEREhUVJTXxwMAAApxGJkyZYp5s1+2bJn5yk2PHj28CiO6zo1OB9Z9an0SreL6n//8xwSe3Bw5ckSefPJJ+e6770wYadiwoQlGLVu29GzTtWtXOXr0aI7H9enTR5577rl8/64AAKAQhhFdl8YtM2fONANildYm2bVrl9x3330yf/58qVKlyinba/DQgmslS5Y022/cuFEGDBhgxrHExMTI7t27TRDR+7KHobJly7p2zAAAoBBM7c3MzDSh5IcffjDFz7R7Raf2XnXVVfl6458xY4a51FWAb7jhBjNlWNe2+fLLL+X2228/5WcePnxYGjduLG+99ZaUL1/ebK9VX7XgWu/evWX9+vVm22uuuUaGDRtmQgkF2AAAKGJhRLtHBg0aJN9//72Eh4dL1apV5dChQ/L555/LO++8YwJG9erVz7if1NRU2bBhg7nerVs3KV26tHTu3NmEkT/++OOU7UNDQ+W9994z17VL56+//pI9e/aY7521cpwwsmjRIvn444/NPnX8ytChQ83jAQBAEQgjGjZWrFgh48ePly5dunim+a5du9as5vvss8/KhAkTzrifAwcOmNYO5QyCrVChgrnct2/faR+rlV/152jAeOKJJ0zdk+xhRB+vQUkDz7vvvmvC0a233prv31XHtOjAWnjPWbFZLzl3CCT9UJL9EsWbvt47l26/9gTyuZYawOO2Sd8/vS0D4lMY0fEcWvJdB4pmd84558gbb7whl19+uXkjCgsLO+OMGFWiRAlPq4WOBcl+X140bOhMGv3DffTRR3LZZZeZBfxq1KghjRo1kuHDh5tBsHo8r732mmlR8SWMZGRkyLp16/L9uOIsLuGfv52uVySpB20fDoqBbdu22T4EFKLXnq1bt0rakdJB81yLK4DjtkV7JwIWRnRGy9lnn53rfdoCoWNGdHqtBoPTccKKzszRLw0lTgjRqbh50W0efvhhGTJkiLz88svyv//9T55//nl588035fHHH88RhPr27WvCiHbnaHDJbSrw6eh4E52xg3zYekBE9psBxU3rnzoIGXCLfkrVN4d69eqd9jUDxUNYnM6i3C/169eXBjHelYkoDM+1sAAet02bNm3yelufwoi2QOiU3twCiXaTJCYm5lp75GQ61kQDiAYRbenQNy9nDIgWVjuZ3nf99debVhQdE6IuvfRSE0Z07ImGEG2t0bVy9Ph0No3T5KWh4kwtNbnRJqb8BpjizjnPesm5Q0HQNweeawgP/+fDrHbRB+r5EIjnWngBHLcN+anU7tOIzuuuu05effVVM6NFm+J1QKvOqNEiaPfee690797dq6YZ3cZZWE8HvmqQ+eqrr8z3F110kacVRseWaNDQVhcdY7J3714zHVibtJwBrZpW9c2vcuXKJty88MIL5v6xY8d69qfBBwAAFC4+hREdn/Hvf//bvNHrdR0rouMztOtEu2Z0mq637rzzTnM5bdo0s+jeli1bTKuIFk1TjzzyiLRt21YWLFhgUpZ2zSgtlKYzcBYuXGhCjc7uUYMHDzbbffLJJ+Z+rT+irSJ6bAAAoAjVGdEBrFrV9McffzStImXKlDF1Ri6++OJ8Nc3obBwNFtrCcfDgQdP18+ijj3qaqrSWiLZ2OE3/V199tbmcOnWqHDt2TJo0aSIPPPCAnHXWWeZ2XUlY96WtNtu3bzd9cNpa48y2AQAARSSMKF2XRt/snZkwOmjVl9V8tVtHv3IzZsyYU27TQOKEktxoINEvAABQ+PlcBWz27Nmmi2bnzp2e22688UbTXZKUlOTW8QEAgCLOpzCi4zd0sboOHTrkmDWjVU510KhOswUAAAhYGPnggw/MINVRo0ZJVFSU53YtdqazYnRdGZ1hAwAAEJAwonU8dLBqbqpVq2aKnulgVAAAgICEEZ16u2TJklzv+/vvv80sl4oVK/qyawAAUMz4NJtGp/Q+9NBDpiCZTs2tUqWKKUqmK+1q6fWrrrrK63r0AACgePMpjOjYEA0jWoVVS7Fn16lTJ7M+DAAAQEDrjGjlVC0Lv3z5cjOGROv1a2ExFpUDAAAFVvRMF6Lr3LmzCSNr1qwxa8IAAAAEbACrln7X8SDZC5198cUXpmvmnnvuMffp2jDp6f+sQAgAAOBaGNm8ebMJHLrEsa5Do/bt22eKn1WoUEEmTJgg48ePl5UrV5paIwAAAK5203z44Ydm5oyu1Ov4/PPPJSUlRV588UXTXaO0IquurKvBBQCAAlUqVXYn7pbQhKOu7jY1NVX2ph6UiMO7JDw13NV97048Zo67OPM6jPz5559mBs3J3Ta6uq6uUeNo2bKlWZvm0KFDpsUEAICCUrLqTnn9j0WB+wG7ArPbklVjpTjzOoxoTZHKlSt7vte6IqtWrZI2bdqcUlNEZ9bo/QAAFKTj+2vLQ92vkNpVy7reMqJrr+lK9TpcwU079x+TV1aukeLM6zBSrlw5iY+P90zdXbFihRmoqmHk5NCSkJBAqwgAoOBlhEvNqJrSoGJ5V3ebnJwsKeHHpF75WqZHwE2ZyYdFMjZJceb1ANbzzjtPPv74Y8nKyjLff/TRRxISEiIdO3bMsd3UqVOlcePGEhYW5v7RAgCA4tsycsstt8iVV14pV199tYSGhsratWulZ8+eUrt2bXO/dtnoNN8ZM2bkGOQKAADgSsuILo6nrR66Kq/2nd18883y3HPPee4fOnSozJ4921x2797d290CAIBiLl8VWM855xyZNGlSrveNHj1aYmNjGSsCAAAKrhx8djqlFwAAwFoYAQCgMNi864jr+9ThCVv2pkpY9FEJD3d3yZNd+45JcUcYAQAUCZmZ/8z2nDBzVeB+yPcHA7bryLDi+5ZcfH9zAECR0qhOBRnz4KUSGhri+r4374yXCbPWyP19mkls7UoBCSIxVaKkuCKMAACKVCAJBO2mUTWrlJGGtdwtqIZ8TO3NTmfULFu2jPMHAADshJE5c+aY6qsAAABWwogWQNuxY4ffPxwAAMCnMSO6ON5TTz0lc+fONYXOKlU6dTBPv379JDo6mjMMAADcDyNTpkyREydOmHEjeY0d6dGjB2EEAFBo7Y1PksSUDK+23X0gyXMZHn7Yq8dERZSS6pXK+HWMxYVPYeTbb791/0gAACggRxLTZODoBfJ/pUm8ptN7vaVTjKeM6irRUaxiH9CpvStXrpRFixbJ/v37ZciQIbJ06VLp0KGDlCtXzp/dAgAQUBoQJg2/3OuWEZ3au279ZmnaJFbCw8O9bhkhiAQwjGRlZcnIkSNl5syZnlk1d999t0yYMEHGjRsn7733ntSrV8+XXQMAUCDy04WSnJwsaUfCpUFMOYmMjAzocRVHPs2m+fDDD01XzZgxY+S3336T2rVrm9vfffddE0Kefvppt48TAAAUUT7XGdGWkZ49e0qZMv8/WdaqVUtee+01E1DS0tLcPE4AAFBE+RRGEhISpEGDBrnep+NFNKDoNgAAAAEJI9otM2/evDwHtaakpEjlypV92TUAAChmfBrAeuONN8o999wj8fHxpqvm+PHjEhcXJ8uXLzcDWHv16iWlSpVy/2gBAECR41MY0em7jz32mBnAOmvWLHNb//79c9wHAAAQ0DojGj60VURri2idEZ3qdO6550qzZs183SUAACiG/Cp6puNCtEsGAAAg4GFk8uTJ0rt3bylfvry5fujQodNuf9ttt5ltUXjFHUiU5LTjru/XlzUc8iMyrKTEVIlyfb8AgEIeRrTQWceOHU3A0Os7duw47fbXXnstYaSQB5GBL3wX0J+RnzUc8mvSsE4EEgAobmEk+1TevKb1Ing4LSKDb7pAalUr6+q+zRoOGzZL08ber+HgrV37jsmYGb8HpEUHABBEY0YmTZokLVq0kNatW7t/RChQGkQa1nK3O401HAAABVIO3lkgDwAAoMDDSM2aNc84ZgQAACBg3TRt2rSRp556SubOnSuxsbFSqVKlU7bp16+fREdH+7J7AABQjPgURqZMmSInTpyQZcuWma/c9OjRgzACAAACE0a+/fZbXx4GAADgbgVWx5o1a+TgwYNSv359qVu3rhu7BAAAxUS+wsiKFStk2rRpUq5cObnvvvvMyrwDBw6U1atXe7a57LLL5JVXXpGoKCpkAgAAF8PIH3/8YRbHCwsLM4viaTBp3LixaRW54YYbzCJ527dvlxkzZshLL70kzzzzjLe7BgAAxZjXYWTq1KnSpUsXeeGFF6R06dLy0UcfyZNPPin333+/DBo0yLNdp06dzLo0OtsmNNSnmcMAAKAY8TotbNq0yUzX1SCitDWkbNmy0r59+xzbaQuJdtEcOHDA/aMFAADFN4xoie8KFSrkuE3riOj4kZNpV05aWpo7RwgAAIo0r8NIVlaWlChRIueDQ0PzLAuv2wMAAJwJgzoAAEDwTO0dMmRIjiXh9+3bd8ptzu0AAACuhpGYmBiJi4vLcVu1atXk8OHDp2yrt2sNEgAAANfCyPvvv+/tpgAAAF5jzAgAAAj+tWn8lZmZKatWrZKEhART1bV27dqn3T49PV1+//13M324adOmUrVqVb/2BwAAinEYSUpKkgEDBshvv/3mmS780EMPmTVvcrN+/Xpz3969e833OjblkUcekdtvv92n/QEAgGLeTTNp0iQTHLSA2r/+9S9Tn+TVV1+VDRs25Lq9lpnXINKoUSNp2bKlHD9+3KyFs3btWp/2BwAAinkY+fLLL83lyy+/bNa/6dmzp+lmmTt37inb6u2XXHKJ3HzzzfLpp5/K9OnTpV27diZwOGEjP/sDAADFPIwcPXrUM134ggsuMJfnn3++pzvmZNrloovyjRgxQvbs2SMTJ06UX3/9VSIiIkwrSH73BwAAivmYER1gqrSkvC66p5zLQ4cOnfax8+fPl3HjxpmAMmbMGKlVq5Zs27bN5/3lRVtddF2eoiY1NdVz6fbvl5KSkuMyWI4bwSeQzzWA55p/9P0zryVjClUYOXHihLnMfrAaLrLflxet+tqhQwf56aefZNiwYWYRP2dWjS/7y0tGRoasW7dOipq4hHRzuXXrVkk78s9KzG5zwmGwHTeCTyCeawDPNf+VLl268IeRqKgoc6ljOnS6rh6082nXadHITrfbsWOHaVHp16+f+frkk09k+PDh8tprr5mv/OzPGzpbp2HDhlLUhMUdFZH9Ur9+fWkQc+rKy/7QT6n65lCvXj3ThRYsx43gE8jnGsBzzT+bNm3yelurYaRKlSqmhUOb3PWTrtYE0UulLy4n279/v3Tt2tUEiyVLlpjHVqpUyXNffvfnDW1liYyMlKImPPyfFgY9X4H6/fTNwe19F8RxI/gE4rkG8Fzzj7ddNNYHsGoXSuvWrc31Z5991pSc15YO1b59e3O5fPlymTNnjhmYWr16dVPk7NixY6Z2yEcffSTPP/+82e6iiy7yan8AAKBwsV70TEOFBg7nS2mg0PEgTt0QbQUZO3asWazv6aeflltuuUUWLlxovlTdunVN4TNv9gcAAAoX62GkSZMm8tlnn5lWjoMHD8rZZ58tffv29TTvtGrVSsqVK2eCiDr33HNNa8esWbPMVF59/HXXXWea7b3ZHwAAKFyshxFVp04dGTp0aK733XXXXafcFhsbK4899phP+wMAAIWL9QqsAACgeCOMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCophcCBAwfks88+k4SEBGnatKn06NFDSpQokef28fHxMmfOHNm3b5/UrVvXbF+mTBnP/a+99pocOXIkx2POP/98ufLKKwP6ewAAgCAMI7t375brrrvOBAzHvHnz5I033sh1+99//10GDhwoR48e9dym23700UdSrVo1SU1NlYkTJ0pmZmaOx6WlpRFGAAAohKyHkfHjx5sgcs4558ill14q77//vnz33XeyZMkSadu27SnbP/vssyaI/Otf/5J27drJhx9+aALN66+/Ls8884z8/fffJoicffbZcu2113oe17BhwwL+zQAAQFCEkYULF5rLp59+Wpo3by7JyckmkOjtJ4cR7cZZu3at6cKZMGGCREdHS40aNWTIkCGyadMms8369evNZf369U33j3bf9OrVy7SaAACAwsdqGDl48KBnbMdZZ52V43LLli2nbK/BQoOKhhINIsrp3qldu3aOMKJjShzvvPOOaUHRgAIAAAoXq2HEGfcRGhoq4eHh5npERIS5PHbs2Cnbh4WFycUXX+z5fvv27TJp0iTz+H79+uUIIy1btjQtKzowdtu2bfLiiy+asST5lZWVZVprihodW+Ncuv37paSk5LgMluNG8Ankcw3gueYfff8MCQkp/GHEOUg9YIcz8PRMv8DmzZulf//+ppXkwQcflBYtWni6ezZu3CidO3eWUqVKmUDSp08fWbZsWb5OjCMjI0PWrVsnRU1cQrq53Lp1q6QdKR2Qn6EhMBiPG8EnEM81gOea/0qXLl34w4jT1eK0PkRGRnpaRMqXL5/n47T1Q4PIoUOH5L777pN7773X3J6eni6rV682A1qvuOIKc1udOnU8n6STkpIkKioqX8eogaYoDn4Ni9NWqf2m66pBTDlX962fUvXNoV69ep6WrmA4bhQO+xKSJSn1uFfb6iy5LVt3SYP6tUzLqTfKhJeUahUj/TxKFDeBfF0rqpyxnIU+jFSsWFEqVKhgQsWff/4prVq1MgNUVaNGjXJ9zM6dO+W2224zjxk8eLDcddddOYLDSy+9JIcPH5bWrVvLRRddJKtWrTL3Va5cOd9BRGlLioakoiY8/J8WBu0eC9Tvp/+wbu+7II4b9hxJTJOHXl0qmf+/sdQ7Cw96vWloaIhMGdVVoqO8Cy9AoF/Xiqr89ERYn03TpUsXUyNk6NChct5558mCBQvM7d26dTOX06dPN10yOk1Xp/8++uijpmumbNmysnfvXjOdV8XExMidd95paolMnTpV7r//fmnfvr18//335v6+ffta/C2B4i3uQKIkp3nX2jG8/78kxcttd+07Ih9/t1mu7xQrtar909J6JhFhJeXA4RTzdSaRYSUlpkr+P8QAyB/rYUTHe6xcudLUB/nmm2/MbRoqdJqv0jChNUcuvPBCM55Ei54p7c7RoOLQoKKPe+ihh+Svv/6S3377TT7//HNzn9Yv0UJpAOwEkYFj5khIqbSA7D8kUmTmsn9eF9yWlREmkwb3IJAART2MVKpUSWbPnm0Ch0711WJlzZo189yvs2Quu+wyEzZOnDghI0eOzLPLR2lXzLRp02TFihVmto2OLdAgk9+BqwDcoS0iJavulFI1NwfdKc3YHet1iw6AIA4jzmjbjh075nrfybfHxsaecX861VcrtOoXAPuO768tD3W/QmpXLevqfnVgus6s0g8dTnkAt+zcf0xeWbnG1X0CKMRhBEARlxEuNaNqSoOKec+S84XOwksJPyb1ytdyfVBhZvJhkQzvZwMA8F2oH48FAADwG2EEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFav2AigQm3cdcX2fqampsmVvqoRFH5Xw8HRX971r3zFX9wcgb4QRAAGVmZllLifMXBW4H/L9wYDtOjKMl0kg0PgvAxBQjepUkDEPXiqhoSGu73vzzniZMGuN3N+nmcTWrhSQIBJTJcr1/QLIiTACoEACSSBoN42qWaWMNKxVPiA/A0DgMYAVAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYxaq9AAqVvfFJkpiS4dW2uw8keS7Dww979ZioiFJSvVIZv44RgLsIIwAKjSOJaTJw9ALJzMrf4ybMWuP1tqGhITJlVFeJjgrL/wECCAjCCIBCQwPCpOGXe90ykpqaKuvWb5amTWIlPDzc65YRgghQuBBGABQq+elCSU5OlrQj4dIgppxERkYG9LgABA4DWAEAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFaxUF5xVipVdifultCEo67uVldS3Zt6UCIO75LwVO9WUvXW7sRj5rgBAEUHYaQYK1l1p7z+x6LA/YBdgdltyaqxgdkxAMAKwkgxdnx/bXmo+xVSu2pZ11tGtm7dKvXr15fwcHdbRnbuPyavrFzj6j4BAHYRRoqzjHCpGVVTGlQs7+puk5OTJSX8mNQrX0siIyNd3Xdm8mGRjE2u7hMAYBcDWAEAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGBVoSgHv3TpUpk8ebLEx8fL2WefLYMGDZJq1aqddvsPPvhA9u3bJ3Xq1JHbbrtNmjVr5vP+AABAMQ4jK1askAEDBsiJEyfM92vXrpVff/1VvvzySylduvQp28+cOVNGjBjh+X716tXy9ddfy4wZM+S8887L9/4AAIBd1sPIm2++aYJDr1695Oqrr5YnnnhCtm3bJnPnzpXevXvn2DYrK0smTJhgrmtrSLdu3WTcuHHy888/m5aQV199NV/7g8jmXUdcPw26au+WvakSFn1UwsPTXd33rn3HXN0fAKCYhxENDcuXLzfX77vvPqlbt65cc8018t///ld++eWXU8KDdsscOHBAwsLCZPDgwVKqVCnp16+fCSP79+/P9/6Ks8zMLHM5YeaqwP2Q7w8GbNeRYdZzNADAJVZf0TVApKf/88k5JiYmx+WuXbtO2b569eqmW0bHgmgQUatW/fNmeu655+Z7f8VZozoVZMyDl0poaIjr+968M14mzFoj9/dpJrG1KwUkiMRUiXJ9vwCAYhhGkpOTzWWJEiU84cIZ15GUlJTrY0qWLOkZjLpgwQJ5//33JSoqSvr37y+JiYn53t+ZaNeQc5xFTa3KYQHZ75Ej/zytKpcrKTEVAzNOp6j+TZA/KSkpOS6BQOG55tv7Z0hISOEPI05g0O4V56CPHz9ubjvTYFMdA/Loo4+ax4wdO9YElLS0NJ/3l5eMjAxZt26dT48truIS/mmdiouLE0kNXFcN4NBxYUBB4LmWP96+91oNIxUrVvRcP3z4sFSoUMFcqipVquT5uM8++0yGDx9ufkkd0NquXTu/9nemwNSwYUOfHltsbT2gnXCmi6xpfd/OO+Dtp1V9c6hXr55ERERw0hAwPNfyb9OmTV5vazWMaPeK1gnZsWOHLF682MyA+fHHH819zZs3z/UxWkPk8ccfN10xEydOlNatW/u1vzPR1pXIyEifHltc6QBj55Jzh4KgQYTnGniuFS7edtEUigqsOttFDRs2TNq0aSNLliyR8PBwufLKK83tTz75pPTs2VN++OEH02WiNUa0G0bHjjz33HPmPv16+OGHvdofAAAoXKzPj9QCZXv27JFZs2ZJQkKClC9fXv7zn/9IjRo1zP27d++WjRs3yrFjx8z0XDMO4f+azPT2k/ulzrQ/AABQuFgPI9rC8cwzz8iQIUNMeNBxBtkHvOh9OhNGw0RmZqappJobbf3wZn8AAKBwsR5GHOXKlTNfJ6tZs2aO76Ojo/3aHwAAKFysjxkBAADFG2EEAABYRRgBAABWEUYAAIBVhBEAAGBVoZlNg8Jtb3ySJKZkeLXt7gNJnsvw8H/K8Z9JVEQpqV6pjF/HCAAIToQRnNGRxDQZOHqBZGbl72RNmLXG621DQ0NkyqiuEh0VmJWEAQCFF2EEZ6QBYdLwy71uGUlNTZV16zdL0yaxnmJ03rSMEEQAoHgijMAr+elCSU5OlrQj4dIgphyLlwEAzogBrAAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAqpCsrKwsu4dQeP3++++ip6d06dK2DyWo6DnLyMiQUqVKSUhIiO3DQRHGcw081wqv9PR08x5wwQUXnHHbkgVyREGKN1LfzxsBDgWB5xoKCs81386Zt++jtIwAAACrGDMCAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKhbKg2tWrFgh06dPlzVr1kjFihVl7NixsmjRIunXrx9nGa7atGmT/P3332Z16OzKli0rHTt25GzDFSdOnJDFixeb51RaWpq88MILsn79eunZsyevay4jjMAVn332mQwbNsws6a5KlCghqamp8swzz0iVKlWkS5cunGm44qWXXpJ33nkn1/vq169PGIFrnn/+eVm6dKl5TukHrRkzZpjbf//9d6lcubJ07dqVs+0SumngyqcH/cSgQeTJJ5885f7Zs2dzluGK9PR0mTJlirmuIfeSSy6RDh06eL5atWrFmYZrz7WZM2d6vp8/f77Url1b7rjjDs8HMLiHlhH4bc+ePXLo0CGpWrWqXHzxxZ7bMzMzPfcDbti/f7/pmomMjJR58+ZJVFQUJxYBceDAAdM1o44fPy5r166V3r17S69evUzLHK9r7qJlBH7TN4SQkBA5cuSIHD582HP7X3/9ZS51/Ajghho1apgWkVKlSklYWBgnFQETHh5uLhMTE2XDhg2mpaR58+ZSsuQ/n+EjIiI4+y6iZQR+K1++vGkiX7hwoQwYMMDctnv3bk+XTffu3TnLcK1L8MYbb5Tx48fLvffea/rsy5QpY8KwE4zbtm3L2Ybf9ENU9erVZe/eveZ1TZ9j2i2oY+HUOeecw1l2UUiWM+IQ8IN204waNUq++eYbz22lS5eWW2+9VQYPHux5swD8sXnz5tOGWx3Aqt03gBsWLFhgXr+0u2bgwIHy8MMPm+egBmIdC6djSOAOwghcpf2oW7duNbNpGjVqJBUqVOAMw9Xn1/Dhw0/bjTN69GjOOFyjLSEaRqKjo833x44dM18xMTGcZRcRRuAa6owAKGp4XSsYjBmBK6gzgoK0ZcsWM6Nh3bp1ZmZNu3bt5JZbbmFQIVzF61rBYTYN/EadERSkVatWybXXXiuzZs0y0y1//fVXU+335ptvlpSUFP4YcAWvawWLMAK/UWcEBempp56S5ORkU+Bs3LhxZuC0Tvf9888/ZfLkyfwx4Ape1woW3TTwG3VGUFDi4+M9XTNvvvmmmdartDT3oEGD5IcffpB77rmHPwj8xutawaJlBK7VGdER59QZQSA5FTE1hDhBRFWrVi3H/YC/eF0rWIQRuEKnU2oBqqSkJPO9VivUcvAaTq677jrOMlyhoUPfJLRUty5cpmWS9Dk3ceJEc3+TJk0403ANr2sFh6m9cIW+OWi/PXVGEGhvvfWWjBkzxlOSW4OvDjbUEvE6qJVAAjfoYGj90kqsvK4FHmEEftO1G3SBvLPOOssssc2aDQgkbQ3R8SI6tVefe6pWrVoycuRI010IuEErrV511VWmBHzPnj3l8ssvN2OVEBiEEbgyqLBNmzbmE8SyZcs4oygQOj5k586dZkGzmjVrsuQAXKXPrSuuuMKsEq30Q1anTp3kyiuvNAFFW+LgHsII/KbLa2uJ7i+++EKuvvpq8+lUSyeHhoZ6/olbtGjBmYZPtPVj8eLFZnbDhRdeaK7nRbdp3749Zxqu0LLv33//vXz77beyZMkSTx0bHbekY+S0tURbhXUdLviHMAK/sXgZCuL5pYvgvf766yyUBys0iHz99dfy0ksvmYVBHfXq1ZO3335b6tSpw1/GD9QZgd/CwsJOO2hQ+/MBX+kU3rZt25pF8JzredFtADcdPXpUvvvuO7Mi+dKlS82AaaUr9upMrm3btsn48ePllVde4cT7gZYR+GT79u1y0003Sd26dc2gVQAoShISEuTRRx+Vn3/+2TNupFy5ctKtWzfp3bu36TLULmqd2aVj5XQdG/iOlhH4RP8JDx48KGXLluUMokDpNF4dN9KxY0cziPWFF16Q9evXmxkP/fr1468BV2hXzI8//iglS5Y045A0gOgAVm0Jduh9PXr0kF9++YWz7ifCCICg8vzzz5vmcg0jWvjMaZn7/fffTVl4HVgI+EsHQw8bNszMntHnVV50LBNrIvmPMAK/7Nu3T+64447TbqP9+M8++yxnGn7T/vqZM2dKTEyM+X7+/Pmm775Lly6m7og2lRNG4Fa13z59+pjnW1xcnGkNDgkJ8Ywj0de+adOm5ViWAL4jjMAvunqqTnk7Hf3kALhV6ddZf0bfHNauXWuaz3v16mXCiFbKBNzy0EMP5fn6xuuauwgj8EulSpXkrrvuOu02OicfcIMWOHNqj2zYsMG0lDRv3tz03Suq/8LNGiPaHaitIdr6+8EHH8gDDzxgWkO0CjBdM+4ijMAvOrq8f//+nEUUCK3yW716ddm7d69ZhFHfKLQaZmpqqrn/nHPO4S8B1wawaujQ0gRDhw41U3uvueYaadiwoQknH374oWk5gTtYtRdA0NDwoWvQaAuJTr0cOHCgKQWvtOrvrbfeavsQUYQGsCqn7LtWkf711189laVPVwkY+UfLCHyiU3q19Luu1AsUJC3BrVMpdeyIBhBVtWpVM3jVGdgKuNEKl31cSMuWLU3dEWcQ6+lm2CD/aBmBT/TFX+s7DB48mDOIAq8z8tNPP5kgooHk6aefNuOWFi5cyF8CrtLS7zpbS+lAab2uY0l09V5tlYN7qMAKIKj85z//MQML582bJ++++668+OKLnvu0LDdTexEoOmBaZ3Bp5WltOYF7aBkBEHR1RhxOnRGn1g0luREoOmj6t99+M63CBBH3EUYABHWdkdatW5s6I4o6I3Aj8Op6M7fffru88cYb5nk2YcIEU/FXZw7qpc6ucRbMgzsYwArXaO2HXbt2eRaVcujMh7POOoszDb9RZwSBNmrUKPnkk0/Mde0O/OOPP2TRokWemTX6+vbFF1+YKb6MG3EPYQSu0IJA2nefkpJyyn06Il379wF/UWcEga4o/eWXX5rrWkNkxYoVniCirSM6k2vcuHEyadIks4geYcQ9dNPAldkNOupcg4hWwtS1aOrUqeP5cupAAP6izggCKT4+3rR86GvYPffcY76UjhPp3Lmzef51797dsz4N3EPLCFwZ2KWfKEqXLi1z5871TIUDAoE6IwgUp4vZ6Q6sUKGCucy+GJ5TBE0/hME9tIzAb1r4TKsVaml4LZ0MBNqaNWvkqaeeMp9Wb7jhBvMplToj8JeWf/dWZmYmJ9xFtIzAb9oicv/995siaM8995xpxtRPEk6lQr2/Xr16nGm4QqfvDhs2zPPGUaJECbM2zTPPPGOCcZcuXTjT8MuRI0fkrbfeMksOZP9eObflJ7jgzCh6Br9t3rzZ04+aGwawwi3aNK4L4+kiZk8++aQJIPr8ev31181zsEOHDmZwIRCI17LseF1zFy0j8Jv2oVarVi3P+1m/Bm7ROiIaRHRA4cUXX3xKkzl1RuAPbdHVQOsNXT0a7iGMwG86Y+aHH37gTCLgdGySdv9ps/nhw4c9t//111/mksqY8IcGDFrW7KCbBq7RQYRaqnvdunVmIal27dqZmQ/O2BHADXfffbcZrKqfYpOSksyYJF3WXceN6Lo1119/PScaCDKEEbhix44dcvPNN5tpvtnpomWvvvqqebMA3KDdNFol85tvvvHcpoHk1ltvNatIE36B4EMYgStuueUW+eWXX8ysmSuvvNI0oc+aNcsUQtM3jptuuokzDdfWp9FxSDo+ZOvWrWY2TaNGjTw1IQAEH8II/Kb9961atTLVV7X53BmwqmHkiSeeMPdNmTKFMw1X1j/Sgau61tGMGTMkIiKCswoUAbSdw2/Hjh0zc+518GD2mTONGzf2hBXADbpir1bJ1O5AgggKgq5P8/DDD3sK7O3evVumT5/OyXcZs2ngN51mqW8M+/btkyVLlkjbtm1NOPn000898/EBN0RHR8tVV11lVk3Vwmc6DVNvc8Yk6fOwRYsWnGy4ggJ7BYcwAr/p4ME+ffrI1KlTZcCAAdKkSRPTGqKfIFTfvn05y3DF9u3bTRBRGnadwOugEBXcLLCnVaX1g5VTYC+72bNnU+3XRYQRuGLo0KFm0Kouv+3UfAgLC5MhQ4bkKE4F+EOfUxp288LaSHALBfYKFmEErr1JvPLKK/Lggw+aOiO66uV5551nFs8D3KJh4/PPP+eEIuAosFewmE0Dn6Snp5t1HLSLpnbt2uZ6XnSb2NhYzjRcKaw3Z86cXO/T+iIairWKZsuWLT1LvQO+osBewSGMwK8FpbIvUpYX+vFR0AuZaUCeNm0a64fALxTYKzh008An+qmzZs2aZoE853peTreIHpAfWthMB0nrsgM6sLB169ZmavlPP/0kDRo0kIYNG5riezt37pS3335bRo4cyQmGzzVtdImB8ePHU2CvANAyAiCoaMl3LQU/d+5cs0ijevfdd2Xs2LEyceJEMwvirrvuMlN8NbQAvrbC9ezZUy655BIzW7Bjx46myxmBQdEzuGbjxo2e5dx1mq9WX9VPrIBbDh48KF999ZVUqlTJE0TURRddZIqhaRjRujdKP9UCvtJB+Fq35scffzQD8y+99FIZPXq053UO7iKMwBX/+9//ZNCgQea61n549tlnTTn4O+64w1QwBNzgFDfTCqw6jVy7anT9Ix0f4oSVl19+2VzXwAL4Sruely5damYJ6grkOnh68uTJprVEV4ZmVpe7CCPw2/Hjx80nUod+cq1cubJcccUVppWE0slwiy45oFVXldawOffcc+WCCy4wlTKVfnrVNxDVqVMnTjz8oi0juvCnftj64Ycf5L777jNdNX/88Ye8+eabnF0XEUbgN/00qoMIlX5SXbVqlelnHThwoKdqJuAWbfnQNUJ04LSuVaOBV9dEGjFihPTr18+sHK2tdKwUDTfoa5uOPdL1aTSAaFkDbaHTOkpwD7Np4Det76D0jWHLli2SnJwszZo18wz20tV8AbdoIT0tza0lurVKpj6/dMaW04Wjg1sBf2lFaX2O6UrkGkBUTEyMXHPNNWZAa40aNTjJLuJdAn7TT6X6BhEXF2fKwiudcunQ6ZaAm3Qcknb/rVmzxnTd6EyaRYsWmZYRwA3x8fEm2GoLXJcuXUwA0bEjTuiFuwgj8Jv+c+pocx20unbtWunRo4ecddZZZmqc/iPzBgE3sZIqCqocvI5L0pYQBkMHHmEErvj3v//tKUDVvHlzc1v58uXl/fffl3POOYezDFewkioCXehs8eLFJohceOGFplvm559/znVb3aZ9+/b8QVxCGIGra9Po2iB///23Z7vIyEhzH2vTwA2spIpA2rdvnzzyyCOeZS70el50G8KIewgj8ImW2+7du7fnn1av54W1aeAWVlJFIJUpU0batm1rBqc61/PCAFZ3EUbgE9amgQ3a9ad1RnSGg65Ro3bv3m1mPShvFtED8qIrPr/zzjue77NfR2CxNg2AoMJKqijoGiM6U1CLOzplDLQaq3bpOJV/4T/CCFyj5ZG1+uVLL71k6o0MGzbMzLLRAmhAIMaPbN26VUqUKCGNGjUyK/oCbtLlLJYsWZLrfXQ/u4sJ03DFf//7X3n00Udl9erVnkqsWjJZm9JZmwZuzqbR4npOn32bNm2kVatWJojs379fnn/+eU42XGsV0Q9X2hpy5513mjEkw4cPNwP2a9WqZdapgXsII/Cbrpb69ttvm+sPPPCA51ODLuOubx5TpkzhLMMvCQkJ8tBDD5m1aPRL1wtZtmyZ5/758+eb23T9EMCt7kD9UKUL5mkxRy2upzVHnnrqKdm1a5d8+OGHnGgXEUbgN+071U+runS7M4BQC6F17tzZXN+xYwdnGX7R4lNff/21Cb76BqHTx++9914zeHXChAlmLRot363PQcCtmVvOYH3VokUL+fXXXz0VWLUeCdzDbBr4LTo62vyD6qfXDRs2SOPGjc3t3333nbmkLx/+0LWOnFaQkSNHmiJ6Op38xx9/lFGjRplLXZ9Gm9J1VVXADdoSoi28jpYtW5quaGcQq65MDvfQMgK/lS1bVi677DIz2vzaa6+Vq666yky/nDhxorm/V69enGX4TEOursyr1TC10u/555/vCR0aRDTszpgxw6yq6izOCLhBB+PrGBGltZT0uo4l0WKOzqrkcActI3CFrkvjfILV1hGneVM/rZ6uIBpwJs6KqVrdN3sAdmjo1XEkgNu0a8YZD6cB5OOPPzbrb9WtW9e0nMA9hBG4Qv8xdXS5Tundtm2b+YSqzel00cBfOkbkZE5TuQ4uPO+88zjJKBD6uqYtc3AfYQSu0cGEc+bMMcu66+Avrf2gc/RPV1IZ8NaRI0fkrbfe8nTdqJSUFM9tToXW66+/npMKn5e5uOeee7zaVqf3Ol3R8B9hBK7Q7hn9J9Y3B6UDv7RvVaf36tReHfwF+EMDyJgxY057mz7vCCPwp0tw48aNXm2rY+TgHsIIXGlGHzFihAkit99+u7z77rue+7TOyNSpUwkj8JkWm9IB0d6uLQL4Sgeofvnll7ne9/PPP5tp5NpCp+PhevbsyYl2EWEEftu7d68pAqTjRvr06ZMjjKjt27dzluEzDRiTJk3iDKJAxoRo9/LJXTcvvviifPvtt+Z7nTmolVh1ECvcQxiB/0+ikv88jbTwmTPzIXuxMx2FDgDBJCkpyYwJ0YH5+rp21llnyeOPP26WIID7CCPwW5UqVczUSl2LxikHf+DAAc+y7t42sQNAYeh2/vTTT2Xs2LHmdUwHRT/22GPSt29fzwcvuI9Ve+EK7YrRFXrXrVuX4/ZOnTrJuHHjctSIAIDCSJcU0JV6dUagM2NGi5uVK1fulG11xiAzBd1DGIFrtEqmDvLSWiO6rHuzZs2kefPmnGEE7BOs1hvR9Wr0kk+t8NfmzZs962udic7cmjdvHifdJbQ5wTWJiYkSGxtrumx0BgQQCBo+dFbDihUrZPr06WZsUr9+/cxieXoJ+EpbO7Q11xvM3HIXLSPwi86iefPNN2XhwoUSHx/vuV1Hmus6NbfddhvrhcBVOohw9uzZ0qBBA7OSr4aRLl26mJaS8ePHS9euXTnjQJAhjMBn69evNwuXaXGzvGjp5Pfff58xI3CFztjS8u8aPHSdEF07RGkLyTPPPCPt27fPUZEVQHCgmwY+0+XbNYjUq1fPNJE3bdpUwsPD5ejRo6YJXT+lrly5Uj744APp378/Zxp+279/vxmbVK1aNU8QUc7YJK15AyD4hNo+AAQnDSGrVq0yAwe1/16rEep4EV24TEPJzTffLEOGDDHbLl682PbhooioXLmyqX6poWTBggWmhUTrQUybNs3cHxMTY/sQAfiAlhH45NChQ55BXFoMKDfOaqoHDx7kLMMVERERcs0118hHH30k9913nxmPpANanZk1DGAFghNhBD7RNwB1uvohzlRLZ1vADU888YR5bs2aNcuMIVHabTN48GBp164dJxkIQoQR+CU1NdXMpMkN/fcIBA3AWt132LBhEhcXZ1pHatSoYVpGAAQnwgj8ooHj7rvv5iwioPVrdNyR1oC48MILcx2DpAOllW6jM2oABBfCCHyigwh1sKo3tAkd8NW+ffvkkUceMRUvX3/9dXM9L7oNYQQIPoQR+KROnTry/fffc/YQcFrNV9cA0a4Y53pedBsAwYeiZwAAwCrqjAAIGjt37pRu3brJgAEDcty+evVqadWqlZlRAyD40E0DoNBLT083lXx1/aOtW7eaKr+TJ0/23K8rRevy77rqKoDgQxgBUOjp9N2ffvpJFi1aZL7XUDJ69OhTtmvYsKGFowPgL8IIgKDw4IMPmmJnWgZep/B27tzZc19oaKhUrVrVLNwIIPgwgBVA0NAWkYkTJ5o1agYOHGj7cAC4hDACIKicOHHCFD7r2LGjKQf/wgsvyPr1681ijaxNAwQnumkABJXnn39eli5dasLI9OnTZcaMGeb233//3bSYdO3a1fYhAsgnpvYCCKpZNTNnzvR8P3/+fKldu7bccccd5vvPPvvM4tEB8BVhBEDQOHDggGel3uPHj8vatWuldevW0qtXL3Pbnj17LB8hAF8QRgAEjfDwcM/ieRs2bDAtJc2bNzezbFRERITlIwTgC8IIgKBRsWJFqV69umkh0SqsISEhcskll3juP+ecc6weHwDfEEYABA0NHyNHjjQtJAkJCWZ6r7N6dHR0tNx66622DxGAD5jaCyDopKammrEjGkDUsWPHzFdMTIztQwPgA8IIgEJNx4doXRGtunrhhRea63nRbdq3b1+gxwfAf4QRAIWaLn7XvXt3qV+/vrz++uvmel50m3nz5hXo8QHwH0XPABRqZcqUkbZt20qNGjU81/Oi2wAIPrSMAAAAq2gZARA0jh49KnPmzMlzpk1YWJiZ+tuyZUspVapUgR8fAN/QMgIg6MaPnImWiJ82bZoJJgAKP+qMAAgaFSpUMMXOypcvb6b1duvWzRQ901aR2NhYs0ie3rdz5055++23bR8uAC/RTQMgqCqw6vozSUlJMnfuXKlTp465/d1335WxY8fK448/Ltdee63cddddsnr1atuHC8BLtIwACBoHDx6Ur776SipVquQJIuqiiy6SjIwMmThxolStWtVTGA1AcCCMAAgaoaH/vGTt3btXvvzyS8nKypKUlBQzPsQJKy+//LK5roEFQHAgjAAIqm6aDh06mOtDhgyRc889Vy644AL57LPPzG2XXnqpLF261Fzv1KmT1WMF4D3CCICgoi0fN9xwg5m6q+vTZGZmSpUqVWTEiBHSr18/qVevngwaNEhuuukm24cKwEtM7QUQlI4fP24Gs5YsWVKqVavm6cIBEHyYTQMg6GzZskXeeecdWbdunURGRkq7du3klltukYiICNuHBsAHtIwACCqrVq2S2267TZKTk3Pc3rx5c5k6dSqBBAhCtGsCCCpPPfWUCSKtWrWScePGyahRo8yYkT///FMmT55s+/AA+ICWEQBBIz4+Xtq0aWO6ZpYsWWJW8VXz5883g1Z1Zs0HH3xg+zAB5BMtIwCChs6eURpCnCCidABr9vsBBBfCCICgoaFD1545cOCATJ8+3RQ909LwWnlVNWnSxPYhAvAB3TQAgspbb70lY8aMMdd19kx6erqcOHHC1B2ZNWsWgQQIQkztBRBUdNVerTGiU3sTExPNbbVq1ZKRI0cSRIAgRcsIgKCk40N27twp4eHhUrNmTQkJCbF9SAB8RBgBEPS2b99uyr/XrVtXZsyYYftwAOQT3TQAgp522+iKvWXLlrV9KAB8wGwaAABgFWEEAABYRRgBAABWMWYEQKGWkJAg77///mm3OXz4cIEdDwD3EUYAFGqHDh3yVFgFUDQRRgAUajpD5sorr/Rq26pVqwb8eAC4jzojAADAKgawAgAAqwgjAADAKsIIAACwijACAACsIowAAACrCCNAMffDDz/If//7X3nrrbfy3Gbfvn1mG/1KT083ty1evNh8r4vU+eKDDz4wjz927Fiuq/DqffpzC8KuXbvMz9NLx9GjR2X16tWnbBMXF1cgxwQUJ4QRoJj78ccf5fXXX5cJEybIunXrct3ms88+k3feecdsk5GR4Qkj+v2JEyfy/TP1Df2ZZ56RqVOnmn3nFkZ03/v37xdbunfvbn5Hx+7du80xEUYA9xFGAEhoaKi0adNGvv7661zPxpw5c6Rdu3aunalZs2ZJbGysecPXFhLbatWqJYMGDTKX2cvQAygYhBEARufOnWXevHmnnI3NmzdLWlqaNGrUyJUzlZmZKZ9++qm0bdtWevToYfb/888/e/XY9evXm3VqNMBs2rRJVq1adUr30t69e01ri94+d+5cc+yOnTt3mq4WbXH5+OOPZcqUKbJly5Yc3TQpKSnmuh7n8uXLPdezW7FihTkObdnRfTqc/SQnJ5vuLz0GPdYDBw6Y+//++2957733ZPr06bSwANkQRgAYHTt2NF0RJ3fVfPXVVyaouNktpF0d3bp1k5YtW0rNmjVlxowZZ3zc+PHj5ZprrjHjOPQYb7rpJhk5cmSOMDJ58mTp2rWrCVUHDx40j9GfoyFAaXDQrpYbb7xR/vjjD/n+++/NmBWnC0Yvz+TJJ5+UF1980Yxn+eabb3J05zj7uf322+Xtt9826+po95aGLn3MI488YsLS7NmzPUEMAGvTAPg/FSpUMOFAu2qaNm3qOS/auvDyyy/nGD/hbxdNvXr15LzzzjPf9+rVywQKfXOvVq1aro/57bffzLiW0aNHm0CiNFD06dNHIiIizPe//PKLuX/48OHSv39/c9vDDz8sN998s9x33305uqBatWolzz33nGRlZUlISIh5rEP3p102b775pvzrX/8y17OrU6eOvPHGG6ZrSx9/9dVXm+Nv3769Z5tKlSqZ41U9e/Y0xzx//nzT3RUeHi5JSUly2WWXycyZM2XYsGGunFcgmNEyAsCjS5cuObpq1q5da2bPtGjRwpWzpOMwFi5caN7AHb179zYzcvSNOS/araOL4Om2Dg1MnTp1yrGNBqp///vfOYLFwIEDZceOHTm6gi6++GJzqUEkv/QYNIg4j9dzk72rRmmrh6Nhw4bmUsOHBhFVpkwZiYmJoasG+D+EEQAel19+uXnjdrpqtItGb3PLJ598YmbjaDeNM1X4iy++kOjoaDOGI69pwhs3bjStKU4IcDRo0MBzfevWrVK3bl0pWTLnYuROGNAZOg4NAr7SVo/swsLCcoxLUZUrV/ZcL1GihLmsWLFijm30d/F1WjRQ1BBGAHhoN4l+0tcuDe2C0FYSHYPhFh0rod0zVapUyXG7jrvQbprvvvsu18fpG/qZphA7XS4ncwafZg8pJweW/PCmNeXk0ATg9Hz/jwRQJOlgVR3X0aFDB9NFc8EFF7iyX52BojNXdLxF9u4VJzAsWLDADGTNLfxoC8iiRYtOCRzZWzvq169vxrVoa0P2sKGzbpyxHvp4b/nShQPAN8R3AKeMG9m2bZuZFaKhwa1P+TomRMdK5FavRH+GjrPQcR25zTDp27evmR6rXTrZu2W+/fZbT2jQcSg6e2XatGmebXSarg4u1Rk7F110Ub6Ot3Tp0nSjAAWElhEAOei4C60psnTpUjMt9Uy0pSO3bg+dweIEmcTERDMNVsef6Jt8bq688kozNVfrclx66aU57mvWrJncfffd8vjjj5v6HeXKlTMtKRoytGy7Myh1yJAh8tJLL5lQoy0huq2O58jrGE+ncePG8uWXX5oQNHTo0Hw9FkD+EEaAYk5bKnQAaXb6pv7nn3+aKbAOneZ6//33S6lSpcz3OpVVZ694Q4uM3XHHHaaWSV40cAwePNiEFQ1E+rN0Bo1Dp+lqq41Ow9VZMlrLY+LEiaZeiGPAgAGmroiGEJ0+q3U99Dh1kKmqXbu22W/16tVz/GwNNXq7Xjo0wOhUXG1dyb7NyYNf9fw5x5nbNhrI9LaTW2ZuuOEGiYqK8ur8AUVdSFZ+OlEBwAIdb6KtHTpN1wlDGhKuuuoqEzZGjBjB3wUIYoQRAIXehg0b5JZbbjEtD9odozNrdECrtsxopdOyZcvaPkQAfiCMAAgKWrbdKSWvU32bNGliupGYRgsEP8IIAACwiqm9AADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAQGz6fxCkYXrPpmddAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running Non-Parametric Statistical Significance Analysis...\n", + "INFO: Preparing for Model Feature Importance Plotting...\n", + "INFO: Generating Feature Importance Boxplot and Histograms...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhcAAAI9CAYAAACJ7loYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQNFJREFUeJzt3QmcjXXfx/HfGDOMfV+y74wtRVkist72pOIpd3oKka2QuJG6K5USbjcpJIoWUWRpoSRkiSg7tyVk3waDYeZ5/f535zwz48zMOeM/c64z5/N+veZ1Zs51nXP+57rmOtf3/LcrJC4uLk4AAAAsyWTriQAAAAgXAADAOmouAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGBVZrtPB8AJNm/eLJMmTZIWLVrIww8/fNPyHTt2yJtvvimDBw+WKlWqePWcX331lSxYsEDee+89yZQpbb+XrF27VqZNm5bgvrCwMClQoIA0bNjQvK+QkJA0LQOA1CNcABnQ6dOn5aeffpJdu3ZJo0aNpGjRogmWnz171ix/4oknvH7OmjVrSq5cudLlpH7ixAlTPg0/lSpVMvddvXpVdu7cKUOGDJEff/xRXnnllTQvB4DUIVwAGdj//u//yhtvvCFvv/32LT9XiRIlzE96qlGjhtx9993uv5s3by7Xr1+Xd955R5566ql0Lw8A7xAugAxMT8779u0zzQz16tVLdt2LFy/KvHnzZOvWrXL58mW57bbbpGPHjuY5EjeL7N69W8aOHSt9+/aVWrVquZ/jxo0b0r9/f7n33nvloYceMvddu3ZNvvjiC/n555/N79WrV5euXbuaWpDUKFmypLmNjY31quyHDh2SF198Ubp16yaNGzdO8FxDhw6VqlWryt///nevy7pmzRpZtmyZqV3Jmzev1K9fX9q0aZPmTUVAIOFoADK4QYMGyYQJEyQmJibJdc6dOyf333+/rFixQpo2bSrt27eXU6dOmRPr9u3bzTp6ktamCj2plytXTrZt2yafffZZgufRE+93330nZcuWNX9fuXLFnLjHjRsnt99+u7Ru3Vq+//57c+I/fvy4z+9FT/gacrQfSalSpbwqu9ZuHDx4UGbNmpXgubSJRYOE63m8Kau+X60xKV68uDz44INSuXJlE1xeffVVn98LkJFRcwFkcPny5ZN27drJBx98IE8++aTHdT788EPTD+PLL7+UbNmymftatWplajvmz58vkZGRN3WubNu2rVl/9OjREh4ebu5ftGiRqVmoXbu2+VtrObZs2WJOytWqVTP3NWnSxDz3mDFjZPz48cmWXWtHcufO7Q4We/fulSxZssiAAQO8LvuIESNMQPj3v/9tQkLhwoXNOgsXLjQdRBs0aOB1WefOnWtqZXr27Ol+/bp160pUVJSPewXI2Ki5AIJAly5dzDf7pGoL9CQ6Y8YM01lTv+0vXrzYnNi1E6WeuD3R2oILFy6YzpUqOjpavv32W+nQoYN7HW0+0BO162StIiIiTN8JLU9ytSmqZcuW8thjj7l/NBxp04s2cfz6669el13LGhcXZwKI0t+XLFlimjMyZ87sdVm1lkPf7/Tp093bUjucusIUgP+i5gIIAqGhoaZ5RDt3vvXWWzct15Om1kAsXbrUnGx1eKr2JciRI0eCvg3xaV+FihUrmtqKZs2ayfLly03AiB8ujhw5Yp4j8aiUw4cPm5O/jmopUqSI1x06ldY06Gu8//77prnHm7IXK1bMPI+GC6112LBhg/z555+mRsOXso4cOdL0rdBaDN2WGiy0KebRRx+V/Pnzp7gfgGBBuACCxJ133mmq/NetW3fTsuHDh5v+FJMnTzYnb9e3ee0kmRw9OU+cONF0qNSQod/g44/g0OepUKGCqXXwJE+ePD6/D+3noENr//jjD5/KrrUX2oFT+1poWbVc8Zt7vClr1qxZTTjTTqMbN240fTJmzpxpmli0JkSbbADQLAIEFZ03Qoel6nDO+FauXGn6EuiP6+R8/vx5OXnypGlCSIp2ntTmAu1kuXr16gQ1AUprEbRzpc61Ef/nP//5jzn5u/pq+EJfT2sRtDbCl7JrE4vWTGjthdZyaNlTW1bt26HLXnjhBRNutHZD+4MA+C/6XABBRDswagdF7QQZn3bC1Am3tPpfafjQERDarOC6z5OCBQvKPffcYwKLNr3oc8fXvXt3M2xVO0u6aM2BNmdoOEjN8M2pU6eazp06WsOXsmv/CS2fjhq5dOnSTeEipbKqZ5999qaZQ3///XfJnj27e4gsAJpFgKCj/QM+//zzBPfpN3AdgaH9B8qUKWO+rWvHxjp16pjfk6O1FVp7oKNHtGYgPn0+7Q+hTQmffvqp6ZegnS61z4T2AUlJ/NEiSptCtJOmjgDRmgNfy65NI1oLoSNJEvf1SKmsGoR0eKq+9ieffGLm0tB+G9pEon0wcubMmeL7AYJFSFxydZ4AApI2G+g8FDpfg6fJqvQkvX//fjNJlE4EpbQz5p49e0xTgn4L1/td6+nJ+NixY+Z3vbZH/CnAtRZBJ53S/gqJpxl3cU3drU0aGgBS6vyoE1Tp+vFpk4f2eyhfvvxNzSkplV2Hzro6bd53330mtCSuufC2rFozok0gGnJ022ofEK21AfD/CBcAgsbrr79uJvlyjSwBkDY4ugBkeNpssWrVKtNMon02CBZA2qLmAkCGp006OgW4zsvhagYCkHYIFwAAwCqGogIAAKsIFwAAwCrCBQAAsCqoRots3rzZjIN3jXkHAADe0blfdI6bWrVqpbhuUNVcaLDwZc4wXVcnCGKeMWdhvzgX+8aZ2C/OFBdg5xhfzqFBVXPhqrHQWQm9odP67tixw8wIqBcqgjOwX5yLfeNM7Bdnuhxg55jffvvN63WDquYCAACkPcIFAACwinABAACsIlwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqwgUAALCKcAEAAKwiXCDghISESEREhLkFADhPZn8XAPBGbGycZMr03zChwSIyMlJuxMay8QDAgQgXCAgaLN786Bc5fDzK/F28cE4Z/Mid/i4WAMADwgUChgaLfUfO+7sYAIAU0OcCAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYlVkc4tq1a3L9+nXJli3bTcvOnDkjN27cSHBfRESE5MiRIx1LCAAAAiJcnD9/XkaNGiXLly834aJ8+fIyevRoqV27tnudli1byoULFxI8rnPnzvLKK6/4ocQAAMDRzSIaJJYtWyZxcXESFhYme/bskR49esjRo0fN8iNHjphgocsKFCjg/smZM6e/iw4AAJxWcxEbGyvnzp2TSpUqybvvvit58uSR7t27y+bNm2X9+vXSsWNH2blzp1m3U6dO8vzzz5uQoT8AAMCZ/BouMmXKJO+//775PTo6WrZv3y5//vmn+bts2bLm1hUufvjhB/n0008lPDxcHnnkERkyZIh5PAAAcBa/97lwmTdvnrz88ssmMPzjH/+QGjVqJAgXx48fl6xZs8qVK1dkxowZUqRIEXnsscd8fh1tfrl8+bJX62rgiX8L/wgJCTEdeD3RfaP7FM7AMeNM7Bdnig6wc4x+1urncUCFCw0POlJET/yffPKJNGnSREqUKCFFixaVihUryrBhw6R+/foyefJkmTBhgqnxSE24iImJkR07dvj0mAMHDvj8OrBHg0VkZKTHZfv37w+YAzOYcMw4E/vFmQ4E0DlGWw+8ERLngK99Ogw1NDTU/IwdO1amTZsm9913n0yZMsUsv3r1qmTJksU9LLVevXrmd+2b4WnoalJ+++03k7x0RIo39KSlO7106dJJfnNG+tVcDBz3g+w7ct7cV65Ybhn/bGNqLhyGY8aZ2C/OFB1g55i9e/eaz+Pq1as7u+ZC+1c89NBDpilE+1SoRo0amXCxa9cuEyp0GOqJEydk7dq1kjt3bneThnbqdAUOX+iG8SWQKN3pvj4G6SMQDshgxDHjTOwXZ4oIkHOMt00iyq89IrXfhI4YOXbsmEydOtVUcbs6eGqS0/Cgw051Aq3XXnvNLB83bpxZXqdOHVPTAQAAnCWTv1PQ4MGDze9vv/22tGrVSr7//nvTptOvXz9z/6BBg8x68+fPN8sXL15sai2eeeYZfxYdAAA4tUPn/fffb25nz54tUVFRUrlyZenfv79UqFDB3K/9K7Q2Q+fBOHjwoJQpU0b69OnjHk0CAACcxe/hwhUwXCHDEw0Yrk6cAADA2ZiFCgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAGTMcPHnn3/KgQMH5MaNGx6Xnzp1Snbv3i1XrlxJ97IBAIAAChfHjh2TLl26SOPGjaVly5ZSv359+frrr93Lr1+/Ls8995zcc8890q5dO7N80aJFfi0zAABwcLgYOXKkbN68WXLnzi2FChWSc+fOyaBBg2T//v1m+QcffCBffvmlZMqUSYoUKSKXLl2S4cOHyx9//OHvogMAAKeFi9jYWMmbN6/ce++9smLFClm1apXcfffdEhMTYwKHmjdvnrl9/fXXZeXKlWbda9euUXsBAIBDZfbni2ttxBtvvGF+P3PmjCxZssT0qwgNDZVq1aqZWgpXDUaDBg3MrTaPaMjYvn27P4sOAACcGC7iW7hwoYwZM8YEDr2tWLGiHDp0SOLi4iQkJMTUcChtPnF18EwNfb7Lly97tW50dHSCW/iH7v+IiAiPy3Tf6D6FM3DMOBP7xZmiA+wc4zofB1S40FqKMmXKmJoKrc2oXLmyhIWFmWUaOFxvSGs1lDaNpIY2uezYscOnx+goFviPBovIyEiPy/T/JVAOzGDCMeNM7BdnOhBA55jw8PDACBd6sj99+rQ8/fTT5mfatGkyduxY08filVdeMevo8FQdNZI5c2b3UNTs2bOn6vU0sJQvX96rdfWkpTu9dOnSSX5zRtpLLilrIKXmwjk4ZpyJ/eJM0QF2jtm7d6/X6/o1XBw9elSaN29umjq0M6fWSlStWtUsO3jwoBk9omFAA8iRI0ekVKlS5laVKFEi1SeqbNmy+fQY3em+PgbpIxAOyGDEMeNM7BdnigiQc4y3TSJ+Hy1y2223meGlWnOhtRRr166ViRMnmmXaLKI1FbVq1TJ/jx8/Xn744QdZsGCB+btevXr+LDoAAHDqPBcjRowwaeijjz6S7t27y6ZNm0xNxjPPPGOWa1OJhgwdSdKrVy8zk6d29mzVqpW/iw4AAJzY56JJkyYyffp0Ey6ioqKkUqVK0rNnT9MkourWrSszZ86UWbNmycmTJ02zSZ8+fdydPQEAgLP4PVy45rBwzWPhSZ06dcwPAABwPr83iwAAgIyFcAEAAAgXAADAuai5AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVmcUh9u/fL8ePH5eSJUvKbbfdlmDZzz//LNHR0QnuK1q0qFSuXDmdSwkAABwfLk6dOiWDBg0yAcKlTZs28tprr0l4eLjcuHFDevXqJVeuXEnwuM6dO8srr7zihxIDAABHh4uXXnrJBIs8efJIxYoVZdOmTbJ48WKpUKGC9O7dWw4cOGCCRf78+aV69erux1FrAQCAM/k1XFy+fFlWrFhhfp89e7YJF++//76ptdDAoeFi586dZnnr1q2lVatWkj17dqlSpYo/iw0AAJwaLq5duyaPPfaYnD9/3gQLpTUUKiIiwty6wsXcuXNNAFF33323TJ48WXLkyOG3sgMAAAeGC20KGTJkiPvvq1evysyZM83vbdu2TRAusmbNKpUqVZKtW7fKunXrZNKkSfL888/7/JpxcXGmxsQbrk6kiTuTIn2FhIS4w2Zium90n8IZOGacif3iTNEBdo7Rz1r9PA6IPhcuunH79u0r27Ztk0aNGplOnapZs2ZSoEAB6devnxlFsnTpUhk4cKAsWLAgVeEiJiZGduzY4dNjtN8H/EeDRWRkZJKjjALlwAwmHDPOxH5xpgMBdI7RgRYBEy4uXrxoRoRs3LhR7rrrLhk/frw7HTVp0sQ0mbiGp9avX9/cnjt3zjzO16aRsLAwKV++vFfr6klLd3rp0qWT/OaMtJdcUi5Tpgw1Fw7CMeNM7Bdnig6wc8zevXu9Xtfv4UKbQnr27Cm//PKLNGzY0DR3aBOIq09G06ZNze3y5culePHi8ueff5pluo527kzNiSpbtmw+PUZ3uq+PQfoIhAMyGHHMOBP7xZkiAuQc422TiCPChc5VocEiZ86cZu6KtWvXmvv179q1a0u9evVk5cqV8txzz0nXrl3lgw8+MMubN2/u0xsFAADpw6/h4ujRozJv3jzze1RUlAwYMMC9rGrVqjJ//nwZOnSobN682QQQ/VEFCxaUZ555xm/lBgAADg0XR44cMU0hnpQqVcrclitXThYuXChz5syRgwcPmjb2Rx991AQMAADgPH4NF3Xq1DE/KdHriOgU4QAAwPm4KioAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMD/4eLs2bN2SwEAAIL7qqhdunQxVyrt0KGDtGjRQrJnz26/ZAAAIHhqLvr3729uhw8fLg0aNJDBgwfLqlWr5MaNG7bLBwAAgqHmok2bNubnxIkTsmTJElm4cKE8+eSTUrBgQWnXrp2p0ahcubL90gIAgIzdobNQoULSvXt3mT9/vixdulTuu+8+mTFjhgkXDzzwgCxfvtxeSQEAQMatuYjv4sWLsmzZMlm8eLGsX79ewsLCpHHjxhIaGioDBgyQbt26ydChQ+2UFgAAZMxwoX0r1qxZI1988YV89913cuXKFalSpYo899xzplkkX758Zr1du3aZGozevXtLrly5bJcdAABklHDx0EMPye+//y558+Y1v2uA8NTHolKlSpInTx6JiYmxUVYAAJBRw0WtWrXkqaeeMs0f2gySnDlz5kj+/PlTWz4AABAM4WLEiBHu32NjYyVTpv/2Cz1z5oy7ScSlZMmSt1pGAAAQDKNFPv/8c2nSpIn88ccf7vu6du0q/fr1k0uXLtkqHwAACIZwoZ04R40aZZpF4jd5DBkyRPbv3y+vvvqqzTICAICMHi7mzp1rmkZeeOEFyZEjh/v+Zs2ayfTp02XRokVy/fp1m+UEAAAZOVzozJw1a9b0uKxw4cKSM2dOOXXq1K2WDQAABEu4KFasmPz0008el+3evVuioqJu6tgJAACCQ6pGi3Tu3FkGDhwo58+fN1dF1WuKXL16VbZs2SITJkyQ9u3bS3h4uP3SAgCAjBkutG+Fhovx48fLtGnTEixr2rSpuVoqAAAITqm+toheBfXBBx801xPRPhgRERFSo0YNKV++vN0SAgCA4LlwmV5TpEyZMlKqVCn3hFra50KVLl2aphEAAIJQqsKFjgR55plnTK1FUr755ht36AAAAMEjVeFi4sSJcvjwYRk5cqQUKlTIPf13fNrJEwAABJ9UhYvNmzfLSy+9JA0bNrRfIgAAEHzzXGTJksVcbh0AAMBKuNALlumFywAAAKw0i+gIkVmzZsmePXvM8FMdhppYt27dJE+ePKl5egAAEIwdOnWK702bNpkfTzp06EC4AAAgCKUqXCxbtsx+SQAAQIZwS5No6aiRH374wczQOXjwYFm9erU0btxYcuXKZa+EAAAg43fojIuLkxEjRkiXLl1k6tSpsmDBArl48aJMmjTJNIccOHDAfkkBAEDGDRcff/yxfPvtt/LWW2/JL7/8IiVKlDD3z5gxw0z7/eKLL9ouJwAAyMjhYvHixWZ2zrZt20r27Nnd9xcvXtxccl0Dh16CHQAABJ9UhYszZ85I2bJlPS7T/hYaOHQdAAAQfFIVLrQZJKkRI9rJMzo6WgoUKHCrZQMAAMEyWqRr167Su3dvOX36tGkauX79uhw9etRcJfXtt982nTrDwsK8fj59/IYNG+T48ePmSqq33367hISEuJfHxMTImjVrzOtFRkZK5cqVU1NsAADg1HChw02HDh1qOnTOmzfP3Ne9e/cEy7x16NAh6dOnj5nt06V27dry7rvvmuaVCxcumNk+d+7c6V7eo0cPM/QVAABkoHkuNExorYXObaHzXGTLlk1q1qwp1apV8+l5Ro8ebYKFdgatVauWLF++XDZu3ChTpkwxAWLy5MkmWOgl3PX5V6xYIe+99560bNlSqlevntriAwAAJ4ULbb7Qpgp15513Jlh2+PBhc1ukSBHJnDn5p9e5MdauXWuaQPRaJcWKFZNPPvlERo0aJVu2bHGPTFFjx46VevXqybBhw2T+/PmmzwfhAgCADBIuHn30UdOckZxvvvnG9J9IyfDhw+XcuXMmWKhMmf7bx1Qv6a73a62IcgUJvVCahovdu3enpugAAMCJ4WLIkCGm1iG+a9euyf79+00fjH79+knRokVTfJ4cOXKY/hQu58+fl2nTppnfO3XqJGfPnjW/a82Grut6jGvd1M4uevnyZa/W1VEv8W/hH7r/PV1517VvdJ/CGThmnIn94kzRAXaO0c/a+IMtrIeLFi1aJLmsefPmZoZOVwdPb2mQeOKJJ8zU4R07djQdQ//zn/+YZZ7eTGxsbCpK/t+RJzt27PDpMUxn7l8aLHSUkCcaaAPlwAwmHDPOxH5xpgMBdMmM8PDwtL9wmSc60kODgg4bzZ8/v1ePOXnypAkje/fulVatWsnLL79s7nfN/qlBQmf8zJIli7vWIWfOnKkqnw6RLV++vFfr6klLd7pOaZ7UN2ekveSScpkyZai5cBCOGWdivzhTdICdY/Qc7S3r4eLUqVM+NVnoUFNXsNAai1dffVVCQ0PNskKFCplRKBoo9u3bZ769ut5cUjOEenOi0uf0he50Xx+D9BEIB2Qw4phxJvaLM0UEyDnG2yaRVIcLvXCZhoLEbTHaD2Pp0qVSsWJFr2st9OqqGhi0JkI7a3766afmfn28Nr80bNhQvv76a3MtkyZNmsjnn39uluvvAADAeVIVLqZPn+5xtIg2ObiGi3pD28s1OKioqCh56aWX3MuqVq1qwsXAgQNl3bp18vvvv5sf1bRpU7nnnntSU3QAAODEcKFzTCTuoa/VJa7mDG9poHj44Yc9LnMNTdXmj0WLFsmCBQtM3wwNHe3atUtNsQEAgFPDhfarcE2i5Y2kJtTSZhD9SYn2vejVq5fP5QQAABloEq3UTKgFAACCNFy88MILMmDAADNrpl4BVWsmdESHTtn94Ycfmv4QOk+Fi7edOwEAQJCGC62J0IuW6WRZ8WlHy0aNGplOmOPHj3dP5Q0AAIJHqs7+mzdvls6dOyc5idb169fd1wQBAADBJVXhQuek2L59u8dlevl0ne8iV65ct1o2AAAQLM0iOhR0zJgxZibOZs2aScGCBc3vGzduNM0h2g8jEGYbAwAADgkXXbp0MdNxjxs3Tt56662bLlyms2kCAIDglKpwoRNm6bTdern0NWvWmIuUaVNJnTp1krx6JQAACA63NJzjzJkzcuzYMTly5IgZPaLXCEl8zREAABBcUhUudOpvrbnQ5pGpU6eaqbm1E+ekSZNMf4tAujY9AABwQLjQq6J+++23pr/FL7/8IiVKlDD3z5gxw1yXPvH8FwAAIHikKlwsXrzYdNrUppDs2bO77y9evLhMmDDBBI6rV6/aLCcAAMjI4UL7WujVSj3R+S00cOg6AAAg+KQqXGgziF52PanZO6Ojo6VAgQK3WjYAABAsQ1G7du0qvXv3NkNQtWlEp/s+evSorF+/Xt5++23TqTMsLMx+aQEAQMYMF3rF06FDh5oOnfPmzTP3de/ePcEyAAAQnFIVLlxhQmstVq9ebS5SptN916xZU6pVq2a3hAAAIOOHC53bokaNGlKvXj3TBAIAAHDLQ1F1CnAAAAAr4aJYsWJy6NCh1DwUAABkcKlqFqlfv76MHj1alixZIuXKlZP8+fPftM4jjzwiuXPntlFGAACQ0cPFrFmz5MaNG7J27Vrz40mbNm0IFwAABKFUhQu9rggAAMAt9bnQ2opz5855uzoAAAhSXoeL2bNny/nz5xPcN27cOK4hAgAAbn20iMvSpUslKirqVp4CAABkMLcULgAAABIjXAAAAKsIFwAAwCrCBQAA8N88FzrrZqZM/59HTp06ddN9LnPmzJHixYvbKSUAAMh44aJ27drm0urxVahQIcn1w8PDb61kAAAgY4eLMWPGpG1JAABAhkCfCwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgP8uuZ7WFi5cKPv27ZMePXpIjhw53PfPmDFDzp8/n2Dd6tWrS7NmzfxQSgAAEBDhYv/+/TJixAi5evWqdO3a1R0u9O+33npLrl+/nmD9zp07Ey4AAHAgR4SLXbt2Se/evU2QSGzPnj0mWFSoUEFat27tvj8yMjKdSwkAAAIiXMydO1deffVVuXHjhmTKlEliY2MTLN+5c6e5rVq1qoSHh0v27NlNyMidO7efSgwAABzdofP33383QWH69OmSNWvWm5a7wsUXX3whY8eOldGjR0vbtm3l8OHDfigtAABwfM1Fly5dZOTIkR6DhavJxNUMUrduXVmyZIkcO3ZM3njjDZk4caLPrxcXFyeXL1/2at3o6OgEt/CPkJAQiYiI8LhM943uUzgDx4wzsV+cKTrAzjH6WaufxwERLnTUR3IGDRpkai86duxoAkiLFi1MIFm1apVPb9QlJiZGduzY4dNjDhw44NP6sEuDRVJ9bLQjcKAcmMGEY8aZ2C/OdCCAzjHaPSEgwkVyrl27JidPnpQrV664azbKlStnbrX24dKlSwmGrHojLCxMypcv79W6etLSnV66dOkkvzkj7SUXIMuUKUPNhYNwzDgT+8WZogPsHLN3716v13V0uMicObMMHz5cLly4IHfccYfUqFFDtm3bZpblyZPH52DhOlFly5bNp8foTvf1MUgfgXBABiOOGWdivzhTRICcY3xpKXB0uNDRIy1btpTPPvtM+vbta5pEtM+Fa54LAADgPH4fLZIS7XNRpUoVOX78uMyePVtOnz5tajGefvppfxcNAAA4veaiT58+psNl/OaOvHnzyqeffio//vijHDp0yLRN3XvvvRIaGurXsgIAgAAIF3pNkaR6p3IdEQAAAoPjm0UAAEBgIVwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAIBwAQAAnIuaCwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgVWZxkPfff1927dolw4YNk9y5c7vvP3LkiMybN09Onz4tkZGR0qlTJwkPD/drWQEAgMPDxdatW+XNN9+U69evy8CBA93h4uDBg/Lggw/K+fPn3et+++23Mn36dD+WFgAAOLpZZO3atdKjRw8TLBKbOHGiCRa1atWSQYMGSc6cOeWnn36SH374wS9lBQAADg8XU6dOlccff1yuXr0qoaGhNy1fuXKluR01apT07NnT1GIowgUAAM7k93Bx6NAhqVChgnz88ceSJUuWBMtOnjwpUVFR5vdy5cqZ27Jly5rbAwcO+KG0AADA8X0uevXqJSVKlJCQkJCblrmCRaZMmdzBIyIiIsEyX8XFxcnly5e9Wjc6OjrBLfxD/zdc+z0x3Te6T+EMHDPOxH5xpugAO8foZ62nc7Ujw0XJkiWTXOZ6E/FPHrGxsebWUxOKN2JiYmTHjh0+PYZaEv/SYKGjhDzZv39/wByYwYRjxpnYL850IIBq4r0dqen3cJGcPHnyuMPFxYsXJUeOHO4ai7x586bqOcPCwqR8+fJerasnLd3ppUuXTvKbM9Jeckm5TJky1Fw4CMeMM7FfnCk6wM4xe/fu9XpdR4cLDRD58+c381ts2bJFGjRoYG5VpUqVUn2iypYtm0+P0Z3u62OQPgLhgAxGHDPOxH5xpogAOcd42yTiiA6dKWnVqpW5HTx4sDz55JOyaNEi8wZbt27t76IBAIBADBf9+/eX6tWry5kzZ2TVqlWmCrxv375SuXJlfxcNAAA4vVnkxRdfNBNpxZ/6W/tdfPLJJ7JhwwY5deqUVKlSxT0sFQAAOI+jwkX79u093q8jQ+rWrZvu5QEAABmwWQQAAAQWwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAqswSAAYPHixnz55NcF/Dhg2le/fufisTAAAI0HBx8eJF+eqrryQuLi7B/UWKFPFbmQAAQACHi507d5pgcdddd0mPHj3c9xctWtSv5QIAAAHa50LDhcqaNavMnz9fvv76a8mfP79UqFDB30UDAACBWnOhfvzxR/d9CxculA8//FBq1qzpx5IBAICADBe7du0yt+3bt5cmTZrI7NmzZdOmTfL666/LnDlzfH4+bWK5fPmyV+tGR0cnuIV/hISESEREhMdlum8S98eB/3DMOBP7xZmiA+wco5+1+nmcIcLFzJkzZf/+/VKtWjXzd6VKlaR169aydetWuXHjhoSGhvr0fDExMbJjxw6fHnPgwAGf1oddGiwiIyM9LtP/jUA5MIMJx4wzsV+c6UAAnWPCw8MDP1xcvXpV3n33XTl8+LC88cYbJkjky5fPHRJ0ebZs2Xx6zrCwMClfvrxX6+pJS3d66dKlk/zmjLSXXFIuU6YMNRcOwjHjTOwXZ4oOsHPM3r17vV7X0eEiS5YsphPniRMnpEWLFtKyZUtZuXKlWVa8eHGfg4XrROXr43Snp+a1kPYC4YAMRhwzzsR+caaIADnHeNskEhCjRR5++GH3RFpdunSRf/zjH+bvxx9/3M8lAwAAARkuevbsKR07dpRr167J5s2bTT+LRx55xPwAAADncXSziKvziI4MefbZZ+XgwYNSqlQpKVy4sL+LBQAAAjVcuGigIFQAAOB8jm8WAQAAgYVwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIF/CI2Ni7ZvwEAgSuzvwuA4JQpU4i8+dEvcvh4lBQvnFMGP3Knv4sEALCEcAG/0WCx78h59gAAZDA0iwAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlxYwnTWgcfTlONMQw4At44ZOi1hOuvA3meKacgBwA7ChUVMZx142GcAYB/NIgAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqwkUGv55JSuv4+re64cU6vixPzWPy5Mxi/Xou3jwn15BJf2xzIPCOFab/zuDXM0lpHV+WqzsqF5K/t45M8XW9eQ5vH+Np/RwRYdav5+LNc3INmfTHNgcC71ghXATBtTFSWseX5cUL5fD6dVN6Dm8fk9z6aXFtkFvdXrCPbQ4E1rFCswgAALCKcAEAAKwiXAAAgODrc7F69WqZOXOmnD59WiIjI6Vfv35SuHBhfxcLAAAEYrjYuHGj9OjRQ27cuGH+3rZtm2zYsEEWLVok4eHh/i4eAAAItGaRKVOmmGDRoUMHU3tRrFgxOXDggCxZssTfRQMAAIEWLjRUrF+/3vz+9NNPS7169aRTp07m73Xr1vm5dAAAIODCxYkTJ+TatWvm99tuuy3B7eHDh/1aNgAA4FlIXFyc/+YHTcG+ffukdevWEhoaKtu3bzf3ffXVVzJo0CCpWrWqzJ8/36fn27Rpk+jbDQsL82p9Xff69euSOXNmCQkJSXZdXX7+4jW5fiNWModmktw5ws3j05I3r5nSOr4sV1nCQiVHtjCf3mtqniP+YxKvn9py2C5Xeu3nQKLbQmsc9ZhN6ZjxFtvcmfsFztsvIWn8+RQTE2Ne44477gjsDp2uEKAbXzeQvik92avUdOZ07Txvd6Ku58vr6I709HppyZvXTGkdX5d7+7q3+hyJl9soR1qUiw/rhNsiUyb7FaJsc2fuFzhvv+ROw88nfS5vn8/R4SJfvnzu38+dOyd58+Y1t6pgwYI+P1+tWrWslg8AANzM0VE2R44cUrJkSfP7ypUrTe3FqlWrzN/Vq1f3c+kAAEDA9blwDUUdP368qYrRmoszZ85I1qxZZdmyZVK0aFF/Fw8AAARSzYXSCbQefvhh0y6lwSJPnjwyduxYggUAAA7l+JoLlwsXLphwoUNRmZkTAADnCphwAQAAAoPjm0UAAEBgIVwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKscfW0RIDY2VlasWCE//vijHDx4UC5evGiuUquztVauXFnatm0r5cuXZ0MBIub4eOedd2TLli3mGHnggQfk3nvvdW+bb775xixv2bKl9OrVi22Wjvbs2SO//fab3H777VK2bFlzle5x48bJ0aNHpUaNGuZq3yVKlMgw+4RwISKnT582l5L1Rv78+b2+ZDtuTXR0tJmhdcOGDR6Xf//99/Luu+/KkCFD5PHHH2dzp+MJTH+8vT6Q/iDt6ZRFerzoScvl66+/lvvvv1/++c9/ms8t/azbtm2bVKtWjV2Sjj7//HMZOXKkucK37ofXX3/d/H3p0iWz/MiRI7Jx40ZZsGBBqi7K6USEi7+mGNcDzhvz5s3jomnpZM6cOSZY6JTvDz74oJQqVUoiIiLMARoVFWU+RBcvXmymg9dvYjp7K9KefvN97733vFpXv4317NkzzcsEMceD/mTPnl2GDh1qLpkwbdo0c8K6cuWKvPXWW2wmP7h06ZK8/PLL5nPrnnvuMbVKgwcPNstGjRolpUuXljfeeEN27twps2bNMsdMRkC4EJGqVau6w4WmyuRqJkJDQ9Nv7wS57du3m9v+/fvLI488ctPyRx99VI4dOya//PKL7Nq1i3CRTrQZKkuWLHL16lVzAtMLCSaFWr7088cff5jb++67z1yPSbVo0cLU6i1dutTsM61+R/rat2+fXL58WcqVKyfTp0+XTz75xISKmjVruj/X+vTpYz7ndu/enWF2D+FCxFQZNmjQwKRJrZLSKqx8+fL5e98EPW2CclXt3nnnnVKmTBnzAam0Wl5DhetgzChViYGgY8eOpvbuiSeekJMnT8rUqVPlrrvu8nexgl7hwoXNNvj1119NO77W5OXOndvUXnTr1k2++OILWb58edBvp/SW5a/PrHPnzplA3rhxY3n++edNTYa6du2ae79kpPMO1xaJR6ukXnnlFfnb3/5mLvMO//rPf/5jOqRp6nfRb8rathz/kjh33323fPDBBxISEuKnkganHTt2mOYq7TioH45cUNC/rl+/Lh06dJC9e/eaY6Fv377mR504ccLUYOgypTUbL730kp9LHBzi4uJMx3Pd9nobv3lK79PaCw0eWsunTcEZpXaJoaiJqtk14efKlct0JoR/aY9q7eOi/SmyZcvmHj3iChaFChUyH5iTJ08mWPhBlSpVZNiwYdKoUSP3SQv+o6OopkyZYmphNVxoXyUXPVb0xKXNJEhfISEh5jNKvwRpEI9Pa1w1WOhnndYwZZRgoai5QEDQQKHfvrQ5RPu96Adn/A9PAP/PNZrH00gdrRHU5RnpRBYoYmNjTe1rfK4mrIyGPhd/0XavZcuWydq1a+Xw4cOmh69W8xYoUMAM22rXrp0UK1bMv3srCDHPhXP9/PPPpjlET1bnz58339C0jb9ChQqmtknH8yP96VwK+lmm/ZF0v+gxlDNnTvPtuEmTJmbEAtLf/v375auvvjId1c+cOWOasXRkj46C09qm5s2bZ6gBA9RciMipU6fkscceS7ZqVzvlvPbaa9K6dev03D9BLaV5LpQejMxzkf61SNr5WT8ok6NtydorHunnzTffTHGYcNOmTeVf//pXhjqROd3cuXPNcFQNFEnR0SM6mkSDYEZAuBAxHZs++ugjKVq0qOlAqDUUWmuh/wjaHrZ69WozQ6RWMervyQ29gz16oOn475TmudAPye+++y5DVi06kW7rp59+2hwHul8qVqxo+sToN2Stbtfx+vPnzzcT082ePZuRJOnYwVZH8ujxoB07tdnD1SyinaL1y5OOhNNaWf2ipJNrIe2dPXtWGjZsaI4HrZ2oW7eu6denzSP6BUqHEOvxoiOvevfuLQMHDswQu4VmkXjzKYwePdoME0qse/fuZgpdnVPh0KFD5sMUaY95Lpy9X3TEwfDhwz2uox+k+oGp6zJMNX33izZ9jBkzxuM62myltRa6LuEi/ea5iImJMeeNSZMmJTl3jNbAakDMKBgt8teU3mrhwoWmXcw1FbhW/2rNxaJFi0yq1DZl7YOB9J/nQr8N6xhxF/2GvHLlSua58ON+WbNmjZltMP7IKv2GrNMYr1+/3j1KAem7X3SfaN+x+FO067GjEwXqlPmKeWHST76/5q7QL6Z6bRc9p7jouUbDx5IlSzLcfqFZRMR8EOqQxvjtYVq1GH/Yo+rUqVOS3whgH/NcOJN+OLZv316OHz+e7PwjOq3xl19+STNiOnZK12YqDeIu+oVIf/SzzEWHQ+oXpox0InO6p556yh3slO4TPWZcE2m5+vXp7J06xDsjIFz8ZfPmzWYs8rp16xJ8Q1Z6pTqtQtRrJDCdcfrSVD9hwgRZtWpVgsm0XN+K27RpYyYK4uJY6UuDxcSJE03/i/jfxJT2kdEpqJ999llOYOnswoUL5nNM+yLp0O34tF+Mtv3rftHgh/QNftP+us6L1mDEp/37tOlwwIABGWp4MOEiEU34elBqpyedlEarGjlx+R/zXDiXXmlTT2pKO6q5qufhXxr6tDOhHjv6GaY1Fcxi638XL140x4xrKKrul4w4codw4aWffvrJjBnXMeLaKQrOoNcX0Y62eu2RIkWK+Ls4+ItWzWutU+XKlc0Fm+AM+q1Z58EoWbIkV3d22HQI69atM336dCbPjIAOnV4aN26cqU5MXKUF/9Jriuh+0Ys1wTl0DgzdL1woy1l0KL3ul88++8zfRUE8OuGZ7hedvj2jYCiql+644w7TESqjTHCSUWjnJ23CYhSPs+gVbLWWr3jx4v4uCuLRuWB0v+gsqnCOvHnzmv0SGRkpGQXNIgAAwCpqLv7CtUWciWuLOBfXFnEmri3iTPu5tkjw4doizsS1RZyJa4s4F9cWcaa5XFskOHFtEWfi2iLOxLVFnIlrizjTWa4tEry4togzcW0RZ+LaIs7EtUWcaR/XFgleXFvEmbi2iDNxbRFn4toizpSPa4sEL64t4kxcW8SZuLaIM3FtEed6imuLBC+uLeJMXFvEmbi2iDNxbRFnusa1RcC1RZyJa4s4F9cWcSauLeJMF7m2SHBbu3atuZZIvXr1uJYIAAA+YIbOJHTq1Em2bdsm8+bN4wI/AAD4gAuXAQAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqhqIm4dChQ3LlyhUpVaqUZMmSxe5WBwAgAyNcAAAAq2gWAQAAVhEuAACAVYQLAABgFeECAABYldnu0wGBY/fu3fL111+b3x955BHJly/fTevExsbKO++8Izdu3JCOHTtKiRIlbuk1Z86caZ6jadOmsmHDBvn555/l6aeflkyZ0jbnHzt2TD777LNk1+nXr5/V1zxw4ICEhobe8ja7FdevX5cpU6ZItWrVpEmTJuJ0TthmgA3UXCBo7dmzRyZNmiTTpk1zh4zE1q9fL++++65Z748//rjl15w1a5asWLFC0puGC30PeqXf9LB3715p166dlW12KzQU6vv+/vvvxemcss0AG6i5QNC75557ZOnSpdK1a9ebtsWSJUukYcOG8s0331jfTnXq1DE/6UlrTB588ME0f52LFy/KtWvX0vx1MhK2GTISwgWCXosWLWTYsGFy+vRpyZ8/f4Iq9e+++06ee+45j+Fi586dsm7dOnMSrV69utStWzfB8ri4OFm7dq2pLciTJ4+0atUqwfKkmkV+/fVX2bJli0RHR0vRokVNdX6uXLncj9mxY4cJQloDotXoBQoUkObNm7vXsSGl95ZcOfft2+dugvniiy/kyJEjJtDotti8ebP06dPnpqai4sWLS7Nmzcxrao3Svffea95f1qxZpWXLlmb7eVuulOg23LVrlzzwwAOyfPlyUz4tv/4f6OutWbNGfv/9d7Nd9bWzZ8/ufpzuy4cfftjUdJ04cULKli1r3rc2ZSTefrp9oqKiTJOMljMkJMQs8/QeK1Wq5HGbpbStff2f0PettXHa3FerVi2pUaNGqvY9kBKaRRD09AShM7EmDhCrV6+WcuXKeeyL8c9//lM6deokW7dulZMnT8qgQYPkySefNLO6qqtXr5q/n3nmGTl69KisWrVK2rdvL+fPn3c/h54UtMpeP+iVfpg/9dRTMmDAADl8+LCcPXtWJk+ebELJn3/+6X6MNtPoCU5PQhcuXDB//+1vf5Pjx49b2ZcpvTdvyumJBint/+CpqUhDnNIT34QJE+Tvf/+7OcHOmzfPnHy9KZe3dBtqebUPjTaXnDp1Sl544QX5n//5H+nfv7/pY6PPr+XQAKL70vU4Lf/9998v8+fPN+HixRdfNCHgzJkz7kD6/PPPS5cuXUwg0O0zcOBA6datm9lXSb3HpGYBtvU/oUF31KhR0rlzZ/ntt9/k4MGD0r17dxkzZoxP+x7wWhwQpL766qu4ihUrxm3dujVu3Lhxcd26dUuwfMiQIXGzZs2KW7lypVlv9erV5v7PPvvM/L1o0SL3ukeOHImrVatW3GuvvWb+njJlSlxkZGTc3r173et8+OGH5nHDhw83f//73/82f8fExJi/P/roo7iqVavGHT161P2Yixcvxt1+++1xb7/9doLHvP/+++51zpw5E1e9evW48ePHJ/leN2/ebB7Xq1evuIkTJ970ExUV5fV786acrtdzbTOl27hatWo3la1JkyZxQ4cONb9rWfRx8+bNM3/HxsZ6XS5Prly5Yh43cuRI932ubTh9+nT3fR988IG5r1+/fu77tmzZYu775ptvEjzOtf/UsWPH4mrXrh03bNgw9zqVK1c279/l8OHDcXfccUfcs88+m+x79LTNbP1P6Gslfu41a9aY+37++edb2saAJ9RcACKmCnnjxo2maUTpt1WtYtb7E9Pqa63taNu2rfu+2267zVShf/755+Zb4qJFi6RRo0am5sNFv1km13SRN29eGTlypKn21ufQb6pa4xEeHn5TJz/t+Bf/cdqsoN9Gb5U3782XcqaWqyre1ZTgTbl81aZNG/fv5cuXN7fxm65c92ntQnxau+FSuHBhUwOifXa0lmHBggVmv99+++3udYoVK2ZqN3Qd7VeR1HtMy/+JL7/80jRx1K9f371OvXr1TM2Ea9ulxTZG8KLPBSBi2sWLFClimka07fqHH34wH7R6nw5ZTdyrv2DBgvKvf/0rwf3a/KHNHlpdru3e2hE0wcGWObOULl06ye2tH+Jz5swx1e7ab0E/zO+66y5z62o6cUncVBMWFmaq5G+1Q2dK702ryn0pZ2po/xPd7r6Wq1ChQj69jvZLcHH1mYjf58Z1n444cdG+Hxoo4itTpoxcvnzZlEVP+Np3JDENKvo8Gg6Seo9p+T+h/4+eOg/37NkzTbcxghfhAoh34nWNGtFRItrBzxP9UI+IiLjp/tq1a5sfbT/Xb6Oevukld/IdN26cTJ8+3bSxa9u3dvLTE4Sn+RmS+7Z7K7x5b76U0xvxT96u95a4g6Q35fJV4tfwhgbEpPapPp/uc0/7xrWO6/Ge3mNa/k8k3saepMU2RvAiXAB/0TDx0UcfmW+fK1euNFXGnmjnz2zZst006dSPP/5oRhlo04d+m92/f3+C5a5vrpUrV/b4vHPnzpXGjRubznsuWtWuHQ7TS0rvLWfOnF6V09OJzvVNOv4JWLfJuXPnrJQrPWizmTZt5MiRw32f7ufcuXObJgSd/EprGBLTWgF9/9q8kRRP28zW/4RuP09NVh9//LFpQtEaEqdsY2QM9LkA/nLnnXeaam8dOaAftCVLlvS4bbQ3vfbP0CGLLnqCHDFihBnGp1XeDz30kGkb3759u3sdHWGQ3IlUP7x16GJ8s2fPNieTmJiYdNlP3rw3b8qpfQJU/KYabWbSb8c6WsFFa4q8GYngTbnSgwajGTNmJJicTEdoaPm0JkJv9WSsI0VctM+G9lnQ8Ooa1uqJp21m63+iQ4cOZijrL7/84r5P+2O8/PLLcunSJUdtY2QM1FwAf9EPT20a+fTTT5OdCvvRRx81oUHbq/Ubn7ZTa18NbfPWoYlKhzXqCUbX1Q5y+gGuYSO5Nmud70KHC/bo0cPUbugHus5LoP00khviaZM3782bcuo3eP0WrEM3f/rpJxk+fLjpi1CxYkUzz4V2PtS+KXrCc3WcvNVypRcNE/qetRZi2bJlpvOmq5OnbhPdFo899pi0bt3aBAZdR5sztGNmcjxtM1v/Exp29f/xiSeeMOXS11m8eLH539T+HE7bxgh8ITpkxN+FAPx5bRH94HV10tMP72+//dZ84Gpve9c3vIULF950bRGduEjnLNBvmnqC1A6cib/d6TdFnThKP8z15KrfarUaOqlri8Sf5EhPINqjf9OmTeYbZa9evcwJQh+TOPxo9blWzeuJI7lri9x3331StWrVFLdNSu8tpXJqE4A2D7gmidJ5HpR+49Y5LQ4dOmROzjoaR7e3fqN3TaKl26Vv376pKpc31xZxbff421Cbq3SkR/z97npsgwYN5I477jDzS+j8FLpPtcOvblPdlvreE3PVEujHq65z9913J5hEK6n36Gmb2fyf0FojfW2tZdFQVLNmzVvexoAnhAsA8IIrXOjJHkDyiKMAAMAqwgUAeEHniUiquQZAQjSLAAAAq6i5AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAGLT/wF9Z3solK06+QAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Generating Composite Feature Importance Plots...\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAACHYAAASvCAYAAABmGu+gAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3QeYldW5P+yHYRh6FSkiUo0FCypiix6DotjAWM6xxR6joLF7jiXBlthNNMaamNhRIyqWaBRyrNgSRYOKqEHARpE+dOa73vX/Zg4jbWAPsGfPfV/Xe609b1trv+zZbX48q05ZWVlZAAAAAAAAAACQd4rW9wAAAAAAAAAAAFg+wQ4AAAAAAAAAgDwl2AEAAAAAAAAAkKcEOwAAAAAAAAAA8pRgBwAAAAAAAABAnhLsAAAAAAAAAADIU4IdAAAAAAAAAAB5SrADAAAAAAAAACBPFUcNNH/+/Hj88cejQ4cOsfvuu69036+//jrefPPNqF+/fuy2227RrFmzdTZOAAAAAAAAAIBaF+y499574/rrr4+99tprpcGO5557Ls4777xYuHBh+rlly5bx5z//OTbffPN1OFoAAAAAAAAAgFoyFcsTTzwRv/nNb1a5X2lpafzyl79MoY7evXvHpptuGtOmTYvBgwevk3ECAAAAAAAAANSaih2LFy+Os846K/72t79FnTp1Vrn/a6+9FjNmzIhu3brFfffdl25nU7G89957aXqW9u3br5NxAwAAAAAAAAAUfMWORYsWpVDHNttsEz//+c9Xuf+YMWNSu9VWW6W2efPm0blz53T7k08+WcujBQAAAAAAAACoRRU76tatm6Zg6devX5qOZVWmT5+e2mbNmlWsa9KkSaVtq+Pdd9+NsrKyqFev3mofCwAAAAAAAJDPFi5cmGZO2G677db3UICaGuwoLi6O/fffv8r7ZyGMNdm2smOyZcGCBat9LCtWUlJSEJfH4yJ3HgsAAAAAAAAANTjYsboaN26c2rlz51asmzNnTqXKHasjq9SRBTu6d+9ejaOs3bLEX8OGDWPYsGExZcqUqIlat24d/fv3T4+zNQkMrQvZ2MaNG5emIsqudz4/Fr788suYP39+1ET169ePDh06eCzUADXhd2Jtcw1cB48HvxOeGzxHep3weul9g/dO3kN6L+3zhM9VPl/6jO27Bt+5+N7J929rm+8ha55PP/00/c0GyD8FG+zo1KlTaj/77LOKigoTJ05Mt7t27bpG58yeyBo1alSNoyQzevTomDBhQo28GB07dkzBjprwx+FsjPn++P3mm29i9uzZURNlgbEs2OGxUHPUhN+Jtc01cB08HvxOeG7wHOl1wuul9w3eO3kP6b20zxM+V/l86TO27xp85+J7J9+/rW2+h6w5hDogfxVMsCP7Y/BTTz0VDRo0iB//+Mex2267Rd26dePdd9+NX/3qV+kPxqWlpel/aK9psAMAAAAAAAAAYF0qigIxderUuPTSS+Pqq69OP7dr1y5OO+20dPvee++Nv/3tb1FcXBwXX3zxeh4pAAAAAAAAAEABV+zo0qVL/Nd//VdsscUWFeuaNm2a1jVu3Lhi3RlnnBE77LBDvPLKK1GvXr3Yb7/9Kh0DAAAAAAAAAJDPamSwY7vttkvL0lq1ahWXX375MvvuuuuuaQEAAAAAAAAAqGlqZLADAAAAAAAAgJpt8eLFsXDhwvU9DFjnshlH6tatW+X9BTsAAAAAAAAAWGfKysrim2++ienTp7vq1FotWrSIdu3aRZ06dVa5r2AHAAAAAAAAAOtMeaijTZs20ahRoyr9YRsKKdhUWloakyZNSj+3b99+lccIdgAAAAAAAACwzqZfKQ91bLDBBq46tVLDhg1Tm4U7st+FVU3LUrSOxgUAAAAAAABALbdw4cLUZpU6oDZr9P//DpT/TqyMYAcAAAAAAAAA65TpV6jt6qzGFESmYgEAAAAAAACA1TRt2rRYtGjR//3xvbg4mjRpEvXq1VtrfbVo0aJK51/d/dfE7NmzY+7cuSvcXlRUZLqdaiLYAQAAAAAAAEAeWBwRdWtM3z/5yU9i7NixldZl4Y4dd9wxLrnkkujevXu1ja68rwceeCB69epV7fuviRtvvDGdf2VTjbz77rtrpe/aRrADAAAAAAAAgDyQBSuOjoiP1nG/W0TEigMKq9K0adMoKSmJefPmxZw5c2LkyJFx1FFHxeOPPx4dOnSolhG2bNkyWrdunfpZG/uviaw6SdZHJrvvWQWPrDpI8+bN07qGDRuutb5rG8EOAAAAAAAAAPJEFuqoWVUeLrvssjjggAPS7ffffz/OO++8+OKLL+J3v/tdXH311ZX2nT9/fixcuDCFIpZn8eLFKRzSrFmzSutvvvnmiqlVlpYFKrJjGjduXKX9M7NmzYr69esvE/r47rvv0rmysEadOnVSUGNF48ycc845ack8+uijqUrJ1ltvHQ899FDFPtOnT0/3t1WrVunc2XmXnhom25ZN5/L9+1vV7bVF0foeAAAAAAAAAAAUgm222SbOPffcdHv48OFRVlaWbk+dOjVOO+202G677WKHHXaIgw46KP7xj39UCmgMHjw4TZuSTeXSu3fvuOuuuypNrfLDH/4wRo0alX5+/vnno2/fvrHtttvG9ttvn7bdf//9K9x/yZIlcccdd6R1WR/ZMaeeemp8+eWXFcdkVUay7VlI4z/+4z/SOHfZZZf085rK7nN2ziuvvDLd9+y+TZgwId3fLAiSjSNb96Mf/Sj++te/VroeK9te2wh2AAAAAAAAAEA1yapWZGbOnBmTJk1Kt7PKFiNGjEgVK7IqGJ988kmcfPLJMXHixLT94osvjiFDhkRpaWk0atQoZsyYEddff3088cQTy5z/22+/TeGR8ePHp0odWYWNLEBy++23p4ohy3PdddfFjTfeGJMnT07nz6p5/P3vf4+jjz46VdVY2i9+8Yu0rqioKFXxyEIZ2Xhy8eCDD0bdunVTBZGNN944rrnmmhQYycaRVeP46quv0jV6++230/6r2l7bCHYAAAAAAAAAQDVp2LBhxe1sWpUPPvgg3njjjWjXrl0Kajz33HMxcODAFOJ4+OGHU9jimWeeSaGPP//5z/Huu++mYEMW2MjWf9+0adPSFCXdunVLVSxee+21tLz66qupYsj3ZeGM++67L92+6qqr0vmzkEnnzp3j66+/ToGSpe23334pQPHss8+m6Vqy6hmff/55Ttdkzz33TBVKsvufTQWT3e/s3A888EDqJ7u/WVWR7P5ngZiVba+Nitf3AAAAAAAAAACgUMyePbvidlZRo7yKxjfffBMHHnhgpX2zbVloIqu40aFDhzT1Sebggw9Oy/L84Ac/iH322Sf+9re/xR577BFt27ZN05z069cvLVlAZGkfffRRCoJ07NgxDjnkkLRuo402iv/8z/+Ma6+9NgVPlnbooYemUEWXLl1SdY1sfNnxudh7772jXr16qWJHdp8XL16cliOPPHKZ6zFu3LiVbq+NBDsAAAAAAAAAoJpkFTEyLVu2TKGLcllYIptWZGlZCCOboiQzd+7cStumTJmSAh9Z5Y6lZVOk/O53v4v33nsvXn/99fjXv/4VI0eOTJVALrzwwjj++OMr7Z/1m5k/f346X3nwI6sYsvT2ctlUMd8/NjsuF9m1+L7sfn9/fRb+qOr22kSwAwAAAAAAAADWUDa1SDadSlZhIgtZ3HDDDWn9j3/849RuvvnmqW3evHnallXCKA9X1K9fPwU1sgBFNmXKrbfeGgcccEC88sorccUVV6TpUp5//vlK/WXTu2ShjKzCx+GHHx4DBgyIO++8M02pkoU9vm/LLbdM08NMmjQpTcVy9NFHpyoc999/f9q+6667Vtr/+xU/qkN5eCWT3f8GDRqkqVUuvfTSNH1Mdg3K98vCGyvbXhsJdgAAAAAAAADAGho8eHBalpaFFwYOHFgR7Nhrr71i+PDhceyxx1ba77rrrov+/fvHSSedFLfddlvcdNNNaSlXfo6ljRkzJn7yk5/EokWLltnWt2/fZdZl08GcddZZKdRxzz33pKVcr169Vjjly9rStGnTNP677rorTj/99Erbsvt75plnrnJ7bSPYAQAAAAAAAECe2KLG9JlNE7L0NClZNYkNNtggdt999zj55JNTgKFcVqnj9ttvjxEjRqSKG1m1jaxyRr9+/dL2LHiRTdsydOjQmDp1atp+1FFHxX777Vepr6yyR1bBIgtn3HvvvfHJJ5+kgMfGG28cRx55ZOy7777L7J/JpmfZZJNN4sEHH0zVOrLpVrIQyCmnnFIxvUmrVq1S9ZGlpzspP8+qpkDJKmxk+7Vo0aLS+uznbH1WmWRp55xzTlr/1FNPpUolG264YQq4ZNekKttrG8EOAAAAAAAAAPLA4oh4YD32vXrTfNx3331V3jebCuXss89Oy4pkwYxsqUpfWaWNbFmdsfXp0yctK5KFPr7vz3/+c1TFQQcdlJbvy6qQLE82tUoWNsmWNdle2/y/iWgAAAAAAAAAYL2qW0v7hpUT7AAAAAAAAAAAyFOCHQAAAAAAAAAAeUqwAwAAAAAAAAAgTwl2AAAAAAAAAADkKcEOAAAAAAAAAIA8JdgBAAAAAAAAAJCnBDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4qXt8DAAAAAAAAAICaZvLkyTF//vxo0aJFNGnSZK329e2338bChQujTZs2UVJSsl7OUX58uTp16kTDhg2jefPmUbdu3SgU31bDta5uKnYAAAAAAAAAsN4tWbKkRvV9zjnnxF577RVPPfVUrG0nnXRS6uv9999freMWLVqU8znKnXLKKen48qVPnz6xyy67xA477BD/8z//k0IuheCkHK/T2qBiBwAAAAAAAADrXVFRUfzpT3+Kb775Zp32265duzjhhBMin7Vt2zZKS0ujfv36Vdr/vffei9/97nfxn//5n7Hvvvuu0TlWpGXLltGoUaMoKytL55s+fXo8/vjjscEGG8T5558fNV3barpO1UmwAwAAAAAAAIC8kIU6JkyYEIUmqwjy3XffpUBEtizPjBkzori4OBo3bpz2zcIFrVu3jgYNGsSvf/3riulBljZz5sxUlSMLW2RTo2SyY6+55pr45z//mSpPTJkyJZ1nRedYsGBB6jvbp/wcK3PhhRfGgAED0u0s3HHVVVfFPffcE3/961+XCXbMnj07VfLIQh+re5+//vrrWLx4cWy88cbpfmbrlp4aZVXnXt61qcr2FV2nlf0blk/fstFGG6Wfp02bFq1atarS9awKU7EAAAAAAAAAwFqQBQduvvnmNGXJbrvtlqYtyaqDfPHFFxX7TJ06NU488cTo3bt3Wm688ca49tprUyhj5MiRy50e5Omnn4499tgjdtxxx3TunXfeOe6+++607dJLL02hjsxll10W55133nLPMWfOnBTSyMb0wx/+MLbffvu45ZZbVuv+ZcGF7LhMFspYOuiQ9derV6/YddddU9WQN954Y7Xu88EHH5x+/sUvfpHuZ3Z/sxDKqs69smtTle3fv05V+Tc87rjj0jEPPPBAupbZuLLzP/jgg1EdBDsAAAAAAAAAYC24+uqr4/e//32arqRFixYpCPH666/HMccck6o/ZH75y1/Ga6+9lm43bdo07rjjjnjppZdWeM4s2PDf//3fqc2qTXTo0CFVvLj//vtTGCGrFFE+jUh2O6uAsTwXXXRRDB06NFWayMaWBTOy6VseffTRld6nrBrFxIkTU2WVf/3rX3Hvvfem9VtuuWXFPueee268+uqrUa9evVRRY9y4cfGzn/2sohrL6tznRx55JJo1axY9evRIFTtWdu5VXZtVbV/Tf8NyV155ZaoiklUhmTVrVqpmkl2vXJmKBQAAAAAAAACqWVaV4qGHHkq3s4oUBxxwQEyaNCmOP/74+Oyzz9K2ww8/PF588cUUFrjrrrti9913T9U2jj322BWeNwsKZFUkunXrlgIRHTt2rLR9m222SWGHrPLF4MGDo1+/fsucIxvH888/H0VFRXHfffel6hfZVCrXXXddjBgxIo1rRbKwQrYsLQtenHPOOel2FpB4++23o127dml8TZo0icceeyxuvfXWdJ+z+7869/mkk06KCy64IE29sqpz9+/ff6XX5uOPP17p9jX5Nxw0aFDF/gcddFAKgmRTCu2///4p5JH9W2Qhklyo2AEAAAAAAAAA1eyjjz5KIYJOnTqlQECmTZs2cdhhh6XbH374YYwfPz7d3njjjVPAIZNNbbLVVlut8LybbbZZHHjggSlYsPfee6epRE499dR44oknYsmSJVUa2+effx5lZWWx0UYbpVBHZr/99kuhjttuu22lx2YhhaWDClmY4amnnqoYczauTBZuGDBgQJqiJAteZLIKH6t7n/v27ZvaLMSxqnOv6tqs7rWryr/h0rIxZdU6svuWLZmsIkquVOwAAAAAAAAAgGrWoEGD1GZTnGShgaw6RiaboqN8e/m6uXPnpqBFVsUiM2fOnBWeN9vnhhtuiJNPPjlNCZIFGt588834+9//HlOmTEnrVyWbxqS8n6X7/fLLL9PP2RQl5eu+78ILL0wBhueeey5V0sjaLKCRrSsfX/n9y6ZK+f41Wd373KxZs0r3fWXnrsq1WZ1rV5V/w6Vl4ZPvX+PsPuZKsAMAAAAAAAAA1tD06dNj4sSJldaVlJTElltuGY0aNYrJkyfH5ZdfHkcddVSqlHH//fenfXbdddfo3r171K9fP4UKfvvb36ZqEtkUKZ988skK+5s5c2ZamjZtGvvuu2/86Ec/isaNG8ejjz4ao0ePTvuUBxD+/e9/x6effpr6WVpWuSLrN5vWJes3q0bxyiuvxLXXXhtdu3ZN07KsSjbFSxZaOOuss+Liiy+OLl26pGlgevToURFyuPTSS9P68kBGdj2yiharc5+Li/8v1rCqc6/q2lTl2i2tKv+GS1tRGCZXgh0AAAAAAAAAsIaycEK2LC0LIAwdOjTOO++8FAh46KGH0lJul112qZi244gjjoh77rknbr/99rRkQYJsipSvvvpquUGBcePGpYDB8qb4yMIWmQ033LBibFloIptqZGlZMOJnP/tZ3HzzzRX9ljvjjDOqfN+z6VtefPHFePrpp+P8889P/Wy66aZpHFklj5/+9KeV9v/Nb34T+++//2rf53KrOnc2/cnKrk1Vrt3SsnGt6t9wXRDsAAAAAAAAACAvtGvXrsb02bp16zRlyfK0adMmtUcffXR07tw5Hnzwwfjss89SpYi+ffvG8ccfX1GJIgsaZFUk3n777Wjbtm2cc845cf3116eQQ1b5I5Otz6YDySpdbL311ul89957b4wdOzYWLVqUAg1HHnlk7Lnnnmn/U045JVXEyM6RVdH4/jkygwYNivbt26cASrZvdl+y8fbp02eF9ymbgiSrcLG0rFpHVm0jm0olG1MWGMkqf2RVQUaMGBGzZ8+uCFyUn7sq9zkLemR9FS9VsSOzqnOv6tqsavv3r1NV/g2zYxYsWFAx9qWvV/l5ciHYAQAAAAAAAMB6t2TJkjjhhBPWW9/l05dUVVYhoip22223tCxPNpXJj3/84xQkyNosFJFNn/Lxxx9XBAYyf/zjHysdl4U1siDEinTr1m2ZY77/c+aQQw5JS1Xcddddy13fqlWreOqppyqty8IMAwcOTMua3ufHH398uf3VX8m5q3JtVrV9eddpZf+Gmaz6SFWv15oQ7AAAAAAAAABgvVvdYEUh9J1NO5JNAZJVzciCDEuHGbbaaqsU0Cg0tfE+50qwAwAAAAAAAADWk1/+8pepSsVrr70W06dPT9OP9OrVa4UVKQpBbbzPuRDsAAAAAAAAAID1pGHDhnHWWWelpbaojfc5F+uvlg0AAAAAAAAAACsl2AEAAAAAAAAAkKcEOwAAAAAAAAAA8pRgBwAAAAAAAABAnhLsAAAAAAAAAADIU4IdAAAAAAAAAAB5qnh9DwAAAAAAAAAAappvvvkm5s+fH61bt47GjRtXrJ87d25MmjQpGjZsGG3atKnSub7++utYsGBBtGvXLurXr1/tYy0/f7mioqIoKSmJVq1aRb169aq9P6qXYAcAAAAAAAAA611ZWVnUqVOnxvQ9cODAGD16dPTt2zduueWWivVvv/12/PSnP40f/vCH8cc//rFK58r2Hzt2bDzwwAPRq1evqG6nnnpqfPzxx8usb9KkSRxzzDFx9tlnV3ufVB/BDgAAAAAAAADWuyxY8dFHH0Vpaek67bdRo0axxRZbrPHxL7zwQowcOTJ22WWXNT5H+/btU/WPBg0axNqUVRfJ7m8WZJkzZ0589913cfvtt6dKIUceeeRa7Zs1J9gBAAAAAAAAQF7IQh2zZ8+OmubXv/51PPHEE1G3bt2V7jd9+vQ0VUvLli0rhTguv/zyiqlYVjTFy5dffhmLFi2qNF3LjBkzYt68edG2bdsqjfOCCy6IAQMGVPz8y1/+Mh5++OF4//33lwl2LG+s3377bepvgw02SNU+yk2YMCGWLFkSG220UcXULqsaWxYqWbx4cZoOZlXXrbYrWt8DAAAAAAAAAICaqkOHDvHJJ5+kgMSKvP7662nKlp122in23HPPNN1KFrJYuHBhxVQs++yzT3zwwQdx5513pts333xzxfFZoGLvvfeOgw8+OIU7svDHcccdF71794499tgj9tprr9THqkydOjW++OKLGDduXLzzzjtp3JkddtihSmP9wx/+kMZ27bXXVuyfnS8b2+GHH54qgaxqbFkAZrfddksVTrLpanbeeed0n1kxwQ4AAAAAAAAAWENnnnlmqlKRBTFmzpy5zPasEseNN96Ybm+yySax4YYbppDEk08+GS+++OIy+//nf/5nap955plU0SLz9NNPp4oY++23X6ricc4558Qbb7yRKmm0adMmJk6cGKeeemoKWazMNddck4IZ++67bxx99NHx7rvvxqGHHhqHHXZYlcb64x//uGL6mfKxPf/886nNzltSUrLSsWWhj4suuiimTJmSzp310aJFi3j00UdT1RCWT7ADAAAAAAAAANZQp06d4thjj41p06bF7373u2W2Z2GHv/zlLykMkS2vvvpqHHjggRXTq3zf5ptvHltttVVMnjw5Ro4cmdZlwYpMFsAYNWpU/OMf/0hTsgwZMiTuv//+GDhwYJq+Jft5ZbLpXbIwxcYbbxzNmzevOPfjjz9epbFuueWW8YMf/CBNo/LWW2+l9dl+mYMOOmiVY8umZ8kCId26dUvbyvvJlm222cZjcAWKV7QBAAAAAAAAAFi1LLyQBSQefPDBNDXL92WBhmHDhqXQQ1aZIgtGZLJpVZYnq9rxr3/9Kx2TVbYYM2ZMdO3aNbbffvsYOnRo2ierfpFNzbK07JiVyaZUGTBgQMXPd999d6riceWVV6ZqIFmVjVWNNeszm4olq9TRpUuXNH1M27ZtY8cdd0zTrKxsbFn/2fpsv6xqSLNmzaJnz57Rr1+/tL5u3boebsuhYgcAAAAAAAAA5KBJkyZx1llnpfDDbbfdVmnb9OnTU1DjzjvvTFOZZMGMI444Im2rU6fOcs93wAEHRKNGjWL48OEVYYny6VKKiv7fn/mz7Vn1jaWXbJqW1ZFV2cjMnj07vvrqqyqNNTsmC2BkU7Nk4Y6ysrI03mxcqxpbdo4sSPLUU0/FhRdeGP/xH/8RH330UZqe5Y9//ONqjb02UbEDAAAAAAAAAHJ06KGHpoodH374YaX12XQq48aNS5U8ssBDNl1JFmxYVVAkq6Dx2GOPpSlL6tWrV1EBI5umJZNV18gCEVnVjPLQRXb+lZk6dWp88cUX6fa8efPSeMunYMmqbrz88surHGubNm1i1113jVdeeSXuuOOOSgGRVY0tC45kFUHq168fP/rRj2K33XZLfWf3Mwt4sHyCHQAAAAAAAACQo6xaxcUXXxxHH310pfXdu3dP27788ss45phj0rry6VpmzZq1wvMdfvjhKfCwYMGC6Nu3b2ywwQYV59t///3j2WefjVNPPbVi/yxAcdNNN6UpTlYkq5aRLd+XjSurqFHVsWYhkyzYkQVFunXrFltuuWWVxrbRRhvFUUcdle7T92XHsXyCHQAAAAAAAADkhVVVnMinPtu3b5/CDln1iXK9evVKU5m88cYbqbJFZtNNN43f/va3cd9996X9+/XrF3vuuWf8/Oc/j/Hjx1eca/78+anSRbntttsudtlllxSyKJ8OpVwWzthiiy1ixIgRaRqVjTfeOI488sg0tcmKxlpaWlrxcxbeKC4ujpYtW8Zee+0Vxx13XJXHmtl7771TEGTOnDlpGpbVGduQIUPS+T/55JM0dU22Pbt/e+yxxxr9O9QGgh0AAAAAAAAArHdlZWUpELC++i6fMqSqfv/73y93/RVXXLHMuqyKxvcrabzwwgsVt++6667lnuvPf/7zctdn05eccsopaamK22+/vUr7VWWsmYULF1ZU3chCHqszth49esTVV19d5fEg2AEAAAAAAABAHljdYEWh9F2TzJgxI77++uu45557UrijZ8+esdlmm63vYRU8FTsAAAAAAAAAgFWaOnVqnH/++SkIc8ghh8TZZ5/tqq0Dgh0AAAAAAAAAwCp17do1nnrqKVdqHSta1x0CAAAAAAAAAFA1gh0AAAAAAAAAAHlKsAMAAAAAAACAdaqsrMwVp1YrW43fAcEOAAAAAAAAANaJevXqpba0tNQVp1Yr/f9/B8p/J1ameB2MBwAAAAAAAACibt260aJFi5g0aVK6Go0aNYo6deq4MtSqSh2lpaXpdyD7Xch+J1ZFsAMAAAAAAACAdaZdu3apLQ93QG3UokWLit+FVRHsAAAAAAAAAGCdySp0tG/fPtq0aRMLFy505al16tWrV6VKHeUEOwAAAAAAAABY57I/bK/OH7ehtipa3wMAAAAAAAAAAGD5BDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4S7AAAAAAAAAAAyFOCHQAAAAAAAAAAeUqwAwAAAAAAAAAgTwl2AAAAAAAAAADkKcEOAAAAAAAAAIA8JdgBAAAAAAAAAJCnBDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4S7AAAAAAAAAAAyFOCHQAAAAAAAAAAeUqwAwAAAAAAAAAgTwl2AAAAAAAAAADkKcEOAAAAAAAAAIA8JdgBAAAAAAAAAJCnBDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4S7AAAAAAAAAAAyFOCHQAAAAAAAAAAeUqwAwAAAAAAAAAgTwl2AAAAAAAAAADkKcEOAAAAAAAAAIA8JdgBAAAAAAAAAJCnBDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4S7AAAAAAAAAAAyFOCHQAAAAAAAAAAeUqwAwAAAAAAAAAgTwl2QIErKiqKli1bphYAAAAAAACAmqV4fQ8AaruysrKoU6fOWjt/gwYNomvXrlGT7wMAAAAAAABAbSXYAetZFogYNmxYTJkyJWqi1q1bR//+/df3MAAAAAAAAAAKkmAH5IHRo0fHhAkToibq2LGjYAcAAAAAAADAWlK0tk4MAAAAAAAAAEBuBDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4S7AAAAAAAAAAAyFOCHQAAAAAAAAAAeUqwAwAAAAAAAAAgTwl2AAAAAAAAAADkKcEOAAAAAAAAAIA8JdgBAAAAAAAAAJCnBDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4S7AAAAAAAAAAAyFOCHQAAAAAAAAAAeUqwAwAAAAAAAAAgTwl2AAAAAAAAAADkKcEOAAAAAAAAAIA8JdgBAAAAAAAAAJCnBDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4S7AAAAAAAAAAAyFOCHQAAAAAAAAAAeUqwAwAAAAAAAAAgTwl2AAAAAAAAAADkKcEOAAAAAAAAAIA8JdgBAAAAAAAAAJCnBDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4S7AAAAAAAAAAAyFOCHQAAAAAAAAAAeUqwAwAAAAAAAAAgTwl2AAAAAAAAAADkKcEOAAAAAAAAAIA8JdgBAAAAAAAAAJCnBDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4S7AAAAAAAAAAAyFOCHQAAAAAAAAAAeUqwAwAAAAAAAAAgTwl2AAAAAAAAAADkKcEOAAAAAAAAAIA8JdgBAAAAAAAAAJCnBDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4S7AAAAAAAAAAAyFOCHQAAAAAAAAAAeUqwAwAAAAAAAAAgTwl2AAAAAAAAAADkKcEOAAAAAAAAAIA8JdgBAAAAAAAAAJCnBDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4S7AAAAAAAAAAAyFOCHQAAAAAAAAAAeUqwAwAAAAAAAAAgTwl2AAAAAAAAAADkKcEOAAAAAAAAAIA8JdgBAAAAAAAAAJCnBDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4S7AAAAAAAAAAAyFOCHQAAAAAAAAAAeUqwAwAAAAAAAAAgTwl2AAAAAAAAAADkKcEOAAAAAAAAAIA8VRw1zEsvvRSvvPJK1K9fP/bbb7/YaqutVrjv4sWL45lnnokPP/ww7b/LLrvEzjvvvE7HCwAAAAAAAABQK4Idt956a9x0000VP//pT3+KW265Jfr06bPMvkuWLImf/vSn8dprr1Wsu/322+PnP/95DBo0aJ2NGQAAAAAAAACg4KdimTp1agp21KlTJ0488cTo169fqshx1VVXLXf/UaNGpVBH06ZN49xzz03HZMfecccdsWjRonU+fgAAAAAAAACAgq3YkU2/snDhwthuu+3iv//7v2PBggVp3fjx4+Ozzz6Lbt26Vdp/5syZqd11113jlFNOibKysjQty6RJk2LevHnRpEmT9XRPAAAAAAAAAAAKrGLHv//979R27do1tSUlJdGxY8dK25a28847R/fu3ePFF19MU68cc8wx8e2338bBBx8s1AEAAAAAAAAA1Ag1pmLH7NmzU9uoUaOKdQ0bNqy0bWn169ePCy64IIU6snBHpmXLlmlKljWVVf0oLS1d4+OpLJsap/zfsKabO3duenysLtfAdVjXj9Ol29rKdXANPBb8Tnhe8PzodcJrpfcM3jt5/+h9tM8TPlP5bOkztu8ZfN/ieyffvfkOcu3zXWzNk/2tK/vbFZB/akywY3lPIuV/SF/etjFjxqRQRxbwOP3002PGjBnx5z//OX7yk5/Ec889l0IeqyubCuajjz5aw3vA92Whji233LIgLkxWNWZN/ljuGrgO68O4cePWS7/5xnVwDTwW/E54XvD86HXCa6X3DN47ef/ofbTPEz5T+WzpM7bvGXzf4nsn3735DnLt811szZLNmgDknxoT7GjevPky1TlmzpyZ2hYtWiyz/9NPP52CGKecckqceuqpad3EiRPjb3/7W4wYMSIOPfTQ1R5DvXr10vQuVI9CSvx16dJljSt21PZrkHEd1o0sfJS9ge7cuXPBVMtZE66Da+Cx4HfC84LnR68TXiu9Z/DeyftH76N9nvCZymdLn7F9z+D7Ft87+e7Nd5Brn+9ia55PP/10fQ8BqOnBjm7duqX2/fffT388zipwTJgwIa3bbLPNltm/vHrClClTKtZNmzYttXXr1l3jPz4vPRUMlKvNfyQv5xrUnOuQjdFzmevgseB3wnOD50evE14vvWfw3sl7SO+jfZ7wucpnS5+xfdfg+xbfO/n+zXeQa5fvYl2HmqaQ/iMuFJoaE+z44Q9/GI0bN47PPvssjj766Jg+fXqqyLHDDjtEu3bt4rvvvosbbrgh7XPRRRel/e+777545JFH4uuvv05Bj7fffjtNzbLjjjuu77sDAAAAAAAAALBKRVFDNGvWLK688soUzPjHP/6RAh4bbLBBXHbZZWn7rFmz4i9/+Us8+eST6ec999wzTcFSXFwcL7/8cgp1ZMnIbP8OHTqs53sDAAAAAAAAAFBAFTsy+++/f/Tq1SuFNOrVqxe77rprNGnSJG3LQh5Z8KOkpKRi/7PPPjuOOOKI+OCDD6KoqCi23Xbb2HDDDdfjPQAAAAAAAAAAKNBgR6ZNmzZxwAEHLLM+C3gcfvjhy6xv3759WgAAAAAAAAAAapoaMxULAAAAAAAAAEBtI9gBAAAAAAAAAJCnBDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4S7AAAAAAAAAAAyFOCHQAAAAAAAAAAeUqwAwAAAAAAAAAgTwl2AAAAAAAAAADkKcEOAAAAAAAAAIA8JdgBAAAAAAAAAJCnBDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4S7AAAAAAAAAAAyFOCHQAAAAAAAAAAeUqwAwAAAAAAAAAgTwl2AAAAAAAAAADkKcEOAAAAAAAAAIA8JdgBAAAAAAAAAJCnBDsAAAAAAAAAAPKUYAcAAAAAAAAAQJ4S7AAAAAAAAAAAyFOCHQAAAAAAAAAAhR7sKC0tjUceeSTOPvvsOOSQQ6Jv377x0UcfVWy/5ZZb4oMPPqiu7gAAAAAAAAAACl5xdZxk+PDhcfHFF8e0adMqrZ8/f37F7ZdffjluvfXWuPzyy+Owww6rjm4BAAAAAAAAAApazhU7XnjhhRg0aFBFqKNDhw7RpEmTZfZr2LBhLF68OAYPHhyjR4/OtVsAAAAAAAAAgIKXU7Bj5syZcckll0RZWVn07t07nn322RgxYkR069ZtmX1vuumm6NGjRyxatChuu+22XLoFAAAAAAAAAKgVcgp2DBs2LKZPn56CHH/4wx+WG+go16JFizQNS/m0LFnAAwAAAAAAAACAtRTseOutt1J77LHHRv369Ve5/1ZbbRUbbrhhzJ8/PyZMmJBL1wAAAAAAAAAABS+nYMd3332X2pVV6vi+LNiRmTNnTi5dAwAAAAAAAAAUvJyCHQ0aNEjtzJkzq3zM5MmTU9u0adNcugYAAAAAAAAAKHg5BTvKK3UMHz68SvuPHDkyBTsaNmwY7du3z6VrAAAAAAAAAICCl1OwY5999knt448/vspwx4QJE+Kiiy5Kt3ffffcoKSnJpWsAAAAAAAAAgIJXnMvBO+ywQ/Tp0ydGjBgRZ5xxRhx88MGx7777xty5c9P2WbNmxahRo9L2+++/P2bPnh316tWLgQMHVtf4AQAAAAAAAAAKVk7Bjsy1114bxx13XIwePToee+yxtJQ7+eSTK+1bt27duOyyy2KLLbbItVsAAAAAAAAAgIKX01QsmaZNm8aQIUPitNNOi+bNm69wv2222SbuueeeOPTQQ3PtEgAAAAAAAACgVsi5YkempKQkzjrrrDTFyvvvvx9jx46NmTNnpgodrVu3jp49e0bnzp2roysAAAAAAAAAgFqjWoIdSwc8evXqlZZykydPTuEOAAAAAAAAAADW8VQsmblz58Yf//jHOOSQQ1LFjqUNGjQodtlll7jyyitj0qRJ1dEdAAAAAAAAAECtkHOwY8KECXHwwQfHtddeG6NHj44lS5Yss8+0adPivvvui/322y9efvnlXLsEAAAAAAAAAKgVcgp2LFiwIE499dQYN25cFBcXx9577x0bbbRRpX0uvvji+PnPf57Wz549O84444z4+OOPcx03AAAAAAAAAEDByynY8cwzz8Snn34ajRo1invuuSd+//vfR5s2bSrts+2226bpWJ599tnYeeedY968eam6BwAAAAAAAAAAazHY8eqrr6b2pJNOil69eq1034YNG8Y111wTRUVFMXLkyJg5c2YuXQMAAAAAAAAAFLycgh3ffvttanfYYYcq7d+uXbvYZJNNYsmSJfHVV1/l0jUAAAAAAAAAQMHLKdjRpEmT1JaWlq72sfXq1culawAAAAAAAACAgpdTsKNTp06pffHFF6u0/+effx7jxo1LoY727dvn0jUAAAAAAAAAQMHLKdix//77p/aJJ56Iv/71ryvdd9asWfE///M/6fbOO+8cjRo1yqVrAAAAAAAAAICCV5zLwdtuu2388Ic/jFdffTXOOuusFO7o169f/OAHP4imTZvGggUL4ptvvom33norhgwZEpMmTYri4uL4+c9/Xn33AAAAAAAAAACgQOUU7Mhcf/31ccwxx8Snn34azz//fFpW2FlxcVx22WWxzTbb5NotAAAAAAAAAEDBy2kqlkzLli1j6NChMXDgwNhwww1XuN9OO+0U999/fxx22GG5dgkAAAAAAAAAUCvkXLEjU79+/TjzzDPTFCsffvhhTJw4MaZOnRr16tWL1q1bpwodG2ywQXV0BQAAAAAAAABQa1RLsKNcnTp1okePHmkBAAAAAAAAAGA9T8UCAAAAAAAAAEANqNgxe/bsmDt3bixZsiTKyspWum+rVq2ipKSkOrsHAAAAAAAAACgoOQc75s+fH3feeWcMHTo0vvrqqyof9/DDD0fPnj1z7R4AAAAAAAAAoGDlHOwYNGhQvPLKK9UzGgAAAAAAAAAAqifYMXz48IpQR5cuXeKAAw6I9u3bR8OGDVd5bKdOnXLpGoDVVFRUFC1btkwtAAAAAAAAUAuCHS+++GJqe/ToEQ899FDUr1+/usYFUCuVlZVFnTp11sq5GzRoEF27do2afB8AAAAAAACgtskp2DFx4sTUnnDCCUIdANUgC0QMGzYspkyZUiOvZ+vWraN///7rexgAAAAAAABQMHIKdpSUlKS2Xbt21TUegFpv9OjRMWHChBp5HTp27CjYAQAAAAAAANWoKJeDu3Tpktpx48ZV13gAAAAAAAAAAKiOYEe/fv1S+8ADD8TChQtzORUAAAAAAAAAANUZ7OjVq1cMGDAgPvrooxg0aFB8+umnuZwOAAAAAAAAAIClFEcOskodG2ywQTRo0CBeeumltGQ/b7jhhlG/fv2VHvurX/0qNt1001y6BwAAAAAAAAAoaDkFO5588skYNWpUpXVTp05Ny6rMmTMnl64BAAAAAAAAAApeTsGOHXfcMVq3br1GxzZv3jyXrgEAAAAAAAAACl5OwY7zzz+/+kYCAAAAAAAAAEAlRZV/BAAAAAAAAAAgXwh2AAAAAAAAAAAU4lQsS1u8eHHMmTMntWVlZZW2LVmyJBYsWBCzZ8+O8ePHx2uvvRZHHHFEbLbZZtXVPQAAAAAAAABAwck52JEFNa644op4/fXXY9GiRVU+bsCAAbl2DQAAAAAAAABQ0HIKdmRVOE466aQU7lgdzZo1iyZNmuTSNQAAAAAAAABAwcsp2PH8889XhDr22GOP2HXXXWPo0KHxySefxOGHHx7du3ePadOmxTvvvJOWzIknnhjnnntuFBdX2ywwAAAAAAAAAAAFKad0xVtvvZXa3r17x1133VVRxePGG2+MevXqxfHHH1+x7wsvvBBnn312PPjgg3HUUUdFx44dcx07AKy2oqKiaNmyZWoBAAAAAAAg3+X0V62vvvoqtQMGDKhY17Nnz9S++eablfbt27dvnHnmmTFv3ryKEAgAfF9ZWdlavSgNGjSIrl27pram3gcAAAAAAABqj5wqdpSWlqa2Q4cOFes23XTT1H7++edpe6NGjSq2HXnkkXHzzTenKVwuvfRS/1sagGXUqVMnhg0bFlOmTKmRV6d169bRv3//9T0MAAAAAAAACkROwY6lQxvlWrVqFc2aNYuZM2fG2LFjY9ttt63Y1qRJk9h4441T6OPLL780HQsAyzV69OiYMGFCjbw62VRjgh0AAAAAAADkxVQsbdq0Se0333xTaX2nTp1S++GHHy5zzOLFi1ObBT8AAAAAAAAAAFhLwY6ePXumNiuZX1ZWVrF+8803T+2LL75Yaf/x48fHxIkT0+3GjRvn0jUAAAAAAAAAQMHLKdixzz77RMOGDeP111+PU089Nb777ru0fs8990ztq6++Gtdcc0189tlnMXLkyDj99NNTxY4WLVrEJptsUj33AAAAAAAAAACgQOUU7GjZsmWcffbZ6fb//u//poocmT59+kSPHj3S7bvvvjv233//OP7442PMmDFp3THHHBNFRTl1DQAAAAAAAABQ8HJOVxx33HFx/fXXR5cuXf7vpEVFceutt1aEO5Y2YMCAOO2003LtFgAAAAAAAACg4BVXx0kOOuigtGTTrJRr165dPProo2malg8//DCKi4ujd+/esfXWW1dHlwAAAAAAAAAABa9agh3l6tatu8zPu+++e1qWVlZWFnXq1KnOrgEAAAAAAAAACk5OU7Fcd911MXDgwPj3v/9dpf0XLFgQRx99dGy//fYxderUXLoGAAAAAAAAACh4OQU73n777Rg+fHjMmDGjSvuXlJTEtGnTorS0NCZPnpxL1wDAGioqKoqWLVumFgAAAAAAgAKZiuWTTz5JgYyllf88duzYVR6/ePHiGDNmTIwbN64i5AEALN/anLasQYMG0bVr17V+6U29BgAAAAAAsA6DHW+++WZceeWVy912ySWXrFanrVu3jk022WS1jgGA2iQLdQwbNiymTJkSNVH2Wt+/f//1PQwAAAAAAIDaE+w46qijYujQofHhhx/m1GHz5s3jqquuiuLiKncNALXS6NGjY8KECVETdezYUbADAAAAAACgGlQ5XVG3bt24/fbbK/2BafDgwfHpp5/G5ZdfHt26dVvp/zrOjm/atGn6Q49pWAAAAAAAAAAAVm21yma0bds2LeUaNmyY2s022yx69uy5OqcCAAAAAAAAAGAViiIHvXv3jk022STef//9XE4DAAAAAAAAAEB1BzuyaVjGjx8f8+bNy+U0AAAAAAAAAABUd7Bj7ty5qd16661zOQ0AAAAAAAAAANUd7Nh8881T+9Zbb+VyGgAAAAAAAAAAqjvYcdppp0WnTp3ijjvuiNtuuy2mTp2ay+kAAAAAAAAAAFhKceRg+PDhsccee8RDDz0Uv/3tb9PSvn372GCDDaJRo0YrPXbw4MHRvXv3XLoHAAAAAAAAAChoOQU7Hn300Rg1alSldV9//XVaVmX27Nm5dA0AAAAAAAAAUPByCnb07NkzmjZtukbHrulxAAAAAAAAAAC1RU7Bjosuuqj6RgIAAAAAAAAAQCVFlX8EAAAAAAAAACBfCHYAAAAAAAAAABTiVCxLmzx5cjz00EPx2muvxbhx42L27NlRUlISbdq0iR49esT+++8fe++9d3V1BwAAAAAAAABQ8Kol2PHkk0/G4MGDY+7cuZXWL1q0KIU8suWZZ56JPn36xFVXXRUtWrSojm4BAAAAAAAAAApazsGOZ599Ni644IKKn7PqHJtvvnk0b9485s2bF+PHj49//vOfUVpaGiNGjIgzzzwz/vSnP0VRkVlgAAAAAAAAAADWWrBj5syZcemll6bbP/jBD+Laa6+NLbbYYpn9smlZbr/99rjrrrvijTfeiIcffjiOPPLIXLoGAAAAAAAAACh4OZXNeOqpp2LGjBnRtm3buPfee5cb6sg0adIkzjvvvPjpT3+afh4yZEgu3QIAAAAAAAAA1Ao5BTveeeed1J5wwgnRsmXLVe4/cODAaNCgQXz88ccxa9asXLoGAAAAAAAAACh4OQU7pkyZktott9yySvs3atQoOnfunG5/9dVXuXQNAAAAAAAAAFDwcgp2FBcXp3bu3LlVPqa0tLTSsQAAAAAAAAAArIVgR5cuXVI7YsSIKu0/duzYGD9+fNSrVy/at2+fS9cAAAAAAAAAAAUvp2BHnz59UvvYY4/Fq6++utJ958yZExdddFG6vdNOO6VpWQAAAAAAAAAAWEvBjh/+8Iex3XbbxaJFi+JnP/tZ/OpXv4oPP/ww/Vxu8uTJMXTo0Dj44IPj/fffjzp16sTAgQNz6RYAAAAAAAAAoFYozvUE1113XRx33HHx5Zdfxr333puWunXrpoocCxYsiPnz51fa/7//+79jhx12yLVbAAAAAAAAAICCl1PFjkzHjh1jyJAhceCBB0ZR0f873eLFi2PWrFmVQh2dO3eO3//+93HCCSfk2iUAAAAAAAAAQK2Qc8WOTJs2beKGG26ICy64IN5444344osvYubMmVGvXr20rWfPnrHttttWBD8AAAAAAAAAAFhHwY5ybdu2jQEDBlTnKQEAAAAAAAAAai0lNAAAAAAAAAAACr1ix4wZM+Jvf/tbvPTSSzF+/PiYNm1aNG3aNFXx2GWXXaJfv36xySabVFd3AAAAAAAAAAAFr1qCHX/5y1/iuuuui+nTp1daP2nSpPjss8/i9ddfj5tuuimOPfbYOOuss6J+/frV0S0AAAAAAAAAQEHLOdhx3333xZVXXlnxc9euXWPTTTdN1Trmz58fEydOjA8//DDdvvvuu+PLL79MIY86derk2jUAAAAAAAAAQEHLKdjx9ddfxzXXXJNub7PNNnHFFVfE5ptvvsx+M2fOjDvvvDPuuuuueP7552PIkCFx5JFH5tI1AAAAAAAAAEDBK8rl4IcffjgWLlyYqnTcc889yw11ZJo1axbnnXdenHHGGennP/3pT7l0CwAAAAAAAABQK+QU7Bg7dmxqTz755GjUqNEq9z/llFOiSZMm8cUXX8TUqVNz6RoAAAAAAAAAoODlFOzIpljJdOzYsUr7l5SUVOw7efLkXLoGAAAAAAAAACh4OQU7Nt5440qVO1ZlyZIl8e2330adOnWiTZs2uXQNAAAAAAAAAFDwcgp29O/fP7V33nlnfPfdd6vc/7HHHkv77brrrtGqVatcugYAAAAAAAAAKHg5BTt22WWXOPnkk+Obb76Jo48+Ov7xj38sd79FixbFQw89FJdddlk0b948Lrnkkly6BQAAAAAAAACoFYpzOfjPf/5zLFiwIE2r8vnnn8dRRx0VnTt3jq222ipatmwZixcvTlOvvPvuuxUVPRo0aBD/8z//s8Jz/upXv4pNN900l2EBAAAAAAAAABSEnIIdzz77bIwaNarSunHjxqVlRbKgR7asyJw5c3IZEgAAAAAAAABAwcgp2LHjjjtG69atq280EWmqFgAAAAAAAAAAcgx2nH/++a4hAAAAAAAAAMBaUrS2TgwAAAAAAAAAQG4EOwAAAAAAAAAACnEqlszcuXPj7rvvjhdffDHGjx8f8+bNi7KyslUe99BDD8W2226ba/cAAAAAAAAAAAUrp2DH/Pnz49hjj433339/tY+tSvgDAAAAAAAAAKA2yynY8Ze//KUi1LHZZpvFbrvtFi1btoy6deuu8tiNNtool64BAAAAAAAAAApeTsGO1157LbV77LFH3HHHHVFUVFRd4wIAAAAAAAAAqPVySmLMmDEjtUcffbRQBwAAAAAAAABAPgU7Wrdundr69etX13gAAAAAAAAAAKiOYMeee+5ZaUoWAAAAAAAAAADyJNhx4IEHRo8ePeLee++NkSNHVt+oAAAAAAAAAACI4lyuQb169eK2226LU045JU488cTYddddY/vtt48WLVpEUdHKMyP77LNPbLDBBv4JAAAAAAAAAADWRrAj8/HHH8e0adNiyZIl8eqrr6alKrbYYgvBDgAAAAAAAACAtRXs+Pzzz+OMM86I+fPn53IaAAAAAAAAAACqO9jxyCOPpFBHSUlJDBo0KH70ox/FhhtuGMXFqz5t48aNc+kaAAAAAAAAAKDg5RTsGDt2bGoHDhwYp556anWNCQAAAAAAAACAiCjK5SosWbIktT179nQxAQAAAAAAAADyKdjRuXPn1E6ePLm6xgMAAAAAAAAAQHUEOwYMGJDaBx54IBYtWpTLqQAAAAAAAAAAqM5gRzYFy7HHHhvvvfdenHbaafHxxx/ncjoAAAAAAAAAAJZSHDkYMmRINGrUKDbYYIN4+eWX09K8efNo3bp1NG7cOOrUqbPCY3/1q1/Fpptumkv3AAAAAAAAAAAFLadgx9ChQ2PUqFGV1s2YMSMtqzJnzpxcugYAAAAAAAAAKHg5BTt23HHHVJ1jTWSVPQAAAAAAAAAAWEvBjvPPPz+XwwEAAAAAAAAAWImilW0EAAAAAAAAAGD9EewAAAAAAAAAAMhTgh0AAAAAAAAAAHmquKo7XnnllfHpp59WW8e/+MUvolu3btV2PgAAAAAAAACAWhvseP/992PUqFHV1vGsWbOq7VwAAAAAAAAAALU62NG0adNo0aJF9XVcXOWuAQAAAAAAAABqpSqnK/74xz+u3ZEAAAAAAAAAAFBJUeUfAQAAAAAAAADIF4IdAAAAAAAAAAB5SrADAAAAAAAAACBPCXYAAAAAAAAAAOQpwQ4AAAAAAAAAgDwl2AEAAAAAAAAAkKcEOwAAAAAAAAAA8pRgBwAAAAAAAABAnhLsAAAAAAAAAADIU4IdAAAAAAAAAAB5SrADAAAAAAAAACBPFVfXiUpLS+Ppp5+OkSNHxhdffBGzZs2Km2++ObbYYou0/ZZbbon/+I//iK233nqN+1iwYEHceeed8eqrr0b9+vXjwAMPjMMPP3ylx7z44ovxl7/8JaZPnx7bbLNNnHbaadGyZcs1HgMAAAAAAAAAQI0KdgwfPjwuvvjimDZtWqX18+fPr7j98ssvx6233hqXX355HHbYYWvUT9bHsGHDKn5+4403Ys6cOXH88ccvd/977rknfv3rX1f8/O6778Z7770XDz30UNStW3eNxgAAAAAAAAAAUGOmYnnhhRdi0KBBFaGODh06RJMmTZbZr2HDhrF48eIYPHhwjB49erX7yaqAZKGOevXqxY033hhnnnlmWn/bbbfFokWLltk/G8/111+fbp9zzjmp0kc2tlGjRqWABwAAAAAAAABAQQc7Zs6cGZdcckmUlZVF796949lnn40RI0ZEt27dltn3pptuih49eqQQRhbGWF3ZFC+ZnXbaKQ444IA0pUqrVq3SFCtjxoxZZv9supZs6patttoqfvazn6VpYIYMGRKvv/567LDDDmt4jwEAAAAAAAAAakiwI6ugkQUrsiDHH/7wh+UGOsq1aNEiTcNSPi3L8qpsrMyECRNSm1XdyNSpUyfat29fadvSPv/889R27tw5rrrqqjj66KNT1Y5sCpbsWAAAAAAAAACAfFecy8FvvfVWao899tioX7/+KvfPqmdsuOGGMXny5BTG6NKlS5X7mjt3bmqX7qekpCS1paWly+w/e/bs1D7zzDOpokjmnXfeSZU8nnzyySqN9/uy8yyvL9ZMFrDJpugpBNnjs/xxtjpcA9fB48HvhOeG9af8vUV5W1u5Dq6Bx4LfCc8Lnh+9Tnit9J7BeyfvH72P9nnCZyqfLX3G9j2D71t870Qm+1uX/yAPBRjs+O6771K7skod31ce7JgzZ85q9ZVV2sgsXry4Yl357Xr16i2zf3FxcUV7xRVXRJs2beLSSy+Nf//736nSyOGHHx6ra+HChfHRRx+t9nEsXxbq2HLLLQvi8mSPqzX5w6Br4Dp4PPid8Nyw/o0bN259DyEvuA6ugceC3wnPC54fvU54rfSewXsn7x+9j/Z5wmcqny19xvY9g+9bfO9E+X+sBwoo2NGgQYPUzpw5s8rHZKGOTNOmTVerr9atW6d2xowZFeumTZtWadvSsiBHZtttt40f//jH6XYW5rjhhhsqpmlZXVmApHv37mt0LMsqpMRfVn1mTSt21PZrkHEdXAePBb8T60MWyMvCDNm0bYVSQWpNuA6ugceC3wnPC54fvU54rfSewXsn7x+9j/Z5wmcqny19xvY9g+9bfO9E5tNPP3UhoBCDHVmljldeeSWGDx8ee+211yr3HzlyZAp2ZH88ad++/Wr1tfnmm1dM/5L9AeKbb76JiRMnpoocW2yxxTL79+zZs+IJaNKkSSnoMXbs2EqhjzX543OjRo3W6FgKW23+g2A518B18HjwO1FTnxuyMXp9dx08FvxOeG7w/Oh1wuul9wzeO3kP6X20zxM+V/ls6TO27xp83+J7J9+/1XaF9B9xodAU5XLwPvvsk9rHH388hTtWZsKECXHRRRel27vvvvtql/HZZZddYqONNkohjT333DMOPvjgVB1g7733jhYtWsTXX38dAwYMiJ/85CcVwY5tttkmpk+fHvvuu2/06dMnTcGS/eGmb9++a3yfAQAAAAAAAABqRLBjhx12SIGJJUuWxBlnnJGCGy+99FKqqJGZNWtWjBo1Kn7zm9+kIMZXX32VpjMZOHDgaveVBUFuueWWVC49C2vMmzcvtt9++xg8eHDavmDBgvj444/jk08+qUiUZfvvuOOOUVpaGl9++WW0a9cubr755th4441zudsAAAAAAAAAAPk/FUvm2muvjeOOOy5Gjx4djz32WFrKnXzyyZX2rVu3blx22WXLnTqlKnr06BHPPfdcjB8/PgVEsgoe5bKpXZ544onUR7m2bdvG/fffH99++20sWrQo7a+EEAAAAAAAAABQa4IdTZs2jSFDhsStt94aDz74YMyYMWO5+2XTolxwwQWpgkYusmBGp06dllvRY0WBkSzgAQAAAAAAAABQq4Id2ZQrDRs2TKGKs846K02x8v7778fYsWNj5syZqXpG69ato2fPnmkKFQAAAAAAAAAA1lGwI6vS8be//S2OOeaY+MlPfpICHr169UoLAAAAAAAAAAC5Kcrl4DFjxsS4ceNS5Q4AAAAAAAAAAPIo2FEe6Nh6662razwAAAAAAAAAAFRHsGPzzTdP7VtvvZXLaQAAAAAAAAAAqO5gx2mnnRadOnWKO+64I2677baYOnVqLqcDAAAAAAAAAGApxZGD4cOHxx577BEPPfRQ/Pa3v01L+/btY4MNNohGjRqt9NjBgwdH9+7dc+keAAAAAAAAAKCg5RTsePTRR2PUqFGV1n399ddpWZXZs2fn0jUAAAAAAAAAQMHLKdjRs2fPaNq06Rodu6bHAQAAAAAAAADUFjkFOy666KLqGwkAAAAAAAAAAJUUVf4RAAAAAAAAAIB8IdgBAAAAAAAAAFCIU7EsWLAgysrK1ujYkpKSqFOnTi7dAwAAAAAAAAAUtJyCHcccc0yMGjVqjY59+OGHo2fPnrl0DwAAAAAAAABQ0EzFAgAAAAAAAABQiBU7TjzxxJgyZcoKty9atChmzpwZH330Ubz22mtp6pbzzz8/dt9999hkk01y6RoAAAAAAAAAoODlFOzo169flfedMGFCnHDCCfGb3/wmdtlll2jQoEEuXQMAAAAAAAAAFLx1NhVLx44d4+qrr46FCxemFgAAAAAAAACAPAl2ZHr16hVt27aNt956K2bMmLEuuwYAAAAAAAAAqHHWabAj07x58ygrK4uvv/56XXcNAAAAAAAAAFCjrNNgx7Rp02L8+PHpdoMGDdZl1wAAlRQVFUXLli1TCwAAAAAAkK+K11VH06dPjwsvvDDmzZuX/ojSsWPHddU1AFBDZVW+6tSps1bOnYVMu3btGjX5PgAAAAAAAIUvp2DHr3/96/jss89Wus/ixYtj1qxZMXbs2Jg/f35a91//9V9Rt27dXLoGAGqBLBAxbNiwmDJlStRErVu3jv79+6/vYQAAAAAAALU12PHee+/FqFGjVuuYnXfeOU499dRcugUAapHRo0fHhAkToibKKpTle7DDlDQAAAAAAFDAwY5tttkmGjVqtMo/FpSUlET79u3jhz/8YfTp00c5cgCAPJnKZV1MSWM6GgAAAAAAWE/BjksuuSSXwwEAWAXT0QAAAAAAQO2WU7BjTflfmwAAVWc6GgAAAAAAqL2Kcjn4uuuui4EDB8a///3vKu2/YMGCOProo2P77bePqVOn5tI1AAAAAAAAAEDByynY8fbbb8fw4cNjxowZVdq/pKQkpk2bFqWlpTF58uRcugYAAAAAAAAAKHhVnorlk08+SYGMpZX/PHbs2FUev3jx4hgzZkyMGzeuIuQBAAAAAAAAAEA1BDvefPPNuPLKK5e77ZJLLonV0bp169hkk01W6xgAAAAAAAAAgNqmylOxHHXUUbHlllvm3GHz5s3jqquuiuLiKmdKAAAAAAAAAABqpSqnK+rWrRu33357TJgwoWLd4MGD49NPP43LL788unXrtsJj69Spk45v2rRpdOzY0TQsAAAAAAAAAABVsFplM9q2bZuWco0bN07tZpttFj179lydUwEAAAAAAAAAsAo5zYdy//33R1lZmQocAAAAAAAAAAD5FuwoKSmpvpEAAAAAAAAAAFB9wY6lLV68OObMmZParIrH0pYsWRILFiyI2bNnx/jx4+O1116LI444Ik3hAgAAAAAAAADAWgp2ZEGNK664Il5//fVYtGhRlY8bMGBArl0DAAAAAAAAABS0nIIdWRWOk046KYU7VkezZs2iSZMmuXQNAAAAAAAAAFDwcgp2PP/88xWhjj322CN23XXXGDp0aHzyySdx+OGHR/fu3WPatGnxzjvvpCVz4oknxrnnnhvFxdU2CwwAAAAAAAAAQEHKKV3x1ltvpbZ3795x1113VVTxuPHGG6NevXpx/PHHV+z7wgsvxNlnnx0PPvhgHHXUUdGxY8dcxw4AAAAAAAAAUNCKcjn4q6++Su2AAQMq1vXs2TO1b775ZqV9+/btG2eeeWbMmzevIgQCAAAAAAAAAMBaCnaUlpamtkOHDhXrNt1009R+/vnnFdvLHXnkkVFSUpKmcFmyZEkuXQMAAAAAAAAAFLycgh2NGjVaZl2rVq2iWbNmUVZWFmPHjq20rUmTJrHxxhvH9OnT48svv8ylawAAAAAAAACAgpdTsKNNmzap/eabbyqt79SpU2o//PDDZY5ZvHhxamfOnJlL1wAAAAAAAAAABS+nYEfPnj1TO2zYsFSho9zmm2+e2hdffLHS/uPHj4+JEyem240bN86lawAAAAAAAACAgpdTsGOfffaJhg0bxuuvvx6nnnpqfPfdd2n9nnvumdpXX301rrnmmvjss89i5MiRcfrpp6eKHS1atIhNNtmkeu4BAAAAAAAAAECByinY0bJlyzj77LPT7f/93/9NFTkyffr0iR49eqTbd999d+y///5x/PHHx5gxY9K6Y445JoqKcuoaAAAAAAAAAKDg5ZyuOO644+L666+PLl26/N9Ji4ri1ltvrQh3LG3AgAFx2mmn5dotAAAAAAAAAEDBK66Okxx00EFpyaZZKdeuXbt49NFH0zQtH374YRQXF0fv3r1j6623ro4uAQAAAAAAAAAKXrUEO8rVrVt3mZ933333tAAAAAAAAAAAsI6nYgEAAAAAAAAAIM+DHaWlpfHII4/E2WefHYccckj07ds3Pvroo4rtt9xyS3zwwQfV1R0AAAAAAAAAQMGrlqlYhg8fHhdffHFMmzat0vr58+dX3H755Zfj1ltvjcsvvzwOO+yw6ugWAAAAAAAAAKCg5Vyx44UXXohBgwZVhDo6dOgQTZo0WWa/hg0bxuLFi2Pw4MExevToXLsFAAAAAAAAACh4OQU7Zs6cGZdcckmUlZVF796949lnn40RI0ZEt27dltn3pptuih49esSiRYvitttuy6VbAAAAAAAAAIBaIadgx7Bhw2L69OkpyPGHP/xhuYGOci1atEjTsJRPy5IFPAAAAAAAAAAAWEvBjrfeeiu1xx57bNSvX3+V+2+11Vax4YYbxvz582PChAm5dA0AAAAAAAAAUPByCnZ89913qV1ZpY7vy4IdmTlz5uTSNQAAAAAAAABAwcsp2NGgQYPUzpw5s8rHTJ48ObVNmzbNpWsAAAAAAAAAgIKXU7CjvFLH8OHDq7T/yJEjU7CjYcOG0b59+1y6BgAAAAAAAAAoeDkFO/bZZ5/UPv7446sMd0yYMCEuuuiidHv33XePkpKSXLoGAAAAAAAAACh4xbkcvMMOO0SfPn1ixIgRccYZZ8TBBx8c++67b8ydOzdtnzVrVowaNSptv//++2P27NlRr169GDhwYHWNHwAAAAAAAACgYOUU7Mhce+21cdxxx8Xo0aPjscceS0u5k08+udK+devWjcsuuyy22GKLXLsFAAAAAAAAACh4OU3FkmnatGkMGTIkTjvttGjevPkK99tmm23innvuiUMPPTTXLgEAAAAAAAAAaoWcK3ZkSkpK4qyzzkpTrLz//vsxduzYmDlzZqrQ0bp16+jZs2d07ty5OroCAAAAAAAAAKg1qiXYsXTAo1evXmkBAAAAAAAAAGAdTcXy3nvvxcsvvxyzZs3KsUsAAAAAAAAAAKo12PHrX/86fvrTn8Znn31W1UMAAAAAAAAAAFgXwY6qOPfcc+PAAw+Mjz/+uDpPCwAAAAAAAABQK1VrsGPChAkxduzYmDdvXnWeFgAAAAAAAACgVqrWYAcAAAAAAAAAANVHsAMAAAAAAAAAIE8JdgAAAAAAAAAA5CnBDgAAAAAAAACAPCXYAQAAAAAAAACQpwQ7AAAAAAAAAADylGAHAAAAAAAAAECeKl7dA55//vn417/+tdxtU6ZMWeU+5fr16xetW7de3e4BAAAAAAAAAGqN1Q523H333dWyz1ZbbSXYAQAAAAAAAACwEqZiAQAAAAAAAACo6RU7Lr/88pg9e3a1ddy9e/dqOxcAAAAAAAAAQK0Odmy++eZrdyQAAAAAAAAAAFRiKhYAAAAAAAAAgDwl2AEAAAAAAAAAkKcEOwAAAAAAAAAA8pRgBwAAAAAAAABAnhLsAAAAAAAAAADIU4IdAAAAAAAAAAB5SrADAAAAAAAAACBPCXYAAAAAAAAAAOQpwQ4AAAAAAAAAgDwl2AEAAAAAAAAAkKeKq/Nks2fPjrlz58aSJUuirKxspfu2atUqSkpKqrN7AAAAAAAAAICCknOwY/78+XHnnXfG0KFD46uvvqrycQ8//HD07Nkz1+4BAAAAAAAAAApWzsGOQYMGxSuvvFI9owEAAAAAAAAAoHqCHcOHD68IdXTp0iUOOOCAaN++fTRs2HCVx3bq1CmXrgEAAAAAAAAACl5OwY4XX3wxtT169IiHHnoo6tevX13jAgAAAAAAAACo9YpyuQITJ05M7QknnCDUAQAAAAAAAACQT8GOkpKS1LZr1666xgMAAAAAAAAAQHUEO7p06ZLacePG5XIaAAAAAAAAAACqO9jRr1+/1D7wwAOxcOHCXE4FAAAAAAAAAEB1Bjt69eoVAwYMiI8++igGDRoUn376aS6nAwAAAAAAAABgKcWRg6xSxwYbbBANGjSIl156KS3ZzxtuuGHUr19/pcf+6le/ik033TSX7gEAAAAAAAAAClpOwY4nn3wyRo0aVWnd1KlT07Iqc+bMyaVrAAAAAAAAAICCl1OwY8cdd4zWrVuv0bHNmzfPpWsAAAAAAAAAgIKXU7Dj/PPPr76RAAAAAAAAAABQSVHlHwEAAAAAAAAAyBeCHQAAAAAAAAAAhTgVy9IWL14cc+bMSW1ZWVmlbUuWLIkFCxbE7NmzY/z48fHaa6/FEUccEZtttll1dQ8AAAAAAAAAUHByDnZkQY0rrrgiXn/99Vi0aFGVjxswYECuXQMAAAAAAAAAFLScgh1ZFY6TTjophTtWR7NmzaJJkya5dA0AAAAAAAAAUPByCnY8//zzFaGOPfbYI3bdddcYOnRofPLJJ3H44YdH9+7dY9q0afHOO++kJXPiiSfGueeeG8XF1TYLDAAAAAAAAABAQcopXfHWW2+ltnfv3nHXXXdVVPG48cYbo169enH88cdX7PvCCy/E2WefHQ8++GAcddRR0bFjx1zHDgAAAAAAAABQ0IpyOfirr75K7YABAyrW9ezZM7VvvvlmpX379u0bZ555ZsybN68iBAIAAAAAAAAAwFoKdpSWlqa2Q4cOFes23XTT1H7++ecV28sdeeSRUVJSkqZwWbJkSS5dAwAAVLuioqJo2bJlagEAAAAA8kFO31Y2atRomXWtWrWKZs2aRVlZWYwdO7bStiZNmsTGG28c06dPjy+//DKXrgEAgFoo+5yxNjVo0CC6du2a2pp6HwAAAACAwlKcy8Ft2rRJ7TfffFNpfadOneKDDz6IDz/8MLbddttK2xYvXpzamTNn5tI1AABQC9WpUyeGDRsWU6ZMiZqodevW0b9///U9DAAAAACgtgQ7evbsGUOHDk1frB588MHpS9bM5ptvnoIdL774Ypp+pdz48eNj4sSJ6Xbjxo1zHTsAAFALjR49OiZMmBA1UceOHQU7AAAAAIB1NxXLPvvsEw0bNozXX389Tj311Pjuu+/S+j333DO1r776alxzzTXx2WefxciRI+P0009PFTtatGgRm2yySS5dAwAAAAAAAAAUvJyCHS1btoyzzz473f7f//3fVJEj06dPn+jRo0e6fffdd8f+++8fxx9/fIwZMyatO+aYY6KoKKeuAQAAAAAAAAAKXs7piuOOOy6uv/766NKly/+dtKgobr311opwx9IGDBgQp512Wq7dAgAAAAAAAAAUvOLqOMlBBx2UlmyalXLt2rWLRx99NE3T8uGHH0ZxcXH07t07tt566+roEgAAAAAAAACg4FVLsKNc3bp1l/l59913TwsAAOSjrNpcNsVgbZ8q0HUAAAAAAKgFwQ4AAFgbysrKok6dOmvl3A0aNIiuXbtGTbgPrgMAAAAAQO1T5WDHhRdeGGPGjImrr746fvCDH1RatyaWPg8AAKxMFogYNmxYTJkypUZeqNatW0f//v1zPo/rAAAAAABQ+1Q52PHZZ5/F6NGjo7S0dJl1a2Lp8wAAwKpk7zsnTJhQIy9Ux44dqyXYkXEdAAAAAABqlyoHO3beeedo165dtGjRYpl1a2Lp8wAAAAAAAAAAkEOw45xzzqnSOgAAAAAAAAAAqkdRNZ0HAAAAAAAAAIBqJtgBAAAAAAAAAFDTp2JZvHhxlJWVVV/HxVXuGgAAAAAAAACgVqpyuuLII4+MUaNGVVvHDz/8cPTs2bPazgcAAAAAAAAAUGhMxQIAAAAAAAAAUNMrdpx44okxZcqUZdZPnjw57rrrrjRVS7du3WL//fePzTffPJo3b57WTZo0Kd5+++146qmnYu7cuXHggQfGoYceGt27d6/u+wIAAAAAAAAAUDuDHf369Vtm3YIFC+Kwww5LAY7TTz89Bg0aFEVFyxYB6d+/f5xyyilx0kknxdNPPx19+vSJJk2a5D56AAAAAAAAAIACltNULE888USMGTMm9tlnnzjjjDOWG+oo17Fjx7jxxhvT7awtKyvLpWsAAAAAAAAAgIKXU7DjlVdeSe2AAQOqtP9WW20VnTp1iokTJ8aXX36ZS9cAAAAAAAAAAAUvp2DH9OnTU9u0adMqH1NSUpLaOXPm5NI1AAAAAAAAAEDByynY0a5du9T+4x//qNL+WaWOzz77LN3u0KFDLl0DAAAAAAAAABS8nIIdO+20U2r/+Mc/xpgxY1a6b2lpaVxwwQWxZMmSdFyTJk1y6RoAAAAAAAAAoODlFOzo379/tG/fPmbPnh1HHHFE3HTTTfHxxx/HggUL0vaysrL46quv4tFHH42DDz44VfaoW7dunH766dU1fgAAAAAAAACAglWcy8ElJSVxxx13xNFHHx2zZs2KW2+9NS2Z+vXrx8KFC1OFjnJ16tSJSy65JHr37p37yAEAAAAAAAAAClxOFTsym222WTz11FOx3377pWoc5ebPn18p1NGjR4944IEH4qijjsq1SwAAAAAAAACAWiGnih3lsulYfvvb38aMGTPitddeiwkTJsS0adOiUaNG0aZNm9hpp52iS5cu1dEVAAAAAAAAAECtUS3BjnLNmzeP/fffvzpPCQAAAAAAAABQa+U8FQsAAAAAAAAAAHke7CgtLY1HHnkkzj777DjkkEOib9++8dFHH1Vsv+WWW+KDDz6oru4AAAAAAAAAAApetUzFMnz48Lj44otj2rRpldbPnz+/4vbLL78ct956a1x++eVx2GGHVUe3AAAAAAAAAAAFLeeKHS+88EIMGjSoItTRoUOHaNKkyTL7NWzYMBYvXhyDBw+O0aNH59otAAAAAAAAAEDByynYMXPmzLjkkkuirKwsevfuHc8++2yMGDEiunXrtsy+N910U/To0SMWLVoUt912Wy7dAgAAAAAAAADUCjkFO4YNGxbTp09PQY4//OEPyw10lGvRokWahqV8WpYs4AEAAAAAAAAAwFoKdrz11lupPfbYY6N+/fqr3H+rrbaKDTfcMObPnx8TJkzIpWsAAAAAAAAAgIKXU7Dju+++S+3KKnV8XxbsyMyZMyeXrgEAAAAAAAAACl5OwY4GDRqkdubMmVU+ZvLkyalt2rRpLl0DAAAAAAAAABS8nIId5ZU6hg8fXqX9R44cmYIdDRs2jPbt2+fSNQAAAAAAAABAwcsp2LHPPvuk9vHHH19luGPChAlx0UUXpdu77757lJSU5NI1AAAAAAAAAEDBK87l4B122CH69OkTI0aMiDPOOCMOPvjg2HfffWPu3Llp+6xZs2LUqFFp+/333x+zZ8+OevXqxcCBA6tr/AAAAAAAAAAABSunYEfm2muvjeOOOy5Gjx4djz32WFrKnXzyyZX2rVu3blx22WWxxRZb5NotAAAAAAAAAEDBy2kqlkzTpk1jyJAhcdppp0Xz5s1XuN8222wT99xzTxx66KG5dgkAAAAAAAAAUCvkXLEjU1JSEmeddVaaYuX999+PsWPHxsyZM1OFjtatW0fPnj2jc+fO1dEVAAAAAAAAAECtUS3BjqUDHr169UoLAAAAAAAAAADreSoWAAAAAAAAAADWc8WOG2+8McaNG1dtHZ9zzjmmZwEAAAAAAAAAqI5gxxtvvBGjRo2K6nLiiSdW27kAAAAAAAAAAGp1sKNcixYtonHjxjl3XFJSkvM5AAAAAAAAAAAKWZWDHcXF/2/XOXPmxLbbbhv77LNP7LXXXtGyZcu1OT4AAAAAAAAAgFqrysGOu+++O/7+97/HM888Ey+//HK89NJLMXjw4Nhxxx1TyGPvvfeONm3arN3RAgAAAAAAAADUIlUOdjRo0CD222+/tMyePTtefPHFePrpp2PkyJFpueKKK6Jnz56x7777Rt++faNDhw5rd+QAAAAAAAAAAAWuysGOpTVp0iQOPvjgtEybNi2ef/75VMnjnXfeiX/+859x1VVXxVZbbZVCHlk1j86dO1f/yAEAAAAAAAAACtwaBTuW1rJlyzjiiCPS8u2338Zf//rXePbZZ2PUqFHxr3/9K2644Yb4wQ9+UBHyyG4DAAAAAAAAALAOgh1La9u2bRx//PFpmTBhQgp4ZMvHH38cn3zySfzud79L1TuygMdJJ50ULVq0iHWlrKwsFi9eHHXr1o06deqss34BAAAAAAAAANZUUawlHTt2jJ/97Gfx5JNPpioegwYNikaNGsW4cePizjvvTO3qmjRpUpx66qmx9dZbxw477BC//OUvY/78+VU69sILL4wePXrE3XffvQb3BgAAAAAAAACghlfs+L4sdPHKK6/E888/H3//+9+jtLQ0p/OdeeaZ8c9//jPdXrBgQTz88MNRXFycAh4r89JLL8Xjjz+eU98AAAAAAAAAADU+2FEe5njuuedixIgRMWfOnIptTZo0iT333DP69u0bW2655Wqd9/3330+hjqZNm8Zjjz2WKn6ccsop6fZ5552XqoEsz6xZs+IXv/hFzvcLAAAAAAAAAKBGBjuy6hkvv/zycsMcLVu2jD59+sQ+++wTu+66a5SUlKxRH+WVOnbaaafo1KlTWjbaaKP46quv4qOPPkpTsyzPr3/96/j2229j0003jbFjx67hPQQAAAAAAAAAqEHBjizMkVXm+Otf/7pMmKNNmzax9957pzBH7969o27dujkPNAtnZDbccMOKda1bt07Bjm+++Wa5x2Rhk6FDh0b//v3TvrkGO8rKynKeTob/U6dOnWjYsGFBXJK5c+emx8fqcg1cB48HvxOeGzxHep3weul9g/dO+fjedum2tnIdXAePBb8Tnhs8P3qd8HrpPYP3Tt5Deh/t84TPVbVN9reu7G9XQA0PdqwszNGxY8c0xUq2bLfddtX+Sz9v3rzU1qtXr2JdeWAkm/7l+2bPnh2//OUvUxDk4osvjjvuuCPnMSxcuDBVB6F6ZKGO1Z2SJ1/9+9//XqMvvl0D18Hjwe+E5wbPkV4nvF563+C9U77Kpr/EdfB48DvhucFzpNcJr5feN3jv5D2k99I+T/hc5fNl7bKmsy8AeRLsuOGGG+LBBx9MgYly3bp1S1U5smVt/4G+fv36FeGKcuW3GzRosMz+V199dXz99dfxu9/9Lpo0aVJRTWHJkiWxePHiNaoikoVKunfvnsO9YGmFlPjr0qXLGlfsqO3XIOM6uA4eC34nPDd4fvQ64fXSe4bVf/+0tt5DZZ+zJk+enELySwfrq1v23nFN3z+uC1lwOwu3dO7cuWAqDa4J18E18FjwO+F5wfOj1wmvld4zeO/k/aP30T5P1B6ffvrp+h4CsAJVDna8+eabKdSRfbm31157xb777htdu3at2L6i6VBWpFWrVquV+Grbtm1qp0yZUrFu0qRJqW3fvv0y+z/33HOpPeOMMyqtv/766+OFF16IRx55JFZX9sVpo0aNVvs4Cl9t/qK3nGvgOng8+J3w3OA50uuE10vvG9bde6e1WRo1C843bdo01raaUt41+7fyOdB18FjwO+G5wfOj1wmvl94zeO/kPaT30T5P+FxVG9SEz+lQW63WVCyZ7H9uDRkyJC25ePjhh6Nnz55V3n+bbbZJ7f/H3p2AezrW/wO/Z+xLIbI2QslalNCqQkQMSf2QnewtlsgWkpJKtqQsSRStlqJ/QpEsZa2xVbaxFZE9ivlf73uu5/SdM2fGcGbMOc/zel3X9/qeOXNmzvk+5/s8z31/7s/9+fz+978vt912W7n77rtrYkcCbMsss0z9u//+97/1gpNqHM2jkUodCRyOHDnyJVXrAAAAGCoy7zn33HMnSHwfTuabb74yevTo6f1jAAAAAEA7Ezuml7e85S01uePGG28s66+/ft/nN9lkk7qj7K677qotYeaee+5aXSSPXl/+8pfLKaecUvbaa6+y3XbbTYdXAAAAMPWMGTOmjB07dlge0lGjRknsAAAAAICpndixxRZb1PYrU8vCCy/8oneknXDCCeULX/hCueyyy2qv5/XWW6/ssccefX+fShwzzjjwS2oqdeQZAAAAAAAAAKBViR29VTKml3nnnbd8/etfH/DvFl100XLTTTdN8t9+5jOfqQ8AAAAAAAAAgOFC+QoAAAAAAAAAgCFKYgcAAAAAAAAAwBAlsQMAAAAAAAAAYIiS2AEAAAD9J8sjR5Z55pmnPgMAAADA9DTjdP3uAAAA8BKNGzeujBgxYpocv1lnnbUsscQSZTi/BgAAAADaQWIHAAAAw1ISIs4999zy0EMPleFovvnmK6NHj57ePwYAAAAAQ5zEDgAAAIatMWPGlLFjx5bhaNSoURI7AAAAAHhBmgUDAAAAAAAAAAxREjsAAAAAAAAAAIYoiR0AAAAAAAAAAEPUjFP6hc8991wZN27c1PvGM07xtwYAAAAAAAAA6KQpzq7YdNNNyw033DDVvvFZZ51VVlxxxan2/wEAAAAAAAAAtI1WLAAAAAAAAAAAw71ix7bbblseeuihiT7/4IMPlhNPPLG2annd615X1l133bL00kuXueaaq37uH//4R/nDH/5QzjvvvPL000+X9dZbr3z4wx8ur3/966f2awEAAAAAAAAA6GZixwc+8IGJPvfss8+WjTfeuCZw7LbbbmXXXXctI0dOXARk9OjRZYcddijbbbdd+fnPf15WX331Mueccw7+pwcAAAAAAAAAaLEpTuwYyNlnn11uvfXWstZaa5VPfOITk/3aUaNGlSOPPLJW68hzKnuMGDFiMN8eAADooAUXXLAMV8P5ZwcAAAAAhmFix2WXXVafN9hggyn6+uWXX7689rWvLXfddVe59957y2te85rBfHsAAKBjnn/++bLNNtuU4f4aBqp0CAAAAAAw1RM7/vWvf9XnV7ziFVP8b2aeeeb6/OSTTw7mWwMAAB2UhIg77rijPP3002U4mm222criiy8+vX8MAAAAAKAriR1NGeFrrrmmrLrqqi/49ffcc0/529/+Vj9eZJFFBvOtAQCAjnr44YfLE088UYajOeecU2IHAAAAAPCiDKr+b5PMcfLJJ5dbb711sl/71FNPlb333ruWHc6/S0ATAAAAAAAAAIBplNgxevTostBCC9Xdcptsskk5+uijyy233FKeffbZ+vfjxo0r9913X/nRj35UNtxww1rZY4YZZii77bbbYL4tAAAAAAAAAEAnDKoVy8wzz1y+9a1vlY997GPl8ccfL8cff3x9xCyzzFL+85//1AodjREjRpQDDjigrLLKKoP/yQEAAAAAAAAAWm5QFTtiqaWWKuedd15ZZ511ajWOxjPPPDNBUsdyyy1XzjjjjLLZZpsN9lsCAAAAAAAAAHTCoCp2NNKO5aijjiqPPvpoufzyy8vYsWPLI488UmafffYy//zzl1VXXbUsvvjiU+NbAQAAAAAAAAB0xlRJ7GjMNddcZd11152a/yUAAAAwnYwcObLMM8889bmrHAPHAQAAAFqV2AEAAAC8fMaNG1dGjBgxzf7/WWedtSyxxBJlqL+GaXkcXo5jEI7D1DsOAAAA0DZTLbHjqaeeKj//+c/LFVdcUe66667y+OOPl2OOOaYss8wy9e+PO+648p73vKe88Y1vnFrfEgAAADotC+Dnnntueeihh8pwNN9885XRo0cP+v9xHBwHAAAAaLOpkthx0UUXlf3337888sgjE3z+mWee6fv40ksvLccff3z5/Oc/XzbeeOOp8W0BAACg88aMGVPGjh07LI/DqFGjpkpiRzgOjgMAAAC01aCb5F544YVl11137UvqWGSRRcqcc8450dfNNtts5bnnnisHHXRQDbYAAAAAAAAAADANEzsee+yxcsABB9T+p6ussko5//zzy8UXX1xe97rXTfS1Rx99dFluueXKf//73/LNb35zMN8WAAAAAAAAAKATBpXYkT6+//rXv2oix0knnTRgQkdj7rnnrm1YmrYsSfAAAAAAAAAAAGAaJXZcffXV9XnLLbcss8wyywt+/fLLL19e/epXl2eeeWbY9v8FAAAAAAAAABgWiR0PP/xwfZ5cpY7+ktgRTz755GC+NQAAAAAAAABA6w0qsWPWWWetz4899tgU/5sHH3ywPr/iFa8YzLcGAAAAAAAAAGi9QSV2NJU6Lrrooin6+iuuuKImdsw222xloYUWGsy3BgAAAAAAAABovUEldqy11lr1+Wc/+9kLJneMHTu27LfffvXjd7/73WXmmWcezLcGAAAAAAAAAGi9GQfzj1daaaWy+uqrl4svvrh84hOfKBtuuGFZe+21y9NPP13//vHHHy833HBD/fvTTz+9PPHEE2WmmWYqu+yyy9T6+QEAAAAAAAAAWmtQiR1xxBFHlK222qqMGTOm/OQnP6mPxvbbbz/B184wwwzlkEMOKcsss8xgvy0AAAAAAAAAQOsNqhVLvOIVryhnnnlm2Xnnnctcc801ya9705veVL773e+WD3/4w4P9lgAAAAAAAAAAnTDoih0x88wzl09/+tO1xcqNN95Y/vKXv5THHnusVuiYb775yoorrlgWW2yxqfGtAAAAAGC6GDlyZJlnnnnqMwAAAAyrxI7eBI+3vvWt9QEAAAAAL6dx48aVESNGTLP/f9ZZZy1LLLFEGc6vAQAAgI4ldpx//vnlwQcfLOuvv3551ateNUX/Ztdddy0333xzOe6448qyyy47mG8PAAAAAH2SEHHuueeWhx56aFgelVS+HT169PT+MQAAAGhTYsepp55abrjhhvLd7363HH/88WXppZd+wX+TRJB77723PPvss4P51gAAAAAwkTFjxpSxY8cOyyMzatQoiR0AAABMZKo0BE2ixqabblouvPDCqfHfAQAAAAAAAAAwtRI7ZptttvLUU0+VT3ziE+Ub3/iGAwsAAAAAAAAAMFQSO7761a+WN7/5zWXcuHHlmGOOKZ/+9KfL008/PTX+awAAAAAAAACAzpoqiR3zzTdfOe2008oGG2xQ/3zBBReUj33sY+WBBx6YGv89AAAAAAAAAEAnTZXEjph55pnLEUccUfbcc88ycuTIMmbMmLLxxhuX6667bmp9CwAAAAAAAACATplqiR2NHXbYoRx77LFl9tlnLw8++GDZcssty9lnnz21vw0AAAAAAAAAQOtN9cSOWHPNNcsPfvCDsvDCC5dnn3227LPPPrWax7hx46bFtwMAAAAAAAAAaKVpktgRSy+9dPnxj39c3vzmN9c/n3zyyeXTn/50TfQAAAAAAAAAAGA6JnbEvPPOW0477bSy4YYb1j//8pe/LDfffPO0/JYAAAAAAAAAAK0xTRM7YuaZZy5f/vKXy1577VVGjpzm3w4AAAAAAAAAoDVmHMw/3nrrrcs//vGPssgii7zg13784x8vSyyxRNlnn33KU089VUaMGDGYbw0AAAAAAAAA0HqDSuxYd911X9TXr7HGGuWPf/zjYL4lAAAAAAAAAEBn6I0CAAAAAAAAADDcK3bsu+++5dZbby2HH354ecMb3jDB516K3v8HAAAAAAAAAIBBJHb87W9/K2PGjClPPfXURJ97KXr/HwAAAAAAAAAABpHY8ba3va0suOCCZe65557ocy9F7/8DAAAAAAx9I0eOLPPMM099BgAAYIglduyxxx5T9DkAAAAAYPoZN25cGTFixDT5v2edddayxBJLlOH8GgAAAFqb2AEAAAAADH1JiDj33HPLQw89VIaj+eabr4wePXp6/xgAAABDhsQOAAAAAGiZMWPGlLFjx5bhaNSoURI7AAAAXkpixxe/+MXyt7/9rUwt++23X3nd61431f4/AAAAAAAAAIDOJnZcf/315YYbbphq3/jxxx+fav8XAAAAAAAAAECnEzve9KY3ldlnn32qfeNXvOIVU+3/AgAAAAAAAADodGLHAQccMG1/EgAAAAAAAAAAJjBywj8CAAAAAAAAADBUSOwAAAAAAAAAABjurVheyHPPPVeefPLJ+jxu3LgJ/u75558vzz77bHniiSfK3XffXS6//PKyySablKWWWmpqfXsAAAAAAAAAgNYZdGJHEjUOPfTQ8vvf/77897//neJ/t8EGGwz2WwMAAAAAAAAAtNqgEjtShWO77baryR0vxitf+coy55xzDuZbAwAAAAAAAAC03qASO/7f//t/fUkdq622WnnHO95RfvrTn5bbbrutfOQjHymvf/3ryyOPPFL++Mc/1kdsu+22Zc899ywzzjjVusAAAAAAAAAAALTSoLIrrr766vq8yiqrlBNPPLGviseRRx5ZZpppprL11lv3fe2FF15Ydt999/L973+/bLbZZmXUqFGD/dkBAAAAAAAAAFpt5GD+8X333VefN9hgg77PrbjiivX5qquumuBr3//+95dPfepT5d///ndfEggAAAAAAAAAANMoseOpp56qz4ssskjf55Zccsn6fPvtt/f9fWPTTTctM888c23h8vzzzw/mWwMAAAAAAAAAtN6gEjtmn332iT73qle9qrzyla8s48aNK3/5y18m+Ls555yzvOY1ryn/+te/yr333juYbw0AAAAAAAAA0HqDSuyYf/756/MDDzwwwedf+9rX1uebbrppon/z3HPP1efHHntsMN8aAAAAAAAAAKD1BpXYseKKK9bnc889t1boaCy99NL1+de//vUEX3/33XeXe+65p348xxxzDOZbAwAAAAAAAAC03qASO9Zaa60y22yzld///vdlp512Kg8//HD9/Hvf+976/Lvf/a58+ctfLn/729/KFVdcUXbbbbdasWPuuecuiy666NR5BQAAAAAAAAAALTWoxI555pmn7L777vXj3/zmN7UiR6y++uplueWWqx+fcsopZd111y1bb711ufXWW+vnNt988zJy5KC+NQAAAAAAAABA6w06u2KrrbYqX/3qV8viiy/+v/905Mhy/PHH9yV39Npggw3KzjvvPNhvCwAAAAAAAADQejNOjf9k/fXXr4+0WWksuOCC5Uc/+lFt03LTTTeVGWecsayyyirljW9849T4lgAAAAAAAAAArTdVEjsaM8www0R/fve7310fAAAAAAAAAAC8zK1YAAAAAAAAAAAYohU7nn766XLKKaeUX//61+Xuu+8u//73v8u4ceNe8N/94Ac/KCussMJgvz0AAAAAAAAAQGsNKrHjmWeeKVtuuWW58cYbX/S/nZLkDwAAAAAAAACALhtUYsePf/zjvqSOpZZaqrzzne8s88wzT5lhhhle8N8uvPDCg/nWAAAAAAAAAACtN6jEjssvv7w+r7baauVb3/pWGTly5NT6uQAAAAAAAAAAOm9QmRiPPvpoff7Yxz4mqQMAAAAAAAAAYCgldsw333z1eZZZZplaPw8AAAAAAAAAAFMjseO9733vBC1ZAAAAAAAAAAAYIokd6623XlluueXKaaedVq644oqp91MBAAAAAAAAAFBmHMwxmGmmmco3v/nNssMOO5Rtt922vOMd7yhvectbytxzz11Gjpx8zshaa61V5p13Xr8CAAAAAAAAAIBpkdgRt9xyS3nkkUfK888/X373u9/Vx5RYZpllJHYAAAAAAAAAAEyrxI7bb7+9fOITnyjPPPPMYP4bAAAAAAAAAACmdmLHD3/4w5rUMfPMM5ddd921vO997yuvfvWry4wzvvB/O8cccwzmWwMAAAAAAAAAtN6gEjv+8pe/1Odddtml7LTTTlPrZwIAAAAAAAAAoJQycjBH4fnnn6/PK664ooMJAAAAAAAAADCUEjsWW2yx+vzggw9OrZ8HAAAAAAAAAICpkdixwQYb1Oczzjij/Pe//x3MfwUAAAAAAAAAwNRM7EgLli233LJcf/31Zeeddy633HLLYP47AAAAAAAAAAB6zFgG4cwzzyyzzz57mXfeecull15aH3PNNVeZb775yhxzzFFGjBgxyX972GGHlSWXXHIw3x4AAAAAAAAAoNUGldjx05/+tNxwww0TfO7RRx+tjxfy5JNPDuZbAwAAAAAAAAC03qASO1ZeeeVaneOlSGUPAAAAAAAAAACmUWLHbrvtVmabbbbB/BcAAAAAAAAAAEzCyDIIxx9/fFl77bXL9773vcH8NwAAAAAAAAAATO3EjltvvbXceeed5emnnx7MfwMAAAAAAAAAwNRO7GgSOt74xjcO5r8BAAAAAAAAAGBqJ3YsvfTS9fnqq68ezH8DAAAAAAAAAMDUTuzYeeedy2tf+9ryrW99q3zzm98s//znPwfz3wEAAAAAAAAA0GPGMggXXXRRWW211coPfvCDctRRR9XHQgstVOadd94y++yzT/bfHnTQQeX1r3/9YL49AAAAAAAAAECrDSqx40c/+lG54YYbJvjc/fffXx8v5IknnhjMtwYAAAAAAAAAaL1BJXasuOKK5RWveMVL+rcv9d8BAAAAAAAAAHTFoBI79ttvv6n3kwAAAAAAAAAAMIGRE/4RAAAAAAAAAIChQmIHAAAAAAAAAEAbW7H0evDBB8sPfvCDcvnll5c777yzPPHEE2XmmWcu888/f1luueXKuuuuW9Zcc82p9e0AAAAAAAAAAFpvqiR2nHPOOeWggw4qTz/99ASf/+9//1uTPPL4xS9+UVZfffXypS99qcw999xT49sCAAAAAAAAALTaoBM7zj///LL33nv3/TnVOZZeeuky11xzlX//+9/l7rvvLtdee2156qmnysUXX1w+9alPle985ztl5EhdYAAAAAAAAAAApllix2OPPVYOPvjg+vEb3vCGcsQRR5Rllllmoq9LW5YTTjihnHjiieXKK68sZ511Vtl0000H860BAAAAAAAAAFpvUGUzzjvvvPLoo4+WBRZYoJx22mkDJnXEnHPOWfbaa6/y8Y9/vP75zDPPHMy3BQAAAAAAAADohEEldvzxj3+sz9tss02ZZ555XvDrd9lllzLrrLOWW265pTz++OOD+dYAAAAAAAAAAK03qMSOhx56qD4vu+yyU/T1s88+e1lsscXqx/fdd99gvjUAAAAAAAAAQOsNKrFjxhlnrM9PP/30FP+bp556aoJ/CwAAAAAAAADANEjsWHzxxevzxRdfPEVf/5e//KXcfffdZaaZZioLLbTQYL41AAAAAAAAAEDrDSqxY/XVV6/PP/nJT8rvfve7yX7tk08+Wfbbb7/68aqrrlrbsgAAAAAAAAAAMI0SO971rneVN7/5zeW///1v2XHHHcthhx1WbrrppvrnxoMPPlh++tOflg033LDceOONZcSIEWWXXXYZzLcFAAAAAAAAAOiEGQf7H3zlK18pW221Vbn33nvLaaedVh8zzDBDrcjx7LPPlmeeeWaCr99nn33KSiutNNhvCwAAAAAAAADQeoOq2BGjRo0qZ555ZllvvfXKyJHj/7vnnnuuPP744xMkdSy22GLlG9/4Rtlmm20G+y0BAAAAAAAAADph0BU7Yv755y9f+9rXyt57712uvPLKctddd5XHHnuszDTTTPXvVlxxxbLCCiv0JX4AAAAAAAAAAPAyJXY0FlhggbLBBhtMzf8SAAAAAAAAAKCzlNAAAAAAAAAAABjuFTsuuuii8vDDD0+1b7zGGmuUV73qVVPt/wMAAAAAAAAA6Gxix7e+9a1yww03TLVvvOSSS0rsAAAAAAAAAACYDK1YAAAAAAAAAACGe8WOr3/96+Xf//73S/omzz33XPnud79bfvKTn5Rx48aVt7zlLWXUqFEv6f8CAAAAAAAAAOiKKU7sWGSRRV7SN0j7ls997nPllltuKXPNNVfZc889y0c/+tEyYsSIl/T/AQAAAAAAAAB0xRQndrxYjz/+ePna175WzjrrrPL888+X9ddfv+y7775l3nnnnVbfEgAAAAAAAACgVaZJYsf5559fvvjFL5YHH3ywLLbYYuXggw8ub3/726fFtwIAAAAAAAAAaK2pmtgxduzYmsTxu9/9rsw000xll112KTvvvHOZeeaZp+a3AQAAAAAAAADohKmS2PGf//ynnHzyyeWb3/xm+fe//11WWWWVcsghh5Qlllhiavz3AAAAAAAAAACdNOjEjj/+8Y/loIMOKn/961/LPPPMUyt2fOhDH5o6Px0AAAAAAAAAQIe95MSOf/3rX+UrX/lK+clPflL//OEPf7h85jOfqckdAAAAAAAAAABMp8SOs88+uxx++OHlkUceKa9//etr25W3vvWtU+HHAQAAAAAAAADgJSV23H777bXVylVXXVVmnXXW8ulPf7psv/32ZaaZZnox/w0AAAAAAAAAAFMzseM73/lOOfLII8uzzz5bllhiibL//vuXUaNGlfvuu6+8FAsttFCZeeaZX9K/BQAAAAAAAADogilO7LjgggtqUkdTuWO77bYb1Dc+66yzyoorrjio/wMAAAAAAAAAoM1GTu8fAAAAAAAAAACAQVbs2HHHHcvDDz9cppZFF110qv1fAAAAAAAAAACdTuxYY401pu1PAgAAAAAAAADABLRiAQAAAAAAAAAYoiR2AAAAAAAAAAAMURI7AAAAAAAAAACGKIkdAAAAAAAAAABDlMQOAAAAAAAAAIAhSmIHAAAAAAAAAMAQJbEDAAAAAAAAAGCIktgBAAAAAAAAADBESewAAAAAAAAAABiiJHYAAAAAAAAAAAxREjsAAAAAAF5MUHXkyDLPPPPUZwAAgGltxmn+HQAAAAAAXmbjxo0rI0aMmCb/96yzzlqWWGKJMpxfAwAAMHxI7AAAAAAAWicJEeeee2556KGHynA033zzldGjR0/vHwMAABgCJHYAAAAAAK00ZsyYMnbs2DIcjRo1SmIHAABQaQIJAAAAAAAAADBESewAAAAAAAAAABiiJHYAAAAAAAAAAAxREjsAAAAAAAAAAIYoiR0AAAAAAAAAAEOUxA4AAAAAAAAAgCFKYgcAAAAAAAAAwBAlsQMAAAAAAAAAYIgadokdzz33XLn11lvLnXfeOUVf//zzz5e77rqrjB07tn4MAAAAAAAAADBcDKvEjj/96U9ljTXWKKNHjy5rr7122Wijjco//vGPSX7973//+7LmmmuWtdZaqz6vvvrq9XMAAAAAAAAAAMPBsEns+O9//1t23333cv/995f55puvzDHHHGXMmDHl4IMPHvDrH3zwwbLLLruUe++9tyy88ML13+TffvKTnywPP/zwy/7zAwAAAAAAAAC0NrHj6quvru1UFlxwwXLxxReXc845p4wcObL85je/GTBR45e//GV5+umny4orrlguvPDCctFFF5VFFlmkPP744+Xaa6+dLq8BAAAAAAAAAKCViR1//vOf6/NKK61UZpllljJq1Kiy6KKLlueee67ceuutE339/PPPXz7wgQ+UjTfeuMw444xl1llnLQsssED9u5lmmull//kBAAAAAAAAAF6sGcsw8dBDD9Xnueeeu+9zc8011wR/12vttdeuj8aNN95Yrr/++vrvV1555Zf0M4wbN6489dRTL+nfMrERI0aU2WabrRWHJtVh8v54sRwDx8H7wTnh2uAa6T7hfmncYOxkDPnix9HG0o6B94JzwnXB9dF9YujExHqfu8gxcBy8H5wTrg2ukW2Sta6sXQFDz7BJ7PjPf/5Tn2eYYYa+z6UVS+/fTcott9xSdthhh/L888+X/fffv8w+++wv+We4+eabX9K/ZWJJ6lh22WVbcWjuuOOOlzSBdQwcB+8H54Rrg2uk+4T7pXGDsZMx5EtbCDKWdgy8F5wTrguuj+4TQ8edd95Zus4xcBy8H5wTrg2ukW0x88wzT+8fARjOiR1NZYdnnnmm73PNx3PMMcck/12qdHz84x8vjz32WNl7773L6NGjX/LPkBYur3/961/yv2dCbcr4W3zxxV9yxY6uH4NwHBwH7wXnhGuD66P7hPulMYOxkzGk+YT5hHnVYOeX5paOg/fDyy8bnZLQsNhii7WmMu+L5Rg4Dt4PzgnXBtfINvnrX/86vX8EYLgndiyyyCL1+d57763PmeDfd9999eNFF110wH/zpz/9qWy77ba1fcrnPve58rGPfWxQP0MCBC+12gft1tWJay/HwHHwfnBOuDa4RrpPuF8aNxg7GUMaS5tPmFeZX5pjizV0M+aSn7HrcVPHwHHwfnBOuDa4RrZBm5KloW2GTWLHqquuWp+vuuqq8tOf/rSMHTu2/Otf/yrzzjtvecMb3lCeffbZctNNN5UZZ5yxLL/88vXvdt555/Lkk0+WD3zgA2W55Zar1TuaRJBXvepV0/kVAQAAAAAAAAC0JLEjLVDWW2+98vOf/7zsu+++fZ/fbbfdygwzzFDuueee8n//939l7rnnrskfp59+ennwwQfr1/zyl7+sj8aXvvSlstFGG02X1wEAAAAAAAAA0LrEjjj88MPLsssuWy677LIy00wz1USPDTbYoP7dLLPMUlZYYYXyile8ov45SR3580BU6wAAAAAAAAAAhoNhldiRZI7tttuuPvpbcMEFyw9/+MO+Px9yyCEv808HAAAAAAAAADB1jZzK/x8AAAAAAAAAAFOJxA4AAAAAAAAAgCFKYgcAAAAAAAAAwBAlsQMAAAAAAAAAYIiS2AEAAAAAAAAAMERJ7AAAAAAAAAAAGKIkdgAAAAAAAAAADFESOwAAAAAAAAAAhiiJHQAAAAAAvPjg8siRZZ555qnPXeUYAADwcpjxZfkuAAAAAAC8rMaNG1dGjBgxzf7/WWedtSyxxBJlqL+GaXkcXo5j8HL8LgEAGNokdgAAAAAAtFASAc4999zy0EMPleFovvnmK6NHjx70/+M4AAAw3EnsAAAAAABoqTFjxpSxY8eW4WjUqFFTJbEjHAcAAIaz7jY/BAAAAAAAAAAY4iR2AAAAAAAAAAAMURI7AAAAAAAAAACGKIkdAAAAAAAAAABDlMQOAAAAAAAAAIAhSmIHAAAAAAAAAMAQJbEDAAAAAAAAAGCIktgBAAAAAAAAADBESewAAAAAAAAAABiiJHYAAAAAAAAAAAxREjsAAAAAAAAAAIYoiR0AAAAAAAAAAEOUxA4AAAAAAAAAgCFKYgcAAAAAAPDSFxpGjizzzDNPfQYAYOqbcRr8nwAAAAAAwBAybty4MmLEiGnyf88666xliSWWKMP5NQAADGUSOwAAAAAAoOWSEHHuueeWhx56qAxH8803Xxk9evT0/jEAAKYLiR0AAAAAANABY8aMKWPHji3D0ahRoyR2AACdpeEdAAAAAAAAAMAQJbEDAAAAAAAAAGCIktgBAAAAAAAAADBESewAAAAAAAAAABiiJHYAAAAAAAAAAAxREjsAAAAAAAAAAIYoiR0AAAAAAAAAAEOUxA4AAAAAAAAAgCFKYgcAAAAAAAAAwBAlsQMAAAAAAAAAYIiS2AEAAAAAAAAAMERJ7AAAAAAAAAAAGKIkdgAAAAAAAAAADFESOwAAAAAAAAAAhiiJHQAAAAAAAAAAQ5TEDgAAAAAAAACAIUpiBwAAAAAAAADAECWxAwAAAAAAAABgiJLYAQAAAAAAAAAwREnsAAAAAAAAAAAYoiR2AAAAAAAAAAAMURI7AAAAAAAAAACGKIkdAAAAAAAAAABDlMQOAAAAAAAAAIAhSmIHAAAAAAAAAMAQJbEDAAAAAAAAAGCIktgBAAAAAAAAADBESewAAAAAAAAAABiiJHYAAAAAAAAAAAxREjsAAAAAAAAAAIYoiR0AAAAAAAAAAEOUxA4AAAAAAAAAgCFKYgcAAAAAAAAAwBAlsQMAAAAAAAAAYIiS2AEAAAAAAAAAMERJ7AAAAAAAAAAAGKIkdgAAAAAAAAAADFESOwAAAAAAAAAAhiiJHQAAAAAAAAAAQ5TEDgAAAAAAAACAIUpiBwAAAAAAAADAECWxAwAAAAAAAABgiJLYAQAAAAAAAAAwREnsAAAAAAAAAAAYoiR2AAAAAAAAAAAMURI7AAAAAAAAAACGKIkdAAAAAAAAAABDlMQOAAAAAAAAAIAhSmIHAAAAAAAAAMAQJbEDAAAAAAAAAGCIktgBAAAAAAAAADBESewAAAAAAAAAABiiJHYAAAAAAAAAAAxREjsAAAAAAAAAAIYoiR0AAAAAAAAAAEOUxA4AAAAAAAAAgCFKYgcAAAAAAAAAwBAlsQMAAAAAAAAAYIiS2AEAAAAAAAAAMERJ7AAAAAAAAAAAGKIkdgAAAAAAAAAADFESOwAAAAAAAAAAhiiJHQAAAAAAAAAAQ5TEDgAAAAAAAACAIWrG6f0DAAAAAABMCwsuuOCwPbDD+WcHAACmLokdAAAAAEDrPP/882WbbbYpw/01jByp6DIAAHSdxA4AAAAAoHWSEHHHHXeUp59+ugxHs802W1l88cWn948BAAAMARI7AAAAAIBWevjhh8sTTzxRhqM555xTYgcAAFCp4wcAAAAAAAAAMERJ7AAAAAAAAAAAGKIkdgAAAAAAAAAADFESOwAAAAAAAAAAhiiJHQAAAAAAAAAAQ5TEDgAAAAAAAACAIUpiBwAAAAAAAADAECWxAwAAAAAAAABgiJLYAQAAAAAAAAAwREnsAAAAAAAAAAAYoiR2AAAAAAAAAAAMUTNO7x8AAAAAAKaWBRdccNgezOH8swMAADDtSOwAAAAAoBWef/75ss0225Th/hpGjlRkF2A4yvV7nnnmcR0HAKY6iR0AAAAAtGZB7Y477ihPP/10GY5mm222svjii0/vHwOgtcaNG1dGjBgxzf7/WWedtSyxxBJlOL8GAGBoktgBAAAAQGs8/PDD5YknnijD0ZxzzimxA2AaSkLEueeeWx566KFheZznm2++Mnr06On9YwAA04HEDgAAAAAAoBPGjBlTxo4dW4ajUaNGSewAgI7SsBMAAAAAAAAAYIiS2AEAAAAAAAAAMERJ7AAAAAAAAAAAGKIkdgAAAAAAAAAADFESOwAAAAAAAAAAhiiJHQAAAAAAADCVzDDDDGWBBRaozwAwNcw4Vf4XAAAAAAAAGCbGjRtXRowYMU3+71lmmaW85jWvKcP5NQAwtEjsAAAAAAAAoFOSEHHvvfeWZ555pgxHSR5ZZJFFpvePAcDLRGIHAAAAAAAAnfPAAw+UJ554ogxHc845p8QOgA4ZOb1/AAAAAAAAAAAABiaxAwAAAAAAAABgiJLYAQAAAAAAAAAwREnsAAAAAAAAYPCLTiNHlnnmmac+AwBTz4xT8f8CAAAAAABgCBs3blwZMWLENPm/Z5111rLEEkuU4fwaAGAoktgBADDELbjggmW4Gs4/OwAAALRREiLOPffc8tBDD5XhaL755iujR4+e3j8GALysJHYAAAxhzz//fNlmm23KcH8NSrACAADA0DFmzJgyduzYMhyNGjVKYgcAnSOxAwBgCEtCxB133FGefvrpMhzNNttsZfHFF5/ePwYAAAAAAAxbEjsAAIa4hx9+uDzxxBNlOJpzzjkldgAAAAAAwCCMHMw/BgAAAAAAAABg2pHYAQAAAAAAAAAwREnsAAAAAAAAAAAYoiR2AAAAAAAAAAAMURI7AAAAAAAAAACGKIkdAAAAAAAAAABDlMQOAAAAAAAAAIAhSmIHAAAAAAAAAMAQJbEDAAAAAAAAAGCIktgBAAAAAAAAADBESewAAAAAAAAAABiiJHYAAAAAAAAAAAxREjsAAAAAAAAAAIYoiR0AAAAAAAAAAEOUxA4AAAAAAAAAgCFKYgcAAAAAAAAAwBAlsQMAAAAAAAAAYIiS2AEAAAAAAAAAMERJ7AAAAAAAAAAAGKIkdgAAAAAAAAAADFESOwAAAAAAAAAAhiiJHQAAAAAAAAAAQ5TEDgAAAAAAAACAIUpiBwAAAAAAAADAECWxAwAAAAAAAABgiJLYAQAAAAAAAAAwREnsAAAAAAAAAAAYoiR2AAAAAAAAAAAMURI7AAAAAAAAAACGKIkdAAAAAAAAAABDlMQOAAAAAAAAAIAhSmIHAAAAAAAAAMAQJbEDAAAAAAAAAGCIktgBAAAAAAAAADBESewAAAAAAAAAABiiJHYAAAAAAAAAAAxREjsAAAAAAAAAAIYoiR0AAAAAAADAVDXDDDOUBRZYoD4DMDgzDvLfAwAAAAAAAMPMuHHjyogRI6bZ/z/LLLOU17zmNWU4vwaAoUJiBwAAAAAAAHRMEiLuvffe8swzz5ThKIkjiyyyyPT+MQBeFhI7AAAAAAAAoIMeeOCB8sQTT5ThaM4555TYAXTGsEvsuP/++8tVV11Vs/De+c53lle+8pVT9esBAAAAAAAAAIaKYZXY8ctf/rLstdde5T//+U/98zzzzFNOPfXUsvTSS0+VrwcAAAAAAAAAGEpGlmHiqaeeKp/73OdqksYqq6xSllxyyfLII4+Ugw46aKp8PQAAAAAAAADAUDNsEjsuv/zy8uijj5bXve515Xvf+14544wzykwzzVSuv/762m5lsF8PAAAAAAAAADDUDJvEjltvvbU+L7/88vV5rrnmKosttlj9+Lbbbhv01wMAAAAAAAAADDUjxo0bN64MA1/4whdq5Y0tttiiHHDAAfVzm2yySbnuuuvKEUccUTbYYINBff0Lufbaa0sOVap+MPWMGDGiPP744+W5554blod1hhlmKK94xSvqe+Olcgz+dxzSOmmYXJIG/PlzfRjsz+/94Bh4LzgnBrouuD66Nrg2OCeMGYydjB+No80npnxOZexk7OT9IM5g7GTsZOxk7GTcYOzES5OxdMbUb3nLWxxCGGJmLMPE5BZLB/q7F/v1LyQXsd5npp4kRgx3g31fOAbjtSFxampcI7wfHAPvBedEf66Pro/uE84JYwZjJ+NH42jziSln7GTs5P1gTmXsZOxk7GTsZNxg7MRLX+OwFgpD07BJ7Jhjjjnq89NPP933uSeffLI+zznnnIP++hfy5je/+SX81AAAAAAAAAAAL93IMky89rWvrc9/+9vf6vOzzz5b7rnnnvrxEkssMeivBwAAAAAAAAAYaoZNxY53vvOdZYYZZijXXXddOeyww8oDDzxQnnrqqbLYYovVRI0nnniinHfeeWXWWWctH/rQh17w6wEAAAAAAAAAhroR48aNG1eGiWOPPbYcd9xxfX+eccYZyze/+c2y2mqrlbvuuqustdZaZe655y5XXXXVC349AAAAAAAAAMBQN6wSO+L3v/99ueyyy8pMM81U1llnnbLMMsvUzz/88MPlqKOOKnPMMUfZZ599XvDrAQAAAAAAAACGumGX2AEAAAAAAAAA0BUjp/cPAAAAAAAAAADAwCR2AAAAAAAAAAAMURI7AAAAAAAAAACGKIkdAAAAAAAAAABDlMQOAAAAAAAAAIAhSmIHAAAAAAAAAMAQNeP0/gFgatpzzz3LO9/5zrLWWmuVOeec08Glz6mnnlrOP//8svXWW5d11123c0fmb3/7W/njH/9YHnzwwbLNNtuUf/7zn2XRRRctXfKf//ynzDTTTPXjP/3pT2Xs2LH1ejHXXHOVLnn00UfL5ZdfXu6+++7yjne8o8wzzzxl1KhR0/vHgul+bfjvf/9bLrnkkjLHHHOUt7/97WXEiBF+K3SSc4JeN954Y/nrX/9a51arrrpq58ZNYew0nvmE+YRz4n+ef/75+jxy5Mjyj3/8o1x11VVl2WWXLa973eumw1UKhgb3iW768Y9/XMaNG1fWXnvt8spXvrJ03bPPPltuvvnmcu+995Z///vfZeaZZy4LLLBAWWaZZTq7VvHcc8+VX//61+Wee+4pb3zjG8sqq6wyvX8kgGFNYgetcuWVV5af//zn5eCDDy7vfe97y+jRo8tqq61WB1FdOw5HH310ueOOO+pCVa8VV1yxnHTSSaWtr3vMmDED/t3FF19cbrjhhnLeeeeV+++/v7ztbW8ryy23XOnChGLfffet50Xj//7v/8rmm29ePv/5z9fzpAv+3//7f3WyeeKJJ5aLLrqo7LrrrnXiucgii9TPv+pVrypdkNf6hS98oTz99NP1z5lU3n777fV9ks93wUMPPVS+9KUvlauvvrpOsvM+6P9emXfeeUvbdfU+0T8g/7nPfa4GWD72sY+VffbZp+9aufHGG5fDDjusdIFzYjznhHOikblDzouBzDjjjPUe8e53v7t85jOfKa94xStKm5MZPvnJT9ZzozH77LPX8eP6669fusLYyXyiYT7hnGg88MADZfvtty/f+c53yqyzzlo23HDDunEiicLHHHNMWX311UsXGDuVOpf89re/XX7yk5+Uf/3rX30JP4299967fPSjHy1tJ+403hVXXFHn2HfeeedEc+yVVlqpfOtb3yptdNNNN5UzzjijHHLIIXUcvd5669XrYK6PXZLz/9hjjy2nnXZaeeKJJyb6+6xNZJ1iv/32q5tJ2uq+++4rBxxwQLnuuuvq+/6II46o86bf/e53fV+T++bhhx9uMw3AS6QVC62SRZksVGdylcBLFm+zIz8Dikw6kyHahQnVbrvtVq699tryyCOPlMcff3yCx5NPPlnaKgv2GTAO9Ei1iibBI3/+wx/+ULogE8csVCaJJcH4Rs6Fr3zlK6ULck5k8baZWH3ve9+rxyJVKpJBf/rpp5cuuOWWW8qBBx5YA45veMMbJvi7H/3oR3U3bhfk/M85kZ11jz322ETXyP7BuDbq8n2i16WXXlrf+xkzJBj/i1/8oiy++OJllllmqQt5zgnnhHOim+fEbLPNVgOvGSv1fzzzzDM1WHnWWWfVRPI2a+ZPCcqvvPLKZbHFFitPPfVU+exnP1v+/Oc/ly4wdhrPfMJ8wjkxoSzc/uUvf6kfZ16RcWQShVPx6mtf+1rpAvOJ0hdfOvLII8tdd91VEyL7z6tynLrAfaLUMWJi0FnMHmiOnTFUW62wwgpl4YUXrtfAxGV33333WgFzr732Kr/97W/r57vgm9/8Zjn++ONr7PHVr351WX755cub3/zmWqEim8pyPcicKpvv2iqxlfz+UyU47/nLLrusbqJJUkfikGussUZNlD/77LPrA4CXRsUOWiWZr3lkEJXB469+9au+hZs85p577rLOOuvUQUZbywhn930mDQlIf/nLX67lQDNoaiQ431bJCM/CXLNb5kMf+lBfmbuURk01j5SQTpJDBthdkASnSGJDJpm9k8ks0KRyQxYw2iwtR7J7JrJrIhPt7CB43/veV49JgvZdcOGFF9akhVQiSNDhtttum+Dvs0jz+te/vrRdKvfEFltsUavX9H//d6F6S5fvEwO9FyLJfwlC5FqZYEvuJbfeeqtzwjlROSe6dU5k5+12221XllpqqRp4TWJDFizOPffcumCX5LdUskg54SR7zDDDDKVtMpbOuCHj6SSxLL300vUamR2GP/3pT8uZZ57ZiUpfxk7jmU+YTzgnJj2GzIaRtB5IvOmtb31rbUWRxbu2V401n5jwvZD5VKoVpM1pbzvHxCC7wH1ifHwtY8TMG7KZJGOnrsyxN9hgg/rI+fDLX/6yxuLTciMVk/PIefCBD3ygxuFynWxry9PMlyJj5I985CMDtjdMBZ/MIRKTa+N7Ir/366+/vlYkSSWjzKsyd1hooYXqn3NvTKv0VNFNYlzi9gC8eBI7aKUs5mdX2Wtf+9paLrlZzM7i7g9+8IO60y6DizZqSkKnt+u6665buiQZ4RlIH3roofU5mcEZUL/rXe+qJfWT2JHkj6233rp0RfPe7y0VnkWIpnpFF6oTNG1H8roTaEv7jST3NEGW/Llr74VMIhtN0ksX3gvRJHttueWWZdFFFy1d1OX7RK/m3E/CV8rHJsCUoGxzbWiuHW3nnHBONJwT46XVyNixY2syx2te85r6uVSp+OEPf1irdCQYm0W8VH3KI4s4bZOKZknkSCJPFiYi18jcMxKczfHpAmOniY9Dw3zCfKLL84nmfpnzIDGGjB+TCJcxVf6uC4kd5hMTjqOzgexNb3pT6Sr3if+dE0suuWRNYuiiVO7II9W0s3EoCT9J8khrmiQF53HQQQeVzTbbrLRRU6FnUnGmVO1Isk8qmCQG0cbEjocffrg+J5EjlR+TyJIEyMRYmvtis9G2dxwBwIujFQut8qc//almRqe010YbbVQDsskWXWWVVWo26Mknn1wX+bPg39aSiBkophJBSoOmSkXXJLieUpjHHXdcHSxnx2VKSQ/U37ALUvYvvvjFL/YFoNKCJR9nwtnmvo6NTCgiSR0nnXRS/TglxRspGdkFb3nLW+pzJtNZxI6UR0yWfGQC3gWbb755fU6SX/++t13R9ftE/2vDJZdcUgNOuSb27qrLceoC54RzouGcGO+OO+6oz5lDNB566KE6d0hCQ9pYNQsYbe0dnsT4yOttFmybuVbMN998pQuMncYznzCfcE4MfL9MvCkLlr1zyyT+NYv9bWY+MV6qFGRB/4ILLuhb0Owi94nxi/nvfve7a4W7phV0l6VKchKC11prrQkSQ9ucAJhW8LHjjjvWR5JYsskw1Xw+/elPlw9+8IM1Tp2qJW2NxSYpPPOjVLD5/ve/X68NSYpPVdRcI7/+9a/3Vf17xzveMb1/XIBhS8UOWmWnnXaqgddIxY5MsjbccMMJFm7f9ra3lZVWWqkGZNu4iyKTiH/84x91wTI70mefffb6aGQXQfr+td373//+GmBJ9Y6URe2qtB3KpDL9DBvpA5wdRdl92gVZfMgidhZvU0Y9E4ss4DaT7fXXX790wZprrlkn1VnA/vvf/14/1yR1pOdlqjd0QXq+5tp/yimnlO9973s1yDBy5P/yXFMqtO3tWNwnxkug6aijjipXXnll/fP+++/fd4wWXHDBCYL0beaccE40nBPjpQ92KlbsueeetWR0dtPl3plA9KhRo8onPvGJOs7OLrS2trPLgl2OQxI50rYs4+rMLzKGbHYmd4Gx03jmE+YTzokJpcR+5pJZtMp9oHc+mdbAXWA+MV7aTmSBNhsnskiZnei97Tf22GOP8uEPf7i0nftEKTfffHNtZZeF+8RX+sdiE4fKBrS2y+aR888/vz6S+NbIeZFzpEkCaqPPfOYzNdaW2ONvfvObSSY+HH744aWtcj3ce++9ayz+mmuumaA6SyqinnDCCfXjVLXJeQLASyOxg1bJJCoBuCRzTGqwmMFkWnH0Zgy3yeOPP17LgTaSwNLsKozeXXdtl53X6YWehYpUrHj00UcnSOa5//77ayJQEn+anYltkxLimVAl6JRgQwbSWYjYZJNNaquirsjibSo0ZJKdBYrITqpk0K+66qqlC1JC/dhjj63lMFO16IEHHijzzz9/WXvttct73vOe0hXXXXddX8WmvB/676xKSeW2c5/4X9JXEv+SzJMASxZwI4lfCdj3BmXbzDnhnGg4J8ZLMPKWW26pweiMHRqZOyQQ+6lPfaoG6lNmus3yWrfddtt6HE488cS+z6cqYuZbXWDsNJ75xHjmE86JRuJNmUsm+S2J8828OmPJ7MruAvOJ8e666646r460MOsfb+tKa0f3iVLb8zWVUQeKxSYe2VapcnfOOefUyjVJ7OgdR6U6RSpVJO7U9g00uS8kceG2226r7UdyXFItORvrXv3qV9cqJtk80vY4QxI2sqn2kUcemeDzib2nqnYqmzTVTVJdO9USkxCyxBJLTKefGGD4GTEuI09oieyey8A5u/KbyfZXv/rVurCfvqddkEFjdhlOSnaUdKX1xAtJSbzTTjut7LvvvjXZh3ZL/8Yk8vRvv5EygQsssEDpiiQzZGKZ45CdBJlAvf3tb6+T7q4E3ybXgiXVnmaYYYbSZu4TE0qQLW2J7r777rqLKC29siu/K5wTzgkGvlcmOJ0ywk1SbHZkJ7kj14s3vOENNUDbhUWKJL8lQJ15VYKwXSyb3PWxU2/p9FQ5S/WWtHLL/LorFd+YeOyU60P/kvpZtGvrBpqBpNVnKnc8+OCDZZtttqm79dOOoQvMJ8ZLfGFyC/YZK6Q9D+2X8eJ9993XyVjs5z//+XLGGWf0/Xm55ZaryRx5pBImTErGk6k2vsoqq9SKugBMmXanCNI5GURngT6JDckGTgDyZz/7WTn11FNrybv3vve9pe2ySC3A1m2ZPDUtiV5Iqnm0tVpJr7TdSC/HplJD//7pvTty2yqB18997nNlmWWWqRn02WnclFTfeOONa6JTFzQ76lKxJ6Uhs0iTFlVd2h3gPvE/6fWaHq/NbrqMG26//fZ6rWh6v7Zdl6o3TUqXz4kkQKdyzV577VWTfCbXvi5fk2o2XZBF/EmV0292mHVBFqO6XCbZ2Gm87Ebffvvty3e+8516vcwGiixg5zw55phjyuqrr17a6IYbbig77LBDWXHFFcsuu+xSP56UfM23vvWt0nbZRJN2VL1tPnsdeOCBZfPNNy9tl3FiNoc0c6lIVci89ixwdi3udOONN9ZEyIyjUw0zlXS7ItXO8shcIguUicMkQTxVCtq+WaBXXveXvvSlcvXVV9ekn/57SFM1tO1xpyRudHU+EYmnNMkcSYhm8vHarsRiAZg2JHbQuvKoSepIG5ZMKiMB6G9+85u1nHBbJ9iCTvRK+c8pbbnTf5dVG2UH1Ve+8pX6WlPyMIsU2W3Y27KnCy699NK6YJeAa4Lxv/jFL+qEOwlxWdzOLrO0o+iCJPrlvtBbuSO9jxOIbWtZTPeJiaXVQs6HjBcSgM2O9EbOlSSKtvWc6A0oZYfM5JIB2xp0ck78b5EuY4ZUtWo+npR8TRd0dXHCOTExY6fxjj766L7S6lnIzjgyicI333xzbXvZ1sSOVGrJNTGVKZqPJyVf0wU/+clP+pI6soiZ6jW98rkuSBJPzoXsSk8J+abdQlo6Zt7Z1rhTf6lU8clPfrJceeWVfZ9Lq7LMqVLlqivSciEteHrH06nsdfzxx3emCuARRxwxQaJTV+JO2SiSxL9sFkoCZD6elHxNYhBtlDaF2UTElMdr23pOAPDyaOfqBZ315z//uT4ffPDBfUGF3Xbbre7WbybcmWi2jaATvc4666waVJoSbe9xGX//+9/rpGn++eevyQxdLYWaBZtGSgZnoSqT7yR15LjceuutrV3E7pWA07HHHls/zqJEdpvl2CRQnfdIW/tiu09M7MILL6zXhlSsyYJ1b2JHM6Zo6znRG1B6oWTAtgadnBOlb5y81VZb1fFAjkk+7vKYocuLE86JiRk7TXwcsoCZsXQSILMjPa0oUr1g5plnLm3zxje+sfzqV7+qY8UkgufjScnXdEHTZiCbZ7J435ss3yVJ8IvMpXbddde+xI5oWnh1IcnlgAMOqEkdef/nfMmGijvvvLN89rOfrRsIll9++dJ2Dz/8cF3MT3JX5pJ53Ukez7xi5513Luecc04nKnc094ktttiiVq/p//5v6xgyG0Uyj3riiSf6Pp6UfE1bfeMb35jiKrj77bdf2XTTTUvX47VtPScAeHlI7KBVmsDCI4880ve5ZM0nUJkeyG0NPAg60es1r3mNA9Iju2UWWWSRunDblaDrQLLrOBJwuOmmm+o1Mb3Rm4olTSuKtjvzzDPrcxI4EmyLSy65pOy00041GJHdJjk2beM+MbEmCJ9e8L2VCJqAXFsXb/sHlF4oGbCtQSfnxP9+v72/4ybBIy0Wcr/I9TE7st/+9re38to4kK4uTjgnJmbsNOFxyL1izJgxdfyYa0QqXuXv2prYMcsss0zQriwfN9fH+NOf/lTGjh1b2zN1pfXEe97zntqSJwvVbY2tvNgxZCPnR7Nw2+YxZCOVe5IknfMhY8mll166bhzIou1Pf/rTOufqQlvDbJBIUkfaMZ122mn1upFkj7SsSqWjVP/KGKrtmorJqQS46KKLlq5YYYUV+hIAcx/oagJg5gwDtT0eyJRuQmuTbBjJ5qrMId7//vd3IvEPgGlLYget8q53vatW5th9993LuuuuWwPQv/71r+vEepVVVmntQHqgoFMGy9mBn9Y0WbjNruN55plnuv6cvPw+9KEP1aDLpJx99tmtXaBoJNB84okn1h7xH/3oR2tp3N7KPQsuuGAZPXp0abuFFlqoPmeR7h//+EdZcsklJ2hDk+SXLsg1sWlF0Xjf+95X3xNNue02BufdJwYuh5uKXgk8L7zwwvVzl19+ebniiiv6AnVdSABMP/AkdqUdURNkSnDu5JNPruOoHXbYobTRpM6JBOCz0zKLNWkvkAWL3oWbNst4ObuPU80o98x99tmnr3JFKtscdthhpQu6ujjRe05knHDZZZfV3cdrrbXWBDvRs4iV6+MCCyxQ2s7Y6X/HIeOntJ/IbvzeFgup3tGcM12o0pBKd5lXXHTRRbVSQxayM4bO59s+p4q3ve1ttUrDoYceWsfMiTE0iS6RJJe0J2m7tP7NOfHFL36xL/EpLVjyceZY/VvUtFFef97/eQ8kqSMybkwcLokdSXrq0txyjTXWqPfRyLUg50JzHLqQ2LH55pvXSi3ZKLHnnnu2tr1pf4kx959PZMNANhj2tn1tux133LFWcpoSbR4/Zi711a9+tVaDTUzpkEMOqdeI/fffv+9rMrf47ne/2xd/AICXohsjLTrjE5/4RC0Pm4D8GWec0ff5BCXTnqUr8vr33nvvmtjRO+H4+Mc/Xktu0x0JzPf2eu1qtvxJJ51UK/nkkX7g/Rd3u5DYkSDbUUcd1dcDuXdymeSWlVdeuXRBAm0pI51dls2CXcqIZ+ddrpNdWcB1nyhlzTXXrAuW2VmVlk1x8cUX1+csar/uda8rbZbrfwLyRx55ZL1PZPdQsziTgGR6QGeBIovbbU2M7XX77bfXRbo8N/eGxRZbrCY3pOVAFxbsLr300vpaDzzwwJoUmgX8lBTPNTOLlttss01r2xP16uriRCMLEVm8z8JtzoMkOPUmdhx//PE1STaPtjN2Gi+LNdlp+v3vf78mAPYmdnRhDB3ZiZzEtyWWWKL++Xvf+15NCs69IQu3p59+evnkJz9ZujC3PPXUU+vH559//kR/n2PShcSObCTKOfG73/2u73NJhMw4KvePLph33nnrc97/SY5vNgxkjhXzzTdf6YJmfNi0hW4Wd1PdqEvHIclu2VCTpPlcHzOn7q3qc95553ViLJ3Ev6OPPrpWd+ovmw1zbNooyRptTtiYUqnak80RketixgVJ+EqSRxIjr7vuunL33XfX8URilADwUnUrSkXrZbCUgHRKQmZilcBkAtDZmd2VnURZqEmPz2QFZwCZHSOPPvponXAfe+yxNcklVQvohkwcm50CWcDL4nUWZ/JI9virX/3q0nZZpMtumaaqTzLje8vJ9+6waLMElXJ9TFAl18X11luvfj7XiATsu7Jw9YEPfKDeH1ImODvzs0CRYxJZ5O9CWWn3ifFyHch9MTtwszP9gQceqPfItddeu5Yab7u99tprgkWZ1VZbbaKvyQJFF86JSBum3C/e+ta31sWaxj333NOZBbumBUnkGGTckMBjxgxJ8kjCcBcSO7q8OJE2AknkyNwhrr322gEXadvYdmMgxk7jpaVA5tJZsM1YqRk7ZyyZ1nZdkIWYplVb5lZZnMnrT9W3JAUmYbYLfvjDH9a4QipS5FrRWwWxmVd0QSqfZQyVZKe0uEzlsyRCbrLJJp2ZW6ZSTVp45bqQtmVJEE7iT1Ppa5111ildkNedhfzMJ1LlLtVLUg0vY6Yku3ShWkfkmti04khSQ9rRdG1DUTYKfO1rX6vj58RWUtGqd/zYxqqgjVS9bJKZXkibKztlvhRNrDWx+SbhY9VVV63vkYwbfv/739eNFE2VHwB4sbqxikOnJNCYRI7eMvtdctttt9WkjixWps1GdptGymdnMJmdyV1K7OjtE/+b3/ym7jrORCILehtssEFZfvnl66Otml1lvfJ6M+HIgmaCML1JDm3UJLYk0Nhkz3dVKhBsuumm5fHHH6+7bvO7z27cBGiT9LPSSiuVttt6661rZaff/va3tQVHI9fKVDrqAveJCSWRI4+u2WmnncoFF1xQg48Dyb1z22237cQCbqr25LzITrPswk3Fll7N7tO2a8rJ576ZharcI5Zddtm+XbhZuOqCLi9OZPF+iy22KMcdd9xkd2lvttlmpSuMncZLwuNSSy1VrxO5ZjbVOpI8nTlV2zdRNNe/nP95/TkOWZhqro/N9bPtml3o22+/fd+CVVcluSUVUbvs8MMPr2PFVHlKpYLGRhttVCvjdUESerJhIPG2zC/ziCzY5nNNm8O2S5LT5FqPtDUhtlc2CWRelfZlSQLuSiXQJim6t2r25LS5slPTBjvtujJmWnHFFeuYoalwlPvGDDPMUOcZuZ92JbGjicvHjTfeWNcsEpdP8lPG2UcccURnqhsBTC0SO2iVlBL/0pe+VHdhJ7jSf7EiWfTNgKqtmnLpmWA2SR1NpYIkdrQ5S7xXfvcHHXRQ3VmaMvJpO5FEl/jQhz5UgxBtT+qYlDvuuKOeHwlQpjdy298TSejII7uu77rrrs7souovv/MkNWTBaiApvd+FxI5MKNMjPi030pYmpXKXWWaZWm69/67DturyfSI9b1O5ZkorWkxpr+DhKMGm7MZPUkuCUBkjNUHX7C5LoKkr1TqaBbsEl3o1u7NzneiCBKLjkksuqbtuc+9sFi2b3bld0PXFiVQfyHggC7cJSPcu1iUY3YXWTA1jp/9V88lO9Oaa2F+qeLQ9saO5PmaBpimfnjaGTXWbVATsSuW7b3/72zVJOgtTXUj+bGTjUOJNqdSR+MLk2p3ma9oed4rEWlKhI4vYSZDNdSCLde94xztKlyQhOG028nvPmDrjpcwtR40aVbqiqzGWXqnWkha3SQDs0lgpMmfobdH3l7/8pS7e5/P95w+peNRWqWKU151EhbQ1Peuss/r+LjGIVALMvXOFFVZo/bipkeviueeeW0444YS60TRVMBOvz/UxVSGT0JEEYQBeHIkdtEoGT03px4F0ITCfhbp3v/vdtfxjSsJmcpHs2KYVRUpFdkH63WYQve+++5ZHHnmkDiSzgJks+p/97Ge1T3wWtdruwx/+cH39jWbnaQbSWazpwi6CVKPIZCGTy+wsTEZ4b2Z83gcHH3xwabtUaUlSR8qCJoEhCQ4JOiRIn1LK2VXQFdmFvsYaa9RHF3X5PpHKNJNamOov5VHbLteCtKHpuixM5H6Y+0TT+zqB+QSgIovbXZBFiKOOOqomvUWSYhsJVGcRswu6vjiRhK4syqVqS1qzJMkn44XcOzN+zDU0Y6skSredsdN43/jGN+rvPdfJJMLlepD3RbOg2YXFicwlUj49iW+ZV2bcnAWrpnXX+uuvX7qyQSBJLikjn+ORBbreJNDMsZPo00Y5B/JITKn5uMtxp0aSYvtXOuuSxJ3SCjr3xLT16xLJThNKjCmJf5tvvnmtkpxKV70bR3LtbOu9IlVh82h8/vOfrxU80p4qx6Mrcg1I4mPiLP1bHSeJIS2act/84he/WLog8ZRsuEy8KTLPTtWSxKIzl8h7JAnlALx4EjtoZW/wlBBOi4n+ZQ/busMugdfeFgIJuCULOIv6GTQ2gYdMuvO12WnTpT7x11xzTQ2uZIEiu0kSjMtiZhcSO5LIMtBuogymk8zQhd3YCTxfccUVfTsvp7T3Z9s0ZbOzAzfXhSxgJls+14n777+/1T2xBZ3cJxq77bZb2WqrrabofdPWMUM4JyaUXXUHHHBAffzyl7+sn0uFp0hSaHbmdkEWLrObLGOlJLust9569fO5P6R6Tf8AZZs4JyaWnYZp2zdQ65m0cetCYkeXx04DHYdU9fra177W14IjLXmyaNWVVgNJfPvBD35Qk2ETa4gktWTRYtVVVy1dkESW7EaOzDH7zzPb3A43m0ZyPcz4sPm4a2PIpnpPEl5zHcjHk5KvSZXEtkucIe09U6GlK4nADclOE0tFo+a4JPbaK1Vd2prYwf9aYacKZjZO9I+1Jtln4403rvOrZtyUuHTGFKkg28Z5VpJBUyU6skZx/fXX1/lDKjtlPJ1EFwBemvbdNei0ZrdQAvCLLrpo6YrsQE6gsb+UkU6/00YGVMke7oKmz3ECLs2EKm1Xmp3JXemDfOqpp05UTjw7CRKc7krp3ATdm13XA2lz24mBvPrVr667DNOaKNfMlFv/yU9+Ui699NLW9kIWdHKf6A20tzXY/mI4Jya24YYblje96U3lhz/8YR075V6Za2WCcF1p0xSparXjjjvWnWbZWZYyuTkGacHRZs6JCaVSR6o0ZBw9zzzz1LlGEn+yoJtkp4022qh0SRfHTpM7DkmSznw7x+Lkk08uO+20UyfmFUkCTJLbgw8+WB9JashCzBve8IZaEbILyU7ZkZ2qb5PS5mSn3vYBqXKX6odJ8pp//vlLV2QBMvfLxJWajyelWcxru6bqZZJennzyybqBpiskO00oMdlsIotcJ1OhI9XOeqtm0n6pbpYqiP3lftHfdtttV8cSqfyTMVbbNHH3xKT/+te/1uSOxOWbVp9NO1QAXjyJHbRKSrx99rOfrTtp9txzz1ZmvA4kZc1SwmxKdKH1Rm8f5N/85je19Ugyp3sX87rSB7nNwbUplcSNlAqOG2+8sU4oEojOzrouJXX0JrvlfMhxyC6qlJSOBKLaStDJfWJSO2+b9jMD+fSnP93axUvnxMSVndLzN4szGUc2cp088cQTax/k3r7RbZYE4Lz3e3dhZ9Hy+OOPb3WveOfEhFKxJot2GTskwSc7TC+++OLypS99qXz/+9/vK6ncdl0eO/U/Dvfcc0/9ONfDlBBPYkMSgLJoNbnKBW2iis34uaX5ZamLtykjn3aWXUrseOMb31jHS0lyysJcPp6UfE0XJNaUBdkszCa+kPdDduM3C/pJfGsqoLU52an3465qNlRljJSWLF2SBfuMG/sfi3yu/1gpiaBJjKM7cfmMn5MIHG9961vrGLJLcXmAaaEbq950xkUXXVQHiaecckrt3ZYkht7yZykt3cadulmkzuCovy4vYq+zzjrl61//ern66qvrn3sXajLZbnO53NVWW23A9isDyU7D7MBsu0cffbSW+rvyyiv7Ppcd2On92ZVymDknUho0cl1MqeQjjzyyL/DW5nOif9Cp6Xud45AF3exMX3bZZetO9baa1H2iy7KT8O9///sk/z471NvKrtOJq5sdeuihtb1EFmkaGUMloSFJHV1I7MjiREqr59zIWCk7C1Mi+Lbbbis777xzOeecc1pbuaP3nPjTn/5U75n93XfffbUNxX777VdLrndBxoiZP+SR62XGmKkGl7lWxtlt1+WxU6+tt966jpUirzk905vjsvLKK3eiFYsqNuN1OSm2f5WGJHakDUeSH3t35bdZqpm99rWvrR9nDpVqqBkvrLXWWhOMnX7xi1/UJLAFFligtF3GSc0iZRaxm1ZFjclVNWmTxJ+S/Jn4W3bpjxs3boK/T3uKto+d0uo5Y+e77767Xh/anBDd3+GHHz7gZsN8Po9eBx54YN2USfvlHpC5Q+LOP//5z2s8KonSuWbmvtmVWCzAtCCxg1a57rrraqZwM6lKgLpXV3YTWcQeX24/5dSTzJPJ1ejRo+uxSc/47LZqc7ngvM+n5L2eXTZdCUIdcMABNakjQfjsNMpEIgt5SfjJ+yPlANsuizIJxDbXxbz2LPYnKJey0gsuuGDpggceeKBsv/325Tvf+U59P6T9wj//+c+6a+SYY46ZYFG3rZL0t9tuu03y79OO4rjjjittlx10m2yySd+fM35I664kfGXharPNNitd0NVdp81CXV53xk1x7bXXluWWW26ir2vzmKFXFmKS1JEe8aeddlpdwMk9I9fJlJdOsP7tb397abvDDjusLkx94hOf6HufZBE7CQ1Z0O5NFm6rRRZZZIIknizQHXHEEX0LVG1OfOtl7DTee97znjqGzLgx18PsRE41o1e+8pW1dVMXqGIzXpeTYntl0TrXyCxkZ8ycBeveHejZZJQ2Vm0lKfZ/ttlmmwHbLjS60iI6Y4Qs3E5Ks7Gi7feJzKXuuOOOWqUlm0Yylm5kI0mSGqBLEmNLVfXcN9LOLTKePOSQQ2w8AhgEiR20SkoDNyXfBtLGah0DsYg9XjKBP/WpT01wbP7v//6vtF12QzQT5z/+8Y91YSKtSPbYY4+6kJ0F7SzYbLHFFq3fNRFZtL/wwgtrsC2l1lMaM8G47LhNkPrMM88sX/jCF0oXyuvfeuutdWdlJDCf98Qvf/nLWu0oO0q6sKh79NFH1wXKSPAp749lllmm3HzzzXUndhcSO5LAMLmgfI5JF+T93v89nySv7ErOe+Oaa67pO1/arKu7TpugUu6Fk0tkyn2yK0k+zS7TNdZYoy8QnbHzO9/5znq/zPukC4kdee15T2T3aRJ9ct/IxxlHbLXVVp2ogJfk34033rjvfrnBBhuULbfcsm98md13XZDS+hlDfuhDH5pg7NRFve13MsfKgnYXdb2KjaTY8TJmajZSPP744/XRa3IxqeFOUuyEMofuUmWGSbnhhhvqc8bVibn1r+TUhVhsUwk0UrVkzJgxE/x9m1uFpzrutttuO8VjTLoj14L+743MrwbaTAHAlGvvqIJOaspC/u1vf6sL2tmVnwz6LFJ1JVPeIvZ4xx57bPnRj340yeOUZIdUKWjrQlUjfQwTWNpzzz1rZYrYd999azWT7373u5Pdtd+mhaokcqRaSxOUzsJldtY0C1VtlkWYPM4///ya/Lb//vv3tRzJcbngggtqckdKh2bhpitBpybZJbtNc61IWcjcO5L00Pbd+ZlEp5pRI++PLFp++ctfrgGpL37xi6WrEoTLLqvIcxcSO7q+63TXXXctK620Uq3kk0oV2YXeyHHpSo/43qD7n//85wmuD01gugut2yLVOXbYYYea+NmMGdKCY/fdd+/U4s3BBx9c29JEroVZtE6SQ5LBurR4m/dBrou5PnSVEvuq2DQkxY6XCqBNpdiuLVxKii11rpQd6FMim0maXept1sSgkgTaldhrf0mQP+GEEzp5Xchra/Pr46VXVe+/2bJXxtap6AHAiyexg1bJ5DqL1r0lAJMtnv59Ka3ehf7oXV/EntIysU8++WTpgvSDj/zem8SO+++/v5YSzwJmdhe94hWvKG3WVCXJMUgJ8WbC2SxWtH2h6le/+tUEk6mUmM+jv7YnMzTyvo/ssstiZUqiZhE7waj8XRcSO7JrIoGn/nJd2GWXXWrSVxb02i5BhLPPPnuCBey05GjKiHdlAbfLu05j5MiR5R3veEdtw9O0KkobjlwT0pKnS4kd73//+2t1ilT+SmJDxpHZeZhqT7l3dqFaRyT5MQl/uR4mIJnjkHlEb+JsF+TcSAuWxgc+8IH6aMZQaW3XdkliaZJCM3eYY445Shcpsa+KzeR0MSk21Yyefvrp8uEPf7ivMkHGS9lUkdhLEsbbrOtJsfldTy6xp4vtoBNzTau6JLxkU1Gbq1NMShLhUykXmLJKsY888ohDBfASdW+kRat961vfqkkd2Y2coEKzOJPJ1Fe+8pVOJHZ0fRG7kQWJ3oocGVCm1UIC8wlCpERkFyTonuSOTK5Hjx5dF7CzYJPkn5RRbntSR9MnPsch50ASvbJwlaoETQLYOuusU9ps7bXXrotUqUYxKQnIvfvd7y5dsNBCC9UEuNwv7rzzzrL++uv3/V2qd3Rt4a5XrpHRBOfbLvfIpvVErwTkN9poo/K2t72tdEGXd532SlJPyghfeeWVfZ+bffbZ67ih9zrRZkkAzc7SJP/99re/rY+mNUk+17+sdpukAsXDDz88weea8yLXxrXWWqveIyLVr9pcUvyyyy4rl1xySV24yvgg1byyUNecJ0n8e+CBB6Z4t/JwlvfEq1/96tqSJYleqVaQ86BpWZW2FOutt15pOyX2x1PFRlJs4kqZRx955JG1kk3mlU2VsyRIZ0yVRJdULWhzckNvUmxas2RunWOTa2OOT8bYiUc1bazaZscdd5zi6q8LLLBA6YK0ds3miLSlSrW/xJnyPmmkWmSbx06hOgFMKHHY/pViU1n98MMPr2PsgTacATBlJHbQKlmwjs997nN1F0GT2BHZfZldFW0OSkfXF7EbCcLm0Wv55ZevrRfOOeeccvXVV3di5+lee+1VS6pn8fL000/v+3yOTQbTXZHXmr6OWcjv3VGUxds111yztFkCbKlKkJKxacGz99579wWi8nfZTdP2ChW98trTqisLc7kf9C7YJvmpC3J/6F8SM/fHZlGzK+VzBwrKZvEyC3ddSWaI3/zmN3VRIrtO89q76oADDqhJHVmIyTgqQafcM7L7MAkPGUN0wcc+9rGyyiqr1PZdae+XcWWqvrW9gs1dd91VF+kmJccij7bvvk27ld4y4meddVadX2WxMuPJJD+l8ttb3vKW0gW33HJLvRbEf/7zn4mSAbN42QVK7Jc6n04VvN77ZCrYpErmL37xi5oI14VNJF1Pis3cOvfHxmqrrTbR12RM1bug3Wa5N6QF7kD3xdwn2prYkWSNriRsvJikhiYhNvfL/smybR47NVQnYCCTaxWftYskAzbJ422TTRL9K8WmEmJiT2mPftppp9U5OAAvnsQOWqVJ5OitQpAJRHYRNNmhXdDlRezJyS6a22+/vW9HehcSOzJh+OUvf1kDjkluyjmQBar0iu9SOekEXZPclGzx2267rQao3/nOd9adRl2QxI3sMswjpRCzKNMEYbMjNzuqUjo01WzabsMNN6y//yQ3ZAf2a1/72vr57Lj99Kc/XbpyLRwoKB+p7rLzzjuXLhCUHe/cc8+t14DVV1+9s4kdCbBdeOGFdTEmC9kJOGXHaapXpI3dmWeeWb7whS+UrlhwwQXrPTLlcRdeeOH657b79re/XRcipkRbE78SZD3ppJPqx6nUkd99Knck+SvXiZwDadW02GKL1UpwXZAAfBKbJqUriZBdL7GfsXLm1YceemhdrM79spH51fHHH1+TOrqQ2NH1pNhU6bngggvqGGEgGUckDtOFpPnE2L7xjW/UeFvmkYnFpTps5hi5TyT2RHdk08Tk2je2vVpHqE7Ai20Vn+q6XdS0QO1KpViAaaFbM3I60Qc5E8nsTE/Wa6QFSz5ecsklO7OQ3fVF7DjuuOPqYkwjCQ0pH90k/3QlEBsJLGX3VAJNmWy/6U1v6sy50H+HXXYi9wZijz766No/vguB2FwHt95667qbZiAHHnhgJxI7Iglu/ZPcMunuimWXXbZWcemVJJ8kRWZ3fptlYTKBxymx//77T3DNaPPYKYkdV1xxRd1R07QY6JKMHbNIk/FTkjoixyELuhlL5Ph0RRZuv/rVr/YlRTdjpgQg25wQmzaO/SUJ8pprrukbO6WFXZvdfffd9bWmZVmuk1msTbW3LGYnySmLd2kvkIX9NrcY6JVKNXlkDnH55ZfXY5T5VBYx217FpleXS+znWphEjrwH4tprrx3wetGFhfzoelLsUkstVd8DWYxLUmgqGjXv/ZwTaV3WlWodqXSVhMiMEX784x/XKogXX3xx+dKXvlTvIc14im5oNkt0meoE9NIqvpTrr7++7LHHHhMcl8Tks3kgujSWBpjaJHbQKrvvvnstcZY+yI0kOGRBO7uMuiSl3LqwIDUpCb5Nqkxsduwn0aVLSS4pk9q7gyIl97NI0/Ydd3bY/U+qtiSpI7/zBB1yXcwiTUoqJ2Cdxd0uSKn9BBzTjinJLv133CVAO++885Y2S8A5pfaT0JT2M1m864ok+U1JKeAkv3VlkSbnQN4DOS9yv8j7v+kXH1nEyyJmmzXnfBI4ck1sdh2nsk9kB2oXZAydyk7Na07FhuxSz2L2LrvsUq+PXanq0sWx05NPPlmfU6GluS8k2Sly3fzMZz5Ttt9++9I1WbBMUmAqmkQS5lMBMDsxu1LJp8sl9vP73mKLLeo1YXL3kM0226y0VZL9fvSjH01xq5L+FT3aJvOoyy67bHr/GENGxgtzzTVXfaQyZNrTnHrqqTURLO29aK9Ugc3cOu2Jkvg5uZZ2+Zq2z7EnRXWCbtIqfvKVYrOhJFWwAHhp2hmVorNe85rX1AlDdghk8JwAXNpObLLJJq3OIL/hhhvKDjvsMEVfm9LKyRxuuwSe+5f/7FKZ2N7EpvS9jWWWWabusMz75Sc/+Uk9Fm1uPWGH3cS9PZtzI9fKv/zlL+WTn/xkXajKruRUNeqCI444YoJymP11oWVXFqTSoumWW25pbe/rSdl77737rnvZLZIEyPzO08Is44UsXmXxMmOGJAF2QSp1NItyabOQR6/JlVVui1SqSfnkJHKkRO773//+Wu2puVass846pQvSciNSmSOtSZLclPfDxhtvXBM8UrGgC9eMro6dmvtfb9WeJokl58h2221Xuib3yVQ0y+J+dhWmEmIjC92phNYkv7RZ10vs77rrrrWqXcbQmUv3tjrN/LLtFWwyXkrS45Qu4nSBRPHx94Xe5PBUwcw8q3mvNJVSaa/8rvPI+KH5uMtzbNUJ6KVVfCnLL798ZyvFAkxrEjtoneyy/fjHP166JDunpjTY8thjj5UuyK7bBGPf+ta3TlAGNC05MuHaaqutOlFG9swzz6zPWYTYeeed68fpl57M6JRb/9SnPtXasvt22A3s1a9+da3OkQlWjlEC1VmsuvTSSydqT9JGWZyL7L7MAu5ss83WqcWJSMnk7JjKwnUSfl73uteVrsjiS7MAk3PgnnvuqdW+Vl111fq5lNa+8MILa1n5P/zhD51oYZaqBM1O7IF0JRkyyT3bbrttTWDoXbRLkmgXro3RnBupatZUrEngLYs1OS7ZjdsFXR47NVV8muodzSJtxg69i3RdWMyO3A+yGJXkphyL3sSO+POf/9yJxI42b5CY0kpnGQ9k40jm3U1VqyQDZs6Za2abr4+77bZbnTtPiS6Mo0Oi+PjxYa6N2SwQG2ywQa3a0Czgp3IH7XbWWWfV5PCc983HXb42qE5AL63ix2+2S1vLxN6zcaKR8XTaYidZ9j3veY83DsBLILGDYU/5v1J3mSZhYUq0PQibQEIe2Y2e8vFpwdMEXBOoTjm87MTM5/pX9GijpuxdzpPG+973vlpCNslASfRpcyCy6zvs+i/mN5ZYYony17/+tVbvyWJVNIs4bZdklkjgsfeYdEnKJC+00EJ1QWrdddetC3ZZvG123S277LI1YN129913X33Ookwj94m0nYhJlQ1tmze96U31OUk+acXx4IMPlm222ab2ju/SOZJxQcYHSepJsCnXiizWdSG5p5FqHCmffvHFF5fNN9+8Jr7lPEiljrTjSbJsF3R97JTKRW95y1sm+FySons/l4+T5NKl3Za9lQiahPo270A2x55Y5pFpzZP5xEUXXVTnGRk3ZNdpPt/Whcu8rv6vLZVRr7rqqlq5ItVscn/oUms/ieLjpX1b07Zu5ZVXrq1XkhCXBc02tydivFQBbeR6kOtCqoE2GydS6enkk0+uybBTWmF4OFOdgF5dbxWf8z+VYg899NB6f8hcqpGEwOOPP76sscYaEjsAXiKJHQx7yv+VMssss3R+J1UjixEJsvXuwM2jv2YnatslCJfFywRcmgW6LN4lUJ2khgSqu7LDLjtIxowZUxdxX/nKV5alllqqU4kdaSWQ0vrNcUnA/sgjj6x/znFoKha0XRYrM5HOgtSee+7ZV2a+Sx555JGa1NHIQn4ejbZfF3qTIiMVa9JuIjuSs3iZYH0CkE3CQ9ulWse+++47QYuiVLPJufL5z3++vPe97y1t9+9//7vss88+9bWmfV+XFqdOOOGECX73ee3XXnttede73lWTvlLVJjvU0wc5C/5d2FXV9bETZYIEllNOOaVWcVl44YXr55LolBZWkWo2bWWOPfG98nOf+1xNjo5sIEiyV64XmVucfvrptcVhF6SiWSoaJamjkXtEFmmS5NEFEsUnHDtlQTvjhw984AP1QXckxpIEt8QVck3IrvymqlESIlMZMO+VbKpoe+wl1aPTwi/H5NZbb62Jwqlss+CCC07vH43poKut4iOxlSRyNC1eM25YbrnlOhuXB5gWureaQeso/zehlDlLi4GBZKEqSSAZYGbR5mMf+1hpm2T8JrDUv1Ry/8W8LixURQIrWcDdb7/9ytVXX113T2Q3cqy11lp1gb8L0pZn7733rhPsRgIOKbufTPo2l1RvZHfxT3/60/Lwww/XPye5IUHJtOP4yEc+0pmAQ3ZYZgKZhZoE5bNA13se5Pxo647LRtpTnXHGGZP8+64sWub6mN23zaORZJ+0WkjyVxekck8W9hNsueOOO/p2qCco+ZWvfKUT98vsJkqlr9wrUrWiS3IPaMqo9y+dm0cj46re6jZt1tWxU5LZco+cEplPdEHaMOV3nsqIqXbVJJFH5lFtbmVmjj2hVPNqKrVkF2oS3dZbb726cJFNBbl/dEHmEbvsskutXDT//PPXRaq89twj0rrqnHPO6URypETxbo+d+J+99tqrLl43BmrBk7hLW8dO/WUBPwlPvfHIjCN33HHHvvZ+dEeSfVZfffW6say3KmbbJZ6UcXI2EExKWgOr7ATw0knsoFXl//Jxggznnntu2XDDDeui5Ve/+tVaaj6l5bsggZTsHkpWfHZY9pdAVBa3sws3OzETrGyTLNBn9/WXv/zluiN/jz32KJtuumnf32XBrktZwVtvvXXNjv7tb3/b1zM+FltssZro0AV5zycAmR0TOTeyoyiB2Uy2s6CZlhTNe6TtsmMkj8h5kPOjaxKIz67LyDWySXRpTK43cFvk3tiVlgovdL885phjypVXXlmTIvNeyPUgwZdmR24XNEkt2YmcxakmsSPSsim7i5qSym2VqgwJLiXJIZUZ2rxY218CjBknT4mutObp6tgp44LeeVVXJaEp18EsWmfucOyxx9br5GWXXVYeeOCB+vm111679dVr+s+xsyM718jswM7HXZN7YTNOzH0ic+0kRDbj6vy5C37xi1/UeEtaXJ522mk1ySvjp8RekiSYZLi3v/3tpe0kind77MT/7LTTTuWCCy6Y5H2h2UzThRhcYguJO91///312rjkkkvWuFOq3x111FF1/JBWNXRD16tipopZ2mLnGpHn3iSPrrXFBpgWJHbQup00CcZmATcBtyxe/exnP6v9wo877rjWD5wiQZYDDjigHHjggfW56Y+c3fmZTB1xxBF1QJXkhwQp25bYEXmdef15JNCQIGwmmgnOJhiX90mCcF1Y2MxEOskL2V2Yxcv0Ak95yCziJMmhC5LA0SR1JOmrKRGcpK/0yP71r3/dmcSOVKn40Y9+VAOw/RMYslj10Y9+tLRdSmEm2WdS2lqtI+1F0ts494gEnCbX5zhfk+tGV6SUfhZkmj7xbS+N2l+TyNFbqSXXh6ZaQ+4bbZed+EnqSZWG3B+T+Jrj0ew6TnJwxk9tlPd8/9L5jz76aF246/+7b3uCT9fHTpOr+tdfArSpetVGGSeljWOSX7PD8je/+U0dJ37hC18oXXXjjTfWAH0WqwaS/vG5brZZ7hGRBeyTTjqpfpye8bleRtOqp+0yp2qqZDaVezJ2fuc731krA6ayUxcSOySKd3vsxP+kwmFa+CX+mkoEiTE28+lU6ch1oivVOlK9JvfJ3rhT4pCHHnporZZ54YUXSuzokK5Xxcy9IBV8UsUmLVkSm89rT1w+50WT9JTEUABePIkdtEqyoBNsePOb39zX9zQtBtLXMQG6tg+cIgu2SWjIwlQTnM3Earfddqul/7LzcP3116+JHRlYtVV2kyXJJ5PMgSRzuguJHZGBc4JveXRRkwmec6J38WqVVVapiR3NtaLtksCSSjaT0lSxaLtm0T6B+T/+8Y8TlMRs82707CDK5DmLtc3Hk5Kv6Qp94ksdM2Xs9MUvfrFvx3GCTfk4O81SQrbtHnnkkbow0ch1IY+utSdKwPETn/hEXaQdSMaX2WXWFanwlXOg2YXavCdSvaCNrQbyOqekalUSX9qc4JKE8Ljzzjvr2CiJHUns6Z8AFVnITPJH22VxtknqSGu/vAd6tfF86G+++earbVcuueSSumCXe2euDxlLRubXXdAs2PbeM5P8NmbMmL7j1AVdTRTvZexEI2OCVLXKHDP30Pvuu68vmSPzieuvv75ssMEGrY+7NAnQqV7TjBkSi0viWxI7cv+kO1TFHC+bbL/xjW8MuFkkMVmJHQAvjcQOWqUJMBx88MF9g+okNGSXepMh2+ZAZGRxJkHILFL2lk9vdtck6NKUjG1z6bOUg0xSRwKNWZRKC5YMJLOYmaBcdhq21dlnn91XLviFpB9um98HkZYK6Rt/8803lz/96U/ljW98Y038yY7MVHfZbrvtShdkJ25TjSHXyARWEmhoNNeFtutqScy873/1q1/V8z2/63w8KW2/JjT0iR9v9913rwtTvYv5OT+ycJdqX12w9NJL14DrpHQlsSNJv837IOPH/kk9XanY0dXqBFmoTrJbI5XNzjrrrFoBMBX+MrfIx7fffntt29T2FiSpPtDIJoE8uprslEW6+Pa3v936FjQvtIkkrT6zeJmxY2Q8fdBBB5VVV121dMH73//+cvTRR9cFq1R/y/3zqquuqq1eM77sQrWO6Fp1t4EYOzFQdchJbR7IOKLtiR2vf/3ryzve8Y4ah0zV2De84Q019pAq0s31k+5QFXN8Fcjjjz++xuLnmWeeGqdOC6+sTyROm3g0AC+NxA5apckKz+6BRkqrJ/iSBcwulABMdngC8VmwSluFd7/73fXj9MONLGh/7Wtf6yuP2VYJOkd24ueYJKElJZVTwSWDyJSMbKvstM77fkqsueaarV/ETb/n7EJtgrApGZtrxJNPPlkXqfbcc88Jdud+/etfL23UVKNIQD47T7uqqyUxUwa3NwgtIK1PfO8i5vnnn193n6ZUagIuiy++eNlkk0068z5JoDlVvHIdyHghpeSzCz9jhfTD7opm8TZjpSS6dWHcPJCuVifI62qqT6Q6SRJgsyjRVABcYIEFakWX9MpOwkeSZtto4403rsluWaTKAlWuiZlbDZTY1JVkpyTFn3766TUhussyZ8r1sanqlPlWNg/kPMnCXRcWKDI+2G+//cphhx1Wfvvb39ZHM87M57pyTuR3nWS3yW20aHvVjmbsBJEd+blnJhk6980FF1ywr0Lwxz72sdYmdSQZONfERmILqVKSa0TmWIk7ZXE748lsMkr8jW5QFbOUu+66q86vM3ZIYuxGG21UW12mvWHmEkkQBOClkdhBq7zrXe+qC3XZfZo+n0nmSPuBZIemxFfbF7AjFUnSw3H//fevWeJ5NBKATTB2xx13rMkOU9pHezjLjsoMqH/4wx/WoGyCDxlAZjD5gQ98oLRRStmlh+FArr766nqORIKzCUa2XSbSmURHJhXp49hI0OHuu+/u+3Obywd/+MMfrrvrsoCbj7NA00VdLYnZ7KKaEqnqkgSYtutyn/jsJEuyW+6PuRfk/vjxj3+8dFn6Yu+9995113EjC/rbbrttHVf2VjhqqyT+fec736kL/F1N6gjVCUpNbMn8KQvXvffFtCfpPUZtlNeaigSRBKdU80lyeBcqc0xKro353aeSTRarcq/svUbk2LS9Kmakasuxxx47YMuit7zlLa1N7Eillswt11tvvZrwmEXaxFYyp0hywyKLLFJjLwO1K2qrLFhPbiPFlLS1asOCdqrjTkpiTynBTzekzWmcdtppdSPZLrvsUv+82Wab1ftDG+fXkTFSNhL1l1ZNzZipiUlNqk007aQq5oRx+VTsyHUg985sQP3e975Xq6unQiAAL177V/TolOwiSwnhBOd7S2pnt2VaD3TFBz/4wZrAkAXMLEwloSULddltlSz6U089tQafmoWsNuoNLC222GI1U/iEE04oF110Uf1c72Ju23zmM5+Z6HN5/YcffnhfUkd2CqTEfgbXbZfqFD/+8Y+n6Gv7l50f7o488shaWr83yJhdI1m8y66R3sSeLFok4aPtuloSM4v4kyqN299jjz1WuqDLfeIzXkpQpWkpkcWqVDHaeeedW3cdnBIJviYAnWSfBJ9TvSnnS5Jjk+SUSk+bbrppabu3ve1ttdVGEoRzHUhJ6d5qFUl6SrWjtlOdYHwFwJwLqfqX6j1Jns/HTRuzFVZYoXRBxsqp7NYkduVacckll9TrZBL/upDwFanKkHYbGUt897vfnejvk9DQ9sSOjBOzIz1jxsyfMp7MOCH3jcw1swu1rR544IEaW0mCx5JLLlkTPBJv+NSnPlW6KgtSuR5EKkPm/ZD5Zh6HHHJIK9t19ZcWE3//+98n+feTq2hC+zdWZT615ZZb1kodJ598ct1g1saqT6mCPLl2jl1s7ch4qmKOPwa9icCZP3z5y1+uVc/aHpcHmNYkdtAqWahM2eALL7ywLtRksp2gdAIPbS39NynZjZ9kjrzupkxmBlRZyGrrDuRea6+9dt+O8wRdE4BqWmxkQtmVPsgJQqanYXZOJBibUsEpFdmF90Ajwfc3vvGNtQ1RFjKbIFwjiU9trV6R3/9Au8kSgOy/yJ/dJl3Q1ZKYOQd+9atfTdHXdqG6VegT/z8psZ9rxVZbbdXac2ByksDRJHWce+65fcmh2UF04okn1upvXUjsyA7kJP9GdmL3l+PThcQO1QnGj50OOuigWt0qCfN5NDKG7kqFnyTApmpHkoRTpWCfffbpS25Jy5a0nuiCVKnIPCKltLM5oH/Fv7buxO6fJJ9jkNaGWbxff/31awXIL33pS7WVWZvLiSfZLTvSr7nmmvqcOXUeWaDJHHudddbpRCJDryWWWGKizyUpNO1vc76k/WfbE78yHjjvvPP6/txUecqiXcYTmWvRHbk2NpVRc23I7z+Lt4lH5FxoaxWbJGtoScRAjjnmmJogn81TXRk395f1hyT/ZsNpbLDBBmXrrbeu8chYbbXVpvNPCDB8SeygdbJon0SOPLoqZf5SKvfKK6+cIBifwGSCUF2QHuGpVNAsaidIn2OQXSUJxKZkbJslsJLXf9RRR9VjkJ1leU8kyNTW3vCTkxJ/CUBmZ1F/CVCn32MbZQd6FiKmRFcCsl0tiZkKTa997Wun948xpOgTT/9kppwjvRW/Umo+iR1dSQ5O27oE3rKov/rqq0+0Az/Jb12gOsH/WvvlHEhSYBZrMrZOaf33vve9pSsuvfTSumngwAMPrLvPs2ibe0da0WRxf5tttqmbCNouCQ2RihWp5tJlqdKRzSR5ZF6ZRYkkxDVzjTZKyfQ8cg5kA02qgqa9Z9r85ZGqkEn4SvwlrU67cs/sL5UxkyieZPlUvcp7pM2S0JVNI/1lM0XmoKnu06WquV2XxdpUdopcD/I+SJWfWHnllVubAJiEt6btzAtJ3ClVEumGbBbIvCpzqlQR76ovfOELfa2xUx0yVYVTSXullVaq8WkAXhqJHQx7CSBk4To7C1Pqb3K9TvM18847b2m7lNFOUkcWKrJLO5ny6e+YRcsEI7ObpO2ycJvdhU32fBZts6Cb4HR2V2Xhpq1VGvLas0Mi5S+zoy7nRcruJyDfRXn/pyJDkl1yPHIcessBzj333KXNwef+7SSS+HXTTTfVa+XCCy9crwdtbsvUX1dLYibwvsMOO9RKTgk+5eNJydc0FY/aTp94mp23WbC++eaba+CpqfKUBd0kDG+33XadOFDN4u32228/xUHqNlKd4H8yVl5qqaXqzrrsSs158vjjj3emnHjunb3j6xyHVDFJUkeSPG699dZOJHakIkMqAF5++eWdTezIpoDe5PjsSD/iiCP6KuB1oZx44igZL+eR1o6pZpUkj8Qdfv/739dHEhs233zz0nbZgZ1j0Hv/TLuqXCMyt+zKNXIgGUtF0wKWbkir15/+9Kc1sStj55NOOqkmRyf2suOOO5a2SjXYKW132rR+pXSmUmwSO6644oqaBNf2Kk4DSQJsEkJ7Y+/rrrtuHTtfcMEFNYE61w4AXjyJHQx7GUTnkUXb5uNJyde0XbOTJokMZ511Vi0LmwBD2m9konXmmWfWjNm2yu84j1/+8pe1922SWZqAa45Dgk/ZnZ/PtbUXcvodNwlOCUBmEXugkuqR8qkpj9f2yUTeE8mSTxC+qwkukWtCklyyKNNIckeq+WQnXhekkk2SORJ0bnYOJSCT3r+ZbE8u4WE4S8A598fsIGw+npR8TZekCkFX+8QnwJjErqYcavPnXlmcaHsgKqXlcwxybmTn0EILLVQXbJ588sl6ndhzzz37vjbJcG3dlZ2d1tld+Yc//KFWuGpjL/QpoTrBeLfffnvZdddd63Oz03SxxRar7UiS9NT28WM0LdsyTkgyaK6Fyy67bF9ScFfa2OVamDlFWs+kyl0qEfTeF7IDuc2J0pHXl6qPuV805cSTPN/EF7pWTjz3xowPUtkp743mutkVDzzwwIAbilLxKlUqejcRtFUSYfuPn3NNTIJL05qDbkns8W9/+1tNhMzmmmw4S3yyzeOFJPlpd8pAMrfM/TEt24477riaHJk4fSPx6lRWbquMnTOHOPTQQ2vVnrR1a2QslYThNdZYQ2IHwEsksYNhLyVhswiRyUIWLSfXu7HNE4pGesRnAJnEhabXbwJvyYpNYkfT266tUo0jQehGSsPm0V9XFiuy4ziPSWlrr9NeyY7PLrsch6bcfhclwJJdppHjkWBbJlQpJ56KLkl6amsVm+a9nmtjSj8mEPv+97+/b2Kd90YWJbKAkyB9G98nqUCQoFNeWxYnJheAauPr7z0PmkWZF5KKT21vPZGF/Mn9OdK2qO2tmlLJqCkRm2tF0yO8WaS4++67+/7cvwpSm2R3bZJasus6wbdUOOpdnErbibXWWqu0neoE42XBLgHZXAtz7Wzk/Dj99NNri7+2y/kQl1xySfnHP/5R7wm9CQxtb+3YSGJ0M2doEn16dWVRPwv2zb0iixRJ8suGiuzK3WyzzUrbJeEvu2uzyzZz7t4qJbk35trZlQSXtN/JolWvxKRy3+xSnCGxp4Gkss/OO+/8sv9MTN/rw7777ls3UTWSLJ3NFNlE0tY2bpk3T0nVz8Qfrr/++lbHW5hQKnU0Y6dsrOrdXBX97yFtkteauWTzmrNpYLnllpvo67pyvwSYFiR2MOxl0f66666rFRqS8ZmdxtmR3tVd+U2rmSRwZEd2E3xsglBtXpCIZPxmIf+2226b7AJnWyeWkd22mWBmx9AL6UJrokwWUgY0LRc++tGP1t99dpc1FlxwwTJ69OjSdlmUiHe+8531PZK2NFmwTCnh7KxJee22VrGJvfbaa4LKNQMFnpPo0dYddgk29wad2tx2ZnLyHjjjjDOm6GsPPPDA1id2MN4yyyxTWytMiSm5tw5XWbxvFmkSgO6/GzntD7tAdYJSxwUZS2cBIq0MM4bq1cwr2i6J8UcddVRtNRH777//BOPHLO53QebWk0sUTwWPtktiT5JiUwGwNxkymymS+PLb3/62tfPLG2+8sY6d0nqlt5VA4i1JlF5vvfXKqquuOkGrmrZrxof3339/ueaaa+oCXVpVdWmRKtWLzj777Ak+lw1FqeTSlaQ3/idtPJPUkcXbJAo3iV9Z2M49pK3Xx8lJRafLLruszjGSDJfKZ2uuueb0/rF4mWTjUBKeJqXNlc5yH8jc4YQTTphsLLoLSbEA04rEDlpRBjNSHjeD5pTOTiByoJJmKR/c9oBDJtFJXEjANRnyCbYkENVkzmcnTZslmJBWC1/+8pdrqeA99tijbLrppn1/l8XstgdcUupOstOE0uM114Y8mr6/jUywu5DY0bQdedvb3lbPg+ZzCUJmASf9cNtsp512qjsMm5YTAyV1bLvttq2/PmSnbYJt2V2aKlZjxowpxx57bLnrrrvq4kSO00C7KdoiO88ntTsmwfnsRO3CAv7PfvazKW5Pl6DLLbfcUndkJwGiuX60SX7XGTs1C1h//etf6zUxC1VdWLBsZLw0ubZcXUl0Up3gfy1G+ifKN228utDeskmIT9uZtC7MPTIL2M258JGPfKSV18OBvOMd76j3gMy7U92sSYLNx9mB3PbWTRk33HnnnXWOlXnD6quv3vd3uV9kc0kWLdu6cJnF+2YBP3OHvM6cC0mSbvPv/YWktH4W7nrHlUmYT3WCLlwbkuSTpJYkO/VW88o5cfTRR9cWFW09J5hYqn9GKoSmgm5vRZ+8JzKuaOIRbZeKqIlJ5pH5ZaOrmw+7KnG2Lktlv5VWWqnGl/Lcm+SRdZk2V4kFeDmMGDepFQ4YJlLaL2W9pkQXyok3E6csUP7973+f4PPZjZ/+fl2VoEsXgiwJoGQCmZYTCUAmmSG7rLqa7JSF7Cah6V3veldZeOGFJ+gLnsoF2223XWm7JG+kH3h2V51yyil10TLtBTbZZJN6XczCRduDswkwrb322rXXb4JPTXuuLFCkokVbq3U00o4ru42zIJff/1e/+tVayaR392Um2Glr1rTy6oIEGlPV5+STT66LVLkufvazn52gD2zXpdJPqje0eRyVdiwJQDU78yPVnbJAs/7665cuyTlx1VVX1d/5qFGjakJU28cKvdKKZnLVCXI+tP1+mWthxkwpoZyqBKmMmPFSFiWSPL7bbrvVNm50ww033FB22GGHvsSe/tp8b8gYKYkcuUdMTha2kyjbRokfJLElVZtSHbPNia9TKptm9txzz/pxkl4zfs55kjF2WpB8+tOfLm2Pq1x77bVliy22qMlO3/ve9/r+LpVd0sorMYlUcaAbcp1M1bdUR0xr04whU8koc++MKfJ+afO1I8mPqcrxwx/+sI4jmwTYVGVI5YJU6kgchu5I8mP/6oeNxKWzeSIJ9Z/5zGdqhYuu6EpcHmBacyVl2MviyyGHHFJ3EGXQlAF0FusGWqDrSlA6O8oSbMjuslQvyQJegtDZbdWF8tlZoMvO2wSeIpPLtOx58MEHa+AhH2ehoq3S2zeJHalW0uhfQrsLgdhGs4squyuzcNtVWazM5DFBx0wgc53MdbM5Pr0l9rNgkySQtskibXbYpjpHEjnaHFzqL4uUCcznHpnFufzus5sq5XGzaJfKBN/97ndr4P773/9+XczugtwrUx44xyMBlQSiE6TOe4RuOeCAA+p1MoszGUNkzJDzIePMxRdfvCy//PKlC5IsnQWp3kBkWtxlR3qbx069+o+Xsw8ij7Yn//XKeZBzIo8kdUQqO0WS37Jo0wX5vad9XXbdJqmhf6WSvffeu7b5a7tvfOMb9fXnPpnEr7ShSUXIZo7R5qpveW0ZF6Q6Q1fLie+zzz59179UNEpbgWahsqvOPPPM+pz7ZRI5mraX2ZmcqqEZT/ZuJGhzslMW7Aeq9tf2BEgmlGqQSez44he/WBM5InOsfJw4TFvn3dlElXHCOeecUzePRNrYZS6RJKeMoZM4TvekQk2ug00VvF6JwaSySzbUJIb9ta99rbSxQmiuCYktRubVGU8kHpnNdvvuu2+tMA7ASyOxg2Evi9Lf+c53+pIXEog+99xzW79Y/UKyaJldEtlt10hANoHaTDTaGnzdeuutaxn1DBLjL3/5S82Abhav0z8+wZdMvNqa6CPZaUIJJORxzz331HMgi9pdlIodTeuqVK7oLY+aIEQTiIjs0G2r3B/Gjh1bA5K9fdLbLpVrHnvssboYk5Y0p59+eg285c9f//rXa8A+JeezAzsT8LbLjvPDDjustq3Ka8/C3O67795XxYVuyfXvwgsvrAk9TcWajCn222+/WukmCzhf+MIXSts9/PDDZZdddqnXilwfk9CSNjxJEm772CnSqi0VzjJuTAue7L7MdSLvgSzQpcVhApJtPga9Ntxww1pGOrtPE4zN3CILN7leJlGyC7L7NhXwJmVyvdPbNoaM0047rS4+5DoRSWbIe6Ht5fWTCJsy4ttvv31ZccUV6yaCLpUT701qS/vb7EZfeeWVO53Y0YyVexPjU+kt50OSoHIfbWsrN8lODCTzqMTasnGoN4E+Y+vEp9oqY+RUQ83rTIuqD33oQzVBOInSSeygu5Lwk8rASy21VI1PZ6yQKkaJR2UslYSOJP3kfZJEjzbNL9Km7KijjiqrrLJKTexIYnTiTDlfmntoEiAzt+xKq0+AqU1iB8NeBgNZmMlusgwaMonu+u6ATCyyUDdQsDEVK7KLpI0uu+yymtSRYEMy5JvBdJI6UgIxu80ymEyyR7KEcyzaKLuK01YjJDuVuoifBev83kePHl1e97rX1cWJRiZaBx98cGm7BKMTaJgSiyyySGmrLErlPXHFFVfUHTRt3U3XX7NTZKGFFqpBg5SNjiR2NAH7JqmhzQtVqcKQRbrsIMnCfcYNaU/TpdYzTCzBpbwfUvGseS/k2rDuuuvWRf1cM7ogO7Ezjs7CZRZwc69MskcW+HMPvfrqq8vb3/720kYJNKY1WXaWZm4RCb72jplT1SitSJqdZ12QKi3NgkwS4nIuJOGlKzJfiJRPT4XItDXsHTdkftEl2TiRcdSYMWNq1ZbMuVINL1UK2jz/zjgpC3VJasjiS66FSXpLBZMkCuec6EoZ9WwcSduNiy66qLafSQJgmxajplTGzNltnevioosu2pcAlcT5LN61/f3Q9WQnBq4am0q5qfyYa2Xmnrk+ZGzVhY01uQ9kI0XGy4kxQCqgZtyc+UTOj8iYOgnTiT8moSPzisy98hiodfZwlFhSUym5mTdmA0WT1JHNEkmcziMxmVS/A+DFk9jBsNfsQM/kIQt1KYWXwfRAg6KUDm574CGLVil5mIzY9K3LQLF3l02bA5AJsEV2EibQkGORnemRRYn0iE8LimQFZ9LV1sSOXpks5L3QlZ2VA0mp6FwbIgs2CUZ3Ucod5pGgQ3aUJOEpJYNTFjUTrq4kOGTxNveBtCVJWe2Uz+5tu5FgdVsm1b2a8vHN77m5LwzUWiCLFm2V3SNZqG/kXpCdNANJO6sPf/jDL+NPx/SS60Ak+Jadts1YKQs2keTALu1ATiu7JgEyi1dJEm0SXNqa2JGk6IwRUqEii9VZnEsiR6RMcMaPn/vc52pLjq4kdvy///f/asuFLNhlETcLebmHJvkzn+9ChaOmxcg666xT3xtdlYXrVL6LFVZYoVb8yjwrLRkyrmjzuKFXxgw5D/IcmUsmvpBKPkmq78I5cc0119QKLX/+85/7qlVkHN2ML1PpatNNNy1tlzaGOQZ5vUn0yTFJG9xIwkvbW3f1JjvlOpD5dq4DeR/kPpGxVMYMU7qpgOHvmGOOqdeCzJ0+/vGPl67IfSAxhYwPs9EsbZ8Tj11iiSWm94/GdHbHHXfU54yfsrksUmE8iQ+5PqaNVVNFt03JcHm9qQCchK6mwlszp8rnNtpoo1rRKokdzXgKgBdPYgfDXjJf77///roA00jP14GkLGDbW7T8/e9/rwt4KaGdnZdJ7OiKBBB6F2iyWyCL2Elw2WabbernmgSHpjVLm2VAnZLy119/fT02WcDPTuRMtpuKJl2Q0n4nnHDCJP++rWVy+8t1IYtSqdSQa2SC0CmPGhtvvHEtN98FSfJpFiAy4ezfdqbt14YEW1P285lnnpngz9H7ua5IcGVSBuqHSztloTr3xSRypN1GFvKzSNFcI7Oo2wXNomQWq3rvHU1CZJsTXJrk4IMOOqgu0KUlS3bPxQ477FCroeU+mR3auTa0vfVEgs4ZMzQLE0l6zBg675EEo9POqws94zfYYINa/S+J4hkrdWHhfiBpdXnVVVfVj1ddddU6XshxibTkaPv50Eg1nyxCZLNAWg70zrm6ck7k3tjMuRu9VXy6kuSTcyKtFn7729/Wdm2NJPp0afdxEqaPPfbYAX/vWfCW2NEdXW13mmSWzBvySMLj2WefXZOhs9kwsnifCldp1ZRj04XqJYyXuWWS5vfcc8/apidJ87/61a/q3CoV8VJNOrGnVLZp0ziqGSM0Y+bMI5MUGttuu23dZNWluDzAtCKxg2EvpcxSGjeVO7JAk0FSBhAD7ZJoe7WOSNm/LFAk4NamrN8p0STtpAxqgvFJ7IiUUk+7gd6s6bZPNlMGM+dGs1DbSNuiBJ+y2ywTiS7IZCql/9Zff/0ajG77DqpJufTSS+tuwgMPPLD885//rIlfmURmkSo7b5P8lDYEXQhATq7VSJurGjXXgN5qRf3/3HbZQZZdIlOyQN2lxEhK3WGXYNOdd945QUnxvF/WXHPNThyiBKWPPvroWqkhyQxJBs1i7q233lqvjW2t1tE/OTjJbWlFE2nX1FRqyLg646ouBCHvvvvuvmOS15t7RYLSWZjIGLJJhGm7tPpMYnR2pWd3epKBkzDetcpO73nPe+pCVSqYpOXKSSedVK+TuU/uuOOOpQsyv0wZ8QUWWKDsvvvuE20kaSo8tV3e8zvvvPMLVrnpwmJuyutnx/GVV15ZY1BJnk/coSuVMlOpI61uk9SRaofZeZ7xdebeSXDJ+Inu6Gq70/7xyMw188i4KffNxOUyls4j14skytINSfLLeDlzy97WjmnVlXlnkkVzv8iGqzbG5e+6666a+Nlssss6TSppdykuDzAtSexg2MsOuixWRkpFJ7kj2eJtr8wxKQm2JdCWYFNakqQPbm9wIQkOo0ePLm0NOqbsYbLkL7/88hqQTtAlAehIedQEXpIpnV6wbZXdAZlEZBCdijbZaZwgZM6N3/zmN3VykXKRWcTvwi7kBJlSGjOPTBxSNjiLE7l2dEnTJz6yyzALV9mNm6SOJHlk4a4LiR3NAl0C9DkO2VmTpJYkuzQ9smn3Il0CKVmYyIJUrokpGZ57Jd2W618qdGSskMW7LE5lXJnF3K5Isl/KyqcyRXYh5xEZN+VzbdpN1l8Wo1IB8K9//WutdJYgbDStmnKPSNJwjkECsm3XVCzKgl3ul2lTs9xyy/UlP+bPXZCgdNP2s2kv0NXKTlmoa+T6mGvjsssu25kqJs3vun/SZ/OeaFretV1+99ksk8pOTVWjJM0nASwJYbmXZk7eBVm4TuuyPLqoWbTL/CnzyWyiyMJ12l1mg02SQ+mOrrY7nVyiSx4ZVydhurcVKN2QDZeZW6bqW+YXGUdkrpVrZeYSRxxxRB1btW3tItVIUjU5cem0JstGsthpp51qknwSwJpkj2y8A+ClkdhBq/z617+uQZWu7JKYlOyieuSRR+rj5ptvnuDvsjO7rYkdKRedhIYkd6QlTd4HmVhmx0jceOON9Tk7y9ochEz/wgRZMkjOeyHJPo1khR9wwAE1ySEJQF1I7MikIqWRU7Uj58N3vvOd+sikKgkeeTTvkTZrFmESeM3O0wQjE5BvFmm6sjiRah377rtvX4uFSOuFzTffvHz+859v7QJ/ElouuuiiKfraLOK2VbNAl0XbvBeS2JEdlglA9JcgS1eqdjQLUlmcSZn17CrL9aHpB5wksFxD2no88ppTGjfJf727sBOESwWLFVZYobXXhv7y+lOlIjsMk8yQoGR2IA90jrRJymNnx/1ee+3VV9UpAfnm956xUxYtuhKAXGihhepzkjoylmxabjz66KP144UXXrh0QXqDT6rFZ7QtGD+5e+f2229fx88JymfHZa4PWbQ75phj6vnTdklYyEJMFiqaHdc5Bs3iRJs3DfRPZEklhlRlGEgqA7bZww8/XKv/ZQ7dW/Eu44ivfe1r9ZrRtVYLSYxMNaM8EoNZbbXVyqmnnlpOOeWU8vWvf316/3i8TLre7nRSkhCce2YeTTIc3ZFxUhKjE2vLhqK0+MvYIeOJbCBoq2ykSdy9SerIRpotttiifpzPZdNh5lldiEcDTCsSO2iVzTbbrA6SJiWVHNq8oB/p+9tkg7/rXe+qgdfeMohtDzSk320WIJIFnOzn3l2V6YecwXPbF2ey0zR22223CZI6mkW7z3zmMzWxI4v7Wbzo/zVtkyBTqrbkkfdFEjyygJcKFukJnEcWL7Own2tI2xdpLrnkkhp8TMJLb9uRLN51QcomJ6kjE+yUgExFl0ggKklhbb0+5DxPBZ/+i9jZRdG7iJ3qLW1exG6OQe+uqQTo8xhocSLXhbabkgW7tddeu7RVAs1J9Dn00EPrIk3vAmXOieOPP76eD209J3r97ne/q/fID33oQzURtEtSuSn9n3MMIjuNs0jXSHJwdqp3pY1dFurSdiVjhlRCTPA144ZUuorsNuzKccgji5XNIlXmVbluZEyZRe6VVlqptF0S3JLQEBlD5R6RpMgkTOc86UJiR+6PSfDKI9W/mooFkQTxLbfcsnRBxolJ6sgcO3OsJANnl34qXSXhI4v6bZXzPRVRc+6nOknmFI0kMSTWlEpXqVaRDSdtl7ljb6vjzB+yA72pYtPMseiGrrc7nRJtTZBnYF3dUBSpjpxNRanulTWJ3oTwjKsTZ0krw7bHogGmJYkdtEoWq5L5OSlNBnmbNZnwCb6efPLJpYuyWNn06ktWfIL0CcBkl2XTO73NPT/T7zbSfmUgKYGZaiYJtuTRpcF0jkmSm1IyNq1HmoBTdqQecsghNTjZ1l7pSXg66qijajui2H///Sdo0ZSduF2QUqhNBYIk+/QGHZsSmW1uN9D1ReyNN964LkwmsSuB5/y+55hjjgF/521+H/Tq8oJd7pd5fU0VgmuvvbYmffXXlftkdlueeeaZdazUld3nved7xs1pV5cKNkkOnnHG/02Vt9pqq/L+97+/VvvqiowZ0hM8VeASiI4ktxx00EGdqVySSkVJGr/uuusG/PsEpruQ2NHbzu8Pf/hDXZxKK9QkzWcM3YVE8UjiYyqg/fCHP6xjqcwbkvSUxf6uVAy955576vO2225bk2Vz38x58JGPfKTOMZL40la5RySmkHtDEjdyr8imicg9IxuIUtEj46o82i4L9RlXN2PI7ERPglNTBa7NST5Mut0p0O0NRb0JsRknNjGojB8zz0pSaGKTXVifAZiWJHbQKimL2iQ2ZPE+A6f0+8wji7ZdKJebhI48EnTJLqK2V+iYnJ/97Gc1E7oZQCdbOjuMspCTFi1tlQWZ9IlPdvRAv/8MpnNMMtDuwq6BBJuzeyq767Lz9Mknn6yfTwA2u5LTiiU71r/xjW/UrPK2JnYkMz5B+PPOO6+Wk87rjlwvEoztXcBqs+Z60FvNJ5PKJiGqzT3SLWKPX7xtgu25P5xxxhlljz326ERljknp8oJdFqlTFja9wCd3T21zNadeWaBs3hO5VybpqWtSqWMgO+ywQ+majBNTyaT/8ZnUMWprdYIkdWSMlHFjKhllzJDEwCSFNedMV9r55bWPGTOmturKscg1NH/X5vtEf1nQ/+xnP1u6qpkvZKyQ939agKZqQxIbMvdOi7sPfvCDpY0uu+yy+rzffvtN1KIp1Uoyv8qcKvPOrjj44INrG7PIJoG0Xknlr7w3ujJ26jrtiWBgXd9Q1Eg8IW3KkhAbafmZik9JBE3MQTUfgJemG6s4dMZAJS9TAixBubRbyG6zNldqiOwiyQJudk6MHj26tpjIbqLGUkstVSfgbZfXn4oEGSgnAJ1khkZK8Gf3XY5FG73jHe+oSR3JAs85kZ3XjZSNTYJLvP3tb+/bZdRmKZ+etjSR15vjkx1FaS3QO5FKJZMEJ9ss14P0urzqqqtqwtuoUaPqLsPeMrptl0BjEry++MUv9i1U5FzJx0lyafNCpkXsCWVhZs899+zMYtSkdH3BLoG27LhPO5pUqTjxxBP7/i7Xxixudyk4nyToVDpLRYZUP8t9shk777TTTn1JgbRPEnqSwJLzIAHYySWz5Gt62xC0ORgduT6kOkHmF5/85CdrEnCSqDNu6IK088vYKb/zBOZ7W/FkgT/3i7YmxGbxZUrkGGRhv+0yl2hkHpHk+CQ6NAtYbY61PPLII/X53e9+9yQrFjRVMVM1tAsbKDK3TguWxpprrlk+8IEPTNefiZeP9kQwaV3eUNTIhtvEYjN2zKaRpqVjE5vOJpvMxQF48SR20HopeZaFiWTDZoKdsl9tb0eTUtqR151Fmi7KTpEMmrN7JnoTOyI7S9qa2JGkleyYSsA5rz87qNJq48EHH6z9j1NSO8k+n/rUp0pXJAiZ8slJdsqxGEiyxpPk0GbZjf/pT396gpZVeX+k/UaCs12w++671wllFi4bKZGZhewu7MC0iF367o9J8svuy1wrE5jOOZCAdEqDdinZqasLdo0m4e+mm26q44arr766jhkShMuO/NwzewNybZbXnbFC5HXnfdE/gE975Xee33HmS83Hk5Kv6ZIkPCUx9Oyzz67XxCSD/eQnPymXXnppvW+0XaoQZOz0/e9/vyZ79d4nMrZu8zWxf2WGSUl7u7Quarskxp9++ul9f05VhmOOOaZ+nF23uZ+2VSp4JZEl8aW09RwoDpOFvKbCT5udc845tTpsEt2aBbq99967XH/99XWunY0kea/QbtoTwaR1eUNRIwnRt99+e4215n6Rdl29mopPALx4EjtoleyeanZSRIKS2X2YLNEEGroQmM8A8YQTTpjk37c9saWRRJ5mUao3+NwEqfOeaHPQKYHXBFdSPjpByd7ElgSnv/zlL09QyaPtE6rzzz9/gs+lZVP/1iNtLy+ea2F24OZ8yC7sxRdfvL4vkuyz88471wBdFxazs+M274ecI1nIzbUix2KTTTbpROuq3kXs7ES+4IILan/s7EjNbsssYLS9HGYqW2X3dVMOtJFEyLRsynvj29/+difGDF1esOsvQackPuW5WaRbbLHFyj777FPLxL7qVa8qbZe2G0lsmpSBFrJojze+8Y3lV7/6Va1Sk/tAPp6UrlSy6X3Ppwpe7pVJgktrv2ja+7VdkqOT0JIA/FprrdU3XkoFnyQMd0HmTxk/v5jKoW2UccKZZ57ZF3PJ3GKBBRaoSQ0ZP7R5DJlKHRkrHn744XU+0Vu9JPOrpipmKl61ucVlxshf+9rX6jgpC3WJq3ziE5/oizckYTrXhWw0afPcGu2JYHK6vqGoNy7fP67Shbg8wLTW3tkGnZQdFL070RvJhE37kS60nUjixvve974Bd51mANmVhaqm5/VZZ53VF5S98sorawuKplRqm+U1Z5EuE4nsnMnAuWlLs9pqq03QnqfN7Cb6n7SkStAx5dNPO+20+h5IskeC9cmkz/Ui7Xm6IPeE7CJLQkeulXnuQlJHr+w6Tl/TLOQlsSPXiOy4TBA2i9hpTdRGKXma4HOSOrIwmcSFLMak3UhaWKXa07XXXluPzdFHH126wILdeKlilaSO/mVi77nnnro7udmV2mapWtOV6k1MLOOC3nth1+6LA1lnnXXqImZkHvnBD36wHHnkkfXPuYdkAbcrUpmkf3WSZiG7C1LNKFUYVl555frI7z4Vr7qgacvW/3rRbJ5Isk+jze3bUhUz4+eMFZLEkuTPJPykSsett95annnmmXpc9thjj9JW2Th10kkn1Y+b6iwXXXRRX1LH5z//+VoNL+PpzCm6dI3oIu2JYNK6vqEomsokuUek7UokEbRp59jbyguAF0diB61y6qmn1p34vTK5zoCqrQGGgdh1WmpyS/q7Zvd1U1a82V33f//3f61tw9IrAehVVlmlPrrIbqIJNSX111hjjb7EnuxAf+c731lbUqSKQRcSOxKc/tznPlfOPffcCXYIJDiZHXjZddh2CSoceuihNTibRK9IckNKy19zzTX1XpodJm10+eWXl5tvvrkGGFJGP8GVXrlPpIJN7h05J7qyyJ3kzzxy30iwJUmQaU2VhMAuSPWaVC/K+Z/3fv/S+10qE3vKKafU5K4k/iXxrVcqgbW9ZVmX3XDDDWWHHXaYoq9NkmgTlG17wnzGSDkfIjssU7ki18lUO5pUe7+2ycaJL33pSzUJOOOo/jssU/ErFQPbuFEg1SmyOSCPVEL88Y9/XB+RGEMz10qix8ILL1za6IgjjuhbkHkhBx54YNl8881LGyXpOcnxTcuRjB3yaOT3n/Nk+eWXL22VahyPPvpoLaufROn47ne/23c+pILufPPNVxM7mgpotJf2RDB5iTl8/OMf7+xhSkJsNsxkbJCxYjRVUxOH2WKLLabzTwgwfEnsoHXZoNmNG72LEwk+9ZbKbDu7TksZMWJE3W2doMJvf/vbWs0lO2qyoyhJH13R1UCs3UQTa9oIpCpBI9fLlBSOBOG6IDttU8klEnjNjtssZv3+97+vLReS1NB26Yn9xBNP1J2GSWJo3h/bbrttTezIjpK2SiA+PvShD02U1BG5P2SBJmOHG2+8sROJHbk/pjXNd77znXo+pILHP//5z1rlK1VckvDRpfZtA5WJbcaWbffrX/+6tmqblP47tmnf2Kl5z7+Q3jaHbZby2ZlL5J4R2SjQ5t34k1vYT/nwSWnrNTItCpPckUfGS6nIkKpeTRXIjBOS+JNH2lL84Ac/mN4/MtNYdlmnImjmU5k/pGJBxk7ZNPK2t72tjp3arLlHNPGD7MJOnCEyj0gLmizkRf8NV7SP9kQwsFR/PO+882o1pyTD5T6R2EM2H6b6WReqiTc22mijWpnjhz/8YY1D5VhkXJUE6eZ+AcCLJ7GDVrE4YddpfwkubLDBBrVkbkqnPv7446VLuhqItZtoYu9///trslOSebIjN215EpTOZDP9sLtQrSMuvvji+pyqHc2u/ATmM7G84oorasJDduO2WRNIyGvtLZl933339S1ktFVec0yuMktTWr352rbLdSHtmCL3iyR1LLPMMrWySXqodyGx4/Wvf31tVZfj8L3vfa9+LsfhhBNO6KtO0AVJ7Gpeb1oY5lqYRNlG7hW0V1pz/epXv5qir01QtgsyLkjFhixiduU6MJAsYEd2VqbyYf9qTk3ycNslST5jgzwyp+xf1aitMmbOg/9Jcnhan6YCYNPS7qtf/WpZd911y7LLLtvaQ9VsBLj77rvrHKIZJ2V80CTA3T9tvYsAAJx5SURBVHHHHfV5/vnnn44/KS8H7YlgQtlId9BBB9UEwP6yeSbtkRN3O/744zuV1JC4cxIg054r8cfE5JJQDsBLJ7GDVrE4Yddp74A6lUuyiJ3BYxI7Upkg5VOzmH3YYYeVLuhqINZuoollh8B+++1X3/upYpNHpC1LPteVlgvN68wOo8ab3vSmOrFOgL4LbbuyiJ3khSRApcdrKlSkuk/aj8S73vWu0lbNDsPeyjW98h5Iok+kylOX7hPxhz/8oVatSCuOt771rbXEeG/yT1tlkTplYvNozoPsKIpUttlyyy1LF2SRKt7znvfU5B66JeOB/j2/s4Cdloa5NibJJ+PrjLHSqqpZxGuz7ChsrpNPPvlkLandRU3Ca66FzXWiC3L/a9qw5JGExyYpPudDFikyhsr9siutL1OFYXIJLdlU0eYE4UYSG7KonVaXa6+9dj1Hfvazn9XKf8cdd1x573vfW9oo7WayOSCVOvK6m6TwHXfcsc6l8ucsWEbaE9Fu/7+9MwG3seze+NOXPs2jkFKKCBmikKRCkVJSqUgzCZFGkuZoUiiVyKfIVKkoiiapUDJHkkaVCCGlvsr/+q3v/+zec5x9HGfa+7zP/buu99r77L3POe9+x+dZ61732kftiYTIAK4UXtTBfYDrIMUDCEO5biLsQDT88MMPu169egWx9Wh/izgUZzPcO5hH9O/f3+6ZxBxoeyiEEGL7kbBDxAolJ1R16nnzzTdN1EH1CBWIgO0drh30Rab3bwhJi1ADsaomyhocKgg8T5o0yarR6Y9MZVkI7SY8Z5xxhlXUcS3o2rVrYrL566+/ms123BPY3rGDFk2dOnUywZtvx+MDEIjA4kr9+vXNhYL7A4EXnFq8IwEBF1yO6AmOAIhETQjwvYFEDccClaZYiXP/4L0QhB1AxS0iL44Lev+S5Cap27p162Aqqs4++2w7N7hH8Dw7ZxsRfx5//HH3yCOPZJnEJTgbgrBj7dq1JvKjJQvBeSrQuT/4+0bHjh3d6aef7uIO86YePXpYq5HrrrvOkvchgNCzffv29hyxAnNHigVYGCOE6GLUp08f9+yzzyZ9v3fv3na8xB2SUog6GCf4+TZjSq6b9957b2yFHcD347zwog7mDYhcgNcQAzKeCuHaKNSeSIgovuUv8deshBu0Bsc9F7enEIQdiKIpIkMU6gurDj/8cLt3zp071wovr7766lSvphBCFEnCmJGLYFByQlWnHl+NTaChdu3a9pxHqlDpdUjyKgRhR6iBWFUTJYeJFG42oUK1JUnrQYMGWQIXCED6NhRUUXiotoirqw0WoD6Bu2LFCnMsIFHRsGHDDK0X4midfeqpp7rJkydb8oEAPG42WIF+9tlnCbcfKg9xrggB3FtITgwePNgEDS1atEi8xzaIa2sibPSxxKWKytumH3bYYXbPDImHHnrIxG0ekvjr1q2z8RIVVNFxw7XXXmuCDxF/cOrgPsnxQEUu4kdEs1wrcLGh4i4EqK70YwTuE3z/KP6eEYJgHoHfsGHDrF0V181of3jmVnEdL3m4HnLfwD7ct/XLPL6gAjdkOAbiOmZIFmugbZl3A+zSpYudI7Qi4ZoZV1EoMRSuCWyD0qVLW6GAh/sE7meMFUIQBYuM10AWIUIGR1RIVijD/Ar3N8aPGzZsiH28gfsh4o7y5cuboMWPFRADIuyIFhgJIYTYPsLI8IlgCDU5kRlVnf6vqspX2mU10A7BIjb0QKyqibaG4wC7Q86LzBW4N954o1Wmxx1aMfl+nj5Z48FaPkrce6fTlgQbcaz1uTbgbkQyj+dx5r777rOqaypEqCz0FYeA6Ofyyy+3KuxQoMJ09uzZbtSoUZaciI6dcLiJK/T3pZoK5wHEj4wfeSRBccEFF7hQ4JynFVNmfMuNKL/99lshrplIJbQi4l6J2xtOd1wXSGbj9sS1Aiv+uDJ9+nS3cOFCqyy89NJLzdksGaG44RF8x70JOC4yz6/iPl4CvnPm752VW2Dcoa3jTTfdlPiZ44LETOfOnS3JH4pLg59PI4T0cC/l/EAgHZ1vxxFczXzxTBSEfyxCCBEiPs6UXTyF+TZiBz+uijM+7o4wlm1DrCXEuLwQQhQEEnaIWBFqciIrQqw6jdKgQQPrb0sVKkpoEjUEaTk+GEzWq1fPhUDIgVhVE2XkjTfesIR2MkKYWMJTTz2VmHBvC6qU4wrtRgjC8wgktwnEEqxH/BNXwZcPRpOYoDUR9vo//vijJbFpSUQVTWjtJxCDInzlHok97CGHHGKvk5y55pprXCgQYBoyZIidCyEJO2jJxLmQE2hJIcKCZDVOBSxcK3F1Gj58uAlF4+pO8Pbbb1urCYoCcL4LqV1dMphbY6OdjLiOGag+x9ksJ3jXhriDi1PUyYkxFfPqJk2aWJvDGTNmJOzW4x5roBK5e/fuJv5CzMFc6++//7a2lzjhhcDMmTPdgAEDbFtkvkbUrFnTDR06NGXrJoQQhQ0xBeB6+Pvvv+fos3F3C6agZtWqVe7888+3+yPPcY7191IhhBC5Q8IOEStCTU6sXLnSevTlBCppQhC50LOPqmuSuH7Q6BXBJPRwdwmBUAOxHlUT/cPHH3+cCLJhG8y1MtpyI5Q+4SRujzvuOLtHhOLilBW040HUQY94BG8e2rKMHDnSde3a1cUdHFpov3LWWWfZeREyJGRYovTs2TNl6yMKD8RNLJwHXBuFAATR0Sq6GjVquPvvvz/h4kKbAREOzKkRxTLnpPWpdyPg+bx580wQGccxFcl57MP9d0X8euKJJ9pcOtQqU4QLLNGfEX1xHESrcOPO1Vdf7T766CNr14QQzEMCi3lWCFAUQPsZKrGzgop0IYQIkUaNGqV6FdIChKA4KXOvoH2Xb2PmtxHFuUIIIXKHhB0idoSYnCAR169fvxx9lkrUEIQdvrVE06ZN3bRp09z69eut0vTkk09OBOhCwIubCLKR2EfkUb16dXN0EWHh7cJxJMDNJFSoLHvllVcs6OqD81Qgh9QHevny5SZoIBFDpWHman3EkSFAVemYMWOsJU1owo7TTjvNLMOpRKYdSVatODx8hm0k4smCBQusLRvngIQdIir2POecc9yyZcvs5zPPPNOuFT6hy30z7vDdce/YViXiQQcd5OLO/PnzrTd65vZMnhDEsohhX3vtNUvkI4QLlbvvvjuDkCEzcW7TFAUXIxzupk6daokq5tgVKlSw8VXcz4XoOYGogzkUrpBVqlTZys1FCCFE2DC/ZPw0efJky13gcEZxEXOJaKGZEEKI7UPCDhErSEzQ+/nDDz+0qprM1mY4N8QxOUHwlQSlBxEDLTgIOOBcEYWAQ0hQYcgSMrSkefzxxzM4d5x99tnuzjvvzBB8EfGGfc41kCQtz0NrN+Gh2vLVV191H3zwgW0PFuzWEYHh7nTMMcfEvgrzt99+s0e+dxSfsIlWYsYZf38kYUVV4W677eZCgX3Nwr72z5MR9+OB70fLNu9A4H+OwjUhpONDCEAA6YV+3BtpvUISk2tnmzZtYr+REP6xZEfv3r2tXUvcGTRokN0n6BnPGAIHSKy0AXFoCIlsBNLEEfjeCGRDKhTIaTwCt0wKCEIBQQNCDpYQ4XoAnAu0oxFCiNAZO3Zsjttdx909OQqxx0suuSTVqyGEELFCGT0RK7AIphI7tOQEYo3BgwcnfsZWnyAbk+zo66Hx5JNPuhdeeMGtW7duq31/7bXXBhGU5nx45JFH7DkuDVgKk8Rku2AVG+cWRcK5hx56yPa1h0km5wOuHQi/osIezgkEH3EHhw6WX375xdx8pkyZ4t59912rumMhMH3qqaeakwXbKK73DIKxVCOPGDHCXluzZo174okn7Hko7hVr1641JyfaUNStW9euiVSQ+MqRjh07mtgnzkEnAkrbCkDFPeiEfTxJ62Q/e7ez0aNHu7g72GyrF3T9+vWDdnwKDdptUH3/3XffmTiYfe/3P8ntuAtE99lnn0TiMhnbej8uIGSAZ555xlwiO3XqZD8zl9p1113t3hl3aDdCK0/cGUhiM35g/3sxMG4FxCLiTo8ePdx1112X4TXmEyG4M8jtbOuWXSeddJKbPn26mzVrlo2lhRAiZKIubtwr1QL4f3PMAQMGuK+++mqrNuG1a9cOOmchhBB5QcIOEStIWEO7du3ceeedt1WQKe7JCfEPJGyza09DT9gQ8JWGCDiuuuoqe46tNAlLklTdunWT/V2MQbyQVYsF3IwyV+h7F4dQoLq0XLly1q6ICkxfrc924dz4/vvvTRwWRxB43XLLLbZgiwlff/21PbJNsNsPAezUV69ebc//+9//WvIySnYuFnEKOoXQRkBsmzfeeMOWbbkTSNgRDsOGDTOXjqzGzCGInegHHoIbx/aAmAHHlk8++cTGCoylnnrqKZtXxL2lHcLoaG94xg9+DBGSyIf9zDyC858xI66hHAO4pbZv3z7Wx4HczjKydOlSE/mRqON6gMiLxYN7C66hQggRImoB7KxooHPnzuaOmhU+BieEEGL7kbBDxApvA8vEErtUES5U3AKVhrQcQdQT7d9HVX4I+ERl1CKWyhqCLgSnsJuPqyuBcFZRiXtPToP1IYCtPP09acFCj0/g2lCnTh3rmY5rw3/+8x+rPiOZFdcAdcuWLS3gOm7cOKueoNKSZE3r1q0zBGXjzKWXXpqtdXScxxEk5RCz5ISqVau6nXbaycUNjn9EoDkhrteBKIcffrhV32aHREDhQML6gQceMMc7qvFp3YWDR2jjaPHP/dCPmWhx2adPHztGEBAzhsqp7XhRhjnls88+m/T9UIQdjI1xakHkgtjPzzfZNsy/hwwZ4uKK3M4ysnHjRhtPRhN00SRdnAXSQgixLdQC2LnPP//cRB3EmnA1YywVdQ0Owe1LCCEKCgk7RKygqgp7UCpIsD2LDhjiDEHXaLW9t9KmmiazMha7WKq1444PrjVr1swCkKGCoAXnAZLZPkmJnTJBF46DUIKQoVKiRAlbgH1OUiaE8z87qCr1LiZUGp555pkmcihTpkziM/Xq1TNbSLZZHBO6VFUSaKDK8oYbbkjYiIdG2bJlbVm/fr17//333TfffGOtJrDf5/U406FDhyzdfLKCVjVxFH5xbpcuXTrDayQpSVaSpCRZ6d2Nvv32WxN+xZnzzz9f7gQiQ9sJ5heIHV999VUTdohwoS86rRaAdgvMNb2rGa2rQmjFQgHJ0UcfbfeHDz/80Fy/mEc1atTIxI+hzKm4HiDqYJx07LHH2muIyBFM09oQcUdcW/pldjtjjIBjBecDz0PjyCOPdJMmTUr6fgjXBSGESIZaAP8Tl6eAgNi8EEKI/COMrLcIhjfffNMC9VgHjxgxwgYR0eqyiRMnxrIdy5w5c7Ksyp87d65ZJYdmnQwtWrQw60/aDJx77rmJ5HZoMHgm+HbzzTdbEJIAC+cBnHLKKRnODxFPcJ7o27evCXpIVBKAx8Xm0EMPdSGCQ02TJk1MzIFDRVYgCiSJEdcg/RdffGHXRpIScU9Wb4vnn3/e3X333QlxJIkbtg8Vqbwed7gncC2IOlplJhSRLGOGRx55JMvKc8ZOoZ8rIiwqVqxoDi4kLEMThFIkQIFAHIWdueWEE05w48ePt3sk22Xo0KHmzIDg58orr3ShwPgAS3Ee/b0BkTBi2eeeey6WcYbMLFu2zB5btWrlypcvb895RBg7YcIEm2/EVdgRZcGCBa5r167uhx9+CEoUG4V7A/s+dLGTEEJkR8gtgCkuPP74460tzezZs00gK4QQIn8II1IrggEhg+8DjcX42rVrM7wfgk2s+B9UDe22224WYGjQoIEFHqNW8t26dbOWA3GH5PRHH31kdvNjxoxJvM7E4sYbb0zpuomChxYbV111VaLlAtVkBN7ogU2FVYhJC4LOOUlUd+/e3cUVJtgEFagyJADvA/Ohwf0BG3GCLVSefvbZZ4n3SNBw/axQoYKLMwhasFDHoYYqbIRflStXDk70h1PHoEGDbJyIYwsBNwShbBvulySw4grjo1KlSgXTgknkDMYHJO4RjjNexuEpeozgdkMlYhwZNWqUzSNy2tILoXTcGThwoM2jzj77bBMEHnbYYSYaDg3mj4g6SEyQoPDQpmbkyJGW6I87/jqAvbqH+Atjquj7cQdLeS/qQDSeuWVdKG54EjsJIUTWqAWwc0uWLHFr1qyxeCRzCsYI0XEChVaPPvqoDiEhhMgFEnaI2AXi/vzzz6Tvx7WKhj7xuJXkhFB62H399deJYAvJbKz2o0T7v8YZgkyDBw92b731lqmksdUmade8efNgAm8hQ2KCSdQBBxzgHnjgAbdy5UrXs2dPayuApTbq+RAg2J7Tc56WXnE/N7DY55jAzYdrARWFVNX5IHSVKlUsYB13pk6datfEc845x6rSo8IOYPvEVdiB0G/GjBm2IPbiHsECHAskrRB5sFSrVi1bR4+4jBm4ViJ6wsUF1y+2B4lLxpb0A44r11xzjS1CZAZXhnXr1tlCYDYKTgVxFXbQlgs3xJxw2mmnuVBEsYwdqcSnPU+IIIRlnIAQDvFvZrdMEjghgOsdSRhasnz55Zc2nuT6QMUxQlnfniXu8H2BKmscbUJFYichhMgatQB2bsOGDW7x4sWJbUJMLhqXyxynF0IIkXMk7BCxAmuzUKvqoj1fxf8G0fSLT0ZIrVlIyDVu3NgWERbetYgKSxK0PpmN4IPkfijQYuGnn37K0WdptxB3YQdJOkQLntWrV9viCcU62QcV+L4IOzzYogKij7iCQwmLd64iWYX4jwWhx9tvv21LKHbi0bEBlbcsXCMbNmzohg8fbi3+Hn74YRd3EMKSpHrhhRfsPMh8DuD0FYLbmfhfFTatNwDnuzJlymQQeMV5znXBBRfkWPhKz/AQoKISYQdiQNr0xF3slxW+ZRsuR1FCGDNEQeiI2xnCR5I1PmHDWKpfv35u7733diFw0kknmXA8RPdDj8ROQgiRHLUA/l8RKk7BycAFTgghRO6QsEMUeagciiaksoMkRUgJ/ZChzYBvNbBx40ZLVhCExGadSjwSm3Ht70f1IElsBtAXXXRRtgltPsN2EvHEOxhFg6y0GYBoIjvu0PebagHPBx98YLbRvJ45IBuCqxFB+WeffTbp+6EIO6g4J2GPewVJS3j//fctcQU1atRwIYBTBfdJv4R0bfAceOCBGWzT2fe41viEXSguX7iUPPTQQ0nf9+0ORTjjB4QLTz31lAsJvrMXbPj2bcw3d955ZxcqzKO4RpLMx62BuUO09cSIESMS48u4goMX46Nly5bZ9wXsxZ944gl7XrNmTRcKuJXg3MF4iWpbxJ++9WkoIHSk5SXtdxCF4wwbbWMXggOgxE5CCJEctQD+n3CDtr/EGIhLE48nLs+4knk2bmctW7bUYSSEELlAwg5R5CEBkdNAM4MHEc5xcckllyS1UqYdRVyFHQyQfaWtf56MUKrLQsVf80jQbNq0KcNrXDf9a4DAIXN/6LhAG5ooxx13nE0sSdyG4kQQBavsuF7/tgeSEqeccoqbMmVKwsHGtyMhaUEQIq5gm47AiaTMxx9/nEG4gM2+b8NSp06dIM4RxG+05CFhB2eeeaYJI/09EueOEJg/f36iHdMdd9xhidpoZX4oldjiH3HDihUrrFVRnB06smPevHkmhNxtt93cySefbG2aaDURFYKFAPcKgvHgRYBRsmuFGhcQ9txyyy22vPbaa/Ya5waUK1fO7hmhwFyCeQPJGITT48aNs9YsOASG4mAxbdo0a2uJOPbpp58O0gFQYichhEgO90fiTYyhmGtnzkfgohtCkR2C4EGDBmUZeybWIGGHEELkjh22KNMtijgE4XMaTCJASdWViD8vvfSSu+mmmyzwSjCW/e6FDlindu7c2VWrVs3FEYLwBF9pz/PDDz8kArFZwWdCC06HxJ133pmtM0MUbJWpLgsBL+wIqcUECdsOHTpYRWmnTp3seTL4zODBg10oEFSZPn26W7lypYkamjZtGvt+6f4cANxKvJCDhQRViDBGoGrIO7WQuKN1FS0IEPqE0HqANixY6V933XXZXiNE/MHd7tZbb7VgNAlthG5RR6tKlSq522+/3YWQvB0yZIgJxf14GvfHU0891UQecXZ2og0ViQiE8p9//nm2hRRsh7iKg7NqU4SQAbcGzgnuEbSoinsS38NxcMUVV5gwlnkDx4d3OsO1IxSHH85/2tgdeuih5gCXOcaEowdC6hBiLoidELhEYSzJeUIrAiGECJEbbrjBXDuSEUIsClcvBNGMoSkYwOkJMct3333nDjvsMNe+fXvXqlWrVK+mEEIUSZThFkWeUHobi+0PusGll15qwehPPvnEXXvtte7cc8+1QSQB6biCWCP63CujsYelNQ3VRVTjxrkaXQiREQKuCNuoHPHPkxFtWxMCtOQhwECLLkQOFStWdKFAwpZkxNy5c20hsZ+ZsWPHmsV43OEeGU3SNmvWzJaQwKmEY2Dy5MnmYBLCfhdZw3jRJ2s3b95s4+gQQeTHsnbtWvfGG2+Yw9PMmTOtFQcLbZxo04IQCmFgnEDQggCQuRM90kNnwYIF5szAtZHigRDEflnBecBcEmHH999/b9cJRKGIHEhSIZCMa/FEFC9koAo55Dk1ldZcH0IWOwkhRFbgiglevJDZ0SqEeRbOZog6EEGOHj3atgMOqXfffbfFGGgRLIQQIndI2CGKPKeddlqi6nRbTJo0KQirM/EPKKAJLhBswLmD9gMMIBlMhpCwoQKdqqr//Oc/lsAj+EI/aKrqBg4caMFoEV/o+3zZZZfl6LNxttinMiBq/ejNykhWRdvRAEHIOAbrCbKTkOI6wL7meTL4TCgQYHjwwQfdL7/8knjt4IMPNrcbqkviDucAlfnZkZ3rU5yYPXu2GzBggFu+fLklbKKmhrjYDB061MUdXEoYKy1evNgET1TaRquQEchitS/CEM4/8cQTSd8PrQqb4DvHftmyZe27v/LKK/Y6YnEEHtxTmWeGUKEfKjhVsN9ZEPRwPJCgOOCAA1xILF26NMN9E6655hr33HPPmXsDxRUhCDtw7Xnsscfc+++/H7SwA6i67tGjR6pXQwgh0gpiCowTac3FdTL0uDyOHbvssovlb44//ngbPw8bNsxiMUIIIbYfCTtEkYeq4+wqj6Nk1dNNxBMCr1ErUJTCBKjffPNNew1r4RAgSUW7IiAQiaijcuXKbsmSJWa3LmFHvCGBn1mwgR0iQUiSuSTumGBFz5c40qRJkywFgLweiiUmFXSHHHJI4ufo81AhIeFbCWCtj1sH1YacG7SroUVL3CqwPaNGjcpxG7sQqokQuNCiLdl4MrMALK4wVkIQCghbMm8PRHIiDLhnkKQ98cQT3RlnnBFs2z6ukzh0cD+gNRPOTl4A2bhxYxMA0q6F9z744ANzMYgbfK8999xzm+29Mleixg3mTz179jRbdRxsEMjTN57vjosHc6q4bwPwYwcEkIgAuTawbRAFhhRvYVzAd7/nnntMJIzgKyoMf/zxx2MtmvfV6O3atcvyPbYF9xHcQ8877zxraSeEECHBmIF2ZSNHjnQ333xzMC3ronAPwBXTgzvmfffd51avXh1UXF4IIQoCCTtEkQf3hZxWk4aQnBD/o2nTpm7w4MGJwMLpp5/uHn74YfuZoFvdunWD2FTz589PPP/oo48sMEtFFc4lVCVTfRZCEFL8j+eff95sD31yjspSKus4DnhdhFNxSiLq22+/tWOBYPSRRx5pdutxblOVmXfeecceSczRfoJr4caNGy1Bg8ADARQVNnFEwp6MIIBExECytn///lZ9Gw1CkZwIAQRN2SVf4ih6E1nD2AAHl08//TS218GccO+991pFoZ9P1K5d27YH1frenYN7Z8eOHa1dSxy58cYbt/mZuIpioyBcIEHD8vnnn5vAg7ZV06dPtwWxNA6JIVQgw8svv2zHfNWqVROijpDGF6+++moiBuVbwGbVqiXOIGzB6RBxbFbfFxEQDi+44HF9iKPwTQghorRo0SLDeJDrIwUVxGCJxUYFgBMnTox9joLvx7iZuJNv+8k4yjtjNmzYMMVrKIQQRRcJO0QsFKBRmFRSbcgAygfleT5v3jwbRMgiNwwYNL/wwguJKn2CkgQefvzxR0vaYaEbAhz7QOCJ6rIqVaqYUpzzgPck7AgHkjO9e/e2fY9DB72wPUw0mWBVqFDBxVXQIgGgs+sfrZmi+94zd+5c9+yzz1qrBfrAhoBvOROtNN5jjz2skgRhR2itBkIGtxbujVwbTzrpJBcqONewCEHylvaVq1atMiFwqK0GcB/gusAcknaGyRzOEHzEVRjJnGlbji2hObpwz6BdEQl9bNYZY/o5VwhtcHGjwP2RBFW0BUfFihWtBWoIPPDAA+73339P+n4IY0ja1N1yyy02v+TRt0jmmGBcff/995tjKjEZXI8k7BBCxB1EHVk5xZKnwD05xHanFJAtXLjQnterV8899NBD5qTN2BlHJyGEELlDwg4RO3eCDh06JLXSZjIpYUc4+IAK6mACs/RB9lCVTQIv7tD3mYAj7iUkKlGQR8UvOh/CAZtwzgOETQQiMyf3Fy1aFFthR2j9z7OzA2W/I3LDWp8APIFXrOWxmsehgh6nBOVx9Yk7VI8MHz7cvfXWW+7CCy+0nq9cL9kOtCgKYRuI/0EC+6abbjJrWNxsTjjhhGA2Dec84r7rr7/eWrHwPBl8BncCEX8QAnLvZGzQvHlzq7Zm3OwT+AiFSdqF4GJz6623bvNzcRZE4o4ZdzeOnEAChrY0OHW88cYbCftwRB5nn322LSHA3HH8+PF2rzzssMNMDAu4YXIeRKuR4wwOLYDwjdZ+2MpfeumllrjzriYhJDARdeDS4luyUJ3dpUsXd9VVV7kxY8ZY7AFhByJBIYSIO2p3ujUU3B5xxBEWZ8HJCacvFuDeUKpUqULfT0IIEQck7BCxYtCgQSbqIPCIvXzp0qUTk0ispZXEDgeqpq6++mr37rvvZtvvMO6QgCHYxASDpGVU2EFiV4SDD0BzfYxWmHkhXJx7YvsKspwwadIkS/LGDb4/ggUYMmTIVqIFRJFcFwnWY68dV1EDlYO0ovGQpJwzZ45r0KCBJa5WrFhhFTWIXnAxCSnBHxoLFiywxEMUbGE5F7CV557pqV69ulUox/XewH2A+4J/nozsqpNFvEDwh6jDQ9LS98OGEMTRgMjvnnvusbYLGzZs2Gqs1KtXr2zbF4n4wJgA1zPA4YmCEeZZjB+irbviDkkZ7pEIvqL3hRNPPDEhgAnBwQXXS8bN0TEllccIhWk94rdHnCFJx3ZAzELszY+beB1wC917770zuOQJIUScibYjQ9TGtRHhp78+cg996qmnTATJnDMEiD0NGDAgy5ZdderUSbQ8FEIIsX1I2CFiBRUT8Mwzz7h+/fpZlRW0adPGKpSjQXoRb0hOelEH+z3a+xc4HkIA22gETVjfEYD0E43TTz/dXXPNNalePVGI1KpVyw0bNsyqp6guBBL9M2bMsOe+4i6OkKjMLlkZJa4Cl++//94esdNPJtpAAMO10/dAjSOIPZctW7bV67/88ostHpxN4rwdxP+SMskEX5s2bbLFk9PrR1GEytqLL77YqmwJuPE8GXHvAy3+gco62nMlIxRhB0JH5pXJ8D3CRRiUK1fOnO9wgYyjCDgn9OnTJ9trAw4OiBviDm6YiDqoOv7yyy8TAnqELbRpCUHYwZyCGAvOHa1bt3bHH3+8PUcI50U/xOS8y5MQQoQA9wHGh7QcYa558sknmyDUXxcpFqAQ8aKLLoq96A0HQO4DbI9ixYqZa3RUDBtC2zIhhCgoJOwQsYSqW6zkqRJgsERiG1Vsx44dzXZexJ8ffvjBHgm8UWkXUiVVZpo0aWJLFCqMRFhwDCDumTJlik2wgBYUQLUpwbk424jntIdpXBOXvkKCyXQyfGCBhHdcwSbbV5lui1CstEPlyCOPNIeenBBnYTDXvOh1j+fr16834d8333xjdvO4FpQtWzal6ykKF+ZOXgSIu83nn39ur9FuIaQgrBcCNmrUyN1yyy1bCVriHJCn3Qhi16gYnuQ182vcWxo3bmxji1AcMRFAv/7666lejbSG+0cox4M/FmjV1Llz54SwA7heRh0s4grXhrvuusucixBER9t84nRG7O3KK6+0OaZv1SKEEHGH1pXROWbDhg23+gxCjxBi1CtXrjRRB+0dJ06cGIwwXAghCgMJO0SsIAmDjboPvlBRQuCJKlysznKa2BNFH+zzsXzDCjaEAXMyUIj37dvXffjhh6YKz1xZSFAq1Iqz0OAa+Mgjj9g+nz59uk2ySpYs6Zo2bRr7dhMHHXRQhp9JRPD9OSf89YHn8+bNc2eeeWYsg9LRcz9ZOwUv/ohzBTLJ6cwJapLYWVnsxz0gHzokZDML2hgnkrTErQURVKVKlew6GRLPP/+8u/vuuy0pBVwPv/jiCxN88boIB66NXbt2dTNnzsyQyKPNQLS1X5zxbmZcKw488EAXEpnvgbQ8ZW7lrw3vvfeeOfzgTuB7pceN+fPnm1V6zZo1zQk0O9t0PoOLQ9y5+eab3U033ZT4mXsD903EDbTBxRUytBaX0TGEd3+LqwNgVm5/iACZXzJ2YmzFuXDSSSeZ29nw4cPNNbJ48eKpXlUhhCgUELVNnjw5aUwFUcdll10WRNEpDoCMDbg/xlkMLYQQqUDCDhErLrnkEjdr1ix7TkUZyasnn3zSfj7mmGOUpAkIAgy33Xabu/32293GjRtdxYoVE/Z3cOyxx7pq1aq5uHP//fdn6P2bmVCCTuIfEHKwhIoP0idrrYCrSRyFHdEe8VTRif8F5a+++mpLToVsJy7+x6effupuvPFGt3Tp0q0Cb927dzdxXAjbgOOeayACqGj17XPPPWfj7AoVKqR0HUXhgUMFog4CsYyZEct/9dVXrkePHu7QQw8115u406xZM3f55ZdbOxYSkxz/0fkE4q8Q3GxovTFw4EATuhGc985eiH+o2KfNXxxB8Mp4EfGnf54MPhMCWKmzeDgv6tWrZ86AL730krV4pCVH3MEd9rvvvrNCIsThgMiJ54cffvhWbWDjyOLFi93IkSNN6Md4OXMxDQ4uxFyEECIkGBvOmTPHYm5r1qwx4Zt3R+Q6yX0zlOJDvuvQoUPtHkHLLgrKok5wOHmEIhYXQoj8RsIOESsYJIwfP94C0qhfGUBQWUTVJTaQIiyniv/85z/2/LXXXrMlcyuSEIQdJLEB+9PzzjtvK3FTXNtOiK2hYgCh2wsvvGCB6cyiHhKaTLbiDhWnfH8q7Kg6pYJg1apViZY0cRZ1iIxwLnhRB9fGzEF4OXaEw59//mnV2CRpCDaRsOY6gbCBCmyCThdccIGLO1OnTrV7wznnnGPi6KiwAxYtWiRhRyAQiOZ4QMRAOzMq7hhHUK3PXItEfggOLlTfL1y40M6HRx99NFgBIPdLLxjHYpx5lge3M4Qecaw8Za5IC0PETXvvvbc9T0YolajcI6JzCJ7T4pHjINoONe4g+Jw9e3YGcTDFFFwzEb+FIpDm2sCC6Av3DhxbQhD9CSFEdjCfxCXXO8V+//33wTjFZoYYJPNqFgSBUerUqSNhhxBC5BIJO0TsIPDoOeyww6wNhQgPKku//vprG1DTAzqqCvYq6hDwE4WLLrrIWhWJcHnrrbfcQw89lPR9X30Zd5YvX26PVN/269fPkrnQpk0bu07ENZnvkxM5IZTkBAEWOPfcc621QCiVM2JrEDB4UceECRMSFfgPPvigCYTfeOONIIQdUWv5aMsmX6Uul69w4HxAyIFDhZ9b4VrTvHlzE3ZguR8CiFpoZ8j9oXLlylsJAEuVKuVCYN26dfYYbUfD8YFAlkeuF3EUdlBpesghhyR+jj73IGR48cUXXZkyZVzLli1d3EHQhYNLTmIxcW/zOGnSJDdq1ChLVHEu4GR0/vnnZ3mcxBGcSWjXhQhwyZIlVlTDwnZA4MFSrly5VK+mEEKkhNCdYmHZsmU2twbcvCiWiLpgcr8QQgiROyTsELGC6iGEHATgUMFm7mmHBdp+++2XsvUThVt9C1ioY7UfKlQRUjU0evRod91112WwzhVh4d1bqlSp4u644w63zz77ZJhUUYkYEvvvv7/ZKNMXHOETk+qnnnrKeqKGkJwQ/3P5IgC94447StQROF7MxDkSbatAFRHCjrgH3Ty1atVyw4YNMzcGkpTw/vvvm7U+1KhRI8VrKAoLP19CwEFA2o8RcK+AEiVKBLEz1q5da4/t27d31157rQsVWloihuR6SPUpkNzftGmTBekRg4UsghowYIBdP0MQdiSDawRti0Jq94fQi2tDqOy1116uc+fOtnCvQOCBiJw55yOPPGJL+fLlLR6BgF4IIUJCTrH/xOURfeKoLoQQIv9Qhk/ECuxhscBMhioNwwH18+OPP+4++uij2NoD54Q333zTvjuJmhEjRljgNVqVPnHiRLVjCQSfmDz11FODCrpmBueaFStWJJKU9MZevXq12a0jdKF3vAgDesLfcsst7q677nIbNmywynQstD3HHXecq1q1akrXURQOOLxxXaTilMQ1DjdUoOP+xT2UZFUINGnSxMZPJGaw1vduT75VFQkaEQY4M3AecD7Qyu/kk0+2tmV+nsVYIgQaNGhggWiS9yGDSH7WrFlu3LhxideeeOIJe6RiX4QDBQMUC0ShcAABcdxp2LBhhjZE2fHuu+8GI4Dz7kWIY5lnLV26NOEAhlMiBQUcH2effXaqV1MIIQqNUJ1iMztl48rxzTffmAAwWkAhhBAib0jYIWJZkd6uXTsLQmYeKO27774pWjNR2HzxxRdWQUYQ8qSTTrIANVXZHir0QwhKz507N9Figwo7X3noURI7HOjhSX/LyZMnu3POOSfY6+Ell1xi1wWoW7euJW/ZLnDMMccEMcEW/4Mk5fDhw+05dtqZIeAiYUcYYBOLyxv3ScaPjB9oPUA1OteEaBKL3vEPP/ywiwvvvPOOiT6pNkfcRoUtDnf0haYndMmSJV3Tpk3N4UaExb333mvOd1999ZU5NXhatWplIqAQQAxNEBpBC+IOgtNRgXSLFi1MJBh3uO4hBn/ssccytJ1gzo34RYQDYkcWElYUUCB0YJ6NGJb7RZxh3pyTuTPuJVFXxLhCjGHatGnutddec2+//baNmfz4+ayzzrJWLIwjqFqn2ETCDiFEiITmFBuF9uiMDb788ku7J1AkEBWC4ibcu3fvlK6jEEIUVSTsELGsSGewRLWACJc5c+YkqvIJOGWuriFJEQL0/fX2d1kRanI/RAi6YRlMQL5+/fpmnxttzYPFeAgBN5KT48ePt/sFE2kqcUlY7bnnnu7KK69M9eqJQoTKYypHOC8aNWpkgejMvcNFGKxfvz7RYoKkjR8/AAlMqow8cavApaqYlgok5po3b25BN8ZIoYyTRHJwMULQQEL/s88+s/smyVvGEKGAyIn7hBdLs0SpXLlyEMKO2bNnWxKXynufhGB+gaMP48tmzZqlehVFIbukIoyNihwYQ/Xs2dO1bt061tcD7wDLOYGTDQUkzKFo6UZ7PyqzETyF0P53wYIFrkuXLvYcwRv3BgoJGD9EhfK0/3z66adTuKZCCFH4yCn2f4U0vqhq8+bNJm6JolbhQgiReyTsELGC/p3Yg44ePdqqKzVICBcqbrMLPBOsDgEsUYGqKgJQtJy49NJL3Zo1ayR+CgzU8lRNAZXpP//8c4b3SV6GAj0+oy0Y+vbtm9L1EakBdwa44oorEtaoIkxIzj7//PM5+ixCoDhx0EEHWQsi3AgQubEwRjrttNNM5CGhdNggeqQNT6jQggbRUzJq167tQqBbt24mkn/vvfes8hRwQrzppptM8IE4Mo5Vp4wTMo+XsxIGhgRiHiqNvdMd4+hFixZZsub22293derUceXKlXNxLiICtgHiJmJOuNcAwhZEw4gYvOAh7lB93bJlS3fGGWe40qVLZ/kZrqFxFvwIIURWyCnWuYoVKyZa9yVzuBJCCJE7dthCdkeImMAEGjtIAkwEqbGWjtrlUnEmh4IwmDFjhrWcINCAvXiocC4QZPI90YGgLM4Md955pzvxxBNTun6i8CAgn13wmUA9CZw4QoKS70+7DRydsuuPzWdCqLITzi1ZssRaClBtPXjw4FgmpYTICRs2bDCbdKqR33///UQLN6hevboJPGhfF3eb/dBB/PvGG2/k6LOMGUJpx+LxlfrMLUn44+RDKCXOYvFbb73V5lQIv3BniLa2pJXdjz/+aNsDp8Q4trJDFJ9TYRPzTYpL4s59993nhg0bZmPrhx56yF7jPCBxj4PD3Xff7c4991wXd3Dq+P77700M2bBhQ3uN86Rx48a2PTh2iEXFGZycED4h5smqLS4iF4quhBAiVD799FMrtmOMxHUx6hQbQm7i119/tXg090wEgNH8jBBCiLwhxw4RK7DH9cFoAm5r167N8H5OeqKKeDBz5kw3duxYs/4MWdhBshJRR9WqVa2vIQNrfy488MADEnYEBO0D4tZCIKcQdGQhKeOfbytxI+IP18QDDjjAffDBBxZswLkgGmzA3eiUU05J6TqKgmP+/PmuQ4cOOfpszZo17X4aVwgwnnXWWbb88ssvVpGNyAMhKIk6lnvvvdfs91u0aJHq1RUF6OxFxX1OYGwdgrCDMUGvXr3sfNi0adNW79MXPM7CDpL3zKc8JK6zcjWJo6hDZA1za6hUqVLitR122MFcOrhXlCpVKohNV61aNRN24NhBsoqiIq4TiDpwMYm7qMOLQi+++GKrSu/evbsJpPn+I0aMcP369XNVqlRJ9SoKIUTKnWIRAiOEIwZLfAEXi1D4/PPPrWUfjxRdCiGEyD8k7BCxYtSoUWaJmYwQFLHinyQMQSYSNyQpotapIUGAyVfcde7cOSHsAAbXtN9QMDa+PPjgg+65555z119/vSVseJ4MPhPXCjuSEkykuQf458nQfSIcqKb0SSpcXDI7uZDQEvElJxb70eRFKDBeIkmF2GnChAnu4Ycfdhs3brQEd2gtB0IDRxZaGSY7XwjM+nFk3FoSJWPKlClu/PjxWb6HaJo2BHGmbt267sUXX7REBNfLoUOHJmyzEUJyvfBtH+PIUUcd5T766KMcfdY7mcQd7g+0IeG8aNq0qStbtqz78MMPze2nQYMG7vjjj3chwLyJFjSMI0eOHJnBzQghZAggXuG4x8EFIegNN9xg14hZs2bZ+3EWvQkhxLbYvHmzxWGZT0XN8mkZzn0iBCEkok/iaz/88IM5liB8FEIIkT9I2CFihQ8sLV++3BI2WAoTiFqzZo16hAcGCToCK9gHY7NPsBoBA2IPaN++vTvzzDNd3PEB+GjVEEltxC4gd4L4738C8dhl++fJ4DNxBScGD4FoqupoR6S2AmFzwQUXZJuAOPzwwwt1fUThV9uStM0JO++8swsBHAlw66Al1fTp0y2Z7yF5F/ckdugcfPDB1qYvM7Tpof0C4wjG0ldccYUtIbB48WJ7RPBCMJo5JS0nuH/ggsYcI+5Qdf/CCy/Y/MGPpxB1MKdCIM5cC0F9HIXiJK3j2qYwtzz//POWoPrqq69M2MFx4BNWJPepTo462lx44YUpXNuCvV4idnv11VetWII59aGHHmqi4FCEb7i2cDzcfPPN7pNPPrH4CpDE4zU5fAkhQoZ2ZS+//LI9P/LII20+SeEhbqE33XSTGz58uIs7K1euNIdU7hG09fTtn71LKvPxvn37pno1hRCiSCJhh4gVtGGhfxutJzwE4ggoEKg88cQTU7p+ovDA6m7VqlX2nMREZuvgdevWBbE7qDTju/fp08cU40ALFp6TtAwl8BQqXbp0MYtcAmycBzwP3amCiolvv/3WNWrUSMKOwOEaKPFGuBQvXjxHleYkcmn1F9eqKhKz77zzjps8ebKbNm1aYqwABN8Iwp1++umuRo0aKV1PUfgsW7bMxo8EoIHjgIrs0qVLB7M7fItP7hWMqXGwQeSEKBChKNvmuOOOc3GHpDUtJ+gVHxV8eUjox1HYIbaGVrdR96ZoFXJo0HqEFmYhg9iLhCVJOw8iUMReQggRMojlAdeOtm3b2nNaluGSiyg2BGdp4u7R+wPFtyyZ27sJIYTYfiTsELGC/ueIOrDG/fLLLxNuBVQYkcyWsCMcLrroIqsiSgZB2RCg3y3uNQRcPZwjOBb06NEjpesmCh7EGlHBRijijewgMYOwg8k0/U29i48Ij/79+ye12IdrrrnGtWrVqlDXSaRPEpP7JpWoBOWoJmrSpImLa8uuqI38Xnvt5U4++WRL4tOGwVdUiXDA3euRRx5xY8aMsRaXHP+9evWy+2doeBELYwWq02m9MHXqVPfxxx/b6z/++KMLAQQtCxcuzDKxjaW4RB3hcOONN9r4KHS3K9xBqTKmDQ2CyMwCF9qh7rfffi7OMJ/CvYgkHfsap1ziDLQvwq2Dgqtk7b2EECLu+LFR1CG0evXqbtddd7UcBWOoEFzfnn322aTvR52lhRBCbB8SdohYwQTaK2I7d+6cEHYAFplUJSrwFAYIN1gItNDnleDLgQce6I455phgeiD7Khos1UeNGmV20pwD2MSef/75se6JLf5J2D333HM57hVN9UDcIfDKNYBg7KOPPmpBV4ROnhEjRqhyIBA2bNiQbVIuOoYQYUD/X1oOsHz//fcZxA5xviYSYDzppJPMQp7gYwiBRrE1BJlHjx5tog7EHTi2XHvttVaRHqoIslmzZjZWAMYKtF7BDQ0QPYXiZONb0gwbNswNGjTIxOG04sDBBdFb3CtORcbWTIgeqT6Oq+AxJ9x///0ZXGIzE0K7U8bQiDpw7GB74NTRoUMHa92FMPCll16SsEMIESxnnHGGxeO4Fnbt2tVeY45JjOGqq64KYr6FcOPoo4+25/PmzXPLly+3ViwUD6jVnRBC5A0JO0Ss8EmYqOqTICUWZ6FMsMU/UE3XrVu3DFZvWCkTkAxJ1EDChkkFDibRaqKvv/7ahB8hCV1CvCaSnMkJv//+uwsBnDq4L8DGjRttiUJ1sgiDjh07msgtarlP8orWbQQb2rRpk9L1E4UDbQXefvttE8Hh0uHHinvvvbcdAySucIKLKyTnEPYxVhBhQ8uhu+66K8O4oF+/frZkhorDxx9/3IXg2EGC0s8l77jjDhtD0O6R6wOJzNBa0tSuXdtasrRu3dq2B0kL3K00nwgDxkm0IKJYImRhx/z58+2xXbt2Jl7IXDwUgktisWLFXKdOnaygiufAWILrwimnnGIJTCGECJUlS5aYKJj487hx4+w1H5tGGPjqq68mPjt27NjY3jeIR1599dXmcOVBEMyco3nz5ildNyGEKMpI2CFiBRbB3333nfWD9j3CacHCcwJRu+22W6pXURRiLz9U0PQApuLwsMMOc0uXLrV+4bw+YcKERAAiztDDEXU4VchZQRKL7SPiCVWlF198cY4+G9eJZGZIRPkERVaQzBVhULJkSVuiUHWIyxPBFsSBJC5EPGF88OSTT1oVFa5ewPFAX/gpU6bYuAFxaNyZPn16wvFuW2CzTrJGhONqlIycikaLOl988YWJOLge+DECDh6IYKg6RBwago00AhdcjHBuwaVk6NChlqzYtGmTicaZa2ueHQa0tsXdDucO7gc4QYYo6vEuNbR/Pfjgg12IMF5iyYrjjjvOHI6EECJUiClQQADRYkPfyiqKLzyKI7TlQtRByy6E4bg9UWSI6xtjiMqVK6d6FYUQokgS/6ymCIru3bu72bNnW7LaQ3KGwBOWsSIcJk+ebEkb+oLTO55BJEFo7KQJxFK1H+11GFewRfWiDqzkoy0nIMRAXEgg1sgs2GAi5V0qCNDjUMHEcp999rEqzLjDZBK4DnC/YJJNsnLNmjXBBmbFP5Cc+vLLL+05jxJ2xBeEnj45efrpp7uWLVtaImLOnDkm7AiFb775xr5zTqBVi4j3/XHatGk5+mwI9tHAHILe4L1793YXXnhh4nVa1rz88ssmZjj11FNd3DnnnHMS1wmStcyr/dy6UqVKEnUEBKJX3CkWLVqUuCdwH/Xtmm6++WZ3wQUXuLjD9YBzgGvBddddF0TBSGZwbiHW5lselyhRwsbNuOEx/1ScQQgRMk899VRC2LEtiMXFEWKPb731ls0baONGwS2C4JtuusnG0bji4fIkhBBi+wlv9iFiDW0lJk2a5EaNGmU2oUwwUYAyuQyp9YZw5twCjRs3NlGHr7IjaYPdemaFdFyhug6oSj7hhBNSvToixQnrSy65xKpMs4KkRQjCDtw6qBqI9sXGQpkALS04qEQUYTBw4EBza/DQggNBoG/rVrZs2RSunSgsCLiRlPjss89cxYoVg9vwJOByKnQlGCfiC0FXnBmEc1OnTjVxNA6AgEvH008/bc8JSHvRdE4D9kWds88+28QbJPRxKnjsscfcQw89ZG4lKp4ICxxsMjv2RM+DOFcdR8GxhGvmsGHDzMGEc+Ff//pX4v2JEyfG1g2R8TICnhdffDHD64yjEHtwreSaKXG0ECJkjjjiCHtkzIgokoIqRNTeBS6keDRzbD+PRAhKCxaEHStWrEjxGgohRNFFwg4ROwg6tW/ffqvXqc4+4IAD1EM8EPbbbz97XLhwYYYgxCeffGLPQ2k/ctJJJ1m1YSiVlSI59PBE1EFFGf2Pqa4j+EpwtlGjRtbKKgQGDx5soo6qVauaI4NP4rMtaN0lYUc4cOx7EWAUgg2tWrWShXTMwT6cnsf0gH/33Xctifvggw+68uXLu5AgyJaVYIMxE5CoImmHs4dvcyjiyfz5812HDh1yfP5wP40riKHp/e0dzhB4eJGHh+r0+vXruxDA4WzPPfdMzCfq1Klj8wuqMHE/Cu26GTLXXnuttTXdVouSuMOcyrd25B65du3aDO/HWeAyZMiQhKiDohkKA9jvFM7Q7pbxNe1AcVCNq7hFCCFyAiI3WgEj6oiKZSkoCsHpycflmUfS4pGxZDROz1haCCFE7thhCyUnQhRx6M82fvx4qyChwpbqaz+A4BCniqJfv37ujTfeCCahHzoMHLFGZgBNJWqVKlWsrx9BGAaT77zzThC2wb///rvr1KmTW7BggbWhIbgSrSbCpYAkv4g/JC2xg+zYsaO5GxGI79q1q00sqcAcN25cEAIgWi7w3ceOHes6d+7sfvrpJ2vfRRsGns+bN8+2h4g/WINmDsRjG12yZElzeBLhwLlP1RBjSdw7/LFAsgKxF+5f5cqVc3EHMUevXr3c66+/7jZt2rTV+5nbUYj4Je/btm2bo8/WqlXLWhDEGaoIEXuRnLz88ssTLVcQ/xGMp+IyhHGTT9768ZKfSzPH5jgguc38KpRtIf6pwsXZhlaGxF+aNWtmrhUhxZ+iibrMMGaIYysSxgnHHnusiTdwQMQNMgrjalo3IZymRU1OxYJCCBE3KCbiOgiVK1c2J2lE1FxHEUhec801LgQomKHAkvviySef7FauXGlFZ2wHROIqrBJCiNwRf3mgiD30+73sssus7YoHIQf920jgM5DKab9oER8OPvhgS0BQbTd9+nRbgKDjPffcE4SoAzj2Z82aZZVE3kI6CmIPCTvCgoA87hy0oKC6isSlr1hv0qSJizveoSMafKaq7pdffslQpS7iT6lSpWwRgmohErcsBNy4JtLaD0EoC8LguCexYcqUKSZuyQpcjlSVH2+qVatmx0BO8G0O4wwi2FtvvdV1797dhNEhJa09fP8ZM2Yk3EoonvDJasTjjKkQjMfZnUBknawiqe8dK4DWPCRosJkPgWRtfolJMZeIFlLECdwOEXVwTbz44ou3ep/Xr7zySrt2IJYXQohQGTNmjD0i4PBOV2+//bYVWjGv7Natm4mF4869995rOZuvvvrKHJ88rVu3lqhDCCHygIQdosjDwIAJNMlKnBlIYlMhMHToUHNtoLKI4COV6d7FQ8QTErNUmPpE3fnnn++OPvpoS85QZVamTBnr5YfoIxQeeeQRE3UceuihVlWX2e5PzgThED3uqTKlKp0ALJNLyKo6O44gauEe0adPn0RbAVqw8Jx2BKGIvkKuSMexJSdw/8iqRYWINzVq1LCF/vEkuRF5ZFeVGycWL16cSN5yn6ASm6DbBRdcYOKXevXqpXoVRQFSvHjxrZKVjK1Xr15tiXuCz7g0kNTDch9xcNxhDoGwKxk42MRZFHvaaaeZw5knq/ZlVF9qPhEOONn06NHD5pfcKytVqmRjqy+++MLab3DfjKvwq127diZyoohon332MbdDxE3cM/05wPUgs7tNnPDzRdztkiUkS5cubY9eNC+EECHix0yMpaKtsimsYyxNa5K99trLxdXV6sADD7T4c8WKFc2hg1ZdxCARSuMEh/uTEEKI3CNhhyjyEESAgQMHWuIaa3X6IhOEIghJwIGkXbKqChEfqDLFjQMRD4GUN9980xIS/BwqBN1g0KBBqrQNHCzEn3zySXtOFRkTTKrrgABs3bp1XQhQeUsAmoBrtPJwp512skC1iH+S7tlnn83RZ3F9krAjXLgunnHGGbYQeAsBX33NcY8I7uGHHzaLfYTTjLE++OADC8SJMKAnOALhrNwYmHOFIOxgnoljRTLiLOoAxoYvvviiu/TSSy0JQeGEb1XGWBLnN82xw+K1116z+SXxFj+v4N7BvRI3h5kzZ8a2ApfrAaINL/YcMGCA/cycKhRxky+UImmHcINrQGa8U0cchS1CCJFTcDCibdnChQsTRVbLly83QSDzzLg6wf3www/ulFNOMbfHvn37WswRcYdvSyOEECJ/kLBDxKZqALtcwK0B1SvBpzp16pijR1yrRkRG6NXnAw24tbzzzjtWRUQvv8xQeRpXdXTmZP5jjz3m3n//fQk7AofjncQcvY8BEQPBuFWrVrlzzz03UV0Vd7hXkNwfNWqUVafj+ISjDQ4/Sk7EH1w4krkvEISgJZFH7i3CQ2u/EPD3AapwGT8tWrTITZ061X388cf2OuJpEQYk7BAFI+qgMp0gNGNnqg8ZV9MvOwQYHzGf9JDAZuwwfPhwEzmdfvrpLu5UqVLFtW/f3ubTCHp0bwwbhAxwzDHHJF6j1SliQIQdzCtEfKECm/kS8Rba8dx9990ZYipvvfWWe+qpp+w5olAhhAiVZs2a2VwKF0haeyIAnDhxor2H8CGuLbuIqQA5GVqcEpfHBRJRS2bYJjhrCyGE2H4k7BBFHiyBIWoF6dtN3HjjjRJ1BIQX97z88suJ12g1wZIZAhGXXHKJC0H4RC9snEzo40jgJXquUI3pK+9EvKHlCnaH2Ov7IOy1115rSQoSFNiqt2zZ0sUd2iog5sA+3VfXkegnCMm50aFDh1SvoihAaMfFEoXjARGov3eQtET4hFWqEKEFIB999FF7josRrVew1geCj7jgiTAgaUdVPhWGzz//vGvRooUl7Ki8Qxh5xBFHuBCoXLmyLVFwJmD7sD0IXocwjsYJE9F8tWrVdB0InAMOOMAep0+f7i677DKbZyL8+uijjxKJfxFvrr/+enf11Vdb2x2KR6jEpvKca8RXX32VEIRF2w8IIURoEG/m3jht2jQ3ZsyYxOvEGshVxBXGAcTVEIPjgAq4lmSOwQDiadqbCSGE2H4k7BCxYfPmzQn3Di/2IIntXwN62SXrBSqKPlQPMnDG/pP+tyTrqCrLyhqVYyEE6GXoLbR926KsWrWI+EMAluT1E088kag+x7niwQcfzDDpiiucB9wbsIKk2pCe8CQu4ffffzeRE/eRiy66SILAgKAND+3acHwiKN2tWzfroe6PDSFCAscOAo+4NcAdd9xh104qsNu0aSPnrwDxDncsOLY0bNjQxKDDhg2zVj0hwljCzy+pxMws/IgjVOiTtF29enWqV0WkgQCwf//+btasWSb4onUXFbmInEjmhNLaMWSoNKdN12233WZOkHPnzt0qUcd8S2NpIUTIcA2kyBAhMG3K/v77bxszInCIczwaF3WKZCgsxLWDhW2RlWN2CC7aQghRUEjYIWJDVj2OSdxFee+999TrM8ZgEeyDzDhUPPPMM65r165BOHMkg4QlSetkaCAd1vmBnX7btm3NqYNJpg/E4eTRoEEDF/fqMoQsHpJTmWHCGVdLTJERqka4T3AOsM9bt27tunfvbr1whQgVBKCIOLyzE04EOHhwnmCfu3Hjxtj2gxYZIUFLJb4Ht5b777/fgrNAhX4IPPvssxaQj4o6OEeWLVtmP++3334uBCpUqOA++OADq9KnZzqCH5zfPLRjCKVlVeiQsEEUfsMNN9h9wVurcy4wD/fOqSEUFPlioqwKjEIQd9SvX99aGDJ24J7AGJoWPVF3L7YL71Ns48cWQggRChSWNm7c2JaQIAbPggiUwinatcmZQwgh8pf4z7qEEEFC0paKU2xAQ4aAixCAyAlnjtdee8117NjRXqtUqZK77rrr3AknnBD7jcR3njx5ctKAK6IOLKWjiQoRP6g2porwxRdftGOBqsJevXoF01ZAiOwYOXKkJbJxcKJdlYeKK1oVkZg59dRTtREDAFHPOeeckxAwnHnmmRaYpdowmTgyjpC0pjAgK44++mh3/PHHuxCgJ7x3AEQYmZm4u76JjJCgQvD0zjvvuDVr1rgyZcrYNYF7RIgFRVkVGIXA7rvvnqW1fpQlS5ZYUUGtWrVsLCGEEHGGFlS4w+YEio7iLhAmHs898sQTT7Q5hIqohBAi/5CwQxR56PvsA03bQpW44TB79mw3fvx4V7JkSUvchTiZYKJAED67iUUIkwnxj2MH1skktZ988kkTMmCzj3o+BBCxzJkzxzVt2tSC0K+//nrinsAEs3jx4ppoBgAtd7g3eKgivPzyy7P8LM42Z599diGunRCpYerUqebGQBs7wKXj6aeftucIoLDYB7VvC4vbb789kcSnCptqfI4Vxg205gkB7gG1a9fO8BpOJrQtql69ejDjBiy1cSVIhpx8whR/tWzZMtWrIYQQQqQNvvVITvBi6Tjz5ZdfujfeeMN99dVX7txzz0316gghRKyQsEMUeQ444IAMP2/YsMFNmDDBAg1UEWAVSiVB6M4NoVGzZk2zvaPnL84dHAuhTSaYKGxrYhHCZCJkHnvsMbseZgZRBwk67BH9NbRTp07ujDPOcHGGXqZMKPn+CDlCqSwUyclO+Pbbb79p04kgwLXprrvuslYrgMDDizw8tF6QC1hYIFqIWuo3a9bMlpCg7QhL6LRo0SLxnIIKjg3mWdwn582bF0z7iZChtScC8T/++GMrh5YrrrjCWjrGvf2pCoqEEEJkx9ixY1V4GqFcuXJWTEWRAAU1asklhBD5h4QdIlZ88803FlCg3QBV2STzsVsfPny4VR9i/yXCSdbtv//+bsaMGa5evXrm3LHLLrtYEBLat29vttJxnkwwgN7WxEIuNvE/D1DJJ4PqS/8+orgQQOjy7bffukaNGtl1QYTFNddc4zp06JCjz+65554Fvj5CpAO0oBo1apSJoWlZhYuNb7nCuKlYsWIWiFOrqrCYOXOmGzBggI0T/vzzz60E1EOHDnVxhHkjrl454dJLL3WnnHKKC2GOjYvVp59+mqVzD+1qmGeJ+IIAnP3M/YB7BO1XYNq0aW769Om2UEzAOCuUgiIhhBAiykEHHZThZ8ZMK1eutLibd3njOaJY4tFxL0Dku3Pv/OSTT2xuSYyeGIvfFtWqVXN9+/ZN9WoKIUSRRMIOESuoIkHUgUWwHyBRnY31+r333ithR0B89tlnbtWqVYnBNMdFlMyVqHGdTGSeWIiwuOyyy3LswhHKscL9AWEHoq+KFSsmxF4iDAgkSLAhRNb3gNatW7tDDjnE7hvly5fXZgoYqvK7dOmScHHJzKZNm1ycRQy0bstp+8MQoA2Pb8sTBbEXTj4SdcRf5IWoA8455xxrR+ThXnH66ae7V155xT311FPWBlSFA0IIIUIH92gKSpI5KCMMjruwg7g7og7P6tWrbfHss88+KVozIYQo+kjYIWLFokWLEj2hfYCJoOSwYcOs2uzXX381K34Rfwgq4dqSjLJly7q4M3v2bDdx4kS3dOlSt379erfzzju7Qw891Gy0mzRpEkxf8NATdaEINnIKduEEpKkMwMlpv/32s9YsnhEjRmiCKYQIkg8++MANGTLEkvo33XRTqldHpBDskhF1kLi/7777rKUllfoe2pnFlQsuuMAdf/zxOfrs4Ycf7kJg8eLF9sicetCgQa5Hjx7WL/2GG26wOUXcExOh8+GHH9ojc+s77rgjw3vMM3B7+vzzz83RhSpkXPGEEEKIkGG8hKhjjz32sNZ1pUuXThQftm3bNoixE/OHZ599Nun7bBshhBC5Q8IOESt8ojrqxkArAhwbqMpWIjscEG6w0F6CCiMq9OvWrWtJXAJQca7SJ3F92223WRuWrAKzr776qjv22GPdY489JqFTzCHQ+txzz+Xos9dff705HMUdnDp8eyKSVpmrkTPbzQshRCjg1uHHziJsfKCVavzmzZu7kECsEYpgI6cg9gK2S+3atS2Bj8MPSX7Gmq1atcrg4iDihXfoOfLII7N8n3k1yRuOC90/hBBCCOeWL19um+GZZ55x/fr1s5Zm0KZNG4vDhuB2xnzi6KOPthjbRx99ZOOEvfbay9zUEY+HIG4RQoiCQsIOESsaNGhgzhzdu3e3ICRBhjfeeMP9/fffrk6dOuZYIMLhxRdfdHfeeac5tUDPnj2tJcsvv/wS6z5+48aNS4g6GDAjaGFATS9HBtIIO0huY6vcq1evVK+uKEA49pNZP2bm999/D2Jf0JrLJyiyYu+99y7U9RFCiHQBO9ySJUu6CRMmuLlz57py5cpZ0NGLYbHgb9iwYapXUxQCBx54oDvppJPc9OnT3axZs2wsGRoIpSkWoK0E5wOOBB6E4iG5ElBl+v3339u1oEaNGm7o0KHmdkbCn+3EHGO33XZL9WqKAtz/UXfUzBBr8VbrJUqU0H4QQggh/p/999/f2gFzn8RZGjEDrcs6duxo4oYQBC6IWnB6A3IzzDNuueUWK0JT/E0IIXKHhB0iVlx99dUJFWjU7osgNe1ZRDgsW7bMRAskJI444gg7Jjzjx493l1xyiatUqZKLIy+//LI9MmnISrhBL0d6PZK4kbAj3tCK6uKLL87RZ0Pph129evUsX8fZ6c033zSBS7Q1ixBChNSKxVsE43TGEoVAnAgD2vhxLFBhx3iSysJoO0vupQgl4x6EZmw0evRoa22Y2Up68ODBJqAOAURdc+bMsef16tWzViwswHxKoo54g8jr/vvvd6+//rp74oknEtcEQEA+cOBAu2aQrNJ9IjyYQ/m508KFC23scNxxx1lV9mGHHWbHDmI4IYQIiYMPPtitWLHCniOK7dOnj1u9erUVGiKU9S6ycQbxLzFJRB04d9Au3PPNN9/Y2Lpz584pXUchhCiqSNghYgWTRxSfU6dOtYoSgpEVKlRwp512miy+AoNjgIEy1sAQFXb4oENchR0//PCDPZ533nlZvn/CCSdYAJZAHK1q9txzz0JeQ1FYkJDIiWCD6yUtSZJZLMeZL774wu4bL730klu7dq21bpIlpBAiRFq0aOEqV66c9H2qzUQYMCbwFfjeAcw74EFO3cCKapLyiiuuMIcKAtHz5s1LvFeqVClXrFgxcwDs379/MMKOs88+2+YOCOYZI9HO8aGHHjJHQC/wEPEF9ybOiSeffNIcHzn2ceagzS0CMBI3wLGgMXRYIPZ5/vnn3ZAhQ0wgT4KO44FqbF5nHnrmmWemejWFEKLQoZgQ1zvA+Y4CIu6jcMwxxwTRioWCS+Jt3BO6du1qwtDMcXkhhBC5Q8IOETuwMkPIwSLC5bfffrNHRAuIFzIHon0AKq4B6Wh/9KxgEoF9cnYtKUT8kza4thB0W7x4sevdu3cwwg4sw1977TUTdESrBqg+JGEjhBAhgnDDizeoovrpp5/cQQcdZM53IiwYD0yaNCnp+3EORr/99tsm6mBOSXUlVZaMlwDHO9p90oZlyZIl5uxRvnx5FwLNmjWzeQMBeto2DR8+XG1OA+Laa6811wWcephPU3Xs4R5x4403mjhQhAPXg1tvvdVcOWDEiBE2l0LMgWvHyJEjLZEnhBAhQkEdbtEIHhlT0sYOERwx6iuvvNKFFJfPHJsOIS4vhBAFjbIXosiDgIPAM8FH1J88TwafkQ1kGPjExNixY80CD2bOnJlQTCdrxxAH/OAYxxpU4Tn5rAgHhAwIGhA2IHAAKu5CqLBDwMJ3x1IdYYunZcuWlrDANjiEPqdCCJEMHAquu+46c3KKtnC7++67zRlPhMHOO++cECwsWLDAff755zZOoOIw7scB3xVw/csqUU3SslatWu799983cUcIwg7mC7SeYfHOLQhhzz//fLteRNv0iHiCbTzVx23atDE3H+8QifivSpUqEkYHCAJQn5wj7jB37lx3+umnW+senDsyO6YKIURo0Bbcgwiub9++LiQOP/xwc3zjfuBbGuL0xXgSEE8LIYTIHRJ2iCIPk0mWv//+O/E8GXxGhAEBBRK1JK99RREVeL5FSVzbsEShmlAIWLNmjbUaQdTw5ZdfZqjIbd26tWvcuLFZKscVXElGjRqVsJUvXry4VdxOmzbNnGuuv/56t//++6d6NYUQIqWQsL3sssuszQRJW6ryEUxPmTLF3M+efvpp7aGAWL9+vVVbI4z2kMC/8847Y12Z753+sI32tG3b1tqu0OITvIuNF8jGHd+CA3zlKe3rqMhn7t2vX79Ur6IoJNj3FFBUq1bN/fLLLxZfibpjksBhnC3CqcSm/S3uRVwPq1at6vbee++gro9CCJEVjJPuv/9+N2PGDJtjZS6qo5VV3AtPmTfccsst5g7M9/VFBHDooYe6du3apXgNhRCi6CJhhyjy4MjAZJLqKf88GXxGhFNVNGDAADd16lRL3q5cudISt1SdIvoQIgSossXy8a233kq06EEVz3WSauyzzjrLhE5xh2QEyUmces455xwTdWAHiUMHwg4hhBDOvfrqqybqKFeunHvmmWdcqVKl3GeffWYV2iT3582b52rWrKlNFQgEYtnvuHeQxEUoTTC2R48eFoyNa/s2L3RdunRp4jVcObwzB4F5LxQ94IADXAggDobLL7/cxLA4veGE2b17dzd58mR3zz33qC1LIDCfuO2226w9kZ9bRCF5c+GFF6Zk3UTh4q9/iDqYb8IxxxxjokAoU6aMdokQIlhw5/Ct/EIuPMUBjxjkuHHj3Ndff23jRQSi5557rhzfhBAiD0jYIYo82H9m9VyEDYpogo4nn3yyLSGxLYFTFImd4h+IRxmPqIkJFS1HsICk2jZqsx8KJCyXLVtmriVxbsckhBC5geQMIPpD1AEVK1Y0B7CXX37Zrp8SdoTj9IU4eqeddrJxJVbSCBpuvvlm6xc+ZswYa88TRxo0aOAeeOABEy7Q8jPqgEe7gUcffdQET7SkOfroo10I+OQDrVeYXwEi2V69elnbR7V2DAfcMF944YXEzxwPFFR4os9FvEEER8EMrqgkL0nUYbtP20+Is7OTEEJsi48//tge27dvb7G4zC1/Q4jFMm7G3QlxdM+ePVO9OkIIESsk7BCxgopsVLEffvihWT+GaHUWOvS77tOnT6I/NgFXktgh9L/OSuA0cOBAC8qfffbZCdtoER7YZHNOkIgIUQD31FNPWTuWiRMnuhEjRthCRfrGjRtTvWpCCJE20GLBi+Ci+J9xOhJhwD5nHkXrEd8fnIQtyXyEHd9++62LK3xfAvB8z6uuusqqDJlH4PCFU8eKFSvsc507dw6m5QTilmHDhrlZs2a5gw8+2F5jvo2Qnm21yy67pHoVRSGxZMkSezz22GNd//79E203RJhwDIwePdrcW7wLJGMJXF3q1q2b6tUTQoiUwXiJ8TSCeYqrQuLHH3+0+8C7775rRYc4PN1www0mmBZCCJE/SNghYgX961555RUXutVZqBBk7tixo/vjjz8Sr1ExgkKaqjss30KD6hm2CwFZCTvCo0uXLjahpLLuzTfftIXEXGjJOZI0WMrfeOON1paG7YEIzDvbYBlNxdmJJ57o6tSpk6hGFUKIkDjhhBPcI488YtfI3Xbbza6dH3zwgY2lSGDXq1cv1asoCgkvhGcMiTjUJ28XLlyYoV1JXCEYzbwR57P58+fb4ilWrJiJOi6++GIXCoh6EIrfeuutNrfg5zlz5th7P/zwg7vyyisTn8XtZM8990zh2oqCpHTp0glhh0QdgvgK8yiuD/4ewX1DyTshROjgUHHJJZe4kSNHmuOdv06GAONkP2fwY0Va+TGGqF27dkrXTQgh4sIOW+SbKWJE06ZNrfdzu3btrGIgc/UQKtEdd9wxZesnChZ6uxJMxD6cRxxc6AOO0GPw4MGWtA0NVNEEYJlUEICWPW64MLEiWffqq6+6DRs22GvYiB9//PF2brCEJPigioCEDRW53Dc87733nrWuEUKIEMH5bvjw4Vu93rt3b0veiHA455xzbOyAwxVtDVetWmUCekSRgwYNck2aNHFxB6czWtJ8//33NofEuYP5pk9uh8Jxxx1n86qcoHFUvGEOccYZZ9j50K9fP3fooYea2MmD1XxIyavQwREXV8QhQ4ZYAQHJPELMBx54oL0eQqsBIYTw0IJq7dq1iZ9xNmPhvojoNRqPxU02jtdIYmuMleH222+3tp533HGHW7p0qTv33HNj28pRCCEKGzl2iFhaSF900UUJm1gRDn4AjdWdt/4kwEAimyRuiBBYIfBGooae4FRgRoNttKTYZ599UrqOonCoVq2aLYh8SFIgaJgxY4YlaVhCS9ohAKPClIX+p4heJk+enOrVEkKIlMI94phjjrFgI+OqMmXKuJYtW1p1tgiLe++911122WUWoCVp56H1RgiiDiAYzRJ1fsTVi7YD33zzTaJdTdzBqYM2pzlBbh3xhpY8tDL85ZdfEq03ooQ2nwgZime4NvgWA8QVdt11V0tU4tpBlXrXrl1TvZpCCFFoMHfKSgjLuHHNmjUZXvPusXGNyx9++OHuggsusOc4a3fv3j3YuLwQQhQEEnaIWEEQAYcG+nxed911GapHRPz5888/7TEqVPDPf//9dxciJO79hIEgHEtW20yEA3b6p59+ui1YIiLwePHFF13IYAfJQrsWKg2FECJkSNqHkrgXyUGwgPATkQ/OFQjocW6oX79+MJsNMUevXr2sKn3Tpk1ZJrFDEHb4ystoQnfZsmXukEMOSRRWiHAcOxB1CIG4jVZdPqYwd+5cm1/S3hLnjk8//VQbSQgRFKNGjcpxjDWObh3gv3+0XVvocXkhhCgIlPUWsQJ3BpJyVJJQMUBbAaqq4m51Jv6H7yyFGtoHX311HQPIaEA2FJvYxx9/3IKvyVBv5LChPRWBt06dOmWZsAgNqsyEECI0SNAOGDDA2m7g8tWgQQOrqpKjl8B9oW3btsFuiClTppgANiuqVq1qrVlCgEQ+xRNYanNMnH322Sb2YR6Bm0v16tVTvYqikEAEffPNNyd9X21vw+G3336zR4pIli9fbq4+XBd9fCGnLj9CCBEXELxmJYJjzMS1kvZl3gku7nF5YvE+xuhj0og+onFHxgw777xzitZUCCGKNhJ2iFhBlYAfMJDcj/a2i7PVmcjIgw8+aEt2r2E1fskll8R+0/lAK84MtJtgIM1r3jJVCKDXpyouhRAiPLALxvHOV93C2LFjrdJ2zJgxGQTSIt7Mnz/fdejQwdWsWdMEnzxPBp8ZPHiwizuLFy+2R1pOMHbGRrt169ZmLV2iRAlXr149FwIDBw60Nn633Xabta0jQbHXXnvZdaNPnz52rRBhwD2BgolFixaZe4d/jTkmySscbE444YRUr6YopAIBQNQxdOhQe04rt/Xr19tzWrkJIUSoIG6jXdWECRMSYgfA+Y52h7QGjjPEn2vVqpXta3Xq1LGiXCGEENuPhB0iKNszuXWIEHn00UfNuSN6blBpd+edd6pdkRBCCBEwtNogOYvL3Q033OBWrlxpYwaS/ATfSNKIMEAUz7FAstY/T4ZP6MYdXzBAn/CjjjrKPfzww65s2bLu+OOPNyePDz74wNrThNDa0TNz5ky3yy67mFPmscce6xYsWGDFE3JqCAOuC61atXLfffddlu/TnkiEAeI22q68/fbblrjkGsm1cvbs2fZ+ixYtUr2KQgiRMh566CH38ssv2/MjjzzSnCmYXzF2vOmmm9zw4cO1d4QQQuQaCTtELG3P5E4QJrSUuPjii3P02VBakJCweeSRR+x55cqVE5OJF154wZUsWdJdc801qV5FIYQQQqSIH3/80R7PP/98cyWATz75xE2bNs19++23EnYERLVq1az1CGNFxsk8T0YotsmlS5dOOJtVqlTJXApwrkD0FD1/QmjF4m21uT4cccQRJgbDtQPXH2y1adEi4s+rr75qog6//4sXL26iHlxcEHw0bNgw1asoCpH+/fu70aNHmxjQjyFwgcTdp27dutoXQohgeeutt+wR1w7f1hAx7LnnnmuCWcZWcXTNxdUP8W9OYAwhhBAid0jYIWKH3AnChSB0KIKNnOKtkRFwXHXVVfacqpqOHTtaEKZbt24WrBZCCCFEeHhHAsSemZPZWAiLcCC46kXyq1atctOnT7fj4pRTTkl85vPPP7fEbo0aNWJvIQ3NmjWzuSXstNNO1nqlS5cuifYTbIdQKvO///572/ccA9F2loh8JOoIhxUrVtjjZZdd5g466CA3Z84cc+kgUYWbyy233JLqVRSFCOf/pZdemuE1hF8sQggRMribAS5vHtpi77rrruZ09u9//9vFdT7B+EAIIUTBoqbJIpbuBLScwJ0AO0iCbrgT+KCcECHhbXJPO+20xGtYpjKZ8HbbQgghhAgT3/OZ8bKnWLFiiep8ER7Mo7766it31113uf/85z/2s19I6j/22GMmDg4BRE6IpLHQhjvuuMOdfPLJJujo27evK1++vAuBpk2b2uN9991n14zmzZsn3mvcuHEK10wUNv7+gJiHWMvChQvNsaNixYom/nnnnXe0U2IMzp84cVx55ZWJ58kWPiOEEKFyxhln2ONLL72UeI3cxK+//mriyLgKO4QQQhQOcuwQsULuBEJkZN9997UgG0G3gw8+2F5bvny5TSaosMFGVwghhBBhM2DAAPfkk0/a840bN271mnf/wmpfxBdsoRs1auTWr19vP1ONX7Vq1a0+F1IwukKFConnOAOGWCxART5CL1rRtGjRIiF0oX3PzTffnOrVE4VIVMxUtmxZt3LlSjsGXn/9dXtNTpDxhpYrvjjEP0+GCkiEECGzZMkSc3sbNGiQGzdunL22evXqRFEqLmiesWPHWuxWCCGEyCkSdojg3AnoBStEKGAhTRCWgNuHH35odoATJ06097DWjlboCiGEECJMGCNnTsJkfg1RqIg39Ppu165dtuKF/fbbz7Vp08aFAFbZ9957rwXfORcyu9j06tUr0Tc9zuDI0KFDh61ef+KJJ9xnn31mxw2CcRGGe8vIkSMTP3MtGDhwYEL4VL9+/RSunShoEHNNmTLFznf2N8+ToWuCECJkZs2aZQK4qKDD8+2332413hRCCCG2Bwk7RKyQO4EQGaEH9kcffeSmTZuWcLSBcuXKuRtvvFGbSwghhAgYktInnnjidjsXiPjSuXNnV7t2bXfFFVe4mjVruiFDhmRI8IeUrHv55ZfdM888s81WRqGxadMmN2nSJPf888+7efPmuffeey+o4yJkKBJgTrlu3Tr7uVOnTq5UqVJu1apV5uZCsl/El+LFi7tDDjkk8XP0uRBCiH946qmnEsKObbHPPvto0wkhhNguJOwQsULuBEJkBOu/wYMHu7feesvNnDnTKg0rV65svbFxshFCCCFE2Lb6UWt9IXBzo+p+8eLF1pqFhC2VhLRYQMiACyKVhmeddVbsN9ayZcvskfY0t9xyy1YtDEMTMyxYsMA999xzZiEedfBR+42wKFasmFu7dq0Je7755htzSz388MNdyZIlU71qooDhnvD555/n6LM4+UgQKoQIlSOOOCLRCnv27Nnm2kFruzVr1iTaZAshhBC5RcIOESvkTiDE1hBsbdy4sS1CCCGEEEJsi8cff9w98sgjWdpD16pVKwhhR40aNewR8dOBBx7oQmT9+vVuwoQJ1h+etiueo446yp188sm2lChRIqXrKAqX/v37Wxse71hTtWpV98UXX9j1YujQododMebTTz/Ncfsp7hOjR48u8HUSQoh05I8//nA9e/Y0MaznvPPOcxdeeKG78847c+yYKIQQQmSFhB0iVsidQAjnzj77bLPHpYqqffv2CavcZHaqBx10kLvqqqss+CKEEEIIIcKGquxBgwaZqAN7aNwZSN5/99131s6vVatWLhQ3yMsvv9zasTBmpvqc+aanUqVKrmzZsi6O0Mpx7NixbsqUKe73339PVJ9+9dVXbvPmzZbE33///VO9mqKQoeoY0Vfp0qVN7PTxxx8n3ps+fbq5ulSvXl37JQA4/7NzaTnssMMKdX2EECKdwDkZUQfixy+//DLhdMbY+oEHHpCwQwghRJ6QsEPEioEDB1qwjcS23AlEqKxcudL99NNPNmHwz7ODCqslS5ZYME5WykIIIYQQYfP1119bX3CsohEKt2jRwtr69e3b140aNSphLx2CwGXhwoUmbHj00Ue3er93795WeRlHrrnmGptDIOi54IILzKGF/X7ccceZsEOECfNFaNmypdu4cWMGYYdvXyRhRxjQVoDWrsccc4wtdevWdQcccECqV0sIIdKC119/3R5vvfVW17lz5wwt7Ghp9dtvv7lddtklhWsohBCiKCNhh4gV2MTS85k+yOrxKkJl+PDh7s8//7QKS/88GfRNx62DwMyGDRvcXnvtVajrKoQQQggh0hOS+owNWX788UfXsGFDG1sOGzbMPfzwwy7u4Fjx4Ycfun/961+ucuXKbrfddsvwfqlSpVzcKVOmjAl8QviuYttk1ZoJuD5A1NFGxA9aMI0ZM8bNnDnTlrlz55r4jwVwAq1Tp44tCD24fgghRIh4Iccee+yR4R6KaBj+/vvvlK2bEEKIoo+EHSJ2E02EHTNmzHAVK1aU+4AIksMPPzzDcyouce6guo7ANPB83rx57swzz7QKvKVLl7o999wzhWsthBBCCCHSAVos7Ljjjomfa9So4e6//373888/28/RqsM4s3btWnukteG1117rQoIK03HjxrkPPvjA2mvg1tKgQYNg9r3IGhxbhgwZ4kaOHJlwZ8BqHmebYsWKuaOPPlqbLsZwXyDmxkJxCG5Gc+bMMZHHrFmz7Foxfvx4W2jzOnr06FSvshBCpASuk7Qw7NOnT8LpjBYsPCdOm1ksLIQQQmwPEnaIWLFlyxabbBJ4wi53v/32y1A1MmLECHMxECIU5s+f7zp06JAIxGfmlFNOcffcc0+hr5cQQgghhEhP9t57b3fOOedYWwVACHzRRRclqgtx7ggBhAxDhw61wHxoNG3a1JYffvjBvfjii7a8/fbbifd79erlmjRp4k444QS5eQTEscce6y6//HL3n//8J3F9wLWB4oHrr79eDg2BQYKS6nMWWvMkc3QRQojQ6N69u5s9e7Z77733Eq8hhCRH0aNHj5SumxBCiKLPDlvIhAsRowoSegEngwHV/vvvX6jrJEQqQdQxbdo0s/+jh2Pp0qWt/Qq0bdvWdevWTX0dhRBCCCFEBhBxUIWPWwe89tprburUqVaByBhyhx12iP0WowIdAQOOkHzvQw89NOF+By1atHD16tVzIUDY6KOPPnIvvPCCmzJlSsK5g+Pg/ffft4IKEQ6LFy+22AotWGiBi8infPnyqV4tUcD88ccfiTYsLEuWLEkI/rgW4JpLGxacW3jcd999tU+EEMGyadMmN2rUKLtnEo9lHHn++ee7Qw45JNWrJoQQoogjxw4RKx5//HGbbGZXfSZESCxfvtwen3nmGdevXz/XqVMn+7lNmzZu1113lahDCCGEEEJsBQIGL+qAZs2a2RISr7/+uok6vCsBS5TKlSsHI+wgaUuilqV3795u8uTJJvJgm6hPfHhUqVLFFhEWtFqhNRXglMs18JhjjrEFMYfibUII8Q+4GO2yyy7urrvucrvvvrt78MEHTewhhBBC5BU5dgghRIxp3LixW7FihVVUjR071u25555mpV27dm33559/WuXdv//971SvphBCCCGESCOoxh4wYID78ssvbcwYpWbNmtaiJO7MmDHDqiyTUb9+fUtshgzHR5kyZVzx4sVTvSqiAJP57OecUL16datIFvGEtgI4NgFuHCQqk3HkkUe6hx9+uBDXTggh0odvvvnGXXLJJdbOz7uH4zK+fv16ax1/4oknpnoVhRBCFGHk2CFixdq1a939999vQTjsYTN3GqLqSjaxIiQOPvhgE3YAVZd9+vRxq1evtj64VN6pD64QQgghhIiCA2KXLl3cxo0bs9wwoVQbHnvssbaI5CiJH39eeukl9+yzz+bos7i56JgIJ/bGkowSJUoU6voIIUQ60b9/fxN10MrPi+DOPfdccxq/9957JewQQgiRJyTsELGib9++bsKECUnfl02sCA0U4vQHh7p167rff//dPfnkk/YzlqnYAgohhBBCCOH54osvTNSBq9t9991nLReKFfsndBCKOwMCaILvr776qtuwYcNWc8levXolqteFiDsUBVSsWNGVL18+6WfKlStXqOskChdcOCZNmpSjzyrOIIQImUWLFtnj7bffnrgeIpoeNmyYuWBRjEp7bCGEECI3SNghYsXHH39sj/T9bNWq1VYtJrCLFCIkTjjhBDd+/HhTiHM+YJs9ZMgQa8ly5ZVXpnr1hBBCCCFEmrHHHnvYIwnc5s2bu1B5+eWX3TPPPJP0/czukELEkZ122ilxvC9dutT99NNPViBQp04dWypUqGCiDxF/dt5552yFPUIIIf7Hv/71L3tct25dYpNw//zvf/9r90z/vhBCCJEbdtiiaISImTsBbVioItCEUwghhBBCCCG2n44dO7rp06dbZSGubyGCWwnfv1GjRu6WW25JCF6iSc7MhQRCxJHPPvvMzZw505aPPvrIHGw8++yzjwk9WJo2bepKlSqV0nUVQgghUs3dd9/tRowYYfdIRNKIOd544w23cuVKE0XynhBCCJFbJOwQsYIKEsQdzZo1czfffHOiukSIkPjkk09MBZ4TqlatqvNECCGEEEJkmFP17NnTxpSAVXTULrp69erWIzzuvPbaa65bt27mBnn99denenWESAtoScS1AZHH66+/7hYuXJh4r3fv3u7CCy9M6foJIYQQqWb9+vXuoosucp9++mmG10uWLOmGDx+uYlQhhBB5Qq1YRJGnRYsWbu3atYmfN2/e7EaNGuWee+45azcRtQWdOHGi2rGI2NOhQwez+MsJ7733ntt///0LfJ2EEEIIIUTRYOPGjQlRB9AHnMXz888/uxCgWODyyy+3dizFixe3lhPRwoFKlSq5smXLpnQdhShMNm3a5GbPnm2ijlmzZrklS5ZkeJ/zRAghhAidvfbay/ISU6dOdYsWLXJ//vmnjSNPO+00a5UthBBC5AUJO0SRB1FHVklsHAvWrFmT4bW//vqrENdMiNSyyy67uEMPPTTbnsfFiuk2IIQQQggh/uHII4+01pbZjTFD4JdffjE3gt9//909+uijW70vdwIRioPP5MmTTczB+UByynPYYYdZCxZs5XlUGxYhhBDif9CuDyEHixBCCJGfKKMnijy4c0SDC9mx7777Fvj6CJEu/Pbbb+67775ztWvXtt7oBNsqV67s/vWvf6V61YQQQgghRBozcOBAd+KJJ7ozzjjD7bjjji5Exo4d6z788EMbOzOG3m233TK8ryS2COU8ePbZZ61Y4PDDD0+IOFj222+/VK+eEEIIkXZQgNq3b18bR+IsvmXLlgzv08pM91AhhBC5RcIOUeQ55JBDUr0KQqQVY8aMcTNmzLCFScRbb71lC+yxxx7u6KOPTgTjqlWrlq2jhxBCCCGECIsvvvjCvfbaa9YX/KyzznKh4tt9tm/f3l177bWpXh0hUgpJqc8++8yWkSNHZvkZudgIIYQQzt1///3ulVdeSbop/v77b20mIYQQuUbCDhGboNvjjz/uTj31VFerVq3E66tWrXL9+vVznTp1kgBEBAO9vllat25tPxN8wzqXBaHH22+/bQu89957bv/990/xGgshhBBCiHTh4IMPtipC5lLLly935cuXdyHSoEEDN3ToUHPAE0IIIYQQIifMnz/fHtu1a+fOO++8rdoYylFcCCFEXpCwQxR5fv75Z0tgf/vtt+6bb75xgwcPTrw3bNgw99JLL7lp06ZZyxZ6wAoREv/973/dxo0bEws9woUQQgghhEjGjz/+6A444AC3aNEi17x5cxMB4/rmW7JUqVLFKhHjDi1YEEtTcYm449BDD83Q0rBFixauXr16KV1HIQqaW265xd188805+myobZuEEEKIKLvvvrs9XnTRRSaYFkIIIfITCTtEkeepp54yUUexYsVMuIGdmQ+4VaxY0VSwOHoMGDDAFiHizpIlS9wHH3xgrVg+/vhj9+uvvybeK1myZKINC/2R5dYhhBBCCCGirFu3zkQdntWrV9viQeQRAvQ/Z54Jc+fOtSVK5cqVJewQsYfYSlTQJIQQQojsufDCC12PHj3c6NGj3XXXXWc5CyGEECK/2GELjTKFKMK0bNnSEtm33nqra9u27VbvL1iwwJ177rlmezZv3ryUrKMQhclxxx3nfvrpJ3tepkyZhJCDpVy5ctoZQgghhBAiKb/88ov79NNPk76PsKNSpUqx34KIpBcvXpz0/fr165u4QwghhBBCCE+XLl3MPfyPP/5wO+20k42doyLJiRMnqh2LEEKIXCNhhyjynHDCCW7lypVu6tSpSe3NjjrqKHMt+Oijj9yee+5Z6OsoRCqEHTvvvLM5dGTH2LFjNZkQQgghhBBb8ddff7kPP/zQRB4EpBs1apQITocGrpBAUJ5Wh7QApUamQoUKqV41IYQQQgiRpgV3WfHee+/JQVkIIUSukQ+UKPLst99+Juz48ssvsxR2rFq1ykQd2J7tuuuuKVlHIVLB5s2bLei8rYC9EEIIIYQQUb744gvXuXNne4RatWqZ89tNN93knnvuuSCEwYg5evXqZS1ZNm3atNX7vXv3lrBDCCGEEEJkYNSoUe7PP/9MulVCGEcLIYQoOCTsEEWe448/3n3yySfu3nvvdQcddJArX7584r0NGza4nj172vO6deuqp50Igm1NIKJoMiGEEEIIITLTrVs3E3UcffTRbvbs2YnXV6xY4UaOHOm6du0a+402ZcoUN378+Czfq1q1aoZ5pxBCCCGEEHDIIYdkuSF+++03Ew5H27IIIYQQ24uEHaLIc8kll7iXXnrJAo8tWrSwSrL999/fXDqWLl3qfv/9d1e8eHF37bXXpnpVhUjpBEIIIYQQQohtsXz5cvfZZ5+5UqVKue7du7u2bdtmeH/hwoVBbMTFixfb43nnnecOO+wwt2bNGte6dWt3wQUXuBIlSrh69eqlehWFEEIIIUQa0K5dO7du3To3YsQIt88++7hx48ZZboJx5C677GKfadKkibVoUSsWIYQQeUHyQFHkYbD0zDPPuJo1a1pbCQKRM2fOdAsWLDBRR5kyZdyTTz7pjjzyyFSvqhBCCCGEEEKkNVQTwp577pnh9Z9//tkeqTQMgT/++MMeDz/8cHMuQehRtmxZc4ycNm2a++CDD1K9ikIIIYQQIg2g4HTZsmUJB+UBAwa4vn37ul9++SXVqyaEECJmyLFDxMahYOzYsW7RokVu/vz5ppDdeeedXaVKlaySaqeddkr1KgohhBBCCCFE2lOhQgW3xx57WHCaqkPAreKJJ56w5wjqQ6B06dL2uMMOO9i8krnm1KlT3ccff2yv//jjjyleQyGEEEIIIYQQQoSEhB0iVuDKIWcOIYQQQgghhMgdCORvueUWW1577TV77euvv7ZH2l5edNFFQWzaZs2auUcffdSeUyhAwUCXLl3sZ3qj16hRI8VrKIQQQgghhBBCiJCQsEMIIYQQQgghhBAJWrZs6apXr279wb/66itXvHhxd9RRR7nWrVu7XXfdNRjHjjFjxiQstO+44w5r/blq1SrXpk0bV758+VSvohBCCCGEEEIIIQJCwg4hhBBCCCGEEEIYCBemTJniSpYs6Xr06JHYKp9//rkbMmSIOVWceOKJwbSl8ey9994JBw8hhBBCCCEys3nzZrdp0ya3ZcuWDD+Df00IIYTICxJ2CCGEEEIIIYQQwv3555/m0HHXXXe5WrVquUaNGmUQdjz22GMm6oi7sIPA+7p169y+++7r5s6da9/ds99++2XYLkIIIYQQQkCTJk2y/VkIIYTIKxJ2CCGEEEIIIYQQgUPLEQQL69evt5/nzJnjqlatutXn/v3vf7s4s3z5ctepUycTdYwePdpNnDjRPfvssxk+M3jw4NiLW4QQQgghhBBCCJFeSNghhBBCCCGEEEIEzu677+7atWuXbbsR3CratGnj4sp///tfd8UVV7jvv//enEvmzZuXeK9UqVKuWLFi7rvvvnP9+/eXsEMIIYQQQhjPP/+8++uvv3K0NRAPCyGEELlFwg4hhBBCCCGEEEK4zp07u9q1a5u4oWbNmm7IkCGJrbLjjju6nXfeOdZb6e233zZRB64kffr0cTVq1HATJkyw9zp06OCaN29uriZLliwxZ4/y5cunepWFEEIIIUSKOeCAA1K9CkIIIQJBwg4hhBBCCCGEEEK4f/3rX65+/fpu8eLFQW6Nzz//3B5btWrlWrRokWWFZa1atdz7779v4g4JO4QQQgghhBBCCFFYSNghhBBCCCGEEEKIBDNnznQDBgxwX375pfvzzz8zbBmcPIYOHRrLrbVhwwZ7PPDAAxOvtW3b1tquVKhQwX4uWbKkPW7evDlFaymEEEIIIYQQQogQkbBDCCGEEEIIIYQQxh9//OG6dOniNm7cmOUW2bRpU2y3VIkSJexx6dKliddw5fDOHFu2bHGffPKJPZflthBCCCGEEEIIIQoTCTuEEEIIIYQQQghhfPHFFybq+Pe//+3uu+8+V6VKFVes2D+hg+LFi8d2SzVo0MA98MADbtKkSe60005zjRo1SryHc8mjjz7qPvvsM7fXXnu5o48+OqXrKoQQQgghhBBCiLCQsEMIIYQQQgghhBDGHnvsYY+4VDRv3jyorXLEEUe4Vq1aufHjx7urrrrK1ahRw7YDLiU4daxYscI+17lz51gLXIQQQgghhBBCCJF+7LAFL1EhhBBCCCGEEEII51zHjh3d9OnT3bBhw1zdunWD2iabN292t912m3vppZe2eg/nEkQdnTp1Ssm6CSGEEEIIIYQQIlwk7BBCCCGEEEIIIYSxdOlS17NnT3OogF133dUWT/Xq1d3jjz8e+61Fy5WpU6e677//3u24447m3NG0aVNXunTpVK+aEEIIIYQQQgghAkStWIQQQgghhBBCCGFs3LgxIeqAX3/91RbPzz//HMSWqlixoi1CCCGEEEIIIYQQ6YAcO4QQQgghhBBCCJFoRfLdd98l3Rq77LKLK1OmjLaWEEIIIYQQQgghRCEiYYcQQgghhBBCCCGEEEIIIYQQQgghRJqiVixCCCGEEEIIIUTAzJkzx1188cU5+mytWrXc008/XeDrJIQQQgghhBBCCCH+QcIOIYQQQgghhBAiYP7++2/3xx9/5OizOf2cEEIIIYQQQgghhMg/1IpFCCGEEEIIIYQImF9//dV9/fXXOfrsrrvu6g455JACXychhBBCCCGEEEII8Q8SdgghhBBCCCGEEEIIIYQQQgghhBBCpCn/SvUKCCGEEEIIIYQQQgghhBBCCCGEEEKIrJGwQwghhBBCCCGEEEIIIYQQQgghhBAiTZGwQwghhBBCCCGEEEIIIYQQQgghhBAiTZGwQwghhBBCCCGEEEIIIYQQQgghhBAiTZGwQwghRIGwZcsWbVkhhBBBoXtfuGjfCx1/QgghhBBCCCGEKEgk7BBCiDRh9uzZrlKlStu9vPvuuy6dWL16tbv++uvdggULUr0qac2kSZNs/w0aNMgVJbp27Wrr3apVK5dujBw5MnFe/Pnnn9v1u1deeaX93gUXXFBg6ycKD/b/448/7k499VRXs2ZNV7t2bde0aVO3cuXK2O+G7M6DdD5/i/o+jfu9rygfOwVN3Pe9KLjjv1OnTvZ3W7duXWSPP4290o+4jgOKMnk5T7bFJZdcYn/38ssvL1Jzn9yud8gU5HEk0p/77rvPHXHEEW769OmpXhUhhBBCpBgJO4QQQuQbX3zxhWvWrJmbOHGiKlez4ccff3S33367K1OmjLviiit0BAqRz9xxxx2uf//+dk367bff3C+//OJWrVrlSpYsqW1dREnnfap7X7ho3wsdf0IIIYQoaDp37uz22Wcf17NnT7du3TptcCGEECJgiqV6BYQQQmxN79693YUXXljkNs3atWst2Say55577nHr1693vXr1csWLF9fmEiIfoYLtpZdesudHHXWUe+CBB1zp0qXdr7/+6v71r7A1zQMHDnRFkXTfpyHc+4rqsVPQhLDvRfoe/zr+RFyOZSGEENmz++67uy5durg777zT5kJ9+vTRJhNCCCECJfWRUCGEECIgZsyY4V5//XVXoUIF16JFi1SvjhCxY8OGDe6PP/6w52effbYrW7as22mnndxee+2V6lUTuUT7VAghhBBCCBEytG478MAD3fjx49UCUAghhAgYCTuEEEKIQmTAgAH22K5du7SoNBcibvz111+J57vuumtK10XkD9qnQgghhBBCiJChWKFNmzbW9tjHlYQQQggRHmrFIoQQMWTz5s1u9OjR5gxB//fffvvNlShRwh1zzDEmKKhWrVq2vz979myzvZ83b5778ccfze6eBGmZMmVcvXr1XNu2bd3BBx+c+Pzvv//uqlevnuFvnHfeefbYuHFj99hjj9nzSy65xBwrGjRo4J566qks//fIkSPdXXfdZc8XLFiQoVXJ5Zdf7t577z2zoDzppJPc3Xff7T755BNbtyOOOMI9/vjjiURuXrYB3/npp5+2//XNN9+4v//+2+27776uRo0armXLlva/c8NHH33k5s6da+t4+umnb/X+9ny/7d1Hnk6dOrk333zTtW/f3nXt2tWNGDHCTZ482X311Vfuv//9rzvooIPcKaec4i677DK3xx57bNf3o9cr+/jTTz91xYoVc/3793cnn3xyvh6brOewYcPcrFmz3A8//GB9Zhs2bGjfK79gO7D/2b7s/1122cXWiwoZtk0Ujg321cqVK+07cPwmY9SoUe6OO+5w//73v93777/v9txzzxytT26Ox7yea/446dixox0n7DMqg7788kvbt+XLl3cXXXSRa968uX2e7//EE0+4adOmudWrV7u9997b/je/yzGZGzie2GZvvfWW7XdcOPbff3939NFH2/HN94/ywQcfuEsvvTTDa9dee60twP6sXLnyNv9vYXz3VJ0HrBP/s2rVqvadMpNu15Xt3ae69+V9G2zvsVOQ54v/2/z+TTfd5IYPH277/Ntvv7XrZ8WKFe2YbNSoUb5eS3JyT+Z/f/jhh9sc96TLubVx40b34osvukmTJrmvv/7a2seUKlXKHX/88e6KK66w6s+syMvxVKlSJXtMdr3JijfeeMN6yMOYMWOs9VJmWrVqZfuBezPjKpIcUX7++Wd37LHH2r1y0KBBrkmTJnn+Ptu6dnJMcq/lmvz999+73XbbzY4v9httozjGYeLEiXbsZAXry99m+eyzz6wFFfuFcRTHYnT/5nTcndfvHerYS+OA9BkHFOY+ye29Ir/Ok4K6f+f3+ZeZ3N7ftkWI983CuN7mdX/ldrts7+8VZtyosLZJft27mP8//PDD9v0WL17sqlSpkvTvCCGEECKeSNghhBAx4/PPP3dXXnmlW7FiRYbXCTS//PLLbsKECfZ+9+7dt/pdgsg9evSwwHNWVvgsJO3Hjh3rnnzySVenTh2XCpYvX+7+85//uE2bNtnPBN4IcvvJeV62AUEBJuDr16/P8DqBFZbXXnvNRBn0Nd1exw2SFECAgh6pufl++bWP6MtOmwqSB1HYdiz8fYJSBDRzAokUErBe1EGwIbOoIy/7BQjK3XjjjYk2G0BgZNy4cfZeNHmTWwjGEUgiwONh20+fPt2WU0891T344IP2HYFj4LTTTrOAE7/DdyNgmBWvvvqqPZ544ok5FnUU5PGYEwhGEiiPbg9AoMSyatUqS7x16NDBjgEPQXQCXAScXnjhBQtubQ8E8kjec5xG+e6772zheGE/kewtKOebgvru6XgepOt1ZXvQvS/vx1a6XitIxJCgQegTvVbzN/m9s846ywL2/rqc39eSZPfkonJukci4+uqr7ftmFiOQOOC4ePTRR00MkflvF/bxdNxxx1lihu3Lvsss7OBeuGTJksQxt2jRoq0+QwKE5AnJkPr16xf49yEJfM0112Q4Jjg+SepNnTo1IVTJDr4LSajoMe7XmYXxA8cIos7tJR3vOek+9vJoHJB+44CC2id5vVfk9TxJ5f17e8+/go4bhHzfLMjrbX5s19xul9z+Xn5Q0HGV7flu+XXvQihUq1YtExhzDHtxixBCCCHCQR7wQggRI3766Sd38cUX2ySRyiRU/gS4Fy5caFUITCSxbaSCaejQoVv9/pAhQ2xiu8MOO1jQgaoDHyhjcklihQkpQbV777038XsE4ZcuXeqeffbZxGtMgHktc9VgfkBggwpNJtisGxVGV111VZ63Aa/fcMMNljig8ovtMXPmTEuusy0IDsErr7ySZQBgW0EzqoeA6o3cfr/c7qPMENQk0EVCjL/H9iEBcc455ySCEQMHDtwuUQfJFoJ+/fr126q6K6/HJvuAgCvBmAoVKlgl0/z58y1Ae91119n2JWCbV6h6IdBCNQ0BONaP/d20adPEvkG0EuWMM86wR9Y/2XFBUO7jjz+252eeeWaO1qUgj8ecQkCK7UGl0pQpU+w4Y9v7ICgWsFRPUtn3yCOPuDlz5lhw3CeyCKRzHG8PBMg43gnI7rfffu6ee+6xv8n+Jnjlg35U7z/00EOJ3yOBxzWHY8LD+7zGkhO3joL+7ul6HqTjdWV79qnufXnfBul8raAqm4Q35z7HWObrMsd8VnbUub2W5OSezHrnZNyT6nNrzZo1VpVMwmGvvfZyt99+ux0XbH+Og3LlylllKVXNJEQ9+XE8+fM0p24dwPHhEyfsq8yQxEC04cGxIzMkIoEqWy/4Lajzg+9HQockEdty8ODBVvHL8dqzZ08bH3O8bwv2Lb/TrFkz29f8DYSb/j5PBT0Czu0dd6frPSedx15RNA5I/TigMPZJXu8VeT1PUn3/zs35l5/3t4L6u0XtvlnQ19u8btfcbpfc/l5+UZBxldx8t/y6d/l4EtfBaMtKIYQQQgTCFiGEEGnBRx99tKVixYq2jBgxIld/o0ePHvb7Rx111JZly5Zl+Zmbb77ZPnPkkUduWbVqVeL1P//8c0v9+vXtvTvvvDPp//C/z/L7778n/Q5z587d6ncvvvhie++yyy5L+vf57v5vbN68OcN7/J5/76WXXsr3bbBkyZLE3//444+z/N02bdrY++3bt9+yPbz77ruJv7106dIsP7Ot75cf++iqq65KvHfXXXdl+ftt27a194855pit3rv66qvtvbPOOst+/vnnn+05r1WpUmXLpEmT8n2/wHnnnWfvNWzYcMu6deu2+l3+r/9eLP/973+3bA8dOnRI/G6XLl22/PXXXxne//vvv7d07do18T1XrlyZ4f3TTz/d3mvatGmWf3/o0KH2fp06dbbaJ8nIy/GY13NtW8fJuHHjEu9Xr159y9dff73VZy666KJst0ky/Hc6+uijt3z11VdZngcdO3a0z1SqVGnLZ599luF9jh2/bq+88sqW7aUgv3uqz4PM52+6XFe2xbb2qe59eT+2tkVWx05Bny/Rv821LPPxzHW5W7duie+0YsWKfL2W5GTMkd24Jx3OrZ49eya2D/eUzHz77bdbatWqZZ+59957C+14yo6RI0cm/u5vv/2W4T22o/+uPF5xxRVb/f5xxx1n740aNSrfvk+y49/fa48//vgta9as2epvvvfee3ZsJRv/Rfdvr169slyvSy+91N6vXbu2HfPbM+5O9T2nKI69QOOA9BsHFOQ+yeu9Iq/nSV7P05yM+fP7/MuP+1tW6x3yfbMgr7f5sV1zu11y+3sFHTdK5TbJj3vXrFmzthknEEIIIUR8kWOHEEKkIdgp0ps8u4X2C5l7e3rVP/1bqfTICio+dtxxR6sGoXrEw2tUGFDt17t376TrRk9SD9ULqYDKiaysSPO6DaI22limZgXVkWyj7XUhoOIGqBg59NBDc/X98nsfYVOcFSeccII94hSBBWkyeB+nDirdWDeqSbHrze/9wr6gcsavM1VQmeH/0qs2r+A4csstt2xls0wlD/bLPGLbSkVbFF99Q69vKq4yQ+UbUI2LPXxOKMjjcXugFUxmateunXjeuHHjLPsO16xZ0x7pVbw9drneCpp9fcghh2z1GY4RKqI4l6h28i2O0v27p+t5kG7Xle1F9768b4N0v1Zw3eWcz2wDz+u4IvjvhMNBQVxLkt2T0/3cYpvQDgSoUI7+Hw8W4M2bN7fn3lUs1ccTVeN+/X3FqgfXKjj//PPtkarYaKUqlulU5Ef/TkF9H9qheVeRTp06ZdkmhdYyvup9W+D8kRWcN/57rFu3Lkd/K53vOek+9sqMxgHpNw7Iz32S13tFXs+TVF9vc3v+FVTcINT7ZkFfb/O6XXO7XXL7e/lJQcVV8vLd8uPeVbFixa3iTEIIIYQIBwk7hBAiJhDcpg89NGjQIOnnCDzT1gEyB8wzw9/74osv3DvvvGOJYwLXUSvWqB12YUKwbrfddsv3bcAE2fcwpd8qCaM33njDLDTzCtsRypYta4HB3Hy//NxHZcqUcSVLlszyvWiv4WTBMvrUelEHdOvWLRG4yO/9ErVjz+73ffIjL1SvXn2rvtvRbXb44Ydnaf/eokWLRECUXrpR2D/YHEcDOTmhII/HnMKxULp06a1ex6rak6zFye67776VQGVbYLPvyS4Zxj6ih3rm30nn716UzoNUXVdyg+59BbMN0ulaceSRR9q9M9m1wP9dWlkUxLVke+7J6XRukSzw9wt6tGcnJiaxgZ13OhxPfFefsIhe97C5//zzz63FwgUXXGCv8f1oA+d599137bFKlSqJ47Ggvo9v+RIVkWRFToQdfOdkY48SJUpkGHvllKJ0z0mnsVcUjQPSbxyQ3/skr/eKvJ4nqb7e5uX8K6y4QQj3zcK83uZmu+Z2u+T29/KTgoqr5OW75ce9C/GPHx/4OJMQQgghwiFj2ZMQQoi0gKqBCy+8cLt+h/7bnpz+LtWGWfUKpffo22+/bZNEKnSSQdVSKsiqiiU/tgHJAiqWSKIzsacvPAuVTNWqVbPqnlNOOSURkNke6JUK9F/N7ffLz320zz77JP2dqPAk2e9/9dVXW1WW0GM2K9FKXveLf07FWLLkHhx22GEur2zLTYVKPvo1Z3bQIMhMFdWsWbOsJy/HkK8u52dftROtKNwWBXk85pRkxwn7InOgPDOZK/+25zzhOMqq2jLz/ia4ntV1LB2/e7qfB+lwXckNuvfl3zZI12uFTyolgx7mixYtyvCd8vNasq17crqeW9Gq9Kyq0JORDscTSRLutdFkl3fr4D56wAEHuAMPPND62pNsRPwTFVs0atSowL/Pt99+m7hXJ0uK5vSanN0xRlVxbhKj6X7PSdexVxSNA9JvHJDf+ySv94q8nifpcL3N7flXkHGD0O6bhXW9ze12ze12ye3v5ScFFVfJy3fLr3sXcSVEr/46JoQQQohwkLBDCCFiQm6q+DNX/lFt0rFjR7Ml9fjWIQTN69ata4GH/v37u1SSzJIyP7bBmWeead/3iSeesAQBNptM8LFHZeG7H3/88e6ee+7JNpCfmV9//TXbYGOU7Oyi82sfZba0zw0ESLGFJQBBwG/w4MGuS5cu+b5fsLf12yW7BGB+VFTvuuuu2b5PAgc2b9681XtU1RCgWbt2rR07voLX26nmpmK0oI7HnOK/b2Hhj5Wc/F+/r/y5le7fPZ3Pg3S6rmwvuvflzzZI52vFHnvske37O++8c4ZzJL+vJblt4ZDqc+vnn3/O1f5Jh+MJYQfVslStsu1IXnhhB9sM6tWr51544QUTduAgxjp4K/uog0ZBfR+/ff3xl4ycbPttObnF7Z6T7mOvzP83hH1SVMYBBbVPcnuvyOs+SYfrbW7Pv4KKG4R43yyM621etmtut0tufy8/Kai4Sl6/W37cu/z4uKDmwkIIIYRIXyTsEEKImBCdUGJHHrWkzQnYkNJOg4lt8eLFXfv27c3uk0rZaMB56NChriDJKmhbWNsgakn72GOPWcCFRAIVoyxYgAOTb/rfvvjiizl2JfCVZNHKy+0lXfaR/x59+vRxLVu2tEoRAhOID7Axzlxdndf94l1OEDX89ddfSbch7xf08eeDcL5FShT64N55551m8UxQhgANrWq8u0lukwsFcTzm9VwrKHxwOScW3X5fpCpQuL2k63mQTteV3KB7X/7d+9KVbV2rfEAbi/N0upak+tyKfp/taXuQDscTLQ+otl63bp1VyJ988sk2zvCCDqhfv74JO7Czp4qW+yPuVljvV61atcC/jxd0bGvb5mfrqTjcc4rK2CukfZLqa1Uqyeu9Iq/7JB2ut7k5/wrqmAn1vlnQ19u8btf82C4FcS/My1w2VdskP+9dPr4UdSwSQgghRBhsv0e2EEKItARbag99PLcX7CdXrVplz3v27Omuvvpq61GeuYpw9erVuV5HH6TwPWizIloxUdjbIKuqGCb4tMPAlWLy5Mnu6KOPtvc+/fRTN3v27O36W3mtqCiMfZRTjjjiCBN1wB133GHVMOzXXr16bWUVntf9Qo9kIHGTuQVMVrboeQFb9+z48ssv7TEru2bcWHy1Db15Cb75vrmIM7ZldZyfx2NBn2sFBdb6fr2//vrrbD/rhS3++Eh30vU8SKfrSm7QvS//733pxooVK3J0XfbXj3S5lqT63IoeF1Gb+KzWs1KlSrawvulwPCFSxI3KixdpAcB34D7oRRvHHnusJTOoml2yZIl766237HXuw9EkR0F9H2+9TmIpOxv07K7XId5zitrYK4R9kuprVSrJ670ir/skHa63uTn/CuqYCfW+WdDX27xu1/zYLtvze4Uxl03VNsnPe5ePK+WHc5YQQgghihYSdgghREygB6ev1ve9ObeHaBCBYHlWkLD3/cuBipIo26oW8JUNVGAmY968eS5V2wAHCibdxx13XJb9eulre+ONN2bZWzUnvVQhOqFPxT4qCAg8XHnllfZ8/vz57plnnsnX/cL+8L//5ptvJv1c9HvnFo6/ZOKb5cuXW+9dqFOnTpaf8dU1WPJSseW/b24qRvNyPBb0uVZQeKEKvP7660k/x3flWPOV3UWBdD0P0vW6klN078v7Nkh3sMpOZnNOQgphm2/fUdjXkuzGPak+t6pVq5ZIUGR3XeBe5YUKuF2ky/HkEx7vvfdeog0LPel9soeK6IoVKyY+Q/IEGjVqlOHvFNT38S1hYNq0aUk/l917eSW74y9d7znpPvYqSNJ1n6T6WpVK8nqvyOs+SYfrbW7Ov4I6ZkK9bxb09Tav2zW32yW3v1cYc9lUbZP8vHf5uX9UZCKEEEKIMJCwQwghYkKJEiUSweyXXnopEQTPKkBTs2ZNSxjfdtttidej9qr0NM8K2kHw+x6sI6NEKxz+/PPPpNWNy5YtS1T/RGGd6ZWeqm3gk0K0FsENIbtqrej3yQnly5e3R6pOs9o2OSE/9lFBQSsQhAZAH9poRVFe98v+++/vGjZsmLBDzaqyDKv27AJhOYXAZlZ9dAnkILTwts3JAi6s5957723P+TxVPvR4Pu2007Z7XfJyPBb0uVZQVKhQIREwf/LJJ7OsniTIdtddd9l5RFLrnHPOcUWBdD0P0vm6khN078v7Nkh3sLgeMGBAlteCe+65x4Rv9BmnXUdhX0uyG/ek+tyiGpT2aPDcc88lknNR6B1POxNo1apVWh1POHZw/+RaN2rUqK3EFNFkzNNPP+3WrFljiaDMCZqC+j7YtZPMA1rR4RySmQULFriJEye6giK74y9d7znpPvYqSNJ1n6T6WpVK8nqvyOs+SYfrbW7Ov4I6ZkK9bxb09Tav2zW32yW3v1cYc9lUbZP8undt3LgxMe7wcSYhhBBChIOEHUIIESN69Ohhk1QCTzgoEKBiQomFJTbRY8aMcW3btrUkCZ+76qqrEr97wgkn2EQSSJS89tprNlmkgoAWD127dnWPPPLIVhPKKPRD90ydOtV+NzrJPeWUU+yRJAz/mwk568K6PfXUU65jx46JXsep2AYkA7C+BFqKDBkyxAQKWGNSEUFiwQe4CMr4z+aEWrVq2SN/K5qM3x7yYx8VFLRioU8sAU+2be/evfNtvwDtR0jYYLnapk0b++4EIvn+o0ePtmMnP2D9SRCx/lTysL/od0vfXSqCvV0rScRkSZZTTz3VnvvgcIMGDdy+++673euSl+OxMM61guLWW2+1XsccuxdccIF7/vnn3dq1ay2YNnfuXHfFFVfY9QUuv/zy7ToPU006ngfpfF3JKbr35f3YSndwguL499dlWm/wHXyS4/rrr88wBimsa0l24550OLeuvfZat9dee9l+b9eunSWcuH6wsL5sl02bNpnF/sUXX5xWxxP3WT92WrhwYZbCjvr16ycEkP5n9nlmCur73HzzzbaPEe1yTcadg7/BfibRw3EVtZHflrPd9rKtcXc63nPSfexV0KTjPkmHa1Uqyeu9Iq/7JNXX29ycfwV1zIR83yzI621+bNfcbpfc/l5Bz2VTuU3y494VFaNEnYeEEEIIEQb/G8UIIYSIBWXLlrWJbqdOnUzx369fP1syQ1UIE1XfHsT/7jXXXOMefPBBC5B369Ztq98rV66cvd69e/dEBUXlypUz9CnmMwSFhg8fbgsVja+88oq9X6NGDXfRRRdZgobKi8wT3FKlSllQgx6nqdgGBLYeeughWy8qZdgWLFm1Hhk4cOB2rRfVYFR2ECyg4uaII47I1XfL6z4qSLBIpxqFypQZM2ZYUuPcc8/N837xv08FE79PQCfzd995551d586dtwrAbC9Uo2HrP27cOFuicHzwf1u3br3Nv0EALvpzbsjL8VgY51pBQX9jKqQ4hqnARtSS1bYhuO6P86JCOp4H6X5dyQm69+X92EpnuMYR/OaewpL5WkBg/fzzz0/JtSS7cU86nFusH8kljgvW4aabbkr6GW97nl/HExXJULVqVTd+/Phct2NhzAQkwjJvG8YdHBtePOHbtxTW+XHkkUe6vn37msCDql7cy6LQ997fi8G3kckvtjXuTsd7TrqPvQqadNwn6XCtSiV5vVfkdZ+k+v6dm/OvoI6ZkO+bBXm9za84T262S25/r6DnsqncJvlx7/JuJRxPfrwlhBBCiHCQY4cQQsQMqoioOKB6lUpH7B0JJBMQR1xw3XXXWVuHrHrJU5kzePBg6/NK9QFVDPQwp3IAZwACxc2bN3dlypSxz2e2A6U3LHbU2GcjYqD6iaoVKi08BMsInvE3+R98hqQNwXD+PhPoVG4DJvkTJkywCTwuCFQnsR2onKC3MAEE3ieYsL2OFr7yJC/91vO6jwqaG2+8MVFlcv/997tVq1bly37x1Sh8PyrnsE4mwMV3p9IFMYmv7M0LHLdjx461KiAsYEkY8T+wWuX1nFTJsR4cRz6p07hx41yvT16Ox8I41woK1ple5wTKCLizHdnfrP95551n+/uGG25IVFoVJdLxPEj360pO0L0v78dWusL6c/3lesB1mfspgXKC3xzzmZPphXkt2da4Jx3OLe4d7HeSH34bsA2x7uaeRoUp2yMdj6eoUAMRB9s7CtW6JH98AtK3MMuKgvo+HIcvvviiO+uss6zPPeMGEi38/PLLL9v293Ds5Sc5GXen4z0n3cdeBU067pN0uFalkrzeK/K6T1J5vc3t+VdQx0zI982CvN7mx3bN7XbJ7e8V9Fw2ldskr/eu6dOn2yNtWzKPjYQQQggRf3bYEp31CyGEEKLAWLRokTv77LMtaMBkPB0tokX+gBBj0qRJ5mBCNa8QQojtgwQbQXQS95mriIUoKpAYpdUDzJ8/P9/FHeIfNPYSQggR93vXihUrTACCaOjVV1/NVjgihBBCiHgiWacQQghRSGDZ3bBhQ6umpIpTxBN6U/ue1Ah5hBBCCBEvsMrH/pwluzHdJ598Yo9U/ErUUXBo7CWEECKEe5dvb4eTi0QdQgghRJhI2CGEEEIUcgUyjBw50v3111/a9jFkypQpbsOGDWahi6WuEEIIIeJFiRIlzDYdqLTNim+//dZNnDjRnmP1LgoOjb2EEELE/d6FEGTMmDHWfiUnbcqEEEIIEU8k7BBCCCEKEXrqnnLKKWah6YP9omjz999/W/KGQMuMGTPcnXfeaa/TH1kIIYQQ8YO2eqeffro9f+edd9yNN97oli5d6jZv3ux+/PFHc/G4+OKL3a+//ur23HNP16VLl1SvcqzQ2EsIIURo9y5EHWvWrLG2LYhBhBBCCBEmO2zZsmVLqldCCCGECAkm4yQDdt11Vzd58mT373//O9WrJPIAQ6maNWtaMsdz/PHHuyFDhrgddthB21YIIXLpcPXmm2+6GjVquHHjxmkbirTjl19+ce3bt3dz5sxJ+pn999/f9e/fXw5e+YzGXkIIIUK6d23atMk1bdrU7bTTTlYgtPvuuxfCGgshhBAiHZFjhxBCCFHI7Lfffu722283146hQ4dq+xdxCMI0aNDAhDpYs1OhO2jQIIk6hBBCiBhDUoXWen369HHHHnus22effczJg7EAgqQbbrjBTZgwQaKOAkBjLyGEECHdux577DH3008/2ZhDog4hhBAibOTYIYQQQgghhBBCCCGEEEIIIYQQQgiRpsixQwghhBBCCCGEEEIIIYQQQgghhBAiTZGwQwghhBBCCCGEEEIIIYQQQgghhBAiTZGwQwghhBBCCCGEEEIIIYQQQgghhBAiTZGwQwghhBBCCCGEEEIIIYQQQgghhBAiTZGwQwghhBBCCCGEEEIIIYQQQgghhBAiTZGwQwghhBBCCCGEEEIIIYQQQgghhBAiTZGwQwghhBBCCCGEEEIIIYQQQgghhBAiTZGwQwghhBBCCCGEEEIIIYQQQgghhBAiTZGwQwghhBBCCCGEEEIIIYQQQgghhBDCpSf/B5GS9ZfzyRBQAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Collecting ensemble statistics from /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival_copy/ensemble_evaluation\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: hcc_survival_copy statistics phase complete\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Completed Phase 8 - Summary Statistics\n" + ] + } + ], + "source": [ + "if RUN_PHASES[\"p8\"]:\n", + " print(\"INFO: Starting Phase 8 - Summary Statistics\")\n", + " P8Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " outcome_type=CFG[\"outcome_type\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " n_splits=N_SPLITS,\n", + " scoring_metric=P8_SCORING_METRIC or CFG[\"p8_scoring_metric\"],\n", + " metric_weight=P8_METRIC_WEIGHT or CFG[\"p8_metric_weight\"],\n", + " top_features=P8_TOP_FEATURES,\n", + " sig_cutoff=P8_SIG_CUTOFF,\n", + " scale_data=P8_SCALE_DATA,\n", + " exclude_plots=P8_EXCLUDE_PLOTS,\n", + " show_plots=P8_SHOW_PLOTS,\n", + " include_ensembles=run_p7 if P8_INCLUDE_ENSEMBLES is None else P8_INCLUDE_ENSEMBLES,\n", + " multiclass_average=P8_MULTICLASS_AVERAGE,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 8 - Summary Statistics\")\n", + "else:\n", + " print(\"INFO: Phase 8 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "c6659ab3", + "metadata": {}, + "source": [ + "## Phase 9: Dataset Comparison\n", + "Optional phase, used only when two or more target datasets were analyzed. It compares performance distributions across datasets and saves outputs under `DatasetComparisons/`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "efe4bc4e", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running dataset comparison (Phase 9) for experiment JupyterRun\n", + "INFO: Running Kruskal-Wallis across datasets...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Starting Phase 9 - Dataset Comparison\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running Mann-Whitney U across datasets...\n", + "INFO: Running Wilcoxon rank-sum across datasets...\n", + "INFO: Running 'best algorithm per dataset' Kruskal-Wallis...\n", + "INFO: Running 'best algorithm per dataset' Mann-Whitney...\n", + "INFO: Running 'best algorithm per dataset' Wilcoxon rank...\n", + "INFO: Generating dataset comparison boxplots (all models)...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvIAAAKGCAYAAAAoKH+bAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAaVNJREFUeJzt3Qd0VFXXxvEdSEIILfTem3QQkI6gIAiCoFQVBFFUpCi+iopIURQUURBUpImIIPJSFJUmoFJEEEGkCkrvLZRAKMm39vG7806SSZ9w507+v7VmTTJz5+ZmhiHPPbPPPgHR0dHRAgAAAMBRMth9AAAAAACSjyAPAAAAOBBBHgAAAHAggjwAAADgQAR5AAAAwIEI8gAAAIADEeQBAAAAByLIAwAAAA4UaPcB+LLff/9ddL2soKAguw8FAABHuX79ugQEBEiNGjXsPhTAbzEinwAN8Sx861/09bx27RqvK+CDeH/6F/6GAmmPEfkEWCPxVapUuQUvBW6FiIgI2blzp5QpU0ZCQ0N50gEfwvvTv2zbts3uQwD8HiPyAAAAgAMR5AEAAAAHIsgDAAAADkSQBwAAAByIya4AAMDn3Lx507SwBNJjs5WMGTMmaVuCPAAA8Km2lcePH5fz58/bfSiAbcLCwqRAgQJmLYaEEOQBAIDPsEJ8vnz5TJvgxIIM4G8nstqK9+TJk+b7ggULJrg9QR4AAPhMOY0V4nPnzm334QC2yJw5s7nWMK/vhYTKbJjsCgAAfIJVE8+CfUjvQv9/0crE5okQ5AEAgE+hnAbpXUASS8oI8gAAAIADUSMPAADgRbt27ZLvv/8+xuiq1j2XKlVKmjRpYtoLevtn6b7vv/9+r2+fEpcuXZLJkycnuM1dd90l1apVS5Ofn54Q5AEAALxo9+7d8vHHH3u8r0SJEjJlyhQpWrSoV3+WniAkJZgnd/uUBvn4fn9L3rx5CfJeQJAHAABIAxpWH3roIdONR9tqLl68WPbv3y8DBgyQ//73v16ZC1ChQgWzPz1BSIvtUyJr1qzmZ1g++eQTuXLlinTq1MnVTpHReO8gyAMAAKQBbaHZp08f1/c9evSQ9u3by/bt22XDhg1St25dc/uNGzdk+fLl8vfff5t2g/fcc4/kyJEjxr5++eUX2bJliynRqVevnpQrV87cHhUVJZGRkTG6mxw7dkx++uknOX36tFlYqFGjRlKsWLF4t1d//fWXrFu3Ti5fviy33Xab3Hnnna62hzt27JClS5dK7dq1pXjx4vLDDz9IhgwZpEGDBlK6dGmPQd79954xY4YJ8voJQK1atcxt+ru+9957UqlSJcmSJYt5TurXry+VK1c29//888+ybds2yZ49uzRr1swsjuQusfvTC4I8AADwcdEiEmHTz9Y2gN5ZlKps2bImDGtg3rhxownyuvhPt27d5M8//3Rt9/7778unn35qttfRfB3d1qBv0RD92muvSdeuXeOUymiA1xDtHtQ1kL/zzjvSunVrj6U1o0ePlmnTpsU4Vg3YWueuJyNaV6+P0X1r4Lf2HRgYKJ9//rnUqFEj2c/FgQMHzD4LFy4sR44cMbedO3fO/Nz+/fvLsmXLXNuOGTNGJkyYIA0bNjQLJiV0f3pDkAcAAD4e4jWgrbPp5zfQ8V+vhXlr5NhauVPLTjTElyxZUlq0aCGHDh2Sb7/9VoYMGSJz5syRL7/80oR4HYl/4IEHTPBfuHChjBw50mwfm45+a9DWUf3y5cub0K/0cZ589913JsTrdq1atTKfCCxatMiMkA8ePDhGrbuOzOuJSJUqVUxpUHh4uMydOzdFQd6iIb5OnTpSpkwZc6LxzTffmJCuZUlt27Y19fbz58+XQYMGyapVq2TJkiUJ3h8cHCzpCUEe6Yqeyet/cPqxYkIrpQG49fR9qe9RIC7vhGhfoiUuauXKleZaw7HSSbB58uSR33//3dTVazhVOsreu3dv87WO5B89etSMYMemI9xK/9bpfnS/WioT39+8BQsWmGvd93PPPWe+bteunQnJq1evNivtuu9bTxR0XxqkdST/zJkzqXoetKxGR/4zZcpkvteJwFYtv3b3yZkzp6nn108CfvvtN9fzFd/99erVk/SEIA+/oh/VXbhwweN9GhD0rN0aBQHge7S2tkOHDq4lyj3Rmlit00V6CvE/+0VpjTpx4oS51iBs1bOrr7/+Os62OjH27Nmz5mv3f/MatC3uJTlKR6Y1xOsovnUSoHXyWo7y8MMPx/kZ1t/EqlWrum7TkfyQkBC5evVqjKCu9fDWCYF1/Fr6kxp64mKFePfnQ8t49OLun3/+SfT+egR5wJn0Pzutj7NGOTzR+7XeD4DvnozrZMCEaJDQSX+5cuW6ZccFu2mQziJOp6PoWhuvtJxE6d8kHYBy7+hiKVSokOtv1s6dO12lNBrSNcDrhFRPI9xvvfWWKb3RUeo//vhDhg8fLq+//rrHUhwt9dEa+M2bN8vdd9/tKqHREK/vNS21sbj3v7dKdlIr9km79fs2b95cKlasGOM+nQi7Zs2aBO9PbxiRh9/QP+r6Bo9vRF7pf2offvihPPXUU2YxDE+yZcvmmt0PwHsOHjwoFy9ejPd+7WLx0UcfmUlrWi+b0Ig8IR5OoF1jtDOL0hIVXYjp2rVrZvTbGjnW8KzlJOvXrzfdV6zRaQ3RGrI1sP74449mGx3N10+XtYZeR93vu+++GD9P75s0aZLpEGM5fPiw6YpjTU6NTfehJTRTp0419flajqP7Vxr89W9iWordglOfD+2Ko2Uy+fPnN5/SWfT5SOz+9IYgD7+S2Mft1up6Wi+YHs/cATtpB46E6CS10NBQsx3vT/hLkI+9MJK2jdSuNBatTdcQr5NLp0+f7rr9+eefN++JBx980Nyv4VrLQ63R8IEDB5r3io6eu/+N05PcYcOGxSh50e21842W2MTWpk0bsw/92dpi0qJtInUk/1bTTjpWWZB2xLHoRF/9dCCx+9MbgjwAAIAXWYsuxR5E0hCvE1Xdy1K0X7x2ftG+6Pv27TMns1p2Y/Vn123Hjh1r6tu1TEZr17VzjPWpVewFnrRER0tutMWl1rdreK9Zs6bpiuNpe6uuvnPnzuaEQbvbaMmKHqc1Wq7f62OsfVh19HpbUj7B1k/B9VMCayKu0k/F9fFaPuROPzXQk59ff/3VnNzo97p4lFXDn9j96U1AtA+0CNCPcr766ivzD07/sXTs2DHB9kG6AICejenHVPoPQSdGuX+0oh9baVskfYG11kr3V6RIkWQfl/4c95nkcD6tKXz55ZdN/SAjfoBv4f3pX1LyN1TrsnXCogZGDaxAenU1ie8F20fk9SA1aLvXTa5YscL0NPW0dLF+tKQfN7mff8ycOdO0T9K6Se0nqgsruH/UpPdrsHc/kwQAAACczDtTjlPhgw8+MCFeP/bRj3Y0jOvHQTrxwhPtNaohXlsvjRgxwnz0pBM5dAEBNXHiRBPidQT+1VdfNZNJdLlhncQBAAAA+AvbR+R1JrbSFcy0bksnhmjo1tubNm0aZ3trZTKd5KGzlbXloE4a0bBurVCmNOQ3aNDArBK2detW06cUAAAA8Be2BnldhEBLYZTVCtAqf9FFEDx59NFHTUjv3r27ma2t7QZ1hrauQKZLBesqaErbN40aNcpc60xmFg8BAACAP7E1yFshXmdkW31TrYUB4us13KpVK1m4cKGZuW2FfQ312jtUJ80qra3v1auXmSigPvvsM7OkcEpmNGsZj/UpAPxjCXjrmtcV8C28P/2L/v30NNcNgJ8Eeav9kvvEVWtVTmsJ4Nh0iWEN8ToCf/vtt5seorr4gY7KWyuS6f60xZN2s1m2bJkZtX/77bdj9BtNKl1wQVdTg3/QVfXcrwH4Dt6f/iehDnQAHB7ktXeqFbx1dF5bSFoj8Tlz5oyzvZbNaN9QbSk5evRocyKgk121S82iRYtMcLcMHTrUtBe85557TC9UbUWZEroccUIrDMKZtG+tzskA4Ht4f/qHvXv32n0IgN+zNchrWNelgHWC6++//y6NGjUy10pX3ozvY1ctidB6eH281tlbZ/16IqALHGjJjS4FrkHeKt9x7zOfHPqxoC7OAP9glXDpNa8r4Ft4f/oXymqAdNC15t577zV93v/zn/+YxaB0VTEdadfb1ZQpU2TXrl3yyCOPmJW7rKCuE1h1+7Vr15rt9CRA6VLG7777rrz00kuyePFiVz95Tx1wAAAAAKeyPchrzbuu/rZlyxbTP17P4HXJXmtEXoO91rhrEK9evbqMGzfO3K9h3qqn1Nr43r17m68fe+wx2bNnj+kr/8MPP5jbdKljXUQKAAAgrencuq+//lry5s1rcom78ePHy5UrV6Rr165SrFgx17bx0UYdOoip2+j8weeeey7OPEId9Dxz5ozJSnfccUea/V7wPbYHeV0Aavbs2bJ582Y5deqUqVvWf7CWxx9/3Exs1RCvNODr6q464VX/0eq22obSEhgYKGPGjJEnnnjChH3tH6/75CM+AABwK/z9999mhXrNJ7GD/KxZs+T8+fPSpEkTE+StbeOj8/80nGv3vZs3b5o1cnSxS4uWGGvu0fmG999/f5r+XvA9tgd5paU0tWrV8nif+z9W97CuHWsSUr58eXMBAADwdTp637Nnzzi3a5bRJh/auEPLib///vsY2Ui782mI15MGT/ML4d98IsgDAACkZ2FhYWYNnPjoSvUa5JcuXSqvvfaaGdRU+r11P9IfgjwAAPBpOuJ85fpNW3525qCMKS7P1ZJhbZftzlqsMinbKm2xrS1ZtZ32sGHDTFmOzh/UJh9aYrxp0yaz3X333ZeiY4SzEeQBAIBPh/gOH6+X3w6cs+Xn1yqeU756ql6KwryG7oTq35OybYsWLUyQz5Ytm9x5552yfPly+e6770yQ17IaXUhTu/rpnECkPwR5AADg01I2Hu6bde8ffPCB6VqTlG2VhniLls9okF+xYoUMHz7cVVbDaHz6RZAHAAA+S0fCdUTciaU1nureP/nkE49BPrEaeaXtJXUxwwsXLpi1cjZu3GhaUVpr7yD9IcgDAACfZlZZDyayhISESLNmzUxP+VGjRsmNGzekfv36ZjQf6RPvCgAAAJvFN9k19qJSWkajQT48PNx8T7ea9I0gDwAAYLP4JrvGXlRKF4TSMhzdPjg42HSzQfpFkAcAAPAiXVH+xRdflJw5c8a5r3///qYFpa7q6r5tfGLvQ/vHjxw5Ug4cOCD58uWT7Nmz89qlYwR5AAAALypVqpS5ePLwww8nedv4aJ08oDLwNAAAAADOQ5AHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAOxMquAAAAXrRv3z6ZM2eO5MiRQ/r27Zumz+2ff/4pixYtkrJly0qnTp1s2ceOHTtkwYIFMW4LDAyU7NmzS9WqVaVBgwbiD/70wnPtbQR5AAAALzpy5Ih89tlnUrhw4TQP8nrSoD+rSZMmSQ6XkZGRsn79evOYlO7D3T///GMeH5927drJ6NGjxen2pfJ5SgsEeQAAAIeqXLmyvPzyy1K0aNEkbb93717p0aOH5MuXzxXkk7uP+OTNm1cef/xx83VUVJT8/vvvsmzZMlm4cKF0795dKlWqJE5W2UvPkzcR5AEAAGyydetWWbdunVy+fFluu+02ueeeeyQ4ODjG6LmWcxw6dEjuuOMOqVixonz88ccmTGo4vnLlivkEIDQ0NMYI+erVq+X06dMSFhYmjRo1Mvs+duyYjBs3Tk6dOmWC9siRI+Wxxx7zuA+9X/exZcsWyZw5symP0TKZhOjP0pMES3R0tNx9991m39u3b3cFef2dFi9eLH///bcJ//fdd5/kyZMnyb/zL7/8Ij/88IM5EdHfSfev+yhdunSi+47vuUnK/Z6ep8Rewz/++EO++eYbqV+/vhQpUsSc2GTMmFEaNmxoTgxSiyAPAAB8mgbCa9eu2fKzNZAFBASkyb5fe+01+fLLL2PcpmF0+vTpkj9/fvM7d+nSxdSgq08++UQeeugh+eKLL+T22283oTZ2uceKFSukf//+cvPmTdc+3333XXnzzTdNbbcGSXXmzBnzuLZt25rQ676P69evy1NPPSVr1qxx7eP999+Xl156SXr27Jnk30/3c/HiRfN1tmzZzPWlS5fM7/TXX3+5tvvwww/l008/NYE9Kb+znhTo8S5btkyOHz9uttOQr89ZQvtO6Ll54IEHEr3fU2lNYq+hfgKij9FSJn2erX3rCdWMGTPMiUpqEOQBAIBPh3gNUxqC7KChbODAgV4P8zrirAEwKCjIhEQdPf7vf/9rwuIrr7wiU6dONeFVA21ISIgJs/pczJ49O8H96mM0LN5///1SoUIF13Hr5NNChQpJ165dzT4KFixoRs/1ttjPrd6vIT5Llizm50ZERJjbxowZY0a49Vg90ZF+HeVXGsi1tObChQtm0mu9evXM7R999JEJ2jpy3apVKzPqPm/ePHn11Vdl/vz5yfqdjx8/bp47/cRAR/6Tsu/4npvEnruUvoYWPS4d3a9WrZr5ffRESo+NIA8AAPxaWo2I2+nrr7821zrybU2Ibd26tdx7772ydu1aOXv2rCkhUc8884z07t3bfK1lIu+88068+y1ZsqR5/IkTJ0yg1fINLYnJlCmTuV/LPjRI5sqVK0YZjLsff/zRXOtxaemNqlOnjilj0RH1+IL8+fPn40x6LVGihBnR1jIV9dNPP7lu1/IVDeF6LDrKfvTo0WT9zhUqVJC33nrL9X1i+07suUns/pS8hpZixYrJ5MmTzb9lPbHR5+TcuXOSWozIAwAAn6XBR0fE/a20RoOmFUYtpUqVMiPRV69eNSHv5MmTrtstWh6TkBdeeMEc75IlS1yhWGu6NRhbE1ETo4Fc6Wi9pUWLFok+TgN+r169ZNeuXSbkavtNDaw1a9Z0bWOVwujxxXbw4MFk/c6l3LZJyr4Te26S+9wl5TW06MmF9e9ITy6seQipRZAHAAA+TQNQfKOiTqWlLRp4N2zYYMpClE4s1QCopRxaX62dZXQ0WSdTNmvWzGzz22+/JbhfDZFaSqIXLS3Ztm2bDBo0yIxoaz18Uk5KrBF37ZvesmVL87VO2NSJmzqiX7t2bY+P01F3q4ZeJ3fqz3300UdNvbj1GN23ltt069bNTP50p98n53cOCQmJc9wJ7Tux50Z/dkL3p+Q1tGj5jSVDBu+tx0qQBwAASAM6sm3VjLvT2m/trb5q1Soz4VFrqjWEWhNRtQ49a9asJhzqNlOmTJEDBw7IjRs3zPfx0XpynZSqNe3W99plRT/N0PCoQdaq99a6+MGDB5ugHZuGd/05WuOtI9lKu8ToCLLW2CeF1plryJ02bZr5REVH6HPmzCnNmzc3v6/+rjpp1DpB0+PSIJ2c3zkg1klJQvvW5/e9996L97nRbRO6P/ZJg0rKa5jWCPIAAABpQNsRelooqWnTpiYsa121TtB07w6jEyKHDBniCopa5qH3L1261IRNa4Tb06iuBlst7dARZfdSJB0N1rIRrc0uX768mcSqx6aTLe+8806PIXzTpk3y1VdfmZ9rhWHtoR67nCUhAwYMMCcAGsiHDRtmOrU88cQTsnHjRjPKbnV70d9F961lTMn9nd0ltG/dT0LPjZYBJfbcxZaU1zCtEeQBAAC83OlGw2N8dFKl6tevn2ljqPXYOhKsLRK1q4n75E3dVkO3BlwtV7HKTKzR3tiLFGkI19Fo3ad2RtFylxo1apgyEKWBVEfHtR2iBnrdp07udN+HnhC88cYb8sgjj5gSFx2N1taP8S2EpMetj9cRd3f6uPHjx7vqzcPDw01gnjVrlvz6669mFFtr0LVzi1WPn5TfuW7duubnlStXLsbP0/sT2ndiz01i93taECqx11Any+pjdLJr7OcrdvlPShDkAQAAvKhw4cLxdoSJTeuoNUDG185x5syZ5mstO9Gabe11boVB66RBL+40LCc0OVUDZMeOHWME4Nj7UNq5xX2xpPho8LZOTpKyDz1R0C44eknJ76wLS8W3SmxAAvtOynOT0P2enuvEXsMyZcqYS1Kfr+QiyAMAAPig9u3bm77kOsnUKnFRGgJ1Qqc/So+/c2oQ5AEAAHyQ1nXPmTPH1H3/888/ZgKmlnVoaYl7FxR/kh5/59QgyAMAAPiojBkzmhCrl/QiPf7OKeW9RpYAAAAAbhmCPAAAAOBABHkAAADAgQjyAAAAgAMR5AEAAAAHIsgDAAAADkT7SQAAAC/asWOH6YUeGhoqL7zwgmmnaPnoo4/k2LFj0qdPHylQoECi+9KFkebNmyfly5eXhx9+2Ouvk66c+tVXX8VYGVWPN1u2bNKoUSOpVauW138mvIcgDwAA4EUHDx6UL7/80nxdrFgxeeihh1z3LVmyRHbt2iVdu3ZNUpDXRZF0X02aNEmTIO9+rLF9/PHH0r9/f3nmmWe8/nPhHQR5AACANDJ+/Hi57777JHv27Cl6fLVq1WTYsGFSqFAhSUv58uUznxKomzdvyu+//y6LFy+WDz/8UB599FHJmjVrmv58pAxBHgAAII2cO3dOPvjgAxk8eHC82xw6dMiM1J84cUIyZcok1atXl2bNmpkylwsXLsjOnTslKipK9u/fL9OmTTNlL1qyY1m1apW5aBlM27ZtJSIiQhYuXCh///23Ceh6W2Kj/zly5DCfEljatWtngnx0dHSSjvXw4cMyefJkc9srr7xijl19//33sn79emnQoIG0aNEi0WPbs2ePrFy5Uk6fPi1hYWHSuHFjqVq1aoqe+/SAIA8AAHyahkkNsnbIkCGDK5QmV926dWXv3r3yxRdfSJcuXaR06dIea+C7d+8uV65ciXG73qbh3720plOnTrJixQo5c+aMGeWvUKGC2XbixImm1v2uu+4ywb9jx44m9LuXyHz66acJBuKTJ0/Ka6+9Zr6+ceOGbNy40Xz9yCOPuEbjEzrWQYMGyQ8//GACuB6bfpKgdERfw3nLli0TPTYN/c8991yMkwc9CRoxYoR07tw5mc9++kCQBwAAPktD3ZYtW0wItIOWxOioc0rCfJYsWeTZZ5+VV199Vd566y2ZMmVKnG2uXbtmQrDSk5U///xT5s+fL8uXL48zih8UFGRGyqdOnSpff/21CfIa9DXE6+i2Tk595513TFCuUqWKCdQ6gq4nEkOGDJFFixbFe6zh4eFxauV1RLxp06ZJPlb9eRrKdcReg7zW32uIz5s3r9SpUyfRY5s7d655vTt06CAVK1Y0J1HWawDPaD8JAACQRh588EGpVKmS/Pzzz7J69eo492s5jJa0PPDAAya8Fi5c2Nwe34mLjmgrLXvRMG2Fc328dptZs2aN+V6DvZavXL9+3QRynWCr5S/x0e21Fl8vWhrTpk0bOX/+vDzxxBPmRCEpx6onGWrp0qUxrlu1apWkYytbtqy5X+/TfRYtWtQcx7333pui5z49YEQeAAD4LB0J1xFxJ5bWWI/XYKwdZ3RUPjAwZvQ6deqUuV/LVnQU21P5jbuSJUtK7dq1TenLhg0b5JtvvjHHpycMSmvXlZa5xKYj4EWKFElSjby6ePGiOfnQkwUdRU/sWPUTAm2TuXv3bhP+daRe6eh7Uo7tP//5j3l+dET//fffN7drzf1TTz3lmoiLmAjyAADAp1m9zZ1KR7J1VFlrwGN7/vnnTSD/7LPPTPmJBmCd0GqVlcQ3Kq9BXuvHdST7jjvuMG0urdFuHc3u0aOHlChRIsbjihcvnqzj1lp5FRkZmeRj1VH50aNHm2008OsxWLX5iR1bcHCwvPjii+aiNfv6+IEDB8q4cePMiUr+/PmTdfzpAUEeAAAgjWk41c4yV69ejXG7BlalNeb6yYOW4LiHaE904ugbb7whv/32m/lea8rd75swYYIpvWnYsKEZ0VYakq1R+8Qmu2qdutay//rrr+Z7rb1P6rFqKcyYMWNMDb/7aHxix6blOm+//bZcunTJtf2RI0fMSYSexOniWoiLGnkAAIA0pn3gH3vssTi3d+vWzXzioKUlWiajAbdUqVKmM4yWsniiAVjbNiptRaltHS29evWSevXqme4x2uZRJ7D+97//lTJlypjAnNhkV73opFMrxGvAvueee5J8rDqxVVtNWtyDfELHpr+Tlu/ofq3j0Jp6vV0nw+rvibgYkQcAAPAindyqk0Zj16P37t3blIfoiLfVO11r57U0Zvv27WbyqNa/60i3lszo6H18C0LpSYEGYL09JCTEdbuOXGvnGO30s2/fPvO9lvZowPZEw7PuP3YZkwbocuXKyW233ea6L7FjdW+7+dNPP5nHak1/Uo9Ny4909H/Tpk2mxaZOhNWynPiOHQR5AAAAr9JuK7EnjqrMmTObfvKxabcWq2OLeymLJXY9udIg7elnWLT0RS+J0dp6q74+KRI7VmV159GFopJ7bNqzXnvmI2kYkQcAAECq6aTUzZs3m7IcPfl49NFHeVbTGEEeAAAAqaa18Vrq07NnT1Ne417yAz+e7Dpv3jyzWIC2MtIX/6+//op3W11VTM/4dPv69eubpYPXr1/vcVtdYEBrr1q3bp2GRw8AAADNXNoaU0tjCPHpJMivWLHCtDHSSQ+6gti6detMmHdvP+Tuvffekw8//NBsrxMhtI+qrjqmSwC701ZIL7/8slnMQGdTAwAAAP7E9iA/depUV0siXQFMZ0hrCyNtPxRf8LcCvYZ+7UmqS/zGXvZ40qRJsmPHjlvwGwAAAADpLMhrANdVu5SWyOisaV1IQFmLHMSWM2dOc62tiPTrLFmyxLhd6dLAH330kcdZ3gAAAIA/sHWyq64QZq0GZi27q8v3qqNHj3p8zKuvvir9+/c3wT8wMNA8/q677pL7778/RkmN3jd06FBTppMa2us1IiIiVfuA77CWmdZrXlfAt/D+9C/691N7kgPw0yBvLR6gCw/oxRxQ4L+HFHsJY/fJrjdv3jRfWycBWk+vdfC6YtnkyZPNQgWvvPJKsvqiJvSpwc6dO1O9H/gG6wQxvhNFAPbh/el/ElpJFIDDg7z1Btdgbp25a3BWuqJYbBrcn3vuOVNDrzXyuqLY2LFjZf78+fL2229Ljx49ZOLEiVKzZk2zjLA3wlpQUJBZOQ3+RdtjVahQwe7DAOAB70//sHfvXrsPAfB7tgb5PHnymPCuIV470Oj3p0+fNvdZSxe7O3TokCnHKViwoGk/qXSFNA3yutzvt99+66q71zCv+1Ua6GvUqCGzZs2SihUrJusY9fh0CWH4B+sEUa95XQHfwvvTv1BWI/Lzzz+b7npaOaBz+3QAUls0WjSvfPnll/E+h7qtrqI6e/ZsU7nw2muvuSoXLDqwqdlJW21rW26kL7YGeV2qWP+BautIDeMPPfSQ6VyjPC3dmy1bNnN94sQJWbt2rVlsYMmSJa7gbwV3DfPWyL57nbtVkgMAAJBWoqKi5Nlnn5WlS5fGue++++6TMWPGmBMdHaDUtXQS0rRpU1m0aJHJNc2aNZPGjRu77tOByo8//th8/dhjj6XBbwJfZ/vKrhrehw0bJu+++64pk9HQnSNHDlf3mmeeeca0mRw1apS0aNHC/CPWFpT6D1bPTq1w3rlzZ7MAQe/evV37PnbsmDlD1Y9pFy9ebE4cAAAA0tLKlStNiA8LC5OuXbuaRh5///23GVnXPHLvvfeaPGPR+7WRR2wlS5Y0+9AVU7XN9vfffx8jyFsnCloqWrp0aV7UdMj2IK//wC9cuCDTpk0zC0JpH/nhw4dLrly5XJNedTTdmtj6zjvvyPjx483ZqW5fvHhxeeqpp+See+6JM7HGWlVMz3qtNpUAAABp6eDBg66A3adPH1c2adSokSkRLly4cIztdQBTV0SNjw5KapDXgUzNSNb+rCCvo/xIn2wP8urJJ580F/3YSCeXutNVXDXEW7WTWtf80ksvmYuOxlvdbjzRN8rmzZslQwbb170CAAAppaWz121qBR0UqiOCyXqI1rbrIOL69eulefPmpgGHBvU777zT4/Ya7nWV+9h0oLJo0aJy9913m6oCHfhcs2aNabutZcY6P1B/jgZ9pE8+EeQtsUO80gDvqYONSijEK0biAQDwgxA/rYXIoQ32/PyidUUeW5KsMF+1alUZMGCAjBs3To4fP26qCbSrXvv27U0JcOyGHuHh4R5r5TX8a5DXqgItH9bSmu+++84EeR2N13JkPWnQJiBIn3wqyAMAAMTlvIWlnn76aVPbrpUFWhajZcLaPW/hwoUyc+ZMqVSpUqI18u7r4Wj5jAZ5rb/XxdOsshpG49M3gjwAAPBdOhKuI+IOKq1xH5nXrjI60VXnAmqb7MuXL5twryP0Sa2RVzrJVbv3Xbx40Yzea+mwtqJs2bJlio4N/oEgDwAAfJsG6WDnNK346KOP5PDhw2YUvV69elKqVCl54403pESJEqbMRmvik0snuGq9vbbr1vaV2uKyYcOGruYgSJ8I8gAAAF6kIVtHzbXDXp06dcxiULrwpU5+VRrukzLZNX/+/DFKbrQ1twZ5LdNRdKsBQR4AAMCLtNuMLtak9fDaZcad9pDXNXKSMtlVF810D/J6UpAnTx6zkqu22NZuNkjfCPIAAABepF31Ro4caUL47t275ezZs6Z9tk5wde8hrzX0WnITH62dj71fLavRsh0N9FmzZuV1S+cI8gAAAGlAS2P0Eh9tLamX5IhdloP0jZWSAAAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAdiZVcAAAAvi46Olh9++EE2btwoly5dkrx580rt2rWlQYMG5v7w8HB5/fXXE9xH+/btJUeOHPLpp59Kvnz55MUXX3Tdd/78eXnnnXckMjJSChYsKM8995xkyJDw+OyuXbtkypQpkitXLnnllVc8brNlyxb5/PPPY9wWFBQk2bJlk6pVq8q9994rGTNmTMYzgbREkAcAAPCimzdvSp8+fWT16tUxbv/oo4+kefPmMn78eLly5Yp88803Ce6nevXqUqBAAbNdyZIlXUH+8uXL0rt3b9m6dauEhYXJF198kWiIVydPnjT7Kly4cLxB/siRIwke1+LFi+Xjjz9O9Gfh1iDIAwAAeJGOxGuIz507t3Tr1s2Mpv/9998yY8YMWb58ubm/YcOG8vbbb7seM2zYMImIiDAnACVKlDC36Qj4vn37Yuz72rVrZhsN8aGhoTJ58mQpXbq0118/PYEYOHCg+ToqKko2b94sc+fOlVWrVsnvv/8uNWrU8PrPRPIR5AEAALxIR7WVBuwePXpI5syZzfca3nVUvHjx4ua2+++/3/WYN9980wR5Lb2pVauW63b3IH/jxg0ZMGCA/PLLL6bcZcKECSbspwUtpXE/Pi3zWb9+vRw6dEj27NlDkPcRBHkAAODz9eZXblyx5WdnDswsAQEByXqM1sLrY3799Ve5++675eGHH5auXbtKvXr1UvUcaDnMypUrzffDhw931dvfClrnf/bsWfN1zpw5b9nPRcII8gAAwGdpgO3+fXfZcmqLLT+/Rr4aMqPljGSF+cqVK8sLL7wgY8aMkTNnzpiaeK0rb9u2rTz99NNSpEiRZB/H/v37zcWipTUPPvigpJXjx4/Lf/7zH1c5z59//mlq87VcqH79+mn2c5E8tJ8EAAA+Lbkj4r6gV69esmDBAmnZsqXp8qJheN68eXLffffJH3/8keL96gi/0np1HfFPKxcvXjSTXvWydOlSOXr0qCmnmT59umTNmjXNfi6ShxF5AADg0yFeR8SdVFpjue2222TcuHGmrlxbSC5atMgE5A8//DBFnV+0Pl4nuupJwpo1a2TIkCHy9ddfS6ZMmSQtJrtqS0ttWantKLNkySJPPvmklC9f3us/CylHkAcAAD5Ng3RoUKg4xQcffCAHDhyQNm3ayJ133ilFixY1oTt//vzy7rvvumrNk0M72WiIV4MHDzZlOlpqM3HiRFd3GW9Pdm3Xrp35uk6dOtK3b1/z8/UERH8n+AaCPAAAgBcFBwebkpTvvvtOatasKXny5DG18r/99pu5PyWTVN0/FShVqpR0795dpk6dai6tWrUyo/9Jde7cOVf9uzsdcfekadOmprZfT1C0l71+CqAnJbAfQR4AAMCLnnjiCTlx4kScOnYN4zrKraE4tZ555hlzsqDtLHWEXn9WUldc1TaXnhZ9euCBB+J9jIZ8rZXX1pP683SFWNiPIA8AAOBFusrqa6+9ZspR/vrrLzMarzXmFStWlLx583p8jLaTjIyMNKPtsTvg6MJRWuriTvenZS579+41358/f950lEmIjtq7L0IVW9myZc2kXN0me/bsMe6z+tZv2fJv96Dw8HDJkSNHIs8E0hpBHgAAIA3kypXL1JcnhXa3iW/SqfvCTO4qVapkLmrhwoVmAmx8dLR+9OjR8e7LXeHChT3ergtZ6QW+gyAPAADgcNrS0lO5TOwgD/9CkAcAAHA4rb2vVq1aguU+8D8EeQAAAIerWrWquSB94fQMAAAAcCCCPAAAAOBABHkAAOBToqOj7T4EwFZJfQ8Q5AEAgE/QXuXWgkVAehbx/+8B6z0RHya7AgAAn6AtEsPCwsxqpSo0NNSshgqkp5H4iIgI8x7Q90Jiq/US5JHu3iBRGaPk6s2rEnGdER/Al+j7MlooqUjvdAEkZYV5ID0KCwtzvRcSQpBHugrxw3YPk4PtD0rPLT1F/l1lGoAPydQkE/XR6ZyOwBcsWFDy5csn169ft/twgFtOy2kSG4m3EOSRrgQIH9ECgBNokElqmAHSK4I80tUoz9DyQ+WlIS/J8OHDpWLFinYfEgA3O3bskGGvDpOAFpxwA0BSEOSR7sJ8hpsZJCRjiIQGhdp9OADc6PuST80AIOkI8nCMo0ePprol2ZEjR1zXISEhKd6PdlIoVKhQqo4F8DepfY966/2peI8CSA8Coll1IV7btm0z11WqVLl1rwjiDQhPPvmkTz07kyZNIswD/4/3KGLjbyiQ9hiRhyNYo3zPP/+8FClSJMX7uXr1quzcuVMqVKiQ4hG/w4cPy7vvvsuCJYCX36PeeH/yHgWQnhDk4SgaEMqUKZOqsBEZGSmlSpUyH70D8J33KO9PAEieDMncHgAAAIAPIMgDAAAADkSQBwAAAByIIA8AAAA4EEEeAAAAcCCCPAAAAOBAtJ9EOhMtGTJcEZHL5uuUCAiIkEyZbpjrf/cDwDvvi4gUvy8BID0iyCMdiZZMmZpJjRq/pGovpUuLzJunXy3x1oEBjueN94Uu7VC+fDURWevNQwMAv0VpDdKZALsPAAAAwL9G5P/55x85c+aMWREwLCwswW2joqLkwIEDcv78eSlevLjkypUrzjZHjx6VEydOSLFixSR37txpeORwjgCJjFwuu3f/LuXLl0/xyq779u2TQYMGyejRo6W0DkMC8Mr7Qld23b37gFSowAk3ADgiyF+7dk369+8vq1atMt8HBwfL4MGDpUuXLh63P3TokPTt21d27dplvs+YMaN0795dXnrpJfP92bNnzdc//vij+T4gIEDat28vr7/+ugQG2v7rwnYBEhWVWUSy6Af5KdpDdHSoREYGmut/9wPAO+8LDfCEeABIKtuT7ZQpU0yIDwkJMaPne/bsMaG7Tp06UrJkyTjbjxw50oT4nDlzSokSJeSPP/6Q6dOnyx133CF33XWXeayG+KxZs5pRoW3btsn8+fPNvnr37m3L7wjvyJw5s1y5csV8EpNSV69eNSePFy5cMNcpocegxwLAu+9Rb7w/eY8CSE9sD/ILFiww1++8847cc889ZrR9+fLlsnjxYunXr1+c7a2R+Hnz5kmRIkVk/PjxMnHiRNm5c6fUq1fPPFZ9/vnnUqFCBZk8ebKMGTNG1q1bR5B3OH09//77b3NJrZMnT6b6WACkzXs0te9P61gAwN/ZGuQvXbokBw8eNF/riLqqW7euCeM7duzw+Jjq1avLsWPHZPbs2XL77bfLTz/9ZG6vUaOGGc3RkhwdzbH+Ey9QoIC51hF/OJuerHXo0EGKFi2a4n1cvXJFDuzbLcWLl5CQkEwp2sfhI0dk3uyZEnDjisg12k8CSt8Pf+/eLh3bt5EihQun7P15NVL+OXRUSpYqlar/s7UEc9asWbwwAPyerUFeJ7dadezWBNfs2bO7at090dIZnciqJTkWrbGvX7+++frVV1913a4fzc6cOdN83bJlyxQdY3R0tJmABXvpSZp+ZK//VnQeRYpER0uWLx+QAsd+S9Wx6L/UmbeJyJx/P/0BIFLael8sTN37ImvOyhJZblHK3+f//zdF/7/Q/zf4/9s++vdTXwsAfhrkb9y4Ya4zZPhfF0zra+u+2HSUZevWrSb4a8carYHXUN+oUSOpWrVqnEm0uq2G/Pvvvz9Fx3j9+nUzEgx76cmb1d0oMjIyZTuJjpbyVyMlyLuHBsDL9u/fr2nc3v8v4BWpOSED4ONBPkuWfzsb3Lx50wTmoKAgM4rifl/sUhyth9ePXL/55hvJly+fzJ07V4YMGWJq5a1Reh2B6dOnj6xfv96U3HzwwQcpHhXQY9KWmLBXpkz/lsHopOVSpUqleD9XSiySv/btkmLFi0vmkJRNWP1n/z8ydOhQGT58uJQsEXdCNpAeeeN9ceXqFdl/+ISUKFkyVRPKvfX/BVJn7969PIWAPwf5vHnzmrN1HT3XWnntMqO1jUpH22PTvvC6bZ48eUyIV1a/Yr1P6f1PPfWUbNiwwdTbf/TRRynuF670BCA1j4d3WPWyep3a1yMqMLNkzp47xfvJlPW8REZllExZc0poWJ5UHQvgL7zyvtAyxoCTJsSn5n3uzf8vkHKU1QB+HuS1B3zt2rVl7dq1pmtNq1atTKtI1aBBA3OtZS3nzp2TcuXKScGCBc1/zKdPn5YRI0aYkhlrFF7vV6NGjTIhPlu2bKa//JYtW8zt2o7SvfQGAAAAcDLb209qHfvGjRtNL3lrUSgN3M2bNzdfa+vINWvWyNixY6V169YyYMAAs3Kg1spbXQm0DEfbVh4/fly+/PJLc9vFixdNeY2lUqVKrpMEAAAAwOlsD/LaTlLDt/Z915H2ihUrSq9evcxovdLvtYZey2nUY489ZoL+okWLzPa6KFS3bt2kUKFCZiReR/g98bS4FAAAAOBUtgd5K6y/+eabHu97/vnn49xWq1Ytc4lNV4PVCwAAAODv/tf3EQAAAIBjEOQBAAAAByLIAwAAAA5EkAcAAAAciCAPAAAAOBBBHgAAAHAggjwAAADgQAR5AAAAwIEI8gAAAIADEeQBAAAAByLIAwAAAA5EkAcAAAAciCAPAAAAOBBBHgAAAHAggjwAAADgQAR5AAAAwIEI8gAAAIADEeQBAAAAByLIAwAAAP4e5G/evClz5syR77//Ps59ffr0kZEjR8qFCxe8eXwAAAAAUhvkX331VRk6dKhs3Lgxzn3Xr1+Xzz//XB599FEJDw9Pzm4BAAAApFWQ//HHH+Xbb7+V0aNHy5AhQ+LcP3nyZPnqq6/kzJkz8sknnyT3OAAAAACkRZBfsGCBPPnkk9KuXTsJCAjwuE3lypXljTfekHnz5iXnGAAAAACkVZA/ePCgNGrUKNHtdJtr167J+fPnk3ssAAAAANKiRj6+kfjY22TOnFmioqKSs2sAAAAAaRHkixcvLlu2bEl0u/3798ulS5ckZ86cyTkOAAAAAGkR5Fu1amUmtJ44cSLB9pRvvvmm3H333UkavQcAAACQxkFew3mpUqWkY8eOMnv2bDl+/LjrPm03uXz5cunatav89ttv8swzz6TwcAAAAAAkRWCSE3+GDPL+++/LoEGDZNiwYeYSFBRkRt51cqvSoD916lQpU6ZMUncLAAAAIC2DvAoLC5NJkybJ5s2bZcWKFXL06FEzqTV//vzSsGFDqV+/vgn3AAAAAHwoyFtuv/12cwEAAADg40F+9erVcvny5Ti3a2lNpkyZJHfu3FKxYkUJDg729jECAAAASGmQHzlypFkUKiGhoaFmouvjjz+e1N0CAAAASMsgP3r0aLl69Wq8bSfPnTtnOtbohFjtIf/ggw+m5HgAAAAAeDPIJ6Umvm3btnLHHXfIhAkTCPIAAACAL/SRT6p7773X9JiPiIjw9q4BAAAApFWQ137z2qZSF4kCAAAA4JAgr4tDnT171tTJAwAAAHBIkJ81a5ZZ4TUkJMTbuwYAAACQ3Mmu33//vVy6dCnerjUXLlwwXWu037x2rgEAAADgA0F+7NixifaRL1y4sIwaNcpMeAUAAADgA0F+/PjxEhkZ6fE+LaPJlSuX5MuXz5vHBgAAACC1Qb5ChQpJ2u7w4cMyZ84c6datm+TPnz+puwcAAACQDEkO8gmJioqSn3/+Wb744gv56aefzPcdO3b0xq4BAAAAeDvIa5vJ//73v/Lll1/KoUOHJFu2bNK+fXtp06aNFC1aNDW7BgAAAODtIL9lyxYz+q6dbLRvvBoxYoQJ8cHBwSnZJQAAAIC0CPJXrlyRxYsXmwC/Y8cOM7m1S5cuJrwPGDBA6tatS4gHAAAAfC3Id+rUSY4cOSJNmjSRfv36SePGjSUw0Csl9gAAAADSamVXLaHRLjR6yZw5s2TI4PVFYQEAAAAkUZKH1LWl5KJFi8zk1mnTpkmBAgWkbdu20q5du6TuAgAAAICXJHlYPWfOnNKjRw/55ptvTJeahg0byueffy6tWrUyHWvWr19v6ugBAAAApL0U1cdUr15dRo4cKWvWrJE33nhDqlatKkOHDpV69eqZia/azeb69eveP1oAAAAARqoK3bNkyWIWfpo7d64Zqdevf/nlF3n22Wfl6NGjqdk1AAAAgAR4bcZquXLlZPDgwWaF17Fjx5rFoQAAAACkDa/3j9QFoVq3bu3t3QIAAABwQw9JAAAAwIF8YkWnM2fOyNdff22uK1asKC1btkywT/3+/ftl1apVcv78eSlZsqTpnKOfBKR0fwAAAIDT2B7kdVKsrhp76tQp121LliyR8ePHe9x+9erV0rdv3xhdcaZOnWpaYoaGhiZ7fwAAAIATJXuYeunSpSZMx/byyy/Lhx9+mOxe8h988IEJ3bfddpv07t3bhHH9GevWrfO4/YQJE0yIb9q0qTz33HNSqFAh2bNnjyxevDhF+wMAAAD8PsiPGjVK+vfvLz/88EOc+/7++28ZN26cPPHEE3L58uUk73PlypXm+vXXX5fnn39eOnToEOP22M6dO2eutX/9U089JV27djXfnz17NkX7AwAAAPw6yG/YsEE+++wzM/I+ZMiQOPdracu0adPkr7/+kunTpydpn6dPnzZ17qps2bIxrvXEwBPtVa+efPJJcxxTpkyRrFmzmjr5lOwPAAAA8Osa+a+++kp69eolPXr0iHebBg0ayIgRI8xF69gTc/HiRXOtE1EzZ85svtZSGHXhwgWPj+nWrZsZXd+6dav8+eef5rZ+/fpJsWLF5J9//kn2/hITHR0tERERKXosvOfq1auu69S8HlbpV3JLwNLiWAB/4o33hTfen946FqSe/v0MCAjgqQR8IchrSNYQnZjmzZvLiy++aEJ6UheF0je7JSoqylzH9+bXchkN8XfeeadUr15d5s2bZ+ri8+fPL7Vq1Ur2/hKj9fg7d+5M0WPhPdZKwfrvMDIyMtX7085HvnIsgD/w5vsiNe9Pbx8LUse9oxwAG4P8zZs3JTAw8c11NFxLXfQ/z8SCfI4cOWKMeuvo+aVLl2Lc5+7kyZOm7WTOnDnNxFo9Hg3zPXv2lDlz5sjdd9+drP0lRVBQkJQpUyZFj4X3ZMqUyVxru9FSpUqleD860qchoUSJEq5Pbew6FsCfeON94Y33p7eOBam3d+9enkbAV4K8lq5s375dKlWqlOhISHh4uOTOnTvRfebKlUvCwsJMXbvuu3bt2uZalStXLs721iRaPUnQj0z1hMF9Ym1y95cUOpJvlefAPiEhIa5rb7weGhJSuh9vHwvgD7z5vkjN+9Pbx4KUo6wG8KEgf88995iuNFo6oyPinuhI+DvvvCONGzdO8htY96f19y+88ILcfvvtplWk0kWclI6079u3T9q3b29aShYsWFCOHTtmutVUq1ZNli9fbrarW7dukvYHAAAApKuuNRqENcBrgNYFltxHwm/cuCGbNm0yfdu1NeXTTz+d5AN49tlnpXTp0iacf/vtt2ZfWipTtWpVc78Gde2Wo7WOWrYzZswYyZs3r+kdr4FdR9+1Nr5Pnz5J2h8AAACQrkbktR5dJ5UOGDDAXDJmzGhKWTRcaw93nRSqE04nTpwoVapUSfIB5MmTRxYuXCg//vijWchJS3d0pN2iJw6NGjWSihUrmu81tGu41wWezpw5Y2optYTG+gQgsf0BAAAA6SrIKw3qs2bNMiu7rlixwtTDa1eYO+64Qxo2bGjKWrJkyZKiWe36WE+aNWvmsX7Smtia3P0BAAAA6S7IKx2J1xCdUJDWchcdwdfJqAAAAABsrJG3bNmyxfRuX7Nmjak/j239+vXStm1bU/YCAAAAwOYRee3Lrqu1rl271nVb2bJlZfr06WbyqXaseffdd2XKlClmJD4lJTYAAAAAvDwiP23aNNm8ebP0799fpk6dKsOHDzert77++uvm/rFjx8rkyZOlZs2asmjRIjPpFAAAAIDNI/K//PKL6VajrRwt2g2mc+fO8t5775mg/9xzz5kWlNrJBgAAAIAPBHltMVmnTp0Yt1WoUMGsmvfpp5+a0fj69eunxTECAAAASGmQ1z7xnures2XLZsptCPEAAADAreOVGpi6det6YzcAAAAAbmWQ197yAAAAAHx0Qah169bJX3/9FeO2K1eueLxdS220fh4AAACAzUF+2LBhSb592bJlUrx48ZQfGQAAAIDUB3ntF6+j70mVL1++JG8LAAAAII2CPBNaAQAAAIdOdv3xxx+lS5cuUq9ePenUqZMsXrw47Y4MAAAAQOqD/KZNm+Tpp5+WQ4cOSfny5eXcuXPy/PPPy8yZM5O6CwAAAAC3urRm9uzZ0rx5cxkzZowEBQVJdHS0jBs3TqZPny7dunXz1vEAAAAA8OaI/L59+6RXr14mxKuAgADp06ePnDhxQsLDw5O6GwAAAAC3Mshrx5rs2bPHuC04ONh0p7lw4YI3jgUAAACAt4N8VFSUGYWPLTAw0NwHAAAAwEe71gAAAABw4Mqu2rnmwIEDcUpuPN1eu3ZtyZw5s3eOEgAAAEDKg/wrr7yS5NuXLVsmxYsXT87uAQAAAHg7yA8ZMkQiIiKSurnkzZs3ydsCAAAASKMg37hx42TuGgAAAEBaYbIrAAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwoEDxAStWrJDp06fLmTNnpGLFijJw4EApUqRInO0OHjwoPXr08LiP/Pnzy+zZs+XmzZsya9YsWbp0qZw/f15KlSolvXv3lipVqtyC3wQAAABIJ0F+3bp10rdvX4mOjjbf//PPP7J161ZZvHixZM6cOca2169flyNHjiS4v4kTJ5qLZe/evfLzzz/LwoULpUSJEmn0WwAAAADprLRm0qRJJsR37txZ5s6dK8WLF5fDhw/Lt99+G2fbYsWKyQ8//BDjUrlyZXNfixYtzLX1uNdee8183bhxY7ly5YoZ9QcAAAD8ha1B/saNG/Lbb7+Zr5944gmpVq2atGvXzny/cePGONsHBQWZkhvrsmHDBvnzzz+lZs2a8sILL5htQkNDzfXtt98uZcqUMScG7rcDAAAA/sDW0pqTJ0+achlVsGDBGNeJldBERkbKmDFjJGPGjPL6669Lhgz/npO8+OKLMmDAAOnQoYNkz55dzp49a4K+dYIAAAAA+ANbg7yWvCgN44GBga5RdxUREZHgYxcsWGBCeps2baR06dKu28PCwiRnzpwSHh5u7le5c+dO8TFq2U9ix4K0d/XqVdd1al4P69+cdW3nsQD+xBvvC2+8P711LEg9/fsZEBDAUwn4a5C3Qrt2mrHe8Fpuo4KDgxN87BdffGGuu3fv7rotKirKTJzVGnutka9du7aMHz9eli1bJvny5ZMhQ4Yk+xj1E4OdO3cm+3HwrqNHj7omQ+unMam1f/9+nzkWwB94832Rmvent48FqZPY33IADg7y7iPl586dk1y5crlG0TV4x+f48eOye/duKVy4sFStWtV1+6FDh0yIL1CggDz88MOu2vvly5ebevqUnmxorT3slSlTJnNdsmRJ01I0pXSkT0OCdjCK3RXpVh8L4E+88b7wxvvTW8eC1NOucQD8OMhnyZLF/Iet/3HrqHnHjh1l1apV5j73gB7bmjVrzHXdunVj3B4SEmKuT58+bSbBakcba9uUltfopwRMlLWf9drqtTdeDw0JKd2Pt48F8AfefF+k5v3p7WNBylFWA6SD9pOdOnUy10OHDpVatWrJr7/+av7j1dp3NWjQILnrrrtk5cqVrsfs27fPXFeqVCnOolD16tUz5Tl6UqBBX0trVPv27W/hbwUAAAD4eZDv2bOnuWgdnU5K0pKacePGmVBuja5rBxv3yU8nTpww19Y27t5//33ToUYn0Gq5jnau0U42dK0BAACAP7F9ZVdtG/nSSy/Jc889ZzrN5MmTx9VKUo0ePdp0HtD6ecvgwYNl4MCBkjdv3jj70641+pg333zT7M/9cQAAAIC/sD3Iu09O8jTBVYN9bEmpd9cReUI8AAAA/JXtpTUAAAAAko8gDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBAu0+ACA59u3bl6on7OrVq/L3339LpkyZJCQkJEX7OHz4cKqOAfBnqXmPeuP9qXiPAkgvCPJwhKioKHM9YcIE8RWhoaF2HwLgM3iPAsCtFxAdHR0tPuDs2bNy7tw5KVq0qAQHB3vc5tq1a/GO9gQFBUmZMmVibKujMrlz55YcOXKk6Ji2bdtmrqtUqZKix8O79uzZIxkypK4aTP/96MlA3759pXTp0qkK8YUKFUrVsQD+JrXvUW+9PxXvUfvxNxRIByPyN27ckCFDhsiCBQtEzymyZ88uw4cPl1atWsXZ9tChQ9KuXTuP+ylcuLCsXLnSfD1v3jx5++23JTw83Hz/wAMPyMiRI1MdAmGvcuXKpXof+tG99e/F/cQPgP3vUd6fAJA8tifbmTNnyvz58yUgIEDy5s0rFy5ckEGDBsmRI0fibKt1k7fddluMS65cucx9GTNmNNerVq2SwYMHmxCvI6Ya3nX/n3/++S3/3QAAAAC/DfJfffWVuR41apSsWbNGGjVqZMpivvnmmzjbFilSRBYtWuS6fPHFF2ZClIb1V155xWwzZcoUc/3000+bUP/JJ5/IHXfcIREREbf4NwMAAAD8tLRGw7V2KFAa4FXjxo3l559/lj///DPRx48dO1aOHj0q3bp1k6ZNm8r169dl69at5r4OHTrIiRMnpGrVqmbUHwAAAPAntgb506dPm7p4LavJmTOnuc2amKr3JeT48eMyZ84cCQsLk2effdb1GA3zur833njDjMirNm3amO9T0s5Mj4/RfP8RGRnpuuZ1BXwL70//Yv19B+CnQV5Dt9LSGOvNbtW6a3lNQj777DMzUVZH47NmzRrjj4D+57F69WopUaKE6VyjZTpaf6+19yk5xp07dyb7cfBN+gmO+zUA38H70//E14UOgB8E+cyZM5vrmzdvmlAeGBjo6lqQJUuWeB+nQX3hwoUm/GsJjae+3m+99Za0b99e1q9fLz169JDvvvsuRUE+dltL+AedCF2hQgW7DwOAB7w//cPevXvtPgTA79ka5PPly2eCso5660hMsWLFXN1qdGJrfLZv3y5nzpyRatWqSYECBVy366i7hnktmbDaoFWvXt1cW60ok0tPFlj4x39o5yPrmtcV8C28P/0LZTWAn3et0RH4GjVqmK/HjRtnJrlqNxpVr149V+94LW3RtpSWX3/91VzXrFkzzn8a1qTZd999VzZt2uRaCdQbPcgBAAAAX2F7+8k+ffqYuvjFixfL448/bkbky5YtKy1btjT3Dxs2zCwCpSHfonXv8YXzAQMGSLZs2WTt2rXy8MMPm3aUun9rQiwAAADgD2xf2VVH3qdNmyYzZswwXWcqVqwo/fr1c02Q0XIbXfhJV3yNvTBU0aJF4+xPl/WeO3euTJo0Sfbv329KdLp3727KcAAAAAB/YXuQV3Xr1jUXT4YOHRrntsQmrZYqVUpGjx7tteMDAAAAfI3tpTUAAAAAko8gDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwIII8AAAA4EAEeQAAAMCBCPIAAACAAxHkAQAAAAciyAMAAAAORJAHAAAAHIggDwAAADgQQR4AAABwoEC7DwC4laKjoyUoKMhc37x5kycf8CH6vgQAJB1BHukqJFy4cEEGDBggZ8+elTVr1th9SABi6dKlC4EeAJKI0hoAAADAgRiRR7oREBAg2bNnl6FDh8rw4cOlYsWKdh8SADc7duyQMWPGSLVq1XheACAJCPJId2H++vXr5jpjxox2Hw4AN/q+BAA4LMhfunRJlixZYuqWK1SoII0aNfK4nd4/a9Ysj/dly5ZNevToEeO2a9euyZQpUyQ0NDTOfQAAAICT2R7kT506JZ07d5YjR464bnvggQfkrbfeirPtuXPnZMKECR73U7hw4ThhXbedNGmSx/sAAAAAJ7M9yH/wwQcmxJcoUULq1q0r8+fPN5cHH3xQatWqFWPbnDlzSt++fWPctmzZMtmzZ4/kz58/xu1//vmnTJ069Zb8DnBW55qogEC5eiNKIq7dsPtwALjR9yUNKAHAQUF++fLl5lpH4G+//XbJkCGDfPHFFyagxw7yuXLlkn79+rm+37dvn3zyyScSFhYmY8eOjVFS8/LLL9PCLB06cOCAaTEZX4jv//UB2V/xcekw55CI6AWALwkp1kb27Pkrwf+/ddJ68eLFb+lxAYAvsjXIa827XtRtt90W41pDemK0+4iG9hEjRkjBggVdt0+cONGM0vfu3dsEfaQP+m+pYcOGEhUVFe82GVu8KBnylbmlxwUg6SKuXJF+/WJ+8hqbTlTfsmWLGdwBgPTM1iAfHh5urnUUXiekKuvaui8+mzZtko0bN0r58uWlXbt2rtu3b99uJrjWq1dPOnXqlOogr6NCERERqdoHbo2QkBDzCc/Fixfj3ebKlSuye98/UqJESbO9J9myZpUiRYum4ZEC6dPhQ4fk4qVL8d5/9epVOXIgTEr3nBPv+9NqbqD383+zb9O/n3QiAvw4yHv66NS6LbE3/4wZM8z1448/7tpW2wpqSU1wcLCMHDnSK6U1us+dO3emej+4dfTEMD5ZsmSR26tWTvDxN69dkQP79qTBkQEIDY6/7WtocBbJVSXh96e6fPky/y87hP49BuCnQV7rHJWWQuhIjI6w6H/Q7vd5otuuXr1aMmfOLM2bN3fdPmfOHNm9e7dUrVrVTJi1aqX1WifV6gh97EmxiQkKCpIyZSjF8Bc6Ir9//34zuVr//QDwHbw//cvevXvtPgTA79ka5PPkyWMCuwZtHfWuUaOGCeIqofC8YcMGUxvftGnTGGHs9OnT5vqPP/4wF4uWWmgryiZNmiQ7yOtov1XuA/+h/254XQHfxPvTP1BWA6SDrjUaxhctWiQvvfSSq/2kskba9b6DBw9KixYtpFy5cuY2K6TryLs7fXxg4P9+JT1B+Oyzz0w95aOPPir58uW7hb8ZAAAA4MdB/rnnnjMTV7XcQS+qQ4cOrtaTX3/9taxZs0ZKlSrlCvLHjh0z11oe4U4nuOrFcvjwYRPkddTfvW0lAAAA4HS2B3ltG6lhfenSpaY0pmLFitKoUSPX/W3btpXq1atL2bJlXbc1aNDAPK5SpUoJ7lsDvC4gpSPyAAAAgD+xPcirrFmzmpVcPbn//vvj3Na6desk7ZeReAAAAPir+Pv0AQAAAPBZBHkAAADAgQjyAAAAgAMR5AEAAAAHIsgDAAAADkSQBwAAAByIIA8AAAA4EEEeAAAAcCCCPAAAAOBABHkAAADAgQjyAAAAgAMF2n0Avuz69esSHR0t27Zts/tQ4CX6eqq9e/dKQEAAzyvgQ3h/+pdr167x/yyQxgjyCSDo+edrGhwcbPdhAPCA96f/vZ78HQXSVkC0NQQCAAAAwDGokQcAAAAciCAPAAAAOBBBHgAAAHAggjwAAADgQAR5AAAAwIEI8gAAAIADEeQBAAAAByLIAwAAAA5EkAcAAAAciCAPAAAAOBBBHgBgmyNHjvDsA0AKBURHR0en9MGALzp48KBs27YtSdsWK1ZMqlSpkubHBMCzhg0bSr58+aRt27bSqlUr8zUAIGkI8vA7s2fPlmHDhiVp286dO8uIESPS/JgAeNa8eXNz8q0yZMggderUkfvuu09atGgh2bJl42kDgAQQ5OF3fvzxR/nss8+StG2TJk2kW7duaX5MADy7fv26rF+/XpYvXy4//PCDnDlzxtweHBxs3p8a9O+8807JkSMHTyEAxEKQBwD4hKioKNmwYYO89dZbsnv3btftWbNmlTFjxkjTpk1tPT4A8DUEefi9/fv3y+LFi+Xs2bMmKOjH9zdv3pSTJ0+aGvmXX37Z7kME0rVr166ZUfklS5bIypUr5fz58+b2sLAwc9H3cP78+eWnn36y+1ABwKcE2n0AQFq6dOmSdO3a1YT4+GrkAdhH57PoifbFixfN90FBQXLXXXdJu3btzAi8ltho2U3fvn3NNtTNA8D/EOTh13799VcT4vPmzWu6Y+zZs0fuvvtumTx5stSvX5/ReMBmGtI1oFeqVMmEd53omitXrhjbaJ18aGio+TQNAPA/BHn4NWviXKNGjaR///7y1FNPyTPPPCORkZEyadIk+f33302gB2CPRx991Iy8ly1bNsHtvv/+e8mSJcstOy4AcAKCPPyaTpKzPq4vWLCghIeHy7lz5yQgIMDV4YYgD9ind+/ecuLECTPBVT8xu3HjhpQsWdJ0k3IP9wUKFOBlAoBYCPLwa7fffnuMj+OrV68ubdq0MWFe5cmTx8ajA/DHH3+YUfmIiIgYJXHz5s2Td955R1q3bs2TBADxoOAQfk07XeiCT9YEOZ0wd/XqVTPqV7RoUenQoYPdhwika++++64J8aVLl5ZRo0bJe++9Z+azaGepN99803SaAgB4RvtJ+LVjx46ZEG+V2CgdjT9w4IDcdtttEhISYuvxAemdLvqk79OvvvpKqlatam7Tk+3atWubtpQbN26U7Nmz232YAOCTGJGHX1u9erWZ6Kq94n/77TdzW86cOU2JDSEesJ+OxCv3Ejj9xExH4kuUKEGIB4AEUCMPv6aLyWiHmvnz55uLTqLTchptc0d9PGC/Tp06mdVcX331VdNVSgP9zJkzTZjX+Szui0DVrVvX9JUHAPyL0hr4vVOnTsm3334rixYtkh07dpjbAgMDzUf6jz/+uNSoUcPuQwTSrQYNGsjp06eTtO2aNWvMmhAAgH8xIg+/p3/4e/ToYS579+6VDz/80AT7FStWSO7cuQnygI10Iajz588naVttIwsA+B+CPNKFw4cPm2Xgv/nmGxPmla4UqRNeAdjnk08+4ekHgBQiyMPve1RrS7vNmzdLdHS0ua1y5crSsWNHsxS8ezcbAPbQhdqmTZtmauW17WS1atWkV69eZhE3AED8CPLwa9u3bzfdarR9nU6c04l1jMIDvkPbwXbp0kX2798f4wRcPz374osvXF1tAABxMdkVfm39+vVm+feWLVvSbhLwQbro04wZM6Rw4cLy9NNPS+bMmeWzzz6TrVu3Sv369WX69Ol2HyIA+CyCPPzOwYMHZdu2bVKsWDHJkSOH+To+uk2VKlVu6fEB+J9WrVrJvn37TJjX9pLq7NmzpptNQECAbNmyhZaTABAPSmvgd9auXSvDhg2Tzp07S4UKFczX8dFtCPKAfXSdB5UvX74Y6z9kypRJrly5YlZ3pXc8AHhGkIffKVSokDRs2FDKli3r+jo+ug0A+5QvX950ldK2sCNHjjQtJidNmmRCfNGiRZmQDgAJoLQGfu3YsWOSLVs2wgDgo3Qyerdu3Uy3Gg3xGTNmlKtXr5r79NO0rl272n2IAOCzMth9AEBaWr16tTRq1EhefvllExgA+JaaNWvK+PHjzWTX69evmxCvXaYGDhxoutkAAOLHiDz82vfffy/PP/+8Ge1TJUuWlA4dOki7du0kT548dh8egP8XFRVlJqrrtb43NcwDABJGkIffO3XqlHz77beyaNEi2bFjh7ktMDBQmjRpIo8//rjUqFHD7kME0rWFCxfKxx9/LDNnzpS8efPKXXfdJY0bN5ZXXnmFia4AkABKa+D3NBj06NFDFixYYAJ969at5caNG7JixQpzGwB7Q/ygQYPkn3/+Me0mlY7Kz549W0aPHs1LAwAJIMgjXdCuGDriN2DAABPmVWhoKKu8AjabM2eOuX7xxRdd5W6TJ0821/Pnz7f12ADA19F+En5Nl3ofNWqUbN68WaKjo81tlStXlo4dO8p9991HNxvAZrrysmrWrFmMtrB6oh0RESHh4eFmYTcAQFwEefi17du3m241OnGuTZs20qlTJ0bhAR9SsGBBOXr0qMydO1eeffZZyZAhgxml1xCvrWP1AgDwjMmu8Gvr1q0ztbcPPvighISE2H04AGLRUjdtNWlNQlc6h0U9+eSTrvsAAHFRIw+/poFAV4t8/fXX7T4UAB7o5PPXXntNcuXKZd6vetGymieeeMLMaQEAxI/SGvi1S5cumR7yFy9etPtQAMTj4YcfNiu4aomNvl8LFSpkVnm1vPHGG+a9PHjwYEptAMANpTXwa2fOnJGePXvK/v37Tc/4SpUqmdE+rcNV+fLlM4tEAfBdDRo0kNOnT8uaNWtMO1kAwL8YkYdfW7Zsmezevdt8PXHixDj3d+7cWUaMGGHDkQEAAKQOQR5+LWfOnAl2qdGOGQAAAE5EkIdfa9mypbkAAAD4G4I8/H5F1127dsV7f5EiRegrDwAAHIkgD7/2888/y7Bhw+K9nxp5AADgVAR5+DXtSnPHHXe4vr9+/bppcafLwpcoUUJq165t6/EBAACkFEEefu3uu+82F3fap1pXjFy7dq2ULVvWtmMDkDRZs2aVyMhIV9tYAMC/CPJIdzJmzGhG6bXsZunSpdTIA7fYihUrTDBPimbNmpn3KQAgLoI8/JqW0Vh95FV0dLRcuHBBvvzyS/P9lStXbDw6IH0aOnSoWeApKVgECgDiR5CHX/vxxx8TnOzapEmTW3o8AETq1q0r58+fT9JTERwczFMGAPEIiNYhSsCPP8KfOnVqjNu0zjZXrlzSpk0bueeee2w7NgAAgNQgyAMAbKNjSYsWLZKdO3fK1atXzYl2QECAKXvbunWrzJgxQ/LmzcsrBAAeUFoDvxceHm7q5HWC65EjR2TkyJEmJDz11FNSp04duw8PSNcmT54s7777rt2HAQCORC8v+LWoqCjp3r27LF682Hz/+uuvyw8//CDr1q2TJ554wvSTB2CfJUuWmOv777/frPugJ9j169c3tfGMxgNAwgjy8GubNm2SXbt2ma91FF47YGg7u4YNG5r2d99//73dhwika2fOnDHXzz77rDRq1EiqVKkiEyZMMCU348ePt/vwAMCnEeTh17SUxrJ9+3azsmvLli1d3Wq0PSUAexd7UkFBQVK1alXZuHGjCfFaK//bb7/JpUuXeHkAIB4Eefi1TJkymWsNA9u2bTNf64hfYOC/00MyZ85s6/EB6V3NmjVdX9euXVtmzpxpTrb1E7PQ0FDJkiWLrccHAL6MIA+/VqFCBdMBY9myZfLhhx9KkSJFpESJEq77K1eubOvxAemdltToRHRVunRpefDBB+XUqVPm+/79+5v3LwDAM9pPwu+NHTtWJk2aJCEhITJu3DhTVjN79myZN2+ezJkzx3ykD8Aee/fulTJlysS4TcvgsmXLJsWKFeNlAYAEEOSRLugqkhrk9aIOHTokuXPnNh/d//LLL7Jw4ULTirJ9+/Z2HyqQrjRo0EDy5MkjHTp0MIu0hYWF2X1IAOAYlNYgXdBwYIV4VbRoURPi1T///CMLFiyQ33//3cYjBNInXWVZO0u98cYbpmvNwIEDTXtYFh0HgMQR5AEAttFVXT/99FN54IEHTJnbt99+Kz179pS7777btKG8du0arw4AxIMgDwCwjbaZrFevnrz11ltmJF6v8+bNa1rHfvDBB2ZlZgCAZ//24AMAwCa6voMu1vb111/LypUr5erVq66uU7SIBYD4EeQBALYZPXq0maNy7tw51wJRnTt3lo4dO5o1HwAA8SPIAwBso6PwGuJr1KhhOte0atXKNREdAJAwgjwAwDYPPfSQtGjRIk4veQBA4gjySDe0nZ2uEnnlypUYdbfBwcFm8RlqcYFbY8WKFRIZGSnNmjWT8uXLy+7du83FE90mU6ZMvDQA4AELQsHvnT592nTC0AWgXnnlFbOq64wZM0zf6lq1atl9eEC6XARK35c6wbVdu3bm6/joNtrFBgAQFyPy8PtuGI888ohZ9KlLly7mNu1Vrd/36tVLli5dKgUKFLD7MIF0pW7duma1Zf00zPo6ProNAMAzRuTh13Q0TwN7sWLFzEi8LgWv+vfvb0L8Cy+8II8//rjdhwmkW3v37qU+HgBSiAWh4NdOnDhhrqtVq+YK8apq1arm+vjx47YdGwCRRx99VO6//36ZOXNmgiPzAIC4CPLwa4UKFTLX69evN+U06ujRo/LNN9/EuB+APXLlyiW7du0yc1YaNWokAwcONCu86uR0AEDCKK2BX7tx44YZ7dOP75V2v9BuGSpHjhzy3XffxRipB3BrRUVFyYYNG0w/eS13u3z5srm9cOHC8sADD0jv3r2pkweAeBDk4feOHTsmr776qqxdu9Y1ylepUiUZMWKEVK5c2e7DA/D/rl69ak6ux44dK6dOnTK30bUGAOJHkEe6ceHCBdPmTkfldbQPgO90l9LArqPyK1euNIFeVahQQT7//HPJmjWr3YcIAD6JIA+/Rx95wHeNHj1aFixYIOfOnTPfa2hv3bq1dOzYUapUqWL34QGAT6OPPPwafeQB36aj8Bria9SoIR06dJBWrVpJaGio3YcFAI5A1xr4NZ1Ep91qtI98v379zG0aFlq0aGE+vl+8eLHdhwika+3btzfvwzlz5pj3JiEeAJKOIA+/Rh95wLf9+uuv8thjj8mff/5p96EAgOMQ5OHX6CMP+LZLly7JyZMnzSR0AEDyMNkVfo0+8oBvmzVrlowcOdKsvty5c2ezrkNQUJDrfq2dDw4OtvUYAcBXEeTh9+gjD/iuBg0amM5S8aGPPADEj6418HsFCxaUqVOnysWLF80iM2FhYWZZeAD2K1u2bIKrKwcG8mcKAOLDiDzShd9//92MzGs7SnclS5aUqlWr2nZcAAAAKcVQB/zazZs3pWfPnqYNpSdak0uQB+zz008/ybVr1+K9v3HjxtTIA0A8CPLwa2vXrnWFeF3uPW/evJIhw/+aNZUvX97GowPw8ssvUyMPAClEkIdfO3v2rLmuX7++TJ8+3e7DARCLdqUJDw83X0dHR0tERITs2bPHlMG1bt1aMmfOzHMGAPEgyMPvO2JkzZrV7sMAEI8JEybEue23336Thx56yIR53r8AED8mu8LvHDp0SLZv3x5jouunn34qHTt2lDp16sToUV2sWDGpWLGiTUcKwBMdmdeReg3y+v6ljzwAeEaQh9+ZPXu2DBs2LEnb6mTXESNGpPkxAfBs3bp1EhkZGWMRN53XMnPmTNfoPKPyAOAZpTXwOwUKFJB69eoladvSpUun+fEAiN8LL7wQ72TXO+64gxAPAAlgRB4AYJunn35azp8/H+O2kJAQKVeunDz55JMs3gYACSDIAwAAAA70v4baAADYYP369XL58mXz9YwZM6RLly7y5ptvxqidBwDExYg8AMA2S5culQEDBsjPP/8sJ06ckAcffNB13yOPPCJDhgzh1QGAeDAiDwCwzeeff27aTarly5dLQECADB061Hy/cOFCXhkASABBHgBgmyNHjri+3rJlixQvXtwsBhUWFiaXLl2Sixcv8uoAQDwI8gAA22iHGhUeHi47duyQypUrm+8DAwPN6Lx1PwAgLoI8AMA21srK3bt3lwsXLkijRo1c92kLSveVmAEAMRHkAQC26du3rxQuXFjOnDkj9evXl1atWpnbdTS+X79+vDIAkAC61gAAbBUVFWWCfN68eV237d69W8qXL2++fuONN0y9/ODBgyVbtmw2HikA+BaCPADApzVo0EBOnz4ta9asiRH2ASC9o7QGAAAAcCCCPAAAAOBABHkAAADAgQjyAAAAgAMR5AEAAAAHIsgDAAAADkSQBwD4hOjoaHN95cqVGLdnzZrV9I/PkIE/WQDgjv8VAQC2WrhwobRs2dL0iletW7eWYcOGybVr18z3S5culU2bNknu3Ll5pQDATaD7NwAA3OoQP2jQIPN1QECAa6XX2bNnS8aMGWXIkCG8IAAQD0bkAQC2mTNnjrl+8cUXJU+ePObryZMnm+v58+fzygBAAgjyAADbnDhxwlw3a9bMdVvZsmUlNDRUIiIiJDw8nFcHAOJBkAcA2KZgwYLmeu7cuXL9+nW5efOmzJo1y4R4neCqFwCAZwHRVpsAAABusW+//VYGDhxovg4M/Hfa1o0bN8z1k08+6boPABAXk10BALbRDjXnz5+XCRMmyNmzZ81tWlbz8MMPy4ABA3hlACABjMgDAGynnWqOHDlirnPmzCnZs2e3+5AAwOdRIw8AsL0FZatWrSQkJESKFy8u7dq1i9FHHgDgGaU1AADb0EceAFKOEXkAgG3oIw8AKUeQBwDYhj7yAJByBHkAgG3oIw8AKUfXGgCAbegjDwApx2RXAIBt6CMPACnHiDwAwHbaP/7o0aNy8+ZNKVSokAQFBdl9SADg8wjyAABb6YqumzdvloiICImOjo5xX8uWLSVTpky2HRsA+DJKawAAtvnxxx+lX79+EhkZ6fH++vXrS968eW/5cQGAExDkAQC2mThxognx2bNnl8qVK0twcHCM+xmNB4D4EeQBALY5c+aMuf7444+lZs2avBIAkAz0kQcA2EZr4AEAKcNkVwDALbVq1SpXTfyNGzfk/fffN11revXqJbly5ZKAgADXtnfddVecchsAwL8I8gCAW6pBgwZy+vTpJG27Zs0aJrsCQDyokQcA3FK1atWS8PDwJG3LaDwAxI8ReQAAAMCBmOwKAAAAOBBBHgAAAHAggjwAAADgQAR5AAAAwIEI8gAAAIAD0X4SgFd9+eWXcvLkSdf3urhP5syZpVixYqZ/eGhoaLL3qYsF/fLLL1K/fn1bXi27fz4AAJ4wIg/A60F+zpw5ru9v3rwpR48elXHjxknTpk1l5cqVyd7noEGD5IMPPrDtlbL75wMA4Akj8gC8Lk+ePNKvX78Yt2mgHzp0qPTv319mz54tVapUSfL+zp49a+urZPfPBwDAE4I8gFsiY8aM8tprr5kReR2dnzJliuu+8+fPy88//2xG7jNlyiS33367VK1a1dynof/gwYNy/fp1Myretm1bKV68eKKPs2hJzK5du+TGjRtSpkwZU94TFBQUY5srV67IqlWr5NChQ5IrVy7zyYGejCT28wEAsBOlNQBumeDgYGnWrJkJ15cvXza3aRDX27777ju5dOmSbNmyRbp27Spjx45NcF+JPU4/AXj66adNWYwG/TNnzsjIkSNNENftLRryW7ZsKePHj5dz587J8uXLpXnz5ikqAQIA4FZiRB7ALVWkSBEzuq2j3OXKlZNXXnlFWrduLcOHD3dto6F66tSp8uSTT5pwvmLFComIiHCV62hIT+xxW7duNWH8q6++co3S9+rVy4ywnzhxQrJmzWpG6fv27WtG4b/44gszKVdp4H/++edl2bJlHn8+AAC+gBF5ALdUtmzZzPXFixclPDxcOnXqJD169DC36Uj5H3/8YUbQr169KqdOnfK4j6Q8Tktt1MKFC83Pcq/dL126tPl+/fr1ppzmiSeecIV41bNnTxPcdbQfAABfxYg8gFvKKmvRQK8j4a1atZIJEybIhg0bTAAvXLiwuVgj754k5XE1a9Y0Qf/zzz+XuXPnmu8bN24s9913n+TPn99st2/fPnOtpT7W1+41/bFvAwDAlzAiD+CW0nCsk01LlSolx48fl4cfftjcNmzYMFmzZo0ph2nXrl2C+0jq415++WX56aef5PXXXzej8R999JGpf9eRePcTBffReIvW1zdq1MirvzsAAN7EiDyAWyYyMlJWr15tRsa19GXJkiVmgum0adOkYsWKru2OHTsW43G6qJS7pD5O5c6dW9q3b28u2uXm3nvvlVmzZkm9evVc3WeaNGlivnc/zsmTJ0tYWJjHnw8AgC9gRB7ALREdHS1vvvmm6VajveSVTjhVFy5ccG2nAf2///2v+VonxVrdbtzLbJLyuE2bNsnEiRPl2rVrrm10P3ocefPmNd/riLt+/fHHH7t+lpoxY4Z5bPbs2T3+fAAAfEFAtP5VAwAveeCBB0xXmC5dupjvo6KizORUrUPXsD1q1Ci58847zX0a6jt37mxaQ7Zp08Z0kdH2jyVKlJBff/1VJk2aZEbLtRvNJ598Yvapo/la757Y48qXLy+PPPKIhIaGmt7xOqquZTYayDWoW3Xy2rayT58+kjNnThPsdcKsfmrw0ksvyUMPPWS2if3z9QIAgN0I8gC86ssvv5STJ0/+7z+ZgADJkiWLqYmvU6eOhISExNheR8w1hB85csSMjlevXl2KFStm6tl1gaf69euboL548WJTG68hWstpkvI47WCj9fPamUZH3PUY9PE6wu5OTyg0vB8+fNhMpNXHWhNnlaefDwCA3QjyAAAAgANRIw8AAAA4EEEeAAAAcCCCPAAAAOBABHkAAADAgQjyAAAAgAMR5AEAAAAHIsgDAAAADkSQBwAAAByIIA8AAAA4EEEeAAAAcCCCPAAAAOBABHkAAABAnOf/AFk2uuMRhP88AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Generating dataset comparison boxplots (per algorithm)...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAKaCAYAAADs71kMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAARSRJREFUeJzt3QmcjXX///HPMAaDsq9ll6wt1mQLqYjslIiylJLqvkvuFrK03rkr6rZGIZRbZBdFWSJFi3CnKEv2dQxmMP/H53P/z/kZZjkzc/ge13k9H4/zuM65rutcvuPMNfOe7xqRkJCQIAAAAI5kcvUPAwAAKMIIAABwijACAACcIowAAACnCCMAAMApwggAAHCKMAIAAJwijAAAAKci3f7zAPA/P/74oyxcuFD+/PNPiYiIkGuuuUYaN24s1atX9/8Xbdq0Sf75z3+m+F/WrFkzKViwoEycOFEeeeSRRO8/344dO2TQoEHSsWNHadq0KR8D4BBhBIBzb731lnzwwQfSuXNnad68uejE0D/99JP06NHDXg8bNszOO3z4sKxYsUJ69eolNWrUSPJa1157rVx99dWyZs0a2yYXRmbMmCGrVq2SIUOGXNKvDUDqCCMAnPrtt99k1KhRFjjatm2bqIajfPny0r9/fwskderU8R+7/vrrpX79+ilet0mTJrJ06VI5fvy45MqVK9Gxc+fOyaxZs6Ru3bpStGjRS/BVAUgL+owAcGrLli1WE1KsWLGLjmkgGTt2rJQoUSLN1+3QoYOcOnXKmn4upLUre/bssSYaAO4RRgA4VaFCBesjos0ly5Ytk/j4eP+xqKgoqwFJKqik5pZbbrEmm08//fSiY//5z3+kQIEC0rBhwwyXH0DG0UwDwKlSpUrJSy+9ZM00vXv3lujoaLn55pulVq1a1tRSunTpi94zZswYmTlzZpLXe/vttyVnzpwWcLTZR/ujaKfY4sWL+/udfPHFF/Lggw9KZCQ/AoFQwJ0IwDltLmnUqJHMmzdPvvrqK1m3bp01pQwfPtwChYaV84OD1pYk14E1a9as/udt2rSRESNGWP+Qxx9/3PZ99tlnVvvSrl27y/CVAQgEYQRASNBmk27dutkjLi5Ovv32W+vYqqNeChcuLH379k1TB1ZVqFAhadCggYURfb/WlmiNyq233mpNOABCA31GADilzTMXzh2ifUU0MEyYMME6r2pfkvRq37697Nq1y2pbNm7cKJs3b7Z9AEIHYQSAU6dPn5aPPvpIYmJiLjqmTTM6V0iePHnSfX2tGdEakrlz58qcOXMkf/78NpkagNBBGAHgVM+ePS109OvXT/bt25fo2PTp0602o3v37um+fubMma3vyJIlS2yYb+vWrSVLlixBKDmAYIlI0AH+AOB4rpGhQ4fK+vXr5brrrrPRMNu3b7fQMGDAABtVo3TGVA0m2mdEaziSoqNmBg4cmGjfzp07/ddYtGhRuuYtAXDpEEYAhIxDhw7ZMNyTJ0/a+jJlypRJdFyH5eo08SnRIKNDgy+kHWL1b6+aNWsGvdwAMoYwAgAAnKLPCAAAcIowAgAAnCKMAAAApwgjAADAKcIIAABwijACAACcYqG8FOgETDovAbM1AgCQNro6ti5OedNNN6V6LjUjKdAgwgS13qKfp64Iy+cKhB7uz/D9HUrNSAp8NSJVqlQJzicD52JjY2XTpk1StmxZiY6Odl0cAOfh/vSW1GZLPh81IwAAwCnCCAAAcIowAgAAnCKMAAAApwgjAADAKcIIAABwKiSG9upQy48++kgOHjwoFStWlG7duknOnDmTPf/rr7+WxYsXy5EjR6R06dJy//33S4ECBdJ9PQAAEMZhZPPmzdKpUyc5deqUvV66dKksX75cpk2bJpkzZ77ofN0/cODARPtmzJghs2fPlvz586f5egAAIMybaUaMGGHBoX79+vLqq69Kvnz55Mcff5TPP/88yfOnTJli2wceeMDeW6lSJTlw4IDMnz8/XdcDAABhHEZ0mthVq1bZ8/79+0vr1q2lffv29nrlypVJvufMmTO21aaXpk2bym233ebfn57rAQCAMA4j+/bts+l/VfHixW177bXX2vaPP/5I8j29e/e25pYOHTpI586dZdSoUVKsWDG555570nU9AAAQxn1GYmJibKvhIioqyp5ny5bNtidOnEjyPbfccotcf/31snHjRtm/f7/ta9SokeTJk0e2bduW5uulRmtbfAEHV76TJ08m2gIIHdyf3qK/P3XV3pAPI74OpefOnfPvO3v2rG0jI5MuWp8+fSyIdOnSRapXry7jx4+XSZMmWRhp3rx5mq8XyBLIOjoH3rJ9+3bXRQCQDO5P7/BVDIR0GMmbN68/PR0/flxy5colR48eTXTsfDt37pSff/7ZhvE+//zztk+f33fffbJo0SILKGm5XqAr9+oKr/DOX176g65kyZKSPXt218UBcB7uT2/ZunVrwOc6DSNXXXWVFC5cWPbs2SNr1qyRJk2ayLp16+yYzg9yIQ0Z6tixY7J3714pVKiQ/P7777YvR44cab5eILSKiaXmvUeDCJ8rEJq4P70h0CaakJhn5O6775Zx48bJ3//+d/trVZtEtElF96t//etfVhuiHVdr1qwp5cuXly1btkjLli2lTJky8sMPP9h5jRs3Duh6AAAgtDifZ+TRRx+VBg0aWPWcBgdtFnnuueekVKlSdlyDyIoVK/ydVXUekRtuuMFmX/3uu+9sSG+7du1sqG8g1wMAAKElIsHX9uHYb7/9ZoHjuuuuS9S/Q8PIoUOHpEKFCommfNeRMzrde4kSJRLtT+16afHTTz/ZtkqVKul6P0KPjozSkKrfTzTTAKGF+9Nb0vI71HkzjY82uejjQpUrV07yfK3pSKm2I7nrwdt0PhntU5QcnZ33l19+sRFXvmHfF9K+RxpyAYTe/ck96k0hE0aAjNIatLp16yYa2p3eIecbNmxId40agEt3fyruUe8hjOCKsXv37lQnoNO1i3yT6SVFh4dPnz5dOnbsKNdcc02S5+gKz/qDUx/J0SaeokWLpqH0gPeldo8G4/5U3KPeQxjBFfNDTkdUBYMGiTlz5mT4OqNHjyaQAEG+R4N1fyru0SsHYQRXBP1rS+ce0B92BQsWTPd14uLirPOz9jcKdGbAC+kaSPpDjmUCgODeo8G4P7lHr0yEEVwxdASMVvGmVM0bCB3urdXBGS0LgODfo8G4P31lwZWDMIIrhg7J1TllfCsxp4f21vf95ZVSb/2U7Nixw9q+AQT3Hg3G/ck9emUijOCKoRPZaTVw7ty5M1SVrNW/Onw3vfOMHDhwgFV/gUtwjwbj/uQevTI5n4EVAACEN8IIAABwijACAACcIowAAACnCCMAAMApwggAAHCKMAIAAJwijAAAAKcIIwAAwCnCCAAAcIowAgAAnCKMAAAApwgjAADAKcIIAABwijACAACcIowAAACnCCMAAMApwggAAHCKMAIAAJwijAAAAKcIIwAAwCnCCAAAcIowAgAAnCKMAAAApwgjAADAKcIIAABwijACAACcIowAAACnCCMAAMApwggAAHCKMAIAAJwijAAAAKcIIwAAwCnCCAAAcIowAgAAnCKMAAAApwgjAADAKcIIAABwijACAACcIowAAACnCCMAAMApwggAAHCKMAIAAJwijAAAAKcIIwAAwCnCCAAAcIowAgAAnCKMAAAApwgjAADAKcIIAABwijACAACcIowAAACnIiUErF27Vj788EM5ePCgVKxYUfr06SP58uW76Lxdu3ZJ3759k7xGwYIFZdSoUfb8oYceksOHDyc63qRJE7suAAAILc7DyPr16+XBBx+U+Ph4e/3999/LmjVrZObMmRIVFZXo3FOnTsnGjRuTvM6RI0dse/ToUVmxYsVFxytUqHBJyg8AAK7wMPLee+9ZEGnWrJncc889MmjQIPn1119l4cKF0rJly0TnXnPNNTJjxoxE+/T8n3/+WW699VZ7vXnzZtvWq1dP+vXr5z8vb968l+XrAQAAV1CfkXPnzlktiHr88celYcOG0rZtW3u9evXqi87PmjWrVKlSxf/QZhsNItq08+KLLyYKI6dPn5Z//vOf8u9//1tiYmKkWLFil/VrAwAAV0DNyL59+yw0+Go9lC807Ny5M8X3am3KK6+8IhERETJkyBDJkiVLojCi/VB8li1bJu+//77Url37kn0tAADgCgwjJ06csG3mzJn9YcLXT8R3LDnz5s2TPXv2SNOmTaVy5cr+/du2bbNt165dpVGjRjJ+/Hj5+uuvrZbkwiaeQCQkJEhsbGya34fg0v5Cvm1GPo+TJ08m2rosC+AlwbgvgnF/BqssyDj9/akVBiEfRiIjI/3NNb5CnzlzxvZd2Hn1QpMnT7btAw88kGj/Rx99JH/99Ze/hkVrXHQkzaZNm6w2xRd6AqXv0ffCrd27d/vDpq82LSO2b98eMmUBvCCY90VG7s9glwUZk9rv8pAII77huxpEdBRM7ty5/aNi8ufPn+z79u/fb31FdDhvtWrV/Pv1m27YsGHWl2T06NEWdnLkyGHHzp49a0EnrWFEzy9btmw6v0IEi/YXUqVKlZLSpUun+zr6F5f+oCtZsqRkz57daVkALwnGfRGM+zNYZUHGbd26NeBznYaRnDlzWs2F9g/RppQWLVrIypUr7dj5TS8X0nM0wNSpUydRFZB+A+qwXg0js2fPts6w8+fPt2Pp/ebW60dHR6fr60PwZMuWzb8Nxueh3wvpvU6wywJ4QTDvi4zcn8EuC9Iv0CaakJiBtXXr1rbt37+/NGjQQL766iur1rn77rtt/9ChQ6VNmzaJ5g7Rob+qUqVKF11P+4qo559/Xu644w57v+rZs+dl+XoAAEDaOA8jvXr1klatWlm/Ee2Qqs0qr776qn90jbb56URn2ozjo+epwoULX3S9Ll26SPfu3e25VvdpM8tjjz3mHzIMAABCi/NJz7QW5LXXXpNnnnlGDhw4ICVKlPBXsakXXnhBjh8/LsWLF/fv0zlJunXrZu2BF9KROc8++6xNeKbNP0WKFLHmIAAAEJqch5HzO7MmtR6N9vW4kAaWQNocy5UrF7TyAQAAjzbTAACA8EYYAQAAThFGAACAU4QRAADgFGEEAAA4RRgBAABOEUYAAIBThBEAAOAUYQQAADhFGAEAAE4RRgAAgFOEEQAA4BRhBAAAOEUYAQAAThFGAACAU4QRAADgFGEEAAA4RRgBAABOEUYAAIBThBEAAOAUYQQAADhFGAEAAE4RRgAAgFOEEQAA4BRhBAAAOEUYAQAAThFGAACAU4QRAADgFGEEAAA4RRgBAABOEUYAAIBThBEAAOAUYQQAADhFGAEAAE4RRgAAgFOEEQAA4BRhBAAAOEUYAQAAThFGAACAU4QRAADgFGEEAAA4RRgBAABOEUYAAIBThBEAAOAUYQQAADhFGAEAAE4RRgAAgFOEEQAA4BRhBAAAOEUYAQAAThFGAACAU4QRAADgFGEEAAA4RRgBAABOEUYAAIBThBEAAOAUYQQAADhFGAEAAE4RRgAAgFOREgK+/PJLmTBhghw6dEgqVKggTz75pBQtWvSi83bs2CEPPvhgktcoXLiwTJo0KU3XAwAA7jkPI6tXr5Y+ffrIuXPn7PWvv/4q69evl7lz50q2bNkSnRsXFyd//vlnktc5e/Zsmq8HAADcc95MM3r0aAsO7dq1k48++kiKFy9uNSDz5s276Fw9tnjx4kSPypUr27Hbb789zdcDAABhHkbOnDkj69ats+cPP/ywVKtWTVq1amWvv/3224vOz5Ili5QoUcL/0BqPn3/+WW666Sbp379/mq8HAADCPIzs27dP4uPj7XmRIkVs6+vbsXPnzhTfe/r0aXn99dclc+bMMmTIEMmUKVOGrgcAAMKwz8jJkydtq4EiMjLSX/uhYmNjU3zv7Nmz5eDBg3L33XdLuXLlMny95CQkJKT7vQieU6dO+bcZ+Tx83yO+rcuyAF4SjPsiGPdnsMqCjNPfnxEREaEfRnxBQTuf+gqtTS0qKioqxfdOmTLFtl27dg3K9ZKjNS2bNm1K13sRPLt377bttm3brFYso7Zv3x4yZQG8IJj3RUbuz2CXBRkT6O9ep2EkX758/ueHDx+WvHnz2nBcVbBgwWTft3fvXtm8ebM1wdxwww0Zvl5KNOCULVs2Xe9F8GTNmtW2pUqVktKlS6f7OvoXl/6gK1mypGTPnt1pWQAvCcZ9EYz7M1hlQcZt3bo14HOdhpEcOXLYN51+8y1dulTatm0ry5cvt2NVqlRJ9n0rVqywbe3atYNyvZRo7Up0dHS63ovg8Q3L1m0wPg/9QZfe6wS7LIAXBPO+yMj9GeyyIP0CbaIJiaG9OgRXPf/881KjRg355ptv7JunZcuWtn/AgAE2bHfZsmUXpS3fsN60XA8AAIQW52FEZ1Tt0qWLNYfExMRI/vz5Zfjw4VKoUCE7riNkdKKzEydOJGqmUb5z0nI9AAAQWpzPwKojX7QW46mnnpKjR49a3w7d5/PKK69YO6KGCp9nn31W+vXrl2TASO16AAAgtDgPIz7alJJU215SHU8D6Yya3PUAAEBocd5MAwAAwhthBAAAOEUYAQAAThFGAACAU4QRAADgFGEEAAA4RRgBAABOEUYAAIBThBEAAOAUYQQAADhFGAEAAE4RRgAAgFOEEQAA4BRhBAAAOEUYAQAAThFGAACAU4QRAADgFGEEAAA4RRgBAABOEUYAAIBThBEAAOAUYQQAADhFGAEAAE4RRgAAgFOEEQAA4BRhBAAAOEUYAQAAThFGAADAlRNGzp49K9OmTZMFCxZcdKxPnz4ybNgwOXbsWDDLBwAAPC5NYeT555+XgQMHyrfffnvRsfj4eJk8ebI88MADcvTo0WCWEQAAeFjAYWT58uUyb948ee211+SFF1646PjYsWPlk08+kYMHD8qYMWOCXU4AABDuYeTTTz+V3r17S6tWrSQiIiLJcypXrixDhw6VGTNmBLOMAADAwwIOI3/++afUq1cv1fP0nLi4ODly5EhGywYAAMJAmvqMJFcjcuE52bNnl3PnzmWkXAAAIEwEHEZKlCghGzZsSPW87du3S0xMjOTJkyejZQMAAGEg4DDSrFkz66S6d+/eFIf+vvzyy9K4ceOAalEAAAACDiMaMEqXLi3t27eXqVOnyp49e/zHdCjv559/Lvfee69899138uijj/I/CwAAAhIZ2GkimTJlkrfeekv69+8vgwYNskeWLFmsBkQ7rCoNK+PHj5eyZcsGelkAABDmAg4jKnfu3DJ69Gj5/vvvZcmSJbJ7927rqFqoUCGpW7eu1KlTxwIKAADAJQkjPjfffLM9AAAALlsYWbZsmZw4ceKi/dpMkzVrVsmXL59UrFhRoqKiMlwoAAAQPgIOI7oInk58lpLo6GjrvNqjR49glA0AAISBgMOIrklz6tSpZIf0Hj582EbSaCdXnWOkbdu2wSwnAAAI9zASSB+Rli1bSs2aNWXkyJGEEQAAEPzp4ANx11132RwksbGxwb40AADwoKCHEZ2PRIcA60RoAAAAlz2M6ARohw4dYm0aAADgJoxMmTLFZmLNli1bsC8NAADCuQPrggULbDXe5EbTHDt2zEbT6HwkOqIGAAAgqGFk+PDhqc4zUqxYMXn11VetEysAAEBQw8g777wjp0+fTvKYNsnkzZtXChYsGOjlAAAA0hZGKlSoENB5O3fulGnTpkmXLl1sAT0AAICgL5R3IV259+uvv5aPPvpIvvrqK3vdvn37YFwaAAB4XIbCiA7h/c9//iPTp0+XHTt2SK5cuaR169bSokULufbaa4NXSgAA4FnpCiMbNmywWhAdYaPziqjBgwdbEGHVXgAAcEnCyMmTJ2Xu3LkWQn755RfrsNqpUycLIP369ZPatWsTRAAAwKULIx06dJBdu3ZJw4YNpW/fvlK/fn2JjAxKlxMAABDGAp6BVZtjdHSMPrJnz25r0AAAAGRUwFUbOlx39uzZ1mH1/fffl8KFC0vLli2lVatWGS4EAAAIXwGHkTx58ki3bt3soR1YP/nkE5k8ebKMGTNGIiIiZPXq1TbpmdaapNVnn30mEyZMkIMHD0rFihXlmWeesfVtkvPf//7XppzfuHGj5MuXz8qkwchHZ4DVkT7nu+eee+Qf//hHmssGAAAurXR1+rjxxhvtob/c58+fb8Fk4MCBNhV8gwYN5M4775QmTZpIlixZUr2WrmXz9NNP+1/v3bvXOsjqSJ0cOXJcdP5vv/0m9957r3+dnD179tj7r776avu3Dxw4IL///vtF7ztx4kR6vlQAAHCJZajjh4YFndzs448/ljlz5tjzb775Rp544gnZvXt3QNcYN26cbbt27WqjdcqUKWOBRJ8nNy29BhHtSLto0SLp3bu31czMmzfPjm/evNm2zZo1s9oa34NaEQAAQlPQeqFed9118txzz9lMrLqonk6Alpr4+Hhr8lHa1FKuXDlrTlHr1q276PyEhAS7vtLAU7JkSRtW/NNPP8nrr7+eKIxs377dRgB1795dli9fnmQtCwAAcC/oY3N10rPmzZsHdO6+ffsskCjfOja+xfaSqlnRJhhtbtGaEK2B+fvf/y5Zs2aV+++/X9q0aZMojGhTj8+zzz5ri/mxmjAAAKHH6UQhp06dsm3mzJn9c5b4+pnoJGsXio2N9deQaP8UnwEDBthWA4meo9fQoNKoUSN577335NNPP5URI0akK4zov+X7d+H+e0W3Gfk8fN9XSX1/Xe6yAF4SjPsiGPdnsMqCjNPfn1p5EPJhxDd1/NmzZ/2FPnPmjO3TGo8Lnd8htnPnztKjRw+ZNWuWvP3229b3RMOIhg+9hi/cPPnkkxZGtm3bJqdPn07yuinRmptNmzZl8CtFRvlqynyfY0ZpM16olAXwgmDeFxm5P4NdFmRMoEvEOA0j+fPntwCiQUSH4uowXW2KOb/Z5sLzNWRo2ND+IEWLFrU+IRpGdKE+/abr06eP7Ny504YLa/DQWhefQBPahQGobNmyGfxKkVG+EFmqVKkUh32nRv/i0h902t8oPcPQg1kWwEuCcV8E4/4MVlmQcVu3bg343DSHER3Boh+0jmY5nzaV6Eq9Gg4C/SbS83T0jBZYR+PokN2lS5faMR06nFTCqlq1qnz//fc22qZ8+fKyZs0aO6bBRMulU9brN7POW6IjbSZNmmTHK1SokK61czTAREdHp/l9CC7t86P08/U9Tw+tttWh3/q9kt7r+AKzvp/vDSB492gw7k/u0dCRlgqANIUR7aehv+S1VuLCMKLfQDNnzpRVq1bJ6NGjAx69oovtDR06VF555RV54403rNZDR+K0aNHCP2pGh+bqObfffrv07NlTHnnkERk7dqx8+OGH/io4bbZRDz/8sPTv31/+9a9/yciRI/0dZB999NG0fKkIMefOnbOtfqahgiAC/B/uUWREwGFEayD0l7/WgNx3330XHZ8+fbqsXLlSnnrqKQssjz32WEDX1ZEwhw8flokTJ9pImRIlSsiQIUOsyUYdP35cjhw5YmvjKO2U+tprr8mbb75po3F8M7DqdZROT6/v0UC0f/9+G52j/UYaN24c6JeKEKRDx/Uzz+iaSDppngYa/f7UWrmMBBGtjQMQvHs0WPcn9+iVJyJBO2wEQEenFClSRP72t7+l2owzePBgCyZpTdXa6zlnzpyJ9usEZxpEdP+FzSx6fkp/naZ2PDU6f4mqUqVKuq+B0PLzzz9boNaauMqVK7suDoDzcH96S1p+hwYcYbVXsk7xnhptStEAobUTaaFp+sIgonRf3rx5k+zvkVrQoBodAIDQF3AY0eG3vuGygYQKhlMBAICghpHixYvbKrmBjO8+evSov88HAABAUMJI06ZNbQSLdjZNjnY/0REx9evXT9ecHgAAIPwEHEbuvPNOyZMnj80FsnDhQhv54qPDcXVhu169etk8ITr0FgAAIKhDe7W/iK7voqvk6kNnNtWOpdpHRGdP1fk8dNbUd999l9EnAADg0kx6pmFjypQpsmzZMlmyZIn1D9EhuTVr1pS6devaSJpAJzsDAABIcxhRWiOiE4gxiRgAAAiGdC2Up9OzL1iwQP744w8bwquToTVo0EDuuOOODC1uBAAAwk+awohOy/7ss8/Kl19+6e8zogsabd68WebPn2/T+OoKupUqVbp0JQYAAOEZRrRviE4Fv2XLFhk2bJjVguiCdr4J0XQlXV2crkePHvLZZ59JgQIFLmW5AQBAuA3t/eKLL6wGRBfEa9eunT+IKK0lqVGjhi2kV7FiRRtRAwAAENQwMm/ePKv1KFasWIrDf5977jlrsgEAAAhqGNHOqtWrV0/1vNKlS1so0blHAAAAghZGdJbVQBbKUzoVPNPBAwCAoIaRkiVLytq1a1M97/fff5e4uDibOh4AACDoC+Xt378/xdoTHWnTokWLQC8LAADCXMBhpFmzZnLNNddIx44dbcKz2NjYRKv1rl+/Xrp162Yjbnr37n2pygsAAMJ1nhFdEO+9996zRfKeeOIJG86rc4lERUXJwYMHbRXfEiVKyJgxY2wNGwAAgKDPwKozrupcIsuXL5elS5fKtm3brH9IhQoVbDp4rT1hOngAAHBJ16bRUTINGza0R0rTxuvIm5w5c6b18gAAIMwE3GfEZ8OGDTJjxgxZsWKFdVhNahG9li1bWtMNAABA0GpGtMPqY489JitXrvTvK1eunEyYMMH6jmgn1jfffFPGjRtnNSI5cuQI9NIAACCMBVwz8v7779tieI8//riMHz9eXnrpJTl+/LgMGTLEjg8fPtyG/larVk1mz54t+fPnv5TlBgAA4VYz8s0339hImu7du/v33XDDDTbUV1fr1bDy5JNPSq9evWzkDQAAQFDDiK41U6tWrUT7dBRNdHS0TJw40WpF6tSpE+jlAAAA0hZG4uPjk+wHkitXLmu6IYgAAID0CEp7Su3atYNxGQAAEIaCEkZ0NlYAAIBLPunZqlWr5Ndff0207+TJk0nu12Yb7U8CAAAQtDAyaNCggPcvXrzY1qoBAAAIShjR+US0FiRQBQsWDPhcAAAQvgIOI3RSBQAAlwKzkwEAAKcIIwAAwCnCCAAAcIowAgAAnCKMAAAApwgjAADAKcIIAABwijACAACcIowAAACnCCMAAMApwggAAHCKMAIAAJwijAAAAKcIIwAAwCnCCAAAcIowAgAAnCKMAAAApwgjAADAKcIIAABwijACAACcIowAAACnCCMAAMApwggAAHCKMAIAAJwijAAAAKcIIwAAwCnCCAAAcCokwsiHH34oDRs2lCpVqkjHjh3l559/TvH877//Xu69916pWrWqNGrUyN6fkesBAIAwDiPz58+XYcOGyV9//SVxcXGyYcMG6dGjhxw9ejTJ8zdu3CjdunWzQHL69GnZtWuXvX/BggXpuh4AAAjzMDJx4kTbPvroo7Jy5UqpWLGiHD58WObMmZPk+SNGjLAQcvfdd8vatWvl6aeflly5csk333yTrusBAIAwDiNac+FrQunQoYPkz59fmjVrZq/Xr19/0fnnzp3zh46HH35Yrr76aqv1WLdunbz00ktpvh4AAHAv0uU/vm/fPjl79qw9L1CgQKKtNrNcaP/+/XLy5EmJiIiQuXPnyieffCLZsmWTzp07y4MPPpjm6wUiISFBYmNj0/kVItRorZpvy+cKhBbuT2/R35/6+zrkw4jvGy9z5sz2sAJF/q9Ip06duuh83z79AkeNGuXf//rrr0tUVJTUqVMnTdcLRHx8vGzatCld70Xo2b17d6ItgNDB/ek9+rs55MOIr5Bam6FNMJkyZbJf/kprPC6UNWtW/3NtptHHzJkzZfDgwTJp0iQbQZOW6wUiS5YsUrZs2XS9F6GraNGiUqFCBdfFAJAE7k9v2Lp1a8DnOg0jBQsWtCocrek4cOCAvdamGFWkSJGLztc+IBoONGDcddddkj17dmnTpo2FEW2GSev1AqHXi46OzuBXilDhC7S65XMFQgv3p7cE2kTjvAOrfuOVL1/enk+bNs0CxMKFC+31zTfffNH52uTi2z916lQ5ceKELFq0yF4XL148zdcDAADuOR/a27VrV9u+++67cuutt9o8Innz5rWhu+qhhx6ygDFv3jx73adPH+sPomFDA0b//v1tf/fu3QO6HgAACC3Ow0jbtm3l+eeftzZCbYK58cYbZdy4cTZsNym1a9eW9957zwKK1oRof46hQ4dKu3bt0nU9AADgltM+Iz5dunSxR1LGjx9/0T7tqOrrrJrW6wEAgNDivGYEAACEN8IIAABwijACAACcIowAAACnCCMAAMApwggAAHCKMAIAAJwijAAAAKcIIwAAwCnCCAAAcIowAgAAnCKMAAAApwgjAADAKcIIAABwijACAACcIowAAACnCCMAAMApwggAAHCKMAIAAJwijAAAAKcIIwAAwCnCCAAAcIowAgAAnCKMAAAApwgjAADAKcIIAABwijACAACcIowAAACnCCMAAMApwggAAHCKMAIAAJwijAAAAKcIIwAAwCnCCAAAcIowAgAAnCKMAAAApwgjAADAKcIIAABwijACAACcIowAAACnCCMAAMApwggAAHCKMAIAAJwijAAAAKcIIwAAwCnCCAAAcIowAgAAnCKMAAAApwgjAADAKcIIAABwijACAACcIowAAACnCCMAAMApwggAAHCKMAIAAJwijAAAAKcIIwAAwCnCCAAAcIowAgAAnIqUEJGQkCCnT5+WbNmypXpuTEyMnDt3LtG+qKgo/3tTOw4AAEJHSISRkSNHysSJE+X48eNSunRpGTx4sNSoUSPZ8xs1aiRHjx5NtK9du3YybNiwgI4DAIDQ4TyMzJw5U0aMGGHPM2fOLL///rs88sgjsmjRIsmXL99F5+/evduCRmRkpGTPnt2/3/c8teMAACC0OA8jkydPtu0zzzwj9913n3Tr1k02bNggc+bMsecX2rx5s23btGkjL774ooWOiIiIgI8DAIDQ4rQDq/YR2bRpkz1v0aKF1V7ccccd9loDSVJ8YWPlypVyww03yM033yxvvfWW9TkJ5DgAAAgtTmtG9u/f7+9omj9/ftvmzZvXtnv37k3yPb6wsWvXLqv1iI2NlX//+99SoEAB6dy5c6rH00pDjF4D3qAB2LflcwVCC/ent+jvz0BbJiJD4RtP+4pkyvS/ShoNEOcfu5D2IylRooQMGDBA6tevb/1NNGyMHz/ewkZqx9MqPj7eX3uDK5/2KTp/CyB0cH96j45kDfkwkjVrVtuePXvWHhpK4uLiUuxwOnDgQP+5qmvXrhY2tCbk5MmTqR5Pa0fWLFmySNmyZTP4lSLUFC1aVCpUqOC6GACSwP3pDVu3bg34XKdhpGDBglYjok012mRTuHBhf/OMfjNeSGtLtG+JpufVq1dLrly5LGD4alT0Ok2bNk32uAaLtNIqpujo6Ax/rQgNvgCsWz5XILRwf3pLWgaPZHJdfVOxYkV7rvOM6LDeefPm2evq1avbVtv1jx07Zs0l+o2aM2dOe/7GG29Y6HjnnXfsvGrVqkmOHDlSPO5rAgIAAKHD+XTwDz30kG0nTJggd911l/z6669SqFAhad68ue3v27evTYC2ePFie/3kk0/advr06XLbbbfJrFmzrMbjiSeeCOg4AAAILc7DSLNmzeS1116T8uXLW+fTevXqWTDRGg6ltR3a3OJrYtHjY8aMsZoOHSGjQWXcuHE2hDeQ4wAAILSERLtFq1at7JEUXzPL+Ro0aGCP5KR2HAAAhA7nNSMAACC8EUYAAIBThBEAAOAUYQQAADhFGAEAAE4RRgAAgFOEEQAA4BRhBAAAOEUYAQAAThFGAACAU4QRAADgFGEEAAA4RRgBAABOEUYAAIBThBEAAOAUYQQAADhFGAEAAE4RRgAAgFOEEQAA4BRhBAAAOEUYAQAAThFGAACAU4QRAADgFGEEAAA4RRgBAABOEUYAAIBThBEAAOAUYQQAADhFGAEAAE4RRgAAgFOEEQAA4BRhBAAAOEUYAQAAThFGAACAU4QRAADgFGEEAAA4RRgBAABOEUYAAIBThBEAAOAUYQQAADhFGAEAAE4RRgAAgFOEEQAA4BRhBAAAOEUYAQAAThFGAACAU4QRAADgFGEEAAA4RRgBAABOEUYAAIBThBEAAOAUYQQAADhFGAEAAE4RRgAAgFOEEQAA4BRhBAAAOEUYAQAAThFGAACAU4QRAADgVKSEiFOnTsnx48clX758kilTyhlp7969Eh8fn2hfjhw5JE+ePOm6HgAACOMwkpCQIK+++qpMmTLFAkbBggVl6NCh0qBBg2Tf07x5cwsa52vXrp0MGzYsXdeDd/zxxx9y7NixZI9v3bpVYmNj5ddff7XvlaRcddVVUqJEiUtYSiA8BeP+VNyj3uM8jEydOlUmTpxoz6Ojo2Xfvn3yxBNPyMKFC6VQoUIXnb9jxw4LIlmzZpX8+fP79/tqRdJ6PXjHoUOHpG7dunLu3LlUz33ssceSPZY5c2bZsGGD5M2bN8glBMJXsO5PxT3qPc7DyLRp02z70ksvSfv27aVbt26ydu1a+eyzz6Rnz54Xnb9lyxbbtm7dWp588kkLJdmzZ0/39eAdGh5WrFiR4l9e2nz3yy+/SMWKFSVbtmzJ/tVFEAFC8/7kHvUmp2Hk5MmTVh2nmjRpYmm3cePGFh5++umnJN+zefNm2y5ZssSCR5YsWaRjx44yYMAAa5ZJ6/XgLak1r2gVsPYhqlChgtWcAbh8uD8RkmHkwIED/io731+iuXPntq02r6QURvS9+hespuzJkydL0aJFpWnTpmm+Xmq03VJ/gcEbNACfvwUQOrg/vUV/f0ZERIR+GImLi7Ot1mD4RrxERkYmOpZUsq5cubLVhFSvXl3GjRsnb7zxhnzwwQfSsGHDNF8vNVrbsmnTpnS9F6Fr+/btrosAIBncn94RFRUV+mHE1yZ49uxZe2iIOH36tO1Lrgr96aeflpiYGMmZM6e9btOmjYURHe7r632dluulRpuBypYtm673IjT/8tIfdCVLlkzU1wiAe9yf3qKjowLlNIzosFutuThz5ozs2bNHihUrJn/99Zcd0+cX0mChtR+HDx+W1atX2wiaEydO+EPDNddck6brBUKrmOhb4D0aRPhcgdDE/ekNgTbRKKezgWmAqFKlij0fPXq0/PDDDzJnzhx7XbNmTX/fkJ07d1q/DR05U7x4casB0TlFtP/I66+/bufVqlXLalpSux4AAAgtzqcm7dWrl6Wn6dOnS4cOHawKXQOHTmym+vfvbyNivvzyS3v997//3fqDaMi45557ZPHixRZSnnrqqYCuBwAAQovzMNKoUSMZOXKk1KhRw9rxNTTopGW+/iQ6sZk2sfja9/W8SZMmyW233SalS5e29+tsq5UqVQroegAAILREJKQ0526Y881N4mv6wZVPm/t0dBTzjAChh/szfH+HOq8ZAQAA4Y0wAgAAnCKMAAAApwgjAADAKcIIAABwijACAACcIowAAACnCCMAAMApwggAAHDK6aq9oS4+Pt4W5fPNIocrn2/CYV3aOi0rSgK49Lg/vSUuLi7gn7OEkRTwy8qbn2lUVJTrYgBIAven9z7PQH+PsjYNAABwij4jAADAKcIIAABwijACAACcIowAAACnCCMAAMApwggAAHCKMAIAAJwijAAAAKcIIwAAwCnCCAAAcIowAgBwZteuXfzvg7Vp4D1//vlnwCstFy9eXKpUqXLJywQgaXXr1pWCBQtKy5YtpVmzZvYc4YeF8uA5U6dOlUGDBgV0bseOHWXw4MGXvEwAknb77bfbHxAqU6ZMUqtWLbn77rvljjvukFy5cvHfFiYII/Cc5cuXy4cffhjQuQ0bNpQuXbpc8jIBSFp8fLysXr1aPv/8c1m6dKkcPHjQ9kdFRdn9qWGlQYMGcvXVV/Nf6GGEEQBASDh37pysWbNGXnnlFdmyZYt/f86cOeWf//yn3HbbbU7Lh0uHMALP2759u8ydO1cOHTpkP+y0Kvjs2bOyb98+6zMyYMAA10UEwlpcXJzVjixcuFC++OILOXLkiO3PnTu3PfQeLlSokHz11Veui4pLJPJSXRgIBTExMXLvvfdaEEmuzwgAd7R/l/6xcPz4cXudJUsWadSokbRq1cpqQrS5RptwHnvsMTuHfiTeRBiBp61du9aCSIECBazX/n//+19p3LixjB07VurUqUOtCOCYBg0NGZUqVbIAop1X8+bNm+gc7TcSHR1ttZrwJsIIPM3XGa5evXry+OOPy8MPPyyPPvqonD59WkaPHi3r16+3UALAjQceeMBqQMqVK5fieQsWLJAcOXJctnLh8iKMwNO045uv6rdIkSJy9OhROXz4sERERPhH3hBGAHd69eole/futU6rWnN55swZKVWqlI1yOz+gFC5cmI/Jwwgj8LSbb745UdXujTfeKC1atLBAovLnz++wdAB+/PFHqx2JjY1N1Lw6Y8YMeeONN6R58+b8J4UBGuDgadoDXyc183V6005wp06dsr++rr32WmnXrp3rIgJh7c0337QgUqZMGXn11VflX//6l/Xv0hFvL7/8so2Ag/cxtBee9tdff1kQ8TXXKK0V+eOPP+T666+XbNmyOS0fEO50YjO9Tz/55BOpWrWq7dM/GGrUqGFDfr/99lu56qqrXBcTlxg1I/C0ZcuWWedVnUvku+++s3158uSx5hqCCOCe1oio85tTteZSa0RKlixJEAkT9BmBp+mESTpyZubMmfbQjnHaNKNDCOkvArjXoUMHm3X1+eeft9FuGkomTZpkgUT7d50/0Vnt2rVt3hF4D8008Lz9+/fLvHnzZPbs2fLLL7/YvsjISKse7tGjh9x0002uiwiErVtvvVUOHDgQ0LkrVqywOYPgPdSMwPP0h1e3bt3ssXXrVnnvvfcsnCxZskTy5ctHGAEc0snOfNO/p0aH6MObCCMICzt37rQpp+fMmWOBROmMjtqJFYA7Y8aM4b8fhBF4fw4DHS74/fffS0JCgu2rXLmytG/f3qadPn+UDQA3dDLC999/3/qO6JDeG264QR566CGbqBDhgZoReNrGjRttFI0ODdTOcNpZjtoQIHToUPtOnTrZyrzn/xGhtZgfffSRf7QNvI0OrPA0XZZcp5q+8847GcoLhCCd2OyDDz6QYsWKySOPPCLZs2eXDz/8UH744QdbqmHChAmui4jLgDACz/nzzz/lp59+kuLFi8vVV19tz5Oj51SpUuWylg/A/2nWrJn89ttvFkh06K7SlbZ1lI2uIbVhwwaG84YBmmngOStXrpRBgwZJx44dpUKFCvY8OXoOYQRwR+cBUgULFkw0P1DWrFnl5MmTNgsrc4t4H2EEnlO0aFFb20JX/PQ9T05qy5YDuLTKly9vo910yP2wYcNs+O7o0aMtiOj6UXQyDw800yDs1qYBEDq0g3mXLl1sFI0GkcyZM9vaNEprNe+9917XRcRlwNo0CLu1aQCEjmrVqsk777xjHVjj4+MtiOjot6eeespG2SA8UDMCT1uwYIH87W9/s7+6FGvTAKFJF8bTzue61XWjWKk3vBBG4HmsTQOEtlmzZsmoUaNsgTxdvqFRo0ZSv359+cc//kHn1TBBMw3CZm2aTz/91Nakad68ua0IqmvT6D4AboNI//79Zdu2bTaUV2ntyNSpU+W1117jowkThBGEBe2tr3959evXzwKJYm0awL1p06bZ9plnnrHmGTV27Fjbzpw502nZcPkwtBeexto0QGjTGZJVkyZNEg251z8WYmNjbd0anbwQ3kYYgaexNg0Q2nQxvN27d8vHH38sTzzxhGTKlMlqSzSI6LB8fcD76MAKT1u1apW1Rbdt25a1aYAQpM2mOoxXRUb+7+9j7dOlevfu7T8Gb6PPCDxNf6jprI5DhgxxXRQASdAO5S+++KLkzZvX7ld9aBNNz549rY8XwgPNNPC0mJgYm2Pk+PHjrosCIBmdO3e2mVa1uUbvV13GQWdj9Rk6dKjdy8899xzNNh5FMw087eDBg9K9e3fZvn279OjRQypVqmR/dWm7tG9xLp0IDUDo0hV8Dxw4ICtWrLCh+vAeakbgaYsXL5YtW7bY83fffTfJVXsHDx7soGQAAB/CCDwtT548cv3116fYkx8A4BZhBJ5255132gMAELoII/D8zKubN29O9vg111yTYs0JAODSI4zA077++msZNGhQssfpMwIA7hFG4Gk6WqZmzZr+1/Hx8TZ8UKegLlmypNSoUcNp+QAAhBF4XOPGje1xPp3HQGd2XLlypa2BASC05cyZU06fPu0fkg/voWYEYSdz5sxWW6JNOIsWLaLPCHCZLVmyxMJFIHQBPb1P4W2EEXiaNsn45hlRCQkJcuzYMZk+fbq9PnnypMPSAeFp4MCBNolZIJjoLDwQRuBpy5cvT7EDa8OGDS9reQCI1K5dW44cORLQf0VUVBT/ZWGA6eDh+erg8ePHJ9qn7c66KFeLFi2kadOmzsoGAPgfwggAwBltOp09e7Zs2rRJTp06ZX8sREREWBPqDz/8IB988AHr0YQBmmngeUePHrV+I9ppddeuXTJs2DD7Qffwww9LrVq1XBcPCGtjx46VN99803Ux4BjjpOBp586dk65du8rcuXPt9ZAhQ2Tp0qWyatUq6dmzp803AsCdhQsX2vaee+6xeYH0j4Q6depYXxFqRcIHYQSetm7dOv908Foboj3zdahg3bp1bWjhggULXBcRCGsHDx607RNPPCH16tWTKlWqyMiRI6355p133nFdPFwmhBF4mjbL+GzcuNFmYNWF83yjaHToLwC3E5qpLFmySNWqVeXbb7+1IKJ9R7777juJiYnh4wkDhBF4WtasWW2rP9B++ukne65/eUVG/q+7VPbs2Z2WDwh31apV8z/X5RkmTZpkfzBozWV0dLTkyJHDaflweRBG4GkVKlSwnvmLFy+W9957z1bp1TVpfCpXruy0fEC40+YZ3/pRZcqUkbZt28r+/fvt9eOPP273L7yPob3wvOHDh8vo0aMlW7Zs8vbbb1sTzdSpU2XGjBkybdo0qx4G4MbWrVulbNmyifZpk2quXLmkePHifCxhgjCCsKCzPWoY0YfasWOH5MuXz6qBv/nmG5k1a5YN823durXrogJh5dZbb5X8+fNLu3btbCLC3Llzuy4SHKCZBmFBf8D5goi69tprLYiobdu2yaeffirr1693WEIgPOlsyDribejQoTaa5qmnnrKh99qJFeGDMAIAcEZnX504caK0adPGmkznzZsn3bt3l8aNG9sQ37i4OD6dMEAYAQA4o0N4b7nlFnnllVesRkS3BQoUsGH5I0aMsBmU4X1MBw8AcErn/9EJCT/77DP54osvbI0a32g4ht+HB8IIAMCZ1157zfpsHT582D8JWseOHaV9+/Y2JxDCA2EEAOCM1oZoELnppptsRE2zZs38ncsRPggjAABn7rvvPrnjjjsummsE4YUwgrChQwV1NkddMO/8dmhdHVQnWKJtGrg8lixZYtO966KV5cuXly1bttgjKXqOb1kHeBeTnsHzDhw4YD30dZKzf/zjHzb7qi5NrvMaVK9e3XXxgLCjE53pfamdVlu1amXPk6Pn6OgaeBs1I/B8L/3777/fJjbr1KmT7dO5DPT1Qw89JIsWLZLChQu7LiYQVmrXrm2zImutpO95cvQceB81I/A0/atKQ4eucaE1IjrttG8BLg0iTz/9tPTo0cN1MYGwldTaNAg/THoGT9u7d69tb7jhBn8QUVWrVrXtnj17nJUNgMgDDzwg99xzj0yaNCnFGhJ4G2EEnla0aFHbrl692ppm1O7du2XOnDmJjgNwg7VpoGimgaedOXPG/urSqmClvfK1F7+6+uqrZf78+YlqTABcXufOnZM1a9bYfCPadHrixAnbX6xYMVuvplevXvQbCQOEEXjeX3/9Jc8//7ysXLnSvxJopUqVZPDgwVK5cmXXxQPw/+k08PoHwvDhw2X//v22j9E04YEwgrBx7NgxG0KotSP6VxeA0F+bZvLkyTZFPLyNMALPY54R4Mpam6Z58+asTRNmmGcEnsY8I0BoY20aKEbTwNO0Y5yOotF5Rvr27Wv7dDEuXQtDq4Lnzp3ruohAWGvdurXdh9OmTbN7k0XywhNhBJ7GPCNAaFu7dq08+OCD8vPPP7suChwijMDTmGcECG0xMTGyb98+FsMLc3RghacxzwgQ2qZMmSLDhg2zWZI7duxo8/7o+lE+N910E/OMhAHCCDyPeUaA0F/BNznMMxIeGE0DzytSpIiMHz9ejh8/bhMp5c6d26agBuBeuXLlUpwFOTKSX1PhgJoRhIX169dbDYkO9T1fqVKl/IvmAQDcIHLC086ePSvdu3e3Ib5J0TZqwgjgzldffSVxcXHJHq9fvz59RsIAYQSepuvR+IKITi1doEAByZTp/waRlS9f3mHpAAwYMIA+IyCMwNsOHTpk2zp16siECRNcFwfABXS0zNGjR+25LmQZGxsr//3vf61JVaeFz549O/9nYYCaEXi+pz6LbAGha+TIkRft++677+S+++6zQML9Gx7owArP2bFjh2zcuDFR59WJEyfawlu1atVKNIeBThNfsWJFRyUFkBStIdEaEw0jev9GRUXxH+VxhBF4ztSpU2XQoEEBnasdWAcPHnzJywQgaatWrZLTp08nmqhQ+3lNmjTJX0tC7Yj30UwDzylcuLDccsstAZ1bpkyZS14eAMl7+umnk+3AWrNmTYJImKBmBADgzCOPPCJHjhxJtC9btmxy3XXXSe/evZmgMEwQRgAAgFOs2gsAcGr16tVy4sQJe/7BBx9Ip06d5OWXX07UlwTeRs0IAMCZRYsWSb9+/eTrr7+WvXv3Stu2bf3H7r//fnnhhRf4dMIANSMAAGcmT55sQ3nV559/LhERETJw4EB7PWvWLD6ZMEEYAQA4s2vXLv/zDRs2SIkSJWzCM11dOyYmxlbbhvcRRgAAzujIGaVTwv/yyy9SuXJlex0ZGWm1JL7j8DbCCADAGd8MyF27dpVjx45JvXr1/Md0eO/5MybDuwgjAABnHnvsMSlWrJgcPHjQFrRs1qyZ7ddakb59+/LJhAlG0wAAnDp37pyFkQIFCvj3bdmyRcqXL2/Phw4dav1HnnvuOcmVK5fDkuJSIYwAAEJ+9W2dMn7FihWJAgu8g2YaAADgFGEEAAA4RRgBAABOEUYAAIBThBEAAOAUYQQAADhFGAEAhATfgnknT55MtD9nzpw2v0imTPzK8io+WQCAU7o675133mlziajmzZvLoEGDJC4uzl4vWrRI1q1bJ/ny5eOT8qhI1wUAAIR3EOnfv79/CnjfjKxTp06VzJkzywsvvOC4hLgcqBkBADgzbdo02z7zzDOSP39+ez527Fjbzpw5k08mTBBGAADO7N2717ZNmjTx7ytXrpxER0dLbGysHD16lE8nDBBGAADOFClSxLYff/yxxMfHy9mzZ2XKlCkWRLTTKgvjhQcWygMAODNv3jx56qmn7Hlk5P+6MZ45c8a2vXv39h+Dt9GBFQDgjI6cOXLkiIwcOVIOHTpk+7SJpnPnztKvXz8+mTBBzQgAwDkdQbNr1y7b5smTR6666irXRcJlRJ8RAIDz4b3NmjWTbNmySYkSJaRVq1aJ5hmB99FMAwBwhnlGoKgZAQA4wzwjUIQRAIAzzDMCRRgBADjDPCNQjKYBADjDPCNQdGAFADjDPCNQ1IwAAJzT+UV2795t08EXLVpUsmTJ4rpIuIwIIwAAp3Tm1e+//97Wo0lISEh07M4775SsWbM6KxsuD5ppAADOLF++XPr27SunT59O8nidOnWkQIECl71cuLwIIwAAZ959910LIjr9e+XKlSUqKirRcWpFwgNhBADgzMGDB207atQoqVatGp9EmGKeEQCAM9onBKADKwDgsvryyy/9fUTOnDkjb731lo2meeihhyRv3rwSERHhP7dRo0YXNd3AewgjAIDL6tZbb5UDBw4EdO6KFSvowBoG6DMCALisqlevLkePHg3oXGpFwgM1IwAAwCk6sAIAAKcIIwAAwCnCCAAAcIowAgAAnCKMAAAApxjaCyCopk+fLvv27fO/1gmssmfPLsWLF7f5JaKjo9N8TZ0Q65tvvrFF01xw/e8DXkfNCICgh5Fp06b5X589e1Z2794tb7/9ttx2223yxRdfpPma/fv3lxEjRjj7pFz/+4DXUTMCIOjy589vy8KfT0PJwIED5fHHH5epU6dKlSpVAr7eoUOHnH5Krv99wOsIIwAui8yZM8uLL75oNSNaSzJu3Dj/sSNHjsjXX39tNSi6ZPzNN98sVatWtWMaXP7880+Jj4+32omWLVtKiRIlUn2fjzavbN682dZAKVu2rDUVZcmSJdE5J0+etPVSduzYYWujaA2OBqrU/n0AwUEzDYDLRqf2btKkiQWEEydO2D4NE7pv/vz5EhMTIxs2bJB7771Xhg8fnuK1Unuf1sQ88sgj1sSiYUWXqh82bJiFCT3fR4OKrhz7zjvvyOHDh+Xzzz+X22+/PV3NSQDSKQEAgqh169YJLVu2TPb46NGjE6677rqEX375JeHMmTMJdevWTXjxxRcTnfP2228nVK1aNSEmJsZeP/jggwmdOnXyHw/kfStXrrR/54cffvAf379/f8I777yTsHXrVnsdHx+f0Lhx44RWrVolxMbG+s8bOnRowo033piwb9++JP99AMFFzQiAyypXrly2PX78uC2W1qFDB+nWrZvt0xqLH3/80WoyTp06Jfv370/yGoG8T5tt1KxZs+zfOr8vS5kyZez16tWrrWmmZ8+eNuLHp3v37hIbG2u1LgAuPfqMALisfE0kGkq0f0azZs1k5MiRsmbNGgsRxYoVs4evqSUpgbyvWrVqFlYmT54sH3/8sb2uX7++3H333VKoUCE777fffrOtNhv5np/fx+XCfQAuDWpGAFxW+gteO5CWLl1a9uzZI507d7Z9gwYNkhUrVlhfjVatWqV4jUDfN2DAAPnqq69kyJAhVivy73//2/qDaI3I+WHn/FoRH+1vUq9evaB+7QCSRs0IgMvm9OnTsmzZMquh0GaUhQsXWqfR999/XypWrOg/76+//kr0Pp047XyBvk/ly5dPWrdubQ8dfXPXXXfJlClT5JZbbvGPimnYsKG9Pr+cY8eOldy5cyf57wMILmpGAFwWCQkJ8vLLL9soGp1rROXMmdO2x44d85+nIeM///mPPdfhtL5ROOc32QTyvnXr1sm7774rcXFx/nP0OlqOAgUK2Gut+dDno0aN8v9b6oMPPrD3XnXVVUn++wCCK0J7sQb5mgDCWJs2bWTv3r3SqVMn/1Tq2uFU+2VoYHj11VelQYMGdkyDSceOHW3YbYsWLWwuEB1aW7JkSVm7dq2MHj3aai102O2YMWPsmlqrov0/Untf+fLl5f7777fp53VuEa3d0CYbDRUaNnz9RnRIcJ8+fSRPnjwWTrQTrNbePPvss3LffffZORf++/oAEDyEEQCXfG2aHDlyWB+RWrVqSbZs2RKdrzUXGiR27dpltRQ33nijrWOj/Tt0EjNdD0bDxty5c62viAYBbZoJ5H06skb7k+iIGa350DLo+7Wm43waijSA7Ny50zrH6nt9nWFVUv8+gOAhjAAAAKfoMwIAAJwijAAAAKcIIwAAwCnCCAAAcIowAgAAnCKMAAAApwgjAADAKcIIAABwijACAACcIowAAACnCCMAAMApwggAABCX/h+lzBjpGUmHYQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Phase 9 dataset comparison complete.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Completed Phase 9 - Dataset Comparison\n" + ] + } + ], + "source": [ + "def list_dataset_dirs(exp_root: Path):\n", + " ignore = {\"jobs\", \"logs\", \"jobsCompleted\", \"dask_logs\", \"DatasetComparisons\", \"reporting\", \"reporting_replication\"}\n", + " if not exp_root.exists():\n", + " return []\n", + " return [\n", + " p for p in sorted(exp_root.iterdir())\n", + " if p.is_dir() and p.name not in ignore and (p / \"CVDatasets\").is_dir()\n", + " ]\n", + "\n", + "if RUN_PHASES[\"p9\"]:\n", + " print(\"INFO: Starting Phase 9 - Dataset Comparison\")\n", + " ds_count = len(list_dataset_dirs(EXP_ROOT))\n", + " if ds_count >= 2:\n", + " P9Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " outcome_label=CFG[\"outcome_label\"],\n", + " outcome_type=CFG[\"outcome_type\"],\n", + " instance_label=CFG[\"instance_label\"],\n", + " sig_cutoff=P9_SIG_CUTOFF,\n", + " show_plots=P9_SHOW_PLOTS,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 9 - Dataset Comparison\")\n", + " else:\n", + " print(f\"INFO: Phase 9 skipped - requires >=2 datasets, found {ds_count}\")\n", + "else:\n", + " print(\"INFO: Phase 9 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "1ac8f00a", + "metadata": {}, + "source": [ + "## Phase 10: Replication\n", + "Optional phase, used when replication data is available. Trained models are re-evaluated on the same replication dataset(s), giving a uniform external or held-out performance check.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "f9e7fd31", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Starting Phase 10 - Replication\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running Statistics Summary for hcc_survival_rep\n", + "INFO: Running stats on Decision Tree\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA00AAAInCAYAAABEG7KkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAwUFJREFUeJzs3Qd0m9X5BvBXe3jvFWcnJGFTZpgtlFlmofBnlVI2ZZRVCoVSStmU1bL3LHsWyi677BVIyF7ee9ta/p/nOleRFUmWZcmSrOd3jo4d65P06ZPsfI/ee99rGBwcHBQiIiIiIiIKyRj6x0RERERERMTQRERERERENAJWmoiIiIiIiCJgaCIiIiIiIoqAoYmIiIiIiCgChiYiIiIiIqIIGJqIiIiIiIgiYGgiIiIiIiKKwBzpSiJKT263W/r6+vz/NhgMYrFYxG63J/RxBwYGxOVySU5OTkJvE+u+4TIS7AeOFxEREZHG0EQ0Ab311lty1llnidPpFJPJpH7W398vZrNZttpqKznttNNk6623jvvj3nffffLAAw/IJ598ktDbxOLuu+9WjxMc1rKzs4eFpH//+99SVlaW0H0hIiKi9GIYHBwcTPZOEFF8/ec//1GhCUFhl1128f+8oaFBbr31Vnn22WfllltukT322CNjD/3111+vjs/HH38shYWFyd4dIiIiSmGc00SUQVBBueKKK2TnnXeWiy++WLq7uzfYxuv1qgpMJNjG4/Fs8HNUb7q6ukLeJnC4YLS38fl8IfcFtwncd1TR4gWPp+8bzzHU50rRHqORtiEiIqL0wNBElIGOO+44aW9vl9dee83/swULFsgxxxwjm266qRrCd9BBB8mHH3447HbffPON2mbzzTeXn/zkJ3L00UfLokWL/Nffdtttst122/n/jfDxhz/8QW27/fbby5Zbbim/+93vpK6uLuxt4Msvv1T3jf3YYost5IADDlBDDgNvc8QRR8ijjz6qAiCGGm677bZy0003hQw5o/Hwww/L3nvvLZdccolss8026vFXrFihrlu2bJmccMIJ6vlj3/bdd195/fXXh90+mm2IiIgovTA0EWUghBcdTmDx4sUqpOTm5soHH3ygfv7zn/9cTjzxRPnf//43bJvq6mr56KOP1Bykqqoq+e1vfyutra0hH+fPf/6zfPvtt2qeEAIXhg3W19fLNddcE3bfcL8IZrNnz5b3339fPvvsM9l9993l9NNPV7fXEGQQRp544gn57rvv5LzzzpPbb799WLiKVVNTkzQ3N6t9uffee2XatGlSU1Mj//d//6eabOAx8HzwbwyD1KEomm2IiIgo/TA0EWUgdNFDk4iWlhb173/84x9is9lUmMH8HqvVqkLKvHnz5Oabb1bb3HnnnVJQUCCXXXaZCle4jz/96U9qGNo777wT8nF++OEHqayslPLycv/wwKefflpVhMLB402dOlXdNzrZZWVlqdCBqs91113n3w5D5y699FJ1/2jk8Ktf/Urt+3vvvReXY4RqEY6DbpiB549hgTfccIN6HmiwgXC30047yd///veotyEiIqL0w9BElKEwX0h3jUNFBcPy8LPOzk7/BUPMUC3B3BxUn1ChQpDQEGpQifrlL38Z8jEwNA2Vq8MPP1x1rlu+fHnEfUIA+/rrr2X+/PliNA7/84TgsXbtWlWpAlw/ffr0YdsgzIWbOzVakydPHvZvHKNZs2ap5x94jDbbbDNV9UJ1KpptiIiIKP2w5ThRBuro6FDNE1Cl0f/GCf/PfvazDbZFRQqNGjAHCpWm0TjjjDNkzpw58uKLL8o///lPueqqq1TQueCCC+SnP/3pBtv39vaq4BSqm53+WU9Pj/qK9unB6ynh3/FqCIoAFgjHCMPvQh0jhEeEo2i2KSkpicv+ERER0fhhaCLKQJgnBLoBQ15enmpNHjj8LXBBWASI/Pz8kHOXEGIQVhCuQsHcKFwQhj7//HO59tpr5cwzz1TzlXCfgXAfqNKEqsigXTqMNrjFC47RJptsIvfcc8+wn6MKhwCK9Z6i2YaIiIjSD4fnEWUYhBec1E+aNEl222039bMddthBrVekqzjaSSedJEceeaQ/YCFsBbb3xrwiVFWw3lEwVHxQWdFttzG/B/eBxgj4WagAprfBHKnAdt24LzRS2GijjZK2phKGDH711Vcb7DeqZr/4xS/U0MZotiEiIqL0w9BENIFhfo+eV4PqDULPqaeeqjrhYXFXPT8JlR+EIQynQ+txtATH9dj+/PPPV9ucdtppKiShS92SJUtk1apV8sc//lEsFotq/x0MQQc/P/744+X7779XQQKd9B566CHVxhsd6UI599xz1VDAs88+W3788UfVwvvCCy9U86HwNVlOOeUU1fwCxwHBCJWvu+66S3X0wzHCcMFotiEiIqL0w//BiSYgBBnMocECtoE/Ky4uVusZYQ0itA7XMM/oqaeeUusfITihIjJz5ky5//77/UP40BjhySeflFtuuUW1Gcf9oTHE448/rjrFAQIDHlc3asDt0ZkPQQtBCMP8dt11V9WZT89HCrwNzJ07Vz0ObodKF6BJBR4HX/VtguccAYa/hRsmGEw/bnDDCXQRxM+D50vpzn/6+aAShuB3xx13+Ct20WxDRERE6ccwGK9Z00RERERERBMQh+cRERERERFFwNBEREREREQUAUMTERERERFRBAxNREREREREETA0ERERERERRcDQREREREREFEFGr9OExSfRcR3rzRAREVH03G63Ws8M67UREU10GV1pQmBKxDJVuE8sasklsHg8UxXfozyeqY7v0dQ/non6P5SIKBVldKVJV5g23XTTuN5vb2+vLFy4UGbOnClOpzOu952JeDx5TFMd36M8ppn4Hv3uu+/icj9EROkgoytNREREREREI2FoIiIiIiIiioChiYiIiIiIKAKGJiIiIiIioggYmoiIiIiIiCLI6O55RERElBxer1et9URElMxO2iaTKaptGZqIiIho3GBtp/r6emlvb+dRJ6Kky8/Pl/LycrVYdyQMTURERDRudGAqLS1Va0aNdKJCRJSoD3Cwhl1jY6P6d0VFRcTtGZqIiIho3Ibk6cBUVFTEo05ESeVwONRXBCf8XYo0VI+NIIiIiGhc6DlMqDAREaUC/fdopDmWDE1EREQ0rjgkj4jS7e8RQxMREREREVEEnNNERERENAr//e9/5W9/+5v/30ajUaxWq5pI/utf/1p23HHHkNupEy+zWXJzc2XTTTeVk08+WUpKSoZdX1tbKw899JB8+eWX0t3dre5zn332kUMOOUQ9Tjjvvvuu3HPPPdLW1iYbbbSR3HDDDSM+jzfffFOuueYa2X777eWvf/1ryG0+//xz+eMf/yibbLKJ3HjjjSG3qaurU9f98MMPUlhYKMcdd5z87Gc/i/jYN998s3zyySfy6KOPDvuk/8UXX5Rbb71VfX/bbbfJrFmzQu7zjBkz5I477hh23X777Scul0v++c9/yuzZs8d8TGMx2mPx7bffyt133y2rVq1S2+M5HHroof5jgn3G67pmzRqpqqpS94fXS4t0/VlnnSVZWVly5ZVXxvU5ZqqUCk0NDQ3S0dEh06dPV39UIsF2mExaWVmpeqwTERERjYeenh5ZvXr1Bj9fvHixfPDBB3LvvffKDjvsEHY7+Prrr+Xjjz+WF154wX/OgxBx6qmnqttpy5YtU/f53nvvqaARaigRgsKZZ54p/f396t8+n29UzwPnXeGguxi2KS4uDnn9wMCAOlFfuXKl/2effvqp3HfffTJ//vyQt1m6dKncddddKjQGP5/HHnvMf8yefPJJufjii0Puc6h5cfg5jgX2SYv1mMZitMcCx+Goo45S+6zhPdHZ2Sm//e1vZdGiRXLsscf659rg/YUgjrC42267jXj9TjvtJH/6059k3333Vd/T2KTM8Dy8Yf7v//5P9t9/f2lubo7YeeeSSy5RKXrPPfdUb4LXXnttXPeViIiIaOrUqfL666/Lq6++Kvfff78KHzhPwfehttPbXnHFFepEHSfNH374odoGFZCzzz5bndxvs8026kT7mWeekYMPPlhdj3Md3D6UlpYWFZgQvh5//HF/pWY8/Pvf/1YhYfLkySrwoEqCVs533nln2NugMuLxeFSlJ9CKFSvkq6++ki233FJ1NUPVKTBQjNZYjul4HAs8Pp7fLrvsosIzKnqA5w1PP/20CkSHH364PPfcc/LLX/5S3R9e42iuR9XKZrNtUJGjNK404QX/wx/+IDU1NSNu+8gjj6hPHvDHBmXM1tZWOf/881WZG1UnIiIiovGAkS5TpkxR3yMwHX300XL55ZdvUF0K3E5vixP45cuXq+Fc8PLLL6tzGlR0MFxLt0K+6qqrVJjA0KuZM2dusA8YnnXeeef5K0w4n0K1A8PXEBoQUFC9QHDAsL0TTjhB5s6dG3G4GIbFrV27VubNmyfbbrttxGOASg4ceOCB8pOf/ES1bcbJ/BdffKECZHALZ1SuEC6wD5MmTRp2HQINHHHEESpMIjy88cYb6uQ/FrEeUzjllFNURSoUVI3+8pe/jPlY6P3BUMI5c+aoIBn4c1SJUEG02+1q+Kc+XhhyF831qMZhX9955x31XPCeoDQOTd9//716433zzTdRbY/ABFdffbV6U+KXHyXWl156SZV5iYiIiMYbKj1vv/22+h4f6kaCE1jMQQGcuAMqLLDzzjv7T5oBHxI//PDD6qQ43OPqD50RmhDYMIUBgelXv/rVsBP/JUuWqMoKhsZh+GAwBKVjjjnGP8wP27/yyisRnwtuA/qDa71AKD4Qx9o3wQuGIsChurLVVlsN+zlCBaoteO4///nPVeBAaMJ5X6yhKdZjCgiz4YZWBs+zivVYoBKFyiOCLZ4r5qPl5OTIOeec498G89/6+vpU+EFFEfeBoBTt9ajaITS9//77DE3pHppQvkRgQmkRvyz6FzUUfDqhf/lRysSbHl8RmhYsWCCpqw+zsJK9E2msV8xmDNmsx+cmyd6ZCYLHlMcz1fE9Gu/jaTCE//81FfS7POL1Do7745pMBrFbYzsdwlAsnODjhF8PkYODDjoo5HaAwNDU1KRug2qLnuuC20NZWdkGjxPp5B7hAwEAYQcVBgzTys/PV0MEcc6Ek+hLL71UNZy4/fbb5a233pI///nPIYel4TZ4DtOmTfNXUnDbwDk6wXDCDhgGBhgiiOYKCHA4bwumz9eCqx44qUew+MUvfqGeB6ZhYN9RvUF4wZC3aOk5SrEeU8CQtnBDA8OtMzbaY4EKESqQqO7huevAFRjwoL6+3v9cEMgRiKO9Xh/n7777LuLzpTQITSj94hOPXXfdVVWLIsFcJ4zVhIKCAvUVfxgAf4BigfsL9UaOFe5v8bJF0tjZJ1l1bZKb8z8pzLtYDIahXyQaPYNxUKbPcInFYhOvN2Wm4aU1q9UnM2e61H8aPKY8nqmI79H4H080E3O7r5Te3t3i9v9dvCbQuz0++XZps8j4ZyYRg8iWs0vFYh79/y+oIARWI3BOcuKJJ6oKT6Tt8vLy1Hye0047zT9kCyfQMNpzEtxOVzZwgq6HAeq5Ur/73e/83duuvfZaNbcHndp0VSQQGgnooWnbbbed+h7PJ7gZQyDdjEsPLUNA0I0oQgUTfXKPYxDo2WefVV/xQbgOmKiY4X2GIW66+qIfL1SzC32OqDvixXpMAaFxtMPzRnssEGJx7oumDZh7haGW6GKIxhWoWurbYHjh888/L5999pnqxnjSSSepLoI6vEW6Xh9nfdwpjUMTuoZES3cHwR8Y/Yda/7GJdaIg7nPhwoUx3Tbk/Q30yfcrv5QuW74sbW+Q7Wa/JBZzS3L+I5hgBly9YjKKuqj/5WjMensZ5uOJxzP+eEzjq7n5LWlv3/BT91iN9Gl9tBBYNptZnLRKUyyBSTd4wAe/OEnHCXpRUVHIFtbYDpULdDtD+2d8CIwTWgytChzyhfk7ekhZoH/84x9quBoqWNEec33OhOFeGh4T1Q+cM4U6b9K30WEjcH5MOHjOgKFlgDlEgPO0UB339OMGHifcVg9tRGdkXIIDFdpn45xP7w86zAV3rgve/7Ec01iG5432WOhgi055qDri8uCDD6pQi8CG4PO///1PNUDT16MzIypLCLiozkW6fosttvCfJ0fbUZFSODSNhi5XoqSNFI9ffN1WcqRf6nDwqUC4SYCx8Ln6ZLJ1QJb2+yS7qkxK8q1itRnUKX5f/5ZiNuSKyTB8IiBFhte7vaNLjBaHeLwGQV62W43isJnEZGR4ivWYdnV1S05O9gYTU4nHMxXwPRr/49naapG8vBOloiL6YU6RoPNbPMU6RC6Zghs8RNoOQ95wQTMGdAvGWkI4d8EJM2BYGoIVhlHhhB7VHpzn4MQZP0cgQOBAs4looLkAhsJhHSSsG5WdnS0PPPCAug9UHzDcLXjIFvYPAQMhRVenMNxvpBFDGPKHeTNof42vOlgEDzMLnO8VWPnAfB48v7322kvOPffcYdtjvjqaNqCV9u677+4fpodggP3UHfgw3QNwzMrLy8d8TGMZnjfaY6GH8aH1ORpu4HnieenjhLlqWCcLa0whbONDft1hGq/hSNdDV1eX+hquZTxFL63+QuETAbzZEZjwCUB1dbV/8mNwB5ZoIf2He/PHwmcyiMtmk2yPyJyymeJwFMmAyyqeQa80uk+SAU+xOC12yXfkSaE9T+yW9Z/mUGgoq69cuVB9gmK22KShtVca2nrVJ5L5OTYpL8qS3Kz4fNqZace0tHRuXN//mYrHk8c0Hd6jnZ0Lpapqctx+5+M1NC/ToHMehruh8y8WQcUwOCwci7knp59+umoXjgsqWAhVulqB2wW36I4Ei+yiSx3mBCE04aRdV0DwOKHWwzzyyCNVSMJCudgvVIOC588EQ1MutNRGxQND//T26IAXCrrEgZ7DEzg0D6EpOITuscceqvPdU089pUITgt3WW2/tX3QXQw4xLE9Xp7BorX6Pj+WYBjdtiMZIxyJ4MWFsj3Wc8PxwDFA9Q5DD9ZiHhS6IGL6HroKoxOF6fACC5XZwHEa6HvR8tEgdEyk6KT9BBKEIJUYkZfyCo9QIePOjAwvGcIIee5tqDAavmLBSuNEiG5fMk5mFU8RutktDd5MsaFws3zcultquBulzp/YE3VRhtZikuixHtphdKlMrcmXA5ZVFK1vlu2XN0tTWJz4fx0ESEVFqO+CAA+SnP/2pOkG+4IIL/KNmMP8I7bBRTcHPcHKPagSGkKHZw2gCL8IJ2pojkKG5AwITho+hsQMCVShYvuWyyy5TwQJBGyMRMO8qEnyAjQVi0WgCIQHnamhKgWpaKDhfQ+DWQ+bQRRnDFnE7dLkLhtCkqzENDQ3qe1TpsK4nhuHheSEw4digqRjCSKB4HtORjHQs9MK8OjCiex7ahmOePipvGEKH98X111/vfw0RCvG64XkixGItpptuuimq6wHHVh93GhvDoJ41lwLQFhG/pPiEQ5dWUbbGpMC///3vquUkvsekxMCxmfgkAeFptGOrdVkafyTixTfQJ+2Lv5CVPSJzNttKnM6LxOUaKs9are9imujQdoM+6ezvkrb+Tmnv7xCvzyd2s00KHXlS4MgXBytQfnhPoOSMT0lC/XHr6B6Q+pYe6eh2idlslNICh5QVOsVi5rCzWI8pjQ6PZ/zxmKb+8Yzl/1CcvGMIEj4FD5w3k25w8othUDjviFSRiLQdXhPdxApVheDjgZN7jKzBsKpQ86QCYTt8yIztcOIeDBUIPB5G7ATel94/VKFwnYZhaTgJx89w37W1tWr/QnWh03BehlCDeVojTZn4zW9+o5oWoFqE+0dgQMDQ7dcD4TRVzy1CGAl8/+r91MPZdCOGcEZzTMci3LEId7wB7wVsr4fsBUL1CNdjv0NVCCNdj0Zr2IeRWsdnsv4o/y6l1PA8hB+9orWGXyCMBdUTGVFyxCQ3jMvFGw/jR9GPPl6TUeMvcDzs+n00GoxqiB4uvsEq6Rzolra+DmnsaZHarkZ/gML1TsuG42Bpvbxsm7r0DXjU0L36ll6pa+6Roryh8JTliPxHlIiIaDRwEhrNXOpI2+HkP9J8qJHWegqE86ZI94WT8cCmEyPtH86pdECKdt4WQki0Q9owrOyjjz5SQ8r23XdfNd8qHFSlwj1+4H5GYzTHdCzCHYtI7wcEwnBQ8dPFhNFc//XXX6s5Uqge0tilVGhCS8lgWFk7VKtHva5B6htqOxnpcKsAZc9VF1WBGuiW9mEByqqqTwUMUBE5bGY1ZG9SabYaqtfQ2iPN7X2S47RKeZFTzX/iGHwiIqLkQvUD86zQpAKhiRIDww9ReAhugU8TIDRNTIGVppErHsEBqmtdBaqpp0XqAgOUPU+cVlagQjGbjFJRnKWCUlvX0NC9JWvaxWYxSVmRU4rzHWobIiIiSo5bbrnF35CBEuP3v/+9quKxS258MDQl3NCaASKYXzO6TkMIUHn2XHVBgOoe6JHWoAA11IUvnwEqBFSVCnPt6tLd55aGlh5Z3dAlaxu7pSR/aOie3cZfASIiovGGk/lIw/Jo7GLtLE2h8YxxnELT4ODY5lwhQOXac9TFN1jpD1DNPW1S39UkNlWBylMVqCwrJ/YHy3ZYJHtSvlS7vWre09DwvV41ZA/hCXOiiIiIiIhCYWgat+F58TvUgQEKXWXUEL7+oABlRxc+BqhwLcsrS7KlpWMoOP24qk0cdrMKT8V5DjFywVwiIiIiCsDQNG6VJkvChqDpADU5b1C6XD3S1tcuLX1tUt/dJFaTRQod+ZLvyJVs68idfjKFyWiQ0gKnuqBlOcLTytpOWdvQLSXrWpYjYBERERERMTSN25ymxLe9VgHKlq0uk1GBcvWoLnyBAUoN4UMFyuJkJ7mgluX961qWD7Ut75GCXLuUF2WpoX1ERERElLkYmsat0jS+hzowQFVjDpSqQHVIa1+7NHQ3rw9Q6+ZAsRW3qKYQUypypao0W7Uqb2jplR86WiTbaVHhqYAty4mIiIgyEkPTuM1pSl61AoEox5atLghQPa5eFZ4QonSAQotzDONjgBpqWY6QhCF67aplea8sXdMuVotRygqz1PA9tiwnIiIiyhwMTWk+pymWAJVty1KXwADV3t+pFtPVAQpVKMyByuQKFJ47hujh0oOW5a29sraxS2qautVaTwhVWFCXiIgyy9tvvy1XXHHFsP8vrFarVFZWyrHHHqsWbw21HZjNZsnJyZHNNttMTjnlFCkrKxt2/dq1a+WBBx6QL7/8Unp6eqSiokL22WcfOeyww8RoDL/G4FtvvSX33HOPtLW1yUYbbSQ333zziM/jzTfflCuvvFK233579TWUTz/9VC688ELZZJNN1NpKkTz//PNqmxNOOEGOPPLIiNveeOON8sknn8jjjz8+7FxD3wfcfvvt6rmE2ucZM2bI3XffPey6vfbaS9xu9wa3i/WYxqKmpkb+/ve/y/fffy9FRUVy3HHHyc9//vMRb4fGXr/73e9k4cKF6rXbdNNN1c+xz3ieq1evlsLCQtlvv/3UYrV6vyM93hlnnCFOp1OuueaauD7HTMUzvoTyrbuk5qEOFaDQhQ8VKAQoi8ns78KX6QEqy2GR6VV5Ul2WrcJTY1ufNLb2Sl62VVWl2LKciChz9PX1qZPVYMuXL5ePPvpIhZcdd9wx7HawYMEC+d///icvvviiWCxDH6x+/PHHctppp0lvb69/u5UrV6qfv/vuu/LPf/4z5P/FAwMDcs4550h/f7/6d7RBAAEC+9fS0hJ2G9wntgkOd8HWrFkj119/vTQ1NUl3d3fEbZcsWaKCwKmnnrrB8/nXv/7lP2ZPPfWU/OlPfwq5zwiewWpra8XlcqmLFusxjQWOFUILAg6sWLFCvvjiC/V+2GmnnSLe9rHHHlOBUL+esHjxYvn1r3897PkgxHZ1dcmJJ5444uPtsssu6vjtu+++/iBPsYtvvKYg69/kqVJpGilAVedVyqZlc2ROyQw1XA8VqB+bl8u3DQtldXuNdA50q09DMpXFbJJJpTmyxawSmVaZJy6PT7Us/25pswpRXl/mHhsiokwzdepUVeF544035KGHHlLVD5/Pp6oaobbT21599dUq2OiQBQgaZ599tjq532677eTBBx+UF154QQ499FB1PW77n//8J+R+tLa2qhNohC8EDQSB8fThhx+qyhICUzQQmLxerxxyyCHDfr5s2TL56quv5Cc/+YmqkCBQ6gARi7Ec01j8+9//VgEGr/eTTz6pKkI4Z7rrrrsi3g6VMATOYHivIDD99Kc/VfetA+RLL70U1eOhKmW32+XOO++M23PMZKlX/piQnfNSPzRtEKCsWeqCEIUmEu19nWoYHypQZqNZChwYwpcvORlagcJaTpjbhEtnj0t121tZ1ylrGrtUG3O2LCcimvgQUiZNmqS+nzx5shx11FFy+eWXq6pLuO30tjixRWiqq6tTP0NAaG9vl5KSEnUdTnYBw/uwHW4fPFQNUFn4/e9/r773eDwqJBx//PEybdo0VZHAfSGYoUIzZ84cNXQOQ+3C+frrr+Uf//iHOpHfeOON1dC9SD7//HP1eBieiMdEtSMS7Mcrr7wi8+bNk6qqqmHXPfvss+orTv5RCcJQvddff132339/iUWsxxRQyUGICwVVxL/+9a8b/BzDDeGAAw6QzTffXA2XQ5jBEDu8NhiaGQwhB2EI4Qj7GRg8ERwBx3XmzJn+apn++UiPh+122GEHeeedd2Tp0qXqPih2DE3jFJrS+VDrADUpr2JoCF9fhxrG19TTqgLUUBOJPNVoIhMDVG6WVV36Xetblte19EghWpYXOiXbaU32LhIRUYJhKJ4eXoWT15GGp+lgVV1d7Q8rsPPOO/tP7gH/r6KKpYfwBUMlpqGhwX8CjqFrnZ2dqsqCOTuBIQbfYx/vuOOOkMPFsE+Yk6WrO9j+tddei/hcUDFCZeiiiy5SJ+wjhSaEIcw72mqrrTa4H1SBHA6HmpOD4YAITaicxRqaYj2m0NjYGHZoZbjhjHp7zJkK/IrnizCk/x08HBHHBEMVEYICQxMqYjj+9913nzo2HR0dkpeXJ+edd17Uj4fjjND0wQcfMDSNUfqeyafZ8DyRiXHijO56uPgD1Lo5UM29wwMUhvoZDZk1+tNuNcuU8lyZVJItTWhZ3torP6xoVfOhyoucUpBjVxUqIiLakM89IOL1jP+hMZnFaLHFdFPMjfnZz36mPtXHEDmcrMLBBx8ccjtARQEn3RjGh0oOKgGABg5QWlq6weNEOrlHYHn00UdVlSsrK0tVV3Bife+996oAg+YUl112mbrf2267TVVu/vKXv6ihX8Fwco7AhGGGqJgBqiCRghAeH/NxAKFpJGhYANOnTx/28/fee0+d6P/iF79QzwMVLuw75vCsWrVKpkyZItHSH+DGekwBlSn9egZDsAsXnMFmG3o/mUwmNQwTr3XgnKrAOVjXXXedzJ49W8270pUjDfeDY4Ahizqo5ebm+vc9msfTx/m7776L+HxpZAxNCWQwBP7xT5/heaMOULkV0uvqk9b+drWY7lCAMkm+aiKRqypQmRSgTEEtyxGelq3tEIu5S8qKnGr4HluWExGtN+h1S9/K71AqGf/DYjCIc/rmYjCN/v9pnFQHViPQ3ezkk0/2z5kJt11+fr7aBtUF3bRBV0JCnVxHghPm8vJy9T3uSw8D1HOl0JFNNwHAXCpUmjAPBsPvgmEIF+A5bL311v5haqgihRNqyFkkzc3N6iuCXaBnnnlGfX3//ff9AROhB9Wzp59+Ws4991z1Mx0YEAyC6TnXYz2mOiyOdnie3jeEaL2Pej8xfDHUYyCk4nUJdT3mpmHeEo4HhmBi2B0C8Omnn646M0bzePo4R2r2QdFhaEoo94SrNIXjtDrURQUod9/QEL6+9oAANdTGPJMCVGDL8t7+oZblNY3dUtvUI0V5dhWs2LKciEhUYHFM3TRplaZYAhNgAj4qOjhJxwk6QlO47dDRbNGiRWo+DYZ+IWxkZ2f7t5k1a5aqAuHEOBhaUGO+C4JWqJPrUPSJdOBjYB9RjcCJdagqiv6ZrlwEzp+JF/0YgcP5UaX773//q77HEDRcAj333HNy1llnqWOGKpTeLhAaYej71pWgsRzTWIbnFRcXD6tw4XkB3h/6Og3VOzTQQPBBa3DQQ/MwL+2II45Qw/bgN7/5japG4YJqICpvCHTRPB5e73Ahk0aHoSmh3BO60hSO0+JQl6rc8oAAhQpUmz9A5TvyJDeDApTTblHd9iaVZqt25QhQTW19kouW5YVoWW7NyPlgRESaGiIX4zC5ZAlu8BBpO8xdwgUn8ocffriaV4QAcNJJJ6ltMCwN6wuhFflNN92khmvhZB5zWtBtDoEAlRQMw4sGGhzgvh555BGZP3++atGNgIf7QaUL+/Ltt98Ouw0aDmAoGCo76NimqzzxpINlYPDAkELs19577y3nn3/+sO1R6ULTBoSqPfbYwz9MD/O4MN8J87awnw8//LD/WOv26GM5prEMz0NzC1Ty0JXvmGOO8c9xw2sefBsdYoKrkDo8IRTq8Irnvu2226qgpBuHYN5cNI+H+W0QHNpo9BiaEsrlH2lgMEzsSlO0AQrD91oDAlTeugpUpgQotCyvKsmWiqIsae3sV133Fq9uE7vNJGWFWWrRXBPnPRERTVioOl166aVqXSVUOzB3BwvdYu7JmWeeqU7ucaKPyhSqPLqigs5nwS26I8H6PRjahTlBmDeFk2h9Ao3KRqhhdUcffbSq6mCIHE7SUbGIZWhbJHPnzvVXcoK75mFx2uAQiqCEAIOAhO9x/LBveF4Y3nbttdeq7fRzw5pEujo2lmM60rpUoRx44IEqDGPfMLxRHztUjYIXE8a8MoSdQKimIeDp9wWG4OG+EHYxfBHNPVBBxPBAzNMa6fH0fLrA406xm/hnqUmVmZWmcBCeKnPLZZOyjWTj0tlSmlWkgtTSlpXyTf0PsqJtjQpVvsGJX0JGQwgEpE1mFMvcaYVqmN6q+k75enGjrGnokgG3N9m7SERECYL1c3bffXd1AnzBBRf4F6XFHCeEAFR8UIHAyT1O8n/5y1+qSkq4CkcoGMqF9aK22GILdV8IFRiOhpN1hKNQ0JgCc3XQbAD7hOF8euhYvCDwYGQFKlqAkPDjjz+qEIcud8EQlABBrr6+Xn2PluhotoFjg+eFC4Yh6pbvgeJ5TEeCwId9wxwzBBhUvRBedYgJXExYVykDL3qYIKpCqAYi0P35z39W/0brdEBnQR0UR3o8wJBQ0A1HKHaGwQxeqVR3Etl0003jdp++gT5pX/yFrOwRmbeFV2y2c8Tt9ojbfaxkZQ1NYqTh+tz9/i58+N5kNEqebagLX64tR/3hXrhwofqUJN5jq1MJWpZjgVx03sMiuYU5dtU4IicBLcvxxzUTjul44fHkMc3E92gs/4fi7znmcuAENrAFdDoeT8wfCRwKNtrt0PlMD1FDmAmcRwQ4uUcb7nDzpAIhfCFQoDKEbmvBUKHA4+HkO3AouN4/BIfANuk6ZOFn+r6xf9jPSDC3BsEAzQcwHDCc3/72t6pT3GeffaaeIwIBQpNuaBFIt1EH7E9gyMG+6TBRUFDgn78TzmiO6VhgnzHEDuEz8H0e7nhruA0aQ6CKFDzPCrfDMQ3V9S/c48Euu+yiboeqI43t7xKH5yUUh+dFw2Gxq0tlTpn0u/ultb9DVZyWtrarAGUbtEq3p3fCV6DQsnxyea4avtfcMTR0byFblhMRpRwEz2jCZ6TtcOIcaT5UcHe5SBA4It0XqjCBDSFG2j+cmOuT+pHuOxCCCy4j+fWvf63WDcL6QRhOF2rfNIS8cI+PfRvNXJ3RHNOxwD6HanM+0vsmUiiNFPTCPR6qeZj7hW57NHYcnjdOw/MydU7TaNnXhad5pbNlk9LZUp5dKv2eAakfaJLvGn+U5a2rVEVqIneBQctytCvfbGaxzJ6MT84MqmX5N0uapLapW9yeifvciYho4kP1A4vr6uYNlBhYwBfDNINb4FNsWGlKKM5pGmuAqrDYJc+ULQMNPVKWVSz9Hpcsa12lmkbk23NUF758W65/TYaJBJ8c5efY1MXfsrypW10wHwrBCl35iIiI0s0tt9ziH1pHiYH5cujQONKwRYoOQ1MCGQwITXrKWHq1UU01VqNFyrNLVFkblSfdhW9562oVoPLsOaoLX54tR0xG0wRuWZ4jTW2961uWZ1nVvKf8bBtblhMRUdrAybxec4kSo6Kigoc2jhiaEgr9/4e+Mxo5PC9e7GablOeUqsuAx6UW0UUjiaEAZRhqY27PU0FqogUoi9kolSXZamHcti7Me+qVJavbxWZFy3KnlKBluWniVd2IiIiIkomhKaE4PC/RbGbr8ACluvC1y/K2oQCF7nuFjvwJF6DQsrwoz6Eu3b0uFZ5WN3SpoXsITqWFTtVYgoiIiIjGjmdVCeXyf2cwcHjeuASo7BJ1cXlc/i58gQFKDeGz56qFdSeKbKdVZjqtam0ntCxvbOuV+tZeKcixqYpUIlqWExEREWUShqaEWj+nid3zxpc1KEDpdaCwgO5EDVA2i0mqy3LU8L2W9j6pbx1qWe60m1V4Ksy1qwoVEREREY0OQ1MCGQwe/5wmhqbkBqiy7BJ1WR+gOocFqHxHruTb8yZEgDIZDWp4XkmBQzp7MHSvR5bXdKjhe5j3VFoQv9XPiYiIiDIBQ1NCcU5TSgcor9vfhW9l21oxGmokx5atKlATIUChZXletk1d+gY8KjzVNfeotZ6ybAbpd3O9JyIiIqJoMDQlfE7TUKnJaLQn9qFo1Kwmi5RmF6uLDlCoQiFAGQw1kosAZUeAyhWzKb1/VRw2s2pZjuF7mPO0urZNVjUMiHN1u0ytNKq1oBCyiIhoZG+++ab8+c9/9v8bfz+tVqtUVlbKcccdJ3vssUfI7cBsNktubq5suumm8rvf/U7dJtCKFSvk/vvvly+//FK6u7tV2+h99tlHjjzySHXbcP7zn//IXXfdpdY+2mijjeT2228f8Xm89tprcvnll8v8+fPluuuuC7nN//73Pzn33HNls802C3ufy5Ytk1tvvVUWLlwoOTk56vkff/zx6piEc80118inn34qTz/99LD/f/DvG2+8UX1/zz33yNy5c0Pu86xZs+SBBx4Ydt3PfvYzGRgYkHvvvVfmzJkz5mMai9WrV8u1114rP/zwgxQWFspvfvMb2W+//cJu/8knn6jXbdWqVWp7bHv00Uf711Ya6f5w3P/1r38Nu0+bzSZvv/22nHLKKWK32+Wmm26K63PMVOl9JphGlSYOz0uzANXfqbrwreqoUZcca5bqwpfuAcpsMkplcbbk2g3S11Eng4ODsmRNu5oPhfWe2LKciGhkODFvbm7e4Oc1NTXy+eefy5133im77rpr2O3q6+tl8eLFatuXX37ZHy7ee+89OeOMM6S/v9+/bV1dnTrZf//999X9hlrMHY9z/vnni8s11IAKaxpGA4+D/evs7Ay7De4T24RbiHbNmjVy2GGHSU9Pj/9n3333nQoBV111VcjbLFq0SAUePNfgD+yeeOIJ/zF76qmn5NJLLw25z8XFxRvcb1NTk9pft3v9+VesxzQWvb29KjTjfQD4es4556j1qHbbbbeQx+G3v/2tf39xLL/55ht1P6eeempU9/fVV19t8B7T76c999xT/vjHP8oBBxygAiWNDRd0SSjOaUrbAJVVJBsVz5DNyuZIdd7Qp4AIT980LJTFzculqadFPF6PpCs0hMh1mmTOlAKZN61QspwWNefpq8VNsqq+U/pd6fvciIjGy7Rp0+SDDz5QJ+Y42Z89e7b6MOqhhx4KuZ3eFpUUVBIQLD788EO1DYLLeeedp07ud9ppJ1U9ePXVV1U1BHA7/DuU1tZWFRYsFou88MILcscdd8h4eeSRR1Rg2mqrrdT+/fWvf1U/f/7559VJfyh33323+Hw+OeSQQ4b9fOnSpfLtt9/Ktttuq4LBSy+9NCzsjNZYjmks/v3vf6tgM336dPU6oGIEqHyFgkokAhMqc/heH7tXXnkl6vtD8EJIevfdd/3vsXfeeUddt++++4rD4VCVLBq79P3IPA0YDOtbjouw7XM6sqwLULi4/RWoDlndUasuqEANzYHKVdumc8tyl9srDa290tTWJw0tvWrIHrru5WbxvUtEFAqGdpWUlKjvy8rK5IgjjlBDx3RlINR2+mQWw6qWL18uDQ0N6mcICB0dHep+brvtNjXECjC8D8PfJk+erIb0BUO1CsP8wOPxqMrFiSeeqCoUbW1takjdxx9/rIINhu2ddNJJsuWWW4Z9QT/77DO55ZZb1HOYN2+e7LjjjhFffFRHEAB//etfq5N7XP72t7+poILnE1z1wvA4DLHbZJNNpLy8fNh1zzzzjPr6q1/9Sj766CN59tln1bDDgw46KKY3YKzHFHD8lixZEvK6XXbZJWQVDcMNYf/991fDA/FaIFSiGoTXJngoIIYyAoZoVldXS2Njo/o3hm9Gc38Iyy0tLVJQUCC///3vVaUNFShUowBD8zD08q233pIff/xRvf4UO4amhMKn9eva5/FQpz2EopKsInVBlUm3MQ8MUPmOPClI0wBlDWxZ3jEUnBatbBUHWpYXZklRHluWExGFgzCAE3wINXQsEOanYK4K4MQdvv76a/UVIUWf3GsYyhZuCBkqTAhHgCoXhmqhwoMqC4bNIdRoCEKorvzzn/8MOVxs5cqVas6MHi6G7XXVIhyEEZzAazihR2CqqqpSc4eCIcDh/oODG+7jxRdfVCELlRcEHYQmDNGLNTTFekwBxzTU0EpAEAtFh2X9vPEcAM8XgSh4/tovf/lLFWhQmcRzxeuGeUsYahnN/aEyp/dVvwcefvhhFcQRygHHGY+BiiZD09gwNCWUy99ynJWmiQXzmgIDFCpQrX3tsgYBqh1d+FCByk/LAKValhegNblTOroHVPVpRW2HrGnoktJCh2pbbjGnd2dBIko9Ax6XeH3ecX9ck9GkFkePBRoM4IQcJ/xdXV3i9Q7t/6GHHhpyOx1y9ByiLbbYQnbYYQf1vT7pLS0t3eBxIp3cb7311ipYICBlZ2er4IahbZirg8CECsYVV1yhKl0ISxjyhWoY5lwFQ7MEnJBjmOGVV16pfnbhhRf6T87D0RWUtWvX+qscZ599dshtv//+e/UVFalA//3vf1VIOfDAA9WQsm222UYFL1TScPwwxBGiaVqkt4n1mOpQFRgGAwUHME0PJdRzilCBw+NgKGJfX98G2+umIDp06+qQftyR7g9VJmy/3XbbqeOOytgFF1wgr7/+umrKgSYa+jjr406xY2gat5bjHOI0kQNUcVahuugAhSrUsACFLnyOPDVfKp3oluX9aFne2iv1Lb2qbTkWysXQvSxHej0fIkpN+Nu5oPFHVSkZbzjB3rxsbkxNfnByG1iNwHCzk08+eYPKSPB2+fn5ctRRR8kJJ5zgP8FHUIDAhgrRwAk1qhP6uehhgKjowOmnny7bb7+9+h7D5hCqUMFAwAmGIWuA4X162Br2EcFpJLgtOuahyQW+ovlAKDjRh7y8vJBD8zC3RwdMHS4RChEGAgMagkMw/TMdiGI9poDhbqMdnoc5ZaBDD/ZH71OoToL/+Mc/5I033pC99tpLdShEc4qLLrpINa5AiBzp/g4++GB1nPF7g+OCIXxPPvmkGtanQ5M+zuGqZhQ9hqaECvyEgoc64wKUzyvt64bwre2sU0P4slUXvvQLUHabWaZW5Mqk0uyhOU+tPdLS0S/ZTosKTwVsWU5EY/zbuUnpRkmrNMXaFRXVDwyHwkk6TtDDda3Ddg8++KCatP+Xv/xFamtr1VAsfVIPGDqFCsEXX3yxwe2vv/56NeQPc32i7Yynq16oRGg40ca+4jp9fajb6JP1SFWV4MB0zDHHqECENtcIHOGEqt7gdhg2qANOcMhBUwncJ/YLVTQI7uaHyou+b31cx3JMYxmepwMr5hrp5wU45oFz2gLbjQOO3ZQpU9QFc9DQIATHdKT7Q4MHhGAEW8yTCwyV+gOIeHUGJHbPSyg2gshsWBy32Fkos4qmyWbl82RqwST1MwSob+sXyqKmZdLQ3aRanKdTy/KK4izZfFaJzKzOVz9buqZdvl3SrBbP9Xi5YC4RxQZD5JxWx7hfYh2aF9jgoaioKGKYwXaYj4IhcQhPqAxhKBzmA2mY7I/hV5jvhDWMEAJw4ot5PtgWlY3nnnsu6n1DEwfA4yEAoEKBE3IMv0PjAAzbC6aHwKEToA4v+D4SnNDjpB0n9GgyESkwga6K6QAA6AyHwPOLX/zC3wFOX7AeE7bFukMwdepU9RVzetAUAccIz+2+++5TP0ew0g0mxnJMMTwveF/05eqrrw55GzS30NUyDMPUc9xQAQoMr5p+zyDYYb8QqhGo9ZDCke4PryWG3WFf8dxwewxnBKyrFVitG2meHY2M5Y+ECjwZ5hyQTKYDFC6oQHWs68JX01kvazrqJNvqVF34MIzPOob/wMcLhoBgiB4uPX1uFZgw52ltY7da6wnznlCdIiKi4RBW0L3tzDPPVHOMMKcJ7bpRZcAQLSxkigCAsIPKkJ4LgxPl4LlSkaD7G9aAQmMGDHdDmNBzZBBs9OKpgY499lgVIjC0D/NkIHDNo1AwxEyf6GNhWjQ00B577DH1vALpxWp110DQt0EDiOCKzO67766GyWGIHoax4f7QEQ7d9dCiWy/Kq58bhqvpStNYjimC5WhhPhaCKYILXlN97P7v//4v5GLCaASBxYPRCALHToc6hGuEnJHuD90a8ZywthNeLwQr3B7HCWFTN/cIDNEUO9bsEkr/oUGZe+SJi5Q5AarIWSAzi6aqCtS0gmoxG80qQH3bsEgWNS2VelSgPIEt61MX5jXNmJSvqk/lRU41bO/bpc2yeHWbaiRBRETD4aQWFwyHw3whvZ4RWkrfdNNN6mQe1+EkGvOfsK4QTo6jGSqnzZgxQw0dxJpHOJHWHe1QJTn88MND3gaPi+tRDcIJOipoCB3h4H7RWCKw6oQhbfoSaige9gdDxjB/B7AuE0IRQt3OO++8wfYIUoDubzqcoTMcngOaKOB54YLjhLlUl1122bDbx/OYjgRd7rBGFjoi4vihGoQ5bmjSEWoxYQQ8NNzA64L3APYF1TZUxaK5P7w+WLMJgQiBCRVNzKfTTTwAVTbQDUcodobBZMy6TBFYsRrC9eiPhW+gT9oXfyEre0Q22/oG8fmWy+CgU2y2oQmZNHr4Q6InNEY7ljsdYSx/R3+X6sLXOdAlvsFBybI61nXhyxvTEJLxPKY+36AKTvWtPdLX7xGHzSxlRU4pynOoznwTUaa8R8cTj2nqH89Y/g/FSaPuhBZquFK6GBgYUCe+OEmNVJGItB1OcvXcGEzWD24UgGOF0IGOeCNBGEBgQRjBiXQwPBbuT3dqC94/nKwHXofhbnjP4LH1fSPUIGwE0i3Ow0H4ClXRQqMJVLPQsAAjF9A5DtvpoXvBsP5QqOOEx9dd57CvI3XWG80xHSu9RlXg/LBwxxswFBIVsnBzkELdXyCEQRzD4OODIIr3HtasorH9XeL4mXGpNPEwU3STkQud+eqiAxS68NV21svajrqhAGXPUyEqngEq3oxGg5QUONRFtyxfWdspaxu61c8wdA9rQhERpSuc9Iaa2D+a7XByG+k+RhMqcbIc6b7wWKG6t4XbP5y462AR6b4Du/WNBtaCQuMHzNUJHE4XTqTH1wvERmM8g3pwd8CR3g+6wcVo7i9QqGOIBhgInCPNM6Po8Gw+gQyGodA0OJi6J7iUJgFqoEvNgartapS1nfXitDj8Xfjs5vgNLUhky3KEJ1zqWta3LM9my3IiooyDOT1YXPfRRx8N25qcxg5zpVBdRmtyGjuGpnGpNPFTdRpjgHLkqwuGTLQPdEr7sABlHxrCl8IBCk0hplTkSlVptjS390lDS6/80NGiWpaj8oQQFc2ChURENDHcfPPNakFgShw0HEF1jW3H44OhKaF0pSl91uOh1IY/fIEBaqgC1S51XY2qkYQ/QNlzxW6xp2TLclSYEJTauwbUYrnL1nbIGkuXlBVmqeF72IaIiCY2nMyn87y2dBBqfhvFjqEpoTg8jxIboFSbckdeQIDqkPru9QEKw/cK7XkpF6BQVSrItatLbz9alvfK2sYuqWnqluJ1LcvRQIKIiIgoFfCsJGHQlJDD8yg5AQrd91r7OtTiubWdDeJQFaihdaDwfSpx2i0yvSpPqsuypbGtT817amztlbxsq6pKYU4UERERUTIxNCWMd11wYiMIGv8AhQoTLr5Bn3SqLnydwwKUXawy4EutdaAsZpNUlWRLRVGWtHb2q4YRP65qE7vNJOWFWVKUP3FblhMREVFqY2hKEIMBoYmHmZLLaAgMUFXSOdCthvA1tDfKmr46sTVnSUV+qboeHflSpWU5hujh0tnjkvqWHllZ1ylrGruktMDJluVEREQ07hiaEsRgXL8KNhtBUMoEKHuuupRYC8TV2KuCUmNPi+rEh857eohfqgSo3CyruvS7QrQsL3RKtpPt/ImIiCjxGJoSvEbTEHbPo9QLUFlmp0zJqxK7wy5d6ypQTT0tqhOf3Wxd14UvT5zW5Acou9UsU8pzZVJJtjShZXlrr/ywolWyHBYpL3JKQQ5aqnLoHhERESUGe/smiMGwvtLE0ESpHqDy7LkytaBaNiufK7OKpkq2NVsFqB+alsiChkWytrNOel19yd5VMa1rWb7ZzGKZNTlfzXFCy/JvljRJbXO3uD2+ZO8iEWWAt99+W7bbbjv56U9/Kq2trcOuO+aYY9R1ixcvHvPjNDQ0qLV29t13X9lll13kl7/8pVx99dXS1NTk3+Zf//qXery//vWvIe/jP//5j7r+3HPPjerf4fztb39Ti6QODg7N19aeeuopdXtcfvjhh7CPj+MSDM8J1y1atEj9+4033vDfFy477LCD7LrrrnLEEUfIa6+95r9d8Ha47LTTTrLPPvvIH/7wB1m7du0Gj7Vs2TK56KKLZO+991bb/upXv5L7779f3O7AD7njY8WKFXLKKaeo54dj9sILL0Tcvq+vT66//nrZa6+9ZM8995QrrrhCenp6or6/SLc/+eST5Ywzzoj7c8xErDSNy5wmVpoovQIULr7BSuke6FFd+Jp72qS+q0lsqgI11IUvy+pMbsvyHLu6oGU5Kk81jd1S29QjRXl2Ne8JXfmIiBLB5XJJe3u7utx0001y+eWX+6/r7OxUP/d6A88DRg/3g7BQW1s7LEQtWLBA3nzzTXn66aclPz9f+vv71eMFnmQHGhgYUNd3d3dH9e9QFi5cKI888oicddZZGyxEjtCG28OTTz4pl112WcjHx/MJ1tbWpo6lDi76uAarr6+Xr7/+Wm6//XYVVMNthzC5fPly+eKLL+SVV14Rq3VoCPd///tfOfPMM9W+BG77zTffyAcffCB33XWXmEwmiQe8Dr/5zW+krq7O/5pdcMEFkpOTIz/72c822B4h9NRTT5WPP/7Y/7OHH35YHZsbbrhhxPsb6fY6SOI9s8cee8TlOWYqVpoSdWCHDc/jvAtKzwCVa8+RqQWTZLPyOTK7aJrk2rJVgFrYtFS+QwWqo056XL1J3U+Eo2mVebLF7FKpLM5Si+YuWNYii1a1qu+DPxUlIoonVFp0pSSecNKPwLTJJpvIM888I++//748+OCDUlJSImvWrFHVlmjgpBkn1DiBjhVCBf6WosoRCNU0hDhUerKysuTll19WVY+xmj59utrnDz/8UIXDuXPnqsdHcAu1nd72lltuUeEHxwf/BoSr8847TwWm3XbbTb1eOHa68oXQhGMdL//+979VwJkxY4Y6Hvpx7r333rBVS+x/QUGBen4PPfSQOBwOeffdd1VgGun+Rro9KmtOp1O9hjQ2rDQlCIfn0UQMULhMzhuULlePtPW1S3Nvm9R3N4nVZJFCR77kO3Il25qVlH20mI1SWZKthu+1dfVLXXOPLF7dJjarSf2sOM+uhvcREcULggJOTDF0DZ/uh4MhfP/85z/lo48+UtvPmTNHTjrpJNl6663D3kZ/4NPR0aFO+EtLS9UFw91QacGJcSivvvqq/OUvf1HX33nnnarygiF+GJIWS3BCBQohA+GtrKxs2HUIc4ChbpMmTVL/xv4Fh6vRQvApLCxU3xcXF8thhx2mqnk1NTVhtwMMT5syZYp6zqjIAIJGV1eXlJeXy6233uqvPv3pT39SQ/YmT54sW265Zcj9QEAJN8wSwwavvfbaDX7+6aefqq/777+/zJo1S37729+q9waqWh6PR8zm4afe7733nvqKY7bNNtuo7z/55BOx2WxR3d9It4cdd9xRvYYI93jvUWwYmsahe57BwEoTTRwYmoGKEy46QLX3dUhL3/oApbvwZVmcGwzlSDQ0hCjKc6hLV+9Qy/JV9Z2ytrFLSvIdUlaUJTZLfIZhEFH8RKpQ4ORYn+yOtC3Wqgs8YRzNtqO1/fbbq0CEE1uEBXyqHwyh59BDDx12wo8TelQ4cBK/++67h7xvDL268cYbVdXkyCOPVCf2xx57rJqzkp2dHfI2GMKGoVgYGnjNNdfI7Nmz1dC6kYbfRYKKDYbPbbHFFsN+jp+9+OKLqoqB54BAhdCESs5YQ1Pw8dOVIFTZIvn2229l9erV6nuEJ31MYP78+cPeQ3DfffdF/D9KD7UMJdzx1MMpEdIAQVcfr8bGRqmsrBy2/apVq9RXBCCENLw3sK+ojuF1Hun+Rro9bL755io04bVkaIodQ1OicE4TZViAqsYcKFWB6pDWvnZp6G5eH6DWzYEa7wCV47Sqy4DbKw0tParzXn1rrwpP6MbHjntEqWPnnXcOex0+Kb/55pv9//75z3+u5vKEstVWWw0bioRP6MOd+M6bN08NZxqLiy++WFVCUHXAfJtg99xzjwpMOIm/8sor1Yk/wtJLL72kJuwjHIX624gQgjk8CEEITl999ZW6VFVVqfk5Bx100LDt8RinnXaaqkKhWQQqIfGgmztgKFwgzBNCYMR+oKqFqhmqTZhPhAoOhpNBNH/3g7dBpQhD/hD+EE501Q3HOdR2gOfd29vrfw8g0IJ+7XXYiPS4wVDRQRgJJTiAafp9qa9H4Ec49/l8IQO83ufA9yGC0MqVK+WBBx4Y8f5Guj3o1+L777+P+HwpMoamhM5p0nMpYv8Uiyhd4D+fHFu2ugQGKLWY7roAhTWiMIxvvAMUKkuTy3Olal3L8jUNXdLb75FZ1fliZdWJiMZg0003VZWVZ599VlUugmGoFCDQ6OF46HSn5yyh0xtOzgM7ov3+979XTSB+8pOfqO1Q0cEJ8JIlS1Q4QpDCSfMhhxziv40exoUTalSY4qWlpUV9zcvLCzk07/XXX1cBCnQzCsxDwj6CHo6G/Q2mfxbchAFhKTDoIiiie9wBBxwQcTs0xkA17vjjj/f/H4NKWOC+jcbpp58+6uF5Otzo5hZ4jvp5hqpqWiwWf7BBZRFDCXVjB4Scke5vpNtvvPHGkpubO+y1pNgwNCVwTpOef24wsIsXZXaAQrMIVJ/a+zvVYrrJClC6ZTkWxV2yuk2+X94isyYXSLaDv6NEyYZGB+EEn1RHaoKA0BAIFZ1ot43VOeeco1pio8IVPHQu1AkzTnTx2DjpxwUn9IEn/4FVNJw0Y3gf2o1jcj+qVGi+gNASGJoA845w3VVXXRVxjtVohOoC2Nzc7H+9UOnQ1Q7t+eefV8EP+455XxBc7UOVRFdxgudnoar16KOPqmOE68INocR2aH6AuTqYt4WKHLrG2e12/zYIkHhtPvvssw1ujyGMRUVF8n//93/+/Rzr8DzMwQLshz5WgOcSanihHnaHJhUbbbSR+h7VM7zH8XxGur+Rbo/QFK/3eabjURyHRhCc00SZDIEo25Ylk/OrZNOyOTKneIYasocAtah5mXzbsFBWt9eoBXbHq9MdQtLG04tUlWnhihZp6Uj+GlREmQ4nx+EuwUOhIm0bfII9mm1jhZNXVEIQHjDPJHgIIKBShE/6EULQFAKVAzQxqK6uVusH6S5wuOAkHmvr4OQXQ+1wv/hbiiFnOAmG4BNhXIf239OmTVNVJ7SYjgeEisCTdR2KEHgw9DFwv3FBSMGwvbfeektti/0BHBccA4RIHAMMW9QBUp/4Bzd4QOUo0muE7bB/GL6JzoIIGAiL//jHP/zbHHjggarahWCF4ZEIO9iH5557Tt3muuuuC7uOEu4r+PnpS6gqk6486gocGnjo+VjoABjquejqI0IoAhrmcOlujJj/NNL9jXR7wM9ABzCKDUPTODSCYMtxouEBqjqvcihAlcxQ1SYEqB+bl/sDVOc4BCgEprlTC6Uw164WyMWQPbYnJ6JYHXfccSoAhfo5hoihIQFO7tFQ4bbbbvNXqHDijyoHQoK+4GQYc4VwsosFWDFMDyfHmKvzxBNPqNsiWAWqqKhQAUQvUoswEI+FW3FyDrobHWAoop5bFrjfuOjGFhiiB+hOh859gArYZpttphoT6GCD5xlYGYoVhvChayDg+H7++efqe7wm559/vvoeIQnHEY9/4YUXqvCGEIoqXigY1hb8/PQlXDMOhDQE8i+//FK9XnjOga9X8GLCCJ547TAMEO8PXFAhwj6icjjS/Y10e8D8JtCBm2LD0JTQStPQSR8rTUShfkcMqj05AtRm5XNVgCpyFKgAtXhdgFrVvlb6PesXI4w3NIKYMSlfqstypK6lR5asaRePd8Nx90REI0E1TM/jCR5C9thjj6mOZqgOoWEBmkIg1AQ3NgiE8IGKFLrmIQxhrgoqJAgxaB2+7777hrwdggxOrnGijCFuY7Xtttuq/cZJOyD8odED9gkn6MH0Aqpor647BqKJx1FHHaUqRwhyuKBCdOKJJ8qll1465n0MfGysS4XjhFCk5zEhuCKk6dCA1wCPj25zqH7Fq+IIqJqh1TsqbKjGITBjPpt+rYMXE0b4QjBGu3Bsj2ON54FhmPh+pPsb6faBzTx22GGHuD3PTGQYzOCPVr/77jv1VZc+48E30Cfti7+Qdtt/pXra0+qT68HBS8RmOzRuj5FpMCwBLVPxH4We0EkT+5hiDpTuwgfzSmaJ2ZTYKZhYCHdZTbta72l2dYHYbeYJczzTEY9p6h/PWP4PxVydFStWqBPAeFQXkgUn3TjpRVAKrjhg7gn+70fjhOC5WDipxUlzqPkzI8HjoeIQfJ+4P4QDnPjr+8VxxmuO/cMlcF+D9z3Sc9FOPvlk1a4aTS0w1A2Ph/0Ibg6hYXge4P6Ch1bq+U+h3od6X/AYunlBKJG209dBTk6Ov1FC4PUIVePx/gv1mkU63njdsL/Br3Gk+xvp9ngvojMlqmNoKEKx/11iI4hxWdyW6zQRjQaaQ+BSmlUkPzQtleVtq2VW0bSENozIz7HJvGlFakHc71e0yMxJ+ZKXzc6XRLQhnPAGLqoaqKCgIOwhw0l+8OKm0QoXaBCWgislOPELPPkL3NfgfY/0XDRUatAhD/OkMFxspMpMpPuLFNqj2ZeRthvpPsK1Ck+EUK9ZpP0bKciFew9Euj2GKTY1NfmHA1LsODwvQdgIgmjsrGarTC+crBbQremqT/ghddjMqkFElsMiP65uUwvjEhFlOgzrwhpU6FRH6QXrN2FYIsIujQ0rTQnCOU1E8YGFcyfllsuajjpxWhyqcUQimU1G2WhygWoMsbq+S/oGPFwIl4gy3i233BK2zTalLqwJhsog246PHUPTuKzTxOF5RGNRll0iPa4+Wdm2VhxmuzgsiR2LjmGAWAzXabfIitoOFZywEK7FHHocORHRRBft0DlKLWi+QfHB4Xnj0HLcYOC8CKKxmpo/SWxmqyxrXSke34aLLSZCcb5DtSXvd3llwbIW6ekbe/teIiIiSj8MTQnCOU1E8YWhBTMKp6jAtLJtzfgthOu0yiZ6IdyVrVwIl4iIKAMxNCUI5zQRxZ/dbJOpBdVqLaf67qZxO8QITHOmFqoOe1wIl4iIKPOkTGjCqterVq2KevVqLPKGFY+x5kEqMhjcAXOaODyPKF7y7blSmVsmNZ310tHfOW4H1mQ0qDbkk8qypa55aCFcLxfCJSIiyghJD01er1cuueQS2X777WXPPfeUnXbaSV577bWw26PX/PHHHy9bb721WvEYX++55x5JNQZD4JwL9tsgiqeK7FIVnla0rZF+z8C4HtzK4myZNTlfOntc8sOKVukfSM0PboiIiGgChSb0/H/yySfV/AR0ZWlvb5fzzz9famtrQ25/5ZVXqlWp0T5x0qRJ0tfXJ9ddd518/PHHkkq4uC1RIn+/DGqYntlokuWtq9Tq7uOpIMeu1nPyDQ6qhXARoIiIiGjiSnpoQmCCq6++Wj766CNVaRoYGJCXXnop5PZff/21+vrss8/KW2+9Jb/97W/Vv7/66itJJQYjhhnqiepsOU4UbwhMMwqnSr/HJSvb1477AQ5cCHfJ2g5p62bFiShTvPjii7Lllluqy3bbbSculyvkdbgkG/YtcH9w2XbbbeXnP/+5XHPNNcP2/ZBDDtlg2x133FF++ctfyoMPPrjBfWOKxKOPPiqHH364GjG08847y6mnnipffPHFiPuFD8uPOeYYOfPMMze47tZbb1WPvdVWW0lNTc0G1z/11FPqeow8Ch69pPd7xYoVw65buHChnHPOOWqRXrxmBx10kNx1113Dnn+8YD9uvPFG+dnPfibz58+X8847T1pbW8Nuf+mll25w3PUFz1V7/vnn5Re/+IXa/2OPPVYWLVq0wePeeeedstdee6nX7Xe/+13I4xdvixYtkl//+tdqv7B/2M9onX766ep5/vjjjxu8P+677z7Zd9991TE85ZRT1DSeQP/5z3/kgAMOUI971FFHybfffuu/7oYbblAj2Hp7eyVekjpuDE9k2bJl6vtddtlFfXqMrx988IEsWLAg5G1mz56tqlDvvfeeuv3333/v/3kqMQiH5xElGtZrmlowSZa3rpasbodaz2k86YVwDT6PfLHaLSvrumTONIcYjYZx3Q8iGl8IC/pkDF/xwS1O3ACjYeJ5ojZWOPkMtT+YS46T0ra2NvXBNWC74G3x7+bmZnVeZrFY5Mgjj1Q/xxx0nMjinC3Q22+/Lf/973/lpptuUifv4bzwwgvy6aefqpP8QBg58Mwzz/j3A98HByt9/DHaKNxzDRyBgJNrBJfAefMY2YQghQ/s7733XjGZ4rcOH0LfHXfc4f83CgH19fVqdFUoCG7h3jN67j7Oe//whz/4f/7JJ5/Icccdp56bXovpL3/5izzxxBP+bd544w0VNHCso1nctqGhQfbee28VVP72t79F9Vw7OjpUeG1pafEfV+wn9mm33XaLeNunn35a3nzzTfV98IiRa6+9Vr0/tXfeeUeWL18uL7/8sloz7PPPP5ezzz7b30kX//7Nb34jr776qpSWlsrBBx+sQvHtt98u5557rqR9aMIvoX6yBQUF6qt+4TF3KdzKxvglxacj2oknnqjmN8Xzj0msfK4+9eY3GT3i8w2K0eiT3l684VPnD2i60X8Ug/84Eo8p2MUqeeZsWda0SgwekWxr1ri/NYpzTVJeYJG65k61ptOMqlyxmJNeyE9r/L1P/eOJ/z/xYWcmczqd6hzif//7nz804WRW/zzV4OQZUxu6u7vVfPCHH35Y/exPf/qTZGdnDzthxXkVXmNse9lll6mTVlQ9dGhC0EBgysrKkosuukhVmVDVwH3hA3GcdO++++5iNm94qon7xQltUVGR+rA8EEJnXV2denyEL4QmVEyiOekPBSfzf/zjH1VgQojDfeXl5ckDDzygTsoxvQMn2qiQxAPOAXFc9XGcOXOmqqh99tln8t1338mmm266wW0uv/xyNb9fQ5jEuW5JSYk/eOgAgftClQmBAYUDVHUQnlBZQ2BCsL3llltkypQpquqHQgOqOHPnzo36nBgjvqL13HPPqWO88cYbq6D80EMPqeeP4xsuNPX09KhQeffdd4e8HgETt8dr/ve//13mzJmjgjPeXziGP/nJT9TxwP4edthhcvLJJ8sFF1wgX375pQpip512mkyfPl222GILVQnF9YHv77QMTTrxI93rP7w66Ycrl+KXFmVApEy8mXAA8YKhzIo3Ziz7gE8a4sYzIJbWRqms9vif35IlS/HM4vcYGWrlypXJ3oUJZ6IcU/zhbOpvlNq1NVJtLxezcfz/tOVlmaV3oF2WLGuUpctFqoqsYrcwOI3VRHmPTtTjif+LMxlOylCpQGg666yz1PHFCT+mGgRXYABD3HBii5NMnLPgNhgqp2HaAcKMHoY0bdo0OeOMM9TQN7j44ovllVdeUSfYCBQ4Ece5EIbHYXjSSBwOhzp5xAUfOOPkFp/wo8IQeFKJeeMIQ4Cf77///ur8K/AD7X/961/qK0LIoYceqr4vKytTH2pj/0444YSwQeebb75RwQq3C94GIQkQBDDcDI/7/vvvy6677iqxwHBJBAGERQzZQqgAVEOWLFmiXodtttkm5G0xxA4hIBQEYwS8YDhHRdDEPP0DDzxQ/Uw3OcOwxVChCb9H+nepv79frrrqKvU95uxXVFSo10hPQ8HrPHnyZDUsDaEJQQHHSr/fdthhBzUsEBAG41lBC0UPxcR7BPuFUIf3FfYX+x3qPYDAhNCMUWKNjY2qOhUIxxW3RbO3ffbZR/0M4TDwuejH/b//+z+prq5WQ0txLAKHhiK0Y1oPjgPCVVqHJvzyAn4pUH7EpxE63epf1kD4hAwlZLwAKHVOnTpV/XHBmwpJ9Lbbbhv1PuCXJ5awFanS1L2sXzWCwH0bDCaZO3eTuN1/JsLrjv+I8Hrr9wzxmAab5Z0tP7YuE6vRIjMLp4rRYBz39+i8jabLpmarLK3plAGXR8rKc6Qw18636xiOKX/vU/d4Ll2KDwQzGyolCDb49FtXnAAn4cGhCZ+MB46SwXAiDGt67LHHZLPNNpMffvhBBZDAYUoIV/jUHNUQBBmcI+FxEEr0sC3MlUGlAp++4xP5aOCDaXwCDzinKi4ujvjeQVADPFdAeEI4hOAwg1Aw0pwWDDXToTN4qBeCY1VVlTphxnPTFa5YQ5Oe54I5PjowaSN1X440bC4cfVwQIDUMF4NwTc4C4XVBaEbgQgACHAeEqcD71fep5yzpoI0wh8CK6tImm2yiqoAIFeEgYGGIJujRXwgZeB00VHl+85vfhLy9fk7B+4X9xX6Hem/hbxDe+3i/I2wFh6bVq1err7m5uarihqGhqJThueA9iNdE3yb4cQOP8eabb66+4ncx7UMTniCCEn7x8SbDi6pffHwiEAwHAgcKt8MffsAvFQRPDosWKlx4g8WLz2QQFz4tMLjVvAaDwSp2e/zuP5PhlyyerxVNvGO6sW0j+bF5mbS422VK/oZ/Q8breG6Zky0rajqktqVfxGiRqpLsjB/GNNZjSvF9j8ZDpg/N01ApwtAohCAdmgKrR4DznH/+858qoGCOBU7mUCm68MIL1afu+NB31qxZ6j40fAJ/xBFHqJNDnBthuJGGE0XMm0EIwMknQgw+YR8pNOFEHCfGCF/6BBnzVzBcLRCGOmFIGwKc3haPhRNYCDzJRaVrtPQIHx3CNHwgjqCCoXJ4f6FpA6ZtIDhhSoc+AY/mvae30fsay37+/ve/Vyf2ke4/mB4CG1iF1UMUdfAJB+8TVGnwPkFYDr7PwPvVAVAXG3S4wxynwPllqHxhHlCoYoQeKhccDLEfgeugRlpDtX/dc9L7FTgcM9zzDXxu4fZJ77+G9zg+WECAR7FFC37cwKGF+v2F28VDUkMTniA+ZcAfCfzyY9KW/nRCjw3GHwocPJQnEZbwJsEfEvzxQblTV5cC/5ik0jpNg4PDP9UgosTJsjplcl6V6qaXZXFKcVZhUg63Wgi3Ol9qm7plbWO39PZ7ZEZVnphMHK5HFBomg2PifDLmASFEnorBPDHdGlUlDLlDNQhzURBKMb8j0Nq1a9WQLX0iHkgPJ8L5DQIDhvthSBEuXV1dIacs4HxJPwbOl3BSHM08lMCTb8wlx9QGzI0JFnxfqEYgMOlP7gODN/YRFYHR0E0Dgm+Hzshw//33++cF4cQb4Q3XnXTSScNOkHXw0wKrdHool95XfSxHA+eaox2ep0/iQ4UOVAsjQZBGEQHzvHRxIPA+9f3i+ev71Nfp+0bIxFwhBGEEvsWLF6uhgRi+FgoCqT6OOL/WjSCuuOKKkI8fTF+n9ycwYI30fMPRt0PQw3PB+T/ep6g4IVjjfavp4xx8PALfX/r9NlZJ/x8ck9SQqDEREWMyEZJmzJihXjDdhhGlO5Ryc3Jy/OVBTHL71a9+Je+++676Q4P7ScV1mhiaiMYXglJJVqGs7qiRHldyJ2JXlmTLrOp1C+GubJV+F9uSE4WGE1PMt2pMwgWPG/rEOBq6qoSTepycoU128DySwE/cdYc6/ek+KiE42cccH8zfwPkN5oYEDqsKrmoEVobsdnvIABEKzrUw1wRzYVAVQ6VL3z4QGhhgHhEm0AO2D9wHfJCt9wFBMRBO+tF+OtScruBwE7jPqIjojsh6WBwuels91wn0/Kvgk2EM79P0MFRdfQveT0CDC1T+wgWqwP0IdQlFDxML3DdUyaC8vFwiwTktBHcdxPwoHRT1/QbfJ14TwFBPXNAIQjdJi9R2HOEP4QQXfczw/tU/wyV4WGMgXcHTLdX1/iG8YL9joZ8LhuRh2Cl+DxDm9HPB66/DcLjjAXo+VaxNRFIuNKFahA4sGKuKT00w5hAdM3RSxLhWlKwRmABtA9GdAyVbvCkwEQ6dMubNmyepxGD0pEIxjygjVedVqnbky1pXiceb3KBSkGuXedMKxecdlB+Wt3IhXKKQfi0i+GS9NAkXPO6xMb8uGCqHkKOHgemRMoFw0ofzGpx8ooKCCeuBF5zUYc4TGjIghKEq0NnZ6Z+fERyaYj0J1MMzQ3W0C/6kHyf/WNcI6+hgv1DlwVf9+Kh2AeaV44NtfOKPE1oM7UMgw9dww7P0MLvAYKFDEebjBB8fnJhjTh46EwYOu8LcFxxPVBnwWLp9OU709WNgSCKeL4YEogMz5u/oOV1oZoFzSlRiQkFVMHhf9CVUlUmHNLzO6ACHbfBVD9sMnsMVTN9n8HsI96fDH5qfYQSW3md9n3q6CiqUaHCBqqIe7hlqyku8bLbZZuorhs1hvxDM9dy2WJtQ6OeCYXUI0ni9dOjVzwXztfTxQIDVwxIDj7H+nYw0Z280UuKMHotW4RIKJjcGwycxuptGqjIYhsqErDQRjT80gcDCtz80LpHlbatlVtG0pM6/cNotMm96kSxb2y6LVrXKlPJcKSvkPB2i9XaPeXhcKsAQPT15PVQnNpzEY3QM1ulBdzGEEn1CqdfEQVMJwDZoDoEKCwIOThiTueQGhnihaoSOdwhC+GAbf0/RHABhABUidOLD89FzTXA9tg1VxdIVBAwL0yEMoQfDrgDVkeD5NxgeiCGQaAiBQLHRRhuprwhRGEaGbnM4XrpyhblgOlgi0KJTHo4xji0uuE5XsLCwqu5yF6mrXbRQBcH94QN9zDfDscB+oTCAKiTguaCxWeB6SHidEZIxpCxU4wZ0zcM8M0xn+cc//qHuE4+lwyvuG10W8ZpgTph+PRDqsZBxohpBHHzwwaqhBgIaqkL6Po4++mj/NqicYegfjglGk40EARHFEbxH8AGCfi6oXOmRaDgeCFIovOj243i/6U6Ogd1Cg4fLpm2laaLSc5pEOKeJKBmsJovMKJwsXa4eqemsT/qLgHWbZk8ukLICp6yq65QVtR1qLTciSn96iB5Cjv4EPBhO3HHiiTknmDOE6gFOrrGuka6w4EQRP8f9YA4HAhbodtPJgIBx5ZVXqv3CCbme44Ngg2oNggGqUjipxX6jSoDmFoHzToLpD8r1fC5M+MeJO06K9bypQHqY2euvv+4fgoc57TgxRxVKhzVUIVAdw0K2gbCuEfYJAUlX2TCSCWEPJ92Rhp/FAt0NMXIKJ/EITQgzCDr6wzuExOD1kBAgceIfrmEFwgOCKOaiYTuEDwwtDNwegQojsBDK8TxxnDE/LNIaRboRROBiwXrxYH2J1AiiqqpKtQ/HqDDsF97f2E8dbgD3i/sJbOAwErSH/+Uvf6mOIUITPozAc9HrumK4HqbwoIqEx8VwRMxBC6yq6QYQ4Qozo2UYjGYQ7ASFFqEQqmd+rHwDfdK++AuxTj1FLFaDeL0zxel8Lm73n4nwi4ayOj6ZYhctHtPRauhukjUddTK9cLIUOoYWz072e7SxrVcFp2yHVTWM4EK4Yz+mFN/3aKL+D8UQKnSaw/CqcFWIdICTSh18UIlA1QInhggYel6I7gAWqmsZqgrhKhg4scT94AQ7+HFwO5zA6qF++r6CfxZM7wte+0hVdzwHPBd9ohr82mHf8PNQrx32IdrwgVNPVB/wWG+++ab/OYS7b73oKuD4Bg9PxHHC84pmOBjuC4+b6PWL9GPhmAUPh8RzxXPWryvo91C4YzCaY43HxSWaYZw4riNFgUjvrWj2S7+vQr12ka6L9vUK97j4IAIVMFRKIwXHaP8upcTwvIkHq6RjHgVeQFaaiJKpLLtEelx9srJtrTjMdjXXKdlKC5zisJllyep2+X55s6pAYQgfEaUHnAQHngjjZC84HIVr8QyRhnwFnhwGP06o4WLRDCGLtC+BIq3hNdKJ/GiqNQg4aBaBKRjoiIbqXKTngO0jPYeR5mgF39d4BCb9WKH2Dccq+HiFeg/FeqzxuNEOSY/nh1KWMPsV6X010rpx0bxeoR4XjSkwfBOL30YKTKPB4XmJsK5zHnBOE1HyTc2fJHazVZa1rhSPL/rhAYmU47TKxjOKVBvyH1a0Smtn5PU7iIgmksMPP1wN6dKtxYni6fHHH1eBEI1M4oWVpoQIPCnjISZKNnyCN71wiixqWior29bIjMIpKbEwp81iknnTitRCuEvXtEtVabZUFmelxL4RESUSKjBo0z6aeS5E0cLQPFxiXSsqFFaaEtg5D1hpIkoNdrNNphVUS3t/p9R1Y22W1KAXwp1Umi01jd2ydG27eNkggogyAIbkjTQ8iygWCEvxDEzA0JTg4Xmc00SUOvLsuVKZWya1nQ3S0d8pqUQvhNvR7ZIfVrTIgJufvhIREaUKhqZE8LcbB07uJkolFdmlkm/PlRVta6Tfs77dayoIXAj3+2Ut0tXrSvYuEREREUNT4ofnMTQRpRbMF5paUC1mo0mWt67yL3CYKvRCuOiut3Blq2pPTkRERMnFSlPCh+eNbiVpIko8BKYZhVOl3+OSle1rU+6QY92mjaYUqNbkK2s7ZWVdJxfCJSIiSiKGpgSHJoOBoYkoFWG9pqkFk6S1r10tgJtqjEaDTK3IVRdUmxavbhO3J7WqYkRERJmCoSkBDJzTRJQWCh35Up5dIms766VroFtSUWmhU+ZMKZTefo/8sLxFevsDh/8SERHReGBoSoRhc5pYaSJKZVW55ZJjzZLlbavF5U3NQJKbZZV50wvFaDKohXDbuBAuERHRuOLKqwlg4PA8orRqDDG9YLL80LRENYaYXTxdjIbU+zzJbjXLvKmFsry2Q5asaVfrOqFNOdFEgUVOk9GYBYtfm0wmSab29nb53//+J9OnT5fZs2ePy2O+++670tfXJzvttJNkZ8f2t8Ttdstbb72ljuGee+4Z930kSiUMTYmA0DQ4uO4fbDlOlOrMJrPMKJwiPzYvkzUdtTIlf5KkIpPJKDMn5UtNU7esbexWQ/amVeWpBXKJ0j0wrV27Vp2EjzeLxSKTJk0aU3BC2Hv99deluLhYtt5661Hf/h//+Ic8/PDDcuKJJ8p5550nY9Xa2qqCEBaPDeeSSy6RhoYGeeWVV2IOTQhdZ511ljp2P/zwwxj2mCj1pd7HqROue158VyMmosTIsjplcl6VNPW0SnNPa0pXxiaV5sjM6nxp7x6QhVwIlyYAhA4EJlQscKI/Xhc8Hh53rBUu3AfCw+233z7q2z7yyCMqMMXLNddcIz/72c+ko6MjbvdJRKw0JWx4nq4zGY2c00SULoqzCqXH3SurO2pUdz0EqVRVmGsXu9Wkuup9v7xFZlXnS46Tf28ovZnNZnUZTy6XK2lD8i666CI1vG00uru7ZdGiRdLV1SWlpaUyb9489WEKvPPOOyqAIcT997//lS233FJmzpyprkOI+vrrryU3N1e22GKLmPe7vr5eFi5cKJWVlVJRURH2mH711VfS398vm2yyiRQVFfkrYJ9++qnY7XbZbbfd/NuvWbNGvv/+e/V8ttpqq5j3jSiRODwvIQIrTRyeR5ROqvMqpc/dL8taV8nckpliMaXu7zAWwt14epGa47RoZatMqchVazsRUeJ98MEHKsCAxzP0/35LS4v85z//8W8zbdo02WijjULevq6uTgWmbbbZRqqrq+XZZ58d8THfeOMN+eMf/6gCk4Y5UPfcc4+UlZXJn/70J/8QR3z/u9/9Ts444wz1OBj219s7tFg2HnNgYGDUz/n++++X66+/3v98Q81jWrBggZx++ukqXOnhj3js4447ToWliy++WB03DGecMmWK2uamm26Sl19+WT03hiZKVQxNicDheURpC00gphdOkYVNS2RF2xqZVTTN/yluKrKYTaol+ar6TrUQbl+/RyaX56T0PhNNBFdccYWsWLFi2M9QgcEwPe3444+XP/zhDyFvn5eXJzfeeKPsvffe8ve//z2qx/zrX/+qAhMqSKjKaB999JEcfPDB8tOf/lSeeeYZNdwQ38+YMUMFFMxfQmDCbRCyvvzyS3+Aitby5cv9gWnq1Kmq0hRcJUNgO//881VgwuOgEvXZZ5/JVVddJZtuuqn85Cc/kf3220+eeOIJeemll1So6+npUfeDcHXAAQeMap+IxhNDU4K753F4HlH6sZosqqPe4pYVUtNZL5PyQg9BSaWFcKdV5qnKE8JTn8ujGkaYTZy2SpQo6DqnO90hpKAKhEYQCAZauCoTIHTgMhoIFmi6sP/++6uGExh6F9jAAkHuhRdeUMPjELBKSkpUlzxUwPD9q6++qpo+YCjcIYccMqrHfvvtt1VgQmB79NFH1eM+//zzw0LhN998o8IVwtlpp52mPrxBcLvvvvtUJQ3H5rDDDhsWmlBxQkOJvfbaSwoLC0e1T0TjiaEp4ZWm1B3aQ0Th5diyZVJuuazpqBOn1aEWwk11ZYVONc9p6dp2/zwnBCkiij8Mf9Mw1G2zzTaTOXPmyC233JKww42KzQUXXCCXX365+rfT6ZQdd9xRzjnnHNWuPBQ9TG7jjTf2d8nD96h0jaZZhL4fhDUd1HbYYYdh26xatUp9bWxslLPPPnvYdUuWLFFfUXGaO3euqsp9++238uKLL6qfH3rooVHvC1EyMDQlqhHEupbjBgMnZhOlq7LsEulx9cnKtrXiMNtVc4hUl5dtG5rntLpdLYQ7Y1KeFOSk/n4T0ci23XZb1ewBjSDQ1OHjjz+W1157TTVSQIUplIKCAvW1trbW/7POzk7/fKxo5efn++diaYHfgw5laPwQ3Ho9sGkEqk0Ifo8//rh88sknUl5erip3RKmMoSkRArrnGQxsOU6UzqbmT5JFzUtlWetKmVMyS8zG5C6CGfVCuNMKZVlNhwpPk8qypbKYC+ESxdNYG0GMFoIO5i5pqBSh+YN+XA3dBzE877nnnlNNFVABw7C+xYsXq6F02223nboOa2MFQtUHwQrd+CZPnrzB4+sQhCF+eFw8t3vvvXfYNujKh8fCccHzRvVLz68MHIqI4YXXXnut2g98yIyhgmj/DniOeK4IiByuR6mEoSnBw/NYaSJKb/iPHI0hFjUtlZVta9QiuOnQZAEL4WJ4HhbBXduwbiHcSi6ES5QqjSBGC1UczCVCy+5geBwNHemwHzfccIMcfvjhqqJz0kknyT//+U81BwkXBCsEErQA1x566CE1zwhNI44++ugNHmP77bdX3fIwB0mHJQQ3m83mD40IU6eccorceuutw4YpOhwONa9JQ9tzzGFCdQx/TwPnV2GdKVTSsD8IeESpgqEpwY0gGJqI0p/dbJNpBdWypGWl1HU3SmXO0Ke7qQ4nI9VlOeK0m2VFbadaCHf25AKxWlK/WkaZSZ98p8PjBTaCCCfaKhPuByEi0v3hAxyEFQzHQ/c7VGPQcGGPPfYY1nwCYQnhCs0VcB2ceeaZqmkEmkJguB469r333nuydOlS/5A6VKRQoQpVZdLQ5e/JJ59UazBVVVWpjn133nmneiwNzR1QcUJHPOzjpEmT1HbouBfomGOOUes4od06Ltr8+fNV8GOViVKNYVBPvslA3333nX9SYrz4Bvqkv+0s8Tr/K1abTazWp8VgiE9pPlOhLSo+NcPEUUx6JR7TZKntapDazgaZWTRV8u25CXuPevt7xNvdJj5Xv5iycsWcVSAG89gaOvT0uWXJmjbxDYrMrs6X7BRfCJe/96l/PGP5PxQnyajOYGgX1uzRMFRs7dq1/jWGxhOGk+HEPrALHRFljv4wf5eCsdKUCIb144QNBnauIpooKrJLpVc1hlgjc0pmqgpUPOCzK19/twpKnu42GXS7xGAyi9HqEFfjanHJajE5csSUXSDm7NgCVJZj/UK4C1e2ytSKPCkpcMRl/4nGCoEFwQWtu8cbKjgMTEQ0EoamhA3P0wW81P40l4hGN9xtakG1LGpaIstbV8mc4pn+ycsxBaXeThWSvD3tMuhxi8FsVaEI4cjoyFaPN+h1i7e7XW3nalotrsZVYnIOBSi1ndka00K4K2o7pHfALZPLuBAupQYEF4YXIkpVDE2JYHCvz0wMTUQTCrrnzSicKgvRGKJ9rUwvDD/+P9jgoE98vV1DQQkVJa9HDBarmHMKxZRdKEZ71gZNJgwmi5jzStRleIBaI9KoK1D5YsopjCpA6YVwHTazrG7okr4BLoRLREQ0EoamBDAEDM/jISaaeLBe09SCSbK8dbVkdTskx5gVdttBn1e8vZ3i7VpXUfJ5xWi1DwUhVIrs4W8bbHiA8qj783S1ibu5RoUokyN7fQXKEnnoYHlRlgpOeiFcNIjAv4mIiGhD/B8ywes0sdJENDEVOvKlN7tP1nbWS7WzfMOg1NOhqklDQcknRptTzAXlQ0HJNva5RJjzZM4tVpehANWhKlA6QCGMDVWwwgcotRDutKF5TghOMyflS34O15YjIiIKxtCUEIEtTNkIgmiiqsotl153n6xoXyPiGRBvV6v0t9eKr6dDDcUz2p1iKawYGnpnDd+RJz4BqkhdVGBbN4RvfYByijl7XYAK2g+7bf1CuItXt6kW5RXF0Ve/iGKRwY17iShN/x4xNCV4nSaGJqKJC/OPphdMls8bVkld40IxSL3k5BaJPbtAbNlFYrdlicVkFovRIFZUm2JsGjGqfTKahgcoVLy6WsXdWiuu5rXrAlTBsCAXuBDumoYu6e13q3lPmP9EFO/23roFOhY8JSJKNvw9Cvz7FA5DU6IaQajkijUfEn+SRERJ1NMhkz0iXY4Sya6cIyaHXXq8bmnvbxNvb8sGTSTMRrNYTRaxqItZrMbh35vRatxgjF+AyilUl6EA1SnebgSoOnE116ghg6qNeQ4qUA7/QrjLazqk3+VVQYoL4VI8oTtefn6+NDY2qn9jzajg5idERONVYUJgwt8j/F0aqXsnQ1Mi+BtB8PASTWTevi5xNayUrLxyKfTkytSiqcMWDvX6vOL2ecTldYvH6xGXzy1u79BlwOOSbleP+t4XNDRgqDqFcGVdF7LWfe8PWWb189GcbA4FqKGAtD5AtYmnrV7cLQhQDlV9KsgukLmY57S6Tc1zmjW5QLIdHGZM8VNePjQHUAcnIqJkQmDSf5ci4Vl9AofnDQ7yRINoovK5+mWgdqkYHVliLpgk0vLjBtuYjCZ1GWkR3OGBavj3mDPVOeBR4Stw3DUC01CwWlepCvG9GRejKXKAGvT5m1boAGWy2mWj/HxZ0W6QhSta1FC94nwOpaL4wHu3oqJCSktLxe0eGplBRJQMGJIX7fpwDE0JXKdpcJCHl2giQre6gdolqgGDrWKm9A24xnR/qCDhIpbwwQSBCcFJV6pcgd973dLvGVDfe3yBSx6IGuqHStVQmLKsC1ZD//YPDXTmqXlOQwFqqALl7W6WKeKRxl6vrFpkl57KcplcXcahVBQ3XMyWiNIJz+oTVWlSoYmVJqKJBsFioG6pCk726rkqOImMLTRF++k8Ag8ukfgGfapCNRSsAqpX+OpzS6+7V1xej9ouECpS/iqVzSJmR5mYXQOS5egWX2OrNC2ul/7abJk8bbLY8opGtb4UERFRumNoSuicJoYmookGc5h8fT1imzQ7oW3EY4XKks1sVZdIUJHyhKhYoZqFqpX+ftA0KFKRL91Oo6yob5Ifv10r5fkOybJniS27QOw5RWJ35A6rXqmqGRER0QTC/9kSwT+niYeXaCJB225PZ4vYyqeLyZEj6Wyok59JIsU+DAn0IFShmUWRW7or+mXJ2iZp6e0Qk3jE1dEgLS1rxGM0iMmRLUZ7jhitNhXc1g8H1EMDA5tZDP0M872IiIjSAc/qE8DgbznOShPRRIGwhDbdlqIqtQZSJlDNJtY1l3BaHJJvz5Xy3GJZtrZdOnpcUlmRLaVOn7ixqG9Xs7j6+sUz4BGfM1t8ZrN4TBYVunrd/epr8Hwrk9EYMM9qeAt2t2uo0hU8jJCIiCgZGJriDv/B6//keXiJJlJrcYQla1GlZDKzySizJxesWwi3W/ryHTK1YorYSqeIr697qAtfd5sMtreJwWwdWkg3p0SMjmxVuQrdJXDDFuwDAwOytq9GvA1GyXJkBTWzWPe9v5nF6FuwExERjQbP6uNuaGgecHge0cRqLW4tm5rs3UkJCCdYCNdhM8uK2g7pG/AMLYTrzBGTM0csJdXi618XoLraxN3eIAazRQUoS3aB2Bw5EQMOKlId3R3iax6QyXmVYrZa/HOu+jyRW7APrXEVunplCdOCnYiIaCQMTXG3vovW4GDkidhElE6txWeIwWBM9i6lFKzdZLeZN1gIFwEGc75wsRQjQPWIt7tVVaDc7Y3qeJqyC1SIMjpzNwhQCDYOs12cJocUOQqGLRgc3II9eNFgdAZEl0BUrfA9hgUGyrY6pTynVA01JCIiihZDU9wFLtTHw0s0cVqLc45iKAhJG08vkiVr2tVCuNOr8qQob/16U0MBKltdrCWTxYsA1dWqqlD9HU1BASon6mAa2ILdKY7oWrB73dLY0yJLW1aqOVqVOaWSZ98wtBEREQXjWX0CQxMbQRClL1fDqqHW4lWp2Vo8lVgtJpk7tVAN1Vu2tkN6+z0yqTQ7ZBgx2bPURdQQvh5VfUKI8georHwx5xTKoJgS0oK90JkvnQPdUt/VKEtbV4nTYleVpwJ7HsMTERGFxdAUd4GLXPKTaaL0bS3ePNRa3JnercXHi9FokBmT8sVp75E1jV1qntOMqjwxmcJXjrBArhUBqnjS+gCFClRns7g8XjF1toq3p1IGHfa4Do3MtWWrS/dAj9R2Ncjy1tViN9ukMqdMChwMT0REtCGGprgLHD/P0ESUbjxdretai1dmTGvxeKoozlINIpbVtMv3K1pkdnWBmvc0kmEBaqBXvE11YlhbI+76ZdLXUSem7Hw1jM+UlRe3AJVty5LZtulq/lN9V5Msb1st9i6rqjwVOvJVlYqIiAgYmuJt3RpNQxiaiNKJt69bXPUrxJyD1uJVyd6dtJWfY5N504pkMRpErGiRmZPyJS/bFvXtjTanmAsrxFPULtbqqWL29g914utsEYPRpIbwDQWoXPXvscq2ZsnMoizpdfWpytPKtrVS19Uo5dklUuQsYHgiIiKGpvgLDE3snkeULnzuAdUpT1U8ytlafKxQbUKDiKVr2+XH1W0yuSxHyouyRn0/RqtDrM4ikaIq8bn6VAtzFaDqEKCM6wJUYVwClNPqkJlFU6XX3afmPK1qrxkKTzmlUszwRESU0VhpijvOaSJKy9biNYuHWotXsrV4PBfC3Whygaxp6JLV9UPznKaU56r5T7FQAarIIVJUqdbPUm3MuxCglg4FKGeemHIQoPLGFKDQWW964RSpdPdLbVejrOmoVSGqLLtYSpxFYjRy2B4RUaZhaIo7t6xfbpHD84jSo7X4snWtxeewtXicoYPe5PJccdotwxbCtZjHVhVCR0NjYaVYCnWAahMPQlTdMjXnyZiVp9qYYy5UrAHKbrHL9MLJ0u8ZUKFpbWe91Hc3SVl2iZQ4C8XEhXKJiDIGQ1NCGkHo2MTheUSpztW4Wnx93etai4df74fisBCu1SSL17TLgmUtMntygWQ54vPB0lCAqhBLYYUaZqkCVFerDNQvHx6gUIEyjf6/PXTWm1pQLRU5ZWq4Xi3CUxfCU7GUZBWpxXiJiGhiY2hK6PA8hiaiVOZurRNPRxNbi4+TbKdVNtEL4a5slWmVucMWwo0Ho8UmxoJysRSU+wMULv4A5cwVcw4CVP6oAxTWeppaMEktiouKU11XgzR0N0lpVpGUZpcwPBERTWAMTQlsBGEwcHgeUarCXBhX81pVnWBr8fFdCHdOlAvhJiZAtctA/Yp1ASpn/RA+U/R/r61mq0zOr1INIhCa6rubpaGnWUqziqUsq1jMMVSziIgotfEveyJajvsnNTE0EaVua/HlQ63Fiycle3cyjsloUG3Ia+3dsrahO6qFcOMaoDyu9RWohpUijQYxoQI1ygBlNVmkOq9StSZvQHBad0HlCUP3LKMIYkRElNoYmhI4PM9giH5dEiIax9bidUvZWjwFVBZnDy2Eu7ZDfljRKrMm54vdmvj/loxmqxjzy8SSXyaDHrd4dIBqXCXSuEpMjhwx5RSIOatADOaRgw/C0aS8iqHw1NMsjerSIiVZhappBMIVERGlN4amuPOwex5RKrcWr12ihmaxtXhqKMixy8bTzUML4S4f/UK4Y4VQZMkvVRcVoHqGhvChQYhLVg8FqOwCVYUaKUBhWF5VbrkKSio4dTdLU0+LFDsLVaDCsD4iIkpPDE0JmdOkx+fx00WilGotXr9cnRiztXhqL4SLtZxy7OO/HypA5ZWqy6DXrcITqlCuptXiQgXKORSgcEG1Khx006vMKVPzm1BxwpC95t5WKXQUSEVOqWooQURE6YWhKYGNIIxGDs8jShWoHHh7O8XO1uIpvRDu6oYuWVXXKdl2g7i961e9G2+Y12TOK1EXFaB6OlQbc3fTWvVeGqpA5Q8FKEvov/VYxwkhCXOcmnpbVdOIlr42KXLkqyYSaGVOREQTODT5fD759NNP5cMPP5QVK1ZIe3u75ObmSkVFhcyfP1922mknsdky9T8DthwnSjXutvp1rcWnqQn/lJrQQQ9VJqfNIj+ubJTVdf3iszVLfm6Wqkbpi9NuHvPiuKMOULnF6oIhnt6edtV90d1cI66mNWJyZK+vQIUIUAhPGJ5X6kR4Gqo8tfS1S4E9T4UqhyUJZTUiIkpcaEJYev755+XOO++UlStXisPhkOrqasnOzpY1a9bIF198IY888oj697HHHivHH3+85OTkSGZh9zyiVDI0vGrNutbixcneHYpCSYFDLMZC8fQ0SFmhQwYNJunuc0tze58Mris+mUwGFa4c9vVhCheLOXEd+ABrOw0PUB3qPaYDlNGeJeacwpABymg0qvlOWBC3ubdN6rsa5fvGxVLoyFOVJ6eFiysTEaV9aEIouvDCC2Xt2rWy3377qcvcuXPVfwKBli9fLh988IE8+eST8sQTT8hVV10lu+66q2QMw/pGEAYDx60TJZO3v2dda/FCsRRV8cVIs/WcchwmqSjKEqfTqX42ODgo/S6valGuLv0e6epxSVNbrz9MYZifMzBIrfseP09MgCpSl0Gf1z8Han2Acoo5e12Asq6vJhkNRjVkr9hZIK297VLX3Sg/NC6RfHuumgvltDI8ERGlbWg6//zzVVA64ogjxGIJ3+Bg+vTp6oJK07vvvitXX321zJw5U6qqMuWEhS3HiVKmtXjtEjHanGItm5qQxVNpfOE11GEokM+HMLUuSK27dPQMSENbr78vj9kcFKZs8Q1TBqNpeIDq6RAv5kC11qpFlPE+NOdgCF+hP0AhPBVnFUqhM19a+9pV5emHpqHwVJ5TItnWrLjsGxERjWNouu+++/yf9kULFSbMccKng5nD4++eZzCwex5RMuCk1d9avGKmOqGlictoNIjTblGXcGGqt3/oa3vXgDS0rg9TGM4XOMTPue7rWBbaVQEqp1BdhgJUp3i7EaDqxNVcowKUamOegwqUYyg8OQulyFEgbX0dUtvVIIualkmuLVtVnrJtDE9ERGkTmi6++GLZYYcdVLUpKyv6P+CRqlITkYGNIIiSCh/SDNQtG2otPmlOVIuT0sQPU0V5UYSpll7/NlaLMaAitX7ulMloiCFADQUkFaB6O8Xb1SaetnpxtyBAOdatA1WovkfVqcCRJ239HarytKh5meTYsqQip0yFKCIiSvHQ1NLSIpdccomao/SLX/xCfvWrX8mmm26a2L1LS671yzQJ5zQRjTd307rW4pWz1EkoUbRhyoswFTDED5e2zgGpd68PUzaLaYPmE/Yow5QKUOsWysW6YWoIXzcCVIO4W2rVsL2hClShFDryVXe9jv5Oqe1qlMXNy9VwvcqcUsm1Z1qDJSKiNApNDz30kHz55ZfyzDPPyL///W/V6GHevHly2GGHyQEHHKA65hF4/YdhcJBDgojGu7W4u71RbGVTxZQVcDZMFAUEnyyHRV0Ceb0+6UMDClWVcqsw1dLRJy63b2gDw7owFdASXYUpq1kFtFAwdHR4gMIQvjbVGh/D+HSAys0ukPzSWdLe36kqT4tbVkiW1aEqT5j7REREKdhyfKuttlIXDNX7z3/+owLUX/7yF7nuuutkn332UdWnLbbYQjIb12kiSnpr8bwSvggUN5jflO3ABWFqffXS4/WpylRvQGUKbdHdnvVhym5dH6b8lamgMDUUoPLVBQHK19ul3s+BAcqZXSCzciqkR3yq8rS0ZaVqUY7KU549l41OiIhScXFbNIQ45JBD1GXVqlUqPD333HPq6+zZs+Xwww9XAcpqzcDhaYbA0MS5FETjwadbi2cXsLU4jRt03st2WtUlEMKUbomuw1RjW594AsKUwzq8JfpQmDKpAIUqKS6DpZM3CFAWi02mZxdIb3a2NLp7ZGnrKrU4LhbJxXA+dokkIkqh0BRoypQpcs4558jZZ58t77//vlxxxRXy17/+VXbeeWd1XeZB9zyNoYloPFqL99cuFYPVIdbyaTxppJQIUzlOq7oEQgUqcL4UQlVnS68KWYCu+PagLn4OW5bYSnNFSqeIr69LPF2t4ulqEYvHLZMsVum32aXR7ZblravEbrarbntoJMHwRESUYqHJ5/PJxx9/rCpNb731lvT398tOO+0k+fn5o7qfjo4OaW9vl8rKyqg67nk8HqmtrZXCwsIUm0/lDvieoYko8a3Flw4Ng6qcxdbilNLQ3txitkpuVnCY8vq7+PnXmeoeEK93MESYKhZ7cZnYB/vF1N8h9p52qfa4pVcGpdnYJ0t728XhyJOK3FLVTALtzImIKImhadmyZfL888/LCy+8IA0NDVJeXi7HHXecHHrooaNayNbr9cpll10mTz/9tApgCFuXX3657LXXXmFvg4B2zTXXSFtbm/o0Dc0oMLfKaDSmTGgaagLBxTSJEt5a3D0g9uq5bC1OactiNkleNi62YT93ub3DghSCFVqjo2U6GI0OsVuyxGEcEJuvW4oGuiRvsF9au9bI0tYacWQVSEXRZLWALhERjWNoQkh55ZVXVGj57rvvxGw2qwVsEXIwHM9kGn23uEceeUR14kP4QdWotbVVzj//fNXOHFWnYO+++65ceOGF6vvS0lJpampSt99oo43k6KOPllQJTV6vUTx9fSGHSOA4Bc736uvrC3tvCII2my2mbVH1C7ewMPbLbrfHtO3AAP7TXjc2PwSHwxHTti6XS4XoYHjO2L9A4bbVsL/62MdzWxxfHc7dbreqeCZzW2yH7cPB+0z/XgZuq48pvurnHrgtjgGORTioBuP3f7Tb4r2A90Q42E5Xmkfa1tdaK7KutbhYbBF/N0Zzv4G/n/idCH7vRdo28HhG2hYi7S//RsT2ex/N35N0+xthNYlYnUYpLcjxb9vT2y9dPf0qRKERRbtLpG/ALj6vVQzuPnFKv9g8HdLRtEpqli8WqyNHSvMrZDDC32IiIopTaPrTn/6kKkv4wz558mQ1jwmNIEpKxtalCoEHrr76ajnwwAPlhBNOkA8++EBeeuklOfnkkzfY/u6771ZfcR32ASHqjjvuUMP7UsNQ8Fi4aKWcccbPQ1a/dtxxR7n55pv9//75z38e9sQM3Qrvuusu/7/3339/NYwxFLSAR2t4DRW4urq6kNtOnz7df+zh2GOPleXLl4fctqKiQr0e2oknnig//PBDyG1RKXzzzTf9/z7jjDNUq/pwJyJ4rTWE5Q8//HCD7XCSi+Pz+eef+3+GNcMwHDQczK/TJ1BXXnmlvPzyy2G3feONN6SgoEB9f+ONN8pTTz0VdtsXX3zRH+Zvu+02efjhh8Nui+OL4wz333//sNcxGF43vH7w+OOPyy233BJ22zvvvFN+8pOfqO+fffZZufbaa8Nue9NNN6nhsvDqq6+qimzgMcVroN+j+B3cY4891PfvvPOO/8OJUP785z+r9yJgeC7mNIZzwQUXqMYw8NVXX4X8vdbOPPNM9V6ERYsW+b8PNuh1y3GH7CennHm2mjCP965+jFCOOeYYOeuss9T39fX1apmEcPB784c//EF9j981/H6GgzXrUCkHBDFsG67ivfvuu6sKuYYPmsLh34ih9yguH3300Yh/I7RM+RvxzNNPhvwbgc+9fIODctV1N8ms2VuKpbtT3n/mUXngofvE6/PIZVddLPM23jjsYxARURxC09dffy177rmnOqHYfvvt4zLJtLe3Vw3zg1122UXdJ77iRHrBggUbbI/Ahv0A7AcW3MXJI04yU8Wgb28ZlO/lzTdSaZ4V0cSaxzTocYvJmSuWvNJk7w5RysB/yyaDQUrynTKjGiGvQL6fNUNyc/LE5XZJZXEmNmciIooPw2C4MVkhAg5aja9YsUJWr14tkyZNkhkzZozpwXE/+lNcfKqM0IQ5Uvhkesstt5R//etfw7bHJ8QYDojt8Ik4Pv3D9wcddJD6BD1waFo0MMQQT3/mzJkSLz5Xn3Qv/1yWd5pl8syNhg0X0Tj0ZvTD89Dafs6cOf7tJ8rQm2QOz8MxRYdLfUzTYXieb6BX3HVLxejIEXvlTP9wt3gO+4tleB6OJ/42Ym5nqN/54PsFDs+LPIQ3lt/7iTg8b6zb6t97HE/MP546dWrY9+hoLV26VB0XDKcnIprooq404YTj3HPPHTaEAcN+sLAt5iLFQp/A4WRC/4ekT9pCnYTpEx2cyGAIGIIbhp9hjlVxcbGcd955Me3DwoULJW48A2JpbRN7wST1HxTFB05aVq5cycMZ52OaVu9Rr0fMbWtEjCbxFGSjG42kEvwNS6vjmQb4ex9/8f47mpHrMRJRRoo6ND322GPy2muvqQ55GFe9du1aNcYaY8Gvv/76mB5cf9qFT+3waRg+DdbBKCsra4PtA5sRYD0odOrD+Pbjjz9ehblYQhPCYNwrTcv6pdYtcf1EL5PhE1L8R8/jmbnHFEPy3LVLZDBnslirZovBnFonaul2PNMBj2nqH09UmoiIMkXUoQkNFy666CI58sgj/T/bbrvtVOMGDK2Ipd03ut8hKCEwoWJUXV0tNTU16jpUkUJtjyGCGCo4d+5cf6ME3dkv1k+HcZ/x4jMZxIVP3txDoTCe953peDwz85iq1uJYvNYoYp+yiRhtqbu/6XA80w2PaeoeTy6gS0SZJOqkg2En22yzzbCfbb311iosNTc3x/TgCExbbLGF+v7WW29VXbjQoU8HMkCIWrx4sXR1dak/0OgqpTsYoSnE7bffrv49a9asmPaBiFKbu3mNeHs7xFYxI6UDExEREU1cxtHM/Qk1drmoqCjiROmRnHrqqSp4oQEEhv4hJKHBxL777quuv/TSS1Vr4/fee0/9G62NMXQP7WIPP/xw1X4Zt4/U8piI0pO7vVHcbQ1iLZmsWosTERERpfTwvEhN9qJswBcSmknce++98sADD6iKFeZLYa0WHdCqqqpUFSknJ0f9G/OPsLYFKkwYn40hfVjLRQ/TI6KJwdvTIa6m1WIpKBNLPluLExERURqEpkSaP3++uoRy+eWXb/AzBKcbbrhhHPaMiJIBrcUH6paJKStfLMXVfBGIiIgofUITOuUFTyBFdSjUzy+++GLVBpyIaDR8Hpf01ywRg9UmtvJpnGxORERE6ROa0HHn008/DXldqJ+fc845Y9szIso4aC0+ULtEfW+rnCUG49C6bURERERpEZpefPHFxO4JEWU01Vq8foUMuvrFXj1XjCm2FhMRERFlrlHPaVqxYoWsXr1araOELndERHFrLd7TLraKmWwtTkREROkZmtBy/MILL5SXX355WOe76667TgoLCxO1f0SUAdwd61qLl04Wc3Z+sneHiIiIKLZ1mh577DF57bXX1FpK1157rWoLvmDBAtUEgohoTK3FG1eLJR+txct4IImIiCh9K03vvvuuXHTRRXLkkUf6f7bddtvJCSecID6fTy0wS0QUU2txZ55YSthanIiIiFJT1EmnoaFBttlmm2E/23rrrVVYQttxIqLRGPS4pb92iRgsNrFVTGdrcSIiIkr/0IQ5TVbrht2sioqKpL+/P977RUQTvLU4ApMMitiq2FqciIiIJkhoQjvgWK4jIgr+e+FSrcX7xF45k63FiYiIKOVxIhIRjSt381rxdLeJtXy6GO1ZPPpEREQ0sdZpQqc8p9M57GeYzxTq5xdffLEUFxfHZy+JaELwdDSJu61erCXVYs4uSPbuEBEREcU3NDkcDvn0009DXhfq5+ecc060d01EGdJafKBxlVjyS8VSUJ7s3SEiIiKKf2h68cUXo79XIqIAvoG+da3Fc8VSMpnHhoiIiNIK5zQR0Ti0Fl+8rrX4DLYWJyIiookbmu677z7p6uoa1Z17vV55/PHH1RpPRJSZrcUH6paiZZ7YKmeKwWhK9i4RERERJS40dXZ2yt577y333nuvNDU1Rdx2YGBAnnvuOTnooIPklVdekezs7NHvGRFNiNbivoFesVXOEqPFluxdIiIiIkrsnKazzz5b5s+fL3/5y1/khhtukG233Va23HJLmTJligpF3d3d0tjYKF999ZV89tlnYjKZ5NRTT5Vjjz1WjEaOAiTKNO6WGtVaHBUmE1uLExERUaa0HEdQevnll+WNN96Qp556Su6//37p6+vzX49wtPnmm8vpp58uhx12GCtMRJncWry1jq3FiYiIKPNCExgMBtlzzz3VxeVySX19vbS3t0tOTo6UlZVtsF4TEWUWb2+nai1uzitha3EiIiLKzNAUyGq1yuTJk9WFiMjnWt9a3FrKvwtEREQ0MXCyERHFrbX4QM0SMZgtYiufLgYD/7wQERHRxMCzGiIas8FBn2otjq/olGcwjamITURERJRSGJqIaEzYWpyIiIgmOoYmIhp7a/GuVrGWTWdrcSIiIpqQxjyGxufzqcsGd2zm8Byiic7T2TzUWrx4kphzCpK9O0REREQJEVOy6e3tlauvvlqt2dTT0xNym9dff10tfEtEE5O3t0tcDetaixdWJHt3iIiIiFIrNN12220qMB100EFSWlqqFrUNVlDAT52JJnZr8aVidOawtTgRERFNeDGFpg8//FCuuOIK2XfffeO/R0SU0ga9bhmoXcrW4kRERJQxYmoEgTlM06dPj//eEFHqtxavXSaDXg9bixMREVHGiCk0bbfddvL222/Hf2+IKKW56leKr79HBSajxZbs3SEiIiJK3eF5e+yxh5x99tlSX18vm222mTgcjg222W233SQrKyse+0hEKcClWou3iK1ihpgc2cneHSIiIqLUDk0XX3yxtLS0yBNPPKEu4brnMTQRTQyezhZxt9SKtbhKzDmFyd4dIiIiotQPTQ8++KC43e6I21RWVsa6T0SUcq3FV65rLc7fayIiIso8MYUmHYgWL14s77//vqo65ebmyuabb67mO4VqQU5E6cfn6h9qLe7IZmtxIiIiylgxhSa45ppr5L777tvg51tttZXcfffdkp3NOQ9E6d9afIkYTGY1j8lg4IchRERElJliOgvCwrYPP/ywagaBLnrff/+9fPDBB3L99ddLXV2dXHvttfHfUyJKTmvxqtkqOBERERFlqphC03PPPSdnnXWWnHrqqVJVVSVms1lKSkpk//33lzvuuENeeOGFEec8EVHqwhymodbiM9lanIiIiDJeTKEJrcZ33HHHkNfNmTNHnE6nmudEROnH1VKruuVZy6aKyZGT7N0hIiIiSs/QVFFRIQsXLgx5XUNDg3R2dqrGEESUjq3Fa4Zai+cWJXt3iIiIiNI3NO2zzz5q3tKbb74pg4OD/p8vWrRITj/9dJk/f76qNhFR+vD2rWstnlvM1uJEREREAWKa3X3wwQerwISA5HA41Hymjo4OdZk0aZLcfPPNsdwtESWztXgtWotnibVsCl8HIiIiorGGJqzDdNttt8lbb70l7733npq/lJWVpdZpOvDAA9lunCiNoEPe+tbiM9lanIiIiChIzH2EDQaD7LHHHupCRGncWrxuqQpO9uq5bC1ORERENJbQhOF4O+ywg6oo4fuenp6I2yNMYVsiSl2eptVicPeJbdJsMVrtyd4dIiIiovQOTddcc43cc889Kgjh+9WrV0fc/vXXX2doIkphxp5W8VodkjVlLluLExEREcUjND344IOq4YP+fqTFaysrK6O9ayIaZ97uVjH1tIh5xjZsLU5EREQUr9AUGIIYiIjSu7W4u3G1+Ow5Yi6oSPbuEBEREU3cRhBYwNZms6kLvPbaa/LNN9/I9ttvL7vssks895GI4t1a3O4Ub46Vx5WIiIgoUYvbLl68WHbffXepr69X/37hhRfkzDPPlPvvv19OPPFEeeKJJ2K5WyIap9bilrLpaIHJ401ERESUqNCEcLTttttKWVmZ+vfjjz+uOuuh0nT11VfLrbfeKoODg7HcNRElrLX4MhWcbJWz2FqciIiIKNGhaeHChXLyySeL3W6Xjo4OFZaOOOIIsVqtcvDBB4vH45GmpqZY7pqIEsDVsEp8fd1q8Vq2FiciIiIah9Dk9XpVQIL33ntPLXS74447+q83m83qZ0SUfO7WWvF0Nou1bKqYnDnJ3h0iIiKizAhNM2bMkFdffVX6+vrk0UcflS222EJycoZOxrB+U3d3txQUFMR7X4lolDxdreJqrhFLUSVbixMRERGNZ2g67rjj1LymrbbaSr7++ms5/vjj/df9/ve/l3322UdVm4goebx93eKqXyHmnCKxFlXxpSAiIiKKUUzJBpWlJ598Ug3Nw/doCqHttddectRRR8W6P0QUBz73gOqUZ7RnibV8Ko8pERER0RjEXA6aM2eOugQ76aSTxrI/RBSP1uI1i1WHPFvlDDEYYiooExEREdFoQ9Obb76p2opnZWWp73t6eiJuv8cee6htiSg5rcXt1XPEYLLw8BMRERGNV2i65ppr5J577lFBCN+j4UMkr7/+OkMT0ThzNa4eai1eNVuMVgePPxEREdF4hqYHH3xQSkpK/N+73e6I21dWVo5974goau7WOvF0NImtfBpbixMRERElIzQFhqBwgcjn84nRyPkTROPN09Umrua1YimsEHNuMV8AIiIiojiKOeF8/vnnqtX42rVr/T/71a9+JTfeeKMKT0Q0Prz9PeKqXy7mnEKxsLU4ERERUWqEpi+//FJ+/etfi9frHTZvab/99lOtyG+++eZ47iMRjdha3CnW8mliMBh4rIiIiIhSITTdd999qrU45jYVFBT4f/6b3/xGHnjgAXnooYdYbSIaj9bitUtUS3Fb5Uy2FiciIiJKpdC0atUq2XPPPUNet9FGG6nqU1NT01j3jYgitRavXy6DHrfYqmaxtTgRERFRqoWmwsJCWbBgQcjrGhoapL29XXJycsa6b0QUobW4t7dTbBUz2FqciIiIKBVDE+YuYa2mZ555Rrq6utTPML/p22+/ldNOO0123nlncTqd8d5XIkJr8bb6odbipVPE5MzlMSEiIiJKlZbjgQ477DD5+uuv5aKLLlIXu90uHo9HXWbPni2XX355/PeUiMTT3SaupjVDrcXzhtZNIyIiIqIUDE3o0HXllVfKUUcdJR988IGav4TgtNlmm8lPf/pTsVgs8d9TogzH1uJEREREaRSatLKyMikvL1cL2h5++OGybNkyMZlM8ds7IhreWtzmFGvZVLYWJyIiIkqH0HTvvfeqhWzdbrf6N7rpXXDBBaoF+R133KGaRRDR2A36vDJQu3SotXjFTDEY+cEEERERUco3gnjjjTdUYMJaTWgGUVVVpX6OuUzd3d3yt7/9bdT32dHRoVqZ6xAWLVS3VqxYMerHI0oHg4ODMlC3TAbdA2KrnCUGM4e+EhEREaVFaPrXv/4lf/jDH+TMM8+UTTbZxD8kb4cddlAVqNdffz3q8IOue5dccolsv/32qlq10047yWuvvRbVbd966y3Zd9995be//W0sT4Mo5bmbAlqL2xzJ3h0iIiKijBRTaKqrq5Ntttkm5HUVFRWSl5cnLS0tUd3XI488Ik8++aT6RB1D+rDG0/nnny+1tbUjVqb+/Oc/x7L7RGnTWtzd3jjUWjwrL9m7Q0RERJSxYgpNJSUl8sknn4S8buXKlSr45OfnR3VfCExw9dVXy0cffaQqTQMDA/LSSy9FvB2GAKJrH9GEbi1eUM7W4kRERETpGJoOOOAAueGGG9RQvIaGBv8wuy+++EJOP/101XYcLchH0tvbq+YkwS677KI6guErLFiwIOzt3nnnHXnhhRdku+22i2X3iVKar79HXPXLxZxdIJbiScneHSIiIqKMF1P3vEMOOUS++eYbufbaa9VFBynMY5o1a5ZceumlUd1Pc3OzGpYH6LoHukIVrorU2dmp7h/tzv/4xz/KQQcdNKYXEY+P8BYvPlefuFwuEbFKX19f3O43k+njmAnHc9DjElfNj2IwWcWSWy7eBD3nTDqm44HHk8c0E9+j+P8TH3YSEWWCmBe3Rac8hCdUfRobG8XpdMrmm28ue++9t1it1qjuRzeLQCMJ/YdXN5UYCh4bwqK6eLy77rpLcnJyYtn9DfZh4cKFEjeeAbG0NooUTFJDFSl+Jvzx9PnE3L5GffUUVot0/Zjwh5zwx3Sc8XjymGbaezTa/++JiDIyNL344osyZ84c2WKLLdQlVg6Hwz+0z+PxiNlsVvOZICsra4Pt33//fXnuuedUlz40nNB//BF8Fi9eLFOmTBGbzTaqfbBYLDJz5kyJZ6Wpe1m/1LpFpk6d6n+OFDt8MorXeiIfT3xi625YLoPOCrFUzRajNbHPMxOO6Xji8eQxzcT36NKlS+NyP0REEzY03X///XLqqafK7Nmzx/TgpaWlKighMKEjX3V1tdTU1KjrJk3acC7H559/rr5+/PHHsv/++/t/jsoT/v3000/LpptuOqp9QIULVbJ48ZkM4sInb+6hUBjP+850E/l4uhpXi3gHxD513rh2ypvIxzQZeDx5TDPpPcqheUSUSWIKTbm5uapCM+YHN5tVpQph6NZbb5WDDz5Ynn/+eXWdbvKAENXT06MqS8XFxWrOlIYKEz45w77g07Nomk8QpRp3e4O6WMvYWpyIiIhowoSmAw88UM455xwVcmbMmCFFRUUbbIMueNF8moWK1Yknnqi64eECuE8sWgto+vDBBx/I3//+dznmmGPURVu7dq3svvvuqmL18ssvx/JUiJLK092+rrV4mVjySvlqEBEREU2U0HT77berjnOPPvpo2G1ef/11NcdoJFiXCa3LH3jgAdVNb968eXLmmWf6J5dWVVWp6lKopg+oMOE6dNIjSje+gV5x1S8TU1a+WIqrk707RERERBTP0HTfffeF7W6nVVZWRn1/8+fPV5dQ0KUvHIQlVpgoHfk8LumvWSIGq11s5dM4N4CIiIhoIoWmFStWyOrVq1WjBgyjI6LRGfR5ZaB2ifreVjlLDMahNvtERERElOahCU0XLrzwwmGVHQytu+6666SwsDBR+0c04VqLD9Qtl0HXgNir54jRzDVOiIiIiFKdMdoNH3vsMXnttdfkuOOOk2uvvVbNO1qwYIFabJaIouNuXiPe3g6xVcwQo42tvomIiIgmVKXp3XfflYsuukiOPPJI/8/QFvyEE04Qn88nRmPU+YsoI7nbG8Xd1iDWUrYWJyIiIkonUSedhoYG2WabbYb9bOutt1ZhCV3viCg8b0+HuJpWD7UWz2drcSIiIqIJGZowp0m3AQ+ENZr6+/vjvV9EE6q1+EDdMjE589hanIiIiGgihyZMYI/lOiLJ9NbitWgtbhNbxXS2FiciIiJKQ5yIRJTo1uKDbC1ORERElDHrNKFTntM5vOMX5jOF+vnFF18sxcXF8dlLonRsLV6/QgZd/WKvnsvW4kRERESZEJocDod8+umnIa8L9fNzzjlnbHtGlMbczWvF29MutoqZbC1ORERElCmh6cUXX0zsnhBNEO4OtBavF2vpZDFn5yd7d4iIiIhojDiniSjercUbV4slH63Fy3hsiYiIiCYAhiaiOPEN9K1rLZ4rlpJqHlciIiKiCYKhiSgOBj1u6a9dLAYLWovPYGtxIiIiogmEoYkoDq3F+3Vr8apZYjCaeEyJiIiIJhCGJqIxthZ3qdbifWKvnMnW4kREREQTEEMT0Ri4W2rE090m1vLpYrRn8VgSERERTUAMTUQx8nQ0ibu1Tqwl1WLOLuBxJCIiIpqgGJqIYmwtPtC4Siz5pWIpKOcxJCIiIprAGJqIYmktXr98XWvxyTx+RERERBMcQxPRKFuLD9QuEYPZytbiRERERBmCoYloFK3FB+qWyuCgT2yVM9lanIiIiChDMDQRRdtavGGl+AZ6xVY5S4wWG48bERERUYZgaCKKtrV4V6tqLW5ia3EiIiKijMLQRDQCT2czW4sTERERZTCGJqIIvL2dMtCwUsx5JWwtTkRERJShGJqIwvC5+mSgbplqLW4tZWtxIiIiokzF0EQUwqDXLQM1aC1uEVv5dDEY+KtCRERElKl4JkgUBC3FB2qXrWstPksMJjOPEREREVEGY2giCm4tXr9SfP09YquYydbiRERERMTQRLRha/GWodbijmweHCIiIiJiaCLaoLV48SQx5xTwwBARERGRwuF5RKq1eJe4GlYNtRYvrOAxISIiIiI/hibKeEOtxZeK0ZnD1uJEREREtAGGJspoqrV47VK2FiciIiKisBiaKGP5W4t7PWwtTkRERERhMTRRxvK3Fq+cxdbiRERERBQWQxNlJJe/tfg0thYnIiIioogYmijjeDpbxN1SK9biKjHnFCZ7d4iIiIgoxTE0UQa2Fl+5rrV4ZbJ3h4iIiIjSAEMTZQyfq3+otbgjm63FiYiIiChqDE2UQa3Fl4jBZBZbxQwxGPjWJyIiIqLo8MyRMqu1eNVsFZyIiIiIiKLF0EQTHuYwDbUWn8nW4kREREQ0agxNNKG5WmpVtzxr2VQxOXKSvTtERERElIYYmmiCtxavGWotnluU7N0hIiIiojTF0EQTkrdvXWvx3GK2FiciIiKiMWFooonZWrwWrcWzxFo2Jdm7Q0RERERpjqGJJhR0yFvfWnwmW4sTERER0ZgxNNHEai1et3SotXjlLLYWJyIiIqK4YGiiCcPVsEp8fetai1vtyd4dIiIiIpogGJpoQnC3orV4M1uLExEREVHcMTRR2vN0tYqruUYsRWwtTkRERETxx9BE6d9avH6FWofJWlSZ7N0hIiIiogmIoYnSls89MNRa3I7W4lOTvTtERERENEExNFH6thavWTzUWrxyBluLExEREVHCMDRRmrYWXxbQWtyS7F0iIiIiogmMoYnSjqtxtfj6utXitWwtTkRERESJxtBEacXdWieejqah1uLOnGTvDhERERFlAHOyd4AoWt7uNhlsrxVLUaXqlkdERERENB5YaaK0YHD3ibtxlZhz0Fq8Ktm7Q0REREQZhKGJUt6ge0BMHXVitDnFWs7W4kREREQ0vhiaKKWhQ56rfrmIwSCW8ulsLU5ERERE446hiVK7tTgCk9ctnrwqtSYTEREREdF4Y2iilG4t7u3tFEvZNBGzNdm7Q0REREQZih/dU0pyt9Wr1uK28mniMjuTvTtERERElMFYaaKU4+lqE1fTGrEUVog5tzjZu0NEREREGY6hiVKKt79HXA3LxZxTKBa2FiciIiKiFMDQRCnD5x6QgdolQ63Fy6aKwWBI9i4RERERETE0Ueq0FkdgMhiMYquYKQajKdm7RERERESksNJESTc4OKhaiw963GKrmiUGsyXZu0RERERElHqhqaOjQ1atWiVutzuq7QcGBmTNmjXi8XgSvm+UWK7GVaq1uK1ihhitDh5uIiIiIkopSQ9NXq9XLrnkEtl+++1lzz33lJ122klee+21sNv39PTIRRddJFtssYXsscce6usNN9ygqhWUxq3FS6eIyZmb7N0hIiIiIkq90PTII4/Ik08+qUJPYWGhtLe3y/nnny+1tbUht7/qqqvkmWeeEZPJJFVVVaoyddddd8ljjz027vtOY+PpDmgtnlfCw0lEREREKSnpoQmBCa6++mr56KOPVKUJQ+9eeumlDbZ1uVz+n993333y9ttvyymnnKL+je8pffjQWrx+uZizC9hanIiIiIhSWlJDU29vryxbtkx9v8suu6gW0/gKCxYs2GD77u5u+elPfyrz58+XbbfdVv1so402Gue9pni0Fu+vXSoGq0Os5dPYWpyIiIiIUpo5mQ/e3Nzsn4tUUFCgvubn56uvTU1NG2yP4Xs33XST/98+n89fqcL8pljg8RHe4sXn6lMVMRGr9PX1xe1+J4pBn1fctYtl0OsVa/FU6esfGPE2+jjyeMYPj2l88XjGH49p6h9P/P/J9fSIKFMkNTTpTnmYn6T/8OJ7GAoe4SEwXXzxxfLxxx/LpptuKocddljM+7Bw4UKJG8+AWFobRQomycqVK+N3vxPB4KCYOmrF4O4XT8Ekkd6lo7o5j2f88ZjyeKY6vkdT+3harda43h8RUapKamhyOBz+DnpoHW42m9V8JsjKyooYdNAs4tVXX5VZs2bJHXfcoW4bC4vFIjNnzpR4Vpq6l/VLrVtk6tSp/udIIu7mNeK1F4m1fIYYR9EpD5+M4j96Hs/44TGNLx7P+OMxTf3juXTp6D74IiJKZ0kNTaWlpSrsIDDV1dVJdXW11NTUqOsmTZoUtsJ07rnnqrbk8+bNk3vvvVcN24sVKlxOpzPm22+wfyaDuPDJm3soFMbzvtO9tfhgf6c4q2eJJa80pvvg8Yw/HlMez1TH92jqHk8OzSOiTJLURhAITFhnCW699VY11O75559X/95uu+3UV4SoxYsXS1dXl/r3zTffrAJTTk6OWq8J86Jw/erVq5P4TCgST3f7UGvxgvKYAxMRERERUUZWmuDUU0+VE088UV544QV1gRkzZsi+++6rvr/00kvlgw8+kL///e9qAVy0GgeEqKOPPtp/PxtvvLE8++yzSXoWFLm1+DIxobV4cejqIRERERFRKkt6aMK6TBhi98ADD6iqEYbcnXnmmf7JpVjAFvOWUFlCw4YpU6aEvJ9wP6fk8Xlc/tbiNrYWJyIiIqI0lfTQBFh3CZdQLr/88mH/fvnll8dpr2isrcUHapaIGERslTPFYBzqikhERERElG6SOqeJJias3TFQt1wG3QNir5wlRjNb0hIRERFR+mJoorhzN60Rb2+H2CpmiNHG7oFERERElN4Ymiiu3O0N6mItmSymrDweXSIiIiJKewxNlIDW4mViyWdrcSIiIiKaGBiaKC58A73iql8upqx8sRRX86gSERER0YTB0ETxaS1es0QMVhtbixMRERHRhMPQRGNvLV67RH1vq5zF1uJERERENOEwNNHYWovXr5BB14DYq9hanIiIiIgmJoYmipm7eY14e9rZWpyIiIiIJjSGJoqJu71R3G1oLV7N1uJERERENKExNNGoeXs6xNW0Wiz5aC1exiNIRERERBMaQxONurX4QN0yMTnzxFLC1uJERERENPExNNHoWovXLhGDxSa2iuliMBh49IiIiIhowmNoolG0Fl8qMihiq2JrcSIiIiLKHAxNNIrW4n1ir5wpRrOVR42IiIiIMgZDE43I3bxWtRa3ls8Qoz2LR4yIiIiIMgpDE0Xk7kBr8XqxFk8Sc3Y+jxYRERERZRyGJorcWrwRrcVLxVJQziNFRERERBmJoYlC8g30rWstniuWksk8SkRERESUsRiaaAODHrf01y5e11p8BluLExEREVFGY2iiDVqLYy0m1Vq8cqYYjCYeISIiIiLKaAxNNKy1uCuwtbjFxqNDRERERBmPoYn83C014uluE2v5dLYWJyIiIiJah6GJFE9Hk7hb68RaUi3m7AIeFSIiIiKidRiaSLy9nTLQuIqtxYmIiIiIQmBoynBsLU5EREREFBlDU4a3Fh+oXSIGs5WtxYmIiIiIwmBoyuDW4gN1S2Vw0MfW4kREREREETA0ZWpr8YaV4hvoFVvlLLYWJyIiIiKKgKEpU1uLd7Wq1uIme1ayd4eIiIiIKKUxNGUYT2czW4sTEREREY0CQ1OmtRZvWCnmvBKxFJQne3eIiIiIiNICQ1OG8Ln6ZKBumZicuWItnZzs3SEiIiIiShsMTRlg0OuWgRq0FreIrXy6GAx82YmIiIiIosWz5wkOLcUHapetay0+Swwmc7J3iYiIiIgorTA0TXCu+pXi6+8RW8VMthYnIiIiIooBQ9ME5lKtxVuGWos7spO9O0REREREaYmhaYLydLaIu6VWrMWTxJxTkOzdISIiIiJKWwxNE5C3t0tcurV4YUWyd4eIiIiIKK0xNE3I1uJLxejIZmtxIiIiIqI4YGiaaK3Fa5eqDnm2ihlsLU5EREREFAcMTROttbjXI7aq2WwtTkREREQUJwxNE621eOUsthYnIiIiIoojhqYJ1Vp8GluLExERERHFGUPThGktXiXmnMJk7w4RERER0YTD0JTGvH3rWovnFoulsDLZu0NERERENCExNKUpn6tfdcpTrcXLpiR7d4iIiIiIJiyGprRtLb6ErcWJiIiIiMYBQ1M6thavW9davHIWW4sTERERESUYQ1OawRwmXx9ai88Uo9We7N0hIiIiIprwGJrSiKulVnXLs5ZNFZMjJ9m7Q0RERESUERia0qq1eI1YiqrEnFuU7N0hIiIiIsoYDE1p1Vq8SKxFbC1ORERERDSeGJrSprV4lhqWR0RERERE44uhKYWhQx5bixMRERERJRdDU0q3Fl8a0FrckuxdIiIiIiLKSAxNKcrVsIqtxYmIiIiIUgBDUwpyt6K1eDNbixMRERERpQCGphTj6WoVVzNai1eytTgRERERUQpgaEoh3r5ucdWvEHMOWotXJXt3iIiIiIiIoSl1+NwDqlOe0Z4l1nK2FiciIiIiShWsNKVKa/GaxWIwmcVWOUMMBr4sRERERESpgmfnKdFafBlbixMRERERpSiGpiRzNa4WX1+32CpmitFqT/buEBERERFREIamJHK31omno2motbgzJ5m7QkREREREYTA0JYmnq01czWvFUljB1uJERERERCmMoSlprcWXD7UWL56UjF0gIiIiIqIoMTQlo7V43VK2FiciIiIiShMMTePdWrx2iWopztbiRERERETpgaFpPFuL1y+XQY9bbFWzxGCyjNdDExERERHRGDA0jWNrcW9vp9gqZojR6hivhyUiIiIiookSmjo6OmTVqlXidrsTsn0yudvqVWtxm2otnpvs3SEiIiIionQKTV6vVy655BLZfvvtZc8995SddtpJXnvttbhtn2ye7jZxNa1Z11q8ONm7Q0RERERE6RaaHnnkEXnyySdlcHBQCgsLpb29Xc4//3ypra2Ny/bJ5OvvWddavFAsRVXJ3h0iIiIiIkrH0IQABFdffbV89NFHqnI0MDAgL730Uly2TxqvR9wNy8Voc4q1bKoYDIZk7xEREREREaVbaOrt7ZVly5ap73fZZRcVLPAVFixYMObtk8nU1SiC1uIVM8VgNCV7d4iIiIiIKEZmSaLm5mY1zA4KCgrU1/z8fPW1qalpzNtHA/eHMBYvPlefuFwu9b03r1L6XG4RXChmfX19w77S2PGYxhePZ/zxmKb+8cT/nxxFQUSZIqmhSXe+M5lM/j+8+B508BjL9tHuw8KFCyVufF4xt7WJN69cVtXWi+BCcbFy5UoeyTjjMeXxTHV8j6b28bRarXG9PyKiVJXU0ORwOPwd8Twej5jNZjU/CbKyssa8fTQsFovMnDlT4qmvb4b6j2nq1Kn+faaxHM8+Hs844zHl8Ux1fI+m/vFcunRpXO6HiCgdJDU0lZaWquCDAFRXVyfV1dVSU1Ojrps0adKYt48GKlZOp1MSAf8xJeq+MxGPJ49pquN7lMc0k96jHJpHRJkkqY0gEIC22GIL9f2tt94qH3/8sTz//PPq39ttt536ilC0ePFi6erqimp7IiIiIiKiCdVy/NRTTxWj0SgvvPCCHHfccSokzZgxQ/bdd191/aWXXir777+/vPfee1FtT0RERERENGGG5wHWWbr33nvlgQceUN3x5s2bJ2eeeaZ/cmlVVZXMmjVLcnJyotqeiIiIiIhoQoUmmD9/vrqEcvnll49qeyIiIiIiogk1PI+IiIiIiCiVMTQRERERERFFwNBEREREREQUAUMTERERERFRBAxNREREREREETA0ERERERERRcDQREREREREFAFDExERERERUQQMTURERERERBEwNBEREREREUXA0ERERERERBQBQxMREREREVEEDE1EREREREQRGAYHBwclQ3355ZeCp2+1WuN6v7hPt9stFotFDAZDXO87E/F48pimOr5HeUwz8T3qcrnUfW211VZxuT8iolRmlgyWqECD+413EMtkPJ48pqmO71Ee00x8j+I++cEgEWWKjK40ERERERERjYRzmoiIiIiIiCJgaCIiIiIiIoqAoYmIiIiIiCgChiYiIiIiIqIIGJqIiIiIiIgiYGgiIiIiIiKKgKGJiIiIiIgoAoYmIiIiIiKiCBiaiIiIiIiIImBoIiIiIiIiioChiYiIiIiIKAJzpCspvO+//14WLVokJSUlssMOO4jFYonr9pmmt7dXPvroI+nq6pItt9xSpk6dGnH7vr4++fzzz6WtrU1mzpwp8+bNG7d9TRfLli2Tb775RvLz82XHHXcUm80W1e2++OILWbx4sey6665SWVmZ8P1MFy6XSz788EP1ntt0001l1qxZI95m4cKF6ve+tLRUtt9+ezGZTOOyr+li9erV6v2WnZ0t8+fPl6ysrIjb41jivYntttpqKykoKBi3fU0nn376qfr932+//SQ3Nzfsdh6PRz7++GNpbGyU2bNnq/c1ERGFxtAUg6uvvlruv/9+/7833nhjeeihh9R//PHYPtPU1NTI0UcfLbW1terfOLG8+OKL5aijjgq5/bfffitnnnmm1NXV+X+21157yY033siT0nXuvvtuueGGG2RwcFD9GyH0/9s7E2gbqzeM7yZT+ROKUgq1qIQSykIUMmRoIFRmESlDKpUyRWkyhsIiU6bMY2ZW0TIVSiVDVCTCokj0X7+39vHdc8899xxyu7rPb62zrvPdfT7ft+8+5+xnv+/77FGjRtnkPRp79uxxLVu2dIcOHXKDBw+WaPqb/fv323jcunWrPT/vvPNsDLZq1SrJyWinTp3c9OnTQ8cKFy5s7/uMGTPG/N74LzNx4kT38ssvuxMnTtjzXLly2RjNkydPxPZ8JkyaNCn0HDHQt29fE1viFIj6p556ysZsiRIlkhRNR44ccY0bN7aFFQ+fw507d1Z3CiFEBJSeFyfr1q0zAXThhRe6ChUquOzZs1sUaciQIf9I+7QIohLBxGSpTJkyNoniGBP4SHTs2NEEEyujVapUsajdvHnz3IQJE1L82lMj27dvNwGJYCpfvrwJH38sOZjEIphEQvr06WOCiYn9XXfdZcf69+9vq/mRGD58uAmmTJky2RglwozYHzFihLrWOffzzz+7Hj162Hu9dOnS7pprrnG7d+92PXv2TDJygmDivV61alWLRjNOu3btqv4M69fmzZubYEqOYcOGmWDKli2bq1ixovXt6NGjra+FEEIkRqIpTmbNmmU/a9eu7QYOHOh69eplz+fMmfOPtE9rkGa3ePHi0Jf40KFDXcmSJS0VauHChYnak5qDACBK98EHH9hktkmTJva74IppWgYByWSUiRDRogEDBoSOnzx5MsnXTZ061f4WRFHEKRCf/v2KUBo0aJBFNunLuXPnRuwqxiYg/hmjRP4ee+yxmFL60gKLFi1yR48edbfddpu9772YXL58uTt8+HCi9jt37rSf999/v4n/MWPGWMRu165doWhqWofPyxo1argNGzbE1N5/NyFe+YyoW7euPdd3kxBCREaiKU6YtEOhQoXsp88B50udupwzbZ/WYPX++PHjLkuWLKG0HNKYgn0XhHakPbVp0yZU/3D++X8NY9U3RB5z1Huxikw6DqmQkaCmgVV+0vgQreIURDWJajDOfO1ctDHKKj/9jPgsWrSoiVWOMWaJNovEY5RoaI4cOSyt0adABmFMErVbsGCBCVAiTCy4lCtXTiL/b1auXGk1od27d7e+jMaxY8esnizSd1OkMS2EEEKi6bTyxcHniQfrkiKlNcXbPq3h+ydz5syhY76PDh48mKh9zpw5XaNGjewBTE5Z1WdCW7NmzRS77nOpT5m8M+GEAwcOJJmWx4QL4ZQhQ4YUvNpzpz+JbJBmm9wYJUUKaFuvXj2rfSIaykp+LGlTaf19H2mMXnXVVe61116z/nvjjTfc+PHjTWh169YtBa86dUPaKKKyTp06ybalj33UOfy7KdKYFkIIIdF02kRKYYqW+hRv+7SCT605nf4hWtegQQObgFGQX7BgwbN2nf+VPo2UyjRt2jRLl6IvixUrliLX+F8eo97YgAgqaaaIeQw4qGXEnEPEP0a3bdtmEWaEKDViRYoUsTrI1q1b63P0b3BlZVEpXsL/BvpeEkKIyMg9L058SphPrQum2AVXTU+3fVrD9w+pNh7fR9H6hwJ8ok2klfGT1CeRfJ+GOzZynOgS6XtXXHGFGzduXMjFcNmyZRZdwSo7LeP7kxocJvRMMqON0eAx6hiZ4COYqMfB3llEHqOkj0IkV1HGJbVORO0QSvwdEKMY7WBckNbHaLwErd0Zy0SXY/ncFUKItIxqmuIElyfwefdbtmyxn7hjRfqyibd9WsPvx7Rv375Qyo7vo3z58kV8DSl5DRs2NMGEPTYr0CLxmPPObjt27LCoB8Lo6quvTtBVTFRJ1eH3mJR06dIlVNMwduxYM4dI6+TOndv6jnob+jK5MUramE+H9Psy4VAWjEKldcLHKGOQzwDImzdvova818H3K8LVi6tIxhEiOvQdTq6RvpuS+twVQoi0jiJNcVK2bFmbSDKhZCLlHd6wdvaTAFY+MTVgQ9Hk2qd1mEyybxUr8R06dLCi5KVLl9qkiCJvmD17tuXZV6pUydq3bdvW7d271yazWECzCg2+z9M6jDlcCGfOnGnpOt5CGGtnxiCRJPoY4c4K/UMPPZTg9TiY0YbzyBTCuXTp0lk/rFixwj333HO2LxB9G3wfU0vCmPQbAuOuN2XKFLPHxznTO0SyIatwtrXA66+/buOQGiU2ASYtDCtx3uMIqPnz55vxCxbjfC7g6oZzIdEptiNgU1zS9bSxdWywMTPmD+zdlD9/fnt/M0apC+Oz1Ts+6rtJCCEic96f8muNC1aKmzZtmiDNBqeiyZMn2wSeDRtffPFFmzT169cv2fbCudWrV1uhPI5OHupr2MwSKleubDUNFH+zqkx/RsL3uXCuffv2IUth8BbtWF4zgSdCxwTeC84gLVq0cEuWLDG7ck2g/mLz5s22uW0wqlG9enWb8AOGD2vXrg31GQKqfv36IYcyQMDS34h94czljX2BPOnTp3cjR4404bR+/XoT80SdsHVHKLERK+l4HhZW2rVrZ+NVJITFIwxJWHBCIAGpjTg5YjGOkMeuHXMSxqqHBQH2GNO2A0IIkRhFmuKEdBtW8dm48osvvrDVemoV+OlTG/iyJ3oSS3vhbK+WGTNmWB/hKFi8eHFb+fRUq1bNvthJJyHiFB4Z8fg+F84MB7C3ZpLJan2tWrXMgQyIhNCHPkUqHFagmeDTTvwFJiNEl4gaEwWhTolx6aGvEaS+z3h/s4rPA8MS+po9dJSSe4rOnTvb5H7VqlVWO4cI9RN83uuMUf85ye+J1hN92rhxo9Xg8FoElkgM73fcMHnve+ivrFmzhtLv+DzgM5cFPCJ3BQoUsDoxCSYhhIiMIk1CCCGEEEIIEQUZQQghhBBCCCFEFCSahBBCCCGEECIKEk1CCCGEEEIIEQWJJiGEEEIIIYSIgkSTEEIIIYQQQkRBokkIIYQQQgghoiDRJIQQQgghhBBR0Oa2QqQSJk2a5H788ccEx9ho8uKLL7bNUdmcMn369Cl+XSdPnnQDBw50d9xxh21EHP48Ob799lu3du1aV7t27QTHN2/e7NasWWObcP7vf/9zhQsXdoUKFXL/FgMGDHDFihWz+wLuc+XKla5UqVJJtvmnzpscf/75pxs2bJhtjJ0tW7a47ksIIYQQZ44iTUKkEiZPnuxGjx6d4BgT7K+//tp16NDBVa9e3e3duzfFr4trYOKP8In0PBrHjx+3a0f4eX799VfXokUL17BhQ7dp0yZ35MgRt2HDBte4cWNXr149t2/fPpcaePbZZ13//v1TxXkRz3/88Yfr0qXLP349QgghhEgeRZqESEVceumlrk2bNomOIzAefPBB99Zbb7levXq5c4UhQ4ZYdKxq1aqhY9zD559/7mbPnu2yZ88eOt6+fXt33333mTA4G2IlOZ544okEz/fv359sm3/qvLGAqKxUqZL1W7A/hRBCCHH2kWgS4hygYMGClrr28ccfJzj+22+/ucWLF7udO3da2lb58uVdjhw5IrbZtWuXy5Url7v77rsTRH7gwIEDbvny5e6HH34wkXPrrbdautyZcPjwYTdy5Ej3wgsvJDj+ySefuBtvvDGBYILLLrvMvfTSS+67776L6x6JelWoUMFlyJDBLVu2zB07dszSBm+55ZYE5yEljpRAIjbXXXedpTtedNFFEdPoxo0bZ9dBpAwBV6NGDUuRDLYZP368O//88xOlHX722Wd2HU2aNLF+Tu6869atcwcPHjRhHOSbb75xc+fOdY8++qjLmjWr/V1IzyM1skqVKhZ9EkIIIUTKoPQ8Ic4RSIu78MJT6xwIgMqVK7t+/fq5X375xX300UeuYsWKbtGiRaE2GzdutOjE4MGDLe2Nif4999zjtm3bFmqDWEJ0EMFA6Kxfv97S5IgInWm64e+//27XFATh9umnn7oFCxZYrU4QrrVZs2Zx3eM777zjevfu7Zo2bWrCinTG+vXruz59+tjvT5w44R5//HFLi0MU0g+vvPKKCRbuN3gehFU0gm04V7du3dyhQ4cStBk0aJDdmxemyZ2X6+nZs2eCvwkgOKdNm2aCyXPvvfe6LVu2mCgTQgghRMqhSJMQ5wCIH+p+6tata8+JlpD2ReRl7NixLmPGjHYcMUAN0fz58+13bdu2dXnz5jUTAaIqiBQiF0R0Ro0aZYLi+eefd9WqVXNdu3YN/X+IFF5D7dHpmk8sWbLEIlbhUa2nn37aNWrUyLVu3dpdfvnlFvEpXry4K126tMuZM2eoXSz3SHQKtm7d6mbMmOEyZ85sz4lEjRgxwjVv3twiP4isiRMnhqJnCCyiPnv27HGXXHJJomtHNCJ8qL+KlC4JtWrVMjE6b968ULQJYbdixQq7vkhEOm/NmjVNoE6dOtW1a9fOjiE2OS9/qyD58+d3uXPntsjbnXfeGfPfQgghhBBnhiJNQqQimHSTtuUfb7/9tuvYsaN75JFHTFgggnyKG1EVRIEXE77uhQk5USOMGmiDQPBpaKR0IVpuv/12E0ykhdWpU8dEDBB5od6IKMrRo0fPyHiC81x//fWJjt9www1uzpw57sknnzRxg1hAuCECWrZs6Xbv3h3zPXrKlSsXEkxw8803W1ofosiLPv4fnPqA/xfRggg5XRCjRYsWdTNnzgwd45qICGLaEStcS5kyZUz0+cjb0qVLLYKFoAqHPqVvhRBCCJFyKNIkRCoWUNOnT3eZMmUyQwVEEzU03sYbSPvy//ZccMEFdozXAbU4QZjo8wCiOJgKUHezatUqE0lEMngAwup0QHAhwDC2iAT/L5EmHhgjcB+Ij4ULF7rt27ebgIjlHoPnC5IuXbrQ9VNPhCjEmXDChAn2vGzZspbqFoxsnQ5Em0jR++mnnyxqxnUjgMLrypKDWiVEHGmLJUuWtPNQkxX+twP69Msvvzyj6xZCCCFEfCjSJEQqdM/jQQoddUFELt5//3376fFiJhiB8VC/w8Sd9LbkIKrz8MMPmwDBtY7UMlLZEANnghd3wWv2aXRE0Hw0KSjcqP3hvqntWb16dUz36EnKFMFHbjp16mR1QN27dzdBQ90RtVFEs84E0hqpMyPChNEGpg6RokPJQaSM2iVEMmKT1EZqriJBv/j+FUIIIUTKoEiTEKkYIg19+/Z1DRo0sPoiamhItfMRCCbbwY1WcY577733bALua3Vwa7v22msTCJdZs2ZZyh/ubES0hg8fbo52nvBNduOFSA/XEG6vjYghqoVQQqyFU6JEiVC7WO4xHnDrw9KcB26BONCNGTMmyY1qY3GnY1Ne3AipP+K6/PNoRDov/UVKHxEmXBIRm0nZitOnZxohE0IIIUR8aLlSiFQO6WStWrWyKBAGDUCUBRMERBT21UHHNSypmbxju33llVdalCqYZofgmDJlSgJhFXSAQ0QR4YLguePlpptuMve7INQQce1EehBvQbhGUuhIDeTaY7nHWCBqRXvMFYIiBWHmjSQiQZtY0hMRYTgO0mcIseSMM5I6Lyl6iDlc/3zkKRJfffWV9a0QQgghUg5FmoQ4B8AgAWvwoUOHmpggIkPEBjFFKh3HMG8gratz586uQIEC9jqiVESoMHvgNdhxb9q0yb377rsW8WCSj8scrm1EOkjpw9abyBTnI42OPY1OByIubMSLIUMwxQ6nuGeeecbS2Kgtypcvn7Xh/qhVon7L1yTFco/JgQj78MMPLaqGUx/3TaoeooR+jbY3Fv3Uo0cPu04ekcD1jyjWjh073Kuvvprs9SR1XiJ9/A6hmVSKH2mU1J2F27gLIYQQ4uxy3p/hG6UIIf4VJk2aZAYKpM1FgpoZIkTsc+Qtro8cOWIigt+R8laqVKmQiYOHGhkMFhBAfnPboM02ERiE0vfff2+RF0wi8uTJY9EgLMNx2iNSQxobESBSx4LPkwJnPv4v6okeeOCBRL8n0rRmzRpLNyM6g2DgfMG9qGK5R4QVJhkYKATFBXVG7NeEoKFfidThxkfUCqGGWPHizJ/Hb0ILCEjMKeg32iJqwtt4sD+nFguBGk4s5/Vg+46zIKIueG2eN9980/6WvF51TUIIIUTKIdEkhDhrIK6Y5BPpEdFBvCIy2YsLV8FwEH7ly5c3gxAihEIIIYRIOVTTJIQ4azRr1swiOxgciMiwl1Tv3r3N7IONgP2eWeFQi1akSBEJJiGEEOJfQKJJCHHWIO0OYwNqlkRksmTJYmmR1JSxjxTCKRyyqDNkyOB69uypbhRCCCH+BZSeJ4QQQgghhBBRUKRJCCGEEEIIIaIg0SSEEEIIIYQQUZBoEkIIIYQQQogoSDQJIYQQQgghRBQkmoQQQgghhBAiChJNQgghhBBCCBEFiSYhhBBCCCGEiIJEkxBCCCGEEEJEQaJJCCGEEEIIIVzS/B/7dsPVxCMR7AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running stats on Logistic Regression\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running stats on Naive Bayes\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA00AAAInCAYAAABEG7KkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAxv1JREFUeJzs3Qd8q2X1B/DT7KR79+592XBBlixFEARk/hnKEpCNIqIMQVER2chSluwtewmyZcteFy5c7t693Ss76f/zO71PSHPTtE2TNml/3/vJp73Nm+TNm7fpc3LOc56C7u7ubiEiIiIiIqKkLMl/TERERERERAyaiIiIiIiI+sFMExERERERUQoMmoiIiIiIiFJg0ERERERERJQCgyYiIiIiIqIUGDQRERERERGlwKCJiIiIiIgoBVuqK4lodAiFQuLz+cTtdovdbl/v+nA4LF6vVzwej9hsA3tbCAaD4vf7paSkRIZr/+PheeD5EBEREWUbM01EY8Brr70m22yzjZx55plJr3/vvff0enwdqHvuuUd+8IMfSCQSkWx79tlndf++973v6WPigv9vueWWcvrpp8uqVauyvg9EREQ0djFoIhpDli5dKm+++WZG7uvnP/+5fPDBB2K1WmW43HTTTfqYuMydO1ceeeQRmT9/vhx//PGaLSMiIiLKBgZNRGMIsjJ///vftbRuoKLR6HqlcYD7aG9v7/V9sqxTZ2dn0ttj28HsRzIzZsyQo446ShYuXCgLFiwY0L6j1A/7mizI6urq0jLFdPYVj9Pd3Z3W8yAiIqLcxqCJaAwpKyuT/fffX+68885+t0VG6tBDD5XNN99ctt56a9luu+3kiiuuiAVGt956q5bIIfhYtGiRfv/444/3uo+2tjbZfvvt5a677or97KuvvpKf/exner9bbbWV7Lffflo+mC48PuY2jRs3bkD7vnbtWtl2223llltuWS+YQtnfjTfeOOB9RaB0/vnn62PgeWKbk08+WVasWJH28yEiIqLcw6CJaIw57LDD5PXXX5c1a9b0uc3nn38uJ510kuy9997yySefyGeffSZ//OMf5bbbbtP5RYk23HBD2WijjeSZZ57p9fPnnntOAxUEaoDg6qc//ak4nU4NPj7++GP58Y9/rIEG9qk/yAIhS4RLY2Oj3uaJJ56Qa6+9VkpLSwe07xMmTNCg6cknn+x137iv1tZWOeCAAwa8r3/5y190Hhju69NPP5UXXnhB7+Piiy8e0GtBRERE+YFBE9EYY7FY5Le//a1cdtllfW7z1FNPyaxZs+SYY47RbnqYt4QgpKamRt5+++2kt0Gw8e6770pDQ0PsZ08//bQGKCYLdMMNN+h9IetTVVWlHfBOPPFEzdBcc801/e47GlmYRhC4nHDCCVqWh8DFlMYNZN8POuggWbJkiQZC8fu6ySabaMnfQPf1yy+/lLq6Ohk/frz+v7q6Wh588EG9LREREY0eDJqIxqA5c+aIy+WSd955J+n1KDm79957NYuDoOHUU0+VXXbZRUvbAoFA0tvsu+++GpCZTBQ62n344Ydy4IEHxrZBULXxxhtLQUFBLGOEC8rfEIBg/tNAG0Egg4QM0Pe//30tFXzggQcGvO977rmnFBYW6jaAx3311VdjGbGB7iuCMQRshxxyiNxxxx06t4qIiIhGHwZNRGPUWWedpWVtmMuTCKVmu+66q1x11VUabGC+DoKCiRMn9tnsoLKyUnbeeedYiR6+Yq7RHnvs0WuO00cffdQrW4TLww8/LEVFRbHGEgOFLM8ll1yiJXTPP//8gPcd+7XXXntp+SAaPLz44os6Nwrld4PZV2SeMAcKmSZ8RRCFgAz3R0RERKMHF7clGqMqKipkn332kbvvvlvnI8X73e9+p9c/9thjmpExOjo6Ut4nskro0Ld8+XItd0PAhAVzDcw7wtpK1113XdKFcouLiwf9PBDAlJeXx7reDXTfsa9oWf7WW2/pvu60004a+A12X00whU59CLKuvPJK+fWvfy3//e9/tayPiIiI8h8zTURj2OGHHy4vv/yyZmTirV69WjbddNNeQQdK0tDkAMFBX5DhQYe+f/7zn7p+kmmqYOywww5azpYYwPziF7+Qgw8+OK3ngH2vr6/XsrnB7Ds63k2dOlWDRpQpxpfmDWRfkbVCtsm0IkdpIu7ziCOO0OwdGlUQERHR6MCgiWgMQ6MDNFdIzKYg64JMCVp3Y/CPr8iemLWM+uJwOLRE7aGHHtKSNZTGJQYcCDYwzwhzkhDgoETwjTfekLPPPlvnDw20ex7K57DALfYLWZ9jjz120PuOoA7NIZAN22233Qa9r0cffbRe0LGvublZv6IUEHOhZs+ePaDXgIiIiHIfy/OIxgB0kUNgga+JzBpDaJdtrkcrbcwJ+tOf/qTZGWRkEDxg3SLMHUImBfOIcJ+JgQ7K3lDu9n//93/rXTdp0iQtifvHP/4hZ5xxhs4jmjlzprYDR2anL+hch8fCPKz4gA9ZLXSzu+iii3TO0kD3HfcHyC6hE96PfvQjfT6D3Vc0oLj++uvlnHPOkZaWFikpKdF5XXg8ZJ6IiIhodCjo5hL2RDRGvf/++3LkkUdqcLTZZpuN9O4QERFRjmKmiYjGHKwl5fP55Oqrr9ayPAZMRERElArrR4hozEHzh5/+9Kfade+vf/3rSO8OERER5TiW5xEREREREaXATBMREREREVEKDJqIiIiIiIhSYNBERERERESUwpjunvfxxx/r4pVmzRYiIiIaGKx5hrXYttxySx4yIhr1xnSmCQFTNpapwn0Gg8Gs3PdYxOPJY5rreI7ymI7FczRbf0OJiHLRmM40mQxTptdo8Xq9Mm/ePJk5c6Z4PJ6M3vdYxOPJY5rreI7ymI7Fc/Tzzz/PyP0QEeWDMZ1pIiIiIiIi6g+DJiIiIiIiohQYNBEREREREaXAoImIiIiIiCgFBk1EREREREQpjOnueURERDQyIpGIrvVERDSSnbStVuuAtmXQRERERMMGazutWbNGWltbedSJaMSVlZVJXV2dLtadCoMmIiIiGjYmYKqpqdE1o/obqBARZesDHKxht3btWv3/uHHjUm7PoImIiIiGrSTPBEyVlZU86kQ0otxut35F4IT3pVSlemwEQURERMPCzGFChomIKBeY96P+5lgyaCIiIqJhxZI8Isq39yMGTURERERERClwThMRERHRIPz3v/+Vv/71r7H/WywWcTgcOpH8Zz/7mey4445Jt9OBl80mJSUlstlmm8lJJ50k1dXVva5ftWqV3H333fLRRx9JZ2en3udee+0lBx10kD5OX1577TW59dZbpaWlRTbYYAO56qqr+n0eL730klx22WWy/fbby1/+8pek23zwwQfyu9/9TjbddFO5+uqrk26zevVqve7LL7+UiooKOeaYY+QHP/hByse+9tpr5d1335X77ruv1yf9Tz31lFx//fX6/Q033CCzZs1Kus8zZsyQm266qdd1++yzjwSDQfnHP/4hs2fPHvIxTcdgj8Vnn30m//znP2Xp0qW6PZ7DwQcfHDsm/d3fJ598oq87bj958mQ5+eST9dyCX/3qV1JYWCgXX3xxRp/jWJVTQVN9fb20tbXJ9OnT9U0lFWyHyaTjx4/XHutEREREw6Grq0uWLVu23s/nz58vb775ptx2223y3e9+t8/tzGD3nXfekSeffDI25kEQccopp+jtjIULF+p9vv766xpoJCslQqBw+umni9/v1/9Ho9FBPQ+Mu/qC7mLYpqqqKun1gUBAB/JLliyJ/ey9996T22+/XXbYYYekt1mwYIHccsstGjQmPp/7778/dsweeughOf/885Puc7J5cfg5jgX2yUj3mKZjsMcCx+GII47QfTZwTrS3t8vPf/7zfu8P3yNIN683zr833nhD7r33Xtl8881lp512kt///vey99576/c0NDlTnocT5qc//ansu+++0tjYmLLzzh/+8Af9VGSPPfbQk+D5558f1n0lIiIimjp1qrzwwgvy3HPPyR133KHBB8Yp+D7Zdmbbiy66SAfqGDS/9dZbug0yIGeccYYO7rfZZhsdGD/66KNy4IEH6vUY6+D2yTQ1NWnAhODrgQceiGVqhsO///1vHdQjy4GAB1kStHK++eab+7wNMiPhcFgzPfEWL14sH3/8sWy55Zba1QxZp/iAYrCGckyH41jg8fH8dtllFw2ekdEDPO+B3N91112nAdPxxx8vTzzxhPzwhz/UQMtkBJG1cjqd62XkKI8zTehWcc4558jKlSv73RbRMz55wJsN0pTNzc1y1llnaSoSWSciIiKi4YBKlylTpuj3CJiOPPJIufDCC9fLLsVvZ7bFAH7RokVafgXPPPOMjmmQ0UG5lmmFfMkll2gwMWHCBJk5c+Z6+4CSs9/+9rf6PQbQGE8hO4HyNQQNCFCQvUDggLI9DLA32mijlOViKItbsWKFbLzxxrLtttumPAbI5MD+++8v3/nOd7Rt8yOPPCIffvihBpCJLZyRuUIwgH2YOHFir+sQ0MBPfvITDSYRPLz44os6+E9HuscUUOaGjFQyyPL8+c9/HvKxMPuDUsINN9xQA8n4n/d3f998841ej2wTrvvNb36jxwsZKARjyMZhX1999VV9LjgnKI+Dpi+++EJPvE8//XRA2yNggksvvVRPIvzyI8X69NNPa5qXiIiIaLgh0/PKK6/o9/hQNxUMYJcvX67fY+AOyLDAzjvvHBs0Az4kvueee3TOVF+Paz50RtCEgA1TGBAwHXroob0G/hhkI7OC0jiUDyZCoHTUUUfFyvyw/bPPPpvyueA2YD64NguE4gNxrH2TuGAoAjgM6LfaaqteP0cQgGwLnjsyJggCEDRh3Jdu0JTuMQUEs32VVibOs0r3WCBzhMwjAls8V8xHKy4uljPPPHNA94e1zjBVBfPOUIKHgBcQfGEeFzKcyNohaELZHoOmPA+akG5EwHTYYYfpL4v5RU0Gn06YX36kMnHS4yuCprlz50quwhsBLpQevDngDwG+DiVNTzym2cJzlMc0H85RlPXkMn8wLJHI8O+j1VogLkd6wyGUTmGAj7/xpkQODjjggKTbAf6ONTQ06G2QbTFzXXB7qK2tXe9xUg3uEXwgAECwg0n/jz/+uJSVlWmJIMZMGGhfcMEF2nDixhtvlJdffln++Mc/Ji1Lw23wHKZNmxbLpOC28XNqEvl8Pv2KMjBAiSCaK+DvNsZticx4LXEAj0E9AoEf//jH+jwwDQP7jmwLgheUqA2UmaOU7jEFlLT1Neboa52xwR4Ll8ulGUgEO3juJkAyAV5/97fffvtpKR6CLDR7iJ/eYm5rjvPnn3+e8vlSHgRNSP3iE4/vfe97mi1KBSeDedMvLy/Xr3hjALwBpQP3l+xEHor5C7+SUKRbT1gzYXGgkzJpfTh2eOP66quvMt7lZqziMeXxzHU8R7NzPPF3tK8J/en8/czUBPpQOCqfLWgUGYm4rkBky9k1YrdZ0gpG47MRGJOccMIJmuFJtV1paanO5zn11FNjJVsYQMNgxyS4nclE4G+kKQM0c6V+8YtfxLqtXX755Tq3B53WTBYjHhoJmNK07bbbTr/H80lsxhDPNOMypWU418yYJ1lgYgIZHIN4jz32mH7FB+EmwETGDOcZStJM9sU8XrJxlRkjmrFCuscUEDQOtjxvsMcCQSzGvt///vd17hVKLdHFEI0rkLXs7/7QLALj3wcffFB/tzHXH7fD+WYCLXOczXGnPA6a0DVkoMxKvXiDMW/U5s0m3QwE7nPevHmSKf6AV75Y8qG4nbOloS0kpa6odEfDOf8JXz4wn5oQj2mu4jnKY5rrMFhO90PGZPr7tH6gELBsPrNqxDJN6QRMgPInfPCLQToG6CiXSvbhHrZD5gIf/pmMALIVaD0eX/KF+SimpCze3//+dy1XQwZroMfcjJlQ7mXgMZGtwJgp2bjJ3MYEG4CsTyp4zoDSMsAcIsA4LVmAbh43/jjhtqa0EeVmuCQGVGifjTGf2R90mIuHBgiJ+z+UY5pOed5gj4UJbBH8IOuIy1133aW/pwjY+rs/BFVojnb22Wfr88cFzSVwfV1dXa9xMj+8HwVB02CYdCVS2oi68Ytv2kr290vdF5xwfU0CTEc4HJTO4BIJ+iNSXlEjkWCHRINdgm6ibpdLrFZmSgZ/TMNam11UVNRvK3riMR0JPEd5TPPlHEWpjqnQGCp0fsukdEvkRlJig4dU26HkDRc0Y0C3YKwlhLELBsyAsjQEViijwoAe2R78zcO6RPi5KVFHs4mBQHMBlMJhHSSsG4W/oXfeeafeB7IPKHdLLNnC/iHAQJBislMo9+uvYgglf5g3c/TRR+tXE1jEzyMyzHyv+MwH5vPg+e25557azCAe5qujaQPWvNptt91iZXpr1qzR/TQd+DDdA3DMTMAwlGOaTnneYI+FyQah9TkabuB54nmZ49Tf/SFgR5klrkOpHrrpAdbUMvvY0dGhXzOVYR7L8uodCp8I4GTHmz8+AZg0aVJs8mNiB5aBQjTe18mfHo94XG6xd0dkq43GydLlUWlo8Eo40i1RV61UVhRLbQW24dpSA4W0OrKB+AQms6/V2MVjyuOZ63iOZud4ImDK1Ptopkrzxhp0zkO5Gzr/Yj4KyuAwyEVAe9ppp2m7cFwwIEZQZbILuF1ii+5U0FENXeowJwhBEwbZJmOBx0n2IeThhx+uQRIWysV+IRuEYDsVNOVCC+z//e9/WvpntkcHvGTQJQ7MHJ740jwETYlB6O67766d7x5++GENmhDYbb311rFFd1FyiGoek53CorXmHB/KMU1s2jAQ/R2LxMWEsT063eH54Rgge4ZADtdjHlZ/94d5aggIcS5hEWVzDE488cTYPpn5aKk6JtLA5HzaA0ERamwRKeMXfM6cOfpznPzowIK+9GBqb3OBzWqXcKTn0wmHzaIXl8MqtZWF0toRkLkLm+TLxU3S1OaTaJRle0RERGMJsgK77rqrDpBNaZWZf4R22Mim4GcY3CMbgRIyNHsYTMCL4ARtzRGQobkDAiaUe6GxAwKqZLB8y5/+9CcNLBBoo7QL865SwQfYWCAWA3gM6jFWQ1MKZNOSwXgNAbcpmUMXZZQt4nbocpcIQZPJxtTX1+v3yNJhXU+U4eF5IVjAsUFTMQQj8TJ5TPvT37Ew89xNwIjueVh8FvP0kXlDCR3OiyuvvHJA94fngP/jdcIxQHYKa4BhbpOBY2uOOw1NQXcOTbZBW0T8kuITDpNaRdoakwL/9re/actJfI9JifG1mfgkAcHTYGurTVoabxKZ9OEn/5GG+mbZZecDtOWj6WaCT0YsFqu0dgZkbbNX2ruCYrNapLrcrZd8LE0YDvzEmcc01/Ec5TEdi+doOn9DMXhHCRKyBfHzZvINBr/4245xR6qMRKrt8JqY+WXIKiQeDwzuUVmDsqr+miBhO3zIjO0w0E6EDAYeDxU78fdl9g9ZKFxnoCwNwQh+ZtpXY/+SdaEzMC5DUIN5Wv1NmTj22GPl/fff12wR7h8BAwIC0349HoapZm4Rgof489fsJyBgMI0T+jKYYzoUfR2Lvo434FzA9qZkbyD3F38c8NxwfBLXgkKjNdymv9bxY5l/gO9LOTVKR/BjVrQ28AuE2k0zkXGnnXaS2267TetyceKh3vP000/P2GTUTLDbXBKO9mSa4mNSfLJisRRIRYlLL75AWIOn+mavrG7skrJip9SUe6S0yMGyByIiohyFQehA5lKn2g6D/1Tzofpb6ykexk2p7guD7fimE/3tH8ZUJkAa6LwtBCEDLWnD4rtvv/22Nn/A+kKYb9UXjJ36evz4/RyIwRzToejrWKQ6HxDwDPb+4o+DSTbE++STT3SOFLKHNHQ5FTShpWQirKydrNWjWdcgFznsLolEQ0mDpnhup02mjCuRibXFWqqH4Gn+shZx2q1SU+GRqjJ32h19iIiIiHIRsh+YZ4UmFQiaKDtQfojEQ2ILfBoFQdNo0ZNp6gma4ssI+5o0a7UUaIYJl05vUIOnFWs79IKMFBpHFHlyJ5NGRERENBTo9GYaMlB2/PrXv9YsXmLJHqWHQVMW2B0O6e6Oavtxk2lCwDSQTkMIjnCZHI5KQ6tXGpp90tTWLB6XTbNPlaVuDbKIiIiI8hUG86nK8mjo0u0sTckxaMoCh62nF38w6Et7UVuU5Y2vKpJx6Li3rnHEklXtsry+Q8v2ass94nLy5SMiIiIiyjaOurPA7ugJmkIhX6w8L931LHC78mKXXvzBsDS0+PRS3+SVkiKHBk9oIMH1MoiIiIiIsoNBUxbY7T3tCkNhf6/yvKFCS/JJtcUyobpImtv9Ovfpm+WtmpVC6V51mVscdtatEhERERFlEoOmLLDZ0DLcKsEggqaeQ5zJTBDalqNED5cuX0jWtvS0LF/Z0CkVxS4NoEoK2TiCiIiIiCgTGDRlic1ik2DIL9Fo5laaTqbQbZdp7lLNQDW2+jSA+mpJs7Yz17blpS6xWtm2nIiIiIgoXQyassRqsUs4HJDu7p75Tdmec2SzWqSuslAvbWgc0eKVpWt6GkdUlva0Lfe4Uq+UTURERERE62PQlCU2i0OCoYBYMjinaaBKi5x6CYYiGjyZ5hFFHrsGT2gqgRI/IiIiGrxXXnlFLrrootj/8Tfe4XDI+PHj5eijj9bFW5NtBzabTYqLi2XzzTeXk08+WWpra3tdv2LFCrnzzjvlo48+kq6uLhk3bpzstddecsghh4jF0nflyMsvvyy33nqrtLS0yAYbbCDXXnttv8/jpZdekosvvli23357/ZrMe++9J+eee65suummurZSKk888YRuc/zxx8vhhx+ecturr75a3n33XXnggQd6jZHMfcCNN96ozyXZPs+YMUP++c9/9rpuzz33lFAotN7t0j2m6Vi5cqX87W9/ky+++EIqKyvlmGOOkR/+8IdJt8XrP3/+/KTX4fXbbLPNYv/HHPlf/OIXMm/evF7XLV++XP7+97/Ll19+KSUlJbL77rvLUUcdpefZL3/5S/F4PHLZZZdl9DmOVQyassRqQ3leQJzW4Q+aDDSFmFhTrK3LTdvyhSvaxGbr0KYRKN9zsnEEERHRoPh8Ph0cJ1q0aJG8/fbbGrzsuOOOfW4Hc+fOlf/973/y1FNPid3eUwnyzjvvyKmnniperze23ZIlS/Tnr732mvzjH/9IOp4IBAJy5plnit/v1/8PNBBAAIH9a2pq6nMb3Ce2SQzuEmHwfuWVV0pDQ4N0dnam3Pabb77RgOeUU05Z7/k8+OCDsWP28MMPy+9///uk+4zAM9GqVaskGAzqxUj3mKYDxwpB0rJly/T/ixcvlg8//FDPh5122mm97deuXdvn+YHXNN7999+vAWP8dbjtgQceKB0dHbHtPvjgA33cCy+8UHbZZRc9fnvvvXcskKf0cbJLllgtDglFvv2lHUnIKlWUuGTDqRWy6YxKqSxxaee9T79pkPnLWrScL931pIiIiMaqqVOnaobnxRdflLvvvluzH1hqBFmNZNuZbS+99FINbEyQBQg0zjjjDB3cb7fddnLXXXfJk08+KQcffLBej9v+5z//Sbofzc3NOmBH8IVAA4HAcHrrrbc0s4SAaSAQMEUiETnooIN6/XzhwoXy8ccfy3e+8x3NkCCgTAweBmMoxzQd//73vzVgwuv90EMPyaGHHqrjq1tuuSXp9jfddFPsvMAF+wrTpk1bL1OGgDTRvffeqwHTFltsoc/LBJg4BxCw77PPPuJyueTmm2/O2HMcy5hpyhKr1Snd0W+DkVxZRwnzmqaMs8vEmiJpavNLfYtXvl7aIk6HVWrKPdqRDy3MiYiIKDUEKRMnTtTvJ0+eLEcccYR+wo+sS1/bmW0xkEbQtHr1av0ZAoTW1laprq7W6zDYBZT3YTvcPrFUDZDJ+PWvf63fh8NhHXgfd9xxOvDGgBr3hcAMGZoNN9xQS+dQateXTz75RMu9MFDfZJNNtHQvFWQ28HgoT8RjIsuRCvbj2WeflY033lgmTJjQ67rHHntMvyLYQCYIpXovvPCC7LvvvpKOdI8pnHDCCRrEJYMs4l/+8pf1fo5yQ9hvv/00kEF5HoInlAXitUHJXLyamprY942NjRps4zgi6DWZNIwjEQwhe4bnER+Ymv079thj9bXFBcEVAmiUaaJc9Lvf/a68+uqrsmDBApk5c2YaR5EMBk1ZnNMU0pN9aIvbZgs66qE8D5cOb1AzTyvWduilsrSndK/IzcYRREREA4FP9k35FAbL/ZWnmcBq0qRJsWAFdt5559jg3owfkMUyJXyJkImpr6+PDbBRstXe3q5ZFszZiQ9i8D32ERmOZOVi2CfMyTLZHWz//PPPp3wuyBghM3TeeedpgNBf0IRgCPOOttpqq/XuB9kSt9utc4BQDoigCVmTdIOmdI9pf6VzfZUzmu0xZyr+K54vgh3z/2Suv/56DfBOO+00zVjGlyvimKGUEUFZfNCEQBDnndXas0bn559/rgETHsc8Fo4zgqY333yTQdMQMWjKEovVLhItyNmgKV6xx6GXUDgiDWhb3uzV9uVoZ47sUwXalrNxBBERZVE0FBCJhIf/GFttYrE707op5sb84Ac/0CwCSuQwOAbMM0m2HSBjgEE3yviQyUEmAJAZSMw+GKkG9whY7rvvPs1yFRYWanaltLRUbrvtNg1gkG3405/+pPd7ww03aObmz3/+s5YJJrr99ts1YMKgHRkzQJYjVSCEx8d8G0DQ1B80SIDp06f3+vnrr7+uAcGPf/xjfR7IcGHf0Yhi6dKlMmXKFBkoM+ZK95iagMS8nokQ2CWDAAaczp7zCcEMyjDxWsfPqUqEcwcBIrJLyBrFz9G64oorZPbs2Tovy2Syku3LmjVrYhlHNIAwx8AcZwRUNDQMmrLEZnNKIGgyTZaMd2fJBrvNqk0jxlUWxhpHLF7VJsvq27Vsr7bcIy4nTxkiIsqs7khIfEs+xx/N4T+0BQXimb6FFODDzkHCoDo+G1FRUSEnnXRSbM5MX9uVlZXpNsgemPGByYSkGlwngwF6XV2dfo/7MmWAZq4UOq6ZJgCYS4VME+bdoPwuEUq4AM9h6623jpWpIYvUl8SSs/6gDA0Q2MV79NFH9esbb7wRCzAR9CB79sgjj8hvfvObXsEOApFEZkrEUI+pCRYHW55n9g1BtNlHs58ou+sLyhKRIUJmML7BBfYBQSxet1S3x+uJBhQ4x9A57//+7/9i15njnKrZBw0MR8BZYrHYxGKxS7S7WwpyPNOUCPuKtuS4+APhnrblrT6pb/JKSZFDg6eyYmdePSciIspdCFjcUzcbsUxTOgETYMI/MjoYpGOAjqCpr+3QQe2rr77S+TQo/UKwUVRUFNtm1qxZmgXC/JdEaDGN+SwItFINnuOZgXv8Y2Afkf3AQD5ZFsX8zGRKAA0ZMsk8RvwYApmW//73v/p9W1ubXuI9/vjj8qtf/UqPGbJQZrt4CDrMfZvsy1COaTrleVVVVb0yXHhegPPDXJcMuvjBj370o9jPkN1Dgw0EYsgcgSnNw7y1n/zkJxoQIwuHLCOuw9yyc845p9d9m9K9ZEEmDQ6DpiyyWe3SHYlKQUFPejYfIbM0ua5EJtQUS0u7X+c+fbO8VZtFYM2n6nI0juj5hSQiIkqXlsilWSY3UhIbPKTaDnOXcMFA/rDDDtN5RQgATjzxRN0GZWlYXwityK+55hotx8JgHnOK0G0OAQEyKRggDwQaHOC+0GFthx120AwGAjzcDzJd2JfPPvus123QyAHd65DZ2XXXXWNZnkwygWV84IGSQuwXgoazzjqr1/bIdKFpA4IqrEFkyvQwjwvznZCdwX7ec889sWNt2qMP5ZimU56H5hbI5KETHjI+Zo4bXvO+boMsGI45rt9yyy1jPzdBTmKWEhAgmeDy5z//uf4fmabEgAkwvw1SBW00MAyasshmdUgoFBWx5lemKRnMaUKJHi5dvpBmn1Y1dsmKhk6pKHZp44iSwoF9+kVERDRWIet0wQUX6LpKyHZg7g4WusXck9NPP10H9xjoIzOFLI/JqKDzWWKL7lQwiEYLbMwJwrwpDMrNABqZi2RldUceeaRmdVAit+222+oHvumUtqWy0UYbxTI5iV3zsDhtYhCKQAkBDAIkfI/jh33D80L52uWXX67bmeeGNYlMdmwox7S/damS2X///TUYxr6hvNEcO2SF+lpMGJkiBEboaGiyQqbDIoKveMi2IQA05w26HJqGImidHj9PDZ34cB+YTxd/3Cl9+Zn+yBN2mzPWCCJfM03JoEHEtPGlMmd2tUyuLZYuf0i+WtIsny9o1ExUJMIUMBERUV+wfs5uu+2mJXRnn312bFFazHFCEICMDwbSGNxjkI85Ksik9JWtSAbNAzBwnjNnjt4XggqUo6EJBIKjZNCYAnN1SkpKdJ9QzmdKwzIFAQ8+SEZ2BRAEfP311xrEoctdIgRKgEAOzQ4AwQKabeDY4HnhgjJE0/I9XiaPaX8Q8GHfMMcMAROyXgheTdCUbDFh0/kwsVmFyWLGX0wZIbJGyBYiQ2fg2OC+zcVkyVASCqbhCKWvoHsMr2pqOolsttlmGb1f/KLMmzdPHI6AtLT6xWH36Ak+mvvjY4FcBExoIGEp6MlK1ZS7dV2oTB1PfEqS6drqsYrHlMcz1/Eczf3jmc7fUAzEMVcDA9j4FtD5eDwxXyW+FGyw26HTmhk8I5iJn0cEGNyjDXdf86TiIfjCoBkf0KLjXCK0H8fjYSwSX/li9g+BQ3ybdBNk4WfmvrF/2M9UMJcHgQGaD8Q3NEiEkjJ0gnv//ff1OaLVNoIm09AinmmjDtif+CAH+4bbQnl5ea9MTTKDOaZDgX1GyRyCz/jzPNnxNj/D72V/+4X7RGMIBFg4p/qacwU437DNLrvsoq8Fso40tPclludlkdXqkO7untRsvpfn9ae0yKmXYCiipXtrW3palxd57Dr3CU0lLGxbTkREowAGuAMJPlNth4FzqvlQid3lUkHAkeq+kIWJbwjR3/5hsG0G9f3ddzwELrj052c/+5muG4T1g1BOl2zfDIyf+np87Ntg5uoM5pgOBfY5WZvzZMd7oOcSJAat/b0uyOYhk4W1n2joRk/NWA6y2hyxTxxGU3leKg67VSbWFMucWdUyY2KpFEiBLFzRJp980yDL6zskEIqM9C4SERHRCEL2A4vrmuYNlB1YwBdlmokt8Ck9zDRluXseYF7TWAmaDGSVKkvdevH6Q9LQ4tPyvdVNXVJW5NTsExpHjPYMHBEREa3vuuuui5XWUXZgvhw6NPZXtkgDw6Api6xoOT5Gg6Z4mNc0ZZxdJtYUSVObX+pbvPL10hZxOqwaPGH+k806do8PERHRWIPBvFlzibJj3LhxPLQZxKApiyxWlOdp2DSmgybDarVoa3JcOrxBzTyhZA8XZKTw8yL30BtHEBERERFlEoOmLCpY9y86huY0DVSxx6GXUDiipXtoHtHY6tN25jXlHqkodenaUEREREREI41BUxahAYTO2Rnj5Xmp2G1WGV9dJOOqCrVdOTruLV7VJsvq26Va25azxTgRERERjSwGTdkOmsSiXzkJLzUEl2hLjos/ENbMU0OrT9Y0ecVhi0qHL6LHkYiIiIhouDH9MQyZpm7OaRoUl9Mmk+tKZM7sGpk2vlQikW5Z1RSUzxc1y6qGTi3pIyIiIiIaLsw0ZVFPZqRAu+extfbgYU5TdblbCp3l4mtbJSUeh6xs6NRLeYlLO+9hXhQRERERUTYxaBqOTFN3t65aTelzOywydVyxOJwubRiBznvzFjeL22WT2nKPVKJxBNuWExHRMHjppZfkj3/8Y+z/+FvvcDhk/Pjxcswxx8juu++edDvAeKCkpEQ222wz+cUvfqG3ibd48WK544475KOPPpLOzk5tG73XXnvJ4YcfnnIs8Z///EduueUWXftogw02kBtvvLHf5/H888/LhRdeKDvssINcccUVSbf53//+J7/5zW9k88037/M+Fy5cKNdff73MmzdPiouL9fkfd9xxekz6ctlll8l7770njzzySK8PlvH/q6++Wr+/9dZbZaONNkq6z7NmzZI777yz13U/+MEPJBAIyG233SYbbrjhkI9pOpYtWyaXX365fPnll1JRUSHHHnus7LPPPkm3/fnPfy5fffVV0utwrHHMDYwlTzjhBD3G8de9/fbb+rrjcSdOnKiPt+uuu+p1J598srhcLrnmmmsy+hzHKo7ksx409VRARiLhbD7UmIH1nOoqCzXL1N7V07Z8yZp2WVbfoes91ZS7dV0oIiKibMHAvLGxcb2fr1y5Uj744AO5+eab5Xvf+16f261Zs0bmz5+v2z7zzDOx4OL111+XX/7yl+L3+2Pbrl69Wgf7b7zxht5vssZSeJyzzjpLgsGg/t/jGVgTJTwO9q+9vb3PbXCf2KavhWiXL18uhxxyiHR1dcV+9vnnn8vSpUvlkksuSXobBAoIePBcEytx/vWvf8WO2cMPPywXXHBB0n2uqqpa734bGhp0f0OhUOxn6R7TdHi9Xg2acR4Avp555pm6HtX3v//99bZvaWlJen6AeS2Nu+++W/c3/rrPPvtMA6lwOBx7vHfffVcD2D322EMvv/vd72S//fbTgJKGhnOast4IoufNIBIOZPOhxhy8yZYWOWX25HLZYla1BlHN7X6Zu7BJM1BNbT6JRtk4goiIsmfatGny5ptv6sAcg/3Zs2fr334McJNtZ7ZFJgUNohBYvPXWW7oNApff/va3Orjfaaed5MEHH5TnnntOsyGA2+H/yTQ3N+tA2m63y5NPPik33XTTsL3s9957rwZMW221le7fX/7yF/35E088oUFEMv/85z8lGo3KQQcd1OvnCxYs0EBg22231UDj6aef7hXsDNZQjmk6/v3vf2vgMn36dH0djjzySP05Ml/J4OfmvMAFARYgixafKUMWyWTf4mHfI5GI/OxnP9MM3BFHHBHL1sHee+8tbrdbM1E0dMw0ZXtO07pMUzic/i89pea0W2VSbbFMqC6Slg6/rG32ycIVbWKzdfS0La/w6DZERESZhNKu6upq/b62tlZ+8pOfaOmYyTQk284MZpENWLRokdTX1+vPECC0tbXp/dxwww3idDr15yjvQ/nb5MmTtaQvEbJVKPMDZBxQ8oXsAzIeyGSglOudd97RwAZleyeeeKJsueWWfT6n999/X6677jp9DhtvvLHsuOOOKY8BMk0IADFwR7CAy1//+lcNVPB8ErNeKI/DAH/TTTeVurq6Xtc9+uij+vXQQw/VsrPHHntMyw4POOAASUe6xxRw/L755puk1+2yyy5Js2goN4R9991Xgx68FggqP/74Y31tEksBy8vLY9+vXbtWyxGxj3//+9+lqKgoNpY8//zz9fY4h5BNM8455xz59a9/rZkyvAYojYTS0lL9itI8lF6+/PLL8vXXX+vrT+lj0DQc6zSJSCjcO81KmWexFEhlqVsvXn9I1rb0zH1a3dQlZUVOzUaVFDrYlIOIiDIOwQAG+JCsdCwe5rsgewAYuMMnn3yiXxGkmMG9gVK2vkrIkGFCcGTGHSj3QoYHWRaUzSGoMRAIIbvyj3/8I2m52JIlS3ROjClvw/avvvpqyueCYMSUhwECBARMEyZM0LlDiRDA4f4TAzfcx1NPPaVBFuZEIdBB0IQSvXSDpnSPaX+lcwjEkjHBsnneeA6A54ugKHH+WjwEqnjNTj/9dJk6dWrs5wi6EIyhxBBZyfigCVDaidcbzxFfcdszzjgjdj2OM4Im3JZB09AwaMoipJ5VQYGEw75sPhQlwLymqePsMqmmSBrbkH3yytdLW8TpsGrwhPlPmB9FRES5IRAOSiQ6/EtKWC1WcdrS68SKBgMYrGLA39HRoaVScPDBByfdzgQ5Zg7RnDlz5Lvf/a5+bwKfmpqa9R4n1eB+66231sACARKyEwjcUNqGuToImCZNmiQXXXSRZikQLKGEDNkwzLlKhGYJGOCjzPDiiy/Wn5177rlaNpeKyaCsWLEiVmIWP3CP98UXX+hXZKTi/fe//9UgZf/999eSsm222UYDL2TScPxQ4ggD6UZstkn3mJqgKj4YjJcYgBmmlNDMUUP2B4+D8aDP1/c4sKmpSQNGZIiQsTPw+v3tb3/TjN9JJ50UK+VMhDlaphQSj405czh28cfZHHdKH4OmLDKLsWJeUyj87aREGj7oqIcgCZcOb0/jiOX1HbJibad23Ksp90ihm40jiIhGUjgSlrlrvx6RRcwxwN6idiOxWQc/JMKgOj4bgXIzDG4TMyOJ25WVlen8k+OPPz42wEegAPENFQYCg2R0aTPPxZQBIqMDp512mmy//fb6PcrmEFQhI4IAJxFK1gDlfaZsDfuIwKk/uC065mHAjq9oPtBXgBBfQpZYmoeOgybANMElgsKzzz67V4AW+2A6jvmZCYjSPaaAsrfBludhThmYYAv7Y/YpVSdBPHc08/jpT3/aqyzvvPPO0yAWj2XuOxlktF544QUtrfz9738vp556qrzyyisaPJvj3FfWjAaOQdNwBE0FCJqYaRppWNMJFyyO29Dik7UtXv2KoAnBUwXallv6/wSLiIgyCwHLpjUbjFimKZ2ACZD9uOeee3SQjgF6X13rsN1dd92lXeP+/Oc/y6pVqzQzYAb1gNIpDHw//PDD9W5/5ZVXaskf5voMtDOeyXphXouBgTv2FdeZ65PdJn6A3ldWJTFgOuqoozQgQptrBBx9SZa9we1QNmgCnMQgB00lcJ/YLwQCkNjND5kcc9/muA7lmKZTnmcCVjTmMM8LcMzj57QlQpYN9txzz9jPkF1DWR6CRMyNin9cBMJoZoGsJeZ+IZO4ySabyJQpU3SunOnOiNK8THUGJHbPG7agKcg5TTnDbrPK+Ooi7bo3a1KZWK0FsnhVm3wyf60sW9Mu/gDbwxMRDTeUyHkc7mG/pFuaF9/gobKyMmUwg+2QDUBJHIInZIZQCof5QAaaB6CcC/OdsIYRggCMI1C2hW2RbXj88ccHvG8o6QI8HgIAZDzQFAKZCzQgQNleIlMCh06AJnjB96kgQEA2CgECmkykCpjAZMVMQAHoNIeA58c//nGvbnK4oJMctkXmBMx8H8wRwnwfHCM8t9tvv11/jsDKNJgYyjFFeV7ivpjLpZdemvQ2aG5hsmUIaMwcNzSFiA9eE+fCffrpp3r+bLHFFuuNIU2WEhcz1wwBI26Hr3hueO44BphPZuY84ZyMz9b1N8+O+sdM07CU51kkGBp8apiyC8FseYlLLwiUNPPU6pM1TV4pLXJo1z00kBhI/TQREdFAIFhB9zZM+MccI8xpQrtuZAmwiCwWRsUgGMEOMkNmLgwG3olzpVJB9zesAYWBNMrdEEyYOTcIbBBMJDr66KM1iEBp33bbbac/i1/zKBl0ekPmzLS6RvMG4/7779fnFc8sVmu6BoK5DRpAJGZkdtttNy2TQ4keMjG4P3SEQ4YF7c3NorzmuaEs0GSahnJM4zvbDRTmYyEwxTwsvKbm2KHsrq/FhDFvCYERyiHjXxMEhwjQ4qHsDi3ZEWzj9cExRMCJ1xnNHszzwjEzDUbQ3CM+iKb0MWc3TJmmcITd83KZy2mTyXUlMmd2jUwbXyrhSLd8s6xVPv2mQVY1dGpJHxERUSZg8I8LyuEwX8hM4kcZ1jXXXKODeVyHQTDmP6EUCwP+gZTKGTNmzNDSQax5hPGI6WiHLMlhhx2W9DZ4XFyPbBAG/MhWIOjoC+4XjSXis04mK4JLslI87A9KxrC4LCAIQFCEoG7nnXdeb3sEUoAmCCY4QwkankNJSYk+L1xwnDCX6k9/+lOv22fymPYHXfOwRhYCFhw/ZJcwxw1NOvpaTBildMmaVSCAQgAZfzHzuTBPCXOf8Bpfe+21+rrieeFnKJNE6aGBTBSYhiOUvoLukZh1mSOwYjX01aM/XXjzmzdvnr4B4PtoNCTd9rWy7Zy9xW7/tn6ZBnc88enUQGu5M6HTF9Kue1goF5CRQkMJzIvKdyN1TEcrHk8e07F4jqbzNxSDRtMJra9ypXyASfsY+GIQmyojkWo7lG+ZOSoYBCc2CsCxQtBhGgOkgmAAAQuCEVOWlfhYuD8EGcn2D4FD/HUo9cI5g8c2940xDYKNeKbFeV8QfCXLaKHRBLJZmLODD5ZRaobtTOleIlNylnic8Pi4LWBf+6sMGcwxHSqzRlX8/LBkx9v8DL8PZp2lvqAcD8EYXofExhC4j8TXF8cHgSjOPaxZRUN7X2J53rBkmqyC7wIBH4OmPFLktkvRhFKZXFcsja09az7NW9wsbpdNass92n0P3fmIxsr7WTASEn/Yr62h/eGAXgKRoISjYdmwaqa47fk7CCYaDAx6U03sH8h2GPynuo/BBJUmK9EXPFay7m197R+CLxNYpLrv+G59g4G1oND4AXN/4svp+pLq8fsLNOINZ6Ce2B2wr+M90HMJEoPWeIkBE6ABBgLO/uaZ0cAwaBqGoEl79OsnPeygl4+wnlNdZaFmmdq7etqWL1nTLsvqO6S6zC3V5W5dF4poNLxnhRAYRYISMEHRugApGAlK1LynFRSI0+YUp9UhxY4iafQ26+0YNBHRQGBODxbXve+++/psTU5Dd/fdd2t2+cADD+ThzAAGTcMSNPWkpkOhnkmKlJ/wiVZpkVMvgVBES/fQOAJBFEr2aircUl7sEgvbllOOQ4ATyxZFegKjniAJgVE0dr47rXYNjkpdxfrVZXXoV4fVHiuDQWdQBE1ERIOBuThYEJiyBw1HkF1j2/HMYNA0TJkmW4FdgsGeiZ6U/5x2q0yqLZYJ1UXS0uHXwGnhijax2zo084R1nxz29eu4iYYTAhpf2C8+BEQhBEX43i+RuEUhEQC5bE4pchRKpae8JzhaFxhZClh+SkTZgcF8Ps9rywfJ5rdR+hg0ZVH8atUOu0uCzDSNOsgqVZa69eL1h2RtS0/L8lWNXVJe7NTgCZkpouGYa9QTHPUERsgimeAIwY/bjmDIJWWuEg2KTHkdP4EkIiLqH4OmLA5k4luOO+wo6Qpk6+EoB2Be09RxdplUUySNbX4t3/t6aYu4nFYNnqrK3Do/imgowZEGRBoYrcschQKxkjqrxaIBkdvmknJ3mbg1a+TqVU5HREREg8egaRhgsIJW4z7ft335afRCRz00jTCNIxA8oWnEirWd2nEPAVShm40jqG8aHIV84lsXHOErMkfxwRECI7fNHQuO8H+HLf/b4RMREeUiBk3DQDNNNoe0hZlpGmtKCh16weK4DS09TSPwFUETgqqKEjaOGOvZIzRg8Ib84g37xBv0aSYpFAn3Co48drdUehAcucRl78kcERER0fBh0DRMHA63BPFJcTTKOQRjkN1mlfHVRTKuqlBaOwJS3+KVRSvbZNmansYRuLgc/HUczfC7r00ZECCFfOsu/lj2CIEQgqNqT4V+ddvd4mTmiIiIKCdwlDYMeuY0ufGxsoRDfnE4M7MaO+XnuVBe4tKLPxDW4Glti1dWN3ZJaRHalnukrMjJ+Sd5LhwJize8Ljhalz1CeR0ySzgHzLyjMnepBkgem0tsVr4dExER5SrOSs8S0wQiFjStC5TYQW/0ioYCEulqG/D2LqdNptSVyJzZNTJ1fImEwlH5ZlmrfPZNo6xq7NT/U34ESG2BDmkKtsqi1mXy2Zp58smaL2V+4yJZ1V6vi8IWOTwyuXS8bFQ9U7as20Q2qZkt0ysmS11RtZQ4ixgwEeWZV155RbbbbjvZddddpbm59zplRx11lF43f/78IT9OfX29rrWz9957yy677CL/93//J5deeqk0NDTEtnnwwQf18f7yl78kvY///Oc/ev1vfvObAf2/L3/96191kdT48Q08/PDDentcvvzyyz4fH8clEZ4Trvvqq6/0/y+++GLsvnD57ne/K9/73vfkJz/5iTz//POx2yVuh8tOO+0ke+21l5xzzjmyYsWK9R5r4cKFct5558mPfvQj3fbQQw+VO+64Q0KhkGTa4sWL5eSTT9bnh2P25JNPptze5/PJlVdeKXvuuafssccectFFF0lXV9eA7y/V7U866ST55S9/mfHnOBbxo81hgJa+DkfPWgTBoG84HpKGUTTok1DzGgl3NGk20TPrO1IwiPVtrJYCbQ6BS6cvpI0jVq7t1AsyUpj7hMVzaeShlA7ldV1Br3QGveINeXVB2EAgIG2hTqnr7pYKT5l4bG7x2F3a1ptd64hGn2AwKK2trXq55ppr5MILL4xd197erj+PRCJDegzcD4KFVatW9Qqi5s6dKy+99JI88sgjUlZWJn6/Xx8vfpAdD+9PuL6zs3NA/09m3rx5cu+998qvfvWr9d7TELTh9vDQQw/Jn/70p6SPj+eTqKWlRY+lCVzMcU20Zs0a+eSTT+TGG2/UQLWv7RBMLlq0SD788EN59tlnxeHo+dv53//+V04//XTdl/htP/30U3nzzTfllltuEas1M2sr4nU49thjZfXq1bHX7Oyzz5bi4mL5wQ9+sN72CEJPOeUUeeedd2I/u+eee/TYXHXVVf3eX3+3N4Ekzpndd989I89xrGKmadi655mgiQvcjhYRf5f4Vy0Q35K5EvG2i7WwrOeKhE/hBqPIbZfpE0o1+zSxpli6vCGZt7hZPl/YqMFUJMLs03AvDtvsa5Xlbavkq4aF8snqL2RewwJZ0b5aM0ilrhKZXj5ZNq6aJdMLJ8rM8ikysWScBk5o2MCAiWj0Q6bFZEoyCYN+BEybbrqpPProo/LGG2/IXXfdJdXV1bJ8+XLNtgwEBs0YUGMAnS4EFRicI8sRD9k0BHHI9BQWFsozzzyjWY+hmj59uu7zW2+9pcHhRhttpI+PwC3Zdmbb6667ToMfHB/8HxBc/fa3v9WA6fvf/76+Xjh2JvOFoAnHOlP+/e9/a4AzY8YMPR7mcW677bY+s5bY//Lycn1+d999t7jdbnnttdc0YOrv/vq7PTJrHo9HX0MaGmaahinTZLXYxG5zSCDoH46HpCxCgBRqXq1fLQ6XOGunirWkUiIdLRLpbMnIY9htFm0aUVfpkbbOoM57WrKmXVuXV5e5de6T28lf30w3asAcpM6QVzNJuKD1N6AhQ6HdI+XuOil0eHQeEhaMNbxefhhCNBYhUMDAFKVr+HS/Lyjh+8c//iFvv/22br/hhhvKiSeeKFtvvXWftzFlcG1tbTrgr6mp0QvK3ZBpwcA4meeee07+/Oc/6/U333yzZl5Q4oeStHQCJ2SgEGQgeKutre11HYI5QKnbxIkT9f/Yv8TgarAQ+FRUVOj3VVVVcsghh2g2b+XKlX1uByhPmzJlij5nZGQAgUZHR4fU1dXJ9ddfH8s+/f73v9eSvcmTJ8uWW26ZdD8QoPRVZomywcsvv3y9n7/33nv6dd9995VZs2bJz3/+cz03kNUKh8Nis/X+2/3666/rVxyzbbbZRr9/9913xel0Duj++rs97LjjjvoaIrjHuUfp4agrS8yEbxM0gd3mlGCI5Xn5+npGulo1WIr6u8Ti8ohz3AyxFpVnNZuA+y4rduolEIpotsm0Lkcrc9M4wmLhwqWDhcYMJjhCqR2aNeB1RjBU6HBrtqjI7tEgyc4W30RZlypDgcGxGez2ty3+5sYPGAez7WBtv/32GhBhYItgAZ/qJ0LQc/DBB/ca8GNAjwwHBvG77bZb0vtG6dXVV1+tWZPDDz9cB/ZHH320zlkpKipKehuUsKEUC6WBl112mcyePVtL6/orv0sFGRuUz82ZM6fXz/Gzp556SrMYeA4IqBA0IZMz1KAp8fiZTBCybKl89tlnsmzZMv0ewZM5JrDDDjv0Oofg9ttvT/k33JRaJtPX8TTllAjSAIGuOV5r166V8ePH99p+6dKl+hUBEII0nBvYV2TH8Dr3d3/93R622GILDZrwWjJoSh+DpmFgfiEddqeEwsHheEjKkO7uqGaQQi2rJRrwidVTLK4Js8VaWDrsx9hpt8qk2mKZUF0kLR1+DZwWLG/VrBRalmNOlMOemZrs0QbBEOYidQQ7pSPQJZ3BLglHe+YboJMdGjVUF1ZogISudiyrIxp+O++8c5/X4ZPya6+9Nvb/H/7whzqXJ5mtttqqVykSPqHva+C78cYbaznTUJx//vmaCUHWAfNtEt16660aMGEQf/HFF+vAH8HS008/rRP2ERwle89BEII5PAiCEDh9/PHHepkwYYLOzznggAN6bY/HOPXUUzULhWYRyIRkgmnugFK4eJgnhIAR+4GsFrJmyDZhPhEyOCgng4G8nyZug0wRSv4Q/CE4MVk3HOdk2wGet8n64xxAQAvmtTfBRqrHTYSMDoKRZBIDMMOcl+Z6BPwIznXZiSQBvNnn+PMQgdCSJUvkzjvv7Pf++rs9mNfiiy++SPl8KTUGTVlkfsljmSa7W7y+gXdXo5HTHY1IuL1RQi1rpDsU1PlKrpqpYnUn/3RvOCGrVFnq1ovXH9LgaU2TV1Y1dkl5sVODp9Ki9D85HS00SAp0SnugMxYkWQoKpMhRKDVFVZpF8jg8YrMw0CSi9G222WaaWXnsscc0c5EIpVKAgMaU46HTnZmzhE5vGJzHd0T79a9/rU0gvvOd7+h2yOhgAPzNN99ocIRACoPmgw46KHYbU8aFMQcyTJnS1NSkX0tLS5OW5r3wwgsaQIFpRoF5SNhHMOVo2N9E5meJTRgQLMUHuggU0T1uv/32S7kdGmMgG3fcccfFAiJkwuL3bTBOO+20QZfnmeDGNLfAczTPM1lW0263xwIbZBZRSmgaOyDI6e/++rv9JptsIiUlJb1eS0oPg6ZhYIImh90lre1rh+MhKU3dkbCE29ZKqKVeAydbUYXYx9eJJUfX1vK47DJtfKlMri2Wxja/lu99vbRFXE6rBk9VZW6xWcdGvxe/ZpK6NFDC11AkrEESskc1hZVS7CzS7+PnIhFR7kCjg74kDqpTNUEwf3MNZHQGum26zjzzTG2JjQxXYulcsgEzBrp4bAz6ccGAPn7wH59Fw6AZ5X1oN47J/chSofkCgpb4oAkw7wjXXXLJJSnnWA1Gsi6AjY2NsdcLmY7EeZ1PPPGEBn7Yd8z7gsRsH7IkJouTOD8LWa377rtPjxGu66uEEtuh+QHm6mDeFjJy6BrncvU03wIEkHht3n///fVujxLGyspK+elPfxrbz6GW52EOFmA/zLECPJdk5YWm7A5NKjbYYAP9HtkznON4Pv3dX3+3R9CUqfN8rONRzJL4dQxiQZPDJaFIMOmnLTSyusMhCTauEN/izyTUtFrnKrmnbibOcdNzNmCKZ7VatDX5ZjOrZMOpFeJx2rVpxCfzG2TxqjbNSI02gXBQGruaZVFzz9pIc9fOl2Vtq7R5Q5WnQmZXTpM5dZvIBlUzZHxJnQZNDJiIchcGx31dEkuhUm2bOMAezLbpwuAVmRAED5hnklgCCMgU4ZN+BCFoCoHMAZoYTJo0SdcPMl3gcMEgHmvrYPCLUjvcLzInKDnDIBgSB8K4Du2/p02bplkntJjOBAQV8YN1ExQh4EHpY/x+44IgBWV7L7/8sm6L/QEcFxwDjIFwDFC2aAJIM/BPbPCAzFGq1wjbYf9QvonOgggwECz+/e9/j22z//77a7YLgRXKIxHsYB8ef/xxvc0VV1zR5zpKuK/E52cuybJMJvNoMnBo4GHmY6EDYLLnYrKPCEIRoGEOl+nGiPlP/d1ff7cH/AxMAEbpYaZpOOc02Vzajjoc8scWu6WRX5A23LJGwm2NeKHEVlajF4stf9dFQoMIXIKhiDS0+mLNIwrddg2sKkq+/QQu39p/m0wSSu4QHOF3C+shVbjLpNhZqKV3VpbbEdEIOOaYY3SdIny6n/hzZLvQkACDewQJmH9jMlQY+CPLkZjpwFwhZAuwACsG97gewZPJ/CCwijdu3Di9byxS+4tf/EKDgUzMa8LgHEw3OkApoplbFt+9DtAUAiVtKNFDu3N0p0PnPjS+QAYMi7DGl5vhecZnhtKFEj50DURJ3Q033KAL4yKgQFB61lln6WPjOGLuT/xrgCAUWbxkTFnbYCBIw1y0jz76SOdWmWyaeb3QMCS+myECT3Q5xDHD+YG/azg2aN6AzCHmYqW6v/5uD5jfZJ4rpY+ZpmHINpmyAhMoca2mkRcN+iWwZpH4lnwu4Y5msVeOE/e0zcVRNTGvA6Z4aAqBphFzZlfLrEllYrUWyKKVbZp9WrG2U4Lh3M54Yg4S1kha0rJC5tZ/JZ/VfyWLW5ZrW/Byd6nMrJgiW9RtLBtVz5KJpeN0zSQGTEQ0UpANM/N4EkvI7r//fu1ohuwQButoCoGgJrGxQWLwgYwUuuZhkI+5KsiQIIjBYHvvvfdOejsEMhhcY6CMEreh2nbbbXW/MWgHBH9o9IB9wiA9kVlAFe3VTcdANPE44ogjNHOEAT0uyBCdcMIJcsEFFwx5H+MfG4EajtO5554bm8eEwBXZJxM04DXA46PbHLJfmco4ArJmCGKQYUOAgzlVmM9mXuvExYRRzonAGO3CsT2ONZ4HyjDxfX/319/t45t5IJCk9BV0x9eRjTGff/65fjWpz0zBJ0HmvnF48SkLUqT+QJd8+Nl/ZMPp20pl5aSMPuZohuOJlqn4Q2EmdKYLr0e4tV5CTStFsHZWRZ3YSqqkIAPZiXB7kwZinplbZeT+ssEXCOuaTyvrW2XJkmWy6UYzZPK4CiktcuRExzi0AW/zt0ubv0OzSni90N2uxFmk5XXFjkKxWW2j+hzNxwwgAlqUQ5a4ijN2v2P5mGZDNo5nOn9DMVdn8eLFOgDMRHZhpGDQjUEvAqXEOUyYe4L3LjROSJyLhUEtBs3J5s/0B4+HksLE+8T9ITjAwN/cL44zXnPsHy7x+5q476mei3HSSSdpu2o0tUCpGx4P+5HYHMJAeR7g/hJLK838p2TnodkXPEaqLE+q7cx1UFxcHGuUEH89gqrhOP+SvWapjjdeN+xv4muc6v76uz3ORXSmREYQDUUo/fel3Bt9jMJ1mr5tOd4z0TEU4gK3I5VdCtYvkYivQ+xltWKvmpCzwU22YEHcKXUlUllkFV/bas02zV/Wou3MqyvcUl3m0Rbmw/l7gnWSWgPt0upr16AJzRsQIE0qHS9lzmJxjJLMHxGNHhjwJpalGeXl5X3eDoP8xMVNB6qvgAbBUmKmBAO/+MFf/L4m7nuq52IgU4MOeZgnhfKz/jIzqe4vVdA+kH3pb7v+7qOvVuHZkOw1S7V//QVyfZ0DqW7/wQcfSENDg5Zt0tAwaBoGJuJHmtRuc0ggyKBpOMWyS40rpcDuENfEDXW9pbEMbcvLCm2y0dRyiYpN25avXNupF8x5wtynIk92/rBEohGdk9S6LqMUjobFZrFJmatYJpTUaVaJZXZERLkDZV1Ygwqd6hA0Uf7AHC6UJfJ1GzoGTcMgvsON3e6UYKjv1ckps6JB37rsUqfYy2vFXjn2skv9QXCEy+RwVBrXNY5oamsWj8smNRUeXQ/KaikYcqc7lN0hUMKaSdHubnHbXbqgbKmrWArtnpwoDyQiouSuu+66PttsU+7CmmDIDLLt+NAxaBrGxW1NB70gy/OGJ7vUskZCTat6skuTNhSre2xnl/qDsrxxVYVSV+mRts6gzn1asqpdltd36HpPWPcJ5X0DLrsLeTWThEAJC82ahWUnlvQ0bXCy7I6IKG8MtHSOcguab1BmMGgahjlN8RPy7HaXdPmSL5RGmREN+CRQv1ii/i6xl9eJvXI8s0uDgPO2rNipF38wrO3Kcalv8morc2Sfyoud62WGUHaHduAIklrjyu6QSRpfXMuyOyIiIspbDJqGQa9Mk90lre09awNQNrJLq3Vx2p7s0kZidaeeNEmpuRw2mVRbrK3LWzr8OvdpwfJWzUr1lO45xR/1SbO3VYOlaHdUy+6qCsulzFkihQ6W3REREVH+Y9A03EGTwyWhSE+7S9aXZk404O3JLgV8PdmlinHMLmW4cQTmNuHi9Ydkydom+WzFImlf1C4el1Vqy0pkckWNlLlLtUU4ERER0WiSM0FTW1ubLvaF9YwSe+ong0XesD1WwE63fedwlejFB0dOtB3v7tZmEC7n4NdpoMRjHJVQ8xoJN6+WAoezJ7vk4nHNBjRzwGKzTd5m8VuDUldrlbrQOAn7HdLdaZe1oQKR8rBUldnFZuW62UM5p6O+Lon42vX/jsoJGXwViYiIKB0jHm1EIhH505/+JI888ohmXzBh7cILL5Q999wz6fboNY8Vt7HIGmCRr1/84hdy/PHHS66v0wROR89aTeGgT4RBU2azS5i7VMDBeiaFoxFp0UCpVbveWQosUu4ulcmlE3QtJXNut3UGtHHEsvoOWbG2UypLe9qWe1z9fwAy1nVHIzr/DuuHRfWCRX2jeOPQD1gYNBEREY28EQ+a0PP/oYce0sEXurJgFemzzjpLVxhH1inRxRdfrAET2idWV1fLihUr5IorrtAe9FhHIBfFZ5ps64KmQNAnnG0ztOxSqHmVWBwucU/aSCzMLmUM5iWh612Tt0XaAx2CHpBYO2l6+WQpc5UkLSstLXLqJRiKSMO6tuVoHlHksWvwVF7s0hI/iguSvO0S9XXq9zinC6w2sbiLxV49UTs9RvydEqxfykNGRESUA0Y8aELABJdeeqkuvIWM0ZtvvilPP/20nHTSSett/8knn+jXxx57TGbOnCmXX3653HbbbfLxxx/nbNAUn2lyoDyvoEACXKspLRhgBuqX6PpLmLekc5eYXRoybREe9EqTr0VafG2aYfLY3brYbIW7TOzWgWWMHHarNo0YV1korcg+NXtl4Yo2sVk7pLrcrRc0lxhzQZKvc10mqXeQZI0Lkgoc7l7vFdiOiHLTU089JX/84x9jrbjfeOMN/Zp4HWB8MpKCwaBst912vX6GaRClpaWy++67y69//evYvh900EGyePHiXtt6PB6pq6uT/fbbT372s5/1ui4cDsu//vUvfc5Lly7V+9100011LPed73yn3787Rx99tJSXl+saUPGuv/56uf322/U9EePBCRN6lyk//PDD+iH6lltuqdvFVy9tvfXWsXHitGnTYtfNmzdP/vnPf+rr4fV6dXrH3nvvLcccc0zs+WcK9gPPCfvu9/tlhx12kPPOO6/Plu0XXHCBbpsMbnfIIYfo919//bVcddVV8vnnn+txO+qoo+SnP/1pbNsnnnhC/vznP693H3h9Jk2aJNny1VdfySWXXKJfkdDA63/AAQekvM1//vMfueGGG6S+vl7H86gi23zzzXvdJ57r3LlzpbKyUl+rE088sdeUnGeeeUbuvPNOWbVqlSZacDzMIr647fPPP6/HBOdwJozo6AUn7cKFC/X7XXbZRX858BVBEw5SMrNnz9aD8/rrr+vtv/jii9jPc40p0YsfCOFTervVIcGgf0T3Le+gM17zKvH5WsXicDO7lCH+cEBa2tt1rhLmLDmsdqkurJRKd5m47K607xdZpYoSl158gbCW7uGyurFLW5ljzafSIseoXNC2d5DUIREEP3gviAVJk9YFSa5R+fyJxgIECxiDAL5iIG4CE1TDmOtyZSySbH8wlxwBR0tLi35wDdgucVv8v7GxUcdlCIoOP/xw/XkoFJKTTz5Zx2zxXnnlFfnvf/8r11xzTZ9TLeDJJ5+U9957T26++eZeP8dUjUcffTS2H/j+9NNPT3r8fT5fn88V9xM/QP/tb3+r+2xgXjwCqbfffls/fI9fHmaoEPTddNNNsf8jIFqzZo1WV/UV2PZ1zuC5AoJZHHuzwDAqszC9BcEvAgrAa5TsfuKPRSoIYH70ox/p/f31r38d0G3a2trkuOOOk6ampthxRQCE6Tbf//73k97mgw8+kDPOOCO2nin+f+yxx8pzzz0nNTU1eh8I0PHVPNdrr71Wv/7+97+PJV3+8Ic/xO4Tj3/22Wfrcz3wwAP1csstt8iNN94ov/nNbyTvgyb8EpoDhog5fhEuzF3qa2Vj/JJedtllsZ+dcMIJ+mlJJt9MhgK/xOZ54cXDpwy9Spq6C6SzszWn3lRzmbetWWzNy8Rr6RBP7WSRslrxRwvwTi65JOL3SSgQEPH6pCBJCVuuCIeDsnLNQlnuXS3tq/zidrm1PXhtYaUU2ntahEdDUfGGMnd8q0tsUllUJM3tflnb0iX1je3isFs081RV4hKbLXePV3+QNfK2NIqls1E6Fn0mfon0BEk2u1hcRVJQVC0Wd5FmkiI4TzDYiHTjjSLl/UZ8PedTQY6d54mCkZAEAgHx+nxii2Zu0GEGQ4mDIsqd4xk/d3eswifY+Fv+v//9LxY0vfvuu7Gf5xoEKhMnTtSB96233ir33HOP/gwD0aKibycNoIoH4yq8xtgWg/NXX31VMzwmaEKggYCpsLBQsyE777yzrFy5Uu8LH4hj0L3bbrslbdaF+8WAFhkEfFgeD0Hn6tWr9fERfCFowtz1dDsOYzD9u9/9TgMmBHG4LwQayFAgaHznnXd0sP7jH/9YMgEBEI6rOY7IoiAD8v7772uGCNNPEmEuf3wAgGASY11kbUzg8fe//11fC/wfmUxkWRBIvPzyy7GgCZkok2WbOnVq7P4GmmkxY2K8pw/U448/rscY02QQKN999936/HF8+wqacNzxWMigoaoMwc5HH32k/Q1OPfVU/X1CsLjrrrtq5gz/xzbImJmgCecfYPsjjjhCM3vIeuIcRcA0ffp0mTNnjtx33336GPHnd14GTSbiR3SfuBAsTrpk8EuLlB1SqTiZ8AuKFwxpQJyY6ewDPmnI5vPD/sb/YWlsaEbcLAEfu7z1pyDkF2vrShGrTVaGnCJrWnsuOajA3yG29jUSCjhFcrBkMBTySXvnKunwNSEdIq7icWJpi4qtMypdBW3SJW3Dsh/4TSgIRqWhKSyLFiOEECl2W6WsyCZuR+4dt6QiIbEEuqQg6JWCkFcKurvFYrHK6rVh6Xa4JYoyXAwUvMgo49I46Ico8LWJrWOthII98yBzVSgalhW+lRJtDIjHmvl9XbJkScbvcyzL9PHMdFlTvsGgDJkKDOp+9atf6fHFgH+nnXZaLwMDd911lw7sMMjEmAW32XbbbWPXYwCMYAalboDysl/+8pey/fbb6//PP/98efbZZ3WAjYACA3GMhQ477DAdOPYHzbMweMQFHzhjcIsPd5FhiB9UYt44giHAz/fdd18df8V/oP3ggw/qVwQhBx98sH5fW1urH2pj/1Ci1Veg8+mnn2pghdslboMgCVA2hzI3PC7KH7/3ve9JOjDQRiCAYBElW6ZDM7Ih33zzjb4O22yzTdLbXn311RoEJINAxDQli4cxH4IblOKZUjGcDygV+/DDD5MGTfg9Mr9L+KAdpW6AOfsoIwRzPp122mlaiobXD5f48SWCJvwfAeuiRYv0/MQ5Y17LbPjwww/1K86RyZMna4CI8wrZ176W1zG3QWkhygZRFoqgyfwc2S5czO1NbIAg23z4gzE2XkscA7wWeHz8brW393SeBQTtmNaDoNiUOOZt0IRfXsAvBSJKfBphottkLzAOElLIOIBIdSKKxpsLTqq//e1vWhs5WDjg6QRbqWA/8UuD+8a+brzxxr2ud7m90uVvl4023CijjzvaYE5HaPUCCRZNkRU+i0ydPj12zuSiSGezhOpt4py2UU5lmto71kr92kXSEWwQd7FNJk+aI4XtndIQcsiUmRuP6DENh6PS2ObX5hHBUFS6XTapKesp68ulxhHd0ah0+zt7mjd426Q7FBbxuMTiqhSLp1SCBXZZuqpe35MydTwj7Y0SanCIa8ZGOZ9pijRYZEb5FG0Yksn3UQxAM3lMx7JsHM8FCxbIWIdBHAIbZBBMxgkwCE8MmvDpenyVDEqSUNZ0//3361yOL7/8UgOQ+FIqBFf4JB3ZEAQymtX1ejUoMWVbKFlCpgJziDbccMMB7Tc+mMYn8IBxSlVVVcpzB4EamDlCCJ4QHEJiMIOgAPNIUsEUC8CgPrHUC4Ej5jBhbhKem8lwpRs0ffbZZ/p1xx13XG9JG4whU0lVNtcXc1wQQBooOQNML+kPXhcEzQi4zFx9sywPIFBDuRmCrJ/85CcapJj7xnZggg8cOwRPyEr19QHHD37wAy3RBFMlhSADr4OB8shjjz026e3NczLP1zxXBH94/RLPLRxP81wSb5N4fHBuYi4dgkEEoRdddJH+HO9hKAOND8rMORU/f2+LLbbQr/hdzPugCQcJgRJ+8XGSIdpE5gjwiUAiHEwcbNzOpB3NhD/zqcxgISLP1ASxZPeNFzPx/ouKyqQr0Jq1xx0NIr5OCTQvF3dJuTjKJ4h8PV9/SXL5mIXDPrE4neLxuEd8Yd1INCxNjctl1doF0uVrF7ejUGZP21Jqq6cJ3l5avnxXGkKRnDimJSVFMm1it7R1BnXe05qWgDS0Y70nt9SWe8TlHJm3qWjQLxFvm0S62nRukkSjYrc7xFpeLdbCUrF6SmKvs/5RXVWf0eMZDrnXnU+5e86DLRzUwZwHz92V+X3NhXN0NMnk8RzrpXkGMkWYb4IgyARN8dkjwDjnH//4h44JMMcCgzlkis4991yd+4IPfWfNmqX3Yaxdu1YHxRhgYmyEciMDg03Mm0EQgMALQQwGyv0FTRiIY2CM4MsMkFHahXK1eCiFQkkbBqVmWzwWSsbADHoBma7BMhU+8Y0aAB+II1BBqRzOL5RnYdoGBv+Y0mEG4AM598w2Zl/T2U80yUAgm+r+E5kS2PggxZQoIpBIBecJsjQ4TxAsG/GBG0rgDAQRpqEGzgGMj3FBggG3weuF8TGCJmRzkunq6lovMMR+mKAc4ueCJTLPyTzf+HLMZM83/meJt0lWFmjiApyLSEjENxgxAROeHwLgkpISzTwZ5vzCBxKZMKJBEw4SPmXAmwR++VGDaD6dMJEiDhZeUKQncSLglxZvJHjzQbrTZJfi30xytQmE4XS4JBQO9pm2HOswgT6w8huxOD3inDBLfP6B19aOdaFQQNbUL5DVDYslFA5IaVGVbDRjeykrGxc717ojfb/5jRT8nqBBBC7+YFjbleNS3+SVkiKHBk+4LpuDNDRwiHg7NJOkGaWgXzszYj6SvXKCWD2lYnEy40GUDfikGx+MDnTCeibhvRHlTmZu9WAhq4SyIGSDMBcFQSnmd8TD8ihmAj8G4vFMVgDjGwQMKPdDSREuHR0dSacsYLxkHgPjJQwaBzIPJX5OG54vpjZgQn6ixPtCNgIDcPPJfXzgjX3EYHUwTNOAxNthLg7ccccdsXlBGGTjvMB16J4WP8g2gZ8Rf/6Yki6zr+ZYDgbGmoMtzzOBQLKgAx8wpYJAGkkEzPOKn5MUfzuUYSKgQvYPZXiYO4SgCa8Nyhjj5xrus88+ehzNXKdkEJCa44jxtWkEYbI68c8pGXOdeY7xAVay5xt/X+YYmdskexwE0jhfEAwho4rujOY8BGQh0X0Qj4VYAp0eDXN+mfNtqEZ8xH7KKafoGxYmIqJ+FUHSjBkzYpPacCBQp4i0W3FxcSw9iAlfhx56qLz22mv6RoP7yUXJBnn2dV3Jgmw73m/ANNIZm3zh9bbJwkXvywefPSfL18yXspIa2WKjXWXTjb4nFRUT8io4R0vySbXFMmd2tUyfUCqRSLd8s7xVPpnfICsbOnUtqExB6/pQyxrxr5wvvoWfSGDVN5pZQhbJOX6WuGfMEdfEDXTxZAZM30LgHe5skWDDcvGv+FoCaxZJNMSOoJQ+zKnB4BjBwXBf8Lh4/HSZrBIG9RicbbXVVut1Yov/dN10qDOf7iMTgsE+5vjstddeOr7B3BA0VzBtohPHEvGZIZfLlTSASAZjLcw1QedhZMWQ6TK3j4cGBhiAm6VfsH38PuCDbLMPCBTjYdCPzmfJ5nQlBjfx+4wsgumIbMricDHbmrlOYOZfJQ6GTXkamDJUk31L3E9Agwtk/voKqOL3I9klGVNqFr9vyJJB/IA+GYxpIbHrILJt5vkg0EXGDcETXhMcb0xzQdIB4+X4TJSRagyA4A9TYnAxj4Hz1/wMl8Syxngmg4dSvPjnjQAoWYt1vHYmkDXbJh4fzJfDc0HpKj7QQMmn+T3D3CcD26FUFfuNdvJm7l/i887UGGjEF0xBtggdMBAp46Bh/g9qJ020ibpWpKwRMAHqOLENfvFxsBGJ//znPx9wHW8ucK5b4DYY9InLyWYQ6wVMLo8OWBkw9a+lZbWsqv9GWjsaxG5zyPjqGTKudoY4nPlfzoQ5TSjRw6XLF4q1LEfgVFHskpoKj5QUOgbd6S7S1S6RrlaJIpsUCvRkkzzFYq+aoGV3aGlPvSHrFsWcLqwzhVbq65ZMKLA5RGx2kWhEukPJm/cQDQTKzUYy0xQ//2SwcFsEOcuWLdP/J66JBAh+MK5BkIC5TYmZKOwDfo7g7Yc//KGWUqEKx8zxSAya0h0EDrQ8E5/aY/B/5plnalYHGRdkeTD2wvPF4yPbhbEb5pVjbhfWIsL+IxBDgIImC5h3kiwoM2V28YGFCYrQQCK+NM0EEZiTh86EOL6m7ArHHJkUlDEicDDtyzHQN4+BkkSUQKIkEB2YUW6H65GhwKAbrwkG/qaZxVDL8zAeRZCBFuPIRCERYMo2E+dwJTKZq8RzCMcbwTiuR/OzjTbaSDOS2HcEFQhykFWZP3++HlM8F+wfWq0D1rPKls0331yDPWS+ENDhHAEEOn21cUe2COcInguOr9lPc3xw/PBc8Noi84WKM5ORNUEpHhOd9XB+ImBKti6YKc1MNWcvr4ImwC8aLskgFZcIn8Tgkg+S/VI5HD1vWMGAV6QnFhzzegKm+WJxFTJgGsB8pcaGpbJq7ULx+jvE4yqWmZPnSFX1FLFacuJXOuMK3XaZ5i7VDFRjq08DqK+WNIvbadPgqarUJVarJUXZXbtEOlsk0tmq/7c4XGItLBMHgiS0A2dG89vj1R2VqN/bK0jqjvSUUCADjCycvWK8HjeL3Sl+f4dIfXY6kNLYgVKxdMvjcgFK9EzQlKwTGwbpqI7BOj2YuI+gxAwozZo4pjMYtsEn7AggEeAg2zGSrfcxqEXWCB3vMNcJgRLGNviAG8EAMkQoncLzQeACuB7bJguYAIN+lIWZDB/Ks8zirmg1ntgMDOWBpp00AooNNthAvyKIQhkZus3heJnMFYIoE1gioEWnPBxjHFtccJ0J0BFQmC53qbraDRQyKbg/tM/GfDMcC+wXAmUEPoDngnlH8esh4XVGkIzgJ9lCtAhaUQKKcwO3N8capXmARhl4DGTrEHibY4GfpVqWZ6iNIA488ECdT4QgH4GLuY8jjzyyV9CL0j8cEwSRyJIhaELSxLQfx7liAlfMaUNLejSxQAMP81ohWMZzwXNHfGB+jkDbQBD573//u1e30MQPKdKVPzU7ecacNMmCJhvK8woKJBhmOQtgHklPwFTEgKmfluFLl30uH376nCxY9ok47C7ZeOYOsuVme0ht7YxRGzDFs1ktUldZKJvPrJYNppSLy2mVpWva5eP5DbJ4VZt4/T110QiMwh0tEli9SHyLPpXAqgUSDXjFVl4r7imbinvqZuKomayZpbEeMCEgQklisHGF+Fd8Jb4FH4t/+TwJNa3UDJKttFpcE2aLZ8aW4p6yiThqpoitpFIDJiLqYUqHEOTgU/RkMHDHwBOlVpgzhE/TMbg2685g4IfGB/g57gdzjUxnNJTUjRQEGBdffLHuF4IkM8cHgQ06vSEwwKf/GMhiv9GgC5kdZB36Yj4oN9kDZKQwcEc5V/x8FcMM+l944YVYCR7mtGNgjiyRCSDQRAzZMSxkGw+BBfYJAZKZD4VKJgR7GLinKj9LB0rG0K0NgQDGgSgbwzpLZkyIIDFxPSQEkCbrlQzuA3N2pkyZos8XpWx4niZoQtCK54hjhYwintMee+yhwUeqzKRpBBG/WLBZPNhcUjWCmDBhgj4GqsKw/zi/ETCbaTaA+8X9mNcJ2SNMv0EGCLfBc0I20zSBw4cKyBqajBsCSZTr4XzDdQjgMU8QEDjF72v8BwymAURfiZnBKugeSBHsKIUWoZCsZ/5Q4EXDGwFOYLy4yVKG7338jNRUTpapkzcXGesB0yoTMM1MOoDF8URaHZ9M5XIXrXB7k87t8MzcKqMD8a7OFllZ/400tqzUN9zqsgkyftws8Xh6FoJOZz4Kuuct6YjIhnO2yeljOhCY44TMU0NTpw7+C6VLyu1BKXLZxOryiK24XKxF5Vktu8vGORpua5BA/RIpnJ18/ZB0oSQx6kMWqUOzSdFAzx8YLMZrdRX1ZJDcxTqHC6WL/UGm6cPPX5CNZ2wv5RUTMraf+fJ7ny+ycTzT+RuKuT3oNIdPjPvKQuQDDCpN4INMBAZuGKxhcGrmhWAw2tcSKsgq9JXBwMAS94P3+8THwe0wgMX3ZqCf7GeJzL7gtU/VUAfPAc8Fr02yeVnYN/w82Wtn1s0ZCAw9kX3AY7300kux59DXfZtFVwHHNzEIwHHC8+qrHCzxvvC4A9l2qPBYOGaJC/ziueI5m9cVzDnU1zGIZ5bp6YvJwAykjBPHtb9QINW5NZBzwJxXyV67/s6bZM/V/F4kE/87iA8ikAFDpjTV4rYDfV8a/R9Nj4D4k6+vNyeH3SnBMT5xeiAB01jm83XIsuVzpbFtldhtTplUN1vqaqeLHQunUixLYvG1SVW4RcqsrdJlD0prwCIr/IVisZVLtatMaoo9YreP3XMrik6d3g4NktBC3cw9QokigiNtcoFgyZG/A1ii4YZBXPxADgO1xOAo1YKiqUq+4gfziY+TrFxsICVkA13cNNUaXv0N5AeTrcHYCM0iUGI1d+5czc6leg7YPtVzSBVAJLuv4QiYzGMl2zccq8TjlewcSvf5DmbOWyY/lLL3cQ6kOq/6O2+SPdfE34tk0JgC5ZtYQDdVwDQYDJpGLGhya7nVWIU5JuhUhkGbc9wMBkwJbcNXrPxCVjcuFZvVLjMmbS7VNdPGRPndwMvJWrX8Ds0cMAfH6i4SZ/VE8RSVS63dKb5AWNY2e6W+2Surm7qkrMgptesaR4z2tWX0+CCLhEDJ2xZr2oD5SDZk3NzFerwKrJktRyEiGozDDjtMHnjgAZ3sH7/oL1Em4NxCQHjaaadJpnAUNkJBEzqddXq/XRxuLGHA1MdxiYZlzepvZHn9NxoITKiZKRMnbChWDm61pBBNHNDmGuePdHeLFVmS6ok9pXfo4hYHDSKmjCuRiTVF0tTml/oWr3y9tEWcDqvUlHu0I5/dNjqmdGL+lim30yDJ7+2dScIaU+5iLb8jIsoVyBSgTbuZ50KUSSjNw6W/tbEGg0HTSGaawumvC5GvMOcEk/LR4pkZpm81NCyRpSu/lEDYLzXlE2XKxE1HRdvwoWZMwp3NEulo0YAAMPh3VE/WjMlAggB01EN3PVw6vEHNPK1Y26GXylK3/rzIbc/D7nZd6xbibdfv8TOdk+QuEXtZbc+cJDZqIKIcN9jOdEQDlclgyWDQlAUD6a3hdLgkFA5qdmGslF31Cpgwh2kAk8xHu7a2elmy/HPp9LVJWXG1bDx5h7QbPIwGOkHX1yHh9kYNlrqlu2eh2ZopYi0qG1JJWbHHoZdQOCoNrV4t30P7crQzR/apAm3LLQU5eUy6A951maT2nhbg0agUWG09maTqSWL1FHN9KSIioiwaG6P1EQya+pqMZ9ZqCgX92rFqtGPA1JvX2ypLls+VlvZ68biLZZNZO0pZWeqVwkczdHRD98FIe6N+j9Iye+V4saK1dULp3VChLG98VZGMqyyU1s6ABk9oV76svl3L9mrLPeJy5s5bo2/RJ5p1K7BYeoKkivEaSBY4U3fBIiIioszJnZHBWCvPW9f+GB30XKM8aPo2YCoR5/gZYzrDhOYf6Ii3pnm5OGxOmTVlK6mqmpL26u75DCVlyCaFO5r0HEFQYC2uFEdJpZbhZRt+N8uLXXrxB8PS0OLTS32TV0qKHBo8lRU7RywwwULPWEdKv3pK9OtY+d1BI4/mdr9EomN2RQwiIsoxDJpGKtOEBW4RNAW8ItkfH44YBkzrjkMkJKtWfSUr1y7ShY2njNtQxo2bPWZKM+NhDg7K78IdzZpBQYDkrJumDR1Gqu28y2GTSbXFMqG6SAfrmPv0zfJWzUqh6151ORpHDO++odsdFpUd7aLRbl2UuMOLS1A6vSEJR6K6BkfQxwniRESUG8beiC1HgiYbgqaCAgmO4rbjDJh6FphraFgsS1fNk3AkJHWVk2XSxI3H3FpL6H6H8jtcogGvFNgcYiutFltJVU6tD2SxFGiJHi5dvpAumruqsUtWNHRKRbFLG0egbTmlLxKJSqfv2wAJ3yNwwrFHU46aCrfOPfvsmzU8zERElDMYNI1QeR6CKZRnBYOjM2gKd7ZKcPVCsRSWinPc9DFTVhSvpXmlLFn5hXj96NRWJ5MnbioeT6mMqaYO3nYJtzVoAA0oN3NUTdRSzVyfj4MGEdPcpZqBQsMIZJ++WtKs7cwRPFWhcYR17J3XgxUKR3plkbr8IZFuEZvVIkUeu2b3ij128bjsGjgRERHlIgZNWcouGKnmqmCtpmA4KKPNWA+YOjtbZNmqL6S1o1GKPeWy6eydpbS0RsYKLKaq5XftTdIdDmqZmb1qgthKKvNyQVUM7usqC/XShsYRLV5ZuqZdltd3aEaqpnxsZQ374w+ENUjq9AWlvSsogWBPiZ3TbtUgqbrMLcWFDnE5rDkfOBMRERkMmrLVInhdtilV0KRrNY2y8ryxHDCFo2FZ5m2S5q+XicvhkdlTt5bq6ikydpo6NEu4rVFbY6Mdtq24oqf8zlUoo0VpkVMvwVBEg6e1LT7tvmezRKXLPzbn3/j8ES2xW7qmQ5Y0rNWW7uB22fRYIYuEcjuHfWTmq2VTIBSRTm9Qs2TIQNLQYJHT+A8dhwv+TlutI3t+tra2yv/+9z+ZPn26zJ49PHMZX3vtNfH5fLLTTjtJUVF6DalCoZC8/PLLegz32GOPjO8jUS7hu/wIleeB0+6U9q4WGS26wyEJ1i8ekwFTm79dFrWvlKBEZOqETaSubuaYaPKgC9C2rZVQ61p9/XVNpbrpPWsqjVBTh+GAAGBiTbG2Lm/p8MuiFU1S3xqSsQCdBpFBMhefr0PaO4NSUR6Vukq3ZpMQJCFDNxrnYmGuW+e6S3hdgFhR4pKZk8bu+mqZCphWrFihg/DhZrfbZeLEiUMKnBDsvfDCC1JVVSVbb731oG//97//Xe655x454YQT5Le//a0MVXNzswZCqRaP/cMf/iD19fXy7LPPph00Iej61a9+pcfuyy+/HMIeE+W+0T+qy9FGEKaDHlqOjxbBxhX61Vk7ZcwETNHuqKxoWy1ru5qkxFMmm07YTOx5WIKW1rpKLfUSbm/Q+SlYT8leXjvmFljFHJzKUrc0tYze5hDIHLV3BXqCpM6gZlfMnC+U2jmrbBINFsrMCaVSXlE8at7D0fY8FiR5Q/p/MA0r8NwRIK5u7NJFmGloEHQgYMLfTJtt+IYm4XBYHxePP5SgCfeB4AFZm9tuu21Qt7333ns1YMqUyy67TB544AF58cUXpbq6OmP3SzTWMWgawaDJ7nBrR7VINJz3WQmUZGEeiwMB0xgIGsAb8sniluUSCAdkcul4qS6sHPVzNCK+Tgm3rJFwV6tmkmzldWIvrZEC29h4zccCZFTavXGZJH9PsOByWnXdKnQPxJwkk0ny+zsk3/s3oNwylkFa16wCHf2kQLTsDsFRbaVHgyX8P/73HOWZlDkImIYzaIJgMDhiJXnnnXeelrcNRmdnp3z11VfS0dEhNTU1svHGG8fOyVdffVUDMARx//3vf2XLLbeUmTNn6nVtbW3yySefSElJicyZMyft/V6zZo3MmzdPxo8fL+PGjevzmH788cfi9/tl0003lcrKylgG7L333hOXyyXf//73Y9svX75cvvjiC30+W221Vdr7RpRN+T1Sz/tMU8+n8qGgT6yu4rx+vsG1y3Tuiq1k9H+qhee7tqtRVravEZfNKRtVzxL3unW3RuvzjXS1amYJwTFahDtqJoutuHJUl+CNFQgOECyYbBK+R+LEYbdISaFTxlUWaqA0WuYkRdatC9XT7jyowVIw1FNmh3W5ECCNry6UIrdDCl22vO+QiGy4L+SXJm+zdIS7Rnp3RpU333xTAxiTsYKmpib5z3/+E9tm2rRpssEGGyS9/erVqzVg2mabbWTSpEny2GOP9fuYyB797ne/04DJwByoW2+9VWpra+X3v/99rMQR3//iF7+QX/7yl/o4KPvzenuCfDwm1kIbrDvuuEOuvPLK2PNNNo9p7ty5ctppp2lwZcof8djHHHOMBkvnn3++HjeUM06Z0jPv95prrpFnnnlGnxuDJspVDJpGMmhaV8oUCPjElcdBE+a0YO0d1+RvP+0arYKRkCxpWS7tgU6pLaqSCSV1YhmlpYjd0UjP2kqt9doRTxehHT9TrIVlo/51Hu3vT15/WNpMkOTtyaogc1RcaJepdSUaJLlGSWOD+JbnHV1B8aLMrrunzK7QZdf5SEUeh2aR8j0wRImZL+yXrpBPvEGfZsP9Yb9Eu7t1gLw20DzSuziqXHTRRbJ48eJeP0MGBmV6xnHHHSfnnHNO0tuXlpbK1VdfLT/60Y/kb3/724Ae8y9/+YsGTMggIStjvP3223LggQfKrrvuKo8++qieC/h+xowZGqBg/hICJtwGQdZHH30UC6AGatGiRbGAaerUqZppSsySIWA766yzNGDC4yAT9f7778sll1wim222mXznO9+RffbZR/71r3/J008/rUFdV1eX3g+Cq/32229Q+0Q0nEbHX8U87Z7ndPYETfm8VlM0HJRQ40pdqNQ6irqkJdPqa5MlrSuxJrHMrpwmJXkc6KaChg6htrUSRnOHaERsReXiqJ0mVnd6E4UpN+YloV16a0dAg6VIpGcx2eJ16ySVFjnWKzvL55bnKC/sXBcoJbY8ryn36Nd8f74YFHvDCIz84g16NUDyhQP6twfPy21zisfukarCCvHYXbK2tVFWysqR3u1RBfOXTKc7vB7IAqERBAIDo68sEyDowGUwEFhg7tW+++6rDSdQehc/FwuB3JNPPqnlcQiwMKcJXfKQAcP3zz33nDZ9QCncQQcdNKjHfuWVVzRgQsB233336eM+8cQTvYLCTz/9VIMrBGennnqqnosI3G6//XbNpOHYHHLIIb2CJmSc0FBizz33lIqKikHtE9FwYtA0knOa7G5tmBAK52/QFGpYgRaBumDpaIU/hsvbV0lDV7OUuUpkatlEsVlH369ONOiTEErw2pt0LgdKLW1o7mB3jvSuURrvQV3IJq0LlFCCZpo31FZ4tBV44ShYTBYZMmSO0PbbZM3Ckaievx6nTcqKnLFufvmcRYpEI1pih8BIs0iaQeoJkCwFBeKyuTRAwrxKj92t5cKJGfDGAmaZMg3lbwYyeZtvvrlsuOGGct1110m2IGNz9tlny4UXXqj/93g8suOOO8qZZ56p7cqTMWVym2yySaxLHr5HpgvznAbK3A+CNROoffe73+21zdKlS/Xr2rVr5Ywzzuh13TfffKNfkXHaaKONNCv32WefyVNPPaU/P/jggwe8L0QjYfSN/PIoaIotcBvMzw56EW+HhDuaxFk7VdflGY1Q4rKoZakEI2GZUjZBByWjDV7HUMsanbdUYHOIvXK8Zg5H62s6WiFYQJDU1hmU1s6AtsO2WguktNCp2ZWyYofYbfkbOMS3/UYGqWdOUk9pIRJGmINUXe7W0kIEh/na8lwzSBocIXvkl66gVwMkQICEgKjI4ZHawioNkFx256gtEab1bbvtttrsAY0g0NThnXfekeeff14bKSDDlEx5ebl+XbVqVexn7e3tsflYA1VWVhabi2XEfw8mKEPjh8TW6/FNI5BtQuCHLn/vvvuu1NXVaeaOKJdxVJTloKm/Fqb52nYci5kGG5ZqyZa1pEpG42tY39kgKzvqxW1zycbVU8U1ypo9WIJeCa74SrolIhanW5x108RaXDFm2sWPBmhogACprSMoHb6gztVB2RnaYSObhHk6+ZxNQhlhS0dAGtrDsa522uLeitJCh5YWosQQi8vm4/PE+wwCIgRICI66giix88cySAiKSpxFUldULR6HWxvPMEDKHUNtBDFYCHQwd8lApgjNH8zjGug+iPK8xx9/XJsqIAOGsr758+drKd12222n12FtrHjI+iCwQje+yZMnr/f4JghCiR8eF88tsb06uvLhsXBc8LyR/TJlsPGliCgvvPzyy3U/cL6jVNB8yIzniOeKAJHlepRLGDRlQfyK5v1lmhw2pwRDg+9gM9Iw3wXNAdyjsPlDMByUxa3LpSPQJXXF1TK+uHaUDVR6Xi+Lr03EOkFcdTPEWlg60jtFA+z8hi53OjepM6Bd3xAsILuCBg6lxU6du5OvwpGwtAc7pSPQKau8y8TXFhT3ynYpKeqZh2TWRsrX+UihSKgnOEImSb96JbLu7wUySIV2t1QXVkihw8MAaQw0ghgsZHEwlwgtuxPhcQx0pMN+XHXVVXLYYYdpRufEE0+Uf/zjHzoHCRcEVghI0ALcuPvuu3WeEZpGHHnkkes9xvbbb6/d8jAHyQRLCNycTmcsaEQwdfLJJ8v111/fq0zR7XbrvCYDbc8xhwnZMfwux8+vwjpTyKRhfxDgEeUKBk0jXJ6HtuPtXY2Sd80fmlbp+jwWp0dGk2ZfqyxrXalB0gZV06XYOfqaH6Dszl4zVUJeizjGzRSrZ3S9hqMNGhsgm4QLur/h7cXpsEp5sUvXTULGJR+zLBCORqQz2KVBEi4oRwNkVMpKLeIOFshmMyqkrLQ4b8vsOmNZJK923wS71SaFdo/UFdVogIRgycr2/coMvvPh8eIbQfRloFkm3A+CiFT3h/EEghWU46H7HbIxaLiw++6792o+gWAJwRWaK+A6OP3007VpBJpCoFwPHftef/11WbBgQaykDhkpZKiSZZkMdPl76KGHdA2mCRMmaMe+m2++WR/LQHMHZJzQEQ/7OHHiRN0OHffiHXXUUbqOE9qt42LssMMOGvgxy0S5pqA7foQ/xnz++eexSYmZhDehlStXaop6iy22kMLCvrvKLV/+uaxqWCzbbZU/bTYDqxfqej3uKZsOy7wXtEXFp2aYOIpJr9maaL2sbZU0eVukwl0qk9HsYRQPYobjmI4l85eslU+/+Eb22XXLjBxPzNVpafdLc7tfu78hqYIFZdHYAJdcageOxW0//PwF2XjG9lJeMaHfQAJBkskmIUjCnyCH1a5laMXrLvj/24s/EH99p2y/+bY5fY5+vbRZX59J4zyx7BG+mk52+ACm0OHWIMkESA6bY9j3c0nDcnlv3ofy4633yNjxTOdvKAbJyM6gtAtr9hgoFVuxYkVsjaHhhL/VGNj3V05PRKNTX+9LiXLnL+8YbDkODodHwpGQRKJhsVpy/+WIdLVJuKNZnHXTR02jgM5Al5bjhaNhmVY+SSo9PZNmiYYL3i8QKCFIQrCEsjs0MigvcUpZrVPL7/JxkVUsrIpmKiZIQjCBNYOQaSl2FEm1p1KDJOcIBBFD/ZAFzwUB4LKONRKI+qXd6okrs+vpZIcgCXMi87GUcLghYEHgEl/ePlzwd5oBExH1Z3SMevO6PK8nog0GfOJ2F+dB84dlusipraRyVLxOqzvqZXVng376O7tyet4N3ii/zz+0ydZAqaOn253dZtHFVstLXNrgIN8G27pwbsinARIWgO7UICmqWdsiR6FMLBmnQRICi3yCsjp8uIIgCReTRbJZbJpJqnJVyeyqOpbZDRECFwYvRJSrGDRlOWjqb9CDTBMEg96cD5rCLfUSDQXEPW6GjIZmD4talumE7HHFNTKuqCbvBqiUf9Ae+9tAya/d4Rx2i1SWujRYQre7fD0PV3aulaWBVp2nhECi2Fko40tqpcTREyTly/PC+zc62CHgM4GSmYvksjk0+KsprNK23+io+XWwuacZxyic/0hERN9i0DTSQZPTrV9zfa0mBEuh5lViL8v/5g/+kF/mNy3W1wbNHjAIIspqx7vOgDS1+7XrHQInNHLA2kkIlLCmUD6zFljFYbHp14qiKg2S0B47XzpO6jyrUE+pHYIk09HOtPyucJdpgIRSO7s1v18rIiJKH4OmkV7cVj+BtUgw9G3nmVwUbFguYrGJvTL1RO9ch/kVCJgwp2JW5TSdcE6UjUVY0e0OGSUsNotACW2y6yp7AiWsKzRaoOvbxsXjxVUxJS9a1yNrZOYj4WKaUaCEEIEROtppkGT39Pv+TUREYweDphHONH27VpM/p5s/RDpbepo/5HFHOXyKvKB5ic5bmlUxTWyjpJEF5Qb82je1+WVFY88aSvi/x2WT8VWFGijlUse7scTMR+qZY9Up/nBQf473AWSZqzwV+hVtzvOlhHA0GMONe4koT9+P+Fc8F4Imu0uCQV9uN3/wlOR184d2f4csaF6qrX9nVkzlmiiUUfg9D0e6ZcnqDqksL5JJtcW6hpLLwbfYXAmSMK+qxFks40sKNUhilnlkoL23WfYAC54SEY00vB/Fvz/1hX/Rs8C0TMVAaiBBk93mkNC6P+y5JtS8RrpDQXGOnyn5qtXXpk0f0LVrRvkUltxQxlWVuqS23J63C7Hms1AkJB2xBXK7xB8O9AqSJpQUSbGjMKczy7pMRdAnEX+nRH2dEvV3icVVqNn90Qbd8crKymTt2rX6f6wZxQwfEY1Yx1evV9+P8L7UX/fO3P0rMobKDhx2t7R1NkouNn8IN68WW3mtWBz5+Ylgs7dV12Aqc5XoGkz5Mjmd8gsaO5QV2sRhz9/y1XwLkkw2yQRJKK9DBzt07EOQlMtNG7ojYQ2MNEjyd2mg1B2N4JO2WKOdaCA3qw8yoa6uTr+awImIaCQhYDLvS6kwaMpi0DTQT88cDpcE1/3hzyXBtctErDaxV4yTfNTQ1SRLW1dKladcppRN5KeZRHkIi063+Np6MklYI2nd/E+0/0b2eHxxrbY3z+UgKRr09wRJvo6eICnQUwqCBcItriKxV9SJxVUsFpdH543ivRfbjlb42zhu3DipqamRUKinnTsR0UhASd5A14dj0JQjmaZIJKQXa4784Q93tkqkq1Wc42bmZfOHNZ0NsqJttdQUVsqk0vEMmIjyUFOwTT5f+7U4nc51ayQV6ZpqRc7cnZOEjBGCImSPIppF6tDMElic7p4gCdl7V2HeZvAzhYvZElE+YdCUC5kmuzO2VpM7B9ZswR/9EJo/FJaKrbhc8s2q9jWyqmOtLlo7oaT/dCsR5Z4KV5m02ZplSukEqSmrztkgSbDwrd8rwYYOiaDMLuDTBjoFFosGSLayGrG6ijRIQmaJiIjyE9/Bc6I8r6eGPRhEN6GRn0Qealkj3eGQOCfMlnyzvG2V1Hc2ysSSOqkrrhnp3SGiNE0uHS9dzjZdXDaXAibM9dQsEkrtfB1SsLpRpEAk4qjUIMlSUiVWd5EUONzMcBMRjSIMmnKhPG/dxN9caDuO2vtw85p1zR9ckk/HHPOXGr3NMrlsgpblERFlZD6SD1mkngu6iQIaNlg9pdJdUSgF7iJxT+WHNEREoxmDphzINNntWFTRkhNBE9ZkElt+NX+IdkdlSctyafG3a4e8Sk/+lRQSUW5A1zqTRdJyOywHoV3t3GIrKheLu7gnk2SyX75mEQsXxSUiGu0YNGVjvY00Vjp32Jwj3kEv3NEika42XZMpX5o/IGBa1LxM2gMdMr18spS7S0d6l4goT8TWR/K2x0rutGlDQYFYXYW6oLfVja52nI9ERDTWMWjKsPiAaTAL9jnsrhHNNKH5Q7ARzR/K9NPUfBCJRmRh81LpDHplZsVUKXGN/HwwIsrt9+eeznYdEvGi/XenBknI9CMwspVW9wRJyCTlyQdHREQ0PBg05UzQ5JTguvVHRkKoebVIOCyOiZMlH4SjEVnQtFh8Yb/MrpymLYiJiJKX27VLpAvZpA79gOjbzna164KkQg2ciIiI+sKgKcOi0What0OmyTtCixlGgz4Jt9SLrWKcWNa1P89loUhIvmlaLMFIWGZXTpfCdd0HiYii4aBEve1acodsEuYkaSbJvW4RWVNuxyCJiIgGgUFTjmSa7CjPi/R0ZRpuWH2+wO7QAUWuC4aDMr9pkUS6o7JB1XRx2/Onwx8RZR7K67Rxgxcld23a7Q4sLo/YiivE6ilhuR0REQ0Zg6acKc9zSyQS0ot1GNckCXc06yeyrgmzc/6T10A4IAval+r3G1TNEJct97NiRJRZWDg26uvqCZAwN8nfhR9qltziKRF75QSxeoq/7W5HRESUAQyaslieZ7EMPAhxONz6NRDwisdTOnzNHxqWi7WoXKyFud11LhANyjfNS8Tj9sjsquk5tdglEWW5eYO/q2edJK+ZlxSVAqtNs0jOmioNlvKhtJiIiPIXg6YcyTQ5nT1BU0ibQQxPABNqWiUSDYujepLkMm/IJyt99TLDMkNL8uwMmIhG/bykSHujWNtWS3BpSMRm7Wne4C5el0kqkQKHe1DvsWMZPiBDp8CCEV7WgogonzFoypk5TT1B03C1Hccf0XDbWrGV1+X0J7ThSFgWtS4Tu8WubcUZMBGN7pI7rBWHtuChYFA/1LGWVImropYd7gYhGgroulMIlLBArx7PjkaxdDVn70UkIhrlGDTlSHmeHfX4FuuwBU3aVSoa1YnSuRyALmpZpl/HOavExnVTiEZfl7vOVi2701bgKLkrLBV7xTj98xQJfCO2ivFi9bBDZsqA0+/VAEkX6MXaU+GQXmdxuHqyc2U1YhV8oLdkGF9hIqLRhUFTjmSawGHDWk3DFDR1tfb8QV03lyoXrelskPZAp0wpnSgrm5aP9O4Q0ZDnJnVqJkmbOPi9+nOru0gz3giWLE5P7H0z6O25nhKOIxoGaRapa102qUsDp5626oViK6nSNaisWHsqrpS5oHElDyUR0RAwaMrCwMAEToMNmuwImoLZrznH/mHgYisul1yFYGlVR72ML66REluR8M89Uf5BxkPXS1oXKKE9eE8Dh1KxlyFQKmGXu/7+noT8PRmkdeV2pqV6gc0hVleh2Ksm9Kw95XTnfAdUIqJ8xqApR8rzwGF3SjDc8wcxm1DfjgUfrYXlObt47eKWZVLsKJRxxbXi8w1P9o2IMpBNCng1k61zk9AO3KyZhBIxT+m6hWXZwCGZaLRbvP6QtLZ6xe5rl+7wJxpoSkGBVgWgAYa9YryuO5XLc1GJiEYjBk1ZLM8bfNDkEq+vQ7INAxp82otSjlw8fotbekrxppVP4uCKKE+EmldLdM2iuGxSSc9cGk+pFNi4REBfQVKnLyQd3qB0dAX1e/yswF8gnohNyifWajYJQVIB53QSEY0oBk25NKfJ4ZbgMLSExcRrHcjkYCnH6o566Qh2yazKaeyUR5QHMJjHBY0cbKXVPXOTXEX8wCOJCIIkb1DaESB5Q9LpC2JdXrFaC6TY45AJ1UVSXOiQhha3dPoqxVFZNfwvKBERJcWgKYtzmgafaXJLJBqWcDgoNptDstaKNuAVe3md5Jp2f4es6lgrE0rqpMRZNNK7Q0QDgKySZ+ZWPFZJRCJR6fD2ZJIQKHX5Q4ImdjarRYoL7TKptlhKCh3idtp6BZlNrSxfJCLKNQyacmhOk93u0q9oO56toAnzDFAfj0+Dc0kwEpJFLcs1WKorqh7p3SEiGrQwgqSuoLSvK7fzBsI9QZLNIiUeh1SVuaXYY18vSCIiotzHoCmHyvOczm8XuPV4SrM2n8nqLtZPh3NrHtMysRQUyPTyyRxMEFFeQand5wsbxecP6/8ddouW29VUeDRYcjlz5/2WiIjSw3fyLAZNVqt1ULd1OHoWcMzWAreYcxD1dmiL2lyC1uKdQa9sUDldbDkUzBER9cfjsos/GJEit13qKgq17M7l4PsYEdFoY0u3BO29996Tt956SxYvXiytra1SUlIi48aNkx122EF22mkncTrHZjtUHJt05zShJM9isUoolJ2241gvBYsgWgvLJFe0+dtldcdamVhSJ0XO3OvmR0SUCuYl4UJERKObbbABwRNPPCE333yzLFmyRNxut0yaNEmKiopk+fLl8uGHH8q9996r/z/66KPluOOOk+LisfXHZCjleeDAArchX9a65mEBRIujZ+7USAuGg7K4ZYWUuoqllvOYiIiIiCjfgyYEReeee66sWLFC9tlnH71stNFG62VTFi1aJG+++aY89NBD8q9//UsuueQS+d73vidjxVDWaYotcBsMZGW/MJ8JLYFzQbQ7qo0fMI9pWhnXYyIi6uXbPyVERJRPQdNZZ52lgdJPfvITsdv7Xqhw+vTpekGm6bXXXpNLL71UZs6cKRMm5NY8muHonjfYOU3gsGGtpsxnmqL+Ll10Mle65q1qr5eukFc2qOI8JiKieGgcUd/slS8XN2npH5pKEBFRngRNt99+u3g8PY0KBgoZJsxxis++jHZDWacJ7HaHdPpaM75fyDKhYx4WnRxprf52WdPZIJNKx0mRg/OYiIji1VZ4xOWwyvL6Dpm3uFnKip0ysaZIm04QEdHIGPCo/vzzz9eSu66urkE9ALJSDsfY+ZRsyHOaHG4JhYPZaTVeWDbi7bwxj2lJy3Ipc5VwHhMRUR9Ki5yyyfRKmTGxVFuZz13UJItXtUkwFOExIyLK5aCpqalJ/vCHP2hnPHz9/PPPs7tno6A8L62gye6WSDQs4QwGTtFQQKIB34h3zcM8poUtS8VqscrU8kkjui9ERLkOf0MqS92y2cwqmVxbLC3tAflsQaNmoLCQLhER5WB53t133y0fffSRPProo/Lvf/9bs04bb7yxHHLIIbLffvtpxzzKTKYJgkGvtiDPWGlegUWshSUj+hKtbF8jvpBfNqiaITbL4Od7ERGNRRZLgdRVFkpVmVtWN3bpfKeGFp+Mry6UmnKPXk9ERNk1qEk3W221lfz1r3/V7njoioc5Tn/+859l5513lvPOO08++eQTGevi5zQNLWjyZ7bVuKdYCkYwUGnxtUl9Z6NMLBknhesW8SUiooGzWS3aGGLzmVVSXuKUZfUd8vmCRmlq842pucNERCPBktYK6B6PHHTQQXLffffJCy+8IEcddZS88cYbcthhh8m+++6razUFg5mflzO2Mk2Z6aCHjnkRX8eIluYFwkFZ2rpCyt2lUlNUNWL7QUQ0GjjsVpk2vlQ2m1ElbpdNFq5oky8WNUlbZ+aXqyAioiEETfGmTJkiZ555prYXv+WWW8Tv98tf/vIXWb16tYxFQw2aUJJntdgytsBtxNuOnRqxVuM6j6l5qZbjTSmbOCL7QEQ0GrmdNpk9uVw2mlahJXpfL22Rr5Y2S5cvNNK7RkQ0duc0pWp88M4778jjjz8uL7/8sgZNaBZRVja4zEZbW5u0trbK+PHjU64DZYTDYVm1apVUVFTk1HyqoTaCAIcNC9xmKGhCaZ7TIxa7U0bCirbV4g/7ZcOqmZzHRESUBVjHaeNpldLS7pflazs061RR6tI25S7HkP/MExHRUIKmhQsXyhNPPCFPPvmk1NfXS11dnRxzzDFy8MEHD2oh20gkIn/605/kkUce0YADwdaFF14oe+65Z5+3QYB22WWXSUtLiwYmaEaBuVXprIuUa5kms1ZTKBTIyL5EvG1iK62WkdDsa5W1XU0ypWyCeNaVHRIRUXaUl7h0TSc0iVjZ0KnznWoqPDK+Knc+WCQiGhNBE4KUZ599VoMWtBy32Wy6gC2CHDSDsFoH32gA85/QiQ8BBrJGzc3NctZZZ8lmm22mWadEKAM899xz9fuamhppaGjQ22+wwQZy5JFHSq4ETQgAfT5f0sAJxyl+7SpsFy8atki7v01/jkDQ6XT2uW28xG29LY3i6+oUV8UkiSTcDvvlcrli/0eGsK+JxInbBgKBXhm1RG63W/zhgM5jKrS4pcji6XO/sa2BeXAIohPhtti/eH1ta2B/zbHP5LY4viY4D4VCmvEcyW2xHbbvC84z83sZv605pvHnaPy2OAap5iUiG4zf/8Fui/MG509fsJ3JNI/UtvG/n/idSDz3Um3b1+984rb9/S4PZtuhvEcM5vc+0+8R/W2bzu/9QN5PxsJ7RFWZSyrL3FLf1CXL1rTJ8tXN0h1o1VJtIiLKctD0+9//XjNLeLOePHmyzmNCM4jq6qFlMRDwwKWXXir777+/HH/88dqd7+mnn5aTTjppve3/+c9/6ldcZ+ZS3XTTTVrelwvMoOLrr7+W3/72t0mzXzvuuKNce+21sf//8Ic/7DU4CAS9EomExOMu1Y6FmCtmoNEGyhiTQQt4tIY3Dv3pT2X1qlVanpdo+vTpsWMPRx99tCxatCjp/Y4bN05fD+OEE06QL7/8Mum2yBSiOcii5qVit9jkb7+/XD7++OM+ByJ4rQ0Ey2+99dZ622FAhePzwQcfxH6GtcJQDtoXNCYxA6iLL75YnnnmmT63ffHFF6W8vFy/v/rqq+Xhhx/uc9unnnoqFszfcMMNcs899/S5LY4vjjPccccdvV7HRHjd8PrBAw88INddd12f2958883yne98R79/7LHH5PLLL+9z22uuuUbLZeG5557TjGz8McVrYM5R/A7uvvvu+v2rr74a+3AimT/+8Y96LgLKc88444w+tz377LPl0EMP1e9xLiT7vTZOP/10PRfhq6++in2fzIknnqgXWLJkSewxkkGzml/96lf6/Zo1a3SZhL4gc33OOefo9/hdw+9nX3784x9rptwM/rFtXxnv3XbbTTPkBj5o6kt/7xHxhvIegefa1/zTbL5HvPTSS7H///KXv9TlLBLhHMXl7bff7vc9wuB7RO/3iPHVRfLfl56RSy+9TPx+r/zuwl/2eeyIiChDQRPaie+xxx76R3b77bdPu/Qsntfr1TI/2GWXXfQ+8RUD6blz5663PQI209Yc+4EFd/GHAYPMXFFZWSnt7e19BgoDYSmwSDgDnwh2h0NSYBn+evZlbas007Rh9cyMnCdERJR+m3J027MUuGVSzQY8jEREaSroHuDiDghw0Gp88eLFsmzZMpk4caLMmDFDhgL3Yz7FxafKGGBjjhQ+md5yyy3lwQcf7LU9PiFGOSC2wyfiyBDg+wMOOEA/QY8vOxkIlBji6c+cOVMyqaurS+bPn6+dBePLRQZaetPUvEwWr/hc5my0uzic7rRKb6Ihv7R/87HYaqYmbTeerdIbXY8p2CSTS8ZLpad8UGU6qcrzli5dKhtuuGFs+7FcepOp8jwc0/hzlOV56Zfn4XjivRFzO5P9zifer3kN+rvfsV6eN9jfe5bn9f0egeOJ+cdTp07t8xwdrAULFuhrj3J6IqLRbsBpCMwH+M1vftOrzAllP1dccYXORUqHGcBhgGAGrWaAl2yOhJmHgD/cKO9A4IbSEsyxqqqq0nK4dPZh3rx5kmkYQOAPVDr8vhbp6GiXRYsXiMNRmNZ9WLwtYulskrCUiBQkL9XJRnvxJd5V4rG6xNVikbWyJqPHEyVYlBvnKK0P72E8npnF3/vMy/T7aHxwT0Q0mg04aLr//vvl+eef1w55qItfsWKF1sZjvsiVV16Z1oObT7vwySE+DcNkbRMYFRauHyzEf5J50UUXaac+1Lcfd9xxGsylEzQhGMx0pgmf6OEPU7qf6Pl87RL6ulGmTp0opaV1ae1DcNV8EUutOOqGlg0cjPquRgl1FsjGVbPEYe2/bfxwHU/iMc02nqM8pmPxHEWmiYhorBhw0ISGC+edd54cfvjhsZ9tt9122rgBpRXptPtG9zsESgiYkDGaNGmSrFy5Uq9DFinZ9igRRKngRhttFJsEbTr7pfvpMO4zG/CHKZ37djrtGszhkKZz++5IWLq7w+KoHC/2LD23RJFoRNraOmVCeZ2UFZfm1PEkHtPhwnOUx3QsnaOcs0pEY8mAIx2UnWyzzTa9frb11ltrsNTY2JjWgyNgmjNnjn5//fXXaxcudOgzARkgiML8oI6ODn2DRlcp0+UMTSFuvPFG/f+sWbNktLBa7XoJhdJb4DbS1aatZZPNZcqWhq4miXZHZFxRzbA9JhERERFRTgVNmPuTrHYZ3eJSTZTuzymnnKKBFxpAoPQPQRIaTOy99956/QUXXKAtdF9//XX9P1obo3QPLaUPO+wwba2K26dqeZyPHFaHBEPpHddIV6tYXIVisTmGLcu0prNBqjwV4himxyQiIiIiyrnyvFRN9gbYgC8pNJO47bbb5M4779SMFeZLYa0WE6BNmDBBs0jFxcX6f8w/wtohyDChPhslfVg/xJTpjRZ2uzOtoKm7O6qZJlt5enOh0rFWs0xRqStmlomIiIiIRp/hX8QniR122EEvyVx44YXr/QyB01VXXSWjmcPukkBw8OV5UV+ndEcjYivMzryiZFmmepNlymDzByIiIiKivAya0CkvcQIpskPJfn7++edrG3BKj8Phlk5vS1qleQU2h5bnDQdmmYiIiIhotLMNpuPOe++9l/S6ZD8/88wzh7ZnY5zDhvK89deq6k+ks1VsRcPTACLMLBMRERERjQEDDpqeeuqp7O4JrZdpQje6UCig85sGIhrwSTQUEMcwdc1b29XIuUxERERENOoNenGlxYsX65pNCxcuzM4eUSxogmDAO7jSPItFLJ6ephnZzjKt7WzkXCYiIiIiGvVsg2k5fu6558ozzzzTq/PdFVdcIRUVFdnavzHL4eiZIxYM+aRQygfeatxTKgUFg19oeLCYZSIiIiKisWLAo+v7779fnn/+eV1L6fLLL9e24HPnztUmEJR5DodLvwaDA2s73h0OScTXOSzzmUyWqbqwkh3ziIiIiGjUG3CmCSV55513nhx++OGxn2233XZy/PHHSzQa1QVmKXOsVrtekGkaiIi3red2nuy3Gl/b2SDR7m6pK6rO+mMREREREY20AUc69fX1ss022/T62dZbb63BEtqOU5Y66A0w0xTubBWru0gKbPbsd8zrQpapQuxcl4mIiIiIxgDLYOY0ORyO9X5eWVkpfv/ABvY0+AVuB5Jp6u6OStTbJtbC4ckydXcLs0xERERENGYMOGjqxkg5jesofXabQ0Lh/tdqino7pDsaFWvhwBpGDDXLVFNYySwTEREREY0ZnIiU423HgyH/wLrm2Z1icfa0Kc+W+nVZptqiqqw+DhERERFRXjaCAHTK83h6WmEbmM+U7Ofnn3++VFVxcD3k8rxwoN/twl2tYst2likS1jbjzDIRERER0Vgz4KDJ7XbLe++9l/S6ZD8/88wzh7ZnJA67W+crhUIBsdudSY9INOCV7lAw6/OZUJbHuUxERERENBYNOGh66qmnsrsn1PdaTQFvn0ETuuYVWKxi8RRnP8tUVCk266CSk0REREREeY9zmnKYw9FT8hgMelPOZ0KWqaAgey/lmq51HfMKuS4TEREREY09Ax5p33777dLR0TGoO49EIvLAAw/oGk80eI51jR36agYRDQcl6u8Sa2FZdrNMnU3MMhERERHRmDXgoKm9vV1+9KMfyW233SYNDQ0ptw0EAvL444/LAQccIM8++6wUFRVlYl/HHKvFJlarvc9MU7SrTaSgQKyFJVnNMhUUMMtERERERGPXgCeonHHGGbLDDjvIn//8Z7nqqqtk2223lS233FKmTJmiQVFnZ6esXbtWPv74Y3n//ffFarXKKaecIkcffbRYLKwCTJfD5pRgKNjnfCaru0gKrHbJhlAkpFkmtBjnXCYiIiIiGqsGNasfgdIzzzwjL774ojz88MNyxx13iM/ni12P4GiLLbaQ0047TQ455BBmmDLVdjz07TE2uqMRiXrbxV41QbKlvrNRs0y1hWwdT0RERERj16BboRUUFMgee+yhl2AwKGvWrJHW1lYpLi6W2tra9dZroqFx2J3iC3St9/OIt0PbkWer1bhmmbqYZSIiIiIiGlL/aIfDIZMnT9YLZS/T1NbZlLRrnsXhEoujp1lE1rJMReyYR0RERERjGycb5Ti73SWhcO85Td3d3etajZdlN8tUWCU2izUrj0FERERElC8YNOU4h92tZXihuHlN0YBXusOhrAVNazobxFJQIDXMMhERERERMWjKdY515XeBwLdBE7JMBVabWNyZb+UejISkoatJagormWUiIiIiImKmKfc51y1wGwrGBU1oNe4p1aYcmVavWSYLs0xERERERJloBAHRaFQviWy2Id81YU7TukxTMOTvOd6hgJbn2SvGZS3LVFdcwywTEREREdE6aUU2Xq9XLr30Ul2zqatr/XbY8MILL+jCtzQ0VotNbFa7BINe/X+kqw1938XqKcn4oV3TsbYny8R1mYiIiIiIhhY03XDDDRowHXDAAVJTU6OL2iYqLy9P566pzwVuezJN2jXPXaxzmjKdZWr0NjPLRERERESUIK2R91tvvSUXXXSR7L333uncnAbJbnNKIBSQ7mhEot4OsVdNyFqWCW3GiYiIiIhoiC3HMYdp+vTp6dyU0uCwOyUUDkikq13bj1uLyrOSZcJCtlauy0RERERENPSgabvttpNXXnklnZvSEMrzUJpncbrFYndmaS5TJV8fIiIiIqJMlOftvvvucsYZZ8iaNWtk8803F7e7p8NbvO9///tSWFiYzt1TkrWakGkKd7aIvawmo8cnGA5qlmlccS2zTEREREREmQqazj//fGlqapJ//etfeumrex6Dpsxw2N3S3d0t4XBQXIWlkklrdF0mK7NMRERERESZDJruuusuCYVCKbcZP358OndNSdjtLv0athSIxVWU8SzTeGaZiIiIiIgyGzSZgGj+/PnyxhtvaNappKREtthiC53vlKwFOaXP6ewpf4y4CqWgoCBjh3J1J+YyWaWac5mIiIiIiPqU9mI/l112mdx+++3r/XyrrbaSf/7zn1JUlLmMyFhnt7ulAM0fMliahw6ITd5WGVdcw7lMREREREQppJUSwsK299xzjzaDQBe9L774Qt5880258sorZfXq1XL55Zenc7fUhwKLRRzVk8Xqzlwg2h7slGh3VMpdJTzuRERERESZDpoef/xx+dWvfiWnnHKKTJgwQWw2m1RXV8u+++4rN910kzz55JP9znmikdXqaxeXzSGudfOliIiIiIgog0ETWo3vuOOOSa/bcMMNxePx6Dwnyk3oxNce6JBSZpmIiIiIiLITNI0bN07mzZuX9Lr6+nppb2/XxhCUm7whnwQjISlj0ERERERElJ2gaa+99tJ5Sy+99JJmLYyvvvpKTjvtNNlhhx0020S5qc3fLjaLVQodfI2IiIiIiLLSPe/AAw/UgAkBktvt1vlMbW1tepk4caJce+216dwtDZNWf7uUOIvFUsDW8EREREREWQmasA7TDTfcIC+//LK8/vrrOn+psLBQ12naf//92W48h2FBW2/IL3VFNSO9K0REREREo3udJiyyuvvuu+uF8kdroENfuxJX8UjvChERERHR6AqaUI733e9+VzNK+L6rqyvl9gimsC3l3nymYkehzmkiIiIiIqIMBk2XXXaZ3HrrrRoI4ftly5al3P6FF15g0JRjItGIdAQ6ZUJJ3UjvChERERHR6Aua7rrrLm34YL7vb/Ha8ePHD33vKKMQMEW7u7k+ExERERFRNoKm+CCIAVH+ds1z213isjlHeleIiIiIiEZ/IwgsYOt0OvUCzz//vHz66aey/fbbyy677JLJfaQMwHparf4OqSos5/EkIiIiIhqEtBbqmT9/vuy2226yZs0a/f+TTz4pp59+utxxxx1ywgknyL/+9a907payqCvklXA0LGXOEh5nIiIiIqJsB00Ijrbddlupra3V/z/wwAPaWQ+ZpksvvVSuv/56zWxQbpXm2Sw2KXR4RnpXiIiIiIhGf9A0b948Oemkk8TlcklbW5sGSz/5yU/E4XDIgQceKOFwWBoaGjK/t5S2Nn+HlLmKdY0mIiIiIiLKctAUiUQ0QILXX39dB+I77rhj7HqbzcbBeQ4JhIPiC/nZNY+IiIiIaLiCphkzZshzzz0nPp9P7rvvPpkzZ44UFxfrdVi/qbOzU8rL2XAglxa0tRQUSImzaKR3hYiIiIhobARNxxxzjM5r2mqrreSTTz6R4447Lnbdr3/9a9lrr70020S5M5+pyFEoVot1pHeFiIiIiCjvpBXZILP00EMPaWkevkdTCGPPPfeUI444IpP7SEMQjkakI9glk0q52DARERERUTrSTgdtuOGGekl04oknpnuXlAXtgQ7tZFjm7CmfJCIiIiKiLAVNL730krYVLyws1O+7urpSbr/77rvrtjSyWn3t4rG7xGHradxBRERERERZCpouu+wyufXWWzUQwvdo+JDKCy+8wKBphCHDhExTdWHlSO8KEREREdHoD5ruuusuqa6ujn0fCoVSbj9+POfQjLTOYJfOaSpzlYz0rhARERERjf6gKT4I6isgikajYrGk1ZCPsrSgrd1qE4/dzeNLRERERJSmtCOcDz74QFuNr1ixIvazQw89VK6++moNnmjktfrbpNRZwoWGiYiIiIiGO2j66KOP5Gc/+5lEIpFe85b22WcfbUV+7bXXDmWfKAP84YD4w0Epc7FrHhERERHRsAdNt99+u7YWx9ym8vLy2M+PPfZYufPOO+Xuu+9mtikHFrS1FBRICVuNExERERENf9C0dOlS2WOPPZJet8EGG2j2qaGhYWh7RkPS5m/XgIlzzIiIiIiIRiBoqqiokLlz5ya9rr6+XlpbW6W4mGVhIwUd8zqDXillaR4RERER0cgETZi7hLWaHn30Ueno6NCfYX7TZ599JqeeeqrsvPPO4vF4hr53lJZ2f4eu0VTKVuNERERERMPXcjzeIYccIp988omcd955enG5XBIOh/Uye/ZsufDCC4e+ZzSkrnmFDrc4rHYeRSIiIiKikQiaCgoK5OKLL5YjjjhC3nzzTZ2/hMBp8803l1133VXsdg7WR0q0OyptgQ6pLepZiJiIiIiIiEYgaDJqa2ulrq5Omw0cdthhsnDhQrFarUPcJRoKzGWKRKNS5izhgSQiIiIiGsmg6bbbbtOFbEOhkP4f3fTOPvtsbUF+0003abMIGpmueSjL8zjcPPxERERERCPVCOLFF1/UgAlrNaEZxIQJE/TnmMvU2dkpf/3rXwd9n21tbdrK3ARhA4Xs1uLFiwf9eKN5faYyNoAgIiIiIhrZoOnBBx+Uc845R04//XTZdNNNYyV53/3udzUD9cILLww4+EHXvT/84Q+y/fbba7Zqp512kueff35At3355Zdl7733lp///OfpPI1RxxfySyAcZKtxIiIiIqKRDppWr14t22yzTdLrxo0bJ6WlpdLU1DSg+7r33nvloYce0hbZKOnDGk9nnXWWrFq1qt/M1B//+Md0dn9Ul+ZZCixS7Cwa6V0hIiIiIhrbQVN1dbW8++67Sa9bsmSJBj5lZWUDui8ETHDppZfK22+/rZmmQCAgTz/9dMrboQQQXfuod2leibNIAyciIiIiIsqMtEbX++23n1x11VVaildfXx8rs/vwww/ltNNO07bjaEHeH6/Xq3OSYJdddtFW5vgKc+fO7fN2r776qjz55JOy3XbbpbP7o1IoEtLOeWVuds0jIiIiIhrx7nkHHXSQfPrpp3L55ZfrxQRSmMc0a9YsueCCCwZ0P42NjVqWB+i6ByZD1VcWqb29Xe8f7c5/97vfyQEHHCBDgcdH8JZJPp+v19dMrL2E7BvuzyvOpNs0+Vp0G3vElvHnM9IyfTyJxzTTeI5mHo9p7h9P/P3Eh51ERGNB2ovbolMegidkfdauXSsej0e22GIL+dGPfiQOh2NA92OaRaCRhHnjNU0lgsFg0ttgUV083i233CLFxcXp7P56+zBv3jzJBpQqZuoP0wrvcgk2+KTEVph0m9X+Bol0R2RBy+gtzcvU8SQe02zhOcpjOtbO0YH+vSciGpNB01NPPSUbbrihzJkzRy/pcrvdsdK+cDgsNptNsyVQWLh+cPDGG2/I448/rl360HDCvPkj8Jk/f75MmTJFnM7kmZi+2O12mTlzpmQSPsnDvk2dOjX2HIecaarvlimlE6TCXZb0+uBakdrCKqkrqpbRJtPHk3hMM43naObxmOb+8VywYEFG7oeIaNQGTXfccYeccsopMnv27CE9eE1NjQZKCJjQkW/SpEmycuVKvW7ixInrbf/BBx/o13feeUf23Xff2M+RecL/H3nkEdlss80GtQ/IcCFLlg34w5SJ+0ZQhGCwr/tD1zy7wy7jymvFbe9/Llm+ytTxJB7TbOE5ymM6ls5RluYR0ViSVtBUUlKiGZohP7jNppkqBEPXX3+9HHjggfLEE0/odabJA4Korq4uzSxVVVXpnCkDGSZ8coZ9wadnA2k+MRq1+TvEaXOM6oCJiIiIiCivgqb9999fzjzzTA1yZsyYIZWVlettgy54A/k0CxmrE044Qbvh4QK4TyxaC2j68Oabb8rf/vY3Oeqoo/RirFixQnbbbTfNWD3zzDMylluNl7nYNY+IiIiIKGeCphtvvFE7tN133319bvPCCy/oHKP+YF0mtC6/8847tZvexhtvLKeffnpscumECRM0u5Ss6QMyTLgOnfTGKm/IJ8FIiEETEREREVEuBU233357n93tjPHjxw/4/nbYYQe9JIMufX1BsDSWM0wmy2S1WKTImbyrHhERERERDXPQtHjxYlm2bJk2akAZHY0sNIEodRaLpWD0thonIiIiIsqLoAlNF84999xemR2U1l1xxRVSUVGRrf2jFFCW1xX0SU15FY8TEREREVGWDDg9cf/998vzzz8vxxxzjFx++eU672ju3Lm62CyNjHZ/h7Z8LWUTCCIiIiKikc80vfbaa3LeeefJ4YcfHvsZ2oIff/zxEo1GxWJhedhIzGcqcnjEZrEO+2MTEREREY0VA4506uvrZZtttun1s6233lqDJXS9o+GFQLU90MEsExERERFRrgRNmNNk2oDHwxpNfr8/0/tF/WgPdkq0u1vKnOu3YiciIiIiohEImrq7u9O6jrKj1dcuLptDXHYXDzERERERURZxIlIeQpDaFmiXMlfpSO8KEREREdGoN6h1mtApz+Px9PoZ5jMl+/n5558vVVVshZ0N3pBPQpGwlLpYmkdERERElDNBk9vtlvfeey/pdcl+fuaZZw5tzyjlgrbomFfkKORRIiIiIiLKlaDpqaeeyu6e0KBajZc4i3WNJiIiIiIiyi7OacozwXBQvCG/lLlLRnpXiIiIiIjGBAZNeaY10KEZJmSaiIiIiIgo+xg05ZlWX5sUOwp1ThMREREREWUfg6Y8EumOSmewi13ziIiIiIiGEYOmPNLu75BodzfXZyIiIiIiGkYMmvJIe6BT3HaXOG2Okd4VIiIiIqIxg0FTHol2R1maR0REREQ0zBg05ZkyJ1uNExERERENJwZNecRmsUmhwzPSu0FERERENKYwaMojZa5iXaOJiIiIiIiGD4OmPFAgBeKxu6XSUz7Su0JERERENObYRnoHqH/ILm1cM4uHioiIiIhoBDDTRERERERElAKDJiIiIiIiohQYNBEREREREaXAoImIiIiIiCgFBk1EREREREQpMGgiIiIiIiJKgUETERERERFRCgyaiIiIiIiIUmDQRERERERElAKDJiIiIiIiohQYNBEREREREaXAoImIiIiIiCgFBk1EREREREQpMGgiIiIiIiJKgUETERERERFRCgyaiIiIiIiIUmDQRERERERElAKDJiIiIiIiohQYNBEREREREaXAoImIiIiIiCgFBk1EREREREQpMGgiIiIiIiJKgUETERERERFRCgyaiIiIiIiIUmDQRERERERElAKDJiIiIiIiohQYNBEREREREaXAoImIiIiIiCgFBk1EREREREQpMGgiIiIiIiJKgUETERERERFRCgyaiIiIiIiIUmDQRERERERElAKDJiIiIiIiohQYNBEREREREaXAoImIiIiIiCgFBk1EREREREQpMGgiIiIiIiJKgUETERERERFRCgyaiIiIiIiIUmDQRERERERElAKDJiIiIiIiohQYNBEREREREaXAoImIiIiIiCgFBk1EREREREQpMGgiIiIiIiJKgUETERERERFRCgyaiIiIiIiI8iFoamtrk6VLl0ooFBrQ9oFAQJYvXy7hcDjr+0ZERERERGPXiAdNkUhE/vCHP8j2228ve+yxh+y0007y/PPP97l9V1eXnHfeeTJnzhzZfffd9etVV10l3d3dw7rfREREREQ0Nox40HTvvffKQw89pEFPRUWFtLa2yllnnSWrVq1Kuv0ll1wijz76qFitVpkwYYJmpm655Ra5//77h33fiYiIiIho9BvxoAkBE1x66aXy9ttva6YJpXdPP/30etsGg8HYz2+//XZ55ZVX5OSTT9b/43siIiIiIqJRFTR5vV5ZuHChfr/LLrtIQUGBfoW5c+eut31nZ6fsuuuussMOO8i2226rP9tggw2Gea+JiIiIiGgssY3kgzc2NsbmIpWXl+vXsrIy/drQ0LDe9ijfu+aaa2L/j0ajsUwV5jelA4+P4C2TfD5fr6/E45lreI7yeOY6nqO5fzzx9xMfdhIRjQUjGjSZTnmYn2TeePG9KcVLBQHT+eefL++8845sttlmcsghh6S9D/PmzZNsWLJkSVbud6zi8eQxzXU8R3lMc12mz1GHw5HR+yMiylUjGjS53e5YBz20DrfZbDqfCQoLC1MGOmgW8dxzz8msWbPkpptu0tumw263y8yZMyWT8Eke/jBNnTo19hyJxzOX8Bzl8cx1PEdz/3guWLAgI/dDRJQPRjRoqqmp0WAHAdPq1atl0qRJsnLlSr1u4sSJfWaYfvOb32hb8o033lhuu+02LdtLFzJcHo9HsgF/mLJ132MRjyePaa7jOcpjOpbOUZbmEdFYMqKNIBAwYZ0luP7667XU7oknntD/b7fddvoVQdT8+fOlo6ND/3/ttddqwFRcXKzrNWFeFK5ftmzZCD4TIiIiIiIarUY00wSnnHKKnHDCCfLkk0/qBWbMmCF77723fn/BBRfIm2++KX/72990AVy0GgcEUUceeWTsfjbZZBN57LHHRuhZEBERERHRaDXiQRPWZUKJ3Z133qlZI5TcnX766bHJpVjAFvOWkFlCw4YpU6YkvZ++fk5ERERERJTXQRNg3SVckrnwwgt7/f+ZZ54Zpr0iIiIiIiIa4TlNREREREREuY5BExERERERUQoMmoiIiIiIiFJg0ERERERERJQCgyYiIiIiIqIUGDQRERERERGlwKCJiIiIiIgoBQZNREREREREKTBoIiIiIiIiSoFBExERERERUQoMmoiIiIiIiFJg0ERERERERJQCgyYiIiIiIiIGTUREREREROlhpomIiIiIiCgFBk1EREREREQpMGgiIiIiIiJKgUETERERERFRCgyaiIiIiIiIUmDQRERERERElAKDJiIiIiIiohQYNBEREREREaXAoImIiIiIiCgFBk1EREREREQpMGgiIiIiIiJKgUETERERERFRCgyaiIiIiIiIUmDQRERERERElAKDJiIiIiIiohQYNBEREREREaXAoImIiIiIiCgFBk1EREREREQpMGgiIiIiIiJKgUETERERERFRCgyaiIiIiIiIUmDQRERERERElAKDJiIiIiIiohQYNBEREREREaXAoImIiIiIiCgFBk1EREREREQpMGgiIiIiIiJKgUETERERERFRCgyaiIiIiIiIUmDQRERERERElAKDJiIiIiIiohQYNBEREREREaXAoImIiIiIiCgFBk1EREREREQpMGgiIiIiIiJKgUETERERERFRCgyaiIiIiIiIUmDQRERERERElAKDJiIiIiIiohQYNBEREREREaXAoImIiIiIiCgFBk1EREREREQpMGgiIiIiIiJKgUETERERERFRCgyaiIiIiIiIUmDQRERERERElAKDJiIiIiIiohQYNBEREREREaXAoImIiIiIiCgFBk1EREREREQpMGgiIiIiIiJKgUETERERERFRCgyaiIiIiIiIUmDQRERERERElAKDJiIiIiIiohQYNBEREREREaXAoImIiIiIiCgfgqa2tjZZunSphEKhrGxPRERERESUl0FTJBKRP/zhD7L99tvLHnvsITvttJM8//zzGdueiIiIiIgor4Ome++9Vx566CHp7u6WiooKaW1tlbPOOktWrVqVke2JiIiIiIjyOmhCAASXXnqpvP3225o5CgQC8vTTT2dkeyIiIiIiorwNmrxeryxcuFC/32WXXaSgoOD/27sTOKvmN47jT/vOZAltoiKFNokIUaKU7HsLolCyZOufJaksIVkKJSFUVLaytRNelVIpqbRIaKOklf6v78O57szcOXOnWbp1P+/Xa17TvXPmdO5vfnfmPOd5fs/xzzJ37txsbw8AAAAA2VXQdqM1a9Z4mZ2ULl3aP6ekpPjn1atXZ3v7eGh/CsZy0ubNm1N9BuOZaJijjGeiY44m/njq76cuXgJAMtitQVPQ+a5AgQKRX7z6t2zbti3b28d7DPPnz7fcsHTp0lzZb7JiPBnTRMccZUyTbY4WLlw4R/cHAIlqtwZNxYoVi3TE27FjhxUsWNDXJ0mJEiWyvX08ChUqZFWqVLGcpCt5+sNUqVKlyDGD8UwkzFHGM9ExRxN/PBctWpQj+wGAPcFuDZrKlCnjgY8CoFWrVlmFChVs5cqV/rXy5ctne/t4KGNVvHhxyw36w5Rb+05GjCdjmuiYo4xpMs1RSvMAJJPd2ghCAVCtWrX83/3797dp06bZ6NGj/XH9+vX9s4KihQsX2saNG+PaHgAAAAD2qpbjHTt2tPz589uYMWOsbdu2HiRVrlzZmjVr5l+/9957rUWLFjZ58uS4tgcAAACAvaY8T3SfpUGDBtmQIUO8O1716tWtc+fOkcWl5cqVs6pVq1qpUqXi2h4AAAAA9qqgSRo0aOAfsfTo0SNL2wMAAADAXlWeBwAAAACJjKAJAAAAAEIQNAEAAABACIImAAAAAAhB0AQAAAAAIQiaAAAAACAEQRMAAAAAhCBoAgAAAIAQBE0AAAAAEIKgCQAAAABCEDQBAAAAQAiCJgAAAAAIQdAEAAAAACHy7dy5c6clqZkzZ5pefuHChXN0v9rn9u3brVChQpYvX74c3XcyYjwZ00THHGVMk3GObtu2zfdVp06dHNkfACSygpbEciug0X5zOhBLZownY5romKOMaTLOUe2TC4MAkkVSZ5oAAAAAIDOsaQIAAACAEARNAAAAABCCoAkAAAAAQhA0AQAAAEAIgiYAAAAACEHQBAAAAAAhCJoAAAAAIARBEwAAAACEIGgCAAAAgBAETQAAAAAQgqAJAAAAAEIUDPsiMjZv3jxbsGCBHXjggXbiiSdaoUKFcnT7ZPPnn3/a559/bhs3brTatWtbpUqVQrffvHmzTZ8+3davX29VqlSx6tWr59mx7ikWL15ss2fPtpSUFDvppJOsSJEicX3fjBkzbOHChXbqqada2bJlc/049xTbtm2zzz77zOfcMcccY1WrVs30e+bPn+/v+zJlytgJJ5xgBQoUyJNj3VMsX77c51vJkiWtQYMGVqJEidDtNZaam9quTp06Vrp06Tw71j3JV1995e//5s2b2z777JPhdjt27LBp06bZr7/+akcccYTPawBAbARNu6BPnz720ksvRR7XqFHDhg4d6n/4c2L7ZLNy5Uq78sor7aeffvLHOrHs1q2bXXHFFTG3/+abb6xz5862atWqyHNNmza1J554gpPSf73wwgvWt29f27lzpz9WEPrKK6/4yXuYX375xTp06GAbNmywAQMGEDT9a926dT4flyxZ4o/z5cvnc/CGG27I8GT07rvvtnfeeSfy3LHHHuvv+2LFisX93tibjRgxwu677z7766+//PHBBx/sc7RixYoxt9fvhJEjR0YeKxjo16+fB1v4j4L6m2++2efs8ccfn2HQtGnTJmvXrp1fWAno93D37t0ZTgCIgfK8LPr66689ACpYsKA1btzY9t9/f88iDRw4MEe2T0YKKhUw6WSpYcOGfhKl53QCH0vXrl09YNKV0bPPPtuzdh9++KENHz48z489ES1dutQDSAVMjRo18sAneC4zOolVwITUnnzySQ+YdGJ/+umn+3P9+/f3q/mxDB482AOm4sWL+xxVhlnB/pAhQxhaM1uzZo317NnT3+snn3yyHXroofbzzz9br169MsycKGDSe71Zs2aejdY8feCBBxjPNOPavn17D5gyM2jQIA+Y9ttvP2vSpImP7auvvupjDQBIj6Api95//33/fNFFF9kzzzxjvXv39sdjx47Nke2TjcrsJkyYEPkj/uKLL1r9+vW9FOrTTz9Nt71KcxQAKEv3xhtv+Mns1Vdf7V+LvmKazBRA6mRUJ0LKFj399NOR5//+++8Mv2/06NH+s1AWBf9R8Bm8XxUoPffcc57Z1FiOGzcu5lBpboqCf81RZf6uu+66uEr6ksH48eNty5Ytdtxxx/n7Pggmp0yZYn/88Ue67VesWOGfzz//fA/+X3vtNc/Y/fjjj5FsarLT78uWLVvanDlz4to++Nuk4FW/Iy699FJ/zN8mAIiNoCmLdNIuRx99tH8OasD1R13rcrK7fbLR1fvt27fbvvvuGynLURlT9NhF03Yqe+rUqVNk/UP+/P9MY9Y3xJ5zWu+lq8gqx1EpZCxa06Cr/CrjU9CK/yirqayG5lmwdi5sjuoqv8ZZwWetWrU8WNVzmrPKNiP9HFU29IADDvCyxqAEMprmpLJ2n3zyiQegyjDpgstpp51GkP+vL774wteEPvjggz6WYbZu3erryWL9bYo1pwEABE27VC8uQZ149LqkWGVNWd0+2QTjU6pUqchzwRj9/vvv6bY/6KCDrG3btv4hOjnVVX2d0J577rl5dtx70pjq5F0nnPLbb79lWJanEy4FTkWLFs3Do91zxlOZDZXZZjZHVSIl2vayyy7ztU/KhupKfjxlU8n+vo81R8uXL28PP/ywj99jjz1mb775pgdaPXr0yMOjTmwqG1VQefHFF2e6rcY4yDqn/dsUa04DAAiadlmsEqaw0qesbp8sgtKaXRkfZetat27tJ2BakF+tWrVcO869ZUxjlTKNGTPGy6U0lnXr1s2TY9yb52jQ2EAZVJWZKphXAw6tZVRzDmR9jv7www+eYVYgqjViNWvW9HWQN954I79H/6WurLqolFVpfwb8XQKA2Oiel0VBSVhQWhddYhd91XRXt082wfio1CYQjFHY+GgBvrJNKivTZ5U+IfMxTduxUc8ru6TyvUMOOcRef/31SBfDyZMne3ZFrbKTWTCeWoOjE3qdZIbN0ejntI5RJ/gKmLQeR+2dEXuOqnxUYnUV1bzUWidl7RQo6eegYFSNdtS4INnnaFZFt3bXXFZ2OZ7fuwCQzFjTlEXq8iRB3f2iRYv8s7pjxfpjk9Xtk01wP6a1a9dGSnaCMTr88MNjfo9K8tq0aeMBk9pj6wo00s+5oLPbsmXLPOuhwKhChQqphkonqirV0dfVpOT++++PrGkYNmyYN4dIduXKlfOx03objWVmc1RlY0E5ZHBfJnUoi85CJbu0c1RzUL8D5LDDDku3vd7rEoyrAtcguIrVOALhNHbq5Brrb1NGv3cBINmRacqiU045xU8kdUKpE6mgw5taOwcnAbryqaYGuqFoZtsnO51M6r5VuhJ/2223+aLkSZMm+UmRFnnLBx984HX2Z555pm/fpUsXW716tZ/MqgW0rkJLMObJTnNOXQjfe+89L9cJWgirtbPmoDJJGmMF7rpCf8kll6T6fnUw0zbaD00hzAoXLuzjMHXqVLvrrrv8vkAa2+j3sdaSaE4GNwRWd71Ro0Z5e3x1zgw6ROqGrDC/tcCjjz7q81BrlHQTYJWFqZW43uMKoD766CNv/KIW4/q9oK5u6lyo7JRuR6Cb4qpcjxtbx0c3ZlbzB927qXLlyv7+1hzVujD9bg06PvK3CQBiy7eTfq1ZoivF11xzTaoyG3Uqeuutt/wEXjds/N///ucnTU899VSm28Ns+vTpvlBeHZ0CWl+jm1nKWWed5WsatPhbV5U1nrEEYw6zW2+9NdJSWIIW7Wp5rRN4Zeh0Ah8EnNGuv/56mzhxorcr5wTqHwsWLPCb20ZnNVq0aOEn/KKGDzNnzoyMmQKoyy+/PNKhTBTAarwV7MO8y5vuCxQoUqSIvfzyyx44zZo1y4N5ZZ3U1l2Bkm7EqnK8gC6s3HLLLT5fkZouHqkhiS44KUASlTaqk6NajCuQV7t2NSfRXA3ogoDuMcZtBwAgPTJNWaRyG13F140rv/32W79ar7UK+hyUNuiPvbIn8WwP83u1vPvuuz5G6ihYr149v/IZaN68uf9hVzmJMk5pMyOBYMxh3nBA7a11kqmr9a1atfIOZKJMiMYwKJFKS1egdYKv7fAPNRlRdklZY2VBtE5J8zKgsVZAGoyZ3t+6iq8PNSzRWOseOpTk/qd79+5+cv/ll1/62jkFocEJvt7rmqPB70l9Xdl6ZZ/mzp3ra3D0vQqwkJ7e7+qGqfd+QOOVkpISKb/T7wP9ztUFPGXujjzySF8nRsAEALGRaQIAAACAEDSCAAAAAIAQBE0AAAAAEIKgCQAAAABCEDQBAAAAQAiCJgAAAAAIQdAEAAAAACEImgAAAAAgBDe3BRLEyJEjbdWqVame040mS5Qo4TdH1c0pixQpkufH9ffff9szzzxjJ554ot+IOO3jzCxevNhmzpxpF110UarnFyxYYDNmzPCbcO6zzz527LHH2tFHH227y9NPP21169b11yV6nV988YU1aNAgw21yar+Z2blzpw0aNMhvjL3ffvtl6XUBAIDsI9MEJIi33nrLXn311VTP6QR74cKFdtttt1mLFi1s9erVeX5cOgad+CvwifU4zPbt2/3YFfgF/vzzT7v++uutTZs2Nm/ePNu0aZPNmTPH2rVrZ5dddpmtXbvWEsGdd95p/fv3T4j9KnjesWOH3X///Tl+PAAAIHNkmoAEUrp0aevUqVO65xVgXHjhhfb4449b7969bU8xcOBAz441a9Ys8pxewzfffGMffPCB7b///pHnb731VjvvvPM8MMiNYCUzN910U6rH69aty3SbnNpvPBRUnnnmmT5u0eMJAAByH0ETsAeoVq2al659/vnnqZ7fvHmzTZgwwVasWOFlW40aNbIDDjgg5jY//vijHXzwwXbGGWekyvzIb7/9ZlOmTLGffvrJg5w6dep4uVx2/PHHH/byyy9bt27dUj0/bdo0q169eqqASQ488EC79957bfny5Vl6jcp6NW7c2IoWLWqTJ0+2rVu3etlg7dq1U+1HJXEqCVTGpkqVKl7uWKhQoZhldK+//rofhzJlCuBatmzpJZLR27z55puWP3/+dGWHs2fP9uO4+uqrfZwz2+/XX39tv//+uwfG0b7//nsbN26cXXXVVZaSkuI/F5XnqTTy7LPP9uwTAADIG5TnAXsIlcUVLPjfdQ4FAGeddZY99dRTtn79evv444+tSZMmNn78+Mg2c+fO9ezEgAEDvOxNJ/pNmza1H374IbKNgiUFHcpgKNCZNWuWl8kpI5TdcsNt27b5MUVT4PbVV1/ZJ5984mt1oulYr7322iy9xmeffdYeeeQRu+aaazywUjnj5Zdfbk8++aR//a+//rKOHTt6WZyCQo3DQw895AGLXm/0fhRYhYneRvvq0aOHbdiwIdU2zz33nL+2IDDNbL86nl69eqX6mYgCzjFjxnjAFDjnnHNs0aJFHpQBAIC8Q6YJ2AMo+NG6n0svvdQfK1uisi9lXoYNG2bFihXz5xUMaA3RRx995F/r0qWLHXbYYd5EQFkVBSnKXCij88orr3hAcc8991jz5s3tgQceiPx/ClL0PVp7tKvNJyZOnOgZq7RZrdtvv93atm1rN954o5UpU8YzPvXq1bOTTz7ZDjrooMh28bxGZadkyZIl9u6771qpUqX8sTJRQ4YMsfbt23vmR0HWiBEjItkzBVjK+vzyyy9WsmTJdMeuoFGBj9ZfxSqXlFatWnkw+uGHH0ayTQrspk6d6scXS6z9nnvuuR6gjh492m655RZ/TsGm9qufVbTKlStbuXLlPPN26qmnxv2zAAAA2UOmCUggOulW2Vbw8cQTT1jXrl3tyiuv9MBCQVBQ4qasioKCIJgI1r3ohFxZIzVq0DYKEIIyNJV0KWg54YQTPGBSWdjFF1/sQYwo86L1RsqibNmyJVuNJ7SfqlWrpnv+qKOOsrFjx1rnzp09uFGwoMBNQUCHDh3s559/jvs1Bk477bRIwCTHHHOMl/UpKAqCPv0/6tQn+n8VtCgI2VUKRmvVqmXvvfde5DkdkzKCatoRLx1Lw4YNPegLMm+TJk3yDJYCqrQ0phpbAACQd8g0AQkcQL3zzjtWvHhxb6igoElraII23qKyr+DfgQIFCvhz+j7RWpxoOtHXhyiLo6YCWnfz5ZdfepCkTIY+RIHVrlDApQBMjS1i0f+rTJM+1BhBr0PBx6effmpLly71ACKe1xi9v2iFCxeOHL/WEykoVGfC4cOH++NTTjnFS92iM1u7Qtkmlej9+uuvnjXTcSsASruuLDNaq6QgTmWL9evX9/1oTVban51oTOfPn5+t4wYAAFlDpglIwO55+lAJndYFKXMxdOhQ/xwIgpnoDExA63d04q7ytswoq3PFFVd4AKKudSotUymbgoHsCIK76GMOyuiUQQuySdGBm9b+6HVrbc/06dPjeo2BjJoiBJmbu+++29cBPfjggx7QaN2R1kYpm5UdKmvUOjNlmNRoQ00dYmWHMqNMmdYuKUhWsKnSRq25ikXjEowvAADIG2SagASmTEO/fv2sdevWvr5Ia2hUahdkIHSyHX2jVXWOe+GFF/wEPFiro25tlSpVShW4vP/++17yp+5symgNHjzYO9oF0t5kN6uU6dExpG2vrSBGWS0FSgrW0jr++OMj28XzGrNC3frU0lwf6haoDnSvvfZahjeqjac7nW7Kq26EWn+k4woeh4m1X42XSvqUYVKXRAWbGbUV15hmN0MGAACyhsuVQIJTOdkNN9zgWSA1aBBlWdQEQUGU2ldHd1xTS2qdvKvtdtmyZT1LFV1mp4Bj1KhRqQKr6A5wCqKU4ZLofWdVjRo1vPtdNK0h0rEr06PgLZqOUSV0Kg3UscfzGuOhrJW2V3OF6CBFgVnQSCIWbRNPeaKCMHUc1JgpEMuscUZG+1WJnoI5df0LMk+xfPfddz62AAAg75BpAvYAapCg1uAvvviiBxPKyChjo2BKpXR6Ts0bVNbVvXt3O/LII/37lKVShkrNHvQ9asc9b948e/755z3joZN8dZlT1zZlOlTSp7beykxpfyqj0z2NdoUyLroRrxoyRJfYqVPcHXfc4WVsWlt0+OGH+zZ6fVqrpPVbwZqkeF5jZhSEvf32255VU6c+vW6V6iko0biG3RtL49SzZ08/Tn3Eoq5/ymItW7bM+vTpk+nxZLRfZfr0NQWaGZX4qYxS687StnEHAAC5K9/OtDdKAbBbjBw50hsoqGwuFq2ZUYZI9zkKWlxv2rTJgwh9TSVvDRo0iDRxCGiNjBosKAAKbm4b3WZbGRgFSitXrvTMi5pEVKxY0bNBahmuTnvK1KiMTRkglY5FP86IOvPp/9J6ogsuuCDd15VpmjFjhpebKTujgEH7i74XVTyvUYGVmmSogUJ0cKF1RrpfkwIajasyderGp6yVAjUFK0FwFuwnuAmtKIBUcwqNm7ZVUJN2m4Dan2stlgLUtOLZb0Bt39VZUEFd9LEF+vbt6z9LfT/rmgAAyDsETQByjYIrneQr04NwCl4VZOpeXOoqmJYCv0aNGnmDEGUIAQBA3mFNE4Bcc+2113pmRw0OEJvuJfXII494sw/dCDi4Z1ZaWotWs2ZNAiYAAHYDgiYAuUZld2psoDVLiG3ffff1skitKdN9pBQ4paUq6qJFi1qvXr0YRgAAdgPK8wAAAAAgBJkmAAAAAAhB0AQAAAAAIQiaAAAAACAEQRMAAAAAhCBoAgAAAIAQBE0AAAAAEIKgCQAAAABCEDQBAAAAQAiCJgAAAACwjP0fjlKyoubl950AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Saving Metric Summaries...\n", + "INFO: Generating Metric Boxplots...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAKQCAYAAABNdHpqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAVSRJREFUeJzt3QmcjXX///HPMGMW+zJj3yfZJhUlOymliKRUstzclm5Rlkoi2pHU7SZSClnuO6SQUMlaRCXbEEW27LsZu//j8+13nb9hhjPnXGe+c2Zez8djHufMOde55prLZc77fJfPN+TSpUuXBAAAwJIstn4wAACAIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsCrU7o9P33755RfRmnBhYWG2DwUAgKBy7tw5CQkJkVtuueW629Iycg0aRChQm3p6zs6ePcu5Q8BxrSGtcK0F9j2UlpFrcFpE4uLifPhnyLwSEhIkPj5eYmNjJSoqyvbhIAPjWgPXWvq1bt06r7elZQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgVboqenbx4kXJksX7fKSV3bTU7JWSq/6ZNWtWCQ1NV78uAABILy0jH3zwgdSoUUMqVqwozZs3lzVr1qS47alTp2TQoEFm+8qVK8v9998v8+bNS7JNnTp15KabbkryNXDgwDT4TQAAQNCFkVmzZsmwYcPk8OHDpjVDy4h37tzZfJ+coUOHytSpU83zFy5ckK1bt0qvXr08ZWf37t0rR48eNS0s2bJl83zRKgIAQPpkPYxMnDjR3Pbs2VNWrVpl1oE5duyYzJ49O9ntly1bZm4//vhjWb9+vbRo0cKEku+//948vmnTJnOrj69du9aEFP16+eWX0+x3AgAAQRJGdGzHxo0bzf0HH3xQcuXKJY0bNzbfp9RVU6hQIU93zcmTJyUxMTHJ404Y+fHHH033TPXq1WX06NFp8vsAAIDUszqic//+/aZVQ0VHR5vb/Pnze7pbkqPjRbp37y5PPfWU5zENMk2aNDH3tZtH7dixwwxu1S6bd999V/LlyyetWrVK9TFq15GuDArvOQHRuQUChWsNaYVrLfVSmmSS7sLImTNnPDNdnFk0ztgO57kr7d69Ww4ePGju6y/pjDM5dOiQxMTESM6cOU0ryQsvvCANGjSQESNGyIcffihjx471KYycO3fOE3CQOtu3b+eUIU1wrSGtcK2ljo7ZTPdhxDlIbR1xpvXqm7+KiIhItlunb9++pqVi/PjxUrVqVTOg9ZNPPpG33nrLfL322mtJXtOhQwcTRjTEaLKNjIxM1TGGhYVJbGysX79nZqPnWf/DlipVKtXnG+BaQ3rE37XU0wkm3rIaRgoWLGgCiAaRAwcOmO/37dtnnitcuPBV2+/atUuOHDliWj50aq9q2rSpCSM69kRbU1q2bGm2W7p0qeTIkcMEGKf1RYNFamnrS1RUlN+/a2akQYRzB641ZCT8XfOet1001gewastIhQoVzP1JkyaZ1ou5c+ea77XVQ2lLiYYMDSx58uQxv5wGljlz5phgMm3aNLNdkSJFJDw83IQObTnRcSLadTNq1Cjz/M0338z0XgAA0iHrJUnbtWsnzz33nBnToV/OYFZt8VBdu3Y103mHDx9uCpw1a9ZMPv/8c+ndu3eS/bRv397cPv300+Y12lqiX0oDyjPPPJPmv1tGsvfQKTmZ+HcX2vWcPn1a/vjrtITnPi4REX+3TF1PjsgwKZQ/u59HCQAIRtbDiIYLbfkYN26cGZiqVVj79+9vBqIq7VrRFhRngOurr74qZcqUkS+++MK0fOi4hC5dukitWrXM8zpodeTIkTJmzBgzo0af19k3t912m9XfM5gdO3lGurz5jVxMWmH/+r77e6CxN7JkCZGJA++R3DnCU318AIDgFnLpykVc4OFUddVCbJldalpGft95SEZOXy9PtawsZYv/PVX7emgZgS+0S1Znu2l3L+OTEEhca4F9D7XeMoLgkJouFO2mUUWjs0tssTwBPCoAQEZgvRw8AADI3AgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrQiUdOHPmjCxevFgOHTokFStWlCpVqlxz+2PHjsnKlSvl6NGjUqZMGalWrZpf+wMAAJk4jBw5ckSeeOIJ2bp1q+exdu3aSb9+/ZLd/tdff5XOnTubIOKoXbu2vP/++xIaGprq/QEAgEzeTTNq1CgTHAoXLiz333+/CRQTJkwwoSM5Q4cONUGkUqVK8sgjj0iuXLlk2bJlMmfOHJ/2BwAAMnkYmTdvnidkDB8+XB588MEkj19pz5495nbs2LHy6quvSqdOnZI8ntr9AQCATBxGtEvlwIED5r6O7VCVK1c2t1u2bEn2NXfddZe5HTBggIwZM0amTp0qYWFh0qBBA5/2BwAAMvGYEWfcR0hIiOTIkcPcz549u2eQanL69OljulwWLlxovlTv3r2lQoUKsm3btlTv73ouXbokCQkJPr02s9IBxM4t5w6BlJiYmOQW4FpLP/T9U9+P030Y0QNVyR2s89yVXn75ZRNGNHzouJEFCxaY7hidVaNfqd3f9Zw7d07i4+N9em1mtefw2f/fdXb6oO3DQSawfft224eATIJrLXWyZcuW/sOI03px8eJF8yk6PDxcTp06ZR7TgalX0m6YmTNnSs6cOU33TGRkpOme6datm3z00Ufy7rvvpmp/3tAuoNjYWD9+y0xom3aV7ZciRYpIhdLRto8GGZi2iOibQ6lSpczfA4BrLf24fFZrug4j0dHRphtFA8Nvv/0mcXFxnoN3Wjkud/jwYRM0smTJIlmzZjWPRUREmFvtDkjt/ryhrSxRUVF+/JaZj4ZA55Zzh7SgQYRrDVxr6Yu3XTTWw4geaN26deWrr76S/v37m/szZswwzzVs2NDcfvPNN7Jr1y6pV6+eFC9eXPLkyWPGmnTt2lVuu+02mT59utnu5ptv9mp/AAAgfbFe9KxXr16yatUq2bRpk/lS9957r9SoUcPc1+4YrSOirR6lS5eW1157zQxiXb58uflSJUuWlB49eni1PwAAkL5YDyMlSpSQ2bNny6xZs8y0XB2UquHBcffdd5suFg0izvc6aHX+/Pmm3Lv2FTdu3NjTXXO9/QEAgPTFehhR+fLlk/bt2yf73KOPPnrVYwULFpS2bdv6tD8AAJC+WK/ACgAAMjfCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsCrU7o8HkBks2/CH/HnwgFfb7j+SIIlnznu17YXz5+TEiZOSc9M+yRoa5tVrIsNDJSZvlFfbliwQLbUrlfFqWwC+I4wACKid+07I2/M/k7CivwfmL1jeVL7mjIjs9W7Tcz+VlZIFukjxgjl9OToAXiKMAAgofSPvfU+LwLaM5MwRmJaRytEEESANEEYABJx2ddQW97s7EhISJD4+XipUqCBRUd4FDADpDwNYAQCAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVqWLhfKWL18u48ePl0OHDknFihWle/fuUrBgwau227lzpzz55JPJ7kO3HzdunLnfpk0bOXLkSJLnGzVqJD169AjQbwAAAII2jKxevVo6deokFy5cMN9v2LBBVq1aJbNnz5Zs2bIl2fbs2bOyZcuWFFfvVBpCfvzxx6uer1KlSkCOHwAABHkYGT16tAkizZo1kwcffFBefPFF2b59u8ydO1eaN2+eZNvixYubkHK5F154QdavXy/169c332/atMncNmjQQHr16uXZLnfu3Gny+wAAgCAaM6IhxGnF6Natm9SoUUNatGhhvl+5cuVV22tLSbly5Txfv/32mwkicXFx0q9fP7PN5s2bze3x48flpZdekiFDhshff/2VbLcPAADI5C0j+/fvN10vqkiRIklud+3adc3X6usGDx4sWbJkkddee01CQ0OTtIz89NNPScakfPjhh1K7du2A/S4AACAIw4gzziNr1qwSFhZm7jvjRE6dOnXN12p3zYEDB6Rx48ZSvnx5z+NOiNFxKNpVoyFk4cKFMnz4cJ/CyKVLlzzHCe+cOXPGc8u5QyAlJiYmuQW41tIPff8MCQlJ/2HECSDaXeMc9Pnz581jVw5evdLkyZPNbdu2bZM8PmnSJDl48KAUKFDAfK/dMxpGtPvm3Llznp/pLX1NfHx8ql6T2e05/Hdr1549e0ROH7R9OMgEdJwZwLWW/lzvvTxdhJF8+fJ57h89elTy5s1rblV0dPQ1u3d01k2hQoXklltu8Tyun8R1nMju3bvl448/NsEjKirKE3j0K7VhRLePjY314bfLxLYd0H8l0+VWoXTK/46Av7RFRINIqVKlJDIykhOKgOFaS72tW7d6va3VMJIjRw4pUaKE7NixQxYvXmxm1CxdutQ8p4NSU6JjQJQOeL28CSg8PNxMFdaumhkzZsijjz4qX3zxhXmubNmyEhERkepj1P07gQbe0X8H55Zzh7SgQYRrDVxr6Yu3XTTpogKrM3umb9++UrNmTVm2bJkJDU2bNjWPa0tHkyZNZMmSJZ7XOLVGKleufNX+2rdvb24HDRpkpvvqIFfVuXPnNPl9AABA6lgPIzrQtFWrVmZWzOHDhyVPnjzy1ltvSeHChc3z2uWi4ePEiROe1+zbt8/cJjddt3Xr1tK1a1czu0an9Oqnpd69e5tWFwAAkP6EXNKRo+mA1gXRMKLjDC4f8KJhRGfWaDjJmTNnkseKFSuWYtOsTv3du3evxMTE+NQ9o9atW3fdLiNcbf3WvfLC6JXy5pPVpXJsIU4RAkZna+kA8woVKtBNg4DiWgvse6j1CqyOXLlyma8rFS1a1KvHrqSBRsejAACA9M16Nw0AAMjcCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACr0s2qvUh7ew6clIQz513f7+4Dpzy3ERFHXd9/VHioFInO4fp+AQB2EEYycRDpMvjbgP6MkdPXB2zf7/dtSCABgAyCMJJJOS0ivR+/VYoVzOnqvk+fPi3xm3+XCjeWlYiICFf3vWvfCXl7ys8BadEBANhBGMnkNIjEFsvj6j4TEhLkzLEIKVMkl0RFRbm6bwBAxsMAVgAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWhkk7s2bNHDh06JKVLl5YcOXIku83p06dl/fr1yT4XHh4ucXFxqdofAACwz3oYOXv2rDz77LMyb948831kZKQMGDBAHnrooau23b17t7Ru3TrZ/RQtWlQWLlyYqv0BAAD7rHfTjB8/3gSHsLAwKVmypCQmJsrAgQNlx44dV22rweLWW29N8hUTE2Oe09endn8AAMA+62FkxowZ5nbo0KGyYMECadCggZw7d05mzZp11bZFihSRqVOner7Gjh1rHs+aNasMGjQo1fsDAACZPIycPHlStm/fbu7XqFHD3NaqVcvcbty48bqv18Cxf/9+ad++vXm9v/sDAACZbMzI4cOHzW1ISIjkyZPH3M+VK1eS51Kya9cu0wqSP39+6d69u9/7S8mlS5ckISFBMhodDOzcuv37adfY5bfBctwIPoG81gCuNf/o+6e+H6f7MKLdJypLliyeA9YuF6UDUa9lwoQJcuHCBdMqomNJ/N3ftY4xPj5eMpo9h/8+H9u2bZMzx7IF5Gc4rVTBdtwIPoG41gCuNf9ly5Yt/YeRqKgoc6uhQt/0ddCp88k3e/bsKb7u4sWLZgyIho7mzZv7vb9r0X3ExsZKRhO+57iI7DdTn8sU+bv1yC36KVXfHEqVKuUJisFw3Ag+gbzWAK41/2zdutXrba2GEZ0Jo2/2Ghy020XfYHbu3GmeK1GiRIqv01ojR48elVtuucUzm8af/V2LtrA4IScjiYj4u4UhIiIiYL+fvjm4ve+0OG4En0BcawDXmn+87aKxPoBVu1CqVq1q7g8fPlzmz58vn332WZKBp1u2bJHVq1cnGfOxcuVKc6tTe1O7PwAAkL5Yn9qrg0+1NUOn4fbo0cPMjqlYsaI0atTIPD948GBT6OyHH35IUl1VlStXLtX7AwAA6Yv1CqzVqlWTyZMny8SJE+XgwYMmOHTp0kVCQ0M9gUNnTeTLl8/zGp0ho60iWtQstfsDAADpS7p4h65SpYq8/fbbyT73/PPPX/VYz549fd4fAABIX6x30wAAgMyNMAIAAKwijAAAAKsIIwAAwCrCCAAACL4wMnLkSFOITBfBAQAASPMwsmzZMlOI7K677pJ///vfLFIFAADSNoxMnTrVFBarU6eOTJkyRe655x5p1aqVeUzXjAEAAAhoGNHFb7TS6aBBg0wryZgxY6Ro0aIyZMgQqV27tnTr1k0WLVpENw4AAAh8BVZdB6Z+/fqmRHt4eLhZmO6bb74xX5UqVZKhQ4dKbGysvz8GAABkUH6FkW3btsnnn38us2fPlt27d0v+/Pmlffv20qJFC7OC7ujRo6Vz587y9ddfm+8BAABcCSPa+vG///1P1qxZY1pG6tatK/369TMtJJcvSDds2DC5/fbb5cCBA1KoUCFffhQAAMjgfAoj2uIRFRUlL7zwgjzwwANJVtS9cmxJ48aNU3weAADApzDy4YcfSsmSJb3a9pVXXuEsAwAAd2fTvP3227J3795knzt16pQ0atRIDh8+7MuuAQBAJuN1y8jPP/8sp0+fNvd/+eUXWbFihcTExFy13ZEjR2TPnj1y7tw5d48UAABk7jCycuVKeffddz3fP//88yluq4NWCxYs6P/RAQCADM/rMNKxY0epUaOGuf/000+bwatXzpDJkiWLZM+eXUqVKuX+kQIAgMwdRrJlyyY333yzuf/mm2+a+zqjBgAAIE3CyIULFzyFy6pXr25KvZ8/fz7lHV9WbwQAACAlXieGe++91zOlV+/v2LHjmtsvWLDA6+m/AAAg8/I6jGiZ9zx58njuHzt27JrbO9sCAAC4EkZat26d7H0AAIA0L3qmEhISZPr06UmKm40YMULWrVvn1wEBAIDMxacwogHk4YcflpdeekkSExM9j69evVoee+wxWbx4sZvHCAAAMjCfwsh7770nefPmNaGjaNGinscnTpwozz77rLzxxhtuHiMAAMjAfAojWg5eQ0d0dPRVz7Vt29aUhNcvAACAgI0ZOXnyZIr1SM6ePSsXL170ddcAACAT8SmM6Nozuk7NlSvzaiG04cOHmzLx+fPnd+sYAQBABuZTmdR//vOfMm/ePGnYsKFUrVrVdNdoa8jatWvNir1jxoxx/0gBAECG5FPLiLZ6fPbZZ2bmzP79+2XRokVmHEnFihVl6tSpUqdOHfePFAAAZEg+LyCjs2mee+458wUAAJCmC+XpfR0fcs0ds1AeAADwAgvlAQAAq1goDwAABEcYOX78uJw5c8bcb9KkieTMmVOyZPG5TAkAAIDhdZqYPXu2HDt2zNxv2bKl7Ny509uXAgAA+N8ykjt3bhk1apTUr1/frNj77bffXrOw2V133SXZs2f3dvcAACCT8jqM/OMf/5DevXvLV199Zb4fMmTINbdfsGABYQQAALgXRho1aiQrV640C+C1adNGBg8eLEWKFElxey0JDwAA4GrRs6ioKPP15JNPSvny5SVXrlypeTkAAIA7Rc9atGhhip6dP38+xe0pegYAAIKm6Nnu3btl+vTpcujQIbO+jYadbNmypbi9Lsr3xRdfyPr166VAgQJmdk/hwoU9z2sX0tGjR5O85rbbbpOHHnrIq+MBAACZqOjZn3/+KQ8//HCS/X399dcybty4ZLc/efKktGvXzgQRx4QJE2TGjBkm/OhMH/3+4sWLSV6nrTqEEQAAgjiMtG7dOtn7/hoxYoQJIrfccovceeedMnbsWFm2bJlZCVinEV9p9OjRJogULVpU2rZta6YY//jjj6bV5tVXX5XffvvNBJGbbrrJrCrsKFWqlGvHDAAA0sGqvdoCMXfuXBMg8uXL5wkWDRo0kLi4OK/3s3jxYnP70ksvmS4ana3z0UcfpRhG5syZY25ffvllqVOnjjzwwAPy888/S/Hixc3jmzZtMrfabbNx40YzvVi7cZznAQBABggjhw8fNtN7t23bJjVq1PA8vnr1atOyocXR6tWrd939HDhwQE6cOGHuly1b1tyWKVPG3G7fvj3ZkvR79+4193PkyCFvvfWWRERESPPmza8KI/Pnz/e8btKkSfLf//5XbrjhBl9+XQAAkN7CyHvvvSd58+aV8ePHS3R0tOfxiRMnmvEab7zxhldhxAkiusZNeHi4uR8ZGZnkucs540pCQkJMEbbExETz/ccff2x+duXKlT1hpHbt2lK3bl0zMFa7bnRQa0rjUK5FZw1pK1BGc/r0ac+t27+f8+/i3AbLcSP4BPJaA7jW/KPvn/p+HbAw8ssvv5hulcuDiEPHcWjLiHa3aGC5Fucg9YAdzsBTZxpxcnR7bUnRWTc62PWHH34wFWE/+eQTGTZsmGzdutV04eg+qlevLs2aNZNVq1aZfad2cb9z585JfHy8ZDR7Dp81t9q6deZYyjOX/JFc61YwHDeCTyCuNYBrzX/XmhnrypgRndWSUj0SnXp75WyWa8240XCh+9OuF6dFJLkgc/ljOmZEW0IaN25suop0UKv+3O+++85MFXZaZpwpv7risH56Su16OWFhYRIbGysZTfie4yKyX0qXLi1lirhbvE7Ps7456KBhp6UrGI4bwSeQ1xrAteYfbRjwlk9h5Pbbb5d3331XKlSo4Bm86oSK4cOHm1Lw11pE7/JwodtpfZFff/1VatWqZW7VjTfeeNX2GlZ0+q5OB9ZVgzWMnDp1yjynIUMTmHYh6ZgW7aKpWbOmaRFRMTExPq2Vo603WnU2o4mI+LuFQcfcBOr30zcHt/edFseN4BOIaw3gWvOPt100PoeRf/7znzJv3jxp2LChVK1a1XTXaKvE2rVrZc+ePTJmzBiv96UF1CZPnix9+vSRSpUqyfLly80vcN9995nndWaNjvnQabpVqlQxtUI08PTt29cs2ufUG3Fm3uhgVn1N9+7dTYuJ7s/t6cgAAMA9qRtA8X+0NeOzzz4zAWH//v1mGq6OI9GpuVOnTjXjNbzVo0cPMxVYWzOWLl1qWleeeuops/aN0jAxc+ZM2bVrl/m+Q4cOJqjoAEadMaNdMtWqVTNhRmkI0cGr2u2j40l0kOM999wjHTt29OVXBQAAAebzmBHtYnnuuefk6aefNt0s2g2ig0NTO0BUx43873//M90pBw8eNF0/zjRfJ3zcf//9poiZM4bjnXfekU6dOpm+4mLFipkw4zQHaVOtFkDbsGGDKVmvfckakgAAQAYLI1u2bDHTZVesWGEWzNO1aJ5//nnTCqHTblNDZ73ccccdyT6n40iSowEjpZChwUTHk+gXAADIgN002iKhXTR//fWXmcrrzIrRMR06tVbrfgAAAAQsjLz//vtmtoqWZtfWkFy5/p5i+cILL5hZNqkZwAoAADI3n8KIzmDRAaHJjQ+5++67TbeLlnoHAAAISBjRQaQ62DQ5WlxM15AJDfV5OAoAAMhEfAojWr9DB69q4bErS6e//vrrpjrm9UrBAwAA+FX0TGfPaCl2HbSqrSQaTrQ4ma6qqyv3AgAABKxlRFs9Pv30U0/RM12HRoue3XDDDaaaakrTcQEAAFwtevbiiy+aCqpa9Exn1Fy+Tg0AAEBAw8jq1atNTZE1a9aYEu5KW0a6detmum8AAAACFkZ0ZV2tslqmTBnTMqIL5R05csQElGeeecbMqNEF6wAAAAISRnTtF11td+jQoUmWCO7cubNMmzZN3n77bWnWrFmqlg8GAACZk08DWLdt2yZt2rRJNmy0bNnStIzowFYAAICAhBHtltGF8pJz7NgxOXv2rOTMmdOXXQMAgEwmi691RrSLZubMmabQmWPr1q1mAOvDDz8sUVFRbh4nAADIoHwaM6IL4SUkJEjfvn3N9N4CBQrIyZMn5dSpU+Z5Hcg6ceJEz/ZaIK1kyZLuHTUAAMjcYUQHr2pJeG/lyZPHlx8DAAAyAZ/CSOvWrd0/EgAAkCmlaszIhQsX5Ouvvzar8jpOnDghr732mrRo0UK6d+8u8fHxgThOAACQ2cOIDlTt0KGDPPXUU6bAmdLKq08++aR88sknJqhs377drFezcePGQB4zAADIjGHkiy++MLNldEXeYsWKmccWL14sq1atkoceesg8P3v2bBNGhg8fHshjBgAAmTGMLFy4UJ5++mmpV6+eZM2a1TNLRmnriONf//qXCShaawQAAMC1MLJz506pXLlyksdWrFghsbGxUrx4cc9jWuxMZ8/oSr4AAACuDmC9vPy7hpPdu3cnO8VX641ERESkZtcAACCT8jqM6DiR9evXe77/9ttvzW3t2rWTbKcFz7Qbh9oiAADA1TojjRs3NiXg8+bNa8KGrtwbExMjtWrV8myzb98+efnll6VRo0as2AsAANwNI02bNpUlS5aYtWdUeHi4jBo1SsLCwsz3vXv3NgNaNaD06NHD290CAIBMLjQ140WGDRsm7dq1M+NFqlatKgULFvQ8f/78eWnTpo1ZRC9fvnyBOl4AAJDZy8HHxcWZryv9+9//duuYAABAJpKq2TQAAABuI4wAAIDgW7UXGUTYaVn5+2bZfTLHdTc9euKMnDl7wavdnjt/Tg7s3y+bTp6RsNC/BzhfT3i2rJInZ/h1t9t/KMEcNwAg4yCMZFIXL16S0Jid8sXeRSJ7A/RDArTf0JiyEhXOpQsAGQV/0TOpciXySv8HHpaT5096tb0vLSPRMTGut4yomFp5pUj09VtzAADBgTCSiVWNLRmQ/SYkJEh8fLxUqFBBoqKiAvIzAAAZBwNYAQCAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFiVrsLIxYsXXd0+tfsDAACZNIx88MEHUqNGDalYsaI0b95c1qxZc83tV65cKS1atJBKlSpJrVq1zOv92R8AAMjEYWTWrFkybNgwOXz4sFy6dMlU7uzcubP5Pjlr166Vjh07yoYNG0zLx8GDB83r58yZ49P+AABAJg8jEydONLc9e/aUVatWSVxcnBw7dkxmz56d7PYjR46Uc+fOyYMPPmhaPPr37y8FChTwtH6kdn8AACATh5GzZ8/Kxo0bzX0NF7ly5ZLGjRub75PrWtGWEO2iUZ06dZKIiAhp06aNLF++3ISS1O4PAABk8oXy9u/fLxcu/L0SbHR0tLnNnz+/ud279+r15w8cOCCnT5+WkJAQmT59ukybNk3Cw8OldevW0rVr11Tvzxva1aMLv8F7iYmJSW6BQOFaQ1rhWvPt/VPfr9N9GDlz5oy5zZo1q2TJ8ncjTWhoaJLnkrsY9Bf86KOPzC954sQJ+fe//y2RkZFSt27dVO3PG9olpONOkHrbt2/ntCFNcK0hrXCtpU62bNnSfxhxDlJbM7QLRgOEvvkr7YK50uWPde/e3bSGzJw503TRTJkyRe66665U7c8bYWFhEhsb69NrMysNjfoftlSpUiYkAlxrCHb8XUu9rVu3er2t1TBSsGBBExg0OGgXjH6/b98+81zhwoWv2l4HqmqA0bEhGjy01aNJkyYmjGg3TGr35w1tfYmKivLzN82cNIhw7sC1hoyEv2ve87aLxvoAVg0WFSpUMPcnTZoku3fvlrlz55rvq1atam61ZUO7WDRgaPioVq2aZ9aMTtd1Zsnop3Bv9gcAANIX61N727VrZ27Hjh0rd955p2zevNkMPm3atKl5XLtibrrpJvnqq6/M9926dTOhZMaMGaaw2YABA8zjWnvEm/0BAID0xWo3jWrWrJlp+Rg3bpwpYKZVU7XbJWfOnJ4xG9ri4QxI1ZYRDRrvvvuuGZdQvHhxE0B0P97sDwAApC8hl3RqCpK1bt06c6uF0+A9nQqtM5C0y4wxIwgkrjWkFa61wL6HWu+mAQAAmRthBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYFSrpwJkzZ2Tx4sVy6NAhqVixolSpUuWa28+YMUNOnDiR5LFy5cpJzZo1vXoeAACkH9bDyJEjR+SJJ56QrVu3eh5r166d9OvXL9ntz549KwMHDpRz584lebxly5YmbFzveQAAkL5YDyOjRo0yQaRw4cJy6623yvz582XChAly//33J9tC8scff5igUaJECalfv77n8VtuucWr5wEAQPpiPYzMmzfP3A4dOlRuv/126d+/v0ybNs08nlwY2bRpk7m94447pHz58pI9e3YTOiIiIrx6HgAApC+htrtoDhw4YO7rWBFVuXJlE0a2bNmS7Gvi4+PN7aeffmq+VKlSpWTSpEkSHR193ecBAED6YjWMHD161NyGhIRIjhw5zH1tyVDHjh1L9jVOy4d2w1SrVk0WLlwo27dvl2HDhsmQIUOu+3xqXbp0SRISEnz+HTOjxMTEJLcA1xqCHX/XxKf3T31/T/dhRA9UJXewznNX6tChg+mC0UGvOXPmlBUrVpgBr19//bUJG9d7PrV0/InT2oLU0RAIpAWuNaQVrrXUyZYtW/oPI05ryMWLF8303vDwcDl16pR5LFeuXFdtf/78edNyooNdNWhc3r2jr9OWlms9f/LkSc/P9FZYWJjExsb6+Ztmvk8Q+h9Wu8ciIyNtHw4yMK41cK2lX5fPkk3XYUTHcGh40KDw22+/SVxcnOfgy5Qpk+xrOnXqZLpNKlSoIDfeeKNnew0fGjSu93xqaatNVFSUX79nZqVBhHMHrjVkJPxd8563XTTWK7DqgdatW9fc11k0b7/9tilYpho2bGhuv/nmGxk/frxs27ZNQkNDPY/36NFDRo4cKc8++6z5vnnz5td9HgAApD/Wp/b26tVLVq1aZQaeOoNP7733XqlRo4a5P3XqVFm2bJlpRSldurQ899xzsmbNGtMN8J///MdTXbV79+7m/vWeBwAA6Yv1MKKzXmbPni2zZs0y03wrVapkwojj7rvvNl02GkRUTEyMfPHFFzJ37lzZsWOHGZegBdKcOiLXex4AAKQv1sOIypcvn7Rv3z7Z5x599NGrHtNxJg8//HCK+7ve8wAAIP1g1V4AAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYFW6mE0DAEBa23volJxMPOfVtqdPn5Y//jot4bmPS0TEWa9ekyMyTArl/3vxV1wbYQQAkOkcO3lGurz5jVxMfk3WlH130OtNs2QJkYkD75HcOcJTfXyZDWEEAJDpaEB4/4W7vG4Z+X3nIRk5fb081bKylC2e3+uWEYKIdwgjAIBMKTVdKNpNo4pGZ5fYYnkCeFSZEwNYAQCAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWhkg4sX75cxo8fL4cOHZKKFStK9+7dpWDBgilu36ZNGzly5EiSxxo1aiQ9evTwaX8AACATh5HVq1dLp06d5MKFC+b7DRs2yKpVq2T27NmSLVu2q7bXEPLjjz9e9XiVKlV82h8AAMjk3TSjR482waFZs2amNaNo0aKyfft2mTt3brLbb9q0ydw2aNDABAzny2kVSe3+AABAJg4jGhqcVo5u3bpJjRo1pEWLFub7lStXJvuazZs3m9vjx4/LSy+9JEOGDJG//vrLdMP4sj8AAJCJu2n2798vZ8+eNfeLFCmS5HbXrl3XbBn56aefPI/pGJEPP/xQypYtm+r9AQCATBxGEhISzG3WrFklLCzM3HfGdZw6dSrZ1zihQseFaFeNhpCFCxfK8OHD5a233kr1/q7n0qVLnuOEdxITE5PcAoHCtYYr/XXolCSe+XvMoJu27T6S5NZtkeFZpXD+7JKR6PtnSEhI+g8jTmDQ7hXnoM+fP28eS2mw6aRJk+TgwYNSoEAB8712z2gYcbpvUru/6zl37pzEx8f79NrMTsfqAFxrSCuHjp+T/8zZF9CfMXbWbwHbd/cmBSV/rr/fFzMKb997rYaRfPnyee4fPXpU8ubNa25VdHT0VdufOXPGjBPZvXu3fPzxxybMREVFeQJInjx5UrU/b+jPiI2N9em1mfnTqgaRUqVKSWRkpO3DQQbGtYbL/bHnuIjsk6daVpai0e62Muj7zx/bd0mZUsUkPDzc1X3vPnBKRk5fL0WKl5IyRXJJRrF161avt7UaRnLkyCElSpSQHTt2yOLFi80MmKVLl5rn4uLirtpeLwCduqtdNTNmzJBHH31UvvjiC/OcjhfJnz9/qvbnDW1dcQIPUkeDCOcOaYFrDSoi4u8xg2WL55fYYv//w6kbTHf96YNSoXS063/XIiL+/tAcERGRof5mettFky6m9jqzXfr27Ss1a9aUZcuWmX+Qpk2bmse1JaRJkyayZMkS83379u3N7aBBg6R+/foyePBg833nzp292h8AAEhfrIcRHYjaqlUryZIlixw+fNh0tehA1MKFC5vntUtmy5YtcuLECfN969atpWvXrhIaGmqm9GqK7N27t2kF8WZ/AAAgfbFegVVDxSuvvCJ9+vQx4UGn4l4+4EWf05kwTpjQkNGzZ09TR2Tv3r0SExNjWj683R8AAEhfrIcRR65cuczXlbSCanI0YOj4kNTuDwAApC/Wu2kAAEDmRhgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVoXa/fEAALgo7LSs/H2z7D6Z47qbHj1xRs6cveDVbs+dPycH9u+XTSfPSFhomFevCc+WVfLkDL/udvsPJZjjzswIIwCADOHixUsSGrNTvti7SGRvgH5IgPYbGlNWosIz71ty5v3NAQAZSrkSeaX/Aw/LyfMnvdrel5aR6JgY11tGVEytvFIk+vqtORkVYQQAkGFUjS0ZkP0mJCRIfHy8VKhQQaKiogLyMzIzBrACAACrCCMAAMAqwggAALAq3YwZ2bNnjxw6dEhKly4tOXJ4P4hnzZo1kjVrVomLi/M8tn79ejl9Ouk0qejoaClZMjB9iQAAIIjDyNmzZ+XZZ5+VefPmme8jIyNlwIAB8tBDD133tXPmzJHevXtL0aJFZeHCheaxixcvSps2bcxgo8u1bNlSXn/99QD9FgAAIGjDyPjx400QCQsLkyJFisiff/4pAwcOlNtuu01KlCiR4uu0FeXVV1+96nF9vQaR3LlzS9myZT2P0yoCAED6ZD2MzJgxw9wOHTpU7rvvPunatat89913MmvWLHnqqadSfN3LL78sR48everxTZs2mdsHHnhAHn74YTMFq3jx4gH8DQAAQNAOYD158qRs377d3K9Ro4a5rVWrlrnduHFjiq+bO3euzJ8/X+rXr59iGJk+fboJJHfddZd069btqjEkAAAgfbDaMnL48GFzGxISInny5DH3c+XKleS55F7zyiuvSLFixaRPnz6yaNGiJM9v3rzZ3J4/f17KlSsnW7dulW+++UZGjx4tPXv2TPUxXrp06arxJ7i2xMTEJLdAoHCtIa1wrYlP75/6/p7uw8i5c+fMbZYsWTwHrDNjnIGtyRk0aJDpnnn33XfNYNcr3X777WYfGlR0Zs7MmTOlb9++8umnn/oURvQYteoeUs9p9QICjWsNaYVrLXWyZcuW/sOIU1L3woUL5k1fB7E63SnZs2e/antt4dDumTvuuENCQ0PNFF4nuKxevdqU6X3sscekXr16JoioBg0aeFpUtFsoNdOGlR5TbGys379rZvsEof9hS5UqlWxgBLjWEGz4u5Z62jPhLathJEYXHAoLM0Fk165dJkDs3LnTPJfcTJp169aZ2xUrVpgvx4EDB6R169YyZcoUadeundnfkiVLpGDBgmbWjQoPD0824FyPttiwDoFvNIhw7pAWuNaQVrjWvOdtF431AazanVK1alVzf/jw4abV47PPPksykHXLli2m1UNbNrSeyK233ur5qly5sqcZSL/PmzevVKtWzTzWr18/Wbx4senWUTrYNTUnBgAAZJKpvd27d5effvpJFixYYL5UxYoVpVGjRub+4MGDZdmyZSasPPLII+bLoa0pDRs2NNVVp06dah7T8SGtWrUyr9EvpTVHevXqZeX3AwAA6TyMaEvG5MmTZeLEiXLw4EETRLp06WLGhCidEaOzWfLly3fVa7XrRVtENIw4ypcvbwatTpgwQXbs2GHGLXTo0IFaIwAApFMhl3TuDZLljFG5fN0bXJ+GR52BpAOKGTOCQOJaQ1rhWgvseyir9gIAAKtoGbmGn3/+2RRt8XaeNP6m58yZqs2gYQQS1xrSCtda6mnZDX0P0OEU6X7MSHrGG6nv540Ah7TAtYa0wrXm2znz9n2UlhEAAGAVY0YAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYxUJ5cM3q1atl8uTJsn79esmXL58MHz5cFi1aJK1bt+Ysw1Vbt26V3377zawOfbmcOXPKnXfeydmGKy5cuCCLFy8219SZM2dk8ODBsmnTJmnSpAl/11xGGIErPv/8c+nbt69ZZltlzZpVTp8+La+88opER0dLo0aNONNwxdChQ2XcuHHJPle6dGnCCFzzxhtvyPLly801pR+0pkyZYh7/+eefpUCBAnLPPfdwtl1CNw1c+fSgnxg0iLz00ktXPT9jxgzOMlxx9uxZmThxormvIbdWrVpSv359z1f16tU503DtWps2bZrn+wULFkjx4sWlY8eOng9gcA8tI/DbX3/9JUeOHJGYmBi54447PI9fvHjR8zzghv3795uumaioKJk3b57kyJGDE4uAOHDggOmaUefPn5cNGzZI8+bNpVmzZqZljr9r7qJlBH7TN4SQkBA5duyYHD161PP4xo0bza2OHwHcULhwYdMiEhYWJuHh4ZxUBExERIS5PXnypGzevNm0lMTFxUlo6N+f4SMjIzn7LqJlBH7LkyePaSL/7rvvpFOnTuax3bt3e7ps7rvvPs4yXOsSfOyxx2TEiBHyr3/9y/TZZ8+e3YRhJxjXrl2bsw2/6YeoQoUKyd69e83fNb3GtFtQx8KpSpUqcZZdFHLJGXEI+EG7aQYOHCjz58/3PJYtWzZp166d9O7d2/NmAfjj999/v2a41QGs2n0DuOGbb74xf7+0u6ZLly7Ss2dPcw1qINaxcDqGBO4gjMBV2o+6bds2M5umXLlykjdvXs4wXL2+XnjhhWt247z55puccbhGW0I0jOTOndt8f+LECfNVpEgRzrKLCCNwDXVGAGQ0/F1LG4wZgSuoM4K09Mcff5gZDfHx8WZmTZ06daRt27YMKoSr+LuWdphNA79RZwRpac2aNfLQQw/J9OnTzXTLVatWmWq/bdq0kcTERP4x4Ar+rqUtwgj8Rp0RpKVBgwZJQkKCKXD2zjvvmIHTOt133bp1Mn78eP4x4Ar+rqUtumngN+qMIK0cOnTI0zUzevRoM61XaWnu7t27y5IlS+TJJ5/kHwR+4+9a2qJlBK7VGdER59QZQSA5FTE1hDhBRBUsWDDJ84C/+LuWtggjcIVOp9QCVKdOnTLfa7VCLQev4eThhx/mLMMVGjr0TUJLdevCZVomSa+5MWPGmOfLly/PmYZr+LuWdpjaC1fom4P221NnBIE2duxYefvttz0luTX46mBDLRGvg1oJJHCDDobWL63Eyt+1wCOMwG+6doMukHfDDTeYJbZZswGBpK0hOl5Ep/bqtaeKFSsmAwYMMN2FgBu00uoDDzxgSsA3adJE7rrrLjNWCYFBGIErgwpr1qxpPkH88MMPnFGkCR0fsnPnTrOgWdGiRVlyAK7Sa6tx48ZmlWilH7IaNmwoTZs2NQFFW+LgHsII/KbLa2uJ7lmzZsmDDz5oPp1q6eQsWbJ4/hPfdNNNnGn4RFs/Fi9ebGY3VK1a1dxPiW5Tr149zjRcoWXfFy5cKF9//bUsW7bMU8dGxy3pGDltLdFWYV2HC/4hjMBvLF6GtLi+dBG8UaNGsVAerNAg8tVXX8nQoUPNwqCOUqVKyQcffCAlSpTgX8YP1BmB38LDw685aFD78wFf6RTe2rVrm0XwnPsp0W0ANx0/fly+/fZbsyL58uXLzYBppSv26kyu7du3y4gRI2TYsGGceD/QMgKf/Pnnn/L4449LyZIlzaBVAMhIDh8+LM8995ysWLHCM24kV65ccu+990rz5s1Nl6F2UevMLh0rp+vYwHe0jMAn+p/w4MGDkjNnTs4g0pRO49VxI3feeacZxDp48GDZtGmTmfHQunVr/jXgCu2KWbp0qYSGhppxSBpAdACrtgQ79Ln7779fVq5cyVn3E2EEQFB54403THO5hhEtfOa0zP3888+mLLwOLAT8pYOh+/bta2bP6HWVEh3LxJpI/iOMwC/79u2Tjh07XnMb7cd/7bXXONPwm/bXT5s2TYoUKWK+X7Bggem7b9Sokak7ok3lhBG4Ve23ZcuW5nrbs2ePaQ0OCQnxjCPRv32TJk1KsiwBfEcYgV909VSd8nYt+skBcKvSr7P+jL45bNiwwTSfN2vWzIQRrZQJuOWZZ55J8e8bf9fcRRiBX/Lnzy+dO3e+5jY6Jx9wgxY4c2qPbN682bSUxMXFmb57RfVfuFljRLsDtTVEW3+nTp0qPXr0MK0hWgWYrhl3EUbgFx1d3r59e84i0oRW+S1UqJDs3bvXLMKobxRaDfP06dPm+UqVKvEvAdcGsGro0NIEzz77rJna26JFC4mNjTXh5L///a9pOYE7WLUXQNDQ8KFr0GgLiU697NKliykFr7Tqb7t27WwfIjLQAFbllH3XKtKrVq3yVJa+ViVgpB4tI/CJTunV0u+6Ui+QlrQEt06l1LEjGkBUTEyMGbzqDGwF3GiFu3xcSLVq1UzdEWcQ67Vm2CD1aBmBT/SPv9Z36N27N2cQaV5n5PvvvzdBRAPJyy+/bMYtfffdd/xLwFVa+l1naykdKK33dSyJrt6rrXJwDxVYAQSVV1991QwsnDdvnnz00UcyZMgQz3NalpupvQgUHTCtM7i08rS2nMA9tIwACLo6Iw6nzohT64aS3AgUHTT9008/mVZhgoj7CCMAgrrOSI0aNUydEUWdEbgReHW9mQ4dOsh7771nrrORI0eair86c1BvdXaNs2Ae3MEAVrhGaz/s2rXLs6iUQ2c+3HDDDZxp+I06Iwi0gQMHymeffWbua3fgr7/+KosWLfLMrNG/b7NmzTJTfBk34h7CCFyhBYG07z4xMfGq53REuvbvA/6izggCXVF69uzZ5r7WEFm9erUniGjriM7keuedd+T99983i+gRRtxDNw1cmd2go841iGglTF2LpkSJEp4vpw4E4C/qjCCQDh06ZFo+9G/Yk08+ab6UjhO5++67zfV33333edangXtoGYErA7v0E0W2bNlk7ty5nqlwQCBQZwSB4nQxO92BefPmNbeXL4bnFEHTD2FwDy0j8JsWPtNqhVoaXksnA4G2fv16GTRokPm02qpVK/MplToj8JeWf/fWxYsXOeEuomUEftMWkaeeesoUQXv99ddNM6Z+knAqFerzpUqV4kzDFTp9t2/fvp43jqxZs5q1aV555RUTjBs1asSZhl+OHTsmY8eONUsOXP69ch5LTXDB9VH0DH77/fffPf2oyWEAK9yiTeO6MJ4uYvbSSy+ZAKLX16hRo8w1WL9+fTO4EAjE37LL8XfNXbSMwG/ah1qwYMEUn2f9GrhF64hoENEBhXfcccdVTebUGYE/tEVXA603dPVouIcwAr/pjJklS5ZwJhFwOjZJu/+02fzo0aOexzdu3GhuqYwJf2jAoGXNDrpp4BodRKiluuPj481CUnXq1DEzH5yxI4Abunbtagar6qfYU6dOmTFJuqy7jhvRdWseeeQRTjQQZAgjcMWOHTukTZs2Zprv5XTRsnfffde8WQBu0G4arZI5f/58z2MaSNq1a2dWkSb8AsGHMAJXtG3bVlauXGlmzTRt2tQ0oU+fPt0UQtM3jscff5wzDdfWp9FxSDo+ZNu2bWY2Tbly5Tw1IQAEH8II/Kb999WrVzfVV7X53BmwqmHkxRdfNM9NnDiRMw1X1j/Sgau61tGUKVMkMjKSswpkALSdw28nTpwwc+518ODlM2duvPFGT1gB3KAr9mqVTO0OJIggLej6ND179vQU2Nu9e7dMnjyZk+8yZtPAbzrNUt8Y9u3bJ8uWLZPatWubcDJz5kzPfHzADblz55YHHnjArJqqhc90GqY+5oxJ0uvwpptu4mTDFRTYSzuEEfhNBw+2bNlSPvnkE+nUqZOUL1/etIboJwj16KOPcpbhij///NMEEaVh1wm8DgpRwc0Ce1pVWj9YOQX2Ljdjxgyq/bqIMAJXPPvss2bQqi6/7dR8CA8Plz59+iQpTgX4Q68pDbspYW0kuIUCe2mLMALX3iSGDRsmTz/9tKkzoqte3nzzzWbxPMAtGja++OILTigCjgJ7aYvZNPDJ2bNnzToO2kVTvHhxcz8luk3ZsmU503ClsN6XX36Z7HNaX0RDsVbRrFatmmepd8BXFNhLO4QR+LWg1OWLlKWEfnyk9UJmGpAnTZrE+iHwCwX20g7dNPCJfuosWrSoWSDPuZ+Say2iB6SGFjbTQdK67IAOLKxRo4aZWv79999LmTJlJDY21hTf27lzp3zwwQcyYMAATjB8rmmjSwyMGDGCAntpgJYRAEFFS75rKfi5c+eaRRrVRx99JMOHD5cxY8aYWRCdO3c2U3w1tAC+tsI1adJEatWqZWYL3nnnnabLGYFB0TO4ZsuWLZ7l3HWar1Zf1U+sgFsOHjwoc+bMkfz583uCiLrttttMMTQNI1r3RumnWsBXOghf69YsXbrUDMyvW7euvPnmm56/c3AXYQSu+PDDD6V79+7mvtZ+eO2110w5+I4dO5oKhoAbnOJmWoFVp5FrV42uf6TjQ5yw8tZbb5n7GlgAX2nX8/Lly80sQV2BXAdPjx8/3rSW6MrQzOpyF2EEfjt//rz5ROrQT64FChSQxo0bm1YSSifDLbrkgFZdVVrDpkqVKnLrrbeaSplKP73qG4hq2LAhJx5+0ZYRXfhTP2wtWbJEunXrZrpqfv31Vxk9ejRn10WEEfhNP43qIEKln1TXrFlj+lm7dOniqZoJuEVbPnSNEB04rWvVaODVNZH69+8vrVu3NitHaysdK0XDDfq3Tcce6fo0GkC0rIG20GkdJbiH2TTwm9Z3UPrG8Mcff0hCQoJUrlzZM9hLV/MF3KKF9LQ0t5bo1iqZen3pjC2nC0cHtwL+0orSeo3pSuQaQFSRIkWkRYsWZkBr4cKFOcku4l0CftNPpfoGsWfPHlMWXumUS4dOtwTcpOOQtPtv/fr1putGZ9IsWrTItIwAbjh06JAJttoC16hRIxNAdOyIE3rhLsII/Kb/OXW0uQ5a3bBhg9x///1yww03mKlx+h+ZNwi4iZVUkVbl4HVckraEMBg68AgjcMUTTzzhKUAVFxdnHsuTJ49MmDBBKlWqxFmGK1hJFYEudLZ48WITRKpWrWq6ZVasWJHstrpNvXr1+AdxCWEErq5No2uD/Pbbb57toqKizHOsTQM3sJIqAmnfvn3Sq1cvzzIXej8lug1hxD2EEfhEy203b97c859W76eEtWngFlZSRSBlz55dateubQanOvdTwgBWdxFG4BPWpoEN2vWndUZ0hoOuUaN2795tZj0obxbRA1KiKz6PGzfO8/3l9xFYrE0DIKiwkirSusaIzhTU4o5OGQOtxqpdOk7lX/iPMALXaHlkrX45dOhQU2+kb9++ZpaNFkADAjF+ZNu2bZI1a1YpV66cWdEXcJMuZ7Fs2bJkn6P72V1MmIYr/vOf/8hzzz0na9eu9VRi1ZLJ2pTO2jRwczaNFtdz+uxr1qwp1atXN0Fk//798sYbb3Cy4VqriH640taQf/7zn2YMyQsvvGAG7BcrVsysUwP3EEbgN10t9YMPPjD3e/To4fnUoMu465vHxIkTOcvwy+HDh+WZZ54xa9Hol64X8sMPP3ieX7BggXlM1w8B3OoO1A9VumCeFnPU4npac2TQoEGya9cu+e9//8uJdhFhBH7TvlP9tKpLtzsDCLUQ2t13323u79ixg7MMv2jxqa+++soEX32D0Onj//rXv8zg1ZEjR5q1aLR8t16DgFszt5zB+uqmm26SVatWeSqwaj0SuIfZNPBb7ty5zX9Q/fS6efNmufHGG83j3377rbmlLx/+0LWOnFaQAQMGmCJ6Op186dKlMnDgQHOr69NoU7quqgq4QVtCtIXXUa1aNdMV7Qxi1ZXJ4R5aRuC3nDlzSoMGDcxo84ceekgeeOABM/1yzJgx5vlmzZpxluEzDbm6Mq9Ww9RKv7fccosndGgQ0bA7ZcoUs6qqszgj4AYdjK9jRJTWUtL7OpZEizk6q5LDHbSMwBW6Lo3zCVZbR5zmTf20eq2CaMD1OCumanXfywOwQ0OvjiMB3KZdM854OA0gn376qVl/q2TJkqblBO4hjMAV+h9TR5frlN7t27ebT6janE4XDfylY0Su5DSV6+DCm2++mZOMNKF/17RlDu4jjMA1Opjwyy+/NMu66+Avrf2gc/SvVVIZ8NaxY8dk7Nixnq4blZiY6HnMqdD6yCOPcFLh8zIXTz75pFfb6vRepysa/iOMwBXaPaP/ifXNQenAL+1b1em9OrVXB38B/tAA8vbbb1/zMb3uCCPwp0twy5YtXm2rY+TgHsIIXGlG79+/vwkiHTp0kI8++sjznNYZ+eSTTwgj8JkWm9IB0d6uLQL4Sgeozp49O9nnVqxYYaaRawudjodr0qQJJ9pFhBH4be/evaYIkI4badmyZZIwov7880/OMnymAeP999/nDCJNxoRo9/KVXTdDhgyRr7/+2nyvMwe1EqsOYoV7CCPw/yIK/fsy0sJnzsyHy4ud6Sh0AAgmp06dMmNCdGC+/l274YYbpF+/fmYJAriPMAK/RUdHm6mVuhaNUw7+wIEDnmXdvW1iB4D00O08c+ZMGT58uPk7poOin3/+eXn00Uc9H7zgPlbthSu0K0ZX6I2Pj0/yeMOGDeWdd95JUiMCANIjXVJAV+rVGYHOjBktbpYrV66rttUZg8wUdA9hBK7RKpk6yEtrjeiy7pUrV5a4uDjOMAL2CVbrjeh6NXrLp1b46/fff/esr3U9OnNr3rx5nHSX0OYE15w8eVLKli1rumx0BgQQCBo+dFbD6tWrZfLkyWZsUuvWrc1ieXoL+EpbO7Q11xvM3HIXLSPwi86iGT16tHz33Xdy6NAhz+M60lzXqfnHP/7BeiFwlQ4inDFjhpQpU8as5KthpFGjRqalZMSIEXLPPfdwxoEgQxiBzzZt2mQWLtPiZinR0skTJkxgzAhcoTO2tPy7Bg9dJ0TXDlHaQvLKK69IvXr1klRkBRAc6KaBz3T5dg0ipUqVMk3kFSpUkIiICDl+/LhpQtdPqb/88otMnTpV2rdvz5mG3/bv32/GJhUsWNATRJQzNklr3gAIPllsHwCCk4aQNWvWmIGD2n+v1Qh1vIguXKahpE2bNtKnTx+z7eLFi20fLjKIAgUKmOqXGkq++eYb00Ki9SAmTZpkni9SpIjtQwTgA1pG4JMjR454BnFpMaDkOKupHjx4kLMMV0RGRkqLFi3kf//7n3Tr1s2MR9IBrc7MGgawAsGJMAKf6BuAulb9EGeqpbMt4IYXX3zRXFvTp083Y0iUdtv07t1b6tSpw0kGghBhBH45ffq0mUmTHPrvEQgagLW6b9++fWXPnj2mdaRw4cKmZQRAcCKMwC8aOLp27cpZREDr1+i4I60BUbVq1WTHIOlAaaXb6IwaAMGFMAKf6CBCHazqDW1CB3y1b98+6dWrl6l4OWrUKHM/JboNYQQIPoQR+KREiRKycOFCzh4CTqv56hog2hXj3E+JbgMg+FD0DAAAWEWdEQBBY+fOnXLvvfdKp06dkjy+du1aqV69uplRAyD40E0DIN07e/asqeSr6x9t27bNVPkdP36853ldKVqXf9dVVwEEH8IIgHRPp+9+//33smjRIvO9hpI333zzqu1iY2MtHB0AfxFGAASFp59+2hQ70zLwOoX37rvv9jyXJUsWiYmJMQs3Agg+DGAFEDS0RWTMmDFmjZouXbrYPhwALiGMAAgqFy5cMIXP7rzzTlMOfvDgwbJp0yazWCNr0wDBiW4aAEHljTfekOXLl5swMnnyZJkyZYp5/OeffzYtJvfcc4/tQwSQSkztBRBUs2qmTZvm+X7BggVSvHhx6dixo/n+888/t3h0AHxFGAEQNA4cOOBZqff8+fOyYcMGqVGjhjRr1sw89tdff1k+QgC+IIwACBoRERGexfM2b95sWkri4uLMLBsVGRlp+QgB+IIwAiBo5MuXTwoVKmRaSLQKa0hIiNSqVcvzfKVKlaweHwDfEEYABA0NHwMGDDAtJIcPHzbTe53Vo3Pnzi3t2rWzfYgAfMDUXgBB5/Tp02bsiAYQdeLECfNVpEgR24cGwAeEEQDpmo4P0boiWnW1atWq5n5KdJt69eql6fEB8B9hBEC6povf3XfffVK6dGkZNWqUuZ8S3WbevHlpenwA/EfRMwDpWvbs2aV27dpSuHBhz/2U6DYAgg8tIwAAwCpaRgAEjePHj8uXX36Z4kyb8PBwM/W3WrVqEhYWlubHB8A3tIwACLrxI9ejJeInTZpkggmA9I86IwCCRt68eU2xszx58phpvffee68peqatImXLljWL5OlzO3fulA8++MD24QLwEt00AIKqAquuP3Pq1CmZO3eulChRwjz+0UcfyfDhw6Vfv37y0EMPSefOnWXt2rW2DxeAl2gZARA0Dh48KHPmzJH8+fN7goi67bbb5Ny5czJmzBiJiYnxFEYDEBwIIwCCRpYsf//J2rt3r8yePVsuXbokiYmJZnyIE1beeustc18DC4DgQBgBEFTdNPXr1zf3+/TpI1WqVJFbb71VPv/8c/NY3bp1Zfny5eZ+w4YNrR4rAO8RRgAEFW35aNWqlZm6q+vTXLx4UaKjo6V///7SunVrKVWqlHTv3l0ef/xx24cKwEtM7QUQlM6fP28Gs4aGhkrBggU9XTgAgg+zaQAEnT/++EPGjRsn8fHxEhUVJXXq1JG2bdtKZGSk7UMD4ANaRgAElTVr1sg//vEPSUhISPJ4XFycfPLJJwQSIAjRrgkgqAwaNMgEkerVq8s777wjAwcONGNG1q1bJ+PHj7d9eAB8QMsIgKBx6NAhqVmzpumaWbZsmVnFVy1YsMAMWtWZNVOnTrV9mABSiZYRAEFDZ88oDSFOEFE6gPXy5wEEF8IIgKChoUPXnjlw4IBMnjzZFD3T0vBaeVWVL1/e9iEC8AHdNACCytixY+Xtt98293X2zNmzZ+XChQum7sj06dMJJEAQYmovgKCiq/ZqjRGd2nvy5EnzWLFixWTAgAEEESBI0TICICjp+JCdO3dKRESEFC1aVEJCQmwfEgAfEUYABL0///zTlH8vWbKkTJkyxfbhAEglumkABD3tttEVe3PmzGn7UAD4gNk0AADAKsIIAACwijACAACsYswIgHTt8OHDMmHChGtuc/To0TQ7HgDuI4wASNeOHDniqbAKIGMijABI13SGTNOmTb3aNiYmJuDHA8B91BkBAABWMYAVAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEyuSVLlsh//vMfGTt2bIrb7Nu3z2yjX2fPnjWPLV682Hyvi9T5YurUqeb1J06cSHYVXn1Of25a2LVrl/l5eus4fvy4rF279qpt9uzZkybHBGQmhBEgk1u6dKmMGjVKRo4cKfHx8clu8/nnn8u4cePMNufOnfOEEf3+woULqf6Z+ob+yiuvyCeffGL2nVwY0X3v379fbLnvvvvM7+jYvXu3OSbCCOA+wggAyZIli9SsWVO++uqrZM/Gl19+KXXq1HHtTE2fPl3Kli1r3vC1hcS2YsWKSffu3c3t5WXoAaQNwggA4+6775Z58+ZddTZ+//13OXPmjJQrV86VM3Xx4kWZOXOm1K5dW+6//36z/xUrVnj12k2bNpl1ajTAbN26VdasWXNV99LevXtNa4s+PnfuXHPsjp07d5quFm1x+fTTT2XixInyxx9/JOmmSUxMNPf1OH/88UfP/cutXr3aHIe27Og+Hc5+EhISTPeXHoMe64EDB8zzv/32m3z88ccyefJkWliAyxBGABh33nmn6Yq4sqtmzpw5Jqi42S2kXR333nuvVKtWTYoWLSpTpky57utGjBghLVq0MOM49Bgff/xxGTBgQJIwMn78eLnnnntMqDp48KB5jf4cDQFKg4N2tTz22GPy66+/ysKFC82YFacLRm+v56WXXpIhQ4aY8Szz589P0p3j7KdDhw7ywQcfmHV1tHtLQ5e+plevXiYszZgxwxPEALA2DYD/kzdvXhMOtKumQoUKnvOirQtvvfVWkvET/nbRlCpVSm6++WbzfbNmzUyg0Df3ggULJvuan376yYxrefPNN00gURooWrZsKZGRkeb7lStXmudfeOEFad++vXmsZ8+e0qZNG+nWrVuSLqjq1avL66+/LpcuXZKQkBDzWofuT7tsRo8eLbfffru5f7kSJUrIe++9Z7q29PUPPvigOf569ep5tsmfP785XtWkSRNzzAsWLDDdXREREXLq1Clp0KCBTJs2Tfr27evKeQWCGS0jADwaNWqUpKtmw4YNZvbMTTfd5MpZ0nEY3333nXkDdzRv3tzMyNE35pRot44ugqfbOjQwNWzYMMk2GqieeOKJJMGiS5cusmPHjiRdQXfccYe51SCSWnoMGkSc1+u5ubyrRmmrhyM2NtbcavjQIKKyZ88uRYoUoasG+D+EEQAed911l3njdrpqtItGH3PLZ599ZmbjaDeNM1V41qxZkjt3bjOGI6Vpwlu2bDGtKU4IcJQpU8Zzf9u2bVKyZEkJDU26GLkTBnSGjkODgK+01eNy4eHhScalqAIFCnjuZ82a1dzmy5cvyTb6u/g6LRrIaAgjADy0m0Q/6WuXhnZBaCuJjsFwi46V0O6Z6OjoJI/ruAvtpvn222+TfZ2+oV9vCrHT5XIlZ/Dp5SHlysCSGt60plwZmgBcm+//IwFkSDpYVcd11K9f33TR3Hrrra7sV2eg6MwVHW9xefeKExi++eYbM5A1ufCjLSCLFi26KnBc3tpRunRpM65FWxsuDxs668YZ66Gv95YvXTgAfEN8B3DVuJHt27ebWSEaGtz6lK9jQnSsRHL1SvRn6DgLHdeR3AyTRx991EyP1S6dy7tlvv76a09o0HEoOntl0qRJnm10mq4OLtUZO7fddluqjjdbtmx0owBphJYRAEnouAutKbJ8+XIzLfV6tKUjuW4PncHiBJmTJ0+aabA6/kTf5JPTtGlTMzVX63LUrVs3yXOVK1eWrl27Sr9+/Uz9jly5cpmWFA0ZWrbdGZTap08fGTp0qAk12hKi2+p4jpSO8VpuvPFGmT17tglBzz77bKpeCyB1CCNAJqctFTqA9HL6pr5u3TozBdah01yfeuopCQsLM9/rVFadveINLTLWsWNHU8skJRo4evfubcKKBiL9WTqDxqHTdLXVRqfh6iwZreUxZswYUy/E0alTJ1NXREOITp/Vuh56nDrIVBUvXtzst1ChQkl+toYafVxvHRpgdCqutq5cvs2Vg1/1/DnHmdw2Gsj0sStbZlq1aiU5cuTw6vwBGV3IpdR0ogKABTreRFs7dJquE4Y0JDzwwAMmbPTv359/FyCIEUYApHubN2+Wtm3bmpYH7Y7RmTU6oFVbZrTSac6cOW0fIgA/EEYABAUt2+6UktepvuXLlzfdSEyjBYIfYQQAAFjF1F4AAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAAAgNv0/A4TVR9vKHcoAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Running Non-Parametric Statistical Significance Analysis...\n", + "INFO: Preparing for Model Feature Importance Plotting...\n", + "INFO: Generating Feature Importance Boxplot and Histograms...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhcAAAI1CAYAAABlvdh1AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAOptJREFUeJzt3Qm8lHP///FPdU57SauUFqU9acHdRpEQLVJEovsmijZbWXJbf7gtJbedQsh906ZSSWiRlJIiiVK0p1V7p5r/4/39/2Z+Z5lTc+Z8M3POvJ6Px3nMzDXXzFzzPTPXvK/vduUJBAIBAwAA8CSvrycCAAAgXAAAAO+ouQAAAF4RLgAAgFeECwAA4BXhAgAAeEW4AAAAXhEuAACAV0l+nw5ALCxcuNBefvnl0O08efJYcnKylShRwho3bmyXX365FSxY0PvrTpgwwaZMmWKvvfbaCX1MNMaOHete53iefvppK1my5AndFiDREC6AXGDr1q325Zdf2sCBA61u3bpu2cGDB23dunX24osv2htvvGFvv/22lStXzuvrnnXWWVa6dOkT/phoNGrUyMqUKRO6PW7cOJs6daoNGzbMihYtGlqe+joAPwgXQC6iYHHeeeelWXbFFVdY586drW/fvvbhhx96fb0qVaq4vxP9mGhUrVrV/QUtWLDAXf7tb3+jpgI4wQgXQC6nppHbbrvN7rvvPps7d641b97cLT906JBrOtCPbkpKip155pl27bXXpjmSP3DggI0fP941u4iaWLp27eqaXDJr4pg1a5Z99tlntmXLFitVqpR7vUsvvdQ11WT2GG3LmDFjbMmSJbZ3716rX7++devWzU466aTQY7799lvr1auXvffee/bbb79Z2bJl7aqrrgrV1ETrk08+sRkzZljHjh3de9V7UxCrWLGiHT582CZNmuRqhVQWtWvXdmWUuhklknWAREOHTiABtG7d2l3qB1D27dvnfgBfeOEFFxj04//pp5+6Go5t27a5dfQjf80117gmlbPPPttatmxpb731lvXu3duOHDni1lm9enXoOeXdd991TTOVK1d2IaR69eo2ZMgQe+aZZ0LrpH+MmnT0w65mGzVlaFvVfNGhQwdbu3Zt6DEKAX//+99dYFFtzKZNm+zqq6+2VatWZats1HSk13v44YfdaxcuXNgFFwWum266yR5//HGrV6+e67eiINapU6fQdkWyDpCQdFZUADnb1KlTAzVq1AjMmjUr03Xq1q0b6Nu3r7v+9NNPB2rXrh1YsWJF6P49e/YEmjVrFhg0aJC7PWzYMPeYDRs2hNb56aef3OvMmDHD3R46dKh7nqB27doF7rjjjjSvu3z58sDChQtDt9M/5p577gk0atQosG3bttCyvXv3Blq0aBHo2bNn6DF63ZkzZ4bWOXDgQKBBgwaBf/3rXxGVkd6zniP168gbb7zhlk+ZMiXs8m+++Sa07ODBg4G2bdsGevXqFfE6QCKi5gJIEAUKFHDV9jJt2jRXS1CjRo3Q/UWKFLELL7zQ1WAcPXrUNW00a9bMypcvH1qnZs2arvaiWrVqYV9DNRaff/65W0fNIlKrVi1XO5IZvd7FF1+cphlBtQeqnZg3b579+eefoeVNmzZN835UwxCsacmuOnXqpLmtMlLNS5MmTULL8ufPb5dccomreVHNTiTrAImIPhdAAlD1vX7oTj75ZHd7w4YNbjTJjTfemGY9VeVrvZ07d9rGjRutYcOGGZ4r9Q98eo888og99thjrhnkySefdMGiTZs21r1799Brp7Znzx7bvXu3VahQIcN96vMQCARCIUU/2vpLLW/evKEmmuxKP5Jm/fr1LmSlLyM1x+g1dRnJOpkFMSA3I1wACWD58uXuh1qdNiUpKcl1PLzuuuvCrq9OnVpn//79WXodDTF97rnnXED55ptvXC3GiBEjbPLkya7TY7AjaFAwLKgPSHoKHcEalb9CsMNpkN6/Qs8NN9wQdv1TTjklonWARES4ABKARoWoGUHND6JgoY6U6Yetvv766y6IqPOmmkBWrFiR4bkGDx7sQopqIzKjQNCqVSv3p6aXRx991I3wUBNC+nChZUuXLs3wHBo5otoONX3EgppJVq5caS1atHA1JEHvv/++zZkzxw1pjWQdIBHR5wLIxVRbocmjPvjgA+vXr19oUikdaS9btsxGjRoVWlc/8Bo9UqlSJXcU36NHDxcu9PggDdmcOHGiCx7paUhm//793aiP1K+v19GQ0nBNH9KzZ083wkLDQIO++OIL1xdDNSv58uWzWFAZaSSJykTvQzQyZejQoa4cFYwiWQdIRNRcALmImiSCP+6aO2LNmjWu7V9zXCgsBLVr187VXGh9DR9VZ8off/zRunTp4gKCqK+EhpGq1uHNN990TRrqk6F+Fak7MAapiUBDWh966CEbPXq0axJQnwRtx/Dhw61QoUJht1lDVnfs2OGGgmrYq55HtRwa4tmnTx+LFfUteeKJJ1zfEc2zofejoKTan/vvvz/idYBElEdDRmK9EQCyR0FB4SA1hQEdPZ9++ulpquxT0+gRNYOoU6Jmsww38ZP6Q+i5dRSuzomp+0AovOjIXc0CqTuP6uhdgUE1FqrlSF37EO4xon4aP/30k7uux6SezEuPUVAJTgAWpMm9tJ46jh6P5spQOFIgSN33Q9vy66+/ZmjaCFI40nbpUqNhUk8pnpV1gERCuAAAAF7R5wIAAHhFuAAAAF4RLgAAgFeECwAA4BXhAgAAeEW4AAAAXiXUJFqLFy92s+ilP78BAAA4Ns1ho9l7w53QMKFrLhQsEnnOML13TfKTyGXgE+VJmcY7PqOUaax+QxOq5iJYY1G/fn1LRJppUbMx6kRRhQsXjvXm5HiUJ2Ua7/iMUqY+ff/99xGvm1A1FwAA4MQjXAAAAK8IFwAAwCvCBQAA8IpwAQAAvCJcAAAArwgXAADAK8IFAADwinABAAC8IlwAAACvCBcAAMArwgUAAPCKcAEAALwiXAAAAK8IFwAAwCvCBQAA8IpwAQAAvCJcAAAArwgXAADAK8IFgLiSnJxsefLkifVmAMiGpOw8GAB8UqioU6euJSXlCy07ejRgefMSNoCchHABIK4oWDzz3iJbt3m3VSxXzO7q3jjWmwQgiwgXAOKOgsWq9btivRkAokSfCwAA4BXhAgAAeEW4AAAAXhEuAACAV4QLAADgFeECAAB4RbgAAABeES4AAIBXhAsAAOAV4QIAAHhFuAAAAF4RLgAAgFeECwAA4BXhAgAAeEW4AAAAXhEuAACAV4QLAADgFeECAAB4RbgAAABeES4AAIBXhAsAAOAV4QIAAHhFuAAAAF4RLgAAgFeECwAA4BXhAgAAeEW4AAAAXhEuAACAV4QLAADgFeECAAB4RbgAAABeES4AAIBXhAsAAOAV4QIAAHhFuAAAAF4RLgAAgFeECwAA4BXhAgAAeEW4AAAAXhEuAACAV4QLAADgFeECAAB4RbgAAABeES4AAIBXhAsAAOBVksWBG2+80Xbs2JFmWZs2bezWW2911xcsWGCjRo2ybdu2WZ06ddzyUqVKxWhrAQBAXIeLXbt22Zdffplhee3atd3l4sWL7R//+IelpKS4299++63Nnz/fxo0bZ/nz5//LtxcAAMR5uPjpp5/cZcuWLW3AgAGh5SVLlnSXL730kgsW7dq1s44dO9pDDz1kv/zyi02bNs06dOgQs+0GAABx2uciGC4OHjxozzzzjL388su2Z88eq1Chgh09etTVUkj//v2tVatWduWVV7rb8+bNi+l2AwCAOK+5UL+KoJkzZ9rIkSOtSpUqLnRIxYoV3aVCh6xbty4m2wsAAOI8XKxevdpdXn/99XbBBRfYiBEjbM6cOa4W41//+pe7L1++fJacnOyuB/tZ7N27N6rXCwQCtm/fPktE+/fvT3MJyjPeHDp0yAoVKpRhuT6z+u4ia/jO+5fIZRoIBCxPnjw5I1yMHj3aNm7cGKqRUA2FRoosX748tI6aR4Jv6vDhw25ZtJ051X8j9XMnojVr1sR6E3IVytMfBYsSJUqEPQhJxJ25L3xGKVNfIv3tjWm4UJPH//zP/9j69evt1VdftaSkJCtSpIi778iRI1a8eHF3XcFCo0q009m5c6dbVrp06aheUzUg1atXt0SknbN2MmpuCnd0CMozHmouwqlatSo1F1HgO+9fIpfpypUrI143puGiQIECbhiqwsVHH33kOmtOmTLF3ad/XJkyZVxNhvpXqKmkffv2NnfuXHd/vXr1onpN1X4ULlzYEpm+EIleBj5Rnv5kVuWaaDtx3/iMUqY+RNokEhejRdTXQoYMGWIXX3yxPfbYY+52r1693OUVV1zhLgcPHmznn3++zZ4921XLXH755THcagAAELfhokePHvb3v//dXVdVk5ot+vbtGxpyevPNN1unTp1cv4tNmza5ZpMnn3wyNHoEAADEl5h36NRIkHvuucdNoKXmj/Lly1vRokVD96uWQqNGBg0aZFu3brXKlStbwYIFY7rNAAAgjsNF6jbBM844I9P7dS4RzicCAED8i3mzCAAAyF0IFwAAwCvCBQAA8IpwAQAAvCJcAAAArwgXAADAK8IFAADwinABAAC8IlwAAACvCBcAAMArwgUAAPCKcAEAALwiXAAAAK8IFwAAwCvCBQAA8IpwAQAAvCJcAAAArwgXAADAK8IFAADwinABAAC8IlwAAACvCBcAAMArwgUAAPCKcAEAALwiXAAAAK8IFwAAwCvCBQAA8IpwAQAAvCJcAAAArwgXAADAK8IFAADwinABAAC8IlwAAACvCBcAAMArwgUAAPCKcAEAALwiXAAAAK8IFwAAwCvCBQAA8IpwAQAACBcAACB+UXMBAAC8IlwAAACvCBcAAMArwgUAAPCKcAEAALwiXAAAAK8IFwAAwCvCBQAA8IpwAQAAvCJcAAAArwgXAADAK8IFAADwinABAAC8IlwAAACvCBcAAMArwgUAAPCKcAEAALwiXAAAAK8IFwAAwCvCBQAA8IpwAQAAvCJcAAAArwgXAADAqySLI3v27LGnnnrKihcvbnfddVdo+caNG23s2LG2fft2q127tnXq1MmSk5Njuq0AACAHhAsFi//+979WoUKFULhYu3atdenSxXbu3Blab/r06fb666/HcEsBAEDcN4vMmzfPBYv0hg8f7oJFgwYNbODAgVa0aFGbPXu2zZo1KybbCQAAckC42Lt3r91///1WoECBDPfNnDnTXT744IPWp08f69q1a5rlAAAgvuSNl+aQ9evXW//+/dMs/+OPP2z37t3uerVq1dJcrlmzJgZbCgAA4r7Pxddff+2aQy655BL39/TTT4fuCwaLvHnzWsGCBd31QoUKpbkvqwKBgO3bt88S0f79+9NcgvKMN4cOHQp9x1PTZ1bfXWQN33n/ErlMA4GA5cmTJ/7DhX7k1Rxy8sknu2aP9D/6wTeReqdy9OjRUOCIRkpKii1fvtwSGbU+lGe8UrAoUaJEhuWrV69OyJ25L3znKVNf8ufPH//hYvTo0bZu3TqrWbOmPfvss6FwsWPHDhc6unfvHgoX6pdRpEiRUI1FuB1QJDSEtXr16paItHPWTqZKlSphjw5BecZDzUU4VatWpeYiCnzn/UvkMl25cmXE68Y0XASDwooVK9xfkELGmDFjrFu3blaqVCnbtm2bLV261Jo2bWrff/+9W0eBJBqqDSlcuLAlMn0hEr0MfKI8/cmsyjXRduK+8RmlTH2ItEkk5uHioosusooVK4Zuq8ZCNRiqldA8F5rvom3btvb++++72/Xr13dDUPUGL7300lhuOgAAiMdwUa9ePfcXpCYShQs1fwSHnA4YMMDVWixbtsy++OILt+zWW2+1OnXqxGy7AQBAHI8WSU0dOx977DEXLlIv++CDD2z+/PluaKpCRY0aNWK6nQAAIIeEi9Q1FqklJSVZ8+bNY7JNAAAgB06iBQAAcg/CBQAA8IpwAQAAvCJcAAAArwgXAADAK8IFAADwinABAAC8IlwAAACvCBcAAMArwgUAAPCKcAEAALwiXAAAAK8IFwAAwCvCBQAA8IpwAQAAvCJcAAAArwgXAADAK8IFAADwinABAAC8IlwAAACvCBcAAMArwgUAAPCKcAEAALwiXAAAAK8IFwAAwCvCBQAA8IpwAQAAvCJcAAAArwgXAADAK8IFAADwinABAABiHy527NjhdysAAECukRTNg7p162bly5e3jh07Wtu2ba1IkSL+twwAACROzUX//v3d5X333WfNmze3u+66y+bMmWNHjhzxvX0AACARai4uu+wy97dlyxabMmWKTZw40W666SYrU6aMtW/f3tVo1KpVy//WAgCA3N2hs2zZstazZ08bN26cTZ061S644AIbOXKkCxdXXnmlffbZZ/62FAAA5N6ai9T27Nlj06ZNs48//tgWLFhgycnJ1qpVK8uXL58NGDDAevToYYMHD/aztQAAIHeGC/Wt+Oqrr2zChAk2Y8YMO3DggNWuXdsGDRrkmkVKlizp1luxYoWrwejTp48VL17c97YDAIDcEi6uuuoq++GHH+zkk0921xUgwvWxqFmzppUoUcJSUlJ8bCsAAMit4aJhw4bWu3dv1/yhZpBjGT16tJUqVSra7QMAAIkQLoYMGRK6fvToUcub9//3C92+fXuoSSSoUqVK2d1GAACQCKNFxo4da61bt7a1a9eGll1zzTXWr18/27t3r6/tAwAAiRAu1Inzn//8p2sWSd3kcffdd9vq1avt8ccf97mNAAAgt4eL999/3zWNPPjgg1a0aNHQ8jZt2tiIESNs0qRJdvjwYZ/bCQAAcnO40MycDRo0CHtfuXLlrFixYrZ169bsbhsAAEiUcFGhQgX78ssvw973888/2+7duzN07AQAAIkhqtEiXbp0sYEDB9quXbvcWVF1TpGDBw/akiVLbPjw4dahQwfLnz+//60FAAC5M1yob4XCxXPPPWdvvPFGmvsuvPBCd7ZUAACQmKI+t4jOgtq1a1d3PhH1wShUqJCdeeaZVr16db9bCAAAEufEZTqnSNWqVa1y5cqhCbXU50KqVKlC0wgAAAkoqnChkSC33367q7XIzPTp00OhAwAAJI6owsXzzz9v69atswceeMDKli0bmv47NXXyBAAAiSeqcLF48WJ75JFHrGXLlv63CAAAJN48FwUKFHCnWwcAAPASLnTCMp24DAAAwEuziEaIjBo1yn755Rc3/FTDUNPr0aOHlShRIpqnBwAAidihU1N8f/vtt+4vnI4dOxIuAABIQFGFi2nTpvnfEgAAkCtkaxItjRqZOXOmm6Hzrrvusrlz51qrVq2sePHi/rYQAADk/g6dgUDAhgwZYt26dbNXX33Vxo8fb3v27LEXXnjBNYesWbPG/5YCAIDcGy7+85//2KeffmrPPvusLVq0yE477TS3fOTIkW7a74cfftj3dgIAgNwcLj7++GM3O+fll19uRYoUCS2vWLGiO+W6AodOwQ4AABJPVOFi+/btdvrpp4e9T/0tFDi0DgAASDxRhQs1g2Q2YkSdPPfv32+lS5fO7rYBAIBEGS1yzTXXWJ8+fWzbtm2uaeTw4cO2YcMGd5bUYcOGuU6dycnJET+fOoPOmzfPNaXUrVvXTdKVWkpKin311Vfu9erUqWO1atWKZrMBAEC8hgsNNx08eLDr0DlmzBi3rGfPnmnui9SSJUvs5ptvtp07d7rbOsNq7969bcCAAe72n3/+6Wb7/Omnn0KP6dWrlxv6CgAActE8FwoTqrXQ3Baa56Jw4cLWoEEDq1evXpaeRyNLFCwaNmzoZvScPXu2vfTSS3b++efbWWed5a4rWOgU7nr+zz//3F5//XW7+OKLrX79+tFuPgAAiKdwsXnzZtdUIY0bN05z37p169zlKaecYklJx376o0ePWocOHVxtR9++fV2txS233OIm5vr1119duNDIFHn66aetadOmdu+999q4ceNcnw/CBQAAuSRcXHfddfb7778fc53p06db5cqVj7mOwkSwOWXVqlXuTKuqCSlWrJg1b97c1WioVkSCQUInSlO4+Pnnn6PZdAAAEI/h4u6773adMFM7dOiQrV692vXB6Nevn5UvXz5Lz6nmjhEjRrjAoaaScuXKueeTPHnyWNGiRd314OWuXbss2tlF9+3bZ4lIo3hSX4LyjDfaj4Q7y7I+s/ruImv4zvuXyGUaCATc7/EJCxdt27bN9L6LLrrIhYNgjUSk1N+iffv29tlnn9mgQYPcDkazfUq4N6MmlWioOWf58uWWyJienfKMV/rea1+Qng40EnFn7gvfecrUl/z585/4E5eF06RJE9uxY4cbNlqqVKnjHqWos6aaP7p27er+Jk+ebHfeeafryPniiy+GgoSGqRYoUCBU66Cmk2hoiGz16tUtEWnnrJ2MQlu4o0NQnrGmfUI4Gp5OzUXW8Z33L5HLdOXKlRGv6z1cbN26NeImC62nQKGRJnPmzHFNHrouChxly5Z1txUo1CdDc1wE31xmM4Qej2pBgq+RqPSFSPQy8Iny9CezKtdE24n7xmeUMvUh0iaRqMOFTlym+SdS01GF+mFMnTrVatSocdxaCwkOL9VcF7feequ1bNnSRo8e7e7TyBC9ES375JNP3LlMWrdu7Tp9iq4DAID4E1W4UMfLcKNF1OQQHC4aqUceecS6d+9u8+fPd39Su3Ztu/322931gQMHuuU//PCD+5MLL7zQWrRoEc2mAwCAeAwXmmMiffunahny5cuX5efSVN6TJk2yCRMm2O7du61mzZp22WWXhaYPV/OH7h8/frz98ccfbnpwdfwEAAC5KFyoX0VwEq1IHG9CrVNPPdU1i2RGfS80uRYAAEjgSbSyOqEWAABI4HDx4IMPuhOLadZMnQFVNRMa0aGOme+++67rD6EpvYMi6dwJAAASOFyoJkInLdNkWampo+V5553nOmE+99xzbrZNAACQWKL69V+8eLF16dIl00m0Dh8+HDonCAAASCxRhQvNjvnjjz+Gve+XX35x810UL148u9sGAAASpVlEQ0GfeOIJN8NmmzZt3GRYur5w4ULXHKJ+GMwACQBAYooqXHTr1s1Nxz106FB79tlnM5y4TLNpAgCAxBRVuNCEWUOGDLEePXrYV1995U5SpqaSs88+253/AwAAJK5sDefYvn27bdq0ydavX+9Gj+ikYunPOQIAABJLVOFCU3+r5kLNI6+++qqbmludOF944QXX30KnowUAAIkpb7RnRf30009df4tFixbZaaed5paPHDnSneM+/fwXAAAgcUQVLj7++GPXaVNNIUWKFAktr1ixog0fPtwFjoMHD/rcTgAAkJvDhfpa6Gyl4Wh+CwUOrQMAABJPVOFCzSA67Xpms3fu37/fSpcund1tAwAAiTIU9ZprrrE+ffq4IahqGtF03xs2bLAFCxbYsGHDXKfO5ORk/1sLAAByZ7jQGU8HDx7sOnSOGTPGLevZs2ea+wAAQGKKKlwEw4RqLebOnetOUqbpvhs0aGD16tXzu4UAACD3hwvNbXHmmWda06ZNXRMIAABAtoeiagpwAAAAL+GiQoUK9vvvv0fzUAAAkMtF1SzSrFkze+ihh2zKlClWrVo1K1WqVIZ1unfvbieddJKPbQQAALk9XIwaNcqOHDli8+bNc3/hXHbZZYQLAAASUFThQucVAQAAyFafC9VW7Ny5M9LVAQBAgoo4XLzzzju2a9euNMuGDh3KOUQAAED2R4sETZ061Xbv3p2dpwAAALlMtsIFAABAeoQLAADgFeECAAB4RbgAAACxm+dCs27mzft/eWTr1q0ZlgWNHj3aKlas6GcrAQBA7gsXTZo0cadWT+2MM87IdP38+fNnb8sAAEDuDhdPPPHEid0SAACQK9DnAgAAeEW4AAAAXhEuAACAV4QLAADgFeECAAB4RbgAAABeES4AAIBXhAsAAOAV4QIAAHhFuAAAAF4RLgAAgFeECwAA4BXhAgAAeEW4AAAAXhEuAACAV4QLAADgFeECAAB4RbgAAABeES4AAIBXhAsAAOAV4QIAAHhFuAAAAF4RLgAAgFeECwAA4BXhAgAAeEW4AAAAXhEuAACAV4QLAADgFeECAAB4RbgAAABeES4AAEDuDBc7d+60FStW2N69e8Pev3nzZlu+fLnt27fvL982AACQg8LF7t27beDAgXbuuedahw4drEmTJvboo4/akSNH3P0pKSl255132nnnnWedOnWy5s2b24QJE2K92QAAIF7DhYLE1KlTrWDBgnbGGWfY0aNH7d1337VRo0a5+9966y2bPHmyJSUlWYUKFVzNxZAhQ2zt2rWx3nQAABBv4eLgwYMuWIjChELEgAED3O3Zs2e7y7Fjx7rLp556yj7//HNr1aqVq82YOHFiDLccAADEZbhQ/4r27dvbRRddZA0aNHDLKleu7C6Tk5Pd/atXr3a3mzVr5i5btGjhLn/88ceYbTcAAMhcksVQyZIl7fHHHw/dPnz4sI0ePdpdV+DYtm2bu54nTx4rUaKEu168eHF3GbwvqwKBQMJ2Ct2/f3+aS1Ce8ebQoUNWqFChDMv1mdV3F1nDd96/RC7TQCDgfo/jPlykpqaOu+++2xYuXGiNGze2zp0725o1a9x9efPmDb2hfPnyhXZC0b6ORp0ksmC5gvKMNwoWwQOJ1FSDmYg7c1/4zlOmvuTPnz/nhAv1vVBfiy+++MLq1q1rL730kgsRwSMYjRxRKFBTyYEDB9yyIkWKRPVaeo7q1atbItLOWTuZKlWqhD06BOUZa5kdNFStWpWaiyjwnfcvkct05cqVEa8b83ChppB+/frZrFmzrGHDhvb6669bsWLF3H1ly5Z1YUDBYv369e6fuW7dOndfpUqVono91YAULlzYEpm+EIleBj5Rnv5kVuWaaDtx3/iMUqY+RNokEhdDUZ999lkXLBQo+vbta6tWrbLvvvvOfv75Zzf8tFGjRm69oUOH2owZM2z8+PFpOngCAID4EtOaiy1bttg777wTmkzrxhtvDN2n5pFx48a5wLFo0SL75JNP3J/UqlXL2rZtG7PtBgAAcRouVEtRp06dsPdVq1bNXZ5zzjkugGgejK1bt7r1e/fu7ZpLAABA/IlpuGjatKn7Ox41jQSbRwAAQHyLeZ8LAACQuxAuAACAV4QLAADgFeECAAB4RbgAAABeES4AAIBXhAsAAOAV4QIAABAuAABA/KLmAgAAeEW4AAAAXhEuAACAV4QLAADgFeECAAB4RbgAAABeES4AAIBXhAsAAOAV4QIAAHhFuAAAAF4RLgAAgFeECwAA4BXhAgAAeEW4AAAAXhEuAACAV4QLAADgFeECAAB4RbgAAABeES4AAIBXhAsAAOAV4QIAAHhFuAAAAF4RLgAAgFeECwAA4BXhAgAAeEW4AAAAXhEuAACAV4QLAADgFeECAAB4RbgAAABeES4AAIBXhAsAAOAV4QIAAHhFuAAAAF4RLgAAgFeECwAA4BXhAgAAeEW4AAAAXhEuAACAV4QLAADgFeECAAB4RbgAAABeES4AAIBXhAsAAOAV4QIAAHhFuAAAAF4RLgAAgFeECwAA4BXhAgAAeEW4AAAAXhEuAACAV4QLAADgFeECAAB4RbgAAABeES4AAEDuDRdHjx61w4cPx3ozAABAbgkXnTt3trp169qmTZvSLH/zzTetRYsWVqdOHbvyyitt6dKlMdtGAACQQ8LFsGHDbPny5RmWT5482Z588kn7448/7MiRI/bDDz9Yr169bOfOnTHZTgAAEOfhYvPmzXbnnXfaK6+8Evb+t99+213269fP5s2b52o2FCwmTpz4F28pAADIEeHi+eefd7UTTZs2tQIFCqS579ChQ7Zs2TJ3vWvXrlayZElr166du/3dd9/FZHsBAMCxJVmMlS1b1u69917r0aOHNWnSJM19W7ZscU0hUqZMGXdZunRpd7lx48aoXi8QCNi+ffssEe3fvz/NJSjPeKMDikKFCmVYrs+svrvIGr7z/iVymQYCAcuTJ0/OCBcDBgzI9L6DBw+6y3z58lnevP+/kiUpKSnNfVmVkpIStm9HIlmzZk2sNyFXoTz9UbAoUaJEhuWrV69OyJ25L3xGKVNf8ufPnzPCRSRvQrUXGqaqgKFwIAULFozqOZOTk6169eqWiLRz1k6mSpUqYY8OQXnGQ81FOFWrVqXmIgp85/1L5DJduXJlxOvGdbhQk4kChYKFRouUK1fONZVI+fLlo3pOVekULlzYEpm+EIleBj5Rnv5kVuWaaDtx3/iMUqY+RNokEhcdOo9FHTxr1qzpro8ePdqNLJk6daq73ahRoxhvHQAAyHHhQnr27OkuNVT1vPPOc/0l1Kmzffv2sd40AAAQ780i6ripv9RVL506dXKjO0aOHGlbt251s3T+85//tOLFi8d0WwEAQA4IFwsXLgy7/Nprr3V/AAAg/sV9swgAAMhZCBcAAMArwgUAAPCKcAEAALwiXAAAAK8IFwAAwCvCBQAA8IpwAQAAvCJcAAAArwgXAADAK8IFAADwinABAAC8IlwAAACvCBcAAMArwgUAAPCKcAEAALwiXAAAAK8IFwAAwCvCBQAA8IpwAQAAvCJcAAAArwgXAADAK8IFAADwinABAAC8IlwAAACvCBcAAMArwgUAAPCKcAEAALwiXAAAAK8IFwAAwCvCBQAA8IpwAQAAvCJcAAAArwgXAADAK8IFAADwinABAAC8IlwAAACvCBcAAMArwgUAAPCKcAEAALwiXAAAAK8IFwAAwCvCBQAA8IpwAQAAvCJcAAAArwgXAADAK8IFAADwinABAAC8IlwAAACvCBcAAMArwgUAAPCKcAEAALwiXAAAAK8IFwAAwCvCBQAA8IpwAQAAvCJcAAAArwgXAADAK8IFAADwinABAAC8IlwAAACvCBcAAMArwgUAAPCKcAEAALwiXAAAAK+SLAeYO3euvfXWW7Zt2zarU6eO9evXz8qVKxfrzQIAADkxXCxcuNB69eplR44ccbeXLVtm33zzjU2aNMny588f680DAAA5rVnk5ZdfdsGiY8eOrvaiQoUKtmbNGpsyZUqsNw0AAOS0cKFQsWDBAnf9tttus6ZNm1rnzp3d7fnz58d46wAAQI4LF1u2bLFDhw6566eeemqay3Xr1sV02wAAQA7sc7Fv3z53mS9fPktOTnbXg/0s9u7dm+XnS0lJsUAgYEuXLrVEpPeeJ08e++WXX9wlKM94pM9ml6bF7PCRIpaUL699//337rOLrOM7718il2lKSkrE7zmuw0UwUKh5JPgPPXz4sFsWTWfOYKEk2gciSO87b964rqzKUSjPE+ekomm/34n6nc0uPqOUqe/PU64IFyVLlgxd37lzp5188snuUsqUKZPl52vYsKHX7QMAABnF9WFs0aJFrVKlSu76rFmzXO3FnDlz3O369evHeOsAAEA4eQJx3pipoajPPfecq4pRzcX27dutYMGCNm3aNCtfvnysNw8AAOSkmgvRBFpXX3216yugYFGiRAl7+umnCRYAAMSpuK+5CPrzzz9duNBQVGbmBAAgfuWYcAEAAHKGuG8WAQAAOQvhAgAAeEW4AAAAXhEuAACAV4QLAADgFeEigezZs8edBOrXX3+N9aYAQI6kc11pP7p8+fJYb0pcYyhqApk/f75df/31ds4559g777wT683JUVatWmWvvvqqrV271mrWrGk33HCDVa1aNXT/448/bgsXLrT77rvPmjRpEtNtzSk2btxokyZNcjvqP/74ww4dOmSFCxe20047zc4991xr164dc9pkwfr1692Mxjp4qFy5svXo0cPq1KkTuv+ll16yGTNm2K233mpt2rQ5Ef/ShKA5l84++2wrVqyY+84jB564DFn33Xff2R133BH2voMHD4bWueCCC6xBgwY2bNgwivk4NmzYYF26dLF9+/a5299++62NHTvWHnroIbvyyivdst9++82WLVtmu3fvpjwj8Omnn9pdd91lBw4cyHDfN998Y+PGjbNXXnnF3n77bStXrhxlehy7du2yrl272rZt29ztRYsW2UcffeT2BTfddFMofOgzumPHDsozglreDh06hL3v6NGjoXW0Hy1SpIgLyUiLcJHL6JT02okci44QtU6FChX+su3Kyd5//30XLGrXrm29e/d2R4avv/663X///e5kegoeyNpn9IEHHnDBolmzZtaqVSs3rX++fPlcAFaYmzBhgq1evdqdV+iJJ56geI9D5aVgoRqLAQMG2KZNm+y1115zp0pQNf4tt9xCGWaRPofHmmNS92k/qhoMZES4yGVUJf/UU0+5anqdnr5169buCFEne1uyZIk7klGNxdChQ61AgQKx3twcQU0hwfPcXHLJJe66fhT/8Y9/uB9JpqPPenOIjp5POukkGzlypDspYXpqFlG1/o8//ujlf5gon9Frr73WLrvsMnddoU1lyHc9ujNyv/vuu66ZU7WSdevWdd/1MmXKuBqLjh07uhqLiRMnuvNeISNKJRfSB3/y5MmuXfWLL76wPn36uB166dKl3f0KFRUrVnRfFBxfsFr+888/t/3797vrZ511lqu2V7AYNGgQba9ZoLMbq5ZCVflq/tA5g4JHiKrV0A/l+PHj3W0+o1n7jM6ZMyfUNFetWjUX3hTiVPvzySef8HXP4oGampbUT02dN1X7o+Ymnd9KFCq0Hw3eRlqEi1xKO+UXX3zRnnnmGdcBSUcw6tCFrFNbdlJSkgts6silGiBRx1iVqWqFdDSDyI8Kr7rqKnddR4ZNmza1WrVquc6HOkJUKFbo0M67Z8+eFGsE1D9AnWG//PJLV+vz2WefueUq1zfeeMM1O9EfKOsKFSrkmj/VAV6hWAcS/fv35zMZAcJFLte+fXv7+OOP7aKLLrKvv/461puTI1WvXt3+/e9/u9EhKSkpVqpUqdB9zZs3dzserYPIqYpZO+0zzjgj1CyivgGiIKejRvVradGiBcUaYc2FRjOpX5DKMfVn9Mwzz3T9hurXr09ZZrMWQ2FXo+5wfAxFTSDTp093vcVVlaejcWTd5s2bXa1Q+nZWVetrWJrKtnz58hRtFqiz7NatW11w05Giyjc5OZkyjJI6dqqTYbi+QKp1K168eJph1MiaxYsX28yZM12NpZqcER7hIkF3PqrFKFmypKuSRvYpWCh46AiHoZPZp2amWbNmuSaU888/38MzYunSpa4/i2oyNJcIskdhWAdsCsJt27alONOhWSQBrVy50o0aoQ+GP6rCV5kyusEPBTWVJ8NQ/fnvf//rypTmUT/UuVvlqX5DyIihqAlIvcfVlq2ZJuGHOiJqpEPqtm5ET8P89Bmlickf9W9RmZ5yyikenzVxqW+QylOfVWREswgAAPCKmotcas2aNW7opKrp1cdC7YNK2JrBTyMc1EaouQYQGU35qymr586d68p279697shF/VbUQ//yyy+3008/neLMAs4t4p/6qaizoT6jGnqqjscahqpaSp2rRZ9VRE77Tk3trVMmqKlOM8iq07HmtlD/Kn3vqbkIj5qLXOiDDz6whx9+2FXTZ6ZevXr25ptvup7jOH7nQp2fQb3EM6OgobbX7t27U5zZPLdIkEY0cG6RyOjgQSckmz17dqbraMiv1mGehsgsWLDAjQY51hw2amLSfpQDi4wIF7mMJsxSO6AS9oUXXuimqVaA0BGMOiCtW7fOnXRLZ6G8+eab7c4774z1Jsc9dXwdPny4q6XQEN5KlSq5YWiaT0DlrRNtafZD9RrXjKjMKnlsCr36jGoK8GOdW0Sf1c6dO9OpMwIffvihDRkyxI2u0WdUs3PqCFs1bqrB0JlnNU+DbqtGU/0vcGya6l/nt9FsvBdffLH7/usgQudmUi2G5g/65ZdfrGXLlm6iMqRFs0guPDW4dtBK0pmNBlEV6e23387Ihghp6l9Rz/Bw84No9lOdHfWHH35wOxvCxbFxbhH/gqOUVMOW2dwLOteQwq/WJVwcm2rUFCwUeN966y0X1NJT4Lj00ktD+wekxVDUXCY4WkFHfdOmTXM7lOB5G1R1qjN66shFypYtG9NtzSl0xCIqT4UHHbkE6ahQUy2rXIVgcXycW+TEfe8VHjRRXurmJvUPmjdvnqu9EL73x6fzL6kWSLWTo0ePti1btoROta5lOuusmp+F73x4NIvkQn379nVt2qnbWtUsEpxeWTR7n6YEVt8LHNuKFSvs6quvDp20THREo51N6lMyUz0auYceesh9/lJTmab+jOozyxTgkdcGderUyR1MpC4/fT5Tf0b1fdd8F6rex7G98MILbtr/Y31GRWeh1skikRbhIhfSkbXOhqgzS6rXeGoKFTr5ljp1qS0RkQcM7Wx0YihNV52aZuTUOVxuu+02d/IoHJ920O+99547+tOkbql/APXDp8+mqvc5t0jkfv/9d3v++efdaJH0JylTzYb6EOh7r/4tiIxOoKdTr6vpI1hzEQwZOtGemqFUrsiIcJHLqaezhlOpE51++FQlyhDU6OlHUFWkKleVo6r4NSkZose5RfxTh20FDNVa6vMZbNpDdNSPTWWqSzWZaD8a7twt+D+EiwSwfft2N6xKOxidJhzZt2jRIrezady4MW2uAJAOHToTgDohDhgwIEP7IaL32muvuTLVCBEAQFqECwAA4BXhAgAAeEW4AAAAXhEuAACAV4QLAADgFeECAAB4xTwXCTJJkc41opPvnHbaabHenFxBZ+7URFqnnnqqOwcBAOD/EC4AAIBXNIsAAACvCBcAAMArwgUAAPCKcAEAALxK8vt0QM7x888/2yeffOKud+/ePexpqY8ePWqvvPKKHTlyxDp16pTt0TZvvfWWe44LL7zQvvnmG/v666/ttttus7x5T2zO37Rpk3344YfHXKdfv35eX3PNmjXutPSxHKF0+PBhe/nll61evXrWunVri3fxUGaAD9RcIKHPFvvCCy/YG2+8EQoZ6elU9ToDqtZbu3Zttl9z1KhR9vnnn9tfTeFC72HZsmV/yeutXLnS2rdv76XMskOhUO/7iy++sHgXL2UG+EDNBRJeixYtbOrUqXbNNddkKIspU6ZYy5Ytbfr06d7L6eyzz3Z/fyXVmHTt2vWEv47mADl06NAJf53chDJDbkK4QMJr27at3XvvvbZt2zYrVapUmir1GTNm2KBBg8KGi59++snmz5/vfkTr169vf/vb39LcHwgEbN68ea62oESJEnbJJZekuT+zZpHvvvvOlixZYvv377fy5cu76vzixYuHHrN8+XIXhFQDomr00qVL20UXXRRax4fjvbdjbeeqVatCTTATJkyw9evXu0Cjsli8eLHdeuutGZqKKlasaG3atHGvqRql888/372/ggUL2sUXX+zKL9LtOh6V4YoVK+zKK6+0zz77zG2ftl+fA73eV199ZT/88IMrV712kSJFQo/T//Lqq692NV1btmyx008/3b1vNWWkLz+Vz+7du12TjLYzT5487r5w77FmzZphy+x4ZZ3Vz4Tet2rj1NzXsGFDO/PMM6P63wPHQ7MIEp5+ICpXrpwhQMydO9eqVasWti/Go48+ap07d7alS5faH3/8YXfeeafddNNNduDAAXf/wYMH3e3bb7/dzeY5Z84c69Chg+3atSv0HPpRUJW9dvSinXnv3r1twIABbkbVHTt22EsvveRCycaNG0OPUTONfuD0I/Tnn3+625deeqlt3rzZy//yeO8tku0MR0FK/R/CNRUpxIl++IYPH27XX3+9+4EdM2aM+/GNZLsipTLU9qoPjZpLtm7dag8++KBde+211r9/f9fHRs+v7VAA0f8y+Dht/xVXXGHjxo1z4eLhhx92IWD79u2hQHrPPfdYt27dXCBQ+QwcONB69Ojh/leZvccCBQqE3VZfnwkF3X/+85/WpUsX+/777+23336znj172hNPPJGl/z0QsQCQoCZPnhyoUaNGYOnSpYGhQ4cGevTokeb+u+++OzBq1KjArFmz3Hpz5851yz/88EN3e9KkSaF1169fH2jYsGHgySefdLdffvnlQJ06dQIrV64MrfPuu++6x913333u9osvvuhup6SkuNvvvfdeoG7duoENGzaEHrNnz57AWWedFRg2bFiax7z55puhdbZv3x6oX79+4Lnnnsv0vS5evNg97pZbbgk8//zzGf52794d8XuLZDuDrxcsM1EZ16tXL8O2tW7dOjB48GB3Xduix40ZM8bdPnr0aMTbFc6BAwfc4x544IHQsmAZjhgxIrTs7bffdsv69esXWrZkyRK3bPr06WkeF/z/yaZNmwJNmjQJ3HvvvaF1atWq5d5/0Lp16wKNGjUK3HHHHcd8j+HKzNdnQq+V/rm/+uort+zrr7/OVhkD4VBzAZi5KuSFCxe6phHR0aqqmLU8PVVfq7bj8ssvDy3TOUZUhT527Fh3lDhp0iQ777zzXM1HkI4sj9V0cfLJJ9sDDzzgqr31HDpSVY1H/vz5M3TyU8e/1I9Ts4KORrMrkveWle2MVrAqPtiUEMl2ZdVll10Wul69enV3mbrpKrhMtQupqXYjqFy5cq4GRH12VMswfvx4938/66yzQutUqFDB1W5oHfWryOw9nsjPxEcffeSaOJo1axZap2nTpq5mIlh2J6KMkbjocwGYuXbxU045xTWNqO165syZbkerZRqymr5Xf5kyZezf//53muVq/lCzh6rL1e6tjqBpvmxJSValSpVMy1s78dGjR7tqd/Vb0M78nHPOcZfBppOg9E01ycnJrko+ux06j/feVFWele2MhvqfqNyzul1ly5bN0uuoX0JQsM9E6j43wWUacRKkvh8KFKlVrVrVnRxQ26IffPUdSU9BRc+jcJDZezyRnwl9HsN1Hr755ptPaBkjcREugFQ/vMFRIxolog5+4WinrjPMptekSRP3p/ZzHY2GO9I71o/v0KFDbcSIEa6NXW3f6uSnH4hw8zMc62g3OyJ5b1nZzkik/vEOvrf0HSQj2a6sSv8akVBAzOx/qufT/zzc/ya4TvDx4d7jifxMpC/jcE5EGSNxES6A/6Uw8d5777mjz1mzZrkq43DU+bNw4cIZJp2aPXu2G2Wgpg8dza5evTrN/cEj11q1aoV93vfff99atWrlOu8FqapdHQ7/Ksd7b8WKFYtoO8P90AWPpFP/AKtMdu7c6WW7/gpqNlPTRtGiRUPL9H8+6aSTXBOCJr9SDUN6qhXQ+1fzRmbClZmvz4TKL1yT1X/+8x/XhKIakngpY+QO9LkA/lfjxo1dtbdGDmhHW6lSpbBlo9706p+hIYtB+oEcMmSIG8anKu+rrrrKtY3/+OOPoXU0wuBYP6TaeWvoYmrvvPOO+zFJSUn5S/5Pkby3SLZTfQIkdVONmpl0dKzRCkGqKYpkJEIk2/VXUDAaOXJkmsnJNEJD26eaCF3qx1gjRYLUZ0N9FhReg8NawwlXZr4+Ex07dnRDWRctWhRapv4Yjz32mO3duzeuyhi5AzUXwP/SzlNNIx988MExp8K+7rrrXGhQe7WO+NROrb4aavPW0ETRsEb9wGhddZDTDlxh41ht1prvQsMFe/Xq5Wo3tEPXvATqp3GsIZ4+RfLeItlOHcHrKFhDN7/88ku77777XF+EGjVquHku1PlQfVP0gxfsOJnd7fqrKEzoPasWYtq0aa7zZrCTp8pEZXHDDTdYu3btXGDQOmrOUMfMYwlXZr4+Ewq7+jzeeOONbrv0Oh9//LH7bKo/R7yVMXK+PBoyEuuNAGJ5bhHteIOd9LTz/vTTT90OV73tg0d4EydOzHBuEU1cpDkLdKSpH0h14Ex/dKcjRU0cpZ25flx1VKtq6MzOLZJ6kiP9gKhH/7fffuuOKG+55Rb3A6HHpA8/qj5X1bx+OI51bpELLrjA6tate9yyOd57O952qglAzQPBSaI0z4PoiFtzWvz+++/ux1mjcVTeOqIPTqKlcunbt29U2xXJuUWC5Z66DNVcpZEeqf/vwcc2b97cGjVq5OaX0PwU+p+qw6/KVGWp955esJZAu1etc+6556aZRCuz9xiuzHx+JlRrpNdWLYtCUYMGDbJdxkA4hAsAiEAwXOjHHsCxEUcBAIBXhAsAiIDmicisuQZAWjSLAAAAr6i5AAAAXhEuAACAV4QLAADgFeECAAB4RbgAAABeES4AAIBXhAsAAOAV4QIAAHhFuAAAAObT/wOLfIrkfcSXfQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhcAAAI9CAYAAACJ7loYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQNFJREFUeJzt3QmcjXXfx/HfGDOMfV+y74wtRVkist72pOIpd3oKka2QuJG6K5USbjcpJIoWUWRpoSRkiSg7tyVk3waDYeZ5/f535zwz48zMOeM/c64z5/N+veZ1Zs51nXP+57rmOtf3/LcrJC4uLk4AAAAsyWTriQAAAAgXAADAOmouAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGBVZrtPB8AJNm/eLJMmTZIWLVrIww8/fNPyHTt2yJtvvimDBw+WKlWqePWcX331lSxYsEDee+89yZQpbb+XrF27VqZNm5bgvrCwMClQoIA0bNjQvK+QkJA0LQOA1CNcABnQ6dOn5aeffpJdu3ZJo0aNpGjRogmWnz171ix/4oknvH7OmjVrSq5cudLlpH7ixAlTPg0/lSpVMvddvXpVdu7cKUOGDJEff/xRXnnllTQvB4DUIVwAGdj//u//yhtvvCFvv/32LT9XiRIlzE96qlGjhtx9993uv5s3by7Xr1+Xd955R5566ql0Lw8A7xAugAxMT8779u0zzQz16tVLdt2LFy/KvHnzZOvWrXL58mW57bbbpGPHjuY5EjeL7N69W8aOHSt9+/aVWrVquZ/jxo0b0r9/f7n33nvloYceMvddu3ZNvvjiC/n555/N79WrV5euXbuaWpDUKFmypLmNjY31quyHDh2SF198Ubp16yaNGzdO8FxDhw6VqlWryt///nevy7pmzRpZtmyZqV3Jmzev1K9fX9q0aZPmTUVAIOFoADK4QYMGyYQJEyQmJibJdc6dOyf333+/rFixQpo2bSrt27eXU6dOmRPr9u3bzTp6ktamCj2plytXTrZt2yafffZZgufRE+93330nZcuWNX9fuXLFnLjHjRsnt99+u7Ru3Vq+//57c+I/fvy4z+9FT/gacrQfSalSpbwqu9ZuHDx4UGbNmpXgubSJRYOE63m8Kau+X60xKV68uDz44INSuXJlE1xeffVVn98LkJFRcwFkcPny5ZN27drJBx98IE8++aTHdT788EPTD+PLL7+UbNmymftatWplajvmz58vkZGRN3WubNu2rVl/9OjREh4ebu5ftGiRqVmoXbu2+VtrObZs2WJOytWqVTP3NWnSxDz3mDFjZPz48cmWXWtHcufO7Q4We/fulSxZssiAAQO8LvuIESNMQPj3v/9tQkLhwoXNOgsXLjQdRBs0aOB1WefOnWtqZXr27Ol+/bp160pUVJSPewXI2Ki5AIJAly5dzDf7pGoL9CQ6Y8YM01lTv+0vXrzYnNi1E6WeuD3R2oILFy6YzpUqOjpavv32W+nQoYN7HW0+0BO162StIiIiTN8JLU9ytSmqZcuW8thjj7l/NBxp04s2cfz6669el13LGhcXZwKI0t+XLFlimjMyZ87sdVm1lkPf7/Tp093bUjucusIUgP+i5gIIAqGhoaZ5RDt3vvXWWzct15Om1kAsXbrUnGx1eKr2JciRI0eCvg3xaV+FihUrmtqKZs2ayfLly03AiB8ujhw5Yp4j8aiUw4cPm5O/jmopUqSI1x06ldY06Gu8//77prnHm7IXK1bMPI+GC6112LBhg/z555+mRsOXso4cOdL0rdBaDN2WGiy0KebRRx+V/Pnzp7gfgGBBuACCxJ133mmq/NetW3fTsuHDh5v+FJMnTzYnb9e3ee0kmRw9OU+cONF0qNSQod/g44/g0OepUKGCqXXwJE+ePD6/D+3noENr//jjD5/KrrUX2oFT+1poWbVc8Zt7vClr1qxZTTjTTqMbN240fTJmzpxpmli0JkSbbADQLAIEFZ03Qoel6nDO+FauXGn6EuiP6+R8/vx5OXnypGlCSIp2ntTmAu1kuXr16gQ1AUprEbRzpc61Ef/nP//5jzn5u/pq+EJfT2sRtDbCl7JrE4vWTGjthdZyaNlTW1bt26HLXnjhBRNutHZD+4MA+C/6XABBRDswagdF7QQZn3bC1Am3tPpfafjQERDarOC6z5OCBQvKPffcYwKLNr3oc8fXvXt3M2xVO0u6aM2BNmdoOEjN8M2pU6eazp06WsOXsmv/CS2fjhq5dOnSTeEipbKqZ5999qaZQ3///XfJnj27e4gsAJpFgKCj/QM+//zzBPfpN3AdgaH9B8qUKWO+rWvHxjp16pjfk6O1FVp7oKNHtGYgPn0+7Q+hTQmffvqp6ZegnS61z4T2AUlJ/NEiSptCtJOmjgDRmgNfy65NI1oLoSNJEvf1SKmsGoR0eKq+9ieffGLm0tB+G9pEon0wcubMmeL7AYJFSFxydZ4AApI2G+g8FDpfg6fJqvQkvX//fjNJlE4EpbQz5p49e0xTgn4L1/td6+nJ+NixY+Z3vbZH/CnAtRZBJ53S/gqJpxl3cU3drU0aGgBS6vyoE1Tp+vFpk4f2eyhfvvxNzSkplV2Hzro6bd53330mtCSuufC2rFozok0gGnJ022ofEK21AfD/CBcAgsbrr79uJvlyjSwBkDY4ugBkeNpssWrVKtNMon02CBZA2qLmAkCGp006OgW4zsvhagYCkHYIFwAAwCqGogIAAKsIFwAAwCrCBQAAsCqoRots3rzZjIN3jXkHAADe0blfdI6bWrVqpbhuUNVcaLDwZc4wXVcnCGKeMWdhvzgX+8aZ2C/OFBdg5xhfzqFBVXPhqrHQWQm9odP67tixw8wIqBcqgjOwX5yLfeNM7Bdnuhxg55jffvvN63WDquYCAACkPcIFAACwinABAACsIlwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqwgUAALCKcAEAAKwiXCDghISESEREhLkFADhPZn8XAPBGbGycZMr03zChwSIyMlJuxMay8QDAgQgXCAgaLN786Bc5fDzK/F28cE4Z/Mid/i4WAMADwgUChgaLfUfO+7sYAIAU0OcCAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYlVkc4tq1a3L9+nXJli3bTcvOnDkjN27cSHBfRESE5MiRIx1LCAAAAiJcnD9/XkaNGiXLly834aJ8+fIyevRoqV27tnudli1byoULFxI8rnPnzvLKK6/4ocQAAMDRzSIaJJYtWyZxcXESFhYme/bskR49esjRo0fN8iNHjphgocsKFCjg/smZM6e/iw4AAJxWcxEbGyvnzp2TSpUqybvvvit58uSR7t27y+bNm2X9+vXSsWNH2blzp1m3U6dO8vzzz5uQoT8AAMCZ/BouMmXKJO+//775PTo6WrZv3y5//vmn+bts2bLm1hUufvjhB/n0008lPDxcHnnkERkyZIh5PAAAcBa/97lwmTdvnrz88ssmMPzjH/+QGjVqJAgXx48fl6xZs8qVK1dkxowZUqRIEXnsscd8fh1tfrl8+bJX62rgiX8L/wgJCTEdeD3RfaP7FM7AMeNM7Bdnig6wc4x+1urncUCFCw0POlJET/yffPKJNGnSREqUKCFFixaVihUryrBhw6R+/foyefJkmTBhgqnxSE24iImJkR07dvj0mAMHDvj8OrBHg0VkZKTHZfv37w+YAzOYcMw4E/vFmQ4E0DlGWw+8ERLngK99Ogw1NDTU/IwdO1amTZsm9913n0yZMsUsv3r1qmTJksU9LLVevXrmd+2b4WnoalJ+++03k7x0RIo39KSlO7106dJJfnNG+tVcDBz3g+w7ct7cV65Ybhn/bGNqLhyGY8aZ2C/OFB1g55i9e/eaz+Pq1as7u+ZC+1c89NBDpilE+1SoRo0amXCxa9cuEyp0GOqJEydk7dq1kjt3bneThnbqdAUOX+iG8SWQKN3pvj4G6SMQDshgxDHjTOwXZ4oIkHOMt00iyq89IrXfhI4YOXbsmEydOtVUcbs6eGqS0/Cgw051Aq3XXnvNLB83bpxZXqdOHVPTAQAAnCWTv1PQ4MGDze9vv/22tGrVSr7//nvTptOvXz9z/6BBg8x68+fPN8sXL15sai2eeeYZfxYdAAA4tUPn/fffb25nz54tUVFRUrlyZenfv79UqFDB3K/9K7Q2Q+fBOHjwoJQpU0b69OnjHk0CAACcxe/hwhUwXCHDEw0Yrk6cAADA2ZiFCgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAGTMcPHnn3/KgQMH5MaNGx6Xnzp1Snbv3i1XrlxJ97IBAIAAChfHjh2TLl26SOPGjaVly5ZSv359+frrr93Lr1+/Ls8995zcc8890q5dO7N80aJFfi0zAABwcLgYOXKkbN68WXLnzi2FChWSc+fOyaBBg2T//v1m+QcffCBffvmlZMqUSYoUKSKXLl2S4cOHyx9//OHvogMAAKeFi9jYWMmbN6/ce++9smLFClm1apXcfffdEhMTYwKHmjdvnrl9/fXXZeXKlWbda9euUXsBAIBDZfbni2ttxBtvvGF+P3PmjCxZssT0qwgNDZVq1aqZWgpXDUaDBg3MrTaPaMjYvn27P4sOAACcGC7iW7hwoYwZM8YEDr2tWLGiHDp0SOLi4iQkJMTUcChtPnF18EwNfb7Lly97tW50dHSCW/iH7v+IiAiPy3Tf6D6FM3DMOBP7xZmiA+wc4zofB1S40FqKMmXKmJoKrc2oXLmyhIWFmWUaOFxvSGs1lDaNpIY2uezYscOnx+goFviPBovIyEiPy/T/JVAOzGDCMeNM7BdnOhBA55jw8PDACBd6sj99+rQ8/fTT5mfatGkyduxY08filVdeMevo8FQdNZI5c2b3UNTs2bOn6vU0sJQvX96rdfWkpTu9dOnSSX5zRtpLLilrIKXmwjk4ZpyJ/eJM0QF2jtm7d6/X6/o1XBw9elSaN29umjq0M6fWSlStWtUsO3jwoBk9omFAA8iRI0ekVKlS5laVKFEi1SeqbNmy+fQY3em+PgbpIxAOyGDEMeNM7BdnigiQc4y3TSJ+Hy1y2223meGlWnOhtRRr166ViRMnmmXaLKI1FbVq1TJ/jx8/Xn744QdZsGCB+btevXr+LDoAAHDqPBcjRowwaeijjz6S7t27y6ZNm0xNxjPPPGOWa1OJhgwdSdKrVy8zk6d29mzVqpW/iw4AAJzY56JJkyYyffp0Ey6ioqKkUqVK0rNnT9MkourWrSszZ86UWbNmycmTJ02zSZ8+fdydPQEAgLP4PVy45rBwzWPhSZ06dcwPAABwPr83iwAAgIyFcAEAAAgXAADAuai5AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVmcUh9u/fL8ePH5eSJUvKbbfdlmDZzz//LNHR0QnuK1q0qFSuXDmdSwkAABwfLk6dOiWDBg0yAcKlTZs28tprr0l4eLjcuHFDevXqJVeuXEnwuM6dO8srr7zihxIDAABHh4uXXnrJBIs8efJIxYoVZdOmTbJ48WKpUKGC9O7dWw4cOGCCRf78+aV69erux1FrAQCAM/k1XFy+fFlWrFhhfp89e7YJF++//76ptdDAoeFi586dZnnr1q2lVatWkj17dqlSpYo/iw0AAJwaLq5duyaPPfaYnD9/3gQLpTUUKiIiwty6wsXcuXNNAFF33323TJ48WXLkyOG3sgMAAAeGC20KGTJkiPvvq1evysyZM83vbdu2TRAusmbNKpUqVZKtW7fKunXrZNKkSfL888/7/JpxcXGmxsQbrk6kiTuTIn2FhIS4w2Zium90n8IZOGacif3iTNEBdo7Rz1r9PA6IPhcuunH79u0r27Ztk0aNGplOnapZs2ZSoEAB6devnxlFsnTpUhk4cKAsWLAgVeEiJiZGduzY4dNjtN8H/EeDRWRkZJKjjALlwAwmHDPOxH5xpgMBdI7RgRYBEy4uXrxoRoRs3LhR7rrrLhk/frw7HTVp0sQ0mbiGp9avX9/cnjt3zjzO16aRsLAwKV++vFfr6klLd3rp0qWT/OaMtJdcUi5Tpgw1Fw7CMeNM7Bdnig6wc8zevXu9Xtfv4UKbQnr27Cm//PKLNGzY0DR3aBOIq09G06ZNze3y5culePHi8ueff5pluo527kzNiSpbtmw+PUZ3uq+PQfoIhAMyGHHMOBP7xZkiAuQc422TiCPChc5VocEiZ86cZu6KtWvXmvv179q1a0u9evVk5cqV8txzz0nXrl3lgw8+MMubN2/u0xsFAADpw6/h4ujRozJv3jzze1RUlAwYMMC9rGrVqjJ//nwZOnSobN682QQQ/VEFCxaUZ555xm/lBgAADg0XR44cMU0hnpQqVcrclitXThYuXChz5syRgwcPmjb2Rx991AQMAADgPH4NF3Xq1DE/KdHriOgU4QAAwPm4KioAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMD/4eLs2bN2SwEAAIL7qqhdunQxVyrt0KGDtGjRQrJnz26/ZAAAIHhqLvr3729uhw8fLg0aNJDBgwfLqlWr5MaNG7bLBwAAgqHmok2bNubnxIkTsmTJElm4cKE8+eSTUrBgQWnXrp2p0ahcubL90gIAgIzdobNQoULSvXt3mT9/vixdulTuu+8+mTFjhgkXDzzwgCxfvtxeSQEAQMatuYjv4sWLsmzZMlm8eLGsX79ewsLCpHHjxhIaGioDBgyQbt26ydChQ+2UFgAAZMxwoX0r1qxZI1988YV89913cuXKFalSpYo899xzplkkX758Zr1du3aZGozevXtLrly5bJcdAABklHDx0EMPye+//y558+Y1v2uA8NTHolKlSpInTx6JiYmxUVYAAJBRw0WtWrXkqaeeMs0f2gySnDlz5kj+/PlTWz4AABAM4WLEiBHu32NjYyVTpv/2Cz1z5oy7ScSlZMmSt1pGAAAQDKNFPv/8c2nSpIn88ccf7vu6du0q/fr1k0uXLtkqHwAACIZwoZ04R40aZZpF4jd5DBkyRPbv3y+vvvqqzTICAICMHi7mzp1rmkZeeOEFyZEjh/v+Zs2ayfTp02XRokVy/fp1m+UEAAAZOVzozJw1a9b0uKxw4cKSM2dOOXXq1K2WDQAABEu4KFasmPz0008el+3evVuioqJu6tgJAACCQ6pGi3Tu3FkGDhwo58+fN1dF1WuKXL16VbZs2SITJkyQ9u3bS3h4uP3SAgCAjBkutG+Fhovx48fLtGnTEixr2rSpuVoqAAAITqm+toheBfXBBx801xPRPhgRERFSo0YNKV++vN0SAgCA4LlwmV5TpEyZMlKqVCn3hFra50KVLl2aphEAAIJQqsKFjgR55plnTK1FUr755ht36AAAAMEjVeFi4sSJcvjwYRk5cqQUKlTIPf13fNrJEwAABJ9UhYvNmzfLSy+9JA0bNrRfIgAAEHzzXGTJksVcbh0AAMBKuNALlumFywAAAKw0i+gIkVmzZsmePXvM8FMdhppYt27dJE+ePKl5egAAEIwdOnWK702bNpkfTzp06EC4AAAgCKUqXCxbtsx+SQAAQIZwS5No6aiRH374wczQOXjwYFm9erU0btxYcuXKZa+EAAAg43fojIuLkxEjRkiXLl1k6tSpsmDBArl48aJMmjTJNIccOHDAfkkBAEDGDRcff/yxfPvtt/LWW2/JL7/8IiVKlDD3z5gxw0z7/eKLL9ouJwAAyMjhYvHixWZ2zrZt20r27Nnd9xcvXtxccl0Dh16CHQAABJ9UhYszZ85I2bJlPS7T/hYaOHQdAAAQfFIVLrQZJKkRI9rJMzo6WgoUKHCrZQMAAMEyWqRr167Su3dvOX36tGkauX79uhw9etRcJfXtt982nTrDwsK8fj59/IYNG+T48ePmSqq33367hISEuJfHxMTImjVrzOtFRkZK5cqVU1NsAADg1HChw02HDh1qOnTOmzfP3Ne9e/cEy7x16NAh6dOnj5nt06V27dry7rvvmuaVCxcumNk+d+7c6V7eo0cPM/QVAABkoHkuNExorYXObaHzXGTLlk1q1qwp1apV8+l5Ro8ebYKFdgatVauWLF++XDZu3ChTpkwxAWLy5MkmWOgl3PX5V6xYIe+99560bNlSqlevntriAwAAJ4ULbb7Qpgp15513Jlh2+PBhc1ukSBHJnDn5p9e5MdauXWuaQPRaJcWKFZNPPvlERo0aJVu2bHGPTFFjx46VevXqybBhw2T+/PmmzwfhAgCADBIuHn30UdOckZxvvvnG9J9IyfDhw+XcuXMmWKhMmf7bx1Qv6a73a62IcgUJvVCahovdu3enpugAAMCJ4WLIkCGm1iG+a9euyf79+00fjH79+knRokVTfJ4cOXKY/hQu58+fl2nTppnfO3XqJGfPnjW/a82Grut6jGvd1M4uevnyZa/W1VEv8W/hH7r/PV1517VvdJ/CGThmnIn94kzRAXaO0c/a+IMtrIeLFi1aJLmsefPmZoZOVwdPb2mQeOKJJ8zU4R07djQdQ//zn/+YZZ7eTGxsbCpK/t+RJzt27PDpMUxn7l8aLHSUkCcaaAPlwAwmHDPOxH5xpgMBdMmM8PDwtL9wmSc60kODgg4bzZ8/v1ePOXnypAkje/fulVatWsnLL79s7nfN/qlBQmf8zJIli7vWIWfOnKkqnw6RLV++vFfr6klLd7pOaZ7UN2ekveSScpkyZai5cBCOGWdivzhTdICdY/Qc7S3r4eLUqVM+NVnoUFNXsNAai1dffVVCQ0PNskKFCplRKBoo9u3bZ769ut5cUjOEenOi0uf0he50Xx+D9BEIB2Qw4phxJvaLM0UEyDnG2yaRVIcLvXCZhoLEbTHaD2Pp0qVSsWJFr2st9OqqGhi0JkI7a3766afmfn28Nr80bNhQvv76a3MtkyZNmsjnn39uluvvAADAeVIVLqZPn+5xtIg2ObiGi3pD28s1OKioqCh56aWX3MuqVq1qwsXAgQNl3bp18vvvv5sf1bRpU7nnnntSU3QAAODEcKFzTCTuoa/VJa7mDG9poHj44Yc9LnMNTdXmj0WLFsmCBQtM3wwNHe3atUtNsQEAgFPDhfarcE2i5Y2kJtTSZhD9SYn2vejVq5fP5QQAABloEq3UTKgFAACCNFy88MILMmDAADNrpl4BVWsmdESHTtn94Ycfmv4QOk+Fi7edOwEAQJCGC62J0IuW6WRZ8WlHy0aNGplOmOPHj3dP5Q0AAIJHqs7+mzdvls6dOyc5idb169fd1wQBAADBJVXhQuek2L59u8dlevl0ne8iV65ct1o2AAAQLM0iOhR0zJgxZibOZs2aScGCBc3vGzduNM0h2g8jEGYbAwAADgkXXbp0MdNxjxs3Tt56662bLlyms2kCAIDglKpwoRNm6bTdern0NWvWmIuUaVNJnTp1krx6JQAACA63NJzjzJkzcuzYMTly5IgZPaLXCEl8zREAABBcUhUudOpvrbnQ5pGpU6eaqbm1E+ekSZNMf4tAujY9AABwQLjQq6J+++23pr/FL7/8IiVKlDD3z5gxw1yXPvH8FwAAIHikKlwsXrzYdNrUppDs2bO77y9evLhMmDDBBI6rV6/aLCcAAMjI4UL7WujVSj3R+S00cOg6AAAg+KQqXGgziF52PanZO6Ojo6VAgQK3WjYAABAsQ1G7du0qvXv3NkNQtWlEp/s+evSorF+/Xt5++23TqTMsLMx+aQEAQMYMF3rF06FDh5oOnfPmzTP3de/ePcEyAAAQnFIVLlxhQmstVq9ebS5SptN916xZU6pVq2a3hAAAIOOHC53bokaNGlKvXj3TBAIAAHDLQ1F1CnAAAAAr4aJYsWJy6NCh1DwUAABkcKlqFqlfv76MHj1alixZIuXKlZP8+fPftM4jjzwiuXPntlFGAACQ0cPFrFmz5MaNG7J27Vrz40mbNm0IFwAABKFUhQu9rggAAMAt9bnQ2opz5855uzoAAAhSXoeL2bNny/nz5xPcN27cOK4hAgAAbn20iMvSpUslKirqVp4CAABkMLcULgAAABIjXAAAAKsIFwAAwCrCBQAA8N88FzrrZqZM/59HTp06ddN9LnPmzJHixYvbKSUAAMh44aJ27drm0urxVahQIcn1w8PDb61kAAAgY4eLMWPGpG1JAABAhkCfCwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgP8uuZ7WFi5cKPv27ZMePXpIjhw53PfPmDFDzp8/n2Dd6tWrS7NmzfxQSgAAEBDhYv/+/TJixAi5evWqdO3a1R0u9O+33npLrl+/nmD9zp07Ey4AAHAgR4SLXbt2Se/evU2QSGzPnj0mWFSoUEFat27tvj8yMjKdSwkAAAIiXMydO1deffVVuXHjhmTKlEliY2MTLN+5c6e5rVq1qoSHh0v27NlNyMidO7efSgwAABzdofP33383QWH69OmSNWvWm5a7wsUXX3whY8eOldGjR0vbtm3l8OHDfigtAABwfM1Fly5dZOTIkR6DhavJxNUMUrduXVmyZIkcO3ZM3njjDZk4caLPrxcXFyeXL1/2at3o6OgEt/CPkJAQiYiI8LhM943uUzgDx4wzsV+cKTrAzjH6WaufxwERLnTUR3IGDRpkai86duxoAkiLFi1MIFm1apVPb9QlJiZGduzY4dNjDhw44NP6sEuDRVJ9bLQjcKAcmMGEY8aZ2C/OdCCAzjHaPSEgwkVyrl27JidPnpQrV664azbKlStnbrX24dKlSwmGrHojLCxMypcv79W6etLSnV66dOkkvzkj7SUXIMuUKUPNhYNwzDgT+8WZogPsHLN3716v13V0uMicObMMHz5cLly4IHfccYfUqFFDtm3bZpblyZPH52DhOlFly5bNp8foTvf1MUgfgXBABiOOGWdivzhTRICcY3xpKXB0uNDRIy1btpTPPvtM+vbta5pEtM+Fa54LAADgPH4fLZIS7XNRpUoVOX78uMyePVtOnz5tajGefvppfxcNAAA4veaiT58+psNl/OaOvHnzyqeffio//vijHDp0yLRN3XvvvRIaGurXsgIAgAAIF3pNkaR6p3IdEQAAAoPjm0UAAEBgIVwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAIBwAQAAnIuaCwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAFYRLgAAgFWECwAAYBXhAgAAWEW4AAAAVhEuAACAVYQLAABgVWZxkPfff1927dolw4YNk9y5c7vvP3LkiMybN09Onz4tkZGR0qlTJwkPD/drWQEAgMPDxdatW+XNN9+U69evy8CBA93h4uDBg/Lggw/K+fPn3et+++23Mn36dD+WFgAAOLpZZO3atdKjRw8TLBKbOHGiCRa1atWSQYMGSc6cOeWnn36SH374wS9lBQAADg8XU6dOlccff1yuXr0qoaGhNy1fuXKluR01apT07NnT1GIowgUAAM7k93Bx6NAhqVChgnz88ceSJUuWBMtOnjwpUVFR5vdy5cqZ27Jly5rbAwcO+KG0AADA8X0uevXqJSVKlJCQkJCblrmCRaZMmdzBIyIiIsEyX8XFxcnly5e9Wjc6OjrBLfxD/zdc+z0x3Te6T+EMHDPOxH5xpugAO8foZ62nc7Ujw0XJkiWTXOZ6E/FPHrGxsebWUxOKN2JiYmTHjh0+PYZaEv/SYKGjhDzZv39/wByYwYRjxpnYL850IIBq4r0dqen3cJGcPHnyuMPFxYsXJUeOHO4ai7x586bqOcPCwqR8+fJerasnLd3ppUuXTvKbM9Jeckm5TJky1Fw4CMeMM7FfnCk6wM4xe/fu9XpdR4cLDRD58+c381ts2bJFGjRoYG5VpUqVUn2iypYtm0+P0Z3u62OQPgLhgAxGHDPOxH5xpogAOcd42yTiiA6dKWnVqpW5HTx4sDz55JOyaNEi8wZbt27t76IBAIBADBf9+/eX6tWry5kzZ2TVqlWmCrxv375SuXJlfxcNAAA4vVnkxRdfNBNpxZ/6W/tdfPLJJ7JhwwY5deqUVKlSxT0sFQAAOI+jwkX79u093q8jQ+rWrZvu5QEAABmwWQQAAAQWwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAqswSAAYPHixnz55NcF/Dhg2le/fufisTAAAI0HBx8eJF+eqrryQuLi7B/UWKFPFbmQAAQACHi507d5pgcdddd0mPHj3c9xctWtSv5QIAAAHa50LDhcqaNavMnz9fvv76a8mfP79UqFDB30UDAACBWnOhfvzxR/d9CxculA8//FBq1qzpx5IBAICADBe7du0yt+3bt5cmTZrI7NmzZdOmTfL666/LnDlzfH4+bWK5fPmyV+tGR0cnuIV/hISESEREhMdlum8S98eB/3DMOBP7xZmiA+wco5+1+nmcIcLFzJkzZf/+/VKtWjXzd6VKlaR169aydetWuXHjhoSGhvr0fDExMbJjxw6fHnPgwAGf1oddGiwiIyM9LtP/jUA5MIMJx4wzsV+c6UAAnWPCw8MDP1xcvXpV3n33XTl8+LC88cYbJkjky5fPHRJ0ebZs2Xx6zrCwMClfvrxX6+pJS3d66dKlk/zmjLSXXFIuU6YMNRcOwjHjTOwXZ4oOsHPM3r17vV7X0eEiS5YsphPniRMnpEWLFtKyZUtZuXKlWVa8eHGfg4XrROXr43Snp+a1kPYC4YAMRhwzzsR+caaIADnHeNskEhCjRR5++GH3RFpdunSRf/zjH+bvxx9/3M8lAwAAARkuevbsKR07dpRr167J5s2bTT+LRx55xPwAAADncXSziKvziI4MefbZZ+XgwYNSqlQpKVy4sL+LBQAAAjVcuGigIFQAAOB8jm8WAQAAgYVwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIF/CI2Ni7ZvwEAgSuzvwuA4JQpU4i8+dEvcvh4lBQvnFMGP3Knv4sEALCEcAG/0WCx78h59gAAZDA0iwAAAKsIFwAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlxYwnTWgcfTlONMQw4At44ZOi1hOuvA3meKacgBwA7ChUVMZx142GcAYB/NIgAAwCrCBQAAsIpwAQAArCJcAAAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqwkUGv55JSuv4+re64cU6vixPzWPy5Mxi/Xou3jwn15BJf2xzIPCOFab/zuDXM0lpHV+WqzsqF5K/t45M8XW9eQ5vH+Np/RwRYdav5+LNc3INmfTHNgcC71ghXATBtTFSWseX5cUL5fD6dVN6Dm8fk9z6aXFtkFvdXrCPbQ4E1rFCswgAALCKcAEAAKwiXAAAgODrc7F69WqZOXOmnD59WiIjI6Vfv35SuHBhfxcLAAAEYrjYuHGj9OjRQ27cuGH+3rZtm2zYsEEWLVok4eHh/i4eAAAItGaRKVOmmGDRoUMHU3tRrFgxOXDggCxZssTfRQMAAIEWLjRUrF+/3vz+9NNPS7169aRTp07m73Xr1vm5dAAAIODCxYkTJ+TatWvm99tuuy3B7eHDh/1aNgAA4FlIXFyc/+YHTcG+ffukdevWEhoaKtu3bzf3ffXVVzJo0CCpWrWqzJ8/36fn27Rpk+jbDQsL82p9Xff69euSOXNmCQkJSXZdXX7+4jW5fiNWModmktw5ws3j05I3r5nSOr4sV1nCQiVHtjCf3mtqniP+YxKvn9py2C5Xeu3nQKLbQmsc9ZhN6ZjxFtvcmfsFztsvIWn8+RQTE2Ne44477gjsDp2uEKAbXzeQvik92avUdOZ07Txvd6Ku58vr6I709HppyZvXTGkdX5d7+7q3+hyJl9soR1qUiw/rhNsiUyb7FaJsc2fuFzhvv+ROw88nfS5vn8/R4SJfvnzu38+dOyd58+Y1t6pgwYI+P1+tWrWslg8AANzM0VE2R44cUrJkSfP7ypUrTe3FqlWrzN/Vq1f3c+kAAEDA9blwDUUdP368qYrRmoszZ85I1qxZZdmyZVK0aFF/Fw8AAARSzYXSCbQefvhh0y6lwSJPnjwyduxYggUAAA7l+JoLlwsXLphwoUNRmZkTAADnCphwAQAAAoPjm0UAAEBgIVwAAACrCBcAAMAqwgUAALCKcAEAAKwiXAAAAKscfW0RIDY2VlasWCE//vijHDx4UC5evGiuUquztVauXFnatm0r5cuXZ0MBIub4eOedd2TLli3mGHnggQfk3nvvdW+bb775xixv2bKl9OrVi22Wjvbs2SO//fab3H777VK2bFlzle5x48bJ0aNHpUaNGuZq3yVKlMgw+4RwISKnT582l5L1Rv78+b2+ZDtuTXR0tJmhdcOGDR6Xf//99/Luu+/KkCFD5PHHH2dzp+MJTH+8vT6Q/iDt6ZRFerzoScvl66+/lvvvv1/++c9/ms8t/azbtm2bVKtWjV2Sjj7//HMZOXKkucK37ofXX3/d/H3p0iWz/MiRI7Jx40ZZsGBBqi7K6USEi7+mGNcDzhvz5s3jomnpZM6cOSZY6JTvDz74oJQqVUoiIiLMARoVFWU+RBcvXmymg9dvYjp7K9KefvN97733vFpXv4317NkzzcsEMceD/mTPnl2GDh1qLpkwbdo0c8K6cuWKvPXWW2wmP7h06ZK8/PLL5nPrnnvuMbVKgwcPNstGjRolpUuXljfeeEN27twps2bNMsdMRkC4EJGqVau6w4WmyuRqJkJDQ9Nv7wS57du3m9v+/fvLI488ctPyRx99VI4dOya//PKL7Nq1i3CRTrQZKkuWLHL16lVzAtMLCSaFWr7088cff5jb++67z1yPSbVo0cLU6i1dutTsM61+R/rat2+fXL58WcqVKyfTp0+XTz75xISKmjVruj/X+vTpYz7ndu/enWF2D+FCxFQZNmjQwKRJrZLSKqx8+fL5e98EPW2CclXt3nnnnVKmTBnzAam0Wl5DhetgzChViYGgY8eOpvbuiSeekJMnT8rUqVPlrrvu8nexgl7hwoXNNvj1119NO77W5OXOndvUXnTr1k2++OILWb58edBvp/SW5a/PrHPnzplA3rhxY3n++edNTYa6du2ae79kpPMO1xaJR6ukXnnlFfnb3/5mLvMO//rPf/5jOqRp6nfRb8rathz/kjh33323fPDBBxISEuKnkganHTt2mOYq7TioH45cUNC/rl+/Lh06dJC9e/eaY6Fv377mR504ccLUYOgypTUbL730kp9LHBzi4uJMx3Pd9nobv3lK79PaCw0eWsunTcEZpXaJoaiJqtk14efKlct0JoR/aY9q7eOi/SmyZcvmHj3iChaFChUyH5iTJ08mWPhBlSpVZNiwYdKoUSP3SQv+o6OopkyZYmphNVxoXyUXPVb0xKXNJEhfISEh5jNKvwRpEI9Pa1w1WOhnndYwZZRgoai5QEDQQKHfvrQ5RPu96Adn/A9PAP/PNZrH00gdrRHU5RnpRBYoYmNjTe1rfK4mrIyGPhd/0XavZcuWydq1a+Xw4cOmh69W8xYoUMAM22rXrp0UK1bMv3srCDHPhXP9/PPPpjlET1bnz58339C0jb9ChQqmtknH8yP96VwK+lmm/ZF0v+gxlDNnTvPtuEmTJmbEAtLf/v375auvvjId1c+cOWOasXRkj46C09qm5s2bZ6gBA9RciMipU6fkscceS7ZqVzvlvPbaa9K6dev03D9BLaV5LpQejMxzkf61SNr5WT8ok6NtydorHunnzTffTHGYcNOmTeVf//pXhjqROd3cuXPNcFQNFEnR0SM6mkSDYEZAuBAxHZs++ugjKVq0qOlAqDUUWmuh/wjaHrZ69WozQ6RWMervyQ29gz16oOn475TmudAPye+++y5DVi06kW7rp59+2hwHul8qVqxo+sToN2Stbtfx+vPnzzcT082ePZuRJOnYwVZH8ujxoB07tdnD1SyinaL1y5OOhNNaWf2ipJNrIe2dPXtWGjZsaI4HrZ2oW7eu6denzSP6BUqHEOvxoiOvevfuLQMHDswQu4VmkXjzKYwePdoME0qse/fuZgpdnVPh0KFD5sMUaY95Lpy9X3TEwfDhwz2uox+k+oGp6zJMNX33izZ9jBkzxuM62myltRa6LuEi/ea5iImJMeeNSZMmJTl3jNbAakDMKBgt8teU3mrhwoWmXcw1FbhW/2rNxaJFi0yq1DZl7YOB9J/nQr8N6xhxF/2GvHLlSua58ON+WbNmjZltMP7IKv2GrNMYr1+/3j1KAem7X3SfaN+x+FO067GjEwXqlPmKeWHST76/5q7QL6Z6bRc9p7jouUbDx5IlSzLcfqFZRMR8EOqQxvjtYVq1GH/Yo+rUqVOS3whgH/NcOJN+OLZv316OHz+e7PwjOq3xl19+STNiOnZK12YqDeIu+oVIf/SzzEWHQ+oXpox0InO6p556yh3slO4TPWZcE2m5+vXp7J06xDsjIFz8ZfPmzWYs8rp16xJ8Q1Z6pTqtQtRrJDCdcfrSVD9hwgRZtWpVgsm0XN+K27RpYyYK4uJY6UuDxcSJE03/i/jfxJT2kdEpqJ999llOYOnswoUL5nNM+yLp0O34tF+Mtv3rftHgh/QNftP+us6L1mDEp/37tOlwwIABGWp4MOEiEU34elBqpyedlEarGjlx+R/zXDiXXmlTT2pKO6q5qufhXxr6tDOhHjv6GaY1Fcxi638XL140x4xrKKrul4w4codw4aWffvrJjBnXMeLaKQrOoNcX0Y62eu2RIkWK+Ls4+ItWzWutU+XKlc0Fm+AM+q1Z58EoWbIkV3d22HQI69atM336dCbPjIAOnV4aN26cqU5MXKUF/9Jriuh+0Ys1wTl0DgzdL1woy1l0KL3ul88++8zfRUE8OuGZ7hedvj2jYCiql+644w7TESqjTHCSUWjnJ23CYhSPs+gVbLWWr3jx4v4uCuLRuWB0v+gsqnCOvHnzmv0SGRkpGQXNIgAAwCpqLv7CtUWciWuLOBfXFnEmri3iTPu5tkjw4doizsS1RZyJa4s4F9cWcaa5XFskOHFtEWfi2iLOxLVFnIlrizjTWa4tEry4togzcW0RZ+LaIs7EtUWcaR/XFgleXFvEmbi2iDNxbRFn4toizpSPa4sEL64t4kxcW8SZuLaIM3FtEed6imuLBC+uLeJMXFvEmbi2iDNxbRFnusa1RcC1RZyJa4s4F9cWcSauLeJMF7m2SHBbu3atuZZIvXr1uJYIAAA+YIbOJHTq1Em2bdsm8+bN4wI/AAD4gAuXAQAAqwgXAADAKsIFAACwinABAACsIlwAAACrCBcAAMAqhqIm4dChQ3LlyhUpVaqUZMmSxe5WBwAgAyNcAAAAq2gWAQAAVhEuAACAVYQLAABgFeECAABYldnu0wGBY/fu3fL111+b3x955BHJly/fTevExsbKO++8Izdu3JCOHTtKiRIlbuk1Z86caZ6jadOmsmHDBvn555/l6aeflkyZ0jbnHzt2TD777LNk1+nXr5/V1zxw4ICEhobe8ja7FdevX5cpU6ZItWrVpEmTJuJ0TthmgA3UXCBo7dmzRyZNmiTTpk1zh4zE1q9fL++++65Z748//rjl15w1a5asWLFC0puGC30PeqXf9LB3715p166dlW12KzQU6vv+/vvvxemcss0AG6i5QNC75557ZOnSpdK1a9ebtsWSJUukYcOG8s0331jfTnXq1DE/6UlrTB588ME0f52LFy/KtWvX0vx1MhK2GTISwgWCXosWLWTYsGFy+vRpyZ8/f4Iq9e+++06ee+45j+Fi586dsm7dOnMSrV69utStWzfB8ri4OFm7dq2pLciTJ4+0atUqwfKkmkV+/fVX2bJli0RHR0vRokVNdX6uXLncj9mxY4cJQloDotXoBQoUkObNm7vXsSGl95ZcOfft2+dugvniiy/kyJEjJtDotti8ebP06dPnpqai4sWLS7Nmzcxrao3Svffea95f1qxZpWXLlmb7eVuulOg23LVrlzzwwAOyfPlyUz4tv/4f6OutWbNGfv/9d7Nd9bWzZ8/ufpzuy4cfftjUdJ04cULKli1r3rc2ZSTefrp9oqKiTJOMljMkJMQs8/QeK1Wq5HGbpbStff2f0PettXHa3FerVi2pUaNGqvY9kBKaRRD09AShM7EmDhCrV6+WcuXKeeyL8c9//lM6deokW7dulZMnT8qgQYPkySefNLO6qqtXr5q/n3nmGTl69KisWrVK2rdvL+fPn3c/h54UtMpeP+iVfpg/9dRTMmDAADl8+LCcPXtWJk+ebELJn3/+6X6MNtPoCU5PQhcuXDB//+1vf5Pjx49b2ZcpvTdvyumJBint/+CpqUhDnNIT34QJE+Tvf/+7OcHOmzfPnHy9KZe3dBtqebUPjTaXnDp1Sl544QX5n//5H+nfv7/pY6PPr+XQAKL70vU4Lf/9998v8+fPN+HixRdfNCHgzJkz7kD6/PPPS5cuXUwg0O0zcOBA6datm9lXSb3HpGYBtvU/oUF31KhR0rlzZ/ntt9/k4MGD0r17dxkzZoxP+x7wWhwQpL766qu4ihUrxm3dujVu3Lhxcd26dUuwfMiQIXGzZs2KW7lypVlv9erV5v7PPvvM/L1o0SL3ukeOHImrVatW3GuvvWb+njJlSlxkZGTc3r173et8+OGH5nHDhw83f//73/82f8fExJi/P/roo7iqVavGHT161P2Yixcvxt1+++1xb7/9doLHvP/+++51zpw5E1e9evW48ePHJ/leN2/ebB7Xq1evuIkTJ970ExUV5fV786acrtdzbTOl27hatWo3la1JkyZxQ4cONb9rWfRx8+bNM3/HxsZ6XS5Prly5Yh43cuRI932ubTh9+nT3fR988IG5r1+/fu77tmzZYu775ptvEjzOtf/UsWPH4mrXrh03bNgw9zqVK1c279/l8OHDcXfccUfcs88+m+x79LTNbP1P6Gslfu41a9aY+37++edb2saAJ9RcACKmCnnjxo2maUTpt1WtYtb7E9Pqa63taNu2rfu+2267zVShf/755+Zb4qJFi6RRo0am5sNFv1km13SRN29eGTlypKn21ufQb6pa4xEeHn5TJz/t+Bf/cdqsoN9Gb5U3782XcqaWqyre1ZTgTbl81aZNG/fv5cuXN7fxm65c92ntQnxau+FSuHBhUwOifXa0lmHBggVmv99+++3udYoVK2ZqN3Qd7VeR1HtMy/+JL7/80jRx1K9f371OvXr1TM2Ea9ulxTZG8KLPBSBi2sWLFClimka07fqHH34wH7R6nw5ZTdyrv2DBgvKvf/0rwf3a/KHNHlpdru3e2hE0wcGWObOULl06ye2tH+Jz5swx1e7ab0E/zO+66y5z62o6cUncVBMWFmaq5G+1Q2dK702ryn0pZ2po/xPd7r6Wq1ChQj69jvZLcHH1mYjf58Z1n444cdG+Hxoo4itTpoxcvnzZlEVP+Np3JDENKvo8Gg6Seo9p+T+h/4+eOg/37NkzTbcxghfhAoh34nWNGtFRItrBzxP9UI+IiLjp/tq1a5sfbT/Xb6Oevukld/IdN26cTJ8+3bSxa9u3dvLTE4Sn+RmS+7Z7K7x5b76U0xvxT96u95a4g6Q35fJV4tfwhgbEpPapPp/uc0/7xrWO6/Ge3mNa/k8k3saepMU2RvAiXAB/0TDx0UcfmW+fK1euNFXGnmjnz2zZst006dSPP/5oRhlo04d+m92/f3+C5a5vrpUrV/b4vHPnzpXGjRubznsuWtWuHQ7TS0rvLWfOnF6V09OJzvVNOv4JWLfJuXPnrJQrPWizmTZt5MiRw32f7ufcuXObJgSd/EprGBLTWgF9/9q8kRRP28zW/4RuP09NVh9//LFpQtEaEqdsY2QM9LkA/nLnnXeaam8dOaAftCVLlvS4bbQ3vfbP0CGLLnqCHDFihBnGp1XeDz30kGkb3759u3sdHWGQ3IlUP7x16GJ8s2fPNieTmJiYdNlP3rw3b8qpfQJU/KYabWbSb8c6WsFFa4q8GYngTbnSgwajGTNmJJicTEdoaPm0JkJv9WSsI0VctM+G9lnQ8Ooa1uqJp21m63+iQ4cOZijrL7/84r5P+2O8/PLLcunSJUdtY2QM1FwAf9EPT20a+fTTT5OdCvvRRx81oUHbq/Ubn7ZTa18NbfPWoYlKhzXqCUbX1Q5y+gGuYSO5Nmud70KHC/bo0cPUbugHus5LoP00khviaZM3782bcuo3eP0WrEM3f/rpJxk+fLjpi1CxYkUzz4V2PtS+KXrCc3WcvNVypRcNE/qetRZi2bJlpvOmq5OnbhPdFo899pi0bt3aBAZdR5sztGNmcjxtM1v/Exp29f/xiSeeMOXS11m8eLH539T+HE7bxgh8ITpkxN+FAPx5bRH94HV10tMP72+//dZ84Gpve9c3vIULF950bRGduEjnLNBvmnqC1A6cib/d6TdFnThKP8z15KrfarUaOqlri8Sf5EhPINqjf9OmTeYbZa9evcwJQh+TOPxo9blWzeuJI7lri9x3331StWrVFLdNSu8tpXJqE4A2D7gmidJ5HpR+49Y5LQ4dOmROzjoaR7e3fqN3TaKl26Vv376pKpc31xZxbff421Cbq3SkR/z97npsgwYN5I477jDzS+j8FLpPtcOvblPdlvreE3PVEujHq65z9913J5hEK6n36Gmb2fyf0FojfW2tZdFQVLNmzVvexoAnhAsA8IIrXOjJHkDyiKMAAMAqwgUAeEHniUiquQZAQjSLAAAAq6i5AAAAVhEuAACAVYQLAABgFeECAABYRbgAAABWES4AAIBVhAsAAGAV4QIAAFhFuAAAAGLT/wF9Z3solK06+QAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Generating Composite Feature Importance Plots...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Collecting ensemble statistics from /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/hcc_survival/replication/hcc_survival_rep/ensemble_evaluation\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: hcc_survival_rep statistics phase complete\n", + "INFO: Replication complete for hcc_survival_rep\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Completed Phase 10 - Replication\n" + ] + } + ], + "source": [ + "if RUN_PHASES[\"p10\"]:\n", + " print(\"INFO: Starting Phase 10 - Replication\")\n", + " rep_path = Path(P10_REP_DATA_PATH or CFG[\"rep_data_path\"])\n", + " data_for_rep = Path(P10_DATASET_FOR_REP or CFG[\"dataset_for_rep\"])\n", + " p10_match_label = P10_MATCH_LABEL if P10_MATCH_LABEL is not None else CFG[\"match_label\"]\n", + " if rep_path.exists() and data_for_rep.exists():\n", + " P10Runner(\n", + " rep_data_path=str(rep_path),\n", + " dataset_for_rep=str(data_for_rep),\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " outcome_label=P10_OUTCOME_LABEL,\n", + " instance_label=P10_INSTANCE_LABEL,\n", + " match_label=p10_match_label,\n", + " exclude_plots=P10_EXCLUDE_PLOTS,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " show_plots=P10_SHOW_PLOTS,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 10 - Replication\")\n", + " else:\n", + " print(\"INFO: Phase 10 skipped - replication path or dataset_for_rep not found\")\n", + "else:\n", + " print(\"INFO: Phase 10 skipped\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "47049373", + "metadata": {}, + "source": [ + "## Phase 11: Reporting\n", + "After this cell runs, report artifacts are generated:\n", + "\n", + "- standard testing-data report under `reporting/`\n", + "- replication report under `reporting_replication/` when Phase 10 was run\n", + "\n", + "The reports summarize actual run settings, data-processing changes, feature engineering/selection, model performance, and replication results where available.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "721ad303", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Starting Phase 11 - Reporting (standard)\n", + "INFO: Completed Phase 11 - Reporting (standard)\n", + "INFO: Starting Phase 11 - Reporting (replication)\n", + "INFO: Completed Phase 11 - Reporting (replication)\n", + "INFO: Pipeline run complete\n" + ] + } + ], + "source": [ + "# Keep phase logs verbose globally, but reduce report-phase noise.\n", + "_report_logger = logging.getLogger()\n", + "_prev_log_level = _report_logger.level\n", + "if RUN_PHASES[\"p11\"] or RUN_PHASES[\"p11_replication\"]:\n", + " _report_logger.setLevel(logging.WARNING)\n", + "\n", + "p11_report_modes = {m.strip().lower() for m in str(P11_REPORT_MODES).split(\",\") if m.strip()}\n", + "\n", + "try:\n", + " if RUN_PHASES[\"p11\"] and \"standard\" in p11_report_modes:\n", + " print(\"INFO: Starting Phase 11 - Reporting (standard)\")\n", + " P11Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " experiment_path=str(EXP_ROOT),\n", + " reporting_dir=P11_REPORTING_DIR,\n", + " report_mode=P11_REPORT_MODE_STANDARD,\n", + " outcome_label=P11_OUTCOME_LABEL or CFG[\"outcome_label\"],\n", + " outcome_type=P11_OUTCOME_TYPE or CFG[\"outcome_type\"],\n", + " instance_label=P11_INSTANCE_LABEL if P11_INSTANCE_LABEL is not None else CFG[\"instance_label\"],\n", + " make_pdf=P11_MAKE_PDF,\n", + " enable_plots=P11_ENABLE_PLOTS,\n", + " reuse_existing_figures=P11_REUSE_EXISTING_FIGURES,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 11 - Reporting (standard)\")\n", + " else:\n", + " print(\"INFO: Standard report skipped\")\n", + "\n", + " if RUN_PHASES[\"p11_replication\"] and \"replication\" in p11_report_modes:\n", + " print(\"INFO: Starting Phase 11 - Reporting (replication)\")\n", + " P11Runner(\n", + " output_path=CFG[\"output_path\"],\n", + " experiment_name=CFG[\"experiment_name\"],\n", + " experiment_path=str(EXP_ROOT),\n", + " reporting_dir=P11_REPORTING_DIR,\n", + " report_mode=P11_REPORT_MODE_REPLICATION,\n", + " outcome_label=P11_OUTCOME_LABEL or CFG[\"outcome_label\"],\n", + " outcome_type=P11_OUTCOME_TYPE or CFG[\"outcome_type\"],\n", + " instance_label=P11_INSTANCE_LABEL if P11_INSTANCE_LABEL is not None else CFG[\"instance_label\"],\n", + " make_pdf=P11_MAKE_PDF,\n", + " enable_plots=P11_ENABLE_PLOTS,\n", + " reuse_existing_figures=P11_REUSE_EXISTING_FIGURES,\n", + " run_cluster=RUN_CLUSTER,\n", + " queue=PHASE_QUEUE,\n", + " reserved_memory=PHASE_RESERVED_MEMORY_GB,\n", + " ).run()\n", + " print(\"INFO: Completed Phase 11 - Reporting (replication)\")\n", + " else:\n", + " print(\"INFO: Replication report skipped\")\n", + "finally:\n", + " _report_logger.setLevel(_prev_log_level)\n", + "\n", + "print(\"INFO: Pipeline run complete\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "29b6a5d0", + "metadata": {}, + "source": [ + "## Output Summary\n", + "This final check prints the experiment folder and expected report paths. If a report path says `exists=False`, verify that Phase 11 ran and that earlier phases completed successfully.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "5a72f2e7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Experiment root: /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun\n", + "Standard report: /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/reporting/JupyterRun_STREAMLINE_Report.pdf (exists=True)\n", + "Replication report:/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun/reporting_replication/JupyterRun_STREAMLINE_Replication_Report.pdf (exists=True)\n" + ] + } + ], + "source": [ + "exp_root = Path(CFG[\"output_path\"]) / CFG[\"experiment_name\"]\n", + "std_pdf = exp_root / \"reporting\" / f\"{CFG['experiment_name']}_STREAMLINE_Report.pdf\"\n", + "rep_pdf = exp_root / \"reporting_replication\" / f\"{CFG['experiment_name']}_STREAMLINE_Replication_Report.pdf\"\n", + "\n", + "print(f\"Experiment root: {exp_root}\")\n", + "print(f\"Standard report: {std_pdf} (exists={std_pdf.exists()})\")\n", + "print(f\"Replication report:{rep_pdf} (exists={rep_pdf.exists()})\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Optional: Zip Experiment Folder\n", + "\n", + "Run this cell when you want a single archive of the experiment folder for sharing, moving results, or attaching outputs to an issue/tutorial record.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Created archive: /Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/out/JupyterRun_results.zip\n" + ] + } + ], + "source": [ + "import shutil\n", + "from pathlib import Path\n", + "\n", + "exp_root = Path(CFG[\"output_path\"]) / CFG[\"experiment_name\"]\n", + "zip_base = Path(CFG[\"output_path\"]) / f\"{CFG['experiment_name']}_results\"\n", + "\n", + "if exp_root.exists():\n", + " archive_path = shutil.make_archive(str(zip_base), \"zip\", exp_root)\n", + " print(f\"Created archive: {archive_path}\")\n", + "else:\n", + " print(f\"Experiment folder not found: {exp_root}\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "streamlinenew", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/UsefulNotebooks/DecisionThreshold_Interactive.ipynb b/UsefulNotebooks/DecisionThreshold_Interactive.ipynb deleted file mode 100644 index 71f7cb86..00000000 --- a/UsefulNotebooks/DecisionThreshold_Interactive.ipynb +++ /dev/null @@ -1,1457 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Useful Notebook: Interactively View Alternative Decision Thresholds for a Trained Model\n", - "**This notebook will allow users to interactively examine different decision thresholds for a target model, and see how this new threshold impacts confusion matrix metrics (i.e. TP, TN, FP, FN).**\n", - "\n", - "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", - "\n", - "***\n", - "## Notebook Details\n", - "Allows users to interactively examine different decision thresholds (rather than the standard .5 probability of case) for a target model and see how new thresholds impact model performance metrics.\n", - "\n", - "This notebook is designed to be run on a single model (i.e. specific dataset, CV, and algorithm)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Notebook Run Parameters\n", - "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed).\n", - "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "experiment_path = \"../DemoOutput/demo_experiment\" # path the target experiment folder \n", - "targetDataName = 'hcc_data' # specify a specific dataset\n", - "algorithm = 'Decision Tree' # specify algorithm\n", - "cvCount = 0 #specify the CV number" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Housekeeping\n", - "### Import Packages" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib notebook\n", - "from ipywidgets import *\n", - "\n", - "import os\n", - "import numpy as np\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "from sklearn import metrics\n", - "pd.options.display.float_format = \"{:.4f}\".format\n", - "sns.set(palette='rainbow', context='talk')\n", - "\n", - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "from sklearn.linear_model import LogisticRegression\n", - "from sklearn import svm\n", - "from sklearn.svm import SVC\n", - "from sklearn.metrics import confusion_matrix\n", - "from sklearn.model_selection import train_test_split\n", - "from sklearn.preprocessing import StandardScaler\n", - "from matplotlib.widgets import Slider\n", - "\n", - "import pickle\n", - "import seaborn as sns\n", - "from sklearn import metrics\n", - "\n", - "import warnings\n", - "warnings.filterwarnings('ignore')\n", - "\n", - "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", - "#from IPython.core.interactiveshell import InteractiveShell\n", - "#InteractiveShell.ast_node_interactivity = \"all\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Automatically detect data folder names" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Analyzed Datasets: ['hcc_data', 'hcc_data_custom']\n" - ] - } - ], - "source": [ - "# Get dataset paths for all completed dataset analyses in experiment folder\n", - "datasets = os.listdir(experiment_path)\n", - "\n", - "# Name of experiment folder\n", - "experiment_name = experiment_path.split('/')[-1] \n", - "\n", - "datasets = os.listdir(experiment_path)\n", - "remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", - " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs',\n", - " 'KeyFileCopy', 'dask_logs',\n", - " experiment_name + '_STREAMLINE_Report.pdf']\n", - "for text in remove_list:\n", - " if text in datasets:\n", - " datasets.remove(text)\n", - "\n", - "datasets = sorted(datasets) # ensures consistent ordering of datasets\n", - "print(\"Analyzed Datasets: \" + str(datasets))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load other necessary parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Algorithms Ran: ['Decision Tree', 'Logistic Regression', 'Naive Bayes']\n" - ] - } - ], - "source": [ - "#Unpickle metadata from previous phase\n", - "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", - "metadata = pickle.load(file)\n", - "file.close()\n", - "#Load variables specified earlier in the pipeline from metadata\n", - "class_label = metadata['Class Label']\n", - "instance_label = metadata['Instance Label']\n", - "cv_partitions = int(metadata['CV Partitions'])\n", - "primary_metirc = metadata['Primary Metric']\n", - "\n", - "#Unpickle algorithm information from previous phase\n", - "file = open(experiment_path+'/'+\"algInfo.pickle\", 'rb')\n", - "algInfo = pickle.load(file)\n", - "file.close()\n", - "algorithms = []\n", - "abbrev = {}\n", - "colors = {}\n", - "for key in algInfo:\n", - " if algInfo[key][0]: # If that algorithm was used\n", - " algorithms.append(key)\n", - " abbrev[key] = (algInfo[key][1])\n", - " colors[key] = (algInfo[key][2])\n", - " \n", - "print(\"Algorithms Ran: \" + str(algorithms))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define Necessary Methods" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "def lnsp(initial, max, num):\n", - " diff = max - initial\n", - " list1 = []\n", - " for i in range(num):\n", - " list1.append(initial + (i * diff/num))\n", - " return list1\n", - "\n", - "\n", - "def get_fp_tp(y_test, proba, thresh):\n", - " pred = []\n", - " fp = 0\n", - " tp = 0\n", - " fn = 0\n", - " tn = 0\n", - " threshold = round(thresh, 2)\n", - " for i in range(len(proba)):\n", - " if proba[i] >= threshold:\n", - " pred.append(1)\n", - " elif proba[i] < threshold:\n", - " pred.append(0)\n", - " np.asarray(y_test)\n", - " y_test = y_test.tolist()\n", - " for i in range(len(y_test)):\n", - " if y_test[i] == pred[i]:\n", - " if y_test[i] == 1:\n", - " tp += 1\n", - " elif y_test[i] == 0:\n", - " tn += 1\n", - " elif y_test[i] != pred[i]:\n", - " if pred[i]== 1:\n", - " fp += 1\n", - " elif pred[i] == 0:\n", - " fn += 1\n", - " return fp, tp, fn, tn\n", - "\n", - "def get_fpr_tpr(y_test, proba):\n", - " negatives = np.sum(y_test == 0)\n", - " positives = np.sum(y_test == 1)\n", - " columns = ['threshold', 'false_positive_rate', 'true_positive_rate']\n", - " fptp = pd.DataFrame(columns=columns, dtype=np.number)\n", - " thresholds = np.linspace(0, 1, 101)\n", - " for i, threshold in enumerate(thresholds):\n", - " fptp.loc[i, 'threshold'] = threshold\n", - " false_positives, true_positives, fn, tn = get_fp_tp(y_test, proba, threshold)\n", - " fptp.loc[i, 'false_positive_rate'] = false_positives / negatives\n", - " fptp.loc[i, 'true_positive_rate'] = true_positives / positives\n", - " fptp.head(15)\n", - " return fptp\n", - "\n", - "def get_tfpn(y_test, proba):\n", - " columns = ['threshold', 'false_positives', 'true_positives', 'false_negatives',]\n", - " tfpn = pd.DataFrame(columns=columns, dtype=np.number)\n", - " thresholds = np.linspace(0, 1, 101)\n", - " for i, threshold in enumerate(thresholds):\n", - " tfpn.loc[i, 'threshold'] = round(threshold, 2)\n", - " false_positives, true_positives, false_negatives, true_negatives = get_fp_tp(y_test, proba, round(threshold, 2))\n", - " tfpn.loc[i, 'false_positives'] = false_positives\n", - " tfpn.loc[i, 'true_positives'] = true_positives\n", - " tfpn.loc[i, 'false_negatives'] = false_negatives\n", - " tfpn.loc[i, 'true_negatives'] = true_negatives\n", - " return tfpn\n", - "\n", - "def cm_maker(y_test, proba, thresh):\n", - " tfpn = get_tfpn(y_test, proba)\n", - " tfpn_partial = tfpn.loc[tfpn['threshold'] == thresh]\n", - " #print(np.array(tfpn_partial.true_positives))\n", - " cm_part_1 = np.array(tfpn_partial.true_positives)\n", - " cm_part_2 = np.array(tfpn_partial.false_negatives)\n", - " cm_part_3 = np.array(tfpn_partial.false_positives)\n", - " cm_part_4 = np.array(tfpn_partial.true_negatives)\n", - " merge = np.concatenate((cm_part_1, cm_part_2))\n", - " merge_2 = np.concatenate((cm_part_3, cm_part_4))\n", - " cm_final = np.concatenate(([merge], [merge_2]))\n", - " return cm_final\n", - "\n", - "def graph_roc(y_test, proba, fig, ax, threshold, tpr, fpr, AUC):\n", - " # ax = ax.flatten()\n", - " auc=metrics.roc_auc_score(y_test, proba)\n", - " # ax.plot(fpr, tpr, label=\"AUC=\" + str(auc))\n", - " ax.plot(fpr, tpr, label='AUC:' + str(AUC))\n", - " ax.set(ylabel = ('True Positive Rate'),\n", - " xlabel = ('False Positive Rate'))\n", - " ax.legend()\n", - "\n", - "def getdata(threshold, fprtpr):\n", - " point = fprtpr.loc[fprtpr['threshold'] == threshold]\n", - " fpr = np.array(point.false_positive_rate)\n", - " tpr = np.array(point.true_positive_rate)\n", - " return fpr, tpr\n", - "\n", - "def graph_line(ax, threshold, fprtpr):\n", - " fpr, tpr = getdata(threshold, fprtpr)\n", - " vert_line = ax.axvline(x=fpr, color='gray', linestyle='--')\n", - " hori_line = ax.axhline(y=tpr, color='gray', linestyle='--')\n", - "\n", - " # vert_line.remove(vert_line)\n", - " # vert_line = ax.axvline(x=(threshold*0.2), color='gray', linestyle='--')\n", - " return vert_line, hori_line\n", - "\n", - "def plot_point(ax, threshold, fprtpr):\n", - " fpr, tpr = getdata(threshold, fprtpr)\n", - " ptplt = ax.plot(fpr, tpr, color='blue', marker='o', markersize=8)\n", - " ax.legend()\n", - " return ptplt\n", - "\n", - "def get_cms(y_test, proba):\n", - " thresholds = np.linspace(0, 1, 101)\n", - " ls = []\n", - " for i in thresholds:\n", - " cm = cm_maker(y_test, proba, round(i, 2)).tolist()\n", - " ls.append(cm)\n", - " return ls\n", - "\n", - "def get_auc(model, x_test, y_test):\n", - " y_predict = model.predict(x_test)\n", - " AUC = metrics.roc_auc_score(y_test, y_predict)\n", - " print(AUC)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Activate an Interactive Window to Explore Model Decision Thresholds" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_device_pixel_ratio', {\n", - " device_pixel_ratio: fig.ratio,\n", - " });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute('tabindex', '0');\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;' +\n", - " 'z-index: 2;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box;' +\n", - " 'pointer-events: none;' +\n", - " 'position: relative;' +\n", - " 'z-index: 0;'\n", - " );\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box;' +\n", - " 'left: 0;' +\n", - " 'pointer-events: none;' +\n", - " 'position: absolute;' +\n", - " 'top: 0;' +\n", - " 'z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " /* This rescales the canvas back to display pixels, so that it\n", - " * appears correct on HiDPI screens. */\n", - " canvas.style.width = width + 'px';\n", - " canvas.style.height = height + 'px';\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " /* User Agent sniffing is bad, but WebKit is busted:\n", - " * https://bugs.webkit.org/show_bug.cgi?id=144526\n", - " * https://bugs.webkit.org/show_bug.cgi?id=181818\n", - " * The worst that happens here is that they get an extra browser\n", - " * selection when dragging, if this check fails to catch them.\n", - " */\n", - " var UA = navigator.userAgent;\n", - " var isWebKit = /AppleWebKit/.test(UA) && !/Chrome/.test(UA);\n", - " if(isWebKit) {\n", - " return function (event) {\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We\n", - " * want to control all of the cursor setting manually through\n", - " * the 'cursor' event from matplotlib */\n", - " event.preventDefault()\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " } else {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'dblclick',\n", - " on_mouse_event_closure('dblclick')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " canvas_div.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " canvas_div.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " canvas_div.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " fig.canvas_div.style.cursor = msg['cursor'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " var img = evt.data;\n", - " if (img.type !== 'image/png') {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " img.type = 'image/png';\n", - " }\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " img\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "function getModifiers(event) {\n", - " var mods = [];\n", - " if (event.ctrlKey) {\n", - " mods.push('ctrl');\n", - " }\n", - " if (event.altKey) {\n", - " mods.push('alt');\n", - " }\n", - " if (event.shiftKey) {\n", - " mods.push('shift');\n", - " }\n", - " if (event.metaKey) {\n", - " mods.push('meta');\n", - " }\n", - " return mods;\n", - "}\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * https://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " // from https://stackoverflow.com/q/1114465\n", - " var boundingRect = this.canvas.getBoundingClientRect();\n", - " var x = (event.clientX - boundingRect.left) * this.ratio;\n", - " var y = (event.clientY - boundingRect.top) * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " modifiers: getModifiers(event),\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.key === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.key;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.key !== 'Control') {\n", - " value += 'ctrl+';\n", - " }\n", - " else if (event.altKey && event.key !== 'Alt') {\n", - " value += 'alt+';\n", - " }\n", - " else if (event.shiftKey && event.key !== 'Shift') {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k' + event.key;\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\", \"webp\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.binaryType = comm.kernel.ws.binaryType;\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " function updateReadyState(_event) {\n", - " if (comm.kernel.ws) {\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " } else {\n", - " ws.readyState = 3; // Closed state.\n", - " }\n", - " }\n", - " comm.kernel.ws.addEventListener('open', updateReadyState);\n", - " comm.kernel.ws.addEventListener('close', updateReadyState);\n", - " comm.kernel.ws.addEventListener('error', updateReadyState);\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " var data = msg['content']['data'];\n", - " if (data['blob'] !== undefined) {\n", - " data = {\n", - " data: new Blob(msg['buffers'], { type: data['blob'] }),\n", - " };\n", - " }\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(data);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "global point, hline, vline, coordinate\n", - "\n", - "full_path = experiment_path+'/'+targetDataName\n", - "\n", - "#Load pickled metric file for given algorithm and cv\n", - "model_file = full_path+'/models/pickledModels/'+abbrev[algorithm]+\"_\"+str(cvCount)+'.pickle'\n", - "file = open(model_file, 'rb')\n", - "model = pickle.load(file)\n", - "file.close()\n", - " \n", - "#load testing data\n", - "test_file_path = full_path + '/CVDatasets/' + targetDataName + \"_CV_\" + str(cvCount) + \"_Test.csv\"\n", - "test = pd.read_csv(test_file_path)\n", - "if instance_label != 'None':\n", - " test = test.drop(instance_label,axis=1)\n", - "x_test = test.drop(class_label,axis=1).values\n", - "y_test = test[class_label].values\n", - "del test #memory cleanup\n", - "\n", - "proba = model.predict_proba(x_test)[:,1]\n", - "tfpn = get_tfpn(y_test, proba)\n", - "# tfpn.to_csv('tfpn.csv')\n", - "# plt.figure(figsize=(9, 9))\n", - "# sns.heatmap(cm, annot=True, fmt=\".3f\", linewidths=.5, square=True, cmap='Blues_r');\n", - "# plt.ylabel('Actual label');\n", - "# plt.xlabel('Predicted label');\n", - "# all_sample_title = 'Accuracy Score: {0}'.format(score)\n", - "# plt.title(all_sample_title, size=15);\n", - "# plt.show()\n", - "threshold = 0.5\n", - "fprtpr = get_fpr_tpr(y_test, proba)\n", - "fprtpr.threshold = round(fprtpr.threshold, 2)\n", - "fpr_roc = fprtpr.false_positive_rate\n", - "tpr_roc = fprtpr.true_positive_rate\n", - "# fprtpr.to_csv('fprtpr.csv')\n", - "#cm = cm_maker(y_test, proba, threshold)\n", - "\n", - "y_predict = model.predict(x_test)\n", - "AUC = metrics.roc_auc_score(y_test, y_predict)\n", - "\n", - "\n", - "cms = get_cms(y_test, proba)\n", - "cm = np.asarray(cms[int(round(threshold, 0) * 100)])\n", - "fig, ax = plt.subplots(nrows=1, ncols=2, figsize = (14, 7))\n", - "fig.tight_layout(pad = 2)\n", - "fpr, tpr = getdata(threshold, fprtpr)\n", - "coordinate = ax[0].text(fpr+0.05, tpr+0.02, s=str(fpr) + str(tpr), fontsize= 12)\n", - "graph_roc(y_test, proba, fig, ax[0], threshold, tpr_roc, fpr_roc, AUC)\n", - "ax[1].imshow(cm, interpolation='nearest', cmap=plt.cm.Wistia)\n", - "fig.subplots_adjust(bottom=0.25)\n", - "classNames = ['Positive', 'Negative']\n", - "tick_marks = np.arange(len(classNames))\n", - "ax[1].set(ylabel = 'True label',\n", - " xlabel = 'Predicted label',\n", - " xticks = np.arange(len(classNames)),\n", - " yticks = np.arange(len(classNames)),\n", - " xticklabels = classNames,\n", - " yticklabels = classNames)\n", - "s = [['TP', 'FN'], ['FP', 'TN']]\n", - "for i in range(2):\n", - " for j in range(2):\n", - " ax[1].text(j-0.3, i, str(s[i][j]) + \" = \" + str(cm[i][j]))\n", - "fig.subplots_adjust(bottom=0.25)\n", - "\n", - "vline, hline = graph_line(ax[0], threshold, fprtpr)\n", - "point, = plot_point(ax[0], threshold, fprtpr)\n", - "\n", - "sli_ax = plt.axes([0.25, 0.1, .65, .03])\n", - "thr_slider = Slider(sli_ax, 'Threshold', valmin=0, valmax=1, valinit=0.5, valstep=0.01)\n", - "\n", - "\n", - "def update(val):\n", - " global point, coordinate\n", - " ax[1].clear()\n", - " threshold = round(thr_slider.val, 2)\n", - "\n", - " coordinate.remove()\n", - " fpr, tpr = getdata(threshold, fprtpr)\n", - " hline.set_ydata(y=tpr)\n", - " vline.set_xdata(x=fpr)\n", - " point.set_data(fpr, tpr)\n", - " point.set_data(fpr, tpr)\n", - " y_predict = model.predict(x_test)\n", - " AUC = metrics.roc_auc_score(y_test, y_predict)\n", - " coordinate = ax[0].text(fpr+0.05, tpr+0.02, s=str(fpr)+str(tpr), fontsize = 12)\n", - "\n", - " cm = np.asarray(cms[int(round(threshold*100, 0))])\n", - " ax[1].imshow(cm, interpolation='nearest', cmap=plt.cm.Wistia)\n", - " classNames = ['Positive', 'Negative']\n", - " # img.('Confusion Matrix - Test Data')\n", - " tick_marks = np.arange(len(classNames))\n", - " ax[1].set(ylabel='True label',\n", - " xlabel='Predicted label',\n", - " xticks=np.arange(len(classNames)),\n", - " yticks=np.arange(len(classNames)),\n", - " xticklabels=classNames,\n", - " yticklabels=classNames)\n", - " s = [['TP', 'FN'], ['FP', 'TN']]\n", - " for i in range(2):\n", - " for j in range(2):\n", - " ax[1].text(j-.4, i, str(s[i][j]) + \" = \" + str(cm[i][j]))\n", - "\n", - " fig.canvas.draw()\n", - "\n", - "thr_slider.on_changed(update)\n", - "plt.show()" - ] - }, - { - "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.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/UsefulNotebooks/DecisionThreshold_TestEval.ipynb b/UsefulNotebooks/DecisionThreshold_TestEval.ipynb deleted file mode 100644 index 73572a25..00000000 --- a/UsefulNotebooks/DecisionThreshold_TestEval.ipynb +++ /dev/null @@ -1,739 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Useful Notebook: Re-Evaluate Models Testing Data Performance Using an Alternative Decision Threshold\n", - "**This notebook will allow users to (1) re-evaluate all trained models on the respective testing datasets using a decision threshold other than the default 0.5, (2) re-generate metric evaluation boxplots comparing algorithm performance using this new decision threshold, and (3) re-run statistical significance analyses comparing algorithm performance using this new decision threshold.**\n", - "\n", - "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", - "\n", - "***\n", - "## Notebook Details\n", - "Allows users to specify alternative decision thresholds (rather than the standard 0.5 probability) and re-evaluate algorithm performane metrics. All results are saved in the same locations in the experiment folder as their original counterparts (with a modified name). \n", - "\n", - "Warning: Since this is run on testing data, this should not be used to pick a new decision threshold (otherwise the resulting model+threshold may be overfit). \n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Notebook Run Parameters\n", - "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed). \n", - "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "experiment_path = \"../DemoOutput/demo_experiment\" # path the target experiment folder \n", - "targetDataName = None # 'None' if user wants to generate visualizations for all analyzed datasets\n", - "algorithms = [] # use empty list if user wishes re-evaluate all modeling algorithms that were run in pipeline.\n", - "threshold = 0.2 # Threshold of case probability used to predict case (typically 0.5 by default in modeling)\n", - "plot_metric_boxplots = True # Plot new boxplots for each metric using new threshold.\n", - "run_sig_test = True # Rerun non-parametric significance testing between all algorithms for each metric.\n", - "name_modifier = '_T_'+str(threshold) # Modifies names of stats files to avoid overwriting originals (This can be left as is or altered)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Housekeeping\n", - "### Import Packages" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import pandas as pd\n", - "import pickle\n", - "from statistics import mean,stdev\n", - "import numpy as np\n", - "from scipy import interp,stats\n", - "# Evalutation metrics\n", - "from sklearn.metrics import accuracy_score\n", - "from sklearn.metrics import balanced_accuracy_score\n", - "from sklearn.metrics import recall_score\n", - "from sklearn.metrics import confusion_matrix\n", - "from sklearn.metrics import precision_score\n", - "from sklearn.metrics import f1_score\n", - "from sklearn.metrics import roc_curve, auc, precision_recall_curve\n", - "from sklearn import metrics\n", - "import csv\n", - "import matplotlib.pyplot as plt\n", - "import copy\n", - "\n", - "import warnings\n", - "warnings.filterwarnings('ignore')\n", - "\n", - "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", - "from IPython.core.interactiveshell import InteractiveShell\n", - "InteractiveShell.ast_node_interactivity = \"all\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Automatically detect data folder names" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Analyzed Datasets: ['hcc_data', 'hcc_data_custom']\n" - ] - } - ], - "source": [ - "# Get dataset paths for all completed dataset analyses in experiment folder\n", - "datasets = os.listdir(experiment_path)\n", - "\n", - "# Name of experiment folder\n", - "experiment_name = experiment_path.split('/')[-1] \n", - "\n", - "datasets = os.listdir(experiment_path)\n", - "remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", - " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs',\n", - " 'KeyFileCopy', 'dask_logs',\n", - " experiment_name + '_STREAMLINE_Report.pdf']\n", - "for text in remove_list:\n", - " if text in datasets:\n", - " datasets.remove(text)\n", - "\n", - "datasets = sorted(datasets) # ensures consistent ordering of datasets\n", - "print(\"Analyzed Datasets: \" + str(datasets))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load other necessary parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Algorithms Ran: ['Decision Tree', 'Logistic Regression', 'Naive Bayes']\n" - ] - } - ], - "source": [ - "# Unpickle metadata from previous phase\n", - "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", - "metadata = pickle.load(file)\n", - "file.close()\n", - "# Load variables specified earlier in the pipeline from metadata\n", - "class_label = metadata['Class Label']\n", - "instance_label = metadata['Instance Label']\n", - "cv_partitions = int(metadata['CV Partitions'])\n", - "sig_cutoff =float(metadata['Statistical Significance Cutoff'])\n", - "primary_metirc = metadata['Primary Metric']\n", - "\n", - "# Unpickle algorithm information from previous phase\n", - "file = open(experiment_path+'/'+\"algInfo.pickle\", 'rb')\n", - "algInfo = pickle.load(file)\n", - "file.close()\n", - "algorithms = []\n", - "abbrev = {}\n", - "colors = {}\n", - "for key in algInfo:\n", - " if algInfo[key][0]: # If that algorithm was used\n", - " algorithms.append(key)\n", - " abbrev[key] = (algInfo[key][1])\n", - " colors[key] = (algInfo[key][2])\n", - " \n", - "print(\"Algorithms Ran: \" + str(algorithms))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define Necessary Methods" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "def classEval(y_true, y_pred):\n", - " \"\"\" Calculates standard classification metrics including:\n", - " True positives, false positives, true negative, false negatives, standard accuracy, balanced accuracy\n", - " recall, precision, f1 score, negative predictive value, likelihood ratio positive, and likelihood ratio negative\"\"\"\n", - " #Calculate true positive, true negative, false positive, and false negative.\n", - " tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()\n", - " #Calculate Accuracy metrics\n", - " ac = accuracy_score(y_true, y_pred)\n", - " bac = balanced_accuracy_score(y_true, y_pred)\n", - " #Calculate Precision and Recall\n", - " re = recall_score(y_true, y_pred)\n", - " pr = precision_score(y_true, y_pred)\n", - " #Calculate F1 score\n", - " f1 = f1_score(y_true, y_pred)\n", - " # Calculate specificity\n", - " if tn == 0 and fp == 0:\n", - " sp = 0\n", - " else:\n", - " sp = tn / float(tn + fp)\n", - " # Calculate Negative predictive value\n", - " if tn == 0 and fn == 0:\n", - " npv = 0\n", - " else:\n", - " npv = tn/float(tn+fn)\n", - " # Calculate likelihood ratio postive\n", - " if sp == 1:\n", - " lrp = 0\n", - " else:\n", - " lrp = re/float(1-sp)\n", - " # Calculate likeliehood ratio negative\n", - " if sp == 0:\n", - " lrm = 0\n", - " else:\n", - " lrm = (1-re)/float(sp)\n", - " return [bac, ac, f1, re, sp, pr, tp, tn, fp, fn, npv, lrp, lrm]" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "def saveMetricMeans(full_path,metrics,metric_dict,name_modifier):\n", - " \"\"\" Exports csv file with average metric values (over all CVs) for each ML modeling algorithm\"\"\"\n", - " with open(full_path+'/model_evaluation/Summary_performance_mean'+name_modifier+'.csv',mode='w', newline=\"\") as file:\n", - " writer = csv.writer(file, delimiter=',', quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n", - " e = ['']\n", - " e.extend(metrics)\n", - " writer.writerow(e) #Write headers (balanced accuracy, etc.)\n", - " for algorithm in metric_dict:\n", - " astats = []\n", - " for l in list(metric_dict[algorithm].values()):\n", - " l = [float(i) for i in l]\n", - " meani = mean(l)\n", - " std = stdev(l)\n", - " astats.append(str(meani))\n", - " toAdd = [algorithm]\n", - " toAdd.extend(astats)\n", - " writer.writerow(toAdd)\n", - " file.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def saveMetricStd(full_path,metrics,metric_dict,name_modifier):\n", - " \"\"\" Exports csv file with metric value standard deviations (over all CVs) for each ML modeling algorithm\"\"\"\n", - " with open(full_path + '/model_evaluation/Summary_performance_std'+name_modifier+'.csv', mode='w', newline=\"\") as file:\n", - " writer = csv.writer(file, delimiter=',', quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n", - " e = ['']\n", - " e.extend(metrics)\n", - " writer.writerow(e) # Write headers (balanced accuracy, etc.)\n", - " for algorithm in metric_dict:\n", - " astats = []\n", - " for l in list(metric_dict[algorithm].values()):\n", - " l = [float(i) for i in l]\n", - " std = stdev(l)\n", - " astats.append(str(std))\n", - " toAdd = [algorithm]\n", - " toAdd.extend(astats)\n", - " writer.writerow(toAdd)\n", - " file.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "def metricBoxplots(full_path,metrics,algorithms,metric_dict,name_modifier):\n", - " \"\"\" Export boxplots comparing algorithm performance for each standard metric\"\"\"\n", - " if not os.path.exists(full_path + '/model_evaluation/metricBoxplots'):\n", - " os.mkdir(full_path + '/model_evaluation/metricBoxplots')\n", - " for metric in metrics:\n", - " tempList = []\n", - " for algorithm in algorithms:\n", - " tempList.append(metric_dict[algorithm][metric])\n", - " td = pd.DataFrame(tempList)\n", - " td = td.transpose()\n", - " td.columns = algorithms\n", - " #Generate boxplot\n", - " boxplot = td.boxplot(column=algorithms,rot=90)\n", - " #Specify plot labels\n", - " plt.ylabel(str(metric))\n", - " plt.xlabel('ML Algorithm')\n", - " #Export and/or show plot\n", - " plt.savefig(full_path + '/model_evaluation/metricBoxplots/Compare_'+metric+name_modifier+'.png', bbox_inches=\"tight\")\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def kruskalWallis(full_path,metrics,algorithms,metric_dict,sig_cutoff,name_modifier):\n", - " \"\"\" Apply non-parametric Kruskal Wallis one-way ANOVA on ranks. Determines if there is a statistically significant difference in algorithm performance across CV runs.\n", - " Completed for each standard metric separately.\"\"\"\n", - " # Create directory to store significance testing results (used for both Kruskal Wallis and MannWhitney U-test)\n", - " if not os.path.exists(full_path + '/model_evaluation/statistical_comparisons'):\n", - " os.mkdir(full_path + '/model_evaluation/statistical_comparisons')\n", - " #Create dataframe to store analysis results for each metric\n", - " label = ['Statistic', 'P-Value', 'Sig(*)']\n", - " kruskal_summary = pd.DataFrame(index=metrics, columns=label)\n", - " #Apply Kruskal Wallis test for each metric\n", - " for metric in metrics:\n", - " tempArray = []\n", - " for algorithm in algorithms:\n", - " tempArray.append(metric_dict[algorithm][metric])\n", - " try:\n", - " result = stats.kruskal(*tempArray)\n", - " except:\n", - " result = [tempArray[0],1]\n", - " kruskal_summary.at[metric, 'Statistic'] = str(round(result[0], 6))\n", - " kruskal_summary.at[metric, 'P-Value'] = str(round(result[1], 6))\n", - " if result[1] < sig_cutoff:\n", - " kruskal_summary.at[metric, 'Sig(*)'] = str('*')\n", - " else:\n", - " kruskal_summary.at[metric, 'Sig(*)'] = str('')\n", - " #Export analysis summary to .csv file\n", - " kruskal_summary.to_csv(full_path + '/model_evaluation/statistical_comparisons/KruskalWallis'+name_modifier+'.csv')\n", - " return kruskal_summary" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def wilcoxonRank(full_path,metrics,algorithms,metric_dict,kruskal_summary,sig_cutoff,name_modifier):\n", - " \"\"\" Apply non-parametric Wilcoxon signed-rank test (pairwise comparisons). If a significant Kruskal Wallis algorithm difference was found for a given metric, Wilcoxon tests individual algorithm pairs\n", - " to determine if there is a statistically significant difference in algorithm performance across CV runs. Test statistic will be zero if all scores from one set are\n", - " larger than the other.\"\"\"\n", - " for metric in metrics:\n", - " if kruskal_summary['Sig(*)'][metric] == '*':\n", - " wilcoxon_stats = []\n", - " done = []\n", - " for algorithm1 in algorithms:\n", - " for algorithm2 in algorithms:\n", - " if not [algorithm1,algorithm2] in done and not [algorithm2,algorithm1] in done and algorithm1 != algorithm2:\n", - " set1 = metric_dict[algorithm1][metric]\n", - " set2 = metric_dict[algorithm2][metric]\n", - " #handle error when metric values are equal for both algorithms\n", - " combined = copy.deepcopy(set1)\n", - " combined.extend(set2)\n", - " if all(x==combined[0] for x in combined): #Check if all nums are equal in sets\n", - " report = ['NA',1]\n", - " else: # Apply Wilcoxon Rank Sum test\n", - " report = stats.wilcoxon(set1,set2)\n", - " #Summarize test information in list\n", - " tempstats = [algorithm1,algorithm2,report[0],report[1],'']\n", - " if report[1] < sig_cutoff:\n", - " tempstats[4] = '*'\n", - " wilcoxon_stats.append(tempstats)\n", - " done.append([algorithm1,algorithm2])\n", - " #Export test results\n", - " wilcoxon_stats_df = pd.DataFrame(wilcoxon_stats)\n", - " wilcoxon_stats_df.columns = ['Algorithm 1', 'Algorithm 2', 'Statistic', 'P-Value', 'Sig(*)']\n", - " wilcoxon_stats_df.to_csv(full_path + '/model_evaluation/statistical_comparisons/WilcoxonRank_'+metric+name_modifier+'.csv', index=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "def mannWhitneyU(full_path,metrics,algorithms,metric_dict,kruskal_summary,sig_cutoff,name_modifier):\n", - " \"\"\" Apply non-parametric Mann Whitney U-test (pairwise comparisons). If a significant Kruskal Wallis algorithm difference was found for a given metric, Mann Whitney tests individual algorithm pairs\n", - " to determine if there is a statistically significant difference in algorithm performance across CV runs. Test statistic will be zero if all scores from one set are\n", - " larger than the other.\"\"\"\n", - " for metric in metrics:\n", - " if kruskal_summary['Sig(*)'][metric] == '*':\n", - " mann_stats = []\n", - " done = []\n", - " for algorithm1 in algorithms:\n", - " for algorithm2 in algorithms:\n", - " if not [algorithm1,algorithm2] in done and not [algorithm2,algorithm1] in done and algorithm1 != algorithm2:\n", - " set1 = metric_dict[algorithm1][metric]\n", - " set2 = metric_dict[algorithm2][metric]\n", - " #handle error when metric values are equal for both algorithms\n", - " combined = copy.deepcopy(set1)\n", - " combined.extend(set2)\n", - " if all(x==combined[0] for x in combined): #Check if all nums are equal in sets\n", - " report = ['NA',1]\n", - " else: #Apply Mann Whitney U test\n", - " report = stats.mannwhitneyu(set1,set2)\n", - " #Summarize test information in list\n", - " tempstats = [algorithm1,algorithm2,report[0],report[1],'']\n", - " if report[1] < sig_cutoff:\n", - " tempstats[4] = '*'\n", - " mann_stats.append(tempstats)\n", - " done.append([algorithm1,algorithm2])\n", - " #Export test results\n", - " mann_stats_df = pd.DataFrame(mann_stats)\n", - " mann_stats_df.columns = ['Algorithm 1', 'Algorithm 2', 'Statistic', 'P-Value', 'Sig(*)']\n", - " mann_stats_df.to_csv(full_path + '/model_evaluation/statistical_comparisons/MannWhitneyU_'+metric+name_modifier+'.csv', index=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Run New Testing Evaluation and Metric Boxplot Generation" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Vizualized Datasets: ['hcc_data_custom']\n", - "---------------------------------------\n", - "hcc_data_custom\n", - "---------------------------------------\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAIoCAYAAACVqMrgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABJYklEQVR4nO3deViVdeL+8fuwC4iKC6IikmaIuFOjmQumTGajNrk0miuOmTOZUk06juauk6WmpVm5TovmOt/STCaXXDNRylQsd0LMhRQVQZbz+8Of5/tlcDkHOTzwnPfrurjsfM6z3OdcT3rzrBar1WoVAACASbgZHQAAAKAoUW4AAICpUG4AAICpUG4AAICpUG4AAICpUG4AAICpUG4AAICpUG4AAICpeBgdoLjl5eXpzJkzKlu2rCwWi9FxAACAHaxWq65cuaJq1arJze3u+2ZcrtycOXNGISEhRscAAACFkJycrBo1atx1GpcrN2XLlpV088sJCAgwOE3plp2drY0bNyomJkaenp5GxwHYJlEisV0WjfT0dIWEhNj+Hb8blys3tw5FBQQEUG7uU3Z2tnx9fRUQEMD/sCgR2CZRErFdFi17TinhhGIAAGAqlBsAAGAqlBsAAGAqlBsAAGAqlBsAAGAqlBsAAGAqlBsAAGAqlBsAAGAqlBsAAGAqlBsAAGAqlBsAAGAqlBsAAGAqlBsAAGAqLvdUcAAACisjI0NJSUkOzXP1epZ2HjimCpX2yr+Mt93zhYeHy9fX19GIEOUGAAC7JSUlqVmzZoWa9w0Hp09ISFDTpk0LtS5XR7kBAMBO4eHhSkhIcGieI6mXFLfigGZ0b6CHgss7tC4UDuUGAAA7+fr6Orw3xe3URXlvu656kY3UOLSik5Lh/+KEYgAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCqGl5u5c+cqLCxMPj4+atasmbZt23bX6T/++GM1atRIvr6+Cg4O1oABA3Tx4sViSgsAAEo6Q8vN8uXLNXz4cI0ePVr79+9Xq1at1LFjR50+ffq202/fvl19+/ZVbGysDh48qBUrVui7777ToEGDijk5AAAoqQwtNzNmzFBsbKwGDRqkevXqadasWQoJCdG8efNuO/3u3btVq1YtDRs2TGFhYXrsscf0/PPPa+/evcWcHAAAlFQeRq34xo0bSkhI0MiRI/ONx8TEaOfOnbed59FHH9Xo0aO1fv16dezYUefOndPKlSvVqVOnO64nKytLWVlZttfp6emSpOzsbGVnZxfBJ3Fdt74/vkeUFGyTKIlycnJsf7JtFp4j351h5ebChQvKzc1VUFBQvvGgoCCdPXv2tvM8+uij+vjjj9WzZ09lZmYqJydHnTt31pw5c+64nqlTp2r8+PEFxjdu3ChfX9/7+xCQJMXHxxsdAciHbRIlSfJVSfLQ7t27lfKj0WlKr4yMDLunNazc3GKxWPK9tlqtBcZuOXTokIYNG6axY8fq97//vVJTU/Xqq69qyJAhWrBgwW3nGTVqlOLi4myv09PTFRISopiYGAUEBBTdB3FB2dnZio+PV4cOHeTp6Wl0HIBtEiXS96fTpAN71bx5czWqGWh0nFLr1pEXexhWbipVqiR3d/cCe2nOnTtXYG/OLVOnTlXLli316quvSpIaNmwoPz8/tWrVSpMmTVJwcHCBeby9veXt7V1g3NPTk7/8igjfJUoatkmUJB4eHrY/2S4Lz5HvzrATir28vNSsWbMCu4/j4+P16KOP3naejIwMubnlj+zu7i7p5h4fAAAAQ6+WiouL04cffqiFCxfq8OHDGjFihE6fPq0hQ4ZIunlIqW/fvrbp//CHP2j16tWaN2+ejh8/rh07dmjYsGF65JFHVK1aNaM+BgAAKEEMPeemZ8+eunjxoiZMmKDU1FRFRkZq/fr1Cg0NlSSlpqbmu+dN//79deXKFb3zzjt6+eWXVb58ebVr107//Oc/jfoIAACghDH8hOKhQ4dq6NCht31v8eLFBcZefPFFvfjii05OBQAASivDH78AAABQlCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVCg3AADAVDyMDgAAgJFOXLima1k5Tlv+sfPXbH96eDjvn10/bw+FVfJz2vJLE8oNAMBlnbhwTdFvbimWdb288oDT17H5lbYUHFFuAAAu7NYem1k9G6tOFX/nrON6lr7YsktPtW0hvzLeTlnH0XNXNXx5olP3QJUmlBsAgMurU8VfkdXLOWXZ2dnZOltZahpaQZ6enk5ZB/LjhGIAAGAqlBsAAGAqhpebuXPnKiwsTD4+PmrWrJm2bdt2x2n79+8vi8VS4Kd+/frFmBgAAJRkhpab5cuXa/jw4Ro9erT279+vVq1aqWPHjjp9+vRtp3/77beVmppq+0lOTlZgYKC6d+9ezMkBAEBJZWi5mTFjhmJjYzVo0CDVq1dPs2bNUkhIiObNm3fb6cuVK6eqVavafvbu3avffvtNAwYMKObkAACgpDKs3Ny4cUMJCQmKiYnJNx4TE6OdO3fatYwFCxaoffv2Cg0NdUZEAABQChl2KfiFCxeUm5uroKCgfONBQUE6e/bsPedPTU3Vl19+qU8++eSu02VlZSkrK8v2Oj09XdLNS/Oys7MLkRy33Pr++B5RUrBNwlE5OTm2P5213RTHdlkcn8Nojnwuw+9zY7FY8r22Wq0Fxm5n8eLFKl++vLp27XrX6aZOnarx48cXGN+4caN8fX0dyorbi4+PNzoCkA/bJOyVfFWSPLR9+3adcs49/GycuV0W5+cwSkZGht3TGlZuKlWqJHd39wJ7ac6dO1dgb85/s1qtWrhwofr06SMvL6+7Tjtq1CjFxcXZXqenpyskJEQxMTEKCAgo/AeAsrOzFR8frw4dOnBjKpQIbJNw1MEz6XrzwG499thjql/NOf8mFMd2WRyfw2i3jrzYw7By4+XlpWbNmik+Pl5PP/20bTw+Pl5dunS567xbt27V0aNHFRsbe8/1eHt7y9u74O2uPT09+cuviPBdoqRhm4S9bj3I0sPDw+nbjDO3y+L8HEZx5HMZelgqLi5Offr0UVRUlFq0aKH3339fp0+f1pAhQyTd3OuSkpKipUuX5ptvwYIF+t3vfqfIyEgjYgMAgBLM0HLTs2dPXbx4URMmTFBqaqoiIyO1fv1629VPqampBe55c/nyZa1atUpvv/22EZEBAEAJZ/gJxUOHDtXQoUNv+97ixYsLjJUrV86hk4oAAIBrMfzxCwAAAEWpUHtuTp48qW3btunkyZPKyMhQ5cqV1aRJE7Vo0UI+Pj5FnREAAMBuDpWbTz75RLNnz9aePXtUpUoVVa9eXWXKlFFaWpqOHTsmHx8f9e7dW6+99hp3DQYAAIawu9w0bdpUbm5u6t+/vz777DPVrFkz3/tZWVnatWuXli1bpqioKM2dO5cHWgIAgGJnd7mZOHGiOnXqdMf3vb291bZtW7Vt21aTJk3SiRMniiQgAACAI+wuN506ddL58+dVuXLle05bqVIlVapU6b6CAQAAFIZDV0tVr15d3bp105dffimr1eqsTAAAAIXmULlZsmSJ0tPT9Yc//EEhISEaM2aMjh075qxsAAAADnOo3PzpT3/Sxo0bdeLECf35z3/Wxx9/rLp16yo6Oloff/yxMjMznZUTAADALoW6iV9ISIhef/11HT9+XBs3blT16tU1ePBgBQcH3/FuwwAAAMXhvu9Q/Pjjj+ujjz7S0qVL5ebmpvnz5xdFLgAAgEK5r2dLnTx5UosWLdKSJUv0yy+/KDo6WrGxsUWVDQAAwGEOl5vMzEytWLFCixYt0jfffKPq1aurf//+GjBggGrVquWEiAAAAPZzqNwMHjxYn332mTIzM9WlSxetW7dOMTExslgszsoHAADgEIfKze7duzV+/Hj16dNHgYGBzsoEAABQaA6Vmx9++EFXrlzR7t27lZ2drUceeYQ7EQMAgBLFoXJz4MABPfHEEzp79qysVqsCAgK0cuVKtW/f3ln5AAAAHOLQpeCvvfaaatasqW3btmnv3r1q06aN/vrXvzorGwAAgMMc2nOzd+9erV+/XlFRUZKkhQsXqkqVKrp69ar8/f2dEhAAAMARDu25uXDhgmrWrGl7XbFiRfn6+ur8+fNFHgwAAKAwHNpzY7FYdOXKFfn4+EiSrFarbSw9Pd02XUBAQNGmBAAAsJND5cZqtapu3boFxpo0aWL7b4vFotzc3KJLCAAA4ACHys3mzZudlQMAAKBIOFRu2rRp46wcAAAARcKhE4qtVqumT5+uli1b6pFHHtHf//53ZWZmOisbAACAwxwqN9OmTdPIkSPl5+en4OBgzZgxQ8OGDXNWNgAAAIc5VG4WL16sOXPmaOPGjfr3v/+ttWvXaunSpbJarc7KBwAA4BCHys2pU6f01FNP2V7//ve/l9Vq1ZkzZ4o8GAAAQGE4VG5u3LihMmXK2F5bLBZ5eXkpKyuryIMBAAAUhkNXS0nSmDFj5Ovra3t948YNTZ48WeXKlbONzZgxo2jSAQAAOMihctO6dWsdOXIk39ijjz6q48eP215bLJaiSQYAAFAIDpWbLVu2OCkGAABA0XDonBsAAICSzu5yM23aNF27ds2uab/99lutW7eu0KEAAAAKy+5yc+jQIYWGhuqFF17Ql19+qfPnz9vey8nJ0Q8//KC5c+fq0Ucf1bPPPsuTwQEAgCHsPudm6dKl+uGHH/Tuu++qd+/eunz5stzd3eXt7a2MjAxJUpMmTTR48GD169dP3t7eTgsNAABwJw6dUNywYUPNnz9f7733nn744QedPHlS169fV6VKldS4cWNVqlTJWTkBAADs4vB9bqSbl3s3atRIjRo1Kuo8AAAA94WrpQAAgKlQbgAAgKlQbgAAgKlQbgAAgKlQbgAAgKkU6mqpa9euadq0afr666917tw55eXl5Xv//z5IEwAAoDgVqtwMGjRIW7duVZ8+fRQcHMyTwAEAQIlRqHLz5Zdfat26dWrZsmVR5wEAALgvhTrnpkKFCgoMDCzqLAAAAPetUOVm4sSJGjt2rO2ZUgAAACVFoQ5LvfXWWzp27JiCgoJUq1YteXp65nt/3759RRIOAADAUYUqN127di3iGAAAAEWjUOXm9ddfL+ocAAAARaJQ5eaWhIQEHT58WBaLRREREWrSpElR5QIAACiUQpWbc+fO6dlnn9WWLVtUvnx5Wa1WXb58WdHR0Vq2bJkqV65c1DkBAADsUqirpV588UWlp6fr4MGDSktL02+//aYff/xR6enpGjZsWFFnBAAAsFuh9txs2LBB//nPf1SvXj3bWEREhN59913FxMQUWTgAAABHFWrPTV5eXoHLvyXJ09OzwHOmAAAAilOhyk27du300ksv6cyZM7axlJQUjRgxQo8//niRhQMAAHBUocrNO++8oytXrqhWrVqqXbu26tSpo7CwMF25ckVz5swp6owAAAB2K9Q5NyEhIdq3b5/i4+OVlJQkq9WqiIgItW/fvqjzAQAAOOS+7nPToUMHdejQoaiyAAAA3De7y83s2bM1ePBg+fj4aPbs2Xed1pHLwefOnavp06crNTVV9evX16xZs9SqVas7Tp+VlaUJEyboo48+0tmzZ1WjRg2NHj1aAwcOtHudAADAvOwuNzNnzlTv3r3l4+OjmTNn3nE6i8Vid7lZvny5hg8frrlz56ply5aaP3++OnbsqEOHDqlmzZq3nadHjx769ddftWDBAtWpU0fnzp1TTk6OvR8DAACYnN3l5sSJE7f97/sxY8YMxcbGatCgQZKkWbNm6auvvtK8efM0derUAtNv2LBBW7du1fHjxxUYGChJqlWrVpFkAQAA5lCoq6X+W25urhITE/Xbb7/ZPc+NGzeUkJBQ4KZ/MTEx2rlz523n+Z//+R9FRUXpjTfeUPXq1VW3bl298sorun79+n3lBwAA5lGoE4qHDx+uBg0aKDY2Vrm5uWrdurV27dolX19fffHFF2rbtu09l3HhwgXl5uYqKCgo33hQUJDOnj1723mOHz+u7du3y8fHR2vWrNGFCxc0dOhQpaWlaeHChbedJysrS1lZWbbX6enpkqTs7GxlZ2fb+YlxO7e+P75HlBRsk3DUrdMacnJynLbdFMd2WRyfw2iOfK5ClZuVK1fqueeekyR9/vnnOnnypJKSkrR06VKNHj1aO3bssHtZFosl32ur1Vpg7Ja8vDxZLBZ9/PHHKleunKSbh7a6deumd999V2XKlCkwz9SpUzV+/PgC4xs3bpSvr6/dOXFn8fHxRkcA8mGbhL2Sr0qSh7Zv365T/s5dlzO3y+L8HEbJyMiwe9pClZsLFy6oatWqkqT169ere/fuqlu3rmJjY+95JdUtlSpVkru7e4G9NOfOnSuwN+eW4OBgVa9e3VZsJKlevXqyWq365Zdf9OCDDxaYZ9SoUYqLi7O9Tk9PV0hIiGJiYhQQEGBXVtxedna24uPj1aFDh9s+jgMobmyTcNTBM+l688BuPfbYY6pfzTn/JhTHdlkcn8Not4682KNQ5SYoKEiHDh1ScHCwNmzYoLlz50q62arc3d3tWoaXl5eaNWum+Ph4Pf3007bx+Ph4denS5bbztGzZUitWrNDVq1fl73+zmv70009yc3NTjRo1bjuPt7e3vL29C4x7enryl18R4btEScM2CXt5eHjY/nT2NuPM7bI4P4dRHPlchTqheMCAAerRo4ciIyNlsVhsN/L79ttvFR4ebvdy4uLi9OGHH2rhwoU6fPiwRowYodOnT2vIkCGSbu516du3r236Xr16qWLFihowYIAOHTqkb775Rq+++qoGDhx420NSAADA9RRqz824ceMUGRmp5ORkde/e3bZnxN3dXSNHjrR7OT179tTFixc1YcIEpaamKjIyUuvXr1doaKgkKTU1VadPn7ZN7+/vr/j4eL344ouKiopSxYoV1aNHD02aNKkwHwMAAJhQoR+/0K1btwJj/fr1c3g5Q4cO1dChQ2/73uLFiwuMhYeHc7IgAAC4I8MfvwAAAFCUDH38AgAAQFEz9PELAAAARa1IHr8AAABQUhSq3HTr1k3Tpk0rMD59+nR17979vkMBAAAUVqHKzdatW9WpU6cC40888YS++eab+w4FAABQWIUqN1evXpWXl1eBcU9PT4dujwwAAFDUClVuIiMjtXz58gLjy5YtU0RExH2HAgAAKKxC3cRvzJgxeuaZZ3Ts2DG1a9dOkvT111/r008/1YoVK4o0IAAAgCMKVW46d+6stWvXasqUKVq5cqXKlCmjhg0b6j//+Y/atGlT1BkBAADsVujHL3Tq1Om2JxUDAAAYqdD3ubl06ZI+/PBD/f3vf1daWpokad++fUpJSSmycAAAAI4q1J6bH374Qe3bt1e5cuV08uRJDRo0SIGBgVqzZo1OnTqlpUuXFnVOAAAAuxSq3MTFxal///564403VLZsWdt4x44d1atXryILBwCAM2XlZsrNJ0Un0o/IzcffKevIycnRmZwzOpx2WB4ehT4b5K5OpF+Vm0+KsnIzJZVzyjpKk0J9y999953mz59fYLx69eo6e/bsfYcCAKA4nLl2Sn5hc/T3Pc5f19wNc526fL8w6cy1xmqmIKeupzQoVLnx8fG57c36jhw5osqVK993KAAAikM1v1BdO/Gi3u7ZWLWrOG/PzY7tO9TysZZO23Nz7NxVvbQ8UdWiQ52y/NKmUN9yly5dNGHCBH322WeSJIvFotOnT2vkyJF65plnijQgAADO4u3uo7zM6goLeEgRFZ1zOCc7O1snPE6oXmA9eXp6OmUdeZmXlZd5Xt7uPk5ZfmlTqKul3nzzTZ0/f15VqlTR9evX1aZNG9WpU0dly5bV5MmTizojAACA3Qq15yYgIEDbt2/Xpk2btG/fPuXl5alp06Zq3759UecDAABwiMPlJicnRz4+PkpMTFS7du1sj18AAAAoCRw+LOXh4aHQ0FDl5uY6Iw8AAMB9KdQ5N//4xz80atQo252JAQAASopCnXMze/ZsHT16VNWqVVNoaKj8/Pzyvb9v374iCQcAAOCoQl8KbrFYijoLAADAfStUuRk3blwRxwAAACgaDp1zk5GRob/85S+qXr26qlSpol69eunChQvOygYAAOAwh8rN66+/rsWLF6tTp0569tlnFR8frxdeeMFZ2QAAABzm0GGp1atXa8GCBXr22WclSc8995xatmyp3Nxcubu7OyUgAACAIxzac5OcnKxWrVrZXj/yyCPy8PDQmTNnijwYAABAYThUbnJzc+Xl5ZVvzMPDQzk5OUUaCgAAoLAcOixltVrVv39/eXt728YyMzM1ZMiQfPe6Wb16ddElBAAAcIBD5aZfv34Fxp577rkiCwMAAHC/HCo3ixYtclYOAACAIlGoZ0sBAACUVJQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKpQbAABgKoaXm7lz5yosLEw+Pj5q1qyZtm3bdsdpt2zZIovFUuAnKSmpGBMDAICSzNBys3z5cg0fPlyjR4/W/v371apVK3Xs2FGnT5++63xHjhxRamqq7efBBx8spsQAAKCkM7TczJgxQ7GxsRo0aJDq1aunWbNmKSQkRPPmzbvrfFWqVFHVqlVtP+7u7sWUGAAAlHQeRq34xo0bSkhI0MiRI/ONx8TEaOfOnXedt0mTJsrMzFRERIT+8Y9/KDo6+o7TZmVlKSsry/Y6PT1dkpSdna3s7Oz7+AS49f3xPaKkYJuEo3Jycmx/Omu7KY7tsjg+h9Ec+VyGlZsLFy4oNzdXQUFB+caDgoJ09uzZ284THBys999/X82aNVNWVpb+9a9/6fHHH9eWLVvUunXr284zdepUjR8/vsD4xo0b5evre/8fBIqPjzc6ApAP2yTslXxVkjy0fft2nfJ37rqcuV0W5+cwSkZGht3TGlZubrFYLPleW63WAmO3PPTQQ3rooYdsr1u0aKHk5GS9+eabdyw3o0aNUlxcnO11enq6QkJCFBMTo4CAgCL4BK4rOztb8fHx6tChgzw9PY2OA7BNwmEHz6TrzQO79dhjj6l+Nef8m1Ac22VxfA6j3TryYg/Dyk2lSpXk7u5eYC/NuXPnCuzNuZvmzZvro48+uuP73t7e8vb2LjDu6enJX35FhO8SJQ3bJOyVbb35y3TSr9fk4eGcfxKvXc/S3vNS1TNX5Vem4L9HReFkWqYkycPDw7TbviOfy7By4+XlpWbNmik+Pl5PP/20bTw+Pl5dunSxezn79+9XcHCwMyICAEzu2LmrkqSRqw84eU0e+tfR75y8DsnP2/ADMiWCod9CXFyc+vTpo6ioKLVo0ULvv/++Tp8+rSFDhki6eUgpJSVFS5culSTNmjVLtWrVUv369XXjxg199NFHWrVqlVatWmXkxwAAlFIx9atKkmpX8VcZT+dceXsk9bJeXnlAb3VroIeCyzllHdLNYhNWyc9pyy9NDC03PXv21MWLFzVhwgSlpqYqMjJS69evV2hoqCQpNTU13z1vbty4oVdeeUUpKSkqU6aM6tevr3Xr1unJJ5806iMAAEqxQD8vPftITaeu49aVTLUr+ymyuvPKDf6X4fuvhg4dqqFDh972vcWLF+d7/be//U1/+9vfiiEVAAAorQx//AIAAEBRotwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABTodwAAABT8TA6AEqOjIwMJSUl2T391etZ2nngmCpU2iv/Mt52zxceHi5fX9/CRAQA4J4oN7BJSkpSs2bNHJ7vDQenT0hIUNOmTR1eDwAA9qDcwCY8PFwJCQl2T38k9ZLiVhzQjO4N9FBweYfWAwCAs1BuYOPr6+vQHhW3Uxflve266kU2UuPQik5MBgCA/TihGAAAmAp7bkzsxIVrupaV47TlHzt/zfanh4fzNiU/bw+FVfJz2vIBAOZCuTGpExeuKfrNLcWyrpdXHnD6Oja/0paCAwCwC+XGpG7tsZnVs7HqVPF3zjquZ+mLLbv0VNsW8nPgUnBHHD13VcOXJzp1DxQAwFwoNyZXp4q/IquXc8qys7Ozdbay1DS0gjw9PZ2yDgAAHMUJxQAAwFTYc2NSWbmZcvNJ0Yn0I3Lzcc5hqZycHJ3JOaPDaYeddkLxifSrcvNJUVZupiTn7IECAJgL5cakzlw7Jb+wOfr7Hueva+6GuU5dvl+YdOZaYzVTkFPXAwAwB8qNSVXzC9W1Ey/q7Z6NVdtJJxTn5ORox/YdavlYS6ftuTl27qpeWp6oatGhTlk+AMB8KDcm5e3uo7zM6goLeEgRFZ13QvEJjxOqF1jPaScU52VeVl7meXm7+zhl+QAA8+GEYgAAYCqUGwAAYCqUGwAAYCqUGwAAYCqUGwAAYCpcLWVS17NzJUk/plx22jquXc/S3vNS1VO/OfXZUgAAOIJyY1LH/n8pGLna2U/s9tC/jn7n5HVIft5sqgCMl5GRoaSkJIfmOZJ6SVlnj+rwj2WUd7G83fOFh4fL19fXwYSQKDemFVO/qiSpdhV/lfF0d8o6jqRe1ssrD+itbg30ULDzHo3g5+2hsEp+Tls+ANgrKSlJzZo1K9S8vZY4Nn1CQoKaNm1aqHW5OsqNSQX6eenZR2o6dR05OTmSpNqV/Zz25HEAKEnCw8OVkJDg0DxXr2dp3eZd6hTdQv4OHMIPDw93NB7+P8oNAAB28vX1dXhvSnZ2tn67cE4tHoly2t3ckR9XSwEAAFOh3AAAAFOh3AAAAFOh3AAAAFOh3AAAAFPhainYOHpzKm5MBQAoiSg3sCnszam4MRUAoCQxvNzMnTtX06dPV2pqqurXr69Zs2apVatW95xvx44datOmjSIjI5WYmOj8oC7A0ZtTcWMqAEBJZGi5Wb58uYYPH665c+eqZcuWmj9/vjp27KhDhw6pZs0731338uXL6tu3rx5//HH9+uuvxZjY3By9ORU3pgIAlESGnlA8Y8YMxcbGatCgQapXr55mzZqlkJAQzZs3767zPf/88+rVq5datGhRTEkBAEBpYVi5uXHjhhISEhQTE5NvPCYmRjt37rzjfIsWLdKxY8f0+uuvOzsiAAAohQw7LHXhwgXl5uYqKCgo33hQUJDOnj1723l+/vlnjRw5Utu2bZOHh33Rs7KylJWVZXudnp4u6eYhlezs7EKmhyTb98f3iJKCbRIlEdtl0XDk+zP8hGKLxZLvtdVqLTAmSbm5uerVq5fGjx+vunXr2r38qVOnavz48QXGN27cyOXIRSQ+Pt7oCEA+bJMoidgu709GRobd01qsVqvViVnu6MaNG/L19dWKFSv09NNP28ZfeuklJSYmauvWrfmmv3TpkipUqCB3d3fbWF5enqxWq9zd3bVx40a1a9euwHput+cmJCREFy5cUEBAgBM+mevIzs5WfHy8OnTowAnFKBHYJlESsV0WjfT0dFWqVEmXL1++57/fhu258fLyUrNmzRQfH5+v3MTHx6tLly4Fpg8ICNCBAwfyjc2dO1ebNm3SypUrFRYWdtv1eHt7y9u74GXKnp6ebGRFhO8SJQ3bJEoitsv748h3Z+hhqbi4OPXp00dRUVFq0aKF3n//fZ0+fVpDhgyRJI0aNUopKSlaunSp3NzcFBkZmW/+KlWqyMfHp8A4AABwXYaWm549e+rixYuaMGGCUlNTFRkZqfXr1ys0NFSSlJqaqtOnTxsZEQAAlDKGn1A8dOhQDR069LbvLV68+K7zjhs3TuPGjSv6UAAAoNTiqeAAAMBUKDcAAMBUKDcAAMBUKDcAAMBUDD+hGADuJCMjQ0lJSXZPf/V6lnYeOKYKlfbKv0zB+1vdTXh4OHctB0yCcgOgWJ24cE3XsnLsmvbQgUT17NjW4XW84fAc0vIvtyiiQWO7pvXz9lBYJb9CrAVAcaDcACg2+5PP6ZkFa+2ePvf6VQU992fnBfo/Xt2cIPfdR+yefv0Lzyg8qKITEwEoLMoNgGKz5fiP8gub49hMEc7JUtAuh6b+5Wozyg1QQlFuABSbno2bSXpbIYG+8va49/UMWVmZSkm2/y7leXm5OpJ0RA+FPyQ3N/d7z/B/VA+pKW9vH7umLePlrpahxda6ADiIcgOg2FQrV04j2rRzbKbG9k+anZ2t9VqvJ598kgcUAi6MS8EBAICpUG4AAICpUG4AAICpUG4AAICpUG4AAICpUG4AAICpUG4AAICpUG4AAICpUG4AAICpUG4AAICpUG4AAICpUG4AAICpUG4AAICpuNxTwa1WqyQpPT3d4CSlX3Z2tjIyMpSens4TmFEisE2iJGK7LBq3/t2+9e/43bhcubly5YokKSQkxOAkAADAUVeuXFG5cuXuOo3Fak8FMpG8vDydOXNGZcuWlcViMTpOqZaenq6QkBAlJycrICDA6DgA2yRKJLbLomG1WnXlyhVVq1ZNbm53P6vG5fbcuLm5qUaNGkbHMJWAgAD+h0WJwjaJkojt8v7da4/NLZxQDAAATIVyAwAATIVyg0Lz9vbW66+/Lm9vb6OjAJLYJlEysV0WP5c7oRgAAJgbe24AAICpUG4AAICpUG4AAICpUG4AAChC169fV0ZGhu31qVOnNGvWLG3cuNHAVK6FcgOHbNu2Tc8995xatGihlJQUSdK//vUvbd++3eBkcEW//vqr+vTpo2rVqsnDw0Pu7u75fgAjdOnSRUuXLpUkXbp0Sb/73e/01ltvqUuXLpo3b57B6VyDy92hGIW3atUq9enTR71799b+/fuVlZUl6eZzPqZMmaL169cbnBCupn///jp9+rTGjBmj4OBgHqmCEmHfvn2aOXOmJGnlypUKCgrS/v37tWrVKo0dO1YvvPCCwQnNj3IDu02aNEnvvfee+vbtq2XLltnGH330UU2YMMHAZHBV27dv17Zt29S4cWOjowA2GRkZKlu2rCRp48aN+uMf/yg3Nzc1b95cp06dMjida+CwFOx25MgRtW7dusB4QECALl26VPyB4PJCQkLErbpQ0tSpU0dr165VcnKyvvrqK8XExEiSzp07x7OlignlBnYLDg7W0aNHC4xv375dDzzwgAGJ4OpmzZqlkSNH6uTJk0ZHAWzGjh2rV155RbVq1dIjjzyiFi1aSLq5F6dJkyYGp3MN3KEYdnvjjTe0ZMkSLVy4UB06dND69et16tQpjRgxQmPHjtVf//pXoyPCxVSoUEEZGRnKycmRr6+vPD09872flpZmUDK4urNnzyo1NVWNGjWSm9vN/Qh79uxRQECAwsPDDU5nfpQbOGT06NGaOXOmMjMzJd18Zsorr7yiiRMnGpwMrmjJkiV3fb9fv37FlAQo6OjRozp27Jhat26tMmXKyGq1ctJ7MaHcwGEZGRk6dOiQ8vLyFBERIX9/f6MjAUCJcfHiRfXo0UObN2+WxWLRzz//rAceeECxsbEqX7683nrrLaMjmh7n3MBhZ86c0cWLF9WgQQP5+/tzQicMlZubq1WrVmnSpEmaPHmy1qxZo9zcXKNjwYWNGDFCnp6eOn36tHx9fW3jPXv21IYNGwxM5jq4FBx2u9NvI4MGDeK3ERji6NGjevLJJ5WSkqKHHnpIVqtVP/30k0JCQrRu3TrVrl3b6IhwQRs3btRXX32lGjVq5Bt/8MEHuRS8mLDnBnbjtxGUNMOGDVPt2rWVnJysffv2af/+/Tp9+rTCwsI0bNgwo+PBRV27di3f35G3XLhwQd7e3gYkcj2UG9ht48aN+uc//8lvIygxtm7dqjfeeEOBgYG2sYoVK2ratGnaunWrgcngylq3bm17/IIkWSwW5eXlafr06YqOjjYwmevgsBTsxm8jKGm8vb115cqVAuNXr16Vl5eXAYkAafr06Wrbtq327t2rGzdu6G9/+5sOHjyotLQ07dixw+h4LoE9N7Abv42gpHnqqac0ePBgffvtt7JarbJardq9e7eGDBmizp07Gx0PLioiIkI//PCDHnnkEXXo0EHXrl3TH//4R+3fv5/zwIoJl4LDbocOHVLbtm3VrFkzbdq0SZ07d8732wj/06K4Xbp0Sf369dPnn39uu4FfTk6OOnfurMWLF6tcuXIGJwRgBMoNHHL27FnNmzdPCQkJysvLU9OmTfWXv/xFwcHBRkeDC/v555+VlJQkq9WqiIgI1alTx+hIcGG1atXSwIEDNWDAAIWEhBgdxyVRbmCX7OxsxcTEaP78+apbt67RcQCgxJozZ44WL16s77//XtHR0YqNjdXTTz/NuYnFiHIDu1WuXFk7d+7Ugw8+aHQUuLC4uDhNnDhRfn5+iouLu+u0M2bMKKZUQEHff/+9Fi5cqE8//VQ5OTnq1auXBg4cqKZNmxodzfQoN7Dbyy+/LE9PT02bNs3oKHBh0dHRWrNmjcqXL3/XE9ktFos2bdpUjMmA28vOztbcuXP12muvKTs7W5GRkXrppZc0YMAAnjXlJJQb2O3FF1/U0qVLVadOHUVFRcnPzy/f+/yWDAD/Kzs7W2vWrNGiRYsUHx+v5s2bKzY2VmfOnNE777yj6OhoffLJJ0bHNCXuc4N7cnd3V2pqqn788Ufb7tSffvop3zT89oGSID09XZs2bVJ4eLjCw8ONjgMXtW/fPi1atEiffvqp3N3d1adPH82cOTPfNhkTE6PWrVsbmNLcKDe4p1s79zZv3mxwEiC/Hj16qHXr1vrrX/+q69evKyoqSidPnpTVatWyZcv0zDPPGB0RLujhhx9Whw4dNG/ePHXt2tV2m4L/KyIiQs8++6wB6VwD5QZAqfXNN99o9OjRkqQ1a9bIarXq0qVLWrJkiSZNmkS5gSGOHz+u0NDQu07j5+enRYsWFVMi10O5gV2++uqre94QjTvCorhdvnzZ9lypDRs26JlnnpGvr686deqkV1991eB0cFX3KjZwPsoN7NKvX7+7vm+xWJSbm1tMaYCbQkJCtGvXLgUGBmrDhg1atmyZJOm3336Tj4+PwengqnJzczVz5kx99tlnOn36tG7cuJHv/bS0NIOSuQ6eLQW7nD17Vnl5eXf8odjACMOHD1fv3r1Vo0YNVatWTW3btpV083BVgwYNjA0HlzV+/HjNmDFDPXr00OXLlxUXF6c//vGPcnNz07hx44yO5xK4FBz3dOtqqSpVqhgdBShg7969Sk5OVocOHeTv7y9JWrduncqXL6+WLVsanA6uqHbt2po9e7Y6deqksmXLKjEx0Ta2e/duLv8uBpQb3JObm5vOnj1LuUGJl5ubqwMHDig0NFQVKlQwOg5clJ+fnw4fPqyaNWsqODhY69atU9OmTXX8+HE1adJEly9fNjqi6XFYCvfUr18/lSlTxugYQAHDhw/XggULJN0sNm3atFHTpk0VEhKiLVu2GBsOLqtGjRpKTU2VJNWpU0cbN26UJH333Xc8X6qYUG5wT4sWLVLZsmWNjgEUsHLlSjVq1EiS9Pnnn+vEiRNKSkrS8OHDbZeIA8Xt6aef1tdffy1JeumllzRmzBg9+OCD6tu3rwYOHGhwOtfAYSkApZaPj4+OHj2qGjVqaPDgwfL19dWsWbN04sQJNWrUSOnp6UZHBLR7927t3LlTderU4ZYZxYRLwQGUWkFBQTp06JCCg4O1YcMGzZ07V5KUkZEhd3d3g9MBNzVv3lzNmzc3OoZLodwAKLUGDBigHj16KDg4WBaLRR06dJAkffvttzxbCoa5ePGiKlasKElKTk7WBx98oOvXr6tz585q1aqVwelcA4elAJRqK1euVHJysrp3764aNWpIkpYsWaLy5curS5cuBqeDKzlw4ID+8Ic/KDk5WQ8++KCWLVumJ554QteuXZObm5uuXbumlStXqmvXrkZHNT3KDex27do1TZs2TV9//bXOnTunvLy8fO8fP37coGSAlJmZyV2JYaiOHTvKw8NDr732mj766CN98cUXiomJ0YcffihJevHFF5WQkKDdu3cbnNT8KDew25/+9Cdt3bpVffr0sR0G+L9eeuklg5LBVeXm5mrKlCl677339Ouvv+qnn37SAw88oDFjxqhWrVqKjY01OiJcSKVKlbRp0yY1bNhQV69eVUBAgPbs2aOoqChJUlJSkpo3b65Lly4ZG9QFcM4N7Pbll19q3bp13PUVJcbkyZO1ZMkSvfHGG/rzn/9sG2/QoIFmzpxJuUGxSktLU9WqVSVJ/v7+8vPzsz3YVZIqVKigK1euGBXPpXCfG9itQoUK+f5HBYy2dOlSvf/+++rdu3e+q6MaNmyopKQkA5PBVf33Hu3/fo3iwZ4b2G3ixIkaO3aslixZIl9fX6PjAEpJSVGdOnUKjOfl5Sk7O9uARHB1/fv3t92FODMzU0OGDJGfn58kKSsry8hoLoVyA7u99dZbOnbsmIKCglSrVi15enrme3/fvn0GJYOrql+/vrZt26bQ0NB84ytWrFCTJk0MSgVX1a9fv3yvn3vuuQLT9O3bt7jiuDTKDezG5YsoaV5//XX16dNHKSkpysvL0+rVq3XkyBEtXbpUX3zxhdHx4GIWLVpkdAT8f1wtBaBU++qrrzRlyhQlJCQoLy9PTZs21dixYxUTE2N0NAAGodzAYQkJCTp8+LAsFosiIiLY/Q9D5OTkaPLkyRo4cKBCQkKMjgOgBKHcwG7nzp3Ts88+qy1btqh8+fKyWq26fPmyoqOjtWzZMlWuXNnoiHAx/v7++vHHH1WrVi2jowAoQbgUHHZ78cUXlZ6eroMHDyotLU2//fabfvzxR6Wnp2vYsGFGx4MLat++vbZs2WJ0DAAlDHtuYLdy5crpP//5jx5++OF843v27FFMTAx33USxmz9/vsaNG6fevXurWbNmtktub+ncubNByQAYiaulYLe8vLwCl39LkqenZ4HnTAHF4YUXXpAkzZgxo8B7FotFubm5xR0JkCT961//0nvvvacTJ05o165dCg0N1axZsxQWFsYDXYsBh6Vgt3bt2umll17SmTNnbGMpKSkaMWKEHn/8cQOTwVXl5eXd8YdiA6PMmzdPcXFxevLJJ3Xp0iXbtli+fHnNmjXL2HAugnIDu73zzju6cuWKatWqpdq1a6tOnToKCwvTlStXNGfOHKPjAUCJMGfOHH3wwQcaPXp0vseCREVF6cCBAwYmcx0cloLdQkJCtG/fPsXHxyspKUlWq1URERFq37690dHgombPnn3bcYvFIh8fH9WpU0etW7fO9w8M4GwnTpy47S0yvL29de3aNQMSuR7KDRzWoUMHdejQwegYgGbOnKnz588rIyNDFSpUkNVq1aVLl+Tr6yt/f3+dO3dODzzwgDZv3sy9cFBswsLClJiYWOCxIF9++aUiIiIMSuVaKDe4q9mzZ2vw4MHy8fG542/Jt3A5OIrblClT9P777+vDDz9U7dq1JUlHjx7V888/r8GDB6tly5Z69tlnNWLECK1cudLgtHAVr776qv7yl78oMzNTVqtVe/bs0aeffqqpU6fqww8/NDqeS+BScNxVWFiY9u7dq4oVKyosLOyO01ksFh0/frwYkwFS7dq1tWrVKjVu3Djf+P79+/XMM8/o+PHj2rlzp5555hmlpqYaExIu6YMPPtCkSZOUnJwsSapevbrGjRun2NhYg5O5BsoNgFLL19dX33zzjaKiovKNf/fdd2rTpo0yMjJ08uRJRUZG6urVqwalhCu7cOGC8vLyVKVKFaOjuBSulkKh5ebmKjExUb/99pvRUeCioqOj9fzzz2v//v22sf379+uFF15Qu3btJEkHDhy4615HoKiNHz9ex44dkyRVqlSJYmMAyg3sNnz4cC1YsEDSzWLTunVrNW3aVCEhIdwCH4ZYsGCBAgMD1axZM3l7e8vb21tRUVEKDAy0bav+/v566623DE4KV7Jq1SrVrVtXzZs31zvvvKPz588bHcnlcFgKdqtRo4bWrl2rqKgorV27Vn/5y1+0efNmLV26VJs3b9aOHTuMjggXlZSUpJ9++klWq1Xh4eF66KGHjI4EF3fw4EF9/PHHWrZsmX755Re1b99ezz33nLp27SpfX1+j45ke5QZ28/Hx0dGjR1WjRg0NHjxYvr6+mjVrlk6cOKFGjRopPT3d6IhwUTdu3NCJEydUu3ZteXhwEShKlh07duiTTz7RihUrlJmZyd+VxYDDUrBbUFCQDh06pNzcXG3YsMF2876MjAxukgZDZGRkKDY2Vr6+vqpfv75Onz4t6eZtCaZNm2ZwOuAmPz8/lSlTRl5eXsrOzjY6jkug3MBuAwYMUI8ePRQZGSmLxWK7kd+3336r8PBwg9PBFY0aNUrff/+9tmzZIh8fH9t4+/bttXz5cgOTwdWdOHFCkydPVkREhKKiorRv3z6NGzdOZ8+eNTqaS2D/Lew2btw4RUZGKjk5Wd27d5e3t7ckyd3dXSNHjjQ4HVzR2rVrtXz5cjVv3lwWi8U2HhERYbtaBShuLVq00J49e9SgQQMNGDBAvXr1UvXq1Y2O5VIoN3BIt27dCoz169fPgCSAdP78+dteZnvt2rV8ZQcoTtHR0frwww9Vv359o6O4LMoN7orHL6Ake/jhh7Vu3Tq9+OKLkmQrNB988IFatGhhZDS4sClTphgdweVxtRTuiscvoCTbuXOnnnjiCfXu3VuLFy/W888/r4MHD2rXrl3aunWrmjVrZnREuIi4uDhNnDhRfn5+iouLu+u0M2bMKKZUros9N7irEydO3Pa/gZLg0Ucf1Y4dO/Tmm2+qdu3a2rhxo5o2bapdu3apQYMGRseDC9m/f7/tSqj/e8fs/8bh0uLBnhsAprRy5crbniMGwPy4FBx269at223vHTJ9+nR1797dgERwZTk5OTp48KB++umnfOP//ve/1ahRI/Xu3dugZACMxp4b2K1y5cratGlTgd39Bw4cUPv27fXrr78alAyu5tChQ3rqqad06tQpSVKXLl00b9489ejRQ99//70GDRqkl156SSEhIQYnhav67rvvtGLFCp0+fVo3btzI997q1asNSuU62HMDu129elVeXl4Fxj09PbmdOIrVyJEjFRYWpn//+9/q0aOH1q5dq1atWunxxx9XcnKy3nzzTYoNDLNs2TK1bNlShw4d0po1a5Sdna1Dhw5p06ZNKleunNHxXALlBnaLjIy87V1fly1bpoiICAMSwVXt2bNH06dP11NPPaV58+ZJkl599VWNHTtWZcuWNTgdXN2UKVM0c+ZMffHFF/Ly8tLbb7+tw4cPq0ePHqpZs6bR8VwCV0vBbmPGjNEzzzyjY8eOqV27dpKkr7/+Wp9++qlWrFhhcDq4knPnztnu+Fq+fHn5+vqqTZs2BqcCbjp27Jg6deokSfL29rbdVHLEiBFq166dxo8fb3BC82PPDezWuXNnrV27VkePHtXQoUP18ssv65dfftF//vMfde3a1eh4cCEWi0Vubv/715ebm5s8PT0NTAT8r8DAQF25ckWSVL16df3444+SpEuXLikjI8PIaC6DE4oBlDpubm4qV66c7Z4hly5dUkBAQL7CI0lpaWlGxIOL69Wrl6KiohQXF6fJkyfr7bffVpcuXRQfH6+mTZtyQnExoNzAIZcuXdLKlSt1/PhxvfLKKwoMDNS+ffsUFBTEg+FQbJYsWWLXdDz3DEZIS0tTZmamqlWrpry8PL355pvavn276tSpozFjxqhChQpGRzQ9yg3s9sMPP6h9+/YqV66cTp48qSNHjuiBBx7QmDFjdOrUKS1dutToiAAAcM4N7BcXF6f+/fvr559/lo+Pj228Y8eO+uabbwxMBgDA/+JqKdjtu+++0/z58wuMV69eXWfPnjUgEQCUHG5ubvd8dpTFYlFOTk4xJXJdlBvYzcfH57Y36zty5IgqV65sQCIAKDnWrFlzx/d27typOXPmiDNBigfn3MBugwcP1vnz5/XZZ58pMDBQP/zwg9zd3dW1a1e1bt1as2bNMjoiAJQoSUlJGjVqlD7//HP17t1bEydO5EZ+xYBzbmC3N998U+fPn1eVKlV0/fp1tWnTRnXq1FHZsmU1efJko+MBQIlx5swZ/fnPf1bDhg2Vk5OjxMRELVmyhGJTTNhzA4dt2rRJ+/btU15enpo2bar27dsbHQkuqlu3boqKitLIkSPzjU+fPl179uzhztkodpcvX9aUKVM0Z84cNW7cWP/85z/VqlUro2O5HMoNgFKLJ9WjJHnjjTf0z3/+U1WrVtWUKVPUpUsXoyO5LMoN7JKXl6fFixdr9erVOnnypCwWi8LCwtStWzf16dPnnlcIAM5QpkwZJSYm6qGHHso3npSUpCZNmuj69esGJYMrcnNzU5kyZdS+fXu5u7vfcTruUOx8XC2Fe7JarercubPWr1+vRo0aqUGDBrJarTp8+LD69++v1atXa+3atUbHhAu69aT6sWPH5hvnSfUwQt++fflFr4Sg3OCeFi9erG+++UZff/21oqOj8723adMmde3aVUuXLlXfvn0NSghXxZPqUZIsXrzY6Aj4/zgshXuKiYlRu3btCpy0ecuUKVO0detWffXVV8WcDJDWrVunKVOmKDExUWXKlFHDhg31+uuvq02bNkZHA2AQyg3uqWrVqtqwYYMaN2582/f379+vjh07cpdiAECJwH1ucE9paWkKCgq64/tBQUH67bffijERAAB3xjk3uKfc3Fx5eNx5U3F3d+dZKSg2gYGB+umnn1SpUiVVqFDhridwpqWlFWMyACUF5Qb3ZLVa1b9/f3l7e9/2/aysrGJOBFc2c+ZMlS1b1vbfXJ0C4L9xzg3uacCAAXZNt2jRIicnAQDg3ig3AEotd3d3paamqkqVKvnGL168qCpVqig3N9egZACMxAnFAEqtO/1ulpWVJS8vr2JOA6Ck4JwbAKXO7NmzJUkWi0Uffvih/P39be/l5ubqm2++UXh4uFHxABiMw1IASp2wsDBJ0qlTp1SjRo18z/Hx8vJSrVq1NGHCBP3ud78zKiIAA1FuAJRa0dHRWr16tSpUqGB0FAAlCOUGgGnk5ubqwIEDCg0NpfAALowTigGUWsOHD9eCBQsk3Sw2rVu3VtOmTRUSEqItW7YYGw6AYSg3AEqtFStWqFGjRpKkzz//XCdPnlRSUpKGDx+u0aNHG5wOgFEoNwBKrYsXL6pq1aqSpPXr16t79+6qW7euYmNjdeDAAYPTATAK5QZAqRUUFKRDhw4pNzdXGzZsUPv27SVJGRkZ+a6gAuBauM8NgFJrwIAB6tGjh4KDg2WxWNShQwdJ0rfffst9bgAXRrkBUGqNGzdOkZGRSk5OVvfu3W0Pd3V3d9fIkSMNTgfAKFwKDgAATIU9NwBKldmzZ2vw4MHy8fGxPYbhToYNG1ZMqQCUJOy5AVCqhIWFae/evapYsaLtMQy3Y7FYdPz48WJMBqCkoNwAAABT4VJwAABgKpxzA6DUiouLu+24xWKRj4+P6tSpoy5duigwMLCYkwEwEoelAJRa0dHR2rdvn3Jzc/XQQw/JarXq559/lru7u8LDw3XkyBFZLBZt375dERERRscFUEw4LAWg1OrSpYvat2+vM2fOKCEhQfv27VNKSoo6dOigP/3pT0pJSVHr1q01YsQIo6MCKEbsuQFQalWvXl3x8fEF9socPHhQMTExSklJ0b59+xQTE6MLFy4YlBJAcWPPDYBS6/Llyzp37lyB8fPnzys9PV2SVL58ed24caO4owEwEOUGQKnVpUsXDRw4UGvWrNEvv/yilJQUrVmzRrGxserataskac+ePapbt66xQQEUKw5LASi1rl69qhEjRmjp0qXKycmRJHl4eKhfv36aOXOm/Pz8lJiYKElq3LixcUEBFCvKDYBS7+rVqzp+/LisVqtq164tf39/oyMBMBD3uQFQ6vn7+yswMFAWi4ViA4BzbgCUXnl5eZowYYLKlSun0NBQ1axZU+XLl9fEiROVl5dndDwABmHPDYBSa/To0VqwYIGmTZumli1bymq1aseOHRo3bpwyMzM1efJkoyMCMADn3AAotapVq6b33ntPnTt3zjf+73//W0OHDlVKSopByQAYicNSAEqttLQ0hYeHFxgPDw9XWlqaAYkAlASUGwClVqNGjfTOO+8UGH/nnXfUqFEjAxIBKAk4LAWg1Nq6das6deqkmjVrqkWLFrJYLNq5c6eSk5O1fv16tWrVyuiIAAxAuQFQqp05c0bvvvuukpKSZLVaFRERoaFDh6patWpGRwNgEMoNANNJTk7W66+/roULFxodBYABKDcATOf7779X06ZNlZuba3QUAAbghGIAAGAqlBsAAGAqlBsAAGAqPH4BQKnzxz/+8a7vX7p0qXiCACiRKDcASp1y5crd8/2+ffsWUxoAJQ1XSwEAAFPhnBsAAGAqlBsAAGAqlBsAAGAqlBsAAGAqlBsAAGAqlBsAJdrJkydlsViUmJhYYtbVtm1bDR8+3Ol5ABQO5QbAHfXv318Wi0VDhgwp8N7QoUNlsVjUv3//fNN37drV4fX88ssv8vLyUnh4+H2kvX8hISFKTU1VZGSkJGnLli2yWCzcFBAoZSg3AO4qJCREy5Yt0/Xr121jmZmZ+vTTT1WzZs0iWcfixYvVo0cPZWRkaMeOHUWyTEfduHFD7u7uqlq1qjw8uL8pUJpRbgDcVdOmTVWzZk2tXr3aNrZ69WqFhISoSZMm9718q9WqRYsWqU+fPurVq5cWLFhwz3n+53/+Rw8++KDKlCmj6OhoLVmypMAellWrVql+/fry9vZWrVq19NZbb+VbRq1atTRp0iT1799f5cqV05///Od8h6VOnjyp6OhoSVKFChUK7KXKy8vT3/72NwUGBqpq1aoaN25cvuVbLBbNnz9fTz31lHx9fVWvXj3t2rVLR48eVdu2beXn56cWLVro2LFjhf7uANwe5QbAPQ0YMECLFi2yvV64cKEGDhxYJMvevHmzMjIy1L59e/Xp00efffaZrly5csfpT548qW7duqlr165KTEzU888/r9GjR+ebJiEhQT169NCzzz6rAwcOaNy4cRozZowWL16cb7rp06crMjJSCQkJGjNmTL73QkJCtGrVKknSkSNHlJqaqrffftv2/pIlS+Tn56dvv/1Wb7zxhiZMmKD4+Ph8y5g4caL69u2rxMREhYeHq1evXnr++ec1atQo7d27V5L017/+1eHvDMA9WAHgDvr162ft0qWL9fz581Zvb2/riRMnrCdPnrT6+PhYz58/b+3SpYu1X79+BaZ3RK9evazDhw+3vW7UqJH1gw8+sL0+ceKEVZJ1//79VqvVan3ttdeskZGR+ZYxevRoqyTrb7/9Zltmhw4d8k3z6quvWiMiImyvQ0NDrV27ds03zX+va/PmzfmWe0ubNm2sjz32WL6xhx9+2Praa6/ZXkuy/uMf/7C93rVrl1WSdcGCBbaxTz/91Orj43O7rwXAfWDPDYB7qlSpkjp16qQlS5Zo0aJF6tSpkypVqnTfy7106ZJWr16t5557zjb23HPPaeHChXec58iRI3r44YfzjT3yyCP5Xh8+fFgtW7bMN9ayZUv9/PPPys3NtY1FRUUVOnvDhg3zvQ4ODta5c+fuOE1QUJAkqUGDBvnGMjMzlZ6eXugcAArirDkAdhk4cKDtEMq7775bJMv85JNPlJmZqd/97ne2MavVqry8PB06dEgREREF5rFarbJYLAXGHJ1Gkvz8/Aqd3dPTM99ri8WivLy8O05zK8/txv57PgD3hz03AOzyxBNP6MaNG7px44Z+//vfF8kyFyxYoJdfflmJiYm2n++//17R0dF33HsTHh6u7777Lt/YrfNXbomIiND27dvzje3cuVN169aVu7u73fm8vLwkKd/eHgAlH3tuANjF3d1dhw8ftv33nVy+fLnATfACAwMLXDaemJioffv26eOPPy5wf5s//elPGj16tKZOnVpg+c8//7xmzJih1157TbGxsUpMTLSdKHxrT8jLL7+shx9+WBMnTlTPnj21a9cuvfPOO5o7d65Dnzk0NFQWi0VffPGFnnzySZUpU0b+/v4OLQNA8WPPDQC7BQQEKCAg4K7TbNmyRU2aNMn3M3bs2ALTLViwQBEREbe9cV/Xrl2Vlpamzz//vMB7YWFhWrlypVavXq2GDRtq3rx5tqulvL29Jd28fP2zzz7TsmXLFBkZqbFjx2rChAn5LuW2R/Xq1TV+/HiNHDlSQUFBXNkElBIW6+0ORANAKTJ58mS99957Sk5ONjoKgBKAw1IASp25c+fq4YcfVsWKFbVjxw5Nnz6dvSoAbCg3AEqdn3/+WZMmTVJaWppq1qypl19+WaNGjTI6FoASgsNSAADAVDihGAAAmArlBgAAmArlBgAAmArlBgAAmArlBgAAmArlBgAAmArlBgAAmArlBgAAmArlBgAAmMr/A7gMLytrxJC0AAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAIoCAYAAACcQ2qaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABFEklEQVR4nO3deXhU5cH+8XtIwmQHImYBQogspmFTFoFSgViSV9xAVFQQAWldQCuideMFg0qwqECVilYRQluMla1VKZKWTTaBQGwEgiABIgRZk0A2Jsn8/vBlfo5JINFMzjnM93NdXDjPnDlzz1yP4c5ZbU6n0ykAAACLamR0AAAAgJ+DMgMAACyNMgMAACyNMgMAACyNMgMAACyNMgMAACyNMgMAACyNMgMAACzN1+gAnlZZWamjR48qJCRENpvN6DgAAKAWnE6nzp49qxYtWqhRo4tve7nsy8zRo0cVHR1tdAwAAPAT5ObmqlWrVhdd5rIvMyEhIZK+/zJCQ0MNTmNtDodDq1atUlJSkvz8/IyOAzAnYTrMyfpTWFio6Oho17/jF2NomZk7d67mzp2rgwcPSpI6duyoKVOmaNCgQZKk0aNHKzU11e01vXr10pYtW2r9Hhd2LYWGhlJmfiaHw6HAwECFhobyPylMgTkJs2FO1r/aHCJiaJlp1aqVXnnlFbVr106SlJqaqsGDB2vnzp3q2LGjJOnGG2/U/PnzXa9p3LixIVkBAIA5GVpmbr31VrfH06ZN09y5c7VlyxZXmbHb7YqMjDQiHgAAsADTnJpdUVGhtLQ0FRUVqU+fPq7xtWvXKjw8XB06dNBvf/tbHT9+3MCUAADAbAw/ADgrK0t9+vRRaWmpgoODtWzZMsXHx0uSBg0apLvuuksxMTHKycnR5MmTdcMNNygjI0N2u73a9ZWVlamsrMz1uLCwUNL3+zEdDofnP9Bl7ML3x/cIs2BOwmyYk/WnLt+hzel0Oj2Y5ZLOnz+vw4cPKz8/X0uWLNF7772ndevWuQrND+Xl5SkmJkZpaWkaOnRotetLTk7W1KlTq4wvWrRIgYGB9Z4fAADUv+LiYg0fPlwFBQWXPIHH8DLzYwMHDlTbtm31zjvvVPt8+/bt9Zvf/EbPPPNMtc9Xt2UmOjpaJ0+e5Gymn8nhcCg9PV2JiYkcpQ9TYE7CbJiT9aewsFDNmzevVZkxfDfTjzmdTrcy8kOnTp1Sbm6uoqKiany93W6vdheUn58fE6ue8F3CbJiTMBvm5M9Xl+/P0DLz/PPPa9CgQYqOjtbZs2eVlpamtWvXauXKlTp37pySk5N1xx13KCoqSgcPHtTzzz+v5s2b6/bbbzcyNgAAMBFDy8x3332nkSNHKi8vT02aNFGXLl20cuVKJSYmqqSkRFlZWVq4cKHy8/MVFRWlhIQEffjhh7W6GiAAAPAOhpaZefPm1fhcQECAPvvsswZMAwAArMg015kBAAD4KSgzAADA0igzAADA0kx3ajaAy0NJeYk2HtqtkvMVtX5NWVmpjuQervXylZUV2pu9VweUr0aNfGr9upbRrWW3+9d6+YDGPuobE68A34BavwZAw6HMAPCIjYd264kNoz3/RpHSxvyP6/aa03V/m1laoIFtu9f9hQA8jjIDwCOa+bVSUc5jeiqxg6LDancrkZ+6ZebquKs9tmUm93SxXkv/Ws0SWtV6/QAaFmUGgEfYffxVWdpS/dpcq04tm9T+hdfUflGHw6EVWqGbbrrJY1db/epIgWaUFsnuU/vdUgAaFgcAAwAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS+PUbAAeUeL4/sq/Xx0p8Nh7FJWUafsJKfLQGQUF2D3yHvuPn/PIegHUH8oMAI/45v9KwLNLszz8Tr76y/5tHn4PKcjOj0vArPi/E4BHJHWMlCS1DQ9WgF/tr85bF3vzCvTk4iy9fmdnXR1Vhwvz1VGQ3VexzYM8tn4APw9lBoBHhAU11j3Xtfboe5SXl0uS2l4ZVLerDAO4rHAAMAAAsDTKDAAAsDTKDAAAsDTKDAAAsDTKDAAAsDTKDAAAsDROzQZgGsXFxcrOzq718nvz8lV2bL/2fBWgylNNa/26uLg4BQYG/oSEAMyIMgPANLKzs9W9e/c6v254at2Wz8jIULdu3er8PgDMiTIDwDTi4uKUkZFR6+XPlZTp0zWbdXNCHwXX4d5McXFxPyUeAJOizAAwjcDAwDptMXE4HDpz8rj6XNdDfn5+HkwGwMw4ABgAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFiaoWVm7ty56tKli0JDQxUaGqo+ffroX//6l+t5p9Op5ORktWjRQgEBARowYIB27dplYGIAAGA2hpaZVq1a6ZVXXtH27du1fft23XDDDRo8eLCrsMyYMUMzZ87UnDlztG3bNkVGRioxMVFnz541MjYAADARQ8vMrbfeqptuukkdOnRQhw4dNG3aNAUHB2vLli1yOp2aPXu2Jk2apKFDh6pTp05KTU1VcXGxFi1aZGRsAABgIqY5ZqaiokJpaWkqKipSnz59lJOTo2PHjikpKcm1jN1uV//+/bVp0yYDkwIAADPxNTpAVlaW+vTpo9LSUgUHB2vZsmWKj493FZaIiAi35SMiInTo0KEa11dWVqaysjLX48LCQkmSw+GQw+HwwCfwHhe+P75HmAVzEmbDnKw/dfkODS8zV199tTIzM5Wfn68lS5Zo1KhRWrdunet5m83mtrzT6awy9kPTp0/X1KlTq4yvWrVKgYGB9Rfci6WnpxsdAXDDnITZMCd/vuLi4lova3M6nU4PZqmzgQMHqm3btnrmmWfUtm1b7dixQ9dee63r+cGDB6tp06ZKTU2t9vXVbZmJjo7WyZMnFRoa6vH8lzOHw6H09HQlJibKz8/P6DgAcxKmw5ysP4WFhWrevLkKCgou+e+34VtmfszpdKqsrEyxsbGKjIxUenq6q8ycP39e69at0x/+8IcaX2+322W326uM+/n5MbHqCd8lzIY5CbNhTv58dfn+DC0zzz//vAYNGqTo6GidPXtWaWlpWrt2rVauXCmbzaYJEyYoJSVF7du3V/v27ZWSkqLAwEANHz7cyNgAAMBEDC0z3333nUaOHKm8vDw1adJEXbp00cqVK5WYmChJevrpp1VSUqJx48bpzJkz6tWrl1atWqWQkBAjYwMAABMxtMzMmzfvos/bbDYlJycrOTm5YQIBAADLMc11ZgAAAH4KygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0ygwAALA0X6MDoH6UlJdo46HdKjlfUavly8pKdST3cJ3eo7KyQnuz9+qA8tWokU+tX9cyurXsdv9aLRvQ2Ed9Y+IV4BtQp2wAAO9FmblMbDy0W09sGO35N4qUNuZ/XLfXnK7b4rO0QAPbdq/biwAAXosyc5lo5tdKRTmP6anEDooOC7zk8j9ny8zVcVd7ZMtM7ulivZb+tZoltKpTLgCAd6PMXCbsPv6qLG2pfm2uVaeWTWr3omvq9h4Oh0MrtEI33XST/Pz86pzxUr46UqAZpUWy+9RulxQAABIHAAMAAIujzAAAAEujzAAAAEsztMxMnz5dPXv2VEhIiMLDwzVkyBDt3bvXbZnRo0fLZrO5/endu7dBiQEAgNkYWmbWrVun8ePHa8uWLUpPT1d5ebmSkpJUVFTkttyNN96ovLw8158VK1YYlBgAAJiNoWczrVy50u3x/PnzFR4eroyMDPXr1881brfbFRkZ2dDxAACABZjq1OyCggJJUlhYmNv42rVrFR4erqZNm6p///6aNm2awsPDq11HWVmZysrKXI8LCwslfX9ascPh8FBy45WXl7v+9tTnvLBeT62/IT4DLi+enpNAXTEn609dvkOb0+l0ejBLrTmdTg0ePFhnzpzR559/7hr/8MMPFRwcrJiYGOXk5Gjy5MkqLy9XRkaG7HZ7lfUkJydr6tSpVcYXLVqkwMBLX0zOqnLPSa9l+eqpzuWKDjY6zU9zOXwGAED9KC4u1vDhw1VQUKDQ0NCLLmuaMjN+/Hh9+umn2rBhg1q1qvkKsHl5eYqJiVFaWpqGDh1a5fnqtsxER0fr5MmTl/wyrGzX0UINmbtFyx/prY4tPPM5HQ6H0tPTlZiY6JGL5jXEZ8DlxdNzEqgr5mT9KSwsVPPmzWtVZkyxm+mxxx7TP//5T61fv/6iRUaSoqKiFBMTo3379lX7vN1ur3aLjZ+f32U9sXx9fV1/e/pzeuq7bMjPgMvL5f7/N6yHOfnz1eX7M7TMOJ1OPfbYY1q2bJnWrl2r2NjYS77m1KlTys3NVVRUVAMkBAAAZmfoqdnjx4/XX//6Vy1atEghISE6duyYjh07ppKSEknSuXPn9NRTT2nz5s06ePCg1q5dq1tvvVXNmzfX7bffbmR0AABgEoZumZk7d64kacCAAW7j8+fP1+jRo+Xj46OsrCwtXLhQ+fn5ioqKUkJCgj788EOFhIQYkBgAAJiN4buZLiYgIECfffZZA6UBAABWxL2ZAACApVFmAACApVFmAACApZniOjP4+UocFZKkr44UeOw9ikrKtP2EFHnojIICql7L5+faf/xcva8TAHD5o8xcJr75vyLw7NIsD7+Tr/6yf5tH3yHIzrQEANQe/2pcJpI6fn9X8bbhwQrw8/HIe+zNK9CTi7P0+p2ddXVUE4+8R5DdV7HNgzyybgDA5Ykyc5kIC2qse65r7dH3uHBX67ZXBqlTS8+UGQAA6ooDgAEAgKVRZgAAgKVRZgAAgKVRZgAAgKVRZgAAgKVRZgAAgKVRZgAAgKVRZgAAgKVRZgAAgKVRZgAAgKVRZgAAgKVRZgAAgKVRZgAAgKVRZgAAgKVRZgAAgKVRZgAAgKX5Gh0AxiguLlZ2dnadXrM3L19lx/Zrz1cBqjzVtNavi4uLU2BgYB0TAoDx6vqz8lxJmTZlfaNmzbcrOMBep/fiZ+VPR5nxUtnZ2erevftPeu3w1Lotn5GRoW7duv2k9wIAI/3Un5UzfsJ78bPyp6PMeKm4uDhlZGTU6TXnSsr06ZrNujmhT51+44iLi6trPAAwhbr+rNybl6+JH2Vp5l2ddXVU0zq/F34ayoyXCgwMrPNvAA6HQ2dOHlef63rIz8/PQ8kAwDzq+rOy0aFTsn9eol906qprYq7wYDL8EAcAAwAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAASzO0zEyfPl09e/ZUSEiIwsPDNWTIEO3du9dtGafTqeTkZLVo0UIBAQEaMGCAdu3aZVBiAABgNoaWmXXr1mn8+PHasmWL0tPTVV5erqSkJBUVFbmWmTFjhmbOnKk5c+Zo27ZtioyMVGJios6ePWtgcgAAYBa+Rr75ypUr3R7Pnz9f4eHhysjIUL9+/eR0OjV79mxNmjRJQ4cOlSSlpqYqIiJCixYt0kMPPWREbAAAYCKGlpkfKygokCSFhYVJknJycnTs2DElJSW5lrHb7erfv782bdpUbZkpKytTWVmZ63FhYaEkyeFwyOFweDL+Ze/C98f3CLNgTsJsysvLXX8zL3+eunx/pikzTqdTEydO1K9+9St16tRJknTs2DFJUkREhNuyEREROnToULXrmT59uqZOnVplfNWqVQoMDKzn1N4pPT3d6AiAG+YkzCL3nCT5asuWLTryldFprK24uLjWy5qmzDz66KP673//qw0bNlR5zmazuT12Op1Vxi547rnnNHHiRNfjwsJCRUdHKykpSaGhofUb2ss4HA6lp6crMTFRfn5+RscBmJMwnS8Pn5aytqt3797q2jrM6DiWdmHPSm2Yosw89thj+uc//6n169erVatWrvHIyEhJ32+hiYqKco0fP368ytaaC+x2u+x2e5VxPz8/ftjVE75LmA1zEmbh6+vr+ps5+fPU5fsz9Gwmp9OpRx99VEuXLtXq1asVGxvr9nxsbKwiIyPdNiGfP39e69at0y9/+cuGjgsAAEzI0C0z48eP16JFi/SPf/xDISEhrmNkmjRpooCAANlsNk2YMEEpKSlq37692rdvr5SUFAUGBmr48OFGRgcAACZhaJmZO3euJGnAgAFu4/Pnz9fo0aMlSU8//bRKSko0btw4nTlzRr169dKqVasUEhLSwGkBAIAZGVpmnE7nJZex2WxKTk5WcnKy5wMBAADL4d5MAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0upUZoqLizV+/Hi1bNlS4eHhGj58uE6ePOmpbAAAAJdUpzLzwgsvaMGCBbr55pt17733Kj09XY888oinsgEAAFySb10WXrp0qebNm6d77rlHkjRixAj17dtXFRUV8vHx8UhAAACAi6nTlpnc3Fxdf/31rsfXXXedfH19dfTo0XoPBgAAUBt1KjMVFRVq3Lix25ivr6/Ky8vrNRQAAEBt1Wk3k9Pp1OjRo2W3211jpaWlevjhhxUUFOQaW7p0af0lBAAAuIg6lZn7779fNpvNbey+++6r10AAAAB1UacyM2XKFLVp00aNGnF5GgAAYA51aiXt27d3u67M3Xffre+++67eQwEAANRWncqM0+l0e7xixQoVFRXVayAAAIC6YH8RAACwtDqVGZvNVuUA4B8/BgAAaEg/69Ts6k7Lljg1GwAANJw6lZlRo0a5Pea0bAAAYLQ6lZn58+d7KgcAAMBPwgHAAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0up0BWAAAKwu52SRisrKPbLub04Uuf729fXcP7FBdl/FNg+69IJegjIDAPAaOSeLlPDaWo+/z5OLszz+HmueGkCh+T+Glpn169fr1VdfVUZGhvLy8rRs2TINGTLE9fzo0aOVmprq9ppevXppy5YtDZwUAHA5uLBFZvbd16hdeHD9r7+kTJ+s3axbBvRRUIC93tcvSfuPn9OEDzM9tnXJigwtM0VFReratavGjBmjO+64o9plbrzxRrcbXDZu3Lih4gEALlPtwoPVqWWTel+vw+HQsSulbjHN5OfnV+/rR/UMLTODBg3SoEGDLrqM3W5XZGRkAyUCAABWY/pjZtauXavw8HA1bdpU/fv317Rp0xQeHl7j8mVlZSorK3M9LiwslPR9W3Y4HB7Pezm78P3xPcIsmJOoq/Lyctffnpg3DTEnPf0ZzKIun83UZWbQoEG66667FBMTo5ycHE2ePFk33HCDMjIyZLdXvy9y+vTpmjp1apXxVatWKTAw0NORvUJ6errREQA3zEnUVu45SfLVhg0bdKj+D5lx8eScbKjPYLTi4uJaL2tzOp1OD2apNZvNVuUA4B/Ly8tTTEyM0tLSNHTo0GqXqW7LTHR0tE6ePKnQ0ND6ju1VHA6H0tPTlZiYyL5gmAJzEnW162ihhszdouWP9FbHFvX/b0JDzElPfwazKCwsVPPmzVVQUHDJf79NvWXmx6KiohQTE6N9+/bVuIzdbq92q42fnx8/7OoJ3yXMhjmJ2rpw7RdfX1+PzhlPzsmG+gxGq8tns9QVgE+dOqXc3FxFRUUZHQUAAJiEoVtmzp07p/3797se5+TkKDMzU2FhYQoLC1NycrLuuOMORUVF6eDBg3r++efVvHlz3X777QamBgAAZmJomdm+fbsSEhJcjydOnChJGjVqlObOnausrCwtXLhQ+fn5ioqKUkJCgj788EOFhIQYFRkAAJiMoWVmwIAButjxx5999lkDpgEAAFZkqWNmAAAAfowyAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALM3QMrN+/XrdeuutatGihWw2m5YvX+72vNPpVHJyslq0aKGAgAANGDBAu3btMiYsAAAwJUPLTFFRkbp27ao5c+ZU+/yMGTM0c+ZMzZkzR9u2bVNkZKQSExN19uzZBk4KAADMytfINx80aJAGDRpU7XNOp1OzZ8/WpEmTNHToUElSamqqIiIitGjRIj300EMNGRUAAJiUoWXmYnJycnTs2DElJSW5xux2u/r3769NmzbVWGbKyspUVlbmelxYWChJcjgccjgcng19mbvw/fE9wiyYk6ir8vJy19+emDcNMSc9/RnMoi6fzbRl5tixY5KkiIgIt/GIiAgdOnSoxtdNnz5dU6dOrTK+atUqBQYG1m9IL5Wenm50BMANcxK1lXtOkny1YcMGHQr23Pt4ck421GcwWnFxca2XNW2ZucBms7k9djqdVcZ+6LnnntPEiRNdjwsLCxUdHa2kpCSFhoZ6LKc3cDgcSk9PV2Jiovz8/IyOAzAnUWe7jhbqtawt+tWvfqWOLer/34SGmJOe/gxmcWHPSm2YtsxERkZK+n4LTVRUlGv8+PHjVbbW/JDdbpfdbq8y7ufnxw+7esJ3CbNhTqK2fH19XX97cs54ck421GcwWl0+m2mvMxMbG6vIyEi3TXXnz5/XunXr9Mtf/tLAZAAAwEwM3TJz7tw57d+/3/U4JydHmZmZCgsLU+vWrTVhwgSlpKSoffv2at++vVJSUhQYGKjhw4cbmBoAAJiJoWVm+/btSkhIcD2+cKzLqFGjtGDBAj399NMqKSnRuHHjdObMGfXq1UurVq1SSEiIUZEBAIDJGFpmBgwYIKfTWePzNptNycnJSk5ObrhQAADAUkx7zAwAAEBtUGYAAIClmfbUbAAA6ltZRaka+R9RTuFeNfKv/yvOlZeX62j5Ue05vcd1CnV9yyk8p0b+R1RWUSqpiUfew2ooMwAAr3G06JCCYt/U81s9+z5vrXzLo+sPipWOFl2j7qr5umvehDIDAPAaLYJiVJTzmP549zVqG+6ZLTMbN2xU31/19diWmW+On9PjH2aqRUKMR9ZvRZQZAIDXsPv4q7K0pWJDr1b8FfW/i8bhcCjHN0e/CPuFx67OW1laoMrSE7L7+Htk/VbEAcAAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSTF1mkpOTZbPZ3P5ERkYaHQsAAJiIr9EBLqVjx47697//7Xrs4+NjYBoAAGA2pi8zvr6+bI0BAAA1Mn2Z2bdvn1q0aCG73a5evXopJSVFV111VY3Ll5WVqayszPW4sLBQkuRwOORwODye93J24fvje4RZMCdRV2dLvv/34cvDp1VeXl7v6y8qLdP2E1LzAycU5G+v9/VL0v4TRZKk8vLyy3ru1+Wz2ZxOp9ODWX6Wf/3rXyouLlaHDh303Xff6eWXX1Z2drZ27dqlK664otrXJCcna+rUqVXGFy1apMDAQE9HBgCY2ObvbEo7cHkcrjDpmnKFBxidwnOKi4s1fPhwFRQUKDQ09KLLmrrM/FhRUZHatm2rp59+WhMnTqx2meq2zERHR+vkyZOX/DJwcQ6HQ+np6UpMTJSfn5/RcQDmJOrsdNF5/XvPcV11ZZAC/Oq/1Hx9rEBPL9ujGbf/Qh0im9T7+i8IsvuozRVBHlu/GRQWFqp58+a1KjOm3830Q0FBQercubP27dtX4zJ2u112e9VNe35+fvywqyd8lzAb5iRqK6Kpn0b0ifX4+3SIbKJrYqrfg4Daqcv/06Y+NfvHysrKtGfPHkVFRRkdBQAAmISpy8xTTz2ldevWKScnR1988YXuvPNOFRYWatSoUUZHAwAAJmHq3Uzffvut7r33Xp08eVJXXnmlevfurS1btigmJsboaAAAwCRMXWbS0tKMjgAAAEzO1LuZAAAALoUyAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALI0yAwAALM3X6AAAAJhVcXGxsrOza7383rx8lR3brz1fBajyVNM6vVdcXJwCAwPrmBASZQYAgBplZ2ere/fudX7d8NS6v1dGRoa6detW9xeCMgMAQE3i4uKUkZFR6+XPlZTp0zWbdXNCHwUH2Ov8XvhpKDMAANQgMDCwTltLHA6Hzpw8rj7X9ZCfn58Hk+GHOAAYAABYGmUGAABYmiXKzFtvvaXY2Fj5+/ure/fu+vzzz42OBAAATML0ZebDDz/UhAkTNGnSJO3cuVPXX3+9Bg0apMOHDxsdDQAAmIDpy8zMmTM1duxY/eY3v9EvfvELzZ49W9HR0Zo7d67R0QAAgAmYusycP39eGRkZSkpKchtPSkrSpk2bDEoFAADMxNSnZp88eVIVFRWKiIhwG4+IiNCxY8eqfU1ZWZnKyspcjwsLCyV9f7qcw+HwXFgvcOH743uEWTAnYTbMyfpTl+/Q1GXmApvN5vbY6XRWGbtg+vTpmjp1apXxVatWcZnoepKenm50BMANcxJmw5z8+YqLi2u9rKnLTPPmzeXj41NlK8zx48erbK254LnnntPEiRNdjwsLCxUdHa2kpCSFhoZ6NO/lzuFwKD09XYmJiVwMCqbAnITZMCfrz4U9K7Vh6jLTuHFjde/eXenp6br99ttd4+np6Ro8eHC1r7Hb7bLbq15C2s/Pj4lVT/guYTbMSZgNc/Lnq8v3Z+oyI0kTJ07UyJEj1aNHD/Xp00d//vOfdfjwYT388MNGRwMAACZg+jJz991369SpU3rxxReVl5enTp06acWKFYqJiTE6GgAAMAHTlxlJGjdunMaNG2d0DAAAYEKWKDM/h9PplFS3A4lQPYfDoeLiYhUWFrIvGKbAnITZMCfrz4V/ty/8O34xl32ZOXv2rCQpOjra4CQAAKCuzp49qyZNmlx0GZuzNpXHwiorK3X06FGFhITUeG0a1M6F09xzc3M5zR2mwJyE2TAn64/T6dTZs2fVokULNWp08RsWXPZbZho1aqRWrVoZHeOyEhoayv+kMBXmJMyGOVk/LrVF5gJT35sJAADgUigzAADA0igzqDW73a4XXnih2issA0ZgTsJsmJPGuOwPAAYAAJc3tswAAABLo8wAAABLo8wAAABLo8wAAPATlZSUqLi42PX40KFDmj17tlatWmVgKu9DmcFFff7557rvvvvUp08fHTlyRJL0l7/8RRs2bDA4GbzRd999p5EjR6pFixby9fWVj4+P2x+goQ0ePFgLFy6UJOXn56tXr156/fXXNXjwYM2dO9fgdN7jsr8CMH66JUuWaOTIkRoxYoR27typsrIySd/fJyMlJUUrVqwwOCG8zejRo3X48GFNnjxZUVFR3KIEhtuxY4dmzZolSVq8eLEiIiK0c+dOLVmyRFOmTNEjjzxicELvQJlBjV5++WW9/fbbuv/++5WWluYa/+Uvf6kXX3zRwGTwVhs2bNDnn3+ua665xugogCSpuLhYISEhkqRVq1Zp6NChatSokXr37q1Dhw4ZnM57sJsJNdq7d6/69etXZTw0NFT5+fkNHwheLzo6WlwaC2bSrl07LV++XLm5ufrss8+UlJQkSTp+/Dj3ZmpAlBnUKCoqSvv3768yvmHDBl111VUGJIK3mz17tp599lkdPHjQ6CiAJGnKlCl66qmn1KZNG1133XXq06ePpO+30lx77bUGp/MeXAEYNZoxY4ZSU1P1/vvvKzExUStWrNChQ4f0xBNPaMqUKXr00UeNjggv06xZMxUXF6u8vFyBgYHy8/Nze/706dMGJYM3O3bsmPLy8tS1a1c1avT9NoKtW7cqNDRUcXFxBqfzDpQZXNSkSZM0a9YslZaWSvr+viNPPfWUXnrpJYOTwRulpqZe9PlRo0Y1UBLA3f79+/XNN9+oX79+CggIkNPp5AD1BkSZwSUVFxdr9+7dqqysVHx8vIKDg42OBACmcOrUKQ0bNkxr1qyRzWbTvn37dNVVV2ns2LFq2rSpXn/9daMjegWOmcElHT16VKdOnVLnzp0VHBzMAZgwVEVFhZYsWaKXX35Z06ZN07Jly1RRUWF0LHipJ554Qn5+fjp8+LACAwNd43fffbdWrlxpYDLvwqnZqFFNv3H85je/4TcOGGL//v266aabdOTIEV199dVyOp36+uuvFR0drU8//VRt27Y1OiK8zKpVq/TZZ5+pVatWbuPt27fn1OwGxJYZ1IjfOGA2v/vd79S2bVvl5uZqx44d2rlzpw4fPqzY2Fj97ne/MzoevFBRUZHbz8cLTp48KbvdbkAi70SZQY1WrVqlP/zhD/zGAdNYt26dZsyYobCwMNfYFVdcoVdeeUXr1q0zMBm8Vb9+/Vy3M5Akm82myspKvfrqq0pISDAwmXdhNxNqxG8cMBu73a6zZ89WGT937pwaN25sQCJ4u1dffVUDBgzQ9u3bdf78eT399NPatWuXTp8+rY0bNxodz2uwZQY14jcOmM0tt9yiBx98UF988YWcTqecTqe2bNmihx9+WLfddpvR8eCF4uPj9d///lfXXXedEhMTVVRUpKFDh2rnzp0cw9WAODUbNdq9e7cGDBig7t27a/Xq1brtttvcfuPgf1Q0tPz8fI0aNUoff/yx64J55eXluu2227RgwQI1adLE4IQAjECZwUUdO3ZMc+fOVUZGhiorK9WtWzeNHz9eUVFRRkeDF9u3b5+ys7PldDoVHx+vdu3aGR0JXqpNmzZ64IEHNGbMGEVHRxsdx2tRZlAth8OhpKQkvfPOO+rQoYPRcQDAlN58800tWLBAX375pRISEjR27FjdfvvtHFfYwCgzqNGVV16pTZs2qX379kZHgRebOHGiXnrpJQUFBWnixIkXXXbmzJkNlApw9+WXX+r999/XBx98oPLycg0fPlwPPPCAunXrZnQ0r0CZQY2efPJJ+fn56ZVXXjE6CrxYQkKCli1bpqZNm170wHObzabVq1c3YDKgKofDobfeekvPPPOMHA6HOnXqpMcff1xjxozhXk0eRJlBjR577DEtXLhQ7dq1U48ePRQUFOT2PL8FA8D3HA6Hli1bpvnz5ys9PV29e/fW2LFjdfToUc2ZM0cJCQlatGiR0TEvW1xnBlX4+PgoLy9PX331lWsT6ddff+22DL9hwAwKCwu1evVqxcXFKS4uzug48EI7duzQ/Pnz9cEHH8jHx0cjR47UrFmz3OZjUlKS+vXrZ2DKyx9lBlVc2Fi3Zs0ag5MA7oYNG6Z+/frp0UcfVUlJiXr06KGDBw/K6XQqLS1Nd9xxh9ER4WV69uypxMREzZ07V0OGDHFdMuCH4uPjdc899xiQzntQZgBYxvr16zVp0iRJ0rJly+R0OpWfn6/U1FS9/PLLlBk0uAMHDigmJuaiywQFBWn+/PkNlMg7UWZQrc8+++ySFyDjiqtoaAUFBa77Mq1cuVJ33HGHAgMDdfPNN+v3v/+9wengjS5VZNAwKDOo1qhRoy76vM1mU0VFRQOlAb4XHR2tzZs3KywsTCtXrlRaWpok6cyZM/L39zc4HbxRRUWFZs2apb///e86fPiwzp8/7/b86dOnDUrmXbg3E6p17NgxVVZW1viHIgMjTJgwQSNGjFCrVq3UokULDRgwQNL3u586d+5sbDh4palTp2rmzJkaNmyYCgoKNHHiRA0dOlSNGjVScnKy0fG8Bqdmo4oLZzOFh4cbHQWoYvv27crNzVViYqKCg4MlSZ9++qmaNm2qvn37GpwO3qZt27Z64403dPPNNyskJESZmZmusS1btnA6dgOhzKCKRo0a6dixY5QZmF5FRYWysrIUExOjZs2aGR0HXigoKEh79uxR69atFRUVpU8//VTdunXTgQMHdO2116qgoMDoiF6B3UyoYtSoUQoICDA6BlDFhAkTNG/ePEnfF5n+/furW7duio6O1tq1a40NB6/UqlUr5eXlSZLatWunVatWSZK2bdvG/ZkaEGUGVcyfP18hISFGxwCqWLx4sbp27SpJ+vjjj5WTk6Ps7GxNmDDBdco20JBuv/12/ec//5EkPf7445o8ebLat2+v+++/Xw888IDB6bwHu5kAWIa/v7/279+vVq1a6cEHH1RgYKBmz56tnJwcde3aVYWFhUZHhJfbsmWLNm3apHbt2nH5igbEqdkALCMiIkK7d+9WVFSUVq5cqbfeekuSVFxcLB8fH4PTAVLv3r3Vu3dvo2N4HcoMAMsYM2aMhg0bpqioKNlsNiUmJkqSvvjiC+7NBEOcOnVKV1xxhSQpNzdX7777rkpKSnTbbbfp+uuvNzid92A3EwBLWbx4sXJzc3XXXXepVatWkqTU1FQ1bdpUgwcPNjgdvEVWVpZuvfVW5ebmqn379kpLS9ONN96ooqIiNWrUSEVFRVq8eLGGDBlidFSvQJlBjYqKivTKK6/oP//5j44fP67Kykq35w8cOGBQMkAqLS3lqr8wzKBBg+Tr66tnnnlGf/3rX/XJJ58oKSlJ7733niTpscceU0ZGhrZs2WJwUu9AmUGN7r33Xq1bt04jR450bdb/occff9ygZPBWFRUVSklJ0dtvv63vvvtOX3/9ta666ipNnjxZbdq00dixY42OCC/RvHlzrV69Wl26dNG5c+cUGhqqrVu3qkePHpKk7Oxs9e7dW/n5+cYG9RIcM4Ma/etf/9Knn37KVVVhGtOmTVNqaqpmzJih3/72t67xzp07a9asWZQZNJjTp08rMjJSkhQcHKygoCDXTVAlqVmzZjp79qxR8bwO15lBjZo1a+b2PydgtIULF+rPf/6zRowY4Xb2UpcuXZSdnW1gMnijH2+t/vFjNBy2zKBGL730kqZMmaLU1FQFBgYaHQfQkSNH1K5duyrjlZWVcjgcBiSCNxs9erTrKr+lpaV6+OGHFRQUJEkqKyszMprXocygRq+//rq++eYbRUREqE2bNvLz83N7fseOHQYlg7fq2LGjPv/8c8XExLiNf/TRR7r22msNSgVvNGrUKLfH9913X5Vl7r///oaK4/UoM6gRpxTCbF544QWNHDlSR44cUWVlpZYuXaq9e/dq4cKF+uSTT4yOBy8yf/58oyPgBzibCYClfPbZZ0pJSVFGRoYqKyvVrVs3TZkyRUlJSUZHA2AQygwuKSMjQ3v27JHNZlN8fDyb82GI8vJyTZs2TQ888ICio6ONjgPARCgzqNHx48d1zz33aO3atWratKmcTqcKCgqUkJCgtLQ0XXnllUZHhJcJDg7WV199pTZt2hgdBYCJcGo2avTYY4+psLBQu3bt0unTp3XmzBl99dVXKiws1O9+9zuj48ELDRw4UGvXrjU6BgCTYcsMatSkSRP9+9//Vs+ePd3Gt27dqqSkJK5siQb3zjvvKDk5WSNGjFD37t1dp8FecNtttxmUDICROJsJNaqsrKxyOrYk+fn5VblPE9AQHnnkEUnSzJkzqzxns9lUUVHR0JEA/eUvf9Hbb7+tnJwcbd68WTExMZo9e7ZiY2O5+WkDYTcTanTDDTfo8ccf19GjR11jR44c0RNPPKFf//rXBiaDt6qsrKzxD0UGRpg7d64mTpyom266Sfn5+a552LRpU82ePdvYcF6EMoMazZkzR2fPnlWbNm3Utm1btWvXTrGxsTp79qzefPNNo+MBgOHefPNNvfvuu5o0aZLbLTZ69OihrKwsA5N5F3YzoUbR0dHasWOH0tPTlZ2dLafTqfj4eA0cONDoaPBSb7zxRrXjNptN/v7+ateunfr16+f2jwrgSTk5OdVersJut6uoqMiARN6JMoNLSkxMVGJiotExAM2aNUsnTpxQcXGxmjVrJqfTqfz8fAUGBio4OFjHjx/XVVddpTVr1nAtGjSI2NhYZWZmVrnFxr/+9S/Fx8cblMr7UGbg5o033tCDDz4of3//Gn8LvoDTs9HQUlJS9Oc//1nvvfee2rZtK0nav3+/HnroIT344IPq27ev7rnnHj3xxBNavHixwWnhDX7/+99r/PjxKi0tldPp1NatW/XBBx9o+vTpeu+994yO5zU4NRtuYmNjtX37dl1xxRWKjY2tcTmbzaYDBw40YDJAatu2rZYsWaJrrrnGbXznzp264447dODAAW3atEl33HGH8vLyjAkJr/Puu+/q5ZdfVm5uriSpZcuWSk5O1tixYw1O5j0oMwAsIzAwUOvXr1ePHj3cxrdt26b+/furuLhYBw8eVKdOnXTu3DmDUsJbnTx5UpWVlQoPDzc6itfhbCbUWkVFhTIzM3XmzBmjo8BLJSQk6KGHHtLOnTtdYzt37tQjjzyiG264QZKUlZV10a2KQH2aOnWqvvnmG0lS8+bNKTIGocygRhMmTNC8efMkfV9k+vXrp27duik6OppLysMQ8+bNU1hYmLp37y673S673a4ePXooLCzMNVeDg4P1+uuvG5wU3mLJkiXq0KGDevfurTlz5ujEiRNGR/JK7GZCjVq1aqXly5erR48eWr58ucaPH681a9Zo4cKFWrNmjTZu3Gh0RHip7Oxsff3113I6nYqLi9PVV19tdCR4sV27dulvf/ub0tLS9O2332rgwIG67777NGTIEAUGBhodzytQZlAjf39/7d+/X61atdKDDz6owMBAzZ49Wzk5OeratasKCwuNjggvdf78eeXk5Kht27by9eWkTJjHxo0btWjRIn300UcqLS3l52QDYTcTahQREaHdu3eroqJCK1eudF0sr7i4mIuSwRDFxcUaO3asAgMD1bFjRx0+fFjS95cJeOWVVwxOB0hBQUEKCAhQ48aN5XA4jI7jNSgzqNGYMWM0bNgwderUSTabzXXhvC+++EJxcXEGp4M3eu655/Tll19q7dq18vf3d40PHDhQH374oYHJ4M1ycnI0bdo0xcfHq0ePHtqxY4eSk5N17Ngxo6N5DbbPokbJycnq1KmTcnNzddddd8lut0uSfHx89OyzzxqcDt5o+fLl+vDDD9W7d2/ZbDbXeHx8vOuMEqAh9enTR1u3blXnzp01ZswYDR8+XC1btjQ6ltehzOCi7rzzzipjo0aNMiAJIJ04caLaU1+Liorcyg3QUBISEvTee++pY8eORkfxapQZuOF2BjCznj176tNPP9Vjjz0mSa4C8+6776pPnz5GRoOXSklJMToCxNlM+BFuZwAz27Rpk2688UaNGDFCCxYs0EMPPaRdu3Zp8+bNWrdunbp37250RHiBiRMn6qWXXlJQUJAmTpx40WVnzpzZQKm8G1tm4CYnJ6fa/wbM4Je//KU2btyo1157TW3bttWqVavUrVs3bd68WZ07dzY6HrzEzp07XWcq/fBq1D/Grs+Gw5YZAJeFxYsXV3uMF4DLH6dmo0Z33nlntdfuePXVV3XXXXcZkAjerLy8XLt27dLXX3/tNv6Pf/xDXbt21YgRIwxKBsBobJlBja688kqtXr26yub7rKwsDRw4UN99951ByeBtdu/erVtuuUWHDh2SJA0ePFhz587VsGHD9OWXX+o3v/mNHn/8cUVHRxucFN5o27Zt+uijj3T48GGdP3/e7bmlS5calMq7sGUGNTp37pwaN25cZdzPz49LdKNBPfvss4qNjdU//vEPDRs2TMuXL9f111+vX//618rNzdVrr71GkYEh0tLS1LdvX+3evVvLli2Tw+HQ7t27tXr1ajVp0sToeF6DMoMaderUqdqrqqalpSk+Pt6ARPBWW7du1auvvqpbbrlFc+fOlST9/ve/15QpUxQSEmJwOnizlJQUzZo1S5988okaN26sP/7xj9qzZ4+GDRum1q1bGx3Pa3A2E2o0efJk3XHHHfrmm290ww03SJL+85//6IMPPtBHH31kcDp4k+PHj7uuqtq0aVMFBgaqf//+BqcCpG+++UY333yzJMlut7su4PjEE0/ohhtu0NSpUw1O6B3YMoMa3XbbbVq+fLn279+vcePG6cknn9S3336rf//73xoyZIjR8eBFbDabGjX6/z+uGjVqJD8/PwMTAd8LCwvT2bNnJUktW7bUV199JUnKz89XcXGxkdG8CgcAAzC9Ro0aqUmTJq7rduTn5ys0NNSt4EjS6dOnjYgHLzZ8+HD16NFDEydO1LRp0/THP/5RgwcPVnp6urp168YBwA2EMoOLys/P1+LFi3XgwAE99dRTCgsL044dOxQREcHN1NBgUlNTa7Uc9w1DQzt9+rRKS0vVokULVVZW6rXXXtOGDRvUrl07TZ48Wc2aNTM6olegzKBG//3vfzVw4EA1adJEBw8e1N69e3XVVVdp8uTJOnTokBYuXGh0RAAAOGYGNZs4caJGjx6tffv2yd/f3zU+aNAgrV+/3sBkAAD8f5zNhBpt27ZN77zzTpXxli1b6tixYwYkAgBzaNSo0SXvvWSz2VReXt5AibwbZQY18vf3r/bieHv37tWVV15pQCIAMIdly5bV+NymTZv05ptviqM4Gg7HzKBGDz74oE6cOKG///3vCgsL03//+1/5+PhoyJAh6tevn2bPnm10RAAwjezsbD333HP6+OOPNWLECL300ktcOK+BcMwMavTaa6/pxIkTCg8PV0lJifr376927dopJCRE06ZNMzoeAJjC0aNH9dvf/lZdunRReXm5MjMzlZqaSpFpQGyZwSWtXr1aO3bsUGVlpbp166aBAwcaHQle6s4771SPHj307LPPuo2/+uqr2rp1K1emRoMqKChQSkqK3nzzTV1zzTX6wx/+oOuvv97oWF6JMgPAMriTO8xixowZ+sMf/qDIyEilpKRo8ODBRkfyapQZVKuyslILFizQ0qVLdfDgQdlsNsXGxurOO+/UyJEjL3kUP+AJAQEByszM1NVXX+02np2drWuvvVYlJSUGJYO3adSokQICAjRw4ED5+PjUuBxXAG4YnM2EKpxOp2677TatWLFCXbt2VefOneV0OrVnzx6NHj1aS5cu1fLly42OCS904U7uU6ZMcRvnTu5oaPfffz+/1JkIZQZVLFiwQOvXr9d//vMfJSQkuD23evVqDRkyRAsXLtT9999vUEJ4K+7kDrNYsGCB0RHwA+xmQhVJSUm64YYbqhxkeUFKSorWrVunzz77rIGTAdKnn36qlJQUZWZmKiAgQF26dNELL7yg/v37Gx0NgEEoM6giMjJSK1eu1DXXXFPt8zt37tSgQYO4CjAAwBS4zgyqOH36tCIiImp8PiIiQmfOnGnARAAA1IxjZlBFRUWFfH1rnho+Pj7cbwQNJiwsTF9//bWaN2+uZs2aXfSgy9OnTzdgMgBmQZlBFU6nU6NHj5bdbq/2+bKysgZOBG82a9YshYSEuP6bM0gA/BjHzKCKMWPG1Gq5+fPnezgJAACXRpkBYBk+Pj7Ky8tTeHi42/ipU6cUHh6uiooKg5IBMBIHAAOwjJp+9yorK1Pjxo0bOA0As+CYGQCm98Ybb0iSbDab3nvvPQUHB7ueq6io0Pr16xUXF2dUPAAGYzcTANOLjY2VJB06dEitWrVyuxdO48aN1aZNG7344ovq1auXUREBGIgyA8AyEhIStHTpUjVr1szoKABMhDIDwLIqKiqUlZWlmJgYCg7gxTgAGIBlTJgwQfPmzZP0fZHp16+funXrpujoaK1du9bYcAAMQ5kBYBkfffSRunbtKkn6+OOPdfDgQWVnZ2vChAmaNGmSwekAGIUyA8AyTp06pcjISEnSihUrdNddd6lDhw4aO3assrKyDE4HwCiUGQCWERERod27d6uiokIrV67UwIEDJUnFxcVuZzgB8C5cZwaAZYwZM0bDhg1TVFSUbDabEhMTJUlffPEF15kBvBhlBoBlJCcnq1OnTsrNzdVdd93luhmqj4+Pnn32WYPTATAKp2YDAABLY8sMAFN744039OCDD8rf3991W4Oa/O53v2ugVADMhC0zAEwtNjZW27dv1xVXXOG6rUF1bDabDhw40IDJAJgFZQYAAFgap2YDAABL45gZAJYxceLEasdtNpv8/f3Vrl07DR48WGFhYQ2cDICR2M0EwDISEhK0Y8cOVVRU6Oqrr5bT6dS+ffvk4+OjuLg47d27VzabTRs2bFB8fLzRcQE0EHYzAbCMwYMHa+DAgTp69KgyMjK0Y8cOHTlyRImJibr33nt15MgR9evXT0888YTRUQE0ILbMALCMli1bKj09vcpWl127dikpKUlHjhzRjh07lJSUpJMnTxqUEkBDY8sMAMsoKCjQ8ePHq4yfOHFChYWFkqSmTZvq/PnzDR0NgIEoMwAsY/DgwXrggQe0bNkyffvttzpy5IiWLVumsWPHasiQIZKkrVu3qkOHDsYGBdCg2M0EwDLOnTunJ554QgsXLlR5ebkkydfXV6NGjdKsWbMUFBSkzMxMSdI111xjXFAADYoyA8Byzp07pwMHDsjpdKpt27YKDg42OhIAA3GdGQCWExwcrLCwMNlsNooMAI6ZAWAdlZWVevHFF9WkSRPFxMSodevWatq0qV566SVVVlYaHQ+AQdgyA8AyJk2apHnz5umVV15R37595XQ6tXHjRiUnJ6u0tFTTpk0zOiIAA3DMDADLaNGihd5++23ddtttbuP/+Mc/NG7cOB05csSgZACMxG4mAJZx+vRpxcXFVRmPi4vT6dOnDUgEwAwoMwAso2vXrpozZ06V8Tlz5qhr164GJAJgBuxmAmAZ69at080336zWrVurT58+stls2rRpk3Jzc7VixQpdf/31RkcEYADKDABLOXr0qP70pz8pOztbTqdT8fHxGjdunFq0aGF0NAAGocwAsLzc3Fy98MILev/9942OAsAAlBkAlvfll1+qW7duqqioMDoKAANwADAAALA0ygwAALA0ygwAALA0bmcAwPSGDh160efz8/MbJggAU6LMADC9Jk2aXPL5+++/v4HSADAbzmYCAACWxjEzAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAEzl4MGDstlsyszMNM17DRgwQBMmTPB4HgA/DWUGgMvo0aNls9n08MMPV3lu3LhxstlsGj16tNvyQ4YMqfP7fPvtt2rcuLHi4uJ+RtqfLzo6Wnl5eerUqZMkae3atbLZbFyED7AYygwAN9HR0UpLS1NJSYlrrLS0VB988IFat25dL++xYMECDRs2TMXFxdq4cWO9rLOuzp8/Lx8fH0VGRsrXl+uHAlZGmQHgplu3bmrdurWWLl3qGlu6dKmio6N17bXX/uz1O51OzZ8/XyNHjtTw4cM1b968S77mn//8p9q3b6+AgAAlJCQoNTW1yhaUJUuWqGPHjrLb7WrTpo1ef/11t3W0adNGL7/8skaPHq0mTZrot7/9rdtupoMHDyohIUGS1KxZsypboSorK/X0008rLCxMkZGRSk5Odlu/zWbTO++8o1tuuUWBgYH6xS9+oc2bN2v//v0aMGCAgoKC1KdPH33zzTc/+bsDUD3KDIAqxowZo/nz57sev//++3rggQfqZd1r1qxRcXGxBg4cqJEjR+rvf/+7zp49W+PyBw8e1J133qkhQ4YoMzNTDz30kCZNmuS2TEZGhoYNG6Z77rlHWVlZSk5O1uTJk7VgwQK35V599VV16tRJGRkZmjx5sttz0dHRWrJkiSRp7969ysvL0x//+EfX86mpqQoKCtIXX3yhGTNm6MUXX1R6errbOl566SXdf//9yszMVFxcnIYPH66HHnpIzz33nLZv3y5JevTRR+v8nQG4BCcA/J9Ro0Y5Bw8e7Dxx4oTTbrc7c3JynAcPHnT6+/s7T5w44Rw8eLBz1KhRVZavi+HDhzsnTJjgety1a1fnu+++63qck5PjlOTcuXOn0+l0Op955hlnp06d3NYxadIkpyTnmTNnXOtMTEx0W+b3v/+9Mz4+3vU4JibGOWTIELdlfvxea9ascVvvBf3793f+6le/chvr2bOn85lnnnE9luT83//9X9fjzZs3OyU5582b5xr74IMPnP7+/tV9LQB+BrbMAKiiefPmuvnmm5Wamqr58+fr5ptvVvPmzX/2evPz87V06VLdd999rrH77rtP77//fo2v2bt3r3r27Ok2dt1117k93rNnj/r27es21rdvX+3bt08VFRWusR49evzk7F26dHF7HBUVpePHj9e4TEREhCSpc+fObmOlpaUqLCz8yTkAVMVRbwCq9cADD7h2ifzpT3+ql3UuWrRIpaWl6tWrl2vM6XSqsrJSu3fvVnx8fJXXOJ1O2Wy2KmN1XUaSgoKCfnJ2Pz8/t8c2m02VlZU1LnMhT3VjP34dgJ+HLTMAqnXjjTfq/PnzOn/+vP7nf/6nXtY5b948Pfnkk8rMzHT9+fLLL5WQkFDj1pm4uDht27bNbezC8ScXxMfHa8OGDW5jmzZtUocOHeTj41PrfI0bN5Ykt605AMyPLTMAquXj46M9e/a4/rsmBQUFVS46FxYWVuU07szMTO3YsUN/+9vfqlxf5t5779WkSZM0ffr0Kut/6KGHNHPmTD3zzDMaO3asMjMzXQf2XtjS8eSTT6pnz5566aWXdPfdd2vz5s2aM2eO3nrrrTp95piYGNlsNn3yySe66aabFBAQoODg4DqtA0DDY8sMgBqFhoYqNDT0osusXbtW1157rdufKVOmVFlu3rx5io+Pr/ZCeUOGDNHp06f18ccfV3kuNjZWixcv1tKlS9WlSxfNnTvXdTaT3W6X9P3p5H//+9+VlpamTp06acqUKXrxxRfdTq2ujZYtW2rq1Kl69tlnFRERwZlHgEXYnNXtWAYAE5s2bZrefvtt5ebmGh0FgAmwmwmA6b311lvq2bOnrrjiCm3cuFGvvvoqW00AuFBmAJjevn379PLLL+v06dNq3bq1nnzyST333HNGxwJgEuxmAgAAlsYBwAAAwNIoMwAAwNIoMwAAwNIoMwAAwNIoMwAAwNIoMwAAwNIoMwAAwNIoMwAAwNIoMwAAwNL+HzmeEYo37QxOAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAIoCAYAAACcQ2qaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABCC0lEQVR4nO3deXxNdwL38e/N4mYhCBVCkKJNI0SDljFV6UhmVItpS1tqn1aHLqTt4DGU2kpbtEx1U2Jm0NbWhVGZ2morEjGKWIPUUktISCRukvv80cd9JhMhqSTnHPfzfr289P7uOfd+c/uTfHNWm9PpdAoAAMCiPIwOAAAAcCsoMwAAwNIoMwAAwNIoMwAAwNIoMwAAwNIoMwAAwNIoMwAAwNIoMwAAwNK8jA5Q3goKCnTy5ElVqVJFNpvN6DgAAKAEnE6nLl26pODgYHl43Hjby21fZk6ePKmQkBCjYwAAgF8hLS1N9erVu+Eyt32ZqVKliqRfPoyAgACD01ibw+HQ6tWrFRsbK29vb6PjAMxJmA5zsuxkZmYqJCTE9XP8Rm77MnNt11JAQABl5hY5HA75+fkpICCAf6QwBeYkzIY5WfZKcogIBwADAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLu+3vmg0AwK+VnZ2tlJSUEi9/+UquNu8+rOo1d6iyr71U7xUWFiY/P7/SRoQoMwAAFCslJUUtW7Ys9XpTf8V7JSYmKioq6lesCcoMAADFCAsLU2JiYomX33/qouK+2K1p3Zvp7jrVSv1e+HUoMwAAFMPPz69UW0s8jp2X/fsruiciUi0a1CjHZPhvHAAMAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAszdAys2HDBj366KMKDg6WzWbT8uXLi1120KBBstlsmjFjRoXlAwAA5mdomcnKylJkZKRmzZp1w+WWL1+uH374QcHBwRWUDAAAWIWXkW/eqVMnderU6YbLnDhxQi+88IK+/fZbde7cuYKSAQAAqzC0zNxMQUGBevfurddee01NmzYt0Tq5ubnKzc11Pc7MzJQkORwOORyOcsnpLq59fnyOMAvmJMwmLy/P9Tfz8taU5vMzdZmZMmWKvLy89NJLL5V4ncmTJ2vcuHFFxlevXi0/P7+yjOe2EhISjI4AFMKchFmkXZYkL23dulUnfjQ6jbVlZ2eXeFnTlpnExES9++67SkpKks1mK/F6I0eOVFxcnOtxZmamQkJCFBsbq4CAgPKI6jYcDocSEhIUExMjb29vo+MAzEmYzq7j6dLuHWrTpo0i6wcaHcfSru1ZKQnTlpnvv/9eZ86cUf369V1j+fn5euWVVzRjxgwdPXr0uuvZ7XbZ7fYi497e3nyzKyN8ljAb5iTMwsvLy/U3c/LWlObzM22Z6d27tzp27Fho7Pe//7169+6t/v37G5QKAACYjaFl5vLlyzp06JDrcWpqqpKTkxUYGKj69eurRo0ahZb39vZW7dq1dffdd1d0VAAAYFKGlpkdO3YoOjra9fjasS59+/bVvHnzDEoFAACsxNAy06FDBzmdzhIvX9xxMgAAwH1xbyYAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBplBkAAGBphpaZDRs26NFHH1VwcLBsNpuWL1/ues7hcGj48OFq1qyZ/P39FRwcrD59+ujkyZPGBQYAAKZjaJnJyspSZGSkZs2aVeS57OxsJSUlafTo0UpKStLSpUt14MABdenSxYCkAADArLyMfPNOnTqpU6dO132uatWqSkhIKDQ2c+ZM3XfffTp+/Ljq169fEREBAIDJGVpmSisjI0M2m03VqlUrdpnc3Fzl5ua6HmdmZkr6ZbeVw+Eo74i3tWufH58jzII5iV/j6PksZeXml8trHzidUejv8uJv91TDGv7l+h5GK82/a8uUmZycHI0YMUI9e/ZUQEBAsctNnjxZ48aNKzK+evVq+fn5lWdEt/G/W8wAozEnUVJnrkgTk8v/R99flu0r9/cY1SJPtXzL/W0Mk52dXeJlLVFmHA6HnnrqKRUUFOj999+/4bIjR45UXFyc63FmZqZCQkIUGxt7wxKEm3M4HEpISFBMTIy8vb2NjgMwJ1Fqe05mSslb9fYTzdT4jrLfspGVk6tV32/XHx5oLX8fe5m/viQdOpulVxfvVuu2v1XT4Nv359q1PSslYfoy43A41KNHD6WmpmrNmjU3LSR2u112e9EJ5O3tzTe7MsJnCbNhTqKkvLx++bEXVqeqIupWLfPXdzgcOpci3XfnHeU2J699DV5eXrf1vC/N12bqMnOtyBw8eFBr165VjRo1jI4EAABMxtAyc/nyZR06dMj1ODU1VcnJyQoMDFRwcLCeeOIJJSUl6ZtvvlF+fr5Onz4tSQoMDFSlSpWMig0AAEzE0DKzY8cORUdHux5fO9alb9++Gjt2rL766itJUosWLQqtt3btWnXo0KGiYgIAABMztMx06NBBTqez2Odv9BwAAIDEvZkAAIDFUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClUWYAAIClGVpmNmzYoEcffVTBwcGy2Wxavnx5oeedTqfGjh2r4OBg+fr6qkOHDtqzZ48xYQEAgCkZWmaysrIUGRmpWbNmXff5qVOnatq0aZo1a5a2b9+u2rVrKyYmRpcuXargpAAAwKy8jHzzTp06qVOnTtd9zul0asaMGRo1apQee+wxSVJ8fLyCgoK0YMECDRo0qCKjAgAAkzLtMTOpqak6ffq0YmNjXWN2u10PPvigNm/ebGAyAABgJoZumbmR06dPS5KCgoIKjQcFBenYsWPFrpebm6vc3FzX48zMTEmSw+GQw+Eoh6Tu49rnx+cIs2BOorTy8vJcf5fHvKmIOVneX4NZlOZrM22ZucZmsxV67HQ6i4z9t8mTJ2vcuHFFxlevXi0/P78yz+eOEhISjI4AFMKcREmlXZYkL23cuFHHKpff+5TnnKyor8Fo2dnZJV7WtGWmdu3akn7ZQlOnTh3X+JkzZ4psrflvI0eOVFxcnOtxZmamQkJCFBsbq4CAgPIL7AYcDocSEhIUExMjb29vo+MAzEmU2p6TmXp791b99re/VdPgsv+ZUBFzsry/BrO4tmelJExbZkJDQ1W7dm0lJCTo3nvvlSRdvXpV69ev15QpU4pdz263y263Fxn39vbmm10Z4bOE2TAnUVJeXl6uv8tzzpTnnKyor8FopfnaDC0zly9f1qFDh1yPU1NTlZycrMDAQNWvX19Dhw7VpEmT1KRJEzVp0kSTJk2Sn5+fevbsaWBqAABgJoaWmR07dig6Otr1+Nruob59+2revHn6y1/+oitXrmjw4MG6cOGC7r//fq1evVpVqlQxKjIAADAZQ8tMhw4d5HQ6i33eZrNp7NixGjt2bMWFAgAAlmLa68wAAACUBGUGAABYGmUGAABYGmUGAABYGmUGAABYGmUGAABYGmUGAABYGmUGAABYGmUGAABYGmUGAABYGmUGAABYGmUGAABYGmUGAABYGmUGAABYGmUGAABYmpfRAQAAqCi5+Tny8Dmh1Mz98vCpXOavn5eXp5N5J7UvfZ+8vMrnR2xq5mV5+JxQbn6OpKrl8h5WQ5kBALiNk1nH5B86U/9nW/m+z/ur3i/X1/cPlU5mtVBLBZXr+1gFZQYA4DaC/RsoK/VFvftkCzWqVT5bZjZt3KR2v21XbltmDp+5rJc/S1ZwdINyeX0roswAANyG3dNHBTl1FRpwt8JrlP0uGofDoVSvVN0TeI+8vb3L/PUlqSAnQwU5Z2X39CmX17ciDgAGAACWRpkBAACWRpkBAACWRpkBAACWRpkBAACWRpkBAACWRpkBAACWRpkBAACWRpkBAACWRpkBAACWRpkBAACWRpkBAACWRpkBAACWRpkBAACWRpkBAACWZuoyk5eXp7/+9a8KDQ2Vr6+v7rzzTr3xxhsqKCgwOhoAADAJL6MD3MiUKVP0wQcfKD4+Xk2bNtWOHTvUv39/Va1aVS+//LLR8QAAgAmYusxs2bJFXbt2VefOnSVJDRs21MKFC7Vjxw6DkwEAALMw9W6m3/72t/ruu+904MABSdKuXbu0ceNGPfzwwwYnAwAAZmHqLTPDhw9XRkaGwsLC5Onpqfz8fE2cOFFPP/10sevk5uYqNzfX9TgzM1OS5HA45HA4yj3z7eza58fnCLNgTqK08vLyXH+Xx7ypiDlZ3l+DWZTmazN1mfnss8/0j3/8QwsWLFDTpk2VnJysoUOHKjg4WH379r3uOpMnT9a4ceOKjK9evVp+fn7lHdktJCQkGB0BKIQ5iZJKuyxJXtq4caOOVS6/9ynPOVlRX4PRsrOzS7yszel0Ossxyy0JCQnRiBEjNGTIENfYhAkT9I9//EMpKSnXXed6W2ZCQkJ07tw5BQQElHvm25nD4VBCQoJiYmLk7e1tdByAOYlS23MyU91mb9XyP7dR0+Cy/5lQEXOyvL8Gs8jMzFTNmjWVkZFx05/fpt4yk52dLQ+Pwof1eHp63vDUbLvdLrvdXmTc29ubb3ZlhM8SZsOcREl5eXm5/i7POVOec7KivgajleZrM3WZefTRRzVx4kTVr19fTZs21c6dOzVt2jQNGDDA6GgAAMAkTF1mZs6cqdGjR2vw4ME6c+aMgoODNWjQII0ZM8boaAAAwCRMXWaqVKmiGTNmaMaMGUZHAQAAJlWqMuPh4SGbzXbDZWw2m+u0MQAAgPJWqjKzbNmyYp/bvHmzZs6cKROfHAUAAG5DpSozXbt2LTKWkpKikSNH6uuvv1avXr00fvz4MgsHAABwM7/6dgYnT57Us88+q+bNmysvL0/JycmKj49X/fr1yzIfAADADZW6zGRkZGj48OFq3Lix9uzZo++++05ff/21IiIiyiMfAADADZVqN9PUqVM1ZcoU1a5dWwsXLrzubicAAICKVKoyM2LECPn6+qpx48aKj49XfHz8dZdbunRpmYQDAAC4mVKVmT59+tz01GwAAICKVKoyM2bMGDVs2LDI/ZIAAACMUqpW0qRJE507d871+Mknn9TPP/9c5qEAAABKqlRl5n8viLdy5UplZWWVaSAAAIDSYH8RAACwtFKVGZvNVuQAYA4IBgAARirVAcBOp1P9+vWT3W6XJOXk5Oj555+Xv79/oeU4NRsAAFSUUpWZvn37Fnr8zDPPlGkYAACA0ipVmZk7d2555QAAoNxdceRLkn48kVEur591JVc7zkq1j12Qv6+9XN7j0JnL5fK6VlaqMgMAgJUd/n9FYMTS3eX4Ll76+6Ht5fj6v/C38yP8Gj4JAIDbiG1aW5LUqFZl+Xp7lvnr7z+VoVcW79Y7TzTT3XWqlvnrX+Nv91JoTf+bL+gmKDMAALcR6F9JT91Xv9xePy8vT5LU6A5/RdQtvzKDwrjODAAAsDTKDAAAsDTKDAAAsDTKDAAAsDTKDAAAsDTKDAAAsDTKDAAAsDTKDAAAsDTKDAAAsDTKDAAAsDTKDAAAsDTKDAAAsDTKDAAAsDTKDAAAsDTKDAAAsDTTl5kTJ07omWeeUY0aNeTn56cWLVooMTHR6FgAAMAkvIwOcCMXLlxQu3btFB0drX/961+qVauWDh8+rGrVqhkdDQAAmISpy8yUKVMUEhKiuXPnusYaNmxoXCAAAGA6pi4zX331lX7/+9+re/fuWr9+verWravBgwfr2WefLXad3Nxc5ebmuh5nZmZKkhwOhxwOR7lnvp1d+/z4HGEWzEmYTV5enutv5uWtKc3nZ3M6nc5yzHJLfHx8JElxcXHq3r27tm3bpqFDh+rDDz9Unz59rrvO2LFjNW7cuCLjCxYskJ+fX7nmBQC4t7TL0tu7vfRqszyFVDY6jbVlZ2erZ8+eysjIUEBAwA2XNXWZqVSpklq1aqXNmze7xl566SVt375dW7Zsue4619syExISonPnzt30w8CNORwOJSQkKCYmRt7e3kbHAZiTMJ1dx9P1xMc7tPjZVoqsH2h0HEvLzMxUzZo1S1RmTL2bqU6dOgoPDy80ds8992jJkiXFrmO322W324uMe3t7882ujPBZwmyYkzALLy8v19/MyVtTms/P1Kdmt2vXTvv37y80duDAATVo0MCgRAAAwGxMXWaGDRumrVu3atKkSTp06JAWLFigjz76SEOGDDE6GgAAMAlTl5nWrVtr2bJlWrhwoSIiIjR+/HjNmDFDvXr1MjoaAAAwCVMfMyNJjzzyiB555BGjYwAAAJMy9ZYZAACAm6HMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS/MyOgAAAGaVnZ2tlJSUEi+//9RF5Z4+pH0/+qrgfLVSvVdYWJj8/PxKmRASZQYAgGKlpKSoZcuWpV6vZ3zp3ysxMVFRUVGlXxGUGQAAihMWFqbExMQSL3/5Sq5WrN2iztFtVdnXXur3wq9DmQEAoBh+fn6l2lricDh04dwZtb2vlby9vcsxGf4bBwADAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLo8wAAABLs1SZmTx5smw2m4YOHWp0FAAAYBKWKTPbt2/XRx99pObNmxsdBQAAmIglyszly5fVq1cvffzxx6pevbrRcQAAgIl4GR2gJIYMGaLOnTurY8eOmjBhwg2Xzc3NVW5urutxZmamJMnhcMjhcJRrztvdtc+PzxFmwZyE2TAny05pPkPTl5lFixYpKSlJ27dvL9HykydP1rhx44qMr169Wn5+fmUdzy0lJCQYHQEohDkJs2FO3rrs7OwSL2tzOp3OcsxyS9LS0tSqVSutXr1akZGRkqQOHTqoRYsWmjFjxnXXud6WmZCQEJ07d04BAQEVEfu25XA4lJCQoJiYGHl7exsdB2BOwnSYk2UnMzNTNWvWVEZGxk1/fpt6y0xiYqLOnDmjli1busby8/O1YcMGzZo1S7m5ufL09Cy0jt1ul91uL/Ja3t7eTKwywmcJs2FOwmyYk7euNJ+fqcvM7373O+3evbvQWP/+/RUWFqbhw4cXKTIAAMD9mLrMVKlSRREREYXG/P39VaNGjSLjAADAPVni1GwAAIDimHrLzPWsW7fO6AgAAMBE2DIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAsjTIDAAAszcvoACgbV/KuaNOxvbpyNb9Ey+fm5uhE2vFSvUdBQb72p+zXEV2Uh4dniderG1JfdrtPiZb1reSpdg3C5evlW6psAAD3RZm5TWw6tlfDNvYr/zeqLW26+HXp1kkv3eLTNU8dG7Us3UoAALdFmblNVPeup6zUF/VqzF0KCfS76fK3smXm7rC7y2XLTFp6tt5OOKDq0fVKlQsA4N4oM7cJu6ePCnLqqn3DexVRt2rJVmpRuvdwOBxaqZV6+OGH5e3tXeqMN/PjiQxNzcmS3bNku6QAAJA4ABgAAFgcZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFgaZQYAAFiaqcvM5MmT1bp1a1WpUkW1atVSt27dtH//fqNjAQAAEzF1mVm/fr2GDBmirVu3KiEhQXl5eYqNjVVWVpbR0QAAgEl4GR3gRlatWlXo8dy5c1WrVi0lJiaqffv2BqUCAABmYuoy878yMjIkSYGBgcUuk5ubq9zcXNfjzMxMSZLD4ZDD4SjfgAa6dOWXr3nX8XTl5eWVy3tk5eRqx1mp5pGz8vexl/nrHzr7yxa3vLy82/r/FcrOtXnCfIFZMCfLTmk+Q5vT6XSWY5Yy43Q61bVrV124cEHff/99scuNHTtW48aNKzK+YMEC+fn5lWdEQ2352aZFRzyNjlEmRrXIUy1fo1MAAIyUnZ2tnj17KiMjQwEBATdc1jJlZsiQIVqxYoU2btyoevXqFbvc9bbMhISE6Ny5czf9MKwsPeuq/r3vjO68w1++3uVTag6cztBflu3T1D/eo7tqVy2X9/C3e6phDf9yeW3cfhwOhxISEhQTEyNvb2+j4wDMyTKUmZmpmjVrlqjMWGI304svvqivvvpKGzZsuGGRkSS73S67veguEG9v79t6YgVV81avtqEV8l531a6qFg1qVMh7ASVxu//7hvUwJ29daT4/U5cZp9OpF198UcuWLdO6desUGloxP6wBAIB1mLrMDBkyRAsWLNCXX36pKlWq6PTp05KkqlWryteXgyoAAIDJrzMze/ZsZWRkqEOHDqpTp47rz2effWZ0NAAAYBKm3jJjkWOTAQCAgUy9ZQYAAOBmKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSKDMAAMDSvIwOAGNkZ2crJSWlVOvsP3VRuacPad+Pvio4X63E64WFhcnPz6+UCeGOSjsvL1/J1ebdh1W95g5V9rWXeD3mJHB7ocy4qZSUFLVs2fJXrdszvnTLJyYmKioq6le9F9zLr52XU0u5PHMSuL1QZtxUWFiYEhMTS7XO5Su5WrF2izpHty31b8FASZR2Xu4/dVFxX+zWtO7NdHedaqV6HwC3D8qMm/Lz8yv1b6YOh0MXzp1R2/taydvbu5ySwZ2Vdl56HDsv+/dXdE9EpFo0qFGOyQCYGQcAAwAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS6PMAAAAS+OieQDKTeq5LGXl5pXb6x8+m+X628ur/L6d+du9FFrTv9xeH8CtocwAKBep57IU/fa6CnmvVxbvLvf3WPtqBwoNYFKUGQDl4toWmRlPtlDjWpXL5z2u5OqbdVv0SIe28i/F/cJK49CZyxr6WXK5bmECcGsoMwDKVeNalRVRt2q5vLbD4dDpO6SoBtW5XxjgxjgAGAAAWBplBgAAWBplBgAAWJolysz777+v0NBQ+fj4qGXLlvr++++NjgQAAEzC9GXms88+09ChQzVq1Cjt3LlTDzzwgDp16qTjx48bHQ0AAJiA6cvMtGnTNHDgQP3pT3/SPffcoxkzZigkJESzZ882OhoAADABU5eZq1evKjExUbGxsYXGY2NjtXnzZoNSAQAAMzH1dWbOnTun/Px8BQUFFRoPCgrS6dOnr7tObm6ucnNzXY8zMzMl/XI9CofDUX5h3cC1z4/PESVx7nKGPHxO6NsD23XoQsmunJuTm6NTP5V8F3J+XoEOHTqog3np8vQq+e9mderVl4/dp0TLpl24Ig+fE8rKvSyHw6/E7wH3xPfJslOaz9DUZeYam81W6LHT6Swyds3kyZM1bty4IuOrV6+Wnx/fiMpCQkKC0RFgAavOnJR/6Puad1xSeR7iVlvadLmU61ws3eL+odK/t+br9O7gUr4R3BXfJ29ddnZ2iZc1dZmpWbOmPD09i2yFOXPmTJGtNdeMHDlScXFxrseZmZkKCQlRbGysAgICyjXv7c7hcCghIUExMTFcbRU31SIjU4t3N1Hd6j7y8fIs0Tq/dstM48ZNym3LjCT5VPLQb0Luka+Xb4nXgXvi+2TZubZnpSRMXWYqVaqkli1bKiEhQX/84x9d4wkJCeratet117Hb7bLbi96jxdvbm4lVRvgsURINatbQK9EdS79iy5Iv6nA4tHLlSj388MPMSZgK3ydvXWk+P1OXGUmKi4tT79691apVK7Vt21YfffSRjh8/rueff97oaAAAwARMX2aefPJJnT9/Xm+88YZOnTqliIgIrVy5Ug0aNDA6GgAAMAHTlxlJGjx4sAYPHmx0DAAAYEKmvs4MAADAzVBmAACApVFmAACApVFmAACApVFmAACApVFmAACApVFmAACApVFmAACApVFmAACApVFmAACApVnidga3wul0SirdrcRxfQ6HQ9nZ2crMzORusDAF5iTMhjlZdq793L72c/xGbvsyc+nSJUlSSEiIwUkAAEBpXbp0SVWrVr3hMjZnSSqPhRUUFOjkyZOqUqWKbDab0XEsLTMzUyEhIUpLS1NAQIDRcQDmJEyHOVl2nE6nLl26pODgYHl43PiomNt+y4yHh4fq1atndIzbSkBAAP9IYSrMSZgNc7Js3GyLzDUcAAwAACyNMgMAACyNMoMSs9vtev3112W3242OAkhiTsJ8mJPGuO0PAAYAALc3tswAAABLo8wAAABLo8wAAABLo8wAAPArXblyRdnZ2a7Hx44d04wZM7R69WoDU7kfygxu6Pvvv9czzzyjtm3b6sSJE5Kkv//979q4caPByeCOfv75Z/Xu3VvBwcHy8vKSp6dnoT9ARevatavmz58vSbp48aLuv/9+vfPOO+ratatmz55tcDr3cdtfARi/3pIlS9S7d2/16tVLO3fuVG5urqRf7pMxadIkrVy50uCEcDf9+vXT8ePHNXr0aNWpU4dblMBwSUlJmj59uiRp8eLFCgoK0s6dO7VkyRKNGTNGf/7znw1O6B4oMyjWhAkT9MEHH6hPnz5atGiRa/w3v/mN3njjDQOTwV1t3LhR33//vVq0aGF0FECSlJ2drSpVqkiSVq9erccee0weHh5q06aNjh07ZnA698FuJhRr//79at++fZHxgIAAXbx4seIDwe2FhISIS2PBTBo3bqzly5crLS1N3377rWJjYyVJZ86c4d5MFYgyg2LVqVNHhw4dKjK+ceNG3XnnnQYkgrubMWOGRowYoaNHjxodBZAkjRkzRq+++qoaNmyo++67T23btpX0y1aae++91+B07oMrAKNYU6dOVXx8vD799FPFxMRo5cqVOnbsmIYNG6YxY8bohRdeMDoi3Ez16tWVnZ2tvLw8+fn5ydvbu9Dz6enpBiWDOzt9+rROnTqlyMhIeXj8so1g27ZtCggIUFhYmMHp3ANlBjc0atQoTZ8+XTk5OZJ+ue/Iq6++qvHjxxucDO4oPj7+hs/37du3gpIAhR06dEiHDx9W+/bt5evrK6fTyQHqFYgyg5vKzs7W3r17VVBQoPDwcFWuXNnoSABgCufPn1ePHj20du1a2Ww2HTx4UHfeeacGDhyoatWq6Z133jE6olvgmBnc1MmTJ3X+/Hk1a9ZMlStX5gBMGCo/P19LlizRhAkTNHHiRC1btkz5+flGx4KbGjZsmLy9vXX8+HH5+fm5xp988kmtWrXKwGTuhVOzUazifuP405/+xG8cMMShQ4f08MMP68SJE7r77rvldDp14MABhYSEaMWKFWrUqJHREeFmVq9erW+//Vb16tUrNN6kSRNOza5AbJlBsfiNA2bz0ksvqVGjRkpLS1NSUpJ27typ48ePKzQ0VC+99JLR8eCGsrKyCn1/vObcuXOy2+0GJHJPlBkUa/Xq1ZoyZQq/ccA01q9fr6lTpyowMNA1VqNGDb355ptav369gcngrtq3b++6nYEk2Ww2FRQU6K233lJ0dLSBydwLu5lQLH7jgNnY7XZdunSpyPjly5dVqVIlAxLB3b311lvq0KGDduzYoatXr+ovf/mL9uzZo/T0dG3atMnoeG6DLTMoFr9xwGweeeQRPffcc/rhhx/kdDrldDq1detWPf/88+rSpYvR8eCGwsPD9Z///Ef33XefYmJilJWVpccee0w7d+7kGK4KxKnZKNbevXvVoUMHtWzZUmvWrFGXLl0K/cbBP1RUtIsXL6pv3776+uuvXRfMy8vLU5cuXTRv3jxVrVrV4IQAjECZwQ2dPn1as2fPVmJiogoKChQVFaUhQ4aoTp06RkeDGzt48KBSUlLkdDoVHh6uxo0bGx0Jbqphw4YaMGCA+vfvr5CQEKPjuC3KDK7L4XAoNjZWH374oe666y6j4wCAKc2cOVPz5s3Trl27FB0drYEDB+qPf/wjxxVWMMoMinXHHXdo8+bNatKkidFR4Mbi4uI0fvx4+fv7Ky4u7obLTps2rYJSAYXt2rVLn376qRYuXKi8vDz17NlTAwYMUFRUlNHR3AJlBsV65ZVX5O3trTfffNPoKHBj0dHRWrZsmapVq3bDA89tNpvWrFlTgcmAohwOh95//30NHz5cDodDERERevnll9W/f3/u1VSOKDMo1osvvqj58+ercePGatWqlfz9/Qs9z2/BAPALh8OhZcuWae7cuUpISFCbNm00cOBAnTx5UrNmzVJ0dLQWLFhgdMzbFteZQRGenp46deqUfvzxR9cm0gMHDhRaht8wYAaZmZlas2aNwsLCFBYWZnQcuKGkpCTNnTtXCxculKenp3r37q3p06cXmo+xsbFq3769gSlvf5QZFHFtY93atWsNTgIU1qNHD7Vv314vvPCCrly5olatWuno0aNyOp1atGiRHn/8caMjws20bt1aMTExmj17trp16+a6ZMB/Cw8P11NPPWVAOvdBmQFgGRs2bNCoUaMkScuWLZPT6dTFixcVHx+vCRMmUGZQ4Y4cOaIGDRrccBl/f3/NnTu3ghK5J8oMruvbb7+96QXIuOIqKlpGRobrvkyrVq3S448/Lj8/P3Xu3Fmvvfaawengjm5WZFAxKDO4rr59+97weZvNpvz8/ApKA/wiJCREW7ZsUWBgoFatWqVFixZJki5cuCAfHx+D08Ed5efna/r06fr88891/PhxXb16tdDz6enpBiVzL9ybCdd1+vRpFRQUFPuHIgMjDB06VL169VK9evUUHBysDh06SPpl91OzZs2MDQe3NG7cOE2bNk09evRQRkaG4uLi9Nhjj8nDw0Njx441Op7b4NRsFHHtbKZatWoZHQUoYseOHUpLS1NMTIwqV64sSVqxYoWqVaumdu3aGZwO7qZRo0Z677331LlzZ1WpUkXJycmusa1bt3I6dgWhzKAIDw8PnT59mjID08vPz9fu3bvVoEEDVa9e3eg4cEP+/v7at2+f6tevrzp16mjFihWKiorSkSNHdO+99yojI8PoiG6B3Uwoom/fvvL19TU6BlDE0KFDNWfOHEm/FJkHH3xQUVFRCgkJ0bp164wNB7dUr149nTp1SpLUuHFjrV69WpK0fft27s9UgSgzKGLu3LmqUqWK0TGAIhYvXqzIyEhJ0tdff63U1FSlpKRo6NChrlO2gYr0xz/+Ud99950k6eWXX9bo0aPVpEkT9enTRwMGDDA4nftgNxMAy/Dx8dGhQ4dUr149Pffcc/Lz89OMGTOUmpqqyMhIZWZmGh0Rbm7r1q3avHmzGjduzOUrKhCnZgOwjKCgIO3du1d16tTRqlWr9P7770uSsrOz5enpaXA6QGrTpo3atGljdAy3Q5kBYBn9+/dXjx49VKdOHdlsNsXExEiSfvjhB+7NBEOcP39eNWrUkCSlpaXp448/1pUrV9SlSxc98MADBqdzH+xmAmApixcvVlpamrp376569epJkuLj41WtWjV17drV4HRwF7t379ajjz6qtLQ0NWnSRIsWLdIf/vAHZWVlycPDQ1lZWVq8eLG6detmdFS3QJlBsbKysvTmm2/qu+++05kzZ1RQUFDo+SNHjhiUDJBycnK46i8M06lTJ3l5eWn48OH6xz/+oW+++UaxsbH65JNPJEkvvviiEhMTtXXrVoOTugfKDIr19NNPa/369erdu7drs/5/e/nllw1KBneVn5+vSZMm6YMPPtDPP/+sAwcO6M4779To0aPVsGFDDRw40OiIcBM1a9bUmjVr1Lx5c12+fFkBAQHatm2bWrVqJUlKSUlRmzZtdPHiRWODugmOmUGx/vWvf2nFihVcVRWmMXHiRMXHx2vq1Kl69tlnXePNmjXT9OnTKTOoMOnp6apdu7YkqXLlyvL393fdBFWSqlevrkuXLhkVz+1wnRkUq3r16oX+cQJGmz9/vj766CP16tWr0NlLzZs3V0pKioHJ4I7+d2v1/z5GxWHLDIo1fvx4jRkzRvHx8fLz8zM6DqATJ06ocePGRcYLCgrkcDgMSAR31q9fP9dVfnNycvT888/L399fkpSbm2tkNLdDmUGx3nnnHR0+fFhBQUFq2LChvL29Cz2flJRkUDK4q6ZNm+r7779XgwYNCo1/8cUXuvfeew1KBXfUt2/fQo+feeaZIsv06dOnouK4PcoMisUphTCb119/Xb1799aJEydUUFCgpUuXav/+/Zo/f76++eYbo+PBjcydO9foCPgvnM0EwFK+/fZbTZo0SYmJiSooKFBUVJTGjBmj2NhYo6MBMAhlBjeVmJioffv2yWazKTw8nM35MEReXp4mTpyoAQMGKCQkxOg4AEyEMoNinTlzRk899ZTWrVunatWqyel0KiMjQ9HR0Vq0aJHuuOMOoyPCzVSuXFk//vijGjZsaHQUACbCqdko1osvvqjMzEzt2bNH6enpunDhgn788UdlZmbqpZdeMjoe3FDHjh21bt06o2MAMBm2zKBYVatW1b///W+1bt260Pi2bdsUGxvLlS1R4T788EONHTtWvXr1UsuWLV2nwV7TpUsXg5IBMBJnM6FYBQUFRU7HliRvb+8i92kCKsKf//xnSdK0adOKPGez2ZSfn1/RkQD9/e9/1wcffKDU1FRt2bJFDRo00IwZMxQaGsrNTysIu5lQrIceekgvv/yyTp486Ro7ceKEhg0bpt/97ncGJoO7KigoKPYPRQZGmD17tuLi4vTwww/r4sWLrnlYrVo1zZgxw9hwboQyg2LNmjVLly5dUsOGDdWoUSM1btxYoaGhunTpkmbOnGl0PAAw3MyZM/Xxxx9r1KhRhW6x0apVK+3evdvAZO6F3UwoVkhIiJKSkpSQkKCUlBQ5nU6Fh4erY8eORkeDm3rvvfeuO26z2eTj46PGjRurffv2hX6oAOUpNTX1upersNvtysrKMiCRe6LM4KZiYmIUExNjdAxA06dP19mzZ5Wdna3q1avL6XTq4sWL8vPzU+XKlXXmzBndeeedWrt2LdeiQYUIDQ1VcnJykVts/Otf/1J4eLhBqdwPZQaFvPfee3ruuefk4+NT7G/B13B6NirapEmT9NFHH+mTTz5Ro0aNJEmHDh3SoEGD9Nxzz6ldu3Z66qmnNGzYMC1evNjgtHAHr732moYMGaKcnBw5nU5t27ZNCxcu1OTJk/XJJ58YHc9tcGo2CgkNDdWOHTtUo0YNhYaGFruczWbTkSNHKjAZIDVq1EhLlixRixYtCo3v3LlTjz/+uI4cOaLNmzfr8ccf16lTp4wJCbfz8ccfa8KECUpLS5Mk1a1bV2PHjtXAgQMNTuY+KDMALMPPz08bNmxQq1atCo1v375dDz74oLKzs3X06FFFRETo8uXLBqWEuzp37pwKCgpUq1Yto6O4Hc5mQonl5+crOTlZFy5cMDoK3FR0dLQGDRqknTt3usZ27typP//5z3rooYckSbt3777hVkWgLI0bN06HDx+WJNWsWZMiYxDKDIo1dOhQzZkzR9IvRaZ9+/aKiopSSEgIl5SHIebMmaPAwEC1bNlSdrtddrtdrVq1UmBgoGuuVq5cWe+8847BSeEulixZorvuuktt2rTRrFmzdPbsWaMjuSV2M6FY9erV0/Lly9WqVSstX75cQ4YM0dq1azV//nytXbtWmzZtMjoi3FRKSooOHDggp9OpsLAw3X333UZHghvbs2eP/vnPf2rRokX66aef1LFjRz3zzDPq1q2b/Pz8jI7nFigzKJaPj48OHTqkevXq6bnnnpOfn59mzJih1NRURUZGKjMz0+iIcFNXr15VamqqGjVqJC8vTsqEeWzatEkLFizQF198oZycHL5PVhB2M6FYQUFB2rt3r/Lz87Vq1SrXxfKys7O5KBkMkZ2drYEDB8rPz09NmzbV8ePHJf1ymYA333zT4HSA5O/vL19fX1WqVEkOh8PoOG6DMoNi9e/fXz169FBERIRsNpvrwnk//PCDwsLCDE4HdzRy5Ejt2rVL69atk4+Pj2u8Y8eO+uyzzwxMBneWmpqqiRMnKjw8XK1atVJSUpLGjh2r06dPGx3NbbB9FsUaO3asIiIilJaWpu7du8tut0uSPD09NWLECIPTwR0tX75cn332mdq0aSObzeYaDw8Pd51RAlSktm3batu2bWrWrJn69++vnj17qm7dukbHcjuUGdzQE088UWSsb9++BiQBpLNnz1731NesrKxC5QaoKNHR0frkk0/UtGlTo6O4NcoMCuF2BjCz1q1ba8WKFXrxxRclyVVgPv74Y7Vt29bIaHBTkyZNMjoCxNlM+B/czgBmtnnzZv3hD39Qr169NG/ePA0aNEh79uzRli1btH79erVs2dLoiHADcXFxGj9+vPz9/RUXF3fDZadNm1ZBqdwbW2ZQSGpq6nX/GzCD3/zmN9q0aZPefvttNWrUSKtXr1ZUVJS2bNmiZs2aGR0PbmLnzp2uM5X++2rU/4tdnxWHLTMAbguLFy++7jFeAG5/nJqNYj3xxBPXvXbHW2+9pe7duxuQCO4sLy9Pe/bs0YEDBwqNf/nll4qMjFSvXr0MSgbAaGyZQbHuuOMOrVmzpsjm+927d6tjx476+eefDUoGd7N371498sgjOnbsmCSpa9eumj17tnr06KFdu3bpT3/6k15++WWFhIQYnBTuaPv27friiy90/PhxXb16tdBzS5cuNSiVe2HLDIp1+fJlVapUqci4t7c3l+hGhRoxYoRCQ0P15ZdfqkePHlq+fLkeeOAB/e53v1NaWprefvttigwMsWjRIrVr10579+7VsmXL5HA4tHfvXq1Zs0ZVq1Y1Op7boMygWBEREde9quqiRYsUHh5uQCK4q23btumtt97SI488otmzZ0uSXnvtNY0ZM0ZVqlQxOB3c2aRJkzR9+nR98803qlSpkt59913t27dPPXr0UP369Y2O5zY4mwnFGj16tB5//HEdPnxYDz30kCTpu+++08KFC/XFF18YnA7u5MyZM66rqlarVk1+fn568MEHDU4FSIcPH1bnzp0lSXa73XUBx2HDhumhhx7SuHHjDE7oHtgyg2J16dJFy5cv16FDhzR48GC98sor+umnn/Tvf/9b3bp1Mzoe3IjNZpOHx///duXh4SFvb28DEwG/CAwM1KVLlyRJdevW1Y8//ihJunjxorKzs42M5lY4ABiA6Xl4eKhq1aqu63ZcvHhRAQEBhQqOJKWnpxsRD26sZ8+eatWqleLi4jRx4kS9++676tq1qxISEhQVFcUBwBWEMoMbunjxohYvXqwjR47o1VdfVWBgoJKSkhQUFMTN1FBh4uPjS7Qc9w1DRUtPT1dOTo6Cg4NVUFCgt99+Wxs3blTjxo01evRoVa9e3eiIboEyg2L95z//UceOHVW1alUdPXpU+/fv15133qnRo0fr2LFjmj9/vtERAQDgmBkULy4uTv369dPBgwfl4+PjGu/UqZM2bNhgYDIAAP4/zmZCsbZv364PP/ywyHjdunV1+vRpAxIBgDl4eHjc9N5LNptNeXl5FZTIvVFmUCwfH5/rXhxv//79uuOOOwxIBADmsGzZsmKf27x5s2bOnCmO4qg4HDODYj333HM6e/asPv/8cwUGBuo///mPPD091a1bN7Vv314zZswwOiIAmEZKSopGjhypr7/+Wr169dL48eO5cF4F4ZgZFOvtt9/W2bNnVatWLV25ckUPPvigGjdurCpVqmjixIlGxwMAUzh58qSeffZZNW/eXHl5eUpOTlZ8fDxFpgKxZQY3tWbNGiUlJamgoEBRUVHq2LGj0ZHgpp544gm1atVKI0aMKDT+1ltvadu2bVyZGhUqIyNDkyZN0syZM9WiRQtNmTJFDzzwgNGx3BJlBoBlcCd3mMXUqVM1ZcoU1a5dW5MmTVLXrl2NjuTWKDO4roKCAs2bN09Lly7V0aNHZbPZFBoaqieeeEK9e/e+6VH8QHnw9fVVcnKy7r777kLjKSkpuvfee3XlyhWDksHdeHh4yNfXVx07dpSnp2exy3EF4IrB2Uwowul0qkuXLlq5cqUiIyPVrFkzOZ1O7du3T/369dPSpUu1fPlyo2PCDV27k/uYMWMKjXMnd1S0Pn368EudiVBmUMS8efO0YcMGfffdd4qOji703Jo1a9StWzfNnz9fffr0MSgh3BV3codZzJs3z+gI+C/sZkIRsbGxeuihh4ocZHnNpEmTtH79en377bcVnAyQVqxYoUmTJik5OVm+vr5q3ry5Xn/9dT344INGRwNgEMoMiqhdu7ZWrVqlFi1aXPf5nTt3qlOnTlwFGABgClxnBkWkp6crKCio2OeDgoJ04cKFCkwEAEDxOGYGReTn58vLq/ip4enpyf1GUGECAwN14MAB1axZU9WrV7/hQZfp6ekVmAyAWVBmUITT6VS/fv1kt9uv+3xubm4FJ4I7mz59uqpUqeL6b84gAfC/OGYGRfTv379Ey82dO7eckwAAcHOUGQCW4enpqVOnTqlWrVqFxs+fP69atWopPz/foGQAjMQBwAAso7jfvXJzc1WpUqUKTgPALDhmBoDpvffee5Ikm82mTz75RJUrV3Y9l5+frw0bNigsLMyoeAAMxm4mAKYXGhoqSTp27Jjq1atX6F44lSpVUsOGDfXGG2/o/vvvNyoiAANRZgBYRnR0tJYuXarq1asbHQWAiVBmAFhWfn6+du/erQYNGlBwADfGAcAALGPo0KGaM2eOpF+KTPv27RUVFaWQkBCtW7fO2HAADEOZAWAZX3zxhSIjIyVJX3/9tY4ePaqUlBQNHTpUo0aNMjgdAKNQZgBYxvnz51W7dm1J0sqVK9W9e3fdddddGjhwoHbv3m1wOgBGocwAsIygoCDt3btX+fn5WrVqlTp27ChJys7OLnSGEwD3wnVmAFhG//791aNHD9WpU0c2m00xMTGSpB9++IHrzABujDIDwDLGjh2riIgIpaWlqXv37q6boXp6emrEiBEGpwNgFE7NBgAAlsaWGQCm9t577+m5556Tj4+P67YGxXnppZcqKBUAM2HLDABTCw0N1Y4dO1SjRg3XbQ2ux2az6ciRIxWYDIBZUGYAAIClcWo2AACwNI6ZAWAZcXFx1x232Wzy8fFR48aN1bVrVwUGBlZwMgBGYjcTAMuIjo5WUlKS8vPzdffdd8vpdOrgwYPy9PRUWFiY9u/fL5vNpo0bNyo8PNzouAAqCLuZAFhG165d1bFjR508eVKJiYlKSkrSiRMnFBMTo6efflonTpxQ+/btNWzYMKOjAqhAbJkBYBl169ZVQkJCka0ue/bsUWxsrE6cOKGkpCTFxsbq3LlzBqUEUNHYMgPAMjIyMnTmzJki42fPnlVmZqYkqVq1arp69WpFRwNgIMoMAMvo2rWrBgwYoGXLlumnn37SiRMntGzZMg0cOFDdunWTJG3btk133XWXsUEBVCh2MwGwjMuXL2vYsGGaP3++8vLyJEleXl7q27evpk+fLn9/fyUnJ0uSWrRoYVxQABWKMgPAci5fvqwjR47I6XSqUaNGqly5stGRABiI68wAsJzKlSsrMDBQNpuNIgOAY2YAWEdBQYHeeOMNVa1aVQ0aNFD9+vVVrVo1jR8/XgUFBUbHA2AQtswAsIxRo0Zpzpw5evPNN9WuXTs5nU5t2rRJY8eOVU5OjiZOnGh0RAAG4JgZAJYRHBysDz74QF26dCk0/uWXX2rw4ME6ceKEQckAGIndTAAsIz09XWFhYUXGw8LClJ6ebkAiAGZAmQFgGZGRkZo1a1aR8VmzZikyMtKARADMgN1MACxj/fr16ty5s+rXr6+2bdvKZrNp8+bNSktL08qVK/XAAw8YHRGAASgzACzl5MmT+tvf/qaUlBQ5nU6Fh4dr8ODBCg4ONjoaAINQZgBYXlpaml5//XV9+umnRkcBYADKDADL27Vrl6KiopSfn290FAAG4ABgAABgaZQZAABgaZQZAABgadzOAIDpPfbYYzd8/uLFixUTBIApUWYAmF7VqlVv+nyfPn0qKA0As+FsJgAAYGkcMwMAACyNMgMAACyNMgMAACyNMgMAACyNMgMAACyNMgPAVI4ePSqbzabk5GTTvFeHDh00dOjQcs8D4NehzABw6devn2w2m55//vkizw0ePFg2m039+vUrtHy3bt1K/T4//fSTKlWqpLCwsFtIe+tCQkJ06tQpRURESJLWrVsnm83GRfgAi6HMACgkJCREixYt0pUrV1xjOTk5WrhwoerXr18m7zFv3jz16NFD2dnZ2rRpU5m8ZmldvXpVnp6eql27try8uH4oYGWUGQCFREVFqX79+lq6dKlrbOnSpQoJCdG99957y6/vdDo1d+5c9e7dWz179tScOXNuus5XX32lJk2ayNfXV9HR0YqPjy+yBWXJkiVq2rSp7Ha7GjZsqHfeeafQazRs2FATJkxQv379VLVqVT377LOFdjMdPXpU0dHRkqTq1asX2QpVUFCgv/zlLwoMDFTt2rU1duzYQq9vs9n04Ycf6pFHHpGfn5/uuecebdmyRYcOHVKHDh3k7++vtm3b6vDhw7/6swNwfZQZAEX0799fc+fOdT3+9NNPNWDAgDJ57bVr1yo7O1sdO3ZU79699fnnn+vSpUvFLn/06FE98cQT6tatm5KTkzVo0CCNGjWq0DKJiYnq0aOHnnrqKe3evVtjx47V6NGjNW/evELLvfXWW4qIiFBiYqJGjx5d6LmQkBAtWbJEkrR//36dOnVK7777ruv5+Ph4+fv764cfftDUqVP1xhtvKCEhodBrjB8/Xn369FFycrLCwsLUs2dPDRo0SCNHjtSOHTskSS+88EKpPzMAN+EEgP+nb9++zq5duzrPnj3rtNvtztTUVOfRo0edPj4+zrNnzzq7du3q7Nu3b5HlS6Nnz57OoUOHuh5HRkY6P/74Y9fj1NRUpyTnzp07nU6n0zl8+HBnREREodcYNWqUU5LzwoULrteMiYkptMxrr73mDA8Pdz1u0KCBs1u3boWW+d/3Wrt2baHXvebBBx90/va3vy001rp1a+fw4cNdjyU5//rXv7oeb9myxSnJOWfOHNfYwoULnT4+Ptf7WADcArbMACiiZs2a6ty5s+Lj4zV37lx17txZNWvWvOXXvXjxopYuXapnnnnGNfbMM8/o008/LXad/fv3q3Xr1oXG7rvvvkKP9+3bp3bt2hUaa9eunQ4ePKj8/HzXWKtWrX519ubNmxd6XKdOHZ05c6bYZYKCgiRJzZo1KzSWk5OjzMzMX50DQFEc9QbgugYMGODaJfK3v/2tTF5zwYIFysnJ0f333+8aczqdKigo0N69exUeHl5kHafTKZvNVmSstMtIkr+//6/O7u3tXeixzWZTQUFBsctcy3O9sf9dD8CtYcsMgOv6wx/+oKtXr+rq1av6/e9/XyavOWfOHL3yyitKTk52/dm1a5eio6OL3ToTFham7du3Fxq7dvzJNeHh4dq4cWOhsc2bN+uuu+6Sp6dnifNVqlRJkgptzQFgfmyZAXBdnp6e2rdvn+u/i5ORkVHkonOBgYFFTuNOTk5WUlKS/vnPfxa5vszTTz+tUaNGafLkyUVef9CgQZo2bZqGDx+ugQMHKjk52XVg77UtHa+88opat26t8ePH68knn9SWLVs0a9Ysvf/++6X6mhs0aCCbzaZvvvlGDz/8sHx9fVW5cuVSvQaAiseWGQDFCggIUEBAwA2XWbdune69995Cf8aMGVNkuTlz5ig8PPy6F8rr1q2b0tPT9fXXXxd5LjQ0VIsXL9bSpUvVvHlzzZ4923U2k91ul/TL6eSff/65Fi1apIiICI0ZM0ZvvPFGoVOrS6Ju3boaN26cRowYoaCgIM48AizC5rzejmUAMLGJEyfqgw8+UFpamtFRAJgAu5kAmN7777+v1q1bq0aNGtq0aZPeeusttpoAcKHMADC9gwcPasKECUpPT1f9+vX1yiuvaOTIkUbHAmAS7GYCAACWxgHAAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0igzAADA0v4vYuq3blvuXfAAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAIoCAYAAACcQ2qaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA8SElEQVR4nO3deXiNd+L//9fJIquEUHsQS5uJPWipFjGSmVYH05a29mXKlGkt3fRnaBRRtGhrSqtKdAZtbZ1WR2Vqq60IMVpiDVLLoCFBiJPk/P7o1/lMGiEhyX3ezvNxXS4973Of+7xyrrvyOu97szkcDocAAAAM5WF1AAAAgDtBmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGM3L6gAlLTc3VydPnlTZsmVls9msjgMAAArB4XDo4sWLqlatmjw8bj73cteXmZMnTyo0NNTqGAAA4DakpqaqRo0aN13G0jKzYcMGTZ06VYmJiTp16pSWL1+url27Op93OBwaN26cPvzwQ50/f14PPPCA/va3v6lBgwaFfo+yZctK+uXDCAoKKu4fwa3Y7XatXr1aMTEx8vb2tjoOwDYJl8M2WXwyMjIUGhrq/D1+M5aWmcuXL6tJkybq37+/nnjiiXzPT5kyRdOmTdP8+fN17733asKECYqOjtb+/fsL9cNJcu5aCgoKoszcIbvdLn9/fwUFBfE/KVwC2yRcDdtk8SvMISKWlplHHnlEjzzyyA2fczgcmjFjhkaPHq3HH39ckhQfH6/KlStr4cKFGjx4cGlGBQAALsplz2ZKSUnR6dOnFRMT4xzz8fFRu3bttHnzZguTAQAAV+KyBwCfPn1aklS5cuU845UrV9axY8cKfF1WVpaysrKcjzMyMiT9MvVnt9tLIKn7uP758TnCVbBNwtWwTRafonyGLltmrvv1vjKHw3HT/WeTJk3SuHHj8o2vXr1a/v7+xZ7PHSUkJFgdAciDbRKuhm3yzmVmZhZ6WZctM1WqVJH0ywxN1apVneNnzpzJN1vzv1577TWNHDnS+fj60dAxMTEcAHyH7Ha7EhISFB0dzYFtcAlsk3A1bJPF5/qelcJw2TITFhamKlWqKCEhQc2aNZMkXbt2TevXr9fkyZMLfJ2Pj498fHzyjXt7e7NhFRM+S7gatkm4GrbJO1eUz8/SMnPp0iUdOnTI+TglJUVJSUkKCQlRzZo1NXz4cMXFxal+/fqqX7++4uLi5O/vrx49eliYGgAAuBJLy8yOHTsUFRXlfHx991Dfvn01f/58vfLKK7py5YqGDBnivGje6tWrC32NGQAAcPeztMy0b99eDoejwOdtNptiY2MVGxtbeqEAAIBRXPY6MwAAAIVBmQEAAEajzAAAAKNRZgAAgNFc9jozAABYLTMzU8nJyYVe/tKVLG3ec1jlK+5QoF/+a57dTHh4OFeqv02UGQAACpCcnKzmzZsX+XVTbuO9EhMTFRkZeRuvBGUGAIAChIeHKzExsdDL7z91QSM/36Np3RrpvqrlivxeuD2UGQAACuDv71+k2RKPYz/L57sr+k3DJmpaq0IJJsP/4gBgAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGo8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGo8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGo8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADCaS5eZ7Oxs/fWvf1VYWJj8/PxUp04dvfHGG8rNzbU6GgAAcBFeVge4mcmTJ2v27NmKj49XgwYNtGPHDvXv31/BwcEaNmyY1fEAAIALcOkys2XLFnXp0kWdOnWSJNWuXVuLFi3Sjh07LE4GAABchUvvZnrooYf07bff6sCBA5Kk3bt3a+PGjXr00UctTgYAAFyFS8/MvPrqq0pPT1d4eLg8PT2Vk5OjiRMn6plnninwNVlZWcrKynI+zsjIkCTZ7XbZ7fYSz3w3u/758TnCVbBNwtVkZ2c7/2a7vDNF+fxcusx8+umn+vvf/66FCxeqQYMGSkpK0vDhw1WtWjX17dv3hq+ZNGmSxo0bl2989erV8vf3L+nIbiEhIcHqCEAebJNwFamXJMlLW7du1YkfrE5jtszMzEIva3M4HI4SzHJHQkNDNWrUKA0dOtQ5NmHCBP39739XcnLyDV9zo5mZ0NBQnTt3TkFBQSWe+W5mt9uVkJCg6OhoeXt7Wx0HYJuEy9l9PE1PztmhJc+2UJOaIVbHMVpGRoYqVqyo9PT0W/7+dumZmczMTHl45D2sx9PT86anZvv4+MjHxyffuLe3N//YFRM+S7gatkm4Ci8vL+ffbJN3piifn0uXmT/84Q+aOHGiatasqQYNGmjXrl2aNm2aBgwYYHU0AADgIly6zLz33nsaM2aMhgwZojNnzqhatWoaPHiwxo4da3U0AADgIly6zJQtW1YzZszQjBkzrI4CAABclEtfZwYAAOBWKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGo8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGo8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgNJcvMydOnFCvXr1UoUIF+fv7q2nTpkpMTLQ6FgAAcBFeVge4mfPnz6tNmzaKiorSv/71L1WqVEmHDx9WuXLlrI4GAABchEuXmcmTJys0NFTz5s1zjtWuXdu6QAAAwOW4dJn55z//qd/97nfq1q2b1q9fr+rVq2vIkCF69tlnC3xNVlaWsrKynI8zMjIkSXa7XXa7vcQz382uf358jnAVbJNwNdnZ2c6/2S7vTFE+P5vD4XCUYJY74uvrK0kaOXKkunXrpm3btmn48OH64IMP1KdPnxu+JjY2VuPGjcs3vnDhQvn7+5doXgCAe0u9JL21x0svNcpWaKDVacyWmZmpHj16KD09XUFBQTdd1qXLTJkyZdSiRQtt3rzZOfbCCy9o+/bt2rJlyw1fc6OZmdDQUJ07d+6WHwZuzm63KyEhQdHR0fL29rY6DsA2idty9OfLupyVUyLrPnA6Xa8s36cpf/yN7q0SXCLvIUkBPp6qXSGgxNbvCjIyMlSxYsVClRmX3s1UtWpVRURE5Bn7zW9+o6VLlxb4Gh8fH/n4+OQb9/b25h+7YsJnCVfDNonCSjl3WdEzNpX4+7yyfF+Jv8fal9orrOLdW2iK8v+0S5eZNm3aaP/+/XnGDhw4oFq1almUCABgsstZvxzTMuOppqpXqfj3A12+kqWv1m3RY+1bK8Av/xfr4nDozCUN/zTJ+bPAxcvMiBEj9OCDDyouLk7du3fXtm3b9OGHH+rDDz+0OhoAwGD1KgWqYfXi3w1kt9t1+h4pslZ5ZgtLkUtfNK9ly5Zavny5Fi1apIYNG2r8+PGaMWOGevbsaXU0AADgIlx6ZkaSHnvsMT322GNWxwAAAC7KpWdmAAAAboUyAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgtDsuM506ddKpU6eKIwsAAECR3XGZ2bBhg65cuVIcWQAAAIqM3UwAAMBoxVJmbDZbcawGAACgyIp8b6awsLA85eXKlStq166dvLz+b1VHjhwpnnQAAAC3UOQyM3/+fOd/OxwOPfroo3rzzTdVvXr14swFAABQKEUuM+3atcvz2NPTU61atVKdOnWKLRQAAEBh3fExMxwvAwAArHTHZcbhcBRHDgAAgNtS5N1Mv3bx4sXiyAEAAHBbuM4MAAAwWrGWmWXLlqlx48bFuUoAAICbKnKZmTNnjrp166YePXro+++/lyStWbNGzZo1U69evdS6detiDwkAAFCQIpWZt956S0OHDlVKSoq++OILdejQQXFxcerevbu6du2q48eP64MPPiiprAAAAPkU6QDguXPnavbs2RowYIDWrVunDh06aM2aNTp06JDKlStXQhEBAAAKVqSZmWPHjqljx46SpPbt28vb21sTJ06kyAAAAMsUqcxcvXpVvr6+zsdlypTRPffcU+yhAAAACqvI15n56KOPFBgYKEnKzs7W/PnzVbFixTzLvPDCC8WTDgAA4BaKVGZq1qypOXPmOB9XqVJFn3zySZ5lbDYbZQYAAJSaIpWZo0eP3vT548ePKzY29g7iAAAAFE2xXjTv/Pnzio+PL85VAgAA3BS3MwAAAEajzAAAAKNRZgAAgNGKdADw448/ftPnL1y4cCdZAAAAiqxIZSY4OPiWz/fp0+eOAgEAABRFkcrMvHnzSioHAADAbeGYGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGo8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaEaVmUmTJslms2n48OFWRwEAAC7CmDKzfft2ffjhh2rcuLHVUQAAgAsxosxcunRJPXv21Jw5c1S+fHmr4wAAABfiZXWAwhg6dKg6deqkjh07asKECTddNisrS1lZWc7HGRkZkiS73S673V6iOe921z8/Pke4CrZJFFV2drbz75LYbkpjmyzpn8FVFOVnc/kys3jxYu3cuVPbt28v1PKTJk3SuHHj8o2vXr1a/v7+xR3PLSUkJFgdAciDbRKFlXpJkry0ceNGHQssufcpyW2ytH4Gq2VmZhZ6WZcuM6mpqRo2bJhWr14tX1/fQr3mtdde08iRI52PMzIyFBoaqpiYGAUFBZVUVLdgt9uVkJCg6OhoeXt7Wx0HYJtEkf14MkNv7dmqhx56SA2qFf/vhNLYJkv6Z3AV1/esFIZLl5nExESdOXNGzZs3d47l5ORow4YNmjlzprKysuTp6ZnnNT4+PvLx8cm3Lm9vb/6xKyZ8lnA1bJMoLC8vL+ffJbnNlOQ2WVo/g9WK8rO5dJn57W9/qz179uQZ69+/v8LDw/Xqq6/mKzIAAMD9uHSZKVu2rBo2bJhnLCAgQBUqVMg3DgAA3JMRp2YDAAAUxKVnZm5k3bp1VkcAAAAuhJkZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGo8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGo8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGo8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNG8rA4AAEBpycq5Kg/fE0rJ2C8P38BiX392drZOZp/UvrR98vIqmV+xKRmX5OF7Qlk5VyUFl8h7mIYyAwBwGycvH1NA2Hv6/7aV7Pu8v+r9El1/QJh08nJTNVflEn0fU1BmAABuo1pALV1OeV7vPNVUdSuVzMzMpo2b1OahNiU2M3P4zCUN+zRJ1aJqlcj6TeTSZWbSpElatmyZkpOT5efnpwcffFCTJ0/WfffdZ3U0AICBfDx9lXu1usKC7lNEheLfRWO325XilaLfhPxG3t7exb5+Scq9mq7cq2fl4+lbIus3kUsfALx+/XoNHTpUW7duVUJCgrKzsxUTE6PLly9bHQ0AALgIl56ZWbVqVZ7H8+bNU6VKlZSYmKi2bdtalAoAALgSly4zv5aeni5JCgkJKXCZrKwsZWVlOR9nZGRI+mXqz263l2zAu9z1z4/PEa6CbRJFlZ2d7fy7JLab0tgmS/pncBVF+dlsDofDUYJZio3D4VCXLl10/vx5fffddwUuFxsbq3HjxuUbX7hwofz9/UsyIgDAxaVekt7a46WXGmUrtPiP/y0Vd8PPUBiZmZnq0aOH0tPTFRQUdNNljSkzQ4cO1cqVK7Vx40bVqFGjwOVuNDMTGhqqc+fO3fLDwM3Z7XYlJCQoOjq6xA5sA4qCbRJF9ePJDHWdtVUrnmulBtWK/3dCaWyTJf0zuIqMjAxVrFixUGXGiN1Mzz//vP75z39qw4YNNy0ykuTj4yMfH598497e3vxjV0z4LOFq2CZRWNdPl/by8irRbaYkt8nS+hmsVpSfzaXLjMPh0PPPP6/ly5dr3bp1CgsLszoSAABwMS5dZoYOHaqFCxfqiy++UNmyZXX69GlJUnBwsPz8/CxOBwAAXIFLX2dm1qxZSk9PV/v27VW1alXnn08//dTqaAAAwEW49MyMIccmAwAAC7n0zAwAAMCtUGYAAIDRKDMAAMBolBkAAGA0ygwAADCaS5/NBABAcbpiz5Ek/XAivUTWf/lKlnaclaocO68Av/xXoy8Oh85cKpH1mowyAwBwG4f/XxEYtWxPCb6Llz45tL0E1/+LAB9+hV/HJwEAcBsxDapIkupWCpSft2exr3//qXS9uGSP3n6yke6rGlzs678uwMdLYRUDSmz9pqHMAADcRkhAGT19f80SW392drYkqe49AWpYveTKDPLiAGAAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDSuAOymMjMzlZycXKTXXLqSpc17Dqt8xR0KLMIN1MLDw+Xv71/UiAAAFAplxk0lJyerefPmt/XaKUVcPjExUZGRkbf1XgAA3Apl5i6Scu6yLmdlF2rZnKCq+vRf64q0/mPnLmnavw9pZMd6qlUxsNCvywmqqh9OpBdqWW6eBgAoKsrMXSL5vz/r0VlLS/x9/Gr7adahE9KhIrxo6/4ivcfXzz2h8MoVihYMAOC2KDN3iYNphxUQ9p7VMYrFwbSmlBkAQKFRZu4S1QJq6XLK83rnqaaqW6nwu4CKIjs7W5s2blKbh9rIy6v4N53DZy5p2KdJqhZVq9jXDQC4e1Fm7hK5ud7KvVpdly9WUW5QcIm8x5UrWTp5vpquXKyigCKczVRYOVcvKffqWfl4+hb7ugHgdhT1zM/9py4o6/Qh7fvBT7k/lyvSe3Hm5+2jzNwlDp+5JEkatWxPCb+Tlz45tL1E3yHAh80SgGu43TM/e8QX/b048/P28VvjLhHToIokqW6lQPl5e95y+StXMpVy6ECR3uN2z2YKq3ev/PwK922Ds5kAuJLw8HAlJiYWevlLV7K0cu0WdYpqXaTrcV1/L9weysxdIiSgjJ6+v2ahl9+587CeeqT9bb3XK0X8xpGYmKiG9fi2AcA8/v7+RZotsdvtOn/ujFrf30Le3t4lmAz/izLjpor6bUO6/W8cfNsAAJQkyoybKuq3DYlvHAAA10SZAeAyinrmCPcLAyBRZgCUkJPp6fo0qWi7Mo8d3KsPJrxc5Pd696OiLT/4r1NVq35EoZevEuyrrg2byc/Lr4jJAJQGygyAEvFpUqI+PjqsaC/yluqNq1cygf7Ht/pAOlq014QEzNfv6t/ezVkBlCzKDIAS8VTT5pLeKdJr7NeydPZkaqGXv2bP0cHjP6l+zRoqU4hLElx3T7VQeZcp/G6pKsG+ahtW+JkcAKWLMgOgRFQLDtaIdh1K9D3sdru+/vprPfrooxyUDrgxD6sDAAAA3AnKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGu+vvmu1wOCRJGRkZFicxn91uV2ZmpjIyMrhDMVwC2yRcDdtk8bn+e/v67/GbuevLzMWLFyVJoaGhFicBAABFdfHiRQUHB990GZujMJXHYLm5uTp58qTKli0rm81mdRyjZWRkKDQ0VKmpqQoKCrI6DsA2CZfDNll8HA6HLl68qGrVqsnD4+ZHxdz1MzMeHh6qUaOG1THuKkFBQfxPCpfCNglXwzZZPG41I3MdBwADAACjUWYAAIDRKDMoNB8fH73++uvy8fGxOgogiW0Srodt0hp3/QHAAADg7sbMDAAAMBplBgAAGI0yAwAAjEaZAQDgNl25ckWZmZnOx8eOHdOMGTO0evVqC1O5H8oMbuq7775Tr1691Lp1a504cUKS9Mknn2jjxo0WJ4M7+u9//6vevXurWrVq8vLykqenZ54/QGnr0qWLFixYIEm6cOGCHnjgAb399tvq0qWLZs2aZXE693HXXwEYt2/p0qXq3bu3evbsqV27dikrK0vSL/fJiIuL09dff21xQribfv366fjx4xozZoyqVq3KLUpguZ07d2r69OmSpCVLlqhy5cratWuXli5dqrFjx+q5556zOKF7oMygQBMmTNDs2bPVp08fLV682Dn+4IMP6o033rAwGdzVxo0b9d1336lp06ZWRwEkSZmZmSpbtqwkafXq1Xr88cfl4eGhVq1a6dixYxancx/sZkKB9u/fr7Zt2+YbDwoK0oULF0o/ENxeaGiouDQWXEm9evW0YsUKpaam6ptvvlFMTIwk6cyZM9ybqRRRZlCgqlWr6tChQ/nGN27cqDp16liQCO5uxowZGjVqlI4ePWp1FECSNHbsWL300kuqXbu27r//frVu3VrSL7M0zZo1szid++AKwCjQlClTFB8fr48//ljR0dH6+uuvdezYMY0YMUJjx47VX/7yF6sjws2UL19emZmZys7Olr+/v7y9vfM8n5aWZlEyuLPTp0/r1KlTatKkiTw8fpkj2LZtm4KCghQeHm5xOvdAmcFNjR49WtOnT9fVq1cl/XLfkZdeeknjx4+3OBncUXx8/E2f79u3byklAfI6dOiQDh8+rLZt28rPz08Oh4MD1EsRZQa3lJmZqb179yo3N1cREREKDAy0OhIAuISff/5Z3bt319q1a2Wz2XTw4EHVqVNHAwcOVLly5fT2229bHdEtcMwMbunkyZP6+eef1ahRIwUGBnIAJiyVk5OjpUuXasKECZo4caKWL1+unJwcq2PBTY0YMULe3t46fvy4/P39neNPPfWUVq1aZWEy98Kp2ShQQd84/vSnP/GNA5Y4dOiQHn30UZ04cUL33XefHA6HDhw4oNDQUK1cuVJ169a1OiLczOrVq/XNN9+oRo0aecbr16/PqdmliJkZFIhvHHA1L7zwgurWravU1FTt3LlTu3bt0vHjxxUWFqYXXnjB6nhwQ5cvX87z7+N1586dk4+PjwWJ3BNlBgVavXq1Jk+ezDcOuIz169drypQpCgkJcY5VqFBBb775ptavX29hMrirtm3bOm9nIEk2m025ubmaOnWqoqKiLEzmXtjNhALxjQOuxsfHRxcvXsw3funSJZUpU8aCRHB3U6dOVfv27bVjxw5du3ZNr7zyin788UelpaVp06ZNVsdzG8zMoEB844CreeyxxzRo0CB9//33cjgccjgc2rp1q/785z+rc+fOVseDG4qIiNB//vMf3X///YqOjtbly5f1+OOPa9euXRzDVYo4NRsF2rt3r9q3b6/mzZtrzZo16ty5c55vHPyPitJ24cIF9e3bV19++aXzgnnZ2dnq3Lmz5s+fr+DgYIsTArACZQY3dfr0ac2aNUuJiYnKzc1VZGSkhg4dqqpVq1odDW7s4MGDSk5OlsPhUEREhOrVq2d1JLip2rVra8CAAerfv79CQ0OtjuO2KDO4IbvdrpiYGH3wwQe69957rY4DAC7pvffe0/z587V7925FRUVp4MCB+uMf/8hxhaWMMoMC3XPPPdq8ebPq169vdRS4sZEjR2r8+PEKCAjQyJEjb7rstGnTSikVkNfu3bv18ccfa9GiRcrOzlaPHj00YMAARUZGWh3NLVBmUKAXX3xR3t7eevPNN62OAjcWFRWl5cuXq1y5cjc98Nxms2nNmjWlmAzIz2636/3339err74qu92uhg0batiwYerfvz/3aipBlBkU6Pnnn9eCBQtUr149tWjRQgEBAXme51swAPzCbrdr+fLlmjdvnhISEtSqVSsNHDhQJ0+e1MyZMxUVFaWFCxdaHfOuxXVmkI+np6dOnTqlH374wTlFeuDAgTzL8A0DriAjI0Nr1qxReHi4wsPDrY4DN7Rz507NmzdPixYtkqenp3r37q3p06fn2R5jYmLUtm1bC1Pe/SgzyOf6ZN3atWstTgLk1b17d7Vt21Z/+ctfdOXKFbVo0UJHjx6Vw+HQ4sWL9cQTT1gdEW6mZcuWio6O1qxZs9S1a1fnJQP+V0REhJ5++mkL0rkPygwAY2zYsEGjR4+WJC1fvlwOh0MXLlxQfHy8JkyYQJlBqTty5Ihq1ap102UCAgI0b968UkrknigzuKFvvvnmlhcg44qrKG3p6enO+zKtWrVKTzzxhPz9/dWpUye9/PLLFqeDO7pVkUHpoMzghvr27XvT5202m3JyckopDfCL0NBQbdmyRSEhIVq1apUWL14sSTp//rx8fX0tTgd3lJOTo+nTp+uzzz7T8ePHde3atTzPp6WlWZTMvXBvJtzQ6dOnlZubW+AfigysMHz4cPXs2VM1atRQtWrV1L59e0m/7H5q1KiRteHglsaNG6dp06ape/fuSk9P18iRI/X444/Lw8NDsbGxVsdzG5yajXyun81UqVIlq6MA+ezYsUOpqamKjo5WYGCgJGnlypUqV66c2rRpY3E6uJu6devq3XffVadOnVS2bFklJSU5x7Zu3crp2KWEMoN8PDw8dPr0acoMXF5OTo727NmjWrVqqXz58lbHgRsKCAjQvn37VLNmTVWtWlUrV65UZGSkjhw5ombNmik9Pd3qiG6B3UzIp2/fvvLz87M6BpDP8OHDNXfuXEm/FJl27dopMjJSoaGhWrdunbXh4JZq1KihU6dOSZLq1aun1atXS5K2b9/O/ZlKEWUG+cybN09ly5a1OgaQz5IlS9SkSRNJ0pdffqmUlBQlJydr+PDhzlO2gdL0xz/+Ud9++60kadiwYRozZozq16+vPn36aMCAARancx/sZgJgDF9fXx06dEg1atTQoEGD5O/vrxkzZiglJUVNmjRRRkaG1RHh5rZu3arNmzerXr16XL6iFHFqNgBjVK5cWXv37lXVqlW1atUqvf/++5KkzMxMeXp6WpwOkFq1aqVWrVpZHcPtUGYAGKN///7q3r27qlatKpvNpujoaEnS999/z72ZYImff/5ZFSpUkCSlpqZqzpw5unLlijp37qyHH37Y4nTug91MAIyyZMkSpaamqlu3bqpRo4YkKT4+XuXKlVOXLl0sTgd3sWfPHv3hD39Qamqq6tevr8WLF+v3v/+9Ll++LA8PD12+fFlLlixR165drY7qFigzKNDly5f15ptv6ttvv9WZM2eUm5ub5/kjR45YlAyQrl69ylV/YZlHHnlEXl5eevXVV/X3v/9dX331lWJiYvTRRx9Jkp5//nklJiZq69atFid1D5QZFOiZZ57R+vXr1bt3b+e0/v8aNmyYRcngrnJychQXF6fZs2frv//9rw4cOKA6depozJgxql27tgYOHGh1RLiJihUras2aNWrcuLEuXbqkoKAgbdu2TS1atJAkJScnq1WrVrpw4YK1Qd0Ex8ygQP/617+0cuVKrqoKlzFx4kTFx8drypQpevbZZ53jjRo10vTp0ykzKDVpaWmqUqWKJCkwMFABAQHOm6BKUvny5XXx4kWr4rkdrjODApUvXz7P/5yA1RYsWKAPP/xQPXv2zHP2UuPGjZWcnGxhMrijX89W//oxSg8zMyjQ+PHjNXbsWMXHx8vf39/qOIBOnDihevXq5RvPzc2V3W63IBHcWb9+/ZxX+b169ar+/Oc/KyAgQJKUlZVlZTS3Q5lBgd5++20dPnxYlStXVu3ateXt7Z3n+Z07d1qUDO6qQYMG+u6771SrVq08459//rmaNWtmUSq4o759++Z53KtXr3zL9OnTp7TiuD3KDArEKYVwNa+//rp69+6tEydOKDc3V8uWLdP+/fu1YMECffXVV1bHgxuZN2+e1RHwPzibCYBRvvnmG8XFxSkxMVG5ubmKjIzU2LFjFRMTY3U0ABahzOCWEhMTtW/fPtlsNkVERDCdD0tkZ2dr4sSJGjBggEJDQ62OA8CFUGZQoDNnzujpp5/WunXrVK5cOTkcDqWnpysqKkqLFy/WPffcY3VEuJnAwED98MMPql27ttVRALgQTs1GgZ5//nllZGToxx9/VFpams6fP68ffvhBGRkZeuGFF6yOBzfUsWNHrVu3zuoYAFwMMzMoUHBwsP7973+rZcuWeca3bdummJgYrmyJUvfBBx8oNjZWPXv2VPPmzZ2nwV7XuXNni5IBsBJnM6FAubm5+U7HliRvb+9892kCSsNzzz0nSZo2bVq+52w2m3Jycko7EqBPPvlEs2fPVkpKirZs2aJatWppxowZCgsL4+anpYTdTChQhw4dNGzYMJ08edI5duLECY0YMUK//e1vLUwGd5Wbm1vgH4oMrDBr1iyNHDlSjz76qC5cuODcDsuVK6cZM2ZYG86NUGZQoJkzZ+rixYuqXbu26tatq3r16iksLEwXL17Ue++9Z3U8ALDce++9pzlz5mj06NF5brHRokUL7dmzx8Jk7oXdTChQaGiodu7cqYSEBCUnJ8vhcCgiIkIdO3a0Ohrc1LvvvnvDcZvNJl9fX9WrV09t27bN80sFKEkpKSk3vFyFj4+PLl++bEEi90SZwS1FR0crOjra6hiApk+frrNnzyozM1Ply5eXw+HQhQsX5O/vr8DAQJ05c0Z16tTR2rVruRYNSkVYWJiSkpLy3WLjX//6lyIiIixK5X4oM8jj3Xff1aBBg+Tr61vgt+DrOD0bpS0uLk4ffvihPvroI9WtW1eSdOjQIQ0ePFiDBg1SmzZt9PTTT2vEiBFasmSJxWnhDl5++WUNHTpUV69elcPh0LZt27Ro0SJNmjRJH330kdXx3AanZiOPsLAw7dixQxUqVFBYWFiBy9lsNh05cqQUkwFS3bp1tXTpUjVt2jTP+K5du/TEE0/oyJEj2rx5s5544gmdOnXKmpBwO3PmzNGECROUmpoqSapevbpiY2M1cOBAi5O5D8oMAGP4+/trw4YNatGiRZ7x7du3q127dsrMzNTRo0fVsGFDXbp0yaKUcFfnzp1Tbm6uKlWqZHUUt8PZTCi0nJwcJSUl6fz581ZHgZuKiorS4MGDtWvXLufYrl279Nxzz6lDhw6SpD179tx0VhEoTuPGjdPhw4clSRUrVqTIWIQygwINHz5cc+fOlfRLkWnbtq0iIyMVGhrKJeVhiblz5yokJETNmzeXj4+PfHx81KJFC4WEhDi31cDAQL399tsWJ4W7WLp0qe699161atVKM2fO1NmzZ62O5JbYzYQC1ahRQytWrFCLFi20YsUKDR06VGvXrtWCBQu0du1abdq0yeqIcFPJyck6cOCAHA6HwsPDdd9991kdCW7sxx9/1D/+8Q8tXrxYP/30kzp27KhevXqpa9eu8vf3tzqeW6DMoEC+vr46dOiQatSooUGDBsnf318zZsxQSkqKmjRpooyMDKsjwk1du3ZNKSkpqlu3rry8OCkTrmPTpk1auHChPv/8c129epV/J0sJu5lQoMqVK2vv3r3KycnRqlWrnBfLy8zM5KJksERmZqYGDhwof39/NWjQQMePH5f0y2UC3nzzTYvTAVJAQID8/PxUpkwZ2e12q+O4DcoMCtS/f391795dDRs2lM1mc1447/vvv1d4eLjF6eCOXnvtNe3evVvr1q2Tr6+vc7xjx4769NNPLUwGd5aSkqKJEycqIiJCLVq00M6dOxUbG6vTp09bHc1tMD+LAsXGxqphw4ZKTU1Vt27d5OPjI0ny9PTUqFGjLE4Hd7RixQp9+umnatWqlWw2m3M8IiLCeUYJUJpat26tbdu2qVGjRurfv7969Oih6tWrWx3L7VBmcFNPPvlkvrG+fftakASQzp49e8NTXy9fvpyn3AClJSoqSh999JEaNGhgdRS3RplBHtzOAK6sZcuWWrlypZ5//nlJchaYOXPmqHXr1lZGg5uKi4uzOgLE2Uz4FW5nAFe2efNm/f73v1fPnj01f/58DR48WD/++KO2bNmi9evXq3nz5lZHhBsYOXKkxo8fr4CAAI0cOfKmy06bNq2UUrk3ZmaQR0pKyg3/G3AFDz74oDZt2qS33npLdevW1erVqxUZGaktW7aoUaNGVseDm9i1a5fzTKX/vRr1r7Hrs/QwMwPgrrBkyZIbHuMF4O7Hqdko0JNPPnnDa3dMnTpV3bp1syAR3Fl2drZ+/PFHHThwIM/4F198oSZNmqhnz54WJQNgNWZmUKB77rlHa9asyTd9v2fPHnXs2FH//e9/LUoGd7N371499thjOnbsmCSpS5cumjVrlrp3767du3frT3/6k4YNG6bQ0FCLk8Idbd++XZ9//rmOHz+ua9eu5Xlu2bJlFqVyL8zMoECXLl1SmTJl8o17e3tziW6UqlGjRiksLExffPGFunfvrhUrVujhhx/Wb3/7W6Wmpuqtt96iyMASixcvVps2bbR3714tX75cdrtde/fu1Zo1axQcHGx1PLdBmUGBGjZseMOrqi5evFgREREWJIK72rZtm6ZOnarHHntMs2bNkiS9/PLLGjt2rMqWLWtxOrizuLg4TZ8+XV999ZXKlCmjd955R/v27VP37t1Vs2ZNq+O5Dc5mQoHGjBmjJ554QocPH1aHDh0kSd9++60WLVqkzz//3OJ0cCdnzpxxXlW1XLly8vf3V7t27SxOBUiHDx9Wp06dJEk+Pj7OCziOGDFCHTp00Lhx4yxO6B6YmUGBOnfurBUrVujQoUMaMmSIXnzxRf3000/697//ra5du1odD27EZrPJw+P//rny8PCQt7e3hYmAX4SEhOjixYuSpOrVq+uHH36QJF24cEGZmZlWRnMrHAAMwOV5eHgoODjYed2OCxcuKCgoKE/BkaS0tDQr4sGN9ejRQy1atNDIkSM1ceJEvfPOO+rSpYsSEhIUGRnJAcClhDKDm7pw4YKWLFmiI0eO6KWXXlJISIh27typypUrczM1lJr4+PhCLcd9w1Da0tLSdPXqVVWrVk25ubl66623tHHjRtWrV09jxoxR+fLlrY7oFigzKNB//vMfdezYUcHBwTp69Kj279+vOnXqaMyYMTp27JgWLFhgdUQAADhmBgUbOXKk+vXrp4MHD8rX19c5/sgjj2jDhg0WJgMA4P9wNhMKtH37dn3wwQf5xqtXr67Tp09bkAgAXIOHh8ct771ks9mUnZ1dSoncG2UGBfL19b3hxfH279+ve+65x4JEAOAali9fXuBzmzdv1nvvvSeO4ig9HDODAg0aNEhnz57VZ599ppCQEP3nP/+Rp6enunbtqrZt22rGjBlWRwQAl5GcnKzXXntNX375pXr27Knx48dz4bxSwjEzKNBbb72ls2fPqlKlSrpy5YratWunevXqqWzZspo4caLV8QDAJZw8eVLPPvusGjdurOzsbCUlJSk+Pp4iU4qYmcEtrVmzRjt37lRubq4iIyPVsWNHqyPBTT355JNq0aKFRo0alWd86tSp2rZtG1emRqlKT09XXFyc3nvvPTVt2lSTJ0/Www8/bHUst0SZAWAM7uQOVzFlyhRNnjxZVapUUVxcnLp06WJ1JLdGmcEN5ebmav78+Vq2bJmOHj0qm82msLAwPfnkk+rdu/ctj+IHSoKfn5+SkpJ033335RlPTk5Ws2bNdOXKFYuSwd14eHjIz89PHTt2lKenZ4HLcQXg0sHZTMjH4XCoc+fO+vrrr9WkSRM1atRIDodD+/btU79+/bRs2TKtWLHC6phwQ9fv5D527Ng849zJHaWtT58+fKlzIZQZ5DN//nxt2LBB3377raKiovI8t2bNGnXt2lULFixQnz59LEoId8Wd3OEq5s+fb3UE/A92MyGfmJgYdejQId9BltfFxcVp/fr1+uabb0o5GSCtXLlScXFxSkpKkp+fnxo3bqzXX39d7dq1szoaAItQZpBPlSpVtGrVKjVt2vSGz+/atUuPPPIIVwEGALgErjODfNLS0lS5cuUCn69cubLOnz9fiokAACgYx8wgn5ycHHl5FbxpeHp6cr8RlJqQkBAdOHBAFStWVPny5W960GVaWlopJgPgKigzyMfhcKhfv37y8fG54fNZWVmlnAjubPr06SpbtqzzvzmDBMCvccwM8unfv3+hlps3b14JJwEA4NYoMwCM4enpqVOnTqlSpUp5xn/++WdVqlRJOTk5FiUDYCUOAAZgjIK+e2VlZalMmTKlnAaAq+CYGQAu791335Uk2Ww2ffTRRwoMDHQ+l5OTow0bNig8PNyqeAAsxm4mAC4vLCxMknTs2DHVqFEjz71wypQpo9q1a+uNN97QAw88YFVEABaizAAwRlRUlJYtW6by5ctbHQWAC6HMADBWTk6O9uzZo1q1alFwADfGAcAAjDF8+HDNnTtX0i9Fpm3btoqMjFRoaKjWrVtnbTgAlqHMADDG559/riZNmkiSvvzySx09elTJyckaPny4Ro8ebXE6AFahzAAwxs8//6wqVapIkr7++mt169ZN9957rwYOHKg9e/ZYnA6AVSgzAIxRuXJl7d27Vzk5OVq1apU6duwoScrMzMxzhhMA98J1ZgAYo3///urevbuqVq0qm82m6OhoSdL333/PdWYAN0aZAWCM2NhYNWzYUKmpqerWrZvzZqienp4aNWqUxekAWIVTswEAgNGYmQHg0t59910NGjRIvr6+ztsaFOSFF14opVQAXAkzMwBcWlhYmHbs2KEKFSo4b2twIzabTUeOHCnFZABcBWUGAAAYjVOzAQCA0ThmBoAxRo4cecNxm80mX19f1atXT126dFFISEgpJwNgJXYzATBGVFSUdu7cqZycHN13331yOBw6ePCgPD09FR4erv3798tms2njxo2KiIiwOi6AUsJuJgDG6NKlizp27KiTJ08qMTFRO3fu1IkTJxQdHa1nnnlGJ06cUNu2bTVixAirowIoRczMADBG9erVlZCQkG/W5ccff1RMTIxOnDihnTt3KiYmRufOnbMoJYDSxswMAGOkp6frzJkz+cbPnj2rjIwMSVK5cuV07dq10o4GwEKUGQDG6NKliwYMGKDly5frp59+0okTJ7R8+XINHDhQXbt2lSRt27ZN9957r7VBAZQqdjMBMMalS5c0YsQILViwQNnZ2ZIkLy8v9e3bV9OnT1dAQICSkpIkSU2bNrUuKIBSRZkBYJxLly7pyJEjcjgcqlu3rgIDA62OBMBCXGcGgHECAwMVEhIim81GkQHAMTMAzJGbm6s33nhDwcHBqlWrlmrWrKly5cpp/Pjxys3NtToeAIswMwPAGKNHj9bcuXP15ptvqk2bNnI4HNq0aZNiY2N19epVTZw40eqIACzAMTMAjFGtWjXNnj1bnTt3zjP+xRdfaMiQITpx4oRFyQBYid1MAIyRlpam8PDwfOPh4eFKS0uzIBEAV0CZAWCMJk2aaObMmfnGZ86cqSZNmliQCIArYDcTAGOsX79enTp1Us2aNdW6dWvZbDZt3rxZqamp+vrrr/Xwww9bHRGABSgzAIxy8uRJ/e1vf1NycrIcDociIiI0ZMgQVatWzepoACxCmQFgvNTUVL3++uv6+OOPrY4CwAKUGQDG2717tyIjI5WTk2N1FAAW4ABgAABgNMoMAAAwGmUGAAAYjdsZAHB5jz/++E2fv3DhQukEAeCSKDMAXF5wcPAtn+/Tp08ppQHgajibCQAAGI1jZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yA8ClHD16VDabTUlJSS7zXu3bt9fw4cNLPA+A20OZAeDUr18/2Ww2/fnPf8733JAhQ2Sz2dSvX788y3ft2rXI7/PTTz+pTJkyCg8Pv4O0dy40NFSnTp1Sw4YNJUnr1q2TzWbjInyAYSgzAPIIDQ3V4sWLdeXKFefY1atXtWjRItWsWbNY3mP+/Pnq3r27MjMztWnTpmJZZ1Fdu3ZNnp6eqlKliry8uH4oYDLKDIA8IiMjVbNmTS1btsw5tmzZMoWGhqpZs2Z3vH6Hw6F58+apd+/e6tGjh+bOnXvL1/zzn/9U/fr15efnp6ioKMXHx+ebQVm6dKkaNGggHx8f1a5dW2+//XaeddSuXVsTJkxQv379FBwcrGeffTbPbqajR48qKipKklS+fPl8s1C5ubl65ZVXFBISoipVqig2NjbP+m02mz744AM99thj8vf3129+8xtt2bJFhw4dUvv27RUQEKDWrVvr8OHDt/3ZAbgxygyAfPr376958+Y5H3/88ccaMGBAsax77dq1yszMVMeOHdW7d2999tlnunjxYoHLHz16VE8++aS6du2qpKQkDR48WKNHj86zTGJiorp3766nn35ae/bsUWxsrMaMGaP58+fnWW7q1Klq2LChEhMTNWbMmDzPhYaGaunSpZKk/fv369SpU3rnnXecz8fHxysgIEDff/+9pkyZojfeeEMJCQl51jF+/Hj16dNHSUlJCg8PV48ePTR48GC99tpr2rFjhyTpL3/5S5E/MwC34ACA/6dv376OLl26OM6ePevw8fFxpKSkOI4ePerw9fV1nD171tGlSxdH37598y1fFD169HAMHz7c+bhJkyaOOXPmOB+npKQ4JDl27drlcDgcjldffdXRsGHDPOsYPXq0Q5Lj/PnzznVGR0fnWebll192REREOB/XqlXL0bVr1zzL/Pq91q5dm2e917Vr187x0EMP5Rlr2bKl49VXX3U+luT461//6ny8ZcsWhyTH3LlznWOLFi1y+Pr63uhjAXAHmJkBkE/FihXVqVMnxcfHa968eerUqZMqVqx4x+u9cOGCli1bpl69ejnHevXqpY8//rjA1+zfv18tW7bMM3b//ffnebxv3z61adMmz1ibNm108OBB5eTkOMdatGhx29kbN26c53HVqlV15syZApepXLmyJKlRo0Z5xq5evaqMjIzbzgEgP456A3BDAwYMcO4S+dvf/lYs61y4cKGuXr2qBx54wDnmcDiUm5urvXv3KiIiIt9rHA6HbDZbvrGiLiNJAQEBt53d29s7z2Obzabc3NwCl7me50Zjv34dgDvDzAyAG/r973+va9eu6dq1a/rd735XLOucO3euXnzxRSUlJTn/7N69W1FRUQXOzoSHh2v79u15xq4ff3JdRESENm7cmGds8+bNuvfee+Xp6VnofGXKlJGkPLM5AFwfMzMAbsjT01P79u1z/ndB0tPT8110LiQkJN9p3ElJSdq5c6f+8Y9/5Lu+zDPPPKPRo0dr0qRJ+dY/ePBgTZs2Ta+++qoGDhyopKQk54G912c6XnzxRbVs2VLjx4/XU089pS1btmjmzJl6//33i/Qz16pVSzabTV999ZUeffRR+fn5KTAwsEjrAFD6mJkBUKCgoCAFBQXddJl169apWbNmef6MHTs233Jz585VRETEDS+U17VrV6WlpenLL7/M91xYWJiWLFmiZcuWqXHjxpo1a5bzbCYfHx9Jv5xO/tlnn2nx4sVq2LChxo4dqzfeeCPPqdWFUb16dY0bN06jRo1S5cqVOfMIMITNcaMdywDgwiZOnKjZs2crNTXV6igAXAC7mQC4vPfff18tW7ZUhQoVtGnTJk2dOpVZEwBOlBkALu/gwYOaMGGC0tLSVLNmTb344ot67bXXrI4FwEWwmwkAABiNA4ABAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNH+fyDIeyb9oPxhAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAIoCAYAAACBPVQBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABMsklEQVR4nO3deVxWZf7/8ffN4s0mKJq4IZJLSJgKai6p2ShNU1+1ybQsXBszp0VRJ8201NLSUtTSmlzQfqXm1momlbnkliiOqbgvJJArIiLIcv/+cLxnGNBA75uDnNfz8eCB93Wu+5zPuR9HeHOd65xjsdlsNgEAAJiIi9EFAAAAlDYCEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB03owsoi/Lz85WcnKyKFSvKYrEYXQ4AACgGm82mixcvqmbNmnJxufEYDwGoCMnJyQoMDDS6DAAAcBOSkpJUu3btG/YhABWhYsWKkq5+gL6+vgZXc3vLycnRmjVrFBkZKXd3d6PLATgmUSZxXDpGenq6AgMD7b/Hb4QAVIRrp718fX0JQLcoJydHXl5e8vX15T81ygSOSZRFHJeOVZzpK0yCBgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApsPT4AEAcKDMzEwlJiaW6D0Zl7O1afdhVa66XT6e1mK/LyQkRF5eXiUtESIAAQDgUImJiYqIiLip904uYf/4+HiFh4ff1LbMjgAEAIADhYSEKD4+vkTv2Z+SpuiluzX18ca6q0alEm0LN4cABACAA3l5eZV4VMbl+FlZN1xWo7AmahpUxUmV4b8xCRoAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJiO4QFo1qxZCg4OloeHhyIiIrRhw4Yb9v/kk0/UpEkTeXl5qUaNGurXr5/Onj1boM/y5csVGhoqq9Wq0NBQrVy50pm7AAAAbjOGBqAlS5ZoyJAhGj16tHbu3Kl27drpoYce0okTJ4rsv3HjRvXu3VsDBgzQnj17tHTpUv3yyy965pln7H02b96snj17KioqSrt27VJUVJR69OihrVu3ltZuAQCAMs7QADR16lQNGDBAzzzzjBo1aqSYmBgFBgZq9uzZRfbfsmWL6tatqxdffFHBwcG677779Oyzz2r79u32PjExMercubNGjRqlkJAQjRo1Sn/6058UExNTSnsFAADKOsMC0JUrVxQfH6/IyMgC7ZGRkdq0aVOR72nTpo1+++03rVq1SjabTb///ruWLVumhx9+2N5n8+bNhdb54IMPXnedAADAfNyM2vCZM2eUl5engICAAu0BAQFKTU0t8j1t2rTRJ598op49eyorK0u5ubnq0qWLZs6cae+TmppaonVKUnZ2trKzs+2v09PTJUk5OTnKyckp8b7hP659fnyOKCs4JlEW5ebm2r9zbN68knx2hgWgaywWS4HXNputUNs1e/fu1YsvvqixY8fqwQcfVEpKikaMGKFBgwZp7ty5N7VOSZo0aZLGjRtXqH3NmjXy8vIqye7gOuLi4owuASiAYxJlSVKGJLlpy5YtOvmr0dXcvjIzM4vd17AAVLVqVbm6uhYamTl16lShEZxrJk2apLZt22rEiBGSpHvuuUfe3t5q166d3njjDdWoUUPVq1cv0ToladSoUYqOjra/Tk9PV2BgoCIjI+Xr63uzuwhdTeNxcXHq3Lmz3N3djS4H4JhEmbTrxDlp93a1atVKTer4G13ObevaGZziMCwAVahQQREREYqLi9Ojjz5qb4+Li1PXrl2LfE9mZqbc3AqW7OrqKunqKI8ktW7dWnFxcRo6dKi9z5o1a9SmTZvr1mK1WmW1Wgu1u7u78wPSQfgsUdZwTKIsufa7zc3NjePyFpTkszP0FFh0dLSioqLUvHlztW7dWv/85z914sQJDRo0SNLVkZmTJ09q4cKFkqT/+7//09/+9jfNnj3bfgpsyJAhatmypWrWrClJeumll9S+fXu9/fbb6tq1q7744gt9//332rhxo2H7CQAAyhZDA1DPnj119uxZjR8/XikpKQoLC9OqVasUFBQkSUpJSSlwT6C+ffvq4sWLeu+99zRs2DBVqlRJDzzwgN5++217nzZt2mjx4sV69dVXNWbMGNWrV09LlizRvffeW+r7BwAAyiaL7dq5I9ilp6fLz89PFy5cYA7QLcrJydGqVav0l7/8hWFdlAkckyiLEo6fVbfZW/T5c63UNKiK0eXctkry+9vwR2EAAACUNgIQAAAwHQIQAAAwHQIQAAAwHQIQAAAwHQIQAAAwHQIQAAAwHQIQAAAwHQIQAAAwHQIQAAAwHQIQAAAwHQIQAAAwHUOfBg8AwO3g6JlLupSd67T1Hz59yf7dzc05v5q9rW4KrurtlHXfjghAAADcwNEzl9TxnZ9KZVvDlu126vrXDr+fEPRvBCAAAG7g2shPTM+mql/NxznbuJytr3/arEfuby1vT6vD13/oVIaGLElw6ijW7YYABABAMdSv5qOwWn5OWXdOTo5S75DCgyrL3d3dKdtAQUyCBgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApsN9gADc1jIzM5WYmFjs/hmXs7Vp92FVrrpdPiW84VxISIi8vLxKWiKAMogABOC2lpiYqIiIiBK/b/JNbCs+Pl7h4eE38U4AZQ0BCMBtLSQkRPHx8cXuvz8lTdFLd2vq4411V41KJd4WgPKBAATgtubl5VWiURmX42dl3XBZjcKaqGlQFSdWBqAsYxI0AAAwHQIQAAAwHQIQAAAwHeYAAShTjp65pEvZuU5b/+HTl+zf3dyc9yPQ2+qm4KreTls/gFtDAAJQZhw9c0kd3/mpVLY1bNlup29j7fD7CUFAGUUAAlBmXBv5ienZVPWr+ThnG5ez9fVPm/XI/a3lXcIbIRbXoVMZGrIkwakjWQBuDQEIQJlTv5qPwmr5OWXdOTk5Sr1DCg+qLHd3d6dsA0DZxyRoAABgOgQgAABgOgQgAABgOswBAlBmZOdlycXjpI6m75eLh3MmQefm5io5N1n7zu1z2mXwR9Mz5OJxUtl5WZKcM5cJwK0hAAEoM5IvHZd38Ey9ss3525q1epZT1+8dLCVfaqoIBTh1OwBuDgEIQJlR0ztIl46+oOk9m6qeky6Dz83N1c8bf1bb+9o6bQTo8KkMvbQkQTU7Bjll/QBuHQEIQJlhdfVQflYtBfvepdAqzrsM/qjbUTXyb+S0y+Dzsy4oP+u0rK4eTlk/gFvHJGgAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6hgegWbNmKTg4WB4eHoqIiNCGDRuu27dv376yWCyFvu6++257n9jY2CL7ZGVllcbuAACA24ChAWjJkiUaMmSIRo8erZ07d6pdu3Z66KGHdOLEiSL7T58+XSkpKfavpKQk+fv76/HHHy/Qz9fXt0C/lJQUeXh4lMYuAQCA24ChAWjq1KkaMGCAnnnmGTVq1EgxMTEKDAzU7Nmzi+zv5+en6tWr27+2b9+u8+fPq1+/fgX6WSyWAv2qV69eGrsDAABuE25GbfjKlSuKj4/XyJEjC7RHRkZq06ZNxVrH3Llz1alTJwUFBRVoz8jIUFBQkPLy8tS0aVNNmDBBzZo1u+56srOzlZ2dbX+dnp4uScrJyVFOTk5xdwlFuPb58TmiOHJzc+3fnXXMlMYxWRr7gdJTHo5LsxyTJdk3wwLQmTNnlJeXp4CAgALtAQEBSk1N/cP3p6Sk6Ntvv9Wnn35aoD0kJESxsbFq3Lix0tPTNX36dLVt21a7du1SgwYNilzXpEmTNG7cuELta9askZeXVwn2CtcTFxdndAm4DSRlSJKbNm7cqOM+zt2WM4/J0twPOF95OC7NckxmZmYWu69hAegai8VS4LXNZivUVpTY2FhVqlRJ3bp1K9DeqlUrtWrVyv66bdu2Cg8P18yZMzVjxowi1zVq1ChFR0fbX6enpyswMFCRkZHy9fUtwd7gf+Xk5CguLk6dO3eWu7u70eWgjNuTnK53dm/Rfffdp7trOuf/Xmkck6WxHyg95eG4NMsxee0MTnEYFoCqVq0qV1fXQqM9p06dKjQq9L9sNpvmzZunqKgoVahQ4YZ9XVxc1KJFCx08ePC6faxWq6xWa6F2d3d3fmk7CJ8lisPNzc3+3dnHizOPydLcDzhfeTguzXJMlmTfDJsEXaFCBUVERBQa7ouLi1ObNm1u+N5169bp0KFDGjBgwB9ux2azKSEhQTVq1LilegEAQPlh6Cmw6OhoRUVFqXnz5mrdurX++c9/6sSJExo0aJCkq6emTp48qYULFxZ439y5c3XvvfcqLCys0DrHjRunVq1aqUGDBkpPT9eMGTOUkJCg999/v1T2CQBQvmTnZcnF46SOpu+Xi4dzJtDk5uYqOTdZ+87ts4/WONLR9Ay5eJxUdl6WJD+Hr/92ZGgA6tmzp86ePavx48crJSVFYWFhWrVqlf2qrpSUlEL3BLpw4YKWL1+u6dOnF7nOtLQ0DRw4UKmpqfLz81OzZs20fv16tWzZ0un7AwAof5IvHZd38Ey9ss3525q1epbT1u0dLCVfaqoI3XiaiVkYPgl68ODBGjx4cJHLYmNjC7X5+fndcJb3tGnTNG3aNEeVBwAwuZreQbp09AVN79lU9ao5bwTo540/q+19bZ0yAnT4VIZeWpKgmh2D/rizSRgegAAAKMusrh7Kz6qlYN+7FFrFOaePcnJydNTtqBr5N3LKJOX8rAvKzzotqytPRbjG8GeBAQAAlDYCEAAAMB0CEAAAMB3mAAEoMy7n5EmSfj15wWnbuHQ5W9tPS9WPn5e3Z+EboDrCoVMZTlkvAMchAAEoMw7/OziMXLHbyVty08eHfnHyNiRvKz9igbKK/50AyozIu6tLkupV85Gnu6tTtrE/5YKGLdutd7s31l01nHdDOG+rm4Krejtt/QBuDQEIQJnh711BT7Ss49Rt5ObmSpLq3eGtsFrcERcwKyZBAwAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yl2ADp//rxmzpyp9PT0QssuXLhw3WUAAABlTbED0Hvvvaf169fL19e30DI/Pz9t2LBBM2fOdGhxAAAAzlDsALR8+XINGjTousufffZZLVu2zCFFAQAAOFOxA9Dhw4fVoEGD6y5v0KCBDh8+7JCiAAAAnKnYAcjV1VXJycnXXZ6cnCwXF+ZUAwCAsq/YiaVZs2b6/PPPr7t85cqVatasmSNqAgAAcCq34nZ8/vnn9cQTT6h27dp67rnn5OrqKknKy8vTrFmzNG3aNH366adOKxQAAMBRih2AHnvsMf3jH//Qiy++qNGjR+vOO++UxWLR4cOHlZGRoREjRqh79+7OrBUAAMAhih2AJOnNN99U165d9cknn+jQoUOy2Wxq3769evXqpZYtWzqrRgAAAIcqUQCSpJYtWxJ2AADAba3YAWj9+vVFtvv5+al+/fry9vZ2WFEAAADOVOwAdP/99193maurq5577jm9++67cnd3d0RdAAAATlPsAHT+/Pki29PS0rRt2zaNGDFC1atX1yuvvOKw4gAAAJyh2AHIz8/vuu1BQUGqUKGCXnnlFQIQAAAo8xx26+YmTZro+PHjjlodAACA0zgsACUnJ6tatWqOWh0AAIDTOCQAnTp1Sq+++qoeeOABR6wOAADAqYo9B6hZs2ayWCyF2i9cuKDffvtNjRo10uLFix1aHAAAgDMUOwB169atyHZfX1+FhIQoMjLS/nwwAACAsqzYAei11177wz65ublycyvxzaUBAABKlUPmAO3du1fR0dGqVauWI1YHAADgVDcdgDIyMjRnzhy1bt1a99xzj7Zt26aRI0c6sjYAAACnKPH5qo0bN2rOnDlavny5goODtXfvXq1bt05t27Z1Rn0AcEOZmZlKTEwsdv/9KWnKTj2kfb96Kv9spRJtKyQkRF5eXiWsEEBZVOwANHnyZM2bN08ZGRl68skntXHjRjVp0kTu7u6qXLmyM2sEgOtKTExUREREid/Xa0HJtxUfH6/w8PCSvxFAmVPsAPTKK6/o5Zdf1vjx47naC0CZERISovj4+GL3z7icrW/WbtbDHVvLx9Na4m0BKB+KHYDGjx+v2NhYffzxx3ryyScVFRWlsLAwZ9YGAH/Iy8urRKMyOTk5On/mlFq3bC53d3cnVgagLCv2JOhXXnlFBw4c0Mcff6zU1FS1atVKTZo0kc1mu+6T4gEAAMqiEl8F1qFDBy1YsEApKSl67rnnFBERoQ4dOqhNmzaaOnWqM2oEAABwqJu+DL5ixYoaNGiQtm7dqp07d6ply5Z66623HFkbAACAUzjkts2NGzdWTEyMpkyZ4ojVoQwr6SXHGZeztWn3YVWuur1EE0653BgA4EwOfW4FEwrLv5u95HhyCftzuTEAwJl4cBdKpKSXHO9PSVP00t2a+nhj3VWjUom2AwCAsxCAUCIlveTY5fhZWTdcVqOwJmoaVMWJlQEAUHwOeRgqAADA7aTYASg5OVnDhw9Xenp6oWUXLlzQiBEj9Pvvvzu0OAAAAGcodgCaOnWq0tPT5evrW2iZn5+fLl68yH2AAADAbaHYAWj16tXq3bv3dZf37t1bX3/9tUOKAgAAcKZiB6CjR4+qTp06111eu3ZtHTt2zBE1AQAAOFWxA5Cnp+cNA86xY8fk6enpiJoAAACcqtgB6N5779XHH3983eULFy5Uy5YtS1zArFmzFBwcLA8PD0VERGjDhg3X7du3b19ZLJZCX3fffXeBfsuXL1doaKisVqtCQ0O1cuXKEtcFAADKr2IHoOHDh2v+/PkaPnx4gau9fv/9dw0bNkyxsbEaPnx4iTa+ZMkSDRkyRKNHj9bOnTvVrl07PfTQQzpx4kSR/adPn66UlBT7V1JSkvz9/fX444/b+2zevFk9e/ZUVFSUdu3apaioKPXo0UNbt24tUW0AAKD8KnYA6tixo95//3299957qlmzpipXrix/f3/VrFlT77//vmbOnKkHHnigRBufOnWqBgwYoGeeeUaNGjVSTEyMAgMDNXv27CL7+/n5qXr16vav7du36/z58+rXr5+9T0xMjDp37qxRo0YpJCREo0aN0p/+9CfFxMSUqDYAAFB+lehO0M8++6weeeQRffbZZzp06JBsNpsaNmyo7t27q3bt2iXa8JUrVxQfH6+RI0cWaI+MjNSmTZuKtY65c+eqU6dOCgoKsrdt3rxZQ4cOLdDvwQcfJAABAAC7Ej8Ko1atWoUCxs04c+aM8vLyFBAQUKA9ICBAqampf/j+lJQUffvtt/r0008LtKemppZ4ndnZ2crOzra/vnazx5ycHOXk5PxhLbi+3Nxc+3c+S5QF145DjkcUV2n8HHP2cWmWn8Ul2bcSB6ClS5dq0aJFOnDggCwWixo0aKBevXqpe/fuJV2VJMlisRR4bbPZCrUVJTY2VpUqVVK3bt1ueZ2TJk3SuHHjCrWvWbNGXl5ef1gLri8pQ5LctGXLFp381ehqgP+Ii4szugTcJq79HNu4caOO+zh3W846LktzH4yUmZlZ7L7FDkD5+fl68skntXTpUjVs2FAhISGy2Wzas2ePevbsqccff1yLFi0qVniRpKpVq8rV1bXQyMypU6cKjeD8L5vNpnnz5ikqKkoVKlQosKx69eolXueoUaMUHR1tf52enq7AwEBFRkYWeedrFN+uE+ek3dvVqlUrNanjb3Q5gHJychQXF6fOnTvL3d3d6HJwG9iTnK53dm/Rfffdp7trOud3grOPy9LYh7KgqMd1XU+xA1BMTIy+//57ffnll3rkkUcKLPvyyy/Vr18/TZ8+XUOGDCnW+ipUqKCIiAjFxcXp0UcftbfHxcWpa9euN3zvunXrdOjQIQ0YMKDQstatWysuLq7Aabo1a9aoTZs2112f1WqV1Wot1O7u7s4PyFvk5uZm/85nibKE/98ortL8Oeas49IsP4tLsm/FvgosNjZWU6ZMKRR+JKlLly6aPHmy5s6dW+wNS1J0dLTmzJmjefPmad++fRo6dKhOnDihQYMGSbo6MlPU4zfmzp2re++9V2FhYYWWvfTSS1qzZo3efvttJSYm6u2339b3339f7GAGAADKv2KPAB08eFCdOnW67vJOnTrp+eefL9HGe/bsqbNnz2r8+PFKSUlRWFiYVq1aZb+qKyUlpdA9gS5cuKDly5dr+vTpRa6zTZs2Wrx4sV599VWNGTNG9erV05IlS3TvvfeWqDYAAFB+FTsAeXp6Ki0t7brPA0tPT7+pR2EMHjxYgwcPLnJZbGxsoTY/P78/nOTUvXv3m56UDQAAyr9inwJr3br1dW9QKEnvv/++Wrdu7ZCiAAAAnKnYI0CjR4/W/fffr7Nnz2r48OH2q8D27dund999V1988YXWrl3rzFoBAAAcotgBqE2bNlqyZIkGDhyo5cuXF1hWuXJlLVq0SG3btnV4gQAAAI5WohshPvroo3rwwQf13Xff6eDBg5Kkhg0bKjIykhsGAgCA20aJ7wTt5eVV4L49/+3kyZOqVavWLRcFAADgTMWeBH0jqampeuGFF1S/fn1HrA4AAMCpih2A0tLS9NRTT+mOO+5QzZo1NWPGDOXn52vs2LG68847tWXLFs2bN8+ZtQIAADhEsU+BvfLKK1q/fr369Omj1atXa+jQoVq9erWysrL07bffqkOHDs6sEwAAwGGKHYC++eYbzZ8/X506ddLgwYNVv359NWzYUDExMU4sDwAAwPGKfQosOTlZoaGhkqQ777xTHh4eeuaZZ5xWGAAAgLMUOwDl5+cXeMqqq6urvL29nVIUAACAMxX7FJjNZlPfvn1ltVolSVlZWRo0aFChELRixQrHVggAAOBgxQ5Affr0KfD66aefdngxAAAApaHYAWj+/PnOrAMAAKDUOORGiAAAALcTAhAAADAdAhAAADAdAhAAADAdAhAAADAdAhAAADAdAhAAADAdAhAAADAdAhAAADAdAhAAADAdAhAAADAdAhAAADAdAhAAADAdAhAAADAdAhAAADAdAhAAADAdAhAAADAdAhAAADAdN6MLgLGOnrmkS9m5Tlv/4dOX7N/d3Jx3uHlb3RRc1dtp6wcAlC8EIBM7euaSOr7zU6lsa9iy3U7fxtrh9xOCAADFQgAysWsjPzE9m6p+NR/nbONytr7+abMeub+1vD2tTtnGoVMZGrIkwakjWQCA8oUABNWv5qOwWn5OWXdOTo5S75DCgyrL3d3dKdsAAKCkmAQNAABMhxEgAABu4HJOniTp15MXnLaNS5eztf20VP34eadMFzh0KsPh67zdEYAAALiBw/8ODyNXOPtiDjd9fOgXp27B28qv/Wv4JAAAuIHIu6tLkupV85Gnu6tTtrE/5YKGLdutd7s31l01nDMnk9uFFEQAAgDgBvy9K+iJlnWcuo3c3KtXsda7w9tpF6WgICZBAwAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0yEAAQAA0zE8AM2aNUvBwcHy8PBQRESENmzYcMP+2dnZGj16tIKCgmS1WlWvXj3NmzfPvjw2NlYWi6XQV1ZWlrN3BQAA3CbcjNz4kiVLNGTIEM2aNUtt27bVhx9+qIceekh79+5VnTp1inxPjx499Pvvv2vu3LmqX7++Tp06pdzc3AJ9fH19tX///gJtHh4eTtsPAABwezE0AE2dOlUDBgzQM888I0mKiYnRd999p9mzZ2vSpEmF+q9evVrr1q3TkSNH5O/vL0mqW7duoX4Wi0XVq1d3au0AAOD2ZVgAunLliuLj4zVy5MgC7ZGRkdq0aVOR7/nyyy/VvHlzTZ48WR9//LG8vb3VpUsXTZgwQZ6envZ+GRkZCgoKUl5enpo2baoJEyaoWbNm160lOztb2dnZ9tfp6emSpJycHOXk5NzKbpZp10bOcnNznbaf19brzM+xNPYD5UdpHJNASfFzzDFK8tkZFoDOnDmjvLw8BQQEFGgPCAhQampqke85cuSINm7cKA8PD61cuVJnzpzR4MGDde7cOfs8oJCQEMXGxqpx48ZKT0/X9OnT1bZtW+3atUsNGjQocr2TJk3SuHHjCrWvWbNGXl5et7inZVdShiS5aePGjTru49xtxcXFOW3dpbkfKD+ceUwCJXXt59iWLVt08lejq7l9ZWZmFruvoafApKunq/6bzWYr1HZNfn6+LBaLPvnkE/n5+Um6ehqte/fuev/99+Xp6alWrVqpVatW9ve0bdtW4eHhmjlzpmbMmFHkekeNGqXo6Gj76/T0dAUGBioyMlK+vr63uotl1p7kdL2ze4vuu+8+3V3TOfuZk5OjuLg4de7cWe7u7k7ZRmnsB8qP0jgmgZLadeKctHu7WrVqpSZ1/I0u57Z17QxOcRgWgKpWrSpXV9dCoz2nTp0qNCp0TY0aNVSrVi17+JGkRo0ayWaz6bfffityhMfFxUUtWrTQwYMHr1uL1WqV1Wot1O7u7l6uf0C6ubnZvzt7P535WZbmfqD8KO//v3F74eeYY5TkszPsMvgKFSooIiKi0DB0XFyc2rRpU+R72rZtq+TkZGVkZNjbDhw4IBcXF9WuXbvI99hsNiUkJKhGjRqOKx4AANzWDL0PUHR0tObMmaN58+Zp3759Gjp0qE6cOKFBgwZJunpqqnfv3vb+vXr1UpUqVdSvXz/t3btX69ev14gRI9S/f3/7JOhx48bpu+++05EjR5SQkKABAwYoISHBvk4AAABD5wD17NlTZ8+e1fjx45WSkqKwsDCtWrVKQUFBkqSUlBSdOHHC3t/Hx0dxcXF64YUX1Lx5c1WpUkU9evTQG2+8Ye+TlpamgQMHKjU1VX5+fmrWrJnWr1+vli1blvr+AQCAssnwSdCDBw/W4MGDi1wWGxtbqC0kJOSGV29MmzZN06ZNc1R5AACgHDL8URgAAACljQAEAABMhwAEAABMhwAEAABMhwAEAABMhwAEAABMhwAEAABMhwAEAABMhwAEAABMhwAEAABMhwAEAABMhwAEAABMhwAEAABMx/CnwcM42XlZcvE4qaPp++Xi4eOUbeTm5io5N1n7zu2Tm5tzDrej6Rly8Tip7LwsSX5O2QYAoHwhAJlY8qXj8g6eqVe2OX9bs1bPcur6vYOl5EtNFaEAp24HAFA+EIBMrKZ3kC4dfUHTezZVvWrOGwH6eePPantfW6eNAB0+laGXliSoZscgp6wfAFD+EIBMzOrqofysWgr2vUuhVZxz6ignJ0dH3Y6qkX8jubu7O2Ub+VkXlJ91WlZXD6esHwBQ/jAJGgAAmA4BCAAAmA4BCAAAmA4BCAAAmA4BCAAAmA4BCAAAmA4BCAAAmA4BCAAAmA43QjSxyzl5kqRfT15w2jYuXc7W9tNS9ePn5e1pdco2Dp3KcMp6AQDlFwHIxA7/OziMXLHbyVty08eHfnHyNiRvK4czAKB4+I1hYpF3V5ck1avmI093V6dsY3/KBQ1btlvvdm+su2o470nt3lY3BVf1dtr6AQDlCwHIxPy9K+iJlnWcuo3c3FxJUr07vBVWy3kBCACAkmASNAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB1uhIgSyczMVGJiYrH7709JU3bqIe371VP5ZysV+30hISHy8vK6iQoBAPhjBCCUSGJioiIiIkr8vl4LStY/Pj5e4eHhJd4OAADFQQBCiYSEhCg+Pr7Y/TMuZ+ubtZv1cMfW8inB0+BDQkJupjwAAIqFAIQS8fLyKtHITE5Ojs6fOaXWLZvL3d3diZUBAFB8TIIGAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmY3gAmjVrloKDg+Xh4aGIiAht2LDhhv2zs7M1evRoBQUFyWq1ql69epo3b16BPsuXL1doaKisVqtCQ0O1cuVKZ+4CAAC4zRgagJYsWaIhQ4Zo9OjR2rlzp9q1a6eHHnpIJ06cuO57evTooR9++EFz587V/v37tWjRIoWEhNiXb968WT179lRUVJR27dqlqKgo9ejRQ1u3bi2NXQIAALcBNyM3PnXqVA0YMEDPPPOMJCkmJkbfffedZs+erUmTJhXqv3r1aq1bt05HjhyRv7+/JKlu3boF+sTExKhz584aNWqUJGnUqFFat26dYmJitGjRIufuEAAAuC0YNgJ05coVxcfHKzIyskB7ZGSkNm3aVOR7vvzySzVv3lyTJ09WrVq11LBhQw0fPlyXL1+299m8eXOhdT744IPXXScAADAfw0aAzpw5o7y8PAUEBBRoDwgIUGpqapHvOXLkiDZu3CgPDw+tXLlSZ86c0eDBg3Xu3Dn7PKDU1NQSrVO6Oq8oOzvb/jo9PV2SlJOTo5ycnJvaP1x17fPjc0RZwTGJsig3N9f+nWPz5pXkszP0FJgkWSyWAq9tNluhtmvy8/NlsVj0ySefyM/PT9LV02jdu3fX+++/L09PzxKvU5ImTZqkcePGFWpfs2aNvLy8SrQ/KFpcXJzRJQAFcEyiLEnKkCQ3bdmyRSd/Nbqa21dmZmax+xoWgKpWrSpXV9dCIzOnTp0qNIJzTY0aNVSrVi17+JGkRo0ayWaz6bffflODBg1UvXr1Eq1TujpPKDo62v46PT1dgYGBioyMlK+v783sHv4tJydHcXFx6ty5s9zd3Y0uB+CYRJm068Q5afd2tWrVSk3q+Btdzm3r2hmc4jAsAFWoUEERERGKi4vTo48+am+Pi4tT165di3xP27ZttXTpUmVkZMjHx0eSdODAAbm4uKh27dqSpNatWysuLk5Dhw61v2/NmjVq06bNdWuxWq2yWq2F2t3d3fkB6SB8lihrOCZRlri5udm/c1zevJJ8doZeBh8dHa05c+Zo3rx52rdvn4YOHaoTJ05o0KBBkq6OzPTu3dvev1evXqpSpYr69eunvXv3av369RoxYoT69+9vP/310ksvac2aNXr77beVmJiot99+W99//72GDBlixC4CAIAyyNA5QD179tTZs2c1fvx4paSkKCwsTKtWrVJQUJAkKSUlpcA9gXx8fBQXF6cXXnhBzZs3V5UqVdSjRw+98cYb9j5t2rTR4sWL9eqrr2rMmDGqV6+elixZonvvvbfU9w8AAJRNhk+CHjx4sAYPHlzkstjY2EJtISEhfzh5sXv37urevbsjygMAAOWQ4Y/CAAAAKG0EIAAAYDoEIAAAYDoEIAAAYDoEIAAAYDqGXwUGAEB5kpmZqcTExBK9Z39KmrJTD2nfr57KP1up2O8LCQnhkU03iQAEAIADJSYmKiIi4qbe22tByfrHx8crPDz8prZldgQgAAAcKCQkRPHx8SV6T8blbH2zdrMe7thaPp6FH810o23h5hCAAABwIC8vrxKPyuTk5Oj8mVNq3bI5zwIrJUyCBgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApsPT4Itgs9kkSenp6QZXcvvLyclRZmam0tPTecIxygSOSZRFHJeOce339rXf4zdCACrCxYsXJUmBgYEGVwIAAErq4sWL8vPzu2Efi604Mclk8vPzlZycrIoVK8pisRhdzm0tPT1dgYGBSkpKkq+vr9HlAByTKJM4Lh3DZrPp4sWLqlmzplxcbjzLhxGgIri4uKh27dpGl1Gu+Pr68p8aZQrHJMoijstb90cjP9cwCRoAAJgOAQgAAJgOAQhOZbVa9dprr8lqtRpdCiCJYxJlE8dl6WMSNAAAMB1GgAAAgOkQgAAAgOkQgAAAgOkQgAAAKGWXL19WZmam/fXx48cVExOjNWvWGFiVuRCA4HAbNmzQ008/rdatW+vkyZOSpI8//lgbN240uDKY0e+//66oqCjVrFlTbm5ucnV1LfAFGKFr165auHChJCktLU333nuv3n33XXXt2lWzZ882uDpz4E7QcKjly5crKipKTz31lHbu3Kns7GxJV5/LMnHiRK1atcrgCmE2ffv21YkTJzRmzBjVqFGDx9ugTNixY4emTZsmSVq2bJkCAgK0c+dOLV++XGPHjtVzzz1ncIXlHwEIDvXGG2/ogw8+UO/evbV48WJ7e5s2bTR+/HgDK4NZbdy4URs2bFDTpk2NLgWwy8zMVMWKFSVJa9as0V//+le5uLioVatWOn78uMHVmQOnwOBQ+/fvV/v27Qu1+/r6Ki0trfQLgukFBgaK252hrKlfv74+//xzJSUl6bvvvlNkZKQk6dSpUzwLrJQQgOBQNWrU0KFDhwq1b9y4UXfeeacBFcHsYmJiNHLkSB07dszoUgC7sWPHavjw4apbt65atmyp1q1bS7o6GtSsWTODqzMH7gQNh5o8ebIWLFigefPmqXPnzlq1apWOHz+uoUOHauzYsXr++eeNLhEmU7lyZWVmZio3N1deXl5yd3cvsPzcuXMGVQazS01NVUpKipo0aSIXl6vjEdu2bZOvr69CQkIMrq78IwDB4UaPHq1p06YpKytL0tVn3AwfPlwTJkwwuDKY0YIFC264vE+fPqVUCVDYoUOHdPjwYbVv316enp6y2WxM1C8lBCA4RWZmpvbu3av8/HyFhobKx8fH6JIAoMw4e/asevToobVr18pisejgwYO68847NWDAAFWqVEnvvvuu0SWWe8wBglMkJyfr7Nmzaty4sXx8fJiECkPl5eVp+fLleuONN/Tmm29q5cqVysvLM7osmNjQoUPl7u6uEydOyMvLy97es2dPrV692sDKzIPL4OFQ1/ur5plnnuGvGhji0KFD+stf/qKTJ0/qrrvuks1m04EDBxQYGKhvvvlG9erVM7pEmNCaNWv03XffqXbt2gXaGzRowGXwpYQRIDgUf9WgrHnxxRdVr149JSUlaceOHdq5c6dOnDih4OBgvfjii0aXB5O6dOlSgZ+R15w5c0ZWq9WAisyHAASHWrNmjd5++23+qkGZsW7dOk2ePFn+/v72tipVquitt97SunXrDKwMZta+fXv7ozAkyWKxKD8/X1OmTFHHjh0NrMw8OAUGh+KvGpQ1VqtVFy9eLNSekZGhChUqGFARIE2ZMkX333+/tm/fritXrugf//iH9uzZo3Pnzunnn382ujxTYAQIDsVfNShrHnnkEQ0cOFBbt26VzWaTzWbTli1bNGjQIHXp0sXo8mBSoaGh+te//qWWLVuqc+fOunTpkv76179q586dzEsrJVwGD4fau3ev7r//fkVEROjHH39Uly5dCvxVw39slLa0tDT16dNHX331lf0miLm5uerSpYtiY2Pl5+dncIUAjEAAgsOlpqZq9uzZio+PV35+vsLDw/X3v/9dNWrUMLo0mNjBgweVmJgom82m0NBQ1a9f3+iSYGJ169ZV//791a9fPwUGBhpdjikRgOAwOTk5ioyM1IcffqiGDRsaXQ4AlFkzZ85UbGysdu3apY4dO2rAgAF69NFHmStZighAcKg77rhDmzZtUoMGDYwuBSYWHR2tCRMmyNvbW9HR0TfsO3Xq1FKqCihs165dmjdvnhYtWqTc3Fz16tVL/fv3V3h4uNGllXsEIDjUsGHD5O7urrfeesvoUmBiHTt21MqVK1WpUqUbTr63WCz68ccfS7EyoGg5OTmaNWuWXn75ZeXk5CgsLEwvvfSS+vXrx7PBnIQABId64YUXtHDhQtWvX1/NmzeXt7d3geX8tQ0A/5GTk6OVK1dq/vz5iouLU6tWrTRgwAAlJyfrvffeU8eOHfXpp58aXWa5xH2A4BCurq5KSUnRr7/+ah+6PXDgQIE+/BWDsiA9PV0//vijQkJCFBISYnQ5MKkdO3Zo/vz5WrRokVxdXRUVFaVp06YVOCYjIyPVvn17A6ss3whAcIhrA4lr1641uBKgoB49eqh9+/Z6/vnndfnyZTVv3lzHjh2TzWbT4sWL9dhjjxldIkyoRYsW6ty5s2bPnq1u3brZb9Hw30JDQ/XEE08YUJ05EIAAlGvr16/X6NGjJUkrV66UzWZTWlqaFixYoDfeeIMABEMcOXJEQUFBN+zj7e2t+fPnl1JF5kMAgsN89913f3hTOe68i9J24cIF+3PAVq9erccee0xeXl56+OGHNWLECIOrg1n9UfiB8xGA4DB9+vS54XKLxaK8vLxSqga4KjAwUJs3b5a/v79Wr16txYsXS5LOnz8vDw8Pg6uDWeXl5WnatGn67LPPdOLECV25cqXA8nPnzhlUmXnwLDA4TGpqqvLz86/7RfiBEYYMGaKnnnpKtWvXVs2aNXX//fdLunpqrHHjxsYWB9MaN26cpk6dqh49eujChQuKjo7WX//6V7m4uOj11183ujxT4DJ4OMS1q8CqVatmdClAIdu3b1dSUpI6d+4sHx8fSdI333yjSpUqqW3btgZXBzOqV6+eZsyYoYcfflgVK1ZUQkKCvW3Lli1c+l4KCEBwCBcXF6WmphKAUObl5eVp9+7dCgoKUuXKlY0uBybl7e2tffv2qU6dOqpRo4a++eYbhYeH68iRI2rWrJkuXLhgdInlHqfA4BB9+vSRp6en0WUAhQwZMkRz586VdDX8dOjQQeHh4QoMDNRPP/1kbHEwrdq1ayslJUWSVL9+fa1Zs0aS9Msvv/A8sFJCAIJDzJ8/XxUrVjS6DKCQZcuWqUmTJpKkr776SkePHlViYqKGDBlivzweKG2PPvqofvjhB0nSSy+9pDFjxqhBgwbq3bu3+vfvb3B15sApMADlmoeHhw4dOqTatWtr4MCB8vLyUkxMjI4ePaomTZooPT3d6BIBbdmyRZs2bVL9+vW5XUgp4TJ4AOVaQECA9u7dqxo1amj16tWaNWuWJCkzM1Ourq4GVwdc1apVK7Vq1croMkyFAASgXOvXr5969OihGjVqyGKxqHPnzpKkrVu38iwwGObs2bOqUqWKJCkpKUkfffSRLl++rC5duqhdu3YGV2cOnAIDUO4tW7ZMSUlJevzxx1W7dm1J0oIFC1SpUiV17drV4OpgJrt379b//d//KSkpSQ0aNNDixYv15z//WZcuXZKLi4suXbqkZcuWqVu3bkaXWu4RgOBQly5d0ltvvaUffvhBp06dUn5+foHlR44cMagyQMrKyuLuzzDUQw89JDc3N7388sv6f//v/+nrr79WZGSk5syZI0l64YUXFB8fry1bthhcaflHAIJDPfnkk1q3bp2ioqLspxz+20svvWRQZTCrvLw8TZw4UR988IF+//13HThwQHfeeafGjBmjunXrasCAAUaXCBOpWrWqfvzxR91zzz3KyMiQr6+vtm3bpubNm0uSEhMT1apVK6WlpRlbqAkwBwgO9e233+qbb77h7rooM958800tWLBAkydP1t/+9jd7e+PGjTVt2jQCEErVuXPnVL16dUmSj4+PvL297Q/rlaTKlSvr4sWLRpVnKtwHCA5VuXLlAv+ZAaMtXLhQ//znP/XUU08VuOrrnnvuUWJiooGVwaz+d2T8f1+jdDACBIeaMGGCxo4dqwULFsjLy8vocgCdPHlS9evXL9Sen5+vnJwcAyqC2fXt29d+t+esrCwNGjRI3t7ekqTs7GwjSzMVAhAc6t1339Xhw4cVEBCgunXryt3dvcDyHTt2GFQZzOruu+/Whg0bFBQUVKB96dKlatasmUFVwaz69OlT4PXTTz9dqE/v3r1LqxxTIwDBobh0E2XNa6+9pqioKJ08eVL5+flasWKF9u/fr4ULF+rrr782ujyYzPz5840uAf/GVWAAyr3vvvtOEydOVHx8vPLz8xUeHq6xY8cqMjLS6NIAGIQABKeIj4/Xvn37ZLFYFBoayqkGGCI3N1dvvvmm+vfvr8DAQKPLAVCGEIDgUKdOndITTzyhn376SZUqVZLNZtOFCxfUsWNHLV68WHfccYfRJcJkfHx89Ouvv6pu3bpGlwKgDOEyeDjUCy+8oPT0dO3Zs0fnzp3T+fPn9euvvyo9PV0vvvii0eXBhDp16qSffvrJ6DIAlDGMAMGh/Pz89P3336tFixYF2rdt26bIyEjubopS9+GHH+r111/XU089pYiICPvlxtd06dLFoMoAGImrwOBQ+fn5hS59lyR3d/dCzwUDSsNzzz0nSZo6dWqhZRaLRXl5eaVdEiBJ+vjjj/XBBx/o6NGj2rx5s4KCghQTE6Pg4GAe0lsKOAUGh3rggQf00ksvKTk52d528uRJDR06VH/6058MrAxmlZ+ff90vwg+MMnv2bEVHR+svf/mL0tLS7MdipUqVFBMTY2xxJkEAgkO99957unjxourWrat69eqpfv36Cg4O1sWLFzVz5kyjywOAMmHmzJn66KOPNHr06AKPaGnevLl2795tYGXmwSkwOFRgYKB27NihuLg4JSYmymazKTQ0VJ06dTK6NJjUjBkzimy3WCzy8PBQ/fr11b59+wK/hABnO3r0aJG3B7Farbp06ZIBFZkPAQhO0blzZ3Xu3NnoMgBNmzZNp0+fVmZmpipXriybzaa0tDR5eXnJx8dHp06d0p133qm1a9dyryCUmuDgYCUkJBR6RMu3336r0NBQg6oyFwIQbtmMGTM0cOBAeXh4XPev7Wu4FB6lbeLEifrnP/+pOXPmqF69epKkQ4cO6dlnn9XAgQPVtm1bPfHEExo6dKiWLVtmcLUwixEjRujvf/+7srKyZLPZtG3bNi1atEiTJk3SnDlzjC7PFLgMHrcsODhY27dvV5UqVRQcHHzdfhaLRUeOHCnFygCpXr16Wr58uZo2bVqgfefOnXrsscd05MgRbdq0SY899phSUlKMKRKm9NFHH+mNN95QUlKSJKlWrVp6/fXXNWDAAIMrMwcCEIByzcvLS+vXr1fz5s0LtP/yyy/q0KGDMjMzdezYMYWFhSkjI8OgKmFmZ86cUX5+vqpVq2Z0KabCVWBwqry8PCUkJOj8+fNGlwKT6tixo5599lnt3LnT3rZz504999xzeuCBByRJu3fvvuHoJeBo48aN0+HDhyVJVatWJfwYgAAEhxoyZIjmzp0r6Wr4ad++vcLDwxUYGMjjCGCIuXPnyt/fXxEREbJarbJarWrevLn8/f3tx6qPj4/effddgyuFmSxfvlwNGzZUq1at9N577+n06dNGl2Q6nAKDQ9WuXVuff/65mjdvrs8//1x///vftXbtWi1cuFBr167Vzz//bHSJMKnExEQdOHBANptNISEhuuuuu4wuCSa3Z88effLJJ1q8eLF+++03derUSU8//bS6desmLy8vo8sr9whAcCgPDw8dOnRItWvX1sCBA+Xl5aWYmBgdPXpUTZo0UXp6utElwqSuXLmio0ePql69enJz4wJYlC0///yzPv30Uy1dulRZWVn8rCwFnAKDQwUEBGjv3r3Ky8vT6tWr7TdAzMzM5EZzMERmZqYGDBggLy8v3X333Tpx4oSkq7dkeOuttwyuDrjK29tbnp6eqlChgnJycowuxxQIQHCofv36qUePHgoLC5PFYrHfDHHr1q0KCQkxuDqY0ahRo7Rr1y799NNP8vDwsLd36tRJS5YsMbAymN3Ro0f15ptvKjQ0VM2bN9eOHTv0+uuvKzU11ejSTIFxYDjU66+/rrCwMCUlJenxxx+X1WqVJLm6umrkyJEGVwcz+vzzz7VkyRK1atVKFovF3h4aGmq/Cgcoba1bt9a2bdvUuHFj9evXT7169VKtWrWMLstUCEBwuO7duxdq69OnjwGVANLp06eLvMT40qVLBQIRUJo6duyoOXPm6O677za6FNMiAOGW8SgMlGUtWrTQN998oxdeeEGS7KHno48+UuvWrY0sDSY2ceJEo0swPa4Cwy3jURgoyzZt2qQ///nPeuqppxQbG6tnn31We/bs0ebNm7Vu3TpFREQYXSJMIjo6WhMmTJC3t7eio6Nv2Hfq1KmlVJV5MQKEW3b06NEi/w2UBW3atNHPP/+sd955R/Xq1dOaNWsUHh6uzZs3q3HjxkaXBxPZuXOn/Qqv/74z+f/i1GzpYAQIgGktW7asyDlrAMo/LoOHQ3Xv3r3Ie6tMmTJFjz/+uAEVwcxyc3O1Z88eHThwoED7F198oSZNmuipp54yqDIARmMECA51xx136Mcffyx0amH37t3q1KmTfv/9d4Mqg9ns3btXjzzyiI4fPy5J6tq1q2bPnq0ePXpo165deuaZZ/TSSy8pMDDQ4EphVr/88ouWLl2qEydO6MqVKwWWrVixwqCqzIMRIDhURkaGKlSoUKjd3d2dW7ujVI0cOVLBwcH64osv1KNHD33++edq166d/vSnPykpKUnvvPMO4QeGWbx4sdq2bau9e/dq5cqVysnJ0d69e/Xjjz/Kz8/P6PJMgQAEhwoLCyvy7rqLFy9WaGioARXBrLZt26YpU6bokUce0ezZsyVJI0aM0NixY1WxYkWDq4PZTZw4UdOmTdPXX3+tChUqaPr06dq3b5969OihOnXqGF2eKXAVGBxqzJgxeuyxx3T48GE98MADkqQffvhBixYt0tKlSw2uDmZy6tQp+511K1WqJC8vL3Xo0MHgqoCrDh8+rIcffliSZLVa7TfmHDp0qB544AGNGzfO4ArLP0aA4FBdunTR559/rkOHDmnw4MEaNmyYfvvtN33//ffq1q2b0eXBRCwWi1xc/vMjzsXFRe7u7gZWBPyHv7+/Ll68KEmqVauWfv31V0lSWlqaMjMzjSzNNJgEDaBccnFxkZ+fn/2eKmlpafL19S0QiiTp3LlzRpQHk+vVq5eaN2+u6Ohovfnmm5o+fbq6du2quLg4hYeHMwm6FBCA4HBpaWlatmyZjhw5ouHDh8vf3187duxQQEAAD/tDqVmwYEGx+vGcOhjh3LlzysrKUs2aNZWfn6933nlHGzduVP369TVmzBhVrlzZ6BLLPQIQHOpf//qXOnXqJD8/Px07dkz79+/XnXfeqTFjxuj48eNauHCh0SUCAMAcIDhWdHS0+vbtq4MHD8rDw8Pe/tBDD2n9+vUGVgYAwH9wFRgc6pdfftGHH35YqL1WrVpKTU01oCIAKDtcXFz+8FlfFotFubm5pVSReRGA4FAeHh5F3vBw//79uuOOOwyoCADKjpUrV1532aZNmzRz5kwxM6V0MAcIDjVw4ECdPn1an332mfz9/fWvf/1Lrq6u6tatm9q3b6+YmBijSwSAMiUxMVGjRo3SV199paeeekoTJkzgZoilgDlAcKh33nlHp0+fVrVq1XT58mV16NBB9evXV8WKFfXmm28aXR4AlBnJycn629/+pnvuuUe5ublKSEjQggULCD+lhBEgOMWPP/6oHTt2KD8/X+Hh4erUqZPRJcGkunfvrubNm2vkyJEF2qdMmaJt27Zxh3KUugsXLmjixImaOXOmmjZtqrffflvt2rUzuizTIQABKNfuuOMO/fjjj2rcuHGB9t27d6tTp076/fffDaoMZjR58mS9/fbbql69uiZOnKiuXbsaXZJpEYDgMPn5+YqNjdWKFSt07NgxWSwWBQcHq3v37oqKivrDKx8AZ/D09FRCQoLuuuuuAu2JiYlq1qyZLl++bFBlMCMXFxd5enqqU6dOcnV1vW4/7gTtfFwFBoew2Wzq0qWLVq1apSZNmqhx48ay2Wzat2+f+vbtqxUrVujzzz83ukyYUFhYmJYsWaKxY8cWaF+8eLFCQ0MNqgpm1bt3b/4YLCMIQHCI2NhYrV+/Xj/88IM6duxYYNmPP/6obt26aeHCherdu7dBFcKsxowZo8cee0yHDx/WAw88IEn64YcftGjRIub/oNTFxsYaXQL+jVNgcIjIyEg98MADhSaaXjNx4kStW7dO3333XSlXBkjffPONJk6cqISEBHl6euqee+7Ra6+9pg4dOhhdGgCDEIDgENWrV9fq1avVtGnTIpfv3LlTDz30EHeDBgCUCdwHCA5x7tw5BQQEXHd5QECAzp8/X4oVAQBwfcwBgkPk5eXJze36h5OrqyvPtkGp8ff314EDB1S1alVVrlz5hpNOz507V4qVASgrCEBwCJvNpr59+8pqtRa5PDs7u5QrgplNmzZNFStWtP+bq24A/C/mAMEh+vXrV6x+8+fPd3IlAAD8MQIQgHLN1dVVKSkpqlatWoH2s2fPqlq1asrLyzOoMgBGYhI0gHLten/jZWdnq0KFCqVcDYCygjlAAMqlGTNmSJIsFovmzJkjHx8f+7K8vDytX79eISEhRpUHwGCcAgNQLgUHB0uSjh8/rtq1axd47lKFChVUt25djR8/Xvfee69RJQIwEAEIQLnWsWNHrVixQpUrVza6FABlCAEIgKnk5eVp9+7dCgoKIhQBJsYkaADl2pAhQzR37lxJV8NP+/btFR4ersDAQP3000/GFgfAMAQgAOXa0qVL1aRJE0nSV199pWPHjikxMVFDhgzR6NGjDa4OgFEIQADKtbNnz6p69eqSpFWrVunxxx9Xw4YNNWDAAO3evdvg6gAYhQAEoFwLCAjQ3r17lZeXp9WrV6tTp06SpMzMzAJXhgEwF+4DBKBc69evn3r06KEaNWrIYrGoc+fOkqStW7dyHyDAxAhAAMq1119/XWFhYUpKStLjjz9uf2Cvq6urRo4caXB1AIzCZfAAAMB0GAECUO7MmDFDAwcOlIeHh/2RGNfz4osvllJVAMoSRoAAlDvBwcHavn27qlSpYn8kRlEsFouOHDlSipUBKCsIQAAAwHS4DB4AAJgOc4AAlGvR0dFFtlssFnl4eKh+/frq2rWr/P39S7kyAEbiFBiAcq1jx47asWOH8vLydNddd8lms+ngwYNydXVVSEiI9u/fL4vFoo0bNyo0NNTocgGUEk6BASjXunbtqk6dOik5OVnx8fHasWOHTp48qc6dO+vJJ5/UyZMn1b59ew0dOtToUgGUIkaAAJRrtWrVUlxcXKHRnT179igyMlInT57Ujh07FBkZqTNnzhhUJYDSxggQgHLtwoULOnXqVKH206dPKz09XZJUqVIlXblypbRLA2AgAhCAcq1r167q37+/Vq5cqd9++00nT57UypUrNWDAAHXr1k2StG3bNjVs2NDYQgGUKk6BASjXMjIyNHToUC1cuFC5ubmSJDc3N/Xp00fTpk2Tt7e3EhISJElNmzY1rlAApYoABMAUMjIydOTIEdlsNtWrV08+Pj5GlwTAQNwHCIAp+Pj4yN/fXxaLhfADgDlAAMq3/Px8jR8/Xn5+fgoKClKdOnVUqVIlTZgwQfn5+UaXB8AgjAABKNdGjx6tuXPn6q233lLbtm1ls9n0888/6/XXX1dWVpbefPNNo0sEYADmAAEo12rWrKkPPvhAXbp0KdD+xRdfaPDgwTp58qRBlQEwEqfAAJRr586dU0hISKH2kJAQnTt3zoCKAJQFBCAA5VqTJk303nvvFWp/77331KRJEwMqAlAWcAoMQLm2bt06Pfzww6pTp45at24ti8WiTZs2KSkpSatWrVK7du2MLhGAAQhAAMq95ORkvf/++0pMTJTNZlNoaKgGDx6smjVrGl0aAIMQgACYUlJSkl577TXNmzfP6FIAGIAABMCUdu3apfDwcOXl5RldCgADMAkaAACYDgEIAACYDgEIAACYDo/CAFAu/fWvf73h8rS0tNIpBECZRAACUC75+fn94fLevXuXUjUAyhquAgMAAKbDHCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAAGA6BCAAt71jx47JYrEoISGhzGzr/vvv15AhQ5xeD4CbQwACcEv69u0ri8WiQYMGFVo2ePBgWSwW9e3bt0D/bt26lXg7v/32mypUqKCQkJBbqPbWBQYGKiUlRWFhYZKkn376SRaLhRsrArcZAhCAWxYYGKjFixfr8uXL9rasrCwtWrRIderUccg2YmNj1aNHD2VmZurnn392yDpL6sqVK3J1dVX16tXl5sZ9ZIHbGQEIwC0LDw9XnTp1tGLFCnvbihUrFBgYqGbNmt3y+m02m+bPn6+oqCj16tVLc+fO/cP3fPnll2rQoIE8PT3VsWNHLViwoNBIzfLly3X33XfLarWqbt26evfddwuso27dunrjjTfUt29f+fn56W9/+1uBU2DHjh1Tx44dJUmVK1cuNNqVn5+vf/zjH/L391f16tX1+uuvF1i/xWLRhx9+qEceeUReXl5q1KiRNm/erEOHDun++++Xt7e3WrdurcOHD9/0ZwegaAQgAA7Rr18/zZ8/3/563rx56t+/v0PWvXbtWmVmZqpTp06KiorSZ599posXL163/7Fjx9S9e3d169ZNCQkJevbZZzV69OgCfeLj49WjRw898cQT2r17t15//XWNGTNGsbGxBfpNmTJFYWFhio+P15gxYwosCwwM1PLlyyVJ+/fvV0pKiqZPn25fvmDBAnl7e2vr1q2aPHmyxo8fr7i4uALrmDBhgnr37q2EhASFhISoV69eevbZZzVq1Cht375dkvT888+X+DMD8AdsAHAL+vTpY+vatavt9OnTNqvVajt69Kjt2LFjNg8PD9vp06dtXbt2tfXp06dQ/5Lo1auXbciQIfbXTZo0sX300Uf210ePHrVJsu3cudNms9lsL7/8si0sLKzAOkaPHm2TZDt//rx9nZ07dy7QZ8SIEbbQ0FD766CgIFu3bt0K9Pnfba1du7bAeq/p0KGD7b777ivQ1qJFC9vLL79sfy3J9uqrr9pfb9682SbJNnfuXHvbokWLbB4eHkV9LABuASNAAByiatWqevjhh7VgwQLNnz9fDz/8sKpWrXrL601LS9OKFSv09NNP29uefvppzZs377rv2b9/v1q0aFGgrWXLlgVe79u3T23bti3Q1rZtWx08eFB5eXn2tubNm9907ffcc0+B1zVq1NCpU6eu2ycgIECS1Lhx4wJtWVlZSk9Pv+k6ABTGLD4ADtO/f3/76Zr333/fIev89NNPlZWVpXvvvdfeZrPZlJ+fr7179yo0NLTQe2w2mywWS6G2kvaRJG9v75uu3d3dvcBri8Wi/Pz86/a5Vk9Rbf/7PgC3hhEgAA7z5z//WVeuXNGVK1f04IMPOmSdc+fO1bBhw5SQkGD/2rVrlzp27HjdUaCQkBD98ssvBdquzae5JjQ0VBs3bizQtmnTJjVs2FCurq7Frq9ChQqSVGDUCEDZxwgQAIdxdXXVvn377P++ngsXLhS6kaC/v3+hS+YTEhK0Y8cOffLJJ4Xu//Pkk09q9OjRmjRpUqH1P/vss5o6dapefvllDRgwQAkJCfbJzddGVIYNG6YWLVpowoQJ6tmzpzZv3qz33ntPs2bNKtE+BwUFyWKx6Ouvv9Zf/vIXeXp6ysfHp0TrAFD6GAEC4FC+vr7y9fW9YZ+ffvpJzZo1K/A1duzYQv3mzp2r0NDQIm9+2K1bN507d05fffVVoWXBwcFatmyZVqxYoXvuuUezZ8+2XwVmtVolXb10/7PPPtPixYsVFhamsWPHavz48QUuYy+OWrVqady4cRo5cqQCAgK4Ygu4TVhsRZ30BoBy5s0339QHH3ygpKQko0sBUAZwCgxAuTRr1iy1aNFCVapU0c8//6wpU6YwOgPAjgAEoFw6ePCg3njjDZ07d0516tTRsGHDNGrUKKPLAlBGcAoMAACYDpOgAQCA6RCAAACA6RCAAACA6RCAAACA6RCAAACA6RCAAACA6RCAAACA6RCAAACA6RCAAACA6fx/OId8faywMGMAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "if not targetDataName == 'None': # User specified one analyzed dataset above (if more than one were analyzed)\n", - " for each in datasets:\n", - " if not each == targetDataName:\n", - " datasets.remove(each)\n", - " print(\"Vizualized Datasets: \"+str(datasets))\n", - "\n", - "for each in datasets: #each analyzed dataset to make plots for\n", - " print(\"---------------------------------------\")\n", - " print(each)\n", - " print(\"---------------------------------------\")\n", - " full_path = experiment_path+'/'+each\n", - " #Create folder for tree vizualization files\n", - " original_headers = pd.read_csv(full_path+\"/exploratory/ProcessedFeatureNames.csv\",sep=',').columns.values.tolist() #Get Original Headers\n", - " metric_dict = {}\n", - " for algorithm in algorithms: #loop through algorithms\n", - " # Define evaluation stats variable lists\n", - " s_bac = [] # balanced accuracies\n", - " s_ac = [] # standard accuracies\n", - " s_f1 = [] # F1 scores\n", - " s_re = [] # recall values\n", - " s_sp = [] # specificities\n", - " s_pr = [] # precision values\n", - " s_tp = [] # true positives\n", - " s_tn = [] # true negatives\n", - " s_fp = [] # false positives\n", - " s_fn = [] # false negatives\n", - " s_npv = [] # negative predictive values\n", - " s_lrp = [] # likelihood ratio positive values\n", - " s_lrm = [] # likelihood ratio negative values\n", - " # Define ROC plot variable lists\n", - " aucs = [] #areas under ROC curve\n", - " # Define PRC plot variable lists\n", - " praucs = [] #area under PRC curve\n", - " aveprecs = [] #average precisions for PRC\n", - " \n", - " for cvCount in range(0,cv_partitions): #loop through cv's\n", - " #load testing data\n", - " test_file_path = full_path + '/CVDatasets/' + each + \"_CV_\" + str(cvCount) + \"_Test.csv\"\n", - " test = pd.read_csv(test_file_path)\n", - " testY = test[class_label].values\n", - " del test #memory cleanup\n", - " \n", - " #Load pickled metric file for given algorithm and cv\n", - " result_file = full_path+'/model_evaluation/pickled_metrics/'+abbrev[algorithm]+\"_CV_\"+str(cvCount)+\"_metrics.pickle\"\n", - " file = open(result_file, 'rb')\n", - " results = pickle.load(file)\n", - " file.close()\n", - " \n", - " #load probas_ for model file\n", - " probas_ = results[9]\n", - "\n", - " #Get new class predictions given specified decision threshold\n", - " y_pred = probas_[:,1] > threshold\n", - "\n", - " integer_map = map(int, y_pred) \n", - " integer_list = list(integer_map)\n", - "\n", - " #Calculate standard classificaction metrics\n", - " metricList = classEval(testY, y_pred)\n", - " \n", - " # Compute ROC curve and area the curve\n", - " fpr, tpr, thresholds = metrics.roc_curve(testY, probas_[:, 1])\n", - " roc_auc = auc(fpr, tpr)\n", - " \n", - " # Compute Precision/Recall curve and AUC\n", - " prec, recall, thresholds = metrics.precision_recall_curve(testY, probas_[:, 1])\n", - " prec, recall, thresholds = prec[::-1], recall[::-1], thresholds[::-1]\n", - " prec_rec_auc = auc(recall, prec)\n", - " ave_prec = metrics.average_precision_score(testY, probas_[:, 1])\n", - "\n", - " #Separate metrics from metricList\n", - " s_bac.append(metricList[0])\n", - " s_ac.append(metricList[1])\n", - " s_f1.append(metricList[2])\n", - " s_re.append(metricList[3])\n", - " s_sp.append(metricList[4])\n", - " s_pr.append(metricList[5])\n", - " s_tp.append(metricList[6])\n", - " s_tn.append(metricList[7])\n", - " s_fp.append(metricList[8])\n", - " s_fn.append(metricList[9])\n", - " s_npv.append(metricList[10])\n", - " s_lrp.append(metricList[11])\n", - " s_lrm.append(metricList[12])\n", - " aucs.append(roc_auc)\n", - " praucs.append(prec_rec_auc)\n", - " aveprecs.append(ave_prec)\n", - " \n", - " #Export and save all CV metric stats for each individual algorithm -----------------------------------------------------------------------------\n", - " results = {'Balanced Accuracy': s_bac, 'Accuracy': s_ac, 'F1 Score': s_f1, 'Sensitivity (Recall)': s_re, 'Specificity': s_sp,'Precision (PPV)': s_pr, 'TP': s_tp, 'TN': s_tn, 'FP': s_fp, 'FN': s_fn, 'NPV': s_npv, 'LR+': s_lrp, 'LR-': s_lrm, 'ROC AUC': aucs,'PRC AUC': praucs, 'PRC APS': aveprecs}\n", - " dr = pd.DataFrame(results)\n", - " filepath = full_path+'/model_evaluation/'+abbrev[algorithm]+\"_performance\"+name_modifier+\".csv\"\n", - " dr.to_csv(filepath, header=True, index=False)\n", - " \n", - " #add to metric list\n", - " metric_dict[algorithm] = results\n", - "\n", - " #Make list of metric names\n", - " my_metrics = list(metric_dict[algorithms[0]].keys())\n", - " \n", - " #Save metric means and standard deviations\n", - " saveMetricMeans(full_path,my_metrics,metric_dict,name_modifier)\n", - " saveMetricStd(full_path,my_metrics,metric_dict,name_modifier)\n", - " \n", - " #Generate boxplots comparing algorithm performance for each standard metric, if specified by user\n", - " if plot_metric_boxplots:\n", - " metricBoxplots(full_path,my_metrics,algorithms,metric_dict,name_modifier) \n", - " \n", - " #Calculate and export Kruskal Wallis, Mann Whitney, and wilcoxon Rank sum stats if more than one ML algorithm has been run (for the comparison) - note stats are based on comparing the multiple CV models for each algorithm.\n", - " if run_sig_test:\n", - " if len(algorithms) > 1:\n", - " kruskal_summary = kruskalWallis(full_path,my_metrics,algorithms,metric_dict,sig_cutoff,name_modifier)\n", - " wilcoxonRank(full_path,my_metrics,algorithms,metric_dict,kruskal_summary,sig_cutoff,name_modifier)\n", - " mannWhitneyU(full_path,my_metrics,algorithms,metric_dict,kruskal_summary,sig_cutoff,name_modifier)\n", - " " - ] - } - ], - "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.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/UsefulNotebooks/DecisionThreshold_TrainEval.ipynb b/UsefulNotebooks/DecisionThreshold_TrainEval.ipynb deleted file mode 100644 index aebb950d..00000000 --- a/UsefulNotebooks/DecisionThreshold_TrainEval.ipynb +++ /dev/null @@ -1,1712 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Useful Notebook: Re-Evaluate Models Training Data Performance Using an Alternative Decision Threshold\n", - "**This notebook will allow users to (1) re-evaluate all trained models on respective training datasets using the standard decision threshold of 0.5 or some other threshold, (2) re-generate metric evaluation boxplots comparing algorithm performance using this new decision threshold, and (3) re-run statistical significance analyses comparing algorithm performance using this new decision threshold.**\n", - "\n", - "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", - "\n", - "***\n", - "## Notebook Details\n", - "Allows users to specify alternative decision thresholds (rather than the standard 0.5 probability) and re-evaluate algorithm performane metrics.\n", - "\n", - "Unlike the main pipeline all results output by this notebook are based on the training performance. This script can be used to evaluate and report training data evaluation metrics using different decision threshold. This notebook can also be used to simply obtain training evaluation metrics for the entire pipeline that correspond to the testing output by setting the threshold parameter to 0.5. \n", - "\n", - "All files will be saved in a single new folder in the experiment folder for each target dataset (i.e. `model_training_evaluation`). Also outputs new metric boxplots, ROC, and PRC plots, but now for training performance rather than testing performance.\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Notebook Run Parameters\n", - "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed).\n", - "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "experiment_path = \"../DemoOutput/demo_experiment\" # path the target experiment folder \n", - "targetDataName = None # 'None' if user wants to generate visualizations for all analyzed datasets or specify (str) list of target dataset names\n", - "algorithms = [] # use empty list if user wishes re-evaluate all modeling algorithms that were run in pipeline.\n", - "threshold = 0.5 # Threshold of case probability used to predict case (typically 0.5 by default in modeling)\n", - "plot_metric_boxplots = True #Plot new boxplots for each metric using new threshold.\n", - "run_sig_test = True # Rerun non-parametric significance testing between all algorithms for each metric.\n", - "name_modifier = '_T_'+str(threshold) # Modifies names of stats files to avoid overwriting originals (This can be left as is or altered)\n", - "plot_ROC = True #Plot ROC for training data \n", - "plot_PRC = True #Plot PRC for training data\n", - "#available_algorithms = ['Naive Bayes','Logistic Regression','Decision Tree','Random Forest','Gradient Boosting','XGB','LGB','SVM','ANN','K Neighbors','eLCS','XCS','ExSTraCS']" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Housekeeping\n", - "### Import Packages" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import pandas as pd\n", - "import pickle\n", - "import copy\n", - "from statistics import mean,stdev\n", - "import numpy as np\n", - "from scipy import interp,stats\n", - "# Evalutation metrics\n", - "from sklearn.metrics import accuracy_score\n", - "from sklearn.metrics import balanced_accuracy_score\n", - "from sklearn.metrics import recall_score\n", - "from sklearn.metrics import confusion_matrix\n", - "from sklearn.metrics import precision_score\n", - "from sklearn.metrics import f1_score\n", - "from sklearn.metrics import roc_curve, auc, precision_recall_curve\n", - "from sklearn import metrics\n", - "import csv\n", - "import matplotlib.pyplot as plt\n", - "import pickle\n", - "\n", - "import warnings\n", - "warnings.filterwarnings('ignore')\n", - "\n", - "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", - "from IPython.core.interactiveshell import InteractiveShell\n", - "InteractiveShell.ast_node_interactivity = \"all\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Automatically detect data folder names" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Analyzed Datasets: ['hcc_data', 'hcc_data_custom']\n" - ] - } - ], - "source": [ - "# Get dataset paths for all completed dataset analyses in experiment folder\n", - "datasets = os.listdir(experiment_path)\n", - "\n", - "# Name of experiment folder\n", - "experiment_name = experiment_path.split('/')[-1] \n", - "\n", - "datasets = os.listdir(experiment_path)\n", - "remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", - " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs',\n", - " 'KeyFileCopy', 'dask_logs',\n", - " experiment_name + '_STREAMLINE_Report.pdf']\n", - "for text in remove_list:\n", - " if text in datasets:\n", - " datasets.remove(text)\n", - "\n", - "datasets = sorted(datasets) # ensures consistent ordering of datasets\n", - "print(\"Analyzed Datasets: \" + str(datasets))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load other necessary parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Analyzed Datasets: ['hcc_data', 'hcc_data_custom']\n" - ] - } - ], - "source": [ - "# Unpickle metadata from previous phase\n", - "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", - "metadata = pickle.load(file)\n", - "file.close()\n", - "# Load variables specified earlier in the pipeline from metadata\n", - "class_label = metadata['Class Label']\n", - "instance_label = metadata['Instance Label']\n", - "cv_partitions = int(metadata['CV Partitions'])\n", - "sig_cutoff =float(metadata['Statistical Significance Cutoff'])\n", - "primary_metirc = metadata['Primary Metric']\n", - "\n", - "#Unpickle algorithm information from previous phase\n", - "file = open(experiment_path+'/'+\"algInfo.pickle\", 'rb')\n", - "algInfo = pickle.load(file)\n", - "file.close()\n", - "algorithms = []\n", - "abbrev = {}\n", - "colors = {}\n", - "for key in algInfo:\n", - " if algInfo[key][0]: # If that algorithm was used\n", - " algorithms.append(key)\n", - " abbrev[key] = (algInfo[key][1])\n", - " colors[key] = (algInfo[key][2])\n", - "print(\"Analyzed Datasets: \" + str(datasets))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define Necessary Methods" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "def classEval(y_true, y_pred):\n", - " \"\"\" Calculates standard classification metrics including:\n", - " True positives, false positives, true negative, false negatives, standard accuracy, balanced accuracy\n", - " recall, precision, f1 score, negative predictive value, likelihood ratio positive, and likelihood ratio negative\"\"\"\n", - " #Calculate true positive, true negative, false positive, and false negative.\n", - " tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()\n", - " #Calculate Accuracy metrics\n", - " ac = accuracy_score(y_true, y_pred)\n", - " bac = balanced_accuracy_score(y_true, y_pred)\n", - " #Calculate Precision and Recall\n", - " re = recall_score(y_true, y_pred)\n", - " pr = precision_score(y_true, y_pred)\n", - " #Calculate F1 score\n", - " f1 = f1_score(y_true, y_pred)\n", - " # Calculate specificity\n", - " if tn == 0 and fp == 0:\n", - " sp = 0\n", - " else:\n", - " sp = tn / float(tn + fp)\n", - " # Calculate Negative predictive value\n", - " if tn == 0 and fn == 0:\n", - " npv = 0\n", - " else:\n", - " npv = tn/float(tn+fn)\n", - " # Calculate likelihood ratio postive\n", - " if sp == 1:\n", - " lrp = 0\n", - " else:\n", - " lrp = re/float(1-sp)\n", - " # Calculate likeliehood ratio negative\n", - " if sp == 0:\n", - " lrm = 0\n", - " else:\n", - " lrm = (1-re)/float(sp)\n", - " return [bac, ac, f1, re, sp, pr, tp, tn, fp, fn, npv, lrp, lrm]" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "def saveMetricMeans(full_path,metrics,metric_dict,name_modifier):\n", - " \"\"\" Exports csv file with average metric values (over all CVs) for each ML modeling algorithm\"\"\"\n", - " with open(full_path+'/model_training_evaluation/Summary_performance_mean'+name_modifier+'.csv',mode='w', newline=\"\") as file:\n", - " writer = csv.writer(file, delimiter=',', quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n", - " e = ['']\n", - " e.extend(metrics)\n", - " writer.writerow(e) #Write headers (balanced accuracy, etc.)\n", - " for algorithm in metric_dict:\n", - " astats = []\n", - " for l in list(metric_dict[algorithm].values()):\n", - " l = [float(i) for i in l]\n", - " meani = mean(l)\n", - " std = stdev(l)\n", - " astats.append(str(meani))\n", - " toAdd = [algorithm]\n", - " toAdd.extend(astats)\n", - " writer.writerow(toAdd)\n", - " file.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def saveMetricStd(full_path,metrics,metric_dict,name_modifier):\n", - " \"\"\" Exports csv file with metric value standard deviations (over all CVs) for each ML modeling algorithm\"\"\"\n", - " with open(full_path + '/model_training_evaluation/Summary_performance_std'+name_modifier+'.csv', mode='w', newline=\"\") as file:\n", - " writer = csv.writer(file, delimiter=',', quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n", - " e = ['']\n", - " e.extend(metrics)\n", - " writer.writerow(e) # Write headers (balanced accuracy, etc.)\n", - " for algorithm in metric_dict:\n", - " astats = []\n", - " for l in list(metric_dict[algorithm].values()):\n", - " l = [float(i) for i in l]\n", - " std = stdev(l)\n", - " astats.append(str(std))\n", - " toAdd = [algorithm]\n", - " toAdd.extend(astats)\n", - " writer.writerow(toAdd)\n", - " file.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "def metricBoxplots(full_path,metrics,algorithms,metric_dict,name_modifier):\n", - " \"\"\" Export boxplots comparing algorithm performance for each standard metric\"\"\"\n", - " if not os.path.exists(full_path + '/model_training_evaluation/metricBoxplots'):\n", - " os.mkdir(full_path + '/model_training_evaluation/metricBoxplots')\n", - " for metric in metrics:\n", - " tempList = []\n", - " for algorithm in algorithms:\n", - " tempList.append(metric_dict[algorithm][metric])\n", - " td = pd.DataFrame(tempList)\n", - " td = td.transpose()\n", - " td.columns = algorithms\n", - " #Generate boxplot\n", - " boxplot = td.boxplot(column=algorithms,rot=90)\n", - " #Specify plot labels\n", - " plt.ylabel(str(metric))\n", - " plt.xlabel('ML Algorithm')\n", - " #Export and/or show plot\n", - " plt.savefig(full_path + '/model_training_evaluation/metricBoxplots/Compare_'+metric+name_modifier+'.png', bbox_inches=\"tight\")\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def kruskalWallis(full_path,metrics,algorithms,metric_dict,sig_cutoff,name_modifier):\n", - " \"\"\" Apply non-parametric Kruskal Wallis one-way ANOVA on ranks. Determines if there is a statistically significant difference in algorithm performance across CV runs.\n", - " Completed for each standard metric separately.\"\"\"\n", - " # Create directory to store significance testing results (used for both Kruskal Wallis and MannWhitney U-test)\n", - " if not os.path.exists(full_path + '/model_training_evaluation/statistical_comparisons'):\n", - " os.mkdir(full_path + '/model_training_evaluation/statistical_comparisons')\n", - " #Create dataframe to store analysis results for each metric\n", - " label = ['Statistic', 'P-Value', 'Sig(*)']\n", - " kruskal_summary = pd.DataFrame(index=metrics, columns=label)\n", - " #Apply Kruskal Wallis test for each metric\n", - " for metric in metrics:\n", - " tempArray = []\n", - " for algorithm in algorithms:\n", - " tempArray.append(metric_dict[algorithm][metric])\n", - " try:\n", - " result = stats.kruskal(*tempArray)\n", - " except:\n", - " result = [tempArray[0],1]\n", - " kruskal_summary.at[metric, 'Statistic'] = str(round(result[0], 6))\n", - " kruskal_summary.at[metric, 'P-Value'] = str(round(result[1], 6))\n", - " if result[1] < sig_cutoff:\n", - " kruskal_summary.at[metric, 'Sig(*)'] = str('*')\n", - " else:\n", - " kruskal_summary.at[metric, 'Sig(*)'] = str('')\n", - " #Export analysis summary to .csv file\n", - " kruskal_summary.to_csv(full_path + '/model_training_evaluation/statistical_comparisons/KruskalWallis'+name_modifier+'.csv')\n", - " return kruskal_summary" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def wilcoxonRank(full_path,metrics,algorithms,metric_dict,kruskal_summary,sig_cutoff,name_modifier):\n", - " \"\"\" Apply non-parametric Wilcoxon signed-rank test (pairwise comparisons). If a significant Kruskal Wallis algorithm difference was found for a given metric, Wilcoxon tests individual algorithm pairs\n", - " to determine if there is a statistically significant difference in algorithm performance across CV runs. Test statistic will be zero if all scores from one set are\n", - " larger than the other.\"\"\"\n", - " for metric in metrics:\n", - " if kruskal_summary['Sig(*)'][metric] == '*':\n", - " wilcoxon_stats = []\n", - " done = []\n", - " for algorithm1 in algorithms:\n", - " for algorithm2 in algorithms:\n", - " if not [algorithm1,algorithm2] in done and not [algorithm2,algorithm1] in done and algorithm1 != algorithm2:\n", - " set1 = metric_dict[algorithm1][metric]\n", - " set2 = metric_dict[algorithm2][metric]\n", - " #handle error when metric values are equal for both algorithms\n", - " combined = copy.deepcopy(set1)\n", - " combined.extend(set2)\n", - " if all(x==combined[0] for x in combined): #Check if all nums are equal in sets\n", - " report = ['NA',1]\n", - " else: # Apply Wilcoxon Rank Sum test\n", - " report = stats.wilcoxon(set1,set2)\n", - " #Summarize test information in list\n", - " tempstats = [algorithm1,algorithm2,report[0],report[1],'']\n", - " if report[1] < sig_cutoff:\n", - " tempstats[4] = '*'\n", - " wilcoxon_stats.append(tempstats)\n", - " done.append([algorithm1,algorithm2])\n", - " #Export test results\n", - " wilcoxon_stats_df = pd.DataFrame(wilcoxon_stats)\n", - " wilcoxon_stats_df.columns = ['Algorithm 1', 'Algorithm 2', 'Statistic', 'P-Value', 'Sig(*)']\n", - " wilcoxon_stats_df.to_csv(full_path + '/model_training_evaluation/statistical_comparisons/WilcoxonRank_'+metric+name_modifier+'.csv', index=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "def mannWhitneyU(full_path,metrics,algorithms,metric_dict,kruskal_summary,sig_cutoff,name_modifier):\n", - " \"\"\" Apply non-parametric Mann Whitney U-test (pairwise comparisons). If a significant Kruskal Wallis algorithm difference was found for a given metric, Mann Whitney tests individual algorithm pairs\n", - " to determine if there is a statistically significant difference in algorithm performance across CV runs. Test statistic will be zero if all scores from one set are\n", - " larger than the other.\"\"\"\n", - " for metric in metrics:\n", - " if kruskal_summary['Sig(*)'][metric] == '*':\n", - " mann_stats = []\n", - " done = []\n", - " for algorithm1 in algorithms:\n", - " for algorithm2 in algorithms:\n", - " if not [algorithm1,algorithm2] in done and not [algorithm2,algorithm1] in done and algorithm1 != algorithm2:\n", - " set1 = metric_dict[algorithm1][metric]\n", - " set2 = metric_dict[algorithm2][metric]\n", - " #handle error when metric values are equal for both algorithms\n", - " combined = copy.deepcopy(set1)\n", - " combined.extend(set2)\n", - " if all(x==combined[0] for x in combined): #Check if all nums are equal in sets\n", - " report = ['NA',1]\n", - " else: #Apply Mann Whitney U test\n", - " report = stats.mannwhitneyu(set1,set2)\n", - " #Summarize test information in list\n", - " tempstats = [algorithm1,algorithm2,report[0],report[1],'']\n", - " if report[1] < sig_cutoff:\n", - " tempstats[4] = '*'\n", - " mann_stats.append(tempstats)\n", - " done.append([algorithm1,algorithm2])\n", - " #Export test results\n", - " mann_stats_df = pd.DataFrame(mann_stats)\n", - " mann_stats_df.columns = ['Algorithm 1', 'Algorithm 2', 'Statistic', 'P-Value', 'Sig(*)']\n", - " mann_stats_df.to_csv(full_path + '/model_training_evaluation/statistical_comparisons/MannWhitneyU_'+metric+name_modifier+'.csv', index=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "def doPlotROC(result_table,colors,full_path):\n", - " \"\"\" Generate ROC plot comparing average ML algorithm performance (over all CV training/testing sets)\"\"\"\n", - " count = 0\n", - " #Plot curves for each individual ML algorithm\n", - " for i in result_table.index:\n", - " plt.plot(result_table.loc[i]['fpr'],result_table.loc[i]['tpr'], color=colors[i],label=\"{}, AUC={:.3f}\".format(i, result_table.loc[i]['auc']))\n", - " count += 1\n", - " # Set figure dimensions\n", - " plt.rcParams[\"figure.figsize\"] = (6,6)\n", - " # Plot no-skill line\n", - " plt.plot([0, 1], [0, 1], color='orange', linestyle='--', label='No-Skill', alpha=.8)\n", - " #Specify plot axes,labels, and legend\n", - " plt.xticks(np.arange(0.0, 1.1, step=0.1))\n", - " plt.xlabel(\"False Positive Rate\", fontsize=15)\n", - " plt.yticks(np.arange(0.0, 1.1, step=0.1))\n", - " plt.ylabel(\"True Positive Rate\", fontsize=15)\n", - " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", - " #Export and/or show plot\n", - " plt.savefig(full_path+'/model_training_evaluation/Summary_ROC.png', bbox_inches=\"tight\")\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "def doPlotPRC(result_table,colors,full_path,data_name,instance_label,class_label):\n", - " \"\"\" Generate PRC plot comparing average ML algorithm performance (over all CV training/testing sets)\"\"\"\n", - " count = 0\n", - " #Plot curves for each individual ML algorithm\n", - " for i in result_table.index:\n", - " plt.plot(result_table.loc[i]['recall'],result_table.loc[i]['prec'], color=colors[i],label=\"{}, AUC={:.3f}, APS={:.3f}\".format(i, result_table.loc[i]['pr_auc'],result_table.loc[i]['ave_prec']))\n", - " count += 1\n", - " #Estimate no skill line based on the fraction of cases found in the first test dataset\n", - " test = pd.read_csv(full_path+'/CVDatasets/'+data_name+'_CV_0_Train.csv')\n", - " if instance_label != 'None':\n", - " test = test.drop(instance_label, axis=1)\n", - " testY = test[class_label].values\n", - " noskill = len(testY[testY == 1]) / len(testY) # Fraction of cases\n", - " # Plot no-skill line\n", - " plt.plot([0, 1], [noskill, noskill], color='orange', linestyle='--',label='No-Skill', alpha=.8)\n", - " #Specify plot axes,labels, and legend\n", - " plt.xticks(np.arange(0.0, 1.1, step=0.1))\n", - " plt.xlabel(\"Recall (Sensitivity)\", fontsize=15)\n", - " plt.yticks(np.arange(0.0, 1.1, step=0.1))\n", - " plt.ylabel(\"Precision (PPV)\", fontsize=15)\n", - " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", - " #Export and/or show plot\n", - " plt.savefig(full_path+'/model_training_evaluation/Summary_PRC.png', bbox_inches=\"tight\")\n", - " plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Run Training Evaluation and Generate Metric Boxplots and ROC and PRC Plots" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Vizualized Datasets: ['hcc_data_custom']\n", - "---------------------------------------\n", - "hcc_data_custom\n", - "---------------------------------------\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "(-0.05, 1.05)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "(-0.05, 1.05)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Decision Tree')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'False Positive Rate')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'True Positive Rate')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0MAAAIhCAYAAACMi2EKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD+WklEQVR4nOzdd3hUxfrA8e/2mk2ySUgCBEKHICiCBbyCKArqFVERsFCsVxFEij/FAtZgAcQrKngNYEHFqxfUey0gIoKigoqF0CHU9LKbZPue+f2xZMmySUhoocznefYhZ86cc2YPye6+OzPvqIQQAkmSJEmSJEmSpDOMurEbIEmSJEmSJEmS1BhkMCRJkiRJkiRJ0hlJBkOSJEmSJEmSJJ2RZDAkSZIkSZIkSdIZSQZDkiRJkiRJkiSdkWQwJEmSJEmSJEnSGUkGQ5IkSZIkSZIknZFkMCRJkiRJkiRJ0hlJBkOSJEmSJEmSJJ2RZDAkSaeoBQsWoFKpwg+j0UhKSgp9+/Zl2rRpFBQUHNfr5+TkoFKpWLBgQYOOGzVqFOnp6celTXVds/q9qu0xatSoE9ouSZIkSZIal0oIIRq7EZIkNdyCBQu47bbbmD9/Ph07dsTv91NQUMDq1auZP38+Go2GRYsW0a9fv+Nyfa/Xy2+//UabNm1ISkqq93Hbt2/H6XTSrVu349Ku2q5ZWFgY3v7111+57777yMzMpG/fvuHypKQk2rRpc8LaJUmSJElS49I2dgMkSTo6Z511Fj169Ahv33DDDYwfP56//e1vXH/99WzdupXk5ORjfl2DwcCFF17Y4OMaI9ho06ZNxHU9Hg8A7dq1q/M5uN1ujEYjKpXquLdRkiRJkqQTTw6Tk6TTUIsWLZgxYwbl5eXMnTs3Yt+6desYOHAgdrsdo9FIt27d+PDDD6POsW/fPu6++27S0tLQ6/U0bdqUwYMHk5+fD9Q8TK6wsDB8jMFgICkpiYsuuoivv/46XKemYXIej4fJkyfTqlUr9Ho9zZo147777qOsrCyiXnp6On//+9/58ssvOffcczGZTHTs2JF58+Yd3Q3j4LDDpUuXcvvtt5OUlITZbMbr9QKwaNEievbsicViwWq10r9/f3777beo89T3/kqSJEmS1PhkMCRJp6mrrroKjUbDd999Fy5bsWIFF110EWVlZcyZM4dPPvmEc845h6FDh0YENfv27eO8885j8eLFTJgwgS+++IJZs2YRGxtLaWlprdccPnw4S5YsYcqUKSxdupQ333yTfv36UVxcXOsxQggGDRrE9OnTGT58OP/73/+YMGECb731Fpdeemk4GKny+++/M3HiRMaPH88nn3xC165dueOOOyKe59G4/fbb0el0vPPOO3z00UfodDoyMzO56aabyMjI4MMPP+Sdd96hvLyciy++mOzs7PCx9b2/kiRJkiSdJIQkSaek+fPnC0CsXbu21jrJycmiU6dO4e2OHTuKbt26Cb/fH1Hv73//u0hNTRXBYFAIIcTtt98udDqdyM7OrvXcO3fuFICYP39+uMxqtYoHHnigznaPHDlStGzZMrz95ZdfCkC88MILEfUWLVokAPHGG2+Ey1q2bCmMRqPYtWtXuMztdgu73S7+8Y9/1Hnd6lasWCEA8e9//ztcVnU/R4wYEVF39+7dQqvVirFjx0aUl5eXi5SUFDFkyJBwWX3vryRJkiRJJwfZMyRJpzFRLT/Ktm3b2LRpE7fccgsAgUAg/LjqqqvIzc1l8+bNAHzxxRf07duXTp06Neh6559/PgsWLOCZZ57hxx9/xO/3H/aYb775BiAqk9uNN96IxWJh+fLlEeXnnHMOLVq0CG8bjUbat2/Prl27GtTW2txwww0R21999RWBQIARI0ZE3DOj0UifPn349ttvgYbdX0mSJEmSTg4yGJKk01RlZSXFxcU0bdoUIDzXZ9KkSeh0uojH6NGjASgqKgJCc3+aN2/e4GsuWrSIkSNH8uabb9KzZ0/sdjsjRowgLy+v1mOKi4vRarVRGelUKhUpKSlRQ+wSEhKizmEwGHC73Q1ub01SU1Mjtqvu23nnnRd13xYtWhS+Zw25v5IkSZIknRxkNjlJOk3973//IxgMcskllwCQmJgIwOTJk7n++utrPKZDhw5AKMX03r17G3zNxMREZs2axaxZs9i9ezeffvopDz/8MAUFBXz55Zc1HpOQkEAgEKCwsDAiIBJCkJeXx3nnndfgdhyNQzPHVd23jz76iJYtW9Z6XEPuryRJkiRJJwcZDEnSaWj37t1MmjSJ2NhY/vGPfwChD+Lt2rXj999/JzMzs87jr7zySt555x02b958xB/gW7RowZgxY1i+fDnff/99rfUuu+wyXnjhBd59913Gjx8fLv/444+prKzksssuO6LrHyv9+/dHq9Wyffv2qCF01TXk/kqSJEmSdHKQwZAkneL++uuv8NyUgoICVq1aFV50dfHixRG9LXPnzuXKK6+kf//+jBo1imbNmlFSUsLGjRv59ddf+fe//w3AU089xRdffEHv3r155JFH6NKlC2VlZXz55ZdMmDCBjh07RrXD4XDQt29fbr75Zjp27EhMTAxr167lyy+/rLWnBODyyy+nf//+PPTQQzidTi666CL++OMPpk6dSrdu3Rg+fPixv2kNkJ6ezlNPPcWjjz7Kjh07GDBgAPHx8eTn5/Pzzz9jsVh48skngfrfX0mSJEmSTg4yGJKkU9xtt90GgF6vJy4ujk6dOvHQQw9x5513Rs3D6du3Lz///DPPPvssDzzwAKWlpSQkJJCRkcGQIUPC9Zo1a8bPP//M1KlTee655yguLiYpKYm//e1v2O32GtthNBq54IILeOedd8jJycHv99OiRQseeugh/u///q/W9qtUKpYsWcITTzzB/PnzefbZZ0lMTGT48OFkZmZiMBiOwV06OpMnTyYjI4OXX36Z999/H6/XS0pKCueddx733HNPuF59768kSZIkSScHlaiebkqSJEmSJEmSJOkMIbPJSZIkSZIkSZJ0RpLBkCRJkiRJkiRJZyQZDEmSJEmSJEmSdEaSwZAkSZIkSZIkSWckGQxJkiRJkiRJknRGksGQJEmSJEmSJElnpDNunSFFUdi/fz8xMTGoVKrGbo4kSZIknTKEEJSXl9O0aVPUavl9qiRJp74zLhjav38/aWlpjd0MSZIkSTpl7dmzh+bNmzd2MyRJko7aGRcMxcTEAKEXcpvN1sitkSRJkqRTh9PpJC0tLfxeKkmSdKo744KhqqFxNptNBkOSJEmSdATkMHNJkk4XcsCvJEmSJEmSJElnJBkMSZIkSZIkSZJ0RpLBkCRJkiRJkiRJZ6Qzbs6QJEmSJEknlhCCQCBAMBhs7KZIknSa02g0aLXaes9tlMGQJEmSJEnHjc/nIzc3F5fL1dhNkSTpDGE2m0lNTUWv1x+2rgyGJEmSJEk6LhRFYefOnWg0Gpo2bYper5eZ6CRJOm6EEPh8PgoLC9m5cyft2rU77ALRMhiSJEmSJOm48Pl8KIpCWloaZrO5sZsjSdIZwGQyodPp2LVrFz6fD6PRWGd9mUBBkiRJkqTj6nDfzEqSJB1LDXnNka9OkiRJkiRJkiSdkWQwJEmSJEmSJEnSGUkGQ5IkSZIkSSepvLw8Lr/8ciwWC3FxcfU65oknnuCcc86ps86oUaMYNGjQUbevJllZWVxxxRXH5dxS7QYPHszMmTMbuxmnHBkMSZIkSZIkVTNq1ChUKhUqlQqtVkuLFi249957KS0tjar7ww8/cNVVVxEfH4/RaKRLly7MmDGjxjWVVqxYwVVXXUVCQgJms5mMjAwmTpzIvn37am3LSy+9RG5uLuvXr2fLli3H9Hkezp9//kmfPn0wmUw0a9aMp556CiFEncd4vV6mTJnC448/HrVv79696PV6OnbsGLUvJycHlUrF+vXro/YNGjSIUaNGRZRt27aN2267jebNm2MwGGjVqhU33XQT69ata9BzbKiPP/6YjIwMDAYDGRkZLF68uM76TzzxRPh3qfrDYrHUWP/7779Hq9XWGcx+8MEHqFSqqGB2ypQpPPvsszidzoY+rTOaDIYkSZIkSZIOMWDAAHJzc8nJyeHNN9/ks88+Y/To0RF1Fi9eTJ8+fWjevDkrVqxg06ZNjBs3jmeffZZhw4ZFBA5z586lX79+pKSk8PHHH5Odnc2cOXNwOBzMmDGj1nZs376d7t27065dO5o0aXLcnu+hnE4nl19+OU2bNmXt2rW88sorTJ8+/bA9Dx9//DFWq5WLL744at+CBQsYMmQILpeL77///ojbtm7dOrp3786WLVuYO3cu2dnZLF68mI4dOzJx4sQjPu/hrFmzhqFDhzJ8+HB+//13hg8fzpAhQ/jpp59qPWbSpEnk5uZGPDIyMrjxxhuj6jocDkaMGMFll11W6/l27drFpEmTary/Xbt2JT09nYULFx7ZEzxTiTOMw+EQgHA4HI3dFEmSJEk6pTT0PdTtdovs7GzhdruPc8uOrZEjR4prr702omzChAnCbreHtysqKkRCQoK4/vrro47/9NNPBSA++OADIYQQe/bsEXq9XjzwwAM1Xq+0tLTG8pYtWwog/Bg5cqQQQohdu3aJgQMHCovFImJiYsSNN94o8vLywsdNnTpVnH322eHtQCAgxo8fL2JjY4XdbhcPPvigGDFiRNRzrO61114TsbGxwuPxhMumTZsmmjZtKhRFqfW4a665RkyaNCmqXFEU0bp1a/Hll1+Khx56SNx2220R+3fu3CkA8dtvv0Ude+2114afu6IoonPnzqJ79+4iGAxG1a3tXh4LQ4YMEQMGDIgo69+/vxg2bFi9z7F+/XoBiO+++y5q39ChQ8Vjjz0W9f9XJRAIiIsuuki8+eabNf6OCiHEE088IS6++OJ6t+d01ZDXnkbtGfruu++45ppraNq0KSqViiVLlhz2mJUrV9K9e3eMRiOtW7dmzpw5x7+hkiRJkiQdM0FF4PT4T+gjqNQ9vKsuO3bs4Msvv0Sn04XLli5dSnFxMZMmTYqqf80119C+fXvef/99AP7973/j8/n4v//7vxrPX9tcoLVr1zJgwACGDBlCbm4uL7/8MkIIBg0aRElJCStXrmTZsmVs376doUOH1tr+GTNmMG/ePLKysli9ejUlJSWHHd61Zs0a+vTpg8FgCJf179+f/fv3k5OTU+txq1atokePHlHlK1aswOVy0a9fP4YPH86HH35IeXl5nW2oyfr169mwYQMTJ06sMX1yXfOqMjMzsVqtdT5WrVpV6/Fr1qyJmgvVv39/fvjhh3q3/80336R9+/ZRPTvz589n+/btTJ06tdZjn3rqKZKSkrjjjjtqrXP++efz888/4/V6692mM12jLrpaWVnJ2WefzW233cYNN9xw2Po7d+7kqquu4q677uLdd9/l+++/Z/To0SQlJdXreEmSJEmSGl+lL8DPO0pO6DXPb23HZtQdvuIB//3vf7FarQSDQTweD0DEELGq+TudOnWq8fiOHTuG62zduhWbzUZqamqD2pyUlITBYMBkMpGSkgLAsmXL+OOPP9i5cydpaWkAvPPOO3Tu3Jm1a9dy3nnnRZ1n1qxZTJ48OfxZac6cOXz11Vd1XjsvL4/09PSIsuTk5PC+Vq1aRR1TVlZGWVkZTZs2jdqXlZXFsGHD0Gg0dO7cmbZt27Jo0SLuvPPOw9+IarZu3QpQ47yjw7nnnnsYMmRInXWaNWtW6768vLzwPaiSnJxMXl5eva7v9XpZuHAhDz/8cET51q1befjhh1m1ahVabc0fzb///nuysrJqnFN1aPu9Xi95eXm0bNmyXu060zVqMHTllVdy5ZVX1rv+nDlzaNGiBbNmzQJCL0Dr1q1j+vTpMhiSJEmSzmAuoODAIz/0r2cXQu9Ape4F1N5r0Bgsei3nt7af8Gs2RN++fXn99ddxuVy8+eabbNmyhbFjx0bVE7UkFBBCoFKpon4+Whs3biQtLS0cCAFkZGQQFxfHxo0bo4Ihh8NBbm4uPXv2DJdptVp69Ohx2GQIh7a5qn5tz8XtdgNgNBojysvKyvjPf/7D6tWrw2W33nor8+bNa3AwdLg21MVut2O3H93vXU33pL5t+c9//kN5eTkjRowIlwWDQW6++WaefPJJ2rdvX+Nx5eXl3HrrrfzrX/8iMTGxzmuYTCYAXC5XvdokNXIw1FC1dU9mZWXh9/sjuq+reL3eiK5CmWFDkqTjJagEKfGUUOgupMRTgiKUxm6SdIoTQkGjcqFTl6JVl6BXl6LXlKFTl6DTlB3YLkWDCyEUhBAoioK+rBx9uYuKpFjiEmJQq0+uYEijVjWol6YxWCwW2rZtC8A///lP+vbty5NPPsnTTz8NEP7gunHjRnr16hV1/KZNm8jIyAjXrQpKGto7dKjaPnwfy4ALICUlJarHo6CgACCqd6RKQkICKpUqKuvee++9h8fj4YILLohor6IoZGdnk5GRQWxsLBAK3g5VVlYW7uWoft8Plz78UJmZmWRmZtZZ54svvqgxOQHUfk9qux+HevPNN/n73/8e7uWDUKCzbt06fvvtN8aMGQOAooT+lrVaLUuXLsVut5OTk8M111wTPk5RQu8vWq2WzZs306ZNGwBKSkI9rklJSfVqk3SKBUO1dU8GAgGKiopqfIGZNm0aTz755IlqoiRJZxi/4qfEHRkAWXQWmlmbodfoG7t50hEQQoS/fRZCgCBiO/wz4sjrKgJFCaBWOdFoitGoi9GoitFpStBqitGqS9BqS9BpSlCpfCAECIEKBYRAiCBCEYiAgvALgqHdoAJDuQuDsxJUEFNUgWLZi9p8Iu/g6Wnq1KlceeWV3HvvvTRt2pQrrrgCu93OjBkzooKhTz/9lK1bt4YDp8GDB/Pwww/zwgsv8NJLL0Wdu6ysrN5rCGVkZLB792727NkT7h3Kzs7G4XDUOGQvNjaW1NRUfvzxR3r37g1AIBDgl19+4dxzz631Oj179uSRRx7B5/Oh14dey5YuXUrTpk2jhs9V0ev1ZGRkkJ2dHfHldVZWFhMnToxKj33//fczb948pk+fTnx8PElJSaxdu5Y+ffqE67jdbjZs2BAe3nbOOeeQkZHBjBkzGDp0aNS8obru5dEOk+vZsyfLli1j/Pjx4bKlS5fWGAwfaufOnaxYsYJPP/00otxms/Hnn39GlL322mt88803fPTRR7Rq1QqNRhNV57HHHqO8vJyXX345opfwr7/+onnz5oftQZIOOqWCIWh4l+3kyZOZMGFCeNvpdEb80kiSJDWUP+inyF1EobuQMm8ZilCw6W2k29JJNCVi1slPng1RY/AgogONw+2rq27Vt6hV37hW/Xvoz7Wdp7bz1rQv9H6koFaXoNOWotUWhwIeTTFabQlabREaTSjYUakCB04AoKAS4sC/oaAHRUEoCgfiLBQhCAoVilAhVGoUYcIfSEQRSahUKdj+2I9x6e+oShOgVIfqxjGoOt1z7P6zzmCXXHIJnTt3JjMzk9mzZ2OxWJg7dy7Dhg3j7rvvZsyYMdhsNpYvX86DDz7I4MGDwx+809LSeOmllxgzZgxOp5MRI0aQnp7O3r17efvtt7FarXWm166uX79+dO3alVtuuYVZs2YRCAQYPXo0ffr0qTFxAcC4ceN47rnnaNeuHZ06dWLmzJmUlZXVeZ2qoVujRo3ikUceYevWrWRmZjJlypQ6e6D69+/P6tWreeCBB4BQwoNff/2VhQsXRs3zuemmm3j00UeZNm0aOp2OSZMmkZmZSXJyMr169aK0tJTnn38erVbLrbfeCoT+vubPn0+/fv3o3bs3jzzyCB07dqSiooLPPvuMpUuXsnLlyhrbdrTD5MaNG0fv3r15/vnnufbaa/nkk0/4+uuvI4b/zZ49m8WLF7N8+fKIY+fNm0dqamrU9BC1Ws1ZZ50VUdakSROMRmNE+aF1qgK+Q8tXrVolF7xtoFMqGKqte1Kr1ZKQkFDjMQaDISITiiRJ0pHwBr0Uugopchfh8IaGccQaYmkd25okcxIGzan1OtPQQKOufbXVVRSlxiCkarvq55rOc+i/te2r/nNN8zMO3Ve14OGhZTXtU6lU4W+dI/cFUKtDgY1aXRQOdEI/F6FWF6FWlwCHDJMUSrhnB6GEHkpVABRqpyIEilARRIU/aMDliafSG4/Ll4A/mIRCU7SaZEy6VGzmlsSYk7CY9ei0WjRZWfCvtcCBb4QnTIChN9fyGyAdiQkTJnDbbbfx0EMPkZaWxuDBg1mxYgWZmZn07t0bt9tN27ZtefTRR3nggQcigobRo0fTvn17pk+fznXXXYfb7SY9PZ2///3vEV/aHk5V9t2xY8fSu3dv1Go1AwYM4JVXXqn1mIkTJ5Kbm8uoUaNQq9XcfvvtXHfddTUOSasSGxvLsmXLuO++++jRowfx8fFMmDDhsG296667OPfcc3E4HMTGxpKVlUVGRkaNCQ8GDRrEvffey2effcb111/PpEmTsFqtTJ8+ne3btxMXF8eFF17IqlWrsNls4ePOP/981q1bx7PPPstdd90VHh3Uq1ev8Lzy46FXr1588MEHPPbYYzz++OO0adOGRYsWRQz/KyoqYvv27RHHKYrCggULGDVqFBqN5ri1z+PxsHjx4sMmx5AiqcThZs+dICqVisWLF0etplvdQw89xGeffUZ2dna47N5772X9+vWsWbOmXtdxOp3ExsbicDgi/rAkSZIO5fK7wj1A5b5y1Co1cYY4kkxJJJoS0WnqP+ehruCi+s9HE4TU1NNxaK9H1XZN56mrfdW3aws0apswXlOQUaW2fYcLVKr/e2x5wwGOWl0Y9XPoUVbLsaEgJ9yrIxQ4EPyoDpk/pihm/P54PL4EXN4EHB47pW47Tm8TXP4EVCIRsz4Om1FHgs2MPcaMxWRAp9Oh0+miUwp//DFMm3Zwe8IEuPnYB0INfQ/1eDzs3LmTVq1aRU2ql05fQ4YMoVu3bkyePLmxm3JGefXVV/nkk09YunRpYzel0TXktadRe4YqKirYtm1beHvnzp2sX78eu91OixYtmDx5Mvv27ePtt98GQmM9Z8+ezYQJE7jrrrtYs2YNWVlZ4Tz+kiRJR6vCVxEOgCr9lahVahKMCTS3N8dusqNT1x4AKYqCz+fD6/Xi8XgIBoMEg8GogASiezbq2lf1b32CkOrl9Q0yau79qP0cpyqVyh0R1BzsxSlCrS5GoylEpTrMuicHenRU1Xt3xCG9OwELIhCLErATVJLwK0m4fYk4fcmUeJIorEzA6dGiKKFjTDo1NpOeWLOednYL9hgTZqMBrVaLTqer332//PJQQLRlC0yaBMOGHfX9kqQj9eKLL0bNjZGOP51OV2cPoVSzRu0Z+vbbb+nbt29U+ciRI8PdiTk5OXz77bfhfStXrmT8+PFs2LCBpk2b8tBDD3HPPfUfDy17hiRJOpTT56TIFQqA3AE3GpWGBFMCSaYk7EY7GnXNwxqqgh+fz4fb7cblcuHz+VAUBbVajVqtDgcRNQUaVT/Xp9dEqotApapArS48pBcnFOBU/axS1SfVrIgMdqgKeAQqIVD8MSj+GIQ/FiWYQFBJRFGaECSZIE3xBJtQoVgpD6hxuv043D4qvf7Q74RKhdWgxWbSEWc2kBhrIc5qwmjQo9Pp0Gg0R/f/7XDAmjUwYMCRn+MwZM+QJEmngoa89pw0w+ROFBkMSZIkhMDhdVDoLqTQXYgv6EOn1pFoSiTRlEi8MR61Knpl82AwGBH8uN1u/H4/wWAQtVodHsJ0PMeEn3kUVCpHtV6cwgNBTtXPJWg0hYCv/qcUCnBg6Fr4oUL4YlB8VhS/LRTsBOJQlCSCoglBkYKiSkborAitEaE14Q1ChTdIuTeA0+XD4fbj8QVQhIJGpcJm0mEz6bBbTSTEWrCZDRj0+mPzOyIE+HxwgufEymBIkqRTwSkzTE6SJOlEUYRCmbcsnATBr/jRa/QkmZJIMiURa4iN+lY+EAiEgx+Xy4XH48Hv94d7fnQ6HSaTSQY/RyyUcS162Fr1gKcICDbwvOLgPB2hIBRNKLjxWRE+C8Ifg+K3ofhjEcEEgiKFoCoRoTUjtKZQsKMzgyGUTlgIgduvUOkL4qysCnxc+AKhTHA6jYoYo44UmwF7TByJNgsxZgN6vR6tVhs9v+doCQGvvAK//AKvvgpW67E9vyRJ0hlEBkOSJJ22gkqQUm8pha5Cij3FBJQAJq2JVEsqCaYEbHpbxLybqsDH6/WGh7wFAgEURUGj0aDT6bBYLMf+w+1pyY9aXZVhrXoygoNzdGrMuFZvB4axBQ0o/tjQ0DWfFeE1I3yWA2W20NwdVcLBIEdrDv2rNyHMRjhkCKQiBG6fQrkrSLm7Eofbh9PtIxAMzfsy6jTYTDpaJlpCPT42M9YDiQ20Wu3xH9ZYFQgdmEvL2LHw5psgA3JJkqQjIoMhSZJOS0XuIjYWbyQoguFFUJNMSVj1oW/Rg8EgHo8nIvipGvImhAhPXjcYDDL4ieIJp5KO7NUpDAdAtWdcqy+BUCwo/jiE3xYKbLyWULDjNYWHs6EYQaNHaI0oWtPBoMcc+hmNHmoJUIKKoNIToMIbODC/x0+Fx0/wQMILy4H5Pe1SYkmIMRNvNWI2Hgx8Tjgh4OWX4d13D5Zdc40MhCRJko6CDIYkSTrt7Cnfw/ay7SSZkmgV2wqjxojf78fv81NcXozH48Hj8YR7fVQqVTjwOepJ7Kc4lcpVSwKCg706KlXFUV9HUeJQgnaUQOzBIWxeC8JjAa8exWMEoa9qVLWenQMBj/Hgz4f27tQkEBRU+IKUe/zVEhsEQpn4AItBS6xZT4sEKwk2M3FWEyZDaJjbSTEMUgh46SV4772DZY8+Ctdd13htkiRJOg3IYEiSpNOGIhS2lm4ltzKXFjEtSNGn4Cx2ku/OJxAIEAgEUKlU4SFvZ1avj0ClKq+Wca363JyDPToqlfsor6NGUewoSiLBYALCH1dtCJsF4TEivHpU/gCIanOB1DqEzhQewqaYDwY/aAy19u7UxBs4ML/HHcB5YJibyxcKfLRqNTEmHXaLgXYpcdhjzMRZjeHEBidlIFxTIPTYY1DHunySJElS/chgSJKk04Jf8ZNdnE2Zp4x0czomr4m9BXtRFAW9Xo/BYMBisTR2M48TBZWqrIZ1cyIDHvAf5XW0KEoCwWASipKAoiShBGJRfLZQJjavEbwGVAEvKr8bVdAbcXS4d8dgRliMEXN4UB/Z25HbH6TSp+BweXG6Q70+3kBoqKNOE1q/JyXOTKLNQrzViK1aYoOTMvA5lBAwYwZ88EFoW6WCxx+HgQMbt12SJEmnCRkMSZJ0ynMH3PxV9BeVnkqaaZvhL/HjDrgxm83odLUvknpqCKJWl9aQgKD60LViGp5xLZIQBhQlMRzkBIMHfg4mhOfr4NOiCvhQBdwHHh5QQhnVVHjQqAMIbRChNaFYY8M9O8oR9O5Et0/g8isH5/e4fJR7/PgCQVQqFUadhhijjpZJMaH5PTEmbGYjWq22ceb3HAtCwPTpsGhRaFsGQmekvLw8hg8fzg8//IBOp6OsrOywxzzxxBMsWbKE9evX11pn1KhRlJWVsWTJkmPW1ipZWVksWrSIpUuXHvNzS7UbPHgwvXr1YsKECY3dlFPKmTI+RJKk05TD62Dt/rWUOcpI9CUSKA+g0+mIjY09BQIhH2p1HlrtXxgMKzCZ/o3FMgeb7Rni4sZhtw8nMXEgdvtw4uImYLNlYrG8gcn0HwyG79DpslGrCzhcICSEhWCwBT5fdzyeK3C5bqGi4n4cjqcoLX2V4sKFlOS+jWNfJhW7R+POuQb/znNQtiei2uZFs6sQbV4O2pJtqF0FoARQ9DYCthb4kzrjS+2BN+1veNMuxpfaA39SZwJxrQlam6IY40FrbFAgpAhBuTfA/jIPG3Od/LSjiOUb81m9JZ/fd5dQ4HSj12polxpP74w0Bp7Xjut6duLK8zvR66w2dGiZShN7HEaj8dQNhAAUBQoLQz+rVDBligyETpBRo0aFFz3WarW0aNGCe++9l9LS0qi6P/zwA1dddRXx8fEYjUa6dOnCjBkzCAaj/y5XrFjBVVddRUJCAmazmYyMDCZOnMi+fftqbctLL71Ebm4u69evZ8uWLcf0edbF4/EwatQounTpglarZVA9h2V6vV6mTJnC448/HrVv79696PV6OnbsGLUvJycHlUpVYwA3aNAgRo0aFVG2bds2brvtNpo3b47BYKBVq1bcdNNNrFu3rl7tPFIff/wxGRkZGAwGMjIyWLx48WGP+eqrr7jwwguJiYkhKSmJG264gZ07d0bUWblyJd27d8doNNK6dWvmzJkTdZ6ysjLuu+8+UlNTMRqNdOrUic8//zy8f8qUKTz77LM4nc6jf6JnkFP4XUKSpDNdbnku6/evR3ErtNC1wGwyY7SejAs7igNBz1a02u3odFvRaHYeg4xrIITtQC/OwUcweGAI24FtoRgh6EVdrUdH5Q/9rA3sA2XXwROqNAfm7phQzE0OJi3QmRAaA9SwGO3RCCgCly+Iw+ULDXPz+KnwBsJrOVkNWmwmPelNQvN7Yi2GcEa3U2KY29HQaCAzM5Qo4eKL4e9/b+wWnVEGDBjA/PnzCQQCZGdnc/vtt1NWVsb7778frrN48WKGDBnCbbfdxooVK4iLi+Prr7/m//7v//jxxx/58MMPw7+nc+fOZfTo0YwcOZKPP/6Y9PR0du/ezdtvv82MGTOYOXNmje3Yvn073bt3p127difkeVcJBoOYTCbuv/9+Pv7443of9/HHH2O1Wrn44ouj9i1YsIAhQ4bw3Xff8f3333PRRRcdUdvWrVvHZZddxllnncXcuXPp2LEj5eXlfPLJJ0ycOJGVK1ce0XkPZ82aNQwdOpSnn36a6667Lvz/v3r1ai644IIaj9mxYwfXXnstEyZMYOHChTgcDsaPH8/111/Pb7/9BsDOnTu56qqruOuuu3j33Xf5/vvvGT16dDhwAvD5fFx++eU0adKEjz76iObNm7Nnzx5iYmLC1+ratSvp6eksXLiQe++997jcg9ORDIYkSTrlKIrCpvxN/LX/L6zCSrvYdljMlpPqw7FKVYZevx6d7lf0+l8PDGVr0BlCGdcigpyqYWxNDgQ8CYAhVF0JhIKcagGP2l+MJrAPVdATGnJ1gNAYEDoTit6KMCceXHtHZwL18etN8wcVyr3BUFIDlw+H24/LdyCpxYHAx2410r6phfgYE3EWI0aD/szO8KfVwnPPHdUQQ+nIGAwGUlJSAGjevDlDhw5lwYIF4f2VlZXcddddDBw4kDfeeCNcfuedd5KcnMzAgQP58MMPGTp0KHv37uX+++/n/vvv56WXXgrXTU9Pp3fv3rUOfUtPT2fXrtCXFW+//TYjR45kwYIF7N69m7Fjx7J8+XLUajUDBgzglVdeITk5ucbzBINBHnzwQebNm4dGo+GOO+5AVHtNqInFYuH1118H4Pvvv6/X8DyADz74gIE19GAKIZg/fz6vvfYazZs3Jysr64iCISEEo0aNol27dqxatSoiCc4555zDuHHjGnzO+po1axaXX345kydPBmDy5MmsXLmSWbNmRQTJ1f36668Eg0GeeeaZcFsnTZrEtddei9/vR6fTMWfOHFq0aMGsWbMA6NSpE+vWrWP69OnhYGjevHmUlJSEh0sCtGzZMup6AwcO5P3335fBUAPIYEiSpFOGEILyinJ+3fsre8v2kmZJo429zUmTEU6lcmAwrMRo/AatdgtQ+4eNUKCTWi3ASaqWnCARRbET8RItBAR9qAKuUKATcKMJbAv38qBUS46g0hycr2NOPJiOWhtKWnCse3dq4g0olHsCB3p8QoGP98D8Hp1GQ4xJR7OEGOKtJuwxJmLNRgwHAp8zlqLAnDmhtYPS0g6Wn46BkBIE39GnaG8QvbVeadhrsmPHDr788suIobdLly6luLiYSZMmRdW/5ppraN++Pe+//z5Dhw7l3//+Nz6fj//7v/+r8fxxcXE1lq9du5YRI0Zgs9l4+eWXMZlMCCEYNGgQFouFlStXEggEGD16NEOHDuXbb7+t8TwzZsxg3rx5ZGVlkZGRwYwZM1i8eDGXXnppg+/F4axatYpbbrklqnzFihW4XC769etH8+bNueCCC3j55ZcjejbqY/369WzYsIH33nuvxtf+2u4lQGZmJpmZmXWe/4svvqixVwtCPUPjx4+PKOvfv384iKlJjx490Gg0zJ8/n1GjRlFRUcE777zDFVdcEf59WrNmDVdccUXUebOyssIB06effkrPnj257777+OSTT0hKSuLmm2/moYceinjdPP/885k2bRperxeDwVDnc5VCZDAkSdJJTwiBy+WisKSQ3/N/xxV0cVbSWTQxN2nspgE+9PqfMRqXo9evpeb5O3r8/rPw+zsQCLQjEGh3oFfnkA+5SvBA744LTSA3opdHFXBH9O6g0aNozShaM8KUELEODxr9cXy+kYQQuP1VgY8X54F1fPzB0PpNBl1o4dJWKXEkxJiJsxzM6HayBLEnBUUJDYlbsgT++1944w1o3ryxW3X8+Cpg1w8n9pote4Extt7V//vf/2K1WsMLNAMRQ9mq5u906tSpxuM7duwYrrN161ZsNhupqakNanJSUhIGgwGTyRTupVq2bBl//PEHO3fuJO1A0PzOO+/QuXNn1q5dy3nnnRd1nlmzZjF58uRwL8OcOXP46quvGtSW+igrK6OsrIymTZtG7cvKymLYsGFoNBo6d+5M27ZtWbRoEXfeeWeDrrF161aAGucdHc4999zDkCFD6qzTrFmzWvfl5eVF9b4lJyeTl5dX6zHp6eksXbqUG2+8kX/84x8Eg0F69uwZMdentvMGAgGKiopITU1lx44dfPPNN9xyyy18/vnnbN26lfvuu49AIMCUKVMi2u/1esnLy6ux50iKJoMhSZJOWkII3G43ZWVlFJQVsK1iGxqdhm5J3bDpbI3ZMrTajRiNyzEYvqtxEdJgMB2frwc+37n4/Z2BAwFKwIsq4EYdyA8HO+qqYCfoO3gClTrco6MY7Qfn7VQFPCegd+dQihC4fQoO98HengqPn4AiUKvUmAyhwKdDQiwJMSbirUasJuOpk8a6sSgKPPssfPJJaLuoCLZsOb2DIb01FJyc6Gs2QN++fXn99ddxuVy8+eabbNmyhbFjx0bVq224mRAi/Htf/eejtXHjRtLS0sKBEEBGRgZxcXFs3LgxKhhyOBzk5ubSs2fPcJlWq6VHjx6HHSrXUG53aJ0yozFy7mZZWRn/+c9/WL16dbjs1ltvZd68eQ0OhqrafCT30263Y7fbG3xcdYde93D/t3l5edx5552MHDmSm266ifLycqZMmcLgwYNZtmxZ+Niazlu9XFEUmjRpwhtvvIFGo6F79+7s37+fF198MSIYMplMALhcrqN6nmcSGQxJknTSqQqCHA4HTqeTcn85u/27MZvNdIztiFHTOEkS1OpcjMZvMBi+QaPZH7VfURLwevrgrfwbijsp3KOjC2yq1rujHDxAoz+QetqIMMYf7N3RmU9o705NgooIp7GuCnwqvQEUIUKJDYw64sxGWqXYibMYiY8xYTEaTu3sbY1BUeCZZ+DTT0PbanVo+zgMXzqpqDUN6qVpDBaLhbZt2wLwz3/+k759+/Lkk0/y9NNPA9C+fXsgFJz06hUd2G3atImMjIxw3aqgpKG9Q4eq7cP3sQy4jlRCQgIqlSoq6957772Hx+OJSDIghEBRFLKzs8nIyCA2NvT74HA4os5bVlYW7uWoft/POeecBrXvaIfJpaSkRPUCFRQU1DpXC+DVV1/FZrPxwgsvhMveffdd0tLS+Omnn7jwwgtrPa9WqyUhIQGA1NRUdDpdxJC4Tp06kZeXh8/nQ68PvWeUlJQAoV5FqX7ku5YkSSeNquFwDoeD8vJyACpUFewJ7iHWEEs7Wzu0R7g455FSqSoxGFZhMCxHp/urqqUgFFRCQSha/OVn4y89m6AzDYIBNOShIQ9Uqmq9O3EIbWrE/J0jnb9wrAWC4sDwtlDQ43T78PgVFCHQajRYjToSYy10PLBwaazZgMloOLPn9xwLigJPPw2ffRbaVqtDPUSXX9647ZJqNHXqVK688kruvfdemjZtyhVXXIHdbmfGjBlRwdCnn37K1q1bw4HT4MGDefjhh3nhhRciEihUKSsrq3OuS3UZGRns3r2bPXv2hHuHsrOzcTgcNQ7Zi42NJTU1lR9//JHevXsDEAgE+OWXXzj33HMbcgsOS6/Xk5GRQXZ2dsQcmKysLCZOnBiVHvv+++9n3rx5TJ8+nfj4eJKSkli7di19+vQJ13G73WzYsCE8vO2cc84Jz3saOnRo1HDbuu7l0Q6T69mzJ8uWLYuYN7R06dIag+EqLpcr6rWyaltRlPB5P6t6Hah23h49eoTnFV100UW899574UybEBqqmZqaGg6EAP766y+aN29OYmJinc9TOkgGQ5IkNTpFUcJBUEVFaMiZ0Wgk15fLftd+koxJtLK2Qn2ihoYJH3rNGoyG5eiNP6PCG5qv4w8FQACBitb4Ss/BX3kOQh1aYFSxmg+moq6au3OSDQ8LJTbwh7O5Od0+PAEFtUqNTqvBatTSPCkOu9VMvNVInMWIXq+T83uONUWBp54KzQ+CUCCUmQn9+jVuu6RaXXLJJXTu3JnMzExmz56NxWJh7ty5DBs2jLvvvpsxY8Zgs9lYvnw5Dz74IIMHDw5/8E5LS+Oll15izJgxOJ1ORowYQXp6Onv37uXtt9/GarUyY8aMerWjX79+dO3alVtuuYVZs2aFEyj06dOHHj161HjMuHHjeO6552jXrh2dOnVi5syZ9coOl52djc/no6SkhPLy8vAaQHX1yPTv35/Vq1fzwAMPAKGEB7/++isLFy6Mmudz00038eijjzJt2jR0Oh2TJk0iMzOT5ORkevXqRWlpKc8//zxarZZbb70VCA0bmz9/Pv369aN379488sgjdOzYkYqKCj777DOWLl1aa2rtox0mN27cOHr37s3zzz/PtddeyyeffMLXX38dMfxv9uzZLF68mOXLlwNw9dVX89JLL/HUU0+Fh8k98sgjtGzZkm7dugGhIG327NlMmDCBu+66izVr1pCVlRWRoe7ee+/llVdeYdy4cYwdO5atW7eSmZnJ/fffH9HGVatWRSVjkOomgyFJkhqNoihUVlZSVlZGZWUlKpUKk8mESqNiu3M7Jb4SWlha0NQcPRn3qAV9h6SidqNVb0Mf8wN626+otZUH6oFQqUGlIhhojtd1MV5PX4Kq5ogYI8SevC+jHv+B+T0uHw63j3JPAF8wFPjodRriLAZapcZgPzC/J9ZsPDPW72lsigJPPgn/+19oW6OBadNO/6Fxp4EJEyZw22238dBDD5GWlsbgwYNZsWIFmZmZ9O7dG7fbTdu2bXn00Ud54IEHIv6WRo8eTfv27Zk+fTrXXXcdbreb9PR0/v73vzNhwoR6t0GlUrFkyRLGjh1L7969I1Jr12bixInk5uYyatQo1Go1t99+O9ddd12NQ9Kqu+qqq8KpvYHwh/e65hrdddddnHvuuTgcDmJjY8MZ7GpKeDBo0CDuvfdePvvsM66//nomTZqE1Wpl+vTpbN++nbi4OC688EJWrVqFzXZwnuj555/PunXrePbZZ7nrrrvCSQZ69epVZ2a3o9WrVy8++OADHnvsMR5//HHatGnDokWLIob/FRUVsX379vD2pZdeynvvvccLL7zACy+8gNlspmfPnnz55Zfh+T2tWrXi888/Z/z48bz66qs0bdqUf/7zn+GEFxAKqJcuXcr48ePp2rUrzZo1Y9y4cTz00EPhOh6Ph8WLFx+X5BinM5U41rPnTnJOp5PY2FgcDkfEH5YkSSdOIBAIB0Futxu1Wo3JZEKj0eBTfGx2bMYdcNPW1ha74Qi/xRPKgWAncu0dlT+UmhoRyvqm0jrQ2Tegj/8dtbEglJhApUaoVIAaIeLweC/B6+1HINCWqAxwJwEhBJW+IE63P5zKutIbxH9gOIVJryXeYiQ+xozdaiTOasRmNsr5PY3lm2+gKsXyKRYINfQ91OPxsHPnTlq1ahU1qV46fQ0ZMoRu3bqF1+ORToxXX32VTz75hKVLlzZ2UxpdQ1575DuhJEknjM/no7y8HIfDgdfrRafTYbVaw0OwXAEXmxybEAg6x3XGorPUfULFH15np3oPT1UQVF3VPB3FEIuIiUMX8ycG64/ojH8drIPpwE9avN6eeL2X4vP14GR6qVSEOJjG2u2n3OOnwhtEABq1BrNBS3yMhVZNQ8Pc7FYTFpNBDnM7mfTtC7ffDm+9Bc8/D5dc0tgtkqRj6sUXX+TTqqQg0gmj0+nq7CGUaiZ7hiRJOu4CgUB4zLnP58NgMGAwGCKGkJT5ytjq3IpBbaBjbEf0Gj0IgSroiejRqVqHRxXwgBI4eBG19sB8nQPzdnTVFhrVGEEl0Ol+P7Ae0PeoVJ6odvr9GXi9l+H1XowQDVsI8HgIKIIKT6i3J5TO2o/LF0SlUqPRhOb32GPMoWFullCPj9lokMPcTgVCwM6d0Lp1Y7ekQWTPkCRJpwLZMyRJ0knD7XZTWFhIZWUlJpMpnD41TAmQX7GLXc5txKuNtNdb0BZlH0xFXU0o2DGi6GMQ5iYRa++g1lETjWYXBsM3GI3foFYXRe0PBlPwei/D47kURTkOc5PqyRc4OMzN4fZR4Q3gCQhUqNBqNcSaDTRvEprfE2cJJTYw6OX8nlNCMBgKfA6kaQZCiTVOsUBIkiTpdCSDIUmSjgshBA6Hg6LCQhSfi1iDBo2vCJXrwBwevxv8bnI8ueT6y2iuiyPdYAQqEDozijkxIg210BobsNCoQKf7DYvlXbTajTW0zYLX2xuP5zICgQxO9Dwgb0DB4fJRVm2om18BtVqN/kDg08oejz3GSLzFRKzFiE4nX65PScEgPP44fPcd/POfcIxTGUuSJElHR767SpJ0zAUCAYqKiijP3Ya1Ygd67cE1FoTGgNCa8OtMbFHKKTXZaJl8LsnWFviOwUKjWu0GLJa30On+PGSPGp+vx4FhcBcCJ35R09JKH5vyyyl3+1ChwmTUY7eaadYklM0t3mrCZpbr95w2AgF47DH4+uvQ9qRJoTWFLIeZCydJkiSdMDIYkiTpmPL7/RQUFODK20qsew8qWyp+a8rBhUZVanxBH5scm/AarLS3dSNOH3fU19VodmCxLECvXxtRHgy2wO2+Cq+3N0LEH/V1joTH62dznoP8Cj92q5EL26eSYrcRa7XIYW6nq0AAHn0UDqw1gk4XWmBVBkKSJEknFRkMSZJ0zPh8PgoKCvDkbSbeux8ltjl+e/uIhUcr/ZVscm5ChYrOcZ0xa81HdU21Oh+L5R0Mhm+Ag/lggsFmuFy34vX2Bhonk1ogEGBfcTk7S33oDUZ6dmpKm5Q4mdL6dBcIwCOPhFJoA+j1MH061LFKvSRJktQ45DuyJEnHhNfrJT8/H3/+ZuJ8eSixLQjY20XUKfGWsM25DZPWRIfYDujVRz5UTaUqx2xehMn0KeAPlytKIi7XrXg8/YDGGW4WCARwVLjIKfXiFnpaNU/hnPQkTHr5knva8/tDgdCKFaFtvR5mzICePRu3XZIkSVKN5DuzJElHzePxkJeXh1KwibhAEYH41gTjWkXU2e/az+7K3SQYEmgd0xqN6kgDFS8m06eYzYtQqSrDpUJYcbmG4XZfQ2PMB4LQEEGPx0NBhZ9CrxZLjJ0eLRJJjTMd/mDp1Of3w+TJ8O23oW29HmbOhAsvbNRmSZIkSbWTq/BJknRU3G43ufv3I/KziQ0UEbC3jQiEFKGwvXw7uyt309TclLYxbY8wEFIwGJZit9+JxTKvWiCkw+0eTEnJPNzuG2iMQMjn8+F0OnFUutnj0uBU22jfMoW+Gc1kIHSmECI0R6h6IDRrlgyEpKOWl5fH5ZdfjsViIS4url7HPPHEE5xzzjl11hk1ahSDBg066vbVJCsriyuuuOK4nFuq3eDBg5k5c2ZjN+OUI4MhSZKOWGVlJbn796Mq2IAtWEIgoQNBW4vw/oASYLNjM0WeIlrHtKaFpcURJAwQ6PVriY+/j5iYl6qtFaTC47mckpIsKivvaJRFUquCIJ/PR6XKxP6ABYM1lgvaJXNWszj0WvkSe8ZQqeCyy0CtBoMhFAidf35jt0o6QqNGjUKlUqFSqdBqtbRo0YJ7772X0tLSqLo//PADV111FfHx8RiNRrp06cKMGTMIBoNRdVesWMFVV11FQkICZrOZjIwMJk6cyL59+2pty0svvURubi7r169ny5Ytx/R51uXbb7/l2muvJTU1FYvFwjnnnMPChQsPe5zX62XKlCk8/vjjUfv27t2LXq+nY8eOUftycnJQqVSsX78+at+gQYMYNWpURNm2bdu47bbbaN68OQaDgVatWnHTTTexbt26ej/HI/Hxxx+TkZGBwWAgIyODxYsXH/aYr776igsvvJCYmBiSkpK44YYb2LlzZ411v//+e7RabZ3B7AcffIBKpYoKZqdMmcKzzz6L0+lsyFM648l3akmSjkhFRQV5ufvRFP5FjHDiT8wgGNMsvN8T9PBX2V9UBCroFNuJJsYmDb6GVruF2NiHsNmmoNHkhMt9vvMoLX2ViooJKErSsXg6DeL1enE4HAQCAfSWWApEDKVBI62T4+jZOoFEq+GEt0k6CfTvH8oYJwOh08KAAQPIzc0lJyeHN998k88++4zRo0dH1Fm8eDF9+vShefPmrFixgk2bNjFu3DieffZZhg0bhhAHk7rMnTuXfv36kZKSwscff0x2djZz5szB4XAwY8aMWtuxfft2unfvTrt27WjSpOGvo0fqhx9+oGvXrnz88cf88ccf3H777YwYMYLPPvuszuM+/vhjrFYrF198cdS+BQsWMGTIEFwuF99///0Rt23dunV0796dLVu2MHfuXLKzs1m8eDEdO3Zk4sSJR3zew1mzZg1Dhw5l+PDh/P777wwfPpwhQ4bw008/1XrMjh07uPbaa7n00ktZv349X331FUVFRVx//fVRdR0OByNGjOCyyy6r9Xy7du1i0qRJNd7frl27kp6eXq+gVTpIJar/pZ4BnE4nsbGxOBwObDZbYzdHkk5JTqeTgvw89EUbsKjc+BM7o5gPBiVOv5Mtji1o1Vo6xnbEqDE26Pxq9X4slrcwGL6LKA8E2lFZeRd+f5dj8jwayuv14vF40Ov1WGNiKPZpyS33Y9ZryUi1EWvWNUq7pEYiRESmxDNBQ99DPR4PO3fupFWrVhiNDXsdaEyjRo2irKyMJUuWhMsmTpzIggULKC4uBkI94y1btqRPnz58/PHHEcd/9tlnDBw4kA8++IChQ4eyd+9e2rRpw+jRo3nppZeirldWVlbjELj09HR27doV3h45ciQLFixg9+7djB07luXLl6NWqxkwYACvvPIKycnJQGiY3JIlS8K9LMFgkAcffJB58+ah0Wi44447yM/Px+FwRDzHw7n66qtJTk5m3rx5tdYZOHAgHTp04MUXX4woF0LQtm1bXnvtNVasWEFBQUHEeXJycmjVqhW//fZbVK/IoEGDiIuLY8GCBQgh6NKlC0ajkZ9//hm1OvJ7/dru5bEwdOhQnE4nX3zxRbhswIABxMfH8/7779d4zEcffcRNN92E1+sNt/Wzzz7j2muvxev1otMdfN8YNmwY7dq1Q6PRRPz/VQkGg/Tp04fbbruNVatWRf2OAjz55JMsX76c776LfP880zTktUf2DEmS1CAOh4O8/XsxFv0VCoSSukQEQkWeIjaWbcSkNdE5rnODAiGVqhSr9TXs9rsjAqFgsClO52TKyl5ulECoqidIURSSkpKISUhhe7mavAo/rRItXNDKLgOhM43PB+PHQwM+SEoHBZUg5b7yE/oIKtHD1uprx44dfPnllxEfXJcuXUpxcTGTJk2Kqn/NNdfQvn378Afkf//73/h8Pv7v//6vxvPX9uF97dq1DBgwgCFDhpCbm8vLL7+MEIJBgwZRUlLCypUrWbZsGdu3b2fo0KG1tn/GjBnMmzePrKwsVq9eTUlJSb2Gdx3K4XBgt9vrrLNq1Sp69OgRVb5ixQpcLhf9+vVj+PDhfPjhh5SXlze4DevXr2fDhg1MnDgxKhCC2u8lQGZmJlartc7HqlWraj1+zZo1UXOh+vfvzw8//FDrMT169ECj0TB//nyCwSAOh4N33nmHK664IuL3af78+Wzfvp2pU6fWeq6nnnqKpKQk7rjjjlrrnH/++fz88894vd5a60iRZDY5SZLqRQhBWVkZBXn7sTo2Y1T58DU5G2E8uJDp3sq97HXtJdGQSOuY1qhV9f2+xY3ZvAST6d+oVO5q14ylsvJmPJ6raIyXq+o9QUlJSZgtVnaV+dhXUEGsWUfX5nFYDfJl9Izj88GkSfDDD7B6dWie0MCBjd2qU4or4OKX/F9O6DW7J3cnRl//uYX//e9/sVqtBINBPB4PQMTk9Kr5O506darx+I4dO4brbN26FZvNRmpqaoPanJSUhMFgwGQykZKSAsCyZcv4448/2LlzJ2lpaQC88847dO7cmbVr13LeeedFnWfWrFlMnjyZG264AYA5c+bw1VdfNagtH330EWvXrmXu3Lm11ikrK6OsrIymTZtG7cvKymLYsGFoNBo6d+5M27ZtWbRoEXfeeWeD2rF161aAGucdHc4999zDkCFD6qzTrFmzWvfl5eWFe9+qJCcnk5eXV+sx6enpLF26lBtvvJF//OMfBINBevbsyeeffx6us3XrVh5++GFWrVpV6zp033//PVlZWTXOqTq0/V6vl7y8PFq2bFlnXSlEvotLknRYQghKSkooys8lxrERg1rB1+QchCE0TEYRCjvKd1DkLSLNnEYzS+1vJpGCGI1fYTYvRK0uqXY9A273DbjdgxHixGdjOzQIstlsOLyCX/Y6CQQFHVJiaB5vOoJkENIpz+uFiRPhxx9D2yYTHPhAKtWfWWume3L3E37Nhujbty+vv/46LpeLN998ky1btjB27NioerXNNhBChF8jqv98tDZu3EhaWlo4EALIyMggLi6OjRs3RgVDDoeD3NxcelZb60qr1dKjR49a236ob7/9llGjRvGvf/2Lzp0711rP7Q59mXXosKSysjL+85//sHr16nDZrbfeyrx58xocDFW1+Ujup91uP2zP1uEcet3D/d/m5eVx5513MnLkSG666SbKy8uZMmUKgwcPZtmyZSiKws0338yTTz5J+/btazxHeXk5t956K//6179ITEyss30mU+g90+VyNfCZnblkMCRJUp2EEBQXF1OUt5e48q3oNOBr0g2htwLgV/xscW6hwl9Bu5h2JBgT6nNW9PofsFgWoNHsrVauxuPpj8t1K4pydG9YR6KmIEioNWzOqyDf6SHBqqdTqg2jrnEWc5UamdcLEyZA1WRpsxn++U84TApjKZpGrWlQL01jsFgstG3bFoB//vOf9O3blyeffJKnn34aIPzBdePGjfTq1Svq+E2bNpGRkRGuWxWUNLR36FC1ffg+lgFXdStXruSaa65h5syZjBgxos66CQkJqFSqqKx77733Hh6PhwsuuCCivYqikJ2dTUZGBrGxsUAoeDtUWVlZuJej+n0/XPrwQ2VmZpKZmVlnnS+++KLG5AQAKSkpUb1ABQUFUb1F1b366qvYbDZeeOGFcNm7775LWloaP/30Ex07dmTdunX89ttvjBkzBgBFURBCoNVqWbp0KXa7nZycHK655prwORRFAUKB7ebNm2nTpg0AJSWhLxaTkk58cqFTlZwzJElSrRRFobCwkKLcPcQ5N6PVqPAlHwyE3AE3G8o24A64yYjLqFcgpNVuIC5uIjbbMxGBkM/Xi9LSOVRU3H/CAyGfzxcxJygtLY3ExESKXEHWbC+mxOXjrGaxdGsRLwOhM5XHE5ojVD0QeuUVGQidQaZOncr06dPZv38/AFdccQV2u73GTHCffvopW7du5aabbgJC67/o9fqID8TVlZWV1bsdGRkZ7N69mz179oTLsrOzcTgcNQ7Zi42NJTU1lR+rejOBQCDAL78cfpjit99+y9VXX81zzz3H3Xfffdj6er2ejIwMsrOzI8qzsrKYOHEi69evDz9+//13+vbtG06iEB8fT1JSEmvXro041u12s2HDBjp06ADAOeecQ0ZGBjNmzAgHBNXVdS/vueeeiDbU9KhpvlOVnj17smzZsoiypUuX1hgMV3G5XGg0ke8bVduKomCz2fjzzz8j2nDPPffQoUMH1q9fzwUXXEDHjh2j6gwcOJC+ffuyfv36iF7Cv/76i+bNmx+2B0k6SPYMSZJUo2AwSFFREaX5e4mv2IpGp8eXfA5oQ8MfHD4HW5xb0Kv1nBV/1mETJWg0e7BY5qPXr4ko9/szqKy8g0Ag43g9lVr5fD7cbjc6nY7ExERsNhsGgwG3L8ivu0spqfCREmukfXKMXDPoTObxhHqEfv45tG02w+zZ0LVr47ZLOqEuueQSOnfuTGZmJrNnz8ZisTB37lyGDRvG3XffzZgxY7DZbCxfvpwHH3yQwYMHh+enpKWl8dJLLzFmzBicTicjRowgPT2dvXv38vbbb2O1WutMr11dv3796Nq1K7fccguzZs0iEAgwevRo+vTpU+sH+XHjxvHcc8/Rrl07OnXqxMyZMw8bgFUFQuPGjeOGG24I94jo9fo6h5r179+f1atX88ADDwChhAe//vorCxcujJrnc9NNN/Hoo48ybdo0dDodkyZNIjMzk+TkZHr16kVpaSnPP/88Wq2WW2+9FQgNU5s/fz79+vWjd+/ePPLII3Ts2JGKigo+++wzli5dysqVK2ts29EOkxs3bhy9e/fm+eef59prr+WTTz7h66+/jhj+N3v2bBYvXszy5cuBUAa+l156iaeeeio8TO6RRx6hZcuWdOvWDbVazVlnnRVxnSZNmmA0GiPKD61TlSji0PJVq1bJBW8bSL67S5IUJRgMUlhYSFn+HuyVW9HojfiSu4UDoQJ3ARsdG7FqrYfNGKdSubFaXyM+/p6IQCgYbI7TOQWHY/oJD4SqFksNBAIkJCSQlpZGUlISer2e3cUuftxRjMsb5JwWcZzVLFYGQmeyqh4hGQhJwIQJE/jXv/4V7pUZPHgwK1asYM+ePfTu3ZsOHTowc+ZMHn300fDCmFVGjx7N0qVL2bdvH9dddx0dO3bkzjvvxGaz1ZiRrjYqlYolS5YQHx9P79696devH61bt2bRokW1HjNx4kRGjBjBqFGj6NmzJzExMVx33XV1XmfBggW4XC6mTZtGampq+FHT+jjV3XXXXXz++efh4W5ZWVlkZGTUmPCgKite1dpFkyZN4plnnmH69OmcffbZDBo0CCEEq1atikjlfv7557Nu3TratGnDXXfdRadOnRg4cCAbNmxg1qxZdbbvaPTq1YsPPviA+fPn07VrVxYsWMCiRYsihv8VFRWxffv28Pall17Ke++9x5IlS+jWrRsDBgzAYDDw5Zdfhuf3HCsej4fFixdz1113HdPznu7kOkOSJEUIBAIUFBTgLNhDgnsHKr0ZX5OzQaNHCMGeyj3sd++nibEJ6db0OjPGabWbiIl5EY1mf7hMUey4XMPxeC4HTuyQM7/fj9vtRqPRYLPZiI2NDU/0Lff42ZhbjtPtJ81upk2SBa1GBkFnvG3b4I47oLISLJZQINSlcda5OhmcKesMSUdnyJAhdOvWjcmTJzd2U84or776Kp988glLly5t7KY0uoa89shhcpIkhfn9fvLz83EV7SXBtQOV0YavSRdQ6wiKINud2ynxldDS0pJUc12TgIOYzR9gNr8HhMZ0C2HA5RqG230tcGIzxAUCAVwuF2q1mri4OOLi4sIvjooi2FFUya7iSkx6DT3S44kz609o+6STWNu28Oqr8NBD8PzzcMiQFEmSor344ot8+umnjd2MM45Op+OVV15p7GaccmTPkCRJQGjoWH5+Pu6i3djdOQhTPP6kLqDW4Av62OzcjDvgpq2tLXZD7WOu1eoibLZMtNqN4bJAoD3l5f9HMFjflNvHRiAQCKd6tdls4SCoauhKmctHdq4Tjz9IywQLrRIsqNUyXbZUA58P9DJIlj1DkiSdCmTPkCRJDVK1QJuvZA929y6EORF/UmdQqakMVLLZsRmBoHNcZyw6S63n0Wo3YLM9g1pddqBEjct1Ey7XME7ky00wGAyvsRATE0NcXBwm08F1gQJBhW2FFewtccvFU6VILhf8979w441QPU2xDIQkSZJOS/LdX5LOcB6Ph7y8PAIlu7B79qJYm+BP6AQqNWW+MrY6t2LUGOlg64BeU/sHQqPxS6zW2UAQAEVJxun8vxOaHEFRFFwuF0IIrFYrcXFxmM3miEnMheVeNuXJxVOlGrhccP/9sH497NkTyiAnfzckSZJOazIYkqQzmNvtJi8vD6Ukh3jvPoIxTQnYO4BKRZ47j5yKHOL0cbSLaYdGXVuygwBW6xsYjZ+FS/z+rjidjyLEiRmKqigKbrebYDAYDoIsFktEkOMLKGzJLyfP4cFu1dMpxYZJL9cMkg5wuWDsWPj999D2f/8Lt9wCKSmN2y5JkiTpuJLBkCSdoSorK8nPz4eSncT5cgna0gjY2yGEYFdFDnnuPFJMKbS0tKy150SlcmKzPYtO90e4zOO5hoqKuzkRLy9CCNxuN36/H7PZjN1ux2KxoFZHZoHLdbjZkl8BQOdmNlJjT2wCB+kkV1kZCoT+OPB7bLPBa6/JQEiSJOkMIIMhSToDVVRUkJ+fj7p0OzZ/IYG4VgTjWhFUgmwt30qZr4xW1lYkm5JrPYdGs5PY2CdRq/OrSqioGIPHM+CEPAePx4PX68VkMpGUlITVao1a5dvjD5Kd6wwvntou2YpBK3uDpGpqCoRefx0OrHYvSZIknd5kMCRJZxin00l+fj4Gxw4s/iICca0JxrbEG/Sy2bEZr+KlY2xH4vRxtZ5Dr/+emJjpqFQeABQlDqfzMQKBzse9/T6fD7fbjV6vJzk5GZvNhlYb+VImhGBPiZvthRVoNSrOTosjKcZw3NsmnWIqKkKB0J9/hrZtNpgzB9q3b9x2SZIkSSeMDIYk6QzicDjIz8vD5NyBOVBCwN6eYEwzKvwVbHZuRoWKznGdMWvNtZxBwWx+H7P53XBJINAWp3MKipJ0XNtetVaQRqMhISGBuLg49DVk+KrwBtiY68Th8tPcbqJtklUunipFKy+HMWNgw4bQdmxsqEdIBkKSJElnFPkJQZLOAEIISkpKyMvdj9m5DXOgBH9CR4IxzSj2FpNdlo1BbeCs+LNqDYRUKjc2W2ZEIOT19qGs7MXjGggpikJFRQUulwubzUbz5s1p0qRJVCCkKILthRX8vLMYf1ChR3o8HVNsMhCSajZt2sFAKC5O9ghJJx2VSsWSJUtq3Z+ens6sWbNqrJ+Tk4NKpWL9+vXHtY2SdDqQnxIk6TRXFQgV5OdhLd+GKejAn9QZxZrKPtc+tjq3Em+Ip1NcJ/TqmlNnq9V5xMZORK///kCJisrKUZSXPwQcn4UUhRB4PB7Ky8sxGAw0a9aM1NRUTKbo5AcOl5+fdpaQU1RJywQLF7ZKIM4s14WR6jBuHDRrBvHxMHcutGvX2C2STjKjRo1CpVLx3HPPRZQvWbLkqNPxFxQU8I9//IMWLVpgMBhISUmhf//+rFmzpt7nWLt2LXffffdRtUOSJDlMTpJOa4qiUFJSQlFBPrEV29ErFfiTuhAwxrOzfDuFnkKampuSZk6r9c1dp/sDm+0ZVKpyAIQwU17+ED7f+cet3X6/H5fLhV6vJyUlBZvNFpUcAUKLp24vrGRPiQubScf5rezEGHXHrV3SaSQ5ORQEuVzQunVjt0Y6SRmNRp5//nn+8Y9/EB8ff8zOe8MNN+D3+3nrrbdo3bo1+fn5LF++nJKSknqfIynp+A5NlqQzhewZkqTTlKIoFBUVUZifS1zFVvSKC1+Ts/EZYtnk2ESRp4jWMa1pYWlRSyAkMBo/JTZ2cjgQCgabUVY267gFQoqiUF5ejsfjwW63k5aWRnx8fI2BUFGFlx93lLC/zE375BjOS4+XgZBUO6cTfL7IspQUGQhJderXrx8pKSlMmzat1joff/wxnTt3xmAwkJ6ezowZM+o8Z1lZGatXr+b555+nb9++tGzZkvPPP5/Jkydz9dVX13rcU089RXJycnjo26HD5CRJOjKyZ0iSTkPBYJCioiJKCvOxu7ahFX58yWfj1hrYVPYXfsVPp9hO2PS1LYrqx2p9DaPxy3CJz9eD8vKHEMJ6XNrsdrvx+XxYrVbsdjtms7nGIC168dR4uXiqVDenE+69FxISYPp0qCHxhtQIFi4MPQ6nY0eYOTOybMIE2LTp8MfeckvocYQ0Gg2ZmZncfPPN3H///TRv3jxi/y+//MKQIUN44oknGDp0KD/88AOjR48mISGBUaNG1XhOq9WK1WplyZIlXHjhhRgMdWe6FELwwAMPsGTJElavXk07OaRTko4pGQxJ0mkmGAxSUFCAozgfe+V2tATxJXfDoVLYUvoXWrWWLvFdMGpqnuujUpUeWEh1Q7jM7R5MZeVtHI/O5EAgQGVlJXq9ntTUVGw2W9SiqVXyHB4255cjhCCjqY2mcXLxVOkwHI5QILRlS2g7MxOeeKJRmyQdUFkJBQWHr5dcw3pnpaX1O7aysuHtOsR1113HOeecw9SpU8nKyorYN3PmTC677DIef/xxANq3b092djYvvvhircGQVqtlwYIF3HXXXcyZM4dzzz2XPn36MGzYMLp27RpRNxAIMGLECNatW8f3338fFYxJknT05DA5STqNBAIB8vLycBTlYa/chlal4EvpRqHiYWPZRkxaE53jOtcaCGm124iPv79aIKSjvPxBKivv4Fi/XAghqKiowO12Ex8fT1paGnFxcTUGQh5/kN92l/LXPgd2s56ebRJkICQdXllZZCCUkAC1fECVGoHFAk2aHP5R01yd+Pj6HWuxHJOmPv/887z11ltkZ2dHlG/cuJGLLrooouyiiy5i69atBINBVq1aFe4JslqtLDzQE3bDDTewf/9+Pv30U/r378+3337Lueeey4IFCyLONX78eNasWcOqVatkICRJx4nsGZKk04Tf7yc/P5+K0gISXNtRqdX4kruxx1vMXtdekoxJtLK2Qq2qOagxGFYSEzMTCM2rUJREnM7HCQSOfbrhqoVTzWYzCQkJWCyWGofECSHYW+pmW2EFWrWKrmmxNIk5PtnrpNNMVSC0dWtoOzExlDChZctGbZZUzdEMYTt02Nxx1rt3b/r3788jjzwS0eMjhIh67RJChH/u0aNHRHrr5Gq9XEajkcsvv5zLL7+cKVOmcOeddzJ16tSI819++eW8//77fPXVV9xyFMP9JEmqnQyGJOk04PP5yM/Px1WaHwqEtHo8SV3Z7tpLsbeYNHMazSzNajlawWx+C7P5w3BJINAJp/MxFMV+TNupKAqVlZWo1WqSkpKIi4tDq635ZejQxVPbJFnRyTWDpPooLQ0FQtu2hbaTkkKBUIsWjdsu6ZT23HPPcc4559C+2npUGRkZrF69OqLeDz/8QPv27dFoNJhMJtq2bVuv82dkZEStKzRw4ECuueYabr75ZjQaDcOGDTvq5yFJUiQZDEnSKc7r9ZKXl4enLB+7azsqnYnKpM5sqdxBhb+CdjHtSDAm1HisSlVJTMwL6PU/h8s8niuoqLgPOLaTzD0eD16vl5iYGBISEmpcLwhCi6fmFFeSU1yJUauhR3q8XDNIqr+SklAgtH17aFsGQtIx0qVLF2655RZeeeWVcNnEiRM577zzePrppxk6dChr1qxh9uzZvPbaa7Wep7i4mBtvvJHbb7+drl27EhMTw7p163jhhRe49tpro+pfd911vPPOOwwfPhytVsvgwYOPy/OTpDOVDIYk6RTmdrvJz8/H58gnwb0DDFYc9nZscm5BQSEjLoMYXUyNx2o0+7DZnkCj2XugRE1Fxd14PAOBo1tQsLpgMEhlZSU6nY6UlBRiY2NrTZDgcPnJznXi8gVomWChdaIFtfrYtUU6zZWWwj33wI4doe0mTWDOHBkIScfM008/zYcfHuxFP/fcc/nwww+ZMmUKTz/9NKmpqTz11FO1Jk+AUDa5Cy64gJdeeont27fj9/tJS0vjrrvu4pFHHqnxmMGDB6MoCsOHD0etVnP99dcf66cmSWcslag+uPUM4HQ6iY2NxeFwYLPVllZYkk5+LpeLvLw8lPIC4lw7EMZYimJbsKViB3q1ng6xHWpNlKDTrcNmew6VKpRpSQgrTucj+P3djmkbq3qDbDYbCQkJGI01tycQVNhRVMnu4tDiqZ1SY+SaQVLDud0wbhz8+msoEJo7F9LSGrtVp5WGvod6PB527txJq1atav37lyRJOtYa8toje4Yk6RRUUVFBfn4+VOQT785BMdnZF9OEHeVbidXF0s7WDq26pj9vgcn0HyyWeYACQDDYAodjKorS9Ji1r2pukFarJTk5udYscQDFFV425pbjDyq0S7bSwl7z+kKSdFgmE8yaBc8+GxoqJ7NvSZIkSYchgyFJOsWUl5eTn5+PujKfWFcOQVMS200WcitySDYmk25NryWY8BET8zIGwzcHS3wXUl7+fwhx7NJUe71ePB4PMTExJCYm1vqNTPXFU+Mtes5NjcOsly9J0lEym0PBkCRJkiTVg/zkIUmnEIfDQUFBAbrKPGLcu/GZm7BJp6HUk09LS0tSzak1HqdWF2GzPYVWuzVc5nLdjMt1C8dq/SBFUXC5XKhUKpo0aUJ8fLxcPFU6voqK4Lnn4JFHwH5sMx9KkiRJZwYZDEnSKUAIgcPhID8/H6M7D6t7L25LEzaoFdz+SjrYOhBvqGFhQkCr3YjN9gxqdcmBcxkoL5+Iz3fxMWtf1bpBVquVhIQEzGZzjfU8/iCb8sopKveSbDPSPsWKQas5Zu2QziCFhfCPf8Du3aHHnDkyIJIkSZIaTAZDknSSE0JQUlJCUVERZvd+zO79OK1N+AsPCOgc1xmLruZV1g2GZcTE/BMIAKAoTXA4phAMtjlmbausDCVhSEpKIj4+Ho0mOriRi6dKx1RBQShr3O7doW2PB7zexm2TJEmSdEqSwZAkncSEEBQXF1NUVITVvReTJ59CSwKbhQujxkgHWwf0mprW4AlisbyJybQkXOL3d8HpfAQh4o5J2/x+Py6XC7PZTGJiIhZLzQFZ5YHFU8tcfprFm2jbRC6eKh2FQwOhpk1DWeNSax4iKkmSJEl1kcGQJJ2kFEWhqKiI4qIibJ69GL2F7DHFsUO4iNfH09bWFo0quhdGpSrHZpuGTvdbuMzj+TsVFf/gWPzJCyFwu90Eg0HsdjsJCQlotdHnVRTBrhIXO4sqMGo1dG8ZT7xFLp4qHYWCgtDQuD17QtvNmoUCoZSUxm2XJEmSdMqSwZAknYQURaGwsJCS4mJiPbvRe4rYYo4hV+Ul1ZRKC0uLGjPGaTS7sNmeRKPJrSqhomI0Hs9Vx6RdgUCAyspKjEYjycnJWK3WGtvhcPvZmOuk0hugZYKZVolWNHLxVOlo5OeHAqG9BxYJbtYM3ngDkpMbt12SJEnSKU0GQ5J0kgkGgxQWFlJaUky8ZzcqTxF/Gk2UqoK0srYi2VTzhz+9/kdiYl5ApXIDIEQsDsdjBAJnHZN2ud1u/H4/8fHx2O129ProXp6gItheWMGeEhdWg5bzWtmxycVTpaOVlxcKhPbtC203bx4KhJo0adx2SZIkSac8GQxJ0kkkEAhQUFCAo7QEuyeHoLeYPw1GPFodHW3tiNPH1XCUwGRahMXyNiAOnKcNTucUFOXoPywGg0EqKyvR6XSkpqZis9lq7A0qrvCyKa8cbyBI2yZy8VTpGPrPfw4GQmlpoaFxMhCSJEmSjgEZDEnSScLv95Ofn0+5o5QETw4uTxF/GQ2o9FY6x3bArK0pXbWbmJiXMBhWhUu83t6Ul48Hjj5bm8fjwev1YrPZSExMxGAwRLc7GFo8NbcstHhqtxZy8VTpGLvnntCaQuvXh1Joy0BIkiRJOkbkJxZJOgn4fD7y8/OpcJaR4N5BmbeQjUYTJmMi7WPbo1dHD0lTq/MPLKS640CJisrKkbjdQ4Cj65FRFIXKyko0Gg3JycnExcXVuIBqvtPD5rxyFCHo1NRGM7l4qnQ8qNXw2GNQXg6xsY3dGkmSalFcXEynTp34+eefSU9Pb+zmSKepwYMH06tXLyZMmHBMzifz20pSI/N6veTm5lLpKCHBtY1cdy5/GUzEWZrTKa5TjYGQTvcn8fH3hwMhIUw4nVNwu4dytIGQz+ejvLwci8VCs2bNsNvtUYGQxx9k/Z4y/tzrIM6s48LWCTIQko6d/fthy5bIMrVaBkLSCTVq1ChUKhX33HNP1L7Ro0ejUqkYNWrUiW/YIaraqVKp0Gq1tGjRgnvvvZfS0tKIenv27OGOO+6gadOm6PV6WrZsybhx4yguLo46Z15eHmPHjqV169YYDAbS0tK45pprWL58eZ1tmTZtGtdcc02NgdAPP/yARqNhwIABUfsuueQSHnjggajyJUuW1Djc+kjbd7Ree+01WrVqhdFopHv37qxatarWuunp6eH/l+qP++67L1ynvLycBx54gJYtW2IymejVqxdr164N7w8EAjz22GO0atUKk8lE69ateeqpp1AU5bg+T2jYcz2SY6ZNm4ZKpYr6f582bRrnnXceMTExNGnShEGDBrF58+aIOlOmTOHZZ5/F6XQe0XM7VKMHQw292QsXLuTss8/GbDaTmprKbbfdVuMfsiSdCjweD7m5uXjKS4mv3MJO9162m200i21L25iaU2cbjf8jNnYyKlXoRSAYbEpZ2Uv4fBceVVuEEJSXl+Pz+UhKSiI1NRWTyRRVZ2+pizU7inG6/XRNi6Vr8ziMuuh2StIR2bcP7r4b7r0Xtm5t7NZIZ7i0tDQ++OAD3G53uMzj8fD+++/TokWLRmxZpAEDBpCbm0tOTg5vvvkmn332GaNHjw7v37FjBz169GDLli28//77bNu2jTlz5rB8+XJ69uxJSUlJuG5OTg7du3fnm2++4YUXXuDPP//kyy+/pG/fvhEf5A/ldrvJysrizjvvrHH/vHnzGDt2LKtXr2Z31TphR+BI23e0Fi1axAMPPMCjjz7Kb7/9xsUXX8yVV15Z63NZu3Ytubm54ceyZcsAuPHGG8N17rzzTpYtW8Y777zDn3/+yRVXXEG/fv3Yd2CO5PPPP8+cOXOYPXs2Gzdu5IUXXuDFF1/klVdeaVDbL7nkEhYsWHDcnmtDj1m7di1vvPEGXbt2jdq3cuVK7rvvPn788UeWLVtGIBDgiiuuCC/wDtC1a1fS09NZuHBhvZ9TnUQj+uCDD4ROpxP/+te/RHZ2thg3bpywWCxi165dNdZftWqVUKvV4uWXXxY7duwQq1atEp07dxaDBg2q9zUdDocAhMPhOFZPQ5KOSGVlpdixY4fY/NdvIvfH98W3374kFv/ygVi/fb3Yt29fDY8c4XA8JLzeruFHRcUosX//plrq1/+Rk5MjsrOzRU5OjqioqKixvRUev1i7s1gs25AnNuxzCF8geILvmHTa27NHiKuuEqJ799DjrruEUJTGbpVUTUPfQ91ut8jOzhZut/s4t+zYGzlypLj22mtFly5dxLvvvhsuX7hwoejSpYu49tprxciRI4UQQiiKIp5//nnRqlUrYTQaRdeuXcW///3viPN98cUX4qKLLhKxsbHCbreLq6++Wmzbti2iTp8+fcTYsWPFgw8+KOLj40VycrKYOnVqvdpZ3YQJE4Tdbg9vDxgwQDRv3ly4XK6Ierm5ucJsNot77rknXHbllVeKZs2a1fheUFpaWms7Pv74Y5GYmFjjvoqKChETEyM2bdokhg4dKp588smI/X369BHjxo2LOm7x4sXi0I+qR9q+o3X++edH3CchhOjYsaN4+OGH63X8uHHjRJs2bYRy4DXN5XIJjUYj/vvf/0bUO/vss8Wjjz4qhBDi6quvFrfffnvE/uuvv17ceuutDWp7nz59xPz58+td/0iea32PKS8vF+3atRPLli2r9f+9uoKCAgGIlStXRpQ/8cQT4uKLL671uIa89jRqz9DMmTO54447uPPOO+nUqROzZs0iLS2N119/vcb6P/74I+np6dx///20atWKv/3tb/zjH/9g3bp1J7jlknR0Kisryc3NxV9Zisn5F3+491Fma05H+9kkGZOi6qtUpcTGPoLR+EW4zO2+DofjKYSIOeJ2CCGorKzE4/GQkJBAs2bNsFgsEXUURbCzqJKfdhbjCyic2zKejKY2dJpG71iWTid79oR6hPLzQ9utW8Nzz4HMSHiaGg5cdYIfw4+opbfddhvz588Pb8+bN4/bb789os5jjz3G/Pnzef3119mwYQPjx4/n1ltvZeXKleE6lZWVTJgwgbVr17J8+XLUajXXXXdd1JCnt956C4vFwk8//cQLL7zAU089Fe5VqI8dO3bw5ZdfotOFljUoKSnhq6++YvTo0VG9/SkpKdxyyy0sWrQIIQQlJSV8+eWX3HfffVHvBQBxcXG1Xve7776jR48eNe5btGgRHTp0oEOHDtx6663Mnz8fIUS9n1OVo2lfZmYmVqu1zkdto5N8Ph+//PILV1xxRUT5FVdcwQ8//HDYdvt8Pt59911uv/328LC/QCBAMBjEaIxMdmQymVi9ejUAf/vb31i+fDlbDgwb/v3331m9ejVXXXVs1g6sra0Nfa4NOea+++7j6quvpl+/fvVqj8PhAMBut0eUn3/++fz88894vd56nacujZZAoerGPfzwwxHldd3sXr168eijj/L5559z5ZVXUlBQwEcffcTVV19d63W8Xm/EjTpW4wsl6UiVl5dTUFCAcDvQOf/kT18BxLeni70LRk10BjiNZhuxsU+hVhceKNFRXn4/Xm/9XkhqU7WAqslkIjExEYvFEjU2Wy6eKp0Qe/aE1hEqKAhtt24dyhp3yJufdDopBgoauxH1Mnz4cCZPnkxOTg4qlYrvv/+eDz74gG+//RYIBTkzZ87km2++oWfPngC0bt2a1atXM3fuXPr06QPADTfcEHHerKwsmjRpQnZ2NmeddXA9uK5duzJ16lQA2rVrx+zZs1m+fDmXX355rW3873//i9VqJRgM4vF4gNAXzgBbt25FCEGnTp1qPLZTp06UlpZSWFhITk4OQgg6duzY4PuUk5ND06ZNa9yXlZXFrbfeCoSG9FVUVLB8+fJ6fyCusm3btiNu3z333MOQIUPqrNOsWbMay4uKiggGgyQfsshzcnIyeXl5h732kiVLKCsri5hjFhMTQ8+ePXn66afp1KkTycnJvP/++/z000+0a9cOgIceegiHw0HHjh3RaDQEg0GeffZZbrrppjqvl5mZSWZmZnjb7Xbz448/MmbMmHDZF198wcUXX3xMnmt9j/nggw/49ddfI+ZF1UUIwYQJE/jb3/4W8TcCof8rr9dLXl4eLVu2rNf5atNowdCR3OxevXqxcOFChg4disfjIRAIMHDgwDrHTk6bNo0nn3zymLZdko6U0+kkPz8fjc+Jr/QXNgYdGBO70CEuA606+s/RYFhJTMxMwAeAothxOh8nEGj4G0EVIQRut5tAIEB8fDwJCQnhbxCrBBXBjsIKdpe4sMjFU6XjaffuUCBUeCDYb9MGXn9dBkKnvYRT5pqJiYlcffXVvPXWWwghuPrqq0lMTAzvz87OxuPxRAUrPp+Pbt26hbe3b9/O448/zo8//khRUVG4R2j37t1RwVB1qampFBTUHTj27duX119/HZfLxZtvvsmWLVsYO3ZsvZ5fVQ+NSqWK+Lmh3G53VC8HwObNm/n555/5z3/+A4BWq2Xo0KHMmzevwcHQ0bTPbrdH9S401KHXFULUqy1ZWVlceeWVUcHiO++8w+23306zZs3QaDSce+653Hzzzfz6669AqEft3Xff5b333qNz586sX7+eBx54gKZNmzJy5Mhar3do4HfLLbdwww03cP3114fLagv8jua51nXMnj17GDduHEuXLq3x96QmY8aM4Y8//gj3lFVX1cvpcrnqda66NHpq7Ybc7OzsbO6//36mTJlC//79yc3N5cEHH+See+4hKyurxmMmT54ckXrP6XSSlpZ27J6AJNWDEAKHw0FBQQE6v5Oy4h/ZrbixJ/egla0datWhQ84UzOa3MZsXhUsCgfYHFlI98g8RwWCQiooKDAYDTZs2JSYmJurvraTSx8ZcJ95AkDZJocVT1bI3SDoedu8ODY0rKgptt20bCoTi4xu3XdIJ8E5jN6BBbr/99vC36q+++mrEvqqg5n//+1/UB8zqa7Ndc801pKWl8a9//YumTZuiKApnnXUWPp8v4phDv5xSqVSHzR5msVho27YtAP/85z/p27cvTz75JE8//TRt27ZFpVKRnZ3NoEGDoo7dtGkT8fHxJCYmotFoUKlUbNy4sca6dUlMTIzKYAehQCAQCETcGyEEOp2O0tJS4uPjsdls4eFQ1ZWVlWGz2cLb7dq1O+L2HdpbUpPaekuq7s2hX9YXFBREfal/qF27dvH111+Hg8Hq2rRpw8qVK6msrMTpdJKamsrQoUNp1aoVAA8++CAPP/www4YNA6BLly7s2rWLadOm1RkMHRr4mUwmmjRpEv4dqcuRPNf6HPPLL79QUFBA9+7dw/uDwSDfffcds2fPxuv1otEcTMY0duxYPv30U7777juaN28edc2qpB9JSdFTCxqq0Qb9H8nNnjZtGhdddBEPPvggXbt2pX///rz22mvMmzeP3NzcGo8xGAzYbLaIhySdSEIISktLyc/PR+crIa/wO3YLL02b9qZNbIeoQEilcmGzPRURCHm9l1FW9uJRBUIej4eKigpiY2Np1qwZNpstIhDyBxU27Hfw665SjDo1F7ZOID3RIgMh6fioqAj1CFUFQu3ahYbGyUBIOgkNGDAAn8+Hz+ejf//+EfsyMjIwGAzs3r2btm3bRjyqvnwtLi5m48aNPPbYY1x22WXhoWnHy9SpU5k+fTr79+8nISGByy+/nNdeey0iKx6EUlRXjbhRqVTY7Xb69+/Pq6++GpG9q0pZWVmt1+zWrRvZ2dkRZYFAgLfffpsZM2awfv368OP333+nZcuW4WxgHTt2rHH+99q1a+nQoUN4+2jad88990S0oaZHbXOe9Ho93bt3j5q7tWzZMnr16lXrNQHmz59PkyZN6pzSYbFYSE1NpbS0lK+++oprr70WCPV6HLq0hUajOa6ptY/kudbnmMsuu4w///wz6n7fcsstrF+/PhwICSEYM2YM//nPf/jmm2/CgeGh/vrrL5o3bx7RS3ukGq1nqPqNu+6668Lly5YtC/8SHMrlcqHVRja5+s2TpJONEILi4mKKiorQ+YrIKVpNhdZI6+aXkmCM/gPWaPZhsz2JRrPnQImayso7cbsHcaTrBymKQkVFBTqdjtTUVGw2W9SLa4HTw6a8coIHFk9tGms8omEIklRvVisMHw4zZ0L79qEeIbmOkHSS0mg0bNy4MfxzdTExMUyaNInx48ejKAp/+9vfcDqd/PDDD1itVkaOHBkekvzGG2+QmprK7t27o+ZMH0uXXHIJnTt3JjMzk9mzZzN79mx69epF//79eeaZZ2jVqhUbNmzgwQcfpFmzZjz77LPhY1977TV69erF+eefz1NPPUXXrl0JBAIsW7aM119/PXwfDtW/f38mT54c7u2B0Fym0tJS7rjjDmIP+fsePHgwWVlZjBkzhtGjRzN79mzuu+8+7r77bkwmE8uWLSMrK4t33onsRTzS9h3tMLkJEyYwfPhwevToQc+ePXnjjTfYvXt3xDpUs2fPZvHixeH1jhRFYf78+YwcOTLq8yvAV199hRCCDh06sG3bNh588EE6dOjAbbfdBoR6E5999llatGhB586d+e2335g5c2ZUAo9DVVRUUFFREd7+4IMPACI6IOx2O3p99DqGR/pcD3dMTExM1Lwfi8VCQkJCRPl9993He++9xyeffEJMTEy4zbGxsREJQFatWhWVsOGIHTbf3HFUlVo7KytLZGdniwceeEBYLBaRk5MjhBDi4YcfFsOHDw/Xnz9/vtBqteK1114T27dvF6tXrxY9evQQ559/fr2vKVNrSydKMBgU+fn5YuPGjWLT+m/EV18/I/63arbYvLPmVNgFBZ8Jj6dnOG22x9NTFBR8elQps3fs2CGys7PFnj17akwv6fYFxPrdpWLZhjyxfnepcPsCjXCnpDPa//4nRFlZY7dCqqczMbV2bQ5Nrf3yyy+LDh06CJ1OJ5KSkkT//v0j0gEvW7ZMdOrUSRgMBtG1a1fx7bffCkAsXrw4XKemVMPVr9OQdi5cuFDo9Xqxe/duIYQQOTk5YtSoUSIlJUXodDqRlpYmxo4dK4qKiqKO3b9/v7jvvvtEy5YthV6vF82aNRMDBw4UK1asqLUdQghx4YUXijlz5oS3//73v4urrrqqxrq//PKLAMQvv/wihBBi3bp1on///qJJkybCZrOJHj16iPfff7/GY4+0fUfr1VdfDV/z3HPPjUr3PHXqVNGyZcvw9ldffSUAsXnz5hrPt2jRItG6dWuh1+tFSkqKuO+++0RZtddDp9Mpxo0bJ1q0aCGMRqNo3bq1ePTRR4XX662znVOnThVAnY/D3auGPtf6HHOomn7fa2tv9dTgbrdb2Gw2sWbNmlrP3ZDXHtWBCzea1157jRdeeIHc3FzOOussXnrpJXr37g2EVlXOyckJZ2wBeOWVV5gzZw47d+4kLi6OSy+9lOeff/6wE8GqOJ1OYmNjcTgccsicdNwoikJhYSElJSUonl3sKl6L1pJCu2aXYdAeOnFQYDItwWJ5Ewh1fQeDaTidUwkG6/d7XdP1KysrUavV2O124uPjI3qDhBDsK3OztaACjUpFx5QYmtjqN6FRko6Yzwe1fBMpnRoa+h7q8XjYuXNneHF16fT2+eefM2nSJP7666+oEQiSdKy8+uqrfPLJJyxdurTWOg157Wn0YOhEk8GQdLwFg0EKCwspLS3F69rCnpL12GytaN2sLxq15pDaPmJiXsFg+Ppgie8Cysv/DyHMR3R9n8+H2+3GarWSkJCA2Rx5HpcvwMZcJ6WVfprGmWiXbJVrBknH344dMGYMPPwwHPjCSzr1yGBIOpyXX36Z66+/Xiarko6bN954gz59+kTMJzuUDIbqIIMh6XgKBAIUFBRQVlaGs+J3Ch2bSbR3pkVKr6g5OGp1CTbb02i1m8JlLtdQXK4RHEluE3FgAVUhRHhsdPWx7Yoi2F3iYkdRBQathk6pNuwW+S29dAJs3w733AOlpaDVwiuvwHnnNXarpCMggyFJkk4FDXntafTU2pJ0uvD7/eTn5+NwlFHkXIuzYjdpST1o0uTcqLpa7WZstqdRq4sPlOgpL5+I13tk35gfbgFVp8dP9v7Q4qkt7GZaJ8nFU6UTZNs2uPfeUCAEoWQJR7BgoiRJkiQdDzIYkqRjwOfzkZ+fT4mjmALHj/hcBbRL/Rs2e/SK3wbDcmJiXgb8AChKEg7HVILBNg2+rqi2gGpVb1D1NSrk4qlSo9q6NRQIVaW7zciAV1+FmJhGbZYkSZIkVZHBkCQdJa/XS15eHkXOAvJL16DxOenYvB+m2PRDagaxWOZhMh1ceM3vPwun8xGEaPjaKsFgkMrKSvR6fY0LqJZU+tiU68QTCNI6yUpLuXiqdCJt2RIKhKoWUuzcORQIWa2N2y5JkiRJqkYGQ5J0FDweD3l5eeQ59lFY9hOWoI+2LfqjtUZmgVOpyrHZnkOn+7XasVdSUXEv0PCeGrfbjd/vJzY2loSEhIi1AvxBha35FewvcxNn1nF2WhwWg/xTl06gQwOhs86C2bNlICRJkiSddOQnJEk6Qm63m7y8PPaU7aTM8QsJQk16i6tQmSMXU9VodmOzPYVGs6+qhIqKe/B4/t7ga1ZfQDUlJYXY2NiI3qDqi6d2TI2hWZxJLp4qnVibN4cCIacztN2lSygQslgat12SJEmSVAMZDEnSEXC5XOTm5rK9bAtu5x80V5tJTbsUTJHD3fT6n4iJeR6Vyg2AEDaczsfw+7s0+JperxePx4PNZiMhISEiO4rHH2RzXjmF5V6SYgx0SInBqDs0jbcknQAlJeAO/b7TtWsoc5wMhCRJkqSTlAyGJKmBXC4Xe/fvZWtpNkrFZtrp7MQ3743QV58ULjCZPsRieYvQ4skQCLTG6XwcRUlp0PUURcHlcqFSqUhOTiYuLi5iMbt9ZW625pejVqno0jyWZLl4qtSYevaE6dPh3XdhxgwwH9l6WZIkSZJ0IshgSJIawOVysWf/HjYW/47elUOGIRlz04sQ+urffHuIiXkJg+G7cInXezHl5eMBU4OuV9cCqqHFU8sprfSRGmekfXKMXDxVOjlcdBH06gVyiKZUh2AwiKIoJ+RaarU6Yt01SZKkKjIYkqR6crvd7Nm/h+yiXzG4d3OWsTm6phcgdAcDFLW6AJvtKbTa7eEyl2sELtcwoP4fDKsWUAVISkoiPj4+/EYuhGBX8cHFU7u1iCPBajg2T1KSGio7G9avh5tvjiyXgZBUh2AwyN69e/H7/SfkejqdjubNm58RAdEll1zCOeecw6xZs06K80jSyU4GQ5JUD+FAqPBXjO4cOpvT0Ta9AKE9OCRNq/2L2NhnUKlCGbSEMFFe/iA+X88GXevQBVSt1TJwOT1+Nu53UuENkGY300Yunio1pg0bYPRoqKyEQABGjGjsFkmnCEVR8Pv9qNVqtNrj+1EkEAjg9/tRFOWEBkPfffcdL774Ir/88gu5ubksXryYQYMGHfH5ZHAiSceHHFMjSYfh8XjYu38v2flrMbh20tnSGm2znlAtEDIaPycu7uFwIBQMplJW9lKDAiEhBC6XC7fbjd1up1mzZuFAKKgIthWUs3ZnCQLokW6nfXKMDISkxvPXXwcDIYDVqyEYbNw2SaccrVZ7Qh7HwiWXXMKCBQvqXb+yspKzzz6b2bNnH5PrS5J0fMhgSJLqUBUIbcj/Cb07h84xbdE2uxA0Vev6BLBaX8NqfQUIfRD0+8+hrOxlgsGW9b5OMBjE6XSiVqtp2rQpTZo0QacLrT9UWunjpx3F7C5x0TrJyvnpdmJNDV+bSJKOmT//jAyEuneHl1+GM2AIkiTV15VXXskzzzzD9ddfX+9jPvroI7p06YLJZCIhIYF+/fpRWVnJqFGjWLlyJS+//DIqlQqVSkVOTg6VlZWMGDECq9VKamoqM2bMOKK21uc8QgheeOEFWrdujclk4uyzz+ajjz4CYO7cuTRr1ixqDtjAgQMZOXLkEbVJkk4UGQxJUi28Xm8oEMpbE0qWYOuIrumFoA4FIiqVk9jYRzEaPwsf43YPwuF4BiFiajttFLfbTWVlJXFxcTRv3pyYmBhUKhX+oEL2fie/7CpFr1VzQasEWiVaUMveIKkx/fEH3HcfuFyh7fPOCwVCpoYlB5EkKVJubi433XQTt99+Oxs3buTbb7/l+uuvRwjByy+/TM+ePbnrrrvIzc0lNzeXtLQ0HnzwQVasWMHixYtZunQp3377Lb/88kuDr12f8zz22GPMnz+f119/nQ0bNjB+/HhuvfVWVq5cyY033khRURErVqwI1y8tLeWrr77illtuOep7I0nHk5wzJEk1qAqE/tq/Gr1nLxnxndEn9wB16JtvjSaH2NgnUKvzDxyhpbx8LF7vFfW+RvUFVFNTU7HZbOEFUgvKPWzOKyegCDqkxNA8Xi6eKp0E/vgDxow5GAidfz7MnAlGmc5dOv1kZmaSmZkZ3na73fz444+MGTMmXPbFF19w8cUXH5Pr5ebmEggEuP7662nZMjSyoEuXg2vS6fV6zGYzKSmh5RkqKirIysri7bff5vLLLwfgrbfeonnz5g26bn3OU1lZycyZM/nmm2/o2TM0/Lt169asXr2auXPn8t577zFgwADee+89LrvsMgD+/e9/Y7fbw9uSdLKSwZAkHSLcI7TvO/TuvWTYu6JP6Q6qUEeqXv8jMTEvhBdSVZQ4nM7HCQQyGnSNmhZQ9QZCi6cWOL0kxhjoKBdPlU4Wv/8OY8fKQEg6Y9xzzz0MGTIkvH3LLbdwww03RAx7a9as2TG73tlnn81ll11Gly5d6N+/P1dccQWDBw8mPj6+xvrbt2/H5/OFgxMAu91Ohw4dGnTd+pwnOzsbj8cTDpaq+Hw+unXrBoTuz913381rr72GwWBg4cKFDBs27IzI4Ced2mQwJEnVhAOhPd+i9e6nU2I39E26hdMEG42fYLXO5eBCqm1xOqegKEn1On9dC6hWLZ6qkounSiebYBCmTj0YCF1wQSgQMsiU7tLpy263Y7fbw9smk4kmTZrQtm3b43I9jUbDsmXL+OGHH1i6dCmvvPIKjz76KD/99BOtWrWKqi+EOCbXrc95quYC/e9//4sKAA0HXgeuueYaFEXhf//7H+eddx6rVq1i5syZx6SNknQ8yTlDknSAx+Nhz749bNj9DVrvPjomdccQDoQULJY5WK1zqAqEvN7elJW9WO9AyOfzUV5ejslkolmzZtjtdtRqNS5fgF92lbJxv5NEq4GerRNkICSdXDSaUPATHw89e8pASJKOE5VKxUUXXcSTTz7Jb7/9hl6vZ/HixUBomFywWsbGtm3botPp+PHHH8NlpaWlbNmypUHXrM95MjIyMBgM7N69m7Zt20Y80tLSgFCweP3117Nw4ULef/992rdvT/fu3Y/oPkjSiSR7hiSJg1njNu5ZjtaXT8cmF2BMqhqr7cZmewG9/uAbhcs1FJdrBPX5PqFqAVUhRMQCqkIIdpe42FFYiU6jlounSie31q0hKwtSUkCvP3x9SaqHQCBw0l6joqKCioqK8PYHH3wAQF5eXrjMbrejr+XvoaKigm3btoW3d+7cyfr167Hb7bRo0SKq/k8//cTy5cu54ooraNKkCT/99BOFhYV06tQJgPT0dH766SdycnKwWq3Y7XbuuOMOHnzwQRISEkhOTubRRx8NjzaoMnv2bBYvXszy5ctrbKfVaj3seWJiYpg0aRLjx49HURT+9re/4XQ6+eGHH7BareGMcbfccgvXXHMNGzZs4NZbb4261uHaIkmNQQZD0hnP5XKxP28/m/d8jcZXQIfkXhgTQ/N/VKpSYmOnotVuPVBbTUXF/Xg8/et17toWUC33+Mne76TcE6BFgpnWiRa0GtlRK51Etm+HVq2g+gerGj7ASdKRUKvV6HQ6/H4/Pp/vuF9Pp9NFBQmHM336dJ588sk666xYsYJLLrmkxn3r1q2jb9++4e0JEyYAMHLkyBrXK7LZbHz33XfMmjULp9NJy5YtmTFjBldeeSUAkyZNYuTIkWRkZOB2u9m5cycvvvgiFRUVDBw4kJiYGCZOnIjD4Yg4b1FREdu3b6/zedTnPE8//TRNmjRh2rRp7Nixg7i4OM4991weeeSRcJ1LL70Uu93O5s2bufnmm6OuU5+2SNKJphLHatDpKcLpdBIbG4vD4cBmszV2c6RGJITA4XCQX5DHtv3LUfmL6ZB6MSZ7aNKoRrOL2Nip4YxxQphxOh/F7z+3Xud2u90EAgHi4+Ox2+3odDoURbCjqJJdxZWY9VoyUm3EmuWaQdJJZt06eOABuPRSeOKJyIBIOqM19D3U4/Gwc+dOWrVqFU4UUyUYDEatS3O8qNVqOZFfks4gdb32HEr2DElnpEAgQHFxMUXFhewp/A5VoIQOTftgim8HgE73Ozbb06hUoUUlFSURh+MpgsHoSayHCgaDVFZWotfradq0aXjdoNJKHxtznXgCQVolWkhPkGsGSSehtWtDgZDXC59/DhkZMGxYY7dKOg1pNBoZoEiS1OhkMCSdcdxuN0VFRTicpeSVfI/iL6J9s0sxxbYGwGD4mpiYWUBoomog0Aan80kUJeGw5/Z4PPh8PmJjY0lISECv1+MPKmwrKGdfqZs4s46uaXFYDfJPTzoJ/fxzKBCqGrbUuzdUSyMsSZIkSacb+YlMOmMIIXA6nRQVFeH1uckvWY3PW0z75v0w29IBMJn+g8Xyr/AxPt95lJdPRghTneeuvoBqSkoKNpsNtVotF0+VTh0//QTjxx8MhPr0geeeA50cxilJkiSdvmQwJJ0RqobFlZaWolYr5BevxOstpV3a5ZhjQpPCDw2EPJ6rqai4F6h7GEfVAqoxMTEkJiZiNBrxBoJs2e8g3+khwaqnU6pNLp4qnbx+/BEmTDgYCF1yCUybJgMhSZIk6bQngyHptOfxeCgsLKSiogKjUUPO3q9xe8tom3YFlpjmQHQg5HLdist1M1B7L46iKFRWVqJWq2nSpAnx8fGo1Wr2l7nZcmDx1LOaxZISK9cMkk5ia9bAxIkHA6G+fSEzUwZC0jF1ohIlSJIkQcNec2QwJJ22qg+LCwQCmI1adu75Are/nLYtBmC1NgVqC4RuqfPcfr8fl8uF2WwmKSkJs9mM2xdkY14pJRU+UmKNtE+OQa+VWbikk9gvv0QGQpdeGgqEtPKtQTo29Hp96Eui/ftJSkpCr9fLocKSJB03Qgh8Ph+FhYWo1epa1wGrTr7jSaelYDBIcXExJSUl6HQ6zEYN23f9D1egkjYtrsRqSQHAaPysQYGQEAKXy4WiKCQkJGC329FoNOwudrG9sAKdRs05LeJIlIunSqeCNm1Cawdt2waXXQbPPisDIemYUqvVtGrVitzcXPbv39/YzZEk6QxhNptp0aJFvdYXk+960mnH4/FQVFREeXk5ZrMZDV625fyPyqCHti2uJMacDITWEbJa3wgfd7hAKBgMHhhqZwwvoFrhDbBxTylOt580u5k2SXLxVOkUEhcHr78OCxfCPffIQEg6LvR6PS1atCAQCBAMBhu7OZIkneY0Gg1arbbevdDynU86bQghKC8vp7CwkEAgQExMDAQq2JHzORWKj7YtryLGlHSgtkJMzEtA4P/bu/P4uOp6/+Ovc2ZNZrK0TfeWUqBlla3IelFBQAHhglcBQUEEoQIiVEAQr4BbFaXsm7Ipl00R+OEVlwrIInplKbLK1kJL27RN25lsM+fMnPP9/XGaSaZJ2kwy6WR5Px+PPMg5c853PjPJg8yn3+/38wEgk/nPTSZCHSWz6+vrGTduHOFwhPfWdDZP/ejWY9U8VYYHY6DrH4gxY+CccyoXj4wKlmURiUSIaC+aiAwx+idsGRE8z2PNmjWsXLkSY0yQCOVaWPz+YzSbPNvNOILaQiIU7BMKh9/acO9U2tpO7XFc3/dpaWnBGMOkSZOYNGkS7Xn4x5K1LF3XxsyGBPvMVCIkw8TTTwczQO3tlY5ERERkSNDMkAx7juOwZs2awrK4SCSCn13P4qV/pBmP7WZ8mtp4Q+H6UGg5icSvNhxZtLScD3Tf4+O6LplMhpqaGsaNG0ckGuOtVS18uC5DXXWEXaepeaoMI089Bd/6FuTzwUzQDTdAdXWloxIREakofZKTYatjWVxTUxOu61JTU4Nt2/iZtSxe+ieaLdhuxuHUxsZ1ucsnmVwA5ADIZI4mn9+527htbW0AjB8/njFjxrCuPc+/P1xL3lPzVBmGnnwSLr4YOvZrTJ0KcZV8FxERUTIkw5Lneaxfv561a9cSCoWora0FwLSvYfGyP5O2Q8za6lPUxsYU3ReP/45I5I0NY0yire2Uosc7EqyOIgmReBVvNrbSmFbzVBmmnngCLrmkMxE64gi4/HLoQ4UdERGRkU7JkAw7PS2LAzBtjbz34eOkQxFmTT+M2lh90X22vYJE4s7CcWvr+UBV4dgYU6gWN3nyZNZlfd56by2WZbHz1Fom11UhMqxsnAgdeSRcdpkSIRERkQ2UDMmw0ZGsrFmzpmhZHAAty3lv+ZOkIzG2m3ZIt0QoqB53DZblAJDNfoZcbtduY0ejUerGjuf1Ve1qnirD21/+At/+NnR04f7MZ+C731UiJCIi0oWSIRkWNl4WV1NTU9izYzUv490VT5OKVjFr6iep65YIQTz+GJHIqwD4/gTa2r5S9HhrayuRSIRcrI6XV7QRCdnsNr2e8TVqnirD0MKFcOmlnYnQ0UfDd76jREhERGQjSoZkyHMch6amJpqbm6mqqiIajRYes1JLeLfxOdbHqpk19WDqonXd7rftVSQSdxSOW1q+gTGdS97a2trIGZs1uSqyWTVPlWHOmCAZUiIkIiKyWUqGZEjraKLqOE7xsjjAXv8u76z6P9bFa5g15WM9JkJgqKm5FsvKAJDNfopcbs/Co77vk253afQSjK2LsNf0Wuqroz2MIzJMWBb88IdBGe0xY4IZIiVCIiIiPVIyJEOS7/usW7eOtWvXYts2tbW1RaWs7bVv8e6aF1hXVcesyf9BfbS+x3Hi8T8RiSzaMGYDbW1fLXrccRxSuRC1NVXsO3Mctq1y2TICRCLwk59AKKRESEREZBP0V1KGHNd1WblyJWvWrCEWi5FIJDoTIWOwm97g3TUvsLZ6zCYTIdtuIpH4ReG4peVcjEkUjo0xZLIOGaJMG5tQIiTD1+OPw4oVxeciESVCIiIim6G/lDKktLa2snz5clpaWqipqSnaH4TxCTW9xrtNi1ibGMesSfv3mgiBIZm8DstqB8BxDiGX+2jRFa7r0py3icRiTKlX2WwZph57LCiffeaZ3RMiERER2SQlQzIk+L7P2rVrWbFiBfl8vtv+IIxPaPWrvLvuVdYmxzNr4r6bSIQgFnucaPT5DWOPpbX1jG7XOI5Dmx9hQl21GqnK8PT73wd9g3wfVq6E3/2u0hGJiIgMK9ozJBXnui5NTU2k0+lu1eIA8D1Cq1/m3fRbNCUnMGv8XptMhGx7HcnkLYXj1tavY0xN0TX5fB7Hg5wVZapmhWQ4+t//hSuuCKrHARx3HJzRPekXERGR3ikZkorqaKKazWZJJpOEQhvN0Pg5wqv+xTvN77KmZiKzxu25yUQoWB53PZbVBoDjfALX3bfbVZlMhlY/QnU8xvikegnJMPPoo/D97xcnQhdeGFSSExERkT5TMiQVYYxh/fr1NDU1AXSrFgeA5xJetYh3Wt/fkAjtzpjYmE2OG4s9RTT6DwB8v57W1q91u8b3fTzfp9WPsHV9lQonyPCycSJ0wgnwzW8qERIREekHJUOyxXmeR1NTE+vWrSMejxOL9TAzk3eCRKh9GWtqJjFr7K6bTYQsaz3J5E2F49bWszGmttt1mUyGLBHscIQp9fEBvx6RLeaRR+AHP+g8/sIXYN48JUIiIiL9pGRItijXdVm9ejXNzc0kk0nC4R5+BfNZwo0v8U5mOWtqJrDdmI9sNhECSCZvwrJaAHCcA3Hd/+h2jTGGfD5POzXUVceoiUcG/JpEtojXXy9OhE48Ec4/X4mQiIjIAKianGwx7e3trFixgtbWVmpra3tMhKxcO9GVL/BOtpE1NZPYbsxHGBsbu9mxo9FniMWeBcCYmh6Xx0FQQc4KRWj3bCbXaVZIhpGddoKTTw6+/+IXlQiJiIiUgWaGZItoaWlh9erVhbLZ3fYHAZbbSmTVy7zlrmFVcgKzx+zUp0TIstI9LI/reSbJcRycSC3hcIhJSoZkOLEs+PrXYc894YADlAiJiIiUgWaGZFAZY0in0zQ2NmKM6T0RcpqJNL7E27m1rEqO73MiBJBM3oJtpwBw3f1wnI/1eJ3rukQiEVI5mwk1cSIh/frLELduXfGxZcF//IcSIRERkTLRp0EZNB0V4xobGwmFQlRXV/d4nZVdT6RxEW97aRqTDcyq37HPiVA0+g9isb9ueL4kra3nAD1/UMxms/jhKvLGVm8hGfp+/Ws45hj4178qHYmIiMiIpWRIBoXv+6xdu5bVq1cTjUaJx3tekmZn1hJZ9S/e8ltoTIxjVt0OjIuN69NzWFYLyeT1hePW1jPx/Z6TqHw+j2VZtPhhqqIh6qtVOEGGsAcegCuvhPb2YGncypWVjkhERGREUjIkZef7PmvWrGHNmjW9l84G7PbVhFe/wlumnVWJccyq277PiRBAMvlzbDtYRuS6H8VxPtnrtdlslnh1grQDU+qrelyqJzIk3H8//PSnnccnnACTJlUuHhERkRFMBRSkrPL5PGvWrCGVSpFIJHounQ3YrY2Em97gbTvHqqoxzKqdXVIiFIk8Tyz2FwCMqaa19Vx6Wx7n+z6+75O1Yhh8VZGToevee2HBgs7j00+HM8/UHiEREZFBomRIyiaXyxX1EAqFQj1eF2pZTmjtW7wV8lkVq2NW7SzGxfueCFlWGzU11xWO29rOwPcber0+m80Sj8dpdCzGJqLEIz3HJVJRGydCX/0qnHGGEiEREZFBpGVyUhau69LY2EhzczM1NTW9J0LNS4NEKAyrYsmSEyGAROI2bLsJgFxuT7LZw3q91hhDLpcjUpWk1fFUOEGGpv/5n+JE6IwzNCMkIiKyBWhmSAbMGMO6detobW2lpqYG2+45xw6llhBKLeHtaIhVkRjb1WxXciIUiSwiHv/jhuetoqXlG/S2PA6CvkLRaJR0LkQkbGhI9rx/SaRi7r4brr228/iMM4IvERERGXT9mhnK5/P85S9/4dZbb6WlpQWAFStW0NraWtbgZHjIZrM0NzdTXV3dayIUXvcO4fT7vBeronFDItQQ731pW08sK0NNzTWF47a20/D9CZu8x3EcamprWdOeZ3JdHNvWv7TLEDN2bOcM0Ny5SoRERES2oJJnhj744AM+/elPs3TpUhzH4dBDD6WmpoYrr7ySbDbLLbfcMhhxyhBljCGVSuH7PpFID+WqjSG87m1CrStoTI5nud/K1smtS06EABKJO7Dt1QDkcruSzR6+yetzuRzhcJgsUXL5LFO0RE6GoiOPBGNg9Wr4ylcqHY2IiMioUvLM0De+8Q322msv1q9fT1VV54fLY489lscff7yswcnQl8lkCrNC3RhDZO0bhFpXkK6fwTt+Ow2xBiZVlV4mOBJ5hXj8fzcMG6Ol5Tw29+ubzWZJJpOszfjUVUdIxrQqVIaoz3xGiZCIiEgFlPzp8Nlnn+Vvf/sb0Wi06PyMGTNYvnx52QKToa9jVgjoXkLb+ETWvI6daSI7bgf+7a4iHoozs2ZmP54pQzJ5deGore1UfH/yJu/wPA+AaFWCtesz7Dilth/PKzII7rgDJkwIEiARERGpqJKTId/3Cx80u/rwww+pqakpS1AyPLS3t9PS0lI0QwiA7xFZ8yq2kyI3/iO8k1tHzs/xkTEfIWSVXtY6kfgloVAjALnczmSzR232nkwmQ3V1NemcTci2mFijwgkyBNx2G9xyS+ceISVEIiIiFVXyMrlDDz2Ua665pnBsWRatra1cdtllHHHEEeWMTYYwYwzpdBrYaFbIzxNd/S9sJ01uwm58iMs6dx3b1mxLPFR6s9Nw+HWqqh7dcBShtfV8Nvdra4zB8zxqa2tZmc4yoTZGOKQq8lJhP/95kAhBsEdo/frKxiMiIiKlzwxdffXVHHTQQey0005ks1lOPPFE3nnnHRoaGrjvvvsGI0YZgnqcFfJcoqtfwcpncCfuTtqyWNqylClVUxgbG9uPZ3GoqbkaMAC0tZ2C503d7F0dTVZdK0rGzbKzlshJpf3858FXh/POgy9+sWLhiIiISKDkZGjKlCm8/PLL3H///bz44ov4vs9pp53GSSed1H25lIxIPe4V8lyiq17G8lzciXvghKK8k3qV2kgt0xPT+/U8icTdhELBPrR8fgcymWP7dJ/rukycOJEVLS7V0RD11dHN3yQyGIwJkqBf/KLz3Lx5cOKJlYtJRERECkpOhp5++mn2339/Tj31VE499dTC+Xw+z9NPP83HPvaxsgYoQ4/rurS3txOPb1j2ls8GiZDxcCftgReu4p30mwBsV7sdllV6b59w+N9UVT3ccURLy+aXx3XEFo1GiVVVs3p1mm0akiU/t0hZGBMsi7v99s5zSoRERESGlJI3Uhx00EGsW7eu2/l0Os1BBx1UlqBkaGtrayOfzxOJRLBy7UQbXwIM7qQ9MZEES9uW0pprZXbtbKJ2f2ZlXGpqFgD+huf7Ip63VZ/uzGQy1NTUsC7jYwxMri99n5LIgBkDN99cnAhdcIESIRERkSGm5GTIGNPjv/SvXbuWRCJRlqBk6PJ9n5aWlqDBqjFEVr0Mdgh34p6YcBVN2SYaM43MSM6gJtK/6oLV1fcSCi0DIJ/fjkzmc326L5/PEwqFqKmpYUUqQ0MyRixcevU6kQFrbIT77+88vvBCOOGEysUjIiIiPerzMrnPfvazQFA97stf/jKxWGepYs/zeOWVV9h///3LH6EMKdlslmw2SyKRwMq1YnkObsMeEI7Rnm9ncctixsXG9auxKkA4/A7V1b/ZcBSipWUe0LeEpmNWKEeIlmyemeOVnEuFTJ4M118PX/86nHMOHHdcpSMSERGRHvQ5GaqrqwOCmaGampqiYgnRaJR9992Xr371q+WPUIaU1tZWjDHYto2dTYFlYWK1eL7H281vEwvF2KZmm36OnitaHtfe/gU8r29NWn3fxxhDbW0ty9MO0bDN+KR6C0kF7bYbPPIIjO1PJUURERHZEvqcDN15550AbL311lxwwQVaEjcK5fN5WlpaCrOCtpPGj9aBZfNe89sDaqwKUF39AKHQ+xueaxva24/v873ZbJaqqiri8SpWLl/LtDFV/SrcINIvxsDf/gYHHNDZUBWUCImIiAxxJe8Zuuyyy5QIjVLt7e2Fam0AdjaFidexon3FgBqrAoRC71Fd3bHHIrShelzfcnVjDLlcjvr6epracuQ9w+Q6lXmXLcQYuPbaoHfQ9dcHxyIiIjIslJwMATz44IMcd9xx7Lvvvuy5555FX6W66aabmDlzJvF4nDlz5vDMM89s8nrHcbj00kuZMWMGsViMbbfdljvuuKM/L0NKYIyhtbWVUCiEZVlYuTbwc6TsEEvbBtJYFSC/obmqB0B7++fxvO36fLfjOMRiMRKJBCvSGeqrIyRiJVeNFymdMXD11fA//xMc/+pX8MYblY1JRERE+qzkZOi6667j1FNPZcKECSxatIi9996bcePGsXjxYg4//PCSxnrggQc477zzuPTSS1m0aBEHHngghx9+OEuXLu31nuOOO47HH3+c22+/nbfeeov77ruPHXbYodSXISVyXZe2traiJXKOn+ctZ9WAGqsCVFU9SDj8HgCetxXt7V8o6X7HcairqyPnW6xrdZlSr1kh2QKMgQUL4N57O8995zuw886Vi0lERERKYhlT2pqOHXbYgcsuu4wvfOEL1NTU8K9//YttttmG7373u6xbt44bbrihz2Pts88+7Lnnntx8882FczvuuCPHHHMM8+fP73b9H//4R0444QQWL17M2H6uxW9ubqauro50Ok1tbW2/xhiN1q9fT2NjY6GQhr3mNd5M/5vWMTP5yJiP9LOfEIRCHzBmzDlAHrBJpa4mn5/d5/td1yWfzzN9+nQ+bM6xdF07B27XQDjUr0lPkb4xBq66qrN8tmXBf/83HH10ZeMSGWT6GyoiI03JnxiXLl1aKKFdVVVFS0sLAF/60pe47777+jyO67q8+OKLHHbYYUXnDzvsMJ577rke73n00UfZa6+9uPLKK5k6dSqzZ8/mggsuIJPJ9Po8juPQ3Nxc9CWl8X2f5ubmoLfQBsua36PZtplVO6vfiRB41NRcRZAIQSbz2ZISIQh+vslkkmg0yspUlok1cSVCMriMgZ/+VImQiIjICFDyp8ZJkyaxdu1aAGbMmME//vEPAJYsWUIpk0xNTU14nsfEiROLzk+cOJHGxsYe71m8eDHPPvssr732Gg8//DDXXHMNDz74IGeffXavzzN//nzq6uoKX9On938512iVyWTIZrOFJXJr21bQmF3FVvWzqY30/18Gq6oeIhx+BwDPm0Zb25dKut/zgj1GtbW1rGtzyeY8pmqJnAymjkTo178Oji0LLrtMiZCIiMgwVXIydPDBB/O73/0OgNNOO43zzz+fQw89lOOPP55jjz225AA2Ln9sjOm1JLLv+1iWxT333MPee+/NEUccwYIFC7jrrrt6nR265JJLSKfTha9ly5aVHONo19FbKBQKBY1V179GQ7iGiXWlzeJ0FQp9SCJx94Yja0P1uNJmmDKZDIlEgqqqKlaksiRiYeqqI5u/UaS/fvGL4kTo8svhM5+paEgiIiLSfyWX3Pr5z3+O7wdNMefOncvYsWN59tlnOeqoo5g7d26fx2loaCAUCnWbBVq9enW32aIOkydPZurUqYV9KxDsMTLG8OGHHzJr1qxu98RiscKMhpQul8vR2tpKLBYrNFat8nJsk9waL9Tf5XE+yeTVQA6ATOY/yed3Km0E38fzvKBwgmdY05plu/E1/YxHpI8+8xn43e9g1aogETriiEpHJCIiIgNQ8syQbduEw5051HHHHcd1113Hueeey5o1a/o8TjQaZc6cOSxcuLDo/MKFCwt7kjZ2wAEHsGLFClpbWwvn3n77bWzbZtq0aSW+EumLrr2F3mt5j5yfY8dQHVZ8TL/HjMf/l0gkKD/seVNoazul5DE6mqxWV1ezqjmLMTCxTkmvDLIpU+DWW2H+fCVCIiIiI0BZdpo3Njby9a9/ne2263tvGIB58+Zx2223cccdd/Dmm29y/vnns3Tp0sIM0yWXXMLJJ59cuP7EE09k3LhxnHrqqbzxxhs8/fTTXHjhhXzlK1+hqkp7RcrNGENzczPhcJjGTCPr3HVsUz2dai+HH6vv15i2vYZE4q7CcWvrN4DSGrV2bbIaCoVYnsowviZGLBzqV0wivfJ9yOWKz02ZAp/8ZGXiERERkbLqczKUSqU46aSTGD9+PFOmTOG6667D932++93vss022/CPf/yj5Oanxx9/PNdccw3f+9732H333Xn66ad57LHHmDFjBgArV64s6jmUTCZZuHAhqVSKvfbai5NOOomjjjqK6667rqTnlb7JZDLBzFDI5YO2D5hcNZnxBAmHiddt5u6eGJLJG7CsYH9XNvtpcrldSx6lY6YqkUiQzuRozebVW0jKz/fhRz+Cb30LXLfS0YiIiMgg6HOfobPOOovf/e53HH/88fzxj3/kzTff5FOf+hTZbJbLLruMj3/844Mda1moR0LfrV69mpVrVrLUX0o8FGenup2IpN7DbluNO63npYybEos9RU3NjwHw/TGsX/9zjEmWPE5zczNjx45lwoQJvLmymaZWh//YrqHXwhsiJfN9+MEP4NFHg+ODD4af/CQomiAyiulvqIiMNH2eGfr973/PnXfeyc9+9jMeffRRjDHMnj2bJ554YtgkQtJ3+XyedHOaD90PAZhVOwvLsrCddL9mhSyrmWSys7lua+tZ/UqE8vk8oVCI2tpaPN/Q2Jxlcl2VEiEpH9+H73+/MxGybTjsMCVCIiIiI1Cfk6EVK1aw005Bxa9tttmGeDzO6aefPmiBSWW1t7ezJL0Ex3I6G6v6HpbT3K/9QsnkL7CsNACuuz+u+x/9iiuTyZBMJonFYqxuyeJ5hin1pe05EumV78P3vhdUjIMgEZo/Hw45pLJxiYiIyKDoczLk+z6RSGcPl1AoRCKRGJSgpLKMMSxZs4Q1uTXMSM4oNFa13WaAkpOhSGQRsdhfNoxdTWvrWf2Ky/d9jDHU1tZiWRYrUhnGJCJUR0uuEC/Sne/DFVfA//5vcBwKwY9/rGIJIiIiI1ifP0UaY/jyl79c6NmTzWaZO3dut4TooYceKm+EssWta1nHm01vMqlmEpOrJxfOW9kU2GFMpLqE0VySyRsLR21tp+H74/oVV9cmq+1unvVtOXaeqjXrUga+H/QNeuyx4DgUCmaEDj64omGJiIjI4OpzMnTKKcW9YL74xS+WPRipvLyf56UVLxGxIsyum130mO2kglmhEvZOVFf/mlBoeTB2fkey2U/3Ky5jDPl8ntraWmzbZkWqnXDIYkKNlsjJAPk+XHYZ/OEPwXHHjNBBB1U2LhERERl0fU6G7rzzzsGMQ4aIN9a8wfqW9ew8ZmdCdpe+PcbHdprJ18/s81ih0IdUVz/QcURLy7n0t7WV4zjE43ESiQTGGFamM0ysjROytaldBshxYMWK4PtwOKgap6IwIiIio0JZmq7KyLCsZRnL1i9jWnQa9dX1RY9ZbgsYv4T9QkFPIcgDkMl8Fs/but+xOY5DbW0t4XCYtW0uTs5XbyEpj6oquP56mDMHrrxSiZCIiMgoop3nAkDaSfNe6j3qqWd89fhupaptJw2WjYn2rRx2LPYEkci/APD9ibS1ndjv2FzXJRKJUFNTA8CKVIZkPExdVWQzd4r0UXU13HKLymeLiIiMMpoZElzP5fW1rxM3ccYxjni8+z4cO5vCj9WCtflfGctqIZn8ReG4tfVsoP97e7LZLDU1NUSjUZy8x5oWh6maFZL+yueDmaD164vPKxESEREZdZQMjXK+8Xlj7RsATI1MBYKy6UWMwXbSfV4il0jcXugp5Dj/get+tN/x5fN5LMsqzAqtSjtYFkysVeEE6Yd8Hr79bfjlL+FrX4NUqtIRiYiISAUpGRrllqSXkHbSzKqZhdvu9jgrZOXawM9j4vWbHS8cfo14/E8AGFNFW9uZA4ovm82STCapqgpmgpanMoxPxomG9asrJepIhJ54IjheuhTefbeyMYmIiEhF9esT5d13380BBxzAlClT+OCDDwC45ppr+H//7/+VNTgZXGva17CsZRnb1G9DxIvgui7RaLTbdcF+IQs/urmePjlqaq4vHLW1nYLvN/Q7Pt/38X2/0GQ13Z6jzckzpV6zQlKiXA4uuaQzEYpG4Wc/g732qmxcIiIiUlElJ0M333wz8+bN44gjjiCVSuF5HgD19fVcc8015Y5PBkl7rp1/r/s346vHMzUxlVQqRSTSc0EC20lhojVgh3p8vENV1UOEQksByOdnkc0eNaAYs9lsoZw2BLNC8UiIsYnuCZtIrzoSoSefDI6jUViwAPbfv7JxiYiISMWVnAxdf/31/OIXv+DSSy8t2luy11578eqrr5Y1OBkceT/P62tfJxaKsf2Y7Wlvby8kHj0JiifUbXJM224kkbi344jW1v73FIKgyWoul6O+vh7btsl7Pqtaskyuj3erdCfSq1wOLr4Y/vrX4Dgahauvhn33rWhYIiIiMjSU/Gl1yZIl7LHHHt3Ox2Ix2trayhKUDK63179NNp9ll4ZdCFkhmpubsSwL2+7+62DlM+C5mymeYEgmbwRcADKZo8jntxtQjI7jEI1GC7NCq1scPM8wpU5V5KSPXBe+9S146qngOBqFa66BffapaFgiIiIydJScDM2cOZOXX3652/k//OEP7LTTTuWISQbRhy0fsrp9NduP3Z7qSDWO49Da2looULAxK5sCwI/3PjMUjT5DNPpCcJ3fQHv7KQOO03Ec6urqCkv3VqQyjE1GqYpueqmeSMHDD8PTTwffx2JBIrT33hUNSURERIaWkpuuXnjhhZx99tlks1mMMfzzn//kvvvuY/78+dx2222DEaOUSUdj1WnJaUyongBAc3Mzvu8TDvf8q2A7aUwkAXZvDU59Eom7CketrWdizMBmb3K5HOFwmGQyaPDa5uRJtefYZeqml+qJFPn85+H11+Hxx+Haa1UsQURERLopORk69dRTyefzXHTRRbS3t3PiiScydepUrr32Wk444YTBiFHKoKOxam2slm3qtwGCpKOlpYVYLNbrfXY2hV81ttfHo9HnCIVWbhhvN1z3gAHHms1mqaurK+xhWpnOEA5ZTKjpPU6RbmwbLr8cTjkFtt220tGIiIjIEFRyMgTw1a9+la9+9as0NTXh+z4TJkwod1xSRsaYoLGqgZ3G7YRtBasj29racF2X2tpeSmZ7LlY+s8n9QtXVDxW+b2//HDCw4gYd1Qk7mqz6vmFFKsvkuipsW4UTZBNcFxobYautOs/ZthIhERER6VXJe4auuOIK3nvvPQAaGhqUCA0Di9OLSTtpdm7YmVgomF3xfb9QTru36my2kwqu7aWSXDj8BuHwmwB43gxyuTkDjjWTyVBdXU11dTUATW0Obt5XbyHZNMeBefPgtNNg8eJKRyMiIiLDRMnJ0G9/+1tmz57Nvvvuyw033MCaNWsGIy4pk66NVeu6JDVtbW2bLKcNwRI5E45DuOflacWzQv/FQGeFfN/H8zzq6uoKCdrKVJaaeJiaeG97lmTU60iE/vEPWL8++D6fr3RUIiIiMgyUnAy98sorvPLKKxx88MEsWLCAqVOncsQRR3DvvffS3t4+GDFKPxUaq1aNZ3rN9MJ5YwzNzc3Ytt1jOe0OtpPudYmcbS8nGn0OAN8fi+N8YsDxOo5T1GQ1m/NoanWYUq9y2tKLbBbOPx/+7/+C4+rqYJ9QLwVBRERERLrqV1fMnXfemR/96EcsXryYJ598kpkzZ3LeeecxadKkcscn/eT5Xmdj1bHbFz2WzWZpbW3d5KwQfh7LbcX0UlK7uvoRwACQyRwNDGzmxhiD67rU1dUVmvk2prNYFkyq0xI56UE2G8wC/fOfwXF1NdxwA+y+e0XDEhERkeGjX8lQV4lEgqqqKqLRKLlcrhwxSRm8tf4tMvkMuzTsQtgu/lfy5uZmjDG9ltOGYFYI6HFmyLKaicf/DIAxcbLZIwYcr+u6RKPRQjltCHoLTaiJEwkN+NdURpqOGaGNE6Fdd61sXCIiIjKs9OtT5pIlS/jhD3/ITjvtxF577cVLL73E5ZdfTmNjY7njk37oaKy6w9gdqI5UFz3W0WR1k7NCbEiGQlHMRvcDVFX9HnAByGY/hTE1A445m81SU1NDNBoFINXu0u56WiIn3WUycN558PzzwXEiATfeqERIRERESlbywvr99tuPf/7zn3zkIx/h1FNPLfQZkqGhp8aqXbW2thaWo22KnU31UkUuRzz+aMdVZDLHDDjmfD5PKBQqlNMGWJ7KUBUNMaZahROkC88LEqEXXwyOOxKhXXapaFgiIiIyPJWcDB100EHcdttt7LzzzoMRjwxAT41Vu8rn86TT6U02WQXA+FhuM179dt0eikb/iW2nAHCc/fH9ge8Ty2Qy1NTUFGar8p7P6maHrRsSvZb9llEqFIIDDgiSoWQySIT0/yIRERHpp5KToR/96EeDEYcMUG+NVbtqbW3FcZzem6xuYDnNYAx+D8UT4vG/FL7PZj814Lh938cYQ21tbSHxWdXi4PmGySqcID05+eSgWtzuu8NOO1U6GhERERnG+pQMzZs3j+9///skEgnmzZu3yWsXLFhQlsCkNEvSS0g7aXYbv1uhsWpXnudttslqB9tJgRXCRJJF5y0rRTQa7NPw/XHkcnsOOO5MJkNVVVWhySoEhRPGJaPEI6EBjy8jgDGw8e/siSdWJhYREREZUfqUDC1atKhQKW7RokWDGpCUrinTxNKWpWxbty318foer2lrayssR9scO5sKZoU2+gAaj/8V8ABwnIMYaDFCYwz5fJ4JEyYU+h21OnnS7Tl2nbbpPU0ySrS3wze/CV/8YrA8TkRERKSM+pQMPfnkkz1+L5XXnmvnzbVvBo1Va6f3eI0xhnQ6TSgU2mST1Q0XYzvN5Ou26vZQLNZ1idwhA4obgsp2sVis0GQVglmhSNimIbmZfU0y8rW1wde/Dq+8Ai+/DFddBfvvX+moREREZAQp+Z/2v/KVr9DS0tLtfFtbG1/5ylfKEpT0zaYaq3bV3t5Oe3s7VVWbL1Nt5VrBeN36C4VCiwmH3wMgn5+F580YUOwQJEN1dXWFfke+b1iZzjK5Lo5tq3DCqNbaCuecEyRCAFVV0NBQ2ZhERERkxCk5GfrlL39JJpPpdj6TyfCrX/2qLEFJ33Q0Vt25YedujVU7dMwKAYRCm9+DY2dTYFmYWHGRheLCCQOfFXJdl0gkUtRktanVIZf31VtotOtIhF59NTiuq4NbboHZsysbl4iIiIw4fa4m19zcjDEGYwwtLS1FTTs9z+Oxxx5jwoTufW1kcCxvXc7q9tXsOHZHEpFEr9dls1laW1v7NCsEQbNVP1oHRdXoPGKxjuWRIRznE/2Ou0PHrFDXMt/LUxlqqyIkYyUXOZSRoqUlSIRefz04rquDm29WIiQiIiKDos+fOuvr67EsC8uymN3DBxPLsrjiiivKGpz0rKOx6tTkVCYmJm762nQa3/cLS9E2x86m8GqmFJ2LRl8s9BZy3X0xZtOluTfH84IiDF1LfGdzHuvaXLaftPkCDzJCtbTA2WfDG28Ex/X1QSI0a1ZFwxIREZGRq8/J0JNPPokxhoMPPpjf/va3jB07tvBYNBplxowZTJkyZRMjSDl0NFatidawbf22m7w2m83S0tLS51khK9cGfq7bfqFYbGGXMQe+RC6TyZBIJIriWpnOYlsWk2rVW2hUam4OZoS6JkK33ALbdW/8KyIiIlIufU6GPv7xjwOwZMkSttpqq832qpHy60tj1a6am5vxPI9IJNKn8W0n2Fvkd9kvZFktxGL/2PD8dbjuXv2MPuD7Pp7nUVdXV/gdMsawIpVhfE2McGhg5bplmHrrLXj77eD7MWOCRGjbTSf7IiIiIgPVp2TolVdeYZdddsG2bdLpNK92bGzuwa677lq24KTY5hqrduU4Ds3NzUV7uzbHyqYw0SR0KcYQiz0F5AHIZg+ihPy517g2brKaas+RcT12mjyw5XcyjH30o3DllfDjH8MNN8A221Q6IhERERkF+vTJdvfdd6exsZEJEyaw++67Y1kWxphu11mWVdgPIuXVl8aqXbW0tJDL5YqSjs2xnTR+VXH54ni8fEvkjDG4rsvEiROLKtstT2WojoYYk4gOaHwZ5j72MdhnH4ipx5SIiIhsGX1KhpYsWcL48eML38uW1ZfGql25rks6nS5pVoi8g5XP4sfrCqdCoWWEw8HSpXx+GzxvYMuWXNclGo0WldPOeT6rW7Js05DcxJ0y4qTT8OyzcOSRxeeVCImIiMgW1KdkaMaMGT1+L4Ovo7FqNBTdZGPVrlpaWnBdt6ha2+bYTgqgqHhCLNbZW8hxBl44IZvNMm7cOKLRzhmgxnQWY2BSnQonjBqpFJx1VrBHKJ2GE0+sdEQiIiIySvWr6ervf//7wvFFF11EfX09+++/Px988EFZgxN4e/3bZPIZdmnYpdfGql3lcjnS6TSxWKykIhe2k8ZEqiHUkaj4xONPdDxKNvuJkmPvKp/PEwqFqKkpLp29Mp1lXDJGPLL5hrAyAqRS8LWvdRZL+NWvgiarIiIiIhVQcjL0ox/9qFAS+e9//zs33HADV155JQ0NDZx//vllD3A0W966nFXtq9h+zPabbKzaVUtLC47jFDUz7Qs7m8KPdS6Ri0QWYdtNALjuRzFmTEnjbSyTyZBMJouW7rVkczRnckyp16zQqLB+PcydC++8ExyPHw8//zkktURSREREKqPk0mDLli1juw29Px555BE+97nPccYZZ3DAAQfwiU98otzxjVqlNFbtkM/nSafTRKPR0kqfey5Wrg2/dqvCqXi8c4ncQAsn+L6PMYba2tqiuFakskTDNg0J7RMZ8datC2aE3nsvOB4/Hm69FbbaatP3iYiIiAyikmeGkskka9euBeDPf/4zhxwSfFCOx+NkMpnyRjdK5bwcr699nWQkudnGql21traSzWZLK5xAZ38hs6F4gmW1E4s9F5wzSVx375LG21g2m+1WTtv3DSvTGSbXxbFt9awa0datC2aEOhKhCROUCImIiMiQUPLM0KGHHsrpp5/OHnvswdtvv82RG6pBvf7662y99dbljm/UMcbwxro3MMawc8POm22s2iGfz7N+/frSZ4XYkAyFophwsPwxFnsGcAFwnE8A/S95bYwhl8vR0NCAbXe+ljWtDnnPMKW+qt9jyzDQkQgtXhwcdyRC0zdfFVFERERksJU8M3TjjTey3377sWbNGn77298ybtw4AF588UW+8IUvlD3A0WZJ8xJS2RQ7jdtps41Vu+rvrBBs6C/UpXdRLNa1t9ChJY/XleM4RKNREoniPU/LUxnqqyMkYgNr4ipDmDFw8cWdidDEicEeISVCIiIiMkSU/Em0vr6eG264odv5K664oiwBjWZNmSaWNi9lm7ptGBPve8GCgcwK4XtYTjNeYhIAtr2CSOR1ADxvOvn8rNLG24jjOIwfP55IJFI4l815rGt12XFK30t/yzBkWXDBBcFeoaqqYEZo6tRKRyUiIiJS0K9/lk+lUtx+++28+eabWJbFjjvuyGmnnUZdXd3mb5Yetefa+fe6f9NQ1cBWtaXtpeiYFSqlr1AH220GOvsLxeOPFx4LCif0fz9PLpcjHA4XNVkFWJHKEApZTKxR4YQRb/ZsuPnmoGLclCmVjkZERESkSMnL5F544QW23XZbrr76atatW0dTUxNXX3012267LS+99NJgxDjidTRWjdiRPjdW7dAxKxSJREqfFQKsbArscNBjCL9LFTkbxzm45PG6ymaz3cppG2NYkcoysSZOOFTyr58Mdek0+H7xudmzlQiJiIjIkFTyp9Hzzz+fo48+mvfff5+HHnqIhx9+mCVLlvCZz3yG8847bxBCHPk6GqvuPG5nInZk8zd00TEr1NH7qVS2kwpmhSyLSOQ1bHs1AK67B77f0K8xobicdlfr2lyyOU+9hUai1avh1FPhBz/onhCJiIiIDEElL5N74YUX+MUvfkE43HlrOBzmoosuYq+99iprcKPBitYVrGpfxY5jdyQZLa355EBnhTA+ttNMvn4mALFYZ28hxxlYb6FMJkN1dXW3JG1lOkt1LER9df8r1MkQtHp1UDVu6dLgq6EBzjqr0lGJiIiIbFLJM0O1tbUsXbq02/lly5ZRU1NTlqBGi2a3mXdT7zIlOaXPjVW7GuiskOW2gPHxY/VYVmZDSW0wphrH2a9fYwb3G/L5PHV1dUXltHOez+qWLFNVTntkWb0azjwzSIIgKJLw2c9WNiYRERGRPig5GTr++OM57bTTeOCBB1i2bBkffvgh999/P6effrpKa5cg5+V4vSlorLpd/XYl3z+gCnIb2E4aLBsTTRKN/g3LygLgOB8D+l/cwHEcYrFYt3LajeksxsCkOi2RGzFWrYIzzoBly4LjadOC8tmTJlU2LhEREZE+KHmZ3M9+9jMsy+Lkk08mn88DEIlE+NrXvsaPf/zjsgc4Ur2Xfg/f+CU1Vu2qubm53xXkOtjZFH6sFiy7S+GEjipy/ec4DhMmTChaSglBb6GGZIxYODSg8WWIaGwMZoSWLw+OOxKhCRMqG5eIiIhIH5WcDEWjUa699lrmz5/Pe++9hzGG7bbbjurq6sGIb8RqdVtpqGooqbFqh1wuRyqVGtCsEMZgO2nyNdOw7dVEIq8A4HlTyOd36t+YgOu6RCKRbuW0m7M5WrN5th1f2r4oGaJWrgwSoRUrguOttoJbblEiJCIiIsNKn6ck2tvbOfvss5k6dSoTJkzg9NNPZ/Lkyey6665KhPrB9V2iof4VEeiYFepasrpUVq4d/DwmXk8s9gRggI7CCf3vLeQ4DslkklisOMlbkcoQi9g0JFU4YdhTIiQiIiIjRJ+Tocsuu4y77rqLI488khNOOIGFCxfyta99bTBjG7GMMeS83IBmheLxeP9nhQhKagP40ZqNlsj1v7eQ53kA3QppeL6hMZ1lcl3VgGKWISIWg45EfKut4NZblQiJiIjIsNTnZXIPPfQQt99+OyeccAIAX/ziFznggAPwPI9QSHtASpHzcxhMv2aGmpubcV13QHuFIEiGTKyWcPRtQqFgz0cutxu+X3pVuw4d5bQ3nilc0+KQ94x6C40UY8cGM0Hz58O3vhWU0RYREREZhvo8M7Rs2TIOPPDAwvHee+9NOBxmRcdSGekz13MBSk6GXNcllUoRi8UGPMMSFE+oK1vhBGMMnudRV1fXLbblqQxjEhGqoyVvUZOhauxY+OlPlQiJiIjIsNbnZMjzPKLR4g/v4XC4UFFO+s7xHACidmnJUMes0ED2CgFY+Qx4Ln6smljsaQCMieO6B/R7zI49TBuX0864HuvbXKaot9Dw9eGHcOml0N5e6UhEREREyqrP/1RvjOHLX/5y0cb4bDbL3Llziz4AP/TQQ+WNcATK+TmgtJkhx3FIpVL9brDalZVNAxCpexPLatsw/oEY0/+xXddlwoQJ3ZZMLk9lCIUsJtRoidywtGxZUCxh9WpYswauuQZUMEVERERGiD4nQ6ecckq3c1/84hfLGsxo4XgOYTtcUn+hVCpFPp8vS+U+20lhIgniVb/rjMnp/xK5XC5HOBzuVk7bGMPKdIZJtXFCtgonDDtLl8LcuUEiBJBKQTarZEhERERGjD4nQ3feeedgxjGquJ5bUiW5TCZDc3NzWWaFINgvZJI20ehLAPj+BHK5Xfo9Xkfz143Laa9tc3FyvpbIDUdLlwYzQmvWBMfbbgs33xzsFRIREREZIbSjvQJc3yViR/p0rTGGdDqN53lEIn27Z5M8FyufITxmMeADHYUT+j5L1ZXv+xhjupXThqC3UCIWpq6qDHHLlvPBB0Ei1NQUHG+3XZAIjRlT2bhEREREyqx/n4BlQEqZGcpkMqTT6bI1tg36CxliNf8onMtmP9nv8ToKJ2wcn5v3aWp1mKpZoeFl40Ro1iwlQiIiIjJiKRmqANdz+1Q8wRhDKpUCgsp95WBn09jJJkKRDwHI5XbG96f0e7xcLkdtbS22Xfyr1JjOAjCpToUTho3334czzuhMhGbPViIkIiIiI5qSoQroazLU1tZGS0tL2WaFIJgZijS8UTgeSOEE13WJRCLdCidAUEVufDJONKxfsWHjl7+EtWuD7zsSofr6ioYkIiIiMpi0Z2gLy/t5PONttseQ7/usX78ey7K6lavuNz+PlUsRrVu04UQUxzlwk7dsiuM41NXVdes/lc7kaHPyzJrYPUmSIeySS4JkaO1auOkmqKurdEQiIiIig6pf/2x/9913c8ABBzBlyhQ++OADAK655hr+3//7f2UNbiRyPRfYfI+h1tZW2trayjwrlCZc8xaEgiVsjrM/xiQ2c1fPNlc4IR4JMS5RWlNZqbBoFH72s2BGSImQiIiIjAIlJ0M333wz8+bN44gjjiCVSuF5HgD19fVcc8015Y5vxOlouLqpAgqe57Fu3TpCoVC3vTgDYTtpouNegQ39jYIqcv2TzWapqqrqVu7b8w2NzVkm18exLPUWGtIWL4bGxuJz0SjU1lYmHhEREZEtrORP2tdffz2/+MUvuPTSS4uWb+211168+uqrZQ1uJHI8B4BIqPdy0y0tLWQymbL1FeoQyi0jXPMuAL7fQC63R7/HyuVy1NXVdUvWVjVn8TzDlDpVkRvS3n03qBp35pmwalWloxERERGpiJKToSVLlrDHHt0/RMdiMdra2soS1Ejmei62ZffaZyiXy7Fu3Tqi0WhZZ4UwPtHqZ8EOZmsc5yD6Wz+jo3BCT0v4VqQyjElEqYqWaZ+TlN8778DcubB+PSxfDtdeW+mIRERERCqi5E/DM2fO5OWXX+52/g9/+AM77bRTyQHcdNNNzJw5k3g8zpw5c3jmmWf6dN/f/vY3wuEwu+++e8nPWUmba7ja3NyM4zjE4+UtSW05zUTHLMLYQZKSzR7a77Ecx6G6urpb4YR2N0+qPafeQkPZ228HidCGku3svHNQOEFERERkFCq5mtyFF17I2WefTTabxRjDP//5T+677z7mz5/PbbfdVtJYDzzwAOeddx433XQTBxxwALfeeiuHH344b7zxBltttVWv96XTaU4++WQ++clPsmqYLfHZVMNVx3FIpVLE4+XfbxPxXyUUb8S3asjnZ+N50/s1jjEG3/d7LZwQDlmMr+lbQ1nZwt5+G772NUing+NddoEbboAeSqOLiIiIjAYlJ0Onnnoq+Xyeiy66iPb2dk488USmTp3KtddeywknnFDSWAsWLOC0007j9NNPB4KKdH/605+4+eabmT9/fq/3nXnmmZx44omEQiEeeeSRUl9CRW2qx1AqlcJ1XeoGoZJXvOrxLrNC/S+c4DgOsVis234mYwwr01km1cUJ2SqcMOS89VaQCDU3B8cf+UiQCCX6V01QREREZCTo16aRr371q3zwwQesXr2axsZGli1bxmmnnVbSGK7r8uKLL3LYYYcVnT/ssMN47rnner3vzjvv5L333uOyyy7r0/M4jkNzc3PRVyU5ntNjMpTJZEin02UtpV1gckQT/wArBIRxnE/0eyjXdUkmk4TDxXl0U6uLk/OZoiVyQ8+//12cCO26qxIhEREREfq7g36DhoYGJkyY0K97m5qa8DyPiRMnFp2fOHEijRuX+93gnXfe4eKLL+aee+7p9mG8N/Pnz6eurq7wNX16/5aHlUvOy3VruGqMYf369RhjiER630/UX1H7WexwK8YO4zj7Ykz3JW594XkelmWR7GFZ1YpUhmQ8TG28/PHLADQ2wllndSZCu+2mREhERERkg5KXyc2cOXOT+1kWL15c0ngbj2WM6XF8z/M48cQTueKKK5g9e3afx7/kkkuYN29e4bi5ubliCZExBtfvvmeora2N5uZmEoP0AbUq+sfgG8vGcQa2RC4ej3cr7uDkPZpaHWZP7F+SJYNo4kQ48ki47z7YfXe47joYjNlHERERkWGo5GTovPPOKzrO5XIsWrSIP/7xj1x44YV9HqehoYFQKNRtFmj16tXdZosg6L3zwgsvsGjRIs455xwAfN/HGEM4HObPf/4zBx98cLf7YrEYsdjQ2NDv+i5Q3GPI933Wr1+PbdtFfZvKxbJaiMZfxBDC98fgunP6PVYul2PcuHHdSn43prNYFkyqK28FPCkDy4J582D6dPjMZ5QIiYiIiHRRcjL0jW98o8fzN954Iy+88EKfx4lGo8yZM4eFCxdy7LHHFs4vXLiQ//zP/+x2fW1tbbemrjfddBNPPPEEDz74IDNnzuzzc1eK6wXJUNc9Qy0tLbS2tvZYna0cYrG/YuFg7MiG3kIl/8iBIBEKh8M97mlansowoSZOJFTGvkjSf7kcdF1uaVlw3HGVi0dERERkiCrbp9fDDz+c3/72tyXdM2/ePG677TbuuOMO3nzzTc4//3yWLl3K3LlzgWCJ28knnxwEatvssssuRV8TJkwgHo+zyy67DNoSs3LqSIY6lsnl83nWrVtHJBIpb4PVLuLRP4IxYIUGXEWup95CqXaXdsdjsmaFhobXXoNjjgn+KyIiIiKb1L9pgh48+OCDjB07tqR7jj/+eNauXcv3vvc9Vq5cyS677MJjjz3GjBkzAFi5ciVLly4tV4gV15EMdTRdbW5uJpvNUltbOyjPFwotIxJ+C/KQ87fD87bp1zjGGDzPo6amptt+rhWpLFXREGMTPZcLly3o1VfhnHOgrQ3OPhtuuw1mzap0VCIiIiJDVsnJ0B577FH0gdgYQ2NjI2vWrOGmm24qOYCzzjqLs846q8fH7rrrrk3ee/nll3P55ZeX/JyV4vouETuCbQWzQG1tbUQikbI3WO0Qi/0F/DzGsnGcwzZ/Qy9c1yUajXZbIpf3fFY1Z5kxrnrQXoP00SuvBIlQe3twvNNOwT4hEREREelVycnQMcccU3Rs2zbjx4/nE5/4BDvssEO54hqRujZcNcaQz+cHbXkc+MTjj4PngRUjm/1Ev0dyXZf6+vpu5cxXtTh4vlFvoUrbOBHae29YsADiWrooIiIisiklJUP5fJ6tt96aT33qU0yaNGmwYhqxuiZDnufh+/6gVJADiEQWYVtrsIzBye2JMWP6NY7v+/i+3+OerBWpDGOTUeKRwXkN0gf/+hd8/evFidDVV8MQqaAoIiIiMpSVNC0RDof52te+huM4gxXPiOb6bqHhqud5eJ43aMlQPP4XLOMBkHGP6Pc4rusSj8epqiqe/Wlz8qTbc0zVrFDlLFpUPCO0zz5KhERERERKUPIarX322YdFixYNRiwjnuM5hUpyHTNDg7FMzrLaiMWeA+Ph+wnc/P79Hst1XWpqarolbStSGSJhm/FJffCuiJdegnPPhUwmON5vv2BpnBIhERERkT4rec/QWWedxTe/+U0+/PBD5syZ02351K677lq24EYa13MLDVc9z8MYMyiFB2KxZwAXfA+3bT+gf5XefN/HsqxuhRN837AynWVyXRzbVuGEili+vDMR2n9/+NnPIKqKfiIiIiKl6HMy9JWvfIVrrrmG448/HoBzzz238JhlWYUP9p7nlT/KESDv5/GNX7RMbrDEYn8BDJbxyTiH9TcXwnEcYrEY8Y024je1Obh5X72FKumoo4LiGE8+CT/9qRIhERERkX7oczL0y1/+kh//+McsWbJkMOMZsXpquDoYs0K2vZxI5HUs38PLjidv797vsVzXZcKECd2W8q1IZamtilATjwwwWhmQY46B//xPUFlzERERkX7pczJkjAEoNESV0nQkQx3V5FzXHZT9QvH448E3xsNNfxRTVb3pG3qRz+cJhULdlshlcx5rWx22n1Qz0FClFM8/D2vXwqc/XXxeiZCIiIhIv5W0Z0iNNfvP9YuToVwuNwiV5PzOZMj3cbIfh34We3Mch6qqqm5L5Fams9iWxcRaLZHbYv75TzjvPMjng+TnU5+qdEQiIiIiI0JJydDs2bM3mxCtW7duQAGNVI7nYFs2YTtcKKtd7pmhSOQ1bHs1YMg3z8QLb93vsfL5PDU1Nd1+3itTGcbXxIiEBqtZrBTpSITcIJnm8cfhsMM0IyQiIiJSBiUlQ1dccQV1dXWDFcuIlvNy3RquRsu86T0onACW8cit3wO/ur5f4+RyOcLhcLfeQuvbXNpdjx0n1w40VOmLf/wD5s3rTIQ+/nH44Q+VCImIiIiUSUnJ0AknnMCECRMGK5YRbeMeQ+WeGbKszIaS2mDyUXKtu2Dq+rdfyHEcEolEt2RteSpDdTTEmIQqlw26v/8dvvnNzkTooIPgRz+CiIpWiIiIiJRLnz+Na7/QwLi+W1RW2xhT1mQoGv0blpUFIJfeFT86vt8zCJ7nkUwmi37mOc9nTYvD5Pp+bkKSvnvuueJE6OCDYf58JUIiIiIiZdbnT+Md1eSkfzZuuFpu8fhfNnxnyDXthB/v33LGXC5HJBLptkRuVXMW3xj1Fhpsf/tb90ToRz+CcMn9kUVERERkM/r8Ccv3/cGMY8RzPbdomVw52fYqIpFXAPBzE/HapuLX9C8Z6m2J3IpUlnHJGPFIuSvgSUFbG/z3f0MuFxwfcgj84AdKhEREREQGiUqCbQG+8cn5ucIyuVwuV9Zlh/H4E0Awc+c07w1WCBMtvQ+QMaawRK6rlmyO5kyOKZoVGlyJBPzsZxCPBxXjfvhDJUIiIiIig0iftLaAnB/8S3/Xhqvl6zFkiMU29BbCIrd2Z0ysFqzS89x8Pt/jErmV6SyRsE1DMlaGeGWT9twT7rwTttkGyt6HSkRERES60szQFuB4DhAkQ8YY8vl82YonhMNvEgotByDn7orVFsKP1fcvTsehurq6aImc7xtWprNMqYtj2yqiUXaLF8PG+/FmzVIiJCIiIrIFKBnaAlwv2AwfDUULPYbKNTPUWTgBnLb/AD+PideXPE5vS+TWtDrk8j5TVEWu/J58Er7wBbj55u4JkYiIiIgMOiVDW0DO27BMzo6WuceQQyz2FADGVJFL7wiAHy29KWoulyMajRKPF+8LWp7KUFcdIRHTisqyeuIJuPhi8Dy4444gMRIRERGRLUrJ0BbgeA5RO4plWYWZoXIkQ7HYP7Cs9uA5nP/AzmaD/UJ26bNOjuNQVVVVtEQum/NY1+pqVqjcnngCLrkkSIQAjjgCPvGJioYkIiIiMhopGdoCXL+4x5AxpizV5GKxLkvknEOwsyn8WOkltY0x+L7fbYncilSGkG0xsUaFE8rmL3/pnBEC+Mxn4PLLoYwNeEVERESkb/QJbAtwPbdQSc7zvLIkQra9lmj0JQB8fwL5zLbguf0qntCxRK5rFTljgsIJE2pjhEP6NSmLhQvh29+Gjp5dRx8N3/2uEiERERGRCtGnsC2ga8PVfD5fljFjsSeA4EN1NnsIVrYFAD9e+sxQRxW5SCRSOLe+PUfG9ZiqJXLl8ec/w6WXFidC3/mOEiERERGRCtInsS3A9d1Cw9Xy9BgyRVXkstlPYjspTCQBdmQT9/UwkjEYY0gkEkXnV6QyVMdC1FdHe7lT+uyJJ4LEpyMR+s//VCIkIiIiMgTo09gW0HWZnOu6Ay6eEA6/Qyi0FIBcbmd8fwq2k8bvR0ntXC7XrdFqzvNZ3ZJlSp1mhcpi9mxoaAi+P+aYYIZIiZCIiIhIxale8iDL+Tl84xd6DHmeN+CZoaLeQs6h4LlYuXb8uq1LHst1XZLJZNESucZ0FmNgcn18E3dKn02bBrfeCr/7Hcydq0RIREREZIjQp7JB1tFjKBaKlamstkss1tGTJorjHIjtpABKLp7QW6PVFakMDckYsXB5GsOOShs3UZ0+Hc46S4mQiIiIyBCiT2aDzPEcACJ2pCzJUDT6TyyrNRjb2R9jqrGzaUw4DuHSSmDn83kikUhRo9XmbI6WbF69hQbi978PymeXqViGiIiIiAwOLZMbZK7nAhANRck62QEnQ8WFEw4BwHb611/IcRwSiURRo9WVqSzRsE1DUoUT+uV//xeuuCKYGTIG5s+HARfMEBEREZHBoJmhQeb6LrZlE7bDeB2NNvvJstYTjT4PgO83kMvtAX4ey23F9KN4wsZL5HzfsDKdYUp9vCy9kEadRx/tTIQgKJqgZXEiIiIiQ5ZmhgZZ1x5DA224Go//lc7eQgcDNrazHih9v1BPVeRWtzjkPaMlcv3x6KPw/e93JkInnADf/CYoqRQREREZspQMDbKuZbVzudyAlsjFYl2ryHUskUtDKIqJVJc0Vk+NVpenMtRXR6iO6teiJI88Aj/4QefxF74A8+YpERIREREZ4rSGZ5C5fnl6DIVC7xEOLwYgn98ez5sOgJ3t334hz/OoqakpzFRlXI/1ba5mhUr18MPFidCJJyoREhERERkmlAwNMtdzidpRjDHk8/l+J0M9FU7A+Fhuc8nJUD6fJxwOF1WRW5HOEApZTKxVb6E+e+gh+OEPO49POgnOP1+JkIiIiMgwofVQg6xjmVxHWe1wuD9veZ54vKO3UBjH+TgAltMMxuCXWDzBcRzi8XihipwxhpWpLBNr4oRsfZDvE88Lmqh2+NKX4NxzlQiJiIiIDCOaGRpEvvHJ+blCw1XP8/o1MxSNvoBlpQFwnH0xpgYISmpjhTCR5Cbu7i6fzxctkVvX5pLNeUzVErm+C4Xg+uth553h5JOVCImIiIgMQ5oZGkQdPYYG2nC16xI5xzm08L3tpPHjdSV9CM/n84RCoeIlcqksiViYuurIJu6UbpJJuPVWiMWUCImIiIgMQ5oZGkSuHyRDHTNDQMmltS2rmWj0HwD4fj2uOyd4wBjsbLrk/UKu6xKLxYjFgnLfbt5nTWtWs0J98cc/QjpdfC4eVyIkIiIiMkwpGRpEHTNDHXuG+iMW+ysQ3Os4BwEhAKxcKxivX/2Fui6Ra0xnAZhUp8IJm3T//fCd78BZZ0Fzc6WjEREREZEyUDI0iFzPxcIqLJPrjx6ryBGU1MayMLHaPo/VsWepa6PVFekMDckY0bB+FXp1773ws58F37/1Fvz5z5WNR0RERETKQp+AB5HruURCESzL6lfD1VDoA8LhdwDI57fF87YpPGY7aUy0Fqy+j7nxErl0JkdrNq/eQpty772wYEHn8Ve/Cv/1X5WLR0RERETKRsnQIHI8h6gdlK/uTzJUXDjhkKLHguIJ9SWN57ouyWSyEMeKVIZYxGZcIlrSOKPG//xPcSJ0xhlw5pnaIyQiIiIyQigZGkQ5P0c01N+Gqz6xWEdvoRDZ7CcKj1i5dvDckoon+L6PZVmFJXKeb2hszjK5rqrkog6jwt13wzXXdB6fcUbwJSIiIiIjhpKhQeR4TqGSXKlltSORF7HttQC47l4YU194zHZSACUlQ67rEo1GCyW1V7dk8TyjKnI9+dWv4NprO4/nzlUiJCIiIjICKRkaRB17hjoaroZCoT7f21vhBAArm8JEk2D3vU1ULpcjmUwWYliRyjAmEaUq2veYRoWnn4brrus8PussOP30ysUjIiIiIoNGydAgyvk5onZQVtsY0+eZIctqIxb7OwDG1OC6+xQ9bjvpkkpqG2MwxlBdXQ1Au5tnfVtOs0I9OeAAOOyw4Puzz4avfKWy8YiIiIjIoOn71IKUJOfn8I1PLBTD932MMX3emxOLPQ3kAHCcTwCRzgfzDlY+ix8vbYlcJBIpLJFbkcoSDlmMr4n1eYxRIxSC738fPvUp+PjHKx2NiIiIiAwizQwNko0brhpj+nxvPL6w8H02e2jRY537her7HovrkkgkCIfDGGNYmc4wqS5OyFbhBADS6eLjUEiJkIiIiMgooGRokHQkQxE7Qj6f7/OsUCi0nHD4TQA8byvy+e2KHredNCZcBaG+lcPeeIlcU6uLk/PVW6jDL34Bxx0H779f6UhEREREZAtTMjRIHM8BIBaKlVRWOxbbuHBCcRJlZ1Ml9RfK5XIbLZHLkIyHqY1HNnPnKPDzn8Ott8LatUHFuJaWSkckIiIiIluQkqFBkvNyhKwQITuE67p9TIZ84vHHN3xv4zif3OjhHFaureQlcvF4nGg0ipP3aGp1VDjBmCAJ+vnPO8+dfDLU1FQuJhERERHZ4lRAYZA4nlNyw9VI5BVsew0Arrsnvj+26HE7G+xtMSUUT/A8j2QyCUBjOotlwcTaeJ/vH3E6EqHbbus8N28enHhi5WISERERkYpQMjRIXN8tarjalx5DXXsLOc4h3R63nRSEosGeoT7I5/OEQiFisaBq3PJUhvHJONHwKJ0QNAZuvhnuuKPz3AUXwAknVC4mEREREamYUfqpePB1NFz1fR/f9zc7M2RZGaLRvwFgTALH2a/bNbaTLmm/kOu6xGIxYrEY6fYc7Y7HlPpROivUUyJ00UVKhERERERGMSVDg8T1XGJ232eGotFnsawsAI7zMWCjanG+h+U0l7RfKJfLkUwmsSyL5akM8UiIsYm+VaEbcW68sXsidNxxlYtHRERERCpOydAgcX230GPI9/3NltYu7i3UwxI5txnoe3+hjtmoqqoq8p7PqpYsk+vjfS7xPeJsKC0OwLe+pURIRERERLRnaDD4xifv54NkKO9t9nrbbiQSeRUAz5tKPr9jt2usbArsMCZS3e2xnriuSzQaJR6P09js4HlmdFeR+8pXgqVy9fXwX/9V6WhEREREZAhQMjQIOnoMRUNRPMfrw6zQE4Xve+otBEHxBD9WB32c2XFdl7Fjx2LbNitSGcYmo8Qjmy/iMKKddlqlIxARERGRIUTL5AaB67kARO0ouVxuM8mQ6dJo1cJxDu7hEh/bae5z8QRjDADV1dW0OXlS7bnRNStkDFx/PfzjH5WORERERESGMCVDgyDn5wCIhWKF8ta9CYdfJxRaGdyX2w3fn9DtGsttAeMHM0N94LoukUiEeDzOilSGcMhifDLWj1cyDBkDCxbAL38Z9A/6v/+rdEQiIiIiMkQpGRoEjudgYRGyQuRyuU2W1e7aW6inwgkQlNTGsjHRmj49v+u6JBIJbDvEynSWyXVV2PYoKJxgDFx1Fdx3X3Ccy8GqVZWNSURERESGLO0ZGgQdPYaMMXiet4mZoSyx2DMAGFOF4+zf41V2No0fqwVr87mrMQbf96murqapzcHN+6Ojt5Ax8NOfwq9/HRxbFvz3f8PRR1c2LhEREREZsjQzNAhczyVqd5bV7m1mKBb7O5bVDoDj/AfQw74eYzYUT6jv03Pn8/kuS+Sy1MTD1MQj/Xwlw4QxcOWVxYnQZZcpERIRERGRTVIyNAhczyUWim02Geq6RM5xDu3xGivXDn4e08fiCa7rEo/H8bFZ2+owZaQXTvB9+MlP4De/CY4tCy6/HD7zmYqGJSIiIiJDn5KhQdC14aoxpsdkyLabiEReBsD3J5LL7dzjWLaTCq6J1vbpufP5PMlkksZmB8uCSXUjeIlcRyL04IPBsW3DFVfAkUdWNi4RERERGRaUDA0Cx3MKyVBvYrEnAB+AbPaT9PajsJ0UJlYL9uZ7BHmeh23bxGIxVqQyTKiJEwmN4B/x22/DI48E33ckQkccUdGQRERERGT4GMGflCvDGEPOyxENRfF9v7erNqoi98lex7OzqZJKasdiMTKeRbvrjfwlcjvsAPPnQzQK3/seHH54pSMSERERkWFE1eTKLO/nMRhioRi59p4brtr2OkKhZcH1+R3x/Sk9jmXlM+C5fU6GcrkcdXV1rGx2qIqGGFM9wgsnABx8cDA7NKF7fyYRERERkU3RzFCZOZ4DQMSO9NpjKBRaXPg+l9up17GsbBqgT8lQxyxUJBZjdXNQOKGnRGxY83345z+7n1ciJCIiIiL9oGSozFzfBTqToZ56DIXDSwrf5/Mzex3LdlKYSAJC0c0+by6XIxKJkHbAN4bJI61wgu/D978PZ53VWUJbRERERGQAlAyVmettSIasSKGgwcbC4c6ZoU0nQ2n8EkpqJxIJVrXmGJuIEo9svuDCsOH7wZ6g3/0uOL7qKlixorIxiYiIiMiwp2SozFzPJWyHMb7ptcdQ58xQCM+b3vNAnouVa+/zfiHf9zGhKOn2HFNHUuEE3w/6Bv3v/wbHoVBQNGFKz/usRERERET6quLJ0E033cTMmTOJx+PMmTOHZ555ptdrH3roIQ499FDGjx9PbW0t++23H3/605+2YLSb53ouUTu6iYarLqHQhwDk8zOAnoscFPoLxeo3+5wdS+TWORAJ2zQkY/1/AUNJRyL02GPBcUcidPDBFQ1LREREREaGiiZDDzzwAOeddx6XXnopixYt4sADD+Twww9n6dKlPV7/9NNPc+ihh/LYY4/x4osvctBBB3HUUUexaNGiLRx57zoarvq+32PD1XD4Azr6C3neJpbIZdOYcBzCm09sXNclEo2ypi3P5Lo4tj0CCid4Hnz3u8WJ0I9/rERIRERERMrGMsaYSj35Pvvsw5577snNN99cOLfjjjtyzDHHMH/+/D6NsfPOO3P88cfz3e9+t0/XNzc3U1dXRzqdpra2tl9xb8rLq18mGoqyVWwrli1bRl1d8TK3WOzP1NRcDUBb21fJZD7b4zjRlc/jRxLkG3qvNtchnU4TSo5laQvsu+04krFhXjG9IxHqmPULh+EnP4GPf7yycYmIjHKD/TdURGRLq9jMkOu6vPjiixx22GFF5w877DCee+65Po3h+z4tLS2MHTu212scx6G5ubnoazB1LJMzxvRY2rpPxRP8PJbbiulD8YSOIg3rsoa66sjwT4QArryyOBG68kolQiIiIiJSdhVLhpqamvA8j4kTJxadnzhxIo2NjX0a46qrrqKtrY3jjjuu12vmz59PXV1d4Wv69F4KFpSJ4znEQjF6m3DrSzJkO0HC1pfiCa7rQihCSw6mjJTCCcceC7W1nYnQxz5W6YhEREREZASqeAGFjWdPeptR2dh9993H5ZdfzgMPPMCETTTdvOSSS0in04WvZcuWDTjm3ni+h2c8IqFIYc9QMVOoJOf7YzGmvsdxbCcFoWjQY2gzcrkcbSZK2LaZWDNCCifssAPcdBP87GdKhERERERk0FRsTVVDQwOhUKjbLNDq1au7zRZt7IEHHuC0007jN7/5DYcccsgmr43FYsRiWyZJ6Gi4Gg1FMW73mSHbbsKyWgHI57fpdRw7m+rTrJAxBmMM67KGyeNihEMVz237x/PAsqBrsYkddqhcPCIiIiIyKlTs03M0GmXOnDksXLiw6PzChQvZf//9e73vvvvu48tf/jL33nsvRx555GCHWZKOhqsdy+Q2nuHq7C+0iUpyxsdym/uUDOVyOTK+jWeFhm9voXweLrkkKJDg+5WORkRERERGkYrutp83bx5f+tKX2Guvvdhvv/34+c9/ztKlS5k7dy4QLHFbvnw5v/rVr4AgETr55JO59tpr2XfffQuzSlVVVd2qtlVCRzIUtaO0e+3dHg+Fuu4X6nlmyHKawRj8PhRPcF2XdC5ETTJKfXW0f0FXUi4H3/42PPlkcByLwbx5lY1JREREREaNiiZDxx9/PGvXruV73/seK1euZJddduGxxx5jxowZAKxcubKo59Ctt95KPp/n7LPP5uyzzy6cP+WUU7jrrru2dPjduL6LbdmFPUPdewx1zgz1XjwhBVYIE0lu9vmcXJ5Wr4qZw3FWKJcLZoT++tfgOBqFTcwIioiIiIiUW8XrMJ911lmcddZZPT62cYLz144PzkOU4zlE7AgQlLzeWGcluQieN63HMWwnjR+rDfbQbEI+n2d91hCJRJhUFx9Q3FtcLgcXXwxPPRUcR6Nw9dWwzz6VjUtERERERpVhuuN+aMp5OaKhYLmaMWajmaEsodAKAPL5GUCo+wDGYGfTfV4il3ItJtYniEd6GGuocl341reKE6FrrlEiJCIiIiJbnJKhMuroMQTBzE1X4fBSwN/wWC/7hXKtYDz8WP1mnyvV5uDZUaaOGUZL5DoSoaefDo5jsSAR2nvvioYlIiIiIqOTkqEycj23sExu45mhrs1We6skZ2fTYFmYWO0mn8f3fZra8ySqYjQkhklvIdeFiy6CZ54JjpUIiYiIiEiFKRkqI9d3gx5DG/r/dNU1GdpU8QQTrQVr0z8WZ8MSuRnja7HtzTeoHRJaW6Gj4W08DtddBx/9aGVjEhEREZFRTclQmRhjyHk5YqEYvu93mxkKhbpWkut5mZzt9G2/0Kp0hlAkyrSxiQHHvcWMHQu33grbbx8kQnPmVDoiERERERnlKl5NbqTI+TkMppeZIVMoq+37DRhT0+1+K9cOntunZquNLS4TxjWQiA2zH19DA9x9N9jKwUVERESk8vSptEw6Gq5G7EghGeqYGbLt1VhWG7CZ/kKw2WSoNePQlrPYekLlm8xukuPATTdBNlt8XomQiIiIiAwR+mRaJo7nABALxbrNDBU3W+2lklw2jYkmwd70bM+H69qJxyJMGTOEl8hls3D++XDHHcF/N06IRERERESGACVDZZLzcwBEQ9Fue4ZCofcL1/VaSc5JbXZWyBhDY3OW6ePriISHaG+hbBbmzYN//jM4fv11WLq0sjGJiIiIiPRgmG06GboczyFsh7EtezMzQ1t3vznvYOWzmy2esK49R863mNHQfc/RkNAxI/T888FxdTXccAPMnl3ZuEREREREeqCZoTJxPbfQcHXjPUPh8PsbrgrheVO73du5X6h+k8+xfF0bNVVRJo4ZgslQJgPnndeZCCUScOONsOuuFQ1LRERERKQ3SobKxPWLG652yhEKLQfA86bT02Sc7aQx4SoIRXsdP+f5rGrOsvWE2qKS3UNCJgPf+Aa88EJw3JEIfeQjlY1LRERERGQThtin6uHL9YKGqwC+7xfOh0IfAh4A+fyMHu+1s6nNLpFb3eJijGHG+CFWRa69PUiEXnopOE4mgypyu+xS2bhERERERDZDyVCZ9LRMDiAc/qBwTY9ltf0cVq5ts8UTVqSzNNTEqElUlS/ocrj99u6J0M47VzYmEREREZE+UDJUJq7nErWDmSFjDJZlARtXkus+M2Rn08E9m5gZanU80u0OW41LEo32vpSuIs44A/beG2pqgkRop50qHZGIiIiISJ+omlwZ5P08nvEKy+SKK8m933ldD5XkbCcFoWiwZ6gXq1pcwpZhWsMQWyIHEIvBggWwYgVs03MPJRERERGRoUgzQ2Xgei5Aj3uGOpIhY6rw/Ynd7rWd9Cb3C3m+YVWLw/hEhKqqIbBErq0N1qwpPhePKxESERERkWFHyVAZ2VbwdnYkQ5aVwbZXAR1L5KziG3wPy2neZEnttW05sm6OqWOqicVigxF237W2wjnnwJlnwurVlY1FRERERGSAlAwNAt/3sSyraL9Qj0vk3Obg+k0UT1jVmqM6ZGior6lsSe2OROjVV2HpUrj4YigqIS4iIiIiMrwoGRoEnudhWdZGleS27nadlU2BHcZEEj2Ok8l5pDI5GqpDlV0i19ICZ58Nr70WHNfVBcmQZW36PhERERGRIUwFFAZBTzNDnrd1t+tsJxXMCvWSVKxqyYHvM7E2TjweH6RoN6MjEXrjjeC4vh5uvhlmzapMPCIiIiIiZaKZoUHQkQyFw0sK57o1XDU+ttPca/EEYwyrW13qY5CoriISiQxixL1obu6eCN1yixIhERERERkRlAwNgs5k6IMNx/UYU190jeW2gPF73S+0PpPHzRvGxiGZTA52yN1tnAiNGQO33grbbbflYxERERERGQRKhsrMGIPv+4RCaSwraKja8xK5NFg2JlrT4zirWnLEw1Abj2z5KnLt7UEi9OabwfHYsUEitO22WzYOEREREZFBpGSozIwxGGOIRJYWzvVYSS6bxo/VgtX9R5DzfNa15xgbt4hGo1s+Gaqqgo98JPh+7NhgaZz6CImIiIjICKMCCmXWkQxFo10ryc3c+CJsJ0W+ZlqPY6xuzQFQH4VEIrHlS2pbFlx4ISSTcPjhMHPm5u8RERERERlmlAyVWUfD1a4zQ0HD1U5Wrh38PKaX4gmrWlzGVocJWfktV1LbmOKqdpYFZ521ZZ5bRERERKQCtEyuzDr2DBX3GNqq6BrbSQHgR2u73d+czdPu+jRU2UQiW2i/UCoFZ57ZuUdIRERERGQUUDJUZsEyOa8wM+R5k4Di2R3bSQWFE+xQt/tXtbjEwhZVtkc8HicajQ5uwOvXw9y58NJLwUyQEiIRERERGSWUDJWZMYZQaDWWlQV6qSSXTfXYX8jzDU1tOSbURPF9n0QiMbjBrlsXJELvvhscx+Mw2M8pIiIiIjJEKBkqM9/3N8wKBftvNm62auUz4Lk99hdqasvh+TC+OoxlWcTj8cELtCMReu+94HjChKB89lZbbfo+EREREZERQgUUyswYQzj8fuHY84orsVnZoPdQT8nQqhaXuqowtskTGsyS2h2J0OLFwXFHIjR9+uA8n4iIiIjIEKSZoTILegytKhzn88Xls20nhYkkIFS8FyiT82jOekyqieC67uCV1F67NiiW0JEITZwIP/+5EiERERERGXWUDJVZsGcoVTj2/Yaix20n3cusUI6wbTG2OowxZnBKajc1BYnQkiXB8aRJQSI0red+RyIiIiIiI5mSoTLzfZ9QaP2GoxDG1HQ+6LlYufZuxROMMaxqcRlfE8H3vMErqf3CC/D++8H3kycHidDUqeV/HhERERGRYUB7hsos2DOUAsD3x9A13yz0F4rVF92zrj1PzjNMTEZx3SzxeJxIJFL+4D79aWhthV/9Cm65BaZMKf9ziIiIiIgME0qGyswYj1CoGbA2JEOd7GwaE45DuHjWZ1WrSyIWIhkLkc7mSSaTWJY1OAF+7nNw5JEwGMvwRERERESGES2TKzPfbwL8Dd+PLXrMdlLd9gu5eZ/17Xkm1UTwfR/btsu3RG71anj66e7nlQiJiIiIiCgZKr+1dEzqFM0M+XkstxWz0X6h1a05AMYnoriuW779QqtXwxlnwAUXwOOPD3w8EREREZERRslQ2TUVvus6M2Q7zcG5jWaGGltcGhIRwiGrUFI7FAoNLIRVq4JE6MMPwffhppsgnx/YmCIiIiIiI4ySobJbBwRTQ8XJUApC0aDH0AbN2TzZnM/EmqDnUFlKajc2diZCEJTNvvlmCGt7mIiIiIhIV0qGysyyus4MdS6Ts7Pd9ws1trjEIzZ18RD5fJ5wODywJXIrVwaJ0PLlwfH06UH57AkT+j+miIiIiMgIpWSozCxrbeH7wsyQ8bHc5qJkKO8bmtpyTEhGsKxgiVwsFiMajfbviVesCBqqrlgRHG+1Fdx6qxIhEREREZFeKBkqI2MMtr2uWwEFy2kGY4qarTa15fB9Ckvk8vk8iUSifyW1lQiJiIiIiJRMyVAZdSRDHTqSIdtJgRXCRJKFx1a1uNRXhYmFbXw/KMUdj8dLf1LPg298I1giBzBjRrA0bvz4fr8OEREREZHRQMlQGQXJ0HrAwpgkEMz62E4aP1ZLx5RRm+vRkvUKs0K5XK7/JbVDIbjwQohGYeutg0SooaE8L0hEREREZARTibEyMsbfkAx13S9ksLNp8nVbFa5b3eISDlmMSwRvv+u61NXVEe5vxbe994YbbghmhcaNG9BrEBEREREZLZQMlZExbViWC1id+4VyrWC8QvEE3xhWtQaFE2yrowS3X1pJ7eZmqK0tPrfnnuV4CSIiIiIio4aWyZWTCcpqW1bnzJCdTYNlYTYkQ+va8+Q9U1Q4IRQK9X2J3NKlcMIJwXI4ERERERHpNyVDZWSxDjBAl2TISWGitWAFb/WqFpdkLEQiGgKC/ULRaLRvydDSpUHVuNWrg2TooYcG5XWIiIiIiIwGSobKqLPHkNWlkly6UFLbyfukMvnCrBAEyVAymdx8Se2lS4OGqmvWBMfbbQcHHVTmVyAiIiIiMnooGSojy1qLCSaG8P2xWLl28NzCfqHVrS6WBeMTESCoPgd9KKn9wQdBItQULMNj1iy45RYYM2ZQXoeIiIiIyGigZKiMLNYWvvf9MUF/IcCP1WKMYVVLjnHVEcKhYBaoTyW133+/OBGaPRtuvhnq6wfnRYiIiIiIjBJKhsrItro2XB2LlU1jokmwIzRnPbI5n0ldlsi5rks8HicSifQ84JIlwR6htRuSLCVCIiIiIiJlo2SojGxrfeH7jpmhjiVyjS0u8YhNXVVnNXPP80gkEj0PtnhxcSK0/fbB0ri6ukGLX0RERERkNFEyVEZWYWYogslFsPJZ/Hg9ec+wtj3HxJrOGSDXdYlEIr33FwqHwd7w49lhh2BGaOPeQiIiIiIi0m9KhsqoY2YomBVKB9/H6lnTlsMYmJDsXCLnOA7JZLL3/UJbbRWUz/7Yx+Cmm5QIiYiIiIiUWXjzl0hfWOSx7WZ8P9gvZDtpTLgKQlFWtbQypipMLBzknr7vY4whmUxuetCttoIFC7ZA9CIiIiIio49mhsokbLfQUVfb98diZ1P48XraHI9WxyvqLZTNZqmqqqK6urpzgHffhR/9CDxvS4cuIiIiIjIqaWaoTCJ2GgNYFvheLVauDb92OqtaXSIhizHVnW91LpejoaEBu2NP0Ntvw9e+Buk0tLTAD34AoVBlXoiIiIiIyCihmaEyiYTShZkh4wRFEbxYHatbckxIRrCtoLeQ67pEo9HOWaGuiRDAypXgOFs8fhERERGR0UbJUJl0zAyBhcmGIRSlyYmQ903REjnHcUgkEkSjUXjrLZg7tzMR2nVXuPFG6Lp8TkREREREBoWSoTKJ2OnOg0wYP1bPqhaXmniI6miw5M33fQBqamrg3/8OZoSam4N7dt0Vrr8eeus7JCIiIiIiZaVkqEwidjPGGMBAxiYbriWVyXcrnBCPx6l6/30466zORGi33eCGG5QIiYiIiIhsQUqGyiS8YWbIMj5+LkljrgrbhoZE0GjVGEMul2PMypXY55zTmQjtvnswI6SlcSIiIiIiW5SqyZVJpGsy5NWx0osyPhEmbBcXTkjcdVdQMQ5gjz3g2muVCImIiIiIVIBmhsokYgfV5EwuTjN1ZPPdCyfU1NQQuvJK2GEH2HNPJUIiIiIiIhWkmaGyMITtZjBg3CpW5xNURWxq48Hbm8/nsSwrKJxQVQU33QSRSPC9iIiIiIhUhGaGyqIF28qD8fHcBI356sKsUPjdd3GbmkgkEsTj8eDy2lolQiIiIiIiFaaZoTKwWBt843tknCS5cJIJyQjhN96g7tJLiU6aROjmm7E2NF4VEREREZHK08xQGVjWWowBy3iks2MZk4hS/dab1H3nO5j2dqoWLyZx772VDlNERERERLpQMlQWTQD4fp7m3Hi2XvYOdf/931iZDMYYzEc/GpTTFhERERGRIUPJUBlYrAPj4/uGyAqP6T+8opAIObvvjnXNNdCxX0hERERERIaEiidDN910EzNnziQejzNnzhyeeeaZTV7/1FNPMWfOHOLxONtssw233HLLFoq0d5a1FowHWZet734MK5sFoH3XXcn+8IfEamsrHKGIiIiIiGysosnQAw88wHnnncell17KokWLOPDAAzn88MNZunRpj9cvWbKEI444ggMPPJBFixbx7W9/m3PPPZff/va3WzjyYhbrsNoyxNemCDf5ADh77snqb32L2vHjKxqbiIiIiIj0zDLGmEo9+T777MOee+7JzTffXDi34447cswxxzB//vxu13/rW9/i0Ucf5c033yycmzt3Lv/617/4+9//3qfnbG5upq6ujnQ6TW2ZZmzy6z6PWfEolgHvtFm0b78Hqy+6iJpx45g8ebKqyImIyIgwGH9DRUQqqWIzQ67r8uKLL3LYYYcVnT/ssMN47rnnerzn73//e7frP/WpT/HCCy+Qy+V6vMdxHJqbm4u+ys1LtJOLR8Cxad9hT7I/+AHTttlGiZCIiIiIyBBWsWSoqakJz/OYOHFi0fmJEyfS2NjY4z2NjY09Xp/P52lqaurxnvnz51NXV1f4mj59enleQBfhcCv+5Mn49dsSv/56Jm21FYlEQomQiIiIiMgQVvECChsnDMaYTSYRPV3f0/kOl1xyCel0uvC1bNmyAUbcXSj0F5KJZ4lu9zuq6uqUBImIiIiIDAPhSj1xQ0MDoVCo2yzQ6tWru83+dJg0aVKP14fDYcaNG9fjPbFYjFgsVp6gexUBeo5ZRERERESGporNDEWjUebMmcPChQuLzi9cuJD999+/x3v222+/btf/+c9/Zq+99iISiQxarCIiIiIiMvJUdJncvHnzuO2227jjjjt48803Of/881m6dClz584FgiVuJ598cuH6uXPn8sEHHzBv3jzefPNN7rjjDm6//XYuuOCCSr0EEREREREZpiq2TA7g+OOPZ+3atXzve99j5cqV7LLLLjz22GPMmDEDgJUrVxb1HJo5cyaPPfYY559/PjfeeCNTpkzhuuuu47/+678q9RJERERERGSYqmifoUpQjwQREZH+0d9QERlpKl5NTkREREREpBKUDImIiIiIyKikZEhEREREREYlJUMiIiIiIjIqKRkSEREREZFRScmQiIiIiIiMSkqGRERERERkVFIyJCIiIiIio5KSIRERERERGZWUDImIiIiIyKikZEhEREREREYlJUMiIiIiIjIqKRkSEREREZFRKVzpALY0YwwAzc3NFY5ERERkeOn429nxt1REZLgbdclQS0sLANOnT69wJCIiIsNTS0sLdXV1lQ5DRGTALDPK/nnH931WrFhBTU0NlmWVbdzm5mamT5/OsmXLqK2tLdu4o5Xez/LTe1peej/LT+9peQ3G+2mMoaWlhSlTpmDbWmkvIsPfqJsZsm2badOmDdr4tbW1+iNeRno/y0/vaXnp/Sw/vaflVe73UzNCIjKS6J91RERERERkVFIyJCIiIiIio5KSoTKJxWJcdtllxGKxSocyIuj9LD+9p+Wl97P89J6Wl95PEZHNG3UFFEREREREREAzQyIiIiIiMkopGRIRERERkVFJyZCIiIiIiIxKSoZERERERGRUUjLURzfddBMzZ84kHo8zZ84cnnnmmU1e/9RTTzFnzhzi8TjbbLMNt9xyyxaKdPgo5T196KGHOPTQQxk/fjy1tbXst99+/OlPf9qC0Q59pf6Odvjb3/5GOBxm9913H9wAh6FS31PHcbj00kuZMWMGsViMbbfdljvuuGMLRTs8lPqe3nPPPey2225UV1czefJkTj31VNauXbuFoh3ann76aY466iimTJmCZVk88sgjm71Hf5tERIopGeqDBx54gPPOO49LL72URYsWceCBB3L44YezdOnSHq9fsmQJRxxxBAceeCCLFi3i29/+Nueeey6//e1vt3DkQ1ep7+nTTz/NoYceymOPPcaLL77IQQcdxFFHHcWiRYu2cORDU6nvZ4d0Os3JJ5/MJz/5yS0U6fDRn/f0uOOO4/HHH+f222/nrbfe4r777mOHHXbYglEPbaW+p88++ywnn3wyp512Gq+//jq/+c1veP755zn99NO3cORDU1tbG7vtths33HBDn67X3yYRkR4Y2ay9997bzJ07t+jcDjvsYC6++OIer7/ooovMDjvsUHTuzDPPNPvuu++gxTjclPqe9mSnnXYyV1xxRblDG5b6+34ef/zx5jvf+Y657LLLzG677TaIEQ4/pb6nf/jDH0xdXZ1Zu3btlghvWCr1Pf3pT39qttlmm6Jz1113nZk2bdqgxThcAebhhx/e5DX62yQi0p1mhjbDdV1efPFFDjvssKLzhx12GM8991yP9/z973/vdv2nPvUpXnjhBXK53KDFOlz05z3dmO/7tLS0MHbs2MEIcVjp7/t555138t5773HZZZcNdojDTn/e00cffZS99tqLK6+8kqlTpzJ79mwuuOACMpnMlgh5yOvPe7r//vvz4Ycf8thjj2GMYdWqVTz44IMceeSRWyLkEUd/m0REugtXOoChrqmpCc/zmDhxYtH5iRMn0tjY2OM9jY2NPV6fz+dpampi8uTJgxbvcNCf93RjV111FW1tbRx33HGDEeKw0p/385133uHiiy/mmWeeIRzW/wY21p/3dPHixTz77LPE43EefvhhmpqaOOuss1i3bp32DdG/93T//ffnnnvu4fjjjyebzZLP5zn66KO5/vrrt0TII47+NomIdKeZoT6yLKvo2BjT7dzmru/p/GhW6nva4b777uPyyy/ngQceYMKECYMV3rDT1/fT8zxOPPFErrjiCmbPnr2lwhuWSvkd9X0fy7K455572HvvvTniiCNYsGABd911l2aHuijlPX3jjTc499xz+e53v8uLL77IH//4R5YsWcLcuXO3RKgjkv42iYgU0z8Jb0ZDQwOhUKjbv1yuXr2627+wdZg0aVKP14fDYcaNGzdosQ4X/XlPOzzwwAOcdtpp/OY3v+GQQw4ZzDCHjVLfz5aWFl544QUWLVrEOeecAwQf5I0xhMNh/vznP3PwwQdvkdiHqv78jk6ePJmpU6dSV1dXOLfjjjtijOHDDz9k1qxZgxrzUNef93T+/PkccMABXHjhhQDsuuuuJBIJDjzwQH7wgx9oJqNE+tskItKdZoY2IxqNMmfOHBYuXFh0fuHChey///493rPffvt1u/7Pf/4ze+21F5FIZNBiHS76855CMCP05S9/mXvvvVd7Broo9f2sra3l1Vdf5eWXXy58zZ07l+23356XX36ZffbZZ0uFPmT153f0gAMOYMWKFbS2thbOvf3229i2zbRp0wY13uGgP+9pe3s7tl38ZyoUCgGdMxrSd/rbJCLSgwoVbhhW7r//fhOJRMztt99u3njjDXPeeeeZRCJh3n//fWOMMRdffLH50pe+VLh+8eLFprq62px//vnmjTfeMLfffruJRCLmwQcfrNRLGHJKfU/vvfdeEw6HzY033mhWrlxZ+EqlUpV6CUNKqe/nxlRNrrtS39OWlhYzbdo087nPfc68/vrr5qmnnjKzZs0yp59+eqVewpBT6nt65513mnA4bG666Sbz3nvvmWeffdbstddeZu+9967USxhSWlpazKJFi8yiRYsMYBYsWGAWLVpkPvjgA2OM/jaJiPSFkqE+uvHGG82MGTNMNBo1e+65p3nqqacKj51yyinm4x//eNH1f/3rX80ee+xhotGo2Xrrrc3NN9+8hSMe+kp5Tz/+8Y8boNvXKaecsuUDH6JK/R3tSslQz0p9T998801zyCGHmKqqKjNt2jQzb948097evoWjHtpKfU+vu+46s9NOO5mqqiozefJkc9JJJ5kPP/xwC0c9ND355JOb/P+i/jaJiGyeZYzWGoiIiIiIyOijPUMiIiIiIjIqKRkSEREREZFRScmQiIiIiIiMSkqGRERERERkVFIyJCIiIiIio5KSIRERERERGZWUDImIiIiIyKikZEhEREREREYlJUMiI8xdd91FfX19pcPot6233pprrrlmk9dcfvnl7L777lskHhERERm5lAyJDEFf/vKXsSyr29e7775b6dC46667imKaPHkyxx13HEuWLCnL+M8//zxnnHFG4diyLB555JGiay644AIef/zxsjxfbzZ+nRMnTuSoo47i9ddfL3mc4ZycioiIjGRKhkSGqE9/+tOsXLmy6GvmzJmVDguA2tpaVq5cyYoVK7j33nt5+eWXOfroo/E8b8Bjjx8/nurq6k1ek0wmGTdu3ICfa3O6vs7f//73tLW1ceSRR+K67qA/t4iIiAw+JUMiQ1QsFmPSpElFX6FQiAULFvCRj3yERCLB9OnTOeuss2htbe11nH/9618cdNBB1NTUUFtby5w5c3jhhRcKjz/33HN87GMfo6qqiunTp3PuuefS1ta2ydgsy2LSpElMnjyZgw46iMsuu4zXXnutMHN18803s+222xKNRtl+++25++67i+6//PLL2WqrrYjFYkyZMoVzzz238FjXZXJbb701AMceeyyWZRWOuy6T+9Of/kQ8HieVShU9x7nnnsvHP/7xsr3Ovfbai/PPP58PPviAt956q3DNpn4ef/3rXzn11FNJp9OFGabLL78cANd1ueiii5g6dSqJRIJ99tmHv/71r5uMR0RERMpLyZDIMGPbNtdddx2vvfYav/zlL3niiSe46KKLer3+pJNOYtq0aTz//PO8+OKLXHzxxUQiEQBeffVVPvWpT/HZz36WV155hQceeIBnn32Wc845p6SYqqqqAMjlcjz88MN84xvf4Jvf/CavvfYaZ555JqeeeipPPvkkAA8++CBXX301t956K++88w6PPPIIH/nIR3oc9/nnnwfgzjvvZOXKlYXjrg455BDq6+v57W9/WzjneR6//vWvOemkk8r2OlOpFPfeey9A4f2DTf889t9/f6655prCDNPKlSu54IILADj11FP529/+xv33388rr7zC5z//eT796U/zzjvv9DkmERERGSAjIkPOKaecYkKhkEkkEoWvz33ucz1e++tf/9qMGzeucHznnXeaurq6wnFNTY256667erz3S1/6kjnjjDOKzj3zzDPGtm2TyWR6vGfj8ZctW2b23XdfM23aNOM4jtl///3NV7/61aJ7Pv/5z5sjjjjCGGPMVVddZWbPnm1c1+1x/BkzZpirr766cAyYhx9+uOiayy67zOy2226F43PPPdccfPDBheM//elPJhqNmnXr1g3odQImkUiY6upqAxjAHH300T1e32FzPw9jjHn33XeNZVlm+fLlRec/+clPmksuuWST44uIiEj5hCubiolIbw466CBuvvnmwnEikQDgySef5Ec/+hFvvPEGzc3N5PN5stksbW1thWu6mjdvHqeffjp33303hxxyCJ///OfZdtttAXjxxRd59913ueeeewrXG2PwfZ8lS5aw44479hhbOp0mmUxijKG9vZ0999yThx56iGg0yptvvllUAAHggAMO4NprrwXg85//PNdccw3bbLMNn/70pzniiCM46qijCIf7/7+jk046if32248VK1YwZcoU7rnnHo444gjGjBkzoNdZU1PDSy+9RD6f56mnnuKnP/0pt9xyS9E1pf48AF566SWMMcyePbvovOM4W2QvlIiIiASUDIkMUYlEgu22267o3AcffMARRxzB3Llz+f73v8/YsWN59tlnOe2008jlcj2Oc/nll3PiiSfy+9//nj/84Q9cdtll3H///Rx77LH4vs+ZZ55ZtGenw1ZbbdVrbB1Jgm3bTJw4sduHfsuyio6NMYVz06dP56233mLhwoX85S9/4ayzzuKnP/0pTz31VNHys1LsvffebLvtttx///187Wtf4+GHH+bOO+8sPN7f12nbduFnsMMOO9DY2Mjxxx/P008/DfTv59ERTygU4sUXXyQUChU9lkwmS3rtIiIi0n9KhkSGkRdeeIF8Ps9VV12FbQdb/n79619v9r7Zs2cze/Zszj//fL7whS9w5513cuyxx7Lnnnvy+uuvd0u6NqdrkrCxHXfckWeffZaTTz65cO65554rmn2pqqri6KOP5uijj+bss89mhx124NVXX2XPPffsNl4kEulTlboTTzyRe+65h2nTpmHbNkceeWThsf6+zo2df/75LFiwgIcffphjjz22Tz+PaDTaLf499tgDz/NYvXo1Bx544IBiEhERkf5TAQWRYWTbbbcln89z/fXXs3jxYu6+++5uy7a6ymQynHPOOfz1r3/lgw8+4G9/+xvPP/98ITH51re+xd///nfOPvtsXn75Zd555x0effRRvv71r/c7xgsvvJC77rqLW265hXfeeYcFCxbw0EMPFQoH3HXXXdx+++289tprhddQVVXFjBkzehxv66235vHHH6exsZH169f3+rwnnXQSL730Ej/84Q/53Oc+RzweLzxWrtdZW1vL6aefzmWXXYYxpk8/j6233prW1lYef/xxmpqaaG9vZ/bs2Zx00kmcfPLJPPTQQyxZsoTnn3+en/zkJzz22GMlxSQiIiL9p2RIZBjZfffdWbBgAT/5yU/YZZdduOeee5g/f36v14dCIdauXcvJJ5/M7NmzOe644zj88MO54oorANh111156qmneOeddzjwwAPZY489+O///m8mT57c7xiPOeYYrr32Wn7605+y8847c+utt3LnnXfyiU98AoD6+np+8YtfcMABB7Drrrvy+OOP87vf/a7XvTJXXXUVCxcuZPr06eyxxx69Pu+sWbP46Ec/yiuvvFKoItehnK/zG9/4Bm+++Sa/+c1v+vTz2H///Zk7dy7HH38848eP58orrwSCCnknn3wy3/zmN9l+++05+uij+b//+z+mT59eckwiIiLSP5YxxlQ6CBERERERkS1NM0MiIiIiIjIqKRkSEREREZFRScmQiIiIiIiMSkqGRERERERkVFIyJCIiIiIio5KSIRERERERGZWUDImIiIiIyKikZEhEREREREYlJUMiIiIiIjIqKRkSEREREZFRScmQiIiIiIiMSv8fAj9o2BDci9YAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "(-0.05, 1.05)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "(-0.05, 1.05)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Decision Tree')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Recall (Sensitivity)')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Precision (PPV)')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0AAAAIhCAYAAABnvNoJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADhXklEQVR4nOzdd3hUVf748fed3pNMekJIqKFJ7+AKiiCrgCsivxURlFVZK1LcBb6KyyquWBbLgqIRxUXBBiorKmJFFJAiVXoIhPRMMpnJ9Lm/P0JGQgpJSKGc1/PM8zD3nnvuuTdkcj9zzuccSZZlGUEQBEEQBEEQhMuAorkbIAiCIAiCIAiC0FREACQIgiAIgiAIwmVDBECCIAiCIAiCIFw2RAAkCIIgCIIgCMJlQwRAgiAIgiAIgiBcNkQAJAiCIAiCIAjCZUMEQIIgCIIgCIIgXDZEACQIgiAIgiAIwmVDBECCIAiCIAiCIFw2RAAkCBepN998E0mSQi+dTkdcXBxDhw7lqaeeIjc3t1HPn56ejiRJvPnmm3U6bvLkyaSkpDRKm2o655n3qrrX5MmTm7RdgiAIgiA0PUmWZbm5GyEIQt29+eab3HHHHSxbtowOHTrg8/nIzc1l48aNLFu2DKVSyapVqxg2bFijnN/j8bBjxw7atGlDdHR0rY87cuQIdrudHj16NEq7qjtnXl5e6P327du57777WLBgAUOHDg1tj46Opk2bNk3WLkEQBEEQmp6quRsgCML56dKlC7179w69Hzt2LA8//DCDBw/mpptu4tChQ8TGxjb4ebVaLf3796/zcc0RYLRp06bCed1uNwDt2rWr8RpcLhc6nQ5Jkhq9jYIgCIIgNA0xBE4QLkEtW7bkueeeo6SkhFdffbXCvl9++YXRo0djtVrR6XT06NGD9957r1IdmZmZ3H333SQlJaHRaEhISODmm28mJycHqHoIXF5eXugYrVZLdHQ0gwYN4quvvgqVqWoInNvtZvbs2bRq1QqNRkNiYiL33XcfRUVFFcqlpKRwww038Pnnn9OzZ0/0ej0dOnTgjTfeOL8bxu9DCr/88kvuvPNOoqOjMRgMeDweAFatWsWAAQMwGo2YTCZGjBjBjh07KtVT2/srCIIgCELzEAGQIFyi/vjHP6JUKvn+++9D27755hsGDRpEUVERr7zyCh9//DHdu3dn/PjxFQKZzMxM+vTpw+rVq5k+fTrr1q1j0aJFhIWFYbPZqj3nxIkTWbNmDY899hhffvklr7/+OsOGDaOgoKDaY2RZ5sYbb+TZZ59l4sSJ/O9//2P69Om89dZbXH311aEApNyvv/7KjBkzePjhh/n444/p2rUrU6ZMqXCd5+POO+9ErVbz9ttv88EHH6BWq1mwYAF//vOf6dSpE++99x5vv/02JSUlXHnllezbty90bG3vryAIgiAIzUgWBOGitGzZMhmQt27dWm2Z2NhYuWPHjqH3HTp0kHv06CH7fL4K5W644QY5Pj5eDgQCsizL8p133imr1Wp537591dZ97NgxGZCXLVsW2mYymeRp06bV2O5JkybJycnJofeff/65DMgLFy6sUG7VqlUyIC9dujS0LTk5WdbpdPLx48dD21wul2y1WuV77rmnxvOe6ZtvvpEB+f333w9tK7+ft99+e4WyGRkZskqlkh944IEK20tKSuS4uDj5lltuCW2r7f0VBEEQBKH5iB4gQbiEyWfMcXL48GF+++03JkyYAIDf7w+9/vjHP5KVlcWBAwcAWLduHUOHDqVjx451Ol/fvn158803eeKJJ/j555/x+XznPObrr78GqDQD27hx4zAajWzYsKHC9u7du9OyZcvQe51OR/v27Tl+/Hid2lqdsWPHVnj/xRdf4Pf7uf322yvcM51Ox1VXXcW3334L1O3+CoIgCILQfEQAJAiXKKfTSUFBAQkJCQCh3J2ZM2eiVqsrvO69914A8vPzgbJcnhYtWtT5nKtWrWLSpEm8/vrrDBgwAKvVyu233052dna1xxQUFKBSqSrNJCdJEnFxcZWGz0VGRlaqQ6vV4nK56tzeqsTHx1d4X37f+vTpU+m+rVq1KnTP6nJ/BUEQBEFoPmIWOEG4RP3vf/8jEAgwZMgQAKKiogCYPXs2N910U5XHpKamAmXTQZ88ebLO54yKimLRokUsWrSIjIwMPvnkE/7+97+Tm5vL559/XuUxkZGR+P1+8vLyKgRBsiyTnZ1Nnz596tyO83H2jG/l9+2DDz4gOTm52uPqcn8FQRAEQWg+IgAShEtQRkYGM2fOJCwsjHvuuQcoe/hu164dv/76KwsWLKjx+JEjR/L2229z4MCBej+0t2zZkvvvv58NGzbw448/VlvummuuYeHChfz3v//l4YcfDm3/8MMPcTqdXHPNNfU6f0MZMWIEKpWKI0eOVBoed6a63F9BEARBEJqPCIAE4SK3Z8+eUK5Jbm4uP/zwQ2gh1NWrV1foVXn11VcZOXIkI0aMYPLkySQmJlJYWMj+/fvZvn0777//PgDz589n3bp1/OEPf2DOnDlcccUVFBUV8fnnnzN9+nQ6dOhQqR3FxcUMHTqUW2+9lQ4dOmA2m9m6dSuff/55tT0iANdeey0jRozgb3/7G3a7nUGDBrFr1y7mzZtHjx49mDhxYsPftDpISUlh/vz5zJ07l6NHj3LdddcRERFBTk4OW7ZswWg08o9//AOo/f0VBEEQBKH5iABIEC5yd9xxBwAajYbw8HA6duzI3/72N/7yl79UyqsZOnQoW7Zs4cknn2TatGnYbDYiIyPp1KkTt9xyS6hcYmIiW7ZsYd68efzrX/+ioKCA6OhoBg8ejNVqrbIdOp2Ofv368fbbb5Oeno7P56Nly5b87W9/45FHHqm2/ZIksWbNGh5//HGWLVvGk08+SVRUFBMnTmTBggVotdoGuEvnZ/bs2XTq1IkXXniBd999F4/HQ1xcHH369GHq1KmhcrW9v4IgCIIgNB9JPnOaKEEQBEEQBEEQhEuYmAVOEARBEARBEITLhgiABEEQBEEQBEG4bIgASBAEQRAEQRCEy4YIgARBEARBEARBuGyIAEgQBEEQBEEQhMuGCIAEQRAEQRAEQbhsXHbrAAWDQU6dOoXZbEaSpOZujiAIgiBcNGRZpqSkhISEBBQK8R2qIAgXp8suADp16hRJSUnN3QxBEARBuGidOHGCFi1aNHczBEEQ6uWyC4DMZjNQ9uFtsViauTWCIAiCcPGw2+0kJSWF/pYKgiBcjC67AKh82JvFYhEBkCAIgiDUgxhCLgjCxUwM4BUEQRAEQRAE4bIhAiBBEARBEARBEC4bIgASBEEQBEEQBOGycdnlAAmCIAiC0LRkWcbv9xMIBJq7KYIgXKKUSiUqlapWOYoiABIEQRAEodF4vV6ysrIoLS1t7qYIgnCJMxgMxMfHo9FoaiwnAiBBEARBEBpFMBjk2LFjKJVKEhIS0Gg0YgY5QRAanCzLeL1e8vLyOHbsGO3atatxsWYRAAmCIAiC0Ci8Xi/BYJCkpCQMBkNzN0cQhEuYXq9HrVZz/PhxvF4vOp2u2rJiEgRBEARBEBpVTd/ECoIgNJTaftaITyRBEARBEARBEC4bIgASBEEQBEEQBOGyIQIgQRAEQRCEC8hvv/1G//790el0dO/evVbHTJ48mRtvvLHGMkOGDGHatGnn3b6qPProo9x9992NUrdQvT59+vDRRx81dzMuOiIAEgRBEARBOMPkyZORJAlJklCr1bRu3ZqZM2fidDoBSE9PD+2XJImwsDD69+/Pp59+WqmuDz/8kCFDhhAWFobJZKJr167Mnz+fwsLCas8/b948jEYjBw4cYMOGDY12nVX57rvv6NWrFzqdjtatW/PKK6+c85icnBxeeOEF5syZU2nfpk2bUCqVXHfddZX2ffvtt0iSRFFRUaV93bt35/HHH6+wbceOHYwbN47Y2Fh0Oh3t27fnrrvu4uDBg7W+vvpYvHgxrVq1QqfT0atXL3744Ycay5/5/+fMV+fOnUNl9u7dy9ixY0lJSUGSJBYtWlSpnpKSEqZNm0ZycjJ6vZ6BAweydevWCmUeffRR/v73vxMMBhvkWi8XIgASBEEQBEE4y3XXXUdWVhZHjx7liSeeYPHixcycObNCma+++oqsrCw2b95M3759GTt2LHv27Antnzt3LuPHj6dPnz6sW7eOPXv28Nxzz/Hrr7/y9ttvV3vuI0eOMHjwYJKTk4mMjGy0azzbsWPH+OMf/8iVV17Jjh07mDNnDg8++CAffvhhjcelpaUxYMAAUlJSKu174403eOCBB9i4cSMZGRn1btvatWvp378/Ho+HFStWsH//ft5++23CwsJ49NFH613vuaxatYpp06Yxd+5cduzYwZVXXsnIkSNrvJYXXniBrKys0OvEiRNYrVbGjRsXKlNaWkrr1q3517/+RVxcXJX1/OUvf2H9+vW8/fbb7N69m+HDhzNs2DAyMzNDZa6//nqKi4v54osvGu6iLwfyZaa4uFgG5OLi4uZuiiAIgiBcVOr6N9Tlcsn79u2TXS5XI7esYU2aNEkeM2ZMhW1/+ctf5Li4OFmWZfnYsWMyIO/YsSO03263y4D84osvyrIsy5s3b5YBedGiRVWew2azVbkdqPCaN2+eLMuyvGvXLnno0KGyTqeTrVarfNddd8klJSXVttnhcMgTJ06UjUajHBcXJz/77LPyVVddJT/00EPVXvcjjzwid+jQocK2e+65R+7fv3+1x8iyLF9xxRXyyy+/XGm7w+GQzWaz/Ntvv8njx4+X//GPf1TY/80338hAlfeiW7duoWt3Op1yVFSUfOONN1Z5/uruZUPo27evPHXq1ArbOnToIP/973+vdR2rV6+WJUmS09PTq9yfnJws//vf/66wrbS0VFYqlfLatWsrbO/WrZs8d+7cCtsmT54sT5w4sdbtuZTV9jOnWXuAvv/+e0aNGkVCQgKSJLFmzZpzHlOfrllBEARBEC4cgaCM3e1r0lcgKJ9Xm/V6PT6fr8p9Pp+P1157DQC1Wg3AihUrMJlM3HvvvVUeEx4eXuX2rKwsOnfuzIwZM8jKymLmzJmUlpZy3XXXERERwdatW3n//ff56quvuP/++6tt76xZs/jmm29YvXo1X375Jd9++y3btm2r8Rp/+uknhg8fXmHbiBEj+OWXX6q9dpvNxp49e+jdu3elfatWrSI1NZXU1FRuu+02li1bhizX/efwxRdfkJ+fzyOPPFLl/uruJcDUqVMxmUw1vqrrzfF6vWzbtq3SPRk+fDibNm2qdfvT0tIYNmwYycnJtT7G7/cTCAQqrWWj1+vZuHFjhW19+/Y957A8oaJmXQjV6XTSrVs37rjjDsaOHXvO8uVds3fddRf//e9/+fHHH7n33nuJjo6u1fGNRwbEytaCIAiCUBtOr58tR6vPgWkMfVtbsejU9Tp2y5YtvPPOO1xzzTUVtg8cOBCFQoHL5SIYDJKSksItt9wCwKFDh2jdunUoIKqtuLg4VCoVJpMpNDTqtddew+VysXz5coxGIwAvv/wyo0aN4umnnyY2NrZCHQ6Hg7S0NJYvX861114LwFtvvUWLFi1qPHd2dnalumJjY/H7/eTn5xMfH1/pmOPHjyPLMgkJCZX2paWlcdtttwFlQwodDgcbNmxg2LBhtbwbZQ4dOgRAhw4d6nQcwPz58ysNXTxbVW0HyM/PJxAIVHlPsrOza3X+rKws1q1bxzvvvFO7Bp9mNpsZMGAA//znP+nYsSOxsbG8++67bN68mXbt2lUom5iYSEZGBsFgUKy5VUvNGgCNHDmSkSNH1rr8K6+8QsuWLUOJYh07duSXX37h2WefbeYA6BWCwV9QKIYDVwPRzdgWQRAEQbiwGTUq+ra2Nvk562Lt2rWYTCb8fj8+n48xY8bw0ksvVSizatUqOnTowMGDB5k2bRqvvPIKVmvZdcmyjCQ1zJej+/fvp1u3bqHgB2DQoEEEg0EOHDhQ6QH9yJEjeL1eBgwYENpmtVpJTU0957nObnN5j0111+JyuQAq9VQcOHCALVu2hGYoU6lUjB8/njfeeKPOAVB9eo3KxcTEEBMTU+/joep7Utuf7Ztvvkl4ePg5Z+iryttvv82dd95JYmIiSqWSnj17cuutt7J9+/YK5fR6PcFgEI/Hg16vr/N5LkfNGgDVVXVds2lpafh8viq/ZfF4PHg8ntB7u93ewK2S8Xg/oaR0F5JyPSqVFoe/HUXu3hR5ehKgaT/gm5JepSdSF0mkPhKLxtJgH/SCIAjCpU2pkOrdG9NUhg4dypIlS1Cr1SQkJFT5jJGUlES7du1o164dJpOJsWPHsm/fPmJiYmjfvj0bN26s9vmkLmp64K5qe30Dhri4uEo9G7m5uahUqmonY4iKigLKhsJFR//+BXBaWhp+v5/ExMQK7VKr1dhsNiIiIrBYLAAUFxdXGsZWVFREWFgYAO3btwfKpgc/M6irjalTp/Lf//63xjL79u2jZcuWVV6bUqms8p6cHXRWRZZl3njjDSZOnIhGo6lTuwHatGnDd999h9PpxG63Ex8fz/jx42nVqlWFcoWFhRgMBhH81MFFFQDVp2v2qaee4h//+EcjtqoIlVKLVm3A73UT8LkwKfcSZjhEsukDSj3tcLj74fIOAEUMSoUShUKBpJBQKpUoJAUKhQKFUnFRBRCyLOPwOchyZpFRkoFGoSFSXxYMRWgjUCqUzd1EQRAEQag3o9FI27Zta13+qquuokuXLjz55JO88MIL3Hrrrbz44ossXryYhx56qFL5oqKiGnNXztSpUyfeeustnE5nqBfoxx9/RKFQhIKDM7Vt2xa1Ws3PP/8cerC32WwcPHiQq666qtrzDBgwoNJU3l9++SW9e/euNohr06YNFouFffv2hdri9/tZvnw5zz33XKUvrseOHcuKFSu4//77adeuHQqFgq1bt1bIj8nKyiIzMzPUYzV8+HCioqJYuHAhq1evrtSGmu7l+QyB02g09OrVi/Xr1/OnP/0ptH39+vWMGTOmxjqhLG/98OHDTJky5Zxla2I0GjEajdhsNr744gsWLlxYYf+ePXvo2bPneZ3jcnNRBUBQ967Z2bNnM3369NB7u91OUlJSA7YoAqVyNWbjUVzKtbhKP4bgUYIeD2pVgDDNASy6I8A7uN2pOJ0Dcdr7EQhGEZTKxmqWv1QqFSqVCqVSiVqtRqFQlAVJp/ef+e8LJViSZRm7106+K598Vz5ZziwUkgKrzhrqHdIo6/6thyAIgiBcbGbMmMG4ceN45JFH6NevH4888ggzZswgMzOTP/3pTyQkJHD48GFeeeUVBg8eXGVgVJUJEyYwb948Jk2axOOPP05eXh4PPPAAEydOrLInwmQyMWXKFGbNmkVkZCSxsbHMnTv3nPkhU6dO5eWXX2b69Oncdddd/PTTT6SlpfHuu+9We4xCoWDYsGFs3LgxNMxr7dq12Gw2pkyZEurFKXfzzTeTlpbG/fffj9ls5p577mHGjBmoVCq6devGqVOnmDt3Lh07dgwFT0ajkddff51x48YxevRoHnzwQdq2bUt+fj7vvfceGRkZrFy5ssr2ne8QuOnTpzNx4kR69+7NgAEDWLp0KRkZGUydOjVUZvbs2WRmZrJ8+fIKx6alpdGvXz+6dOlSqV6v18u+fftC/87MzGTnzp2YTKZQ4P3FF18gyzKpqakcPnyYWbNmkZqayh133FGhrh9++KFSoCnU7KIKgOrTNavVatFqtY3cMglog173EDrtAxQW7yK/cCVm7ddYjDmoVUoUKg0GwyEMhsNERy/H7++IyzUIl2sQfr81NHazPJHy7O7uMwOl8mBIrVaHgqazg6Qzg6VGvXJJIkwbRpg2jDbhbSj1lVLgKiDfnc8B2wGwgUVjIUofRaQ+EqPaeO5KBUEQBOEidMMNN5CSksKTTz7J4sWLefrpp+nVqxf/+c9/eOWVVwgGg7Rp04abb76ZSZMm1bpeg8HAF198wUMPPUSfPn0wGAyMHTuW559/vtpjnnnmGRwOB6NHj8ZsNjNjxgyKi4trPE+rVq347LPPePjhh/nPf/5DQkICL7744jnzrO+++26mTJnCwoULUSgUoVnPzg5+oKwHaMGCBWzfvp2ePXvy73//m/j4eObMmUN6ejoxMTEMHTqUlStXolL9/pg6ZswYNm3axFNPPcWtt94a+kL76quv5oknnjjHHay/8ePHU1BQwPz588nKyqJLly589tlnlXqszp5Jrri4mA8//JAXXnihynpPnTpFjx49Qu+fffZZnn32Wa666iq+/fbbUB2zZ8/m5MmTWK1Wxo4dy5NPPlmhNy4zM5NNmzadc5ifUJEkn09mWQOSJInVq1fXmCT2t7/9jU8//TQUMQP89a9/ZefOnfz000+1Oo/dbicsLIzi4uLQ2NPGEAwGOZFTyOETG7GqPyM5djsmcyGSUo2s1ID0e2Di93fE47kSj2cwwWDlCRRkWQ4FRcFgsNKrvEz5SsNn9hIplcpQkFRTr5JSqWzwXiVfwEeBu4B8Vz6F7kKCcjCUNxSljyJMG3bB9GQJgiAI51bXv6Fut5tjx47RqlWrSknywqVDlmX69+/PtGnT+POf/9zczbmszJo1i+LiYpYuXdrcTbkg1PYzp1l7gBwOB4cPHw69P3bsGDt37sRqtdKyZctKXYr16ZptLgqFguT4KBKirufQyb5sOHAKs/8XOidsJjpmH0pjISg1yJIKlWo/KtV+jMal+P0dzgiGyrpsywOZ2jg7SPL7/Xi93lAAdWa5s3uVFApFqFepPFiqrlepNoGLWqkmzhhHnDGOQDCAzWOjwFVAbmkuJx0nUSlUoWAoQheBSnFRdUgKgiAIgkDZc8rSpUvZtWtXczflshMTE3POHCehsmbtAfr2228ZOnRope2TJk3izTffZPLkyaSnp4e6AqEsoezhhx9m7969JCQk8Le//a3COMxzaaoeoLOVlrrYl5HLbyfzMHjz6RJxiPjoHWisB1AYbMgKFWevJVRVMNSQqupNKg+Uyl/lgc7ZvUpKpRK9Xo9er0en09U6QIOy4KvEV0K+K58CVwFOnxOFpCBMG0aUPooofRRaZWMPWxQEQRDqSvQACYJwIavtZ84FMwSuqTRXAARlD/5FJQ52H8vhWG4xFtlBR2MxsbrDqK0HUUUeQqHLo6pFVf3+1DOCoXNPvdjQ7a5q+J3P50OSJDQaDUajMTQF45ljdmvD5XeFgqFiTzEyMia1KRQMmTSmRroyQRAEoS5EACQIwoXsohgCd7mRJIkIi5nBVxhpX1jEzqPZ/FRkJNIfR6fgFUTk5KHQ5qOMOYE6fD9K9YnQsSrVAVSqAxiNr+P3tz8jGIprknaX5xadLRgM4vV6sdlsFBYWhoIho9FY62BIr9KTZE4iyZyEL+ij0FVIvjufEyUnSLeno1VqidSXDZUL14ajkMQqx4IgCIIgCEL9iACoGSgUCuKirAwLt3Aip4Bfj+Xwg01BvCWODlIR5sx4fBndweJHGZOBxrgNlepY6HiV6iAq1UGMxjT8/nang6ErmyQYqupadDodOp0OWZbxer0UFRVhs9lCwZDJZEKn09UqGFIr1MQaY4k1xhKUgxR5ispmlXPlc8pxCqWkxKq3EqWLwqq3olZc2AvpCYIgCIIgCBcWMQTuAuB2uzmSmceejHzcfpmWkUba6IoxlJ5C8jmRNSaCESrUEfvRan9EpTpaZT3NHQydqTwY8ng8AKjVakwmE0ajsdbB0NkcXkdovSGHz4FE2RTc5b1DepVYAVkQBKExiSFwgiBcyEQOUDUuxAAIygIGh9PJbxm5HDhlA4WS1tFmWupK0TpOoHDbQKnBb24B4TIa3c9otT9cVMGQ1+tFluVKw+TqMoFCOU/AE+oZKvIUEZSDGNVGIvWRROoisWgsYoptQRCEBiYCIEEQLmQiAKrGhRoAlQsGg9iK7ew5lk16gROdVkObaBPxOh9qx0mUzmxAImCKJ2BugUJnQ6P54RzBUNszgqH4pr2gs1QVDJlMptAECvUJhvxBPza3rWwiBXcB/qAfjUJTFgzpI4nQRqBU1L1eQRAEoSIRAAmCcCETAVA1LvQAqJzf7ye3wMbu47mcKnIRbjLQJtpIlE5GWZKJqiQTgj6C+ij8liRkXTgKRSZa7cbTwdCRaupti8cz+HQwlNDEV1VR+QQKPp+PYDCIVqs972BIlmWKPcWhBVhdfhcKSYFVZyVKH4VVZ0Wj1DTC1QiCIFz6RAAkCMKFTARA1bhYAqByHo+Hk9n57M7Ip9gdIDrcSOtIPRaNhLI0B6X9BJKvFFljxm9JImiIBklxRjC0EZXqcJV1+/1tzphNLrGJr6yiM4OhM3uGynOG6hMMAZT6SkM9Q8WeYoCyvKHTC7Aa1IaGvAxBEIRLmgiAmsZvv/3G5MmT2blzJx06dGDnzp3nPGby5MkUFRWxZs2aassMGTKE7t27s2jRogZra7lHH32UnJwcli5d2uB1C9Xr06cPs2fP5qabbmruplwQavuZI+YTvsBptVpat0zg2p5t6ZlipcThZOuxQvblunFoY/HG98UX0xVZoUKdvw9N5s8o7RkE/TG4XOMpKnqJwsI0nM478PvbVqhbpTqC0fgmVutfCA+/D71+JUplZrNcZ/lscmazGZOpbN2fwsJCTpw4wfHjx8nNzcXpdBIIBOpUr0FtoKWlJT1iejAwYSCpEamoFWrS7elsyd7C5qzNHCk6Urb+0OX1XYAgCIJQjcmTJ4eWgFCr1bRu3ZqZM2fidDoBSE9PD+2XJImwsDD69+/Pp59+WqmuDz/8kCFDhhAWFobJZKJr167Mnz+fwsLCas8/b948jEYjBw4cYMOGDY12nWfLysri1ltvJTU1FYVCwbRp02p1XE5ODi+88AJz5syptG/Tpk0olUquu+66Svu+/fZbJEmiqKio0r7u3bvz+OOPV9i2Y8cOxo0bR2xsLDqdjvbt23PXXXdx8ODBWrWzvhYvXhx6oO7Vqxc//PBDjeXP/P9z5qtz584VyhUVFXHfffcRHx+PTqejY8eOfPbZZ6H9S5YsoWvXrlgsFiwWCwMGDGDdunUV6nj00Uf5+9//TjAYbLgLvgyIAOgiIEkSRqORzm1aMqJHa9rHGMix2dl8zMbRQjceTQS+2O544/sQ1EWgKjqK9uRPqAoPIfldBIMJuFy3nA6G3sDpvBO/v12Fc6hURzEa3yIi4sIJhiwWS6VgKCMjg/z8/HoFQxqlhnhTPF2iujAoYRBdoroQrg0nx5nDjtwdbDq1if0F+8krzcMf9DfGpQmCIAgXieuuu46srCyOHj3KE088weLFi5k5c2aFMl999RVZWVls3ryZvn37MnbsWPbs2RPaP3fuXMaPH0+fPn1Yt24de/bs4bnnnuPXX3/l7bffrvbcR44cYfDgwSQnJxMZGdlo13g2j8dDdHQ0c+fOpVu3brU+Li0tjQEDBpCSklJp3xtvvMEDDzzAxo0bycjIqHfb1q5dS//+/fF4PKxYsYL9+/fz9ttvExYWxqOPPlrves9l1apVTJs2jblz57Jjxw6uvPJKRo4cWeO1vPDCC2RlZYVeJ06cwGq1Mm7cuFAZr9fLtddeS3p6Oh988AEHDhzgtddeIzHx9xE5LVq04F//+he//PILv/zyC1dffTVjxoxh7969oTLXX389xcXFfPHFF41zAy5RYgjcRcjv91NoK2L/iTyOF5Si1+tIthpICNOgkCTwe1A5MlGWZELQT9AQXZYnpA2rUI9CkXVGztChas7VGo/nSrzeKwkELoxhcl6vFyjrHTObzej1evR6fZULtdaGLMvYvXYK3AUUuApw+pwoJAXh2nCi9FFE6iPRKrUNeSmCIAgXpctlCFxVw8nuuusu1q5dS1ZWFunp6bRq1YodO3bQvXt3AEpKSrBYLLz44os88MADbNmyhX79+rFo0SIeeuihSucoKioiPDy80vazZzCdN28ejz/+OLt37+ahhx7ip59+wmAwMHbsWJ5//vnQF4Vnt9npdPLXv/6Vjz76CLPZzMyZM/n0009rPQSuLsPlunbtyj333MN9991XYbvT6SQ+Pp6tW7cyb948OnXqxGOPPRba/+233zJ06FBsNlule9G9e3duvPFGHn/8cUpLS0lOTmbw4MGsXr260vmru5cNoV+/fvTs2ZMlS5aEtnXs2JEbb7yRp556qlZ1rFmzhptuuoljx46RnJwMwCuvvMIzzzzDb7/9hlpd+zUNrVYrzzzzDFOmTAltu+OOOwgEAixfvrzW9VyqxBC4S5hKpSImOor+nVszpGM8ZmWA/adsbM2wk1viRVZq8Ie3xpM4EL+1PZLXgSZ7O5rsbSicuXA65g0G43G5xlFU9CKFhctq0TN0LwbDuyiVJ5vjsiv1DMmyTH5+fmiYXH5+PqWlpXXuBpaksvWEWoe1pk9cH/rG9aVVWCuCcpBDtkP8dOontuVsI704HYfX0UhXJwiCcBkJBsBd3LSvYN1GDZxNr9fj8/mq3Ofz+XjttdcAQg+zK1aswGQyce+991Z5THUP7FlZWXTu3JkZM2aQlZXFzJkzKS0t5brrriMiIoKtW7fy/vvv89VXX3H//fdX295Zs2bxzTffsHr1ar788ku+/fZbtm3bVocrrh2bzcaePXvo3bt3pX2rVq0iNTWV1NRUbrvtNpYtW1av4eZffPEF+fn5PPLII1Xuryn4mTp1KiaTqcZXdb05Xq+Xbdu2MXz48Arbhw8fzqZNm2rd/rS0NIYNGxYKfgA++eQTBgwYwH333UdsbCxdunRhwYIF1Y5uCQQCrFy5EqfTyYABAyrs69u37zmH5QkV1X01SuGCodVqSUqMJzIijFO5+ew9Wcjukx6sZj2tIvWE61UEzIkETAkoXAUoS06gzt+LrNQSsCQRMMWDouy/QDAYh8s1DpdrHApF9hk9Q7+Pq1WpjqFSHcNgWI7f3wq3ewQez7XIctNPJFAeDOl0ulDPUH5+PpIkodFoMJvNGAwGdDpdnXuGDGoDBrWBJHMSvqCPQlch+e58TpScIN2ejlapDfUMhWvDUUjiewRBEIQ68TrgeO0fIBtE8kDQhZ27XBW2bNnCO++8wzXXXFNh+8CBA1EoFLhcLoLBICkpKdxyyy0AHDp0iNatW9fp232AuLg4VCoVJpOJuLiydfxee+01XC4Xy5cvx2g0AvDyyy8zatQonn76aWJjYyvU4XA4SEtLY/ny5Vx77bUAvPXWW7Ro0aJe11+T48ePI8syCQmVZ5ZNS0vjtttuA8qGFDocDjZs2MCwYcPqdI5Dh8pGqXTo0KHO7Zs/f36loYtnq6rtAPn5+QQCgUr3NzY2luzs7FqdPysri3Xr1vHOO+9U2H706FG+/vprJkyYwGeffcahQ4e477778Pv9FXrJdu/ezYABA3C73ZhMJlavXk2nTp0q1JWYmEhGRgbBYLDeo2EuNyIAusiV5we1SdYTYw0n/VQeB3NK2OH0EBOmJ8Wqw6hREjREETREIXlLUNpPoLIdRlV0jIApHr8lCVS/dxOWBUM343LdfDoY+vF0MHQgVEalOobJ9ApG45t4PNfgco0iEEiuqomN7uxgyOPxkJeXh0KhOO9gSK1QE2uMJdYYS1AOUuQpIt+VT74rn0xHJiqFCqvOSqQuEqveilpRtz90giAIlyWNqSwgaepz1sHatWsxmUz4/X58Ph9jxozhpZdeqlBm1apVdOjQgYMHDzJt2jReeeUVrFYrUDa8uqEW5N6/fz/dunULBT8AgwYNIhgMcuDAgUoP6EeOHMHr9VboKbBaraSmpjZIe87kcrkAKg03OnDgAFu2bOGjjz4CykavjB8/njfeeKPOAdD5ZGvExMQQExNT7+Oh8rDEuvxs33zzTcLDw7nxxhsrbA8Gg8TExLB06VKUSiW9evXi1KlTPPPMMxUCoNTUVHbu3ElRUREffvghkyZN4rvvvqsQBOn1+tDzj16vr/+FXkZEAHSJUCgUhIWF0dlopEVMMYcz8ziSX0KBw0N8mI6WETq0KkXZdNlRnfCHt0FVchKl4xTKkpMEDTGn84QqjukuC4bG4nKNRaHIPaNn6DcAJMmNTvc/dLr/4fN1xeW6Ea+3H801ulKhUIRygs4Ohs7MGapPMFS+npBVZ4UIcHgdoWAotzQXibKhdOW9Q3qV+BASBEGokkJZ796YpjJ06FCWLFmCWq0mISGhyp6cpKQk2rVrR7t27TCZTIwdO5Z9+/YRExND+/bt2bhxIz6fr869QGer6YG7qu1Nmd4dFRUFlA2Fi46ODm1PS0vD7/dXSOqXZRm1Wo3NZiMiIiKUR1ZcXFxpGFtRURFhYWX/R9q3bw+UTQ9+9vCvc5k6dSr//e9/ayyzb98+WrZsWeW1KZXKSr09ubm5lYLOqsiyzBtvvMHEiRPRaCquQRgfH49ara6wzEfHjh3Jzs7G6/WGyms0Gtq2LZvFt3fv3mzdupUXXniBV199NXRcYWFhaA1FoXZEP9klRqVSERkZSffUVgzpGE+cAU7k2/klw85xmxt/8PSHokqLP6INnsQBp/OEStBkb0OTvR1F6e95QmcKBmNwuW6iqOjf2GxLcLuvR5Z//8ZHrd6FxTKfiIgp6PWrkaTSprrsKpUHQ2FhYRiNRgKBAHl5eaHZ5AoKCuqVM1TOpDGREpZC77je9I/vT9uItkiSxNHio2zO2szW7K0cLT6K3WsXU2wLgiBcZIxGI23btiU5OblWAcxVV11Fly5dePLJJwG49dZbcTgcLF68uMryVU39XJ1OnTqxc+fO0DTcAD/++CMKhSIUHJypbdu2qNVqfv7559A2m83WKNNFt2nTBovFwr59+0Lb/H4/y5cv57nnnmPnzp2h16+//kpycjIrVqwAoF27digUCrZu3VqhzqysLDIzM0M9VsOHDycqKoqFCxdW2Yaa7uX8+fMrtKGqV3VD4DQaDb169WL9+vUVtq9fv56BA8/dg/ndd99x+PDhChMWlBs0aBCHDx+u8Axy8OBB4uPjKwVLZ5JlGY/HU2Hbnj176Nmz5znbI/xO9ABdorRaLfFxcYRZLKTkF/LbqUKO5HjJsmtJjtATZ1aXfWukODNPKB+V/QTqvL3IKh0BcxIBU1woT+hMgUAKDsf9OJ13oNV+hV7/aWjabKUyG6NxKQbD27jd1+J2j272GeSq6xmSJOm8e4YAdCodiaZEEk2J+IN+bG4b+a58TjlOkWHPQKPUEKmLJFIfiVVnFXlDgiAIl6AZM2Ywbtw4HnnkEfr168cjjzzCjBkzyMzM5E9/+hMJCQkcPnyYV155hcGDB1c5O1xVJkyYwLx585g0aRKPP/44eXl5PPDAA0ycOLHKngiTycSUKVOYNWsWkZGRxMbGMnfu3Fr9fStfdNXhcJCXl8fOnTvRaDSV8k7KKRQKhg0bxsaNG0PDvNauXYvNZmPKlCmhXpxyN998M2lpadx///2YzWbuueceZsyYgUqlolu3bpw6dYq5c+fSsWPH0OQDRqOR119/nXHjxjF69GgefPBB2rZtS35+Pu+99x4ZGRmsXLmyyvad7xC46dOnM3HiRHr37s2AAQNYunQpGRkZTJ06NVRm9uzZZGZmVpqFLS0tjX79+tGlS5dK9f71r3/lpZde4qGHHuKBBx7g0KFDLFiwgAcffDBUZs6cOYwcOZKkpCRKSkpYuXIl3377LZ9//nmFun744YdKEzUINRMB0CWsPD9Ir9cTEW4hKzefQzkl/Jbl41SxllaROqwGdXlhgoZovIZoJI8dVckJVLZDqIpP5wmZk0BVeSpoWTbido/B7R6FRrMNvX4NavX201W60Os/Qa//FK+3Ny7Xjfh8PYCGGRNdX7UJhgwGA1qttl7BkEqhItoQTbQhGlmWKfYUk+/Kp8BdQJYzKzSULkofRaQuErVS5A0JgiBcCm644QZSUlJ48sknWbx4MU8//TS9evXiP//5D6+88grBYJA2bdpw8803M2nSpFrXazAY+OKLL3jooYfo06dPhWmwq/PMM8/gcDgYPXo0ZrOZGTNmUFxcfM5z9ejRI/Tvbdu28c4775CcnEx6enq1x9x9991MmTKFhQsXolAoQrOenR38AIwdO5YFCxawfft2evbsyb///W/i4+OZM2cO6enpxMTEMHToUFauXIlK9ftj6pgxY9i0aRNPPfUUt956K3a7naSkJK6++mqeeOKJc15XfY0fP56CggLmz59PVlYWXbp04bPPPqswo1tWVlalmeSKi4v58MMPeeGFF6qsNykpiS+//JKHH36Yrl27kpiYyEMPPcTf/va3UJmcnBwmTpxIVlYWYWFhdO3alc8//zw0sQVAZmYmmzZtOucwP6EisQ7QZcTv91NcXMzJ3AKO5DrxSGqsRg2trHpMWmUVB7hP5wllla0nZIzBb66cJ3Q2pfI4ev3H6HQbAG+FfYFAS1yuMbjdVwMX1poQgUAgtM7QmTlD5xMMnc3pc1LgKiDflY/da0dCwqK1EKUryxsyqJt+Rj1BEITaulzWARLqRpZl+vfvz7Rp0/jzn//c3M25rMyaNYvi4mKWLl3a3E25INT2M0f0AF1GyvODTCYTsRE20rMLyChysr3UR6xZS3KEDp36jId8lQ5/RFv8YSkoHdkoS06gcW4jqA0nYGlBUB8FVSRfBgLJOBwP4nTegU73OXr9JygU+QAolRmYTC9hNC7D7b4Ol2sUweD5zc7SUJRKZahnKBAI4PF4yM3NDc0yZzKZQrPJ1XdmH6PaiFFtpKWlJd6AlwJXAQXuAo7Zj3Gk+Ah6lZ4ofRRR+igsGkuDzSAkCIIgCI1FkiSWLl3Krl27mrspl52YmJhzTvMtVCZ6gC5TsixTWlpKYWEhR7OLyHIGUarUJIRpSQrXoVJW8eAtyyhceajsJ5E8xcgqfdl6Qsa4shl9qhVAo9mEXv8xavXes/Yp8HgG4XKNwe/vRHMPj6tKeTDk8/lCwdCZOUMNEaQEggFsHltZQOQqwBv0olaoidRHEqWPIlwbjqqKXCxBEISmJHqABEG4kIkeIKFGZ+YHWSwWEvMLOJpXQkahn5wSH0kRWuItGhRnPtxLEkFDDF5DDJKnGJX9JKrCg6iKjhIwJ+I3JVaZJwRKvN4r8XqvRKU6hF6/Bq32OyAABNFqf0Cr/QG/vy0u1414PFcC1c+A0tSUSiUGQ9nQtPJgKCcnp0GDIaVCGer5kWUZu9ce6h3KdmajkBSEa8NDU2xrlVXdZ0EQBEEQBOFcRA+QAPyeH5SbX8ixglLsfiUGrZrkCB3RpuqT9CW/C6X9dJ4QQQKGGAKWlsjnWHBOkgrR6z9Dp/sfCkVRhX3BYDhu9w24XH9EliMa4OoaR1P0DAGU+kopcJf1DBV7ipGRMWvMoUkUTHVc3E8QBKG+RA+QIAgXstp+5ogASKjA4/Fgs9nIyreRUeTFJasI06tpZdVh0dXQYRj0o3RkobSfQAp4COrCCZiTCOojq8wT+p0XrfY79PqPUamOnLVPhcczhNLSMQQCbRvi8hrNmcGQUqmsNIFCQwVDvoAvFAwVugsJyAF0Kh2RurKhcmHaMDHFtiAIjUYEQIIgXMhEAFQNEQCdW3l+kM1m42ReEaccQXySikijmpQIHQZNDfk+soyiNA+VPQPJW1KHPCEZlWovBsMaNJqfgIqLk/p8V+ByjcbrHciFvn5vVcGQxWJBr9c3aDAUlIMUeYrId+WT78rHG/CiUqiw6qxE6iKx6q2oFWKKbUEQGo4IgARBuJCJHCCh3s7MDzKbzcQUFJBZ6CTHEWBHqZ84s4akcC0aVRWBiCQRNMbgNcYguYtQlZTnCR0jYE7Ab24ByqryeyT8/i7Y7V1QKHLQ69ei061DkspWvVard6NW7yYYjMHlGoXbPQJZNjfujainM3OG/H4/Xq+X7OzsBg+GytcTsuqstI9oT4m3pGy9IVcBuaW5SEiE68JDC7DqVfqGukRBEARBEISLlugBEs6pPD+o0GbjRKGLAq8ChUJBi3AtCRYtSkXND/FleUInTucJyQQMsQQsSefMEwIXOt3X6PVrUCpPVtgjy1o8nmG4XGMIBJLO7wKbSHkwVN4zpNfrMZlMDd4zBOD2uylwl603VOwpJigHMaqNoUkUzGqzmGJbEIQ6Ez1AgiBcyMQQuGqIAKj+yvOD8guLyLR7Kfar0KgUJEfoiDGpz/1AHfShdGShsp+AgJegLoKAJYmgznqOPKEgavV29PqP0Wh+qbTX6+2FyzUGn68XF/rwuHJVBUNmsxmdTtfgwZA/6KfQXUi+K59CdyH+oB+NUhPKG4rQRYi8IUEQakUEQIIgXMjEEDihwWm1WmJjYzGbzYTbbOTb7GQ6fBzIDXCqWEWKVUeEoYacE4WagKUlAXOLUJ6QOncXstpQlidkiK0mT0iBz9cbn683SuVJ9PpP0GrXI0luADSabWg02wgEWuByjcbjGYYsX9jDvVQqFSpV2a+f3+/H4/HgcDgaJRhSKVTEGGKIMcQQlIPYPfayvCF3PlnOLBSSIjRMLlIXiVop8oYEQRCa02+//cbkyZPZuXMnHTp0YOfOnec8ZvLkyRQVFbFmzZpqywwZMoTu3buzaNGiBmtruUcffZScnByWLl3a4HUL1evTpw+zZ8/mpptuau6mXFTE175CnZTnByUkJNA6uQVdEiy0Nsv4vB72ZDvZk+XE6QmcoxIFQWMs3vg+eGN7IKsMqAoOoM38CWXRMQh4qz00EGiBw3EvhYVv43T+hWAwNrRPqTyJybQYq3UiRuPrKBQ5DXXZjUqlUmEwGAgLC0On0+F2u8nKyiIjI4OTJ09SVFSE2+2mITprFZKCcF04bSPa0j++P33i+pBsScYT8PBb4W9sOrWJHbk7OGE/QamvtAGuThAE4eIzefJkJElCkiTUajWtW7dm5syZOJ1leanp6emh/ZIkERYWRv/+/fn0008r1fXhhx8yZMgQwsLCMJlMdO3alfnz51NYWFjt+efNm4fRaOTAgQNs2LCh0a7zbB999BHXXnst0dHRWCwWBgwYwBdffHHO43JycnjhhReYM2dOpX2bNm1CqVRy3XXXVdr37bffIkkSRUVFlfZ1796dxx9/vMK2HTt2MG7cOGJjY9HpdLRv35677rqLgwcP1voa62Px4sWhHoVevXrxww8/nPOYFStW0K1bNwwGA/Hx8dxxxx0UFBRUKPPhhx/SqVMntFotnTp1YvXq1RX2P/XUU/Tp06csHzsmhhtvvJEDBw5UKPPoo4/y97//nWCw4uRRQs1EACTUi0KhwGKx0KJFC1JbJdEt0UwLQwB7qZvtmSUczCvF4z/3L6OsC8cXcwXehH4EjDGo7BloMzehKvgNyeus/jjZhMs1lsLCN7Db/w+f74rQPklyotd/iNV6JxbLE6jVu4GLY6SnSqXCaDQ2STAEYFQbSbYk0zO2JwMTBtI+oj0qScUx+zG2ZG9hS9YWjhYdLVt/6PIaLSsIwmXuuuuuIysri6NHj/LEE0+wePFiZs6cWaHMV199RVZWFps3b6Zv376MHTuWPXv2hPbPnTuX8ePH06dPH9atW8eePXt47rnn+PXXX3n77berPfeRI0cYPHgwycnJREZGNto1nu3777/n2muv5bPPPmPbtm0MHTqUUaNGsWPHjhqPS0tLY8CAAaSkpFTa98Ybb/DAAw+wceNGMjIy6t22tWvX0r9/fzweDytWrGD//v28/fbbhIWF8eijj9a73nNZtWoV06ZNY+7cuezYsYMrr7ySkSNH1ngtGzdu5Pbbb2fKlCns3buX999/n61bt/KXv/wlVOann35i/PjxTJw4kV9//ZWJEydyyy23sHnz5lCZ7777jvvuu4+ff/6Z9evX4/f7GT58eCgQB7j++uspLi6uVaAq/E7kAAkNwu/3Y7fbKSgsJNNWSo5LQqlSkWDR0iJci+ocEyWEBH0oS06hKjlZliekt55eT8h6zkOVyiPo9Z+g030D+M5qX5vTw+OGAFXNQndhKx8m5/f7UalUFRZd1Wg0DT6hQSAYwOaxUeAqm0jBF/ShVqiJ1J/OG9JGoKxxWnNBEC5Fl0sOUFXDye666y7Wrl1LVlYW6enptGrVih07dtC9e3cASkpKsFgsvPjiizzwwANs2bKFfv36sWjRIh566KFK5ygqKiI8PLzS9rM/z+fNm8fjjz/O7t27eeihh/jpp58wGAyMHTuW559/HpPJVGWbnU4nf/3rX/noo48wm83MnDmTTz/9tM5D4Dp37sz48eN57LHHqi3TtWtX7rnnHu67774K251OJ/Hx8WzdupV58+bRqVOnCvV8++23DB06FJvNVuledO/enRtvvJHHH3+c0tJSkpOTGTx4cKVeEqj+XjaEfv360bNnT5YsWRLa1rFjR2688UaeeuqpKo959tlnWbJkCUeO/L6+4UsvvcTChQs5ceIEAOPHj8dut7Nu3bpQmeuuu46IiAjefffdKuvNy8sjJiaG7777jj/84Q+h7XfccQeBQIDly5ef17VeCmr7mSN6gIQGoVKpsFqtpCQn06VVAj3i9VgUXo4XOPnlRAlZdg/B2sTaCjWBsGQ8iQPwRXZE8ntQ5/6K5tQWFI4skKvvVQoE2uBwPExBwVuUlk4kGIw4o31HMJv/jdU6CYNhOQpF9UMPLkRn9gxptdoqe4Y8Hk+D9dIoFUqi9FGkWlMZmDCQHjE9iDfGY/fY2ZO/hx9P/cjuvN1kObLwBDwNck5BEC4fgWCAEm9Jk74CwXMMzz4HvV6Pz+ercp/P5+O1114DQK0uy6NcsWIFJpOJe++9t8pjqntgz8rKonPnzsyYMYOsrCxmzpxJaWlp6OF469atvP/++3z11Vfcf//91bZ31qxZfPPNN6xevZovv/ySb7/9lm3bttXhiiEYDFJSUoLVWv2XkDabjT179tC7d+9K+1atWkVqaiqpqancdtttLFu2rF5/p7744gvy8/N55JFHqtxfU/AzdepUTCZTja/qenO8Xi/btm1j+PDhFbYPHz6cTZs2VXvOgQMHcvLkST777DNkWSYnJ4cPPviA66+/PlTmp59+qlTviBEjaqy3uLgYoNLPo2/fvrUalif8TkyCIDQotVpNVFRU2UQJYcXkFdhIL3RzMNdPZrGXVlYdkcZaJNlLCoKmOLymOCS3DZX9BOqC36DoKH5TAgFzYjXrCYEsR1BaeiulpePQan9Ar1+DSnUIAIWiCIPhXQyG9/B4rsLlGoPf374hb0GjO3sCBbfbjcPhaLSeIUmSCNOGEaYNo3V4a0p9pRS4CihwF3DQdhDZJpNiSSElLOW8zyUIwuWh1F/Ktpy6PYyfr16xvTBr6rd+3JYtW3jnnXe45pprKmwfOHAgCoUCl8tFMBgkJSWFW265BYBDhw7RunXrUEBUW3FxcahUKkwmE3FxcQC89tpruFwuli9fjtFoBODll19m1KhRPP3008TGxlaow+FwkJaWxvLly7n22msBeOutt2jRokWd2vLcc8/hdDpD11SV48ePI8syCQkJlfalpaVx2223AWW9Gw6Hgw0bNjBs2LA6tePQobK/4R06dKjTcQDz58+vNHTxbFW1HSA/P59AIFDp/sbGxpKdnV1tfQMHDmTFihWMHz8et9uN3+9n9OjRvPTSS6Ey2dnZdapXlmWmT5/O4MGD6dKlS4V9iYmJZGRkEAwGUShE30ZtiABIaBRarZaYmBjMZjOREcWcyrORUeRmb5afcIOaFKsOi652//1kXQQ+XQSSz4nSfhKVPQOV/TgBYzwBSwtktbGaI9V4PFfj8QxFpdqPXv8xWu1GIAgE0Gq/Rqv9Gr+/Iy7XjXg8g4CLa1hXTcHQmesMNeQwOYPagEFtIMmShC/g44TjBOn2dNRKNYmmxAY5hyAIlzaDykCv2F5Nfs66WLt2LSaTCb/fj8/nY8yYMRUeYKGsh6NDhw4cPHiQadOm8corr4S+nZdlucE+d/fv30+3bt1CwQ/AoEGDCAaDHDhwoNKD9JEjR/B6vQwYMCC0zWq1kpqaWutzvvvuuzz++ON8/PHHxMTEVFvO5XIBVBpudODAAbZs2cJHH30ElP29Gj9+PG+88UadA6DzGd0QExNTY/tr4+yf47l+tvv27ePBBx/kscceY8SIEWRlZTFr1iymTp1KWlpaveq9//772bVrFxs3bqy0T6/XEwwG8Xg86PUX9iy4FwoRAAmNSq/Xo9PpsFgsxBUVcSKviBNFpex0+Ygxa0mO0KJX1y7okNVG/JGp+MNboXScQlWSidJxiqA+8vR6QhHVHCnh93eipKQTTmc+Ot1a9Pr/IUkOAFSq/ZjN+zEao3C5bsDtHoksX3z5YWcHQy6Xi5KSkkYNhtRKNa3DWhMMBjlkO4RGoSHaEN0gdQuCcOlSKpT17o1pKkOHDmXJkiWo1WoSEhKq7MlJSkqiXbt2tGvXDpPJxNixY9m3bx8xMTG0b9+ejRs34vP56twLdLaaHoyr2n6+w6FXrVrFlClTeP/9988ZrERFRQFlQ+Gio3///E9LS8Pv95OY+PsXY7Iso1arsdlsREREhPLIiouLKw1jKyoqIiwsDID27ctGavz2228VgrramDp1Kv/9739rLLNv3z5atmxZ5bUplcpKvTK5ubmVgs4zPfXUUwwaNIhZs2YBZTlSRqORK6+8kieeeIL4+Hji4uJqXe8DDzzAJ598wvfff19lL15hYSEGg0EEP3Ug+smERidJUmgayM5tWtKvdSSJBpncIgfbTpRwtMCFL1CH6RuVGgJhKafzhDog+d2oc3aezhPKrjFPKBiMorR0MgUFb+NwPEgg8PsHnkKRj9H4JpGREzGZXkCpPH4+l92szs4ZcrlcoZyhzMxMiouLGzRnqE14G2IMMewv3E+Ru6hB6hQEQWhORqORtm3bkpycXKsA5qqrrqJLly48+eSTANx66604HA4WL15cZfmqpn6uTqdOndi5c2eF2b9+/PFHFApFKDg4U9u2bVGr1fz888+hbTabrVbTRb/77rtMnjyZd955p0LOSnXatGmDxWJh3759oW1+v5/ly5fz3HPPsXPnztDr119/JTk5mRUrVgDQrl07FAoFW7durVBnVlYWmZmZoR6r4cOHExUVxcKFC6tsQ033cv78+RXaUNWruiFwGo2GXr16sX79+grb169fz8CBA6s9Z2lpaaWhaEpl2Ze95X93BwwYUKneL7/8skK9sixz//3389FHH/H111/TqlWrKs+3Z88eevbsWW17hMpED5DQZCRJwmQyYTAYCA8PJzG/gKO5djLyveSUeEkK15EQpkFR294JSUHQFI/XFI/CVYiy5ATqgv1QdAS/OZGAKaHaPCHQ4XaPxO2+DrV6J3r9x2g0WyibLtuLTvc5Ot3n+HzdcbluxOvtw8X6fcHZPUOlpaUVeobKF109n54hSZLoYO3Arrxd7M7fTY+YHpg0poa8DEEQhAvejBkzGDduHI888gj9+vXjkUceYcaMGWRmZvKnP/2JhIQEDh8+zCuvvMLgwYOrnB2uKhMmTGDevHlMmjSJxx9/nLy8PB544AEmTpxYZY+ByWRiypQpzJo1i8jISGJjY5k7d+4580Peffddbr/9dl544QX69+8f6qHQ6/Wh3pizKRQKhg0bxsaNG7nxxhuBsuGDNpuNKVOmVDru5ptvJi0tjfvvvx+z2cw999zDjBkzUKlUdOvWjVOnTjF37lw6duwYmiTAaDTy+uuvM27cOEaPHs2DDz5I27Ztyc/P57333iMjI4OVK1dW2b7zHQI3ffp0Jk6cSO/evRkwYABLly4lIyODqVOnhsrMnj2bzMzM0Cxso0aN4q677mLJkiWhIXDTpk2jb9++oWDroYce4g9/+ANPP/00Y8aM4eOPP+arr76qMMTtvvvu45133uHjjz/GbDaHfh5hYWEVent++OGHShMqCDW7OJ/ohIuaQqHAbDaT3DKJPh2S6ZVkRo+Xg9l2fskoIc/hrXPPRFBvxRfTDW98XwL6SFTF6Wgzf0JVeBCpxgU9JXy+Htjtj1NY+Bou1xhk+fcPFbV6JxbL40RE3IVO9zGS5KrfRV8gyhNrw8LC0Gg0lJaWcurUKU6cOMGpU6fOq2dIISnoEtUFvUrPrvxduPwX970SBEGoqxtuuIGUlJRQL9DTTz/NO++8w+bNmxkxYgSdO3dm+vTpdO3alUmTJtW6XoPBwBdffEFhYSF9+vTh5ptv5pprruHll1+u9phnnnmGP/zhD4wePZphw4YxePBgevWqOe/q1Vdfxe/3c9999xEfHx96nStQu/vuu1m5cmVoMc60tDSGDRtWZdA0duxYdu7cyfbt2wH497//zV/+8hfmzJlD586dmTBhAq1ateLLL78MfXkHMGbMGDZt2oRarebWW2+lQ4cO/PnPf6a4uJgnnniixvadj/Hjx7No0SLmz59P9+7d+f777/nss89ITk4OlSkfYVFu8uTJPP/887z88st06dKFcePGkZqaGsqHgrKJElauXMmyZcvo2rUrb775JqtWraJfv36hMkuWLKG4uJghQ4ZU+HmsWrUqVCYzM5NNmzZxxx13NNo9uBSJdYCEZle+hlBWXiGHcktw+pWEm3S0suoI19ezkzLgRVmSicpx6vR6QlH4LS2Qq80T+p0klaLTfYlO9wlKZVaFfbJswO0ejss1mmAwvn5tuwD5fD48Hg+BQAC1Wl0hZ0itVtepZ8gb8LI9dzsSEj1jeqJWnt/Yd0EQLhyXyzpAQt3Iskz//v2ZNm0af/7zn5u7OZeVWbNmUVxczNKlS5u7KReE2n7miCFwQrMrX0PIbDYTF2UnI7uAw3lOdjo9xFh0JFt1GDV1nJ1NqSEQ3opAWDJKZzZK+0k0OTuRNSb8lpYEDdEgVd0BKssGXK4bcblGo9FsQa//GLV6J1AWHOn1a9DrP8br7YvLdSM+XzegYRcibWpqtTo0xt3n8+F0OrHb7ZWCIY3m3IvIapQaukZ1ZWfuTnbl76J7dHexaKogCMIlTJIkli5dyq5du5q7KZedmJiYc07zLVQmeoCEC47X66WoqIijWYUcLShFUqpJCNfTMkKHVlX/UZsKVyFKewYKtw2UGvzmFgTMCaA4dw+FUnkMvf5jdLqvgYoL4QUCKbhcN+J2DwG09W7fhaimnqFzBUMl3hJ25u4kTBtGl6guKKoJOAVBuHiIHiBBEC5ktf3MEQGQcMFyu90U2mwcyizkRLEHtUZDS6uBxDAtKkX9e1wkrxNlyQmUzmxAImCKJ2Bugaw+9xoRklSMTvc5ev1aFIr8Cvtk2YzL9Ufc7hsIBqPq3b4L1dnBUPksc3q9vtohcoXuQvbk7yHGEEMHa90XsBME4cIiAiBBEC5kIgCqhgiALi6yLONyucgvsPHbqUKyS3wY9TpSIg3EmeuWm1JJeZ5QSSYEfafzhJKQdeG1ONiPVvsjev0aVKrfztqnxOMZhMv1J/z+S/Oh3+fz4Xa7AUKTKhgMhipnGMpx5rC/cD8tzS1pHd66qZsqCEIDEgGQIAgXMpEDJFwSytcQStLribSGk5VbwP5TNvacLCTTZKB1lB6roZ5J9uV5QpaWZXlCJSfR5OxA1pjxW5IIGmKg2gBLhcdzFR7PVahUB9Dr16DV/gAEgABa7fdotd/j96fict2IxzOYS+nXrTxnyO/343A4KCkpwWKxEBMTU2HWHoBYYyzeoJcjRUdQK9UkmZOaqdWCIAiCIAiiB6i5myPUUTAYxOl0kpGdz2+niij1S8SEGWgVqcekPc9Ee1lG4S7PEypCVmoJWFoQMMXXKk9IoShAp1uLXv8ZkmQ/q92RuFw34HaPRJarXkvhYhYIBHA4HJjNZmJjY6tcNPBI0RFOlJygo7UjscbqV9AWBOHCJXqABEG4kIkeIOGSVL6GUEejkRYxVo5k5nEw206uvZTECCOtIvX1nyhBkgjqIwnqI5G8DpT2E6iKjqIqSi/LE7K0QFbpqz08GIyktHQSpaV/Rqv99vTwuGOn212A0fgWRuM7uN1DcbluJBCoekXni5FSqcRsNlNSUgJQZRDUOqw13oCXA7YDqJVqrDprczRVEARBEITLnAiAhIuSQqEgLCyMbiYTreLt7M/I5WieneziUpIjTSSF61Ap658fJGtM+KM64ve3RuXIRFmSibLkJEFDdFmekLamXhwNHs9wPJ5rUat3o9evQaP5GZAB3+k1hr7E5+uKy3UjXm8/LoU1icuD05KSEmRZJjY2tsJMcZIkkWpNxZfvY2/+XrrHdMesMTdjiwVBEARBuByJAEi4qCmVSiIiIuhjMtGmqJj9Gbkczi7ipE1D62gT8RYNivOZKEGlxR/eGr+lfD2hE2iytyNrLWV5QvroGvKEJHy+rvh8XVEostHrP0Gn+wJJKgVArd6FWr2LQCAOt3s0bvdwZNlY/7ZeAM4MgoLBIHFxcWi1v08NrpAUdIrsxK95v7I7bzfdY7pjqMXse4IgCIIgCA3l4v/aWRAoS8qPjY5i4BVtubpzIuFaiX0nC9mSXkSew3fuCs5FoSRgTsSb0A9f9BXIKFDn7UVz6meU9hMQ9Nd4eDAYh9N5N4WF/8Xh+CuBQGJon1KZjdG4FKt1IkbjEpTKzPNvbzNSKBRYLBZcLhfZ2dmh2eLKqRQqukZ1RalQsjt/N96At5laKgiCcOGSJIk1a9ZUuz8lJYVFixZVWT49PR1Jkti5c2ejtlEQLlYiABIuKRqNhqSEOK7q1pYrO8SjIsDO4wVsP1GM3V1zkFIrkkTQEIUvrgfe+N7IWgsq22G0Jzehsh0Gv7vGw2VZj9s9GpttKXb7fHy+nmdU7UKv/4SIiLuwWB5Drd5O2bC5i48kSZjNZtxud5VBkFqppmt0VwLBALvyduE/RwApCILQ1CZPnowkSfzrX/+qsH3NmjXntwQDkJubyz333EPLli3RarXExcUxYsQIfvrpp1rXsXXrVu6+++7zaocgXK7EEDjhkqTT6WidlEB8VATpWfnsPVHA5iMu4iOMtIk2oFef54xxgKwx44vqDOFtUZWcROk4hdJ+gqAh5nSeUE0zJCnwevvg9fZBqTyOXv8xOt0GwAvIaDRb0Wi2Egi0xOUag9t9NXBxzaAkSRImkwmHw0FWVhZxcXHo9b9PIqFX6eka3ZUduTvYW7CXK6KuQCGJ72QEQbhw6HQ6nn76ae655x4iIiIarN6xY8fi8/l46623aN26NTk5OWzYsIHCwsJa1xEdHd1g7RGEy4142hAuaXq9ng6tWnBdr7Z0TYog3+7kx0N5HMp14gsEG+YkKi3+iDZ4Egfgj2iH5C1Bk70NTfZ2FKV5cI6Z5gOBZByOByko+C9O550Eg1GhfUplBibTS0RGTsRofAOFIq9h2txEyoMgr9dLVlYWpaWlFfabNCauiLqCYk8xvxX+xmU2K78gXN78rupfZw+NrbGs59xl62nYsGHExcXx1FNPVVvmww8/pHPnzmi1WlJSUnjuuedqrLOoqIiNGzfy9NNPM3ToUJKTk+nbty+zZ8/m+uuvr/a4+fPnExsbGxrWdvYQOEEQak/0AAmXvPKH8O6pRlonRLLveC6Hc4rJtDlpHWMhMUyLUnF+wxkAUKjK1g0yJ6Jw5aOyn0CdtwdZpSNgTiJgigNF9b9ysmzG5RqHy3UTGs0m9Po1qNX7Tl+DA73+ffT6D/F4BuFyjcHv7wQ0QLsbWflwuDN7gozG3yd7CNeF09Hakb0Fe9EoNLSNaNuMrRUEocl8dWX1+6IGQe8Xfn//zbUQqGaIcURP6Lf09/ffjQJfUcUy1/1SryYqlUoWLFjArbfeyoMPPkiLFi0q7N+2bRu33HILjz/+OOPHj2fTpk3ce++9REZGMnny5CrrNJlMmEwm1qxZQ//+/StMFFMVWZaZNm0aa9asYePGjbRr165e1yIIwu9ED5Bw2ZAkiTCLhX6dW/PHXm2ID9Nx4JSNTUcKyLZ7Gq73QZIIGqLxxvXEG9frdJ7QIbSZP6GyHQG/5xwVKPF6r6S4+DmKil7E47kaKB+yF0Sr/YHw8JmEhz+IVrsBaIBJHpqAyWQiGAySnZ0dWi+oXLQhmnYR7TjpOMkJ+4lmaqEgCEJlf/rTn+jevTvz5s2rtO/555/nmmuu4dFHH6V9+/ZMnjyZ+++/n2eeeaba+lQqFW+++SZvvfUW4eHhDBo0iDlz5rBr165KZf1+P7fffjtffvklP/74owh+BKGBiB4g4bKjUCiIjAjnDxYzuQVF/Jqew68ZBYQbtLSLs2A1qM9dSS3JWgs+bWcIb1OWJ1SSidKeQdAYg9/SEvkc6+D4/e0oKZmFwzEFvf4zdLr/oVAUAaBSHcZsfhajMQ23+3pcrj8iyw03Rr0xGI1GSktLycnJQZblCivJJ5oS8QQ8HCk+glqpJs4Y14wtFQSh0Q37ofp90ll5mkPX11D2rO9yr/q0/m2qxtNPP83VV1/NjBkzKmzfv38/Y8aMqbBt0KBBLFq0iEAgwKZNmxg5cmRo36uvvsqECRMYO3Ys119/PT/88AM//fQTn3/+OQsXLuT111+v0HP08MMPo9Vq+fnnn4mKikIQhIYheoCEy5ZSqSQ+JpJhPdszpHMSCgm2Hs1jx4kinJ5Aw55MpcMf0RZPi4H4I9oieexosn5Bnb2jVnlCsmyltPQ2CgvfoqRkBn7/78PEFAobBsN/iYy8HbP5OZTKww3b9gZmMJSt+5OdnU1xcXGFfa3DWhNvjOdA4QEKXAXN0TxBEJqKSl/9S6mpQ1ntucuepz/84Q+MGDGCOXPmVNguy3KlGeHOHE3Qu3dvdu7cGXqNHj06tE+n03Httdfy2GOPsWnTJiZPnlypl+naa68lMzOTL7744ryvQRCE34keIOGyp1KpaJUYS2J0BEez8tl9PI8fD+fSwmqkTbQJraoBvydQqAhYkgiYW6Bw5Z2RJ6Qv226MA0VNM9Rp8HiG4fFcg0q1F73+Y7TaTUAQ8KPVfoVW+xU+XxdcrjF4vQP4ffjchcNgMITWCZJlmbCwsNBDRPuI9ngDXvYW7KV7THcsmppm0xMEQWga//rXv+jevTvt27cPbevUqRMbN26sUG7Tpk20b98epVKJXq+nbdva5TV26tSp0ro/o0ePZtSoUdx6660olUr+3//7f+d9HYIgiABIEEI0Gg0dkhNIjrHy24lc9p8s4JTNSatoM8mRRlQNMVFCOUkiaIjBa4hB8hSjsp9EVXgQVdFRAuZE/KZEUNWUGCvh93ehpKQLTmcOev1adLp1SJITALV6D2r1HoLBGFyuUbjdI5DlmofbNTW9Xo/b7SYnJ4dgMEhERASSJCFJEp0iO/Fr3q/szttNj5geGNSG5m6uIAiXuSuuuIIJEybw0ksvhbbNmDGDPn368M9//pPx48fz008/8fLLL7N48eJq6ykoKGDcuHHceeeddO3aFbPZzC+//MLChQsrDaeDshykt99+m4kTJ6JSqbj55psb5foE4XIiAiBBOIter6NH+5a0TYxkT3ouh7JsZBQ4aBcbRkK4DsV5LoB3Nlkbhi86DMnfGqX95OlXBgFDDAFLS2SNqcbjg8FYnM4pOJ23otN9jV7/MUpl2UQCCkUuRmMaBsN/8XiG4XKNIRBIatD2nw+dTockSeTm5iLLMlarFUmSUCqUXBF9BTtydrArfxc9YnqgPXuYiyAIQhP75z//yXvvvRd637NnT9577z0ee+wx/vnPfxIfH8/8+fOrnQEOyiaE6devH//+9785cuQIPp+PpKQk7rrrrkpD7MrdfPPNBINBJk6ciEKh4KabbmroSxOEy4okX2YLb9jtdsLCwiguLq6QgC0IVZFlmcLiEnal53A8z45eraRDfBjR5kZ8GA/6UDqyUdpPIAU8BHXhBMxJBPWRUKvgS0at3o5e/zEazdZKe73e3rhco/H5enGhpAF6vV7cbjdRUVFERkaGhsO5/W62525HrVDTPaY7akXDTVAhCELd1fVvqNvt5tixY7Rq1Qqd7uJazFkQhItPbT9zRA+QINRAkiQiwy0M6WYmp7CYnUez2X68gHCDhtQ4C+EGzbkrqSuF+vc8odI8VPYM1Hm7kdUGAuYWtcgTkvD5euHz9UKpzDydJ7QeSSpbQ0Oj+QWN5hcCgRa4XKPxeIYhy+efJHw+NBoNkiSRl5dHMBgkKioKhUKBTqWjW3Q3duTuYG/+XrpGd0Vx9oxPgiAIgiAIdSB6gAShDoLBIBk5hew8loPN4SLOoqd9nAW9pnEnGpDcRahKTpbNGKdQ4zcnEjAnVp4pqbrjJQc63Zfo9Z+gUORU2CfLRtzuEbhcowgGm3fqaZ/PR2lpKVarlejoaBSKsmCn2FPMr3m/EqmLpFNkp0qzLgmC0DRED5AgCBey2n7miABIEOrB7/dz+FQBu4/nUur20iLCQJsYExpVIwdCvlKUJSdROrIAmYAhloAl6Zx5Qr8LotH8jF6/BrV691n7FHi9A3C5xuDzdQGaJ8jw+/04nU4iIiKIjo5GqSy7p/mufPbm7yXeFE/7iPbnqEUQhMYgAiBBEC5kYgicIDQilUpFh5axtIqzsi8jp2zGuKJcWkebSY4yNvhECeVktQG/tT3+8FYoHVmo7CdQOrMJ6iIIWE7nCdVIgdc7EK93IErlEfT6T9DpvgF8lAVHP6LR/Ijf3xqXawwezxCgEYb51UClUmEymbDZbASDQWJiYlCpVETpo2gf0Z4DtgNolVqSLclN2i5BEARBEC4NogdIEBqAo9TNnuO5HM4qREGQ9rEW4sP1jT9USw6G8oQkrwNZbSRgOZ0nVMtcGUkqQq9fh063FoWisMK+YDAct/uPuFzXI8vWxriCagUCARwOBxaLhZiYGNTqsgkQ0ovTSbenkxqRSrwpvknbJAiXO9EDJAjChUz0AAlCEzIZdPTv2JL2iZH8eiyHfdnFHMsroUNCGJGmRvyjLykIGmPxGmOR3Lay9YQKDqCyHa11npAsh1Na+mdKS29Gq92IXr8aleoQAApFEQbDOxgMq/B4rsLlGoPf3zTDz5RKJWazGbvdjizLxMTEoNFoSAlLwRPwcNB2ELVSTZQ+qknaIwiCIAjCpUEEQILQgKwWI0O7tSar0M7OozlsP15EhEFFapwFs75xh5LJugh8uohQnpDKnoHKfpyAMY6AOQlZYzxHDWo8nqF4PENQqfafnj1uIxAEAmi1X6PVfo3f35HS0hvxegcBjZvzpFAoMJvNlJSUEAwGiY2NRavV0j6iPf6gn30F++gW3Y0wbVijtkMQBEEQhEuHGAInCI1ElmXSc2zsSs+lqMRJrFlD+/gwdOom+t4h6ENZkomqJBMCXoJ66+n1hGo/lE2hyEOnW4te/xmS5KiwLxCIp7T0/+HxXE1jf5ciyzIlJSXo9XpiY2PR6XQE5SC78nbh8DnoEdMDo/pcAZ4gCOdLDIETBOFCJmaBq4YIgISmFggEOXiqgL3H8yh1u0gK19EqxtLoM8aFyEEUztyyPCGfE1ltxG9JImiMrXWeELjR6b5Br1+DUplRYU8wGEtp6Xjc7mFA4y1UKssyDocDjUZDXFwcer0eX9DHztyd+II+esX2QqtsxAVqBUEQAZAgCBe02n7miBUFBaGRKZUKOiZFM6pfe65olUC2M8jGg7mk59kJBoON3wBJQdAUhzehL77Y7sgqHeqC39Bm/oSyOB0C3lpUosPtHonN9grFxQvw+bqH9igUOZhMLxIRcW8od6gxSJKEyWTC5/ORlZWF0+lErVDTNborEhK78nbhC/oa7fyCIAiCIFwaRAAkCE1Eq1bRo008o/qm0qZFLMcKvfx4KJdThQ6aqiM2qIvAF9MVb0JfAvooVMXpaDM3oSo4gORz1qIGCZ+vB8XFT1FU9Cxeb6/QHqXyJOHhD6PXr6Qsb6jhlQdBfr+f7OxsHA4HWqWWbtHd8Aa87MnfQyAYaJRzC4IgCIJwaRABkCA0MZNew4AOLRjZux3RkVb255ay+XAuhSWuJmuDrDbij0zFkzgQf1gKSlc+mlNbUOfuQuG21aoOv78zdvsTFBX9G7+/7emtAYzGtwgLm4VCkd1o7TeZTASDQbKzs7Hb7RjUBrpEdaHEW8L+wv1NFlAKgiAIUFBQQExMDOnp6c3dFOESdfPNN/P88883WH0iABKEZmI167m6awrXdG+DwWxhx8kSth/Lw+HyNF0jlBoCYSl4Egfgi+yA5HejztmJ5tQWFI5skM/dk+P3d6Co6N+Ulo6n/CNFrd5HRMS9aLXrgcYJRoxGI5IkkZ2dTVFRERaNhU6RnShwFXDQdrBRzikIwuVj8uTJSJLE1KlTK+279957kSSJyZMnN33DzlLeTkmSUKvVtG7dmpkzZ+J0OivtV6lUtGzZkr/+9a/YbJW/7MrOzuaBBx6gdevWaLVakpKSGDVqFBs2bKixDU899RSjRo0iJSWlwvZNmzahVCq57rrrqjxuyJAhTJs2rdL2NWvWVFpHr75tO1+LFy8O5ZP06tWLH374odqyKSkpoXt95uu+++6rUC4zM5PbbruNyMhIDAYD3bt3Z9u2baH933//PaNGjSIhIQFJklizZk1jXV4FdbnW2h6zZMkSunbtisViwWKxMGDAANatW1dtfU899RSSJFX6f/HYY4/x5JNPYrfb63VtZ2v2AKiuN3vFihV069YNg8FAfHw8d9xxBwUFBU3UWkFoeAlWMyN6tGZQlxQCaj1b0ovYk5GP29OE+SySgqApvixPKKYbskqLumD/73lC58ytUVFaOpmiooUEg7FlVUouzObnsVieRJIa5gPrbHq9HpVKRU5ODjabjUhdJKnWVLKcWRwrPtYo5xQE4fKRlJTEypUrcbl+76F3u928++67tGzZshlbVtF1111HVlYWR48e5YknnmDx4sXMnDmz0v709HRef/11Pv30U+69994KdaSnp9OrVy++/vprFi5cyO7du/n8888ZOnRopQf4M7lcLtLS0vjLX/5Sad8bb7zBAw88wMaNG8nIyKji6Nqpb9vO16pVq5g2bRpz585lx44dXHnllYwcObLaa9m6dStZWVmh1/r16wEYN25cqIzNZmPQoEGo1WrWrVvHvn37eO655wgPDw+VcTqddOvWjZdffrnebR8yZAhvvvlmrcvX9Vpre0yLFi3417/+xS+//MIvv/zC1VdfzZgxY9i7d2+l+rZu3crSpUvp2rVrpX1du3YlJSWFFStW1PqaatKsAVBdb/bGjRu5/fbbmTJlCnv37uX9999n69atVf7SCcLFRJIkWseGc32vtvRsn0RJUMNPxwo4eKoQn9/fpG0J6q34Yrrhje9LQB9Zlid0chOqwoNIvtIaj/X7O2OzLcbtvja0TaP5kYiIv6JWb6vhyPrT6XRoNBpyc3MpKCgg1hBL67DWHLcf55TjVKOcUxCEy0PPnj1p2bIlH330UWjbRx99RFJSEj169Ahtk2WZhQsX0rp1a/R6Pd26deODDz6oUNfnn3/O4MGDCQ8PJzIykhtuuIEjR45UKDNkyBAefPBBHnnkEaxWK3FxcTz++OPnbKdWqyUuLo6kpCRuvfVWJkyYUKHXoHx/ixYtGD58OOPHj+fLL7+sUEd5r9aWLVu4+eabad++PZ07d2b69On8/PPP1Z573bp1qFQqBgwYUGG70+nkvffe469//Ss33HBDnR7Gz1bftp2v559/nilTpvCXv/yFjh07smjRIpKSkliyZEmV5aOjo4mLiwu91q5dS5s2bbjqqqtCZZ5++mmSkpJYtmwZffv2JSUlhWuuuYY2bdqEyowcOZInnniCm266qdGu7Wx1vdbaHjNq1Cj++Mc/0r59e9q3b8+TTz6JyWSq9HNzOBxMmDCB1157jYiIiCrPN3r0aN59990Gud5mDYDqerN//vlnUlJSePDBB2nVqhWDBw/mnnvu4ZdffmnilgtC41ApFXRKiuL63m3pkJxIrlvBT0fyOZ5b1DQzxp1B1hjxR3YoyxOytETpzEVzajPq3N1INeQJybIBh2M6dvtcZNkEgEJRSFjY/2E0vgI0/BA/rVaLTqcjLy+PvLw8WphakGhK5KDtIHmleQ1+PkEQztdE4I9N/JpYr5becccdLFu2LPT+jTfe4M4776xQ5v/+7/9YtmwZS5YsYe/evTz88MPcdtttfPfdd6EyTqeT6dOns3XrVjZs2IBCoeBPf/pTpc/2t956C6PRyObNm1m4cCHz588P9STUll6vx+eruuf+6NGjfP7556jVvy9bUFhYyOeff859992H0Vh5TbUzeyfO9v3339O7d+9K21etWkVqaiqpqancdtttLFu2rF75mefTtgULFmAymWp8VTfyyOv1sm3bNoYPH15h+/Dhw9m0adM52+31evnvf//LnXfeWWE43yeffELv3r0ZN24cMTEx9OjRg9dee+2c9TWm+lxrfY4JBAKsXLkSp9NZKWC+7777uP766xk2bFi17ezbty9btmzB4zn/54gmWpGxsvIb9/e//73C9ppu3MCBA5k7dy6fffYZI0eOJDc3lw8++IDrr7++2vN4PJ4KN6qhxg4KQmPSaVT0ahNL+0Qru4/ncTzHxsmiPFpH6YkNN6FQNOF3F0oNgfBWBMKSUTqzUdpPosnZiawx4be0JGiIrnI9Ia93MDZbR0ymf6PRlPX+6PUfo9HswG6fRSDQttIx50Oj0SBJEgUFBQSDQVpFtcIb9LK/cD9qhZpwXXiDnk8QhPNRAOQ2dyNqZeLEicyePZv09HQkSeLHH39k5cqVfPvtt0BZYPP888/z9ddfhx7qWrduzcaNG3n11VdD3/6PHTu2Qr1paWnExMSwb98+unTpEtretWtX5s2bB0C7du14+eWX2bBhA9deey21sWXLFt555x2uueaa0La1a9diMpkIBAK43W6ACgnlhw8fRpZlOnToUMe7UzY8LSEhodL2tLQ0brvtNqBsCJ7D4WDDhg01PuBW5XzaNnXqVG655ZYayyQmJla5PT8/n0AgQGxsbIXtsbGxZGefe5KfNWvWUFRUVClP7OjRoyxZsoTp06czZ84ctmzZwoMPPohWq+X2228/Z73VWbBgAQsWLAi9d7lc/Pzzz9x///2hbevWrePKK6+sdGx9rrUux+zevZsBAwbgdrsxmUysXr2aTp06hfavXLmS7du3s3Xr1hqvMTExEY/HQ3Z2NsnJyTWWPZdmC4Dqc7MHDhzIihUrGD9+PG63G7/fz+jRo3nppZeqPc9TTz3FP/7xjwZtuyA0FbNOzcDUBNonWNl1PI8D+UWcsOXRNtpEhNlQKUm0UUkKAqYEAqYEFK4ClPYTqPP3gVKD39yCgDkBFBUXQg0GI7Hb/4lO9wkmUxrgQ6nMICJiGk7n7bhcN9OQHdFqtRqj0YjNZkOWZdpFtcMX8LGnYA/do7tj0pga7FyCIJyPyIvmnFFRUVx//fW89dZbyLLM9ddfT1RUVGj/vn37cLvdlQIUr9dbYZjckSNHePTRR/n555/Jz88P9fxkZGRUCoDOFB8fT25uzcFieYDj9/vx+XyMGTOmwrPR0KFDWbJkCaWlpbz++uscPHiQBx54ILS/vGemPn9TXC5XpQUnDxw4wJYtW0JDB1UqFePHj+eNN96ocwB0Pm2zWq1YrdY6H3ems88ry3Kt2pKWlsbIkSMrBYfBYJDevXuHgpUePXqwd+9elixZcl4B0NnB3oQJExg7dmyFYXTVBXvl6nOttTkmNTWVnTt3UlRUxIcffsikSZP47rvv6NSpEydOnOChhx7iyy+/POdiyXq9HoDS0pqH49dGswVA5epys/ft28eDDz7IY489xogRI8jKymLWrFlMnTqVtLS0Ko+ZPXs206dPD7232+0kJSU13AUIQhOIMusY2rkFmTYrezLy2JVtJ6KwlNbRJkwGXdMGQkBQH0lQH4nkdaC0n0BVfAxVcToBUzwBSxKySn9GaQm3eww+X3fM5oWoVEcpmy57GRrNL5SUzAhNnNAQVCoVJpOJoqIiAoEAqdGp7LXtZVf+LnrG9ESnEqvRC0Lze7u5G1And955Z+ib9P/85z8V9pUHMv/73/8qPWBqtdrQv0eNGkVSUhKvvfYaCQkJBINBunTpgtdbcTHqM4emQdlz0rmGQJcHOGq1moSEhEp1GI1G2rYt63V/8cUXGTp0KP/4xz/45z//CZT1NEmSxP79+7nxxhtrPNfZoqKiKs0ol5aWht/vr3A/ZFlGrVZjs9lCOR4Wi4Xi4uJKdRYVFWGxWM67bWf3ilSlul6RqKgolEplpS/lc3NzK315f7bjx4/z1VdfVcgdKxcfH1+h9wOgY8eOfPjhhzXWeS5nB3t6vZ6YmJjQz70m9bnWuhyj0WhC7ejduzdbt27lhRde4NVXX2Xbtm3k5ubSq9fv6woGAgG+//57Xn75ZTweD0qlEigbDglluVbnq9lygOpzs5966ikGDRrErFmz6Nq1KyNGjGDx4sW88cYbZGVlVXmMVqsNTb1X/hKEi5EkSbSwGhneNZm+HZPxa0xsy3Sw/2QBLncTTp19Blljwh/VsWKeUObPqPP2ILmLKpQNBJIpKlqEyzUOKAvY1Ordp6fL/pqGnC5bqVRiNpspKSkhPzefDmEdUEgKduXtwhdowtn1BEG4JFx33XV4vV68Xi8jRoyosK9Tp05otVoyMjJo27ZthVf5F64FBQXs37+f//u//+Oaa66hY8eOVU5DXV/lAU5ycnKl4Kcq8+bN49lnn+XUqbKJYqxWKyNGjOA///lPaPrsMxUVFVVbV48ePdi3b1/ovd/vZ/ny5Tz33HPs3Lkz9Pr1119JTk6uMItXhw4dqszj3rp1K6mpqefdtqlTp1ZoQ1WvqvKXoOyhvVevXpXyr9avX8/AgQOrPSfAsmXLiImJqTJFY9CgQRw4cKDCtoMHD573kK7zUZ9rPZ/7I8tyKD3lmmuuYffu3ZV+JhMmTGDnzp2h4Adgz549tGjRokIPbH01Ww/QmTfuT3/6U2j7+vXrGTNmTJXHlJaWolJVbHL5jRELHwqXC4VCom1sGC0jzRzKLuJgZgG/ZNhJMCtJijSh0WiavlHleUKWlmV5QiUn0eTsQNaYz8gTkgA1TuedeL19MJufQaHIQ5JKMZufQaPZjMNxP7JsbpAmKRSKUBAUCARIjUplX/E+dufvplt0N5QK5bkrEQRBoOxZY//+/aF/n8lsNjNz5kwefvhhgsEggwcPxm63s2nTJkwmE5MmTSIiIoLIyEiWLl1KfHw8GRkZlXKgm9KQIUPo3LkzCxYsCE21vHjxYgYOHEjfvn2ZP38+Xbt2xe/3s379epYsWRK6/rONGDGC2bNnh3p21q5di81mY8qUKYSFhVUoe/PNN5OWlhbqTbv33nt5+eWXue+++7j77rvR6/WsX7+etLQ03n77917C+rbtfIfATZ8+nYkTJ9K7d28GDBjA0qVLycjIqLA21Msvv8zq1atD6xEFg0GWLVvGpEmTKj2zAjz88MMMHDiQBQsWcMstt7BlyxaWLl3K0qVLQ2UcDgeHDx8OvT927Bg7d+7EarVWO/26w+HA4XCE3q9cuRKgQkeD1Wqt9hmhPtdam2PmzJnDyJEjSUpKoqSkJJQ/9/nnnwNlvz9nDgGFsoA+MjKy0vYffvih0qQL9dWsQ+DOdeNmz55NZmYmy5cvB8q6j++66y6WLFkSGgI3bdo0+vbtW2UCniBcyjQqBZ1bWGkVY2HfSRvp2YXkZBTTwqIiwWqu8oO30SmUBMyJv+cJlZxAnb8XWaklYGlBwBQPCjU+3xXYbEswmRaf7v0BrfZ71Op9lJTMwOfr3jDNUSiwWCw4HA6K8opoG9GWA44D7C3YS5eoLiiqmLxBEAShKjWNIPnnP/9JTEwMTz31FEePHiU8PJyePXsyZ84coOyzaOXKlTz44IN06dKF1NRUXnzxRYYMGdJEra9s+vTp3HHHHfztb38jKSmJVq1asX37dp588klmzJhBVlYW0dHR9OrVq8apkK+44gp69+7Ne++9xz333ENaWhrDhg2rFPxA2UQQCxYsYPv27fTs2ZOUlBR++OEH5s6dy/Dhw3G73bRv354333yzwto59W3b+Ro/fjwFBQXMnz+frKwsunTpwmeffVahtyY/P7/CdOZfffUVGRkZlWYKLNenTx9Wr17N7NmzmT9/Pq1atWLRokVMmDAhVOaXX35h6NChofflqRyTJk2qdjrxZ5999pw579988021/+fqc621OSYnJ4eJEyeSlZVFWFgYXbt25fPPP6/1pB7l3G43q1ev5osvvqjTcdWR5GbuOlm8eDELFy4M3bh///vf/OEPfwDKVi9OT08PzbQC8NJLL/HKK69w7NgxwsPDufrqq3n66afPmdhVzm63ExYWRnFxsRgOJ1xSikt97DmRT2Z+EZqgl5bhGqLDTZW+rWxqZXlCGShLcwHF6TyhFqE8Ia32O0yml5Ck34c2uFx/wumcDDRMb5YsyzidTpRKJZpwDUdLjxJrjKWDte6zCgnC5ayuf0PdbjfHjh0LLXguXJo+++wzZs6cyZ49e5p2llLhsvGf//yHjz/+uNL6VWer7WdOswdATU0EQMKlLqfYxZ4TBeQX2TFJPpIjtIRbmnjq7Kr4PagcmShLMiHoJ2iIwW9pgawNQ6HIx2x+DrV6Z6h4IJCC3f4IgUCrBmtCaWlp2UQrZomTvpO0NLekdXjrBqtfEC51IgASqvPCCy9w0003iYmmhEaxdOlSrrrqqlBuWHVEAFQNEQAJl4NgUOakrZT9JwsotpcQrvaTbDVgNOibPxAKBk6vJ3QCye9C1lrwW5II6iPRGz7BaHwD8J8urMLpvAOX60Yaas4Wl8tVNlWswUeenEfbiLYkmcUfbEGoDREACYJwIavtZ06zT4MtCELDUygkWkYaiQ/Xk57n4MCpQn7NcRCjc5EYYcCg1zf51Nm/N+7MPKF8lPaTqPP2Iqt0eM298YZdgSX8OZTKdMCP0fgaGs0WSkpmEgye/8wver0ej8eD7JQxa80cKjyERqEh1thwU3ELgiAIgnDhEgM1BeESplYqaBdnYdgVSXRMSaQYE7uz3aTnFOJ2u5t39kRJImiIxhfXA298b2StBZXtMKrjpyg59iAu56jfr0P9KxERU9Fqv2uQU2u1WvR6PQaXAY1Xw778fRS6CxukbkEQBEEQLmwiABKEy4BOreSKpAiuviKJpMQ4cn16dmc5OZVvq7QIX3OQNWZ8UZ3xJA4kYE5EWZKP/7eOOI/fRdBfNpOQJDkxm/+F2bwQSXKco8ZzU6vVmEwmInwRyKUyu3J2UeItOe96BUEQBEG4sIkASBAuI2admj6toriycxKRUdGccGvZl+0gt7AIn+8CWCBUpcUf0QZP4gD8Ee0IFMVTumci/sJUpGBZXpBW+w0REfeiVu8+/9OpVFjMFmLkGNx2N9uztlPqKz3vegVBEARBuHCJAEgQLkNRJi2D2sfSL7UFOouVIyVKDmTbsRXb8fv9566gsSlUBCwt8Cb0x2vtS+mp23Edux7J7UcKeFEocgkL+xtGYxpwfj1YSqWScEs4icpEim3FbDu1DW+g+XvFBEEQBEFoHCIAEoTLlCRJJIbruapDPD3btUDWR3CgCI7k2Cm22wkEAs3dxFCekDeuJ07dnRSffIyAPR6F14kUcKPXvUd4+MMolcfP6zQKhQJrmJUUTQq5+blsObEFf/ACCAQFQRAEQWhwIgAShMucUiHRKsrIkE7xdEyJp1Rl5oBN5nhuMSUlJQSDweZuIgCy1oI3/EoKPUspLRoP/gAKnxM1e4kIuxed7mOg/m2VJInIsEja6NtwKu8UWzK2EJQvjGsXBEEQBKHhiGmwBUEAQKtS0jE+jJZWI4dySjiRV0xRkZvo0iIizTp0Ol3zryEEoDLg4H5czuGEGZ5AKR1D4S/GrH0ereI7SlxzCMr1my5bkiRiwmMISkF+y/4NRVBB35S+F8Z1C8IlJhAINNkXLAqFAqVS2STnEgThwicCIEEQKjBqVXRvGUFypJED2XZyikooLHARq/cQZiwLhJptDaEzBILtKXS8htG4DIP2Awj40Kq2oDZOwFH8V9zSKFDU74EnLiwOWZLZl70PBQp6p/QWQZAgNKBAIMDJkyebbPIVtVpNixYtLosgaMiQIXTv3p1FixZdEPUIwoVI/EUXBKFKEUYN/VpH0rdtPMaIKE569Rwt9JBfWITb7W7u5p2mxemcSlHJQgLKJIJqA5LKgyXiWcKZjqp4L/g99ao53hJPqjWVA9kH2Jm+88KYHEIQLhHBYBCfz4dCoUCj0TTqS6FQ4PP5mnw47/fff8+oUaNISEhAkiTWrFlzXvUNGTKEadOmNUjbBOFyJwIgQRCqJUkScWE6BreNpnurOBTGCNLdWjJsHgptRXg89QsuGprP1xObbTEe71XIKj1BtRF15C7CY/+OoWglqvx9SN66rx3UwtKCNtY27M3ey+703RfEmkmCcClRqVRN8moIQ4YM4c0336x1eafTSbdu3Xj55Zcb5PyCIDQcEQAJgnBOCoVEy0gDf0iNpVPLWDwaC+kuLVl2D0VFRRdEYCDLFkpK5lBSMgMZI7JSByYfxnZvY7CsQpP1M+qcHShcBSDLta43xZJCckQy+/L2sf/4flwuVyNehSAIl4qRI0fyxBNPcNNNN9X6mA8++IArrrgCvV5PZGQkw4YNw+l0MnnyZL777jteeOEFJElCkiTS09NxOp3cfvvtmEwm4uPjee655+rV1trUI8syCxcupHXr1uj1erp168YHH3wAwKuvvkpiYmKlXrbRo0czadKkerVJEBqTCIAEQag1tVJBu1gzf0iNIyU+imLJxHGXhrwSN8XFxXg8HuQ6BBcNT8LjGYbNthifrxMgISvVaBI2Y+j8HkpVFurcXWiytqAsyYRg7ab6bmNpQ3xYPPsK9nEw4yAOR917kwRBEGqSlZXFn//8Z+68807279/Pt99+y0033YQsy7zwwgsMGDCAu+66i6ysLLKyskhKSmLWrFl88803rF69mi+//JJvv/2Wbdu21fnctann//7v/1i2bBlLlixh7969PPzww9x222189913jBs3jvz8fL755ptQeZvNxhdffMGECRPO+94IQkMTkyAIglBneo2SLolhJFkNHM4tIbe4lBKfj0h8aNxu1Gp1s84aFwzGUVz8DHr9exiN/wUCKHUnMKW+itN2K/6sjqgKD6IqOobfnEjAnAhKTbX1SZJEu7B2+GU/B4oPoJAVJMUlERYWdkFMCCEIQsNbsGABCxYsCL13uVz8/PPP3H///aFt69at48orr2yQ82VlZeH3+7nppptITk4G4Iorrgjt12g0GAwG4uLiAHA4HKSlpbF8+XKuvfZaAN566y1atGhRp/PWph6n08nzzz/P119/zYABAwBo3bo1Gzdu5NVXX+Wdd97huuuu45133uGaa64B4P3338dqtYbeC8KFRARAgiDUW5heTa9kK3klRg7llpBV6iFcLROBl5KSEpRKJXq9vplmXlLgcv0/fL5emM0LUSpPAl6MEW/iNfbBYbsHRbETlT0Dlf04AUMsAUtLZI2xytqUkpIOYR3YI+/hsPMw8imZOG8cUVFRYoY4QbgETZ06lVtuuSX0fsKECYwdO7bCkLbExMQGO1+3bt245ppruOKKKxgxYgTDhw/n5ptvJiIiosryR44cwev1hgISAKvVSmpqap3OW5t69u3bh9vtDgVI5bxeLz169ADK7s/dd9/N4sWL0Wq1rFixgv/3//7fZTHznnDxEQGQIAjnLdqsJcqkIbPIxdE8Jyc8SqINRsIUXkpLSwHQ6XSo1eomb5vf3w6b7SVMpjfQ6T4FQKPZSkTMAUr00/C4B6IsOYWq5CRKZzZBXQQBS0uCemululQKFR3DOrKnaA8ZvgykPIlAIEB0dHSDJVoLgnBhsFqtWK2/fw7o9XpiYmJo27Zto5xPqVSyfv16Nm3axJdffslLL73E3Llz2bx5M61atapUvqGGG9emnvLcnv/973+Vgj6tVgvAqFGjCAaD/O9//6NPnz788MMPPP/88w3SRkFoaOJrS0EQGoQkSbSIMDCwTSStYswUeiTS3VowRmK2WPB6vc2YJ6TD4bgXu30+wWD46fbasVjmY7L8h2B4DJ7EAfiiOiEFfahzf0VzagtKxymQKyb1apVaOoZ1JCAFOCWfotBWSFZW1gU0NbggCBcrSZIYNGgQ//jHP9ixYwcajYbVq1cDZUPgAoHf8xbbtm2LWq3m559/Dm2z2WwcPHiwTuesTT2dOnVCq9WSkZFB27ZtK7ySkpKAsgDxpptuYsWKFbz77ru0b9+eXr161es+CEJjE19ZCoLQoFRKBW2iTSSG6zma5+RksQu9Wk2L8BgiJB/FxcXY7XY0Gk2TL6rq9fbBZluC2fwiGs1PAOh0X6BW76KkZBZ+Y0e8xlgktw2V/SSqggOobEcr5QkZVAZSw1LZX7SfHEUOCkfZOiMxMTGYTKYmux5BuNg1xfpa9T2Hw+GoMOHJypUrAcjOzg5ts1qtaDRV5w86HA4OHz4cen/s2DF27tyJ1WqlZcuWlcpv3ryZDRs2MHz4cGJiYti8eTN5eXl07NgRgJSUFDZv3kx6ejomkwmr1cqUKVOYNWsWkZGRxMbGMnfu3EpDcl9++WVWr17Nhg0bqmynyWQ6Zz1ms5mZM2fy8MMPEwwGGTx4MHa7nU2bNmEymUIzvU2YMIFRo0axd+9ebrvttkrnOldbBKGpiABIEIRGoVMr6ZRgoWWkgUM5JRzMcxNmUJMSFY8y4A4FQiqVCr1e32R5NLIcjt3+KDrdlxiNryBJbpTKLMLDZ1Ja+mdKS/8fsi4Cny4CyVeKsuTk73lCxjgC5iRkjRGL2kI7SzsO2g+i0WmIDcSSlZVFVFQU4eHhYnIEQaiBQqFArVbj8/maZBp9tVpd58+YZ599ln/84x81lvnmm28YMmRIlft++eUXhg4dGno/ffp0ACZNmlTlekIWi4Xvv/+eRYsWYbfbSU5O5rnnnmPkyJEAzJw5k0mTJtGpUydcLhfHjh3jmWeeweFwMHr0aMxmMzNmzKC4uLhCvfn5+Rw5cqTG66hNPf/85z+JiYnhqaee4ujRo4SHh9OzZ0/mzJkTKnP11VdjtVo5cOAAt956a6Xz1KYtgtAUJLl556xtcna7nbCwMIqLi7FYLM3dHEG4bBQ6vRzMKcHh9hNj0dIqUo/s81BcXIzT6USSJPR6fZPm0igUp7BYnkGl+i20ze9vT0nJIwQCZ4xzD3hROk6hKsmEgJeg3krAnERQbyXXlctRx1GSDElEKiPxer1YrVYiIyNF8q9wyanr31C3282xY8do1aoVOp2uwr5AIFBp3ZjGolAoxO+jIFwGavrMOZPoARIEoUlYjRr6tbKSbXdzJNfJlvQiWkQYSI6NJ8Lrxm6343A4CAaD6HS6aoeVNKRgMIGiomcxGFZiMLwDBFGpDhIefh9O59243SMBCZQaAmEpBCwtUThzUdkzUOf+iqw2EmdJwqtP4ETpCdQmNVaDlYKCAnw+H9HR0U1yHYJwMVIqlSIoEQShWYgASBCEJiNJEvFhemLMOk4UlnKswMmpYhcpkUaSYuOIiPBgt9spKSnB5XKh1WrRarWNPJxMSWnpBLzeXpjNz6BUnkKSPJhML6HRbKGk5CFk+fQ0tJKCoCkOrykOhduG0n4CdcFvtFFqCChljtoPog7vTJg5DLvdjt/vJyYmBr1e34jtFwRBEAShLsQscIIgNDmlQiIlysigNlEkhOk5mufgp6MF2DwQExNDUlIS0dHRyLKM3W7H5XI1+sxxfn8HbLaXT/f6lNFoNhMRcS8azZZK5YO6CHwxXfEm9CWgj6Kd10ds8UmOZH6D052LxWLB7XZz6tQpSkpKGrXtgiAIgiD8//buPL6uqt7//2ufeczJPDRJ23SkpYytQOECMhWBH4NfmS4IVOAioiIiIojK4IDXAQUvIMgkKlAZ9IoCUvUCZRCltAxtoUM6N0MznXk++/dH6GlDkjZJ06bJeT8fjzweycra+6yzH+Us3ll7f9bAKQCJyIhx2CxMr/Yzd3IZAbed5VtCvLm2g0gaysvLGT9+PFVVVVgsFkKhELFYbA8/M+AmErmaUOhmTDMAgMXSRVHRzfh8vwDivY4w7V4yZdNJ1R3FpIpPEMikWLPuL2Sa/02RPYNpmjQ1NdHR0TEC5b9FRETk4xSARGTEeRw2DqwrZs7EEqwWgyUbuliyoZNEtrvMbH19PePGjcNut+dL0+64H8ZwS6WOoKPjXlKpT+TbXK7nKCn5MjZbP3tsWB2YJZNpmPz/sAYmsSK8GrPpLQKR1ThI0draytatW/fouEX2VXur2IGIFLaBftaoCpyI7HNaQwlWt0aIp7PUBNxMqvDislvJ5XJEo9F85ThgD1eOM3G5nsPnux/YVqq3+5mhWOxcoO8HuFPZFO93vY89GeagnBV7Nk3KXUnQVom/pJzKykrsdvseGrPInjPYOTSXy7Fq1SqsVmu+KIhKxIvIcDNNk1Qqlf9D49SpU3da+l4BSET2SbmcyeauOI1tUXI5k/pSDxPLPNisFkzTJBaLEQwG88/XuFyuPRYqrNZN+P0/wmZblW/LZGYQCn2dXK6mz2PimTjLupbhtjrZ31KEM7QBM5ejy1qKvWIqVTXjdlqiU2RfNJQ5NJVK0dTURCwW28OjE5FC5/F4qKmp2WUFVgUgEdmnpbM51rdH2dARw2ax0FDupa7EjWEYmKZJPB7PV47LZDK43e49VHo6g8fzGB7PAqB7id003UQiV5JMngT0/qt2OB1mRdcKAo4A03wN2IPrsYQ3E09myJZOpmziAfj8fv1FXEaNoc6hpmmSyWR0C6iI7DFWqxWbzTagOVUBSERGhUQ6y+rWCM3BBB6nlSmVPir93SsopmmSSCTyQSidTu+xIGSzLf+oXHZzvi2VOopw+Mv5wgk76kx28mHoQypcFUz2T8ZIx7B1rSXduZGM1Y134myKx03WfigyKmgOFZGxQAFIREaVUCLN6tYIHZEUJV47Uyr9BNzbb31LJpP5W+NSqVR+U9XhXGUxjDhe7y9xuV7Mt+VyJYTD15JOz+nVvzXRSmO4kVpPLfXe+u5zJLpg6wdkwm04S+sITDkcZ1HZsI1RZE/QHCoiY4ECkIiMSm2RJKtaIkSTGaoDLiZX+HA7tq+iJJNJwuEwwWCQVCq1RzZVdThew++/E8PYvs9PInE6kchlgLNH382xzWyMbqTB10CVu2r7L8LNZJqW4bBk8dXOwDv+IAy7ng2SfZPmUBEZCxSARGTUMk2TLcEEjVsjpLM56ko8NJR7sVu3V35JpVKEw2G6urr2SBCyWDrw+X6Gw/FWvi2brSccvp5MZkqPvusi62iONzO1aCplzh1We8wcqdbVWLvW4vV48NYfgLN6Olh0W5zsWzSHishYoAAkIqNeNmeyvj3K+o4YBtBQ7qW+xIPFsj3kpNNpQqHQHgpCJi7Xs/h8DwDpj9qsRKOfIx7/NNu2XDNNk9Xh1XQkO5gRmEGRo+dnUCYVJ9PyIa54C75ACZ7xh2ArHQ8qkiD7CM2hIjIWKACJyJiRzGRp3BplS1ccl93K5AofVUU9Q86eDEJW64aPymWvybelUnMIh6/FNEsAyJk5Pgh+QDQTZWbxTLw2b6/zpKJdmK0f4skF8ZXW4JlwKIavYrfHJ7K7NIeKyFigACQiY040mWF1a4St4SRFbjtTK32UeHtWhNtzQSiN1/sobvdT+ZZcrphw+Ouk04cCkM1lWR5cTiqXYlbxLJxWZ6+zmKZJorMZW+dqfLYM3sqJuOoOBKd/N8cnMnSaQ0VkLFAAEpExqzOaYlVrhFA8TbnfydRKH16nrUefjwchl8uF09k7kAyW3b4Yv/8nWCxd+bZ4/Gyi0UsAG6lcimWdyzAMg/2L98du6XsT12w2S7J9A67wevwuG95x07BVzQDb7o9RZLA0h4rIWKAAJCJjmmmatISSrNkaIZHOMq7YzaQKL05bzwIDqVSKUCiUrxo3HPsIGUYnfv8dPQokZDL7EQp9g1yumkQ2wfud7+O0OplaNBWXtf/qb6lkgkxbI75kM0U+H67amVjKJqtQguxVmkNFZCxQABKRgpDLmWzqjNPYFsEEJpR6mFDmxWrpecvbtn2EQqEQ6XQaj8eD3d736swAXxm3+494vQ8BWQBM00s4fA2p1H8QTUdZGVpJKpei3ltPjbum39vwTNMkHg1h6VxLUa4Lf6AUZ+0sKKpVoQTZKzSHishYoAAkIgUlnc2xri3Kxs4YdquFSRU+xgVcvUJHIpEgGAwSDAYxTRO3243NZuvnrLtms63E778dq7V5h9c4hWj0v8hkHWyMbaQ53ozX5mWSbxJee+/iCNtks1nioQ5c4fUUWaL4Smuw1cwCb/mQxycyEJpDRWQsUAASkYIUT2VZszVCczCB12ljapWPcl/P52pM0ySRSNDV1UUoFALA6/VisVj6OuUuGUYUn+8unM5X8m3ZbA3h8LVkMrOIpCM0hhuJZWOMc4+j1luL1ej/FrdUKkUy2IIvvpliRw53+XgsVTNUKEH2GM2hIjIWKACJSEELxtOsbg3TGU1T4nUwtcpHkavnLW+maRKLxejs7CQSiWC1WnG73UMMQiYu1wt4vfdhGMmP2gzi8f9HNHoxOdNGU6yJTbFNOK1OGnwNBByB/s9mmsTjccxQE8WZFvwuO86KBozyaWDv/5kikaHQHCoiY4ECkIgI0BpOsLo1QiyZpTrgYkqlD5e95+pLLpcjEonQ2dlJLBbbrdLZFstm/P47sNuX59uy2ToikS+QTh9KPBOnMdJIOB2mwlXBBO8EbJb+b8HL5XLEohHs0S0UZ9vxeT3YK6dDaYMKJciw0RwqImOBApCIyEdM02RzV5zGrVEyuRzjPyqUYLf2XOnJZrMEg0E6Ozt3s2JcDrf7abzeR4FMvjWVOoJI5L/IZmtoTbSyIboBi2Fhom8iZc6ynZ4xnU4Ti4TwJpoptYRw+wJYK6ZDoE6FEmS3aQ4VkbFAAUhE5GMy2RzrO2JsaI9hsRhMKvdSW+zG8rGKcalUiq6uLoLBINlsFq/Xi9U6+NUWq3Utfv+d2Gwf7tBqIxb7DPH4eSQzVtZG1tKZ6qTEUUKDrwGHtf/Ate3ZpXQsRHGmlYAliquoAqNyhgolyG7RHCoiY4ECkIhIPxLpLI1bozQF47jtVqZU+qgs6v1cTTwep7Ozk1AohNVqxePxDOG2uBxO5z/weh/CYunc3porIxq9lGTyONoTHayLriNn5pjgnUCFq2Knr5PL5YjFYhjJIKWZVorsWeyBGqiYDi59/sngaQ4VkbFAAUhEZBfCiTSrWyO0R1IEPHamVvoo9vRcgTFNk0gkQnt7O/F4HKfTics1+CIEhhHH43kct/sP7HhbXCYzg0jkCyRSDayPrmdrYit+u5/J/sk73UC1+9gMsVgMVyZISaYVn9OCtWQ8lE1VoQQZFM2hIjIWKACJiAxQeyTJqtYIkUSGyiInUyp9eBw9CxNkMhmCwSBdXV2kUim8Xu+Q9g+yWDbj8/0Kh+PNHVoNEol5RKOX0JW00BhuJJVLUeeto8Zdg8XYeVW6RCJBMhGnKNdFSa4dt8uJUToJShrAOvQ9jqRwaA4VkbFAAUhEZBBM06Q51F0xLpXJUVfioaHci8PWM3wkk0k6OjoIBoO7cVsc2O3/xue7H6t10w5j8BKLXUgkdiqbos00xZvwWD1M9k/e6Qaq28Yfi8XIppOUmh0EzC6cbl/3apAKJcguaA4VkbFAAUhEZAiyOZONHTHWtkcBaCjzUl/qwbpDoYSP3xY39GpxadzuZ/F4fodhxLaPIVtHJPJ5umIzWBNeQywbo8ZdQ523bqcbqHYfmyUajWIz05SZ7fjNMDZPMahQguyE5lARGQsUgEREdkMqk2NtW5RNnTGcNiuTK71UF7l6rPZkMhk6Ozvp7OzENE28Xu+QNlE1jE683kdwuRYC2z+6U6nDCUcuZ1PEYFN0Ew6Lg0n+STvdQHX7sSni8TgeS4qy7FY8RhKLr1KFEqRPmkNFZCxQABIRGQaxVIbVrRFaQ0l8LhtTK32U+Zw9+8RitLe3E4lEcLlcOJ3Ofs62czbbSny+X2KzrdixlXj803SEP83q0JYBb6AK3StV8XicdDpNwJqgNLsVp5HBKK5XoQTpQXOoiIwFCkAiIsOoK5ZiVWuEYCxNmc/B1Co/Puf2ALJtE9WOjg4ymcyQ9w4CE6fz/z4qm92eb83lSolELmVTcBbrt22g6p1ImWvnG6h2H9tdNhszR4klQnG2DbvFAqUNKpQggOZQERkbFIBERPaA1o8KJcTTWWoCbiZVeHHZtwedRCJBe3s74XAYm82G2+0eUpEEw4jjdi/A43maHctmp9P70xm6nFVdxoA3UN1+bJpYLIbDZlBuCeNLt2G1OaB8mgolFDjNoSIyFigAiYjsIbmcyeauOI1tUXI5k/FlHiaUerBZLR/9Pkc4HKa9vZ1kMjnkktkAFksTPt/9OBz/3LGVROJUNnb8fzSG28iZOcZ7x1Ppqtxl2DJNk2QySTKZxOe0UGZ24E53Yjj9ULEf+CqGNE4Z3TSHishYoAAkIrKHpbM51rdH2dARw2axMKnCS23x9hWfVCpFZ2cnXV1dAEMukgDbymbfh9W6Od9mmn5C4Yv5oH06WxPt+O1+Jvkm4ba5d3m+bbfFmaZJwAklmVac2Qh4ylUooQBpDhWRsUABSERkL0mks6xujdAcTOBxWplS6aPS311gYNv+PJ2dnYTDYex2+5Bvi+sum/1HPJ7HMIxEvjWTmUpT58V82GkjmU1S56mjxrPrDVS7j80QjUax2+2UOjIEkluw5pJQVNt9a5wKJRQEzaEiMhYoAImI7GWhRJpVLRE6oylKvHamVPoJuO3A9tviOjo6SCQSu1UtzmJpw+t9AKfz5R1aDeKJk1jZehIboxE8Vg+T/JPw2X0DOmcymSSRSOB2OSmzxfElmjDMnAolFAjNoSIyFigAiYiMkLZIklUtEaLJDNUBF5MrfLgd3YUSMpkMwWCQrq4u0uk0Ho9nyM8H2e3v4fPdjdW6Pt9mml46Qufxbus0opk41e5q6r31u9xAtfvY7rLZmUwGv9dFGUFc8Waw2KB8KgTqVShhjNIcKiJjgQKQiMgIMk2TLcEEjVsjpLM56ks8TCz3Yv+oUEIymaSzs5NgMAjszvNBGdzuZ/F4fothxLa3ZhpY23Yeqzrd2C12GvwNFDuKB3TGbDZLLBbDYrEQ8DopybRgj7eBw6dCCWOU5lARGQsUgERE9gHZnMn69ijr22MYBkwq91FX4sZiMXo8HxSJRHazbHYHPt9DOJ1/79EejX+Sd5qOpSMJ5c5yJvgmYLfYB3TOVCpFPB7H4XBQ4rZQlNyCLRVSoYQxSHOoiIwFCkAiIvuQZCZL49YoW7riuOxWJlf4qA50FxjI5XJEIhE6OjqIx+O79XyQzbYMn+8ebLbGfJtpemjqOoN3WqZjYGOibyLlrvIBnzORSJBMJnE6nZQ5M/jim7FmEyqUMIZoDhWRsUABSERkHxRNZljVGqEtnKTIbWdqpY8Sb/cmpsP3fFAWl+sveL2PYhjRfGs6U88HLWeyPlRGsaOYBl8DTuvAgpZpmiQSCVKpFC6ngzJrDG+iCasBlEyE0kkqlDCKaQ4VkbFAAUhEZB/WGU2xqjVCKJ6mwu9kSqUPr7M7QAzX80GG0YXX+zAu14s92rtih7Nky9EkMkXUe+upclUN+La7HkHIYaXMCOJNbsVqd6pQwiimOVRExgIFIBGRfZxpmrSEkqzZGiGRzjKu2M2kCi9Om3VYnw+y2T7E57sbm21Vvi1nutjQcRLLWg/EZy+hwdeAx+YZ1Ni3BSG3DUqybfhyQazugAoljEKaQ0VkLFAAEhEZJXI5k42dMda2RTGBiWVexpd6sFqM/PNB7e3t3fv0uN04HI6hvAou11/xeh/GMML51mS6inebP0VrpIFaTy3jPOMGtIHqNj1WhIwUZdlWvEYSq7+yOwipUMKooDlURMYCBSARkVEmnc2xti3Kps4YdquFSRU+xgVcGIZBJpOhq6uLrq4uMpkMXq8Xq3XXe/t8nGGE8Xp/jcv1HLBtmjBpixzIkqbjsJjjmOSfhN/uH9R5dwxCnlyEkkwrHlsOW+kEFUoYBTSHishYoAAkIjJKxVNZ1myN0BxM4HPZmFLpo9zXXawgkUjQ0dFBKBTCarXi8XiGeFvc6o+qxa3It2VNG2vajmVV++FUueqp99RjtQwuZJmmSTKZJJmI4810UpzZisflwFYxVYUS9mGaQ0VkLFAAEhEZ5YLxNKtawnTF0pT6HEyt9OF32TFNM39b3O6Vzc7hdP4Nr/dhLJaufGs0Vcp7TfMIJQ5gkn/SgDdQ3VE+CMWjeJMtFOc6cfuKsFfPUKGEfZDmUBEZC4YUgNatW8eiRYtYt24dsViMiooKDjnkEObOnYvLtW/fvqAPbxEZq1rDCVa3RogluwslTKn04bBZhvG2uAgez29xu58FcgCY5GgJT+f95pPxWqdR763HZR38PLAtCKWiQbyJLQSI4A5UYB83C3yVgz6f7BmaQ0VkLBhUAHrssce46667+Ne//kVlZSW1tbW43W46OjpYs2YNLpeLCy+8kG984xtMmDBhT457yPThLSJjWS5nsrkrzpqtEQAmV/ioK+muCjdct8VZrY34fL/Ebn8v35bOwdqOT9DY/kl8tnFUuaoodhQP+vymaZJKpUiF2vDGNlJkS+MqrcVRewC4AoMeqwwvzaEiMhYMOAAdeuihWCwW5s+fzxlnnMH48eN7/D6ZTPLGG2/wxBNP8PTTT3PPPfdwzjnn7JFB7w59eItIIUhlcqxujbClK47PZWN6lZ8SrwPTNAmHw3R0dBCPx3ejWpyJ0/kSXu8DWCwd+bZk1sXa9uNZ03EIDsNHpbuSSlcldot90K+QTCZJd23GG9uE127iqZqKY9z+YHcPYbwyHDSHishYMOAA9Je//IXTTjttQCdta2tj7dq1fOITn9itwe0J+vAWkUISjKdZ2RImGEtTHXAxpdKHy27N3xbX2dlJLpfD4/EM8ba4OG73E3g8fwDS+fZUppy17SezumMyYKHMWUa1uxqf3Tfo10glk6Tb1+KNbcLjcuKunYmzeoYKJYwAzaEiMhYMeBOH0047ja1btw6ob3l5+YDDzz333ENDQwMul4vZs2ezaNGinfZPJpPcdNNNTJgwAafTyeTJk3nooYcG9FoiIoUm4LYzZ0IJM8cV0RFN8caadta1RbFYrJSXl1NXV4fP5yMajRKLxRjsY6Gm6SYW+xwdHQ+STJ4AdN/y5rC1Mb3qd8yb+jAzypsIp0O83/U+73W+R2uilayZHfBrOJxOvOP2I1V3JB0EaFv1Fp1v/5FE84dQWHV8RERkGAzqGSCHw8EZZ5zBZZddxqc+9akh3Tu+owULFnDRRRdxzz33cNRRR3HffffxwAMPsHz58l632G1z5pln0tLSwve+9z2mTJlCa2srmUyGI488ckCvqb9eiUih2rZ/0MaOGG67lWnVfsp9zmHcRBWs1tX4fA9ity/t0Z7JTKG569OsC9bQlQpiNaxUuiqpclcNumhCOhYi2/oBrmQ7rqIy3BMOxVVWv9tzkuya5lARGQsGFYAef/xxHn74Yf7xj39QXV3N5z73OebPn8/kyZOH9OKHH344hx56KPfee2++bcaMGZx11lncfvvtvfq/8MILnH/++TQ2NlJaWjqk19SHt4gUukgyw4fNYTqjKcr9TqZV+fA4bKTTaYLB4G7fFgdgt7+D1/vrHvsHAaTT+9MZ/k82hsrzK0HFjuIhFU3IRDvItazAngriLBmHZ+KhuIurFIT2IM2hIjIWDKkM9saNG3nooYf49a9/zfr16znmmGO4/PLL+cxnPjPgMtipVAqPx8OTTz7Jpz/96Xz7V77yFZYuXcrLL7/c65irrrqKlStXMmfOHH7zm9/g9Xo544wz+O53v4vb3fdDsclkkmQymf85FApRX1+vD28RKXitoQQrWyKkslnGl3ppKPditRjE43E6OjoIh8PYbDbcbvcQQ4WJw/FvPJ5fY7M19vhNKjWbcPRCWqJltMRbiGaiOCwOqtxVgy6akAs3k2tZgSUTx1E+Ee/4g/EEyhSE9gAFIBEZCwb8DNCO6uvrufnmm2lsbOTFF1+ktraWK664gpqaGq666qoBnaOtrY1sNktVVVWP9qqqKpqbm/s8prGxkVdffZX333+fP/zhD/z85z/nqaee4otf/GK/r3P77bcTCATyX/X19QN/oyIiY1hlkYu5k8uYUOZlQ0eU19e00RLqvgWupqaGmpoarFYroVCIVCo1hFcwSKUOo6vrF4TDN5LN1uV/43AspqzkWqZU3sfB5UXMKp5FwBFgU3QTb7e/zerQasLp8IBexeKvxjb5kxjVs0h2bKbz7f+ldfmrREJdg36mSURExr4hrQD15emnn+aKK66gq6uLbHbXD7du2bKF2tpaXn/9debOnZtv//73v89vfvMbPvjgg17HzJs3j0WLFtHc3Ewg0L0fxDPPPMPZZ59NNBrtcxVIK0AiIrsWT2VZ2RJmazhJidfOtCo/fpeddDpNZ2cnXV3dYcLr9WKxDOlvZ0AWp/PveL2/w2Jp3aHdIJk8jmj0QpKZCrYmttISbyGZS+K1ealyVVHmKsNqDOB2vFwGOhrJtTdiGhZsVTPw183A4/XtxrhlG60AichYsFs1RNetW8fDDz/Mr3/9azZt2sRxxx3HZZddNqBjy8vLsVqtvVZ7Wltbe60KbVNTU0NtbW0+/ED3M0OmabJp0yamTp3a6xin04nT6RzEuxIRKTxuh5WD6otpjyT5sDnMv9Z2UFfiYVKFl8rKSnw+X/62OIfDgcvlGsItZlaSyXkkk5/E5XoBj+cJLJZOuvcU+gdO58skEvNw2i6gxn0wwXSQ5ngzjZFG1kfXU+GqoNpdvfOiCRYblE/DUjwBS8dqsk3v0dG6imD1/hSNm7KbAU5ERMaCQc8CiUSC3/zmNxx//PFMmTKFRx55hEsuuYTVq1ezcOFCzj///AGdx+FwMHv2bBYuXNijfeHChf1WdDvqqKPYsmULkUgk37Zy5UosFgt1dXV9HiMiIgNX5nNyxKQyplT62BKM8/qadjZ3dW+YOm7cOMaNG4dhGIRCIdLp9K5P2CcHicQZdHQ8RDR6Kaa5bW+gLC7X85SWXorPdz8lTtgvsB8Hlx5MlauKtkQbSzuWsqJrBR3Jjp3f3mZzkqvcH8uko3H5imHzYjreeZ5Na5YTCoUGdKeCiIiMTYO6Be6KK67g97//PYlEgjPPPJNLL72UefPmDflB021lsH/5y18yd+5c7r//fn71q1+xbNkyJkyYwI033sjmzZt59NFHAYhEIsyYMYMjjjiCW2+9lba2Ni6//HKOPfZYfvWrXw3oNbV8LyIyMIl0ltWtEZqDCYrcdqZX+Ql47KRSqfxtccBur6oYRhS3+w+43c9gGPF8u2m6icfPJB7/DKbpI2fmaE+20xJvIZKJdBdNcFVR4a7AYdl52W5LvB1r+yrS0U4SzjKslftRXFGDz+cbcqW7QqQ5VETGgkEFoAMPPJDLLruMiy66aMhlqD/unnvu4Uc/+hFNTU3MmjWLn/3sZxxzzDEAzJ8/n3Xr1vHSSy/l+3/wwQd8+ctf5rXXXqOsrIxzzz2X733ve/1Wgfs4fXiLiAxOVyzFB81hIokMNcUuplT6cFgtxGIxOjo6iEQiu3Fb3HaGEcTjeQq3+3+B7atLpukjFjubePwMoPuzPpqO0pxopi3RBkCps5QqdxVF9p18rpsm1sgWLJ2NpBMx4u4qLOVTKCnrvsXPZtutu8ILguZQERkLBl0EIRwO889//pN0Os1hhx1GeXn5nhrbHqEPbxGRwTNNk81dcVa3RjCByeU+6krcgEkoFKK9vZ1UKrVbm6huY7G04/E8gcv1PLD9VrVcrphY7HwSiVOA7tfI5DLdRRMSLSSyCTxWD9Xu6p0XTchlsIY2Yg2uJ5XOEPPUYimZQHFJKX6/H7t94CW4C43mUBEZCwYVgN577z0+9alP0dzcjGmaFBUV8dRTT3HiiSfuyTEOK314i4gMXSqTY83WCJs743idNqZX+yn1OkilUnR1dREMBnd7E9VtLJZmPJ7HcLn+DuTy7blcObHYhSQSJwHdr2GaZr5oQleqC6th3XXRhEwSW1cj1kgTyZyViKcea6CG4uJi/H7/bge5sUhzqIiMBYMKQKeeeiqdnZ389Kc/xeVyceutt/Lhhx/2WbJ6X6UPbxGR3RdKpFnZHKYrlqayyMm0Kj8uu5V4PE5nZyehUAiLxYLH49ntqmtW60Y8nt/gdC7q0Z7NjiMW+yzJ5LHsWNMnkU3QGm+lNdFKxswQsAeocldR4ijp8xY9IxXB1rkKS7yThMVDxF2HzVdGIBDA7/erkugONIeKyFgwqABUWVnJc889x5w5cwBob2+nsrKSYDCIz+fbxdH7Bn14i4gMn6Zg921xmazJhDIPE8u8GEZ30Zquri4ikQh2ux23271bzwcBWK2r8XofxeH4d4/2bHYi0ejFpFJHANtfY7BFEyzxdmydazDSURL2EsLOGmxuP0VFRRQVFeFy7aT8doHQHCoiY8GgApDFYqG5uZnKysp8m9/v591336WhoWGPDHC46cNbRGR4ZbI51rZF2dgZw2mzMrXKR6XfRS6XIxwO09HRQSKRyO/LtrtByGZbjtf7CHb7ez3HkZlGNHoJ6fQh7BiEYHvRhPZEOyZm/0UTTBNrtAlb11rIpUm4qgk7KrHanT2C0O6+h9FKc6iIjAWDCkBWq5WVK1dSUVEBdN9zXV9fz6uvvsrEiRPz/fblD0V9eIuI7BnRZIYPW8J0RFKU+hxMr/LjddrIZDKEQiE6OzuHrVACmNjtS/F6H8FmW9njN+n0AUSjl5DJ7N/rqL6KJlS5qyh3lmO17PDM0keFEmyhDWBYSXhrCVtLsFht+P1+AoHAsKxqjTaaQ0VkLBj0CtDHP+xN08y3bft+X95gTh/eIiJ7Vms4waqWCMlMlvoSDw3lXmxWS75QwrZNVL1e7zCUnjZxON7E6/01Vuu6Hr9JpT5BNHox2eyU3kd9VDShJd5CZ6ozXzShylWF27bDtgqZJLbgWqyRJkybm4R/IlHDC4DP56O4uBiPx1MwQUhzqIiMBYMKQC+//PKA+h177LFDHtCepg9vEZE9L5szWd8eZV17FLvVwtRKP9WB7mdoEolEvmIcMCwV4yCH0/kKHs9vsVo39/hNMnk0sdhFZLP1fR6ZzCZpSbTQGu8umlBkL6LKXUWpozQfbLoLJazGkujEdAaI+ycSy3WXy/Z6vQQCgd3eEHY00BwqImPBoPcBGu304S0isvck0llWtoRpDSUp9tiZXu3H77Jjmma+Ylw4HB62inGQxeX6Gx7Pb7FY2nZot5BMHk80eiG5XHWfR+bMHB3JDloSLYTTYewWO1WuKipdlTis3bfs7VgoIeetJOmfQCwNuVyuRxDa/UC3b9IcKiJjwaACkGma/OQnP+GPf/wj6XSaE088ke985zujqjKOPrxFRPa+jmiKD5pDxFNZakvcTCr34bBZME2TSCRCR0cHsVhs2CrGQQqX63k8niewWLp2aLeSSJxCLHY+uVxZv0dHM1Ga491FE3LkKHOWUeWqoshR1KtQQtZfT8pfRzyZIZPJ4Ha7KSkpwefzjbkgpDlURMaCQQWg22+/nW9961uccMIJuN1u/vrXv3LxxRdz//3378kxDit9eIuIjIxczmRTZ5w1bREMYEqlj9pid/7Z0W1BKB6P43K5humPa3Hc7j/h8TyFYUR2aLcTj59BLHYOphno9+idFk3A7FEoIROYSNpbTSKZIp1O4/F48kForNwapzlURMaCQQWg6dOn85WvfIWrrroKgBdeeIGzzjqLeDw+ah4A1Ye3iMjISmayrG6N0NSVwO+yMb3aT7Gn+xazTCZDMBikq6trGCvGgWFEcLufwe3+I4YRz7ebppt4/NPE4/8P0/Tu9Bxdqa5eRRMqXZV4sPYolJApmUzGVUY8HiebzeaLJXi93lEzV/ZHc6iIjAWDCkAul4uVK1cyfvx4oPuWOJfLRWNjI7W1tXtskMNJH94iIvuGYCzNhy1hQvE01QEXUyp9uOzdt4wlk8l8xbhcLofb7R6GinFgGF14PL/H7f4zkM63m6aPWOwc4vEzgJ2vPG0rmrA1sZV0Lr29aAJ2HF2N+UIJ6ZIpZO0+YrEYpmlSXl5OWVn/t92NBppDRWQsGHQZ7JaWlvw+QNC9Eeo777zDpEmT9sgAh5s+vEVE9h2mabIlmGB1a4ScaTKp3Et9iQeLpXulZMdCCYZhDFOhBLBY2vB4Hsfl+iuwfeuGXK6EWOx8EolPATtfeeqvaEI1NjzBDflCCZniSSRzVpLJJLW1tfh8vt0e/0jRHCoiY8GgA9AVV1yBx+PJt91999189rOfJRDYfg/1HXfcMbyjHEb68BYR2fekszkat0bZ1BnD7bAyvcpPmc8JdIekaDRKZ2cnkUhkGAslgMXShNf7W5zO/wO2T4e5XAXR6GdJJk8Adl3IIJqJ0hJvoS3R1l00wVFKTQ7KolshlyZTPJmQtRSbzca4ceNwOp27PfaRoDlURMaCQQWgT37yk7uccAzD4B//+MduD2xP0Ye3iMi+K5xIs7IlTGc0TYXfybQqP25HdwDJ5XI9CiU4nc5hq0Jqta7H6/0NDsdrPdqz2VpisYtIJo8Gdr3ylMllaEu20RxvJpFN4LY4qE3EqMqkyNQeRSiaoKioiOrq6lFZIU5zqIiMBdoHSERE9jktoQQrW8KkszkmlHmZWObF+tFtcZlMhlAoRGdn57AWSgCw2Vbh8TyKw/FWj/ZMZhKx2MWkUocBA1t5CqaCtMRb6Ei04mr/kJKS/SgrO4hsPEtFRQVlZWWjriiC5lARGQsUgEREZJ+UzZmsbYuyoSOKw2plWpWPyqLtKz6pVIquri6CwSDZbBaPxzMshRIAbLb38Xp/jd3+fo/2TGY/otFLSKcPHvC5UtkU7U2v0xrZSLx0Ch6Ll4ARYMb4GRQHiodlvHuL5lARGQsGHIB++MMf8uUvfxmvd+dlQgHefPNN2traOO2003Z7gMNNH94iIqNLLJVhZUuEtnCSEq+D6dV+fM7tQScej+crxgF4vd5h2nfHxG5fjNf7a2y21T1+k04fRDR6CZnMjAGdyUiFsW35Ny2BWpqMDG2RNhwWBzPrZzKpfBJO6+h4JkhzqIiMBQP+U9ny5cuZMGEC55xzDmeccQZz5szJV4PLZDIsX76cV199ld/+9rc0NTXx6KOP7rFBi4hI4fA4bBxcX8zWcJJVLWHebGynvtRDQ7kXu9WC2+3G5XJRVFSUrxg3PIUSDNLpOXR1zcbheB2v91Gs1g0A2O3vUFx8LanU4USjF5HNTt7pmUyHH8NVTFUyRmn1IcR8MRrbG1m2aRmbo5upKaphnG8cJa6S3RiviIgMxKBugXv33Xe5++67efLJJwkGg1itVpxOJ7FYDIBDDjmEK664gksuuWSfrXCjv16JiIxeuZzJ+o4Y69qiWC0GUyp91ARc+aCzJwslQA6n8yU8nt9itTb1+E0yeQyx2MVks/3viWeJtmJvW0aq5hOYDh+madIV6iJmiZH2pkmZKTw2D+N846j2VmOzDM/tfMNJc6iIjAVDegbINE3effdd1q1bRzwep7y8nIMPPpjy8vI9McZhpQ9vEZHRL5HOsro1QnMwQcBjZ1qVn4Dbnv/9niyUABlcrhfxeB7HYmnbod1CInEisdgF5HJVvQ8zczg3v0HWXUambL/uJtMkFApRVFSEq8RFc6yZtngbhmFQ5ami1leLz7Hv7BukOVRExgIVQRARkVGrM5riw5YwkUSGccVuplT6cNi2P/+zJwslQAq3+y94PAswjOAO7Tbi8VOJxS7ANAM9jrAG12ELriNZeyRYuwNZLpcjFApRWlpKZWUlaTPNlsgWmqJNpLIpAs4Atb5ayt3lWIzheLZp6DSHishYoAAkIiKjmmmabOqMs2ZrBIDJFT7qSno+/7NjoQTDMPB4PMNUKAEMI47L9b94PE9hGNEdxuUlGr2IROI08o/cZlM4N79OJtBANjAh3zeTyRCNRiktLaWiogKLxULOzNEWb2NLZAtdyS4cFgc1vu5nhUaqaILmUBEZCxSARERkTEhlcqxujbClK47PZWN6lZ8S7/bb3kzTJBqN0tnZSSQSGaZCCdsZRhi3+2nc7v/FMBL59my2nkjk86TTswGwta3AmujoXgXa4bX7CkHbRNNRNkc20xJtIWfmqPJWMa1k2l5fEdIcKiJjgQKQiIiMKcF4mpUtYYKxNFVFLqZW+XDZrfnf53I5wuEwHR0dJBKJYS6UABZLB17vwzidf+vRHotdQCx2EUYqjKPpLdIV+5PzVPbosy0ElZSUUFlZ2WuVKpPL0BxtpjHYSLm7nBmlM/bqZqqaQ0VkLBjZm4lFRESGWcBtZ86EEmaOK6IzluKNNe2sbYuSy3X/vc9isRAIBKivr6eyshLTNAkGg6TT6WF5/VyulHD4a3R1/YxMZlq+3eN5DLv935gOP6YzgC20qdexNpsNr9dLZ2cnra2tZLPZnr+32Kjz1zGjdAZbY1tZ2blyWMYsIlJIFIBERGTMMQyDccVu5k4uo7bETePWCP9sbGdrOJnvY7PZKCsro66ujtLSUpLJJOFwuFfoGKpMZj+6un5GLHZRvq2o6CdYLG1kiuowkkGMVKTXcTuGoJaWFjKZTK8+FZ4KppdOpynaRGNX47CMV0SkUAypFE40GuWHP/whf//732ltbSWXy/X4fWOjPoxFRGTk2a0WplX5GVfs5sPmMO9s7KLc72RalQ+Po3sKdDqdVFVV4ff78xupWiyWYSqUYCEW+09stg9xOP6FYYTw+39EMHs7WB1Yw5vyJbF3ZLPZ8Pl8BINBcrkclZWVvcp4V3urSefSrOlag81iY3zR+N0cq4hIYRhSALr88st5+eWXueiii6ipqdmr9x+LiIgMls9pY/aEElpDCVa2dK8GjS/1MrHMg83aHXI8Hg9utzu/kWo4HMbhcOByuXZznjMIh79GSckXsVjasNvfw+N9nKT/aGzBtWSKJ+VLYu/IarXi9/sJh8NkMhmqqqpwu909+tT768nkMjQGG7FZbIzzjduNcYqIFIYhFUEoLi7mL3/5C0cdddSeGNMepQc4RUQKWzZnsq49yvr2KHarhamVfqoDPYsgZLPZfKGEZDI5LBup2mzvU1z8DSAHGAQ7bsOyLkImMJFsYGK/x5mmma9aV1VVhdfr7dVnVecqNkc2M6N0BlXePjZhHSaaQ0VkLBjS2n5JSQmlpaXDPRYREZE9zmoxmFzhY+6kcopcdt7fHGTx+g7Cie1FEKxWK8XFxdTX11NRUUEmkyEUCvX5PM5AZTKziEa3PQ9k4i/+GbkiD7bwZjBz/R5nGAZ+v59MJkNzczORSO/nhqYUT6HaW80HHR/QFm8b8hhFRArBkALQd7/7Xb7zne8Qi8WGezwiIiJ7hdth5aD6Yg4ZX0wyk+Nfazv4sDlMOrs9jNjtdsrLy6mrqyMQCBCPxwmHw72efR2oePxc0ulDgO5y2Z66pyGbwBLbdWjx+XzkcjlaWlp6hSDDMJheMp0ydxnL25fTlega0vhERArBkG6BO+SQQ1izZg2maTJx4kTsdnuP37/99tvDNsDhpuV7ERH5uFzOZGNnjMa2KBbDYEqlj3GBns/+mKZJLBbLF0oY6kaqhtFJSclVWCxdACS2nECq43hS1YcO6PhoNIphGFRXV+Pz+Xq+DzPHu1vfJZwKc3Dlwfgd/kGNbVc0h4rIWDCkIghnnXXWMA9DRERk5FgsBhPKvFQVuVjdGmHFlhCbOmLsV11EwNP9Rz7DMPB6vbjd7vzzQaFQaNAbqZpmCeHw9QQCNwEmruoXyQUrSKemYg4gsHi9XmKxGM3Nzfnqdfn3YViYVT6Ld7a+w7tb3+WQykPw2D2Dvh4iImPZkFaARjP99UpERHalK5big+YwkUSGmmIXUyp9OG3WHn0ymQzBYJCuri5SqRQej6fXHRE74/H8Go/nie4fYjaCm24mXTpnwMfHYrHu/Y7GjetVHS6dS7O0dSmmaXJYzWEDPueuaA4VkbFgSCtA2yxevJgVK1ZgGAYzZ87kkEMOGa5xiYiIjJhij4PDG0rZ3BVndWuE1nCSyeU+6krcWCzdt7xt20jV5/PR1dVFMBgkkUjg8XiwWq27eAWIxT6L3f4+dvv7GM4YvtL76MweAFbngMbo8XgIh8O0trYybty4HuHLbrFT462hMah9+UREPm5IAai1tZXzzz+fl156ieLiYkzTJBgMctxxx/HEE09QUVEx3OMUERHZqwzDoK7EQ6XfRWNbhFWtYTZ1dd8WV+rdXhLb6XRSWVnZYyNVq9WKx+PZxfNBVsLhb1BSchVYQ9iLVuDp+i0xLhvwGH0+H6FQiLa2NqqqqoZh41YRkbFvSJ+UX/7ylwmFQixbtoyOjg46Ozt5//33CYVCXH311cM9RhERkRHjsFnYr7qIwxpKcVgtvL2+k3c3dZFIZ/N9DMPA4/FQU1NDbW0tDoeDUChEMpnc6blzuXLC4a8BBqbFjrf4N9isKwc8NsMw8itQnZ2dQ32LIiIFZUgB6IUXXuDee+9lxowZ+baZM2dy99138/zzzw/b4ERERPYVfpedORNLmVUbIBhP88aadhq3Rsjmtj9Ka7FY8Pv91NbWUlFRkd9QNZvN9nveVOpw4vFPY1rtGGQo8t6GYcQHPC6r1Yrb7aa9vb3PPYJERKSnIQWgXC7X54Oedrt9yHsjiIiIjAbVARdzJ5VRX+pmXXuUfza20xpO9Ohjs9koLy+ntrYWn89HNBrd6WpQNPo5Mtn9MA0rVmMjPt+dwMBrFDkcDgzDYOvWrbu1WauISCEYUgA6/vjj+cpXvsKWLVvybZs3b+arX/0qJ5xwwrANTkREZF9ks1qYUunn8IYyPA4r724M8vaGTqLJnuHD7XZTU1NDVVUVyWRyJ+HETih0I6alCMPM4nT8A5frxUGNyeVykU6nd7raJCIiQwxA//M//0M4HGbixIlMnjyZKVOm0NDQQDgc5he/+MVwj1FERGSf5HXaOGR8CQfWB4insvyzsZ1VLWEy2e13Q1gsFoqLiykuLiYajdLf7hO5XA2h6NcxDQMjm8bnuwerdf2Ax2KxWDBNUwFIRGQXhlQFrr6+nrfffpuFCxfywQcfYJomM2fO5MQTTxzu8YmIiOzzKv0uyr1O1nfEWNcWpSmYYGqVj5pA9/48hmFQVlZGIpEgGo3i8/n6PE8qdQyJ3Dzcnr9ikqSo6Ad0dt4J7HqjVcMwyOVyuhVdRGQXdmsfoJNOOomTTjppuMYiIiIyalksBg3lXmoCLla2hFm2OcTmzjjTqv0UuezY7XbKy8vZsmULqVQKh8PR53nCqa/isLyDxdqB1boBn+9eIpGvDmgM20KQiIj0b8AB6K677uKKK67A5XJx11137bSvSmGLiEihctmtHFhXTEc0xYfNYf7V2MHEci9TKn34fD5KS0vZunUrNput7317LD7CbV8i4LwNrCYu14uk0weTTB63y9fWLXAiIrtmmP3djPwxDQ0NvPXWW5SVldHQ0ND/CQ2DxsZ9d+fpUChEIBAgGAxSVFQ00sMREZExLJczWdcepXFrlFm1AaoDLrLZLE1NTUQikX7nISMVwRu/H3fDc5gWO6bppqvrF2SztTt9vVAoRHl5OeXl5WwKb6Ix2MgxdccM2/vRHCoiY8GAV4DWrl3b5/ciIiLSN4vFYFKFj1gqy4qmED6XDZ+zu0R2MpkkkUjgcvV+vsd0+Eh2HoetczO2suUYRhy//3a6uu4A+r51rvv1LKTT6T34jkRERr8hVYH7uGw2y9KlS7ULtYiISB9m1BThslt5d1MXmWwOl8tFSUkJyWSy32d2sv464htOIpuuAsBmW4PX++BOX8disWgfIBGRXRhSALrmmmt48MHuD+FsNssxxxzDoYceSn19PS+99NJwjk9ERGTUs1oMDqwLkMzk+KA5DEAgEMDv9xOLxfo8JucuxzSKiG28AOjefNzt/hN2+7/7fZ1tAWiAd7eLiBSkIQWgp556ioMOOgiAZ599lnXr1vHBBx9wzTXXcNNNNw3rAEVERMYCr9PGzJoimoMJNnbEsFqtlJaWYhgGqVSq9wGGQbaoDrocRELz881+/88wjGCfr2GxWFQKW0RkF4YUgNra2qiurgbgueee45xzzmHatGlcdtllvPfee8M6QBERkbGiqshFfamHVa1hgvE0Ho+HkpIS4vF4n6s2WV8NYJBuPZhUajYAFksnfv8vgN79twUgVYITEenfkAJQVVUVy5cvJ5vN8sILL+Q3QI3Fuv+iJSIiIn2bWunD77Lz3qYgqUyO4uJiPB4P0Wi0d2eLnay3GlukiUj4K5imHwCH4zWczoW9u2sFSERkl4YUgD73uc9x7rnnMmvWLAzDyG+G+uabb7LffvsN6wBFRETGEovF4IDaAFnTZNmWIFarlbKyMkzT7LOAQdZfB9kURHKEw9v32fP5fonF0vSxc1u0F5CIyC4MKQDdcsstPPDAA1xxxRW89tprOJ1OAKxWKzfccMOwDlBERGSscdmtzBpXRHskxbr2GF6vl0Ag0GdBBNPhJecqxhbeRCr1HyQS3X907C6N/ROg52qPaZpaARIR2YkB7wP0cWeffXavtksuuWS3BiMiIlIoynxOGiq8rGmNUOSyUVJSQjQa7XNvoKy/DvvW9zGSIaLGlTgc72KxtGC3L8flepZE4sx8X8MwugPQsGx0ISIy9gw4AN11111cccUVuFwu7rrrrp32vfrqq3f6exEREYFJ5V6C8TTvbwlxeEMpxcXFtLa24nQ6MQwj3y/nLse0ubCGN5FxziQc/hqBwPUAeL2/JpU6klyuIt8/m80qAImI9MMwB7hZQENDA2+99RZlZWU0NDT0f0LDoLGxcdgGONxCoRCBQIBgMEhRUdFID0dERApcKpPjzbXtuO1WDhznZ8uWzaTTabxeb49+1tAGbF2NJGuPBKsDn+9OXK4Xus+ROoxQ6BbAIBwOU1JSQsqdojHYyDF1xwzbWDWHishYMOAVoLVr1/b5vYiIiAydw2bhwNpi3lrfwbrOBDVlZWzevJlsNtujsmrWV4Otay3W8GayxQ1Eo5fhcLyJxdKJw/EvnM5FJJPHYLFYSKfT4B7BNyUisg/TArmIiMgIC3jsTK30s6E9Rixno6ioqHdBhHxJ7C1g5jBNH5HIVflfe733YhhhLBZLn9XkRESk25AC0Nlnn80Pf/jDXu0//vGPOeecc3Z7UCIiIoVmfJmHqiIXy5vDOL1FWCwWUqlUjz7bSmJbYlsBSKWOIpU6AgCLpQuv9wEsFgvZbFaV4ERE+jGkAPTyyy9z2mmn9Wr/1Kc+xSuvvLLbgxIRESlEM2r8OK0WVrUn8fmLiMfj7Pio7o4lsbsZRCJfxDQ9ALhcL+J0rsE0TQb4iK+ISMEZUgCKRCI4HI5e7Xa7nVAotNuDEhERKUQ2q4UD6gLEU1lakjYcDgfJZLJHn6y/DiMZwkgGAcjlyonFPpv/vcu1lGw2q81QRUT6MaQANGvWLBYsWNCr/YknnmDmzJm7PSgREZFC5XfZ2a/GT1s0Q8LqIZlM9ljN2VYSe/sqEKRSh+a/t9vXajNUEZGdGNJGqN/+9rf5zGc+w5o1azj++OMB+Pvf/87jjz/Ok08+OawDFBERKTQ1ATed0TSbO6OMszuIx+N4PN23uWEYZP112LrWQDYFVgfZbB1gB9LYbApAIiI7M6QVoDPOOIM//vGPrF69mquuuoqvfe1rbNq0ib/97W+cddZZwzxEERGRwrNftZ8it4PNcRvxZKpHoMn6qgEDa3jzRy1WMpkJ3d9ZtwBxBSARkX4MaQUI4LTTTuuzEIKIiIjsPovF4MC6Yv7ZmKEpksBpj+Hz+T76pb17X6DIFrKBCWBYyGQmYbOtBkwcjo0kclNGdPwiIvuqIe8D1NXVxQMPPMA3v/lNOjo6AHj77bfZvHnzLo4UERGRgXA7rOxfGyBlcbI5mOpR2CDrq+1REjuTmZT/ncOxTkUQRET6MaQA9O677zJt2jT++7//mx//+Md0dXUB8Ic//IEbb7xxOMcnIiJS0Cr9LqbXltGWstLcGc63d5fELsEW2ghANrs9ADmdG7QZqohIP4YUgK699lrmz5/PqlWrcLlc+fZTTjlF+wCJiIgMsymVPsaVF7O6PUk0sb0sdtZfh5EKYySDZDIT8+1O53oFIBGRfgwpAP373//m85//fK/22tpampubd3tQIiIisp1hGMxuqMDj8fLexq58WeycuyxfEts0/eRyFQDY7evJZtOgvVBFRHoZUgByuVx9bnj64YcfUlFRsduDEhERkZ5cDhuHTa0hljVY3RrpbvyoJLYl2gqZZP45IIslgc2ylZypSnAiIh83pAB05plnctttt5FOp4Huv0xt2LCBG264gc985jPDOkARERHpVlPqZ0ZtKY1bw3TEuufgrK8aDAvWyBYymYZ8X5djA2ZOS0AiIh83pAD0k5/8hK1bt1JZWUk8HufYY49lypQp+P1+vv/97w/3GEVEROQjsyZWUel38f7mIMlMrkdJ7G0ByDDAYVuvvYBERPowpABUVFTEq6++ytNPP80Pf/hDvvSlL/Hcc8/x8ssv4/V6B3Wue+65h4aGBlwuF7Nnz2bRokUDOu61117DZrNx8MEHD+EdiIiIjE5Op5PZk6vIZTMsb46SM02y/u6S2LmQ/6NeBm7nRt0CJyLSh0FvhJrJZHC5XCxdupTjjz+e448/fsgvvmDBAq655hruuecejjrqKO677z5OOeUUli9fzvjx4/s9LhgMcvHFF3PCCSfQ0tIy5NcXEREZjcpKipk1rov3mmKsbbcxuby7JLalM4VZ68IwEridm8gFFYBERD5u0CtANpuNCRMmDMsGa3fccQeXXXYZl19+OTNmzODnP/859fX13HvvvTs97vOf/zwXXHABc+fO3e0xiIiIjDZ2u53x1RXU+gy2hJJsjaQ+KokdJZsaB4DT3obFjI/wSEVE9j1DugXuW9/6FjfeeCMdHR1DfuFUKsXixYuZN29ej/Z58+bx+uuv93vcww8/zJo1a7j55psH9DrJZJJQKNTjS0REZLTz+/1MrCiiyJZjVVucsLUY0+bGjJTk+7jsG0dwhCIi+6ZB3wIHcNddd7F69WrGjRvHhAkTej338/bbb+/yHG1tbWSzWaqqqnq0V1VV9buX0KpVq7jhhhtYtGgRNtvAhn777bdz6623DqiviIjIaGG1WikpKaE+GqMxbPBBa5xD/eNwhvxQmgMM3NZNIz1MEZF9zpAC0JlnnolhGMMygI+fxzTNPs+dzWa54IILuPXWW5k2bdqAz3/jjTdy7bXX5n8OhULU19cPfcAiIiL7CL/fT6DIzwSirA7mWJUIcLBtHEauu0S2x64AJCLycUMKQLfccstuv3B5eTlWq7XXak9ra2uvVSGAcDjMW2+9xZIlS/jSl74EQC6XwzRNbDYbL774Yp8FGZxOJ06nc7fHKyIisq+xWCwUFxcTjUaZVOpkVVuSLY4ZTMumMSx2PI7NIz1EEZF9zqCeAYrFYnzxi1+ktraWyspKLrjgAtra2ob0wg6Hg9mzZ7Nw4cIe7QsXLuTII4/s1b+oqIj33nuPpUuX5r+uvPJKpk+fztKlSzn88MOHNA4REZHRzOfz4ff78RhpagIOPojXkk4Ug5nF52wml8uM9BBFRPYpg1oBuvnmm3nkkUe48MILcblcPP7443zhC1/gySefHNKLX3vttVx00UXMmTOHuXPncv/997NhwwauvPJKoPv2tc2bN/Poo49isViYNWtWj+MrKytxuVy92kVERAqFYRgUFxcTiUSoL7IRSfppC9VR6lyKxWIjl1uPxTJ5pIcpIrLPGFQAeuaZZ3jwwQc5//zzAfjsZz/LUUcdRTabxWq1DvrFzzvvPNrb27nttttoampi1qxZPPfcc0yYMAGApqYmNmzYMOjzjpjMTsqNGlawOgbY1wJW59D6ZhNgmv30NcDqGmLfJOxsQz2be4h9U2DupKT6YPpaXd3jHva+zu7rDJBLw87+mrpX+ma6+/fH4gCLdQh9s5BL7aSvHSy2wfc1c93/Jvrta+vuP5J9d/zv0zS7/9sY7r6gz4gh9dVnxED6etwuioqKCAaD7Ffhois+haLMYrAbmOaHgAKQiMg2hmn2N7v15nA4WLt2LbW1tfk2t9vNypUrR01hgVAoRCAQIBgMUlRUNLwnf2FO/78rPwrm3Ln954X/0f//OJUcCoffv/3nv58I6a6++xbNhCMf3f7zS6dDoqnvvr5J8B+/3/7zq+dCpLHvvq4a+OSz239+/WIILe+7r70YTvjb9p/fvAI6+6kEaHXBSa9u//mtr0Dba333BfjUW9u/X/INaPl7/31PXLT9f4bevQW2/Ln/vscvBMdHpWKX/zds2Mkq5jF/Ak/3vhp8cCes+03/ff/j993XGWD1/d1f/Zn7KARmdn/f+CisvKv/vofdB6Wzu79f/3tY8aP++x76c6j8j+7vNz0L7++kCuLBP4TqE7u/b/4bLL2h/76zboa607u/b30V3r6m/74zrocJ53Z/37EY/vX5/vtOuxomXdz9fXA5vHFx/32nXNH9Bd3/dl89t/++Ey+C/b7S/X1sC7xyRv99x58DM7/R/X2qE/5xUv99x/1/cOAt3d9n4vC3o/vvW3UCHPLf23/WZ0Q3fUZ0fz/MnxFx90y2bNmCs+V/KU3fhWPWFjqtlQQ81+FwXNP/sYOwR+dQEZG9ZFArQNlsFofD0aPNZrORyej+YhERkZHkdrupra0lmyrBtsEDhoGZy2KaH4z00ERE9imDWgGyWCyccsopPaqqPfvssxx//PE99gJ65plnhneUw2iP/vVKt7cMoa9ubxl8X90CN+x9dQvcR331GTG0vvviZ0SKLOeSTFfgch6NxXJp/8cOglaARGQsGFQA+tznPjegfg8//PCQB7Sn6cNbRERkaDSHishYMKhb4PblYCMiIiIiIrIrg9oHSEREREREZDRTABIRERERkYKhACQiIiIiIgVDAUhERERERAqGApCIiIiIiBQMBSARERERESkYCkAiIiIiIlIwFIBERERERKRgKACJiIiIiEjBUAASEREREZGCoQAkIiIiIiIFQwFIREREREQKhgKQiIiIiIgUDAUgEREREREpGApAIiIiIiJSMBSARERERESkYCgAiYiIiIhIwVAAEhERERGRgqEAJCIiIiIiBUMBSERERERECoYCkIiIiIiIFAwFIBERERERKRgKQCIiIiIiUjAUgEREREREpGAoAImIiIiISMFQABIRERERkYKhACQiIiIiIgVDAUhERERERAqGApCIiIiIiBQMBSARERERESkYCkAiIiIiIlIwFIBERERERKRgKACJiIiIiEjBUAASEREREZGCoQAkIiIiIiIFQwFIREREREQKhgKQiIiIiIgUDAUgEREREREpGApAIiIiIiJSMBSARERERESkYCgAiYiIiIhIwVAAEhERERGRgqEAJCIiIiIiBUMBSERERERECoYCkIiIiIiIFAwFIBERERERKRgKQCIiIiIiUjAUgEREREREpGAoAImIiIiISMFQABIRERERkYKhACQiIiIiIgVDAUhERERERAqGApCIiIiIiBQMBSARERERESkYCkAiIiIiIlIwFIBERERERKRgKACJiIiIiEjBUAASEREREZGCoQAkIiIiIiIFQwFIREREREQKhgKQiIiIiIgUDAUgEREREREpGApAIiIiIiJSMBSARERERESkYCgAiYiIiIhIwVAAEhERERGRgqEAJCIiIiIiBUMBSERERERECoYCkIiIiIiIFIwRD0D33HMPDQ0NuFwuZs+ezaJFi/rt+8wzz3DSSSdRUVFBUVERc+fO5a9//eteHK2IiIiIiIxmIxqAFixYwDXXXMNNN93EkiVLOProoznllFPYsGFDn/1feeUVTjrpJJ577jkWL17Mcccdx+mnn86SJUv28shFRERERGQ0MkzTNEfqxQ8//HAOPfRQ7r333nzbjBkzOOuss7j99tsHdI7999+f8847j+985zsD6h8KhQgEAgSDQYqKioY0bhERkUKkOVRExoIRWwFKpVIsXryYefPm9WifN28er7/++oDOkcvlCIfDlJaW9tsnmUwSCoV6fImIiIiISGEasQDU1tZGNpulqqqqR3tVVRXNzc0DOsdPf/pTotEo5557br99br/9dgKBQP6rvr5+t8YtIiIiIiKj14gXQTAMo8fPpmn2auvL448/zi233MKCBQuorKzst9+NN95IMBjMf23cuHG3xywiIiIiIqOTbaReuLy8HKvV2mu1p7W1tdeq0MctWLCAyy67jCeffJITTzxxp32dTidOp3O3xysiIiIiIqPfiK0AORwOZs+ezcKFC3u0L1y4kCOPPLLf4x5//HHmz5/PY489xmmnnbanhykiIiIiImPIiK0AAVx77bVcdNFFzJkzh7lz53L//fezYcMGrrzySqD79rXNmzfz6KOPAt3h5+KLL+bOO+/kiCOOyK8eud1uAoHAiL0PEREREREZHUY0AJ133nm0t7dz22230dTUxKxZs3juueeYMGECAE1NTT32BLrvvvvIZDJ88Ytf5Itf/GK+/ZJLLuGRRx7Z28MXEREREZFRZkT3ARoJ2sNARERkaDSHishYMOJV4ERERERERPYWBSARERERESkYCkAiIiIiIlIwFIBERERERKRgKACJiIiIiEjBUAASEREREZGCoQAkIiIiIiIFQwFIREREREQKhgKQiIiIiIgUDAUgEREREREpGApAIiIiIiJSMBSARERERESkYCgAiYiIiIhIwVAAEhERERGRgqEAJCIiIiIiBUMBSERERERECoYCkIiIiIiIFAwFIBERERERKRgKQCIiIiIiUjAUgEREREREpGAoAImIiIiISMFQABIRERERkYKhACQiIiIiIgVDAUhERERERAqGApCIiIiIiBQMBSARERERESkYCkAiIiIiIlIwFIBERERERKRgKACJiIiIiEjBUAASEREREZGCoQAkIiIiIiIFQwFIREREREQKhgKQiIiIiIgUDAUgEREREREpGApAIiIiIiJSMBSARERERESkYCgAiYiIiIhIwVAAEhERERGRgqEAJCIiIiIiBUMBSERERERECoYCkIiIiIiIFAwFIBERERERKRgKQCIiIiIiUjAUgEREREREpGAoAImIiIiISMFQABIRERERkYKhACQiIiIiIgVDAUhERERERAqGApCIiIiIiBQMBSARERERESkYCkAiIiIiIlIwFIBERERERKRgKACJiIiIiEjBUAASEREREZGCoQAkIiIiIiIFQwFIREREREQKhgKQiIiIiIgUDAUgEREREREpGApAIiIiIiJSMBSARERERESkYCgAiYiIiIhIwVAAEhERERGRgqEAJCIiIiIiBUMBSERERERECoYCkIiIiIiIFAwFIBERERERKRgKQCIiIiIiUjAUgEREREREpGAoAImIiIiISMFQABIRERERkYKhACQiIiIiIgVDAUhERERERAqGApCIiIiIiBSMEQ9A99xzDw0NDbhcLmbPns2iRYt22v/ll19m9uzZuFwuJk2axC9/+cu9NFIRERERERntRjQALViwgGuuuYabbrqJJUuWcPTRR3PKKaewYcOGPvuvXbuWU089laOPPpolS5bwzW9+k6uvvpqnn356L49cRERERERGI8M0TXOkXvzwww/n0EMP5d577823zZgxg7POOovbb7+9V/9vfOMb/OlPf2LFihX5tiuvvJJ33nmHN954Y0CvGQqFCAQCBINBioqKdv9NiIiIFAjNoSIyFozYClAqlWLx4sXMmzevR/u8efN4/fXX+zzmjTfe6NX/5JNP5q233iKdTvd5TDKZJBQK9fgSEREREZHCNGIBqK2tjWw2S1VVVY/2qqoqmpub+zymubm5z/6ZTIa2trY+j7n99tsJBAL5r/r6+uF5AyIiIiIiMuqMeBEEwzB6/GyaZq+2XfXvq32bG2+8kWAwmP/auHHjbo5YRERERERGK9tIvXB5eTlWq7XXak9ra2uvVZ5tqqur++xvs9koKyvr8xin04nT6RyeQYuIiIiIyKg2YitADoeD2bNns3Dhwh7tCxcu5Mgjj+zzmLlz5/bq/+KLLzJnzhzsdvseG6uIiIiIiIwNI3oL3LXXXssDDzzAQw89xIoVK/jqV7/Khg0buPLKK4Hu29cuvvjifP8rr7yS9evXc+2117JixQoeeughHnzwQa677rqRegsiIiIiIjKKjNgtcADnnXce7e3t3HbbbTQ1NTFr1iyee+45JkyYAEBTU1OPPYEaGhp47rnn+OpXv8rdd9/NuHHjuOuuu/jMZz4zUm9BRERERERGkRHdB2gkaA8DERGRodEcKiJjwYhXgRMREREREdlbFIBERERERKRgKACJiIiIiEjBUAASEREREZGCoQAkIiIiIiIFQwFIREREREQKhgKQiIiIiIgUDAUgEREREREpGApAIiIiIiJSMBSARERERESkYCgAiYiIiIhIwVAAEhERERGRgqEAJCIiIiIiBcM20gPY20zTBCAUCo3wSEREREaXbXPntrlURGQ0KrgAFA6HAaivrx/hkYiIiIxO4XCYQCAw0sMQERkSwyywP+Pkcjm2bNmC3+/HMIxhO28oFKK+vp6NGzdSVFQ0bOctVLqew0/XdHjpeg4/XdPhtSeup2mahMNhxo0bh8Wiu+hFZHQquBUgi8VCXV3dHjt/UVGRJu5hpOs5/HRNh5eu5/DTNR1ew309tfIjIqOd/nwjIiIiIiIFQwFIREREREQKhgLQMHE6ndx88804nc6RHsqYoOs5/HRNh5eu5/DTNR1eup4iIn0ruCIIIiIiIiJSuLQCJCIiIiIiBUMBSERERERECoYCkIiIiIiIFAwFIBERERERKRgKQAN0zz330NDQgMvlYvbs2SxatGin/V9++WVmz56Ny+Vi0qRJ/PKXv9xLIx09BnNNn3nmGU466SQqKiooKipi7ty5/PWvf92Lo933Dfbf6DavvfYaNpuNgw8+eM8OcBQa7DVNJpPcdNNNTJgwAafTyeTJk3nooYf20mhHh8Fe09/97nccdNBBeDweampq+NznPkd7e/teGu2+7ZVXXuH0009n3LhxGIbBH//4x10eo7lJREQBaEAWLFjANddcw0033cSSJUs4+uijOeWUU9iwYUOf/deuXcupp57K0UcfzZIlS/jmN7/J1VdfzdNPP72XR77vGuw1feWVVzjppJN47rnnWLx4Mccddxynn346S5Ys2csj3zcN9npuEwwGufjiiznhhBP20khHj6Fc03PPPZe///3vPPjgg3z44Yc8/vjj7Lfffntx1Pu2wV7TV199lYsvvpjLLruMZcuW8eSTT/Lvf/+byy+/fC+PfN8UjUY56KCD+J//+Z8B9dfcJCLyEVN26bDDDjOvvPLKHm377befecMNN/TZ//rrrzf322+/Hm2f//znzSOOOGKPjXG0Gew17cvMmTPNW2+9dbiHNioN9Xqed9555re+9S3z5ptvNg866KA9OMLRZ7DX9PnnnzcDgYDZ3t6+N4Y3Kg32mv74xz82J02a1KPtrrvuMuvq6vbYGEcrwPzDH/6w0z6am0REumkFaBdSqRSLFy9m3rx5PdrnzZvH66+/3ucxb7zxRq/+J598Mm+99RbpdHqPjXW0GMo1/bhcLkc4HKa0tHRPDHFUGer1fPjhh1mzZg0333zznh7iqDOUa/qnP/2JOXPm8KMf/Yja2lqmTZvGddddRzwe3xtD3ucN5ZoeeeSRbNq0ieeeew7TNGlpaeGpp57itNNO2xtDHnM0N4mIdLON9AD2dW1tbWSzWaqqqnq0V1VV0dzc3Ocxzc3NffbPZDK0tbVRU1Ozx8Y7Ggzlmn7cT3/6U6LRKOeee+6eGOKoMpTruWrVKm644QYWLVqEzaaPgY8byjVtbGzk1VdfxeVy8Yc//IG2tjauuuoqOjo69BwQQ7umRx55JL/73e8477zzSCQSZDIZzjjjDH7xi1/sjSGPOZqbRES6aQVogAzD6PGzaZq92nbVv6/2QjbYa7rN448/zi233MKCBQuorKzcU8MbdQZ6PbPZLBdccAG33nor06ZN21vDG5UG8280l8thGAa/+93vOOywwzj11FO54447eOSRR7QKtIPBXNPly5dz9dVX853vfIfFixfzwgsvsHbtWq688sq9MdQxSXOTiIhWgHapvLwcq9Xa6y+Ura2tvf6Stk11dXWf/W02G2VlZXtsrKPFUK7pNgsWLOCyyy7jySef5MQTT9yTwxw1Bns9w+Ewb731FkuWLOFLX/oS0P0/76ZpYrPZePHFFzn++OP3ytj3VUP5N1pTU0NtbS2BQCDfNmPGDEzTZNOmTUydOnWPjnlfN5Rrevvtt3PUUUfx9a9/HYADDzwQr9fL0Ucfzfe+9z2tWAyS5iYRkW5aAdoFh8PB7NmzWbhwYY/2hQsXcuSRR/Z5zNy5c3v1f/HFF5kzZw52u32PjXW0GMo1he6Vn/nz5/PYY4/pGYAdDPZ6FhUV8d5777F06dL815VXXsn06dNZunQphx9++N4a+j5rKP9GjzrqKLZs2UIkEsm3rVy5EovFQl1d3R4d72gwlGsai8WwWHpOU1arFdi+ciEDp7lJROQjI1R8YVR54oknTLvdbj744IPm8uXLzWuuucb0er3munXrTNM0zRtuuMG86KKL8v0bGxtNj8djfvWrXzWXL19uPvjgg6bdbjefeuqpkXoL+5zBXtPHHnvMtNls5t133202NTXlv7q6ukbqLexTBns9P05V4Hob7DUNh8NmXV2defbZZ5vLli0zX375ZXPq1Knm5ZdfPlJvYZ8z2Gv68MMPmzabzbznnnvMNWvWmK+++qo5Z84c87DDDhupt7BPCYfD5pIlS8wlS5aYgHnHHXeYS5YsMdevX2+apuYmEZH+KAAN0N13321OmDDBdDgc5qGHHmq+/PLL+d9dcskl5rHHHtuj/0svvWQecsghpsPhMCdOnGjee++9e3nE+77BXNNjjz3WBHp9XXLJJXt/4Puowf4b3ZECUN8Ge01XrFhhnnjiiabb7Tbr6urMa6+91ozFYnt51Pu2wV7Tu+66y5w5c6bpdrvNmpoa88ILLzQ3bdq0l0e9b/q///u/nX4uam4SEembYZq6j0BERERERAqDngESEREREZGCoQAkIiIiIiIFQwFIREREREQKhgKQiIiIiIgUDAUgEREREREpGApAIiIiIiJSMBSARERERESkYCgAiYiIiIhIwVAAEpF+TZw4kZ///Of5nw3D4I9//ONOj2lvb6eyspJ169bt0bENxrp16zAMg6VLl+603yc/+UmuueaaAZ93/vz5nHXWWbs1tmQyyfjx41m8ePFunUdEREQGRgFIZB80f/58DMPAMAxsNhvjx4/nC1/4Ap2dnSM9tF26/fbbOf3005k4cWK+7emnn+bwww8nEAjg9/vZf//9+drXvrbXxlRfX09TUxOzZs0C4KWXXsIwDLq6unr0e+aZZ/jud7874PPeeeedPPLII/mfBxugAJxOJ9dddx3f+MY3BnWciIiIDI0CkMg+6lOf+hRNTU2sW7eOBx54gGeffZarrrpqpIe1U/F4nAcffJDLL7883/a3v/2N888/n7PPPpt//etfLF68mO9///ukUqm9Ni6r1Up1dTU2m22n/UpLS/H7/QM+byAQoLi4eDdHBxdeeCGLFi1ixYoVu30uERER2TkFIJF9lNPppLq6mrq6OubNm8d5553Hiy++2KPPww8/zIwZM3C5XOy3337cc889PX6/adMmzj//fEpLS/F6vcyZM4c333wTgDVr1nDmmWdSVVWFz+fjE5/4BH/72992a8zPP/88NpuNuXPn5tv+/Oc/8x//8R98/etfZ/r06UybNo2zzjqLX/ziFz2OffbZZ5k9ezYul4tJkyZx6623kslk8r83DIMHHniAT3/603g8HqZOncqf/vSn/O87Ozu58MILqaiowO12M3XqVB5++GGg5y1w69at47jjjgOgpKQEwzCYP38+0HMF58Ybb+SII47o9R4PPPBAbr75ZqDnLXDz58/n5Zdf5s4778yv3q1du5YpU6bwk5/8pMc53n//fSwWC2vWrAGgrKyMI488kscff3ywl1xEREQGSQFIZBRobGzkhRdewG6359t+9atfcdNNN/H973+fFStW8IMf/IBvf/vb/PrXvwYgEolw7LHHsmXLFv70pz/xzjvvcP3115PL5fK/P/XUU/nb3/7GkiVLOPnkkzn99NPZsGHDkMf5yiuvMGfOnB5t1dXVLFu2jPfff7/f4/7617/y2c9+lquvvprly5dz33338cgjj/D973+/R79bb72Vc889l3fffZdTTz2VCy+8kI6ODgC+/e1vs3z5cp5//nlWrFjBvffeS3l5ea/Xqq+v5+mnnwbgww8/pKmpiTvvvLNXvwsvvJA333wzH1IAli1bxnvvvceFF17Yq/+dd97J3Llz+a//+i+amppoampi/PjxXHrppfkgts1DDz3E0UcfzeTJk/Nthx12GIsWLer3GomIiMgwMUVkn3PJJZeYVqvV9Hq9psvlMgETMO+44458n/r6evOxxx7rcdx3v/tdc+7cuaZpmuZ9991n+v1+s729fcCvO3PmTPMXv/hF/ucJEyaYP/vZz/I/A+Yf/vCHfo8/88wzzUsvvbRHWyQSMU899VQTMCdMmGCed9555oMPPmgmEol8n6OPPtr8wQ9+0OO43/zmN2ZNTU2P1/7Wt77V47yGYZjPP/+8aZqmefrpp5uf+9zn+hzX2rVrTcBcsmSJaZqm+X//938mYHZ2dvbod+yxx5pf+cpX8j8feOCB5m233Zb/+cYbbzQ/8YlP5H++5JJLzDPPPLPf403TNLds2WJarVbzzTffNE3TNFOplFlRUWE+8sgjPfrdeeed5sSJE/scv4iIiAwfrQCJ7KOOO+44li5dyptvvsmXv/xlTj75ZL785S8DsHXrVjZu3Mhll12Gz+fLf33ve9/Lr1gsXbqUQw45hNLS0j7PH41Guf7665k5cybFxcX4fD4++OCD3VoBisfjuFyuHm1er5e//OUvrF69mm9961v4fD6+9rWvcdhhhxGLxQBYvHgxt912W4/3sm0lZVsf6L79bMfz+v1+WltbAfjCF77AE088wcEHH8z111/P66+/PuT3sc2FF17I7373OwBM0+Txxx/vc/VnZ2pqajjttNN46KGHgO5bAhOJBOecc06Pfm63u8d7FRERkT1DAUhkH+X1epkyZQoHHnggd911F8lkkltvvRUgfxvbr371K5YuXZr/ev/99/nnP/8JdP8P9c58/etf5+mnn+b73/8+ixYtYunSpRxwwAG7VZygvLy830p1kydP5vLLL+eBBx7g7bffZvny5SxYsCD/fm699dYe7+W9995j1apVPQLVjrcAQvdzQduuxSmnnML69eu55ppr2LJlCyeccALXXXfdkN8LwAUXXMDKlSt5++23ef3119m4cSPnn3/+oM9z+eWX88QTTxCPx3n44Yc577zz8Hg8Pfp0dHRQUVGxW+MVERGRXdt5SSQR2WfcfPPNnHLKKXzhC19g3Lhx1NbW0tjY2O+KxIEHHsgDDzxAR0dHn6tAixYtYv78+Xz6058Gup8J2t29ew455BB++9vf7rLfxIkT8Xg8RKNRAA499FA+/PBDpkyZsluvX1FRwfz585k/fz5HH300X//613sVIABwOBwAZLPZnZ6vrq6OY445ht/97nfE43FOPPFEqqqq+u3vcDj6POepp56K1+vl3nvv5fnnn+eVV17p1ef999/nkEMO2dVbFBERkd2kFSCRUeKTn/wk+++/Pz/4wQ8AuOWWW7j99tu58847WblyJe+99x4PP/wwd9xxBwD/+Z//SXV1NWeddRavvfYajY2NPP3007zxxhsATJkyhWeeeYalS5fyzjvvcMEFF+RXU4bq5JNPZtmyZT1WgW655Rauv/56XnrpJdauXcuSJUu49NJLSafTnHTSSQB85zvf4dFHH+WWW25h2bJlrFixggULFvCtb31rwK/9ne98h//93/9l9erVLFu2jD//+c/MmDGjz74TJkzAMAz+/Oc/s3XrViKRSL/nvfDCC3niiSd48skn+exnP7vTMUycOJE333yTdevW0dbWlr+eVquV+fPnc+ONNzJlypQeVfK2WbRoEfPmzRvw+xUREZGhUQASGUWuvfZafvWrX7Fx48b87WSPPPIIBxxwAMceeyyPPPIIDQ0NQPdqxIsvvkhlZSWnnnoqBxxwAD/84Q+xWq0A/OxnP6OkpIQjjzyS008/nZNPPplDDz10t8Z3wAEHMGfOHH7/+9/n24499lgaGxu5+OKL2W+//TjllFNobm7mxRdfZPr06UB3cPrzn//MwoUL+cQnPsERRxzBHXfcwYQJEwb82g6HgxtvvJEDDzyQY445BqvVyhNPPNFn39raWm699VZuuOEGqqqq+NKXvtTvec855xza29uJxWL5ktf9ue6667BarcycOZOKiooez1NddtllpFIpLr300l7HvfHGGwSDQc4+++yBvVkREREZMsM0TXOkByEiY8dzzz3Hddddl9/rRrq99tprfPKTn2TTpk29bqM755xzOOSQQ/jmN785QqMTEREpHHoGSESG1amnnsqqVavYvHkz9fX1Iz2cEZdMJtm4cSPf/va3Offcc3uFn2QyyUEHHcRXv/rVERqhiIhIYdEKkIjIHvTII49w2WWXcfDBB/OnP/2J2trakR6SiIhIQVMAEhERERGRgqEb9EVEREREpGAoAImIiIiISMFQABIRERERkYKhACQiIiIiIgVDAUhERERERAqGApCIiIiIiBQMBSARERERESkYCkAiIiIiIlIw/n/BSIm0XrvWFAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "(-0.05, 1.05)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "(-0.05, 1.05)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Logistic Regression')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'False Positive Rate')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'True Positive Rate')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "(-0.05, 1.05)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "(-0.05, 1.05)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Logistic Regression')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Recall (Sensitivity)')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Precision (PPV)')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "(-0.05, 1.05)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "(-0.05, 1.05)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Naive Bayes')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'False Positive Rate')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'True Positive Rate')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "(-0.05, 1.05)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "(-0.05, 1.05)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Naive Bayes')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Recall (Sensitivity)')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Precision (PPV)')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhgAAAKECAYAAABFIEMoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABVQ0lEQVR4nO3deVyVdf7//+dh3wRFEzdE1BQRN7ASTctS1CylTRtL07B0nBaipsGPH/fSxtJs08ncm0Ydt6bFKfjmkmZlIpqmWCoKIYRLioriAc7vDz+e3zCgceg6XHF43G83bnje57re53VOF/Dsfb2v92Wx2Ww2AQAAGMjN7AIAAIDrIWAAAADDETAAAIDhCBgAAMBwBAwAAGA4AgYAADAcAQMAABiOgAEAAAznYXYB1a20tFTHjx9XnTp1ZLFYzC4HAIAaw2az6dy5c2rSpInc3K4/RlHrAsbx48cVGhpqdhkAANRY2dnZatas2XW3qXUBo06dOpKufDiBgYEmV1NzWK1WpaSkKC4uTp6enmaXAxfGsYbqwrHmuIKCAoWGhtr/ll5PrQsYV0+LBAYGEjAcYLVa5efnp8DAQH4Q4VQca6guHGtVV5kpBkzyBAAAhiNgAAAAwxEwAACA4QgYAADAcAQMAABgOAIGAAAwHAEDAAAYjoABAAAMR8AAAACGI2AAAADDETAAAIDhCBgAAMBwBAwAAGA4AgYAADAcAQMAABiOgAEAAAxHwAAAAIbzMLsAAACMUFhYqIyMjEpvf/5ikbbvPax6DXYqwNe70vtFRETIz8+vKiXWKgQMAIBLyMjIUExMjMP7zXJw+7S0NEVHRzv8OrUNAQMA4BIiIiKUlpZW6e0P5p5R0uq9mvNgB7VtXNeh18GvI2AAAFyCn5+fQyMLbsdOyXvrRbWL6qTOYfWdWFntxCRPAABgOAIGAAAwHAEDAAAYjoABAAAMR8AAAACGI2AAAADDETAAAIDhCBgAAMBwBAwAAGA4AgYAADAcS4UDcCrucAnUTgQMAE7FHS6B2omAAcCpuMMlUDsRMAA4FXe4BGonJnkCAADDETAAAIDhCBgAAMBwBAwAAGA4AgYAADAcAQMAABiOgAEAAAxHwAAAAIYjYAAAAMOZHjDmzZun8PBw+fj4KCYmRlu3br3u9m+//bbatWsnX19ftW3bVsuXL6+mSgEAQGWZulT4qlWrlJiYqHnz5qlHjx565513NGDAAO3fv1/Nmzcvt/38+fM1fvx4vfvuu7rpppu0Y8cOPf7446pXr57uueceE94BAACoiKkjGHPmzFFCQoJGjx6tdu3aae7cuQoNDdX8+fMr3P69997TmDFjNHToULVs2VIPPfSQEhIS9Ne//rWaKwcAANdj2gjG5cuXlZaWpuTk5DLtcXFx2r59e4X7FBUVycfHp0ybr6+vduzYIavVKk9Pzwr3KSoqsj8uKCiQJFmtVlmt1t/6NmqNq58Vnxmcrbi42P6d4w3OxLHmOEc+J9MCxsmTJ1VSUqKQkJAy7SEhIcrLy6twn379+mnhwoWKj49XdHS00tLStHjxYlmtVp08eVKNGzcut8/MmTM1derUcu0pKSny8/Mz5s3UIqmpqWaXABeXfV6SPPT1118rZ5/Z1cCVcaw5rrCwsNLbmn67dovFUuaxzWYr13bVxIkTlZeXp27duslmsykkJEQjR47UrFmz5O7uXuE+48ePV1JSkv1xQUGBQkNDFRcXp8DAQOPeiIuzWq1KTU1V3759KxwpAoyyJ+u0tHenunXrpk7Ng80uBy6MY81xV88CVIZpAaNBgwZyd3cvN1qRn59fblTjKl9fXy1evFjvvPOOfv75ZzVu3FgLFixQnTp11KBBgwr38fb2lre3d7l2T09P/lBWAZ8bnM3Dw8P+nWMNzsSx5jhHPifTJnl6eXkpJiam3JB7amqqunfvft19PT091axZM7m7u2vlypW6++675eZm+hW3AADg/5h6iiQpKUnDhw9X165dFRsbqwULFigrK0tjx46VdOX0Rk5Ojn2tix9++EE7duzQLbfcol9++UVz5szRvn37tGzZMjPfBgAA+C+mBoyhQ4fq1KlTmjZtmnJzcxUVFaUNGzYoLCxMkpSbm6usrCz79iUlJZo9e7YOHjwoT09P9e7dW9u3b1eLFi1MegcAAKAipk/yHDdunMaNG1fhc0uXLi3zuF27dkpPT6+GqgAAwG/BxAUAAGA4AgYAADAcAQMAABiOgAEAAAxn+iRPADVT5skLulBUbHi/h09csH+/uhCSkfy9PRTewN/wfgGURcAA4LDMkxfU+9XNTn2N59bsdVrfm56/nZABOBkBA4DDro5czB3aWa0bBhjb98Uifbz5K919e6z8fcsv8/9bHMo/r8RVu50y8gKgLAIGgCpr3TBAUU2DDO3TarUq7wYpOqwe94cAajAmeQIAAMMRMAAAgOEIGAAAwHAEDAAAYDgCBgAAMBwBAwAAGI6AAQAADEfAAAAAhiNgAAAAwxEwAACA4QgYAADAcAQMAABgOAIGAAAwHAEDAAAYjoABAAAMR8AAAACGI2AAAADDETAAAIDhCBgAAMBwBAwAAGA4AgYAADAcAQMAABiOgAEAAAxHwAAAAIbzMLsAADVPUcklufnkKLPgoNx8Agztu7i4WMeLj+vA6QPy8DD2V1RmwXm5+eSoqOSSpCBD+wZQFgEDgMOOXzgm//A39T87nPca8z6d55R+/cOl4xc6K0YhTukfwBUEDAAOa+IfpguZT+n1oZ3VqqHxIxhfbvtSPW7tYfgIxuH883pm1W416R1maL8AyiNgAHCYt7uPSi81VXhgW0XWN/ZUg9VqVaZHptoFt5Onp6ehfZdeOqvSSyfk7e5jaL8AymOSJwAAMBwBAwAAGI6AAQAADMccDAAOu2gtkSTtyzlreN8XLhZp5wmp0bFf5O/rbWjfh/LPG9ofgGsjYABw2OH/+0OdvG6vk17BQ+8d+tZJfUv+3vzqA5yNnzIADotr30iS1KphgHw93Q3t+2DuWT23Zq9mP9BBbRsbvxiWv7eHwhv4G94vgLIIGAAcFuzvpYdubu6UvouLiyVJrW7wV1RTVtsEaiomeQIAAMMRMAAAgOEIGAAAwHDMwQDgVIWFhcrIyKj09gdzz6go75AO7PNV6am6ld4vIiJCfn5+VagQgDMQMAA4VUZGhmJiYhzeb9gyx7ZPS0tTdHS0w68DwDlMDxjz5s3TK6+8otzcXLVv315z585Vz549r7n9+++/r1mzZunHH39UUFCQ+vfvr1dffVX169evxqoBVFZERITS0tIqvf35i0X6ZNNXGtg7VgEOLLQVERFRlfIAOImpAWPVqlVKTEzUvHnz1KNHD73zzjsaMGCA9u/fr+bNy18Ct23bNo0YMUKvvfaa7rnnHuXk5Gjs2LEaPXq01q9fb8I7APBr/Pz8HBpZsFqt+uVkvmJv7mr43VQBVB9TJ3nOmTNHCQkJGj16tNq1a6e5c+cqNDRU8+fPr3D7r7/+Wi1atNDTTz+t8PBw3XrrrRozZox27txZzZUDAIDrMW0E4/Lly0pLS1NycnKZ9ri4OG3fvr3Cfbp3764JEyZow4YNGjBggPLz87VmzRoNHDjwmq9TVFSkoqIi++OCggJJV/4vyWq1GvBOaoernxWfGZyNYw3V5eqibsXFxRxvleTI52RawDh58qRKSkoUEhJSpj0kJER5eXkV7tO9e3e9//77Gjp0qC5duqTi4mINGjRIb7755jVfZ+bMmZo6dWq59pSUFGacV0FqaqrZJaCW4FiDs2WflyQPff3118rZZ3Y1NUNhYWGltzV9kqfFYinz2GazlWu7av/+/Xr66ac1adIk9evXT7m5ufrzn/+ssWPHatGiRRXuM378eCUlJdkfFxQUKDQ0VHFxcQoMDDTujbg4q9Wq1NRU9e3bl/PicCqONfy3o6cu6EJRieH9FuWdlfYeUMPWHRTWyBn3vXFXi/qudd+bq2cBKsO0gNGgQQO5u7uXG63Iz88vN6px1cyZM9WjRw/9+c9/liR17NhR/v7+6tmzp1588UU1bty43D7e3t7y9i4/E93T05NfXlXA54bqwrEGSco8eUF9537p1Nd4Yf0Bp/W96fnbXermeo78TJoWMLy8vBQTE6PU1FTde++99vbU1FQNHjy4wn0KCwvl4VG2ZHf3K3dytNlszisWAGCKC0VX5knMHdpZrRsGGNv3xSJ9vPkr3X17rPwduCS6Mg7ln1fiqt32+msjU0+RJCUlafjw4eratatiY2O1YMECZWVlaezYsZKunN7IycnR8uXLJUn33HOPHn/8cc2fP99+iiQxMVE333yzmjRpYuZbAQA4UeuGAYbfXddqtSrvBik6rB6jZU5gasAYOnSoTp06pWnTpik3N1dRUVHasGGDwsLCJEm5ubnKysqybz9y5EidO3dOb731lp577jnVrVtXd9xxh/7617+a9RYAAEAFTJ/kOW7cOI0bN67C55YuXVqu7amnntJTTz3l5KoAAMBvwd1UAQCA4QgYAADAcAQMAABgOAIGAAAwHAEDAAAYjoABAAAMR8AAAACGI2AAAADDETAAAIDhCBgAAMBwBAwAAGA4AgYAADAcAQMAABiOgAEAAAxHwAAAAIbzMLsAmKOwsFAZGRmV3v78xSJt33tY9RrsVICvd6X3i4iIkJ+fX1VKBADUYASMWiojI0MxMTEO7zfLwe3T0tIUHR3t8OsAAGo2AkYtFRERobS0tEpvfzD3jJJW79WcBzuobeO6Dr0OAKD2IWDUUn5+fg6NLLgdOyXvrRfVLqqTOofVd2JlAABXwCRPAABgOAIGAAAwHAEDAAAYjoABAAAMR8AAAACGI2AAAADDETAAAIDhCBgAAMBwBAwAAGA4AgYAADAcAQMAABiOgAEAAAxHwAAAAIYjYAAAAMMRMAAAgOEIGAAAwHAEDAAAYDgPswuAsTJPXtCFomLD+z184oL9u4eH8YeNv7eHwhv4G94vAMAcBAwXknnygnq/utmpr/Hcmr1O63vT87cTMgDARRAwXMjVkYu5QzurdcMAY/u+WKSPN3+lu2+Plb+vt6F9H8o/r8RVu50y8gIAMAcBwwW1bhigqKZBhvZptVqVd4MUHVZPnp6ehvYNAHA9TPIEAACGI2AAAADDETAAAIDhCBgAAMBwBAwAAGA4AgYAADAcAQMAABiOgAEAAAxnesCYN2+ewsPD5ePjo5iYGG3duvWa244cOVIWi6XcV/v27auxYgAA8GtMDRirVq1SYmKiJkyYoPT0dPXs2VMDBgxQVlZWhdu//vrrys3NtX9lZ2crODhYDz74YDVXDgAArsfUgDFnzhwlJCRo9OjRateunebOnavQ0FDNnz+/wu2DgoLUqFEj+9fOnTv1yy+/aNSoUdVcOQAAuB7T7kVy+fJlpaWlKTk5uUx7XFyctm/fXqk+Fi1apD59+igsLOya2xQVFamoqMj+uKCgQNKVe2tYrdYqVP77VVxcbP9u9Hu72p8zPjNn1o2ax5nHGmoefq/9vjjyXhwKGAcPHtSKFSu0detWHT16VIWFhbrhhhvUpUsX9evXT/fff7+8vSt3p82TJ0+qpKREISEhZdpDQkKUl5f3q/vn5ubq3//+t/7xj39cd7uZM2dq6tSp5dpTUlLk5+dXqVpriuzzkuShbdu26ZixN1O1S01NNbzP6qgbNY8zjjXUPPxe+30pLCys9LaVChjp6el64YUXtHXrVnXv3l0333yz4uPj5evrq9OnT2vfvn2aMGGCnnrqKb3wwgtKTEysdNCwWCxlHttstnJtFVm6dKnq1q2r+Pj46243fvx4JSUl2R8XFBQoNDRUcXFxCgwMrFSNNcX3xwv06t6vdeutt6p9E2Pfm9VqVWpqqvr27Wv43VSdWTdqHmcea6h5+L32+3L1LEBlVCpgxMfH689//rNWrVql4ODga2731Vdf6bXXXtPs2bP1P//zP9fts0GDBnJ3dy83WpGfn19uVOO/2Ww2LV68WMOHD5eXl9d1t/X29q4w7Hh6errcLy8PDw/7d2e9N2d8btVRN2oeV/wZheP4vfb74sh7qVTA+PHHH3/1D7kkxcbGKjY2VpcvX/7Vbb28vBQTE6PU1FTde++99vbU1FQNHjz4uvtu2bJFhw4dUkJCwq8XDwAAql2lAkZlwkVVtk9KStLw4cPVtWtXxcbGasGCBcrKytLYsWMlXTm9kZOTo+XLl5fZb9GiRbrlllsUFRXlUF0AAKB6VCpgvPHGG5Xu8Omnn670tkOHDtWpU6c0bdo05ebmKioqShs2bLBfFZKbm1tuTYyzZ89q7dq1ev311yv9OrVFUcklufnkKLPgoNx8jJ1VVFxcrOPFx3Xg9AH70J9RMgvOy80nR0UllyQFGdo3AMAclfpL8dprr1WqM4vF4lDAkKRx48Zp3LhxFT63dOnScm1BQUEOzWKtTY5fOCb/8Df1Pzuc9xrzPp3nlH79w6XjFzorRteffwMAqBkqFTAyMzOdXQcM0MQ/TBcyn9LrQzurVUPjRzC+3Paletzaw/ARjMP55/XMqt1q0vva65kAAGoW0xbagvG83X1UeqmpwgPbKrK+sacarFarMj0y1S64neEzoksvnVXppRPydvcxtF8AgHkqFTD+cx2JXzNnzpwqFwMAAFxDpRfaqozKLJAFAABcX6UCxqZNm5xdBwAAcCGm3k0VAAC4pipN8vz222+1evVqZWVllVu1c926dYYUBgAAai6HRzBWrlypHj16aP/+/Vq/fr2sVqv279+vjRs3KiiIRZIAAEAVAsaMGTP02muv6eOPP5aXl5def/11HThwQEOGDFHz5s2dUSMAAKhhHA4Yhw8f1sCBAyVduVPphQsXZLFY9Oyzz2rBggWGFwgAAGoehwNGcHCwzp07J0lq2rSp9u3bJ0k6c+YMS3gDAABJVZjk2bNnT6WmpqpDhw4aMmSInnnmGW3cuFGpqam68847nVEjAACoYRwOGG+99ZYuXbok6crt1D09PbVt2zbdd999mjhxouEFAgCAmsfhgBEcHGz/t5ubm1544QW98MILhhYFAABqNofnYGzYsEGfffZZufaUlBT9+9//NqQoAABQszkcMJKTk1VSUlKuvbS0VMnJyYYUBQAAajaHA8aPP/6oyMjIcu0RERE6dOiQIUUBAICazeGAERQUpCNHjpRrP3TokPz9/Q0pCgAA1GwOB4xBgwYpMTFRhw8ftrcdOnRIzz33nAYNGmRocQAAoGZy+CqSV155Rf3791dERISaNWsmSfrpp5/Us2dPvfrqq4YXiMq7aL0yN2ZfzlnD+75wsUg7T0iNjv0if19vQ/s+lH/e0P4AAOZzOGAEBQVp+/btSk1N1Z49e+Tr66uOHTuqV69ezqgPDjj8f3+ok9ftddIreOi9Q986qW/J37tKN/cFAPwOVek3usViUVxcnHr16iVvb29ZLBaj60IVxLVvJElq1TBAvp7uhvZ9MPesnluzV7Mf6KC2jY2/a66/t4fCGzCHBwBchcMBo7S0VC+99JL+9re/6eeff9YPP/ygli1bauLEiWrRooUSEhKcUScqIdjfSw/d7Jw72hYXF0uSWt3gr6imxgcMAIBrcXiS54svvqilS5dq1qxZ8vLysrd36NBBCxcuNLQ4AABQMzkcMJYvX64FCxbo4Ycflrv7/z8M37FjR2VkZBhaHAAAqJkcDhg5OTlq3bp1ufbS0lJZrVZDigIAADWbw3Mw2rdvr61btyosLKxM++rVq9WlSxfDCgMAoKjkktx8cpRZcFBuPgGG9l1cXKzjxcd14PQBeXgYexVbZsF5ufnkqKjkkqTaOW/N4U908uTJGj58uHJyclRaWqp169bp4MGDWr58uT7++GNn1AgAqKWOXzgm//A39T87nPca8z6d55R+/cOl4xc6K0YhTun/987hgHHPPfdo1apVmjFjhiwWiyZNmqTo6Gh99NFH6tu3rzNqBADUUk38w3Qh8ym9PrSzWjU0fgTjy21fqsetPQwfwTicf17PrNqtJr3Dfn1jF1WlT7Rfv37q169fufZvv/1WN910028uCgAASfJ291HppaYKD2yryPrGnmqwWq3K9MhUu+B28vT0NLTv0ktnVXrphLzdfQzttyZxeJLn+fPndfHixTJtu3fv1j333KNu3boZVhgAAKi5Kh0wfvrpJ/Xo0UNBQUEKCgpSUlKSCgsLNWLECN10003y9vbWtm3bnFkrAACoISp9iiQ5OVnnz5/X66+/rrVr1+r111/Xli1b1KlTJ/3www8KDw93Zp0AAKAGqXTA2LRpk/75z3+qR48eeuCBB9SkSRM9+OCDSk5OdmZ9AACgBqr0KZK8vDy1atVKktSoUSP5+vpq8ODBTisMAADUXA5N8vzPpcHd3Nzk41N7Z8cCAIBrq/QpEpvNpjvvvNN+rfDFixd1zz33lLnhmSTt2rXL2AoBAECNU+mAMXny5DKPOT0CAACupcoBAwAA4FocXmgLAADg11RqBKN///6aNGmSunfvft3tzp07p3nz5ikgIEB/+tOfDCkQzlFYWKiMjIxKb38w94yK8g7pwD5flZ6qW+n9IiIi5OfnV4UKAQA1WaUCxoMPPqghQ4aoTp06GjRokLp27aomTZrIx8dHv/zyi/bv369t27Zpw4YNuvvuu/XKK684u278RhkZGYqJiXF4v2HLHNs+LS1N0dHRDr8OAKBmq1TASEhI0PDhw7VmzRqtWrVK7777rs6cOSNJslgsioyMVL9+/ZSWlqa2bds6s14YJCIiQmlpaZXe/vzFIn2y6SsN7B2rAF9vh14HAFD7VHqSp5eXl4YNG6Zhw4ZJks6ePauLFy+qfv36ht+FDs7n5+fn0MiC1WrVLyfzFXtzV/57AwB+VZVu1y7JftMzAACA/8ZVJAAAwHAEDAAAYDgCBgAAMJzpAWPevHkKDw+Xj4+PYmJitHXr1utuX1RUpAkTJigsLEze3t5q1aqVFi9eXE3VAgCAynA4YIwcOVJffPGFIS++atUqJSYmasKECUpPT1fPnj01YMAAZWVlXXOfIUOG6PPPP9eiRYt08OBBrVixgkshAQD4nXH4KpJz584pLi5OoaGhGjVqlB599FE1bdq0Si8+Z84cJSQkaPTo0ZKkuXPn6rPPPtP8+fM1c+bMctt/+umn2rJli44cOaLg4GBJUosWLar02gAAwHkcDhhr167VqVOn9Pe//11Lly7V5MmT1adPHyUkJGjw4MGVXiPh8uXLSktLU3Jycpn2uLg4bd++vcJ9PvzwQ3Xt2lWzZs3Se++9J39/fw0aNEjTp0+Xr69vhfsUFRWpqKjI/rigoEDSlXUdrFZrpWqF7J8VnxmcjWMN/6m4uNj+3ehjwpnHmjPrNpMj76VK62DUr19fzzzzjJ555hmlp6dr8eLFGj58uAICAvTII49o3LhxuvHGG6/bx8mTJ1VSUqKQkJAy7SEhIcrLy6twnyNHjmjbtm3y8fHR+vXrdfLkSY0bN06nT5++5jyMmTNnaurUqeXaU1JSuEdGFaSmpppdAmoJjjVIUvZ5SfLQtm3bdCzAOa/hjGOtOuo2Q2FhYaW3rfJCW5KUm5urlJQUpaSkyN3dXXfddZe+//57RUZGatasWXr22Wd/tQ+LxVLmsc1mK9d2VWlpqSwWi95//337Il9z5szRAw88oLfffrvCUYzx48crKSnJ/rigoEChoaGKi4tTYGCgI2+3VrNarUpNTVXfvn1ZyRNOxbGG//T98QK9uvdr3XrrrWrfxNjf2c481pxZt5mungWoDIcDhtVq1YcffqglS5YoJSVFHTt21LPPPquHH35YderUkSStXLlSf/zjH68bMBo0aCB3d/dyoxX5+fnlRjWuaty4sZo2bVpmBdF27drJZrPpp59+qnDUxNvbW97e5e+d4enpyS+vKuBzQ3XhWIMkeXh42L8763hwxrFWHXWbwZH34vBVJI0bN9bjjz+usLAw7dixQzt37tTYsWPt4UKS+vXrp7p16163Hy8vL8XExJQbmkpNTb3mbeF79Oih48eP6/z58/a2H374QW5ubmrWrJmjbwUAADiJwwHjtdde0/Hjx/X222+rc+fOFW5Tr149ZWZm/mpfSUlJWrhwoRYvXqwDBw7o2WefVVZWlsaOHSvpyumNESNG2LcfNmyY6tevr1GjRmn//v364osv9Oc//1mPPfbYNSd5AgCA6udwwNi0aVOFs0gvXLigxx57zKG+hg4dqrlz52ratGnq3LmzvvjiC23YsEFhYWGSrszx+M81MQICApSamqozZ86oa9euevjhh3XPPffojTfecPRtAAAAJ3J4DsayZcv08ssvlzklIkkXL17U8uXLHV5Vc9y4cRo3blyFzy1durRcW0REBLPLAQD4nat0wCgoKJDNZpPNZtO5c+fk4+Njf66kpEQbNmxQw4YNnVIkAACoWSodMOrWrSuLxSKLxaI2bdqUe95isVS43gQAAKh9Kh0wNm3aJJvNpjvuuENr1661L9UtXbkiJCwsTE2aNHFKkQAAoGapdMC47bbbJEmZmZlq3rz5NRfDAgAAqFTA+O677xQVFSU3NzedPXtWe/fuvea2HTt2NKw4AABQM1UqYHTu3Fl5eXlq2LChOnfuLIvFIpvNVm47i8WikpISw4sEAAA1S6UCRmZmpm644Qb7vwEAAK6nUgHj6sJXknTDDTdwF1IAAHBdDq/k2bBhQz3yyCP67LPPVFpa6oyaAABADedwwFi+fLmKiop07733qkmTJnrmmWf07bffOqM2AABQQzkcMO677z6tXr1aP//8s2bOnKkDBw6oe/fuatOmjaZNm+aMGgEAQA3jcMC4qk6dOho1apRSUlK0Z88e+fv7s5InAACQ9BsCxqVLl/TPf/5T8fHxio6O1qlTp/T8888bWRsAAKihHL6bakpKit5//3198MEHcnd31wMPPKDPPvvMvtInAACAwwEjPj5eAwcO1LJlyzRw4EB5eno6oy4AAFCDORww8vLyFBgY6IxaAACAi6hUwCgoKCgTKgoKCq65LeEDAABUKmDUq1dPubm5atiwoerWrVvhnVRtNhv3IgEAAJIqGTA2btyo4OBgSdKmTZucWhAAAKj5KhUw/vMKkfDwcIWGhpYbxbDZbMrOzja2OgAAUCM5vA5GeHi4Tpw4Ua799OnTCg8PN6QoAABQszkcMK7Otfhv58+fl4+PjyFFAQCAmq3Sl6kmJSVJkiwWiyZOnFjmlu0lJSX65ptv1LlzZ8MLBAAANU+lA0Z6erqkKyMYe/fulZeXl/05Ly8vderUiaXCAQCAJAcCxtWrR0aNGqXXX3+d9S4AAMA1ObyS55IlS5xRBwAAcCGVChj33Xefli5dqsDAQN13333X3XbdunWGFAYAAGquSgWMoKAg+5UjQUFBTi0IAADUfJUKGP95WoRTJAAA4Nc4vA7GxYsXVVhYaH987NgxzZ07VykpKYYWBgAAai6HA8bgwYO1fPlySdKZM2d08803a/bs2Ro8eLDmz59veIEAAKDmcThg7Nq1Sz179pQkrVmzRo0aNdKxY8e0fPlyvfHGG4YXCAAAah6HA0ZhYaHq1KkjSUpJSdF9990nNzc3devWTceOHTO8QAAAUPM4HDBat26tDz74QNnZ2frss88UFxcnScrPz2fxLQAAIKkKAWPSpEl6/vnn1aJFC91yyy2KjY2VdGU0o0uXLoYXCAAAah6HV/J84IEHdOuttyo3N1edOnWyt99555269957DS0OAADUTA4HDElq1KiRGjVqVKbt5ptvNqQgAABQ8zkcMC5cuKCXX35Zn3/+ufLz81VaWlrm+SNHjhhWHAAAqJkcDhijR4/Wli1bNHz4cDVu3Ni+hDgAAMBVDgeMf//73/rkk0/Uo0cPZ9QDAABcgMNXkdSrV0/BwcHOqAUAALgIhwPG9OnTNWnSpDL3IwEAAPhPDp8imT17tg4fPqyQkBC1aNFCnp6eZZ7ftWuXYcUBAICayeGAER8f74QyAACAK3E4YEyePNkZdQAAABfi8BwM6cpt2hcuXKjx48fr9OnTkq6cGsnJyTG0OAAAUDM5PILx3XffqU+fPgoKCtLRo0f1+OOPKzg4WOvXr7ffth0AANRuDo9gJCUlaeTIkfrxxx/l4+Njbx8wYIC++OILQ4sDAAA1k8MB49tvv9WYMWPKtTdt2lR5eXkOFzBv3jyFh4fLx8dHMTEx2rp16zW33bx5sywWS7mvjIwMh18XAAA4j8MBw8fHRwUFBeXaDx48qBtuuMGhvlatWqXExERNmDBB6enp6tmzpwYMGKCsrKzr7nfw4EHl5ubav2688UaHXhcAADiXwwFj8ODBmjZtmqxWqyTJYrEoKytLycnJuv/++x3qa86cOUpISNDo0aPVrl07zZ07V6GhoZo/f/5192vYsKH9jq6NGjWSu7u7o28DAAA4kcOTPF999VXdddddatiwoS5evKjbbrtNeXl5io2N1UsvvVTpfi5fvqy0tDQlJyeXaY+Li9P27duvu2+XLl106dIlRUZG6n//93/Vu3fva25bVFSkoqIi++Oroy9Wq9UekvDrrn5WfGZwNo41/Kfi4mL7d6OPCWcea86s20yOvBeHA0ZgYKC2bdumjRs3ateuXSotLVV0dLT69OnjUD8nT55USUmJQkJCyrSHhIRccy5H48aNtWDBAsXExKioqEjvvfee7rzzTm3evFm9evWqcJ+ZM2dq6tSp5dpTUlLk5+fnUM2QUlNTzS4BtQTHGiQp+7wkeWjbtm06FuCc13DGsVYddZvBkduEWGw2m82JtVzT8ePH1bRpU23fvl2xsbH29pdeeknvvfdepSdu3nPPPbJYLPrwww8rfL6iEYzQ0FCdPHlSgYGBv+1N1CJWq1Wpqanq27dvueXhASNxrOE/fX+8QPHzv9YHf+ym9k2M/Z3tzGPNmXWbqaCgQA0aNNDZs2d/9W9opUcwvvnmG50+fVoDBgywty1fvlyTJ0/WhQsXFB8frzfffFPe3t6V6q9BgwZyd3cvN1qRn59fblTjerp166a///3v13ze29u7wpo8PT355VUFfG6oLhxrkCQPDw/7d2cdD8441qqjbjM48l4qPclzypQp+u677+yP9+7dq4SEBPXp00fJycn66KOPNHPmzEq/sJeXl2JiYsoNTaWmpqp79+6V7ic9PV2NGzeu9PYAAMD5Kj2CsXv3bk2fPt3+eOXKlbrlllv07rvvSpJCQ0M1efJkTZkypdIvnpSUpOHDh6tr166KjY3VggULlJWVpbFjx0qSxo8fr5ycHPvqoHPnzlWLFi3Uvn17Xb58WX//+9+1du1arV27ttKvCQAAnK/SAeOXX34pc+piy5Yt6t+/v/3xTTfdpOzsbIdefOjQoTp16pSmTZum3NxcRUVFacOGDQoLC5Mk5ebmllkT4/Lly3r++eeVk5MjX19ftW/fXp988onuuusuh14XAAA4V6UDRkhIiDIzMxUaGqrLly9r165dZa7OOHfuXJXOM40bN07jxo2r8LmlS5eWefzCCy/ohRdecPg1AABA9ar0HIz+/fsrOTlZW7du1fjx4+Xn56eePXvan//uu+/UqlUrpxQJAABqlkqPYLz44ou67777dNtttykgIEDLli2Tl5eX/fnFixcrLi7OKUUCAICapdIB44YbbtDWrVt19uxZBQQElFuee/Xq1QoIcKHVRAAAQJU5vJJnUFBQhe3BwcG/uRgAAOAaHL7ZGQAAwK8hYAAAAMMRMAAAgOEIGAAAwHAEDAAAYDgCBgAAMBwBAwAAGI6AAQAADEfAAAAAhiNgAAAAwxEwAACA4QgYAADAcAQMAABgOAIGAAAwHAEDAAAYjoABAAAMR8AAAACGI2AAAADDETAAAIDhCBgAAMBwBAwAAGA4AgYAADAcAQMAABjOw+wCAAC4lovWEknSvpyzhvd94WKRdp6QGh37Rf6+3ob2fSj/vKH91UQEDADA79bh//tDnbxur5NewUPvHfrWSX1L/t61989s7X3nAIDfvbj2jSRJrRoGyNfT3dC+D+ae1XNr9mr2Ax3UtnGQoX1LV8JFeAN/w/utKQgYAIDfrWB/Lz10c3On9F1cXCxJanWDv6KaGh8wajsmeQIAAMMRMAAAgOEIGAAAwHAEDAAAYDgCBgAAMBwBAwAAGI6AAQAADEfAAAAAhiNgAAAAwxEwAACA4QgYAADAcAQMAABgOAIGAAAwHAEDAAAYjoABAAAMR8AAAACGMz1gzJs3T+Hh4fLx8VFMTIy2bt1aqf2+/PJLeXh4qHPnzs4tEAAAOMzUgLFq1SolJiZqwoQJSk9PV8+ePTVgwABlZWVdd7+zZ89qxIgRuvPOO6upUgAA4AhTA8acOXOUkJCg0aNHq127dpo7d65CQ0M1f/786+43ZswYDRs2TLGxsdVUKQAAcISHWS98+fJlpaWlKTk5uUx7XFyctm/ffs39lixZosOHD+vvf/+7XnzxxV99naKiIhUVFdkfFxQUSJKsVqusVmsVq699rn5WfGZwNo41VJfi4mL7d463ynHkczItYJw8eVIlJSUKCQkp0x4SEqK8vLwK9/nxxx+VnJysrVu3ysOjcqXPnDlTU6dOLdeekpIiPz8/xwuv5VJTU80uAbUExxqcLfu8JHno66+/Vs4+s6upGQoLCyu9rWkB4yqLxVLmsc1mK9cmSSUlJRo2bJimTp2qNm3aVLr/8ePHKykpyf64oKBAoaGhiouLU2BgYNULr2WsVqtSU1PVt29feXp6ml0OXBjHGqrLnqzT0t6d6tatmzo1Dza7nBrh6lmAyjAtYDRo0EDu7u7lRivy8/PLjWpI0rlz57Rz506lp6frySeflCSVlpbKZrPJw8NDKSkpuuOOO8rt5+3tLW9v73Ltnp6e/PKqAj43VBeONTjb1ZFwDw8PjrVKcuRzMm2Sp5eXl2JiYsoNg6ampqp79+7ltg8MDNTevXu1e/du+9fYsWPVtm1b7d69W7fcckt1lQ4AAH6FqadIkpKSNHz4cHXt2lWxsbFasGCBsrKyNHbsWElXTm/k5ORo+fLlcnNzU1RUVJn9GzZsKB8fn3LtAADAXKYGjKFDh+rUqVOaNm2acnNzFRUVpQ0bNigsLEySlJub+6trYgAAgN8f0yd5jhs3TuPGjavwuaVLl1533ylTpmjKlCnGFwUAAH4T05cKBwAAroeAAQAADEfAAAAAhiNgAAAAwxEwAACA4QgYAADAcAQMAABgOAIGAAAwHAEDAAAYjoABAAAMR8AAAACGI2AAAADDETAAAIDhCBgAAMBwBAwAAGA4AgYAADAcAQMAABiOgAEAAAxHwAAAAIYjYAAAAMMRMAAAgOEIGAAAwHAEDAAAYDgCBgAAMBwBAwAAGI6AAQAADEfAAAAAhiNgAAAAwxEwAACA4QgYAADAcAQMAABgOAIGAAAwHAEDAAAYjoABAAAMR8AAAACGI2AAAADDETAAAIDhCBgAAMBwBAwAAGA4AgYAADAcAQMAABiOgAEAAAxHwAAAAIYjYAAAAMMRMAAAgOEIGAAAwHAEDAAAYDgCBgAAMJzpAWPevHkKDw+Xj4+PYmJitHXr1mtuu23bNvXo0UP169eXr6+vIiIi9Nprr1VjtQAAoDI8zHzxVatWKTExUfPmzVOPHj30zjvvaMCAAdq/f7+aN29ebnt/f389+eST6tixo/z9/bVt2zaNGTNG/v7+euKJJ0x4BwAAoCKmjmDMmTNHCQkJGj16tNq1a6e5c+cqNDRU8+fPr3D7Ll266A9/+IPat2+vFi1a6JFHHlG/fv2uO+oBAACqn2kjGJcvX1ZaWpqSk5PLtMfFxWn79u2V6iM9PV3bt2/Xiy++eM1tioqKVFRUZH9cUFAgSbJarbJarVWovHa6+lnxmcHZONZQXYqLi+3fOd4qx5HPybSAcfLkSZWUlCgkJKRMe0hIiPLy8q67b7NmzXTixAkVFxdrypQpGj169DW3nTlzpqZOnVquPSUlRX5+flUrvhZLTU01uwTUEhxrcLbs85Lkoa+//lo5+8yupmYoLCys9LamzsGQJIvFUuaxzWYr1/bftm7dqvPnz+vrr79WcnKyWrdurT/84Q8Vbjt+/HglJSXZHxcUFCg0NFRxcXEKDAz87W+glrBarUpNTVXfvn3l6elpdjlwYRxrqC57sk5Le3eqW7du6tQ82OxyaoSrZwEqw7SA0aBBA7m7u5cbrcjPzy83qvHfwsPDJUkdOnTQzz//rClTplwzYHh7e8vb27tcu6enJ7+8qoDPDdWFYw3O5uHhYf/OsVY5jnxOpk3y9PLyUkxMTLlh0NTUVHXv3r3S/dhstjJzLAAAgPlMPUWSlJSk4cOHq2vXroqNjdWCBQuUlZWlsWPHSrpyeiMnJ0fLly+XJL399ttq3ry5IiIiJF1ZF+PVV1/VU089Zdp7AAAA5ZkaMIYOHapTp05p2rRpys3NVVRUlDZs2KCwsDBJUm5urrKysuzbl5aWavz48crMzJSHh4datWqll19+WWPGjDHrLQAAgAqYPslz3LhxGjduXIXPLV26tMzjp556itEKAABqANOXCgcAAK6HgAEAAAxHwAAAAIYjYAAAAMMRMAAAgOEIGAAAwHAEDAAAYDgCBgAAMBwBAwAAGI6AAQAADEfAAAAAhiNgAAAAwxEwAACA4QgYAADAcAQMAABgOAIGAAAwHAEDAAAYjoABAAAMR8AAAACGI2AAAADDETAAAIDhCBgAAMBwBAwAAGA4AgYAADAcAQMAABiOgAEAAAxHwAAAAIYjYAAAAMMRMAAAgOE8zC4AAAAjFBYWKiMjo9LbH8w9o6K8Qzqwz1elp+pWer+IiAj5+flVocLahYABAHAJGRkZiomJcXi/Ycsc2z4tLU3R0dEOv05tQ8AAALiEiIgIpaWlVXr78xeL9MmmrzSwd6wCfL0deh38OgIGAMAl+Pn5OTSyYLVa9cvJfMXe3FWenp5OrKx2YpInAAAwHAEDAAAYjoABAAAMR8AAAACGI2AAAADDETAAAIDhCBgAAMBwBAwAAGA4AgYAADAcAQMAABiOgAEAAAxHwAAAAIYjYAAAAMMRMAAAgOEIGAAAwHAEDAAAYDgCBgAAMJyH2QVUN5vNJkkqKCgwuZKaxWq1qrCwUAUFBfL09DS7HLgwjjVUF441x13923n1b+n11LqAce7cOUlSaGioyZUAAFAznTt3TkFBQdfdxmKrTAxxIaWlpTp+/Ljq1Kkji8Vidjk1RkFBgUJDQ5Wdna3AwECzy4EL41hDdeFYc5zNZtO5c+fUpEkTubldf5ZFrRvBcHNzU7Nmzcwuo8YKDAzkBxHVgmMN1YVjzTG/NnJxFZM8AQCA4QgYAADAcAQMVIq3t7cmT54sb29vs0uBi+NYQ3XhWHOuWjfJEwAAOB8jGAAAwHAEDAAAYDgCBgAAMBwBAwAAGI6AgWvaunWrHnnkEcXGxionJ0eS9N5772nbtm0mVwYAjrt48aIKCwvtj48dO6a5c+cqJSXFxKpcFwEDFVq7dq369esnX19fpaenq6ioSNKV9ednzJhhcnVwJT///LOGDx+uJk2ayMPDQ+7u7mW+AKMMHjxYy5cvlySdOXNGt9xyi2bPnq3Bgwdr/vz5JlfnerhMFRXq0qWLnn32WY0YMUJ16tTRnj171LJlS+3evVv9+/dXXl6e2SXCRQwYMEBZWVl68skn1bhx43L3CBo8eLBJlcHVNGjQQFu2bFH79u21cOFCvfnmm0pPT9fatWs1adIkHThwwOwSXUqtuxcJKufgwYPq1atXufbAwECdOXOm+guCy9q2bZu2bt2qzp07m10KXFxhYaHq1KkjSUpJSdF9990nNzc3devWTceOHTO5OtfDKRJUqHHjxjp06FC59m3btqlly5YmVARXFRoaKgZSUR1at26tDz74QNnZ2frss88UFxcnScrPz+dmZ05AwECFxowZo2eeeUbffPONLBaLjh8/rvfff1/PP/+8xo0bZ3Z5cCFz585VcnKyjh49anYpcHGTJk3S888/rxYtWujmm29WbGyspCujGV26dDG5OtfDHAxc04QJE/Taa6/p0qVLkq6s2//8889r+vTpJlcGV1KvXj0VFhaquLhYfn5+8vT0LPP86dOnTaoMrigvL0+5ubnq1KmT3Nyu/D/2jh07FBgYqIiICJOrcy0EDFxXYWGh9u/fr9LSUkVGRiogIMDskuBili1bdt3nH3300WqqBLXFoUOHdPjwYfXq1Uu+vr6y2WzlJhfjtyNg4Lr4QQTgKk6dOqUhQ4Zo06ZNslgs+vHHH9WyZUslJCSobt26mj17ttkluhTmYKBCp06d0p133qk2bdrorrvuUm5uriRp9OjReu6550yuDq6mpKREa9eu1YsvvqiXXnpJ69evV0lJidllwcU8++yz8vT0VFZWlvz8/OztQ4cO1aeffmpiZa6Jy1RRof/8QWzXrp29fejQoXr22WdJ+jDMoUOHdNdddyknJ0dt27aVzWbTDz/8oNDQUH3yySdq1aqV2SXCRaSkpOizzz5Ts2bNyrTfeOONXKbqBIxgoEIpKSn661//yg8inO7pp59Wq1atlJ2drV27dik9PV1ZWVkKDw/X008/bXZ5cCEXLlwoM3Jx1cmTJ+Xt7W1CRa6NgIEK8YOI6rJlyxbNmjVLwcHB9rb69evr5Zdf1pYtW0ysDK6mV69e9qXCJclisai0tFSvvPKKevfubWJlrolTJKjQ1R/Eq5ek8oMIZ/H29ta5c+fKtZ8/f15eXl4mVARX9corr+j222/Xzp07dfnyZb3wwgv6/vvvdfr0aX355Zdml+dyuIoEFdq/f79uv/12xcTEaOPGjRo0aFCZH0TOi8MoI0aM0K5du7Ro0SLdfPPNkqRvvvlGjz/+uGJiYrR06VJzC4RLycvL0/z585WWlqbS0lJFR0frT3/6kxo3bmx2aS6HgIFr4gcR1eHMmTN69NFH9dFHH9kX2SouLtagQYO0dOlSBQUFmVwhgKogYKAcq9WquLg4vfPOO2rTpo3Z5aCW+PHHH5WRkSGbzabIyEi1bt3a7JLgYlq0aKHHHntMo0aNUmhoqNnluDwCBip0ww03aPv27brxxhvNLgUADPHmm29q6dKl2rNnj3r37q2EhATde++9TFx3EgIGKvTcc8/J09NTL7/8stmlwAUlJSVp+vTp8vf3V1JS0nW3nTNnTjVVhdpiz549Wrx4sVasWKHi4mINGzZMjz32mKKjo80uzaUQMFChp556SsuXL1fr1q3VtWtX+fv7l3meX/r4LXr37q3169erbt26170qyWKxaOPGjdVYGWoTq9WqefPm6S9/+YusVquioqL0zDPPaNSoUdwSwQAEDJTh7u6u3NxcDR069Jrb8EsfQE1mtVq1fv16LVmyRKmpqerWrZsSEhJ0/PhxvfXWW+rdu7f+8Y9/mF1mjUfAQBlubm7Ky8tTw4YNzS4FtVRBQYE2btyoiIgIbp8NQ+3atUtLlizRihUr5O7uruHDh2v06NFljrNvv/1WvXr10sWLF02s1DWw0BYAUw0ZMkS9evXSk08+qYsXL6pr1646evSobDabVq5cqfvvv9/sEuEibrrpJvXt21fz589XfHy8/bLo/xQZGamHHnrIhOpcDyMYKMPNzU3Lli371bUHBg0aVE0VwdU1atRIn332mTp16qR//OMfmjx5svbs2aNly5ZpwYIFSk9PN7tEuIhjx44pLCzM7DJqDQIGynBz+/Xb01gsFm6lDcP4+vra7546YsQINWnSRC+//LKysrIUGRmp8+fPm10igCrgZmcoJy8vT6Wlpdf8IlzASKGhofrqq6904cIFffrpp4qLi5Mk/fLLL/Lx8TG5OriSkpISvfrqq7r55pvVqFEjBQcHl/mCsQgYKINLs1DdEhMT9fDDD6tZs2Zq0qSJbr/9dknSF198oQ4dOphbHFzK1KlTNWfOHA0ZMkRnz55VUlKS7rvvPrm5uWnKlClml+dyOEWCMriKBGbYuXOnsrOz1bdvXwUEBEiSPvnkE9WtW1c9evQwuTq4ilatWumNN97QwIEDVadOHe3evdve9vXXX3NpqsG4igRlPProo/L19TW7DNQyXbt2VdeuXSVdGcbeu3evunfvrnr16plcGVxJXl6efVQsICBAZ8+elSTdfffdmjhxopmluSROkaCMJUuWqE6dOmaXgVokMTFRixYtknQlXNx2222Kjo5WaGioNm/ebG5xcCnNmjVTbm6uJKl169ZKSUmRdGXtC+5HYjwCBgBTrVmzRp06dZIkffTRR8rMzFRGRoYSExM1YcIEk6uDK7n33nv1+eefS5KeeeYZTZw4UTfeeKNGjBihxx57zOTqXA9zMACYysfHR4cOHVKzZs30xBNPyM/PT3PnzlVmZqY6deqkgoICs0uEi/r666+1fft2tW7dmrV9nIA5GABMFRISov3796tx48b69NNPNW/ePElSYWGh3N3dTa4Orqxbt27q1q2b2WW4LAIGAFONGjVKQ4YMUePGjWWxWNS3b19J0jfffMO9SGCoU6dOqX79+pKk7Oxsvfvuu7p48aIGDRqknj17mlyd6+EUCSp04cIFvfzyy/r888+Vn5+v0tLSMs8fOXLEpMrgitasWaPs7Gw9+OCDatasmSRp2bJlqlu3rgYPHmxydajp9u7dq3vuuUfZ2dm68cYbtXLlSvXv318XLlyQm5ubLly4oDVr1ig+Pt7sUl0KAQMV+sMf/qAtW7Zo+PDh9v+z/E/PPPOMSZXBlV26dInVO2G4AQMGyMPDQ3/5y1/097//XR9//LHi4uK0cOFCSdJTTz2ltLQ0ff311yZX6loIGKhQ3bp19cknn7DIEZyupKREM2bM0N/+9jf9/PPP+uGHH9SyZUtNnDhRLVq0UEJCgtklooZr0KCBNm7cqI4dO+r8+fMKDAzUjh077GuvZGRkqFu3bjpz5oy5hboYLlNFherVq8fa/KgWL730kpYuXapZs2bJy8vL3t6hQwf7/2ECv8Xp06fVqFEjSVcW2PL39y/z+61evXo6d+6cWeW5LAIGKjR9+nRNmjRJhYWFZpcCF7d8+XItWLBADz/8cJmrRjp27KiMjAwTK4Mr+e/TvNx3yfm4igQVmj17tg4fPqyQkBC1aNFCnp6eZZ7ftWuXSZXB1eTk5Kh169bl2ktLS2W1Wk2oCK5o5MiR9tU6L126pLFjx8rf31+SVFRUZGZpLouAgQoxmxrVpX379tq6davCwsLKtK9evVpdunQxqSq4kkcffbTM40ceeaTcNiNGjKiucmoNAgYqNHnyZLNLQC0xefJkDR8+XDk5OSotLdW6det08OBBLV++XB9//LHZ5cEFLFmyxOwSaiWuIsF1paWl6cCBA7JYLIqMjOT/KOEUn332mWbMmKG0tDSVlpYqOjpakyZNUlxcnNmlAagiAgYqlJ+fr4ceekibN29W3bp1ZbPZdPbsWfXu3VsrV67UDTfcYHaJcAHFxcV66aWX9Nhjjyk0NNTscgAYiKtIUKGnnnpKBQUF+v7773X69Gn98ssv2rdvnwoKCvT000+bXR5chIeHh1555RWVlJSYXQoAgzGCgQoFBQXp//2//6ebbrqpTPuOHTsUFxfHgjQwTHx8vOLj4zVy5EizSwFgICZ5okKlpaXlLk2VJE9Pz3L3JQF+iwEDBmj8+PHat2+fYmJi7JcOXsVttIGaiREMVGjw4ME6c+aMVqxYoSZNmki6sl7Bww8/rHr16mn9+vUmVwhX4eZ27TO1FouF0ycw1Hvvvae//e1vyszM1FdffaWwsDDNnTtX4eHh3FjPYMzBQIXeeustnTt3Ti1atFCrVq3UunVrhYeH69y5c3rzzTfNLg8upLS09JpfhAsYaf78+UpKStJdd92lM2fO2I+vunXrau7cueYW54IYwcB1paamKiMjQzabTZGRkerTp4/ZJQFAlURGRmrGjBmKj49XnTp1tGfPHrVs2VL79u3T7bffrpMnT5pdokthDgauq2/fvurbt6/ZZcCFvfHGGxW2WywW+fj4qHXr1urVq1eZ+5QAVZGZmVnhWj7e3t66cOGCCRW5NgIG7N544w098cQT8vHxueYv/au4VBVGee2113TixAkVFhaqXr16stlsOnPmjPz8/BQQEKD8/Hy1bNlSmzZtYq0M/Cbh4eHavXt3uWXp//3vfysyMtKkqlwXp0hgFx4erp07d6p+/foKDw+/5nYWi0VHjhypxsrgylasWKEFCxZo4cKFatWqlSTp0KFDGjNmjJ544gn16NFDDz30kBo1aqQ1a9aYXC1qsiVLlmjixImaPXu2EhIStHDhQh0+fFgzZ87UwoUL9dBDD5ldokshYAAwVatWrbR27Vp17ty5THt6erruv/9+HTlyRNu3b9f999+v3Nxcc4qEy3j33Xf14osvKjs7W5LUtGlTTZkyRQkJCSZX5no4RYJKKSkp0d69exUWFqZ69eqZXQ5cSG5uroqLi8u1FxcXKy8vT5LUpEkTnTt3rrpLgwt6/PHH9fjjj+vkyZMqLS1Vw4YNzS7JZXGZKiqUmJioRYsWSboSLnr16qXo6GiFhoZq8+bN5hYHl9K7d2+NGTNG6enp9rb09HT98Y9/1B133CFJ2rt373VP2wGVMXXqVB0+fFiS1KBBA8KFkxEwUKE1a9aoU6dOkqSPPvpIR48eVUZGhhITEzVhwgSTq4MrWbRokYKDgxUTEyNvb295e3ura9euCg4OtofcgIAAzZ492+RKUdOtXbtWbdq0Ubdu3fTWW2/pxIkTZpfk0piDgQr5+Pjo0KFDatasmZ544gn5+flp7ty5yszMVKdOnVRQUGB2iXAxGRkZ+uGHH2Sz2RQREaG2bduaXRJc0Pfff6/3339fK1eu1E8//aQ+ffrokUceUXx8vPz8/Mwuz6UwgoEKhYSEaP/+/SopKdGnn35qX2CrsLCQ9QjgFC1btlTbtm01cOBAwgWcpn379poxY4aOHDmiTZs2KTw8XImJiWrUqJHZpbkcAgYqNGrUKA0ZMkRRUVGyWCz2xba++eYbRUREmFwdXElhYaESEhLk5+en9u3bKysrS9KVtVZefvllk6uDK/P395evr6+8vLxktVrNLsflEDBQoSlTpmjhwoV64okn9OWXX8rb21uS5O7uruTkZJOrgysZP3689uzZo82bN8vHx8fe3qdPH61atcrEyuCKMjMz9dJLLykyMlJdu3bVrl27NGXKFPsVSzAOczAAmCosLEyrVq1St27dytwf4tChQ4qOjma+DwwTGxurHTt2qEOHDnr44Yc1bNgwNW3a1OyyXBbrYMCOpcJhhhMnTlR4ueCFCxdksVhMqAiuqnfv3lq4cKHat29vdim1AiMYsGOpcJjhtttu0wMPPKCnnnpKderU0Xfffafw8HA9+eSTOnTokD799FOzSwRQBYxgwC4zM7PCfwPONHPmTPXv31/79+9XcXGxXn/9dX3//ff66quvtGXLFrPLQw2XlJSk6dOny9/fX0lJSdfdds6cOdVUVe1AwABgqu7du+vLL7/Uq6++qlatWiklJUXR0dH66quv1KFDB7PLQw2Xnp5uv0LkP1eL/W+cjjMep0hQoQceeEBdu3Ytd8XIK6+8oh07dmj16tUmVYbaZM2aNXrggQfMLgNAFXCZKiq0ZcsWDRw4sFx7//799cUXX5hQEVxRcXGxvv/+e/3www9l2v/1r3+pU6dOevjhh02qDMBvxSkSVOj8+fPy8vIq1+7p6cllgzDE/v37dffdd+vYsWOSpMGDB2v+/PkaMmSI9uzZo9GjR+vjjz82uUq4mm+//VarV69WVlaWLl++XOa5devWmVSVa2IEAxWKioqqcJGjlStXKjIy0oSK4GqSk5MVHh6uf/3rXxoyZIg++OAD9ezZU3feeaeys7P16quvKjQ01Owy4UJWrlypHj16aP/+/Vq/fr2sVqv279+vjRs3KigoyOzyXA5zMFChDz/8UPfff7+GDRtmv2X2559/rhUrVmj16tWKj483t0DUeI0aNdKGDRsUHR2tM2fOKDg4WO+8844ef/xxs0uDi+rYsaPGjBmjP/3pT/ZF3cLDwzVmzBg1btxYU6dONbtEl0LAwDV98sknmjFjhnbv3i1fX1917NhRkydP1m233WZ2aXABbm5uys3NVUhIiKQrt2TftWuX2rRpY3JlcFX+/v76/vvv1aJFCzVo0ECbNm1Shw4ddODAAd1xxx3Kzc01u0SXwhwMXNPAgQMrnOgJGMFiscjN7f8/S+vm5iZPT08TK4KrCw4O1rlz5yRJTZs21b59+9ShQwedOXNGhYWFJlfneggYuKYzZ85ozZo1OnLkiJ5//nkFBwdr165dCgkJYf1+/GY2m01t2rSxrz9w/vx5denSpUzokKTTp0+bUR5cUM+ePZWamqoOHTpoyJAheuaZZ7Rx40alpqbqzjvvNLs8l8MpElTou+++U58+fRQUFKSjR4/q4MGDatmypSZOnKhjx45p+fLlZpeIGm7ZsmWV2u7RRx91ciWoLU6fPq1Lly6pSZMmKi0t1auvvqpt27apdevWmjhxourVq2d2iS6FgIEK9enTR9HR0Zo1a1aZO1xu375dw4YN09GjR80uEQDwO8ZlqqjQt99+qzFjxpRrb9q0qfLy8kyoCABQkzAHAxXy8fGpcEGtgwcP6oYbbjChIgCoGjc3t1+914jFYlFxcXE1VVQ7EDBQocGDB2vatGn65z//KenKD19WVpaSk5N1//33m1wdAFTe+vXrr/nc9u3b9eabb4rZAsZjDgYqVFBQoLvuukvff/+9zp07pyZNmigvL0+xsbHasGGD/P39zS4RAKosIyND48eP10cffaSHH35Y06dPV/Pmzc0uy6UwgoEKBQYGatu2bdq4caN27dql0tJSRUdHq0+fPmaXBgBVdvz4cU2ePFnLli1Tv379tHv3bkVFRZldlktiBAOAqR544AF17dpVycnJZdpfeeUV7dixQ6tXrzapMriSs2fPasaMGXrzzTfVuXNn/fWvf1XPnj3NLsulcRUJyiktLdXixYt19913KyoqSh06dNCgQYO0fPlyzlPCcFu2bKlwxdj+/fvriy++MKEiuJpZs2apZcuW+vjjj7VixQpt376dcFENGMFAGTabTffcc482bNigTp06KSIiQjabTQcOHNDevXs1aNAgffDBB2aXCRfi6+ur3bt3q23btmXaMzIy1KVLF128eNGkyuAq3Nzc5Ovrqz59+sjd3f2a23G7dmMxBwNlLF26VF988YU+//xz9e7du8xzGzduVHx8vJYvX64RI0aYVCFcTVRUlFatWqVJkyaVaV+5cqUiIyNNqgquZMSIEb96mSqMxwgGyoiLi9Mdd9xR7nz4VTNmzNCWLVv02WefVXNlcFUffvih7r//fg0bNkx33HGHJOnzzz/XihUrtHr1asXHx5tbIIAqIWCgjEaNGunTTz9V586dK3w+PT1dAwYMYDVPGOqTTz7RjBkztHv3bvn6+qpjx46aPHmybrvtNrNLA1BFBAyU4eXlpWPHjqlx48YVPn/8+HGFh4erqKiomisDANQkXEWCMkpKSuThce2pOe7u7iynCwD4VUzyRBk2m00jR46Ut7d3hc8zcgEjBAcH64cfflCDBg1Ur169607AO336dDVWBsAoBAyU8eijj/7qNlxBgt/qtddeU506dez/ZoY/4HqYgwEAAAzHHAwApnJ3d1d+fn659lOnTl13USQAv28EDACmutYgalFRkby8vKq5GgBGYQ4GAFO88cYbkiSLxaKFCxcqICDA/lxJSYm++OILRUREmFUegN+IORgATBEeHi5JOnbsmJo1a1bmdIiXl5datGihadOm6ZZbbjGrRAC/AQEDgKl69+6tdevWqV69emaXAsBABAwAvyslJSXau3evwsLCCB1ADcYkTwCmSkxM1KJFiyRdCRe9evVSdHS0QkNDtXnzZnOLA1BlBAwAplq9erU6deokSfroo4909OhRZWRkKDExURMmTDC5OgBVRcAAYKpTp06pUaNGkqQNGzbowQcfVJs2bZSQkKC9e/eaXB2AqiJgADBVSEiI9u/fr5KSEn366afq06ePJKmwsJCFtoAajHUwAJhq1KhRGjJkiBo3biyLxaK+fftKkr755hvWwQBqMAIGAFNNmTJFUVFRys7O1oMPPmi/k6+7u7uSk5NNrg5AVXGZKgAAMBwjGACq3RtvvKEnnnhCPj4+9iXDr+Xpp5+upqoAGIkRDADVLjw8XDt37lT9+vXtS4ZXxGKx6MiRI9VYGQCjEDAAAIDhuEwVAAAYjjkYAEyVlJRUYbvFYpGPj49at26twYMHKzg4uJorA/BbcIoEgKl69+6tXbt2qaSkRG3btpXNZtOPP/4od3d3RURE6ODBg7JYLNq2bZsiIyPNLhdAJXGKBICpBg8erD59+uj48eNKS0vTrl27lJOTo759++oPf/iDcnJy1KtXLz377LNmlwrAAYxgADBV06ZNlZqaWm504vvvv1dcXJxycnK0a9cuxcXF6eTJkyZVCcBRjGAAMNXZs2eVn59frv3EiRMqKCiQJNWtW1eXL1+u7tIA/AYEDACmGjx4sB577DGtX79eP/30k3JycrR+/XolJCQoPj5ekrRjxw61adPG3EIBOIRTJABMdf78eT377LNavny5iouLJUkeHh569NFH9dprr8nf31+7d++WJHXu3Nm8QgE4hIAB4Hfh/PnzOnLkiGw2m1q1aqWAgACzSwLwG7AOBoDfhYCAAAUHB8tisRAuABfAHAwApiotLdW0adMUFBSksLAwNW/eXHXr1tX06dNVWlpqdnkAqogRDACmmjBhghYtWqSXX35ZPXr0kM1m05dffqkpU6bo0qVLeumll8wuEUAVMAcDgKmaNGmiv/3tbxo0aFCZ9n/9618aN26ccnJyTKoMwG/BKRIApjp9+rQiIiLKtUdEROj06dMmVATACAQMAKbq1KmT3nrrrXLtb731ljp16mRCRQCMwCkSAKbasmWLBg4cqObNmys2NlYWi0Xbt29Xdna2NmzYoJ49e5pdIoAqIGAAMN3x48f19ttvKyMjQzabTZGRkRo3bpyaNGlidmkAqoiAAeB3KTs7W5MnT9bixYvNLgVAFRAwAPwu7dmzR9HR0SopKTG7FABVwCRPAABgOAIGAAAwHAEDAAAYjqXCAZjivvvuu+7zZ86cqZ5CADgFAQOAKYKCgn71+REjRlRTNQCMxlUkAADAcMzBAAAAhiNgAAAAwxEwAACA4QgYAADAcAQMAE539OhRWSwW7d69+3fzWrfffrsSExOdXg9QWxEwABc3cuRIWSwWjR07ttxz48aNk8Vi0ciRI8tsHx8f7/Dr/PTTT/Ly8lJERMRvqPa3Cw0NVW5urqKioiRJmzdvlsViYV0NoJoRMIBaIDQ0VCtXrtTFixftbZcuXdKKFSvUvHlzQ15j6dKlGjJkiAoLC/Xll18a0qejLl++LHd3dzVq1EgeHizzA5iJgAHUAtHR0WrevLnWrVtnb1u3bp1CQ0PVpUuX39y/zWbTkiVLNHz4cA0bNkyLFi361X0+/PBD3XjjjfL19VXv3r21bNmyciMNa9euVfv27eXt7a0WLVpo9uzZZfpo0aKFXnzxRY0cOVJBQUF6/PHHy5wiOXr0qHr37i1JqlevXrnRmtLSUr3wwgsKDg5Wo0aNNGXKlDL9WywWvfPOO7r77rvl5+endu3a6auvvtKhQ4d0++23y9/fX7GxsTp8+HCVPzvAVREwgFpi1KhRWrJkif3x4sWL9dhjjxnS96ZNm1RYWKg+ffpo+PDh+uc//6lz585dc/ujR4/qgQceUHx8vHbv3q0xY8ZowoQJZbZJS0vTkCFD9NBDD2nv3r2aMmWKJk6cqKVLl5bZ7pVXXlFUVJTS0tI0ceLEMs+FhoZq7dq1kqSDBw8qNzdXr7/+uv35ZcuWyd/fX998841mzZqladOmKTU1tUwf06dP14gRI7R7925FRERo2LBhGjNmjMaPH6+dO3dKkp588kmHPzPA5dkAuLRHH33UNnjwYNuJEyds3t7etszMTNvRo0dtPj4+thMnTtgGDx5se/TRR8tt74hhw4bZEhMT7Y87depke/fdd+2PMzMzbZJs6enpNpvNZvvLX/5ii4qKKtPHhAkTbJJsv/zyi73Pvn37ltnmz3/+sy0yMtL+OCwszBYfH19mm/9+rU2bNpXp96rbbrvNduutt5Zpu+mmm2x/+ctf7I8l2f73f//X/virr76ySbItWrTI3rZixQqbj49PRR8LUKsxggHUEg0aNNDAgQO1bNkyLVmyRAMHDlSDBg1+c79nzpzRunXr9Mgjj9jbHnnkES1evPia+xw8eFA33XRTmbabb765zOMDBw6oR48eZdp69OihH3/8USUlJfa2rl27Vrn2jh07lnncuHFj5efnX3ObkJAQSVKHDh3KtF26dEkFBQVVrgNwRcyCAmqRxx57zD6c//bbbxvS5z/+8Q9dunRJt9xyi73NZrOptLRU+/fvV2RkZLl9bDabLBZLuTZHt5Ekf3//Ktfu6elZ5rHFYlFpaek1t7laT0Vt/70fUNsxggHUIv3799fly5d1+fJl9evXz5A+Fy1apOeee067d++2f+3Zs0e9e/e+5ihGRESEvv322zJtV+czXBUZGalt27aVadu+fbvatGkjd3f3Stfn5eUlSWVGPQA4HyMYQC3i7u6uAwcO2P99LWfPni23UFVwcHC5S1p3796tXbt26f333y+3/sUf/vAHTZgwQTNnzizX/5gxYzRnzhz95S9/UUJCgnbv3m2fvHl1ROC5557TTTfdpOnTp2vo0KH66quv9NZbb2nevHkOveewsDBZLBZ9/PHHuuuuu+Tr66uAgACH+gDgOEYwgFomMDBQgYGB191m8+bN6tKlS5mvSZMmldtu0aJFioyMrHBxrfj4eJ0+fVofffRRuefCw8O1Zs0arVu3Th07dtT8+fPtV5F4e3tLunJp7T//+U+tXLlSUVFRmjRpkqZNm1bmMtPKaNq0qaZOnark5GSFhIRwxQdQTSy2ik5qAkA1e+mll/S3v/1N2dnZZpcCwACcIgFginnz5ummm25S/fr19eWXX+qVV15hdAFwIQQMAKb48ccf9eKLL+r06dNq3ry5nnvuOY0fP97ssgAYhFMkAADAcEzyBAAAhiNgAAAAwxEwAACA4QgYAADAcAQMAABgOAIGAAAwHAEDAAAYjoABAAAMR8AAAACG+/8A6YhVL9hBetQAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "if not targetDataName == 'None': # User specified one analyzed dataset above (if more than one were analyzed)\n", - " for each in datasets:\n", - " if not each == targetDataName:\n", - " datasets.remove(each)\n", - " print(\"Vizualized Datasets: \"+str(datasets))\n", - " \n", - "for each in datasets: #each analyzed dataset to make plots for\n", - " print(\"---------------------------------------\")\n", - " print(each)\n", - " print(\"---------------------------------------\")\n", - " full_path = experiment_path+'/'+each\n", - " \n", - " #Create Folder to store training evaluation results\n", - " if not os.path.exists(full_path+\"/model_training_evaluation\"):\n", - " os.mkdir(full_path+\"/model_training_evaluation\")\n", - " \n", - " #Create folder for tree vizualization files\n", - " original_headers = pd.read_csv(full_path+\"/exploratory/OriginalFeatureNames.csv\",sep=',').columns.values.tolist() #Get Original Headers\n", - " metric_dict = {}\n", - " result_table = []\n", - " for algorithm in algorithms: #loop through algorithms\n", - " alg_result_table = [] #stores values used in ROC and PRC plots\n", - " # Define evaluation stats variable lists\n", - " s_bac = [] # balanced accuracies\n", - " s_ac = [] # standard accuracies\n", - " s_f1 = [] # F1 scores\n", - " s_re = [] # recall values\n", - " s_sp = [] # specificities\n", - " s_pr = [] # precision values\n", - " s_tp = [] # true positives\n", - " s_tn = [] # true negatives\n", - " s_fp = [] # false positives\n", - " s_fn = [] # false negatives\n", - " s_npv = [] # negative predictive values\n", - " s_lrp = [] # likelihood ratio positive values\n", - " s_lrm = [] # likelihood ratio negative values\n", - " # Define ROC plot variable lists\n", - " tprs = [] # true postitive rates\n", - " aucs = [] #areas under ROC curve\n", - " mean_fpr = np.linspace(0, 1, 100) #used to plot all CVs in single ROC plot\n", - " mean_recall = np.linspace(0, 1, 100) #used to plot all CVs in single PRC plot\n", - " # Define PRC plot variable lists\n", - " precs = [] #precision values for PRC\n", - " praucs = [] #area under PRC curve\n", - " aveprecs = [] #average precisions for PRC\n", - " \n", - " for cvCount in range(0,cv_partitions): #loop through cv's\n", - " #load training data\n", - " train_file_path = full_path + '/CVDatasets/' + each + \"_CV_\" + str(cvCount) + \"_Train.csv\"\n", - " train = pd.read_csv(train_file_path)\n", - " if instance_label != 'None':\n", - " train = train.drop(instance_label,axis=1)\n", - " trainX = train.drop(class_label,axis=1).values\n", - " trainY = train[class_label].values\n", - " del train #memory cleanup\n", - " \n", - " #Load pickled metric file for given algorithm and cv\n", - " model_file = full_path+'/models/pickledModels/'+abbrev[algorithm]+\"_\"+str(cvCount)+'.pickle'\n", - " file = open(model_file, 'rb')\n", - " model = pickle.load(file)\n", - " file.close()\n", - " \n", - " # Determine probabilities of class predictions for each train instance (this will be used much later in calculating an ROC curve)\n", - " probas_ = model.predict_proba(trainX)\n", - "\n", - " #Get new class predictions given specified decision threshold\n", - " y_pred = probas_[:,1] > threshold\n", - "\n", - " integer_map = map(int, y_pred) \n", - " integer_list = list(integer_map)\n", - "\n", - " #Calculate standard classificaction metrics\n", - " metricList = classEval(trainY, y_pred)\n", - " # Compute ROC curve and area the curve\n", - " fpr, tpr, thresholds = metrics.roc_curve(trainY, probas_[:, 1])\n", - " roc_auc = auc(fpr, tpr)\n", - " # Compute Precision/Recall curve and AUC\n", - " prec, recall, thresholds = metrics.precision_recall_curve(trainY, probas_[:, 1])\n", - " prec, recall, thresholds = prec[::-1], recall[::-1], thresholds[::-1]\n", - " prec_rec_auc = auc(recall, prec)\n", - " ave_prec = metrics.average_precision_score(trainY, probas_[:, 1])\n", - "\n", - " #Separate metrics from metricList\n", - " s_bac.append(metricList[0])\n", - " s_ac.append(metricList[1])\n", - " s_f1.append(metricList[2])\n", - " s_re.append(metricList[3])\n", - " s_sp.append(metricList[4])\n", - " s_pr.append(metricList[5])\n", - " s_tp.append(metricList[6])\n", - " s_tn.append(metricList[7])\n", - " s_fp.append(metricList[8])\n", - " s_fn.append(metricList[9])\n", - " s_npv.append(metricList[10])\n", - " s_lrp.append(metricList[11])\n", - " s_lrm.append(metricList[12])\n", - " \n", - " #update list that stores values used in ROC and PRC plots\n", - " alg_result_table.append([fpr, tpr, roc_auc, prec, recall, prec_rec_auc, ave_prec])\n", - " # Update ROC plot variable lists needed to plot all CVs in one ROC plot\n", - " tprs.append(interp(mean_fpr, fpr, tpr))\n", - " tprs[-1][0] = 0.0\n", - " aucs.append(roc_auc)\n", - " # Update PRC plot variable lists needed to plot all CVs in one PRC plot\n", - " precs.append(interp(mean_recall, recall, prec))\n", - " praucs.append(prec_rec_auc)\n", - " aveprecs.append(ave_prec)\n", - "\n", - " # Define values for the mean ROC line (mean of individual CVs)\n", - " mean_tpr = np.mean(tprs, axis=0)\n", - " mean_tpr[-1] = 1.0\n", - " mean_auc = np.mean(aucs)\n", - " # Generate ROC Plot (including individual CV's lines, average line, and no skill line) - \n", - " # based on https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc_crossval.html-----------------------\n", - " if plot_ROC:\n", - " # Set figure dimensions\n", - " plt.rcParams[\"figure.figsize\"] = (6,6)\n", - " # Plot individual CV ROC lines\n", - " for i in range(cv_partitions):\n", - " plt.plot(alg_result_table[i][0], alg_result_table[i][1], lw=1, alpha=0.3,label='ROC fold %d (AUC = %0.3f)' % (i, alg_result_table[i][2]))\n", - " # Plot no-skill line\n", - " plt.plot([0, 1], [0, 1], linestyle='--', lw=2, color='r',label='No-Skill', alpha=.8)\n", - " # Plot average line for all CVs\n", - " std_auc = np.std(aucs) # AUC standard deviations across CVs\n", - " plt.plot(mean_fpr, mean_tpr, color=colors[algorithm],label=r'Mean ROC (AUC = %0.3f $\\pm$ %0.3f)' % (mean_auc, std_auc),lw=2, alpha=.8)\n", - " # Plot standard deviation grey zone of curves\n", - " std_tpr = np.std(tprs, axis=0)\n", - " tprs_upper = np.minimum(mean_tpr + std_tpr, 1)\n", - " tprs_lower = np.maximum(mean_tpr - std_tpr, 0)\n", - " plt.fill_between(mean_fpr, tprs_lower, tprs_upper, color='grey', alpha=.2,label=r'$\\pm$ 1 std. dev.')\n", - " #Specify plot axes,labels, and legend\n", - " plt.xlim([-0.05, 1.05])\n", - " plt.ylim([-0.05, 1.05])\n", - " plt.title(str(algorithm))\n", - " plt.xlabel('False Positive Rate')\n", - " plt.ylabel('True Positive Rate')\n", - " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", - " #Export and/or show plot\n", - " plt.savefig(full_path+'/model_training_evaluation/'+abbrev[algorithm]+\"_ROC.png\", bbox_inches=\"tight\")\n", - " plt.show()\n", - "\n", - " #Define values for the mean PRC line (mean of individual CVs)\n", - " mean_prec = np.mean(precs, axis=0)\n", - " mean_pr_auc = np.mean(praucs)\n", - " #Generate PRC Plot (including individual CV's lines, average line, and no skill line)------------------------------------------------------------------------------------------------------------------\n", - " if plot_PRC:\n", - " # Set figure dimensions\n", - " plt.rcParams[\"figure.figsize\"] = (6,6)\n", - " # Plot individual CV PRC lines\n", - " for i in range(cv_partitions):\n", - " plt.plot(alg_result_table[i][4], alg_result_table[i][3], lw=1, alpha=0.3, label='PRC fold %d (AUC = %0.3f)' % (i, alg_result_table[i][5]))\n", - " #Estimate no skill line based on the fraction of cases found in the first test dataset\n", - " test = pd.read_csv(full_path + '/CVDatasets/' + each + '_CV_0_Train.csv') #Technically there could be a unique no-skill line for each CV dataset based on final class balance (however only one is needed, and stratified CV attempts to keep partitions with similar/same class balance)\n", - " testY = test[class_label].values\n", - " noskill = len(testY[testY == 1]) / len(testY) # Fraction of cases\n", - " # Plot no-skill line\n", - " plt.plot([0, 1], [noskill, noskill], color='orange', linestyle='--', label='No-Skill', alpha=.8)\n", - " # Plot average line for all CVs\n", - " std_pr_auc = np.std(praucs)\n", - " # Plot standard deviation grey zone of curves\n", - " plt.plot(mean_recall, mean_prec, color=colors[algorithm],label=r'Mean PRC (AUC = %0.3f $\\pm$ %0.3f)' % (mean_pr_auc, std_pr_auc),lw=2, alpha=.8)\n", - " std_prec = np.std(precs, axis=0)\n", - " precs_upper = np.minimum(mean_prec + std_prec, 1)\n", - " precs_lower = np.maximum(mean_prec - std_prec, 0)\n", - " plt.fill_between(mean_recall, precs_lower, precs_upper, color='grey', alpha=.2,label=r'$\\pm$ 1 std. dev.')\n", - " #Specify plot axes,labels, and legend\n", - " plt.xlim([-0.05, 1.05])\n", - " plt.ylim([-0.05, 1.05])\n", - " plt.title(str(algorithm))\n", - " plt.xlabel('Recall (Sensitivity)')\n", - " plt.ylabel('Precision (PPV)')\n", - " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", - " #Export and/or show plot\n", - " plt.savefig(full_path+'/model_training_evaluation/'+abbrev[algorithm]+\"_PRC.png\", bbox_inches=\"tight\")\n", - " plt.show()\n", - " \n", - " #Export and save all CV metric stats for each individual algorithm -----------------------------------------------------------------------------\n", - " results = {'Balanced Accuracy': s_bac, 'Accuracy': s_ac, 'F1 Score': s_f1, 'Sensitivity (Recall)': s_re, 'Specificity': s_sp,'Precision (PPV)': s_pr, 'TP': s_tp, 'TN': s_tn, 'FP': s_fp, 'FN': s_fn, 'NPV': s_npv, 'LR+': s_lrp, 'LR-': s_lrm, 'ROC AUC': aucs,'PRC AUC': praucs, 'PRC APS': aveprecs}\n", - " dr = pd.DataFrame(results)\n", - " filepath = full_path+'/model_training_evaluation/'+abbrev[algorithm]+\"_performance\"+name_modifier+\".csv\"\n", - " dr.to_csv(filepath, header=True, index=False)\n", - " \n", - " #add to metric list\n", - " metric_dict[algorithm] = results\n", - " \n", - " #Store ave metrics for creating global ROC and PRC plots later\n", - " mean_ave_prec = np.mean(aveprecs)\n", - " result_dict = {'algorithm':algorithm,'fpr':mean_fpr, 'tpr':mean_tpr, 'auc':mean_auc, 'prec':mean_prec, 'recall':mean_recall, 'pr_auc':mean_pr_auc, 'ave_prec':mean_ave_prec}\n", - " result_table.append(result_dict)\n", - " \n", - " #Result table later used to create global ROC an PRC plots comparing average ML algorithm performance.\n", - " result_table = pd.DataFrame.from_dict(result_table)\n", - " result_table.set_index('algorithm',inplace=True)\n", - "\n", - " #Make list of metric names\n", - " my_metrics = list(metric_dict[algorithms[0]].keys())\n", - " \n", - " #Plot ROC and PRC curves comparing average ML algorithm performance (averaged over all CVs)\n", - " doPlotROC(result_table,colors,full_path)\n", - " doPlotPRC(result_table,colors,full_path,each,instance_label,class_label)\n", - " \n", - " #Save metric means and standard deviations\n", - " saveMetricMeans(full_path,my_metrics,metric_dict,name_modifier)\n", - " saveMetricStd(full_path,my_metrics,metric_dict,name_modifier)\n", - " \n", - " #Generate boxplots comparing algorithm performance for each standard metric, if specified by user\n", - " if plot_metric_boxplots:\n", - " metricBoxplots(full_path,my_metrics,algorithms,metric_dict,name_modifier) \n", - " \n", - " #Calculate and export Kruskal Wallis, Mann Whitney, and wilcoxon Rank sum stats if more than one ML algorithm has been run (for the comparison) - note stats are based on comparing the multiple CV models for each algorithm.\n", - " if run_sig_test:\n", - " if len(algorithms) > 1:\n", - " kruskal_summary = kruskalWallis(full_path,my_metrics,algorithms,metric_dict,sig_cutoff,name_modifier)\n", - " wilcoxonRank(full_path,my_metrics,algorithms,metric_dict,kruskal_summary,sig_cutoff,name_modifier)\n", - " mannWhitneyU(full_path,my_metrics,algorithms,metric_dict,kruskal_summary,sig_cutoff,name_modifier)\n", - " " - ] - }, - { - "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.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/UsefulNotebooks/GenPlots_CompositeFI.ipynb b/UsefulNotebooks/GenPlots_CompositeFI.ipynb deleted file mode 100644 index 82ba6f09..00000000 --- a/UsefulNotebooks/GenPlots_CompositeFI.ipynb +++ /dev/null @@ -1,756 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Useful Notebook: Generate Custom Composite Feature Importance Plots\n", - "**This notebook will allow users to generate custom variations of the composite feature importance plots.**\n", - "\n", - "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", - "\n", - "***\n", - "## Notebook Details\n", - "Generates custom feature importance plots: (1) to include all features in the dataset or (2) some different number of top features, (3) composite FI plots that also includes fractionation (each algorithm has limited total bar area to fill in the overall plot), or (4) to provide a way to generate modified versions of these plots without rerunning or directly editing the code in the original pipeline. \n", - "\n", - "When run, 'as-is' this notebook will generate 4 feature composite plots: (1) normalized only, (2) normalized and weighted, (3) normalized and fractionated, and (4) normalized, weighted, and fractionated. However these plots will illustrate all features in the processed data (unless the user changes `top_model_features`). These plots will also present mean FI scores (but the user can change this to median using `fi_ranking`, and they will weight these FI scores using mean model balanced accuracy (however users can change this to median, and some other metric weighting with `fi_weighting` and `metric_weight`, respectively. These will be saved in the same location as the original composite feature importance plots within the experiment folder." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Notebook Run Parameters\n", - "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed). \n", - "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "experiment_path = \"../DemoOutput/demo_experiment\" # path the target experiment folder \n", - "targetDataName = None # 'None' if user wants to generate visualizations for all analyzed datasets\n", - "algorithms = [] # use empty list if user wishes to plot feature importance for all modeling algorithms that were run in pipeline.\n", - "top_model_features = None # None - to plot all features in original dataset, or specify some (int) to indicate # of top features to plot.\n", - "name_modifier = '_AllFeatures' # Modifies standard composite FI plot filename to avoid overwriting originals.\n", - "viz_norm_only = True # Generate plot with only FI normalization\n", - "viz_norm_weight = True #Generate plot with FI normalization and performance metric weighting\n", - "viz_norm_frac = True # Generate plot with FI normalization and fractionation (each algorithm has limited bar area to distribute in plot)\n", - "viz_norm_weight_frac = True #Generate plot with FI normalization performance metric weighting and fractionation\n", - "legend_inside_plot = True # place legend ouside plot in upper right hand corner, other wise placed inside on upper right hand corner.\n", - "fi_ranking = 'mean' # specify either 'mean' or 'median' to indicate whether to take the mean or median CV FI value for these plots.\n", - "fi_weighting = 'mean' #sepcify either 'mean' or 'median' to indicate whether to take the mean or median of selected evaluation metric to weigh FI scores in composite FI plot\n", - "metric_weight = 'Balanced Accuracy' # model evaluation metric used to weigh model feature importances" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Housekeeping\n", - "### Import Packages" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import pandas as pd\n", - "import pickle\n", - "from statistics import mean, stdev, median\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib import rc\n", - "import numpy as np\n", - "#from streamline.modeling.utils import ABBREVIATION, COLORS\n", - "import seaborn as sns\n", - "sns.set_theme()\n", - "\n", - "import warnings\n", - "warnings.filterwarnings('ignore')\n", - "\n", - "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", - "from IPython.core.interactiveshell import InteractiveShell\n", - "InteractiveShell.ast_node_interactivity = \"all\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Automatically detect data folder names" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Analyzed Datasets: ['hcc_data', 'hcc_data_custom']\n" - ] - } - ], - "source": [ - "# Get dataset paths for all completed dataset analyses in experiment folder\n", - "datasets = os.listdir(experiment_path)\n", - "\n", - "# Name of experiment folder\n", - "experiment_name = experiment_path.split('/')[-1] \n", - "\n", - "datasets = os.listdir(experiment_path)\n", - "remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", - " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs',\n", - " 'KeyFileCopy', 'dask_logs',\n", - " experiment_name + '_STREAMLINE_Report.pdf']\n", - "for text in remove_list:\n", - " if text in datasets:\n", - " datasets.remove(text)\n", - "\n", - "datasets = sorted(datasets) # ensures consistent ordering of datasets\n", - "print(\"Analyzed Datasets: \" + str(datasets))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Load other necessary parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Algorithms Ran: ['Decision Tree', 'Logistic Regression', 'Naive Bayes']\n" - ] - } - ], - "source": [ - "# Unpickle metadata from previous phase\n", - "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", - "metadata = pickle.load(file)\n", - "file.close()\n", - "# Load variables specified earlier in the pipeline from metadata\n", - "class_label = metadata['Class Label']\n", - "instance_label = metadata['Instance Label']\n", - "cv_partitions = int(metadata['CV Partitions'])\n", - "\n", - "# Unpickle algorithm information from previous phase\n", - "file = open(experiment_path + '/' + \"algInfo.pickle\", 'rb')\n", - "algInfo = pickle.load(file)\n", - "file.close()\n", - "algorithms = []\n", - "abbrev = {}\n", - "colors = {}\n", - "algColors = []\n", - "for key in algInfo:\n", - " if algInfo[key][0]: # If that algorithm was used\n", - " algorithms.append(key)\n", - " algColors.append(algInfo[key][2])\n", - " abbrev[key] = (algInfo[key][1])\n", - " colors[key] = (algInfo[key][2])\n", - "#colors = dict((k, COLORS[k]) for k in algorithms if k in COLORS)\n", - "print(\"Algorithms Ran: \" + str(algorithms))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define necessary methods" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "def primaryStats(algorithms, original_headers, cv_partitions, full_path, data_name, instance_label, class_label, abbrev):\n", - " \"\"\"\n", - " Combine classification metrics and model feature importance scores\n", - " \"\"\"\n", - " metric_dict = {}\n", - " for algorithm in algorithms: #completed for each individual ML modeling algorithm\n", - " # Define evaluation stats variable lists\n", - " s_bac = [] # balanced accuracies\n", - " s_ac = [] # standard accuracies\n", - " s_f1 = [] # F1 scores\n", - " s_re = [] # recall values\n", - " s_sp = [] # specificities\n", - " s_pr = [] # precision values\n", - " s_tp = [] # true positives\n", - " s_tn = [] # true negatives\n", - " s_fp = [] # false positives\n", - " s_fn = [] # false negatives\n", - " s_npv = [] # negative predictive values\n", - " s_lrp = [] # likelihood ratio positive values\n", - " s_lrm = [] # likelihood ratio negative values\n", - " aucs = [] #areas under ROC curve\n", - " praucs = [] #area under PRC curve\n", - " aveprecs = [] #average precisions for PRC\n", - " \n", - " # Define feature importance lists\n", - " FI_all = [] # used to save model feature importances individually for each cv within single summary file (all original features in dataset prior to feature selection included)\n", - " FI_ave = [0] * len(original_headers) # used to save average FI scores over all cvs. (all original features in dataset prior to feature selection included)\n", - " # Gather statistics over all CV partitions\n", - " for cvCount in range(0,cv_partitions):\n", - " # Unpickle saved metrics from previous phase\n", - " result_file = full_path + '/model_evaluation/pickled_metrics/' + abbrev[algorithm] + \"_CV_\" + str(cvCount) + \"_metrics.pickle\"\n", - " file = open(result_file, 'rb')\n", - " results = pickle.load(file)\n", - " file.close()\n", - " # Separate pickled results\n", - " metricList = results[0]\n", - " roc_auc = results[3]\n", - " prec_rec_auc = results[6]\n", - " ave_prec = results[7]\n", - " fi = results[8]\n", - " # Separate metrics from metricList\n", - " s_bac.append(metricList[0])\n", - " s_ac.append(metricList[1])\n", - " s_f1.append(metricList[2])\n", - " s_re.append(metricList[3])\n", - " s_sp.append(metricList[4])\n", - " s_pr.append(metricList[5])\n", - " s_tp.append(metricList[6])\n", - " s_tn.append(metricList[7])\n", - " s_fp.append(metricList[8])\n", - " s_fn.append(metricList[9])\n", - " s_npv.append(metricList[10])\n", - " s_lrp.append(metricList[11])\n", - " s_lrm.append(metricList[12])\n", - " aucs.append(roc_auc)\n", - " praucs.append(prec_rec_auc)\n", - " aveprecs.append(ave_prec)\n", - " \n", - " # Format feature importance scores as list (takes into account that all features are not in each CV partition)\n", - " tempList = []\n", - " j = 0\n", - " headers = pd.read_csv(full_path + '/CVDatasets/' + data_name + '_CV_' + str(cvCount) + '_Test.csv').columns.values.tolist()\n", - " if instance_label != None:\n", - " headers.remove(instance_label)\n", - " headers.remove(class_label)\n", - " for each in original_headers:\n", - " if each in headers: # Check if current feature from original dataset was in the partition\n", - " # Deal with features not being in original order (find index of current feature list.index()\n", - " f_index = headers.index(each)\n", - " FI_ave[j] += fi[f_index]\n", - " tempList.append(fi[f_index])\n", - " else:\n", - " tempList.append(0)\n", - " j += 1\n", - " FI_all.append(tempList)\n", - " # Export and save all CV metric stats for each individual algorithm -----------------------------------------------------------------------------\n", - " results = {'Balanced Accuracy': s_bac, 'Accuracy': s_ac, 'F1_Score': s_f1, 'Sensitivity (Recall)': s_re, 'Specificity': s_sp,'Precision (PPV)': s_pr, 'TP': s_tp, 'TN': s_tn, 'FP': s_fp, 'FN': s_fn, 'NPV': s_npv, 'LR+': s_lrp, 'LR-': s_lrm, 'ROC_AUC': aucs,'PRC_AUC': praucs, 'PRC_APS': aveprecs}\n", - " metric_dict[algorithm] = results\n", - "\n", - " #Turn FI sums into averages\n", - " for i in range(0, len(FI_ave)):\n", - " FI_ave[i] = FI_ave[i] / float(cv_partitions)\n", - "\n", - " return metric_dict\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "def prepFI(algorithms,full_path,abbrev,metric_dict,metric_weight,fi_ranking,fi_weighting):\n", - " \"\"\" Organizes and prepares model feature importance data for boxplot and composite feature importance figure generation.\"\"\"\n", - " #Initialize required lists\n", - " fi_df_list = [] # algorithm feature importance dataframe list (used to generate FI boxplots for each algorithm)\n", - " fi_ave_list = [] # algorithm feature importance averages list (used to generate composite FI barplots)\n", - " ave_metric_list = [] # algorithm focus metric averages list (used in weighted FI viz)\n", - " all_feature_list = [] # list of pre-feature selection feature names as they appear in FI reports for each algorithm\n", - " #Get necessary feature importance data and primary metric data (currenly only 'balanced accuracy' can be used for this)\n", - " for algorithm in algorithms:\n", - " # Get relevant feature importance info\n", - " temp_df = pd.read_csv(full_path+'/model_evaluation/feature_importance/'+abbrev[algorithm]+\"_FI.csv\") #CV FI scores for all original features in dataset.\n", - " if algorithm == algorithms[0]: # Should be same for all algorithm files (i.e. all original features in standard CV dataset order)\n", - " all_feature_list = temp_df.columns.tolist()\n", - " fi_df_list.append(temp_df)\n", - " if fi_ranking =='mean':\n", - " fi_ave_list.append(temp_df.mean().tolist()) #Saves average FI scores over CV runs\n", - " elif fi_ranking =='median':\n", - " fi_ave_list.append(temp_df.median().tolist()) #Saves average FI scores over CV runs\n", - " else:\n", - " print(\"Error: fi_ranking selection not found (must be mean or median) \")\n", - " # Get relevant metric info\n", - " if fi_weighting =='mean':\n", - " avgBA = mean(metric_dict[algorithm][metric_weight])\n", - " elif fi_weighting =='median':\n", - " avgBA = median(metric_dict[algorithm][metric_weight])\n", - " ave_metric_list.append(avgBA)\n", - " #Normalize Average Feature importance scores so they fall between (0 - 1)\n", - " fi_ave_norm_list = []\n", - " for each in fi_ave_list: # each algorithm\n", - " normList = []\n", - " for i in range(len(each)): #each feature (score) in original data order\n", - " if each[i] <= 0: #Feature importance scores assumed to be uninformative if at or below 0\n", - " normList.append(0)\n", - " else:\n", - " normList.append((each[i]) / (max(each)))\n", - " fi_ave_norm_list.append(normList)\n", - " #Identify features with non-zero averages (step towards excluding features that had zero feature importance for all algorithms)\n", - " alg_non_zero_FI_list = [] #stores list of feature name lists that are non-zero for each algorithm\n", - " for each in fi_ave_list: # each algorithm\n", - " temp_non_zero_list = []\n", - " for i in range(len(each)): # each feature\n", - " if each[i] > 0.0:\n", - " temp_non_zero_list.append(all_feature_list[i]) #add feature names with positive values (doesn't need to be normalized for this)\n", - " alg_non_zero_FI_list.append(temp_non_zero_list)\n", - " non_zero_union_features = alg_non_zero_FI_list[0] # grab first algorithm's list\n", - " #Identify union of features with non-zero averages over all algorithms (i.e. if any algorithm found a non-zero score it will be considered for inclusion in top feature visualizations)\n", - " for j in range(1, len(algorithms)):\n", - " non_zero_union_features = list(set(non_zero_union_features) | set(alg_non_zero_FI_list[j]))\n", - " non_zero_union_indexes = []\n", - " for i in non_zero_union_features:\n", - " non_zero_union_indexes.append(all_feature_list.index(i))\n", - " return fi_df_list,fi_ave_norm_list,ave_metric_list,all_feature_list,non_zero_union_features,non_zero_union_indexes" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def selectForViz(top_model_features,non_zero_union_features,non_zero_union_indexes,algorithms,ave_metric_list,fi_ave_norm_list):\n", - " \"\"\" Identify list of top features over all algorithms to visualize (note that best features to vizualize are chosen using algorithm performance weighting and normalization:\n", - " frac plays no useful role here only for viz). All features included if there are fewer than 'top_model_features'. Top features are determined by the sum of performance\n", - " (i.e. balanced accuracy) weighted feature importances over all algorithms.\"\"\"\n", - " featuresToViz = None\n", - " #Create performance weighted score sum dictionary for all features\n", - " scoreSumDict = {}\n", - " i = 0\n", - " for each in non_zero_union_features: # for each non-zero feature\n", - " for j in range(len(algorithms)): # for each algorithm\n", - " # grab target score from each algorithm\n", - " score = fi_ave_norm_list[j][non_zero_union_indexes[i]]\n", - " # multiply score by algorithm performance weight\n", - " weight = ave_metric_list[j]\n", - " if weight <= .5:\n", - " weight = 0\n", - " if not weight == 0:\n", - " weight = (weight - 0.5) / 0.5\n", - " score = score * weight\n", - " #score = score * ave_metric_list[j]\n", - " if not each in scoreSumDict:\n", - " scoreSumDict[each] = score\n", - " else:\n", - " scoreSumDict[each] += score\n", - " i += 1\n", - " # Sort features by decreasing score\n", - " scoreSumDict_features = sorted(scoreSumDict, key=lambda x: scoreSumDict[x], reverse=True)\n", - " if top_model_features == None or not len(non_zero_union_features) > top_model_features:\n", - " featuresToViz = scoreSumDict_features\n", - " else:\n", - " featuresToViz = scoreSumDict_features[0:top_model_features]\n", - "\n", - " return featuresToViz #list of feature names to vizualize in composite FI plots." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "def getFI_To_Viz_Sorted(featuresToViz,all_feature_list,algorithms,fi_ave_norm_list):\n", - " \"\"\" Takes a list of top features names for vizualization, gets their indexes. In every composite FI plot features are ordered the same way\n", - " they are selected for vizualization (i.e. normalized and performance weighted). Because of this feature bars are only perfectly ordered in\n", - " descending order for the normalized + performance weighted composite plot. \"\"\"\n", - " #Get original feature indexs for selected feature names\n", - " feature_indexToViz = [] #indexes of top features\n", - " for i in featuresToViz:\n", - " feature_indexToViz.append(all_feature_list.index(i))\n", - " # Create list of top feature importance values in original dataset feature order\n", - " top_fi_ave_norm_list = [] #feature importance values of top features for each algorithm (list of lists)\n", - " for i in range(len(algorithms)):\n", - " tempList = []\n", - " for j in feature_indexToViz: #each top feature index\n", - " tempList.append(fi_ave_norm_list[i][j]) #add corresponding FI value\n", - " top_fi_ave_norm_list.append(tempList)\n", - " all_feature_listToViz = featuresToViz\n", - " return top_fi_ave_norm_list,all_feature_listToViz" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def composite_FI_plot(fi_list, algorithms, algColors, all_feature_listToViz, figName,full_path,yLabelText,name_modifier,legend_inside_plot,fi_ranking,fi_weighting,metric_weight):\n", - "\n", - " algorithms, algColors, fi_list = (list(t) for t in zip(*sorted(zip(algorithms, algColors, fi_list), reverse=True)))\n", - " # Set basic plot properties\n", - " rc('font', weight='bold', size=16)\n", - " # The position of the bars on the x-axis\n", - " r = all_feature_listToViz # feature names\n", - " # Set width of bars\n", - " bar_width = 0.75\n", - " # Set figure dimensions\n", - " plt.figure(figsize=(24, 12))\n", - " # Plot first algorithm FI scores (lowest) bar\n", - " p1 = plt.bar(r, fi_list[0], color=algColors[0], edgecolor='white', width=bar_width)\n", - " # Automatically calculate space needed to plot next bar on top of the one before it\n", - " bottoms = [] # list of space used by previous\n", - " # algorithms for each feature (so next bar can be placed directly above it)\n", - " bottom = None\n", - " for i in range(len(algorithms) - 1):\n", - " for j in range(i + 1):\n", - " if j == 0:\n", - " bottom = np.array(fi_list[0]).astype('float64')\n", - " else:\n", - " bottom += np.array(fi_list[j]).astype('float64')\n", - " bottoms.append(bottom)\n", - " if not isinstance(bottoms, list):\n", - " bottoms = bottoms.tolist()\n", - " if len(algorithms) > 1:\n", - " # Plot subsequent feature bars for each subsequent algorithm\n", - " ps = [p1[0]]\n", - " for i in range(len(algorithms) - 1):\n", - " p = plt.bar(r, fi_list[i + 1], bottom=bottoms[i], color=algColors[i + 1], edgecolor='white',\n", - " width=bar_width)\n", - " ps.append(p[0])\n", - " lines = tuple(ps)\n", - " else:\n", - " ps = [p1[0]]\n", - " lines = tuple(ps)\n", - " # Specify axes info and legend\n", - " plt.xticks(np.arange(len(all_feature_listToViz)), all_feature_listToViz, rotation='vertical')\n", - " plt.xlabel(\"Features (ranked by sum of \"+fi_ranking+\" feature importance: weighted by \"+fi_weighting+\" model \"+metric_weight.lower()+\")\", fontsize=20)\n", - " plt.ylabel(yLabelText, fontsize=20)\n", - " algorithms_list, lines_list = (list(t) for t in zip(*sorted(zip(algorithms, lines))))\n", - " if legend_inside_plot:\n", - " plt.legend(lines[::-1], algorithms[::-1],loc=\"upper right\")\n", - " else:\n", - " plt.legend(lines[::-1], algorithms[::-1],loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", - " # Export and/or show plot\n", - " plt.savefig(full_path+'/model_evaluation/feature_importance/Compare_FI_' + figName +name_modifier+ '.png', bbox_inches='tight')\n", - " plt.show()\n", - " \n", - "\n", - " \n", - " \"\"\" Generate composite feature importance plot given list of feature names and associated feature importance scores for each algorithm.\n", - " This is run for different transformations of the normalized feature importance scores. \"\"\"\n", - " \"\"\"\n", - " # Set basic plot properites\n", - " rc('font', weight='bold', size=16)\n", - " # The position of the bars on the x-axis\n", - " r = all_feature_listToViz #feature names\n", - " #Set width of bars\n", - " barWidth = 0.75\n", - " #Set figure dimensions\n", - " plt.figure(figsize=(24, 12))\n", - " #Plot first algorithm FI scores (lowest) bar\n", - " p1 = plt.bar(r, fi_list[0], color=algColors[0], edgecolor='white', width=barWidth)\n", - " #Automatically calculate space needed to plot next bar on top of the one before it\n", - " bottoms = [] #list of space used by previous algorithms for each feature (so next bar can be placed directly above it)\n", - " for i in range(len(algorithms) - 1):\n", - " for j in range(i + 1):\n", - " if j == 0:\n", - " bottom = np.array(fi_list[0])\n", - " else:\n", - " bottom += np.array(fi_list[j])\n", - " bottoms.append(bottom)\n", - " if not isinstance(bottoms, list):\n", - " bottoms = bottoms.tolist()\n", - " #Plot subsequent feature bars for each subsequent algorithm\n", - " ps = [p1[0]]\n", - " for i in range(len(algorithms) - 1):\n", - " p = plt.bar(r, fi_list[i + 1], bottom=bottoms[i], color=algColors[i + 1], edgecolor='white', width=barWidth)\n", - " ps.append(p[0])\n", - " lines = tuple(ps)\n", - " # Specify axes info and legend\n", - " plt.xticks(np.arange(len(all_feature_listToViz)), all_feature_listToViz, rotation='vertical')\n", - " plt.xlabel(\"Feature\", fontsize=20)\n", - " plt.ylabel(yLabelText, fontsize=20)\n", - " if legend_inside_plot:\n", - " plt.legend(lines[::-1], algorithms[::-1],loc=\"upper right\")\n", - " else:\n", - " plt.legend(lines[::-1], algorithms[::-1],loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", - " #Export and/or show plot\n", - " plt.savefig(full_path+'/model_evaluation/feature_importance/Compare_FI_' + figName +name_modifier+ '.png', bbox_inches='tight')\n", - " plt.show()\n", - " \"\"\"" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def fracFI(top_fi_ave_norm_list):\n", - " \"\"\" Transforms feature scores so that they sum to 1 over all features for a given algorithm. This way the normalized and fracionated composit bar plot\n", - " offers equal total bar area for every algorithm. The intuition here is that if an algorithm gives the same FI scores for all top features it won't be\n", - " overly represented in the resulting plot (i.e. all features can have the same maximum feature importance which might lead to the impression that an\n", - " algorithm is working better than it is.) Instead, that maximum 'bar-real-estate' has to be divided by the total number of features. Notably, this\n", - " transformation has the potential to alter total algorithm FI bar height ranking of features. \"\"\"\n", - " fracLists = []\n", - " for each in top_fi_ave_norm_list: #each algorithm\n", - " fracList = []\n", - " for i in range(len(each)): #each feature\n", - " if sum(each) == 0: #check that all feature scores are not zero to avoid zero division error\n", - " fracList.append(0)\n", - " else:\n", - " fracList.append((each[i] / (sum(each))))\n", - " fracLists.append(fracList)\n", - " return fracLists" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "def weightFI(ave_metric_list,top_fi_ave_norm_list):\n", - " \"\"\" Weights the feature importance scores by algorithm performance (intuitive because when interpreting feature importances we want to place more weight on better performing algorithms) \"\"\"\n", - " # Prepare weights\n", - " weights = []\n", - " # replace all balanced accuraces <=.5 with 0 (i.e. these are no better than random chance)\n", - " for i in range(len(ave_metric_list)):\n", - " if ave_metric_list[i] <= .5:\n", - " ave_metric_list[i] = 0\n", - " # normalize balanced accuracies\n", - " for i in range(len(ave_metric_list)):\n", - " if ave_metric_list[i] == 0:\n", - " weights.append(0)\n", - " else:\n", - " weights.append((ave_metric_list[i] - 0.5) / 0.5)\n", - " # Weight normalized feature importances\n", - " weightedLists = []\n", - " for i in range(len(top_fi_ave_norm_list)): #each algorithm\n", - " weightList = np.multiply(weights[i], top_fi_ave_norm_list[i]).tolist()\n", - " weightedLists.append(weightList)\n", - " return weightedLists,weights" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "def weightFracFI(fracLists,weights):\n", - " \"\"\" Weight normalized and fractionated feature importances. \"\"\"\n", - " weightedFracLists = []\n", - " for i in range(len(fracLists)):\n", - " weightList = np.multiply(weights[i], fracLists[i]).tolist()\n", - " weightedFracLists.append(weightList)\n", - " return weightedFracLists" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Generate composite feature importance plots" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------------------------\n", - "Dataset: hcc_data\n", - "---------------------------------------\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------------------------\n", - "Dataset: hcc_data_custom\n", - "---------------------------------------\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAB6IAAATWCAYAAACPNWhcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5hV5b024GfPDDJUKSqCgl2xREWwk2hs0cQWxBIVe4lKNCZq1Ogx0c/EWGJv0WjshlhQo7GR2LGBiopYsIAKsQAivcz+/vAwCQfLsGcjU+77uuY6w9rvWs/vnZn4z3PWWoVisVgMAAAAAAAAAJRJxeIeAAAAAAAAAICmRRENAAAAAAAAQFkpogEAAAAAAAAoK0U0AAAAAAAAAGWliAYAAAAAAACgrBTRAAAAAAAAAJSVIhoAAAAAAACAslJEAwAAAAAAAFBWimgAAAAAAAAAyqpqcQ/QFBWLxdTUFBf3GM1SRUVhsfzs5Tbd3Oa0V7lNN1Nu085tTnuV23Qz5Tbt3Oa0V7lNN1Nu085tTnuV23Qz5TbdTLlNO7c57VVu081sjrl88bMvFArfuE4RvQjU1BQzYcLUxT1Gs1NVVZGOHdtk8uRpmTOnRq7cRpkpt2nnNqe9yvU3Jbdx5janvcr1NyW3ceY2p73K9Tclt3HmNqe9Nrfc5rRXuf6m5DbO3Oa018WZyxc6dWqTyspvLqI9mhsAAAAAAACAslJEAwAAAAAAAFBWimgAAAAAAAAAykoRDQAAAAAAAEBZKaIBAAAAAAAAKKuqxT0AAAAAAAAAfNuKxWJqampSUzO3rNetqSlkxozKzJo1M3PnFst67YaU2Rxzm4PKyqpUVJTnXmZFNAAAAAAAAM1GsVjM9OlTMmXKZ2Uvoef55JOK1NTULJJrN6TM5pjbHLRq1Tbt23dKoVCo13UU0QAAAAAAADQbkydPyPTpU1Jd3SbV1a1TUVFZ78Lt/6qsLHzrd+oujszmmNuUFYvFzJo1M1OmTEySLLlk53pdTxENAAAAAABAs1BTMzfTp09N27Yd0rbtkossp6qqInPmfLt36y6OzOaY29QtsUTLJMmUKRPTrl3Hej2muzwP+AYAAAAAAIAGbu7cuUmKadmyenGPAg3WvDJ67tw59bqOIhoAAAAAAIBmpryP4oampFyPqvdobgAAAAAAAEhSUVFIRUX9S7jKyoW7F7SmppiaGu87pmlRRAMAAAAAANDsVVQU0qlTdQqFb78+KxbnZMKEGQtVRvfvv1PGjx9X++/Kyqp06LBkevXqk0MPPSLLLbd8WWecl3fuuRdlk002q9M5ffv2SZLcdNNtWWGFFcs6z3+777578rvf/fZr15x88mn54Q93WmQzsCBFNAAAAAAAAM1eRUXhf0vofZK89i0mr5lC4aZUVBRKuit6nXXWTYcOHTJz5sy8+ebrefjhB/L888/k6qtvyLLLdi3blBtuuEkmTZqQTp061fmc7353iyRJ69atyzbHl+nSZdnarBkzZuS5555Jkmy++XdTUVFRu4ZvlyIaAAAAAAAAar2W5IXFPUSdHXDAIdlkk81SVVWRKVOm5YQTfp7hw5/PZZddlNNP/33Zcn71q18v9Dm///15Zcv/Or17b5jevTdMkowb92F2333nJMnpp5+Vli1bfiszsCBFNAAAAAAAADQB1dXVOfDAQzN8+PN54olHM2vWrCyxxBL5/PPPc/HFf8wTTzyWmTNnZM01186RRx6dtdZap/bcl19+KX/602UZOfKVtGixRNZe+zs56qijs/LKqyZZ8NHc48ePy6WXXpiXXnohU6Z8nk6dOmfrrbfLoYcekaqqLyrIL3s09/Dhz+cvf7k6o0Z9cdf5euutn8MOOzKrrbZG7edHH/3TrL/+Btl553655porM2HChPTsuWZ+8YtfZcUVVyrpZzOvoF522a7Zdtvtc+edt6Vbt+Xy5z/fkI8++ncuvviPefbZZ1IsFtOrV+8MHPjz9OixQu35d999Z26++YaMH/9hunRZNrvu2j8/+cm+Jc3SXCzcm9IBAAAAAACABmteoTtr1qyMHTsmxWIxxx9/TO677560b79k1lln3bz88ks5+uifZsyY95Ikb7wxKsccc0ReeGFYVlpplXTr1i3PPPNUjj76p5k8+bMvzTnttJPzr389nI4dO2aDDfpk6tSpuemm63LVVZd/5WzPPDM0P//5kRk+/PmssMKK6dq1W4YOfTJHHHFwbTE9z1tvvZFzzjkzXbp0TbFYzPDhz+e8886q98/n3/8en7/97ZasuupqWW+9XpkxY0Z+9rPD88gj/0y3bstltdVWz9ChT2TgwMPy2WeTkiSDB9+Ws88+MxMmfJoNNuiTGTOm59JLL8hf/nJ1vedpytwRDQAAAAAAAE1Eq1atar+fOnVKhg17Lq+8MiKrrLJarrnmxlRWVmbw4Nty7rlnZdCgm3PccSfl5ptvyKxZs7LTTrvmV786JUly5pm/yfTp0/Lhhx+kffslF8gZO3ZMkuTYY4/Leuv1zjvvjM6wYc+nZ881v3K2Sy45PzU1NTnkkJ/mgAMOSZKce+7vM3jw7bnssgtz0UVX1K6dMmVKrrjimqyzzroZMuShnHbaSXn11Vfq/fMpFos58cRTs802P0iS/P3vg/Phhx9ks8365uyzL0iSXH75xbnpputyzz2Ds+++B+T6669Nklx00eXp2XOtTJ78Wfr1+1FuvfXG7LPP/mnRokW952qKFNEAAAAAAADQRMyYMb32+1atWuWVV0YkSUaPfjNbbLHxfGtfffXlJF/cfZwkG2+8ae1nv/71b7425yc/GZArr7wkAwf+NO3atc96662fzTb7btZY48uL6MmTP8s777ydJNlxx11rj++0048zePDtGTHixRSLxflmX2eddZMkq6zyxePBZ82a+bUz1dX6629Q+/3rr7+eJHnqqSdqHyU+z6uvvpKJEyfmo4/+nSQ55JD9FrjWu+++k9VWW70sczU1imgAAAAAAABoIt5+e3SSpLKyMt27r5AXXhiWJOnceamstdba863t0KFjktQWwHPnzq39bObMmWnZsuVX5gwYcEA23XTzPPnko3nhheEZNuz5PPHEY7n33rtz5ZXXLrC+UFi4NwZXV//nzu5575wulzZt2i5w7eWWWz4rr7zKfOtWXHGl+bI326xvKisr51tTUeFNyF9FEQ0AAAAAAABNwKxZs3LLLTcmSb73ve+nuro6K630Rbm6xBItc9ppZ6a6ujqPPDIkI0e+mg033ChJsuqqq+e9997NU089nq233i5JcuqpJ+aFF4blF784ITvssON8ORMnTsg111yVTz75KL/97ZnZf/9D8umnn2SXXbbPq6++nMmTJ6d9+/bzndOuXbt0794jY8eOyd//Prj20dz33HNnkmS99XqlUCjUrv/v78vtv8vjeeVzp06d8v/+39n/++jy2/Pxxx9l882/m3bt2mXppZfJxx9/lH799sgmm2yWiRMn5M9/vjIrrrhSVlhhxUU2Z2OniAYAAAAAAIBG6i9/uTp33XV75s6dmzfeeD2ffPJxllxyyRxxxM+SJH36bJSePdfKqFEjs/feu6Vbt+XyyisjMnfu3Ky77npJvnjM9mOP/SsPPPCPvPPO26msrMxrr41Mhw4dsuGGmyyQ2aFDx4wc+Upef/217LXXbll55VXy3nvvJkl69lxrgRJ6nsMPPyqnnnpirr76ijz55OOZNWtWRo9+M9XV1TniiKMXzQ/oG2y33fa59tqr8vLLI7LPPrunY8cOeeWVl1NVVZXvfnfLJMm+++6f888/Jyed9Musu+76eeedtzNhwqfZYovvp3//vRbL3I2BIhoAAAAAAABqffk7jhtq3rx3QFdWVqZDhw75wQ9+mIMOOizdui2X5Is7i88554JcdtlFGTr0iYwc+WpWXHHl7LffQenbd4skSc+ea+b88y/NVVddntdeG5mWLVtmk002y+GHD8xSSy21QGahUMh5512cq666LEOHPplhw55Lx46dsuOOu+TQQ4/4ylm33HLr/PGPl+SGG67Na6+NTJL/zTkqq622Rr1+DqVq2bI6F198ZS677MIMG/Z8Pvnko6y99ndy6KFHpGfPL343u+22Z4rFYu64428ZMeLFtG+/ZPr33ytHHDFwsczcWCiiAQAAAAAAaPZqaoopFuekULjpW88uFuekpqa4UOfcdts98/27qqoic+bUfOnajh075de//s3XXm/99TfIpZdeVee8Dh065PjjT/7a3CeeeH6BYxtuuHE23HDjr8zZYIM+C5y3/PLdv/RaX6Zr125fuvarjidfvB/6zDPP+drr9u+/l7ufF5IiGgAAAAAAgGavpqaYCRNmpKKi/u8mrqysyNy5X17OflX2whbR0NApogEAAAAAACDlLYS/6i5haC4qFvcAAAAAAAAAADQtimgAAAAAAAAAykoRDQAAAAAAAEBZKaIBAAAAAAAAKCtFNAAAAAAAAABlpYgGAAAAAAAAoKwU0QAAAAAAAACUlSIaAAAAAAAAklRUFFJVVVHvr8rKhVtfUVFY6Fn7998pffv2ydNPP7UIfhLly3v44Qfy9ttv1fs6/23gwMOyySYbpG/fPrVfW221eXbffeecf/7ZmTZtWsnXbojuu++e9O3bJ4cddsDiHmWhVC3uAQAAAAAAAGBxq6gopEOHVqmsrPzWs+fOnZtJk6anpqb4rWfX1YYbbpJJkyakU6dOdT7nF7/4WZ59dmguuuiKel3nq6y66urp2rVrkmTatOl5+eUXc/vtgzJ16tSccspv6339hqJLl2Xz3e9uke7dV1jcoywURTQAAAAAAADNXkVFIZWVlbn22mszfvz4by132WWXzYEHHpiKikKDLqJ/9atfL/Q577wzuizX+Sq77tovu+7av/bfQ4Y8lNNOOykPPXR/jj/+pLRsWV22rMWpd+8N07v3hot7jIWmiAYAAAAAAID/NX78+IwdO3Zxj1E2w4c/n7/85eqMGvVakmS99dbPYYcdmdVWW6N2zSuvjMhFF/0xb731Rrp1Wy4/+9kvcuaZv8mECZ/miSeeT/LFI7XHjx+Xc8+9KJtsslnGjx+XSy+9MC+99EKmTPk8nTp1ztZbb5dDDz0iVVVV6d9/p3z88UdJkqOP/ml22GHH/PrXv1ngOknyxBOP5brrrs7o0W+ldevW6dWrT4466udZdtllF2qvPXr0SPLFHeYzZsxIy5bVmTVrVq688tI89ND9mTLl86y88qo5+ODDs+mmmy/U/vv27ZMkOfbY43PttVelurpVrr/+1sydW5OLL/5jnnjiscycOSNrrrl2jjzy6Ky11jpJksmTP8vll1+cp59+KpMmTcySS3bI5pt/N0cddUxat26TJHn00X/lhhuuzZgx7yVJVlhhxRxwwCHZfPPvJvni0dy/+91vs9Za6+RPf/pLkmTOnDm55ZYbc999d2f8+HHp2LFTttpq2xxyyE9TXf1FAX/mmb/JP/7x9xx77Al5553RefjhB9KqVetsscX3M3DgsamqWrRVsXdEAwAAAAAAQBP0zDND8/OfH5nhw5/PCiusmK5du2Xo0CdzxBEH1xbTn376SX7xi59l5MhXsswyXbLkkh1y0knHZcqUz7/22qeddnL+9a+H07Fjx2ywQZ9MnTo1N910Xa666vIkXzyCe4klWiZJvvOd9bL66j2/9DpPPfVETjrpl3nttZHp2XOtLLlkh/zrXw/n2GOPzJw5c+q0z2KxmM8//zy33fbXJMlyyy2fJZfskCQ588zT8te/3pSqqqqst16vvPPO6PzqV8fmhReGlbT/Sy+9MCuuuHLWXHPttGrVOscff0zuu++etG+/ZNZZZ928/PJLOfron9aWyued94fcc8/gtGzZMn36bJQkueuuO/KHP/y/JMk777yd//mfEzN69JtZc821s9pqq2fUqJE5+eTj5nu39v915pm/yZVXXpJPPvkk6667fmbNmplbb70xxx571AI/t6uuujzPPvt0evRYMR9//FFuu+2veeih++v0s60Pd0QDAAAAAABAE3TJJeenpqYmhxzy0xxwwCFJknPP/X0GD749l112YS666IrcccffMm3a1HznO+vm4ov/lKqqqtx++6Ccf/7ZX3vtsWPHJEmOPfa4rLde77zzzugMG/Z8evZcM8kXj+B++ukn8/HHH+XQQ4/IBhv0+dLrXH/9NSkWizn00COy//4HZ86cOTn55OPTqlWr/Pvf47Pccst/5QznnntWzj33rPmOtW3bLr/61SlJkvffH5shQx5Kx46dctNNt6VVq1Z5+umnctxxR+fGG69Lr169F3r/Bx54WAYMOCBJ8vzzz+aVV0ZklVVWyzXX3JjKysoMHnxbzj33rAwadHOOO+6k2p/T/vsfnG233T4TJnyaIUMeyqqrrpok+eCD9zN37tysscaaOfXU32appZbOgw/en7lz56Rdu/ZfOsOoUSPz0EP3p2XLlvnzn29Ijx4r5LPPJuWAA/bOyy+/lIceuj877LBj7fouXbrk6qtvSIsWLXLccUfn6aefyquvvjzfmkXBHdEAAAAAAADQxEye/FneeeftJMmOO+5ae3ynnX6cJBkx4sUUi8W8++4Xa/r23aL2Uc3bbrv9N17/Jz8ZkCQZOPCn+eEPt86f/nRZWrZsmTXWWHOh5nzzzdeTJBtv/MVjuquqqnL22efnt7/93deW0Emy6qqrp0+fjWrn3njjzfLXv95ZW3q/8cYX1544cUK23fa76du3T4477ugkyauvvpwkC73/9dfvVfv9G2+MSpKMHv1mtthi4/Tt26e2GJ93/b322jcVFRU588zfZIcdtspZZ52RiopC7aO7e/feMGussWZGjnwlu+66Q37yk34ZMeKFdOu2fJZeepkvneHFF4cnSdZbr1d69FghSbLkkh2yxRbfT5K89NIL861fb71eadGiRZJk5ZW/KMBnzZr1lXssF3dEAwAAAAAAQBNTKNTtftS5c+cm+eLx1gtjwIADsummm+fJJx/NCy8Mz7Bhz+eJJx7LvffenSuvvHah5503R5LMnPnF+52/ya679suuu/bPyJGv5Oijf5pnnnkq1157dX7+8+OSpLZYbtu2bXr16v1/zi6kpqZmofffpk3b2u/nXb9z56Wy1lprz7euQ4eOSZLttts+a6+9Th599J958cXheeWVl/Pss0/n9tsH5frr/5pWrVrlyiuvzdChT+SZZ57Oyy+/lLvuuiODB9+e4447Mbvu2n+BGSoqvv53WygU5vt3dXWrBWZe2N93KdwRDSRJKioKqaqq+Mavysov/rNRWfnNa6uqKlJRUfiGZAAAAAAAoNzatWuX7t17JEn+/vfBtcfvuefOJF/cJVsoFLLSSqskSZ588rHadwv/4x/3fO21J06ckPPO+0P+/Ocr8pOf7JsLLrgst956R5Iv7gSePHlykv8UojU1NV95rVVXXT1J8tRTj9euPfzwg7L99t/P888/W6e9rrXWOrXl82233ZoHH/zi/ccrr/zF3orFYk444df5/e/Pyx577J1u3ZbLD36wQyoqKhZ6/5WVlbXfzzt3iSVa5rTTzszvf39efvCDH6Z79xWy1VbbZNasWbnoovNywQXnZJttfpCzz74ggwf/I23atMmHH36QMWPezdChT+R3v/tt3n57dI477sRcd90tOeywo5IkTz/91FfuN/nizud576L+7LNJefTRfyX54nf73/5vMf1tcUc0kIqKQjp1qk6hUPf/JLRv3+qbFyUpFudkwoQZqalZ9P+fNQAAAAAA0Nz88Y9/SOvWbVIoJPNucu3RY4Wcfvrvc/jhR+XUU0/M1VdfkSeffDyzZs3K6NFvprq6Okcc8cUjqnfddbf87W+35OWXR2TfffdIx44d8uabb3xtZocOHTNy5Ct5/fXXstdeu2XllVfJe++9myTp2XOttG/fvnbdRx/9O+eff3Y23bRvBg78+QLXGjDgwJx44i9y3XV/zvDhz2XKlCl55523s/zy3fOd76xb55/DjjvumqeffiqPPPLPnH/+2endu0+WX757ttxyqzzyyD8zYMAeWXnlVTNy5CuZMWNGunbtVvL+5+nTZ6P07LlWRo0amb333i3dui2XV14Zkblz52bdddfLEksskfHjx2fo0Cdz0EH7pGfPtTJ+/LhMnTo1yyzTJSussGLmzp2bf/3r4cyePTtPPPFY2rZtmxEjXkySbLjhJl+au84666Zv3+/liScey8EHD8haa62T0aPfzKRJE/Od76yXbbb5QZ1/bouSIhpIRUXhf0vofZK8VsYrr5lC4aZUVBQU0QAAAAAANArLLrtso8r78MMPvvKzLbfcOn/84yW54YZr89prI5Mkm2yyWQ4//KisttoaSZIuXZbNeeddnAsvPDfvvPN2WrZsmd///twce+zA2vcK/1+FQiHnnXdxrrrqsgwd+mSGDXsuHTt2yo477pJDDz2idt1BBx2aCy44N+PGjcvkyZ996bX69v1ezjzznFx33Z8zatRradOmbb7//W1yxBE/q9Pjuf/bCSf8Oq+++ko+/vijnHvuWfn978/NySf/JksttUweeWRIXn75pSy7bNfsvvtP0q/f7iXv/79/Duecc0Euu+yiDB36REaOfDUrrrhy9tvvoPTtu0WS5LTTzsif//ynPPLIkAwf/nzatWuX739/mxx++FFp2bI6a665ds477+Jcd92f88Ybr2fOnNlZbrnls+uu/Wtn/DJnnPGH3Hzz9bn//nszYsQL6dChY/baa98cfPDhtY/fXtwKxW/jAeDNzNy5NZkwYeriHqPZqaqqSMeObTJx4tTMmfPVj3iQ+9XXSjZI8sI3LV8IvZIML+uM3+bPuSn8buU2rNzmtFe5/qbkNs7c5rRXuf6m5DbO3Oa0V7n+puQ2ztzmtNfmltuc9irX31RTz509e1Y+/XRcOnfumhYtlphvfUVFIR06tJrv0cvflrlz52bSpOn1uqmrqqqipJ/v8OHP5+WXX0rnzktl++1/lKqqqrzzztsZMGCPdOmybG6//e+LJLe+ypVb3/03RV/3v5Mk6dSpTe2rXL9Ow6jD4WtUVBTq9J7h/353cV3V1BTdqQsAAAAAAKSmpphJk6bXqZP4JpWVFZk7t+4l6eLsKwqFQq666vIkye23/zWdOi2VkSNfSZJ873vfXywzfZua+/4XJUU0DdqifHdx4v3FAAAAAADAf5SzEF4cdwmXolev3jnxxFPyt7/9Ne+9917efnt0OndeKj/84U457LAjF/d4i1xz3/+ipIimQVt07y5OvL8YAAAAAAAg2XHHXbPjjrsu7jEWm+a+/0VFEU0j8VrK++5iAAAAAAAAYFGp+8t0AQAAAAAAAKAOFNEAAAAAAAAAlJUiGgAAAAAAAICyUkQDAAAAAAAAUFaKaAAAAAAAAADKqmpxDwAAAAAAAAANQUVFIRUVhXpfp7Jy4e4FrakppqamWO9caEgU0QAAAAAAADR7FRWFdOzYOhUV3/4DhWtqajJx4rSFKqP7998p48ePy4ABB+bww4+qPT58+PM5+uifZv31N8gll/ypTte677578rvf/TZrrbVO/vSnvyzs+HU2cOBhefHF4fMda9GiRZZaapn86Ec7Zf/9D06hUP//RwAaBkU0AAAAAAAAzd4Xd0NX5LXXXsu0adO+tdzWrVtnzTXXTEVFoaS7om+55YZst90OWW21VUueoUuXZfPd726R7t1XKPkaC2PVVVdP165dUywWM23atLz88ku5+uorMnfu3Bx88OHfygwseopoAAAAAAAA+F/Tpk3LlClTFvcYdTZnzpycd95ZueKKq0u+Ru/eG6Z37w3LONXX23XXftl11/61/77rrjtyzjm/y7/+9bAiugn59p8tAAAAAAAAAJRFRUVFXnxxeP7+97u/cs3bb7+VX/ziZ9lhh63y/e9vmt133yXXXntV7ef33XdP+vbtk8MOOyBJsvfeu6Vv3z4ZMuSh2jVjxrybvn375Ac/2CLTp09Pktx9953Zffdds+WWm2TPPXfNLbfcWNIeZs2alSTp1m252mMfffTvnHLKCdlxx22z5Zab5Mc//mEuvPC8zJ49OxMmfJrNN98offv2ybhxH9aec+ONf0nfvn1y0knH1V734ovPz847/yBbbbVZDjlkvwwd+uR8uZdcckH6998pW221WXbe+Qc57bST88knn5S0D+aniAYAAAAAAIBGapdddkuSXHLJBZk8+bMFPp81a1Z+8Yuf5dlnh2bZZZfNuuv2yieffJQ///nKPPHEo196zZ12+nGS5IEH7q099o9/fPH9tttun1atWmXw4Nty9tln5tNPP80GG/TJjBnTc+mlF+Qvf/nmO7MHD74jJ530y5x44i9yxBEH5cILz02XLsvmyCOPqV1z0knH5ZFH/pl27dplgw02zJQpn+dvf7slgwffnk6dOmezzTZPkgwZ8mDtOY888s8kyQ477JgkOfPM0/LXv96UqqqqrLder7zzzuj86lfH5oUXhiVJrrnmT7n11htTU1OT3r03THV1dYYMeTAnn3zcN+6Bb+bR3AAAAAAAANBI7bnn3hkx4sWMHv1mLrvsomy33Q7zfT5jxowceOChmT59Wvbaa98kyR//+Ifcccff8u6776Rv3y0WuOYPf7hjrrrqsjzzzNBMnDghSy7ZIQ88cF+S/5TU119/bZLk0kuvzGqr9czkyZ+lX78f5dZbb8w+++yfFi1afOXMb731Rt566435jlVUVGT8+HFZccWVMmvWrPTrt3s++ujf2X//g1NRUZGbb74hl112Yd57753/nWOXPP74oxky5MHsu+8BGTfuw4waNTJLLrlkNtusb95/f2yGDHkoHTt2yk033ZZWrVrl6aefynHHHZ0bb7wuvXr1ztix7yVJdtmlX/baa9/MnTsngwffnh49VsjcuXNTWVlZyq+E/6WIBgAAAAAAgEaqsrIyxx9/Uo444uDce+/d6dq123yft2/fPt///jYZMuTB/OY3v86oUa/l/ffHJPnPI7H/ryWX7JDvfe/7efjhB/LQQ/dnpZVWyUcf/Turr75G1lijZyZOnJiPPvp3kuTAA/dd4Px3330nq622+lfOfNxxJ2bXXfunWCxm6tSpufPO23LllZfk178+PoMG3ZXOnZfK1ltvl3/+86GcddYZef311/L226Pnm3mzzfqmU6fOefPNNzJmzHu1d3dvu+32qaqqyhtvvJ4kmThxQrbd9rvz5b/66stJkt122zNDhz6Vq666PNddd03WXHOtbLjhxllrrXWU0GWgiAYAAAAAAIBGbJ111s2uu/bLnXfenuuvv2a+z/797/EZOPCwfPrpp+nff49su+32efbZobn99kEpFotfec1ddumXhx9+IEOGPJQVV3wrSbLzzl/cDV1V9Z+KcfPN+6aiYv7StqKibm8HLhQKadu2bfbdd//cdNNfMmXKlIwY8WI23njTDBx4WN56683svPOPc+CBh2bs2DG58spLa2euqqrK9tv/MDfffEOGDHkwTz31eJJk++13nG/Gtm3bplev3v83OTU1Ndlggz4ZNGhwHn30nxk+/Pm88sqIvPTSCxk06JZcf/2tWWqppeu0D76cIhoAAAAAAAAauSOPPDqPPvpIJkz4dL7j//znwxk37sP07r1hjjzymBSLxdx2263feL1evXqnR48VMnLkK3nvvXdSXV2dbbfdPknSrl27LL30Mvn444/Sv/+e2XDDTTNx4oT8+c9XZsUVV8oKK6y4ULP/+9//zowZM5Ik7dsvmWeffTpvvPF6lltu+fzylyemUCjkrLPOWOC8H/1ol9x88w2566478sknH2ellVZOz55rJklWXnmVJEmxWMwJJ/w6HTt2ygsvDMsTTzya73xnvVRUVOSqqy7PW2+9kQMPPDS77bZnisViBgzYI++++05effWVbLHF9xdqH8xPEQ0AAAAAAACNXLt27TJw4LE5/fRT5jverdtySZJhw57LEUccnEmTJmbs2C8ezT19+vSvvebOO/84l1xyQaZMmZIf/nCntGnTtvazfffdP+eff05OOOEXWXfd9fPOO29nwoRPs8UW30///nt97XUHD74jzzwzNEkyc+bMjBz5aubMmZMVVlgx663XK2+//cUd2B988H4OPnhAisWavPnmG/8787Ta66ywwopZZ51188orI5IkO+ywY+1nyy/fPVtuuVUeeeSfGTBgj6y88qoZOfKVzJgxo/bx5TNmTM+TTz6e4cOH5TvfWS+TJk3Mu+++k7Zt22attdb+2j3wzep2XzwAAAAAAAA0A61bt07btm2/ta/WrVuXbfbttts+ffpsNN+xLbb4fvbf/+B07tw5b731Rtq2bZfDDjsySfLSS8O/9no77LBjllhiiSTJTjvtOt9nu+22Z37+8+PSrdtyGTHixRQKhfTvv1f+538WvHP5/3rrrTfy+OOP5vHHH82wYc8lSb773S1z3nkXp6qqKquv3jO/+MWv0qXLsnnvvXdSU1OTo4/+RQqFQl5+eUTmzp1be60f/nCnJF+8K3u77XaYL+fkk3+T/v33SlVVi7z88ktZeull8otf/Kq2KD/yyGNy+OEDs8wyy+Sll4bno4/+nU022SwXXHB5ll56mW/cB1/PHdEAAAAAAAA0ezU1xdTU1GTNNddcDNk1qan56vc1f5nbbrvnS49fcMFlCxw79NAjcuihR8x3bL/9Dqr9/oc/3Km20P1vSy7ZIf/851NfOUP//ntlr732zpw5NXWa+ZJL/lSndUnSr9/u6ddv9/mO7bHH3guse+utL+6U7t17owXe6dy6dev8/OfH5ec/P+5LMyorKzNgwAEZMOCAOs9F3SmiAQAAAAAAaPZqaoqZOHFaKioK9b5WZWVF5s6tWzk7L3thi+jm7qqrrsjLL7+c5557Okmy++5f/zhwvn2KaAAAAAAAAEh5C+G63iVMaT7//PO8+OKwLLNMl+y55z7ZdNPNF/dI/B+KaAAAAAAAAKBR+cUvjs/RR/9ycY/B16hY3AMAAAAAAAAA0LQoogEAAAAAAAAoK0U0AAAAAAAAzUx53gMNTVGxWJ7/fSiiAQAAAAAAaBYqKyuTFDJz5ozFPQo0WLNmzUySVFZW1es69TsbAAAAAAAAGomKisq0atUmU6ZMypw5s1Nd3ToVFZUpFAplzampKWTu3G/3ruvFkdkcc5uyYrGYWbNmZsqUiWnVqm0qKup3T7MiGgAAAAAAgGajfftOadGiZaZMmZQZM6YukoyKiorU1NQskms3pMzmmNsctGrVNu3bd6r3dRTRAAAAAAAANBuFQiGtW7dNq1ZtUlNTk5qauWW9fmVlIUsu2TqffTbtW7tjd3FkNsfc5qCysqred0LPo4gGAAAAAACg2SkUCqmsrPzf90aXT1VVRaqrqzN9+tzMmfPt3LG7ODKbYy4Lpzx1NgAAAAAAAAD8L0U0AAAAAAAAAGWliAYAAAAAAACgrBTRAAAAAAAAAJSVIhoAAAAAAACAslJEAwAAAAAAAFBWimgAAAAAAAAAykoRDQAAAAAAAEBZKaIBAAAAAAAAKCtFNAAAAAAAAABlpYgGAAAAAAAAoKwU0QAAAAAAAACUlSIaAAAAAAAAgLJSRAMAAAAAAABQVopoAAAAAAAAAMpKEQ0AAAAAAABAWVUt7gEWxuzZs3PeeeflrrvuytSpU9O7d++ceuqpWXnllb90/ZQpU3LmmWfm4Ycfzpw5c9K3b9+ceuqpWWaZZZIka6yxxldmDRkyJMsvv/wi2QcAAAAAAABAU9aoiugLLrgg1157bTp27JiVVlopTz31VA455JDce++9adWq1QLrTznllPzjH/9I165d07Jlyzz44IMZP358Bg0alEKhkK233nq+9R999FFefvnlLLvssunYseO3tS0AAAAAAACAJqXRFNEzZ87MLbfckkKhkEGDBqVHjx7ZZ5998vzzz+ehhx7KzjvvPN/68ePH5/7770/r1q1zzz33pLq6Ottvv31GjBiR4cOHp3fv3rnssstq1xeLxey3336pqKjIhRdemDZt2nzbWwQAAAAAAABoEhrNO6Jff/31TJ06NV27dk2PHj2SJJtuummSZPjw4QusHz58eIrFYtZee+20a9cuLVq0yEYbbfSV62+77bY8++yz6d+/f9Zff/1FtxEAAAAAAACAJq7R3BH94YcfJsl8j8ye9/348eMXWD9u3Lg6r587d24uv/zyVFVV5aijjirLvFVVjabjb9AqKxf9z7G+GfPO/zZmXVS5i3r2cs74bf6cm8LvVm7Dym1Oe5XbdDPlNu3c5rRXuU03U27Tzm1Oe5XbdDPlNu3c5rTX5pbbnPYqt+lmym3auc1pr4szl4XTaIroGTNmJEmqqv4zcosWLeb7rNT1Dz74YD744IPsuOOOWXbZZes9a0VFIR07erR3Y9G+/YLvF1+c12ksuQujnDMujv02t9+t3KaZKbdp5zanvcptuplym3Zuc9qr3KabKbdp5zanvcptuplym26m3Kad25z2KrfpZjbHXOqmbEX0vHcvjxs3LlOmTMmZZ56ZJHnggQey7rrrpmvXrvW6fsuWLZMkc+bMqT02e/bsJEl1dfVXrp87d+4C61u1mv+P8s4770yS/OhHP6rXjPPU1BQzefK0slyruausrFjk/xGZPHl65s6tKfn8eTPW9zqLM3dR/5zLOeO3+XNuCr9buQ0rtzntVa6/KbmNM7c57VWuvym5jTO3Oe1Vrr8puY0ztznttbnlNqe9yvU3Jbdx5janvS7OXL7Qvn2rOt2NXu8i+oUXXshvf/vbvP766/Mdn1dEn3/++fnggw9yyCGH5Oijj06hUCgpp0uXLkmSzz77rPbYxIkTk+RLS+556ydNmrTA+v++63nWrFl57rnn0rJly2y22WYlzfZl5szxR99YzJ1bU5bfV7mu01hyF0Y5Z1wc+21uv1u5TTNTbtPObU57ldt0M+U27dzmtFe5TTdTbtPObU57ldt0M+U23Uy5TTu3Oe1VbtPNbI651E29Hpz+4IMPZsCAAXn99ddTLBZTUVGRYrE435oPP/wws2fPzhVXXJHTTjut5Kw111wz1dXV+eCDDzJ27NgkydNPP50k6d279wLr119//STJq6++milTpmTOnDl5/vnnF1g/YsSITJs2LauvvvqX3lkNAAAAAAAAwMIpuYgeP358TjjhhMyZMyfrrrturr322jz++OMLrPvLX/6S9ddfP8ViMX/7298ydOjQkvJatWqVPffcM8ViMXvuuWd+/OMf57nnnsvyyy+fbbfdNkOHDs2RRx6Zc845J0nSvXv3bLPNNpkyZUp23nnn7LTTThkzZkx69epVW1Inyfvvv58kWW211UqaCwAAAAAAAID5lVxEX3PNNZkxY0bWXXfd3HDDDdl0002/9I7iDTbYINddd11t+XvrrbeWPOwJJ5yQQw45JEny1ltvZbPNNsvVV1+dli1bZty4cRkyZEiee+652vVnn3129thjj3z++ecZN25ctttuu1xyySXzPR78008/TZJ06tSp5LkAAAAAAAAA+I+S3xH9+OOPp1AoZODAgVliiSW+dm3Lli0zcODAHHLIIXnxxRdLjUxVVVWOP/74HH/88Qt81q9fv/Tr12++Y23atMkZZ5yRM8444yuvefDBB+fggw8ueSYAAAAAAAAA5lfyHdHjxo1Lkqyzzjp1Wr/WWmslSSZMmFBqJAAAAAAAAACNQMlFdGVlZZJkzpw5dVo/ffr0JPnSx3cDAAAAAAAA0HSUXER37949SfLss8/Waf0jjzwy33kAAAAAAAAANE0lF9FbbrllisViLrzwwkyePPlr144ZMyYXX3xxCoVCvve975UaCQAAAAAAAEAjUHIRfcABB2TJJZfM+++/n9122y2DBw/OO++8U/v57Nmz88477+Tqq6/O7rvvnkmTJqV169bZb7/9yjI4AAAAAAAAAA1TVakndujQIRdeeGF++tOfZuzYsTnppJOSJIVCIUmy7rrr1q4tFoupqqrKueeem06dOtVzZAAAAAAAAAAaspLviE6STTbZJIMGDUqfPn1SLBa/8qtnz5654YYb8v3vf79ccwMAAAAAAADQQJV8R/Q8q6++em688caMHj06zzzzTMaOHZspU6akuro63bp1S+/evee7OxoAAAAAAACApq3eRfQ8q6yySlZZZZX5js2cOTNVVWWLAAAAAAAAAKARqNejuZNk9OjROfnkk/OHP/xhgc/+/ve/p0+fPvnVr36VsWPH1jcKAAAAAAAAgEagXkX0vffemx//+Me5884788ILLyzw+ZgxYzJ9+vTcfffd2WWXXTJ06ND6xAEAAAAAAADQCJRcRI8ePTonnnhiZs2albZt22aDDTZYYM3222+fgw8+OO3bt8+0adNyzDHH5N///ne9BgYAAAAAAACgYSu5iP7zn/+c2bNnZ4UVVshdd92VE044YYE1a665Zo4//vjcfffdWWGFFfL555/nmmuuqdfAAAAAAAAAADRsJRfRzzzzTAqFQk444YR069bta9d26dIlv/jFL1IsFvPII4+UGgkAAAAAAABAI1ByEf3RRx8lSXr16lWn9euvv36SZNy4caVGAgAAAAAAANAIlFxEt2vXLkkyderUOq0vFotJkiWWWKLUSAAAAAAAAAAagZKL6BVWWCFJ8vDDD9dp/ZAhQ+Y7DwAAAAAAAICmqeQi+kc/+lGKxWIuueSSvPTSS1+7dtSoUbnoootSKBSy7bbblhoJAAAAAAAAQCNQVeqJP/7xj3Pddddl7Nix2WeffbLTTjtliy22yIorrpjq6urMmDEjY8aMyeOPP5677rors2bNSpcuXTJgwIByzg8AAAAAAABAA1NyEd2mTZtccsklOfjgg/PJJ59k8ODBGTx48JeuLRaL6dy5c6688sq0adOm1EgAAAAAAAAAGoGSH82dJGussUb+8Y9/ZN99903nzp1TLBYX+GrVqlX22muv3HXXXenZs2e55gYAAAAAAACggSr5juh52rVrl1NOOSWnnHJKXn/99fz73//OZ599llatWqVr167p2bNnKisryzErAAAAAAAAAI1AvYvo/7bGGmtkjTXWKOclAQAAAAAAAGhk6vVobgAAAAAAAAD4v+p9R/TYsWMzZMiQvP/++5k+fXpqamq+dn2hUMjvfve7+sYCAAAAAAAA0EDVq4i+/PLLc+mll2bu3LkLdZ4iGgAAAAAAAKDpKrmIfvzxx3PhhRf+50JVVWnXrl2WWGKJsgwGAAAAAAAAQONUchF90003JUk6duyY3//+99l8883TokWLsg0GAAAAAAAAQONUchH90ksvpVAo5Ne//nW23HLLMo4EAAAAAAAAQGNWUeqJU6dOTZJsuummZRsGAAAAAAAAgMav5CJ62WWXTZLMmjWrbMMAAAAAAAAA0PiVXER/73vfS5L861//KtswAAAAAAAAADR+JRfRhx9+eNq3b58LL7wwo0aNKudMAAAAAAAAADRiVaWeOGPGjJx22mn59a9/nf79+6dv375Zb7310rFjx1RVff1l+/fvX2osAAAAAAAAAA1cyUX0dtttV/t9sVjMo48+mkcfffQbzysUCopoAAAAAAAAgCas5CK6WCx+7b8BAAAAAAAAaJ5KLqKHDBlSzjkAAAAAAAAAaCJKLqKXW265cs4BAAAAAAAAQBNRsbgHAAAAAAAAAKBpKWsRXSwWU1NTM9/XnDlzMn369Hz66acZNmxYzjrrrHJGAgAAAAAAANDAlPxo7iQZP358Lrjggjz++OOZOHFiisVinc478cQT6xMLAAAAAAAAQANWchE9efLk7L333hk3blydC+gkadu2bamRAAAAAAAAADQCJRfRN910Uz788MMkyVprrZUNN9ww77//foYMGZINN9wwvXv3zsSJE/PMM8/k3XffTaFQyEEHHZRjjjmmbMMDAAAAAAAA0PCUXEQ/8sgjKRQK2WKLLXL55ZenUCjkjTfeyJAhQ1JZWZmf//znSb54b/TFF1+cyy67LH/7299ywAEHZOmlly7X/AAAAAAAAAA0MBWlnvjuu+8mSQ4++OAUCoUkyWqrrZZWrVrlxRdfTE1NTZKkUCjk6KOPzpZbbpnPP/88N998c/2nBgAAAAAAAKDBKrmInjp1apJkxRVXrD1WKBSyyiqrZObMmXn77bfnW7/vvvumWCzmscceKzUSAAAAAAAAgEag5CK6TZs2Sb549PZ/W2GFFZIkb7311nzHV1999STJ2LFjS40EAAAAAAAAoBEouYju2rVrkv88onueHj16pFgs5o033pjv+LzCetq0aaVGAgAAAAAAANAIlFxE9+nTJ8ViMX/6058ye/bs2uOrrrpqkuSRRx6Zb/2zzz6b5D93UgMAAAAAAADQNJVcRO+1114pFAp58skn069fv9x///1Jku9+97tp3bp1Xnvttfy///f/Mnr06DzwwAM566yzUigUstZaa5VteAAAAAAAAAAanpKL6FVXXTVHHXVUisVi3nrrrTz66KNJkvbt22fPPfdMsVjMTTfdlB133DE///nP8+mnnyZJfvKTn5RncgAAAAAAAAAapJKL6CQZOHBgLrjggqyzzjrp3r177fFjjz022267bYrFYu1XoVDIoYcemu22267eQwMAAAAAAADQcFXV9wLbb799tt9++xSLxdpjSyyxRC6++OK8+OKLeeGFF1JRUZHNN9+89v3RAAAAAAAAADRd9S6i5ykUCgscW3/99bP++uvX/vvDDz/MuHHj0rt373LFAgAAAAAAANDAlFxE9+zZMxUVFRk2bFhatWr1jesnTJiQrbbaKssss0wee+yxUmMBAAAAAAAAaODq9Y7o/34c9zeZOHFikmTSpEn1iQQAAAAAAACggfvGO6Jramry+9//PlOmTPnSz0877bRUVlZ+7TVmz56dYcOGJUmWWmqpEsYEAAAAAAAAoLH4xiK6oqIiK620Uk4//fQF3gNdLBZzzz331Clo3t3Tu+22WwljAgAAAAAAANBY1Okd0T/5yU/ywgsvZPz48bXHnnvuuRQKhWywwQapqPjqJ3wXCoVUVVWlQ4cO2XjjjbPHHnvUf2oAAAAAAAAAGqw6FdGFQiHnnHPOfMd69uyZJLn66qvTqlWr8k8GAAAAAAAAQKNUpyL6y/Tt2zdLL710qqpKvgQAAAAAAAAATdBXP1P7G0ydOjUvvfRSnn766XLOAwAAAAAAAEAjV/LtzKNHj87nn3+eJZdcspzzAAAAAAAAANDIlXxH9OzZs5Mkyy+/fNmGAQAAAAAAAKDxK7mI7tOnT5Lk4YcfLtswAAAAAAAAADR+JRfRv/3tb9OtW7ecccYZufjii/P666+nWCyWczYAAAAAAAAAGqGS3xF9wQUXZJVVVskHH3yQyy67LJdddlkqKyvTrl27tGzZ8ivPKxQK+de//lVqLAAAAAAAAAANXMlF9N13351CoZAktXdCz5kzJxMnTvza8+adAwAAAAAAAEDTVHIRveuuuyqVAQAAAAAAAFhAyUX0WWedVc45AAAAAAAAAGgiKhb3AAAAAAAAAAA0LSXfEf1/jRw5Ms8++2zGjRuXadOmpVWrVunWrVs22GCDrLvuuuWKAQAAAAAAAKCBq3cRPWrUqJx22mkZMWLEV65ZffXV84c//CE9e/asbxwAAAAAAAAADVy9Hs09dOjQ7LXXXhkxYkSKxWKKxWJatWqVzp07p7q6uvbY66+/nj322CNPP/10ueYGAAAAAAAAoIEq+Y7oSZMm5ec//3lmzJiR9u3b58gjj8wOO+yQLl261K758MMPc//99+fKK6/MZ599luOOOy5///vf06FDh3LMDgAAAAAAAEADVPId0dddd10+++yzdO7cObfddlsOOOCA+UroJOnWrVsOOuig3HbbbVlqqaXy6aef5vbbb6/30AAAAAAAAAA0XCUX0Y8++mgKhUKOOeaY9OjR42vXdu/ePUcffXSKxWIeeOCBUiMBAAAAAAAAaARKLqLHjBmTJPne975Xp/VbbLHFfOcBAAAAAAAA0DSVXETPnj07SdKyZcs6rW/RokWSZMaMGaVGAgAAAAAAANAIlFxEz3sf9IgRI+q0/uWXX06SLLPMMqVGAgAAAAAAANAIlFxEb7TRRikWi7nooosya9asr107c+bMXHjhhSkUCtloo41KjQQAAAAAAACgESi5iB4wYEAqKioycuTIHHjggXnjjTe+dN2oUaNywAEHZOTIkSkUChkwYEDJwwIAAAAAAADQ8FWVeuIaa6yRI488MpdcckmGDx+eXXbZJT169MjKK6+c1q1bZ9q0aXn77bczZsyY2nOOOuqorLHGGmUZHAAAAAAAAICGqeQiOkkGDhyYNm3a5KKLLsr06dPz3nvvzVc8F4vFJEnLli1z7LHH5oADDqjXsAAAAAAAAAA0fPUqopPkwAMPzM4775x77rknzz33XMaNG5epU6emdevW6datW/r06ZNddtklnTp1Kse8AAAAAAAAADRw9S6ik6Rz58454IAD3PEMAAAAAAAAQCrKfcGpU6fm3//+d2bNmlXuSwMAAAAAAADQCJTljugHH3wwf//73/PUU09l6tSptcc7d+6c733ve+nXr1/69OlTjigAAAAAAAAAGrh6FdETJkzI0UcfnWHDhiVJisXifJ9/8sknufPOO3PnnXdml112yemnn54llliiPpEAAAAAAAAANHAlF9EzZ87MIYccktdeey3FYjHLL798ttxyy6ywwgqprq7OtGnT8s477+TRRx/NuHHjctddd2XmzJk5//zzyzk/AAAAAAAAAA1MyUX0bbfdlpEjR6aioiInnHBCDjjggBQKhQXW1dTU5IorrshFF12U+++/PzvttFO22mqreg0NAAAAAAAAQMNVUeqJd955ZwqFQg488MAceOCBX1pCJ0lFRUWOPPLI7LPPPikWi7n55ptLHhYAAAAAAACAhq/kInrMmDFJkj333LNO6/fZZ58kyahRo0qNBAAAAAAAAKARKLmInqdt27Z1WtepU6ckybRp0+obCQAAAAAAAEADVnIRvc466yRJHnvssTqtf+mll5Ika621VqmRAAAAAAAAADQCJRfRhx9+eAqFQs4+++y8/fbbX7v2888/zznnnJNCoZCDDjqo1EgAAAAAAAAAGoGSi+iNN944p59+eiZPnpz+/fvnsssuy7vvvjvfmgkTJmTw4MHp169fRo8enZ122imrrbZaxo4d+6VfAAAAAAAAADR+VaWe2Ldv3yRJRUVFpk2blosvvjgXX3xxWrRokbZt22bmzJkLvA/6nnvuyT333POl1ysUChk5cmSp4wAAAAAAAADQQJRcRH/yySfz/btYLCZJZs2alQkTJtRvKgAAAAAAAAAarZKL6N///vflnAMAAAAAAACAJqLkIvrHP/5xOecAAAAAAAAAoImoWNwDAAAAAAAAANC0KKIBAAAAAAAAKKuSH82dJOPHj88VV1yRp556Kv/+978za9asbzynUChk5MiR9YkFAAAAAAAAoAEruYgeO3Zs9txzz0ycODHFYrGcMwEAAAAAAADQiJVcRF944YWZMGFCKioqsv3222f99ddP27ZtU1Gx6J72PXv27Jx33nm56667MnXq1PTu3TunnnpqVl555S9dP2XKlJx55pl5+OGHM2fOnPTt2zennnpqlllmmdo1Y8aMyR/+8IcMHTo0SyyxRLbddtuceOKJadOmzSLbBwAAAAAAAEBTVnIR/fTTT6dQKGTgwIE58sgjyznTV7rgggty7bXXpmPHjllppZXy1FNP5ZBDDsm9996bVq1aLbD+lFNOyT/+8Y907do1LVu2zIMPPpjx48dn0KBBKRQK+fTTT/OTn/wkn3zySdZee+1MnDgxgwYNyuzZs3PWWWd9K3sCAAAAAAAAaGpKvn158uTJSZLddtutbMN8nZkzZ+aWW25JoVDIoEGDctddd6VPnz754IMP8tBDDy2wfvz48bn//vvTunXr3HPPPfn73/+e5ZdfPiNGjMjw4cOTJNdee20++eSTbLfddrnjjjvyt7/9Le3atcuoUaMyZ86cb2VfAAAAAAAAAE1NyUX0sssumyQpFAplG+brvP7665k6dWq6du2aHj16JEk23XTTJKktlv/b8OHDUywWs/baa6ddu3Zp0aJFNtpoo/nWP/HEE0mS7bbbLkmy1FJL5fnnn8/gwYNTVVXyzeIAAAAAAAAAzVrJbevWW2+dv/zlL3nkkUeyxx57lHOmL/Xhhx8mSTp27Fh7bN7348ePX2D9uHHjvnH9mDFjkiSjRo3K+eefn6lTp2bbbbfNSSedVO93RFdVLbp3ZTcnlZWL/udY34x5538bsy6q3EU9ezln/DZ/zk3hdyu3YeU2p73KbbqZcpt2bnPaq9ymmym3aec2p73KbbqZcpt2bnPaa3PLbU57ldt0M+U27dzmtNfFmcvCKbmIPuKII3L//ffn3HPPzWqrrZZevXqVc64FzJgxI0nmu1O5RYsW8322sOunT5+eJLn66qvTq1evjBs3Ln/7298yZcqUXHDBBSXPWlFRSMeO9Suy+fa0b7/g+8UX53UaS+7CKOeMi2O/ze13K7dpZspt2rnNaa9ym26m3Kad25z2KrfpZspt2rnNaa9ym26m3KabKbdp5zanvcptupnNMZe6KbmIbt++fa6//vocfPDB2XvvvdOrV6+stdZaadu27Tc+rvuYY45Z6LyWLVsmyXzvbp49e3aSpLq6+ivXz507d4H1rVq1qj1v2rRp2XPPPXP66adn8uTJ2XrrrfOPf/wjp5xySpZaaqmFnjNJamqKmTx5WknnMr/KyopF/h+RyZOnZ+7cmpLPnzdjfa+zOHMX9c+5nDN+mz/npvC7lduwcpvTXuX6m5LbOHOb017l+puS2zhzm9Ne5fqbkts4c5vTXptbbnPaq1x/U3IbZ25z2uvizOUL7du3qtPd6PV6EfJf//rX2kdmv/DCC3nhhRfqdF4pRXSXLl2SJJ999lntsYkTJyZJunbt+pXrJ02atMD6ee+37tatW95666307NkzyRfl+korrZSXXnop48aNK7mITpI5c/zRNxZz59aU5fdVrus0ltyFUc4ZF8d+m9vvVm7TzJTbtHOb017lNt1MuU07tzntVW7TzZTbtHOb017lNt1MuU03U27Tzm1Oe5XbdDObYy51U/KD0wcNGpSrr746c+fOTbFYXKivUqy55pqprq7OBx98kLFjxyZJnn766SRJ7969F1i//vrrJ0leffXVTJkyJXPmzMnzzz8/3/pNNtlkvuvMmDGj9to9evQoaU4AAAAAAACA5q7kO6JvvfXWJF/cXfyrX/0qffr0SefOnb/xsdylatWqVfbcc89cd9112XPPPdOlS5eMHDkyyy+/fLbddtsMHTo0N9xwQ1ZaaaUcf/zx6d69e7bZZps8/PDD2XnnndOyZcuMGTMmvXr1qi2pDzzwwAwePDgPPPBA+vXrlylTpmTChAnZfffds+SSSy6SfQAAAAAAAAA0dSXfEf3uu++mUCjkzDPPzPbbb5+lllpqkZXQ85xwwgk55JBDkiRvvfVWNttss1x99dVp2bJlxo0blyFDhuS5556rXX/22Wdnjz32yOeff55x48Zlu+22yyWXXFI75/LLL58bbrghG220Ud56663MmTMnhx12WE499dRFug8AAAAAAACApqzkO6JbtGiR6dOn175f+dtQVVWV448/Pscff/wCn/Xr1y/9+vWb71ibNm1yxhln5IwzzvjKa6611lq54YYbyj4rAAAAAAAAQHNV8h3R8wrod999t1yzAAAAAAAAANAElFxEDxgwIMViMRdddFHmzp1bzpkAAAAAAAAAaMRKLqK32Wab7L///nn66afzk5/8JPfdd1/ef//9TJ06NTU1NV/7BQAAAAAAAEDTVfI7ovfbb78kScuWLfPyyy/nl7/8ZZ3OKxQKGTlyZKmxAAAAAAAAADRwJRfRzz77bDnnAAAAAAAAAKCJKLmIHjhwYDnnAAAAAAAAAKCJUEQDAAAAAAAAUFYVi3sAAAAAAAAAAJoWRTQAAAAAAAAAZVWnR3N/+OGHZQ3t1q1bWa8HAAAAAAAAQMNRpyJ6q622SqFQKEtgoVDIyJEjy3ItAAAAAAAAABqeOhXRSVIsFhflHAAAAAAAAAA0EXUqogcOHLio5wAAAAAAAACgiVBEAwAAAAAAAFBWFYt7AAAAAAAAAACaFkU0AAAAAAAAAGWliAYAAAAAAACgrBTRAAAAAAAAAJSVIhoAAAAAAACAslJEAwAAAAAAAFBWimgAAAAAAAAAykoRDQAAAAAAAEBZKaIBAAAAAAAAKCtFNAAAAAAAAABlVVWOi7z22msZNGhQhg0blvHjx2fq1Kl59dVXkyS/+tWvsuqqq2bAgAGprq4uRxwAAAAAAAAADVi9iug5c+bkzDPPzK233pokKRaLSZJCoVC7ZujQobn77rtzxx135Kqrrsryyy9fn0gAAAAAAAAAGrh6PZr75JNPzq233ppisZiuXbtm++23X2BN27ZtUywW88477+TQQw/NrFmz6hMJAAAAAAAAQANXchH92GOP5e67706hUMjJJ5+chx9+OL/73e8WWHfvvffmxBNPTKFQyLvvvptbbrmlXgMDAAAAAAAA0LCVXEQPGjQohUIh++yzT/bbb79UVHz5pQqFQg444IDsv//+KRaLuf/++0seFgAAAAAAAICGr+Qi+sUXX0yS9O/fv07r+/XrlyR56623So0EAAAAAAAAoBEouYj+7LPPkiRdu3at0/ouXbokSaZPn15qJAAAAAAAAACNQMlFdPv27ZMkH3/8cZ3Wv//++0mSDh06lBoJAAAAAAAAQCNQchG99tprJ0nuvvvuOq2/+eabkyRrrbVWqZEAAAAAAAAANAIlF9E777xzisVi/vznP+fhhx/+2rXXXHNNbr/99hQKhfzoRz8qNRIAAAAAAACARqCq1BN33HHHDBo0KM8++2x+9rOfZcMNN5zvbudBgwbl/fffzz//+c+MHj06SbLuuutm5513rv/UAAAAAAAAADRYJRfRSXLppZfmyCOPzHPPPVf7VSgUkiSnnXZakqRYLCb54pHcl112We3nAAAAAAAAADRN9Sqi27Vrl+uvvz533HFHbr311owcOTJz586db80qq6yS3XffPXvvvXeWWGKJeg0LAAAAAAAAQMNXchE9e/bstGjRIoVCIbvttlt22223TJ06NR988EGmTJmSVq1aZdlll03Hjh3LOS8AAAAAAAAADVzJRfRPf/rTFAqFHHXUUenVq1eSpE2bNll99dXLNhwAAAAAAAAAjU9FqSe++uqrefLJJzNr1qxyzgMAAAAAAABAI1dyET19+vQkyWqrrVa2YQAAAAAAAABo/Eouotdee+0kyXPPPVe2YQAAAAAAAABo/Eouok877bS0b98+p5xySu64445MmTKlnHMBAAAAAAAA0EhVlXri/fffn759++bee+/Nr3/965xyyinp1q1bOnTokJYtW37leYVCITfeeGOpsQAAAAAAAAA0cCUX0ZdffnkKhUKSpFgsplgs5v3338/777//tefNOwcAAAAAAACApqnkInrDDTcs5xwAAAAAAAAANBElF9E33HBDOecAAAAAAAAAoImoWNwDAAAAAAAAANC0KKIBAAAAAAAAKKuSH8194YUXlhx6zDHHlHwuAAAAAAAAAA1byUX05ZdfnkKhsFDnFIvFFAoFRTQAAAAAAABAE1ZyEZ18USzX1ZJLLpm11lqrPnEAAAAAAAAANAIlF9GjRo362s9nzpyZSZMmZfjw4bnyyivz+uuv53vf+14OPPDAUiMBAAAAAAAAaAQqFtWFW7ZsmS5dumSHHXbIX//616yxxho555xzMnz48EUVCQAAAAAAAEADsMiK6P/WsmXLHH300ampqcm11177bUQCAAAAAAAAsJh8K0V0kqy33npJ4o5oAAAAAAAAgCbuWyuiP//88yTJlClTvq1IAAAAAAAAABaDb62Ivv7665Mkyy677LcVCQAAAAAAAMBiUFXqiUOHDv3GNXPmzMnEiRPzwAMP5J///GcKhUK22GKLUiMBAAAAAAAAaARKLqIPPPDAFAqFOq8vFovp0KFDDj300FIjAQAAAAAAAGgE6vVo7mKxWKevQqGQjTfeONddd12WXnrpcs0OAAAAAAAAQANU8h3R8975/HUqKirSunXrdO/ePe3atSs1CgAAAAAAAIBGpOQieqONNirnHAAAAAAAAAA0ESU/mvuSSy7JpZdemjlz5tRp/ZQpU3LSSSflmGOOKTUSAAAAAAAAgEag5DuiL7nkkhQKhRx00EGpqvrmy8yePTt33nlnWrduXWokAAAAAAAAAI3ANzbIxWIx48aN+8rPx40bl+rq6q+9xuzZs3PPPfckSQqFwkKOCAAAAAAAAEBj8o1FdKFQyKmnnpqnnnpqgeNJ8qMf/ajOYYVCId/5zncWckQAAAAAAAAAGpM6vSP6N7/5TZZYYokUi8V6fS277LI5+eSTF/WeAAAAAAAAAFiM6vSO6O7du+dvf/tbJk2alOSLx3Xvv//+KRQKufLKK7/20dyFQiGVlZXp0KFDVlhhhVRWVpZlcAAAAAAAAAAapjoV0Umy+uqrf+nxDTfcMK1atSrbQAAAAAAAAAA0bnUuov+vIUOGJIkSGgAAAAAAAID5lFxEL7fcciWdN3v27LRo0aLUWAAAAAAAAAAauJKL6HmmTZuW559/PhMnTsycOXNSLBbn+7xYLGbWrFmZNm1a3nvvvTz66KN5/PHH6xsLAAAAAAAAQANVryL69ttvz5lnnpnp06fXaX2xWEyhUKhPJAAAAAAAAAANXMlF9KuvvppTTz01xWJxgbugv8ryyy+fzTbbrNRIAAAAAAAAABqBilJPvOmmm1JTU5Pq6uqcfPLJGTx4cE477bQkyY9//OM8+OCD+etf/5pjjjkmrVu3TqFQyMYbb5zTTz+9bMMDAAAAAAAA0PCUXEQPGzYshUIhhx56aPbbb7/07Nkz2223XZLk5ZdfTo8ePbLeeuvliCOOyM0335zq6urccccdef7558s2PAAAAAAAAAANT8lF9Mcff5wk2XrrrWuPde7cOcsss0zefvvtTJkypfZ4z549s//++6dYLObWW2+tx7gAAAAAAAAANHQlF9GzZ89Okiy77LLzHV955ZVTLBbzxhtvzHd8++23T5KMGDGi1EgAAAAAAAAAGoGSi+gOHTokSSZPnjzf8R49eiRJRo8ePd/xeYX1vDupAQAAAAAAAGiaSi6iV1999STJc889N9/xFVZYIcViMS+//PJ8xz/99NMk/7mTGgAAAAAAAICmqeQi+rvf/W6KxWL++Mc/5sUXX6w9vs466yRJHnrooUyaNKn2+Lx3Qy+zzDKlRgIAAAAAAADQCJRcRO++++7p3LlzPv300/zkJz/JGWeckSTZeOONs9JKK2XSpEnZbbfdcs455+SnP/1pbrzxxhQKhWy66aZlGx4AAAAAAACAhqfkIrpNmza54oor0rlz5xSLxRQKhdrPfvnLXyZJPvzww1xzzTV59NFHUywW07p16xx++OH1nxoAAAAAAACABqvkIjpJvvOd7+SBBx7I//zP/2TzzTevPb7NNtvk4osvrn1fdLFYzHe+851cd9116dGjR72HBgAAAAAAAKDhqqrvBdq0aZO99957gePbbLNNttlmm0yaNCmVlZVp165dfaMAAAAAAAAAaATqXUR/kw4dOizqCAAAAAAAAAAakLIU0bNmzcqQIUMybNiwjB8/PlOnTs21116bJLnxxhuzzjrrZP311y9HFAAAAAAAAAANXL2L6Pvuuy+/+93v8umnnyZJisViCoVC7efXXXdd3n///ey0004544wz0rJly/pGAgAAAAAAANCAVdTn5BtvvDG//OUv88knn6RYLKZz584LrPn4449TLBZzzz335Nhjj61PHAAAAAAAAACNQMlF9OjRo/P73/8+SbLddtvloYceygMPPLDAuvvuuy/bbLNNisVi/vWvf+XBBx8sfVoAAAAAAAAAGrySi+i//OUvmTt3bjbffPNcdNFF6d69+3yP5J6nW7duufjii7PFFlukWCzmjjvuqNfAAAAAAAAAADRsJRfRQ4cOTaFQyE9/+tNvXFsoFHLYYYclSV5++eVSIwEAAAAAAABoBEouoj/66KMkyWqrrVan9SuvvHKS5LPPPis1EgAAAAAAAIBGoOQiurq6Okkybdq0Oq2fPHlykqRNmzalRgIAAAAAAADQCJRcRK+00kpJkscee6xO6//xj3/Mdx4AAAAAAAAATVPJRfQ222yTYrGYiy66KO+///7Xrn3hhRdy5ZVXplAoZKuttio1EgAAAAAAAIBGoKrUE/fdd9/cfPPNGT9+fHbbbbcMGDAgPXv2rP38vffey9ixYzNkyJDcdtttmT17dpZaaqnsvffeZRkcAAAAAAAAgIap5CK6VatWueKKK3LggQdmwoQJufTSS5MkhUIhSbL99tvXri0Wi2nbtm0uvfTStG3btp4jAwAAAAAAANCQlfxo7iRZY401ctddd2WXXXZJVVVVisXiAl9JstVWW+WOO+7IeuutV5ahAQAAAAAAAGi4Sr4jep6ll146f/jDH3LKKadk+PDhGTt2bKZMmZLq6up069YtG2ywQZZaaqlyzAoAAAAAAABAI1DvInqedu3aZYsttijX5QAAAAAAAABopOr0aO5Ro0Zl1KhRi3oWAAAAAAAAAJqAOt0Rveuuu6aioiLDhg1Lq1atFvVMAAAAAAAAADRidbojOkmKxeJXfjZr1qwMHDgwP/vZz8oyFAAAAAAAAACNV1neET1nzpw8/PDDKRQK5bgcAAAAAAAAAI1Yne+Ibghmz56ds846K5tuumnWXXfdHHjggXn77be/cv2UKVNy0kknZcMNN0yvXr3ys5/9LB999NF8aw4++OCsscYa831tvPHGi3orAAAAAAAAAE1WWe6I/rZccMEFufbaa9OxY8estNJKeeqpp3LIIYfk3nvv/dJ3V59yyin5xz/+ka5du6Zly5Z58MEHM378+AwaNKj27u2RI0emqqoqW2yxRe15bdu2/db2BAAAAAAAANDUNJoieubMmbnllltSKBQyaNCg9OjRI/vss0+ef/75PPTQQ9l5553nWz9+/Pjcf//9ad26de65555UV1dn++23z4gRIzJ8+PD07t0748ePz4QJE7LqqqvmsssuW0w7AwAAAAAAAGhaGs2juV9//fVMnTo1Xbt2TY8ePZIkm266aZJk+PDhC6wfPnx4isVi1l577bRr1y4tWrTIRhttNN/6kSNHJkkqKyvzP//zPznhhBPywAMPfBvbAQAAAAAAAGiyGs0d0R9++GGSpGPHjrXH5n0/fvz4BdaPGzfuG9fPK6Jff/31vP7660mSu+66K0cffXSOOuqoes1bVdVoOv4GrbJy0f8c65sx7/xvY9ZFlbuoZy/njN/mz7kp/G7lNqzc5rRXuU03U27Tzm1Oe5XbdDPlNu3c5rRXuU03U27Tzm1Oe21uuc1pr3Kbbqbcpp3bnPa6OHNZOI2miJ4xY0aSpKrqPyO3aNFivs8Wdn2nTp3Sp0+fbLvtttltt93y6KOP5pe//GUuv/zy7Lbbbll22WVLmrWiopCOHduUdC7fvvbtF3y/+OK8TmPJXRjlnHFx7Le5/W7lNs1MuU07tzntVW7TzZTbtHOb017lNt1MuU07tzntVW7TzZTbdDPlNu3c5rRXuU03sznmUjeNpohu2bJlkmTOnDm1x2bPnp0kqa6u/sr1c+fOXWB9q1Zf/FHuvffe2XvvvWs/33HHHXPFFVfkzTffzMsvv1xyEV1TU8zkydNKOpf5VVZWLPL/iEyePD1z59aUfP68Get7ncWZu6h/zuWc8dv8OTeF363chpXbnPYq19+U3MaZ25z2KtfflNzGmduc9irX35TcxpnbnPba3HKb017l+puS2zhzm9NeF2cuX2jfvlWd7kZfqCL6nnvuyRJLLLHA8VmzZtV+P3jw4G+8zq677rowsUmSLl26JEk+++yz2mMTJ05MknTt2vUr10+aNGmB9fMK5nHjxuWjjz7KqquumjZtvriDed7+/rvwLsWcOf7oG4u5c2vK8vsq13UaS+7CKOeMi2O/ze13K7dpZspt2rnNaa9ym26m3Kad25z2KrfpZspt2rnNaa9ym26m3KabKbdp5zanvcptupnNMZe6Wagi+rTTTvvKzwqFQpLkpJNO+tprFAqFkoroNddcM9XV1fnggw8yduzYdO/ePU8//XSSpHfv3gusX3/99ZMkr776aqZMmZLq6uo8//zz860/5phj8tJLL+XEE0/MgQcemA8++CBvvvlmKisrs+666y70jAAAAAAAAAAkdX6Dd7FYLNtXKVq1apU999wzxWIxe+65Z3784x/nueeey/LLL59tt902Q4cOzZFHHplzzjknSdK9e/dss802mTJlSnbeeefstNNOGTNmTHr16lVbUh988MFJkrPPPjsDBgzIbrvtllmzZmXvvffOcsstV9KcAAAAAAAAAM1dne6Ivv766xf1HHVywgknpEWLFrnzzjvz1ltvZbPNNsv//M//pGXLlhk3blyGDBmS9dZbr3b92WefnbPOOiv3339/JkyYkO222y6nnXZa7d3bP/jBD3L++efnT3/6U0aMGJEOHTpk4MCBOeKIIxbXFgEAAAAAAAAavToV0RtttNGinqNOqqqqcvzxx+f4449f4LN+/fqlX79+8x1r06ZNzjjjjJxxxhlfec0f/vCH+eEPf1j2WQEAAAAAAACaqzo/mhsAAAAAAAAA6kIRDQAAAAAAAEBZKaIBAAAAAAAAKCtFNAAAAAAAAABlpYgGAAAAAAAAoKwU0QAAAAAAAACUlSIaAAAAAAAAgLJSRAMAAAAAAABQVopoAAAAAAAAAMpKEQ0AAAAAAABAWVXVZdF+++1XtsBCoZDrrruubNcDAAAAAAAAoGGpUxH97LPPplAopFgsLvBZoVCo/b4un//3vwEAAAAAAABoeupURO+6665fWiBPnDgxjzzySJJkySWXTN++fbPSSiulXbt2mTVrVsaOHZsnnngiH374YaqqqrLvvvumU6dOZd0AAAAAAAAAAA1LnYros846a4FjM2bMyO67755CoZD9998/xx57bFq2bLnAumKxmGuvvTbnnHNOhgwZkttvv73+UwMAAAAAAADQYFWUeuLVV1+dN998M7vuumtOPPHELy2hky8ezX3QQQdlv/32y9ixY3PJJZeUPCwAAAAAAAAADV/JRfTf//732ruh62LPPfdMkjz88MOlRgIAAAAAAADQCJRcRI8bNy5J0rVr1zqtn/du6E8//bTUSAAAAAAAAAAagZKL6M6dOydJRo8eXaf1I0aMSJJ06dKl1EgAAAAAAAAAGoGSi+h11103xWIxF1xwQebMmfO1a6dOnZpzzjknhUIhG220UamRAAAAAAAAADQCJRfR894N/dxzz+WAAw7I8OHDF1hTLBbz2GOPZa+99sqbb76ZqqqqHHTQQaVPCwAAAAAAAECDV1Xqib169crRRx+diy66KMOGDcs+++yT1q1bp3v37qmurs706dMzZsyYzJgxI8ViMUly5plnZuWVVy7b8AAAAAAAAAA0PCUX0Uly5JFHZtlll80f//jHfPLJJ5k6dWpGjRq1wLru3bvn9NNPz6abblqfOAAAAAAAAAAagXoV0UnSr1+//OhHP8rTTz+dp59+OuPGjcvnn3+eJZdcMl27ds13v/vdbLTRRqmoKPkp4AAAAAAAAAA0IvUuopOkZcuW2WKLLbLFFluU43IAAAAAAAAANGJlv015ypQpGT9+fLkvCwAAAAAAAEAjUZY7oh9++OEMGjQoL7zwQqZMmZJCoZCRI0cmSQ466KD06NEjRx11VJZeeulyxAEAAAAAAADQgNWriJ46dWp++ctf5tFHH02SFIvFBda8/vrrGTp0aB566KFceeWVWWeddeoTCQAAAAAAAEADV69Hcx999NF59NFHUywWs8EGG+Sggw5aYE3Pnj1TLBbz6aef5ogjjsjnn39en0gAAAAAAAAAGriSi+h77703Tz75ZFq0aJFLL700N910UwYOHLjAuj//+c+5+OKL07Jly3zyySe54YYb6jUwAAAAAAAAAA1byUX0nXfemUKhkMMOOyxbb731167ddtttc/jhh6dYLGbIkCGlRgIAAAAAAADQCJRcRL/66qtJkh/96Ed1Wr/DDjskSd59991SIwEAAAAAAABoBEouoqdMmZIkWWqppeq0vmPHjkmS2bNnlxoJAAAAAAAAQCNQchHdoUOHJMn7779fp/WjR49O8p9CGgAAAAAAAICmqeQiulevXkmSW2+9tU7rr7nmmhQKhay33nqlRgIAAAAAAADQCJRcRO+2224pFosZNGhQrrvuuq9cN3PmzPy///f/MmTIkCTJrrvuWmokAAAAAAAAAI1AVaknbrHFFvnhD3+Y++67L2eddVZuuOGGrLXWWrWfn3/++Xn//ffz5JNP5rPPPqs9Z6uttqr/1AAAAAAAAAA0WCUX0Uly1llnpbKyMvfcc0/ef//9fPDBBykUCkmSP/3pT0mSYrGYJNlyyy1z3nnn1XNcAAAAAAAAABq6ehXRSyyxRM4555z0798/t9xyS5577rl8+umntZ+3adMmvXv3zh577JFtttmm3sMCAAAAAAAA0PDVq4ieZ+ONN87GG2+cJJk6dWqmTJmSVq1apX379uW4PAAAAAAAAACNSMlF9ODBg5MkO++8cyoqKmqPt2nTJm3atFlg/bRp03LNNddk8uTJOfnkk0uNBQAAAAAAAKCBq/jmJV/uxBNPzMknn5yZM2fWaf3s2bNzySWX5M477yw1EgAAAAAAAIBGoOQiOkmKxWIKhcI3rpszZ04eeOCB2u8BAAAAAAAAaLq+8dHcNTU12WOPPfLqq6/Od3xeAd2rV686hxUKhayxxhoLOSIAAAAAAAAAjck33hFdUVGR008/PYVCIcVisV5frVq1yi9/+ctvY18AAAAAAAAALCbfeEd0kqy11lr505/+lI8//rj22EknnZRCoZDf/OY3WWKJJb7y3EKhkMrKynTo0CHrrLNOOnbsWP+pAQAAAAAAAGiw6lREJ0nfvn3n+/dJJ52UJNl5553TqlWr8k4FAAAAAAAAQKNV5yL6/7r++uuTJNXV1WUbBgAAAAAAAIDGr+QieqONNirnHNDgVFQUUlFR+MZ1lZUV8/3fb1JTU0xNTbFeswEAAAAAAEBDVnIR/d9GjRqVMWPGZOrUqZk7d+43ru/fv385YmGRqagopFOn6hQKdf+fSPv2dXtEfbE4JxMmzFBGAwAAAAAA0GTVq4h+9tlnc8opp2Ts2LF1PqdQKCiiafAqKgr/W0Lvk+S1Ml55zRQKN6WioqCIBgAAAAAAoMkquYgePXp0Dj/88MyYMSPFokKNpuq1JC8s7iEAAAAAAACgUSm5iL766qszffr0VFVVZcCAAdl2222z9NJLp6Kibu/JBQAAAAAAAKBpKrmIfvrpp1MoFPLTn/40AwcOLOdMAAAAAAAAADRiJd++/MknnyRJdtxxx7INAwAAAAAAAEDjV3IRveSSSyZJ2rRpU7ZhAAAAAAAAAGj8Si6iN9xwwyTJM888U7ZhAAAAAAAAAGj8Si6iDz300BQKhVxwwQWZOHFiOWcCAAAAAAAAoBGrqsuisWPHLnCsXbt22X///XPttddml112yQEHHJD11lsvHTp0yBJLLPG11+vevXtp0wIAAAAAAADQ4NWpiN52221TKBS+9LNCoZCPP/4455xzTp0CC4VCRo4cWfcJAQAAAAAAAGhU6lREJ0mxWFyUcwAAAAAAAADQRNSpiP7973+/qOcAAAAAAAAAoImoUxH94x//eFHPAd9gzUZyTQAAAAAAAKDOj+aGxaVYnJtC4aZFdm0AAAAAAACgvBTRNHiFQmXuvvvufPLJJ2W97lJLLZWdd965rNcEAAAAAAAA6lFEb7311gu1vlAopLKyMi1btkznzp2z8sorZ/PNN89WW21V6gg0I6+++mrGjh1b1mt2795dEQ0AAAAAAACLQMlF9AcffFCv4Keffjo333xzNt5445x33nnp3Llzva4HAAAAAAAAQMNQchH9xz/+MaNHj85ll12WYrGYpZdeOltttVVWXnnltG7dOtOnT8+YMWPy6KOPZuzYsSkUCvne976XLl26ZMqUKXn11Vfz3nvv5ZlnnsnRRx+d66+/PpWVleXcGwAAAAAAAACLQclF9CabbJLf/e53SZLDDz88P/vZz1JVteDlTjnllFx77bU5++yz89Zbb+Xcc89Nu3btkiR33313TjnllAwfPjz33Xdfdtppp1LHAQAAAAAAAKCBqCj1xMsvvzyffPJJdt999xx77LFfWkLPc+CBB2a//fbLhx9+mCuuuKL2+M4775yDDz44xWIxgwcPLnUUAAAAAAAAABqQkovof/7znykUChkwYECd1u+5554pFot54IEH5ju+ww47JEnefvvtUkcBAAAAAAAAoAEpuYj++OOPkyTLLLNMndZ36tQpSfLRRx/Nd3ze+Z988kmpowAAAAAAAADQgJRcRHfp0iVJ8tprr9Vp/ahRo5Ik7du3n+/4hAkTkiTV1dWljgIAAAAAAABAA1JyEb3uuuumWCzmvPPOy8yZM7927ezZs3PBBRekUChkgw02mO+zf/3rX0mSVVZZpdRRAAAAAAAAAGhASi6iDzzwwBQKhbzyyivZe++98/TTT3/puueeey4DBgzIiy++mEKhkP322y9JMnXq1Nxxxx257LLLUigUsvXWW5c6CgAAAAAAAAANSFWpJ66zzjo5+eSTc+aZZ2bkyJE58MAD07p163Tv3j3V1dWZPn16xowZkxkzZqRYLCZJjj766PTp0ydJ8pe//CWXXHJJisViunXrln322ac8OwIAAAAAAABgsSq5iE6SAQMGpFu3bvnDH/6QMWPGZOrUqbXvgv5vXbt2zUknnZTtttuu9tg777yTYrGYXr165Q9/+ENat25dn1EAAAAAAAAAaCDqVUQnydZbb50tt9wyw4YNyxNPPJEPPvggkyZNSnV1dXr06JGNN9443/ve91JRMf9TwA855JAce+yxWW655eo7AgAAAAAAAAANSL2L6CSprKzMRhttlI022qjO5/Ts2bMc0QAAAAAAAAA0MBXfvAQAAAAAAAAA6q5Od0RfeOGFSZIOHTpk//33n+9YKY455piSzwUAAAAAAACgYatTEX355ZenUCikR48etUX0vGOlUEQDAAAAAAAANF11fkd0sVis0zEAAAAAAAAAmrc6FdGjRo2q0zEAAAAAAAAAqFjcAwAAAAAAAADQtCiiAQAAAAAAACirOr8j+uu89tprGTRoUIYNG5bx48dn6tSpefXVV5Mkv/rVr7LqqqtmwIABqa6uLkccAAAAAAAAAA1YvYroOXPm5Mwzz8ytt96aJCkWi0mSQqFQu2bo0KG5++67c8cdd+Sqq67K8ssvX59IAAAAAAAAABq4ej2a++STT86tt96aYrGYrl27Zvvtt19gTdu2bVMsFvPOO+/k0EMPzaxZs+oTCQAAAAAAAEADV3IR/dhjj+Xuu+9OoVDIySefnIcffji/+93vFlh377335sQTT0yhUMi7776bW265pV4DAwAAAAAAANCwlVxEDxo0KIVCIfvss0/222+/VFR8+aUKhUIOOOCA7L///ikWi7n//vtLHhYAAAAAAACAhq/kIvrFF19MkvTv379O6/v165ckeeutt0qNBAAAAAAAAKARqCr1xM8++yxJ0rVr1zqt79KlS5Jk+vTppUYClEVFRSEVFYVvXFdZWTHf/62LmppiamqKJc8GAAAAAADQFJRcRLdv3z4TJkzIxx9/nPbt23/j+vfffz9J0qFDh1IjAeqtoqKQ/8/ev4fXVddp4/+9VhLStKG2WKSlBCjMKIcRwSJYQPGAPoo+QUFERRS+4oyPogwKKg6gI+J4QkA8MIooIEWrohRQhIIHFHigFEVbwQELhNLws6Qc0nOy9+8PnnbsFOjuzk6bw+t1Xb0oK5/9ud8rO1cpubPW2mabMSmK2v/4Gz++rea11WpfenpWKqMBAAAAAIBRre4ies8998xNN92U2bNn56STTtro+pkzZyZJ9thjj3ojAQasLIv/V0IfneTPDd599xTFZSnLQhENAAAAAACManUX0Z2dnfnNb36Tb3/723nhC1+YQw455BnXXnTRRfnxj3+coijyhje8od5IgAb6c5I7t/QQAAAAAAAAI1LdRfQb3/jGzJo1K7fddls++MEP5iUvecl6VzvPmjUrDz30UG688cbcd999SZK99tornZ2dA58aAAAAAAAAgCGr7iI6Sb72ta/l/e9/f26//fZ1v4qiSJJ88pOfTJJUq0/dnnaPPfbI17/+9XUfBwAAAAAAAGBkGlARvfXWW+eSSy7JFVdcke9///tZsGBB+vv711uz66675sgjj8w73vGObLXVVgMaFgAAAAAAAIChb0BFdJIURZEjjjgiRxxxRJYtW5ZFixalt7c3bW1tmTx5ciZOnNiIOQEAAAAAAAAYJmoqoo8++ugceOCBOfDAA7PXXns94+21x40bl+c///kNHRAAAAAAAACA4aWmIvqOO+7IvHnzcv7552f8+PHZf//9c9BBB+WAAw7IDjvsMNgzAgAAAAAAADCM1FREd3R0pKurK0ny+OOP5/rrr8/111+fJNlxxx3XXS390pe+NOPGjRu8aQEAAAAAAAAY8moqoq+//vr87W9/y+23357bb789c+fOzb333ptqtZoHHnggDz74YC6//PI0NTVlr732yoEHHpiDDjroWW/jDQAAAAAAAMDIVFMRnSTbbrttDj300Bx66KFJksceeyxz585dV07fc8896evry7x583LnnXfmq1/96rrbeK+9YtptvAEAAAAAAABGvpqL6P9pwoQJOeSQQ3LIIYckSXp7e3PHHXdk7ty5mTt3bv70pz/l8ccfz3XXXbfebbwPOuignH766Y2ZHgAAAAAAAIAhp+4i+n9qb2/PwQcfnIMPPjhJsmrVqvzhD3/IvHnzctttt+XWW29ddxvveovoNWvW5Oyzz86VV16ZZcuWZfr06Tn99NOzyy67PO363t7enHXWWZkzZ076+vrWleDPe97zNlj75JNP5o1vfGO6u7tzww03uHobAAAAAAAAoE4NK6LXqlarWbBgQW677bb86U9/yt13350HHngg1Wp1wHufe+65+c53vpOJEydm2rRpufnmm3P88cfnmmuuSVtb2wbrTzvttPz85z/PlClT0tramuuuuy7d3d2ZNWvWBs+uPvPMM9Pd3T3gGQEAAAAAAABGu4YU0Q888EBuuumm/O53v8vcuXPT29ubJOvK5+bm5uyzzz458MAD87KXvayujFWrVuXyyy9PURSZNWtWdtxxxxx99NGZO3durr/++nR2dq63vru7O9dee23Gjh2bq666KmPGjMnrXve63HXXXZk3b16mT5++bu2cOXNy5ZVX1nn2AAAAAAAAAPy9uorolStX5tZbb81NN92U3/zmN3nooYeSZL2rnjs6OnLggQfmoIMOyktf+tK0t7cPaNB77rkny5Yty/bbb58dd9wxSTJjxozMnTs38+bN26CInjdvXqrVavbcc89svfXWSZL99tsvDz300HpFdE9PT84444xMnjw5q1evTk9Pz4DmBAAAAAAAABjtai6i77333tx000256aabMnfu3KxZsybJf5fP48aNy/7775+DDjooBx100LqyuFEefvjhJMnEiRPXHVv7+6e7pfbixYtrWv+pT30qjz76aL797W/njDPOaOjMAAAAAAAAAKNRTUX0K1/5ynXl7driuSzL7Lnnnuuuet57773T3NzwR06vs3LlyiRZL6OlpWW9j23q+tmzZ+cXv/hF3vrWt+aggw5q6LzNzWVD9xutmpoG//P4dBmDnduI/dfu0ci9BstQOt8t9TVVz+s3x6xyN2/uaDpXuSM3U+7Izh1N5yp35GbKHdm5o+lc5Y7cTLkjO3c0netoyx1N5yp35GbKHdm5o+lct2Qum6am5njx4sUpiiITJ07Mq171qhxwwAE54IADMmHChEEe77+1trYmSfr6+tYdW3tV9pgxY55xfX9//wbr29ra8sgjj+Qzn/lMpk6dmo997GMNnbUsi0ycOK6hezJ4xo9vG9aZW2L+TeV8t+w+code7mg6V7kjN1PuyM4dTecqd+Rmyh3ZuaPpXOWO3Ey5Izt3NJ3raMsdTecqd+Rmyh3ZuaPpXLdkLrXZpEuYly5dmjvuuCOtra1pa2vL/vvvn7Fjxw7WbOvZbrvtkiSPP/74evMkyZQpU55x/WOPPbbB+smTJ+d3v/tdHn/88Tz++OPrnhe91qtf/eqccMIJ+eAHP1jXrJVKNU88sbyu17K+pqZy0P8QeeKJFenvr2zW3KfL3FRrZ2zkXoNlKJ3vlvqa2hSNfG/lDq3c0XSucn1NyR2euaPpXOX6mpI7PHNH07nK9TUld3jmjqZzHW25o+lc5fqakjs8c0fTuW7JXJ4yfnxbTVej11REH3PMMfntb3+bhQsXZuHChbn//vszc+bMNDc3Z++9987LXvayHHTQQdljjz0GPPgz2X333TNmzJgsWrQoXV1d6ejoyK233pokGxTJSbL33nsnSebPn5/e3t6MGTMmc+fOXbd+5cqVefWrX73ea373u99l5cqVOfDAA7PLLrsMaN6+Pl/0w0V/f2Wzv1+NzNwS828q57tl95E79HJH07nKHbmZckd27mg6V7kjN1PuyM4dTecqd+Rmyh3ZuaPpXEdb7mg6V7kjN1PuyM4dTee6JXOpTU1F9L/9278lSR5++OHcdNNNuemmm3Lrrbemt7c3t99+e+bOnZtzzjknEydOzAEHHJCDDjooBx10UCZNmtSwQdva2nLUUUfl4osvzlFHHZXtttsuCxYsyA477JDXvOY1ueWWW3LppZdm2rRpOeWUU9LR0ZFDDjkkc+bMSWdnZ1pbW/Pggw9mn332yd57752iKDJjxoz1Ml71qldl0aJF+fSnP50ddtihYbMDAAAAAAAAjCabdGvu7bffPkcddVSOOuqo9Pf3584771xXTP/5z39OT09Prr766lxzzTVJkhe84AXrSunp06enpaVlQMN+9KMfTUtLS37yk5/k3nvvzQEHHJAzzjgjra2tWbx4cW644Ya86EUvWrf+C1/4Qj73uc/l2muvTU9PT1772tfmk5/8ZIqiGNAcAAAAAAAAADyzTSqi/15TU1P23Xff7LvvvjnppJPS09OzrpS++eab09PTk7vvvjv33HNPvv3tb2fMmDHZf//9c9BBB+Wd73xnfcM2N+eUU07JKaecssHHDj/88Bx++OHrHRs3blzOPPPMnHnmmTXtf+ONN9Y1FwAAAAAAAAD/re4i+n/aZpttcthhh+Wwww5L8tSzmW+//fbcfvvtueOOO/LYY4/lV7/6VX7961/XXUQDAAAAAAAAMPSVg7Xx+PHj87znPS877rhjdt111zQ1NQ1WFAAAAAAAAABDSEOuiF6zZk3+9Kc/5c4778y8efMyb968LF26dN3Hq9Vqmpqastdee2XGjBmNiAQAAAAAAABgiKqriF66dOl6pfP8+fOzevXqJE+VzmvtsssumTFjRmbMmJH9998/W2+9dWOmBgAAAAAAAGDIqqmIXrhw4brSed68ebn//vvXfezvi+ftttsuM2bMyEtf+tIccMABed7zntfwgQEAAAAAAAAY2moqol//+tenKIok6xfP48ePz3777bfuqudddtllcKYEAAAAAAAAYNio+dbc1Wo1ra2tefGLX7zuqucXvvCF6wpqAAAAAAAAAEhqLKL/+Z//OTNmzMj06dOz1VZbDfZMAAAAAAAAAAxjNRXRH/7whwd7DgAAAAAAAABGiHJLDwAAAAAAAADAyKKIBgAAAAAAAKChFNEAAAAAAAAANJQiGgAAAAAAAICGUkQDAAAAAAAA0FCKaAAAAAAAAAAaShENAAAAAAAAQEMpogEAAAAAAABoqOZaFt1+++0NDX3JS17S0P0AAAAAAAAAGDpqKqKPOeaYFEXRkMCiKLJgwYKG7AUAAAAAAADA0FNTEZ0k1Wq1pnVNTU0ZO3ZsVq9enVWrVq07XhRFWlpaNn1CAAAAAAAAAIaVmoroG2644WmPX3755bnwwgszfvz4HH/88XnNa16TnXfeed3V03/729/y61//Ol//+tfzyCOP5MQTT8x73vOexk0PAAAAAAAAwJBTUxE9derUDY7dcccdueiii7Lddttl5syZT7tm2223zVve8pYccsghedvb3pYvfelL2WWXXfLKV75y4JMDAAAAAAAAMCSV9b7wm9/8ZqrVak4++eSnLaH/3oQJE3LyySenWq3moosuqjcSAAAAAAAAgGGg7iL697//fZLkwAMPrGn99OnTkyR//vOf640EAAAAAAAAYBiou4ju6+tLkqxevbqm9U8++WSSpKmpqd5IAAAAAAAAAIaBuovonXbaKUly7bXX1rT+Rz/6UZJkl112qTcSAAAAAAAAgGGg7iL6DW94Q6rVas4777z85je/eda1P/7xj/Ptb387RVHkiCOOqDcSAAAAAAAAgGGgud4Xvu1tb8usWbPywAMP5F/+5V/y0pe+NC9/+cvT0dGRtra2rFixIn/9618zZ86c/PGPf0y1Ws2LX/zivOlNb2rg+AAAAAAAAAAMNXUX0ePGjcuFF16Y448/Pg888EBuvfXW3HrrrRusq1arSZJ99903X/3qV9PcXHckAAAAAAAAAMPAgFrhjo6OXH311bnsssty9dVXZ/78+euK5yQpyzLTp0/PEUcckTe/+c0DHhYAAAAAAACAoW/Alye3tLTk2GOPzbHHHpve3t488sgjeeKJJ/Kc5zwn2223XcaNG9eIOQEAAAAAAAAYJhp6n+z29va0t7c3cksAAAAAAAAAhplySw8AAAAAAAAAwMgyoCuiq9VqfvrTn+a6667LQw89lJUrV6ZSqTzra4qiyJw5cwYSCwAAAAAAAMAQVncR3d/fn3/5l3/J7373uyRPldK1KIqi3kgAAAAAAAAAhoG6i+gf/vCH+e1vf5skGTNmTF74whdmm222yVZbbdWw4QAAAAAAAAAYfuouon/6058mSfbYY49ceOGF2WabbRo1EwAAAAAAAADDWFnvC//rv/4rRVHkYx/7mBIaAAAAAAAAgHXqLqLXPhN6t912a9gwAAAAAAAAAAx/dRfRO+20U5JkyZIlDRsGAAAAAAAAgOGv7iL69a9/farVan784x83ch4AAAAAAAAAhrm6i+hjjz02L3jBC3LxxRfnsssuS39/fyPnAgAAAAAAAGCYaq73hbNnz85hhx2W888/P5/5zGfyla98JXvssUcmTpyY5uZn3rYoinz+85+vNxYAAAAAAACAIa7uIvq0005LURRJkmq1mscffzy33nrrs76mWq0qogEAAAAAAABGuLqL6O23376RcwAAAAAAAAAwQtRdRN94442NnAMAAAAAAACAEaLc0gMAAAAAAAAAMLIoogEAAAAAAABoqLpvzf337rvvvixdujR9fX2pVqvrfaxarWbNmjVZtmxZHnjggVx//fW54oorGhELAAAAAAAAwBA0oCL6t7/9bc4444wsXry4UfMAAAAAAAAAMMzVXUQ/8MAD+cAHPpDVq1dvcBX0MxkzZkymT59ebyQAAAAAAAAAw0DdRfSll16aVatWpbm5OUcffXT222+/zJ8/P1//+tdz6KGH5sgjj8zSpUtzyy235IorrkilUsm73/3unHTSSY2cHwAAAAAAAIAhpqz3hbfcckuKosjRRx+dU089Na9+9avz1re+NUly//33Z8aMGTn00ENz5pln5pvf/Gaamppy4YUX5u67727Y8AAAAAAAAAAMPXUX0Y888kiS5LDDDlt3bPLkyZk4cWLuueeerFy5ct3xAw88MG9729vS39+fmTNnDmBcAAAAAAAAAIa6uovotUXzlClT1jv+D//wD6lUKvnLX/6y3vHOzs4kyR133FFvJAAAAAAAAADDQN3PiH7Oc56Tnp6eLF++PBMnTlx3vKOjI3Pnzs19992Xvfbaa73jSbJ48eIBjAub2+5DfD8AAAAAAAAYeuouoqdNm5aenp786U9/ytSpU9cd33nnnVOtVrNgwYK8+c1vXnf8ySefTJKsXr16AOPC5lOt9qcoLhuUfZ9NU1OZ5uaN36ygLIskSUtLU5qaNr6+r6+S/v5KbUMCAAAAAADAANRdRB9wwAGZO3duzjnnnLzwhS/M9ttvnyR5wQtekCS5/vrrc/LJJ6e1tTVJcs011yTJeldPw1BWFE2ZPXt2lixZ0rA9J02atO429U+nLItMmNCWsqz9rvnt7WNqWlepVLJ06fJUKtWa9wYAAAAAAIB61F1Ev/3tb8+FF16YBx54IK973evy3ve+Nx/84Adz4IEHZsqUKenu7s673vWuHHbYYbnvvvvy/e9/P0VR5CUveUkj54dBNX/+/HR1dTVsv46Ojo0W0WVZDloBXpaFIhoAAAAAAIBBV3cRPXHixJxzzjn513/916xYsSKPPvroUxs2N+f9739/Tj/99Nx111256667kiTVajXNzc05/vjjGzM5jGCbuwAHAAAAAACARqq7iE6Sgw8+OD/72c/yve99L89//vPXHT/yyCOzcuXKfOUrX1n3bOhtt902Z555ZvbYY4+BTQwAAAAAAADAkDagIjpJpkyZklNOOWWD48ccc0ze+ta35t57701TU1Oe//znb9JzbwEAAAAAAAAYngZcRD+b1tbW7LnnnoMZAQAAAAAAAMAQ4xJlAAAAAAAAABpKEQ0AAAAAAABAQymiAQAAAAAAAGgoRTQAAAAAAAAADaWIBgAAAAAAAKChFNEAAAAAAAAANJQiGgAAAAAAAICGUkQDAAAAAAAA0FCKaAAAAAAAAAAaqnlzBV122WVZunRpiqLIuHHjstNOO+Wggw5KS0vL5hoBAAAAAAAAgM1gsxXR3/ve93L//fcnSdra2rJ8+fJsv/32+eY3v5l/+Id/2FxjAAAAAAAAADDINuutuavVapJk3rx5ue6667LDDjvk9NNP35wjAAAAAAAAADDINtsV0Z///OezcuXKdf++44475itf+UpWrVq1uUYAAAAAAAAAYDPYbEX0XnvttcGxCRMmbK54AAAAAAAAADaTzXprbgAAAAAAAABGPkU0AAAAAAAAAA1V0625b7/99oaGvuQlL2nofgAAAAAAAAAMHTUV0cccc0yKomhIYFEUWbBgQUP2AgAAAAAAAGDoqamITpJqtVrTuqampowdOzarV6/OqlWr1h0viiItLS2bPiEAAAAAAAAAw0pNRfQNN9zwtMcvv/zyXHjhhRk/fnyOP/74vOY1r8nOO++87urpv/3tb/n1r3+dr3/963nkkUdy4okn5j3veU/jpgcAAAAAAABgyKmpiJ46deoGx+64445cdNFF2W677TJz5synXbPtttvmLW95Sw455JC87W1vy5e+9KXssssueeUrXznwyQEAAAAAAAAYksp6X/jNb34z1Wo1J5988tOW0H9vwoQJOfnkk1OtVnPRRRfVGwkAAAAAAADAMFB3Ef373/8+SXLggQfWtH769OlJkj//+c/1RgIAAAAAAAAwDNRdRPf19SVJVq9eXdP6J598MknS1NRUbyQAAAAAAAAAw0DdRfROO+2UJLn22mtrWv+jH/0oSbLLLrvUGwkAAAAAAADAMFB3Ef2GN7wh1Wo15513Xn7zm98869of//jH+fa3v52iKHLEEUfUGwkAAAAAAADAMNBc7wvf9ra3ZdasWXnggQfyL//yL3npS1+al7/85eno6EhbW1tWrFiRv/71r5kzZ07++Mc/plqt5sUvfnHe9KY3NXB8AAAAAAAAAIaauovocePG5cILL8zxxx+fBx54ILfeemtuvfXWDdZVq9Ukyb777puvfvWraW6uOxIAAAAAAACAYWBArXBHR0euvvrqXHbZZbn66qszf/78dcVzkpRlmenTp+eII47Im9/85gEPCwAAAAAAAMDQN+DLk1taWnLsscfm2GOPTW9vbx555JE88cQTec5znpPtttsu48aNa8ScAAAAAAAAAAwTDb1Pdnt7e9rb2xu5JQAAAAAAAADDTMOK6Lvuuivz5s3L4sWLs2zZsnzmM59JkvziF7/IXnvtlSlTpjQqChghmprKNDeXNa0tyyJJ0tLSlKamjb+mr6+S/v7KgOYDAAAAAACgPgMuou+88878+7//e+655571jq8tos8555wsWrQoxx9/fD70oQ+lKIqBRgIjQFkWmTChLWVZWxG9Vnv7mJrWVSqVLF26PJVKdeOLAQAAAAAAaKgBFdHXXXddPvzhD6e/vz/VajVNTU3p7+9fr2x++OGHs2bNmlxwwQV59NFH8+lPf3rAQwPDX1kWKcsys2fPzpIlSxq696RJk9LZ2ZmyLBTRAAAAAAAAW0DdRXR3d3c++tGPpq+vLy960Yvyr//6r3nBC16QAw44YL113/3ud/OFL3whv//97/PDH/4wr3/96zNjxowBDw6MDPPnz09XV1dD9+zo6EhnZ2dD9wQAAAAAAKB2m3ZP3L9z0UUXZeXKldlrr71y6aWXZsaMGRkzZsNb5r74xS/OxRdfnL333jtJ8v3vf7/uYQEAAAAAAAAY+uouom+66aYURZETTjghW2211bOubW1tzQknnJBqtZrf//739UYCAAAAAAAAMAzUXUQvXrw4SfJP//RPNa3fY489kiQ9PT31RgIAAAAAAAAwDNRdRDc1NSVJ+vr6alq/YsWKJHna23cDAAAAAAAAMHLUXUR3dHQkSW677baa1v/qV79a73UAAAAAAAAAjEx1F9GveMUrUq1Wc9555+WJJ5541rUPPvhgzj///BRFkZe//OX1RgIAAAAAAAAwDNRdRB977LF5znOek4ceeihHHHFEfvrTn2bhwoXrPr5mzZosXLgwF154YY488sg89thjGTt2bN71rnc1ZHAAAAAAAAAAhqbmel84YcKEnHfeeXnf+96Xrq6unHrqqUmSoiiSJHvttde6tdVqNc3NzfnSl76UbbbZZoAjAwAAAAAAADCU1X1FdJK89KUvzaxZs7LvvvumWq0+46/ddtstl156aV75ylcOaNg1a9bkc5/7XGbMmJG99torxx13XP76178+4/re3t6ceuqpeclLXpJ99tknH/zgB/P/+//9/9Zb893vfjevfe1rs9dee+V//+//nauuumpAMwIAAAAAAACMdnVfEb3W85///Hzve9/Lfffdl//7f/9vurq60tvbmzFjxmT77bfP9OnT17s6eiDOPffcfOc738nEiRMzbdq03HzzzTn++ONzzTXXpK2tbYP1p512Wn7+859nypQpaW1tzXXXXZfu7u7MmjUrRVHkBz/4Qf7jP/4j48aNy4tf/OLMnTs3J598cpqamnLooYc2ZGYAAAAAAACA0WbARfRau+66a3bddddGbbeBVatW5fLLL09RFJk1a1Z23HHHHH300Zk7d26uv/76dHZ2rre+u7s71157bcaOHZurrroqY8aMyete97rcddddmTdvXqZPn55f/vKXSZKvfe1rmTFjRi644IKcc845+elPf6qIBgAAAAAAAKjTgG7NvTndc889WbZsWaZMmZIdd9wxSTJjxowkybx58zZYP2/evFSr1ey5557Zeuut09LSkv3222+99RdccEHuuOOO7L///kmSJUuWJEme85znDPr5AAAAAAAAAIxUA74iure3N7fcckseeuihrFixIpVKZaOvOeGEEzY55+GHH06STJw4cd2xtb/v7u7eYP3ixYtrWt/e3p7Fixfngx/8YP74xz+mo6MjJ5544ibP9z81Nw+bjn9Ia2oa/M/j02UMdu4z7T+ackfqe9uIjLWv3xyzyt28uaPpXOWO3Ey5Izt3NJ2r3JGbKXdk546mc5U7cjPljuzc0XSuoy13NJ2r3JGbKXdk546mc92SuWyaARXRP/3pT3PWWWelt7d3k15XTxG9cuXKJElz83+P3NLSst7H6l3/17/+NX/84x+TPFVWP/bYY9lhhx02eca1yrLIxInj6n49m9f48Rs+X3wkZsodfrnDfX65QytT7sjOHU3nKnfkZsod2bmj6VzljtxMuSM7dzSdq9yRmyl35GbKHdm5o+lc5Y7czNGYS23qLqLvuuuunHrqqUmSarXasIGeSWtra5Kkr69v3bE1a9YkScaMGfOM6/v7+zdY39a2/hfli1/84tx55535xS9+kY9//OP553/+58yZMydjx46ta9ZKpZonnlhe12tZX1NTOeh/iDzxxIr0969/Jf9g5z5d5mjLHanv7TPlboq1Mw50H7lDL3c0natcX1Nyh2fuaDpXub6m5A7P3NF0rnJ9Tckdnrmj6VxHW+5oOle5vqbkDs/c0XSuWzKXp4wf31bT1eh1F9EXXXRRqtVq2tracvLJJ+fggw/Oc5/73Gy11Vb1bvmstttuuyTJ448/vu7Y0qVLkyRTpkx5xvWPPfbYBusnT56c5Kliuru7Ox0dHUmSN7/5zfnsZz+bRx99NPfee2/22muvuuft6/NFP1z091c2+/u1JTLlDr/c4T6/3KGVKXdk546mc5U7cjPljuzc0XSuckduptyRnTuazlXuyM2UO3Iz5Y7s3NF0rnJHbuZozKU2dd84fe7cuSmKIqecckqOPvro7LDDDmlra0tTU9NGf9Vj9913z5gxY7Jo0aJ0dXUlSW699dYkyfTp0zdYv/feeydJ5s+fn97e3vT19WXu3LnrrX/Vq16VQw45ZN3x++67L08++WSSZNttt61rTgAAAAAAAIDRru4ieu2VyYccckjDhnk2bW1tOeqoo1KtVnPUUUflzW9+c26//fbssMMOec1rXpNbbrkl73//+/PFL34xSdLR0ZFDDjkkvb296ezszP/+3/87Dz74YPbZZ591JfUxxxyTJHnve9+b4447bt3+b3nLW572KmsAAAAAAAAANq7uInrSpElJkqIoGjbMxnz0ox/N8ccfnyS59957c8ABB+TCCy9Ma2trFi9enBtuuCG33377uvVf+MIX8ta3vjVPPvlkFi9enNe+9rX56le/um7mf/7nf84ZZ5yRKVOm5M4778y2226bj3/84/n0pz+92c4JAAAAAAAAYKSp+xnRM2bMyE9+8pPcfPPNOeywwxo50zNqbm7OKaecklNOOWWDjx1++OE5/PDD1zs2bty4nHnmmTnzzDOfcc+jjz46Rx99dMNnBQAAAAAAABit6r4i+vjjj89WW22Vc889N4888kgjZwIAAAAAAABgGKv7iuidd94555xzTj7ykY+sewbzXnvtlYkTJ6a5+dm3nTFjRr2xAAAAAAAAAAxxdRfRe+6557rfr1ixIpdddlkuu+yyjb6uKIosWLCg3lgAAAAAAAAAhri6i+hqtfqs/w4AAAAAAADA6FR3EX3JJZc0cg4AAAAAAAAARoi6i+j99tuvkXMAAAAAAAAAMEKUW3oAAAAAAAAAAEaWuq+I/nuPPfZYfvrTn+a2227L4sWLs3z58rS1tWX77bfPPvvsk87Ozmy33XaNiAIAAAAAAABgiBtwEf2DH/wgn/vc57Jy5cokSbVaXfexe+65J7/85S/zta99LR/72Mfy9re/faBxAAAAAAAAAAxxAyqiL7roonzxi19cVz7vuOOO2WWXXTJ27Nj09vbmvvvuy6JFi7Jy5cp8+tOfzqpVq3Lsscc2Ym4AAAAAAAAAhqi6i+j77rsvZ599dpLkRS96UT71qU9l991332Ddn/70p5x55pn5wx/+kC996Ut5+ctfnl122aX+iQEAAAAAAAAY0sp6X3jxxRenv78/u+22Wy655JKnLaGT5J/+6Z9yySWXZI899kh/f39mzZpV97AAAAAAAAAADH11F9H/9//+3xRFkRNPPDGtra3Pura1tTUf+tCHUq1W87vf/a7eSAAAAAAAAACGgbqL6O7u7iRP3Za7FmvXLVq0qN5IAAAAAAAAAIaBuovopqamJMnq1atrWr92XVEU9UYCAAAAAAAAMAzUXUTvtNNOSZLf/OY3Na1fu66jo6PeSIBhrampTGtr80Z/tbQ89YM+LS1NNa1vaqr7j3IAAAAAAIBB0VzvC1/+8pfnz3/+c84777wccMABmTp16jOuXbRoUc4777wURZGDDz643kiAYassi0yY0JayrL00bm8fU9O6SqWSpUuXp1Kp1jseAAAAAABAQ9VdRL/rXe/K5ZdfnkcffTRHHHFETjjhhLzmNa/Jdtttt27NI488kl/84hf5+te/nsceeyzt7e1597vf3ZDBAYaTsixSlmVmz56dJUuWNGzfSZMmpbOzM2VZKKIBAAAAAIAho+4i+rnPfW6+8IUv5EMf+lAee+yxnHXWWTnrrLMyduzYjB07NsuXL8/y5cuTJNVqNc3NzTn77LOzzTbbNGx4gOFm/vz56erqath+HR0d6ezsbNh+AAAAAAAAjTCgB4u+4hWvyMUXX5w999wz1Wo11Wo1y5Yty9/+9rcsW7Zs3bE99tgjM2fOdFtuAAAAAAAAgFGg7iui19pnn33y4x//OH/+859z2223pbu7O729vRk7dmy233777Lvvvtlzzz0bMSsAAAAAAAAAw8CAi+i1dt999+y+++6N2g4AAAAAAACAYWpAt+YGAAAAAAAAgP+ppiuiP/rRjyZJJk2atO73a/+5qYqiyOc///m6XgsAAAAAAADA0FdTET179uwURZEdd9xxXQG99timqFarimgAAAAAAACAEa6mInr77bdPkjzvec/b4BgAAAAAAAAA/L2aiugbb7yxpmMAAAAAAAAAUG7uwNWrV2/uSAAAAAAAAAA2o7qL6He9611597vfXXOx/Nhjj+VVr3pV3vCGN9QbCQAAAAAAAMAwUNOtuZ/ObbfdlqIo0t/fX9P6VatW5eGHH05ra2u9kQAAAAAAAAAMAxstoiuVSq6++upUKpWn/fhVV12Vrbba6ln3WLNmTW644YYkydixY+sYEwAAAAAAAIDhYqNFdFmWueuuu3LZZZetd7woiiTJJz/5yU0KPPjggzdpPQAAAAAAAADDS03PiD7ppJPyvOc9L9Vqdd2vtf7+2DP9ampqynOf+9y84Q1vyCc+8YlBOxkAAAAAAAAAtryanhE9bty4/PrXv17v2G677ZaiKHLnnXemra1tUIYDAAAAAAAAYPipqYh+Ottvv32KokhZ1nRRNQBbSFNTmebmjf9ZXZZPPXKhpaUpTU0bX9/XV0l/f2XA8wEAAAAAACNP3UX0jTfeuN6/9/b2pr29fb1jDz/8cLq7u7PPPvuse6Y0AJtPWRaZMKFtk35oqL19TE3rKpVKli5dnkqluvHFAAAAAADAqFJ3Eb3Wj3/841xwwQX5p3/6p5xzzjnrfeyXv/xlPvOZz2T77bfPKaeckte97nUDjQNgE5TlU3eumD17dpYsWdKwfSdNmpTOzs6UZaGIBgAAAAAANjCgIvozn/lMLrvsslSr1YwdO3aDj3d1daVarWbRokU56aST8tBDD+X4448fSCQAdZg/f366uroatl9HR0c6Ozsbth8AAAAAADCy1P2A55tuuinf+973Uq1W88IXvjDvf//7N1hz4okn5j//8z+zzz77pFqt5pxzzsldd901oIEBGB6amsq0tjZv9FdLS1OSp55NXcv6Wp5fDQAAAAAAbFl1XxE9c+bMJMmBBx6YCy64IC0tLRusaWtry8EHH5yXvexlec973pNbbrklF198cc4+++z6JwZgyPNsakaKp25vX9S0du0PSdT6wxKVStXXMQAAAAAwYtVdRN91110piiIf+tCHnraE/ntlWeYDH/hAbrnlltx+++31RgIwTHg2NSNBWRbZZpsxKYpN++vS+PFtNa2rVvvS07PS1zIAAAAAMCLVXUQ//vjjSZKddtqppvW77rprkqSnp6feSACGGc+mZjgry+L/ldBHJ/lzg3ffPUVxmR+qAAAAAABGrLqL6G233Tbd3d3p7u7OhAkTNrp+bQG99dZb1xsJALAF/DnJnVt6CAAAAACAYaX2h3f+Dy94wQuSJLNmzapp/Y9//OMkye67715vJAAAAAAAAADDQN1F9OGHH55qtZrLL788F1100bOunTlzZr773e+mKAq3VAUAAAAAAAAY4eq+NfdrXvOaHHTQQfntb3+bL37xi7nsssty8MEHZ6eddkpbW1tWrFiRrq6u3HTTTXnwwQdTrVYzffr0HHbYYY2cHwAAAAAAAIAhpu4iuiiKfPnLX86HP/zh/Pa3v82iRYty+eWXb7CuWq0mSfbff/+cd955KYqi/mkBAAAAAAAAGPLqLqKTZPz48bnwwgszZ86cXHXVVbn11lvz+OOPr/v4uHHjss8+++Twww/P61//eiU0AAAAAAAAwCgwoCJ6rUMOOSSHHHJIkmT16tVZunRp2traMn78+EZsDwAAAAAAAMAw0pAi+u9ttdVW2W677Rq9LQAAAAAAAADDRLk5w/r6+nLjjTduzkgAAAAAAAAANrMBXRFdqVTy05/+NDfddFOWLl2avr6+VKvVDdasWbMmy5cvz+LFi7Nq1aosWLBgQEMDAAAAAAAAMHTVXUT39/fnve99b2655ZYNPra2jC6K4lmPAQAANFpZFinLjf9/R1NTud4/N6ZSqaZSqW58IQAAAAD1F9FXXnllbr755iTJmDFjMm3atCxfvjwPPPBAOjo6su2222bp0qW5//77U61WUxRFOjs787a3va1hwwMAAPy9siyyzTZjUhS1/6/O+PFtNa2rVvvS07NSGQ0AAABQg7qL6J/97GdJkn/8x3/MRRddlG233TZz587NO9/5zuy5554599xzkyTd3d35t3/7t/zud7/LH//4x3z6059uyOAAAAD/U1kW/6+EPjrJnxu48+4pistSloUiGgAAAKAGdRfRd999d4qiyAc/+MFsu+22SZK99torzc3NufXWW9etmzx5cr7xjW/kiCOOyL333psrrrgib3/72wc+OQAAwDP6c5I7t/QQAAAAAKNWbQ9DexqPP/54kmT33Xdfd2yrrbbKzjvvnMcffzyLFi1a7/jxxx+farWan//85wMYFwAAAAAAAIChru4iequttkqStLe3r3d8p512SpLce++96x2fPn16kuS+++6rNxIAAAAAAACAYaDuInrSpElJkkceeWS94zvuuGOS5L/+67/WOz527Ngk/30lNQAAAAAAAAAjU91F9N57750k+fGPf7ze8V122SXVajVz585d7/hf/vKXJElLS0u9kQAAAAAAAAAMA3UX0W984xtTrVbzve99L2eccUb++te/Jkle+tKXpizL/OY3v8l1112XJHn00UfzxS9+MUkybdq0BowNAAAAAAAAwFBVdxH9spe9LK94xStSrVbzwx/+MF/96leTJB0dHTnkkENSqVRy4okn5oADDsjLX/7yLFiwIEVR5A1veEPDhgcAAAAAAABg6Km7iE6Sc889N+94xzvS1NSUHXbYYd3xT3ziE5k6dWqq1Wp6enrS39+farWafffdN+9+97sHPDQAAAAAAAAAQ1fzQF48ZsyYnHHGGfnwhz+cJ598ct3xyZMn58orr8zMmTMzb968NDU15cADD8yRRx6Z5uYBRQIAAAAAAAAwxNXdCl999dXp6OjIi170orS3t6e9vX29j7e3t+ef//mfBzwgAAAAAAAAAMNL3bfmPv/88/O2t70tP/jBDxo5DwAAAAAAAADDXN1FdHd3d5Lk5S9/ecOGAQAAAAAAAGD4q7uI3nrrrZMkq1evbtgwAAAAAAAAAAx/dRfRRx11VKrVar785S+nUqk0ciYAAAAAAAAAhrHmel/4vve9L0uXLs3MmTPzv/7X/8qrX/3q7Lbbbpk4cWK22mqrZ33tjBkz6o0FAAAAAAAAYIiru4jea6+9kiRFUeShhx7KxRdfXNPriqLIggUL6o0FAAAAAAAAYIiru4iuVquNnAMAAAAAAACAEaLuIvqSSy5p5BwAAAAAAAAAjBB1F9H77bdfI+cAAAAAAAAAYIQot/QAAAAAAAAAAIwsNV0RfcIJJ6Qoipx99tnZaqutBnsmgM1g92GyJwAAAAAAwPBTUxE9Z86cFEWR/v7+p/14tVrNPffckyTZbbfdGjcdwCCoVvtTFJcN2t4AAAAAAACjXd3PiP57K1asyJve9KaUZZkFCxY0YkuAQVMUTZk9e3aWLFnS0H0nTZqUzs7Ohu4JAAAAAAAwHDWkiF6rWq02cjuAQTN//vx0dXU1dM+Ojg5FNEAdyrJIWRYbXdfUVK73z42pVKqpVPz9FAAAAAC2hIYW0QAAsCnKssg224xJUdT+19Lx49tqWlet9qWnZ6UyGgAAAAC2AEU0AABbTFkW/6+EPjrJnxu48+4pistSloUiGgAAAAC2AEU0AABDwJ+T3LmlhwAAAAAAGqS2B+wBAAAAAAAAQI0U0QAAAAAAAAA0lCIaAAAAAAAAgIbapCK6KIrBmgMAAAAAAACAEaJ5UxYfeuihT1tGV6vVdb9/9atf/ax7FEWROXPmbEosAAAAAAAAAMPIJhXRDz/88LN+vFqtZtGiRc+6xlXVAAAAAAAAACNbTUX0S17yksGeAwAAAAAAAIARoqYi+tJLLx3sOQAAAAAAAAAYIcotPQAAAAAAAAAAI4siGgAAAAAAAICGUkQDAAAAAAAA0FA1PSMaAABGmrIsUpbFRtc1NZXr/XNjKpVqKpXqgGYDAAAAgOFOEQ0AwKhTlkW22WZMiqL2vw6PH99W07pqtS89PSuV0QAAAACMaopoAABGnbIs/l8JfXSSPzdw591TFJelLAtFNAAAAACjmiIaAIBR7M9J7tzSQwAAAADAiFPbg+4AAAAAAAAAoEaKaAAAAAAAAAAaShENAAAAAAAAQEMpogEAAAAAAABoqObNFfTxj388Dz/8cIqiyNixY7PzzjvnTW96U17wghdsrhEAAAAAAAAA2Aw22xXRf/jDH3L77bfntttuS7VazS9+8Yu85S1vyXXXXbe5RgAAAAAAAABgM9hsV0RXq9VUq9UURZELLrgg1Wo1n/vc5/KjH/0or33tazfXGABJksmTJw+LPQEAAAAAAIajzVZEX3vttev9e1EU+ehHP5qy9JhqYPOqVCo57rjjBm1vAAAAAACA0W6zFdFPp6mpaZPWr1mzJmeffXauvPLKLFu2LNOnT8/pp5+eXXbZ5WnX9/b25qyzzsqcOXPS19eXgw46KKeffnqe97znrVvzwx/+MJdcckm6urry3Oc+N69//etzwgknZMyYMQM6N2DoKssyCxcuzIoVKxq6b1tbW6ZNm9bQPQEAAAAAAIajLVpEb6pzzz033/nOdzJx4sRMmzYtN998c44//vhcc801aWtr22D9aaedlp///OeZMmVKWltbc91116W7uzuzZs1KURT54Q9/mNNOOy1jxozJi1/84ixYsCDf+ta38re//S2f//znt8AZAptLT09Pent7G7pne3u7IhoAAAAAACDJsLkv9qpVq3L55ZenKIrMmjUrV155Zfbdd98sWrQo119//Qbru7u7c+2112bs2LG56qqrcvXVV2eHHXbIXXfdlXnz5iVJZs6cmST53Oc+l+985zu55JJLkiSzZ8/O8uXLN9/JAQAAAAAAAIwgNV0R/dWvfrWhoSeccMImv+aee+7JsmXLsv3222fHHXdMksyYMSNz587NvHnz0tnZud76efPmpVqtZs8998zWW2+dJNlvv/3y0EMPZd68eZk+fXpOPPHELF68ODNmzEiSTJ48OclTz3h97LHHMnbs2IGcJgAAAAAAAMCoVHMRXRTFgMOq1WqKoqiriH744YeTJBMnTlx3bO3vu7u7N1i/ePHija5/xStesd5rvvvd7yZJtt9++0yZMmWTZwQAAAAAAACgxiJ6++23f9rj1Wp1XeGbJJMmTcouu+ySrbfeOqtXr05XV1ceeOCBVKvVNDc3Z//996+70F65cuVTAzf/98gtLS3rfWwg63/wgx/kG9/4RpLkAx/4wICL9+bmYXPX8yGtqWnwP49PlzHYuc+0/2jKHanv7ZbKHUrv7ZbMrWePRuxVlkVN+5TlU/9taW1tTktLtaa9+/srqVRqW/tMGnmuoyl3S/15Uc/rh+vnuFF71LP/aPtzaihnNjrXezu0ckfTucoduZlyR3buaDpXuSM3U+7IzZQ7snNH07nKHbmZozGXTVNTEX3jjTc+7fGTTz45V199dfbee++ceuqpedGLXrTBmq6urnz2s5/NL3/5y7S0tKwrezdVa2trkqSvr2/dsTVr1iRJxowZ84zr+/v7N1jf1ta23tpLLrkkn/3sZ1OtVnPkkUfmLW95S10zrlWWRSZOHDegPdh8xo9v2/iiEZApd2TnjqZzbXRuI/Zae8ePWo0d2zpoez+bkfB+DYfcTdGoGX2On9lI+Nz478rQMtzf2y2VO5rOVe7IzZQ7snNH07nKHbmZckduptyRnTuazlXuyM0cjbnUpqYi+un89Kc/XVdCX3LJJdlqq62edl1HR0e+/vWv573vfW9+/etf5+KLL86xxx67yXnbbbddkuTxxx9fd2zp0qVJ8rS30V67/rHHHttg/dpnQSfJZZddlrPOOitJctRRR+Xf//3fN3m2/6lSqeaJJ5YPeB+e+kmWwf5D5IknVqS/v7JZc58uc7TljtT3dkvlDqX3dkvmboq1Mw50r7X7zJ49O0uWLBnQTP/TpEmT0tnZ2bAZG/F5G025W+rPi00x3D/Hf7/XYPHn1NDPbHSu93Zo5Y6mc5Xra0ru8MwdTecq19eU3OGXKXdk546mc5Xra2ok5fKU8ePbaroave4ieubMmSmKIieddNIzltBrrX0u9G9/+9tcccUVdRXRu+++e8aMGZNFixalq6srHR0dufXWW5Mk06dP32D93nvvnSSZP39+ent7M2bMmMydO3e99bfccks+85nPJEmOPvronHHGGZs81zPp6/NFP1z091c2+/u1JTLljuzc0XSujc5t1F7z589PV1dXAyb6bx0dHens7GzYjCPh/RoOuZvCezv4RsLnxn9Xhpbh/t5uqdzRdK5yR26m3JGdO5rOVe7IzZQ7cjPljuzc0XSuckdu5mjMpTZ1F9H/9V//lSTZbbfdalo/bdq0JMmDDz5YV15bW1uOOuqoXHzxxTnqqKOy3XbbZcGCBdlhhx3ymte8JrfccksuvfTSTJs2Laeccko6OjpyyCGHZM6cOens7Exra2sefPDB7LPPPutK6s9//vOpVJ764ly0aFHe//73r8v75Cc/ue6qagAAAAAAAABqV3cRPXbs2KxcuTJ/+9vf8pznPGej69deJTZ+/Ph6I/PRj340LS0t+clPfpJ77703BxxwQM4444y0trZm8eLFueGGG9Z7TvUXvvCFfO5zn8u1116bnp6evPa1r80nP/nJFEWRrq6u/PnPf1639le/+tV6WR/5yEcU0QDDTFNTmebmjd8OJEnK8qnnLre0NNV0C5G+vopbvAAAAAAAQI3qLqJ33XXX9PT05Hvf+14+9alPbXT9BRdckKIosscee9Qbmebm5pxyyik55ZRTNvjY4YcfnsMPP3y9Y+PGjcuZZ56ZM888c4P1HR0dueeee+qeBYChpSyLTJjQlrKsrYheq719TE3rKpVKli5dnkqlWs94AAAAAAAwqtRdRL/tbW/Lbbfdlh/84AfZeuutc8IJJ6S1tXWDdU888UQ++9nPZs6cOSmKIu9+97sHNDAAPJ2yLFKWZWbPnp0lS5Y0dO9Jkyals7MzZVkoogEAAAAAoAZ1F9Gvf/3rM3v27PzqV7/KhRdemJkzZ+YlL3lJdtxxx7S1tWX58uX561//mjvuuCOrVq1KkrzjHe/IjBkzGjY8APxP8+fPX/c4iEbp6OhIZ2dnQ/cEAAAAAICRrO4iuiiKnHvuufnUpz6VK6+8MsuWLcuvf/3rDdZVq9U0Nzfnve99bz70oQ8NaFgAAAAAAAAAhr66i+gkGTNmTD73uc/lmGOOyTXXXJNbb7013d3deeKJJzJhwoRMmTIlL3vZy3LYYYdlp512atTMAAAAAAAAAAxhAyqi19pzzz2z5557NmIrAAAAAAAAAIa5cksPAAAAAAAAAMDI0pAroh999NH85Cc/yR133JHu7u4sW7Ys1113XZLky1/+cnbbbbcceuihjYgCAAAAAAAAYIgbcBF94YUX5vzzz8/q1auTJNVqNUVRrPv41VdfnW9961u5/PLL85WvfCUTJ04caCQAAAAAAAAAQ9iAbs199tln5+yzz86qVavS2tqavfbaa4M1K1euTLVazdy5c/N//s//SbVaHUgkAPD/NDWVaW1t3uivlpamJElLS1NN65uaPLkDAAAAAICBqfuK6D/84Q/51re+laIo8u53vzsf+tCHkiTTp09fb92cOXNyzjnn5NJLL80f/vCHXHHFFTniiCMGNjUAjHJlWWTChLaUZe2lcXv7mJrWVSqVLF26PJWKHx4DAAAAAKA+dRfRl156aZLkjW98Y0499dQkyfLlyzdYN3bs2Pzbv/1bnnjiiVx55ZW56qqrFNEAMEBlWaQsy8yePTtLlixp2L6TJk1KZ2dnyrJQRAMAAAAAULe6i+i5c+emKIocc8wxNa1/17velSuvvDJ33313vZEAwP8wf/78dHV1NWy/jo6OdHZ2Nmw/AAAAAABGp7ofAvnoo48mSXbeeeea1k+dOjVJ0tvbW28kAAAAAAAAAMNA3UX0uHHjkiSPPfZYTev/9re/JUm23nrreiMBAAAAAAAAGAbqLqL/8R//MUly/fXX17T+Jz/5SZLk+c9/fr2RAAAAAAAAAAwDdRfRhx56aKrVar72ta/lj3/847Ou/cUvfpGLL744RVHkta99bb2RAAAAAAAAAAwDzfW+8Mgjj8zMmTPzX//1X3nHO96RN77xjdltt93Wffzmm29OV1dXbrjhhtx0002pVqvZeeedc+SRRzZkcAAAAAAAAACGprqL6Obm5nzrW9/Kcccdl4ULF+anP/1pkqQoiiTJe97znnVrq9VqpkyZkgsuuCBbbbXVwCYGAAAAAAAAYEir+9bcSTJ58uRcccUVef/735/nPve5qVarG/waO3ZsjjnmmPzkJz/Jzjvv3KCxAQAAAAAAABiq6r4ieq22trZ86EMfyoc+9KHcd999efDBB9Pb25u2trZMmTIlu+22W5qamhoxKzDodh/i+wEAAAAAADAcDLiI/nu77rprdt1110ZuCWwm1Wp/iuKyQdkXAAAAAACA0aXuIvqrX/1q2tra8s53vjOtra0bXb98+fK8+MUvTlmWWbBgQb2xwCApiqbMnj07S5YsadiekyZNSmdnZ8P2AwAAAAAAYHgYUBFdFEWuueaafO1rX8uUKVNqel21Wq03Ehhk8+fPT1dXV8P26+joUEQDAAAAAACMQuVAN1iwYEGOOOKIzJ07txHzAAAAAAAAADDMDbiInjhxYnp6enLsscdm5syZjZgJAAAAAAAAgGFswEX0ZZddlj322CN9fX0588wzc/rpp6evr68RswEAQ1Bzc1Pa2lo2+qu19akngLS2Nte0vrm5aQufGQAAAAAAjVL3M6LXmjJlSi6//PJ87GMfy7XXXpsf/ehHuffee3P++edn0qRJjZgRABgiyrLIhAltKYqi5teMHdta07pqtZqenmWpVKr1jgcAAAAAwBAx4CI6SVpbW3Puuefmq1/9ar72ta/l97//fd7ylrfk/PPPzwtf+MIk2aRvWAMAQ1NZFimKIosWLcqqVasatm9ra2umTp2asiwU0QAAAAAAI0BDiui1TjjhhDz/+c/Pxz72sXR3d+ed73xn/v3f/z1vetOb0tpa29VQAMDQ193dnd7e3obt197enqlTpzZsPwAAAAAAtqwBPyP6f3rta1+bmTNnZvvtt8+qVaty6qmn5vOf/3zKskxLS0uj4wAAAAAAAAAYYhp6RfRau+++e370ox/lAx/4QO68885897vfzQMPPJDm5ub09fUNRiQj3OTJk4fFngAAAAAAAMAgFdFJss022+SSSy7JGWeckZ/85Cf55S9/mWq16lnRbLJKpZLjjjtu0PYGAAAAAAAAGmvQiugkaWlpyX/8x3/kH//xH3P22Wenv79/MOMYocqyzMKFC7NixYqG7tvW1pZp06Y1dE8AAAAAAABgAEX0JZdckiQZM2bMRtf+f//f/5d/+Id/yIUXXphqtVpvJKNYT09Pent7G7pne3u7IhoAAAAAAAAGQd1F9H777bdJ61/+8pfn5S9/eb1xAMAo19RUprm53Oi6snzqMSAtLU1patr4+r6+Svr7PaoBAAAAAKCRBvXW3AAAjVCWRSZMaEtZbrxYXqu9feN3bUmSSqWSpUuXp1Jx1xYAAAAAgEapqYh+xStekSTp6OjIpZdeut6xTVUURX75y1/W9VoAYHQqyyJlWWb27NlZsmRJw/adNGlSOjs7U5aFIhoAAAAAoIFqKqK7u7uTJK2trRsc21RFUdT1OgCA+fPnp6urq2H7dXR0pLOzs2H7AQAAAADwlJqK6De/+c1Jkuc+97kbHAMAAAAAAACAv1dTEf0f//EfNR0DAAAAAAAAgHJLDwAAAAAAAADAyKKIBgAAAAAAAKCharo193nnndfQ0BNPPLGh+wEAAAAAAAAwdNRURH/jG99IURQNC1VEAzBYJk+ePCz2BAAAAACAkaymIjpJqtXqYM4BAANWqVRy3HHHDdreAAAAAABAbWoqou++++7BngMABqwsyyxcuDArVqxo6L5tbW2ZNm1aQ/cEAAAAAICRrOYrogFgOOjp6Ulvb29D92xvb1dEAwAAAADAJii39AAAAAAAAAAAjCwNuSL6vvvuy9KlS9PX17fBs6Sr1WrWrFmTZcuW5YEHHsj111+fK664ohGxAAAAAAAAAAxBAyqif/vb3+aMM87I4sWLGzUPAAAAAAAAAMNc3UX0Aw88kA984ANZvXr1BldBP5MxY8Zk+vTp9UYCAAAAAAAAMAzUXURfeumlWbVqVZqbm3P00Udnv/32y/z58/P1r389hx56aI488sgsXbo0t9xyS6644opUKpW8+93vzkknndTI+QEAAAAAAAAYYsp6X3jLLbekKIocffTROfXUU/PqV786b33rW5Mk999/f2bMmJFDDz00Z555Zr75zW+mqakpF154Ye6+++6GDQ8AAAAAAADA0FN3Ef3II48kSQ477LB1xyZPnpyJEyfmnnvuycqVK9cdP/DAA/O2t70t/f39mTlz5gDGBQAAAAAAAGCoq7uIXls0T5kyZb3j//AP/5BKpZK//OUv6x3v7OxMktxxxx31RgIAAAAAAAAwDNRdRD/nOc9Jkixfvny94x0dHUmS++6772mPL168uN5IAAAAAAAAAIaBuovoadOmJUn+9Kc/rXd85513TrVazYIFC9Y7/uSTTyZJVq9eXW8kAAAAAAAAAMNA3UX0AQcckGq1mnPOOScPP/zwuuMveMELkiTXX399Vq1ate74NddckySZOHFivZEAAAAAAAAADAN1F9Fvf/vbM3bs2DzwwAN53etel/PPPz9JcuCBB2bKlCl55JFH8q53vSszZ87MmWeema9+9aspiiIveclLGjY8AAAAAAAAAENP3UX0xIkTc84552TMmDFZvXp1Hn300SRJc3Nz3v/+96dareauu+7KmWeemZkzZ6a/vz9NTU05/vjjGzY8AAAAAAAAAENP80BefPDBB+dnP/tZvve97+X5z3/+uuNHHnlkVq5cma985Svrng297bbb5swzz8wee+wxsIkBAAAAAAAAGNIGVEQnyZQpU3LKKadscPyYY47JW9/61tx7771pamrK85///JRl3RdgAwAAAAAAADBMDLiIfjatra3Zc889BzMCAAAAAAAAgCHGJcoAAAAAAAAANNSAroju7u7OBRdckJtvvjmPPPJIVq9evdHXFEWRBQsWDCQWAAAAAAAAgCGs7iK6q6srRx11VJYuXZpqtdrImQAAAAAAAAAYxuouos8777z09PSkLMu87nWvy95775329vaUpbt9AwAAAAAAAIxmdRfRt956a4qiyAknnJD3v//9jZwJAIAtoKmpTHPzxn+osCyLJElLS1Oamja+vq+vkv7+yoDnAwAAAACGj7qL6CeeeCJJcsQRRzRsGAAABq8QTp65FC7LIhMmtG3S3W3a28fUtK5SqWTp0uWpVDzOBQAAAABGi7qL6MmTJ6erqytFUTRyHgCAUW0wC+HkmUvhsixSlmVmz56dJUuW1LzfxkyaNCmdnZ0py0IRDQAAAACjSN1F9Ktf/ep897vfza9+9au89a1vbeRMAACj1mAVwkltpfD8+fPT1dXVsMyOjo50dnY2bD8AAAAAYHiou4j+P//n/+Taa6/Nl770pfzjP/5j9tlnn0bOBQAwqjW6EE6UwgAAAADA5lN3ET1+/Phccsklec973pN3vOMd2WeffbLHHnukvb19o7frPvHEE+uNBQAAAAAAAGCIq7uITpIf/OAHefjhh5Mkd955Z+68886aXqeIhmc3efLkIb0fAAAAAAAAPJu6i+hZs2blwgsvTFEUqVaf/hmDwKarVCo57rjjBmVfAAAAAAAA2BzqLqK///3vJ3nqSsuPfexj2XffffPc5z53o7flBp5dWZZZuHBhVqxY0bA929raMm3atIbtBwAAAAAAAM+m7iL6/vvvT1EUOeuss3LAAQc0ciYY9Xp6etLb29uw/drb2xXRAAAAAAAAbDZlvS9saWlJkuy2224NGwYAAAAAAACA4a/uInptAX3//fc3ahYAAAAAAAAARoC6i+hjjjkm1Wo1X/nKV9Lf39/ImQAAAAAAAAAYxuouog855JC8+93vzq233pq3v/3t+dnPfpaHHnooy5YtS6VSedZfAAAAAAAAAIxczfW+8F3veleSpLW1NX/84x/zkY98pKbXFUWRBQsW1BsLAAAAAAAAwBBXdxF92223NXIOAAAAAAAAAEaIuovoD3zgAymKopGzAAAAAAAAADAC1F1Ef/CDH2zkHAAAMOI1NZVpbi5rWluWT/3QZ0tLU5qaNv6avr5K+vsrA5oPAAAAABql7iL65JNPTnt7e4455pjsuuuujZwJAABGnLIsMmFCW8qytiJ6rfb2MTWtq1QqWbp0eSqVaj3jAQAAAEBD1V1E33LLLenp6cnBBx+siAYAgI0oyyJlWWb27NlZsmRJQ/eeNGlSOjs7U5aFIhoAAACAIaHuIvrJJ59MkrzoRS9q2DAw1EyePHlI7wcADD/z589PV1dXQ/fs6OhIZ2dnQ/cEAAAAgIGou4jeddddc/fdd+fuu+/OAQcc0MiZYEioVCo57rjjBmVfAAAAAAAAGMnqLqI//vGP5/jjj88nPvGJfP7zn8/+++/fyLlgiyvLMgsXLsyKFSsatmdbW1umTZvWsP0AAAAAAABgKKq7iO7q6sqb3vSm/PCHP8yxxx6b8ePHZ7fddsuECRPS2tr6jK8riiKf//zn642Fzaqnpye9vb0N26+9vV0RDQAAAAAAwIhXdxF92mmnpSiKFEWRarWaxx9/PLfddtuzvqZarSqiAQAAAAAAAEa4uovo7bffvpFzAAAAAAAAADBC1F1E33jjjY2cAwAAGCRNTWWam8uNrivLIknS0tKUpqaNr0+Svr5K+vsrA5oPAAAAgJGn7iIaAAAY+sqyyIQJbSnL2orlJGlvH1Pz2kqlkqVLl6dSqdYzHgAAAAAjVMOK6Gq1mrvvvjsPP/xwli9fnra2tkydOjXPf/7z09TU1KgYAABgE5RlkbIsM3v27CxZsqShe0+aNCmdnZ0py0IRDQAAAMB6BlxEL1u2LN/4xjcya9asPPnkkxt8fOzYsXnzm9+ck046KePGjRtoHAAAUIf58+enq6uroXt2dHSks7OzoXsCAAAAMDLUfn++p/Hwww/nLW95S7797W/niSeeSLVa3eDXsmXLctlll+Xwww/PQw891Ki5AQAAAAAAABii6r4iuq+vL+973/uycOHCJMmrXvWqvO51r8uuu+6atra29Pb25q9//Wuuvfba/OpXv8qDDz6Yf/3Xf833v//9NDd7NDUAAAAAAADASFV3I/yjH/0of/nLX9Lc3Jyzzz47/+t//a8N1uy1115505velDlz5uRf//VfM3/+/PzsZz9z+z4AgI2YPHnysNgTnk1zc1NaWjZ+E6ayLJIkra3NaWnZ+LOm16yppK+vf8DzAQAAADB46i6if/azn6UoirznPe952hL67x1yyCF5z3vek//8z//MlVdeqYgGAHgWlUolxx133KDtDZtDWRaZMKEtRVHU/JqxY1trWletVtPTsyyVysZLawAAAAC2jLqL6L/85S9JksMOO6ym9Ycddlj+8z//M/fee2+9kQAAo0JZllm4cGFWrFjR0H3b2toybdq0hu4Jz6QsixRFkUWLFmXVqlUN27e1tTVTp05NWRaKaAAAAIAhrO4iure3N0kyadKkmtavXbd06dJ6IwEARo2enp51f99qlPb2dkU0m113d3dDv5bb29szderUhu0HAAAAwOCou4ieOHFilixZkvvvvz977bXXRtfff//9SZLnPOc59UYCAAAMWU1NZZqba38mdktLU5qaNr6+r6+S/n631QcAAACGl7qL6Be96EW54YYb8t3vfjdf/vKXN7r+O9/5zrrXAYxWkydPHtL7AQD1WftM7LLceLG8Vnv7mJrWVSqVLF263K3IAQAAgGGl7iL6LW95S+bMmZOf//zn2W677fKRj3wkzc0bbtfX15cvfelL+fnPf56iKHLEEUcMaGCA4apSqeS4444blH0BgC2rLIuUZZnZs2dnyZIlDdt30qRJ6ezs9ExsAAAAYNipu4h+xStekVe96lW58cYb893vfjdXXXVVXvnKV2bXXXfN2LFjs3z58tx333355S9/mUcffTRJ8qpXvSqvfOUr6x52zZo1Ofvss3PllVdm2bJlmT59ek4//fTssssuT7u+t7c3Z511VubMmZO+vr4cdNBBOf300/O85z1vg7WnnnpqrrjiinzqU5/K29/+9rpnBHgmZVlm4cKFWbFiRcP2bGtr87xXABhC5s+fn66urobt19HRkc7OzobtBwAAALC51F1EJ8mXv/zlnHTSSfnlL3+ZJUuW5Ec/+tEGa6rVp35q/1WvelW++MUvDiQu5557br7zne9k4sSJmTZtWm6++eYcf/zxueaaa9LW1rbB+tNOOy0///nPM2XKlLS2tua6665Ld3d3Zs2alaIo1q27+OKLc8UVVwxoNoBa9PT0pLe3t2H7tbe3K6IBAAAAAIAhp/YHmD2NMWPG5Bvf+Ea+8Y1v5FWvelXa29tTrVbX/dp6663zile8It/4xjfy9a9/PWPHjq07a9WqVbn88stTFEVmzZqVK6+8Mvvuu28WLVqU66+/foP13d3dufbaazN27NhcddVVufrqq7PDDjvkrrvuyrx585Ik999/f973vvfls5/9bN1zAQAAAAAAALC+AV0RvdYrX/nKdbfcXrZsWXp7ezNu3Li0t7c3YvskyT333JNly5Zl++23z4477pgkmTFjRubOnZt58+ZtcLu6efPmpVqtZs8998zWW2+dJNlvv/3y0EMPZd68eZk+fXp+9atf5Ze//GUOPfTQPPDAA5k/f37D5gUAAAAAAAAYrRpSRP+9cePGZdy4cY3eNg8//HCSZOLEieuOrf19d3f3BusXL1680fW77757Lr744rz0pS/NMccc09B5m5sHdLE5/09T0+B/Hp8uY7Bzn2n/0ZQ7Ut/bLZU7lN7bLZU7Ut/bLZU7lN7bLZU7Ut/bLZW78fd29wYn7l5j7uAYTe/tlsodSu/tlsytZ4/N8TWxJTPljuzc0XSuckduptyRnTuaznW05Y6mc5U7cjPljuzc0XSuWzKXTdPwInqwrFy5MknS3PzfI7e0tKz3sU1dv//++w/KrGVZZOLExpfxDI7x4zd8vvhIzJQ7snNH07nKHbmZckd27rNlVqv9KYrLGp5ZrfaPqs/xaMsdTefa6Fzvl9yRkDuazlXuyM2UO7JzR9O5jrbc0XSuckduptyRnTuaznVL5lKbmoroo48+umGBRVHke9/73ia/rrW1NUnS19e37tiaNWuSPPWs6mda39/fv8H6trbB/aKsVKp54onlg5oxWjQ1lYP+h8gTT6xIf39ls+Y+XeZoyx2p7+2Wyh1K7+2Wyh2p7+2Wyh1K7+2Wyh2p7+2Wyt3Yezt79uwsWbKkYXmTJk1KZ2enr6kRnDuU3tstlVsURcaPb0tZFoOS+dT/16xItVqte4+1n5dn+rwNFrkjN3c0natcX1Nyh2fuaDrX0ZY7ms5Vrq8pucMzdzSd65bM5Snjx7fVdDV6TUX0HXfckaIo6v4GRFE89Y2RarW67vebarvttkuSPP744+uOLV26NEkyZcqUZ1z/2GOPbbB+8uTJdc2wKfr6fNEPF/39lc3+fm2JTLkjO3c0navckZspd2Tnbixz/vz56erqalheR0dHOjs7R9XneLTljqZzfabc5uYyZVk0/Ac5kv/+YY5qtdqQ823U562pqazpMUhry/mn/rnx9X19lYZ+42IofZ2M1NzRdK5yR26m3JGdO5rOdbTljqZzlTtyM+WO7NzRdK5bMpfa1FREv+QlL6k74OGHH86iRYvWFdD1FtG77757xowZk0WLFqWrqysdHR259dZbkyTTp0/fYP3ee++d5Klvavb29mbMmDGZO3fuM64HAAAYjhr9gxzJf/8wx1BSlkUmTGhLWdb+/K/29g3vnvV0KpVKli5dnkql/qu/AQAAgPXVVERfeumlm7xxtVrNd7/73Zx33nnrrqaeOnVqzjrrrE3eK3nqdtpHHXVULr744hx11FHZbrvtsmDBguywww55zWtek1tuuSWXXnpppk2bllNOOSUdHR055JBDMmfOnHR2dqa1tTUPPvhg9tlnn3UlNQAAAMNDWRYpy3LQbuVfloUiGgAAABqopiJ6U91///059dRT8/vf/37dsXe84x05+eSTM3bs2Lr3/ehHP5qWlpb85Cc/yb333psDDjggZ5xxRlpbW7N48eLccMMNedGLXrRu/Re+8IV87nOfy7XXXpuenp689rWvzSc/+cm6r8oGAEaj3YfJngCbT3NzU1paar9Fdmtrc1paait516yppK+v/xk/Pli38gcAAAAaq+FF9He+852cd955WbVqVarVajo6OnLWWWdlv/32G/Dezc3NOeWUU3LKKads8LHDDz88hx9++HrHxo0blzPPPDNnnnnmRveu56pvAGBkq1b7UxSXDdreAMPR2ltkb8oP+I4d21rz2mq1mp6eZa5OBgAAgGGuYUX0woULc+qpp+YPf/hDqtVqiqLIO9/5znzkIx9JW1tbo2IAADabomhq+C1gk/++DSxsTpMnTx4WezL0lWWRoiiyaNGirFq1qqF7t7a2ZurUqW6TDQAAACPAgIvoarWaiy66KOeff/66q6B33HHHfPazn82+++7biBkBALaYRt8CNnEbWDa/SqWS4447btD2ZnTq7u5Ob29vQ/dsb2/P1KlTG7onAAAAsGUMqIj+61//mk984hPrXQV9zDHH5CMf+UjGjBnTqBkBAIABKMsyCxcuzIoVKxq6b1tbW6ZNm9bQPQEAAAAYGeoqoqvVar797W/n/PPPz+rVq1OtVrPTTjvlrLPOchU0AAAMQT09PYNy9aoiGgAAAICns8lF9H333ZdPfOITueuuu1KtVlOWZd71rnflwx/+cFpbWwdjRgAAAAAAAACGkZqL6Gq1mm9961v52te+tu4q6J133jmf/exn8+IXv3gwZwQAAAAAAABgGKmpiL7vvvvy8Y9/PH/6059SrVbT1NSUd73rXTnppJOy1VZbDfaMAAAAsMU0NZVpbi43uq4siyRJS0tTmpo2vr6vr5L+/sqA5wMAAIChqKYi+k1velP6+vpSrVZTFEWmTZuWRx99NKeddtomBxZFkc9//vOb/DoAAADY3MqyyIQJbSnLjRfLa7W3j6lpXaVSydKly1OpVOsdDwAAAIasmoroNWvWpCiKFMVTP91933335b777tvksLVFtiIaAACA4aAsi5RlmdmzZ2fJkiUN23fSpEnp7OxMWRaKaAAAAEakmoro7bfffrDnAAAAgCFr/vz56erqath+HR0d6ezsbNh+AAAAMNTUVETfeOONgz0HAABsAbsP8f0AAAAAYHiqqYgGAICRplrtT1FcNij7AjRCU1OZ5uaNP5u6LJ96jFZLS1Oamja+vq+vkv7+yoDnAwAAgGejiAYAYFQqiqYsWrQoq1atatiera2tmTp1asP2A0avsiwyYUJbynLjxfJa7e1jalpXqVSydOlyz6YGAABgUCmiAQAYtbq7u9Pb29uw/drb2xXRQEOUZZGyLDN79uwsWbKkYftOmjQpnZ2dKctCEQ0AAMCgUkQDAADAEDV//vx0dXU1bL+Ojo50dnY2bD8AAAB4JrXf4wsAAAAAAAAAaqCIBgAAAAAAAKChFNEAAAAAAAAANJRnRAMAAABJkubmprS01PYz62VZJElaW5vT0lLd6Po1ayrp6+sf0HwAAAAMH4pogFFg8uTJQ3o/AAC2vLIsMmFCW4qi2KTXjR3bWtO6arWanp5lqVQ2XloDAAAw/CmiAUa4SqWS4447blD2BQBg5CjLIkVRZNGiRVm1alVD925tbc3UqVNTloUiGgAAYJRQRAOMcGVZZuHChVmxYkXD9mxra8u0adMath8AAENHd3d3ent7G7pne3t7pk6d2tA9AQAAGNoU0QCjQE9PT0O/mdje3q6IBgAAAAAAnlG5pQcAAAAAAAAAYGRRRAMAAAAAAADQUIpoAAAAAAAAABpKEQ0AAAAAAABAQzVv6QEAAACA0a2pqUxz88Z/Vr4siyRJS0tTmppq+9n6vr5K+vsrA5oPAACATaeIBgAAALaYsiwyYUJbyrL2m7a1t4+peW2lUsnSpctTqVTrGQ8AAIA6KaIBAACALaYsi5RlmdmzZ2fJkiUN3XvSpEnp7OxMWRaKaAAAgM1MEQ0ADBuTJ08e0vsBAPWbP39+urq6GrpnR0dHOjs7G7onAAAAtVFEAwDDQqVSyXHHHTco+wIAW95g/ICYHzoDAADYchTRAMCwUJZlFi5cmBUrVjRsz7a2tkybNq1h+wEA9RmsHzhbuzcAAACbnyIaABg2enp60tvb27D92tvbFdEAMAQMxg+cJRv/obOmpjLNzeVG9ynLIknS0tKUpqaNr+/rq6S/XwEOAACMbopoAAAAYItr9A+cJc/+Q2dlWWTChLaU5caL5f/eb0xN6yqVSpYuXZ5KpVrz3gAAACONIhoAAAAYdcqySFmWmT17dpYsWdKwfSdNmpTOzs6UZaGIBgAARjVFNAAAADBqzZ8/P11dXQ3br6OjI52dnQ3bDwAAYLiq/f5TAAAAAAAAAFADRTQAAAAAAAAADaWIBgAAAAAAAKChPCMaAAAYgXYf4vsBAAAAjGyKaAAAYESpVvtTFJcNyr4AAAAA1EYRDQAAjChF0ZTZs2dnyZIlDdtz0qRJ6ezsbNh+AAAAACOdIhoAABhx5s+fn66urobt19HRoYgGAAAA2ATllh4AAAAAAAAAgJHFFdEAAAAAm1FTU5nm5o1fG1CWRZKkpaUpTU0bX9/XV0l/f2XA8wEAADSCIhoAAABgMynLIhMmtKUsa79JXXv7mJrWVSqVLF26PJVKtd7xAAAAGkYRDQAAjDiTJ08e0vsBo1dZFinLMrNnz86SJUsatu+kSZPS2dmZsiwU0QAAwJCgiAYAAEaUSqWS4447blD2BWiU+fPnp6urq2H7dXR0pLOz81nXuCU4AACwOSmiAQCAEaUsyyxcuDArVqxo2J5tbW2ZNm1aw/YD2NzcEhwAANjcFNEAAMCI09PTk97e3obt197erogGhrUtdUvwWq/CXjtj4kpsAAAYKRTRAAwaz+cEAIChZXPeEryeq7ATV2IDAMBIoYgGYFB4PicAAIxug3UVdrLxK7EBAIAtTxENwKDwfE4AACBp/FXYybNfiQ0AAAwNimgABo3ncwIAAAAAwOi0aQ/pAQAAAAAAAICNcEU0AAAAACNKU1OZ5uaNX39RlkWSpKWlKU1NG1/f11dJf39lwPMBAMBooIgGAAAAYMQoyyITJrSlLGu/EWB7+5ia1lUqlSxdujyVSrXe8QAAYNRQRAMAAAAwYpRlkbIsM3v27CxZsqRh+06aNCmdnZ0py0IRDQAANVBEAwAAADDizJ8/P11dXQ3br6OjI52dnc+6prm5KS0ttd8SvLW1OS0tGy+116yppK+vv7ZBAQBgiFBEAwAAAMAArb0leFEUNb9m7NjWmtZVq9X09CxzJTYAAMOKIhoAAAAABqgsixRFkUWLFmXVqlUN27e1tTVTp051S3AAAIYdRTQAAAAANEh3d3d6e3sbtl97e3umTp3asP0AAGBz2fhDawAAAAAAAABgEyiiAQAAAAAAAGgot+YGAAAAgGGsqalMc/PGrzcpyyJJ0tLSlKamja/v66ukv78y4PkAABidFNEAAAAAMEyVZZEJE9pSlrXf+LC9fUxN6yqVSpYuXZ5KpVrveAAAjGKKaAAAAAAYpsqySFmWmT17dpYsWdKwfSdNmpTOzs6UZaGIBgCgLopoAAAAABjm5s+fn66urobt19HRkc7OzobtBwDA6FP7PXsAAAAAAAAAoAauiAbWmTx58pDeDwAAAAAAgOFBEQ0kSSqVSo477rhB2RcAAAAYeZqbm9LSsvEbLpZlkSRpbW1OS8vGnze9Zk0lfX39A8psdC4AAJtOEQ0kScqyzMKFC7NixYqG7dnW1pZp06Y1bD8AAAAGxp2waJSyLDJhQluKoqj5NWPHtta0rlqtpqdnWSqV9cvjejIbkQsAQH0U0cA6PT096e3tbdh+7e3timgAAIAhwp2waKSyLFIURRYtWpRVq1Y1bN/W1tZMnTo1ZVk8bRE9GJkbywUAoD6KaAAAAIBRwJ2wGAzd3d0N/6H2qVOnbtbMWnMBANg0imgAAACAUcKdsAAAgM2l3NIDAAAAAAAAADCyKKIBAAAAAAAAaCi35gYAAAAAeBbNzU1padn4NT1lWSRJWlub09JS3ej6NWsq6evrH/B8AABDkSIaAAAAAOAZlGWRCRPaUhRFza8ZO7a1pnXVajU9PctSqTx9ad3UVKa5ufYCvKWlKU1NG1/f11dJf3+lphkBAOqliAYAAACAYW7y5MlDer/hrCyLFEWRRYsWZdWqVQ3bt7W1NVOnTk1ZFk9bRK8twMuy9qcrtrePqWldpVLJ0qXLn7EABwBoBEU0AAAAAAxjlUolxx133KDsy3/r7u5Ob29vw/Zrb2/P1KlTn/HjZVmkLMvMnj07S5YsaVjupEmT0tnZ+YwFOABAoyiiAQAAgFHLVaSMBGVZZuHChVmxYkXD9mxra8u0adMath/1mz9/frq6uhq2X0dHRzo7O591jWdiAwCNoIgGAAAARiVXkTKS9PT0NPxqXUX06LQln4kNAIwsimgAAABgVHIVKcCGttQzsQGAkUcRDQAAAIxariIFeHqb+5nYAMDIo4gGAAAAAGCLa2oq09xc+7OpW1qa0tS08fV9fZX093tsAgBsbopoAAAAAAC2qLXPpi7LjRfLa7W3j6lpXaVSydKly90SHAA2M0U0AAAAAABbVFkWKcsys2fPzpIlSxq276RJk9LZ2enZ1ACwBSiiAQAAABg0kydPHhZ7AkPD/Pnz09XV1bD9Ojo60tnZ+Ywfb25uSktL7bcDb21tTktLbYX2mjWV9PX11zYoAIxAimgAAACAzazRRepQLWYrlUqOO+64QdsbYCDW3g68KIqaXzN2bGvNa6vVanp6lj3tldiehw3AaKCIBgAAANiMBqucHYrFbFmWWbhwYVasWNHQfdva2jJt2rSG7gmMPmVZpCiKLFq0KKtWrWro3q2trZk6derT3hLc87ABGC0U0QAAAACb0WCUs0O5mO3p6Ulvb29D92xvbx+y5wsMP93d3YPy59TUqVOf9mOehw3AaKGIBgAAANjMGl3OKmYBhp/N/TzsZPCeib2x52G7FTnA6KSIBgAAAACAEW4wn4n9bM/D3lK3Iq+1dF87Y9K44h2ApyiiAQAAAABghBusZ2I/2/Ow1+Zu7luR11O6J40p3rcUV50DQ5EiGgAAAACAIWHy5MlDer+RoNHPxH6252H/vc15K/LBKt2TjRfvg1UIJ89cCm+pq84TBTjw7BTRAAAADeIbp4PP5xgARq5KpZLjjjtuUPZldGp06Z48e/E+mIVw8syl8Ja46nxt7pYqwIHhQRENAADQAL5xOvh8jgFgZCvLMgsXLsyKFSsatmdbW1umTZvWsP3g2ay96newM56pnN2cV52vnWVLFOBJ7c8A9/xv2LIU0QAAAA3gG6eDz+cYAEa+np6eht822n/r2ZwG4++sydD+e+uWKMA39RngjXj+d63l99oZEwU4KKIBAAAaxDdOB5/PMQAAQ12j/86a+Hvr3xusZ4A/2/O/6ym/k8YU4DCcKaIBAAAAAAAYVhr9DPCNPf97MMrv5NkLcBjuFNEAAAAAAACwEY0uv5NnL8BhuFNEAwAAAAAAwBBU67OpN/W51IlnUzP4FNEAAAAAAMCgmjx58pDeD4aiep5NXetzqZNnfzb1YBXgyu/RRRENAMA6vjEAAABAo1UqlRx33HGDsi+MZFvq2dSDWYA/W/mdJE1NZZqbay/AW1qa0tS08fV9fZX09/szY3MbVkX0mjVrcvbZZ+fKK6/MsmXLMn369Jx++unZZZddnnZ9b29vzjrrrMyZMyd9fX056KCDcvrpp+d5z3veujW/+tWvcvbZZ2fhwoWZMmVK3ve+9+WII47YXKcEADBk+MYAAAAAg6EsyyxcuDArVqxo2J5tbW2ZNm1aw/aDoWxzP5t6sArwZyu/1+ZOmNCWstx4sbxWe/uYmtZVKpUsXbr8GQtwBsewKqLPPffcfOc738nEiRMzbdq03HzzzTn++ONzzTXXpK2tbYP1p512Wn7+859nypQpaW1tzXXXXZfu7u7MmjUrRVHk7rvvzgc+8IFUq9W88IUvzIIFC/KJT3wiz33uc/OKV7xi858gAMAW5BsDAAAADJaenp6GFmnt7e3+fxMGWaML8Gcrv5OniuiyLDN79uwsWbKkYbmTJk1KZ2fnMxbgDJ5hU0SvWrUql19+eYqiyKxZs7Ljjjvm6KOPzty5c3P99dens7NzvfXd3d259tprM3bs2Fx11VUZM2ZMXve61+Wuu+7KvHnzMn369Hzve99LX19f3v/+9+fEE0/MD3/4w5x22mm5+OKLFdEAwKjkGwMAT8+jCwAAADaP+fPnp6urq2H7dXR0bNAjsnkMmyL6nnvuybJly7L99ttnxx13TJLMmDEjc+fOzbx58zb4Apo3b16q1Wr23HPPbL311kmS/fbbLw899NC6InrevHlJkv333z9JcuCBByZJfv/736darW7Sve8BAAAYmTy6AAAAADZdUa1Wh8U16Ndee21OPPHE7LnnnrniiiuSJJdddlk+/elP55WvfGUuuOCC9dZ/+9vfzhe+8IW89rWvzfnnn58k+cIXvpBvf/vbeec735nTTz89++yzT5YvX57Zs2fnBS94QVasWJG99947SXLrrbdm4sSJdc1arVZd2t8gRfHUbUJXr16dRn+pFkWRrbbaKpX/P3tnHRdF/v/x5yIg2IlgF4qIIEoYKCdhoofdddh1Z52Jed7p2XVid51dYCvmqYBio6SNgaK0wP7+4LHzYwXU+zqzo948H497HO7sY187O/OJeWd6Oh9+tFS6H9P8r+lqNN+9e0dqaqpomgD6+vrkz59fp9c247OVe0pOXbmvrVz3sti6H9PMrPtfuqeUeUo6zcy6/4V7WbmnpNf8r+kq95T0mpl1U1NTRdfV19f/qubH7+3ayqX7Nc4XcunKfW3/C/uL/5qu3PeUslf+MpR7Kquucm2l05X72v7X7qn/wr0s97X9XnS/1rVP4d+j6SP+Kb6ZjOikpCQg42bRYGBgoHXs377/w/dkfu+XNF9XqVTkyqVkU4uJoaGhZJ/9sab3Uul+TPO/pqupWKBrXeWe+n515bq2ct3LUul+jddWLl1lnpJeE/5b97JyT0mv+V/TVe4p6TVB+3lRl7pyzI/f27WVS/drnC/k0v3e9uhf42/8X9P9r80Xyr0sva4yT32/ut/bfPEpXbnuqf/Svfxfu6f+a2ufgvh8M7947ty5AbQiIN6/fw+AkZFRju9PS0vL8n5jY+Ns35P5s7P7TAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQWFT/PNOKJLlCgBQGxsrPDa69evATAzM8vx/W/evMnyflNT02w/MyYmBoA8efJQsGBBMb++goKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCwn+Gb8YRXa1aNYyMjHj8+DEPHz4EMvo4A9SuXTvL+zW9nm/dukVcXBypqakEBARovT9zP+jM/69Vq9Zn1TVXUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUMiKSi12d3MJ+f3331m/fj1FixalRIkS3L59m9KlS+Pr60tQUBAbN26kQoUKjB49GoDBgwdz/PhxSpUqRe7cuQkPD8fW1patW7eiUqm4efMmHTt2BKBGjRrcvn2b5ORkVq1aRYMGDeQ8VQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBYVvlm8mIxrg119/pU+fPgCEhoZSr149Vq1aRe7cuXn69CknTpzgypUrwvv//PNPOnTowLt373j69CmNGzdmyZIlQrazlZUVy5Yto1KlSty8eRMTExP++OMPxQmtoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCg8AV8UxnRCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgpfP99URrSCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCwteP4ohWUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUBAVxRGtoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoCAqiiNaQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFUFEe0goKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKoKI5oBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQVRURzRCgoKCgoKCgoKCgoKEpKQkCD3V1BQUFBQUFBQUFBQUFBQUFDQOSq1Wq2W+0soKPwbrly5QlJSEg0aNJD7qygoiEZISAh37tzh1atX5MqVi+LFi1O9enXKly8v91cTnZMnT+Ls7EyuXLl0ohcfH09MTAxlypTRid5/mZkzZ9K6dWuqVq0q91f5T/Hu3Tvy588v99dQEJGYmBiSk5P5cJtesmRJmb6RNPyX1j5XV1dsbGyYN2+e3F9FQeGbQ679RUJCAnny5Mn22PXr17G2ttbp99EVarUalUrFixcvCA4OxtraGhMTE7m/lsIXkpqaSmpqKkZGRoSEhPDPP//g6OiIhYWF3F9NdNLS0nT2rJmZ/9JvLDdPnjzR2j8WL15cUr13795x9+5dLU0LCwuMjIwk1f0aePLkCUZGRhQpUkSSz/f19SU1NZVWrVpJ8vlfK/+l56DsUGwY4vBfHT8K3yb6cn8BBYV/y/Hjx4mMjMTQ0JBDhw4xbdo0nWnHxcVx8OBBzp8/z+3bt4mJiUFPT0/YMDRs2JAmTZqIvhlVq9WcO3cuW10rKysaNGiAnZ2dqJoawsPDc9StX78+pUqVElXvn3/+YceOHbx69Qo7Ozu6du1K4cKFheNz5swhICCAbdu2iaoLGdf38uXLWudqYmJC9erVqVWrFsbGxqLqvXz5ks2bN7Nz505evnyZ7XtKly5NmzZt6Nixo6gbf7nuZYBBgwZRtGhRPDw88PT0pFq1aqJrZGbSpEmkp6czfvx4zp8/j6enp6R6cvLu3TsuXLhAwYIFqVOnDklJScyZM4dLly5hYmLCwIEDJZsrANatW8f69eupWrUqrVu3pmXLlpI9sIL85/shr1+/Jl++fBgYGEimkZaWxsKFC3FxccHS0pIePXoQHBxMjRo1WLZsGUWLFpVMWw50vQbJTVBQEGPHjuXhw4dZjqlUKm7fvq2T7yHlvSzn2qchNjaWHTt2EBwcTKVKlXB1dSVXrlxYWlqKrqUhPj6eFy9eSPb5XxNyjtvt27dTs2ZNzM3NGT16NGfOnMHJyYkZM2bk6FCUgr1792JmZoajo6PONDUEBASwfft2Zs+eLcnny3F9db2/0NCjRw9Wr15NwYIFhdeio6OZPXs2fn5+3Lp1S/LvoEtevHjB0KFD6d+/P9bW1nh4ePD27VsKFCjA2rVrJZ0j5eD169fo6elRsGBBzp49y9mzZ6lfvz7Ozs6yfJ+0tDTS0tIwNDQU/bPDw8Pp06cP48ePx8LCgvbt2/P+/Xv09fVZuXIlderUEV1TTho2bEjLli3x9PTUmRP4v/Iby2mvuXjxIjt27ODChQvExsZqHStWrBgNGzakTZs21K5dWxS9lJQU9u/fz44dO7h58ybp6elax3PlyoWdnR1t2rShadOmkozdD3nz5g158uTRiZYGV1dX3NzcWLx4sSSfHxYWxtWrVwE4cOAAK1eulETna+BreA6SA7lsGOnp6ezfv5/g4OAsQd4qlYrff/9dEt2XL18yb968HHWPHz8umtbXPH6k3Nfo2n6vIA5KRrTCN8Xq1atJTk5m1apVAHTr1o0RI0ZIrpuQkMDixYvZvn07iYmJWTKUNKhUKvLkyUO3bt3o37//Fxu81Go1W7ZsYc2aNTx58uSjumXKlKFPnz60b98elUr1RboAp0+fZuXKlQQFBQnf5UNNlUqFo6Mjffr0oX79+l+seerUKQYPHixs8FUqFYULF2b+/PmCIW/w4MGcPHmSO3fufLGehrt377JmzRoOHz7M+/fvsz1XY2NjmjdvTu/evalUqdIXa65bt47FixcTHx9Pnjx5qF69OhUqVBAMXbGxsURERHD37l0hUnDQoEH07t37i3Tlupcz07x5c8LDwwWdKlWq0Lp1azw8PChWrJhoOgA3btzg4cOHzJw5EwMDA0qVKsWGDRtE1fgcdGHoevDgAd26dRMcHW3btsXAwICtW7cK79HX12fLli2SZfBMnjyZEydO8PLlS1QqFbly5cLJyYnWrVvj4uIiqlNLzvO9du0aBw4coFChQvTq1Ys3b94waNAgQkNDMTIyYsCAAfTv319UTQ1z585l1apVTJgwgdy5c+Pt7Q1kjKX27duLGpyVkpLy2e8V++FCjjXoQ3T5AKmhY8eOBAcH53j87t27ourp+l6Wa+3LTGRkJN26dePVq1dAhnHN3Nyc1atXs2rVKhwcHETTyszmzZv5888/GTp0KHZ2duTPnx89vf/vklShQgVJdF1dXXM8ZmhoSLFixWjcuDHdu3f/Yi25x+2aNWuYPXs2kydPJn/+/IwcOVLQ7d27N7/++quoeh/DwsICd3d3yYy2H/LmzRv27t3L33//TUREBICoe2WQ9/rqcn+RGQsLCypVqsSaNWsoWLAgq1atYvXq1SQmJpIvXz4CAgJE05JzzdUwcuRIfH19GT16NMnJySxcuJBKlSoRFhbGDz/8gI+PjyS6OSFlttS1a9fw8vJi+vTpVKpUSStQdcGCBTRp0kRUvfT0dP766y+2bdvGmzdvsLW1ZciQIVrBKoMHD+bUqVOSBJ0NGDAAf39/xowZw+vXr1m+fDlOTk6cP38ee3t7WZ6PpMTCwkKwiVStWhVPT09atmwpacDmf+E3lstec/PmTaZMmcKtW7dQq9Xo6+tTunRpYf/45s0bHj9+TGpqKiqVipo1azJ+/Hhq1KjxP2seP36cGTNm8OzZM9RqNSVLlsx2z/rkyRNUKhUlS5ZkzJgxNG7cWJRzvnTpEkeOHKFs2bJ06tSJFy9e8PPPP3Pnzh0MDAzw9PRk4sSJoq0HPXr0yPHY5cuXKVy4MObm5qhUKtavXy+KJsC0adPQ09Nj+/bt5MmThxEjRtCxY0fRPv/fIHVFg6/hOUgudGnDyMxvv/3G5s2bgez3rWLvlTUMHDiQ06dPZ2tvFVNXzvEj175GDvu9gngojmiFb4qmTZtSoEABrl+/jrm5OfPnz6dy5cqS6zo7OxMdHY2NjQ0uLi7UrFmTihUram18IyIiuHXrFv7+/gQGBlK4cGHOnj37Rbpt2rTh9u3bFCtWTEu3QIECwP9vVG7evMnZs2d5+PAhFhYW7N2794t0Bw0axMmTJzEwMMDBweGjupcvXyYpKQlnZ+cvNk60a9eOW7du0atXL0qUKMHff/9NeHg4uXPnxsfHh7p164r+YDNjxgy2bNlCWloa5cqVw9bWNttzvXXrFvfv30dfX59OnToxceLEL9K1srKiSZMmeHp6UqdOnRwNaOnp6QQFBXHw4EH27dsnRLr9r8h1L39IaGgofn5+HD58mLCwMC2j4o8//oi7uzv6+l9etMPCwgJ9fX1SU1OxtLRky5YtOi+fpStD14ABAzh9+jTly5cnPj6ely9fCr9p+/btCQ4OZsWKFdSpU4d169aJopkdarWay5cvc/jwYY4dOyYYjQsUKEDz5s3p2rWrKPO2XOd74cIF+vbtKxhgqlevTsGCBTl//rzwHpVKxcyZM/nxxx9F09Xg4uJCfHw8mzZtYv78+YKRomPHjqSnp3Pq1CnRtD63WoHYmbpyrUEfoqsHyMzY2tpiZGTE8uXLqVq1apZ5UMwyk3Lcy3KtfZkZMGAAZ86cwcvLi5UrV+Lm5kaDBg2YMmUKtra2bNmyRTStzGQ2in+IlNnuGt2PPfKpVCqGDx9Ov379/medr2HcNm3alOjoaFatWsWmTZs4efIkGzZsYPDgwRgbG3Ps2DHRtODjc6SmtDFIe30vXbrE33//zbFjx7SMMbVq1RL1Xv4arq+u9heZGThwIKdOncLMzAy1Ws2zZ8/Q19enffv2DB06VNRMJbnW3Mw4OTmRJ08e9uzZQ//+/YmKiuLs2bO0adOG6OhorfVBbHSdLdWjRw+uXLnClClTiIiIYN26dXTs2JFdu3ZRrVo1duzYIare6tWrs1Qp0NPT4+effxYCvqRw4GmoW7cuxYoVY+/evXTq1ImYmBhOnDhBp06diIiI4NKlS6JpnTt37rPf6+TkJJpuZq5fv46fnx9Hjx7l8ePHQEaAqpOTE56enri4uIge0KHL3/hDdFWpQg57DYClpSUmJia0bNkSFxcXrKyssuwh379/T0hICP7+/hw6dIjIyMgvmistLCyoWbOmcL/k1J4gJiaGM2fOcOjQIeEafClHjx5l+PDhwh7dwcGB9+/fC4FgkLEW9OjRg3Hjxn2xHmjvU7Nz7GheE/sZyMvLCyMjI06fPo2ZmRlTp06VJMD4U3xY0aB58+aiVzT4Gp6DNOi6gpAubRiZ0dg/GzZsSJUqVbI8W//yyy+S6Do4OJCUlMSwYcOoUqVKlmtdt25dUXTkHD9y7Gvkst8riIdSmlvhm+Lw4cOsW7cOIyMjypYty+DBg/Hz89PKKJECd3d3unTpQsWKFbM9bmJigomJCY6Ojvz0009ER0ezcePGL9Y1MTFhxIgRH31As7W1pU2bNkDGA9fatWu/WPfRo0dMnTqVFi1akC9fvo++NyUlhePHj4sSFRkeHo6dnR1jxowBoFOnTgwcOJCLFy8yePBgSUqMHDx4EC8vLzw9PXO8vhqePXvGgQMH2Lx58xcvZKdPn/6s7F89PT3s7Oyws7MTZZMk1738IZUrV2bo0KEMHTqUM2fO4O3tTXR0NP7+/vj7+2NmZsZff/31xdGnZ8+eJTAwUMhIat++Pfv27ZN8zsjMvHnzSEhI4N27d+zZswe1Wi0YulatWiWaI/rq1atYWlqye/duEhISaNq0KS9evGD27Nnkz58fV1dXAgICJC8jqcmGsrKywtramgULFhAdHU1sbCxbt25lx44dzJ49m2bNmn2RjlznO3/+fNLT02nfvj0vX77k5MmTqFQqfv75Z7p37861a9cYPHgw69atk8QR/fLlS+rWrYu5uTmBgYHUrFmTYsWKUalSJf755x9RtQoUKJCl7F12iB3TKNca9CGBgYEYGBjk+AApBWXKlKFIkSI66Tsqx70s19qXmcuXL1OrVi1Gjhwp7Cs6duzI3r17JYuK15DTWJEyLnjLli3069ePDh060LJlSwB2797Nzp07+fPPPzE0NOSXX35h165dX+SI/hrG7dOnT3FwcKB27dr8/PPP1KhRAxsbGywtLSVxABgbG5OQkJDtscxGW7Gvb0xMDHv27GHHjh1ERUVpaZiYmLBs2TKqV68uqubXcH11tb/IzF9//cWMGTPYtGkTKpUKGxsbZs6cKUkFA7nW3My8fftWcPDcuHFDqNxTpEgRIdNeKhYsWMCqVaswMTHh/v37XLt2DciobrRw4ULRs6Xu3r1LjRo16NixIz/++CMVK1Zk6tSpRERESLIW7Nixgzx58jB37lxMTU1Zt24d+/btY8GCBahUqi+afz+HhIQESpYsSXJyMnfu3KFp06ZAxjz2/v17UbX69OnzWRXapAyqsLa2xtramjFjxnDjxg0OHz7Mvn37hGfN/Pnz07lzZ4YMGSLa/k6Xv7GGT1Wq2LFjh6iVKuSw10DG/ODm5vbRZ3gDAwOsrKywsrJi8ODBnDlz5os0d+3a9VlraZEiRfD09MTT05OwsLAv0tTg4+NDWloaLVq04P379xw9ehSVSkXjxo0ZOHAgYWFhjB07lsOHD4vmiF64cCFTpkzh9evXVK9enZ9//hkjIyPUajU9e/YU9lZis3r1ahYvXsz79++xsbHhzz//ZM+ePTq11wD8+eefPH36lEePHnHjxg1SUlKEigZ//fWXKI7or+E5CLQrCIWGhnLo0CEgw95uZmYmSQUhXdowMpOQkEDNmjVZsWKFZBrZkSdPHiwtLenTp4+kOnKOHzn2NXLZ7xXEQ3FEK3xzJCQk0KRJE7p27crjx491MsF+zqR1+fJl3r17h6urKyVKlGDUqFFfrPs5WQSRkZEkJSVhYWGBtbU18+fP/2Ld/fv3f/I9CQkJpKenky9fPpo3b07z5s2/WLdAgQI8ffqUlJQUDA0NMTIywsfHBy8vLwICAvDy8hIincTC39//s6OhTU1N6du3ryilcT5nAzp8+HCioqLYvXs3AIUKFfpi3X+7AIt1L3/Iy5cv8fPzw9fXl+DgYCHat2bNmjx8+JAnT54wbdq0L87mKV68OMePH6dhw4YMHDiQq1ev6vyhRpeGrqSkJNLT08mTJw9Dhw7l0qVLgiEoLS2Nly9fStorJTk5mZMnT+Lr68uZM2dISUlBrVZjamrKjz/+SEhICKdPn2bx4sWiGIrlON/Q0FAcHBwEg2jLli0JDQ2ld+/eGBkZ4eTkRO3atSWJXIaMefLZs2dcunSJ2NhYateuTWJiIvfu3RM9W+j48eMMGjSIgIAAhg4dKoljPTvkWoM+RFcPkJkZO3YsQ4YMwdfXl3r16mWJSBcze0eOe1mutS8zKpUqi/NQrVYTExMjab89scuqfy5//PEHFStW1DIqTZgwgcDAQNatW8fmzZupVasWly9f/iKdr2Hc5smTh3fv3hESEsLLly9p27Yt6enpREVFafX4FYsDBw4wduxYrly5QvXq1Zk1a5aQkWthYYGbmxtLliwRVXP48OEcP36c1NRU1Go1enp62Nvb4+Hhgbe3N0WLFhXdCQ3yX19d7i8+zOb84YcfePDgAWfOnCE0NJQbN24IGZZiZnPKteZmplixYoSEhLB27VpSUlJwdHTk1q1bBAUFUbJkSUm1Dx06RIECBXB0dGT+/PnkzZtXyJYSuzITZGRPFixYkNjYWO7fv0/r1q0B6Rz9z549o3bt2jRq1AiAWbNmYWpqyvLly5k/f74olaA+hqmpKdevX2fOnDmkpaVRt25dTp8+TWBgoOhlKx0cHLh8+TIqlQoTExNRq7n8W2JjY7l79y63bt3i9evXwvV9+/YtK1as4M2bN0ydOlUULV3+xqBdqaJevXqfrFTRp0+fL65UIYe9Bvisctdr1qwhOjpacMw2bNjwizRzWkufPXsmBDpbWlpiZmYmHBPrOoeHh2Ntbc3cuXOBjNZmERERTJo0iWLFilGtWjW2b98uBOyIQZMmTbC3t8fb25sTJ07w+++/88cff2BrawtA4cKFJWtfU6JECSpVqkTz5s3p2bOnzu01AMHBwVSuXJnu3bvTqVMnSpUqxapVq+jUqRMhISGiaHwNz0EAf//9N0ZGRpibm7Np0yZy584tVBA6duyYJI5oXdowMtO8eXMuXrxIWlqaTteiXr164ePjw7NnzzA1NZVUS67xI8e+Ri77vYJ4KI5ohW+OQYMGCX9/WGJIyj5Sn+L3338nJCRE8myaD/nll1+4d++eZNHEOdGlSxfRdZ2dndm+fTuNGjXC29ubpk2bkjt3blasWEG/fv0ICAggKSlJlB7YGj5nEevatSuhoaFCNo3UhgINERERom16s+Pdu3csWbKEO3fuZNuXbtu2bZLo9uzZk4CAANLT01Gr1RQvXhxPT0/atm1L+fLlSUxMpE2bNqKNpTlz5vD+/XsMDAxE7cn8uejK0NWgQQMOHjxIs2bN2LVrF+3bt6d9+/ZAhuO/V69ePHz4UKigIAV169YVeo8bGBjQpEkT2rZti5OTkzBuu3Xrxo0bN75YS67zLVSoEKGhoTx69IjSpUvzxx9/cOfOHeF6PnnyhNu3b+dYvu1LqV27NkeOHKFXr16oVCpcXV0ZNWoU0dHRovcDyp8/P8uWLaNly5asXLmSdu3aSXZe/xYp1qAP0eUDpAZvb2/UarXQ2zYzYmcOyX0v54TUa1/9+vU5duwYAwYMAOD+/ft07dqVBw8e4O7uLpluTiQmJnLlypUvNpjmREhISLbZm+np6cJcHB8fL+reKiekHrdWVlacO3eOLl26oFKpaNSoEWPHjuXBgwd4eHiIrleqVCk2btzIunXrWLBgAW3atGHIkCH07dtXdC0Nfn5+qFQqDA0NGTBgAG3bthXGqKbfnlxIeX11ub/IKZtTE8SiyQQUe07+GtbcJk2asHbtWhYsWEDu3Llxd3dn8uTJJCQkaLWWkQJdZ0uVLl2aoKAgJkyYgFqtpn79+uzYsYOgoKAv6iubE6ampty8eZNbt25haWkptERITk5m3bp1zJ49W9LKK61bt2bBggVs2bKFQoUK4ebmhre3NykpKXTp0kVUrQ0bNjBz5kzWrVtHkyZNGD9+vKif/zns3bsXX19fLly4QFpaGmq1mhIlSuDp6Sk8Z44fP56jR4+K5ojW5W8M8lSqkMNe87ns37+fkJAQ0TKEs2PHjh1MnTpVuKf09fXx9vYW/RksOTlZy2lZvnx5IiIitBx2+fPnJzU1VVTdIkWKsHTpUvbu3cuMGTPo1q3bR3tHi0WHDh2Ev/Ply8fLly+5fv06efLkwcrK6pP3txjIUdEgO6R+DgLdVxAC3dowMlOlShX8/Pxo06YN9vb2GBsba81PI0aMkEQ3JCSE9PR0GjduTLly5ciTJ4+Wrpi2VrnGjxz7mq/Zfq/weShXQ+GbRdd9pL5m5Gr1LrbuL7/8wv379wkKCtL67Dx58rBmzRomT57Mnj17RNX8HOLj43n79q3OdaVm/PjxHD9+PMf+p1Jx6dIl9PX1cXV1pW3btjg7O2tF7RkbG2Nubv5Z5Qk/F80G6Pbt2/z5558EBgYCYG9vz+jRoz+7L9//gq4MXePHj+fRo0eEh4dn2WwaGRkRGhpKtWrVJNtsQ8YDnIWFBW3atKFVq1bZRvBWrVpVlMheuc63VatWLF++nCZNmnDp0iWhBBxkOO4aN25MWloaPXv2FFVXw5gxY3j27BmRkZF4eXlRtWpVTExMsLS0lKR0V758+Rg9ejQrVqzA399fcPZ/DUi99unyAVKDJssuO8Q+X7nvZbkYP348t2/f5vTp0wBERUURFRWFmZkZo0ePlkw3NDSUX3/9lfDwcJKTk7MclyqQsVy5cty7d4+RI0fi7u6OWq3m2LFjgoPa19eXa9eufbK8mVhIOW5HjRrF3bt3efnyJR07dqRmzZrs2rULU1NTyXrAQUbQSsOGDRkzZgzz58/n+PHjkmnp6+uTmppKSkoKK1asIDQ0lBYtWtCgQQPJNP8NUl1fXe4vpM78/Rhyr7nDhw9HX1+fqKgounXrhomJCVWrVqVcuXKSVwfRdbZU9+7dmTRpEsePH6dMmTI0atSICRMmkJ6eLsm5tm3blrlz59KuXTu8vb0Fx+TYsWPR09NjzZo1pKSkSPYMNmDAAAoVKkRUVBRt27alYMGC2NnZYW9vL8l9NmbMGIKDg9m4cSNt2rT54nZL/5axY8cCGXOmu7s7bdu2pUGDBsIzZ7ly5Th48KCofc91/RvLUania7XX6IolS5bQsWNHnJ2dyZUrF7du3WLx4sWiO9I0FU80aOaFzPODlPYaTQ/jCRMmsHbtWp0FFqSmpjJ16lR2795Neno6rq6u1K5dG19fX1auXClJdrAGXVc0kBNdVxACbRtGnz59JLdhaJg+fToqlYq3b99y79494XW1Wo1KpZLMNpZ5Hrx//77WManGk67Hj9z7mpz4Xu333wuKI1rhm0XXfaQUpKdw4cJs2bKFkJCQLGVrDA0N+eOPP+jZsyfHjh2T6Rt+X5w7d47cuXPTr18/SpQoobMSLmPGjOHHH3+kSJEiOb5n+vTpolc3uHv3Ll27diUxMVF47cKFC3Tp0oWtW7dKZiDRlaGrSJEibNu2LVtHVr58+Vi9ejUODg6SZltk10tLs8nXIFbGllzn+/PPP6NWqzl9+nQWB7hm3urUqZNkGXElS5Zk+/btWq8NHTr0o+PpS5Gq9PXXjhwPkCdOnJDkc7ND7ntZLkxNTTlw4AAHDx7kzp076OvrY25uTqtWrcidO7dkur///nuO2ZP29vaS6Y4YMUIo9+7r6wtkzMu5cuVi+PDhQt9XqbMddUHVqlU5c+YM8fHxwj39008/MW7cuCxl7sWmYsWKbN++neXLl/PXX39JpnP27Fn27dvHrl27uH//PocOHcLX11fYM4mdHfW18Dm9OsXaX5w8eVL4++HDh5QpU0aUz/1c5FxzDQ0Ns1TkkNJAnBldZ0t16NABMzMzoqKiaNKkCcbGxvzwww+0aNECV1dX0fW8vLyIi4tj+/btWTLdf/31V8zNzZk7dy6vXr0SXVtDp06dtP4tZaajSqViwoQJ7N+/n6dPn+rcEW1ubk7btm358ccfKVy4cLbv8fDwoEWLFqLq6vI3/hzErlTxX7LXeHl5MWLECK21R6VSkZ6ejkqlkty5kpCQQGRkJGq1Wmgpo/m35riUmJqasnr1arZs2YKfnx/m5uaS6gEsXryYHTt2ULJkSZ48eQJkrMM3btzgzz//5Pfff5dMW9cVDeRE1xWEQB4bBmQ838hRoeGPP/7Quaaux8/XsK9R+PZQqeVKpVRQ+EJcXFyIj49n06ZNzJ8/n0uXLgl9pNLT0zl16pROv4+np6cspbn/a7py8L3+xi4uLpQvX541a9ZI8vmZuXLlyme/VyqDfP/+/fH396dTp05C+Zrt27ezfft2fvjhhy/ql/Upzp49Kxi6ihcvzv79+8mbN68khi65+euvv0hJSREMl61bt6ZRo0YMGzZM3i+mI+Lj48mbN6/w79DQUF6/fi3qfR0bG8uOHTsIDg6mUqVKuLq6kitXLiwtLUXT+NrRxbz8qYwOTZl9qYiOjhb6K8qBLu7l7Phe9xd2dnYULVqUbdu24erqyqZNm0hISOCnn36iQ4cOTJw4UTLtu3fvsnr1asLCwkhLS8Pc3JyePXtSo0YNjh07Rnx8vE4c0VJc24iICPLmzYuJiYngVM+J7EqUS8Hdu3c5fvw4FStW1HIoij2GgoOD2bFjB35+fsTHxwMZRvJKlSrRuXNnunbtKorO5yL12D116hRhYWEkJydrGeIDAwOzGDfFwsnJiQoVKrBx40ZJPv9rJCAggBUrVhAcHIyDgwOtWrXi+fPnkt9PT548Yfjw4ULFl379+jF16lSuX7/O6tWrJcuES01NJSwsDD09PSpWrKiTHpKalkEfkpKSwtWrV3F0dBR9vvhYuWKVSiWpg+dT6Gp/IQUjR46kRo0a9OrVK9u2KpnR9PvVJd/rnio7xD7X7t27ExAQQOPGjfnll1+oUKECW7du5bfffhNajOnr6zN+/HjRHZUWFhaf7Tz7nq7tDz/8gIGBAYcOHcLa2ho3NzfmzZtH06ZNSUpK4sKFC5Lqb9++ncjISNq2bUvlypXZsGEDKpWK7t27S6qbGV2M2ZCQEPr06SNUEJoyZQre3t6cO3eOTZs2ZWmB+b9y7tw5ihUrhoWFBefOnfvoe52cnETR/C8j5/iRY1+TE/+lde9bRMmIVvhm0XUfKQUFMfnURgwQjIpSMXDgQGbMmMGBAwdwdnbGyMhI6/jn9N/4XLp37y77w1RAQAAWFhZMmTJFeG3q1Klcu3btXznK/xcaNGigVTazVatWkurJxYoVK1i0aJGwuUxKSuLOnTvcvXsXIyMj+vXrJ/M3lJ7MjjuA+fPnc/LkSdHu68jISLp16yZElmoyzlevXs2qVatwcHAQRUdBekdzTvj7+/Pbb7/x6NEjAMqWLcv48eN13uNeinv5a1j7nj17xm+//cadO3eylMhWqVScPXtWEt3k5GRKly5N4cKFqV69Ojdv3qRDhw7Y2dlx/PhxSR3RFhYWzJ49O9tjcvTFFpPmzZvj5ubG4sWLadasWY57DbH7+X4MCwuLbLP/xF4PbGxssLGxYcKECfj6+rJz506uXr1KaGgov/32m84d0VKydOlSlixZonNdlUr13WaZZ8eZM2cYOHAgaWlpqFQq1Go1gYGBrF+/nly5cmXJ9hQTObKlfHx8WLNmDe/evcPV1ZW6dety6dIl5syZI+pz0IfkVK3H0NAQR0dHQPz5Ys+ePcI11aD5t9yOaLHO9XMDfFUqlWgtFA4dOkRycjK9evXi0KFDH9WUwxH9vZCSkvLJ94idY7Vx40b8/f1ZuHAhLVu2xNPTkyFDhtCwYUPhXq1WrZpoTrsP+ZzzkSPTU0pevXqFg4OD1vxraGhIqVKluH79uqTae/fupXz58loVOHr06MGBAwfYsWOHKOX1v4bnINBdBaE+ffrg7u7O4sWL6dOnj2x79NTUVI4dO0ZwcDClSpWifv365M2blxIlSkimCRm9uJcsWUJAQAAADg4ODB48GFNTU0n05Bw/cuxrFL5NFEe0wjeLLvtIfc5Dd1RUlKiawCejagGh5IaYzJs375PvefHihei6cvA5GRRv3rwRXfdjGzENH5Y0Fhtra2ty587Nr7/+muWY2JtBExMTrXN58eIF6enpGBsbo6enR3x8PMbGxqL2TM6O7MquSlmKFeRzesjBjh07yJ8/P6NGjQIyejXv3LmTn376iV27dv0nHNFSM3PmTGJiYujTpw8rV64EMkqnvX//Xign9q3zNa1Bun6AvHz5MoMGDSItLU14LSoqisGDB7N27dpvMlsoM1/D2jdmzBguX76crYFPSl1TU1Nu3rzJvXv3sLa2Zs+ePVSqVImQkBDJyysGBARw7do1rUxSDUOGDBFFQ65xq1artc4pJ8Pt91wEzNjYmLZt29K2bVvCw8PZsWPHZ/UO/TfIPS/v2bMHAwMD2rdvz+bNm+nWrRvh4eFcuHBBsv5+kGGYnTt3LlOnTsXOzo58+fJpZcx+bxk8ixYtwtDQkEWLFgltGVxdXdm+fTvr16+X1BEN2Vd8efbsmSQVX9auXcuCBQswNjYWXrt//z5Hjx5l7ty5H80g/hYZMGCA8LdarSYlJYWbN29y+/ZtSceQLsmuXU92iLnWDxkyhIoVKwIwePDg784x+LVgY2Mji66zszPOzs4cPHiQxYsX06RJEzp37kz//v1zLPkuBnfv3pXss79mKlSowJUrVzh69CiAUPY3MDBQ8vL+Y8eOxd3dXXCaQcZcuWnTJsLDw0VxRMv5HJRTBaHMe7fo6GhAvApCJUuWFMZJyZIlRfnMf8uLFy/46aefCA0NBTL2NG/fvmX9+vVs2LBBsvvq0aNHdOzYkZiYGOEZJCoqilOnTrF9+3ZJAljkHD+6Qi77vYJ4KI5ohW8WXfaR0vSf/hRibxg+FlUrpe6KFStkNxTrismTJ8tyrnJtxDIzbtw4YmNjsz0mtsH2zJkzwt87d+5k+vTpLFu2jHr16gnHhwwZImmmcPXq1bly5QrLly+nbdu2wne5fv06derUkUx3zJgxXLp0Kdtj38MYysyzZ89wcHDQMhZYWVlRo0YNybPO/ytcvnyZWrVqMXLkSMER3bFjR/bu3fvdRJd+LWuQHA+QixcvJi0tjZEjR2q1EJg3bx6LFi365svDfg1r37Vr1yhQoADjx4+nRIkS6Onp6US3bdu2LFiwgJMnT9KoUSNWr15Nt27dAKhVq5ZkujllkmrGkFiOaLnGbWZj7X/VcJuZihUrMmbMGCGYddKkSVy4cOGLs//knpejo6Oxt7cXSkc2aNCAiRMn0rRpU06ePClZoNusWbNQqVRs27aNbdu2aR3TZZa9rrh37x729vZaVXzs7e2xtrbm6tWrkmrruuLL1q1bKV68OAcPHhQcD8OGDeP48eP4+fl9d47o7Hp9q9VqunXrxr1793T/hSRg7dq1wt/h4eH8/vvvNGvWDHd3d/T09PDz88Pf358FCxaIppl5DR06dKhon6ugzefaJqRagzw8PGjWrBnbt29n2bJl7Nixg969e9O7d+8sFYTkQKy1Xm6GDRvG0KFD+fnnn1GpVFy6dIlLly6hVquF4Cgx8fHxYeHChcK/jx8/TrVq1bK8r2DBgqLoyfkcJEcFoZMnT2b7ty6ZOXMmoaGhNGvWDF9fXyAje/ft27fMnj2b1atXS6Kr6Y38ww8/aNke/f39mTdvniQVMnQ9fuRALvu9gngojmiFb5YxY8bw7NkzIiMj6dOnD1WrVsXExARLS8tsH7S+hD/++EPUz/tc5Iqq9fT0lH3iPnnyJM7OzpL36ZIru0yujVhmwsLCKF68OPPnz9epMX7p0qXY2toKTmiAhg0bYmtri4+PD+3atZNEd/DgwfTu3ZsFCxZoGSD09PTo37+/JJqQ4fQoWLCgTp0euho/H1KsWDFu3rzJkydPhAetyMhIrl+/LmnUuFznKwcqlSpL9qRarSYmJkbSMpK6/I2/hjUI5HmAvHnzJjVr1tR6WOzXrx8nT57k5s2bouvpmq9hAKY9ygABAABJREFU7TMzM6NEiRL8+OOPOtUdMGAA+fLlw8LCAjs7O4YNG8bKlSspW7asVssIsdmzZw9qtRpzc3MqV66Mvr40j39fy7j9kHfv3pE/f365v4bO0VznV69efXaW4MeQ+/rmyZNHyHCwsrIiICAAZ2dnihQpImkAglxGY7n2NQUKFCAiIoKkpCThtZiYGO7duyfpPg50X/HlyZMn1KlTR8vBUKRIESpXrkxQUJCoWl8rKpWKYsWKcfjwYaZOnSr31/li6tatK/y9dOlSqlatypw5c4TX3N3d8fT0ZPXq1VrBFmLy+vVr9PT0KFiwIGfPnuXs2bPUr19fkvYqcleq0OU8deLECck1PiQ4OJjJkycTFRVF+fLlmTJlCl26dKFNmzasX7+e1atXs3nzZvr370+vXr10/v0yI9Zar0GuNcjNzQ0fHx+WL1/OnTt30NfXx9zcnL59+9KoUSPR9Xr37s22bdt49uxZltYFGvT09ITA0S9FzucguSsIjRs3DisrqyxtY/78809iY2OZMWOGJLrnzp2jevXqzJs3T3BE9+vXj8OHDxMcHCyJJsCFCxcoX748y5YtE/bPrq6uNGvW7LNKtP8v6Hr8yMG3Xh1OQXFEK3zD6LKPlFx9IuWKqh08eDBlypSRRVvDoEGDKFq0KB4eHnh6emYbmSgGX1t2WXb9j6RyLllaWqKnp4ednZ0kn58Tr1+/JiUlhdevXwtGrefPnxMSEpKldLWYODo6snz5cmbNmiWU5ilfvjwjRozQMlyIjRxOD12Nnw9p0aIFq1atomnTppQvX560tDSioqJIS0sTpZxVTsh1vnJQv359jh07JpRYvH//Pl27duXBgweS9nrV5W/8NaxBIM8DpIGBQbZlmuPj4yUNNPgv8euvv/LLL7/g4+ODs7MzRkZGWsfFKkeXHZkNWYMGDWLQoEGSaWl49eoVFhYWQn9QqZg5c6Zkn/25pKWlsXDhQlxcXLC0tKRHjx4EBwdTo0YNli1bJnrrnv8Scl9fKysrLly4wLp167Czs2PWrFncvHmToKAgihcvLpmuXEZjufY1Hh4erFu3Djc3N1QqFZcvX6ZJkybExcXRvXt3SbV1XfGlVKlSXLt2jVu3bgEZPSTPnTtHYGDgV7EHEZsPnZZpaWk8e/aMY8eOfZfBOtevX6dSpUpZXk9PT5csu//atWt4eXkxffp0KlWqRL9+/VCr1WzcuJEFCxbQpEkTUfXkrlShy3lKqj7MH2PixIkYGRnh6upKVFQUEydO5MCBAxgZGdG/f386d+7M8uXLWbhwoeyOaLGR89laUw5dF+TOnZvdu3fz7t07mjRpQv369Zk8ebJwXKVSUahQIdHmyEaNGuHo6IiDgwMODg6ULl1alM/9HOSoIBQaGsrr16+BjMDYBw8eUKVKFeF4Wloap0+f5smTJ5I5opOTk7PtX5yWliZp256UlBSKFy+uNf/q6elRvHhxnj9/LpmuLsePHKxevVqxiXzjKI5ohW+WnMq8hoWFAeJGymRX0jA7VCoVgwcPFk137969n/1eT09P0XTd3d0xMzMTNkn29vY6fyCvWLEi4eHhQu+OKlWq0Lp1azw8PChWrJhkuunp6Tx79ixbh6hUxum7d+8ybtw4QkJCsmyGpCz7N3DgQH7++WemTJmCk5NTFmO8VH3vHBwcOHPmDE2bNsXW1ha1Wk1QUBBxcXG4ublJoqmhQYMGNGjQgNjYWPT09HRieJHD6SHX+Bk2bBgPHz7kyJEjWmX+GjduLHqliszIdb5yMH78eG7fvs3p06eBjFLRUVFRmJmZMXr0aMl0dfkbfw1rEMjzAFmrVi38/f2ZNGmSkIW9a9cuQkND+eGHHyTR1CWfa8iScu3LmzcvBgYGLFy4UKscn9S6kDFe161bR3BwMFZWVjRr1oykpCRJo9SdnZ0JDw+XPJv137RfkCqafcGCBaxatQoTExPu378vtNa5ceMGCxcuZNq0aZLo/heQ+/qOGTOGPn36kDdvXpo0acLKlSu5ePEigKSBbhpiYmK0eqwnJCRw5coVOnfuLImeXPuaESNGEB0djZ+fHwBv374FMvZxw4cPl0wXdF/xxcvLi0mTJtGuXTtUKhX+/v74+/ujVquzZGx9D2TntNTcz1K2RpKLkiVLcvfuXX799Vfc3NxIT0/n8OHD3L9/P1sHtRjMmzePhIQE3r17J1Qj6dixI7t27WLVqlWiO6LlrlShy3mqR48en/U+lUrF+vXrRdF89OgR+/fvp0yZMjx8+DDLOClQoACjR4/+7pzQIO+zta73ykWKFKFIkSKcOHECY2NjSRKbNFSrVo3Tp0+zd+9eVCoVpqamglPawcFB1iAoKSoI3bt3T2gVAxAUFJRlLKvVakkDTWrXrs2FCxf47bffAHj48CEjR47k3r17WhUaxcbc3JygoCAOHjyIh4cHAPv37ycoKAhra2vJdOV41tQldnZ22NjYCGPG1tZWcUx/Y6jUUoaAKChIiIWFxUc33mJGTn9K63vTXbduHYGBgQQEBPD69WvZNkmhoaH4+flx+PBhwsLCUKlU5MqVCycnJ3788Ufc3d1FLTH5zz//MHz4cKH0X2akNE63a9fuoyVXpYpY/Nj9JeX5Pnr0iIEDB3L//n2t12vWrMmSJUtEfbiJiIggb968mJiYEBER8dH3ShVocOnSJQYNGpRtlqOUv7Oux09mIiIiuHv3Lmq1mmrVqkmaYahBzvP9GIMHD+bkyZOiztGJiYkcPHhQq+RSq1atyJ07t2ga2aGr3/hrWYM6dOjArVu3mDVrltYD5NixY7G2ts7SL1QM7t69S6dOnbSCodRqNYaGhmzbtg1LS0vRNT8XMe5lCwuLz36vVGtf06ZNiYyM1Lnu9evX6dmzJ4mJiahUKlxdXSlfvjxr1qxhwYIFNG7cWBLdw4cPM2nSJGxtbalTpw7GxsZaa3/Hjh1F0ZFrz5oZFxcX4uPj2bRpE/Pnz+fSpUscOXKEjh07kp6ezqlTpyTR/VykWA90pfk1XN+UlBSSkpIoUKAAz549w8/PjzJlykgaxBgQEMCwYcOEjJ4PkfJayrmvefDgAbdv30ZfX58qVapQtmxZSXQyM2zYMI4dO4azszOnT5+mXLlyFC1alKtXr+Lu7s6iRYtE19y6dSs+Pj5ER0cDUKJECfr16/dVOKLFni+y63ltZGREjRo18PT01FmLpuyQYm709fXVcoBAxn4qV65c/PXXX5JkjDk4OFC+fHn+/vtvfvzxR96/f4+vry89evTgzp07/yqg53N4+PCh7Nn7upqnPtw/flhGWfNvlUol2n3Uq1cvgoKCKFy4MK9fv8bOzo41a9aI8tliI8UYkmMNkmuvrCEgIIAVK1YQHByMg4MDrVq14vnz56KvCffu3ePy5ctcuXKFgIAAXr16pfW86+joSJs2bUTVzIwuKwh5eXkRGhrK8+fPMTQ0pFChQsIxPT09ChcuzJAhQ3BxcRFNMzP379+nW7duxMbGAv8/V+TNm5dNmzZJlu1/5MgRoVezxkajeb6fN28ezZo1E11T7vHzKcSYp2bMmEFgYKBgazQwMMDa2lqwEdWqVUtxTH/lKI5ohW+Whg0bCgYRtVpNSkoKsbGxGBsbY2VlxYYNG0TTGjVqlKCVmprK0aNHyZs3L7Vq1UKlUhEQEEB6ejrdu3cXNeuvc+fOWkaf4OBgVCoVFSpUQKVSERYWhpGREY0bN5asj/X9+/e1NkkvX74UNkmOjo46K9V35swZvL29iY6OFn4TMzMz/vrrr39l2P4YHh4eQsnm7JDKOG1tbU3BggVz7NUsVYTgpzZ7UpYjTE9P5/z580RERKCnp0flypWpU6eO6DrVqlXDzc2NxYsXy+Z4l8vpkRldjJ+via/pfOVwPOgCXf3Gcq5BcjxAQsacMH/+fAICAtDT08Pa2pphw4ZhY2Mjid7nIsa9/ODBA+Hvq1evMn78ePr06YO7uzt6enr4+vqydetWVq9eTc2aNUX41lmxsbHBxMSEjRs3UqJECZ1lE3Xv3p2rV68yceJEpkyZgpubG61atWLEiBFUqVKF3bt3S6Krq8DNzPtyyOhLmZ6ejrGxMXp6esTHx2NsbEyNGjVE3aNnxtramrp167J8+XIcHR2xsrJi9erV9OvXj3/++Yfr169Lovu5fMuO6K/h+spBp06duHbtGgULFiQ2NpYSJUoILWaaNm3KggULdPI9dLmviYyM5NGjR0JlpOXLl+Pq6krlypVF1fmQZ8+e0a1bNx49eqT1upmZGRs2bJDU4RYTE4OBgcFXVaJa7Pni0KFD2NvbY2JiIsrniYlUc+P169dZu3YtkZGRqFQqzM3N6dOnD+bm5qLqaLC1tcXOzo45c+ZQt25dWrduzYwZM+jevTt3794V3RFtYWHxVVQQ0iDlPLVjxw7h7xcvXrB06VJsbW1xcXFBT09PqMY1bdo0WrRo8UVamXV8fHx48OAB5cqVo3///pK2gvgSpN5f6GoNkmuvDBnnOHDgQNLS0gQnXunSpVm/fj2TJ0+mU6dOkmmHhYVx+fJlAgICuHLlCi9evJB0rzh37lxWrVrFhAkTyJ07N97e3kCGTax9+/aSVBBycXHByclJlupEz58/Z8uWLVpB/F26dJF8Pfz777+ZO3eu4ATPnz8/gwcPlqyKgpzj53MQc56Ki4vjypUrwri5ffs26enpgmPa0dFRtlanCh9HKc2t8M1y5syZLK89fPiQLl26iB49NmfOHOHv33//nUKFCnHgwAGhbMuLFy9o1aqV6P1tt27dKvzt4+PD/fv32bZtm1BO6t69e3Tu3FnSbENzc3PMzc2FKMCwsDCuXLnClStXhJJ4UvHy5Uv8/Pzw9fUlODiY9PR0ICNz9uHDhzx58oRp06axZcsWUfQePHhAmTJldG6crly5MsbGxjrv1SxX3zvIiH60t7cnb968qFQqybL81Gq1VrR0TrFXUsZkPX36VJb7StfjBzLmh2nTphEcHJxlPpS65K0c5/s5tGjR4osjbTt16oSDgwMjRoz45EOwFFm6GuT4jeVcg5o0acK0adOyfYCUygkNGYbF5cuXS/b5n8OVK1coXLiwluNBjHs5c1bdzz//jLW1tVa5V0tLSwICApgxY4aW0VFMHB0diYmJwdTUVJLPz4kbN25gb29Pp06dmDJlCpBR7tbW1pYbN25IpitVGewPybwv37lzJ9OnT2fZsmVC2bszZ84wZMgQSUvAajJlL126RGxsLLVr1yYxMZF79+7pvD+0VGNILuS4vl9DKf979+5RtWpVdu3aRf369Vm8eDGFChWiTZs22fYcFBM51tyAgAD69u1L3bp1cXJyQq1W89dff+Hj48PKlSslfVYxNTXlwIEDHDp0SMjGFrviy7lz5z77vVK1KPpcxJ4vJk+ejJmZGQcOHBDtM8VCqrnR2tqa+fPni/65OVG6dGmCgoKYMGECarWa+vXrs2PHDoKCgqhRo4boemPHjiUwMBB/f3/ZSv3qap7K3IJhwIABlC1blg0bNggB/N26daNFixYcPnxYNEd0wYIFBQfd55KWlkauXLlE0ZcbOdYgufbKAIsWLcLQ0JBFixbRt29fAFxdXdm+fTvr16+X1BFdqVIlKlWqJLT7iIqKkkwLMgKTChQogKOjI/Pnzydv3rxCBaGzZ89Koimn7dHExETSNnE50aFDBzw9PQkNDUVPT4+KFStKmq0r5/jJ7rkH4PLlyyQmJuLs7CzqWp8vXz4aNWoklByPj48nMDBQsBOtWLFCcUR/pSiOaIXvijJlyuDk5ISPj4+oPZMzs2fPHqpXr67VO6R48eKYm5uze/duxowZI4nuxo0bsbKy0uppVKVKFSH7u1+/fpLofohmkyTlRgygZ8+eQqa5Wq2mePHieHp60rZtW8qXL09iYiJt2rQRNVLQxsaGxMREnRunJ02aRO/evfH29s62h7CUhhC5sh62bdvG7NmzhXLV+fLlY9SoUaKVCNWQOdtYF5nH2SGH00OO8QMwbdo0Ll26lO0xKZ39uj7fR48ecfToUQoWLEirVq2Ii4tj3LhxXLp0CRMTE4YMGULLli0BaN68+RfrXbt2TShZr+l5mh1SBjnIdU99iK7WIMgIbtPFA+S5c+coVqwYFhYWnzSS68ow3r17d9zd3Vm8eLHwmhj3cmbCwsIoWbKkUEoRMgx4MTExPHv2TFStzLRq1YqJEyfSr18/6tevn2XNFXsd0pA7d26ePXumNRcmJyfz8OFD8uTJI4kmZOwfdY0mUylz77WGDRtia2uLj48P7dq1k0S3du3aHDlyhF69egnZLKNGjSI6Olqy65oTuhhDcqGr6/u5+wYp9xdpaWkUKVIEfX19rKysuH79Ot26dcPGxkbSYCi51twFCxaQmJgoZIy+f/+edu3asWXLFhYuXCjpfLJkyRIqVqyY5f5Zu3YtcXFxohgU+/Tp81l7JamCG3S9f8xMqVKlBEeSLpDzXDU8ffqUJUuWEBAQAGSUzh48eLBkz2Tdu3dn0qRJHD9+nDJlytCoUSMmTJhAeno6ffr0EV2vV69eQmZd5gpC58+fZ9++fZJXEJJrnrp48SLVqlXTqiKnr69PwYIF/1WwyadwdnamQ4cOtGnThnLlyn30vU+ePOHgwYNs3bpV9jYgYiDXtZVrrwwZgWf29vY0aNBAeM3e3h5ra2uuXr0qisa8efOyvKZSqdDT0yNv3rxUqlQJJyenT95vX8rLly+pW7cu5ubmBAYGUrNmTYoVK0alSpX4559/RNP5GoLpP9Zf3tDQkOLFi+Pu7i5KafCUlBRy5cpFrly5SElJEV7PbFvVvC6FQ1rO8ZPdcw9kBHiEhYVx8eJFSZ+D8ubNS8OGDWnYsCEASUlJkmkpfBmKI1rhm+XDfq/p6ek8ffqU8+fPC5lLUqCnp8fVq1e5ePEidevWBcDf359r165JOrknJSVx8+ZNwsPDqVixIpCxWbp586bozoecNgm5cuUSNkidOnWSdIN06dIl9PX1cXV1pW3btjg7O2s9bBgbG2Nubi7qtZ46dSqdOnXCy8uLBg0aYGxsrHVcKiPmkydPSE1NZefOnezcuVPrmJRZHnJlPRw9elSI0MuXLx9qtZp3794xZcoUihQpgru7uyS6GgPXhxugtWvXEh8fz5AhQyTRlcPpIcf4Abh58yZ58+blt99+o0qVKpJnC2nQ5fneunWL7t27k5iYCGSUb86fPz+nT58GMiKYf/31VwoVKqT1IPsl/PHHH5iZmQl/y4Euf+OvYQ0ChIojGzdulLQ3s6Y09eLFiz9qJBd7PXB1df3o8XPnzuHq6opKpeL48eOi6WqoVKkSd+/epWfPnjRq1Ij09HSOHz/Ow4cPsbKyEl1Pg6bdypkzZ7KN+pdqrXdxcWHv3r20bt0ayCgZ6uHhQXR0tOjBkzkZQrJDCkOIpnTx69evKVy4MJBRFi8kJET06kGZGTNmDM+ePSMyMhIvLy+qVq2KiYkJlpaWkmRCyD2GPociRYoI64dY6Or6Hj16VPj7U6X8paJUqVJcu3aNK1euYGNjw/bt2ylQoADBwcGSOsDl2sfduXOH2rVrC5UqDA0N8fb2JiQkRJKAzpiYGMFYuGTJEurXr6/VliEtLY39+/cTGRkpiiO6ZMmSX/wZ/yty7B8z07BhQ1avXk3Lli2xtbUlf/78QuamSqXSqk7ypch9rpDhCO/YsSMxMTHCWI2KiuLUqVNs375dktZXHTp0wMzMjKioKJo0aYKxsTE//PADLVq0+OR68aV8WEEoPDxccExLFTQj1zxVtGhRgoODWbhwIW5ubqSnp+Pn58f169cpXbq0aDpNmzZl5cqVrFixgkqVKmFjY0OFChUoUKAAaWlpvHr1imfPnnHlyhUePHiAnp6eVua2LhF7rZfr2upyr/whBQoUICIiQsuBFRMTw71794S9zpeyYsWKT9puK1euzPr167USn8RGVxWEvoZg+suXL2fpKa/R1Ly2d+9epk2b9sXj18bGRmgL+LGWWlLZeHU9ftasWcPmzZuFf2ueezRofDRitj0ZOXJktq9r7ESVK1emRYsWWr3IFb4ulB7RCt8sOZV0UKvV1K5dW2tCFJOpU6eydetWVCoVxsbGqNVqkpKSUKvV9O7dW7KM6JEjR3Lo0CH09fWpUKECarWaiIgI0tPTad26Nb///rtoWp/q86JSqTAyMmLLli2SlRhcsmQJ7dq1+2jEcmxsLPnz58/SU/l/ZcOGDfz+++85boSkyvRr1KgRT58+xdjYmEKFCmXRl6qMTbdu3QgICKB///4MHz6clJQUZs2axZYtW7Czs5Ms66Ft27bcvXuXOXPmCOVtfX19GTVqFNWrVxe1HGtmA5eLiwv169dn+vTpwvG0tDSGDRtGZGSkaJGuH6Lpz5k56y8zUtxXcowfyCj9U7p0adasWSPaZ34Oujzf7t27c+XKFerXr8/r16+5ffu20E+pS5cuBAcHM23aNGrUqCFJZO/q1auF6Gxdosvf+GtYgwAaNGhA6dKltdpkSEHmnlmfisYWcz2wtLTM0r5AQ+aHc5VKJck8dfHiRQYMGEBycrIwN6rVavLly8eaNWsku8e7d+/+0eNSrX3v3r2jb9++WQwxVlZWrFixQlSDU7Vq1QRDyMfGiFSGkH79+nHmzBkKFiyIra0tarWaoKAg4uLihO+lK2JiYiQz5sk5hmJiYggICODJkyckJSVhbGxM2bJlsbe3J1++fKJqfYgc17d169YYGRllmY87depEWlqaZKX8//77byZNmsTo0aOpX78+bdu2FTLEGjZsyIoVKyTRlWsfV7t2bUqWLJmlfHPz5s159uwZQUFBomkBbNmyRdiX57RPhgzHk5iZjnIg9/4x894q8++s+d3FnKPkPleA4cOH4+fnxw8//EDbtm2BjLYC/v7+tGjRgrlz50qimxNhYWFale2k4smTJ1r/LlCggGRrglzz1MaNG5kxY0aW+UKtVvPHH38IThgxuHv3LsuXL+fYsWOkpqZmGTsARkZGNGvWjN69e1OlShXRtAGio6O5evUqz549IykpCSMjI8zMzLC1tZW0v61c11aXe+UPmTlzJuvWraNYsWK8evWK/Pnzo1ariYuLo3v37owfP/6LNcaOHZvtOpeenk58fDxBQUG8fv2ajh07CokbUvDzzz9z5MgR4bvs3buXRYsWcfLkSVG19+zZg5mZGXXq1GHPnj0ffa+Y4zYz/v7+jBw5kgYNGghl+/fu3cv58+eZMGECycnJzJw5kwoVKrB///4v0rKwsMDNzY0lS5Z80p4hRXCfrsfP27dvcXd3JzY2Nltnv4YOHTqI1hv8c+xERYsWZevWrZK3plD431Ac0QrfLNlNQEZGRtSoUYNp06ZJ1jdZs1Dt2LGD1NRUICNavGfPnvz888/o60tTaODNmzf8+uuvWXpjN2/enN9++03UbOycNgmaDdKJEye4dOkSLi4u/PXXX6LpZsbR0REzMzP27t0ryednR/369Xn16hXlypWjePHiWTaJUhmnbW1tKV26NLt27ZK0Z8iH1K5dGwsLiyxBG926dSMkJIQrV65IomtjY4O1tXWW37N79+4EBwdz/fp10bS+BgOXHE4POcYPwMGDB5k0aRLr1q3TqaNUl+dbu3ZtqlSpwtatW0lLS6Np06Y8evSIoKAgoYpCz549uXHjhugGW4BatWpRoUIFdu3aJfpnfwxd/sZfwxoEGdUS5s6dS/v27bGzsyNfvnxafd/k7h/5pQQHBzNmzBgiIyOpXr06kydPpmjRoqjVatzc3Khfv77w0ChF5hBklM3cvHkzkZGR6OnpUblyZbp16yapoUluLl68KPQ/rVKlilBdR0zkNoQ8evSIgQMHcv/+fa3Xa9asyZIlS4TsCCmIi4tjw4YNBAQEoFKpsLe3p1u3bpIY4uUYQ+np6fzxxx/CGvQhhoaG9OvXj8GDB4uilx1yXF9ra2tKliyJn5+fVin/Zs2a8ezZM1H3jh9y6tQpSpQogaWlJXv27GHNmjWUKVMGb29v0bPNNci1jxswYAD+/v44OTlRv359UlNTOXPmDFeuXKFBgwaiO97T0tJo2bIl4eHhORoxCxYsyMiRI+nQoYOo2rpG7v1jTg4QDWJW3JH7XCFjDBUuXFhrzkhPT6dZs2a8efMmx1ZCX0J0dDQzZswgLCyM5ORk4X5OSEggNjZWksCvoKAgZs+ejY+PDwULFhQCoDWUK1eOAwcOSFKlSq55CsDPz4+1a9cSGRmJSqXC3Nyc/v37S5ZhHx8fz8WLFwkJCeHVq1cAFCtWDCsrK+zs7ESvjBgfH8/EiRM5cuRIjsFuzZs3Z/r06Vmq+ImBXNc2ISGBPHny6GSv/CEpKSmMGTMGPz8/rdcbN27MrFmzJPmdPyQmJoZmzZphbGwsVJCQgidPnjB8+HChglC/fv2YOnUq169fZ/Xq1ZJkkz558gQjI6Msz3hRUVEkJiZ+8nnlf6Vnz57ExMRoBdip1WpatGhB2bJl8fHxoXv37ly/fp3g4OAv0nr8+DHGxsYUKVKEx48ff/S9UjxbyzF+QkNDef78OT/99BO1atXSql6jUqkoUqSIqAE6S5YsyfZ1jZ3o3LlzhIWF4eHhwZw5c0TTVRAPpTS3wjeLLvu9pqSkCA7C3LlzM3nyZEaPHi2U4ClXrhy5c+eW9DsUKlSIFStWEB4eTkREhGCwlSLK51PRaN26dcPd3V2yB0fIiN6VyqmfEykpKdSoUUOyrIqccHFxISQkRMvBoSvevn2b5bWYmJhsjZtikSdPHp4/f056eroQQZuWlkZ0dLTohuKOHTuyadOmTxq4hg0bJqpuZuTozynH+IGMzCF9fX06duyIsbGx1kO5SqXKtgyuGOjyfI2MjIiOjiYuLo58+fIxceJEgoKChL57cXFxREZGSlYOyMLCgufPn2utS7pAl7/x17AGAcyaNQuVSsW2bduyZOxI2TYhM8nJyUREREjSm9rGxoZ9+/YxZ84cNm3aRP/+/fH29hbaFxgbG4v+kLxo0SIcHR2xtbXF0NAQMzMzRo0aJarGp/gwW+hDpCrdOnPmTFq3bk3dunUlN6idOHFCMJidOHFCUq3sKF26NPv27eP8+fNae9Y6depIqvv69Wu6dOlCZGSksN5fuHCB/fv3s3nzZtFKK2qQYwwtWbKEjRs3Csad2NhY0tLSqF69Ou/evePBgwcsWbKEggUL0q1bN1G1NchxfeUq5Q8ZlYs0tG7dWrKsnczItY8bPXo0V69e5ezZs0KAplqtpkCBAowePVp0vVy5cnHo0CHS0tKwsrLC1dWVRYsWCcf19PQkK9n5sVLJUpTTl3v/KEWP4JyQ+1wh47n+w8ByPT09ihcvzvPnzyXR/O233zh27Fi2x8qXLy+63r179/Dy8iIpKYm7d+/i6OgIoPW8GxUVxaFDhyQpy6rLeeqff/6hVq1awl64WbNmQmU1XZA3b17c3Nxwc3PTid6MGTPw8/MjT5481KhRg8KFC6Ovr09qaioxMTHcunWLQ4cOYWRkxG+//Sa6vlxrUMuWLbGxsWHevHk6cT5nxtDQkPnz5zN8+HAtJ17ZsmV19h2KFCmClZWVJIEymSlZsiTbt2/Xem3o0KGSBgK7urpmWzVnwoQJPHjwIEvClVhcvXo1S4stlUpFgQIFhLYFenp6wvr0JWTe80sVxP0x5Bg/lStXpnLlymzYsIHChQtjbm4uqd6n2ikmJibi7u4uaq9zBXFRHNEK3yzjxo3DyspK6IOj4c8//yQ2NpYZM2aIplW7dm1sbGxwcHDAwcGBWrVqkSdPHsmitjQ0atQIR0dH7O3tcXBwoEyZMlSsWFHoES0Xenp6VKxYUbJ+QwBt2rRh8eLF9OvXL9tMNCl6OLZq1Qp/f3/hoVlX2NracuLECVq3bk2dOnWy9BAeMWKEJLr29vb4+/vTt29frayHiIgIyaKJAerVq4evry8DBgwQHor37NnDw4cPs/Rv/lLkNHBlJj09nQMHDmhlaLVo0ULUUlaZkWP8QEYPHg0JCQkkJCQI/5byd9bl+TZp0oQtW7bg4uLCyZMncXZ2xtnZGUDov/PmzRt69eolmmZmzM3NuXr1Kg0bNqR69epaPf4AyUoNynVPZYcu1iCQp5dkfHw8kyZNol27dtSoUYPWrVvz6NEjzMzMWL9+vejBZ7lz52bChAm4ubkxbtw4Ro4cyeHDh0XVyMyyZctYtmwZBgYGWFtb4+DgoOWY1gWfcj5IFWCwbt061q9fT9WqVWndujUtW7aUzOCT2fhhaGhI8eLFs32fn5+faIaSbt26CXtWjbG4QYMGku4nPmTevHlERERgaWlJq1atANi3bx937txh/vz5opWFy4yux9CuXbvIly8fGzZswNLSkqdPn9KuXTssLS2ZNm0aISEhdO/enY0bN4rqiJb7+v76668MGDBA6HkK/1/K39vbWzLd9+/fs3XrVu7cuZNtv/Xvbc2tVKmSELhx9+5d1Go11apVo0uXLh8t0folqFQq9PX1tYLM4+LiSElJkdQo/rFsJSn2rHLsH8+dO0exYsWwsLD4ZOUnMau8yL1Xhoz9clBQEAcPHsTDwwOA/fv3ExQUJFnVpsuXL2NqasqSJUvo0qULS5cuJSYmhvHjxwslYcVk9erVJCYm4uDgoOUs01Tj2Lx5M2vWrOHw4cOSOKJ1OU/16tULQ0NDYe+oscnpMihXlxw/fpySJUuyb9++bPurxsXF0apVK44ePSqJI1quNSg+Pp4XL15I8tnZkd26bmpqqrXead6jq3stJiYmiz1QCnRRQWjLli3CnlitVhMQEECPHj2E4+np6Vy7dk2Sig0aTExMCA4OZu7cuTRu3Bi1Ws3Ro0e5du0apUqVwt/fn8uXL0viON6+fTs1a9bE3Nyc0aNHc+bMGZycnJgxY4boVRRA9+MnMw4ODpw6dQp/f/8sFUECAwOzBD5IhbGxMdWqVZPcTqTwv6OU5lb4pggNDeX169dARrnb2rVr88svvwjH09LSmDZtGk+ePMnSF+FLmDFjBoGBgcIDeWYDqpSb4EGDBhEUFMSbN29QqVSYmpoKRlt7e3vZeh6kp6fj5uZGYmKiZBO8HH11Fy5cyNq1a8mXLx82NjZZNoBSGZt02bMrM2FhYXTp0kXo6aHRLFCgAJs3b5Ysmu3x48e0a9eO169fZ9HdtWuXLPf1u3fvsn3IE4OkpCS8vLwICgrS6hdZu3ZtVq1aJcmDhhzjB7Qd0dnh4OAgia4uzzcxMZGJEydy6dKlLEa9xMREbG1tadiwIfPnzydv3ryi6Wr4WACUlPOFXPdUduhiDZKLyZMn8/fffzNmzBggI4MpX758xMXF0bx5c+bNmyeZdnx8PH/88Qc7d+4EEEo7i8nbt2+5cuWK8N/du3dJT0/X2b4Kch5DuXPnpmjRoqL24c7M5MmTOXHiBC9fvkSlUpErVy6cnJxo3bo1Li4ukhlh3NzcWLt2rdbaeuvWLX7//XeCgoJEG7s//vgj9+/f19onOzo64uDgoLNAAycnJwwMDDh8+LBQqSgpKYmmTZvy/v17zp8/L6m+LsZQ7dq1qVGjBuvWrRNe69GjByEhIUIGTY8ePQgODv7iEoOZ+Rqu79OnT9myZYtWFrbUpfy9vb2F6/mh2eS/subqkgMHDuDj40N4eDiurq64uLhw//59YU0Uk8z7B7VaTUpKCtevX2fTpk0sWLCAevXqiaonx/7RwsICd3d3Fi9enKVkc2bEDsKSe68McOTIEX7++WdUKpWwHiQnJwMZQUtSZNPWqFGDOnXqsHLlSjp16kSnTp3w9PSkR48ePHnyRPQsezc3N+Lj4zl9+rRwjplbc6SkpNCwYUP09fUlaUGly3nq+PHjWntHXdrk5MDW1hZTU1MOHTqUbeB6eno6Hh4ePHv2TJIKUXKtQZs3b+bPP/9k6NCh2NnZZelBLXb7xWrVqn3W+8SaI7NzfEPGGhQfH8/u3buZM2cONjY2kjrusqsgpFKpqFChgqgVhJ4/f06TJk1ITEz8aA9hzTolBTt37mTixInZ9pSfMmUK8fHxzJ49m59++olff/1VNN01a9Ywe/ZsJk+eTP78+Rk5ciSQ8Tv37t1bVC0Nuh4/mVm6dOlHn3l0uW9t1qwZr169+qRtUkEeFEe0wjeFr6+vMIHntClSq9WUKlVKklKEcXFxXLlyhcuXLxMQEMDt27e1DKiOjo5aPRHE4t69e0IGQEBAAK9evcrimG7Tpo1oejk9qKSnp5OQkMDevXvx9/fH2dkZHx8f0XQzI0dfXbkcPLrs2fUh0dHRbNmyhTt37ugk60HD8+fP8fHxISAgAD09Paytrenbt6+kTui4uDiWLl2abd+u0NBQUYNXMjNr1izWrl1LiRIlcHd3B+DYsWNCLxUpSh3KMX7kRI7zTU5OzrYlQ2RkpFb5vZiYGJKSkkTLrl28ePFH54tPlSv6X9HlbyznGhQREfHZ75XiYa5hw4aoVCr+/vtvxo8fz61btzhz5gyenp68e/dOsvL2mfH39+fw4cNUr15dK6NS7HsZMublwMBAYV9169YtUlNTMTQ0lKzna+bWE5mdD8OHD2fWrFk0bNhQEl2N3uXLlzl8+DDHjh0TnNIFChSgefPmdO3alcqVK4uqaWFhQfHixYWeb/Pnz2ffvn2kp6eLvl9+9+6dVqDBnTt3sg00kKqEs7W1Nba2tqxfv17r9Z49e3Lt2jVRHbMfQ8ox1L17d65evcqoUaMwNzfn+vXrLF68mMqVK7N//35mzZrFhg0bqFixolY/PDGQ+/rKQe3atUlKSsLT05MSJUpkcQh8D2vuvHnzqFy5Mq1atfposJNKpWL48OGi6X7Ivn37BIezSqXC1dUVU1NTNm/ezNChQxk0aJBk2pkZNmwYiYmJrFy5UpLP1+X+0cXFBScnJ6ZNm4aLi8tH3ytFEJZce2UNf//9N3PnziU2NhaA/PnzM3jwYMkysRs1asT79+/ZtWsXq1at4sGDB0ybNo3OnTsTExMj+rOmjY0NdnZ2rF69Wnht2LBh2NjY4OXlBYCXlxeXL1/mxo0bomqDfM+bcXFxBAQEaNnk0tLSMDAwwMbG5rt4zh0yZAgnTpygTJky1K5dm0KFCmFgYEBqaiqxsbEEBATw4MEDmjZtyvz580XXl+va6jJgRqP3uYjRGvJzHd9//vknLVu2/GK9nPD29mbHjh3ZVhDq0KGDqBWELl68yKNHj/D29sbS0pLOnTsLx/T09ChSpAj16tWTtNWlv78/y5cvJywsjLS0NMzNzfnpp59wd3dn165dPHv2jAEDBojaKrFp06ZER0ezatUqNm3axMmTJ9mwYQODBw/G2Ng4xzYOX4Kux09m3NzceP78Oe3bt2fz5s1069aN8PBwLly4wIgRI+jXr58oOjnZajR2oj179rBlyxYcHR2zPA8qfB0ojmiFbw4vLy9CQ0N5/vw5hoaGWr2F9PT0KFy4MEOGDPnkw5YYxMfHExgYKBhkbt26Jckm/0PCwsK0HNMvXrwQ1Un6sQUMMgyphoaGbN68mRo1aoimKze6dPB82OdIV/wvfWXT0tJk6V8tNuPGjWPPnj0AWSIy8+XLR0BAgCS6jRo1Ijk5GT8/PwoWLAhkRKG2aNECQ0NDTp8+LYmuXAQEBLBixQqCg4NxcHCgVatWPH/+PEsbhf8KgwcP5tSpU6Jt/J88eYKRkVGWDLCoqCgSExMlbxmhC+Rcg3QdGf8hNWrUoH79+ixdulRoy+Hj40O/fv24dOmSzhxp2SH2vZwdiYmJBAUFcfnyZUkdHtkxduxYQkJChHVCSuLj4zl69CgLFiwgOjpaeF1fX5/Zs2eLmqk1ffp0Nm/eTP78+UlLSyMhIYH8+fPTv39/evToIek+JD4+noCAAGG/evPmTdLS0iQL7GvVqhWRkZGsXbuW2rVrAxlrUu/evalUqRJ79+6VRPdzEWMM3bhxg27duglZNWq1mly5cvHXX3/h7OxMo0aNePHiBQsWLJC8l6Wur68cODk5YW5uztq1a+X+KpKROYMyp/VX6ipNAB4eHrx48YKtW7fSvHlz3Nzc+OWXX+jSpQv58+fXSb97tVpNt27duH37NlevXpVc72OIMV/k5Aj+2pByf5GSkkJoaKjQ1kXKNW/mzJmsW7eOIUOGUKNGDfr37y+Mp2rVqrF7925R9erUqUPx4sU/GnTk4eHB27dvJeu/+jWgKf2qsclt3bpV7q/0xbx48YLBgwcLQZkfVs0DqF69OitWrKBo0aKyfEcp+NRzrBjO4Mx8rEXDh4hRuvlT52dmZkafPn0kt5vIUUFoz549mJmZfVfBih9D09pz5cqVODk5Ub58eTZt2iTpM72ux09matSogb29PWvWrKFJkyaMHz8eZ2dnmjZtSqFChdi2bZsoOp9jq1GpVKxYsULUliMK4qH0iFb45tBEfGaO8JWLvHnz0rBhQyF7JikpSSe6lSpVolKlSkI0WVRUlKifn100sqZ/V/78+alUqRI9evSgevXqoup+iC766u7atUvovy1FNntOZO5zpMvShs7OznTo0IHWrVtrRaJnx5MnTzh48CBbt27l1KlTon6P69evs27dOiIjI8mVKxeVK1fGy8tL9EywzJw5c4bChQszZcoURo4cyfTp03n69CmLFi2SLKMF4OXLl9jZ2QlOaIDChQtTtWpVAgMDJdPVdV9qyPiNBw4cSFpamuDsDwwMZP369eTKlYtOnTpJpi3H+X4uYsb8ubq64ubmlqV81YQJE3jw4IGkhiZd/cZyrkGfe62kiuMsUqQIERERHDx4kISEBBwcHIiOjubGjRuUKFFCEs1/g5jn/TGnYNWqVbl8+TI1a9YUfV38sCxeeno6T58+5erVqzx9+lRUrcwkJydz8uRJfH19OXPmDCkpKajVakxNTfnxxx8JCQnh9OnTLF68WFRHtLe3N6VKlWL27Nmo1Wrs7e1ZvHixViCnVOTNm1erN2hiYqKkzp2uXbsyefJkunfvTrly5YCMPbJardZpH/uP8aVjqEaNGhw4cIANGzbw8OFDTE1N6dSpk2CYGTx4MDY2NpK1V8mMrq+vHHTv3p1Vq1YRFBRErVq1dKqtqzXX09MTKysr4W8p+iN/DlFRUTg6OlKxYkXhtcqVK1O9enVJgkU/3JOmpaXx4sULoqOjMTMzE13vf+FL54t69erh7u6Oh4cH9erV+yr2xDkhxb5KrVZz6dIl4Xnz3bt32Nvbi66jYeTIkahUKmrUqIGzszNt27Zl165dFCxYkPHjx4uuZ2FhweXLl7l48SJ169bNcvz06dOEhoZKmqAhx/PXkydPsrymsY/16NGD9+/fS9Lu5NGjR9y4cUMo8Z4ZsXtwFy9enL///pugoCCCgoJ4+vQpSUlJ5M6dmxIlSlCzZk0cHBwkna/luLZSOsqyIyfnclxcHCkpKaK3/sguoCrzM66xsbGoejnx9u1bbG1ttQKVjIyMKFeunGRVAlu3bs29e/fw8/PTGkOaoEYxM/vPnTtHsWLFsLCw+GRbAqmclXny5OHdu3eEhITw8uVL2rZtS3p6OlFRUVp2QTHR9fjJTJ48eXjz5g0AVlZWBAQE4OzsTJEiRUT9XjntFTLbiby8vBQn9FeMkhGt8F0SFhZGpUqVJPlsV1fXHI8ZGhpSrFgxGjdu/MlyNv+WHj16fFS3ePHiuLu76yQTXBfoqq+uJvLf1NRUcAjrov+2XH2Opk6dyvbt21Gr1VSqVAkbGxsqVKhAgQIFSEtL49WrVzx79owrV67w4MED9PT0aN++PVOmTBHtO/j6+jJq1CjUarXWRkJfX58lS5bwww8/iKaVGSsrK+rVq8eKFSto27YtP/30Ey1atKBTp068ffsWX19fSXSbNm3Kixcv2LNnD2XLlgUyStK1adOGEiVK4OfnJ7qmHH2pAdq1a0dYWBiLFi2ib9++uLm50bNnT/r164epqakk5wryne/nMHjwYE6ePPlFWURbtmzh8OHDQEYf7sKFC2s5GdLT07l27RoGBgaSOQG+5t/4e2LixIns3LkTlUqFnp4ehw8f5rfffuPMmTP06dNHaE8iB2Lcy5n5VOY7ZBjiVq1aRZUqVUTRhI9HUltYWEiWEV2rVi0SExOF9d7V1ZW2bdvi5OQk/A7dunXjxo0bXxwln11fuWPHjnHu3Dn09fUZPHiwYFyTwkE7bty4HI9p9qyurq6fXYHg3zB//nxWr15NamoqkFEtqWvXrkyYMEF0rX+L2GNILuS8vrrm6dOneHp68vbtW/Lmzau11qlUKsnaJci15gYEBGBtbS1Ln1UXFxeSk5PZv38/9evXx83NjREjRtC+fXsKFy4sen/dnDKH9PT0mDZtGu3atRNV798ixnyReZ0tWrQozZs3x8PDA2tra7G+pihIMTc+evSIwYMHc+/ePa3XbWxsWLx4McWLFxdN62O8fv0aIyMj4uPjKVasmKifffToUYYNG0aePHn46aefqFu3LkWKFCE6OpozZ86wZcsWkpOTWbFiBQ0aNBBVG+Sbpz61f9TX1+eHH35gxowZFChQQBTNv//+m2nTpmm1d8nMt76uf8h/9bnvwIED+Pj4EB4ejqurKy4uLty/f19oG/GlvHjx4l/PPbGxsaI7LuWoILR9+/aP2hTFrvCp6TstV7nqvn37cu7cOfLkyUNCQgJbt25ly5YtHDhwAA8PD2bPni2Jrlx4eXlx4cIFxowZQ+7cuZk1axa2trZcvHiR4sWL66S9mMK3gZIRrfDNEh0dzYwZM7Lt9xobGyvZgvL48eMsZX0zExERQUBAAImJiaL1QYAM58PHdCEju2jatGm0b9/+i7SOHj2Km5vbv4p2PHv2rKgPOAsXLiQwMDBLX93AwEAWL14sWl/dvXv3Cv2F/P392bt3r1b/bc1/Yjum3dzchJKJH/Y5WrFiBcuWLZOkz9HkyZPp2LEjy5cv59ixY4SGhmZb6snIyAhPT0969+4tqgMAYNGiRaSnp+Ph4YG7uzt6enocO3aM/fv3M2fOHMkc0YUKFSIsLIykpCSsrKw4deoUjRs35u3bt9lGVotFmzZtmDdvHj/++KOw0Q8MDBR6DkqBrsbPh9y7dw97e3utucDe3h5ra2tJs6TkOl9d4ebmxuzZs0lMTESlUvH69WsuX76c5X2NGjWS7Dvo8jf+GtYguRg9ejQJCQlERkby008/UaZMGcqVK4ebm5tOq3bogt69e7Njxw4hywLg0qVLpKen88MPP/D48WOuX7/O3LlzWb58uWi6Oe2jSpYsKWrQ1YckJCRgYWFBmzZtaNWqVbYZyVWrVhUlU3ny5Mk5Gl1SU1NZtGiR8G8pHNF79uwR9DMbMDP/e9myZSxcuFD08tHDhw8X+ihrMtO+hmoCumTt2rXcvHmTuXPnSvL5clzfQ4cOYW9vj4mJiSif97n8+uuvQn/ZuLg44uLihGNSZqLJta8ZPHgwZmZmspSx79ChAwsWLMDZ2RmVSoW/vz8nT55ErVbTu3dv0fX++OOPLK8ZGRlhZWUleUCyrpg3bx5HjhzhzJkzvHz5ko0bN7Jx40bKli1Ly5Yt8fDw+GSFrG+VadOmERISQoECBahVqxYqlYqgoCCCg4OZOnUqS5YsEV2zWrVqWaoWFS5cmM6dO/P8+XPRy8s3btyYrl27snnzZpYuXcrSpUu1jmvGjlT7Y7nmKWtra8LCwoiPjyd//vwAvHv3Dn19fQoVKsTbt285fvw4hQoVYvr06aJorl27ltTUVAoXLkyZMmXQ15fflC7lWi/Xtf1YAJuBgYGQ9DNixAjRA6b27dsnOJw16/vt27eF9jaDBg36Yo1GjRrRtGlT2rRpg6OjY47t71JTU7l69SoHDx5k//79ottR5KggtH79elQqFQ0bNuT06dM0btyYiIgI7t+/L6rdHDKe6QoXLiz8LQejRo3i7t27vHz5ko4dO1KzZk127dqFqakpv/zyiySaco6fMWPG0KdPH/LmzUuTJk1YuXIlFy9eBPhi/0Rmbt68KVTx+VykTFRU+PcoGdEK3yxDhw7l2LFj2R4rX768kD0mNkFBQfTr148OHTrQsmVLAHbv3s3OnTv5888/MTQ05JdffsHExIQjR46Ipuvv78/IkSNp0KABLVq0ADKcqOfPn2fChAkkJyczc+ZMKlSowP79+79Iy9LSkhIlStCqVSvc3NyoXr16FodAWloawcHBXLhwAV9fXyIjI0V1/svVVzc0NJRLly4JPe9evnyJSqXCzMyMkydPSqL5IbrqcxQfH8/FixcJCQnh1atXABQrVgwrKyvs7OzIkyePJLrW1tZUrlw5S5+sNm3aEBYWJlkP1HHjxrF3714GDBhAlSpVGD58OMbGxiQlJVG+fHnJsnXT0tL49ddfOXTokNbrLi4uLFq0SJIHWbnGj5OTE4aGhvj6+lKzZk3c3NyYNm2aoOvv7y+J7tfch1usLI+LFy/y6NEjvL29sbS0FFozQEb2TpEiRahXr55kvQB1+Rt/DWvQ10RKSoos2WkfInbG0uzZs9m1axcHDhwQsgOePHmCp6cnvXr1YtCgQXh4ePD8+fNsAy/+V7LrB2dsbCx6+b0PuXXrluQtTTT8m6o8Yga7adi3bx/Tp0/H3NycJk2aABmOxNDQUAYNGsTr169Zt24dVlZW/P3336LrR0REEBERQa5cuahUqRKlS5cWXeN/QVcZ0VLryHF97ezsMDMz+2gvVCmwtrbG2NiY8ePHU6JEiSxrkYODgyS6cu1r3N3dKViwIDt37pTk8z+GWq1m7ty5bNy4USjbmTt3brp06cLo0aO/6rLSUiDmOE5OTsbf35/Dhw/j7+9PfHw8kOFssbKyomXLlh+tviY1UsxZNWvWJG/evBw4cEBY32NiYmjVqhVxcXGilZ/du3cvly5dAjKCdEqWLImjo6NwPD09nWPHjgnVi6Tg4MGDrFu3jlu3bqFWq9HT06NmzZr06tWLxo0bS6IJ8s1T+/btw9vbm8WLFwutIY4dO8bIkSOZN28ednZ2gp1OrCw8W1tbTExM2Lt3r87KJ38KKdd6ua5t/fr1effuXZY2OplRqVT07t2bX3/9VVRtDw8PXrx4wdatW2nevDlubm788ssvdOnShfz584sSSLJq1SqWLl1KUlIS+fPnx9LSMtvqhNeuXSMpKQljY2MGDhxI3759RThDbXRdQcjGxgZra2s2btyIi4sLv/32G7Vr16ZZs2aULVuWdevWSaIrJ2q1mvj4ePLlywdkPJ+UKFFCMjurnOMHMmwWSUlJFChQgGfPnuHn50eZMmVEDTq2sLDA1taWNm3a4OrqmuPze3R0NBcvXuTgwYNcuHDhu7UTfYvIH8aloPA/cvnyZUxNTVmyZAldunRh6dKlxMTEMH78eMFRKwV//PEHFStW1Jq4J0yYQGBgIOvWrWPz5s3UqlVLVKMpwJo1azAzM9PqneHq6kqLFi04fvw4Pj4+HD58mOvXr3+x1rZt25gyZQrLly9nxYoVGBgYUKZMGfLnz096ejovX77k1atXQn/DGjVqiO4slauvbuXKlalcuTJdu3YFMjYLly9f5sqVK5JpytXnKG/evFqZ2brC2tpaMIBoUKvVJCUlYWtrK5nuhAkTiI+Px9zcnMaNG1OvXj0uXLiAgYEBw4cPl0w3V65czJ07l969ews9lmxsbKhZs6ZkmnKNHw8PD9atW4ebmxsqlYrLly/TpEkT4uLiRG9XkBm5zleXaHq/6evrY2ZmRp06dXSqr8vf+GtYg+QkICCAa9euaVV70SBlP3tds3PnTiwtLbVK1JUsWZLq1auzefNmBg0aRKlSpYiIiBBVN6d+cFKjKyc0SONc/jccP36cIkWKsHHjRiHYqkuXLjRt2pR79+4xe/Zsrl69Knovszdv3jBmzBjOnDmj9Xrz5s2ZNm0aefPmFVXva6VFixaSlsWW4/qWKlWK9PR00T7vc6lQoQKFChXixx9/1KmuXPuaNm3asHjxYvr164ednR358uXTytiSste6SqVi1KhRDB48mNDQUAwMDChbtqyoBtuPlZX/8Lv8/vvvounKTe7cuWncuDGNGzcmJSWFs2fP4uvri6+vLzdu3ODWrVuyOqKloFChQpQvX17LSF2kSBEqVKjA06dPRdOxsbFh4sSJpKamolKpePr0abYtPjI7p8XGw8MDDw8P3r9/T2xsLIUKFdJJxq5c89SiRYuwtbUVnNCQEURTs2ZN5syZw+HDh7G0tOT8+fOiadaqVYu4uLivxgkN0q71cl3bWbNmMXjwYCZNmoSHhweQkfSzcOFC/vrrL4oXL07Xrl05fPiw6I60qKgoHB0dqVixovBa5cqVqV69OgEBAaJo9OnTB09PT9atW8fevXv5559/+Oeff7K8z8zMjLZt29K5c2eKFi0qivaH6LqCkIGBgeD0trKy4urVq9SrV4+yZcty69YtyXTHjRuHlZWVYN/V8OeffxIbG8uMGTMk005MTCQ8PFywWUDG2AKEamBiItf4SUhIIE+ePBgaGgrB83nz5pWkms38+fP5448/8Pb2ZvLkyZQqVYoKFSpo2Ymio6N5+PAhAKampsyZM0f076Hwv6M4ohW+WRISErC2tsbKygpLS0tevXqFp6cnu3btYt++fZKVsAwJCaFChQpZXk9PT+fGjRtARqap2OXarl69iqWlpdZrKpWKAgUKCCUv9PT0RDHSWFtbs3v3bs6cOcPu3bu5ePEiYWFhWu8pVqwY9erVo3379pIsoqVKleL69es8ePBAq69ucHCwZEbknJzNFStWxMLCgsePH0ui7eLiovM+R7rm3Llzwt9NmjRh5syZjBkzBjc3N96/f8/Bgwd5+fIl3t7ekn2HfPnyaZUjXb16Nbdv38bU1FTSTLglS5ZQsWJFmjdvrlVGZu3atcTFxUkyV8kxfgBGjBhBdHS0kF3+9u1bIKN0nJTOfrnOVw5at27No0eP8PPzEzKGMiNVuXdd/sZfwxokF0uXLs22XKRarUalUn1XjmjNvik0NJTKlSsDcP/+fSGgLjIykuvXrwtlF7+ETp06ffZ7t23b9sV6Xxvp6ekcOHBACIayt7enRYsWkmUYnj17lho1amgZwg0NDSlVqpTQ5zVPnjy8f/9eVN3p06fj7++Pvr4+FSpUQKVSER4ejq+vL4aGhtmW4v0ead68uaSfL8f1bdiwIatXr6Zly5bY2tqSP39+wUGqUqkk22NMnDiRAQMGsHLlSho0aJCl6kh2z4RiINe+ZuHChahUKs6cOZNtJqGUjmjIeL7fv38/kZGR5MqVC3Nzc5o3by5aVRBNWfmcSsprjn1vjujMXLt2jbNnzwr2A8i5ZcW3zNChQ5k+fToXL14UgjmPHDlCcHAw06ZNE02nQoUKzJgxg/DwcJYvX0758uVp2rSpcFxTtUiKeXnt2rW0a9dO2CdpSq/mREpKCrt37/5Xe6KPIdc89fLlS9LS0khOThbm5KSkJB48eMDr16+Ji4sjKipK1GpCffv2ZdiwYUyZMoV69ephbGysZb9xcnISTetzkXKtl+va/vHHH1hbW9OlSxfhtV69enHkyBH+/PNP9uzZg7W1tdb8JRbFixfnzp07QqVAgPDwcK5fvy6qg7ZYsWKMGjVKKN189+7dLNUJpS4jPG7cOKpXr063bt2E0usgrXO2SpUqXLt2jd27d1OrVi18fHx4+vQply9fFr0HdmhoKK9fvwYy1v0HDx5otRtMS0vj9OnTPHnyRDJH9IkTJxg7dqxWSxcNUvWmlmP8bN68mfnz57Np0yYsLCyE1xcsWMDZs2eZOnWqsAaLQbNmzXB1dWXXrl3s3r2bW7duCU5nDfr6+tSqVYv27duLuodUEAfFEa3wzVKsWDHu3LlDdHQ0NWrUwM/Pj7p16/Lo0SNiYmIk0y1Xrhz37t1j5MiRuLu7o1arOXbsmOCg9vX15dq1a1qRdGJgYmJCcHAwc+fOpXHjxqjVao4ePcq1a9coVaoU/v7+XL58WdSNYcOGDWnYsCFqtZpnz54J0VvFixfH1NRUNJ3skKOvbvfu3T8ZQFCtWjX++usvUc9fjj5HuqZPnz5Zftv9+/drlZFXq9V4eXlJsil78OABcXFxVKxYESMjIyBjA1i9enVCQ0MZMGAAO3bsEE0vJiaGpKQkIMMRXb9+fa0M6LS0NMHQJoUjWo7xAxmG6Pnz5zN8+HBu376Nvr4+VapUER5gpUKu85WDv//+m2nTppGWlpbtcanOV47fWM41SC727NmDWq3G3NycypUrfxU96KTCzc2NPXv24OnpSfny5VGr1URFRZGWlkbLli05f/48r1+/5ocffvhirc8thyllz1e5SEpKwsvLi6CgIMHZsGPHDrZv386qVauENVFMChYsSFBQENu2bRPKgh45coTAwECKFi1KQEAAly9f/qjB/H/h1KlT5M+fn23btglGvPDwcDp16sTRo0e/K0f01atXCQoK4unTpyQnJ2NkZISZmRm1a9fGxsZGUm05ru/KlSuBjGCV0NBQ4XWN01AqR3Tv3r1JT09n3rx5zJs3T+uYVIZEkG9fI2dg1507d+jbt6+WEwAy9tErVqwQ5dl6wIABwt/x8fFs2bKF0qVL4+TkJPSljomJkTR4Ug6CgoLw9fXl8OHDwu+rVqvJmzcv7u7uQhnjb50PnYHv37/np59+wtjYmPT0dJKTk8mXL5+w9xALTcUEAwMDIfhYFyxatIhFixbh6uqKm5sbNWvW1Nofq9Vqob3JhQsXOHnyJCkpKaI5ouWap2rVqsU///yDh4cHDRo0QK1Wc+7cOaKjo7Gzs8PPz4/IyEhR18JevXqhUqnYvn0727dv1zom5VogF3Jd24cPH5Kamiqs7ZARTBkTE8PTp09JS0vj5cuXkjwfdejQgQULFuDs7CysBydPnhR6rUuBhYWFlvNOSrJzzlatWlU4LrVzdsSIEfTt25ekpCSaN2/OsmXLhDYgmjYvYqGx12sICgrKUvVDrVZLGlSxaNEi3r17h56eHoULF9bJM72ux8+pU6eYPn06KpWKgIAArXv59OnTPH78mP79+7Np0yasra1F0YQMm2Pnzp3p3Lkzb968ITQ0VLATFStWDEtLS8nKnyt8Od+vdUvhu6dJkyasW7eOHTt24OTkRP/+/QVjpZTl6EaMGMGQIUOEclaQsYjlypWL4cOHCyUkxd6gDRgwgIkTJ7Jq1SpWrVqldaxv376EhoaiVqsl6QOk6ZFsZmYm+mfnhJeXFyEhIRw6dEgrm9bFxQUvLy9JNJs1a8bZs2dJTEwUsrM0peGqVq3K8+fPuX37NrNmzdIqkf6ldO3aFW9vb5YvX56lz9GUKVOEPkdy9rn9UkqWLCmLbkxMDD///LNQTil//vxMmTJFMBCsWLGCJUuWiJ6VdfjwYa2ggQsXLuDq6prlfVKVWtLl+ElJSSFXrlzkypVL6EdjamqqZQjRvC5VNKIc8wVklNU3MjLKklEfFRVFYmIiFhYW1KlTR9RKBmvXriU1NZXChQtTpkwZnTkq5fqNQZ41SC5evXqFhYWFkLWlK+S4lydMmEBCQgJHjhzRciy5uLjg7e3N6tWrKV26tCilw74GB2RAQADW1tY6j8peuHAhgYGBlChRQsh6OHbsGIGBgSxevJjRo0eLrtm1a1fmzZvH1KlTmTp1qvC6Wq2mU6dO3Lx5k/fv39OwYUNRdY2NjalSpYpWJknFihWpVq0a4eHhomp9iK7G0IsXLxgyZIhQOSBzJqNmzrC1tWXJkiWSVXuR4/p6enrKEiiiKSOZHVJmkcq15spZ1v+3337j5cuXlCtXTnAMnzt3jsjISKZOncr69eu/WOOXX34R/h4zZgwlSpRg//79QlbliBEjaN68ueROJV3NF7NmzcLPz4/o6Ggg457V19fHycmJVq1a4erqmiXLX2x0ub/QGKI/JCEhQfj73bt3ordQ0zBkyBBSU1NJSkrCyMiIkJAQ/vnnHxwdHSVxNh08eJCZM2dy6NAhDh06BICRkRH58uUjPT2dN2/eCNXyVCoVjRs3FrUcq1zzlLe3N15eXjx8+JAtW7YIrxcrVoxJkyZx9OhR9PX1tQJPvhS5bBlyIde1tbCw4MaNG3Tr1g0XFxfUajUnT57kwYMHVKtWjX379nHnzh1JxlP//v2Ji4tj48aNpKam8v79e3Lnzk2XLl0YOHCg6Hq6Rm7nrJ2dHceOHSMtLQ0TExPWr1/Pzp07KV26dJay2V9K8+bN2bVrF6GhoTx//hxDQ0MKFSokHNc4h6WsNBYVFYWpqSk7duzQakMlJboeP2vWrAEy/BFt27bVOrZjxw5mzpzJ/v37BZurFBQqVAg7OztJPltBGlTq77EOj8J/gvfv3zNv3jzq1KmDs7MzEyZMYNeuXRQsWJClS5dKOhmFhISwatUqwsLCSEtLw9zcnJ49e1KjRg2OHTtGfHy8JJGC/v7+LF++XEv3p59+wt3dnV27dvHs2TMGDBig1cvrW+fmzZs666u7Zs0alixZwtatW4XowBs3btC9e3fGjRtH69atad68OQkJCVy4cEE0XVdXV0qXLp3FwNKjRw+eP3/O4cOH6d+/P+fPn+fmzZui6f4XGDt2LHv37tV6zcjIiCNHjvDbb79x/Phx1Go11apVy7af1/+KJqMvPDxcqwRgZgoWLMjIkSPp0KGDaLofoovxU61aNdzc3Fi8ePFHg4B0ES2uy/kCtM89M926dePBgwdZ+pSKga2tLSYmJuzdu1eWPmW6/o3/a/zyyy+Eh4drVYvQBXLcyxoePnxIaGiosK8pV64c8P/9pr4XHB0dMTMzy7ImSU2jRo1ITk7Gz89PKH33+vVrWrRogaGhoWRBbps3b2bFihWCA8TExISffvqJXr16sW7dOu7du8eECRNE7du8YsUKVq5cyfbt24XsyevXr9OzZ0+GDBkiqfFUV2No2LBhHD16lNKlS+Pg4CBkWaSmphITE0NgYCAPHjygSZMmLFy4UBTN7JDj+v4XkWPNjY2NJSoqSqunYUJCAleuXGHUqFGS6VpbW1OsWDF8fX2FSg1JSUm0aNGCly9fEhwcLKqera0tNWrUYMOGDVqvd+3albt370raB1VX80VmY7OtrS2tWrWiWbNmWgZ5qdHl/uLfOJgdHBxE09UQHh5Onz59GDduHNWqVaN58+a8f/8efX19Vq5cSZ06dUTXBAgLC2P37t2cP3+e+/fvC1WT9PX1sbS0pH79+rRt25bSpUtLoi/HPJWcnMyBAwcICwsjNTWVKlWq4OHhgbGxMXfv3iVPnjySV+SSks8t9a1SqbJtoyAWur62V69excvLi4SEBK3WCcbGxqxcuZKAgAAWLFjAjBkzsji+xCIxMVFIRilbtux39Szi5eX1Wc5ZFxcXyb5DcnIyUVFR6OnpUbZsWckDdF1cXHBychK1JcPn0KlTJwwMDHQa4Kfr8VO7dm1KlCghJOh9SHp6Oo0bNyYlJUVSW4LCt4XiiFb4rnj9+jVGRkbEx8eLXu5P4fvHyckJc3Nz1q5dq/V6r169ePDgASdPnpTEIWxjY0PhwoU5cuSIVp+jpk2b8vr1a86fP0+7du14/vw5QUFBoulChrFpx44dBAcHU6lSJVxdXcmVK1eWfuRfSnZZszkh5mbU2dmZ+Ph41q5dS/ny5Vm7di1//fUXlpaW3L59G5VKRe/evRk+fDgGBgai6ULGpi8tLQ0rKytcXV21+lPr6el9NyVgLSwscHNzY8mSJZ+Mrrx7966OvpV0bNmyhcOHDwMZBq/ChQtjbm4uHE9PT+fatWsYGBhw9epV0fW9vLyIi4vLUhZO4fvg8OHDTJo0CVtbW+rUqZOlB52Y/Tnlvpczk926IKVh4unTpyxZskSoluHg4MDgwYMlLfnu7u5OwYIFhTJ0uqJGjRrY2dll2dv07t2bwMBAIbNWKuLj40lLSxM1mz4zH5YYvXHjBiqViooVK5KamkpkZCT58uXDzc1N9J6vcowhW1tbTE1NOXDgQLYVMVJTU2nVqhVPnz6VfNyC9Nc3M7ras/6XOX78OL/88kuO7T/u3LkjmXaTJk0oUaJEFsdw586deffuHQcPHhRVz8nJidevXzN16lTc3NxIT0/Hz8+PGTNmULRoUdGdO3LMF82bN6dVq1Z4eHhI5oTMjq9pf6FLBgwYgL+/P2PGjOH169csX74cJycnzp8/j729fZZ7Wyo0beoKFy783Txvvnjx4l9nFcbGxoree/bx48cEBQWhUqmoVauWZJnSVlZWpKWlfbLyhkqlknReloOXL1+yadMmwsPDSU1NxdzcnM6dO2NqasqlS5fQ09OTpI2Eq6srTk5OWpVeIOPZ++nTpzk6275F5HDOpqamsmDBAjZs2CBUIzQ0NKRXr14MGzbsu0qmArh9+za9e/emT58+2faVr1ChgiS6uhw/muCUj1Ws6dmzJ1evXpX8eVPh20FxRCt8s+QUXdu5c2eeP3/OiRMnRNNq2bIlPXr0oHnz5p+M7E9JSeH48eOsX79edEfB3bt3uXv3LsnJyVmOiWmc/hrIroyxBkNDQ4oVK0bjxo3p3r27aJq2trYYGRlx6NAhoXzYq1ev8PDwICkpiSNHjtCxY0fi4uK4cuWKaLq9e/fmn3/+oXTp0lp9jh49eoSdnR2tWrXC29sbGxsbUe+pyMhIunXrJvQKc3V1xdzcnNWrV7Nq1SpRI8Xlypq1trbG0dFR6C2YkJBArVq1UKlUFClShNmzZ1OvXj3R9D5FfHw8enp6kmey6nL8PH78GGNjY4oUKcLjx48/+l6pSj3p8nyfP39OkyZNSExMzDHbHTKcTh+uT2Lwzz//MGzYMJo3b57tQ83nRtD/W+SYk/+LWFhYfNRoKKaxSe57+e7du4wbN46QkJAs2lJWUHj06BEdO3YkJiZGS7dYsWJs375dsnlq2bJlLF68GCcnJ+zs7MiXL5+W0UWqfVzTpk158eIFe/bsEbKDIiMjadOmDSVKlMDPz08S3ZiYGMLCwrLds4o5T31ueTkpjLVyjCEHBwfy5cvHgQMHsn0miY+Pp2XLlsTHx3Pp0iVRNLNDV9dXgy73rF9DJppca27r1q25c+cO5ubm3L9/HxsbGx4/fszLly/p1KkTU6ZMEVUvcxDS6dOnGTlyJJMnT8bd3Z3U1FT27dvHwoULWbJkCQ0aNBBVe+HChSxbtizLmqtWqxk5ciR9+/YVVU/uNVeXyHWuI0eOpEaNGvTq1UurBG12zJ07VzRdDXXr1qVYsWLs3buXTp06ERMTw4kTJ+jUqRMRERGSzskaNL1BX7x4QXBwMNbW1piYmEiipct5ysrKiqZNm9KmTRscHR1zdFqlpqZy9epVDh48yP79+0UNdJgzZw5r164Vyp3nypULLy8vSXrKP3jwgEGDBhEWFkbfvn0/ui5Jkd3/X3nuO378uBAov2TJkiw93tPT09m2bRvx8fGiV+X4WgkLC9NqcSMWf/zxBxs2bECtVgtZ5prM3d69e4vaNiAzL1++ZN68eQQHB5OcnJylpc3x48cl0ZW7UqAuaNmyJU+fPuXIkSPZthx8+fIlTZs2pXjx4pI9byp8eyg9ohW+Kfbu3Sts4NVqNbdu3WLcuHHC8fT0dEJCQoTNoViULFkSb29vpk+fTr169bC2tqZChQoUKFCAtLQ0Xr16xbNnz7hy5QpBQUEkJyeL3vdu/fr1zJw5M8fjunBEx8XFkZKSIlnPucw8fvz4ow+uERERBAQEkJiYSL9+/UTRdHJy4tixYzRp0oRatWqhVqu5evUqcXFxODs7c+rUKZ4+fSr6Zl+OPkcAM2fOJCYmhj59+giOWlNTU96/f8+CBQu0vsuXolarhWv5sfgnsWOjUlJStHqfaTa9efLkYdu2bZQpU0ZUvZzYunUrK1as4NmzZwCYmZkxcOBA2rdvL4meLsdPZqeN5u+4uDjy5csnaEkV8alBl+drYmLCX3/9xaNHj/D29sbS0pLOnTsLx/X09ChSpIhkAQ69evVCpVKxffv2LIEpUj7UyDEnf4gu1yC5kCLCPyfkvpcnTpyYo2NQyjjZuXPn8urVK3744QehLNnOnTvx9/dn3rx5khinIcPpoVKpOHPmTLbOK6n2cW3atGHevHn8+OOP1K5dG4DAwECSkpIkaSMD4Ovry9ixY4WMh8yIPU/J2f9bjjHk6urKnj17aNiwIZaWlhQuXBgDAwNSU1OJjY3l1q1bxMXFSba/AN1eXw263LPm1Gf2Q6TMNJRrzY2MjBQCX52cnBg9ejSVKlWiRYsWQhl2MbGxscnymre3N97e3sK/jYyMmDp1qujG4qFDh5I3b17Wrl0rBDiYmZnRv3//LJUWxEDuNVeXyHWuhw4dIjk5mV69egk9k7NDpVJJstYnJCRQsmRJkpOTuXPnDk2bNgXA2Ng42/lSTF68eMHQoUPp378/1tbWeHh48PbtWwoUKMDatWslqRyhy3nql19+YenSpRw6dIj8+fNjaWmZrT3u2rVrJCUlYWxszKBBg75IMzPbt29n1apV6OnpCdn9oaGhrFixglKlSoneaqts2bKsXr2aVq1asXPnTvr06aOTyiMa5HzuCwgIYMWKFQQHB+Pg4ECrVq14/vy56H2EAUqUKMHQoUOBjHkhIiKCpUuXar1HrVZjZWUlujZk9BFet24dwcHBWFlZ0axZM5KSkmjUqJEkehqio6OZMWOGEFCYuQ1HbGysJPu4vXv3YmhoqBVYdvHiRQYOHMju3bslc0R7e3tz+vTpbO9lKfdxurR5ZkaX48fDw4P58+fTt29fRo0ahbW1NXnz5uXdu3dcu3aN+fPnEx8fT69evUTXVvh2UTKiFb4pIiIiaNmyJampqVo9Dz7E0dHxo+Uh/hdOnjyJj4+PUFIiu+hpyIhI9PLywtnZWVT9Bg0a8OLFC8qWLYuJiUkWfSl7Txw4cAAfHx/Cw8NxdXXFxcWF+/fvM2bMGMk0g4KC6NevHx06dKBly5YA7N69m507d/Lnn39iaGjIL7/8gomJCUeOHBFF8/nz5wwZMiRL2ZCqVauyfPlyduzYwYYNG1i5cqXo/XGSk5PZv3+/UEJFF32OatWqhaWlJZs2bdIqr9y5c2fu3r0ragSxXFmzmc8r82sNGjQQDJlSs3z5chYsWJBtxt+IESNEz7gAecYPwNu3bxk2bBhmZmaCc6B+/fpUqFCBJUuWSNaTTq7z3bNnD2ZmZpL1fMuOT/VsOnnypCS6cv3GIM8a9F9DjnvZ2tqaggULMn/+fEqUKIGenp7Wcakykx0dHSlcuDB+fn7CXio9PZ1mzZrx5s0byTKWPpU1ItU+Li0tjV9//TWLUd7FxYVFixZlW975S3Fzc+PRo0cYGRllWxpUqnlKTnQ1huLj45kwYQJHjhzJ0ZDl5ubG7NmzJau+Isf11eWeVe4+syDfmpu5b/KAAQOws7OjT58+eHl5cevWLf755x/RtEDeigaZiYuLQ6VS6aynuRxrrlzo8lwzZzQuXrz4o06GIUOGiK7fpEkT3r59S7Nmzdi6dSu//fYbRYsWZdiwYVSqVIk9e/aIrqlh5MiR+Pr6Mnr0aJKTk1m4cCGVKlUiLCyMH374AR8fH9E1dT1PvXz5knXr1rF3794cA4bMzMxo27YtnTt3zjZD73/Fw8ODhw8fsn79esEOdPXqVXr27Em5cuU4cOCAaFqZ2bx5MwsWLGDYsGE6zT6Waw06c+YMAwcOJC0tDZVKhaurK6VLl2b9+vVMnjxZkiCh5cuXExoayoEDBzA1NdUKCtYEzXTs2JHy5cuLqnv9+nV69uwpVI5wdXWlfPnyrFmzhgULFtC4cWNR9TIzdOhQjh07lu2x8uXLC60VxMTBwQFLS0vWrVun9XqvXr24ffv2v9p7/VvdpKQkhg0bRpUqVbK046tbt64kunKg6/GTkpJCt27duH79erbrrVqtxtLSki1btmBkZCSqtgZdOt4VxEFxRCt8c+zbt4/w8HCWL19O+fLlhUhT+P+NQvPmzSXLmAoLC+PcuXOEhIQI0dPFihXDysoKJycnyTIsbW1tqVy5Mjt27JDk83Ni3759jB07Vijz5OrqiqmpKZs3b2bo0KGiRppmpn379qhUKv7++2+t19u0aYOxsTGbN2/Gy8uLy5cvc+PGDVG1L168SFhYmOAQ1kRrP336lPz58wuZnt86tWvXply5cuzevVsw6i1evJimTZtKaozfu3cvZmZmODo6ar1+8OBBEhMTRc3isbCwoHz58lob+RUrVmR5TaVSSVJWC/6/B523t7cwXx07dowpU6ZQpEgRSco6yjV+vL292bFjB/b29mzcuJGkpCRcXV2JiYmhffv2kvUhknO+uHfvXpbypPHx8QQEBDB//nxRteRErt9YrjVIbq5fv05wcDBFixaldu3aFCxYULIHOA26vpcz3zu6xNbWFisrqyyO327dunHr1q3vql9lZm7evElAQAAqlUro6SUVNjY2lC1bll27dkna6/tD3r9/z9atW7lz5062fcelynbXoMsxFB0dTVBQEE+fPiUpKYncuXNTokQJatasKXkvWDmur1x7VrmQa81t06YN9+/fZ/78+YSGhvL333/Tvn17li1bhpGRkeiG4k8Fp2ZGiuCk9PR0Dhw4IMyN9vb2tGjRIktglBT8V/aP8HWda3JyMu/evaNYsWKif7aPjw8LFiwAoFChQhw5cgRvb2+OHj3K9OnTJa1U4eTkRJ48edizZw/9+/cnKiqKs2fP0qZNG6Kjozl//rzomnI+f2la1n1oj5OipDBkBE/WqlUrixPte+1/Kte1bdeuHWFhYSxatIi+ffvi5uZGz5496devH6amppKW9x03bhyWlpY6c/h3796dq1evMnHiRKZMmYKbmxutWrVixIgRVKlShd27d0um7ejoiLGxMUuWLKFLly4sXbqUmJgYxo8fz4ABA4QscTGZPn06fn5+HDx4ULDVP378mNatW9OhQwdGjRoluibADz/8QPny5bOMXV2RmppKWFgYenp6VKxYUdJe2HKMn6SkJBYsWMDOnTuJi4sTXjc2NsbT05ORI0dKZj+XI3BF4ctRSnMrfHP8+OOPABgYGGTp4aELKlWqJNkG92M0adKEK1eu8O7dO/Lnz68z3ZUrV1KgQAG2bt0q/NadOnVi//797Nq1SzInQEhISLblfNPT04XNbnx8vCTlVOrWrZttZJyZmZnoWgCJiYmsWbMmx74lYmf3a6hfvz7Hjh0TSn7fv3+frl278uDBA9zd3SXRBBg7dizu7u5ajmi1Ws3GjRsJDw8X/SE9KioqS/ZzZGSk8JrGwSWVIzo+Pp7atWtrbYTat2/PgQMHRH8o1yDX+Dl16hSlSpUSou6NjIw4fvw4LVu25PTp06JqZUau892+fftH+yV+T4ZEuX5judYguYiPj2fo0KFcvHgRyCjD++jRI7Zt28bGjRslyxKW416eNGkSvXv3xtvbG2dn5yyOdqn6nZubmxMUFMTBgwfx8PAAYP/+/QQFBWFtbS2JpobU1FSOHTtGcHAwpUqVon79+uTNm5cSJUpIqgsZ/RWlKi34IfXq1ePhw4c6ceZkZtq0aezcuRPIWjFJqlKsGnQ9hkqUKEGzZs0++b5JkyZx4cIFUcsay3F9dblnnTdv3me9T8q9o1xr7qBBg/j55595/PgxzZs3x8fHh0WLFqFWq3FzcxNVCz7fuRwWFia6dlJSEl5eXgQFBQnzxY4dO4QSvFIGf8mx5p48eRJnZ2dJjeDZIddeuVq1akLASmZ69uzJixcvOHHihOiaAwYMoFChQkRFRdG2bVsKFiyInZ0d9vb2kjqhIaMqlZWVFQYGBty4cUOozlekSBEiIiIk0ZTTXmNhYfHZFRXEoGDBgkRERJCcnCy0/UpKSiIyMlKyil//BrHXermu7b1797C3txdKN0NG2yJra2vJA0U11dxiYmKylKu+cuWKVnsBMbhx4wb29vZ06tRJmCMbN26Mra2tZDYiDQkJCVhbW2NlZYWlpSWvXr3C09OTXbt2sW/fPkkc0Xnz5iUxMZGmTZtSq1Yt3r9/T1BQEO/fv+fRo0eMHDlSeK+Y+/VevXrh4+PDs2fPMDU1Fe1zPwcfHx/WrFnDu3fvcHV1pW7duly6dIk5c+ZIEsgpx/gxMjJi7Nix/Prrr0RERBAbG0vevHmpWLFiluxzsVm0aBGGhoaC4x0ybCfbt29n/fr1iiP6K0VxRCt8k7x584Z+/foJk/eFCxe4c+cOpqamuLu76zT7QleMGTOGpk2b0rRpU2xsbLKU25PKuBYVFYWjoyMVK1YUXqtcuTLVq1cnICBAEk2AcuXKce/ePUaOHIm7uztqtZpjx44Jm2JfX1+uXbum9b2+lJcvXzJv3rwcHcJi9ybTMGnSJA4ePKjzviXjx4/n9u3bgoMwKiqKqKgozMzMGD16tKhaPj4+LFy4UPj38ePHqVatWpb3FSxYUFTd1q1bi/p5/wuurq4EBgZqPbi+e/eO8PBwyQJp5Bg/ALGxsdSuXVurtKGxsTElS5bk2rVromplRq7zXb9+PSqVioYNG3L69GkaN25MREQE9+/fl6xPsqura47HpJyn5PqN5VqD5GL27NlcuHCBmjVrCmMmNjaWJ0+eMGvWLBYtWiSJrhz38pMnT0hNTeX/2DvzuJrS/4G/71URsmRnLEMILUTWMChZkp3sOzOWxjr2bTBjLE2DMcoaYwnRDMq+y0yFipGlJFvWSKVFdX9/9Lrn11WW+TrPPTG9/7r3nPu6n7M862fdvXu3ZDzUIrLe+bBhw/j222+ZMmUKs2bNApCitAYNGiREJmTWbxw6dCgRERFAZl9++fIlXl5ebN68WZhC9eHDhyxcuJDw8HCdaDTIfM4isnLMnz+fTp060aVLF5o0aZJtzTpx4kTZZUJm7WK1Wk2XLl1yTPcuEiX60Ifw7NmzfxV1+iEo8X71uWb19PR87/pbtBOjPufcP/74AwcHBwoWLIi9vT27d+/G2NiYSpUqsWrVKn7//XcqVqyIq6urDHf2dvRds/KXX37hwoULlClTRnJmOHLkCBcuXGDlypWyt6usKDFejB49mhIlSuDk5ESXLl1y3IeJQJ/36uvrK2VH0Gg0/PPPP0yfPl06n5GRwY0bN8jIyJBVblbeVHwPHDgQQHgwQcmSJbl+/TobN24kNTWVRo0a8c8//3Dx4kXKly8vRKZSewMlaNWqFTt37sTFxUVyAvPz8+Px48fCnQw+BLnneqXebZEiRYiKiiI5OVk6Fhsby40bNyhevLisst4kODgYV1dXnj9/nuN5uQ3R+fPn5+HDhzo6wJSUFO7evUvBggVllfUmJUuWJDw8nEePHmFpaYm/vz9NmjTh3r17xMbGCpHp6ekJZAbhvBmgkDUVuNyOo9evXycjI4O2bdtSuXJlChYsqLPG27Fjh2yysrJx40bc3d111sg3b97k8OHDLF++XGdukgsl+49arX5vwN6YMWM4ceKEbOs5JR1X8vjfyTNE5/FJkZqayowZM/Dz82PHjh1YWVkxY8YMnXo7ZmZmeHl5CUvNrRTLly8nLi4OyF57TWSUR6lSpQgPD5fSHgHcunWLsLAwoRE8EydOZOzYsfj5+eHn5wdkbijz5cvHhAkTJM/eLl26yCZz9uzZnDx5Uu8G4XPnzqFWq+nVqxc1atQQUq8xJ8qWLcu+ffvYv38/4eHhGBgYUL16dZydnSWDqVwMGTKEHTt28PDhQ1QqVY7PWK1W079/f1nlaj1blcTCwoJjx47h7OxM8+bNSU1N5eTJk7x48YKCBQtKkTdyKjSV6D+QuWkNDg7mwIED2NnZkZ6ezokTJ7hw4UKOXtVyodT93r9/n/r167NmzRpat26Ni4sL9evXp3379sJStL1LySBynFLqGSs1BynFkSNHMDMzY8eOHZJhcsqUKZw4cUJo6lkl2vLSpUt5/fo1xsbGFCtWTGj7zeoI5OjoyPfff6+zrjIxMWHMmDEfFGH6v7J48WIiIiJo37691IcMDQ15+fIlS5cuZf369ULkTp06lcDAQL2ubbZs2UJcXBxxcXE6kYxa450oQ7SxsTFWVlYsWrRIyP+/CyX6kFIo8X71uWbt0qWL0PHoQ9DnnDt16lTmzZtH69atcXZ2xs7OToqatbOzE5ad4k0WLlz4zpqVcnPw4EFMTU35888/JUfYMWPG0LFjRw4cOCDUEK3EeFG1alVu3bolOT/VqFGDrl274uTkJCRNtRZ93qu1tTWzZs0iLS0NlUpFTExMjnWZ3ywPJRcJCQn8+uuvOTpTRERECHXKdXR0lAwf+fPnx8HBgblz5/Lq1SvZ1+ZalNobKMHEiRMJDAwkPDyca9euAZn3WqFCBcaPH6/sxQlAqXfr5OTEpk2bsLe3R6VSERgYiKOjIwkJCcJTZi9btozY2FiKFi1KXFwcZcqU4fnz56SmpuqUg5SL1q1b4+vrKwVOhIWF4eTkxKNHj4T3GUdHRzZt2sSuXbuws7Nj1KhRfPXVVwDCnJTGjBmjyNoq6xxw8+ZNnXMir2f79u2UKlWK/fv3S3OOq6srR48exd/fX4ghWsn+86HIWR1YScN7Hv87eYboPD4p1q1bx/79+6XvgYGB7NmzR6p39+zZMyIiIli9erUU5fK5cODAAQwMDOjcubNeozx69eqFu7s7LVu2RKVScerUKY4fP45Go2HIkCHC5LZq1QofHx/Wr19PZGQk6enpVK9enUGDBmFpacmRI0dYvHixrIu0CxcuYGhoiKurKzVq1BCeSiQrNjY2zJ07V2/ytBgbG+vFizd//vzs2bOH+Ph4HB0dadasmc79qlQqihUrpte08/pi8eLFQGb0zp07d4D/X4D9/vvv0nc5DdFK9B/IdDiYOXNmtho/Go1GaKShUvdraGhIWloakOlwcOnSJZo2bUqlSpX4559/ZJWlZePGjdJnjUZDamoqYWFh/P7771JdOhEo9YyVmoOUIj4+HjMzs2zHTUxMiImJESZXibb84sULqlevrpc6s02bNsXBwQEnJyeaNm1Kr1696NKlCxEREVLNLtHXcPbsWerUqYObm5uk1Bs5ciQHDx4kNDRUmNyQkBCKFCnCjBkz9LZ+3LFjByqVikaNGul1zTpgwADWrVvHxYsXsbGx0YtMLUr0IaVQ6v0aGxvj7OyMtbU1arWaSpUqCem32nWbkuhzzi1cuDAJCQkcOHAAPz8/ihYtSocOHXByctJrPwoMDKRs2bI51qzs2LGj7PKePn1KgwYNdLIxFS9enJo1a3LhwgXZ5WVFifHCz8+PiIgI/P39OXjwINevX+enn35i2bJl2NnZ0blzZxwcHGR3iNbnvX755ZcsWrSIW7du4eHhQZUqVXQMSGq1GlNTU2EZqRYtWoSvr6+0r8uqcBdVI1PLhAkTMDAwIDo6mv79+1O6dGlq1qxJ5cqVGT58uBCZSu0NlKBYsWLs2bOH7du3ExwcjFqtxtramt69e8ue0S03oNS7nThxIo8ePZJq2b58+RLITFktKgOJlhs3blCzZk18fHxo1qwZK1eupFixYnTr1k2IXnDGjBlERUVJDiqPHz8GMsdJkY5QAJMmTUKlUmFpaUnLli3p3r07Pj4+FC1alBkzZgiRKSLd94egVGDKgwcPaNy4sc74YGpqipmZGRcvXhQiU8n+owSfguE9j+zkGaLz+KTYv38/hoaGeHp6YmVlJRmba9WqxY4dO4iPj8fe3p5Tp059doboYsWKUblyZb1HeYwaNYqEhAS2bNlCWloar1+/Jn/+/PTt21d4bU5zc3OWLl2a4zkRNYwLFixI7dq1hW3W3kbPnj3x9fUlMTFRJ6WxCP5NnQy509SYmppiamrKsWPHMDY2/uyyFrwNpSJr9N1/ALp3705ycjJr1qzhyZMnQGZE69dffy3c4UGJ+61RowYhISHs2bMHGxsb1qxZQ0xMDIGBgcKUEjnVr//qq6+IiIhg48aNNG3aVIhcUOYZKzkHKUHt2rUJDg6WHA6ylowQaRBQoi23bt2a69ev66VeZWJiIn/88Qd//PEHJUqUoEOHDnTq1AlLS0vhsrWkpKTkqMhKT0+X1Tv8TcqVK0eZMmXo3LmzMBlvYmhoSIMGDdi0aZPeZAI4OzuzYcMG+vXrR6FChXRqvIpKQ65FiT6kFEq837S0NNzd3dm8eTOvX78GwMjIiMGDB+Pq6ip0HImLiyM6OprU1NRsNSPfdLyTE33NuefPnycgIICDBw9y/PhxXrx4wbZt29i+fTvly5fHyckJZ2fn96Zc/Fj0XbOyQoUKhIWFcefOHSpVqgTA7du3CQ0N/eDa1f8rSo0XZmZmjBs3jnHjxnH69Glmz57No0ePOHXqFKdOnaJcuXKsXr1a1lIR+r5X7VxnaGhI1apVhRmdc+L06dMUK1aMefPmMWnSJBYsWEBMTAwrVqxg7NixQmUbGRnp1FgF9BKpq8TeQCkKFizIsGHDGDZsmNKXoheUeLdGRkb8/PPPTJgwgatXr2JgYECNGjWkMVok6enpmJqaYmBggIWFBWFhYfTv3x9ra2vOnz8vuzwTExN27NjB+fPnde41p72+3BgaGjJ16lTp+6JFi5g8eTJFixYV6lwYHR3Npk2bCA0NxcLCgvbt25OcnEyrVq2EyXxXqT4R71VLhQoVCAkJkRyu0tLSOHv2LBcuXKBixYpCZCrZf5Tgv2Z4/1zIM0Tn8Ulx79496tevL03OAQEBqFQqaSFkYmKChYWF8LqR2vRKWRUSWmxtbYXIHDFiBO7u7oSFhWFlZSVERk6oVComT57MmDFjiIiIwNDQkEqVKgmvWwL6X6gMHjyYNWvW8PDhQ8qWLStERk6o1WqSkpJwdHTEwsIiW90SOdOuf2hKMJGG03LlyvHnn3++tRb3Dz/8IEy2EigVWaPEQh+gX79+9OvXj9jYWDQaDSVKlBAqT4sS9ztx4kRGjBhBcnIyHTp04LfffpNq3To6OgqT+yYajYZnz54Jq6mrRYlnrOQcpASTJ09m6NChLFmyBJVKRWhoKCEhIRgYGAj1JFeiLderV49jx47RtWtXGjdurGM01F6TXLi5uXHo0CFOnz7N06dP2bJlC1u2bKFSpUp06tQJJycnIalfs1K/fn0CAgJYuHAhAHfv3mXSpEncuHFDqAPJd999x/jx41mzZg0tW7bM9pxFlE3o27cvO3bs4MGDB8JqU+bEd999J6VbT0hIICEhQTon2iEst8wH+kCJ97t06VI2b96MRqORxv9Xr17h6enJ69ev+e6774TIPXr0KOPHjyc9PT3H8yIN0fqacw0NDWnZsiUtW7YkPT2d8+fPc/DgQY4dO8b9+/fx9PTE09MTc3PzHNMcy4W+a1Z269YNNzc3OnfuTP369YHM7FjJycnCIziVGi+ePn2Kv78/fn5+hIaGSrWS69aty927d3nw4AHff/8927Ztk02mUvc6duxYXr16RVhYmN50NnFxcTRt2hRHR0c8PT0xMjJi9OjRnD59mp07dzJ48GDZZWYlODgYT09PQkNDadiwIc7Ozjx+/Jh+/foJk6nUfjMiIoIiRYpQunRpvL29OX36NHZ2drLW8XVzc8PMzAxnZ2eplFZOyJnVLDehr3f74MGDbMcMDAx0dJ7a34hcc2gNh0FBQVhbW+Pt7U2RIkUIDQ0V6jDapEkTmjRpQkpKClFRUaSmpgrP0gRw7do1rl27RkpKSrZzvXv3ll1eWFgYgwYNIikpCZVKRfny5Tl37hwbNmzA3d2dtm3byi4zJ549e4aPjw+7d+/m3r17wvQnw4YNY86cOfTo0UPK6nbq1Ck0Go2sY3Ju6T9K8F8zvH8uqDQiR9Q88pCZevXqYWlpyebNm7l16xYdOnRApVLx+++/SxvIHj16cP/+fWHeTceOHWPatGk6yi0tKpVK2EQ2ZMgQQkJCSE5OpnDhwjr10ERHeaSlpZGWlkaBAgW4fv06f/31F40aNZLVW/pN3lyotGnThipVqghdqEyfPp1jx46RnJxM5cqVsxmE5Y4Q1vKu56hSqQgPD5dN1r9RIL3Le/BjWLhwIVu3bgWy1wiR+35zC29b6KtUKnr16iW7PH32n6ioKAoVKkTp0qWlelFvQ1SdaCXGCy1Pnz4lPT2dMmXKEB4ejo+PD1988QX9+vUTksbrzawG6enpPHnyhEePHlGuXDmOHz8uu0xQ9hkrMQcpybVr11i/fr1OHdShQ4cKq9mlRd9tOev7yzrXalNaipgLUlJSOHXqFAcPHuTUqVMkJiZK8i0sLOjUqRMDBw6UXS5k1iXr37+/ZCjVUqhQIX7//Xdh7/fvv/9m9OjRvHr1Kts5UevWmTNncuDAASCztuubxm9R6ykrKyuMjY3fmoa8YcOGQuRq0Xcf+hDGjBnD8ePHZe1PSrzfRo0akZyczKpVq2jevDmQGcnyzTffUKBAAf766y/ZZULmWjg8PJzq1atz8+ZNrK2tuX//Pk+fPsXFxYV58+YJkavknKslKSmJ5cuXs3XrVqHjspbFixezadMmxo4di6WlJaNGjZLmhlq1arFnzx5Z5aWnp/Pdd99JbVlL69atWbFihewpqt9E3+PFoEGDCA4OJiMjA41GQ6lSpejSpQvdu3enSpUqJCUl0a1bNx4+fMilS5dkla3E2KiEzsbOzo78+fNz4MABfvzxRxITE/nxxx/p3LkzDx48EFoj+vTp03zzzTekp6dLY8YXX3yBl5cXc+fO/VdZ0T4UpcapkydPMnbsWBYtWiS1I8h8r3Leq7m5Ofb29qxatQpzc/McHdr0MTZ+CHLP9fp8tx+6/hWpawXYuXMnc+bMYcqUKTRr1ozu3btL42WLFi3w9PSUVV5iYqJkqLS0tKRbt27cvXuXcuXK4eXlJSxqFsDLy+udwRIi2vOAAQO4dOkSs2bNYt68edjb2+Ps7MzEiROpUaOG7HP8m5w7dw5vb2+OHz8uZaNSq9VC29T27dtZs2YNjx49AqBMmTKMHDlSVkN0buk/H4KIPQn8/zj85MkTQkNDsbKyonTp0rLKyEM+8iKi8/ikqFKlCiEhIQQEBODj4wNkpqyuV68eAH/88QdXrlyhbt26wq5hxYoVxMfHo1arKV68uPBNqpashvX4+Hji4+Ol7yKjPG7dusXw4cOZPn06tWrVomfPnrx+/RoDAwPWrl1L48aNhchdunQpr1+/Zt68eZKSx8rKCrVazZo1a4RsbLIaaW/evKlzTuQzHjNmjN5SN4syLv8bjhw5Ii3oa9Soobc+pBTvW+iLMETrs/906NABe3t7Vq5cSfv27d/alkUufpUYL7SULFlS+lyjRg3hZSHepsRSq9VCU1Ur9YyVmoOUIigoiOLFi2dLhRcYGMipU6do2bKlMNn6bstKlC3Inz8/bdu2pW3btqSmpnLmzBn8/Pzw8/Pj8uXL/PPPP8IM0dWrV2ffvn1s27ZNx8mgb9++QjfLc+fOlQzubyLKH1m7RodMx4qsiHznX375JcWKFdNrGvKs6LsPKYUS71ej0VCvXj3JCA2ZUUR169YVqli7ffu2FBllZ2fHlClTqFatGh07dpQUiyJQas5NT0/n3Llz+Pv7c/ToURISEqRxQnS2KH3XrMyXLx/Lly9nyJAhBAcHo1KpsLa2FqpHyIq+x4u///4bAwMD2rRpQ/fu3WnZsqWOs46xsTHVq1fP5iwlB0qMjUrobJo3b46vry8eHh40btyYCRMmSE7uorOurFixAiMjI1asWMGIESMAaNOmDd7e3nh5eQkxRCs1Tq1evZqMjAwMDAzYt28farWa8ePHs3r1arZt2ybbvXbp0gULCwvpsxKltpRCn+/2Q9ai+fPnF55lrVevXpQqVYoyZcpgbm7OwoUL2bBhAxUrVmT27Nmyy1uyZAl+fn5YWlpy/fp17ty5Q+HChXnw4AE///zzO6PwP5Z169ah0WioVKkSpUuX1kvbvnz5Mra2tjpOfG3btqVevXpcvnxZiMwnT55I0c/3798HMttb/vz56dGjh7A9n5Y+ffrQp08fYmNjMTQ0xMTEhJSUFJ4+faozL34MuaX/KMGTJ08YN24co0aNwsrKik6dOhEXF0eRIkXYuHEjtWvXVvoS88iBz1v7n8dnR48ePViwYIFUl0WlUjFw4EDUajWurq4cOXIElUolZKGtJTo6mrJly7Jr1y5KlSolTM6bbN68WW+ysrJkyRJiYmK4f/8+V65cITU1FTs7O86dO8fq1auFGQGUWKj8+OOPQv73fYhMt/oufH1933leVFq6V69eUbduXdm9SnMiN3gIfu4LfY1Go7MAfttiWGQCFn2PFydOnOCHH37Aw8ODqlWrSse15RNmzpxJjRo1ZJcLOY9TBQoUwMLCQqjntBJjMig3BynFgAEDcHBwYOXKlTrHV6xYQWRkpOzZXpRsy0qVLdASEhLCmTNndJ6p6ERRpUuXZvz48SQmJqJWqzE2NhYqDyAmJoaKFSuyZcsWypQpo5c5SKn11KxZs/j6669Zu3YtzZs318keBGKycijZh4KDg7GysnpnCkdTU1PKlSsnq1wl3m+nTp3w9/cnNjYWU1NTAO7fv8/Vq1eFOPRlRduOLCwsCAkJoUGDBtSqVUv2qNGs6HPOzcjI4O+//8bPz4/Dhw9LNfY0Gg0mJiY4OjrSqVMn4RkFlKpZaWFhIRmbRKPkeDF16lQ6d+4s9Z+cWLBgASYmJrLIU/JeQRmdzcyZM0lMTKR69eq0bduWpk2bEhAQgKGhofB6zTdu3MDW1lbHWcfW1hYrKythY5VSe4PIyEjq169Px44dWblyJTVq1GDkyJH8/fffst5r1nWqkmtWJeZ6fb5bbQ1dyBw3xo8fz9y5c7G3t0etVuPn58cPP/wgxBj8JlnTjnft2lVoEMeJEycoXbo07du3Z8aMGRQrVozTp0/TpUsXgoKChMmFzPI1lpaW7Nq1S6icrOTPn5+HDx/q7LVSUlK4e/eu7CW3tOUQTp48KUU/q1Qq6taty6VLl6hatarw9lSrVi0pWCPrvDto0CCePHnCsWPHZJGTm/qPvlm8eDGhoaFERUVx7do1Xrx4QbVq1YiMjGTFihWsWbNG6UvMIwfyDNF5fFL069eP58+fs3XrVjIyMujVqxfffPMNkOnVrFarGTVqlNC6Tubm5hgaGuplQ/PkyRNJzodu/uPi4ihatKhs1xAaGoqZmRkDBgzAxcWFChUqsG7dOlxcXLh+/bpsct5EnwsVLfqMFv76668ZOHDgB9eFDA0NxcvLS1bPyGnTpr1TIS2qH3Xo0IHz58+Tnp5Ovnz5hMjQ8qFGBZHGh899oX/gwAEpSubNyCh9oc/7vXDhAmPGjEGj0RAUFKSjXDt8+DDR0dEMGDCA7du365yTC6WyGigxJoNyc5A+2bBhg1SuAODs2bO0adNG+p6RkUFMTIxsymEtSrRlpee+ixcv4ufnx8GDB3n27BmQOf4XKlQIBwcHOnXqJIuct7F9+3Y8PT15+PAhkFmr6+uvv6Znz57CZDZq1IjY2Fjh0YxZa9p96Dgl9zpgyJAhZGRk4Obmlq3NiHA4U3o+GDNmDOXKlXunY+GCBQtkkaX0+y1UqBBJSUm0a9cOGxsbXr9+zcWLF3n9+jX37t1j0qRJ0m+XL18ui0zIdF64dOkSR48epW7dumzbto3Xr18TFBSULSW5nOhzzm3evLlUg1mj0WBkZETLli3p1KkTX331ldBalWfPnqVkyZKYm5tz9uzZd/7Wzs7uo+VNnz79g36nUqn44YcfPlpeVpQeL4YMGUJQUBABAQE4OTkBMG/ePMlgCsimQ1D6XkG/OhsthQsXZsWKFdL39evXc/XqVcqWLSs8Gq1IkSJERUWRnJwsHYuNjeXGjRsUL15ciEyl9gaQ6bjy5MkTbt++Td++fYHMrIGiUr23adMGOzs75s+fr3N82LBhxMTE4OfnJ0Qu6Heu16LPd5t1nbB06VJsbGx01sV9+vTBz8+P5cuXy16f+kP3FyLqgD9//pxmzZpRsmRJLl26RMOGDTEyMuKLL77g77//llXWmzg6OhIUFER8fLzs+8u30bp1a3x9faU1ZFhYGE5OTjx69Eh2vePIkSNRqVRoNBpq1qxJx44dcXJyonz58kJLe/n6+krvTqPR8M8//+isOzIyMrhx4wYZGRmyyVSy/3wIKSkpxMfHU7JkSczMzCRnRzn4+++/qVixIr1792bUqFGUKlWKAwcO0K1bN6HOUHl8HHmG6Dw+OcaOHcvYsWNzPD5v3jxZjbA5MWfOHIYMGcLatWtp2rQpxsbGOsY8OaMtWrVqRbt27ejWrRuNGjV6qzInLS2NS5cusX//fv78809ZPUFfvXpF+fLlSUlJITw8nHbt2gGZ6btev34tm5w30ddCRVsPskOHDhQqVOidv01NTeXo0aN4eXnh7e39UXJjYmIYNmwYpUuXpk2bNlhbW/Pll19SpEgR0tPTefbsGQ8fPiQoKIjz589z//59qlev/lEy36RevXpS29VoNKSmphIdHY1GoxGayrhGjRr4+/vTrVs3bG1ts/WhiRMnyibr8OHD0udLly4xY8YMhg8fjoODg+QhuH37dtavXy+bzDf53Bf6w4YNo1q1aqxfv56BAwfSoEEDXF1dZZXxPvR5vx4eHmRkZODk5JRtMe/m5sbSpUv566+/WLNmDUuWLJFVtparV6+yZMkSLly4AGRGPEyZMkVoDWF9PuOsKDUH6ZMePXrg4eFBXFwcKpWKpKQkKX1YVtq3by+rXCXaslJz308//YS/v7+USlej0WBgYICdnR3Ozs60adMmW/Ss3Hh4eODu7q6j1Lt//z5z5szhxYsXUipNuXF2dmbWrFmMHDmSZs2aZTOe9e7dWxY5LVu2pFevXnTt2vW9KUgfPHjA/v372b59OydOnJBFPmSuh9+GCIczpeeDIkWK6K28idLvV5tFJykpiZMnT+qcO3jwoPRZpVLJaogePXo03377Lffv36dDhw6sWbOGFStWoNFosLe3l03Om+hzzn327BkqlYoGDRrg7OxMu3bt9LZe1a7JV65cyfDhw4WXd8lahiknGVmR2xCt9Hhx9OhRvv32W5o1a4aTkxPp6ens3r2bXbt28csvv8janpW+V9CvzkbLm8ZKlUpFnTp19GKsdHJyYtOmTdjb26NSqQgMDMTR0ZGEhAQGDBggRKZSe4Mvv/yS4OBgxo0bh0qlws7OjjVr1hAWFkaTJk1kk3P06FHJyfr+/fsEBQWxatUq6XxGRgbh4eFvLX8iF/qc67Uo9W5jYmJ4/fq1jvNbYmIid+7c4cWLF7LL8/T01NGHvasOuNyGaFNTU6Kioti/fz+vXr2iYcOGPHr0iMuXL1OmTBlZZb3J1KlTadeuHe3atcPa2jpbhiY511FaZsyYQVRUlFRm7PHjx0BmVpIpU6bILg8yHSpq165N7dq1hTvkAlhbWzNr1izS0tJQqVTExMTkuO5o1KiREPn67j9ZyRoBnpWsEeBy96GXL19iYWGBoaEhly9flkqYaftWHrkTlUZ0Dro88vjMeJeiX+5oi3Xr1vHrr7+SnJyMiYkJtWvXzlFhGxISQnJyMsbGxnzzzTeyKjMdHR15+fIl7du3Z/v27SxcuJASJUrg6upKtWrV3rmh/xji4+MZMWJEtnqoFhYWeHp6vjOt2L9h1KhRnDp1CiMjI5o0afJOpfjFixdJSUmhRYsWeHh4fJTc9PR0tm3bxoYNG4iJiXmr4kWj0VCxYkWGDBmCi4uL0NR0kDmZ9+jRAxcXF4YOHSpEhrm5ueShmPW+td/Dw8OFyO3atSsFChRg+/btOsddXFxIT08XFrH8/Plz2rVrh4GBgd4W+vrqP9r/rFq1Km5ubjg5OdG0adO3pv4RofQB/d5vw4YNMTEx4ciRIzn2x5SUFOzt7TE0NOT48eOyydVy7do1+vTpQ1JSks5xY2Njtm/fLszLV5/POCtKzUH6JiIigsePHzN06FBsbGx0SjaoVCpMTU1lT2GpRFtWau7L2i/q1auHs7Mz7du3p1ixYh/1v/8GOzs7nj9/zuzZsyWHiiNHjjBv3jxMTU05c+aMELlvm3O1yDXnzp8/H29vbzQaDdWqVXvneurOnTuo1Wp69uwppXz8FFF6Pvjtt99YuXIldnZ2NGjQgMKFC+s4rcrlZADKv9+VK1d+cFr5nByWP4bw8HCMjY2pUqUKZ8+e5ffff6dixYq4uroKM9jqc85du3YtnTp10ouS9k1at26NnZ0d33//Pa1bt37nb+XoQ29bM9y5c4eNGzeSkpKCRqPBzMyM/fv3f7S8rCg9XnTr1o3r168zffp0+vfvT1paGps3b8bNzY1atWrJug9S+l5BfzqbrMbKVatWUbVqVTp06CCdz8jIYMeOHSQmJhIaGiqLzJxITU1l6tSp+Pv76xxv27YtixcvFhKhrNTe4MiRI4wfP5709HQsLCzYsWMH06dP5+DBg2zYsAFbW1tZ5Fy+fPm9pR80Gg0WFhbs3r1bFpk5oc+5XotS77Zfv35cvHiRSpUq0bx5czIyMjh79ix3796lUaNGbNq0SVZ578sQmBW5y5LMmjWL3bt3o1KpUKvVHDx4kIULF3L69GmGDx+uk+lFbrSyc0KkPg7g/PnzXL16FQMDA2rUqCGr84iWzZs34+Pjw/Xr16X3a2pqioODAzt27KBWrVrCdAh//PEHt27dwsPDgypVqkh7PgC1Wo2pqSkdOnQQ0of03X+yRoDv3buX8uXL6xjZMzIyOHLkCBkZGdnGEjlo3bo1Go0GFxcX3N3dmTVrFnXr1mXAgAGUK1eOAwcOyC4zj48nzxCdRx7/kvcp+eVOTfv06VM2bdqEr68vT58+zfE35cqVo3v37vTp00f2tE9r1qzB3d0dgGLFinHo0CFmz57N4cOHWbBggdB0kqCfhcrx48clL1rI7hGvHSYbNmzIsGHDJE8rOUhLSyMgIICzZ89y/fp1KVVoyZIlsbCwoFmzZkLu+V1MmzaNwMBAYYqB9y34RdUetLKyonz58vj7+0vy09PTad++PQ8fPpTev9x87gt9R0dH7ty5A7zdkxjE1uHWoo/7tbKyokGDBmzYsOGtvxkyZAgXLlwQ0qa0zjMuLi6ScsTb2xtvb2+++uor4bVw9PGMs6L0HKRv1q1bh42NDTY2NsJlKdmW9T33dejQAWdnZ5ycnPjiiy9k+99/Q7169bC0tGTz5s06xwcOHMjly5eF1XB8XyTUli1bZJN17do1PDw8OHLkiBQNoEW7lipQoADt27dnyJAhwuqD3r9/n4sXL6JSqbCxsaF8+fJC5Cg9H+jLyUBLbnm//yX0PecqSWpqKrdv3yYxMRFjY2O+/PJL4Zkq0tLSWLt2LR4eHiQnJ1OgQAG++eYbhg0bJnsEotLjRb169bC2ts6miB48eDBhYWFcvHhRNllK3yvoT2eTW4yVWu7cuaMzZlSqVEm4TCXGqcjISO7cuUPjxo0xNjbm1KlTmJqaYmlpKascDw8PIiIi2LdvH2XLltUxcmuNSr17935vppCPQd9zfVb0/W7Dw8MZPny4tC/QUqFCBdavXy/kOSclJXH06FEePnxI+fLladOmjdDSG1ri4uKYP38+t2/fZujQoTg5OfHDDz8QExPD8uXLhZbFqFevHq9fv6Zz586UKVMmm8OQ3A59SnHlyhV27tyJn58fCQkJUv8pVKgQ33zzDd27dxfmlDxo0CB69+6t45gkGn33n6ioKDp16qSzJ8jJxNioUSO8vLxklQ2ZGc82btyISqUif/78HD58mLlz53LixAkmTZokLNtYHh9HniE6jzw+Ia5du8a1a9eyKWyrVasmVO6OHTuIjo6me/fumJmZsXnzZlQqlbA0T5BZw8vCwoJ+/frpHF+yZAlxcXEsWrRIdpmRkZFvVYrb2dlRsWJF2WUqyZu12NLT03n48CFubm6kpKQI8Vp7HwkJCRQuXFjIf3ft2pVr165ha2tLq1atyMjI4OjRo4SEhGBhYSEsIlqJhb4++8/x48eZO3eu5CjzrmWFqBrS+rxfbYTu0aNHc0znn5iYiL29PQULFuTYsWOyydVSv359KlasmK1OWOfOnbl3756UrltulBiTtSgxBymFjY0NX375JT4+PsJlKd2W/2tMnjyZCxcucPDgQcm4Eh8fT/v27WnZsqWQPvTixQsKFiwoKbPOnTvHtWvXKFu2LA4ODsKUXImJiZw/fz7H9VSDBg2E1o5ctmwZGzdulOqv5cuXj2HDhsmeDg6U70P6dDLIipLvVx8oWUc46zUoNefqm5iYGJYuXcqxY8dITU2VjufLl4+2bdsyefJkIc4kgYGBzJ8/n1u3bqHRaLCzs2Pu3LnC9ntKjxeNGjWiSJEiHDx4UIqmTE1NpV27diQkJBAYGCibLKXvVd/kBmPl28ojTZ06lSdPnrzTKeB/5b80Tk2fPp3atWsrsvdQYq5X8t0mJiayb98+oqKiUKvVmJmZ0alTJyFr1sjISAYNGqRjuPviiy/YsmWLIllCsqZUFkmrVq2oXLmy7BGy7+Lu3bvMnz+fCxcu6NSyB/EBC8nJyRw8eJDdu3cTHBwsycyfP78wnWejRo3eW9tdBPrsP6BsBHhqaiorV64kOjqa/v3707BhQ9zd3UlOTmbq1KkfnO0gD/2SVyM6jzw+IczNzYWlXX0XLi4uOt8HDhwIIHvN24iICJ4/fw5kpva4c+eOTjRFeno6J0+e5MGDB0IWv9WqVRNu1M9NvK0Wm0aj4auvvtLrtYSGhuLt7c3Bgwdl9cjPynfffcfXX39NYGAgQUFBQOa9Fi5c+K2ppOWgWLFiVK5cWfhmXKn+07BhQymlrLm5Ofb29jr1s0Sh1P06ODiwbt06XF1dmTNnDpUrV5bORUZG8sMPP/DixQucnZ1lk/kmOUUIiYgaUnpM1qKvOSg3YG5uzuPHj/WiiMgNbfm/hIWFBceOHcPZ2ZnmzZuTmprKyZMnJWOxm5sbgCx16FJTU5kxYwZ+fn7s2LEDKysrZs6cyZ49e6TfmJmZ4eXlJUQxUKhQIezt7YXW0M0Jb29v1q1bh1qtlmqLR0RE4OnpSYUKFd4btfZvUboPiTI0vw+l3q++2Lt3rxR9Brw1ykNuQ3RumXP1yd27d+nduzfPnz/P9nzT0tLw8/Pjr7/+YufOnbJls3j+/Dk//fQTf/zxBxqNhpIlSzJjxgzhUUtKjxd2dnb4+fnRpUsXGjVqRHp6OufPnycmJkZHcSwHSt/ruwgODmbnzp2y1qYeNWoUAAYGBno1VgYFBXH//n0g07EiISFBJwI6PT2doKCgbNFxH0NuGKciIyP5/vvvCQ0NJSUlReecKIOWNmNbbGyslMIf4NWrVwQFBdGnTx/ZZWrR11yfG94tZK4x3tz7ieLHH3/k6dOnFCxYkOrVq3Pjxg3u3r3Ljz/+yC+//CJc/okTJ4iMjMzWpi5cuIC3t7cwuSNGjMDd3Z2wsDCsrKyEycnKzJkz3+rwJDo+skCBAnTp0oUuXboQHR3Nrl278PX1lXVsfJOiRYvqvbY76Lf/QGYwBIChoWG20hSiMTIyypbCfvz48YD4NpXH/05eRHQenwUJCQmkpqYKq1Xi4uJCw4YNmThx4nsH9R07dgi5BqVISEjg119/zXGBFBERIasHmZ+fnzSRvC31kEajoUKFCp+F97TS5FSLzdjYGEtLSyZPnkzJkiWFyk9ISOCPP/7A29ubmzdvCq8RDZlRF1u3buX27duSh2D//v2FjR0A27Ztw93dnXXr1gld6CvVfxwcHDAzM+O3335j+vTpVKxYkdGjR8v2/29DqfuNj4+ne/fu3LlzB5VKhYmJCYUKFSI+Pp7ExEQ0Gg3ly5dnz549QlI9DRw4kKCgIMaPH0/37t0B2L17N+7u7jRu3FhWz+bcMCbrcw7KDcydO5edO3dStGhR6tSpg4mJiU4dODlryivdlv9rZHUkfNOwlfW7HPPg6tWrWbFiBQA7d+4kOTmZgQMHolKpsLa25tmzZ9y7d49+/foxa9asj5KVm3BycuLu3bt4eXlRt25dAC5dusSgQYOoXLky+/btk1VebuhDGRkZ7Nu3j+DgYFQqFba2tnTs2PGj66q/T+aff/4pGQGyqhNERgnrC205CC0HDx4kOjpaMjZlRavwkoPcMOfqm0mTJnHgwAEaNWrE2LFjqVWrFgULFuTVq1fcvHmT9evXc/ToUbp27SpL6Z5du3axbNkyXr58iVqtxsXFhQkTJgjLxpQVpceLR48e0a9fP+7du6fjaFGhQgW2bt0qa/Sf0vf6Ji9evMDX15edO3cSFRUFiE1nHBYWRmhoKCVKlKB+/foULVpUSKrfc+fOMWzYsHdGfWk0GqpVqyZbrczcME4NGjRIqkuaEyIycAUHB+Pq6ioZat9EZHsC/cz1ueHd6puGDRui0WjYv38/ZcqUISoqih49elCgQAHOnTsnVPavv/76Tud9kW1qyJAhhISEkJycTOHChXUc2lUqlRRkICdWVlYYGRmxbNkyKleurLO/BfRSRiAr6enpnDp1KkedqBwoUdtdSVatWsXo0aOzjUkPHz7ku+++y1aaSg7S0tLYsWNHjnqikJAQTp06JbvMPD6ePEN0Hp80+/btY82aNdy6dYs2bdrQunVrbt68ydSpU2WVkzXK710RyaKNaEowffp0fH19pcVo1iGjcOHCUmoTuRg2bBgRERE8fvwYIyMjnc2pWq2mePHijB07VtiCIQ/xXLx4kZ07d3Lo0CGSk5OlNlW9enUGDhz42dV81edCX4n+Y2FhQZ06ddi0aRP16tWjTZs2/Pzzzzn+Vu4IT6XGi2fPnjFv3jyOHj2azduyRYsWfP/998LSef39998MGTIkx8is9evXy167S+kxWd9zkNLoe42hZFv+rzFt2rQPThH2sQaXDh06cPfuXTw9PWnSpAmzZs1i9+7d1K5dmz179hAfH4+9vT1FihThyJEjHyUrN2FlZYWNjU02h5xBgwZx6dIlIbVIlexDycnJDBs2jIsXL+o4NdSvX59169YJq3G4cOFCtm7dCuQcJfy57YXGjBnD8ePH9XJfSsy5WdNhvw+513F2dnZkZGRw4sSJHDO7pKamYm9vj0ajkWW9rK21+j5ERVUqPee+evWKffv2ce3aNTQaDbVq1cLJySnH9Nkfi9L3Cplr5p07d3LkyBFev34tXYeNjQ3btm2TXV5iYiLjxo3j/PnzALRp0wYrKyt27NjBli1bqFChguwy58yZQ0REBBcvXqRo0aI62d20aVGHDRuGtbW1bDKV3hvUr18fyJyLatSogaGhoc55EQYtFxcXQkJCKFq0KHFxcZQpU4bnz59L6e3fdGCSE33O9Uq/W31Tp04dGjduzPr166VjgwcPJjg4mCtXrgiVbW9vz+PHj+nZsydbt26lf//+3Lp1i4CAACZOnMjIkSOFyVZCp+3o6Ejp0qUVy+ajb5Ss7a4E5ubm1KtXj6VLl0oZbP744w8WLlxIQkKCkPv94Ycf2LJlS456IrVaLTTdex7/O3mpufP4ZPnjjz+YNm2azsB+9epVtm7diomJiawReT/++CPlypWTPv+XOH36NMWKFWPevHlMmjSJBQsWEBMTw4oVK4TUttUuAlu3bo2dnR3ff/+97DL+yzx48OCDfytnPbaXL1/i6+vLrl27iIiIADKVl/nz5yclJYXq1avLHqmUE8HBwXh6ehIaGkrDhg1xdnbm8ePH2eofyYlWGQGZEQLx8fHSd7nrlijRf0qVKkVYWBg2NjZAZs3onJQdIpR6So0XJUqUYOXKlTx79owrV67w8uVLChUqRJ06dShTpoxQ2Y0aNcLDw4OffvpJ6ktVqlRh4sSJshuhQfkxWd9zkNKMGTNGr/WMlGzLSjF27FhsbGwYOnSoXuUuXrxYb7Lu3btH/fr1pTEhICAAlUqFg4MDACYmJlhYWHx2jhxFixYlKiqKlJQUyaiVnJzM7du3hUXdKdmHfvnlFy5cuECZMmWkd3vkyBEuXLjAypUrmTJlihC5R44cQaPR0KJFC2rUqCEs9aA2cvFD+PLLL4Vcg75RYs79UAOViHXcixcvaNSo0VvLixgZGVGrVi1ZI9M+JA5DVKyG0nNuwYIF9RaFpdS9xsbGsnfvXnbt2kV0dDTw/++zdOnS/Pbbb9SpU0eI7KVLlxIQEEDdunWljD1xcXE8ePCAn376ScpUIifaMWLAgAE0aNCAb7/9VnYZb6L03qBEiRJ88cUXtG/fXm8yb9y4Qc2aNfHx8aFZs2asXLmSYsWK0a1bt2yGcLnR51yv9LvVN+np6dkM+QULFiQ9PV247EePHmFra8vs2bM5e/YszZs3Z9asWbRr147jx48LNUSLiE59H5MnT2batGkEBwfToEEDvcvXN7a2tkpfgl4pW7Ysly5dokuXLnz33XcEBARw6NAhNBqNlKVKbg4dOoSxsTFjx45l6dKlTJw4kejoaHx8fJg2bZoQmXl8PHmG6Dw+WdauXUuRIkXYvn27VIfAxcWFP//8Ex8fH1kN0V27ds3x83+BuLg4mjZtiqOjI56enhgZGTF69GhOnz7Nzp07GTx4sBC5x48ff+u5yMjIz7KW85s1h7TIaRBu06bNB/1ObmVTixYtpHszMDCgcePGODk5YW9vT4MGDfRSP+X06dN88803pKenSx5zFy5cwMvLi3z58gmrpaLEQl+f/Wf06NHMnz+ftLS0bJ6IWRGZgEWp8aJEiRK0bNnynb+ZM2cOAQEBHD16VDa5zZs3p3nz5sTFxaFWq/VSJ1mpZ6zUHKQU48aNU0SuUm0Z9JfCUsv58+eJi4vTuyFan+TLl4+MjAwAbt26xYMHD1CpVDRs2FD6TVxcHAULFlTqEoXQqlUrdu7ciYuLi6Sg9vPzkyJORKJEHzp48CCmpqb8+eefFC1aFMh0ZunYsSMHDhwQZoh+9eoVdevWxdPTU8j/a/nQOnOioleVRJ9z7oeuz0Ss49LS0t473hsYGMhmFBCRsvd/QYnxIikpiQ0bNrw1pb6Xl5csct5En/c6YcIEjh49SlpaGhqNBrVaja2tLU5OTsyePZsSJUoIM0JDpnHQzMyMHTt2SBGHU6ZM4cSJE+9MJS0HderUwdHRUaiMN1Fqb6CtPa7P+rbp6emYmppiYGCAhYUFYWFh9O/fH2trax2ncxEoMdcr9W6fP39O8eLFhfz324iNjeXs2bM63yEz9X3WcdLOzk5WuQULFuTFixcAknNoy5YtMTU1FT5XZd0PPHr0CJVKRenSpWWX8+YzS0lJYcCAAXpLB64k/5XIby379+9n8eLF7N69m7lz5wKZtbnHjx/PwIEDhch89uwZTZo0YejQofj6+vLll18ycuRIrl69yp49e4TJzePjyDNE5/HJEh0dTaNGjahatap0zMzMjDp16giP8AgLC2PTpk3cvn2bfPnyYWZmxvDhw4UbR4ODgwkJCcnRWCkqMqxYsWJERkaSnJyMhYUFJ06coG3btrx8+fJfRdf+Wx49esSiRYtyrPcQFxcnTOGkrTuampqa7RmL8mq7ePEi06ZN4+7du9nOya1c+xAlUv78+SlRooRsMiEzIkmlUpE/f35cXV3p3bu3XuqxZWXFihUYGRmxYsUKRowYAWQa5r29vfHy8hJmiE5ISKBly5bZ6uCIRJ/9p2fPnnTq1InY2Fhat25Ns2bN9O49rdR48SE8e/aM+/fvy/JfQUFBWFtbS6kxixYtyvXr1ylYsCAVK1aURcbbUOoZKzUHKUl0dDSbNm0iNDQUCwsL2rdvT3JyMq1atVL0uuRsy5BzCst79+4JTWEJmanhjh07plcFpr6pUqUKISEhBAQE4OPjA2T2pXr16gGZWYWuXLkizEMdMqOyL1++TEpKSrZzXbp0ESJz4sSJBAYGEh4eLinxtPUM5azl+78idx96+vQpDRo0kBTTAMWLF6dmzZpcuHBBNjlv0qFDB86fP096errQtY1SBtI3U1VrnTqypvbVIneqai36nHOVrvX5phHgTZ49e6bHq8k9yD1ezJkzh/379+fYX/SZiSUn5LpXf39/VCoVRkZGfP3113Tv3l0yrsyePfuj//99xMfHY2Zmlu24iYkJMTExQmVv2rQJLy8vatSoQbdu3ejUqROmpqZCZSq1N9i5cycGBgb07t0bY2NjHac6UQatChUqEBISIu3FvL29KVKkCKGhoUKdrUGZuV6pd9uiRQu++uorunTpQsuWLfUSrBASEiLphrIyfPhw6bMIhzcLCwsCAgLYtGkTDRo04KeffuLKlStcvHiRUqVKySorJ06dOsXChQu5d+8ekJnSfsaMGe91HPo3PH36NMfjorME5kRaWhqRkZGo1WqqVq2qF91cWloaR44cITQ0lAoVKtCsWTMKFSokNCtIREQERYoUoXTp0nh7e3P69Gns7Ozo06ePMJmQ6VhRqVIlDA0Nef36NZC59zQzMxP2fosUKSKtHerUqcP58+dxcHBApVJx+/ZtITLz+HjyDNF5fLKUKlWK8PBwnc3prVu3CAsLEzqw+/n5MXnyZDQajbQgu3z5Mvv27WPVqlV89dVXQuT++uuvrFq1KttxbWpyUYbo5s2b4+vri4eHB40bN2bChAkcO3aM5ORkqlSpIkQmZNb8eVvdQlFyjx07xrRp00hISMh2TmS0xU8//cSdO3dyPCf3xuaff/6RPp84cYLx48czd+5c7O3tUavV+Pn58cMPP8i+Wbe3t+fkyZOkpKSwbNkyVqxYQYsWLfSeUsvW1pbmzZtLx2xtbbGysuLSpUvC5I4ePZoSJUrg5OREly5dqFWrljBZWvTdfwoUKED58uXZvHkzpqamwgxIb0OJ8UKfZGRkMHHiRA4dOoSXl5eOF7OHhweHDh1izJgxsmYCeROlnrFSc5BShIWFMWjQIJKSklCpVJQvX55z586xYcMG3N3dadu2rdKXKBtKpLCETEN/fHw8vXv3xtDQkMKFC6NWq4HPxyO/R48eLFiwgGHDhgGZ9zVw4EDUajWurq4cOXIElUolzAFr586dfP/992+NYhRliC5WrBh79uxh+/btBAcHo1arsba2pnfv3joK3M+FChUqEBYWxp07d6SamLdv35YUXqKoUaMG/v7+dOvWDVtbW4yNjXWUTBMnTpRFjlLRq29LVf2m44rIvYE+59wPbStZlcZy8jYjgJa31VfM499x7tw51Go1vXr1EppSX0kMDAxIS0sjNTUVT09PIiIi6Nixo87eTyS1a9cmODiYjRs3AplGGDc3N0JDQ6USRqLo3bs3x44d4/r16yxevJilS5diZ2dH165dad26tZD00UrtDQIDA6XPr1694tWrV9J3UWPF4MGDpSjstm3b4uHhwdSpU6UyFSJRYq5X6t1qDXdHjx6lWLFikv5EVCYDOTMP/lumTp3K8OHDKVSoEI6Ojqxdu1ZyzhWdxScwMJDRo0frrNOjo6MZM2YMGzdulC0AR4nMgDmxZs0aNmzYQHx8PG3atKFJkyb8/fffLFu2TJhD4ZMnTxg6dKhUSq1Nmza8fPkSLy8vNm/e/M463f8rJ0+eZOzYsSxatIgvvvhCikw+fvy40H0fQPfu3aV1e//+/YmKiuLcuXMMHz6cbt26sWjRItllNmjQgCNHjrB69WoaNmzIzJkzOXfuHHfu3JFKq+aR+/j8Vp95/Gfo1asX7u7utGzZEpVKxalTpzh+/DgajYYhQ4YIk7tixQoyMjJwcnLCwcEBtVrNkSNH+PPPP1m2bJkwQ/TevXvRaDRUr14dMzMzvW0eZ86cSWJiItWrV6dt27Y0bdqUgIAADA0NhUaXBAYGUrZsWVatWkXfvn359ddfiY2NZcaMGXTs2FGIzBUrVhAfH49araZ48eJ6e8Y3btygePHieHh4ULNmTaFys3r+LV26FBsbG52Fbp8+ffDz82P58uWyRt+tWrVKqtm1e/duoqKipE2GSqXi2bNnXL58GUtLS9lkvkmRIkWIiooiOTlZOhYbGys9f1FUrVqVW7duSYvO6tWr061bN5ycnChZsqQQmUr0H63cdyHKYUap+9UXmzdv5uDBg6hUKu7evatjiI6JiSE9PZ2VK1dSpUqVD05l+m9R6hm/aw6aMGGCMLlKsXTpUl6/fs28efOYN28ekGn8UKvVrFmz5rMyRCuVwjJr9EhqaqqUgg+UjwqTi379+vH8+XO2bt1KRkYGvXr14ptvvgEy1wFqtZpRo0YJMwhv3LiRtLQ0ihcvTsWKFfW2nlq4cCH169dn2LBhkhH+c6Zbt264ubnRuXNn6tevD2S27+TkZGHvFmDBggWoVCpevnzJjRs3pONag6FchuicSE5O5urVq6hUKmrXrv3W2sIfg5KpqrUoNecmJCTw66+/5hgFFxERITkNyYWSRoD/IjY2NpJi+nPkzJkz/PHHH/j4+HDz5k0OHDiAn5+fVMImLS1NqPzJkyczdOhQlixZgkqlIjQ0lJCQEAwMDISXXpk/fz7z5s0jMDCQgwcPcuTIEU6ePMmpU6coUqQIHTp0oF+/fjlGbP+vKDVOKWHc6tWrF6VKlaJMmTKYm5uzcOFCNmzYQMWKFYVH2ysx1yv1bs+cOcOhQ4c4ePAgFy5cYMuWLfz++++YmZnRtWtXnJycZE0h/a4U5KL54osvOHr0KMnJyRQpUoRt27bh7+9PxYoVsbe3Fyp75cqVpKenM2nSJHr16gWAt7c3bm5urFixQra00ll1FkqxceNG3N3dMTY2lo7dvHmTw4cPs3z5cqZPny5E7uLFi4mIiKB9+/b4+fkBYGhoyMuXL1m6dKlUj11OVq9eTUZGBgYGBuzbtw+1Ws348eNZvXo127ZtE2qIDg8Pp2TJkixevFhKyb5lyxaWLVvGnj17hBiiZ86cyf379ylXrhzt27dn8+bNhIeHA7zTwTEPZVFpROcRySMPQWg0GpYvX86WLVuktH/58+enb9++TJkyRYpukRsrKyvMzMzYs2ePzvFu3boRGRlJaGioELn16tWjcuXK7N27V1FFqUaj4erVq5QtW1b29M1ZsbS0pHHjxqxduxYXFxdcXFzo0qULAwcO5MGDB7LXqASoW7cuxYoVY9euXXpJh6PF2dkZU1NTNm3apDeZkNmWS5YsycGDByVPwMTERDp06MCLFy+EtWXITEe+a9cuDh48KEX+QWZKld27dwuRuXjxYjZt2kTJkiV59uwZJiYmaDQaEhISGDBgADNmzBAiFzJT5Pj7+3Pw4EEiIyNRqVTky5cPOzs7OnfujIODg6yKeiX6D4C5ufk7xyftwlBulLrfD2HMmDEcP378o+7d2dmZiIgIfvvttxzTZXl7ezN37lxsbGzYtm3bx1zuW8ktz1hfc5BS1K1bl3r16rFx40bMzc2xt7dn1apVDBgwgMuXL8tuBPg3yNGWs2JlZUW9evXw8vLSudfevXtz48YNYZkq3ucwI1ppojXWPXnyhNDQUKysrITUZXsbkZGRlCxZUmiEcL169ShdujS+vr46ih/R2NjYULNmTbZv3643mf8GuftQeno63333HQcOHNA53rp1a1asWCHMAWDatGnvnOt//PFHIXJ37NjB0qVLpei3QoUKMWXKFHr37i2rnH+TIlhUNJpSc+706dPx9fWVxqmsqqLChQsLL3+Vx/8j93jx888/4+vri5+fH4UKFZLlP+VC7nsFCA0NZdeuXfj7+5OYmAhkOptVq1aNPn360K9fP9lkZeXatWusX7+e8PBwDAwMqF69OkOHDtVLRiwtiYmJHD58GHd3dx49eiQdNzAwYOnSpbJlJMstewN9oHV002c2Ny1KzPW54d0+e/aMgwcP4unpyePHjwFQq9W0a9eOefPmSQ4mnypt2rTB2toaNzc3vcuuV68eNWvWZMeOHTrHXVxcuH79urA92NWrV1myZInkFGxra8uUKVOEjo9t27YlKSmJ/fv306hRI+zt7fn+++9xdnZGrVZz+vRpIXIbNWpExYoV2b17t84+t1u3bty5c0fIeqp+/frUrl2bLVu20K5dOwoUKICvry/Dhg3j0qVLXLx4UXaZWkaPHs2iRYuyBfjcunWLqVOnsmvXLmGyU1NTMTIyIjExkXPnzlGxYkW9zrl5/DvyIqLz+GRRqVRMnjyZMWPGEBERgaGhIZUqVdKpESMCKysraTOjRaPRkJycLNXeE0HLli25deuW3o3Qbdq0wc7Ojvnz5wOZz71OnToMGzaMmJgYybtLbkqWLEl4eDiPHj3C0tISf39/mjRpwr1793Sil+TE3NwcQ0NDvRqhIVOhN3bsWPz8/GjatGm2NiwqXYylpSUXL16kU6dONG/enIyMDM6ePcvjx49p1KiREJlabGxssLGxYdasWRw4cAAfHx9CQ0N1UofLzcSJE3n06BH+/v4AvHz5EshcnIqOrDQzM2PcuHGMGzeO06dPM3v2bB49esSpU6c4deoU5cqVY/Xq1bKl6FGi/wA4OTlJY5RGoyE1NZXr16/z9OlTBgwYIEyuUverL27fvo21tfVbazb17t2bnTt3EhkZKewalHzG2kis1NRUSSl+69Ytbt26JVvqsNxC/vz5efjwoY7yPyUlhbt37wpf3+gbpVJYvsvQLCr1LGSmaBs3bhyjRo3CysoKJycnXr58SZEiRdi4cSO1a9cWJjsr1apVEy7DxsaGhIQEvRqhIfPdXrlyhSdPnuh9LacE+fLlY/ny5QwZMoTg4GBUKhXW1tZCa39DpmOfvjl8+LCUJaJw4cKSI+G8efMwNTXFwcFBNln6Li+SE0rNuadPn6ZYsWLMmzePSZMmsWDBAmJiYlixYoWwrDb6pGvXrlhYWLBgwQJWrVpF1apVhWWSyW2o1WqSkpJwdHTEwsKCggUL6ugVli9fruDVyY+1tTXW1tbMnDkTPz8/du/ezaVLl4iIiGDhwoXCDNHm5uYsXbpUyH+/i5SUFI4fP46fnx+nT5+W1sxly5alc+fOXL9+nZMnT7Jy5UrZjKn6HKfc3NwwMzPD2dn5nYY7lUolZF+/Z88erl69qoghWom5Xum99fXr1/Hz88Pf35/Hjx+j0WjInz8/KSkp+Pn5kZ6ejru7u/DrEEliYiJPnjxRRLahoaFOSnstiYmJwnSP165do1+/fiQlJUnHAgIC6Nu3L9u3bxeSqhrgwYMHNG7cWMcB19TUFDMzM6GG2ZSUlBxLIqSnpwvNqGNoaMiTJ0+4ffs2ffv2BTL3tyLKM2Rl9erV0ueEhARSU1MxNTWlatWq2Rwe5CYhIUHK4mNhYQFkvve8rDu5kzxDdB6fNEFBQTx69AgnJycA5s2bJ6XulJOzZ89Knx0dHVm8eDFTp07F3t6e169fs3//fp4+fSo0LU+7du2YM2cOo0aNonHjxtnqsckZDXD06FGpvsP9+/cJCgrSqU+dkZFBeHh4NoO8nDg6OrJp0yZ27dqFnZ0do0aNktKei/JumjNnDkOGDGHt2rU0bdo02zP+8ssvhcidPXs2Go2GSZMmZTsnsv7crFmzGD58ONHR0URHR0vHK1SoICn7RFOoUCF69epFr169uHnzJj4+PsJkGRkZ8fPPPzNhwgSuXr2KgYEBNWrUkGotieTp06f4+/vj5+dHaGgoGRkZQGb04927d3nw4AHff/+9bNGsSvQfgGXLlmU79vr1a3r27PnWWqFyoNT96gtDQ0OpzbzrN6mpqcKuQalnfOzYMaZNm0ZCQkK2cyLHR6Vo3bo1vr6+dO3aFcisGe3k5MSjR4+EptpVAqVSWOo79ayWxYsXExoaSlRUFNeuXSMuLo5q1aoRGRnJihUrWLNmjRC5SjBixAhcXV2ZN29ejuspbco2ucmfPz/Pnj2jVatWfPHFF5iYmOiUJBGtCFEKCwsLLCwsSE9P17lfOYmKiqJQoUKULl2aqKiod/5WxHrZw8ODfPnysWzZMskQ4Ofnx+TJk/H09JTVEJ0bUGrOjYuLo2nTpjg6OuLp6YmRkRGjR4/m9OnT7Ny5k8GDBwuTrQ8iIiIoUqQIkFk2yMHB4T9jiP7tt9+kzydPntQ5p1KpPjtDtBZjY2O6d+9O9+7duXXrFrt27eLPP/+U7f+z6kjeh0hnjiZNmpCUlIRGo8HQ0BBHR0e6d++OnZ2dNP/279+fy5cvyyZTn+OUp6cn9vb2ODs74+npmWNwhjaTgwhDdG5wdNPHXK9FqTno119/xc/Pj1u3bknrc2tra7p3706HDh2Iiopi5MiRnDt3Ttg16Itx48axZMkS1q1bR4MGDTAxMdHJ6ilK9wiZDqOnTp1izpw5dO/eHQAfHx8iIiKElZr8+eefSUpKwsXFRScduLe3N+7u7sL2QRUqVCAkJEQKeElLS+Ps2bNcuHCBihUrCpEJmdHJAQEBLFy4EIC7d+8yadIkbty4Ibu9QsuXX35JcHAw48aNQ6VSYWdnx5o1awgLC6NJkyZCZGZl3759rFmzhlu3btGmTRtat27NzZs3mTp1qhB5Fy9eZNq0ady9ezfbuc9RT/S5kGeIzuOT5ejRo3z77bc0a9YMJycn0tPT2b17N7t27eKXX36Rta7G8OHDsy12//zzT51NjEajYdiwYcIGu/Hjx6NSqTh9+nSO6UPkNESXKVNGUgKrVCqioqL49ddfdX6T1dtIBJMmTUKlUmFpaUnLli3p3r07Pj4+FC1aVFgKZe0izM3NLZunrciJ7F0pAEV6y9WqVYvDhw/z559/cvv2bdRqNWZmZnTq1EmYJ+S7qF69OtOmTRMup2LFilSqVElKi1qgQAGhaVEHDRpEcHAwGRkZaDQaSpUqRZcuXejevTtVqlQhKSmJbt26yZqOTon+8zYMDQ0xMzNj7969OTpbyEFuul8RmJubExoaSlhYGFZWVtnOh4WFceXKFerUqSPsGpR6xitWrCA+Ph61Wk3x4sX1VmtWKWbMmEFUVJRkDNWmorOwsGDKlCkKXpn8NGjQgJ07d+o9heWiRYvemXpWFH///TcVK1akd+/ejBo1ilKlSnHgwAG6desmq2I4NzB48GBUKpWkYMqKyPXUoUOHgEwl0+3bt7PJ/Vw4ceIEP/zwAx4eHlStWlU67u7uTmhoKLNmzaJGjRqyyuzQoQP29vZSNN3bnqeo9xsREYGNjY1ONFqHDh3Yvn270FIySqHUnFusWDEiIyNJTk7GwsKCEydO0LZtW16+fMmDBw+EydUXRYsWJTAwUFLInj59OkfHGJVKxZkzZ/R9eUIZM2bMZzUO/i9UrVqVqVOnyrofWbVqlc5zfXPvrl1nqFQqoYboV69eYW5uTrdu3XB2dqZYsWLZflOzZs0cj/+v6HOc6tKli6R76tKli97bshKObkrM9VqUmoNWrlwJQIkSJXB2dqZHjx46mXwsLS2xtbX9LAzRCxYseKsTkGgj2vjx4/nrr7/YtWuXlDJZo9FgZGQkzBk4ODgYc3NznYCX+fPnExISQlBQkBCZAMOGDWPOnDn06NEDlUolZSTUaDTCMmNAZtbL/v378/vvvwOZUf7Xr1+nUKFCTJ48WYjMUaNGMX78eEJCQrCwsKBFixb4+/tjaGjI6NGjhcjU8scffzBt2jRpvoPMVOxbt27FxMREiPyffvqJO3fu5Hgurwpx7iWvRnQenyzdunXj+vXrTJ8+nf79+5OWlsbmzZtxc3OjVq1astYgaN269Qf/9vjx47LJzcr70tpu2bJFVnkeHh5ERESwb98+ypYtq5P+VK1WY2pqSu/evalSpYqsct/F8+fPKVq0qLD63+9LB6ONEpeb99Wi00eKwEePHqFSqfRap1LfvJkWtWPHjsTFxQlPi2pubo6BgQFfffUV3bt3p2XLltnasKurK8HBwQQEBAi5BhDff4BsBof09HQePnyIl5cX+fLlE5r+6E30cb8fwuzZszl37txHzQ0HDhxg0qRJmJiY0LdvX6ysrChUqBAJCQmEhITg7e1NQkICP/74o16jZvXxjOvWrUuxYsXYtWvXfyLVrpbz58/rZG7Qhxfz+5CjLecGmjVrRkZGRo6pZ6dNmyYs4s/KyoqmTZuyYsUKbG1tadmyJStWrGD48OFcuHBBWD02JXjfullUG9q7d+87z2szDSiFHH3owoULDBgwAI1Gw7x583QcUR0dHYmOjqZo0aJs375dR3H9sWStb6fEerlJkyYUKVIEf39/ac5JT0+nffv2JCQkCF0/5Rb0Medqa0R//fXX1KhRgwkTJmBsbExycjJVqlSRytt8qvz666+SoeNNR6SsqFQqWR1E/xc+lzn3Q/iU79Xc3ByVSkXhwoWpX78+tWrVemu0qkhD9D///JPNITWrQUBf5Jb9l9y8a94TMV4oNde/C32826+//poePXrw1VdfvdX5OCgoCENDQ+FlSESjlO4x6////PPPBAcHo1arsbKywtXVFWtrayHy6tevj5mZWTZ9Ua9evYiMjJTqRotg+/btrFmzhkePHgGZgVcjR44UaoiGTIfybdu26Thc9+3bV6jONTIykjt37khZVE+dOoWpqSmWlpbCZEJmib4nT56wfft2yXl1/Pjx9O3bFxMTE44dOya7zHr16lGgQAE8PDyoWbNmtjFDdOaIPP438gzReXyy1KtXD2trazZt2qRzfPDgwYSFhenV4PE5M336dGrXri20vmtW0tPT2bdvH23bttWphxkcHIxGo/ns6oEqzalTp1i4cCH37t0DoFKlSsyYMeOttWg/ZSZNmoSfnx9TpkwhJSWFX375RUqL+tVXXwlJB/TixQt27NhBr169MDU1JSAggPDwcMqVK4e9vb0UeR4XF5ctHdP/gtL9R6uMeRONRoOzszNLliyRVZ7S9wsQGxsrpfh9EznTzy5cuJDff//9rc+3R48eUuonOVH6Gbu4uGBoaCi7s1Vu5+7du0RERKBWq6lWrRpffPGFcJn6astaMjIy+PPPPwkNDdVJkQ2ZSr0ffvhBdpmQGV3etGlTPD096d69O0OHDqVjx464uLjw8uVL/Pz8hMht3bo1Go0GFxcX3N3dmTVrFnXr1mXAgAGUK1eOAwcOCJGbh/7QRx8aOXIkp0+fxsnJie+++05HmfXPP/+wdOlS/vrrLyFzrpJo13DNmzeXHK727t3L2bNn6dChw2eTVljpOTchIYEZM2bQrl07HB0dGTFiBAEBARgaGrJ8+XLatm0rVL4+iI6O5vHjxwwYMID69evz7bff5vi7hg0bCr0Ofc+5kLnf2LVrF6GhoVSrVo02bdqQL18+Yc64WpS4V33RvHlzqc6r1iDdoEEDGjVqRKNGjfRaImj16tWkpqYyfvx4INP5qlWrVri6usoqR+lxCjIznxw5coTQ0FAqVKhAs2bNKFSoEGXKlBEiT9+ObkrN9bnh3eYhngMHDmBra6vXIJSBAwcSFBTE+PHjpUyUu3fvxt3dncaNG2fT64sgNjYWQ0NDTExMhMvKSmJiImq1GmNjY73Ie/r0KWFhYRQsWBALCwuhGb+0WFpa0qhRI9atW6fjvKqtbS8i+5ezszOmpqZ6aTt5yMfnnd8wj88aIyMj7t+/r1MjJTU1lTt37ugldWdwcDDBwcGoVCpsbW2xsbGRXUZqair58uUjX7587639KSqV8o8//ghkTtpv1lIMCgqiT58+sslKTk5m6NChXLp0iZIlS+psTNevX8/Jkyfp1q0bCxcu/ORTi02aNAlLS0sGDx783vRgopRrgYGBjB49Wqd2b3R0NGPGjGHjxo2f3UZDn2lRU1NTmTFjBn5+fuzYsQNTU1NmzpzJnj17pN+YmZnh5eWFqakpRYsW/WiZuaH/5NRmjI2NsbS0ZNiwYbLKyg336+fnx7Rp03j9+nW2c3Kn1Jo1axZNmzZlx44dXLlyhZcvX1KoUCFq165Nr169dNKVykVueMZz5sxhyJAhrF27NsdasyLrZylBQkICs2fP5uDBgzrHO3bsyPfff6+jFJITfbZlLT/88ANbt24Fck5lKcoQrVTqWUdHRzZu3Ii7uzv58+fHwcGBuXPn8urVq8+u/rdSaDQa/P39uXDhglQrU4vINgX660MhISFUqFCBJUuWZHNeq1OnDh4eHtjb2xMcHCyLvHeRlJQk7bsqVqwotKzLxIkTCQgI4PTp01LKZI1GQ5EiRSSji1y8Ga3zLuQsjZQb5tzChQuzYsUKHblXr16lbNmylChRQohMfVO5cmUqV67Mjz/+SLly5YQbnHNCiTn39u3b9O/fn2fPngH/Hy27fv161q1bJ+w5KHGv+uTMmTNERkby119/cf78eQIDAzlx4gQnTpxApVJRpEgRbG1tadSokVDHfk9PTynjCmSOJ+Hh4Vy7do0CBQowcuRIWeTkhnHqyZMnDB06lIiICADatGnDy5cv8fLyYvPmze+NNP1f0HdGFSXm+tzwbu/evcv8+fO5cOECycnJOuc+h/EiJ5QwGs6dO5dy5cqxb98+4bK0jBkzhiFDhuDu7o67u7t0XK1WM2rUKL1cg6mpqV7kaNm+fTuenp48fPgQgPLly/P111/Ts2dPIfLS0tKYP38+e/bsISMjgzZt2lC/fn38/PxYu3atrKUZ3qRUqVKEh4dLawyAW7duERYWJsxBaNq0aYwdOxY/Pz+aNm2aTU+iRLnJPN5PniE6j08WOzs7/Pz86NKlC40aNSI9PZ3z588TExNDu3bthMlNT09nypQp2VKTdejQgaVLl8qaqsba2lqqx/auFCkiF2XBwcG4urry/PnzHM/LaYj28PDg4sWLGBsbEx8fr3POyMgItVrNnj17sLS0xMXFRRaZLi4uNGzYkIkTJ773P+Ws/XPgwAFSUlIYPHjwO6Og3lY3Rg5WrlxJeno6kyZNolevXkCm8s3NzY0VK1YIjUA8e/YslSpVolKlSri5uUk12iZOnCgs3dPLly+xsLDA0NCQy5cvS1HfpqamREVFySpr3bp17N+/X/oeGBiIj48PKpUKa2trnj17RkREBKtXr2bWrFmyyFSi/7yJPqNWc8P9urm5kZqaSoECBShevLhwB5nWrVv/q1IRH0tueMZaj2k3Nzfc3Nx0zn2OComFCxfi7+9Pvnz5pFR7UVFRHDhwACMjI2GGNH23ZYAjR46g0Who0aIFNWrU0Fv97+bNm+Pr64uHhweNGzdmwoQJHDt2TEo9K4oJEyZgYGBAdHQ0/fv3p3Tp0pibm1O5cmWGDx8uTK6+sLOzo2XLlixatOidEW4ia68uWbJE8orXp3MD6K8PaR0o3rZWyp8/P2ZmZkJTHKakpPDTTz+xc+dOyZnRyMiIwYMHM27cOCF9uUKFCvzxxx+sWbNGJ43kiBEjqFixoqyy5s6d+8HvT05DdG6YcyHnSMO0tDRh8pSia9euxMTEMHPmTMmY07BhQ8aMGUPZsmWFylZizl28eDGxsbEMHz6ctWvXAlC2bFlev36Nu7s727ZtEyJXiXvVoq+o2WrVqlGtWjX69etHRkYGV65c4dSpU2zZsoW4uDiOHj3KsWPHhBqid+3ahYmJiVR7tECBAuzevZuhQ4fi4+MjmyE6N4xTixcvJiIigvbt20tZbAwNDXn58iVLly5l/fr1sstctWrVW8+pVCrGjBkjqzwl5vrc8G5nzpxJYGBgjuc+t2SuShoNK1SoQEZGhrD/z4lGjRrh4eHBTz/9JDmRVKlShYkTJ+aKElRy4+Hhgbu7u067vX//PnPmzOHFixeMGDFCdpkrV65k165dlC9fXnKuvnv3LpcvX2bJkiVC90G9evXC3d2dli1bSrW4jx8/jkajYciQIUJkzp49G41Gk2Ng1+eoJ/pcyDNE5/HJ8t133xEaGsrNmzeJiIiQBvgKFSowdepUYXLXrl2Ln58fxsbGNG7cGIC//voLPz8/atasKdsiHzIXW9r7etfCS+SibNmyZcTGxlK0aFHi4uIoU6YMz58/JzU1VXaDv7+/PwYGBmzdujVbirBffvmFU6dO8fXXX7Nz507ZFr8hISGULFlS+vw25N40jx07VjIyjBkzRpEI7ytXrlC3bl2dRdDIkSM5fvw4V65cESbX19eX6dOns3DhQqKiovD09ATg+vXrmJiYCPOILFmyJNevX2fjxo2kpqbSqFEj/vnnHy5evEj58uVllbV//34MDQ3x9PTEyspKMjbXqlWLHTt2EB8fj729PadOnZLNEK1E/8mJtLQ00tLSKFCgANevX+evv/6iUaNGsnun54b7ffLkCdWrV8fHx+ez9LjMDc9YqblPKQ4fPoyJiQnbtm2jevXqQKY3sYuLC4cOHRK2gVSiLb969Yq6detKc4C+mDlzJomJiVSvXp22bdvStGlTKfXshAkThMkNDQ2lc+fOmJmZSce+/fZb/v77b06fPv3Jl8R4+vQpcXFx0ue3IXK9o8064uDgQJUqVfRao1JffahcuXKEh4eTmJhIoUKFsp1PTEzk2rVrlCpVStg1LF68mO3btwNQsGBBVCoViYmJeHp6kpqaKmwfVrp0aebMmSPkv7OiVEag3DDnKhFpqBT37t2jd+/exMbGSuuJ6OhoTpw4gbe3NxUqVBAmW4k5NzAwEBsbGyZNmiQZonv37o2vr6/QethKrZWVaMvh4eGcO3eO8+fPc+HCBZ1U5KKjHB8+fEjDhg11ghcsLCywtLQkKChINjm5YZw6e/YsderUwc3NTTJEjxw5koMHDxIaGipE5qpVq965fpHbEK3EXJ8b3m1ISAiFCxdm2bJlVK5c+bOu8aqk0bBFixasX7+eTp06Ua9ePUxMTKRnrVKphO2HmjdvTvPmzYmLi0OtVus9RbY+2bJlC2q1mtmzZ0t68yNHjjBv3jw2b94sxBD9xx9/ULFiRQ4cOICVlRWQGTV88uRJTp48Kbu8rIwaNYqEhAS2bNlCWloar1+/Jn/+/PTt25fRo0cLkXn//v23nvsc9USfC3mG6Dw+WcqUKcOff/7Jvn37uHbtGhqNhlq1auHk5JTjYk0u9uzZg4mJCXv27JE88O/cuUO3bt3YvXu3rIboY8eOSXUkjh07Jtv//htu3LhBzZo18fHxoVmzZqxcuZJixYrRrVs3DA0NZZV1//59bGxs3lqnqmXLltSrV48bN27IJlOblk37WV+MHTtW+jxu3Lgcf5OSkpLNG1VODA0NefXqVbbjiYmJQhUFGzZswMDAgJIlS3Lw4EEMDAxYsmQJ8+bNw9fXV5ghWp9pUe/du0f9+vUl786AgABUKhUODg4AmJiYYGFhIWs6LSX6z5vcunWL4cOHM336dGrVqkXPnj15/fo1BgYGrF27VnLekYPccL9Nmzbl7t27ejV26JPc8IyvXbsm7L9zI8bGxtSoUUMyQgNUrVqV2rVrS8pUESjRljt06MD58+d1SqzoA6VSzw4YMAAHBwdWrlypc3zlypVERkZy/vx5YbL1webNmylevLj0WQkyMjKwtrbWeb/6Ql99yMHBgXXr1uHq6sqcOXOoXLmydC4yMpIffviBFy9e4OzsLOwa/Pz8KFCgAL/++ivNmjUD4Pz583zzzTfs2bNHmCE6NDQ0x7TroLuu/lj0md0lK7lhzlUi0lApli9fzrNnz/jqq6906lWeOnUKNzc3oXXHlZhzVSpVtn2fRqMhNjZW6L5PqbWyvtryrl27CAgI4K+//uLFixfS2FS4cGEaNWpEw4YNadiwIXXq1JFF3tsoWbIkV65c4cGDB5KD9e3btwkLC5PmZjnIDeNUSkpKjnqo9PR0YcYHJycnyRCt0WhITU3l+vXrPH36VEikuxJzfW54t+XKlaN06dJ89dVXwmTkFpQ0GmqdkbRBXVq0JRtEGKLbtGmDnZ0d8+fP1ylLN2zYMGJiYqRx+nMhMTGR+vXr6zht9OzZk3379gmplwzw7NkzGjZsqDOnGxkZUaFCBcLCwmSXV6tWLSmDq0qlYvLkyYwZM4aIiAgMDQ2pVKmSsLJioJyNJI+PI88QnccnTcGCBWVNifYhxMTEYGtrq5MGrlKlSlhaWspejy2rJ7ZIr+x3kZ6ejqmpKQYGBlhYWBAWFkb//v2xtraWXWlasGBBEhIS3vmbN2vFfCxZ6/3ou/aPlqwTeFYGDRrEkydPhE2wNjY2nDp1ijlz5kgKGB8fHyIiIoQu/u/evYutrS0tW7Zk/vz51KlThw4dOrB3716hNQ1zSotas2ZNIWlR8+XLJ6U7unXrFg8ePEClUunUX4uLi5N1YaZE/3mTJUuWEBMTw/3797ly5QqpqanY2dlx7tw5Vq9eLashOjfc7/z58+nUqRNdunShSZMmkuOQlokTJwqVL5rc8Iz/a/Tp04dNmzYRGRlJtWrVgEzjS2hoKK6ursLkKtGWa9Sogb+/P926dcPW1jZb/W85Zb6v/ELBggV5+fIlL1++lLXu+IYNG6Q62JAZxdOmTRvpe0ZGBjExMZ9FREDW+U2JmqsAnTt35tixY6Smpuo9S4W++tCoUaM4fPgw586do127dpiYmFCoUCHi4+NJTExEo9FQvnx5vvnmG1nk5URGRgZ169aVjNAATZo0wdraWpjz0Nq1a7OVZ4D/V5rKaYjOidjYWFJSUiQjx6tXrwgKCpK1RFFumHOViDRUioCAAKpUqcJvv/0mzT1t2rShffv2nD17VqhsJebcZs2aceTIEb7++msg0wDRr18/7ty5IznKikCptbK+2vLs2bNRqVQUKlSIFi1aSIZnCwsLvWY869ixI+vWraNdu3ZUqVKF9PR0oqOjSU9Pl7UeaW4Yp+rXr09AQAALFy4EMnULkyZN4saNGzRt2lSIzGXLlmU79vr1a3r27CmVqJATJeb63PBuJ0+ezLRp0wgODqZBgwZCZSmNvo2GWenSpYtexqejR49K68L79+8TFBSkk+Y+IyNDivzXB8+ePePChQsULVoUW1tboQ5Sbdq0kTJj5M+fH4D4+Hhu3bpFhw4dhMj88ssvCQoK4vDhwwAkJCTg7e3NhQsXhGQByZrBVYuxsTGWlpayy8oJpWwkeXwceYboPD5ZkpKS2LBhA6GhoTqKAcj0+PXy8hIit1SpUoSHh/PixQupbkdsbCzh4eGULl1aiEzInLRWrVpFeHg4qamp2c7LWb84KxUqVCAkJISgoCCsra3x9vamSJEihIaGyu5xamFhwfnz5zl16lSOKSpPnjxJeHi4UAVndHQ0mzZtIjQ0FAsLC9q3b09ycjKtWrWSVY6vry9///03kDmB//PPP0yfPl06n5GRwY0bN4TWbhk/fjx//fUXu3btYteuXdK1GBkZvTVKWw4MDQ15/fo1d+/e5cGDBzg6OgLw+PFjoR5zRkZG2eqHjB8/XoisKlWqEBISQkBAAD4+PgAUK1aMevXqAZkesNrU6HKRG/pPaGgoZmZmDBgwABcXFypUqMC6detwcXHh+vXrssrKDferrf0WFxdHZGSkdFyrGP/UDdFKPWMXFxcaNmzIxIkT35v6TdTcpxT37t0jPT2dzp078+WXX/L69Wvu3LmDWq3m0KFDHDp0SPqtnPeuRFtesGABKpWKly9f6kRXiJD5oRt+uetJ9ejRAw8PD+Li4lCpVCQlJeWYRqx9+/ayycwtHDx4kI0bN3L79m3y5cuHmZkZI0eOfGf96P+FrMZJAwMDnj17RteuXWnWrBkFChTQ+a3IMVlffcjExITt27czb948jh49KjlQaGnRogXff/+90NqC3bt3Z9++fTx//lyKtLt//z7h4eGyGjyy4uXlhUajwcLCgsqVK+stujI4OBhXV1eeP3+e43k5DdG5YV2jRKShUqSmplKqVCkdZbxaraZUqVI8fvxYqGwl5twZM2Zw9epVKdIuOjqa6OhoypUrx5QpU2SXp0WptbK+23JiYiKnT5/m9OnTOZ4XXa/S1dWVu3fvcujQIZ01Vdu2bWXd7+aGcWrq1KkMGDCA33//HcjM4Hf9+nUKFSok1cjWB4aGhpiZmbF3794ca5R+DErM9Uq92zfXhSkpKQwYMIDChQtLBjzI7ENnzpyRVbaS6NtomJXFixcL/X8tZcqUkfSKKpWKqKgofv31V53faNd2crNq1SoOHjxIxYoVmTJlCvfv38fV1VVypqhWrRpr166VsmPKjYWFBceOHcPZ2ZnmzZuTmprKyZMnefHiBQULFpT2L3JGoLu6ujJu3Di+/fZbVCoVf//9N3///TcajUZIKnAlmDRpEpaWlgwePPi9467IzDZ5/O/kGaLz+GSZM2cO+/fvz3EjIdK7q3379lI9jdatWwNw/Phx4uLipKhSEcyYMYOjR4/q/X4HDx7MnDlzCAsLo23btnh4eDB16lQ0Gg0tWrSQVdbQoUM5d+4cY8aMoV27dlhZWUmen6GhoRw5ckS6JhGEhYUxaNAgkpKSUKlUlC9fnnPnzrFhwwbc3d1p27atbLKsra2ZNWsWaWlpqFQqYmJi2Lt3b7bfNWrUSDaZb2Jubs6OHTv4+eefCQ4ORq1WY2Vlhaur61tTMslB9erVuXjxIkOGDEGlUtGiRQsWLVrEjRs3ZDf4u7m5YWZmhrOzc46RNFmRUxHSo0cPFixYwLBhw4DMPjpw4EDUajWurq4cOXIElUola30lpfsPZEYIlS9fnpSUFMLDw6V6OMbGxrx+/VpWWbnhfnfs2IFKpaJRo0aUKVNGb4rxly9fcvfuXSnNn6+vL3Z2dlK9e7lQ6hmHhIRI9xISEvLW3+kz0kRf+Pr6Sp9v3rwpfc7IyNB5FnLfuxJtWV/e+PDhdaLkVk4XKVKErVu38vjxY4YOHYqNjY2Oo5dKpcLU1JQaNWrIKldptmzZwg8//KDzPAMDAwkKCmLhwoWyrpc9PT112pFGoyEyMpJbt27pHBPtHKTPPlSiRAlWrlzJs2fPuHLlCi9fvqRQoULUqVOHMmXKCJGZVdmTlpbGixcvaNeuHTY2NqSlpXHhwgUMDAyERaInJiZSq1Ytdu/eLeT/38ayZcuIjY2laNGixMXFUaZMGZ4/f05qaqq0xpGL3LCuUSLSUCm0+5H9+/fj5OQEwJ9//snFixelNKmiUGLOLVu2LPv27WP//v2Eh4djYGBA9erVcXZ21jH2yI1Sa2V9tuUPWTuIduQwMjLil19+ISoqSqdsnZxZXiB3jFM1atRg3759bNu2Tact9+3bV1hgiLe3t8739PR0Hj58yJEjR4SVl9H3XK/Uu3369GmOx+Pj43XK1H1u+z6ljYaPHj0iJCSEpKSkbOfkKltnaWnJ+PHjiYiIYN++fZQtWxZbW1vpvFqtxtTUVPYsp7/99psUeR0REcH169dRq9UkJSVhYmJCUlISkZGR/Pjjj8LK+WiN/dHR0dy5cwf4/3lA60Qjdyp0e3t71qxZg4eHh87YOGLECNn1rFquXLnyQY44chmFDxw4QEpKCoMHD+bAgQNv/Z1KpcozROdSVJrPzbU1j/8MTZs2JS4ujl69elGjRg0MDHT9KkR55CcnJzN8+HCCg4NRqVTSZGJhYcHmzZuFRXTWq1cPjUbDyJEjc9zEiUwrfeLECcqUKUPt2rXZu3cvGzZsoGLFisyePVt2D7INGzawbNkyMjIysikWVSoV48aNY/To0bLK1DJgwAAuXbrErFmzmDdvHvb29jg7OzNx4kRq1KjBnj17ZJX3xx9/cOvWLTw8PKhSpYqOQku7KOvQoQOmpqayylWaoKAgRo4cSVJSEi1btmTNmjWSo8WWLVtk9QA1NzfH3t6eVatWYW5unuMGRtu2wsPDZZMLmV6YW7duJSMjg169ekkLtAkTJnD48GFGjRole6pdJfsPZNbhfvnyJe3bt2f79u0sXLiQEiVK4OrqSrVq1XJ0tvgYlL7fpk2bUq1aNb3Wk7x58yaDBg3C1taWX375BchMs29sbMyGDRuoWbOmrPKUeMZ79+6lXLlyNG7c+L1tRqmSCqL4N31EzntXoi3/1wgMDKR48eI69b8/V1q3bk1MTAwjR47EwcEBtVrNkSNH+O233/jiiy84evSobLKmTZv2wcrJH3/8UTa5b5Jb+9CcOXMICAj46Gf+oWszEespyDSE//PPPxw8eFD2/34XNjY2VKxYER8fH5o1a8batWspVqwY3bp1o1WrVixdulRWeUqva27evEn//v2Ji4sDkPa6hQoV4vfff6dWrVrCZOubQ4cOSQYArSE2JSUFyHRkFZmpIreOFyJQ6l5v3LjBgAED/hNtOSv379/n4sWLqFQqbGxspHrRcqL0OOXr60u5cuWyOezv37+fpKQkIXrAd+kRnJ2dWbJkiewy/w1yzfVKvNvAwMAP/q1SpV9Ecfr0adasWaM3o6EWX19fZs2a9da08iLWcdOnT6d27dpCaqq/ib29PY8fP2bWrFkkJyfzww8/SA6pI0aM4MGDB5JDtDZLpdwosT958OABBQoUyKY/jo6OJikpSfZIe+24+D6zopx7g1WrVlG1alU6dOgg1aZ+G6LL9uTxv5FniM7jk0XJDVxGRgaHDx+Wokitra1p27Ztjumf5KJ169ZUqVKFDRs2CJORW7h27Ro7d+7k8uXLkudn7dq16dWrl1AP9bp161KvXj02btyoY8AcMGAAly9ffmdk3seQdTLVN/fu3ePy5cuS4iUrcnlC5sSLFy94/Pgx1atXR6VSERoaSunSpWV3bJg2bRoWFhb079//vYtBkQrqrERGRlKyZEmKFi0q5P+V6j8Aa9aswd3dHchMRX7o0CFmz57N4cOHWbBggRDFgJL3u2rVKnbs2MHOnTuFKHpyYsSIEZw5c4auXbvy448/kpqaiqurKydPnuSrr75izZo1sstU8hn/17h+/brszgQfgr7aclRUFIUKFaJ06dLvrdssdxRPbkBf5T+Uxtramtq1a7N9+3ad43379iU8PJxLly4pdGXiUGI++BDGjBnD8ePHP1oBlLWm3/uQS/GTNQItLi6OVatWUb9+fb766qtsadfljqbRYm1tjY2NDRs3bmTYsGG0atWK/v37M2zYMK5fvy6klrDSc+7jx4/1GmmoJDt37mT58uWSsdLExIQxY8YIjeYE/Y0XuaHUiZJj43+pLUNmBoeNGzdKpb3y5cvHsGHDZIu2y4qS45S5uTkODg6sXLlSOqbRaHBxceHWrVsEBQXJLjMn45m2FuqwYcOElhf7EOSa60HZdxsUFETx4sUxMzPTOR4YGCgFMXzKfPPNN9SsWZPx48e/1aFCH7Ru3ZoHDx5QunRpypcvny3Iadu2bcJkx8bG6pTWfPXqFUFBQbKWOrG0tKR+/fps2rQJyCyjoi03WbhwYQCGDRvG33//zZUrV2STm5X09HRh2RLeRk5jI0D//v25c+fOW0tHfIy8D9Vj5xmF89CSl5o7j0+Wnj174uvrS2JiIoUKFdKrbLVaTbt27WRPyfYuvvnmGxYtWsS+ffto2bJlNgWMqFR4Go0Gf39/Lly4QFJSUrZa3D/88IPsMs3NzZkzZ857f/f3338TExMjm8E0f/78PHz4UOceU1JSuHv3ruybi6zK+I4dO0rHckKUMn7nzp18//33b/WEFGmILlasmE5NI2trayFysta/0VctnPdRrVo1of+vVP8B+PrrrylWrBjR0dF0796dokWL0qBBA2xtbYVlqVDyfmNiYkhISKBDhw5UqVIl27gsQqkXGhpK7dq1JccJIyMj1qxZQ8+ePYUZd5R8xgDHjh0jPDyc1NRUneNyprLKLXTp0gVzc3O6du2Kk5OT3jJi6Kstd+jQAXt7e1auXEn79u3f6hwkspbiwIED33pOpVLh5eUlRK4+y38oTZMmTbh9+7YUQQOZ9VgfPnxI8+bNZZXVpk0b7OzsmD9/vqz/+29RYj7QJ0ookObOnZstIuv8+fP89ddf2X4ryhBdoUIFSXlpbW2Nt7c3RYoUITQ0VFiqXaXn3NKlS8taUzY306tXL7p06UJERARqtZqqVasK21NnRV/jRW4odaLU2Dh27Fjq16//n2nL3t7erFu3DrVaLWVeiYiIwNPTkwoVKtCrVy9Z5el7nFqzZo2UCQrg6NGjOUa1i3L0/i9kL9Ci5Bw0YMCAHA1pK1as4NatWwQEBMgmSwkCAgKkcmXTpk3DwcFBEUP0s2fPqFKlCn/++ade5jyA4OBgXF1def78eY7n5TREv379WsdGULx4cQDJCA1QoECBt+pB5aBFixZ06tRJ2tuLYtu2bTrZgoKDg3X2utryXqKC5qpWraqokfnatWtcu3Ytx8AqUXuDPD6OPEN0Hp8s2hoPjo6OWFhYULBgQZ1NlJz1AD6k5oEIuVmxsrIif/78fPfdd9nOiVTYLlmyRPIke1PhIsoQ/aFs3ryZ48ePy7b4bd26Nb6+vlK607CwMJycnHj06JHsSp6syvh3eZCJfLcbN24kLS2N4sWLU7FixWzp7UXxrlRoct/v+yLusvI5Rt+9C7n7j5Y3Iy7eZfTRJyLu18fHR/p87do1nXOilHqpqak5etemp6fnuADXJyKesZubG2vXrs12XO6aSrmFQoUKER4ezrVr11iyZAktWrSgS5cutGrVSmjWFX21ZY1Go7OWeJshR2TCpnelABSpjF+6dCmvX79m3rx5zJs3D8hc26nVatasWfPJG6KzRq9aWFhw5swZBg0aROvWrXn9+jWHDh0iISFB9nS39+/f59mzZ7L+5/+CEvOBUmStZZ8Tcs0BWesIKsXgwYOZM2cOYWFhtG3bFg8PD6ZOnYpGo6FFixaKXpuIOfddazYjIyNKlSqFg4MDrVu3lk2m0hgZGVG7dm29ytTXePHjjz9K2ab0lfnpTZQaG8+fP09cXBxDhgwRJiM3sWXLFvLnz4+Xlxd169YF4NKlSwwaNIgtW7bIboj+UOQap4YMGcKOHTt4+PDhW1PBqtVq+vfv/1Fy3sbbnN6GDRtGTEwMfn5+QuTmZuR6txs2bGDr1q3S97Nnz9KmTRvpe0ZGBjExMZiYmHyUnNxAgQIFOH/+PD169AAy9yRvy1Yh0oGxUaNGPHnyRG9GaMjM2BAbG0vRokWJi4ujTJkyPH/+nNTUVCEBXlnnFyXW4c+ePcPLywsvLy9q1KhB165d6dSpEyVKlJBVjr29PUuXLpUcnZ8/f57jXvdzy74F4OXl9c5gozxDdO4kzxCdxyfLb7/9Jn0+efKkzjm5C9MfOHDgg34nt9ysTJ8+XUob9iYiFbbausgODg5UqVIlW9qWz4kZM2YQFRUleYw/fvwYyFSoTpkyRVZZWZXx73p/It/tw4cPqVy5Mr6+vhgbGwuT8yb6vN8PTXcu0uD/XyIpKYkNGzYQGhqqk3IJxEYaKoUSSj1LS0uCg4OZM2cOzZs3Jy0tjZMnTxIeHk6DBg30fj2i8fb2RqPR0LhxY8qUKfNZz0GQqTgNCAjA39+fY8eOcfz4cU6cOEGRIkVwcnKic+fOQtLi6astZ1VCv6mQ1hcLFizQ+Z6amkpYWBhHjx7Ndk5OLl++jK2tLS4uLpIhum3bttSrV4/Lly8Lk6svcopeDQwMlFJkaueDSZMmCa29qhRKGXmU4H2lTuQyjOaGCLRevXpRqlQpypQpg7m5OQsXLmTDhg1UrFiR2bNnK315shMYGJijkSfrMV9fX77//nthmW7+C+hrvNA6V7/5WUvWrBWiUGpsdHR05NixY4SFhf0nysjcuXMHGxsbyQgNUK9ePerVq/dZlMPInz8/e/bsIT4+HkdHR5o1a8bcuXOl8yqVimLFislqrDx69Ki0Vr1//z5BQUE6ZSoyMjIIDw8nMTFRNpn/RXr06IGHhwdxcXGoVCqSkpK4f/9+tt99DmvHjh07sm3bNq5cuYJKpSIuLi7HbBUixuWspUQcHBxYsGABM2bMoHXr1tkyVdjZ2cku/8aNG9SsWRMfHx+aNWvGypUrKVasGN26dRPibH3//n3JSVbbnnbu3CmtZXJqY3Kyc+dO/P39OXz4MNevX2fx4sUsW7YMOzs7unTpQuvWrWVxBChdujSrV6/m3r17zJ49m1q1atG3b1/pvFqtxtTUlKZNm360rDextbWVMnAowbp169BoNFSqVInSpUt/do6/nyt5hug8PlnGjBmjt4EmN9QziIyMpFSpUvz88896VcZnZGRgbW3NihUr9CJPSUxMTNixYwfnz5/n6tWrGBgYUKNGDZo0aSK7rNygjLexsSEhIUGvRmiAw4cPS581Go1kBFi+fLns9W0/1LAt0uD/X2LOnDns378/x+f5OS4Mc1LqiWbChAkMHjyYXbt2sWvXLiCz/RoaGvLtt9/q/XpEo9FosLW1lTJzfO4YGhrSsmVLWrZsSVpaGseOHeOHH37g0aNHbNu2jW3btmFtbc3PP/8sRTnJgRJtWSlyMp7069ePkSNHcvTo0Q92YPq36LP8hxIoGb0aERGBm5vbO38jOoPCf6kP1atXT5rTteu46OhoNBqN8Mj+4OBggoODUalU2NraYmNjI1QeZEaRaPtt165dcXBw0Env+Dnh4eHBpEmTaN68uVQ6yNfXl3PnzjFz5kxSUlJYvHgxW7ZsyTNEfwRKjRerV68mNTVVSlfdrVs3WrVqhaurqzCZSt1rdHQ08fHx9O7dG0NDQwoXLizpT1QqFWfOnJFd5sKFC6lfv74iBrOiRYsSFRVFSkoK+fPnByA5OZnbt2/rlMP6lDE1NcXU1JRjx45hbGwsvHxNmTJlGDduHJDZZqKiovj11191fqPRaLCwsBB6HZ87RYoUYevWrTx+/JihQ4diY2MjPXfIfPampqbUqFFDwauUh9mzZ2Nvb8/jx4+ZNm0atWvXzrH+uAiGDx+eTR+zd+9e9u7dq3NMVIBGeno6pqamGBgYYGFhQVhYGP3798fa2prz58/LLu/atWuS4y9k9tWsziuiHbGsrKywsrJi6tSpXL58mYMHD/LHH39w6tQpTp06hYmJCX369GHs2LEfbYjX6qsNDAwoV64cjRs3luMW3su/dRidM2cOAQEBHD16VBb5CQkJWFpaSjqxPD4N8gzReXyyZF2ciCY3GKJr166NWq3We8Rb586dOXbsGKmpqXpN3aIE06dPx8LCgn79+ukYn5csWUJcXByLFi0SIrd79+7Y2toybdo0If//NkaMGIGrqyvz5s2jadOmGBsb6yzGRHhCAlSqVCnbserVq3P+/HkWL17Mtm3bZJOllJH/v8q5c+dQq9X06tWLGjVq6C3duz5xc3PDzMwMZ2fndxo+RBk9bGxs2LFjB+vXr+fatWtoNBpq1arF0KFDqVOnjuzylKZr164cOHCAu3fvUrFiRaUvRy+8fv2aM2fO4Ofnx/Hjx3n16hWQqRCLjY0lJCSE2bNns27duo+So3Rbfvr0KW5ubm/NoCDXJvXf8GaGHTnRZ/kPJVAyejU6OjrHFP5aRKXyV7oPKcX27duzHXv58iU9evQQFhmRnp7OlClT8Pf31zneoUMHli5dKsxBNzU1lfnz55M/f36pZqazszO2trYsWLDgs9sbbdiwgXLlyvHzzz9Lx9q0aUPHjh05evQoa9as4eDBg4SFhSl4lZ8mSo8Xnp6erFixQnIaSk5OlkqBFChQgJEjR8omS+l7Bbhw4YL0OTU1ldjYWB25ItizZw9Xr15VxBDdqlUrdu7ciYuLiyTfz8+Px48ff3ZOIxUqVODq1atMnDhRes+2trZMnjxZ1jT7lpaWjB8/noiICPbt20fZsmV1nO60kYZ56V8/HjMzM8zMzNi8eTPFixdXNMpSJCqVSopMvXfvHlWrVhXmAPsm5cuX14uct1GhQgVCQkIICgrC2toab29vihQpQmhoqOxBIbmhtIuWuLg4rl27xj///MPz58+le3358iWenp68ePEiW8r/f8PZs2cpWbIk5ubmlCpVirS0NJ3o96yI0u9+KM+ePZM1Et3R0ZGgoCDi4+M/i9T9/xU+Pw1xHv8pbty4QWRkpE5dzMTERC5cuPDeyIj/lXfVRTMyMqJkyZLUrVtXdsXEN998w7fffsu8efOws7MTmj4l67MzMDDg2bNndO3alWbNmmWTO3HiRNnkKkFERATPnz8HMj0C79y5o+NtmZ6ezsmTJ3nw4IEwQ/Tdu3cpVKiQkP9+F4MHD0alUuHt7a1T2xH0n6r61atXREZGcuvWLb3JzEpkZCTVqlVTRPbnho2NjY636eeGp6cn9vb2ODs74+npmS0VrTZ9pUjlWu3atYWVgchtjBo1Cl9fX5ycnKhSpUq2DA4i62cpwYwZMzh69Cjx8fFoNBqMjIzo0KED3bt3p2nTpjx+/Jg+ffpw8eLFj5aldFuePXs2J0+e1HsGhUmTJul8T09P5+HDh4SGhspetysr+iz/oTQPHjx453m5lWHlypWjUaNGsv7nh6B0H8pNFClSBBsbG37//XeGDh0q+/+vXbsWPz8/jI2NpUiPv/76Cz8/P2rWrCmrES0r7u7u+Pj4SOluk5OTefz4MX/++SclS5b87PrupUuXshlyVCoVRYoUkSKW1Go1GRkZSlyerOjbEVjp8WLXrl2YmJgwefJkILNW6e7duxk6dCg+Pj6y9iGl7xUy69fqm4YNG3LlyhWePHlCqVKl9Cp74sSJBAYGSs4FkPmsK1SoIEXAfy5cu3aNfv36kZSUJB0LCAigX79+bN++HXNzc9lkjRo1CsjUiekzevW/SsOGDTlx4gSnTp3ScVJ99eoVFy5cyKaz+pQZO3Ysz58/Jy4ujqJFi3LmzBnOnDlDs2bNaNmypezyjh8/Lvt//hsGDx7MnDlzCAsLo23btnh4eDB16lQ0Gg0tWrSQVVZuKO3i6+uLn58fAQEBpKeno9FoKFOmDF26dKFbt26Eh4czY8YMDh8+/FGG6OHDh+Pg4MDKlStzjHrX8jmWIpw6dSrt2rWjXbt2WFtbZ9MT/Vf0ZZ8aeYboPD5ZvL29dVJtvIkoQ/T76qIBlCpVinXr1smaPmbkyJF6MxrmtGF800io3Tx+6oboGzdu6CilL168yMCBA3V+o93EiaJPnz5s3rwZf39/GjRogImJiU5kh6hoC6W8It90msjIyCA+Pp60tDQqV64sTO6jR49YtGiR5LySdWMTFxf32S3MlKBnz574+vqSmJioiHOFPujSpYuUgq1Lly56STnu7e3NF198QbNmzd67Af/cvPLnzJlDXFwcANevX9c59zmme9+zZw8AtWrVonv37nTq1ImiRYtK58uUKYOFhQV//fXXR8tSoi1n5cKFCxgaGuLq6kqNGjWE1AfLiQMHDrz1XP/+/YXJzZcvn97KfyhNmzZt3npOhCKkdu3aitQhVboPfQimpqaypvEHskVaaJ05Tpw4oeMcLCd79uzBxMSEPXv2SNkx7ty5Q7du3di9e7cwQ7Sfnx8lS5aUIoQLFCjA8ePH6d69O/7+/p+dIbp06dKEhoayfPly2rZti0aj4fDhw4SEhFChQgVOnTpFYGCg0H2RvtC3I7DS48XDhw9p2LAh1tbW0jELCwssLS0JCgqSVZbS9wqZBi0tjx49QqVSUbp0aaEy8+fPz7Nnz2jVqhVffPEFJiYm5MuXTzov0nmyWLFi7Nmzh+3btxMcHIxarcba2prevXvrrCM/B37++WeSkpJwcXGhV69eAJKOzN3dXfZSX/D/tc5jY2Oz6RGCgoLo06eP7DL/DSLmeiX49ddfdepwf86EhIQwbNgwFixYQLVq1Rg5ciQajYYtW7bg7u6Oo6OjUPkvX77k7t27UkY1X19f7OzsKFmypBB5vXr1olSpUpQpUwZzc3MWLlzIhg0bqFixIrNnzxYiU0m0Tm4GBgY4ODjQvXt3mjdvLul5K1euzP79+zl37txHySlfvjzFixeXPv+XWL58uaQnetPRQqVS5Rmicyl5hug8Plm8vLxQqVS0aNGCkydP0rZtW6Kiorh586YwZQTAkCFD2LVrl1SbDODvv/8mIyODr776ivv370v1bj08PGSTq89JJbcq00TQoUMHfHx8iIiI4PHjxxgZGenUUVKr1RQvXlxoevZ9+/aRkpKSo1FfpOeaUl6RT58+zfG4sbGx0KiEhQsXcuTIkRzPValSRZjc/xJqtZqkpCQcHR2xsLCgYMGCOmPJ57AYXLx4MQAvXrzg+++/lxxFAgICCA8Pp2zZsjg4OMjqQDJ37lwcHBxo1qwZc+fOfef4/LkZos+cOYOxsTEjRoygTJkywtKv5hb69+9Pjx493hnN8e233zJjxoyPlqVEW85KwYIFqV27NsOHDxfy/28jp/m8QIECWFpaCo2q7dSpE9bW1ri5uX2WxuesvC3FXv78+YVGnesbpfsQZCrF38wOpcXOzo4FCxbILvNtERcajYavvvpKdnkAMTEx2Nra6pRoqFSpEpaWlgQHBwuRCZlpBBs2bKij4C9dujTVq1eX3XiXG/j666+ZNWsW69aty1b+YcSIEUREROilFrg+0LcjsNLjRcmSJbly5QoPHjyQ9Aq3b98mLCxMUmLLhdL3quXUqVMsXLiQe/fuAZljxowZM4REGwIcOnQIgLS0NG7fvq1zTrRu5dWrVxQsWJBhw4YxbNgwnXNhYWFYWVkJla9PgoODMTc31wlKmT9/vpT2V5RMV1dXKZPem4g2RCsx1yvB3r17MTQ0pGfPnmzdupX+/ftz69YtAgICPvkAmDdxc3Pj1atXxMfHs3fvXjQaDb1798bHx4d169YJNUTfvHmTQYMGYWtryy+//ALA999/j7GxMRs2bKBmzZpC5LZq1Ur63LVrV6lc0edI9erV6d69O507d37rHOvk5ETHjh0/Sk5Wna7SUe/65sCBAxgYGNC5c+f/hJ7ocyHPEJ3HJ8v9+/epX78+a9asoXXr1ri4uFC/fn3at28vtG6VWq3GwMCAffv2SSmXHjx4QJcuXahevTo///wzTk5OXLp0SVa5+pxUtJvH3I5ctUTWr18PZNZvtLOz4/vvv5flfz+Ud6WwlLteSm4gp1RpBQoUwMzMjIIFCwqTGxgYSNmyZVm1ahV9+/bl119/JTY2lhkzZnz0AvBTRETb+u2336TPb9ZaVdorUa77ff36NdOnT8fPz48dO3ZgZWXFzJkzpUhWyKxz5eXlhampqSwybW1tMTMzkz7nVkS0qbJly1K+fHlGjx4t+3/nRmbNmvXe38hVRkCJtpyVwYMHs2bNGh4+fEjZsmVl//+3kZMhWpvlRSSJiYk8efJEqIzcwj///CN91mg0pKamEhYWxoQJE96Zzeh/oXz58kLa54egdB/y8/Nj2rRpvH79Ots5kY6MOTnHGhsbY2lpKaX9lZtSpUoRHh7OixcvJIfR2NhYwsPDhUY5litXjosXLxISEiKl5/7rr7+4ePGiXsetnBAx5/bo0YNSpUrh4eFBZGQk6enpVK9enaFDh+Lg4ICPjw/jxo3j66+/ll22vtG3I7DS40XHjh1Zt24d7dq1o0qVKqSnpxMdHU16errsNYSVvlfI3PeNHj2a9PR06Vh0dDRjxoxh48aNQtbTSmTm0DJw4EDWr1+vE/386NEjli5dir+/v868rE9E6TLy58//QcfkYtmyZcTGxlK0aFHi4uIoU6YMz58/JzU1lXbt2gmTC8rN9e9DxLt99OgRtra2zJ49m7Nnz9K8eXNmzZpFu3btOH78uNCAI31z7do1LC0t6d27N507d6Zq1arMnz+fqKgowsPDhcpesmQJsbGxku4tNTWVhg0bcvLkSX7++WchWQUg06HD09OT0NBQGjZsiLOzM48fP6Zfv35C5CnJvn373vsbEWOHviPdlaRYsWJUrlxZWAnNPMSQZ4jO45PF0NCQtLQ0IDOt1KVLl2jatCmVKlUSutDevXs3tWvX1qn7U758eerUqcPWrVsZPXo0FSpUICoqStg16JvU1FT27dtHREQEKpWKGjVq0KFDB+FezFl5/vw5hQsX1kndOXDgQBwcHGSToTX2Jycnc/XqVVQqFbVr1xa6qQE4evTofyYCHTIN0TY2NkJqCL6LV69eYWVlhYWFBbVr1+bZs2d06dIFHx8f/vjjD8aNG6fX69Envr6+2Wpoyt1/AMaMGZMr2rLI8WLt2rXs379f+h4YGIiPjw8qlQpra2uePXtGREQEq1ev/iCj4oeQtc5Rbqh5BPoZkyGznu/UqVPx8/OjefPm2cZjfc5DoqhVq9YH/U5uZZMSbTkr169fJyMjg7Zt21K5cuVsGRREprBcvXo1qampUt3Ebt260apVK1xdXYXJHDduHEuWLGHdunU5Rt99+eWXwmTrm6ypSCEzLV3jxo1p2bIlP//8s6y14JT0/le6D7m5uZGamkqBAgUoXry43uZfLy8vnchkfdC+fXvWr19Pp06daN26NZD57uPi4ujevbswub169WLZsmX06dOHggULkp6eLkWkyW28exf6WscBtGzZ8q0RoyKftb7RtyOw0uOFq6srd+/e5dChQ9y4cUM63rZtW9lrCCt9rwArV64kPT2dSZMm6aRvdnNzY8WKFULW00pG9125coW+ffuyYcMGihYtyrp161i/fj1JSUkULlxYL9egr3GqTp06BAUF4eHhIY1Ju3fvJiwsjMaNG8sqS8uNGzeoWbMmPj4+NGvWjJUrV1KsWDG6desmvLSMUnN9VvT1bgsWLMiLFy+ATB1vcHAwLVu2xNTUVKp9/rnw+vVrybHh5s2b0vihj0CU0NBQnbI2RkZGrFmzhp49e8oeUKXl9OnTfPPNN6Snp6NSqdBoNFy4cAEvLy/y5cuHi4uLELn65M0Sj29DpVLh5eUlu3ylIt2VYsSIEbi7u392WT8+d/IM0Xl8stSoUYOQkBD27NmDjY0Na9asISYmhsDAQKF1cDIyMrh8+TIRERFShNrNmzelKGxtiisTExNZ5b5LUS3SEzIyMpIRI0YQExMD/H/U0K+//sratWtlT2kcEhLCvn37KFasGIMHD+bFixeMHj2aiIgIChQowNdff82oUaMAhGw0duzYwdKlS3n16hUAhQoVYsqUKULT3X777bfY2toKTUudmzh//jxxcXF6N0SXLFmS8PBwHj16hKWlJf7+/jRp0oR79+4RGxur12vRN9OmTcPBwUFn8yii/+jbmK/EeLF//34MDQ3x9PTEyspKUqDVqlWLHTt2EB8fj729PadOnRKmXMvIyODhw4c5pmeT25il9Ji8fPlyMjIymDRpUrZzSkYByMmHKhzkVkwo3Zb37t0rfb5586bOOZFKNk9PT1asWCFFQyUnJxMeHs61a9coUKCAsGiLBQsWvDUzxOfSlrWkpqbqfM/IyCAmJoZLly5J68nPAaX70JMnT6hevTo+Pj56dcrp06cPX375pV4do8aNG0doaCjBwcHs3LlTGg8tLCwYM2aMMLnDhg0jNjaWLVu2kJiYCGQ6Q/fv31+vkVn6WsdBpsHlzRSwiYmJBAcHS7WyPweOHTumV3lKjxdGRkb88ssvREVFce3aNTQaDbVq1RLiBKX0vUKmYbZu3bqMGDFCOjZy5EiOHz/OlStXhMgE5SL+WrVqxYkTJ3BxcUGj0fDw4UMMDAzo06eP3vZn+hqnxowZw5AhQ3B3d8fd3V06rlarpT2J3KSnp2NqaoqBgQEWFhaEhYXRv39/rK2tOX/+vBCZWpSa67Oir3drYWFBQEAAmzZtokGDBvz0009cuXKFixcv6gQCfQ588cUXXLx4kZkzZ6LRaGjWrBm7du3i4sWLWFpaCpWdmpqazWkU0HG2k5sVK1ZgZGTEihUrpHG5TZs2eHt74+XlpVdDdHx8vOz6esh0unoTrdH9zWMiUCrSXSmOHDnC69ev6d27N4ULF9YJWFCpVJw5c0bBq8vjbeQZovP4ZJk4cSIjRowgOTmZDh068Ntvv7F7924AofU07O3t2bt3L126dKFKlSpoNBoprVWnTp04d+4cz58/l71G2rsU0CK95ubPn8+DBw+oWLGi5B1/5swZoqOjmT9/Phs3bpRNVkBAACNGjCAjIwPIrOtUtGhRSUGdlJSEu7s7ZcuWpXPnzrLJ1XL48GEpZWThwoXRaDQkJCQwb948TE1NhUQdANy9e5dChQoJ+e83SUhI0JtX9NtwdHTk2LFjevdcc3R0ZNOmTezatQs7OztGjRol9dMPjUjMzbzvHo4ePUqtWrVkN3h4e3t/8G/ldOhQary4d+8e9evXl2q8BgQEoFKppPHBxMRE8uAWwV9//cWECRMkb/GsyP1ulR6TITON4tv4XEoXHD58WOf7vHnzOH/+vFRrUBRKt2WlUlju2rULExMTKYVwgQIF2L17N0OHDsXHx0eoceltbfZzactarK2t33ruXfXPPzWU7kNNmzbl7t27eq+JplKppKxU+qJAgQJs3ryZI0eOEBQUhFqtxtramrZt2wqNRlOpVHz33XeMGTOGyMhIILM8goh1u1LruKx4e3u/M33+52SIrlChApBZzzcyMhK1Wk3VqlVzVM7LgdLjhZYvv/xSeAaO3HCvhoaGkmN5VhITE4UZ85SM+Fu9ejWLFi3i999/lyLPFy9eLPu7zg3jVKNGjfDw8OCnn34iIiICgCpVqjBx4kSpzclNhQoVpBrU1tbWeHt7U6RIEUJDQ4Wv4fQ11+eGdzt16lSGDx9OoUKFcHR0ZO3atZKhX59ZSPTBgAEDmDNnDkePHqVixYq0atWKmTNnkpGRwfDhw4XKtrS0JDg4mDlz5tC8eXPS0tI4efIk4eHhNGjQQIjMGzduYGtrS/PmzaVjtra2WFlZCYvChkzj+i+//ELr1q2pXbs2AwcOJDQ0FEtLS3777TdKlCghm6w3a7Vv27aNa9eu6a2GuxKR7v8GU1NTypUrJ9v/ZXUCio+PJz4+XvqeG7I05pEzeYboPD5ZGjRowJEjR0hPT6d06dJs2rQJHx8fvvjiC6EepzNnzuTVq1ccOnRIWvhCZn3h2bNns379er744gu+++47WeVmVVRnrbe3fPlyoZ5NISEhlC9fnj///BNjY2MAUlJS6NChAxcvXpRV1s8//0xGRgY9e/bk6dOnHD9+HJVKxbfffsuAAQMICQlhzJgxbNq0SYjRw8PDg3z58rFs2TLat28PZNbkmTx5Mp6ensIM0X369GHz5s34+/vnmK5Tzs1y165dMTMz47fffmP69OnUqVOH/v37y/b/H0J0dDTx8fH07t0bQ0NDChcuLN2vSM+1SZMmoVKpsLS0pGXLlnTv3h0fHx+KFi3KjBkzhMjUJ8bGxjkqXEDXE1PuzfLcuXM/eKEnpyFaqfEiX758kmH21q1bPHjwAJVKxf+xd55xUVzv3752BQQVLLErdhQVsABiwaiAYI9dYu8lRmONLdZojBoFa7D3ghUbNqxRLIACGlEEFQuKUQyC0tnnBc/OnxU0/pKZHVj2euMyMx/vs2XOOXOX792oUSPhmri4OMn6nc+fP5+3b9/meE7s71buORm0X7EkB5UqVdL4W73WfnxcbOT+LcslYfny5UsaNWqkESy1srLC2tqagIAAyezqmqTg5/jUXFS+fHnRe0TLidz30Ny5c+nYsSOdO3emSZMmwtyhJqfet2IwePBgli5dyty5c7Gzs6NIkSIawTtHR0dJ7CqVSpo1ayYkHD969EiSILS6UqhAgQJCdb+hoaFGEoX6uJh7dLn2cVnZunUrCoWCr7/+mgsXLuDq6sqjR4948OCBTvXmVOPl5cWmTZuIj4/H2dmZJk2acP36dX777TfRg5VyzBeOjo60aNGCBQsWfPa+FPv5S+65EaBhw4ZcvHiRWbNmCfLNBw4cICIiQvSCATXarvi7fPmyxt8tW7bkyZMnXLp0iYiICG7fvs3z588B8ebl3DBPBQYG4uDgwLFjx4iLi0OpVEpS3ZiVgQMHMmvWLEJDQ3F1dWXt2rVMmTIFlUolaruRnNDWWp8bvtuaNWvi5+dHUlISZmZm7Nq1ixMnTmBubo6Li4tkduWgZ8+elCtXjqioKNzc3DAxMaFly5a0b98eZ2dnSW2PHz+egQMHsm/fPvbt2wdkfq+Ghob88MMPktg0MzPj0aNHJCUlCcdiY2MJDw+nePHiktgE8PT0ZMOGDZQuXZoHDx4QHBwMwO3bt1m+fDnz5s0TzdbHyRIXLlzg3r17WkuikKPSPSuxsbHZFHXUODo6ih6Q37Ztm6j/nx7toA9E68nTlCxZUnhdu3ZtyaSdslKkSBGWL1/O06dPiYiIID09HQsLCypXrgxkSj6J3WcJcnZIW1hYcPXqVX799Vd27doluk3IdBqWKlVKY8NbsGBBypQpI/oDekREBI0aNRI2Ax07diQiIoJBgwZhbGyMo6Mjtra2kmVzRURE0LBhQyEIDdCuXTt2795NSEiIJDYBjh49SnJyco4PEWJnnL548YISJUqQmJjIoUOHePfundA362OkyhYPCgoSXqekpGjIYkuZuWZoaMiUKVOEvxcsWMCkSZMoWrSo1quJpODo0aNMnTqVgIAA6taty6JFi4T2AZaWlri4uLBq1SrR7arlbbWNXPNFlSpVCA4Oxt/fnwMHDgBQrFgxGjRoAMDhw4cFOUApePLkCebm5mzfvp0yZcpIes/IPSfD/1Us5YS6Ok3Pv0OO37K3tzcVK1akWbNm/6imIFVLjJIlS3Lnzh2io6MpX7488H9tVaR0hHyKxMREAgICJHdkahM/P79sc5OJiQklSpSQaUTSIPd6sH37duLi4oiLi9OYD9VtdKQKRC9atAiFQsGePXuy9XKXqlLq3bt3jB07lnLlygmVHv369aNKlSqsWrWKYsWKiWarXr16uLi4sHLlys9W94v9XuXax2Xl+fPn2Nra4uXlhZOTE+7u7tja2tK2bVuhDZWusHnzZjw9PTWecR88eMDp06dZunQp06ZNE9WeHPPF69eviYuLE15/CrH3knLPjQDjxo3j2rVr2QItRkZGkklVa7vib+jQoTl+dwqFgg8fPgjPvWLOVblhnho9ejTlypXDx8dH0pZ8WenZsyelSpWiTJkyWFpaMn/+fDZt2oS5uTkzZ86U1La21vrc8N1Cpg8qJiaGoKAglEolrVu3pmLFipLblYPmzZtrzBedOnXSit2GDRvi7e3Nhg0bNFo1DB48mLp160pis0OHDmzZsgUXFxcUCgU3btzAzc2NhIQE+vXrJ4lNgOPHj2NmZoaDgwMeHh4ULlyYU6dO0atXL52Tbpaj0l2Nr68vU6dOJTU1Nds5qZ4Nsia3fUzW6mg9uQt9IFpPnuXly5fMnz+fsLCwbBk32ugHoFQqSUhIQKFQaGTjS5nZ+zEfPnwgMjKShw8fSmZjwoQJTJw4kb179+Lq6kpqaio+Pj6EhoayYsUKjT6A/zVwWaxYMSIiInj27BkVK1Zk4cKFhIWFCVmX0dHR3L17l9KlS/8nO5+iUKFCvHr1ioyMDCEwmZ6eTkxMjKRy1tHR0Z88J3bGaalSpQgNDaVhw4YAnDt3Lkcnm5SSS3Jmrt27d4979+7lmKUnZR9wbVChQgW2b9/Oli1b8PT0pGvXrnz//fcavdGkQJs9IrMi13zRvXt3fv75Z4YMGQJk3iv9+/dHqVQyduxYzpw5g0KhkEx+r169eiQmJlK2bFlJ/v+syD0nA8TExLBgwQIhu1Zt+8OHD8TFxelUX1fL4J0AAQAASURBVF1tI8dvefbs2bRu3ZpmzZr9o5qCVHNy+/bt2bBhA23atKFKlSqkp6cLLVakzFiPiIjgxx9/5OHDhzmuQWFhYZLZ1jY//PAD9vb2TJ06Veu2AwMDCQ4O1pgv1Hz//fei2pJ7PdizZw8KhQIHBwfKlCmjtaQ6dQKHNlmyZAnXrl3T6O2ulr1dtmyZqBUtKpXqiyq/xN6jy7WPy4qhoaEgu25lZcWtW7do2rQplSpV4s8//9TaOLTB7t27KVWqFMeOHRP6no4dOxY/Pz9OnDgheiBajvli27ZtQgKQNp+/5J4bITNwtmfPHjw8PAgMDESpVGJjY8PYsWOpU6eOJDa1XfEnx1ycG+YpMzMzDAy078pu1aqV8LpLly5aU/bR1lqfG77bhIQEZs6cycmTJzWOt2/fnnnz5mnV1yo1r1+/ZtmyZYSEhGTbsyoUCvz8/CS1X7t2bZYuXSqpjaxMmDCBmJgYTpw4AWQmGAK4urpKUsil5vXr1zRp0gQLCwuCgoKoX78+JUuWpHr16ly7dk0yu3IgR6W7mmXLlpGSkoKxsTHFixfXijR2QkICq1evztFPFBERIVS/68ld6APRevIsU6ZM4fr16zmek3rS++2339i8ebMgOVWgQAGGDBnC+PHjJbP5sZxSRkYG8fHxpKWlCdXYUrBo0SIKFCjA7NmzmT17tsa50aNHC6/FCFx26tSJtWvX4ubmxvXr17GyssLKygrIDHi4urqSnp7OgAED/pOdT9G0aVN8fX0ZOXIknTt3BuDQoUM8ffqUdu3aSWITtCs9+9133zF37lzS0tI0JJY+RkrJpc9lrknJ1q1b+fXXXz95Pq8HotUMHDiQr7/+milTpuDh4SH5Q4xcyDVf9OnTh7dv37Jz504yMjLo2bMno0aNAjLXAqVSyYgRI4Q5RGzmzp2Lu7s7Q4YMoXnz5tnk2cT8Hcs9J0OmFPmZM2dyPFelShXJ7GqTjyuD1TKKe/fuzTYXi/n9yvFbtre3F6or5FJTGDt2LE+fPuXUqVOEh4cLx6V2hPzyyy+f3CfJ9VlIxdOnTyXpoftPrF69OsdqHXXVkNiBaLnXA0NDQ+zs7NiyZYsk//+nOHfunFbtAZw/f54KFSoI7YiMjY3x8/OjY8eOXLhwQVRbZ8+eFdZWOdpDyLmPq1mzJsHBwRw8eJCGDRvi5eXFixcvuHHjhtYqD7VFdHQ0jRs31nhfJUqUoEaNGqK3nwJ55ouFCxdiZWXFzz//zI0bN6hWrZqkz7Rq5J4b1VhaWrJ27VpJbWRF2xV/cszFauScp7p27crKlSsZPnx4ju0hxNwrv379mmPHjtG2bVvKlClDdHQ0y5Yt4969e5QtW5Zhw4YJiSxSoe21Xs7vdv78+Zw4cYICBQpQrVo1ILMNx/HjxzEyMuKXX37R2likZubMmVy4cCFHv5s2gngvXrxg1apVBAYGApk+utGjR0uW7G5kZISHhwfjx4/n7t27GBgYULNmTclbUZmZmfHy5UuuX79OXFwctra2JCYmEh4eLmp/aMj8rWZFLXX/+PHjbN9z1apVRbUNmZXue/bsYePGjVqrdFfz119/YWFhwYEDByRT1vyYBQsW4OPjIzznZf2MpSwk0/PfUKikjDbo0SMh9erVw9jYmOnTp+eYGShVsMvb25vZs2ejVCoFZ2pERAQqlYq5c+d+Uub4v5K1L1lWTExM8PDwkKzX0afs5sR/7X+YkZGBp6cnFy5c4MiRIxrnUlJSaNiwIT169GDGjBmSZME+f/6c7t278/btW2Hzp1KpMDMz48CBA5ibm4tuMytpaWlERkaiVCqpVq1ajv09xCApKYnY2FicnJxo1qzZJ6tIPieJ+78yceJErK2tGThwIBMnTvzstVJlZjZv3py//vqLSpUqUbp06WwbfLkqe6UiIyODtWvXsmbNGlJTU7Ump6Ut5J4vciIyMpKSJUtK6qzdtm0bv/zyyycfUMWsqswNn7GDgwMmJiasWrWK3r17s3r1amJjY5k+fTojR46UTF5Rm1haWmb7PtUPVB+jrapZbfyW5ebRo0caD+lSOASyYmdnx1dffcWePXtwdnZmx44dfPjwgcGDB9OzZ0+ttJfRFh4eHsJcZWdnh6mpqcY+XSoHhYuLC8+ePcPCwoIaNWpkm5eWLFkiid2c0MY9tGrVKvbs2cPevXslr4zLqW/yp5Di+7W2tsbW1jabI75///4EBwfrnGw0yLOPCwwMZNiwYUyePBkXFxc6duwoSDu7u7vrVI93Nzc33rx5w9atW+nWrRstW7akb9++jBo1CnNzc3x9fbU2FqnmC2traxo2bMjWrVuxtLSkdevWrFy5UlQb/ytSz43p6ekcPXoUV1dXjerJwMBAVCqVpIlfKSkpTJkyRaj4U+Pq6sqiRYuyJY/qAnLMU+p9s9R75cePH+Pu7k5cXBze3t5YWFjQoUMHoqOjhYCHgYEBW7ZskVT2VptrfVbk+G4bNmxIgQIF2LVrFxYWFkBmn3l3d3fS09M1WrzldRo1akRSUhJjx46lZs2aGiqbAE2aNJHM9rNnz+jVqxexsbEawbuSJUvi7e0tqh9QTf/+/bGzs2Ps2LEax6dMmcJff/3Fpk2bRLcJmSpNp06dEuYKHx8fVqxYwblz5+jVq5eo+5ratWt/0XVSqk/KxahRo3j69Ck+Pj5a8701a9aMjIwM5syZw8SJE/n555958eIFK1asYOrUqQwcOFAr49Dzv6EPROvJs7Rp04YyZcqwdetWrdrt0KEDT58+ZevWrUJfo1u3bjFgwAAqV67M0aNHJbF748aNbMeMjY2pUaOGpBI16sqsL0GKDUtW3r9/r1FhExERwdu3b0V9oHz16hVeXl4aEl7Dhg2TPAjt5eXFpk2biI+Px9nZmSZNmnD9+nV+++03yRy2N27coHjx4sImX0qy9hX6XHKDQqGQLNDSoEEDatSoIcjU5Bfu3buHn59ftioIKe6f3IQ25gs5aNasGW/evKFy5cqUKlVK1oQKbXzG1tbWNG7cmPXr1+Pu7o67uzudO3emf//+REdH60TF//9SJaNLCTNyOSQ+Jjk5mUePHlGtWjVJM7itra1p1KgRGzdupF+/fnTs2JGePXsyePBgHj58KHpVp5w4OTnx8uXLT1Z5SOV8adCgAZUrV+bQoUNaqSaRmxkzZnD8+HEgUyHC2NhY4/zH/Zv/C7Vr1xb6Jn/O0SbV99uhQwceP37MokWLcHR0JD09nfPnzzNr1iyqVq3KsWPHRLcJmfPUpzAyMqJUqVK0bt0aJycnSeyD9vdxr1+/Jj09nTJlyhAWFsaBAweoWLEiffr0yeYoz8vs3buXWbNm5ZgINnPmTPr06SPTyMTD0dGRN2/eUKxYMd6+fUvBggUxNTXNdp022pppg6SkJAYPHsytW7dYv369hqLcqFGjuHDhAl27dmX+/PmSrhFPnjzRasUffD4Aoo2ghzbnqX/aN4u1Vx4/fjwnTpygcuXKbNiwAX9/f2bPno2hoSEzZswgKiqKzZs306JFC0kr77W51ueENr/bZs2aUbNmTTZv3qxxfODAgURERHD58mXRbMlNy5YtqVKlitZVbeD/ftstW7akW7duAOzfv5+LFy/Svn170QpDAgICBH/y1KlTqVOnjsa+Kj09ndWrV/PmzRtCQkJEsfkx0dHRjB8/nsePHzN06FCGDRvG3LlzCQ0NZePGjRQrVkw0W9os4voUERERmJmZUbp0aby9vbl06RKOjo58++23kthT8+rVKzp27EipUqVo0qRJtsQrsXrZZ8XKyoqmTZuybt06unXrxuDBg2nfvj3u7u68e/dOqwmFer4cvTS3njzLjz/+yLhx4/Dy8qJFixbZNmRSVbY8efKEhg0bCkFoyHR8NWjQgFu3bkliEzQrvBMSEihQoIBWsmpzCi7Hx8fn+BArNR/LPHp4eHDu3DnRApcbN27E3t6eWbNmifL/fSmbN2/G09NT4/t88OABp0+fZunSpaL3KFPTqFEj7t69y8CBA4XsUnt7eyZPnvzF2Xxfyvfffy/IK40ePVoWB7GbmxsBAQGy/X7lwtLSMsdNsdj3T25D6vlCLlJSUrC2ts4VCRXa+IxLlixJWFgYMTExWFtbc+LECZo0acKzZ8+IjY0VzY6c6FJw+Z/I6pC4ceMGCQkJGg7a9PR0AgICePPmjWRjeP/+PbNmzaJ79+5YW1vTtWtXnj59Srly5di6datkiWdly5blzp07hIeHY2Njw6FDh6hevTr3798XpNt0hejo6E+ekzIHukWLFjx8+DBfBKEBDhw4ILz+2KEl9mcgV99kNYMGDWLGjBlMmjQpmz0p20PcuHEjx1Y2WY/5+Pgwb948yXrMa3sfV7JkSeF17dq1dUqtISs9e/YkPT0dLy8vYmJiAChTpgzDhw/XiSA0wLfffsvKlSsFta/k5GSSk5OzXacrc+batWu5efMmJiYmxMfHa5wzMjJCqVRy8OBBrK2tJelPrVY4cXZ21krwOStyzMtZ0eY8pa19c0BAAGXKlOHo0aMYGRnh5+eHQqHAxcVF+P1cunRJckUOba71OaHN7/bbb79ly5YtREZGUr16dQBCQkIICQnJlria1xk4cCBeXl68fPlSMjnsT+Hv70+VKlX4/fffhd+Qs7Mzbdu2FTXYn5KSwtSpU1EoFELByce+TZVKJXzXUlC+fPlsbbDGjBlDiRIlRLclVXD5S7lw4QLff/89CxYsoGLFikJrzXPnzqFQKCRZ99Rs376duLg44uLiiIyMFI6rlSukCEQXK1aMyMhIkpKSsLKy4vz587i6uvLu3bvPPovqkRd9IFpPnqVw4cIYGhqyfPlyli9frnFOyqzPokWL8ujRI5KTkylYsCCQmX37+PFjUbOpPkalUrFp0yY2b94sOGjLly/PiBEjJJMDh0yn8PLly3FychIy2EJCQrC2tub3338Xva+GnKxevZqqVatqbPa1we7duylVqhTHjh0TegyNHTsWPz8/Tpw4IVkg+t69e/Tp04fExEThmL+/P71792b37t3/U0bfP2Fubi7Ix8slpTtlyhTatGlDmzZtqFevXrZEDqkkwfXoEZNOnTpx8eJFEhIS8kXvGzc3N7Zs2cK+fftwdHRkxIgRwlwidsKMHunJDQ6JxYsX4+vri7W1Nffv3+fJkycUKVKE6OhoPDw8WLZsmSR2u3XrhqenJ+fOnaNVq1Zs3LiRvn37AplShLqEHH11IVMtadasWYwYMYLGjRtjYmKi4aQVs29kbmDhwoVasyV33+Ru3bqRlJSEl5cXf/31FwClSpVi5MiRkgWAITOwNXHiRJo3b0779u2BzMDzlStXmDFjBsnJyfz6669s375d0nFoi9jYWJYvX87NmzdJTEzUCGApFAqdUCHJyrfffsu3335LbGwshoaGOpeoOnr0aDp06MCrV6/o168ftra2/PDDD3IPSzJOnDiBgYEBO3fupE6dOhrnli9fzsWLFxk5ciR79+6VxCHv7+/P1atXKVasGF26dKF79+5CIrbUnD59WnitUqlISUkhNDSUpUuX4uXlpZUxSE1iYiJ+fn68fPmSChUq4OTklK0YRUz+/vtvmjZtipGREWlpaUIv3aZNmwrXlC9fnqdPn0o2BtDuWi83z549Iz09nW+++YaqVauSmprKkydPUCqVnDp1ilOnTgnXSl0JLjX3798nIyMDV1dXKleuTKFChTT2rFK+v5SUlGzKakqlklKlSvHq1SvR7DRr1oyePXsSERHBzZs3KVq0qMYznlKppESJEgwZMkQ0mwCXL1+mZMmSWFpa/mNgPatyRl5nzZo1ZGRkYGBgwNGjR1EqlYwbN441a9awa9cuSQPRe/bsQaFQ4ODgkGPrVClo3rw5Pj4+rF27lsaNGzN+/HjOnj1LUlISVapUkdy+nn+HPhCtJ88ye/Zs3r9/n+M5KbM+W7VqJTy8tG3bFgBfX19evXolqQNixYoVeHl5aby358+fM3v2bP7++2+GDx8uiV1PT082bNhA6dKlefDgAcHBwQDcvn2b5cuXf7K/cF7E0tKSV69ekZKSIqk858dER0fTuHFjjV5ZJUqUoEaNGty8eVMyux4eHiQmJuLu7i4kM3h7e+Pt7Y2np6eoD61Tpkxhzpw5ODk50alTJxwdHSXrgf0pli5dKvS5O3funMY5hUKhD0T/S750864rsn9yY2ZmxuvXr4WEio8dMLr2O544cSIKhQJra2tatGhBt27dOHDgAEWLFmX69OlyD0/P/4hcDomsnD9/ntKlS9O2bVumT59OsWLFuHTpEp07dyYgIEAyuyNHjqRIkSJYWloKkuTr16+nUqVKQsa6riB1q5ZPMW7cOBQKBZcuXeLSpUvZzutaILpLly5as5X1O5Xr++3Tpw99+vQRehpqIxl206ZNlCtXDg8PD+GYs7Mz7du3x8/PDy8vL06ePKkzPap/+uknzp8//0lZfV3j5cuX7Ny5k8ePH1OgQAFq1KhB7969JamUkovKlStTuXJlFi5cSLly5TRU1nSN58+f07Bhw2xBaDUtWrSgQYMGhIeHS2J/9uzZHD58mODgYKGAwNbWlp49e9KmTRtJ/Qs5VWBbWFhw9epVfv31V3bt2iWZbW0QGRnJgAEDNBRzKlasyLZt2yhXrpwkNosUKcKLFy8AuHLlComJiSgUCho3bgxAamoq4eHhlCpVShL7arS51suNj4+P8PrBgwfC64yMDMEPCbqxHh06dEh4nfW9gvTvz8LCgps3b3Ls2DE6dOgAwJEjR7h58yY2Njai2lL7i/v164ednZ1WkqGGDh1K69atWblyJUOHDv3k56lrvZojIyOxtbWlffv2rFy5kpo1azJ8+HCuX78uqXorgKGhIXZ2dlqVmp8xYwbv37/HwsICV1dXmjZtir+/P4aGhowfP15r49Dzv6EPROvJs7x48QJzc3O2b99OmTJltLYZmTBhAjdu3CAsLEyQ3lCpVFSoUIFx48ZJZnffvn0olUpmz55N69atUSqVnDlzhtmzZ7Nt2zbJAtHHjx/HzMwMBwcHPDw8KFy4MKdOnaJXr146F1SysLDg1q1bfP3119StWxdTU1ONYKlUAZ4KFSoQHBzMn3/+CUBaWhqXL18mKChI0t7UgYGBWFpaMmfOHOHY3LlzCQ4OFt0ZX6RIERISEjh+/Di+vr4ULVqUdu3a0aFDB61Vgh0/fhwDAwO++eYbrWXp5Qdev379RdfpwgNjbuD3338HMpU4Pq5K08WECkNDQ6ZMmSL8vWDBAiZNmkTRokX193AeJatDwtbWVtK9U068ffuWZs2aUbJkSW7dukWjRo0wMjKiYsWKXL9+XVLb6gpogO+++47vvvtOUnvaxN3dnUaNGjFhwoR/zLiXqspD7F65uZFly5ZRo0YNOnXq9NnqfYVCIaoTZuLEiV98rVjr0KNHjz57/t27d8JrqVoy3bp1K1tQS6FQYGZmxtWrV4HMBJqMjAxJ7Gsbf39/ChYsyOTJk6lcubLWk0a1ydWrVxk1ahTJyclC4F2hULB161bWr1+v0YZLF+jSpQtRUVHMnTuXkJAQrKysaNu2LUlJSbRq1Uru4YlCoUKFSEhI+Ow1SUlJktlXV9hHRUVx8OBBfH19CQwMJCgoiAULFki+x/iYDx8+EBkZycOHD7VqVwoWLlzI69evKVSoEBYWFoSHh/Ps2TN+/fXXbOqIYlG/fn0uXrzIpEmTCA4ORqFQULduXczNzQkNDWXVqlW8evVKKE4RE7nWernJT9Xfcr7XIUOG8MMPPzB58mSh/Ya6bYNU7U6ySuonJCTw6NEjSpcuTZkyZUS3Vb58eYoXLy68zk8YGhry119/8fjxY3r37g1kttY0NDSU1G7v3r3Zs2cP0dHRWvvMixQpwooVK4S/N27cyN27dylbtqxOKbfqGvpAtJ48i4ODA7GxsVrvp1GsWDEOHjzI7t27CQwMRKlUUq9ePXr16qVR0So279+/FzJq1XTv3p0jR44IAUwpeP36NU2aNMHCwoKgoCDq169PyZIlqV69OteuXZPMrhyoe4f8/fffXLlyReOclAGeIUOGCP0qFQoFFy9e5OLFi6hUKsl7lKnl5f/p2H/l6tWr+Pv7c/LkSc6dO8fff//Nrl272L17N+XLl6djx4507NhRUjnWYsWKUblyZRYsWCCZjfzItm3b5B5CvkKuHuty8vbtW5RKJUWLFuWPP/7gjz/+oFmzZrRo0ULuoen5D3yqx19iYiIBAQF8/fXXktgtUaIEjx494tixY3z48IFGjRoRExPD7du3JXGGqFm1atUnzxkZGVGqVCkcHR0lr6yRiuDgYKG3bNaqlY+Rcv7KD/3W161bh4uLC506dWLdunUan6e6D5v6XzGd08ePH/+i68TcL7dr1+6LbUpV0VK6dGlCQkJYunQprq6uqFQqTp8+TXBwMBUqVODixYvcuHFDtipxsSlWrBjm5uY60yP5cyxevJikpCTs7OxwcnJCqVRy9uxZAgICWLBgAfv27ZN7iKISGhrKgAEDhKrO8uXLc+XKFTZt2oSnpyeurq5yD/E/Y2VlxdWrV7l48WKOe8QLFy4QFhYmeVV45cqVadu2LRkZGXh7e/Pu3TuNxBkp+FihKiMjg/j4eNLS0qhcubKktrVBaGgopqamHDt2jDJlyvDo0SO6d+8uyGVLwffff8/169c5duwYkBngmTp1KgArV67kjz/+wMTEhJEjR4puW661Xm7yU/W3nO/Vzc2NefPmaSgGmpqaMnr0aNETK/bt28eOHTv49ddfqV27Nvv27eOXX34hKSkJhUJBly5dmDdvnqiJb1nVDz9WQtRlqlatSmBgIGPGjEGhUODo6IiXlxehoaE0adJEUtsvXrwgISGBdu3aUaVKlWyqfVIlIaelpZGWloaxsTHh4eEEBgbi4OCgD0TnYvSBaD15lk6dOvHTTz8xfPhwmjVrlm2ik1J+r1ChQgwZMkRS6ciPcXNz48aNGxqy0XFxcTx8+FCSLEw1ZmZmvHz5kuvXrxMXF4etrS2JiYmEh4fr3OQuV4CnZ8+epKen4+XlRUxMDABlypRh+PDhkjqC6tatS0BAAGvXrqVbt24A7N+/n9DQUEFySiwMDQ1p0aIFLVq0ID09natXr3Ly5EnOnj3L8+fPWbt2LWvXrsXS0lJDpkhMhg0bhqenJ6GhoaJLDuVnvtSZI2XLhPyEXD3W5SI4OJghQ4bw888/U716dYYPH45KpWL79u14enri5uYm9xD1/EsiIyOZPHkyDx8+FLLwsxIWFiaJ3ebNm7N//36mTp1KgQIFaN26NbNmzeLvv/+me/fuktiEzED0p/YYameiiYkJ69atw87OTrJxSIVa9lX9WlukpKRQoEABChQoQEpKymev1WbbFano3LkzVlZWwmtt7Vvl2CN/6b5Byv3FyJEj+emnn9iwYQMbNmzQODds2DAiIiJQqVQ6EcSDzPe7dOlSoqKidCJ49TkiIiKoWrUq27ZtExRW+vfvT8eOHbl//77MoxOfJUuWkJqaypw5cwQ1LBsbG5RKJV5eXjrxGx48eDBXrlxh9OjRtGnTBhsbGwoXLkx8fDwhISGcOXMGgIEDB0pi//Xr1xw9ehQfHx9B/lupVNKqVStJe3OqbeeEiYmJEDzNy7x//57GjRsLCYNVq1bF2tpa0kC0lZUV+/fv58CBA2RkZNC5c2csLS2BzGSDggULMnbsWGrWrCm6bbnW+tzA3bt3Wbx4MUFBQUCm2s3kyZOpXbu2zCMTn/PnzxMZGamhzPHhwweCgoKEIhmp6NmzJ507dyYiIgKlUkm1atVE3ycfO3aMmTNnolAoSE1N5fHjx8ydO5e0tDQKFixIamoqBw8epHr16gwePFhU22qmTZuGlZVVNr/q4sWLiYuL06kilREjRjBu3DiCg4OxsrLi66+/5sSJExgaGkquwnXgwAHhtVo5Vo1U89fDhw8ZOnQo06ZNo3bt2vTo0YPU1FQMDAxYv3696D5tPeKgD0TrybNMmjRJ6AOXk0S0VIHo1NRUdu/eTVhYWI4OLzGrZrPK8BQpUoSYmBihv25aWhqXLl0iJSVF0k2Zra0tp06dYuDAgSgUCpydnZk0aRIxMTE612tPzgCPWsorNjYWQ0NDTE1NJbc5evRoBg0ahKenJ56ensJxpVLJiBEjJLNboEABHB0dcXR0ZMaMGSxdupSdO3eiUqmybVrE5MyZM6SmptKrVy+KFCmiUfmt718sDmlpaezZsyfHB6rg4GAuXrwo8wh1g6ioKLZs2aKz0opZWbZsGR8+fCA+Pp5Dhw6hUqno1asXBw4cYMOGDToRiP5fnJNSZRPLwYIFCz5ZxSilxPLkyZP58OEDjx8/ZvDgwZibm1O5cmVcXFwk3QdMmTKF1atXU7x4cVq2bAnA2bNnefv2Lb169eLFixecOnWKFStW5EmliayVHdqs8qhXrx4uLi6sXLmSevXqffI6XekD9+uvvwKZ6j3z5s0TnIb+/v6EhYVRtmxZWrduLbozUY49spR7wi+le/fulCpVirVr1xIZGUl6ejoWFhYMHjyY1q1bc+DAAcaMGSNJRZy2+HgNSk5OpmPHjlSrVk1rFS1yUKNGDQoWLKjR5kOpVFKwYEFq1aol48ik4fbt29jb2+Pu7i4Eol1dXWnQoAG3b9+Wd3Ai0axZM3788Ud+++03jh07pqHkoE74GjNmjGT75ZYtW5Keno5KpaJcuXJ069aNHj16SKq2oianfYOxsTE1atSgUKFCktuXmvT09GzzUaFChUhPT5fUbvXq1fnxxx+zHVfLGUuFXGu93Ny7d48+ffqQmJgoHPP396d3797s3r1bSATQBVavXq2hlqSeo7RFRkYGr1+/xsTEBIDnz58L58Rqd7Jjxw4gM8mtWrVqrF27lrS0NMqVK8fhw4eJjo6me/fuHD16VNRAdEREBG/fvgUye3E/efJEI2EkPT2dCxcuEB0dLWog+nMy+lmRSsmgdevWHDlyhCdPntC4cWMMDAzo0KED/fv3x9raWnR7WZFDan7x4sW8ePGC58+fc+fOHVJSUnB0dOTKlSusWbNGH4jOpegD0XryLHL1gZs3bx779+8Hsmfgiy3fnJMMz+PHj4mKitKwP3/+fMkqZ6dMmcLLly95/PgxQ4YMoVatWpQuXZo6depova+jNggPD2fjxo08ePAApVKJhYUFQ4cOFV0yetq0adStW1ejXyRkSoZqCwcHB9auXcuiRYuIiIgAoEqVKkyYMEFS6Zb09HSuXLnCiRMn8PPzIyEhQfgtSym1r+7lB5l9UuLj44W/81OWsZQsXryY7du3a0iGqdH38xWH/CCtmJV79+5hbW1Nr169+Oabb6hWrRpz587l0aNHklXMapvPyRhnRdfmqdDQUCpXrsyePXtwdnZmx44dfPjwgcGDB0saBChatGg2R8GkSZMkd+ZFRkZSqFAhDh8+LDiFx4wZQ7t27UhLS2P58uV07dpV0nYrUvK/VG6ImcioUqmEteZzlbG6osqRmprKtGnT8PX1Zc+ePdjY2DBjxgwOHjwoXFOjRg22bt0q6p7y8uXLlCxZEktLSy5fvvzZaz+WiJWSwMBA9u7dy+LFiyWzoVb0yQm1olBe5lNrkLYqWrRJ1r7j/fv3Z+bMmSxfvpzWrVuTlpbGkSNHePbsGRs3bpRxlNJQsGBBXr58qTEXJicn8/TpU50IVKoZPHgwTZs2Ze/evdy+fZt3795RuHBh6tSpQ8+ePSVVxcrIyKBFixa4u7vz9ddfa/XZJ6tCVUJCAikpKVr1K2iD2NhYjfUnNjYWgCtXrmj8rrW5BkmFXGu93Hh4eJCYmIi7u7vQktDb2xtvb288PT3x8vKSeYTicejQIQwNDenRowc7d+6kb9++PHz4EH9/fyZMmCCp7WvXrjF+/Hj+/vvvbOfETNwMDw/HysqKH374AYBLly6hUCho06YNZmZmmJmZ0aBBA9GffcLDw5k4caLw982bN+nfv7/GNSqVSvS2Kh/773NCakn96tWra/iumzRpgq+vLwsXLmTXrl2S2AR5pOZDQkKoUaMG/fr1w93dnQoVKrBhwwbc3d11UtlGV9AHovXkWX744QdsbGy0ngXo6+uLUqmkc+fOlClTRtIHjNwgw1O+fPlszsUxY8ZIvuENCAigePHi1KhRQ+P4jRs3SExMpEWLFrRv317UavBz584xduxYIZMZ4M6dOxw9epTVq1eL2o/00KFDxMfHawSinZ2dcXR0ZO7cuaLZ+SeaN29O8+bNiYuLQ6lUSlaJnZGRwfXr1/H19eX06dNCnyyVSoWpqSlubm507NhR0p5debHC7N8ix/0DcOrUKUxMTPj+++9ZsmQJEyZMICoqigMHDkgqCyfX+5UDuaQV5fqMU1NTKVq0KHFxcTx48EB4yNGVoBLIk0GcG0hOTqZixYoUL16cunXrcufOHXr27ImdnR1+fn6SVZv4+Ph89nznzp0lsevr64uNjY2Gw9/MzIwaNWpw+PBhfvrpJ0qWLJlnH5xnz579xXtWMQPRZ8+eFao5zp49K9r/m1tZv3690K8SMufgAwcOoFAoqFevHm/evCEiIoI1a9aIeg8NHTqU1q1bs3LlSoYOHfrJ71obled///03Pj4+7N27VwgsShmITkhIYNu2bQQGBqJQKLC3t6dv374UKVJEMpvaXHPz0xqUU99xLy8vjeCGWnlFFxQUsuLk5ISPj4+wjwoNDaVDhw7ExMRItu7JhaWlJbNmzdK63fPnz2ul+vlTHD16FC8vLx4+fIizszNOTk48ePCAKVOmSGJP288GwcHBDBs2LNvxoUOHCq91Rf1ErrVejVzPfYGBgVhaWgrPuABz584lODiYgIAAUW3JTUxMDPb29sycOZPLly/TvHlzfvrpJ9q0acO5c+cYPny4ZLbnz58vVAx/jJjP2KmpqRQrVgzITBxRtyxwcHAQrlEoFKL7vNu1a8eBAweIiIjg1atXGBkZCeOAzAKJ4sWL8/3334tqNzf479U8ePAAb29vjh49KvhexWbZsmXUqFGDTp06fbYaXKrA+4cPHyhfvjzJycmEhYXRpk0bILMlRWpqquj29IiDPhCtJ88yevRoypUr948ORbExMTHBxsZGK70k1JI8ciOHA6Zfv36CwysrK1asIDIykqtXr+boTPgv/Pbbb6SlpdG+fXtB7tXPz48jR47w22+/iRqIzonnz5/z5s0bSW18iqJFi0r6/zdv3lzIWlapVBgZGdGiRQs6duxIy5YttZJQsm3bNho2bChZ/5nchBz3D8CbN29o0qQJgwcPxsfHh6pVqzJ8+HDu3r3LwYMHs2WiioVc71cO5JJWlOszrlixIjdv3mTGjBmoVCqaNWvGvn37uHnzpuQSU9pCjgzi3EDZsmW5c+cO4eHh2NjYcOjQIapXr879+/f58OGDZHanTp36WSeBVA55Y2Njbt68yR9//EHz5s2BzMqAmzdvYmJiwt27dwkKCqJ48eKS2JcauZSKslYzZH2tqxVhx44dw9DQkHXr1mFjYyM4oGvXrs2ePXuIj4/HxcWFixcviuqcLl++vPDbLF++vGj/7//C9evX2bt3r9BqRe0sbdiwoWQ23759S+/evXn8+LFgz9/fnyNHjrBz507J7ldtrrn5aQ36Ugd7RkaGxCPRPtOnT+fRo0dCBfyrV6+AzD64kydPlnFkeZusjvidO3d+8jopK+AADh8+nC3gfPfuXXbu3Impqakk/UG1OU/Jte7IhVxrvRo5n62ztk/73LG8TqFChYSKZCsrKwIDA2nRogUlSpSQvDXJkydPMDc3Z/v27ZQpU0ay4Gm5cuW4c+cOCQkJ7N+/H5VKRcGCBYXik8jISIKDg6lSpYrottXKJk5OTjg6OjJv3jzRbXyM3P775ORkjh8/zt69ewkJCQEy9z0GBga0bdtWdHvr1q3DxcWFTp065ajmqlZIlGr9K1u2LKGhofz222+kp6fTpEkTLly4QFBQkOiKpnrEQx+I1pNnMTMzw8BA+z/hfv36sWHDBm7evCmp4wP4R+m7rEglQaRNB8ymTZs0HuAuX76Ms7Oz8HdGRgYvXryQrGr32bNn1K5dW0Ne3dXVlcjISB48eCCJzfzCmzdvUCgU2NnZ0alTJ9q0aaOVPthZuXr1KnFxcTobiJb7/oHMeVndX6hu3bpcvXqV1q1bo1AoePz4sai2csP7lQNtSivmhs+4X79+zJo1Cz8/P8zNzWnVqhUzZswgIyNDowJClzh//nyOfdaDgoL+J/nj3E63bt3w9PTk3LlztGrVio0bNwoqIVLurxo0aCA8KKtUKlJSUoiKikKlUkkqbf/NN9+wefNmhg8fLvQ5TEpKAqBnz54EBgby/v17yZPepGL79u1yDwHQfkWYtnn27Bm2trZCCxV/f38UCgWtW7cGwNTUVHBoism5c+dyfC01sbGxHDp0iH379mVrTVS6dGl+//136tatK5n9ZcuW8ejRI+rUqUOnTp2AzIBPWFgYHh4eojo2c8OaC9prUyQHuaHvuFyYmpqyZ88erl69yt27dzEwMKBmzZqStmPKD3zOEa9GailWyKygLVq0KLt37xYChO7u7hw5coQDBw6IFoiWa57S5rqTG5Bjrc8Na1DdunUJCAhg7dq1QuuL/fv3ExoaqnP9Xq2srPD392fLli3Y2dmxaNEi7ty5w82bNylVqpSktuvVq0diYqKkbfEgU/Fx8+bNNG/enKSkJBQKBe3ataNQoUKsWrWKzZs3k5qaKhQBSYGcc0dcXBxRUVGkpKRoPNMHBAQwadIk0ezcu3ePvXv3cvToUY22h5CZpLtnzx5JflOdO3fGyspKeK3tavAuXbrg6enJrl27KFasGC4uLsycOZOUlBR69+6t1bHo+XL0gWg9eZauXbuycuVKhg8fjp2dHUWKFKFAgQLCeTFl/7LSqVMnNm3aRJ8+fShcuLDgTITMTNc//vhDNFufk77LipQSRNp0wHTv3p21a9cSFxeHQqEgMTFRCGplRYpsLsjcDH5chaVSqUhKSqJBgwaS2MwvTJw4kY4dO0q+2f0cbm5unD17ltDQUEn7g8mF3PcPgJ2dHWfOnGHNmjU0atSIGTNmcOXKFZ48eUK5cuVEtZUb3q8caFNaMTd8xj179qRcuXJERUXh5uaGiYkJLVu2pH379hrOEV1h9erVrFq1Svhb7bzURUaOHEmRIkWwtLTEzs6OsWPHsn79eipVqqQhySc2u3fvznbs3bt3dO/eHQsLC8nsTpw4EYVCwfbt20lMTAQyE0t69uzJ5MmT8fLywsHBgWnTpkk2BilJSUmhQIECFChQgJSUlM9eK5UKStaKMPV9I3VFmLYpUKCAUK358OFDoqOjUSgUGq1N4uLitNbzNSUlhQcPHlC0aFEqVqwo6v89fvx4/Pz8SEtLQ6VSoVQqsbe3p0OHDsycOZOvvvpK0iA0ZCYGlStXjt27dwsVWe7u7rRp04azZ8/q1HMQaLdNUW4ipzlL2+2/tEWTJk30wWcRkdsRryYqKgoHBweqVasmHKtRowZ169YVNViZG+YpOYmNjdVIFFUjdsW2HGt9bvhuR48ezaBBg/D09MTT01M4rlQqGTFihGR25WDKlCkMHTqUwoUL4+bmxvr167l69SoAPXr0kNT23LlzcXd3Z8iQITRv3lxocaNGLF/66NGj+fPPP7lx4wYA9evXF9q13b9/n/fv3+Pg4MCgQYNEsafG3d2dRo0aMWHCBNzd3T977Z49e0S1rcbPz49x48aRnp6e43mxAtE9e/YUVPHUbQ9bt25Nhw4dGDx4MGZmZpIlNqgrwP/++2/mzZsn7Jv8/f0JCwujbNmytG7dWrL91MiRIylWrBhRUVF069aNokWLYmdnh729veT3kJ5/j0KlS0329OQrLC0tNaQePiYsLEwSu/369ftkfxKFQiGqXScnpy++VqpML0dHRwwNDTl58qTggElKSqJNmzakpqZy5coVUe2p+3gMHjyYhg0bMmbMGOGcQqGgRIkS1KxZU1Sbai5cuMD48eNxdnbG1dWV1NRUjh49yuXLl5k+fTqVKlUSrv2vFeiWlpY0aNCA0aNHC8eGDh2a7ZgYtvRk0qdPH27duoVKpcLQ0JAiRYoIPd7FTiKRCznvH8jsdfTdd9/Rt29f2rZty7fffivMibNnz+bbb78V1Z7c71cO4uPjGTZsmCCtqMbKyop169aJLkObHz9jOXFxceHVq1f06NGDnTt30rdvXx4+fIi/vz8TJkyQtF9Yfmfq1KncuHFD8sz55ORkoqKiSE9Pp1KlShQuXFhSe9qidu3auLi4sHLlys/2DJQyebJDhw789ddfQkWYi4sL48aNo3fv3piamupED+kuXboQGRmJl5cXBw4c4Pjx4xQvXpwrV66gVCqFYHz9+vVFd675+Phw4sQJzM3N+e6774iOjmbUqFG8fv0agKZNm+Lp6SlatZT6Wc/IyIiRI0fSrVs3SpcuLZyrXbs2hw4dEsXWp7CxsaFBgwZs3bpV4/iAAQMIDg4WpA/FQu41t127djx8+DDHNkUWFhYcPXpUMtva5t69e0ybNo379+9nCyrpSp/ZL+3fqivvNz/j5OREcnIyR44coVmzZri4uDBhwgR69OhB8eLF8fPzE82W3POUHNy8eZOpU6fy9OnTbOekuH/kWutzw3f7xx9/sGjRIiIiIgCoUqUKEyZMkFS1SA4+fPiAgYEBSUlJmJmZ8fLlS2GP5eLiIqntbdu28csvv3wycUZsX3pERATp6enUqlVLOHbmzBmUSiWtWrUSfHJiYWlpiYuLC6tWrcLS0vKT14ntv89Kly5dCAsLw8LCggcPHlCvXj2eP3/O69evNVqs/Vey7pXHjx9Pnz59MDQ0FM5JuVdOTU1l2rRp+Pr6smfPHmxsbJgxYwYHDx4UrqlRowZbt27VuVZJev49+kC0njxLv379PnteKolAGxsbTExMmD59OmXKlMm2aGbNUtQFtO2AUXPjxg2KFy8uaXXSx6gX8X9CjIcNbdrSk4lcm1A5kOP+yUpKSgpGRka8f/+eK1euYG5u/sXOsH+D3O9XDrQtrSjXZ/z69WuWLVtGSEhItgoEhUIhqmMtN2BtbY29vT2bNm3Czc2N6dOn06JFC9q0aUOxYsUky9qWi6ioKLZs2UJISAhWVla0bduWpKQkWrVqJZnNj9uepKen8/LlS5YtW0ZycnK2JI//Qm6oEtYWX+r0Aenkca2trXFwcGDDhg0a4xk0aBCBgYFCxUBeZufOnfz8888ae8ixY8cyatQoxo4dy5kzZwBYuHChqCoZe/bsYe7cuUICcM2aNVGpVISHhwvXKBQKOnfuzMKFC0WxaWVlRVpaGgqFAmNjY5ycnGjfvj3NmzfH2tpaK4HoTp068fjxYzZv3oytrS0AgYGBDBo0iOrVq+Pj4yOJXbnWXBsbG6pXr57tc+3WrRsPHjwgNDRUq+ORku7du3Pnzp1PntcFGe9/mouzogvv91O8efOGoKAgihYtir29vehBj39i/PjxREVFaTjnxcbLywtPT08MDAxIT08X/s3IyOD777/n+++/F91mfnr+6tWr12f9XmLfP3Kt9Wpyw3cbFxeHUqnUuTZbapydnalXrx7Lli3Tuu1mzZrx5s0bKleuTKlSpbL5JXNLu51/y6FDhyhXrhyNGzf+x32iWmVObBo0aEDNmjXx9vbG0dERT09PqlevTvv27alXrx6///67KHbU3yVk7sPr1atH+/btadOmDc2bN5d0r7xmzRpWrFgBwN69e0lKSqJ///7CON68ecOzZ8/o06ePJL3sExMT2bRp0yf9RB/HMPTkDvTS3HryLHItjlWrVqVYsWJ88803stjPSkpKCr6+vuzbt0+jn4uYVKlShVu3bhEUFKThgLl586akvcIaNWrE+fPnuXjxotb6ZIotqZRbbH2KyMhI5s2bJyzcWdHFAPi2bdvkHoLWkOP+yUpCQoJgVy1XFx0dLdnvXu73KwfallaU6zOeOXMmFy5cyFatBHxRMk9eo1ChQvz9998AQu+3Fi1aUKJECZ1zEoeGhjJgwAASExNRKBSUL1+eK1eusGnTJjw9PSWrfPhU2xOVSkXLli1FtVWvXj2hSrhevXqfvE4X1tyzZ88K0n5yVR6XKlWKsLAwwSEDmZKWoaGhlClTRpYxiU2fPn14+/YtO3fuJCMjg549ezJq1CggU8pTLV8ptmN6+/btKBQKhg8fTlJSElu3bkWhUNC3b1/Gjh1LZGQkgwcP5tKlS6LZ/OOPPzh8+DAHDhzgwYMHHD9+HF9fX8EpnZaWJpqtT9GnTx9mz55Nv379qFy5MoDQU16qNlAg35qbn9oUhYeHU6pUKTw8PHJMLtcFTp8+Lby+desW06dPZ+jQobRu3RqlUomvry+7d+9m48aNMo5SXFatWsXJkycxNzdn8uTJPH/+nLFjx5KUlARA9erVWb9+vegtgz7Ho0ePuH//vqQ2RowYQUJCAtu3byctLY3U1FQKFixInz59JGtLkZ+ev8LDwylevDhr166lVq1aGBhI60qXa61Xo83v9tGjR589r1ZdgUxfrK7w/v17/vrrL1lsp6SkYG1tzb59+2SxLzVZg8sODg4YGxtnq8iNiooSWiVJhVpR1MrKiuDgYOzs7Khduza3bt0SzcbFixc5f/48Bw4c4I8//hCKxdSy2YmJiUKRiNgcO3YMQ0ND1q1bh42NjRBsrl27Nnv27CE+Ph4XFxcuXrwoSSB61qxZHDt2LN/4iXQFfUW0njxNRkYGR48eJTAwEIVCgb29Pe3bt5f0QTIgIICRI0cycuRImjdvLiwuarSxOXrw4AHe3t4cPXqUd+/eAdJJkXt7ezN79myUSmU2B8ysWbNEl9pV83GfzI/RpepVuRgwYADXr1//5HldC3pkJSYmBoVCIUg86hpy3T/ali1To+vzRW6QVpTrM27UqBFJSUmMHTuWmjVrClJTanStz+GQIUPw9/dnypQpFCxYkEWLFtGgQQOuXr1KqVKldKKFgJp+/fpx69YtfvrpJ+bMmYOLiwudOnViwoQJ1KxZU7LKoZzanpiYmGBtbc2kSZMoWbKkaLZyQ5VwfuJTFWEqlYrRo0dLUhGWm4iMjKRkyZIULVpU9P/bxsYGGxsbduzYAUDXrl0JCwvj2rVrgr2BAwcSGBj42SrTf0tISAj79u3jxIkTvH//Hshc86pXr863335Lnz59RLepxsPDg40bNwqBb6VSSZ8+fZgxY4ZkNuVac7XZpkhuunbtiomJiWTJ3LmNLl26YGxszO7duzWOu7u7k56erhMBid9//53ly5cLf5cvXx6lUsmzZ88wNTUlMTGR9PR0WrduLVRxaYPOnTtz//59rTyPJCYmEhERgaGhIZUqVWLGjBmSVWPr+vNXVjp16kSJEiXYsmWL3EORdK1Xo83vNjc858rBzp07Wbx4MWPGjMHOzg5TU1MNP7aUfuWff/6Zixcv4uPjQ5EiRSSzkxvI2jooK3379uXJkyeiJlBmpWvXrjx48AAPDw8iIiLYu3cvPXr04Pfff8fY2Fjomy0mMTExHDx4kEOHDvHkyRMg874pWrQoXbt25ccffxTVno2NDQ0bNhTmRScnJ168eCGoN0CmbyMwMFASJdWmTZsSFxdHz549qVmzZrYEIX2f6NyJviJaT54lKSmJIUOGcPPmTSEDZt++fXh7e7NhwwaMjY0lsTto0CAyMjJYtmxZNhkVKTdHycnJHD9+nL179wqTuEqlwsDAgLZt20piEzJliKKjo9m4caOQrahUKunbt69kQWjIlFMxNDT8ZJ9MKQkMDNRIbmjYsKGk9uTizp07FC5cmPnz5+cY4JGCZ8+eUa5cOQoUKCAce/HiBWZmZlrpk3nx4kXmz5/Ps2fPAKhUqZIgfatLyHX/LFq0SNj0foyUeW9yzhfa4Es/O138jAsVKkSdOnUYOnSoZDZyE1OmTGHo0KEULlwYNzc31q9fz9WrVwHde5i6ffs29vb2Gn2yXF1dadCggaQSylL3gM5KbqgS1iYPHz7k/PnzmJub07p1a/7++29mzZrFlStXKFasGL169WLEiBGS2f9URVjv3r0lqwjLTUipVJSamoqZmZnwd9myZQkLC9NwhBcuXJj09HRJ7NerV4969eoxY8YMfH192b9/P7du3SIiIoL58+dLGogeP368kDijUCiwtraWvMJerjV35MiRKBQKjh8/zvHjxzXO/fzzz8JrXQgIzJo1i0GDBjFz5kxatGiRzXeQ1wPtHxMZGUn58uUFeX3IbE0RGxvLy5cvZR6dOBw4cAAjIyN++uknkpKShB6oEydOZNiwYURHR9O5c+fPJmLnddSJdWqkrMbW5jw1ceLEL7526dKlotoGmDp1Kt9//z2+vr40bdqUQoUKaZzXZnsVKdd6Ndr8bnPDc64cqKXXc/q9Sr3GmpmZ8fr1a9q0aUO9evWyrX9S3EPaZNeuXZw8eRLI/N0EBgbSv39/4XxGRgbBwcGS+j+/++47fvjhB54/f067du3w8vJixYoVqFQqyXqAlylThlGjRjFq1CiuX7/O3r178fPz4++//2bz5s2iB6ILFChARkYGkPkMGB0djUKh0GhXGhcXl22+FJOGDRsye/Zsyf5/PeKjD0TrybMsX76coKAgypQpQ+vWrQE4c+YMQUFBrFy5ksmTJ0ti93MycFJsju7du8fevXs5evQoCQkJGjYqVKjAnj17KFWqlOh2syKHAyYmJgZ7e3tmzpzJ5cuXad68OT/99BNt2rTh3LlzDB8+XHSb6enpTJ48mRMnTmgcb9euHUuWLNE5ybavvvqKihUrSprIkJXFixezdetWdu3apSFRunLlSk6fPs1PP/0kmbwUZPY6+u677zScpFFRUYwePZrNmzdjb28vmW1tI8f9A9qXLVMj1/vVFrlBWlGuz3jgwIF4eXnx8uVLypYtK4mN3ETNmjXx8/MjKSkJMzMzdu3axYkTJzA3N5fsoVUuChYsyMuXLzX2NcnJyTx9+lTSB1Y1165dIyIiQuh3K8UaUKFChWyvExIShOqDR48e6YzM4I0bNxgxYoQgf9quXTvev3/PhQsXgEw5R09PTzIyMoQseTFwdXWlY8eOdOjQgapVqzJp0iRGjx6tURGmjd+TrqNSqTT2wXJJ3pmYmNCtWze6devGw4cP2bdvH0eOHJHcbsmSJYXnTW0g15qbG1oHaYvo6GjS0tLYv38/+/fv1zinC4H2j6levTr37t1jwIABtGrVioyMDPz8/Hj69KnQRievExMTg62tLT179gTgxIkTBAcHC8nz5cuXx9raWqcD0dpEm/PUx4kxn+JTgb3/ysyZM1GpVDkGxHVxvtDmd5ufFYE+5T+WOuiu7k+clJSULVFWqnsoJ7ImRomJi4sLS5YsEdo/vX37NscK5FatWoluO+sY9u/fj4mJCZUqVWLVqlXs2LEDc3NzfvjhB8nsqnFwcMDBwYH4+HiOHDnCgQMHRLdRpUoVgoOD8ff3F/7/YsWKCa1cDh8+zJ07d6hfv77otiEzSd/Hx4f3799rpahJjzjoA9F68iwnT56kRIkSHDlyRMjGHz16NO3bt+f48eOSBaK1uVHq2bOnUBWkUqkwNTWldevWdOjQgcGDB2NmZiZ5EFqNth0wcvTJXL9+Pb6+vpiYmNC4cWMg01Ht6+tLrVq18nww62PGjh3LrFmzCA0NxcbGRlJbhw4dYtOmTUBmFVzWQPTNmzdJSEhg+vTplC5dmqZNm0oyhpUrV5Kens7EiRMFB4W3tzfLli1jxYoVsvWdlwK5+syam5tTokQJyX9PH6PrfXWzSmH+8MMP2NjYMH78eOFYnTp1CAwMZMGCBZJJK8r1Gd+/f5+MjAxcXV2pXLkyhQoV0nhg3bNnj2S25cLIyEiorChbtiyDBg2SeUTS4OTkhI+Pj9DHKzQ0lA4dOhATEyNpUtKrV68YM2YMoaGhGscbNGjAihUrRJXmzsq7d+8YO3Ys5cqVY+HChUCmLFzVqlVZtWoVxYoVk8SutlixYgWJiYk0aNCAtLQ0jh8/jkKhwNbWlkGDBhEZGcny5cvZv3+/qIHoJ0+esGbNGtasWUOdOnXo1KkT7dq106gI0yMOb9684fLly8JrgCtXrggO06y9ubVBtWrVmDJlyv9UKfclfGklrEKhkKxdglxrrjYVI+RmyZIlpKamYmJiQrFixXS+n+CPP/7IyJEjuXHjBgEBAUCmf6FIkSLMnDlT5tGJQ2pqqoYzunjx4gAa0rPGxsaiKjeo58TPoW4noGtoc56Su7XG8+fPP3lO1yp1IXc+W0dGRmqlGlxbyOmjGD16tCxr3po1a0hJSWHcuHFApnx1q1atGDt2rKh2SpcuzZo1a3j27BkzZ86kTp06GmqeSqWSEiVKSOZ3BPDx8aFcuXKC9LyjoyOOjo4cPXqUEydOaE3pzNTUlD59+kiiHNS9e3d+/vlnhgwZAmTui/v3749SqWTs2LGcOXMGhUKBu7u76LYh83tMTEzEzc0NKyurbH6ivF7Zr6voA9F68iyvX7/Gzs5OQxKuePHi1KpVi6CgIK3YDw0NpVChQlhZWUnSWyM0NBSFQoGRkRHjx4+nT58+WpFPzsrTp0+ZO3cuQUFBQpWLGimzP62srPD392fLli3Y2dmxaNEi7ty5w82bNyULvh88eBBTU1MOHjyIubk5kOng7Nq1K/v379e5QPTevXsxMDCgV69emJiYaFQMie1c27VrFwqFgtmzZ2fbiBw7doyVK1eydu1aNm7cKNmGUJ2NN2zYMOHY8OHDOXfunCT9DOVEjvsH5JMtk+v9yoFc0opyfcaHDh0SXj948EDjnK44jR0dHWnRogULFiz4bABEyqCHHEyfPp1Hjx4RHBwMZAaIIfO3JlUyIcCcOXMICQnB1NQUW1tbIFNp4NatW8ydOzdbDzGxWLJkCdeuXRMqr9V7qqCgIJYtW8a8efMksast/vzzTywsLNi9e7fQg/PFixcsXryYChUq4OLiwvnz5/nzzz9FtTthwgROnz7NnTt3+PPPP7l79y6LFy+mcePGdOzYERcXF53vf6ctgoODNfZQgEbbBKkqW/4JsdVXXr9+/UXXSfle5d7X5Ic2RX///TcWFhaCnLOu06RJE06ePMnOnTt5/PgxSqWSGjVq0LdvX0qUKCH38EQj632pjflo6NCh/2hHrrlRarQ5T8kdiM4P7VWyItcaFBMTw4IFC4iMjCQ5OVkI8n/48IG4uDidqjyfNm0aVlZW2QKEixcvJi4ujgULFkhme8yYMZL9359i3bp1rFixQuM5KCwsjHv37mFsbCy6r7VJkyZA5h6xXLlyQqGRtpg6dSqtW7fGwcFBOKZSqdixYwcPHz7UiZZbffr04e3bt+zcuZOMjAx69uwpJBsXKFAApVLJiBEjJEswV1f2A4IClxptVvbr+d/QB6L15FkqVKhAaGgoT548EarFHj9+TEhIiIYUotikpaUxd+5cDh48SEZGBs7Oztja2uLr68v69etFrWj56quvePPmDcnJySxatIiTJ0/Svn172rRpI5qNf2LGjBk5ypiAtNmfcvTJfPHiBfb29kIQGjIrEa2trQkMDJTEppxk/V4/fPjAhw8fhL/FfliOiIigdu3aOWbDGRgYMH78eM6ePStpZqihoaHGe1Tz/v17nXNAydVnVi7ZsvzUV1cuaUW5PmN15agu8/r1a+Li4oTXn0LXnJgFChRgz549XL16lbt372JgYEDNmjUFx4FU+Pv789VXX3H48GGh+jk2NpZOnTp9UWXTv+X8+fNUqFABLy8vILMqy8/Pj44dO2Z7eM6LJCUlUbFiRSDzu61VqxYvXrygXLlywjXFixf/bIubf8Pw4cMZPnw40dHRnDp1ilOnThESEsKVK1fw9/dnzpw5tGzZkg4dOuicvL02yU+Szdu2bZN7CLKtufmpTZGTkxP379+nQIECcg9Fa5QrV45JkybJPQxJef78Od7e3sJryEy+VvstPlfZ+m+Qc26Uuxpbzuev8PBwIVip5v3790Jyn9hk9S8mJCSQkpKiUwkcHyPXdzt//nzOnDmT47kqVapIZldbRERE8PbtWyAz2frJkyfUrFlTOJ+ens6FCxeIjo6WNBANmS3qtmzZQkhICFZWVrRt25akpCTJ5Kr37duHqampsAYZGxuzf/9+Bg8ezIEDByQr+unSpQvh4eGcOHEi23wRGBiIh4eHaLa8vLxYvny58Lefn59QEZ2VrMV0eZ3vv/8+x0Sh77//njlz5kj6XuWq7Nfz31CodFFHRE++YN26dSxbtgwTExOhokVdtTtu3DhGjBghiV0PDw/Wrl1L+fLliY6OxsXFhdKlS7Nr1y66du3KL7/8IpqttLQ0zp8/z4EDB/jjjz9IT09HoVCgVCpJT0+nSpUqHDlyRNIgmo2NDUZGRvz2229Urlw528N6VslYsUlJSRH6ZL58+VLyPplOTk4kJiZy4sQJIaEgNjaWdu3aUbhwYZ3LhP1UgoGaRo0aiWarQYMG1K1blx07dnzymn79+hEaGkpISIhodrMycuRILl68SI8ePejWrRsABw4cYN++fbRs2VIjo04X0Pb9A2BpafnZ81ImGsjxfuXg6tWrjBw5kuTkZGHjrZZW3LRpk6Sy6PnlM9Y2N27coHjx4lhYWGh1XpYbZ2dn6tWrJ4nD8HM4OTlRqVIltmzZonG8f//+PHv2TDJpWmtra2xtbXO0GxwcnE0qPK9haWmJi4sLq1atAjKdA+fOnSMsLEy4JqdjUhATEyMEpW/evCn0N9alSpr8wPr166lYsSJt27YlOjoaY2NjnXb8f4wca66Xlxeenp7Z2hQlJSUxfvx4nVKH2rFjB7/99huVKlWicePGGBsba5yfMGGCTCOTDrVihFo9zt7enkmTJlGnTh2ZRyYOlpaW2ZzSH1cjq/+Weh3SBjm934+R+v3KMU95e3szZ86cT56X6r0ePXoULy8vHj58iLOzM05OTjx48IApU6ZIYk9u5PhuHRwcMDExYdWqVfTu3ZvVq1cTGxvL9OnTGTlypCyVvGLi6+srJOx/SilBpVJRoUIFSX2PoaGhDBgwQOih7OzsTJUqVdi0aROenp64urqKbtPa2ppGjRqxceNGjeNDhgwhICBAsucgbc4XycnJuLm58fLlSxQKRY6FW0qlku+++052lQc9euRCXxGtJ88yZMgQ7t+/z/HjxzWyQZ2cnIQeBVJw+PBhzM3NOX78uODwnzp1KhcuXBC9osXAwIDWrVvTunVrYmJiOHjwoJA5B5lZbF9//TVdu3blxx9/FNW2mnLlylG6dGlatmwpyf+fEx8+fKBQoUIafTILFy4seZ/Mtm3bsnHjRjp27IiTkxOQ2SstLi5OCFzqEtoMaFSrVo07d+4QFRVF5cqVs52Piori9u3bkma6jhs3jmvXrrFv3z6hj65KpcLIyCjPP9RkRa77B+SRLZPz/cqBHNKKcn/G58+fz1GiLSgoSKh6yctknYtPnz6Nra0tbdu2lXFE2uH9+/f89ddfWrc7dOhQFi1axJUrV2jWrBmQ6Ri6deuWpNUHlStXJjAwkOPHj+Po6Eh6ejrnz58nKCiIqlWrSmZXm2RkZJCamopKpSIjIwNA+Ft9XhukpqaSnJysoYKiz73Oe3h5eWFvb0/btm1xcnKidevWkknnf46cgneTJ0/OscpFDORcc/NTm6L58+cDmZWVWVt/qIMDuhaIvnfvHn369CExMVE45u/vT58+fdi9e/c/JpPmBdSSr/kFOaux5Zyntm7dikKh4Ouvv+bChQu4urry6NEjHjx4INkcdfjwYSHgrA4e3r17l507d2Jqasp3330niV05kPO7/fDhAzY2NlhZWVGnTh3evHlD586dOXDgAIcPH87zPpt27dpx4MABIiIiePXqFUZGRhqKmkqlkuLFi0sepFyyZAmpqanMmTNHCNLa2NigVCrx8vKSJBBdsmRJ7ty5Q3R0tDB3PX78mNDQUIoXLy66PTXanC8KFizIwYMHiY+Px83NjWbNmjF79mzhvEKhoFixYpiamopqNz+jbXUMPf8dfSBaT57i4cOHlClThsKFC1OgQAGWLl3KoEGDhB5W9erVo379+pKO4c2bNzRq1EijCtnIyEiQCpeKMmXKMGrUKEaNGsX169fZu3cvfn5+/P3332zevFmyQPSkSZOYOnUqgYGB2NnZSWIjKzt37sTDw4MdO3ZoPBB7enryxx9/MHfuXMlkO8eMGUNISAiBgYEaEl5WVlaMHj1aEptyoy3nWteuXfn5558ZNGgQo0aNwtramsKFC5OQkEBwcDDr168nOTmZLl26iGo3K5aWluzZswcPDw8CAwNRKpXY2NgwduxYnakEkPP+Ae3Llsn9fuVCm9KKcn/Gq1evFiosQXf77Kk5ePAgd+/ezReB6DFjxrB48WI2bNiAnZ0dpqamGrKvUgVnT5w4gVKpZOjQoZiYmJCenk5KSgpKpZLFixezePFiQPye3IMGDWLGjBnZ7l2VSsWAAQNEsyMn58+fz6bKIKVKQ1ZevnzJyZMn8fX15fbt28D/zRf29vZ07NhRK+PQIx5paWncunVLuCcfPHiQo1NJoVAwfvx4ScbwqeBd7969JQneyb3m5qc2RZ07d9bp/cTHeHh4kJiYiLu7Oz179gQyK8W8vb3x9PQU2kbkZbZv3y73ELSKVAou/4Tc89Tz58+xtbXFy8sLJycn3N3dhSROqfxx69evp2jRouzevZt27doB4O7uzpEjRzhw4IDOBKLl/m5LlixJWFgYMTExWFtbc+LECZo0acKzZ8+IjY2VzK42UVcEOzk54ejoyLx587Q+htu3b2Nvb4+7u7sQiHZ1daVBgwbCHlps2rdvz4YNG2jTpg1VqlQhPT2dqKgo0tPTJZV71/Z8UaJECUqUKEHLli355ptvJFUQze/8U7W7PhCdO9EHovXkKQYNGkSNGjXYuHEj/fv3x87OjrFjx0raF/NjqlatSkBAAKdPnwYygy3e3t4EBQVpLZPYwcEBBwcH4uPjhc2vmDg6Omr8nZycTL9+/ShSpAgFCxYUjovtpD1//jw///wzCoWCwMBAjc/zwoULPH/+nBEjRrBjxw5JHJvGxsZs27aNM2fOEBAQgFKppF69eri6umJoaCi6PbnRpnOtd+/e+Pv7c/bsWWbNmpXtvEqlwtHRkf79+4tmMycsLS1Zu3atpDbkQu77R422ZMtyy/vVNhkZGRw5coSQkBCNCmHInJPFbA+RGz7jQ4cOYWhoSI8ePdi5cyd9+/bl4cOH+Pv761y1EmRWR9+5c4e//vqLUqVKyT0cSVH/tpYuXZrtnJQ95QMCAoTXWStm09PTNXp0ix2g6NatG0lJSXh5eQmV4KVKlWLkyJE608v+S6qOxf5cd+zYga+vL8HBwahUKmEMFhYWdOzYkY4dO2r0qdaTd2jUqBF//PEHmzdvRqFQEBUVxfr16zWuUScbSBWI1mbwLjesuaVKlSIsLIy///5bo01RWFgYpUuXlsSmXPz6669yD0GrqH9TWZ22c+fOJTg4WGNd1KPnc+SGecrQ0JC0tDQgs2Dg1q1bNG3alEqVKvHnn39KYjMqKgoHBweqVasmHKtRowZ169bVmSSd3PDdurm5sWXLFvbt24ejoyMjRowQlBmlUiGRC7kSSSCzcvfly5ca+/bk5GSePn1KoUKFJLE5duxYnj59yqlTpwgPDxeOu7q6Mm7cOElsgjzzBWS23nr37l2+SC6XCznUMfT8d/SBaD15ijdv3lC0aFEiIiK4ceMGBgYGPHr0KMdrpaqkGTt2LGPGjOGHH35AoVBw/fp1rl+/jkqlYtiwYZLY/BSmpqb06dOHPn36iPr/ZnXEZiU+Pp74+Hjhb7GdiZs2bQJg2LBh2aSw9+3bx6+//sqRI0dYt26dRoWcWPj4+FCuXDnc3Nxwc3MTjh87dozExESdcRSr0aZzTaFQsGrVKnbs2MGePXuIjIwUzlWqVImePXsyaNAgjWo4MYiOjv7ia+WUNxMDue8f0K5sWW54v3Lwyy+/sHPnTiB70EfsQHRu+IxjYmKwt7dn5syZXL58mebNm/PTTz/Rpk0bzp07p3MPGQULFuTNmze0atWKihUrYmpqSoECBYTze/bskXF04vOpwKWUMsrbtm2T7P/+J9R7ttjYWFQqFV999ZVsYxEbOVozwP/J60KmWkT79u3p2LEjtWrVkmU8esTj119/Zdu2bfz1118cPHiQ8uXL4+DgoNUxaDN4lxvW3PzUpuifvj9dlHnOmlD+uWN69HyK3DBP1axZk+DgYA4ePEjDhg3x8vLixYsX3Lhxg6JFi0piU52k8+bNG+HYw4cPCQ0NpUyZMpLY1Da54budOHEiCoUCa2trWrRoQbdu3Thw4ABFixZl+vTpktjMjzg5OeHj4yOoEYaGhtKhQwdiYmLo3LmzJDaNjIxYvnw5jx494t69e6hUKmrXri15eyI55gvIX8nlciGHOoae/45CpW+YpScP4ebmJvRH/pw8p5SVNAAXL15k7dq1hIWFYWBggIWFBcOGDaNVq1aS2dQmN27c+OJrxewzbGtrS5kyZfD19c3xfEZGBq6urqSkpHDp0iXR7KqxtLTM1n9OpVLh7u7Ow4cPdS5b3NbWFnNzc3x8fDSOf/PNNzx79kyQ65aCxMRE3r17R+HChSlSpIhkdiwtLb8oYULqOUMbyH3/AHTo0IG//vpLkC1zcXFh3Lhx9O7dG1NTU1EDFbnh/cpBixYtiImJ4euvv6ZmzZoYGGjmFIqZUZwbPmMHBwcqVKjAwYMHmThxIuXLl2fixIn07t2be/fucfPmTUnsysXnlCgUCgVhYWFaHI1u8v3339OwYUMGDx4s91D0iIC9vT1t2rShY8eOou5J9eQu+vXrh62traRVMzlha2tLjRo18Pb21jjes2dPIiMjRd0r54Y1NykpiaFDhwptr7K2Kdq2bZtklVJy8E/PCLq23vbv35+AgADGjRsnBJn279+Pp6cnjRs3ZsuWLfIOUE+eIDfMU4GBgQwbNozJkyfj4uJCx44diYuLA9CQGhYTLy8vPD09MTAwID09XfhXpVIxevRoyXv6aoPc8N3mxNu3bylatKjoBQv5mfj4eIYNG0ZwcLDGcSsrK9atWydpazVtI8d8AfDDDz9w+vRpChQokC+Sy+XAzs4OCwsLdu/ezdixY6lVqxajR49m4MCB/Pnnnzrnv9cV9BXRevIUU6ZMYfbs2bx+/Vrj4fhjpM6vaNGiBS1atJDUhpzI5chLS0v7bLaYUqmkQoUK3Lp1SzSbXl5eLF++XPjbz88vR9kfKbPl5ESuzHgTExNMTEwkt/O5KufXr1+TkpIi+Ri0hRz3z8doU7YsN7xfOfjw4QP169dn3bp1ktvKDZ+xlZUV/v7+bNmyBTs7OxYtWsSdO3e4efOmTmYXL1y4UO4haIUPHz5kC2jEx8djamoque2rV68SFxenD0TrCFeuXMHIyEjuYeg8EydO/OJrc5Lb/6+oe78GBgYKQVJ7e3saNmwouq2s1K1bl4CAANauXasRvAsNDaVx48ai2soNa25+alNUunRpIRCtUqlISUkhLi4OExMTrbb90hajR49m0KBBeHp64unpKRxXKpWMGDFCvoHpyVPkhnnKzs6OM2fOkJ6eTunSpdm6dSv79+/H3NxcdKVANSNGjCAhIYHt27eTlpZGamoqBQsWpHfv3owaNUoSm9omN3y3kKmGFRwcrNE+To1U1br5DVNTU/bs2cPVq1e5e/cuBgYG1KxZU/T+346OjrRo0YIFCxZka/+YFbFbPmblU/NFxYoVJZsvAE6dOgVk3lePHz/WOCe2smh+Ra5qdz3/DX0gWk+ewsnJSZAJs7S0xMXFRRbJ1fPnzxMZGanRn/PDhw8EBQVly5jXBS5dusS6deuIiIhAoVBgYWHByJEjadq0qah21H063rx5k6Nc5evXr/nzzz+pUKGCaDYHDRrEnj17ePny5SeTG5RKJX379hXNZm5Bm841ucip9867d+/47bff2LdvHwBfffUVU6dO1fbQREeO++djtClblhverxy0a9eOq1evkp6erpFVKwW54TOeMmUKQ4cOpXDhwri5ubF+/XquXr0KoHPtEgBBIk2X2blzJx4eHuzYsUOjAtzT05M//viDuXPniu4IyYqbmxtnz54lNDRUp/rH51f0QWjtcPz48S+67lN93/8rGRkZTJo0iRMnTmgcb9euHUuWLJGsUkqbwbvcsOZC5nv7uE2RLpJTRd/Tp0/p3bs3Xbt2lWFE0uLg4MDatWtZtGgRERERAFSpUoUJEyZIuubmJrSV8KbL5IZ5atWqVVSrVo127doBmX7Bn376iU2bNuHl5SVJdbJCoWDSpEmMHj2aiIgIDA0NqVSpkk6pROSG79bHx4effvqJ9PT0HM/rA9H/Hmdn5y+6TqFQ4OfnJ4rN169fC9XHn2r/qLYpJSVLliQ5OZnw8HAMDAz48ccfJX9+yC/J5XIyYcIEhg0bRlJSEu3ateP3339n//79ADq/h83L6APRevIszs7O1K9fX+t2V69erRH8/pxEuC6wb98+Zs2apRGgvXHjBgEBAfzyyy+iOs07dOiAh4cHw4YNY9KkSdjY2FC4cGHi4+MJDg7Gw8OD9+/fM3DgQNFsFixYkIMHDxIfH4+bmxvNmjVj9uzZwnmFQkGxYsV08qE1P2bGHz58mMWLFxMbGwtkSitOmjQJMzMzmUf235Hj/vmYnj174unpSYsWLVAoFFy8eJFz586hUqkYNGiQqLZyw/uVg5o1a3LixAm6du2Kvb09JiYmGmvQhAkTRLOVGz7jihUr4ufnR1JSEmZmZuzatYsTJ05gbm6Oi4uLZHblJDAwkHXr1hESEkKjRo3o1KkTr169kjRrW1ucP3+en3/+GYVCIfReVXPhwgWeP3/OiBEj2LFjh2RB4qioKOLj4+nVqxeGhoYUKVJECGKJnZF/7do1ypYtS5UqVUT7P/XokQO5ZUfXrVuHr68vJiYmQrLktWvX8PX1pVatWgwfPlwSu9oM3uWGNRfA29ub+vXrY2FhweTJk7l06RKOjo4sWLBAp4IuOWFubo6joyNeXl46GfBo3rw5zZs3Jy4uDqVSqZPPt2rS09NZvnw5Tk5O1KlTh/79+xMSEoK1tTW///57joE2Pf+MXPNUbGwsSUlJQGYgulmzZhq+wPT0dI4ePcrjx48lWa8+lnhNSkrizz//BDIT4kqWLJnnk59zwxq0YsUK0tLSKF26NOXLl9c5Oe5ly5Z90XUKhYLx48eLavv58+dfbFsstm3bRvHixYXXcpCWloanpyfbtm0jNTUVyLxnBw4cyNixYyVL7M8PyeVyI1e1u57/hr5HtJ48i62tLXXr1tX6gubi4sKrV6/o0aMHO3fupG/fvjx8+BB/f38mTJggmSNELpycnHjx4gVDhw6lTZs2AJw5cwYvLy/Mzc05c+aMaLZSUlLo27cvoaGhOW6AVCoVderUYdeuXRgbG4tmV83z588xMTHRqZ4o/8Qff/yRo3PN1dVV5pGJy6NHj5gzZw43btxApVJRs2ZN5s6dS4MGDeQemmjIff+obSxdupTt27eTnJwMIMiWTZo0SdSNfm54v3Kg7mn4cRKU+m8xexrmhs/Y2dmZevXqffGDe17n0qVLjBo1ivT0dBQKBc7OzlSsWJGtW7cye/Zs3N3d5R7if6Jfv34EBAQwfPhwRo0apdGiITY2ll9//ZUjR45IqnijzT7czZo1o06dOqxfvx5nZ2ccHR2ZO3euaP9/biU6OhpjY+Ns+6moqCgSExM/+x3o0ZMTrq6uvH37loMHD2Jubg7AkydP6Nq1KyVKlOD06dOSj0Hq4F1uWHM3bdrEkiVLmD17NqampoIku0KhYNCgQfz444+S2JWDR48eafydkZHBixcvmD59OnFxcYSEhMg0Mun48OEDERERpKSkZFMBs7e3l2lU0rB06VI2bNjAjBkzKFiwIDNnzgQyf8s9evRg3rx5Mo8wbyLXPLVr1y5+/vlnwcangmVfffUVly9fFs2umn/qKQ9Qu3Zt1qxZQ9myZUW3rw1ywxpUr149ypUrx5EjR3RS8eZLfkdSPNMDgqKYmhUrVhAcHMymTZuyXatLKhkLFy5k27ZtqFQqIZnuw4cPWtnX3L17l8WLFxMUFARkrrOTJ0/OsRWknv+dbt26YW9vrxPqlvkJfSBaT55l+vTpnD17lvXr12tVWtHa2hp7e3s2bdqEm5sb06dPp0WLFrRp04ZixYqxZ88erY1FG9SvX5/atWuze/dujeO9e/fmzz//FP0hPSkpCU9PT/bv309CQoJw3MTEhM6dOzNx4kSKFCkiqs2s6HIl2ueQOzNeKqm0lJQUfv/9dzZu3EhqairGxsZ8//33DBw4UHJZYzmQ+/5Rk5iYmE22TAr1iNzyfrXJ1KlTP/s5ii0DJfdn3LhxYywsLIT+oLpO9+7diYyMZMWKFQwbNgwXFxcGDBjA8OHDKVu2bDZZ2ryGra0tZcqUwdfXN8fzGRkZuLq6kpKSkqNsqhjcuHHjs+cbNWokmi1ra2vKlSvHjBkzGDFiBA0aNGD06NE5Xvu53ml5jdq1a+Pi4sLKlSs1jvft25cnT55I9t3q0R7h4eFCmyI179+/JygoSJLEoazPX1kZNGgQgYGB3L59WzRbjx49onDhwpQuXTpbsPJjqlatKppdkH/NbdOmDTExMWzYsIEdO3Zw7tw5tm3bxujRozExMRE1AVluPuUIVqlU2NrasnPnTi2PSFrOnj3L1KlTNX5XahQKBXfv3pVhVNLh5OTE+/fv2bFjBx4eHly/fp1Tp07Rq1cvMjIyOH/+vNxDzLPIMU+lp6fTsWNHHj58+Ml2akWLFmXixIn07NlTVNsA48eP548//iAxMZEaNWoACM+6tWrV4tWrV7x48YK2bdvi4eEhun1tIfcaNHz4cP766y8OHTokmQ05+afn+KxILe08evRozp07J3rAOytyVoCrcXBwICkpiVWrVtG8eXMgMyg/atQojI2NuXbtmiR27927x7fffput17mJiQm7d+/WJ+WKQKNGjbC0tJSt2l7Pv0MfiNaTZ+nTpw+3bt1CpVJJLq2YFQcHBypUqMDBgweZOHEi5cuXZ+LEifTu3Zt79+5x8+ZNSezKxfDhw4mKiuLkyZPCpiklJYW2bdtSu3ZtySqWMjIyePToEXFxcRQuXJhq1aphaGgoiS01ul6JBvI619RoUyrN1dWVp0+folKpKFCgAJ06dcpRNkuhUHwyOJAXkeP+efLkCQkJCVSrVi1blnRERATTpk0T+nKLjRzvN78h12e8c+dOFi9ezJgxY7Czs8PU1FRDpk2qeUoubGxssLe3Z+PGjVhaWgqVwQMGDODWrVuEhobKPcT/RL169ahfvz5bt2795DXafK8xMTEoFApKly4tyf//zTffEB4e/o/X6UIQYNeuXZw8eRLIDPYXL14cCwsL4XxGRgbBwcEYGhpy69Yt0ezmBidXfsPb25s5c+Z88rwUTk0nJycSExM5ceIExYoVAzJVFNq1a0fhwoU5e/asaLayJlJ8rnpJyvtWrjW3Xr16NGrUiPXr1+Po6EiVKlXYsWMHw4cP5/r16zpVJZyTE9jY2Bhra2vmzZunc/uLb775hvv376NUKilevDgGBppd+i5evCjTyKTBxsaGJk2asHbtWhwcHLCysmLjxo0MHz6ca9eu5fn9VG5A2/OUSqUiPT0dKysrnJ2dWbFihXBOqVRK2i5v06ZNrFq1it27d1OrVi0Abt++Tb9+/Zg2bRpdunShXbt2fPjwAX9/f8nGoS20+d1mrWB/8eIFP//8Mx06dMDJySmbT0GXkjblRhuBaDkrwNU0atSIOnXqsGXLFo3jAwcO5O7du/+YoPxvGTFiBBcvXsTd3V1IjvH29sbb25uWLVvi5eUlid38hIeHB9u2beOXX37J0U+ki6oKuoC+R7SePIta3gIyA6Pqnq8gbl+Lj7GyssLf358tW7ZgZ2fHokWLuHPnDjdv3qRUqVKS2ZWL9u3bM2fOHPr374+TkxOpqamcPHmSmJgYunfvjre3t3Btr169RLOrVCqpXr36Z68ZPXo058+fF80JtGLFCoyMjIRKNMiUhfX29mbr1q06EYhu166d4Fxr27atLM41T09PNmzYQOnSpXnw4AHBwcFA5sPc8uXLRZVKe/LkifA6PT0dHx8fACGLOqvEsS4ForV5/8TGxvLDDz8QGBgIgKmpKXPmzKFdu3ZAZl/HVatWCT15pECO+UKbBAQEULx4cSEDPycuXLjAkydP6N+/vyRjkOszVvcTXrp0abZzuhC8+xgzMzMePXok9MGDzHssPDxc6LGVl6lUqRJ//vknb968yTHp6PXr1/z555+S99m7ePEi8+fP59mzZ8K41Ao3YjJv3jx+/fVX/vrrL54/f07BggV1tv2Hi4sLS5YsITExEYVCwdu3b3N07rRq1UpUu+vWrftiJ5c+EC0OW7duRaFQ8PXXX3PhwgVcXV159OgRDx48kKxFUdu2bdm4cSMdO3bEyckJgHPnzhEXF0e3bt1EtaVSqTSq7T6Vty9lPr9ca26hQoWIj4/n/v37vH79mm7dupGRkUFUVBRFixYVzU5u4N69e3IPQatERUVRtmxZ9u3bp5M+i48xMzPj5cuXXL9+nbi4OGxtbUlMTCQ8PFzfH1oktD1PKRQKDAwMNO5dqRMK1WzatIl69eoJQWjIVOqoX78+a9eupVevXlSvXp0rV65IOg5toc3vdujQodn2cYcOHcpWFa1rz31du3alS5cutG/fXmefDTp37iypb/5L6NixIydOnCA2Nlb4nJ8/f87du3clUU9QExgYiKWlpUbi5ty5cwkODs7Wc17Pv+Po0aMkJyczYcKEbOd0bb7QJfSBaD15FrnkF6ZMmcLQoUMpXLgwbm5urF+/Xui30aNHD1nGJCVTpkxBoVAQEBAgBJrUjpesWaggbiD6SxHTCRQeHo69vb0g2QKZfTxsbGxErd6Rk9zgXDt+/DhmZmY4ODjg4eFB4cKFBak0sZUMvv/+e1H/P11DjO958eLFGpvpd+/eMX36dGxtbZk/fz5+fn6oVKpc0Qsnr4rA9OvXj9atWwsytwsXLiQgIICDBw8K1+zbt49z585JFoj+UqT4jOWYp+SiQ4cObNmyBRcXFxQKBTdu3MDNzY2EhAT69esn9/D+Mx06dMDDw4Nhw4YxadIkbGxsKFy4MPHx8QQHB+Ph4cH79+8ZOHCgZGO4ceMG3333Henp6cKxqKgoRo8ezebNm0Xtk1mvXj2htYmlpSWOjo6SKcnITenSpVmzZg3Pnj1j5syZ1K5dm969ewvnlUolJUqUoGnTpqLazQ1OrvzG8+fPsbW1xcvLCycnJ9zd3bG1taVt27aSVRmOGTOGkJAQAgMD2bt3rzD/W1lZiZ5ImDXIkduDlWKvg1ZWVly+fJnevXujUCho1aoVU6dO5cmTJ3To0EFUW3q0i6WlJYaGhvkiCA2ZrUBOnTrFwIEDBaWzSZMmERMTI4vPIj8jxX5dWwmFat6/f8+9e/c0gllv3rzh/v37JCUl8erVK8LDwzExMZHEfm5FjO+2fPnyIowk73H37l3CwsJYtGgRLVq0oEuXLrRs2TKbWoVYfNw7/c2bNwBcuXIl2/coVuX5r7/+Ksr/818oXLgwiYmJtGnThoYNG5KamsrNmzdJTU3l2bNnTJw4Ubg2p8T3/0LBggW/6Jief0d0dPQnz+min0hX0Aei9eRZsvbwS0hIICUlRSuZZDVr1sTPz4+kpCTMzMzYtWsXJ06cwNzcHBcXF8ntaxsxHbK5HV2vRIPc4Vx7/fo1TZo0wcLCgqCgIOrXr0/JkiWpXr266D1a9IFo6bl69SpFihRh8+bNVKlShc2bN7NmzRpGjRrF3bt3USgUDB48WF+J9h/Jupl+9uyZpDJauYncHgQQmwkTJhATEyP0gn737h2Q2WZg3LhxMo5MHAYNGsTZs2cJDQ1lyJAh2c6rVCrq1KnD0KFDJRvDypUrSU9P1+gj6O3tzbJly1ixYoVk/cjVv+WkpCRhbqxTp45OOSSaNGkCgIGBAeXKlaNx48aS28wNTq78hqGhIWlpaUBm4PLWrVs0bdpUUDyQAmNjY7Zt28aZM2cICAhAqVRSr149XF1d9a04RGTSpEncu3eP169f06tXL+rXr8+BAwcoW7asTqxBX5qsp1AoPttCIi8ya9YsBg0axPr162natCkmJiYaSTy6JkU+ZcoUXr58yePHjxk6dCi1atWidOnS1KlTRyd+y/kZbSYUqnF0dOTMmTO4ubnRsGFDVCoVt27dIiEhgRYtWnD+/HlevHih4aPU82WcO3dO7iHIwrJlyzh58iR//PEHZ8+e5dy5cxQtWpQOHTrwzTffYG1tLaq9nCrP1cezInXbkaNHjxIYGIhCocDe3p727dtryCmLzbp16wBITEzkwoULGufULYWATyqw/Vvq1q1LQEAAa9euFZR79u/fT2hoqFaej/IDYrbl0aM99IFoPXmao0eP4uXlxcOHD3F2dsbJyYkHDx4wZcoUSe0aGRkJ/QbKli3LoEGDJLUnJ1I5ZHMjul6J9iXEx8djamoqqQ29VJpu8fbtWxwcHISHpaFDh7JmzRrCwsL46quvWLJkiegVcHryD9OmTcPKyoo+ffpoHF+8eDFxcXEsWLBAppFJg5GRER4eHowfP567d+9iYGBAzZo1qVSpktxDEwUjIyO2bduGp6cn+/fvJyEhQThnYmJC586dmThxYraecGJy584d6tevL7TgABg+fDjnzp3jzp07ktkF2LNnD0uWLOHDhw9AZpb+5MmTda46q0uXLhw+fJht27YJgZ8RI0bg6uoquozyx8TFxREVFUVKSoqQwPPhwwcCAgKYNGmSpLbzCzVr1iQ4OJiDBw/SsGFDvLy8ePHiBTdu3JBUvlmpVOLm5oabm5tkNiCzLc+XoFAo8PPzk3Qs2qZWrVpcunSJ9+/fU6RIEQAGDx7MtGnTKFSokMyj++98rhek2kGvlvLXNdRz77Jly1i2bJnGOV2UsCxfvrxGCzHIVFbQVQnc/IQcCYUzZ84kJiaG0NBQjX7qtWrVYs6cOezbtw9TU9McJWL1/O88ffqUiIgIQSK8YsWKcg9JdNq1a0e7du1ISkriwoULnDx5kosXL7Jz50527txJtWrVGDBggGjy0XJXniclJTFkyBBu3rwp7M/37duHt7c3GzZskOzZb/To0bKs6aNHj2bQoEF4enri6ekpHFcqlYwYMULr49FFDh06RLVq1YSWgGo2b97M+/fv9UVJuRR9IFpPnuXw4cPZAs53795l586dmJqa8t1334lmKz87JPITn6tE08VqzvT0dJYvX46TkxN16tShf//+hISEYG1tze+//y5ZUFgvlaZbpKSkaFT0qR2VhQoVYs+ePZibm8s1ND15lIiICN6+fQtkPmA8efKEmjVrCufT09O5cOEC0dHROheI7t+/P3Z2dowdO1Yj+DxlyhT++usvNm3aJOPoxMHY2JipU6fy448/8ujRI+Li4ihcuDDVqlXTSmWjoaGhEAjOyvv374UkQyk4ffq00CesSJEiqFQqEhISmDNnDiVKlKB169aS2dY2+/btY9asWTRu3Jj+/fuTkpLC5cuXuXTpEhkZGZK1svHz82PcuHEaVVJZ0QeixWHChAkMGzaMpKQk2rVrx++//87+/fsBJA8Sa4Pnz59/0XW6EqwMCAigePHi1KhRA8h8X+ogNGRWyl64cIEnT57I3v7jv/Kp1l43b97Ey8uL5ORk4P/UHXSJz8lU6oqE5eXLlylZsiSWlpbZZGg/RizpWT3aR46EwtKlS7N3716uXr1KZGQkaWlp1KxZU0i27t69O4MGDdKYO/X87yQkJDBz5kyNSlWA9u3bM2/ePJ1IiPoYIyMjzMzMKFSoEIaGhiQmJgIQGRnJ7NmziY6OFkXFQe7K8+XLlxMUFESZMmWEZ54zZ84QFBTEypUrmTx5siR2x4wZI8n/+084ODiwdu1aFi1aREREBABVqlRhwoQJOrnH0BaxsbGCgumqVatwdHSkfv36wvn09HSOHDnC48eP9YHoXIo+EK0nz7J+/XqKFi3K7t27hQwYd3d3jhw5woEDB0QNROc3h0R+Rdcr0T7G09OTDRs2ULp0aR48eEBwcDAAt2/fZvny5cybN08Su3qptPxBw4YN9UFoPf+K8PBwjX5NN2/ezOb8VqlUVKhQQdtDk4SAgABhn3Hjxg0SEhI01p309HQCAgKEXl66grrKQds0bNiQixcvMmvWLKFC7MCBA0RERNCyZUvJ7K5du5YCBQrw22+/0bZtWwB8fX2ZNGkS69at06lA9NatWzEyMuLbb78FMoP/y5YtY8qUKWzbtk2yQPTq1atJS0vDwsKCBw8eUK9ePZ4/f87r169xd3eXxGZ+xM7OjjNnzpCenk7p0qXZunUr+/fvx9zcPJt6RV5k8+bNwuuHDx/yyy+/0LZtW1q3bo1SqeTEiRNcvHhRo8IlL9OvXz9at27NypUrAVi4cCEBAQEcPHhQuGbfvn2cO3cuzweiP5bNfffuHUuWLOHAgQNkZGRQsmRJpk6dqpP9sPNDq5OhQ4cKv+VPydCCblaA5yfkSCjcvn07HTt2pEmTJjkGkcqVKyeJ3fzG/PnzOXHiBAUKFKBatWoAPHr0iOPHj2NkZMQvv/wi8wjFIzAwkOPHj3P69GliY2NRqVQULFiQ9u3b061bN8LCwvDw8ODAgQM64SM7efIkJUqU4MiRI4J6zujRo2nfvj3Hjx+XLBANmdL9W7ZsISQkBCsrK9q2bUtSUhKtWrWSzCZA8+bNad68OXFxcSiVSsmVJ/MDJ0+e5Oeffxb+vnLlSo6Fg3qlzdyLPhCtJ88SFRWFg4ODsEEBqFGjBnXr1iUwMFBUW1kdEgArVqwgODhYJyqT8js+Pj6UK1cOBwcH4VilSpV0NviclePHj2NmZoaDgwMeHh4ULlyYU6dO0atXL/744w/J7Oql0nSPiIiIbDJ/T58+1TimUCh0UllAW7x580ao7lAHJK9cuSJUsehSkLJdu3ZCYPDVq1cYGRlRrFgx4bxSqaR48eI6k+WakpLC1KlTUSgUKBQKwsLCmDZtmsY1KpVKlqCtLjJu3DiuXbvGvn372LdvH5D5+RoZGUmaNR8REUHDhg2FIDRk/tZ3795NSEiIZHbl4OnTp9jZ2eHq6gpkzv9ubm7s3buXoKAgyew+fvyYevXq4e3tjaOjI5MnT6Z69eq0b9+emJgYyezmN1atWqUhhWdpaclPP/3Epk2b8PLyyvNzc9Ygw+rVq6lVqxa//fabcKx169Z07tyZjRs30rx5czmGKDpZK2KfPXtGWFiYjKPRDj4+PixevFhQYOnVqxeTJk3SO4rzMOXLl6d48eLCaz26iRwJhQsWLGDRokW0bNmSzp0707JlSwwM9O50sTl9+jSmpqbs2rULCwsLIDMhzN3dnVOnTulUILpv374oFApUKhV16tShe/fudOzYUViDmjZtSmBgIP7+/jKPVBxev36NnZ2dRguX4sWLU6tWLUmfDUJDQxkwYACJiYkoFArKly/PlStX2LRpE56ensKzilgkJibi5+fHy5cvKV++PM7OzpK2rclv9OrVix07dvDw4UPh/vmYokWLMnbsWBlGp+dL0K+cevIspUqVIiwsTMP5/vDhQ0JDQylTpoyotj7OetyxY0eOx/XkPaZOnYqLi4tGIHratGnUrVuXvn37yjgy6Xn9+jVNmjTBwsKCoKAg6tevT8mSJalevTrXrl0T1ZZcUmkpKSlffK2Ukqy6TlRUFOvXr9c49vjxY+GYut+ePhD97wkODtaQoIPMyg81utbTcOPGjQA4OTnh6OgomUJDbqBZs2b07NmTiIgIbt68SdGiRTWCzkqlkhIlSjBkyBAZR6k7WFpasmfPHjw8PAgMDESpVGJjY8PYsWOpU6eOZHYLFSrEq1evyMjIQKlUApnV7jExMTon5WhqasqDBw9ISEgQ3ltcXBz379+XXFZR3SrCysqK4OBg7OzsqF27Nrdu3ZLUrq7zsRRes2bNsknhHT16VOek8EJDQ3NMAsrIyND/pvIokZGRzJkzh8DAQFQqFbVq1WLu3Lkav2dd5HPV7AqFgq1bt2pxNNKQVXpWbhlaPdIhR0Kho6Mj165dw8/Pj7Nnz1K0aFE6dOhA586dsbKyksRmfsTExISaNWsKQWiAatWqUadOHUHeWFcoWrQonTp1onv37tSqVSvHa5o3b469vb2WRyYNFSpUIDQ0lCdPnghFP48fPyYkJERSlbMlS5aQmprKnDlzhBZJNjY2KJVKvLy8RA1ER0ZGMmDAAI0YRcWKFdm2bZteNUEkChQowPHjx0lPT8fKygpnZ2dWrFghnFcqlTrlE9NF9IFoPXmWnj174unpSYsWLVAoFFy8eJFz586hUqkYNGiQ3MPTOV6/fk1oaCiFChXCyspKNqdpcnIy8fHxlCxZkho1agh9nMXk0KFDxMfH63wg2szMjJcvX3L9+nXi4uKwtbUlMTGR8PBw0aVM5JJKq1ev3hddl18k2qS4f7p06SLCyKRBG/OFNsjNVR1Sf8b5xZGoDrR37dqVFi1a8MMPP8g8It3G0tKStWvXatVm06ZN8fX1ZeTIkXTu3BnI3G88ffpUqCzVFZycnNi7dy+urq7Uq1eP9PR0QkJCePfuHd27d5fMbtWqVbl16xZ+fn7Ur1+fXbt2kZqaSkBAAMbGxpLZzQ98LIXn7++vdSm8iIgIzMzMKF26NN7e3ly6dAlHR0dBAl4Kypcvz7179/jxxx9xcXEhIyODkydP8uDBA1lUKnRlXyMXHh4ebNq0ibS0NJRKJe7u7gwcOJACBQoQHR2tcW1u3nv9G27cuPHJc7rotJ02bRpWVlbZ2gUsXryYuLg4FixYINPIdB8p5qno6GiMjY0pUaKELAmFGzZs4N27d/j5+XHy5EmuXr3Kzp072blzJ9WrV6dz585069ZNqMjXVaReg7799lu2bNlCZGSksMaGhIQQEhKicxWOly9fxtDQ8LPX9O7dW0ujkZ6uXbuybNkyvvnmG2xtbQEICgoiKSlJeC6Sgtu3b2Nvb4+7u7sQiHZ1daVBgwbcvn1bVFsLFy7k9evXFCpUCAsLC8LDw3n27Bm//vory5cvF9VWfkahUGBgYJAvWo7oIvpAtJ48y4gRI0hISGD79u2kpaWRmppKwYIF6d27t6j9ofM7aWlpzJ07l4MHD5KRkYGzszO2trb4+vqyfv16DblUMalduzYuLi5CvzI1AwYM4K+//uLs2bP66sr/iK2tLadOnWLgwIEoFAqcnZ2ZNGkSMTEx9OrVS1Rbckml5STV8l+uyyto8/5ZuHChKP/Pf0HX54vcEIzV9c84t/D333/z+PFjuYehk6grNl1dXTWqctVVcVJXHEyYMAF/f38uXboktL9QqVSYmZnpRO+3rEyePJl79+4RGhrK+fPnhePW1taS9oD77rvv+OGHH3j+/Dnt2rXDy8uLFStWoFKpcHFxkcxufkBuKbwLFy7w/fffs2DBAipWrMjs2bOBzPVRoVBI1gN87NixTJw4kaNHj3L06FEg874tUKCApL9l/ZorDWvXrhWCrhkZGezatYtdu3Zlu04XE1SzJpJApmpUaGgofn5+2c7lVSIiIgSp9UOHDvHkyRNq1qwpnE9PT+fChQtER0frA9EioM15ytnZWcOWHAmFZmZmdO3ala5du3Lu3Dnmzp1LTEwMERERLF26FC8vL1avXq2htJdXkWsNevbsGenp6XzzzTdUrVqV1NRUnjx5glKp5NSpU5w6dUq4ds+ePaLb1yZJSUn89ttvhIWF5ajil9ff38cMGTKE+/fvc/z4cQ2FRCcnJ0lVvwoWLMjLly819q3Jyck8ffpUdJWm0NBQTE1NOXbsGGXKlOHRo0d0795d9NahevTkZfSBaD15FoVCwaRJkxg9ejQREREYGhpSqVIlSST/PpYSzqk/pxoxZYVzAytXrmTfvn2UL19eyBR/+vQpt2/fZvHixaL2afHx8eH69etAppPnzz//1OiTmZGRQXh4OBkZGaLZzM9MmTKFly9f8vjxY4YOHUqtWrUoXbo0derUEd0pLpdU2tmzZ7VmS27y2/2T396vHOg/Y+2TmJjI69ev5R6GzpGUlMTgwYO5desWJUuW1Nirbdy4kQsXLtC1a1fmz58vWWVYhQoVOHz4MF5eXhoVPMOGDcPc3FwSm3JhamqKt7c3/v7+hIWFoVKpqF27Ns2aNZO08s7FxYX9+/djYmJCpUqVWLVqFTt27MDc3FyvMvAfkVsKb82aNWRkZGBgYMDRo0dRKpWMGzeONWvWsGvXLskC0e3ataNixYps3ryZx48fo1AosLCwYOjQoRrSoWIg55r75s0b4Xk3p+fcrDKTeRldq3L+X+jRo0e2Y3369GH48OH4+fnphDJHeHg4EydOFP6+efNmNklylUolqQysriPXPKVSqWRPHA8NDcXX15eTJ08SExODSqXC2NgYFxcXHjx4wP3791m0aBEHDx6UdZz/ltzw3Ofj4yO8fvDggYbt4OBg4W9dUHGYPn06fn5+Of6udeH9fUyBAgVYunQpgwYNIjAwEIVCQb169SRvi+Hk5ISPj4+g4hcaGkqHDh2IiYkRvRL7/fv3NG7cWGgVWrVqVaytrfWBaD16sqBQyb2a69HzP5KYmIifnx8vX76kfPnyODs7Sy63Z2lp+UWbAV3Mnm7ZsiWGhoYcP34cGxsbXFxcWLZsGW3atCEpKQl/f3/RbD169IiOHTuSlpYmfN45TVEODg6i9bGytLTEyckJT09P4ZiNjU22Y5A/egjHxsZSokQJSW3kRqm0+Ph4TE1NtW5XTOS4f+Qkv71fOdB/xtpn586dLF68mDFjxmBnZ4epqanQTxgyH2j1/O8sX76c33//HRMTE3755Rfatm0rnPvhhx/w8/MjIyOD2bNnSxbQyo+kpaURGRmJUqmkWrVqFChQQFJ7Pj4+lCtXLls10tGjR0lKSsoxEKPnvxETE4NCoaB06dKS2rG1taVOnTps376dNm3aYGxsjI+PD0OGDOHWrVvcvHlTUvvaQK4190uec1UqFQqFgrCwMNHs6skdDB8+nMDAQJ24hyCz6i4iIoJXr15hZGSkod6mVCopXrw433//PU5OTvINMg8j5zzl4uLCqlWrRPs//xdat27Ns2fPhPdqbW1Nt27d6NChA0WKFEGlUtGtWzciIyMJCQmRZYz/ldzw3Hfo0KEvvjY3twf7Eho0aIBKpWL48OGUKVNG43kP8v77yy3Ex8czbNgwjUQGACsrK9atWyeq79PS0hJnZ2dWr14tHPvuu+84f/68fv+kR8//R18RrSdPERkZyYABAzSysitWrMi2bdsoV66cZHbzc/b0mzdvaNSokUYQ1sjIiAoVKhAaGiqqrapVq7JgwQIePnzI2rVrqVKlCm3atBHOK5VKSpQoIXrG9vnz5zV6CSsUihyP6VqSAWTKH92+fZvk5ORs58TMEMwNUmkJCQmsXr2ayMhIkpOThQerDx8+EBERkW1zmteQ6/6Ri/z2fuVA/xlrn59//hmFQsHSpUuzndPVdUgbnDhxAgMDA3bu3Jmtf+Dy5cu5ePEiI0eOZO/evfpAtEh4eXmxadMm4uPjcXZ2pkmTJly/fp3ffvtNssS+qVOn0rp1a41AtEqlEiSl9YFo8bh48SLz58/n2bNnAFSqVInp06fTokULyWwaGhry119/8fjxY6FvYnx8/D/2WPyvnD9/Pse9Y1BQEN7e3qLZkWvNzc/PufmJrJXCkPns9fLlS0JCQiTt7a5tNm7cCGRWwTk6OjJv3jyZR6RbyPlsEBAQ8EV7NCkkjZ8+fUrx4sXp1KkT3bt3z6aIoVAoqFSpkuh2tUlueO7LT8HX4sWLU6VKlXzTVjI2Npbly5dz8+ZNEhMTNZIcFAoFfn5+ktg1NTVlz549XL16lbt372JgYEDNmjVp0qSJJPZiY2M1FFVjY2OB7GqquqakqkfPl6IPROvJUyxcuJDXr19TqFAhLCwsCA8P59mzZ/z6668sX75cMru5oT+nXFStWpWAgABOnz4NZAbzvL29CQoKwtLSUnR733zzDZDpbKpWrZpWAhxfIgyhi+IRe/fuZd68eaSnp+d4XsxAdG6QSluwYAE+Pj5CVUfW77RIkSKS2dUmctw/cpLf3q8c5IbPODAwkHXr1hESEkKjRo3o1KkTr169yqaqoCt8ar3RxXVIWzx//pyGDRtmC0KradGiBQ0aNCA8PFzLI9NNNm/ejKenJyYmJsLv9sGDB5w+fZqlS5dqSD3+V7y8vDSeAfz8/Khdu3a264oWLSqazfzOjRs3+O677zT2j1FRUYwePZrNmzdL0m+9atWqBAYGMmbMGBQKBY6Ojnh5eREaGiqZMxFg9erVGhV46j2kVMix5ubn59z8xPHjxz95rm/fvlociXbQ/66lQ65ng3fv3v1j4rhU8/OKFStwcnLCwCC7Cz05OZmCBQtmU9PLi+if+7THqFGjWLBgAUePHqVFixbZVD51TY3xp59+4vz587JJkTdp0kTS/aKa4OBghg0blu340KFDhdf65HLxiIqKYsuWLYSEhGBlZUXbtm1JSkqiVatWcg9NzyfQB6L15ClCQ0MxNTXl2LFjlClThkePHtG9e3d9zwUJGTt2LGPGjOGHH35AoVBw/fp1rl+/jkqlynGBFZOsGZhqXr58yY8//si2bdtEsZGfegh/zObNm0lLS6N48eKYm5vn+GAlFu3atePAgQNfJJUmFZcuXaJYsWLMmTOHiRMn8vPPP/PixQtWrFghqV250Mb9kxPv3r3j6dOn1K1bF8iUSnV0dKRkyZKS2QT53m9+Qo7P+NKlS4waNYr09HQhgSQoKIitW7dSoEABnatevXfvntxD0EkKFSpEQkLCZ69JSkrS0mh0n927d1OqVCmOHTsmVCePHTsWPz8/Tpw4IWogetCgQezZs4eXL19mSzJTo1QqdTLQIhcrV64kPT2diRMn0rNnTwC8vb1ZtmwZK1asYPv27aLbHDFiBOPGjSM4OBgrKyu+/vprTpw4gaGhoaTVRIcOHcLQ0JAePXqwc+dO+vbty8OHD/H392fChAmS2QX9vkaPuOT0rGNsbIy1tXW2dgZ5FXd3dxo1asSECRP+cX8oRdVsfkSb81Tt2rXp16+fqP/nl3L+/HmaN2+ezV9y584dfvzxR3x9fWUZl5Ton/ukxcbGhoIFC/Ljjz9mO6eLgUp/f38KFizI5MmTqVy5sqTtepydnb/oOrErsfUKM9olNDSUAQMGkJiYiEKhoHz58ly5coVNmzbh6emJq6ur3EPUkwP6QLSePMX79+9p3LgxZcqUATKz462trfWBaAlxcXHBy8uLtWvXEhYWhoGBARYWFgwbNkzSLKNVq1Zx5coVlixZQsWKFQE4fPgw8+fP/0dn8v/Cpypwd+zYwd27d/nll19Es5XbePnyJZUrV8bHxwcTExPJ7cktlRYXF0fTpk1xc3Nj3bp1GBkZ8d1333Hp0iX27t3LwIEDtToeKdHW/fMxDx48YMCAAdjb2wsVavPmzcPExIRNmzZRq1YtSezK9X7zE3J9xitWrMDIyIgVK1YIyU/Ozs54e3uzdetWnXJIfIqUlBR8fX3Zt28fO3fulHs4eRIrKyuuXr3KxYsXc5QOvnDhAmFhYTRq1EiG0eke0dHRNG7cWKMKuUSJEtSoUUP0PqQFCxbk4MGDxMfH4+bmRrNmzZg9e7ZwXqFQUKxYMUxNTUW1m5+5c+cO9evX10hIHT58OOfOnePOnTuS2GzdujVHjhzhyZMnNG7cGAMDAzp06ED//v2xtraWxCZk9sC2t7dn5syZXL58mebNm/PTTz/Rpk0bzp07x/DhwyWxq9/X6BEbXUy6/Zjg4GAh8fVzlbPaqL7LD2h7nipfvrxs0s2HDh3i5s2bLFmyBBsbG1QqFb///jtr1qz5pLpcXkb/3Cc906ZNIy4uLsdzuqiCVaxYMczNzbVS2f78+fMvuk7stUCvxKFdlixZQmpqKnPmzGHOnDlAZoKHUqnEy8tLH4jOpegD0XryFOnp6dkkSwoVKqSTm7/cRIsWLSTt+ZYTZcuW5datW3Tu3Jkff/wRf39/Tp06hUqlon79+pLbv3r1KufOndPpQHTDhg1JSEjQShA6K3Jt0IoVK0ZkZCRJSUlYWVlx/vx5XF1deffuHdHR0bKMSSrkun8WL15MbGwshQoVAjIDaI0aNeLChQt4eHjg5eUliV2554v8gFyfcXh4OPb29jRv3lw4Zm9vj42NDbdu3ZLMbm7gwYMHeHt7c/ToUd69eyf3cPI0gwcP5sqVK4wePZo2bdpgY2ND4cKFiY+PJyQkhDNnzgBInpCUlpZGWloaxsbG3L9/n2vXruHg4CBJqxM5qVChAsHBwfz5559A5vu+fPkyQUFBmJubi26vRIkSlChRgpYtW/LNN9/k+T6NuR1DQ0M+fPiQ7fj79+8llZKsXr061atXJyUlhZSUFEFiMSUlRTK7hQoV4u+//wYyE1oCAwNp0aIFJUqUkFTBQr+v0SMFZ8+eJSwsjJSUlGznpK7w1wYLFy6kXLlywms90pKf5qk6depw9+5devfuzZAhQ7h+/TohISGoVKocK4fzOvrnPumJjIykVKlSeHh4UKZMGZRKpdxDkpSRI0eydOlSoqKiqFy5sqS2Nm/erPH3ihUrCA4OZtOmTZLa1aNdbt++jb29Pe7u7kIg2tXVlQYNGnD79m15B6fnk+gD0XryHLGxsVy+fFnjb4ArV65oZI45OjpqfWy6SmBgIMHBwSQnJ2fLzpMqu/rYsWP8+uuv7N+/X6hsMTY2Zty4cdl6C+v5dwwbNoyxY8cyZ84cmjZtiomJiUZWoJj3UG6QSmvevDk+Pj6sXbuWxo0bM378eM6ePUtSUhJVqlSRxKZcyHX/hISEUKdOHcH5Y2RkhJeXFz169JD04VE/X0iPXJ+xmZkZjx490pBNjo2NJTw8nOLFi0tmVy6Sk5M5fvw4e/fuJSQkBMjMijcwMKBt27Yyjy7v0qxZM3788Ud+++03jh07ptErU93zdcyYMZIqvTx8+JChQ4cyffp0LC0t6dGjB6mpqRgYGLB+/XoaN24smW1tM2TIEGbNmkX37t1RKBRcvHiRixcvolKpJK2EuHHjBu/evdPfKxLTsGFDLl68yKxZs+jWrRuA0H6lZcuWkti8d+8e06ZN4/79+9meRaSUsLSyssLf358tW7ZgZ2fHokWLuHPnDjdv3qRUqVKS2AT9vkaP+Cxbtoz169dnO65eA3UhEJ21WtbBwQFjY2NKlCihcU1UVBSJiYnaHppOos15qkuXLkLbJznYt28f69atY/Xq1axbtw6AkiVLMnv2bFxcXGQbl1Ton/ukp06dOiiVSuzs7OQeimR87PdLTk6mY8eOVKtWLVuBmZg+wI97Qe/YsSPH43ryNgULFuTly5cazwXJyck8ffpUKIzRk/vQB6L15DmCg4Nz7E08dOhQ4bUu9tSQi9WrV7Nq1apsx9UPrVIFogsVKkSlSpUwNDQkNTUVyKxorVGjhl5OSyQGDhyIQqHA29sbb29vjXNi30O5QSptxowZvH//HgsLC1xdXWnatCn+/4+9O4+rMf3/B/46R0UlkSX7MuooW1IJWZOdGfsWhkYY+zK2+diHYcY6xIRh7CpabDEkRKVFyhYphZJQ2vdz7t8f/c797XTOSemcc9fp/Xw85jG673PO9b63616u+3pfAQHQ1NTE0qVLlVYuF7g6fvLz82WO9yMUCpGXl6e0cqm+UD6u1vGIESNw/Phx2NnZgcfjITg4GIMHD0ZmZiZn48Qpw4sXL+Dm5obLly8jMzNT4oaqWbNmcHFxUWqjR3Xg4OCAnj17ws3NDU+ePEF6ejp0dXXRvn17TJgwAZ07d1Zq+X/++ScSExMRHx+PJ0+eID8/H7169YK/vz8OHjyoVg3REyZMgFAohLOzM5KSkgAAhoaGmD17tlIbort164anT5/i06dPdLwo0ZIlS/DgwQOcP38e58+fB1B0X6ClpYWFCxcqpcy1a9ciMjJS5jxlprBctWoVZs2aBV1dXQwePBhHjhxBYGAgAGD8+PFKK5eua4iiubq6gmEYdpgzde99N2DAANjZ2WH//v0S0//3v//h7du38PPz4ygy9aHKeorrHu45OTn48OEDhEIhe87Jzc3Fly9fOI1LWei+T/l+/vlnLF68GBs3bkSvXr2kGmbVoWOVvOd+JTPK0HUN+Ra2trbw8vJiX0J7/PgxRowYgaSkJIwaNYrb4IhcPEYdBx8gasvW1rbMn6XxGRTDzs4O8fHxMDY2hpGRETQ0JN9f2bFjh1LKHT16NHuBYm9vj9jYWPj7+4PH42HMmDHYunWrUsoV8/b2xuvXr9V6PK2vHU+KPIY8PT3RpEkTdO/eHZ6enqV+VlVjPzEMg+fPn6Nx48aoX7++SspUFa6On2nTpiE0NBTjx49H7969UVhYiDt37uDSpUuwtLTEqVOnlFIu1/VFdcDVOs7Pz8eqVatw7do1iemDBg3C9u3b1eJt1wkTJrDpoxiGgZ6eHgYOHIgRI0bAwcEBpqamX603SeXXo0cPNGjQAF5eXpg0aRJSUlJw69YtTJo0CbGxsQgKCuI6RIW5evUqrKys0KhRI6SkpEBTU1MlYzQvXrwYN27cQI0aNdC8eXPo6elJvBylrIwr1cH79+8lehe+ePECe/bsQWhoKPh8Pjp37oxFixbBzMxMKeV37twZ+vr6clNYNmvWTCnlAkXnodzcXNSpUwcfPnzAtWvX0KJFC6X2gqPrGqJo3bp1Q7t27ZR2LV4ZnD17FtevXwdQlCGjXr16MDY2ZueLRCKEh4dDU1NT7dL8cqE61VN9+/bFx48f2RfYY2JicOHCBfB4PHTv3l0qFXBVVxnv+/744w+VDymnTCYmJnIbYNWlY1V57l+V+Qxw/vz58PX1lftCI6maMjIy4OjoKPXCQ8eOHXH48GGpjCikcqCGaEJIqczNzdGqVSt4enqq9E01ExMTNGjQANu3b2ffBjx16hR27tyJ/Px8lV9EiHuAk4or+TBTTJwqTZljZWZnZyM6Ohr5+flSPWisrKyUVq6qcXX8hIWFYcaMGeyb00DRsaOpqYl///1XaamnKlt9oY64Xsdv377F8+fPoaGhAYFAoFZjwIofRGhpaWHp0qWwt7eHpqYmO48aotWDmZkZunfvjj179qBbt24YMmQIdu7ciZkzZyIiIgJhYWFch6gwlpaWaNKkCS5fvqzScku7fuDxeHQuqABTU1OZvQtVZcyYMdDW1saZM2c4Kb+k3Nxc7N27F6tXr1bK73N9ziXqZ9u2bbh69SrOnTuHFi1acB2OUnz8+BGDBw9GTk4OeDye3GwJAwcO5KwuUyfVqZ4yMTGBsbExdu3aBYFAAKDopf1169YhJSVFrZYV4H7bqvN9n5gqO4VUN8WH8gQAJycnRERE4J9//pE6L6hDz/PqLjAwUKK+oBTslRs1RBNCSrVkyRK8fv0aly5dUmm58+bNw9atW6XGgnn9+jVWrVrFpgJUpMLCQri4uCAmJkZiPOzs7GyEh4fj7t27Ci+zMvj8+TMeP34MHR0ddOzYEbVr11ZqefIeZk6dOlWpqdJu3bqF1atXIzMzU2qeurx1KsbF8SP2/PlzHD16FC9evADDMDA1NYWDg4NSx/XicnmrC67W8fTp02FpaYlFixZJTF+1ahU+ffqEY8eOKaVcVbKxsUFycjKAorrIzMwMw4cPx5AhQ9C7d29qiFYTgwcPZscvPnfuHLZs2YL69etj0aJFaNu2rVpt4x9++AEikUjlDdGVJeOKOjIxMYGdnZ3M4XpUITw8HDNnzsSIESPQt29fpaawFIlEOHjwIM6fP4/MzEx06dIFq1evZntWhoWFYc2aNXj79q3SHsbTdQ1RtJSUFAwdOhS5ublo3bq1VM9CdckYERgYiPj4eKxbtw7t27fH5MmT2Xl8Ph8GBgbo2bMnatasyWGU6qE61VNbtmzBypUroaWlJTE9JSUF69ev5+zcqCxcbtu4uDjEx8ez5/VDhw5hwIABMDIyUlqZRDUSExPh5OSE0NBQAEWZOubPn4/GjRsrtJzSepsXp27PAAmpCqghmhBSquvXr2P9+vUwNzdH9+7doa2tLXFSnzhxotJjyMzMRH5+PtuDVigUyhyHtqJ+//13nDp1iu39XPz/fD5f7S5SCgsLsWnTJnh4eEAkEmHAgAGwsLCAt7c3jhw5grp16yqsrMqQKu2HH37Ay5cvwefzUa9ePak08+r6ooGqjp/KorotLxeUvY5DQkKQkJAAAFi9ejXat2+P6dOns/OFQiEOHDiA5ORkREREKKxcrhQWFuL27dtwd3fHvXv3IBQKwePxwOfzIRQK0bp1a1y6dEnq4RepWpydnbF3714ARePs/ffff1i3bh1u3LiB3377Tanjzararl27cPToUbRt2xbm5uYSKbJ5PB6WLl3KcYSkvLhuiPb29saqVatQWFgoNU/RDxL/+usvODs7S/SaadKkCby9veHq6oodO3ZAKBRCV1cXDx8+VFi58tB1DVGEBQsWwMfHR+Y8dcwYUXxYKKJ86l5PMQyD2NhYpKenQ09PD23atFH7cdbFVLltQ0ND4ejoiB49euDgwYNgGAZdunQBn8/HkSNHlJZdjUspKSlSnWBCQkIkXqJRB/Hx8Zg4cSJSUlIkrq8aNGgAV1dXhQ6xQkN6Vg8xMTHYvHkzIiIikJeXJzGPXjKovKghmhBSqq+9TabMm9bLly/D2dkZr1+/xoABA2Bra4tXr15h1apVSimvb9++yMjIwIIFC7Bjxw4sXboUb968gbu7O3799VeJhhB1sGfPHhw6dAhNmzbF+/fvYWdnh0aNGuHs2bMYM2YMfv/9d4WVVRlSpXXp0gV169bF+fPn0bBhQ6WUUZmo6vhxdXVF8+bNYWNjA1dX11I/q8wXV1RdX1RHqlrH/v7++Omnn0o99zAMg7Zt2+Lq1asKLZtrSUlJ8PDwgKenJ96+fQug6EZKX18fY8aMwcqVKzmOkFSEi4sL3rx5g7Fjx8LIyAgnT54Ej8fDtGnTuA5NoYqnyC5+HItf8FPmtePz58/x559/sg2EVlZWWLFiBUxNTZVWZnVgYmICfX19tGnT5qufVUbPyv79+yMxMRHa2tqoW7eu1PlBkQ8ShwwZgvj4eCxZsgStW7eGi4sL/P39MXbsWPblTTMzM+zcuVOpKY7puoYokpmZGfh8PhwdHWWOs66OGSOioqLYTGdiWVlZCA0NxZ49eziMTH2oez2Vn5+P/fv3w8XFRSKrmq6uLiZOnIjFixer7YuiXGzbqVOnIjQ0FHPmzMHSpUuRn5+PP/74A2fPnoWlpaVajXEfGhqKRYsW4cuXLzLnq9vLQUuXLsW1a9fQr18/jB07FgBw4cIF3L17F8OHD8euXbs4jpBUNT/++COCgoLkzhePc08qF42vf4QQUp1xNW7uxYsXsXr1aomxmZ8/f44zZ85AT08P8+bNU3iZycnJ6NGjBxwcHODl5YU2bdpg9uzZeP78OTw8PNSuIfrixYto0aIFrl69is6dOwMo6n14584d3LlzR6FlNWrUCAcPHixTqjRlMTExgaamZrVohFbl8bNhwwYMHDgQNjY22LBhQ6mNh8pqiOaivqhuVLmObWxsMGHCBERHRyMsLAz6+vpo27YtO19cX/z0008KK7OyMDQ0xM8//4yff/4ZQUFBcHNzg4+PD1JTU/Hvv/9SQ7QCleyBINa0aVOllPfp0ydMmjRJYpr4uuLatWsYOnSoUsrlwqhRo8qUEk/RXrx4AXt7e+Tk5LDTAgICMGXKFJw7d67UMaTJ16WnpyM8PLzUzyhru6empsLY2Bju7u5Kf+iflJQEc3NzzJo1CwDQtWtX9OzZE+7u7uDxeJg3bx7mz5+v1N5+dF1DFK1x48Zo2rRptdl3XF1dsXHjRrnzqSG64tS9niosLMSsWbMQEhIida2YmZmJY8eOISIiAsePH5fKtFbVcbVtIyMjYWFhwWbO0dLSwrp16/Dy5Uu1a1TauXMnUlJSoK+vj7S0NBgaGuLLly/Iz8/HkCFDuA5P4QICAtC6dWv8/fff7D41YMAADB06VGpMZ0LK4unTp9DV1cWWLVsgEAigqanJdUikDNTrbEkIUTiu3jo8cuQI6tSpg3PnzmHYsGEAgEmTJuHSpUtwd3dXysVvnTp12HSwHTp0QGBgIAYOHAgej4e4uDiFl8e15ORkdOvWTeKBnpaWFpo1a4bHjx8rvLwePXoAADQ0NDhJlbZ+/XrMnDkTR44cQc+ePaXSzJell09Vocrjx8rKih2ziasXV7ioL6obVa/jzZs3AwCmTZsGCwsLLFmyRKG/XxVYW1vD2toaGRkZ7HomFRcWFobVq1fj3bt3UvOUmcZr8uTJ+PfffyV6UD579gy///47wsLC1Kohevv27ZyUu2fPHuTk5GDSpEmYMGECgKLGCFdXV+zduxfOzs6cxKUuTE1NOeu9b2tri5cvX6ok1WtOTg7q1KnD/i0eI5PH42H//v0YMGCA0mOg6xqiaMuXL8eqVavg7e2N3r17S42RrG69Ok+cOAEej4c+ffrgzp07GDRoEGJjY/Hq1SvMnj2b6/DUgrrXU2fPnkVwcDAaNWqEJUuWoHv37mjQoAGSkpLg5+eHgwcP4uHDhzh9+jRmzJjBdbgKxeW2TU9Pl5qWkpICoVCotDK5EBUVhXbt2sHd3R02NjbYv38/6tatizFjxqhlg1p+fj4aNmwo8fyNz+ejYcOG+PjxI4eRkaqqfv36aN68uVrdQ1cH1BBNCJGSn5+PGjVqoEaNGsjPzy/1s8q6aX3z5g2sra3x3XffsdOMjIzQoUMHhIaGKqVMS0tL3Lx5EwcPHkS3bt3wv//9D/7+/nj79i2aNGmilDK51KZNG4SEhODGjRsAit7sdXV1xcOHD5Xaa2j06NGIiorCtWvXVJoqTZwCaPfu3di9e7fEPHUbQ0SVx0/xl1W4enGFi/qiuuFqHcvbp3JychASEoI+ffoorezKQk9PD/b29rC3t+c6FLXwxx9/sGnPS1LmiEXx8fGYMmUKjh49irp162LPnj24ePEiRCKRQsdF48r9+/fRoEEDmJiYfLVnQ69evZQSQ2hoKExMTCR6wW3atAnh4eEICQlRSpnVSdOmTTlL32tubo5bt25h9OjR6N69O2rVqiUxf9myZQotr/iDUvG/LSwsVNIIDdB1DVG8Xbt2QSQSYfny5VLz1O0+CAASEhJgYWEBZ2dn2NraYtKkSbCwsMDQoUOV8sJ1daTu9dTly5ehqamJf/75BwKBgJ3eokUL2Nvbo3Pnzpg8eTIuX76sdg3RXG1bKysr3L17F46OjrCxsUFhYSH8/PwQGxuL3r17K61cLgiFQhgYGEBDQwMdO3bE48ePMXXqVJiZmSEwMJDr8BTO2NgYYWFhuHLlCkaMGAEAuHTpEsLCwtjsjISUx6JFi7B+/Xo8fvyY9qEqhBqiCSFSzMzMYGdnh/3798PMzEzu55R509qwYUNERkYiOTmZnfb69Ws8fvwYhoaGSinzf//7HxISEtCkSRMMHToUJ0+eZMdmcXR0VEqZXFq0aBEWLlyIxYsXg8fjISgoCEFBQWAYRqnLy1WqtNIaGJTZ+MAFLo6f4lSd8pbr5a0OuFrHMTExWLFiBV6/fi3x4oqYuo2fRZQvKioK9erVw6FDh9CuXTuVpVO0t7fHmTNnYG9vD6FQiOzsbOjp6WHOnDlqMfTHrFmzMHDgQOzfvx+zZs2Sm6JZ2Q0eJXv5yZtGqpYtW7YAKDp+X716xU4Xpw1VdEN0cnKy1AsVhYWFUtOU9VIFXdcQRXvz5o3ceep2HwQAmpqaKCwsBAB07NgRjx49Qs+ePdGyZUs8e/aM4+jUg7rXUzExMTAxMZFohC6uU6dOMDExQUxMjIojUz6utu2KFSvw6NEj3Lt3jz3fMgyDOnXqYMWKFUorlwvNmjVjX5Q0MzODq6sr6tSpg4iICLWsk3/66ScsXrwYK1aswNq1awGAvbf/8ccfuQyNVFFubm7Q0NDAxIkToa2tDR0dHXYej8fDvXv3OIyOyEMN0YQQKQzDsBc/XDXeTZgwAXv37kXfvn3B4/Fw9+5d+Pr6gmEYzJw5UyllGhoawt3dHfn5+dDS0sLp06fh7++PFi1awNTUVCllcsnOzg7Ozs44dOgQIiMjoaGhAWNjYzg6OqJ///5KK5erVGnqNq5Qabg4fgDuUt5ytbzVCVfreOvWrXL3G65SwZOqrUWLFjAwMFD5m9Pr1q1Ds2bNsGPHDjAMAysrKzYNnzpo2rQpm8JYWS8dfU2HDh0QEhKCQ4cOsVlQLly4gMePH6t8OBB1M3r0aHTo0IGz8lU97nh4eLjES5k8Hk/mNLquIVXFrVu3uA5BpQQCAcLDw+Hh4YGuXbvC2dkZiYmJCA4Ohr6+PtfhqQV1r6dEItFXX1bU0NBQy0ZDrrZt27ZtcenSJZw5cwYvXrwAwzAwNTXFlClT0LhxY6WVy4UZM2awvTkHDRqEQ4cOYdWqVWAYRi0zfg0ePBibN2/Grl27kJaWBqAo69f8+fMptTL5JsHBwey/s7OzkZ2dzf6tynsGUj48Rh3PmoSQCklISIC2tjYMDAzYMZPlUVY6SYZhsGvXLpw6dYp9U65mzZqYMmUKVqxYAT6fr5RyAeDLly/Izc1VWW/O6sbMzAydO3fGqVOnYGtriy1btrCp0lq2bInjx48rtfzc3Fw8f/4cPB4P7du3V8ueUlwdPxMnTkRERITc+cp6GYDL+qK64GodW1paon79+nBxccGAAQNw+vRpZGdnw8HBARMmTGDfqCakrAICArBgwQJs2bIFPXv2lHh7GlDskCOurq5S027evIn79+9DQ0MD8+fPh4GBAYCi+pNUTFBQEGbOnCl1/cbj8XD06FH06NGDo8hIVWJra1vmz/r6+iolBrquIaRiQkND4ejoiBUrVsDOzg4jR45kGz8mTZpUanYuUjbqXk8NHz4cCQkJ8Pb2lvkc6M2bNxg5ciRatWqFy5cvcxCh8qj7tq0sbt++DUNDQ7Rv3x6enp44duwYWrRogfXr16tdw7tYfn4+oqOjwefz8d133yltqEei/oo3RMvSrVs3FUVCyoMaogkhlYapqSmbElwsJycH0dHR0NTURMuWLaUeGCvS48ePsXr1asTGxkrNU8exs4Cit+MjIyNljgWu6DSHYpaWljA2Nsa5c+ewaNEitGvXDvPnz8eMGTPw7NkzpY7j6OLigh07drBvy+nq6mLFihVq0QDA9fEDFI3hWKtWLbkpb2vUqKGwsirD8qq7yrCOO3XqhG7duuHo0aOYNm0aRo4ciQkTJsDBwQGvX7/GnTt3lFo+UT8DBgxASkoKcnNzpeYp+lxvYmIi841s8e1X8XnqlGa+oKAAcXFxyMzMhLa2Ntq0aaOyl77u3buHP/74A9HR0QCA1q1bY9myZRg0aJBKyifKExUVhZiYGIlhGrKysvDw4UPs3r2bw8gUozKcc4n6+vDhA7Zs2YLIyEipoU7UNYXl58+fIRQKYWhoiBcvXuDChQto3rw57O3toampyXV4VVJ1qqf27NmDQ4cOwdjYGGvXroWVlRX4fD5EIhECAgKwdetWxMXFYf78+ViwYAHX4VZYZdi2IpEIly5dQkREhNQwXzweD7///rtSy1elkJAQ1KtXD0ZGRhLTg4KCkJubi759+3IUmfLExcUhPj6eHdbk0KFDGDBggNQ6IISoL0rNTQiRsnz58jJ/dteuXQort3hKcDFtbW106tRJYWWUZtOmTXj9+rXMeer4zs7u3btx5MgRqenKGm9PjKtUaTdu3GDffq9duzYYhkFmZiY2btwIAwMDDBw4UGllqwLXxw+g2pS3lWF51V1lWMeNGzfG06dPERUVhc6dO8PT0xNt27bFy5cvJdIvEVJWpWV6UfS5vrqlj09MTMSOHTtw69YtiRfcatSogUGDBmH58uVKy6Qj1rt3b/Tu3RtpaWng8/nQ09NTanlENVxdXUvtwagODdGV4ZxL1NeqVasQFBQkc566prBs0KAB8vLyEBUVBQ0NDaxcuZJ631VQdaqnZs2ahevXr+PVq1eYMWMGatSogbp16yI1NRVCoRAMw6BNmzZqkYYcqBzb9vfff8eZM2fYeIpTt4boadOmYeDAgRIN/wCwf/9+xMTEIDAwkKPIlEOcpaJHjx7o1asXGIbBwYMH4ezsjCNHjsDS0pLrEEkVsHv3bhgZGeH7778v9dqfx+Nh6dKlKoyMlBU1RBNCpFy9erVMn+PxeAptiOZaVFQUDAwMcOLECbRq1UqhvTcrI1dXVzAMg+7du8PQ0FBlKZaWLVsGR0dH5ObmYtiwYfj7779x4cIFAEVjxyjLoUOHUKNGDezcuZMdh8bb2xu//PILDh8+XOUboiuD1atXY8GCBfD29lZ6yltSPYwdOxZ79+6Fr68v+vfvj6NHj2Lq1KkAgK5du3IcHamKVDlO5qlTp1RWFtfevXuHiRMn4suXL1IPDwsLC+Ht7Y0HDx7Azc0NzZs3V2jZOTk58PHxwYcPH9C0aVMMGDCAxgBVMydOnACPx0OfPn1w584dDBo0CLGxsXj16hVmz57NdXiEVHrh4eHQ19fHr7/+qtL7Pq4UFhZi7969OHnyJAoKCgAU3YfMmDEDixYtUvv7fFJxenp6OHfuHNavXw9fX18UFhbi8+fPAIqegw0YMACbN2+Grq4ux5Gqj5s3b7JjJAsEgq+O0V3VHDt2jG1oB4D79+9jwIAB7N8ikQiJiYlq+RLl3r17kZOTA2NjYwBF2ZPGjRuHs2fP4q+//qpW90zk2x0+fBh2dnb4/vvvcfjwYbmZx6ghuvKi1NyEEClOTk5l/qwi0xCZmJigcePGsLCw+OpnldEA/sMPP6B27doSF4fqrFu3bmjXrh0nF31cpEorPjZ1cdOmTUNERAQeP36slHJVhevjB1B9yluul1fdVZZ1fPr0aZiYmMDS0hIHDx7EP//8gxYtWmDnzp3szSwhipCRkaHUhz8hISFISkrCiBEjAAAbN27EoEGD0LNnT6WVqSrLly/H1atXYW1tjQULFsDU1BQ6OjrIzs7Gq1evcPToUfj4+GD06NHYtm2bwsqNiYnBjz/+iOTkZHZa8+bNcfLkSTRp0kRh5RBuFb+Gs7W1xZYtW2BhYYGhQ4eiZcuWOH78ONchVlhlOecS9TRkyBAYGhrixIkTXIeiEtu2bcPJkyfBMAz7Ymx2djZ4PB5mzpyJlStXchxh1VRd66mUlBQ8ffoUaWlpqF27Njp06IBGjRpxHZZCVYZta2VlhbZt28LFxUUpv8+19PR0DBw4EGlpaeDxeHIzMU2YMAGbN29WcXTKZWFhARMTE6lnrVOnTsXLly+VOjwfUR+rV69Gx44dMXXqVKxevbrUjC6KvN8kikMN0YSQSkM8luLXqiUej6ewsRSLp44MDQ3FwoULsW7dOgwYMEBqPEN16825bds2XL16FefOnUOLFi1UXn5eXh7evHkDPp+Pli1bKn399ujRA3Xq1MG1a9fYXgBCoRBDhw5FZmYmAgIClFq+snFx/MiKoTQvXrxQaFlcL6+6qwzr+P3796hVqxYMDAwkpsfFxSE3N/er+xwhJWVmZuLAgQPsWLPi/Ts7OxvR0dEIDw9XSrk+Pj5YvHgxbGxscPjwYQiFQpiZmYFhGPz111+ws7NTSrmq0qtXL4hEIty+fVvmeND5+fmws7MDwzAKHYt01qxZuH//PnR0dGBsbIyoqCjk5uZi0KBB+OuvvxRWDuGWpaUljI2Nce7cOSxatAjt2rXD/PnzMWPGDDx79kwtHmBWhnMuUV++vr5YsmQJ5s2bh759+6JWrVoS89u0acNRZMphbW2N3NxcODk5oXfv3gCAwMBA/Pzzz6hVqxYePHjAcYRVE9VT6qsybNsNGzYgMDAQ165dU9usBdHR0fj48SMcHBzQtWtXLFy4kJ3H4/FgYGAAgUDAYYTKYWFhgaZNm+Ly5csS04cNG4YPHz4gLCyMo8gIIaqkXnkuCCFKERUVxT6wFcvKysLDhw8VPiZbmzZtMGzYMIX+ZmnMzMykpq1Zs0ZqmqJ7c1YGc+bMgZeXF0aMGIHWrVtDW1tbYr6y3kTlKlVaz5494e3tjblz52LUqFEAAE9PT7x7906l+5wyqfr4KUmVKW8B7pe3OuB6Hdva2socP2vt2rV4+/Yt/Pz8OIqMVFVbt26Fl5cXm7ar+AO32rVrK63cgwcPAgD69OkDoCht2LJly7B7924cOnSoyjdEp6amwtraWmYjNFB0njc1NYW/v79Cy338+DH09PRw5coVGBoaIjY2FuPGjUNoaKhCyyHcEggECA8Ph4eHB7p27QpnZ2ckJiYiODhYrdKwc33OJepLV1cXmpqa+Ouvv6Re0lHH+1yGYWBubs42QgNFLyV36dJF7ZZV1aieUl9cb1uBQIBr165hzJgxsLKygra2tkSPx2XLlnEWm6IYGRnByMgIJ0+eRL169apNdi8rKyvcvXsXjo6OsLGxQWFhIfz8/BAbGytRTxNSHuIXyfPz86VeorGysuIoKlIaaogmhJTK1dUVGzdulDtf0Q3R3333nULTfX9NWZNCqGPyiPXr1yMtLQ0A8PLlS4l5paU4qagdO3bITJV2+PBhFBQUKC1V2rJlyxAQEAA/Pz+2NxbDMKhTpw6WLFmilDJVTdXHT0nNmjVj/52UlAQej6fUtGVcL291wMU6Pnv2LK5fv87+HRoaiunTp7N/i0QihIeHKy2NP1Fvfn5+qFu3LjZu3Ijly5fjt99+Q2JiIvbt26fUfT02NhZWVlbsGOcaGhpwcHCAn59flR8aAih6yaxkD7uSNDQ0IBQKFVpuVlYWunfvDkNDQwBFD1E7depEDdFqZtmyZXB0dERubi6GDRuGv//+GxcuXAAADB48mOPoFIeua4iybNiwAVlZWTLnqeN97siRI3Ht2jWkpKSwWXUSEhLw/PlzTJgwgePoqjaqp9QX19v2t99+A4/HQ3p6OqKiotjp4pdH1aEhWuz9+/d4//49nj17JnO+uOOEulixYgUePXqEe/fu4f79+wD+71ncihUrOI6OVEW3bt3C6tWrkZmZKTVPHV+wUxfUEE0IKdWJEyfA4/HQp08f3LlzB4MGDUJsbCxevXqF2bNncx1eham6B2dlcu/ePWhra8PR0RGGhoZsumpl8/LygpaWlsxUaR4eHkpriG7WrBkuXrwIZ2dnhIaGgs/no3PnznB0dOQkNbm6unv3LrZs2YL4+HgAQMuWLfHrr7+ib9++HEdGqgo7Ozvs2LEDOTk54PF4+PLlC4KDg6U+179/fw6iI1VdWloaevbsicGDB+Pw4cPQ0tLCvHnz4OfnBzc3N8yYMUMp5WppaSEhIQFCoZDN/JGfn4+3b99CQ0M9bslSUlLYh0uyFB/HWVGEQqFUA7iOjo7CG7wJtywtLXHz5k0IhUI0atQIJ06cwIULF9C8eXPY29tzHR4hlV5iYiJatGiBU6dOwdDQUKkvHVcGurq6yMnJwZAhQ9C1a1cUFBQgLCwMBQUFiI+Px/Lly9nPqtNYxoRUZaNGjVL7uknsa+PbqltDdNu2bXHp0iWcOXMGL168AMMwMDU1xZQpU9C4cWOuwyNV0L59+5CRkQE+n4969eqpzf20uqOtRAgpVUJCAiwsLODs7AxbW1tMmjQJFhYWGDp0qMJ78FhZWak8NU3xHpzFZWVlgc/nS6WrVieNGzdG06ZNMW/ePJWWy2WqtEaNGmH9+vVKLYMrXBw/JQUHB2PevHkSDQBv3rzB/Pnz8e+//yo0PU5lWF51x9U6btSoEQ4ePIj4+HisW7eOvUkV4/P5MDAwQM+ePVUeG6n66tati5iYGOTm5qJjx464ffs2Bg0ahPT0dLx//15p5fbq1Qve3t4YNWoUrK2tIRQKERgYiMTERAwZMkRp5apSeHg4HB0d5c4X92hRtJIN4CkpKQAAf39/iZ5+vXr1UnjZRDXGjh0LKysrrF69GkDRWJZr167lOCrFousaokzW1tZISUmpNg/8Dx8+DADIycnBnTt3JOYVz7rD4/GoIbocqJ5SX5Vh227fvp3T8lXJ3NycvSZmGAb5+fl48+YNGIbBoEGDOI5OOQwNDdWqVzvh1ps3b9C4cWOcP38eDRs25DocUkbUEE0IKZWmpiYKCwsBAB07dsSjR4/Qs2dPtGzZUm4amW916tSpcn1+/fr1CAgIgI+Pj8JiOHfuHA4fPowPHz4AAJo2bYq5c+di/PjxCiujsli+fDlWrVoFb29v9O7dW2pcRy0tLaWUq8pUaa6urmjevDlsbGzg6upa6mcnTpyo0LJVrTIcP/v374dQKMTy5cvZbenq6ordu3dj37595Y6xNJVhedUdl+u4R48eAIoalJo1a4YRI0ZU+DcJAYDevXvDy8sLhw4dQvfu3bF06VLcunULubm5aN26tdLKXblyJSIiIvDq1StER0ezDaTNmjXDqlWrlFauqjRt2pSzsuU1gM+aNYv9N6Voq9revXsHXV1drsNQKrquIcr0/fffY+3atZg9ezZsbGykMklU9fugkubPn19telaqEtVT6ourbRsSEoJ69erByMhI7mfu3LmDt2/fSgzVVNWdO3dOalp6ejrGjRvH+QsBilLWYRx5PB6WLl2q5GiIujExMYGmpiY1Qlcx1BBNCCmVQCBAeHg4PDw80LVrVzg7OyMxMRHBwcHQ19fnNLbk5GQkJCQo7PcOHTqEvXv3SvSeSUhIwPr165GamlpqL5+qaNeuXRCJRBKpycSU+cBWlanSNmzYgIEDB8LGxgYbNmwo9YGEuj2A+RpFHz8A8PTpU3Tp0kXiWJk9ezZ8fX3x9OlThZZVXspYXiJJGev4yJEjaNKkCTVEE4X53//+h6ysLBgbG2PQoEHo2bMnAgICoKmpqdSHIIaGhrh06RIuX74skZJuxIgRatHA5uvry0m5XDaAE9WZPHkyTp48iWvXrsHS0hJ6enoSQ8oo6+XJyoyua0h5/PLLL+DxePDz88O9e/ek5qvbfdDChQu5DoGA6il1pqhtO23aNAwcOBD79+8HAGzbtg0hISHw8PBgP3P+/Hn4+vqqVUO0LHXq1EHXrl1x+vRpODg4cB1OhR0+fPirLwSJsyVRQzQpr/Xr12PmzJk4cuQIevbsCW1tbYn9rU2bNhxGR+ShhmhCSKmWLVsGR0dH5ObmYtiwYfj7779x4cIFAMDgwYM5jk6xTp06BT6fj3Xr1rFpMm/evImNGzfi5MmTatcQ/ebNG7nzijfGK5oqU6VZWVmxb9cqMi00kU1TUxPZ2dlS07OysqrlQ2JScc2aNYNIJOI6DKJGateujX379rF/Hz16FM+fP0fjxo1Rv359pZato6Mj82F/RkYG9PT0lFq2uuKqAZyo1uXLl5GXlyczpSP1difk66rjfdCbN29w/PhxREREoGPHjhg6dChyc3PRv39/rkMjhBRT/NlTfHw8IiMjOYxGNYoPKQMAQqEQHz58wO3bt5GXl8dRVIpVncb8Jqo3duxYAEU970v2vqd7g8qLGqIJIaWytLTEzZs3IRQK0ahRI5w4cQIXLlxA8+bNMXXqVK7DU6isrCxYWFhg0qRJ7LTx48fj8uXLePLkCYeRKcetW7c4KVeVqdKKp5hSZFpoIlvXrl1x9+5drF+/nr0wdHd3R3R0NPr168dtcKRK6tOnD44ePYqRI0fC3Nwcenp6qFGjBgBK40W+XWFhIW7evImIiAg0a9YMNjY27DAkypKZmYkDBw4gJiYGeXl57EO37OxsREdHIzw8XKnlE1KVlTZ+uzJfniREXVS3+6DHjx/jxx9/RE5ODng8Hpo2bQp/f38cO3YMe/fuVdsxWAkhVcOsWbNkPhNjGEZtnptUpzG/ieqVdv1P9waVFzVEE0JKFRMTg7Zt27J/m5iYYO3atcjPz8fx48clxt+r6gYMGICHDx8iLy+PHS85IyMDr1+/xrBhwziOTvGaNWvGSblcpUqbPn06LC0tsWjRIonpq1atwqdPn3Ds2DFO4lInS5YswYMHD3D+/HmcP38eQNFFoJaWFqXII9/kyJEjAMCOqytGabzIt/r06RMcHBzY/WnAgAFIT0/HiRMncPLkSZiYmCil3K1bt8LLy4vdd4vfINeuXVspZRKiLrh6eZKQqqxkj7vS9OrVS4mRqN6OHTtQUFCAjRs3YuPGjQCAzp07g8/nw9nZmRqiCSGckjW0jLa2Njp16oRffvmFg4iULy0tDW/evEF+fr7EC7khISFqu8xEeV68eMF1COQbUEM0IaRU9vb2OHz4MDp37sxOu3nzJnbs2IF3796pVUN0x44dcevWLXz//ffo3bs38vPzcefOHaSmpkJHR4dN91GVGz8mTZqEbt26YdmyZRI9v2VxcXFRWhyqSpUWEhLCjl0UHByMzMxMtGzZkp0vFAoREhKC5ORkhZZbXZmYmMDFxQV79uxBaGgo+Hw+OnfujEWLFqF9+/Zch0eqIErpRRRt+/btiI6OxtChQ+Ht7Q2gaFiB9PR07NixA0ePHlVKuX5+fqhbty42btyI5cuX47fffkNiYiL27duHBQsWKKVMQtQFVy9PElKVyetxV5I6prB88uQJrKysMGnSJLYhetCgQTA3N1fLTGeEkKqlug0t4+PjgyVLlkAoFMqcTw3RRJFKdqgjlQc1RBNCSpWamoqZM2fCyckJdevWxe+//47Q0FAwDIMuXbpwHZ5CiVPHvHnzBm/fvgXwfyk9Tp8+zf5dlRuiw8PD0aBBA/bf8iiz4UeVqdLy8/OxevVq8Hg88Hg8REZGYs2aNRKfYRiGLlIU5OrVq7CyssKhQ4e4DoWoCUrpRRTt/v376NChA3bv3s02RM+ePRvXr19HRESE0spNS0tDz549MXjwYBw+fBhaWlqYN28e/Pz84ObmhhkzZiitbEKqqri4ODg5OWHTpk3Q1dWFqampxPyOHTvCzc2NXlgiRAZZPe6qi5o1a+LDhw8S2Ufy8vLw7t076OjocBgZIaSk5ORkNoODuIOAv78/e/yqS6eB/Pz8Mn9WS0tLiZGo3oEDB1BYWAhjY2O8evUKZmZmSEhIwOfPn7/aQYYQWZKSkrB161aZw16lpaWp3Qt26oIaogkhpVqxYgV27tyJ2bNnQyQSQSgUokWLFli2bBmGDh3KdXgKVR163m3btg1NmjRh/80FVaZKs7GxwYQJExAdHY2wsDDo6+tLNDrz+XwYGBjgp59+UliZ1dmGDRvQpEkTXL58metQiBqJiopibzDEsrKy8PDhQzZTBSFllZeXB01NTanpQqFQqeNJ1a1bFzExMcjNzUXHjh1x+/ZtDBo0COnp6aWOf0tIdZWQkAB7e3ukpKRgypQp6Nq1q9Qx+vTpU/j4+GDgwIEcRUlI5VXdetwVZ2trCy8vL4wePRpA0YvQI0aMQFJSEkaNGsVtcIQQCeHh4XB0dJSYVjzzorgzSFVnZmZWps+pY5aKuLg4mJmZwdXVFb169cKKFSvQtm1bDB8+HElJSVyHR6qgLVu24ObNmzLntW7dWrXBkDKjhmhCSKl++uknNG/eHCtXrkRBQQF69OiBI0eOQEOD++rDwMCAbVRVhOrQ8058M17y36qk6lRpmzdvBgBMmzYNFhYWWLJkicLLqIoUffwARakzRSKRQn9TUZSxvESSMtaxq6srW0/IQg3RpLwsLCwQEBCALVu2AADevXuH5cuXIyoqCj179lRaub1794aXlxcOHTqE7t27Y+nSpbh16xZyc3PpZpkQGY4ePYrk5GQYGRlBX1+fnW5hYYHFixfj/PnzuHz5Mq5evVotG6LpuoYQ+X799VfExsayGcA+fvwIoCiLwooVKziMrHqhekp9KWrbVqfMDWV94VWZL8ZyqWbNmgCK6uHw8HBYWlrC1NQUjx494jgyUhUFBwejcePGcHJywpQpU3DgwAGkpKTg119/xfDhw7kOj8jBY9S1hiOEfDNZD/YjIiIQFBQEHo+HsWPHwsDAAACwbNkypcWRkpIi1QtOrFevXgopQ5wCqCwUVSaXnJycyvQ5Ho+H+fPnKyUGa2trGBgYwNvbG6amprCzs8OuXbswePBg5OfnIyAgQCnlypOTk4OQkBD06dNHpeUqmyqOn5J27dqFo0ePom3btjA3N4eenh5q1KgBQPljq3OxvNUNF+t42LBhiIuLQ58+fXDnzh0MGjQIsbGxePXqFWbPnq3UcxBRT69evcLUqVORlpYGoKhuYhgGurq6OH36tFTqX0XJzMzEr7/+iiFDhmDw4MFwdHREQEAANDU1sWvXLoVmAyFEHQwePBjJycm4efMm6tWrBwAwMTGBnZ0dnJyckJ6ejn79+qFOnTq4c+cOt8EqAV3XEFJxgYGBeP78OTQ0NCAQCNCjRw+uQ1IrVE+pL9q2ipeQkFDmzzZr1kyJkajemDFj8OrVK+zZswfR0dFwc3PD+PHj8ffff6NWrVoIDg7mOkRSxXTq1Andu3fHkSNHMGnSJEyaNAmjRo3C9OnT8f79e/j4+HAdIpGBGqIJIVJMTExkpr4pWV2Ix9xVBm9vb6xevRoFBQVS8xSZqkbesiqzTC6VdXkBKG3brlmzBl5eXmjXrh1evHiBRo0aoWbNmoiPj8eoUaOUljI8JiYGK1aswOvXr2XeUClrebmgquOnJBMTE4lyxMTptKp6fVGdcbWOzczM0LlzZ5w6dQq2trbYsmULLCwsMHToULRs2RLHjx9XSrlEvX38+BFnz55FZGQkNDQ0YGxsjClTpqBRo0Yqi4FhGDx//hyNGzdG/fr1VVYuIVVFly5d0LVrVxw7doydNmbMGHTv3h0rV64EADg4OCA0NBSPHz/mKkyloOsaQkhlR/WU+qJtSxTNx8cHixcvxsqVK9G/f398//337Li+w4YNoyxnpNz69++PgoICuLu7459//sHbt2+xefNmTJ48GSkpKWxGFFK5cJ9blxBS6VSGsZJ3796N/Px81KpVC/Xq1VNaPNUpFRAAjBgxgl2XhYWFuHHjBnR1ddG1a1fweDyEhoZCJBJh2rRpSouBq1RpW7dulXvTZGVlpbRyuaCq46ckruoOrpa3OuFqHWtqaqKwsBBAUR3x6NEj9OzZEy1btsSzZ89UEgNRP40aNVLZMA05OTnw8fHBhw8f0KxZM9ja2qJWrVrg8Xjo0KGDSmIgpCrS0tJCamqqxDQPDw+Jv798+QI9PT0VRqUadF1DSPkNGDCgTJ/j8XjUU0oBqJ5SX7RtlW/69Oly52lpaaFhw4YYOHAgbG1tVRiV8tjZ2eHChQvQ1tZGy5Yt4eTkhNOnT6NFixZYtGgR1+GRKmjw4ME4fvw4zp8/j169emHOnDno168fACgtwxmpOGqIJoRIqQxjJX/69AnGxsZwd3eHlpaW0srx9fVV2m9XRjt37mT//fvvv6Nu3bq4fPkym2r906dP7NuJyqKnpwcXFxeVp0p7/PgxWrVqBRcXFwwYMACnT59GdnY2HBwc0K5dO6WWrWqqOn5K4qru4Gp5qxOu1rFAIEB4eDg8PDzQtWtXODs7IzExEcHBwRJjhhJSmjVr1pTpczweD7///rvCyo2JicGPP/6I5ORkdlrz5s1x8uRJGjORkK/47rvv8PTpU7x48UIi44pYREQEoqKiYG1tzUF0ykXXNYSUX1nT3lKjmmJQPaW+aNsqX3BwMDs8UHHFp3l5eWHz5s0YP348FyEqXPHGwV69elGKd1Ihy5cvB4/HQ6dOndC3b1+MHTsW7u7u0NfXx6+//sp1eEQOaogmhEipDOMm9+zZE+/evQOfz1fK75dVfn4+vL29cf78eZw5c4bTWBTN09MTHTp0YBuhAaBhw4YwNjaGh4cHVq1apdTye/ToodJxuvLy8tC8eXPUq1cPHTp0wNOnTzFhwgRYWlrCx8cHa9euVVksysbl8ZOUlITw8HDk5ORIzRs1apRSyqws9YU642odL1u2DI6OjsjNzcWwYcPw999/48KFCwCK3oIlpCw8PT3ZB8+ljUqk6Ibobdu24fPnz9DR0YGxsTGioqIQHx+P7du346+//lJYOYSoo7FjxyI8PByzZ8/GsmXL0KNHD9SrVw9JSUnw8/PDwYMHIRKJMG7cOK5DVTi6riGK9vnzZ+zevRsRERFsOlQxdekh/O+//0r8vW/fPoSHh0uk9yeKQ/WU+qJtq3yHDh3C8uXL0bt3bwwfPhxAUcOzv78//ve//yEvLw/bt2/HqVOn1KIhOicnB8eOHZN7Djpx4gSH0ZGqSFNTU+KZ9datW/HLL79AX1+f6q5KjMaIJoRIqQzjJn/8+BEjR45Ew4YN0aNHD2hra0vMX7ZsmVLKFXv16hVcXV1x+fJlpKenA1CvMYQBwNraGrm5uXB2dmYbhO/evYuFCxdCR0cHDx48UFhZlSFV2sCBA5Geno5Tp07h4sWLCAsLwy+//IJFixYhOzsbjx49Ukq5XODq+PHy8sLatWshFAplzlfWMcR1fVEdcLmOP3/+DKFQCENDQ7x48QIXLlxA8+bNYW9vD01NTaWVS9SH+Lqmdu3asLCwQLdu3VCvXj2Znx09erTCyu3WrRsYhsGVK1dgaGiI2NhYjBs3DrVq1YK/v7/CyiFEXc2bNw++vr4y70sYhsHQoUOxZ88eDiJTLrquIYr2888/486dOzJfxuLxeGp3nwsA8+fPh6+vr1ouW2VA9ZT6om2rfD/++CNSUlJw+fJldhrDMBg+fDhatmwJZ2dnTJs2DY8fP0ZERASHkSrGihUrcOXKlWp1DiKKVxk6zZGKoR7RhBAplWHc5FOnTiEtLQ1paWmIiYlhpzMMAx6Pp5SL37y8PFy9ehVubm7sxR7DMNDQ0MDQoUMVXh7Xhg0bhnPnzsHBwQHa2tpgGAa5ublgGAb29vYKLasypEobO3Ys9u7dC19fX/Tv3x9Hjx7F1KlTAQBdu3ZVWrlc4OL4AYp6HhQWFqJRo0Zo2rSpyt5E5Gp5qxMu13GDBg2Ql5eHqKgoaGhoYOXKlZQmjpRLly5d8PTpU2RkZODu3bvw8/ODkZERrK2tYW1tDSsrK6Wkes/KykL37t1haGgIAGjTpg06deqE0NBQhZdFiDpycnLCkSNHcPr0aXz69Imd3qRJE0ybNg0zZ87kMDrloesaomgPHz6EpqYmFi1aBIFAQC/ykQqjekp90bZVvkePHqF9+/YS03g8HurUqYPAwEAAAJ/Ph0gk4iI8hfP39wefz8eECRMgEAigoUHNUaT8Zs2axXmnOVIxdOQTQqRUhnGTXVxcwOPxYG1tDUNDQ6U2aL148QJubm64fPkyMjMzJd7Sa9asGVxcXNCwYUOllc+V1atXAwDOnz+P7OxsAICWlhZ+/PFHLF68WKFlVYZUaXPnzkXt2rVhYmICS0tLLFq0CEeOHEHLli2xYcMGlcWhCqo8fopLTk5G69atcenSJZU2FHK1vNUJV+u4sLAQe/fuxcmTJ1FQUACgqJ6aMWMGFi1ahBo1aqgkDlK1ubi4ICsrCyEhIQgMDERAQACioqIQFRWF06dPg8fjoV27drC2tmbPjYogFApRq1YtiWk6Ojpys0YQQiTx+XzMmTMHjo6OiI+Px5cvX2BgYIAWLVpwHZpS0XUNUTQdHR20b98es2bN4joUoiaonlJftG2Vr1GjRoiIiMCuXbswaNAgMAyDGzduIDw8HM2aNcPdu3cRHByMZs2acR2qwnTt2lXtnrsR1aoMneZIxVBDNCGk3FQxbrKmpiYsLS1x/Phxpfy+2IQJE/DkyRMARW946unpYeDAgRgxYgQcHBxQp04dtWyEBoCaNWtiw4YNWLFiBd6+fQs+n49WrVqhZs2aCi+r5FjQp0+fljld2cQ9oIGidI/z5s1TafmqoqrjpyRra2t8+vRJ5b1VuVre6oSrdbxjxw6cPHkSDMNAR0cHAJCdnY3Dhw+joKAAK1euVGk8pOrS1dVFv3790K9fPwBASkoKLly4gH/++Qfp6emIjIzEixcvFNoQLS6neBqxlJQUAEU9A4q/+EbpwwiRj8/no2XLlmjZsiXXoagEXdcQRZsxYwacnZ3x4cMHNG7cmOtwlKJkys7k5GQA0udbgM65ikD1lPqibat8c+fOxdq1a/HPP//gn3/+kZjn6OiI6OhoMAyDQYMGcRShYo0fPx5eXl7IysqCrq4u1+GQKqoydJojFUMN0YSQMpM1brKyTJkyBS4uLnj//r1S33p6/PgxeDwetLS0sHTp0mo55qiOjg5MTEy4DkMlQkNDER4ejry8PKkHEgsWLOAoKsVT1fEDSD70GThwIH777Tf8+uuvsLW1leoJqKyHPqpc3uqKq3Xs5eUFLS0tODk5oXfv3gCAwMBA/Pzzz/Dw8KCGaFIuGRkZCAoKgr+/PwICAvD27VuJc4GRkZHCywwPD4ejo6PU9OK90ih9GCGkOLquIYr28uVLiEQiDBo0CK1atYKOjo5EeksXFxcOo1MMeSk7S/YCp3OuYlA9pb5o2yrfuHHj0LBhQxw6dAgxMTEQCoUwNjaGg4MDBg4cCHd3dyxcuBBz587lOlSF4PP5yMnJweDBg9GxY0epc9CuXbs4jI6oC1V0miMVQw3RhJBScTVucmJiIjIzMzFs2DC0bt1aqkFLUTfL9evXR3JyMvLy8vDHH3/g+vXrGD58OIYMGaKQ3yeVx4EDB+Dk5CQ1XTzWkTo1RKvq+AFkP/Tx9PSEp6enxDRlPvRR5fJWV1ytY4ZhYG5uzjZCA0WZFLp06UIPEUmZ7d27FwEBAXj27BlEIhHb+GxkZIRu3bqx/xkYGCi0XHp4Rwj5FnRdQxSt+HX5q1evJOaVZbzFqoDOuapF9ZT6om2rGn379kXfvn1lzhs7dqyKo1Guv//+m/33nTt3JObxeDxqiCYVospOc6RiqCGaECIT1+Mmu7u7S8RSnCJvlu/evYvbt2/D3d0d9+7dQ3h4OCIiIrB9+3YAQE5ODvLz81WealjdVIZUaZ6enmAYBsbGxjAyMoKGhvqeAlV1/ACV46GPKpe3uuJqHY8cORLXrl1DSkoK20iYkJCA58+fY8KECUorl6gXZ2dn8Hg86OrqwsLCgm14rl+/PvuZ3Nxchff8oPRhhJBvQdc1RNG2bdvGdQhKR+dc1aJ6Sn3RtiWKNn/+fNp3iEJx1WmOVAyPKdkCQAip9r42brKpqalUb0dF+9rvjx49WuFlJiUlwcPDA56ennj79i2AogttfX19jBkzhlLAVoCJiUmZLjyV2WvW3NwcrVq1gqenp9pfBHNx/HCpui0vF7hax7t378apU6egqamJrl27oqCgAGFhYSgoKICdnR1q1KjBfpbepCbyVIZzECGElBVd1xBCKjuqp9QXbVtCSGXFdac5UjHUEE0IkSJ+YCtr3GQTExOVNERzLSgoCG5ubvDx8UFeXh54PB4iIyO5Dkuhxo4dCysrK6xevVrpZdna2pb5s8p6m33JkiV4/fo1Ll26pJTfr+6ys7Oho6MjMS0jIwN6enocRUTUQVnHr1fHOpooTmU4BxFCCCFcun37NmJiYpCXl8c+uM3OzsbDhw/h6urKcXSEEELUWWZmJk6ePInQ0FDweDxYWVlh6tSpqF27NtehkSqiMnSaIxWjvnlJCSHfjKtxk3fv3g0jIyN8//332L17t9zP8Xg8LF26VKmxWFtbw9raGhkZGbh06ZJEeiJ18e7dO+jq6qqkrMrwYH/IkCFYv3495syZg+7du0NbW1uih9zEiRM5jK7iuDx+zpw5gz179uD06dMSDYd79+7FvXv3sGnTJvTo0UOhZVam+kJdVYZ1TGm8iCJUhnMQIYSUpjKcc4n6OnDgAJycnNi/GYah6ytSblRPqS/atkSZvnz5gilTpiAuLo59ESogIACXLl3CmTNnUK9ePY4jJFXB48eP5XaaI1UD9YgmhEgpLCyUGDdZKBSCx+OBz+dDKBSidevWuHTpksLHTTYxMYGdnR2cnJzkptEU3zRTz7eK27NnD06ePInff/8dlpaW0NPTA5/PZ+er27jYX0vNWtX3Ka6On9u3b+Pnn38Gj8fD//73P0ydOpWdN2DAACQkJEBLSwunT59G586dFVYu1RfKR+uYEEIIUQ065xJlsrOzw8ePHzF+/HicOXMGU6dOxevXrxEQEIBly5Zh9uzZXIdIqgCqp9QXbVtupKSkSGWpCAkJweTJkzmOTLHWrVuH8+fPo3379vj+++8BABcvXkRkZCQmTJiAzZs3cxwhqQpsbGyQnJwMoOilGDMzM7bTXO/evalHdBVAPaIJIVI0NDQwcOBADBw4UOa4yW/evEGfPn0UPm7yqFGj0LFjR/bf9Ja2cl2+fBl5eXlYtmyZ1Dx1HCfTysqK6xCUiqvj59ixYwAAR0dHjB07VmLe+fPnsX37dly6dAmHDx+W6IlRUVRfKF9lWcfR0dGoU6cOGjVqBFdXV/j5+aFXr15qd4NOCCGk+qos51yinpKSkmBlZYV169bh/v376N27N9auXYshQ4bA19eXGqJJmVA9pb5o26pWaGgoFi1ahC9fvsicr273ubdv30aTJk1w7tw51KxZEwAwadIkDBkyBLdu3aKGaFImd+/eleg0Fx4ejoiICGzfvh0AkJOTg/z8fLXrVKVOqEc0IaTMqsO4ydXJ18ZeffHihYoiUY13796hRYsWXIehdiwsLGBoaAhvb2+Z80UiEQYNGoT8/Hz4+fmpODpS1d25cwcLFizA1q1b0bx5c9jb2wMoellmw4YNmDRpEscREkIIIYRUbtbW1mjWrBk8PDywfPlyNG3aFMuXL8eUKVPw4sULhIWFcR0iIYRUG5MmTUJ4eDj09fWRlpYGQ0NDfPnyBfn5+RgyZAj27t3LdYgK1blzZ5ibm+PEiRMS03/88Ue2MZGQ8pDVaY7H40FfX1/hneaI4lCPaEJImalq3OTU1FTo6OiwbzEFBAQgMjISTZo0gZ2dHb3dpCC3bt3iOgSVmjx5Mtq0aYNTp05xHYpSqfr4KSwsRMOGDeXO5/P5aNasGR49eqTQcsWovlA+LtfxwYMHIRKJoKGhgcuXL4PP52PJkiU4ePAgzp49Sw3RhBBC1Apd1xBl6NixIwICAnD8+HFYWlrijz/+wNOnTxEWFlbqdTwhslA9pb5o26pGVFQU2rVrB3d3d9jY2GD//v2oW7cuxowZo5Zj3rZu3RqPHj3Cw4cPYWFhAaCoV3hYWBjatm3LcXSkKjI0NMTPP/+Mn3/+WaLTXGpqKv79919qiK6kqCGaEFJuenp6sLe3Z3umKUp+fj5+/fVXeHt7w8XFBZ07d8avv/4qMcaDkZERTpw4AQMDA4WWXR01a9YMAJCbm4vnz5+Dx+Ohffv2bKocdcPj8VBYWMh1GErD1fHTsmVLPHv2DMnJyahfv77U/M+fP+PZs2fs/qYoVF8oX2VYxzExMbCwsMDw4cOxf/9+CAQCzJ49G0FBQUp7uYEQQghRtcpwziXqa9WqVZg1axZ0dXUxePBgHDlyBIGBgQCA8ePHcxwdqSqonlJftG1VSygUwsDAABoaGujYsSMeP36MqVOnwszMjK2b1Ym9vT02bNiAadOmoVWrVgCKhnxkGAYTJ07kODpS1amq0xypOD7XARBCiNg///yDK1euQCQSAQCCg4Ph4eEBADAzM0Pz5s0RHR2NgwcPchmmWnFxcYGNjQ3s7e0xZcoU2NjYwNXVleuwlMLBwQFPnjzBpk2bcPXqVdy9exf3799n/6vquDp+RowYgczMTDg6OiIgIACZmZlgGAbp6enw8/ODo6MjsrKyMHz4cIWWS/WF8lWWdaypqYlPnz4hLi4OXbt2BQBkZGSo5dvihBBCqqfKcs4l6kkgEMDHxweDBw9GnTp1cPbsWaxatQpOTk5YtGgR1+GRKoLqKfVF21a1mjVrhvDwcISEhMDMzAyurq64dOkSIiIikJOTw3V4Cjdx4kTMmTMHfD4fsbGxiI2NBQBMnTpV7cbDJtwRd5oT112k8qExogkhlcawYcPw7t07HD58GD169MDatWtx4cIFtG/fHh4eHsjIyICdnR3q1KmDmzdvch1ulXfjxg32wUPt2rXBMAyysrLA4/Gwb98+DBw4kOMIFcvExAQ8Hk/mPB6Ph+fPn6s4IsXi6vjJz8/H1KlT8fjxY5nrl2EYtG/fHmfPnkWtWrUUVi7VF8pXGdbxuHHjEBUVhfbt2yMiIgIHDhxAVFQU9u7dix49euDff/9VSrmEEEKIKlWGcy6pHvLz86WmUbpdUhZUT6kv2raq5ebmhvXr12PFihWwsbHB2LFjIRKJwDAM+vTpg8OHD3MdolJ8/vwZjx49Ao/HQ6dOnWBoaMh1SIQQFaIe0YSQSiM+Ph4WFhbo0aMHgKLxaHg8Htsgqqenh44dO+Ljx49chqk2Dh06hBo1amDPnj0IDQ3Fw4cPsXv3bvB4PLW88G3atCmaNGki87/GjRtzHV6FcXX8aGlp4eTJk5gxYwZ0dXXBMAz7X61atTB58mScPHlSoY3QANUXqlAZ1vGcOXMgFAoRHh6ODh06oE+fPoiJiYGmpibmzZuntHIJIYQQVaoM51yivl68eIHRo0ejffv2MDMzk/ivS5cuXIdHqgiqp9QXbVvVmjBhAv7++2/06NEDJiYm2LJlC4yMjGBra4tNmzZxHZ7SNGjQAAMHDoSdnR01QhNSDdEY0YSQSqNGjRpsKqDXr1/j/fv34PF46NatG/uZtLQ06OjocBWiWomOjkbXrl0xdOhQdtqwYcNw7tw5REREcBiZcvj6+nIdglJxefzUqlULq1evxsqVKxEbG4u0tDTo6uriu+++U1r6ZKovlK8yrOOBAwfi0qVLePv2Lbp37w4NDQ2MGDEC06dPR6dOnZRWLiGEEKJKleGcS9TX2rVrERkZKXMeJUkkZUX1lPqibat6/fv3Z/89evRojB49msNoFG/69Oll+hyPx8OJEyeUHA0hpDKghmhCSKXRunVrhIeHIyAgAO7u7gCAunXrwtzcHABw8eJFPH36lN7aVhAdHR18/PgRIpEIfH5RggyhUIikpCTUrl2b4+iU5/Hjx4iIiED9+vVhYWEBfX19hffW5UJlOH74fD7atm2rtN8vrjIsr7qrLOu4bdu2EvtVjx494O3tjW3btuHs2bNKLZsQQghRhcpyziXqKSoqCg0bNsSePXtgaGjI3vsRUh5UT6kv2raqVVBQgHPnziEyMlLmcAm7du3iICrFCg4OLnU+j8cDwzByh88jhKgfaogmhFQa48aNw2+//YaffvoJQNGFyfTp08Hn87Fo0SLcvHkTPB4PkyZN4jhS9dCzZ094e3tj7ty5GDVqFADA09MT7969w7Bhw7gNTgmysrKwcOFCBAYGAgAGDBiA+Ph4uLi44NSpU2jWrBnHEVZMdTt+qtvycqGyreNXr17B1dUVly9fRnp6ukrKJIQQQlShsp1ziXoxMjKCtrY2LC0tuQ6FVGFUT6kv2raqtXnzZly4cAGAdFYKHo+nFg3RJ0+elDk9LCwMzs7OyMvLAwA2HTwhRP1RQzQhpNKwt7fHly9fcObMGYhEIkyYMAE///wzgKJUQXw+H3PmzGEbTUnFLFu2DAEBAfDz88O9e/cAFF0E16lTB0uWLOE2OCXYsWMHAgIC0KVLF4SHhwMoSi/1/v17/PHHH9i3bx+3AVZQdTt+qtvycqEyrOO8vDxcvXoVbm5u7JABDMNAQ0NDYlgBQgghpCqrDOdcor7Wr1+PmTNnYt26dejbt69UNqhevXpxFBmpSqieUl+0bVXL29sbfD4fo0aNUtssFcXTugNAeno6duzYAXd3d4hEIjRo0ACrV6/GiBEjOIqQEKJqPIYGhCGEVAExMTFo0KAB9PX1uQ5FrXz8+BHOzs4IDQ0Fn89H586d4ejoiBYtWnAdmsLZ2NigXr16uHLlCkxMTGBnZwcnJycMGzYMycnJCAoK4jpEpalux091W14uKHsdv3jxAm5ubrh8+TIyMzMl3hRv1qwZXFxc0LBhQ6WUTQghhFQmdF1DKsrb2xurVq1CYWGh1Dwej4fnz59zEBVRJ1RPqS/atorXq1cvGBsb499//+U6FJXw8vLCn3/+iS9fvgAAJkyYgF9++QV6enocR0YIUSXqEU0IqRJUNe5sddOoUSOsX7+e6zBUIiMjA0ZGRlLT9fT0kJiYyEFEqlPdjp/qtrxcUOY6njBhAp48eQKgqPeznp4eBg4ciBEjRsDBwQF16tShRmhCCCHVBl3XkIrasWMHCgoKoK2tjbp169KYnEThqJ5SX7RtFW/atGn4559/EBYWhq5du3IdjtLExMRg48aNCA0NBcMwaNeuHTZt2kRjjRNSTVFDNCGEVCOurq5o3rw5bGxs4OrqKvdzfD4fNWvWRKtWrWBmZqbCCJWnffv2CA0NZd86/fz5M3bv3o2IiAi1vvgnpKp5/PgxeDwetLS0sHTpUtjb20NTU5PrsAghhBBCqqTU1FQYGxvD3d0dWlpaXIdDCCHV2vfff49jx47B3t4eurq6EsMl8Hg8dui8qmzPnj04duwYCgsLwefzMWnSJMyYMQM1atTA+/fvJT7btGlTjqIkhKgSpeYmhJBqxMTEBAMHDsT+/fthYmJSprfhf/rpJ/zyyy8qiE65QkND4eDggIKCAnaaeKzZI0eOoEePHhxGRwgRs7GxQXJyMoCiG3EzMzMMHz4cQ4YMQe/evWFqagpPT0+OoySEEEIIqRqWL1+Oly9f4uLFi6hRowbX4RBCSLU2bdo0hISEyJzH4/EQGRmp4ogUr6zPG2l4CEKqD+oRTQgh1YiVlRWbntrKyqrUz3769AlxcXFwc3NTi4ZoS0tLuLm54ejRo4iMjISGhgaMjY3h4OAAU1NTrsMjhPx/d+/exe3bt+Hu7o579+4hPDwcERER2L59OwAgJycH+fn51KOHEEIIIaQMzM3NcevWLYwePRrdu3eX6H0HAMuWLeMoMkIIqX4iIiKgr6+PX3/9FYaGhuDz+VyHpHDUy5kQUhL1iCaEECKTUChE165dwefz8ejRI67DqbCQkBDUq1dPapzo4OBg5OTkoG/fvhxFRgiRJykpCR4eHvD09MTbt28BFL01ra+vjzFjxmDlypUcR0gIIYQQUrmZmJiw/y7eQ41hGLXpfUcIIVXFDz/8gLp16+LEiRNch0IIISpDDdGEEFKNpaWl4c2bN8jPz4f4dJCdnY3Q0FAsX74cDx8+xPv37zFy5EiOI6244mnJi5s6dSpiYmIQGBjIUWSEkLIICgqCm5sbfHx8kJeXRw9OCSGEEELKYPXq1aWmSN22bZsKoyGEkOotJCQEc+fOxdy5c9G7d2/UrFlTYn6bNm04iowQQpSHGqIJIaSa8vHxwZIlSyAUCmXOV4cGnmPHjuHMmTMAgISEBGhra8PAwICdLxKJkJiYCD09Pblj9BBCKpeMjAxcunQJ7u7u8PDw4DocQgghhBBCCCGkTDp27AiRSARZTTI0ZjIhRF3RGNGEEFJNHThwAIWFhTA2NsarV69gZmaGhIQEfP78GZMmTeI6PIUYN24cDh06hLS0NPB4POTk5CAhIUHqc0OHDuUgOkLIt9DT04O9vT3s7e25DoUQQgghpNL72gu3VlZWKoqEEEJIYWGh3HnUX5AQoq6oRzQhhFRT5ubmEAgEcHV1Ra9evbB37160bdsWw4cPh5mZGf7++2+uQ1SI6OhofPz4EQ4ODujatSsWLlzIzuPxeDAwMIBAIOAwQkIIIYQQQghRDhMTk1JTc6tDJixCCCGEEFJ5UY9oQgipxsRj0XTs2BHh4eGwtLSEqakpHj16xHFkimNkZAQjIyOcPHkS9erVg7GxMdchEUIIIYQQQohKNGrUiG2IZhgG+fn5SEtLg7a2Njp27MhxdIQQUn3l5+dLTdPS0uIgEkIIUS5qiCaEkGqqTZs2ePToEXx8fNClSxecPXsWBQUFCAkJQa1atbgOT+G6deuG0NBQ/PPPP8jLy5NKebRgwQKOIiOEEEIIIYQQ5fDz85Oa9u7dO0yZMgVjxozhICJCCKm+Xrx4gTVr1uDly5dSz6VojGhCiLqi1NyEEFJN+fj4YPHixVi5ciX69++P77//nm2gHTZsGHbv3s11iAp14MABODk5SU1nGAY8Ho9S0hFCCCGEEEKqjTVr1uDRo0e4fv0616EQQki1MW7cODx9+lTu/BcvXqgwGkIIUQ3qEU0IIdWUnZ0dLly4AG1tbbRs2RJOTk44ffo0WrRogUWLFnEdnsJ5enqCYRgYGxvDyMgIGhp0CiSEEEIIIYSot9jYWIm/RSIREhMT4e/vj7S0NI6iIoSQ6ikqKgoNGzbEnj17YGhoCD6fz3VIhBCidPQUnhBCqjFTU1P237169UKvXr04jEa5kpOTYWJiAk9PT3aMNEIIIYQQQghRZ8OGDZM5nWEYWFhYqDgaQgip3oyMjKCtrQ1LS0uuQyGEEJWhhmhCCKlG1qxZU6bP8Xg8/P7770qORrX69u2L169fUyM0IYQQQgghpNqQNSJfrVq10KlTJ2zevJmDiAghpPpav349Zs6ciXXr1qFv376oVauWxHx17iBCCKm+aIxoQgipRkxMTNiG2NKqf3UcM/n69etYv349zM3N0b17d2hra0s0Sk+cOJHD6AghhBBCCCGEEEKIOvP29saqVatQWFgoNY/H4+H58+ccREUIIcpFDdGEEFKNiBuia9euDQsLC3Tr1g316tWT+dnRo0erODrlKt4IL4u6NbwTQgghhBBCCCGEkMqjf//+SExMhLa2NurWrSv1nMrX15ejyAghRHkoNTchhFQjXbp0wdOnT5GRkYG7d+/Cz88PRkZGsLa2hrW1NaysrKCvr891mEphZWXFdQiEEEIIIYQQonQDBgwo0+d4PB58fHyUHA0hhBCx1NRUGBsbw93dHVpaWlyHQwghKkE9ogkhpJrJyspCSEgIAgMDERAQgFevXgEoegjB4/HQrl07WFtbY/Xq1RxHSgghhBBCCCGkvExMTMr0OXUckokQQiqz5cuX4+XLl7h48SJq1KjBdTiEEKIS1BBNCCHVXEpKCi5cuIB//vkH6enpANTngURsbGyZP9umTRslRkIIIYQQQgghqhEYGCjx9759+xAeHo5jx45JfbZHjx6qCosQQqq906dPY+fOnWjZsiW6d++OWrVqScxftmwZR5ERQojyUEM0IYRUQxkZGQgKCoK/vz8CAgLw9u1bFD8dGBsb4/LlyxxGqBimpqZl+hyPx8Pz58+VHA0hhBBCCCGEqN78+fPh6+urFi8bE0JIVVY8Y0Xx8aEZhlGbTiGEEFISjRFNCCHVyN69exEQEIBnz55BJBKxjc9GRkbo1q0b+5+BgQHHkSpGWd+1oneyCCGEEEIIIYQQQogyjRo1SqIBmhBCqgPqEU0IIdWIiYkJeDwedHV1YWFhwTY8169fX+qzTZs25SBCQgghhBBCCCGKRD2iCSGEEEIIV6hHNCGEVENZWVnw8/ODn5+fzPmUqpoQQgghhBBCqqb79+9L/J2cnAwA8Pf3l8oG1atXL5XFRQghBIiKikJMTAzy8vLYaVlZWXj48CF2797NYWSEEKIc1COaEEKqEVtb2zJ/1tfXV4mREEIIIYQQQghRBnEmrK+hF5AJIUS1XF1dsXHjRrnzKXMFIUQdUY9oQgipRqhxmRBCCCGEEELUGw2zRAghldOJEyfA4/HQp08f3LlzB4MGDUJsbCxevXqF2bNncx0eIYQoBTVEE0IIIYQQQgghhBCiJugFZEIIqZwSEhJgYWEBZ2dn2NraYtKkSbCwsMDQoUPx+PFjrsMjhBCl4HMdACGEEEIIIYQQQgghhBBCiDrT1NREYWEhAKBjx4549OgRatasiZYtW+LZs2ccR0cIIcpBPaIJIYQQQgghhBBCCCGEEEKUSCAQIDw8HB4eHujatSucnZ2RmJiI4OBg6Ovrcx0eIYQoBfWIJoQQQgghhBBCCCGEEEIIUaJly5ahZs2ayM3NxbBhw8AwDC5cuACRSITBgwdzHR4hhCgFj2EYhusgCCGEEEIIIYQQQgghhBBC1Nnnz58hFAphaGiIyMhIuLu7o3nz5rC3t4empibX4RFCiMJRQzQhhBBCCCGEEEIIIYQQQgghhBCFotTchBBCCCGEEEIIIYQQQgghShAXF4dffvkFWVlZAABTU1OJ/8aPHw/qL0gIUVfUEE0IIYQQQgghhBBCCCGEEKJgCQkJsLe3x9WrV/Hy5UsAAMMwEv89ffoUPj4+HEdKCCHKQQ3RhBBCCCGEEEIIIYQQQgghCnb06FEkJyejbdu20NfXZ6dbWFjg5MmTGDlyJBiGwdWrVzmMkhBClEeD6wAIIYQQQgghhBBCCCGEEELUjb+/P2rXro1Tp06hXr167PR69eqhW7duMDExwa1btxAeHs5dkIQQokTUI5oQQgghhBBCCCGEEEIIIUTBkpKS0LlzZ4lG6Pbt26Nly5YAgDp16qBLly5ISUnhKkRCCFEq6hFNCCGEEEIIIYQQQgghhBCiYFpaWkhNTZWY5uHhIfH3ly9foKenp8KoCCFEdahHNCGEEEIIIYQQQgghhBBCiIJ99913iIqKwosXL2TOj4iIQFRUFNq1a6fiyAghRDWoIZoQQgghhBBCCCGEEEIIIUTBxo4di8LCQsyePRteXl5ISkpCfn4+3r17hzNnzmDevHkQiUQYN24c16ESQohS8BiGYbgOghBCCCGEEEIIIYQQQgghRN3MmzcPvr6+4PF4UvMYhsHQoUOxZ88eDiIjhBDlo4ZoQgghhBBCCCGEEEIIIYQQJRCJRDhy5AhOnz6NT58+sdObNGmCadOmYebMmTIbqQkhRB1QQzQhhBBCCCGEEEIIIYQQQogSiUQixMfH48uXLzAwMECLFi24DokQQpSOGqIJIYQQQgghhBBCCCGEEEIIIYQoFJ/rAAghhBBCCCGEEEIIIYQQQgghhKgXaogmhBBCCCGEEEIIIYQQQgghhBCiUNQQTQghhBBCCCGEEEIIIYQQQgghRKGoIZoQQggBIBQKuQ6BEEJINUTnn+qHtjlRFdrXCCGEEEIIIVyjhmhCCCEVMm3aNLRr165c/82bN4/rsFkikQhnz57Ftm3buA6l0lqyZAk6dOiA6OhorkMpMw8PD3Z/e/PmDdfhSBAfM6tXr/6m702ePFlJkRFViI2NxeLFi2FjY4OOHTuiV69e2Lx5M9dhqbW7d+9i2rRp6NatGzp16oT+/fvDy8uL67CQnJyM5cuX4+HDh1yHolDx8fFs/Xv+/Hmuw6lU1HWbV3fi/X3Pnj0K+01FXMc8f/4cEyZMUFhM5bF69Wq0a9cO06ZN+6bv9enTR0mREfJ1+/fvR7t27WBra6vQ3/3WusLW1hbt2rXDL7/8otB4ykIZ9Zu6Kn79ExQUxHU4REWmTJkCKysrJCYmch0KIYRUatQQTQghpFpbtWoVNm3ahMzMTK5DqZQuXryIa9euYeLEiTAyMuI6HEKqtOTkZEyaNAnXr1/H58+fUVBQgE+fPqFWrVpch6a2AgICMGfOHAQHByMtLQ35+fl4//496tWrx2lcKSkpGDp0KK5cuQKGYTiNhagGbXOiSvfu3cO4cePw9OlTrkMhhBBC1NaaNWuQkZGB1atX0/UdIYSUQoPrAAghhKiHpk2b4sqVK2X6rIZG5Tn9fPjwgesQKq20tDRs374durq6WLBgAdfhEFLl+fr6IjU1FQDwv//9D8OGDQOPx4OWlha3gakxDw8PMAwDXV1dODk5wdTUFPn5+Zw3RGdnZyMtLY3TGJRFU1MTLVu2BADUrl2b42gqD3Xe5tWdeH/nul4p7tOnT5SWmxBCCFGyTp06YdiwYbh69Sq8vLwwevRorkMihJBKqfK0BBBCCKnSeDwedHV1uQ6DKND+/fuRkpKCuXPnwsDAgOtwCKnyPn36BACoW7cupk+fznE01cPnz58BADY2NujZsyfH0VQPhoaGuHnzJtdhEKIytL8TQggh1deCBQtw7do17NixA4MHD4aOjg7XIRFCSKVDqbkJIYQQIiUpKQmurq7Q0NCAvb091+EQohbEvdPopR3VoXVOCCGEEEIIUZbvvvsOffr0QXJyMk6fPs11OIQQUilRj2hCCCGVxqNHj3DmzBmEhoYiOTkZ2traEAgEGD58OMaNGwdNTc1Sv+vh4YGHDx/i48ePyM3NhZ6eHoyMjGBnZ4eJEydKjMO6evVqeHp6sn97enqyf798+RIAMG3aNAQHB6Nr1644d+6czHL3798PJycnAMCzZ8/YtONBQUFsj8cnT57g0KFDcHV1RXp6Opo0aYL58+fj+++/Z3/n/fv3OH78OO7du4fExETweDy0aNEC/fv3x4wZM+Sme0xLS8OpU6fg6+uL2NhYFBYWon79+jAzM8Po0aPRr1+/r612mU6cOIH8/HzY2tqiUaNGUvPF62bu3LkYOnQoNm/ejKdPn0JbWxsdOnSAs7Mzm244JSUFLi4u8Pf3R2xsLNLT01GzZk0YGhqiR48emDZtGlq3bi1Vhq2tLRISErBlyxb88MMPOH78OLy9vfHmzRvweDwYGxtj1KhRGD9+fLnTvW/fvh3//vsvAMDe3h7r16+XmM8wDK5evYqLFy/i2bNnSE9PR926dWFmZoYJEyagb9++pf6+n58fTp8+jcjISKSnp6Nly5YYO3Yspk6dWq445SkoKMCJEyfg5eWFt2/fonbt2rCwsIC9vT26d+8u8VknJyfs378fAHDr1i00b95c5m8mJSWhX79+EIlE2Lt3L4YOHVqmWJKSkth99927dwCABg0awNLSEhMmTICFhYXUd8TbduTIkdi5c6fM3xUfo4aGhvDz82OnFz+2Xr58icjISBw5cgTBwcFIT09H48aNMWTIEMydOxc6OjoQCoU4e/YsPDw8EBsbixo1aqBTp06YO3eu1Loqq7y8PLi7u+PatWuIiopCVlYW6tWrB3Nzc4wdO1Zq/yhZ3yQkJKBdu3YAgG7duuHUqVNfLVNc14g/7+Pjg1OnTiEyMhIFBQVo06YNJk6ciIkTJwIoqhucnZ3h4+ODDx8+oE6dOujevTuWLFmCFi1ayCyjIvu9SCTC9evX8d9//+HJkydISUmBSCRC3bp10alTJ/zwww8YOHAgeDyezOUS17P379/H6dOn8fjxY2RkZKBRo0bo168fZs+eDUNDw6+uJzHxPiZWvI5fsGABFi5cyM4rKCjAhQsX4O3tzW7P+vXrw9LSEtOmTUOXLl3klpOfn4+LFy/i1q1beP78OVJTU8Hn82FgYIAuXbpg/Pjx6NGjh8R3xNteTLw/jx49Gtu3b0d8fDwGDBgAANiyZQvGjx9f6jKWPI7E+9vIkSOxdOlSbNy4ESEhIdDU1ETbtm2xf/9+NGzYkP383bt3ceHCBTx69AipqamoXbs2OnTogNGjR2P48OFS2+xrSotfHPO2bdswZMgQ/PPPP7h27RoSEhKgp6cHc3NzzJs3D+3btwdQdG4/cuQIHj16hMzMTLRo0QLff/89Zs2aJVXvi89Ljo6OWLJkCY4dOwYvLy8kJCSgXr16MDU1hYODA6ysrOTGLhQKcfXqVVy6dAnPnj1DRkYG9PX10aFDB3z//fdy14d4m/77779ITU3Fvn37EB8fDwMDAwwfPhzHjh2T+HzJbS7G9XEUHR0NFxcXBAQE4P379+DxeGjTpg2GDBmCadOmQVtbW+b3vuX6rfh+UnI9yJOZmYnu3bujoKAAixYtwvz586U+s3HjRvaa7cqVKzA2NpaYzzAMevbsiZSUFKxZswYzZsyQmPctdaB4+8+dOxdLly6Vmv/06VMcO3YMjx8/RlJSEho2bAhbW1vMmzcPgYGBWLZsGZo1awZfX1+5y/78+XMcOXIEISEhSE1NRYMGDdCjRw/89NNPMDIyYj9X/BxZMr5t27ZhzJgxEvMqcvw/evQIx48fx5MnT/D582c0adIEI0aMwKxZs+R+pzwYhsGFCxdw7tw5xMTEoFatWujYsSMmTpyIQYMGSXzWy8sLq1atAgCcOnUK3bp1k/mbeXl56NmzJzIzM7FixYoyxUrn3/KdfwHVXavduXMH58+fR0REBFJTU6GrqwuBQIBhw4Z99d7x1atXOHbsGEJDQ5GUlIQGDRrAzs4OP//8c5mWUdHnzrLKzs7GoUOH4O3tjQ8fPqBu3bro3r07Zs6cyZ47ZfnW+7GvefXqFVxdXRESEoLExERkZWWhdu3aaNWqFfr16wd7e3vo6+tLfKd4/X/jxg1oa2vj8OHDuHv3Lj58+ABdXV2YmZnB3t4effr0kVt2ZmYmvLy8cOXKFbx584bdb62traXqxuK+fPmCEydO4Pbt23j37h2EQiGaNGmC3r17w8HBAU2aNCm1TFdXV7ZMTU1NmJmZYfbs2WjcuHG5119x33JNqYj1kZKSgvPnz+O///5DfHw8cnJy0LRpU/Tu3Rs//fST1Pr42jkPkP8cpXi98/fff+O3336Dr68veDweWrdujW3btrG/r6r1kZOTg549eyI7OxtjxozBtm3b5P7munXr4ObmBiMjI1y9elVi3rhx43Dnzh2cOHECM2fOLLX+IYSQ6ogaogkhhHBOJBLhzz//ZBsGxfLz8xESEoKQkBC4ubnB2dlZ6kGIUCjExo0b4ebmJvW7KSkpCA4ORnBwMNzd3XHmzBno6ekpdVlk2bZtG86ePcv+HRcXJ/Eg6urVq1izZg3y8vIkvvfy5Uu8fPkSLi4uOHDgACwtLSXmv3v3DtOnT8f79+8lpicmJiIxMRHXr1/HyJEjsWPHjnI9DMnPz4eHhwcAYPDgwaV+Nj4+HtOnT2fHvczLy5MY8/bu3btYsmQJsrOzJb5XUFCAzMxMxMTE4Pz583BycpL7oCE9PR3jx4/HixcvJKaHh4cjPDwcPj4+OHz4MGrUqFGm5du/fz+7r02ePFmqETo9PR0LFixAUFCQxPRPnz7Bx8cHPj4++P7777F161apsX2FQiE2bdoEV1dXielRUVHYtm0bfH19pbZzeeXl5WHWrFl48OCBxLQbN27gxo0bmDFjBtasWcPO++GHH+Dk5ASGYeDt7Y3Zs2fL/N0rV65AJBJBT08Ptra2ZYrlyZMn+Omnn6TGPY2Pj0d8fDy8vLwwZ84cLFu27BuW9Ou8vb2xcuVKFBQUsNPevHmDQ4cOITg4GMeOHWMf9BcXGBiI4OBgHDhwAP379y9XmXFxcZg/fz6io6Mlpn/8+BH//fcf/vvvPwwbNgzbt29HzZo1v33hSvH777/jxIkTEtOePXuG9evX482bN5g8ebJU3fD582dcuXIF/v7+8PDwQNOmTSW+X5H9XpzCPyIiQirWpKQkJCUlwcfH56uNTfv27cOBAwckpsXHx+P06dO4dOkSTp06BRMTk9JXTjklJiZi9uzZiIqKkpj+4cMHXLlyBVeuXIGjoyOWL18uVY++e/cOs2bNQlxcnNTvJiQkICEhAVevXpVq+FaVtLQ0TJs2jW2Qz8nJQWpqKtsInZ+fj9WrV0s9SPvy5Qvu37+P+/fvw8PDA/v27VP4WM+fP3/GmDFjEBsby07Ly8vDzZs3cf/+fZw6dQrPnj3D5s2bJca5jYmJwZ49e/DixQvs3btX5m8XFhbC0dERAQEB7DTxedHX1xc///wzlixZIvW95ORkLFiwAGFhYVKx3r17F3fv3oWbmxv27duHunXryiz7xo0bEg9ck5KS5H62JK6Po1OnTmH79u0oLCyUmP7s2TM8e/YMnp6eOH78uMR1WEWu375F7dq1YWVlhYCAADx48EBmQ3Txc2NwcLBUQ7S4oQ6ARP1fkTqwNKdOncLWrVvBMAw7LSEhAadOncK1a9fYxsvSuLi44Pjx4xCJROy0xMREeHh44Nq1a3B2di73i1UVPf4PHjyIv/76S2JaXFwcnJyc8N9//8l96a2sRCIRVq5ciUuXLrHTcnNz2diGDh2KHTt2sA/6Bw0ahE2bNiE7OxtXrlyR2xB9+/ZtZGZmgs/nY+TIkeWOi86/5aeMa7WcnBwsX74ct27dkpiemprK3vudPXsWzs7OaNasmVRM7u7uWL9+vUR9l5CQgBMnTuD69eulHk9cnjvT0tIwceJEiWuWjx8/4tKlS7hy5QpWrVol8XKNmCLux2RxcnJi7zGKS01NRWpqKiIiInD+/HmcOXNGar8Xe/bsGTZt2oTU1FR2Wn5+Pu7cuYM7d+7Ifeno5cuXWLBgAd6+fSsxPSEhAR4eHrh8+TK2b9+OESNGSMx/8OABFi1aJHXvEhsbi9jYWLi5ueHPP/+UeQ8s77rv7t27uHfvHhwcHGQuY1lU9JryW9dHcHAwlixZguTkZInpcXFxiIuLg4eHB/7++29YW1t/87LJkp+fj1mzZuHJkyfstLdv36JVq1YAVLs+tLW1MXjwYHh6euLmzZvYtGmTzPN8QUEBbty4AQASHQrE+vbtC21tbXz+/Bk+Pj5lfqmbEEKqC0rNTQghhHP79u1jH2IOGjQIZ8+eRVBQEHx8fLBmzRro6enh+fPnmDNnjlQj3vHjx9lG6OHDh7Nvevv6+uLw4cMwNzcHUHQzUrxH0ubNmxEWFsb21hw5ciTCwsKkHkArwtmzZzFo0CBcv34dvr6+2LhxIxtXQEAAfvnlF+Tl5cHExAQHDhxAQEAA7t27hz179qB169ZITU3F7NmzpW7ENm7ciPfv36NBgwb4888/4ePjg8DAQLi6urI9Jy5fviz1oORrAgMD8eXLF/B4PPTu3bvUz165cgVCoRB79uxBQEAAjh8/jnnz5gEo6uW9ePFiZGdno3Xr1tizZw8bo7u7O6ZPnw4NDQ3k5eVhw4YNUg8xxPbv34+oqCjMnDkTV65cwYMHD3D8+HH2rf/79+/Dy8urTMt2/Phxtgf7xIkTsWHDBon5IpEI8+fPR1BQEDQ0NODo6IgrV64gKCgIFy9exLRp08Dj8XDp0iVs3bpV6vcPHjzINkIPHDgQFy5cwIMHD+Dq6op+/fohKChI5sPC8nj27BkePHiAfv364fz583jw4AFOnz7N7lPHjx/HmTNn2M+3aNECXbt2BVC0veQRzxs0aFCZGlAZhsHKlSuRlpaG1q1b48CBA7h9+zYCAgJw4sQJthfpoUOH8OjRo29d3FKtXr0ajRo1wl9//cXuB+KHz48ePcKYMWPw4MEDODg44Nq1awgMDMTu3buhr68PoVCIP/74o1zlffnyBT/99BOio6OhqamJuXPnwtvbG0FBQXBxcWEfWnl7e0u8DCCub+bMmQMAaNq0KVvfHDlypFwxRERE4MSJE+jWrRvOnDmDgIAAHD16lO2tcOLECTg4OCAjIwMbN26En58f7t69i4ULF4LP5+PLly9wdnaW+M2K7vdr1qxBREQEatSogQULFuDy5ct48OABrl27ht9//519+Ojp6Sn1oFksMjISBw4cgLm5OY4ePcp+f9q0aQCKHtRv2bKlzOvp6tWrcut48XbIzs6Gg4MDoqKioKOjg+XLl+O///5DUFAQ3Nzc2Id1R44ckdpOQqEQCxYsQFxcHHR0dLBmzRpcu3YNDx48wJUrV/Drr7+yDZAHDx7Emzdv2O+GhYVJ1MuHDx9GWFgYNm/eXOblKws/Pz98/PgRGzduhL+/P9zc3CT2y//9739sHBMmTICHhweCg4Ph7e2N+fPnQ1NTE/7+/li2bJnc+vlbOTk54c2bN5g7dy5u3LiB27dvY9myZeDxeGwDw+bNm9GpUyecOHECDx48gLu7O3t8X7t2DeHh4TJ/29XVFQEBAejevTtcXFzYOlJcJ/399984f/68xHfy8/Mxe/ZshIWFgcfjYfLkyfDy8kJQUBC8vLzYxsKgoCDMmzdPqrFW7Ny5czA2NmZ7F+7cuROjR48u0zbn8ji6cuUKtmzZgsLCQpiamuLvv/9GQEAAbty4gUWLFkFDQwOvX7+W6vlUkes3TU1NtGnTBm3atJHoof814uubR48eIScnR2JeUlKSxMsNwcHBUt8XZ9j47rvv2AfeFa0D5bl16xa2bNkChmHQoUMH/Pvvv3jw4AEuXbqE8ePH4/Pnzzh48OBXf+fYsWNo0qQJ/vzzT/j5+eHatWuYP38+atSogZycHKxdu5ZtpLa0tERYWBg2bdrEfl9c9xV/cF6R49/Dw4NthLayssKZM2fw4MEDeHl5YfTo0Xj16hVu375d5vUky6dPn3Dp0iV06dIFJ0+exIMHD3D+/Hm2QfLatWvYs2cP+3kdHR3Y2dkBAP777z+5x6j4Wqdbt27lfjmCzr/fRhnXasuWLWMboYcMGQJXV1cEBQWxL1xqaGggKioKDg4OyMzMlPhuUFAQfv31VxQWFkIgEODIkSMIDAyEt7c3HBwc8PHjR1y8eFHu8nB57vTz80NUVBTGjBmDS5cuITAwEIcPH0bbtm0hEomwbds23L17V+I7irofK+n69evYv38/GIaBjY0NTpw4AT8/P/j5+eHkyZNsVq7379/LfXEMAH799VeIRCKsW7cOvr6+uH//Pnbs2MFeQx04cEDiGgoo2id/+uknvH37Fjo6OlixYgVu3rwJf39/HDhwAK1atUJBQQFWr14t8eJoVFQU5syZg7S0NDRv3pytUwMCAnD48GF06tQJubm5WLZsGR4+fChRprjhNC4uDrVq1cLKlStx+/Zt+Pv7488//0SDBg3wzz//lGndlVSRa8qKrI93795h9uzZSE5ORv369bFp0ybcvn0bfn5++OOPP9CgQQNkZWVh0aJFUg3VFfX06VM8efIECxcuxL1793Dx4kX89ttvqFWrFifr44cffgAAZGRkSB1DYn5+fkhNTQWPx5P5IpOWlhbbYH/t2jVFrSpCCFEfDCGEEFIBU6dOZQQCAdOvXz8mMzPzq/8JhUKJ78fFxTEmJiaMQCBgfvvtN5llPHnyhDE1NWUEAgHz77//stOFQiFjY2PDCAQCZubMmYxIJJL6bnZ2NtOrVy9GIBAwY8eOlRv/qlWr5M6bNGmS3OXft28fIxAIGIFAwBQUFLDTHzx4wE63tbWVmCdWWFjI2NraMgKBgBk3bhyTm5sr9ZnU1FT2M3PnzmWnZ2RkMO3atWMEAgHj5eUl9b38/Hxm8ODBjEAgYObMmSM3flk2b97MCAQCZsCAAXI/I143AoGAcXNzk/mZP/74gxEIBEyHDh2Yt2/fyvzM1q1b2d959eqVxLz+/fuz806ePCn13c/FNYMkAAAxtUlEQVSfPzOdO3eWuYzu7u7sd+Pi4hiGYRhXV1d22tq1a2XuLxcuXGA/899//8mM+fjx4+xnnj59yk7/8OEDG8/ixYulfl8oFDILFixgvytrnytN8XW+cOFCqWMpNzeXGTt2LCMQCJhu3bpJ7E8uLi7sd6Ojo6V+OyYmhp0fGBhYpniioqLY74SEhEjNT09PZ6ysrGQe2+Jtu3z5crm/v2rVKkYgEDC9e/eWmF782OrSpQvz/v17ifkfPnxg2rdvz37m4MGDUr995swZdn7J75dm+/bt7Pdu3rwp8zPi40cgEDB37tyRmCeuL/r371/mMkt+VyAQMGPGjGHy8/Ml5nt7e7Pz5W2TxYsXyzy2K7Lfv3r1qtR1zTAMExkZyX7mjz/+kLtc48ePl1ouhmGYhQsXMgKBgGnXrh2TnJwsewXJUVod/9dff7F1VHh4uMzvi+uojh07Mh8/fmSn37lzh4374sWLMr978+ZN9jOnT5+WmPfu3Tt23oMHD+TOk1e/Moz840h87AgEAmbPnj0yvxsYGMh+5tixY1+N/8aNG3LjKKm0+IvX68XP52KOjo7s/BEjRkidF1NTU5lOnToxAoGAcXJykphXvI6cOXOm1Hk3JyeHGTNmDCMQCJgePXow2dnZ7LxTp06x3z1+/LjM5Tp69Kjc7SmebmJiwsTGxn51vZTc5lweR7m5uUyPHj0YgUDAjB49WmK9iP3777/s7wcFBTEMU7Hrt4qIjY1lY/Hz85OY5+npyZ4Dxdu5pAkTJkitw4rUgQzzf9t/9+7d7LSCggLGzs6OEQgEzKhRo2Su1127drHfLXleKH4dY2Njw3z+/Fnq+9u2bWM/8+zZM7nfL6kix39OTg7Ts2dPRiAouj7Oy8uT+m7xa7upU6fK/H15itdfEydOlKoDhEIh8/PPPzMCgYBp37498+HDB3bevXv35J5/GabouqRjx46MQCBgLly4UOaY6Pxb/vOvMq/VfH192elbt26VWf61a9fkLvfIkSMZgUDADBw4kElPT5f6bvH1XfK4rOi5U1ZdURbFz52///671PwvX76wnxk2bJjEvIrej8mLWXzPMXz4cJn1gFAoZEaPHs0IBAKme/fuEvOKnw/bt28vVX8xjOR2Pnr0qMS83377jf3uw4cPpb4bHx/PWFhYMAKBgFm9ejU73d7enhEIiu7NU1JSpL6Xl5fHjB8/nhEIBMzIkSMl5hU/D96+fVvqu+/evWMsLS3lnudLU9Frym9dH3PnzmUEAgHTtWtX9n65uOLn8P3797PTy7Ify3uOUrze+eWXXyrN+hAKhUyfPn0YgaDoPl6WJUuWMAKBgLG3t5e73AcOHGAEAgFjbm7OFBYWyv0cIYRUR9QjmhBCiEK8f/8eXbt2/ep/4vGXxVxdXSESiaCtrS13jKGOHTti+PDh7OfFsrKyMHbsWIwYMQJz5syRmX5aW1sbnTt3BlDUm5ELAwYMkDmG8f379xEfHw8AWL58ucxeqPr6+pg7dy6AonSCHz9+BFCUGor5/2+sy3pDWVNTE3/++SfOnDlT7l524h678saRKo7H48lN3y0QCDBx4kQ4OjrKHROveOpEedtHX18fkyZNkppev359dOrUCQDY9SjP1atX2d7P48ePx+bNm2XuL+KUqlZWVlLjD4pNnTqVTfNXPCW8j48PcnNzwePxsGLFCqnf5/P5WLt2bZlTiMujoaGBdevWgc+XvIyrWbMmfvnlFwBFKfGK90YaOnQom2JMVq/oy5cvAwAaN24sN51lScV7t8naB/X09HDgwAG4uLiwveQVbeTIkVLjlhkaGrL7m6amJn788Uep74l7jwNFPejKQiQSwd3dHQBgZ2fH9rwqadWqVTAwMAAAuWPLV5SDg4PUuGPFU/ebm5tLpfIHwPYILbnMFdnvhUIhHBwcMHjwYEyePFnmd01MTFCnTh0ApdfDspYL+L8ekAzDSIz7XBEMw7Dnk+HDh8PMzEzm5xYtWoRatWohPz9fYpxvXV1dTJ8+HcOHD8ewYcNkfrd4GkOuzj9DhgyROV28zZs1aybzGAGK9nNxj/KSww1UlI6ODuzt7aWmF99vp02bJnVe1NfXR5s2bQDIP3b5fD42bdokdd4V92ACiuqs4qm7xfu0qamp3PXh4ODAjlvo4uIi8zPt2rX7pjE2uTyOAgMD2Tp8xYoVMseBnjx5MgQCAXr16sWmdq3I9VtFtG7dml3HxbeheFkAYMqUKQCKtnNMTAw7/8uXL3j8+DEASAxBUZE6UJ6HDx+yKUHlrdeFCxeWqTf4jz/+iPr160tNHzhwIPvvkulHS1OR4//Bgwf4/PkzgKJrV1npS5ctWyY1Juy3WLt2rVQdwOfzsWbNGvB4PBQWFkpc0/Ts2RONGjUCAJnZgP777z/k5+ejVq1aXx16Rh46/5afoq/VxOugfv367HVvSUOGDGGPcTc3N3aIh1evXrH3ovPmzZM5ZNP06dPRtm1bmb/L9bmzXr16WL58udT0unXrsumro6OjJdIdK+p+rDiRSIR+/fph1KhRmDdvnsx6gM/ns8dCab/Zq1cvmWNb29jYsOfx4vd5DMOwvU2HDx/OZn0qrlmzZhg/fjzMzMzYuig6OhohISEAirZ9vXr1pL6npaXFns9evnwpkcVKfK/UvXt3trd3cc2bN4ejo6Pc5SxNRa4pv3V9ZGRk4N69ewCK9nlxhpDiOnbsiCFDhsDCwkIpww3Jq4e5WB/Fh2u4ffs2srKyJL6TlZXF3lvLSsstJhAI2M+XHMaJEEKqOxojmhBCCKfEaRO/++47AJC66Bfr3LkzLl26hNevX+PLly+oV68e9PT05D78BIrGiYyMjGQfsMpL06dspqamMqcXHwtOIBDIXfaOHTsCKLqxevToEQYPHox69erByMgI0dHR2LlzJ6KiojBo0CB0794dOjo6AMA2wJfX69evAYB92F+apk2bsg+4Sho1ahRGjRol97uJiYl4/vw5+7e87WNqairz4RgAtsGvZHrO4m7fvo0dO3ZAJBLB3Nwcv/32m8xG6MzMTDae9u3by90eANCpUyckJCRIpHIXj0tpZGQkczw6oOjBW6dOneSmlC0Lc3NzuQ+uu3XrBh0dHWRnZyM0NJRthKpTpw769++P//77D97e3li8eLHE98QPckeOHCnVwC2PsbEx6tati9TUVKxYsQJBQUGws7ODpaUl+0DKysrqWxezTOTt4/Xr10dsbCzatGnDHg/FFR+zr6xjdr98+ZIdT07ew2Kg6CGWra0tLly4gJCQEDAMU64x2stC1nIXb6To0KGDzO+Jlzs/P5+dVtH9vl27dli1apXc72RlZSE8PJzdr0qrh+U1BhdfttzcXLnfL4+YmBi2McXU1FTucvN4PLRr1w4RERESy21paSmzsUEsLS0NoaGh7N9cnH80NDSkxscVEz+Mbd++fan1p5mZGR4+fIhHjx4pdF9u3769zHpdXKeLPyOLrP24uM6dO5f6sL127drIzMxEYGAgBgwYgNTUVHa8zdKObaCocePly5eIiopir0WKk3e+/xoujyNx462Ojo7cMSBr1qzJPoQXq8j1W0X17dsXcXFxEuNBA/+3LIMHD4a3tzfi4uIQHBzMNir5+/tDJBKhbt26bCNXRetAee7fvw+gaL3KG29WU1MTtra2X22sKt4gV1zxa4HS4i6pIse/eJ3r6OiwjW0l1apVC7169Sr30DDFNW3alL3+LalFixZo06YNXr9+jdDQUPz0008AihoSRowYgWPHjsHHxwd5eXkSjSfifdjW1vabx+6l82/5KfpaTbz/9u/fv9Tx2ocMGQJfX19kZGTgxYsX6NChg0SdIW8sZB6PhwEDBki8xFKybK7OnX379pW7zMUbRx8+fMi+rKuo+7Hi+Hw+FixYIHe+SCRCdHQ024DMMAyEQqHMl3Hl7R9aWlrQ09PDly9fJNb1y5cv2es3WQ3CYiWPjbLed7dr1w41atSAUCjEw4cPYWZmhoyMDDx79gyA/P0GKHoJYdeuXXLny1ORa8pvXR/BwcHsuO0lx2Avbvfu3aXGXhHyrpm4WB9AUXruI0eOIDc3F76+vhLpt2/evImcnBxoaWnJfckTkHx+EhMTw77ASAghhBqiCSGEKEizZs3g6+tb7u+9e/cOQNG4t7LeWJXlw4cPUg8yP378CH9/f7x+/Rpv3rzBmzdv8Pr1a4kHPoyCx+kqK/EYRiWJlx0AevToUabfSkxMZP+9ceNGzJo1C7m5ufD09ISnpyc0NTXRtWtX9O3bF4MGDZL7MF6ejIwM9sZcXtzFleUzBQUFCAgIwIsXLxAXF4d3794hOjpa6u14eduntIfW4ocxpW3b7du3s/OfPn2Kly9fwsTEROpzCQkJbI+JEydO4MSJE6UvGCS3h/jfX1vn3333XYUaosUP/WXh8/lo3rw5oqKi8P79e4l5P/zwA/777z/ExcXh6dOn7APeiIgItidVaW94l1SzZk2sX78eK1asQF5eHs6cOYMzZ85AR0cHVlZW6Nu3LwYOHMj2TlIGefuG+KGrrq6uzPnf8kCw+LaW11Om5PzMzExkZGTIfVnjW8la7uIvEMh7wC7rJYOK7vfFRUVFISQkBLGxsXj37h3i4uLw9u1bduxSoPRjVd72LP7QtfhvVUTx3oPbtm3Dtm3bvvodecsdERGB8PBwdnljY2Px/v17iWXl4vxTu3ZtmQ99MzMz2Re0bt68iZs3b371txS9L3/t2AXKtx8XJ+6NIguPx0PLli3x/PlzfPjwAUBRTzvx9inrsQ3IvhYpyznxa1R9HIl7GrZo0aLMLyIBirt++xb9+/fHiRMnEBkZiZSUFBgYGOD169dISkpC3bp10a5dO1hYWCAuLg4hISFsb1Hx+NC9e/dmjw1F1oHFiXuPfm29lnZOF5O3XxX/3bLWjRU9/otf65R2Li3LcpXma99v1aoVXr9+LXWtM2rUKBw7dgxZWVm4c+cO2+Pu48eP7MsT5bnWKYnOv+WnyGs18b4IlK++TkxMRIcOHdj1V7t2bYkXn0qStf9VhnNnacdF/fr1oauri6ysLJm91yt6PyZPWloa7t27h+joaLx9+5a9Bxdnz/ja75b3Pq947/jyZCApft89bty4Mn1HvL8Uv05o2bKl3M+3bt2abcT+VuW9pvzW9VH8e7J6Q6tCWa6ZVLU+gKKXrNu3b4/nz5/j6tWrEg3R4pe2+/fvX+rxXHyZypp1ixBCqgtqiCaEEMKpzMzMCn0nPT0df/zxBy5evMi+1Sumq6uLHj164NOnTxJvequavFRWFV12KysrXLp0Cc7Ozrh58yYyMjJQUFCAoKAgBAUF4c8//0T//v3x22+/lSn1IwCJhwZl6S3ytTRd58+fx4EDB6QenPH5fJiamqJ169Zs+ix5ZKU1Lw+GYWBra4uQkBBkZGTgf//7H9zc3KQaaCq6PcQPxmSl3yzuW3vhiH3t98W9Skr2XOnTpw/q1auHL1++4OrVq2xDtLiHkImJSakNOLIMHz4crVu3xuHDh3Hnzh3k5uYiOzsbd+/exd27d7F161Z8//33WLdundwHjRXxtXWhyJ7Ixbe1rJ47xRWPKzs7W+EN0bVq1VLYb1V0vweKHoBv27ZNKk0uUNRjz8bGBrdv32Z7lMtT0WO9PBSx3KGhodi+fbtECkyx5s2bo1evXnJTOKuCvPq5PD0ni8vMzFTYvlyWffhbj9+v1bHissV19rce27LWY2m9876Gq+NI/Htfq09LUsQx9K0sLS3ZBpegoCAMHTqU7Q1taWkJHo8Ha2truLu7s42PDMOwvZSLp+VW1nKkpqYC+Pp6Lcu5UV5WmG9R0eO/sl/rtGvXDiYmJnjx4gWuXr3KNkR7e3tDJBKhXr166NWr1zfHReff8lPktVrx/fdb6uuy7r+yUnZXhnNnWY6LrKwsqeNCEfdjJeXn52PPnj1wcXGRanSuWbMmrK2tIRKJ2F7k8pS3fiu+L5fneKzI8Zaenl6mMvl8PnR0dNj9rDy+9ZryW9dH8e+V9/yvKKU9R1D1+hD74Ycf8Pz5c9y/fx9paWnQ19dHSkoKe43xtReZitcd31pnEEKIuqKGaEIIIZyqVasWMjMzMXz48HKnfiosLMRPP/3EjvdnaWmJnj17QiAQoG3btmjdujX4fD5++eUXpTVEVyRNrPjmqGHDhuzD0fJq1aoVtm3bhs2bNyMsLAwBAQHw9/fH06dPwTAMbt++DUdHR3h4eJSrpxNQ8Z6Hp06dwpYtWwAUpaQeNGgQTE1NYWRkBGNjY+jo6CAgIKDcDz7Ka/Dgwdi9ezdcXV2xefNmPH36FCdPnsTMmTMlPlf8JnzTpk0yx6UujXiMqZIPY0qSl062rL62z4lveks+RNPU1MTw4cNx+vRpXLt2DStXrgTDMLh+/TqAb+8h1KFDB/z111/Izc1FUFAQAgMD4e/vj6ioKAiFQnh6eiItLQ1///13uX5XUSmYFaX4A8+vbePiD7u4erhTVhXd79+/f4+pU6ciLS2NTTNrbm4OY2NjGBsbw9DQEEDRixBfexCuSsWX+59//kHv3r3L9f0nT55gxowZKCgogI6ODuzs7GBmZgYjIyMIBAIYGBigsLBQqQ3R33qMFH8wN3v2bJnjTVZlX6tjxcevuBdW8YbA8hzbX2sEKQ8ujyPx/lBamll53/vW67eK0tTUhI2NDW7cuIHAwEAMHTqUTbkrTi8uTof96dMntndecnIyNDQ0JI73itaB8ojX69f2qa/NV7SKHv+V/VoHKGpIePHiBe7cuYOsrCzo6uqyvdmGDRum0Ib9iqiu59+KKM+1mKxG64rsv5Xh3Pktx4Wy7seWL1+OGzduAChKsdyvXz8IBAIYGRnhu+++g4aGBvbs2fPVhujyKn7clOc6qPj2e/z4cbnGPC4+5v3XzpXfUvdV5JryW9dH8e+JU04rUkXu47hYH2IjRozAjh07UFBQgBs3bmD8+PG4du0aCgsLUbdu3VJTswOSz08UPTQTIYRUddQQTQghhFNNmzZFVFQUO4aUPLLG17p+/TrbCL1ixQrMmjVL5ndLphwrq7KMqSbu8fItmjZtCgBISUlBdnZ2hR5qa2pqwtraGtbW1li6dCkSExOxdu1a3L9/H5GRkQgNDUW3bt2++jvFH8h/63oDim78/vrrLwBF49qdOnVKZoNcRcooq+XLl0NDQwOTJ0+Gl5cXHj9+jL/++gt2dnYSabQbN27M/vtb9scmTZogIiICsbGxpX73a7/9NbLS7YkVFhayKYdlpY774YcfcPr0aSQmJuLZs2fIz8/Hp0+f2HEVK6JWrVro27cv+vbtC6BoXKwVK1bg2bNn8PX1RUJCAjt2trKPLWUoPu53TEyM3LErgf8bZ11XV1fi4VVlVNH93tnZGWlpaahRowZOnz6NLl26yPxeZXsI3qRJE/bf37Lce/fuRUFBAfT09ODu7i4zreG31m/FszWUzPQhJhQKJXrolEedOnXY3qTfsuyVXfG06yWJRCJ2vviYbtKkCXg8HhiGkTkmaHHiYxv4v3O4InB5HImXIz4+vtTtfe7cOWRkZKBjx47o2bNnha7fFKFv3764ceMGAgICwDAM29ghvtYxNDRE69at2XGixSl1LS0tJRppKloHyiOuE969eweRSCT3ZcDS9ldlqOjxL6473759K3fMV0C51zrA/x2Lsq51RowYgZ07dyIvLw/3799Hly5d2F51FUnLrWjV9fxbEbVr10adOnWQnp7+1fq6+HxxPSfef7OyspCUlMQ21pdUPI2zWGU4d5Z2XHz48IFtYBcfF8q6H3v06BHbCG1vb4/169fL/Jwy7vOKX7+9ffsW7du3l/m558+f47///kOLFi0wfPhwiXN2fHx8qandS24/Q0ND8Pl8iEQiieuAkj5+/CgxnnlZVeSa8lvXR8nviccULykgIAChoaFo2bIlfvjhB/B4PHZdKOs+jov1IT4uGjRogJ49e8LPzw+3bt3C+PHjcevWLQBFL7d/rcE+JSWF/bcysoERQkhVVr6uUYQQQoiCWVhYACgaY1A8XqMs69evh7W1NcaOHcv2SHr06BE7f8qUKTK/l5OTw47HW94evuIbktJuoisy1q942YVCIe7cuSP3c5cvX4a5uTmGDx+O0NBQAMCdO3cwfvx4WFtby0z/1aRJE4k39cs6RpH4AQ9QsRvI6OhoNq7Ro0fL7RUqTnMFKG7sV3n4fD42b96MGjVqICcnBxs2bJCYb2BgwD6U8PX1lTuWmUgkwvDhw9G7d2+sWLGCnS7uYRUXF4dXr17J/G5mZibCwsIqtByPHj2S+za+n58f+wDE0tJSan7nzp3Rpk0bAMDt27dx9+5dAEU9yOQ9jJPnwoULGDVqFGxtbWWuq7Zt2+Lnn39m/y6+D37t2CosLJSZio1LAoGAPTb+++8/uZ/Lz8/H7du3AQDm5uYqia0iKrrfi+thU1NTmQ/BASAsLIztlcDFWMmymJiYsA+IxA+YZMnKyoKNjQ369++PnTt3stPFx3HPnj3ljq1XvH4rudylPaAuXl/KO0aePXsmt5H6a3g8Hnv+CQgIKLV3z6xZs9CzZ0/MmDGj0my7rwkNDZXb2y0gIICdJ35pRl9fH8bGxgDAPliXR3zst2nTptzjQZe2zbk8jsTjO2dlZeHhw4cyP8MwDJycnLBr1y5cvXoVQMWu3xShb9++4PF4ePfuHe7evYsvX76w40OLiXtHBwcH4969ewCKxncsrqJ1oDziBvGcnBy5PQIZhmHPw4omb3+r6PEvvtbJzc2Vm81HJBJ9c6YfsdjYWLnjIb98+ZJtwJd1rdOoUSP06NEDgOS1TqtWreQeX1yoruffiii+/96+fbvU3qfi+lpHR4cdeqZ4b0YfHx+53xWPJy+vbK7OnYGBgXJ/r/iY1VZWVgCUdz9W/B588uTJMj8jEokQFBRUrt8tCxMTE/blbXG9LsvVq1fh7OyM3377DRoaGhJ1RWnXfWFhYTAzM8PgwYPZXuK1a9dmz5Xl3W/KoiLXlN+6PszNzdnzRGnfc3Nzw4EDB3DgwAH281+7j0tOTpb5MkdZcbE+ihs1ahRbRnJyMnsOL8uLTMXXiSJfWCSEEHVADdGEEEI4NWHCBABFDU+bNm2CUCiU+kxERAQ8PT2RmpqKunXrsuPOFe9dEh0dLfU9kUiEzZs3sw8+ZT20F994yJpXvDeLrNTeV65ckVluWQ0YMAANGjQAAOzcuVPiDVqxlJQU7Nu3D9nZ2fj8+TNMTU0BAPXr18fjx4+RmpqKs2fPyvz9yMhIqWUpi++++w5AUcq/b1W8h4y8deTv7w8PDw/2729tVCkPU1NTTJ8+XWb5wP/tjzExMTh69KjM3zh58iRiYmLw8eNHGBkZsdMHDhzINlT+9ttvMpdnz549FU7DmZmZyfZuKC4jIwM7duwAUNTTT94YiD/88AOAooee4hcgxNPKo3bt2oiMjERCQgLbMFGSeB/k8XgSvc/F+2NYWBg+fvwo9b2jR48qtMFCEWrUqIGxY8cCKHqAJe9B1I4dO9iHEOPHj1dZfBVRkf1eXA8nJCTITIGXlpaGzZs3s3+r4jgvCw0NDYwZMwZA0YMqeSkp9+7di+TkZLx//x4mJibsdHEdFxsbK/PhamJiokTDdcnlLv7Qq+S8unXrso2cPj4+Ur8vFArh5OT0tUUslXibp6amsvVGSTdv3sT9+/eRnJyMli1bVpme0dnZ2di7d6/M6eJlbdWqFdugAPzf+oiMjMSJEydk/u7x48cRFRUF4NuO7dK2OZfH0YABA9j9bdeuXTIbds6dO4fPnz8DAIYPHw6gYtdvitCwYUN06NABALBv3z4ARY2/xfdTcUO0v78/m0GnZEN08WX5ljpQnj59+rA9s3bv3i1zvR4/frxCD+tLU/w6rGTZFTn+u3Xrxp7P//zzT5nn6uP/r717j4qq2uMA/iWYYRxQXo4RYJJKDzF0LO0xuXwMppWaViaVPNJAkEdjUGSSiqA2oRCKKOLCFyKiMiEIsRQWWcvKMNRKJ5LE7iVEcRhbrZvpbXH/mDXnMs6gwGBj9v38BTPnwD7vvc/ev9/euvWmEc03097ejlWrVpl9fvXqVSHNsFQqxbRp0yyub6zX1NTUoLq6GsDtFQ1t9E98/lrLuM8uXbpk8pzt6NChQ8KgwJkzZwrp2AcOHCgMEsnOzrY4ULeyslIY+NvZ/7bVs/PcuXPIz883+/z8+fPIzs4GYBicYRzgcKvaYzdrgwNAVlYWGhsbu/V3u8LBwUG4lktKSiy20VtaWrB3714AhvaZSCRCQECAUI/Lzc01KZvRlStXoFar8ccff6CpqQkBAQHCd8Y2wLfffos9e/aYravX64Vj0F3W1Cl7uj8GDBggtBW3bdtmceCPVqsV2jvPPvus8LmxHXf48GGLAzIyMzOtGoBhi/3RkVKphLOzM65cuYLVq1fj6tWr8PHxMak3dqbj+xPjOxUiIjJgRzQREdnUsGHDhJHU1dXVCAkJweeffw6dToeff/4Z+fn5CA8Px7Vr1+Do6GgSCdCxoy0+Ph5VVVW4cOECmpubcfDgQcyZM8ekYW2pA9D48rW2thZnzpwx6QwODAwUfo6JiUFVVRUuXbqEhoYGpKenIzEx0aq0u46Ojli8eDEAw0ukl156CR9//DFaWlrQ0tKCgwcPIjg4WIj6iI+PFyL4Hn74YeFFSmZmJtRqNU6fPg2dToezZ89i69atWLFiBQBDFGzHhvTNGKM46+rqetyIvP/++yGTyQAAhYWFyM7Oxrlz56DT6XDy5EmkpqYiIiLC5MX1XzVPYlxcnPByWK1WC+k6AUNkvTGFV1paGt577z1899130Ov1+OGHH/DBBx/ggw8+AAD4+voiODhYWNfFxQXvvPMOAOCrr75CWFgYvv76a+j1emi1WrzzzjvIz8/vNI1lV9nb22PLli1YvHgx6uvr0dbWhsOHD+PVV1/FTz/9BDs7OyxbtqzT/zN9+nTY2dnh1KlT0Gq1kEgkmDRpUrfLoVQq4evrCwBISkpCdnY2fvzxR7S1teHMmTNYt24dcnJyAABTpkwRzgfg/9fW1atXER4eji+++AI6nQ6nT5/GkiVLkJ6eflumtI6KihLS+apUKmRkZKChoQGXL1/GiRMnoFKpsH37dgCG9G1TpkyxZXG7zJrzXqFQADBEAERFRaGurg46nQ6NjY0oKCjAzJkzodVqheU7ztloa9HR0cK9ID4+Hmq1WrimvvvuOyQmJgrH85FHHjF5CWfc7vr6eiQkJOD06dNoa2tDQ0MDNm/ejBkzZpi84L5+uzue3xUVFWhtbTVJnzpx4kQAhtSBKpUKWq0WOp0OX3zxBV5//XV8+umnVl0jgYGBGD9+PABg586dWLBgAWpra9HW1oaffvoJ2dnZQlYNNzc3REdH9/h/2cK2bduwaNEi4XgeOXIEc+bMEc7F6++Rs2fPFtLtr1q1CsnJydBqtbh8+TK0Wi2Sk5OFa0AulyM0NLTbZbrRMbfldSSRSIRn1zfffIOQkBDhntzQ0IC1a9cKHYJjx47Fk08+CcC6+htgeBE8ZcoUTJkyBWvWrOlR2Y3n8Pfffw/g/x3PRsbf9Xo9/vzzTwwePNjiwDxr7oGdsbe3x6JFiwAYsucY96vxPrFq1Sqo1eoebXdXdIzYNw4GMJ431lz/9vb2QufmmTNn8MorrwgR6cbt+vDDD3ulrlNZWYmoqCicPHkSbW1tqK2txeuvv46jR48CABITEy3OEQ0YOhekUina2tqEQXeddVrb0j/1+WuNiRMnCs/Ibdu2QaVS4cSJE7h8+TIaGhqQkZEBlUoFwNDx/NZbb5msv3TpUohEIrS2tiIoKAjl5eXQ6XT417/+JZz7nZ2/tn522tvbY+XKlVi9ejUaGxuh0+lQUVGBV155BTqdDmKxGO+//76w/K1qjykUCqGDPSUlBfv378f58+fR0tKCzz77DJGRkVi/fr3JOr3ZzouJiYGHhweuXbuGsLAw7Ny5E83NzWhpaUFlZSVCQkKg1+shlUoRFxcnrLd06VI4ODjg119/xezZs5Gfn49///vfuHTpEj7//HOEhYUJ2c7mzZtnMi3PzJkzhajqpUuXYs2aNcK+PHToEIKCgtDc3NyjgQfW1il7uj8SExMhkUig1+sRFBSEkpISXLx4EU1NTdi3bx/eeOMNXLt2DTKZDHPnzhXWUyqVAICLFy8iIiICJ06cgE6nQ11dHeLi4rB7926r6qi22h9GEokETz/9NADD8xMwPD+6cmyN0dyurq43TP9ORPRPxDmiiYjI5hYvXoxr165h7969qK2txbx588yWcXJyQnp6uklE2rhx4/Dcc8/hwIED+Pnnn7FgwQKz9QYMGAClUoldu3bh6tWraG5uNpk76LHHHkN5eTnOnz8vRPlUVVXBx8cHo0ePxqxZs7Bnzx40NTWZ/X1fX1+oVCrhZUdPPPvss/j111+RmpqKpqYmJCYmmi1jZ2eH6OhoYRS+UVpaGkJDQ9HY2Ii8vDzk5eWZrevr6ytECnWVQqHAli1boNfr0dDQ0KXIn+vZ29sjJSUFMTEx+O9//4vMzEyzKN677roLERER2L59O65cuWJxZPqtIJVKkZSUhOjoaOj1eqSkpAjRc2KxGJs2bcKCBQtw8uRJ7Nu3D/v27TP7G76+vsjNzTWb13vWrFnQ6XTIyMhAbW0t5syZY/K9v78/hg4dipKSkh6Xf/r06fjhhx+wd+9eYTS3kYODA5YtW2aSevB63t7eGD16tPAi1zjqu7tEIhHWrl2LuXPnorW11eIxBoARI0YgJSXF5LNp06ahrKwMn332GbRaLcLCwky+l8vleP7557Fs2bJul+tWcnFxQV5eHiIjI3H27Fls3LgRGzduNFtu+vTpSE5OtkEJe8aa837+/PmoqalBQ0MDjhw5giNHjpitN3LkSLi6uqKmpgbnzp27pdvSHW5ubsjLy0NUVNQN76MBAQHIysoyiQB6++23cezYMVy8eBEHDhywmBVg/Pjx0Ov1OH78uNl2SyQSjBw5EsePHxeu5TFjxmDHjh0AgDfffBNfffUVmpqaUFlZaZYOPjg4GL///rvZPaCr7OzssGbNGsTHx6OmpgZVVVUWU1X2798fGzZs6Hbqflu6//77cdddd6G4uNgs64VYLMaKFSuEztSOn+fk5CA6OhrHjx9HQUGBxWwjCoUCq1evNkvj2BU3Oua2vo5efPFFtLa2IiMjA3V1dWb3ZMBwX05PTzf5rKf1N8AQwXT27FkAhpfZPTFu3DiT7ADGAXpG/fv3x5AhQ4S5Yi1FQwPWP/s7M3nyZKhUKmRmZlrcr97e3hgyZAgOHz7co3PqRoYPHw6pVIr//Oc/WLJkCZYsWYKYmBjExsZaff0/+eSTUKvVSEpKQn19PSIiIsy2KzAwsNPsAl1hvEarq6uFiOaOYmJiEBQU1On6ffr0weTJk6HRaNDe3o6RI0d2KzvQX+Wf+vy11urVq5GQkIDq6mpUVFRYzGri7++PzMxMszru0KFDkZOTg9jYWPzyyy9YuHChyfeurq6YM2eOxcwjtn52hoSEoLKyErm5ucjNzTX5TiqV4qOPPjLL3nIr2mN+fn4IDw/Hpk2bcOnSJYvTFfTt2xezZs0S6lXnzp0zGZRqDZlMhs2bN2P+/Pm4cOECli9fbhL9b/z/mZmZJvPIjxo1CmvXrkVCQoLQBry+jQIY2nPXd1Da2dkhKytLGPSxadMmbNq0yWSZhIQErF279oYp4y2xtk7Z0/3h5+eH7OxsxMXF4fz588KgtI4GDBiA3Nxck47lsLAwVFVV4dSpUzh69KjZO4pJkybhgQce6HH2Hlvtj45mzJiB4uJiYVB+VzNqGDuiOw7WICIiA0ZEExGRzYlEIqxYsQL5+fmYOnUqvL29IRaLIZFI4Ofnh7lz56K8vFwYgd7RmjVrsHz5csjlcjg5OcHBwQGurq6Qy+V46623UFZWhsjISKED4fr5H19++WXExsbCy8sLIpEIMpnMZK7D1NRUZGRk4IknnkC/fv0gkUgwdOhQxMbGQqPR9EqDOigoCBUVFQgODsbQoUMhlUohEong7e2N559/HkVFRYiNjTVbz9PTExqNBgkJCZDL5ejXrx8cHBzg5uaGRx99FIsWLcL+/ftNOt674oknnoCHhwcAmMzt1V0TJkzA7t278cwzz0Amk8HBwQFSqRSDBw/GSy+9hL179yI+Pl5Ic9VxbrNbLTAwUBjNXVFRYfKSUyaTobCwEGq1GmPHjoWHhwccHBzg7OwMuVyOd999FyUlJZ02XOfPn4+ioiI888wz8PLyglgsxqBBgxAVFYWCggJIJBKryi6VSlFQUIDIyEgMHDhQOG+nTZsGjUbTpZSxHRvT1qSqfOCBB1BWVoYFCxbA399fuAY9PDygUCiQmpqKXbt2mUUs2dvbIycnB8nJycK1K5VK4e/vj0WLFiE/P7/LL/r/ar6+vti/fz/ef/99jB49Gq6urhCLxRg4cCCee+45bN26FWlpabdt+TvT0/PexcUFRUVFiIyMxJAhQyAWi4Vz8qmnnoJarcbOnTsxdepUAIapDjpOG2BrgwcPFo7nmDFj4OrqKjxHHnvsMaSmpqKwsBDu7u4m6/n4+ECj0SA4OBj33nsvRCIRxGIx7rnnHiiVSqxfvx45OTlCx9c333xjkn0BMKTqnzhxIvr27QtHR0eTaCFPT098/PHHwn51dHSEq6srFAoFsrOzkZSUZPW2Ozs7IycnB+vXr8ekSZMwYMAAiEQi4VqMjY1FeXl5tzJq3A6cnZ1RWFiIqKgoDBw4EGKxGPfeey9mz56N0tLSTu95/fv3R0FBAdRqNZ566im4u7tDJBLBy8sLEyZMQFZWFjZv3mx2LnRHZ8f8driO5s+fD41GgxdeeAHe3t4QiURwcnKCXC5HcnIy8vPzheknjKypv/WGhx9+WJjixM3NTZjru6OOUdKddUQD1j/7OxMVFYUdO3Zg0qRJ6N+/v1C/mzt3LjQaDTw9PQEYsuT0Jnd3d2zcuBEjRoyARCKBs7OzSdYFa6//GTNmoKSkBC+++KJwnXl5eSE4OBjFxcXCcekpe3t7bNy4EW+//bZwTbi7uyMwMBAFBQUW68XX6zjtyO2Yltvon/r8tYaTkxM2bNiA7OxsKJVKyGQyId2wcaBEYWGhybQwHSkUChw4cAChoaG477774OjoCJlMhhdeeAEajeaGKXVt+eyUyWQoLi7Ga6+9Bk9PT+EZNXv2bJSVlWHcuHFm69yq9lh8fDwyMzPx+OOPo1+/frC3t0ffvn3h7++PyMhIHDhwACqVShgIcH0b3FrDhg1DRUUF3nzzTaENIhKJMGjQIAQHB6O0tFSIrO1IqVTi4MGDiIyMxEMPPQRnZ2fh3Jk8eTLy8vKQmppqMSrezc0N27dvR2pqKuRyOVxcXODk5IRHH30U69evR3h4eI+2pTfqlD3dHwqFApWVlXjjjTfg5+eHPn36wNHREX5+foiMjERpaanZQDJjPSshIQHDhg1Dnz59hHm0V61ahaysLKuyYthyfxiNGTNGmON5+PDhXUqz/dtvvwkZWoz3XSIi+j+7dmsmbiAiIqI70kcffYQNGzYgICDA4jxY9Pe2b98+vPfee/Dw8LglkVhERH+14OBgHD16FKNGjcKuXbtsXRyiLlm4cCHKy8vx+OOPWxVBTOa+/PJLhIaGQiQS4fDhw1YNIiEion+O9vZ2KJVKNDU1YfHixQgJCbnpOrt378aSJUvg4+ODyspKtq+JiK7DiGgiIiIyExoaCqlUipMnT6K+vt7WxaFetn//fgCGFNlsJBMREfUurVaL+Ph4ZGVl4bfffrO4THt7O06dOgUAXYq2ou4x1nXGjx/PTmgiIuqyY8eOoampCSKRqMvRzcbB+xEREWxfExFZwI5oIiIiMuPm5oZXX30VAFBUVGTj0lBvqq2tFVKuXz+nFxEREVnP2dkZZWVlWLduHT755BOLy5SWlgrzsd4oRSh1X2NjI8rLywGwrkNERF33559/IicnB4BhvuuuDGTSarX49ttv4enpiZkzZ97qIhIR/S1xiA4RERFZNG/ePBQXF2PPnj0IDw/H3XffbesiUQ9pNBq0trZCr9ejoKAA7e3tmDhxIoYMGWLrohEREd1xfHx8IJfLUVdXh5UrV0Kv12PChAlwd3fHhQsX8Mknn2Dz5s0ADHNRKpVKG5f476+6uhr19fX4448/UFRUhN9//x0PPvggxo4da+uiERHRbUyn0yEvLw9ubm6oqanB0aNHYWdnh3nz5nVp/XXr1gEAVCoVxGLxrSwqEdHfFjuiiYiIyCJ3d3csW7YMcXFxyMzMxMqVK21dJOqh+vp65OXlCb+7uLggKSnJhiUiIiK6s6nVaoSFheGXX35BWloa0tLSzJaRy+VIT0+HnZ2dDUp4Z2lubkZGRobwu1gsRkpKCvctERHdkEQiQW5urslnoaGhGD58+E3XPXbsGA4dOoTx48czGpqI6AaYmpuIiIg6NXnyZEydOhUajYZzRf+NjRgxAu7u7pBKpVAoFMjPz4e3t7eti0VERHTHGjRoEEpLSxEfH48RI0bA2dkZIpEInp6eUCgUUKvV2LFjB2Qyma2Lekd48MEHcffdd0MikUAul2PLli0ICAiwdbGIiOg2J5VKMWrUKIjFYnh5eWHhwoV49913u7RuWloa+vXrh+XLl9/iUhIR/b3Ztbe3t9u6EEREREREREREREREREREdOdgRDQREREREREREREREREREfUqdkQTEREREREREREREREREVGvYkc0ERERERERERERERERERH1KnZEExERERERERERERERERFRr2JHNBERERERERERERERERER9Sp2RBMRERERERERERERERERUa9iRzQREREREREREREREREREfUqdkQTEREREREREREREREREVGvYkc0ERERERERERERERERERH1qv8B8PmhtrR3NvYAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# algorithms = sorted(algorithms, reverse=True)\n", - "if targetDataName: # User specified one analyzed dataset above (if more than one were analyzed)\n", - " for each in datasets:\n", - " if not each == targetDataName:\n", - " datasets.remove(each)\n", - "\n", - "for each in datasets: #each analyzed dataset to make plots for\n", - " print(\"---------------------------------------\")\n", - " print(\"Dataset: \"+str(each))\n", - " print(\"---------------------------------------\")\n", - " full_path = experiment_path+'/'+each\n", - " \n", - " #Create folder for tree vizualization files\n", - " original_headers = pd.read_csv(full_path+\"/exploratory/ProcessedFeatureNames.csv\",sep=',').columns.values.tolist() #Get Original Headers\n", - " \n", - " metric_dict = primaryStats(algorithms,original_headers,cv_partitions,full_path,each,instance_label,class_label,abbrev)\n", - "\n", - " #Prepare for feature importance visualizations\n", - " fi_df_list,fi_ave_norm_list,ave_metric_list,all_feature_list,non_zero_union_features,non_zero_union_indexes = prepFI(algorithms,full_path,abbrev,metric_dict,metric_weight,fi_ranking,fi_weighting)\n", - "\n", - " #Select 'top' features for composite vizualization\n", - " featuresToViz = selectForViz(top_model_features,non_zero_union_features,non_zero_union_indexes,algorithms,ave_metric_list,fi_ave_norm_list)\n", - " \n", - " #Take top feature names to vizualize and get associated feature importance values for each algorithm, and original data ordered feature names list\n", - " top_fi_ave_norm_list,all_feature_listToViz = getFI_To_Viz_Sorted(featuresToViz,all_feature_list,algorithms,fi_ave_norm_list) #If we want composite FI plots to be displayed in descenting total bar height order.\n", - "\n", - " #Generate Normalized composite FI plot\n", - " if viz_norm_only:\n", - " composite_FI_plot(top_fi_ave_norm_list, algorithms, algColors, all_feature_listToViz, 'Norm',full_path, 'Normalized Feature Importance',name_modifier,legend_inside_plot,fi_ranking,fi_weighting,metric_weight)\n", - "\n", - " #Fractionate FI scores for normalized and fractionated composite FI plot\n", - " fracLists = fracFI(top_fi_ave_norm_list)\n", - "\n", - " #Generate Normalized and Fractioned composite FI plot\n", - " if viz_norm_frac:\n", - " composite_FI_plot(fracLists, algorithms, algColors, all_feature_listToViz, 'Norm_Frac',full_path, 'Normalized and Fractioned Feature Importance',name_modifier,legend_inside_plot,fi_ranking,fi_weighting,metric_weight)\n", - "\n", - " #Weight FI scores for normalized and (model performance) weighted composite FI plot\n", - " weightedLists,weights = weightFI(ave_metric_list,top_fi_ave_norm_list)\n", - "\n", - " #Generate Normalized and Weighted Compount FI plot\n", - " if viz_norm_weight:\n", - " composite_FI_plot(weightedLists, algorithms, algColors, all_feature_listToViz, 'Norm_Weight',full_path, 'Normalized and Weighted Feature Importance',name_modifier,legend_inside_plot,fi_ranking,fi_weighting,metric_weight)\n", - "\n", - " #Weight the Fractionated FI scores for normalized,fractionated, and weighted compount FI plot\n", - " weightedFracLists = weightFracFI(fracLists,weights)\n", - "\n", - " #Generate Normalized, Fractionated, and Weighted Compount FI plot\n", - " if viz_norm_weight_frac:\n", - " composite_FI_plot(weightedFracLists, algorithms, algColors, all_feature_listToViz, 'Norm_Frac_Weight',full_path, 'Normalized, Fractioned, and Weighted Feature Importance',name_modifier,legend_inside_plot,fi_ranking,fi_weighting,metric_weight)\n", - " \n", - " " - ] - } - ], - "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.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/UsefulNotebooks/GenPlots_FI_Heatmap.ipynb b/UsefulNotebooks/GenPlots_FI_Heatmap.ipynb deleted file mode 100644 index b5312020..00000000 --- a/UsefulNotebooks/GenPlots_FI_Heatmap.ipynb +++ /dev/null @@ -1,363 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Useful Notebook: Generate a New Ranked Feature Importance Heatmap\n", - "**This notebook will allow users to generate an interactive html visualization of ranked feature importance estimates across algorithms.**\n", - "\n", - "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", - "\n", - "***\n", - "## Notebook Details\n", - "Takes the feature importance scores from each model and generates a feature importance 'rank' heatmap across all algorithms for the target datasets. These are output as an interactive html visualization using bokeh.\n", - "\n", - "This notebook requires additional installation of the bokeh package: \n", - "```\n", - "pip install bokeh\n", - "```\n", - "When run, 'as-is' this notebook will save an html link within the experiment folder for each target dataset. Clicking this link will open an interactive feature importance heatmap, where features are ranked from top to bottom by average importance rank over all algorithms. In this heatmap blue = high importance, and yellow is low importance. Users can hover there mouse over cells to get additional information about that given datapoint. These links will be saved in the same folder as other model feature importance outputs. \n", - "\n", - "This code for this visualization was written provided by Sy Hwang in September of 2021.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Notebook Run Parameters\n", - "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed). \n", - "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "experiment_path = \"../DemoOutput/demo_experiment\" # path the target experiment folder \n", - "targetDataName = None # 'None' if user wants to generate visualizations for all analyzed datasets, otherwise (str) list of target dataset names\n", - "algorithms = [] #use empty list if user wishes re-evaluate all modeling algorithms that were run in pipeline." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Housekeeping\n", - "### Import Packages" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "pd.set_option('display.max_rows', None)\n", - "import os\n", - "\n", - "from bokeh.io import output_file, save, export_png\n", - "from bokeh.models import (BasicTicker, ColorBar, ColumnDataSource,\n", - " ContinuousColorMapper, LinearColorMapper, HoverTool)\n", - "from bokeh.plotting import figure\n", - "from bokeh.transform import transform\n", - "from bokeh.palettes import Cividis256\n", - "import pickle\n", - "\n", - "import warnings\n", - "warnings.filterwarnings('ignore')\n", - "\n", - "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", - "from IPython.core.interactiveshell import InteractiveShell\n", - "InteractiveShell.ast_node_interactivity = \"all\"" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Algorithms Ran: ['Decision Tree', 'Logistic Regression', 'Naive Bayes']\n" - ] - } - ], - "source": [ - "# Unpickle metadata from previous phase\n", - "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", - "metadata = pickle.load(file)\n", - "file.close()\n", - "# Load variables specified earlier in the pipeline from metadata\n", - "\n", - "#Unpickle algorithm information from previous phase\n", - "file = open(experiment_path+'/'+\"algInfo.pickle\", 'rb')\n", - "algInfo = pickle.load(file)\n", - "file.close()\n", - "algorithms = []\n", - "abbrev = {}\n", - "for key in algInfo:\n", - " if algInfo[key][0]: # If that algorithm was used\n", - " algorithms.append(key)\n", - " abbrev[key] = (algInfo[key][1])\n", - " \n", - "print(\"Algorithms Ran: \" + str(algorithms))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Automatically Detect Dataset Names" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Analyzed Datasets: ['hcc_data', 'hcc_data_custom']\n" - ] - } - ], - "source": [ - "# Get dataset paths for all completed dataset analyses in experiment folder\n", - "datasets = os.listdir(experiment_path)\n", - "\n", - "# Name of experiment folder\n", - "experiment_name = experiment_path.split('/')[-1] \n", - "\n", - "datasets = os.listdir(experiment_path)\n", - "remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", - " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs',\n", - " 'KeyFileCopy', 'dask_logs',\n", - " experiment_name + '_STREAMLINE_Report.pdf']\n", - "for text in remove_list:\n", - " if text in datasets:\n", - " datasets.remove(text)\n", - "\n", - "datasets = sorted(datasets) # ensures consistent ordering of datasets\n", - "print(\"Analyzed Datasets: \" + str(datasets))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Generate Ranked Feature Importance Heatmap" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------------------------\n", - "Dataset: hcc_data\n", - "---------------------------------------\n" - ] - }, - { - "data": { - "text/html": [ - "
GlyphRenderer(
id = 'p1048', …)
coordinates = None,
data_source = ColumnDataSource(id='p1001', ...),
glyph = Rect(id='p1045', ...),
group = None,
hover_glyph = None,
js_event_callbacks = {},
js_property_callbacks = {},
level = 'glyph',
muted = False,
muted_glyph = Rect(id='p1047', ...),
name = None,
nonselection_glyph = Rect(id='p1046', ...),
propagate_hover = False,
selection_glyph = 'auto',
subscribed_events = PropertyValueSet(),
syncable = True,
tags = [],
view = CDSView(id='p1049', ...),
visible = True,
x_range_name = 'default',
y_range_name = 'default')
\n", - "\n" - ], - "text/plain": [ - "GlyphRenderer(id='p1048', ...)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "'C:\\\\Users\\\\ryanu\\\\Desktop\\\\STREAMLINE\\\\DemoOutput\\\\demo_experiment\\\\hcc_data\\\\model_evaluation\\\\feature_importance\\\\FI_Rank_Heatmap.html'" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------------------------\n", - "Dataset: hcc_data_custom\n", - "---------------------------------------\n" - ] - }, - { - "data": { - "text/html": [ - "
GlyphRenderer(
id = 'p1167', …)
coordinates = None,
data_source = ColumnDataSource(id='p1120', ...),
glyph = Rect(id='p1164', ...),
group = None,
hover_glyph = None,
js_event_callbacks = {},
js_property_callbacks = {},
level = 'glyph',
muted = False,
muted_glyph = Rect(id='p1166', ...),
name = None,
nonselection_glyph = Rect(id='p1165', ...),
propagate_hover = False,
selection_glyph = 'auto',
subscribed_events = PropertyValueSet(),
syncable = True,
tags = [],
view = CDSView(id='p1168', ...),
visible = True,
x_range_name = 'default',
y_range_name = 'default')
\n", - "\n" - ], - "text/plain": [ - "GlyphRenderer(id='p1167', ...)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "'C:\\\\Users\\\\ryanu\\\\Desktop\\\\STREAMLINE\\\\DemoOutput\\\\demo_experiment\\\\hcc_data_custom\\\\model_evaluation\\\\feature_importance\\\\FI_Rank_Heatmap.html'" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "if targetDataName: # User specified one analyzed dataset above (if more than one were analyzed)\n", - " for each in datasets:\n", - " if not each == targetDataName:\n", - " datasets.remove(each)\n", - "\n", - "for each in datasets: \n", - " print(\"---------------------------------------\")\n", - " print(\"Dataset: \"+str(each))\n", - " print(\"---------------------------------------\")\n", - " full_path = experiment_path+'/'+each\n", - "\n", - " series = list()\n", - " feats = None\n", - " for algorithm in algorithms:\n", - " filename = full_path+'/model_evaluation/feature_importance/'+abbrev[algorithm]+'_FI.csv'\n", - " df = pd.read_csv(filename)\n", - " if not feats:\n", - " feats = df.abs().mean().keys().to_list()\n", - " series.append(pd.Series(feats, name='feats'))\n", - " fi_avgrank = df.abs().mean().rank(ascending=False).values\n", - " series.append(pd.Series(fi_avgrank, name=algorithm.partition('_')[0]))\n", - "\n", - " finaldf = pd.concat(series, axis=1).set_index('feats')\n", - " finaldf['MeanRank'] = finaldf.mean(axis=1)\n", - " finaldf.sort_values(by='MeanRank', inplace=True)\n", - " finaldf.columns.name = 'algos'\n", - " inputdf = pd.DataFrame(finaldf.stack(), columns=['ranked']).reset_index()\n", - "\n", - "\n", - " source = ColumnDataSource(inputdf)\n", - " mapper = LinearColorMapper(palette=Cividis256, low=inputdf.ranked.min(), high=inputdf.ranked.max())\n", - "\n", - " tools=[\"wheel_zoom\", \"pan\", \"reset\"]\n", - " p = figure(width=900,\n", - " height=1600,\n", - " title=\"FI Heatmap (All Variables)\",\n", - " x_range=list(finaldf.columns),\n", - " y_range=list(reversed(finaldf.index)),\n", - " tools=tools,\n", - " toolbar_location='left',\n", - " x_axis_location=\"above\"\n", - " )\n", - " p.rect(x=\"algos\",\n", - " y=\"feats\",\n", - " width=1,\n", - " height=1,\n", - " source=source,\n", - " line_color=\"white\",\n", - " fill_color={\"field\":\"ranked\", \"transform\": mapper},\n", - " )\n", - " tooltips = [(\"algo\", \"@algos\"),\n", - " (\"feature\", \"@feats\"),\n", - " (\"rank\", \"@ranked\")]\n", - "\n", - " hover = HoverTool(tooltips = tooltips)\n", - " p.add_tools(hover)\n", - " p.axis.axis_line_color = None\n", - " p.axis.major_tick_line_color = None\n", - " p.axis.major_label_text_font_size = \"14px\"\n", - " p.title.text_font_size = '24px'\n", - " p.axis.major_label_standoff = 0\n", - " p.xaxis.major_label_orientation = 1.0\n", - "\n", - " output_file(full_path+'/model_evaluation/feature_importance/'+'FI_Rank_Heatmap.html')\n", - " save(p)\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "interpreter": { - "hash": "1a12a98ae265c92e0b59419562a28d4a83daa07b99af1da9cec83ddf5b471690" - }, - "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.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/UsefulNotebooks/GenPlots_ROC_PRC.ipynb b/UsefulNotebooks/GenPlots_ROC_PRC.ipynb deleted file mode 100644 index a23fd93c..00000000 --- a/UsefulNotebooks/GenPlots_ROC_PRC.ipynb +++ /dev/null @@ -1,575 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Useful Notebook: Generate Custom ROC and PRC Plots\n", - "**This notebook will allow users to generate (1) ROC and PRC plots for each algorithm (over all CV partitions) if this function was previously turned off in the pipeline, (2) all ROC and PRC plots with the legend inside the plot rather than to the upper right, and (3) allow code-savy users to easily modify this notebook to regenerate these plots to their own specifications.**\n", - "\n", - "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", - "\n", - "***\n", - "## Notebook Details\n", - "Generates custom ROC and PRC plots to provide a way to generate modified versions of these plots without rerunning or directly editing the code in the original pipeline. \n", - "\n", - "When run, 'as-is' this notebook will regenerate all ROC and PRC plots putting the legend inside of the plots: (1) in the upper right hand corner for PRC plots, and (2) in the lower right hand corner for ROC plots. However in some (maybe all cases) the legend will then obstruct the curves themselves. This simple customization of the plots is meant as an example. Users are welcome to modify the plot cells at the bottom of this notebook to further tweak the appearance of the respective plots. These will be saved in the same location within the 'experiment folder' as the original ROC and PRC plots, but with a filename modified by `name_modifier` below.\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Notebook Run Parameters\n", - "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed). \n", - "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "experiment_path = \"../DemoOutput/demo_experiment\" # path the target experiment folder \n", - "targetDataName = None # 'None' if user wants to generate visualizations for all analyzed datasets, otherwise give a (str) list of target dataset names\n", - "algorithms = [] #use empty list if user wishes to plot feature importance for all modeling algorithms that were run in pipeline.\n", - "name_modifier = '_New' # Modifies standard plot filenames to avoid overwriting originals.\n", - "legend_inside_plot = True #place legend inside plot, other wise placed outside on upper right hand corner.\n", - "plot_ROC = True # For each algorithm plot ROC curve - including lines for each trained CV model.\n", - "plot_PRC = True # For each algorithm plot PRC curve - including lines for each trained CV model.\n", - "plot_meta_ROC = True #Generate ROC summarizing average ROC curves (all cvs) for each algorithm\n", - "plot_meta_PRC = True #Generate PRC summarizing average ROC curves (all cvs) for each algorithm" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Housekeeping\n", - "### Import Packages" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import pandas as pd\n", - "import pickle\n", - "from statistics import mean,stdev\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib import rc\n", - "import numpy as np\n", - "from scipy import interp,stats\n", - "\n", - "import warnings\n", - "warnings.filterwarnings('ignore')\n", - "\n", - "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", - "from IPython.core.interactiveshell import InteractiveShell\n", - "InteractiveShell.ast_node_interactivity = \"all\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Automatically detect data folder names" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Analyzed Datasets: ['hcc_data', 'hcc_data_custom']\n" - ] - } - ], - "source": [ - "# Get dataset paths for all completed dataset analyses in experiment folder\n", - "datasets = os.listdir(experiment_path)\n", - "\n", - "# Name of experiment folder\n", - "experiment_name = experiment_path.split('/')[-1] \n", - "\n", - "datasets = os.listdir(experiment_path)\n", - "remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", - " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs',\n", - " 'KeyFileCopy', 'dask_logs',\n", - " experiment_name + '_STREAMLINE_Report.pdf']\n", - "for text in remove_list:\n", - " if text in datasets:\n", - " datasets.remove(text)\n", - "\n", - "datasets = sorted(datasets) # ensures consistent ordering of datasets\n", - "print(\"Analyzed Datasets: \" + str(datasets))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load other necessary parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Decision Tree', 'Logistic Regression', 'Naive Bayes']\n" - ] - } - ], - "source": [ - "# Unpickle metadata from previous phase\n", - "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", - "metadata = pickle.load(file)\n", - "file.close()\n", - "# Load variables specified earlier in the pipeline from metadata\n", - "class_label = metadata['Class Label']\n", - "instance_label = metadata['Instance Label']\n", - "cv_partitions = int(metadata['CV Partitions'])\n", - "\n", - "# Unpickle algorithm information from previous phase\n", - "file = open(experiment_path+'/'+\"algInfo.pickle\", 'rb')\n", - "algInfo = pickle.load(file)\n", - "file.close()\n", - "algorithms = []\n", - "abbrev = {}\n", - "colors = {}\n", - "for key in algInfo:\n", - " if algInfo[key][0]: # If that algorithm was used\n", - " algorithms.append(key)\n", - " abbrev[key] = (algInfo[key][1])\n", - " colors[key] = (algInfo[key][2])\n", - " \n", - "print(algorithms) " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define Necessary Methods" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "def primaryStats(algorithms,original_headers,cv_partitions,full_path,data_name,instance_label,class_label,abbrev,colors,plot_ROC,plot_PRC,name_modifier,legend_inside_plot):\n", - " \"\"\" Combine classification metrics and model feature importance scores\"\"\"\n", - " result_table = []\n", - " metric_dict = {}\n", - " for algorithm in algorithms: #completed for each individual ML modeling algorithm\n", - " alg_result_table = [] #stores values used in ROC and PRC plots\n", - " # Define evaluation stats variable lists\n", - " s_bac = [] # balanced accuracies\n", - " s_ac = [] # standard accuracies\n", - " s_f1 = [] # F1 scores\n", - " s_re = [] # recall values\n", - " s_sp = [] # specificities\n", - " s_pr = [] # precision values\n", - " s_tp = [] # true positives\n", - " s_tn = [] # true negatives\n", - " s_fp = [] # false positives\n", - " s_fn = [] # false negatives\n", - " s_npv = [] # negative predictive values\n", - " s_lrp = [] # likelihood ratio positive values\n", - " s_lrm = [] # likelihood ratio negative values\n", - " # Define ROC plot variable lists\n", - " tprs = [] # true postitive rates\n", - " aucs = [] #areas under ROC curve\n", - " mean_fpr = np.linspace(0, 1, 100) #used to plot all CVs in single ROC plot\n", - " mean_recall = np.linspace(0, 1, 100) #used to plot all CVs in single PRC plot\n", - " # Define PRC plot variable lists\n", - " precs = [] #precision values for PRC\n", - " praucs = [] #area under PRC curve\n", - " aveprecs = [] #average precisions for PRC\n", - " \n", - " #Gather statistics over all CV partitions\n", - " for cvCount in range(0,cv_partitions):\n", - " #Unpickle saved metrics from previous phase\n", - " result_file = full_path+'/model_evaluation/pickled_metrics/'+abbrev[algorithm]+\"_CV_\"+str(cvCount)+\"_metrics.pickle\"\n", - " file = open(result_file, 'rb')\n", - " results = pickle.load(file)\n", - " file.close()\n", - " #Separate pickled results\n", - " metricList = results[0]\n", - " fpr = results[1]\n", - " tpr = results[2]\n", - " roc_auc = results[3]\n", - " prec = results[4]\n", - " recall = results[5]\n", - " prec_rec_auc = results[6]\n", - " ave_prec = results[7]\n", - " #Separate metrics from metricList\n", - " s_bac.append(metricList[0])\n", - " s_ac.append(metricList[1])\n", - " s_f1.append(metricList[2])\n", - " s_re.append(metricList[3])\n", - " s_sp.append(metricList[4])\n", - " s_pr.append(metricList[5])\n", - " s_tp.append(metricList[6])\n", - " s_tn.append(metricList[7])\n", - " s_fp.append(metricList[8])\n", - " s_fn.append(metricList[9])\n", - " s_npv.append(metricList[10])\n", - " s_lrp.append(metricList[11])\n", - " s_lrm.append(metricList[12])\n", - " #update list that stores values used in ROC and PRC plots\n", - " alg_result_table.append([fpr, tpr, roc_auc, prec, recall, prec_rec_auc, ave_prec])\n", - " # Update ROC plot variable lists needed to plot all CVs in one ROC plot\n", - " tprs.append(interp(mean_fpr, fpr, tpr))\n", - " tprs[-1][0] = 0.0\n", - " aucs.append(roc_auc)\n", - " # Update PRC plot variable lists needed to plot all CVs in one PRC plot\n", - " precs.append(interp(mean_recall, recall, prec))\n", - " praucs.append(prec_rec_auc)\n", - " aveprecs.append(ave_prec)\n", - " \n", - " print(algorithm)\n", - " #Define values for the mean ROC line (mean of individual CVs)\n", - " mean_tpr = np.mean(tprs, axis=0)\n", - " mean_tpr[-1] = 1.0\n", - " mean_auc = np.mean(aucs)\n", - " #Generate ROC Plot (including individual CV's lines, average line, and no skill line) - based on https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc_crossval.html-----------------------\n", - " if plot_ROC:\n", - " # Set figure dimensions\n", - " plt.rcParams[\"figure.figsize\"] = (6,6)\n", - " # Plot individual CV ROC lines\n", - " for i in range(cv_partitions):\n", - " plt.plot(alg_result_table[i][0], alg_result_table[i][1], lw=1, alpha=0.3,label='ROC fold %d (AUC = %0.3f)' % (i, alg_result_table[i][2]))\n", - " # Plot no-skill line\n", - " plt.plot([0, 1], [0, 1], linestyle='--', lw=2, color='r',label='No-Skill', alpha=.8)\n", - " # Plot average line for all CVs\n", - " std_auc = np.std(aucs) # AUC standard deviations across CVs\n", - " plt.plot(mean_fpr, mean_tpr, color=colors[algorithm],label=r'Mean ROC (AUC = %0.3f $\\pm$ %0.3f)' % (mean_auc, std_auc),lw=2, alpha=.8)\n", - " # Plot standard deviation grey zone of curves\n", - " std_tpr = np.std(tprs, axis=0)\n", - " tprs_upper = np.minimum(mean_tpr + std_tpr, 1)\n", - " tprs_lower = np.maximum(mean_tpr - std_tpr, 0)\n", - " plt.fill_between(mean_fpr, tprs_lower, tprs_upper, color='grey', alpha=.2,label=r'$\\pm$ 1 std. dev.')\n", - " #Specify plot axes,labels, and legend\n", - " plt.xlim([-0.05, 1.05])\n", - " plt.ylim([-0.05, 1.05])\n", - " plt.title(str(algorithm))\n", - " plt.xlabel('False Positive Rate')\n", - " plt.ylabel('True Positive Rate')\n", - " if legend_inside_plot:\n", - " plt.legend(loc=\"lower right\")\n", - " else:\n", - " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", - " #Export and/or show plot\n", - " plt.savefig(full_path+'/model_evaluation/'+abbrev[algorithm]+\"_ROC\"+name_modifier+\".png\", bbox_inches=\"tight\")\n", - " plt.show()\n", - "\n", - " #Define values for the mean PRC line (mean of individual CVs)\n", - " mean_prec = np.mean(precs, axis=0)\n", - " mean_pr_auc = np.mean(praucs)\n", - " #Generate PRC Plot (including individual CV's lines, average line, and no skill line)------------------------------------------------------------------------------------------------------------------\n", - " if plot_PRC:\n", - " # Set figure dimensions\n", - " plt.rcParams[\"figure.figsize\"] = (6,6)\n", - " # Plot individual CV PRC lines\n", - " for i in range(cv_partitions):\n", - " plt.plot(alg_result_table[i][4], alg_result_table[i][3], lw=1, alpha=0.3, label='PRC fold %d (AUC = %0.3f)' % (i, alg_result_table[i][5]))\n", - " #Estimate no skill line based on the fraction of cases found in the first test dataset\n", - " test = pd.read_csv(full_path + '/CVDatasets/' + data_name + '_CV_0_Test.csv') #Technically there could be a unique no-skill line for each CV dataset based on final class balance (however only one is needed, and stratified CV attempts to keep partitions with similar/same class balance)\n", - " testY = test[class_label].values\n", - " noskill = len(testY[testY == 1]) / len(testY) # Fraction of cases\n", - " # Plot no-skill line\n", - " plt.plot([0, 1], [noskill, noskill], color='orange', linestyle='--', label='No-Skill', alpha=.8)\n", - " # Plot average line for all CVs\n", - " std_pr_auc = np.std(praucs)\n", - " # Plot standard deviation grey zone of curves\n", - " plt.plot(mean_recall, mean_prec, color=colors[algorithm],label=r'Mean PRC (AUC = %0.3f $\\pm$ %0.3f)' % (mean_pr_auc, std_pr_auc),lw=2, alpha=.8)\n", - " std_prec = np.std(precs, axis=0)\n", - " precs_upper = np.minimum(mean_prec + std_prec, 1)\n", - " precs_lower = np.maximum(mean_prec - std_prec, 0)\n", - " plt.fill_between(mean_recall, precs_lower, precs_upper, color='grey', alpha=.2,label=r'$\\pm$ 1 std. dev.')\n", - " #Specify plot axes,labels, and legend\n", - " plt.xlim([-0.05, 1.05])\n", - " plt.ylim([-0.05, 1.05])\n", - " plt.title(str(algorithm))\n", - " plt.xlabel('Recall (Sensitivity)')\n", - " plt.ylabel('Precision (PPV)')\n", - " if legend_inside_plot:\n", - " plt.legend(loc=\"upper right\")\n", - " else:\n", - " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", - " #Export and/or show plot\n", - " plt.savefig(full_path+'/model_evaluation/'+abbrev[algorithm]+\"_PRC\"+name_modifier+\".png\", bbox_inches=\"tight\")\n", - " plt.show()\n", - " \n", - " #Export and save all CV metric stats for each individual algorithm -----------------------------------------------------------------------------\n", - " results = {'Balanced Accuracy': s_bac, 'Accuracy': s_ac, 'F1 Score': s_f1, 'Sensitivity (Recall)': s_re, 'Specificity': s_sp,'Precision (PPV)': s_pr, 'TP': s_tp, 'TN': s_tn, 'FP': s_fp, 'FN': s_fn, 'NPV': s_npv, 'LR+': s_lrp, 'LR-': s_lrm, 'ROC AUC': aucs,'PRC AUC': praucs, 'PRC APS': aveprecs}\n", - " metric_dict[algorithm] = results\n", - "\n", - " #Store ave metrics for creating global ROC and PRC plots later\n", - " mean_ave_prec = np.mean(aveprecs)\n", - " result_dict = {'algorithm':algorithm,'fpr':mean_fpr, 'tpr':mean_tpr, 'auc':mean_auc, 'prec':mean_prec, 'recall':mean_recall, 'pr_auc':mean_pr_auc, 'ave_prec':mean_ave_prec}\n", - " result_table.append(result_dict)\n", - " #Result table later used to create global ROC an PRC plots comparing average ML algorithm performance.\n", - " result_table = pd.DataFrame.from_dict(result_table)\n", - " result_table.set_index('algorithm',inplace=True)\n", - "\n", - " return result_table,metric_dict\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "def doPlotROC(result_table,colors,full_path,name_modifier,legend_inside_plot):\n", - " \"\"\" Generate ROC plot comparing average ML algorithm performance (over all CV training/testing sets)\"\"\"\n", - " count = 0\n", - " #Plot curves for each individual ML algorithm\n", - " for i in result_table.index:\n", - " plt.plot(result_table.loc[i]['fpr'],result_table.loc[i]['tpr'], color=colors[i],label=\"{}, AUC={:.3f}\".format(i, result_table.loc[i]['auc']))\n", - " count += 1\n", - " # Set figure dimensions\n", - " plt.rcParams[\"figure.figsize\"] = (6,6)\n", - " # Plot no-skill line\n", - " plt.plot([0, 1], [0, 1], color='orange', linestyle='--', label='No-Skill', alpha=.8)\n", - " #Specify plot axes,labels, and legend\n", - " plt.xticks(np.arange(0.0, 1.1, step=0.1))\n", - " plt.xlabel(\"False Positive Rate\", fontsize=15)\n", - " plt.yticks(np.arange(0.0, 1.1, step=0.1))\n", - " plt.ylabel(\"True Positive Rate\", fontsize=15)\n", - " if legend_inside_plot:\n", - " plt.legend(loc=\"lower right\")\n", - " else:\n", - " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", - " #Export and/or show plot\n", - " plt.savefig(full_path+'/model_evaluation/Summary_ROC'+name_modifier+'.png', bbox_inches=\"tight\")\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def doPlotPRC(result_table,colors,full_path,data_name,instance_label,class_label,name_modifier,legend_inside_plot):\n", - " \"\"\" Generate PRC plot comparing average ML algorithm performance (over all CV training/testing sets)\"\"\"\n", - " count = 0\n", - " #Plot curves for each individual ML algorithm\n", - " for i in result_table.index:\n", - " plt.plot(result_table.loc[i]['recall'],result_table.loc[i]['prec'], color=colors[i],label=\"{}, AUC={:.3f}, APS={:.3f}\".format(i, result_table.loc[i]['pr_auc'],result_table.loc[i]['ave_prec']))\n", - " count += 1\n", - " #Estimate no skill line based on the fraction of cases found in the first test dataset\n", - " test = pd.read_csv(full_path+'/CVDatasets/'+data_name+'_CV_0_Test.csv')\n", - " if instance_label != 'None':\n", - " test = test.drop(instance_label, axis=1)\n", - " testY = test[class_label].values\n", - " noskill = len(testY[testY == 1]) / len(testY) # Fraction of cases\n", - " # Plot no-skill line\n", - " plt.plot([0, 1], [noskill, noskill], color='orange', linestyle='--',label='No-Skill', alpha=.8)\n", - " #Specify plot axes,labels, and legend\n", - " plt.xticks(np.arange(0.0, 1.1, step=0.1))\n", - " plt.xlabel(\"Recall (Sensitivity)\", fontsize=15)\n", - " plt.yticks(np.arange(0.0, 1.1, step=0.1))\n", - " plt.ylabel(\"Precision (PPV)\", fontsize=15)\n", - " if legend_inside_plot:\n", - " plt.legend(loc=\"upper right\")\n", - " else:\n", - " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", - " #Export and/or show plot\n", - " plt.savefig(full_path+'/model_evaluation/Summary_PRC'+name_modifier+'.png', bbox_inches=\"tight\")\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Generate all ROC and PRC Plots" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------------------------\n", - "Dataset: hcc_data_custom\n", - "---------------------------------------\n", - "Decision Tree\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Logistic Regression\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Naive Bayes\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "if not targetDataName == 'None': # User specified one analyzed dataset above (if more than one were analyzed)\n", - " for each in datasets:\n", - " if not each == targetDataName:\n", - " datasets.remove(each)\n", - "\n", - "for each in datasets: #each analyzed dataset to make plots for\n", - " print(\"---------------------------------------\")\n", - " print(\"Dataset: \"+str(each))\n", - " print(\"---------------------------------------\")\n", - " full_path = experiment_path+'/'+each\n", - " #Create folder for tree vizualization files\n", - " original_headers = pd.read_csv(full_path+\"/exploratory/ProcessedFeatureNames.csv\",sep=',').columns.values.tolist() #Get Original Headers\n", - " \n", - " result_table,metric_dict = primaryStats(algorithms,original_headers,cv_partitions,full_path,each,instance_label,class_label,abbrev,colors,plot_ROC,plot_PRC,name_modifier,legend_inside_plot)\n", - "\n", - " #Plot ROC and PRC curves comparing average ML algorithm performance (averaged over all CVs)\n", - " if plot_meta_ROC:\n", - " doPlotROC(result_table,colors,full_path,name_modifier,legend_inside_plot)\n", - " if plot_meta_PRC:\n", - " doPlotPRC(result_table,colors,full_path,each,instance_label,class_label,name_modifier,legend_inside_plot)\n" - ] - }, - { - "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.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/UsefulNotebooks/ModelViz_DT_GP.ipynb b/UsefulNotebooks/ModelViz_DT_GP.ipynb deleted file mode 100644 index 4c35768d..00000000 --- a/UsefulNotebooks/ModelViz_DT_GP.ipynb +++ /dev/null @@ -1,1798 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Useful Notebook: Generate Model Visualizations for Decision Tree and Genetic Programming Algorithms\n", - "**This notebook will allow users to generate a direct visualization of the models generated by algorithms that create directly interpretable models.** \n", - "\n", - "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", - "\n", - "***\n", - "## Notebook Details\n", - "Generates decision tree and genetic programming model visualizations for each CV model trained by STREAMLINE. Opens each pickled decision tree and genetic programming model and generates a respective vizualization, and optionally saves them to a new folder in the working experiment folder for the given target dataset (`model_evaluation`). Can be run for a single dataset or all datasets. Includes an option to only visualize the best performing model (out of all CV datasets) determined by the user specified target metric (testing data evaluation). Also provides the option to inverse the standard scaling applied to the dataset, so that feature values can be interpreted in their original scale.\n", - "\n", - "Requirements: conda install python-graphviz \n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Notebook Run Parameters\n", - "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed). Note that in the basic demo, only Decision Tree is run, not Genetic Programming. \n", - "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "experiment_path = \"../DemoOutput/demo_experiment\" # path the target experiment folder \n", - "targetDataName = None # 'None' if user wants to generate visualizations for all analyzed datasets\n", - "inverseScaling = True #If standardscaling was applied, revert scaled decision boundaries to their original data values.\n", - "bestOnly = False # Only generate viz. for best performing CV decision tree, otherwise generate one for each CV model.\n", - "targetMetric = 'ROC AUC' #Only used when bestOnly = True, names of different available metrics is included below.\n", - "\n", - "#metricOptions = ['Balanced Accuracy','Accuracy','F1_Score','Sensitivity (Recall)','Specificity','Precision (PPV)','TP','TN','FP','FN','NPV','LR+','LR-','ROC_AUC','PRC_AUC','PRC_APS']" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Housekeeping\n", - "### Import Packages" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import pickle\n", - "import pandas as pd\n", - "import graphviz\n", - "from sklearn import tree\n", - "from subprocess import call\n", - "import matplotlib.pyplot as plt\n", - "\n", - "import warnings\n", - "warnings.filterwarnings('ignore')\n", - "\n", - "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", - "from IPython.core.interactiveshell import InteractiveShell\n", - "InteractiveShell.ast_node_interactivity = \"all\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Automatically detect dataset folder names" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Analyzed Datasets: ['hcc_data', 'hcc_data_custom']\n" - ] - } - ], - "source": [ - "# Get dataset paths for all completed dataset analyses in experiment folder\n", - "datasets = os.listdir(experiment_path)\n", - "\n", - "# Name of experiment folder\n", - "experiment_name = experiment_path.split('/')[-1] \n", - "\n", - "datasets = os.listdir(experiment_path)\n", - "remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", - " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs',\n", - " 'KeyFileCopy', 'dask_logs',\n", - " experiment_name + '_STREAMLINE_Report.pdf']\n", - "for text in remove_list:\n", - " if text in datasets:\n", - " datasets.remove(text)\n", - "\n", - "datasets = sorted(datasets) # ensures consistent ordering of datasets\n", - "print(\"Analyzed Datasets: \" + str(datasets))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define Necessary Methods" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "def unscaleTree(dotFilePath,original_headers,train_feature_list,scaler):\n", - " \"\"\" Takes a dot file goes in and finds feature names next to associated cutoff values. Then inverse scales these cutoff \n", - " values using previously pickled scaler. Scaling is reversed by multiplying by '.scale_' and adding '.mean_' from scaler.\n", - " These new values replace the old ones and the dot file is resaved with these changes.\"\"\"\n", - " my_file = open(dotFilePath)\n", - " file_list = my_file.readlines()\n", - " my_file.close()\n", - " new_file_list = []\n", - " for each in file_list: #Each line of file\n", - " for feature in original_headers: #check each feature name\n", - " if ('\"'+str(feature)) in each:\n", - " #Separate string by spaces\n", - " stringList = each.split(' ')\n", - " #Find chunk with \\nentropy\n", - " i = 0\n", - " purityText = None\n", - " for chunk in stringList:\n", - " if '\\\\nentropy' in chunk:\n", - " purityText = '\\\\nentropy'\n", - " #Isolate numerical value\n", - " targetValue = float(chunk.replace('\\\\nentropy',''))\n", - " break\n", - " elif '\\\\ngini' in chunk:\n", - " purityText = '\\\\ngini'\n", - " #Isolate numerical value\n", - " targetValue = float(chunk.replace('\\\\ngini',''))\n", - " break\n", - " i += 1\n", - " #Get index of target feature name in original feature ordering\n", - " feature_index = original_headers.index(feature)\n", - " #Inverse scale based on specific feature scale index (mean and std)\n", - " originalValue = (targetValue*scaler.scale_[feature_index]) + scaler.mean_[feature_index]\n", - " #Replace numerical value in original dot file with inverse scaled 'original' value\n", - " stringList[i] = str(originalValue)+purityText\n", - " #Rebuild string\n", - " each = \" \".join(stringList)\n", - " new_file_list.append(each)\n", - " my_file = open(dotFilePath, \"w\")\n", - " new_file_contents = \"\".join(new_file_list)\n", - " my_file.write(new_file_contents)\n", - " my_file.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "def generateTreePlot(experiment_path,each,algorithm,cvCount,max_index,scale_data,class_label,instance_label,inverseScaling,targetMetric):\n", - " \"\"\" Takes all steps to generate a single decision tree visualization (for a given original dataset/cv training model).\n", - " Includes option to inverse scale all feature values in tree decision boundaries (to their original value range, pre-scaling)\"\"\"\n", - " #Pickle load target model\n", - " modelInfo = experiment_path+\"/\"+each+'/models/pickledModels/'+algorithm+'_'+str(cvCount)+'.pickle' #Corresponding pickle file name with scalingInfo\n", - " infile = open(modelInfo,'rb')\n", - " model = pickle.load(infile)\n", - " infile.close()\n", - " #Pickle load target model\n", - " if scale_data:\n", - " #Scalar is in original data order and is specified for all features (pre-feature selection)\n", - " scaleInfo = experiment_path+\"/\"+each+'/scale_impute/scaler_cv'+str(cvCount)+'.pickle' #Corresponding pickle file name with scalingInfo\n", - " infile = open(scaleInfo,'rb')\n", - " scaler = pickle.load(infile)\n", - " infile.close()\n", - "\n", - " #Load feature names in their original order (corresponding to scaler order)\n", - " original_headers = pd.read_csv(experiment_path+\"/\"+each+\"/exploratory/OriginalFeatureNames.csv\",sep=',').columns.values.tolist() #Get Original Headers\n", - "\n", - " #Load feature names for CV training dataset used to train model (features sorted alphabetically)\n", - " cv_train_path = experiment_path+\"/\"+each+\"/CVDatasets/\"+each+'_CV_'+str(cvCount)+'_Train.csv'\n", - " cv_train_data = pd.read_csv(cv_train_path, na_values='NA', sep = \",\")\n", - " #Get List of features in cv dataset (if feature selection took place this may only include a subset of original training data features)\n", - " train_feature_list = list(cv_train_data.columns.values)\n", - " train_feature_list.remove(class_label)\n", - " try:\n", - " train_feature_list.remove(instance_label)\n", - " except:\n", - " pass\n", - " \n", - " #Generate Tree dot file\n", - " tree_path = experiment_path+'/'+each+'/model_evaluation/DT_Viz/'\n", - " tree.export_graphviz(model, out_file=tree_path+\"DT_Tree_\"+str(cvCount)+'.dot', feature_names=train_feature_list, class_names=True, filled=True)\n", - " if scale_data and inverseScaling:\n", - " # Revert tree decision boundary values back to pre-scaled values for interpretability\n", - " unscaleTree(tree_path+\"DT_Tree_\"+str(cvCount)+'.dot',original_headers,train_feature_list,scaler)\n", - " # Generate Tree visualization\n", - " graph = graphviz.Source.from_file(tree_path+\"DT_Tree_\"+str(cvCount)+'.dot')\n", - " graph.format = \"png\" #Add this line to generate png files rather than pdfs.\n", - " if cvCount == max_index: #This tree had best performance\n", - " printMetric = targetMetric.replace(\" \", \"_\")\n", - " graph.render(tree_path+\"DT_Tree_\"+str(cvCount)+'_Best_'+printMetric)\n", - " else:\n", - " graph.render(tree_path+\"DT_Tree_\"+str(cvCount))\n", - " return graph\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "def generateGPPlot(experiment_path,data_name,algorithm,cvCount,max_index,scale_data,class_label,instance_label,targetMetric):\n", - " \"\"\" Takes all steps to generate a single genetic programming tree. https://gplearn.readthedocs.io/en/stable/examples.html \"\"\"\n", - " #Pickle load target model\n", - " modelInfo = experiment_path+\"/\"+data_name+'/models/pickledModels/'+algorithm+'_'+str(cvCount)+'.pickle' #Corresponding pickle file name with scalingInfo\n", - " infile = open(modelInfo,'rb')\n", - " model = pickle.load(infile)\n", - " infile.close()\n", - " #Generate GP tree visualization\n", - " tree_path = experiment_path+'/'+data_name+'/model_evaluation/GP_Viz/'\n", - " dot_data = model._program.export_graphviz()\n", - " graph = graphviz.Source(dot_data)\n", - " graph.format = \"png\" #Add this line to generate png files rather than pdfs.\n", - " if cvCount == max_index: #This tree had best performance\n", - " printMetric = targetMetric.replace(\" \", \"_\")\n", - " graph.render(tree_path+\"GP_Tree_\"+str(cvCount)+'_Best_'+printMetric)\n", - " else:\n", - " graph.render(tree_path+\"GP_Tree_\"+str(cvCount))\n", - " return graph" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Generate Decision Tree and/or Genetic Programming Tree Vizualizations" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Vizualized Datasets: ['hcc_data', 'hcc_data_custom']\n", - "Number of CV Partitions: 3\n" - ] - } - ], - "source": [ - "if targetDataName: # User specified one analyzed dataset above (if more than one were analyzed)\n", - " for each in datasets:\n", - " if not each == targetDataName:\n", - " datasets.remove(each)\n", - "print(\"Vizualized Datasets: \"+str(datasets))\n", - "\n", - "# Unpickle metadata from previous phase\n", - "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", - "metadata = pickle.load(file)\n", - "file.close()\n", - "\n", - "# Unpickle algInfo from previous phase\n", - "file = open(experiment_path+'/'+\"algInfo.pickle\", 'rb')\n", - "algInfo = pickle.load(file)\n", - "file.close()\n", - "\n", - "#Load variables specified earlier in the pipeline from metadata\n", - "class_label = metadata['Class Label']\n", - "instance_label = metadata['Instance Label']\n", - "cv_partitions = metadata['CV Partitions']\n", - "scale_data = metadata['Use Data Scaling']\n", - "do_DT = algInfo['Decision Tree'][0]\n", - "do_GP = algInfo['Genetic Programming'][0]\n", - "print(\"Number of CV Partitions: \"+str(cv_partitions))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ROC AUC values for each CV training set with DT:\n", - "[0.5889355742296918, 0.6470588235294118, 0.6785714285714285]\n", - "Best ROC AUC: 0.6785714285714285\n", - "---------------------------------------\n", - "hcc_data- CV Dataset: 2\n", - "---------------------------------------\n" - ] - }, - { - "data": { - "image/svg+xml": [ - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "Tree\r\n", - "\r\n", - "\r\n", - "\r\n", - "0\r\n", - "\r\n", - "Albumin (mg/dL) <= 3.749809305949444\r\n", - "gini = 0.5\r\n", - "samples = 110\r\n", - "value = [55.0, 55.0]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1\r\n", - "\r\n", - "Alpha-Fetoprotein (ng/mL) <= 45.873065538544324\r\n", - "gini = 0.451\r\n", - "samples = 74\r\n", - "value = [27.5, 52.381]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "0->1\r\n", - "\r\n", - "\r\n", - "True\r\n", - "\r\n", - "\r\n", - "\r\n", - "12\r\n", - "\r\n", - "Gamma glutamyl transferase (U/L) <= 79.53090132200012\r\n", - "gini = 0.159\r\n", - "samples = 36\r\n", - "value = [27.5, 2.619]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "0->12\r\n", - "\r\n", - "\r\n", - "False\r\n", - "\r\n", - "\r\n", - "\r\n", - "2\r\n", - "\r\n", - "Iron <= 81.182855723424\r\n", - "gini = 0.482\r\n", - "samples = 27\r\n", - "value = [15.368, 10.476]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1->2\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "5\r\n", - "\r\n", - "Aspartate transaminase (U/L) <= 60.47885334152118\r\n", - "gini = 0.348\r\n", - "samples = 47\r\n", - "value = [12.132, 41.905]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1->5\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "3\r\n", - "\r\n", - "gini = 0.386\r\n", - "samples = 11\r\n", - "value = [3.235, 9.167]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "2->3\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "4\r\n", - "\r\n", - "gini = 0.176\r\n", - "samples = 16\r\n", - "value = [12.132, 1.31]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "2->4\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "6\r\n", - "\r\n", - "gini = 0.484\r\n", - "samples = 10\r\n", - "value = [5.662, 3.929]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "5->6\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "7\r\n", - "\r\n", - "Arterial Hypertension <= 0.4999973261800784\r\n", - "gini = 0.249\r\n", - "samples = 37\r\n", - "value = [6.471, 37.976]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "5->7\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "8\r\n", - "\r\n", - "Total Proteins (g/dL) <= 6.855504152173777\r\n", - "gini = 0.101\r\n", - "samples = 24\r\n", - "value = [1.618, 28.81]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "7->8\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "11\r\n", - "\r\n", - "gini = 0.453\r\n", - "samples = 13\r\n", - "value = [4.853, 9.167]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "7->11\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "9\r\n", - "\r\n", - "gini = 0.232\r\n", - "samples = 10\r\n", - "value = [1.618, 10.476]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "8->9\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "10\r\n", - "\r\n", - "gini = -0.0\r\n", - "samples = 14\r\n", - "value = [0.0, 18.333]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "8->10\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "13\r\n", - "\r\n", - "gini = 0.41\r\n", - "samples = 10\r\n", - "value = [6.471, 2.619]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "12->13\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "14\r\n", - "\r\n", - "gini = 0.0\r\n", - "samples = 26\r\n", - "value = [21.029, 0.0]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "12->14\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------------------------\n", - "hcc_data- CV Dataset: 2\n", - "---------------------------------------\n" - ] - }, - { - "data": { - "image/svg+xml": [ - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "Tree\r\n", - "\r\n", - "\r\n", - "\r\n", - "0\r\n", - "\r\n", - "Alkaline phosphatase (U/L) <= 201.81387672282642\r\n", - "gini = 0.5\r\n", - "samples = 110\r\n", - "value = [55.0, 55.0]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1\r\n", - "\r\n", - "Alanine transaminase (U/L) <= 28.984137980123577\r\n", - "gini = 0.427\r\n", - "samples = 74\r\n", - "value = [46.912, 20.952]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "0->1\r\n", - "\r\n", - "\r\n", - "True\r\n", - "\r\n", - "\r\n", - "\r\n", - "14\r\n", - "\r\n", - "Total Proteins (g/dL) <= 7.802097738723476\r\n", - "gini = 0.31\r\n", - "samples = 36\r\n", - "value = [8.088, 34.048]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "0->14\r\n", - "\r\n", - "\r\n", - "False\r\n", - "\r\n", - "\r\n", - "\r\n", - "2\r\n", - "\r\n", - "Age at diagnosis <= 71.4964404658491\r\n", - "gini = 0.472\r\n", - "samples = 20\r\n", - "value = [8.088, 13.095]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1->2\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "9\r\n", - "\r\n", - "Mean Corpuscular Volume <= 109.25137645419262\r\n", - "gini = 0.28\r\n", - "samples = 54\r\n", - "value = [38.824, 7.857]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1->9\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "3\r\n", - "\r\n", - "Total Bilirubin(mg/dL) <= 1.4973640082090065\r\n", - "gini = 0.305\r\n", - "samples = 8\r\n", - "value = [5.662, 1.31]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "2->3\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "6\r\n", - "\r\n", - "Major dimension of nodule (cm) <= 4.148394232619101\r\n", - "gini = 0.283\r\n", - "samples = 12\r\n", - "value = [2.426, 11.786]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "2->6\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "4\r\n", - "\r\n", - "gini = 0.0\r\n", - "samples = 5\r\n", - "value = [4.044, 0.0]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "3->4\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "5\r\n", - "\r\n", - "gini = 0.494\r\n", - "samples = 3\r\n", - "value = [1.618, 1.31]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "3->5\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "7\r\n", - "\r\n", - "gini = 0.499\r\n", - "samples = 5\r\n", - "value = [2.426, 2.619]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "6->7\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "8\r\n", - "\r\n", - "gini = 0.0\r\n", - "samples = 7\r\n", - "value = [0.0, 9.167]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "6->8\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "10\r\n", - "\r\n", - "Alpha-Fetoprotein (ng/mL) <= 6993.726839163693\r\n", - "gini = 0.17\r\n", - "samples = 50\r\n", - "value = [38.015, 3.929]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "9->10\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "13\r\n", - "\r\n", - "gini = 0.283\r\n", - "samples = 4\r\n", - "value = [0.809, 3.929]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "9->13\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "11\r\n", - "\r\n", - "gini = 0.067\r\n", - "samples = 46\r\n", - "value = [36.397, 1.31]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "10->11\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "12\r\n", - "\r\n", - "gini = 0.472\r\n", - "samples = 4\r\n", - "value = [1.618, 2.619]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "10->12\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "15\r\n", - "\r\n", - "Haemoglobin (g/dL) <= 13.70028074819275\r\n", - "gini = 0.225\r\n", - "samples = 31\r\n", - "value = [4.853, 32.738]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "14->15\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "20\r\n", - "\r\n", - "gini = 0.41\r\n", - "samples = 5\r\n", - "value = [3.235, 1.31]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "14->20\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "16\r\n", - "\r\n", - "Haemoglobin (g/dL) <= 10.150302369912593\r\n", - "gini = 0.138\r\n", - "samples = 26\r\n", - "value = [2.426, 30.119]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "15->16\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "19\r\n", - "\r\n", - "gini = 0.499\r\n", - "samples = 5\r\n", - "value = [2.426, 2.619]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "15->19\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "17\r\n", - "\r\n", - "gini = 0.499\r\n", - "samples = 5\r\n", - "value = [2.426, 2.619]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "16->17\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "18\r\n", - "\r\n", - "gini = 0.0\r\n", - "samples = 21\r\n", - "value = [0.0, 27.5]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "16->18\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------------------------\n", - "hcc_data- CV Dataset: 2\n", - "---------------------------------------\n" - ] - }, - { - "data": { - "image/svg+xml": [ - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "Tree\r\n", - "\r\n", - "\r\n", - "\r\n", - "0\r\n", - "\r\n", - "Performance Status* <= 1.0877695058930197\r\n", - "gini = 0.5\r\n", - "samples = 110\r\n", - "value = [55.0, 55.0]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1\r\n", - "\r\n", - "Liver Metastasis <= 0.5008\r\n", - "gini = 0.469\r\n", - "samples = 74\r\n", - "value = [43.676, 26.19]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "0->1\r\n", - "\r\n", - "\r\n", - "True\r\n", - "\r\n", - "\r\n", - "\r\n", - "16\r\n", - "\r\n", - "Packs of cigarets per year <= 25.677107666264774\r\n", - "gini = 0.405\r\n", - "samples = 36\r\n", - "value = [11.324, 28.81]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "0->16\r\n", - "\r\n", - "\r\n", - "False\r\n", - "\r\n", - "\r\n", - "\r\n", - "2\r\n", - "\r\n", - "Leukocytes(G/L) <= 8411.74748058586\r\n", - "gini = 0.384\r\n", - "samples = 62\r\n", - "value = [41.25, 14.405]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1->2\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "15\r\n", - "\r\n", - "gini = 0.283\r\n", - "samples = 12\r\n", - "value = [2.426, 11.786]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1->15\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "3\r\n", - "\r\n", - "Alpha-Fetoprotein (ng/mL) <= 64921.747173670476\r\n", - "gini = 0.349\r\n", - "samples = 59\r\n", - "value = [40.441, 11.786]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "2->3\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "14\r\n", - "\r\n", - "gini = 0.361\r\n", - "samples = 3\r\n", - "value = [0.809, 2.619]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "2->14\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "4\r\n", - "\r\n", - "Ascites degree* <= 2.0146190415203025\r\n", - "gini = 0.301\r\n", - "samples = 57\r\n", - "value = [40.441, 9.167]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "3->4\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "13\r\n", - "\r\n", - "gini = 0.0\r\n", - "samples = 2\r\n", - "value = [0.0, 2.619]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "3->13\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "5\r\n", - "\r\n", - "Alanine transaminase (U/L) <= 78.96329486671726\r\n", - "gini = 0.251\r\n", - "samples = 52\r\n", - "value = [38.015, 6.548]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "4->5\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "12\r\n", - "\r\n", - "gini = 0.499\r\n", - "samples = 5\r\n", - "value = [2.426, 2.619]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "4->12\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "6\r\n", - "\r\n", - "Leukocytes(G/L) <= 5948.849154070616\r\n", - "gini = 0.151\r\n", - "samples = 38\r\n", - "value = [29.118, 2.619]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "5->6\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "11\r\n", - "\r\n", - "gini = 0.425\r\n", - "samples = 14\r\n", - "value = [8.897, 3.929]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "5->11\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "7\r\n", - "\r\n", - "Aspartate transaminase (U/L) <= 86.68327064917162\r\n", - "gini = 0.089\r\n", - "samples = 34\r\n", - "value = [26.691, 1.31]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "6->7\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "10\r\n", - "\r\n", - "gini = 0.455\r\n", - "samples = 4\r\n", - "value = [2.426, 1.31]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "6->10\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "8\r\n", - "\r\n", - "gini = 0.0\r\n", - "samples = 31\r\n", - "value = [25.074, 0.0]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "7->8\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "9\r\n", - "\r\n", - "gini = 0.494\r\n", - "samples = 3\r\n", - "value = [1.618, 1.31]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "7->9\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "17\r\n", - "\r\n", - "Haemoglobin (g/dL) <= 12.890429266232424\r\n", - "gini = 0.331\r\n", - "samples = 30\r\n", - "value = [7.279, 27.5]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "16->17\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "20\r\n", - "\r\n", - "gini = 0.37\r\n", - "samples = 6\r\n", - "value = [4.044, 1.31]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "16->20\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "18\r\n", - "\r\n", - "gini = 0.196\r\n", - "samples = 18\r\n", - "value = [2.426, 19.643]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "17->18\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "19\r\n", - "\r\n", - "gini = 0.472\r\n", - "samples = 12\r\n", - "value = [4.853, 7.857]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "17->19\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ROC AUC values for each CV training set with DT:\n", - "[0.6190476190476191, 0.6358543417366946, 0.7093837535014005]\n", - "Best ROC AUC: 0.7093837535014005\n", - "---------------------------------------\n", - "hcc_data_custom- CV Dataset: 2\n", - "---------------------------------------\n" - ] - }, - { - "data": { - "image/svg+xml": [ - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "Tree\r\n", - "\r\n", - "\r\n", - "\r\n", - "0\r\n", - "\r\n", - "Haemoglobin (g/dL) <= 14.60460111628038\r\n", - "gini = 0.5\r\n", - "samples = 110\r\n", - "value = [55.0, 55.0]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1\r\n", - "\r\n", - "Performance Status* <= 0.12952903473512356\r\n", - "gini = 0.482\r\n", - "samples = 82\r\n", - "value = [34.779, 51.071]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "0->1\r\n", - "\r\n", - "\r\n", - "True\r\n", - "\r\n", - "\r\n", - "\r\n", - "4\r\n", - "\r\n", - "gini = 0.272\r\n", - "samples = 28\r\n", - "value = [20.221, 3.929]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "0->4\r\n", - "\r\n", - "\r\n", - "False\r\n", - "\r\n", - "\r\n", - "\r\n", - "2\r\n", - "\r\n", - "gini = 0.477\r\n", - "samples = 35\r\n", - "value = [20.221, 13.095]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1->2\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "3\r\n", - "\r\n", - "gini = 0.401\r\n", - "samples = 47\r\n", - "value = [14.559, 37.976]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1->3\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------------------------\n", - "hcc_data_custom- CV Dataset: 2\n", - "---------------------------------------\n" - ] - }, - { - "data": { - "image/svg+xml": [ - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "Tree\r\n", - "\r\n", - "\r\n", - "\r\n", - "0\r\n", - "\r\n", - "Alkaline phosphatase (U/L) <= 200.27869936913353\r\n", - "gini = 0.472\r\n", - "samples = 110\r\n", - "value = [68, 42]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1\r\n", - "\r\n", - "Direct Bilirubin (mg/dL) <= 0.5201246330852103\r\n", - "gini = 0.339\r\n", - "samples = 74\r\n", - "value = [58, 16]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "0->1\r\n", - "\r\n", - "\r\n", - "True\r\n", - "\r\n", - "\r\n", - "\r\n", - "4\r\n", - "\r\n", - "gini = 0.401\r\n", - "samples = 36\r\n", - "value = [10, 26]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "0->4\r\n", - "\r\n", - "\r\n", - "False\r\n", - "\r\n", - "\r\n", - "\r\n", - "2\r\n", - "\r\n", - "gini = 0.142\r\n", - "samples = 39\r\n", - "value = [36, 3]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1->2\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "3\r\n", - "\r\n", - "gini = 0.467\r\n", - "samples = 35\r\n", - "value = [22, 13]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1->3\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------------------------\n", - "hcc_data_custom- CV Dataset: 2\n", - "---------------------------------------\n" - ] - }, - { - "data": { - "image/svg+xml": [ - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "Tree\r\n", - "\r\n", - "\r\n", - "\r\n", - "0\r\n", - "\r\n", - "Alpha-Fetoprotein (ng/mL) <= 101.77739983759238\r\n", - "gini = 0.5\r\n", - "samples = 110\r\n", - "value = [55.0, 55.0]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1\r\n", - "\r\n", - "Iron <= 67.43046466629525\r\n", - "gini = 0.432\r\n", - "samples = 63\r\n", - "value = [39.632, 18.333]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "0->1\r\n", - "\r\n", - "\r\n", - "True\r\n", - "\r\n", - "\r\n", - "\r\n", - "8\r\n", - "\r\n", - "Aspartate transaminase (U/L) <= 154.9697624512269\r\n", - "gini = 0.416\r\n", - "samples = 47\r\n", - "value = [15.368, 36.667]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "0->8\r\n", - "\r\n", - "\r\n", - "False\r\n", - "\r\n", - "\r\n", - "\r\n", - "2\r\n", - "\r\n", - "gini = 0.492\r\n", - "samples = 18\r\n", - "value = [8.088, 10.476]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1->2\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "3\r\n", - "\r\n", - "Sim_Cat_3_3 <= 0.8376005050499682\r\n", - "gini = 0.319\r\n", - "samples = 45\r\n", - "value = [31.544, 7.857]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "1->3\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "4\r\n", - "\r\n", - "Encephalopathy degree* <= 1.0841330450935065\r\n", - "gini = 0.094\r\n", - "samples = 32\r\n", - "value = [25.074, 1.31]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "3->4\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "7\r\n", - "\r\n", - "gini = 0.5\r\n", - "samples = 13\r\n", - "value = [6.471, 6.548]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "3->7\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "5\r\n", - "\r\n", - "gini = 0.0\r\n", - "samples = 26\r\n", - "value = [21.029, 0.0]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "4->5\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "6\r\n", - "\r\n", - "gini = 0.37\r\n", - "samples = 6\r\n", - "value = [4.044, 1.31]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "4->6\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "9\r\n", - "\r\n", - "Mean Corpuscular Volume <= 93.55348786144594\r\n", - "gini = 0.454\r\n", - "samples = 41\r\n", - "value = [15.368, 28.81]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "8->9\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "12\r\n", - "\r\n", - "gini = 0.0\r\n", - "samples = 6\r\n", - "value = [0.0, 7.857]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "8->12\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "10\r\n", - "\r\n", - "gini = 0.158\r\n", - "samples = 15\r\n", - "value = [1.618, 17.024]\r\n", - "class = y[1]\r\n", - "\r\n", - "\r\n", - "\r\n", - "9->10\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "11\r\n", - "\r\n", - "gini = 0.497\r\n", - "samples = 26\r\n", - "value = [13.75, 11.786]\r\n", - "class = y[0]\r\n", - "\r\n", - "\r\n", - "\r\n", - "9->11\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "for each in datasets: #each analyzed dataset to make plots for\n", - " if do_DT:\n", - " #Create folder for tree vizualization files\n", - " if not os.path.exists(experiment_path+'/'+each+'/model_evaluation/DT_Viz'):\n", - " os.mkdir(experiment_path+'/'+each+'/model_evaluation/DT_Viz')\n", - " #Open results dictionary to get metric for each CV\n", - " cvMetrics = pd.read_csv(experiment_path+'/'+each+'/model_evaluation/DT_performance.csv',na_values='NA',sep=',')\n", - " metric_cv_list = cvMetrics[targetMetric].tolist()\n", - " #identify best CV\n", - " max_value = max(metric_cv_list)\n", - " max_index = metric_cv_list.index(max_value)\n", - " # Vizualize best performing model\n", - " print(str(targetMetric)+\" values for each CV training set with DT:\")\n", - " print(str(metric_cv_list))\n", - " print(\"Best \"+str(targetMetric)+\": \"+str(max_value))\n", - " for cvCount in range(0,int(cv_partitions)):\n", - " graph = generateTreePlot(experiment_path,each,algInfo['Decision Tree'][1],cvCount,max_index,scale_data,class_label,instance_label,inverseScaling,targetMetric)\n", - " print(\"---------------------------------------\")\n", - " print(each+\"- CV Dataset: \"+str(max_index))\n", - " print(\"---------------------------------------\")\n", - " graph\n", - " \n", - " if do_GP:\n", - " #Create folder for tree vizualization files\n", - " if not os.path.exists(experiment_path+'/'+each+'/model_evaluation/GP_Viz'):\n", - " os.mkdir(experiment_path+'/'+each+'/model_evaluation/GP_Viz')\n", - "\n", - " #Open results dictionary to get metric for each CV\n", - " cvMetrics = pd.read_csv(experiment_path+'/'+each+'/model_evaluation/GP_performance.csv',na_values='NA',sep=',')\n", - " metric_cv_list = cvMetrics[targetMetric].tolist()\n", - " #identify best CV\n", - " max_value = max(metric_cv_list)\n", - " max_index = metric_cv_list.index(max_value)\n", - " # Vizualize best performing model\n", - " print(str(targetMetric)+\" values for each CV training set with GP:\")\n", - " print(str(metric_cv_list))\n", - " print(\"Best \"+str(targetMetric)+\": \"+str(max_value))\n", - " for cvCount in range(0,int(cv_partitions)):\n", - " graph = generateGPPlot(experiment_path,each,algInfo['Genetic Programming'][1],cvCount,max_index,scale_data,class_label,instance_label,targetMetric)\n", - " print(\"---------------------------------------\")\n", - " print(each+\"- CV Dataset: \"+str(max_index))\n", - " print(\"---------------------------------------\")\n", - " graph" - ] - } - ], - "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.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/UsefulNotebooks/PredictionProbs_Replication.ipynb b/UsefulNotebooks/PredictionProbs_Replication.ipynb deleted file mode 100644 index 9da6cb63..00000000 --- a/UsefulNotebooks/PredictionProbs_Replication.ipynb +++ /dev/null @@ -1,518 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Useful Notebook: Report Replication Data Prediction Probabilities\n", - "**This notebook will generate model (class 1) prediction probabilities for instances of respective replication dataset.**\n", - "\n", - "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6 and phase 8 - replication) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", - "\n", - "***\n", - "## Notebook Details\n", - "STREAMLINE outputs pickled objects with all the metric results during the initial testing evaluation of trained models as well as following application of trained models to additional hold out replication data.\n", - "\n", - "This notebook grabs these prediction probabilities for a specific replication dataset and reports them as .csv files for each algorithm and CV partition pair (i.e for each of the CV trained models).\n", - "\n", - "When run, the last code cell will generate a new folder (`prediction_probas`) in the pipeline's output experiment folder in the `/replication/[REPDATANAME]/model_evaluation` folder of the `dataset` specified below. Here the class 1 prediction probabilities are reported as a `.csv` file for each algorithm and CV partition pair. In these files is the instance's true outcome value, the unique instance ID, and the predicted probability of the instance being class 1 (i.e. which typically encodes cases or the less frequent class). \n", - "\n", - "* *This code is set up to run on a specific pair of an original dataset and a paired replication dataset one at a time.*\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Notebook Run Parameters\n", - "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed). \n", - "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "experiment_path = \"../DemoOutput/demo_experiment\" # path the target experiment folder \n", - "dataname = 'hcc_data_custom' #name of target dataset folder in experiment output folder from pipeline\n", - "rep_dataname =\"hcc_data_custom_rep\"#path to replication dataset file (needed to grab instance labels and true class values)\n", - "algorithms = [] # use empty list if user wishes re-evaluate all modeling algorithms that were run in pipeline, otherwise specify a (str) list of algorithm identifiers." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Housekeeping\n", - "### Import Packages" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import pandas as pd\n", - "import pickle\n", - "import numpy as np\n", - "from statistics import mean\n", - "from scipy import interp,stats\n", - "import warnings\n", - "warnings.filterwarnings('ignore')\n", - "\n", - "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", - "from IPython.core.interactiveshell import InteractiveShell\n", - "InteractiveShell.ast_node_interactivity = \"all\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load Other Necessary Parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Algorithms Ran: ['Decision Tree', 'Logistic Regression', 'Naive Bayes']\n" - ] - } - ], - "source": [ - "# Unpickle metadata from previous phase\n", - "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", - "metadata = pickle.load(file)\n", - "file.close()\n", - "# Load variables specified earlier in the pipeline from metadata\n", - "class_label = metadata['Class Label']\n", - "instance_label = metadata['Instance Label']\n", - "cv_partitions = int(metadata['CV Partitions'])\n", - "\n", - "# Unpickle algorithm information from previous phase\n", - "file = open(experiment_path+'/'+\"algInfo.pickle\", 'rb')\n", - "algInfo = pickle.load(file)\n", - "file.close()\n", - "algorithms = []\n", - "abbrev = {}\n", - "colors = {}\n", - "for key in algInfo:\n", - " if algInfo[key][0]: # If that algorithm was used\n", - " algorithms.append(key)\n", - " abbrev[key] = (algInfo[key][1])\n", - " colors[key] = (algInfo[key][2])\n", - " \n", - "print(\"Algorithms Ran: \" + str(algorithms))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Extract and Output Replication Data Prediction Probabilities " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Algorithm: Decision Tree\n", - "CV: 0\n", - "[0.39306358 0.39306358 0.39306358 0.39306358 0.39306358 0.7228739\n", - " 0.39306358 0.7228739 0.7228739 0.16267943 0.39306358 0.16267943\n", - " 0.16267943 0.39306358 0.7228739 0.39306358 0.7228739 0.7228739\n", - " 0.7228739 0.39306358 0.39306358 0.16267943 0.7228739 0.7228739\n", - " 0.39306358 0.7228739 0.39306358 0.16267943 0.7228739 0.39306358\n", - " 0.16267943 0.39306358 0.16267943 0.39306358 0.39306358 0.16267943\n", - " 0.39306358 0.7228739 0.16267943 0.39306358 0.39306358 0.16267943\n", - " 0.7228739 0.16267943 0.16267943 0.39306358 0.39306358 0.7228739\n", - " 0.39306358 0.16267943 0.7228739 0.16267943 0.39306358 0.16267943\n", - " 0.7228739 0.7228739 0.39306358 0.39306358 0.7228739 0.16267943\n", - " 0.39306358 0.39306358 0.7228739 0.7228739 0.39306358 0.16267943\n", - " 0.7228739 0.16267943 0.39306358 0.7228739 0.39306358 0.7228739\n", - " 0.7228739 0.39306358 0.16267943 0.39306358 0.7228739 0.39306358\n", - " 0.7228739 0.7228739 0.7228739 0.16267943 0.39306358 0.7228739\n", - " 0.39306358 0.39306358 0.7228739 0.16267943 0.39306358 0.7228739\n", - " 0.7228739 0.39306358 0.7228739 0.39306358 0.39306358 0.39306358\n", - " 0.7228739 0.39306358 0.7228739 0.7228739 0.7228739 0.39306358\n", - " 0.7228739 0.7228739 0.7228739 0.39306358 0.39306358 0.7228739\n", - " 0.7228739 0.39306358 0.16267943 0.7228739 0.16267943 0.16267943\n", - " 0.7228739 0.39306358 0.39306358 0.39306358 0.16267943 0.7228739\n", - " 0.39306358 0.7228739 0.16267943 0.7228739 0.7228739 0.39306358\n", - " 0.7228739 0.7228739 0.7228739 0.16267943 0.7228739 0.7228739\n", - " 0.7228739 0.39306358 0.7228739 0.16267943 0.39306358 0.39306358\n", - " 0.16267943 0.39306358 0.39306358 0.16267943 0.39306358 0.16267943\n", - " 0.7228739 0.7228739 0.39306358 0.39306358 0.7228739 0.16267943\n", - " 0.39306358 0.7228739 0.39306358 0.39306358 0.7228739 0.7228739\n", - " 0.16267943 0.39306358 0.7228739 0.16267943 0.7228739 0.39306358\n", - " 0.16267943 0.39306358 0.7228739 0.7228739 0.39306358 0.39306358\n", - " 0.16267943 0.16267943]\n", - "CV: 1\n", - "[0.07692308 0.37142857 0.37142857 0.07692308 0.07692308 0.72222222\n", - " 0.72222222 0.72222222 0.37142857 0.72222222 0.72222222 0.07692308\n", - " 0.72222222 0.37142857 0.37142857 0.72222222 0.72222222 0.37142857\n", - " 0.07692308 0.37142857 0.37142857 0.07692308 0.07692308 0.72222222\n", - " 0.07692308 0.72222222 0.07692308 0.37142857 0.72222222 0.72222222\n", - " 0.37142857 0.07692308 0.07692308 0.72222222 0.37142857 0.07692308\n", - " 0.72222222 0.72222222 0.07692308 0.72222222 0.07692308 0.07692308\n", - " 0.37142857 0.07692308 0.07692308 0.07692308 0.37142857 0.72222222\n", - " 0.37142857 0.07692308 0.72222222 0.72222222 0.07692308 0.07692308\n", - " 0.72222222 0.37142857 0.72222222 0.37142857 0.72222222 0.37142857\n", - " 0.37142857 0.72222222 0.37142857 0.07692308 0.07692308 0.07692308\n", - " 0.37142857 0.37142857 0.37142857 0.07692308 0.37142857 0.72222222\n", - " 0.37142857 0.72222222 0.07692308 0.72222222 0.37142857 0.07692308\n", - " 0.72222222 0.37142857 0.72222222 0.37142857 0.07692308 0.72222222\n", - " 0.37142857 0.07692308 0.72222222 0.07692308 0.37142857 0.72222222\n", - " 0.37142857 0.07692308 0.72222222 0.37142857 0.07692308 0.72222222\n", - " 0.72222222 0.37142857 0.72222222 0.37142857 0.72222222 0.07692308\n", - " 0.07692308 0.72222222 0.72222222 0.07692308 0.37142857 0.37142857\n", - " 0.07692308 0.37142857 0.37142857 0.37142857 0.07692308 0.07692308\n", - " 0.37142857 0.72222222 0.07692308 0.37142857 0.72222222 0.72222222\n", - " 0.72222222 0.72222222 0.07692308 0.72222222 0.72222222 0.07692308\n", - " 0.37142857 0.37142857 0.07692308 0.07692308 0.72222222 0.37142857\n", - " 0.37142857 0.37142857 0.07692308 0.72222222 0.07692308 0.37142857\n", - " 0.07692308 0.72222222 0.37142857 0.07692308 0.37142857 0.07692308\n", - " 0.72222222 0.72222222 0.37142857 0.07692308 0.37142857 0.07692308\n", - " 0.07692308 0.07692308 0.72222222 0.72222222 0.37142857 0.07692308\n", - " 0.07692308 0.72222222 0.37142857 0.07692308 0.37142857 0.37142857\n", - " 0.37142857 0.72222222 0.37142857 0.07692308 0.07692308 0.07692308\n", - " 0.07692308 0.07692308]\n", - "CV: 2\n", - "[0.46153846 0.46153846 0.56431535 0.46153846 0.56431535 0.91322314\n", - " 1. 0.91322314 0.50295858 0.50295858 1. 1.\n", - " 0.46153846 0. 0.50295858 0.46153846 0.46153846 0.\n", - " 0.91322314 0.56431535 0.50295858 0.50295858 0. 0.91322314\n", - " 0. 0.46153846 0.50295858 0.50295858 0.91322314 0.\n", - " 0.46153846 0.50295858 0.56431535 0.46153846 0.46153846 0.50295858\n", - " 0. 0.46153846 0. 0.91322314 0. 0.\n", - " 0.50295858 0. 0.46153846 0.50295858 0.46153846 0.56431535\n", - " 0.46153846 0.50295858 0.56431535 0.24460432 0. 0.\n", - " 1. 1. 0.91322314 0.56431535 0.56431535 0.91322314\n", - " 0.24460432 0.50295858 0.46153846 0. 0.56431535 0.56431535\n", - " 0.56431535 0.46153846 0.46153846 0.46153846 0.91322314 0.46153846\n", - " 0.46153846 0. 0.56431535 0. 0.46153846 0.50295858\n", - " 0.56431535 0.24460432 0.56431535 0.50295858 0.46153846 0.50295858\n", - " 0. 0.56431535 0.56431535 0. 0.91322314 0.24460432\n", - " 0.91322314 0. 0.46153846 0.46153846 0. 1.\n", - " 0. 0. 0.46153846 0. 0.46153846 0.56431535\n", - " 0.50295858 1. 0. 1. 0.56431535 0.56431535\n", - " 0.46153846 0. 0.46153846 1. 0. 0.\n", - " 0.46153846 0.91322314 0.50295858 0.50295858 0.50295858 0.46153846\n", - " 0.56431535 1. 0. 0.91322314 0.91322314 0.\n", - " 0.46153846 0.56431535 0.24460432 0.50295858 0.46153846 0.\n", - " 0.46153846 0. 0.56431535 0.91322314 0.24460432 0.50295858\n", - " 0.56431535 0.91322314 0.46153846 0. 0. 0.\n", - " 0.24460432 0.91322314 0.56431535 0.56431535 0. 0.91322314\n", - " 0. 0.46153846 0.91322314 0.46153846 0.46153846 0.50295858\n", - " 0. 0.46153846 0.56431535 0.46153846 0. 0.\n", - " 0.46153846 0.46153846 0.46153846 0.46153846 0.46153846 0.56431535\n", - " 0.56431535 0. ]\n", - "Algorithm: Logistic Regression\n", - "CV: 0\n", - "[0.49534041 0.49888709 0.50201429 0.49767499 0.49669748 0.50138653\n", - " 0.50044446 0.50241338 0.50181543 0.49949531 0.49924569 0.49438219\n", - " 0.49894924 0.4976448 0.50120487 0.49781333 0.50031647 0.50372162\n", - " 0.49872813 0.49765179 0.49671395 0.49320597 0.50068305 0.5051638\n", - " 0.49676574 0.50092144 0.50145725 0.4954995 0.50114244 0.49946409\n", - " 0.49982354 0.49910722 0.49660974 0.49678497 0.49624706 0.49712472\n", - " 0.49940948 0.4988254 0.49518287 0.50127127 0.49656363 0.49772033\n", - " 0.50385518 0.49363547 0.49717114 0.49701494 0.49896716 0.50489191\n", - " 0.49836886 0.49636166 0.50531303 0.50149751 0.49534901 0.49736934\n", - " 0.50794868 0.50157229 0.49904997 0.49835936 0.50480577 0.49456697\n", - " 0.50065931 0.4995872 0.49977498 0.49970967 0.49622699 0.50108596\n", - " 0.49918712 0.50067506 0.49912212 0.49989678 0.49791418 0.50494711\n", - " 0.50239815 0.5054784 0.49598444 0.50266891 0.50368161 0.49630493\n", - " 0.50086641 0.50701336 0.50177897 0.49693297 0.50093208 0.50295502\n", - " 0.49887413 0.49965774 0.50003155 0.49337832 0.49835174 0.50154258\n", - " 0.50197713 0.49580408 0.49886378 0.50167838 0.49632535 0.49884257\n", - " 0.5002302 0.49707595 0.5005323 0.50325582 0.50191384 0.50028475\n", - " 0.49866936 0.51486583 0.49828368 0.5005329 0.49798282 0.50433121\n", - " 0.50228221 0.49865868 0.50158682 0.50765105 0.4964301 0.49936704\n", - " 0.50492199 0.5005842 0.49809446 0.49611165 0.49704673 0.5027939\n", - " 0.50080759 0.50510359 0.49348274 0.50432684 0.50441907 0.49723752\n", - " 0.50087408 0.50049076 0.50024311 0.5022457 0.49942054 0.50139722\n", - " 0.49854129 0.49818313 0.49925683 0.49782421 0.49614141 0.49663962\n", - " 0.49993691 0.50032315 0.49959971 0.49776281 0.49831484 0.49963585\n", - " 0.50299112 0.50382355 0.49819692 0.49594549 0.49955964 0.49272576\n", - " 0.49438708 0.50134129 0.49744654 0.49810805 0.50496364 0.49757198\n", - " 0.49654493 0.50109537 0.50545241 0.49194302 0.50084317 0.49863092\n", - " 0.49897595 0.50727909 0.50065144 0.50019049 0.50093208 0.49996658\n", - " 0.50108596 0.49984976]\n", - "CV: 1\n", - "[0.49417914 0.49934229 0.4994559 0.49978395 0.49699443 0.50326344\n", - " 0.49793822 0.50679402 0.50323717 0.49821271 0.50224134 0.49326612\n", - " 0.49873356 0.49581321 0.49744788 0.49960835 0.49815085 0.50120963\n", - " 0.49666613 0.49745417 0.49500966 0.49166134 0.4966295 0.51282382\n", - " 0.49807159 0.49828142 0.49729582 0.49159547 0.5019404 0.49918688\n", - " 0.50119926 0.49635112 0.49636924 0.49986035 0.49302959 0.49497992\n", - " 0.49980932 0.50201168 0.49471105 0.50433629 0.49390193 0.49818573\n", - " 0.50580565 0.4917973 0.4940194 0.4983302 0.496704 0.50792869\n", - " 0.50373392 0.49131055 0.50358928 0.50286488 0.49483157 0.49276313\n", - " 0.51109877 0.50257101 0.49812423 0.49784287 0.50747401 0.49668245\n", - " 0.49780403 0.49394711 0.50033498 0.50123279 0.497793 0.49972565\n", - " 0.49746228 0.50206481 0.50145855 0.50087856 0.49394952 0.54008415\n", - " 0.50138831 0.50649449 0.49364103 0.50383116 0.50125573 0.49392383\n", - " 0.50326685 0.50446537 0.50173086 0.49399979 0.49854687 0.49890217\n", - " 0.50003931 0.50072249 0.50182964 0.48909792 0.49999801 0.50433567\n", - " 0.50219178 0.49342052 0.50107982 0.49890589 0.49535676 0.49875834\n", - " 0.5028773 0.49813991 0.50127701 0.50058794 0.50428752 0.50167393\n", - " 0.50033571 0.51870485 0.5003806 0.49988284 0.499182 0.5089707\n", - " 0.50283171 0.49559923 0.49687309 0.50822726 0.49230972 0.49681539\n", - " 0.5052011 0.50054243 0.49868534 0.49618323 0.49567526 0.51002111\n", - " 0.50192922 0.50520448 0.49178262 0.50617477 0.51094666 0.50306785\n", - " 0.49887567 0.50248216 0.49852624 0.50080407 0.50115 0.50014882\n", - " 0.49668925 0.49609727 0.50229607 0.49631646 0.49439222 0.49341445\n", - " 0.50451396 0.49708096 0.50465277 0.49547626 0.49520983 0.49436584\n", - " 0.50263966 0.51036192 0.49856078 0.49513379 0.49660167 0.49007758\n", - " 0.49149696 0.50332736 0.50013539 0.49695148 0.50245629 0.49423058\n", - " 0.49970624 0.5004102 0.50312417 0.49205973 0.50152441 0.50094537\n", - " 0.50416333 0.5107239 0.49891333 0.49778307 0.49873428 0.50157216\n", - " 0.49972565 0.49484079]\n", - "CV: 2\n", - "[0.15239928 0.45996858 0.65766578 0.30590761 0.251534 0.45944333\n", - " 0.33289458 0.69374734 0.62887107 0.41735708 0.52161541 0.2058136\n", - " 0.39943911 0.27018211 0.47061259 0.38841635 0.50336009 0.43555523\n", - " 0.53233184 0.35795422 0.30742753 0.22026122 0.46088948 0.70200164\n", - " 0.39598835 0.40045227 0.40612169 0.23538628 0.33049569 0.40013152\n", - " 0.49800212 0.42035851 0.3661809 0.36032281 0.29695717 0.45280746\n", - " 0.35967118 0.45305899 0.25751045 0.52993546 0.27748314 0.47193849\n", - " 0.64282687 0.13992805 0.25202859 0.42142141 0.39361016 0.73298869\n", - " 0.5456813 0.32156885 0.76340774 0.55251258 0.20658144 0.21436083\n", - " 0.85557832 0.61216076 0.45382046 0.27214988 0.72151245 0.31155052\n", - " 0.41817749 0.32441489 0.35170034 0.4415247 0.27507516 0.59882048\n", - " 0.43553484 0.57743593 0.45767299 0.58019692 0.26829608 0.73095968\n", - " 0.59285428 0.71008276 0.31377001 0.55121495 0.74197716 0.32604847\n", - " 0.60080817 0.69504904 0.58837349 0.2074762 0.43884172 0.59980489\n", - " 0.39668582 0.58119447 0.50596774 0.14996061 0.30706191 0.36846406\n", - " 0.65566049 0.17489787 0.57982715 0.50882902 0.24590829 0.45422076\n", - " 0.41256804 0.33824826 0.50182921 0.49425142 0.53216178 0.75708762\n", - " 0.53226958 0.95510114 0.42294514 0.60115499 0.45405635 0.66208183\n", - " 0.6301058 0.36052469 0.60451223 0.79119768 0.24343209 0.51167468\n", - " 0.58952191 0.47058325 0.51217478 0.27330791 0.48224439 0.60421235\n", - " 0.52008419 0.64329876 0.19024327 0.77161876 0.71187659 0.42067656\n", - " 0.47163489 0.17852688 0.47302425 0.66319971 0.35419048 0.43530417\n", - " 0.27323883 0.38046006 0.58210037 0.38443484 0.21895693 0.28670067\n", - " 0.70642965 0.53024454 0.3751706 0.27941074 0.27732428 0.32870212\n", - " 0.58228252 0.75741344 0.37586281 0.34609483 0.44989869 0.1928648\n", - " 0.20537833 0.54073427 0.38498294 0.39318635 0.79013399 0.35658918\n", - " 0.36649914 0.49889941 0.65592462 0.28074405 0.51351922 0.44932567\n", - " 0.68872822 0.6766802 0.4344091 0.51075299 0.43884172 0.72748775\n", - " 0.59882048 0.35145973]\n", - "Algorithm: Naive Bayes\n", - "CV: 0\n", - "[9.95853212e-01 9.86539313e-01 9.99999813e-01 9.57739232e-01\n", - " 6.28351329e-01 9.99522057e-01 9.89764293e-01 9.99956674e-01\n", - " 9.99956320e-01 9.98403825e-01 8.13730643e-01 0.00000000e+00\n", - " 9.92163194e-01 9.53358378e-01 9.99999996e-01 9.40279182e-01\n", - " 9.95340053e-01 9.99999988e-01 5.24955950e-01 9.24635779e-01\n", - " 6.90702498e-01 2.57525978e-03 9.99921463e-01 0.00000000e+00\n", - " 6.30149096e-01 9.99800131e-01 1.00000000e+00 2.96112634e-03\n", - " 9.99989318e-01 0.00000000e+00 9.97842585e-01 9.97158859e-01\n", - " 4.04115594e-01 1.06254607e-01 1.75126635e-01 8.02753471e-01\n", - " 9.72842273e-01 5.68633272e-01 1.68288600e-02 0.00000000e+00\n", - " 3.25779094e-01 6.47718603e-01 1.00000000e+00 3.51235313e-09\n", - " 8.41365157e-01 1.69647131e-01 8.97976004e-01 1.00000000e+00\n", - " 8.85612851e-03 3.07781640e-02 9.99999996e-01 9.99999979e-01\n", - " 5.01214118e-01 9.99843039e-01 1.00000000e+00 9.99999975e-01\n", - " 9.97467229e-01 9.68442576e-01 9.99999739e-01 4.28498316e-03\n", - " 9.99940994e-01 9.94666330e-01 9.95752814e-01 9.98099465e-01\n", - " 9.58647560e-02 9.99651197e-01 9.91702602e-01 9.99999922e-01\n", - " 9.93540219e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 9.99995887e-01 9.99999997e-01 7.64851217e-02 9.99444696e-01\n", - " 9.99999816e-01 8.24737631e-02 9.99084230e-01 1.00000000e+00\n", - " 9.99990940e-01 1.95393828e-01 9.97248417e-01 9.99998434e-01\n", - " 9.13264414e-01 9.91776863e-01 9.88032185e-01 0.00000000e+00\n", - " 9.25110947e-01 9.99993619e-01 9.99949155e-01 1.58653991e-03\n", - " 9.69392398e-01 9.99999999e-01 2.64319827e-01 9.35644975e-01\n", - " 0.00000000e+00 6.81891532e-01 9.75071170e-01 1.00000000e+00\n", - " 9.99709020e-01 9.99983680e-01 6.25849758e-01 1.00000000e+00\n", - " 1.00000000e+00 9.99881081e-01 1.17672951e-09 9.99999951e-01\n", - " 1.25052555e-01 9.03806978e-01 9.99983782e-01 1.00000000e+00\n", - " 1.22547715e-01 9.93113133e-01 1.00000000e+00 9.99984298e-01\n", - " 6.18951118e-01 9.96446041e-01 5.04950917e-01 0.00000000e+00\n", - " 9.99575653e-01 9.99999880e-01 2.85828475e-03 1.00000000e+00\n", - " 1.15558492e-14 2.78888816e-01 9.99979746e-01 1.00000000e+00\n", - " 9.99858521e-01 9.99999203e-01 9.81745844e-01 9.99978960e-01\n", - " 9.64148791e-01 8.75404761e-01 9.94192528e-01 0.00000000e+00\n", - " 5.29386165e-01 3.03590023e-07 9.98661891e-01 9.99805746e-01\n", - " 4.48430419e-21 9.99931473e-01 9.56173544e-01 9.95457789e-01\n", - " 9.99998839e-01 9.99999984e-01 9.50007833e-01 3.15003280e-01\n", - " 9.96740110e-01 3.81689853e-04 1.03321633e-02 9.99983247e-01\n", - " 0.00000000e+00 1.00000000e+00 1.00000000e+00 2.83919376e-01\n", - " 2.60075032e-01 9.98453728e-01 1.00000000e+00 0.00000000e+00\n", - " 9.99532635e-01 9.98310381e-01 0.00000000e+00 1.00000000e+00\n", - " 1.00000000e+00 9.90620475e-01 9.97248417e-01 9.99974302e-01\n", - " 9.99651197e-01 9.97105003e-01]\n", - "CV: 1\n", - "[2.93906238e-07 1.27116780e-04 2.06789572e-03 1.05488891e-03\n", - " 7.56584598e-03 1.84654913e-02 4.74139387e-04 8.76282057e-01\n", - " 9.99999416e-01 1.53618933e-05 1.00000000e+00 1.75367845e-05\n", - " 1.00071773e-04 6.07650307e-06 3.69607993e-03 2.15557376e-02\n", - " 5.57301683e-05 6.79886872e-02 6.40447856e-04 8.22585600e-06\n", - " 8.36272479e-06 3.41171108e-07 7.09688189e-05 1.00000000e+00\n", - " 1.20383530e-03 4.09540249e-04 4.19295045e-04 7.90063918e-09\n", - " 9.26098802e-03 1.46838721e-02 5.17690840e-01 3.69834372e-06\n", - " 8.36557976e-06 3.57612854e-01 5.22407375e-08 4.39079743e-06\n", - " 6.12838491e-04 6.31077341e-03 1.98509778e-06 9.48432157e-01\n", - " 3.23827711e-06 7.07044791e-04 1.00000000e+00 2.03335355e-12\n", - " 6.48610420e-07 6.66753225e-05 6.72118212e-06 9.98930839e-01\n", - " 5.23594252e-01 1.36144703e-08 4.30107723e-01 6.72451716e-01\n", - " 2.95249869e-06 1.14543023e-07 9.99999840e-01 8.07635440e-01\n", - " 2.36546919e-04 3.47674814e-05 9.73369110e-01 9.45520598e-01\n", - " 3.58561812e-05 3.25114316e-07 2.24544660e-03 1.96867516e-01\n", - " 7.99607658e-05 7.00251906e-03 6.16869642e-06 1.20541451e-01\n", - " 2.06004307e-03 1.28783821e-02 2.43345858e-06 1.00000000e+00\n", - " 9.99999954e-01 9.99958780e-01 8.84869741e-08 1.03155878e-01\n", - " 9.99983256e-01 1.31611241e-07 5.83248043e-02 1.00000000e+00\n", - " 6.23429912e-02 1.53014492e-07 7.89228512e-01 3.17871039e-04\n", - " 5.50864209e-02 1.89662733e-04 2.07669883e-01 1.74357687e-09\n", - " 2.98999877e-03 3.67470279e-01 1.46405753e-02 3.74277250e-08\n", - " 5.10084355e-01 2.39624435e-04 3.49373350e-06 1.41544330e-04\n", - " 3.55977255e-03 2.03176280e-04 2.13574527e-04 7.53560199e-02\n", - " 1.65019381e-02 8.56440196e-01 2.07469813e-04 1.00000000e+00\n", - " 9.55881292e-04 1.00000000e+00 1.89113389e-10 9.99366607e-01\n", - " 2.02457966e-05 4.30383283e-07 7.64755537e-05 1.00000000e+00\n", - " 1.19070291e-08 5.00205306e-06 9.99999731e-01 5.79310374e-03\n", - " 9.29414339e-01 1.31999303e-03 1.79505385e-06 9.99993738e-01\n", - " 2.02864528e-02 1.00000000e+00 1.21159716e-07 9.66332113e-01\n", - " 1.00000000e+00 9.90721788e-01 9.51125954e-05 1.00000000e+00\n", - " 1.46141773e-04 1.35308426e-02 5.65945839e-02 3.08971385e-03\n", - " 5.45735138e-05 9.25357955e-07 2.59876756e-01 4.02819800e-06\n", - " 1.36511673e-06 1.67714026e-11 9.97914890e-01 2.56994490e-05\n", - " 1.00000000e+00 3.43500255e-05 9.20281857e-07 5.79221110e-07\n", - " 1.08479644e-01 1.00000000e+00 3.02606457e-05 2.19099082e-06\n", - " 2.14457391e-06 7.26963018e-09 1.01803773e-08 9.94310771e-01\n", - " 4.32904292e-01 1.00000000e+00 4.37509290e-01 1.40334829e-05\n", - " 2.75225781e-03 4.27450595e-04 9.53545761e-02 1.82360939e-05\n", - " 8.34766479e-01 8.44971657e-01 1.00000000e+00 1.00000000e+00\n", - " 3.51723865e-01 5.25059124e-06 8.12718623e-01 8.39502338e-01\n", - " 7.00251906e-03 1.04254069e-06]\n", - "CV: 2\n", - "[4.63065786e-011 1.06968704e-007 4.22507247e-003 5.60264574e-008\n", - " 2.95599836e-008 2.12628928e-007 1.08158631e-005 2.59936194e-004\n", - " 8.46004097e-001 4.05377086e-008 3.63581957e-006 3.69439090e-011\n", - " 2.78418036e-007 9.37599092e-010 5.42196258e-003 2.60692361e-008\n", - " 1.62748327e-007 1.12106860e-004 1.66079352e-007 2.46859829e-008\n", - " 2.50494900e-008 4.20626389e-010 3.59313449e-007 1.00000000e+000\n", - " 1.72350465e-008 1.03469469e-007 1.15911297e-001 2.89475802e-010\n", - " 3.48454463e-007 3.07320843e-006 1.18013001e-005 3.79919402e-006\n", - " 1.10456395e-008 1.46528644e-007 1.40540714e-009 1.13797762e-007\n", - " 3.92208270e-008 1.06038017e-007 1.10506902e-009 3.60938246e-007\n", - " 2.20813881e-009 4.72493991e-004 1.00000000e+000 3.35580239e-011\n", - " 1.52613919e-009 6.32913282e-008 8.29107318e-009 2.89030600e-001\n", - " 1.47638508e-004 2.54777131e-008 3.70482359e-003 9.17899898e-001\n", - " 7.96535946e-010 1.26640532e-009 9.99998950e-001 1.83823480e-003\n", - " 2.03703458e-006 1.23289597e-008 1.92812912e-002 1.24033443e-008\n", - " 1.81257835e-006 3.53354608e-007 9.84104371e-008 4.73953817e-007\n", - " 1.93293869e-009 6.96287139e-006 1.32769878e-008 5.01795340e-006\n", - " 3.34097249e-007 5.65164285e-007 1.34415827e-009 6.99598481e-113\n", - " 1.02258410e-004 1.68531448e-003 1.85823014e-009 3.53143407e-005\n", - " 9.35094774e-001 2.78985741e-009 2.46451322e-005 1.00000000e+000\n", - " 2.15818565e-003 1.10531967e-008 7.15495472e-007 7.52873079e-005\n", - " 1.97096637e-008 5.56668144e-006 1.96315148e-006 4.78447479e-006\n", - " 6.10181983e-008 8.65059987e-007 7.53453140e-005 2.43730227e-011\n", - " 2.69392151e-006 9.85117811e-005 2.84821624e-009 2.76311138e-007\n", - " 6.07125590e-009 2.07961256e-008 1.06228789e-007 1.14537000e-002\n", - " 4.07979682e-006 1.63181131e-002 4.94031634e-007 1.00000000e+000\n", - " 9.13236338e-008 8.81279066e-003 9.99987675e-001 2.16458146e-002\n", - " 1.05443500e-002 6.59179185e-009 1.42679847e-003 1.00000000e+000\n", - " 4.28796867e-010 1.53536674e-006 9.98547729e-001 3.10466646e-006\n", - " 8.80789903e-008 2.89610398e-008 1.66022764e-007 3.35706026e-007\n", - " 4.91178408e-006 6.60972762e-004 1.54774868e-010 9.42662846e-004\n", - " 8.51234735e-007 5.14779952e-007 2.96702464e-005 1.00000000e+000\n", - " 1.21295136e-005 3.51362936e-004 3.37173357e-008 3.22299128e-005\n", - " 3.69144958e-009 5.25565667e-009 4.97252462e-006 2.04265858e-009\n", - " 9.57920075e-009 1.30645464e-009 6.31701546e-004 1.52571446e-006\n", - " 1.02523926e-011 3.51262538e-009 3.69523574e-009 2.41829987e-006\n", - " 1.19455092e-003 2.14319596e-001 3.39877786e-008 5.28572734e-009\n", - " 8.98911683e-008 3.12254190e-011 2.25580548e-010 1.12198847e-005\n", - " 5.63146368e-009 1.00000000e+000 9.99951649e-001 4.28640898e-008\n", - " 8.20141465e-008 3.25427842e-007 9.99621162e-001 5.23784021e-004\n", - " 1.09416931e-005 1.62343190e-006 9.85852835e-001 1.00000000e+000\n", - " 2.97685126e-004 3.00773314e-007 7.15495472e-007 1.02283622e-002\n", - " 6.96287139e-006 6.52822910e-006]\n" - ] - } - ], - "source": [ - "full_path = experiment_path+'/'+dataname\n", - "new_full_path = full_path+'/replication/'+rep_dataname\n", - " \n", - "#Make folder in experiment folder/datafolder to store all prediction probabilities per algorithm/CV combination\n", - "if not os.path.exists(new_full_path+'/model_evaluation/prediction_probas'):\n", - " os.mkdir(new_full_path+'/model_evaluation/prediction_probas')\n", - "\n", - "for algorithm in algorithms: #loop through algorithms\n", - " print(\"Algorithm: \"+str(algorithm))\n", - "\n", - " for cvCount in range(0,cv_partitions): #loop through cv's\n", - " print(\"CV: \"+str(cvCount))\n", - " #Load pickled metric file for given algorithm and cv\n", - " result_file = new_full_path+'/model_evaluation/pickled_metrics/'+abbrev[algorithm]+\"_CV_\"+str(cvCount)+\"_metrics.pickle\"\n", - " file = open(result_file, 'rb')\n", - " results = pickle.load(file)\n", - " file.close()\n", - "\n", - " #Load processed replication dataset (From which we will get the instancelabel values and class outcome values.)\n", - " rep_data = pd.read_csv(new_full_path+'/'+rep_dataname+'_Processed.csv')\n", - " probas_summary = rep_data[[class_label,instance_label]]\n", - "\n", - " #Separate pickled results\n", - " probas_ = results[9]\n", - " print(probas_[:,1])\n", - " probas_summary['1_prob'] = probas_[:,1]\n", - " file_name = new_full_path+'/model_evaluation/prediction_probas/' + algorithm + '_CV_'+str(cvCount)+'_class1_probas.csv'\n", - " probas_summary.to_csv(file_name, index=False)\n", - "\n" - ] - }, - { - "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.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/UsefulNotebooks/PredictionProbs_Test_EvalMetricAccess.ipynb b/UsefulNotebooks/PredictionProbs_Test_EvalMetricAccess.ipynb deleted file mode 100644 index 974b8c68..00000000 --- a/UsefulNotebooks/PredictionProbs_Test_EvalMetricAccess.ipynb +++ /dev/null @@ -1,1065 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Useful Notebook: Report Testing Data Prediction Probabilities and Illustrate Accessing Evaluation Metrics\n", - "**This notebook will (1) show users how to access all model evaluation metrics from internal pickle files, and (2) generate model (class 1) prediction probabilities for instances of the respective testing dataset.**\n", - "\n", - "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", - "\n", - "***\n", - "## Notebook Details\n", - "STREAMLINE outputs pickled objects with (1) all the metric results, (2) elements needed to build the ROC and PRC plots, as well as (3) the prediction probabilities on the testing data across all datasets, algorithm models, and CV dataset partitions. \n", - "\n", - "This notebook illustrates how the user can access the pickled metric information saved as a list object. \n", - "\n", - "It includes (1) grabbing and calculating all average metric scores over the CV partitions, (2) grabbing the elements needed to build the average ROC plot, (3) grabbing the elementes needed to build the average PRC plot, (4) grabbing and reporting average model feature importance scores, and (5) grabbing and reporting the model testing prediction probabilities for each instance of the dataset. \n", - "\n", - "When run, this last item will generate a new folder (`prediction_probas`) in the pipeline's output experiment folder in the `model_evaluation` folder for each dataset. Here the class 1 prediction probabilities are reported as a `.csv` file for each algorithm and CV partition pair. In these files is the instance's true outcome value, the unique instance ID, and the predicted probability of the instance being class 1 (i.e. which typically encodes cases or the less frequent class). \n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Notebook Run Parameters\n", - "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed). \n", - "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "experiment_path = \"../DemoOutput/demo_experiment\" # path the target experiment folder \n", - "target_data_list = None # None if user wants to generate output for all analyzed target datasets, otherwise provide a (str) list of target dataset names to run\n", - "algorithms = [] # use empty list if user wishes re-evaluate all modeling algorithms that were run in pipeline, otherwise specify a (str) list of algorithm identifiers." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## Housekeeping\n", - "### Import Packages" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import pandas as pd\n", - "import pickle\n", - "import numpy as np\n", - "from statistics import mean\n", - "from scipy import interp,stats\n", - "import warnings\n", - "warnings.filterwarnings('ignore')\n", - "\n", - "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", - "from IPython.core.interactiveshell import InteractiveShell\n", - "InteractiveShell.ast_node_interactivity = \"all\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Automatically Detect Dataset Names" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Analyzed Datasets: ['hcc_data', 'hcc_data_custom']\n" - ] - } - ], - "source": [ - "# Get dataset paths for all completed dataset analyses in experiment folder\n", - "datasets = os.listdir(experiment_path)\n", - "\n", - "# Name of experiment folder\n", - "experiment_name = experiment_path.split('/')[-1] \n", - "\n", - "datasets = os.listdir(experiment_path)\n", - "remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", - " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs',\n", - " 'KeyFileCopy', 'dask_logs',\n", - " experiment_name + '_STREAMLINE_Report.pdf']\n", - "for text in remove_list:\n", - " if text in datasets:\n", - " datasets.remove(text)\n", - "\n", - "datasets = sorted(datasets) # ensures consistent ordering of datasets\n", - "print(\"Analyzed Datasets: \" + str(datasets))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load Other Necessary Parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Algorithms Ran: ['Decision Tree', 'Logistic Regression', 'Naive Bayes']\n" - ] - } - ], - "source": [ - "# Unpickle metadata from previous phase\n", - "file = open(experiment_path + '/' + \"metadata.pickle\", 'rb')\n", - "metadata = pickle.load(file)\n", - "file.close()\n", - "# Load variables specified earlier in the pipeline from metadata\n", - "class_label = metadata['Class Label']\n", - "instance_label = metadata['Instance Label']\n", - "cv_partitions = int(metadata['CV Partitions'])\n", - "\n", - "# Unpickle algorithm information from previous phase\n", - "file = open(experiment_path + '/' + \"algInfo.pickle\", 'rb')\n", - "algInfo = pickle.load(file)\n", - "file.close()\n", - "algorithms = []\n", - "abbrev = {}\n", - "for key in algInfo:\n", - " if algInfo[key][0]: # If that algorithm was used\n", - " algorithms.append(key)\n", - " abbrev[key] = (algInfo[key][1])\n", - "\n", - "print(\"Algorithms Ran: \" + str(algorithms))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "## From Pickle: Extract Metric List and Cacluate CV Averages" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "def print_results(algorithm, full_path):\n", - " # Define evaluation stats variable lists\n", - " s_bac = [] # balanced accuracies\n", - " s_ac = [] # standard accuracies\n", - " s_f1 = [] # F1 scores\n", - " s_re = [] # recall values\n", - " s_sp = [] # specificities\n", - " s_pr = [] # precision values\n", - " s_tp = [] # true positives\n", - " s_tn = [] # true negatives\n", - " s_fp = [] # false positives\n", - " s_fn = [] # false negatives\n", - " s_npv = [] # negative predictive values\n", - " s_lrp = [] # likelihood ratio positive values\n", - " s_lrm = [] # likelihood ratio negative values\n", - " \n", - " aucs = [] #areas under ROC curve\n", - " praucs = [] #area under PRC curve\n", - " aveprecs = [] #average precisions for PRC\n", - " \n", - " for cv_count in range(0, cv_partitions): #loop through cv's\n", - " #Load pickled metric file for given algorithm and cv\n", - " result_file = full_path + '/model_evaluation/pickled_metrics/' + abbrev[algorithm] + \"_CV_\" + str(cv_count) + \"_metrics.pickle\"\n", - " file = open(result_file, 'rb')\n", - " results = pickle.load(file)\n", - " file.close()\n", - " \n", - " #Separate pickled results\n", - " metric_list = results[0] #First item in pickled list is the metric list (set of standard classification metrics)\n", - " roc_auc = results[3] #Fourth item is the ROC AUC\n", - " prec_rec_auc = results[6] #Seventh item is the PRC AUC\n", - " ave_prec = results[7] #Eighth item is the average precision of PRC\n", - " \n", - " #Separate metrics from metricList\n", - " s_bac.append(metric_list[0])\n", - " s_ac.append(metric_list[1])\n", - " s_f1.append(metric_list[2])\n", - " s_re.append(metric_list[3])\n", - " s_sp.append(metric_list[4])\n", - " s_pr.append(metric_list[5])\n", - " s_tp.append(metric_list[6])\n", - " s_tn.append(metric_list[7])\n", - " s_fp.append(metric_list[8])\n", - " s_fn.append(metric_list[9])\n", - " s_npv.append(metric_list[10])\n", - " s_lrp.append(metric_list[11])\n", - " s_lrm.append(metric_list[12])\n", - " \n", - " aucs.append(roc_auc)\n", - " praucs.append(prec_rec_auc)\n", - " aveprecs.append(ave_prec)\n", - " \n", - " results = {'Balanced Accuracy': mean(s_bac), 'Accuracy': mean(s_ac), \n", - " 'F1_Score': mean(s_f1), 'Sensitivity (Recall)': mean(s_re), \n", - " 'Specificity': mean(s_sp),'Precision (PPV)': mean(s_pr), \n", - " 'TP': mean(s_tp), 'TN': mean(s_tn), 'FP': mean(s_fp), \n", - " 'FN': mean(s_fn), 'NPV': mean(s_npv), 'LR+': mean(s_lrp), \n", - " 'LR-': mean(s_lrm), 'ROC_AUC': mean(aucs),'PRC_AUC': mean(praucs), \n", - " 'PRC_APS': mean(aveprecs)}\n", - " print(results)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------------------------\n", - "Dataset: hcc_data\n", - "---------------------------------------\n", - "Algorithm: Decision Tree\n", - "{'Balanced Accuracy': 0.6227824463118581, 'Accuracy': 0.6424242424242425, 'F1_Score': 0.5345616443177419, 'Sensitivity (Recall)': 0.5396825396825397, 'Specificity': 0.7058823529411765, 'Precision (PPV)': 0.5304692891649413, 'TP': 11, 'TN': 24, 'FP': 10, 'FN': 9, 'NPV': 0.7135854341736695, 'LR+': 1.8518197851531188, 'LR-': 0.6538762364849321, 'ROC_AUC': 0.638188608776844, 'PRC_AUC': 0.5622552868527515, 'PRC_APS': 0.4961754551912484}\n", - "Algorithm: Logistic Regression\n", - "{'Balanced Accuracy': 0.7100840336134454, 'Accuracy': 0.7090909090909091, 'F1_Score': 0.6511283376399656, 'Sensitivity (Recall)': 0.7142857142857143, 'Specificity': 0.7058823529411765, 'Precision (PPV)': 0.6019679554162313, 'TP': 15, 'TN': 24, 'FP': 10, 'FN': 6, 'NPV': 0.802742060806577, 'LR+': 2.4645502645502644, 'LR-': 0.40083065083065084, 'ROC_AUC': 0.7824463118580766, 'PRC_AUC': 0.6765544222430395, 'PRC_APS': 0.6923576650690432}\n", - "Algorithm: Naive Bayes\n", - "{'Balanced Accuracy': 0.6386554621848739, 'Accuracy': 0.6545454545454545, 'F1_Score': 0.5474576271186441, 'Sensitivity (Recall)': 0.5714285714285714, 'Specificity': 0.7058823529411764, 'Precision (PPV)': 0.6081871345029239, 'TP': 12, 'TN': 24, 'FP': 10, 'FN': 9, 'NPV': 0.7284503173249977, 'LR+': 2.9829725829725824, 'LR-': 0.6162726368510574, 'ROC_AUC': 0.7383286647992531, 'PRC_AUC': 0.6137809851824108, 'PRC_APS': 0.6089370982036545}\n", - "---------------------------------------\n", - "Dataset: hcc_data_custom\n", - "---------------------------------------\n", - "Algorithm: Decision Tree\n", - "{'Balanced Accuracy': 0.5889355742296919, 'Accuracy': 0.5818181818181818, 'F1_Score': 0.5303783952707102, 'Sensitivity (Recall)': 0.6190476190476191, 'Specificity': 0.5588235294117647, 'Precision (PPV)': 0.4722222222222222, 'TP': 13, 'TN': 19, 'FP': 15, 'FN': 8, 'NPV': 0.7017727181066564, 'LR+': 1.4648526077097508, 'LR-': 0.6893221800054098, 'ROC_AUC': 0.6547619047619048, 'PRC_AUC': 0.6321725510131307, 'PRC_APS': 0.5121696205029538}\n", - "Algorithm: Logistic Regression\n", - "{'Balanced Accuracy': 0.6764705882352942, 'Accuracy': 0.6787878787878788, 'F1_Score': 0.6128019323671497, 'Sensitivity (Recall)': 0.6666666666666666, 'Specificity': 0.6862745098039216, 'Precision (PPV)': 0.5769590643274853, 'TP': 14, 'TN': 23, 'FP': 10, 'FN': 7, 'NPV': 0.7725925925925926, 'LR+': 2.373219373219373, 'LR-': 0.48828420256991684, 'ROC_AUC': 0.753968253968254, 'PRC_AUC': 0.6626744813297993, 'PRC_APS': 0.6785416910469191}\n", - "Algorithm: Naive Bayes\n", - "{'Balanced Accuracy': 0.6197478991596639, 'Accuracy': 0.6424242424242425, 'F1_Score': 0.5147993768683424, 'Sensitivity (Recall)': 0.5238095238095238, 'Specificity': 0.7156862745098039, 'Precision (PPV)': 0.6335621335621335, 'TP': 11, 'TN': 24, 'FP': 9, 'FN': 10, 'NPV': 0.7131506506506506, 'LR+': 4.497354497354497, 'LR-': 0.6527628749850972, 'ROC_AUC': 0.7215219421101774, 'PRC_AUC': 0.6205507476490729, 'PRC_APS': 0.6211007634474849}\n" - ] - } - ], - "source": [ - "if target_data_list: # User specified one analyzed dataset above (if more than one were analyzed)\n", - " for each in datasets:\n", - " if not each in target_data_list:\n", - " datasets.remove(each)\n", - "\n", - "for each in datasets: \n", - " print(\"---------------------------------------\")\n", - " print(\"Dataset: \"+str(each))\n", - " print(\"---------------------------------------\")\n", - " full_path = experiment_path + '/' + each\n", - " for algorithm in algorithms: #loop through algorithms\n", - " print(\"Algorithm: \"+str(algorithm))\n", - " print_results(algorithm, full_path)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## From Pickle: Extract list of true and false positive rates for constructing ROC" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------------------------\n", - "Dataset: hcc_data\n", - "---------------------------------------\n", - "Algorithm: Decision Tree\n", - "{'tprs': array([0. , 0.02212984, 0.04425968, 0.06638952, 0.08851936,\n", - " 0.1106492 , 0.13277904, 0.15490888, 0.17703872, 0.19676355,\n", - " 0.20980783, 0.2228521 , 0.23644151, 0.25103033, 0.26561915,\n", - " 0.28020798, 0.2947968 , 0.30938562, 0.32397444, 0.33856326,\n", - " 0.35315208, 0.40870611, 0.41252205, 0.41633798, 0.42592593,\n", - " 0.43791887, 0.44991182, 0.46753247, 0.48661215, 0.50569184,\n", - " 0.51996152, 0.53358987, 0.54721821, 0.55555556, 0.56373256,\n", - " 0.57194164, 0.58066378, 0.58938592, 0.59830848, 0.60839346,\n", - " 0.61847844, 0.62856341, 0.63864839, 0.64873337, 0.65705467,\n", - " 0.66168831, 0.66632195, 0.67095559, 0.67558923, 0.68022286,\n", - " 0.68808188, 0.69916627, 0.71025065, 0.72133504, 0.73241943,\n", - " 0.74350382, 0.75458821, 0.7656726 , 0.77675699, 0.78287867,\n", - " 0.78747337, 0.79206807, 0.79666277, 0.80125747, 0.80585217,\n", - " 0.81198607, 0.81821618, 0.82444628, 0.83067638, 0.83690648,\n", - " 0.84313658, 0.84936668, 0.85559678, 0.86182689, 0.86805699,\n", - " 0.87428709, 0.88051719, 0.88674729, 0.89297739, 0.89920749,\n", - " 0.9054376 , 0.9116677 , 0.9178978 , 0.9241279 , 0.930358 ,\n", - " 0.9365881 , 0.9428182 , 0.94904831, 0.95527841, 0.96150851,\n", - " 0.96773861, 0.97196454, 0.97546898, 0.97897341, 0.98247784,\n", - " 0.98598227, 0.9894867 , 0.99299114, 0.99649557, 1. ])}\n", - "Algorithm: Logistic Regression\n", - "{'tprs': array([0. , 0.19047619, 0.19047619, 0.3015873 , 0.3015873 ,\n", - " 0.3015873 , 0.3968254 , 0.3968254 , 0.3968254 , 0.3968254 ,\n", - " 0.3968254 , 0.3968254 , 0.42857143, 0.42857143, 0.42857143,\n", - " 0.47619048, 0.47619048, 0.47619048, 0.53968254, 0.53968254,\n", - " 0.53968254, 0.57142857, 0.57142857, 0.57142857, 0.6984127 ,\n", - " 0.6984127 , 0.6984127 , 0.6984127 , 0.6984127 , 0.6984127 ,\n", - " 0.71428571, 0.71428571, 0.71428571, 0.82539683, 0.82539683,\n", - " 0.82539683, 0.82539683, 0.82539683, 0.82539683, 0.82539683,\n", - " 0.82539683, 0.82539683, 0.82539683, 0.82539683, 0.85714286,\n", - " 0.85714286, 0.85714286, 0.87301587, 0.87301587, 0.87301587,\n", - " 0.9047619 , 0.9047619 , 0.9047619 , 0.9047619 , 0.9047619 ,\n", - " 0.9047619 , 0.9047619 , 0.9047619 , 0.9047619 , 0.9047619 ,\n", - " 0.9047619 , 0.9047619 , 0.92063492, 0.92063492, 0.92063492,\n", - " 0.92063492, 0.92063492, 0.92063492, 0.92063492, 0.92063492,\n", - " 0.95238095, 0.95238095, 0.95238095, 0.95238095, 0.95238095,\n", - " 0.95238095, 0.96825397, 0.96825397, 0.96825397, 0.96825397,\n", - " 0.96825397, 0.96825397, 0.96825397, 0.96825397, 0.96825397,\n", - " 0.96825397, 0.96825397, 0.96825397, 1. , 1. ,\n", - " 1. , 1. , 1. , 1. , 1. ,\n", - " 1. , 1. , 1. , 1. , 1. ])}\n", - "Algorithm: Naive Bayes\n", - "{'tprs': array([0. , 0.04906205, 0.0981241 , 0.14285714, 0.14285714,\n", - " 0.14285714, 0.17460317, 0.17460317, 0.17460317, 0.23809524,\n", - " 0.23809524, 0.23809524, 0.38095238, 0.38095238, 0.38095238,\n", - " 0.52380952, 0.52380952, 0.52380952, 0.57142857, 0.57142857,\n", - " 0.57142857, 0.6031746 , 0.6031746 , 0.6031746 , 0.61904762,\n", - " 0.61904762, 0.61904762, 0.63492063, 0.63492063, 0.63492063,\n", - " 0.66666667, 0.66666667, 0.66666667, 0.73015873, 0.73015873,\n", - " 0.73015873, 0.73015873, 0.73015873, 0.77777778, 0.77777778,\n", - " 0.77777778, 0.77777778, 0.77777778, 0.77777778, 0.84126984,\n", - " 0.84126984, 0.84126984, 0.84126984, 0.84126984, 0.84126984,\n", - " 0.85714286, 0.85714286, 0.85714286, 0.9047619 , 0.9047619 ,\n", - " 0.9047619 , 0.9047619 , 0.9047619 , 0.9047619 , 0.9047619 ,\n", - " 0.9047619 , 0.9047619 , 0.9047619 , 0.9047619 , 0.9047619 ,\n", - " 0.9047619 , 0.9047619 , 0.92063492, 0.92063492, 0.92063492,\n", - " 0.92063492, 0.92063492, 0.92063492, 0.92063492, 0.92063492,\n", - " 0.92063492, 0.92063492, 0.92063492, 0.92063492, 0.92063492,\n", - " 0.92063492, 0.92063492, 0.92063492, 0.92063492, 0.92063492,\n", - " 0.93650794, 0.93650794, 0.93650794, 0.97001764, 0.97274331,\n", - " 0.97546898, 0.97819464, 0.98092031, 0.98364598, 0.98637165,\n", - " 0.98909732, 0.99182299, 0.99454866, 0.99727433, 1. ])}\n", - "---------------------------------------\n", - "Dataset: hcc_data_custom\n", - "---------------------------------------\n", - "Algorithm: Decision Tree\n", - "{'tprs': array([0. , 0.03815937, 0.07631874, 0.11255411, 0.12890813,\n", - " 0.14526215, 0.16161616, 0.17797018, 0.19432419, 0.21067821,\n", - " 0.22703223, 0.24338624, 0.25974026, 0.27609428, 0.29244829,\n", - " 0.30880231, 0.32515633, 0.34151034, 0.35786436, 0.37421837,\n", - " 0.39057239, 0.40692641, 0.42328042, 0.43963444, 0.45598846,\n", - " 0.47234247, 0.48869649, 0.50505051, 0.52140452, 0.53775854,\n", - " 0.55411255, 0.57046657, 0.58682059, 0.5959596 , 0.60487997,\n", - " 0.61380034, 0.62272071, 0.63164109, 0.64006812, 0.64563383,\n", - " 0.65119953, 0.65676523, 0.66233094, 0.66789664, 0.67346234,\n", - " 0.67902804, 0.68459375, 0.69015945, 0.69572515, 0.70129085,\n", - " 0.70685656, 0.71242226, 0.71798796, 0.72355366, 0.72911937,\n", - " 0.73468507, 0.74025077, 0.74581647, 0.75138218, 0.75694788,\n", - " 0.76251358, 0.76807928, 0.77945707, 0.79183695, 0.80421683,\n", - " 0.8146144 , 0.82488807, 0.83516175, 0.84543543, 0.85570911,\n", - " 0.86598278, 0.87625646, 0.88653014, 0.8954009 , 0.8988604 ,\n", - " 0.9023199 , 0.90596441, 0.91005291, 0.91414141, 0.91822992,\n", - " 0.92231842, 0.92640693, 0.93049543, 0.93458393, 0.93867244,\n", - " 0.94276094, 0.94684945, 0.95093795, 0.95502646, 0.95911496,\n", - " 0.96320346, 0.96729197, 0.97138047, 0.97546898, 0.97955748,\n", - " 0.98364598, 0.98773449, 0.99182299, 0.9959115 , 1. ])}\n", - "Algorithm: Logistic Regression\n", - "{'tprs': array([0. , 0.17460317, 0.17460317, 0.26984127, 0.26984127,\n", - " 0.26984127, 0.47619048, 0.47619048, 0.47619048, 0.47619048,\n", - " 0.47619048, 0.47619048, 0.47619048, 0.47619048, 0.47619048,\n", - " 0.47619048, 0.47619048, 0.47619048, 0.47619048, 0.47619048,\n", - " 0.47619048, 0.50793651, 0.50793651, 0.50793651, 0.57142857,\n", - " 0.57142857, 0.57142857, 0.61904762, 0.61904762, 0.61904762,\n", - " 0.66666667, 0.66666667, 0.66666667, 0.6984127 , 0.6984127 ,\n", - " 0.6984127 , 0.6984127 , 0.6984127 , 0.71428571, 0.71428571,\n", - " 0.71428571, 0.76190476, 0.76190476, 0.76190476, 0.80952381,\n", - " 0.80952381, 0.80952381, 0.80952381, 0.80952381, 0.80952381,\n", - " 0.87301587, 0.87301587, 0.87301587, 0.87301587, 0.87301587,\n", - " 0.87301587, 0.87301587, 0.87301587, 0.87301587, 0.92063492,\n", - " 0.92063492, 0.92063492, 0.92063492, 0.92063492, 0.92063492,\n", - " 0.92063492, 0.92063492, 0.95238095, 0.95238095, 0.95238095,\n", - " 0.95238095, 0.95238095, 0.95238095, 0.95238095, 0.95238095,\n", - " 0.95238095, 0.95238095, 0.95238095, 0.95238095, 0.95238095,\n", - " 0.95238095, 0.95238095, 0.95238095, 0.95238095, 0.95238095,\n", - " 0.96825397, 0.96825397, 0.96825397, 0.96825397, 0.96825397,\n", - " 0.96825397, 0.96825397, 0.96825397, 0.96825397, 0.96825397,\n", - " 0.96825397, 0.96825397, 0.98412698, 0.98412698, 1. ])}\n", - "Algorithm: Naive Bayes\n", - "{'tprs': array([0. , 0.09074876, 0.11800545, 0.17460317, 0.17460317,\n", - " 0.17460317, 0.20634921, 0.20634921, 0.20634921, 0.3968254 ,\n", - " 0.3968254 , 0.3968254 , 0.44444444, 0.44444444, 0.44444444,\n", - " 0.44444444, 0.44444444, 0.44444444, 0.50793651, 0.50793651,\n", - " 0.50793651, 0.52380952, 0.52380952, 0.52380952, 0.53968254,\n", - " 0.53968254, 0.53968254, 0.58730159, 0.58730159, 0.58730159,\n", - " 0.65079365, 0.65079365, 0.65079365, 0.66666667, 0.66666667,\n", - " 0.6984127 , 0.6984127 , 0.6984127 , 0.73015873, 0.73015873,\n", - " 0.73015873, 0.76190476, 0.76190476, 0.76190476, 0.76190476,\n", - " 0.76190476, 0.76190476, 0.77777778, 0.77777778, 0.77777778,\n", - " 0.84126984, 0.84126984, 0.84126984, 0.84126984, 0.84126984,\n", - " 0.84126984, 0.84126984, 0.84126984, 0.84126984, 0.84126984,\n", - " 0.84126984, 0.84126984, 0.88888889, 0.88888889, 0.88888889,\n", - " 0.9047619 , 0.9047619 , 0.9047619 , 0.9047619 , 0.9047619 ,\n", - " 0.9047619 , 0.9047619 , 0.9047619 , 0.9047619 , 0.9047619 ,\n", - " 0.9047619 , 0.9047619 , 0.9047619 , 0.9047619 , 0.93650794,\n", - " 0.93650794, 0.93650794, 0.93650794, 0.93650794, 0.93650794,\n", - " 0.95359949, 0.95578002, 0.95796056, 0.97601411, 0.97819464,\n", - " 0.98037518, 0.98255572, 0.98473625, 0.98691679, 0.98909732,\n", - " 0.99127786, 0.99345839, 0.99563893, 0.99781946, 1. ])}\n" - ] - } - ], - "source": [ - "if target_data_list: # User specified one analyzed dataset above (if more than one were analyzed)\n", - " for each in datasets:\n", - " if not each in target_data_list:\n", - " datasets.remove(each)\n", - "\n", - "for each in datasets: \n", - " print(\"---------------------------------------\")\n", - " print(\"Dataset: \"+str(each))\n", - " print(\"---------------------------------------\")\n", - " full_path = experiment_path+ '/' + each\n", - " for algorithm in algorithms: #loop through algorithms\n", - " print(\"Algorithm: \"+str(algorithm))\n", - " # Define evaluation stats variable lists\n", - " tprs = [] # true postitive rates\n", - " mean_fpr = np.linspace(0, 1, 100) # used to plot all CVs in single ROC plot\n", - " \n", - " for cv_count in range(0, cv_partitions): #loop through cv's\n", - " # Load pickled metric file for given algorithm and cv =\n", - " result_file = full_path + '/model_evaluation/pickled_metrics/' + abbrev[algorithm] + \"_CV_\" + str(cv_count) + \"_metrics.pickle\"\n", - " file = open(result_file, 'rb')\n", - " results = pickle.load(file)\n", - " file.close()\n", - " \n", - " #Separate pickled results\n", - " fpr = results[1]\n", - " tpr = results[2]\n", - "\n", - " tprs.append(interp(mean_fpr, fpr, tpr))\n", - " tprs[-1][0] = 0.0\n", - "\n", - " results = {'tprs': np.mean(tprs, axis=0)}\n", - " \n", - " print(results)\n", - " #print('fprs: '+str(mean_fpr))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## From Pickle: Extract list of precision and recall values for constructing PRC" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------------------------\n", - "Dataset: hcc_data\n", - "---------------------------------------\n", - "Algorithm: Decision Tree\n", - "{'precs': array([1. , 0.98428732, 0.96857464, 0.95286195, 0.93714927,\n", - " 0.92143659, 0.90572391, 0.89001122, 0.87429854, 0.85858586,\n", - " 0.84287318, 0.82716049, 0.81144781, 0.79573513, 0.78002245,\n", - " 0.76430976, 0.74859708, 0.7328844 , 0.71717172, 0.70145903,\n", - " 0.68574635, 0.67003367, 0.65432099, 0.63860831, 0.60005261,\n", - " 0.58505191, 0.57005121, 0.55505051, 0.5400498 , 0.53386744,\n", - " 0.53121242, 0.5285574 , 0.52590238, 0.52324735, 0.52059233,\n", - " 0.51793731, 0.51528229, 0.51262726, 0.51170526, 0.51511579,\n", - " 0.51852633, 0.52193686, 0.5253474 , 0.5297276 , 0.53483505,\n", - " 0.53994249, 0.54504994, 0.55015739, 0.53797119, 0.53561151,\n", - " 0.53325183, 0.53089214, 0.51994802, 0.51860834, 0.51726866,\n", - " 0.51592898, 0.51458931, 0.51365547, 0.51326276, 0.51287006,\n", - " 0.51247735, 0.51208464, 0.48734635, 0.48330461, 0.47926287,\n", - " 0.47522114, 0.46079749, 0.45631127, 0.45182505, 0.44733883,\n", - " 0.44285261, 0.43952397, 0.43908928, 0.4386546 , 0.43821992,\n", - " 0.43778524, 0.43735055, 0.43691587, 0.43648119, 0.43604651,\n", - " 0.43561182, 0.43517714, 0.43474246, 0.43430778, 0.43387309,\n", - " 0.43343841, 0.43300373, 0.43256905, 0.43213436, 0.43169968,\n", - " 0.429529 , 0.42504365, 0.4205583 , 0.41607294, 0.41158759,\n", - " 0.40710224, 0.40261689, 0.39813154, 0.39364619, 0.38181818])}\n", - "Algorithm: Logistic Regression\n", - "{'precs': array([0.66666667, 0.7020202 , 0.73737374, 0.77272727, 0.80808081,\n", - " 0.67340067, 0.6969697 , 0.72053872, 0.74410774, 0.76767677,\n", - " 0.78451178, 0.7962963 , 0.80808081, 0.81986532, 0.83164983,\n", - " 0.79040404, 0.7986532 , 0.80690236, 0.81515152, 0.734221 ,\n", - " 0.74043465, 0.7466483 , 0.75286195, 0.7590756 , 0.72540338,\n", - " 0.73114259, 0.73688181, 0.74262102, 0.74836023, 0.74052491,\n", - " 0.7452085 , 0.74989208, 0.75457567, 0.75925926, 0.76318743,\n", - " 0.7671156 , 0.77104377, 0.77497194, 0.76762815, 0.77099336,\n", - " 0.77435856, 0.77772376, 0.78108896, 0.74251747, 0.74592002,\n", - " 0.74932257, 0.75272513, 0.75612768, 0.75918584, 0.76218661,\n", - " 0.76518738, 0.76818815, 0.70470974, 0.70827507, 0.7118404 ,\n", - " 0.71540574, 0.71897107, 0.65912032, 0.66286294, 0.66660556,\n", - " 0.67034818, 0.6740908 , 0.67757049, 0.68094502, 0.68431954,\n", - " 0.68769406, 0.58545455, 0.58896561, 0.59247667, 0.59598773,\n", - " 0.59949879, 0.60293258, 0.60617321, 0.60941385, 0.61265448,\n", - " 0.61589511, 0.57647647, 0.57958166, 0.58268685, 0.58579204,\n", - " 0.58889723, 0.54867865, 0.55165097, 0.55462329, 0.5575956 ,\n", - " 0.5150854 , 0.51786185, 0.52063831, 0.52341477, 0.52619123,\n", - " 0.4696813 , 0.47235036, 0.47501943, 0.47768849, 0.48035755,\n", - " 0.43818218, 0.44072814, 0.4432741 , 0.44582005, 0.38181818])}\n", - "Algorithm: Naive Bayes\n", - "{'precs': array([1. , 0.95639731, 0.91279461, 0.86919192, 0.82558923,\n", - " 0.73989899, 0.74343434, 0.7469697 , 0.75050505, 0.7540404 ,\n", - " 0.6991342 , 0.69761905, 0.6961039 , 0.69458874, 0.69307359,\n", - " 0.61616162, 0.62390572, 0.63164983, 0.63939394, 0.62827882,\n", - " 0.63363797, 0.63899711, 0.64435626, 0.64971541, 0.61681753,\n", - " 0.62550286, 0.6341882 , 0.64287354, 0.65155888, 0.60947352,\n", - " 0.61707989, 0.62468626, 0.63229262, 0.6010101 , 0.60768524,\n", - " 0.61436039, 0.62103553, 0.62771067, 0.61947682, 0.62525253,\n", - " 0.63102823, 0.63680394, 0.64257964, 0.64791505, 0.65292023,\n", - " 0.65792541, 0.66293059, 0.66793577, 0.62579387, 0.63037503,\n", - " 0.63495619, 0.63953735, 0.60151988, 0.60567754, 0.60983519,\n", - " 0.61399285, 0.61815051, 0.61027956, 0.61402479, 0.61777001,\n", - " 0.62151524, 0.62526047, 0.60439775, 0.60796201, 0.61152627,\n", - " 0.61509053, 0.58589181, 0.58920585, 0.5925199 , 0.59583394,\n", - " 0.59914798, 0.5447743 , 0.54810438, 0.55143447, 0.55476455,\n", - " 0.55809464, 0.5017151 , 0.50479103, 0.50786697, 0.5109429 ,\n", - " 0.51401883, 0.51431135, 0.51719783, 0.52008432, 0.52297081,\n", - " 0.51410633, 0.51684748, 0.51958864, 0.52232979, 0.52507095,\n", - " 0.4921309 , 0.4937147 , 0.49529849, 0.49688228, 0.49846607,\n", - " 0.45981703, 0.46132548, 0.46283392, 0.46434237, 0.38181818])}\n", - "---------------------------------------\n", - "Dataset: hcc_data_custom\n", - "---------------------------------------\n", - "Algorithm: Decision Tree\n", - "{'precs': array([1. , 0.99170964, 0.98341927, 0.97512891, 0.96683855,\n", - " 0.95854819, 0.95025782, 0.94196746, 0.9336771 , 0.92538673,\n", - " 0.91709637, 0.90880601, 0.90051565, 0.89222528, 0.88393492,\n", - " 0.87564456, 0.86735419, 0.85906383, 0.85077347, 0.84248311,\n", - " 0.83419274, 0.82590238, 0.81761202, 0.80932165, 0.80077877,\n", - " 0.79189918, 0.78301959, 0.77414 , 0.76526041, 0.75638082,\n", - " 0.74750124, 0.73862165, 0.72974206, 0.72086247, 0.71198288,\n", - " 0.70310329, 0.69422371, 0.68534412, 0.67646453, 0.66758494,\n", - " 0.65870535, 0.64982576, 0.64094618, 0.63206659, 0.623187 ,\n", - " 0.61430741, 0.60542782, 0.59654823, 0.58961115, 0.58299781,\n", - " 0.57638447, 0.56977114, 0.56354479, 0.55964036, 0.55573593,\n", - " 0.5518315 , 0.54792707, 0.54402264, 0.54011822, 0.53621379,\n", - " 0.53230936, 0.52840493, 0.52552473, 0.52305422, 0.52058371,\n", - " 0.5181132 , 0.51564269, 0.51317218, 0.51070167, 0.50823116,\n", - " 0.50576065, 0.45017782, 0.44878001, 0.44738219, 0.44598437,\n", - " 0.44458656, 0.44318874, 0.44179093, 0.44039311, 0.43899529,\n", - " 0.43759748, 0.43619966, 0.43480184, 0.43340403, 0.43200621,\n", - " 0.4305428 , 0.42868585, 0.4268289 , 0.42497194, 0.42311499,\n", - " 0.42125803, 0.41940108, 0.41754413, 0.41568717, 0.41383022,\n", - " 0.4057971 , 0.39980237, 0.39380764, 0.38781291, 0.38181818])}\n", - "Algorithm: Logistic Regression\n", - "{'precs': array([0.66666667, 0.7020202 , 0.73737374, 0.77272727, 0.80808081,\n", - " 0.67340067, 0.6969697 , 0.72053872, 0.74410774, 0.76767677,\n", - " 0.72962963, 0.74259259, 0.75555556, 0.76851852, 0.78148148,\n", - " 0.79040404, 0.7986532 , 0.80690236, 0.81515152, 0.82303992,\n", - " 0.82876383, 0.83448773, 0.84021164, 0.84593555, 0.81168831,\n", - " 0.81673882, 0.82178932, 0.82683983, 0.83189033, 0.83613917,\n", - " 0.84006734, 0.84399551, 0.84792368, 0.85185185, 0.85499439,\n", - " 0.85813692, 0.86127946, 0.864422 , 0.76762815, 0.77099336,\n", - " 0.77435856, 0.77772376, 0.78108896, 0.68083114, 0.68451152,\n", - " 0.6881919 , 0.69187228, 0.69555266, 0.64412929, 0.64833678,\n", - " 0.65254426, 0.65675174, 0.6501792 , 0.65397523, 0.65777126,\n", - " 0.66156728, 0.66536331, 0.64718615, 0.65062049, 0.65405483,\n", - " 0.65748918, 0.66092352, 0.56652087, 0.57031226, 0.57410365,\n", - " 0.57789504, 0.56671664, 0.57024139, 0.57376615, 0.5772909 ,\n", - " 0.58081565, 0.53235564, 0.53574183, 0.53912803, 0.54251423,\n", - " 0.54590043, 0.51952753, 0.52268716, 0.5258468 , 0.52900643,\n", - " 0.53216606, 0.50519875, 0.50821253, 0.5112263 , 0.51424007,\n", - " 0.48960609, 0.49245846, 0.49531083, 0.4981632 , 0.50101558,\n", - " 0.49027391, 0.4929833 , 0.4956927 , 0.4984021 , 0.50111149,\n", - " 0.38705571, 0.38951737, 0.39197903, 0.39444069, 0.38181818])}\n", - "Algorithm: Naive Bayes\n", - "{'precs': array([1. , 0.96111111, 0.92222222, 0.88333333, 0.84444444,\n", - " 0.73535354, 0.74242424, 0.74949495, 0.75656566, 0.76363636,\n", - " 0.76868687, 0.77222222, 0.77575758, 0.77929293, 0.78282828,\n", - " 0.78463203, 0.78614719, 0.78766234, 0.78917749, 0.65693442,\n", - " 0.6665865 , 0.67623858, 0.68589065, 0.69554273, 0.67462722,\n", - " 0.68239939, 0.69017156, 0.69794372, 0.70571589, 0.64391781,\n", - " 0.6509583 , 0.65799879, 0.66503928, 0.62222222, 0.62843587,\n", - " 0.63464953, 0.64086318, 0.64707683, 0.64322368, 0.64851726,\n", - " 0.65381084, 0.65910441, 0.66439799, 0.660512 , 0.66509222,\n", - " 0.66967243, 0.67425265, 0.67883286, 0.63518916, 0.63959787,\n", - " 0.64400659, 0.64841531, 0.62334506, 0.62750118, 0.63165731,\n", - " 0.63581344, 0.63996957, 0.54862516, 0.55265625, 0.55668734,\n", - " 0.56071843, 0.56474952, 0.55571676, 0.55942198, 0.5631272 ,\n", - " 0.56683242, 0.51571906, 0.51925902, 0.52279897, 0.52633892,\n", - " 0.52987887, 0.52673861, 0.53004598, 0.53335335, 0.53666071,\n", - " 0.53996808, 0.50019268, 0.50330318, 0.50641369, 0.5095242 ,\n", - " 0.51263471, 0.48079782, 0.48376999, 0.48674216, 0.48971433,\n", - " 0.46940546, 0.47220361, 0.47500175, 0.47779989, 0.48059803,\n", - " 0.46290346, 0.46421374, 0.46552401, 0.46683429, 0.46814456,\n", - " 0.44397302, 0.4451643 , 0.44635559, 0.44754687, 0.38181818])}\n" - ] - } - ], - "source": [ - "if target_data_list: # User specified one analyzed dataset above (if more than one were analyzed)\n", - " for each in datasets:\n", - " if not each in target_data_list:\n", - " datasets.remove(each)\n", - "\n", - "for each in datasets: \n", - " print(\"---------------------------------------\")\n", - " print(\"Dataset: \"+str(each))\n", - " print(\"---------------------------------------\")\n", - " full_path = experiment_path + '/' + each\n", - " for algorithm in algorithms: #loop through algorithms\n", - " print(\"Algorithm: \"+str(algorithm))\n", - " # Define evaluation stats variable lists\n", - " precs = [] # true postitive rates\n", - " mean_recall = np.linspace(0, 1, 100) # used to plot all CVs in single PRC plot\n", - " \n", - " for cv_count in range(0, cv_partitions): #loop through cv's\n", - " #Load pickled metric file for given algorithm and cv\n", - " result_file = full_path + '/model_evaluation/pickled_metrics/' + abbrev[algorithm] + \"_CV_\" + str(cv_count) + \"_metrics.pickle\"\n", - " file = open(result_file, 'rb')\n", - " results = pickle.load(file)\n", - " file.close()\n", - " \n", - " #Separate pickled results\n", - " prec = results[4]\n", - " recall = results[5]\n", - "\n", - " precs.append(interp(mean_recall, recall, prec))\n", - "\n", - " results = {'precs': np.mean(precs, axis=0)}\n", - "\n", - " print(results)\n", - " #print('recall: '+str(mean_recall))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## From Pickle: Extract Average Model Feature Importance Estimates (Over CVs)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dataset: ['hcc_data', 'hcc_data_custom']\n", - "---------------------------------------\n", - "Dataset: hcc_data\n", - "---------------------------------------\n", - "Algorithm: Decision Tree\n", - "{'Gender': 0.0, 'Symptoms': 0.0, 'Alcohol': 0.0, 'Hepatitis B Surface Antigen': 0.0, 'Hepatitis B e Antigen': 0.0, 'Hepatitis B Core Antibody': 0.0, 'Hepatitis C Virus Antibody': 0.0, 'Cirrhosis': 0.0, 'Endemic Countries': 0.0, 'Smoking': 0.0, 'Diabetes': 0.0, 'Obesity': 0.0, 'Hemochromatosis': 0.0, 'Arterial Hypertension': 0.0, 'Chronic Renal Insufficiency': 0.0, 'Human Immunodeficiency Virus': 0.0, 'Nonalcoholic Steatohepatitis': 0.0, 'Esophageal Varices': 0.0, 'Splenomegaly': 0.0, 'Portal Hypertension': 0.0, 'Portal Vein Thrombosis': 0.0, 'Liver Metastasis': 0.035235760971055095, 'Radiological Hallmark': 0.0, 'Age at diagnosis': 0.024112978524743225, 'Grams of Alcohol per day': 0.0, 'Packs of cigarets per year': 0.01684173669467786, 'Performance Status*': 0.053046218487394964, 'Encephalopathy degree*': 0.0, 'Ascites degree*': 0.01264005602240896, 'International Normalised Ratio*': 0.0, 'Alpha-Fetoprotein (ng/mL)': 0.06785714285714282, 'Haemoglobin (g/dL)': 0.0, 'Mean Corpuscular Volume': 0.010329131652661071, 'Leukocytes(G/L)': 0.00498366013071894, 'Platelets': 0.0, 'Albumin (mg/dL)': 0.06011904761904758, 'Total Bilirubin(mg/dL)': 0.0, 'Alanine transaminase (U/L)': 0.024544817927170875, 'Aspartate transaminase (U/L)': 0.03979925303454713, 'Gamma glutamyl transferase (U/L)': 0.0, 'Alkaline phosphatase (U/L)': 0.06925770308123248, 'Total Proteins (g/dL)': 0.02049486461251167, 'Creatinine (mg/dL)': 0.0, 'Number of Nodules': 0.0, 'Major dimension of nodule (cm)': 0.0, 'Direct Bilirubin (mg/dL)': 0.0, 'Iron': 0.023062558356675967, 'Oxygen Saturation (%)': 0.0, 'Ferritin (ng/mL)': 0.0}\n", - "Algorithm: Logistic Regression\n", - "{'Gender': 0.006757703081232487, 'Symptoms': 0.01143790849673207, 'Alcohol': 0.0, 'Hepatitis B Surface Antigen': 0.010690943043884231, 'Hepatitis B e Antigen': 0.0007352941176470562, 'Hepatitis B Core Antibody': 0.0011904761904761862, 'Hepatitis C Virus Antibody': 0.02563025210084034, 'Cirrhosis': 0.0003968253968253954, 'Endemic Countries': 0.009570494864612518, 'Smoking': 0.0015522875816993409, 'Diabetes': 0.030567226890756315, 'Obesity': 0.0038165266106442476, 'Hemochromatosis': 0.0, 'Arterial Hypertension': 0.022350606909430432, 'Chronic Renal Insufficiency': 0.0004318394024276399, 'Human Immunodeficiency Virus': 0.0, 'Nonalcoholic Steatohepatitis': 0.0, 'Esophageal Varices': 0.002054154995331466, 'Splenomegaly': 0.001225490196078427, 'Portal Hypertension': 0.013422035480859025, 'Portal Vein Thrombosis': 0.01188141923436045, 'Liver Metastasis': 0.0250583566760038, 'Radiological Hallmark': 0.0, 'Age at diagnosis': 0.007913165266106477, 'Grams of Alcohol per day': 3.501400560224077e-05, 'Packs of cigarets per year': 0.015954715219421114, 'Performance Status*': 0.019666199813258685, 'Encephalopathy degree*': -0.0021942110177404217, 'Ascites degree*': 0.017471988795518232, 'International Normalised Ratio*': 0.007236227824463155, 'Alpha-Fetoprotein (ng/mL)': 0.013176937441643338, 'Haemoglobin (g/dL)': 0.013842203548085921, 'Mean Corpuscular Volume': 0.012278244631185825, 'Leukocytes(G/L)': -0.0026960784313725277, 'Platelets': -0.0037815126050419813, 'Albumin (mg/dL)': 0.0026844070961718294, 'Total Bilirubin(mg/dL)': -0.0014939309056955987, 'Alanine transaminase (U/L)': 0.015371148459383768, 'Aspartate transaminase (U/L)': 0.034593837535014035, 'Gamma glutamyl transferase (U/L)': -0.0005018674136321104, 'Alkaline phosphatase (U/L)': 0.03144257703081233, 'Total Proteins (g/dL)': 0.00283613445378151, 'Creatinine (mg/dL)': 0.005777310924369786, 'Number of Nodules': 0.011251167133520085, 'Major dimension of nodule (cm)': 0.014647525676937482, 'Direct Bilirubin (mg/dL)': -0.001552287581699322, 'Iron': 0.006851073762838493, 'Oxygen Saturation (%)': -0.002042483660130708, 'Ferritin (ng/mL)': 0.027766106442577057}\n", - "Algorithm: Naive Bayes\n", - "{'Gender': -0.0009803921568627416, 'Symptoms': -0.003408029878618128, 'Alcohol': 0.0, 'Hepatitis B Surface Antigen': -0.0024159663865546393, 'Hepatitis B e Antigen': 0.0013188608776843987, 'Hepatitis B Core Antibody': 0.0, 'Hepatitis C Virus Antibody': -0.0036647992530345445, 'Cirrhosis': 0.005777310924369739, 'Endemic Countries': 0.005660597572362272, 'Smoking': -0.0004901960784313708, 'Diabetes': 0.00039682539682538804, 'Obesity': 0.0, 'Hemochromatosis': 0.0, 'Arterial Hypertension': 0.0034313725490196143, 'Chronic Renal Insufficiency': 0.004761904761904734, 'Human Immunodeficiency Virus': -0.0007002801120448266, 'Nonalcoholic Steatohepatitis': 0.0, 'Esophageal Varices': 0.001225490196078427, 'Splenomegaly': 0.0, 'Portal Hypertension': 0.0, 'Portal Vein Thrombosis': 0.004271708683473401, 'Liver Metastasis': 0.006209150326797368, 'Radiological Hallmark': 0.0, 'Age at diagnosis': -0.002287581699346412, 'Grams of Alcohol per day': 0.005473856209150338, 'Packs of cigarets per year': 0.003151260504201677, 'Performance Status*': 0.019631185807656396, 'Encephalopathy degree*': 0.010795985060690924, 'Ascites degree*': -0.004878618113912241, 'International Normalised Ratio*': 0.020471521942110157, 'Alpha-Fetoprotein (ng/mL)': 0.0238562091503268, 'Haemoglobin (g/dL)': 0.007738095238095232, 'Mean Corpuscular Volume': 0.004271708683473374, 'Leukocytes(G/L)': -0.0014355742296918864, 'Platelets': -0.0014589169000933766, 'Albumin (mg/dL)': 0.009862278244631172, 'Total Bilirubin(mg/dL)': 0.011356209150326793, 'Alanine transaminase (U/L)': -0.003968253968253965, 'Aspartate transaminase (U/L)': -0.002556022408963595, 'Gamma glutamyl transferase (U/L)': -0.002567693744164342, 'Alkaline phosphatase (U/L)': 0.001388888888888891, 'Total Proteins (g/dL)': -0.0006652661064425747, 'Creatinine (mg/dL)': 0.0035480859010270723, 'Number of Nodules': -0.0016456582633053163, 'Major dimension of nodule (cm)': 0.00024509803921567066, 'Direct Bilirubin (mg/dL)': 0.011671335200746957, 'Iron': -0.004621848739495782, 'Oxygen Saturation (%)': -0.001225490196078427, 'Ferritin (ng/mL)': 0.003034547152194219}\n", - "---------------------------------------\n", - "Dataset: hcc_data_custom\n", - "---------------------------------------\n", - "Algorithm: Decision Tree\n", - "{'Symptoms': 0.0, 'Alcohol': 0.0, 'Hepatitis B Surface Antigen': 0.0, 'Hepatitis B e Antigen': 0.0, 'Hepatitis B Core Antibody': 0.0, 'Hepatitis C Virus Antibody': 0.0, 'Cirrhosis': 0.0, 'Endemic Countries': 0.0, 'Smoking': 0.0, 'Diabetes': 0.0, 'Obesity': 0.0, 'Hemochromatosis': 0.0, 'Arterial Hypertension': 0.0, 'Chronic Renal Insufficiency': 0.0, 'Human Immunodeficiency Virus': 0.0, 'Nonalcoholic Steatohepatitis': 0.0, 'Esophageal Varices': 0.0, 'Splenomegaly': 0.0, 'Portal Hypertension': 0.0, 'Portal Vein Thrombosis': 0.0, 'Liver Metastasis': 0.0, 'Radiological Hallmark': 0.0, 'Grams of Alcohol per day': 0.0, 'Packs of cigarets per year': 0.0, 'Performance Status*': 0.04472455648926238, 'Encephalopathy degree*': 0.0, 'Ascites degree*': 0.0, 'International Normalised Ratio*': 0.0, 'Alpha-Fetoprotein (ng/mL)': 0.02747432306255837, 'Haemoglobin (g/dL)': 0.015651260504201684, 'Mean Corpuscular Volume': 0.02801120448179273, 'Leukocytes(G/L)': 0.0, 'Platelets': 0.0, 'Albumin (mg/dL)': 0.0, 'Total Bilirubin(mg/dL)': 0.0, 'Alanine transaminase (U/L)': 0.0, 'Aspartate transaminase (U/L)': 0.01866246498599441, 'Gamma glutamyl transferase (U/L)': 0.0, 'Alkaline phosphatase (U/L)': 0.0840919701213819, 'Total Proteins (g/dL)': 0.0, 'Creatinine (mg/dL)': 0.0, 'Number of Nodules': 0.0, 'Major dimension of nodule (cm)': 0.0, 'Direct Bilirubin (mg/dL)': 0.0, 'Iron': 0.018989262371615332, 'Oxygen Saturation (%)': 0.0, 'Ferritin (ng/mL)': 0.0, 'Sim_Cat_2': 0.0, 'Sim_Text_Cat_2': 0.0, 'Sim_Cor_-1.0_B': 0.0, 'Sim_Cor_0.9_A': 0.0, 'Sim_Cor_0.9_B': 0.0, 'Sim_Cor_1.0_B': 0.0, 'Miss_Sim_Miss_0.6': 0.0, 'Miss_Sim_Miss_0.7': 0.0, 'Sim_Cat_3_1': 0.0, 'Sim_Cat_3_2': 0.0, 'Sim_Cat_3_3': 0.02435807656395893, 'Sim_Cat_4_1': 0.0, 'Sim_Cat_4_2': 0.0, 'Sim_Cat_4_3': 0.0, 'Sim_Cat_4_4': 0.0, 'Sim_Text_Cat_3_Category 1': 0.0, 'Sim_Text_Cat_3_Category 2': 0.0, 'Sim_Text_Cat_3_Category 3': 0.0, 'Sim_Text_Cat_4_Category 1': 0.0, 'Sim_Text_Cat_4_Category 2': 0.0, 'Sim_Text_Cat_4_Category 3': 0.0, 'Sim_Text_Cat_4_Category 4': 0.0}\n", - "Algorithm: Logistic Regression\n", - "{'Symptoms': 0.011764705882352948, 'Alcohol': -0.0023809523809523725, 'Hepatitis B Surface Antigen': 0.0, 'Hepatitis B e Antigen': -0.00015172735760971, 'Hepatitis B Core Antibody': -0.001015406162464986, 'Hepatitis C Virus Antibody': 0.012406629318394022, 'Cirrhosis': 0.0, 'Endemic Countries': 0.0015522875816993409, 'Smoking': 0.005847338935574227, 'Diabetes': 0.0019374416433239894, 'Obesity': 0.0, 'Hemochromatosis': 0.0007352941176470562, 'Arterial Hypertension': 0.007212885154061636, 'Chronic Renal Insufficiency': -0.0004668534080298885, 'Human Immunodeficiency Virus': 0.0007352941176470562, 'Nonalcoholic Steatohepatitis': 0.0007002801120448192, 'Esophageal Varices': 0.0011904761904761789, 'Splenomegaly': 0.0, 'Portal Hypertension': 0.0, 'Portal Vein Thrombosis': 0.005088702147525703, 'Liver Metastasis': -0.0015639589169000798, 'Radiological Hallmark': 0.002474323062558348, 'Grams of Alcohol per day': 0.00018674136321195078, 'Packs of cigarets per year': 0.0056139122315592704, 'Performance Status*': 0.016083099906629324, 'Encephalopathy degree*': 0.0005252100840336154, 'Ascites degree*': -7.002801120446998e-05, 'International Normalised Ratio*': 0.002264239028944907, 'Alpha-Fetoprotein (ng/mL)': 0.0013772175536881407, 'Haemoglobin (g/dL)': 0.013375350140056036, 'Mean Corpuscular Volume': 0.0003384687208216608, 'Leukocytes(G/L)': 0.0015522875816993485, 'Platelets': -0.003909897292250223, 'Albumin (mg/dL)': 0.012616713352007482, 'Total Bilirubin(mg/dL)': -0.0058006535947712325, 'Alanine transaminase (U/L)': 0.0002450980392156854, 'Aspartate transaminase (U/L)': 0.005929038281979478, 'Gamma glutamyl transferase (U/L)': 7.00280112044931e-05, 'Alkaline phosphatase (U/L)': 0.008473389355742305, 'Total Proteins (g/dL)': 0.0004901960784313708, 'Creatinine (mg/dL)': -0.00030345471521942, 'Number of Nodules': 0.0027194211017740402, 'Major dimension of nodule (cm)': 0.011006069094304405, 'Direct Bilirubin (mg/dL)': -0.0032679738562091387, 'Iron': -0.005602240896358542, 'Oxygen Saturation (%)': -0.0006419234360410808, 'Ferritin (ng/mL)': 0.010305788982259605, 'Sim_Cat_2': -0.00966386554621849, 'Sim_Text_Cat_2': -0.0017156862745097978, 'Sim_Cor_-1.0_B': 0.0, 'Sim_Cor_0.9_A': 0.0049603174603174574, 'Sim_Cor_0.9_B': -0.0011904761904761862, 'Sim_Cor_1.0_B': 0.0010154061624650008, 'Miss_Sim_Miss_0.6': -0.0015289449112978546, 'Miss_Sim_Miss_0.7': -0.0004901960784313708, 'Sim_Cat_3_1': -0.0011904761904761862, 'Sim_Cat_3_2': -0.005777310924369734, 'Sim_Cat_3_3': 0.005590569561157795, 'Sim_Cat_4_1': -0.0009803921568627416, 'Sim_Cat_4_2': 0.0, 'Sim_Cat_4_3': 0.0012254901960784233, 'Sim_Cat_4_4': 0.0051120448179271935, 'Sim_Text_Cat_3_Category 1': 0.007819794584500465, 'Sim_Text_Cat_3_Category 2': 0.018487394957983197, 'Sim_Text_Cat_3_Category 3': 0.005718954248365996, 'Sim_Text_Cat_4_Category 1': 0.002229225023342681, 'Sim_Text_Cat_4_Category 2': -0.0026960784313725394, 'Sim_Text_Cat_4_Category 3': 0.01100606909430441, 'Sim_Text_Cat_4_Category 4': -0.0007936507936507908}\n", - "Algorithm: Naive Bayes\n", - "{'Symptoms': -0.005929038281979471, 'Alcohol': -0.00039682539682538804, 'Hepatitis B Surface Antigen': 0.0, 'Hepatitis B e Antigen': 0.0008286647992530278, 'Hepatitis B Core Antibody': 0.00277777777777779, 'Hepatitis C Virus Antibody': 0.004190009337068167, 'Cirrhosis': 0.0, 'Endemic Countries': 0.009138655462184857, 'Smoking': -0.0014705882352941124, 'Diabetes': 0.0014939309056956399, 'Obesity': 0.0, 'Hemochromatosis': -5.8356676003738327e-05, 'Arterial Hypertension': -0.0022058823529411795, 'Chronic Renal Insufficiency': 0.014367413632119541, 'Human Immunodeficiency Virus': 0.002135854341736683, 'Nonalcoholic Steatohepatitis': -0.001540616246498594, 'Esophageal Varices': 0.0026844070961718146, 'Splenomegaly': 0.0, 'Portal Hypertension': 0.0007936507936507982, 'Portal Vein Thrombosis': 0.0009453781512605083, 'Liver Metastasis': 0.0022759103641456576, 'Radiological Hallmark': 0.0019841269841269957, 'Grams of Alcohol per day': 0.005625583566760073, 'Packs of cigarets per year': 0.0009337068160597829, 'Performance Status*': 0.014063958916900111, 'Encephalopathy degree*': 0.0004318394024276213, 'Ascites degree*': 0.0005018674136321174, 'International Normalised Ratio*': 0.013118580765639607, 'Alpha-Fetoprotein (ng/mL)': 0.01715686274509806, 'Haemoglobin (g/dL)': 0.01001400560224092, 'Mean Corpuscular Volume': 0.004446778711484596, 'Leukocytes(G/L)': -0.0008870214752567479, 'Platelets': 0.001132119514472474, 'Albumin (mg/dL)': 0.010971055088702159, 'Total Bilirubin(mg/dL)': 0.006524276377217564, 'Alanine transaminase (U/L)': -0.002894491129785229, 'Aspartate transaminase (U/L)': -0.005695611577964517, 'Gamma glutamyl transferase (U/L)': 0.0009103641456582858, 'Alkaline phosphatase (U/L)': 0.002812791783380031, 'Total Proteins (g/dL)': 0.0009803921568627416, 'Creatinine (mg/dL)': 0.009161998132586394, 'Number of Nodules': 0.0, 'Major dimension of nodule (cm)': 0.006477591036414575, 'Direct Bilirubin (mg/dL)': 0.007959850606909442, 'Iron': 0.007107843137254925, 'Oxygen Saturation (%)': 0.001482259570494893, 'Ferritin (ng/mL)': 0.008776844070961742, 'Sim_Cat_2': -0.0004901960784313708, 'Sim_Text_Cat_2': 0.00042016806722690054, 'Sim_Cor_-1.0_B': 0.0, 'Sim_Cor_0.9_A': -0.0004901960784313745, 'Sim_Cor_0.9_B': -0.00019841269841268266, 'Sim_Cor_1.0_B': -0.0036181139122315616, 'Miss_Sim_Miss_0.6': -0.0016456582633053052, 'Miss_Sim_Miss_0.7': -0.0010971055088702035, 'Sim_Cat_3_1': 0.002777777777777794, 'Sim_Cat_3_2': 0.0036297852474323194, 'Sim_Cat_3_3': -0.0007703081232493117, 'Sim_Cat_4_1': 0.0, 'Sim_Cat_4_2': -0.0015873015873015817, 'Sim_Cat_4_3': 0.007819794584500495, 'Sim_Cat_4_4': 0.00011671335200748774, 'Sim_Text_Cat_3_Category 1': 0.0003618113912231694, 'Sim_Text_Cat_3_Category 2': -0.0010037348272642578, 'Sim_Text_Cat_3_Category 3': 0.0056839402427638006, 'Sim_Text_Cat_4_Category 1': 0.0014355742296918717, 'Sim_Text_Cat_4_Category 2': 0.0019841269841269957, 'Sim_Text_Cat_4_Category 3': -0.0005485527544351128, 'Sim_Text_Cat_4_Category 4': 0.001190476190476201}\n" - ] - } - ], - "source": [ - "if target_data_list: # User specified one analyzed dataset above (if more than one were analyzed)\n", - " for each in datasets:\n", - " if not each in target_data_list:\n", - " datasets.remove(each)\n", - "print(\"Dataset: \" + str(datasets))\n", - "\n", - "for each in datasets: \n", - " print(\"---------------------------------------\")\n", - " print(\"Dataset: \"+str(each))\n", - " print(\"---------------------------------------\")\n", - " full_path = experiment_path + '/' + each\n", - " original_headers = pd.read_csv(full_path + \"/exploratory/ProcessedFeatureNames.csv\", sep=',').columns.values.tolist() # Get Original Headers\n", - " for algorithm in algorithms: #loop through algorithms\n", - " print(\"Algorithm: \"+str(algorithm))\n", - " # Define evaluation stats variable lists\n", - " FI_ave = [0] * len(original_headers) # used to save average FI scores over all cvs. (all original features in dataset prior to feature selection included)\n", - " \n", - " for cv_count in range(0, cv_partitions): # loop through cv's\n", - " #Load pickled metric file for given algorithm and cv\n", - " result_file = full_path + '/model_evaluation/pickled_metrics/' + abbrev[algorithm] + \"_CV_\" + str(cv_count) + \"_metrics.pickle\"\n", - " file = open(result_file, 'rb')\n", - " results = pickle.load(file)\n", - " file.close()\n", - " \n", - " #Separate pickled results\n", - " fi = results[8]\n", - " \n", - " # Format feature importance scores as list (takes into account that all features are not in each CV partition)\n", - " tempList = []\n", - " j = 0\n", - " headers = pd.read_csv(full_path + '/CVDatasets/' + each + '_CV_' + str(cv_count) + '_Test.csv').columns.values.tolist()\n", - " if instance_label != None: \n", - " headers.remove(instance_label)\n", - " headers.remove(class_label)\n", - " for feature in original_headers:\n", - " if feature in headers: # Check if current feature from original dataset was in the partition\n", - " # Deal with features not being in original order (find index of current feature list.index()\n", - " f_index = headers.index(feature)\n", - " FI_ave[j] += fi[f_index]\n", - " j += 1\n", - " \n", - " #Turn FI sums into averages\n", - " for i in range(0, len(FI_ave)):\n", - " FI_ave[i] = FI_ave[i] / float(cv_partitions)\n", - "\n", - " fi_dict = {}\n", - " for key in original_headers:\n", - " for value in FI_ave:\n", - " fi_dict[key] = value\n", - " FI_ave.remove(value)\n", - " break \n", - " \n", - " print(fi_dict)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Extract and Output Testing Data Prediction Probabilities " - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------------------------\n", - "Dataset: hcc_data\n", - "---------------------------------------\n", - "Algorithm: Decision Tree\n", - "CV: 0\n", - "[0.40963855 0. 0. 0.65384615 0.73913043 0.\n", - " 0.65384615 0.65384615 1. 1. 0.73913043 0.0974212\n", - " 0. 0. 0.0974212 0.40963855 0. 0.40963855\n", - " 1. 0.40963855 1. 0.0974212 0.73913043 1.\n", - " 0. 0. 0. 0.40963855 0.40963855 0.28813559\n", - " 0. 0.0974212 0. 0.86624204 0.73913043 0.28813559\n", - " 0. 0. 1. 0.73913043 0.65384615 0.40963855\n", - " 0. 0.73913043 1. 0. 0.65384615 0.0974212\n", - " 0.0974212 0. 1. 0. 0.40963855 0.65384615\n", - " 0. ]\n", - "CV: 1\n", - "[0.61818182 0.03472932 0.03472932 0.44736842 1. 0.44736842\n", - " 1. 0.28813559 0. 0.51908397 0.03472932 0.51908397\n", - " 0.03472932 1. 0. 0.03472932 0.03472932 0.03472932\n", - " 0.03472932 1. 0.03472932 0.28813559 1. 0.51908397\n", - " 0.03472932 0.44736842 1. 1. 0.28813559 0.03472932\n", - " 1. 0.03472932 0. 0.03472932 0.03472932 0.28813559\n", - " 0.82926829 0.03472932 0.28813559 1. 1. 1.\n", - " 0.03472932 1. 0.51908397 0.03472932 1. 1.\n", - " 0.03472932 0.03472932 0.51908397 1. 0.03472932 0.82926829\n", - " 0.03472932]\n", - "CV: 2\n", - "[0.82926829 0.30630631 0.30630631 0.89005236 0.30630631 0.\n", - " 0. 0. 0.76404494 0.61818182 0. 0.\n", - " 0. 0.82926829 0.82926829 0.30630631 0.35051546 0.\n", - " 0.89005236 0.24460432 0.30630631 0. 0.89005236 0.24460432\n", - " 0.82926829 0.30630631 0.89005236 0.89005236 0.30630631 0.\n", - " 0. 0.35051546 0.61818182 0.61818182 0.24460432 0.30630631\n", - " 0.24460432 0.82926829 0.89005236 0.44736842 0.24460432 0.\n", - " 0.89005236 0.24460432 0.89005236 0.24460432 0. 0.\n", - " 0.89005236 0. 0. 0.82926829 0.35051546 0.\n", - " 0.82926829]\n", - "Algorithm: Logistic Regression\n", - "CV: 0\n", - "[0.10243969 0.36521402 0.79219946 0.29729119 0.40999958 0.9166584\n", - " 0.08156246 0.87732404 0.51531291 0.87749185 0.8846669 0.04375437\n", - " 0.0649787 0.00442223 0.6335645 0.15411756 0.01877892 0.02962374\n", - " 0.21284926 0.80870472 0.77311971 0.02786447 0.54796395 0.92979416\n", - " 0.03502072 0.02339422 0.04938803 0.69026286 0.00681252 0.010138\n", - " 0.06481761 0.96699357 0.06843035 0.3115648 0.84034724 0.01739876\n", - " 0.02824161 0.31452325 0.97669593 0.24476132 0.97233129 0.96746517\n", - " 0.62015695 0.97373291 0.60799655 0.05245576 0.06696346 0.13713535\n", - " 0.03394541 0.50104044 0.92390736 0.80860262 0.90935909 0.09305754\n", - " 0.05888322]\n", - "CV: 1\n", - "[0.57062159 0.44376916 0.15567988 0.94911811 0.09178888 0.22050546\n", - " 0.83561418 0.53275344 0.02207891 0.99121595 0.03068489 0.98685005\n", - " 0.32960006 0.99893729 0.25555859 0.69317741 0.77349158 0.03836811\n", - " 0.07728366 1. 0.78512889 0.94145682 0.58162832 0.88920279\n", - " 0.54463188 0.06138869 0.0174368 0.63556573 0.25918736 0.25172054\n", - " 0.98141627 0.96154244 0.04925853 0.57920265 0.08738649 0.89846907\n", - " 0.9948029 0.02008428 0.45056377 0.98352185 0.8934077 0.958178\n", - " 0.5036484 0.88423131 0.57378292 0.16594009 0.05496957 0.0396632\n", - " 0.08283056 0.16419068 0.99120657 0.08392869 0.95336586 0.271061\n", - " 0.27079294]\n", - "CV: 2\n", - "[0.49127833 0.49248539 0.48928833 0.52546154 0.48434932 0.47446361\n", - " 0.44422396 0.43455328 0.5374557 0.54629792 0.44345091 0.47594214\n", - " 0.47260808 0.47557553 0.51500796 0.47713745 0.45033858 0.44903219\n", - " 0.51850186 0.55706458 0.47268979 0.45588247 0.55167635 0.52278731\n", - " 0.5329314 0.5128118 0.50524292 0.53128454 0.46668769 0.48788902\n", - " 0.47647443 0.50580112 0.51549467 0.50283022 0.67093914 0.49680639\n", - " 0.52238015 0.49428949 0.54735095 0.48239571 0.53183462 0.44688997\n", - " 0.51613641 0.45835299 0.51430678 0.47106313 0.47861655 0.46344229\n", - " 0.49619777 0.43064124 0.45682252 0.49302749 0.47359741 0.44083287\n", - " 0.57871822]\n", - "Algorithm: Naive Bayes\n", - "CV: 0\n", - "[2.88081452e-01 8.64634060e-01 9.76492656e-01 9.99999990e-01\n", - " 9.99366926e-01 9.99999892e-01 5.74027257e-06 0.00000000e+00\n", - " 9.99052628e-01 9.99997858e-01 9.99998776e-01 0.00000000e+00\n", - " 9.99734915e-01 2.28945591e-01 9.99999962e-01 8.23197742e-01\n", - " 2.85198607e-01 8.22761383e-01 9.70645651e-01 9.99995467e-01\n", - " 9.99745037e-01 5.10577912e-01 9.99999279e-01 9.99999304e-01\n", - " 5.29983528e-02 0.00000000e+00 6.43394623e-01 9.99432358e-01\n", - " 0.00000000e+00 3.93473857e-01 6.18301021e-01 1.00000000e+00\n", - " 1.85333128e-01 9.99021199e-01 9.99652576e-01 2.03854712e-01\n", - " 7.11703555e-03 9.83978363e-01 9.99996493e-01 0.00000000e+00\n", - " 1.00000000e+00 2.22911992e-15 9.99957447e-01 9.99999587e-01\n", - " 9.86704786e-01 5.65169717e-02 9.88404126e-01 9.38760970e-01\n", - " 9.86976015e-01 9.97918111e-01 9.99704735e-01 9.99810298e-01\n", - " 9.99954841e-01 9.96816707e-01 0.00000000e+00]\n", - "CV: 1\n", - "[1.38896322e-05 1.58683906e-01 7.68892260e-05 9.99993872e-01\n", - " 1.14797728e-05 1.37593608e-05 9.81915653e-01 5.74148619e-02\n", - " 8.62529259e-08 1.00000000e+00 1.90951166e-08 9.96190601e-01\n", - " 3.35212191e-06 9.99246259e-01 4.70987687e-06 2.71507687e-03\n", - " 9.03149796e-02 2.53073393e-04 1.18581307e-01 1.00000000e+00\n", - " 9.99996289e-01 3.03598261e-01 8.82670139e-04 7.08993430e-01\n", - " 2.98950336e-03 7.54459316e-07 2.46204219e-07 1.17199668e-03\n", - " 1.00000000e+00 1.94132939e-02 9.82294732e-01 3.40963854e-01\n", - " 3.64297876e-07 1.00000000e+00 1.80893059e-08 2.30997637e-02\n", - " 1.00000000e+00 2.79817471e-05 6.96025879e-06 9.99344267e-01\n", - " 6.25409167e-03 5.50548276e-01 6.80963552e-07 9.99790415e-01\n", - " 1.43457465e-02 8.86125004e-05 3.59751142e-05 1.09659845e-05\n", - " 1.00000000e+00 5.92703028e-05 1.00000000e+00 3.30592162e-06\n", - " 9.29219247e-01 9.98029645e-01 9.94867436e-02]\n", - "CV: 2\n", - "[4.15256564e-07 2.55900507e-08 1.24023046e-04 1.96401361e-05\n", - " 1.00000000e+00 9.99986817e-01 6.05771236e-10 2.68576570e-10\n", - " 4.11685718e-04 2.34571694e-03 4.64067954e-11 7.06800911e-08\n", - " 8.34585478e-09 1.63865222e-08 2.34362902e-07 8.97823274e-05\n", - " 1.04456827e-09 2.05557171e-09 1.02797673e-04 9.99619911e-01\n", - " 2.52136486e-07 8.56863192e-10 8.39971409e-03 3.62746113e-05\n", - " 7.32220089e-05 6.77218255e-01 6.88462581e-06 2.09504050e-03\n", - " 3.86828136e-08 1.15722988e-06 1.34756322e-07 6.68795875e-06\n", - " 6.86316928e-03 2.49124281e-07 1.00000000e+00 9.99996906e-01\n", - " 6.37895623e-04 1.85304964e-07 9.99561773e-01 1.57962601e-08\n", - " 6.95912785e-04 8.97914645e-10 5.73714956e-05 1.00000000e+00\n", - " 3.17523973e-01 1.50629376e-10 8.84436564e-09 1.65236093e-09\n", - " 1.28709891e-07 4.27833304e-11 6.71759055e-10 1.67904435e-05\n", - " 1.32198468e-08 1.42027232e-04 1.00000000e+00]\n", - "---------------------------------------\n", - "Dataset: hcc_data_custom\n", - "---------------------------------------\n", - "Algorithm: Decision Tree\n", - "CV: 0\n", - "[0.39306358 0.39306358 0.39306358 0.7228739 0.7228739 0.7228739\n", - " 0.16267943 0.7228739 0.7228739 0.7228739 0.7228739 0.7228739\n", - " 0.39306358 0.39306358 0.7228739 0.7228739 0.39306358 0.16267943\n", - " 0.39306358 0.39306358 0.39306358 0.16267943 0.7228739 0.7228739\n", - " 0.16267943 0.7228739 0.39306358 0.39306358 0.39306358 0.16267943\n", - " 0.39306358 0.7228739 0.16267943 0.7228739 0.7228739 0.16267943\n", - " 0.39306358 0.7228739 0.7228739 0.7228739 0.7228739 0.7228739\n", - " 0.7228739 0.16267943 0.39306358 0.39306358 0.16267943 0.39306358\n", - " 0.16267943 0.39306358 0.7228739 0.7228739 0.7228739 0.7228739\n", - " 0.16267943]\n", - "CV: 1\n", - "[0.37142857 0.07692308 0.07692308 0.37142857 0.72222222 0.37142857\n", - " 0.72222222 0.72222222 0.07692308 0.72222222 0.07692308 0.72222222\n", - " 0.07692308 0.72222222 0.37142857 0.37142857 0.07692308 0.07692308\n", - " 0.07692308 0.72222222 0.37142857 0.72222222 0.72222222 0.72222222\n", - " 0.37142857 0.37142857 0.37142857 0.72222222 0.72222222 0.07692308\n", - " 0.37142857 0.07692308 0.37142857 0.37142857 0.07692308 0.72222222\n", - " 0.37142857 0.37142857 0.72222222 0.72222222 0.72222222 0.72222222\n", - " 0.37142857 0.72222222 0.72222222 0.07692308 0.07692308 0.72222222\n", - " 0.07692308 0.07692308 0.72222222 0.72222222 0.37142857 0.37142857\n", - " 0.37142857]\n", - "CV: 2\n", - "[0.46153846 0.91322314 1. 0.91322314 1. 0.50295858\n", - " 0.50295858 0.50295858 0.91322314 0.46153846 0.50295858 0.91322314\n", - " 0.56431535 0.50295858 0.91322314 0. 0.50295858 0.50295858\n", - " 0.56431535 1. 0.50295858 0. 0.56431535 0.46153846\n", - " 0. 1. 0.91322314 0.56431535 0.50295858 0.91322314\n", - " 0.56431535 0.56431535 0. 0.50295858 1. 0.56431535\n", - " 0.46153846 0. 0.46153846 0.91322314 1. 0.\n", - " 0.46153846 0.56431535 0.24460432 0.91322314 0.56431535 0.56431535\n", - " 0. 0.91322314 0. 0.46153846 0. 0.46153846\n", - " 0.46153846]\n", - "Algorithm: Logistic Regression\n", - "CV: 0\n", - "[0.49534041 0.49924569 0.4976448 0.50120487 0.502234 0.50372162\n", - " 0.49971729 0.5051638 0.50092144 0.50297836 0.50165006 0.49832391\n", - " 0.49619632 0.49624706 0.50252345 0.4988254 0.49656363 0.49717114\n", - " 0.49896716 0.49836886 0.50280489 0.49736934 0.50035052 0.50480577\n", - " 0.49456697 0.500838 0.49622699 0.49912212 0.49791418 0.49598444\n", - " 0.49630493 0.50701336 0.49542938 0.50015409 0.50003155 0.49337832\n", - " 0.49580408 0.49886378 0.50429297 0.5002302 0.50717668 0.50441907\n", - " 0.50024311 0.5022457 0.49991528 0.49663962 0.4988762 0.49831484\n", - " 0.49963585 0.49979832 0.50134129 0.50117852 0.50181743 0.5006964\n", - " 0.49897595]\n", - "CV: 1\n", - "[0.49934229 0.50312423 0.49699443 0.50323717 0.49781363 0.49563526\n", - " 0.50086184 0.49986035 0.49471105 0.50493138 0.4917973 0.50792869\n", - " 0.49483157 0.51368698 0.49784287 0.50033498 0.50123279 0.49972565\n", - " 0.49923414 0.54008415 0.50125573 0.50439583 0.49890217 0.50433567\n", - " 0.50219178 0.49813991 0.49650812 0.50428752 0.5003806 0.50163334\n", - " 0.5089707 0.50283171 0.49559923 0.50822726 0.49230972 0.50054243\n", - " 0.50853239 0.49618323 0.49567526 0.51002111 0.50192922 0.50617477\n", - " 0.4964557 0.50649467 0.50247193 0.49939558 0.49439222 0.49708096\n", - " 0.49486112 0.49547626 0.51036192 0.49694714 0.50245629 0.50312417\n", - " 0.50094537]\n", - "CV: 2\n", - "[0.30590761 0.45944333 0.33289458 0.69374734 0.2058136 0.4293158\n", - " 0.30742753 0.22026122 0.65149025 0.80703383 0.23538628 0.33049569\n", - " 0.3661809 0.45280746 0.52993546 0.47193849 0.26744405 0.32156885\n", - " 0.76340774 0.85557832 0.32441489 0.26128677 0.70457271 0.59285428\n", - " 0.71008276 0.58848565 0.51640687 0.58837349 0.2074762 0.30706191\n", - " 0.2672458 0.42882612 0.49425142 0.53226958 0.95510114 0.45405635\n", - " 0.60451223 0.51167468 0.58952191 0.39946654 0.64329876 0.19024327\n", - " 0.47163489 0.17852688 0.44166451 0.38443484 0.37586281 0.34609483\n", - " 0.44989869 0.1928648 0.20537833 0.45551449 0.36649914 0.28074405\n", - " 0.6766802 ]\n", - "Algorithm: Naive Bayes\n", - "CV: 0\n", - "[9.95853212e-01 8.13730643e-01 9.53358378e-01 9.99999996e-01\n", - " 9.99969246e-01 9.99999988e-01 9.99801635e-01 0.00000000e+00\n", - " 9.99800131e-01 9.99998564e-01 9.99987817e-01 0.00000000e+00\n", - " 9.96476406e-01 1.75126635e-01 9.99999898e-01 5.68633272e-01\n", - " 3.25779094e-01 8.41365157e-01 8.97976004e-01 8.85612851e-03\n", - " 9.99991603e-01 9.99843039e-01 9.99981308e-01 9.99999739e-01\n", - " 4.28498316e-03 0.00000000e+00 9.58647560e-02 9.93540219e-01\n", - " 0.00000000e+00 7.64851217e-02 8.24737631e-02 1.00000000e+00\n", - " 5.42683244e-02 9.97812258e-01 9.88032185e-01 0.00000000e+00\n", - " 1.58653991e-03 9.69392398e-01 9.99999770e-01 0.00000000e+00\n", - " 1.00000000e+00 1.15558492e-14 9.99858521e-01 9.99999203e-01\n", - " 9.99237751e-01 3.03590023e-07 9.94187194e-01 9.56173544e-01\n", - " 9.95457789e-01 9.96145743e-01 9.99983247e-01 9.99688129e-01\n", - " 9.99880816e-01 9.99648589e-01 0.00000000e+00]\n", - "CV: 1\n", - "[1.27116780e-04 8.50666158e-01 7.56584598e-03 9.99999416e-01\n", - " 2.22029376e-05 1.02949383e-05 7.45020111e-01 3.57612854e-01\n", - " 1.98509778e-06 1.00000000e+00 2.03335355e-12 9.98930839e-01\n", - " 2.95249869e-06 9.99998175e-01 3.47674814e-05 2.24544660e-03\n", - " 1.96867516e-01 7.00251906e-03 1.22761587e-03 1.00000000e+00\n", - " 9.99983256e-01 9.02266302e-01 3.17871039e-04 3.67470279e-01\n", - " 1.46405753e-02 2.03176280e-04 4.77577039e-06 1.65019381e-02\n", - " 9.55881292e-04 5.88803875e-01 9.99366607e-01 2.02457966e-05\n", - " 4.30383283e-07 1.00000000e+00 1.19070291e-08 5.79310374e-03\n", - " 1.00000000e+00 1.31999303e-03 1.79505385e-06 9.99993738e-01\n", - " 2.02864528e-02 9.66332113e-01 2.11184497e-06 9.99120537e-01\n", - " 7.25405135e-02 3.12685674e-07 1.36511673e-06 2.56994490e-05\n", - " 4.54252430e-07 3.43500255e-05 1.00000000e+00 4.43289611e-06\n", - " 4.37509290e-01 9.53545761e-02 8.44971657e-01]\n", - "CV: 2\n", - "[5.60264574e-08 2.12628928e-07 1.08158631e-05 2.59936194e-04\n", - " 3.69439090e-11 6.27628652e-07 2.50494900e-08 4.20626389e-10\n", - " 3.62669682e-04 4.55084516e-02 2.89475802e-10 3.48454463e-07\n", - " 1.10456395e-08 1.13797762e-07 3.60938246e-07 4.72493991e-04\n", - " 2.29007400e-09 2.54777131e-08 3.70482359e-03 9.99998950e-01\n", - " 3.53354608e-07 4.60723744e-10 6.62014704e-03 1.02258410e-04\n", - " 1.68531448e-03 8.98443382e-01 2.78982677e-05 2.15818565e-03\n", - " 1.10531967e-08 6.10181983e-08 3.70596068e-09 4.30043579e-07\n", - " 1.14537000e-02 4.94031634e-07 1.00000000e+00 9.99987675e-01\n", - " 1.42679847e-03 1.53536674e-06 9.98547729e-01 4.96955438e-08\n", - " 6.60972762e-04 1.54774868e-10 2.96702464e-05 1.00000000e+00\n", - " 1.35458113e-01 2.04265858e-09 3.39877786e-08 5.28572734e-09\n", - " 8.98911683e-08 3.12254190e-11 2.25580548e-10 6.77701730e-06\n", - " 8.20141465e-08 5.23784021e-04 1.00000000e+00]\n" - ] - } - ], - "source": [ - "if target_data_list: # User specified one analyzed dataset above (if more than one were analyzed)\n", - " for each in datasets:\n", - " if not each in target_data_list:\n", - " datasets.remove(each)\n", - "\n", - "for each in datasets: \n", - " print(\"---------------------------------------\")\n", - " print(\"Dataset: \"+str(each))\n", - " print(\"---------------------------------------\")\n", - "\n", - " full_path = experiment_path + '/' + each\n", - " \n", - " # Make folder in experiment folder/datafolder to store all prediction probabilities per algorithm/CV combination\n", - " if not os.path.exists(full_path + '/model_evaluation/prediction_probas'):\n", - " os.mkdir(full_path + '/model_evaluation/prediction_probas')\n", - " \n", - " original_headers = pd.read_csv(full_path + \"/exploratory/OriginalFeatureNames.csv\", sep=',').columns.values.tolist() #Get Original Headers\n", - " for algorithm in algorithms: #loop through algorithms\n", - " print(\"Algorithm: \"+str(algorithm))\n", - "\n", - " for cv_count in range(0,cv_partitions): #loop through cv's\n", - " print(\"CV: \"+str(cv_count))\n", - " #Load pickled metric file for given algorithm and cv\n", - " result_file = full_path + '/model_evaluation/pickled_metrics/' + abbrev[algorithm] + \"_CV_\" + str(cv_count) + \"_metrics.pickle\"\n", - " file = open(result_file, 'rb')\n", - " results = pickle.load(file)\n", - " file.close()\n", - " \n", - " #Load associated testing dataset\n", - " test_data = pd.read_csv(full_path + '/CVDatasets/'+each+'_CV_' + str(cv_count) + '_Test.csv')\n", - " probas_summary = test_data[[class_label,instance_label]]\n", - "\n", - " #Separate pickled results\n", - " probas_ = results[9]\n", - " print(probas_[:,1])\n", - " probas_summary['1_prob'] = probas_[:,1]\n", - " file_name = full_path + '/model_evaluation/prediction_probas/' + algorithm + '_CV_'+str(cv_count) + '_class1_probas.csv'\n", - " probas_summary.to_csv(file_name, index=False)" - ] - } - ], - "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.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/checker.py b/checker.py deleted file mode 100644 index 38dde80a..00000000 --- a/checker.py +++ /dev/null @@ -1,23 +0,0 @@ -import sys -import argparse -from streamline.utils.checker import check_phase - - -def main(argv): - parser = argparse.ArgumentParser(description='program to check if run is complete') - parser.add_argument('--out-path', dest='output_path', type=str, help='path to output directory') - parser.add_argument('--exp-name', dest='experiment_name', type=str, help='name of experiment (no spaces)') - parser.add_argument('--phase', dest='phase', type=int, default=5, help='phase to check') - parser.add_argument('--count-only', dest='len_only', type=bool, default=False, help='show only no of jobs') - parser.add_argument('--rep-data-path', dest='rep_data_path', type=str, default='', - help='replication dataset path') - parser.add_argument('--dataset-for-rep', dest='dataset_for_rep', - type=str, default='', help='train dataset for replication path') - - options = parser.parse_args(argv[1:]) - check_phase(options.output_path, options.experiment_name, options.phase, options.len_only, - options.rep_data_path, options.dataset_for_rep) - - -if __name__ == "__main__": - sys.exit(main(sys.argv)) diff --git a/data/DemoData/hcc_data.csv b/data/DemoData/hcc_data.csv deleted file mode 100644 index 2668fdaf..00000000 --- a/data/DemoData/hcc_data.csv +++ /dev/null @@ -1,166 +0,0 @@ -InstanceID,Gender,Symptoms ,Alcohol,Hepatitis B Surface Antigen,Hepatitis B e Antigen,Hepatitis B Core Antibody,Hepatitis C Virus Antibody,Cirrhosis,Endemic Countries,Smoking,Diabetes,Obesity,Hemochromatosis,Arterial Hypertension,Chronic Renal Insufficiency,Human Immunodeficiency Virus,Nonalcoholic Steatohepatitis,Esophageal Varices,Splenomegaly,Portal Hypertension,Portal Vein Thrombosis,Liver Metastasis,Radiological Hallmark,Age at diagnosis,Grams of Alcohol per day,Packs of cigarets per year,Performance Status*,Encephalopathy degree*,Ascites degree*,International Normalised Ratio*,Alpha-Fetoprotein (ng/mL),Haemoglobin (g/dL),Mean Corpuscular Volume,Leukocytes(G/L),Platelets,Albumin (mg/dL),Total Bilirubin(mg/dL),Alanine transaminase (U/L),Aspartate transaminase (U/L),Gamma glutamyl transferase (U/L),Alkaline phosphatase (U/L),Total Proteins (g/dL),Creatinine (mg/dL),Number of Nodules,Major dimension of nodule (cm),Direct Bilirubin (mg/dL),Iron,Oxygen Saturation (%),Ferritin (ng/mL),Class -0,1,0,1,0,0,0,0,1,0,1,1,,1,0,0,0,0,1,0,0,0,0,1,67,137,15,0,1,1,1.53,95,13.7,106.6,4.9,99,3.4,2.1,34,41,183,150,7.1,0.7,1,3.5,0.5,,,,0 -1,0,,0,0,0,0,1,1,,,1,0,0,1,0,0,0,1,0,0,0,0,1,62,0,,0,1,1,,,,,,,,,,,,,,,1,1.8,,,,,0 -2,1,0,1,1,0,1,0,1,0,1,0,0,0,1,1,0,0,0,0,1,0,1,1,78,50,50,2,1,2,0.96,5.8,8.9,79.8,8.4,472,3.3,0.4,58,68,202,109,7,2.1,5,13,0.1,28,6,16,0 -3,1,1,1,0,0,0,0,1,0,1,1,0,0,1,0,0,0,0,0,0,0,1,1,77,40,30,0,1,1,0.95,2440,13.4,97.1,9,279,3.7,0.4,16,64,94,174,8.1,1.11,2,15.7,0.2,,,,1 -4,1,1,1,1,0,1,0,1,0,1,0,0,0,1,1,0,0,0,0,0,0,0,1,76,100,30,0,1,1,0.94,49,14.3,95.1,6.4,199,4.1,0.7,147,306,173,109,6.9,1.8,1,9,,59,15,22,0 -5,1,0,1,0,,0,0,1,0,,0,1,0,0,0,0,0,1,1,1,0,0,1,75,,,1,1,2,1.58,110,13.4,91.5,5.4,85,3.4,3.5,91,122,242,396,5.6,0.9,1,10,1.4,53,22,111,1 -6,1,0,0,0,,1,1,1,0,0,1,0,,0,0,0,0,0,0,0,0,0,1,49,0,0,0,1,1,1.4,138.9,10.4,102,3.2,42000,2.35,2.72,119,183,143,211,7.3,0.8,5,2.6,2.19,171,126,1452,1 -7,1,1,1,0,,0,0,1,0,1,1,,0,0,0,0,0,0,1,1,1,0,1,61,,20,3,1,1,1.46,9860,10.8,92,3,58,3.1,3.2,79,108,184,300,7.1,0.52,2,9,1.3,42,25,706,1 -8,1,1,1,0,0,0,0,1,0,1,1,0,0,1,0,0,0,,1,1,0,0,1,50,100,32,1,1,2,3.14,8.8,11.9,107.5,4.9,70,1.9,3.3,26,59,115,63,6.1,0.59,1,6.4,1.2,85,73,982,0 -9,1,1,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,43,100,0,0,1,1,1.12,1.8,11.8,87.8,5100,193000,4.2,0.5,71,45,256,303,7.1,0.59,1,9.3,0.7,,,,0 -10,1,0,1,0,0,0,1,1,,,0,0,0,0,0,0,0,,1,1,0,0,1,41,,,0,1,2,1.05,100809,13,94.2,5.7,196,4.4,3,90,334,494,236,7.6,0.8,5,,1.1,,,,1 -11,1,0,1,0,0,0,1,1,1,0,0,0,0,1,0,0,0,,0,1,0,0,1,74,,0,0,1,1,1.33,86,15.7,96.7,4,61,3.7,1.3,132,168,113,154,,7.6,5,1.9,0.3,144,41,277,0 -12,1,0,1,0,0,0,0,1,0,1,1,0,0,1,0,0,,,1,1,1,0,0,66,,30,0,1,1,1.53,60,13.3,90.1,5.5,207000,4.4,8.5,25,36,35,74,8.5,0.73,1,5,0.8,,,,0 -13,1,,0,0,0,0,1,1,,,0,0,0,0,0,0,0,0,0,0,0,0,1,56,0,,0,1,1,1.2,6.6,13.7,93.8,4.1,91000,4.5,1,103,96,205,70,8.8,0.88,1,22,,82,24,,0 -14,1,0,1,0,0,0,0,1,0,,1,0,0,1,0,0,,1,1,1,0,0,1,63,,,2,2,2,1.25,29,13.5,93,6,128,3.15,10.5,76,116,165,163,7.3,1.07,4,4.5,4.5,197,84,302,0 -15,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,1,41,100,0,1,1,2,1.61,4.6,10.2,89.6,5.5,161,3.1,3.1,24,57,163,176,5,0.8,2,2.6,1.3,25,13,60,0 -16,1,0,1,0,0,0,0,1,,1,1,,1,0,0,0,,,1,1,1,0,1,72,,,3,2,1,2.14,60,12.1,99.2,5,58,2.4,9.8,69,63,201,235,6.2,0.96,2,2,2.9,136,95,767,1 -17,1,1,1,0,0,0,0,1,0,1,0,0,,0,0,0,,1,1,1,1,1,1,60,100,60,2,1,1,1.05,9.2,10.3,103.7,5.4,159,3.8,0.5,56,91,459,146,5.4,1.23,5,13.5,3.8,187,58,443,0 -18,1,,1,0,0,0,0,1,,1,0,,0,1,1,0,0,1,0,0,0,0,1,64,200,78,1,1,1,1.13,8.8,14.9,94.8,6.3,137,4.3,0.9,16,23,82,180,6.5,4.95,1,5.4,0.9,144,49,295,0 -19,1,1,1,0,0,0,0,1,,,0,0,0,1,0,0,0,1,1,1,1,0,1,75,500,,0,1,3,1.44,34,15.9,103.4,9600,101000,3.4,3.4,27,87,260,147,6.3,0.9,5,2.3,1.6,67,34,774,1 -20,1,0,1,0,0,0,0,1,,1,0,1,0,0,0,0,0,1,1,1,0,0,0,71,200,60,0,1,1,1.29,19.6,11.7,101,2600,109000,3.6,1.7,13,35,23,141,7.3,0.68,1,2.5,0.7,152.6,,76.9,0 -21,1,0,1,0,0,1,1,1,0,1,0,0,0,0,0,0,0,,0,0,0,0,0,73,80,47,0,1,1,1.06,3.9,16.4,90.7,7.8,187,4.5,1,54,47,52,97,6.3,0.75,1,6.8,0.2,87,26,84,0 -22,1,1,1,0,0,1,0,1,,0,0,1,0,1,0,0,0,0,1,1,0,0,1,66,180,0,1,1,3,1.27,1975,10.8,86.5,9100,154000,3.1,1.2,68,136,869,562,69,1.14,5,3.8,0.5,112,73,1001,1 -23,1,1,1,0,0,0,0,1,1,1,1,0,0,1,0,0,0,1,1,1,1,1,1,64,200,60,1,1,1,4.82,185,10.7,88.1,5,194000,3.6,3.8,217,86,879,396,7,0.53,5,15,1.6,,,,1 -24,1,1,1,0,,1,0,0,0,1,0,0,,1,0,,0,,0,,0,1,0,84,150,,4,1,1,1.74,5532,13.1,111,3.5,351000,2.4,1.3,26,67,108,311,5.6,0.95,1,10,0.7,,,,1 -25,1,0,1,0,,0,0,1,0,0,1,0,0,0,0,0,0,1,1,1,1,0,1,80,100,0,2,1,1,1.33,13327,13.7,94.3,5.2,110,3.1,1.6,52,107,465,233,8.4,0.79,5,,0.7,93,31,79,0 -26,1,1,1,,,,1,1,0,1,0,0,,0,0,,0,1,1,1,1,0,1,45,50,16,1,1,3,1.38,,13.6,98.4,4.3,99000,3.3,1.3,178,325,252,172,8.1,0.83,1,5,0.7,,,,1 -27,1,,1,1,0,1,0,1,,,0,0,0,0,0,0,0,1,1,1,0,0,1,57,,,0,1,1,1.37,5.9,15.5,88.2,4.9,113,4.5,3.2,36,65,34,111,,,2,4,1,180,56,,0 -28,1,0,1,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,1,1,1,0,1,61,60,67.5,1,1,1,1.3,3255,12.2,89.5,4.4,108,3,1.1,59,85,419,293,7.7,0.67,2,6.5,0.4,94,27,70,1 -29,1,1,1,0,,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,20,,2,1,1,1,1.21,1.9,9.9,83.4,8.1,556,3.2,1.8,150,112,599,974,7.7,0.7,5,,1.1,22,7,369,0 -30,1,1,1,1,0,,0,1,1,1,0,0,0,0,0,0,0,,1,1,1,0,1,60,20,8,2,1,1,1.19,11,13.1,87.9,7.8,212,3.5,0.7,27,26,143,158,8.2,0.71,1,16,,,,,0 -31,1,0,1,0,,0,0,1,,1,1,,0,1,0,0,0,1,1,1,0,0,1,62,120,,0,1,1,1.44,1237,12.2,94,6200,93000,4.2,1,35,85,191,129,58,1.06,5,7,,75,24,239,0 -32,1,1,1,,,,0,1,,,0,0,0,0,0,0,0,0,0,0,0,0,1,67,100,,0,1,1,1.32,7.7,15.7,96.1,9.1,268000,3.4,0.6,20,29,49,135,8.2,0.9,2,,,,,,0 -33,1,1,1,0,,0,0,1,,,0,0,0,1,0,0,,0,0,0,0,0,1,77,,,0,1,1,1.24,266,13.7,97.7,13000,170000,4.2,0.5,68,85,232,227,16.8,1.72,1,5.9,,,,,0 -34,1,1,1,1,0,1,0,1,,0,0,0,0,1,0,0,0,1,0,1,0,0,0,62,,0,0,1,1,1.28,5689,14.3,99.6,6.8,77,3.8,1.7,154,102,184,184,6.9,0.89,2,3,0.77,,,,0 -35,1,,0,1,,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,76,0,0,0,1,1,0.96,14.2,14.8,98.5,4.95,187,4.2,0.77,43,86,89,113,6.7,0.95,3,8.8,0.37,,,,0 -36,1,1,1,0,0,0,0,1,0,0,1,0,0,1,0,0,0,,1,1,0,0,1,73,75,0,4,1,2,2,3.1,13.1,109.3,44.6,60,2.3,7.8,38,74,180,127,5.6,0.88,5,3.1,3.3,98,89,870,1 -37,1,1,1,0,0,0,0,1,,1,1,0,,1,0,0,,,0,1,0,0,1,84,200,30,1,1,2,1.24,633,13,96.5,7200,143000,2.3,1.1,40,58,322,209,6.7,1.4,5,4.9,0.2,57,25,134,1 -38,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,70,100,0,0,1,1,1.09,5.4,14.9,105,7.2,230000,4.2,1.3,18,26,174,92,7.3,0.8,2,6,0.3,,,,0 -39,1,1,1,1,0,1,1,1,1,0,0,0,0,1,0,0,0,,0,,0,1,1,59,200,0,0,1,1,1.42,479,11.3,82.2,9500,160000,3.1,1.4,113,143,924,288,7.9,0.98,5,17,0.6,,,,0 -40,0,,0,0,0,1,1,1,0,0,0,0,,1,0,0,0,,,,0,0,1,71,0,0,0,1,1,1.18,19,13.9,88.3,6.86,201000,4.4,0.8,142,117,123,104,8.5,0.74,2,3.3,0.3,143,50.18,120,0 -41,1,0,0,0,0,1,0,1,0,0,1,1,0,1,0,0,0,,0,0,,,0,66,0,0,0,1,1,1.21,2.8,15.7,92.7,15.4,188000,4.1,0.7,299,553,196,68,6.5,1.3,1,5,0.3,,,,0 -42,0,0,1,0,0,0,0,1,,,0,0,0,0,0,0,0,,0,0,0,1,0,86,,,3,1,1,1.2,185203,15,85.5,8.8,183,3.6,1,49,117,442,278,7.2,0.86,5,15.8,0.3,21,9,279,1 -43,1,0,1,,,,,1,0,,0,1,0,0,0,,1,1,1,1,0,0,1,71,75,,0,1,1,1.17,5,15.1,104.1,4.3,65000,3.8,2.5,61,56,239,56,7.3,0.7,1,2,0.2,,,,0 -44,0,0,0,0,0,1,1,1,,0,0,0,0,0,0,0,0,,1,1,0,0,1,52,0,0,0,1,1,1.71,237,15.6,98.1,4.3,88,3.2,2.2,30,52,72,97,6.7,0.86,5,2.2,0.5,,,,0 -45,1,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,60,,0,0,1,1,1.18,2.8,16.6,93.8,8300,167000,4.9,0.9,35,29,62,68,8.3,0.72,1,2.3,,,,,0 -46,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,,,,45,0,0,0,1,1,,,,,,,,,,,,,,,,,,,,,0 -47,1,1,1,0,0,0,0,1,0,,0,0,0,0,0,0,0,1,1,1,1,1,0,66,,,1,1,2,1.64,16,14,102.9,11.5,277000,3.1,6.8,140,244,795,595,7.2,0.79,1,2.3,4.1,63,34,888,1 -48,1,1,0,0,0,0,0,0,0,1,1,0,0,1,1,0,1,0,0,0,0,0,0,80,0,80,0,1,1,1.33,163,10.6,96.2,9900,280000,3.3,1,28,57,236,171,7.5,1.38,1,19,,45,21,802,1 -49,1,,1,0,,1,0,1,0,1,0,0,0,0,0,0,0,1,1,1,0,0,0,58,,40,0,1,1,1.49,20,15,96.7,9,78,4.6,2.1,40,49,137,109,7.6,0.8,1,2,0.4,184,59,905,0 -50,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,,0,0,0,1,1,27,0,0,2,1,1,0.97,46,10.5,78.7,20.9,251,2.4,0.3,31,185,91,539,5,0.38,5,20,0.3,,,,1 -51,0,0,1,,,,1,1,,0,1,0,0,0,0,0,0,,1,1,0,1,0,73,100,0,0,1,1,1.2,41470,12.6,91.4,12,275000,3.11,2.3,55,94,394,350,7.3,1.7,5,,0.8,84,37,497,1 -52,1,1,1,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,73,,0,0,1,1,1.33,4.7,11.8,80.2,3.7,99,4.1,0.7,50,47,67,62,7.4,0.77,1,2.3,,104,37,635,0 -53,1,,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,1,1,0,0,1,50,,0,0,1,1,1.65,7.3,15.3,93.7,3500,57000,,1.4,111,93,294,130,,0.76,2,2,0.3,184,2.26,59,0 -54,1,1,1,0,0,0,1,1,,1,0,,,0,0,0,,1,1,1,1,0,1,51,100,30,3,1,2,1.35,1898,12.4,95.1,9.8,216,2.7,8.2,164,523,433,397,6.7,0.82,1,2.1,5.5,56,27,742,1 -55,0,1,0,,,,1,0,0,0,1,0,,1,0,,,0,,0,0,1,1,78,0,0,1,1,1,1.32,77,10.8,88,6000,174000,3.2,0.9,48,19,171,923,5.4,1.31,3,15.4,,,,,1 -56,1,1,1,0,,,,1,0,1,1,0,,1,0,0,,0,0,1,0,0,1,81,100,10,2,1,2,3.56,2.7,7.3,90.8,2.42,159000,3.4,0.5,25,32,80,55,6.2,0.85,1,2.2,,22,6,48,1 -57,1,,1,0,0,0,0,1,0,1,1,0,0,1,0,0,0,1,0,1,0,0,1,65,100,,0,1,1,1.24,2.6,10.3,83,6.1,1.71,3.9,0.8,11,28,77,120,7,0.58,1,4.7,0.85,32,10,18,0 -58,1,,1,0,0,0,0,1,0,0,1,,,0,0,0,,1,1,1,0,0,1,72,70,0,3,2,2,1.96,12,10.9,102,4.1,99,1.9,4.2,73,85,470,263,7,0.99,1,8.5,1.9,44,20,176,1 -59,1,1,0,,,,,0,0,1,1,0,,1,1,,0,0,0,0,0,0,0,82,0,,0,1,1,1.11,,18.7,92.4,6900,270000,4,0.9,35,73,115,103,6.8,1.24,1,10,,,,,1 -60,1,1,0,1,0,1,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,1,76,0,50,1,1,3,1.28,608,12.6,100,5.4,129,4,1.7,107,99,125,100,7.5,0.9,5,3.5,0.5,,,,0 -61,1,1,1,0,0,1,1,1,0,1,0,0,0,0,0,0,0,1,1,1,0,0,1,56,100,40,0,2,2,1.46,41,14.6,100.8,5.5,42000,3.1,3.7,121,165,101,207,6.3,0.69,1,3,1.9,224,95,363,0 -62,0,0,1,0,0,0,0,1,0,1,0,1,0,0,0,0,0,1,1,1,0,0,1,68,,30,2,1,2,1.94,,11.5,97.4,5700,77000,2.7,4.9,34,48,46,178,6.1,0.62,1,4.6,2.2,,,,0 -63,1,1,1,0,0,0,0,1,0,1,1,0,0,1,0,0,0,1,1,1,0,0,1,72,300,,3,1,3,1.57,2,12.6,96.6,2.9,76000,3.5,2.4,33,40,110,166,,0.77,1,2,0.5,,,,0 -64,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,,,,,0,0,0,66,0,0,0,1,1,1.29,7,12.1,95.1,3.8,77000,3.8,1.4,37,38,194,161,6.7,0.71,1,10,0.5,0,0,0,0 -65,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,,,0,0,1,0,40,0,0,2,1,1,1.17,3.1,15.1,86,8.9,275000,2.8,1.3,74,50,23,104,5.4,0.6,5,7.8,0.2,46,18,,1 -66,1,,1,0,,1,0,1,0,1,0,0,0,0,0,0,0,,1,1,0,0,1,68,60,,0,1,1,1.34,13,15.6,93,4.9,91000,4.54,1.4,54,52,275,113,7.8,0.55,2,6.2,0.3,94,33,393,0 -67,1,1,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,63,100,0,0,1,1,2.07,1.7,9.5,99.2,3300,79000,2.1,1.6,56,82,134,113,37,0.4,1,2.7,0.2,94,37,48,0 -68,1,1,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,,1,1,0,1,1,72,100,0,0,1,2,1.3,249,12.7,100.3,5.5,114,3.1,3.9,21,42,40,108,5.8,0.9,5,8,1.2,37,17,419,1 -69,0,1,1,0,0,1,0,1,,0,0,1,0,0,1,0,,,0,1,1,0,1,88,80,0,2,2,3,1.27,66,10.9,97.3,8.9,270,2.7,2.1,145,84,179,260,5.9,,5,3,1.3,15,17,639,1 -70,0,1,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,,1,1,0,0,1,23,0,0,0,1,1,1.17,358,12.7,74,2.2,51,2.9,2.8,53,41,54,94,4.9,0.2,2,5.4,0.8,50,16,20,0 -71,1,1,1,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,1,1,1,59,75,44,3,2,2,1.01,1810346,13,102.1,8300,433000,3.4,1.9,138,86,1575,417,6.5,0.64,5,15,1.1,,,,0 -72,1,1,1,0,0,0,0,1,,1,0,0,0,1,0,0,0,,1,1,1,1,0,82,50,48,2,1,2,1.53,33502,14.4,101.1,11.6,109,3.1,2.3,27,80,177,1.28,6.7,1.5,5,4,0.8,26,15,227,0 -73,1,1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,,0,0,1,1,1,67,,0,0,1,1,0.94,20,13,92,6.9,222000,3.7,0.6,162,354,1390,684,7.1,0.81,5,,,,,,1 -74,1,1,1,0,,0,0,1,0,1,0,0,0,1,0,0,0,1,1,1,0,0,1,61,,15,0,1,1,1.15,2.5,14.9,92.3,6,159000,3.8,1,28,38,74,101,7.4,1.1,5,7.5,0.3,61,,255,0 -75,1,1,1,0,,,1,1,,,0,0,0,0,0,0,0,1,1,1,0,0,1,61,100,,0,1,1,1.92,2269,12.1,119,5.1,80000,,9.6,204,357,199,174,,0.99,1,7.6,4.6,178,90,960,1 -76,1,1,1,0,0,0,0,1,0,,0,0,0,1,0,0,0,1,0,1,1,0,0,67,,,2,1,2,3.16,4181,9.1,103.6,5.1,128000,3,2.2,57,91,115,165,7.7,0.83,1,4.5,1.2,72,29.5,355,1 -77,1,1,1,0,0,0,0,1,,,0,0,0,0,0,0,0,,0,1,0,0,1,78,80,,0,1,1,1.45,5.1,14.4,100.2,7.1,77000,4.1,0.9,43,63,540,114,7,1.09,5,,,,,,0 -78,1,1,1,0,0,0,0,1,0,,0,0,0,0,0,0,0,,0,1,0,1,1,52,80,,3,1,1,1.34,345,9.8,81.8,13.6,561,2.6,0.5,43,43,23,88,5.6,,5,4.7,0.5,19,8,141,0 -79,1,,1,0,0,0,1,1,,1,0,0,0,0,0,0,0,1,1,1,0,0,0,51,100,34.5,2,2,2,2.08,2.9,10.4,91.1,5.8,91000,2.4,16,123,145,109,190,5.9,0.9,0,,9.6,,,,0 -80,1,1,1,,,,,1,0,,1,0,0,1,1,0,,,1,1,0,1,1,74,,,3,2,1,1.32,2.5,12.6,83.7,9.8,102000,3.3,1.2,29,43,196,204,7.3,1.1,5,,0.5,,,,1 -81,1,0,1,0,,0,0,1,0,,1,0,0,0,0,0,0,1,1,1,0,0,1,56,100,,1,2,1,1.63,5.04,15.8,99,5.8,75000,3.5,4.6,93,85,193,165,6.6,0.7,1,6,1.7,200,87,316,0 -82,1,0,1,0,0,0,0,1,0,0,,,,1,1,0,0,0,,1,0,0,0,64,100,0,1,1,3,1.71,3.7,14.8,104.3,5.8,56000,2.7,2.6,74,157,311,280,8,0.8,2,3,1.4,,1.52,859,0 -83,1,1,1,0,0,0,0,1,0,,0,0,0,0,0,0,0,1,1,1,1,0,1,83,100,,2,1,3,1.48,2.6,12.7,106,3.8,80,2.9,3.4,34,53,156,207,7.2,,2,4.1,1.4,105,69,221,1 -84,1,,0,0,0,0,1,1,,1,1,0,0,1,0,0,0,0,1,0,0,0,1,57,0,,0,,,1.1,2.9,16.4,94.8,4.6,94000,4.1,1.1,104,74,88,85,7.9,1.05,1,5.5,0.3,,,,0 -85,1,1,1,0,0,1,0,1,0,1,0,1,0,0,0,0,0,0,1,1,1,0,1,58,,10,1,2,1,1.47,20,13.9,100.8,4,112000,3,2.9,50,92,124,244,6.3,0.8,2,6.8,0.7,181,99,108,0 -86,1,1,1,0,0,0,0,1,0,,0,0,0,0,0,0,0,,0,1,0,1,1,71,,,1,1,1,1.08,2.79,12.6,83.9,7100,284000,,,28,46,70,213,,0.48,5,,,26,8,,0 -87,1,0,0,0,0,1,1,1,0,1,0,0,0,0,0,1,0,0,1,1,0,0,1,52,0,33,0,1,2,,42,15.8,97.9,4.2,142000,4.2,0.5,74,62,38,70,7.5,0.77,3,1.5,,120,35,30,0 -88,1,1,1,0,0,0,0,1,0,,1,0,0,0,0,0,0,1,1,1,0,0,1,74,100,,0,1,2,1.37,457,11.7,70.6,5.7,138000,4.1,2.1,22,33,33,90,9.7,1.6,5,5.6,0.9,13,3,28,1 -89,1,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,1,1,0,0,1,61,,50,1,2,3,1.23,,9.5,90,7.6,38000,2.2,1.5,59,51,993,474,3.9,2.69,1,2,1,,,,0 -90,1,1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,69,100,0,2,1,3,1.41,123,10.1,89.5,2.3,89000,4,4.3,31,60,75,177,6.8,0.7,3,3.5,1,37,11,173,1 -91,1,0,1,0,,0,0,1,0,,1,0,0,1,0,0,0,1,1,1,,,,65,,,0,1,1,1.22,8.7,14.6,95.1,6.7,142000,4.2,1.3,19,33,346,120,7.8,0.83,,,0.3,184,65,423,0 -92,1,1,1,0,0,1,0,1,0,0,1,0,,1,1,0,0,,0,1,0,0,1,79,70,0,3,1,1,1.01,226,11.5,95.6,6.3,108,4.2,1,27,31,667,222,6.2,3.13,1,8.8,0.2,,,,1 -93,1,1,1,0,0,0,0,1,0,1,1,1,,,0,,0,,,1,1,1,1,69,200,60,1,1,1,1.39,2159,13.1,90.6,10400,261000,3.6,1.9,42,197,552,335,7.1,0.68,5,,0.6,,,,1 -94,1,,1,0,0,0,0,1,0,1,1,0,0,1,1,,0,0,0,0,0,0,1,87,100,50,0,1,1,1.09,48,12.6,97.6,4.9,169000,4.2,0.8,30,31,86,91,6.9,1.9,5,2,,53,21,278,0 -95,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,78,0,0,1,1,1,1.6,2.4,9.5,85.8,6900,228000,3.5,0.6,11,17,44,124,6.8,1.6,1,5.5,,15,7,810,1 -96,1,1,1,0,0,0,1,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,1,71,,0,1,1,2,1.11,5,9.1,90.9,6.36,307000,2.47,,31,29,339,254,5.5,1.18,3,6.3,,,,,0 -97,1,0,1,0,0,0,0,1,0,,0,0,,0,0,0,0,1,1,1,1,0,1,58,,,0,1,1,1.64,64,14.1,103.6,4.5,68,2.9,3.3,28,43,51,137,6.8,0.67,4,4.7,1.1,,,,0 -98,1,0,1,0,,0,0,1,0,,0,0,0,1,0,0,0,0,0,0,0,0,0,73,,,0,1,1,1.23,5.5,13.1,89.6,6.1,160000,3.2,0.8,28,30,90,92,6.3,0.86,5,,,93,25,29,0 -99,1,0,1,0,,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,73,,0,2,1,2,1.67,8.5,13,102.3,24.8,133000,2.7,9.5,262,335,351,66,6.1,1.2,5,7,5.5,,,,0 -100,1,1,1,,,,0,1,0,0,0,0,0,0,0,,0,1,1,1,0,1,0,93,,0,2,1,1,1.16,2785,12,94.4,7.9,78000,2.6,3.5,26,34,339,297,5.7,2.19,5,,1.5,55,33,256,0 -101,1,1,0,0,0,0,1,1,0,,0,0,0,1,0,0,0,,1,1,0,1,1,52,0,,1,1,3,1.04,6574,13.5,98,4800,77000,3.5,28.9,56,192,464,262,6.9,1.2,5,4,19.5,121,27,749,1 -102,1,1,1,0,0,0,0,1,0,,0,0,0,1,0,0,,1,1,1,0,0,1,64,70,,2,1,2,1.55,5.7,13.9,99.7,5200,124000,2.1,0.8,37,75,203,110,5,0.56,3,2.4,,92,56,489,0 -103,1,1,0,1,,,1,1,,,0,0,,0,0,0,0,,,1,0,,0,63,0,,4,3,3,1.93,,13.5,93.3,8190,406000,2.9,40.5,139,266,403,670,6.3,4.82,5,,29.3,,,,1 -104,1,1,0,0,0,0,0,0,,1,0,0,0,1,0,0,0,0,0,0,0,0,0,64,0,50,1,1,1,1.17,39,12.6,93.8,4900,144000,3.8,1,42,74,277,312,78,1.01,1,15,,87,25,81,0 -105,1,1,1,0,0,0,0,1,,0,0,0,0,1,1,0,0,1,1,1,0,0,1,67,,0,3,1,2,1.48,2.5,14.3,101.5,5,120,2.2,1.2,34,71,222,97,5.2,2.82,3,2.4,0.3,92,56,48.9,0 -106,1,1,1,0,0,1,1,1,0,1,0,0,0,0,0,0,1,0,1,1,0,0,1,50,80,1,0,1,1,1.18,32,14,90.1,5.2,121000,4.2,0.4,420,226,147,174,8.6,0.9,5,3,,26.4,54,2230,0 -107,1,1,1,0,0,0,0,1,0,0,1,0,,0,1,0,0,1,1,1,0,0,1,79,75,0,3,1,2,1.32,7.6,5,69.5,3800,96000,3.7,0.5,17,69,76,86,6.3,2.68,1,10,,9,3,490,1 -108,1,1,1,0,0,0,0,1,0,0,1,1,0,1,0,0,1,0,0,1,0,1,1,85,100,0,1,1,1,1.25,173,11.3,103.9,6200,176000,2.4,1.7,63,114,80,163,6.1,0.67,5,20,0.5,131,78,1316,1 -109,0,0,1,0,0,0,0,1,,,0,0,0,0,0,0,0,1,0,1,0,0,0,62,,,0,1,1,1.54,2.3,12.1,89.7,4.5,97000,2.7,1.4,19,27,72,120,4.3,0.61,5,4,0.7,,,,0 -110,1,1,1,1,0,1,0,1,,1,0,0,0,1,0,0,0,1,1,1,1,1,1,74,200,30,2,2,2,1.26,114,14.9,104.5,4.3,90000,3.2,4.8,106,154,148,166,7.2,0.48,5,12.6,1.8,161,96,297,0 -111,1,1,1,0,0,0,0,1,0,,0,1,0,0,0,0,0,,1,1,1,0,1,56,90,,2,1,2,1.87,173,11.1,105.5,6.1,51000,3.1,32.3,110,206,127,188,5.4,1.29,5,,22.1,,,,1 -112,1,0,1,0,0,0,0,1,0,,0,0,0,0,0,0,0,1,1,1,0,0,1,74,100,,0,1,1,1.36,18,15.3,90.9,4.9,81000,4.2,1.7,35,49,97,109,7.3,1.02,1,3.5,0.3,,,,0 -113,1,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,1,1,1,1,1,0,62,0,7.5,1,1,1,1.45,42,16.2,99.1,5.001,77000,4.1,1.3,42,118,279,158,7.7,0.88,2,7.4,0.3,,,,0 -114,1,1,1,0,0,0,0,1,0,,1,0,,0,0,0,0,1,1,1,1,0,1,60,100,,3,3,2,1.87,28274,10.3,94.7,11.1,109000,2.4,5.7,25,111,55,128,7,1.3,1,1.5,1.9,51,18,56,1 -115,1,1,1,0,,,0,1,0,1,0,0,0,0,0,0,0,,,,0,0,0,55,100,43,0,1,1,1.23,736,14,88.2,4.68,286000,4.7,0.8,48,113,649,629,8.4,0.71,5,9.1,0.3,,,,0 -116,1,1,1,0,0,0,0,1,0,1,1,0,,1,0,0,0,1,1,1,0,0,0,57,96,60,0,1,3,1.17,1009,13.8,93.2,3100,137000,3,0.7,25,55,343,235,,0.79,2,20,,,,,1 -117,1,1,1,1,1,1,0,1,0,,0,0,0,0,0,0,0,,1,1,0,0,0,63,120,,4,3,2,2.42,22475,12,111.4,9.9,70000,3.28,19,134,178,54,146,8,3.23,1,,9.7,106,67,2165,1 -118,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,63,,0,0,1,1,1.28,5.2,14.6,96.1,6.1,194000,4.2,7.9,97,69,816,79,7.7,1.02,1,3,,,,,0 -119,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,79,180,23,0,1,2,1.46,5.2,14.9,103.8,4500,53000,3.2,1.4,62,87,263,239,8.1,0.72,1,1.5,1,,,,0 -120,1,1,0,1,0,,0,1,1,0,1,0,0,1,0,,,,,,0,0,0,63,0,0,1,1,1,1.14,14177,10.2,96.1,6000,109000,2.6,4.9,70,113,833,980,7.5,0.78,5,9,2.8,,,,0 -121,1,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,,0,0,0,0,1,59,100,0,0,1,1,1.94,3.1,10.8,102.8,5300,97000,3.6,1.1,119,125,663,433,6.5,0.87,2,3.2,0.4,52.5,37,856,1 -122,1,1,1,0,0,1,1,1,0,1,0,0,0,0,0,0,0,1,1,1,1,1,0,51,75,52.5,2,1,1,1.56,50655,9.8,85.6,3900,132000,2.6,2.6,123,219,503,363,7.3,0.55,1,4,1.5,40,12,57,1 -123,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,,,0,0,0,0,1,74,0,0,0,1,1,1.11,1.2,15.1,83.8,5.2,178000,4.7,0.5,35,17,45.3,151,6.4,1.5,1,8.3,,88,27,90,0 -124,1,1,1,0,0,1,1,1,,1,0,0,1,0,0,0,,1,0,1,0,0,0,62,,,2,1,2,1.08,657,11.8,89.2,9400,211000,3.2,0.8,43,101,646,466,7.3,0.7,1,8.3,,,,579,1 -125,1,1,1,0,0,0,0,1,0,,0,0,0,0,0,0,0,0,0,1,1,0,1,76,100,,4,2,2,1.2,421500,14.3,89.5,9.8,309000,3.1,1.5,20,44,291,217,6.3,0.7,1,20,0.5,52,17,832,1 -126,1,0,0,0,0,,1,1,0,,1,0,0,0,0,0,0,1,1,1,0,0,1,73,0,,0,1,1,1.2,472,15.6,88.4,5.5,83000,4,2.4,117,128,249,117,7.2,0.69,1,13,0.7,,,,0 -127,1,0,1,0,0,0,,1,0,0,1,0,,1,0,0,0,,1,1,1,0,1,76,,0,3,2,1,1.66,77,12.3,104.2,2900,60000,3.2,2.8,54,38,311,182,6.2,0.77,2,4.3,1,93,47,307,0 -128,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,,,0,0,0,0,72,0,510,2,1,1,1.13,2.1,12.6,95.1,8.7,254000,3.68,0.7,26,38,161,127,6.9,1.11,2,4.3,,28,10,308,1 -129,0,1,1,,,,,1,0,0,1,0,0,0,0,,0,0,0,1,0,0,1,77,75,0,2,2,2,1.07,2,11.6,83.5,9,318000,3.89,0.9,23,48,319,171,7.1,0.66,2,5.8,,,,,1 -130,0,1,0,,,,0,1,0,0,0,1,0,1,0,,,,0,0,1,1,0,75,0,0,2,1,3,1.22,4.2,14.9,87.4,15.4,179000,3.5,0.6,31,61,196,150,5.4,0.7,5,17.5,0.3,,,,0 -131,0,0,1,,,,0,1,0,,0,0,0,0,0,0,0,1,0,1,0,0,1,55,100,,2,2,2,2.5,7.5,11.3,119.6,13.1,135000,3.2,8.6,62,94,82,147,6.5,1,5,2.6,3.8,,,,0 -132,0,0,0,0,0,0,1,1,,0,1,0,0,0,1,0,0,,1,0,0,0,0,72,0,0,0,1,1,1.21,152,10.9,99.6,7.3,93000,3.2,1.3,82,80,427,106,7.1,6.1,2,9,0.7,,,,1 -133,0,1,0,,,,,0,0,0,0,0,,1,1,0,0,0,0,0,0,1,1,82,0,0,1,1,1,1.09,811,11.4,89.3,9.1,318000,3.4,0.8,77,102,739,587,7.2,2.14,5,16,,14,5,149,1 -134,0,1,0,,,,,0,0,0,0,0,0,0,0,,0,0,0,0,0,0,1,46,0,0,0,1,1,1.42,4.7,14.2,90.3,6690,268000,3.1,0.32,37,44,80,517,5.5,0.7,1,13,0.12,,,,0 -135,0,1,0,0,0,0,0,1,0,0,1,1,0,1,0,0,1,0,0,0,0,1,1,71,0,0,1,1,1,1.24,2.6,13.3,96.4,7.8,280000,4.1,0.6,70,52,141,123,6.8,0.82,5,8.3,,,,,0 -136,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0,0,1,56,0,40,2,1,1,1.25,2089,15.4,91.6,10.9,175000,4.4,1.3,45,32,717,295,7.4,1.1,5,6,0.6,,,,0 -137,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,78,0,0,0,2,1,1.03,18,13.2,89.5,2.6,136000,4.3,0.8,18,29,82,141,7.2,0.85,1,9.5,,91,31,80,0 -138,0,1,0,0,0,1,0,1,,,,,0,,,0,1,0,0,0,0,0,1,55,0,,0,1,1,1.19,4.9,13.6,97.3,5400,133000,4.5,0.9,54,63,487,89,7.8,0.78,2,3.32,,78,30,220,0 -139,0,1,1,0,0,1,1,1,0,1,1,1,0,1,0,0,0,0,0,1,0,0,1,76,,12,2,1,1,0.94,240,14.7,102.3,9.9,267000,3.6,0.5,64,132,356,192,7.4,0.9,3,2,0.4,,,,0 -140,0,1,0,,,,0,1,0,0,0,0,0,0,0,,0,,0,0,1,0,0,43,0,0,0,1,1,1.25,180,12.2,87.6,7.2,130,3.5,0.5,79,58,229,302,7,0.6,5,9,,,,206,1 -141,1,1,0,0,0,1,1,1,0,,0,0,0,0,0,0,0,,1,1,0,0,0,71,0,,0,1,1,1.47,15,13.3,89.7,5.7,154000,3.2,1,,87,120,108,102,0.68,3,2,,,,,1 -142,1,,1,0,0,0,1,1,0,0,1,1,1,0,1,0,0,1,0,1,0,0,0,67,70,0,0,1,,1.02,24,16,98.8,6.6,96000,4.1,1.4,207,158,116,84,7.2,0.9,1,2.2,0.3,,,,0 -143,1,0,1,0,0,0,0,1,0,1,1,1,0,0,0,0,,1,1,1,0,0,0,67,,40,0,1,1,1.798,9.4,11.2,102.4,4.1,60000,3.4,3.7,43,63,175,106,7.6,0.52,1,2.1,1.1,94,39,344,0 -144,1,,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,,,,0,0,1,51,,37,0,1,1,1.26,7,14.9,106.3,6.4,122,3,1.5,195,401,272,93,6.4,1,3,2.9,0.4,124,51,642,0 -145,1,1,1,0,0,0,0,1,0,,,,,,,0,,,,,0,0,0,80,,,0,1,1,1,4.8,9.2,94,6.2,157000,3.88,0.76,42,51,983,141,,1.1,1,15,0.33,,,,0 -146,1,1,1,0,0,0,0,1,,1,0,1,0,1,1,0,,1,0,1,1,0,0,79,100,15,2,1,3,1.68,92421,14.3,72.2,13.3,459000,3.2,1.6,24,76,570,472,5.9,2.02,1,,0.6,29,4,14,1 -147,1,0,1,0,,0,0,1,,,1,1,,1,0,0,0,1,1,1,0,0,1,75,,,0,1,1,1.71,5.2,11.1,106.9,2100,52000,3.3,2.6,15,47,94,117,7.1,0.79,1,3.5,1,,,,0 -148,0,0,0,0,,0,0,1,,0,0,0,0,0,0,0,0,1,1,1,0,0,0,81,0,0,0,1,1,1.18,16,13.3,94.3,4800,96000,3.8,1.2,26,35,75,105,7.6,0.53,1,2.4,0.3,,,,0 -149,0,1,0,0,0,0,0,0,,0,0,0,0,0,0,0,0,1,1,1,1,0,0,25,0,0,2,1,1,,1.5,,,,,,,,,,,,,1,6.6,,,,,0 -150,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,36,0,0,0,1,1,1.12,3204,16.1,92,10.5,182,4.3,0.7,46,31,92,79,7.3,1,1,,0.2,,,,0 -151,0,0,1,0,0,0,0,1,0,,0,0,0,0,0,0,0,1,,,0,0,1,69,,,0,1,1,1.2,10,13.5,104.9,13.5,194,4,1,31,79,126,85,7.6,0.8,1,7,0.4,,,,0 -152,1,1,1,0,0,0,1,1,0,1,1,0,0,0,1,0,0,1,1,1,0,1,1,47,250,18,1,1,3,1.39,695,11.1,93.9,5.4,88000,2.7,1,31,73,38,44,7,0.96,5,3.5,,,,,0 -153,1,1,1,,,,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,87,,0,3,1,1,1.2,33,9.7,91.6,10.1,277,3.8,2.4,60,54,468,338,7,1.13,1,15,1.3,,,,1 -154,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,1,1,0,0,0,36,0,0,0,1,1,1.52,615,11.7,99.7,5.6,70000,2.82,3,66,50,120,318,6.4,0.64,5,1.9,1,,,,0 -155,1,1,1,0,0,0,0,1,,1,0,0,1,0,0,0,0,,1,1,1,0,1,64,75,25,3,2,3,1.63,1671,12.8,101.6,4.4,172000,3.44,5.8,38,95,92,139,7.6,0.9,3,9,2.9,111,94,1600,1 -156,1,1,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,49,,0,1,1,1,1.24,975,15.3,103,11.5,124000,3.5,1.2,62,85,561,266,7.5,0.77,1,2.3,0.6,180,70,1176,1 -157,1,,1,0,0,0,0,1,,1,0,0,0,1,0,0,0,1,1,1,0,0,1,62,,20,0,1,2,1.41,1.7,14.7,97.2,6900,72000,3.5,1.3,31,24,67,97,7.3,0.76,1,3.5,0.3,,,,0 -158,1,,0,0,0,0,0,1,,,1,0,0,0,1,0,0,1,1,1,0,0,1,71,0,,3,1,1,1.16,1713,8.2,94.2,6,209000,3.6,0.3,62,59,450,263,6.8,1.49,1,7.5,,,,,0 -159,1,1,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,,1,1,0,1,1,64,100,0,3,3,3,1.52,4.9,7.9,111.2,4.1,67000,2.43,1.9,40,71,69,73,4.8,0.77,5,3.2,0.7,40,18,283,1 -160,0,0,1,,,,1,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,40,,,0,1,1,0.84,,15.4,109.2,9.3,184000,4.6,0.5,35,40,449,109,7.6,0.7,5,3,,,,,0 -161,0,1,0,,,,,1,0,0,0,0,0,1,0,,0,1,1,1,0,0,1,68,0,0,2,1,1,1.33,4887,12.1,88.9,2.5,141,3,3.6,50,91,147,280,6.7,0.7,1,2.2,2.3,,,,1 -162,1,0,1,0,0,0,0,1,0,1,1,1,0,1,1,0,,,,,0,0,1,65,,48,0,1,1,1.13,75,13.3,90,8,385000,4.3,0.6,53,52,164,181,7.5,1.46,5,18.6,,,,,0 -163,1,0,1,1,0,1,1,1,1,1,0,0,0,0,0,1,0,,,,1,1,1,44,,,2,1,1,2.14,94964,15.6,117.3,5200,118000,4.8,1.1,50,60,320,170,8.4,0.74,5,18,,,,,1 -164,1,1,1,0,0,0,1,1,0,1,0,0,0,0,0,0,0,,1,1,0,1,1,52,50,,0,1,1,1.79,44340,12.7,95.8,14.4,412000,2.2,28.5,78,127,444,462,6.6,3.95,5,8.5,19.8,,,,1 diff --git a/data/DemoData/hcc_data_custom.csv b/data/DemoData/hcc_data_custom.csv deleted file mode 100644 index c8d7f097..00000000 --- a/data/DemoData/hcc_data_custom.csv +++ /dev/null @@ -1,170 +0,0 @@ -InstanceID,Symptoms ,Alcohol,Hepatitis B Surface Antigen,Hepatitis B e Antigen,Hepatitis B Core Antibody,Hepatitis C Virus Antibody,Cirrhosis,Endemic Countries,Smoking,Diabetes,Obesity,Hemochromatosis,Arterial Hypertension,Chronic Renal Insufficiency,Human Immunodeficiency Virus,Nonalcoholic Steatohepatitis,Esophageal Varices,Splenomegaly,Portal Hypertension,Portal Vein Thrombosis,Liver Metastasis,Radiological Hallmark,Grams of Alcohol per day,Packs of cigarets per year,Performance Status*,Encephalopathy degree*,Ascites degree*,International Normalised Ratio*,Alpha-Fetoprotein (ng/mL),Haemoglobin (g/dL),Mean Corpuscular Volume,Leukocytes(G/L),Platelets,Albumin (mg/dL),Total Bilirubin(mg/dL),Alanine transaminase (U/L),Aspartate transaminase (U/L),Gamma glutamyl transferase (U/L),Alkaline phosphatase (U/L),Total Proteins (g/dL),Creatinine (mg/dL),Number of Nodules,Major dimension of nodule (cm),Direct Bilirubin (mg/dL),Iron,Oxygen Saturation (%),Ferritin (ng/mL),Class,Sim_Cat_2,Sim_Cat_3,Sim_Cat_4,Sim_Text_Cat_2,Sim_Text_Cat_3,Sim_Text_Cat_4,Sim_Miss_0.6,Sim_Miss_0.7,Sim_Cor_-1.0_A,Sim_Cor_-1.0_B,Sim_Cor_0.9_A,Sim_Cor_0.9_B,Sim_Cor_1.0_A,Sim_Cor_1.0_B,Invariant_Val,Invariant_NA,Invariant_Val_NA -0,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,137.0,15.0,0.0,1.0,1.0,1.53,95.0,13.7,106.6,4.9,99.0,3.4,2.1,34.0,41.0,183.0,150.0,7.1,0.7,1.0,3.5,0.5,,,,0.0,1,1,4,Category 2,Category 2,Category 1,,,0.5932786483101787,-0.5932786483101787,0.898261627292706,0.9399532587410278,0.01794567856849183,0.01794567856849183,42,,43.0 -1,,0.0,0.0,0.0,0.0,1.0,1,,,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,0.0,,0.0,1.0,1.0,,,,,,,,,,,,,,,1.0,1.8,,,,,0.0,2,3,2,Category 2,Category 3,Category 2,0.23321641154980122,0.3443837320442332,0.6502941858734539,-0.6502941858734539,0.8293324051412837,0.1825500260597307,0.12625378279261346,0.12625378279261346,42,,43.0 -2,0.0,1.0,1.0,0.0,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,1.0,50.0,50.0,2.0,1.0,2.0,0.96,5.8,8.9,79.8,8.4,472.0,3.3,0.4,58.0,68.0,202.0,109.0,7.0,2.1,5.0,13.0,0.1,28.0,6.0,16.0,0.0,1,2,2,Category 1,Category 3,Category 2,0.34292686427826025,,0.4792789285762873,-0.4792789285762873,0.31753144787673704,0.3878364937645984,0.6596293663947422,0.6596293663947422,42,, -3,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,40.0,30.0,0.0,1.0,1.0,0.95,2440.0,13.4,97.1,9.0,279.0,3.7,0.4,16.0,64.0,94.0,174.0,8.1,1.11,2.0,15.7,0.2,,,,1.0,1,1,4,Category 2,Category 2,Category 3,0.47396994143055615,0.41279355060675227,0.6157420219422428,-0.6157420219422428,0.9527975276012943,0.7934424911991063,0.16161981128587144,0.16161981128587144,42,,43.0 -4,1.0,1.0,1.0,0.0,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,100.0,30.0,0.0,1.0,1.0,0.94,49.0,14.3,95.1,6.4,199.0,4.1,0.7,147.0,306.0,173.0,109.0,6.9,1.8,1.0,9.0,,59.0,15.0,22.0,0.0,1,2,3,Category 1,Category 2,Category 3,,,0.3290174378146622,-0.3290174378146622,0.8252007674155681,0.5838130941185526,0.2554933446556047,0.2554933446556047,42,,43.0 -5,0.0,1.0,0.0,,0.0,0.0,1,0.0,,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,,1.0,1.0,2.0,1.58,110.0,13.4,91.5,5.4,85.0,3.4,3.5,91.0,122.0,242.0,396.0,5.6,0.9,1.0,10.0,1.4,53.0,22.0,111.0,1.0,1,2,3,Category 1,Category 3,Category 3,0.648822840291576,0.5982860582681546,0.47018259269666507,-0.47018259269666507,0.6663068858350397,0.23855764840991467,0.9466379541996072,0.9466379541996072,42,,43.0 -6,0.0,0.0,0.0,,1.0,1.0,1,0.0,0.0,1.0,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.4,138.9,10.4,102.0,3.2,42000.0,2.35,2.72,119.0,183.0,143.0,211.0,7.3,0.8,5.0,2.6,2.19,171.0,126.0,1452.0,1.0,1,2,2,Category 2,Category 3,Category 2,,,0.7442790655949556,-0.7442790655949556,0.12176191112527479,0.5059578444366252,0.5601822583749119,0.5601822583749119,42,,43.0 -7,1.0,1.0,0.0,,0.0,0.0,1,0.0,1.0,1.0,,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,,20.0,3.0,1.0,1.0,1.46,9860.0,10.8,92.0,3.0,58.0,3.1,3.2,79.0,108.0,184.0,300.0,7.1,0.52,2.0,9.0,1.3,42.0,25.0,706.0,1.0,2,3,3,Category 1,Category 2,Category 4,0.5841994847141693,,0.8718327789731212,-0.8718327789731212,0.4782340230480723,1.1844526933309516,0.7507295069993472,0.7507295069993472,42,,43.0 -8,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,100.0,32.0,1.0,1.0,2.0,3.14,8.8,11.9,107.5,4.9,70.0,1.9,3.3,26.0,59.0,115.0,63.0,6.1,0.59,1.0,6.4,1.2,85.0,73.0,982.0,0.0,1,3,1,Category 2,Category 3,Category 4,,,0.4336553339563889,-0.4336553339563889,0.5061075548467509,0.5863475294037935,0.5579807387826399,0.5579807387826399,42,,43.0 -9,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,100.0,0.0,0.0,1.0,1.0,1.12,1.8,11.8,87.8,5100.0,193000.0,4.2,0.5,71.0,45.0,256.0,303.0,7.1,0.59,1.0,9.3,0.7,,,,0.0,2,1,2,Category 2,Category 1,Category 2,,,0.04366165770736119,-0.04366165770736119,0.2325513583653801,0.34986666651363396,0.5525136147827252,0.5525136147827252,42,,43.0 -10,0.0,1.0,0.0,0.0,0.0,1.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,,,0.0,1.0,2.0,1.05,100809.0,13.0,94.2,5.7,196.0,4.4,3.0,90.0,334.0,494.0,236.0,7.6,0.8,5.0,,1.1,,,,1.0,1,1,3,Category 1,Category 1,Category 2,0.5865354346607591,0.9676993882070865,0.16167254414680265,-0.16167254414680265,0.07996539435930194,-0.22545217123975553,0.0941519101256979,0.0941519101256979,42,,43.0 -11,0.0,1.0,0.0,0.0,0.0,1.0,1,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,,0.0,1.0,0.0,0.0,1.0,,0.0,0.0,1.0,1.0,1.33,86.0,15.7,96.7,4.0,61.0,3.7,1.3,132.0,168.0,113.0,154.0,,7.6,5.0,1.9,0.3,144.0,41.0,277.0,0.0,2,3,2,Category 1,Category 2,Category 2,,,0.0208611392915381,-0.0208611392915381,0.7767236304716927,0.17768457140740213,0.34366319260910305,0.34366319260910305,42,, -12,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,,,1.0,1.0,1.0,0.0,0.0,,30.0,0.0,1.0,1.0,1.53,60.0,13.3,90.1,5.5,207000.0,4.4,8.5,25.0,36.0,35.0,74.0,8.5,0.73,1.0,5.0,0.8,,,,0.0,1,2,1,Category 2,Category 2,Category 2,,0.10309374601374488,0.6532630192373301,-0.6532630192373301,0.12203505212439503,0.09250975989424577,0.2824308986865117,0.2824308986865117,42,,43.0 -13,,0.0,0.0,0.0,0.0,1.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,,0.0,1.0,1.0,1.2,6.6,13.7,93.8,4.1,91000.0,4.5,1.0,103.0,96.0,205.0,70.0,8.8,0.88,1.0,22.0,,82.0,24.0,,0.0,1,1,2,Category 1,Category 2,Category 2,,,0.3323146253551089,-0.3323146253551089,0.5942907505617747,0.11041404432984137,0.39072836561361324,0.39072836561361324,42,,43.0 -14,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,1.0,0.0,0.0,1.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,1.0,,,2.0,2.0,2.0,1.25,29.0,13.5,93.0,6.0,128.0,3.15,10.5,76.0,116.0,165.0,163.0,7.3,1.07,4.0,4.5,4.5,197.0,84.0,302.0,0.0,2,3,2,Category 1,Category 1,Category 2,,0.8074302518167612,0.5424786357193675,-0.5424786357193675,0.9364491738836606,0.07014141493276138,0.7983441882243283,0.7983441882243283,42,,43.0 -15,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,100.0,0.0,1.0,1.0,2.0,1.61,4.6,10.2,89.6,5.5,161.0,3.1,3.1,24.0,57.0,163.0,176.0,5.0,0.8,2.0,2.6,1.3,25.0,13.0,60.0,0.0,2,3,2,Category 1,Category 3,Category 3,,,0.49327684678379957,-0.49327684678379957,0.8761051925980425,1.1387085836094897,0.37193266791686486,0.37193266791686486,42,,43.0 -16,0.0,1.0,0.0,0.0,0.0,0.0,1,,1.0,1.0,,1.0,0.0,0.0,0.0,,,1.0,1.0,1.0,0.0,1.0,,,3.0,2.0,1.0,2.14,60.0,12.1,99.2,5.0,58.0,2.4,9.8,69.0,63.0,201.0,235.0,6.2,0.96,2.0,2.0,2.9,136.0,95.0,767.0,1.0,2,3,2,Category 2,Category 1,Category 3,,,0.0815264895524267,-0.0815264895524267,0.27775262374926113,0.6214282526774713,0.4516968192316827,0.4516968192316827,42,,43.0 -17,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,,0.0,0.0,0.0,,1.0,1.0,1.0,1.0,1.0,1.0,100.0,60.0,2.0,1.0,1.0,1.05,9.2,10.3,103.7,5.4,159.0,3.8,0.5,56.0,91.0,459.0,146.0,5.4,1.23,5.0,13.5,3.8,187.0,58.0,443.0,0.0,1,2,1,Category 2,Category 3,Category 3,,0.6905602324456406,0.4032613611238318,-0.4032613611238318,0.8514486375512653,0.39194463178643774,0.3973813904853165,0.3973813904853165,42,,43.0 -18,,1.0,0.0,0.0,0.0,0.0,1,,1.0,0.0,,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,200.0,78.0,1.0,1.0,1.0,1.13,8.8,14.9,94.8,6.3,137.0,4.3,0.9,16.0,23.0,82.0,180.0,6.5,4.95,1.0,5.4,0.9,144.0,49.0,295.0,0.0,2,3,4,Category 1,Category 1,Category 3,0.330348481280914,0.5213006674135694,0.22056112492232327,-0.22056112492232327,0.0003325061204894064,0.10664083773701197,0.0934079719752956,0.0934079719752956,42,,43.0 -19,1.0,1.0,0.0,0.0,0.0,0.0,1,,,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,500.0,,0.0,1.0,3.0,1.44,34.0,15.9,103.4,9600.0,101000.0,3.4,3.4,27.0,87.0,260.0,147.0,6.3,0.9,5.0,2.3,1.6,67.0,34.0,774.0,1.0,1,3,2,Category 2,Category 3,Category 2,,0.0867052118621836,0.4183997886676527,-0.4183997886676527,0.01768780961325722,0.45265989680750285,0.4410721582507837,0.4410721582507837,42,,43.0 -20,0.0,1.0,0.0,0.0,0.0,0.0,1,,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,200.0,60.0,0.0,1.0,1.0,1.29,19.6,11.7,101.0,2600.0,109000.0,3.6,1.7,13.0,35.0,23.0,141.0,7.3,0.68,1.0,2.5,0.7,152.6,,76.9,0.0,1,3,2,Category 2,Category 1,Category 4,0.00753436313407474,,0.20357828034224268,-0.20357828034224268,0.602553163842865,0.6316669084217452,0.19560927304451503,0.19560927304451503,42,,43.0 -21,0.0,1.0,0.0,0.0,1.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,0.0,0.0,80.0,47.0,0.0,1.0,1.0,1.06,3.9,16.4,90.7,7.8,187.0,4.5,1.0,54.0,47.0,52.0,97.0,6.3,0.75,1.0,6.8,0.2,87.0,26.0,84.0,0.0,2,3,3,Category 2,Category 2,Category 1,,,0.8404524062769335,-0.8404524062769335,0.3647982191445295,-0.19176565540596485,0.18672329577304148,0.18672329577304148,42,,43.0 -22,1.0,1.0,0.0,0.0,1.0,0.0,1,,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,1.0,180.0,0.0,1.0,1.0,3.0,1.27,1975.0,10.8,86.5,9100.0,154000.0,3.1,1.2,68.0,136.0,869.0,562.0,69.0,1.14,5.0,3.8,0.5,112.0,73.0,1001.0,1.0,2,1,2,Category 2,Category 1,Category 2,0.36535681967405764,0.6389493853342618,0.17419333657825364,-0.17419333657825364,0.38646084115914714,0.24629887175155538,0.09403610443426635,0.09403610443426635,42,,43.0 -23,1.0,1.0,0.0,0.0,0.0,0.0,1,1.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,1.0,200.0,60.0,1.0,1.0,1.0,4.82,185.0,10.7,88.1,5.0,194000.0,3.6,3.8,217.0,86.0,879.0,396.0,7.0,0.53,5.0,15.0,1.6,,,,1.0,1,1,3,Category 2,Category 3,Category 1,0.4878098008087379,,0.9607805514869769,-0.9607805514869769,0.5644410906788825,1.0863397995410788,0.35667097414176474,0.35667097414176474,42,,43.0 -24,1.0,1.0,0.0,,1.0,0.0,0,0.0,1.0,0.0,0.0,,1.0,0.0,,0.0,,0.0,,0.0,1.0,0.0,150.0,,4.0,1.0,1.0,1.74,5532.0,13.1,111.0,3.5,351000.0,2.4,1.3,26.0,67.0,108.0,311.0,5.6,0.95,1.0,10.0,0.7,,,,1.0,1,3,4,Category 1,Category 1,Category 4,0.8508175178361462,0.7241033292731386,0.4159073661469408,-0.4159073661469408,0.19178245559186058,0.28028062761634703,0.7574818847894174,0.7574818847894174,42,,43.0 -25,0.0,1.0,0.0,,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,100.0,0.0,2.0,1.0,1.0,1.33,13327.0,13.7,94.3,5.2,110.0,3.1,1.6,52.0,107.0,465.0,233.0,8.4,0.79,5.0,,0.7,93.0,31.0,79.0,0.0,2,2,1,Category 1,Category 1,Category 3,,,0.8462452920190493,-0.8462452920190493,0.21175535066547835,0.42558205109816966,0.27644169058339607,0.27644169058339607,42,,43.0 -26,1.0,1.0,,,,1.0,1,0.0,1.0,0.0,0.0,,0.0,0.0,,0.0,1.0,1.0,1.0,1.0,0.0,1.0,50.0,16.0,1.0,1.0,3.0,1.38,,13.6,98.4,4.3,99000.0,3.3,1.3,178.0,325.0,252.0,172.0,8.1,0.83,1.0,5.0,0.7,,,,1.0,2,1,1,Category 1,Category 1,Category 4,0.8058648867411434,0.9805768001799882,0.6287648182059451,-0.6287648182059451,0.4846015870188647,0.585054152656044,0.31234910188551357,0.31234910188551357,42,,43.0 -27,,1.0,1.0,0.0,1.0,0.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,,0.0,1.0,1.0,1.37,5.9,15.5,88.2,4.9,113.0,4.5,3.2,36.0,65.0,34.0,111.0,,,2.0,4.0,1.0,180.0,56.0,,0.0,2,3,4,Category 2,Category 2,Category 2,0.05565348935697534,0.9033638126360249,0.7353502986657526,-0.7353502986657526,0.754253544343863,0.30591943446163133,0.6426746576724236,0.6426746576724236,42,,43.0 -28,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,60.0,67.5,1.0,1.0,1.0,1.3,3255.0,12.2,89.5,4.4,108.0,3.0,1.1,59.0,85.0,419.0,293.0,7.7,0.67,2.0,6.5,0.4,94.0,27.0,70.0,1.0,1,1,1,Category 2,Category 1,Category 3,0.8423140352981816,0.6466649191171634,0.7677238880667803,-0.7677238880667803,0.6194977514075877,0.28692781922349003,0.19584081258691888,0.19584081258691888,42,,43.0 -29,1.0,1.0,0.0,,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,,2.0,1.0,1.0,1.0,1.21,1.9,9.9,83.4,8.1,556.0,3.2,1.8,150.0,112.0,599.0,974.0,7.7,0.7,5.0,,1.1,22.0,7.0,369.0,0.0,1,1,4,Category 1,Category 2,Category 2,,,0.5048448818930178,-0.5048448818930178,0.2973550482368389,0.4153274409207134,0.8969579304235343,0.8969579304235343,42,,43.0 -30,1.0,1.0,1.0,0.0,,0.0,1,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,1.0,20.0,8.0,2.0,1.0,1.0,1.19,11.0,13.1,87.9,7.8,212.0,3.5,0.7,27.0,26.0,143.0,158.0,8.2,0.71,1.0,16.0,,,,,0.0,1,2,4,Category 2,Category 2,Category 3,,,0.5433005233632884,-0.5433005233632884,0.4303371775089212,0.7433696136519437,0.5201905232515545,0.5201905232515545,42,,43.0 -31,0.0,1.0,0.0,,0.0,0.0,1,,1.0,1.0,,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,120.0,,0.0,1.0,1.0,1.44,1237.0,12.2,94.0,6200.0,93000.0,4.2,1.0,35.0,85.0,191.0,129.0,58.0,1.06,5.0,7.0,,75.0,24.0,239.0,0.0,1,3,4,Category 1,Category 1,Category 1,,,0.513995867808725,-0.513995867808725,0.1706647585499984,0.63303573555011,0.44760294032021697,0.44760294032021697,42,, -32,1.0,1.0,,,,0.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,100.0,,0.0,1.0,1.0,1.32,7.7,15.7,96.1,9.1,268000.0,3.4,0.6,20.0,29.0,49.0,135.0,8.2,0.9,2.0,,,,,,0.0,1,3,1,Category 1,Category 1,Category 1,,0.044165437710100175,0.5880583780900792,-0.5880583780900792,0.07462981433708171,-0.30687270235027364,0.5578201919292014,0.5578201919292014,42,,43.0 -33,1.0,1.0,0.0,,0.0,0.0,1,,,0.0,0.0,0.0,1.0,0.0,0.0,,0.0,0.0,0.0,0.0,0.0,1.0,,,0.0,1.0,1.0,1.24,266.0,13.7,97.7,13000.0,170000.0,4.2,0.5,68.0,85.0,232.0,227.0,16.8,1.72,1.0,5.9,,,,,0.0,1,2,3,Category 1,Category 1,Category 1,,,0.029394445756507293,-0.029394445756507293,0.7826960407441492,0.8932193007727535,0.16603431341619546,0.16603431341619546,42,,43.0 -34,1.0,1.0,1.0,0.0,1.0,0.0,1,,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,,0.0,0.0,1.0,1.0,1.28,5689.0,14.3,99.6,6.8,77.0,3.8,1.7,154.0,102.0,184.0,184.0,6.9,0.89,2.0,3.0,0.77,,,,0.0,2,2,4,Category 2,Category 3,Category 4,,,0.39551516984901525,-0.39551516984901525,0.2653874091881946,0.7562692007201774,0.6134731386391763,0.6134731386391763,42,,43.0 -35,,0.0,1.0,,1.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,1.0,0.96,14.2,14.8,98.5,4.95,187.0,4.2,0.77,43.0,86.0,89.0,113.0,6.7,0.95,3.0,8.8,0.37,,,,0.0,1,3,2,Category 2,Category 1,Category 2,0.9173956130855316,0.5558065814371796,0.6061887135611715,-0.6061887135611715,0.1777663878512482,-0.27026921950354843,0.36310073663401043,0.36310073663401043,42,,43.0 -36,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,75.0,0.0,4.0,1.0,2.0,2.0,3.1,13.1,109.3,44.6,60.0,2.3,7.8,38.0,74.0,180.0,127.0,5.6,0.88,5.0,3.1,3.3,98.0,89.0,870.0,1.0,1,3,1,Category 1,Category 2,Category 4,0.005300006397605417,,0.5977235652558643,-0.5977235652558643,0.6916180555693193,1.270514301967363,0.8971863409646189,0.8971863409646189,42,,43.0 -37,1.0,1.0,0.0,0.0,0.0,0.0,1,,1.0,1.0,0.0,,1.0,0.0,0.0,,,0.0,1.0,0.0,0.0,1.0,200.0,30.0,1.0,1.0,2.0,1.24,633.0,13.0,96.5,7200.0,143000.0,2.3,1.1,40.0,58.0,322.0,209.0,6.7,1.4,5.0,4.9,0.2,57.0,25.0,134.0,1.0,1,2,4,Category 1,Category 1,Category 1,0.9750671629451425,,0.7929560946056315,-0.7929560946056315,0.618051674287186,1.270644250942094,0.16885420667768614,0.16885420667768614,42,,43.0 -38,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,100.0,0.0,0.0,1.0,1.0,1.09,5.4,14.9,105.0,7.2,230000.0,4.2,1.3,18.0,26.0,174.0,92.0,7.3,0.8,2.0,6.0,0.3,,,,0.0,2,1,4,Category 1,Category 3,Category 2,0.49074877925878446,0.12052257878646444,0.6550093388321085,-0.6550093388321085,0.6331896260134641,1.7141192706601083,0.507051103865441,0.507051103865441,42,,43.0 -39,1.0,1.0,1.0,0.0,1.0,1.0,1,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,,0.0,,0.0,1.0,1.0,200.0,0.0,0.0,1.0,1.0,1.42,479.0,11.3,82.2,9500.0,160000.0,3.1,1.4,113.0,143.0,924.0,288.0,7.9,0.98,5.0,17.0,0.6,,,,0.0,1,1,2,Category 1,Category 1,Category 1,,,0.9921333163406724,-0.9921333163406724,0.22889460484661361,0.3066666974881599,0.598112629369018,0.598112629369018,42,,43.0 -40,,0.0,0.0,0.0,1.0,1.0,1,0.0,0.0,0.0,0.0,,1.0,0.0,0.0,0.0,,,,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.18,19.0,13.9,88.3,6.86,201000.0,4.4,0.8,142.0,117.0,123.0,104.0,8.5,0.74,2.0,3.3,0.3,143.0,50.18,120.0,0.0,1,2,3,Category 2,Category 3,Category 4,,,0.283854528608645,-0.283854528608645,0.232645538562681,0.3124361118651462,0.03338360178638122,0.03338360178638122,42,,43.0 -41,0.0,0.0,0.0,0.0,1.0,0.0,1,0.0,0.0,1.0,1.0,0.0,1.0,0.0,0.0,0.0,,0.0,0.0,,,0.0,0.0,0.0,0.0,1.0,1.0,1.21,2.8,15.7,92.7,15.4,188000.0,4.1,0.7,299.0,553.0,196.0,68.0,6.5,1.3,1.0,5.0,0.3,,,,0.0,2,1,3,Category 2,Category 3,Category 4,0.7184572708365536,,0.35915102966623147,-0.35915102966623147,0.22080262978563914,0.5592008637108292,0.36369312475614024,0.36369312475614024,42,,43.0 -42,0.0,1.0,0.0,0.0,0.0,0.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,1.0,0.0,,,3.0,1.0,1.0,1.2,185203.0,15.0,85.5,8.8,183.0,3.6,1.0,49.0,117.0,442.0,278.0,7.2,0.86,5.0,15.8,0.3,21.0,9.0,279.0,1.0,1,2,3,Category 1,Category 1,Category 4,,0.4217626597305125,0.3838471518677963,-0.3838471518677963,0.1737525956622945,0.5041314589669676,0.7326352347008328,0.7326352347008328,42,,43.0 -43,0.0,1.0,,,,,1,0.0,,0.0,1.0,0.0,0.0,0.0,,1.0,1.0,1.0,1.0,0.0,0.0,1.0,75.0,,0.0,1.0,1.0,1.17,5.0,15.1,104.1,4.3,65000.0,3.8,2.5,61.0,56.0,239.0,56.0,7.3,0.7,1.0,2.0,0.2,,,,0.0,1,1,4,Category 1,Category 2,Category 1,,0.7953418379590974,0.4658128070202485,-0.4658128070202485,0.6557236725616563,1.0811232373487876,0.8203775074489733,0.8203775074489733,42,,43.0 -44,0.0,0.0,0.0,0.0,1.0,1.0,1,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.71,237.0,15.6,98.1,4.3,88.0,3.2,2.2,30.0,52.0,72.0,97.0,6.7,0.86,5.0,2.2,0.5,,,,0.0,1,1,4,Category 2,Category 3,Category 2,0.8385825587026248,,0.8359980637812094,-0.8359980637812094,0.8480158852494014,1.1049664369274788,0.31316199481728235,0.31316199481728235,42,, -45,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,,0.0,0.0,1.0,1.0,1.18,2.8,16.6,93.8,8300.0,167000.0,4.9,0.9,35.0,29.0,62.0,68.0,8.3,0.72,1.0,2.3,,,,,0.0,1,3,4,Category 2,Category 1,Category 2,,,0.23579209395920986,-0.23579209395920986,0.7243174696766612,0.6056544083834138,0.7985932723827512,0.7985932723827512,42,,43.0 -46,1.0,0.0,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,,0.0,0.0,0.0,1.0,1.0,,,,,,,,,,,,,,,,,,,,,0.0,1,3,1,Category 1,Category 1,Category 1,,,0.7760002070354295,-0.7760002070354295,0.7920936337605432,1.2455404663466032,0.9677558771033888,0.9677558771033888,42,,43.0 -47,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,0.0,,,1.0,1.0,2.0,1.64,16.0,14.0,102.9,11.5,277000.0,3.1,6.8,140.0,244.0,795.0,595.0,7.2,0.79,1.0,2.3,4.1,63.0,34.0,888.0,1.0,2,1,2,Category 1,Category 2,Category 2,0.7109524788367483,,0.4053101830857434,-0.4053101830857434,0.4047984290851998,-0.10263027195923852,0.8568739360750941,0.8568739360750941,42,,43.0 -48,1.0,0.0,0.0,0.0,0.0,0.0,0,0.0,1.0,1.0,0.0,0.0,1.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,80.0,0.0,1.0,1.0,1.33,163.0,10.6,96.2,9900.0,280000.0,3.3,1.0,28.0,57.0,236.0,171.0,7.5,1.38,1.0,19.0,,45.0,21.0,802.0,1.0,2,1,4,Category 1,Category 3,Category 1,,,0.6018553836620085,-0.6018553836620085,0.6540757953719981,0.5912191902717471,0.1176439881593252,0.1176439881593252,42,,43.0 -49,,1.0,0.0,,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,,40.0,0.0,1.0,1.0,1.49,20.0,15.0,96.7,9.0,78.0,4.6,2.1,40.0,49.0,137.0,109.0,7.6,0.8,1.0,2.0,0.4,184.0,59.0,905.0,0.0,2,3,2,Category 2,Category 3,Category 2,,,0.6325405332263061,-0.6325405332263061,0.35423624044477453,1.0004291688779363,0.7397303320855406,0.7397303320855406,42,,43.0 -50,1.0,0.0,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,1.0,1.0,0.0,0.0,2.0,1.0,1.0,0.97,46.0,10.5,78.7,20.9,251.0,2.4,0.3,31.0,185.0,91.0,539.0,5.0,0.38,5.0,20.0,0.3,,,,1.0,1,3,2,Category 2,Category 1,Category 3,,,0.37284863718893446,-0.37284863718893446,0.52550462196864,-0.07201565421043254,0.3196668324405447,0.3196668324405447,42,,43.0 -51,0.0,1.0,,,,1.0,1,,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,1.0,0.0,100.0,0.0,0.0,1.0,1.0,1.2,41470.0,12.6,91.4,12.0,275000.0,3.11,2.3,55.0,94.0,394.0,350.0,7.3,1.7,5.0,,0.8,84.0,37.0,497.0,1.0,1,3,3,Category 2,Category 1,Category 3,,0.560677194003514,0.5126152052058052,-0.5126152052058052,0.4816348465348623,0.13816656932543037,0.9884159894120765,0.9884159894120765,42,, -52,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,1.0,1.0,1.33,4.7,11.8,80.2,3.7,99.0,4.1,0.7,50.0,47.0,67.0,62.0,7.4,0.77,1.0,2.3,,104.0,37.0,635.0,0.0,1,2,1,Category 1,Category 2,Category 4,,,0.413031174647697,-0.413031174647697,0.1768871451438544,0.45200628636978035,0.4853589831598871,0.4853589831598871,42,,43.0 -53,,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,0.0,0.0,1.0,1.0,1.65,7.3,15.3,93.7,3500.0,57000.0,,1.4,111.0,93.0,294.0,130.0,,0.76,2.0,2.0,0.3,184.0,2.26,59.0,0.0,2,1,4,Category 1,Category 2,Category 3,,,0.06913278618661944,-0.06913278618661944,0.3870787603356308,0.5200731327007764,0.12243389835894103,0.12243389835894103,42,,43.0 -54,1.0,1.0,0.0,0.0,0.0,1.0,1,,1.0,0.0,,,0.0,0.0,0.0,,1.0,1.0,1.0,1.0,0.0,1.0,100.0,30.0,3.0,1.0,2.0,1.35,1898.0,12.4,95.1,9.8,216.0,2.7,8.2,164.0,523.0,433.0,397.0,6.7,0.82,1.0,2.1,5.5,56.0,27.0,742.0,1.0,1,3,3,Category 2,Category 3,Category 3,0.506103956359347,,0.43716538881682654,-0.43716538881682654,0.963822275482351,0.48602531543371064,0.7251855480273908,0.7251855480273908,42,,43.0 -55,1.0,0.0,,,,1.0,0,0.0,0.0,1.0,0.0,,1.0,0.0,,,0.0,,0.0,0.0,1.0,1.0,0.0,0.0,1.0,1.0,1.0,1.32,77.0,10.8,88.0,6000.0,174000.0,3.2,0.9,48.0,19.0,171.0,923.0,5.4,1.31,3.0,15.4,,,,,1.0,1,1,3,Category 2,Category 3,Category 3,0.9320143422569341,0.4410321617481616,0.09739339255355217,-0.09739339255355217,0.24858025771494208,0.04230747206261054,0.32301119838621384,0.32301119838621384,42,,43.0 -56,1.0,1.0,0.0,,,,1,0.0,1.0,1.0,0.0,,1.0,0.0,0.0,,0.0,0.0,1.0,0.0,0.0,1.0,100.0,10.0,2.0,1.0,2.0,3.56,2.7,7.3,90.8,2.42,159000.0,3.4,0.5,25.0,32.0,80.0,55.0,6.2,0.85,1.0,2.2,,22.0,6.0,48.0,1.0,2,2,4,Category 1,Category 1,Category 1,0.3206421921595143,0.40448544968185074,0.4050207990803215,-0.4050207990803215,0.13380373627948872,-0.39426760589229415,0.9970781570816617,0.9970781570816617,42,,43.0 -57,,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,1.0,100.0,,0.0,1.0,1.0,1.24,2.6,10.3,83.0,6.1,1.71,3.9,0.8,11.0,28.0,77.0,120.0,7.0,0.58,1.0,4.7,0.85,32.0,10.0,18.0,0.0,1,2,2,Category 2,Category 3,Category 3,,0.5724277594334657,0.5929183998317819,-0.5929183998317819,0.4185806216239353,0.8041060623183116,0.9797824578545219,0.9797824578545219,42,,43.0 -58,,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,,,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,1.0,70.0,0.0,3.0,2.0,2.0,1.96,12.0,10.9,102.0,4.1,99.0,1.9,4.2,73.0,85.0,470.0,263.0,7.0,0.99,1.0,8.5,1.9,44.0,20.0,176.0,1.0,2,3,3,Category 2,Category 2,Category 3,0.3692304815098961,,0.5794148993435008,-0.5794148993435008,0.7903377358601481,0.59976786431195,0.6561340180205807,0.6561340180205807,42,,43.0 -59,1.0,0.0,,,,,0,0.0,1.0,1.0,0.0,,1.0,1.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,1.0,1.11,,18.7,92.4,6900.0,270000.0,4.0,0.9,35.0,73.0,115.0,103.0,6.8,1.24,1.0,10.0,,,,,1.0,2,2,2,Category 1,Category 2,Category 4,,,0.6626212790083204,-0.6626212790083204,0.5821482297799723,1.3051160574094443,0.12982644895171758,0.12982644895171758,42,,43.0 -60,1.0,0.0,1.0,0.0,1.0,0.0,1,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,0.0,50.0,1.0,1.0,3.0,1.28,608.0,12.6,100.0,5.4,129.0,4.0,1.7,107.0,99.0,125.0,100.0,7.5,0.9,5.0,3.5,0.5,,,,0.0,2,1,1,Category 2,Category 1,Category 3,,0.6616551750805415,0.09526150795462629,-0.09526150795462629,0.6809748272382445,0.6482281213211142,0.6868609976750291,0.6868609976750291,42,,43.0 -61,1.0,1.0,0.0,0.0,1.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,100.0,40.0,0.0,2.0,2.0,1.46,41.0,14.6,100.8,5.5,42000.0,3.1,3.7,121.0,165.0,101.0,207.0,6.3,0.69,1.0,3.0,1.9,224.0,95.0,363.0,0.0,1,3,2,Category 1,Category 2,Category 3,,,0.6521232455304379,-0.6521232455304379,0.1896948481746772,0.0749427857215988,0.0930304864600272,0.0930304864600272,42,,43.0 -62,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,30.0,2.0,1.0,2.0,1.94,,11.5,97.4,5700.0,77000.0,2.7,4.9,34.0,48.0,46.0,178.0,6.1,0.62,1.0,4.6,2.2,,,,0.0,1,1,1,Category 1,Category 2,Category 2,,,0.3121480566964471,-0.3121480566964471,0.6189481930077215,0.41895396964839826,0.029364159102392318,0.029364159102392318,42,,43.0 -63,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,300.0,,3.0,1.0,3.0,1.57,2.0,12.6,96.6,2.9,76000.0,3.5,2.4,33.0,40.0,110.0,166.0,,0.77,1.0,2.0,0.5,,,,0.0,1,1,2,Category 1,Category 2,Category 4,,,0.3990459461371111,-0.3990459461371111,0.32350039491147375,0.18470611505701817,0.8229584462214861,0.8229584462214861,42,,43.0 -64,0.0,0.0,0.0,0.0,0.0,0.0,0,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,,,,,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.29,7.0,12.1,95.1,3.8,77000.0,3.8,1.4,37.0,38.0,194.0,161.0,6.7,0.71,1.0,10.0,0.5,0.0,0.0,0.0,0.0,1,2,3,Category 1,Category 2,Category 4,,0.8766653778624495,0.8579862539227058,-0.8579862539227058,0.8343033659547675,0.7991788248093662,0.20975294768368136,0.20975294768368136,42,,43.0 -65,1.0,0.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,0.0,0.0,1.0,0.0,0.0,0.0,2.0,1.0,1.0,1.17,3.1,15.1,86.0,8.9,275000.0,2.8,1.3,74.0,50.0,23.0,104.0,5.4,0.6,5.0,7.8,0.2,46.0,18.0,,1.0,1,2,3,Category 1,Category 1,Category 4,,,0.009030404129550251,-0.009030404129550251,0.6292988060107362,1.661501998538744,0.3790271262190974,0.3790271262190974,42,,43.0 -66,,1.0,0.0,,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,60.0,,0.0,1.0,1.0,1.34,13.0,15.6,93.0,4.9,91000.0,4.54,1.4,54.0,52.0,275.0,113.0,7.8,0.55,2.0,6.2,0.3,94.0,33.0,393.0,0.0,1,2,1,Category 1,Category 1,Category 4,,,0.5884126333406055,-0.5884126333406055,0.1988562777752959,0.03126514419730245,0.9734573899761731,0.9734573899761731,42,,43.0 -67,1.0,1.0,0.0,0.0,1.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,100.0,0.0,0.0,1.0,1.0,2.07,1.7,9.5,99.2,3300.0,79000.0,2.1,1.6,56.0,82.0,134.0,113.0,37.0,0.4,1.0,2.7,0.2,94.0,37.0,48.0,0.0,1,2,4,Category 1,Category 3,Category 4,0.11669606414168132,0.9903413133417771,0.5987139801001076,-0.5987139801001076,0.06461667984408614,-0.07538136579093146,0.33684050186110326,0.33684050186110326,42,, -68,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,1.0,1.0,100.0,0.0,0.0,1.0,2.0,1.3,249.0,12.7,100.3,5.5,114.0,3.1,3.9,21.0,42.0,40.0,108.0,5.8,0.9,5.0,8.0,1.2,37.0,17.0,419.0,1.0,2,2,1,Category 2,Category 2,Category 4,0.4731662010518922,0.0002375235758845795,0.396659776343562,-0.396659776343562,0.042633209287032736,0.06696158282344718,0.29648978128331527,0.29648978128331527,42,,43.0 -69,1.0,1.0,0.0,0.0,1.0,0.0,1,,0.0,0.0,1.0,0.0,0.0,1.0,0.0,,,0.0,1.0,1.0,0.0,1.0,80.0,0.0,2.0,2.0,3.0,1.27,66.0,10.9,97.3,8.9,270.0,2.7,2.1,145.0,84.0,179.0,260.0,5.9,,5.0,3.0,1.3,15.0,17.0,639.0,1.0,1,3,1,Category 1,Category 3,Category 1,,,0.23702785710833618,-0.23702785710833618,0.37140856765014074,0.8095073502724591,0.9182079996227752,0.9182079996227752,42,,43.0 -70,1.0,0.0,0.0,0.0,1.0,0.0,1,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.17,358.0,12.7,74.0,2.2,51.0,2.9,2.8,53.0,41.0,54.0,94.0,4.9,0.2,2.0,5.4,0.8,50.0,16.0,20.0,0.0,2,1,2,Category 1,Category 1,Category 3,,,0.2346740382615511,-0.2346740382615511,0.2658511366543135,-0.3801267872158922,0.11074844531895811,0.11074844531895811,42,, -71,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,1.0,1.0,75.0,44.0,3.0,2.0,2.0,1.01,1810346.0,13.0,102.1,8300.0,433000.0,3.4,1.9,138.0,86.0,1575.0,417.0,6.5,0.64,5.0,15.0,1.1,,,,0.0,1,1,2,Category 2,Category 1,Category 4,0.10669925011343606,0.9325899094252529,0.8837096696607526,-0.8837096696607526,0.646090123462508,0.7798514361291058,0.7595824101146318,0.7595824101146318,42,,43.0 -72,1.0,1.0,0.0,0.0,0.0,0.0,1,,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,,1.0,1.0,1.0,1.0,0.0,50.0,48.0,2.0,1.0,2.0,1.53,33502.0,14.4,101.1,11.6,109.0,3.1,2.3,27.0,80.0,177.0,1.28,6.7,1.5,5.0,4.0,0.8,26.0,15.0,227.0,0.0,1,1,1,Category 2,Category 1,Category 3,,,0.4420243737828575,-0.4420243737828575,0.4993338349786183,0.09309307786253729,0.988065566652774,0.988065566652774,42,,43.0 -73,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,1.0,1.0,1.0,,0.0,0.0,1.0,1.0,0.94,20.0,13.0,92.0,6.9,222000.0,3.7,0.6,162.0,354.0,1390.0,684.0,7.1,0.81,5.0,,,,,,1.0,1,1,3,Category 2,Category 1,Category 3,,,0.33088936298917193,-0.33088936298917193,0.2660192780053807,0.4805833241406625,0.9012960107746488,0.9012960107746488,42,,43.0 -74,1.0,1.0,0.0,,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,15.0,0.0,1.0,1.0,1.15,2.5,14.9,92.3,6.0,159000.0,3.8,1.0,28.0,38.0,74.0,101.0,7.4,1.1,5.0,7.5,0.3,61.0,,255.0,0.0,2,2,2,Category 1,Category 1,Category 1,,,0.44877757383140304,-0.44877757383140304,0.14923777795017612,-0.08091096895661107,0.6516679187064259,0.6516679187064259,42,,43.0 -75,1.0,1.0,0.0,,,1.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,100.0,,0.0,1.0,1.0,1.92,2269.0,12.1,119.0,5.1,80000.0,,9.6,204.0,357.0,199.0,174.0,,0.99,1.0,7.6,4.6,178.0,90.0,960.0,1.0,2,1,4,Category 2,Category 1,Category 4,,,0.6693904014593614,-0.6693904014593614,0.1271997626874496,-0.8898551390390583,0.314060794992732,0.314060794992732,42,,43.0 -76,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0,,,2.0,1.0,2.0,3.16,4181.0,9.1,103.6,5.1,128000.0,3.0,2.2,57.0,91.0,115.0,165.0,7.7,0.83,1.0,4.5,1.2,72.0,29.5,355.0,1.0,2,3,2,Category 1,Category 1,Category 2,,,0.1457565682447517,-0.1457565682447517,0.8646603921404177,0.9392894951174534,0.2543219811783167,0.2543219811783167,42,,43.0 -77,1.0,1.0,0.0,0.0,0.0,0.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,0.0,0.0,1.0,80.0,,0.0,1.0,1.0,1.45,5.1,14.4,100.2,7.1,77000.0,4.1,0.9,43.0,63.0,540.0,114.0,7.0,1.09,5.0,,,,,,0.0,2,3,2,Category 1,Category 2,Category 1,,,0.4494338352137377,-0.4494338352137377,0.24347796840486724,0.376549527357401,0.8192551048714611,0.8192551048714611,42,,43.0 -78,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,0.0,1.0,1.0,80.0,,3.0,1.0,1.0,1.34,345.0,9.8,81.8,13.6,561.0,2.6,0.5,43.0,43.0,23.0,88.0,5.6,,5.0,4.7,0.5,19.0,8.0,141.0,0.0,1,1,4,Category 1,Category 3,Category 2,,,0.5878843711103869,-0.5878843711103869,0.6517106479109683,0.3341243286342522,0.8798219139516953,0.8798219139516953,42,,43.0 -79,,1.0,0.0,0.0,0.0,1.0,1,,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,100.0,34.5,2.0,2.0,2.0,2.08,2.9,10.4,91.1,5.8,91000.0,2.4,16.0,123.0,145.0,109.0,190.0,5.9,0.9,0.0,,9.6,,,,0.0,2,1,1,Category 1,Category 1,Category 3,,,0.9485833548514337,-0.9485833548514337,0.8106859279862663,0.4513696974283388,0.5254349125456929,0.5254349125456929,42,,43.0 -80,1.0,1.0,,,,,1,0.0,,1.0,0.0,0.0,1.0,1.0,0.0,,,1.0,1.0,0.0,1.0,1.0,,,3.0,2.0,1.0,1.32,2.5,12.6,83.7,9.8,102000.0,3.3,1.2,29.0,43.0,196.0,204.0,7.3,1.1,5.0,,0.5,,,,1.0,1,3,4,Category 2,Category 2,Category 3,,,0.25252778207541926,-0.25252778207541926,0.6140813111847361,-0.01894093853099965,0.24433994078646615,0.24433994078646615,42,,43.0 -81,0.0,1.0,0.0,,0.0,0.0,1,0.0,,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,100.0,,1.0,2.0,1.0,1.63,5.04,15.8,99.0,5.8,75000.0,3.5,4.6,93.0,85.0,193.0,165.0,6.6,0.7,1.0,6.0,1.7,200.0,87.0,316.0,0.0,1,3,1,Category 2,Category 2,Category 1,,,0.35925074791624556,-0.35925074791624556,0.8595652316469458,1.1105951603247655,0.11294320841117356,0.11294320841117356,42,,43.0 -82,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,,,,1.0,1.0,0.0,0.0,0.0,,1.0,0.0,0.0,0.0,100.0,0.0,1.0,1.0,3.0,1.71,3.7,14.8,104.3,5.8,56000.0,2.7,2.6,74.0,157.0,311.0,280.0,8.0,0.8,2.0,3.0,1.4,,1.52,859.0,0.0,2,2,1,Category 1,Category 3,Category 1,0.7815144817514149,0.33637046382842206,0.3793585899224238,-0.3793585899224238,0.3923937215284745,0.7377032935925748,0.08717946783183117,0.08717946783183117,42,,43.0 -83,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,100.0,,2.0,1.0,3.0,1.48,2.6,12.7,106.0,3.8,80.0,2.9,3.4,34.0,53.0,156.0,207.0,7.2,,2.0,4.1,1.4,105.0,69.0,221.0,1.0,2,3,1,Category 1,Category 1,Category 2,,,0.6055381576448828,-0.6055381576448828,0.9562221906489483,0.47743057411288564,0.7190774473538556,0.7190774473538556,42,,43.0 -84,,0.0,0.0,0.0,0.0,1.0,1,,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,,0.0,,,1.1,2.9,16.4,94.8,4.6,94000.0,4.1,1.1,104.0,74.0,88.0,85.0,7.9,1.05,1.0,5.5,0.3,,,,0.0,2,2,4,Category 1,Category 3,Category 4,0.7505019247653135,,0.35673205304000166,-0.35673205304000166,0.13314500417809694,-0.11552147076622284,0.42011872784772497,0.42011872784772497,42,,43.0 -85,1.0,1.0,0.0,0.0,1.0,0.0,1,0.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,,10.0,1.0,2.0,1.0,1.47,20.0,13.9,100.8,4.0,112000.0,3.0,2.9,50.0,92.0,124.0,244.0,6.3,0.8,2.0,6.8,0.7,181.0,99.0,108.0,0.0,2,2,1,Category 2,Category 1,Category 2,0.7995371309195156,,0.5335119252996956,-0.5335119252996956,0.1021495296575381,0.06434748836475973,0.9053598742778703,0.9053598742778703,42,,43.0 -86,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,0.0,1.0,1.0,,,1.0,1.0,1.0,1.08,2.79,12.6,83.9,7100.0,284000.0,,,28.0,46.0,70.0,213.0,,0.48,5.0,,,26.0,8.0,,0.0,2,2,3,Category 1,Category 2,Category 1,,,0.7817903298450294,-0.7817903298450294,0.6586921462074435,1.5826701590296028,0.7396713007267637,0.7396713007267637,42,,43.0 -87,0.0,0.0,0.0,0.0,1.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,0.0,0.0,1.0,0.0,33.0,0.0,1.0,2.0,,42.0,15.8,97.9,4.2,142000.0,4.2,0.5,74.0,62.0,38.0,70.0,7.5,0.77,3.0,1.5,,120.0,35.0,30.0,0.0,2,2,4,Category 1,Category 2,Category 2,,,0.7053855941122036,-0.7053855941122036,0.9428311414132617,1.0861610882385797,0.1912604179145867,0.1912604179145867,42,, -88,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,100.0,,0.0,1.0,2.0,1.37,457.0,11.7,70.6,5.7,138000.0,4.1,2.1,22.0,33.0,33.0,90.0,9.7,1.6,5.0,5.6,0.9,13.0,3.0,28.0,1.0,2,2,3,Category 2,Category 2,Category 1,,0.8528218216919013,0.44636864651258557,-0.44636864651258557,0.8088834616363281,0.3167698263037048,0.613777418815699,0.613777418815699,42,,43.0 -89,0.0,1.0,0.0,0.0,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,50.0,1.0,2.0,3.0,1.23,,9.5,90.0,7.6,38000.0,2.2,1.5,59.0,51.0,993.0,474.0,3.9,2.69,1.0,2.0,1.0,,,,0.0,2,1,1,Category 2,Category 2,Category 2,0.6337585637201772,0.7155533152342419,0.8642161776741689,-0.8642161776741689,0.07641685943805143,0.20118994050490857,0.43550545439815935,0.43550545439815935,42,, -90,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,0.0,100.0,0.0,2.0,1.0,3.0,1.41,123.0,10.1,89.5,2.3,89000.0,4.0,4.3,31.0,60.0,75.0,177.0,6.8,0.7,3.0,3.5,1.0,37.0,11.0,173.0,1.0,1,3,2,Category 1,Category 3,Category 1,,0.5891085344708948,0.5581402495938629,-0.5581402495938629,0.2793677139347164,-0.34865498766562686,0.5772497307686131,0.5772497307686131,42,,43.0 -91,0.0,1.0,0.0,,0.0,0.0,1,0.0,,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,,,,,,0.0,1.0,1.0,1.22,8.7,14.6,95.1,6.7,142000.0,4.2,1.3,19.0,33.0,346.0,120.0,7.8,0.83,,,0.3,184.0,65.0,423.0,0.0,2,2,1,Category 2,Category 1,Category 1,,0.2772656456967736,0.5399058395022125,-0.5399058395022125,0.9303188848378237,1.150251716690645,0.7380691233385172,0.7380691233385172,42,,43.0 -92,1.0,1.0,0.0,0.0,1.0,0.0,1,0.0,0.0,1.0,0.0,,1.0,1.0,0.0,0.0,,0.0,1.0,0.0,0.0,1.0,70.0,0.0,3.0,1.0,1.0,1.01,226.0,11.5,95.6,6.3,108.0,4.2,1.0,27.0,31.0,667.0,222.0,6.2,3.13,1.0,8.8,0.2,,,,1.0,2,3,3,Category 2,Category 1,Category 1,,,0.03418776593915818,-0.03418776593915818,0.25305843280078455,0.9581067658780446,0.8061958810037908,0.8061958810037908,42,,43.0 -93,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,1.0,,,0.0,,0.0,,,1.0,1.0,1.0,1.0,200.0,60.0,1.0,1.0,1.0,1.39,2159.0,13.1,90.6,10400.0,261000.0,3.6,1.9,42.0,197.0,552.0,335.0,7.1,0.68,5.0,,0.6,,,,1.0,1,3,3,Category 1,Category 3,Category 4,,,0.9866929803571616,-0.9866929803571616,0.7811704237869193,1.4352576015563145,0.8437373264067243,0.8437373264067243,42,,43.0 -94,,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,1.0,,0.0,0.0,0.0,0.0,0.0,0.0,1.0,100.0,50.0,0.0,1.0,1.0,1.09,48.0,12.6,97.6,4.9,169000.0,4.2,0.8,30.0,31.0,86.0,91.0,6.9,1.9,5.0,2.0,,53.0,21.0,278.0,0.0,2,2,4,Category 2,Category 1,Category 2,,0.10946759867911515,0.12297080852962672,-0.12297080852962672,0.8251321959287038,1.0629516279267532,0.2539748745720247,0.2539748745720247,42,, -95,0.0,0.0,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.6,2.4,9.5,85.8,6900.0,228000.0,3.5,0.6,11.0,17.0,44.0,124.0,6.8,1.6,1.0,5.5,,15.0,7.0,810.0,1.0,1,1,2,Category 1,Category 2,Category 2,0.713782454855326,,0.2311309124276466,-0.2311309124276466,0.4954521034609818,0.1916033429506671,0.031115599917357684,0.031115599917357684,42,,43.0 -96,1.0,1.0,0.0,0.0,0.0,1.0,0,1.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,,0.0,1.0,1.0,2.0,1.11,5.0,9.1,90.9,6.36,307000.0,2.47,,31.0,29.0,339.0,254.0,5.5,1.18,3.0,6.3,,,,,0.0,1,2,4,Category 2,Category 1,Category 2,,0.12443755729685635,0.05169683724152696,-0.05169683724152696,0.3863489098483155,-0.21933591034847888,0.7392947351647732,0.7392947351647732,42,,43.0 -97,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,,,0.0,1.0,1.0,1.64,64.0,14.1,103.6,4.5,68.0,2.9,3.3,28.0,43.0,51.0,137.0,6.8,0.67,4.0,4.7,1.1,,,,0.0,2,1,3,Category 1,Category 2,Category 1,0.6241015441818376,,0.6400029668369137,-0.6400029668369137,0.45012443241975963,-0.20522323925040953,0.1063437262557746,0.1063437262557746,42,,43.0 -98,0.0,1.0,0.0,,0.0,0.0,1,0.0,,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,0.0,1.0,1.0,1.23,5.5,13.1,89.6,6.1,160000.0,3.2,0.8,28.0,30.0,90.0,92.0,6.3,0.86,5.0,,,93.0,25.0,29.0,0.0,1,3,1,Category 1,Category 3,Category 2,0.539781061914633,,0.22470117697268,-0.22470117697268,0.22696469436536415,-1.0189334544650683,0.31491958861296765,0.31491958861296765,42,,43.0 -99,0.0,1.0,0.0,,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,0.0,2.0,1.0,2.0,1.67,8.5,13.0,102.3,24.8,133000.0,2.7,9.5,262.0,335.0,351.0,66.0,6.1,1.2,5.0,7.0,5.5,,,,0.0,1,1,2,Category 1,Category 1,Category 2,,0.25898265160181366,0.1800104374727235,-0.1800104374727235,0.8893909161288442,1.1028965397504435,0.0038171341243471435,0.0038171341243471435,42,,43.0 -100,1.0,1.0,,,,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,1.0,1.0,0.0,1.0,0.0,,0.0,2.0,1.0,1.0,1.16,2785.0,12.0,94.4,7.9,78000.0,2.6,3.5,26.0,34.0,339.0,297.0,5.7,2.19,5.0,,1.5,55.0,33.0,256.0,0.0,1,1,1,Category 2,Category 3,Category 1,0.5774862709061257,,0.08855558422324139,-0.08855558422324139,0.4506196567297579,0.3607327270103231,0.6816694824016201,0.6816694824016201,42,, -101,1.0,0.0,0.0,0.0,0.0,1.0,1,0.0,,0.0,0.0,0.0,1.0,0.0,0.0,0.0,,1.0,1.0,0.0,1.0,1.0,0.0,,1.0,1.0,3.0,1.04,6574.0,13.5,98.0,4800.0,77000.0,3.5,28.9,56.0,192.0,464.0,262.0,6.9,1.2,5.0,4.0,19.5,121.0,27.0,749.0,1.0,1,1,1,Category 1,Category 1,Category 3,,0.9823305150800816,0.10330895712401567,-0.10330895712401567,0.8824594404560998,1.1905316351507538,0.16713201147122125,0.16713201147122125,42,,43.0 -102,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,1.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,1.0,70.0,,2.0,1.0,2.0,1.55,5.7,13.9,99.7,5200.0,124000.0,2.1,0.8,37.0,75.0,203.0,110.0,5.0,0.56,3.0,2.4,,92.0,56.0,489.0,0.0,2,3,2,Category 2,Category 2,Category 1,0.3914821102015019,,0.5846707004425887,-0.5846707004425887,0.10569347990627409,0.7175886251489202,0.6552824096916582,0.6552824096916582,42,,43.0 -103,1.0,0.0,1.0,,,1.0,1,,,0.0,0.0,,0.0,0.0,0.0,0.0,,,1.0,0.0,,0.0,0.0,,4.0,3.0,3.0,1.93,,13.5,93.3,8190.0,406000.0,2.9,40.5,139.0,266.0,403.0,670.0,6.3,4.82,5.0,,29.3,,,,1.0,1,3,4,Category 1,Category 3,Category 2,,,0.6882078658665954,-0.6882078658665954,0.9882752710001314,0.9329955608771253,0.9917426171678388,0.9917426171678388,42,,43.0 -104,1.0,0.0,0.0,0.0,0.0,0.0,0,,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,50.0,1.0,1.0,1.0,1.17,39.0,12.6,93.8,4900.0,144000.0,3.8,1.0,42.0,74.0,277.0,312.0,78.0,1.01,1.0,15.0,,87.0,25.0,81.0,0.0,2,1,1,Category 1,Category 1,Category 1,0.06661911239081697,0.9037239671752705,0.397378988464401,-0.397378988464401,0.44327308744361826,0.4625689693368711,0.07267087161001629,0.07267087161001629,42,,43.0 -105,1.0,1.0,0.0,0.0,0.0,0.0,1,,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,0.0,3.0,1.0,2.0,1.48,2.5,14.3,101.5,5.0,120.0,2.2,1.2,34.0,71.0,222.0,97.0,5.2,2.82,3.0,2.4,0.3,92.0,56.0,48.9,0.0,1,1,3,Category 2,Category 2,Category 3,,,0.4798970815920732,-0.4798970815920732,0.04783082039410547,-0.15934480755474986,0.07707801195146069,0.07707801195146069,42,, -106,1.0,1.0,0.0,0.0,1.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0,1.0,80.0,1.0,0.0,1.0,1.0,1.18,32.0,14.0,90.1,5.2,121000.0,4.2,0.4,420.0,226.0,147.0,174.0,8.6,0.9,5.0,3.0,,26.4,54.0,2230.0,0.0,1,2,1,Category 1,Category 3,Category 1,,0.7433528228936241,0.6859677359829841,-0.6859677359829841,0.038021848237454914,-0.11663503662516046,0.3403800926666749,0.3403800926666749,42,,43.0 -107,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,,0.0,1.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,75.0,0.0,3.0,1.0,2.0,1.32,7.6,5.0,69.5,3800.0,96000.0,3.7,0.5,17.0,69.0,76.0,86.0,6.3,2.68,1.0,10.0,,9.0,3.0,490.0,1.0,1,1,2,Category 1,Category 3,Category 2,0.4315281431364426,0.06498640948289403,0.017379790185479638,-0.017379790185479638,0.7462072574818386,0.9891192049215987,0.866386514251342,0.866386514251342,42,, -108,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,1.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,1.0,0.0,1.0,1.0,100.0,0.0,1.0,1.0,1.0,1.25,173.0,11.3,103.9,6200.0,176000.0,2.4,1.7,63.0,114.0,80.0,163.0,6.1,0.67,5.0,20.0,0.5,131.0,78.0,1316.0,1.0,1,2,2,Category 2,Category 1,Category 3,,,0.32313065707027855,-0.32313065707027855,0.6590355342036808,0.5171236672193903,0.21552986879133185,0.21552986879133185,42,,43.0 -109,0.0,1.0,0.0,0.0,0.0,0.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,,,0.0,1.0,1.0,1.54,2.3,12.1,89.7,4.5,97000.0,2.7,1.4,19.0,27.0,72.0,120.0,4.3,0.61,5.0,4.0,0.7,,,,0.0,2,1,2,Category 1,Category 1,Category 4,,,0.9730977480703464,-0.9730977480703464,0.8021305581275875,0.5828652841558029,0.36037781993034756,0.36037781993034756,42,,43.0 -110,1.0,1.0,1.0,0.0,1.0,0.0,1,,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,1.0,200.0,30.0,2.0,2.0,2.0,1.26,114.0,14.9,104.5,4.3,90000.0,3.2,4.8,106.0,154.0,148.0,166.0,7.2,0.48,5.0,12.6,1.8,161.0,96.0,297.0,0.0,2,2,4,Category 1,Category 1,Category 2,,,0.580112229695468,-0.580112229695468,0.10536753395280596,0.08684664663008267,0.06850540662697957,0.06850540662697957,42,,43.0 -111,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,1.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,1.0,90.0,,2.0,1.0,2.0,1.87,173.0,11.1,105.5,6.1,51000.0,3.1,32.3,110.0,206.0,127.0,188.0,5.4,1.29,5.0,,22.1,,,,1.0,1,3,1,Category 1,Category 2,Category 3,0.16673075999338316,,0.25422457989749325,-0.25422457989749325,0.03557086703554835,0.41835615585609953,0.7631552912588894,0.7631552912588894,42,,43.0 -112,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,100.0,,0.0,1.0,1.0,1.36,18.0,15.3,90.9,4.9,81000.0,4.2,1.7,35.0,49.0,97.0,109.0,7.3,1.02,1.0,3.5,0.3,,,,0.0,1,1,4,Category 1,Category 1,Category 3,,,0.5217300466362131,-0.5217300466362131,0.5085792894475785,0.15579718723713354,0.4083063427594511,0.4083063427594511,42,,43.0 -113,1.0,0.0,1.0,0.0,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,0.0,0.0,7.5,1.0,1.0,1.0,1.45,42.0,16.2,99.1,5.001,77000.0,4.1,1.3,42.0,118.0,279.0,158.0,7.7,0.88,2.0,7.4,0.3,,,,0.0,2,1,4,Category 2,Category 3,Category 4,,0.046945357147813005,0.34265348812091534,-0.34265348812091534,0.38759523148276953,0.31983659984720436,0.7592487330608428,0.7592487330608428,42,,43.0 -114,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,1.0,0.0,,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,100.0,,3.0,3.0,2.0,1.87,28274.0,10.3,94.7,11.1,109000.0,2.4,5.7,25.0,111.0,55.0,128.0,7.0,1.3,1.0,1.5,1.9,51.0,18.0,56.0,1.0,1,1,2,Category 2,Category 3,Category 1,,,0.5322449888262991,-0.5322449888262991,0.46194693667095577,0.522666373800494,0.9036078443467951,0.9036078443467951,42,,43.0 -115,1.0,1.0,0.0,,,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,,0.0,0.0,0.0,100.0,43.0,0.0,1.0,1.0,1.23,736.0,14.0,88.2,4.68,286000.0,4.7,0.8,48.0,113.0,649.0,629.0,8.4,0.71,5.0,9.1,0.3,,,,0.0,1,1,2,Category 1,Category 1,Category 1,,,0.12574151180664883,-0.12574151180664883,0.991588408870274,1.3981585709642914,0.23276314710128876,0.23276314710128876,42,,43.0 -116,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,96.0,60.0,0.0,1.0,3.0,1.17,1009.0,13.8,93.2,3100.0,137000.0,3.0,0.7,25.0,55.0,343.0,235.0,,0.79,2.0,20.0,,,,,1.0,1,2,4,Category 2,Category 1,Category 2,,,0.13271465381927738,-0.13271465381927738,0.9707499576706702,0.7693679151452357,0.8073960303399513,0.8073960303399513,42,,43.0 -117,1.0,1.0,1.0,1.0,1.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,0.0,120.0,,4.0,3.0,2.0,2.42,22475.0,12.0,111.4,9.9,70000.0,3.28,19.0,134.0,178.0,54.0,146.0,8.0,3.23,1.0,,9.7,106.0,67.0,2165.0,1.0,2,1,1,Category 1,Category 3,Category 4,0.7524031200388227,,0.14354236203939286,-0.14354236203939286,0.9423153896731928,0.5351918907949096,0.059093890078253275,0.059093890078253275,42,,43.0 -118,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,,0.0,0.0,1.0,1.0,1.28,5.2,14.6,96.1,6.1,194000.0,4.2,7.9,97.0,69.0,816.0,79.0,7.7,1.02,1.0,3.0,,,,,0.0,2,3,3,Category 2,Category 2,Category 1,,,0.9398197919268417,-0.9398197919268417,0.7838426767676738,0.4943303682627932,0.8988473881802473,0.8988473881802473,42,,43.0 -119,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,180.0,23.0,0.0,1.0,2.0,1.46,5.2,14.9,103.8,4500.0,53000.0,3.2,1.4,62.0,87.0,263.0,239.0,8.1,0.72,1.0,1.5,1.0,,,,0.0,2,3,4,Category 1,Category 1,Category 4,,,0.7328989183413418,-0.7328989183413418,0.3548413602568904,0.7783743174570403,0.6507685475587474,0.6507685475587474,42,,43.0 -120,1.0,0.0,1.0,0.0,,0.0,1,1.0,0.0,1.0,0.0,0.0,1.0,0.0,,,,,,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.14,14177.0,10.2,96.1,6000.0,109000.0,2.6,4.9,70.0,113.0,833.0,980.0,7.5,0.78,5.0,9.0,2.8,,,,0.0,1,1,1,Category 1,Category 1,Category 1,0.14312798554846962,,0.1623818946623209,-0.1623818946623209,0.4121309302627716,1.2572150690343238,0.8742267241383516,0.8742267241383516,42,,43.0 -121,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,0.0,1.0,100.0,0.0,0.0,1.0,1.0,1.94,3.1,10.8,102.8,5300.0,97000.0,3.6,1.1,119.0,125.0,663.0,433.0,6.5,0.87,2.0,3.2,0.4,52.5,37.0,856.0,1.0,1,3,2,Category 1,Category 3,Category 3,,,0.18834908376560144,-0.18834908376560144,0.5496160437189245,-0.07799931526740322,0.00018839955658189744,0.00018839955658189744,42,,43.0 -122,1.0,1.0,0.0,0.0,1.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,0.0,75.0,52.5,2.0,1.0,1.0,1.56,50655.0,9.8,85.6,3900.0,132000.0,2.6,2.6,123.0,219.0,503.0,363.0,7.3,0.55,1.0,4.0,1.5,40.0,12.0,57.0,1.0,2,1,2,Category 1,Category 1,Category 1,,,0.7308294748708763,-0.7308294748708763,0.8305344564048399,0.2700501054857166,0.1690810703559925,0.1690810703559925,42,,43.0 -123,0.0,0.0,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,,,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.11,1.2,15.1,83.8,5.2,178000.0,4.7,0.5,35.0,17.0,45.3,151.0,6.4,1.5,1.0,8.3,,88.0,27.0,90.0,0.0,2,1,1,Category 1,Category 2,Category 4,,,0.15616384479217393,-0.15616384479217393,0.06871283251826776,-0.011735264256463138,0.3897593874264921,0.3897593874264921,42,,43.0 -124,1.0,1.0,0.0,0.0,1.0,1.0,1,,1.0,0.0,0.0,1.0,0.0,0.0,0.0,,1.0,0.0,1.0,0.0,0.0,0.0,,,2.0,1.0,2.0,1.08,657.0,11.8,89.2,9400.0,211000.0,3.2,0.8,43.0,101.0,646.0,466.0,7.3,0.7,1.0,8.3,,,,579.0,1.0,2,3,3,Category 1,Category 3,Category 3,,,0.23456129333482867,-0.23456129333482867,0.4242968858848881,0.4302318382894385,0.3795029033747186,0.3795029033747186,42,,43.0 -125,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,1.0,100.0,,4.0,2.0,2.0,1.2,421500.0,14.3,89.5,9.8,309000.0,3.1,1.5,20.0,44.0,291.0,217.0,6.3,0.7,1.0,20.0,0.5,52.0,17.0,832.0,1.0,2,1,2,Category 2,Category 1,Category 3,,0.5152479243147259,0.963346832820399,-0.963346832820399,0.08261766345926869,0.417387977902975,0.22673038292351066,0.22673038292351066,42,,43.0 -126,0.0,0.0,0.0,0.0,,1.0,1,0.0,,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,0.0,,0.0,1.0,1.0,1.2,472.0,15.6,88.4,5.5,83000.0,4.0,2.4,117.0,128.0,249.0,117.0,7.2,0.69,1.0,13.0,0.7,,,,0.0,1,3,2,Category 1,Category 3,Category 3,,0.49118634086862656,0.25530652472843185,-0.25530652472843185,0.5146575865735116,0.07475595494143639,0.3816119398672001,0.3816119398672001,42,,43.0 -127,0.0,1.0,0.0,0.0,0.0,,1,0.0,0.0,1.0,0.0,,1.0,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,1.0,,0.0,3.0,2.0,1.0,1.66,77.0,12.3,104.2,2900.0,60000.0,3.2,2.8,54.0,38.0,311.0,182.0,6.2,0.77,2.0,4.3,1.0,93.0,47.0,307.0,0.0,2,2,2,Category 2,Category 1,Category 4,,,0.6616323503711468,-0.6616323503711468,0.8989008240062354,0.3456122559336226,0.12884871200025483,0.12884871200025483,42,,43.0 -128,0.0,0.0,1.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,0.0,0.0,0.0,0.0,0.0,510.0,2.0,1.0,1.0,1.13,2.1,12.6,95.1,8.7,254000.0,3.68,0.7,26.0,38.0,161.0,127.0,6.9,1.11,2.0,4.3,,28.0,10.0,308.0,1.0,1,1,1,Category 1,Category 1,Category 2,0.45700021928167833,0.8974361480462039,0.9786312874005304,-0.9786312874005304,0.7824849245639379,0.764427226698616,0.41276112926602604,0.41276112926602604,42,,43.0 -129,1.0,1.0,,,,,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,1.0,0.0,0.0,1.0,75.0,0.0,2.0,2.0,2.0,1.07,2.0,11.6,83.5,9.0,318000.0,3.89,0.9,23.0,48.0,319.0,171.0,7.1,0.66,2.0,5.8,,,,,1.0,2,2,4,Category 2,Category 1,Category 2,,,0.37429676713979265,-0.37429676713979265,0.22784241754310997,0.09242391315668144,0.8023543291592642,0.8023543291592642,42,,43.0 -130,1.0,0.0,,,,0.0,1,0.0,0.0,0.0,1.0,0.0,1.0,0.0,,,,0.0,0.0,1.0,1.0,0.0,0.0,0.0,2.0,1.0,3.0,1.22,4.2,14.9,87.4,15.4,179000.0,3.5,0.6,31.0,61.0,196.0,150.0,5.4,0.7,5.0,17.5,0.3,,,,0.0,1,3,2,Category 2,Category 2,Category 2,,0.6229373829351187,0.017515990862062236,-0.017515990862062236,0.9759908495987925,1.282340082453239,0.4790700631033512,0.4790700631033512,42,,43.0 -131,0.0,1.0,,,,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,1.0,100.0,,2.0,2.0,2.0,2.5,7.5,11.3,119.6,13.1,135000.0,3.2,8.6,62.0,94.0,82.0,147.0,6.5,1.0,5.0,2.6,3.8,,,,0.0,2,2,4,Category 2,Category 2,Category 4,,,0.24414729042237426,-0.24414729042237426,0.6673503980464284,0.813050571366861,0.018000088945214987,0.018000088945214987,42,,43.0 -132,0.0,0.0,0.0,0.0,0.0,1.0,1,,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.21,152.0,10.9,99.6,7.3,93000.0,3.2,1.3,82.0,80.0,427.0,106.0,7.1,6.1,2.0,9.0,0.7,,,,1.0,2,2,3,Category 1,Category 3,Category 3,0.4863574819956078,,0.8308771913417055,-0.8308771913417055,0.010427699397403067,0.2514691746239373,0.4214440415792474,0.4214440415792474,42,,43.0 -133,1.0,0.0,,,,,0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,1.0,1.0,1.0,1.09,811.0,11.4,89.3,9.1,318000.0,3.4,0.8,77.0,102.0,739.0,587.0,7.2,2.14,5.0,16.0,,14.0,5.0,149.0,1.0,2,3,2,Category 1,Category 1,Category 2,0.4089551770854932,,0.8646088359550367,-0.8646088359550367,0.2554134846852195,0.1843297731825145,0.027175016090844162,0.027175016090844162,42,,43.0 -134,1.0,0.0,,,,,0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.42,4.7,14.2,90.3,6690.0,268000.0,3.1,0.32,37.0,44.0,80.0,517.0,5.5,0.7,1.0,13.0,0.12,,,,0.0,2,2,2,Category 2,Category 1,Category 4,0.7718819805982451,0.8601268164179238,0.7685193645237912,-0.7685193645237912,0.26071329991991654,1.2614155999777465,0.9662434107067982,0.9662434107067982,42,,43.0 -135,1.0,0.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,1.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,1.0,1.0,1.0,1.24,2.6,13.3,96.4,7.8,280000.0,4.1,0.6,70.0,52.0,141.0,123.0,6.8,0.82,5.0,8.3,,,,,0.0,1,2,3,Category 1,Category 2,Category 2,0.012203072318044517,,0.11310981907657303,-0.11310981907657303,0.06925430628585993,-0.3028370035349632,0.12745395942286897,0.12745395942286897,42,,43.0 -136,1.0,0.0,0.0,0.0,0.0,0.0,0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,0.0,40.0,2.0,1.0,1.0,1.25,2089.0,15.4,91.6,10.9,175000.0,4.4,1.3,45.0,32.0,717.0,295.0,7.4,1.1,5.0,6.0,0.6,,,,0.0,2,3,2,Category 2,Category 1,Category 1,,,0.7955103716964032,-0.7955103716964032,0.959826518075929,1.1300897001741304,0.7076883263306187,0.7076883263306187,42,,43.0 -137,1.0,0.0,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,2.0,1.0,1.03,18.0,13.2,89.5,2.6,136000.0,4.3,0.8,18.0,29.0,82.0,141.0,7.2,0.85,1.0,9.5,,91.0,31.0,80.0,0.0,1,2,4,Category 1,Category 2,Category 2,0.5655083473229738,0.27295937485631494,0.9186777969935043,-0.9186777969935043,0.47825529457592375,-0.12301526920938238,0.9727763228920858,0.9727763228920858,42,, -138,1.0,0.0,0.0,0.0,1.0,0.0,1,,,,,0.0,,,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,,0.0,1.0,1.0,1.19,4.9,13.6,97.3,5400.0,133000.0,4.5,0.9,54.0,63.0,487.0,89.0,7.8,0.78,2.0,3.32,,78.0,30.0,220.0,0.0,1,3,1,Category 2,Category 1,Category 2,,,0.6006095425462361,-0.6006095425462361,0.895814597371882,0.3383194249923379,0.8260390516665719,0.8260390516665719,42,,43.0 -139,1.0,1.0,0.0,0.0,1.0,1.0,1,0.0,1.0,1.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,,12.0,2.0,1.0,1.0,0.94,240.0,14.7,102.3,9.9,267000.0,3.6,0.5,64.0,132.0,356.0,192.0,7.4,0.9,3.0,2.0,0.4,,,,0.0,1,2,4,Category 2,Category 3,Category 3,,,0.9408753563380648,-0.9408753563380648,0.32221550344462835,0.025258144217883582,0.6993153751262037,0.6993153751262037,42,,43.0 -140,1.0,0.0,,,,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.25,180.0,12.2,87.6,7.2,130.0,3.5,0.5,79.0,58.0,229.0,302.0,7.0,0.6,5.0,9.0,,,,206.0,1.0,1,3,1,Category 1,Category 1,Category 4,,,0.8268388837118774,-0.8268388837118774,0.12523357043282712,0.8229157904565922,0.8394609095007669,0.8394609095007669,42,,43.0 -141,1.0,0.0,0.0,0.0,1.0,1.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,0.0,0.0,,0.0,1.0,1.0,1.47,15.0,13.3,89.7,5.7,154000.0,3.2,1.0,,87.0,120.0,108.0,102.0,0.68,3.0,2.0,,,,,1.0,2,3,1,Category 2,Category 1,Category 3,,,0.6669715169909073,-0.6669715169909073,0.4743361099062139,0.5419314143268217,0.9817986932606276,0.9817986932606276,42,,43.0 -142,,1.0,0.0,0.0,0.0,1.0,1,0.0,0.0,1.0,1.0,1.0,0.0,1.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,70.0,0.0,0.0,1.0,,1.02,24.0,16.0,98.8,6.6,96000.0,4.1,1.4,207.0,158.0,116.0,84.0,7.2,0.9,1.0,2.2,0.3,,,,0.0,1,2,4,Category 1,Category 2,Category 3,,0.329051365369871,0.5771852367117482,-0.5771852367117482,0.11395663471431716,-0.15482245167331599,0.6213444972535296,0.6213444972535296,42,,43.0 -143,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,1.0,0.0,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,0.0,,40.0,0.0,1.0,1.0,1.798,9.4,11.2,102.4,4.1,60000.0,3.4,3.7,43.0,63.0,175.0,106.0,7.6,0.52,1.0,2.1,1.1,94.0,39.0,344.0,0.0,1,2,4,Category 2,Category 1,Category 3,,,0.3485736672419705,-0.3485736672419705,0.4860155029775399,0.6006269632424499,0.5591848068293265,0.5591848068293265,42,,43.0 -144,,1.0,0.0,0.0,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,,0.0,0.0,1.0,,37.0,0.0,1.0,1.0,1.26,7.0,14.9,106.3,6.4,122.0,3.0,1.5,195.0,401.0,272.0,93.0,6.4,1.0,3.0,2.9,0.4,124.0,51.0,642.0,0.0,1,2,4,Category 2,Category 1,Category 3,,,0.15928744524280514,-0.15928744524280514,0.9202971812194077,0.8435880694183653,0.6282381104632814,0.6282381104632814,42,,43.0 -145,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,,,,,,0.0,,,,,0.0,0.0,0.0,,,0.0,1.0,1.0,1.0,4.8,9.2,94.0,6.2,157000.0,3.88,0.76,42.0,51.0,983.0,141.0,,1.1,1.0,15.0,0.33,,,,0.0,2,1,4,Category 1,Category 2,Category 3,0.2879296164757261,0.28139096057752677,0.6049539226905408,-0.6049539226905408,0.5207681418342127,0.254245107751726,0.532675886761555,0.532675886761555,42,,43.0 -146,1.0,1.0,0.0,0.0,0.0,0.0,1,,1.0,0.0,1.0,0.0,1.0,1.0,0.0,,1.0,0.0,1.0,1.0,0.0,0.0,100.0,15.0,2.0,1.0,3.0,1.68,92421.0,14.3,72.2,13.3,459000.0,3.2,1.6,24.0,76.0,570.0,472.0,5.9,2.02,1.0,,0.6,29.0,4.0,14.0,1.0,2,1,3,Category 1,Category 3,Category 2,,,0.3181115536181195,-0.3181115536181195,0.6164997268950835,-0.05392665019579723,0.6350891059097188,0.6350891059097188,42,, -147,0.0,1.0,0.0,,0.0,0.0,1,,,1.0,1.0,,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,,0.0,1.0,1.0,1.71,5.2,11.1,106.9,2100.0,52000.0,3.3,2.6,15.0,47.0,94.0,117.0,7.1,0.79,1.0,3.5,1.0,,,,0.0,2,1,2,Category 1,Category 3,Category 3,0.9118524088429647,,0.8664386675276454,-0.8664386675276454,0.1566384369738083,0.768020724874327,0.44984220797255925,0.44984220797255925,42,,43.0 -148,0.0,0.0,0.0,,0.0,0.0,1,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.18,16.0,13.3,94.3,4800.0,96000.0,3.8,1.2,26.0,35.0,75.0,105.0,7.6,0.53,1.0,2.4,0.3,,,,0.0,2,3,1,Category 2,Category 2,Category 3,0.13911619414306187,0.6957142928497502,0.9933369373586285,-0.9933369373586285,0.043735625879969486,0.13081966524896083,0.2184431828833071,0.2184431828833071,42,,43.0 -149,1.0,0.0,0.0,0.0,0.0,0.0,0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,0.0,0.0,0.0,2.0,1.0,1.0,,1.5,,,,,,,,,,,,,1.0,6.6,,,,,0.0,1,2,4,Category 1,Category 2,Category 4,,,0.7524277626155725,-0.7524277626155725,0.11080796217980704,1.0472377559262789,0.12024722651167563,0.12024722651167563,42,,43.0 -150,0.0,0.0,0.0,0.0,1.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.12,3204.0,16.1,92.0,10.5,182.0,4.3,0.7,46.0,31.0,92.0,79.0,7.3,1.0,1.0,,0.2,,,,0.0,1,3,4,Category 2,Category 2,Category 1,0.2560155318536622,,0.09048169528705075,-0.09048169528705075,0.5985315756843657,0.9485551099523386,0.0683409355322604,0.0683409355322604,42,,43.0 -151,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,,,0.0,0.0,1.0,,,0.0,1.0,1.0,1.2,10.0,13.5,104.9,13.5,194.0,4.0,1.0,31.0,79.0,126.0,85.0,7.6,0.8,1.0,7.0,0.4,,,,0.0,2,1,4,Category 2,Category 2,Category 2,,,0.2886855955306381,-0.2886855955306381,0.09501169899230466,0.3258252256744784,0.2633157837532001,0.2633157837532001,42,,43.0 -152,1.0,1.0,0.0,0.0,0.0,1.0,1,0.0,1.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,1.0,250.0,18.0,1.0,1.0,3.0,1.39,695.0,11.1,93.9,5.4,88000.0,2.7,1.0,31.0,73.0,38.0,44.0,7.0,0.96,5.0,3.5,,,,,0.0,1,2,3,Category 1,Category 2,Category 2,,,0.10910963176574973,-0.10910963176574973,0.3759928899413114,0.14869243212389777,0.046123564335733835,0.046123564335733835,42,, -153,1.0,1.0,,,,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,,0.0,3.0,1.0,1.0,1.2,33.0,9.7,91.6,10.1,277.0,3.8,2.4,60.0,54.0,468.0,338.0,7.0,1.13,1.0,15.0,1.3,,,,1.0,1,3,4,Category 1,Category 3,Category 2,,0.8944799309680674,0.6505116477917158,-0.6505116477917158,0.550091940458156,0.017632684301552737,0.5671707799193856,0.5671707799193856,42,,43.0 -154,0.0,0.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.52,615.0,11.7,99.7,5.6,70000.0,2.82,3.0,66.0,50.0,120.0,318.0,6.4,0.64,5.0,1.9,1.0,,,,0.0,1,2,4,Category 2,Category 3,Category 3,,,0.7651908645557847,-0.7651908645557847,0.38865279862984703,0.254880782940586,0.2838284470235203,0.2838284470235203,42,,43.0 -155,1.0,1.0,0.0,0.0,0.0,0.0,1,,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,1.0,75.0,25.0,3.0,2.0,3.0,1.63,1671.0,12.8,101.6,4.4,172000.0,3.44,5.8,38.0,95.0,92.0,139.0,7.6,0.9,3.0,9.0,2.9,111.0,94.0,1600.0,1.0,2,3,4,Category 2,Category 2,Category 3,,,0.9256748308807118,-0.9256748308807118,0.16368380146530148,-0.34275235879266847,0.8245348080870322,0.8245348080870322,42,,43.0 -156,1.0,1.0,0.0,0.0,1.0,1.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,,0.0,1.0,1.0,1.0,1.24,975.0,15.3,103.0,11.5,124000.0,3.5,1.2,62.0,85.0,561.0,266.0,7.5,0.77,1.0,2.3,0.6,180.0,70.0,1176.0,1.0,2,2,2,Category 1,Category 1,Category 3,,,0.43817234641198766,-0.43817234641198766,0.2737913075141065,0.5298235931294552,0.07424087298838644,0.07424087298838644,42,,43.0 -157,,1.0,0.0,0.0,0.0,0.0,1,,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,20.0,0.0,1.0,2.0,1.41,1.7,14.7,97.2,6900.0,72000.0,3.5,1.3,31.0,24.0,67.0,97.0,7.3,0.76,1.0,3.5,0.3,,,,0.0,1,1,3,Category 1,Category 2,Category 4,0.6513672109882461,,0.9013756495884443,-0.9013756495884443,0.928317532848577,1.5471425043018256,0.22635149434148594,0.22635149434148594,42,,43.0 -158,,0.0,0.0,0.0,0.0,0.0,1,,,1.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,0.0,,3.0,1.0,1.0,1.16,1713.0,8.2,94.2,6.0,209000.0,3.6,0.3,62.0,59.0,450.0,263.0,6.8,1.49,1.0,7.5,,,,,0.0,2,1,4,Category 1,Category 1,Category 1,,,0.8778911590413275,-0.8778911590413275,0.6759822755863554,0.49465502791424365,0.7302461470901459,0.7302461470901459,42,,43.0 -159,1.0,1.0,1.0,0.0,1.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,1.0,1.0,100.0,0.0,3.0,3.0,3.0,1.52,4.9,7.9,111.2,4.1,67000.0,2.43,1.9,40.0,71.0,69.0,73.0,4.8,0.77,5.0,3.2,0.7,40.0,18.0,283.0,1.0,2,2,1,Category 1,Category 2,Category 3,0.374435369720422,,0.3171957167653986,-0.3171957167653986,0.49604783867988655,0.8581371249858669,0.5988082963834914,0.5988082963834914,42,,43.0 -160,0.0,1.0,,,,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,0.0,1.0,1.0,0.84,,15.4,109.2,9.3,184000.0,4.6,0.5,35.0,40.0,449.0,109.0,7.6,0.7,5.0,3.0,,,,,0.0,2,3,1,Category 1,Category 2,Category 1,,,0.868900625540571,-0.868900625540571,0.012714889986893518,-0.28898458561437346,0.06449127124916754,0.06449127124916754,42,,43.0 -161,1.0,0.0,,,,,1,0.0,0.0,0.0,0.0,0.0,1.0,0.0,,0.0,1.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,2.0,1.0,1.0,1.33,4887.0,12.1,88.9,2.5,141.0,3.0,3.6,50.0,91.0,147.0,280.0,6.7,0.7,1.0,2.2,2.3,,,,1.0,2,1,1,Category 2,Category 3,Category 4,0.07732106548878726,,0.3756722518817265,-0.3756722518817265,0.9924154004894702,0.7613316222887121,0.8772394571622004,0.8772394571622004,42,,43.0 -162,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,1.0,0.0,1.0,1.0,0.0,,,,,0.0,0.0,1.0,,48.0,0.0,1.0,1.0,1.13,75.0,13.3,90.0,8.0,385000.0,4.3,0.6,53.0,52.0,164.0,181.0,7.5,1.46,5.0,18.6,,,,,0.0,2,1,3,Category 2,Category 1,Category 2,,,0.2968692745602808,-0.2968692745602808,0.6714549348946433,0.24907487627057828,0.8772617628261795,0.8772617628261795,42,,43.0 -163,0.0,1.0,1.0,0.0,1.0,1.0,1,1.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,,,,1.0,1.0,1.0,,,2.0,1.0,1.0,2.14,94964.0,15.6,117.3,5200.0,118000.0,4.8,1.1,50.0,60.0,320.0,170.0,8.4,0.74,5.0,18.0,,,,,1.0,1,1,3,Category 2,Category 1,Category 3,0.8404396319804229,,0.6490746587943931,-0.6490746587943931,0.31692247734494494,-0.6445809036896053,0.33040800387577385,0.33040800387577385,42,,43.0 -164,1.0,1.0,0.0,0.0,0.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,1.0,1.0,50.0,,0.0,1.0,1.0,1.79,44340.0,12.7,95.8,14.4,412000.0,2.2,28.5,78.0,127.0,444.0,462.0,6.6,3.95,5.0,8.5,19.8,,,,1.0,2,2,1,Category 2,Category 3,Category 1,,,0.32838122788508106,-0.32838122788508106,0.8792686599978382,0.775417275961631,0.3404058433495647,0.3404058433495647,42,,43.0 -no_class_0,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,1.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,1.0,70.0,,2.0,1.0,2.0,1.55,5.7,13.9,99.7,5200.0,124000.0,2.1,0.8,37.0,75.0,203.0,110.0,5.0,0.56,3.0,2.4,,92.0,56.0,489.0,,1,2,4,Category 1,Category 3,Category 1,,0.8681608040515469,0.6302087483291442,-0.6302087483291442,0.2584316202918181,0.2885792725937171,0.9890283583501739,0.9890283583501739,42,,43.0 -no_class_1,1.0,1.0,0.0,0.0,1.0,0.0,1,0.0,0.0,1.0,0.0,,1.0,1.0,0.0,0.0,,0.0,1.0,0.0,0.0,1.0,70.0,0.0,3.0,1.0,1.0,1.01,226.0,11.5,95.6,6.3,108.0,4.2,1.0,27.0,31.0,667.0,222.0,6.2,3.13,1.0,8.8,0.2,,,,,1,3,3,Category 1,Category 3,Category 3,,0.24528553225533456,0.6098318054986945,-0.6098318054986945,0.5440165791827516,0.9542129594108072,0.6261761715931382,0.6261761715931382,42,,43.0 -miss_0_0.7,0.0,1.0,,,,,1,,,1.0,,,,,,,,1.0,,0.0,0.0,1.0,,,,,,,,,,,,,10.5,,,165.0,,7.3,,4.0,,,197.0,,,0.0,2,3,1,Category 1,Category 3,Category 2,0.16552051036728976,,0.5634389273484588,-0.5634389273484588,0.6360707637298251,0.9191871832780423,0.5313165205680591,0.5313165205680591,42,,43.0 -miss_1_0.8,,,,,,,1,,,,,,0.0,,,0.0,,,1.0,,,,,,,,2.0,,,,,,,3.89,0.9,,,,,,,,5.8,,,,,0.0,1,3,1,Category 2,Category 1,Category 2,,,0.3804197042327977,-0.3804197042327977,0.22106337145372845,0.5515714280078797,0.8381521835519244,0.8381521835519244,42,,43.0 diff --git a/data/DemoFeatureTypes/hcc_cat_feat.csv b/data/DemoFeatureTypes/hcc_cat_feat.csv deleted file mode 100644 index 4b8ea6f4..00000000 --- a/data/DemoFeatureTypes/hcc_cat_feat.csv +++ /dev/null @@ -1 +0,0 @@ -Gender,Symptoms ,Alcohol,Hepatitis B Surface Antigen,Hepatitis B e Antigen,Hepatitis B Core Antibody,Hepatitis C Virus Antibody,Cirrhosis,Endemic Countries,Smoking,Diabetes,Obesity,Hemochromatosis,Arterial Hypertension,Chronic Renal Insufficiency,Human Immunodeficiency Virus,Nonalcoholic Steatohepatitis,Esophageal Varices,Splenomegaly,Portal Hypertension,Portal Vein Thrombosis,Liver Metastasis,Radiological Hallmark,Sim_Cat_2,Sim_Cat_3,Sim_Cat_4,Sim_Text_Cat_2,Sim_Text_Cat_3,Sim_Text_Cat_4,Invariant_Val,Invariant_NA,Invariant_Val_NA diff --git a/data/DemoFeatureTypes/hcc_quant_feat.csv b/data/DemoFeatureTypes/hcc_quant_feat.csv deleted file mode 100644 index 758d9785..00000000 --- a/data/DemoFeatureTypes/hcc_quant_feat.csv +++ /dev/null @@ -1 +0,0 @@ -Age at diagnosis,Grams of Alcohol per day,Packs of cigarets per year,Performance Status*,Encephalopathy degree*,Ascites degree*,International Normalised Ratio*,Alpha-Fetoprotein (ng/mL),Haemoglobin (g/dL),Mean Corpuscular Volume,Leukocytes(G/L),Platelets,Albumin (mg/dL),Total Bilirubin(mg/dL),Alanine transaminase (U/L),Aspartate transaminase (U/L),Gamma glutamyl transferase (U/L),Alkaline phosphatase (U/L),Total Proteins (g/dL),Creatinine (mg/dL),Number of Nodules,Major dimension of nodule (cm),Direct Bilirubin (mg/dL),Iron,Oxygen Saturation (%),Ferritin (ng/mL),Sim_Miss_0.6,Sim_Miss_0.7,Sim_Cor_-1.0_A,Sim_Cor_-1.0_B,Sim_Cor_0.9_A,Sim_Cor_0.9_B,Sim_Cor_1.0_A,Sim_Cor_1.0_B diff --git a/data/DemoRepData/hcc_data_custom_rep.csv b/data/DemoRepData/hcc_data_custom_rep.csv deleted file mode 100644 index cb016fb4..00000000 --- a/data/DemoRepData/hcc_data_custom_rep.csv +++ /dev/null @@ -1,174 +0,0 @@ -InstanceID,Symptoms ,Alcohol,Hepatitis B Surface Antigen,Hepatitis B e Antigen,Hepatitis B Core Antibody,Hepatitis C Virus Antibody,Cirrhosis,Endemic Countries,Smoking,Diabetes,Obesity,Hemochromatosis,Arterial Hypertension,Chronic Renal Insufficiency,Human Immunodeficiency Virus,Nonalcoholic Steatohepatitis,Esophageal Varices,Splenomegaly,Portal Hypertension,Portal Vein Thrombosis,Liver Metastasis,Radiological Hallmark,Grams of Alcohol per day,Packs of cigarets per year,Performance Status*,Encephalopathy degree*,Ascites degree*,International Normalised Ratio*,Alpha-Fetoprotein (ng/mL),Haemoglobin (g/dL),Mean Corpuscular Volume,Leukocytes(G/L),Platelets,Albumin (mg/dL),Total Bilirubin(mg/dL),Alanine transaminase (U/L),Aspartate transaminase (U/L),Gamma glutamyl transferase (U/L),Alkaline phosphatase (U/L),Total Proteins (g/dL),Creatinine (mg/dL),Number of Nodules,Major dimension of nodule (cm),Direct Bilirubin (mg/dL),Iron,Oxygen Saturation (%),Ferritin (ng/mL),Class,Sim_Cat_2,Sim_Cat_3,Sim_Cat_4,Sim_Text_Cat_2,Sim_Text_Cat_3,Sim_Text_Cat_4,Sim_Miss_0.6,Sim_Miss_0.7,Sim_Cor_-1.0_A,Sim_Cor_-1.0_B,Sim_Cor_0.9_A,Sim_Cor_0.9_B,Sim_Cor_1.0_A,Sim_Cor_1.0_B,Invariant_Val,Invariant_NA,Invariant_Val_NA -0,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,137.0,15.0,0.0,1.0,1.0,1.53,95.0,13.7,106.6,4.9,99.0,3.4,2.1,34.0,41.0,183.0,150.0,7.1,0.7,1.0,3.5,0.5,,,,0.0,1,1,4,Category 2,Category 2,Category 1,,,0.5932786483101787,-0.5932786483101787,0.898261627292706,0.9399532587410278,0.0179456785684918,0.0179456785684918,42,,43.0 -1,,0.0,0.0,0.0,0.0,1.0,1,,,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,0.0,,0.0,1.0,1.0,,,,,,,,,,,,,,,1.0,1.8,,,,,0.0,2,3,2,Category 2,Category 3,Category 2,0.2332164115498012,0.3443837320442332,0.6502941858734539,-0.6502941858734539,0.8293324051412837,0.1825500260597307,0.1262537827926134,0.1262537827926134,41,,43.0 -2_random,,1.0,0.0,0.0,0.0,1.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0,0.0,2.0,3.0,1.26,66.0,11.2,96.7,4.4,161.0,3.4,3.5,30.0,29.0,115.0,161.0,7.8,0.8,5.0,3.5,1.7,,25.0,,1.0,2,3,2,Category 2,Category 3,Category 2,,,0.5322449888262991,-0.1616725441468026,0.110807962179807,0.775417275961631,0.8394609095007669,0.7380691233385172,42,41.0,43.0 -3,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,40.0,30.0,0.0,1.0,1.0,0.95,2440.0,13.4,97.1,9.0,279.0,3.7,0.4,16.0,64.0,94.0,174.0,8.1,1.11,2.0,15.7,0.2,,,,1.0,1,1,4,Category 2,Category 2,Category 3,0.4739699414305561,0.4127935506067522,0.6157420219422428,-0.6157420219422428,0.9527975276012944,0.7934424911991063,0.1616198112858714,0.1616198112858714,42,,41.0 -4,1.0,1.0,1.0,0.0,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,100.0,30.0,0.0,1.0,1.0,0.94,49.0,14.3,95.1,6.4,199.0,4.1,0.7,147.0,306.0,173.0,109.0,6.9,1.8,1.0,9.0,,59.0,15.0,22.0,0.0,1,2,3,Category 1,Category 2,Category 3,,,0.3290174378146622,-0.3290174378146622,0.8252007674155681,0.5838130941185526,0.2554933446556047,0.2554933446556047,42,,43.0 -5,0.0,1.0,0.0,,0.0,0.0,1,0.0,,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,,1.0,1.0,2.0,1.58,110.0,13.4,91.5,5.4,85.0,3.4,3.5,91.0,122.0,242.0,396.0,5.6,0.9,1.0,10.0,1.4,53.0,22.0,111.0,1.0,1,2,3,Category 1,Category 3,Category 3,0.648822840291576,0.5982860582681546,0.470182592696665,-0.470182592696665,0.6663068858350397,0.2385576484099146,0.9466379541996072,0.9466379541996072,42,,43.0 -6,0.0,0.0,0.0,,1.0,1.0,1,0.0,0.0,1.0,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.4,138.9,10.4,102.0,3.2,42000.0,2.35,2.72,119.0,183.0,143.0,211.0,7.3,0.8,5.0,2.6,2.19,171.0,126.0,1452.0,1.0,1,2,2,Category 2,Category 3,Category 2,,,0.7442790655949556,-0.7442790655949556,0.1217619111252747,0.5059578444366252,0.5601822583749119,0.5601822583749119,42,,43.0 -7,1.0,1.0,0.0,,0.0,0.0,1,0.0,1.0,1.0,,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,,20.0,3.0,1.0,1.0,1.46,9860.0,10.8,92.0,3.0,58.0,3.1,3.2,79.0,108.0,184.0,300.0,7.1,0.52,2.0,9.0,1.3,42.0,25.0,706.0,1.0,2,3,3,Category 1,Category 2,Category 4,0.5841994847141693,,0.8718327789731212,-0.8718327789731212,0.4782340230480723,1.1844526933309516,0.7507295069993472,0.7507295069993472,42,,43.0 -8,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,100.0,32.0,1.0,1.0,2.0,3.14,8.8,11.9,107.5,4.9,70.0,1.9,3.3,26.0,59.0,115.0,63.0,6.1,0.59,1.0,6.4,1.2,85.0,73.0,982.0,0.0,1,3,1,Category 2,Category 3,Category 4,,,0.4336553339563889,-0.4336553339563889,0.5061075548467509,0.5863475294037935,0.5579807387826399,0.5579807387826399,42,,43.0 -9_random,0.0,0.0,0.0,0.0,0.0,1.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,,,0.0,0.0,0.0,0.0,1.0,70.0,0.0,0.0,1.0,1.0,1.24,5.7,15.4,96.7,5.7,188000.0,2.9,2.2,119.0,,449.0,204.0,6.7,0.48,1.0,2.4,2.3,,,,0.0,1,3,1,Category 1,Category 1,Category 3,0.2560155318536622,,0.6098318054986945,-0.6882078658665954,0.2793677139347164,0.2700501054857166,0.5591848068293265,0.3403800926666749,42,,43.0 -10,0.0,1.0,0.0,0.0,0.0,1.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,,,0.0,1.0,2.0,1.05,100809.0,13.0,94.2,5.7,196.0,4.4,3.0,90.0,334.0,494.0,236.0,7.6,0.8,5.0,,1.1,,,,1.0,1,1,3,Category 1,Category 1,Category 2,0.5865354346607591,0.9676993882070865,0.1616725441468026,-0.1616725441468026,0.0799653943593019,-0.2254521712397555,0.0941519101256979,0.0941519101256979,42,,43.0 -11,0.0,1.0,0.0,0.0,0.0,1.0,1,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,,0.0,1.0,0.0,0.0,1.0,,0.0,0.0,1.0,1.0,1.33,86.0,15.7,96.7,4.0,61.0,3.7,1.3,132.0,168.0,113.0,154.0,,7.6,5.0,1.9,0.3,144.0,41.0,277.0,0.0,2,3,2,Category 1,Category 2,Category 2,,,0.0208611392915381,-0.0208611392915381,0.7767236304716927,0.1776845714074021,0.343663192609103,0.343663192609103,42,, -12_random,0.0,,0.0,,,0.0,1,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,0.0,,1.0,1.0,1.0,1.2,226.0,16.4,102.9,4.9,94000.0,3.4,2.6,35.0,41.0,470.0,466.0,6.2,,5.0,18.0,0.5,93.0,,277.0,1.0,1,3,1,Category 2,Category 3,Category 4,,,0.9485833548514336,-0.7353502986657526,0.52550462196864,-0.3427523587926684,0.8437373264067243,0.1129432084111735,42,, -13,,0.0,0.0,0.0,0.0,1.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,,0.0,1.0,1.0,1.2,6.6,13.7,93.8,4.1,91000.0,4.5,1.0,103.0,96.0,205.0,70.0,8.8,0.88,1.0,22.0,,82.0,24.0,,0.0,1,1,2,Category 1,Category 2,Category 2,,,0.3323146253551089,-0.3323146253551089,0.5942907505617747,0.1104140443298413,0.3907283656136132,0.3907283656136132,42,,43.0 -14,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,1.0,0.0,0.0,1.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,1.0,,,2.0,2.0,2.0,1.25,29.0,13.5,93.0,6.0,128.0,3.15,10.5,76.0,116.0,165.0,163.0,7.3,1.07,4.0,4.5,4.5,197.0,84.0,302.0,0.0,2,3,2,Category 1,Category 1,Category 2,,0.8074302518167612,0.5424786357193675,-0.5424786357193675,0.9364491738836606,0.0701414149327613,0.7983441882243283,0.7983441882243283,42,,43.0 -15_random,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,,,0.0,0.0,0.0,0.0,137.0,0.0,0.0,1.0,3.0,1.29,2159.0,14.4,94.2,5.0,91000.0,4.0,0.7,43.0,75.0,173.0,207.0,6.4,,5.0,4.6,0.7,,9.0,,1.0,1,1,2,Category 1,Category 2,Category 1,,0.2452855322553345,0.6400029668369137,-0.9607805514869768,0.3235003949114737,0.6006269632424499,0.5671707799193856,0.276441690583396,42,,43.0 -16_random,1.0,0.0,0.0,0.0,1.0,0.0,1,,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,,1.0,0.0,0.0,2.0,1.0,1.0,1.25,249.0,14.3,96.5,6690.0,222000.0,3.4,2.1,119.0,33.0,229.0,209.0,6.3,0.7,5.0,2.0,,13.0,,,0.0,2,2,4,Category 1,Category 1,Category 3,,,0.4371653888168265,-0.1435423620393928,0.1053675339528059,-0.080910968956611,0.866386514251342,0.979782457854522,42,,43.0 -17,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,,0.0,0.0,0.0,,1.0,1.0,1.0,1.0,1.0,1.0,100.0,60.0,2.0,1.0,1.0,1.05,9.2,10.3,103.7,5.4,159.0,3.8,0.5,56.0,91.0,459.0,146.0,5.4,1.23,5.0,13.5,3.8,187.0,58.0,443.0,0.0,1,2,1,Category 2,Category 3,Category 3,,0.6905602324456406,0.4032613611238318,-0.4032613611238318,0.8514486375512653,0.3919446317864377,0.3973813904853165,0.3973813904853165,42,,43.0 -18_random,1.0,1.0,,,0.0,0.0,1,0.0,1.0,0.0,0.0,,0.0,1.0,0.0,,1.0,1.0,0.0,0.0,0.0,1.0,200.0,0.0,1.0,1.0,1.0,1.45,86.0,11.3,90.1,,172000.0,4.1,2.1,42.0,30.0,33.0,120.0,8.4,0.2,5.0,7.5,0.5,180.0,,,1.0,2,3,4,Category 2,Category 1,Category 2,0.2560155318536622,,0.6006095425462361,-0.9398197919268416,0.3864608411591471,1.2572150690343238,0.3196668324405447,0.3907283656136132,42,,43.0 -19_random,,1.0,0.0,0.0,1.0,0.0,1,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,100.0,,0.0,1.0,2.0,1.2,7.6,10.3,105.0,9.3,128.0,3.2,1.1,113.0,63.0,70.0,117.0,6.7,0.79,2.0,5.0,0.7,37.0,30.0,48.0,0.0,2,3,1,Category 2,Category 2,Category 4,,0.046945357147813,0.6055381576448828,-0.3838471518677963,0.1492377779501761,0.2385576484099146,0.3123491018855135,0.2097529476836813,42,,43.0 -20,0.0,1.0,0.0,0.0,0.0,0.0,1,,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,200.0,60.0,0.0,1.0,1.0,1.29,19.6,11.7,101.0,2600.0,109000.0,3.6,1.7,13.0,35.0,23.0,141.0,7.3,0.68,1.0,2.5,0.7,152.6,,76.9,0.0,1,3,2,Category 2,Category 1,Category 4,0.0075343631340747,,0.2035782803422426,-0.2035782803422426,0.602553163842865,0.6316669084217452,0.195609273044515,0.195609273044515,42,,43.0 -21,0.0,1.0,0.0,0.0,1.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,0.0,0.0,80.0,47.0,0.0,1.0,1.0,1.06,3.9,16.4,90.7,7.8,187.0,4.5,1.0,54.0,47.0,52.0,97.0,6.3,0.75,1.0,6.8,0.2,87.0,26.0,84.0,0.0,2,3,3,Category 2,Category 2,Category 1,,,0.8404524062769335,-0.8404524062769335,0.3647982191445295,-0.1917656554059648,0.1867232957730414,0.1867232957730414,42,,43.0 -22_random,1.0,0.0,1.0,0.0,0.0,1.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,0.0,1.0,0.0,1.0,75.0,,1.0,1.0,3.0,0.96,42.0,14.0,103.7,5.001,88000.0,4.1,0.9,117.0,192.0,72.0,97.0,5.8,0.2,3.0,2.0,,,,,0.0,2,2,2,Category 2,Category 1,Category 1,,0.336370463828422,0.0436616577073611,-0.6616323503711468,0.602553163842865,1.1049664369274788,0.7251855480273908,0.9917426171678388,42,,43.0 -23,1.0,1.0,0.0,0.0,0.0,0.0,1,1.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,1.0,200.0,60.0,1.0,1.0,1.0,4.82,185.0,10.7,88.1,5.0,194000.0,3.6,3.8,217.0,86.0,879.0,396.0,7.0,0.53,5.0,15.0,1.6,,,,1.0,1,1,3,Category 2,Category 3,Category 1,0.4878098008087379,,0.9607805514869768,-0.9607805514869768,0.5644410906788825,1.0863397995410788,0.3566709741417647,0.3566709741417647,42,,43.0 -24_random,1.0,0.0,1.0,0.0,0.0,,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,200.0,,0.0,1.0,3.0,1.2,16.0,,102.4,,57000.0,4.3,0.8,134.0,50.0,89.0,166.0,8.4,0.7,1.0,6.0,0.3,,,423.0,1.0,1,2,3,Category 1,Category 2,Category 4,0.5774862709061257,,0.0904816952870507,-0.7651908645557847,0.2737913075141065,0.522666373800494,0.7397303320855406,0.1129432084111735,42,,43.0 -25,0.0,1.0,0.0,,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,100.0,0.0,2.0,1.0,1.0,1.33,13327.0,13.7,94.3,5.2,110.0,3.1,1.6,52.0,107.0,465.0,233.0,8.4,0.79,5.0,,0.7,93.0,31.0,79.0,0.0,2,2,1,Category 1,Category 1,Category 3,,,0.8462452920190493,-0.8462452920190493,0.2117553506654783,0.4255820510981696,0.276441690583396,0.276441690583396,42,,43.0 -26_random,0.0,0.0,0.0,0.0,1.0,1.0,1,0.0,,1.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,,0.0,0.0,3.0,2.0,1.33,2.5,10.8,93.9,15.4,412000.0,3.4,2.3,111.0,29.0,795.0,106.0,78.0,0.9,5.0,1.9,0.3,171.0,,307.0,0.0,2,3,2,Category 1,Category 3,Category 1,,,0.5771852367117482,-0.868900625540571,0.4242968858848881,0.9891192049215988,0.6261761715931382,0.1616198112858714,42,,43.0 -27,,1.0,1.0,0.0,1.0,0.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,,0.0,1.0,1.0,1.37,5.9,15.5,88.2,4.9,113.0,4.5,3.2,36.0,65.0,34.0,111.0,,,2.0,4.0,1.0,180.0,56.0,,0.0,2,3,4,Category 2,Category 2,Category 2,0.0556534893569753,0.9033638126360248,0.7353502986657526,-0.7353502986657526,0.754253544343863,0.3059194344616313,0.6426746576724236,0.6426746576724236,42,,43.0 -28,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,60.0,67.5,1.0,1.0,1.0,1.3,3255.0,12.2,89.5,4.4,108.0,3.0,1.1,59.0,85.0,419.0,293.0,7.7,0.67,2.0,6.5,0.4,94.0,27.0,70.0,1.0,1,1,1,Category 2,Category 1,Category 3,0.8423140352981816,0.6466649191171634,0.7677238880667803,-0.7677238880667803,0.6194977514075877,0.28692781922349,0.1958408125869188,0.1958408125869188,42,,43.0 -29_random,1.0,,0.0,,1.0,0.0,1,1.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,,0.0,0.0,1.0,70.0,,0.0,1.0,1.0,1.79,19.6,12.7,97.3,4800.0,88000.0,2.7,7.8,31.0,73.0,126.0,209.0,,0.88,1.0,3.8,5.5,92.0,,767.0,0.0,1,2,4,Category 1,Category 1,Category 3,0.5774862709061257,,0.8664386675276454,-0.1457565682447517,0.5061075548467509,0.3059194344616313,0.412761129266026,0.4853589831598871,42,,43.0 -30_random,0.0,1.0,0.0,0.0,1.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,0.0,1.0,1.0,0.0,,3.0,1.0,1.0,1.07,9860.0,14.7,102.0,8190.0,137000.0,3.4,0.5,106.0,52.0,646.0,70.0,7.5,0.9,2.0,,1.3,46.0,10.0,48.0,0.0,1,2,3,Category 1,Category 1,Category 4,,0.5558065814371796,0.0516968372415269,-0.4463686465125855,0.6517106479109683,-0.3068727023502736,0.8742267241383516,0.9677558771033888,42,,43.0 -31_random,1.0,0.0,,0.0,0.0,0.0,1,0.0,0.0,1.0,,0.0,1.0,0.0,0.0,0.0,,1.0,0.0,0.0,0.0,1.0,70.0,47.0,0.0,2.0,2.0,1.66,2.8,14.0,93.8,4.0,142000.0,3.7,1.0,134.0,29.0,503.0,117.0,7.5,2.19,5.0,1.5,0.3,,27.0,,0.0,2,3,4,Category 2,Category 1,Category 2,,,0.4381723464119876,-0.6061887135611715,0.7811704237869193,-0.2052232392504095,0.7392947351647732,0.2543219811783167,42,,43.0 -32,1.0,1.0,,,,0.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,100.0,,0.0,1.0,1.0,1.32,7.7,15.7,96.1,9.1,268000.0,3.4,0.6,20.0,29.0,49.0,135.0,8.2,0.9,2.0,,,,,,0.0,1,3,1,Category 1,Category 1,Category 1,,0.0441654377101001,0.5880583780900792,-0.5880583780900792,0.0746298143370817,-0.3068727023502736,0.5578201919292014,0.5578201919292014,42,,43.0 -33,1.0,1.0,0.0,,0.0,0.0,1,,,0.0,0.0,0.0,1.0,0.0,0.0,,0.0,0.0,0.0,0.0,0.0,1.0,,,0.0,1.0,1.0,1.24,266.0,13.7,97.7,13000.0,170000.0,4.2,0.5,68.0,85.0,232.0,227.0,16.8,1.72,1.0,5.9,,,,,0.0,1,2,3,Category 1,Category 1,Category 1,,,0.0293944457565072,-0.0293944457565072,0.7826960407441492,0.8932193007727535,0.1660343134161954,0.1660343134161954,42,,43.0 -34,1.0,1.0,1.0,0.0,1.0,0.0,1,,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,,0.0,0.0,1.0,1.0,1.28,5689.0,14.3,99.6,6.8,77.0,3.8,1.7,154.0,102.0,184.0,184.0,6.9,0.89,2.0,3.0,0.77,,,,0.0,2,2,4,Category 2,Category 3,Category 4,,,0.3955151698490152,-0.3955151698490152,0.2653874091881946,0.7562692007201774,0.6134731386391763,0.6134731386391763,42,,43.0 -35,,0.0,1.0,,1.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,1.0,0.96,14.2,14.8,98.5,4.95,187.0,4.2,0.77,43.0,86.0,89.0,113.0,6.7,0.95,3.0,8.8,0.37,,,,0.0,1,3,2,Category 2,Category 1,Category 2,0.9173956130855316,0.5558065814371796,0.6061887135611715,-0.6061887135611715,0.1777663878512482,-0.2702692195035484,0.3631007366340104,0.3631007366340104,42,,43.0 -36_random,1.0,1.0,0.0,0.0,0.0,,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,100.0,15.0,0.0,1.0,1.0,1.79,3.7,11.1,92.0,,318000.0,4.1,2.2,123.0,63.0,196.0,,,0.67,1.0,6.0,0.6,,,120.0,0.0,1,1,4,Category 2,Category 1,Category 3,0.2560155318536622,0.3443837320442332,0.0904816952870507,-0.6098318054986945,0.5146575865735116,0.8435880694183653,0.2263514943414859,0.0333836017863812,42,, -37,1.0,1.0,0.0,0.0,0.0,0.0,1,,1.0,1.0,0.0,,1.0,0.0,0.0,,,0.0,1.0,0.0,0.0,1.0,200.0,30.0,1.0,1.0,2.0,1.24,633.0,13.0,96.5,7200.0,143000.0,2.3,1.1,40.0,58.0,322.0,209.0,6.7,1.4,5.0,4.9,0.2,57.0,25.0,134.0,1.0,1,2,4,Category 1,Category 1,Category 1,0.9750671629451424,,0.7929560946056315,-0.7929560946056315,0.618051674287186,1.270644250942094,0.1688542066776861,0.1688542066776861,42,,43.0 -38,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,100.0,0.0,0.0,1.0,1.0,1.09,5.4,14.9,105.0,7.2,230000.0,4.2,1.3,18.0,26.0,174.0,92.0,7.3,0.8,2.0,6.0,0.3,,,,0.0,2,1,4,Category 1,Category 3,Category 2,0.4907487792587844,0.1205225787864644,0.6550093388321085,-0.6550093388321085,0.6331896260134641,1.7141192706601085,0.507051103865441,0.507051103865441,42,,43.0 -39,1.0,1.0,1.0,0.0,1.0,1.0,1,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,,0.0,,0.0,1.0,1.0,200.0,0.0,0.0,1.0,1.0,1.42,479.0,11.3,82.2,9500.0,160000.0,3.1,1.4,113.0,143.0,924.0,288.0,7.9,0.98,5.0,17.0,0.6,,,,0.0,1,1,2,Category 1,Category 1,Category 1,,,0.9921333163406724,-0.9921333163406724,0.2288946048466136,0.3066666974881599,0.598112629369018,0.598112629369018,42,,43.0 -40,,0.0,0.0,0.0,1.0,1.0,1,0.0,0.0,0.0,0.0,,1.0,0.0,0.0,0.0,,,,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.18,19.0,13.9,88.3,6.86,201000.0,4.4,0.8,142.0,117.0,123.0,104.0,8.5,0.74,2.0,3.3,0.3,143.0,50.18,120.0,0.0,1,2,3,Category 2,Category 3,Category 4,,,0.283854528608645,-0.283854528608645,0.232645538562681,0.3124361118651462,0.0333836017863812,0.0333836017863812,42,,43.0 -41,0.0,0.0,0.0,0.0,1.0,0.0,1,0.0,0.0,1.0,1.0,0.0,1.0,0.0,0.0,0.0,,0.0,0.0,,,0.0,0.0,0.0,0.0,1.0,1.0,1.21,2.8,15.7,92.7,15.4,188000.0,4.1,0.7,299.0,553.0,196.0,68.0,6.5,1.3,1.0,5.0,0.3,,,,0.0,2,1,3,Category 2,Category 3,Category 4,0.7184572708365536,,0.3591510296662314,-0.3591510296662314,0.2208026297856391,0.5592008637108292,0.3636931247561402,0.3636931247561402,42,,43.0 -42_random,1.0,0.0,0.0,0.0,1.0,0.0,1,0.0,,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,0.0,200.0,52.5,1.0,1.0,3.0,1.17,42.0,14.0,83.0,6.1,97000.0,4.0,0.8,16.0,35.0,795.0,106.0,7.2,0.9,1.0,3.5,29.3,91.0,11.0,642.0,1.0,1,3,2,Category 2,Category 3,Category 4,,,0.3592507479162455,-0.9730977480703464,0.550091940458156,0.768020724874327,0.6134731386391763,0.9677558771033888,42,,43.0 -43,0.0,1.0,,,,,1,0.0,,0.0,1.0,0.0,0.0,0.0,,1.0,1.0,1.0,1.0,0.0,0.0,1.0,75.0,,0.0,1.0,1.0,1.17,5.0,15.1,104.1,4.3,65000.0,3.8,2.5,61.0,56.0,239.0,56.0,7.3,0.7,1.0,2.0,0.2,,,,0.0,1,1,4,Category 1,Category 2,Category 1,,0.7953418379590974,0.4658128070202485,-0.4658128070202485,0.6557236725616563,1.0811232373487876,0.8203775074489733,0.8203775074489733,42,,43.0 -44,0.0,0.0,0.0,0.0,1.0,1.0,1,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.71,237.0,15.6,98.1,4.3,88.0,3.2,2.2,30.0,52.0,72.0,97.0,6.7,0.86,5.0,2.2,0.5,,,,0.0,1,1,4,Category 2,Category 3,Category 2,0.8385825587026248,,0.8359980637812094,-0.8359980637812094,0.8480158852494014,1.1049664369274788,0.3131619948172823,0.3131619948172823,42,, -45_random,1.0,0.0,0.0,0.0,1.0,0.0,1,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,,1.0,0.0,,0.0,1.0,100.0,,0.0,1.0,1.0,1.41,12.0,12.4,96.7,4.1,97000.0,4.3,1.1,113.0,306.0,272.0,94.0,6.3,0.8,5.0,,0.5,87.0,30.0,220.0,1.0,1,3,3,Category 1,Category 2,Category 1,0.4739699414305561,0.5724277594334657,0.6055381576448828,-0.1435423620393928,0.3548413602568904,0.7798514361291058,0.1616198112858714,0.3907283656136132,42,,43.0 -46,1.0,0.0,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,,0.0,0.0,0.0,1.0,1.0,,,,,,,,,,,,,,,,,,,,,0.0,1,3,1,Category 1,Category 1,Category 1,,,0.7760002070354295,-0.7760002070354295,0.7920936337605432,1.2455404663466032,0.9677558771033888,0.9677558771033888,42,,43.0 -47,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,0.0,,,1.0,1.0,2.0,1.64,16.0,14.0,102.9,11.5,277000.0,3.1,6.8,140.0,244.0,795.0,595.0,7.2,0.79,1.0,2.3,4.1,63.0,34.0,888.0,1.0,2,1,2,Category 1,Category 2,Category 2,0.7109524788367483,,0.4053101830857434,-0.4053101830857434,0.4047984290851998,-0.1026302719592385,0.8568739360750941,0.8568739360750941,42,,43.0 -48,1.0,0.0,0.0,0.0,0.0,0.0,0,0.0,1.0,1.0,0.0,0.0,1.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,80.0,0.0,1.0,1.0,1.33,163.0,10.6,96.2,9900.0,280000.0,3.3,1.0,28.0,57.0,236.0,171.0,7.5,1.38,1.0,19.0,,45.0,21.0,802.0,1.0,2,1,4,Category 1,Category 3,Category 1,,,0.6018553836620085,-0.6018553836620085,0.6540757953719981,0.5912191902717471,0.1176439881593252,0.1176439881593252,42,,43.0 -49,,1.0,0.0,,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,,40.0,0.0,1.0,1.0,1.49,20.0,15.0,96.7,9.0,78.0,4.6,2.1,40.0,49.0,137.0,109.0,7.6,0.8,1.0,2.0,0.4,184.0,59.0,905.0,0.0,2,3,2,Category 2,Category 3,Category 2,,,0.6325405332263061,-0.6325405332263061,0.3542362404447745,1.0004291688779363,0.7397303320855406,0.7397303320855406,42,,43.0 -50,1.0,0.0,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,1.0,1.0,0.0,0.0,2.0,1.0,1.0,0.97,46.0,10.5,78.7,20.9,251.0,2.4,0.3,31.0,185.0,91.0,539.0,5.0,0.38,5.0,20.0,0.3,,,,1.0,1,3,2,Category 2,Category 1,Category 3,,,0.3728486371889344,-0.3728486371889344,0.52550462196864,-0.0720156542104325,0.3196668324405447,0.3196668324405447,42,,43.0 -51_random,1.0,1.0,0.0,,1.0,0.0,0,0.0,,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,1.0,,0.0,1.0,,0.0,0.0,3.0,2.0,1.28,5.8,14.9,96.7,6.0,161.0,2.1,1.0,62.0,178.0,184.0,363.0,6.2,3.95,3.0,6.0,0.5,180.0,27.0,120.0,1.0,2,1,3,Category 2,Category 1,Category 4,0.7718819805982451,0.336370463828422,0.9730977480703464,-0.7760002070354295,0.550091940458156,0.3498666665136339,0.9970781570816616,0.4853589831598871,42,,43.0 -52,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,1.0,1.0,1.33,4.7,11.8,80.2,3.7,99.0,4.1,0.7,50.0,47.0,67.0,62.0,7.4,0.77,1.0,2.3,,104.0,37.0,635.0,0.0,1,2,1,Category 1,Category 2,Category 4,,,0.413031174647697,-0.413031174647697,0.1768871451438544,0.4520062863697803,0.4853589831598871,0.4853589831598871,42,,43.0 -53,,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,0.0,0.0,1.0,1.0,1.65,7.3,15.3,93.7,3500.0,57000.0,,1.4,111.0,93.0,294.0,130.0,,0.76,2.0,2.0,0.3,184.0,2.26,59.0,0.0,2,1,4,Category 1,Category 2,Category 3,,,0.0691327861866194,-0.0691327861866194,0.3870787603356308,0.5200731327007764,0.122433898358941,0.122433898358941,42,,43.0 -54,1.0,1.0,0.0,0.0,0.0,1.0,1,,1.0,0.0,,,0.0,0.0,0.0,,1.0,1.0,1.0,1.0,0.0,1.0,100.0,30.0,3.0,1.0,2.0,1.35,1898.0,12.4,95.1,9.8,216.0,2.7,8.2,164.0,523.0,433.0,397.0,6.7,0.82,1.0,2.1,5.5,56.0,27.0,742.0,1.0,1,3,3,Category 2,Category 3,Category 3,0.506103956359347,,0.4371653888168265,-0.4371653888168265,0.963822275482351,0.4860253154337106,0.7251855480273908,0.7251855480273908,42,,43.0 -55_random,0.0,1.0,0.0,,1.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,120.0,,2.0,1.0,3.0,1.2,3204.0,10.9,102.0,7100.0,280000.0,2.9,10.5,111.0,192.0,184.0,62.0,7.5,0.67,1.0,,1.4,,,278.0,0.0,1,3,1,Category 2,Category 1,Category 2,,,0.6859677359829841,-0.8778911590413275,0.1566384369738083,0.254245107751726,0.8742267241383516,0.8229584462214861,42,,43.0 -56_random,,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,3.0,,123.0,12.6,92.0,2.5,38000.0,3.4,0.6,43.0,71.0,40.0,239.0,6.3,0.56,5.0,2.4,0.5,,,1001.0,1.0,2,1,4,Category 2,Category 2,Category 2,,,0.1457565682447517,-0.3485736672419705,0.110807962179807,0.768020724874327,0.6868609976750291,0.8437373264067243,42,,43.0 -57,,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,1.0,100.0,,0.0,1.0,1.0,1.24,2.6,10.3,83.0,6.1,1.71,3.9,0.8,11.0,28.0,77.0,120.0,7.0,0.58,1.0,4.7,0.85,32.0,10.0,18.0,0.0,1,2,2,Category 2,Category 3,Category 3,,0.5724277594334657,0.5929183998317819,-0.5929183998317819,0.4185806216239353,0.8041060623183116,0.979782457854522,0.979782457854522,42,,43.0 -58,,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,,,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,1.0,70.0,0.0,3.0,2.0,2.0,1.96,12.0,10.9,102.0,4.1,99.0,1.9,4.2,73.0,85.0,470.0,263.0,7.0,0.99,1.0,8.5,1.9,44.0,20.0,176.0,1.0,2,3,3,Category 2,Category 2,Category 3,0.3692304815098961,,0.5794148993435008,-0.5794148993435008,0.7903377358601481,0.59976786431195,0.6561340180205807,0.6561340180205807,42,,43.0 -59,1.0,0.0,,,,,0,0.0,1.0,1.0,0.0,,1.0,1.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,1.0,1.11,,18.7,92.4,6900.0,270000.0,4.0,0.9,35.0,73.0,115.0,103.0,6.8,1.24,1.0,10.0,,,,,1.0,2,2,2,Category 1,Category 2,Category 4,,,0.6626212790083204,-0.6626212790083204,0.5821482297799723,1.3051160574094445,0.1298264489517175,0.1298264489517175,42,,43.0 -60_random,0.0,0.0,1.0,0.0,0.0,,1,0.0,,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,2.0,1.33,2.8,12.6,90.9,6.3,154000.0,3.4,,113.0,76.0,115.0,163.0,7.6,0.68,5.0,17.5,,,10.0,22.0,0.0,1,1,2,Category 1,Category 1,Category 3,,,0.9186777969935044,-0.1800104374727235,0.110807962179807,0.4805833241406625,0.0683409355322604,0.3368405018611032,42,,43.0 -61,1.0,1.0,0.0,0.0,1.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,100.0,40.0,0.0,2.0,2.0,1.46,41.0,14.6,100.8,5.5,42000.0,3.1,3.7,121.0,165.0,101.0,207.0,6.3,0.69,1.0,3.0,1.9,224.0,95.0,363.0,0.0,1,3,2,Category 1,Category 2,Category 3,,,0.6521232455304379,-0.6521232455304379,0.1896948481746772,0.0749427857215988,0.0930304864600272,0.0930304864600272,42,,43.0 -62,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,30.0,2.0,1.0,2.0,1.94,,11.5,97.4,5700.0,77000.0,2.7,4.9,34.0,48.0,46.0,178.0,6.1,0.62,1.0,4.6,2.2,,,,0.0,1,1,1,Category 1,Category 2,Category 2,,,0.3121480566964471,-0.3121480566964471,0.6189481930077215,0.4189539696483982,0.0293641591023923,0.0293641591023923,42,,43.0 -63,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,300.0,,3.0,1.0,3.0,1.57,2.0,12.6,96.6,2.9,76000.0,3.5,2.4,33.0,40.0,110.0,166.0,,0.77,1.0,2.0,0.5,,,,0.0,1,1,2,Category 1,Category 2,Category 4,,,0.3990459461371111,-0.3990459461371111,0.3235003949114737,0.1847061150570181,0.8229584462214861,0.8229584462214861,42,,43.0 -64,0.0,0.0,0.0,0.0,0.0,0.0,0,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,,,,,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.29,7.0,12.1,95.1,3.8,77000.0,3.8,1.4,37.0,38.0,194.0,161.0,6.7,0.71,1.0,10.0,0.5,0.0,0.0,0.0,0.0,1,2,3,Category 1,Category 2,Category 4,,0.8766653778624495,0.8579862539227058,-0.8579862539227058,0.8343033659547675,0.7991788248093662,0.2097529476836813,0.2097529476836813,42,,43.0 -65,1.0,0.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,0.0,0.0,1.0,0.0,0.0,0.0,2.0,1.0,1.0,1.17,3.1,15.1,86.0,8.9,275000.0,2.8,1.3,74.0,50.0,23.0,104.0,5.4,0.6,5.0,7.8,0.2,46.0,18.0,,1.0,1,2,3,Category 1,Category 1,Category 4,,,0.0090304041295502,-0.0090304041295502,0.6292988060107362,1.661501998538744,0.3790271262190974,0.3790271262190974,42,,43.0 -66_random,0.0,0.0,0.0,0.0,1.0,0.0,1,,,0.0,0.0,0.0,1.0,0.0,0.0,0.0,,,0.0,0.0,0.0,1.0,,0.0,1.0,1.0,3.0,,2.3,13.5,97.2,10.9,199.0,3.5,,21.0,91.0,196.0,139.0,5.8,0.78,5.0,8.8,0.7,21.0,,639.0,0.0,1,2,1,Category 1,Category 1,Category 2,,0.5891085344708948,0.2357920939592098,-0.0173797901854796,0.1252335704328271,0.5419314143268217,0.0726708716100162,0.7631552912588894,42,, -67_random,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,2.0,1.0,2.0,1.46,13327.0,16.2,102.1,4800.0,318000.0,3.5,1.4,43.0,50.0,196.0,150.0,7.6,0.67,1.0,6.0,1.9,28.0,47.0,,1.0,2,1,2,Category 2,Category 1,Category 2,0.4739699414305561,0.5152479243147259,0.5846707004425887,-0.22470117697268,0.8893909161288442,0.0930930778625372,0.8394609095007669,0.6213444972535296,42,,43.0 -68,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,1.0,1.0,100.0,0.0,0.0,1.0,2.0,1.3,249.0,12.7,100.3,5.5,114.0,3.1,3.9,21.0,42.0,40.0,108.0,5.8,0.9,5.0,8.0,1.2,37.0,17.0,419.0,1.0,2,2,1,Category 2,Category 2,Category 4,0.4731662010518922,0.0002375235758845,0.396659776343562,-0.396659776343562,0.0426332092870327,0.0669615828234471,0.2964897812833152,0.2964897812833152,42,,43.0 -69_random,1.0,1.0,0.0,0.0,0.0,0.0,1,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,,0.0,1.0,1.0,0.0,0.0,1.0,1.0,2.0,1.39,173.0,14.0,95.1,7100.0,318000.0,4.8,1.0,70.0,63.0,196.0,93.0,8.6,0.2,1.0,,0.5,9.0,,859.0,1.0,1,2,2,Category 1,Category 1,Category 3,,0.6957142928497502,0.3485736672419705,-0.7524277626155725,0.388652798629847,1.2572150690343238,0.412761129266026,0.6213444972535296,42,,43.0 -70,1.0,0.0,0.0,0.0,1.0,0.0,1,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.17,358.0,12.7,74.0,2.2,51.0,2.9,2.8,53.0,41.0,54.0,94.0,4.9,0.2,2.0,5.4,0.8,50.0,16.0,20.0,0.0,2,1,2,Category 1,Category 1,Category 3,,,0.2346740382615511,-0.2346740382615511,0.2658511366543135,-0.3801267872158922,0.1107484453189581,0.1107484453189581,42,, -71,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,1.0,1.0,75.0,44.0,3.0,2.0,2.0,1.01,1810346.0,13.0,102.1,8300.0,433000.0,3.4,1.9,138.0,86.0,1575.0,417.0,6.5,0.64,5.0,15.0,1.1,,,,0.0,1,1,2,Category 2,Category 1,Category 4,0.106699250113436,0.9325899094252528,0.8837096696607526,-0.8837096696607526,0.646090123462508,0.7798514361291058,0.7595824101146318,0.7595824101146318,42,,43.0 -72,1.0,1.0,0.0,0.0,0.0,0.0,1,,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,,1.0,1.0,1.0,1.0,0.0,50.0,48.0,2.0,1.0,2.0,1.53,33502.0,14.4,101.1,11.6,109.0,3.1,2.3,27.0,80.0,177.0,1.28,6.7,1.5,5.0,4.0,0.8,26.0,15.0,227.0,0.0,1,1,1,Category 2,Category 1,Category 3,,,0.4420243737828575,-0.4420243737828575,0.4993338349786183,0.0930930778625372,0.988065566652774,0.988065566652774,42,,43.0 -73,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,1.0,1.0,1.0,,0.0,0.0,1.0,1.0,0.94,20.0,13.0,92.0,6.9,222000.0,3.7,0.6,162.0,354.0,1390.0,684.0,7.1,0.81,5.0,,,,,,1.0,1,1,3,Category 2,Category 1,Category 3,,,0.3308893629891719,-0.3308893629891719,0.2660192780053807,0.4805833241406625,0.9012960107746488,0.9012960107746488,42,,43.0 -74,1.0,1.0,0.0,,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,15.0,0.0,1.0,1.0,1.15,2.5,14.9,92.3,6.0,159000.0,3.8,1.0,28.0,38.0,74.0,101.0,7.4,1.1,5.0,7.5,0.3,61.0,,255.0,0.0,2,2,2,Category 1,Category 1,Category 1,,,0.448777573831403,-0.448777573831403,0.1492377779501761,-0.080910968956611,0.6516679187064259,0.6516679187064259,42,,43.0 -75_random,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,,0.0,0.0,0.0,0.0,,,1.0,0.0,1.0,1.0,70.0,0.0,0.0,1.0,1.0,,1.2,12.2,89.5,6690.0,128000.0,1.9,1.4,134.0,306.0,356.0,466.0,6.7,0.64,5.0,3.5,0.6,98.0,,,0.0,1,1,4,Category 1,Category 3,Category 1,,,0.9921333163406724,-0.22470117697268,0.2288946048466136,1.150251716690645,0.5578201919292014,0.9466379541996072,42,,43.0 -76,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0,,,2.0,1.0,2.0,3.16,4181.0,9.1,103.6,5.1,128000.0,3.0,2.2,57.0,91.0,115.0,165.0,7.7,0.83,1.0,4.5,1.2,72.0,29.5,355.0,1.0,2,3,2,Category 1,Category 1,Category 2,,,0.1457565682447517,-0.1457565682447517,0.8646603921404177,0.9392894951174534,0.2543219811783167,0.2543219811783167,42,,43.0 -77,1.0,1.0,0.0,0.0,0.0,0.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,0.0,0.0,1.0,80.0,,0.0,1.0,1.0,1.45,5.1,14.4,100.2,7.1,77000.0,4.1,0.9,43.0,63.0,540.0,114.0,7.0,1.09,5.0,,,,,,0.0,2,3,2,Category 1,Category 2,Category 1,,,0.4494338352137377,-0.4494338352137377,0.2434779684048672,0.376549527357401,0.8192551048714611,0.8192551048714611,42,,43.0 -78_random,,1.0,0.0,0.0,,0.0,1,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,1.0,0.0,47.0,2.0,1.0,2.0,1.02,14.2,13.5,94.7,8.9,77000.0,3.4,,28.0,91.0,126.0,318.0,6.7,0.9,5.0,,1.1,26.0,,905.0,0.0,2,1,3,Category 1,Category 3,Category 3,,,0.2357920939592098,-0.2525277820754192,0.1217619111252747,0.1104140443298413,0.988065566652774,0.5591848068293265,42,,43.0 -79,,1.0,0.0,0.0,0.0,1.0,1,,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,100.0,34.5,2.0,2.0,2.0,2.08,2.9,10.4,91.1,5.8,91000.0,2.4,16.0,123.0,145.0,109.0,190.0,5.9,0.9,0.0,,9.6,,,,0.0,2,1,1,Category 1,Category 1,Category 3,,,0.9485833548514336,-0.9485833548514336,0.8106859279862663,0.4513696974283388,0.5254349125456929,0.5254349125456929,42,,43.0 -80,1.0,1.0,,,,,1,0.0,,1.0,0.0,0.0,1.0,1.0,0.0,,,1.0,1.0,0.0,1.0,1.0,,,3.0,2.0,1.0,1.32,2.5,12.6,83.7,9.8,102000.0,3.3,1.2,29.0,43.0,196.0,204.0,7.3,1.1,5.0,,0.5,,,,1.0,1,3,4,Category 2,Category 2,Category 3,,,0.2525277820754192,-0.2525277820754192,0.6140813111847361,-0.0189409385309996,0.2443399407864661,0.2443399407864661,42,,43.0 -81,0.0,1.0,0.0,,0.0,0.0,1,0.0,,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,100.0,,1.0,2.0,1.0,1.63,5.04,15.8,99.0,5.8,75000.0,3.5,4.6,93.0,85.0,193.0,165.0,6.6,0.7,1.0,6.0,1.7,200.0,87.0,316.0,0.0,1,3,1,Category 2,Category 2,Category 1,,,0.3592507479162455,-0.3592507479162455,0.8595652316469458,1.1105951603247657,0.1129432084111735,0.1129432084111735,42,,43.0 -82_random,0.0,0.0,0.0,0.0,0.0,1.0,0,0.0,1.0,0.0,0.0,,0.0,0.0,0.0,,,1.0,1.0,1.0,1.0,1.0,100.0,,0.0,1.0,2.0,1.18,,10.8,93.8,6.0,277000.0,4.6,0.6,97.0,34.0,646.0,113.0,7.0,,1.0,3.0,,171.0,56.0,278.0,0.0,1,3,4,Category 1,Category 3,Category 3,,0.7953418379590974,0.6018553836620085,-0.3426534881209153,0.618051674287186,0.1847061150570181,0.2964897812833152,0.7076883263306187,42,,43.0 -83,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,100.0,,2.0,1.0,3.0,1.48,2.6,12.7,106.0,3.8,80.0,2.9,3.4,34.0,53.0,156.0,207.0,7.2,,2.0,4.1,1.4,105.0,69.0,221.0,1.0,2,3,1,Category 1,Category 1,Category 2,,,0.6055381576448828,-0.6055381576448828,0.9562221906489484,0.4774305741128856,0.7190774473538556,0.7190774473538556,42,,43.0 -84_random,0.0,1.0,0.0,,1.0,0.0,1,,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,2.0,,4.9,10.3,96.1,,318000.0,3.8,2.6,93.0,40.0,444.0,109.0,,3.95,1.0,,,180.0,,316.0,0.0,1,1,2,Category 2,Category 1,Category 4,0.7184572708365536,,0.1623818946623209,-0.9186777969935044,0.2278424175431099,1.282340082453239,0.1298264489517175,0.8568739360750941,42,,43.0 -85_random,1.0,0.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,0.0,1.0,1.0,40.0,,0.0,1.0,1.0,1.09,41.0,9.8,91.6,5.2,65000.0,3.4,2.1,66.0,69.0,134.0,180.0,6.7,0.88,5.0,,0.5,37.0,,,1.0,1,3,4,Category 2,Category 1,Category 2,0.0773210654887872,0.8601268164179238,0.0436616577073611,-0.3290174378146622,0.0950116989923046,0.3383194249923379,0.4790700631033512,0.2824308986865117,42,,43.0 -86,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,0.0,1.0,1.0,,,1.0,1.0,1.0,1.08,2.79,12.6,83.9,7100.0,284000.0,,,28.0,46.0,70.0,213.0,,0.48,5.0,,,26.0,8.0,,0.0,2,2,3,Category 1,Category 2,Category 1,,,0.7817903298450294,-0.7817903298450294,0.6586921462074435,1.5826701590296028,0.7396713007267637,0.7396713007267637,42,,43.0 -87,0.0,0.0,0.0,0.0,1.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,0.0,0.0,1.0,0.0,33.0,0.0,1.0,2.0,,42.0,15.8,97.9,4.2,142000.0,4.2,0.5,74.0,62.0,38.0,70.0,7.5,0.77,3.0,1.5,,120.0,35.0,30.0,0.0,2,2,4,Category 1,Category 2,Category 2,,,0.7053855941122036,-0.7053855941122036,0.9428311414132616,1.0861610882385797,0.1912604179145867,0.1912604179145867,42,, -88,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,100.0,,0.0,1.0,2.0,1.37,457.0,11.7,70.6,5.7,138000.0,4.1,2.1,22.0,33.0,33.0,90.0,9.7,1.6,5.0,5.6,0.9,13.0,3.0,28.0,1.0,2,2,3,Category 2,Category 2,Category 1,,0.8528218216919013,0.4463686465125855,-0.4463686465125855,0.8088834616363281,0.3167698263037048,0.613777418815699,0.613777418815699,42,,43.0 -89,0.0,1.0,0.0,0.0,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,50.0,1.0,2.0,3.0,1.23,,9.5,90.0,7.6,38000.0,2.2,1.5,59.0,51.0,993.0,474.0,3.9,2.69,1.0,2.0,1.0,,,,0.0,2,1,1,Category 2,Category 2,Category 2,0.6337585637201772,0.7155533152342419,0.8642161776741689,-0.8642161776741689,0.0764168594380514,0.2011899405049085,0.4355054543981593,0.4355054543981593,42,, -90,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,0.0,100.0,0.0,2.0,1.0,3.0,1.41,123.0,10.1,89.5,2.3,89000.0,4.0,4.3,31.0,60.0,75.0,177.0,6.8,0.7,3.0,3.5,1.0,37.0,11.0,173.0,1.0,1,3,2,Category 1,Category 3,Category 1,,0.5891085344708948,0.5581402495938629,-0.5581402495938629,0.2793677139347164,-0.3486549876656268,0.5772497307686131,0.5772497307686131,42,,43.0 -91,0.0,1.0,0.0,,0.0,0.0,1,0.0,,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,,,,,,0.0,1.0,1.0,1.22,8.7,14.6,95.1,6.7,142000.0,4.2,1.3,19.0,33.0,346.0,120.0,7.8,0.83,,,0.3,184.0,65.0,423.0,0.0,2,2,1,Category 2,Category 1,Category 1,,0.2772656456967736,0.5399058395022125,-0.5399058395022125,0.9303188848378235,1.150251716690645,0.7380691233385172,0.7380691233385172,42,,43.0 -92,1.0,1.0,0.0,0.0,1.0,0.0,1,0.0,0.0,1.0,0.0,,1.0,1.0,0.0,0.0,,0.0,1.0,0.0,0.0,1.0,70.0,0.0,3.0,1.0,1.0,1.01,226.0,11.5,95.6,6.3,108.0,4.2,1.0,27.0,31.0,667.0,222.0,6.2,3.13,1.0,8.8,0.2,,,,1.0,2,3,3,Category 2,Category 1,Category 1,,,0.0341877659391581,-0.0341877659391581,0.2530584328007845,0.9581067658780446,0.8061958810037908,0.8061958810037908,42,,43.0 -93_random,1.0,0.0,0.0,,1.0,0.0,1,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,0.0,0.0,2.0,1.0,1.25,86.0,14.3,94.2,2.9,78.0,,3.9,140.0,63.0,346.0,113.0,7.2,0.4,2.0,10.0,1.3,,8.0,,0.0,1,3,2,Category 2,Category 3,Category 3,0.7718819805982451,,0.0904816952870507,-0.2035782803422426,0.52550462196864,1.270644250942094,0.3123491018855135,0.2263514943414859,42,,43.0 -94_random,0.0,1.0,0.0,0.0,0.0,1.0,1,0.0,,1.0,,0.0,0.0,0.0,0.0,,1.0,0.0,1.0,0.0,1.0,0.0,0.0,52.5,0.0,1.0,1.0,1.33,9.2,,89.7,,83000.0,4.4,0.9,42.0,49.0,126.0,180.0,7.3,1.6,1.0,,0.4,93.0,,70.0,1.0,2,1,4,Category 1,Category 2,Category 1,,,0.5322449888262991,-0.9398197919268416,0.3864608411591471,0.2462988717515553,0.2263514943414859,0.4853589831598871,42,,43.0 -95_random,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,0.0,70.0,,0.0,1.0,1.0,1.3,249.0,,90.6,6.4,94000.0,4.2,3.5,20.0,192.0,869.0,303.0,5.8,2.19,1.0,3.32,1.0,,,419.0,1.0,2,1,1,Category 2,Category 1,Category 1,,,0.8268388837118774,-0.6490746587943931,0.4242968858848881,-0.3068727023502736,0.8772394571622004,0.1671320114712212,42,,43.0 -96,1.0,1.0,0.0,0.0,0.0,1.0,0,1.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,,0.0,1.0,1.0,2.0,1.11,5.0,9.1,90.9,6.36,307000.0,2.47,,31.0,29.0,339.0,254.0,5.5,1.18,3.0,6.3,,,,,0.0,1,2,4,Category 2,Category 1,Category 2,,0.1244375572968563,0.0516968372415269,-0.0516968372415269,0.3863489098483155,-0.2193359103484788,0.7392947351647732,0.7392947351647732,42,,43.0 -97,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,,,0.0,1.0,1.0,1.64,64.0,14.1,103.6,4.5,68.0,2.9,3.3,28.0,43.0,51.0,137.0,6.8,0.67,4.0,4.7,1.1,,,,0.0,2,1,3,Category 1,Category 2,Category 1,0.6241015441818376,,0.6400029668369137,-0.6400029668369137,0.4501244324197596,-0.2052232392504095,0.1063437262557746,0.1063437262557746,42,,43.0 -98_random,0.0,0.0,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,,2.0,1.0,2.0,1.42,173.0,13.3,94.7,7.1,179000.0,2.3,1.1,52.0,85.0,183.0,239.0,6.9,0.99,5.0,2.2,0.3,37.0,9.0,,0.0,1,1,4,Category 1,Category 1,Category 2,0.4570002192816783,0.4911863408686265,0.8359980637812094,-0.7760002070354295,0.8106859279862663,0.4302318382894385,0.6507685475587474,0.7507295069993472,42,,43.0 -99,0.0,1.0,0.0,,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,0.0,2.0,1.0,2.0,1.67,8.5,13.0,102.3,24.8,133000.0,2.7,9.5,262.0,335.0,351.0,66.0,6.1,1.2,5.0,7.0,5.5,,,,0.0,1,1,2,Category 1,Category 1,Category 2,,0.2589826516018136,0.1800104374727235,-0.1800104374727235,0.8893909161288442,1.1028965397504435,0.0038171341243471,0.0038171341243471,42,,43.0 -100,1.0,1.0,,,,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,1.0,1.0,0.0,1.0,0.0,,0.0,2.0,1.0,1.0,1.16,2785.0,12.0,94.4,7.9,78000.0,2.6,3.5,26.0,34.0,339.0,297.0,5.7,2.19,5.0,,1.5,55.0,33.0,256.0,0.0,1,1,1,Category 2,Category 3,Category 1,0.5774862709061257,,0.0885555842232413,-0.0885555842232413,0.4506196567297579,0.3607327270103231,0.6816694824016201,0.6816694824016201,42,, -101_random,1.0,1.0,0.0,0.0,0.0,1.0,1,0.0,1.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,1.0,50.0,0.0,0.0,1.0,3.0,1.0,2.9,14.4,104.5,4.9,251.0,3.7,1.3,35.0,85.0,346.0,91.0,6.5,0.8,5.0,18.6,,28.0,27.0,905.0,0.0,2,3,4,Category 1,Category 1,Category 1,,,0.5771852367117482,-0.0090304041295502,0.1492377779501761,0.9329955608771252,0.6261761715931382,0.1688542066776861,42,,43.0 -102,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,1.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,1.0,70.0,,2.0,1.0,2.0,1.55,5.7,13.9,99.7,5200.0,124000.0,2.1,0.8,37.0,75.0,203.0,110.0,5.0,0.56,3.0,2.4,,92.0,56.0,489.0,0.0,2,3,2,Category 2,Category 2,Category 1,0.3914821102015019,,0.5846707004425887,-0.5846707004425887,0.105693479906274,0.7175886251489202,0.6552824096916582,0.6552824096916582,42,,43.0 -103,1.0,0.0,1.0,,,1.0,1,,,0.0,0.0,,0.0,0.0,0.0,0.0,,,1.0,0.0,,0.0,0.0,,4.0,3.0,3.0,1.93,,13.5,93.3,8190.0,406000.0,2.9,40.5,139.0,266.0,403.0,670.0,6.3,4.82,5.0,,29.3,,,,1.0,1,3,4,Category 1,Category 3,Category 2,,,0.6882078658665954,-0.6882078658665954,0.9882752710001314,0.9329955608771252,0.9917426171678388,0.9917426171678388,42,,43.0 -104,1.0,0.0,0.0,0.0,0.0,0.0,0,,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,50.0,1.0,1.0,1.0,1.17,39.0,12.6,93.8,4900.0,144000.0,3.8,1.0,42.0,74.0,277.0,312.0,78.0,1.01,1.0,15.0,,87.0,25.0,81.0,0.0,2,1,1,Category 1,Category 1,Category 1,0.0666191123908169,0.9037239671752704,0.397378988464401,-0.397378988464401,0.4432730874436182,0.4625689693368711,0.0726708716100162,0.0726708716100162,42,,43.0 -105_random,1.0,1.0,1.0,0.0,0.0,1.0,1,0.0,0.0,,0.0,0.0,1.0,,0.0,0.0,1.0,0.0,1.0,1.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,,100809.0,11.3,94.2,14.4,77000.0,4.2,1.4,28.0,523.0,127.0,44.0,7.3,0.9,1.0,,0.37,,,,0.0,1,1,2,Category 2,Category 1,Category 2,0.7184572708365536,,0.6550093388321085,-0.3955151698490152,0.5146575865735116,0.5171236672193903,0.6261761715931382,0.1063437262557746,42,, -106,1.0,1.0,0.0,0.0,1.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0,1.0,80.0,1.0,0.0,1.0,1.0,1.18,32.0,14.0,90.1,5.2,121000.0,4.2,0.4,420.0,226.0,147.0,174.0,8.6,0.9,5.0,3.0,,26.4,54.0,2230.0,0.0,1,2,1,Category 1,Category 3,Category 1,,0.7433528228936241,0.6859677359829841,-0.6859677359829841,0.0380218482374549,-0.1166350366251604,0.3403800926666749,0.3403800926666749,42,,43.0 -107,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,,0.0,1.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,75.0,0.0,3.0,1.0,2.0,1.32,7.6,5.0,69.5,3800.0,96000.0,3.7,0.5,17.0,69.0,76.0,86.0,6.3,2.68,1.0,10.0,,9.0,3.0,490.0,1.0,1,1,2,Category 1,Category 3,Category 2,0.4315281431364426,0.064986409482894,0.0173797901854796,-0.0173797901854796,0.7462072574818386,0.9891192049215988,0.866386514251342,0.866386514251342,42,, -108,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,1.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,1.0,0.0,1.0,1.0,100.0,0.0,1.0,1.0,1.0,1.25,173.0,11.3,103.9,6200.0,176000.0,2.4,1.7,63.0,114.0,80.0,163.0,6.1,0.67,5.0,20.0,0.5,131.0,78.0,1316.0,1.0,1,2,2,Category 2,Category 1,Category 3,,,0.3231306570702785,-0.3231306570702785,0.6590355342036808,0.5171236672193903,0.2155298687913318,0.2155298687913318,42,,43.0 -109,0.0,1.0,0.0,0.0,0.0,0.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,,,0.0,1.0,1.0,1.54,2.3,12.1,89.7,4.5,97000.0,2.7,1.4,19.0,27.0,72.0,120.0,4.3,0.61,5.0,4.0,0.7,,,,0.0,2,1,2,Category 1,Category 1,Category 4,,,0.9730977480703464,-0.9730977480703464,0.8021305581275875,0.5828652841558029,0.3603778199303475,0.3603778199303475,42,,43.0 -110,1.0,1.0,1.0,0.0,1.0,0.0,1,,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,1.0,200.0,30.0,2.0,2.0,2.0,1.26,114.0,14.9,104.5,4.3,90000.0,3.2,4.8,106.0,154.0,148.0,166.0,7.2,0.48,5.0,12.6,1.8,161.0,96.0,297.0,0.0,2,2,4,Category 1,Category 1,Category 2,,,0.580112229695468,-0.580112229695468,0.1053675339528059,0.0868466466300826,0.0685054066269795,0.0685054066269795,42,,43.0 -111,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,1.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,1.0,90.0,,2.0,1.0,2.0,1.87,173.0,11.1,105.5,6.1,51000.0,3.1,32.3,110.0,206.0,127.0,188.0,5.4,1.29,5.0,,22.1,,,,1.0,1,3,1,Category 1,Category 2,Category 3,0.1667307599933831,,0.2542245798974932,-0.2542245798974932,0.0355708670355483,0.4183561558560995,0.7631552912588894,0.7631552912588894,42,,43.0 -112,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,100.0,,0.0,1.0,1.0,1.36,18.0,15.3,90.9,4.9,81000.0,4.2,1.7,35.0,49.0,97.0,109.0,7.3,1.02,1.0,3.5,0.3,,,,0.0,1,1,4,Category 1,Category 1,Category 3,,,0.5217300466362131,-0.5217300466362131,0.5085792894475785,0.1557971872371335,0.4083063427594511,0.4083063427594511,42,,43.0 -113,1.0,0.0,1.0,0.0,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,0.0,0.0,7.5,1.0,1.0,1.0,1.45,42.0,16.2,99.1,5.001,77000.0,4.1,1.3,42.0,118.0,279.0,158.0,7.7,0.88,2.0,7.4,0.3,,,,0.0,2,1,4,Category 2,Category 3,Category 4,,0.046945357147813,0.3426534881209153,-0.3426534881209153,0.3875952314827695,0.3198365998472043,0.7592487330608428,0.7592487330608428,42,,43.0 -114,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,1.0,0.0,,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,100.0,,3.0,3.0,2.0,1.87,28274.0,10.3,94.7,11.1,109000.0,2.4,5.7,25.0,111.0,55.0,128.0,7.0,1.3,1.0,1.5,1.9,51.0,18.0,56.0,1.0,1,1,2,Category 2,Category 3,Category 1,,,0.5322449888262991,-0.5322449888262991,0.4619469366709557,0.522666373800494,0.9036078443467952,0.9036078443467952,42,,43.0 -115_random,0.0,1.0,0.0,0.0,0.0,0.0,0,,0.0,,0.0,0.0,0.0,0.0,,0.0,1.0,1.0,0.0,0.0,0.0,1.0,,,0.0,1.0,1.0,1.07,16.0,12.2,109.3,9.3,70.0,3.2,2.6,140.0,94.0,75.0,44.0,,0.78,1.0,3.5,,61.0,,,,1,3,1,Category 1,Category 3,Category 1,,0.8974361480462039,0.9730977480703464,-0.3592507479162455,0.3870787603356308,-0.6445809036896053,0.8772394571622004,0.3368405018611032,42,,43.0 -116,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,96.0,60.0,0.0,1.0,3.0,1.17,1009.0,13.8,93.2,3100.0,137000.0,3.0,0.7,25.0,55.0,343.0,235.0,,0.79,2.0,20.0,,,,,1.0,1,2,4,Category 2,Category 1,Category 2,,,0.1327146538192773,-0.1327146538192773,0.9707499576706702,0.7693679151452357,0.8073960303399513,0.8073960303399513,42,,43.0 -117_random,0.0,0.0,,0.0,0.0,,1,,1.0,0.0,0.0,0.0,1.0,1.0,0.0,,1.0,1.0,0.0,0.0,0.0,0.0,100.0,0.0,0.0,1.0,2.0,1.87,10.0,13.5,89.5,4.5,109000.0,4.3,1.1,207.0,335.0,1575.0,184.0,7.1,0.88,5.0,4.1,0.3,,,30.0,0.0,2,3,4,Category 1,Category 1,Category 1,0.2560155318536622,0.9033638126360248,0.2346740382615511,-0.3121480566964471,0.4993338349786183,0.4302318382894385,0.6507685475587474,0.0001883995565818,42,,43.0 -118,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,,0.0,0.0,1.0,1.0,1.28,5.2,14.6,96.1,6.1,194000.0,4.2,7.9,97.0,69.0,816.0,79.0,7.7,1.02,1.0,3.0,,,,,0.0,2,3,3,Category 2,Category 2,Category 1,,,0.9398197919268416,-0.9398197919268416,0.7838426767676738,0.4943303682627932,0.8988473881802473,0.8988473881802473,42,,43.0 -119,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,180.0,23.0,0.0,1.0,2.0,1.46,5.2,14.9,103.8,4500.0,53000.0,3.2,1.4,62.0,87.0,263.0,239.0,8.1,0.72,1.0,1.5,1.0,,,,0.0,2,3,4,Category 1,Category 1,Category 4,,,0.7328989183413418,-0.7328989183413418,0.3548413602568904,0.7783743174570403,0.6507685475587474,0.6507685475587474,42,,43.0 -120,1.0,0.0,1.0,0.0,,0.0,1,1.0,0.0,1.0,0.0,0.0,1.0,0.0,,,,,,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.14,14177.0,10.2,96.1,6000.0,109000.0,2.6,4.9,70.0,113.0,833.0,980.0,7.5,0.78,5.0,9.0,2.8,,,,0.0,1,1,1,Category 1,Category 1,Category 1,0.1431279855484696,,0.1623818946623209,-0.1623818946623209,0.4121309302627716,1.2572150690343238,0.8742267241383516,0.8742267241383516,42,,43.0 -121,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,0.0,1.0,100.0,0.0,0.0,1.0,1.0,1.94,3.1,10.8,102.8,5300.0,97000.0,3.6,1.1,119.0,125.0,663.0,433.0,6.5,0.87,2.0,3.2,0.4,52.5,37.0,856.0,1.0,1,3,2,Category 1,Category 3,Category 3,,,0.1883490837656014,-0.1883490837656014,0.5496160437189245,-0.0779993152674032,0.0001883995565818,0.0001883995565818,42,,43.0 -122,1.0,1.0,0.0,0.0,1.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,0.0,75.0,52.5,2.0,1.0,1.0,1.56,50655.0,9.8,85.6,3900.0,132000.0,2.6,2.6,123.0,219.0,503.0,363.0,7.3,0.55,1.0,4.0,1.5,40.0,12.0,57.0,1.0,2,1,2,Category 1,Category 1,Category 1,,,0.7308294748708763,-0.7308294748708763,0.8305344564048399,0.2700501054857166,0.1690810703559925,0.1690810703559925,42,,43.0 -123,0.0,0.0,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,,,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.11,1.2,15.1,83.8,5.2,178000.0,4.7,0.5,35.0,17.0,45.3,151.0,6.4,1.5,1.0,8.3,,88.0,27.0,90.0,0.0,2,1,1,Category 1,Category 2,Category 4,,,0.1561638447921739,-0.1561638447921739,0.0687128325182677,-0.0117352642564631,0.3897593874264921,0.3897593874264921,42,,43.0 -124,1.0,1.0,0.0,0.0,1.0,1.0,1,,1.0,0.0,0.0,1.0,0.0,0.0,0.0,,1.0,0.0,1.0,0.0,0.0,0.0,,,2.0,1.0,2.0,1.08,657.0,11.8,89.2,9400.0,211000.0,3.2,0.8,43.0,101.0,646.0,466.0,7.3,0.7,1.0,8.3,,,,579.0,1.0,2,3,3,Category 1,Category 3,Category 3,,,0.2345612933348286,-0.2345612933348286,0.4242968858848881,0.4302318382894385,0.3795029033747186,0.3795029033747186,42,,43.0 -125,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,1.0,100.0,,4.0,2.0,2.0,1.2,421500.0,14.3,89.5,9.8,309000.0,3.1,1.5,20.0,44.0,291.0,217.0,6.3,0.7,1.0,20.0,0.5,52.0,17.0,832.0,1.0,2,1,2,Category 2,Category 1,Category 3,,0.5152479243147259,0.963346832820399,-0.963346832820399,0.0826176634592686,0.417387977902975,0.2267303829235106,0.2267303829235106,42,,43.0 -126_random,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,,1.0,1.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,1.0,300.0,0.0,0.0,1.0,2.0,1.65,,12.2,,6900.0,199.0,3.2,1.1,132.0,63.0,229.0,128.0,7.1,0.81,1.0,10.0,0.5,,,905.0,0.0,2,1,4,Category 2,Category 2,Category 1,0.4739699414305561,0.0002375235758845,0.3231306570702785,-0.6490746587943931,0.4047984290851998,0.0930930778625372,0.7595824101146318,0.3368405018611032,42,,43.0 -127,0.0,1.0,0.0,0.0,0.0,,1,0.0,0.0,1.0,0.0,,1.0,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,1.0,,0.0,3.0,2.0,1.0,1.66,77.0,12.3,104.2,2900.0,60000.0,3.2,2.8,54.0,38.0,311.0,182.0,6.2,0.77,2.0,4.3,1.0,93.0,47.0,307.0,0.0,2,2,2,Category 2,Category 1,Category 4,,,0.6616323503711468,-0.6616323503711468,0.8989008240062354,0.3456122559336226,0.1288487120002548,0.1288487120002548,42,,43.0 -128,0.0,0.0,1.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,0.0,0.0,0.0,0.0,0.0,510.0,2.0,1.0,1.0,1.13,2.1,12.6,95.1,8.7,254000.0,3.68,0.7,26.0,38.0,161.0,127.0,6.9,1.11,2.0,4.3,,28.0,10.0,308.0,1.0,1,1,1,Category 1,Category 1,Category 2,0.4570002192816783,0.8974361480462039,0.9786312874005304,-0.9786312874005304,0.7824849245639379,0.764427226698616,0.412761129266026,0.412761129266026,42,,43.0 -129,1.0,1.0,,,,,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,1.0,0.0,0.0,1.0,75.0,0.0,2.0,2.0,2.0,1.07,2.0,11.6,83.5,9.0,318000.0,3.89,0.9,23.0,48.0,319.0,171.0,7.1,0.66,2.0,5.8,,,,,1.0,2,2,4,Category 2,Category 1,Category 2,,,0.3742967671397926,-0.3742967671397926,0.2278424175431099,0.0924239131566814,0.8023543291592642,0.8023543291592642,42,,43.0 -130,1.0,0.0,,,,0.0,1,0.0,0.0,0.0,1.0,0.0,1.0,0.0,,,,0.0,0.0,1.0,1.0,0.0,0.0,0.0,2.0,1.0,3.0,1.22,4.2,14.9,87.4,15.4,179000.0,3.5,0.6,31.0,61.0,196.0,150.0,5.4,0.7,5.0,17.5,0.3,,,,0.0,1,3,2,Category 2,Category 2,Category 2,,0.6229373829351187,0.0175159908620622,-0.0175159908620622,0.9759908495987925,1.282340082453239,0.4790700631033512,0.4790700631033512,42,,43.0 -131_random,1.0,0.0,0.0,0.0,,0.0,1,,,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,200.0,50.0,1.0,1.0,1.0,1.28,163.0,12.1,94.2,8300.0,137000.0,3.4,0.8,35.0,74.0,879.0,222.0,8.3,1.9,5.0,3.5,,,33.0,307.0,0.0,1,1,2,Category 1,Category 3,Category 1,,,0.5335119252996956,-0.2886855955306381,0.5146575865735116,-0.3427523587926684,0.8023543291592642,0.4516968192316827,42,, -132_random,1.0,0.0,0.0,,,0.0,1,,,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,100.0,30.0,4.0,1.0,1.0,1.33,5.5,9.8,69.5,5.0,102000.0,4.2,1.4,73.0,38.0,279.0,128.0,8.8,0.59,5.0,6.0,,87.0,,,1.0,1,1,1,Category 1,Category 3,Category 2,,,0.3591510296662314,-0.1800104374727235,0.232645538562681,0.9542129594108072,0.1660343134161954,0.4516968192316827,42,,43.0 -133_random,,1.0,0.0,0.0,1.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,2.0,1.02,5689.0,12.7,102.0,9.3,280000.0,4.3,1.7,45.0,35.0,75.0,151.0,5.5,2.69,2.0,,1.9,,54.0,59.0,1.0,1,2,1,Category 1,Category 3,Category 3,,,0.3728486371889344,-0.5794148993435008,0.6360707637298251,0.3124361118651462,0.507051103865441,0.3304080038757738,42,,43.0 -134_random,1.0,1.0,0.0,0.0,0.0,0.0,1,,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,,0.0,0.0,1.0,1.0,1.29,10.0,14.0,91.1,,137000.0,4.7,3.7,134.0,86.0,91.0,163.0,37.0,0.68,3.0,7.5,,,,,1.0,2,1,4,Category 2,Category 1,Category 3,0.7184572708365536,,0.5929183998317819,-0.3181115536181195,0.8293324051412837,0.9392894951174534,0.8023543291592642,0.4355054543981593,42,,43.0 -135_random,1.0,1.0,1.0,0.0,,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,1.0,250.0,0.0,4.0,1.0,1.0,1.36,41.0,12.6,96.7,7.2,318000.0,3.5,1.7,26.0,49.0,196.0,109.0,,0.66,2.0,,,,17.0,,0.0,2,3,4,Category 1,Category 2,Category 1,0.4878098008087379,0.0002375235758845,0.1257415118066488,-0.6400029668369137,0.3222155034446283,0.8435880694183653,0.7392947351647732,0.3897593874264921,42,, -136,1.0,0.0,0.0,0.0,0.0,0.0,0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,0.0,40.0,2.0,1.0,1.0,1.25,2089.0,15.4,91.6,10.9,175000.0,4.4,1.3,45.0,32.0,717.0,295.0,7.4,1.1,5.0,6.0,0.6,,,,0.0,2,3,2,Category 2,Category 1,Category 1,,,0.7955103716964032,-0.7955103716964032,0.959826518075929,1.1300897001741304,0.7076883263306187,0.7076883263306187,42,,43.0 -137,1.0,0.0,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,2.0,1.0,1.03,18.0,13.2,89.5,2.6,136000.0,4.3,0.8,18.0,29.0,82.0,141.0,7.2,0.85,1.0,9.5,,91.0,31.0,80.0,0.0,1,2,4,Category 1,Category 2,Category 2,0.5655083473229738,0.2729593748563149,0.9186777969935044,-0.9186777969935044,0.4782552945759237,-0.1230152692093823,0.9727763228920858,0.9727763228920858,42,, -138,1.0,0.0,0.0,0.0,1.0,0.0,1,,,,,0.0,,,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,,0.0,1.0,1.0,1.19,4.9,13.6,97.3,5400.0,133000.0,4.5,0.9,54.0,63.0,487.0,89.0,7.8,0.78,2.0,3.32,,78.0,30.0,220.0,0.0,1,3,1,Category 2,Category 1,Category 2,,,0.6006095425462361,-0.6006095425462361,0.895814597371882,0.3383194249923379,0.8260390516665719,0.8260390516665719,42,,43.0 -139_random,,1.0,1.0,,0.0,0.0,1,0.0,,0.0,,0.0,0.0,1.0,0.0,0.0,,1.0,,0.0,1.0,1.0,50.0,0.0,2.0,1.0,2.0,1.56,66.0,16.4,96.2,6900.0,318000.0,4.1,1.3,35.0,,184.0,109.0,5.8,0.7,1.0,4.7,0.1,37.0,17.0,,0.0,2,2,3,Category 1,Category 3,Category 4,0.2560155318536622,0.7953418379590974,0.6061887135611715,-0.1457565682447517,0.6517106479109683,1.2455404663466032,0.7251855480273908,0.1063437262557746,42,,43.0 -140,1.0,0.0,,,,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.25,180.0,12.2,87.6,7.2,130.0,3.5,0.5,79.0,58.0,229.0,302.0,7.0,0.6,5.0,9.0,,,,206.0,1.0,1,3,1,Category 1,Category 1,Category 4,,,0.8268388837118774,-0.8268388837118774,0.1252335704328271,0.8229157904565922,0.8394609095007669,0.8394609095007669,42,,43.0 -141_random,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,1.0,1.09,421500.0,9.8,107.5,9.3,318000.0,4.0,4.9,54.0,69.0,76.0,150.0,6.7,0.88,1.0,3.0,,,,120.0,1.0,1,2,2,Category 2,Category 1,Category 1,,0.0002375235758845,0.0173797901854796,-0.6006095425462361,0.7811704237869193,0.0701414149327613,0.5772497307686131,0.3304080038757738,42,,43.0 -142,,1.0,0.0,0.0,0.0,1.0,1,0.0,0.0,1.0,1.0,1.0,0.0,1.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,70.0,0.0,0.0,1.0,,1.02,24.0,16.0,98.8,6.6,96000.0,4.1,1.4,207.0,158.0,116.0,84.0,7.2,0.9,1.0,2.2,0.3,,,,0.0,1,2,4,Category 1,Category 2,Category 3,,0.329051365369871,0.5771852367117482,-0.5771852367117482,0.1139566347143171,-0.1548224516733159,0.6213444972535296,0.6213444972535296,42,,43.0 -143,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,1.0,0.0,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,0.0,,40.0,0.0,1.0,1.0,1.798,9.4,11.2,102.4,4.1,60000.0,3.4,3.7,43.0,63.0,175.0,106.0,7.6,0.52,1.0,2.1,1.1,94.0,39.0,344.0,0.0,1,2,4,Category 2,Category 1,Category 3,,,0.3485736672419705,-0.3485736672419705,0.4860155029775399,0.6006269632424499,0.5591848068293265,0.5591848068293265,42,,43.0 -144,,1.0,0.0,0.0,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,,0.0,0.0,1.0,,37.0,0.0,1.0,1.0,1.26,7.0,14.9,106.3,6.4,122.0,3.0,1.5,195.0,401.0,272.0,93.0,6.4,1.0,3.0,2.9,0.4,124.0,51.0,642.0,0.0,1,2,4,Category 2,Category 1,Category 3,,,0.1592874452428051,-0.1592874452428051,0.9202971812194076,0.8435880694183653,0.6282381104632814,0.6282381104632814,42,,43.0 -145_random,1.0,1.0,0.0,,1.0,0.0,1,,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,0.0,100.0,,3.0,2.0,1.0,2.08,48.0,12.0,102.4,3.0,137000.0,2.9,0.8,26.0,192.0,92.0,222.0,7.6,0.9,2.0,20.0,1.0,152.6,15.0,423.0,0.0,2,2,1,Category 2,Category 3,Category 2,0.6337585637201772,,0.0293944457565072,-0.4494338352137377,0.8480158852494014,-0.3427523587926684,0.988065566652774,0.276441690583396,42,,43.0 -146,1.0,1.0,0.0,0.0,0.0,0.0,1,,1.0,0.0,1.0,0.0,1.0,1.0,0.0,,1.0,0.0,1.0,1.0,0.0,0.0,100.0,15.0,2.0,1.0,3.0,1.68,92421.0,14.3,72.2,13.3,459000.0,3.2,1.6,24.0,76.0,570.0,472.0,5.9,2.02,1.0,,0.6,29.0,4.0,14.0,1.0,2,1,3,Category 1,Category 3,Category 2,,,0.3181115536181195,-0.3181115536181195,0.6164997268950835,-0.0539266501957972,0.6350891059097188,0.6350891059097188,42,, -147,0.0,1.0,0.0,,0.0,0.0,1,,,1.0,1.0,,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,,0.0,1.0,1.0,1.71,5.2,11.1,106.9,2100.0,52000.0,3.3,2.6,15.0,47.0,94.0,117.0,7.1,0.79,1.0,3.5,1.0,,,,0.0,2,1,2,Category 1,Category 3,Category 3,0.9118524088429648,,0.8664386675276454,-0.8664386675276454,0.1566384369738083,0.768020724874327,0.4498422079725592,0.4498422079725592,42,,43.0 -148,0.0,0.0,0.0,,0.0,0.0,1,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.18,16.0,13.3,94.3,4800.0,96000.0,3.8,1.2,26.0,35.0,75.0,105.0,7.6,0.53,1.0,2.4,0.3,,,,0.0,2,3,1,Category 2,Category 2,Category 3,0.1391161941430618,0.6957142928497502,0.9933369373586284,-0.9933369373586284,0.0437356258799694,0.1308196652489608,0.2184431828833071,0.2184431828833071,42,,43.0 -149,1.0,0.0,0.0,0.0,0.0,0.0,0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,0.0,0.0,0.0,2.0,1.0,1.0,,1.5,,,,,,,,,,,,,1.0,6.6,,,,,0.0,1,2,4,Category 1,Category 2,Category 4,,,0.7524277626155725,-0.7524277626155725,0.110807962179807,1.0472377559262789,0.1202472265116756,0.1202472265116756,42,,43.0 -150,0.0,0.0,0.0,0.0,1.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.12,3204.0,16.1,92.0,10.5,182.0,4.3,0.7,46.0,31.0,92.0,79.0,7.3,1.0,1.0,,0.2,,,,0.0,1,3,4,Category 2,Category 2,Category 1,0.2560155318536622,,0.0904816952870507,-0.0904816952870507,0.5985315756843657,0.9485551099523386,0.0683409355322604,0.0683409355322604,42,,43.0 -151,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,,,0.0,0.0,1.0,,,0.0,1.0,1.0,1.2,10.0,13.5,104.9,13.5,194.0,4.0,1.0,31.0,79.0,126.0,85.0,7.6,0.8,1.0,7.0,0.4,,,,0.0,2,1,4,Category 2,Category 2,Category 2,,,0.2886855955306381,-0.2886855955306381,0.0950116989923046,0.3258252256744784,0.2633157837532001,0.2633157837532001,42,,43.0 -152,1.0,1.0,0.0,0.0,0.0,1.0,1,0.0,1.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,1.0,250.0,18.0,1.0,1.0,3.0,1.39,695.0,11.1,93.9,5.4,88000.0,2.7,1.0,31.0,73.0,38.0,44.0,7.0,0.96,5.0,3.5,,,,,0.0,1,2,3,Category 1,Category 2,Category 2,,,0.1091096317657497,-0.1091096317657497,0.3759928899413114,0.1486924321238977,0.0461235643357338,0.0461235643357338,42,, -153_random,0.0,0.0,0.0,0.0,,1.0,0,1.0,1.0,0.0,,0.0,0.0,1.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,1.0,100.0,0.0,0.0,1.0,3.0,1.26,3204.0,13.7,91.6,6690.0,91000.0,2.6,0.7,119.0,32.0,55.0,417.0,7.0,0.7,1.0,,1.0,92.0,95.0,,1.0,2,1,4,Category 1,Category 2,Category 4,,0.064986409482894,0.6550093388321085,-0.5424786357193675,0.3548413602568904,0.7934424911991063,0.8061958810037908,0.0461235643357338,42,,43.0 -154_random,0.0,1.0,0.0,,0.0,0.0,0,,,1.0,0.0,,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,,1.09,249.0,14.1,103.6,3.8,222000.0,3.8,0.7,,47.0,127.0,239.0,5.4,0.81,4.0,2.1,22.1,,,,0.0,2,3,4,Category 2,Category 2,Category 2,,,0.4381723464119876,-0.3181115536181195,0.602553163842865,0.2385576484099146,0.8061958810037908,0.3816119398672001,42,,43.0 -155,1.0,1.0,0.0,0.0,0.0,0.0,1,,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,1.0,75.0,25.0,3.0,2.0,3.0,1.63,1671.0,12.8,101.6,4.4,172000.0,3.44,5.8,38.0,95.0,92.0,139.0,7.6,0.9,3.0,9.0,2.9,111.0,94.0,1600.0,1.0,2,3,4,Category 2,Category 2,Category 3,,,0.9256748308807118,-0.9256748308807118,0.1636838014653014,-0.3427523587926684,0.8245348080870322,0.8245348080870322,42,,43.0 -156_random,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,0.0,,0.0,2.0,1.0,1.0,1.02,5.5,13.7,92.0,24.8,284000.0,4.1,1.0,43.0,,816.0,127.0,5.8,3.13,2.0,3.0,,,96.0,,1.0,2,3,4,Category 1,Category 2,Category 2,,,0.3290174378146622,-0.3804197042327977,0.8792686599978382,1.1049664369274788,0.0683409355322604,0.9677558771033888,42,,43.0 -157,,1.0,0.0,0.0,0.0,0.0,1,,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,,20.0,0.0,1.0,2.0,1.41,1.7,14.7,97.2,6900.0,72000.0,3.5,1.3,31.0,24.0,67.0,97.0,7.3,0.76,1.0,3.5,0.3,,,,0.0,1,1,3,Category 1,Category 2,Category 4,0.6513672109882461,,0.9013756495884444,-0.9013756495884444,0.928317532848577,1.5471425043018256,0.2263514943414859,0.2263514943414859,42,,43.0 -158_random,1.0,1.0,0.0,0.0,1.0,1.0,1,0.0,1.0,1.0,0.0,0.0,1.0,,0.0,0.0,,,1.0,0.0,0.0,1.0,,37.0,0.0,1.0,2.0,1.25,,10.8,95.1,4.4,124000.0,4.2,2.6,26.0,114.0,194.0,244.0,6.4,0.2,5.0,3.5,0.37,15.0,18.0,295.0,1.0,2,3,1,Category 1,Category 3,Category 3,,0.5152479243147259,0.5929183998317819,-0.8664386675276454,0.6809748272382445,0.0747559549414363,0.0726708716100162,0.5313165205680591,42,,43.0 -159,1.0,1.0,1.0,0.0,1.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,1.0,1.0,100.0,0.0,3.0,3.0,3.0,1.52,4.9,7.9,111.2,4.1,67000.0,2.43,1.9,40.0,71.0,69.0,73.0,4.8,0.77,5.0,3.2,0.7,40.0,18.0,283.0,1.0,2,2,1,Category 1,Category 2,Category 3,0.374435369720422,,0.3171957167653986,-0.3171957167653986,0.4960478386798865,0.8581371249858669,0.5988082963834914,0.5988082963834914,42,,43.0 -160,0.0,1.0,,,,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,0.0,1.0,1.0,0.84,,15.4,109.2,9.3,184000.0,4.6,0.5,35.0,40.0,449.0,109.0,7.6,0.7,5.0,3.0,,,,,0.0,2,3,1,Category 1,Category 2,Category 1,,,0.868900625540571,-0.868900625540571,0.0127148899868935,-0.2889845856143734,0.0644912712491675,0.0644912712491675,42,,43.0 -161_random,,1.0,0.0,0.0,,1.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0,120.0,60.0,2.0,1.0,2.0,1.25,5.7,10.8,96.1,9400.0,433000.0,4.0,1.0,119.0,60.0,180.0,113.0,7.6,0.8,5.0,7.0,,197.0,3.0,423.0,1.0,2,2,4,Category 1,Category 2,Category 1,0.1391161941430618,,0.5977235652558643,-0.5771852367117482,0.3169224773449449,0.8581371249858669,0.0941519101256979,0.9727763228920858,42,, -162,0.0,1.0,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,1.0,0.0,1.0,1.0,0.0,,,,,0.0,0.0,1.0,,48.0,0.0,1.0,1.0,1.13,75.0,13.3,90.0,8.0,385000.0,4.3,0.6,53.0,52.0,164.0,181.0,7.5,1.46,5.0,18.6,,,,,0.0,2,1,3,Category 2,Category 1,Category 2,,,0.2968692745602808,-0.2968692745602808,0.6714549348946433,0.2490748762705782,0.8772617628261795,0.8772617628261795,42,,43.0 -163,0.0,1.0,1.0,0.0,1.0,1.0,1,1.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,,,,1.0,1.0,1.0,,,2.0,1.0,1.0,2.14,94964.0,15.6,117.3,5200.0,118000.0,4.8,1.1,50.0,60.0,320.0,170.0,8.4,0.74,5.0,18.0,,,,,1.0,1,1,3,Category 2,Category 1,Category 3,0.8404396319804229,,0.6490746587943931,-0.6490746587943931,0.3169224773449449,-0.6445809036896053,0.3304080038757738,0.3304080038757738,42,,43.0 -164,1.0,1.0,0.0,0.0,0.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,1.0,1.0,50.0,,0.0,1.0,1.0,1.79,44340.0,12.7,95.8,14.4,412000.0,2.2,28.5,78.0,127.0,444.0,462.0,6.6,3.95,5.0,8.5,19.8,,,,1.0,2,2,1,Category 2,Category 3,Category 1,,,0.328381227885081,-0.328381227885081,0.8792686599978382,0.775417275961631,0.3404058433495647,0.3404058433495647,42,,43.0 -no_class_0,1.0,1.0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,1.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,1.0,70.0,,2.0,1.0,2.0,1.55,5.7,13.9,99.7,5200.0,124000.0,2.1,0.8,37.0,75.0,203.0,110.0,5.0,0.56,3.0,2.4,,92.0,56.0,489.0,,1,2,4,Category 1,Category 3,Category 1,,0.8681608040515469,0.6302087483291442,-0.6302087483291442,0.2584316202918181,0.2885792725937171,0.989028358350174,0.989028358350174,42,,43.0 -no_class_1,1.0,1.0,0.0,0.0,1.0,0.0,1,0.0,0.0,1.0,0.0,,1.0,1.0,0.0,0.0,,0.0,1.0,0.0,0.0,1.0,70.0,0.0,3.0,1.0,1.0,1.01,226.0,11.5,95.6,6.3,108.0,4.2,1.0,27.0,31.0,667.0,222.0,6.2,3.13,1.0,8.8,0.2,,,,,1,3,3,Category 1,Category 3,Category 3,,0.2452855322553345,0.6098318054986945,-0.6098318054986945,0.5440165791827516,0.9542129594108072,0.6261761715931382,0.6261761715931382,42,,43.0 -miss_0_0.7,0.0,1.0,,,,,1,,,1.0,,,,,,,,1.0,,0.0,0.0,1.0,,,,,,,,,,,,,10.5,,,165.0,,7.3,,4.0,,,197.0,,,0.0,2,3,1,Category 1,Category 3,Category 2,0.1655205103672897,,0.5634389273484588,-0.5634389273484588,0.6360707637298251,0.9191871832780424,0.5313165205680591,0.5313165205680591,42,,43.0 -miss_1_0.8,,,,,,,1,,,,,,0.0,,,0.0,,,1.0,,,,,,,,2.0,,,,,,,3.89,0.9,,,,,,,,5.8,,,,,0.0,1,3,1,Category 2,Category 1,Category 2,,,0.3804197042327977,-0.3804197042327977,0.2210633714537284,0.5515714280078797,0.8381521835519244,0.8381521835519244,42,,43.0 -new_val_cat_text_binary,0.0,0.0,0.0,0.0,0.0,1.0,0,0.0,1.0,0.0,0.0,,0.0,0.0,0.0,,,1.0,1.0,1.0,1.0,1.0,100.0,,0.0,1.0,2.0,1.18,,10.8,93.8,6.0,277000.0,4.6,0.6,97.0,34.0,646.0,113.0,7.0,,1.0,3.0,,171.0,56.0,278.0,0.0,1,3,4,Category 5,Category 3,Category 3,,0.7953418379590974,0.6018553836620085,-0.3426534881209153,0.618051674287186,0.1847061150570181,0.2964897812833152,0.7076883263306187,42,,43.0 -new_val_cat_text_3,1.0,1.0,0.0,0.0,0.0,1.0,1,0.0,1.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,1.0,50.0,0.0,0.0,1.0,3.0,1.0,2.9,14.4,104.5,4.9,251.0,3.7,1.3,35.0,85.0,346.0,91.0,6.5,0.8,5.0,18.6,,28.0,27.0,905.0,1.0,2,3,4,Category 1,Category 7,Category 1,,,0.5771852367117482,-0.0090304041295502,0.1492377779501761,0.9329955608771252,0.6261761715931382,0.1688542066776861,42,,43.0 -new_val_cat_binary,1.0,0.0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,0.0,0.0,1.0,0.0,0.0,0.0,2.0,1.0,1.0,1.17,3.1,15.1,86.0,8.9,275000.0,2.8,1.3,74.0,50.0,23.0,104.0,5.4,0.6,5.0,7.8,0.2,46.0,18.0,,1.0,7,2,3,Category 1,Category 1,Category 4,,,0.0090304041295502,-0.0090304041295502,0.6292988060107362,1.661501998538744,0.3790271262190974,0.3790271262190974,42,,43.0 -new_val_cat_3,,1.0,0.0,0.0,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,,0.0,0.0,1.0,,37.0,0.0,1.0,1.0,1.26,7.0,14.9,106.3,6.4,122.0,3.0,1.5,195.0,401.0,272.0,93.0,6.4,1.0,3.0,2.9,0.4,124.0,51.0,642.0,0.0,1,16,4,Category 2,Category 1,Category 3,,,0.1592874452428051,-0.1592874452428051,0.9202971812194076,0.8435880694183653,0.6282381104632814,0.6282381104632814,42,,43.0 diff --git a/data/Generate_Expanded_HCC_Dataset.ipynb b/data/Generate_Expanded_HCC_Dataset.ipynb deleted file mode 100644 index 931a6f11..00000000 --- a/data/Generate_Expanded_HCC_Dataset.ipynb +++ /dev/null @@ -1,483 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "OfstZAEElnPB" - }, - "source": [ - "# Create simulated replication data for original HCC dataset\n", - "Takes the original HCC dataset and then for a user defined proportion of instances, generates new values for each feature and class outcome based on the distribution of values for that respective column in the data. This effectively adds some noise to the dataset so that the replication data is different from the original HCC dataset for the demonstration of the replication phase." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "executionInfo": { - "elapsed": 6531, - "status": "ok", - "timestamp": 1691164531262, - "user": { - "displayName": "ryan urbanowicz", - "userId": "09525282221743790591" - }, - "user_tz": 420 - }, - "id": "haDZyxwslmgw", - "outputId": "0b5ac11c-c3f2-4a5c-a453-1a6f20d798c4" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File Path: ./DemoData\n", - "File Name: hcc_data\n", - "Updated dataset saved to ./OtherData/hcc_data_rep.csv.\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "\n", - "random_seed = 42\n", - "np.random.seed(seed=random_seed)\n", - "\n", - "# Specify the path to your CSV dataset\n", - "csv_file = \"./DemoData/hcc_data.csv\"\n", - "\n", - "column_to_exclude = 'InstanceID'\n", - "\n", - "# Specify the proportion of instances to replace (between 0 and 1)\n", - "replace_proportion = 0.3\n", - "\n", - "# Find the last occurrence of the directory separator '/'\n", - "last_separator_index = csv_file.rfind('/')\n", - "\n", - "# Extract the file path\n", - "file_path = csv_file[:last_separator_index] if last_separator_index != -1 else ''\n", - "\n", - "# Find the extension separator '.'\n", - "extension_separator_index = csv_file.rfind('.')\n", - "\n", - "# Extract the file name without the extension\n", - "file_name = csv_file[last_separator_index + 1 : extension_separator_index] if last_separator_index != -1 else csv_file[:extension_separator_index]\n", - "\n", - "# Print the extracted file path and file name\n", - "print(\"File Path:\", file_path)\n", - "print(\"File Name:\", file_name)\n", - "\n", - "# Load the CSV dataset\n", - "data = pd.read_csv(csv_file)\n", - "\n", - "# Select random instances to replace\n", - "replace_indices = np.random.choice(len(data), size=int(len(data) * replace_proportion), replace=False)\n", - "\n", - "# Iterate over the selected indices and replace feature values\n", - "for index in replace_indices:\n", - " # Get the values of the current instance\n", - " instance_values = data.iloc[index, :]\n", - "\n", - " # Iterate over the features\n", - " for feature in instance_values.index:\n", - " # Check if the current feature is the one to exclude\n", - " if feature == column_to_exclude:\n", - " # Change the value of the excluded feature\n", - " data.at[index, feature] = str(instance_values[feature]) + \"_random\"\n", - " else:\n", - " # Compute the distribution of the feature values in the rest of the dataset\n", - " feature_distribution = data[data.index != index][feature]\n", - "\n", - " # Generate a new feature value that resembles the rest of the dataset\n", - " new_value = np.random.choice(feature_distribution)\n", - "\n", - " # Assign the new feature value to the current instance\n", - " data.at[index, feature] = new_value\n", - "\n", - "# Save the updated dataset with the simulated features\n", - "output_file = './OtherData/'+file_name+'_rep.csv'\n", - "data.to_csv(output_file, index=False)\n", - "print(f\"Updated dataset saved to {output_file}.\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "f8vlWxqWdPUm" - }, - "source": [ - "# Create Custom HCC dataset for STREAMLINE Testing (with some text variables)\n", - "Starting with the original HCC dataset, we make custom modifications to that dataset to explicitly test different data challenges and edge case scenarios that might exist in user loaded data.\n", - "\n", - "These include:\n", - "* Removal of covariate features (i.e. gender and age at diagnosis)\n", - "* Instances with a missing class label\n", - "* Instances with a high percent of missingness\n", - "* Simulate numerically encoded categorical features (with 2, 3,or 4 state values)\n", - "* Simulate text-value categorical features (with 2, 3,or 4 state values)\n", - "* Simulate quantiative features with high missingness\n", - "* Simulate pairs of features with high correlations between them\n", - " * Both positive and negative correlations\n", - "* Add invariant features with (1) all one value, (2) all missing values, or (3) a mix of one value and missing values" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "executionInfo": { - "elapsed": 292, - "status": "ok", - "timestamp": 1691164531552, - "user": { - "displayName": "ryan urbanowicz", - "userId": "09525282221743790591" - }, - "user_tz": 420 - }, - "id": "fau-KvVEdPi9", - "outputId": "83317cd7-3e0e-4698-90c0-d333097c9374" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File Path: ./DemoData\n", - "File Name: hcc_data\n", - "Updated dataset saved to ./DemoData/hcc_data_custom.csv.\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "\n", - "random_seed = 42\n", - "np.random.seed(seed=random_seed)\n", - "\n", - "class_label = 'Class'\n", - "instance_ID_label = 'InstanceID'\n", - "features_to_remove = ['Gender','Age at diagnosis']\n", - "cat_feature_list = [2,3,4]\n", - "cat_feature_list_text = [2,3,4]\n", - "miss_feature_list = [0.6,0.7]\n", - "corr_feature_list = [-1.0,0.9,1.0]\n", - "num_nolabel_instances = 2\n", - "miss_instance_list = [0.7,0.8]\n", - "\n", - "# Specify the path to your existing CSV dataset\n", - "csv_file = \"./DemoData/hcc_data.csv\"\n", - "\n", - "def remove_features(data, features_to_remove):\n", - " return data.drop(features_to_remove, axis=1)\n", - "\n", - "def generate_categorical_feature(num_categories, num_rows):\n", - " categories = [f\"Category {i+1}\" for i in range(num_categories)]\n", - " return np.random.choice(categories, size=num_rows)\n", - "\n", - "def generate_categorical_feature_numerical_encode(num_categories, num_rows):\n", - " categories = np.arange(1, num_categories + 1)\n", - " return np.random.choice(categories, size=num_rows)\n", - "\n", - "def generate_quantitative_feature(num_rows, missing_percentage):\n", - " data = np.random.rand(num_rows)\n", - " missing_mask = np.random.choice([False, True], size=num_rows, p=[1-missing_percentage, missing_percentage])\n", - " data[missing_mask] = np.nan\n", - " return data\n", - "\n", - "def generate_correlated_values(feature1, correlation):\n", - " # Generate the second feature correlated with the first feature\n", - " feature2 = correlation * feature1 + np.random.normal(0, np.sqrt(1 - correlation**2), len(feature1))\n", - " return feature2\n", - "\n", - "# Find the last occurrence of the directory separator '/'\n", - "last_separator_index = csv_file.rfind('/')\n", - "\n", - "# Extract the file path\n", - "file_path = csv_file[:last_separator_index] if last_separator_index != -1 else ''\n", - "\n", - "# Find the extension separator '.'\n", - "extension_separator_index = csv_file.rfind('.')\n", - "\n", - "# Extract the file name without the extension\n", - "file_name = csv_file[last_separator_index + 1 : extension_separator_index] if last_separator_index != -1 else csv_file[:extension_separator_index]\n", - "\n", - "# Print the extracted file path and file name\n", - "print(\"File Path:\", file_path)\n", - "print(\"File Name:\", file_name)\n", - "\n", - "# Load the existing CSV dataset\n", - "data = pd.read_csv(csv_file)\n", - "\n", - "# Remove specified features from original dataset\n", - "data = remove_features(data, features_to_remove)\n", - "\n", - "# Generate random instances resembling existing dataset and add to the dataset that have missing class label\n", - "i = 0\n", - "for _ in range(num_nolabel_instances):\n", - " random_instance = data.sample(n=1, replace=True)\n", - " random_instance[class_label] = np.nan\n", - " random_instance[instance_ID_label] = 'no_class_'+str(i)\n", - " data = pd.concat([data, random_instance], ignore_index=True)\n", - " i += 1\n", - "\n", - "# Generate random instances resembling existing dataset but have some percentage of missingness\n", - "i = 0\n", - "for miss in miss_instance_list:\n", - " random_instance = data.sample(n=1, replace=True)\n", - " num_features = len(data.columns)\n", - " num_missing_values = int(num_features * miss)\n", - " random_features = np.random.choice(data.columns, size=num_missing_values, replace=False)\n", - " random_instance[random_features] = np.nan\n", - " random_instance[instance_ID_label] = 'miss_'+str(i)+'_'+str(miss)\n", - " # Randomly choose a value of 0 or 1\n", - " value = np.random.choice([0, 1])\n", - " random_instance[class_label] = value\n", - " data = pd.concat([data, random_instance], ignore_index=True)\n", - " i += 1\n", - "\n", - "# Simulate the categorical feature and add it to the dataset\n", - "num_rows = len(data)\n", - "for cat in cat_feature_list:\n", - " simulated_categorical_feature = generate_categorical_feature_numerical_encode(cat, num_rows)\n", - " data['Sim_Cat_'+str(cat)] = simulated_categorical_feature\n", - "\n", - "# Simulate the text-based categorical feature and add it to the dataset\n", - "num_rows = len(data)\n", - "for cat in cat_feature_list_text:\n", - " simulated_categorical_feature = generate_categorical_feature(cat, num_rows)\n", - " data['Sim_Text_Cat_'+str(cat)] = simulated_categorical_feature\n", - "\n", - "# Simulate the quantitative feature and add it to the dataset\n", - "for miss in miss_feature_list:\n", - " simulated_quant_feature = generate_quantitative_feature(num_rows, miss)\n", - " data['Sim_Miss_'+str(miss)] = simulated_quant_feature\n", - "\n", - "# Simulate the correlated variables and add them to the dataset\n", - "for corr in corr_feature_list:\n", - " # Generate a new random quantitative feature\n", - " new_feature = np.random.rand(len(data))\n", - "\n", - " # Generate the correlated feature based on the new feature\n", - " correlated_feature = generate_correlated_values(new_feature, corr)\n", - "\n", - " # Add the new features to the dataset\n", - " data['Sim_Cor_'+str(corr)+'_A'] = new_feature\n", - " data['Sim_Cor_'+str(corr)+'_B'] = correlated_feature\n", - "\n", - "#Simulate invariant features\n", - "data['Invariant_Val'] = 42\n", - "data['Invariant_NA'] = np.nan\n", - "num_missing = int(len(data) * 0.1)\n", - "new_column_values = [43] * (len(data) - num_missing) + [np.nan] * num_missing\n", - "np.random.shuffle(new_column_values)\n", - "data['Invariant_Val_NA'] = new_column_values\n", - "\n", - "# Shuffle the array to randomize the placement of NaN values\n", - "np.random.shuffle(new_column_values)\n", - "\n", - "# Save the updated dataset with the simulated features\n", - "output_file = './DemoData/'+file_name+'_custom.csv'\n", - "data.to_csv(output_file, index=False)\n", - "print(f\"Updated dataset saved to {output_file}.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "zf8yWymwdPrh" - }, - "source": [ - "# Create replication dataset for the custom HCC dataset\n", - "Takes the original 'Custom HCC dataset' (generated above) and then for a user defined proportion of instances, generates new values for each feature and class outcome based on the distribution of values for that respective column in the data. This effectively adds some noise to the dataset so that the replication data is different from the original HCC dataset for the demonstration of the replication phase.\n", - "\n", - "Furthermore, we make some additional custom modifications to this dataset to test aspects of the STREAMLINE replication phase. These include:\n", - "\n", - "* A random instance that includes a new categorical value for a binary text categorical feature\n", - "* A random instance that includes a new categorical value for a 3-value text categorical feature\n", - "* A random instance that includes a new categorical value for a binary categorical feature\n", - "* A random instance that includes a new categorical value in 3-value categorical feature\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "executionInfo": { - "elapsed": 6250, - "status": "ok", - "timestamp": 1691164537800, - "user": { - "displayName": "ryan urbanowicz", - "userId": "09525282221743790591" - }, - "user_tz": 420 - }, - "id": "eS2x07BbdP2G", - "outputId": "ce4e87ea-dcc0-45ba-ce09-52f269c5b02e" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File Path: ./DemoData\n", - "File Name: hcc_data_custom\n", - "Updated dataset saved to ./DemoRepData/hcc_data_custom_rep.csv.\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "\n", - "random_seed = 42\n", - "np.random.seed(seed=random_seed)\n", - "\n", - "# Specify the path to your CSV dataset\n", - "csv_file = \"./DemoData/hcc_data_custom.csv\"\n", - "\n", - "column_to_exclude = 'InstanceID'\n", - "\n", - "num_sim_instances = 4 #Number of made up instances generated in original HCC dataset (at end of the dataset) -these will not be randomized to preserve them as examples of data challenges\n", - "\n", - "# Specify the proportion of instances to replace (between 0 and 1)\n", - "replace_proportion = 0.3\n", - "\n", - "# Find the last occurrence of the directory separator '/'\n", - "last_separator_index = csv_file.rfind('/')\n", - "\n", - "# Extract the file path\n", - "file_path = csv_file[:last_separator_index] if last_separator_index != -1 else ''\n", - "\n", - "# Find the extension separator '.'\n", - "extension_separator_index = csv_file.rfind('.')\n", - "\n", - "# Extract the file name without the extension\n", - "file_name = csv_file[last_separator_index + 1 : extension_separator_index] if last_separator_index != -1 else csv_file[:extension_separator_index]\n", - "\n", - "# Print the extracted file path and file name\n", - "print(\"File Path:\", file_path)\n", - "print(\"File Name:\", file_name)\n", - "\n", - "# Load the CSV dataset\n", - "data = pd.read_csv(csv_file)\n", - "\n", - "# Select random instances to replace\n", - "replace_indices = np.random.choice(len(data)-num_sim_instances, size=int(len(data) * replace_proportion), replace=False)\n", - "\n", - "# Iterate over the selected indices and replace feature values\n", - "for index in replace_indices:\n", - " # Get the values of the current instance\n", - " instance_values = data.iloc[index, :]\n", - "\n", - " # Iterate over the features\n", - " for feature in instance_values.index:\n", - " # Check if the current feature is the one to exclude\n", - " if feature == column_to_exclude:\n", - " # Change the value of the excluded feature\n", - " data.at[index, feature] = str(instance_values[feature]) + \"_random\"\n", - " else:\n", - " # Compute the distribution of the feature values in the rest of the dataset\n", - " feature_distribution = data[data.index != index][feature]\n", - "\n", - " # Generate a new feature value that resembles the rest of the dataset\n", - " new_value = np.random.choice(feature_distribution)\n", - "\n", - " # Assign the new feature value to the current instance\n", - " data.at[index, feature] = new_value\n", - "\n", - "# Generate random instance that includes a new categorical value in binary text categorical feature\n", - "random_instance = data.sample(n=1, replace=True)\n", - "# Randomly choose a value of 0 or 1\n", - "value = np.random.choice([0, 1])\n", - "random_instance[class_label] = value\n", - "random_instance[instance_ID_label] = 'new_val_cat_text_binary'\n", - "random_instance['Sim_Text_Cat_2'] = 'Category 5' # assign new value\n", - "data = pd.concat([data, random_instance], ignore_index=True)\n", - "\n", - "# Generate random instance that includes a new categorical value in 3-value text categorical feature\n", - "random_instance = data.sample(n=1, replace=True)\n", - "# Randomly choose a value of 0 or 1\n", - "value = np.random.choice([0, 1])\n", - "random_instance[class_label] = value\n", - "random_instance[instance_ID_label] = 'new_val_cat_text_3'\n", - "random_instance['Sim_Text_Cat_3'] = 'Category 7' # assign new value\n", - "data = pd.concat([data, random_instance], ignore_index=True)\n", - "\n", - "# Generate random instance that includes a new categorical value in binary categorical feature\n", - "random_instance = data.sample(n=1, replace=True)\n", - "# Randomly choose a value of 0 or 1\n", - "value = np.random.choice([0, 1])\n", - "random_instance[class_label] = value\n", - "random_instance[instance_ID_label] = 'new_val_cat_binary'\n", - "random_instance['Sim_Cat_2'] = 7 # assign new value\n", - "data = pd.concat([data, random_instance], ignore_index=True)\n", - "\n", - "# Generate random instance that includes a new categorical value in 3-value categorical feature\n", - "random_instance = data.sample(n=1, replace=True)\n", - "# Randomly choose a value of 0 or 1\n", - "value = np.random.choice([0, 1])\n", - "random_instance[class_label] = value\n", - "random_instance[instance_ID_label] = 'new_val_cat_3'\n", - "random_instance['Sim_Cat_3'] = 16 # assign new value\n", - "data = pd.concat([data, random_instance], ignore_index=True)\n", - "\n", - "#Add exceptions to the invariant data columns\n", - "data.at[1, 'Invariant_Val'] = 41\n", - "data.at[2, 'Invariant_NA'] = 41\n", - "data.at[3, 'Invariant_Val_NA'] = 41\n", - "\n", - "# Save the updated dataset with the simulated features\n", - "output_file = './DemoRepData/'+file_name+'_rep.csv'\n", - "data.to_csv(output_file, index=False)\n", - "print(f\"Updated dataset saved to {output_file}.\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "authorship_tag": "ABX9TyNtiZnKEe8on4QGhDImr0Um", - "provenance": [] - }, - "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.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/data/OtherData/hcc_data_rep.csv b/data/OtherData/hcc_data_rep.csv deleted file mode 100644 index b3329921..00000000 --- a/data/OtherData/hcc_data_rep.csv +++ /dev/null @@ -1,166 +0,0 @@ -InstanceID,Gender,Symptoms ,Alcohol,Hepatitis B Surface Antigen,Hepatitis B e Antigen,Hepatitis B Core Antibody,Hepatitis C Virus Antibody,Cirrhosis,Endemic Countries,Smoking,Diabetes,Obesity,Hemochromatosis,Arterial Hypertension,Chronic Renal Insufficiency,Human Immunodeficiency Virus,Nonalcoholic Steatohepatitis,Esophageal Varices,Splenomegaly,Portal Hypertension,Portal Vein Thrombosis,Liver Metastasis,Radiological Hallmark,Age at diagnosis,Grams of Alcohol per day,Packs of cigarets per year,Performance Status*,Encephalopathy degree*,Ascites degree*,International Normalised Ratio*,Alpha-Fetoprotein (ng/mL),Haemoglobin (g/dL),Mean Corpuscular Volume,Leukocytes(G/L),Platelets,Albumin (mg/dL),Total Bilirubin(mg/dL),Alanine transaminase (U/L),Aspartate transaminase (U/L),Gamma glutamyl transferase (U/L),Alkaline phosphatase (U/L),Total Proteins (g/dL),Creatinine (mg/dL),Number of Nodules,Major dimension of nodule (cm),Direct Bilirubin (mg/dL),Iron,Oxygen Saturation (%),Ferritin (ng/mL),Class -0,1,0.0,1,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,67,137.0,15.0,0,1.0,1.0,1.53,95.0,13.7,106.6,4.9,99.0,3.4,2.1,34.0,41.0,183.0,150.0,7.1,0.7,1.0,3.5,0.5,,,,0 -1,0,,0,0.0,0.0,0.0,1.0,1,,,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,62,0.0,,0,1.0,1.0,,,,,,,,,,,,,,,1.0,1.8,,,,,0 -2_random,0,0.0,1,0.0,0.0,,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,86,100.0,0.0,1,1.0,2.0,1.45,4181.0,14.4,90.0,,170000.0,3.4,2.6,69.0,158.0,294.0,171.0,5.9,2.14,3.0,2.0,,,,,1 -3,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,77,40.0,30.0,0,1.0,1.0,0.95,2440.0,13.4,97.1,9.0,279.0,3.7,0.4,16.0,64.0,94.0,174.0,8.1,1.11,2.0,15.7,0.2,,,,1 -4,1,1.0,1,1.0,0.0,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,76,100.0,30.0,0,1.0,1.0,0.94,49.0,14.3,95.1,6.4,199.0,4.1,0.7,147.0,306.0,173.0,109.0,6.9,1.8,1.0,9.0,,59.0,15.0,22.0,0 -5,1,0.0,1,0.0,,0.0,0.0,1,0.0,,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,75,,,1,1.0,2.0,1.58,110.0,13.4,91.5,5.4,85.0,3.4,3.5,91.0,122.0,242.0,396.0,5.6,0.9,1.0,10.0,1.4,53.0,22.0,111.0,1 -6,1,0.0,0,0.0,,1.0,1.0,1,0.0,0.0,1.0,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,49,0.0,0.0,0,1.0,1.0,1.4,138.9,10.4,102.0,3.2,42000.0,2.35,2.72,119.0,183.0,143.0,211.0,7.3,0.8,5.0,2.6,2.19,171.0,126.0,1452.0,1 -7,1,1.0,1,0.0,,0.0,0.0,1,0.0,1.0,1.0,,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,61,,20.0,3,1.0,1.0,1.46,9860.0,10.8,92.0,3.0,58.0,3.1,3.2,79.0,108.0,184.0,300.0,7.1,0.52,2.0,9.0,1.3,42.0,25.0,706.0,1 -8,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,50,100.0,32.0,1,1.0,2.0,3.14,8.8,11.9,107.5,4.9,70.0,1.9,3.3,26.0,59.0,115.0,63.0,6.1,0.59,1.0,6.4,1.2,85.0,73.0,982.0,0 -9_random,0,0.0,1,0.0,,0.0,0.0,1,0.0,1.0,0.0,1.0,,0.0,0.0,,0.0,0.0,1.0,1.0,0.0,0.0,1.0,71,,,2,3.0,1.0,1.03,4.9,14.4,92.4,5.8,137000.0,3.2,40.5,56.0,116.0,69.0,44.0,6.1,0.72,5.0,5.0,0.2,131.0,,307.0,0 -10,1,0.0,1,0.0,0.0,0.0,1.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,41,,,0,1.0,2.0,1.05,100809.0,13.0,94.2,5.7,196.0,4.4,3.0,90.0,334.0,494.0,236.0,7.6,0.8,5.0,,1.1,,,,1 -11,1,0.0,1,0.0,0.0,0.0,1.0,1,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,,0.0,1.0,0.0,0.0,1.0,74,,0.0,0,1.0,1.0,1.33,86.0,15.7,96.7,4.0,61.0,3.7,1.3,132.0,168.0,113.0,154.0,,7.6,5.0,1.9,0.3,144.0,41.0,277.0,0 -12_random,0,1.0,1,,0.0,0.0,1.0,1,,1.0,0.0,0.0,,1.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,56,,0.0,0,1.0,1.0,1.07,41.0,12.6,85.5,5.2,160000.0,4.2,7.9,63.0,75.0,90.0,154.0,7.7,0.52,5.0,2.0,3.8,61.0,10.0,,1 -13,1,,0,0.0,0.0,0.0,1.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,56,0.0,,0,1.0,1.0,1.2,6.6,13.7,93.8,4.1,91000.0,4.5,1.0,103.0,96.0,205.0,70.0,8.8,0.88,1.0,22.0,,82.0,24.0,,0 -14,1,0.0,1,0.0,0.0,0.0,0.0,1,0.0,,1.0,0.0,0.0,1.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,1.0,63,,,2,2.0,2.0,1.25,29.0,13.5,93.0,6.0,128.0,3.15,10.5,76.0,116.0,165.0,163.0,7.3,1.07,4.0,4.5,4.5,197.0,84.0,302.0,0 -15_random,1,1.0,0,0.0,0.0,0.0,1.0,1,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,74,100.0,0.0,0,1.0,1.0,1.63,20.0,13.6,102.9,5300.0,159000.0,4.2,0.5,33.0,57.0,101.0,165.0,8.1,0.88,1.0,9.0,0.3,,34.0,307.0,1 -16_random,1,0.0,0,0.0,,0.0,0.0,1,,1.0,0.0,,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,67,80.0,,1,3.0,3.0,1.33,2.0,10.8,97.2,7100.0,406000.0,2.4,0.6,71.0,154.0,164.0,466.0,7.5,0.86,2.0,20.0,0.6,42.0,18.0,18.0,0 -17,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,,0.0,0.0,0.0,,1.0,1.0,1.0,1.0,1.0,1.0,60,100.0,60.0,2,1.0,1.0,1.05,9.2,10.3,103.7,5.4,159.0,3.8,0.5,56.0,91.0,459.0,146.0,5.4,1.23,5.0,13.5,3.8,187.0,58.0,443.0,0 -18_random,1,1.0,0,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,0.0,93,0.0,0.0,1,1.0,1.0,3.16,42.0,12.0,90.1,7100.0,113.0,3.9,1.0,37.0,30.0,113.0,130.0,7.8,0.7,5.0,4.0,,0.0,,742.0,1 -19_random,1,1.0,1,0.0,0.0,0.0,0.0,1,,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,1.0,77,0.0,,1,1.0,1.0,1.55,5.8,10.7,93.7,3.8,38000.0,3.0,0.5,106.0,41.0,108.0,174.0,7.7,0.9,2.0,8.8,1.9,26.0,,,0 -20,1,0.0,1,0.0,0.0,0.0,0.0,1,,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,71,200.0,60.0,0,1.0,1.0,1.29,19.6,11.7,101.0,2600.0,109000.0,3.6,1.7,13.0,35.0,23.0,141.0,7.3,0.68,1.0,2.5,0.7,152.6,,76.9,0 -21,1,0.0,1,0.0,0.0,1.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,0.0,0.0,73,80.0,47.0,0,1.0,1.0,1.06,3.9,16.4,90.7,7.8,187.0,4.5,1.0,54.0,47.0,52.0,97.0,6.3,0.75,1.0,6.8,0.2,87.0,26.0,84.0,0 -22_random,1,1.0,0,0.0,,0.0,0.0,1,0.0,1.0,0.0,0.0,,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,0.0,87,70.0,0.0,3,1.0,1.0,1.28,42.0,14.3,96.6,3100.0,77000.0,3.1,0.8,97.0,,311.0,139.0,8.1,0.53,1.0,2.1,4.1,,,316.0,1 -23,1,1.0,1,0.0,0.0,0.0,0.0,1,1.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,1.0,64,200.0,60.0,1,1.0,1.0,4.82,185.0,10.7,88.1,5.0,194000.0,3.6,3.8,217.0,86.0,879.0,396.0,7.0,0.53,5.0,15.0,1.6,,,,1 -24_random,1,0.0,0,0.0,0.0,0.0,1.0,1,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,0.0,46,,7.5,0,1.0,2.0,1.25,,15.6,89.3,2.2,70000.0,4.2,3.9,16.0,41.0,279.0,302.0,7.2,0.7,3.0,2.2,0.5,,25.0,,0 -25,1,0.0,1,0.0,,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,80,100.0,0.0,2,1.0,1.0,1.33,13327.0,13.7,94.3,5.2,110.0,3.1,1.6,52.0,107.0,465.0,233.0,8.4,0.79,5.0,,0.7,93.0,31.0,79.0,0 -26_random,1,0.0,1,,0.0,0.0,1.0,1,0.0,,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,,1.0,0.0,0.0,0.0,76,75.0,67.5,4,1.0,1.0,1.4,6.6,13.0,102.4,,118000.0,3.1,1.3,31.0,60.0,108.0,44.0,7.2,0.7,1.0,5.9,19.8,,24.0,,0 -27,1,,1,1.0,0.0,1.0,0.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,57,,,0,1.0,1.0,1.37,5.9,15.5,88.2,4.9,113.0,4.5,3.2,36.0,65.0,34.0,111.0,,,2.0,4.0,1.0,180.0,56.0,,0 -28,1,0.0,1,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,61,60.0,67.5,1,1.0,1.0,1.3,3255.0,12.2,89.5,4.4,108.0,3.0,1.1,59.0,85.0,419.0,293.0,7.7,0.67,2.0,6.5,0.4,94.0,27.0,70.0,1 -29_random,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,1.0,63,75.0,0.0,2,1.0,1.0,3.16,615.0,14.9,83.9,4.4,270.0,3.1,0.8,195.0,92.0,924.0,297.0,16.8,1.2,5.0,9.3,1.3,55.0,,220.0,0 -30_random,1,1.0,1,,,0.0,0.0,1,,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,87,0.0,40.0,2,1.0,1.0,2.42,14177.0,13.2,90.0,5.1,187.0,3.4,0.8,37.0,31.0,125.0,161.0,7.1,1.5,5.0,2.4,,,,,0 -31_random,1,1.0,0,0.0,,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,0.0,1.0,0.0,0.0,1.0,71,75.0,60.0,4,,1.0,1.17,5.8,16.0,96.1,7.6,114.0,3.2,1.1,69.0,354.0,175.0,109.0,6.5,1.6,5.0,4.9,1.9,,,,0 -32,1,1.0,1,,,,0.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,67,100.0,,0,1.0,1.0,1.32,7.7,15.7,96.1,9.1,268000.0,3.4,0.6,20.0,29.0,49.0,135.0,8.2,0.9,2.0,,,,,,0 -33,1,1.0,1,0.0,,0.0,0.0,1,,,0.0,0.0,0.0,1.0,0.0,0.0,,0.0,0.0,0.0,0.0,0.0,1.0,77,,,0,1.0,1.0,1.24,266.0,13.7,97.7,13000.0,170000.0,4.2,0.5,68.0,85.0,232.0,227.0,16.8,1.72,1.0,5.9,,,,,0 -34,1,1.0,1,1.0,0.0,1.0,0.0,1,,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,62,,0.0,0,1.0,1.0,1.28,5689.0,14.3,99.6,6.8,77.0,3.8,1.7,154.0,102.0,184.0,184.0,6.9,0.89,2.0,3.0,0.77,,,,0 -35,1,,0,1.0,,1.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,76,0.0,0.0,0,1.0,1.0,0.96,14.2,14.8,98.5,4.95,187.0,4.2,0.77,43.0,86.0,89.0,113.0,6.7,0.95,3.0,8.8,0.37,,,,0 -36_random,1,1.0,1,1.0,0.0,0.0,0.0,1,,,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,1.0,1.0,0.0,1.0,61,75.0,0.0,2,1.0,2.0,1.71,3.9,14.1,90.0,6.1,113.0,3.1,1.3,195.0,143.0,80.0,188.0,7.2,1.11,5.0,6.0,,124.0,15.0,,1 -37,1,1.0,1,0.0,0.0,0.0,0.0,1,,1.0,1.0,0.0,,1.0,0.0,0.0,,,0.0,1.0,0.0,0.0,1.0,84,200.0,30.0,1,1.0,2.0,1.24,633.0,13.0,96.5,7200.0,143000.0,2.3,1.1,40.0,58.0,322.0,209.0,6.7,1.4,5.0,4.9,0.2,57.0,25.0,134.0,1 -38,1,0.0,1,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,70,100.0,0.0,0,1.0,1.0,1.09,5.4,14.9,105.0,7.2,230000.0,4.2,1.3,18.0,26.0,174.0,92.0,7.3,0.8,2.0,6.0,0.3,,,,0 -39,1,1.0,1,1.0,0.0,1.0,1.0,1,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,,0.0,,0.0,1.0,1.0,59,200.0,0.0,0,1.0,1.0,1.42,479.0,11.3,82.2,9500.0,160000.0,3.1,1.4,113.0,143.0,924.0,288.0,7.9,0.98,5.0,17.0,0.6,,,,0 -40,0,,0,0.0,0.0,1.0,1.0,1,0.0,0.0,0.0,0.0,,1.0,0.0,0.0,0.0,,,,0.0,0.0,1.0,71,0.0,0.0,0,1.0,1.0,1.18,19.0,13.9,88.3,6.86,201000.0,4.4,0.8,142.0,117.0,123.0,104.0,8.5,0.74,2.0,3.3,0.3,143.0,50.18,120.0,0 -41,1,0.0,0,0.0,0.0,1.0,0.0,1,0.0,0.0,1.0,1.0,0.0,1.0,0.0,0.0,0.0,,0.0,0.0,,,0.0,66,0.0,0.0,0,1.0,1.0,1.21,2.8,15.7,92.7,15.4,188000.0,4.1,0.7,299.0,553.0,196.0,68.0,6.5,1.3,1.0,5.0,0.3,,,,0 -42_random,1,1.0,0,0.0,,0.0,0.0,1,,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,1.0,71,75.0,0.0,4,1.0,3.0,1.49,615.0,14.6,109.3,5.5,251.0,2.7,1.0,26.0,34.0,993.0,472.0,7.1,3.95,5.0,2.0,0.5,,,,0 -43,1,0.0,1,,,,,1,0.0,,0.0,1.0,0.0,0.0,0.0,,1.0,1.0,1.0,1.0,0.0,0.0,1.0,71,75.0,,0,1.0,1.0,1.17,5.0,15.1,104.1,4.3,65000.0,3.8,2.5,61.0,56.0,239.0,56.0,7.3,0.7,1.0,2.0,0.2,,,,0 -44,0,0.0,0,0.0,0.0,1.0,1.0,1,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,52,0.0,0.0,0,1.0,1.0,1.71,237.0,15.6,98.1,4.3,88.0,3.2,2.2,30.0,52.0,72.0,97.0,6.7,0.86,5.0,2.2,0.5,,,,0 -45_random,1,0.0,0,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,77,75.0,,4,1.0,3.0,1.41,50655.0,14.3,91.6,6.4,121000.0,2.2,2.4,24.0,,540.0,139.0,6.8,2.69,5.0,2.6,1.9,131.0,,,1 -46,0,1.0,0,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,,45,0.0,0.0,0,1.0,1.0,,,,,,,,,,,,,,,,,,,,,0 -47,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,0.0,66,,,1,1.0,2.0,1.64,16.0,14.0,102.9,11.5,277000.0,3.1,6.8,140.0,244.0,795.0,595.0,7.2,0.79,1.0,2.3,4.1,63.0,34.0,888.0,1 -48,1,1.0,0,0.0,0.0,0.0,0.0,0,0.0,1.0,1.0,0.0,0.0,1.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,80,0.0,80.0,0,1.0,1.0,1.33,163.0,10.6,96.2,9900.0,280000.0,3.3,1.0,28.0,57.0,236.0,171.0,7.5,1.38,1.0,19.0,,45.0,21.0,802.0,1 -49,1,,1,0.0,,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,58,,40.0,0,1.0,1.0,1.49,20.0,15.0,96.7,9.0,78.0,4.6,2.1,40.0,49.0,137.0,109.0,7.6,0.8,1.0,2.0,0.4,184.0,59.0,905.0,0 -50,0,1.0,0,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,1.0,1.0,27,0.0,0.0,2,1.0,1.0,0.97,46.0,10.5,78.7,20.9,251.0,2.4,0.3,31.0,185.0,91.0,539.0,5.0,0.38,5.0,20.0,0.3,,,,1 -51_random,0,1.0,1,0.0,,0.0,1.0,1,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,,1.0,1.0,0.0,0.0,1.0,0.0,64,,0.0,0,1.0,2.0,1.37,2.1,11.8,106.0,6.1,122.0,3.28,2.1,262.0,58.0,108.0,151.0,,0.8,3.0,4.7,0.3,,,,1 -52,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,73,,0.0,0,1.0,1.0,1.33,4.7,11.8,80.2,3.7,99.0,4.1,0.7,50.0,47.0,67.0,62.0,7.4,0.77,1.0,2.3,,104.0,37.0,635.0,0 -53,1,,1,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,50,,0.0,0,1.0,1.0,1.65,7.3,15.3,93.7,3500.0,57000.0,,1.4,111.0,93.0,294.0,130.0,,0.76,2.0,2.0,0.3,184.0,2.26,59.0,0 -54,1,1.0,1,0.0,0.0,0.0,1.0,1,,1.0,0.0,,,0.0,0.0,0.0,,1.0,1.0,1.0,1.0,0.0,1.0,51,100.0,30.0,3,1.0,2.0,1.35,1898.0,12.4,95.1,9.8,216.0,2.7,8.2,164.0,523.0,433.0,397.0,6.7,0.82,1.0,2.1,5.5,56.0,27.0,742.0,1 -55_random,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,1.0,1.0,0.0,,1.0,0.0,1.0,1.0,0.0,0.0,1.0,72,100.0,,0,2.0,1.0,1.17,185.0,10.3,94.0,7100.0,194.0,3.2,5.8,31.0,63.0,277.0,280.0,7.2,0.86,2.0,,5.5,184.0,,,0 -56_random,1,1.0,0,,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,0.0,44,0.0,67.5,0,1.0,1.0,1.28,2.9,13.1,90.7,4800.0,307000.0,3.1,0.6,132.0,31.0,123.0,89.0,7.7,0.75,5.0,2.0,,94.0,,832.0,1 -57,1,,1,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,1.0,65,100.0,,0,1.0,1.0,1.24,2.6,10.3,83.0,6.1,1.71,3.9,0.8,11.0,28.0,77.0,120.0,7.0,0.58,1.0,4.7,0.85,32.0,10.0,18.0,0 -58,1,,1,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,,,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,1.0,72,70.0,0.0,3,2.0,2.0,1.96,12.0,10.9,102.0,4.1,99.0,1.9,4.2,73.0,85.0,470.0,263.0,7.0,0.99,1.0,8.5,1.9,44.0,20.0,176.0,1 -59,1,1.0,0,,,,,0,0.0,1.0,1.0,0.0,,1.0,1.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,82,0.0,,0,1.0,1.0,1.11,,18.7,92.4,6900.0,270000.0,4.0,0.9,35.0,73.0,115.0,103.0,6.8,1.24,1.0,10.0,,,,,1 -60_random,1,1.0,0,,0.0,0.0,1.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,0.0,56,75.0,,0,1.0,3.0,1.18,,18.7,89.5,6.1,91000.0,4.1,0.6,53.0,34.0,45.3,474.0,,0.52,5.0,9.0,19.8,,,,0 -61,1,1.0,1,0.0,0.0,1.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,56,100.0,40.0,0,2.0,2.0,1.46,41.0,14.6,100.8,5.5,42000.0,3.1,3.7,121.0,165.0,101.0,207.0,6.3,0.69,1.0,3.0,1.9,224.0,95.0,363.0,0 -62,0,0.0,1,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,68,,30.0,2,1.0,2.0,1.94,,11.5,97.4,5700.0,77000.0,2.7,4.9,34.0,48.0,46.0,178.0,6.1,0.62,1.0,4.6,2.2,,,,0 -63,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,72,300.0,,3,1.0,3.0,1.57,2.0,12.6,96.6,2.9,76000.0,3.5,2.4,33.0,40.0,110.0,166.0,,0.77,1.0,2.0,0.5,,,,0 -64,1,0.0,0,0.0,0.0,0.0,0.0,0,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,,,,,0.0,0.0,0.0,66,0.0,0.0,0,1.0,1.0,1.29,7.0,12.1,95.1,3.8,77000.0,3.8,1.4,37.0,38.0,194.0,161.0,6.7,0.71,1.0,10.0,0.5,0.0,0.0,0.0,0 -65,0,1.0,0,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,0.0,0.0,1.0,0.0,40,0.0,0.0,2,1.0,1.0,1.17,3.1,15.1,86.0,8.9,275000.0,2.8,1.3,74.0,50.0,23.0,104.0,5.4,0.6,5.0,7.8,0.2,46.0,18.0,,1 -66_random,1,,1,,0.0,0.0,1.0,1,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,1.0,73,75.0,,3,1.0,1.0,1.3,4.9,9.5,89.7,13.3,51000.0,3.1,0.5,110.0,108.0,279.0,207.0,6.5,0.52,1.0,,0.5,44.0,,856.0,0 -67,1,1.0,1,0.0,0.0,1.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,63,100.0,0.0,0,1.0,1.0,2.07,1.7,9.5,99.2,3300.0,79000.0,2.1,1.6,56.0,82.0,134.0,113.0,37.0,0.4,1.0,2.7,0.2,94.0,37.0,48.0,0 -68,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,1.0,1.0,72,100.0,0.0,0,1.0,2.0,1.3,249.0,12.7,100.3,5.5,114.0,3.1,3.9,21.0,42.0,40.0,108.0,5.8,0.9,5.0,8.0,1.2,37.0,17.0,419.0,1 -69_random,1,0.0,1,,0.0,1.0,1.0,1,0.0,,1.0,0.0,,0.0,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,64,0.0,60.0,0,1.0,1.0,1.79,2089.0,13.0,91.6,4.5,178000.0,2.9,7.9,28.0,73.0,196.0,109.0,8.1,0.7,1.0,9.0,0.4,44.0,,832.0,0 -70,0,1.0,0,0.0,0.0,1.0,0.0,1,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,23,0.0,0.0,0,1.0,1.0,1.17,358.0,12.7,74.0,2.2,51.0,2.9,2.8,53.0,41.0,54.0,94.0,4.9,0.2,2.0,5.4,0.8,50.0,16.0,20.0,0 -71,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,1.0,1.0,59,75.0,44.0,3,2.0,2.0,1.01,1810346.0,13.0,102.1,8300.0,433000.0,3.4,1.9,138.0,86.0,1575.0,417.0,6.5,0.64,5.0,15.0,1.1,,,,0 -72,1,1.0,1,0.0,0.0,0.0,0.0,1,,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,,1.0,1.0,1.0,1.0,0.0,82,50.0,48.0,2,1.0,2.0,1.53,33502.0,14.4,101.1,11.6,109.0,3.1,2.3,27.0,80.0,177.0,1.28,6.7,1.5,5.0,4.0,0.8,26.0,15.0,227.0,0 -73,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,1.0,1.0,1.0,67,,0.0,0,1.0,1.0,0.94,20.0,13.0,92.0,6.9,222000.0,3.7,0.6,162.0,354.0,1390.0,684.0,7.1,0.81,5.0,,,,,,1 -74,1,1.0,1,0.0,,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,61,,15.0,0,1.0,1.0,1.15,2.5,14.9,92.3,6.0,159000.0,3.8,1.0,28.0,38.0,74.0,101.0,7.4,1.1,5.0,7.5,0.3,61.0,,255.0,0 -75_random,1,,1,0.0,0.0,1.0,0.0,1,,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,65,,,4,1.0,1.0,1.3,3.7,,83.5,,96000.0,4.4,0.6,62.0,58.0,108.0,109.0,5.6,0.85,1.0,7.0,,131.0,,316.0,1 -76,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0,67,,,2,1.0,2.0,3.16,4181.0,9.1,103.6,5.1,128000.0,3.0,2.2,57.0,91.0,115.0,165.0,7.7,0.83,1.0,4.5,1.2,72.0,29.5,355.0,1 -77,1,1.0,1,0.0,0.0,0.0,0.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,0.0,0.0,1.0,78,80.0,,0,1.0,1.0,1.45,5.1,14.4,100.2,7.1,77000.0,4.1,0.9,43.0,63.0,540.0,114.0,7.0,1.09,5.0,,,,,,0 -78_random,1,0.0,0,0.0,0.0,0.0,1.0,1,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,36,75.0,0.0,0,1.0,2.0,1.66,50655.0,14.3,90.6,4.5,78000.0,4.4,1.0,30.0,71.0,879.0,105.0,5.6,1.11,5.0,13.0,1.9,,59.0,,0 -79,1,,1,0.0,0.0,0.0,1.0,1,,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,51,100.0,34.5,2,2.0,2.0,2.08,2.9,10.4,91.1,5.8,91000.0,2.4,16.0,123.0,145.0,109.0,190.0,5.9,0.9,0.0,,9.6,,,,0 -80,1,1.0,1,,,,,1,0.0,,1.0,0.0,0.0,1.0,1.0,0.0,,,1.0,1.0,0.0,1.0,1.0,74,,,3,2.0,1.0,1.32,2.5,12.6,83.7,9.8,102000.0,3.3,1.2,29.0,43.0,196.0,204.0,7.3,1.1,5.0,,0.5,,,,1 -81,1,0.0,1,0.0,,0.0,0.0,1,0.0,,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,56,100.0,,1,2.0,1.0,1.63,5.04,15.8,99.0,5.8,75000.0,3.5,4.6,93.0,85.0,193.0,165.0,6.6,0.7,1.0,6.0,1.7,200.0,87.0,316.0,0 -82_random,1,0.0,1,0.0,0.0,1.0,1.0,1,,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,0.0,1.0,59,,0.0,1,1.0,1.0,1.79,185.0,14.9,104.5,6.1,309000.0,3.44,0.5,54.0,86.0,194.0,188.0,,4.82,1.0,4.9,0.2,94.0,,18.0,0 -83,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,83,100.0,,2,1.0,3.0,1.48,2.6,12.7,106.0,3.8,80.0,2.9,3.4,34.0,53.0,156.0,207.0,7.2,,2.0,4.1,1.4,105.0,69.0,221.0,1 -84_random,1,0.0,1,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,71,100.0,32.0,2,1.0,1.0,1.18,28274.0,14.4,87.4,44.6,38000.0,3.1,1.1,34.0,87.0,184.0,263.0,5.8,0.77,5.0,8.8,0.3,,59.0,70.0,0 -85_random,1,0.0,0,0.0,0.0,0.0,,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,0.0,0.0,0.0,1.0,65,,,2,1.0,1.0,1.32,811.0,12.2,99.6,5400.0,38000.0,3.7,9.8,34.0,42.0,232.0,396.0,7.4,0.69,5.0,3.0,22.1,,,,0 -86,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,0.0,1.0,1.0,71,,,1,1.0,1.0,1.08,2.79,12.6,83.9,7100.0,284000.0,,,28.0,46.0,70.0,213.0,,0.48,5.0,,,26.0,8.0,,0 -87,1,0.0,0,0.0,0.0,1.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,0.0,0.0,1.0,52,0.0,33.0,0,1.0,2.0,,42.0,15.8,97.9,4.2,142000.0,4.2,0.5,74.0,62.0,38.0,70.0,7.5,0.77,3.0,1.5,,120.0,35.0,30.0,0 -88,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,74,100.0,,0,1.0,2.0,1.37,457.0,11.7,70.6,5.7,138000.0,4.1,2.1,22.0,33.0,33.0,90.0,9.7,1.6,5.0,5.6,0.9,13.0,3.0,28.0,1 -89,1,0.0,1,0.0,0.0,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,61,,50.0,1,2.0,3.0,1.23,,9.5,90.0,7.6,38000.0,2.2,1.5,59.0,51.0,993.0,474.0,3.9,2.69,1.0,2.0,1.0,,,,0 -90,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,0.0,69,100.0,0.0,2,1.0,3.0,1.41,123.0,10.1,89.5,2.3,89000.0,4.0,4.3,31.0,60.0,75.0,177.0,6.8,0.7,3.0,3.5,1.0,37.0,11.0,173.0,1 -91,1,0.0,1,0.0,,0.0,0.0,1,0.0,,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,,,,65,,,0,1.0,1.0,1.22,8.7,14.6,95.1,6.7,142000.0,4.2,1.3,19.0,33.0,346.0,120.0,7.8,0.83,,,0.3,184.0,65.0,423.0,0 -92,1,1.0,1,0.0,0.0,1.0,0.0,1,0.0,0.0,1.0,0.0,,1.0,1.0,0.0,0.0,,0.0,1.0,0.0,0.0,1.0,79,70.0,0.0,3,1.0,1.0,1.01,226.0,11.5,95.6,6.3,108.0,4.2,1.0,27.0,31.0,667.0,222.0,6.2,3.13,1.0,8.8,0.2,,,,1 -93_random,1,1.0,1,0.0,0.0,0.0,,1,0.0,,1.0,0.0,,1.0,0.0,0.0,,0.0,0.0,1.0,0.0,0.0,1.0,40,,0.0,3,1.0,1.0,1.49,2.0,12.1,93.9,5.4,406000.0,3.4,1.2,13.0,28.0,69.0,166.0,7.2,0.52,1.0,4.0,0.3,59.0,15.0,870.0,0 -94_random,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,,0.0,1.0,,0.0,0.0,,0.0,1.0,1.0,1.0,0.0,0.0,0.0,25,,,3,1.0,1.0,1.28,5.7,13.0,102.3,4.3,222000.0,1.9,2.6,34.0,107.0,1575.0,595.0,6.7,3.23,5.0,6.5,0.3,14.0,34.0,870.0,0 -95_random,1,,1,1.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,1.0,58,0.0,0.0,2,1.0,3.0,1.46,4.7,18.7,103.9,6.4,406000.0,3.4,1.4,25.0,197.0,,66.0,6.7,1.7,3.0,5.0,1.9,,54.0,,0 -96,1,1.0,1,0.0,0.0,0.0,1.0,0,1.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,71,,0.0,1,1.0,2.0,1.11,5.0,9.1,90.9,6.36,307000.0,2.47,,31.0,29.0,339.0,254.0,5.5,1.18,3.0,6.3,,,,,0 -97,1,0.0,1,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,58,,,0,1.0,1.0,1.64,64.0,14.1,103.6,4.5,68.0,2.9,3.3,28.0,43.0,51.0,137.0,6.8,0.67,4.0,4.7,1.1,,,,0 -98_random,1,1.0,0,0.0,0.0,1.0,1.0,1,0.0,1.0,1.0,0.0,,0.0,1.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,79,100.0,,0,1.0,1.0,1.42,123.0,15.7,91.5,2100.0,91000.0,4.2,,73.0,85.0,795.0,154.0,6.3,0.86,5.0,,2.9,171.0,5.0,,0 -99,1,0.0,1,0.0,,0.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,73,,0.0,2,1.0,2.0,1.67,8.5,13.0,102.3,24.8,133000.0,2.7,9.5,262.0,335.0,351.0,66.0,6.1,1.2,5.0,7.0,5.5,,,,0 -100,1,1.0,1,,,,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,1.0,1.0,0.0,1.0,0.0,93,,0.0,2,1.0,1.0,1.16,2785.0,12.0,94.4,7.9,78000.0,2.6,3.5,26.0,34.0,339.0,297.0,5.7,2.19,5.0,,1.5,55.0,33.0,256.0,0 -101_random,0,0.0,1,0.0,,0.0,0.0,1,0.0,,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,,1.0,0.0,0.0,1.0,72,0.0,0.0,3,1.0,1.0,1.41,,14.9,105.0,5.5,154000.0,4.0,0.8,26.0,99.0,311.0,97.0,7.1,0.52,,7.4,1.3,184.0,,2165.0,0 -102,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,1.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,1.0,64,70.0,,2,1.0,2.0,1.55,5.7,13.9,99.7,5200.0,124000.0,2.1,0.8,37.0,75.0,203.0,110.0,5.0,0.56,3.0,2.4,,92.0,56.0,489.0,0 -103,1,1.0,0,1.0,,,1.0,1,,,0.0,0.0,,0.0,0.0,0.0,0.0,,,1.0,0.0,,0.0,63,0.0,,4,3.0,3.0,1.93,,13.5,93.3,8190.0,406000.0,2.9,40.5,139.0,266.0,403.0,670.0,6.3,4.82,5.0,,29.3,,,,1 -104,1,1.0,0,0.0,0.0,0.0,0.0,0,,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,64,0.0,50.0,1,1.0,1.0,1.17,39.0,12.6,93.8,4900.0,144000.0,3.8,1.0,42.0,74.0,277.0,312.0,78.0,1.01,1.0,15.0,,87.0,25.0,81.0,0 -105_random,1,1.0,1,0.0,0.0,0.0,0.0,0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,,0.0,,0.0,1.0,0.0,0.0,1.0,81,,0.0,4,1.0,1.0,1.27,,9.5,93.8,3800.0,130.0,3.2,40.5,110.0,266.0,115.0,66.0,37.0,2.14,5.0,3.1,1.1,93.0,54.0,423.0,0 -106,1,1.0,1,0.0,0.0,1.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0,1.0,50,80.0,1.0,0,1.0,1.0,1.18,32.0,14.0,90.1,5.2,121000.0,4.2,0.4,420.0,226.0,147.0,174.0,8.6,0.9,5.0,3.0,,26.4,54.0,2230.0,0 -107,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,,0.0,1.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,79,75.0,0.0,3,1.0,2.0,1.32,7.6,5.0,69.5,3800.0,96000.0,3.7,0.5,17.0,69.0,76.0,86.0,6.3,2.68,1.0,10.0,,9.0,3.0,490.0,1 -108,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,1.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,1.0,0.0,1.0,1.0,85,100.0,0.0,1,1.0,1.0,1.25,173.0,11.3,103.9,6200.0,176000.0,2.4,1.7,63.0,114.0,80.0,163.0,6.1,0.67,5.0,20.0,0.5,131.0,78.0,1316.0,1 -109,0,0.0,1,0.0,0.0,0.0,0.0,1,,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,62,,,0,1.0,1.0,1.54,2.3,12.1,89.7,4.5,97000.0,2.7,1.4,19.0,27.0,72.0,120.0,4.3,0.61,5.0,4.0,0.7,,,,0 -110,1,1.0,1,1.0,0.0,1.0,0.0,1,,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,1.0,74,200.0,30.0,2,2.0,2.0,1.26,114.0,14.9,104.5,4.3,90000.0,3.2,4.8,106.0,154.0,148.0,166.0,7.2,0.48,5.0,12.6,1.8,161.0,96.0,297.0,0 -111,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,,0.0,1.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,1.0,56,90.0,,2,1.0,2.0,1.87,173.0,11.1,105.5,6.1,51000.0,3.1,32.3,110.0,206.0,127.0,188.0,5.4,1.29,5.0,,22.1,,,,1 -112,1,0.0,1,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,74,100.0,,0,1.0,1.0,1.36,18.0,15.3,90.9,4.9,81000.0,4.2,1.7,35.0,49.0,97.0,109.0,7.3,1.02,1.0,3.5,0.3,,,,0 -113,1,1.0,0,1.0,0.0,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,0.0,62,0.0,7.5,1,1.0,1.0,1.45,42.0,16.2,99.1,5.001,77000.0,4.1,1.3,42.0,118.0,279.0,158.0,7.7,0.88,2.0,7.4,0.3,,,,0 -114,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,,1.0,0.0,,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,1.0,60,100.0,,3,3.0,2.0,1.87,28274.0,10.3,94.7,11.1,109000.0,2.4,5.7,25.0,111.0,55.0,128.0,7.0,1.3,1.0,1.5,1.9,51.0,18.0,56.0,1 -115_random,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,1.0,,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,1.0,72,100.0,,4,2.0,2.0,1.2,4.9,15.7,89.6,3.2,122.0,2.2,32.3,35.0,49.0,,171.0,7.2,0.6,5.0,3.0,1.2,93.0,,888.0,0 -116,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,0.0,,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,57,96.0,60.0,0,1.0,3.0,1.17,1009.0,13.8,93.2,3100.0,137000.0,3.0,0.7,25.0,55.0,343.0,235.0,,0.79,2.0,20.0,,,,,1 -117_random,1,1.0,1,0.0,0.0,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,1.0,75,100.0,0.0,0,1.0,1.0,1.24,14177.0,11.4,95.1,5.2,75000.0,4.6,28.5,121.0,,108.0,235.0,8.4,1.72,3.0,,1.7,,,76.9,0 -118,1,0.0,1,0.0,0.0,0.0,0.0,1,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,63,,0.0,0,1.0,1.0,1.28,5.2,14.6,96.1,6.1,194000.0,4.2,7.9,97.0,69.0,816.0,79.0,7.7,1.02,1.0,3.0,,,,,0 -119,1,0.0,1,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,79,180.0,23.0,0,1.0,2.0,1.46,5.2,14.9,103.8,4500.0,53000.0,3.2,1.4,62.0,87.0,263.0,239.0,8.1,0.72,1.0,1.5,1.0,,,,0 -120,1,1.0,0,1.0,0.0,,0.0,1,1.0,0.0,1.0,0.0,0.0,1.0,0.0,,,,,,0.0,0.0,0.0,63,0.0,0.0,1,1.0,1.0,1.14,14177.0,10.2,96.1,6000.0,109000.0,2.6,4.9,70.0,113.0,833.0,980.0,7.5,0.78,5.0,9.0,2.8,,,,0 -121,1,0.0,1,0.0,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,0.0,1.0,59,100.0,0.0,0,1.0,1.0,1.94,3.1,10.8,102.8,5300.0,97000.0,3.6,1.1,119.0,125.0,663.0,433.0,6.5,0.87,2.0,3.2,0.4,52.5,37.0,856.0,1 -122,1,1.0,1,0.0,0.0,1.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,0.0,51,75.0,52.5,2,1.0,1.0,1.56,50655.0,9.8,85.6,3900.0,132000.0,2.6,2.6,123.0,219.0,503.0,363.0,7.3,0.55,1.0,4.0,1.5,40.0,12.0,57.0,1 -123,1,0.0,0,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,,,0.0,0.0,0.0,0.0,1.0,74,0.0,0.0,0,1.0,1.0,1.11,1.2,15.1,83.8,5.2,178000.0,4.7,0.5,35.0,17.0,45.3,151.0,6.4,1.5,1.0,8.3,,88.0,27.0,90.0,0 -124,1,1.0,1,0.0,0.0,1.0,1.0,1,,1.0,0.0,0.0,1.0,0.0,0.0,0.0,,1.0,0.0,1.0,0.0,0.0,0.0,62,,,2,1.0,2.0,1.08,657.0,11.8,89.2,9400.0,211000.0,3.2,0.8,43.0,101.0,646.0,466.0,7.3,0.7,1.0,8.3,,,,579.0,1 -125,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,1.0,76,100.0,,4,2.0,2.0,1.2,421500.0,14.3,89.5,9.8,309000.0,3.1,1.5,20.0,44.0,291.0,217.0,6.3,0.7,1.0,20.0,0.5,52.0,17.0,832.0,1 -126_random,0,0.0,1,0.0,0.0,1.0,0.0,1,0.0,,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,25,,30.0,2,1.0,3.0,0.95,421500.0,14.9,117.3,9.0,194000.0,3.1,9.5,28.0,117.0,115.0,86.0,7.7,1.5,2.0,3.5,0.37,,,490.0,0 -127,1,0.0,1,0.0,0.0,0.0,,1,0.0,0.0,1.0,0.0,,1.0,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,1.0,76,,0.0,3,2.0,1.0,1.66,77.0,12.3,104.2,2900.0,60000.0,3.2,2.8,54.0,38.0,311.0,182.0,6.2,0.77,2.0,4.3,1.0,93.0,47.0,307.0,0 -128,1,0.0,0,1.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,0.0,0.0,0.0,0.0,72,0.0,510.0,2,1.0,1.0,1.13,2.1,12.6,95.1,8.7,254000.0,3.68,0.7,26.0,38.0,161.0,127.0,6.9,1.11,2.0,4.3,,28.0,10.0,308.0,1 -129,0,1.0,1,,,,,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,,0.0,0.0,0.0,1.0,0.0,0.0,1.0,77,75.0,0.0,2,2.0,2.0,1.07,2.0,11.6,83.5,9.0,318000.0,3.89,0.9,23.0,48.0,319.0,171.0,7.1,0.66,2.0,5.8,,,,,1 -130,0,1.0,0,,,,0.0,1,0.0,0.0,0.0,1.0,0.0,1.0,0.0,,,,0.0,0.0,1.0,1.0,0.0,75,0.0,0.0,2,1.0,3.0,1.22,4.2,14.9,87.4,15.4,179000.0,3.5,0.6,31.0,61.0,196.0,150.0,5.4,0.7,5.0,17.5,0.3,,,,0 -131_random,0,1.0,1,0.0,,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,,,0.0,1.0,0.0,1.0,1.0,63,100.0,0.0,0,1.0,1.0,1.66,2089.0,11.6,94.0,2900.0,268000.0,2.4,7.9,54.0,59.0,322.0,163.0,5.0,0.52,1.0,5.0,0.7,22.0,,,0 -132_random,1,1.0,1,0.0,0.0,0.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,1.0,0.0,0.0,0.0,73,0.0,,0,1.0,1.0,1.33,2.8,13.5,104.5,6900.0,268000.0,3.44,28.5,31.0,58.0,339.0,139.0,8.2,0.69,5.0,9.3,,40.0,,,1 -133_random,1,1.0,0,0.0,0.0,0.0,,0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,1.0,0.0,0.0,1.0,43,100.0,,0,1.0,1.0,1.28,7.0,16.0,96.1,5.2,196.0,3.2,10.5,71.0,76.0,76.0,263.0,7.0,1.5,2.0,6.8,0.6,,,,0 -134_random,1,1.0,1,,0.0,0.0,1.0,1,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,73,50.0,,4,1.0,1.0,,2785.0,12.7,91.5,2100.0,179000.0,3.4,0.8,35.0,116.0,164.0,170.0,,0.7,5.0,1.9,3.8,197.0,,,1 -135.0_random,0,,1,0.0,,0.0,0.0,1,0.0,,0.0,0.0,,1.0,0.0,0.0,,,0.0,1.0,0.0,1.0,1.0,63,,0.0,0,2.0,1.0,1.33,5.4,11.6,87.4,4.9,78000.0,4.2,1.2,35.0,,319.0,130.0,,1.11,1.0,20.0,,104.0,,,0 -136,0,1.0,0,0.0,0.0,0.0,0.0,0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,56,0.0,40.0,2,1.0,1.0,1.25,2089.0,15.4,91.6,10.9,175000.0,4.4,1.3,45.0,32.0,717.0,295.0,7.4,1.1,5.0,6.0,0.6,,,,0 -137,0,1.0,0,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,78,0.0,0.0,0,2.0,1.0,1.03,18.0,13.2,89.5,2.6,136000.0,4.3,0.8,18.0,29.0,82.0,141.0,7.2,0.85,1.0,9.5,,91.0,31.0,80.0,0 -138,0,1.0,0,0.0,0.0,1.0,0.0,1,,,,,0.0,,,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,55,0.0,,0,1.0,1.0,1.19,4.9,13.6,97.3,5400.0,133000.0,4.5,0.9,54.0,63.0,487.0,89.0,7.8,0.78,2.0,3.32,,78.0,30.0,220.0,0 -139_random,1,0.0,1,0.0,0.0,,1.0,1,,1.0,1.0,0.0,,0.0,0.0,0.0,,1.0,0.0,1.0,0.0,0.0,0.0,63,0.0,52.5,1,1.0,2.0,1.53,5.7,15.4,88.3,5.001,58.0,3.4,1.3,121.0,53.0,101.0,166.0,7.2,0.8,2.0,5.0,,32.0,26.0,,0 -140,0,1.0,0,,,,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,0.0,,0.0,0.0,1.0,0.0,0.0,43,0.0,0.0,0,1.0,1.0,1.25,180.0,12.2,87.6,7.2,130.0,3.5,0.5,79.0,58.0,229.0,302.0,7.0,0.6,5.0,9.0,,,,206.0,1 -141_random,1,,1,,,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,82,0.0,,3,1.0,2.0,1.11,10.0,13.2,95.1,8.0,137000.0,4.1,0.9,20.0,334.0,69.0,280.0,8.0,1.1,5.0,6.6,0.8,,18.0,1452.0,0 -142,1,,1,0.0,0.0,0.0,1.0,1,0.0,0.0,1.0,1.0,1.0,0.0,1.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,67,70.0,0.0,0,1.0,,1.02,24.0,16.0,98.8,6.6,96000.0,4.1,1.4,207.0,158.0,116.0,84.0,7.2,0.9,1.0,2.2,0.3,,,,0 -143,1,0.0,1,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,1.0,0.0,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,0.0,0.0,67,,40.0,0,1.0,1.0,1.798,9.4,11.2,102.4,4.1,60000.0,3.4,3.7,43.0,63.0,175.0,106.0,7.6,0.52,1.0,2.1,1.1,94.0,39.0,344.0,0 -144,1,,1,0.0,0.0,1.0,0.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,,,0.0,0.0,1.0,51,,37.0,0,1.0,1.0,1.26,7.0,14.9,106.3,6.4,122.0,3.0,1.5,195.0,401.0,272.0,93.0,6.4,1.0,3.0,2.9,0.4,124.0,51.0,642.0,0 -145_random,1,0.0,1,1.0,0.0,0.0,1.0,1,0.0,,0.0,1.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,0.0,74,,0.0,3,1.0,1.0,1.17,9860.0,10.8,95.1,14.4,38000.0,4.2,0.9,36.0,34.0,123.0,139.0,6.4,0.7,1.0,9.0,,,5.0,316.0,1 -146,1,1.0,1,0.0,0.0,0.0,0.0,1,,1.0,0.0,1.0,0.0,1.0,1.0,0.0,,1.0,0.0,1.0,1.0,0.0,0.0,79,100.0,15.0,2,1.0,3.0,1.68,92421.0,14.3,72.2,13.3,459000.0,3.2,1.6,24.0,76.0,570.0,472.0,5.9,2.02,1.0,,0.6,29.0,4.0,14.0,1 -147,1,0.0,1,0.0,,0.0,0.0,1,,,1.0,1.0,,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,75,,,0,1.0,1.0,1.71,5.2,11.1,106.9,2100.0,52000.0,3.3,2.6,15.0,47.0,94.0,117.0,7.1,0.79,1.0,3.5,1.0,,,,0 -148,0,0.0,0,0.0,,0.0,0.0,1,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,81,0.0,0.0,0,1.0,1.0,1.18,16.0,13.3,94.3,4800.0,96000.0,3.8,1.2,26.0,35.0,75.0,105.0,7.6,0.53,1.0,2.4,0.3,,,,0 -149,0,1.0,0,0.0,0.0,0.0,0.0,0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0,0.0,25,0.0,0.0,2,1.0,1.0,,1.5,,,,,,,,,,,,,1.0,6.6,,,,,0 -150,1,0.0,0,0.0,0.0,1.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,36,0.0,0.0,0,1.0,1.0,1.12,3204.0,16.1,92.0,10.5,182.0,4.3,0.7,46.0,31.0,92.0,79.0,7.3,1.0,1.0,,0.2,,,,0 -151,0,0.0,1,0.0,0.0,0.0,0.0,1,0.0,,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,,,0.0,0.0,1.0,69,,,0,1.0,1.0,1.2,10.0,13.5,104.9,13.5,194.0,4.0,1.0,31.0,79.0,126.0,85.0,7.6,0.8,1.0,7.0,0.4,,,,0 -152,1,1.0,1,0.0,0.0,0.0,1.0,1,0.0,1.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,1.0,0.0,1.0,1.0,47,250.0,18.0,1,1.0,3.0,1.39,695.0,11.1,93.9,5.4,88000.0,2.7,1.0,31.0,73.0,38.0,44.0,7.0,0.96,5.0,3.5,,,,,0 -153_random,1,1.0,0,0.0,0.0,1.0,1.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,56,100.0,60.0,0,1.0,2.0,1.25,,14.9,96.5,9.0,268000.0,4.3,4.3,69.0,38.0,76.0,85.0,7.2,0.77,1.0,6.5,2.2,,,1176.0,0 -154_random,0,0.0,1,,0.0,0.0,0.0,1,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,74,,40.0,1,2.0,2.0,1.798,615.0,10.8,95.1,11.1,406000.0,3.28,0.7,139.0,69.0,194.0,980.0,16.8,0.53,2.0,6.6,1.9,,34.0,134.0,1 -155,1,1.0,1,0.0,0.0,0.0,0.0,1,,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,,1.0,1.0,1.0,0.0,1.0,64,75.0,25.0,3,2.0,3.0,1.63,1671.0,12.8,101.6,4.4,172000.0,3.44,5.8,38.0,95.0,92.0,139.0,7.6,0.9,3.0,9.0,2.9,111.0,94.0,1600.0,1 -156_random,1,0.0,1,0.0,0.0,0.0,0.0,1,0.0,,1.0,1.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,1.0,50,0.0,32.0,0,1.0,1.0,1.28,50655.0,15.6,99.0,5.5,122.0,3.3,0.5,63.0,87.0,646.0,90.0,6.7,0.4,3.0,,1.1,,25.0,856.0,1 -157,1,,1,0.0,0.0,0.0,0.0,1,,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,1.0,62,,20.0,0,1.0,2.0,1.41,1.7,14.7,97.2,6900.0,72000.0,3.5,1.3,31.0,24.0,67.0,97.0,7.3,0.76,1.0,3.5,0.3,,,,0 -158_random,1,0.0,1,0.0,0.0,0.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,1.0,86,75.0,67.5,0,1.0,1.0,1.18,2.0,14.3,83.7,7.6,58.0,4.2,2.4,59.0,52.0,55.0,312.0,5.5,0.58,2.0,7.5,0.6,,,76.9,1 -159,1,1.0,1,1.0,0.0,1.0,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,1.0,1.0,64,100.0,0.0,3,3.0,3.0,1.52,4.9,7.9,111.2,4.1,67000.0,2.43,1.9,40.0,71.0,69.0,73.0,4.8,0.77,5.0,3.2,0.7,40.0,18.0,283.0,1 -160,0,0.0,1,,,,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,40,,,0,1.0,1.0,0.84,,15.4,109.2,9.3,184000.0,4.6,0.5,35.0,40.0,449.0,109.0,7.6,0.7,5.0,3.0,,,,,0 -161_random,1,1.0,1,0.0,0.0,,0.0,1,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,77,0.0,44.0,0,1.0,2.0,1.29,9.2,12.6,99.0,4.5,169000.0,3.2,3.0,30.0,29.0,311.0,130.0,7.6,0.77,2.0,2.9,,,,283.0,0 -162,1,0.0,1,0.0,0.0,0.0,0.0,1,0.0,1.0,1.0,1.0,0.0,1.0,1.0,0.0,,,,,0.0,0.0,1.0,65,,48.0,0,1.0,1.0,1.13,75.0,13.3,90.0,8.0,385000.0,4.3,0.6,53.0,52.0,164.0,181.0,7.5,1.46,5.0,18.6,,,,,0 -163,1,0.0,1,1.0,0.0,1.0,1.0,1,1.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,,,,1.0,1.0,1.0,44,,,2,1.0,1.0,2.14,94964.0,15.6,117.3,5200.0,118000.0,4.8,1.1,50.0,60.0,320.0,170.0,8.4,0.74,5.0,18.0,,,,,1 -164,1,1.0,1,0.0,0.0,0.0,1.0,1,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,,1.0,1.0,0.0,1.0,1.0,52,50.0,,0,1.0,1.0,1.79,44340.0,12.7,95.8,14.4,412000.0,2.2,28.5,78.0,127.0,444.0,462.0,6.6,3.95,5.0,8.5,19.8,,,,1 diff --git a/data/UCIBinaryClassification/hcc_survival.csv b/data/UCIBinaryClassification/hcc_survival.csv new file mode 100644 index 00000000..2edf5c48 --- /dev/null +++ b/data/UCIBinaryClassification/hcc_survival.csv @@ -0,0 +1,133 @@ +InstanceID,Gender,Symptoms,Alcohol,HepatitisBSurfaceAntigen,HepatitisBeAntigen,HepatitisBCoreAntibody,HepatitisCVirusAntibody,Cirrhosis,EndemicCountries,Smoking,Diabetes,Obesity,Hemochromatosis,ArterialHypertension,ChronicRenalInsufficiency,HIV,NASH,EsophagealVarices,Splenomegaly,PortalHypertension,PortalVeinThrombosis,LiverMetastasis,RadiologicalHallmark,AgeAtDiagnosis,GramsAlcoholPerDay,PacksCigarettesPerYear,PerformanceStatus,EncephalopathyDegree,AscitesDegree,InternationalNormalisedRatio,AlphaFetoprotein,Hemoglobin,MeanCorpuscularVolume,Leukocytes,Platelets,Albumin,TotalBilirubin,AlanineTransaminase,AspartateTransaminase,GammaGlutamylTransferase,AlkalinePhosphatase,TotalProteins,Creatinine,NumberOfNodules,MajorDimensionOfNodule,DirectBilirubin,Iron,OxygenSaturation,Ferritin,Class +HCC_0001,1,0,1,0,0,0,0,1,0,1,1,NA,1,0,0,0,0,1,0,0,0,0,1,67,137,15,0,1,1,1.53,95,13.7,106.6,4.9,99,3.4,2.1,34,41,183,150,7.1,0.7,1,3.5,0.5,NA,NA,NA,1 +HCC_0002,0,NA,0,0,0,0,1,1,NA,NA,1,0,0,1,0,0,0,1,0,0,0,0,1,62,0,NA,0,1,1,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,1,1.8,NA,NA,NA,NA,1 +HCC_0003,1,0,1,1,0,1,0,1,0,1,0,0,0,1,1,0,0,0,0,1,0,1,1,78,50,50,2,1,2,0.96,5.8,8.9,79.8,8.4,472,3.3,0.4,58,68,202,109,7,2.1,5,13,0.1,28,6,16,1 +HCC_0004,1,1,1,0,0,0,0,1,0,1,1,0,0,1,0,0,0,0,0,0,0,1,1,77,40,30,0,1,1,0.95,2440,13.4,97.1,9,279,3.7,0.4,16,64,94,174,8.1,1.11,2,15.7,0.2,NA,NA,NA,0 +HCC_0006,1,0,1,0,NA,0,0,1,0,NA,0,1,0,0,0,0,0,1,1,1,0,0,1,75,NA,NA,1,1,2,1.58,110,13.4,91.5,5.4,85,3.4,3.5,91,122,242,396,5.6,0.9,1,10,1.4,53,22,111,0 +HCC_0007,1,0,0,0,NA,1,1,1,0,0,1,0,NA,0,0,0,0,0,0,0,0,0,1,49,0,0,0,1,1,1.4,138.9,10.4,102,3.2,42000,2.35,2.72,119,183,143,211,7.3,0.8,5,2.6,2.19,171,126,1452,0 +HCC_0008,1,1,1,0,NA,0,0,1,0,1,1,NA,0,0,0,0,0,0,1,1,1,0,1,61,NA,20,3,1,1,1.46,9860,10.8,92,3,58,3.1,3.2,79,108,184,300,7.1,0.52,2,9,1.3,42,25,706,0 +HCC_0009,1,1,1,0,0,0,0,1,0,1,1,0,0,1,0,0,0,NA,1,1,0,0,1,50,100,32,1,1,2,3.14,8.8,11.9,107.5,4.9,70,1.9,3.3,26,59,115,63,6.1,0.59,1,6.4,1.2,85,73,982,1 +HCC_0010,1,1,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,43,100,0,0,1,1,1.12,1.8,11.8,87.8,5100,193000,4.2,0.5,71,45,256,303,7.1,0.59,1,9.3,0.7,NA,NA,NA,1 +HCC_0011,1,0,1,0,0,0,1,1,NA,NA,0,0,0,0,0,0,0,NA,1,1,0,0,1,41,NA,NA,0,1,2,1.05,100809,13,94.2,5.7,196,4.4,3,90,334,494,236,7.6,0.8,5,NA,1.1,NA,NA,NA,0 +HCC_0012,1,0,1,0,0,0,1,1,1,0,0,0,0,1,0,0,0,NA,0,1,0,0,1,74,NA,0,0,1,1,1.33,86,15.7,96.7,4,61,3.7,1.3,132,168,113,154,NA,7.6,5,1.9,0.3,144,41,277,1 +HCC_0013,1,0,1,0,0,0,0,1,0,1,1,0,0,1,0,0,NA,NA,1,1,1,0,0,66,NA,30,0,1,1,1.53,60,13.3,90.1,5.5,207000,4.4,8.5,25,36,35,74,8.5,0.73,1,5,0.8,NA,NA,NA,1 +HCC_0015,1,0,1,0,0,0,0,1,0,NA,1,0,0,1,0,0,NA,1,1,1,0,0,1,63,NA,NA,2,2,2,1.25,29,13.5,93,6,128,3.15,10.5,76,116,165,163,7.3,1.07,4,4.5,4.5,197,84,302,1 +HCC_0017,1,0,1,0,0,0,0,1,NA,1,1,NA,1,0,0,0,NA,NA,1,1,1,0,1,72,NA,NA,3,2,1,2.14,60,12.1,99.2,5,58,2.4,9.8,69,63,201,235,6.2,0.96,2,2,2.9,136,95,767,0 +HCC_0019,1,NA,1,0,0,0,0,1,NA,1,0,NA,0,1,1,0,0,1,0,0,0,0,1,64,200,78,1,1,1,1.13,8.8,14.9,94.8,6.3,137,4.3,0.9,16,23,82,180,6.5,4.95,1,5.4,0.9,144,49,295,1 +HCC_0020,1,1,1,0,0,0,0,1,NA,NA,0,0,0,1,0,0,0,1,1,1,1,0,1,75,500,NA,0,1,3,1.44,34,15.9,103.4,9600,101000,3.4,3.4,27,87,260,147,6.3,0.9,5,2.3,1.6,67,34,774,0 +HCC_0021,1,0,1,0,0,0,0,1,NA,1,0,1,0,0,0,0,0,1,1,1,0,0,0,71,200,60,0,1,1,1.29,19.6,11.7,101,2600,109000,3.6,1.7,13,35,23,141,7.3,0.68,1,2.5,0.7,152.6,NA,76.9,1 +HCC_0022,1,0,1,0,0,1,1,1,0,1,0,0,0,0,0,0,0,NA,0,0,0,0,0,73,80,47,0,1,1,1.06,3.9,16.4,90.7,7.8,187,4.5,1,54,47,52,97,6.3,0.75,1,6.8,0.2,87,26,84,1 +HCC_0023,1,1,1,0,0,1,0,1,NA,0,0,1,0,1,0,0,0,0,1,1,0,0,1,66,180,0,1,1,3,1.27,1975,10.8,86.5,9100,154000,3.1,1.2,68,136,869,562,69,1.14,5,3.8,0.5,112,73,1001,0 +HCC_0024,1,1,1,0,0,0,0,1,1,1,1,0,0,1,0,0,0,1,1,1,1,1,1,64,200,60,1,1,1,4.82,185,10.7,88.1,5,194000,3.6,3.8,217,86,879,396,7,0.53,5,15,1.6,NA,NA,NA,0 +HCC_0025,1,1,1,0,NA,1,0,0,0,1,0,0,NA,1,0,NA,0,NA,0,NA,0,1,0,84,150,NA,4,1,1,1.74,5532,13.1,111,3.5,351000,2.4,1.3,26,67,108,311,5.6,0.95,1,10,0.7,NA,NA,NA,0 +HCC_0026,1,0,1,0,NA,0,0,1,0,0,1,0,0,0,0,0,0,1,1,1,1,0,1,80,100,0,2,1,1,1.33,13327,13.7,94.3,5.2,110,3.1,1.6,52,107,465,233,8.4,0.79,5,NA,0.7,93,31,79,1 +HCC_0027,1,1,1,NA,NA,NA,1,1,0,1,0,0,NA,0,0,NA,0,1,1,1,1,0,1,45,50,16,1,1,3,1.38,NA,13.6,98.4,4.3,99000,3.3,1.3,178,325,252,172,8.1,0.83,1,5,0.7,NA,NA,NA,0 +HCC_0028,1,NA,1,1,0,1,0,1,NA,NA,0,0,0,0,0,0,0,1,1,1,0,0,1,57,NA,NA,0,1,1,1.37,5.9,15.5,88.2,4.9,113,4.5,3.2,36,65,34,111,NA,NA,2,4,1,180,56,NA,1 +HCC_0029,1,0,1,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,1,1,1,0,1,61,60,67.5,1,1,1,1.3,3255,12.2,89.5,4.4,108,3,1.1,59,85,419,293,7.7,0.67,2,6.5,0.4,94,27,70,0 +HCC_0030,1,1,1,0,NA,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,20,NA,2,1,1,1,1.21,1.9,9.9,83.4,8.1,556,3.2,1.8,150,112,599,974,7.7,0.7,5,NA,1.1,22,7,369,1 +HCC_0031,1,1,1,1,0,NA,0,1,1,1,0,0,0,0,0,0,0,NA,1,1,1,0,1,60,20,8,2,1,1,1.19,11,13.1,87.9,7.8,212,3.5,0.7,27,26,143,158,8.2,0.71,1,16,NA,NA,NA,NA,1 +HCC_0032,1,0,1,0,NA,0,0,1,NA,1,1,NA,0,1,0,0,0,1,1,1,0,0,1,62,120,NA,0,1,1,1.44,1237,12.2,94,6200,93000,4.2,1,35,85,191,129,58,1.06,5,7,NA,75,24,239,1 +HCC_0033,1,1,1,NA,NA,NA,0,1,NA,NA,0,0,0,0,0,0,0,0,0,0,0,0,1,67,100,NA,0,1,1,1.32,7.7,15.7,96.1,9.1,268000,3.4,0.6,20,29,49,135,8.2,0.9,2,NA,NA,NA,NA,NA,1 +HCC_0034,1,1,1,0,NA,0,0,1,NA,NA,0,0,0,1,0,0,NA,0,0,0,0,0,1,77,NA,NA,0,1,1,1.24,266,13.7,97.7,13000,170000,4.2,0.5,68,85,232,227,16.8,1.72,1,5.9,NA,NA,NA,NA,1 +HCC_0036,1,NA,0,1,NA,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,76,0,0,0,1,1,0.96,14.2,14.8,98.5,4.95,187,4.2,0.77,43,86,89,113,6.7,0.95,3,8.8,0.37,NA,NA,NA,1 +HCC_0037,1,1,1,0,0,0,0,1,0,0,1,0,0,1,0,0,0,NA,1,1,0,0,1,73,75,0,4,1,2,2,3.1,13.1,109.3,44.6,60,2.3,7.8,38,74,180,127,5.6,0.88,5,3.1,3.3,98,89,870,0 +HCC_0039,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,70,100,0,0,1,1,1.09,5.4,14.9,105,7.2,230000,4.2,1.3,18,26,174,92,7.3,0.8,2,6,0.3,NA,NA,NA,1 +HCC_0040,1,1,1,1,0,1,1,1,1,0,0,0,0,1,0,0,0,NA,0,NA,0,1,1,59,200,0,0,1,1,1.42,479,11.3,82.2,9500,160000,3.1,1.4,113,143,924,288,7.9,0.98,5,17,0.6,NA,NA,NA,1 +HCC_0041,0,NA,0,0,0,1,1,1,0,0,0,0,NA,1,0,0,0,NA,NA,NA,0,0,1,71,0,0,0,1,1,1.18,19,13.9,88.3,6.86,201000,4.4,0.8,142,117,123,104,8.5,0.74,2,3.3,0.3,143,50.18,120,1 +HCC_0042,1,0,0,0,0,1,0,1,0,0,1,1,0,1,0,0,0,NA,0,0,NA,NA,0,66,0,0,0,1,1,1.21,2.8,15.7,92.7,15.4,188000,4.1,0.7,299,553,196,68,6.5,1.3,1,5,0.3,NA,NA,NA,1 +HCC_0044,1,0,1,NA,NA,NA,NA,1,0,NA,0,1,0,0,0,NA,1,1,1,1,0,0,1,71,75,NA,0,1,1,1.17,5,15.1,104.1,4.3,65000,3.8,2.5,61,56,239,56,7.3,0.7,1,2,0.2,NA,NA,NA,1 +HCC_0045,0,0,0,0,0,1,1,1,NA,0,0,0,0,0,0,0,0,NA,1,1,0,0,1,52,0,0,0,1,1,1.71,237,15.6,98.1,4.3,88,3.2,2.2,30,52,72,97,6.7,0.86,5,2.2,0.5,NA,NA,NA,1 +HCC_0046,1,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,60,NA,0,0,1,1,1.18,2.8,16.6,93.8,8300,167000,4.9,0.9,35,29,62,68,8.3,0.72,1,2.3,NA,NA,NA,NA,1 +HCC_0047,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,NA,NA,NA,45,0,0,0,1,1,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,1 +HCC_0048,1,1,1,0,0,0,0,1,0,NA,0,0,0,0,0,0,0,1,1,1,1,1,0,66,NA,NA,1,1,2,1.64,16,14,102.9,11.5,277000,3.1,6.8,140,244,795,595,7.2,0.79,1,2.3,4.1,63,34,888,0 +HCC_0049,1,1,0,0,0,0,0,0,0,1,1,0,0,1,1,0,1,0,0,0,0,0,0,80,0,80,0,1,1,1.33,163,10.6,96.2,9900,280000,3.3,1,28,57,236,171,7.5,1.38,1,19,NA,45,21,802,0 +HCC_0051,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,NA,0,0,0,1,1,27,0,0,2,1,1,0.97,46,10.5,78.7,20.9,251,2.4,0.3,31,185,91,539,5,0.38,5,20,0.3,NA,NA,NA,0 +HCC_0054,1,NA,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,1,1,0,0,1,50,NA,0,0,1,1,1.65,7.3,15.3,93.7,3500,57000,NA,1.4,111,93,294,130,NA,0.76,2,2,0.3,184,2.26,59,1 +HCC_0057,1,1,1,0,NA,NA,NA,1,0,1,1,0,NA,1,0,0,NA,0,0,1,0,0,1,81,100,10,2,1,2,3.56,2.7,7.3,90.8,2.42,159000,3.4,0.5,25,32,80,55,6.2,0.85,1,2.2,NA,22,6,48,0 +HCC_0058,1,NA,1,0,0,0,0,1,0,1,1,0,0,1,0,0,0,1,0,1,0,0,1,65,100,NA,0,1,1,1.24,2.6,10.3,83,6.1,1.71,3.9,0.8,11,28,77,120,7,0.58,1,4.7,0.85,32,10,18,1 +HCC_0061,1,1,0,1,0,1,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,1,76,0,50,1,1,3,1.28,608,12.6,100,5.4,129,4,1.7,107,99,125,100,7.5,0.9,5,3.5,0.5,NA,NA,NA,1 +HCC_0062,1,1,1,0,0,1,1,1,0,1,0,0,0,0,0,0,0,1,1,1,0,0,1,56,100,40,0,2,2,1.46,41,14.6,100.8,5.5,42000,3.1,3.7,121,165,101,207,6.3,0.69,1,3,1.9,224,95,363,1 +HCC_0063,0,0,1,0,0,0,0,1,0,1,0,1,0,0,0,0,0,1,1,1,0,0,1,68,NA,30,2,1,2,1.94,NA,11.5,97.4,5700,77000,2.7,4.9,34,48,46,178,6.1,0.62,1,4.6,2.2,NA,NA,NA,1 +HCC_0064,1,1,1,0,0,0,0,1,0,1,1,0,0,1,0,0,0,1,1,1,0,0,1,72,300,NA,3,1,3,1.57,2,12.6,96.6,2.9,76000,3.5,2.4,33,40,110,166,NA,0.77,1,2,0.5,NA,NA,NA,1 +HCC_0065,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,NA,NA,NA,NA,0,0,0,66,0,0,0,1,1,1.29,7,12.1,95.1,3.8,77000,3.8,1.4,37,38,194,161,6.7,0.71,1,10,0.5,0,0,0,1 +HCC_0066,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,NA,NA,0,0,1,0,40,0,0,2,1,1,1.17,3.1,15.1,86,8.9,275000,2.8,1.3,74,50,23,104,5.4,0.6,5,7.8,0.2,46,18,NA,0 +HCC_0067,1,NA,1,0,NA,1,0,1,0,1,0,0,0,0,0,0,0,NA,1,1,0,0,1,68,60,NA,0,1,1,1.34,13,15.6,93,4.9,91000,4.54,1.4,54,52,275,113,7.8,0.55,2,6.2,0.3,94,33,393,1 +HCC_0068,1,1,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,63,100,0,0,1,1,2.07,1.7,9.5,99.2,3300,79000,2.1,1.6,56,82,134,113,37,0.4,1,2.7,0.2,94,37,48,1 +HCC_0069,1,1,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,NA,1,1,0,1,1,72,100,0,0,1,2,1.3,249,12.7,100.3,5.5,114,3.1,3.9,21,42,40,108,5.8,0.9,5,8,1.2,37,17,419,0 +HCC_0070,0,1,1,0,0,1,0,1,NA,0,0,1,0,0,1,0,NA,NA,0,1,1,0,1,88,80,0,2,2,3,1.27,66,10.9,97.3,8.9,270,2.7,2.1,145,84,179,260,5.9,NA,5,3,1.3,15,17,639,0 +HCC_0071,0,1,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,NA,1,1,0,0,1,23,0,0,0,1,1,1.17,358,12.7,74,2.2,51,2.9,2.8,53,41,54,94,4.9,0.2,2,5.4,0.8,50,16,20,1 +HCC_0072,1,1,1,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,1,1,1,59,75,44,3,2,2,1.01,1810346,13,102.1,8300,433000,3.4,1.9,138,86,1575,417,6.5,0.64,5,15,1.1,NA,NA,NA,1 +HCC_0074,1,1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,NA,0,0,1,1,1,67,NA,0,0,1,1,0.94,20,13,92,6.9,222000,3.7,0.6,162,354,1390,684,7.1,0.81,5,NA,NA,NA,NA,NA,0 +HCC_0075,1,1,1,0,NA,0,0,1,0,1,0,0,0,1,0,0,0,1,1,1,0,0,1,61,NA,15,0,1,1,1.15,2.5,14.9,92.3,6,159000,3.8,1,28,38,74,101,7.4,1.1,5,7.5,0.3,61,NA,255,1 +HCC_0076,1,1,1,0,NA,NA,1,1,NA,NA,0,0,0,0,0,0,0,1,1,1,0,0,1,61,100,NA,0,1,1,1.92,2269,12.1,119,5.1,80000,NA,9.6,204,357,199,174,NA,0.99,1,7.6,4.6,178,90,960,0 +HCC_0078,1,1,1,0,0,0,0,1,NA,NA,0,0,0,0,0,0,0,NA,0,1,0,0,1,78,80,NA,0,1,1,1.45,5.1,14.4,100.2,7.1,77000,4.1,0.9,43,63,540,114,7,1.09,5,NA,NA,NA,NA,NA,1 +HCC_0080,1,NA,1,0,0,0,1,1,NA,1,0,0,0,0,0,0,0,1,1,1,0,0,0,51,100,34.5,2,2,2,2.08,2.9,10.4,91.1,5.8,91000,2.4,16,123,145,109,190,5.9,0.9,0,NA,9.6,NA,NA,NA,1 +HCC_0081,1,1,1,NA,NA,NA,NA,1,0,NA,1,0,0,1,1,0,NA,NA,1,1,0,1,1,74,NA,NA,3,2,1,1.32,2.5,12.6,83.7,9.8,102000,3.3,1.2,29,43,196,204,7.3,1.1,5,NA,0.5,NA,NA,NA,0 +HCC_0084,1,1,1,0,0,0,0,1,0,NA,0,0,0,0,0,0,0,1,1,1,1,0,1,83,100,NA,2,1,3,1.48,2.6,12.7,106,3.8,80,2.9,3.4,34,53,156,207,7.2,NA,2,4.1,1.4,105,69,221,0 +HCC_0085,1,NA,0,0,0,0,1,1,NA,1,1,0,0,1,0,0,0,0,1,0,0,0,1,57,0,NA,0,NA,NA,1.1,2.9,16.4,94.8,4.6,94000,4.1,1.1,104,74,88,85,7.9,1.05,1,5.5,0.3,NA,NA,NA,1 +HCC_0086,1,1,1,0,0,1,0,1,0,1,0,1,0,0,0,0,0,0,1,1,1,0,1,58,NA,10,1,2,1,1.47,20,13.9,100.8,4,112000,3,2.9,50,92,124,244,6.3,0.8,2,6.8,0.7,181,99,108,1 +HCC_0087,1,1,1,0,0,0,0,1,0,NA,0,0,0,0,0,0,0,NA,0,1,0,1,1,71,NA,NA,1,1,1,1.08,2.79,12.6,83.9,7100,284000,NA,NA,28,46,70,213,NA,0.48,5,NA,NA,26,8,NA,1 +HCC_0088,1,0,0,0,0,1,1,1,0,1,0,0,0,0,0,1,0,0,1,1,0,0,1,52,0,33,0,1,2,NA,42,15.8,97.9,4.2,142000,4.2,0.5,74,62,38,70,7.5,0.77,3,1.5,NA,120,35,30,1 +HCC_0089,1,1,1,0,0,0,0,1,0,NA,1,0,0,0,0,0,0,1,1,1,0,0,1,74,100,NA,0,1,2,1.37,457,11.7,70.6,5.7,138000,4.1,2.1,22,33,33,90,9.7,1.6,5,5.6,0.9,13,3,28,0 +HCC_0090,1,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,1,1,0,0,1,61,NA,50,1,2,3,1.23,NA,9.5,90,7.6,38000,2.2,1.5,59,51,993,474,3.9,2.69,1,2,1,NA,NA,NA,1 +HCC_0091,1,1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,69,100,0,2,1,3,1.41,123,10.1,89.5,2.3,89000,4,4.3,31,60,75,177,6.8,0.7,3,3.5,1,37,11,173,0 +HCC_0092,1,0,1,0,NA,0,0,1,0,NA,1,0,0,1,0,0,0,1,1,1,NA,NA,NA,65,NA,NA,0,1,1,1.22,8.7,14.6,95.1,6.7,142000,4.2,1.3,19,33,346,120,7.8,0.83,NA,NA,0.3,184,65,423,1 +HCC_0093,1,1,1,0,0,1,0,1,0,0,1,0,NA,1,1,0,0,NA,0,1,0,0,1,79,70,0,3,1,1,1.01,226,11.5,95.6,6.3,108,4.2,1,27,31,667,222,6.2,3.13,1,8.8,0.2,NA,NA,NA,0 +HCC_0094,1,1,1,0,0,0,0,1,0,1,1,1,NA,NA,0,NA,0,NA,NA,1,1,1,1,69,200,60,1,1,1,1.39,2159,13.1,90.6,10400,261000,3.6,1.9,42,197,552,335,7.1,0.68,5,NA,0.6,NA,NA,NA,0 +HCC_0095,1,NA,1,0,0,0,0,1,0,1,1,0,0,1,1,NA,0,0,0,0,0,0,1,87,100,50,0,1,1,1.09,48,12.6,97.6,4.9,169000,4.2,0.8,30,31,86,91,6.9,1.9,5,2,NA,53,21,278,1 +HCC_0096,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,78,0,0,1,1,1,1.6,2.4,9.5,85.8,6900,228000,3.5,0.6,11,17,44,124,6.8,1.6,1,5.5,NA,15,7,810,0 +HCC_0097,1,1,1,0,0,0,1,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,1,71,NA,0,1,1,2,1.11,5,9.1,90.9,6.36,307000,2.47,NA,31,29,339,254,5.5,1.18,3,6.3,NA,NA,NA,NA,1 +HCC_0098,1,0,1,0,0,0,0,1,0,NA,0,0,NA,0,0,0,0,1,1,1,1,0,1,58,NA,NA,0,1,1,1.64,64,14.1,103.6,4.5,68,2.9,3.3,28,43,51,137,6.8,0.67,4,4.7,1.1,NA,NA,NA,1 +HCC_0100,1,0,1,0,NA,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,73,NA,0,2,1,2,1.67,8.5,13,102.3,24.8,133000,2.7,9.5,262,335,351,66,6.1,1.2,5,7,5.5,NA,NA,NA,1 +HCC_0101,1,1,1,NA,NA,NA,0,1,0,0,0,0,0,0,0,NA,0,1,1,1,0,1,0,93,NA,0,2,1,1,1.16,2785,12,94.4,7.9,78000,2.6,3.5,26,34,339,297,5.7,2.19,5,NA,1.5,55,33,256,1 +HCC_0103,1,1,1,0,0,0,0,1,0,NA,0,0,0,1,0,0,NA,1,1,1,0,0,1,64,70,NA,2,1,2,1.55,5.7,13.9,99.7,5200,124000,2.1,0.8,37,75,203,110,5,0.56,3,2.4,NA,92,56,489,1 +HCC_0104,1,1,0,1,NA,NA,1,1,NA,NA,0,0,NA,0,0,0,0,NA,NA,1,0,NA,0,63,0,NA,4,3,3,1.93,NA,13.5,93.3,8190,406000,2.9,40.5,139,266,403,670,6.3,4.82,5,NA,29.3,NA,NA,NA,0 +HCC_0105,1,1,0,0,0,0,0,0,NA,1,0,0,0,1,0,0,0,0,0,0,0,0,0,64,0,50,1,1,1,1.17,39,12.6,93.8,4900,144000,3.8,1,42,74,277,312,78,1.01,1,15,NA,87,25,81,1 +HCC_0106,1,1,1,0,0,0,0,1,NA,0,0,0,0,1,1,0,0,1,1,1,0,0,1,67,NA,0,3,1,2,1.48,2.5,14.3,101.5,5,120,2.2,1.2,34,71,222,97,5.2,2.82,3,2.4,0.3,92,56,48.9,1 +HCC_0107,1,1,1,0,0,1,1,1,0,1,0,0,0,0,0,0,1,0,1,1,0,0,1,50,80,1,0,1,1,1.18,32,14,90.1,5.2,121000,4.2,0.4,420,226,147,174,8.6,0.9,5,3,NA,26.4,54,2230,1 +HCC_0108,1,1,1,0,0,0,0,1,0,0,1,0,NA,0,1,0,0,1,1,1,0,0,1,79,75,0,3,1,2,1.32,7.6,5,69.5,3800,96000,3.7,0.5,17,69,76,86,6.3,2.68,1,10,NA,9,3,490,0 +HCC_0109,1,1,1,0,0,0,0,1,0,0,1,1,0,1,0,0,1,0,0,1,0,1,1,85,100,0,1,1,1,1.25,173,11.3,103.9,6200,176000,2.4,1.7,63,114,80,163,6.1,0.67,5,20,0.5,131,78,1316,0 +HCC_0110,0,0,1,0,0,0,0,1,NA,NA,0,0,0,0,0,0,0,1,0,1,0,0,0,62,NA,NA,0,1,1,1.54,2.3,12.1,89.7,4.5,97000,2.7,1.4,19,27,72,120,4.3,0.61,5,4,0.7,NA,NA,NA,1 +HCC_0111,1,1,1,1,0,1,0,1,NA,1,0,0,0,1,0,0,0,1,1,1,1,1,1,74,200,30,2,2,2,1.26,114,14.9,104.5,4.3,90000,3.2,4.8,106,154,148,166,7.2,0.48,5,12.6,1.8,161,96,297,1 +HCC_0112,1,1,1,0,0,0,0,1,0,NA,0,1,0,0,0,0,0,NA,1,1,1,0,1,56,90,NA,2,1,2,1.87,173,11.1,105.5,6.1,51000,3.1,32.3,110,206,127,188,5.4,1.29,5,NA,22.1,NA,NA,NA,0 +HCC_0114,1,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,1,1,1,1,1,0,62,0,7.5,1,1,1,1.45,42,16.2,99.1,5.001,77000,4.1,1.3,42,118,279,158,7.7,0.88,2,7.4,0.3,NA,NA,NA,1 +HCC_0116,1,1,1,0,NA,NA,0,1,0,1,0,0,0,0,0,0,0,NA,NA,NA,0,0,0,55,100,43,0,1,1,1.23,736,14,88.2,4.68,286000,4.7,0.8,48,113,649,629,8.4,0.71,5,9.1,0.3,NA,NA,NA,1 +HCC_0119,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,63,NA,0,0,1,1,1.28,5.2,14.6,96.1,6.1,194000,4.2,7.9,97,69,816,79,7.7,1.02,1,3,NA,NA,NA,NA,1 +HCC_0120,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,79,180,23,0,1,2,1.46,5.2,14.9,103.8,4500,53000,3.2,1.4,62,87,263,239,8.1,0.72,1,1.5,1,NA,NA,NA,1 +HCC_0122,1,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,NA,0,0,0,0,1,59,100,0,0,1,1,1.94,3.1,10.8,102.8,5300,97000,3.6,1.1,119,125,663,433,6.5,0.87,2,3.2,0.4,52.5,37,856,0 +HCC_0123,1,1,1,0,0,1,1,1,0,1,0,0,0,0,0,0,0,1,1,1,1,1,0,51,75,52.5,2,1,1,1.56,50655,9.8,85.6,3900,132000,2.6,2.6,123,219,503,363,7.3,0.55,1,4,1.5,40,12,57,0 +HCC_0124,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,NA,NA,0,0,0,0,1,74,0,0,0,1,1,1.11,1.2,15.1,83.8,5.2,178000,4.7,0.5,35,17,45.3,151,6.4,1.5,1,8.3,NA,88,27,90,1 +HCC_0125,1,1,1,0,0,1,1,1,NA,1,0,0,1,0,0,0,NA,1,0,1,0,0,0,62,NA,NA,2,1,2,1.08,657,11.8,89.2,9400,211000,3.2,0.8,43,101,646,466,7.3,0.7,1,8.3,NA,NA,NA,579,0 +HCC_0126,1,1,1,0,0,0,0,1,0,NA,0,0,0,0,0,0,0,0,0,1,1,0,1,76,100,NA,4,2,2,1.2,421500,14.3,89.5,9.8,309000,3.1,1.5,20,44,291,217,6.3,0.7,1,20,0.5,52,17,832,0 +HCC_0127,1,0,0,0,0,NA,1,1,0,NA,1,0,0,0,0,0,0,1,1,1,0,0,1,73,0,NA,0,1,1,1.2,472,15.6,88.4,5.5,83000,4,2.4,117,128,249,117,7.2,0.69,1,13,0.7,NA,NA,NA,1 +HCC_0128,1,0,1,0,0,0,NA,1,0,0,1,0,NA,1,0,0,0,NA,1,1,1,0,1,76,NA,0,3,2,1,1.66,77,12.3,104.2,2900,60000,3.2,2.8,54,38,311,182,6.2,0.77,2,4.3,1,93,47,307,1 +HCC_0130,0,1,1,NA,NA,NA,NA,1,0,0,1,0,0,0,0,NA,0,0,0,1,0,0,1,77,75,0,2,2,2,1.07,2,11.6,83.5,9,318000,3.89,0.9,23,48,319,171,7.1,0.66,2,5.8,NA,NA,NA,NA,0 +HCC_0131,0,1,0,NA,NA,NA,0,1,0,0,0,1,0,1,0,NA,NA,NA,0,0,1,1,0,75,0,0,2,1,3,1.22,4.2,14.9,87.4,15.4,179000,3.5,0.6,31,61,196,150,5.4,0.7,5,17.5,0.3,NA,NA,NA,1 +HCC_0133,0,0,0,0,0,0,1,1,NA,0,1,0,0,0,1,0,0,NA,1,0,0,0,0,72,0,0,0,1,1,1.21,152,10.9,99.6,7.3,93000,3.2,1.3,82,80,427,106,7.1,6.1,2,9,0.7,NA,NA,NA,0 +HCC_0134,0,1,0,NA,NA,NA,NA,0,0,0,0,0,NA,1,1,0,0,0,0,0,0,1,1,82,0,0,1,1,1,1.09,811,11.4,89.3,9.1,318000,3.4,0.8,77,102,739,587,7.2,2.14,5,16,NA,14,5,149,0 +HCC_0135,0,1,0,NA,NA,NA,NA,0,0,0,0,0,0,0,0,NA,0,0,0,0,0,0,1,46,0,0,0,1,1,1.42,4.7,14.2,90.3,6690,268000,3.1,0.32,37,44,80,517,5.5,0.7,1,13,0.12,NA,NA,NA,1 +HCC_0136,0,1,0,0,0,0,0,1,0,0,1,1,0,1,0,0,1,0,0,0,0,1,1,71,0,0,1,1,1,1.24,2.6,13.3,96.4,7.8,280000,4.1,0.6,70,52,141,123,6.8,0.82,5,8.3,NA,NA,NA,NA,1 +HCC_0137,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0,0,1,56,0,40,2,1,1,1.25,2089,15.4,91.6,10.9,175000,4.4,1.3,45,32,717,295,7.4,1.1,5,6,0.6,NA,NA,NA,1 +HCC_0138,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,78,0,0,0,2,1,1.03,18,13.2,89.5,2.6,136000,4.3,0.8,18,29,82,141,7.2,0.85,1,9.5,NA,91,31,80,1 +HCC_0140,0,1,1,0,0,1,1,1,0,1,1,1,0,1,0,0,0,0,0,1,0,0,1,76,NA,12,2,1,1,0.94,240,14.7,102.3,9.9,267000,3.6,0.5,64,132,356,192,7.4,0.9,3,2,0.4,NA,NA,NA,1 +HCC_0141,0,1,0,NA,NA,NA,0,1,0,0,0,0,0,0,0,NA,0,NA,0,0,1,0,0,43,0,0,0,1,1,1.25,180,12.2,87.6,7.2,130,3.5,0.5,79,58,229,302,7,0.6,5,9,NA,NA,NA,206,0 +HCC_0142,1,1,0,0,0,1,1,1,0,NA,0,0,0,0,0,0,0,NA,1,1,0,0,0,71,0,NA,0,1,1,1.47,15,13.3,89.7,5.7,154000,3.2,1,NA,87,120,108,102,0.68,3,2,NA,NA,NA,NA,0 +HCC_0143,1,NA,1,0,0,0,1,1,0,0,1,1,1,0,1,0,0,1,0,1,0,0,0,67,70,0,0,1,NA,1.02,24,16,98.8,6.6,96000,4.1,1.4,207,158,116,84,7.2,0.9,1,2.2,0.3,NA,NA,NA,1 +HCC_0144,1,0,1,0,0,0,0,1,0,1,1,1,0,0,0,0,NA,1,1,1,0,0,0,67,NA,40,0,1,1,1.798,9.4,11.2,102.4,4.1,60000,3.4,3.7,43,63,175,106,7.6,0.52,1,2.1,1.1,94,39,344,1 +HCC_0145,1,NA,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,NA,NA,NA,0,0,1,51,NA,37,0,1,1,1.26,7,14.9,106.3,6.4,122,3,1.5,195,401,272,93,6.4,1,3,2.9,0.4,124,51,642,1 +HCC_0146,1,1,1,0,0,0,0,1,0,NA,NA,NA,NA,NA,NA,0,NA,NA,NA,NA,0,0,0,80,NA,NA,0,1,1,1,4.8,9.2,94,6.2,157000,3.88,0.76,42,51,983,141,NA,1.1,1,15,0.33,NA,NA,NA,1 +HCC_0147,1,1,1,0,0,0,0,1,NA,1,0,1,0,1,1,0,NA,1,0,1,1,0,0,79,100,15,2,1,3,1.68,92421,14.3,72.2,13.3,459000,3.2,1.6,24,76,570,472,5.9,2.02,1,NA,0.6,29,4,14,0 +HCC_0148,1,0,1,0,NA,0,0,1,NA,NA,1,1,NA,1,0,0,0,1,1,1,0,0,1,75,NA,NA,0,1,1,1.71,5.2,11.1,106.9,2100,52000,3.3,2.6,15,47,94,117,7.1,0.79,1,3.5,1,NA,NA,NA,1 +HCC_0149,0,0,0,0,NA,0,0,1,NA,0,0,0,0,0,0,0,0,1,1,1,0,0,0,81,0,0,0,1,1,1.18,16,13.3,94.3,4800,96000,3.8,1.2,26,35,75,105,7.6,0.53,1,2.4,0.3,NA,NA,NA,1 +HCC_0150,0,1,0,0,0,0,0,0,NA,0,0,0,0,0,0,0,0,1,1,1,1,0,0,25,0,0,2,1,1,NA,1.5,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,1,6.6,NA,NA,NA,NA,1 +HCC_0152,0,0,1,0,0,0,0,1,0,NA,0,0,0,0,0,0,0,1,NA,NA,0,0,1,69,NA,NA,0,1,1,1.2,10,13.5,104.9,13.5,194,4,1,31,79,126,85,7.6,0.8,1,7,0.4,NA,NA,NA,1 +HCC_0154,1,1,1,NA,NA,NA,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,87,NA,0,3,1,1,1.2,33,9.7,91.6,10.1,277,3.8,2.4,60,54,468,338,7,1.13,1,15,1.3,NA,NA,NA,0 +HCC_0156,1,1,1,0,0,0,0,1,NA,1,0,0,1,0,0,0,0,NA,1,1,1,0,1,64,75,25,3,2,3,1.63,1671,12.8,101.6,4.4,172000,3.44,5.8,38,95,92,139,7.6,0.9,3,9,2.9,111,94,1600,0 +HCC_0157,1,1,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,49,NA,0,1,1,1,1.24,975,15.3,103,11.5,124000,3.5,1.2,62,85,561,266,7.5,0.77,1,2.3,0.6,180,70,1176,0 +HCC_0158,1,NA,1,0,0,0,0,1,NA,1,0,0,0,1,0,0,0,1,1,1,0,0,1,62,NA,20,0,1,2,1.41,1.7,14.7,97.2,6900,72000,3.5,1.3,31,24,67,97,7.3,0.76,1,3.5,0.3,NA,NA,NA,1 +HCC_0159,1,NA,0,0,0,0,0,1,NA,NA,1,0,0,0,1,0,0,1,1,1,0,0,1,71,0,NA,3,1,1,1.16,1713,8.2,94.2,6,209000,3.6,0.3,62,59,450,263,6.8,1.49,1,7.5,NA,NA,NA,NA,1 +HCC_0160,1,1,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,NA,1,1,0,1,1,64,100,0,3,3,3,1.52,4.9,7.9,111.2,4.1,67000,2.43,1.9,40,71,69,73,4.8,0.77,5,3.2,0.7,40,18,283,0 +HCC_0162,0,1,0,NA,NA,NA,NA,1,0,0,0,0,0,1,0,NA,0,1,1,1,0,0,1,68,0,0,2,1,1,1.33,4887,12.1,88.9,2.5,141,3,3.6,50,91,147,280,6.7,0.7,1,2.2,2.3,NA,NA,NA,0 +HCC_0163,1,0,1,0,0,0,0,1,0,1,1,1,0,1,1,0,NA,NA,NA,NA,0,0,1,65,NA,48,0,1,1,1.13,75,13.3,90,8,385000,4.3,0.6,53,52,164,181,7.5,1.46,5,18.6,NA,NA,NA,NA,1 +HCC_0164,1,0,1,1,0,1,1,1,1,1,0,0,0,0,0,1,0,NA,NA,NA,1,1,1,44,NA,NA,2,1,1,2.14,94964,15.6,117.3,5200,118000,4.8,1.1,50,60,320,170,8.4,0.74,5,18,NA,NA,NA,NA,0 +HCC_0165,1,1,1,0,0,0,1,1,0,1,0,0,0,0,0,0,0,NA,1,1,0,1,1,52,50,NA,0,1,1,1.79,44340,12.7,95.8,14.4,412000,2.2,28.5,78,127,444,462,6.6,3.95,5,8.5,19.8,NA,NA,NA,0 diff --git a/data/UCIBinaryClassification/hcc_survival_copy.csv b/data/UCIBinaryClassification/hcc_survival_copy.csv new file mode 100644 index 00000000..2edf5c48 --- /dev/null +++ b/data/UCIBinaryClassification/hcc_survival_copy.csv @@ -0,0 +1,133 @@ +InstanceID,Gender,Symptoms,Alcohol,HepatitisBSurfaceAntigen,HepatitisBeAntigen,HepatitisBCoreAntibody,HepatitisCVirusAntibody,Cirrhosis,EndemicCountries,Smoking,Diabetes,Obesity,Hemochromatosis,ArterialHypertension,ChronicRenalInsufficiency,HIV,NASH,EsophagealVarices,Splenomegaly,PortalHypertension,PortalVeinThrombosis,LiverMetastasis,RadiologicalHallmark,AgeAtDiagnosis,GramsAlcoholPerDay,PacksCigarettesPerYear,PerformanceStatus,EncephalopathyDegree,AscitesDegree,InternationalNormalisedRatio,AlphaFetoprotein,Hemoglobin,MeanCorpuscularVolume,Leukocytes,Platelets,Albumin,TotalBilirubin,AlanineTransaminase,AspartateTransaminase,GammaGlutamylTransferase,AlkalinePhosphatase,TotalProteins,Creatinine,NumberOfNodules,MajorDimensionOfNodule,DirectBilirubin,Iron,OxygenSaturation,Ferritin,Class +HCC_0001,1,0,1,0,0,0,0,1,0,1,1,NA,1,0,0,0,0,1,0,0,0,0,1,67,137,15,0,1,1,1.53,95,13.7,106.6,4.9,99,3.4,2.1,34,41,183,150,7.1,0.7,1,3.5,0.5,NA,NA,NA,1 +HCC_0002,0,NA,0,0,0,0,1,1,NA,NA,1,0,0,1,0,0,0,1,0,0,0,0,1,62,0,NA,0,1,1,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,1,1.8,NA,NA,NA,NA,1 +HCC_0003,1,0,1,1,0,1,0,1,0,1,0,0,0,1,1,0,0,0,0,1,0,1,1,78,50,50,2,1,2,0.96,5.8,8.9,79.8,8.4,472,3.3,0.4,58,68,202,109,7,2.1,5,13,0.1,28,6,16,1 +HCC_0004,1,1,1,0,0,0,0,1,0,1,1,0,0,1,0,0,0,0,0,0,0,1,1,77,40,30,0,1,1,0.95,2440,13.4,97.1,9,279,3.7,0.4,16,64,94,174,8.1,1.11,2,15.7,0.2,NA,NA,NA,0 +HCC_0006,1,0,1,0,NA,0,0,1,0,NA,0,1,0,0,0,0,0,1,1,1,0,0,1,75,NA,NA,1,1,2,1.58,110,13.4,91.5,5.4,85,3.4,3.5,91,122,242,396,5.6,0.9,1,10,1.4,53,22,111,0 +HCC_0007,1,0,0,0,NA,1,1,1,0,0,1,0,NA,0,0,0,0,0,0,0,0,0,1,49,0,0,0,1,1,1.4,138.9,10.4,102,3.2,42000,2.35,2.72,119,183,143,211,7.3,0.8,5,2.6,2.19,171,126,1452,0 +HCC_0008,1,1,1,0,NA,0,0,1,0,1,1,NA,0,0,0,0,0,0,1,1,1,0,1,61,NA,20,3,1,1,1.46,9860,10.8,92,3,58,3.1,3.2,79,108,184,300,7.1,0.52,2,9,1.3,42,25,706,0 +HCC_0009,1,1,1,0,0,0,0,1,0,1,1,0,0,1,0,0,0,NA,1,1,0,0,1,50,100,32,1,1,2,3.14,8.8,11.9,107.5,4.9,70,1.9,3.3,26,59,115,63,6.1,0.59,1,6.4,1.2,85,73,982,1 +HCC_0010,1,1,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,43,100,0,0,1,1,1.12,1.8,11.8,87.8,5100,193000,4.2,0.5,71,45,256,303,7.1,0.59,1,9.3,0.7,NA,NA,NA,1 +HCC_0011,1,0,1,0,0,0,1,1,NA,NA,0,0,0,0,0,0,0,NA,1,1,0,0,1,41,NA,NA,0,1,2,1.05,100809,13,94.2,5.7,196,4.4,3,90,334,494,236,7.6,0.8,5,NA,1.1,NA,NA,NA,0 +HCC_0012,1,0,1,0,0,0,1,1,1,0,0,0,0,1,0,0,0,NA,0,1,0,0,1,74,NA,0,0,1,1,1.33,86,15.7,96.7,4,61,3.7,1.3,132,168,113,154,NA,7.6,5,1.9,0.3,144,41,277,1 +HCC_0013,1,0,1,0,0,0,0,1,0,1,1,0,0,1,0,0,NA,NA,1,1,1,0,0,66,NA,30,0,1,1,1.53,60,13.3,90.1,5.5,207000,4.4,8.5,25,36,35,74,8.5,0.73,1,5,0.8,NA,NA,NA,1 +HCC_0015,1,0,1,0,0,0,0,1,0,NA,1,0,0,1,0,0,NA,1,1,1,0,0,1,63,NA,NA,2,2,2,1.25,29,13.5,93,6,128,3.15,10.5,76,116,165,163,7.3,1.07,4,4.5,4.5,197,84,302,1 +HCC_0017,1,0,1,0,0,0,0,1,NA,1,1,NA,1,0,0,0,NA,NA,1,1,1,0,1,72,NA,NA,3,2,1,2.14,60,12.1,99.2,5,58,2.4,9.8,69,63,201,235,6.2,0.96,2,2,2.9,136,95,767,0 +HCC_0019,1,NA,1,0,0,0,0,1,NA,1,0,NA,0,1,1,0,0,1,0,0,0,0,1,64,200,78,1,1,1,1.13,8.8,14.9,94.8,6.3,137,4.3,0.9,16,23,82,180,6.5,4.95,1,5.4,0.9,144,49,295,1 +HCC_0020,1,1,1,0,0,0,0,1,NA,NA,0,0,0,1,0,0,0,1,1,1,1,0,1,75,500,NA,0,1,3,1.44,34,15.9,103.4,9600,101000,3.4,3.4,27,87,260,147,6.3,0.9,5,2.3,1.6,67,34,774,0 +HCC_0021,1,0,1,0,0,0,0,1,NA,1,0,1,0,0,0,0,0,1,1,1,0,0,0,71,200,60,0,1,1,1.29,19.6,11.7,101,2600,109000,3.6,1.7,13,35,23,141,7.3,0.68,1,2.5,0.7,152.6,NA,76.9,1 +HCC_0022,1,0,1,0,0,1,1,1,0,1,0,0,0,0,0,0,0,NA,0,0,0,0,0,73,80,47,0,1,1,1.06,3.9,16.4,90.7,7.8,187,4.5,1,54,47,52,97,6.3,0.75,1,6.8,0.2,87,26,84,1 +HCC_0023,1,1,1,0,0,1,0,1,NA,0,0,1,0,1,0,0,0,0,1,1,0,0,1,66,180,0,1,1,3,1.27,1975,10.8,86.5,9100,154000,3.1,1.2,68,136,869,562,69,1.14,5,3.8,0.5,112,73,1001,0 +HCC_0024,1,1,1,0,0,0,0,1,1,1,1,0,0,1,0,0,0,1,1,1,1,1,1,64,200,60,1,1,1,4.82,185,10.7,88.1,5,194000,3.6,3.8,217,86,879,396,7,0.53,5,15,1.6,NA,NA,NA,0 +HCC_0025,1,1,1,0,NA,1,0,0,0,1,0,0,NA,1,0,NA,0,NA,0,NA,0,1,0,84,150,NA,4,1,1,1.74,5532,13.1,111,3.5,351000,2.4,1.3,26,67,108,311,5.6,0.95,1,10,0.7,NA,NA,NA,0 +HCC_0026,1,0,1,0,NA,0,0,1,0,0,1,0,0,0,0,0,0,1,1,1,1,0,1,80,100,0,2,1,1,1.33,13327,13.7,94.3,5.2,110,3.1,1.6,52,107,465,233,8.4,0.79,5,NA,0.7,93,31,79,1 +HCC_0027,1,1,1,NA,NA,NA,1,1,0,1,0,0,NA,0,0,NA,0,1,1,1,1,0,1,45,50,16,1,1,3,1.38,NA,13.6,98.4,4.3,99000,3.3,1.3,178,325,252,172,8.1,0.83,1,5,0.7,NA,NA,NA,0 +HCC_0028,1,NA,1,1,0,1,0,1,NA,NA,0,0,0,0,0,0,0,1,1,1,0,0,1,57,NA,NA,0,1,1,1.37,5.9,15.5,88.2,4.9,113,4.5,3.2,36,65,34,111,NA,NA,2,4,1,180,56,NA,1 +HCC_0029,1,0,1,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,1,1,1,0,1,61,60,67.5,1,1,1,1.3,3255,12.2,89.5,4.4,108,3,1.1,59,85,419,293,7.7,0.67,2,6.5,0.4,94,27,70,0 +HCC_0030,1,1,1,0,NA,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,20,NA,2,1,1,1,1.21,1.9,9.9,83.4,8.1,556,3.2,1.8,150,112,599,974,7.7,0.7,5,NA,1.1,22,7,369,1 +HCC_0031,1,1,1,1,0,NA,0,1,1,1,0,0,0,0,0,0,0,NA,1,1,1,0,1,60,20,8,2,1,1,1.19,11,13.1,87.9,7.8,212,3.5,0.7,27,26,143,158,8.2,0.71,1,16,NA,NA,NA,NA,1 +HCC_0032,1,0,1,0,NA,0,0,1,NA,1,1,NA,0,1,0,0,0,1,1,1,0,0,1,62,120,NA,0,1,1,1.44,1237,12.2,94,6200,93000,4.2,1,35,85,191,129,58,1.06,5,7,NA,75,24,239,1 +HCC_0033,1,1,1,NA,NA,NA,0,1,NA,NA,0,0,0,0,0,0,0,0,0,0,0,0,1,67,100,NA,0,1,1,1.32,7.7,15.7,96.1,9.1,268000,3.4,0.6,20,29,49,135,8.2,0.9,2,NA,NA,NA,NA,NA,1 +HCC_0034,1,1,1,0,NA,0,0,1,NA,NA,0,0,0,1,0,0,NA,0,0,0,0,0,1,77,NA,NA,0,1,1,1.24,266,13.7,97.7,13000,170000,4.2,0.5,68,85,232,227,16.8,1.72,1,5.9,NA,NA,NA,NA,1 +HCC_0036,1,NA,0,1,NA,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,76,0,0,0,1,1,0.96,14.2,14.8,98.5,4.95,187,4.2,0.77,43,86,89,113,6.7,0.95,3,8.8,0.37,NA,NA,NA,1 +HCC_0037,1,1,1,0,0,0,0,1,0,0,1,0,0,1,0,0,0,NA,1,1,0,0,1,73,75,0,4,1,2,2,3.1,13.1,109.3,44.6,60,2.3,7.8,38,74,180,127,5.6,0.88,5,3.1,3.3,98,89,870,0 +HCC_0039,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,70,100,0,0,1,1,1.09,5.4,14.9,105,7.2,230000,4.2,1.3,18,26,174,92,7.3,0.8,2,6,0.3,NA,NA,NA,1 +HCC_0040,1,1,1,1,0,1,1,1,1,0,0,0,0,1,0,0,0,NA,0,NA,0,1,1,59,200,0,0,1,1,1.42,479,11.3,82.2,9500,160000,3.1,1.4,113,143,924,288,7.9,0.98,5,17,0.6,NA,NA,NA,1 +HCC_0041,0,NA,0,0,0,1,1,1,0,0,0,0,NA,1,0,0,0,NA,NA,NA,0,0,1,71,0,0,0,1,1,1.18,19,13.9,88.3,6.86,201000,4.4,0.8,142,117,123,104,8.5,0.74,2,3.3,0.3,143,50.18,120,1 +HCC_0042,1,0,0,0,0,1,0,1,0,0,1,1,0,1,0,0,0,NA,0,0,NA,NA,0,66,0,0,0,1,1,1.21,2.8,15.7,92.7,15.4,188000,4.1,0.7,299,553,196,68,6.5,1.3,1,5,0.3,NA,NA,NA,1 +HCC_0044,1,0,1,NA,NA,NA,NA,1,0,NA,0,1,0,0,0,NA,1,1,1,1,0,0,1,71,75,NA,0,1,1,1.17,5,15.1,104.1,4.3,65000,3.8,2.5,61,56,239,56,7.3,0.7,1,2,0.2,NA,NA,NA,1 +HCC_0045,0,0,0,0,0,1,1,1,NA,0,0,0,0,0,0,0,0,NA,1,1,0,0,1,52,0,0,0,1,1,1.71,237,15.6,98.1,4.3,88,3.2,2.2,30,52,72,97,6.7,0.86,5,2.2,0.5,NA,NA,NA,1 +HCC_0046,1,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,60,NA,0,0,1,1,1.18,2.8,16.6,93.8,8300,167000,4.9,0.9,35,29,62,68,8.3,0.72,1,2.3,NA,NA,NA,NA,1 +HCC_0047,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,NA,NA,NA,45,0,0,0,1,1,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,1 +HCC_0048,1,1,1,0,0,0,0,1,0,NA,0,0,0,0,0,0,0,1,1,1,1,1,0,66,NA,NA,1,1,2,1.64,16,14,102.9,11.5,277000,3.1,6.8,140,244,795,595,7.2,0.79,1,2.3,4.1,63,34,888,0 +HCC_0049,1,1,0,0,0,0,0,0,0,1,1,0,0,1,1,0,1,0,0,0,0,0,0,80,0,80,0,1,1,1.33,163,10.6,96.2,9900,280000,3.3,1,28,57,236,171,7.5,1.38,1,19,NA,45,21,802,0 +HCC_0051,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,NA,0,0,0,1,1,27,0,0,2,1,1,0.97,46,10.5,78.7,20.9,251,2.4,0.3,31,185,91,539,5,0.38,5,20,0.3,NA,NA,NA,0 +HCC_0054,1,NA,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,1,1,0,0,1,50,NA,0,0,1,1,1.65,7.3,15.3,93.7,3500,57000,NA,1.4,111,93,294,130,NA,0.76,2,2,0.3,184,2.26,59,1 +HCC_0057,1,1,1,0,NA,NA,NA,1,0,1,1,0,NA,1,0,0,NA,0,0,1,0,0,1,81,100,10,2,1,2,3.56,2.7,7.3,90.8,2.42,159000,3.4,0.5,25,32,80,55,6.2,0.85,1,2.2,NA,22,6,48,0 +HCC_0058,1,NA,1,0,0,0,0,1,0,1,1,0,0,1,0,0,0,1,0,1,0,0,1,65,100,NA,0,1,1,1.24,2.6,10.3,83,6.1,1.71,3.9,0.8,11,28,77,120,7,0.58,1,4.7,0.85,32,10,18,1 +HCC_0061,1,1,0,1,0,1,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,1,76,0,50,1,1,3,1.28,608,12.6,100,5.4,129,4,1.7,107,99,125,100,7.5,0.9,5,3.5,0.5,NA,NA,NA,1 +HCC_0062,1,1,1,0,0,1,1,1,0,1,0,0,0,0,0,0,0,1,1,1,0,0,1,56,100,40,0,2,2,1.46,41,14.6,100.8,5.5,42000,3.1,3.7,121,165,101,207,6.3,0.69,1,3,1.9,224,95,363,1 +HCC_0063,0,0,1,0,0,0,0,1,0,1,0,1,0,0,0,0,0,1,1,1,0,0,1,68,NA,30,2,1,2,1.94,NA,11.5,97.4,5700,77000,2.7,4.9,34,48,46,178,6.1,0.62,1,4.6,2.2,NA,NA,NA,1 +HCC_0064,1,1,1,0,0,0,0,1,0,1,1,0,0,1,0,0,0,1,1,1,0,0,1,72,300,NA,3,1,3,1.57,2,12.6,96.6,2.9,76000,3.5,2.4,33,40,110,166,NA,0.77,1,2,0.5,NA,NA,NA,1 +HCC_0065,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,NA,NA,NA,NA,0,0,0,66,0,0,0,1,1,1.29,7,12.1,95.1,3.8,77000,3.8,1.4,37,38,194,161,6.7,0.71,1,10,0.5,0,0,0,1 +HCC_0066,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,NA,NA,0,0,1,0,40,0,0,2,1,1,1.17,3.1,15.1,86,8.9,275000,2.8,1.3,74,50,23,104,5.4,0.6,5,7.8,0.2,46,18,NA,0 +HCC_0067,1,NA,1,0,NA,1,0,1,0,1,0,0,0,0,0,0,0,NA,1,1,0,0,1,68,60,NA,0,1,1,1.34,13,15.6,93,4.9,91000,4.54,1.4,54,52,275,113,7.8,0.55,2,6.2,0.3,94,33,393,1 +HCC_0068,1,1,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,63,100,0,0,1,1,2.07,1.7,9.5,99.2,3300,79000,2.1,1.6,56,82,134,113,37,0.4,1,2.7,0.2,94,37,48,1 +HCC_0069,1,1,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,NA,1,1,0,1,1,72,100,0,0,1,2,1.3,249,12.7,100.3,5.5,114,3.1,3.9,21,42,40,108,5.8,0.9,5,8,1.2,37,17,419,0 +HCC_0070,0,1,1,0,0,1,0,1,NA,0,0,1,0,0,1,0,NA,NA,0,1,1,0,1,88,80,0,2,2,3,1.27,66,10.9,97.3,8.9,270,2.7,2.1,145,84,179,260,5.9,NA,5,3,1.3,15,17,639,0 +HCC_0071,0,1,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,NA,1,1,0,0,1,23,0,0,0,1,1,1.17,358,12.7,74,2.2,51,2.9,2.8,53,41,54,94,4.9,0.2,2,5.4,0.8,50,16,20,1 +HCC_0072,1,1,1,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,1,1,1,59,75,44,3,2,2,1.01,1810346,13,102.1,8300,433000,3.4,1.9,138,86,1575,417,6.5,0.64,5,15,1.1,NA,NA,NA,1 +HCC_0074,1,1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,NA,0,0,1,1,1,67,NA,0,0,1,1,0.94,20,13,92,6.9,222000,3.7,0.6,162,354,1390,684,7.1,0.81,5,NA,NA,NA,NA,NA,0 +HCC_0075,1,1,1,0,NA,0,0,1,0,1,0,0,0,1,0,0,0,1,1,1,0,0,1,61,NA,15,0,1,1,1.15,2.5,14.9,92.3,6,159000,3.8,1,28,38,74,101,7.4,1.1,5,7.5,0.3,61,NA,255,1 +HCC_0076,1,1,1,0,NA,NA,1,1,NA,NA,0,0,0,0,0,0,0,1,1,1,0,0,1,61,100,NA,0,1,1,1.92,2269,12.1,119,5.1,80000,NA,9.6,204,357,199,174,NA,0.99,1,7.6,4.6,178,90,960,0 +HCC_0078,1,1,1,0,0,0,0,1,NA,NA,0,0,0,0,0,0,0,NA,0,1,0,0,1,78,80,NA,0,1,1,1.45,5.1,14.4,100.2,7.1,77000,4.1,0.9,43,63,540,114,7,1.09,5,NA,NA,NA,NA,NA,1 +HCC_0080,1,NA,1,0,0,0,1,1,NA,1,0,0,0,0,0,0,0,1,1,1,0,0,0,51,100,34.5,2,2,2,2.08,2.9,10.4,91.1,5.8,91000,2.4,16,123,145,109,190,5.9,0.9,0,NA,9.6,NA,NA,NA,1 +HCC_0081,1,1,1,NA,NA,NA,NA,1,0,NA,1,0,0,1,1,0,NA,NA,1,1,0,1,1,74,NA,NA,3,2,1,1.32,2.5,12.6,83.7,9.8,102000,3.3,1.2,29,43,196,204,7.3,1.1,5,NA,0.5,NA,NA,NA,0 +HCC_0084,1,1,1,0,0,0,0,1,0,NA,0,0,0,0,0,0,0,1,1,1,1,0,1,83,100,NA,2,1,3,1.48,2.6,12.7,106,3.8,80,2.9,3.4,34,53,156,207,7.2,NA,2,4.1,1.4,105,69,221,0 +HCC_0085,1,NA,0,0,0,0,1,1,NA,1,1,0,0,1,0,0,0,0,1,0,0,0,1,57,0,NA,0,NA,NA,1.1,2.9,16.4,94.8,4.6,94000,4.1,1.1,104,74,88,85,7.9,1.05,1,5.5,0.3,NA,NA,NA,1 +HCC_0086,1,1,1,0,0,1,0,1,0,1,0,1,0,0,0,0,0,0,1,1,1,0,1,58,NA,10,1,2,1,1.47,20,13.9,100.8,4,112000,3,2.9,50,92,124,244,6.3,0.8,2,6.8,0.7,181,99,108,1 +HCC_0087,1,1,1,0,0,0,0,1,0,NA,0,0,0,0,0,0,0,NA,0,1,0,1,1,71,NA,NA,1,1,1,1.08,2.79,12.6,83.9,7100,284000,NA,NA,28,46,70,213,NA,0.48,5,NA,NA,26,8,NA,1 +HCC_0088,1,0,0,0,0,1,1,1,0,1,0,0,0,0,0,1,0,0,1,1,0,0,1,52,0,33,0,1,2,NA,42,15.8,97.9,4.2,142000,4.2,0.5,74,62,38,70,7.5,0.77,3,1.5,NA,120,35,30,1 +HCC_0089,1,1,1,0,0,0,0,1,0,NA,1,0,0,0,0,0,0,1,1,1,0,0,1,74,100,NA,0,1,2,1.37,457,11.7,70.6,5.7,138000,4.1,2.1,22,33,33,90,9.7,1.6,5,5.6,0.9,13,3,28,0 +HCC_0090,1,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,1,1,0,0,1,61,NA,50,1,2,3,1.23,NA,9.5,90,7.6,38000,2.2,1.5,59,51,993,474,3.9,2.69,1,2,1,NA,NA,NA,1 +HCC_0091,1,1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,69,100,0,2,1,3,1.41,123,10.1,89.5,2.3,89000,4,4.3,31,60,75,177,6.8,0.7,3,3.5,1,37,11,173,0 +HCC_0092,1,0,1,0,NA,0,0,1,0,NA,1,0,0,1,0,0,0,1,1,1,NA,NA,NA,65,NA,NA,0,1,1,1.22,8.7,14.6,95.1,6.7,142000,4.2,1.3,19,33,346,120,7.8,0.83,NA,NA,0.3,184,65,423,1 +HCC_0093,1,1,1,0,0,1,0,1,0,0,1,0,NA,1,1,0,0,NA,0,1,0,0,1,79,70,0,3,1,1,1.01,226,11.5,95.6,6.3,108,4.2,1,27,31,667,222,6.2,3.13,1,8.8,0.2,NA,NA,NA,0 +HCC_0094,1,1,1,0,0,0,0,1,0,1,1,1,NA,NA,0,NA,0,NA,NA,1,1,1,1,69,200,60,1,1,1,1.39,2159,13.1,90.6,10400,261000,3.6,1.9,42,197,552,335,7.1,0.68,5,NA,0.6,NA,NA,NA,0 +HCC_0095,1,NA,1,0,0,0,0,1,0,1,1,0,0,1,1,NA,0,0,0,0,0,0,1,87,100,50,0,1,1,1.09,48,12.6,97.6,4.9,169000,4.2,0.8,30,31,86,91,6.9,1.9,5,2,NA,53,21,278,1 +HCC_0096,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,78,0,0,1,1,1,1.6,2.4,9.5,85.8,6900,228000,3.5,0.6,11,17,44,124,6.8,1.6,1,5.5,NA,15,7,810,0 +HCC_0097,1,1,1,0,0,0,1,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,1,71,NA,0,1,1,2,1.11,5,9.1,90.9,6.36,307000,2.47,NA,31,29,339,254,5.5,1.18,3,6.3,NA,NA,NA,NA,1 +HCC_0098,1,0,1,0,0,0,0,1,0,NA,0,0,NA,0,0,0,0,1,1,1,1,0,1,58,NA,NA,0,1,1,1.64,64,14.1,103.6,4.5,68,2.9,3.3,28,43,51,137,6.8,0.67,4,4.7,1.1,NA,NA,NA,1 +HCC_0100,1,0,1,0,NA,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,73,NA,0,2,1,2,1.67,8.5,13,102.3,24.8,133000,2.7,9.5,262,335,351,66,6.1,1.2,5,7,5.5,NA,NA,NA,1 +HCC_0101,1,1,1,NA,NA,NA,0,1,0,0,0,0,0,0,0,NA,0,1,1,1,0,1,0,93,NA,0,2,1,1,1.16,2785,12,94.4,7.9,78000,2.6,3.5,26,34,339,297,5.7,2.19,5,NA,1.5,55,33,256,1 +HCC_0103,1,1,1,0,0,0,0,1,0,NA,0,0,0,1,0,0,NA,1,1,1,0,0,1,64,70,NA,2,1,2,1.55,5.7,13.9,99.7,5200,124000,2.1,0.8,37,75,203,110,5,0.56,3,2.4,NA,92,56,489,1 +HCC_0104,1,1,0,1,NA,NA,1,1,NA,NA,0,0,NA,0,0,0,0,NA,NA,1,0,NA,0,63,0,NA,4,3,3,1.93,NA,13.5,93.3,8190,406000,2.9,40.5,139,266,403,670,6.3,4.82,5,NA,29.3,NA,NA,NA,0 +HCC_0105,1,1,0,0,0,0,0,0,NA,1,0,0,0,1,0,0,0,0,0,0,0,0,0,64,0,50,1,1,1,1.17,39,12.6,93.8,4900,144000,3.8,1,42,74,277,312,78,1.01,1,15,NA,87,25,81,1 +HCC_0106,1,1,1,0,0,0,0,1,NA,0,0,0,0,1,1,0,0,1,1,1,0,0,1,67,NA,0,3,1,2,1.48,2.5,14.3,101.5,5,120,2.2,1.2,34,71,222,97,5.2,2.82,3,2.4,0.3,92,56,48.9,1 +HCC_0107,1,1,1,0,0,1,1,1,0,1,0,0,0,0,0,0,1,0,1,1,0,0,1,50,80,1,0,1,1,1.18,32,14,90.1,5.2,121000,4.2,0.4,420,226,147,174,8.6,0.9,5,3,NA,26.4,54,2230,1 +HCC_0108,1,1,1,0,0,0,0,1,0,0,1,0,NA,0,1,0,0,1,1,1,0,0,1,79,75,0,3,1,2,1.32,7.6,5,69.5,3800,96000,3.7,0.5,17,69,76,86,6.3,2.68,1,10,NA,9,3,490,0 +HCC_0109,1,1,1,0,0,0,0,1,0,0,1,1,0,1,0,0,1,0,0,1,0,1,1,85,100,0,1,1,1,1.25,173,11.3,103.9,6200,176000,2.4,1.7,63,114,80,163,6.1,0.67,5,20,0.5,131,78,1316,0 +HCC_0110,0,0,1,0,0,0,0,1,NA,NA,0,0,0,0,0,0,0,1,0,1,0,0,0,62,NA,NA,0,1,1,1.54,2.3,12.1,89.7,4.5,97000,2.7,1.4,19,27,72,120,4.3,0.61,5,4,0.7,NA,NA,NA,1 +HCC_0111,1,1,1,1,0,1,0,1,NA,1,0,0,0,1,0,0,0,1,1,1,1,1,1,74,200,30,2,2,2,1.26,114,14.9,104.5,4.3,90000,3.2,4.8,106,154,148,166,7.2,0.48,5,12.6,1.8,161,96,297,1 +HCC_0112,1,1,1,0,0,0,0,1,0,NA,0,1,0,0,0,0,0,NA,1,1,1,0,1,56,90,NA,2,1,2,1.87,173,11.1,105.5,6.1,51000,3.1,32.3,110,206,127,188,5.4,1.29,5,NA,22.1,NA,NA,NA,0 +HCC_0114,1,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,1,1,1,1,1,0,62,0,7.5,1,1,1,1.45,42,16.2,99.1,5.001,77000,4.1,1.3,42,118,279,158,7.7,0.88,2,7.4,0.3,NA,NA,NA,1 +HCC_0116,1,1,1,0,NA,NA,0,1,0,1,0,0,0,0,0,0,0,NA,NA,NA,0,0,0,55,100,43,0,1,1,1.23,736,14,88.2,4.68,286000,4.7,0.8,48,113,649,629,8.4,0.71,5,9.1,0.3,NA,NA,NA,1 +HCC_0119,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,63,NA,0,0,1,1,1.28,5.2,14.6,96.1,6.1,194000,4.2,7.9,97,69,816,79,7.7,1.02,1,3,NA,NA,NA,NA,1 +HCC_0120,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,79,180,23,0,1,2,1.46,5.2,14.9,103.8,4500,53000,3.2,1.4,62,87,263,239,8.1,0.72,1,1.5,1,NA,NA,NA,1 +HCC_0122,1,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,NA,0,0,0,0,1,59,100,0,0,1,1,1.94,3.1,10.8,102.8,5300,97000,3.6,1.1,119,125,663,433,6.5,0.87,2,3.2,0.4,52.5,37,856,0 +HCC_0123,1,1,1,0,0,1,1,1,0,1,0,0,0,0,0,0,0,1,1,1,1,1,0,51,75,52.5,2,1,1,1.56,50655,9.8,85.6,3900,132000,2.6,2.6,123,219,503,363,7.3,0.55,1,4,1.5,40,12,57,0 +HCC_0124,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,NA,NA,0,0,0,0,1,74,0,0,0,1,1,1.11,1.2,15.1,83.8,5.2,178000,4.7,0.5,35,17,45.3,151,6.4,1.5,1,8.3,NA,88,27,90,1 +HCC_0125,1,1,1,0,0,1,1,1,NA,1,0,0,1,0,0,0,NA,1,0,1,0,0,0,62,NA,NA,2,1,2,1.08,657,11.8,89.2,9400,211000,3.2,0.8,43,101,646,466,7.3,0.7,1,8.3,NA,NA,NA,579,0 +HCC_0126,1,1,1,0,0,0,0,1,0,NA,0,0,0,0,0,0,0,0,0,1,1,0,1,76,100,NA,4,2,2,1.2,421500,14.3,89.5,9.8,309000,3.1,1.5,20,44,291,217,6.3,0.7,1,20,0.5,52,17,832,0 +HCC_0127,1,0,0,0,0,NA,1,1,0,NA,1,0,0,0,0,0,0,1,1,1,0,0,1,73,0,NA,0,1,1,1.2,472,15.6,88.4,5.5,83000,4,2.4,117,128,249,117,7.2,0.69,1,13,0.7,NA,NA,NA,1 +HCC_0128,1,0,1,0,0,0,NA,1,0,0,1,0,NA,1,0,0,0,NA,1,1,1,0,1,76,NA,0,3,2,1,1.66,77,12.3,104.2,2900,60000,3.2,2.8,54,38,311,182,6.2,0.77,2,4.3,1,93,47,307,1 +HCC_0130,0,1,1,NA,NA,NA,NA,1,0,0,1,0,0,0,0,NA,0,0,0,1,0,0,1,77,75,0,2,2,2,1.07,2,11.6,83.5,9,318000,3.89,0.9,23,48,319,171,7.1,0.66,2,5.8,NA,NA,NA,NA,0 +HCC_0131,0,1,0,NA,NA,NA,0,1,0,0,0,1,0,1,0,NA,NA,NA,0,0,1,1,0,75,0,0,2,1,3,1.22,4.2,14.9,87.4,15.4,179000,3.5,0.6,31,61,196,150,5.4,0.7,5,17.5,0.3,NA,NA,NA,1 +HCC_0133,0,0,0,0,0,0,1,1,NA,0,1,0,0,0,1,0,0,NA,1,0,0,0,0,72,0,0,0,1,1,1.21,152,10.9,99.6,7.3,93000,3.2,1.3,82,80,427,106,7.1,6.1,2,9,0.7,NA,NA,NA,0 +HCC_0134,0,1,0,NA,NA,NA,NA,0,0,0,0,0,NA,1,1,0,0,0,0,0,0,1,1,82,0,0,1,1,1,1.09,811,11.4,89.3,9.1,318000,3.4,0.8,77,102,739,587,7.2,2.14,5,16,NA,14,5,149,0 +HCC_0135,0,1,0,NA,NA,NA,NA,0,0,0,0,0,0,0,0,NA,0,0,0,0,0,0,1,46,0,0,0,1,1,1.42,4.7,14.2,90.3,6690,268000,3.1,0.32,37,44,80,517,5.5,0.7,1,13,0.12,NA,NA,NA,1 +HCC_0136,0,1,0,0,0,0,0,1,0,0,1,1,0,1,0,0,1,0,0,0,0,1,1,71,0,0,1,1,1,1.24,2.6,13.3,96.4,7.8,280000,4.1,0.6,70,52,141,123,6.8,0.82,5,8.3,NA,NA,NA,NA,1 +HCC_0137,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0,0,1,56,0,40,2,1,1,1.25,2089,15.4,91.6,10.9,175000,4.4,1.3,45,32,717,295,7.4,1.1,5,6,0.6,NA,NA,NA,1 +HCC_0138,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,78,0,0,0,2,1,1.03,18,13.2,89.5,2.6,136000,4.3,0.8,18,29,82,141,7.2,0.85,1,9.5,NA,91,31,80,1 +HCC_0140,0,1,1,0,0,1,1,1,0,1,1,1,0,1,0,0,0,0,0,1,0,0,1,76,NA,12,2,1,1,0.94,240,14.7,102.3,9.9,267000,3.6,0.5,64,132,356,192,7.4,0.9,3,2,0.4,NA,NA,NA,1 +HCC_0141,0,1,0,NA,NA,NA,0,1,0,0,0,0,0,0,0,NA,0,NA,0,0,1,0,0,43,0,0,0,1,1,1.25,180,12.2,87.6,7.2,130,3.5,0.5,79,58,229,302,7,0.6,5,9,NA,NA,NA,206,0 +HCC_0142,1,1,0,0,0,1,1,1,0,NA,0,0,0,0,0,0,0,NA,1,1,0,0,0,71,0,NA,0,1,1,1.47,15,13.3,89.7,5.7,154000,3.2,1,NA,87,120,108,102,0.68,3,2,NA,NA,NA,NA,0 +HCC_0143,1,NA,1,0,0,0,1,1,0,0,1,1,1,0,1,0,0,1,0,1,0,0,0,67,70,0,0,1,NA,1.02,24,16,98.8,6.6,96000,4.1,1.4,207,158,116,84,7.2,0.9,1,2.2,0.3,NA,NA,NA,1 +HCC_0144,1,0,1,0,0,0,0,1,0,1,1,1,0,0,0,0,NA,1,1,1,0,0,0,67,NA,40,0,1,1,1.798,9.4,11.2,102.4,4.1,60000,3.4,3.7,43,63,175,106,7.6,0.52,1,2.1,1.1,94,39,344,1 +HCC_0145,1,NA,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,NA,NA,NA,0,0,1,51,NA,37,0,1,1,1.26,7,14.9,106.3,6.4,122,3,1.5,195,401,272,93,6.4,1,3,2.9,0.4,124,51,642,1 +HCC_0146,1,1,1,0,0,0,0,1,0,NA,NA,NA,NA,NA,NA,0,NA,NA,NA,NA,0,0,0,80,NA,NA,0,1,1,1,4.8,9.2,94,6.2,157000,3.88,0.76,42,51,983,141,NA,1.1,1,15,0.33,NA,NA,NA,1 +HCC_0147,1,1,1,0,0,0,0,1,NA,1,0,1,0,1,1,0,NA,1,0,1,1,0,0,79,100,15,2,1,3,1.68,92421,14.3,72.2,13.3,459000,3.2,1.6,24,76,570,472,5.9,2.02,1,NA,0.6,29,4,14,0 +HCC_0148,1,0,1,0,NA,0,0,1,NA,NA,1,1,NA,1,0,0,0,1,1,1,0,0,1,75,NA,NA,0,1,1,1.71,5.2,11.1,106.9,2100,52000,3.3,2.6,15,47,94,117,7.1,0.79,1,3.5,1,NA,NA,NA,1 +HCC_0149,0,0,0,0,NA,0,0,1,NA,0,0,0,0,0,0,0,0,1,1,1,0,0,0,81,0,0,0,1,1,1.18,16,13.3,94.3,4800,96000,3.8,1.2,26,35,75,105,7.6,0.53,1,2.4,0.3,NA,NA,NA,1 +HCC_0150,0,1,0,0,0,0,0,0,NA,0,0,0,0,0,0,0,0,1,1,1,1,0,0,25,0,0,2,1,1,NA,1.5,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,1,6.6,NA,NA,NA,NA,1 +HCC_0152,0,0,1,0,0,0,0,1,0,NA,0,0,0,0,0,0,0,1,NA,NA,0,0,1,69,NA,NA,0,1,1,1.2,10,13.5,104.9,13.5,194,4,1,31,79,126,85,7.6,0.8,1,7,0.4,NA,NA,NA,1 +HCC_0154,1,1,1,NA,NA,NA,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,87,NA,0,3,1,1,1.2,33,9.7,91.6,10.1,277,3.8,2.4,60,54,468,338,7,1.13,1,15,1.3,NA,NA,NA,0 +HCC_0156,1,1,1,0,0,0,0,1,NA,1,0,0,1,0,0,0,0,NA,1,1,1,0,1,64,75,25,3,2,3,1.63,1671,12.8,101.6,4.4,172000,3.44,5.8,38,95,92,139,7.6,0.9,3,9,2.9,111,94,1600,0 +HCC_0157,1,1,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,49,NA,0,1,1,1,1.24,975,15.3,103,11.5,124000,3.5,1.2,62,85,561,266,7.5,0.77,1,2.3,0.6,180,70,1176,0 +HCC_0158,1,NA,1,0,0,0,0,1,NA,1,0,0,0,1,0,0,0,1,1,1,0,0,1,62,NA,20,0,1,2,1.41,1.7,14.7,97.2,6900,72000,3.5,1.3,31,24,67,97,7.3,0.76,1,3.5,0.3,NA,NA,NA,1 +HCC_0159,1,NA,0,0,0,0,0,1,NA,NA,1,0,0,0,1,0,0,1,1,1,0,0,1,71,0,NA,3,1,1,1.16,1713,8.2,94.2,6,209000,3.6,0.3,62,59,450,263,6.8,1.49,1,7.5,NA,NA,NA,NA,1 +HCC_0160,1,1,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,NA,1,1,0,1,1,64,100,0,3,3,3,1.52,4.9,7.9,111.2,4.1,67000,2.43,1.9,40,71,69,73,4.8,0.77,5,3.2,0.7,40,18,283,0 +HCC_0162,0,1,0,NA,NA,NA,NA,1,0,0,0,0,0,1,0,NA,0,1,1,1,0,0,1,68,0,0,2,1,1,1.33,4887,12.1,88.9,2.5,141,3,3.6,50,91,147,280,6.7,0.7,1,2.2,2.3,NA,NA,NA,0 +HCC_0163,1,0,1,0,0,0,0,1,0,1,1,1,0,1,1,0,NA,NA,NA,NA,0,0,1,65,NA,48,0,1,1,1.13,75,13.3,90,8,385000,4.3,0.6,53,52,164,181,7.5,1.46,5,18.6,NA,NA,NA,NA,1 +HCC_0164,1,0,1,1,0,1,1,1,1,1,0,0,0,0,0,1,0,NA,NA,NA,1,1,1,44,NA,NA,2,1,1,2.14,94964,15.6,117.3,5200,118000,4.8,1.1,50,60,320,170,8.4,0.74,5,18,NA,NA,NA,NA,0 +HCC_0165,1,1,1,0,0,0,1,1,0,1,0,0,0,0,0,0,0,NA,1,1,0,1,1,52,50,NA,0,1,1,1.79,44340,12.7,95.8,14.4,412000,2.2,28.5,78,127,444,462,6.6,3.95,5,8.5,19.8,NA,NA,NA,0 diff --git a/data/UCIFeatureTypes/auto_mpg_categorical_features.csv b/data/UCIFeatureTypes/auto_mpg_categorical_features.csv new file mode 100644 index 00000000..68f7dd83 --- /dev/null +++ b/data/UCIFeatureTypes/auto_mpg_categorical_features.csv @@ -0,0 +1,4 @@ +Feature +Cylinders +ModelYear +Origin diff --git a/data/UCIFeatureTypes/auto_mpg_quantitative_features.csv b/data/UCIFeatureTypes/auto_mpg_quantitative_features.csv new file mode 100644 index 00000000..27d52b4e --- /dev/null +++ b/data/UCIFeatureTypes/auto_mpg_quantitative_features.csv @@ -0,0 +1,5 @@ +Feature +Displacement +Horsepower +Weight +Acceleration diff --git a/data/UCIFeatureTypes/hcc_survival_categorical_features.csv b/data/UCIFeatureTypes/hcc_survival_categorical_features.csv new file mode 100644 index 00000000..c2f3b7cc --- /dev/null +++ b/data/UCIFeatureTypes/hcc_survival_categorical_features.csv @@ -0,0 +1,27 @@ +Feature +Gender +Symptoms +Alcohol +HepatitisBSurfaceAntigen +HepatitisBeAntigen +HepatitisBCoreAntibody +HepatitisCVirusAntibody +Cirrhosis +EndemicCountries +Smoking +Diabetes +Obesity +Hemochromatosis +ArterialHypertension +ChronicRenalInsufficiency +HIV +NASH +EsophagealVarices +Splenomegaly +PortalHypertension +PortalVeinThrombosis +LiverMetastasis +RadiologicalHallmark +PerformanceStatus +EncephalopathyDegree +AscitesDegree diff --git a/data/UCIFeatureTypes/hcc_survival_quantitative_features.csv b/data/UCIFeatureTypes/hcc_survival_quantitative_features.csv new file mode 100644 index 00000000..2ae13e60 --- /dev/null +++ b/data/UCIFeatureTypes/hcc_survival_quantitative_features.csv @@ -0,0 +1,24 @@ +Feature +AgeAtDiagnosis +GramsAlcoholPerDay +PacksCigarettesPerYear +InternationalNormalisedRatio +AlphaFetoprotein +Hemoglobin +MeanCorpuscularVolume +Leukocytes +Platelets +Albumin +TotalBilirubin +AlanineTransaminase +AspartateTransaminase +GammaGlutamylTransferase +AlkalinePhosphatase +TotalProteins +Creatinine +NumberOfNodules +MajorDimensionOfNodule +DirectBilirubin +Iron +OxygenSaturation +Ferritin diff --git a/data/UCIFeatureTypes/student_dropout_categorical_features.csv b/data/UCIFeatureTypes/student_dropout_categorical_features.csv new file mode 100644 index 00000000..662c52ac --- /dev/null +++ b/data/UCIFeatureTypes/student_dropout_categorical_features.csv @@ -0,0 +1,18 @@ +Feature +MaritalStatus +ApplicationMode +Course +DaytimeEveningAttendance +PreviousQualification +Nationality +MothersQualification +FathersQualification +MothersOccupation +FathersOccupation +Displaced +EducationalSpecialNeeds +Debtor +TuitionFeesUpToDate +Gender +ScholarshipHolder +International diff --git a/data/UCIFeatureTypes/student_dropout_quantitative_features.csv b/data/UCIFeatureTypes/student_dropout_quantitative_features.csv new file mode 100644 index 00000000..7800e355 --- /dev/null +++ b/data/UCIFeatureTypes/student_dropout_quantitative_features.csv @@ -0,0 +1,20 @@ +Feature +ApplicationOrder +PreviousQualificationGrade +AdmissionGrade +AgeAtEnrollment +CurricularUnits1stSemCredited +CurricularUnits1stSemEnrolled +CurricularUnits1stSemEvaluations +CurricularUnits1stSemApproved +CurricularUnits1stSemGrade +CurricularUnits1stSemWithoutEvaluations +CurricularUnits2ndSemCredited +CurricularUnits2ndSemEnrolled +CurricularUnits2ndSemEvaluations +CurricularUnits2ndSemApproved +CurricularUnits2ndSemGrade +CurricularUnits2ndSemWithoutEvaluations +UnemploymentRate +InflationRate +GDP diff --git a/data/UCIMulticlassClassification/student_dropout_academic_success.csv b/data/UCIMulticlassClassification/student_dropout_academic_success.csv new file mode 100644 index 00000000..6ab935db --- /dev/null +++ b/data/UCIMulticlassClassification/student_dropout_academic_success.csv @@ -0,0 +1,3540 @@ +InstanceID,MaritalStatus,ApplicationMode,Course,DaytimeEveningAttendance,ApplicationOrder,PreviousQualification,Nationality,MothersQualification,FathersQualification,MothersOccupation,FathersOccupation,PreviousQualificationGrade,AdmissionGrade,Displaced,EducationalSpecialNeeds,Debtor,TuitionFeesUpToDate,Gender,ScholarshipHolder,International,AgeAtEnrollment,CurricularUnits1stSemCredited,CurricularUnits1stSemEnrolled,CurricularUnits1stSemEvaluations,CurricularUnits1stSemApproved,CurricularUnits1stSemGrade,CurricularUnits1stSemWithoutEvaluations,CurricularUnits2ndSemCredited,CurricularUnits2ndSemEnrolled,CurricularUnits2ndSemEvaluations,CurricularUnits2ndSemApproved,CurricularUnits2ndSemGrade,CurricularUnits2ndSemWithoutEvaluations,UnemploymentRate,InflationRate,GDP,Class +Student_00001,1,17,171,1,5,1,1,19,12,5,9,122.0,127.3,1,0,0,1,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_00002,1,15,9254,1,1,1,1,1,3,3,3,160.0,142.5,1,0,0,0,1,0,0,19,0,6,6,6,14.0,0,0,6,6,6,13.666666666666666,0,13.9,-0.3,0.79,2 +Student_00003,1,1,9070,1,5,1,1,37,37,9,9,122.0,124.8,1,0,0,0,1,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_00004,1,17,9773,1,2,1,1,38,37,5,3,NA,119.6,1,0,0,1,0,0,0,20,0,6,8,6,13.428571428571429,0,0,6,10,5,12.4,0,9.4,-0.8,-3.12,2 +Student_00005,2,39,NA,0,1,1,1,37,38,9,9,100.0,141.5,0,0,0,1,0,0,0,45,0,6,9,5,12.333333333333334,0,0,6,6,6,13.0,0,13.9,-0.3,0.79,2 +Student_00006,2,39,9991,0,1,19,1,37,37,9,7,133.1,114.8,0,0,1,1,1,0,0,50,0,5,10,5,11.857142857142858,0,0,5,17,5,11.5,5,16.2,0.3,-0.92,2 +Student_00008,1,18,9254,1,4,1,1,37,37,9,9,119.0,113.1,1,0,0,0,1,0,0,22,0,5,5,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_00010,1,1,9238,1,1,1,1,1,19,4,7,138.0,123.0,1,0,1,0,0,0,0,18,0,6,9,5,11.4,0,0,6,14,2,13.5,0,8.9,1.4,3.51,0 +Student_00011,1,1,9670,1,1,1,1,38,19,5,7,139.0,130.6,1,0,0,1,0,0,0,18,0,6,6,6,12.333333333333334,0,0,6,7,5,14.2,0,13.9,-0.3,0.79,2 +Student_00012,1,1,9500,1,1,1,1,19,38,9,9,136.0,119.3,1,0,0,1,0,1,0,18,0,8,8,7,13.214285714285714,0,0,8,8,7,13.214285714285714,0,12.7,3.7,-1.7,2 +Student_00013,1,1,9853,1,2,1,1,19,37,4,9,133.0,130.2,1,0,0,1,0,0,0,19,0,6,6,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_00014,1,53,9254,1,1,42,1,1,1,4,7,110.0,111.8,1,0,0,1,NA,1,0,21,0,6,7,6,10.571428571428571,0,0,6,8,5,11.0,0,8.9,1.4,3.51,2 +Student_00016,1,1,9773,1,1,1,1,19,37,9,3,127.0,120.7,1,0,0,1,0,0,0,20,0,6,6,5,13.2,0,0,6,7,0,0.0,0,15.5,2.8,-4.06,0 +Student_00018,1,17,9500,1,2,1,1,NA,1,5,4,135.0,127.3,1,0,0,1,0,0,0,18,0,7,8,7,13.30625,0,0,8,8,8,14.545,0,15.5,2.8,-4.06,2 +Student_00019,1,1,9130,1,1,1,1,3,19,3,5,137.0,136.3,1,0,0,1,0,0,0,20,0,5,8,4,12.5,1,0,5,8,4,12.25,2,10.8,1.4,1.74,2 +Student_00020,1,1,9853,1,1,1,1,19,19,7,7,140.0,124.6,1,0,0,1,0,0,0,18,0,7,7,6,11.666666666666666,0,0,7,8,6,13.5,0,16.2,0.3,-0.92,1 +Student_00021,1,1,171,1,3,1,1,1,1,9,8,122.0,120.3,0,0,0,1,0,1,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,2 +Student_00022,1,18,9556,1,4,1,1,1,38,4,7,127.0,121.8,1,0,0,1,0,0,0,20,0,7,14,7,11.4375,0,0,8,9,8,11.425,0,12.7,3.7,-1.7,1 +Student_00023,1,1,9500,1,4,1,1,19,19,1,1,142.0,125.5,1,0,0,1,0,0,0,18,0,8,12,7,12.857142857142858,0,0,8,12,7,12.857142857142858,0,12.7,3.7,-1.7,2 +Student_00024,1,1,9670,1,4,1,1,1,38,4,7,125.0,114.9,1,0,0,1,0,1,0,19,0,6,8,6,13.375,0,0,6,7,6,12.285714285714286,0,11.1,0.6,2.02,2 +Student_00025,1,1,9500,1,1,1,1,19,19,3,7,126.0,123.9,0,0,0,1,0,0,0,19,0,7,8,6,13.296666666666669,0,0,8,9,7,14.114285714285714,0,11.1,0.6,2.02,2 +Student_00029,1,1,9147,1,1,1,1,19,1,9,9,135.0,122.1,1,0,0,1,0,0,0,20,0,5,6,5,12.0,0,0,5,6,5,12.333333333333334,0,16.2,0.3,-0.92,2 +Student_00030,1,17,9500,1,2,1,1,3,3,1,10,127.0,118.8,1,0,0,NA,1,0,0,19,0,7,9,6,12.933333333333332,0,0,7,7,6,13.716666666666669,0,16.2,0.3,-0.92,1 +Student_00031,1,44,9003,1,1,39,1,4,5,4,2,150.0,150.0,0,0,0,1,1,0,0,21,0,6,15,5,11.857142857142858,0,0,6,17,5,10.571428571428571,0,16.2,0.3,-0.92,1 +Student_00032,1,51,9070,1,1,1,1,42,3,125,124,125.0,130.0,1,0,0,1,1,0,0,20,2,6,7,6,12.833333333333334,0,0,6,9,4,13.4,0,8.9,1.4,3.51,2 +Student_00033,1,1,9147,1,1,1,1,1,1,4,6,143.0,138.8,0,0,0,0,1,0,0,18,0,5,9,3,11.333333333333334,0,0,5,8,2,13.5,0,8.9,1.4,3.51,1 +Student_00034,1,18,8014,0,1,1,1,19,1,9,5,138.0,134.5,1,0,0,1,0,0,0,19,0,6,6,6,12.666666666666666,0,0,6,8,6,14.375,0,12.4,0.5,1.79,2 +Student_00035,1,1,9991,0,1,1,1,2,37,3,9,130.0,131.4,0,0,0,1,1,0,0,34,0,5,6,5,12.4,0,0,5,9,5,13.428571428571429,0,13.9,-0.3,0.79,2 +Student_00036,1,39,33,1,1,1,1,38,37,9,6,130.0,102.5,0,0,1,0,1,0,0,37,0,7,7,0,0.0,0,0,7,7,1,10.0,0,8.9,1.4,3.51,0 +Student_00037,1,39,9119,1,1,10,1,34,37,0,0,133.1,128.8,1,0,0,1,1,0,0,43,0,5,0,0,0.0,0,0,5,0,0,0.0,0,7.6,2.6,0.32,0 +Student_00039,4,39,9991,0,1,1,1,19,19,9,3,120.0,113.9,1,0,0,1,0,0,0,39,0,5,8,5,11.0,0,0,5,5,5,11.6,0,7.6,2.6,0.32,2 +Student_00041,1,1,9773,1,5,1,1,3,3,2,2,126.0,121.1,0,0,1,1,0,0,0,18,0,6,6,4,12.75,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_00042,1,1,9147,1,2,1,1,3,19,2,7,133.0,120.4,1,0,0,1,0,0,0,22,0,5,5,5,14.8,0,0,5,5,5,15.8,0,8.9,1.4,3.51,2 +Student_00043,1,1,9500,1,6,1,1,1,3,2,2,103.0,100.6,1,1,0,1,0,0,0,22,0,7,9,5,13.928,0,0,8,9,7,14.342857142857142,0,11.1,0.6,2.02,2 +Student_00044,1,17,9773,1,1,1,1,1,38,5,5,120.0,121.4,0,0,0,0,0,0,0,20,0,6,7,4,13.0,0,0,6,7,5,13.8,0,12.4,0.5,1.79,0 +Student_00045,1,39,9991,0,1,1,1,37,37,9,9,133.1,109.7,0,0,0,1,0,0,0,29,0,5,0,0,0.0,0,0,5,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_00046,1,17,9991,0,1,1,1,38,38,4,5,154.0,NA,0,0,0,1,0,0,0,24,0,5,9,2,11.5,0,0,5,11,3,14.333333333333334,1,7.6,2.6,0.32,1 +Student_00047,1,17,9238,1,2,1,1,19,19,9,9,130.0,127.6,1,0,0,1,0,0,0,18,0,6,6,6,11.666666666666666,0,0,6,8,5,13.2,0,11.1,0.6,2.02,2 +Student_00048,1,17,9500,1,6,1,1,37,19,7,7,132.0,132.4,1,0,0,1,0,1,0,22,0,7,8,6,13.516666666666666,0,0,8,9,7,13.771428571428572,0,11.1,0.6,2.02,2 +Student_00049,1,44,8014,0,1,39,1,1,19,9,9,130.0,133.4,0,0,0,1,0,1,0,NA,3,6,6,6,11.5,0,2,6,7,6,13.285714285714286,0,12.4,0.5,1.79,2 +Student_00050,1,1,9238,1,1,1,1,37,38,9,9,139.0,126.1,0,0,0,1,0,1,0,19,0,6,7,5,12.333333333333334,0,0,6,7,6,12.833333333333334,0,12.7,3.7,-1.7,2 +Student_00051,1,39,9254,1,1,1,1,19,38,9,7,130.0,113.5,0,0,0,1,0,1,0,24,0,6,6,6,13.666666666666666,0,0,6,6,6,14.166666666666666,0,12.4,0.5,1.79,2 +Student_00052,1,1,9500,1,1,1,1,37,38,6,6,139.0,121.3,1,0,0,1,0,1,0,19,0,8,10,6,11.833333333333334,0,0,8,10,6,11.833333333333334,0,9.4,-0.8,-3.12,1 +Student_00054,NA,1,9130,1,3,1,1,37,37,90,90,167.0,159.3,0,0,0,1,0,0,0,19,0,5,7,5,14.714285714285714,0,0,5,5,5,15.8,0,7.6,2.6,0.32,2 +Student_00055,1,39,9991,0,1,1,1,38,38,9,9,130.0,120.0,0,0,0,1,0,0,0,27,0,5,12,5,10.6,0,0,5,10,5,11.0,0,9.4,-0.8,-3.12,0 +Student_00057,2,7,9254,1,1,3,1,1,3,4,3,130.0,130.0,0,0,0,1,0,0,0,39,0,6,10,0,0.0,0,0,6,6,0,0.0,0,12.4,0.5,1.79,0 +Student_00058,1,39,9130,1,1,40,1,3,3,2,2,129.0,155.3,1,0,0,1,0,0,0,27,0,6,9,5,13.0,0,5,11,13,10,12.9,0,12.4,0.5,1.79,0 +Student_00059,1,17,9500,1,1,NA,1,38,38,7,10,141.0,139.8,1,0,0,1,0,0,0,18,0,8,8,8,14.935,0,0,8,8,8,14.935,0,9.4,-0.8,-3.12,2 +Student_00060,1,1,171,1,3,1,1,38,37,4,9,125.0,115.2,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,1 +Student_00062,1,44,9238,1,1,39,1,19,1,9,9,130.0,131.9,0,0,0,1,0,1,0,21,3,6,7,6,12.0,0,2,6,7,6,12.0,0,13.9,-0.3,0.79,2 +Student_00063,1,17,171,1,3,1,1,1,37,4,7,133.0,126.0,1,0,0,1,1,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,1 +Student_00064,1,17,9070,1,1,1,1,1,1,3,4,127.0,130.2,1,0,0,1,1,0,0,19,0,6,6,5,11.4,0,0,6,8,1,10.0,0,10.8,1.4,1.74,1 +Student_00066,4,42,9500,1,1,19,1,1,1,5,5,133.1,126.0,1,0,0,1,1,0,0,29,2,7,10,5,11.9,0,1,8,10,5,11.0,0,13.9,-0.3,0.79,0 +Student_00067,1,1,171,1,3,1,1,19,19,5,3,139.0,128.2,1,0,0,1,1,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,2 +Student_00068,1,44,9003,1,1,39,1,19,37,9,9,130.0,130.0,1,0,0,1,1,0,0,23,0,6,8,6,12.571428571428571,0,0,6,7,6,12.428571428571429,0,8.9,1.4,3.51,2 +Student_00069,1,1,9147,1,3,1,1,1,38,7,7,125.0,120.1,0,0,1,1,1,0,0,19,0,5,8,5,11.2,0,0,5,10,4,10.75,3,16.2,0.3,-0.92,0 +Student_00070,1,39,9254,1,1,1,1,19,37,7,10,160.0,100.0,0,0,0,1,1,0,0,26,0,6,7,6,12.0,0,0,6,8,5,10.8,0,12.7,3.7,-1.7,1 +Student_00071,1,17,9147,1,1,1,1,38,37,5,5,148.0,134.0,0,0,0,1,1,0,0,18,0,5,9,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,1 +Student_00073,1,1,171,1,1,1,1,19,19,5,10,141.0,135.8,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00074,1,17,9254,1,4,1,1,38,37,5,7,118.0,111.7,1,0,0,1,1,0,0,18,0,6,12,3,11.666666666666666,0,0,6,12,1,12.0,0,12.4,0.5,1.79,0 +Student_00075,1,1,9773,1,2,1,1,38,38,9,9,142.0,132.9,1,0,0,1,1,0,0,18,0,6,8,6,12.333333333333334,0,0,6,11,3,12.333333333333334,0,10.8,1.4,1.74,2 +Student_00076,1,17,9147,1,3,1,1,19,19,4,7,120.0,115.5,1,0,1,1,1,0,0,18,0,5,8,3,10.333333333333334,0,0,5,11,3,10.857142857142858,0,10.8,1.4,1.74,0 +Student_00077,1,18,9254,1,4,1,1,19,37,7,NA,106.0,106.0,1,0,0,1,1,1,0,21,0,6,8,4,10.5,0,0,6,11,1,11.0,0,9.4,-0.8,-3.12,0 +Student_00078,1,17,9773,1,4,1,1,1,19,9,8,121.0,120.3,1,0,1,1,1,1,0,19,0,6,6,6,13.666666666666666,0,0,6,6,6,13.333333333333334,0,8.9,1.4,3.51,2 +Student_00079,1,17,9500,1,4,1,1,38,37,9,9,150.0,130.8,0,0,0,1,1,1,0,22,0,7,7,7,14.842857142857142,0,0,8,9,8,15.055555555555555,0,16.2,0.3,-0.92,2 +Student_00080,2,39,8014,0,1,1,1,37,37,9,6,120.0,117.0,0,0,0,NA,1,0,0,33,0,6,8,6,12.0,0,0,6,6,6,11.666666666666666,0,10.8,1.4,1.74,2 +Student_00081,1,1,9853,1,6,1,1,19,19,9,9,114.0,110.2,1,0,0,1,1,0,0,20,0,6,8,5,12.2,0,0,6,7,5,12.2,0,10.8,1.4,1.74,0 +Student_00083,1,39,9003,1,1,4,1,3,3,4,2,160.0,180.4,0,0,1,1,1,0,0,24,6,12,17,6,12.166666666666666,0,7,12,14,10,13.3,0,12.4,0.5,1.79,0 +Student_00084,1,17,9254,1,1,1,1,19,19,4,4,120.0,125.5,0,0,0,1,1,0,0,18,0,5,6,5,12.0,0,0,5,8,3,11.333333333333334,0,NA,3.7,-1.7,1 +Student_00085,2,39,8014,0,1,1,1,37,37,9,6,130.0,110.0,1,0,0,1,0,0,0,33,0,6,7,6,11.0,0,0,6,11,5,11.0,0,9.4,-0.8,-3.12,2 +Student_00086,1,42,9500,1,1,1,1,37,38,9,7,160.0,161.0,1,0,0,1,0,1,0,22,0,8,8,7,13.08,0,0,8,8,7,13.08,0,10.8,1.4,1.74,2 +Student_00087,1,39,9670,1,1,1,1,1,19,4,5,120.0,100.0,0,0,0,1,0,1,0,25,0,5,7,4,10.5,0,0,5,7,5,11.6,0,9.4,-0.8,-3.12,2 +Student_00088,1,17,9070,1,1,1,1,19,38,4,0,124.0,117.6,1,0,0,1,1,0,0,20,0,6,9,6,10.666666666666666,1,0,6,6,5,11.2,0,7.6,2.6,0.32,2 +Student_00089,1,1,9147,1,6,1,1,38,37,9,9,143.0,128.7,1,0,0,1,1,0,0,23,0,5,6,4,14.0,0,0,5,5,5,13.8,0,11.1,0.6,2.02,1 +Student_00090,1,43,9119,1,2,1,1,38,19,9,6,115.0,112.2,1,0,1,1,1,0,0,18,0,5,9,2,10.0,0,0,5,9,0,0.0,0,15.5,2.8,-4.06,1 +Student_00091,1,39,9500,1,1,1,1,1,1,4,10,133.1,100.8,0,0,0,1,1,0,0,24,0,7,18,0,0.0,0,0,7,7,0,0.0,0,13.9,-0.3,0.79,0 +Student_00092,1,17,9773,1,2,1,41,19,1,9,9,133.1,105.0,1,0,0,0,0,0,1,21,0,6,6,6,14.0,0,0,6,6,6,13.5,0,8.9,1.4,3.51,2 +Student_00095,2,39,NA,0,1,1,1,37,19,9,9,133.1,114.0,0,0,0,1,0,0,0,44,2,8,11,8,11.875,0,0,6,7,6,12.333333333333334,0,12.7,3.7,-1.7,2 +Student_00096,1,15,9119,1,1,1,26,38,3,9,2,130.0,137.0,1,0,0,1,1,0,1,19,0,5,9,5,14.0,0,0,5,11,3,13.25,0,13.9,-0.3,0.79,1 +Student_00097,1,1,9773,1,5,1,1,37,1,5,5,135.0,124.9,1,0,0,1,0,0,0,18,0,6,6,6,13.666666666666666,0,0,6,6,6,13.333333333333334,0,8.9,1.4,3.51,2 +Student_00098,1,1,9500,1,5,1,1,37,37,7,7,132.0,120.3,1,0,0,1,0,1,0,18,0,7,7,7,13.75,0,0,8,9,8,14.47777777777778,0,12.4,0.5,1.79,2 +Student_00099,1,1,9085,1,1,1,1,1,2,9,1,135.0,134.3,1,0,0,1,0,0,0,19,0,5,7,5,14.2,2,0,5,7,5,13.8,0,12.7,3.7,-1.7,1 +Student_00100,1,1,9500,1,4,1,1,3,3,2,2,115.0,111.5,1,0,1,0,0,0,0,19,0,7,10,4,11.96,0,0,7,7,0,0.0,0,13.9,-0.3,0.79,0 +Student_00102,1,1,171,1,4,1,1,1,1,9,10,133.1,110.0,1,0,0,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,2 +Student_00103,2,39,8014,0,1,1,1,37,37,6,5,130.0,113.5,1,0,0,1,0,0,0,36,0,6,0,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00104,4,39,9003,1,1,12,1,37,37,9,6,133.1,160.0,0,0,0,1,0,0,0,43,13,18,19,18,14.63157894736842,0,10,13,14,13,NA,1,15.5,2.8,-4.06,2 +Student_00105,1,18,9853,1,1,1,1,19,19,9,7,123.0,117.4,1,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_00106,1,51,9070,1,1,1,1,3,1,2,8,130.0,122.2,0,0,1,1,0,0,0,20,4,10,12,10,13.0,0,5,11,11,11,12.272727272727272,0,11.1,0.6,2.02,2 +Student_00107,1,1,9238,1,2,1,1,37,38,4,7,122.0,118.2,1,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_00109,1,1,9500,1,5,1,1,3,4,4,3,111.0,108.2,1,0,0,1,0,0,0,20,2,7,9,6,13.266666666666666,0,0,7,10,5,12.3,0,12.4,0.5,1.79,0 +Student_00110,1,17,9853,1,2,1,1,19,1,9,3,133.1,107.0,1,0,0,1,0,0,0,20,0,7,12,6,11.666666666666666,0,0,7,10,3,13.0,0,16.2,0.3,-0.92,1 +Student_00111,1,1,9238,1,1,1,1,37,37,6,7,142.0,136.1,1,0,0,1,0,0,0,18,0,6,8,6,13.857142857142858,0,0,6,6,6,15.0,0,13.9,-0.3,0.79,2 +Student_00112,1,17,9147,1,2,1,1,1,38,4,7,123.0,115.3,1,0,0,1,0,1,0,18,0,5,9,3,13.0,0,0,5,11,3,11.0,0,8.9,1.4,3.51,1 +Student_00114,1,1,9773,1,3,1,1,1,38,4,7,158.0,157.0,1,0,0,1,0,0,0,18,0,6,6,6,12.666666666666666,0,0,6,7,6,12.571428571428571,0,10.8,1.4,1.74,2 +Student_00116,1,43,9500,1,1,1,1,38,38,9,5,130.0,100.0,0,0,0,1,0,0,0,20,0,7,11,6,11.616666666666667,0,0,7,7,7,13.0,0,13.9,-0.3,NA,1 +Student_00117,1,17,9238,1,1,1,1,19,37,9,7,154.0,140.4,1,0,0,1,0,1,0,20,0,6,13,2,10.0,0,0,6,12,4,10.75,0,7.6,2.6,0.32,1 +Student_00119,1,1,9085,1,2,1,1,37,38,9,7,140.0,137.0,0,0,0,1,0,0,0,18,0,5,12,5,13.142857142857142,2,0,5,6,5,11.4,0,9.4,-0.8,-3.12,2 +Student_00120,1,1,9147,1,1,1,1,2,19,4,5,127.0,121.8,0,0,0,1,0,0,0,18,0,5,5,5,12.6,0,0,5,5,5,14.0,0,11.1,0.6,2.02,2 +Student_00121,1,17,9254,1,1,1,NA,1,1,4,5,133.1,131.0,1,0,0,1,0,0,0,21,0,6,12,3,11.0,0,0,6,12,2,11.0,0,9.4,-0.8,-3.12,0 +Student_00122,1,1,9147,1,2,1,1,19,19,9,7,120.0,118.6,1,0,0,1,0,0,0,19,0,5,8,5,10.8,0,0,5,9,4,11.25,2,16.2,0.3,-0.92,2 +Student_00123,1,1,171,1,1,1,1,3,19,2,9,137.0,122.3,0,0,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_00124,1,1,9670,1,1,1,1,38,38,9,9,131.0,127.9,0,0,0,1,0,1,0,19,0,5,5,5,12.8,0,0,5,5,5,14.2,0,9.4,-0.8,-3.12,2 +Student_00125,1,1,9085,1,1,1,1,19,38,4,7,130.0,121.3,1,0,0,1,0,0,0,19,0,6,15,6,14.166666666666666,0,0,6,13,6,12.2,0,15.5,2.8,-4.06,2 +Student_00126,1,17,9556,1,6,1,1,1,1,4,5,122.0,117.1,1,0,0,1,0,0,0,19,0,7,12,5,12.1,0,0,7,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_00128,1,1,9853,1,1,1,1,19,38,9,3,146.0,145.3,1,0,0,1,0,1,0,18,0,6,8,5,12.8,0,0,6,7,5,13.4,0,9.4,-0.8,-3.12,1 +Student_00130,1,17,9500,1,6,1,1,1,37,8,9,132.0,128.0,1,0,0,1,0,0,0,19,0,7,7,7,13.467142857142855,0,0,8,9,8,15.011111111111113,0,12.4,0.5,1.79,2 +Student_00132,1,17,9070,1,2,1,1,37,37,9,9,130.0,123.7,1,0,0,1,0,0,0,18,0,6,6,6,12.333333333333334,0,0,6,6,6,13.0,0,7.6,2.6,0.32,2 +Student_00133,1,1,9147,1,4,1,1,1,19,4,8,126.0,120.1,1,0,0,1,0,0,0,19,0,5,7,5,12.4,0,0,5,5,5,14.6,0,8.9,1.4,3.51,2 +Student_00134,1,17,9500,1,6,1,1,1,19,3,3,148.0,131.7,1,0,0,1,0,0,0,19,0,7,8,5,14.0,0,0,7,7,0,0.0,0,13.9,-0.3,0.79,0 +Student_00135,1,43,9238,1,1,1,1,38,37,9,7,130.0,133.2,0,0,0,1,0,0,0,20,5,9,15,9,11.666666666666666,0,2,7,8,7,11.714285714285714,0,7.6,2.6,0.32,2 +Student_00136,1,1,9670,1,1,1,1,1,38,3,9,117.0,109.3,0,0,1,0,0,1,0,19,0,6,7,5,12.0,0,0,6,9,4,12.5,0,12.4,0.5,1.79,0 +Student_00137,1,17,9670,1,1,1,1,19,19,5,5,120.0,113.0,1,0,0,1,0,0,0,20,0,5,7,4,12.2,0,0,5,5,4,11.5,0,7.6,2.6,0.32,2 +Student_00138,1,1,9773,1,1,1,1,1,1,141,175,153.0,157.9,0,0,1,1,0,1,0,18,0,6,6,6,14.833333333333334,0,0,6,6,6,14.833333333333334,0,8.9,1.4,3.51,2 +Student_00139,1,1,9500,1,2,1,1,19,1,4,7,117.0,112.1,0,0,0,1,0,1,0,20,0,7,9,5,13.188,0,0,8,9,7,12.892857142857142,0,11.1,0.6,2.02,1 +Student_00140,1,18,9500,1,1,1,1,19,1,4,8,178.0,174.7,0,0,0,1,0,0,0,18,0,7,8,7,17.125,0,0,8,8,8,17.5875,0,13.9,-0.3,0.79,2 +Student_00141,1,1,9500,1,5,1,1,37,37,9,9,129.0,128.8,1,0,0,1,0,0,0,19,0,7,7,6,12.666666666666666,0,0,7,7,6,12.666666666666666,0,7.6,2.6,0.32,2 +Student_00142,1,1,9773,1,6,1,1,19,1,4,4,116.0,110.1,1,0,0,1,0,1,0,19,0,6,8,6,12.666666666666666,0,0,6,10,5,12.0,0,NA,0.5,1.79,2 +Student_00143,1,51,9147,1,1,1,1,3,1,3,3,99.0,99.7,1,0,1,0,0,0,0,22,0,5,8,0,0.0,0,0,5,7,0,0.0,0,8.9,1.4,3.51,1 +Student_00144,1,1,9238,1,3,1,1,1,12,9,10,135.0,121.0,1,0,0,1,0,1,0,19,0,6,7,6,11.333333333333334,0,0,6,6,6,11.5,0,12.4,0.5,1.79,2 +Student_00145,1,1,9500,1,3,1,1,19,19,9,7,141.0,131.7,1,0,0,1,0,1,0,19,0,7,10,7,13.605,0,0,8,11,8,12.33125,0,15.5,2.8,-4.06,2 +Student_00146,1,17,9853,1,5,1,1,37,38,5,6,132.0,119.1,1,0,0,1,0,1,0,19,0,6,10,5,12.0,0,0,6,9,5,10.8,0,9.4,-0.8,-3.12,2 +Student_00148,1,17,9254,1,1,1,1,1,37,9,10,113.0,117.2,1,0,0,1,0,0,0,20,0,6,8,5,11.2,0,0,6,12,3,11.666666666666666,0,7.6,2.6,0.32,0 +Student_00149,1,1,9147,1,1,1,1,3,19,2,10,134.0,128.8,0,0,0,1,0,0,0,18,0,5,10,5,13.375,0,0,5,9,5,14.166666666666666,0,13.9,-0.3,0.79,2 +Student_00150,1,1,9500,1,1,1,1,1,19,9,9,136.0,131.5,0,0,0,1,0,1,0,20,0,7,8,6,13.863333333333337,0,0,8,9,7,14.178571428571429,0,11.1,0.6,2.02,2 +Student_00151,1,1,171,1,1,1,1,3,37,2,8,136.0,121.7,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,1 +Student_00152,1,1,9085,1,1,1,1,1,38,4,7,129.0,123.4,0,0,0,1,0,0,0,19,0,5,6,5,12.4,0,0,5,6,5,13.4,0,7.6,2.6,0.32,2 +Student_00153,1,17,9853,1,1,1,1,38,38,7,6,138.0,124.7,1,0,0,1,0,0,0,18,0,6,11,3,12.333333333333334,0,0,6,10,5,10.833333333333334,0,9.4,-0.8,-3.12,1 +Student_00154,1,1,9853,1,1,1,1,37,37,9,9,137.0,132.8,1,0,0,1,0,0,0,18,0,6,7,6,13.333333333333334,0,0,6,8,5,11.8,0,7.6,2.6,0.32,2 +Student_00155,1,43,9853,1,1,1,1,3,37,2,5,115.0,108.7,1,0,0,1,0,0,0,21,0,6,10,3,12.666666666666666,0,0,6,12,3,10.0,0,9.4,-0.8,-3.12,0 +Student_00156,1,1,9853,1,1,1,1,38,37,6,6,129.0,138.1,0,0,0,1,0,0,0,19,0,6,8,6,12.0,0,0,6,10,4,11.5,0,7.6,2.6,0.32,0 +Student_00157,1,1,9147,1,1,1,1,38,38,9,9,131.0,126.5,0,0,0,1,0,1,0,18,0,5,5,5,10.6,0,0,5,5,5,11.8,0,12.4,0.5,1.79,2 +Student_00160,1,39,8014,0,1,NA,1,1,19,6,8,120.0,122.0,0,0,0,1,0,1,0,24,0,6,11,5,11.0,0,0,6,9,5,12.6,0,11.1,0.6,2.02,2 +Student_00161,1,1,9670,1,1,1,1,19,1,4,1,128.0,118.2,0,0,0,1,0,0,0,NA,0,6,6,6,13.166666666666666,0,0,6,9,6,13.0,0,10.8,1.4,1.74,0 +Student_00162,1,1,9500,1,1,1,1,19,37,9,7,127.0,123.9,1,0,0,1,0,1,0,18,0,7,9,7,12.855555555555554,0,0,8,12,7,12.761111111111113,0,15.5,2.8,-4.06,2 +Student_00163,1,1,9500,1,2,1,1,19,19,9,9,134.0,125.8,1,0,0,1,0,0,0,18,0,7,8,7,14.91875,0,0,8,8,8,15.355,0,15.5,2.8,-4.06,2 +Student_00165,1,17,9670,1,2,1,1,1,19,5,4,124.0,124.4,0,0,0,1,0,0,0,19,0,5,5,5,14.2,0,0,5,5,5,14.2,0,7.6,2.6,0.32,2 +Student_00166,1,17,9773,1,1,1,1,19,37,7,7,133.1,126.0,0,0,0,1,0,1,0,19,0,6,6,6,12.5,0,0,6,7,6,13.0,0,15.5,2.8,-4.06,2 +Student_00167,3,39,9003,1,1,1,1,1,37,6,6,170.0,170.0,0,0,1,1,0,0,0,47,0,1,1,0,NA,0,0,6,0,0,0.0,0,8.9,1.4,3.51,1 +Student_00168,1,17,9238,1,3,1,1,19,19,7,8,125.0,121.5,0,0,0,1,0,0,0,19,0,6,10,5,11.666666666666666,0,0,6,12,4,11.0,0,13.9,-0.3,0.79,2 +Student_00169,1,39,9500,1,1,3,1,2,2,1,1,130.0,130.0,0,0,0,1,0,0,0,29,1,8,8,7,14.257142857142856,0,1,8,8,7,14.257142857142856,0,12.7,3.7,-1.7,2 +Student_00170,1,43,9238,1,1,1,1,19,19,4,8,125.0,117.0,1,0,0,1,0,0,0,21,0,6,13,3,12.0,0,0,6,12,2,11.333333333333334,0,16.2,0.3,-0.92,0 +Student_00171,1,39,9085,1,1,1,1,37,19,9,7,130.0,130.0,1,0,0,1,0,0,0,28,0,5,13,4,11.25,1,0,5,11,4,10.5,0,12.7,3.7,-1.7,1 +Student_00173,1,17,9500,1,1,NA,1,2,38,4,5,131.0,132.3,1,0,0,1,0,0,0,19,0,7,7,6,11.683333333333332,0,0,7,7,6,11.683333333333332,0,7.6,2.6,0.32,2 +Student_00174,1,42,8014,0,1,1,1,19,2,4,6,150.0,148.0,0,0,0,1,0,0,0,26,0,6,10,3,11.666666666666666,0,0,6,8,5,12.0,0,9.4,-0.8,-3.12,2 +Student_00175,1,17,9254,1,2,1,1,37,37,9,8,125.0,122.6,1,0,1,0,0,0,0,20,0,6,8,4,11.75,0,0,6,6,6,13.166666666666666,0,11.1,0.6,2.02,0 +Student_00176,1,1,9670,1,1,1,1,37,37,9,9,131.0,123.0,1,0,0,1,0,1,0,18,0,5,6,3,11.666666666666666,0,0,5,6,4,13.5,0,7.6,2.6,0.32,1 +Student_00181,1,43,9853,1,1,1,1,3,1,3,3,140.0,128.3,1,0,0,1,0,0,0,35,19,21,21,21,12.61904761904762,0,13,19,19,19,12.789473684210526,0,12.4,0.5,1.79,2 +Student_00182,1,44,9991,0,1,39,1,37,19,9,8,140.0,140.0,0,0,0,1,0,1,0,26,2,6,7,6,12.666666666666666,0,2,6,7,6,13.166666666666666,1,9.4,-0.8,-3.12,1 +Student_00183,1,39,9773,1,1,19,1,19,19,3,4,133.1,104.0,0,0,1,0,0,0,0,27,0,6,6,5,12.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_00184,1,18,9070,1,3,1,1,1,37,5,5,131.0,122.3,1,0,0,0,0,0,0,19,0,6,6,6,12.166666666666666,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_00185,1,17,9254,1,2,1,1,1,19,4,6,143.0,135.0,0,0,0,1,0,0,0,20,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_00187,1,43,9238,1,1,1,1,1,37,5,9,143.0,126.6,0,0,1,0,0,0,0,21,5,10,18,8,11.5,0,0,6,12,4,10.0,0,9.4,-0.8,-3.12,1 +Student_00189,1,39,9085,1,1,1,1,1,19,9,9,133.1,162.3,1,0,0,1,0,0,0,24,0,6,10,2,11.0,0,0,6,6,0,0.0,0,8.9,1.4,3.51,0 +Student_00193,1,39,9147,1,1,1,1,12,3,4,3,140.0,118.0,1,0,0,1,0,0,0,24,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00194,1,51,9853,1,1,1,1,1,1,4,10,139.0,134.0,0,0,0,1,NA,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00195,1,1,9500,1,4,1,1,38,38,9,8,142.0,129.8,1,0,0,1,0,0,0,18,0,8,8,7,12.242857142857144,0,0,8,8,7,12.242857142857144,0,12.7,3.7,-1.7,2 +Student_00197,1,18,9500,1,6,1,1,37,37,5,5,126.0,122.8,1,0,0,1,0,0,0,18,0,8,8,8,12.93375,0,0,8,8,8,12.93375,0,9.4,-0.8,-3.12,2 +Student_00198,1,7,9119,1,1,3,1,3,2,2,2,150.0,150.0,0,0,0,1,0,0,0,35,0,5,0,0,0.0,0,0,5,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_00199,1,1,9853,1,1,1,1,19,19,3,8,130.0,131.8,0,0,0,1,0,0,0,18,0,7,9,7,12.571428571428571,0,0,7,8,7,14.428571428571429,0,11.1,0.6,2.02,2 +Student_00200,1,39,9500,1,1,1,1,1,3,175,121,120.0,105.9,0,0,0,1,0,0,0,35,0,3,4,3,11.816666666666668,0,0,3,3,3,11.333333333333334,0,11.1,0.6,2.02,1 +Student_00202,1,1,9238,1,4,1,1,19,19,4,0,127.0,127.4,1,0,0,1,0,0,0,20,0,6,8,6,11.166666666666666,0,0,6,6,6,11.333333333333334,0,7.6,2.6,0.32,2 +Student_00203,1,1,9500,1,4,1,1,19,19,7,7,140.0,129.5,1,0,0,1,0,0,0,18,0,8,8,7,12.324285714285711,0,0,8,8,7,12.324285714285711,0,10.8,1.4,1.74,2 +Student_00204,1,44,9238,1,1,39,1,38,38,5,10,130.0,126.7,0,0,1,NA,0,0,0,21,3,6,6,6,12.166666666666666,0,2,6,7,6,11.714285714285714,0,13.9,-0.3,0.79,2 +Student_00205,NA,17,9238,1,2,1,1,19,37,9,8,128.0,116.5,0,0,0,1,0,1,0,18,0,6,11,5,11.142857142857142,0,0,6,11,4,11.25,0,16.2,0.3,-0.92,2 +Student_00206,1,1,9238,1,1,1,1,34,34,0,0,132.0,119.1,1,0,0,1,0,0,0,18,0,6,9,4,11.0,0,0,6,9,4,10.75,0,7.6,2.6,0.32,2 +Student_00209,1,1,9085,1,1,1,1,19,1,8,7,120.0,115.1,1,0,0,1,0,0,0,19,0,6,8,6,13.857142857142858,0,0,6,9,5,13.4,0,13.9,-0.3,0.79,2 +Student_00210,1,39,9254,1,1,19,1,3,19,2,3,133.1,124.5,0,0,0,1,0,1,0,36,0,6,7,6,13.714285714285714,0,0,6,6,5,12.8,0,16.2,0.3,-0.92,0 +Student_00211,1,1,9500,1,2,1,1,38,1,7,4,131.0,128.3,1,0,0,1,0,1,0,18,0,8,8,7,12.642857142857142,0,0,8,8,7,NA,0,12.7,3.7,-1.7,2 +Student_00212,1,1,9500,1,1,1,1,37,37,9,9,149.0,136.0,0,0,0,1,0,1,0,18,0,7,7,6,12.916666666666666,0,0,7,7,6,12.916666666666666,0,7.6,2.6,0.32,2 +Student_00213,1,43,9130,1,1,1,1,1,3,9,2,140.0,140.0,1,0,0,1,0,1,0,20,0,6,8,6,15.625,0,0,6,8,6,15.857142857142858,0,13.9,-0.3,0.79,2 +Student_00214,1,39,9991,0,1,1,1,37,37,9,9,133.1,126.3,0,0,0,1,0,1,0,26,0,5,7,0,0.0,0,0,5,8,0,0.0,0,16.2,0.3,-0.92,0 +Student_00215,1,43,9773,1,1,1,1,1,1,4,5,122.0,126.9,0,0,0,1,0,0,0,21,0,6,8,6,11.714285714285714,0,0,6,7,6,12.0,0,7.6,2.6,0.32,2 +Student_00217,1,18,9147,1,1,1,1,19,3,5,5,121.0,115.8,1,0,0,1,0,1,0,19,0,5,7,5,11.6,0,0,5,5,5,11.6,0,12.4,0.5,1.79,2 +Student_00219,1,39,8014,0,1,1,1,1,19,5,4,133.1,102.5,0,0,0,1,0,1,0,27,0,6,16,1,10.0,0,0,6,13,0,0.0,0,8.9,1.4,3.51,0 +Student_00220,1,17,9085,1,1,1,1,19,37,1,3,121.0,131.5,0,0,0,1,0,0,0,21,0,5,10,0,0.0,1,0,5,9,2,13.5,0,7.6,2.6,0.32,0 +Student_00221,1,1,9147,1,1,1,1,38,38,7,7,133.0,147.0,0,0,0,1,0,1,0,18,0,5,7,4,NA,0,0,5,8,3,12.333333333333334,0,9.4,-0.8,-3.12,2 +Student_00222,2,1,9853,1,4,1,1,37,37,5,7,134.0,122.5,0,1,0,1,0,1,0,19,0,6,6,6,13.333333333333334,0,0,6,6,6,14.5,0,10.8,1.4,1.74,2 +Student_00223,1,1,9254,1,3,1,1,1,1,3,3,115.0,117.5,1,0,0,1,0,0,0,18,0,6,9,4,NA,0,0,6,13,2,12.5,0,9.4,-0.8,-3.12,0 +Student_00224,1,51,9500,1,1,1,1,19,1,5,9,127.0,150.0,0,0,0,1,0,1,0,19,0,7,9,5,13.85,0,0,8,9,7,12.19285714285714,0,11.1,0.6,2.02,2 +Student_00225,1,18,9500,1,1,1,1,1,38,4,5,135.0,127.5,1,0,0,1,0,1,0,19,0,7,8,6,13.741666666666667,0,0,8,9,7,14.9125,0,16.2,0.3,-0.92,2 +Student_00226,2,7,9991,0,1,43,1,40,5,3,3,140.0,140.0,0,0,0,1,0,0,0,33,2,6,7,6,15.333333333333334,0,0,5,5,5,15.8,0,11.1,0.6,2.02,2 +Student_00227,2,7,9147,1,1,3,1,1,4,3,10,130.0,130.0,0,0,0,1,NA,0,0,45,0,5,6,5,11.0,0,0,5,5,5,13.8,0,12.4,0.5,1.79,2 +Student_00229,1,39,9670,1,2,1,1,34,34,0,0,140.0,97.0,1,0,0,1,0,0,0,28,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00230,1,43,9500,1,1,1,1,1,1,5,8,120.0,112.0,1,0,0,1,0,1,0,19,0,8,15,7,11.571428571428571,0,0,8,15,7,11.571428571428571,0,12.7,3.7,-1.7,2 +Student_00231,1,1,9254,1,2,1,1,1,37,4,5,140.0,123.6,1,0,0,1,0,0,0,18,0,6,10,6,12.857142857142858,0,0,6,6,3,12.666666666666666,0,12.7,3.7,-1.7,2 +Student_00233,1,1,9670,1,2,1,1,1,3,4,3,135.0,133.3,0,0,0,1,0,0,0,19,0,5,5,5,13.0,0,0,5,5,5,13.2,0,9.4,-0.8,-3.12,2 +Student_00234,1,1,9254,1,1,1,1,1,37,9,9,123.0,132.1,0,0,0,1,0,1,0,21,0,6,9,5,11.0,0,0,6,8,5,12.0,0,15.5,2.8,-4.06,2 +Student_00235,1,1,9147,1,1,1,1,37,1,9,10,133.1,100.0,0,0,0,1,0,0,0,21,0,5,12,3,12.0,0,0,5,12,1,15.0,3,16.2,0.3,-0.92,0 +Student_00236,1,1,9238,1,1,1,1,38,37,9,9,154.0,140.4,0,0,0,1,0,1,0,22,0,6,6,5,12.6,0,0,6,6,6,13.0,0,NA,1.4,1.74,2 +Student_00238,1,17,9238,1,2,1,1,37,37,3,9,133.0,119.7,0,1,0,1,0,1,0,NA,0,6,9,6,11.333333333333334,0,0,6,9,6,11.571428571428571,0,15.5,2.8,-4.06,2 +Student_00239,1,1,9130,1,1,1,1,19,1,9,9,126.0,122.5,1,0,0,0,0,0,0,25,0,5,14,4,13.5,2,0,5,10,4,14.25,0,9.4,-0.8,-3.12,0 +Student_00240,1,39,9085,1,1,19,1,19,19,9,7,133.1,140.0,0,0,1,0,0,0,0,24,2,6,11,3,11.75,0,1,6,14,3,10.333333333333334,0,16.2,0.3,-0.92,0 +Student_00241,1,1,9500,1,3,1,1,3,1,4,4,125.0,119.4,1,0,0,1,0,0,0,19,0,7,10,6,12.471428571428572,0,0,7,8,7,11.4625,0,12.4,0.5,1.79,1 +Student_00243,1,1,9147,1,2,1,1,37,19,5,5,118.0,119.1,1,0,0,1,0,1,0,20,0,5,5,5,11.6,0,0,5,5,5,13.6,0,12.4,0.5,1.79,2 +Student_00244,1,39,9147,1,1,1,1,37,1,9,1,120.0,122.7,0,0,0,0,0,0,0,25,0,5,5,0,0.0,0,0,5,9,0,0.0,0,10.8,1.4,1.74,0 +Student_00245,NA,1,9147,1,1,1,1,38,19,9,10,127.0,117.9,0,0,0,1,0,1,0,20,5,10,13,9,12.9,0,4,10,12,10,12.363636363636363,0,8.9,1.4,3.51,2 +Student_00246,1,7,9500,1,1,3,1,19,38,5,3,130.0,130.0,0,0,0,1,0,0,0,23,0,8,8,8,13.22,0,0,8,8,8,13.22,0,9.4,-0.8,-3.12,2 +Student_00248,1,44,9003,1,1,39,1,37,37,9,10,130.0,130.0,0,0,1,0,0,0,0,29,0,6,13,3,12.75,0,0,6,8,3,11.333333333333334,0,13.9,-0.3,0.79,0 +Student_00249,1,1,9254,1,3,1,1,19,37,4,7,121.0,116.8,1,0,0,1,0,0,0,21,0,6,8,6,11.333333333333334,0,0,6,8,4,12.25,0,11.1,0.6,2.02,2 +Student_00250,1,1,9670,1,1,1,1,19,1,9,8,136.0,123.4,1,0,0,1,0,1,0,18,0,6,10,6,13.25,0,0,6,13,5,14.142857142857142,0,11.1,0.6,2.02,2 +Student_00252,1,1,9773,1,3,1,1,38,37,7,7,131.0,127.2,1,0,0,1,0,1,0,18,0,6,6,6,15.0,0,0,6,6,6,12.833333333333334,0,8.9,1.4,3.51,0 +Student_00253,1,1,9085,1,1,1,1,9,19,90,6,122.0,103.4,0,0,0,1,0,0,0,19,0,5,6,5,14.4,0,0,5,6,5,13.0,0,7.6,2.6,0.32,2 +Student_00254,1,1,9773,1,1,1,1,37,37,9,8,127.0,123.2,1,0,0,1,0,0,0,18,0,6,12,1,11.0,0,0,6,12,0,0.0,0,9.4,-0.8,-3.12,1 +Student_00255,1,17,9147,1,1,1,1,1,1,4,4,136.0,124.1,0,0,0,1,0,0,0,18,0,5,8,5,NA,0,0,5,6,5,10.8,0,8.9,1.4,3.51,2 +Student_00256,2,39,9556,1,1,19,1,38,37,7,7,133.1,99.5,1,0,1,0,0,1,0,37,0,7,13,1,16.0,0,0,7,12,0,0.0,0,8.9,1.4,3.51,0 +Student_00257,1,17,9991,0,1,40,1,37,37,6,6,127.0,124.9,0,0,0,1,0,0,0,29,0,5,10,5,13.571428571428571,0,0,5,14,5,12.333333333333334,3,16.2,0.3,-0.92,2 +Student_00258,1,17,9070,1,3,NA,1,37,37,9,9,116.0,110.8,0,0,0,1,0,0,0,18,0,6,6,6,11.833333333333334,0,0,6,6,6,12.5,0,7.6,2.6,0.32,1 +Student_00261,NA,1,9254,1,1,1,1,37,38,9,7,131.0,137.0,0,0,0,1,0,1,0,20,0,6,8,6,11.166666666666666,0,0,6,10,5,10.6,0,15.5,2.8,-4.06,2 +Student_00262,1,39,8014,0,1,1,1,37,37,99,99,100.0,100.0,0,0,0,1,0,0,0,34,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_00263,1,NA,9119,1,1,1,1,37,38,9,9,130.0,120.0,0,0,1,0,0,0,0,30,8,12,17,8,11.75,0,6,12,19,6,12.166666666666666,2,7.6,2.6,0.32,0 +Student_00264,1,1,9238,1,1,1,1,1,1,4,4,135.0,122.8,0,0,0,1,0,0,0,18,0,6,7,6,14.0,0,0,6,7,6,14.0,0,10.8,1.4,1.74,2 +Student_00266,1,1,9773,1,2,1,1,3,1,1,3,146.0,149.2,1,0,0,1,0,0,0,18,0,6,11,4,12.25,0,0,6,10,3,11.666666666666666,0,9.4,-0.8,-3.12,2 +Student_00267,1,17,9500,1,4,1,1,4,1,2,3,146.0,140.0,1,0,0,1,0,0,0,18,0,8,8,7,14.828571428571427,0,0,8,8,7,14.828571428571427,0,12.7,3.7,-1.7,2 +Student_00268,1,1,9773,1,2,1,1,38,38,9,9,154.0,133.4,1,0,0,1,0,1,0,19,0,6,7,5,11.4,0,0,6,8,5,12.8,0,12.7,3.7,-1.7,2 +Student_00269,1,1,9070,1,1,1,1,37,37,9,9,137.0,126.2,1,0,0,1,0,1,0,19,0,6,6,6,13.0,0,0,6,8,6,12.5,0,10.8,1.4,1.74,2 +Student_00271,1,44,9003,1,1,39,1,37,38,4,8,150.0,150.0,0,0,0,1,0,1,0,21,0,6,9,6,12.666666666666666,0,0,6,8,5,12.8,0,13.9,-0.3,0.79,2 +Student_00272,1,1,9147,1,2,1,1,1,19,9,9,121.0,113.7,1,0,0,0,0,0,0,20,0,5,10,2,10.0,0,0,5,12,1,13.0,0,7.6,2.6,0.32,0 +Student_00273,1,17,9147,1,1,1,1,12,19,4,8,122.0,117.8,1,0,0,1,0,0,0,20,0,5,10,5,13.5,0,0,5,8,5,12.333333333333334,0,13.9,-0.3,0.79,2 +Student_00274,1,1,9500,1,1,1,1,5,1,2,5,143.0,136.7,0,0,0,1,0,0,0,19,2,7,8,7,12.67,0,1,8,8,8,13.55,0,11.1,0.6,2.02,2 +Student_00275,1,1,9238,1,1,1,1,1,38,4,5,152.0,144.7,0,0,0,1,0,0,0,20,0,6,8,6,14.5,0,0,6,7,6,15.428571428571429,0,16.2,0.3,-0.92,2 +Student_00277,1,42,9853,1,1,1,1,37,38,3,3,120.0,113.7,0,0,0,1,0,0,0,20,0,6,8,5,11.0,0,0,6,10,3,10.666666666666666,0,12.7,3.7,-1.7,0 +Student_00278,2,7,9130,1,1,3,1,5,4,2,0,140.0,140.0,0,0,1,0,0,0,0,29,7,9,16,7,11.555555555555555,4,5,7,12,5,13.2,2,7.6,2.6,0.32,0 +Student_00279,1,1,9500,1,1,1,1,19,19,5,6,143.0,142.3,0,0,0,1,0,1,0,18,0,7,7,7,13.79714285714286,0,0,8,8,8,13.775,0,12.4,0.5,1.79,1 +Student_00280,1,1,9500,1,1,1,1,19,19,5,5,129.0,119.6,1,0,0,1,0,1,0,20,0,7,8,7,14.00375,0,0,8,11,7,13.812857142857142,0,15.5,2.8,-4.06,2 +Student_00282,4,1,8014,0,1,1,1,39,19,4,10,133.1,143.0,1,0,0,1,0,1,0,47,0,6,9,5,14.166666666666666,0,0,6,7,6,14.166666666666666,0,16.2,0.3,-0.92,2 +Student_00283,2,51,9991,0,1,1,1,37,37,8,4,127.0,100.1,0,0,0,1,0,0,0,31,1,5,5,5,14.0,0,0,5,5,5,13.8,0,8.9,1.4,3.51,2 +Student_00284,1,1,9070,1,1,1,1,19,37,7,5,126.0,119.4,0,0,0,1,0,1,0,21,0,6,7,5,13.8,0,0,6,6,6,12.833333333333334,0,16.2,0.3,-0.92,2 +Student_00288,1,39,8014,0,1,15,1,34,1,90,2,170.0,101.0,0,0,0,1,0,0,0,32,0,6,9,4,12.0,0,0,6,12,4,11.5,0,7.6,2.6,0.32,2 +Student_00289,1,18,8014,0,2,1,1,3,1,3,4,117.0,111.8,1,0,0,1,0,1,0,19,0,6,8,6,10.833333333333334,0,0,6,9,6,11.5,0,10.8,1.4,1.74,2 +Student_00290,1,39,9500,1,1,1,1,3,3,1,1,140.0,140.0,1,0,0,1,0,0,0,24,0,8,8,8,13.385,0,0,8,8,8,13.385,0,9.4,-0.8,-3.12,2 +Student_00291,1,17,9085,1,4,1,1,19,19,4,10,123.0,124.4,1,0,0,1,0,0,0,19,0,6,14,6,15.666666666666666,0,0,6,9,6,14.5,0,15.5,2.8,-4.06,2 +Student_00292,1,44,9003,1,1,39,1,19,37,6,6,150.0,150.0,0,0,1,1,0,1,0,19,0,6,9,6,14.333333333333334,0,0,6,7,6,13.833333333333334,0,13.9,-0.3,0.79,2 +Student_00293,1,44,9003,1,1,39,1,37,37,9,4,140.0,140.0,0,0,0,1,0,0,0,24,0,6,10,6,11.428571428571429,0,0,6,12,5,13.0,0,12.4,0.5,1.79,1 +Student_00294,1,17,9238,1,4,1,1,19,19,191,144,123.0,116.0,1,0,0,1,0,1,0,18,0,6,9,6,11.666666666666666,0,0,6,8,6,11.666666666666666,0,8.9,1.4,3.51,2 +Student_00295,1,1,9070,1,1,1,1,38,37,3,6,130.0,135.6,1,0,0,1,0,1,0,19,0,6,9,5,12.0,0,0,6,10,2,11.333333333333334,0,8.9,1.4,3.51,0 +Student_00296,2,1,9500,1,1,1,1,3,38,2,4,137.0,121.0,0,0,0,NA,0,1,0,19,0,8,8,7,14.725714285714288,0,0,8,8,7,14.725714285714288,0,10.8,1.4,1.74,2 +Student_00298,1,1,9238,1,1,1,1,1,1,3,3,125.0,125.7,1,0,0,1,0,0,0,18,0,6,10,6,11.571428571428571,0,0,6,8,6,12.333333333333334,0,12.4,0.5,1.79,2 +Student_00299,1,17,9556,1,4,1,1,1,1,4,10,112.0,107.1,1,0,0,1,0,0,0,20,0,7,7,7,12.5,0,0,8,8,8,13.1375,0,12.4,0.5,1.79,2 +Student_00301,1,17,9670,1,4,1,1,38,38,9,7,135.0,127.0,1,0,0,1,0,0,0,18,0,6,10,6,12.25,0,0,6,9,6,13.714285714285714,0,11.1,0.6,2.02,2 +Student_00302,1,1,9085,1,2,1,1,38,37,9,9,117.0,113.5,1,0,0,1,0,1,0,21,0,5,7,4,12.0,0,0,5,5,5,12.2,0,10.8,1.4,1.74,2 +Student_00303,1,1,9500,1,1,1,1,19,19,4,9,160.0,154.4,0,0,0,1,0,1,0,18,0,7,9,7,15.116666666666667,0,0,8,9,8,16.168888888888887,0,15.5,2.8,-4.06,2 +Student_00304,1,51,9670,1,1,1,1,19,19,5,5,136.0,122.0,0,0,1,0,0,0,0,18,0,5,6,2,12.5,0,0,5,6,4,10.25,0,9.4,-0.8,-3.12,0 +Student_00305,1,17,9238,1,2,1,1,1,11,4,3,143.0,128.0,1,0,0,1,0,0,0,19,0,6,11,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00308,1,39,9130,1,1,3,1,3,1,90,90,150.0,150.0,1,0,0,1,0,0,0,34,1,5,6,1,11.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_00309,1,1,9085,1,3,1,1,11,11,90,90,142.0,155.3,0,0,0,1,0,0,0,19,0,5,5,5,15.2,0,0,5,6,5,13.2,0,7.6,2.6,0.32,2 +Student_00310,1,44,9130,1,1,39,1,37,37,7,8,120.0,120.0,1,0,1,0,0,0,0,19,2,6,7,5,11.6,0,1,6,12,2,11.0,0,12.4,0.5,1.79,0 +Student_00311,1,51,9238,1,1,1,1,3,19,2,1,160.0,116.1,0,0,1,1,0,0,0,26,0,6,6,6,14.833333333333334,0,0,6,7,6,15.142857142857142,0,11.1,0.6,2.02,2 +Student_00312,1,17,9853,1,1,1,1,34,34,0,0,133.1,118.9,1,0,0,1,0,0,0,21,0,6,12,3,11.333333333333334,0,0,6,10,3,11.333333333333334,0,7.6,2.6,0.32,0 +Student_00313,1,17,9147,1,2,1,1,19,19,4,8,142.0,127.3,0,0,0,1,0,1,0,18,0,5,5,5,11.2,0,0,5,5,5,11.8,0,11.1,0.6,2.02,2 +Student_00314,1,17,9853,1,4,1,1,38,38,5,7,121.0,113.7,1,0,0,1,NA,1,0,20,0,6,8,5,13.4,0,0,6,9,5,13.666666666666666,0,9.4,-0.8,-3.12,2 +Student_00315,1,51,9147,1,1,1,1,1,1,4,4,135.0,118.5,0,0,0,1,0,0,0,25,0,5,12,2,10.5,0,0,5,5,0,0.0,0,11.1,0.6,2.02,0 +Student_00316,1,1,9147,1,1,1,1,1,38,4,3,153.0,146.7,0,0,0,1,0,0,0,18,0,5,5,5,16.2,0,0,5,5,5,16.4,0,11.1,0.6,2.02,2 +Student_00317,1,1,9500,1,1,1,1,19,19,3,6,140.0,124.3,1,0,0,1,0,1,0,18,0,7,7,7,14.542857142857144,0,0,8,11,8,14.88181818181818,0,16.2,0.3,-0.92,2 +Student_00318,1,1,9500,1,1,1,1,41,19,3,5,152.0,137.8,0,0,0,1,NA,0,0,19,0,7,7,7,13.694285714285714,0,0,8,9,8,14.355555555555554,0,11.1,0.6,2.02,2 +Student_00319,1,1,9238,1,1,1,1,19,38,5,9,120.0,130.2,0,0,0,1,0,1,0,18,0,6,8,6,11.285714285714286,0,0,6,10,6,11.857142857142858,0,12.4,0.5,1.79,2 +Student_00320,1,17,9500,1,1,1,1,38,38,7,7,160.0,147.8,0,0,0,1,0,0,0,20,0,7,11,6,11.757142857142856,0,0,8,12,6,13.083333333333334,0,15.5,2.8,-4.06,1 +Student_00321,1,7,9085,1,1,40,1,19,19,9,5,150.0,150.0,0,0,1,0,0,0,0,26,0,3,3,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_00323,1,1,9500,1,1,1,1,1,1,5,1,150.0,155.6,0,0,0,1,0,0,0,19,0,7,7,7,14.3,0,0,8,9,8,14.055555555555555,0,16.2,0.3,-0.92,2 +Student_00324,1,43,9147,1,4,1,1,37,37,9,9,124.0,117.4,0,0,0,1,0,0,0,19,3,10,15,5,11.8,0,4,10,14,8,12.0,0,7.6,2.6,0.32,2 +Student_00325,1,5,9085,1,3,1,1,1,19,7,5,141.0,128.8,1,0,0,1,0,0,0,19,0,5,9,3,10.333333333333334,1,0,5,8,3,13.0,0,7.6,2.6,0.32,1 +Student_00326,1,1,9254,1,1,1,1,NA,19,5,8,121.0,117.5,1,0,0,1,0,0,0,18,0,6,7,6,10.571428571428571,0,0,6,11,3,11.666666666666666,0,16.2,0.3,-0.92,2 +Student_00327,1,43,9500,1,1,6,1,1,37,9,9,134.0,120.4,1,0,0,NA,0,0,0,19,0,7,7,6,13.333333333333334,0,0,7,7,6,13.333333333333334,0,7.6,2.6,0.32,2 +Student_00329,1,1,9853,1,1,1,1,2,19,4,4,132.0,125.0,1,0,0,1,0,0,0,18,0,6,9,5,12.6,0,0,6,8,5,11.4,0,9.4,-0.8,-3.12,1 +Student_00330,1,1,9085,1,1,1,1,19,38,9,5,135.0,136.8,1,0,0,1,0,0,0,18,0,5,11,5,NA,3,0,5,7,5,11.6,0,9.4,-0.8,-3.12,1 +Student_00331,1,1,9853,1,1,1,1,1,38,9,6,123.0,121.6,1,0,0,1,0,0,0,18,0,7,12,5,12.0,0,0,7,9,6,12.666666666666666,0,11.1,0.6,2.02,1 +Student_00332,1,44,9119,1,1,39,1,19,37,4,7,151.0,151.0,0,0,1,1,0,0,0,26,0,5,6,0,0.0,0,0,5,5,0,0.0,0,16.2,0.3,-0.92,0 +Student_00333,1,1,9238,1,1,1,1,38,38,7,7,107.0,103.5,1,0,0,1,0,0,0,20,0,6,7,6,12.0,0,0,6,7,6,13.0,0,12.4,0.5,1.79,2 +Student_00334,1,1,8014,0,1,1,1,37,38,9,10,126.0,119.4,0,0,0,1,0,0,0,19,0,6,6,6,12.666666666666666,0,0,6,6,6,11.666666666666666,0,12.7,3.7,-1.7,2 +Student_00335,1,1,9238,1,1,1,1,34,37,4,9,133.0,134.4,1,0,0,1,0,1,0,18,0,6,6,6,12.166666666666666,0,0,6,9,6,13.666666666666666,0,9.4,-0.8,-3.12,2 +Student_00336,1,44,9238,1,1,39,1,38,37,7,7,140.0,143.0,0,0,0,1,0,0,0,19,3,6,6,6,13.333333333333334,0,2,6,6,6,14.666666666666666,0,13.9,-0.3,0.79,2 +Student_00338,1,1,9500,1,4,1,1,38,38,7,7,141.0,132.5,1,0,0,1,0,1,0,18,0,8,8,8,13.39125,0,0,8,8,8,13.39125,0,9.4,-0.8,-3.12,2 +Student_00339,1,17,9238,1,1,1,1,3,1,9,10,122.0,114.7,0,0,0,1,0,0,0,19,0,6,9,5,12.166666666666666,0,0,6,8,6,12.428571428571429,0,13.9,-0.3,0.79,2 +Student_00340,1,17,9130,1,1,1,1,2,9,3,5,156.0,166.9,0,0,0,1,0,0,0,18,0,5,9,4,11.25,0,0,5,6,4,12.5,0,7.6,2.6,0.32,2 +Student_00341,1,1,9085,1,1,1,1,1,2,3,1,129.0,125.9,1,0,0,1,0,0,0,19,0,5,13,4,12.0,2,0,5,8,3,12.0,0,9.4,-0.8,-3.12,1 +Student_00342,1,1,171,1,1,1,1,3,3,2,2,188.0,178.3,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00343,2,39,8014,0,1,1,1,37,37,9,9,120.0,117.0,1,0,0,NA,0,0,0,33,0,6,7,6,12.833333333333334,0,0,6,8,6,12.857142857142858,0,12.4,0.5,1.79,2 +Student_00344,1,39,9003,1,1,3,1,3,3,1,2,130.0,150.0,0,0,0,1,0,0,0,35,0,6,10,6,14.0,0,0,6,11,6,13.1,0,16.2,0.3,-0.92,2 +Student_00345,1,42,9147,1,1,1,1,37,38,9,1,130.0,130.0,1,0,0,1,0,0,0,26,3,5,5,4,13.0,0,1,5,7,2,12.0,0,9.4,-0.8,-3.12,1 +Student_00346,1,1,9773,1,1,1,1,19,19,7,5,140.0,135.1,1,0,0,1,0,0,0,18,0,6,7,6,13.5,0,0,6,8,6,12.5,0,9.4,-0.8,-3.12,2 +Student_00347,1,43,9238,1,1,1,1,37,37,9,9,110.0,110.0,0,0,0,1,0,0,0,36,10,16,24,13,10.692307692307692,1,9,13,19,9,12.307692307692308,0,15.5,2.8,-4.06,1 +Student_00348,4,39,9991,0,1,1,1,37,37,6,6,133.1,136.2,0,0,0,1,0,0,0,39,0,5,6,5,11.0,0,0,5,9,5,11.666666666666666,0,10.8,1.4,1.74,2 +Student_00350,1,1,8014,0,2,1,1,3,1,3,9,96.0,100.0,0,0,0,1,0,0,0,20,0,6,10,5,12.0,0,0,6,9,4,11.25,0,9.4,-0.8,-3.12,1 +Student_00351,1,1,9254,1,1,1,1,19,19,9,9,117.0,116.3,1,0,0,1,0,0,0,24,0,6,9,4,12.6,0,0,6,6,4,11.5,0,12.7,3.7,-1.7,0 +Student_00352,1,43,9773,1,1,1,1,19,19,9,8,123.0,134.0,0,0,0,1,0,1,0,20,0,6,6,6,13.666666666666666,0,0,6,6,6,13.333333333333334,0,12.4,0.5,1.79,2 +Student_00353,1,1,171,1,4,1,1,1,1,9,5,127.0,124.2,1,0,0,0,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00354,2,1,9500,1,1,1,1,37,38,9,7,151.0,134.5,0,0,1,1,0,1,0,18,0,7,7,6,14.2,0,0,7,7,6,14.2,0,7.6,2.6,0.32,2 +Student_00355,1,1,9254,1,1,1,1,19,19,4,6,127.0,120.7,0,0,1,0,0,0,0,22,0,6,10,5,11.0,0,0,6,12,0,0.0,0,10.8,1.4,1.74,0 +Student_00358,1,39,9991,0,1,1,1,37,37,90,8,133.1,128.2,0,0,0,1,0,0,0,33,0,5,0,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_00360,1,39,9085,1,1,43,1,3,39,2,3,160.0,172.0,0,0,0,1,0,0,0,26,0,6,0,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_00361,1,17,9853,1,4,1,1,19,38,4,1,140.0,128.5,1,0,0,1,0,0,0,18,0,6,7,6,11.666666666666666,0,0,6,10,6,11.833333333333334,0,10.8,1.4,1.74,2 +Student_00362,1,1,9773,1,1,1,1,37,38,9,7,146.0,128.5,0,0,1,NA,0,0,0,19,0,6,13,3,12.666666666666666,0,0,6,12,2,10.0,0,10.8,1.4,1.74,0 +Student_00363,1,17,9147,1,4,1,1,19,38,9,10,112.0,112.0,1,0,0,1,0,0,0,20,0,5,10,3,10.333333333333334,0,0,5,9,4,11.0,2,16.2,0.3,-0.92,1 +Student_00364,1,53,9085,1,1,42,1,19,37,9,8,140.0,142.5,1,0,0,1,NA,1,0,22,7,11,18,8,13.5,0,4,9,16,7,13.714285714285714,0,8.9,1.4,3.51,2 +Student_00365,1,1,9500,1,4,1,1,1,1,9,1,136.0,133.0,1,0,0,1,0,0,0,19,0,7,8,5,13.98,0,0,7,8,5,13.98,0,7.6,2.6,0.32,1 +Student_00366,1,1,9085,1,1,1,1,37,38,7,5,133.1,106.0,1,0,0,1,0,1,0,21,0,6,13,6,16.153846153846153,0,0,6,10,6,15.75,0,15.5,2.8,-4.06,2 +Student_00368,1,17,9085,1,1,1,1,19,37,2,7,134.0,131.2,0,0,0,1,0,0,0,19,0,5,8,1,11.0,0,0,5,6,5,11.2,0,7.6,2.6,0.32,1 +Student_00369,1,1,9853,1,1,1,1,38,37,191,195,122.0,112.9,1,0,0,1,0,1,0,19,0,7,8,7,13.857142857142858,0,0,7,8,6,13.666666666666666,0,8.9,1.4,3.51,2 +Student_00370,1,1,9500,1,6,1,1,19,19,9,5,138.0,124.8,1,0,0,1,0,0,0,18,0,8,8,7,13.414285714285716,0,0,8,8,7,13.414285714285716,0,12.7,3.7,-1.7,0 +Student_00371,2,43,8014,0,1,1,1,37,39,9,4,160.0,140.9,0,0,0,1,0,0,0,50,7,11,11,11,13.545454545454543,0,3,7,7,7,13.571428571428571,0,16.2,0.3,-0.92,2 +Student_00372,4,39,9991,0,1,1,1,38,19,9,7,130.0,148.0,0,0,0,1,0,1,0,31,0,5,11,4,11.25,0,0,5,10,4,10.833333333333334,0,13.9,-0.3,0.79,1 +Student_00374,4,39,9991,0,1,1,1,1,37,141,192,140.0,129.7,0,0,0,1,0,0,0,35,0,5,8,5,12.0,0,0,5,9,5,12.857142857142858,0,13.9,-0.3,0.79,2 +Student_00375,2,39,9085,1,1,19,1,38,38,4,7,133.1,128.2,0,0,0,1,0,0,0,31,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_00378,1,1,9500,1,1,1,1,1,1,4,4,152.0,141.0,1,0,0,1,0,1,0,18,0,7,7,7,15.135714285714286,0,0,8,8,8,15.287499999999998,0,12.4,0.5,1.79,2 +Student_00379,1,17,9853,1,1,1,1,3,3,3,3,125.0,NA,1,0,0,0,0,1,0,18,0,7,7,7,12.285714285714286,0,0,7,8,6,13.333333333333334,0,8.9,1.4,3.51,1 +Student_00380,1,44,9085,1,1,39,1,37,38,5,6,140.0,140.0,1,0,0,1,0,0,0,21,2,6,16,5,12.666666666666666,0,1,6,15,2,13.5,0,16.2,0.3,-0.92,1 +Student_00381,4,39,9500,1,1,19,1,38,19,5,7,133.1,140.0,0,0,0,1,0,1,0,26,0,7,13,5,12.74,0,0,8,12,6,10.978571428571428,0,16.2,0.3,-0.92,0 +Student_00382,1,43,9500,1,1,1,1,19,37,8,8,170.0,100.0,0,0,0,1,0,0,0,20,0,7,8,6,13.25,0,0,8,8,8,13.75,0,13.9,-0.3,0.79,1 +Student_00384,1,1,9853,1,1,1,1,19,19,5,5,125.0,117.0,0,0,0,1,0,1,0,19,0,6,7,6,13.428571428571429,0,0,6,6,6,13.166666666666666,0,15.5,2.8,-4.06,2 +Student_00385,1,53,9147,1,1,42,1,3,4,2,1,140.0,140.2,0,0,0,1,0,0,0,20,6,11,19,9,12.555555555555555,0,3,9,14,8,11.11111111111111,0,8.9,1.4,3.51,2 +Student_00386,1,1,NA,1,1,1,1,34,34,0,0,124.0,129.3,0,0,0,1,0,0,0,19,0,6,8,6,11.5,0,0,6,7,6,11.166666666666666,0,7.6,2.6,0.32,2 +Student_00387,1,1,9853,1,1,1,1,37,37,9,9,140.0,145.3,0,0,0,1,0,0,0,18,0,6,6,6,13.666666666666666,0,0,6,9,6,12.333333333333334,0,7.6,2.6,0.32,2 +Student_00388,1,39,9991,0,1,3,1,37,37,9,9,130.0,146.2,0,0,0,1,0,0,0,28,10,14,16,11,11.272727272727272,0,6,11,16,10,12.0,0,10.8,1.4,1.74,2 +Student_00389,1,17,9853,1,1,1,1,1,19,4,5,134.0,122.5,1,0,0,1,0,0,0,22,0,6,10,5,13.166666666666666,0,0,6,8,5,12.4,0,15.5,2.8,-4.06,1 +Student_00390,1,44,8014,0,1,39,1,37,37,7,7,160.0,156.1,0,0,0,1,0,1,0,21,3,6,6,6,14.666666666666666,0,2,6,6,6,14.166666666666666,0,13.9,-0.3,0.79,2 +Student_00393,1,1,9773,1,6,1,1,30,37,7,7,141.0,128.4,1,0,1,0,0,0,0,18,0,6,8,5,13.0,0,0,6,8,5,11.4,0,7.6,2.6,0.32,0 +Student_00394,1,17,9085,1,2,1,1,1,1,9,10,120.0,115.0,0,0,0,0,0,0,0,20,0,5,8,2,10.5,0,0,5,8,2,12.333333333333334,0,7.6,2.6,0.32,0 +Student_00395,1,17,9085,1,2,1,1,1,19,4,3,166.0,158.7,0,0,0,1,0,0,0,18,0,6,7,6,14.857142857142858,0,0,6,7,6,14.0,0,11.1,0.6,2.02,2 +Student_00396,1,1,9500,1,4,1,1,1,1,4,9,147.0,124.5,1,0,0,1,0,1,0,19,0,8,11,7,12.86,0,0,8,11,7,12.86,0,10.8,1.4,1.74,2 +Student_00398,1,44,9085,1,1,39,1,38,37,4,6,150.0,150.0,1,0,0,1,0,1,0,22,3,6,11,6,13.142857142857142,0,2,6,10,3,12.0,0,13.9,-0.3,0.79,2 +Student_00399,1,17,9670,1,1,1,1,37,19,5,8,124.0,114.2,1,0,1,1,0,0,0,18,0,6,6,5,11.8,0,0,6,9,4,13.714285714285714,0,10.8,1.4,1.74,0 +Student_00402,1,17,9254,1,1,1,1,37,37,7,7,136.0,121.7,1,0,0,1,0,0,0,20,0,6,13,3,10.333333333333334,0,0,6,12,3,10.333333333333334,0,10.8,1.4,1.74,1 +Student_00403,1,1,9773,1,1,1,1,38,37,9,9,120.0,114.8,1,1,0,1,0,0,0,19,0,6,11,4,12.25,0,0,6,11,3,11.0,0,7.6,2.6,0.32,1 +Student_00404,1,1,9254,1,1,1,1,19,38,9,9,128.0,127.0,0,0,0,1,0,0,0,19,0,6,6,6,12.0,0,0,6,7,4,12.75,0,12.4,0.5,1.79,1 +Student_00405,1,17,9500,1,1,1,1,37,37,5,5,142.0,131.3,1,0,0,1,0,0,0,19,0,8,8,7,14.731428571428571,0,0,8,8,7,14.731428571428571,0,10.8,1.4,1.74,2 +Student_00406,1,1,171,1,1,1,1,1,19,3,9,135.0,137.1,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_00408,1,39,9991,0,1,40,1,1,19,9,9,140.0,139.0,0,0,0,1,0,0,0,27,0,5,5,5,15.8,0,0,5,5,5,14.8,0,8.9,1.4,3.51,2 +Student_00409,1,17,9238,1,1,1,1,1,19,4,4,135.0,129.1,0,0,0,1,0,0,0,19,0,6,6,6,14.666666666666666,0,0,6,7,6,14.571428571428571,0,15.5,2.8,-4.06,2 +Student_00412,1,39,9500,1,1,3,1,19,1,4,8,122.0,NA,0,0,0,1,0,0,0,24,0,8,8,7,NA,0,0,8,8,7,12.401428571428571,0,10.8,1.4,1.74,2 +Student_00413,1,1,9500,1,3,1,1,1,1,4,10,128.0,118.9,1,0,0,1,0,0,0,20,0,7,8,7,11.5875,0,0,8,9,7,14.071428571428571,0,13.9,-0.3,0.79,2 +Student_00414,1,7,9991,0,1,40,1,37,37,6,6,140.0,140.0,0,0,0,1,0,0,0,26,3,5,5,5,14.0,0,1,5,5,5,15.6,0,12.4,0.5,1.79,2 +Student_00415,1,1,9238,1,1,1,NA,1,38,9,7,132.0,127.1,1,0,0,1,0,1,0,20,0,6,9,6,12.333333333333334,0,0,6,6,6,11.833333333333334,0,8.9,1.4,3.51,2 +Student_00416,1,1,9085,1,1,1,1,37,37,90,90,131.0,137.0,0,0,0,1,0,0,0,18,0,5,5,5,14.0,0,0,5,6,5,15.4,0,7.6,2.6,0.32,2 +Student_00417,1,1,9085,1,1,1,1,1,1,9,9,126.0,127.4,1,0,0,NA,0,0,0,19,0,6,13,6,15.23076923076923,0,0,6,10,6,12.375,0,15.5,2.8,-4.06,2 +Student_00418,1,1,9853,1,1,1,1,19,19,9,9,133.1,97.0,1,0,0,1,0,0,0,23,0,6,9,5,11.6,0,0,6,9,3,11.0,0,12.7,3.7,-1.7,0 +Student_00419,1,1,9500,1,4,1,1,37,37,9,9,136.0,126.3,1,0,0,1,0,1,0,18,0,7,7,6,11.6,0,0,7,7,6,11.6,0,7.6,2.6,0.32,2 +Student_00420,1,1,9500,1,4,1,1,1,19,4,5,140.0,127.5,0,0,0,1,0,0,0,18,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_00421,1,1,9500,1,1,1,1,2,1,2,8,135.0,126.6,0,0,0,1,0,1,0,19,0,7,7,7,12.901428571428571,0,0,8,9,8,13.094444444444443,0,11.1,0.6,NA,2 +Student_00422,1,42,9991,0,1,1,1,1,2,4,3,160.0,120.0,0,0,0,1,0,0,0,30,4,7,9,7,14.142857142857142,0,1,5,5,5,14.8,0,7.6,2.6,0.32,2 +Student_00423,1,44,9085,1,1,39,1,1,2,4,6,140.0,140.0,1,0,0,1,0,0,0,29,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00424,1,1,9500,1,6,1,1,3,1,3,3,140.0,131.5,1,0,0,1,0,0,0,19,0,8,8,8,13.25375,0,0,8,8,8,13.25375,0,9.4,-0.8,-3.12,2 +Student_00425,1,17,9556,1,6,1,1,19,2,5,3,115.0,112.2,1,0,0,1,0,0,0,20,0,7,7,7,13.785714285714286,0,0,8,8,8,14.1,0,12.4,0.5,1.79,2 +Student_00426,1,1,9500,1,1,1,1,37,37,9,3,144.0,150.5,0,0,0,1,0,0,0,20,0,7,7,6,13.916666666666666,0,0,7,7,6,13.916666666666666,0,7.6,2.6,0.32,2 +Student_00427,1,1,9670,1,4,1,1,38,38,3,7,128.0,121.0,1,0,0,1,0,0,0,19,0,6,8,6,NA,0,0,6,9,6,13.571428571428571,0,11.1,0.6,2.02,2 +Student_00428,1,17,9147,1,1,1,1,38,2,9,2,116.0,112.2,1,0,0,1,0,0,0,20,0,5,8,3,11.333333333333334,0,0,5,12,2,10.666666666666666,0,10.8,1.4,1.74,1 +Student_00429,3,1,9085,1,2,1,1,19,1,4,4,135.0,129.4,1,0,0,1,0,0,0,21,0,5,8,0,0.0,4,0,5,12,0,0.0,4,10.8,1.4,1.74,0 +Student_00430,1,17,9670,1,1,1,1,19,38,4,10,121.0,114.4,0,0,0,1,0,0,0,19,0,6,10,5,11.5,0,0,6,9,4,14.6,0,11.1,0.6,2.02,2 +Student_00432,1,39,8014,0,1,1,1,37,37,7,8,120.0,120.0,0,0,0,1,0,1,0,27,0,6,8,6,11.833333333333334,0,0,6,10,5,12.8,0,15.5,2.8,-4.06,2 +Student_00434,1,1,9500,1,1,1,1,1,1,90,3,141.0,127.8,0,0,0,1,0,1,0,19,0,7,7,0,0.0,2,0,7,7,0,0.0,2,7.6,2.6,0.32,0 +Student_00435,1,1,9773,1,1,1,1,1,19,4,8,140.0,124.6,1,0,0,1,0,0,0,19,0,6,7,5,14.2,0,0,6,7,6,14.571428571428571,0,15.5,2.8,-4.06,2 +Student_00438,1,1,9670,1,1,1,1,19,37,4,5,130.0,118.8,0,0,0,1,0,1,0,18,0,6,6,6,14.5,0,0,6,8,6,13.666666666666666,0,12.7,3.7,-1.7,2 +Student_00439,1,1,9670,1,5,1,1,9,1,2,4,133.1,133.0,1,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_00440,2,39,9500,1,1,19,1,37,37,9,9,133.1,129.0,1,0,0,1,0,0,0,36,0,7,7,6,11.3,0,0,7,7,6,11.3,0,7.6,2.6,0.32,2 +Student_00441,1,43,9556,1,1,1,1,3,4,3,2,147.0,100.0,0,0,0,1,0,0,0,18,0,2,2,0,0.0,0,0,4,4,1,16.0,0,10.8,1.4,1.74,1 +Student_00442,1,43,9130,1,1,1,1,19,38,4,5,127.0,120.7,1,0,1,1,0,0,0,18,0,5,11,1,12.0,0,0,5,9,3,12.0,0,12.7,3.7,-1.7,1 +Student_00443,1,17,9500,1,6,1,1,19,38,9,3,136.0,132.5,1,0,0,1,0,0,0,19,0,8,9,7,12.3,0,0,8,9,7,12.3,0,12.7,3.7,-1.7,2 +Student_00444,1,1,9500,1,5,1,NA,19,19,7,8,127.0,120.3,1,0,0,1,0,1,0,18,0,8,8,7,12.694285714285714,0,0,8,8,7,12.694285714285714,0,10.8,1.4,1.74,2 +Student_00445,1,17,9670,1,1,1,1,19,19,1,1,123.0,114.6,0,0,0,1,0,0,0,18,0,5,5,4,11.0,0,0,5,5,4,11.0,0,9.4,-0.8,-3.12,2 +Student_00446,1,1,9238,1,1,1,1,37,19,9,3,128.0,116.5,1,0,0,1,0,1,0,19,0,6,6,6,13.0,0,0,6,6,6,14.166666666666666,0,12.4,0.5,1.79,2 +Student_00447,1,1,9500,1,1,1,1,3,1,2,1,128.0,127.8,0,0,0,1,0,1,0,19,0,7,8,7,14.4125,0,0,8,8,8,16.05,0,13.9,-0.3,NA,2 +Student_00450,1,1,9254,1,3,1,1,19,38,3,10,122.0,114.3,1,0,0,1,0,1,0,20,0,6,8,5,12.8,0,0,6,9,5,12.8,0,12.4,0.5,1.79,1 +Student_00451,1,18,9500,1,1,1,1,38,37,5,5,126.0,114.8,1,0,0,1,0,0,0,20,0,8,8,7,14.402857142857142,0,0,8,8,7,14.402857142857142,0,10.8,1.4,1.74,2 +Student_00452,1,1,9500,1,4,1,1,37,37,9,8,135.0,123.0,1,0,0,1,0,1,0,18,0,8,8,7,13.381428571428572,0,0,8,8,7,13.381428571428572,0,10.8,1.4,1.74,2 +Student_00453,1,1,9500,1,2,1,1,19,19,7,5,131.0,122.1,1,0,0,1,0,0,0,18,0,7,8,7,14.13125,0,0,8,8,8,13.98375,0,15.5,2.8,-4.06,2 +Student_00454,1,17,9085,1,4,1,1,19,37,4,7,140.0,123.7,0,0,0,1,0,0,0,19,0,5,11,5,11.714285714285714,2,0,5,6,5,12.6,0,9.4,-0.8,-3.12,2 +Student_00455,1,1,9147,1,3,1,1,19,38,9,7,131.0,132.4,1,0,0,1,0,0,0,19,0,5,5,5,11.8,0,0,5,8,4,11.25,0,9.4,-0.8,-3.12,1 +Student_00456,2,39,8014,0,1,1,1,34,34,99,99,130.0,114.8,0,0,0,1,0,0,0,44,0,6,9,6,11.166666666666666,0,1,6,15,2,11.0,1,7.6,2.6,0.32,2 +Student_00457,1,7,9003,1,1,3,1,38,37,5,6,130.0,130.0,0,0,0,1,0,0,0,32,0,6,7,0,0.0,0,0,6,6,0,0.0,0,12.4,0.5,1.79,0 +Student_00459,2,NA,9003,1,1,1,1,1,19,4,9,130.0,152.4,1,0,0,1,0,0,0,36,4,12,14,12,13.846153846153848,0,5,12,18,11,14.090909090909092,0,8.9,1.4,3.51,2 +Student_00460,1,17,9773,1,1,1,1,37,37,5,7,125.0,120.1,0,0,0,1,0,1,0,18,0,6,7,6,12.5,0,0,6,8,6,13.333333333333334,0,16.2,0.3,-0.92,2 +Student_00461,1,1,9130,1,1,1,1,3,3,3,2,160.0,155.1,1,0,0,1,0,0,0,20,0,5,5,5,16.4,0,0,5,5,5,14.6,0,12.7,3.7,-1.7,2 +Student_00462,1,51,9070,1,1,1,1,19,19,5,7,130.0,124.5,0,0,0,1,0,1,0,20,5,11,11,11,13.818181818181818,0,5,11,11,11,13.454545454545457,0,11.1,0.6,2.02,2 +Student_00464,1,39,9147,1,1,19,1,3,1,3,5,133.1,153.2,1,0,1,1,0,0,0,24,0,5,8,5,10.2,0,0,5,6,5,12.2,0,12.4,0.5,1.79,2 +Student_00465,1,17,9238,1,1,1,1,1,1,4,9,148.0,129.8,0,0,0,1,0,0,0,20,0,6,11,5,10.6,0,0,6,11,4,10.4,0,15.5,2.8,-4.06,1 +Student_00466,1,43,8014,0,1,1,1,NA,3,2,3,133.1,135.0,0,0,0,1,0,0,0,27,7,10,10,9,11.444444444444445,0,4,11,11,5,10.8,0,10.8,1.4,1.74,0 +Student_00467,1,1,9853,1,1,1,1,1,38,5,10,133.0,131.3,1,0,0,1,0,0,0,20,0,6,9,5,14.333333333333334,0,4,8,8,8,12.625,0,15.5,2.8,-4.06,1 +Student_00468,1,43,9238,1,6,1,1,34,34,0,0,129.0,125.2,0,0,0,1,0,1,0,23,15,16,18,16,13.0,0,11,13,15,13,13.266666666666667,0,9.4,-0.8,-3.12,2 +Student_00469,1,1,9500,1,5,1,1,NA,38,4,8,144.0,141.3,1,0,0,1,0,1,0,18,0,8,9,8,13.31,1,0,8,9,8,13.31,1,9.4,-0.8,-3.12,2 +Student_00470,1,17,9238,1,1,1,1,37,37,4,9,120.0,117.1,1,0,0,1,0,1,0,18,0,6,10,5,10.571428571428571,1,0,6,9,5,12.2,0,12.7,3.7,-1.7,2 +Student_00471,1,17,9500,1,3,1,1,1,37,9,9,144.0,126.5,1,0,0,1,0,1,0,20,0,8,8,7,13.487142857142857,0,0,8,8,7,13.487142857142857,0,10.8,1.4,1.74,2 +Student_00472,1,1,9254,1,1,1,1,19,38,9,7,132.0,120.1,0,0,0,1,0,1,0,20,0,6,6,6,12.333333333333334,0,0,6,7,6,11.833333333333334,0,13.9,-0.3,0.79,2 +Student_00473,1,1,9670,1,1,1,1,38,19,7,10,142.0,128.4,0,0,0,1,0,0,0,23,0,6,11,6,11.875,0,0,6,9,5,12.833333333333334,0,11.1,0.6,2.02,0 +Student_00474,1,1,9500,1,2,1,1,19,19,9,9,136.0,140.0,1,0,0,1,0,0,0,20,0,7,7,6,13.966666666666669,0,0,7,7,6,13.966666666666669,0,7.6,2.6,0.32,2 +Student_00475,1,39,9254,1,1,NA,1,34,34,0,0,133.1,110.0,1,0,0,0,0,0,0,28,0,5,10,0,0.0,0,0,5,10,0,0.0,0,7.6,2.6,0.32,0 +Student_00476,1,1,9670,1,1,1,1,1,19,3,5,122.0,116.8,1,0,0,1,0,0,0,21,0,5,8,4,11.5,0,0,5,5,5,12.8,0,7.6,2.6,0.32,2 +Student_00477,1,1,9556,1,2,1,1,19,19,9,9,133.1,104.5,1,0,0,1,0,0,0,21,0,2,2,2,12.5,0,0,7,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00478,1,7,9500,1,1,3,1,34,34,0,0,140.0,140.0,0,0,0,1,0,0,0,28,0,7,0,0,0.0,0,0,8,0,0,0.0,0,7.6,2.6,0.32,0 +Student_00479,1,1,9500,1,1,1,1,3,1,3,3,117.0,113.2,0,1,0,1,0,0,0,18,0,7,10,6,11.98,0,0,8,11,7,13.225,0,16.2,0.3,-0.92,2 +Student_00480,1,17,9238,1,1,1,1,NA,19,191,175,128.0,118.6,1,0,0,1,0,1,0,21,0,6,8,5,13.2,0,0,6,7,5,11.8,0,8.9,1.4,3.51,1 +Student_00482,1,18,9500,1,6,1,1,1,19,1,1,141.0,126.7,1,0,0,1,0,1,0,18,0,8,8,7,14.314285714285717,0,0,8,8,7,14.314285714285717,0,12.7,3.7,-1.7,2 +Student_00483,1,1,9500,1,3,NA,1,3,1,2,5,130.0,133.8,0,0,0,1,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,7.6,2.6,0.32,0 +Student_00484,1,44,9085,1,1,39,1,38,38,9,7,140.0,140.0,0,0,0,1,0,0,0,20,2,6,9,6,12.666666666666666,0,1,6,12,2,13.0,0,13.9,-0.3,0.79,1 +Student_00485,1,1,9500,1,3,1,1,1,19,9,5,102.0,100.6,1,0,0,1,0,1,0,20,0,7,9,6,12.766666666666666,0,0,8,10,7,12.128571428571428,0,12.4,0.5,1.79,2 +Student_00486,1,17,9853,1,1,1,1,1,37,7,9,126.0,132.7,0,0,0,1,0,1,0,18,0,6,7,6,12.666666666666666,0,0,6,7,5,12.2,0,10.8,1.4,1.74,2 +Student_00487,1,43,9670,1,2,1,1,38,19,4,3,125.0,106.6,1,0,0,1,0,0,0,20,4,6,7,6,11.5,0,0,6,10,4,10.571428571428571,0,10.8,1.4,1.74,0 +Student_00489,1,17,9500,1,3,1,1,37,37,9,7,132.0,128.3,1,0,0,1,0,1,0,19,0,7,8,7,14.70625,0,0,8,8,8,14.4775,0,15.5,2.8,-4.06,2 +Student_00491,1,1,9070,1,1,1,1,19,1,3,8,115.0,123.4,0,0,0,1,0,0,0,23,1,6,8,6,13.0,1,0,6,8,6,11.875,0,13.9,-0.3,0.79,2 +Student_00492,1,1,9670,1,1,1,1,37,37,5,5,125.0,124.0,0,0,0,1,0,0,0,19,0,6,7,6,14.857142857142858,0,0,6,6,6,13.333333333333334,0,12.4,0.5,1.79,2 +Student_00493,1,1,9500,1,6,1,1,1,3,3,2,137.0,121.3,1,0,0,1,0,0,0,20,0,7,7,6,12.6,0,0,7,7,6,12.6,0,7.6,2.6,0.32,2 +Student_00494,1,1,9085,1,1,1,1,37,37,9,4,101.0,101.0,1,0,1,1,0,0,0,22,0,6,9,5,13.333333333333334,0,0,6,17,4,11.4,0,12.4,0.5,1.79,1 +Student_00496,1,7,9130,1,3,3,1,19,37,90,5,130.0,130.0,0,0,1,0,0,0,0,27,1,5,6,2,11.5,0,0,5,5,1,11.0,0,12.7,3.7,-1.7,0 +Student_00497,1,39,9556,1,1,19,NA,37,38,9,9,100.0,120.0,0,0,0,1,0,0,0,29,0,7,9,1,10.0,0,0,7,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_00499,1,17,9070,1,1,1,1,19,38,9,7,126.0,118.7,0,0,0,1,0,0,0,18,0,6,7,5,11.8,0,0,6,6,6,12.666666666666666,0,16.2,0.3,-0.92,2 +Student_00500,1,17,9500,1,1,1,1,NA,38,7,7,128.0,131.5,0,0,0,1,0,0,0,18,0,8,8,8,12.77125,0,0,8,8,8,12.77125,0,9.4,-0.8,-3.12,2 +Student_00503,1,1,9070,1,1,1,1,1,1,4,4,125.0,132.0,0,0,0,0,0,0,0,18,1,6,10,5,12.2,1,0,6,11,4,10.833333333333334,0,13.9,-0.3,0.79,1 +Student_00504,1,7,9085,1,2,3,1,3,3,1,1,130.0,130.0,0,0,0,0,0,0,0,28,0,5,9,1,12.0,1,0,4,10,0,0.0,4,10.8,1.4,1.74,0 +Student_00505,1,1,9500,1,2,1,1,37,1,7,7,135.0,132.8,1,0,0,1,0,1,0,18,0,8,12,7,11.721428571428572,0,0,8,12,7,11.721428571428572,0,12.7,3.7,-1.7,2 +Student_00509,1,1,9130,1,1,1,1,5,5,2,2,150.0,146.2,0,0,0,1,0,0,0,18,0,5,12,4,13.0,2,0,5,6,5,14.0,0,9.4,-0.8,-3.12,0 +Student_00510,1,1,9147,1,2,1,1,1,19,4,6,125.0,115.2,0,1,0,1,0,0,0,21,0,5,6,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_00511,1,1,9070,1,2,1,1,4,1,2,3,121.0,120.7,1,0,0,1,0,0,0,NA,0,6,8,4,10.75,0,0,6,9,0,0.0,0,9.4,-0.8,-3.12,1 +Student_00512,2,39,8014,0,1,1,1,34,34,99,99,120.0,101.8,0,0,0,0,0,0,0,32,0,5,5,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_00513,1,39,9670,1,2,1,1,34,34,0,0,140.0,100.0,0,0,0,1,0,0,0,28,0,5,6,4,12.5,0,0,5,7,4,11.75,0,7.6,2.6,0.32,2 +Student_00515,2,18,8014,0,2,1,1,37,37,9,10,140.0,120.4,0,0,1,0,0,0,0,39,0,5,5,0,0.0,0,0,4,4,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00517,2,39,9003,1,1,1,1,37,19,9,4,120.0,148.8,0,0,0,1,0,0,0,50,0,6,7,6,12.5,0,0,6,15,5,12.4,0,8.9,1.4,3.51,2 +Student_00518,1,17,9853,1,2,1,1,1,1,9,4,138.0,123.0,1,0,0,1,0,0,0,23,0,6,10,5,12.8,0,0,6,9,3,11.666666666666666,0,10.8,1.4,1.74,0 +Student_00519,4,39,8014,0,1,19,1,34,34,0,0,133.1,100.0,0,0,0,1,0,0,0,48,0,6,11,1,10.0,0,0,6,11,1,11.0,0,9.4,-0.8,-3.12,0 +Student_00521,1,1,NA,1,6,1,1,37,1,5,5,135.0,126.8,1,0,0,1,0,1,0,18,0,8,8,7,12.61,0,0,8,8,7,12.61,0,10.8,1.4,1.74,2 +Student_00522,1,17,9130,1,1,1,1,3,19,2,9,130.0,115.9,0,0,0,1,0,0,0,18,0,5,14,2,12.0,2,0,5,6,5,12.6,0,9.4,-0.8,-3.12,2 +Student_00524,1,18,9085,1,3,1,103,1,1,9,9,149.0,132.2,1,0,0,1,0,1,1,18,0,5,9,4,12.0,0,0,5,8,5,13.0,0,10.8,1.4,1.74,2 +Student_00525,1,1,9556,1,1,NA,103,5,3,1,1,180.0,183.5,1,0,0,1,0,0,1,18,0,7,8,4,12.0,0,0,8,8,0,0.0,0,16.2,0.3,-0.92,0 +Student_00526,1,43,9119,1,1,1,1,1,1,9,3,133.1,136.0,0,0,0,1,1,0,0,31,0,5,12,1,12.0,0,0,5,9,1,11.0,4,16.2,0.3,-0.92,0 +Student_00527,1,39,9119,1,1,19,1,19,19,5,3,133.1,100.9,1,0,0,1,1,0,0,NA,0,5,9,1,12.0,0,0,5,6,3,10.5,0,10.8,1.4,1.74,1 +Student_00528,1,39,171,1,1,1,1,3,1,2,10,145.0,114.5,1,0,0,1,1,0,0,24,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_00529,1,39,9147,1,1,1,1,37,37,9,9,110.0,110.3,0,0,1,0,1,0,0,26,0,5,5,0,0.0,0,0,5,9,0,0.0,0,10.8,1.4,1.74,0 +Student_00530,1,1,9130,1,1,1,1,3,3,2,2,154.0,137.2,1,0,1,1,1,0,0,18,0,6,11,5,13.625,0,0,6,9,4,11.75,0,16.2,0.3,-0.92,0 +Student_00531,1,17,9147,1,1,1,1,37,37,4,7,126.0,116.9,0,0,0,1,1,1,0,19,0,5,12,3,11.666666666666666,0,0,5,10,3,11.666666666666666,0,12.7,3.7,-1.7,1 +Student_00532,1,17,9670,1,1,1,1,19,37,9,8,133.0,121.8,1,0,0,1,1,0,0,22,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_00533,1,1,9500,1,2,1,1,4,2,2,3,145.0,127.3,1,0,0,1,1,0,0,18,0,8,8,7,11.69,0,0,8,8,7,11.69,0,10.8,1.4,1.74,2 +Student_00534,1,44,9070,1,1,39,1,1,19,4,7,120.0,120.0,0,0,1,0,1,0,0,20,0,6,11,0,0.0,6,0,6,12,0,0.0,12,16.2,0.3,-0.92,0 +Student_00535,1,44,171,1,1,39,1,4,4,2,2,150.0,150.0,0,0,0,1,1,0,0,25,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,2 +Student_00536,1,43,9991,0,1,1,1,3,3,4,4,150.0,100.0,1,0,0,1,1,0,0,24,0,5,10,4,11.5,0,0,5,11,5,11.285714285714286,0,13.9,-0.3,NA,2 +Student_00537,1,39,9119,1,1,1,1,3,3,4,4,150.0,150.0,1,0,0,1,1,0,0,27,0,5,10,1,14.0,0,0,5,0,0,0.0,0,8.9,1.4,3.51,0 +Student_00538,1,17,9254,1,1,1,1,3,19,4,4,127.0,116.9,0,0,0,1,1,0,0,21,0,6,7,5,11.0,0,0,6,7,5,12.4,0,15.5,2.8,-4.06,2 +Student_00539,1,44,9003,1,1,39,1,19,38,3,9,140.0,140.0,1,0,0,1,1,0,0,21,0,6,7,6,12.857142857142858,0,0,6,6,6,13.166666666666666,0,12.4,0.5,1.79,2 +Student_00540,1,18,9773,1,3,1,1,19,1,9,9,128.0,122.1,1,0,0,1,1,0,0,19,0,6,9,4,12.5,0,0,6,6,6,11.333333333333334,0,10.8,1.4,1.74,0 +Student_00541,1,39,9500,1,1,1,1,19,19,5,5,127.0,160.0,0,0,0,1,1,0,0,28,0,7,7,7,14.528571428571428,0,0,8,11,8,15.018181818181818,0,16.2,0.3,-0.92,2 +Student_00542,1,1,9147,1,1,1,1,19,19,5,7,117.0,118.4,0,0,0,1,1,0,0,20,0,5,8,5,10.0,0,0,5,10,2,12.0,0,7.6,2.6,0.32,1 +Student_00545,1,17,9119,1,2,1,1,19,1,9,10,127.0,121.1,1,0,0,1,1,1,0,18,0,5,6,5,13.2,0,0,5,8,5,12.6,0,8.9,1.4,3.51,1 +Student_00546,1,1,9147,1,2,1,1,19,1,5,10,133.0,121.8,0,0,0,1,1,0,0,20,0,5,9,4,10.2,0,0,5,6,3,11.0,0,15.5,2.8,-4.06,1 +Student_00547,1,39,9119,1,1,40,1,1,1,5,10,120.0,146.8,0,0,0,1,1,0,0,25,2,5,6,5,14.2,0,1,5,5,2,13.5,0,16.2,0.3,-0.92,1 +Student_00548,1,1,9670,1,1,1,1,38,19,5,6,133.1,138.0,0,0,1,1,1,0,0,22,0,6,8,6,12.625,0,0,6,11,2,14.5,0,11.1,0.6,2.02,1 +Student_00549,1,1,9500,1,1,1,1,37,37,9,9,149.0,138.0,0,0,0,1,1,0,0,18,0,8,11,6,13.496666666666668,1,0,8,11,6,13.496666666666668,1,9.4,-0.8,-3.12,1 +Student_00550,1,17,9147,1,2,1,1,19,38,9,7,125.0,116.3,1,0,0,1,1,0,0,19,0,5,8,5,13.25,0,0,5,8,5,11.0,0,13.9,-0.3,0.79,2 +Student_00551,1,1,9119,1,5,1,1,12,19,4,5,126.0,122.5,1,0,0,1,1,0,0,19,0,5,12,3,12.0,0,0,5,10,3,12.0,0,12.4,0.5,1.79,0 +Student_00552,1,39,9773,1,1,19,1,19,1,7,9,133.1,115.0,1,0,1,0,1,0,0,25,0,6,10,4,13.0,0,0,6,9,4,13.75,0,12.7,3.7,-1.7,0 +Student_00553,1,43,9070,1,1,NA,1,12,12,1,10,115.0,115.0,0,0,1,1,1,0,0,21,5,11,12,9,11.77777777777778,0,3,8,11,3,13.666666666666666,0,15.5,2.8,-4.06,0 +Student_00554,1,17,9119,1,3,1,1,1,2,3,2,117.0,119.8,1,0,0,1,1,0,0,19,0,5,10,2,11.0,0,0,6,10,0,0.0,0,11.1,0.6,2.02,0 +Student_00556,1,44,9003,1,1,39,1,3,2,2,2,150.0,150.0,0,0,0,1,1,0,0,25,9,14,16,14,12.428571428571429,0,3,9,13,6,10.857142857142858,0,15.5,2.8,-4.06,0 +Student_00557,1,17,9147,1,1,1,1,NA,1,7,4,130.0,117.8,1,0,0,1,1,0,0,20,0,5,8,3,11.0,0,0,5,11,3,12.0,0,10.8,1.4,1.74,1 +Student_00558,1,1,171,1,1,1,1,37,37,9,9,161.0,144.2,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_00559,1,44,9254,1,1,39,1,39,39,194,193,130.0,130.0,1,0,1,1,1,0,0,23,0,6,12,3,11.5,0,0,6,12,3,10.666666666666666,0,8.9,1.4,3.51,1 +Student_00560,1,42,9500,1,1,1,1,1,3,9,10,111.0,128.2,1,0,0,1,1,0,0,23,0,8,8,8,12.5075,0,0,8,8,8,12.5075,0,9.4,-0.8,-3.12,2 +Student_00561,1,53,9003,1,1,42,1,3,38,141,151,140.0,135.3,0,0,0,1,1,0,0,21,7,12,18,11,12.090909090909092,0,5,12,14,11,12.0,0,8.9,1.4,3.51,2 +Student_00563,1,39,9991,0,1,1,1,1,1,4,10,139.0,140.7,0,0,0,1,1,0,0,25,0,5,13,1,NA,0,0,5,8,2,11.333333333333334,0,12.4,0.5,1.79,0 +Student_00564,1,1,9130,1,1,1,1,19,38,9,NA,132.0,130.4,1,0,0,1,1,0,0,18,0,6,6,6,13.5,0,0,6,9,5,13.2,0,8.9,1.4,3.51,2 +Student_00565,1,1,9070,1,6,6,1,1,1,9,9,119.0,123.2,1,0,0,1,1,0,0,22,0,6,6,6,14.166666666666666,0,0,6,8,6,NA,0,10.8,1.4,1.74,2 +Student_00566,1,39,9670,1,1,1,1,19,19,3,9,133.1,118.0,0,0,0,1,1,0,0,27,0,6,7,6,14.0,0,0,6,7,6,14.714285714285714,0,8.9,1.4,3.51,2 +Student_00567,1,39,9003,1,1,NA,1,4,1,2,4,133.1,120.0,0,0,0,1,1,0,0,25,0,3,4,0,0.0,0,0,3,5,0,0.0,0,16.2,0.3,-0.92,0 +Student_00568,1,17,9119,1,4,1,1,34,36,0,5,129.0,118.9,1,0,0,1,1,0,0,18,0,5,9,3,11.666666666666666,0,0,5,10,3,11.333333333333334,4,7.6,2.6,0.32,0 +Student_00569,1,17,9085,1,1,1,1,38,19,8,8,128.0,117.2,0,0,0,1,NA,0,0,20,0,5,7,5,14.6,1,0,5,5,5,14.2,0,12.7,3.7,-1.7,2 +Student_00570,1,NA,9003,1,1,1,1,3,4,2,2,120.0,120.0,0,0,0,1,1,0,0,27,0,6,10,5,13.0,0,0,6,13,5,11.5,0,16.2,0.3,-0.92,2 +Student_00572,1,1,9147,1,1,1,1,38,37,9,9,130.0,124.8,1,0,0,1,1,0,0,22,0,5,9,0,0.0,0,0,5,5,1,12.0,0,7.6,2.6,0.32,0 +Student_00573,1,17,9119,1,6,1,1,19,3,5,10,111.0,106.5,1,0,0,1,1,0,0,19,0,5,10,3,10.5,0,0,5,11,3,10.8,0,12.4,0.5,1.79,0 +Student_00574,1,1,9147,1,6,1,1,3,19,4,5,NA,116.8,0,0,0,1,1,0,0,20,0,5,14,3,12.4,0,0,5,8,5,10.833333333333334,0,13.9,-0.3,0.79,1 +Student_00575,1,43,171,1,4,1,1,19,12,9,10,117.0,109.3,0,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_00576,2,39,9085,1,1,9,1,1,1,4,4,133.1,120.0,1,0,0,0,1,0,0,29,0,5,12,0,0.0,4,0,5,8,0,0.0,1,9.4,-0.8,-3.12,0 +Student_00577,1,1,9500,1,2,1,1,3,1,9,9,149.0,137.5,0,0,0,1,1,0,0,19,0,8,8,7,13.828571428571427,0,0,8,8,7,13.828571428571427,0,12.7,3.7,-1.7,2 +Student_00579,2,1,9238,1,1,1,1,37,37,5,5,134.0,120.4,0,0,0,1,0,0,0,20,0,6,7,6,11.5,0,0,6,6,6,11.666666666666666,0,7.6,2.6,0.32,2 +Student_00581,1,39,8014,0,1,1,NA,34,5,0,1,133.1,118.5,1,0,0,1,0,0,0,31,0,6,12,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_00582,1,17,9500,1,5,NA,1,12,1,5,5,141.0,133.0,1,0,0,1,0,0,0,18,0,7,8,7,12.5375,0,0,8,9,7,12.614285714285714,0,13.9,-0.3,0.79,2 +Student_00583,1,17,9670,1,1,1,1,1,19,8,7,141.0,128.8,1,0,0,1,0,0,0,19,0,6,6,6,14.833333333333334,0,0,6,8,6,13.285714285714286,0,8.9,1.4,3.51,1 +Student_00584,1,1,9147,1,1,1,1,37,38,9,8,148.0,133.0,1,0,0,1,0,0,0,18,0,5,10,4,12.0,0,0,5,9,4,12.8,0,13.9,-0.3,0.79,2 +Student_00586,1,1,9147,1,1,1,1,1,19,3,3,143.0,133.9,0,0,0,1,0,1,0,18,0,5,5,5,15.0,0,0,5,5,5,15.2,0,12.7,3.7,-1.7,2 +Student_00587,1,17,9085,1,1,1,1,38,19,90,90,120.0,127.0,0,0,0,1,0,0,0,19,0,5,7,3,12.0,0,0,5,7,5,13.2,0,7.6,2.6,0.32,2 +Student_00589,1,1,9254,1,3,1,1,37,37,9,3,122.0,124.5,1,0,0,1,0,0,0,19,0,6,12,6,11.666666666666666,0,0,6,14,3,12.0,0,7.6,2.6,0.32,2 +Student_00590,1,1,9556,1,4,1,1,37,1,5,4,122.0,123.9,0,0,0,1,0,0,0,19,0,7,9,7,12.1625,0,0,8,8,8,13.825,0,13.9,-0.3,0.79,2 +Student_00591,1,1,9670,1,2,1,1,19,1,9,3,123.0,117.8,1,0,0,1,0,0,0,18,0,6,6,6,13.833333333333334,0,0,6,11,6,14.555555555555555,0,10.8,1.4,1.74,2 +Student_00592,1,1,9500,1,1,1,1,3,19,2,8,133.0,126.7,0,0,0,1,0,0,0,19,0,7,12,4,12.45,0,0,7,11,5,11.7,0,16.2,0.3,-0.92,1 +Student_00593,1,44,9670,1,1,39,1,37,1,9,4,110.0,110.0,0,0,0,1,0,1,0,20,2,6,9,6,12.125,0,2,6,7,6,13.571428571428571,0,11.1,0.6,2.02,2 +Student_00594,1,17,9670,1,1,1,1,1,19,4,8,155.0,134.7,1,0,0,1,0,0,0,20,0,6,8,5,13.4,0,0,6,10,4,13.0,0,12.7,3.7,-1.7,1 +Student_00596,1,39,9991,0,1,3,1,37,37,9,9,120.0,141.0,0,0,0,1,0,0,0,29,10,15,15,11,11.454545454545457,0,9,13,16,11,11.545454545454543,0,10.8,1.4,1.74,0 +Student_00597,1,17,9853,1,1,1,1,38,12,7,0,133.1,NA,0,0,0,0,0,1,0,20,0,6,10,4,12.0,0,0,6,14,3,10.0,0,7.6,2.6,0.32,0 +Student_00598,4,39,9853,1,1,1,1,37,1,9,10,143.0,140.0,0,0,1,0,0,0,0,31,0,7,8,6,12.666666666666666,0,0,7,9,5,12.6,0,8.9,1.4,3.51,0 +Student_00599,1,17,9670,1,1,1,1,19,37,7,4,149.0,134.3,0,1,0,1,0,0,0,20,0,6,7,6,12.666666666666666,0,0,6,9,6,13.77777777777778,0,10.8,1.4,1.74,2 +Student_00600,1,17,9003,1,1,1,1,38,37,9,9,133.0,125.3,1,0,0,1,0,0,0,21,12,18,22,18,11.88888888888889,1,11,13,13,13,11.461538461538462,0,15.5,2.8,-4.06,2 +Student_00601,1,7,9130,1,1,3,1,19,38,9,NA,140.0,140.0,1,0,0,1,0,0,0,23,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00602,1,17,9070,1,5,1,1,19,38,5,7,122.0,119.6,0,0,1,0,0,0,0,21,0,6,6,4,13.0,0,0,6,8,4,11.6,0,10.8,1.4,1.74,0 +Student_00603,1,7,9500,1,1,40,1,1,1,9,4,170.0,170.0,0,0,0,1,0,0,0,24,4,7,7,7,16.885714285714283,0,3,8,9,8,15.744444444444444,0,16.2,0.3,-0.92,2 +Student_00604,1,39,8014,0,1,1,1,1,1,4,4,120.0,150.5,0,0,0,1,0,0,0,27,0,6,6,6,12.5,0,1,6,6,6,12.333333333333334,0,15.5,2.8,-4.06,2 +Student_00605,1,1,9500,1,1,1,1,1,37,3,8,143.0,128.0,0,0,0,1,0,1,0,18,0,7,9,7,13.055555555555555,0,0,8,8,8,15.8125,0,13.9,-0.3,0.79,2 +Student_00607,1,17,9130,1,1,1,1,19,3,3,2,123.0,121.6,1,0,1,1,0,1,0,19,0,5,7,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00608,1,1,9500,1,6,1,1,38,19,7,7,131.0,125.3,1,0,0,1,0,1,0,19,0,8,8,7,12.355714285714283,0,0,8,8,7,12.355714285714283,0,10.8,1.4,1.74,2 +Student_00609,1,17,9085,1,1,1,1,19,38,194,193,127.0,117.6,0,0,0,1,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00612,2,1,8014,0,1,1,1,1,37,4,7,150.0,139.9,1,0,0,1,0,0,0,24,0,6,9,5,13.0,0,0,6,6,6,14.166666666666666,0,9.4,-0.8,-3.12,2 +Student_00613,1,1,9070,1,1,1,1,1,1,1,1,116.0,110.8,1,0,0,1,0,0,0,20,0,6,6,6,12.833333333333334,0,0,6,10,6,11.166666666666666,0,12.4,0.5,1.79,2 +Student_00615,1,1,9500,1,1,1,1,19,37,9,9,130.0,117.8,1,0,0,1,0,1,0,19,0,8,8,7,12.357142857142858,0,0,8,8,7,12.357142857142858,0,12.7,3.7,-1.7,2 +Student_00616,1,1,9500,1,6,1,1,1,37,9,9,144.0,127.5,1,0,0,1,0,1,0,18,0,8,8,7,13.857142857142858,0,0,8,8,7,13.857142857142858,0,12.7,3.7,-1.7,2 +Student_00618,1,17,9500,1,1,1,NA,37,37,9,8,143.0,130.6,1,0,0,1,0,0,0,20,0,7,8,7,12.847142857142858,0,0,8,10,8,13.788888888888888,0,16.2,0.3,-0.92,2 +Student_00619,1,17,9500,1,2,1,1,19,37,4,7,137.0,126.3,1,0,0,1,0,1,0,19,0,7,9,6,12.339999999999998,0,0,8,9,8,13.01875,0,11.1,0.6,2.02,2 +Student_00620,1,44,9085,1,1,39,1,3,1,2,3,140.0,140.0,1,0,0,1,0,0,0,19,0,6,10,5,12.666666666666666,0,0,6,19,4,11.75,0,12.4,0.5,1.79,1 +Student_00621,1,1,9773,1,1,1,1,3,19,4,5,133.1,105.0,1,0,0,1,0,0,0,20,0,6,6,6,13.833333333333334,0,0,6,6,6,12.5,0,12.7,3.7,-1.7,2 +Student_00623,1,17,9853,1,5,1,1,38,38,9,7,117.0,114.6,1,0,0,1,0,0,0,19,0,6,11,4,13.25,0,0,6,10,4,NA,0,9.4,-0.8,-3.12,0 +Student_00624,1,17,9500,1,1,1,1,38,37,7,5,137.0,131.0,1,0,0,1,0,1,0,18,0,8,8,8,13.73125,0,0,8,8,8,13.73125,0,9.4,-0.8,-3.12,2 +Student_00625,1,17,9070,1,4,1,1,38,37,9,9,116.0,109.0,0,0,0,1,0,1,0,23,0,6,6,6,13.333333333333334,0,0,6,8,3,12.666666666666666,0,11.1,0.6,2.02,0 +Student_00627,1,44,8014,0,1,39,1,37,38,6,6,130.0,130.0,1,0,0,1,0,0,0,23,5,9,10,9,10.88888888888889,0,3,8,10,6,11.333333333333334,0,11.1,0.6,2.02,2 +Student_00628,1,1,9500,1,3,1,1,19,37,9,7,106.0,109.5,1,0,0,1,0,0,0,19,0,7,8,7,13.025,0,0,8,9,8,13.811111111111112,0,13.9,-0.3,0.79,2 +Student_00629,1,17,9773,1,2,1,1,1,38,5,6,125.0,115.9,1,0,0,1,0,0,0,18,0,6,6,6,13.0,0,0,6,6,6,14.166666666666666,0,12.4,0.5,1.79,2 +Student_00631,1,39,9500,1,1,1,1,19,37,9,9,133.1,120.0,0,0,0,1,0,1,0,25,0,8,8,7,12.042857142857144,0,0,8,8,7,12.042857142857144,0,12.7,3.7,-1.7,2 +Student_00632,1,1,9853,1,2,1,1,1,38,4,9,117.0,109.7,1,0,0,1,0,0,0,19,0,6,9,5,12.2,0,0,6,10,4,13.0,0,9.4,-0.8,-3.12,1 +Student_00633,1,1,9500,1,1,1,1,1,19,5,7,136.0,136.4,0,0,0,1,0,1,0,19,0,7,8,7,12.8375,0,0,8,8,8,15.5,0,13.9,-0.3,0.79,2 +Student_00634,1,39,9556,1,1,1,1,38,38,191,193,120.0,120.0,0,0,1,1,0,1,0,24,0,7,13,7,11.0,0,0,8,13,7,11.7,0,12.7,3.7,-1.7,2 +Student_00635,1,1,9670,1,1,1,1,37,37,9,7,135.0,132.6,1,0,0,1,0,1,0,NA,0,6,7,6,13.5,0,0,6,9,5,14.0,0,8.9,1.4,3.51,2 +Student_00637,1,1,9500,1,5,1,1,37,37,9,9,147.0,134.3,0,0,0,1,0,1,0,18,0,8,12,7,12.62857142857143,0,0,8,12,7,12.62857142857143,0,12.7,3.7,-1.7,2 +Student_00639,1,17,9238,1,3,1,1,1,1,4,5,121.0,117.2,0,0,0,1,0,0,0,19,0,6,11,5,11.2,0,0,6,13,5,11.6,0,15.5,2.8,-4.06,2 +Student_00642,1,1,9147,1,6,1,1,37,37,9,9,128.0,116.5,0,0,0,1,0,0,0,18,0,5,9,3,11.666666666666666,0,0,5,15,2,11.0,0,7.6,2.6,0.32,1 +Student_00643,1,1,9147,1,1,1,1,37,38,4,9,129.0,121.0,1,0,0,1,0,0,0,18,0,5,8,2,10.5,0,0,5,7,3,12.333333333333334,0,7.6,2.6,0.32,1 +Student_00644,1,1,9500,1,3,1,1,37,38,7,7,143.0,133.8,1,0,0,1,0,0,0,18,0,8,8,8,14.26875,0,0,8,8,8,14.26875,0,9.4,-0.8,-3.12,1 +Student_00645,1,1,9773,1,2,1,1,38,38,7,7,108.0,115.0,1,0,1,0,0,0,0,20,0,6,0,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_00646,NA,1,9147,1,1,NA,1,19,37,9,9,130.0,131.8,1,0,0,1,0,1,0,19,0,5,8,2,10.5,0,0,5,11,3,13.333333333333334,0,7.6,2.6,0.32,1 +Student_00647,1,1,9238,1,1,1,1,37,1,3,5,135.0,121.0,0,0,0,1,0,0,0,21,0,6,11,5,11.2,0,0,6,15,1,10.0,0,7.6,2.6,0.32,1 +Student_00648,2,39,9991,0,1,3,1,19,19,9,7,140.0,152.4,0,0,0,1,0,0,0,26,0,5,5,5,12.0,0,0,5,6,5,14.833333333333334,0,10.8,1.4,1.74,2 +Student_00649,1,43,9556,1,2,1,1,1,19,4,3,120.0,110.2,0,0,0,1,0,0,0,27,0,7,9,7,12.228571428571428,0,1,8,10,8,13.2125,0,10.8,1.4,1.74,2 +Student_00650,1,1,9670,1,1,1,1,1,38,5,1,117.0,113.5,1,0,0,1,0,0,0,20,0,5,6,4,11.5,0,0,5,5,4,10.75,0,9.4,-0.8,-3.12,2 +Student_00651,1,17,9238,1,1,1,1,19,1,5,0,151.0,144.4,1,0,0,1,0,0,0,18,0,6,8,6,15.375,0,0,6,7,6,16.428571428571427,0,16.2,0.3,-0.92,2 +Student_00652,1,53,9085,1,1,42,1,1,1,5,5,140.0,143.3,1,0,0,0,0,0,0,23,7,12,19,9,13.666666666666666,0,4,9,15,6,13.5,0,8.9,1.4,3.51,1 +Student_00653,1,39,9500,1,1,19,1,1,5,4,3,133.1,100.0,0,0,0,1,0,0,0,24,0,8,11,7,12.614285714285714,0,0,8,11,7,12.614285714285714,0,12.7,3.7,-1.7,2 +Student_00655,1,1,9773,1,1,1,1,19,38,3,5,125.0,115.9,0,0,0,1,0,0,0,19,0,6,13,4,11.75,0,0,6,10,4,11.0,0,10.8,1.4,1.74,2 +Student_00656,1,1,9238,1,4,1,1,19,38,9,6,125.0,114.9,1,0,1,1,0,1,0,19,0,6,9,5,11.4,0,0,6,9,3,10.0,0,8.9,1.4,3.51,1 +Student_00658,1,51,8014,0,1,1,1,1,38,5,7,121.0,112.3,0,0,0,1,0,0,0,22,14,16,16,13,10.923076923076923,0,13,13,13,11,11.454545454545457,0,16.2,0.3,-0.92,2 +Student_00659,1,43,9070,1,1,1,1,1,19,5,10,141.0,127.0,0,0,0,1,0,0,0,20,0,6,6,5,12.4,0,0,6,9,5,12.4,0,12.7,3.7,-1.7,2 +Student_00661,1,44,9003,1,1,39,1,1,3,4,2,180.0,180.0,0,0,0,1,0,0,0,NA,0,6,6,6,15.833333333333334,0,0,6,8,6,15.5,0,15.5,2.8,-4.06,2 +Student_00662,1,1,9500,1,1,1,1,19,19,194,193,117.0,117.4,1,0,0,1,0,0,0,19,0,7,12,5,11.8,0,0,7,9,6,11.708333333333334,0,11.1,0.6,2.02,1 +Student_00663,1,17,9773,1,4,1,1,1,19,4,1,127.0,115.8,1,0,0,1,0,0,0,18,0,6,7,6,12.571428571428571,0,0,6,6,6,13.666666666666666,0,13.9,-0.3,0.79,2 +Student_00664,1,1,9670,1,3,1,1,37,37,0,0,126.0,136.5,1,0,0,1,0,0,0,18,0,5,7,3,12.0,0,0,5,7,4,13.25,1,7.6,2.6,0.32,2 +Student_00665,1,17,9500,1,3,1,1,3,3,9,7,143.0,129.0,1,0,0,1,1,0,0,19,0,7,8,7,13.3625,0,0,8,9,8,14.444444444444445,0,13.9,-0.3,0.79,2 +Student_00666,1,1,9085,1,1,1,13,3,3,6,6,144.0,137.6,1,0,0,1,0,1,1,19,0,5,6,5,15.4,0,0,5,5,5,16.0,0,10.8,1.4,1.74,2 +Student_00667,1,17,9773,1,2,1,1,37,38,5,5,126.0,129.5,1,0,1,0,0,0,0,18,0,6,9,5,12.2,0,0,6,9,4,11.75,0,10.8,1.4,1.74,0 +Student_00668,1,51,9238,1,1,39,1,38,38,5,7,140.0,129.1,1,0,0,1,0,1,0,20,6,11,11,11,12.818181818181818,0,6,11,11,11,13.545454545454543,0,12.4,0.5,1.79,2 +Student_00669,1,17,9500,1,5,1,1,1,19,4,8,148.0,130.2,1,0,0,1,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00670,1,42,9500,1,1,1,1,19,37,5,7,100.0,134.3,1,0,0,1,0,0,0,28,12,17,21,17,13.394736842105264,0,11,17,19,17,13.554736842105264,0,16.2,0.3,-0.92,2 +Student_00671,1,1,9238,1,1,1,1,37,1,9,9,151.0,138.4,1,0,0,1,0,1,0,20,0,6,8,6,NA,0,0,6,8,6,11.0,0,12.7,3.7,-1.7,2 +Student_00672,1,42,8014,0,1,1,1,NA,38,90,7,120.0,120.0,1,0,0,1,0,0,0,30,9,11,19,9,13.444444444444445,1,5,7,7,7,14.714285714285714,0,7.6,2.6,0.32,0 +Student_00673,1,1,9500,1,4,1,1,1,19,9,7,135.0,123.5,1,0,0,1,0,1,0,19,0,7,8,7,12.285714285714286,0,0,8,10,8,11.7375,0,12.4,0.5,1.79,2 +Student_00675,1,1,9254,1,1,1,1,38,38,5,8,116.0,110.8,1,0,0,1,0,0,0,18,0,6,8,6,12.166666666666666,0,0,6,6,6,13.5,0,11.1,0.6,2.02,2 +Student_00676,1,17,9853,1,1,1,1,37,37,9,9,147.0,142.8,1,0,0,1,0,0,0,23,0,6,11,2,10.0,0,0,6,15,2,11.0,0,7.6,2.6,0.32,0 +Student_00678,1,1,9853,1,1,1,1,37,19,7,7,133.0,126.7,1,0,0,1,0,0,0,18,0,6,9,5,11.833333333333334,0,0,6,6,4,12.0,0,15.5,2.8,-4.06,1 +Student_00679,2,39,9773,1,1,19,1,37,37,0,0,100.0,163.5,0,0,1,0,1,0,0,50,0,6,7,1,15.0,0,0,5,12,0,0.0,0,10.8,1.4,1.74,0 +Student_00680,1,1,171,1,1,1,41,3,3,2,5,151.0,161.9,1,0,0,1,0,1,1,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_00681,1,17,9254,1,2,1,41,19,38,9,9,124.0,123.3,1,0,0,1,0,0,1,22,0,6,7,6,10.833333333333334,0,0,6,6,6,10.666666666666666,0,13.9,-0.3,0.79,2 +Student_00682,1,44,9238,1,1,39,41,1,1,4,6,140.0,137.5,0,0,1,1,0,1,1,23,3,6,7,6,13.142857142857142,0,2,6,6,6,14.0,0,12.4,0.5,1.79,2 +Student_00683,1,18,9085,1,4,1,1,1,1,4,5,170.0,166.6,0,0,1,0,0,1,0,20,2,5,8,5,14.4,1,0,5,6,5,14.0,0,12.7,3.7,-1.7,0 +Student_00684,4,39,9238,1,1,19,1,37,37,9,10,133.1,103.5,0,0,0,0,0,0,0,44,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_00685,4,39,9003,1,1,19,1,37,37,9,9,133.1,110.0,0,0,0,1,1,0,0,49,6,12,17,7,12.0,0,3,12,19,9,11.22222222222222,0,15.5,2.8,-4.06,2 +Student_00686,2,43,9991,0,1,1,1,37,37,9,9,100.0,128.2,0,0,0,1,1,0,0,46,6,10,13,9,12.2,0,4,10,12,10,12.8,0,7.6,2.6,0.32,2 +Student_00687,1,39,9085,1,1,39,1,37,37,1,9,120.0,137.7,1,0,0,0,1,0,0,41,3,3,3,3,12.333333333333334,0,2,2,2,2,11.0,0,12.4,0.5,1.79,0 +Student_00688,1,17,9500,1,3,1,1,38,19,9,8,133.0,128.8,1,0,0,1,1,0,0,18,0,7,8,7,NA,0,0,8,9,8,12.48125,0,13.9,-0.3,0.79,2 +Student_00689,3,39,9991,0,1,1,1,37,1,9,2,120.0,170.0,0,0,0,1,1,0,0,43,0,5,5,5,11.8,0,0,5,6,5,14.0,0,9.4,-0.8,-3.12,2 +Student_00690,4,39,9147,1,2,19,1,37,37,9,7,133.1,116.4,0,0,1,0,1,0,0,70,0,5,5,0,0.0,0,0,5,9,0,0.0,0,10.8,1.4,1.74,0 +Student_00692,2,43,9003,1,1,1,1,37,37,9,7,133.1,136.0,0,0,0,1,1,0,0,41,18,19,19,19,12.68421052631579,0,12,13,13,13,12.384615384615383,0,15.5,2.8,-4.06,2 +Student_00694,1,39,33,1,1,1,41,38,37,9,8,100.0,100.0,0,0,1,0,1,0,1,35,0,7,18,3,11.25,0,0,7,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_00695,2,39,9130,1,1,19,1,2,1,2,9,NA,157.0,1,0,0,1,1,0,0,44,1,5,13,4,14.0,3,1,5,9,4,15.5,2,10.8,1.4,1.74,2 +Student_00696,1,1,9147,1,1,1,1,3,1,5,5,143.0,152.1,1,0,1,1,1,0,0,18,0,5,15,4,13.333333333333334,0,0,5,6,2,13.5,0,13.9,-0.3,0.79,0 +Student_00697,2,1,8014,0,1,1,1,37,37,0,0,165.0,162.9,1,0,0,1,1,0,0,45,0,6,7,6,13.666666666666666,0,0,6,6,6,13.666666666666666,0,7.6,2.6,0.32,2 +Student_00698,1,1,9254,1,1,1,1,3,1,2,1,154.0,137.2,0,0,0,1,1,0,0,20,0,6,12,3,10.0,0,0,6,9,5,10.8,0,15.5,2.8,-4.06,1 +Student_00699,1,44,9003,1,1,39,1,1,38,9,1,140.0,140.0,1,0,0,1,1,0,0,22,0,6,12,5,12.6,0,0,6,11,6,11.714285714285714,0,12.4,0.5,1.79,2 +Student_00700,1,43,9119,1,1,1,1,37,38,5,7,140.0,146.5,0,0,0,1,1,0,0,39,0,5,10,3,17.333333333333332,0,0,5,11,1,17.0,0,13.9,-0.3,0.79,0 +Student_00701,1,44,9085,1,1,39,1,2,2,6,6,130.0,130.0,0,0,0,0,1,0,0,20,2,6,10,5,13.2,0,1,6,21,3,12.0,0,12.4,0.5,1.79,1 +Student_00702,2,39,9147,1,1,NA,1,37,19,9,3,133.1,128.0,0,0,0,1,1,0,0,49,0,5,9,3,14.0,0,0,5,8,3,13.666666666666666,0,NA,1.4,3.51,0 +Student_00703,1,7,9556,1,1,4,1,5,5,2,2,190.0,190.0,1,0,0,1,1,0,0,43,4,4,4,4,13.875,0,1,1,1,1,12.5,0,11.1,0.6,2.02,0 +Student_00704,2,39,9991,0,1,1,1,37,37,9,9,120.0,133.2,1,0,0,1,1,0,0,32,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00705,1,39,9238,1,1,12,1,37,37,9,9,100.0,124.3,0,0,0,1,1,0,0,47,3,9,9,9,13.11111111111111,0,3,7,7,7,14.857142857142858,0,10.8,1.4,1.74,2 +Student_00706,5,39,9991,0,1,1,1,37,37,9,9,120.0,138.1,0,0,0,1,1,1,0,37,0,5,8,5,13.0,0,0,5,11,4,13.333333333333334,2,16.2,0.3,-0.92,0 +Student_00708,2,39,9003,1,1,1,1,37,37,9,6,150.0,140.0,0,0,0,1,1,0,0,60,17,18,18,18,14.11111111111111,0,11,13,13,13,14.23076923076923,0,15.5,2.8,-4.06,2 +Student_00709,2,39,9254,1,1,1,1,1,19,9,9,120.0,148.3,0,0,0,1,1,0,0,47,6,11,11,11,14.727272727272728,0,6,9,9,9,15.77777777777778,0,10.8,1.4,1.74,2 +Student_00710,1,39,8014,0,1,1,1,37,11,9,7,133.1,96.0,0,0,1,0,1,0,0,50,0,6,6,0,0.0,0,0,5,6,0,NA,0,12.4,0.5,1.79,0 +Student_00712,1,39,9119,1,1,1,1,37,37,9,8,100.0,160.0,0,0,1,0,1,0,0,45,0,5,5,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_00713,NA,39,9085,1,1,1,1,37,37,90,90,133.1,110.3,0,0,0,1,1,0,0,33,0,5,7,4,13.5,0,0,5,6,5,11.6,0,7.6,2.6,0.32,2 +Student_00714,1,1,9500,1,1,1,1,3,3,2,2,143.0,129.0,0,0,0,1,1,0,0,18,0,8,8,7,13.105714285714283,0,0,8,8,7,13.105714285714283,0,10.8,1.4,1.74,2 +Student_00715,2,39,9085,1,1,1,1,37,37,6,6,120.0,150.0,0,0,0,1,1,0,0,43,0,5,8,5,13.5,2,0,5,5,5,14.4,0,9.4,-0.8,-3.12,2 +Student_00717,1,39,9130,1,1,9,1,34,36,0,90,133.1,107.5,0,0,0,1,1,0,0,29,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00718,4,39,9670,1,1,1,1,2,1,3,9,140.0,170.0,0,0,1,0,1,0,0,53,0,6,11,3,14.333333333333334,0,0,6,6,0,0.0,0,12.7,3.7,-1.7,0 +Student_00719,2,42,9991,0,1,6,1,37,37,9,9,123.0,123.0,0,0,0,1,1,0,0,37,0,5,10,5,15.8,0,0,5,5,5,17.6,0,9.4,-0.8,-3.12,1 +Student_00722,1,1,9254,1,1,1,1,19,1,3,7,115.0,113.6,0,0,0,1,1,0,0,23,0,6,10,6,13.0,0,0,6,9,6,12.0,0,11.1,0.6,2.02,1 +Student_00724,1,39,8014,0,1,1,1,37,37,90,5,140.0,115.5,0,0,0,0,1,0,0,33,0,6,6,1,11.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_00725,1,7,9130,1,3,3,1,37,26,90,10,130.0,130.0,0,0,0,0,1,0,0,41,0,5,9,0,0.0,4,0,5,9,0,0.0,3,10.8,1.4,1.74,0 +Student_00727,1,51,9670,1,1,1,1,12,5,3,3,140.0,126.6,0,0,0,1,1,0,0,19,2,6,7,6,14.428571428571429,0,1,7,8,7,14.375,0,11.1,0.6,2.02,2 +Student_00729,1,1,171,1,2,1,41,19,1,4,7,131.0,131.4,1,0,0,1,1,0,1,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_00730,1,43,9670,1,1,1,1,3,2,2,2,141.0,133.3,1,0,0,1,1,0,0,18,0,6,13,4,13.75,0,0,6,8,5,11.2,0,13.9,-0.3,0.79,1 +Student_00731,1,1,9773,1,1,1,1,19,37,9,9,120.0,118.3,0,0,1,0,1,1,0,18,0,6,11,5,12.166666666666666,0,0,6,15,3,12.0,0,13.9,-0.3,0.79,0 +Student_00732,1,44,9003,1,1,39,1,2,1,4,6,140.0,140.0,0,0,0,1,1,0,0,21,0,6,12,5,12.142857142857142,0,0,6,11,5,11.666666666666666,0,13.9,-0.3,0.79,2 +Student_00733,1,1,9254,1,1,1,1,1,19,6,6,132.0,124.7,1,0,0,1,1,0,0,21,0,6,9,6,12.0,0,0,6,8,5,11.6,0,13.9,-0.3,0.79,2 +Student_00734,2,39,9147,1,2,1,1,19,37,4,7,130.0,140.0,0,0,0,1,1,0,0,34,0,5,10,3,11.666666666666666,1,0,5,7,4,12.75,0,9.4,-0.8,-3.12,2 +Student_00735,4,39,9130,1,1,1,1,37,37,6,7,140.0,150.0,1,0,0,1,1,0,0,34,0,6,9,0,0.0,0,0,6,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_00737,1,43,9773,1,1,1,1,3,37,3,7,140.0,116.9,0,0,0,1,1,0,0,32,6,11,15,7,11.285714285714286,0,5,7,10,6,12.333333333333334,0,13.9,-0.3,0.79,1 +Student_00738,1,17,9254,1,2,1,1,37,37,5,7,130.0,123.4,1,0,0,1,1,0,0,30,0,6,17,2,10.0,0,0,6,15,3,11.333333333333334,0,7.6,2.6,0.32,0 +Student_00740,1,51,9773,1,1,1,1,1,19,8,8,158.0,117.1,1,0,0,1,1,0,0,20,1,7,7,6,13.833333333333334,0,1,6,7,5,13.0,0,8.9,1.4,3.51,0 +Student_00741,1,1,9070,1,1,1,1,19,19,9,7,124.0,113.9,1,0,0,1,1,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00742,1,1,9254,1,1,1,1,3,3,2,2,136.0,128.7,0,0,0,1,1,0,0,19,0,6,7,6,14.428571428571429,0,0,6,6,6,12.5,0,8.9,1.4,3.51,2 +Student_00743,1,17,9500,1,3,1,1,3,3,3,3,142.0,132.9,1,0,0,1,1,0,0,18,0,7,8,5,14.2,0,0,7,9,6,12.4,0,12.4,0.5,1.79,0 +Student_00744,1,39,9991,0,1,1,1,1,19,4,8,150.0,123.0,0,0,0,1,1,0,0,27,0,5,8,4,11.5,0,0,5,9,3,10.333333333333334,0,12.7,3.7,-1.7,0 +Student_00745,1,39,NA,1,1,12,1,1,1,9,9,120.0,129.8,1,0,0,1,1,0,0,52,0,6,7,5,13.0,0,0,6,6,6,15.0,0,9.4,-0.8,-3.12,2 +Student_00746,2,43,9003,1,1,1,1,1,1,4,5,149.0,156.1,1,0,0,0,1,0,0,29,0,6,6,0,0.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_00748,1,43,9085,1,1,1,25,38,38,9,6,110.0,117.2,1,0,0,1,1,0,1,28,13,18,45,18,12.5,12,10,13,26,12,11.428571428571429,6,15.5,2.8,-4.06,2 +Student_00749,1,39,9670,1,1,6,1,1,1,90,3,133.1,107.0,1,0,0,1,1,0,0,30,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00751,1,1,9670,1,2,1,1,38,37,5,5,130.0,123.4,1,0,0,1,0,0,0,21,0,5,5,4,11.75,0,0,5,5,3,13.333333333333334,0,9.4,-0.8,-3.12,2 +Student_00752,1,1,9070,1,1,1,1,37,37,9,9,141.0,126.7,1,0,1,1,0,1,0,20,0,6,9,6,13.333333333333334,0,0,6,10,6,14.666666666666666,0,12.7,3.7,-1.7,2 +Student_00753,1,42,9500,1,1,1,1,37,37,3,3,123.0,123.0,1,0,0,1,0,1,0,21,0,8,8,8,13.105,0,0,8,8,8,13.105,0,9.4,-0.8,-3.12,2 +Student_00754,2,39,9991,0,1,19,1,19,37,7,9,133.1,137.2,0,0,1,0,0,0,0,32,0,5,5,0,0.0,0,0,5,6,0,0.0,0,10.8,1.4,1.74,0 +Student_00755,1,1,9070,1,3,1,1,37,37,9,9,122.0,125.9,1,0,0,1,1,1,0,20,0,6,6,6,15.5,0,0,6,7,6,12.166666666666666,0,12.4,0.5,1.79,2 +Student_00756,1,1,171,1,4,1,1,1,19,4,5,132.0,138.0,1,0,1,0,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00757,1,15,9670,1,1,1,41,1,1,9,5,133.1,128.2,0,0,1,NA,1,0,1,18,0,6,6,4,11.25,0,0,6,7,3,12.333333333333334,0,8.9,1.4,3.51,0 +Student_00758,1,43,9991,0,1,1,1,37,2,9,4,130.0,126.5,1,0,0,0,1,0,0,23,10,15,24,12,11.0,0,10,14,21,11,11.363636363636363,1,7.6,2.6,0.32,0 +Student_00759,1,1,9254,1,1,1,1,1,1,3,3,111.0,112.4,1,0,0,1,1,0,0,20,0,6,10,6,12.333333333333334,0,0,6,9,4,13.0,0,12.4,0.5,1.79,2 +Student_00761,1,17,9003,1,1,1,1,3,3,2,2,125.0,100.0,0,0,0,1,1,0,0,27,16,18,19,18,12.22222222222222,0,9,12,15,12,12.384615384615383,0,15.5,2.8,-4.06,2 +Student_00762,1,5,171,1,1,1,1,3,19,1,10,137.0,144.7,1,0,0,1,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,1 +Student_00764,1,15,9147,1,1,1,21,1,3,192,3,133.1,100.0,0,0,1,1,1,0,1,40,0,5,10,1,11.0,0,0,5,10,1,10.0,0,11.1,0.6,2.02,1 +Student_00765,2,44,8014,0,1,39,NA,1,1,5,5,150.0,154.0,0,0,0,1,1,0,0,37,12,16,17,16,14.125,0,6,11,14,10,13.0,0,12.4,0.5,1.79,2 +Student_00767,1,44,9130,1,1,39,1,1,1,4,4,150.0,150.0,1,0,0,1,0,0,0,20,0,5,7,4,12.0,1,0,5,6,4,12.4,0,10.8,1.4,1.74,1 +Student_00768,NA,7,9991,0,1,40,1,1,37,4,1,133.1,100.0,0,0,0,1,0,0,0,26,8,9,11,9,12.333333333333334,0,4,7,7,7,12.571428571428571,0,12.4,0.5,1.79,2 +Student_00769,2,39,8014,0,1,1,1,37,37,9,7,133.1,162.5,0,0,0,1,1,0,0,54,4,9,9,9,14.333333333333334,0,2,7,7,7,13.857142857142858,0,8.9,1.4,3.51,2 +Student_00770,1,17,9670,1,5,1,1,19,19,5,5,132.0,134.1,1,0,0,1,1,0,0,21,0,6,6,6,15.166666666666666,0,0,6,9,6,14.0,0,10.8,1.4,1.74,2 +Student_00772,1,17,9773,1,6,1,1,1,19,5,5,126.0,119.0,1,0,0,1,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00773,1,1,9500,1,3,1,NA,1,19,4,9,136.0,131.1,1,0,0,1,0,0,0,19,0,7,9,6,13.411428571428573,0,0,8,12,7,13.294444444444444,0,15.5,2.8,-4.06,1 +Student_00774,1,1,9238,1,2,1,1,38,1,4,10,129.0,129.4,1,0,0,1,0,0,0,18,0,6,7,6,12.333333333333334,0,0,6,7,6,12.166666666666666,0,9.4,-0.8,-3.12,2 +Student_00775,1,1,9085,1,1,1,1,3,1,2,8,126.0,123.9,1,0,0,1,0,0,0,19,0,6,13,4,11.8,0,0,6,18,4,12.2,0,12.4,0.5,1.79,1 +Student_00776,1,44,9085,1,1,39,1,1,1,4,7,140.0,140.0,1,0,1,1,0,0,0,22,2,6,9,6,12.0,0,1,6,12,3,12.0,0,13.9,-0.3,0.79,0 +Student_00777,1,43,9085,1,1,1,1,2,1,4,4,162.0,162.0,0,0,0,1,0,0,0,19,0,6,7,6,15.0,0,0,6,8,6,15.625,0,12.4,0.5,1.79,2 +Student_00778,1,1,171,1,1,1,1,3,2,4,2,148.0,131.6,1,0,0,1,0,0,0,21,6,12,12,8,13.875,0,4,11,13,9,12.7,1,8.9,1.4,3.51,0 +Student_00779,1,17,9853,1,1,1,1,3,3,132,132,119.0,110.6,0,0,0,1,0,0,0,20,0,7,9,6,11.833333333333334,0,0,7,7,6,14.333333333333334,0,11.1,0.6,2.02,1 +Student_00780,1,17,9773,1,3,1,1,1,19,5,5,123.0,117.4,1,0,0,1,0,1,0,18,0,6,6,6,12.5,0,0,6,6,6,13.833333333333334,0,16.2,0.3,-0.92,2 +Student_00782,1,17,9670,1,1,1,1,1,1,5,4,113.0,106.7,1,0,1,1,0,0,0,20,0,6,10,2,11.666666666666666,0,0,6,10,4,10.5,0,15.5,2.8,-4.06,0 +Student_00783,1,1,9500,1,1,1,1,19,37,3,8,152.0,156.9,0,0,0,1,0,1,0,18,0,7,10,7,14.668,0,0,8,8,8,14.63375,0,15.5,2.8,-4.06,2 +Student_00784,1,1,9500,1,3,1,1,3,3,1,3,154.0,129.0,1,0,0,1,0,0,0,18,0,8,9,6,13.345,2,0,8,9,6,13.345,2,9.4,-0.8,-3.12,1 +Student_00785,1,1,9773,1,2,1,1,1,34,9,9,130.0,124.8,1,0,0,1,0,1,0,20,0,6,7,5,12.8,0,0,6,6,6,12.333333333333334,0,12.4,0.5,1.79,2 +Student_00788,1,1,9500,1,1,1,1,3,1,4,5,148.0,132.8,0,0,0,1,0,0,0,18,0,8,8,7,14.537142857142856,0,0,8,8,7,14.537142857142856,0,10.8,1.4,1.74,2 +Student_00789,1,5,9085,1,3,1,1,37,37,0,90,143.0,159.1,0,0,1,1,0,1,0,18,0,5,5,5,14.4,0,0,5,5,5,14.0,0,7.6,2.6,0.32,0 +Student_00790,1,17,171,1,3,1,1,19,1,5,4,147.0,137.6,1,0,0,1,0,1,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_00791,1,17,9773,1,1,1,1,1,19,9,9,138.0,124.0,0,0,0,1,0,1,0,19,0,6,6,6,13.166666666666666,0,0,6,6,6,13.833333333333334,0,11.1,0.6,2.02,2 +Student_00792,1,39,9500,1,1,1,1,3,3,2,2,120.0,149.0,0,0,0,0,1,0,0,36,0,6,15,2,11.5,0,0,7,9,0,0.0,0,15.5,2.8,-4.06,0 +Student_00793,NA,17,9238,1,1,1,1,1,40,9,2,145.0,129.6,0,0,0,1,0,1,0,19,0,6,7,6,11.333333333333334,0,0,6,7,6,12.428571428571429,0,11.1,0.6,2.02,2 +Student_00794,1,17,9238,1,3,1,1,3,1,2,5,118.0,110.0,1,0,0,1,0,0,0,18,0,6,6,6,12.0,0,0,6,6,5,13.6,0,8.9,1.4,3.51,2 +Student_00796,1,1,9773,1,3,1,1,38,38,5,8,135.0,133.3,1,0,0,1,0,1,0,18,0,6,6,6,14.833333333333334,0,0,6,6,6,14.166666666666666,0,8.9,1.4,3.51,2 +Student_00798,1,18,9500,1,3,1,1,1,1,4,8,145.0,133.6,1,0,0,1,0,0,0,18,0,7,8,7,13.087142857142856,0,0,8,8,8,12.95,0,11.1,0.6,2.02,2 +Student_00799,1,1,9130,1,1,1,1,1,37,9,9,133.0,123.2,1,0,0,1,0,1,0,19,0,6,8,6,13.333333333333334,0,0,6,7,6,13.666666666666666,0,8.9,1.4,3.51,2 +Student_00800,1,1,9853,1,1,1,1,3,1,3,7,127.0,137.2,1,0,0,1,0,0,0,18,0,6,7,6,12.166666666666666,0,0,6,10,4,12.75,0,10.8,1.4,1.74,1 +Student_00801,1,53,9070,1,1,42,1,40,19,3,5,130.0,130.0,1,0,0,0,0,1,0,22,0,6,8,6,11.0,0,0,6,10,4,12.0,0,8.9,1.4,3.51,1 +Student_00803,1,17,9147,1,4,1,NA,19,19,5,5,125.0,118.0,1,0,0,1,0,0,0,19,0,5,7,5,13.6,0,0,5,6,5,12.2,0,8.9,1.4,3.51,2 +Student_00806,1,17,9147,1,2,1,1,19,1,9,3,118.0,113.5,1,0,1,1,0,0,0,20,0,5,10,2,11.5,0,0,5,8,3,10.0,0,11.1,0.6,2.02,1 +Student_00807,1,17,9070,1,3,1,NA,1,38,3,5,142.0,146.9,1,0,0,1,0,1,0,18,0,6,6,6,13.0,0,0,6,6,6,12.166666666666666,0,16.2,0.3,-0.92,2 +Student_00809,1,1,9773,1,4,1,1,1,3,4,7,143.0,129.7,1,0,0,1,0,0,0,20,0,4,4,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_00810,1,1,9070,1,5,1,1,3,1,9,3,123.0,121.3,1,0,0,1,0,0,0,20,0,6,6,6,11.166666666666666,0,0,6,9,6,11.5,0,12.4,0.5,1.79,1 +Student_00811,1,1,9238,1,1,1,1,1,1,9,4,115.0,109.1,1,0,1,0,0,1,0,22,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00812,1,17,9853,1,2,1,1,19,38,5,7,112.0,107.1,1,0,0,1,0,1,0,18,0,7,8,7,12.142857142857142,0,0,7,9,6,13.666666666666666,0,11.1,0.6,2.02,2 +Student_00813,1,17,9500,1,1,1,1,19,38,9,9,135.0,129.2,0,0,0,1,0,1,0,18,0,7,7,7,14.145714285714286,0,0,8,9,8,13.627777777777778,0,11.1,0.6,2.02,2 +Student_00814,1,1,9500,1,1,1,1,3,4,3,3,162.0,154.1,0,0,0,1,0,0,0,18,0,7,7,7,14.45,0,0,8,9,8,14.144444444444444,0,11.1,0.6,2.02,2 +Student_00815,1,1,9853,1,1,1,1,19,3,4,4,143.0,147.2,0,0,0,1,0,0,0,18,0,7,7,7,15.714285714285714,0,0,7,7,7,15.0,0,11.1,0.6,2.02,2 +Student_00816,1,51,9147,1,1,1,1,1,1,4,4,130.0,120.0,0,0,0,1,0,0,0,21,0,5,9,5,12.8,0,0,5,11,3,12.666666666666666,0,11.1,0.6,2.02,1 +Student_00818,1,16,9070,1,1,1,1,1,1,4,4,125.0,120.8,1,0,0,1,0,0,0,18,0,6,6,6,14.5,0,0,6,6,6,12.833333333333334,0,12.4,0.5,1.79,2 +Student_00820,1,1,8014,0,1,1,1,34,37,9,NA,123.0,121.3,1,0,0,1,0,0,0,25,0,6,6,6,12.833333333333334,0,0,6,6,6,12.833333333333334,0,7.6,2.6,0.32,2 +Student_00821,1,1,9147,1,1,1,1,19,19,9,9,142.0,127.0,1,0,0,1,0,1,0,18,0,5,10,5,12.0,0,0,5,8,4,11.6,0,13.9,-0.3,0.79,2 +Student_00823,1,1,9085,1,1,1,6,1,19,4,7,140.0,131.6,1,0,0,1,0,0,1,20,0,7,9,6,14.714285714285714,0,1,7,16,6,13.2,0,12.4,0.5,1.79,1 +Student_00824,1,1,9238,1,2,1,1,19,19,9,9,133.1,106.0,1,0,0,1,0,1,0,20,0,6,7,6,12.571428571428571,0,0,6,7,6,13.285714285714286,0,12.4,0.5,NA,2 +Student_00825,1,18,9773,1,4,1,1,1,1,9,9,114.0,111.6,1,0,0,1,0,1,0,21,0,6,6,6,12.5,0,0,6,6,6,11.5,0,11.1,0.6,2.02,2 +Student_00829,1,1,9500,1,4,1,1,19,19,4,5,148.0,137.0,1,0,0,1,0,0,0,18,0,8,8,8,14.25,0,0,8,8,8,14.25,0,9.4,-0.8,-3.12,2 +Student_00830,1,43,9670,1,1,1,1,3,19,3,5,139.0,120.8,0,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00831,1,17,9254,1,1,1,1,39,3,3,3,136.0,128.7,1,0,0,1,0,0,0,20,0,6,8,6,11.666666666666666,0,0,6,10,6,11.0,0,13.9,-0.3,0.79,0 +Student_00832,1,39,9238,1,1,9,1,34,34,0,0,133.1,118.0,0,0,0,1,0,0,0,47,0,6,12,0,0.0,0,0,5,10,0,0.0,0,7.6,2.6,0.32,0 +Student_00833,1,43,9130,1,1,1,6,1,3,9,2,120.0,120.0,0,0,1,1,0,0,1,21,2,5,9,5,13.2,2,0,5,7,2,12.5,2,10.8,1.4,1.74,1 +Student_00834,2,39,9130,1,1,1,1,37,37,9,6,130.0,160.0,0,0,0,1,1,0,0,31,1,6,11,2,12.0,1,1,6,12,1,10.0,1,16.2,0.3,-0.92,0 +Student_00835,2,39,9119,1,1,1,1,37,37,90,5,110.0,150.0,1,0,0,1,1,0,0,46,0,5,6,0,0.0,0,0,5,5,0,NA,0,7.6,2.6,0.32,0 +Student_00836,1,1,9119,1,3,1,1,3,1,3,4,133.0,121.8,1,0,0,1,1,0,0,18,0,5,9,4,12.0,0,0,5,10,2,11.0,0,8.9,1.4,3.51,1 +Student_00838,NA,51,9556,1,1,1,1,1,37,152,193,131.0,126.6,1,0,0,1,1,0,0,23,0,7,11,5,12.414285714285713,0,0,7,13,2,13.5,0,8.9,1.4,3.51,1 +Student_00839,1,44,9130,1,1,39,1,3,1,2,8,150.0,150.0,0,0,0,0,1,0,0,22,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_00840,NA,1,9147,1,1,1,1,38,1,3,10,125.0,114.5,1,0,0,1,1,0,0,19,0,5,5,5,13.8,0,0,5,7,5,12.4,0,9.4,-0.8,-3.12,2 +Student_00841,1,1,9147,1,1,1,41,3,3,9,9,108.0,107.0,0,0,1,0,0,0,1,19,0,5,14,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,NA,0 +Student_00842,1,17,9147,1,1,1,1,3,1,3,4,116.0,115.7,0,0,0,0,1,0,0,22,0,5,10,4,11.5,0,0,5,11,4,14.0,0,8.9,1.4,3.51,1 +Student_00843,1,39,9130,1,1,1,1,3,34,3,0,133.1,120.0,0,0,1,NA,1,0,0,29,0,5,11,0,0.0,4,0,5,6,0,0.0,1,9.4,-0.8,-3.12,0 +Student_00844,1,1,9500,1,3,1,1,37,38,9,5,147.0,134.8,1,0,0,1,0,0,0,18,0,7,7,6,14.016666666666666,0,0,7,7,6,14.016666666666666,0,7.6,2.6,0.32,2 +Student_00845,1,1,9238,1,1,1,1,38,34,9,9,143.0,133.6,1,0,0,1,0,0,0,18,0,6,9,5,11.4,0,0,6,8,5,10.8,0,9.4,-0.8,-3.12,2 +Student_00846,1,1,171,1,1,1,1,37,37,9,8,115.0,129.0,1,0,1,0,0,1,0,23,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00848,1,17,9147,1,1,1,1,19,19,9,9,118.0,122.2,0,0,0,1,0,0,0,19,0,5,11,3,10.666666666666666,0,0,5,9,4,10.25,0,11.1,0.6,2.02,2 +Student_00850,1,17,9500,1,6,1,1,1,19,4,4,143.0,129.9,0,0,0,1,0,1,0,20,3,7,7,7,13.914285714285713,0,5,8,8,8,14.10625,0,11.1,0.6,2.02,2 +Student_00851,1,1,9500,1,6,1,1,3,3,1,1,133.0,126.2,1,0,0,1,0,0,0,19,0,7,9,7,13.761111111111113,0,0,8,11,7,12.82375,0,15.5,2.8,-4.06,2 +Student_00852,1,5,9853,1,2,1,1,19,19,4,5,122.0,112.6,1,0,0,1,0,0,0,22,0,6,10,5,12.6,0,0,6,9,4,11.25,0,12.7,3.7,-1.7,1 +Student_00853,1,1,9238,1,1,1,1,19,19,9,9,164.0,149.0,1,0,0,1,0,1,0,23,0,6,7,6,13.857142857142858,0,0,6,6,6,14.166666666666666,0,10.8,1.4,1.74,2 +Student_00854,2,39,9500,1,1,1,1,1,19,9,9,133.1,120.0,0,0,0,1,1,1,0,34,0,8,8,7,13.842857142857143,0,0,8,8,7,13.842857142857143,0,12.7,3.7,-1.7,2 +Student_00855,1,17,9119,1,4,1,1,19,19,5,5,127.0,120.4,1,0,1,0,1,0,0,18,0,5,12,0,0.0,0,0,5,8,0,0.0,0,9.4,-0.8,-3.12,1 +Student_00856,1,1,9773,1,3,1,1,1,39,4,1,140.0,128.1,1,1,0,1,1,0,0,21,0,6,6,5,11.8,0,0,6,9,0,0.0,0,16.2,0.3,-0.92,0 +Student_00857,1,1,9238,1,1,1,1,1,19,4,3,127.0,141.7,1,0,0,1,1,0,0,22,0,6,6,6,12.666666666666666,0,0,6,6,6,13.833333333333334,0,10.8,1.4,1.74,0 +Student_00858,1,39,9003,1,1,12,1,37,1,9,10,133.1,130.0,0,0,0,1,1,0,0,28,0,6,6,0,0.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_00859,1,5,9119,1,4,1,1,19,37,4,6,115.0,113.3,1,0,0,1,1,0,0,23,0,5,7,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00861,1,18,9119,1,2,1,1,1,2,5,4,136.0,122.7,1,0,0,1,1,0,0,18,0,5,7,5,12.6,0,0,5,9,3,13.25,0,13.9,-0.3,0.79,0 +Student_00862,1,39,9147,1,2,12,1,19,38,9,9,133.1,120.0,1,0,1,0,1,0,0,28,0,5,5,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00863,1,44,9070,1,1,39,1,1,19,5,8,120.0,119.8,0,0,0,1,1,0,0,21,2,7,7,2,12.0,0,5,9,10,7,12.142857142857142,0,12.4,0.5,1.79,0 +Student_00864,1,39,9670,1,1,1,1,38,19,9,8,133.1,122.9,0,0,1,0,1,0,0,25,0,6,7,3,14.0,0,0,6,9,2,14.5,0,13.9,-0.3,0.79,0 +Student_00865,1,44,9085,1,1,39,1,1,1,5,4,160.0,160.0,1,1,0,0,1,0,0,19,2,6,6,6,14.0,0,1,6,11,6,NA,0,12.4,0.5,1.79,0 +Student_00866,1,1,9500,1,4,1,1,1,1,4,10,128.0,125.2,1,0,0,1,1,1,0,18,0,7,7,7,14.682857142857143,0,0,8,9,8,15.055555555555555,0,12.4,0.5,1.79,2 +Student_00867,1,39,9119,1,1,3,1,1,38,90,90,130.0,143.4,0,0,0,1,1,0,0,29,0,3,3,0,0.0,3,0,5,0,0,0.0,0,10.8,1.4,1.74,0 +Student_00868,1,39,9119,1,1,19,1,37,38,3,7,133.1,96.7,0,0,0,1,1,1,0,29,0,5,6,0,0.0,0,0,5,7,0,0.0,0,12.4,0.5,1.79,0 +Student_00869,1,18,9254,1,1,1,1,19,19,4,5,137.0,126.9,0,0,0,1,1,0,0,20,0,6,7,6,13.857142857142858,0,0,6,7,5,12.8,0,16.2,0.3,-0.92,2 +Student_00870,1,1,171,1,1,1,1,19,1,9,7,163.0,143.1,0,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_00871,1,1,9254,1,1,1,1,1,1,191,193,125.0,114.5,0,0,0,1,1,0,0,20,0,6,8,6,13.142857142857142,0,0,6,7,6,12.5,0,8.9,1.4,3.51,2 +Student_00872,2,39,NA,1,1,1,1,34,34,0,0,120.0,140.0,1,0,0,1,1,0,0,33,0,5,14,1,18.0,0,0,5,9,2,13.0,0,9.4,-0.8,-3.12,0 +Student_00873,1,42,9991,0,1,1,1,19,19,5,5,150.0,113.7,0,0,0,1,1,0,0,30,11,15,15,13,11.461538461538462,0,6,11,15,10,11.583333333333334,1,16.2,0.3,-0.92,2 +Student_00875,1,1,9003,1,1,1,1,1,19,194,194,148.0,143.5,0,0,1,1,1,0,0,18,0,6,6,5,15.0,0,0,6,8,4,14.5,0,8.9,1.4,3.51,2 +Student_00877,1,17,9070,1,1,1,1,38,19,9,NA,119.0,115.2,0,0,0,1,1,1,0,21,0,6,8,4,11.5,0,0,6,7,5,11.0,0,15.5,2.8,-4.06,0 +Student_00878,1,39,9556,1,2,1,1,19,19,4,5,130.0,100.0,0,0,0,1,1,1,0,25,0,7,7,2,10.0,0,0,7,7,0,0.0,0,15.5,2.8,-4.06,0 +Student_00879,1,1,9670,1,2,1,1,19,19,7,10,135.0,121.4,0,0,0,1,1,0,0,19,0,5,7,3,12.333333333333334,0,0,5,5,5,11.6,0,9.4,-0.8,-3.12,2 +Student_00880,1,44,9070,1,1,39,1,19,1,9,3,120.0,120.0,1,0,0,1,1,0,0,23,2,7,8,5,12.2,0,5,9,10,7,12.142857142857142,1,16.2,0.3,-0.92,0 +Student_00881,1,17,9070,1,2,1,1,38,38,9,8,126.0,129.9,1,0,0,1,1,1,0,19,0,6,6,6,13.666666666666666,0,0,6,7,5,13.2,0,12.4,0.5,1.79,2 +Student_00882,1,1,171,1,1,1,1,3,2,2,5,149.0,151.1,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_00883,1,39,9003,1,1,1,1,19,37,9,6,110.0,120.0,0,0,1,0,1,0,0,31,0,6,15,1,11.0,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_00884,1,39,9003,1,1,1,1,37,37,4,7,133.1,130.0,0,0,1,0,1,0,0,32,0,6,8,3,13.0,0,4,10,14,6,11.428571428571429,0,16.2,0.3,-0.92,0 +Student_00885,1,16,9500,1,2,1,1,2,38,4,9,127.0,119.0,1,0,0,1,0,1,0,19,0,8,12,7,12.599999999999998,0,0,8,12,7,12.599999999999998,0,10.8,1.4,1.74,2 +Student_00886,1,42,9773,1,1,6,1,34,34,0,0,120.0,122.0,1,0,0,1,NA,0,0,34,8,10,11,10,12.2,0,5,10,12,9,NA,0,7.6,2.6,0.32,2 +Student_00887,1,16,9773,1,6,1,1,38,14,0,0,136.0,129.7,1,0,0,1,0,0,0,21,0,6,6,6,13.166666666666666,0,0,6,6,6,13.0,0,7.6,2.6,0.32,2 +Student_00888,1,43,9238,1,2,1,1,37,37,9,7,110.0,112.5,1,0,0,1,0,1,0,53,4,7,16,6,11.0,0,2,7,9,7,11.0,0,9.4,-0.8,-3.12,2 +Student_00891,1,1,9773,1,2,1,1,1,19,9,9,159.0,151.3,1,0,0,1,0,0,0,18,0,6,6,6,14.0,0,0,6,6,6,14.666666666666666,0,10.8,1.4,1.74,2 +Student_00892,1,39,171,1,1,1,1,37,38,175,193,147.0,133.3,0,0,0,0,0,0,0,32,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_00894,1,7,8014,0,1,3,1,37,12,9,4,140.0,140.0,0,0,0,0,0,0,0,26,0,5,9,0,0.0,0,0,5,10,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00895,1,42,9085,1,1,39,1,1,1,4,7,150.0,150.0,1,0,0,1,0,0,0,26,11,18,45,18,11.833333333333334,10,9,13,27,13,12.461538461538462,5,15.5,2.8,-4.06,2 +Student_00896,2,44,9991,0,1,39,NA,1,37,4,9,130.0,130.0,0,0,0,0,0,0,0,21,0,5,12,3,11.333333333333334,0,0,5,10,1,13.0,0,15.5,2.8,-4.06,0 +Student_00897,1,17,9773,1,1,1,1,37,37,5,5,120.0,125.3,0,0,0,1,0,0,0,18,0,6,9,6,12.5,0,0,6,9,6,13.0,0,7.6,2.6,0.32,2 +Student_00898,1,43,9070,1,1,39,1,19,37,5,9,130.0,124.0,1,0,0,1,0,1,0,21,4,12,12,12,13.333333333333334,0,5,12,12,11,12.545454545454543,0,15.5,2.8,-4.06,2 +Student_00899,1,1,NA,1,1,1,1,38,19,9,5,112.0,113.8,1,0,0,1,0,0,0,21,0,6,10,6,10.833333333333334,0,0,6,10,4,11.0,0,7.6,2.6,0.32,1 +Student_00900,1,17,9670,1,1,1,1,19,19,7,7,128.0,124.4,0,0,0,1,0,1,0,19,0,6,6,6,13.0,0,0,6,6,6,14.0,0,13.9,-0.3,0.79,2 +Student_00901,1,17,9147,1,1,1,1,19,19,9,7,114.0,107.7,0,0,0,1,0,0,0,19,0,5,7,2,10.0,0,0,5,11,2,14.0,0,10.8,1.4,1.74,0 +Student_00902,1,43,9238,1,2,1,1,38,38,5,5,118.0,110.0,0,0,0,1,0,1,0,19,0,6,8,6,11.428571428571429,0,0,6,11,5,11.2,0,10.8,1.4,1.74,2 +Student_00903,1,7,9500,1,1,3,1,37,38,7,7,130.0,130.0,1,0,0,1,0,0,0,27,0,8,8,8,12.8875,0,0,8,8,8,12.8875,0,9.4,-0.8,-3.12,2 +Student_00904,1,1,9500,1,2,1,1,37,1,9,4,145.0,138.8,1,0,0,1,0,1,0,18,0,7,7,6,12.95,0,0,7,7,6,12.95,0,7.6,2.6,0.32,2 +Student_00906,1,1,9500,1,3,1,1,1,1,5,5,114.0,114.5,1,0,0,1,0,1,0,19,0,7,7,7,13.094285714285714,0,0,8,8,8,12.55,0,12.4,0.5,1.79,2 +Student_00908,1,17,9238,1,2,1,1,19,38,7,6,145.0,128.6,1,0,0,1,0,1,0,19,0,6,12,5,11.714285714285714,0,0,6,11,6,11.0,0,12.7,3.7,-1.7,2 +Student_00909,1,17,9238,1,5,1,1,19,1,5,5,130.0,130.0,1,0,0,1,0,0,0,20,0,6,8,4,11.25,0,0,6,15,3,10.0,0,9.4,-0.8,-3.12,1 +Student_00910,1,1,171,1,1,1,1,38,19,7,10,150.0,134.6,0,0,0,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00911,1,1,9853,1,1,1,1,37,37,9,5,145.0,146.8,0,0,0,1,0,0,0,18,0,6,6,6,13.166666666666666,0,0,6,6,6,13.333333333333334,0,7.6,2.6,0.32,2 +Student_00912,1,1,9085,1,1,1,1,19,1,5,4,128.0,135.7,1,0,0,1,0,0,0,20,0,5,7,4,12.75,0,0,5,5,5,13.4,0,10.8,1.4,1.74,2 +Student_00913,NA,39,9991,0,1,1,1,37,37,9,9,140.0,120.0,0,0,0,0,0,0,0,38,0,5,6,5,10.6,0,0,5,9,2,11.0,0,12.7,3.7,-1.7,0 +Student_00915,1,39,9500,1,1,1,1,37,37,9,6,140.0,135.5,0,0,0,1,0,0,0,32,0,7,0,0,0.0,0,0,8,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_00916,1,15,9773,1,1,1,26,19,19,4,5,120.0,120.0,1,0,0,1,0,0,1,22,0,6,6,6,13.0,0,0,6,6,6,13.666666666666666,0,12.4,0.5,1.79,2 +Student_00917,2,39,9991,0,1,NA,1,34,34,90,90,147.0,111.7,1,0,0,NA,0,0,0,28,0,5,10,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00918,2,39,8014,0,1,9,1,37,37,8,10,133.1,100.0,1,0,0,1,0,0,0,37,0,6,0,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00919,2,44,9003,1,1,39,1,37,38,9,4,160.0,160.0,0,0,0,1,0,0,0,43,0,6,8,6,14.166666666666666,0,0,6,9,6,15.0,0,15.5,2.8,-4.06,2 +Student_00921,4,39,8014,0,1,19,1,37,37,9,3,140.0,131.0,0,0,0,1,0,1,0,29,0,6,11,4,11.75,0,0,6,9,5,10.4,0,10.8,1.4,1.74,2 +Student_00922,1,39,8014,0,1,1,1,37,37,9,9,133.1,97.0,0,0,0,1,0,1,0,35,0,6,8,6,10.833333333333334,0,0,6,7,6,11.5,0,10.8,1.4,1.74,2 +Student_00923,1,17,9238,1,6,1,1,1,3,4,2,131.0,131.7,1,0,0,1,0,0,0,18,0,6,8,4,11.75,0,0,6,8,4,12.25,0,9.4,-0.8,-3.12,0 +Student_00924,1,39,9500,1,1,19,1,37,37,9,6,133.1,120.0,0,0,0,0,0,1,0,39,0,7,14,3,11.5,0,0,7,9,2,10.5,0,16.2,0.3,-0.92,0 +Student_00925,4,39,9991,0,1,1,1,37,37,9,9,120.0,110.0,0,0,0,1,0,0,0,37,0,5,14,2,10.0,0,0,5,7,3,11.333333333333334,0,12.7,3.7,-1.7,1 +Student_00926,1,39,9500,1,1,1,1,37,37,9,7,130.0,133.0,1,0,0,1,0,1,0,26,0,7,7,6,13.7,0,0,7,7,6,13.7,0,7.6,2.6,0.32,2 +Student_00927,1,7,9085,1,1,3,1,19,20,4,90,140.0,140.0,1,0,0,1,0,0,0,32,0,5,8,1,14.0,2,0,5,12,0,0.0,4,10.8,1.4,1.74,0 +Student_00928,2,39,8014,0,1,1,1,37,37,6,8,133.1,100.0,0,0,1,1,0,0,0,37,3,8,12,7,11.375,0,2,7,10,6,12.166666666666666,0,13.9,-0.3,0.79,1 +Student_00929,1,39,9085,1,1,1,1,37,19,191,163,140.0,129.3,1,0,1,1,0,0,0,28,0,6,17,0,0.0,0,0,6,6,0,0.0,0,8.9,1.4,3.51,1 +Student_00930,1,1,9238,1,1,1,1,19,37,0,0,133.1,137.0,1,0,0,1,0,0,0,19,0,6,10,0,0.0,4,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_00932,1,1,9853,1,1,1,1,19,38,9,9,115.0,108.0,0,0,0,1,0,1,0,19,0,7,10,6,13.0,0,0,7,7,7,13.285714285714286,0,12.4,0.5,1.79,2 +Student_00933,2,7,9670,1,1,3,1,37,37,7,7,110.0,110.0,0,0,0,1,0,0,0,32,4,11,15,8,13.6,0,2,8,10,8,15.11111111111111,0,13.9,-0.3,0.79,2 +Student_00934,2,39,9147,1,1,1,1,37,37,9,9,140.0,127.7,1,0,0,1,0,0,0,31,0,5,8,3,11.0,0,0,5,9,2,11.5,0,7.6,2.6,0.32,0 +Student_00935,1,39,9500,1,1,1,1,3,1,2,5,100.0,121.3,1,0,0,1,0,0,0,34,0,8,11,7,11.705714285714285,0,0,8,11,7,11.705714285714285,0,10.8,1.4,NA,1 +Student_00939,1,1,NA,1,1,1,1,19,38,4,10,145.0,131.7,1,0,0,1,0,0,0,18,0,6,7,6,12.666666666666666,0,0,6,8,4,NA,0,7.6,2.6,0.32,1 +Student_00940,4,39,8014,0,1,19,1,37,37,90,7,133.1,110.0,0,0,0,0,0,0,0,31,0,6,8,5,11.4,0,0,6,9,3,11.0,0,9.4,-0.8,-3.12,0 +Student_00941,1,1,9773,1,3,1,1,19,19,5,5,110.0,105.5,1,0,0,1,0,0,0,19,0,6,6,6,13.0,0,0,6,8,5,12.4,0,12.4,0.5,1.79,2 +Student_00944,1,7,9085,1,1,3,1,1,19,9,10,130.0,130.0,0,0,0,1,0,0,0,34,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00945,1,16,9556,1,1,1,1,37,37,9,7,137.0,122.7,1,0,0,1,NA,1,0,18,0,7,7,7,15.285714285714286,0,0,8,8,8,16.075,0,12.4,0.5,1.79,2 +Student_00946,1,17,9254,1,2,1,1,37,37,7,NA,123.0,113.9,1,0,0,1,0,0,0,18,0,6,6,6,13.166666666666666,0,0,6,6,6,12.666666666666666,0,11.1,0.6,2.02,2 +Student_00947,1,1,9147,1,1,1,1,3,19,3,3,156.0,151.1,0,0,1,1,1,0,0,19,0,5,7,5,13.6,0,0,5,11,5,12.833333333333334,5,16.2,0.3,-0.92,2 +Student_00948,1,17,9773,1,2,1,1,3,5,0,2,133.1,125.8,1,0,0,0,NA,1,0,22,0,4,8,0,0.0,0,0,4,8,0,0.0,0,7.6,2.6,0.32,0 +Student_00949,2,43,9670,1,1,1,1,34,34,0,0,100.0,128.2,0,0,0,1,1,0,0,32,6,10,12,10,11.4,0,4,9,9,4,11.5,0,7.6,2.6,0.32,2 +Student_00950,1,39,9147,1,1,1,1,37,3,9,2,140.0,135.1,0,0,0,1,1,0,0,61,0,5,0,0,0.0,0,0,5,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00951,1,39,9991,0,1,1,1,37,37,9,9,130.0,120.2,1,0,0,1,1,0,0,30,0,5,7,5,11.0,0,0,5,5,5,11.6,0,7.6,2.6,0.32,2 +Student_00953,1,44,9003,1,1,39,1,1,19,4,8,140.0,140.0,0,0,0,1,1,0,0,20,0,6,7,6,13.571428571428571,0,0,6,6,6,12.666666666666666,0,12.4,0.5,1.79,2 +Student_00954,1,18,9500,1,5,1,1,19,1,1,10,137.0,129.3,0,0,0,1,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00955,1,42,9119,1,1,1,1,3,1,2,9,120.0,108.2,1,0,0,1,1,0,0,26,4,10,14,4,11.25,0,4,11,11,4,12.0,0,7.6,2.6,0.32,0 +Student_00956,1,17,9670,1,4,1,1,1,1,4,90,125.0,125.4,1,0,0,1,1,0,0,19,0,5,6,3,13.333333333333334,0,0,5,5,1,11.0,0,7.6,2.6,0.32,0 +Student_00958,1,1,9773,1,3,1,1,38,1,9,4,115.0,116.1,1,0,0,1,1,0,0,19,0,6,6,6,12.5,0,0,6,7,5,13.0,0,12.4,0.5,1.79,2 +Student_00959,1,1,9147,1,1,1,1,1,19,5,5,150.0,137.8,1,0,0,1,1,1,0,19,0,5,6,5,13.2,0,0,5,6,5,12.666666666666666,0,16.2,0.3,-0.92,2 +Student_00960,1,1,9670,1,3,1,1,14,11,0,0,134.0,128.4,1,0,0,0,1,0,0,19,0,5,5,0,0.0,0,0,4,4,0,0.0,0,7.6,2.6,0.32,0 +Student_00962,1,43,9147,1,1,1,1,37,37,9,9,141.0,130.2,0,0,0,1,1,0,0,24,10,15,16,15,13.466666666666669,1,10,14,14,14,13.642857142857142,0,9.4,-0.8,-3.12,2 +Student_00963,1,1,9130,1,1,1,1,3,1,2,4,133.0,126.0,0,0,0,1,1,0,0,18,0,5,7,3,13.666666666666666,0,0,5,5,5,13.2,0,7.6,2.6,0.32,2 +Student_00964,1,1,9119,1,2,1,1,38,38,5,5,149.0,141.0,0,0,0,1,1,0,0,18,0,5,9,2,11.666666666666666,0,0,5,9,2,12.5,2,7.6,2.6,0.32,1 +Student_00965,1,1,9773,1,1,1,1,1,3,3,7,121.0,113.0,1,0,0,1,1,1,0,18,0,6,7,6,11.666666666666666,0,0,6,12,5,10.2,0,12.4,0.5,1.79,2 +Student_00966,1,44,9003,1,1,39,1,4,1,2,8,120.0,120.0,0,0,0,1,1,0,0,21,0,6,9,5,13.4,0,0,6,9,5,12.4,0,8.9,1.4,3.51,2 +Student_00967,2,39,9991,0,1,1,1,19,37,9,5,148.0,130.9,0,0,0,0,1,0,0,28,0,5,5,0,0.0,0,0,5,6,0,0.0,0,12.4,0.5,1.79,0 +Student_00968,1,39,9003,1,1,12,1,37,19,9,10,133.1,120.0,0,0,0,1,1,0,0,58,0,6,9,0,0.0,0,0,6,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_00969,2,39,9991,0,1,1,1,34,34,0,0,135.0,134.1,1,0,0,0,1,0,0,49,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00970,1,39,9119,1,1,1,1,1,38,3,5,150.0,120.0,0,0,0,1,1,0,0,24,0,5,6,3,10.666666666666666,0,0,5,9,2,10.5,0,15.5,2.8,-4.06,1 +Student_00971,1,43,9670,1,1,1,1,34,34,0,0,130.0,114.8,0,0,0,1,1,0,0,25,0,5,5,4,13.75,0,0,5,5,4,14.75,0,7.6,2.6,0.32,2 +Student_00972,4,42,9147,1,1,1,1,37,38,7,3,133.1,123.0,1,0,0,1,1,0,0,33,0,5,5,1,10.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00973,2,39,9119,1,2,19,1,37,37,7,7,133.1,118.0,0,0,0,0,1,0,0,33,0,5,11,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00974,2,43,9853,1,1,1,1,37,37,7,7,110.0,100.0,0,0,0,1,1,0,0,40,0,2,4,1,16.0,0,0,4,5,4,15.5,0,13.9,-0.3,0.79,2 +Student_00975,2,39,9991,0,1,1,1,37,19,9,3,170.0,151.1,0,0,0,1,1,0,0,48,0,5,9,5,12.285714285714286,0,0,5,8,5,11.125,0,16.2,0.3,-0.92,2 +Student_00977,1,39,9500,1,1,19,1,38,38,9,8,133.1,106.0,1,0,0,1,1,0,0,24,0,7,7,6,12.666666666666666,1,0,7,7,6,12.666666666666666,1,7.6,2.6,0.32,2 +Student_00978,2,1,9085,1,1,1,1,19,19,192,144,139.0,127.1,0,0,0,1,1,1,0,23,0,5,6,5,11.8,0,0,5,7,4,13.25,1,10.8,1.4,1.74,2 +Student_00979,1,39,9991,0,1,19,1,19,37,7,5,133.1,155.5,1,0,1,0,1,0,0,39,0,5,6,5,10.6,0,0,5,7,5,14.666666666666666,0,10.8,1.4,1.74,0 +Student_00980,1,18,9003,1,1,1,1,1,38,9,6,133.1,101.0,0,0,0,1,1,0,0,21,5,11,16,9,11.9,0,3,9,14,8,12.25,0,15.5,2.8,NA,2 +Student_00981,1,42,9119,1,1,6,1,35,35,6,6,120.0,128.2,1,0,0,1,1,0,0,34,4,6,8,4,11.25,0,1,5,8,2,10.5,0,7.6,2.6,0.32,0 +Student_00982,2,39,9991,0,1,1,1,19,19,4,4,100.0,113.0,0,0,0,1,1,1,0,41,0,5,9,4,11.0,0,0,5,6,5,11.4,0,8.9,1.4,3.51,1 +Student_00983,1,1,9773,1,1,1,1,NA,38,4,5,134.0,122.8,0,0,0,1,1,0,0,18,0,6,6,6,12.0,0,0,6,6,6,12.5,0,12.7,3.7,-1.7,2 +Student_00984,2,39,9991,0,1,1,1,38,38,9,3,130.0,145.6,0,0,0,1,1,0,0,34,0,5,10,4,11.75,0,0,5,10,4,10.833333333333334,0,13.9,-0.3,0.79,1 +Student_00985,1,1,9147,1,1,1,1,1,1,2,10,128.0,116.5,0,0,0,1,1,0,0,19,0,5,8,2,10.0,0,0,5,8,1,16.0,0,7.6,2.6,0.32,0 +Student_00988,1,17,9070,1,1,1,1,1,1,5,0,134.0,133.3,1,0,0,1,1,0,0,18,0,6,7,5,10.8,1,0,6,6,0,0.0,0,7.6,2.6,0.32,0 +Student_00989,1,1,9238,1,1,1,1,2,2,3,4,127.0,115.8,1,0,0,1,1,0,0,19,0,6,11,3,12.0,0,0,6,12,2,10.0,0,11.1,0.6,NA,0 +Student_00990,1,17,9085,1,2,1,1,19,38,9,1,133.1,100.0,1,0,1,0,1,0,0,19,0,6,10,5,12.5,0,0,6,19,2,13.5,0,12.4,0.5,1.79,0 +Student_00991,1,17,9500,1,1,1,1,1,3,9,2,130.0,128.6,1,0,0,1,0,0,0,18,0,7,7,7,14.728571428571428,0,0,8,11,8,16.327272727272728,0,16.2,0.3,-0.92,2 +Student_00992,1,1,9130,1,1,NA,1,3,3,2,2,135.0,137.1,1,0,0,1,0,0,0,18,0,6,8,6,12.0,0,0,6,8,5,NA,0,12.4,0.5,1.79,2 +Student_00993,1,1,9773,1,1,1,1,1,3,3,3,143.0,149.0,1,0,0,1,0,0,0,18,0,6,8,6,11.428571428571429,0,0,6,7,6,11.0,0,11.1,0.6,2.02,0 +Student_00994,1,44,9238,1,2,39,1,3,19,4,9,150.0,147.0,1,0,0,1,0,0,0,19,3,6,6,6,14.166666666666666,0,2,6,6,6,13.5,0,12.4,0.5,1.79,2 +Student_00997,1,1,9500,1,3,1,1,3,1,134,135,113.0,107.8,1,0,0,1,0,1,0,20,0,7,10,5,14.46,0,0,7,8,6,13.55,0,12.4,0.5,1.79,1 +Student_00998,1,44,9085,1,1,39,6,19,1,6,4,130.0,130.0,1,0,0,1,0,0,1,22,0,6,12,5,12.8,0,0,6,19,2,11.5,0,12.4,0.5,1.79,1 +Student_00999,1,17,9254,1,1,1,1,1,19,3,3,115.0,109.4,1,0,0,1,0,0,0,19,0,6,8,6,12.666666666666666,0,0,6,8,5,13.4,0,11.1,0.6,2.02,2 +Student_01000,1,1,9070,1,3,1,1,34,34,0,0,146.0,143.6,1,0,0,1,0,0,0,18,0,6,6,6,12.5,0,0,6,6,6,13.0,0,7.6,2.6,0.32,0 +Student_01001,1,17,9070,1,3,1,1,38,1,5,5,132.0,124.3,0,1,0,1,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01002,1,1,9670,1,5,1,1,19,38,9,9,116.0,119.5,1,0,0,0,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_01003,1,1,171,1,1,1,1,3,4,2,5,163.0,175.6,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,2 +Student_01004,1,17,9147,1,2,1,1,19,19,7,7,122.0,116.1,1,0,0,1,0,1,0,19,0,5,8,5,11.2,0,0,5,5,3,11.0,0,12.4,0.5,1.79,2 +Student_01005,1,17,9238,1,2,1,1,1,3,3,4,136.0,126.6,1,0,0,1,0,0,0,18,0,6,6,6,16.5,0,0,6,7,6,17.428571428571427,0,11.1,0.6,2.02,0 +Student_01006,1,17,9085,1,1,1,1,3,19,5,5,142.0,130.8,1,0,0,1,0,0,0,18,0,5,9,3,13.666666666666666,1,0,5,5,5,12.0,0,12.7,3.7,-1.7,2 +Student_01009,1,1,9500,1,1,1,1,19,37,5,5,165.0,142.3,0,0,0,1,0,1,0,18,0,8,8,7,14.428571428571429,0,0,8,8,7,14.428571428571429,0,12.7,3.7,-1.7,2 +Student_01011,1,1,9500,1,2,1,1,19,19,9,10,135.0,122.9,1,0,0,1,0,0,0,18,0,7,10,7,13.128,0,0,8,13,6,13.193333333333332,0,15.5,2.8,-4.06,2 +Student_01012,1,17,9500,1,1,1,1,19,1,4,3,128.0,117.2,1,0,0,1,0,0,0,20,0,7,9,6,11.605,0,0,8,10,7,12.4125,0,16.2,0.3,-0.92,2 +Student_01013,1,17,9147,1,1,1,1,1,38,4,5,139.0,152.0,0,0,0,1,0,1,0,18,0,5,5,5,14.6,0,0,5,8,5,12.0,0,12.7,3.7,-1.7,2 +Student_01014,1,1,9773,1,2,1,1,19,1,4,5,125.0,122.2,1,0,0,1,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_01016,1,17,9254,1,1,1,1,19,19,9,8,116.0,119.9,1,0,0,1,0,0,0,20,0,6,6,6,12.333333333333334,0,0,6,6,6,12.333333333333334,0,12.4,0.5,1.79,2 +Student_01017,1,17,9147,1,1,1,1,37,1,9,9,138.0,123.7,1,0,1,1,0,1,0,19,0,5,5,4,11.0,0,0,5,5,0,0.0,0,11.1,0.6,2.02,0 +Student_01018,1,51,9070,1,1,1,1,3,1,3,5,135.0,121.8,0,0,0,1,0,1,0,19,5,11,11,11,13.181818181818182,0,5,11,11,11,12.909090909090908,0,11.1,0.6,2.02,2 +Student_01021,1,1,9500,1,2,1,1,1,38,4,7,NA,124.3,1,0,0,1,0,1,0,20,0,8,8,8,12.98125,0,0,8,8,8,12.98125,0,9.4,-0.8,-3.12,2 +Student_01022,1,44,9147,1,1,39,1,19,1,4,9,117.4,117.4,1,0,0,1,0,0,0,21,4,7,10,6,11.333333333333334,0,1,5,6,5,11.2,0,11.1,0.6,2.02,2 +Student_01024,1,17,9070,1,1,1,1,38,38,9,9,116.0,123.7,0,0,0,1,0,0,0,20,0,6,6,6,14.5,0,0,6,7,6,13.5,0,11.1,0.6,2.02,2 +Student_01025,1,18,9853,1,2,1,1,38,38,191,171,111.0,105.8,1,0,0,1,0,0,0,19,0,7,7,7,13.142857142857142,0,0,7,8,7,12.857142857142858,0,8.9,1.4,3.51,2 +Student_01026,1,17,9085,1,3,1,1,1,19,4,90,128.0,124.2,0,0,0,0,0,0,0,21,0,5,8,2,11.5,0,0,5,7,2,10.5,0,7.6,2.6,0.32,0 +Student_01028,1,1,9254,1,5,1,1,19,37,9,9,131.0,123.7,0,0,0,1,0,1,0,19,0,6,8,5,11.666666666666666,0,0,6,7,5,12.2,0,8.9,1.4,3.51,2 +Student_01029,1,17,9500,1,2,1,1,19,19,9,4,135.0,129.8,1,0,0,1,0,0,0,18,0,7,8,7,13.175,0,0,8,8,8,14.875,0,13.9,-0.3,0.79,2 +Student_01031,1,1,9147,1,2,NA,1,1,19,4,3,132.0,126.4,1,0,0,1,0,1,0,18,0,5,13,3,10.6,0,0,5,12,3,10.5,0,13.9,-0.3,0.79,2 +Student_01032,1,1,9853,1,1,1,1,19,37,5,7,120.0,115.1,0,0,0,1,0,1,0,18,0,6,11,4,12.0,0,0,6,8,4,10.75,0,15.5,2.8,-4.06,1 +Student_01034,1,17,9085,1,1,1,1,1,37,9,9,129.0,118.2,1,0,0,1,0,1,0,18,0,5,7,4,13.25,0,0,5,8,5,15.571428571428571,0,10.8,1.4,1.74,2 +Student_01035,1,17,9070,1,1,1,1,38,19,7,7,136.0,121.7,1,0,0,1,0,0,0,18,0,6,6,2,NA,0,0,6,6,0,0.0,0,12.4,0.5,NA,0 +Student_01037,1,17,9238,1,1,1,1,1,38,9,7,125.0,119.8,0,0,0,1,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,NA,0 +Student_01038,1,1,9238,1,1,1,1,1,3,4,2,154.0,164.9,0,0,0,1,0,0,0,18,0,6,6,6,14.0,0,0,6,6,6,13.166666666666666,0,10.8,1.4,1.74,2 +Student_01039,1,42,9085,1,1,1,1,1,38,4,9,100.0,100.0,1,0,0,1,0,1,0,20,1,2,2,2,12.0,0,1,6,11,6,12.833333333333334,0,13.9,-0.3,0.79,2 +Student_01041,1,17,9070,1,4,1,1,1,19,4,5,126.0,120.4,1,0,0,1,0,0,0,18,0,6,8,5,11.8,0,0,6,7,5,10.4,1,16.2,0.3,-0.92,2 +Student_01042,1,18,9500,1,6,1,1,37,37,9,7,124.0,117.8,0,0,0,1,0,1,0,20,0,8,8,7,12.791428571428572,1,0,8,8,7,12.791428571428572,1,10.8,1.4,1.74,2 +Student_01043,4,43,9670,1,1,1,1,37,37,9,6,NA,110.0,0,0,0,1,0,0,0,40,4,8,8,8,11.625,0,3,7,12,5,11.2,0,9.4,-0.8,-3.12,2 +Student_01044,1,1,9500,1,6,1,1,38,38,9,9,133.0,128.8,1,0,0,1,0,1,0,18,0,7,11,6,11.994444444444444,0,0,8,11,7,12.43142857142857,0,15.5,2.8,-4.06,2 +Student_01045,1,1,9254,1,5,1,1,19,19,4,7,126.0,116.6,1,0,0,NA,0,0,0,19,0,6,9,5,11.6,0,0,6,12,5,12.2,0,13.9,-0.3,0.79,2 +Student_01046,1,7,9991,0,1,40,1,1,19,4,9,120.0,120.0,0,0,0,1,0,0,0,24,0,5,5,0,NA,0,0,5,6,0,0.0,0,12.4,0.5,1.79,0 +Student_01047,1,1,9773,1,3,1,1,3,38,2,10,175.0,157.5,1,0,0,1,0,0,0,19,0,6,8,6,13.166666666666666,0,0,6,7,6,13.166666666666666,0,10.8,1.4,1.74,0 +Student_01048,1,1,9500,1,6,1,1,2,1,4,4,141.0,136.3,1,0,0,1,0,0,0,19,0,8,8,7,14.1,0,0,8,8,7,14.1,0,10.8,1.4,1.74,2 +Student_01049,1,1,9500,1,1,1,1,1,19,9,6,133.0,121.5,1,0,0,1,0,1,0,20,0,7,8,6,12.396666666666668,0,0,8,9,7,12.94285714285714,0,11.1,0.6,2.02,2 +Student_01050,1,1,9500,1,1,1,1,38,38,5,5,143.0,133.9,0,0,0,1,0,0,0,18,0,7,7,7,15.014285714285714,0,0,8,8,8,16.0875,0,12.4,0.5,1.79,2 +Student_01051,1,1,171,1,1,1,1,1,38,4,8,141.0,136.8,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_01052,1,17,9500,1,2,NA,1,19,37,4,7,134.0,133.5,1,0,0,1,0,0,0,19,0,7,8,7,14.05,0,0,8,8,8,15.1,0,13.9,-0.3,0.79,2 +Student_01053,1,17,9500,1,3,1,1,3,3,4,5,138.0,130.0,1,0,0,1,0,0,0,18,0,7,8,7,14.85,0,0,8,8,8,15.2,0,13.9,-0.3,0.79,0 +Student_01054,1,44,9085,1,1,39,1,3,3,2,2,140.0,140.0,1,0,0,1,0,0,0,19,0,6,10,6,13.0,0,0,6,19,5,13.0,0,12.4,0.5,1.79,2 +Student_01055,1,1,9500,1,2,1,1,37,37,9,7,142.0,132.7,1,0,0,1,0,1,0,19,0,7,8,7,14.7875,0,0,8,8,8,15.8625,0,13.9,-0.3,0.79,2 +Student_01056,1,1,9500,1,1,1,1,19,19,5,7,118.0,117.8,0,0,0,1,0,1,0,19,0,7,7,7,13.7,0,0,8,9,7,14.671428571428574,0,12.4,0.5,1.79,2 +Student_01057,1,1,9500,1,2,1,1,1,37,4,4,131.0,126.1,1,0,0,1,0,1,0,19,0,7,7,7,12.495714285714286,0,0,8,9,7,12.242857142857144,0,11.1,0.6,2.02,0 +Student_01058,1,1,9500,1,1,1,1,1,38,1,7,130.0,120.0,0,0,0,1,0,0,0,19,0,7,7,6,14.566666666666668,0,0,7,7,6,14.566666666666668,0,7.6,2.6,0.32,2 +Student_01059,1,39,9670,1,1,12,1,1,19,1,5,133.1,100.0,1,0,1,0,0,0,0,25,0,5,5,5,11.2,0,0,5,5,4,11.25,0,9.4,-0.8,-3.12,0 +Student_01060,1,1,9500,1,1,1,1,19,19,4,10,130.0,116.8,0,0,0,1,0,0,0,20,0,8,8,7,12.685714285714283,0,0,8,8,7,12.685714285714283,0,12.7,3.7,-1.7,2 +Student_01062,1,1,9070,1,1,1,1,19,19,7,7,133.1,117.0,0,0,0,1,0,0,0,20,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01064,1,1,9500,1,1,1,1,19,1,4,4,149.0,134.8,0,0,0,1,0,0,0,18,0,8,8,8,14.445,0,0,8,8,8,14.445,0,9.4,-0.8,-3.12,2 +Student_01065,1,1,9853,1,1,1,1,19,1,5,10,163.0,146.6,1,0,1,1,0,0,0,18,0,6,9,5,13.6,0,0,6,10,4,11.75,0,9.4,-0.8,-3.12,1 +Student_01066,1,7,8014,0,1,40,1,19,1,5,10,130.0,130.0,1,0,1,0,0,0,0,23,7,12,12,11,14.0,0,4,10,11,8,14.625,0,13.9,-0.3,0.79,0 +Student_01067,1,1,9500,1,6,1,1,38,37,5,6,145.0,127.5,1,0,0,1,0,1,0,19,0,7,7,6,13.416666666666666,0,0,7,7,6,13.416666666666666,0,7.6,2.6,0.32,2 +Student_01068,1,1,9147,1,1,1,1,37,38,3,3,130.0,123.0,0,0,0,1,0,0,0,18,0,5,8,5,12.333333333333334,2,0,5,7,5,11.4,0,15.5,2.8,-4.06,2 +Student_01069,1,43,9500,1,1,1,1,1,19,9,8,128.0,100.0,1,0,0,1,0,0,0,20,0,7,8,7,13.1,0,0,8,8,8,14.8125,0,13.9,-0.3,0.79,2 +Student_01070,1,1,9670,1,2,1,1,19,19,9,9,111.0,114.2,1,0,0,1,0,0,0,18,0,6,9,4,13.2,0,0,6,10,5,12.8,0,12.4,0.5,1.79,2 +Student_01071,1,1,9500,1,1,1,1,1,1,4,4,140.0,123.5,1,0,0,1,0,1,0,19,0,8,8,8,14.75,0,0,8,8,8,14.75,0,9.4,-0.8,-3.12,2 +Student_01072,1,44,9238,1,1,39,1,19,19,8,8,140.0,144.3,1,0,0,NA,0,1,0,19,3,6,7,6,13.142857142857142,0,2,6,6,6,14.333333333333334,0,12.4,0.5,1.79,2 +Student_01073,1,1,9853,1,1,1,1,38,37,5,NA,145.0,142.2,0,0,0,1,0,0,0,19,0,6,9,4,12.5,0,0,6,9,5,12.5,0,9.4,-0.8,-3.12,1 +Student_01075,1,1,9238,1,1,1,1,37,37,9,5,132.0,135.9,0,0,0,1,0,0,0,18,0,6,11,5,12.4,0,0,6,7,6,13.0,0,9.4,-0.8,-3.12,2 +Student_01077,1,2,9853,1,1,1,1,19,38,9,9,120.0,122.5,0,0,0,0,0,0,0,28,11,11,11,11,11.727272727272728,0,8,8,8,8,12.0,0,15.5,2.8,-4.06,0 +Student_01079,1,43,171,1,1,1,1,3,1,2,3,116.0,117.3,1,0,1,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_01080,1,1,9500,1,2,1,1,1,37,4,9,112.0,106.8,1,0,0,1,0,1,0,19,0,7,8,6,13.533333333333331,0,0,8,9,7,13.614285714285714,0,12.4,0.5,1.79,2 +Student_01081,1,1,9070,1,1,1,1,1,19,4,0,126.0,120.1,0,1,0,1,0,1,0,20,0,6,6,6,13.166666666666666,0,0,6,6,6,12.666666666666666,0,11.1,0.6,2.02,2 +Student_01083,1,51,9070,1,1,1,1,5,1,2,10,117.0,120.0,1,0,0,1,0,0,0,21,0,6,7,5,12.2,0,0,6,7,4,12.6,0,8.9,1.4,3.51,1 +Student_01084,1,1,9853,1,1,1,NA,1,19,9,4,153.0,139.7,1,0,0,1,0,1,0,19,0,7,7,7,13.428571428571429,0,0,7,7,7,14.857142857142858,0,11.1,0.6,2.02,2 +Student_01085,1,1,9070,1,2,1,1,19,1,9,3,124.0,123.7,1,0,0,1,0,1,0,18,1,6,8,6,12.714285714285714,1,0,6,8,6,12.625,0,13.9,-0.3,0.79,2 +Student_01086,1,17,9130,1,2,1,1,3,1,2,NA,127.0,116.5,0,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01087,1,17,9670,1,1,1,1,12,38,9,5,126.0,122.2,0,0,0,1,0,1,0,19,0,6,6,6,13.666666666666666,0,0,6,9,6,13.666666666666666,0,8.9,1.4,3.51,2 +Student_01088,1,1,9773,1,1,1,1,38,19,132,103,133.1,146.0,0,0,1,1,0,0,0,20,0,6,6,5,11.0,0,0,6,6,6,13.166666666666666,0,16.2,0.3,-0.92,2 +Student_01089,1,17,9853,1,2,1,1,1,1,4,0,114.0,108.8,1,0,0,1,0,0,0,18,0,7,11,5,11.4,0,0,7,9,6,13.333333333333334,0,13.9,-0.3,0.79,1 +Student_01090,1,43,171,1,1,1,1,19,19,5,7,133.0,133.0,0,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,1 +Student_01093,1,17,9238,1,3,1,1,37,38,0,7,143.0,NA,1,0,0,1,0,0,0,18,0,6,14,5,11.0,0,0,6,6,6,11.666666666666666,0,7.6,2.6,0.32,2 +Student_01094,1,18,9773,1,4,1,1,19,19,4,4,130.0,121.3,1,0,0,1,0,0,0,20,0,6,12,5,12.0,0,0,6,8,6,11.571428571428571,0,15.5,2.8,-4.06,0 +Student_01095,1,17,9500,1,3,1,1,19,1,9,9,136.0,129.0,1,0,0,1,0,1,0,19,0,7,7,7,13.308571428571428,0,0,8,10,8,12.55,0,12.4,0.5,1.79,2 +Student_01096,1,1,9853,1,1,1,1,37,37,9,9,125.0,114.9,1,0,1,0,0,0,0,21,0,6,8,3,13.666666666666666,0,0,6,7,3,10.666666666666666,0,15.5,2.8,-4.06,0 +Student_01097,1,17,9670,1,1,3,1,12,3,5,8,110.0,106.5,1,0,1,0,0,0,0,20,0,6,6,0,0.0,0,0,6,9,0,0.0,0,10.8,1.4,1.74,0 +Student_01098,1,1,9254,1,1,1,1,37,38,9,9,130.0,133.9,1,0,0,1,0,0,0,18,0,6,10,5,12.2,0,0,6,8,4,11.25,0,9.4,-0.8,-3.12,2 +Student_01099,1,1,9773,1,1,1,1,1,4,5,3,135.0,124.9,0,0,0,1,0,1,0,20,0,6,7,6,12.666666666666666,0,0,6,6,6,12.833333333333334,0,10.8,1.4,1.74,2 +Student_01100,1,1,9500,1,2,1,1,19,37,1,9,133.0,128.5,1,0,0,1,0,1,0,19,0,8,8,8,14.07125,0,0,8,8,8,14.07125,0,9.4,-0.8,-3.12,2 +Student_01101,1,1,9085,1,1,6,1,19,19,9,NA,122.0,126.2,1,0,0,1,0,0,0,22,0,5,14,4,14.25,3,0,5,9,5,13.2,4,9.4,-0.8,-3.12,0 +Student_01102,1,17,9130,1,1,1,1,19,19,9,9,122.0,121.7,1,0,0,0,0,0,0,22,0,6,0,0,0.0,0,0,2,2,0,0.0,2,9.4,-0.8,-3.12,0 +Student_01104,1,43,9147,1,1,1,1,3,19,9,9,123.0,113.2,0,0,0,1,0,0,0,21,3,10,18,6,11.166666666666666,2,4,10,16,7,10.571428571428571,0,7.6,2.6,0.32,1 +Student_01106,1,1,171,1,4,1,1,37,38,9,9,139.0,127.8,1,0,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01107,1,1,9500,1,2,1,1,34,34,0,0,124.0,123.3,1,0,0,1,0,1,0,20,0,8,8,7,14.901428571428571,1,0,8,8,7,14.901428571428571,1,9.4,-0.8,-3.12,0 +Student_01109,1,51,9991,0,1,42,1,19,37,5,9,110.0,128.2,0,0,0,0,0,0,0,22,7,12,12,7,11.0,0,5,5,5,5,10.6,0,8.9,1.4,3.51,0 +Student_01110,1,17,9085,1,4,1,1,19,36,90,7,138.0,134.9,1,0,0,1,0,0,0,20,0,5,7,4,12.4,0,0,5,9,5,12.666666666666666,0,7.6,2.6,0.32,2 +Student_01111,1,44,9003,1,1,39,1,38,38,6,6,140.0,140.0,0,0,0,1,0,0,0,19,0,6,7,6,12.0,0,0,6,7,6,12.666666666666666,0,12.4,0.5,1.79,2 +Student_01112,1,1,9500,1,5,1,1,1,19,6,7,126.0,115.5,1,0,0,1,0,1,0,19,0,7,8,7,NA,0,0,8,10,7,13.328571428571427,0,12.4,0.5,1.79,2 +Student_01113,1,1,9500,1,2,1,1,38,19,9,7,113.0,106.7,1,0,0,1,0,1,0,20,0,7,10,5,12.62,0,0,7,8,6,12.5,0,11.1,0.6,2.02,1 +Student_01114,1,39,9991,0,1,1,1,38,38,3,3,120.0,140.0,0,0,0,1,0,0,0,25,0,5,11,3,10.666666666666666,0,0,5,11,3,11.333333333333334,0,15.5,2.8,-4.06,1 +Student_01115,1,1,9500,1,1,1,1,19,19,9,7,145.0,136.6,0,0,0,1,0,1,0,19,0,7,12,6,13.766666666666666,0,0,8,10,7,14.051428571428572,0,15.5,2.8,-4.06,2 +Student_01116,1,18,9500,1,1,1,1,38,37,9,7,124.0,119.3,1,0,0,1,0,0,0,19,0,8,8,8,13.11625,0,0,8,8,8,13.11625,0,9.4,-0.8,-3.12,2 +Student_01117,1,1,9070,1,1,1,1,3,38,1,9,160.0,152.0,1,0,0,0,0,0,0,19,0,5,5,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01119,1,39,9556,1,2,1,1,37,37,9,9,130.0,159.0,1,0,0,1,0,0,0,25,0,7,11,7,11.857142857142858,0,0,8,21,5,11.7,0,12.4,0.5,1.79,1 +Student_01120,1,17,9500,1,1,1,1,19,38,5,9,127.0,129.5,1,0,0,1,0,1,0,20,0,7,7,6,12.333333333333334,0,0,7,7,6,12.333333333333334,0,7.6,2.6,0.32,2 +Student_01121,1,39,9238,1,1,1,1,38,19,9,9,170.0,140.0,1,0,0,1,0,0,0,24,0,6,9,4,15.75,0,0,6,10,5,16.4,0,9.4,-0.8,-3.12,1 +Student_01122,1,1,9670,1,3,1,1,1,1,5,5,111.0,105.4,0,0,0,1,0,0,0,20,0,5,6,5,13.333333333333334,0,0,5,6,5,13.2,0,7.6,2.6,0.32,2 +Student_01126,1,1,9670,1,2,1,1,37,38,9,9,144.0,126.9,0,0,0,1,0,1,0,21,0,5,5,5,13.2,0,0,5,5,4,13.0,0,9.4,-0.8,-3.12,2 +Student_01127,1,39,9500,1,1,3,1,3,37,2,10,133.8,184.0,0,0,0,1,0,0,0,28,0,7,9,7,17.005555555555556,0,1,8,9,8,16.582222222222224,0,15.5,2.8,-4.06,2 +Student_01128,1,1,9238,1,1,1,1,37,38,9,9,125.0,125.0,1,0,1,0,0,1,0,19,0,6,8,5,10.6,0,0,6,8,5,11.0,0,10.8,1.4,1.74,2 +Student_01129,1,1,9147,1,1,1,1,37,37,9,6,150.0,138.5,0,0,0,1,0,1,0,18,0,5,5,5,14.0,0,0,5,6,5,13.6,0,12.4,0.5,1.79,2 +Student_01130,5,17,9500,1,5,1,1,37,38,5,8,143.0,133.5,1,0,0,1,0,1,0,18,0,8,8,7,12.114285714285714,0,0,8,8,7,12.114285714285714,0,12.7,3.7,-1.7,2 +Student_01131,1,1,9500,1,3,1,1,19,37,7,7,145.0,141.5,1,0,0,1,0,1,0,18,0,8,8,8,13.05875,0,0,8,8,8,13.05875,0,9.4,-0.8,-3.12,2 +Student_01133,1,1,9147,1,1,1,1,37,37,194,171,138.0,131.0,1,0,0,1,0,0,0,19,0,5,9,4,11.0,0,0,5,8,3,10.666666666666666,0,12.4,0.5,1.79,1 +Student_01134,1,1,NA,1,1,1,1,19,1,9,5,145.0,145.0,0,0,0,1,0,1,0,NA,0,7,7,7,14.071428571428571,0,0,8,8,8,15.1625,0,13.9,-0.3,0.79,2 +Student_01135,1,17,9254,1,1,1,1,37,37,5,6,122.0,114.3,0,0,0,0,0,0,0,20,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01136,1,44,171,1,1,39,1,37,37,5,6,110.0,108.3,0,0,0,0,0,0,0,26,4,9,9,4,11.25,0,3,10,12,3,11.0,0,12.4,0.5,1.79,0 +Student_01137,1,1,9070,1,3,1,1,37,38,9,9,136.0,125.2,1,0,0,1,0,1,0,18,0,6,6,6,14.0,0,0,6,8,6,13.625,0,10.8,1.4,1.74,2 +Student_01138,1,1,9254,1,1,1,1,1,38,4,9,145.0,131.7,1,0,0,1,0,1,0,21,0,6,8,6,12.166666666666666,0,0,6,11,3,11.666666666666666,0,10.8,1.4,1.74,0 +Student_01141,1,1,9500,1,6,1,1,38,19,5,6,130.0,125.1,1,0,0,1,0,0,0,18,0,7,11,7,13.37,0,0,8,13,7,12.833333333333334,0,15.5,2.8,-4.06,2 +Student_01143,1,1,9670,1,1,1,1,1,1,2,2,128.0,130.8,1,0,0,1,0,0,0,20,0,5,5,4,15.0,0,0,5,5,4,13.75,0,7.6,2.6,0.32,0 +Student_01144,NA,NA,9853,1,1,1,1,19,19,9,5,152.0,154.1,0,0,1,1,0,1,0,18,0,6,6,6,13.333333333333334,0,0,6,7,6,12.571428571428571,0,12.7,3.7,-1.7,2 +Student_01145,1,16,9147,1,2,1,1,37,37,9,9,132.0,122.6,1,0,0,1,0,1,0,20,0,5,8,3,12.0,0,0,5,9,4,12.625,0,10.8,1.4,1.74,1 +Student_01146,1,1,8014,0,2,1,1,19,11,0,0,107.0,103.5,1,0,0,1,0,0,0,22,0,6,7,5,13.4,0,0,6,9,5,12.2,0,7.6,2.6,0.32,2 +Student_01147,1,1,171,1,1,1,1,19,38,4,5,131.0,132.8,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,1 +Student_01148,1,51,9991,0,1,1,1,19,38,5,7,141.0,100.0,0,0,0,1,0,0,0,21,1,5,9,4,11.5,0,1,5,5,5,11.4,0,8.9,1.4,3.51,2 +Student_01149,1,18,9853,1,2,1,NA,1,1,9,0,120.0,115.8,0,0,0,1,0,0,0,18,0,7,12,6,12.0,0,0,7,11,6,12.166666666666666,0,13.9,-0.3,0.79,1 +Student_01150,1,1,9500,1,1,1,1,19,19,4,4,148.0,133.8,0,0,0,1,0,0,0,18,0,8,8,7,13.485714285714284,0,0,8,8,7,13.485714285714284,0,12.7,3.7,-1.7,2 +Student_01152,1,17,171,1,1,1,1,37,37,9,1,145.0,150.3,1,0,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01154,1,1,9500,1,1,1,1,38,1,9,4,138.0,127.5,1,0,0,1,0,0,0,19,0,7,10,5,12.94,0,0,7,7,5,13.76,0,16.2,0.3,-0.92,1 +Student_01155,1,1,9500,1,3,1,1,1,37,7,7,135.0,120.5,1,0,0,1,0,0,0,19,0,8,11,7,13.258571428571427,0,0,8,11,7,13.258571428571427,0,10.8,1.4,1.74,2 +Student_01156,1,1,9147,1,1,1,1,1,2,10,10,118.0,117.3,1,0,0,1,0,0,0,19,0,5,9,4,12.25,0,0,5,10,4,12.0,0,8.9,1.4,3.51,1 +Student_01157,1,17,9254,1,1,1,1,38,37,9,7,123.0,120.6,1,0,0,0,0,0,0,19,0,6,9,3,11.666666666666666,0,0,6,15,1,10.0,0,10.8,1.4,1.74,0 +Student_01159,1,1,9773,1,2,1,41,1,37,9,7,150.0,130.8,0,0,0,1,0,1,1,20,0,6,9,5,11.8,0,0,6,9,5,11.833333333333334,0,15.5,2.8,-4.06,2 +Student_01160,1,1,9147,1,1,1,1,19,19,3,9,121.0,112.6,1,0,0,1,0,1,0,20,0,5,7,5,14.2,0,0,5,7,5,13.285714285714286,0,11.1,0.6,2.02,2 +Student_01161,1,39,9991,0,1,19,1,37,37,9,9,133.1,117.2,0,0,0,1,0,0,0,41,0,5,8,5,11.0,0,0,5,6,5,11.8,1,7.6,2.6,0.32,2 +Student_01162,4,7,9500,1,1,40,1,37,37,3,3,130.0,130.0,1,0,0,1,0,0,0,32,0,7,16,4,13.625,0,0,7,8,7,12.6375,0,12.4,0.5,1.79,1 +Student_01164,4,39,8014,0,1,1,1,37,37,3,4,160.0,97.0,0,0,0,1,0,1,0,35,0,6,9,6,11.333333333333334,0,0,6,6,6,11.333333333333334,0,15.5,2.8,-4.06,2 +Student_01165,1,39,9500,1,1,1,1,37,37,9,9,110.0,130.0,0,0,1,0,0,0,0,32,0,7,12,4,13.7,0,0,7,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_01166,1,39,8014,0,1,40,1,19,37,5,9,140.0,148.0,0,0,0,1,0,0,0,37,7,11,11,11,13.727272727272728,0,4,8,8,8,14.75,0,12.4,0.5,1.79,2 +Student_01167,2,39,9147,1,2,3,1,3,37,9,9,130.0,103.4,0,0,0,1,0,0,0,30,4,7,9,7,11.75,0,3,8,12,7,11.142857142857142,0,12.7,3.7,-1.7,0 +Student_01169,1,17,9773,1,2,1,1,3,1,2,7,139.0,124.0,1,0,0,1,0,1,0,20,0,6,6,6,14.0,0,0,6,7,6,13.857142857142858,0,15.5,2.8,-4.06,0 +Student_01170,1,1,9670,1,1,1,1,19,37,5,7,135.0,121.4,0,0,0,1,1,0,0,21,0,5,7,4,11.5,0,0,5,6,4,11.75,0,9.4,-0.8,-3.12,2 +Student_01171,1,NA,9147,1,1,1,1,38,19,5,7,117.0,118.1,0,0,0,1,1,0,0,19,0,5,6,5,11.2,0,0,5,5,5,13.2,0,12.4,0.5,1.79,2 +Student_01172,1,17,9500,1,4,1,1,1,19,4,3,137.0,121.3,1,0,0,1,1,1,0,18,0,8,8,7,15.07,0,0,8,8,7,15.07,0,10.8,1.4,1.74,2 +Student_01173,1,42,9119,1,1,1,1,34,34,0,0,144.0,119.5,0,0,0,1,1,0,0,18,0,5,6,1,10.0,0,0,5,7,1,12.0,0,10.8,1.4,1.74,0 +Student_01174,1,39,9991,0,1,1,1,1,1,4,10,130.0,115.2,0,0,0,1,1,0,0,24,0,5,5,4,12.0,0,0,5,6,5,12.666666666666666,0,12.4,0.5,1.79,1 +Student_01175,1,18,9670,1,1,1,1,1,37,9,9,140.0,130.2,1,0,0,1,1,0,0,22,0,6,11,4,13.0,0,0,6,11,4,12.6,0,12.7,3.7,-1.7,2 +Student_01176,1,17,9254,1,4,1,1,19,1,5,5,130.0,130.0,1,0,0,1,1,0,0,18,0,6,7,4,11.0,0,0,6,7,3,11.25,0,16.2,0.3,-0.92,0 +Student_01177,1,16,9238,1,2,1,1,37,37,5,6,130.0,126.9,1,0,0,1,0,0,0,18,0,6,8,6,13.571428571428571,0,0,6,11,5,12.166666666666666,0,9.4,-0.8,-3.12,2 +Student_01180,1,18,9556,1,1,1,1,38,37,9,9,140.0,122.8,0,0,0,1,0,1,0,19,0,7,11,7,12.625,0,0,8,11,8,12.5125,0,12.7,3.7,-1.7,2 +Student_01181,6,39,9500,1,1,1,1,37,37,9,9,133.1,110.0,0,0,0,1,0,0,0,36,0,7,12,4,11.5,0,0,7,14,3,12.333333333333334,0,16.2,0.3,-0.92,0 +Student_01182,1,16,9085,1,1,1,1,1,1,9,9,140.0,127.1,1,0,0,1,0,0,0,18,0,5,8,4,13.25,1,0,5,10,4,10.5,0,12.7,3.7,-1.7,2 +Student_01183,1,1,9500,1,3,1,1,19,19,5,5,133.1,108.5,1,0,0,1,0,0,0,19,0,7,9,7,12.60625,0,0,8,12,6,11.9,0,12.4,0.5,1.79,2 +Student_01185,1,1,9500,1,2,1,1,19,38,192,192,133.1,96.0,1,0,0,1,0,0,0,19,0,7,10,6,13.598333333333334,0,0,8,11,6,11.933333333333332,0,11.1,0.6,2.02,1 +Student_01186,1,1,9238,1,1,1,1,19,19,9,9,135.0,124.5,0,0,0,1,0,1,0,18,0,6,11,5,11.142857142857142,0,0,6,8,6,12.285714285714286,0,16.2,0.3,-0.92,2 +Student_01187,2,7,9500,1,1,3,1,37,19,9,7,120.0,120.0,1,0,0,1,0,0,0,45,7,11,11,11,12.7,0,6,10,12,10,12.96818181818182,0,13.9,-0.3,0.79,1 +Student_01188,1,17,9147,1,1,1,1,37,37,9,7,140.0,132.3,1,0,0,1,0,0,0,20,0,5,9,1,10.0,0,0,5,10,1,11.0,0,7.6,2.6,0.32,0 +Student_01189,1,17,9254,1,1,1,1,19,1,5,7,128.0,120.7,1,0,1,1,0,0,0,18,0,6,8,6,11.666666666666666,0,0,6,10,4,11.5,0,13.9,-0.3,0.79,2 +Student_01190,1,1,9670,1,1,1,1,1,19,4,4,141.0,132.6,0,0,0,1,0,1,0,18,0,6,8,6,14.0,0,0,6,7,6,13.142857142857142,0,11.1,0.6,2.02,2 +Student_01191,1,7,9130,1,2,3,1,34,34,0,0,140.0,140.0,0,0,0,1,0,0,0,25,0,5,9,0,0.0,4,0,5,9,0,0.0,3,10.8,1.4,1.74,0 +Student_01192,1,1,9500,1,6,1,1,1,1,4,4,139.0,124.5,1,0,0,1,0,0,0,19,0,8,9,7,12.04142857142857,0,0,8,9,7,12.04142857142857,0,10.8,1.4,1.74,2 +Student_01193,1,1,171,1,1,1,1,19,19,7,7,142.0,142.0,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_01194,1,7,9254,1,1,40,1,1,1,3,6,130.0,130.0,0,0,0,1,0,0,0,39,12,13,14,13,13.76923076923077,0,9,12,16,12,14.583333333333334,0,13.9,-0.3,0.79,2 +Student_01195,2,39,9003,1,1,1,1,38,37,9,9,130.0,144.0,0,0,0,1,0,0,0,29,13,18,20,18,15.444444444444445,0,11,13,13,13,15.307692307692308,0,15.5,2.8,-4.06,2 +Student_01196,1,17,9853,1,1,1,1,19,19,4,7,125.0,128.5,1,0,0,1,0,0,0,18,0,7,9,6,11.5,0,0,7,8,7,12.714285714285714,0,13.9,-0.3,0.79,1 +Student_01197,1,7,9070,1,1,3,1,37,2,9,3,140.0,140.0,0,0,0,0,0,0,0,23,0,3,3,2,10.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01198,1,42,9853,1,1,1,1,1,37,5,5,120.0,113.9,1,0,0,1,0,0,0,21,0,6,8,4,12.25,0,0,6,13,3,10.333333333333334,0,12.7,3.7,-1.7,0 +Student_01199,1,1,9238,1,1,1,1,1,19,4,4,147.0,137.2,0,0,0,0,0,0,0,18,0,6,6,6,14.5,0,0,6,6,6,15.166666666666666,0,10.8,1.4,1.74,2 +Student_01200,1,7,9085,1,1,40,1,1,19,5,5,140.0,140.0,1,0,0,1,0,0,0,23,0,6,7,6,15.571428571428571,0,0,6,8,6,16.375,0,12.4,0.5,1.79,2 +Student_01201,1,1,9130,1,1,1,1,1,19,4,4,161.0,152.3,0,0,0,1,0,0,0,18,0,6,7,6,15.571428571428571,0,0,6,7,6,14.714285714285714,0,11.1,0.6,2.02,2 +Student_01202,2,39,8014,0,1,19,1,37,37,4,8,133.1,112.5,0,0,0,1,0,0,0,32,0,6,8,5,13.8,0,0,6,7,6,12.166666666666666,0,9.4,-0.8,-3.12,2 +Student_01203,2,39,9147,1,2,1,1,19,37,9,7,150.0,101.0,0,0,1,0,0,0,0,29,0,5,8,3,10.666666666666666,0,0,5,14,2,14.8,0,10.8,1.4,1.74,0 +Student_01204,1,1,9238,1,6,1,1,1,38,194,163,113.0,112.3,1,0,1,1,0,1,0,20,0,6,8,5,11.6,0,0,6,8,4,11.75,0,8.9,1.4,3.51,2 +Student_01205,1,39,9238,1,1,1,1,34,34,0,0,140.0,114.0,1,0,0,0,0,0,0,28,0,6,11,1,13.0,0,0,6,12,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01206,1,7,9147,1,1,3,1,38,38,1,9,130.0,130.0,0,0,0,1,0,0,0,27,0,5,9,3,12.0,0,0,5,11,4,13.625,0,10.8,1.4,1.74,2 +Student_01207,1,43,9500,1,2,1,1,37,34,90,0,120.0,121.5,0,0,1,1,0,0,0,22,11,14,14,12,12.333333333333334,2,11,14,14,12,12.333333333333334,2,7.6,2.6,0.32,2 +Student_01208,2,39,9003,1,1,19,1,19,37,9,10,133.1,NA,0,0,1,1,0,0,0,37,0,6,10,6,12.875,0,0,6,12,6,12.9,0,16.2,0.3,-0.92,1 +Student_01210,2,39,9003,1,1,1,1,37,37,9,9,120.0,125.7,0,0,1,0,0,0,0,43,0,6,10,4,12.25,0,0,6,13,4,10.5,0,8.9,1.4,3.51,0 +Student_01211,1,43,9556,1,1,1,1,37,37,9,9,140.0,128.0,1,0,0,0,0,0,0,32,0,7,7,0,0.0,7,0,8,8,0,0.0,7,10.8,1.4,1.74,0 +Student_01213,4,39,9500,1,1,19,1,38,1,9,4,133.1,120.0,0,0,0,1,0,1,0,35,0,8,9,8,13.63,1,0,8,9,8,13.63,1,9.4,-0.8,-3.12,2 +Student_01214,1,1,9670,1,1,1,1,37,37,0,0,130.0,117.8,1,0,0,NA,0,0,0,21,0,5,8,3,13.0,0,0,5,7,4,11.5,1,7.6,2.6,0.32,2 +Student_01216,1,1,9500,1,1,1,1,3,38,3,7,176.0,169.7,0,0,0,1,0,1,0,18,0,7,7,7,16.9,0,0,8,9,8,16.37777777777778,0,16.2,0.3,-0.92,2 +Student_01221,1,1,171,1,2,1,1,39,1,3,4,136.0,134.3,1,0,1,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,0 +Student_01222,1,1,9500,1,1,1,1,19,1,9,5,132.0,123.4,0,0,0,NA,0,1,0,18,0,7,7,7,14.604285714285712,0,0,8,9,8,15.68333333333333,0,11.1,0.6,2.02,2 +Student_01225,1,1,9500,1,3,1,1,19,38,7,7,137.0,126.5,1,0,0,1,0,1,0,19,0,8,8,8,13.57625,0,0,8,8,8,13.57625,0,9.4,-0.8,-3.12,2 +Student_01226,1,17,9238,1,1,1,1,38,38,7,7,153.0,159.7,1,0,0,1,0,1,0,18,0,6,7,6,15.142857142857142,0,0,6,6,6,15.833333333333334,0,12.7,3.7,-1.7,2 +Student_01227,1,1,9147,1,1,1,1,9,19,4,3,160.0,151.3,0,0,0,1,0,0,0,23,0,5,8,3,10.666666666666666,0,0,5,8,5,11.6,0,7.6,2.6,0.32,2 +Student_01228,1,17,9238,1,1,1,1,38,38,5,7,145.0,138.0,1,0,0,1,0,0,0,20,0,6,11,5,11.2,0,0,6,6,6,12.0,0,9.4,-0.8,-3.12,2 +Student_01229,1,1,9500,1,5,1,1,38,38,4,8,137.0,126.5,1,0,0,1,0,0,0,18,0,8,8,8,13.76375,0,0,8,8,8,13.76375,0,9.4,-0.8,-3.12,2 +Student_01230,1,53,9085,1,1,42,1,1,1,4,3,140.0,140.0,1,0,1,1,0,0,0,21,7,9,10,8,13.25,0,4,9,14,5,12.2,0,8.9,1.4,3.51,1 +Student_01231,1,1,9238,1,1,1,1,19,38,5,6,120.0,112.3,0,0,0,1,0,1,0,22,0,6,10,5,10.714285714285714,0,0,6,10,5,12.2,0,12.7,3.7,-1.7,2 +Student_01232,1,1,9238,1,1,1,1,1,19,4,4,122.0,127.3,1,0,1,1,0,0,0,20,0,6,6,6,12.166666666666666,0,0,6,7,6,11.666666666666666,0,9.4,-0.8,-3.12,2 +Student_01233,1,7,9500,1,1,3,1,19,38,4,10,130.0,130.0,1,0,0,1,0,0,0,23,1,7,8,6,14.357142857142858,0,1,7,8,6,14.357142857142858,0,7.6,2.6,0.32,2 +Student_01234,1,17,9773,1,2,1,1,3,1,4,5,133.1,115.0,1,0,0,1,0,0,0,19,0,6,6,6,12.833333333333334,0,0,6,6,6,12.666666666666666,0,16.2,0.3,-0.92,2 +Student_01235,1,17,9500,1,6,1,1,1,37,1,1,150.0,131.5,1,0,0,1,0,0,0,19,0,8,8,7,13.925714285714283,0,0,8,8,7,13.925714285714283,0,10.8,1.4,1.74,2 +Student_01236,1,39,9991,0,1,1,1,19,38,7,4,133.1,125.7,0,0,0,1,0,0,0,NA,0,5,9,2,12.0,0,0,5,9,3,11.0,0,10.8,1.4,1.74,0 +Student_01237,1,1,9500,1,6,1,1,1,37,4,3,141.0,126.8,1,0,0,1,0,0,0,18,0,7,7,7,13.44285714285714,0,0,8,9,8,13.744444444444444,0,16.2,0.3,-0.92,2 +Student_01238,1,18,9119,1,1,1,1,1,37,7,7,146.0,132.4,1,0,0,1,1,0,0,18,0,5,5,1,16.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01239,1,44,9003,1,1,39,1,38,37,9,9,150.0,150.0,1,0,0,1,1,0,0,20,0,6,8,6,13.125,0,0,6,10,6,13.2,0,16.2,0.3,-0.92,2 +Student_01240,1,1,9670,1,1,1,1,3,1,4,4,133.1,95.0,0,0,0,1,1,0,0,19,0,6,7,0,0.0,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_01241,1,43,9991,0,1,1,1,37,37,9,9,120.0,128.2,0,0,0,0,1,0,0,32,5,9,9,5,11.4,0,4,4,4,4,11.0,0,10.8,1.4,1.74,0 +Student_01242,2,39,9130,1,1,1,1,19,19,4,4,150.0,130.0,0,0,0,0,1,0,0,31,0,4,12,2,11.0,2,0,5,9,3,11.666666666666666,0,9.4,-0.8,-3.12,0 +Student_01243,1,39,9119,1,1,19,1,1,19,4,5,133.1,100.0,0,0,0,1,1,0,0,25,0,5,13,1,11.0,0,0,5,11,1,10.0,0,13.9,-0.3,0.79,1 +Student_01245,2,43,9991,0,1,1,1,37,37,4,9,140.0,100.0,0,0,0,0,0,0,0,31,2,6,10,4,11.75,0,0,5,6,1,10.0,0,12.7,3.7,-1.7,0 +Student_01247,1,1,9238,1,1,1,1,19,19,9,9,128.0,120.0,0,0,0,1,0,1,0,18,0,6,8,6,13.5,0,0,6,9,6,12.833333333333334,0,11.1,0.6,2.02,2 +Student_01248,1,1,9238,1,3,1,1,19,19,9,9,117.0,117.0,1,0,1,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_01249,1,53,9670,1,1,42,1,19,37,3,6,140.0,140.0,1,0,1,1,0,0,0,21,0,6,12,1,NA,0,0,6,11,1,11.0,0,8.9,1.4,3.51,1 +Student_01250,1,1,9853,1,2,1,1,38,37,5,3,124.0,118.1,1,0,0,0,0,0,0,18,0,6,11,3,13.0,0,0,6,10,5,11.8,0,9.4,-0.8,-3.12,0 +Student_01251,1,1,9254,1,1,1,1,19,39,4,8,158.0,153.5,1,0,0,1,0,0,0,20,0,6,7,6,14.833333333333334,0,0,6,6,6,16.0,0,11.1,0.6,2.02,2 +Student_01252,1,43,9773,1,1,1,1,38,37,9,5,137.0,127.9,1,0,0,1,0,0,0,NA,0,6,6,6,11.833333333333334,0,0,6,7,6,12.857142857142858,0,15.5,2.8,-4.06,2 +Student_01253,1,17,NA,1,3,1,1,38,38,7,8,123.0,118.8,1,1,0,1,0,1,0,18,0,6,10,5,12.0,0,0,6,11,5,12.333333333333334,0,11.1,0.6,2.02,2 +Student_01254,1,1,9238,1,1,1,1,38,38,7,8,126.0,126.7,1,0,0,1,0,0,0,19,0,6,11,4,12.75,0,0,6,7,6,NA,0,7.6,2.6,0.32,2 +Student_01255,1,43,9085,1,1,1,1,19,19,5,1,170.0,170.0,1,0,0,1,0,0,0,19,0,5,5,0,0.0,5,0,5,7,4,14.75,1,12.7,3.7,-1.7,1 +Student_01256,4,39,9130,1,1,1,1,3,1,5,5,133.1,110.0,1,0,0,1,0,1,0,30,0,6,7,0,0.0,0,0,6,16,1,10.0,0,11.1,0.6,2.02,0 +Student_01257,1,17,9238,1,1,1,1,19,38,5,5,115.0,115.0,1,0,0,1,0,0,0,19,0,6,6,6,12.0,0,0,6,7,6,12.857142857142858,0,11.1,0.6,2.02,2 +Student_01258,1,1,9556,1,3,1,1,38,37,7,7,132.0,119.0,1,0,0,1,0,0,0,19,0,7,9,7,11.677777777777775,0,0,8,8,8,13.8,0,12.7,3.7,-1.7,2 +Student_01259,1,1,9500,1,4,1,1,1,37,4,7,132.0,121.8,1,0,0,1,0,1,0,19,0,8,8,7,13.6,0,0,8,8,7,13.6,0,12.7,3.7,-1.7,2 +Student_01260,1,1,9085,1,1,1,1,19,38,9,9,143.0,133.4,1,0,0,1,0,0,0,19,0,6,7,6,16.0,0,0,6,8,6,15.875,0,12.4,0.5,1.79,2 +Student_01261,1,1,9238,1,3,1,1,1,1,3,3,137.0,131.4,1,0,0,1,0,0,0,20,0,6,9,5,11.8,0,0,6,7,6,11.5,0,7.6,2.6,0.32,2 +Student_01263,1,1,9773,1,2,1,1,19,19,9,9,121.0,122.8,0,0,0,1,1,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_01264,2,39,9853,1,1,1,1,37,19,7,3,130.0,140.0,0,0,1,1,0,1,0,34,0,6,7,6,16.142857142857142,0,0,6,10,6,16.2,0,9.4,-0.8,-3.12,2 +Student_01265,1,18,9500,1,2,1,1,38,37,9,5,135.0,125.3,1,0,0,1,0,1,0,18,0,8,8,7,11.785714285714286,0,0,8,8,7,11.785714285714286,0,12.7,3.7,-1.7,2 +Student_01266,1,1,9500,1,6,1,1,1,1,4,5,137.0,126.3,1,0,0,1,0,1,0,18,0,8,8,8,13.42375,0,0,8,8,8,13.42375,0,9.4,-0.8,-3.12,2 +Student_01267,1,1,9670,1,1,1,1,38,38,9,10,100.0,100.0,0,0,0,NA,0,0,0,20,0,6,8,6,12.5,0,0,6,10,5,14.166666666666666,0,11.1,0.6,2.02,2 +Student_01268,1,17,9500,1,2,1,1,19,37,9,7,127.0,121.3,1,0,0,1,0,1,0,20,0,8,8,7,12.464285714285714,0,0,8,8,7,12.464285714285714,0,10.8,1.4,1.74,2 +Student_01269,1,53,9991,0,1,1,1,NA,38,191,193,140.0,135.0,0,0,1,1,0,0,0,23,6,11,18,8,12.375,0,3,9,15,5,12.6,0,8.9,1.4,3.51,1 +Student_01270,1,39,9670,1,1,1,1,37,37,6,6,140.0,120.0,0,0,0,1,0,0,0,28,0,6,8,1,10.0,0,0,6,9,0,0.0,0,10.8,1.4,1.74,0 +Student_01271,1,17,9773,1,1,1,1,37,19,9,10,121.0,113.7,0,0,0,1,0,0,0,18,0,6,8,5,12.6,0,0,6,10,6,12.428571428571429,0,15.5,2.8,-4.06,1 +Student_01272,1,43,9147,1,1,1,1,19,38,9,9,131.0,129.7,1,0,0,1,0,0,0,19,0,5,5,5,12.6,0,0,5,6,4,12.4,0,16.2,0.3,-0.92,2 +Student_01273,2,1,9147,1,1,1,1,38,37,9,8,151.0,132.1,1,0,0,1,0,0,0,34,0,5,7,2,10.0,0,0,5,6,4,12.0,0,7.6,2.6,0.32,0 +Student_01274,NA,51,9853,1,1,1,1,37,37,7,NA,130.0,120.3,0,0,0,1,0,0,0,35,0,7,7,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_01275,1,7,9991,0,1,40,1,37,37,9,7,120.0,120.0,0,0,0,1,0,0,0,32,0,5,7,5,11.6,0,0,5,8,5,12.333333333333334,0,12.4,0.5,1.79,2 +Student_01276,1,17,9254,1,2,1,1,19,19,4,7,136.0,123.1,1,0,0,1,0,0,0,19,0,6,8,6,12.166666666666666,0,0,6,6,6,13.5,0,11.1,0.6,2.02,2 +Student_01277,1,17,9670,1,5,1,1,1,19,9,7,125.0,119.4,1,0,0,1,0,0,0,18,0,6,10,4,13.6,0,0,6,7,5,12.666666666666666,0,11.1,0.6,2.02,2 +Student_01278,2,39,9147,1,1,1,1,37,37,9,9,133.1,140.0,0,0,0,0,0,0,0,35,0,5,8,4,12.5,1,0,5,8,5,11.8,0,9.4,-0.8,-3.12,0 +Student_01279,1,39,8014,0,1,1,1,1,12,4,5,133.1,116.5,0,0,0,1,1,1,0,24,0,6,6,4,12.25,0,0,6,10,4,11.5,0,12.4,0.5,1.79,1 +Student_01280,1,17,9238,1,1,1,1,19,37,9,9,120.0,113.0,1,0,0,1,0,1,0,20,0,6,7,6,11.714285714285714,0,0,6,8,6,12.625,0,13.9,-0.3,0.79,2 +Student_01281,1,1,9773,1,3,1,11,19,19,4,9,143.0,133.9,1,0,0,1,1,1,1,18,0,6,7,6,13.5,0,0,6,7,6,13.0,0,16.2,0.3,-0.92,2 +Student_01282,1,1,9500,1,3,1,1,38,19,7,9,133.1,115.5,1,0,0,1,1,1,0,20,0,8,8,7,13.024285714285714,0,0,8,8,7,13.024285714285714,0,10.8,1.4,1.74,2 +Student_01284,1,1,9119,1,1,1,1,19,19,4,4,168.0,171.2,0,0,0,1,1,1,0,18,0,5,6,5,17.333333333333332,0,0,5,8,5,18.571428571428573,0,12.4,0.5,1.79,2 +Student_01285,1,1,9670,1,1,1,1,19,37,5,7,124.0,119.1,0,0,0,1,1,1,0,20,0,5,7,4,11.0,0,0,5,7,4,11.5,0,9.4,-0.8,-3.12,2 +Student_01286,1,17,9853,1,2,1,1,19,38,3,3,127.0,121.1,1,0,0,1,1,0,0,19,0,7,10,6,13.666666666666666,0,0,7,9,6,12.5,0,12.4,0.5,1.79,0 +Student_01287,1,1,9070,1,2,1,1,1,1,4,9,129.0,132.9,1,0,0,1,1,1,0,20,0,6,9,6,11.375,0,0,6,6,5,13.8,0,7.6,2.6,0.32,1 +Student_01288,1,1,9238,1,1,1,1,19,1,9,9,137.0,132.8,0,0,0,1,1,0,0,19,0,6,6,6,12.833333333333334,0,0,6,8,6,11.833333333333334,0,10.8,1.4,1.74,2 +Student_01289,1,1,9773,1,1,1,1,36,37,0,0,120.0,126.7,1,0,0,1,1,0,0,20,0,6,9,5,12.6,0,0,6,11,4,11.5,0,7.6,2.6,0.32,2 +Student_01290,1,1,9500,1,1,1,1,NA,19,9,7,110.0,105.8,1,0,0,1,1,0,0,22,0,7,8,6,14.333333333333334,0,0,8,9,7,13.771428571428572,0,11.1,0.6,2.02,2 +Student_01291,1,17,9119,1,2,1,1,1,19,9,8,120.0,117.2,0,0,0,1,1,1,0,18,0,5,8,4,13.5,0,0,6,10,6,13.625,0,11.1,0.6,2.02,1 +Student_01293,1,44,9003,1,1,39,1,1,19,9,NA,120.0,120.0,0,0,0,1,1,0,0,22,2,6,15,3,11.75,0,0,6,12,2,10.0,0,13.9,-0.3,0.79,0 +Student_01294,1,17,9119,1,5,1,11,4,12,2,9,124.0,119.5,1,0,0,1,1,0,1,20,0,5,5,5,14.8,0,0,5,5,5,17.6,0,8.9,1.4,3.51,2 +Student_01295,2,39,9003,1,1,1,1,1,41,9,3,168.0,153.9,0,0,1,0,1,0,0,34,0,6,7,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_01296,2,39,NA,0,1,19,1,1,1,4,4,133.1,130.0,0,0,0,1,1,0,0,24,0,6,14,1,10.0,0,0,5,5,0,0.0,0,16.2,0.3,-0.92,0 +Student_01297,1,39,9670,1,2,1,1,34,34,0,0,150.0,107.0,1,0,0,1,1,0,0,26,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_01298,1,39,9500,1,1,1,1,37,37,9,6,140.0,132.8,0,0,0,1,1,0,0,35,0,7,10,4,12.6,0,0,7,9,5,12.38,0,12.4,0.5,1.79,0 +Student_01299,1,1,9991,0,1,1,1,2,37,4,9,145.0,127.5,1,0,0,1,1,0,0,22,0,5,9,5,12.428571428571429,1,0,5,7,5,11.8,0,7.6,2.6,0.32,2 +Student_01300,1,18,9254,1,1,1,1,38,38,5,5,118.0,123.3,1,0,0,1,1,0,0,26,0,6,10,4,10.0,0,0,6,11,3,12.0,0,9.4,-0.8,-3.12,1 +Student_01302,1,1,9254,1,5,1,1,3,19,3,9,120.0,114.8,1,0,0,0,1,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_01303,1,44,171,1,1,39,1,3,3,2,2,140.0,140.0,0,0,1,1,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,2 +Student_01304,1,51,9670,1,1,1,1,3,3,1,10,126.0,NA,0,0,1,1,1,0,0,21,5,11,12,10,12.1,0,2,8,9,8,13.333333333333334,0,11.1,0.6,2.02,2 +Student_01305,1,1,9773,1,2,1,1,1,19,7,7,137.0,133.2,1,0,0,1,NA,1,0,19,0,6,7,6,14.714285714285714,0,0,6,6,6,15.0,0,13.9,-0.3,0.79,2 +Student_01306,1,1,9773,1,3,1,1,19,19,9,9,130.0,123.0,1,0,0,1,0,0,0,18,0,6,6,6,12.666666666666666,0,0,6,7,6,12.833333333333334,0,12.7,3.7,-1.7,2 +Student_01309,1,18,9500,1,1,1,1,37,38,5,7,140.0,126.0,1,0,0,1,0,0,0,18,0,8,8,7,13.314285714285717,0,0,8,8,7,13.314285714285717,0,12.7,3.7,-1.7,2 +Student_01310,1,1,9500,1,3,1,1,38,38,9,9,132.0,119.3,1,0,0,1,0,0,0,19,0,8,8,7,11.98857142857143,0,0,8,8,7,11.98857142857143,0,10.8,1.4,1.74,2 +Student_01311,1,53,NA,1,1,42,1,1,19,143,172,130.0,133.8,1,0,0,1,0,0,0,21,6,11,17,11,11.545454545454543,0,3,9,13,8,12.88888888888889,0,8.9,1.4,3.51,2 +Student_01312,1,1,9085,1,1,1,1,37,37,9,6,130.0,126.5,1,0,0,1,0,1,0,18,0,6,13,6,16.46153846153846,0,0,6,8,6,13.875,0,15.5,2.8,-4.06,2 +Student_01314,1,1,9500,1,4,1,1,3,39,2,3,144.0,129.0,1,0,0,1,0,0,0,18,0,7,8,7,12.65,0,0,8,9,8,13.411111111111111,0,16.2,0.3,-0.92,0 +Student_01315,1,1,9670,1,1,1,1,19,1,5,7,127.0,118.3,1,0,0,1,0,0,0,18,0,6,7,6,12.333333333333334,0,0,6,10,3,12.0,0,13.9,-0.3,0.79,1 +Student_01316,1,17,9500,1,2,1,1,19,37,9,7,131.0,129.8,1,0,0,1,0,0,0,20,0,7,8,6,14.37,0,0,8,10,7,14.65,0,12.4,0.5,1.79,2 +Student_01317,1,17,9085,1,2,1,1,1,19,4,9,123.0,113.6,1,0,0,1,0,0,0,19,0,5,13,3,12.0,2,0,5,8,4,11.75,0,9.4,-0.8,-3.12,1 +Student_01318,1,1,9773,1,5,1,1,34,38,0,8,130.0,128.3,1,0,0,0,0,1,0,18,0,6,12,3,12.0,0,0,6,15,3,10.666666666666666,0,7.6,2.6,0.32,0 +Student_01320,1,17,9853,1,2,1,1,1,38,4,8,131.0,121.9,1,0,0,1,0,0,0,19,0,6,10,5,12.6,0,0,6,7,5,11.2,0,10.8,1.4,1.74,2 +Student_01321,1,1,9238,1,5,3,1,1,38,9,3,135.0,129.4,0,0,1,1,0,0,0,18,0,6,6,6,12.166666666666666,0,0,6,6,6,12.333333333333334,0,10.8,1.4,1.74,2 +Student_01323,1,1,9500,1,5,1,1,38,38,9,9,145.0,125.5,1,0,0,1,0,1,0,18,0,8,8,8,13.76375,0,0,8,8,8,13.76375,0,9.4,-0.8,-3.12,2 +Student_01324,1,17,NA,1,6,1,1,38,38,5,5,118.0,117.8,1,0,0,NA,0,1,0,19,0,7,11,6,12.4,0,0,7,8,6,12.8,0,11.1,0.6,2.02,2 +Student_01325,1,17,9147,1,3,1,1,3,38,2,10,125.0,118.7,1,0,0,1,0,0,0,18,0,5,16,4,10.666666666666666,0,0,5,11,2,12.0,0,13.9,-0.3,0.79,1 +Student_01326,1,1,9500,1,2,1,1,37,37,9,9,152.0,139.0,1,0,0,1,0,0,0,18,0,7,7,6,14.333333333333334,0,0,7,7,6,14.333333333333334,0,7.6,2.6,0.32,2 +Student_01328,1,17,9254,1,1,1,1,34,38,0,7,137.0,137.7,1,0,1,0,0,0,0,19,0,6,14,1,10.0,0,0,6,13,0,0.0,0,7.6,2.6,0.32,0 +Student_01330,1,1,9085,1,1,1,1,4,1,2,9,120.0,113.4,0,0,0,1,0,0,0,18,0,6,14,4,11.5,0,0,6,17,3,13.75,0,11.1,0.6,2.02,1 +Student_01331,1,17,9556,1,3,1,1,19,38,9,7,131.0,128.5,0,0,0,1,0,1,0,18,0,7,9,7,12.855555555555556,0,0,8,8,8,13.9125,0,12.7,3.7,-1.7,2 +Student_01332,1,1,9500,1,1,1,1,1,1,3,10,141.0,142.8,0,0,0,NA,0,0,0,18,0,7,7,7,13.7,0,0,8,9,8,13.994444444444444,0,11.1,0.6,2.02,2 +Student_01333,1,NA,9130,1,1,1,1,3,1,1,3,144.0,137.7,0,0,0,0,0,0,0,23,0,5,9,0,0.0,3,1,5,10,1,12.0,3,10.8,1.4,1.74,0 +Student_01334,1,1,9238,1,1,1,1,19,37,7,7,107.0,103.5,1,0,0,1,0,0,0,20,0,6,13,3,11.2,0,0,6,9,4,12.0,0,16.2,0.3,-0.92,1 +Student_01335,1,1,9500,1,1,1,1,38,38,5,5,133.0,123.2,0,0,0,1,0,0,0,18,0,7,7,7,13.285714285714286,0,0,8,9,8,13.333333333333334,0,16.2,0.3,-0.92,2 +Student_01336,1,17,9853,1,2,1,1,1,19,2,10,126.0,126.0,1,0,0,1,0,0,0,19,0,6,9,5,13.0,0,0,6,8,5,10.4,0,7.6,2.6,0.32,1 +Student_01337,1,39,9500,1,1,1,1,1,38,3,7,133.1,121.7,0,0,0,1,0,1,0,27,0,7,8,6,12.6,0,0,7,9,6,11.685714285714283,0,12.4,0.5,1.79,1 +Student_01338,1,17,9147,1,1,1,1,37,37,9,6,147.0,142.8,1,0,1,0,0,1,0,19,0,5,5,5,12.8,0,0,5,5,4,12.0,0,11.1,0.6,2.02,1 +Student_01339,1,NA,9130,1,1,1,1,1,19,9,9,120.0,120.0,1,0,0,1,0,0,0,21,0,6,14,5,11.5,1,0,6,13,5,11.0,1,15.5,2.8,-4.06,0 +Student_01340,1,18,9500,1,1,1,1,37,38,7,8,130.0,119.3,1,0,0,1,0,1,0,19,0,8,8,7,11.4,0,0,8,8,7,11.4,0,10.8,1.4,1.74,2 +Student_01342,1,1,9773,1,5,1,1,19,19,9,9,138.0,139.4,1,0,0,1,0,0,0,18,0,6,7,5,12.8,0,0,6,10,4,NA,0,10.8,1.4,1.74,2 +Student_01343,1,17,9085,1,1,1,1,19,38,7,7,124.0,113.9,1,0,0,1,0,1,0,20,0,5,8,5,12.0,1,0,5,8,4,15.0,1,12.7,3.7,-1.7,2 +Student_01344,1,1,9853,1,1,1,1,37,37,9,7,133.0,124.6,1,0,0,1,0,1,0,18,0,6,8,5,13.0,0,0,6,9,5,13.5,0,9.4,-0.8,-3.12,2 +Student_01345,1,17,9070,1,1,1,1,1,1,4,8,122.0,123.8,1,0,1,0,0,1,0,18,0,6,6,6,11.833333333333334,0,0,6,8,6,11.0,0,12.7,3.7,-1.7,0 +Student_01346,1,1,9085,1,3,1,1,1,3,4,4,138.0,126.3,1,0,0,1,0,0,0,18,0,6,8,6,14.0,0,0,6,9,6,13.333333333333334,0,8.9,1.4,3.51,2 +Student_01347,1,17,9773,1,4,1,1,1,1,3,3,134.0,120.4,1,0,0,1,0,1,0,18,0,6,6,6,12.333333333333334,0,0,6,6,6,13.5,0,16.2,0.3,-0.92,2 +Student_01348,1,1,9500,1,3,1,1,1,1,7,7,128.0,120.5,1,0,0,1,0,1,0,19,0,7,10,5,13.04,0,0,7,7,7,12.5,0,12.4,0.5,1.79,1 +Student_01350,1,39,9085,1,1,19,1,19,19,4,9,133.1,139.9,1,0,0,1,0,1,0,24,1,6,7,6,12.5,0,0,6,11,6,12.833333333333334,0,8.9,1.4,3.51,2 +Student_01351,1,1,171,1,1,1,1,1,1,3,3,142.0,133.3,1,0,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,2 +Student_01352,1,1,9500,1,3,1,1,19,19,9,9,141.0,126.0,1,0,0,1,0,0,0,18,0,8,8,7,15.657142857142857,0,0,8,8,7,15.657142857142857,0,12.7,3.7,-1.7,2 +Student_01353,1,1,9070,1,2,NA,1,1,19,4,3,145.0,133.5,0,0,0,1,0,0,0,NA,0,6,6,6,12.166666666666666,0,0,6,6,6,11.333333333333334,0,12.7,3.7,-1.7,2 +Student_01355,1,1,9238,1,1,1,1,1,38,5,8,108.0,105.9,0,0,0,1,0,1,0,20,0,6,11,5,10.6,0,0,6,9,5,11.166666666666666,0,11.1,0.6,2.02,1 +Student_01356,1,1,9085,1,1,1,1,1,12,4,5,132.0,124.3,0,0,0,1,0,0,0,20,0,6,10,6,13.428571428571429,0,0,6,11,5,12.666666666666666,0,13.9,-0.3,0.79,1 +Student_01357,1,39,9773,1,1,1,1,34,37,0,0,140.0,102.5,0,0,0,1,0,0,0,26,0,6,8,4,11.75,0,0,6,12,0,0.0,0,7.6,2.6,0.32,0 +Student_01360,1,42,9119,1,1,1,1,19,37,9,9,120.0,113.8,0,0,0,0,1,0,0,27,0,5,0,0,0.0,0,0,5,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01362,1,1,9500,1,4,1,1,37,38,9,9,139.0,124.0,1,0,0,1,1,1,0,18,0,8,8,7,13.331428571428573,0,0,8,8,7,13.331428571428573,0,10.8,1.4,1.74,2 +Student_01364,1,44,171,1,1,39,1,19,1,9,9,150.0,154.8,1,0,0,1,1,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,2 +Student_01365,1,1,9500,1,1,1,1,19,37,4,9,138.0,141.0,0,0,0,1,1,0,0,19,0,7,7,6,13.7,0,0,7,7,6,13.7,0,7.6,2.6,0.32,2 +Student_01366,1,39,9670,1,1,9,1,6,22,3,3,133.1,120.0,0,0,1,0,1,0,0,26,0,5,5,0,0.0,0,0,5,5,0,0.0,5,9.4,-0.8,-3.12,0 +Student_01369,1,1,9147,1,1,1,1,19,19,7,3,140.0,120.0,1,0,0,1,1,0,0,21,0,5,8,3,10.0,0,0,5,10,4,11.0,0,12.7,3.7,-1.7,0 +Student_01370,1,53,9670,1,1,42,1,1,19,9,9,110.0,114.2,0,0,0,1,1,1,0,23,0,6,7,5,13.0,0,0,6,7,6,12.857142857142858,0,8.9,1.4,3.51,2 +Student_01371,1,39,8014,0,1,38,1,38,37,4,8,133.1,95.5,0,0,0,1,1,0,0,29,0,6,11,6,12.0,0,0,6,6,6,14.0,0,11.1,0.6,2.02,2 +Student_01372,1,1,9500,1,1,1,1,1,1,9,9,129.0,120.0,0,0,0,1,1,0,0,20,0,8,8,7,15.028571428571428,0,0,8,8,7,15.028571428571428,0,12.7,3.7,-1.7,2 +Student_01373,1,1,9238,1,1,1,1,1,19,5,9,116.0,111.1,0,0,0,1,1,0,0,18,0,6,8,6,12.0,0,0,6,7,6,11.714285714285714,0,15.5,2.8,-4.06,2 +Student_01374,1,1,9773,1,1,1,1,1,38,3,5,130.0,128.6,1,0,0,1,1,0,0,19,0,6,8,5,12.0,0,0,6,8,5,12.4,0,9.4,-0.8,-3.12,2 +Student_01375,1,7,9556,1,1,3,1,1,37,4,8,130.0,130.0,0,0,0,0,1,0,0,23,3,7,7,3,NA,0,3,8,8,3,11.333333333333334,4,10.8,1.4,1.74,0 +Student_01376,1,1,171,1,1,1,1,38,1,5,1,116.0,111.1,0,0,0,1,1,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_01377,1,17,9147,1,1,1,1,1,1,9,3,136.0,122.7,1,0,0,1,1,0,0,18,0,5,6,5,12.0,0,0,5,7,4,12.5,0,15.5,2.8,-4.06,1 +Student_01378,1,1,171,1,1,1,1,37,19,7,7,147.0,134.4,1,0,0,1,1,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,2 +Student_01379,1,1,9070,1,5,1,1,19,37,5,5,117.0,131.0,1,0,1,0,1,0,0,21,0,6,6,1,14.0,0,0,6,7,0,0.0,7,9.4,-0.8,-3.12,0 +Student_01380,1,51,9238,1,1,1,1,1,1,5,9,141.0,125.0,0,0,0,1,1,0,0,22,0,6,6,0,0.0,0,0,6,7,0,0.0,0,11.1,0.6,2.02,0 +Student_01381,1,18,9556,1,1,1,1,3,19,2,8,133.1,106.0,1,0,0,1,1,0,0,21,0,7,8,7,12.375,0,0,7,11,5,12.583333333333334,0,8.9,1.4,3.51,2 +Student_01382,1,39,9500,1,1,1,1,38,19,9,9,133.1,128.0,1,0,0,0,1,0,0,32,0,7,0,0,0.0,0,0,8,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_01384,1,1,9500,1,1,1,1,19,38,9,8,148.0,134.8,1,0,0,1,1,0,0,18,0,7,7,6,13.35,0,0,7,7,6,13.35,0,7.6,2.6,0.32,2 +Student_01385,1,39,9070,1,1,1,1,1,1,5,3,130.0,112.0,1,0,0,1,1,1,0,24,0,6,6,6,15.0,0,0,6,6,2,16.0,0,15.5,2.8,-4.06,2 +Student_01386,1,1,9130,1,1,1,1,19,37,1,9,120.0,116.1,1,0,0,1,1,0,0,22,0,5,9,2,10.5,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_01387,1,43,9130,1,1,1,1,2,3,3,2,120.0,120.0,1,0,0,0,1,0,0,22,0,6,0,0,0.0,0,0,4,6,0,0.0,2,10.8,1.4,1.74,0 +Student_01388,1,1,9147,1,3,1,1,37,37,9,5,133.0,119.7,1,0,0,1,1,0,0,19,0,5,8,5,13.25,0,0,5,6,5,11.833333333333334,0,13.9,-0.3,0.79,2 +Student_01389,1,17,9119,1,6,1,1,37,13,4,90,129.0,117.1,1,0,0,1,1,0,0,19,0,5,10,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_01390,1,1,9085,1,2,1,1,1,19,3,3,118.0,112.4,1,0,0,1,1,0,0,21,0,5,7,4,11.5,0,0,5,15,3,10.6,4,10.8,1.4,1.74,1 +Student_01391,1,1,9500,1,2,1,1,1,1,2,7,NA,131.0,1,0,0,1,0,1,0,18,0,8,8,8,13.88125,0,0,8,8,8,13.88125,0,9.4,-0.8,-3.12,2 +Student_01392,1,1,9254,1,2,1,1,3,19,3,10,127.0,130.9,1,0,0,1,0,0,0,18,0,6,8,6,11.333333333333334,0,0,6,8,5,12.6,0,9.4,-0.8,-3.12,2 +Student_01393,1,1,171,1,1,1,1,19,19,9,9,131.0,134.9,1,0,1,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_01394,1,17,9238,1,1,1,1,1,19,4,9,132.0,127.1,1,0,0,1,0,0,0,19,0,6,7,6,12.857142857142858,0,0,6,7,6,13.666666666666666,0,13.9,-0.3,0.79,2 +Student_01395,1,17,9773,1,5,1,1,38,38,191,175,113.0,110.2,1,0,1,1,0,0,0,19,0,6,6,5,11.6,0,0,6,6,6,12.5,0,8.9,1.4,3.51,2 +Student_01396,1,17,9254,1,1,1,1,12,1,9,3,115.0,108.7,1,0,0,1,0,1,0,18,0,6,9,5,11.4,0,0,6,6,6,11.333333333333334,0,12.4,0.5,1.79,2 +Student_01397,1,1,9130,1,1,1,1,1,1,3,9,133.1,138.0,1,0,0,1,0,0,0,20,0,6,11,6,13.333333333333334,0,0,6,10,6,13.0,0,16.2,0.3,-0.92,1 +Student_01398,1,44,9070,1,1,39,1,12,37,3,9,150.0,147.7,0,0,1,1,0,1,0,22,2,7,7,7,13.571428571428571,0,5,9,9,9,13.77777777777778,0,12.4,0.5,1.79,2 +Student_01399,2,39,9556,1,1,19,1,37,38,9,9,133.1,123.0,0,0,0,1,0,0,0,31,0,7,13,6,11.833333333333334,0,0,7,8,7,12.228571428571428,0,12.4,0.5,1.79,2 +Student_01400,1,17,9853,1,1,1,1,19,19,9,8,141.0,142.8,0,0,0,1,0,1,0,19,0,7,7,7,14.428571428571429,0,0,7,7,7,14.142857142857142,0,16.2,0.3,-0.92,2 +Student_01401,1,1,171,1,2,1,1,1,3,3,3,140.0,138.3,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,1 +Student_01402,1,NA,9254,1,2,1,1,38,38,9,7,136.0,125.2,1,0,0,1,0,1,0,18,0,6,8,6,12.285714285714286,0,0,6,9,5,12.4,0,8.9,1.4,3.51,2 +Student_01403,1,1,9085,1,1,1,1,12,1,1,90,140.0,141.8,0,0,0,1,0,0,0,21,0,5,7,5,14.4,0,0,5,5,5,13.8,0,7.6,2.6,0.32,2 +Student_01404,1,17,9500,1,5,1,1,38,1,9,7,143.0,130.6,1,0,0,1,0,1,0,18,0,7,8,7,13.15,0,0,8,9,8,15.06875,0,13.9,-0.3,0.79,2 +Student_01405,1,44,9147,1,1,39,22,2,37,2,8,130.0,130.0,0,0,1,0,1,0,1,25,0,5,6,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_01407,1,18,9500,1,2,1,1,38,37,5,5,129.0,119.0,1,0,0,1,0,1,0,19,0,8,8,7,12.342857142857143,0,0,8,8,7,12.342857142857143,0,10.8,1.4,1.74,2 +Student_01408,1,1,9773,1,2,1,1,38,1,9,9,132.0,124.3,1,0,0,1,0,0,0,19,0,6,6,5,12.2,0,0,6,7,5,10.8,0,10.8,1.4,1.74,1 +Student_01410,1,15,9147,1,1,1,1,38,1,9,1,150.0,150.0,0,0,0,1,1,0,0,19,0,5,5,5,10.6,0,0,5,8,5,11.6,0,12.4,0.5,1.79,2 +Student_01411,1,39,8014,0,1,19,1,37,37,9,5,133.1,135.5,0,0,0,1,0,0,0,58,0,6,6,0,0.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_01413,1,43,9670,1,1,1,22,37,37,9,9,127.0,127.0,1,0,0,1,1,0,1,23,3,9,11,6,10.5,0,4,10,10,10,11.7,0,9.4,-0.8,-3.12,2 +Student_01414,1,1,9773,1,2,1,1,37,37,9,9,122.0,126.9,1,0,0,1,0,1,0,19,0,6,11,4,11.0,0,0,6,11,3,11.666666666666666,0,9.4,-0.8,-3.12,1 +Student_01415,1,18,9500,1,3,1,1,19,1,4,7,131.0,127.5,1,0,0,1,0,0,0,18,0,7,7,7,13.457142857142856,0,0,8,8,8,14.5125,0,13.9,-0.3,0.79,2 +Student_01416,1,1,9085,1,2,1,1,19,19,90,90,130.0,122.0,0,0,0,1,0,0,0,20,0,5,6,5,12.6,0,0,5,8,4,12.333333333333334,0,7.6,2.6,0.32,2 +Student_01417,1,17,9085,1,5,1,1,19,19,90,7,130.0,115.8,0,0,0,0,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_01418,1,17,9670,1,1,1,1,3,19,5,5,130.0,121.6,0,0,0,1,0,0,0,18,0,6,6,6,13.666666666666666,0,0,6,8,5,13.6,0,8.9,1.4,3.51,2 +Student_01419,1,17,9147,1,4,1,1,19,19,5,7,122.0,116.4,1,0,1,1,0,1,0,18,0,5,5,5,11.6,0,0,5,5,5,11.8,0,11.1,0.6,2.02,2 +Student_01420,1,39,9130,1,1,1,1,38,38,9,10,114.0,120.0,0,0,0,1,0,0,0,24,0,6,9,6,12.571428571428571,0,0,6,10,5,12.833333333333334,0,11.1,0.6,2.02,0 +Student_01421,1,17,9853,1,4,1,1,37,37,9,5,143.0,127.3,1,0,0,1,0,0,0,18,0,6,7,5,11.8,0,0,6,7,5,11.4,0,10.8,1.4,1.74,0 +Student_01422,1,1,9147,1,3,1,1,1,38,5,7,127.0,123.5,1,0,0,1,0,1,0,19,0,5,5,5,11.6,0,0,5,11,3,12.666666666666666,0,9.4,-0.8,-3.12,1 +Student_01424,1,1,9254,1,1,1,1,38,38,6,6,129.0,118.5,1,0,0,1,0,0,0,18,0,6,6,6,10.666666666666666,0,0,6,6,6,11.5,0,7.6,2.6,0.32,2 +Student_01425,1,1,9130,1,2,1,1,19,37,9,9,140.0,129.5,1,0,0,1,0,0,0,18,0,5,10,4,13.5,1,0,5,5,5,13.4,0,12.7,3.7,-1.7,1 +Student_01427,1,44,9085,1,1,1,1,4,4,2,6,140.0,140.0,0,0,0,1,0,0,0,22,2,6,9,6,13.333333333333334,0,1,6,9,4,11.5,0,13.9,-0.3,0.79,2 +Student_01428,1,1,9254,1,1,1,1,2,37,1,1,143.0,133.2,1,0,0,1,0,0,0,19,0,6,9,5,13.4,0,0,6,16,2,13.5,0,10.8,1.4,1.74,1 +Student_01429,3,17,9238,1,1,1,1,37,37,9,9,138.0,133.5,1,0,0,1,0,1,0,21,0,6,8,3,10.2,0,0,6,13,4,12.25,0,12.7,3.7,-1.7,1 +Student_01431,1,1,9500,1,3,1,1,38,38,5,7,144.0,128.0,1,0,0,1,0,1,0,18,0,8,11,7,12.90857142857143,0,0,8,11,7,12.90857142857143,0,10.8,1.4,1.74,2 +Student_01432,1,1,9853,1,5,1,1,1,12,4,9,123.0,113.2,1,0,0,1,0,0,0,20,0,6,12,4,12.0,0,0,6,11,1,10.0,0,10.8,1.4,1.74,0 +Student_01433,1,1,9254,1,3,1,1,37,38,7,7,129.0,122.0,1,0,0,1,0,1,0,18,0,6,9,6,10.833333333333334,0,0,6,8,5,11.0,0,7.6,2.6,0.32,1 +Student_01434,1,16,9070,1,3,1,1,1,38,4,8,152.0,156.9,1,0,0,1,0,0,0,19,0,6,6,6,15.333333333333334,0,0,6,9,6,15.833333333333334,0,12.7,3.7,-1.7,2 +Student_01435,1,1,9500,1,2,1,1,1,38,9,9,130.0,125.1,1,0,0,1,0,1,0,18,0,7,9,6,12.816666666666668,0,0,8,11,6,12.875,0,11.1,0.6,2.02,1 +Student_01437,1,15,9119,1,1,1,32,1,3,143,152,160.0,160.0,0,0,1,1,0,0,1,19,0,6,11,2,13.5,1,0,5,11,2,11.0,0,8.9,1.4,3.51,1 +Student_01438,2,39,8014,0,1,1,1,37,37,9,9,140.0,101.0,0,0,0,1,0,0,0,35,0,6,7,6,12.5,0,0,6,6,6,12.166666666666666,0,15.5,2.8,-4.06,2 +Student_01439,1,18,9670,1,1,1,1,1,1,9,9,133.0,121.5,1,0,0,1,0,1,0,19,0,6,7,6,13.0,0,0,6,6,6,14.333333333333334,0,12.4,0.5,1.79,2 +Student_01440,1,1,9085,1,1,1,1,38,37,9,6,138.0,126.8,1,0,0,1,1,0,0,18,0,5,6,4,11.75,0,0,5,10,5,12.571428571428571,1,10.8,1.4,1.74,2 +Student_01441,1,1,9670,1,5,1,1,19,19,7,3,142.0,NA,0,0,0,1,1,0,0,19,0,5,5,4,12.5,0,0,5,5,4,14.25,0,7.6,2.6,0.32,2 +Student_01442,1,1,171,1,1,1,1,1,1,9,9,115.0,134.3,1,0,0,1,1,0,0,25,16,17,19,17,11.61111111111111,0,14,17,22,17,12.055555555555555,0,12.4,0.5,1.79,2 +Student_01443,1,17,9254,1,6,1,1,1,1,4,3,125.0,120.5,1,0,0,1,1,0,0,18,0,6,6,6,14.0,0,0,6,6,6,NA,0,11.1,0.6,2.02,2 +Student_01445,1,43,9991,0,1,1,1,1,1,6,6,140.0,100.0,0,0,0,1,1,0,0,34,0,5,5,5,13.8,0,0,5,6,5,13.833333333333334,0,9.4,-0.8,-3.12,2 +Student_01446,1,1,9254,1,2,1,1,4,19,4,3,110.0,114.8,1,0,0,0,1,0,0,18,0,5,6,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_01447,1,1,171,1,1,1,1,3,29,3,5,114.0,111.9,0,0,0,0,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01448,1,17,9119,1,3,1,1,1,19,4,3,138.0,125.4,1,0,0,1,1,1,0,18,0,5,9,4,12.25,0,0,5,9,3,12.333333333333334,0,8.9,1.4,3.51,0 +Student_01449,1,44,9003,1,1,39,1,37,37,9,4,140.0,140.0,0,0,0,1,1,0,0,20,0,6,12,3,11.5,0,0,6,12,3,13.666666666666666,0,12.4,0.5,1.79,0 +Student_01450,1,44,9070,1,1,39,1,1,19,4,4,140.0,140.0,0,0,0,1,1,0,0,25,2,7,9,6,12.571428571428571,0,5,9,9,9,12.555555555555555,0,16.2,0.3,-0.92,2 +Student_01452,1,1,9003,1,1,1,1,19,37,9,9,148.0,131.6,1,0,0,1,1,0,0,19,8,12,17,11,12.0,2,4,12,21,12,12.307692307692308,0,15.5,2.8,-4.06,2 +Student_01453,1,1,171,1,1,1,1,1,1,4,1,132.0,119.4,1,0,0,1,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01455,1,1,9119,1,1,1,1,3,1,2,3,121.0,114.0,0,0,0,1,1,0,0,20,0,5,9,4,11.6,0,0,5,7,4,12.25,2,7.6,2.6,0.32,1 +Student_01456,1,1,9147,1,2,1,1,1,37,4,9,120.0,113.4,1,0,0,1,1,1,0,19,0,5,5,0,0.0,0,0,5,5,0,0.0,0,11.1,0.6,2.02,0 +Student_01457,1,1,9147,1,1,1,1,1,19,4,5,123.0,117.8,0,0,0,1,1,0,0,20,0,5,9,5,12.0,0,0,5,9,4,13.0,0,8.9,1.4,3.51,1 +Student_01458,1,1,9500,1,6,1,1,1,1,3,7,122.0,114.3,1,0,0,1,1,0,0,18,0,7,8,6,13.976666666666668,0,0,8,12,6,12.041666666666666,1,11.1,0.6,2.02,1 +Student_01459,1,1,9670,1,1,1,1,2,38,143,163,136.0,129.7,1,0,0,1,1,0,0,19,0,6,10,4,12.5,0,0,6,12,1,10.0,3,16.2,0.3,-0.92,1 +Student_01461,1,39,9670,1,1,1,1,38,37,7,7,120.0,140.0,0,0,0,1,1,0,0,24,0,6,15,4,10.5,0,0,6,16,4,12.5,0,15.5,2.8,-4.06,0 +Student_01462,1,44,9003,1,1,39,1,38,38,9,8,150.0,150.0,1,0,0,1,1,0,0,20,0,6,8,5,12.857142857142858,0,0,6,11,6,12.3,0,16.2,0.3,-0.92,2 +Student_01463,1,1,9670,1,3,1,1,3,19,2,8,121.0,122.4,1,0,0,1,NA,0,0,19,0,5,7,3,11.666666666666666,0,0,5,5,4,12.0,0,9.4,-0.8,-3.12,1 +Student_01465,1,17,9254,1,2,1,1,19,19,4,3,135.0,135.0,1,0,0,1,1,0,0,20,0,6,8,6,11.833333333333334,0,0,6,9,5,10.4,0,7.6,2.6,0.32,1 +Student_01466,1,43,8014,0,4,1,1,34,34,0,0,116.0,116.2,0,0,0,1,1,0,0,21,9,11,11,11,12.454545454545457,0,3,11,17,8,12.75,0,9.4,-0.8,-3.12,2 +Student_01467,1,17,9119,1,2,1,1,10,12,9,9,120.0,120.4,1,0,0,1,1,0,0,20,0,5,6,3,11.0,0,0,5,6,0,0.0,0,10.8,1.4,1.74,0 +Student_01468,2,17,9119,1,5,1,1,37,38,4,4,126.0,122.9,1,0,0,1,1,0,0,21,0,5,10,4,13.2,0,0,5,7,4,14.25,2,7.6,2.6,0.32,1 +Student_01469,1,1,9773,1,1,1,1,1,19,9,7,170.0,155.0,0,0,0,1,1,1,0,18,0,6,6,6,15.5,0,0,6,6,6,14.166666666666666,0,11.1,0.6,2.02,2 +Student_01471,1,17,9147,1,1,1,1,3,38,3,7,120.0,124.2,1,0,0,1,1,0,0,18,0,5,13,5,12.0,0,0,5,9,4,11.4,0,13.9,-0.3,0.79,1 +Student_01472,1,44,9003,1,1,39,1,3,3,7,1,130.0,130.0,1,0,0,1,1,0,0,20,0,6,12,4,11.6,0,0,6,11,5,11.5,0,15.5,2.8,-4.06,1 +Student_01474,1,17,9773,1,1,1,1,37,37,0,4,117.0,120.5,1,0,0,1,1,0,0,19,0,6,12,0,0.0,1,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01476,1,17,9130,1,1,1,1,19,38,4,7,130.0,122.5,0,0,0,1,1,0,0,19,0,5,11,4,12.0,1,0,5,9,5,12.6,0,9.4,-0.8,-3.12,2 +Student_01477,1,39,9991,0,1,1,1,37,37,9,5,133.0,139.2,1,0,1,1,1,0,0,33,0,5,11,2,12.5,0,0,5,9,2,11.5,1,12.7,3.7,-1.7,0 +Student_01478,1,51,171,1,1,1,1,2,1,3,3,128.0,131.2,1,0,0,1,1,0,0,21,6,12,12,12,13.666666666666666,0,4,11,16,11,13.0,0,8.9,1.4,3.51,2 +Student_01479,2,39,9003,1,1,1,1,1,19,4,4,133.1,120.0,0,0,1,0,1,0,0,25,0,6,17,2,14.5,2,0,6,13,0,0.0,1,15.5,2.8,-4.06,0 +Student_01480,1,1,9085,1,1,1,1,1,1,4,9,123.0,116.7,1,0,0,1,1,1,0,20,0,6,10,4,13.2,0,0,6,8,0,0.0,0,12.4,0.5,1.79,0 +Student_01482,4,39,9773,1,1,19,1,37,37,9,1,133.1,117.5,0,0,0,1,0,0,0,39,0,6,10,4,11.25,0,0,6,6,6,11.333333333333334,0,10.8,1.4,1.74,2 +Student_01484,1,17,9254,1,1,1,1,1,1,9,9,126.0,124.3,0,0,0,1,0,1,0,19,0,6,8,6,11.166666666666666,0,0,6,7,4,13.4,0,16.2,0.3,-0.92,2 +Student_01485,1,39,9500,1,1,19,1,37,37,9,7,133.1,116.0,0,0,0,1,0,1,0,26,0,7,8,6,10.983333333333334,0,0,7,8,6,10.983333333333334,0,7.6,2.6,0.32,2 +Student_01488,1,17,9670,1,1,1,1,1,37,4,9,133.1,96.0,1,0,0,1,0,1,0,25,0,6,8,6,11.285714285714286,0,0,6,10,5,12.2,0,15.5,2.8,-4.06,1 +Student_01489,1,43,8014,0,1,1,1,19,37,8,5,131.0,125.0,0,0,0,1,1,0,0,24,0,6,13,0,NA,3,0,6,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_01490,1,17,9119,1,6,1,1,19,19,4,0,124.0,126.1,1,0,0,1,1,0,0,20,0,5,7,4,13.0,0,0,5,9,5,14.833333333333334,3,NA,2.6,0.32,2 +Student_01491,2,39,9003,1,1,1,1,37,37,9,9,120.0,155.8,0,0,0,1,1,0,0,29,0,6,9,6,16.11111111111111,0,0,6,7,6,13.5,0,13.9,-0.3,0.79,2 +Student_01492,1,1,9773,1,1,1,1,1,3,9,9,133.1,116.0,0,0,0,1,1,0,0,20,0,6,8,6,11.5,0,0,6,8,6,11.0,0,16.2,0.3,-0.92,2 +Student_01493,1,44,9130,1,1,39,1,3,4,2,2,110.0,110.0,1,0,0,1,1,0,0,20,0,6,15,4,10.75,0,0,6,12,2,10.5,0,13.9,-0.3,0.79,0 +Student_01494,1,39,9670,1,1,19,1,19,1,5,8,133.1,97.2,1,0,0,1,1,1,0,24,0,6,10,4,11.6,0,0,6,8,5,13.0,0,11.1,0.6,2.02,2 +Student_01495,1,39,9500,1,1,19,1,1,3,2,2,133.1,100.0,0,0,1,1,1,0,0,24,0,7,21,0,0.0,3,0,7,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_01496,1,7,9119,1,1,40,1,3,1,2,5,140.0,140.0,0,0,0,1,1,0,0,23,0,5,5,5,13.8,0,0,5,7,5,14.142857142857142,0,11.1,0.6,2.02,2 +Student_01497,1,43,9556,1,1,1,1,1,37,5,5,130.0,128.0,1,0,0,1,1,0,0,20,0,7,8,7,13.585714285714284,0,0,8,8,8,14.6875,0,15.5,2.8,-4.06,2 +Student_01498,1,17,9670,1,2,1,1,1,1,4,10,110.0,115.3,1,0,0,1,1,0,0,19,0,6,8,6,13.857142857142858,0,0,6,8,5,13.0,0,15.5,2.8,-4.06,2 +Student_01499,4,39,9003,1,1,1,1,37,37,9,8,140.0,150.0,0,0,0,1,1,0,0,28,0,6,12,5,12.0,0,0,6,10,6,12.333333333333334,0,11.1,0.6,2.02,1 +Student_01500,1,44,9003,1,1,39,1,1,38,4,4,160.0,160.0,1,0,0,1,1,1,0,20,0,6,9,6,13.444444444444445,0,0,6,9,5,12.6,0,13.9,-0.3,0.79,2 +Student_01501,1,1,9070,1,1,1,1,38,37,3,3,138.0,133.1,0,0,0,1,1,0,0,18,0,6,6,6,14.0,0,0,6,7,6,13.857142857142858,0,8.9,1.4,3.51,2 +Student_01502,1,1,9670,1,1,1,1,1,1,90,90,126.0,119.0,1,0,1,1,1,0,0,20,0,6,10,1,12.0,1,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01503,2,39,9991,0,1,1,1,37,19,5,3,120.0,156.0,1,0,0,1,1,0,0,33,0,5,5,5,14.2,0,0,5,6,5,13.833333333333334,0,10.8,1.4,1.74,2 +Student_01504,2,39,9500,1,1,1,NA,37,37,191,183,130.0,163.7,0,0,0,1,0,0,0,35,0,7,11,5,13.34,0,0,7,9,5,10.84,0,12.4,0.5,1.79,1 +Student_01505,1,39,9500,1,1,40,1,37,37,9,7,130.0,130.0,0,0,0,1,0,0,0,27,3,8,12,7,12.457142857142856,0,3,8,12,7,12.457142857142856,0,12.7,3.7,-1.7,1 +Student_01506,1,17,9773,1,5,1,1,38,38,7,7,122.0,123.1,1,0,0,0,0,0,0,19,0,6,12,3,11.0,0,0,6,12,3,12.0,0,9.4,-0.8,-3.12,0 +Student_01507,1,39,9991,0,1,1,41,37,19,9,9,160.0,160.0,0,0,0,1,0,1,1,31,0,5,13,4,10.5,0,0,5,10,4,10.5,0,15.5,2.8,-4.06,1 +Student_01508,1,1,171,1,1,1,1,19,37,7,7,134.0,136.1,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_01509,1,43,9070,1,1,1,1,19,37,7,7,134.0,132.7,1,0,0,1,1,0,0,22,9,13,13,13,14.0,0,7,12,13,12,13.0,0,15.5,2.8,-4.06,2 +Student_01511,1,17,9254,1,1,1,1,1,1,4,8,127.0,126.7,1,0,0,0,1,0,0,22,0,1,1,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,NA,0 +Student_01513,1,17,171,1,1,1,1,19,37,5,9,143.0,156.3,1,0,0,1,1,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,2 +Student_01514,1,10,9254,1,1,1,24,3,1,9,9,115.0,116.1,1,0,0,1,0,0,1,19,0,6,6,6,13.5,0,0,6,6,6,14.333333333333334,0,12.4,0.5,1.79,2 +Student_01515,1,17,9500,1,1,1,1,19,37,9,9,131.0,123.8,1,0,0,1,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01516,1,1,171,1,1,1,1,19,37,9,7,146.0,153.0,1,0,0,1,0,1,0,21,15,17,18,17,13.38888888888889,0,15,17,18,17,14.88888888888889,0,11.1,0.6,2.02,2 +Student_01517,1,7,9500,1,1,5,1,19,1,4,1,140.0,140.0,1,0,0,0,0,0,0,39,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.4,0.5,NA,0 +Student_01519,1,1,171,1,1,1,1,37,19,9,8,133.0,141.4,0,0,0,1,1,1,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,1 +Student_01521,1,39,9991,0,1,1,1,19,19,9,9,120.0,115.0,1,0,0,1,1,0,0,27,0,5,9,1,10.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_01522,2,39,9991,0,1,1,1,37,37,9,9,133.1,168.0,0,0,0,1,1,0,0,29,0,5,5,5,15.2,0,0,5,5,5,15.2,0,11.1,0.6,2.02,2 +Student_01523,1,17,9085,1,1,1,1,NA,1,9,4,130.0,101.3,1,0,0,1,1,0,0,20,0,6,12,4,12.8,0,0,6,17,0,0.0,0,12.4,0.5,1.79,0 +Student_01524,1,1,9670,1,1,1,1,19,1,7,4,125.0,122.6,0,0,0,1,1,0,0,21,0,5,7,5,11.166666666666666,0,0,5,5,4,11.0,0,9.4,-0.8,-3.12,0 +Student_01525,1,1,171,1,1,1,1,3,2,2,2,134.0,141.7,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,1 +Student_01526,1,1,9500,1,1,1,1,1,1,4,3,151.0,132.3,0,0,0,1,1,0,0,19,0,8,9,7,12.828571428571427,0,0,8,9,7,12.828571428571427,0,12.7,3.7,-1.7,2 +Student_01527,1,17,9773,1,1,1,1,1,1,5,1,112.0,111.7,0,0,1,0,1,0,0,19,0,6,6,6,12.5,0,0,6,10,4,12.6,0,15.5,2.8,-4.06,0 +Student_01529,1,15,9254,1,1,1,26,19,1,9,7,140.0,140.0,1,0,0,0,0,0,1,21,0,6,6,6,11.5,0,0,6,10,4,13.25,0,13.9,-0.3,0.79,2 +Student_01530,1,10,9500,1,1,1,24,3,3,2,9,140.0,140.0,1,0,1,0,0,0,1,23,0,8,11,7,11.328571428571427,0,0,8,11,7,11.328571428571427,0,12.7,3.7,-1.7,0 +Student_01531,4,39,9003,1,1,1,1,19,19,9,4,133.1,100.7,0,0,0,1,0,0,0,39,0,6,15,2,13.0,2,0,6,13,3,13.0,1,15.5,2.8,-4.06,1 +Student_01532,1,17,9500,1,3,1,1,38,1,9,5,143.0,133.8,1,0,0,1,0,0,0,18,0,7,7,6,13.033333333333331,0,0,7,7,6,13.033333333333331,0,7.6,2.6,0.32,2 +Student_01533,2,15,9773,1,1,1,41,37,37,9,6,133.1,100.0,0,0,0,1,0,0,1,59,0,6,8,6,12.166666666666666,0,0,6,7,4,11.75,0,11.1,0.6,2.02,2 +Student_01534,1,7,9119,1,1,4,1,4,3,2,7,180.0,180.0,0,0,1,1,1,0,0,30,0,5,6,4,14.5,0,0,5,10,3,16.2,0,13.9,-0.3,0.79,1 +Student_01535,1,1,9085,1,1,1,1,1,38,9,9,136.0,130.8,1,0,0,1,0,0,0,18,0,5,7,5,14.4,1,0,5,5,5,13.6,0,12.7,3.7,-1.7,2 +Student_01537,1,39,9500,1,1,1,1,37,19,9,8,130.0,106.2,1,0,0,1,0,0,0,27,0,7,14,0,0.0,0,0,7,14,0,0.0,0,11.1,0.6,2.02,0 +Student_01538,1,1,9238,1,1,1,1,38,19,9,10,141.0,125.6,1,0,0,1,0,1,0,18,0,6,6,6,12.666666666666666,0,0,6,6,6,12.0,0,9.4,-0.8,-3.12,2 +Student_01539,1,18,9853,1,5,1,1,38,19,7,7,121.0,117.5,1,0,1,0,0,0,0,20,0,6,14,2,12.0,0,0,6,14,3,11.666666666666666,0,10.8,1.4,1.74,0 +Student_01540,2,39,9119,1,1,3,1,37,37,4,7,120.0,122.5,0,0,0,0,0,0,0,32,0,5,6,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_01541,1,17,9147,1,1,1,1,38,37,3,5,129.0,132.9,1,0,0,1,0,0,0,19,0,5,5,3,11.666666666666666,0,0,5,10,4,10.8,0,9.4,-0.8,-3.12,0 +Student_01544,1,7,9130,1,1,2,6,42,1,4,9,133.1,100.0,0,0,0,1,1,0,1,35,0,7,8,0,0.0,1,0,6,9,0,0.0,0,8.9,1.4,3.51,0 +Student_01548,2,39,9991,0,1,9,1,34,34,0,0,133.1,118.4,0,0,0,0,0,0,0,39,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_01549,2,7,9254,1,1,2,1,37,37,9,9,100.0,100.0,0,0,0,0,0,0,0,37,0,5,5,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_01550,5,39,9500,1,1,1,1,38,38,9,9,110.0,110.0,0,0,0,0,0,0,0,37,0,8,8,0,0.0,1,0,8,8,0,0.0,1,12.7,3.7,-1.7,0 +Student_01551,2,43,8014,0,1,1,1,34,34,0,0,133.1,100.0,0,0,0,1,0,1,0,35,11,16,16,16,12.6875,0,11,13,13,13,12.0,0,9.4,-0.8,-3.12,2 +Student_01552,1,43,9147,1,1,1,1,37,37,9,9,123.0,106.2,0,0,0,1,0,0,0,49,9,13,22,10,10.4,0,4,9,18,6,10.666666666666666,0,12.7,3.7,-1.7,2 +Student_01554,1,1,9085,1,2,1,1,1,38,5,5,130.0,122.3,1,0,0,1,0,0,0,18,0,5,10,5,14.333333333333334,2,0,5,8,5,13.0,1,9.4,-0.8,-3.12,2 +Student_01555,1,39,8014,0,1,1,1,37,37,9,9,133.1,112.5,0,0,0,1,0,1,0,30,0,7,7,6,14.666666666666666,1,0,6,7,6,14.333333333333334,0,10.8,1.4,1.74,2 +Student_01556,1,1,9500,1,2,1,1,NA,19,2,7,97.0,98.1,1,0,0,1,0,0,0,21,0,7,7,7,12.835714285714284,0,0,8,8,8,14.23125,0,11.1,0.6,2.02,2 +Student_01558,1,17,9147,1,1,1,1,1,38,6,6,139.0,143.6,1,0,1,1,NA,0,0,18,0,5,9,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,1 +Student_01559,1,16,171,1,1,1,NA,37,37,9,9,150.0,134.6,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,0 +Student_01560,1,1,9500,1,3,1,NA,3,19,2,10,141.0,126.8,1,0,0,1,1,0,0,18,0,8,8,8,13.24875,0,0,8,8,8,13.24875,0,9.4,-0.8,-3.12,2 +Student_01561,1,15,33,1,1,1,41,2,3,2,4,133.1,100.0,0,0,0,1,1,0,1,20,0,7,10,7,12.857142857142858,0,0,7,7,4,12.75,0,8.9,1.4,3.51,1 +Student_01564,1,44,9130,1,1,39,1,19,19,5,5,140.0,140.0,1,0,1,0,0,0,0,20,1,6,11,3,12.0,0,0,6,11,2,11.0,0,12.4,0.5,1.79,1 +Student_01566,1,17,9238,1,6,1,1,1,19,7,7,135.0,126.6,1,0,0,1,0,1,0,19,0,6,8,6,13.625,0,0,6,7,6,12.166666666666666,0,NA,3.7,-1.7,2 +Student_01567,1,17,9500,1,5,1,1,19,38,9,5,144.0,130.7,1,0,0,1,0,1,0,18,0,7,8,7,14.85,0,0,8,9,8,15.61111111111111,0,13.9,-0.3,0.79,2 +Student_01568,1,1,9147,1,2,1,1,1,19,4,4,108.0,105.9,1,0,0,1,1,0,0,21,0,5,9,4,10.75,0,0,5,6,5,11.4,0,11.1,0.6,2.02,2 +Student_01569,1,15,9556,1,1,1,26,19,1,9,4,137.0,137.0,0,0,1,1,0,0,1,19,0,7,11,0,0.0,4,0,7,11,2,11.666666666666666,0,8.9,1.4,3.51,1 +Student_01570,1,43,9130,1,1,1,NA,37,37,9,6,133.1,100.0,0,0,0,1,0,0,1,37,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,NA,0 +Student_01572,1,39,9003,1,1,19,1,37,37,9,10,NA,120.0,0,0,1,0,1,0,0,38,0,6,8,0,0.0,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_01573,6,39,9991,0,1,12,1,37,37,90,90,130.0,119.0,1,0,0,0,1,0,0,55,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_01575,5,7,9991,0,1,2,1,37,37,6,6,120.0,120.0,0,0,0,1,0,0,0,46,6,8,12,8,12.375,0,4,9,11,5,12.4,0,8.9,1.4,3.51,2 +Student_01576,1,NA,171,1,4,1,1,19,19,4,4,131.0,119.8,1,1,0,1,0,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,2 +Student_01577,2,39,9670,1,2,19,1,37,37,9,9,133.1,135.6,0,0,0,1,0,0,0,46,0,6,10,5,11.4,0,0,6,9,4,13.75,0,12.4,0.5,1.79,0 +Student_01578,1,39,9991,0,1,1,1,19,37,5,5,100.0,120.7,0,0,0,1,0,0,0,28,0,5,9,4,11.25,0,0,5,7,4,13.0,0,7.6,2.6,NA,1 +Student_01580,1,16,171,1,1,1,1,38,37,9,9,158.0,164.3,1,0,0,1,1,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,1 +Student_01581,1,1,9773,1,1,1,1,37,37,9,7,146.0,149.2,1,0,0,1,1,1,0,21,0,6,6,6,13.5,0,0,6,6,6,14.166666666666666,0,12.7,3.7,-1.7,2 +Student_01583,1,43,9991,0,1,1,1,19,37,3,9,120.0,100.0,0,0,0,1,NA,0,0,34,0,5,9,0,0.0,0,0,5,10,1,11.0,0,13.9,-0.3,0.79,0 +Student_01584,1,17,9853,1,1,1,1,37,38,9,9,119.0,125.0,1,0,0,1,0,1,0,21,0,6,9,5,12.0,0,0,6,8,5,11.2,0,10.8,1.4,1.74,0 +Student_01585,1,1,9773,1,1,1,1,37,19,9,9,132.0,131.0,1,0,0,1,0,1,0,18,0,6,8,5,13.0,0,0,6,7,6,13.0,0,15.5,2.8,-4.06,2 +Student_01586,1,1,171,1,1,1,1,29,38,9,8,130.0,122.0,1,0,0,1,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_01587,1,1,9147,1,1,1,1,38,37,7,7,132.0,131.3,1,0,0,1,0,0,0,18,0,5,8,4,12.0,0,0,5,8,4,12.25,0,9.4,-0.8,-3.12,1 +Student_01588,1,17,9119,1,2,1,1,1,2,3,3,133.1,117.0,1,0,0,1,1,0,0,21,0,5,10,5,11.166666666666666,0,0,5,10,3,10.8,0,12.4,0.5,1.79,1 +Student_01590,1,17,8014,0,2,1,1,1,19,4,99,134.0,126.0,1,0,0,1,1,0,0,22,0,6,7,6,12.666666666666666,0,0,6,6,6,12.166666666666666,0,7.6,2.6,0.32,2 +Student_01591,1,44,9003,1,1,39,1,1,19,4,7,120.0,120.0,0,0,0,1,1,0,0,23,1,6,6,1,11.0,0,0,6,8,0,0.0,0,15.5,2.8,NA,0 +Student_01593,1,1,9147,1,4,1,1,19,38,5,5,120.0,NA,1,0,0,1,1,0,0,18,0,5,6,4,11.5,0,0,5,12,2,10.333333333333334,0,10.8,1.4,1.74,1 +Student_01594,1,1,171,1,3,1,1,38,37,9,3,129.0,127.3,1,0,1,0,1,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01595,1,17,9147,1,1,1,1,1,38,9,9,118.0,118.4,1,0,0,1,1,0,0,19,0,5,10,2,10.5,0,0,5,5,4,11.75,0,12.4,0.5,1.79,1 +Student_01596,1,1,9670,1,1,1,1,1,37,4,9,127.0,128.1,0,0,0,1,1,0,0,19,0,5,8,4,12.5,0,0,5,6,4,11.0,0,7.6,2.6,0.32,1 +Student_01597,1,1,9500,1,2,1,1,37,37,9,9,133.1,99.0,1,0,0,1,1,0,0,22,0,7,9,6,12.833333333333334,0,0,8,12,6,12.5,0,16.2,0.3,-0.92,1 +Student_01598,1,1,9773,1,1,1,1,19,1,9,9,164.0,161.2,0,0,0,1,1,1,0,18,0,6,7,6,15.571428571428571,0,0,6,7,6,16.142857142857142,0,13.9,-0.3,0.79,2 +Student_01600,1,17,9773,1,1,1,1,38,38,9,9,117.0,111.1,0,0,1,1,1,0,0,19,0,6,6,4,11.25,0,0,6,6,3,11.333333333333334,0,16.2,0.3,-0.92,0 +Student_01601,1,1,171,1,4,1,1,1,1,0,3,131.0,149.9,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,2 +Student_01602,1,17,9670,1,6,1,1,1,19,4,10,110.0,111.3,0,0,0,1,1,0,0,21,0,6,10,6,12.285714285714286,0,0,6,11,4,14.25,0,15.5,2.8,-4.06,1 +Student_01603,1,1,9254,1,2,1,1,1,19,4,1,125.0,121.5,1,0,0,1,1,0,0,18,0,6,12,5,11.0,0,0,6,11,3,10.333333333333334,0,9.4,-0.8,-3.12,1 +Student_01604,1,44,9003,1,1,39,1,19,38,6,6,120.0,120.0,1,0,0,1,1,0,0,19,0,6,8,6,12.142857142857142,0,0,6,11,5,13.6,0,12.4,0.5,1.79,2 +Student_01605,1,39,9003,1,1,19,1,1,19,9,8,133.1,120.0,0,0,1,0,1,0,0,27,0,6,11,2,11.5,0,0,6,7,0,0.0,0,8.9,1.4,3.51,0 +Student_01606,1,53,9003,1,1,42,1,38,38,9,9,130.0,130.0,1,0,1,1,1,0,0,20,7,12,16,11,12.545454545454543,0,5,10,12,8,11.625,0,8.9,1.4,3.51,1 +Student_01607,1,1,9254,1,5,1,1,3,19,3,9,101.0,98.9,1,0,0,1,1,0,0,20,0,6,10,4,13.0,0,0,6,6,6,13.0,0,12.4,0.5,1.79,2 +Student_01608,1,1,9500,1,6,1,1,4,3,2,1,141.0,136.3,1,0,0,1,1,0,0,18,0,8,9,8,12.8875,1,0,8,9,8,12.8875,1,9.4,-0.8,-3.12,2 +Student_01609,1,17,9773,1,1,1,1,38,19,9,10,128.0,125.2,1,0,0,1,1,0,0,18,0,6,6,6,12.666666666666666,0,0,6,7,5,13.6,0,12.4,0.5,1.79,1 +Student_01610,1,1,9070,1,2,1,1,38,19,7,7,145.0,130.0,1,0,0,1,1,0,0,18,0,6,7,6,12.833333333333334,0,0,6,7,6,12.571428571428571,0,8.9,1.4,3.51,2 +Student_01615,2,39,8014,0,1,1,1,38,37,5,3,NA,110.5,0,0,0,1,0,1,0,36,0,6,6,6,11.833333333333334,0,0,6,6,6,11.5,0,10.8,1.4,1.74,2 +Student_01616,2,39,9085,1,1,19,1,19,19,9,5,133.1,101.0,1,0,0,1,0,0,0,26,0,6,21,3,12.666666666666666,0,0,6,15,2,11.0,0,15.5,2.8,-4.06,0 +Student_01617,1,1,9085,1,1,1,1,37,38,6,9,121.0,121.0,0,0,0,1,0,0,0,19,0,5,9,4,13.75,1,0,5,8,4,14.5,0,7.6,2.6,0.32,2 +Student_01618,1,39,8014,0,1,1,1,37,1,7,4,120.0,95.0,1,0,0,1,0,0,0,24,0,6,8,5,11.4,0,0,6,8,5,11.8,0,15.5,2.8,-4.06,0 +Student_01619,1,1,9773,1,2,1,109,19,1,9,9,130.0,126.9,1,0,0,1,0,1,1,19,0,6,8,6,13.166666666666666,0,0,6,6,6,13.0,0,11.1,0.6,2.02,0 +Student_01620,1,42,9670,1,1,1,1,1,1,9,10,130.0,116.3,1,0,0,1,0,1,0,20,3,7,10,6,12.833333333333334,0,2,8,8,5,11.8,0,12.7,3.7,-1.7,2 +Student_01621,1,18,9670,1,1,1,1,19,3,9,7,128.0,120.0,1,0,0,1,0,0,0,19,0,6,8,6,14.125,0,0,6,10,5,14.5,0,11.1,0.6,2.02,2 +Student_01623,2,39,9556,1,1,1,1,37,37,9,4,120.0,150.0,0,0,0,0,0,0,0,50,0,7,18,6,10.25,0,0,7,14,4,11.25,0,12.7,3.7,-1.7,0 +Student_01625,1,42,9853,1,1,1,1,1,19,4,7,120.0,111.3,0,0,0,1,0,0,0,24,9,13,17,10,11.5,0,7,13,18,9,NA,0,16.2,0.3,-0.92,0 +Student_01627,1,1,9085,1,1,1,1,37,2,9,4,127.0,123.2,1,0,0,1,0,1,0,18,0,6,7,6,15.714285714285714,0,0,6,17,5,12.77777777777778,0,12.4,0.5,1.79,2 +Student_01628,1,44,9991,0,1,39,1,37,37,5,5,130.0,130.0,1,0,0,1,1,0,0,32,2,6,9,4,12.5,0,3,7,7,4,11.0,0,9.4,-0.8,-3.12,0 +Student_01630,1,39,NA,1,1,1,1,37,38,9,8,120.0,100.0,0,0,1,1,1,0,0,24,0,5,11,0,0.0,0,0,5,5,0,0.0,0,16.2,0.3,-0.92,0 +Student_01632,2,39,9773,1,1,19,1,19,19,9,4,NA,131.0,0,0,1,0,1,0,0,42,0,4,5,0,0.0,0,0,4,4,0,0.0,0,13.9,-0.3,0.79,0 +Student_01633,2,39,9991,0,1,12,1,37,37,9,9,133.1,133.8,1,0,0,1,1,0,0,52,0,5,5,5,13.6,0,0,5,5,5,14.2,0,7.6,2.6,0.32,2 +Student_01634,1,43,8014,0,1,1,1,38,3,132,122,130.0,100.0,0,0,0,1,1,0,0,54,9,13,14,13,NA,0,7,11,12,11,12.818181818181818,0,12.7,3.7,-1.7,1 +Student_01637,2,39,9130,1,1,1,1,1,19,6,6,130.0,154.0,1,0,0,1,1,0,0,37,1,5,12,3,12.0,2,1,5,8,4,13.0,1,10.8,1.4,1.74,2 +Student_01638,1,1,9500,1,1,1,1,1,1,4,4,121.0,114.9,0,0,0,1,1,1,0,21,0,7,9,6,13.342857142857143,0,0,8,10,7,11.65,0,12.4,0.5,1.79,2 +Student_01639,1,39,9670,1,1,9,1,37,37,5,3,133.1,110.0,0,0,1,1,1,0,0,26,0,5,5,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01642,1,1,9070,1,2,1,1,38,38,9,7,164.0,165.8,1,0,0,1,0,0,0,18,0,6,7,6,14.166666666666666,0,0,6,7,6,14.857142857142858,0,9.4,-0.8,-3.12,2 +Student_01643,1,17,9500,1,5,1,1,1,1,4,4,137.0,127.6,1,0,0,1,0,0,0,18,0,7,7,7,13.528571428571428,0,0,8,9,8,14.655555555555557,0,12.4,0.5,1.79,2 +Student_01644,1,17,8014,0,2,1,1,37,19,9,9,122.0,123.8,0,0,0,1,0,0,0,20,0,6,8,5,12.0,0,0,6,8,6,11.0,0,10.8,1.4,1.74,2 +Student_01645,1,17,9254,1,4,1,1,3,3,3,3,124.0,126.1,1,0,0,1,0,0,0,20,0,5,5,5,11.4,0,0,6,11,1,11.0,0,10.8,1.4,1.74,0 +Student_01646,1,1,171,1,2,1,1,3,19,4,7,120.0,119.7,1,0,0,1,0,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,8.9,1.4,3.51,0 +Student_01647,1,1,171,1,2,1,1,1,19,3,3,117.0,121.6,1,0,0,1,0,0,0,22,6,12,12,12,12.916666666666666,0,4,11,16,11,14.5,0,8.9,1.4,3.51,2 +Student_01648,1,43,9500,1,1,NA,1,1,38,4,7,140.0,100.0,0,0,0,1,0,1,0,18,0,7,8,7,13.6375,0,0,8,8,8,14.3875,0,13.9,-0.3,0.79,2 +Student_01649,1,1,9500,1,5,1,1,19,37,9,7,130.0,127.6,1,0,0,1,0,0,0,18,0,7,10,7,12.9,0,0,8,15,7,12.142857142857142,0,15.5,2.8,-4.06,0 +Student_01652,1,1,9500,1,3,1,1,1,1,4,7,142.0,131.0,1,0,0,1,0,0,0,18,0,8,8,7,14.7,0,0,8,8,7,14.7,0,10.8,1.4,1.74,2 +Student_01654,1,1,9556,1,3,1,1,19,19,3,10,122.0,113.3,1,0,0,1,0,1,0,20,0,7,7,7,13.0,0,0,8,8,8,15.0625,0,12.4,0.5,1.79,2 +Student_01655,1,1,9853,1,2,1,1,1,1,2,9,131.0,121.9,1,0,0,1,0,0,0,20,0,6,6,6,13.5,0,0,6,6,0,0.0,0,12.7,3.7,-1.7,0 +Student_01656,1,1,9085,1,2,1,1,38,1,9,3,120.0,118.3,1,0,0,1,0,0,0,20,0,5,11,5,12.333333333333334,2,0,5,7,5,12.6,0,9.4,-0.8,-3.12,2 +Student_01657,1,1,9147,1,1,1,1,3,19,1,4,131.0,118.8,0,0,0,1,0,0,0,19,0,5,6,5,13.4,0,0,5,6,5,13.0,0,16.2,0.3,-0.92,2 +Student_01658,1,1,9085,1,2,1,1,37,19,9,8,130.0,129.0,0,0,0,1,0,0,0,20,0,5,7,4,11.75,0,0,5,9,2,10.5,0,7.6,2.6,0.32,1 +Student_01659,1,43,171,1,3,1,1,37,37,9,9,120.0,143.3,1,0,0,1,0,1,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_01661,1,53,9085,1,1,42,1,1,19,4,6,160.0,155.7,1,0,0,1,0,0,0,27,7,12,17,11,14.727272727272728,0,4,9,10,7,14.142857142857142,0,8.9,1.4,3.51,2 +Student_01662,1,1,9085,1,2,1,1,3,3,5,2,157.0,153.9,1,0,0,1,0,0,0,18,0,6,7,6,16.571428571428573,0,0,6,6,6,15.666666666666666,0,13.9,-0.3,0.79,2 +Student_01663,1,1,9500,1,1,1,1,19,1,4,4,150.0,137.8,0,0,0,1,0,0,0,18,0,7,10,7,15.145,0,0,8,8,8,15.7425,0,15.5,2.8,-4.06,2 +Student_01665,1,1,9085,1,1,1,1,37,37,9,1,120.0,123.2,0,0,0,1,0,0,0,20,0,5,8,5,14.166666666666666,2,0,5,6,4,11.75,2,9.4,-0.8,-3.12,2 +Student_01666,1,1,9773,1,1,1,1,1,1,4,4,150.0,138.1,1,0,0,1,0,0,0,19,0,6,7,6,14.0,0,0,6,7,5,15.0,0,11.1,0.6,2.02,1 +Student_01667,1,17,9238,1,1,1,1,1,1,5,6,158.0,140.5,0,0,0,1,0,1,0,20,0,6,9,6,11.333333333333334,0,0,6,6,6,12.333333333333334,0,10.8,1.4,1.74,2 +Student_01668,1,1,9500,1,4,1,1,3,19,1,NA,145.0,130.0,1,0,0,1,0,0,0,18,0,8,8,8,13.76125,0,0,8,8,8,13.76125,0,9.4,-0.8,-3.12,2 +Student_01669,1,44,9070,1,1,39,1,1,38,4,6,100.0,104.8,0,0,1,0,0,0,0,22,2,7,9,5,11.6,0,5,9,9,5,10.0,0,12.4,0.5,1.79,0 +Student_01671,1,39,9991,0,1,1,1,1,1,4,2,133.1,127.7,0,0,0,1,0,0,0,25,0,5,12,4,12.5,0,0,5,10,4,11.0,0,13.9,-0.3,0.79,1 +Student_01672,1,1,9085,1,1,1,1,19,3,4,2,148.0,136.5,0,0,0,1,0,0,0,19,0,6,13,6,15.307692307692308,0,0,6,9,6,14.0,0,15.5,2.8,-4.06,2 +Student_01674,1,39,9500,1,1,40,1,1,1,4,NA,130.0,190.0,1,0,0,1,0,0,0,27,1,7,7,7,14.757142857142856,0,1,8,9,8,14.077777777777778,0,16.2,0.3,-0.92,2 +Student_01675,1,17,9500,1,4,1,1,1,1,4,9,136.0,128.5,1,0,0,1,0,0,0,18,0,7,7,6,12.766666666666666,0,0,7,7,6,12.766666666666666,0,7.6,2.6,0.32,2 +Student_01676,1,17,9254,1,3,1,1,1,1,4,4,122.0,126.6,0,0,0,0,0,0,0,18,0,5,5,5,10.4,0,0,6,13,0,0.0,0,10.8,1.4,1.74,0 +Student_01677,1,17,9556,1,1,1,1,3,3,1,7,140.0,131.6,1,0,0,1,1,0,0,19,0,7,0,0,0.0,0,0,7,0,0,0.0,0,11.1,0.6,2.02,0 +Student_01679,1,17,9085,1,1,1,1,37,36,4,90,130.0,127.6,0,0,0,1,1,0,0,23,0,5,6,4,14.25,0,0,5,6,5,13.4,0,7.6,2.6,0.32,2 +Student_01680,1,39,9500,1,1,1,1,1,37,9,9,133.1,100.0,0,0,0,1,1,0,0,28,0,7,11,3,11.916666666666666,1,0,7,17,0,0.0,0,16.2,0.3,-0.92,0 +Student_01682,1,1,9773,1,1,1,1,1,19,4,4,117.0,109.3,0,0,0,1,1,0,0,19,0,6,11,4,12.25,0,0,6,10,3,12.666666666666666,0,7.6,2.6,0.32,1 +Student_01683,1,1,9670,1,2,1,1,19,1,9,4,124.0,117.7,1,0,1,1,1,0,0,20,0,5,5,4,12.0,0,0,5,6,5,11.6,0,9.4,-0.8,-3.12,0 +Student_01684,1,1,9670,1,1,1,1,2,2,3,3,124.0,124.7,1,0,0,1,1,0,0,21,0,5,7,3,11.0,0,0,5,5,4,12.75,0,7.6,2.6,0.32,0 +Student_01686,1,1,9070,1,5,1,1,3,3,2,2,125.0,140.8,1,0,0,1,1,0,0,22,0,6,6,6,14.666666666666666,0,0,6,6,6,15.0,0,9.4,-0.8,-3.12,2 +Student_01687,1,17,9085,1,3,1,1,38,1,9,9,121.0,111.9,1,0,0,1,1,0,0,21,0,5,11,0,0.0,0,0,5,10,5,12.285714285714286,1,10.8,1.4,1.74,2 +Student_01688,1,7,9556,1,1,3,1,3,3,2,2,140.0,140.0,0,0,1,0,1,0,0,38,0,7,8,3,12.666666666666666,0,0,5,5,0,0.0,0,13.9,-0.3,0.79,0 +Student_01689,1,1,171,1,1,1,1,19,1,9,9,124.0,121.2,1,0,0,1,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,1 +Student_01690,1,43,171,1,4,1,1,37,37,9,9,136.0,123.8,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,0 +Student_01691,1,7,9119,1,1,1,1,34,34,0,0,140.8,134.0,0,0,0,1,1,0,0,24,0,5,0,0,0.0,0,0,5,0,0,0.0,0,7.6,2.6,0.32,0 +Student_01692,1,18,9070,1,3,1,1,1,37,4,7,142.0,130.8,1,0,0,0,1,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_01694,1,1,9147,1,1,1,1,3,19,3,10,131.0,123.3,0,0,0,1,1,0,0,19,0,5,7,5,11.8,0,0,5,8,4,12.4,2,16.2,0.3,-0.92,1 +Student_01695,1,39,9119,1,1,3,1,3,3,3,10,130.0,147.6,0,0,0,1,1,0,0,NA,0,5,0,0,0.0,0,0,5,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01696,1,17,9670,1,1,1,1,38,37,9,8,120.0,113.4,1,0,0,1,1,1,0,19,0,6,6,6,13.333333333333334,0,0,6,7,6,13.285714285714286,0,8.9,1.4,3.51,2 +Student_01697,1,17,9070,1,1,1,1,19,38,4,5,141.0,133.7,1,0,0,1,1,0,0,22,0,6,7,5,11.4,0,0,6,6,6,12.166666666666666,0,7.6,2.6,0.32,2 +Student_01698,1,39,9085,1,1,1,1,34,1,0,2,130.0,128.2,0,0,0,1,1,0,0,25,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_01699,1,1,9500,1,1,1,1,1,1,5,5,168.0,161.0,1,0,0,1,1,0,0,18,0,7,7,7,16.142857142857142,0,0,8,9,0,0.0,0,16.2,0.3,-0.92,0 +Student_01700,1,7,9500,1,1,3,1,37,37,90,90,130.0,130.0,1,0,0,1,1,0,0,30,0,8,8,0,0.0,8,0,8,8,0,0.0,8,9.4,-0.8,-3.12,0 +Student_01701,1,1,9500,1,1,1,1,38,37,9,9,156.0,156.3,0,0,0,1,1,1,0,18,0,8,8,8,15.63375,0,0,8,8,8,15.63375,0,9.4,-0.8,-3.12,2 +Student_01703,1,17,9773,1,6,1,1,34,34,0,0,131.0,129.3,0,0,0,1,1,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_01704,1,1,9238,1,1,1,1,38,38,7,7,130.0,136.3,1,0,0,1,1,0,0,18,0,6,8,6,12.5,0,0,6,7,6,11.5,0,10.8,1.4,1.74,2 +Student_01705,1,39,9670,1,1,1,1,1,19,4,9,133.1,140.0,0,0,0,1,1,1,0,25,0,6,8,6,12.285714285714286,0,0,6,6,6,13.0,0,15.5,2.8,-4.06,2 +Student_01706,1,1,9119,1,1,1,1,3,1,4,1,131.0,135.9,0,0,0,1,1,0,0,18,0,5,10,2,14.0,0,0,5,7,3,11.0,1,7.6,2.6,0.32,1 +Student_01707,1,1,171,1,5,1,1,1,1,4,4,160.0,139.7,0,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_01708,1,1,9147,1,4,1,1,1,38,8,9,117.0,117.0,1,0,0,1,1,0,0,19,0,5,5,4,10.75,0,0,5,6,4,12.25,0,12.4,0.5,1.79,1 +Student_01709,1,39,9556,1,1,19,1,19,1,7,10,133.1,105.0,0,0,0,1,1,0,0,25,0,7,14,4,12.95,1,0,7,11,4,13.125,1,15.5,2.8,-4.06,0 +Student_01710,1,1,9500,1,3,1,1,37,38,9,5,130.0,130.5,1,0,0,1,0,0,0,19,0,7,7,6,12.45,0,0,7,7,6,12.45,0,7.6,2.6,0.32,2 +Student_01711,1,44,9991,0,1,39,1,37,37,9,9,130.0,130.0,0,0,0,1,0,0,0,31,2,6,12,4,12.25,0,3,7,9,7,12.0,0,9.4,-0.8,-3.12,1 +Student_01712,1,1,9500,1,3,1,1,19,19,5,4,137.0,131.5,1,0,0,1,0,1,0,20,0,8,8,8,13.38125,0,0,8,8,8,13.38125,0,9.4,-0.8,-3.12,2 +Student_01713,1,42,9500,1,1,1,41,3,1,3,10,133.1,100.0,1,0,0,0,0,0,1,33,1,7,10,5,12.16,0,0,6,7,5,11.34,0,12.4,0.5,1.79,0 +Student_01714,1,44,9085,1,1,39,1,1,3,9,4,140.0,140.0,0,0,1,0,0,0,0,24,2,6,11,4,12.5,0,1,6,18,2,11.5,0,12.4,0.5,1.79,1 +Student_01715,1,17,9238,1,4,1,1,19,37,9,9,140.0,130.2,1,0,0,1,0,1,0,18,0,6,8,6,12.75,0,0,6,10,6,12.166666666666666,0,12.7,3.7,-1.7,2 +Student_01716,1,17,9500,1,2,1,1,1,19,4,10,135.0,133.5,1,0,0,1,0,0,0,19,0,8,8,8,13.3425,0,0,8,8,8,13.3425,0,9.4,-0.8,-3.12,2 +Student_01717,1,NA,9500,1,4,1,1,38,38,7,7,140.0,133.2,1,0,0,1,0,1,0,20,0,7,10,7,14.175,0,0,8,14,6,13.03125,0,15.5,2.8,-4.06,2 +Student_01718,2,39,9500,1,1,1,1,37,38,4,4,100.0,130.0,0,0,0,1,1,1,0,33,0,8,16,1,10.0,1,0,8,16,1,10.0,1,12.7,3.7,-1.7,1 +Student_01720,1,39,9991,0,1,19,1,2,1,2,4,133.1,100.0,0,0,0,1,1,0,0,24,0,5,7,0,0.0,0,0,5,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_01721,1,17,9085,1,1,1,1,38,37,9,9,128.0,116.5,1,0,0,NA,1,0,0,18,0,5,6,5,12.0,0,0,5,8,5,12.142857142857142,0,10.8,1.4,1.74,2 +Student_01722,1,1,9254,1,2,1,1,37,37,9,9,NA,124.2,1,0,0,1,0,1,0,18,0,6,8,6,10.571428571428571,0,0,6,9,5,11.4,0,16.2,0.3,-0.92,2 +Student_01723,1,51,9085,1,1,1,1,3,3,2,8,127.0,138.8,1,0,0,1,0,0,0,22,4,12,19,11,14.153846153846152,0,5,12,20,12,15.428571428571429,0,8.9,1.4,3.51,2 +Student_01725,1,1,171,1,1,1,1,19,19,3,10,147.0,151.9,1,0,0,1,0,0,0,21,13,17,20,17,12.0,0,14,17,18,17,12.666666666666666,0,11.1,0.6,2.02,2 +Student_01726,2,39,9991,0,1,1,1,37,37,5,NA,110.0,120.0,1,0,0,1,0,0,0,38,0,5,11,3,11.333333333333334,0,0,5,9,4,12.0,0,9.4,-0.8,-3.12,0 +Student_01727,1,43,9238,1,1,1,1,34,34,99,99,142.0,131.9,0,0,0,1,0,1,0,29,9,16,17,16,12.588235294117649,0,10,13,14,13,13.357142857142858,0,9.4,-0.8,-3.12,2 +Student_01728,1,44,9130,1,1,39,1,38,37,4,9,130.0,130.0,1,0,0,1,0,1,0,20,0,6,11,4,12.0,0,0,6,9,4,10.75,0,16.2,0.3,-0.92,1 +Student_01729,1,NA,9254,1,1,1,1,38,37,4,9,131.0,131.7,1,0,0,0,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_01730,2,43,9991,0,1,1,1,37,37,9,9,110.0,132.5,0,0,0,1,1,0,0,37,7,12,13,12,12.25,0,8,13,13,13,12.846153846153848,0,9.4,-0.8,-3.12,2 +Student_01732,1,1,9130,1,1,1,1,19,19,90,8,136.0,133.9,1,0,0,0,1,0,0,20,0,5,7,4,13.0,0,0,5,11,3,12.0,2,10.8,1.4,1.74,0 +Student_01734,2,39,8014,0,1,1,1,37,3,9,10,140.0,172.0,0,0,0,1,1,0,0,44,5,11,21,9,NA,0,8,11,16,9,11.0,0,12.4,0.5,1.79,1 +Student_01735,1,1,9147,1,1,1,1,1,1,9,9,118.0,111.0,0,0,0,0,1,0,0,21,0,5,7,2,11.0,0,0,5,9,3,11.428571428571429,0,10.8,1.4,1.74,0 +Student_01736,1,44,9070,1,1,NA,1,2,19,3,8,120.0,120.0,0,0,0,1,1,0,0,21,2,7,10,6,13.428571428571429,0,5,9,9,8,13.125,0,16.2,0.3,-0.92,2 +Student_01737,1,1,9500,1,6,1,1,3,1,2,1,151.0,129.8,1,0,0,1,1,0,0,18,0,8,10,8,13.05375,2,0,8,10,8,13.05375,2,9.4,-0.8,-3.12,2 +Student_01738,1,1,9500,1,5,1,1,1,3,9,10,130.0,118.1,1,0,0,1,1,0,0,18,0,7,10,6,12.035714285714286,0,0,8,9,7,13.75,0,NA,-0.3,0.79,1 +Student_01739,1,39,9003,1,1,1,1,3,1,5,9,140.0,130.0,0,0,0,1,1,0,0,27,0,6,6,6,14.166666666666666,0,0,6,7,6,13.833333333333334,0,11.1,0.6,2.02,2 +Student_01740,2,39,9070,1,1,19,1,37,37,9,10,133.1,126.3,0,0,0,0,1,0,0,38,0,6,6,0,0.0,0,0,6,8,0,0.0,0,10.8,1.4,1.74,0 +Student_01741,1,18,9130,1,1,1,1,3,3,5,2,146.0,137.8,0,0,0,1,1,0,0,18,0,6,11,5,13.6,0,0,6,13,3,12.666666666666666,0,13.9,-0.3,0.79,0 +Student_01743,1,1,9130,1,1,1,1,3,19,2,9,121.0,115.4,1,0,0,1,1,0,0,18,0,6,8,6,13.714285714285714,0,0,6,7,5,13.333333333333334,0,15.5,2.8,-4.06,0 +Student_01744,1,43,9773,1,1,1,1,1,1,9,6,127.0,110.0,0,0,1,0,1,0,0,19,0,6,10,3,11.666666666666666,0,0,6,11,2,10.0,0,16.2,0.3,-0.92,0 +Student_01745,1,39,9670,1,1,1,1,37,37,90,90,133.1,97.4,0,0,1,0,1,0,0,44,0,6,9,1,14.0,0,0,6,6,0,0.0,0,12.7,3.7,-1.7,0 +Student_01746,1,44,9085,1,1,39,1,1,1,4,4,130.0,130.0,1,1,0,1,1,0,0,26,2,6,20,4,12.5,0,1,6,16,3,10.0,0,15.5,2.8,-4.06,0 +Student_01747,1,43,9130,1,1,1,1,19,1,9,NA,156.0,156.0,0,0,1,0,1,0,0,24,0,6,11,5,11.833333333333334,0,0,6,11,4,11.5,0,15.5,2.8,-4.06,0 +Student_01748,1,39,9003,1,1,1,1,19,1,9,6,130.0,126.1,1,0,0,0,1,0,0,27,0,6,6,0,0.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_01749,1,39,9003,1,1,1,1,1,1,9,4,110.0,120.0,0,0,1,0,1,0,0,27,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_01750,1,43,9070,1,1,1,1,38,38,7,7,108.0,105.2,1,0,0,1,1,0,0,25,11,17,18,13,11.538461538461538,0,10,15,15,10,12.4,0,12.7,3.7,-1.7,0 +Student_01751,1,44,9003,1,1,1,1,3,2,2,6,NA,120.0,1,0,0,1,1,0,0,21,4,9,14,7,11.285714285714286,2,2,8,15,4,12.25,0,12.7,3.7,-1.7,1 +Student_01753,1,17,9070,1,2,1,1,39,39,3,3,152.0,134.2,1,0,0,1,1,0,0,NA,0,6,7,5,11.8,0,0,6,9,4,12.0,0,15.5,2.8,-4.06,1 +Student_01754,1,44,9119,1,1,39,1,19,3,5,2,150.0,150.0,0,0,0,1,1,0,0,20,0,5,16,0,0.0,0,0,5,12,2,10.5,0,12.7,3.7,-1.7,1 +Student_01755,1,17,9119,1,5,1,1,3,1,2,9,123.0,116.0,1,0,1,0,1,0,0,20,0,5,5,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_01756,1,1,9119,1,1,1,NA,1,1,3,3,150.0,143.4,0,0,0,0,1,1,0,18,0,5,5,5,14.2,0,0,5,5,5,14.2,0,8.9,1.4,3.51,1 +Student_01757,1,17,171,1,1,1,1,4,4,3,3,145.0,143.6,0,0,1,1,1,0,0,19,5,12,12,10,12.7,0,4,11,16,10,12.272727272727272,0,8.9,1.4,3.51,1 +Student_01759,1,1,9670,1,4,1,1,4,19,2,5,125.0,118.0,1,0,0,1,0,0,0,19,0,6,7,6,14.428571428571429,0,0,6,8,6,15.0,2,16.2,0.3,-0.92,2 +Student_01760,1,1,9500,1,4,1,1,1,1,4,7,117.0,109.3,1,0,0,1,0,1,0,18,0,7,7,7,13.117142857142856,0,0,8,9,7,12.6,0,11.1,0.6,2.02,2 +Student_01761,1,1,9238,1,2,1,1,19,19,191,171,121.0,119.3,1,0,1,1,0,0,0,20,0,6,7,6,12.666666666666666,0,0,6,7,6,11.833333333333334,0,8.9,1.4,3.51,2 +Student_01764,NA,15,9147,1,1,1,26,37,2,6,4,140.0,140.0,0,0,1,1,1,0,1,19,0,5,12,3,10.5,0,0,5,8,4,11.25,0,12.4,0.5,1.79,2 +Student_01766,1,1,9147,1,1,1,1,19,38,9,9,140.0,129.2,1,0,0,1,0,0,0,26,0,5,6,0,0.0,0,0,5,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01767,1,39,9003,1,1,1,41,1,1,9,9,140.0,100.0,0,0,1,0,0,0,1,29,3,9,9,3,14.333333333333334,0,1,7,8,1,14.0,0,15.5,2.8,-4.06,0 +Student_01768,1,44,9254,1,1,39,1,19,2,9,3,170.0,170.0,0,0,0,0,1,0,0,26,2,8,14,8,15.125,0,1,6,12,6,13.666666666666666,0,11.1,0.6,2.02,1 +Student_01769,1,7,9500,1,1,3,1,3,19,2,6,140.0,140.0,0,0,0,1,1,0,0,27,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.4,0.5,1.79,0 +Student_01770,1,51,9147,1,1,1,1,3,3,2,2,116.0,115.2,0,0,1,1,1,0,0,32,2,7,16,3,12.0,0,3,8,10,3,10.333333333333334,0,8.9,1.4,3.51,1 +Student_01771,1,16,9853,1,3,1,1,37,19,9,5,134.0,121.4,1,0,0,1,0,1,0,23,0,6,10,4,14.25,1,0,6,8,5,12.0,0,7.6,2.6,0.32,1 +Student_01772,1,39,9147,1,1,1,41,38,38,9,8,133.1,134.8,0,0,0,1,0,0,1,24,0,5,12,2,10.5,0,0,5,9,4,10.0,2,16.2,0.3,-0.92,1 +Student_01774,1,42,9003,1,1,1,1,19,19,4,4,140.0,140.0,1,0,0,1,1,0,0,25,0,6,14,5,11.666666666666666,0,0,6,11,4,12.0,0,15.5,2.8,-4.06,1 +Student_01776,1,1,9773,1,3,1,1,1,3,0,0,149.0,148.7,0,0,0,0,1,0,0,20,0,4,4,0,0.0,0,0,4,8,0,0.0,0,10.8,1.4,1.74,0 +Student_01777,2,1,9254,1,1,1,1,19,38,4,7,140.0,133.0,0,0,0,1,1,0,0,33,3,9,11,9,12.8,0,2,7,9,7,11.428571428571429,0,12.7,3.7,-1.7,2 +Student_01778,2,39,9991,0,1,1,1,37,12,9,9,140.0,150.0,0,0,1,1,1,0,0,35,0,5,6,5,10.8,0,0,5,7,5,12.0,2,9.4,-0.8,-3.12,0 +Student_01780,1,1,9500,1,1,1,1,37,19,9,9,125.0,122.4,1,0,0,1,1,0,0,19,0,7,7,7,13.725714285714286,0,0,8,8,8,14.5,0,11.1,0.6,2.02,2 +Student_01781,1,1,9670,1,1,1,1,1,37,9,10,133.1,139.0,0,0,0,1,1,0,0,21,0,6,6,5,12.8,0,0,6,9,5,12.25,0,10.8,1.4,1.74,1 +Student_01783,1,39,9500,1,1,1,1,37,37,3,7,130.0,143.8,0,0,0,1,1,0,0,27,0,8,8,7,15.57,0,0,8,8,7,15.57,0,10.8,1.4,1.74,0 +Student_01784,1,17,9147,1,3,1,1,NA,38,123,171,122.0,116.1,1,0,1,1,1,0,0,19,0,5,10,4,11.0,0,0,5,13,2,12.0,0,8.9,1.4,3.51,1 +Student_01785,1,7,9500,1,2,3,1,37,38,9,9,140.0,138.0,0,0,0,1,1,0,0,28,0,7,7,7,14.114285714285714,0,0,8,9,8,15.91111111111111,0,16.2,0.3,-0.92,0 +Student_01786,1,43,9147,1,1,1,1,37,38,7,7,123.0,110.0,0,0,0,1,1,0,0,25,0,5,12,3,NA,1,0,5,12,4,11.5,0,9.4,-0.8,-3.12,1 +Student_01788,1,7,9991,0,1,3,1,37,37,9,9,140.0,140.0,0,0,0,1,1,0,0,27,0,5,6,4,13.5,0,0,5,6,4,13.75,0,7.6,2.6,0.32,2 +Student_01789,1,1,9070,1,1,1,1,3,3,0,1,116.0,108.7,1,0,0,1,1,0,0,23,0,6,9,4,11.25,1,0,6,10,0,0.0,4,7.6,2.6,0.32,0 +Student_01790,1,17,9254,1,3,1,1,19,1,4,4,118.0,115.9,1,0,0,1,1,1,0,18,0,6,7,6,12.142857142857142,0,0,6,8,6,11.333333333333334,0,8.9,1.4,3.51,2 +Student_01791,2,39,9500,1,1,1,1,37,37,9,4,140.0,127.3,0,0,0,1,1,0,0,26,0,8,8,7,13.075714285714286,0,0,8,8,7,13.075714285714286,0,10.8,1.4,1.74,2 +Student_01794,1,17,9085,1,1,1,1,1,1,4,7,137.0,134.6,1,0,0,1,1,0,0,22,0,6,16,0,0.0,0,0,6,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_01795,1,43,9500,1,1,1,1,19,37,173,183,136.0,118.4,1,0,0,1,0,0,0,21,0,7,12,4,13.125,0,0,7,8,6,12.333333333333334,0,13.9,-0.3,0.79,1 +Student_01796,1,1,9500,1,3,1,1,38,38,7,9,134.0,132.8,1,0,0,1,0,1,0,19,0,8,8,7,13.512857142857142,0,0,8,8,7,13.512857142857142,0,10.8,1.4,1.74,2 +Student_01797,1,1,NA,1,1,1,1,38,37,9,7,160.0,155.5,1,0,0,1,0,1,0,18,0,6,7,6,12.833333333333334,0,0,6,6,6,12.166666666666666,0,10.8,1.4,1.74,2 +Student_01798,1,1,9085,1,3,1,1,38,1,9,9,126.0,132.0,1,0,0,1,0,1,0,NA,0,5,8,3,15.0,2,0,5,9,3,11.666666666666666,0,9.4,-0.8,-3.12,0 +Student_01799,1,39,9003,1,1,19,1,37,38,4,9,133.1,110.0,0,0,1,0,0,0,0,40,0,6,12,5,12.8,0,0,6,16,3,13.333333333333334,0,11.1,0.6,2.02,0 +Student_01800,1,NA,9254,1,3,1,26,38,3,9,3,114.0,127.3,1,0,1,0,0,0,1,20,0,6,14,3,12.333333333333334,0,0,6,16,0,0.0,0,10.8,1.4,1.74,0 +Student_01803,1,1,9147,1,2,1,1,1,1,9,9,131.0,118.8,0,0,0,1,1,1,0,18,0,5,9,4,11.5,0,0,5,5,5,12.8,0,12.4,0.5,1.79,2 +Student_01804,1,43,9670,1,2,1,1,19,1,4,4,130.0,127.6,1,0,0,1,1,0,0,22,4,6,6,6,11.833333333333334,0,0,6,11,4,11.142857142857142,0,10.8,1.4,1.74,0 +Student_01805,1,51,9147,1,1,NA,1,19,19,9,5,133.1,112.1,0,0,1,0,1,0,0,38,0,5,5,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_01807,1,1,9119,1,3,1,1,1,1,3,5,117.0,111.1,0,0,0,1,1,1,0,NA,0,5,10,5,11.8,0,0,5,12,3,11.5,0,11.1,0.6,2.02,1 +Student_01810,1,51,9991,0,1,1,1,1,1,5,3,134.0,120.6,1,0,0,1,1,0,0,27,2,6,6,6,12.333333333333334,0,0,5,5,5,13.0,0,11.1,0.6,2.02,2 +Student_01811,1,39,9254,1,1,1,1,37,37,9,9,130.0,126.5,0,0,0,1,1,0,0,26,0,6,7,6,12.428571428571429,0,0,6,6,6,12.833333333333334,0,7.6,2.6,0.32,2 +Student_01812,1,1,9500,1,6,1,1,1,19,3,3,127.0,120.2,1,0,0,1,0,1,0,19,0,7,7,7,12.765714285714289,0,0,8,9,8,13.544444444444444,0,12.4,0.5,1.79,2 +Student_01813,2,51,9500,1,1,1,1,37,37,5,5,130.0,120.0,0,0,0,1,1,0,0,44,0,7,11,5,12.1,0,0,7,10,5,12.6,0,11.1,0.6,2.02,0 +Student_01814,1,1,9147,1,2,1,1,37,38,9,9,142.0,137.5,1,0,0,1,1,0,0,19,0,5,10,5,12.0,0,0,5,9,5,11.5,0,13.9,-0.3,0.79,2 +Student_01815,1,18,9070,1,1,1,1,1,37,4,7,117.0,127.9,1,0,0,1,1,0,0,20,0,6,6,0,0.0,0,0,6,6,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01817,4,43,9991,0,1,1,1,37,37,6,6,164.0,131.8,0,0,0,1,0,0,0,31,7,14,19,13,11.357142857142858,0,9,14,14,13,12.0,1,9.4,-0.8,-3.12,2 +Student_01818,1,43,9070,1,1,1,1,37,37,9,9,130.0,129.0,1,0,0,1,0,0,0,25,0,6,6,6,13.5,0,0,6,6,6,12.5,0,9.4,-0.8,-3.12,2 +Student_01819,1,17,9773,1,4,1,1,2,37,9,9,127.0,115.8,1,0,1,0,0,0,0,19,0,6,6,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_01820,1,17,9500,1,3,1,1,3,2,3,3,140.0,126.4,1,0,0,1,0,0,0,18,0,7,7,7,13.884285714285712,0,0,8,9,8,14.75,0,11.1,0.6,2.02,0 +Student_01821,1,43,9085,1,1,1,1,19,38,4,9,130.0,130.0,1,0,0,0,0,0,0,19,0,6,12,5,13.0,0,0,6,12,3,11.666666666666666,0,13.9,-0.3,0.79,1 +Student_01823,1,17,9147,1,1,1,1,1,38,4,5,162.0,138.6,1,0,0,1,NA,0,0,19,0,5,10,1,11.0,0,0,5,13,0,0.0,0,12.7,3.7,-1.7,1 +Student_01824,1,39,9670,1,1,1,1,1,1,4,4,133.1,112.9,0,0,0,1,0,0,0,24,0,6,12,2,11.666666666666666,0,0,6,20,2,10.5,6,16.2,0.3,-0.92,0 +Student_01825,1,1,9238,1,1,1,1,3,3,3,3,120.0,111.6,0,0,0,1,0,0,0,20,0,6,6,6,14.5,0,0,6,6,6,12.666666666666666,0,12.4,0.5,1.79,2 +Student_01827,1,1,9238,1,1,1,1,38,1,5,7,141.0,132.6,0,0,0,1,NA,1,0,18,0,6,7,6,13.285714285714286,0,0,6,6,6,14.333333333333334,0,12.4,0.5,1.79,2 +Student_01828,1,17,9085,1,1,1,1,1,38,4,9,125.0,118.4,1,0,0,1,0,0,0,21,0,5,13,3,11.333333333333334,2,0,5,12,2,10.5,1,9.4,-0.8,-3.12,1 +Student_01830,1,1,9147,1,1,1,1,38,37,5,6,128.0,122.1,0,0,0,1,0,1,0,18,0,5,11,4,11.571428571428571,0,0,5,9,5,12.0,0,13.9,-0.3,0.79,1 +Student_01831,1,1,9853,1,1,1,1,37,19,9,8,162.0,142.8,0,0,1,1,0,0,0,18,0,6,10,5,13.0,0,0,6,10,4,11.5,0,12.7,3.7,-1.7,0 +Student_01832,1,1,9238,1,1,1,1,1,1,4,4,130.0,124.8,0,0,0,1,0,1,0,18,0,6,9,6,11.5,0,0,6,11,5,14.0,0,11.1,0.6,2.02,2 +Student_01833,1,17,9147,1,2,1,1,37,19,9,8,134.0,126.3,1,0,0,1,0,1,0,18,0,5,8,5,11.8,0,0,5,10,5,11.6,3,16.2,0.3,-0.92,2 +Student_01834,1,1,9147,1,1,1,1,19,19,9,9,133.1,119.0,1,0,0,0,0,1,0,19,0,5,7,3,10.666666666666666,0,0,5,10,3,12.285714285714286,0,10.8,1.4,1.74,0 +Student_01835,1,17,9500,1,1,1,1,19,38,3,9,137.0,124.9,0,0,0,1,0,1,0,19,0,7,11,6,13.8875,0,0,8,9,8,14.864444444444445,0,15.5,2.8,-4.06,2 +Student_01836,1,1,9238,1,1,1,1,38,38,191,192,133.1,118.0,0,0,1,1,0,1,0,20,0,6,7,5,11.4,0,0,6,9,6,11.5,0,8.9,1.4,3.51,2 +Student_01838,2,39,9500,1,1,1,1,37,37,9,9,133.1,109.0,1,0,0,1,0,0,0,39,0,7,8,5,12.16,0,0,7,8,5,12.16,0,7.6,2.6,0.32,1 +Student_01839,1,17,9500,1,3,1,1,3,19,2,5,133.0,130.8,1,0,0,1,0,0,0,19,0,8,8,8,13.427499999999998,0,0,8,8,8,13.427499999999998,0,9.4,-0.8,-3.12,2 +Student_01840,1,39,9070,1,1,1,1,1,19,4,4,130.0,110.0,1,0,0,1,0,0,0,24,0,6,6,6,15.166666666666666,0,0,6,6,2,15.5,0,15.5,2.8,-4.06,2 +Student_01842,1,17,9130,1,1,1,1,19,19,3,10,125.0,131.0,1,0,0,1,1,0,0,19,0,5,11,2,10.5,2,0,5,9,0,0.0,3,10.8,1.4,1.74,0 +Student_01843,1,1,9147,1,1,1,1,1,38,3,6,158.0,155.2,0,0,0,1,1,1,0,18,0,5,5,5,11.8,0,0,5,8,3,11.0,0,9.4,-0.8,-3.12,2 +Student_01844,1,1,9147,1,2,1,1,3,1,3,3,128.0,121.0,1,1,1,1,1,0,0,20,0,5,6,5,13.2,0,0,5,10,5,11.4,3,16.2,0.3,-0.92,1 +Student_01846,1,1,9130,1,1,1,1,3,19,2,4,138.0,131.0,1,0,0,1,1,0,0,19,0,6,8,4,11.6,0,0,6,14,2,13.0,0,11.1,0.6,2.02,0 +Student_01847,1,17,9003,1,1,1,1,37,3,5,2,126.0,116.9,0,0,0,1,1,0,0,19,0,6,10,6,13.666666666666666,0,0,6,10,4,12.25,0,13.9,-0.3,0.79,0 +Student_01848,2,39,9991,0,1,1,1,36,14,9,10,140.0,130.0,1,0,0,1,1,0,0,41,0,5,9,4,10.75,0,0,5,7,2,10.0,0,9.4,-0.8,-3.12,0 +Student_01849,1,1,9500,1,2,1,1,5,5,2,2,143.0,137.8,0,0,0,1,1,0,0,19,0,7,10,6,13.492857142857144,0,0,8,9,8,12.68888888888889,0,12.4,0.5,1.79,2 +Student_01850,1,43,9254,1,3,1,1,3,3,2,2,135.0,122.1,0,0,0,1,1,0,0,19,0,6,14,3,12.5,0,0,6,9,4,11.0,0,12.7,3.7,-1.7,1 +Student_01851,1,7,9500,1,1,3,1,1,1,7,10,120.0,120.0,1,0,0,0,1,0,0,23,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_01852,1,1,9119,1,1,1,1,19,38,9,7,148.0,133.0,0,0,0,1,1,0,0,18,0,5,12,5,13.285714285714286,0,0,5,16,5,14.8,0,12.4,0.5,1.79,0 +Student_01853,1,1,9147,1,1,1,1,3,19,3,3,126.0,115.2,0,0,0,1,1,0,0,19,0,5,6,5,12.6,0,0,5,13,5,11.8,5,16.2,0.3,-0.92,2 +Student_01856,4,39,9670,1,2,19,1,19,1,90,90,133.1,103.0,0,0,0,0,1,0,0,34,0,6,6,0,0.0,0,0,6,9,0,0.0,0,10.8,1.4,1.74,0 +Student_01857,1,1,9070,1,1,1,1,3,3,9,9,136.0,136.0,1,0,1,0,0,1,0,19,0,6,6,6,11.833333333333334,0,0,6,8,6,12.875,0,10.8,1.4,1.74,2 +Student_01858,1,15,9238,1,1,1,26,19,1,9,9,150.0,146.5,1,0,1,0,1,0,1,22,0,6,10,5,11.5,0,0,6,8,5,12.4,0,13.9,-0.3,0.79,2 +Student_01859,1,17,9070,1,3,1,1,1,4,4,2,130.0,131.4,0,0,0,1,1,0,0,20,0,6,6,6,14.166666666666666,0,0,6,8,6,12.333333333333334,0,11.1,0.6,2.02,2 +Student_01860,2,42,9991,0,1,1,1,3,2,2,2,130.0,130.0,0,0,0,1,1,0,0,27,2,2,2,2,12.5,0,0,5,6,2,12.5,0,12.7,3.7,-1.7,1 +Student_01861,2,39,9119,1,1,1,1,19,19,0,5,110.0,137.0,0,0,1,1,1,0,0,30,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_01862,1,39,9119,1,1,1,1,1,1,4,4,110.0,125.9,0,0,0,1,1,0,0,34,0,5,7,0,0.0,0,0,5,8,1,11.0,0,10.8,1.4,1.74,1 +Student_01863,1,1,9254,1,1,1,1,1,1,5,4,121.0,111.9,1,0,0,0,1,0,0,20,0,6,14,2,10.5,0,0,6,16,0,0.0,0,10.8,1.4,1.74,0 +Student_01864,1,17,9070,1,1,1,1,37,38,9,5,127.0,131.2,1,0,0,1,1,0,0,18,0,6,6,6,11.833333333333334,0,0,6,6,6,13.166666666666666,0,7.6,2.6,NA,2 +Student_01866,1,39,9991,0,1,1,1,1,1,3,7,130.0,140.0,0,0,0,1,1,0,0,26,0,5,5,5,12.4,0,0,5,5,5,12.4,0,15.5,2.8,-4.06,2 +Student_01868,1,39,9991,0,1,1,1,37,37,9,6,100.0,153.5,0,0,1,0,1,0,0,31,0,5,9,0,0.0,0,0,5,6,0,0.0,0,12.4,0.5,1.79,0 +Student_01869,1,1,171,1,3,1,1,37,19,9,8,139.0,142.2,1,0,0,1,1,1,0,20,6,12,12,12,14.583333333333334,0,4,11,14,11,14.333333333333334,0,8.9,1.4,3.51,2 +Student_01870,1,1,9773,1,1,1,1,19,11,0,0,150.0,131.1,1,0,0,1,1,0,0,19,0,6,6,6,11.666666666666666,0,0,6,10,3,12.666666666666666,0,7.6,2.6,0.32,2 +Student_01874,1,39,8014,0,1,1,1,34,34,0,0,133.1,97.5,1,0,0,1,1,0,0,29,0,6,10,0,0.0,1,0,5,10,0,0.0,0,7.6,2.6,0.32,0 +Student_01875,1,1,9773,1,4,1,1,19,19,7,7,133.0,134.4,1,0,0,1,1,1,0,20,0,6,6,6,12.166666666666666,0,0,6,8,4,12.75,0,9.4,-0.8,-3.12,2 +Student_01876,1,1,9500,1,1,NA,1,37,37,9,9,125.0,118.8,0,0,0,1,1,0,0,24,0,7,7,6,13.3,0,0,7,7,6,13.3,0,7.6,2.6,0.32,2 +Student_01877,1,NA,9556,1,1,19,1,42,1,3,7,133.1,110.5,0,0,0,1,1,0,0,37,0,7,15,0,0.0,0,0,7,13,0,0.0,1,11.1,0.6,2.02,0 +Student_01878,1,1,9500,1,5,1,1,37,19,4,4,143.0,123.3,1,0,0,1,1,0,0,18,0,7,0,0,0.0,0,0,8,0,0,0.0,0,7.6,2.6,0.32,0 +Student_01879,1,1,171,1,2,1,1,2,19,5,5,127.0,139.6,1,0,1,0,1,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_01880,1,17,9500,1,1,1,1,19,3,4,9,157.0,138.8,0,0,0,1,1,0,0,18,0,8,8,7,13.55714285714286,0,0,8,8,7,13.55714285714286,0,12.7,3.7,-1.7,2 +Student_01881,2,44,9119,1,1,39,1,37,37,9,9,160.0,160.0,0,0,1,1,1,0,0,41,3,7,15,5,14.333333333333334,0,1,6,16,6,14.636363636363637,0,12.4,0.5,1.79,1 +Student_01882,1,39,9003,1,1,1,1,37,37,9,4,140.0,140.0,0,0,0,1,1,0,0,35,0,6,16,4,12.0,0,0,6,11,3,10.333333333333334,0,13.9,-0.3,0.79,0 +Student_01885,2,39,9500,1,1,1,1,37,37,191,172,133.1,115.2,0,0,0,1,0,0,0,48,0,7,11,4,11.75,0,0,7,14,3,11.725,0,11.1,0.6,2.02,1 +Student_01886,1,1,9500,1,1,NA,1,19,2,9,3,132.0,126.0,1,0,0,1,0,0,0,19,0,7,7,6,12.183333333333332,0,0,7,7,6,12.183333333333332,0,7.6,2.6,0.32,2 +Student_01888,2,43,9773,1,1,1,1,37,37,5,0,160.0,160.0,0,0,1,0,1,0,0,51,0,4,4,0,0.0,0,0,4,4,0,0.0,0,12.7,3.7,-1.7,0 +Student_01889,1,10,9085,1,1,1,22,2,19,2,8,184.4,184.4,0,0,0,1,0,0,1,18,0,6,8,6,15.0,0,0,6,10,5,14.333333333333334,0,11.1,0.6,NA,2 +Student_01890,1,1,171,1,1,1,1,1,1,9,3,149.0,156.0,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,2 +Student_01891,1,1,171,1,1,1,1,40,43,4,4,146.0,150.2,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,2 +Student_01892,1,1,9500,1,5,1,1,38,37,7,7,139.0,126.3,1,0,0,1,0,1,0,18,0,8,8,8,13.435,0,0,8,8,8,13.435,0,9.4,-0.8,-3.12,2 +Student_01893,1,1,9130,1,1,1,1,2,22,4,3,152.0,146.1,1,0,0,1,0,0,0,18,0,5,8,4,13.5,2,0,5,9,0,0.0,3,10.8,1.4,1.74,0 +Student_01894,1,1,171,1,1,1,1,2,3,4,8,147.0,145.3,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,1 +Student_01895,1,18,171,1,1,1,1,1,1,4,3,121.0,116.8,1,0,0,1,0,0,0,NA,15,17,18,17,11.5,0,16,17,17,17,12.176470588235292,0,12.4,0.5,1.79,2 +Student_01896,1,1,9070,1,1,1,1,19,19,7,9,124.0,132.1,1,0,0,1,0,0,0,19,0,6,10,2,10.5,0,0,6,6,3,11.0,0,7.6,2.6,0.32,1 +Student_01898,1,1,9773,1,1,1,1,3,3,2,2,121.0,112.3,1,0,1,0,0,0,0,18,0,6,7,5,12.2,0,0,6,11,4,11.5,0,11.1,0.6,2.02,0 +Student_01899,1,1,171,1,1,1,1,12,12,4,1,143.0,155.3,1,1,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,2 +Student_01901,1,43,9773,1,1,1,1,1,37,3,0,126.0,110.0,0,0,1,1,0,0,0,20,0,6,7,6,13.333333333333334,0,0,6,8,6,12.666666666666666,0,12.4,0.5,1.79,2 +Student_01902,1,42,9085,1,1,1,1,1,9,4,4,133.1,128.2,0,0,0,1,0,0,0,24,5,11,29,9,12.0,6,4,10,21,9,12.555555555555555,0,9.4,-0.8,-3.12,2 +Student_01903,1,1,9130,1,1,1,1,1,1,4,4,127.0,120.4,1,0,0,1,0,0,0,18,0,6,9,6,15.125,0,0,6,9,6,14.0,0,13.9,-0.3,0.79,2 +Student_01904,1,17,9500,1,1,1,1,19,1,4,10,160.0,153.0,1,0,0,1,0,0,0,18,0,7,7,6,13.116666666666667,0,0,7,7,6,13.116666666666667,0,7.6,2.6,0.32,2 +Student_01905,1,1,9773,1,1,1,1,19,1,7,9,121.0,117.9,1,0,0,1,0,0,0,19,0,6,7,6,12.833333333333334,0,0,6,7,6,11.666666666666666,0,11.1,0.6,2.02,2 +Student_01906,NA,44,9238,1,1,39,1,1,37,4,8,150.0,145.6,1,0,0,1,0,1,0,20,3,6,6,6,13.333333333333334,0,2,6,6,6,14.166666666666666,0,13.9,-0.3,0.79,2 +Student_01908,1,NA,9500,1,6,1,1,19,1,9,10,141.0,126.8,1,0,0,1,0,0,0,18,0,8,8,7,12.944285714285714,0,0,8,8,7,12.944285714285714,0,10.8,1.4,1.74,2 +Student_01909,1,17,9853,1,1,1,1,2,19,3,9,112.0,106.1,1,0,0,1,0,0,0,19,0,6,8,5,12.333333333333334,0,0,6,8,5,11.0,0,15.5,2.8,-4.06,1 +Student_01910,1,1,9500,1,1,1,1,3,3,2,2,148.0,137.3,1,0,0,1,0,0,0,19,0,7,7,6,14.266666666666666,0,0,7,7,6,14.266666666666666,0,7.6,2.6,0.32,2 +Student_01911,1,1,9670,1,2,1,1,3,19,4,5,120.0,115.5,1,0,0,1,0,0,0,18,0,6,8,5,13.0,0,0,6,8,5,14.0,0,13.9,-0.3,0.79,2 +Student_01912,1,1,9500,1,2,1,1,37,37,5,7,132.0,127.5,1,0,0,1,0,0,0,20,0,8,8,8,12.48375,0,0,8,8,8,12.48375,0,9.4,-0.8,-3.12,2 +Student_01915,1,1,9853,1,1,1,1,12,12,9,4,142.0,132.6,1,0,0,1,0,0,0,18,0,6,8,5,15.4,0,0,6,7,5,12.2,0,7.6,2.6,0.32,2 +Student_01916,1,1,9500,1,4,1,1,1,37,4,8,148.0,132.0,1,0,0,1,0,0,0,18,0,7,7,6,13.45,0,0,7,7,6,13.45,0,7.6,2.6,0.32,2 +Student_01917,1,17,9500,1,5,1,1,19,38,5,8,136.0,130.3,1,0,0,1,0,1,0,18,0,7,7,6,12.6,0,0,7,7,6,12.6,0,7.6,2.6,0.32,2 +Student_01918,1,1,9500,1,4,1,1,19,38,9,10,123.0,116.7,1,0,0,1,0,0,0,20,0,7,7,7,12.485714285714286,0,0,8,12,8,12.9375,0,16.2,0.3,-0.92,2 +Student_01920,1,43,9670,1,1,1,1,19,19,1,1,151.0,100.0,0,0,1,1,0,0,0,20,0,6,12,5,12.2,0,0,6,8,5,14.6,0,13.9,-0.3,0.79,1 +Student_01922,1,1,9238,1,2,1,1,37,38,9,8,136.0,139.2,1,0,0,1,0,0,0,18,0,6,7,6,13.833333333333334,0,0,6,6,6,14.0,0,9.4,-0.8,-3.12,2 +Student_01923,1,1,9853,1,1,1,1,19,1,9,1,142.0,132.6,0,0,0,1,0,0,0,18,0,6,8,5,12.8,0,0,6,14,3,10.0,0,9.4,-0.8,-3.12,1 +Student_01925,1,17,9670,1,1,1,1,1,38,4,7,NA,125.6,0,0,1,1,0,1,0,18,0,6,7,1,14.0,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_01927,1,1,9085,1,1,1,1,NA,19,9,4,134.0,128.4,1,0,0,1,0,1,0,19,0,5,7,5,12.5,0,0,5,8,5,12.714285714285714,0,10.8,1.4,1.74,2 +Student_01934,1,39,9500,1,1,19,1,19,37,9,4,133.1,120.0,0,0,0,1,0,1,0,25,0,8,8,8,13.3675,0,0,8,8,8,13.3675,0,9.4,-0.8,-3.12,2 +Student_01935,1,1,9500,1,4,1,1,19,38,9,9,133.1,119.6,1,0,0,1,0,1,0,19,0,7,7,6,12.808333333333332,0,0,8,11,7,12.825714285714286,0,12.4,0.5,1.79,2 +Student_01936,1,17,9500,1,6,1,1,1,38,3,3,143.0,133.2,1,0,0,1,0,0,0,18,0,7,7,7,13.918571428571427,0,0,8,9,8,13.8875,0,11.1,0.6,2.02,2 +Student_01937,1,17,9130,1,1,1,NA,4,1,2,10,147.0,141.8,1,0,0,1,0,0,0,19,0,6,8,6,13.0,0,0,6,9,4,12.8,0,13.9,-0.3,0.79,2 +Student_01938,2,1,9500,1,1,1,1,19,38,4,5,142.0,130.3,0,0,0,1,0,0,0,18,0,7,7,6,13.683333333333332,0,0,7,7,6,13.683333333333332,0,7.6,2.6,0.32,2 +Student_01939,1,39,9085,1,1,1,1,19,19,4,10,150.0,100.0,0,0,0,1,0,0,0,24,1,6,11,5,13.0,0,1,6,12,1,12.0,0,13.9,-0.3,0.79,0 +Student_01940,1,1,9773,1,2,1,1,3,3,3,4,124.0,114.6,1,0,0,NA,0,0,0,21,0,6,8,5,12.8,0,0,6,7,5,11.2,0,11.1,0.6,2.02,2 +Student_01941,1,1,9254,1,2,1,1,1,1,9,4,136.0,123.4,1,0,0,1,0,1,0,18,0,6,9,6,13.571428571428571,0,0,6,6,6,12.166666666666666,0,8.9,1.4,3.51,2 +Student_01942,1,1,9238,1,1,1,1,38,38,9,6,116.0,116.4,1,0,0,1,0,0,0,18,0,6,6,6,13.166666666666666,0,0,6,6,6,13.166666666666666,0,8.9,1.4,3.51,2 +Student_01944,1,1,9070,1,1,1,1,4,19,3,5,117.0,123.7,1,0,0,1,0,0,0,19,0,6,6,6,12.666666666666666,0,0,6,8,5,11.4,0,12.4,0.5,1.79,2 +Student_01946,1,1,9500,1,4,1,1,37,37,9,9,129.0,117.1,1,0,0,1,0,0,0,30,0,7,7,7,14.692857142857145,0,0,8,8,8,14.9625,0,12.4,0.5,1.79,2 +Student_01947,1,1,9500,1,1,1,1,19,38,5,3,157.0,149.3,0,0,0,1,0,0,0,18,0,8,8,8,14.035,0,0,8,8,8,14.035,0,9.4,-0.8,-3.12,2 +Student_01948,1,17,9085,1,1,1,1,1,19,4,10,135.0,125.6,1,0,0,1,0,0,0,18,0,5,8,4,11.0,1,0,5,8,3,14.0,0,12.7,3.7,-1.7,2 +Student_01949,1,1,9773,1,1,1,1,38,38,9,9,139.0,145.0,1,0,0,1,0,1,0,18,0,6,6,6,13.333333333333334,0,0,6,6,6,13.333333333333334,0,9.4,-0.8,-3.12,2 +Student_01950,1,18,9500,1,1,1,NA,38,37,5,5,115.0,115.0,0,0,0,1,0,0,0,20,0,7,13,6,11.7725,0,0,8,9,7,12.33,0,15.5,2.8,-4.06,2 +Student_01951,1,1,9254,1,1,1,1,38,38,4,7,123.0,114.3,0,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_01952,1,43,9254,1,2,1,1,19,19,9,9,140.0,126.0,1,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,12,0,0.0,0,10.8,1.4,1.74,0 +Student_01953,1,1,171,1,1,1,1,19,37,7,7,138.0,124.0,1,0,0,0,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01954,1,1,9254,1,4,1,1,1,38,5,6,132.0,122.6,1,0,0,1,0,1,0,18,0,6,7,6,12.285714285714286,0,0,6,6,6,12.0,0,8.9,1.4,3.51,2 +Student_01955,1,1,9500,1,4,1,1,3,19,2,3,140.0,133.8,1,0,0,1,0,0,0,17,0,8,14,5,NA,0,0,8,14,5,12.46,0,10.8,1.4,1.74,1 +Student_01956,1,18,9853,1,1,1,1,19,38,4,NA,117.0,113.5,1,0,0,1,0,0,0,19,0,7,10,6,12.166666666666666,0,0,7,9,6,13.166666666666666,0,12.4,0.5,1.79,2 +Student_01957,1,1,9238,1,4,1,1,19,1,4,5,125.0,122.6,1,1,0,1,0,0,0,18,0,6,9,5,11.833333333333334,0,0,6,8,2,11.5,0,13.9,-0.3,0.79,1 +Student_01958,1,7,9500,1,1,3,1,37,37,4,4,140.0,140.0,0,0,0,1,0,0,0,25,0,8,8,7,14.805714285714286,0,0,8,8,7,14.805714285714286,0,10.8,1.4,1.74,2 +Student_01959,1,1,9238,1,1,1,1,12,38,4,9,133.1,107.0,1,0,0,1,0,0,0,19,0,6,11,5,10.6,0,0,6,10,6,11.714285714285714,0,11.1,0.6,2.02,0 +Student_01960,1,53,9085,1,1,42,1,19,1,9,9,130.0,NA,1,0,1,0,0,0,0,24,7,9,9,8,13.125,0,4,9,13,6,13.0,0,8.9,1.4,3.51,1 +Student_01961,1,1,9238,1,1,1,1,1,1,4,9,134.0,124.2,1,0,1,1,0,1,0,19,0,6,6,6,12.833333333333334,0,0,6,6,6,12.666666666666666,0,9.4,-0.8,-3.12,2 +Student_01962,1,18,9500,1,1,NA,1,19,1,9,4,128.0,125.8,0,0,0,1,0,1,0,20,0,8,8,0,0.0,8,0,8,8,0,0.0,8,9.4,-0.8,-3.12,1 +Student_01963,1,1,9670,1,1,1,1,1,1,5,4,115.0,108.0,1,0,0,1,0,1,0,20,0,6,9,5,13.0,0,0,6,6,5,13.8,0,12.4,0.5,1.79,2 +Student_01964,1,1,9500,1,2,1,1,1,1,4,4,119.0,115.2,1,0,0,1,0,1,0,20,0,7,8,7,12.725,0,0,8,8,8,13.7125,0,13.9,-0.3,0.79,2 +Student_01965,1,17,9085,1,1,1,1,1,3,4,1,131.0,129.3,1,0,0,1,0,0,0,19,0,5,10,4,11.25,1,0,5,10,3,10.333333333333334,0,12.7,3.7,-1.7,2 +Student_01967,1,1,9085,1,1,1,1,1,19,3,4,120.0,116.7,0,0,0,1,0,0,0,20,0,5,12,3,12.333333333333334,2,0,5,8,3,13.0,1,9.4,-0.8,-3.12,2 +Student_01969,1,17,9853,1,1,1,1,1,1,3,4,146.0,128.2,0,0,1,1,0,0,0,18,0,6,8,4,13.25,0,0,6,10,3,10.666666666666666,0,NA,3.7,-1.7,1 +Student_01970,1,1,9670,1,4,1,1,1,2,4,7,133.0,121.1,1,0,0,1,0,0,0,18,0,6,7,6,13.666666666666666,0,0,6,9,5,15.4,0,13.9,-0.3,0.79,2 +Student_01972,1,17,9085,1,1,1,1,2,19,2,4,128.0,123.3,1,0,0,1,0,1,0,20,0,6,6,6,14.833333333333334,0,0,6,8,6,12.142857142857142,0,8.9,1.4,3.51,2 +Student_01974,1,17,9147,1,1,NA,1,19,19,4,6,122.0,119.9,0,0,0,1,0,1,0,21,0,5,6,5,11.4,0,0,5,6,5,12.2,0,12.7,3.7,-1.7,2 +Student_01975,1,1,9500,1,4,1,1,1,12,3,10,140.0,131.6,1,0,0,1,0,0,0,18,0,7,8,7,13.135,0,0,8,9,8,13.244444444444444,0,12.4,0.5,1.79,2 +Student_01976,1,51,9070,1,1,1,1,1,1,4,4,143.0,120.0,1,0,0,1,0,0,0,21,3,10,10,10,13.0,0,5,11,11,10,11.4,0,11.1,0.6,2.02,0 +Student_01977,1,1,9500,1,4,1,1,19,19,3,3,118.0,110.0,1,0,0,1,0,0,0,19,0,7,12,4,12.85,0,0,7,7,7,12.62142857142857,0,11.1,0.6,2.02,1 +Student_01978,1,44,9238,1,1,39,1,1,19,191,102,140.0,143.0,0,0,0,1,0,0,0,20,3,6,6,6,13.5,0,2,6,9,5,12.5,0,NA,-0.3,0.79,2 +Student_01979,1,44,9085,1,1,1,1,1,2,3,3,140.0,140.0,0,0,0,1,0,0,0,20,0,6,7,6,14.285714285714286,0,0,6,9,3,13.0,0,13.9,-0.3,0.79,1 +Student_01981,1,1,9147,1,1,1,1,19,19,9,9,140.0,124.3,1,0,0,1,0,1,0,18,0,5,8,4,10.75,0,0,5,5,5,13.0,0,12.4,0.5,1.79,2 +Student_01983,1,43,9085,1,1,39,1,38,37,6,6,150.0,150.0,1,0,0,1,0,1,0,21,2,7,15,3,13.0,2,1,5,12,5,13.285714285714286,1,10.8,1.4,1.74,2 +Student_01985,1,1,9500,1,1,1,1,19,1,5,5,162.0,147.5,1,0,0,1,0,1,0,18,0,8,8,8,14.14125,0,0,8,8,8,14.14125,0,9.4,-0.8,-3.12,2 +Student_01987,2,42,9500,1,1,2,1,37,37,9,9,130.0,130.0,0,0,0,1,0,1,0,32,0,8,8,8,14.6625,0,0,8,8,8,14.6625,0,9.4,-0.8,-3.12,2 +Student_01989,1,1,9500,1,2,1,1,19,37,3,3,116.0,109.0,1,0,0,1,0,1,0,23,0,7,8,6,12.993333333333334,0,0,8,9,8,12.66875,0,11.1,0.6,2.02,2 +Student_01990,1,1,9670,1,5,1,1,4,1,4,10,120.0,112.0,1,0,0,1,0,0,0,18,0,6,10,4,11.25,0,0,6,11,5,NA,0,8.9,1.4,3.51,1 +Student_01991,1,17,8014,0,1,1,NA,37,19,5,5,132.0,121.2,0,0,0,1,0,0,0,18,0,6,8,5,12.2,0,0,6,10,5,12.8,0,10.8,1.4,1.74,2 +Student_01992,1,43,171,1,1,2,1,37,37,9,9,140.0,140.0,1,0,0,1,0,0,0,34,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01993,1,39,8014,0,1,1,100,1,1,4,7,120.0,119.5,0,0,1,1,0,0,1,25,2,6,6,6,11.333333333333334,0,0,6,6,4,11.75,0,8.9,1.4,3.51,1 +Student_01994,1,1,9147,1,1,1,1,37,38,193,181,136.0,125.9,0,0,0,1,0,0,0,21,0,5,7,5,12.2,0,0,5,7,5,11.8,0,NA,0.6,2.02,2 +Student_01995,1,1,9254,1,1,1,1,19,9,0,0,133.0,121.5,1,0,0,1,0,1,0,20,0,6,12,0,0.0,0,0,6,12,0,0.0,0,7.6,2.6,0.32,0 +Student_01996,1,1,9238,1,5,1,1,30,19,0,2,126.0,121.5,1,0,0,1,0,0,0,18,0,6,8,6,11.333333333333334,0,0,6,6,6,11.666666666666666,0,7.6,2.6,0.32,2 +Student_01997,1,17,9085,1,1,1,1,3,37,4,8,142.0,132.4,1,0,0,1,0,0,0,18,0,6,8,6,13.857142857142858,0,0,6,15,6,13.1,0,12.4,0.5,1.79,2 +Student_01998,1,17,9773,1,1,1,1,37,37,9,9,121.0,122.4,0,0,0,1,0,0,0,18,0,6,7,6,12.857142857142858,0,0,6,6,6,13.333333333333334,0,NA,-0.3,0.79,2 +Student_01999,1,39,8014,0,1,1,1,37,38,4,7,134.0,NA,1,0,0,1,0,0,0,24,0,6,10,1,10.0,0,0,6,12,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02000,1,51,9147,1,1,1,1,19,19,9,7,140.0,120.4,0,0,1,0,0,0,0,32,14,15,17,14,10.214285714285714,0,13,13,13,13,11.384615384615383,0,16.2,0.3,-0.92,2 +Student_02002,1,1,9238,1,1,1,1,38,37,9,NA,157.0,137.8,0,0,0,1,0,1,0,18,0,6,6,6,13.833333333333334,0,0,6,7,0,0.0,0,15.5,2.8,-4.06,0 +Student_02003,1,51,9254,1,1,1,1,38,38,9,9,120.0,118.0,0,0,0,1,0,0,0,28,0,6,8,6,12.857142857142858,0,0,6,8,5,12.6,0,8.9,1.4,3.51,2 +Student_02004,1,17,9853,1,5,1,1,19,38,4,8,134.0,122.1,1,0,0,1,0,1,0,18,0,6,8,6,11.666666666666666,0,0,6,9,4,12.0,0,10.8,1.4,1.74,0 +Student_02005,1,7,9853,1,1,3,1,34,34,0,0,140.0,140.0,1,0,0,0,0,0,0,24,0,6,12,0,0.0,0,0,5,10,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02007,NA,39,8014,0,1,1,1,37,37,9,8,146.0,120.5,0,0,0,1,0,0,0,44,0,6,6,6,14.833333333333334,0,0,6,6,6,14.166666666666666,0,10.8,1.4,1.74,2 +Student_02008,1,16,9085,1,3,1,1,37,37,9,2,130.0,119.5,1,0,0,1,0,1,0,18,0,6,14,6,14.333333333333334,0,0,6,9,6,12.0,0,15.5,2.8,-4.06,2 +Student_02009,1,1,171,1,1,1,1,37,37,9,7,151.0,147.5,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_02010,1,1,9773,1,6,1,1,1,1,90,90,133.1,129.6,0,0,0,1,0,0,0,22,0,6,0,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_02011,1,18,9853,1,1,1,1,37,37,9,5,132.0,126.1,0,0,0,1,0,1,0,18,0,7,9,6,12.333333333333334,0,0,7,7,6,12.666666666666666,0,11.1,0.6,2.02,2 +Student_02013,5,39,9853,1,1,19,1,38,1,5,3,133.1,105.5,0,0,1,1,0,0,0,33,0,6,7,5,13.2,0,0,6,7,5,10.6,0,7.6,2.6,0.32,0 +Student_02014,2,39,9853,1,1,1,1,37,37,9,9,110.0,95.5,0,0,1,0,0,0,0,32,0,6,6,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_02015,2,39,9003,1,1,1,1,19,19,4,4,133.1,107.5,0,0,0,0,0,0,0,35,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_02016,1,1,9238,1,1,1,1,19,19,6,6,105.0,106.1,1,0,0,1,0,0,0,20,0,6,6,6,11.5,0,0,6,7,6,13.285714285714286,0,11.1,0.6,2.02,2 +Student_02017,1,39,9254,1,1,1,1,NA,1,6,6,160.0,116.3,1,0,0,1,0,0,0,24,0,6,8,5,12.6,0,0,6,7,5,12.2,0,9.4,-0.8,-3.12,2 +Student_02019,1,1,9254,1,1,1,1,19,19,5,5,100.0,101.8,1,0,0,1,0,0,0,21,0,6,8,5,11.6,0,0,6,6,5,13.0,0,12.4,0.5,1.79,1 +Student_02020,1,1,9773,1,2,1,1,1,1,4,9,143.0,144.1,1,0,0,1,1,1,0,19,0,6,7,6,13.666666666666666,0,0,6,6,6,13.833333333333334,0,12.7,3.7,-1.7,2 +Student_02021,1,NA,9003,1,1,1,1,19,1,9,5,160.0,107.8,1,0,0,0,1,0,0,27,0,6,10,0,0.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_02022,1,39,9853,1,1,1,1,19,1,9,4,140.0,128.2,0,0,0,0,0,0,0,30,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02023,1,17,171,1,4,1,1,38,38,9,9,133.1,117.0,1,0,0,1,1,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_02024,1,1,9070,1,1,1,1,1,12,5,8,116.0,110.4,1,0,0,1,1,0,0,19,0,6,6,6,11.5,0,0,6,8,6,12.285714285714286,0,8.9,1.4,3.51,2 +Student_02025,2,39,9991,0,1,1,1,37,37,9,10,120.0,170.0,0,0,0,1,0,0,0,34,0,5,12,2,11.5,0,0,5,9,4,11.75,0,9.4,-0.8,-3.12,1 +Student_02026,1,43,9500,1,1,1,1,4,19,4,10,141.0,NA,0,0,0,1,1,0,0,18,0,7,7,7,NA,0,0,8,10,7,12.9125,0,13.9,-0.3,0.79,2 +Student_02028,1,1,171,1,2,1,1,3,39,1,3,127.0,133.5,1,0,0,1,1,0,0,17,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,1 +Student_02029,1,1,9500,1,1,1,1,19,37,4,9,132.0,128.0,1,0,0,1,0,1,0,19,0,7,7,6,12.966666666666669,0,0,7,7,6,12.966666666666669,0,7.6,2.6,0.32,2 +Student_02030,1,1,9773,1,1,1,1,37,38,9,6,135.0,122.1,1,0,0,1,1,0,0,18,0,6,6,6,13.833333333333334,0,0,6,6,6,13.666666666666666,0,12.7,3.7,-1.7,2 +Student_02032,4,39,9254,1,1,1,1,38,37,9,9,140.0,112.0,0,0,1,1,0,0,0,45,4,10,12,5,12.166666666666666,4,2,8,8,0,0.0,2,12.7,3.7,-1.7,0 +Student_02033,1,39,9085,1,1,1,1,19,37,9,6,133.1,130.0,1,0,0,NA,0,0,0,26,0,6,17,6,12.666666666666666,0,0,6,21,4,12.25,0,15.5,2.8,-4.06,2 +Student_02034,2,39,9991,0,2,1,1,37,37,9,9,100.0,100.0,1,0,0,1,1,0,0,51,0,4,4,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02035,2,39,9773,1,1,19,1,37,37,6,6,133.1,162.0,0,0,1,1,1,1,0,49,0,6,8,6,12.285714285714286,0,0,6,7,6,14.166666666666666,0,10.8,1.4,1.74,2 +Student_02036,1,42,9500,1,1,1,1,3,19,2,8,100.0,153.0,0,0,0,1,1,0,0,22,3,6,7,3,14.5,0,4,7,8,4,14.375,0,15.5,2.8,-4.06,1 +Student_02037,1,17,9147,1,1,1,NA,1,37,5,9,137.0,131.4,1,0,0,1,1,0,0,22,0,5,8,2,10.0,0,0,5,7,1,10.0,0,7.6,2.6,0.32,0 +Student_02038,2,7,9130,1,1,3,1,3,3,1,1,120.0,128.2,0,0,0,1,0,0,0,33,1,5,11,2,11.5,1,1,5,8,2,12.0,0,9.4,-0.8,-3.12,0 +Student_02040,1,1,9238,1,4,1,1,38,19,7,7,134.0,128.4,1,0,0,1,0,1,0,18,0,6,6,6,12.5,0,0,6,6,6,11.666666666666666,0,10.8,1.4,1.74,2 +Student_02041,1,1,9853,1,5,1,1,38,37,9,9,128.0,120.3,1,0,1,0,0,0,0,20,0,6,9,3,11.666666666666666,0,0,6,10,2,11.0,0,10.8,1.4,1.74,0 +Student_02042,2,57,9991,0,1,1,41,38,37,4,6,133.1,NA,0,0,0,1,0,0,1,37,5,10,11,7,13.428571428571429,0,5,10,11,10,11.6,0,8.9,1.4,3.51,2 +Student_02043,1,1,9254,1,1,1,2,37,1,9,3,131.0,126.1,1,0,0,1,1,0,1,18,0,6,6,6,13.666666666666666,0,0,6,6,6,13.5,0,7.6,2.6,0.32,2 +Student_02045,1,44,9085,1,1,39,1,1,19,3,3,140.0,140.0,1,0,0,NA,0,0,0,21,2,6,7,6,13.0,0,1,6,15,4,12.8,0,12.4,0.5,1.79,2 +Student_02046,1,1,9500,1,2,1,1,19,1,9,1,133.0,122.2,0,0,0,1,0,0,0,20,0,7,9,6,12.783333333333331,0,0,8,9,7,12.842857142857143,0,13.9,-0.3,0.79,2 +Student_02047,1,1,9500,1,2,1,NA,37,1,7,7,126.0,118.7,1,0,0,1,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02048,1,17,9556,1,2,1,1,38,19,7,7,125.0,121.5,1,0,0,1,0,0,0,20,0,7,13,4,13.5,0,0,7,11,4,11.225,0,11.1,0.6,2.02,0 +Student_02050,1,1,9500,1,4,1,1,1,19,9,7,140.0,127.0,1,0,0,1,0,0,0,19,0,8,8,7,13.44285714285714,0,0,8,8,7,13.44285714285714,0,12.7,3.7,-1.7,2 +Student_02051,1,1,9238,1,1,1,1,37,38,9,3,124.0,114.2,0,0,0,1,0,0,0,18,0,6,13,4,11.0,0,0,6,12,5,10.833333333333334,0,15.5,2.8,-4.06,2 +Student_02052,1,17,9238,1,1,1,1,38,38,7,7,133.0,125.3,1,0,0,1,0,1,0,18,0,6,6,6,11.333333333333334,0,0,6,7,6,12.285714285714286,0,15.5,2.8,-4.06,2 +Student_02053,1,1,9773,1,2,1,1,1,19,4,5,127.0,120.4,1,0,0,1,0,0,0,18,0,5,7,2,10.0,0,0,1,1,0,0.0,0,12.7,3.7,-1.7,0 +Student_02054,1,1,9500,1,6,1,1,1,38,3,9,138.0,123.0,1,0,0,1,0,0,0,19,0,7,10,5,13.44,0,0,7,8,6,13.066666666666668,0,12.4,0.5,1.79,1 +Student_02055,1,1,9556,1,2,1,1,1,19,4,5,142.0,130.5,1,0,0,1,0,1,0,18,0,7,8,7,12.214285714285714,0,0,8,8,8,14.0625,0,16.2,0.3,-0.92,2 +Student_02056,1,1,9070,1,1,1,41,37,19,9,8,130.0,125.5,1,0,0,1,0,1,1,19,0,6,6,6,14.166666666666666,0,0,6,6,6,13.5,0,11.1,0.6,2.02,2 +Student_02057,1,53,9003,1,1,42,1,1,19,9,7,130.0,133.8,0,0,1,1,0,1,0,24,7,12,13,12,12.846153846153848,0,5,11,13,11,12.636363636363637,0,8.9,1.4,3.51,2 +Student_02058,1,44,9085,1,1,39,1,37,37,9,9,150.0,150.0,0,0,0,NA,0,0,0,20,2,6,8,6,13.0,0,1,6,18,2,12.0,0,12.4,0.5,1.79,1 +Student_02059,1,1,9147,1,1,1,1,1,19,5,7,127.0,130.5,1,0,0,1,0,1,0,21,0,5,6,5,12.8,1,0,5,7,4,11.25,0,9.4,-0.8,-3.12,2 +Student_02060,1,44,NA,1,1,39,1,38,37,4,10,140.0,140.0,0,0,1,0,0,0,0,20,1,6,13,4,13.0,0,1,6,11,5,12.0,0,NA,0.3,-0.92,0 +Student_02061,1,17,9500,1,6,1,1,19,37,3,9,126.0,119.4,1,0,0,1,0,1,0,19,0,7,7,7,13.371428571428572,0,0,8,9,8,13.666666666666666,0,16.2,0.3,-0.92,2 +Student_02063,1,1,9500,1,3,1,1,1,1,9,9,141.0,126.3,1,0,0,1,0,0,0,18,0,8,8,7,13.328571428571427,0,0,8,8,7,13.328571428571427,0,12.7,3.7,-1.7,2 +Student_02064,1,1,9085,1,1,1,1,38,38,4,7,120.0,111.6,1,0,0,1,0,0,0,19,0,6,12,5,14.0,0,0,6,14,5,11.0,0,16.2,0.3,-0.92,2 +Student_02065,1,17,9147,1,4,1,1,38,19,9,9,120.0,111.3,1,0,0,1,0,0,0,21,0,5,5,5,12.6,0,0,5,5,5,13.2,0,8.9,1.4,3.51,2 +Student_02066,1,1,9853,1,2,1,1,1,38,9,8,134.0,122.5,1,0,0,1,0,1,0,19,0,6,7,6,14.0,0,0,6,6,6,15.0,0,15.5,2.8,-4.06,2 +Student_02067,1,1,9254,1,5,1,1,19,1,7,10,128.0,116.5,1,0,0,1,0,1,0,18,0,6,7,6,NA,0,0,6,6,6,12.666666666666666,0,8.9,1.4,3.51,2 +Student_02068,1,17,9070,1,5,1,1,4,1,4,4,133.0,132.0,1,1,0,1,0,1,0,17,0,6,6,6,13.0,0,0,6,6,6,12.5,0,15.5,2.8,-4.06,2 +Student_02069,1,18,9853,1,4,1,1,19,38,4,10,123.0,123.7,1,0,0,1,0,0,0,19,0,6,8,5,12.666666666666666,0,0,6,8,5,11.0,0,15.5,2.8,NA,1 +Student_02070,1,17,9147,1,6,1,1,37,1,9,7,118.0,117.0,1,0,0,0,1,0,0,23,0,5,9,3,10.0,1,0,5,9,3,12.333333333333334,0,9.4,-0.8,-3.12,0 +Student_02071,1,1,9670,1,1,1,1,1,37,1,10,113.0,116.5,1,0,0,1,0,0,0,19,0,6,7,6,12.833333333333334,0,0,6,10,6,11.77777777777778,0,8.9,1.4,3.51,2 +Student_02072,1,1,9500,1,1,1,1,19,3,9,4,135.0,121.5,1,0,0,1,0,0,0,18,0,7,7,6,12.916666666666666,0,0,7,7,6,12.916666666666666,0,7.6,2.6,0.32,2 +Student_02073,1,1,9670,1,1,1,1,38,38,5,9,133.1,105.0,1,0,0,1,0,0,0,20,0,6,9,6,13.285714285714286,0,0,6,8,5,13.8,0,15.5,2.8,-4.06,2 +Student_02074,1,1,9085,1,3,1,1,1,19,9,9,130.0,121.3,1,0,0,1,0,1,0,19,0,5,6,5,14.6,0,0,5,5,5,13.8,0,10.8,1.4,1.74,2 +Student_02075,1,1,9238,1,1,1,1,19,38,3,9,135.0,136.1,1,0,0,1,0,1,0,18,0,6,6,6,14.0,0,0,6,6,6,13.666666666666666,0,12.4,0.5,1.79,2 +Student_02076,1,17,9238,1,2,1,1,37,37,9,4,133.0,123.6,0,0,0,1,0,1,0,19,0,6,7,6,14.142857142857142,0,0,6,6,6,15.0,0,13.9,-0.3,0.79,2 +Student_02077,1,1,9238,1,4,1,1,38,1,4,10,123.0,129.0,1,0,0,1,0,0,0,19,0,6,8,6,11.666666666666666,0,0,6,6,6,12.333333333333334,0,10.8,1.4,1.74,2 +Student_02078,1,17,9500,1,1,1,1,19,37,4,8,145.0,136.8,1,0,0,1,0,0,0,18,0,8,9,8,14.3775,1,0,8,9,8,14.3775,1,9.4,-0.8,-3.12,2 +Student_02079,1,17,9500,1,2,1,1,3,3,3,6,146.0,133.4,1,0,0,1,0,0,0,18,0,7,8,7,12.5,0,0,8,9,7,13.042857142857144,0,13.9,-0.3,0.79,2 +Student_02081,1,1,9500,1,1,1,1,38,37,9,9,144.0,125.8,0,0,0,1,0,1,0,19,0,8,12,7,12.471428571428572,0,0,8,12,7,12.471428571428572,0,12.7,3.7,-1.7,2 +Student_02082,1,1,9500,1,1,1,1,4,4,2,1,131.0,120.5,0,0,0,1,0,0,0,19,0,7,7,6,14.15,0,0,7,7,6,14.15,0,7.6,2.6,0.32,2 +Student_02083,1,1,9500,1,2,1,1,37,37,9,8,141.0,130.2,1,0,0,1,0,0,0,21,0,7,11,7,14.072222222222225,0,0,8,8,8,14.0475,0,15.5,2.8,-4.06,2 +Student_02084,1,1,9773,1,3,1,1,3,1,2,3,138.0,135.9,1,0,0,1,0,0,0,18,0,6,7,6,14.857142857142858,0,0,6,6,6,14.666666666666666,0,13.9,-0.3,0.79,2 +Student_02085,1,1,9773,1,1,1,1,19,37,9,9,127.0,116.5,0,0,0,1,0,1,0,19,0,6,7,6,14.285714285714286,0,0,6,6,6,13.166666666666666,0,11.1,0.6,2.02,2 +Student_02088,1,17,9130,1,1,1,1,3,2,3,6,157.0,150.9,1,0,0,1,0,0,0,18,0,6,8,6,15.0,0,0,6,8,5,15.166666666666666,0,13.9,-0.3,0.79,0 +Student_02089,1,1,9500,1,3,1,1,19,19,4,8,129.0,127.3,1,0,0,1,0,1,0,20,0,7,7,6,12.633333333333333,0,0,7,7,6,12.633333333333333,0,7.6,2.6,0.32,2 +Student_02090,1,39,9670,1,1,19,1,1,1,4,7,133.1,100.0,0,0,1,0,0,0,0,25,0,5,5,5,11.2,0,0,5,5,5,12.6,0,9.4,-0.8,-3.12,0 +Student_02091,1,1,9500,1,5,1,1,38,37,5,7,142.0,128.8,1,0,0,1,0,0,0,18,0,7,7,6,14.233333333333334,0,0,7,7,6,14.233333333333334,0,7.6,2.6,0.32,2 +Student_02092,5,1,9085,1,3,1,1,19,19,4,7,133.0,119.7,1,0,0,1,0,0,0,21,0,5,13,5,12.2,2,0,5,10,3,11.333333333333334,1,9.4,-0.8,-3.12,1 +Student_02094,1,1,9500,1,1,1,1,37,37,9,9,151.0,138.0,1,0,0,1,0,0,0,18,0,7,7,6,15.2,0,0,7,7,6,15.2,0,7.6,2.6,0.32,2 +Student_02095,1,17,9853,1,1,1,1,3,3,2,2,135.0,132.9,1,0,0,0,0,0,0,29,0,6,9,6,16.333333333333332,0,0,6,8,5,15.6,0,12.7,3.7,-1.7,0 +Student_02096,1,43,9130,1,1,1,1,3,3,2,2,140.0,140.0,0,0,0,1,0,0,0,20,10,17,29,14,12.5625,4,7,12,24,12,12.857142857142858,1,15.5,2.8,-4.06,2 +Student_02097,1,7,9500,1,1,3,1,3,1,4,4,140.0,140.0,0,0,0,1,0,0,0,26,0,7,0,0,0.0,0,0,8,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02098,1,1,9238,1,2,1,1,38,1,7,7,100.0,99.3,1,0,0,1,0,0,0,21,0,6,8,5,12.4,0,0,6,6,6,12.0,0,12.4,0.5,1.79,2 +Student_02099,1,18,9500,1,1,1,1,37,19,5,5,126.0,119.3,0,0,0,1,0,1,0,19,0,8,9,8,13.78125,1,0,8,9,8,13.78125,1,9.4,-0.8,-3.12,2 +Student_02100,1,17,9254,1,2,1,1,19,19,5,5,123.0,113.2,1,0,1,1,0,0,0,19,0,6,10,6,NA,0,0,6,8,5,11.666666666666666,0,16.2,0.3,-0.92,0 +Student_02103,1,1,9500,1,6,1,1,37,37,9,8,138.0,127.2,1,0,0,1,0,1,0,18,0,7,8,7,13.26,0,0,8,8,8,14.28625,0,15.5,2.8,-4.06,2 +Student_02104,1,1,9773,1,2,1,1,34,19,3,0,128.0,141.0,1,0,0,0,0,0,0,20,0,6,10,4,12.0,0,0,6,15,3,10.666666666666666,0,7.6,2.6,0.32,0 +Student_02105,1,1,9238,1,1,1,1,19,38,9,9,136.0,121.7,0,1,0,1,0,1,0,20,0,6,9,6,11.875,0,0,6,7,6,14.428571428571429,0,16.2,0.3,-0.92,2 +Student_02106,1,43,9500,1,1,1,1,19,19,4,7,127.0,121.1,0,0,0,1,0,1,0,18,0,7,11,5,12.16,0,0,7,7,2,13.4,0,16.2,0.3,-0.92,1 +Student_02107,1,16,9070,1,1,1,1,1,1,3,3,145.0,146.1,1,0,0,1,0,0,0,18,0,6,6,1,15.0,0,0,6,7,4,12.5,0,9.4,-0.8,-3.12,1 +Student_02109,1,17,9085,1,1,1,1,2,19,2,9,138.0,126.8,1,0,0,1,0,0,0,18,0,5,12,2,11.5,0,0,5,12,3,11.8,2,10.8,1.4,1.74,1 +Student_02110,1,44,9085,1,1,39,1,3,3,2,2,150.0,150.0,1,0,0,1,0,0,0,22,2,6,7,6,14.428571428571429,0,1,6,9,5,13.0,0,13.9,-0.3,0.79,2 +Student_02111,1,44,9085,1,3,39,1,1,19,4,1,150.0,150.0,1,0,0,1,0,0,0,19,0,5,10,1,13.0,1,0,5,8,3,15.333333333333334,0,12.7,3.7,-1.7,1 +Student_02112,1,17,9003,1,1,1,1,19,1,9,2,131.0,134.5,1,0,0,1,0,1,0,19,0,6,7,6,15.0,0,0,6,8,6,14.333333333333334,0,12.4,0.5,1.79,2 +Student_02113,1,1,9556,1,2,1,1,19,19,9,9,136.0,129.5,1,0,0,1,0,0,0,18,0,7,9,7,15.155555555555557,0,0,8,8,8,16.8,0,12.7,3.7,-1.7,2 +Student_02114,1,1,9238,1,1,1,1,38,38,175,183,117.0,113.2,1,0,1,1,0,0,0,20,0,6,8,6,10.666666666666666,0,0,6,7,6,11.857142857142858,0,11.1,0.6,2.02,2 +Student_02115,1,17,9853,1,1,1,1,38,37,5,5,158.0,140.2,1,0,0,1,0,0,0,18,0,6,9,5,11.0,0,0,6,9,4,11.25,0,10.8,1.4,1.74,0 +Student_02116,1,17,9670,1,2,1,1,1,19,5,5,129.0,119.2,1,0,0,1,0,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_02117,1,1,9238,1,1,1,1,1,19,4,4,140.0,140.7,0,0,0,1,0,0,0,19,0,6,7,6,12.285714285714286,0,0,6,7,6,12.0,0,NA,0.5,1.79,2 +Student_02118,1,1,9500,1,5,1,1,38,38,9,9,141.0,142.3,1,0,0,1,0,0,0,18,0,8,8,8,12.82875,0,0,8,8,8,12.82875,0,9.4,-0.8,-3.12,0 +Student_02119,1,1,9773,1,4,1,11,12,12,90,4,132.0,129.9,1,0,0,1,0,0,1,18,0,6,6,6,12.666666666666666,0,0,6,8,5,14.4,0,7.6,2.6,0.32,2 +Student_02120,1,17,171,1,1,1,1,1,1,6,7,133.0,134.8,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,1 +Student_02121,1,17,9085,1,1,1,1,19,19,4,9,109.0,104.1,1,0,1,0,0,1,0,21,0,6,16,2,13.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_02122,1,1,9147,1,1,1,1,1,38,5,5,135.0,122.4,0,0,1,1,0,0,0,19,0,5,10,5,10.875,0,0,5,8,4,12.4,0,13.9,-0.3,0.79,2 +Student_02123,1,1,9147,1,1,1,1,37,37,9,7,122.0,120.6,1,0,0,1,0,1,0,19,0,5,5,5,12.8,0,0,5,8,5,11.6,0,9.4,-0.8,-3.12,2 +Student_02125,1,1,171,1,1,1,1,5,3,3,3,174.0,157.9,0,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_02126,1,43,9254,1,1,1,1,38,38,9,9,142.0,125.9,0,0,0,1,0,1,0,19,0,6,0,0,0.0,0,0,6,11,1,10.0,0,10.8,1.4,1.74,0 +Student_02127,1,17,9500,1,2,1,1,38,1,5,7,131.0,118.4,1,0,0,1,0,1,0,20,0,7,9,6,13.766666666666666,0,0,8,9,8,13.744444444444444,0,16.2,0.3,-0.92,0 +Student_02128,1,1,9500,1,3,1,1,18,18,1,1,139.0,130.8,1,0,0,0,0,0,0,18,0,8,9,6,12.758333333333333,1,0,8,9,6,12.758333333333333,1,9.4,-0.8,-3.12,0 +Student_02129,1,1,171,1,1,1,1,19,19,8,8,170.0,176.7,1,0,0,1,0,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,0 +Student_02130,1,1,9070,1,1,1,1,19,1,5,7,182.0,156.8,1,0,0,1,0,0,0,18,0,6,6,6,12.666666666666666,0,0,6,8,6,13.25,0,10.8,1.4,1.74,2 +Student_02131,1,1,9085,1,1,1,1,19,37,3,7,125.0,126.8,0,0,0,1,0,0,0,18,0,6,13,6,12.0,0,0,6,16,4,12.75,0,11.1,0.6,2.02,1 +Student_02132,1,1,9238,1,1,1,1,1,37,5,7,142.0,128.0,0,0,0,1,0,1,0,19,0,6,8,6,NA,0,0,6,8,6,12.0,0,16.2,0.3,-0.92,2 +Student_02133,1,1,9147,1,2,1,1,19,37,4,5,119.0,113.8,1,0,0,1,0,0,0,20,0,5,8,3,11.333333333333334,0,0,5,8,5,12.2,0,7.6,2.6,0.32,2 +Student_02135,1,1,9500,1,3,1,1,19,38,1,1,150.0,130.8,1,0,0,1,0,0,0,18,0,8,8,7,13.614285714285714,0,0,8,8,7,13.614285714285714,0,12.7,3.7,-1.7,2 +Student_02136,1,39,9254,1,1,1,1,19,1,4,1,133.1,101.0,0,0,1,1,0,0,0,25,0,6,6,0,0.0,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_02139,1,17,9556,1,2,1,1,19,38,4,8,122.0,118.3,1,0,0,1,0,1,0,19,0,7,7,7,11.971428571428572,0,0,8,8,8,14.4375,0,15.5,2.8,-4.06,2 +Student_02141,1,17,9500,1,5,1,1,1,1,5,4,137.0,131.1,1,0,0,1,0,0,0,18,0,7,9,7,12.385714285714286,0,0,8,9,7,12.728571428571428,0,13.9,-0.3,0.79,1 +Student_02143,1,17,9238,1,1,1,1,1,1,9,9,123.0,115.7,1,0,0,1,0,0,0,21,0,6,8,6,12.166666666666666,0,0,6,7,6,13.285714285714286,0,11.1,0.6,2.02,2 +Student_02144,1,1,171,1,2,1,1,3,1,2,3,133.1,141.0,1,0,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_02146,1,17,9130,1,1,1,1,3,3,2,2,143.0,131.8,1,0,1,NA,0,0,0,18,0,6,9,5,12.4,0,0,6,12,5,14.166666666666666,0,8.9,1.4,3.51,1 +Student_02147,1,1,9070,1,1,1,1,37,37,9,6,150.0,131.1,0,0,0,1,0,1,0,19,0,6,7,5,13.4,0,0,6,6,6,12.833333333333334,0,15.5,2.8,-4.06,2 +Student_02148,1,1,9254,1,6,1,1,38,19,9,5,129.0,117.8,1,0,0,1,0,0,0,18,0,6,11,6,12.0,0,0,6,11,4,12.5,0,8.9,1.4,3.51,2 +Student_02150,1,1,9238,1,1,1,1,38,37,5,5,133.1,108.0,0,0,0,1,0,1,0,20,0,6,8,6,12.125,0,0,6,7,6,14.428571428571429,0,16.2,0.3,-0.92,2 +Student_02151,1,1,9853,1,1,1,1,1,19,3,3,132.0,122.9,1,0,0,1,0,0,0,20,0,7,7,7,13.857142857142858,0,0,7,7,7,13.285714285714286,0,11.1,0.6,2.02,2 +Student_02153,1,1,NA,1,4,1,1,38,37,7,7,137.0,126.0,1,0,0,1,0,0,0,19,0,7,9,7,14.283333333333337,0,0,8,9,8,13.125555555555556,0,15.5,2.8,-4.06,2 +Student_02154,1,42,9238,1,1,1,1,1,19,4,9,133.1,134.0,0,0,0,1,0,0,0,21,10,13,21,11,13.272727272727272,0,6,11,13,9,13.0,0,7.6,2.6,0.32,2 +Student_02155,1,1,9070,1,1,1,1,38,19,151,193,143.0,134.3,1,1,0,1,0,0,0,19,0,6,6,6,14.666666666666666,0,0,6,7,6,15.142857142857142,0,8.9,1.4,3.51,2 +Student_02156,1,1,9500,1,1,1,1,19,19,9,9,148.0,138.7,0,0,0,1,0,1,0,19,0,7,10,7,15.114999999999998,0,0,8,10,8,15.092,0,15.5,2.8,-4.06,2 +Student_02157,1,17,171,1,2,1,1,1,1,4,1,137.0,143.3,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,1 +Student_02158,1,44,NA,1,1,39,1,37,19,9,10,160.0,160.0,1,0,0,1,0,0,0,22,1,6,13,6,15.0,0,1,6,7,6,13.142857142857142,0,16.2,0.3,-0.92,2 +Student_02159,1,1,9853,1,2,1,1,3,1,3,5,112.0,111.0,0,0,0,1,0,0,0,21,0,6,8,5,13.2,0,0,6,9,5,14.333333333333334,0,9.4,-0.8,-3.12,2 +Student_02160,1,17,9254,1,4,1,1,37,37,5,8,133.0,128.5,1,0,0,1,0,1,0,18,0,6,14,2,11.0,0,0,6,14,3,10.333333333333334,0,7.6,2.6,0.32,0 +Student_02162,1,17,9670,1,2,1,1,34,37,0,0,123.0,114.6,1,0,1,0,0,0,0,18,0,5,8,3,12.0,0,0,5,6,4,10.75,0,7.6,2.6,0.32,0 +Student_02163,1,17,9238,1,1,1,1,19,37,7,NA,103.0,104.1,0,0,0,1,0,0,0,20,0,6,6,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_02164,1,17,9500,1,4,1,1,1,1,3,3,140.0,127.6,1,0,0,1,0,0,0,23,0,7,7,6,13.796666666666669,0,0,8,11,7,13.775,0,12.4,0.5,1.79,2 +Student_02165,1,1,9773,1,2,1,1,1,1,3,3,159.0,151.0,1,0,0,1,0,0,0,18,0,6,6,6,14.833333333333334,0,0,6,6,6,15.333333333333334,0,12.7,3.7,-1.7,2 +Student_02166,1,44,9238,1,1,39,1,1,1,9,3,140.0,135.7,1,0,0,1,0,0,0,20,3,6,6,6,12.833333333333334,0,2,6,6,6,13.833333333333334,0,12.4,0.5,1.79,2 +Student_02167,NA,17,9500,1,1,1,1,38,37,5,NA,148.0,137.8,1,0,0,1,0,1,0,18,0,8,8,7,14.962857142857144,0,0,8,8,7,14.962857142857144,0,10.8,1.4,1.74,2 +Student_02168,1,1,9147,1,6,1,1,38,38,9,9,112.0,117.3,1,0,0,1,0,0,0,20,0,5,8,4,12.0,0,0,5,8,5,11.2,0,11.1,0.6,2.02,2 +Student_02169,1,18,9500,1,2,1,1,1,3,3,2,131.0,121.2,1,0,0,1,0,0,0,18,0,7,8,7,12.4,0,0,8,9,8,12.8,0,16.2,0.3,-0.92,2 +Student_02170,1,NA,9670,1,1,1,1,3,3,2,1,145.0,129.3,1,0,0,1,0,0,0,20,0,6,7,6,15.571428571428571,0,0,6,6,6,17.166666666666668,0,16.2,0.3,-0.92,2 +Student_02171,1,1,9500,1,5,1,1,1,1,5,8,133.1,123.0,1,0,0,1,0,0,0,19,0,8,8,7,13.714285714285714,0,0,8,8,7,13.714285714285714,0,12.7,3.7,-1.7,2 +Student_02173,2,7,9070,1,1,43,1,NA,1,9,NA,140.0,140.0,0,0,0,1,0,0,0,33,0,6,7,6,15.0,0,0,6,8,3,11.0,0,11.1,0.6,2.02,2 +Student_02174,1,1,9085,1,1,1,1,12,2,4,2,150.0,144.6,0,0,1,0,0,0,0,24,0,5,6,1,13.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_02175,1,43,9238,1,1,1,1,1,38,4,3,120.0,118.3,0,0,0,1,NA,1,0,20,8,11,12,11,12.0,0,6,11,14,11,12.75,0,13.9,-0.3,0.79,2 +Student_02176,1,1,171,1,1,1,1,19,38,9,NA,156.0,153.6,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_02177,1,1,9070,1,4,1,1,1,1,7,3,167.0,158.3,1,0,0,1,0,0,0,18,0,6,6,6,15.166666666666666,0,0,6,6,6,14.166666666666666,0,15.5,2.8,-4.06,2 +Student_02179,1,17,9500,1,1,1,1,1,1,5,5,147.0,134.9,0,1,0,1,0,0,0,18,0,7,7,7,13.642857142857142,0,0,8,11,8,14.772727272727272,0,16.2,0.3,-0.92,2 +Student_02180,1,1,9773,1,3,1,1,38,37,5,5,129.0,142.0,1,0,0,1,0,0,0,19,0,6,8,6,12.666666666666666,0,0,6,7,6,12.714285714285714,0,9.4,-0.8,-3.12,2 +Student_02181,1,17,171,1,1,1,1,38,38,7,7,136.0,127.3,1,0,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_02182,1,17,9238,1,1,1,1,19,19,5,4,128.0,116.5,0,0,0,1,0,1,0,18,0,6,8,5,10.8,0,0,6,9,6,10.5,0,12.4,0.5,1.79,2 +Student_02183,1,43,9500,1,1,1,1,19,19,7,7,140.0,138.6,0,0,0,1,0,1,0,19,0,7,9,6,14.25,0,0,8,11,8,13.063636363636364,0,16.2,0.3,-0.92,2 +Student_02184,1,42,9853,1,1,1,1,37,19,9,3,141.0,133.0,0,0,0,1,0,0,0,20,6,14,22,12,12.153846153846152,0,5,12,18,10,12.9,0,10.8,1.4,1.74,0 +Student_02185,1,17,9238,1,2,1,1,2,1,3,4,133.0,136.2,1,0,0,1,0,0,0,19,0,6,14,1,11.5,0,0,6,12,2,10.5,0,7.6,2.6,0.32,1 +Student_02186,1,17,NA,1,1,1,1,19,19,7,5,125.0,118.0,1,0,0,NA,0,1,0,19,0,6,10,4,12.25,0,0,6,9,3,12.333333333333334,0,9.4,-0.8,-3.12,2 +Student_02187,1,1,9070,1,1,1,1,19,37,4,4,124.0,126.8,0,0,0,1,0,1,0,18,1,6,8,6,12.0,1,0,6,12,5,11.142857142857142,0,13.9,-0.3,0.79,1 +Student_02188,1,NA,9500,1,6,1,1,19,38,5,7,140.0,128.5,1,0,0,1,0,1,0,18,0,8,8,8,13.40375,0,0,8,8,8,13.40375,0,9.4,-0.8,-3.12,2 +Student_02189,1,17,9254,1,1,1,1,3,1,2,3,140.0,129.9,0,0,0,1,0,1,0,19,0,6,15,6,11.333333333333334,0,0,6,9,3,12.666666666666666,0,9.4,-0.8,-3.12,2 +Student_02191,1,17,171,1,1,1,1,37,37,9,6,144.0,129.3,1,0,0,1,1,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,1 +Student_02192,1,1,9500,1,6,1,1,4,19,2,3,138.0,124.7,1,0,0,1,1,0,0,18,0,7,0,0,0.0,0,0,8,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_02193,1,39,9003,1,1,1,1,3,1,2,4,130.0,154.9,0,0,1,0,1,0,0,35,0,6,8,5,16.166666666666668,0,0,6,10,4,16.0,0,8.9,1.4,3.51,0 +Student_02195,1,1,171,1,1,1,1,37,19,5,8,136.0,129.0,1,0,0,1,1,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_02199,1,1,9147,1,3,1,1,38,38,9,9,136.0,127.3,1,0,0,1,1,0,0,19,0,5,8,3,11.0,0,0,5,7,2,NA,0,12.7,3.7,-1.7,0 +Student_02200,1,39,9556,1,2,1,1,1,1,9,10,133.1,100.5,0,0,0,1,1,0,0,24,0,7,18,0,0.0,0,0,7,13,0,0.0,1,11.1,0.6,2.02,0 +Student_02201,1,39,8014,0,1,1,1,37,37,9,7,140.0,122.0,1,0,1,0,1,0,0,29,0,6,11,4,12.5,0,0,6,7,0,0.0,0,12.4,0.5,1.79,0 +Student_02202,1,39,9500,1,1,1,1,38,3,9,1,150.0,140.0,0,0,0,1,1,0,0,24,0,7,11,7,11.294444444444444,0,0,8,22,2,12.6,0,15.5,2.8,-4.06,2 +Student_02203,1,17,9254,1,2,1,1,19,38,6,6,121.0,116.1,1,0,0,1,1,0,0,19,0,6,8,5,11.2,0,0,6,11,4,12.5,0,15.5,2.8,-4.06,2 +Student_02204,2,7,171,1,1,3,1,19,19,9,9,120.0,130.0,1,0,0,1,1,0,0,37,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,0 +Student_02205,1,5,9070,1,2,1,1,1,1,4,10,143.0,146.2,1,0,0,1,1,0,0,18,0,6,7,5,13.2,0,0,6,6,5,11.8,0,16.2,0.3,-0.92,2 +Student_02206,1,44,9119,1,1,39,1,1,1,9,8,180.0,180.0,0,0,0,1,1,1,0,20,3,7,12,6,14.142857142857142,0,1,6,10,6,14.125,0,12.4,0.5,1.79,1 +Student_02207,1,1,9147,1,5,1,1,39,39,3,3,132.0,127.8,1,0,0,0,1,0,0,18,0,5,0,0,0.0,0,0,5,0,0,0.0,0,11.1,0.6,2.02,0 +Student_02208,1,43,9147,1,1,1,1,37,19,9,8,130.0,130.8,0,0,0,1,1,0,0,22,0,5,5,0,0.0,0,0,5,9,3,13.333333333333334,2,16.2,0.3,-0.92,1 +Student_02209,1,17,9147,1,2,1,1,38,38,4,7,133.1,109.0,1,0,0,1,1,1,0,22,0,5,7,3,12.333333333333334,0,0,5,9,3,10.571428571428571,0,10.8,1.4,1.74,1 +Student_02210,1,1,9773,1,5,1,1,1,38,9,5,131.0,132.4,1,0,1,0,1,0,0,18,0,6,6,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_02211,1,1,9500,1,3,1,1,1,1,4,4,149.0,129.3,1,0,0,1,1,0,0,18,0,8,8,7,13.1,0,0,8,8,7,13.1,0,12.7,3.7,-1.7,2 +Student_02213,1,1,9119,1,1,1,1,38,19,5,5,126.0,130.2,0,0,0,1,1,0,0,19,0,5,7,5,10.2,0,0,5,8,3,NA,0,10.8,1.4,1.74,1 +Student_02214,1,1,9238,1,1,1,1,19,38,9,9,140.0,132.0,0,0,0,1,1,0,0,19,0,6,10,5,11.571428571428571,0,0,6,10,3,13.0,0,16.2,0.3,-0.92,0 +Student_02215,1,44,9003,1,1,39,1,19,19,9,7,170.0,170.0,1,0,1,1,1,0,0,21,0,6,7,6,15.285714285714286,0,0,6,6,6,15.166666666666666,0,12.4,0.5,1.79,2 +Student_02216,1,1,9773,1,2,1,1,3,1,2,4,133.0,130.2,0,0,0,1,1,0,0,19,0,6,9,5,12.6,0,6,10,16,8,11.0,1,8.9,1.4,3.51,1 +Student_02217,1,18,9556,1,2,1,1,3,3,2,2,126.0,115.5,0,0,0,1,1,0,0,18,0,7,11,6,13.433333333333332,0,0,7,10,4,13.6,0,8.9,1.4,3.51,2 +Student_02220,1,1,9070,1,1,1,1,37,1,9,8,130.0,120.2,1,0,0,1,1,0,0,22,0,6,9,6,14.666666666666666,0,0,6,12,6,14.666666666666666,0,NA,3.7,-1.7,2 +Student_02221,1,39,9500,1,1,1,1,1,1,4,9,130.0,150.0,0,0,0,1,1,0,0,24,0,8,8,7,12.742857142857144,0,0,8,8,7,12.742857142857144,0,12.7,3.7,-1.7,2 +Student_02222,1,1,9500,1,2,1,1,1,3,5,10,99.0,100.0,1,0,0,1,1,0,0,19,0,7,9,7,11.975,0,0,8,9,7,13.12857142857143,0,13.9,-0.3,0.79,2 +Student_02223,1,43,9119,1,1,1,1,3,1,2,3,146.0,100.0,0,0,0,1,1,0,0,18,0,5,9,4,12.25,0,0,5,11,3,11.666666666666666,0,13.9,-0.3,0.79,1 +Student_02224,1,17,171,1,1,1,1,38,37,4,6,129.0,128.0,0,0,0,0,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02227,1,1,9670,1,1,1,1,3,3,3,3,116.0,110.1,1,0,0,1,1,0,0,19,0,6,9,5,13.333333333333334,0,0,6,6,5,13.0,0,12.4,0.5,1.79,2 +Student_02229,2,39,9773,1,1,1,1,37,38,9,3,120.0,155.5,0,0,0,1,1,0,0,47,0,6,12,5,13.8,0,0,6,13,4,14.0,0,12.7,3.7,-1.7,0 +Student_02230,1,1,9070,1,1,1,1,1,1,3,9,117.0,118.4,0,0,0,1,1,0,0,19,0,6,6,6,11.833333333333334,0,0,6,8,4,10.75,2,16.2,0.3,-0.92,2 +Student_02231,1,1,171,1,4,1,1,1,38,4,8,137.0,141.2,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,2 +Student_02232,1,1,171,1,1,1,1,3,3,2,NA,124.0,119.1,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_02233,1,43,9147,1,1,1,1,1,3,1,1,151.0,111.0,0,0,0,1,1,0,0,28,0,5,9,2,10.0,0,0,5,9,0,0.0,0,15.5,2.8,-4.06,0 +Student_02234,1,43,9254,1,1,6,1,34,34,0,0,138.6,138.6,1,0,0,1,1,0,0,20,0,6,10,4,11.5,0,0,6,11,3,11.666666666666666,0,7.6,2.6,0.32,0 +Student_02236,1,1,171,1,1,1,1,19,19,4,8,136.0,150.4,1,0,0,1,1,1,0,NA,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,2 +Student_02237,1,1,9254,1,1,1,1,38,19,9,4,123.0,117.8,0,0,0,1,1,0,0,19,0,6,10,4,12.75,0,0,6,12,2,13.0,0,10.8,1.4,1.74,1 +Student_02238,1,39,9254,1,1,19,1,38,37,4,5,133.1,102.5,0,0,1,0,1,0,0,24,0,6,7,0,0.0,0,0,6,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_02240,1,39,9085,1,1,12,1,38,19,9,8,133.1,138.3,1,0,1,0,1,0,0,25,0,6,6,0,0.0,0,0,6,6,0,0.0,0,8.9,1.4,3.51,1 +Student_02241,1,39,9254,1,1,1,1,3,1,3,4,150.0,122.3,0,0,0,1,1,0,0,28,0,6,10,6,13.0,0,0,6,8,5,12.2,0,13.9,-0.3,0.79,2 +Student_02243,1,43,9119,1,1,1,1,1,38,4,7,128.0,100.0,0,0,0,1,1,0,0,19,0,5,8,5,12.0,0,0,5,12,2,10.5,0,13.9,-0.3,0.79,1 +Student_02244,1,17,9500,1,4,1,1,38,37,5,7,133.0,126.4,1,0,0,1,1,1,0,18,0,7,7,7,13.462857142857144,0,0,8,8,8,13.90625,0,11.1,0.6,2.02,2 +Student_02245,1,39,9254,1,1,19,1,37,37,90,90,133.1,100.0,0,0,0,1,1,0,0,48,0,6,13,3,10.0,0,0,6,15,1,10.0,0,7.6,2.6,0.32,0 +Student_02246,1,17,9238,1,4,1,1,37,37,9,8,129.0,117.1,1,0,0,1,1,0,0,21,0,6,6,6,12.333333333333334,0,0,6,7,6,13.666666666666666,0,8.9,1.4,3.51,2 +Student_02247,1,17,9500,1,1,1,1,1,1,4,5,128.0,124.7,0,0,0,1,1,1,0,19,0,7,11,6,12.528571428571428,0,0,7,10,6,12.416666666666666,0,15.5,2.8,-4.06,1 +Student_02250,1,1,9130,1,1,1,1,1,1,4,10,141.0,NA,1,0,0,1,1,0,0,18,0,5,5,5,13.6,0,0,5,6,4,13.25,1,10.8,1.4,1.74,2 +Student_02252,1,16,171,1,1,1,1,19,37,9,7,122.0,133.9,1,0,0,1,1,0,0,25,9,13,16,10,11.454545454545457,0,5,11,13,7,12.25,0,12.4,0.5,1.79,0 +Student_02253,1,7,9085,1,1,40,1,5,3,2,2,140.0,140.0,0,0,1,1,1,0,0,27,8,13,13,8,13.5,2,5,11,12,5,14.4,0,11.1,0.6,2.02,0 +Student_02254,NA,39,9119,1,1,12,1,34,34,0,0,133.1,95.1,0,0,0,0,1,0,0,49,0,5,5,0,0.0,0,0,5,6,0,0.0,0,10.8,1.4,1.74,0 +Student_02255,1,39,9991,0,1,1,1,19,37,5,5,120.0,128.2,0,0,0,0,1,0,0,31,0,5,5,2,11.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02256,1,39,9254,1,1,1,1,37,37,9,6,133.1,121.5,0,0,0,1,1,0,0,54,0,6,9,6,13.714285714285714,0,0,6,13,5,14.333333333333334,0,16.2,0.3,-0.92,0 +Student_02257,1,7,33,1,1,40,1,38,37,5,6,120.0,120.0,1,0,1,0,1,0,0,25,18,21,26,21,12.363636363636363,0,12,16,21,12,12.25,1,11.1,0.6,2.02,0 +Student_02258,1,44,9003,1,1,39,1,5,3,2,2,130.0,130.0,0,0,0,1,1,0,0,20,1,7,13,3,10.666666666666666,0,0,6,14,2,11.5,0,15.5,2.8,-4.06,1 +Student_02259,1,7,9070,1,1,3,1,4,4,2,2,120.0,120.0,0,0,0,1,1,0,0,28,0,6,9,2,12.0,0,0,6,10,3,12.666666666666666,0,12.7,3.7,-1.7,0 +Student_02260,2,39,8014,0,1,19,1,37,37,9,6,133.1,107.0,0,0,0,1,1,0,0,41,1,7,7,7,12.857142857142858,0,0,6,6,6,13.166666666666666,0,12.7,3.7,-1.7,2 +Student_02261,1,1,9670,1,2,1,1,1,19,4,4,122.0,116.1,0,0,0,1,1,1,0,19,0,6,10,6,13.125,0,0,6,9,6,12.714285714285714,0,11.1,0.6,2.02,1 +Student_02262,1,43,9147,1,1,1,1,1,1,4,4,123.0,114.4,0,0,0,1,1,0,0,22,0,5,6,0,0.0,0,0,5,8,2,11.5,0,15.5,2.8,-4.06,0 +Student_02263,1,1,9254,1,1,1,1,2,1,2,3,178.0,157.7,0,0,0,1,1,0,0,34,0,6,13,2,13.5,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_02264,1,39,9003,1,1,1,1,38,38,9,9,130.0,150.0,0,0,1,0,1,0,0,28,5,11,14,11,15.090909090909092,0,5,10,11,10,15.0,0,NA,0.6,2.02,0 +Student_02265,1,1,9853,1,1,1,1,37,37,9,4,110.0,114.3,1,0,0,1,1,0,0,42,0,6,9,5,12.4,0,0,6,10,5,11.8,0,7.6,2.6,0.32,1 +Student_02266,1,18,9085,1,1,1,1,1,19,3,5,106.0,104.6,0,0,0,0,1,0,0,21,0,6,10,5,14.0,0,0,6,11,4,14.8,0,11.1,0.6,NA,1 +Student_02267,1,7,9003,1,1,3,1,39,39,9,4,140.0,140.0,0,0,0,NA,1,0,0,50,2,6,8,2,13.5,0,1,6,9,1,13.0,0,15.5,2.8,-4.06,0 +Student_02268,1,1,9147,1,4,1,1,3,1,3,4,108.0,109.1,1,0,0,1,1,0,0,19,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.4,0.5,1.79,0 +Student_02269,1,43,9500,1,1,1,1,3,4,2,4,120.0,120.6,0,0,0,1,1,0,0,18,0,7,12,4,12.65,0,0,7,10,3,10.666666666666666,0,16.2,0.3,-0.92,0 +Student_02270,2,39,9991,0,1,1,1,37,37,1,1,100.0,161.9,0,0,0,1,1,0,0,59,0,5,7,0,0.0,0,0,5,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_02271,2,7,9991,0,1,3,1,34,34,99,99,140.0,140.0,1,0,0,0,1,0,0,33,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_02272,1,17,9070,1,2,1,1,37,38,9,10,133.1,NA,1,0,0,1,1,1,0,23,0,6,8,6,13.333333333333334,0,0,6,7,5,12.8,0,9.4,-0.8,-3.12,2 +Student_02273,2,39,9991,0,1,19,1,37,1,5,5,133.1,138.3,0,0,0,1,1,0,0,44,0,5,9,3,11.333333333333334,0,0,5,8,5,11.142857142857142,0,13.9,-0.3,0.79,0 +Student_02274,2,1,8014,0,4,1,1,34,34,0,0,140.0,128.0,1,0,0,1,1,0,0,37,0,6,0,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02275,2,39,171,1,1,19,1,37,37,9,9,100.0,139.0,0,0,0,1,1,0,0,36,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_02276,1,1,9991,0,2,1,1,1,3,4,2,123.0,113.2,0,0,0,0,1,0,0,22,0,5,7,3,11.666666666666666,0,0,5,8,2,10.5,2,7.6,2.6,0.32,0 +Student_02277,NA,39,8014,0,1,19,1,37,37,6,6,133.1,139.0,0,0,0,1,1,0,0,49,0,6,8,6,12.166666666666666,0,0,6,8,6,14.428571428571429,0,12.4,0.5,1.79,2 +Student_02278,1,NA,9773,1,1,1,1,1,42,5,3,135.0,110.0,1,0,0,1,1,0,0,23,0,6,7,6,13.333333333333334,0,0,6,6,4,12.75,0,11.1,0.6,2.02,2 +Student_02279,NA,1,9070,1,1,1,1,1,1,4,9,132.0,136.6,1,0,0,1,1,0,0,19,0,6,7,5,11.4,0,0,6,10,3,11.0,3,7.6,2.6,0.32,1 +Student_02280,2,43,8014,0,1,1,1,37,37,5,5,120.0,161.1,0,0,0,1,1,0,0,47,0,6,9,6,NA,0,0,6,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_02281,1,43,9003,1,1,1,1,1,2,4,2,130.0,130.0,0,0,0,1,1,0,0,28,9,18,36,17,13.058823529411764,1,6,12,15,12,12.307692307692308,0,15.5,2.8,-4.06,2 +Student_02282,1,44,9003,1,1,39,NA,1,38,9,6,140.0,140.0,0,0,0,1,1,0,0,21,0,6,13,4,11.75,0,0,6,15,4,10.5,0,15.5,2.8,-4.06,1 +Student_02283,1,1,9254,1,1,1,1,38,1,9,9,133.1,121.0,0,0,1,0,NA,0,0,21,0,6,9,5,11.833333333333334,0,0,6,8,5,10.0,0,8.9,1.4,3.51,0 +Student_02284,1,43,9238,1,1,39,1,2,1,1,2,120.0,118.6,0,0,0,1,1,0,0,21,9,11,14,10,12.4,0,6,10,13,10,11.8,0,13.9,-0.3,0.79,2 +Student_02285,1,1,9070,1,1,1,1,19,38,4,4,140.0,138.3,0,0,0,1,1,0,0,20,1,6,8,6,13.428571428571429,1,0,6,12,4,NA,0,13.9,-0.3,0.79,1 +Student_02286,2,42,9147,1,1,1,1,37,37,9,9,133.1,115.8,0,0,0,0,1,0,0,49,0,5,5,0,0.0,0,0,5,9,0,0.0,0,10.8,1.4,1.74,0 +Student_02287,1,39,9991,0,1,1,1,19,37,6,8,120.0,160.0,0,0,0,1,NA,0,0,40,0,5,5,5,11.0,0,0,5,5,5,13.4,0,15.5,2.8,-4.06,2 +Student_02288,1,17,9254,1,1,1,1,1,1,3,3,125.0,114.5,0,0,0,1,1,1,0,22,0,6,8,6,13.625,0,0,6,8,6,14.428571428571429,0,11.1,0.6,2.02,2 +Student_02289,1,42,9119,1,1,1,1,1,37,5,5,136.0,117.5,0,0,0,1,1,0,0,19,2,5,6,4,11.8,0,0,5,7,2,11.5,0,15.5,2.8,-4.06,1 +Student_02290,1,39,9991,0,1,1,1,3,38,2,7,133.1,121.7,0,0,0,1,1,0,0,31,0,5,5,0,0.0,0,0,5,7,0,0.0,0,13.9,-0.3,0.79,0 +Student_02292,1,1,9238,1,1,1,1,37,37,5,10,127.0,125.3,0,0,0,1,1,0,0,19,0,6,9,5,10.8,0,0,6,11,5,11.0,0,7.6,2.6,0.32,2 +Student_02293,1,18,9147,1,1,1,1,34,34,90,90,131.0,131.0,0,0,0,1,1,0,0,22,0,5,11,3,13.666666666666666,0,0,5,10,3,11.333333333333334,0,9.4,-0.8,-3.12,0 +Student_02294,1,1,9773,1,1,1,1,19,37,9,9,127.0,126.3,0,0,0,1,1,0,0,19,0,6,8,6,12.833333333333334,0,0,6,8,6,13.333333333333334,0,15.5,2.8,-4.06,2 +Student_02296,1,17,9670,1,3,1,1,1,38,4,7,137.0,138.4,0,0,0,1,1,0,0,19,0,6,8,6,15.125,0,0,6,7,6,13.428571428571429,0,11.1,0.6,2.02,2 +Student_02297,1,43,9147,1,2,1,1,1,19,3,3,126.0,100.0,1,0,0,1,1,0,0,22,0,5,11,0,0.0,0,0,5,7,1,10.0,1,16.2,0.3,-0.92,0 +Student_02298,1,1,9238,1,1,1,1,4,5,2,2,136.0,126.2,0,0,0,1,1,0,0,22,0,6,10,5,11.4,0,0,6,8,5,11.0,0,10.8,1.4,1.74,2 +Student_02299,1,1,9238,1,1,1,1,1,1,4,4,124.0,118.8,0,0,0,1,1,0,0,19,0,6,12,4,12.25,0,0,6,9,6,11.0,0,9.4,-0.8,-3.12,2 +Student_02302,1,17,9070,1,1,1,1,19,19,7,7,131.0,125.1,0,0,0,1,1,0,0,18,0,6,7,6,12.333333333333334,0,0,6,10,5,10.8,4,16.2,0.3,-0.92,1 +Student_02303,1,1,9147,1,1,1,1,37,37,9,9,130.0,118.8,0,0,1,1,1,1,0,22,0,5,8,5,10.666666666666666,0,0,5,11,2,11.0,0,15.5,2.8,-4.06,1 +Student_02304,1,18,9119,1,5,1,1,3,2,2,3,136.0,125.2,1,0,0,1,1,0,0,19,0,5,9,5,11.833333333333334,0,0,5,9,5,14.714285714285714,0,12.4,0.5,1.79,1 +Student_02305,1,17,9147,1,1,1,1,1,19,4,8,133.1,95.0,0,0,0,1,1,0,0,20,0,5,14,0,0.0,0,0,5,5,0,0.0,0,11.1,0.6,2.02,0 +Student_02306,1,1,9070,1,3,1,1,37,37,9,9,110.0,107.6,1,0,0,1,1,1,0,22,0,6,6,6,11.666666666666666,0,0,6,6,6,12.166666666666666,0,7.6,2.6,0.32,1 +Student_02307,1,7,9130,1,1,3,1,2,38,2,3,140.0,140.0,1,0,0,0,1,0,0,18,2,5,7,2,13.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_02308,4,43,9991,0,2,38,1,3,1,2,9,133.1,125.4,0,0,0,1,1,0,0,39,0,2,5,0,0.0,0,0,4,4,0,0.0,0,10.8,1.4,1.74,0 +Student_02309,1,1,9500,1,1,1,1,19,1,90,NA,141.0,128.0,0,0,0,1,1,0,0,18,0,8,8,0,0.0,3,0,8,8,0,0.0,3,10.8,1.4,1.74,0 +Student_02310,1,17,9119,1,3,1,1,1,38,3,3,130.0,129.3,0,0,0,1,1,1,0,18,0,5,5,5,13.0,0,0,5,5,5,14.2,0,8.9,1.4,3.51,2 +Student_02311,1,1,9238,1,1,1,1,19,38,9,9,160.0,152.0,0,0,0,1,1,1,0,19,0,6,7,6,13.857142857142858,0,0,6,6,6,14.0,0,13.9,-0.3,0.79,2 +Student_02312,1,1,9500,1,1,1,1,1,19,9,9,140.0,128.8,0,0,0,1,1,0,0,18,0,7,7,6,13.391666666666666,0,0,8,8,8,12.4875,0,12.4,0.5,1.79,2 +Student_02313,1,1,9147,1,1,1,1,34,19,0,4,150.0,152.8,1,0,0,1,1,1,0,18,0,5,7,4,12.75,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_02314,1,44,9130,1,1,39,1,37,37,6,6,150.0,150.0,1,0,0,1,1,0,0,22,0,5,7,4,14.5,0,0,5,5,5,14.6,0,10.8,1.4,1.74,2 +Student_02315,1,1,9238,1,1,1,1,1,1,3,4,133.1,112.0,0,0,0,1,1,0,0,19,0,6,7,6,12.166666666666666,0,0,6,6,6,12.166666666666666,0,12.4,0.5,1.79,2 +Student_02316,1,1,9130,1,1,1,1,19,37,9,8,152.0,135.6,1,0,0,1,1,0,0,18,0,5,5,5,15.4,0,0,5,5,5,15.6,0,12.7,3.7,-1.7,0 +Student_02317,1,39,9119,1,1,19,1,1,1,4,3,133.1,134.4,0,0,1,0,1,0,0,31,0,5,9,2,13.333333333333334,0,0,5,9,2,16.0,4,16.2,0.3,-0.92,0 +Student_02318,1,39,9991,0,1,1,1,3,1,3,3,130.0,120.5,0,0,0,1,1,0,0,28,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_02319,1,1,9070,1,1,1,1,1,1,4,8,148.0,141.4,0,0,0,1,1,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,NA,0 +Student_02320,1,17,9254,1,1,1,1,1,1,4,8,148.0,145.2,0,0,0,1,1,0,0,20,0,6,7,6,13.714285714285714,0,0,6,8,6,14.714285714285714,0,16.2,0.3,-0.92,2 +Student_02322,1,43,9070,1,1,1,1,1,2,4,2,160.0,100.0,0,0,0,1,1,0,0,38,1,6,9,5,16.0,1,0,6,11,4,16.5,0,13.9,-0.3,0.79,1 +Student_02323,2,39,9991,0,1,1,1,37,37,9,9,130.0,140.0,1,0,0,1,1,0,0,31,0,5,8,1,11.0,0,0,5,5,1,13.0,0,9.4,-0.8,-3.12,0 +Student_02324,1,39,9500,1,1,1,1,1,37,9,9,110.0,126.0,1,0,0,1,1,0,0,27,0,7,7,7,14.085714285714284,0,0,7,7,7,14.085714285714284,0,7.6,2.6,0.32,1 +Student_02325,1,18,9238,1,1,1,1,1,3,9,2,NA,112.6,1,0,0,1,1,0,0,21,0,6,9,6,10.166666666666666,0,0,6,10,6,10.5,0,12.7,3.7,-1.7,2 +Student_02326,2,39,9119,1,1,1,1,37,37,9,9,110.0,106.8,0,0,0,1,1,0,0,34,0,5,8,1,10.0,0,0,5,9,0,0.0,0,8.9,1.4,3.51,0 +Student_02329,1,1,171,1,1,1,1,38,19,9,2,170.0,160.6,1,0,0,1,1,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_02330,2,39,9070,1,1,12,1,37,38,5,10,110.0,130.0,0,0,1,0,1,1,0,46,0,6,6,0,0.0,0,0,6,6,0,0.0,0,15.5,2.8,NA,0 +Student_02332,1,39,9003,1,1,1,1,19,37,9,7,133.1,110.0,1,0,0,1,1,0,0,31,0,6,8,0,0.0,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_02335,1,1,9670,1,1,1,1,38,37,9,NA,137.0,122.3,0,0,0,1,1,1,0,18,0,6,7,6,13.571428571428571,0,0,6,6,6,14.333333333333334,0,12.4,0.5,1.79,2 +Student_02337,1,43,9991,0,1,1,1,NA,19,9,4,100.0,130.0,0,0,0,1,1,0,0,40,1,5,6,4,10.25,0,3,8,18,5,11.2,5,15.5,2.8,-4.06,0 +Student_02338,1,39,9130,1,1,1,1,1,38,9,9,120.0,150.0,0,0,0,1,1,0,0,25,0,6,6,0,0.0,0,0,6,6,0,0.0,0,12.4,0.5,1.79,0 +Student_02339,1,17,9119,1,5,1,1,38,38,5,9,126.0,116.9,1,0,1,1,1,0,0,20,0,5,5,4,14.5,0,0,6,8,3,13.333333333333334,0,11.1,0.6,2.02,0 +Student_02340,1,17,9119,1,1,1,1,19,19,9,9,122.0,114.7,0,0,0,1,1,0,0,20,0,5,6,5,15.8,0,0,5,8,5,13.714285714285714,0,11.1,0.6,2.02,1 +Student_02341,1,39,9003,1,1,1,1,37,37,9,10,111.0,95.8,1,0,0,0,1,0,0,NA,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_02342,1,17,9119,1,4,1,1,37,19,9,4,139.0,133.1,1,0,0,1,1,0,0,18,0,5,8,4,12.5,0,0,5,7,3,14.666666666666666,1,7.6,2.6,0.32,1 +Student_02344,1,17,9991,0,2,1,1,37,19,9,4,116.0,118.5,0,0,0,1,1,0,0,23,0,5,6,4,13.0,0,0,5,5,5,13.0,0,7.6,2.6,0.32,2 +Student_02346,1,53,9085,1,1,42,1,1,19,3,8,150.0,150.3,1,0,0,1,1,1,0,21,7,11,15,9,14.22222222222222,0,4,9,15,7,13.75,0,8.9,1.4,3.51,2 +Student_02347,1,43,9670,1,1,1,1,3,19,4,8,132.0,120.5,0,0,0,1,1,0,0,19,0,6,17,4,12.5,0,0,6,8,4,13.25,0,13.9,-0.3,0.79,1 +Student_02348,1,18,9119,1,1,1,1,1,1,4,3,108.0,105.6,1,0,0,1,1,0,0,20,0,5,7,5,12.166666666666666,0,0,5,7,5,15.285714285714286,0,12.4,0.5,1.79,2 +Student_02350,4,39,9254,1,1,1,1,37,19,9,9,120.0,131.0,1,0,0,1,1,0,0,44,0,6,6,6,12.666666666666666,0,0,6,6,6,11.5,0,12.4,0.5,1.79,2 +Student_02351,1,18,9500,1,1,1,1,19,3,4,9,NA,127.0,0,0,0,1,1,0,0,19,0,8,8,7,13.614285714285714,0,0,8,8,7,13.614285714285714,0,12.7,3.7,-1.7,2 +Student_02352,1,44,9130,1,1,39,1,2,1,3,6,150.0,150.0,1,0,0,1,1,0,0,22,11,18,32,12,12.857142857142858,1,8,12,15,10,14.3,0,16.2,0.3,-0.92,2 +Student_02353,1,1,9130,1,1,1,1,3,3,1,2,160.0,149.2,0,0,0,1,1,0,0,18,0,5,7,4,14.0,0,0,5,5,5,14.2,0,7.6,2.6,0.32,2 +Student_02354,1,17,9670,1,1,1,1,37,37,9,9,125.0,121.5,1,0,0,1,1,1,0,21,0,6,8,4,14.75,0,0,6,6,5,11.8,0,12.7,3.7,-1.7,2 +Student_02355,1,1,9085,1,2,1,1,37,19,90,90,125.0,137.3,0,0,0,1,1,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_02356,1,17,9670,1,4,1,1,3,1,2,3,122.0,119.6,1,0,0,1,1,0,0,18,0,6,8,6,13.625,0,0,6,7,6,14.285714285714286,0,11.1,0.6,2.02,2 +Student_02357,1,1,171,1,1,1,1,1,1,4,3,138.0,141.5,0,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_02358,1,44,9003,1,1,39,1,1,38,6,6,150.0,150.0,1,0,0,1,1,0,0,21,0,6,12,4,11.8,0,0,6,11,4,11.875,0,16.2,0.3,-0.92,0 +Student_02359,1,39,9003,1,1,1,1,3,3,2,2,140.0,110.0,0,0,0,1,1,0,0,31,0,6,8,6,15.125,0,0,6,10,6,14.6,0,16.2,0.3,-0.92,2 +Student_02361,1,39,9119,1,1,1,1,19,19,9,7,139.0,110.3,0,0,1,1,1,0,0,24,0,5,12,1,10.0,0,0,5,11,1,11.0,0,8.9,1.4,3.51,1 +Student_02362,1,42,9773,1,1,1,1,19,6,4,3,133.1,120.0,0,0,0,1,1,0,0,27,0,4,8,0,0.0,0,0,5,10,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02363,1,1,9147,1,5,1,1,19,19,9,9,118.0,114.2,1,0,0,1,1,0,0,20,0,5,9,3,10.333333333333334,0,0,5,6,5,12.8,0,12.4,0.5,1.79,2 +Student_02364,1,44,9119,1,1,39,1,1,19,4,5,140.0,140.0,1,0,0,1,1,0,0,22,0,5,9,0,0.0,0,0,5,6,2,11.666666666666666,0,10.8,1.4,1.74,1 +Student_02365,1,1,9003,1,1,1,1,19,19,9,9,144.0,132.8,0,0,0,1,1,1,0,19,0,6,9,4,12.0,2,0,6,10,4,12.5,0,15.5,2.8,-4.06,1 +Student_02366,1,18,9773,1,1,1,1,1,1,4,7,125.0,121.5,1,0,0,1,1,0,0,19,0,6,6,6,13.833333333333334,0,0,6,6,6,14.5,0,8.9,1.4,3.51,2 +Student_02367,1,1,171,1,1,1,1,1,1,7,4,131.0,127.2,1,0,1,1,1,0,0,23,13,17,19,13,12.153846153846152,0,10,17,28,11,11.909090909090908,1,11.1,0.6,2.02,1 +Student_02369,1,1,9773,1,1,1,1,3,2,4,6,140.0,133.4,1,0,0,0,1,0,0,29,0,6,8,6,16.5,0,0,6,6,5,13.8,0,11.1,0.6,2.02,1 +Student_02371,1,NA,9003,1,1,1,1,1,1,4,5,140.0,140.0,0,0,0,1,1,0,0,20,0,6,11,6,11.285714285714286,0,0,6,12,5,11.77777777777778,0,16.2,0.3,-0.92,1 +Student_02372,1,1,171,1,5,1,1,19,3,9,2,139.0,136.9,1,0,0,1,1,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_02373,1,17,171,1,3,1,1,3,39,2,5,125.0,117.0,1,1,0,1,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,1 +Student_02374,1,1,9670,1,2,1,1,3,1,3,5,117.0,110.7,1,0,0,1,1,0,0,20,0,6,10,5,14.0,0,0,6,10,6,12.0,0,11.1,0.6,2.02,1 +Student_02375,1,39,9130,1,1,1,1,19,19,9,5,150.0,160.0,1,0,0,1,1,0,0,24,0,5,13,4,13.75,1,0,5,9,3,12.0,0,9.4,-0.8,-3.12,1 +Student_02376,1,1,9670,1,1,1,1,37,37,5,8,95.0,95.0,0,0,0,0,1,0,0,21,0,6,9,4,13.25,0,0,6,6,5,11.0,0,12.7,3.7,-1.7,0 +Student_02377,1,39,9147,1,1,1,1,37,1,7,3,150.0,148.8,0,0,0,1,1,1,0,25,0,5,7,4,14.25,0,0,5,7,4,14.75,0,12.7,3.7,-1.7,2 +Student_02378,1,39,9147,1,1,1,1,37,37,9,9,120.0,110.0,0,0,0,0,1,0,0,32,0,5,9,0,0.0,1,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02379,1,43,9991,0,1,1,1,3,4,2,2,136.0,133.9,0,0,0,0,1,0,0,26,8,12,12,8,11.25,0,3,8,8,3,11.333333333333334,0,7.6,2.6,0.32,0 +Student_02380,1,1,9130,1,1,1,1,2,37,9,7,133.0,125.7,1,0,0,1,1,1,0,18,0,6,7,6,13.5,0,0,6,8,6,12.5,0,12.4,0.5,1.79,2 +Student_02382,1,1,9070,1,3,1,1,19,38,5,7,127.0,141.0,1,0,0,1,1,1,0,19,0,6,6,6,15.166666666666666,0,0,6,6,6,12.333333333333334,0,12.4,0.5,1.79,2 +Student_02383,1,7,9119,1,1,40,1,1,1,4,4,130.0,130.0,0,0,0,1,1,0,0,27,4,6,6,6,13.166666666666666,0,2,5,7,5,15.142857142857142,0,11.1,0.6,2.02,0 +Student_02384,1,53,9003,1,1,1,1,19,1,9,9,130.0,130.0,0,0,1,1,1,0,0,21,7,12,20,10,11.8,0,5,12,15,9,11.444444444444445,0,8.9,1.4,3.51,1 +Student_02385,1,17,9119,1,1,1,1,19,1,4,5,127.0,115.8,0,0,0,1,1,0,0,20,0,5,10,4,11.5,0,0,5,11,0,0.0,0,13.9,-0.3,0.79,1 +Student_02386,1,44,9070,1,1,39,1,19,38,4,0,140.0,140.0,1,0,0,1,1,0,0,21,0,6,6,6,14.5,0,0,6,8,6,11.333333333333334,0,12.4,0.5,1.79,2 +Student_02387,1,1,9773,1,5,1,1,37,3,5,2,125.0,126.1,1,0,0,1,1,0,0,22,0,6,10,5,13.4,0,0,6,12,3,10.666666666666666,0,9.4,-0.8,-3.12,1 +Student_02388,1,1,171,1,1,1,1,1,38,5,7,135.0,137.5,1,0,1,0,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_02389,1,17,9147,1,4,1,1,38,19,5,5,132.0,120.8,1,0,0,1,1,1,0,18,0,5,8,4,10.8,0,0,5,10,2,12.5,0,11.1,0.6,2.02,0 +Student_02391,2,39,9003,1,1,1,1,1,37,9,1,130.0,122.0,0,0,1,0,1,0,0,25,3,10,23,6,11.428571428571429,0,2,7,15,4,12.0,1,15.5,2.8,-4.06,0 +Student_02392,1,43,9003,1,1,1,1,37,1,5,4,130.0,130.0,0,0,0,1,1,0,0,25,8,14,24,8,12.5,2,6,13,23,10,11.6,0,15.5,2.8,-4.06,0 +Student_02393,1,1,9147,1,1,1,1,38,19,9,5,135.0,126.3,0,0,0,1,1,0,0,18,0,5,11,2,13.5,0,0,5,11,3,12.333333333333334,0,8.9,1.4,3.51,1 +Student_02394,1,1,9254,1,1,1,1,4,19,4,5,133.1,98.0,0,0,0,1,1,0,0,26,0,6,6,0,0.0,0,0,6,12,0,0.0,0,10.8,1.4,NA,0 +Student_02395,1,17,9147,1,3,1,1,37,37,6,5,135.0,121.0,1,0,0,1,1,1,0,18,0,5,8,5,12.75,0,0,5,7,5,11.5,0,13.9,-0.3,0.79,2 +Student_02396,1,43,9773,1,1,1,1,19,38,9,7,128.0,124.2,1,0,0,1,1,0,0,22,0,6,17,3,11.333333333333334,3,0,6,14,3,12.333333333333334,0,15.5,2.8,-4.06,1 +Student_02397,1,39,9003,1,1,1,1,1,3,4,5,140.0,130.0,0,0,0,1,1,0,0,25,0,6,8,0,0.0,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_02398,1,1,9773,1,2,1,1,3,1,4,4,135.0,136.1,1,0,0,1,1,0,0,19,0,6,9,5,11.4,0,0,6,13,5,12.4,0,8.9,1.4,3.51,1 +Student_02399,1,17,9773,1,2,1,1,3,19,2,3,131.0,132.8,1,0,0,1,1,0,0,19,0,6,7,6,14.428571428571429,0,0,6,7,6,14.571428571428571,0,13.9,-0.3,0.79,2 +Student_02400,1,17,9500,1,1,1,1,1,1,5,5,131.0,126.3,0,0,0,1,1,0,0,19,0,7,9,7,12.492857142857144,0,0,8,10,8,11.7125,0,16.2,0.3,-0.92,2 +Student_02401,4,39,8014,0,1,19,1,1,37,9,1,100.0,111.5,0,0,0,1,1,0,0,45,2,8,10,4,11.5,0,2,8,13,4,11.0,0,10.8,1.4,1.74,0 +Student_02402,NA,39,9991,0,1,1,1,37,37,9,9,140.0,118.2,0,0,0,1,1,0,0,52,0,5,7,5,11.2,0,0,5,6,5,12.8,1,7.6,2.6,0.32,2 +Student_02403,1,1,9147,1,1,1,1,19,19,9,3,124.0,115.6,1,0,0,0,1,0,0,20,0,5,9,3,12.0,1,0,5,7,3,11.0,0,9.4,-0.8,-3.12,0 +Student_02404,1,1,9500,1,1,1,1,38,37,5,10,130.0,117.8,1,0,0,1,1,0,0,19,0,8,8,7,15.885714285714286,0,0,8,8,7,15.885714285714286,0,10.8,1.4,1.74,2 +Student_02405,1,1,NA,1,1,1,1,1,38,9,9,142.0,127.0,0,0,1,0,1,0,0,21,0,7,12,4,12.94,0,0,7,12,4,11.58,0,12.4,0.5,1.79,0 +Student_02406,2,39,8014,0,1,1,1,37,37,9,9,150.0,140.0,0,0,0,0,1,0,0,35,0,6,6,6,14.0,0,0,6,6,6,14.166666666666666,0,9.4,-0.8,-3.12,2 +Student_02408,4,39,9500,1,1,19,1,37,38,5,5,110.0,151.0,0,0,1,0,1,0,0,47,0,7,7,0,0.0,7,0,8,8,0,0.0,8,15.5,2.8,-4.06,0 +Student_02410,2,39,9991,0,1,1,1,37,37,9,9,100.0,125.3,1,0,0,1,1,0,0,41,0,5,8,4,11.25,0,0,5,8,3,11.0,1,7.6,2.6,0.32,0 +Student_02411,1,7,9119,1,1,3,1,34,34,90,90,130.0,130.0,0,0,0,1,1,0,0,26,0,5,5,0,0.0,0,0,5,6,0,0.0,0,NA,1.4,1.74,0 +Student_02415,1,43,9147,1,2,1,1,34,37,9,9,130.0,118.5,1,0,0,1,1,0,0,23,5,10,19,8,11.625,1,4,10,16,10,11.181818181818182,3,7.6,2.6,0.32,2 +Student_02416,1,43,9238,1,2,1,1,34,30,0,5,129.0,118.9,1,0,0,1,1,0,0,22,0,6,11,0,0.0,0,0,5,10,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02419,1,53,171,1,1,42,1,1,19,9,9,130.0,130.0,1,0,0,0,1,1,0,22,5,12,15,11,12.545454545454543,0,4,11,16,11,12.666666666666666,0,8.9,1.4,3.51,2 +Student_02420,1,39,9003,1,1,1,6,1,1,192,144,133.1,129.8,0,0,0,1,1,0,1,24,0,7,7,7,13.571428571428571,0,0,6,9,5,13.4,0,8.9,1.4,3.51,1 +Student_02422,2,39,9991,0,1,19,1,37,37,5,5,133.1,111.9,1,0,0,1,1,0,0,41,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_02423,1,39,9003,1,1,1,1,37,37,9,9,NA,150.1,1,0,0,1,1,0,0,43,0,6,9,6,14.77777777777778,0,0,6,11,5,12.2,0,13.9,-0.3,0.79,2 +Student_02425,1,39,9119,1,2,1,1,37,37,5,5,120.0,128.0,0,0,0,1,1,0,0,30,0,2,2,0,0.0,0,0,2,2,0,0.0,0,7.6,2.6,0.32,0 +Student_02426,1,39,9147,1,2,38,1,19,38,9,9,133.1,102.5,0,0,0,0,1,0,0,26,0,4,4,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02428,2,39,9670,1,2,1,1,37,37,9,9,100.0,110.0,0,0,0,1,1,1,0,36,0,5,5,5,11.4,0,0,5,7,5,11.6,0,9.4,-0.8,-3.12,2 +Student_02429,1,39,9003,1,1,19,1,1,19,4,10,133.1,114.0,0,0,0,1,1,0,0,29,3,9,13,6,11.666666666666666,0,2,7,10,6,10.857142857142858,0,15.5,2.8,-4.06,0 +Student_02430,1,42,9119,1,1,1,1,34,34,0,0,120.0,128.2,1,0,0,1,1,0,0,35,6,10,12,7,11.285714285714286,0,2,8,8,5,13.0,0,9.4,-0.8,-3.12,0 +Student_02431,1,1,9773,1,1,1,1,NA,38,6,3,128.0,116.5,0,0,0,1,1,1,0,18,0,6,12,4,11.5,0,0,6,10,5,12.6,0,10.8,1.4,1.74,2 +Student_02433,1,1,9773,1,3,1,1,38,38,9,7,146.0,134.1,1,0,0,1,1,1,0,18,0,6,6,6,12.5,0,0,6,7,6,12.666666666666666,0,10.8,1.4,1.74,0 +Student_02436,1,42,9119,1,1,1,1,38,37,5,8,150.0,133.5,1,0,0,1,1,0,0,21,0,5,10,5,13.0,0,0,5,10,5,12.6,0,9.4,-0.8,-3.12,2 +Student_02437,1,39,9003,1,1,1,1,1,3,2,6,130.0,110.0,0,0,0,1,1,0,0,32,8,18,27,13,13.714285714285714,1,7,12,18,12,12.083333333333334,0,15.5,2.8,-4.06,2 +Student_02438,1,1,9119,1,4,1,1,37,37,9,5,111.0,107.5,1,0,0,1,1,1,0,22,0,5,9,3,12.333333333333334,0,0,6,14,3,12.5,0,11.1,0.6,2.02,0 +Student_02439,1,7,9003,1,1,3,1,1,38,9,7,130.0,130.0,1,0,0,0,1,0,0,32,11,17,31,11,12.727272727272728,4,10,12,24,10,12.7,1,15.5,2.8,-4.06,0 +Student_02440,1,43,9670,1,1,6,1,34,34,0,0,170.0,111.6,0,0,0,1,1,0,0,35,1,5,5,1,14.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02441,1,18,9147,1,3,1,1,1,38,4,7,133.1,101.0,1,0,0,0,1,0,0,23,0,5,0,0,0.0,0,0,5,0,0,0.0,0,8.9,1.4,3.51,0 +Student_02442,1,39,8014,0,1,1,1,37,37,6,6,100.0,108.3,0,0,0,1,1,0,0,39,0,6,8,5,11.4,0,1,6,12,3,11.0,1,7.6,2.6,0.32,1 +Student_02443,2,43,9670,1,1,1,1,34,34,0,0,120.0,128.2,0,0,0,1,1,0,0,35,0,5,5,0,0.0,0,0,5,5,1,10.0,0,9.4,-0.8,-3.12,0 +Student_02444,2,39,9003,1,1,3,1,3,19,4,6,110.0,150.0,0,0,0,1,1,0,0,32,0,6,8,6,18.875,0,6,12,14,12,17.692307692307693,0,16.2,0.3,-0.92,2 +Student_02445,1,1,NA,1,1,1,1,34,34,0,0,133.1,142.8,0,0,0,1,1,0,0,20,0,6,12,0,0.0,0,0,6,12,0,0.0,0,7.6,2.6,0.32,0 +Student_02446,1,39,9500,1,1,1,1,37,37,9,9,120.0,100.0,0,0,0,1,1,0,0,34,0,7,15,6,11.333333333333334,0,0,7,16,4,12.6,0,16.2,0.3,-0.92,1 +Student_02447,1,7,9991,0,1,40,1,37,37,6,6,150.0,150.0,1,0,0,1,1,0,0,NA,3,7,9,7,13.5,0,0,5,6,5,16.2,0,8.9,1.4,3.51,0 +Student_02449,1,39,9119,1,1,19,1,37,37,9,4,120.0,98.6,0,0,1,0,1,0,0,28,0,5,10,0,0.0,0,0,5,7,0,0.0,0,12.4,0.5,1.79,0 +Student_02450,1,7,9991,0,1,3,1,37,37,9,9,130.0,130.0,0,0,0,1,1,0,0,31,9,9,9,9,14.22222222222222,0,5,5,5,5,12.8,0,12.7,3.7,-1.7,0 +Student_02452,1,39,9003,1,1,1,1,1,3,9,10,100.0,120.0,0,0,1,0,1,0,0,44,2,7,14,4,12.0,2,0,6,16,0,0.0,1,15.5,2.8,-4.06,0 +Student_02453,1,1,9085,1,1,1,1,1,1,9,NA,142.0,127.7,1,0,0,1,1,0,0,19,0,5,9,5,12.6,1,0,5,8,4,12.0,0,12.7,3.7,-1.7,2 +Student_02454,1,15,171,1,1,1,26,1,1,2,9,130.0,130.0,0,0,0,1,1,0,1,21,6,12,12,12,15.083333333333334,0,4,11,15,11,13.083333333333334,0,8.9,1.4,3.51,1 +Student_02455,1,18,9119,1,1,1,1,3,19,3,5,148.0,147.7,0,0,0,1,1,1,0,18,0,5,5,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02456,1,44,9003,1,1,39,1,19,19,5,5,170.0,170.0,1,0,0,1,1,0,0,20,0,6,8,6,14.5,0,0,6,10,6,15.3,0,16.2,0.3,-0.92,2 +Student_02457,1,39,9070,1,1,1,1,37,37,7,7,110.0,110.2,0,0,0,1,1,0,0,55,0,6,6,6,14.5,0,0,6,6,6,13.5,0,11.1,0.6,2.02,2 +Student_02458,1,1,9147,1,1,1,1,19,37,4,NA,166.0,146.4,0,0,0,1,1,0,0,27,0,5,12,3,10.0,0,0,5,12,1,13.0,0,7.6,2.6,0.32,1 +Student_02459,1,17,9119,1,2,1,1,12,19,5,5,135.0,121.0,0,0,0,1,1,0,0,19,0,5,0,0,0.0,0,0,5,0,0,0.0,0,12.4,0.5,1.79,0 +Student_02460,1,1,9147,1,1,1,1,19,37,9,9,133.0,129.9,0,0,0,1,1,0,0,18,0,5,5,5,11.6,0,0,5,5,5,13.2,0,12.4,0.5,1.79,2 +Student_02461,2,39,9773,1,1,1,1,37,37,7,4,NA,132.0,0,0,0,1,1,0,0,43,0,6,10,4,11.75,0,0,6,7,0,0.0,0,15.5,2.8,-4.06,0 +Student_02462,1,18,9254,1,3,1,1,19,19,9,6,121.0,125.9,1,0,0,1,1,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02464,1,17,9254,1,5,1,1,37,38,9,9,130.0,122.7,1,0,1,1,1,1,0,20,0,6,7,0,0.0,0,0,6,6,0,0.0,0,8.9,1.4,3.51,0 +Student_02465,2,39,9991,0,1,1,1,37,19,9,9,121.0,141.4,0,0,1,0,1,0,0,29,0,5,7,4,11.25,0,0,5,8,4,11.8,0,10.8,1.4,1.74,0 +Student_02467,1,1,9119,1,1,1,1,37,37,9,9,146.0,148.5,1,0,0,1,1,0,0,18,0,5,7,4,10.0,0,0,5,8,1,16.0,0,10.8,1.4,1.74,1 +Student_02468,1,44,9003,1,1,39,1,37,37,9,1,140.0,140.0,0,0,0,1,1,1,0,20,0,6,11,5,13.833333333333334,0,0,6,13,6,12.3,0,15.5,2.8,-4.06,1 +Student_02469,1,43,9070,1,1,1,1,38,37,8,7,125.0,131.7,1,0,0,1,1,0,0,20,3,6,6,4,12.75,0,3,9,12,3,12.666666666666666,0,12.4,0.5,1.79,0 +Student_02470,2,39,9147,1,2,1,1,37,37,9,9,120.0,104.7,1,0,0,1,1,0,0,36,0,4,4,0,0.0,0,0,5,9,0,0.0,0,10.8,1.4,1.74,0 +Student_02471,1,44,9130,1,1,39,1,5,1,2,5,150.0,150.0,1,0,0,1,1,0,0,19,1,6,13,5,11.6,0,1,6,12,2,NA,0,13.9,-0.3,0.79,1 +Student_02472,2,39,9085,1,1,19,1,37,37,90,90,110.0,110.0,0,0,0,0,1,0,0,29,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_02473,1,1,9670,1,1,1,1,1,1,9,9,120.0,129.1,1,0,0,1,1,0,0,18,0,6,6,4,11.25,0,0,6,10,3,10.333333333333334,0,10.8,1.4,1.74,0 +Student_02474,1,39,9003,1,1,1,1,1,1,1,6,133.1,120.0,0,0,0,0,1,0,0,24,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02475,1,1,9773,1,1,1,1,3,19,2,5,133.1,127.0,0,0,0,1,1,0,0,20,0,6,6,6,14.333333333333334,0,0,6,7,6,15.0,0,15.5,2.8,-4.06,2 +Student_02476,2,39,8014,0,1,19,1,19,37,9,9,133.1,151.5,0,0,1,0,1,0,0,45,0,6,7,0,0.0,0,0,5,5,0,0.0,0,16.2,0.3,-0.92,0 +Student_02477,1,43,9500,1,2,1,1,38,37,4,4,130.0,126.8,1,0,0,1,1,1,0,28,18,23,23,20,13.5,3,18,23,23,20,13.5,3,7.6,2.6,NA,2 +Student_02478,1,1,9254,1,1,1,1,19,38,9,9,160.0,140.8,1,0,0,1,1,0,0,23,0,6,8,6,12.666666666666666,0,0,6,10,5,12.2,0,7.6,2.6,0.32,1 +Student_02479,1,1,9500,1,1,1,1,1,19,4,NA,128.0,125.6,1,0,0,1,1,0,0,18,0,7,7,7,12.444285714285714,0,0,8,11,7,11.347142857142858,0,12.4,0.5,1.79,2 +Student_02480,1,1,9147,1,2,1,1,19,19,9,4,140.0,127.8,1,0,0,1,1,0,0,23,0,5,7,3,10.666666666666666,1,0,5,7,3,11.333333333333334,0,9.4,-0.8,-3.12,0 +Student_02481,1,43,171,1,1,1,1,3,3,2,2,120.0,120.0,1,0,0,1,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,1 +Student_02482,1,1,9070,1,1,1,1,19,19,5,5,140.0,131.3,0,0,0,1,1,1,0,22,1,6,6,6,12.666666666666666,0,1,6,6,5,12.4,0,12.4,0.5,1.79,2 +Student_02483,1,39,9991,0,1,12,1,37,38,5,5,120.0,155.7,0,0,0,1,1,0,0,33,0,5,5,5,13.2,0,0,5,6,5,14.833333333333334,0,10.8,1.4,1.74,2 +Student_02484,1,53,9003,1,1,42,1,1,38,9,6,130.0,128.5,0,0,0,1,1,0,0,21,7,12,20,10,12.7,0,5,12,14,11,12.181818181818182,0,8.9,1.4,3.51,2 +Student_02485,2,39,9147,1,1,1,1,37,37,9,5,100.0,170.0,0,0,0,1,1,0,0,45,0,5,6,5,14.833333333333334,0,0,5,5,5,14.8,0,15.5,2.8,-4.06,2 +Student_02486,2,39,9003,1,1,1,1,37,37,9,9,133.1,100.0,0,0,0,0,1,0,0,44,4,10,10,4,11.5,0,1,7,8,1,12.0,0,15.5,2.8,-4.06,0 +Student_02487,4,39,9670,1,1,1,1,19,19,90,99,110.0,107.2,0,0,0,1,1,0,0,42,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02489,1,17,9147,1,6,1,1,19,38,5,6,133.0,123.2,1,0,0,1,1,0,0,20,0,5,7,3,12.666666666666666,1,0,5,12,2,12.5,0,9.4,-0.8,-3.12,1 +Student_02492,1,1,9147,1,2,1,1,1,1,9,6,128.0,120.3,0,0,0,1,1,0,0,19,0,5,9,5,10.8,0,0,5,13,2,13.5,0,8.9,1.4,3.51,1 +Student_02493,1,51,8014,0,1,1,1,1,1,4,4,120.0,128.5,0,0,1,0,1,0,0,26,2,8,13,4,10.5,0,5,10,16,7,10.428571428571429,0,12.4,0.5,1.79,0 +Student_02494,2,39,9003,1,1,1,1,37,37,8,7,133.1,150.0,0,0,0,1,1,0,0,31,0,6,10,6,15.0,0,0,6,11,5,12.5,0,13.9,-0.3,0.79,2 +Student_02495,1,1,9773,1,1,1,1,1,19,9,9,142.0,136.1,0,0,1,1,1,1,0,19,0,6,6,6,12.666666666666666,0,0,6,6,6,14.0,0,16.2,0.3,-0.92,2 +Student_02496,1,39,9773,1,1,19,1,37,37,0,0,100.0,128.0,1,0,0,1,1,0,0,28,0,6,7,6,13.166666666666666,0,0,6,6,6,13.666666666666666,0,7.6,2.6,0.32,2 +Student_02497,1,1,171,1,1,1,1,19,37,9,9,149.0,158.1,1,0,0,1,1,1,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,2 +Student_02498,2,1,8014,0,2,1,1,37,1,9,10,110.0,108.7,1,0,0,1,0,0,0,43,0,6,6,6,13.0,0,0,6,6,6,12.5,0,9.4,-0.8,-3.12,2 +Student_02499,1,39,171,1,1,19,101,1,19,2,7,133.1,110.0,0,0,0,1,1,1,1,25,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_02500,1,39,9238,1,1,19,1,37,37,9,9,133.1,120.0,0,1,1,1,0,0,0,40,0,6,13,2,10.0,0,0,6,10,1,15.0,0,16.2,0.3,-0.92,0 +Student_02501,1,44,9085,1,1,39,6,5,4,1,1,150.0,150.0,0,0,0,1,NA,0,1,20,2,6,7,6,13.333333333333334,0,1,6,16,5,13.375,0,12.4,0.5,1.79,2 +Student_02502,2,39,8014,0,1,12,1,37,37,9,1,133.1,113.0,0,0,0,1,0,0,0,46,0,6,13,3,12.333333333333334,0,0,6,6,6,13.333333333333334,0,11.1,0.6,2.02,2 +Student_02503,1,51,33,1,1,1,1,19,37,5,7,121.0,118.6,0,0,0,1,0,0,0,26,14,21,23,20,13.181818181818182,0,10,14,18,14,11.642857142857142,0,8.9,1.4,3.51,2 +Student_02505,1,18,9853,1,3,1,1,38,37,9,5,122.0,120.3,1,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_02507,1,1,9556,1,1,1,1,19,19,4,9,123.0,113.8,1,0,0,1,0,0,0,18,0,7,9,7,11.155555555555557,0,0,8,10,8,11.425,0,12.7,3.7,-1.7,2 +Student_02508,1,39,8014,0,1,1,1,38,37,9,7,120.0,108.0,0,0,0,1,1,1,0,37,1,7,9,6,11.857142857142858,0,1,6,7,5,12.0,0,13.9,-0.3,0.79,2 +Student_02509,1,17,171,1,1,1,1,19,38,9,7,114.0,129.1,0,0,0,1,1,1,0,23,0,0,0,0,0.0,0,0,0,0,0,0.0,0,NA,-0.8,-3.12,2 +Student_02512,1,15,9500,1,1,1,108,3,2,122,4,190.0,190.0,1,0,0,1,0,0,1,18,0,7,15,4,11.575,0,0,7,10,5,12.419999999999998,0,NA,0.5,1.79,1 +Student_02513,1,17,9500,1,4,1,1,3,3,2,2,136.0,132.5,1,0,0,1,0,0,0,19,0,7,8,7,13.198571428571428,0,0,8,8,8,13.0625,0,11.1,0.6,2.02,2 +Student_02514,1,10,9085,1,2,1,22,19,1,4,9,163.3,163.3,0,0,0,1,0,0,1,18,0,6,10,6,13.5,0,0,6,12,6,12.0,0,12.4,0.5,1.79,2 +Student_02515,1,1,9670,1,1,1,1,1,3,4,3,126.0,122.5,1,0,0,1,0,0,0,19,0,6,6,6,13.333333333333334,0,0,6,8,5,12.8,0,8.9,1.4,3.51,0 +Student_02517,1,17,9070,1,1,1,1,1,1,1,5,137.0,131.8,0,0,0,1,0,1,0,22,0,6,7,6,12.166666666666666,0,0,6,9,4,12.0,0,9.4,-0.8,-3.12,2 +Student_02518,1,1,9500,1,3,1,1,19,1,9,5,139.0,135.0,1,0,0,1,0,1,0,18,0,8,8,7,12.214285714285714,0,0,8,8,7,12.214285714285714,0,12.7,3.7,-1.7,2 +Student_02519,1,17,9254,1,1,1,1,19,39,5,4,142.0,141.7,0,0,0,1,0,1,0,18,0,6,8,6,12.666666666666666,0,0,6,6,6,13.0,0,13.9,-0.3,0.79,2 +Student_02520,1,1,9773,1,3,NA,1,38,38,5,5,133.1,131.3,1,0,0,1,0,1,0,18,0,6,7,6,12.285714285714286,0,0,6,6,6,13.5,0,8.9,1.4,3.51,2 +Student_02521,1,1,9254,1,6,1,1,38,37,5,7,126.0,123.9,1,0,0,1,0,1,0,18,0,6,7,6,13.0,0,0,6,6,6,13.0,0,12.4,0.5,1.79,2 +Student_02522,1,1,9254,1,2,1,1,4,3,7,4,131.0,126.1,1,0,0,1,0,0,0,18,0,6,8,6,12.142857142857142,0,0,6,6,6,11.166666666666666,0,8.9,1.4,3.51,2 +Student_02523,1,17,9500,1,6,1,1,1,19,7,7,131.0,126.5,1,0,0,1,0,1,0,19,0,7,8,7,13.875714285714285,0,0,8,9,7,13.085714285714284,0,11.1,0.6,2.02,2 +Student_02524,1,17,9853,1,1,1,1,19,1,5,5,108.0,107.3,0,0,0,1,0,0,0,20,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_02525,1,17,9238,1,4,1,1,1,19,9,5,133.1,95.0,1,0,0,1,0,1,0,19,0,6,12,6,11.666666666666666,0,0,6,7,0,0.0,0,15.5,2.8,-4.06,0 +Student_02526,1,1,9085,1,2,1,1,3,1,4,7,122.0,116.1,1,0,0,NA,0,0,0,18,0,6,13,6,13.153846153846152,0,0,6,12,3,11.0,0,15.5,2.8,-4.06,2 +Student_02528,1,17,9500,1,6,1,1,19,19,7,7,135.0,128.0,1,0,0,1,0,1,0,18,0,7,7,7,14.44142857142857,0,0,8,8,8,13.65625,0,11.1,0.6,2.02,2 +Student_02529,1,17,9773,1,2,1,1,3,38,2,6,148.0,144.2,1,0,0,1,0,0,0,18,0,6,6,6,15.166666666666666,0,0,6,7,6,14.285714285714286,0,12.4,0.5,1.79,2 +Student_02531,1,17,9773,1,1,1,1,1,1,4,7,122.0,116.8,1,0,1,1,0,0,0,18,0,6,6,6,11.666666666666666,0,0,6,6,6,12.333333333333334,0,16.2,0.3,-0.92,2 +Student_02532,1,44,9003,1,1,39,1,37,38,9,6,160.0,160.0,0,0,0,1,0,1,0,20,0,6,8,6,12.625,0,0,6,10,6,13.2,0,16.2,0.3,-0.92,2 +Student_02534,1,17,9130,1,1,1,1,2,19,2,6,NA,126.3,1,0,0,1,0,1,0,18,0,6,7,6,12.833333333333334,1,0,6,8,6,13.0,0,8.9,1.4,3.51,1 +Student_02535,1,1,9238,1,1,1,1,38,38,8,7,115.0,112.9,1,0,0,1,0,1,0,19,0,6,7,6,11.857142857142858,0,0,6,8,6,13.142857142857142,0,12.4,0.5,1.79,2 +Student_02537,1,43,9130,1,1,1,41,3,4,3,2,100.0,100.0,0,0,0,1,0,0,1,19,0,5,10,5,14.857142857142858,2,0,5,7,5,15.142857142857142,0,9.4,-0.8,-3.12,1 +Student_02538,1,1,9670,1,1,1,1,19,19,7,7,130.0,121.6,0,0,0,1,0,0,0,19,0,6,7,6,14.714285714285714,0,0,6,6,6,15.833333333333334,0,12.4,0.5,1.79,2 +Student_02539,1,15,9670,1,1,1,26,42,1,2,7,130.0,130.0,0,1,1,1,0,0,1,20,0,6,6,6,13.5,0,0,6,9,5,13.0,0,8.9,1.4,3.51,2 +Student_02540,1,18,9130,1,1,1,1,38,19,9,5,135.0,121.7,1,0,0,1,0,1,0,18,0,5,7,4,11.5,0,0,5,5,5,12.4,0,10.8,1.4,1.74,2 +Student_02544,1,17,9070,1,1,1,1,19,1,4,3,108.0,111.9,0,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_02545,1,44,9003,1,1,39,1,38,38,6,3,140.0,140.0,0,0,0,1,0,0,0,19,0,6,18,3,11.666666666666666,0,0,6,14,4,11.5,0,15.5,2.8,-4.06,1 +Student_02546,1,1,9773,1,3,1,1,3,1,2,8,153.0,137.6,1,0,0,1,0,0,0,18,0,6,6,6,16.0,0,0,6,7,6,14.333333333333334,0,12.4,0.5,1.79,2 +Student_02547,1,1,9238,1,1,1,1,19,19,9,5,135.0,135.0,1,0,0,1,0,0,0,20,0,6,6,6,13.833333333333334,0,0,6,6,6,11.833333333333334,0,10.8,1.4,1.74,2 +Student_02548,1,1,9500,1,5,1,1,19,37,7,7,146.0,133.8,1,0,0,1,0,0,0,19,0,8,9,8,13.2325,1,0,8,9,8,13.2325,1,9.4,-0.8,-3.12,2 +Student_02549,1,1,9773,1,2,1,1,19,19,9,9,130.0,126.9,1,0,0,1,1,1,0,18,0,6,6,6,14.0,0,0,6,6,6,NA,0,9.4,-0.8,-3.12,2 +Student_02550,1,17,9254,1,2,1,1,1,2,5,3,113.0,106.7,1,0,1,1,1,1,0,19,0,6,14,2,10.0,0,0,6,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_02551,1,43,8014,0,1,1,22,37,37,9,9,145.7,145.7,1,0,0,1,0,0,1,25,8,16,16,15,13.333333333333334,0,11,13,13,11,12.272727272727272,0,13.9,-0.3,0.79,2 +Student_02552,1,17,9070,1,3,1,1,3,3,4,4,145.0,153.1,1,0,0,1,0,1,0,20,0,6,6,6,12.5,0,0,6,6,6,14.333333333333334,0,12.7,3.7,-1.7,1 +Student_02553,1,1,8014,0,1,1,1,38,37,5,5,126.0,118.7,0,0,0,1,0,0,0,19,0,6,6,6,12.5,0,0,6,6,6,11.5,0,12.7,3.7,-1.7,2 +Student_02554,1,17,9991,0,1,NA,1,34,34,0,0,160.0,161.8,1,0,1,1,1,0,0,33,0,5,8,2,10.5,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_02555,1,18,9119,1,4,1,1,19,38,194,175,134.0,124.9,1,0,1,1,1,0,0,18,0,5,11,3,10.666666666666666,0,0,5,9,3,11.333333333333334,0,8.9,1.4,3.51,1 +Student_02558,1,1,171,1,2,1,1,3,3,2,2,165.0,163.6,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,1 +Student_02559,1,43,9147,1,1,1,1,38,19,141,171,142.0,115.0,0,0,0,1,0,0,0,19,0,5,11,5,11.5,0,0,5,9,2,10.666666666666666,0,13.9,-0.3,0.79,1 +Student_02560,1,1,9773,1,1,1,1,19,1,5,10,156.0,136.8,1,0,0,1,0,0,0,18,0,6,6,6,14.0,0,0,6,6,6,13.5,0,11.1,0.6,2.02,0 +Student_02561,1,17,9853,1,5,1,1,3,19,2,7,141.0,130.9,1,0,0,1,0,0,0,18,0,6,7,6,13.5,0,0,6,8,5,12.6,0,7.6,2.6,0.32,2 +Student_02562,1,1,9500,1,3,1,1,19,37,7,7,143.0,127.0,1,0,0,1,0,0,0,18,0,8,8,8,13.07375,0,0,8,8,8,13.07375,0,9.4,-0.8,-3.12,2 +Student_02563,2,39,9500,1,1,19,1,38,38,2,10,133.1,120.0,0,0,0,1,0,0,0,37,0,7,9,2,10.75,0,0,7,9,0,0.0,0,16.2,0.3,-0.92,0 +Student_02564,1,1,9238,1,1,1,1,38,1,2,4,133.0,126.0,0,0,0,1,0,0,0,20,0,6,11,1,12.0,0,0,5,10,0,0.0,0,9.4,-0.8,-3.12,1 +Student_02565,1,1,9254,1,1,1,41,37,37,5,5,172.0,153.8,1,0,0,1,0,1,1,20,0,6,6,6,14.0,0,0,6,6,6,13.333333333333334,0,10.8,1.4,1.74,2 +Student_02566,1,15,9238,1,1,1,26,19,19,9,6,140.0,140.0,0,0,0,1,1,0,1,21,0,6,7,6,12.333333333333334,0,0,6,7,6,13.428571428571429,0,11.1,0.6,2.02,2 +Student_02567,1,17,9500,1,1,1,1,38,1,5,4,142.0,136.6,0,0,0,1,0,1,0,18,0,7,7,7,13.464285714285714,0,0,8,9,8,14.788888888888888,0,12.4,0.5,1.79,2 +Student_02568,1,39,8014,0,1,1,1,19,1,9,8,140.0,105.0,0,0,0,1,0,0,0,26,0,6,14,3,10.666666666666666,1,0,6,9,5,11.2,0,15.5,2.8,-4.06,1 +Student_02569,1,39,9147,1,1,12,1,37,37,9,7,133.1,139.4,0,0,1,1,0,0,0,41,0,5,6,5,11.6,0,0,5,8,5,12.2,0,7.6,2.6,0.32,1 +Student_02570,1,1,9773,1,2,1,1,NA,1,3,9,148.0,140.0,1,0,0,1,NA,1,0,18,0,6,6,6,13.666666666666666,0,0,6,6,6,14.666666666666666,0,16.2,0.3,-0.92,2 +Student_02571,1,1,9500,1,4,1,1,19,37,9,7,137.0,130.8,0,0,1,1,0,0,0,18,0,8,9,8,14.4025,1,0,8,9,8,14.4025,1,9.4,-0.8,-3.12,2 +Student_02573,1,1,9238,1,1,1,1,1,1,4,10,133.1,110.0,0,0,1,1,0,0,0,23,0,6,8,6,12.625,0,0,6,6,6,14.166666666666666,0,12.7,3.7,-1.7,2 +Student_02574,1,1,9500,1,4,1,1,37,19,9,NA,138.0,127.8,1,0,0,1,0,0,0,19,0,7,7,6,14.983333333333334,0,0,7,7,6,14.983333333333334,0,7.6,2.6,0.32,2 +Student_02577,1,44,9085,1,1,39,1,37,37,9,9,120.0,120.0,1,0,1,1,0,0,0,32,0,6,14,4,11.5,0,0,6,14,3,11.0,0,16.2,0.3,-0.92,0 +Student_02580,1,1,9238,1,1,1,1,37,37,9,9,148.0,143.5,0,0,0,1,0,0,0,18,0,6,6,6,13.0,0,0,6,6,6,12.833333333333334,0,10.8,1.4,1.74,2 +Student_02581,1,1,9238,1,1,1,1,19,37,4,7,145.0,148.9,1,0,0,1,0,1,0,18,0,6,6,6,13.666666666666666,0,0,6,6,6,13.0,0,10.8,1.4,1.74,2 +Student_02582,1,39,9003,1,1,1,1,38,38,4,7,133.1,115.6,1,0,0,0,0,0,0,27,0,6,8,0,0.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_02584,1,39,9991,0,1,1,1,19,37,9,8,150.0,138.5,0,0,0,1,0,0,0,26,0,5,10,4,12.0,0,0,5,9,4,11.25,0,12.7,3.7,-1.7,1 +Student_02585,1,NA,9853,1,1,1,1,19,12,9,4,130.0,133.2,1,0,0,1,0,0,0,19,0,6,6,6,14.166666666666666,0,0,6,7,6,13.666666666666666,0,7.6,2.6,NA,2 +Student_02586,1,17,8014,0,2,1,1,37,34,0,0,120.0,117.6,1,0,0,1,0,0,0,19,0,6,8,5,12.2,0,0,6,7,6,12.0,0,7.6,2.6,0.32,2 +Student_02587,1,18,9147,1,2,1,1,1,37,5,5,115.0,108.7,1,0,0,1,0,0,0,21,0,5,8,3,12.0,1,0,5,9,3,12.666666666666666,0,9.4,-0.8,-3.12,1 +Student_02588,1,1,9147,1,4,1,1,1,19,4,6,133.1,106.0,1,0,0,1,0,0,0,24,0,5,11,2,10.5,0,0,5,14,1,11.0,0,12.7,3.7,-1.7,1 +Student_02589,1,17,9853,1,1,1,1,37,37,9,10,120.0,122.6,0,0,0,1,0,0,0,20,0,6,8,3,12.333333333333334,0,0,6,11,2,10.5,0,12.7,3.7,-1.7,0 +Student_02590,1,1,9853,1,4,1,1,19,1,5,9,134.0,127.4,1,0,0,1,0,0,0,18,0,6,7,5,12.2,0,0,6,7,5,12.2,0,10.8,1.4,1.74,1 +Student_02591,1,39,9003,1,1,1,1,19,19,9,NA,133.1,100.0,0,0,0,1,0,0,0,30,0,6,6,0,0.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_02592,1,1,9853,1,1,1,1,NA,37,9,9,133.1,95.0,1,0,1,0,0,0,0,22,0,7,10,6,11.5,0,0,7,8,6,13.166666666666666,0,11.1,0.6,2.02,1 +Student_02594,1,39,9556,1,1,1,1,19,19,4,5,120.0,122.8,0,0,0,1,0,0,0,26,0,7,12,6,12.166666666666666,0,0,8,8,8,11.675,0,13.9,-0.3,0.79,0 +Student_02595,1,17,9147,1,1,1,1,19,19,7,7,115.0,115.0,1,0,0,1,0,0,0,23,0,5,7,2,10.0,1,0,5,9,1,12.0,0,9.4,-0.8,-3.12,1 +Student_02597,1,1,9070,1,1,1,1,1,37,5,9,133.1,143.0,1,0,1,1,0,0,0,21,0,6,9,5,11.4,0,0,6,8,5,12.2,0,12.7,3.7,-1.7,0 +Student_02598,1,43,171,1,1,1,1,19,38,9,9,145.0,100.0,0,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02599,1,17,9085,1,3,1,1,19,37,5,5,130.0,121.3,1,0,0,1,0,0,0,21,0,5,14,2,13.0,2,0,5,8,4,12.0,1,9.4,-0.8,-3.12,1 +Student_02602,1,17,9254,1,1,1,1,1,1,4,9,122.0,112.9,1,0,0,1,0,0,0,22,0,6,14,4,12.25,0,0,6,11,3,11.333333333333334,0,7.6,2.6,0.32,1 +Student_02603,1,1,9238,1,3,1,1,38,19,5,8,126.0,120.8,1,0,0,1,0,0,0,19,0,6,7,6,12.285714285714286,0,0,6,7,6,12.833333333333334,0,12.4,0.5,1.79,2 +Student_02604,1,1,9085,1,5,1,1,38,37,9,8,121.0,114.0,1,0,0,0,0,0,0,19,0,5,12,0,0.0,4,0,5,8,0,0.0,1,9.4,-0.8,-3.12,0 +Student_02605,1,17,9238,1,1,1,1,37,37,7,5,152.0,132.1,1,0,0,1,0,0,0,19,0,6,10,2,10.5,0,0,6,11,1,13.0,0,9.4,-0.8,-3.12,0 +Student_02606,2,44,9085,1,1,39,1,37,37,192,192,160.0,160.0,0,0,0,1,0,0,0,27,0,5,12,3,14.0,2,0,5,8,5,12.0,1,9.4,-0.8,-3.12,2 +Student_02607,1,10,9085,1,1,1,1,37,37,5,5,134.0,134.0,1,0,0,1,0,0,0,22,2,5,7,5,14.2,0,0,5,10,5,12.2,0,12.7,3.7,-1.7,2 +Student_02608,1,1,9773,1,1,1,1,37,1,9,7,128.0,124.2,1,0,0,1,0,0,0,18,0,6,8,5,13.0,0,0,6,7,6,13.142857142857142,0,15.5,2.8,-4.06,0 +Student_02609,1,17,9254,1,4,1,1,38,38,5,5,125.0,115.6,1,0,0,1,0,0,0,20,0,6,6,6,11.0,0,0,6,8,4,12.75,0,9.4,-0.8,-3.12,2 +Student_02610,2,43,9991,0,1,1,1,37,37,9,9,130.0,128.2,0,0,0,1,0,0,0,34,3,8,9,3,11.0,0,2,7,7,2,10.0,0,9.4,-0.8,-3.12,0 +Student_02611,1,17,9500,1,2,1,1,1,38,5,8,138.0,132.8,1,0,0,1,0,0,0,18,0,7,9,6,12.385714285714286,0,0,8,9,8,13.755555555555556,0,13.9,-0.3,0.79,2 +Student_02613,1,1,9130,1,1,1,41,1,19,5,5,134.0,125.6,1,0,0,1,0,0,1,20,0,5,6,5,16.166666666666668,0,0,5,6,5,15.833333333333334,0,12.7,3.7,-1.7,2 +Student_02614,1,39,9991,0,1,1,1,1,38,4,9,130.0,115.0,0,0,0,1,1,0,0,25,0,5,7,0,0.0,0,0,5,8,0,0.0,0,16.2,0.3,-0.92,0 +Student_02615,1,1,9119,1,4,1,1,3,19,2,9,126.0,123.6,1,0,0,1,1,0,0,18,0,5,6,5,12.4,0,0,5,9,3,13.0,0,8.9,1.4,3.51,0 +Student_02616,1,1,9130,1,1,1,1,1,1,9,9,148.0,141.7,0,0,0,0,1,0,0,18,0,6,8,5,11.6,0,0,6,11,4,13.0,0,8.9,1.4,3.51,0 +Student_02619,1,17,9853,1,2,1,1,38,19,5,5,150.0,142.0,1,0,0,1,0,1,0,19,0,6,8,6,12.333333333333334,0,0,6,7,5,12.4,0,10.8,1.4,1.74,0 +Student_02621,1,42,9070,1,1,1,1,3,2,2,2,100.0,115.9,0,0,0,1,0,0,0,29,9,10,15,9,11.555555555555555,0,7,11,17,10,11.9,0,9.4,-0.8,-3.12,1 +Student_02622,1,1,9070,1,1,1,1,1,37,9,9,110.0,105.1,1,0,0,1,0,1,0,20,0,6,6,6,12.0,0,0,6,6,6,11.833333333333334,0,12.4,0.5,1.79,2 +Student_02623,1,51,8014,0,1,42,1,19,37,134,193,140.0,138.0,1,0,1,1,0,1,0,21,13,13,13,11,12.727272727272728,0,9,11,11,10,12.6,0,8.9,1.4,3.51,2 +Student_02624,1,43,9991,0,1,1,41,37,37,9,8,133.1,114.7,0,0,0,1,0,0,1,34,2,2,2,2,10.5,0,1,1,1,1,11.0,0,10.8,1.4,1.74,0 +Student_02625,1,1,9773,1,4,1,22,1,37,3,9,140.0,130.5,1,0,0,1,0,0,1,20,0,6,6,6,12.333333333333334,0,0,6,6,6,12.0,0,12.7,3.7,-1.7,2 +Student_02626,1,39,9991,0,1,1,1,37,37,9,9,110.0,134.3,0,0,0,1,1,0,0,24,0,5,10,0,0.0,0,0,5,7,1,12.0,0,10.8,1.4,1.74,0 +Student_02627,1,1,9500,1,1,1,1,1,1,4,3,148.0,137.5,0,0,0,1,1,0,0,18,0,7,7,7,14.842857142857143,0,0,8,9,8,14.38888888888889,0,16.2,0.3,-0.92,2 +Student_02628,1,1,9500,1,1,1,1,1,19,4,4,137.0,125.3,0,0,0,1,1,0,0,19,0,7,7,7,12.2,0,0,7,7,7,12.2,0,7.6,2.6,0.32,1 +Student_02629,1,1,9147,1,1,1,1,1,19,7,7,120.0,111.3,0,0,0,1,1,1,0,18,0,5,10,4,10.8,0,0,5,10,4,11.75,0,15.5,2.8,-4.06,1 +Student_02630,1,39,9991,0,9,1,1,38,38,9,5,120.0,144.8,0,0,0,1,1,0,0,28,0,5,7,4,12.75,0,0,5,7,5,14.333333333333334,0,10.8,1.4,1.74,1 +Student_02632,1,17,9254,1,1,1,1,38,38,0,5,132.0,126.1,0,0,0,1,1,0,0,20,0,6,9,4,10.75,0,0,6,12,0,0.0,0,7.6,2.6,0.32,0 +Student_02633,1,43,9500,1,1,1,1,1,1,7,4,130.0,136.0,1,0,0,1,1,0,0,22,0,8,9,8,12.55375,1,0,8,9,8,12.55375,1,9.4,-0.8,-3.12,2 +Student_02634,1,1,9500,1,4,1,1,19,1,4,4,128.0,124.3,1,0,0,1,1,0,0,19,0,8,8,7,12.665714285714284,0,0,8,8,7,12.665714285714284,0,10.8,1.4,1.74,2 +Student_02635,1,1,9670,1,1,1,1,1,19,7,5,132.0,129.9,1,0,0,1,1,0,0,20,0,6,10,6,12.714285714285714,0,0,6,8,4,13.0,0,12.4,0.5,1.79,1 +Student_02636,1,39,9556,1,2,1,1,3,1,2,4,133.1,136.1,0,0,0,1,1,0,0,26,0,7,7,2,11.75,0,0,5,10,0,0.0,0,12.4,0.5,1.79,0 +Student_02637,1,1,9254,1,2,1,1,37,37,9,9,120.0,115.1,1,0,0,0,1,0,0,21,0,6,11,3,11.0,0,0,6,14,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02639,1,17,9147,1,1,1,1,37,38,9,7,127.0,115.8,1,0,0,1,1,0,0,18,0,5,5,5,13.4,0,0,5,6,5,12.2,0,11.1,0.6,2.02,2 +Student_02641,2,39,9119,1,1,19,1,37,37,9,9,133.1,100.0,0,0,0,1,1,0,0,36,0,5,0,0,0.0,0,0,5,0,0,NA,0,16.2,0.3,-0.92,0 +Student_02642,1,1,9773,1,1,1,1,38,38,9,9,125.0,133.4,1,0,0,1,1,1,0,20,0,6,8,6,12.0,0,0,6,8,6,11.5,0,13.9,-0.3,0.79,2 +Student_02643,1,17,9670,1,5,1,1,3,4,2,2,127.0,122.8,0,0,0,1,1,0,0,20,0,6,6,3,12.333333333333334,0,0,6,9,0,0.0,0,10.8,1.4,1.74,0 +Student_02645,1,39,9003,1,1,1,1,37,19,6,4,150.0,137.0,0,0,0,1,1,0,0,35,1,6,7,5,12.8,0,1,6,11,5,13.833333333333334,0,15.5,2.8,-4.06,2 +Student_02646,1,1,171,1,1,1,1,1,37,7,7,133.1,118.0,0,0,0,1,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,0 +Student_02648,1,44,9003,1,1,39,1,38,38,9,5,130.0,130.0,0,0,1,0,1,0,0,20,0,6,16,4,11.8,0,0,6,15,2,12.0,0,16.2,0.3,-0.92,0 +Student_02649,1,43,8014,0,1,12,1,37,1,9,10,133.1,112.5,0,0,0,1,1,0,0,50,6,13,13,6,11.333333333333334,0,2,11,11,2,13.5,0,16.2,0.3,-0.92,0 +Student_02650,1,1,9500,1,1,1,1,19,38,9,8,125.0,118.3,0,0,0,1,1,0,0,20,0,8,12,5,12.002,1,0,8,12,5,12.002,1,10.8,1.4,1.74,0 +Student_02651,1,1,9500,1,1,1,1,3,1,2,8,127.0,121.4,0,0,0,1,1,0,0,20,0,7,10,5,13.976666666666668,0,0,8,9,8,13.22222222222222,0,12.4,0.5,1.79,1 +Student_02652,1,7,9003,1,1,3,1,3,19,2,10,140.0,140.0,0,0,0,0,1,0,0,35,0,6,10,5,15.2,0,1,6,9,1,11.0,0,15.5,2.8,-4.06,0 +Student_02653,1,1,9670,1,1,1,1,3,19,4,5,110.0,109.0,0,0,0,1,1,1,0,19,0,6,7,6,13.142857142857142,0,0,6,8,6,14.166666666666666,0,15.5,2.8,-4.06,2 +Student_02654,2,39,9147,1,2,1,1,37,37,5,7,133.1,110.0,0,0,0,1,1,0,0,43,0,5,14,0,0.0,1,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02655,1,17,9500,1,5,1,1,3,38,2,1,124.0,119.8,0,0,0,1,1,0,0,19,0,8,11,7,13.867142857142856,0,0,8,11,7,13.867142857142856,0,10.8,1.4,1.74,2 +Student_02656,1,39,9500,1,1,NA,1,37,37,9,9,114.0,130.0,0,0,0,1,1,0,0,25,0,8,11,6,12.675,0,0,8,11,6,12.675,0,12.7,3.7,-1.7,2 +Student_02657,1,NA,171,1,1,1,1,1,3,5,10,155.0,167.3,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_02658,1,17,9853,1,2,1,1,1,19,9,9,114.0,111.9,1,0,0,1,1,1,0,20,0,6,6,6,12.0,0,0,6,7,6,12.5,0,7.6,2.6,0.32,1 +Student_02659,1,1,171,1,1,1,1,38,37,5,5,133.1,136.0,1,0,0,1,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02660,1,1,9254,1,1,1,1,37,37,3,3,125.0,124.0,0,0,0,1,1,1,0,19,0,6,7,6,11.0,0,0,6,6,5,12.2,0,11.1,0.6,2.02,0 +Student_02661,2,39,9991,0,1,1,1,19,37,3,9,120.0,132.9,0,0,0,1,1,0,0,32,0,5,11,4,10.75,0,0,5,11,4,11.333333333333334,0,13.9,-0.3,0.79,0 +Student_02662,2,39,9773,1,1,38,1,37,37,9,7,100.0,154.0,1,0,0,1,1,0,0,57,0,6,7,5,14.2,0,0,6,6,6,14.166666666666666,0,9.4,-0.8,-3.12,2 +Student_02663,1,1,9500,1,1,1,1,1,19,3,5,133.1,115.0,0,0,0,0,1,0,0,20,0,7,11,4,12.6,0,0,7,7,4,11.575,0,NA,0.3,-0.92,0 +Student_02664,1,39,9991,0,1,1,1,1,1,5,5,120.0,96.0,1,0,0,0,1,0,0,38,0,5,5,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_02665,2,39,9991,0,1,1,1,37,3,9,3,120.0,168.2,0,0,0,1,1,0,0,45,0,5,6,5,14.0,0,0,5,6,5,14.166666666666666,0,12.4,0.5,1.79,2 +Student_02666,2,39,9773,1,1,1,1,37,37,9,10,110.0,140.0,0,0,1,0,1,0,0,43,0,6,16,2,10.0,0,0,6,12,4,12.25,0,10.8,1.4,1.74,0 +Student_02668,2,39,9991,0,1,19,1,19,19,4,4,133.1,150.0,0,0,0,0,1,0,0,49,0,5,8,2,11.0,0,0,5,5,1,11.0,0,15.5,2.8,-4.06,0 +Student_02669,2,39,9500,1,1,19,1,37,38,9,7,133.1,100.5,1,0,0,1,1,0,0,43,0,8,8,7,11.635714285714286,0,0,8,8,7,11.635714285714286,0,10.8,1.4,1.74,1 +Student_02671,1,17,9119,1,5,1,1,19,19,5,5,138.0,123.3,1,0,1,1,1,0,0,18,0,5,9,4,12.5,0,0,5,11,5,11.285714285714286,0,12.4,0.5,1.79,1 +Student_02672,2,39,9991,0,1,1,1,38,38,1,4,120.0,138.7,0,0,0,1,1,0,0,43,0,5,5,5,13.8,0,0,5,6,5,13.666666666666666,0,10.8,1.4,1.74,2 +Student_02673,1,1,9254,1,2,1,1,19,1,9,8,NA,117.2,0,0,0,1,1,0,0,21,0,6,8,3,12.0,0,0,6,9,1,11.0,0,15.5,2.8,-4.06,0 +Student_02674,2,39,9991,0,1,1,1,34,34,99,99,160.0,114.3,0,0,0,1,1,0,0,40,0,5,9,3,11.0,0,0,5,8,4,12.5,1,7.6,2.6,0.32,1 +Student_02675,1,17,9670,1,1,1,1,19,37,5,5,134.0,125.3,1,0,0,1,1,1,0,19,0,6,7,4,13.75,0,0,6,10,6,11.555555555555555,0,10.8,1.4,1.74,2 +Student_02676,1,1,9254,1,1,1,1,37,37,1,1,133.1,97.0,0,0,0,1,1,0,0,27,0,6,6,6,10.666666666666666,0,0,6,8,4,11.25,0,10.8,1.4,1.74,1 +Student_02677,2,42,9556,1,1,1,1,37,37,9,6,110.0,140.0,0,0,0,1,1,0,0,43,0,7,7,0,0.0,0,0,8,13,2,13.15,0,16.2,0.3,-0.92,0 +Student_02678,1,43,9991,0,1,1,1,37,37,9,9,130.0,124.0,0,0,0,1,1,0,0,31,1,5,6,5,NA,0,0,5,7,5,15.4,0,9.4,-0.8,-3.12,2 +Student_02679,1,44,9003,1,1,39,1,38,1,134,134,140.0,140.0,1,0,1,1,1,0,0,26,0,6,6,0,0.0,0,0,6,7,0,0.0,0,8.9,1.4,3.51,1 +Student_02680,1,39,9991,0,1,1,1,37,38,175,103,150.0,127.0,0,0,0,1,1,0,0,34,0,5,5,5,15.8,0,0,5,5,5,16.8,0,8.9,1.4,3.51,2 +Student_02684,1,17,9085,1,1,1,1,1,19,5,9,133.1,130.0,0,0,0,1,1,0,0,22,0,5,8,3,13.0,0,0,5,8,3,10.666666666666666,0,7.6,2.6,0.32,2 +Student_02685,1,7,9003,1,1,3,1,1,19,5,9,130.0,130.0,0,0,0,1,1,0,0,27,0,6,8,0,0.0,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_02687,1,51,9147,1,1,1,1,19,38,9,8,130.0,115.7,0,0,0,1,1,0,0,20,0,5,7,5,11.0,0,0,5,7,3,10.0,0,8.9,1.4,3.51,1 +Student_02688,1,42,9119,1,1,1,1,19,19,90,90,140.0,120.0,0,0,1,0,1,0,0,31,0,4,4,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_02689,1,1,9119,1,1,1,1,37,19,9,9,140.0,166.0,1,0,1,1,1,0,0,20,0,5,7,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,1 +Student_02690,1,17,9773,1,1,1,1,1,38,90,8,145.0,132.8,1,0,0,0,NA,0,0,21,0,6,10,2,12.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_02691,1,17,9147,1,1,1,1,19,19,9,7,133.1,100.0,0,0,0,1,1,0,0,21,0,5,7,4,10.75,0,0,5,10,2,11.0,3,16.2,0.3,-0.92,0 +Student_02692,1,1,9147,1,1,1,1,1,4,9,10,127.0,121.8,0,0,0,1,1,0,0,19,0,5,8,5,11.6,0,0,5,10,4,13.5,3,16.2,0.3,-0.92,2 +Student_02693,1,17,9147,1,4,1,1,19,19,4,4,114.0,109.5,1,0,0,1,1,1,0,20,0,5,6,5,11.8,0,0,5,8,4,11.6,0,8.9,1.4,3.51,2 +Student_02694,1,1,9003,1,1,1,1,38,1,9,4,140.0,138.3,0,0,0,1,1,0,0,18,0,6,7,6,16.0,0,0,6,6,6,15.166666666666666,0,12.4,0.5,1.79,2 +Student_02695,1,1,9773,1,2,1,1,1,1,4,3,140.0,131.6,0,0,0,1,1,1,0,18,0,6,6,6,12.666666666666666,0,0,6,6,6,11.5,0,16.2,0.3,-0.92,2 +Student_02696,1,39,9500,1,1,1,1,1,2,144,123,120.0,125.3,0,0,1,1,1,0,0,30,0,7,12,4,14.4,0,0,7,9,6,13.5,0,12.4,0.5,1.79,1 +Student_02697,1,39,9254,1,1,19,1,19,19,3,1,133.1,101.5,0,0,1,0,1,0,0,34,0,6,6,0,0.0,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_02698,1,17,9670,1,1,1,1,19,19,191,171,115.0,109.1,0,0,1,0,1,0,0,21,0,6,11,4,12.25,0,0,6,9,4,13.4,0,11.1,0.6,2.02,1 +Student_02699,1,44,9070,1,1,39,1,37,1,9,7,123.9,123.9,0,0,0,1,1,0,0,20,2,7,9,5,12.6,0,5,9,10,8,12.75,1,16.2,0.3,-0.92,0 +Student_02700,1,1,9500,1,1,1,1,37,37,9,9,157.0,143.0,0,0,0,1,1,0,0,18,0,8,8,7,13.4,0,0,8,8,7,13.4,0,12.7,3.7,-1.7,2 +Student_02701,1,1,171,1,1,1,1,1,1,4,3,127.0,126.3,1,0,1,1,1,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_02702,2,42,9003,1,1,1,1,3,1,2,2,120.0,113.3,0,0,0,1,1,0,0,26,0,6,9,1,10.0,0,0,6,6,0,0.0,0,12.4,0.5,1.79,0 +Student_02703,1,17,9119,1,1,1,1,38,19,7,3,130.0,119.9,1,0,1,1,1,0,0,20,0,5,5,0,0.0,0,0,5,5,0,0.0,5,9.4,-0.8,-3.12,0 +Student_02704,1,44,9003,1,1,39,1,1,38,1,9,140.0,140.0,0,0,0,1,1,0,0,25,0,6,16,3,11.25,0,0,6,14,4,11.2,0,15.5,2.8,-4.06,0 +Student_02705,1,17,9670,1,1,1,1,1,1,4,4,NA,108.0,0,0,0,1,1,0,0,19,0,5,10,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,1 +Student_02707,1,1,9130,1,1,1,NA,3,3,2,2,125.0,132.4,0,0,0,1,1,0,0,20,0,5,7,4,11.75,0,0,5,5,5,13.4,0,7.6,2.6,0.32,2 +Student_02708,1,1,9147,1,1,1,1,1,3,9,5,136.0,137.1,0,0,0,1,1,0,0,20,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_02712,1,43,8014,0,1,1,1,37,37,0,6,113.0,128.2,0,0,0,0,0,0,0,41,0,6,6,0,0.0,6,0,6,12,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02713,1,1,9147,1,2,1,1,37,38,7,9,130.0,117.8,0,0,1,1,NA,1,0,19,0,5,11,2,11.5,0,0,5,10,0,0.0,0,12.7,3.7,-1.7,0 +Student_02714,1,43,9130,1,1,1,1,3,3,3,4,150.0,150.0,1,0,0,1,0,0,0,21,0,6,10,6,12.0,0,0,6,12,5,12.8,0,13.9,-0.3,0.79,2 +Student_02715,1,39,9085,1,1,1,1,1,1,5,5,110.0,160.0,1,0,1,1,0,0,0,30,0,6,7,6,16.428571428571427,0,0,6,7,6,16.666666666666668,0,13.9,-0.3,0.79,0 +Student_02716,1,1,9500,1,5,1,1,38,38,9,9,101.0,104.5,1,0,0,1,0,1,0,21,0,7,9,5,13.336000000000002,0,0,8,9,7,13.207142857142856,0,11.1,0.6,2.02,2 +Student_02717,2,39,9556,1,2,1,1,19,38,9,9,110.0,112.8,0,0,0,1,0,1,0,26,0,7,7,0,0.0,0,0,8,8,0,0.0,6,10.8,1.4,1.74,1 +Student_02718,1,15,9670,1,1,1,41,1,1,9,4,133.1,100.0,0,0,0,1,0,0,1,21,2,7,9,7,14.666666666666666,0,1,6,8,6,14.0,0,11.1,0.6,2.02,2 +Student_02719,1,1,9500,1,1,1,1,1,1,3,4,138.0,132.5,1,0,0,1,0,0,0,18,0,8,8,7,14.115714285714288,0,0,8,8,7,14.115714285714288,0,10.8,1.4,1.74,2 +Student_02720,1,1,9085,1,4,1,1,3,1,1,4,138.0,123.3,1,0,0,1,0,1,0,19,0,6,7,6,14.857142857142858,0,0,6,10,6,13.11111111111111,0,12.4,0.5,1.79,2 +Student_02722,1,17,9147,1,2,1,1,2,3,2,2,129.0,128.3,1,0,0,NA,0,0,0,19,0,5,10,3,11.0,0,0,5,9,4,11.75,0,12.7,3.7,-1.7,1 +Student_02723,1,43,9085,1,1,1,1,3,3,2,5,127.0,100.0,0,0,0,1,0,0,0,21,0,6,11,4,11.75,0,0,6,12,3,13.666666666666666,0,13.9,-0.3,0.79,1 +Student_02724,1,17,9147,1,2,1,1,19,1,9,3,133.0,120.1,1,0,0,1,0,1,0,18,0,5,15,2,10.0,0,0,5,14,2,12.0,0,13.9,-0.3,0.79,0 +Student_02725,1,39,9500,1,1,1,1,37,37,7,7,100.0,160.0,1,0,0,1,0,1,0,24,0,8,15,6,12.415,0,0,8,15,6,12.415,0,10.8,1.4,1.74,2 +Student_02726,1,1,9130,1,1,1,1,4,5,2,2,138.0,123.0,1,0,0,1,0,0,0,21,0,5,12,1,11.0,0,0,5,9,2,10.5,0,12.7,3.7,-1.7,1 +Student_02727,1,44,9085,1,1,39,1,19,19,9,9,150.0,150.0,1,0,0,1,0,0,0,23,1,6,14,5,14.428571428571429,0,1,6,7,6,13.428571428571429,0,16.2,0.3,-0.92,2 +Student_02729,1,39,9085,1,1,1,1,4,1,2,9,130.0,120.0,0,0,0,0,0,0,0,26,0,6,8,6,15.428571428571429,0,0,6,7,5,14.5,0,11.1,0.6,2.02,1 +Student_02730,1,1,9130,1,1,1,1,38,38,5,8,133.0,120.4,1,0,0,1,0,0,0,20,0,5,9,4,12.0,1,0,5,6,5,13.4,0,9.4,-0.8,-3.12,2 +Student_02731,1,1,9238,1,1,1,1,4,1,5,5,133.0,131.6,0,0,0,1,0,0,0,18,0,6,7,6,13.833333333333334,0,0,6,7,6,13.714285714285714,0,11.1,0.6,2.02,2 +Student_02732,1,1,9238,1,1,1,1,2,12,3,10,107.0,104.2,1,0,0,1,0,0,0,20,0,6,6,6,12.166666666666666,0,0,6,7,6,12.142857142857142,0,11.1,0.6,2.02,2 +Student_02734,1,17,9238,1,2,1,1,1,19,4,10,118.0,110.7,1,1,0,1,0,0,0,18,0,6,15,2,10.333333333333334,3,0,6,13,3,13.333333333333334,0,12.7,3.7,-1.7,1 +Student_02735,1,1,9773,1,4,1,1,1,12,9,10,136.0,121.7,1,0,0,1,0,1,0,22,0,6,7,5,13.2,0,0,6,7,5,13.6,0,12.4,0.5,1.79,2 +Student_02736,1,1,9500,1,1,1,1,37,37,9,9,125.0,126.0,1,0,1,1,0,0,0,20,0,7,7,6,15.4,0,0,7,7,6,15.4,0,7.6,2.6,0.32,2 +Student_02738,1,1,9130,1,1,1,1,3,1,2,4,144.0,134.9,1,0,1,1,0,0,0,18,0,6,13,6,10.857142857142858,0,0,6,10,4,11.0,0,15.5,2.8,-4.06,0 +Student_02739,1,17,9147,1,2,1,1,38,37,6,6,146.0,143.9,0,0,0,1,0,0,0,18,0,5,11,5,11.333333333333334,0,0,5,8,5,12.0,0,13.9,-0.3,0.79,2 +Student_02740,1,1,9085,1,4,1,1,37,1,9,9,145.0,145.0,1,0,0,1,0,1,0,19,0,5,7,4,14.5,0,0,5,5,5,13.6,0,10.8,1.4,1.74,2 +Student_02741,1,1,9070,1,2,1,1,19,38,9,9,126.0,132.0,1,0,0,1,0,1,0,19,0,6,6,6,14.166666666666666,0,0,6,8,6,12.375,0,10.8,1.4,1.74,2 +Student_02742,1,17,8014,0,1,1,1,34,34,0,0,141.0,136.1,0,0,0,1,0,0,0,24,0,6,7,6,12.833333333333334,0,0,6,8,6,12.0,0,7.6,2.6,0.32,2 +Student_02744,1,1,9238,1,1,1,1,1,1,3,3,133.1,102.0,1,0,0,1,0,1,0,20,0,6,7,6,13.666666666666666,0,0,6,7,6,14.571428571428571,0,11.1,0.6,2.02,2 +Student_02745,1,39,9254,1,1,1,1,19,19,4,7,133.1,123.0,0,0,1,0,0,1,0,28,0,6,6,6,10.833333333333334,0,0,6,7,5,11.0,0,13.9,-0.3,0.79,0 +Student_02746,1,1,9853,1,2,1,1,37,19,9,8,NA,137.5,1,0,0,1,0,0,0,21,0,6,7,6,13.428571428571429,0,0,6,8,6,13.142857142857142,0,7.6,2.6,0.32,2 +Student_02747,1,1,9500,1,1,1,1,37,38,191,163,106.0,102.2,1,0,1,1,1,0,0,20,0,7,7,7,12.401428571428571,0,0,8,10,6,11.808333333333332,0,11.1,0.6,2.02,1 +Student_02748,1,42,9003,1,1,1,1,3,2,2,6,130.0,105.3,0,0,0,0,1,0,0,36,0,6,8,0,0.0,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_02749,2,39,9991,0,1,1,1,37,37,9,9,110.0,130.0,0,0,0,0,1,0,0,42,0,4,4,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02750,2,39,9991,0,1,1,1,37,37,9,7,150.0,122.5,0,0,0,1,1,0,0,47,0,5,9,4,11.5,0,0,5,6,5,11.6,1,7.6,2.6,0.32,0 +Student_02751,1,39,9119,1,1,1,1,1,38,4,7,160.0,112.0,0,0,0,0,1,0,0,25,0,5,8,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02752,1,39,9670,1,1,12,1,1,37,3,5,170.0,110.0,0,0,0,1,1,1,0,NA,0,6,8,6,14.142857142857142,0,0,6,6,6,13.5,0,15.5,2.8,-4.06,2 +Student_02753,2,39,8014,0,1,19,1,19,37,6,8,133.1,149.5,0,0,0,1,1,0,0,48,0,6,6,0,0.0,0,0,5,6,0,0.0,0,12.4,0.5,1.79,0 +Student_02754,1,43,9991,0,1,1,1,38,38,9,7,120.0,141.0,0,0,0,1,1,1,0,NA,5,10,12,10,13.8,0,5,10,10,10,12.8,0,10.8,1.4,1.74,2 +Student_02755,1,7,9991,0,1,40,1,38,38,9,7,130.0,130.0,0,0,0,1,1,0,0,38,10,10,10,10,13.6,0,5,10,10,5,13.6,0,8.9,1.4,3.51,0 +Student_02756,1,7,9238,1,1,40,1,37,37,5,5,130.0,130.0,0,0,0,1,1,0,0,37,11,16,23,15,11.733333333333333,0,6,11,17,9,11.88888888888889,0,NA,2.8,-4.06,2 +Student_02757,1,39,9147,1,2,1,1,37,37,9,9,120.0,104.0,0,0,0,0,1,0,0,26,0,5,8,1,10.0,0,0,5,9,1,10.0,0,10.8,1.4,1.74,0 +Student_02758,NA,44,9085,1,1,39,1,3,5,2,2,110.0,110.0,0,0,0,1,1,0,0,23,0,6,19,0,0.0,0,0,6,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_02759,1,44,9003,1,1,39,1,38,19,3,5,120.0,120.0,0,0,0,1,1,0,0,23,0,6,6,0,0.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,1 +Student_02760,1,44,9003,1,1,39,1,2,3,9,6,130.0,130.0,0,0,0,1,1,0,0,20,0,6,12,4,10.8,0,0,6,13,4,12.0,0,12.4,0.5,1.79,1 +Student_02761,1,39,9500,1,1,4,1,3,38,3,7,150.0,127.0,1,0,0,1,1,0,0,26,2,7,8,6,13.046666666666669,0,2,8,10,7,13.30625,0,11.1,0.6,2.02,0 +Student_02762,1,43,8014,0,1,1,1,37,37,9,5,120.0,100.0,0,0,0,1,0,0,0,45,5,9,13,8,11.0,0,3,7,10,6,10.833333333333334,0,12.7,3.7,-1.7,1 +Student_02763,1,39,8014,0,1,19,1,37,37,5,5,100.0,111.0,1,0,0,1,0,1,0,26,0,6,10,3,12.333333333333334,0,0,6,14,3,11.666666666666666,0,7.6,2.6,0.32,1 +Student_02764,1,43,8014,0,1,3,1,9,9,90,90,133.1,130.0,0,0,0,1,0,0,0,26,8,11,16,10,11.8,0,3,7,7,7,13.285714285714286,0,7.6,2.6,0.32,2 +Student_02765,1,39,9991,0,1,1,1,37,37,9,9,130.0,130.1,0,0,0,1,0,0,0,25,0,5,8,3,NA,0,0,5,8,3,11.25,0,10.8,1.4,1.74,1 +Student_02767,1,7,9500,1,1,3,1,37,37,7,7,130.0,130.0,1,0,0,1,0,0,0,27,0,8,8,7,14.414285714285716,0,0,8,8,7,14.414285714285716,0,12.7,3.7,-1.7,2 +Student_02768,6,17,8014,0,3,1,1,19,1,5,90,115.0,115.0,0,0,0,0,0,0,0,24,0,5,5,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_02769,1,17,9147,1,1,1,1,38,19,6,10,124.0,126.8,1,0,0,1,0,0,0,20,0,5,8,5,12.333333333333334,0,0,5,7,5,12.2,0,15.5,2.8,-4.06,2 +Student_02770,1,1,9500,1,1,NA,1,1,19,9,8,124.0,116.7,1,0,0,1,0,1,0,18,0,7,9,0,0.0,0,0,7,8,1,10.0,0,15.5,2.8,-4.06,0 +Student_02771,1,17,9556,1,6,1,1,19,38,7,7,134.0,128.5,1,0,0,1,0,1,0,18,0,7,9,7,14.1,0,0,8,8,8,13.3125,0,12.7,3.7,-1.7,2 +Student_02772,1,1,9500,1,4,1,1,37,37,9,9,137.0,127.5,1,0,0,1,0,0,0,18,0,8,8,8,13.045,0,0,8,8,8,13.045,0,9.4,-0.8,-3.12,2 +Student_02773,1,1,9500,1,1,1,1,19,37,3,8,124.0,117.5,1,0,0,1,1,0,0,19,0,8,10,5,12.858,3,0,8,10,5,12.858,3,9.4,-0.8,-3.12,1 +Student_02774,1,42,9500,1,3,1,1,1,1,4,4,136.0,148.8,1,0,0,1,0,1,0,19,0,8,8,8,14.2525,0,0,8,8,8,14.2525,0,9.4,-0.8,-3.12,2 +Student_02775,1,1,9500,1,4,1,1,12,1,5,10,126.0,120.2,0,0,0,1,0,1,0,19,0,7,9,5,14.06,0,0,7,9,7,11.242857142857142,0,12.4,0.5,1.79,1 +Student_02776,1,1,9500,1,4,1,1,38,37,9,5,142.0,127.3,1,0,0,1,0,0,0,18,0,8,8,7,15.075714285714286,0,0,8,8,7,15.075714285714286,0,10.8,1.4,1.74,2 +Student_02777,1,17,171,1,2,1,1,19,37,9,9,141.0,136.1,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,1 +Student_02778,1,43,9670,1,2,1,1,3,3,5,5,129.0,122.4,1,0,0,1,0,0,0,19,0,5,5,4,13.75,0,0,6,9,5,12.6,0,12.7,3.7,-1.7,1 +Student_02780,1,1,9238,1,2,1,NA,19,19,4,7,136.0,121.7,1,0,0,1,0,1,0,21,0,6,9,5,12.333333333333334,0,0,6,7,5,11.8,0,13.9,-0.3,0.79,2 +Student_02781,1,1,9500,1,3,1,1,38,38,5,7,137.0,122.7,1,0,0,1,0,1,0,18,0,7,8,7,13.778571428571428,0,0,8,10,8,13.122222222222222,0,16.2,0.3,-0.92,2 +Student_02783,1,43,9773,1,1,1,1,19,37,5,5,119.0,105.0,1,0,0,1,0,0,0,23,0,6,11,3,11.333333333333334,0,0,6,7,2,11.0,0,16.2,0.3,-0.92,1 +Student_02784,1,1,9238,1,1,1,1,37,37,9,7,132.0,129.9,1,0,0,1,0,0,0,20,0,6,7,5,13.2,0,0,6,6,6,12.666666666666666,0,10.8,1.4,1.74,1 +Student_02785,1,1,9070,1,1,1,1,37,37,5,7,152.0,136.3,0,0,0,1,0,1,0,18,1,6,8,6,13.571428571428571,1,0,6,11,6,12.375,0,13.9,-0.3,0.79,2 +Student_02789,1,39,9670,1,1,1,1,19,19,7,7,148.0,130.9,0,0,1,0,1,0,0,24,0,6,12,0,0.0,0,0,6,9,0,0.0,0,NA,1.4,1.74,0 +Student_02790,1,39,171,1,1,1,1,37,37,9,7,133.1,100.0,0,0,1,1,1,1,0,33,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_02791,1,17,9147,1,1,1,1,19,37,5,7,115.0,112.9,1,0,0,0,1,0,0,19,0,5,7,2,12.5,0,0,5,13,1,11.0,0,9.4,-0.8,-3.12,0 +Student_02793,4,39,8014,0,1,1,1,37,37,7,7,133.1,143.0,0,0,0,1,1,0,0,37,3,9,13,8,12.0,0,2,7,8,7,11.571428571428571,0,12.7,3.7,-1.7,2 +Student_02794,1,1,171,1,1,1,1,38,37,9,8,168.0,155.1,1,0,1,0,1,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_02795,4,39,9991,0,1,1,1,37,37,9,9,130.0,127.6,0,0,0,1,1,0,0,29,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,1 +Student_02796,2,39,9500,1,1,38,1,37,37,9,3,133.1,146.6,0,0,0,1,1,0,0,37,0,7,8,7,12.828571428571427,0,0,8,8,8,NA,0,13.9,-0.3,0.79,2 +Student_02798,1,1,9670,1,2,1,1,1,38,7,7,123.0,120.6,1,0,0,1,1,0,0,19,0,6,6,6,13.333333333333334,0,0,6,8,5,14.0,0,8.9,1.4,3.51,2 +Student_02799,1,42,9500,1,1,1,1,19,1,9,3,150.0,110.0,1,0,0,1,1,1,0,33,6,14,20,14,13.072857142857144,6,6,14,20,14,13.072857142857144,6,9.4,-0.8,-3.12,2 +Student_02800,1,42,9119,1,1,1,1,1,1,5,7,120.0,108.6,0,0,0,0,1,0,0,34,2,7,13,5,12.0,0,2,7,7,3,11.0,0,15.5,2.8,-4.06,0 +Student_02801,1,1,9254,1,1,1,1,3,19,3,8,145.0,134.9,1,0,0,1,0,0,0,18,0,6,6,6,15.5,0,0,6,6,6,16.0,0,12.4,0.5,1.79,2 +Student_02804,1,1,9085,1,3,1,1,19,19,9,1,147.0,135.6,1,0,0,1,0,0,0,20,0,6,7,6,16.714285714285715,0,0,6,6,6,15.333333333333334,0,13.9,-0.3,0.79,2 +Student_02805,1,1,9238,1,1,1,1,19,19,9,9,125.0,121.5,1,0,0,1,0,1,0,19,0,6,9,6,10.857142857142858,0,0,6,7,6,11.666666666666666,0,12.4,0.5,1.79,2 +Student_02808,1,1,9670,1,1,1,1,12,12,5,7,122.0,126.6,1,0,0,1,0,0,0,18,0,6,8,6,14.625,0,0,6,9,6,14.142857142857142,0,11.1,0.6,2.02,1 +Student_02809,1,1,9773,1,1,1,1,1,38,9,NA,123.0,116.7,0,0,0,1,0,1,0,18,0,6,6,6,12.166666666666666,0,0,6,8,6,12.666666666666666,0,12.4,0.5,1.79,2 +Student_02810,1,1,9500,1,3,1,1,1,19,131,181,126.0,120.1,1,0,0,1,0,0,0,19,0,7,12,4,13.375,0,0,7,8,6,12.116666666666667,0,12.4,0.5,1.79,1 +Student_02811,1,1,9853,1,1,1,1,38,37,9,9,128.0,124.9,0,0,0,1,0,1,0,19,0,6,6,6,12.5,0,0,6,6,6,12.833333333333334,0,12.7,3.7,-1.7,2 +Student_02812,1,39,9500,1,1,1,1,19,1,1,90,100.0,114.0,1,0,1,0,0,0,0,31,0,7,8,5,12.56,0,0,7,8,5,12.56,0,7.6,2.6,0.32,0 +Student_02813,1,17,9500,1,5,1,1,1,1,4,3,140.0,131.1,1,0,0,1,0,0,0,18,0,7,7,7,13.19,0,0,8,8,8,14.23125,0,11.1,0.6,2.02,2 +Student_02814,1,1,9238,1,1,1,1,1,19,9,9,145.0,129.3,0,0,1,1,0,1,0,19,0,6,11,3,11.0,0,0,6,9,4,11.25,0,10.8,1.4,1.74,2 +Student_02815,1,1,171,1,1,1,1,3,38,2,10,143.0,129.7,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_02816,1,17,9238,1,1,1,1,37,38,9,5,132.0,120.8,0,0,0,1,0,1,0,19,0,6,11,5,11.6,0,0,6,10,6,11.714285714285714,0,15.5,2.8,-4.06,2 +Student_02817,1,1,9500,1,1,1,1,19,19,9,6,130.0,135.0,0,0,0,1,0,0,0,19,0,7,7,6,14.266666666666666,0,0,7,7,6,14.266666666666666,0,NA,2.6,0.32,2 +Student_02818,NA,1,9147,1,1,1,1,37,37,9,7,129.0,117.8,0,0,0,1,0,1,0,19,0,5,6,4,11.0,0,0,5,9,4,13.857142857142858,0,10.8,1.4,1.74,1 +Student_02819,2,7,8014,0,1,3,1,37,34,0,0,124.4,130.0,0,0,0,1,0,0,0,30,8,10,11,9,12.666666666666666,0,3,7,7,7,12.428571428571429,1,7.6,2.6,0.32,2 +Student_02820,1,43,9773,1,1,1,1,19,1,5,5,127.0,117.6,1,0,0,1,0,0,0,18,0,6,6,0,0.0,0,0,6,10,3,11.0,0,16.2,0.3,-0.92,1 +Student_02821,1,18,9500,1,6,1,1,1,1,3,6,144.0,130.8,1,0,0,1,0,0,0,18,0,8,11,7,12.771428571428572,0,0,8,11,7,12.771428571428572,0,12.7,3.7,-1.7,2 +Student_02822,1,18,9085,1,5,1,1,5,3,2,3,121.0,111.9,1,0,0,1,0,0,0,21,0,5,12,0,0.0,3,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_02823,1,44,9238,1,1,1,1,1,38,4,9,150.0,145.9,0,0,0,1,0,1,0,19,3,6,6,6,15.5,0,2,6,7,6,13.571428571428571,0,13.9,-0.3,0.79,2 +Student_02825,1,1,9500,1,5,1,1,3,19,4,8,125.0,120.3,1,0,0,1,0,0,0,19,0,7,11,5,11.716666666666669,0,0,7,8,5,13.7,0,13.9,-0.3,0.79,1 +Student_02828,2,39,9991,0,1,1,1,37,37,9,6,140.0,130.2,0,0,0,1,0,1,0,39,0,5,13,4,12.333333333333334,0,0,5,14,2,10.0,4,16.2,0.3,-0.92,2 +Student_02829,1,1,9070,1,2,1,1,3,4,2,2,129.0,136.4,1,0,0,1,0,0,0,18,0,6,6,6,12.333333333333334,0,0,6,6,6,12.833333333333334,0,7.6,2.6,0.32,1 +Student_02830,1,17,171,1,1,1,1,3,1,9,9,130.0,126.9,1,0,0,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02831,1,17,9147,1,5,1,1,19,38,3,10,131.0,119.8,1,0,0,1,0,0,0,19,0,5,8,5,12.6,0,0,5,9,4,11.6,0,8.9,1.4,3.51,2 +Student_02832,1,17,9147,1,3,1,1,1,1,4,7,137.0,124.4,1,0,0,1,NA,0,0,18,0,5,5,5,12.6,0,0,5,5,4,11.0,0,11.1,0.6,2.02,1 +Student_02833,2,39,9003,1,1,1,1,3,3,2,2,150.0,120.0,0,0,1,0,0,0,0,34,1,6,10,6,14.333333333333334,0,0,6,9,6,12.833333333333334,0,11.1,0.6,2.02,1 +Student_02835,1,39,9085,1,1,1,1,19,19,7,7,133.1,130.0,1,0,0,1,0,0,0,24,0,6,7,6,14.857142857142858,0,0,6,10,5,13.6,0,13.9,-0.3,0.79,2 +Student_02836,2,43,9147,1,1,1,1,19,37,7,10,130.0,138.0,0,0,0,1,0,0,0,34,12,15,17,12,11.916666666666666,0,11,13,13,11,13.181818181818182,0,7.6,2.6,0.32,2 +Student_02837,2,39,9991,0,1,1,1,34,34,0,0,110.0,114.6,1,0,0,1,0,0,0,46,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_02838,2,39,9147,1,2,1,1,37,37,9,8,140.0,108.0,0,0,0,1,0,0,0,50,0,5,12,3,13.333333333333334,1,0,5,8,5,12.2,0,9.4,-0.8,-3.12,1 +Student_02839,1,39,9991,0,1,1,1,37,37,9,5,140.0,140.0,0,0,0,0,0,0,0,37,0,5,5,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_02840,1,1,9085,1,2,1,1,38,19,4,9,148.0,134.7,1,0,0,1,0,0,0,18,0,6,6,6,17.0,0,0,6,6,6,15.5,0,8.9,1.4,3.51,2 +Student_02841,1,39,9085,1,1,1,1,37,37,6,6,130.0,110.0,0,0,0,1,0,1,0,25,0,6,13,3,11.666666666666666,0,0,6,14,2,11.333333333333334,0,11.1,0.6,2.02,1 +Student_02843,2,39,9070,1,1,1,1,3,1,2,5,160.0,126.5,0,0,0,1,0,1,0,30,1,6,8,6,13.0,1,0,6,9,5,12.857142857142858,0,13.9,-0.3,0.79,2 +Student_02844,4,1,9991,0,1,1,1,37,37,9,9,130.0,118.1,0,0,1,0,0,0,0,37,0,5,0,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02845,2,39,9991,0,1,1,1,37,37,9,9,120.0,119.9,0,0,0,1,0,0,0,50,0,5,9,2,10.5,0,0,5,7,3,NA,0,12.7,3.7,-1.7,1 +Student_02846,1,44,9003,1,1,39,1,38,38,9,6,160.0,160.0,1,0,0,1,0,0,0,20,0,6,7,6,13.571428571428571,0,0,6,9,6,12.714285714285714,0,12.4,0.5,1.79,2 +Student_02850,1,44,9085,1,1,39,1,3,3,4,2,140.0,140.0,1,0,0,1,0,0,0,19,0,6,8,4,14.4,0,0,6,6,5,13.0,0,13.9,-0.3,0.79,2 +Student_02852,1,1,9773,1,3,1,1,1,37,4,5,130.0,120.9,1,0,1,1,0,0,0,18,0,6,6,6,14.333333333333334,0,0,6,6,6,14.166666666666666,0,8.9,1.4,3.51,2 +Student_02853,1,53,9003,1,1,42,1,1,1,144,144,130.0,125.8,0,0,1,1,0,0,0,21,7,13,21,11,11.909090909090908,0,5,11,14,11,10.727272727272728,0,8.9,1.4,3.51,2 +Student_02854,1,18,9070,1,3,1,1,1,1,5,3,164.0,161.2,1,0,0,1,0,0,0,18,1,6,8,6,13.714285714285714,1,0,6,8,6,14.375,0,13.9,-0.3,0.79,2 +Student_02855,1,1,9500,1,1,1,1,19,19,9,10,125.0,122.0,1,0,1,1,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,11.1,0.6,2.02,0 +Student_02856,1,17,9500,1,1,1,1,1,1,9,9,137.0,127.9,1,0,0,1,0,1,0,18,0,7,10,5,13.46,0,0,7,8,7,12.2375,0,11.1,0.6,2.02,0 +Student_02857,1,1,9773,1,1,1,1,1,3,3,3,133.0,135.8,1,0,0,1,0,0,0,19,0,6,6,6,15.0,0,0,6,6,6,13.333333333333334,0,11.1,0.6,2.02,2 +Student_02858,1,1,171,1,1,1,1,1,1,4,3,163.0,149.7,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02859,1,1,9670,1,2,1,1,2,1,4,4,160.0,137.3,1,0,0,1,0,0,0,19,0,6,7,5,13.4,0,0,6,6,5,12.8,0,12.7,3.7,-1.7,2 +Student_02860,4,43,8014,0,1,12,1,34,34,0,NA,133.1,106.0,1,0,0,1,0,0,0,48,0,6,9,5,13.0,0,0,6,10,4,12.5,0,7.6,2.6,0.32,1 +Student_02861,4,43,9238,1,1,1,1,37,37,9,9,120.0,110.0,0,0,1,1,0,0,0,34,0,6,13,4,11.25,0,0,6,8,4,13.75,0,13.9,-0.3,0.79,2 +Student_02862,1,1,9085,1,1,1,1,3,3,2,2,140.0,146.4,0,0,0,1,0,0,0,18,0,5,5,5,12.6,0,0,5,7,5,11.6,0,7.6,2.6,0.32,2 +Student_02863,2,39,8014,0,1,1,1,37,37,9,9,140.0,121.0,0,0,0,1,0,0,0,50,0,6,8,6,12.666666666666666,0,0,6,6,6,11.833333333333334,0,10.8,1.4,1.74,2 +Student_02864,1,43,9853,1,1,1,1,37,37,6,6,140.0,125.2,0,0,1,1,0,0,0,41,20,21,23,21,12.333333333333334,0,19,19,19,19,12.105263157894736,0,12.4,0.5,1.79,2 +Student_02865,1,17,9773,1,2,1,1,1,1,5,5,115.0,119.6,1,0,0,1,NA,1,0,22,0,6,11,5,12.0,0,0,6,11,5,11.0,0,7.6,2.6,0.32,0 +Student_02866,4,39,9147,1,1,1,1,37,37,9,9,140.0,142.8,0,0,0,1,0,0,0,43,0,5,5,5,16.4,0,0,5,5,5,16.6,0,7.6,2.6,0.32,2 +Student_02868,1,39,9003,1,1,19,1,37,37,9,9,133.1,100.0,0,0,0,1,0,0,0,60,0,6,10,6,12.75,0,0,6,6,4,14.75,0,13.9,-0.3,0.79,2 +Student_02869,2,39,9147,1,1,1,1,37,37,9,10,110.0,140.0,0,0,0,1,0,0,0,41,0,5,14,4,14.5,1,0,5,12,5,13.0,0,9.4,-0.8,-3.12,1 +Student_02870,2,39,9991,0,1,19,1,37,37,9,9,133.1,150.3,0,0,0,1,0,0,0,47,0,5,5,5,14.8,0,0,5,5,5,14.4,0,7.6,2.6,0.32,2 +Student_02871,1,1,171,1,1,3,1,3,3,2,2,116.0,128.2,0,0,0,1,0,0,0,22,12,17,22,17,10.36842105263158,0,14,17,18,17,11.5,0,11.1,0.6,2.02,2 +Student_02872,2,39,9500,1,1,1,1,37,37,9,6,110.0,114.3,0,0,0,1,0,0,0,41,0,7,0,0,0.0,0,0,8,0,0,0.0,0,10.8,1.4,1.74,0 +Student_02873,2,43,9991,0,1,1,1,38,37,5,6,140.0,117.3,0,0,0,1,0,0,0,28,6,10,15,6,10.666666666666666,0,5,10,17,9,11.333333333333334,1,7.6,2.6,0.32,1 +Student_02874,5,42,9254,1,1,2,1,37,37,4,9,120.0,120.0,0,0,0,1,0,0,0,32,9,15,21,13,12.692307692307692,0,12,15,22,13,12.384615384615383,0,10.8,1.4,1.74,2 +Student_02876,1,51,9147,1,1,1,1,1,37,9,10,160.0,118.0,0,0,0,1,0,0,0,53,14,15,15,15,11.8,0,12,13,13,12,11.666666666666666,1,8.9,1.4,3.51,1 +Student_02877,1,39,9556,1,1,1,6,3,3,4,4,133.1,169.2,0,0,1,0,NA,0,1,54,0,7,7,0,0.0,0,0,5,10,0,0.0,0,12.4,0.5,1.79,0 +Student_02878,1,39,8014,0,1,1,1,37,37,9,7,120.0,106.8,0,0,0,1,0,0,0,49,0,6,9,5,12.333333333333334,0,0,6,12,4,11.5,0,13.9,-0.3,0.79,1 +Student_02879,2,42,9853,1,1,1,1,37,37,4,7,133.1,100.0,0,0,0,1,0,0,0,34,6,12,18,11,13.0,0,4,13,22,8,11.875,0,12.7,3.7,-1.7,0 +Student_02880,4,39,8014,0,1,1,1,38,37,5,7,133.1,144.5,0,0,0,1,0,0,0,45,0,6,13,4,12.5,0,0,6,8,3,11.666666666666666,0,16.2,0.3,-0.92,0 +Student_02881,4,39,8014,0,1,19,1,37,37,9,7,133.1,134.5,0,0,0,1,0,1,0,47,0,6,8,5,12.2,0,0,6,10,4,11.25,0,12.4,0.5,1.79,2 +Student_02883,2,39,9991,0,1,1,1,37,37,9,9,133.1,113.4,0,0,0,1,0,0,0,33,0,5,14,1,10.0,0,0,5,13,2,12.0,0,NA,0.5,1.79,0 +Student_02884,2,39,8014,0,1,1,1,37,37,9,9,140.0,128.0,0,0,0,1,0,1,0,43,0,6,7,6,12.333333333333334,0,0,6,8,6,11.5,0,8.9,1.4,3.51,2 +Student_02885,1,7,9003,1,1,3,1,37,37,6,6,120.0,120.0,0,0,0,1,0,0,0,54,9,13,13,13,14.307692307692308,0,5,12,15,12,15.23076923076923,0,15.5,2.8,-4.06,2 +Student_02887,2,39,9991,0,1,1,1,37,37,9,9,120.0,120.7,0,0,0,1,0,0,0,39,0,5,6,5,11.0,0,0,5,5,5,13.2,0,7.6,2.6,0.32,2 +Student_02888,1,1,9853,1,1,1,1,19,37,9,9,153.0,153.7,0,0,0,1,0,1,0,18,0,6,8,6,13.142857142857142,0,0,6,6,6,12.833333333333334,0,15.5,2.8,-4.06,2 +Student_02890,1,17,9670,1,4,1,1,38,19,9,6,126.0,119.4,1,0,0,1,0,1,0,18,0,6,6,6,14.0,0,0,6,9,5,13.8,0,8.9,1.4,3.51,2 +Student_02891,2,39,8014,0,1,12,1,34,34,0,0,110.0,157.8,0,0,0,1,0,0,0,44,5,8,13,8,13.75,0,2,6,9,6,12.5,0,7.6,2.6,0.32,2 +Student_02892,1,39,9991,0,1,1,1,3,1,3,9,150.0,154.0,0,0,0,1,0,0,0,27,0,5,5,0,0.0,0,0,5,6,0,0.0,0,12.4,0.5,1.79,0 +Student_02894,2,43,8014,0,1,1,1,34,34,0,0,130.0,130.0,0,0,0,1,0,0,0,45,10,12,12,9,12.444444444444445,3,4,7,8,6,12.0,0,9.4,-0.8,-3.12,0 +Student_02895,1,17,9853,1,4,1,1,38,37,9,9,122.0,118.9,1,0,0,1,0,0,0,20,0,6,7,6,12.666666666666666,0,0,6,7,5,13.0,0,7.6,2.6,0.32,2 +Student_02896,2,1,8014,0,1,1,1,37,37,9,9,151.0,152.4,0,0,0,1,0,0,0,40,0,6,7,6,11.333333333333334,0,0,6,7,6,10.5,0,10.8,1.4,1.74,2 +Student_02897,1,39,9991,0,1,1,1,37,37,6,6,120.0,147.8,0,0,0,1,0,0,0,40,0,5,9,4,11.25,0,0,5,6,5,12.0,0,13.9,-0.3,0.79,1 +Student_02898,1,43,9500,1,1,1,1,3,3,2,2,136.0,100.0,0,0,0,NA,0,0,0,18,0,7,8,7,13.6125,0,0,8,8,8,14.575,0,13.9,-0.3,0.79,2 +Student_02899,1,18,9500,1,6,1,1,3,19,3,8,140.0,129.0,1,0,0,1,0,0,0,21,0,8,8,7,12.414285714285716,0,0,8,8,7,12.414285714285716,0,12.7,3.7,-1.7,2 +Student_02900,1,17,171,1,2,1,1,2,1,3,3,131.0,148.9,1,0,0,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_02901,2,43,9991,0,1,2,1,37,37,9,8,120.0,120.0,0,0,0,1,0,0,0,36,8,12,21,11,11.5,0,7,12,22,12,11.4375,0,9.4,-0.8,-3.12,1 +Student_02902,2,7,8014,0,1,3,1,19,19,4,4,170.0,170.0,0,0,0,1,0,0,0,27,0,5,5,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02903,2,39,9556,1,1,1,NA,38,38,9,9,100.0,130.0,0,0,0,1,0,0,1,32,0,7,10,7,11.0,0,0,8,8,8,13.125,0,12.7,3.7,-1.7,2 +Student_02904,1,17,9238,1,1,1,1,1,1,3,3,116.0,119.2,1,0,0,1,0,1,0,18,0,6,6,6,14.0,0,0,6,6,6,13.5,0,8.9,1.4,3.51,2 +Student_02905,1,39,8014,0,1,1,1,37,37,9,7,133.1,129.0,0,0,0,1,0,0,0,37,0,6,13,4,12.0,0,0,6,10,3,12.0,0,16.2,0.3,-0.92,0 +Student_02907,4,39,8014,0,2,1,1,37,38,7,5,160.0,115.0,0,0,0,1,0,1,0,41,0,6,8,6,11.333333333333334,0,0,6,9,6,11.333333333333334,0,NA,1.4,1.74,2 +Student_02909,1,43,9085,1,1,1,1,37,37,90,90,130.0,125.1,0,0,0,1,0,0,0,21,2,9,14,8,13.555555555555555,0,2,7,10,7,13.571428571428571,0,7.6,2.6,0.32,2 +Student_02910,1,44,9003,1,1,1,1,1,19,3,9,140.0,140.0,1,0,1,0,0,0,0,23,0,6,13,5,11.6,0,0,6,11,4,12.25,0,12.4,0.5,1.79,0 +Student_02911,1,NA,9773,1,2,1,1,1,1,3,3,123.0,120.9,1,0,0,1,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02913,1,43,9085,1,4,1,1,34,34,99,99,133.1,125.2,0,0,0,1,0,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_02914,1,1,9238,1,2,1,1,22,30,0,8,136.0,135.7,1,0,0,1,0,0,0,19,0,6,8,6,14.375,0,0,6,8,6,14.75,0,7.6,2.6,0.32,2 +Student_02915,6,39,9147,1,2,1,1,37,37,9,9,133.1,110.0,0,0,0,1,0,0,0,47,0,5,0,0,0.0,0,0,5,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02916,6,39,8014,0,1,1,1,37,37,9,9,133.1,119.0,0,0,0,1,0,1,0,48,0,6,7,6,10.666666666666666,0,0,6,9,5,11.8,0,10.8,1.4,1.74,1 +Student_02917,2,7,8014,0,1,3,1,37,37,9,9,110.0,110.0,0,0,0,1,0,0,0,39,9,13,19,12,13.416666666666666,0,4,10,10,10,14.5,0,16.2,0.3,-0.92,2 +Student_02919,1,43,9991,0,1,2,1,37,37,9,9,110.0,112.9,0,0,0,1,0,0,0,38,14,15,16,14,10.928571428571429,0,12,14,16,12,11.833333333333334,0,9.4,-0.8,-3.12,0 +Student_02920,5,39,9003,1,1,19,1,19,1,9,9,133.1,119.4,0,0,1,0,0,0,0,27,0,6,6,0,0.0,0,0,6,7,0,0.0,0,8.9,1.4,3.51,0 +Student_02921,1,1,171,1,1,1,1,19,19,4,7,162.0,152.9,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,2 +Student_02922,1,39,8014,0,1,1,1,19,37,4,5,155.0,117.5,0,0,0,1,0,0,0,34,0,6,6,4,13.25,0,0,6,6,0,0.0,0,12.7,3.7,-1.7,1 +Student_02923,2,39,9238,1,1,19,1,37,37,4,4,133.1,98.5,0,0,0,1,0,0,0,48,0,6,14,6,11.333333333333334,0,0,6,11,5,12.4,0,15.5,2.8,-4.06,0 +Student_02924,1,39,9670,1,1,1,1,34,34,0,0,150.0,108.0,0,0,0,1,0,0,0,25,0,5,6,1,11.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_02925,2,39,9500,1,1,1,1,19,37,6,6,133.1,120.0,0,0,0,1,0,1,0,32,0,8,9,7,12.757142857142856,0,0,8,9,7,12.757142857142856,0,12.7,3.7,-1.7,2 +Student_02927,1,44,8014,0,1,39,1,1,3,4,6,140.0,139.2,0,0,1,1,0,0,0,20,3,6,6,6,13.833333333333334,0,2,6,7,6,14.571428571428571,0,12.4,0.5,1.79,2 +Student_02928,1,1,9147,1,1,1,1,19,37,9,7,158.0,130.0,1,0,0,1,0,0,0,20,0,5,8,4,11.25,0,0,5,7,5,10.4,0,7.6,2.6,0.32,2 +Student_02930,1,1,9500,1,3,1,1,1,1,4,4,136.0,127.0,1,0,0,1,0,0,0,19,0,8,10,1,13.67,7,0,8,10,1,13.67,7,9.4,-0.8,-3.12,1 +Student_02931,1,39,9991,0,1,9,1,37,34,90,90,133.1,118.1,1,0,0,1,0,0,0,39,0,5,9,0,0.0,0,0,5,5,2,12.5,0,7.6,2.6,0.32,0 +Student_02935,2,39,8014,0,1,12,1,34,34,0,0,133.1,135.0,0,0,0,1,0,0,0,51,0,6,12,0,0.0,0,1,6,11,0,0.0,1,7.6,2.6,0.32,0 +Student_02936,1,43,9773,1,1,1,22,34,34,90,90,133.1,130.0,0,0,1,1,0,0,1,23,0,6,11,1,16.0,0,0,6,8,4,12.25,0,7.6,2.6,0.32,0 +Student_02937,1,44,9085,1,1,1,1,29,10,6,6,150.0,150.0,1,0,0,1,0,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_02938,1,43,9853,1,5,1,1,34,34,0,0,150.0,150.2,1,0,0,0,0,0,0,28,0,6,9,4,12.75,1,0,5,5,0,0.0,5,9.4,-0.8,-3.12,0 +Student_02939,2,39,9991,0,1,1,1,37,37,9,3,110.0,127.1,0,0,0,1,0,0,0,34,0,5,9,4,11.0,0,0,5,10,4,10.75,1,7.6,2.6,0.32,1 +Student_02941,NA,39,8014,0,1,3,1,37,37,9,9,100.0,130.0,0,0,0,1,0,1,0,43,0,6,7,5,12.2,0,0,6,6,6,12.333333333333334,0,9.4,-0.8,-3.12,2 +Student_02942,2,39,9556,1,2,1,105,1,3,9,2,133.1,152.8,1,0,0,1,0,0,1,28,0,7,9,7,12.428571428571429,0,0,8,8,8,12.3,0,12.4,0.5,1.79,1 +Student_02943,1,1,171,1,1,1,1,40,1,2,4,145.0,160.1,0,0,0,1,0,1,0,19,6,12,12,12,14.5,0,4,11,15,11,13.583333333333334,0,8.9,1.4,3.51,2 +Student_02945,1,1,9500,1,4,1,1,4,3,2,3,118.0,110.7,1,0,0,1,0,0,0,18,0,7,7,7,11.714285714285714,0,0,8,8,8,12.75,0,12.4,0.5,1.79,2 +Student_02946,2,39,9853,1,1,1,1,37,19,9,5,133.1,138.3,0,0,0,1,0,0,0,45,0,7,12,4,10.25,0,0,7,10,3,13.0,0,11.1,0.6,2.02,0 +Student_02947,1,44,9853,1,1,39,1,3,37,2,7,150.0,150.0,0,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_02948,1,17,9670,1,6,1,1,4,1,3,10,113.0,112.3,0,0,0,1,0,0,0,20,0,6,9,6,12.375,0,0,6,7,6,13.142857142857142,0,11.1,0.6,2.02,2 +Student_02949,1,1,9853,1,6,1,1,1,19,5,5,136.0,122.0,0,0,0,1,0,0,0,18,0,6,6,6,12.666666666666666,0,0,6,6,6,12.0,0,7.6,2.6,0.32,2 +Student_02950,1,39,9085,1,1,1,1,3,3,4,2,140.0,141.7,1,0,0,1,0,0,0,27,0,6,13,3,10.5,0,0,6,19,1,12.0,0,12.4,0.5,1.79,0 +Student_02951,2,1,9003,1,1,1,1,19,38,5,5,131.0,118.4,0,0,0,1,0,0,0,20,0,6,11,6,14.125,0,0,6,10,5,12.6,0,13.9,-0.3,0.79,2 +Student_02952,1,1,9085,1,3,1,1,1,1,4,8,138.0,128.7,1,0,0,1,0,0,0,18,0,6,7,6,14.666666666666666,0,0,6,12,6,13.833333333333334,0,8.9,1.4,3.51,2 +Student_02953,2,39,9670,1,2,1,1,37,37,9,9,100.0,100.0,0,0,0,1,0,0,0,35,0,5,8,5,11.4,0,0,5,7,3,12.333333333333334,0,9.4,-0.8,-3.12,1 +Student_02954,1,39,171,1,1,1,1,37,37,9,9,140.0,100.8,0,1,0,1,0,0,0,26,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_02957,1,7,9500,1,1,3,1,37,37,9,5,130.0,130.0,0,0,0,1,0,0,0,36,0,7,7,0,0.0,7,0,7,7,0,0.0,7,16.2,0.3,NA,0 +Student_02958,2,39,8014,0,1,3,1,37,37,9,9,110.0,160.5,0,0,0,1,0,0,0,38,8,11,11,11,12.636363636363637,0,5,8,8,8,11.0,0,13.9,-0.3,0.79,2 +Student_02960,5,39,9254,1,1,1,1,2,2,2,2,133.1,103.0,0,0,0,1,0,0,0,62,0,6,7,6,15.0,0,0,6,10,6,12.833333333333334,0,10.8,1.4,1.74,2 +Student_02962,1,1,9500,1,1,1,1,19,37,9,9,139.0,131.5,1,0,0,1,0,0,0,18,0,8,8,7,14.13714285714286,0,0,8,8,7,14.13714285714286,0,10.8,1.4,1.74,2 +Student_02963,NA,18,9070,1,3,1,1,1,1,3,4,134.0,121.4,0,0,0,1,0,0,0,18,0,6,6,2,12.0,0,0,6,6,1,11.0,0,9.4,-0.8,-3.12,0 +Student_02965,1,1,9070,1,1,1,1,19,19,9,9,124.0,138.4,1,0,1,1,0,1,0,19,1,6,8,6,13.285714285714286,1,0,6,8,6,12.5,0,13.9,-0.3,0.79,0 +Student_02966,1,17,NA,1,1,1,1,1,3,7,3,137.0,131.1,1,0,1,1,0,1,0,19,0,5,7,5,13.6,0,0,5,5,5,12.6,0,8.9,1.4,3.51,2 +Student_02967,1,42,9500,1,1,1,1,3,3,3,3,157.0,100.0,0,0,0,1,0,0,0,18,0,7,8,7,13.55,0,0,8,8,8,14.1875,0,13.9,-0.3,0.79,2 +Student_02968,1,17,9500,1,4,1,1,4,1,2,1,138.0,133.0,1,0,0,1,0,0,0,18,0,8,8,0,0.0,5,0,8,8,0,NA,5,9.4,-0.8,-3.12,1 +Student_02969,1,39,8014,0,2,1,1,35,37,90,90,100.0,100.0,0,0,0,1,0,0,0,41,0,6,10,4,13.5,0,1,6,7,6,11.166666666666666,0,7.6,2.6,0.32,2 +Student_02970,1,39,9670,1,1,1,1,19,3,4,2,130.0,159.0,0,0,0,1,0,1,0,51,0,6,8,5,11.6,0,0,6,9,5,14.2,0,12.4,0.5,1.79,2 +Student_02972,1,39,9991,0,1,3,1,19,1,9,5,120.0,134.0,0,0,0,1,0,0,0,25,0,5,14,1,11.0,0,0,5,11,2,12.666666666666666,4,16.2,0.3,-0.92,0 +Student_02973,1,5,9085,1,1,1,1,1,1,4,4,150.0,139.4,0,0,0,1,0,0,0,18,0,5,9,3,12.0,1,0,5,6,4,13.0,0,7.6,2.6,0.32,1 +Student_02974,1,16,9147,1,6,NA,1,37,37,9,9,128.0,116.5,1,0,0,1,0,0,0,20,0,5,8,4,11.6,0,0,5,10,3,12.333333333333334,0,7.6,2.6,0.32,2 +Student_02975,1,1,171,1,1,1,1,1,19,123,103,124.0,113.9,1,1,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02976,5,43,9991,0,1,3,1,3,3,1,1,130.0,130.0,0,0,0,1,0,0,0,41,5,10,14,10,14.636363636363637,0,5,10,13,10,14.6,0,16.2,0.3,-0.92,2 +Student_02977,1,1,9254,1,2,1,1,1,19,9,9,132.0,129.9,1,0,0,1,0,1,0,19,0,6,8,6,13.0,0,0,6,6,6,12.166666666666666,0,8.9,1.4,3.51,2 +Student_02978,1,42,9853,1,1,12,1,1,3,3,2,133.1,133.7,0,0,0,1,0,0,0,28,14,18,23,14,12.785714285714286,2,16,17,18,16,13.875,0,16.2,0.3,-0.92,0 +Student_02979,1,1,9070,1,3,1,1,5,3,5,7,129.0,124.8,1,0,0,1,0,0,0,21,0,6,6,6,14.5,0,0,6,7,5,12.0,0,12.4,0.5,1.79,2 +Student_02980,1,1,9085,1,1,1,1,3,2,1,1,135.0,133.6,1,0,0,0,0,0,0,22,0,5,12,4,14.6,3,0,5,5,4,12.75,1,9.4,-0.8,-3.12,0 +Student_02981,1,17,9773,1,4,1,1,37,19,5,7,138.0,133.5,1,0,0,0,0,0,0,18,0,6,7,6,12.5,0,0,6,6,6,12.166666666666666,0,10.8,1.4,1.74,2 +Student_02982,1,1,9070,1,1,1,1,19,37,9,9,135.0,128.0,1,0,0,1,0,1,0,19,0,6,6,6,14.0,0,0,6,8,6,13.125,0,10.8,1.4,1.74,2 +Student_02983,1,17,9500,1,6,1,1,3,19,5,5,131.0,127.2,1,0,0,1,0,1,0,19,0,7,7,7,13.801428571428572,0,0,8,8,8,14.575,0,11.1,0.6,2.02,2 +Student_02984,1,7,9853,1,1,3,1,19,19,4,5,NA,150.0,0,0,1,0,0,0,0,25,1,6,7,6,14.428571428571429,0,0,6,7,6,13.666666666666666,0,10.8,1.4,1.74,2 +Student_02985,1,42,9500,1,4,6,1,1,19,2,9,133.0,127.8,1,0,0,1,0,1,0,18,0,7,7,6,14.35,0,0,7,7,6,14.35,0,7.6,2.6,0.32,2 +Student_02986,1,17,9070,1,1,1,1,37,19,9,9,135.0,125.2,1,0,0,1,0,0,0,19,0,6,6,6,14.333333333333334,0,0,6,6,6,13.5,0,12.7,3.7,-1.7,2 +Student_02989,1,NA,171,1,1,1,1,3,3,3,3,158.0,151.4,1,0,0,0,0,0,0,19,6,12,12,12,13.0,0,4,11,14,11,13.25,0,8.9,1.4,3.51,2 +Student_02990,1,1,9254,1,2,1,1,38,19,9,7,137.0,125.1,1,0,0,1,0,0,0,18,0,6,10,4,11.75,0,0,6,9,5,11.2,0,7.6,2.6,0.32,1 +Student_02991,1,1,9130,1,1,1,1,19,19,9,9,172.0,163.3,1,0,0,1,0,1,0,18,0,6,8,6,14.5,0,0,6,11,4,13.0,0,13.9,-0.3,0.79,2 +Student_02992,1,18,9500,1,1,1,1,37,37,3,3,123.0,118.0,1,0,0,1,0,1,0,19,0,8,8,7,11.82,0,0,8,8,7,11.82,0,10.8,1.4,1.74,2 +Student_02993,1,1,9773,1,2,1,1,3,3,3,2,144.0,140.2,1,0,0,1,0,0,0,20,0,6,0,0,0.0,0,0,6,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_02995,1,17,9773,1,1,1,1,1,38,9,8,136.0,131.5,1,0,0,1,0,0,0,18,0,6,7,6,12.571428571428571,0,0,6,8,6,11.857142857142858,0,13.9,-0.3,0.79,2 +Student_02996,1,17,9500,1,5,1,1,1,1,5,5,137.0,132.6,1,0,0,1,0,1,0,18,0,7,7,7,13.857142857142858,0,0,8,8,8,14.9,0,13.9,-0.3,0.79,2 +Student_02997,1,17,9238,1,1,1,1,19,1,0,5,128.0,122.1,1,0,0,1,0,0,0,18,0,6,9,5,11.833333333333334,0,0,6,7,5,13.8,0,13.9,-0.3,0.79,2 +Student_02999,1,1,9130,1,1,1,1,3,19,4,8,130.0,133.0,1,0,0,1,0,0,0,19,0,6,6,6,14.666666666666666,0,0,6,8,6,13.666666666666666,0,12.4,0.5,1.79,2 +Student_03000,4,39,8014,0,1,1,1,19,19,90,90,138.0,127.0,0,0,0,0,0,0,0,37,0,4,4,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_03003,1,1,9773,1,3,1,1,3,1,5,3,136.0,129.0,1,0,0,1,0,1,0,19,0,6,7,6,14.0,0,0,6,8,5,12.2,0,13.9,-0.3,0.79,0 +Student_03004,1,17,9556,1,3,1,1,19,19,9,4,126.0,119.0,1,0,0,1,0,1,0,19,0,7,8,7,12.142857142857142,0,0,8,8,8,13.375,0,16.2,0.3,-0.92,0 +Student_03005,1,17,9147,1,1,1,1,37,38,9,9,135.0,128.0,1,0,1,1,0,1,0,18,0,5,5,5,12.8,0,0,5,5,5,13.0,0,11.1,0.6,2.02,2 +Student_03006,1,1,9500,1,4,1,1,19,38,7,7,122.0,117.1,1,0,0,1,0,1,0,18,0,7,7,7,14.572857142857142,0,0,8,9,8,14.955555555555556,0,12.4,0.5,1.79,2 +Student_03007,1,1,9147,1,4,1,1,1,19,4,5,137.0,136.3,0,0,0,1,0,0,0,18,0,5,9,4,11.25,0,0,5,6,4,11.0,0,8.9,1.4,3.51,2 +Student_03008,1,17,9147,1,5,1,1,1,38,4,5,127.0,124.6,1,0,0,1,0,1,0,19,0,5,12,2,10.0,0,0,5,11,4,11.75,0,11.1,0.6,2.02,1 +Student_03009,1,1,9130,1,1,1,1,40,19,2,9,137.0,130.7,1,0,0,1,0,0,0,18,0,6,8,5,14.4,0,0,6,11,4,14.6,0,8.9,1.4,3.51,0 +Student_03013,1,16,9500,1,1,1,1,37,37,9,9,133.1,95.0,1,0,0,1,0,0,0,20,0,7,7,6,13.755,0,0,8,9,7,13.571428571428571,0,12.4,0.5,1.79,2 +Student_03014,1,17,9670,1,1,1,1,1,1,3,3,132.0,119.4,1,0,0,1,0,1,0,18,0,6,7,6,13.833333333333334,0,0,6,11,6,13.5,0,8.9,1.4,3.51,2 +Student_03016,1,1,9500,1,4,1,1,38,1,5,6,136.0,133.9,1,0,0,1,0,0,0,18,0,7,9,7,14.711111111111112,0,0,8,9,8,14.627777777777778,0,15.5,2.8,-4.06,2 +Student_03017,1,53,9085,1,1,42,1,1,19,4,8,150.0,145.2,1,0,0,1,0,0,0,20,7,11,13,11,14.615384615384617,0,4,9,11,9,13.7,0,8.9,1.4,3.51,2 +Student_03018,1,1,9500,1,1,1,1,3,3,1,5,130.0,118.8,0,0,0,1,0,0,0,18,0,7,7,7,13.677142857142858,0,0,8,9,8,14.533333333333331,0,11.1,0.6,2.02,2 +Student_03019,1,16,9085,1,2,1,1,37,37,9,9,136.0,123.4,1,0,0,1,0,1,0,19,0,5,8,5,13.166666666666666,2,0,5,5,5,12.8,0,9.4,-0.8,-3.12,2 +Student_03020,1,17,9238,1,6,1,1,3,3,1,2,138.0,123.0,1,0,0,1,0,0,0,19,0,6,11,5,10.8,0,0,6,12,5,11.333333333333334,0,15.5,2.8,-4.06,2 +Student_03021,1,17,9130,1,1,1,1,19,9,5,3,131.0,118.4,0,0,0,1,0,0,0,19,0,5,8,3,12.0,0,0,5,7,5,12.833333333333334,0,7.6,2.6,0.32,2 +Student_03022,1,1,9500,1,1,1,1,3,1,2,3,147.0,131.6,0,0,0,1,0,0,0,18,0,7,8,6,NA,0,0,8,8,8,14.71875,0,11.1,0.6,2.02,2 +Student_03023,1,17,9853,1,1,1,1,38,19,4,10,140.0,122.3,1,0,0,1,0,0,0,19,0,6,9,4,13.0,0,0,6,9,4,12.25,0,12.7,3.7,-1.7,0 +Student_03024,1,1,171,1,2,1,1,38,19,9,9,152.0,151.7,1,0,0,1,0,1,0,24,0,0,0,0,0.0,0,0,0,0,0,0.0,0,NA,0.6,2.02,2 +Student_03025,1,1,171,1,1,1,1,19,37,9,7,169.0,176.0,1,0,0,NA,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,2 +Student_03026,1,1,9500,1,6,1,1,1,1,4,9,149.0,133.0,1,0,0,1,0,1,0,18,0,8,8,7,14.0,0,0,8,8,7,14.0,0,12.7,3.7,-1.7,2 +Student_03027,1,1,9773,1,4,1,1,3,19,2,3,137.0,139.8,1,1,0,1,0,0,0,18,0,6,10,6,12.571428571428571,0,0,6,11,6,12.571428571428571,0,10.8,1.4,1.74,1 +Student_03029,1,39,8014,0,1,1,1,37,37,9,6,130.0,134.0,0,0,0,1,0,1,0,35,2,8,8,8,13.625,0,1,7,7,7,14.0,0,8.9,1.4,3.51,2 +Student_03030,1,17,9147,1,6,1,1,37,37,9,9,145.0,132.0,1,0,0,1,0,0,0,19,0,5,7,4,12.5,0,0,5,8,4,10.0,1,7.6,2.6,0.32,2 +Student_03031,1,7,9853,1,1,3,1,37,37,9,9,130.0,130.0,0,0,0,1,0,0,0,28,14,15,25,14,12.428571428571429,1,8,14,22,11,11.909090909090908,0,7.6,2.6,0.32,0 +Student_03032,1,43,9500,1,1,1,1,38,3,5,2,157.0,141.4,0,0,0,1,0,0,0,21,3,7,8,7,13.3875,0,2,8,8,8,15.9,0,13.9,-0.3,0.79,2 +Student_03033,1,NA,9500,1,2,1,1,19,1,5,5,135.0,128.9,1,0,0,1,0,1,0,19,0,7,8,6,12.648333333333332,0,0,8,9,8,12.205555555555556,0,11.1,0.6,2.02,2 +Student_03034,1,5,9238,1,2,1,1,40,38,2,9,123.0,118.1,1,0,0,1,0,0,0,19,0,6,6,6,14.0,0,0,6,6,6,13.333333333333334,0,8.9,1.4,3.51,2 +Student_03035,1,1,9085,1,1,1,1,3,4,2,2,139.0,130.6,0,0,0,1,0,0,0,18,0,5,12,5,12.8,2,0,5,10,5,11.857142857142858,1,9.4,-0.8,-3.12,2 +Student_03036,1,1,9254,1,1,1,1,12,1,4,4,136.0,122.0,1,0,0,1,0,0,0,18,0,6,8,6,11.333333333333334,0,0,6,11,6,NA,0,7.6,2.6,0.32,2 +Student_03037,1,1,9500,1,2,1,1,3,3,2,2,135.0,123.0,1,0,0,0,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03038,1,1,9670,1,1,1,1,1,1,9,10,126.0,126.7,1,0,0,1,0,1,0,20,0,6,6,6,14.166666666666666,0,0,6,9,6,13.0,0,8.9,1.4,3.51,2 +Student_03039,1,1,9773,1,1,1,1,38,19,9,9,122.0,126.6,1,0,0,1,0,0,0,18,0,6,6,6,12.833333333333334,0,0,6,6,6,13.833333333333334,0,8.9,1.4,3.51,2 +Student_03040,1,1,9853,1,1,1,1,38,38,9,9,125.0,125.4,0,0,1,0,0,0,0,19,0,7,11,4,12.0,0,0,7,9,6,11.833333333333334,0,16.2,0.3,-0.92,0 +Student_03041,1,1,9773,1,3,1,1,1,19,9,9,134.0,136.1,1,0,0,1,0,1,0,20,0,6,6,6,13.0,0,0,6,7,6,13.142857142857142,0,12.4,0.5,1.79,0 +Student_03042,1,17,9500,1,5,1,1,19,1,9,4,130.0,128.8,1,0,0,1,0,0,0,18,0,7,8,6,13.39,0,0,8,10,7,12.757142857142856,0,11.1,0.6,2.02,1 +Student_03043,1,17,9670,1,4,1,1,1,37,7,7,110.0,111.1,1,0,0,0,0,0,0,18,0,6,6,6,12.333333333333334,0,0,6,8,5,13.6,0,8.9,1.4,3.51,2 +Student_03044,1,1,9070,1,1,1,1,3,3,3,3,131.0,135.9,0,0,0,1,0,1,0,21,1,6,8,6,12.571428571428571,1,0,6,8,6,11.625,0,13.9,-0.3,0.79,2 +Student_03045,1,5,9254,1,5,1,1,1,37,9,7,122.0,119.6,1,0,0,1,0,1,0,19,0,6,6,6,12.333333333333334,0,0,6,6,6,12.833333333333334,0,12.4,0.5,1.79,2 +Student_03047,1,1,9085,1,1,1,1,1,1,9,7,146.0,126.0,0,0,0,1,0,0,0,19,0,5,7,3,12.333333333333334,0,0,5,7,4,10.25,0,7.6,2.6,0.32,1 +Student_03048,1,1,9773,1,4,1,1,37,37,0,90,137.0,134.2,1,0,0,1,0,0,0,18,0,6,6,6,13.166666666666666,0,0,6,8,5,14.2,0,10.8,1.4,1.74,0 +Student_03049,1,1,9147,1,1,1,1,1,19,3,3,130.0,123.0,0,0,0,1,0,1,0,18,0,5,7,5,13.333333333333334,0,0,5,6,5,13.6,0,12.7,3.7,-1.7,2 +Student_03051,2,39,9556,1,1,1,1,37,37,9,6,160.0,120.0,0,0,0,1,0,0,0,31,0,7,21,5,10.9,3,0,8,21,3,11.7,1,12.7,3.7,-1.7,0 +Student_03052,1,42,9147,1,1,1,1,3,38,2,5,139.0,112.3,1,0,0,1,0,0,0,19,0,5,8,2,11.5,0,0,5,10,3,10.857142857142858,0,10.8,1.4,1.74,1 +Student_03053,1,16,9085,1,1,1,1,37,37,9,9,138.0,123.0,1,0,0,1,0,1,0,20,0,6,7,6,15.857142857142858,0,0,6,6,6,16.0,0,13.9,-0.3,0.79,2 +Student_03054,1,17,9085,1,1,1,1,38,19,0,90,137.0,122.3,0,0,0,1,0,1,0,19,0,5,5,5,12.6,0,0,5,9,3,13.0,0,7.6,2.6,0.32,0 +Student_03055,1,17,9238,1,1,1,1,38,38,9,6,127.0,122.8,0,0,0,1,0,1,0,19,0,6,8,6,14.0,0,0,6,7,6,14.571428571428571,0,16.2,0.3,-0.92,2 +Student_03056,5,7,9130,1,1,3,1,19,38,9,6,160.0,160.0,0,0,0,0,0,0,0,27,1,5,8,3,14.666666666666666,2,0,5,7,2,13.0,2,10.8,1.4,1.74,0 +Student_03057,1,17,9773,1,2,1,1,19,19,9,6,132.0,120.1,1,0,0,1,0,1,0,18,0,6,6,6,13.666666666666666,0,0,6,6,6,14.0,0,8.9,1.4,3.51,2 +Student_03058,1,1,8014,0,1,1,1,34,34,0,0,126.0,142.4,0,0,0,1,0,0,0,32,0,6,0,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_03059,1,1,9500,1,4,1,1,38,19,8,7,133.0,127.3,1,0,0,1,0,0,0,18,0,8,8,7,12.628571428571428,0,0,8,8,7,12.628571428571428,0,12.7,3.7,-1.7,2 +Student_03060,1,1,9500,1,3,NA,1,19,37,9,9,140.0,125.5,1,0,0,1,0,1,0,19,0,8,8,7,14.232857142857142,0,0,8,8,7,14.232857142857142,0,10.8,1.4,1.74,2 +Student_03061,1,1,9773,1,2,1,1,19,19,5,6,130.0,137.4,0,0,0,1,0,0,0,19,0,6,6,6,15.0,0,0,6,7,6,14.0,0,15.5,2.8,-4.06,1 +Student_03062,1,17,9254,1,2,1,1,12,37,9,9,129.0,122.0,1,0,0,1,0,0,0,18,0,6,15,2,10.0,0,0,6,12,0,0.0,0,10.8,1.4,1.74,0 +Student_03063,1,17,9670,1,3,1,1,19,1,4,4,110.0,107.5,1,0,0,1,0,1,0,18,0,6,11,4,12.25,0,0,6,10,4,11.0,0,12.7,3.7,-1.7,0 +Student_03064,1,39,NA,1,1,19,1,19,19,171,163,133.1,104.0,0,0,1,0,0,1,0,24,0,6,6,6,13.5,0,0,6,6,6,13.0,0,11.1,0.6,2.02,2 +Student_03067,1,44,9070,1,1,39,1,1,1,4,10,130.0,130.0,1,0,0,1,0,0,0,19,2,7,11,6,12.0,0,5,9,9,8,12.75,0,16.2,0.3,-0.92,2 +Student_03068,1,1,9500,1,3,1,6,2,3,5,2,140.0,124.3,1,0,0,1,0,0,1,19,0,7,9,5,12.32,0,0,7,9,5,11.9,0,12.4,0.5,1.79,1 +Student_03071,1,1,9670,1,3,1,1,1,19,5,5,121.0,111.9,1,0,0,1,1,1,0,20,0,6,7,6,11.333333333333334,0,0,6,10,4,10.571428571428571,0,10.8,1.4,1.74,1 +Student_03072,1,39,8014,0,1,38,1,1,1,4,4,133.1,107.5,0,0,1,0,1,0,0,29,0,6,6,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_03074,1,39,9119,1,1,1,1,19,37,9,4,130.0,149.0,1,0,0,1,1,0,0,33,0,5,10,4,12.0,0,0,5,8,3,13.666666666666666,1,7.6,2.6,0.32,1 +Student_03075,2,2,9147,1,1,2,1,37,37,9,9,120.0,120.0,0,0,0,0,1,0,0,57,12,15,17,12,11.75,0,9,14,16,9,NA,0,9.4,-0.8,-3.12,0 +Student_03076,1,1,9670,1,1,1,1,4,2,123,112,132.0,143.6,1,0,0,1,1,0,0,20,0,6,8,5,12.8,0,0,6,10,5,11.6,0,13.9,-0.3,0.79,1 +Student_03077,1,39,9670,1,1,1,1,1,1,4,4,100.0,120.0,0,0,0,1,1,0,0,26,0,5,7,3,11.333333333333334,0,0,5,7,3,13.666666666666666,0,9.4,-0.8,-3.12,0 +Student_03078,1,43,9119,1,1,1,1,1,1,9,2,130.0,128.0,0,0,1,0,1,0,0,27,0,5,5,0,0.0,0,0,5,7,0,0.0,0,13.9,-0.3,0.79,1 +Student_03079,1,1,9670,1,1,1,1,1,37,4,9,129.0,118.2,0,0,0,1,1,0,0,19,0,5,5,5,10.8,0,0,5,5,4,12.25,0,9.4,-0.8,-3.12,2 +Student_03080,1,44,9085,1,1,39,1,12,38,4,8,160.0,160.0,1,0,0,1,1,0,0,23,1,6,10,5,12.5,0,1,6,8,2,13.5,0,12.4,0.5,1.79,0 +Student_03082,1,1,9500,1,6,1,1,19,37,3,5,122.0,116.6,1,0,1,1,1,1,0,20,0,7,7,7,13.314285714285717,0,0,8,8,8,12.575,0,12.4,0.5,1.79,2 +Student_03083,1,18,9070,1,1,1,1,38,38,7,5,143.0,141.6,0,0,0,1,0,1,0,19,6,12,12,11,13.090909090909092,0,5,11,12,11,12.083333333333334,0,10.8,1.4,1.74,2 +Student_03084,1,1,9130,1,1,1,1,3,19,2,9,110.0,105.5,1,0,1,0,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03085,1,1,9070,1,1,1,1,37,19,9,3,124.0,116.3,1,0,0,1,0,0,0,20,0,6,8,5,12.2,0,0,6,6,6,11.5,0,16.2,0.3,-0.92,2 +Student_03086,2,7,9147,1,1,3,1,19,1,9,9,110.0,110.0,0,0,0,1,0,0,0,33,5,8,10,6,12.833333333333334,0,2,5,8,4,12.0,0,11.1,0.6,2.02,1 +Student_03087,1,43,9991,0,1,1,1,37,37,9,9,130.0,119.5,1,0,0,1,0,0,0,22,9,15,17,15,11.2,0,9,14,15,14,12.428571428571429,0,7.6,2.6,0.32,2 +Student_03088,1,1,9147,1,6,1,1,19,12,4,4,139.0,125.0,1,0,0,1,0,0,0,18,0,5,8,3,12.333333333333334,0,0,5,7,4,12.0,0,7.6,2.6,0.32,2 +Student_03089,5,39,9500,1,1,3,1,37,38,9,9,140.0,160.0,0,0,0,1,0,0,0,27,0,8,8,7,15.94285714285714,0,0,8,8,7,15.94285714285714,0,12.7,3.7,-1.7,2 +Student_03090,1,39,9991,0,1,1,1,37,37,9,7,150.0,150.0,0,0,0,1,0,0,0,27,0,5,0,0,0.0,0,0,5,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_03091,1,1,9238,1,1,1,1,37,37,9,9,123.0,115.0,1,0,0,1,0,0,0,19,0,6,10,4,10.25,0,0,6,8,6,10.714285714285714,0,11.1,0.6,2.02,2 +Student_03093,1,1,8014,0,1,1,1,38,19,6,10,100.0,112.8,0,0,0,1,0,1,0,23,0,6,6,6,14.166666666666666,0,0,6,6,6,12.5,0,12.7,3.7,-1.7,2 +Student_03095,1,17,9254,1,2,1,1,19,19,7,7,130.0,121.6,1,0,0,1,0,1,0,18,0,6,9,1,10.0,1,0,6,6,0,0.0,0,12.7,3.7,-1.7,0 +Student_03096,1,1,9238,1,4,1,1,19,38,9,9,118.0,110.0,0,0,0,1,0,1,0,18,0,6,7,6,12.285714285714286,0,0,6,8,6,11.428571428571429,0,12.4,0.5,1.79,2 +Student_03097,1,39,8014,0,1,1,1,38,38,9,9,120.0,148.5,0,0,0,1,0,1,0,31,0,6,6,6,14.0,0,0,6,6,6,12.333333333333334,0,10.8,1.4,1.74,2 +Student_03099,1,1,9238,1,1,1,1,37,37,9,9,138.0,135.9,1,0,0,1,0,0,0,19,0,6,11,5,11.6,0,0,6,11,6,11.666666666666666,0,7.6,2.6,0.32,1 +Student_03100,1,17,8014,0,1,1,1,19,37,4,7,127.0,115.8,0,0,0,1,0,0,0,24,0,6,12,1,12.0,0,0,6,12,0,0.0,0,10.8,1.4,1.74,0 +Student_03101,NA,1,9500,1,1,1,1,38,19,3,10,134.0,121.2,0,0,0,1,0,0,0,19,0,7,10,7,13.47,0,0,8,8,8,13.32625,0,15.5,2.8,-4.06,2 +Student_03102,1,17,9147,1,4,1,1,1,1,4,5,133.0,136.2,1,0,0,1,0,0,0,19,0,5,6,5,12.4,0,0,5,5,5,12.8,0,7.6,2.6,0.32,2 +Student_03104,1,1,171,1,1,1,41,37,37,9,9,180.0,152.7,1,0,1,0,1,0,1,27,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,0 +Student_03105,1,17,9238,1,4,1,1,NA,19,4,7,129.0,123.1,1,0,0,1,0,0,0,19,0,6,7,6,12.0,0,0,6,7,6,12.428571428571429,0,NA,0.6,2.02,2 +Student_03106,2,39,9085,1,1,1,1,19,19,1,4,NA,130.0,0,0,0,1,0,0,0,29,0,5,8,5,NA,2,0,5,6,5,15.4,0,9.4,-0.8,-3.12,0 +Student_03107,1,1,9500,1,6,1,1,1,38,4,5,141.0,125.0,1,0,0,1,0,1,0,18,0,8,8,8,12.32,0,0,8,8,8,12.32,0,9.4,-0.8,-3.12,2 +Student_03108,1,1,9500,1,1,1,1,1,19,9,10,118.0,113.1,1,0,0,1,0,0,0,19,0,7,7,7,13.79857142857143,0,0,8,8,8,14.75625,0,11.1,0.6,2.02,2 +Student_03109,1,NA,9773,1,5,1,1,38,1,4,5,127.0,121.1,1,0,0,1,0,0,0,18,0,6,6,6,13.166666666666666,0,0,6,6,6,12.5,0,15.5,2.8,-4.06,1 +Student_03110,1,1,9147,1,1,1,1,1,38,3,9,177.0,162.3,0,0,0,1,0,1,0,18,0,5,6,5,16.333333333333332,0,0,5,5,5,15.4,0,15.5,2.8,-4.06,2 +Student_03111,1,42,171,1,1,1,1,1,1,1,4,132.0,132.0,1,0,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03112,1,17,9500,1,4,1,1,4,4,4,4,133.0,130.7,1,0,0,1,0,0,0,19,0,7,7,7,14.757142857142856,0,0,8,9,8,15.366666666666667,0,12.4,0.5,1.79,2 +Student_03113,NA,17,9254,1,4,1,1,1,1,4,4,124.0,122.3,1,0,0,1,0,0,0,19,0,6,7,6,11.666666666666666,0,0,6,6,6,12.333333333333334,0,13.9,-0.3,0.79,0 +Student_03114,1,NA,9670,1,1,1,1,3,38,2,9,143.0,144.1,1,0,0,1,0,0,0,19,0,6,7,5,12.6,0,0,6,10,5,12.375,0,10.8,1.4,1.74,1 +Student_03115,1,1,9773,1,1,1,1,1,19,9,7,128.0,118.2,0,0,0,1,0,0,0,19,0,6,6,6,11.666666666666666,0,0,6,6,6,11.5,0,12.7,3.7,-1.7,2 +Student_03116,1,1,9238,1,1,1,1,19,38,5,8,138.0,133.5,0,0,0,1,0,1,0,19,0,6,6,6,15.0,0,0,6,6,6,13.333333333333334,0,8.9,1.4,3.51,2 +Student_03117,1,1,9500,1,5,1,1,37,37,7,9,144.0,126.8,1,0,1,0,0,0,0,NA,0,7,0,0,0.0,0,0,8,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03119,1,17,9254,1,1,1,1,19,19,3,10,111.0,117.7,0,0,0,1,0,0,0,20,0,6,8,5,10.8,0,0,6,9,4,11.5,0,9.4,-0.8,-3.12,2 +Student_03120,1,1,9085,1,1,1,1,38,37,1,1,133.1,115.0,1,0,0,1,0,0,0,21,0,5,8,3,11.333333333333334,1,0,5,8,3,13.333333333333334,0,12.7,3.7,-1.7,1 +Student_03121,2,1,9991,0,1,2,1,37,37,6,3,120.0,129.2,0,0,0,1,0,0,0,31,4,10,16,5,11.4,0,4,10,10,6,12.833333333333334,0,9.4,-0.8,-3.12,0 +Student_03122,1,1,9556,1,1,1,1,37,38,7,9,135.0,125.8,0,0,0,1,0,1,0,20,0,7,14,7,10.642857142857142,0,0,8,8,8,11.55,0,12.7,3.7,-1.7,2 +Student_03123,1,17,9670,1,5,1,1,19,30,7,7,125.0,118.4,1,0,0,1,0,1,0,19,0,5,8,3,10.5,0,0,5,6,4,11.75,1,7.6,2.6,0.32,1 +Student_03124,1,1,9500,1,1,1,1,38,38,9,9,147.0,142.0,1,0,0,1,0,0,0,18,0,7,7,6,14.65,0,0,7,7,6,14.65,0,7.6,2.6,0.32,2 +Student_03125,1,17,9500,1,3,1,1,19,37,7,7,137.0,126.7,1,0,0,1,0,1,0,19,0,7,7,7,13.714285714285714,0,0,8,11,8,14.863636363636363,0,16.2,0.3,-0.92,2 +Student_03126,1,43,9238,1,1,1,1,34,34,0,0,117.0,109.3,0,0,0,1,0,0,0,30,9,16,19,15,12.266666666666667,0,11,13,14,13,12.071428571428571,0,9.4,-0.8,-3.12,2 +Student_03127,1,17,NA,1,1,1,1,37,19,9,8,126.0,116.9,1,0,0,1,0,0,0,21,0,6,11,6,10.375,0,0,6,12,3,11.666666666666666,0,12.7,3.7,-1.7,1 +Student_03128,1,18,9147,1,1,1,1,19,19,9,5,128.0,121.7,1,0,0,1,0,0,0,19,0,5,8,5,11.0,0,0,5,6,5,15.4,0,12.4,0.5,1.79,2 +Student_03129,1,1,9147,1,6,1,1,1,37,4,9,115.0,117.1,1,0,1,1,0,0,0,22,0,5,5,5,13.8,0,0,5,5,5,13.0,0,7.6,2.6,0.32,2 +Student_03130,1,1,9773,1,1,1,1,1,38,4,9,121.0,114.4,0,0,0,1,0,1,0,18,0,6,6,6,12.666666666666666,0,0,6,6,6,12.833333333333334,0,11.1,0.6,2.02,2 +Student_03131,1,17,9238,1,1,1,1,3,1,3,4,134.0,133.0,1,0,0,1,0,0,0,18,0,6,8,6,11.75,0,0,6,10,5,12.0,0,12.7,3.7,-1.7,2 +Student_03132,1,1,9500,1,3,1,1,38,38,9,8,126.0,118.8,1,0,0,1,0,1,0,19,0,8,8,7,12.785714285714286,0,0,8,8,7,12.785714285714286,0,12.7,3.7,-1.7,2 +Student_03133,1,1,9130,1,1,1,1,3,1,2,4,151.0,151.0,1,0,0,1,0,0,0,18,0,6,11,6,14.444444444444445,0,0,6,6,6,13.333333333333334,0,16.2,0.3,-0.92,2 +Student_03134,1,1,9500,1,6,1,1,1,1,4,4,122.0,119.6,1,0,0,1,NA,0,0,21,0,7,8,6,13.25,0,0,8,8,8,13.8375,0,13.9,-0.3,0.79,1 +Student_03135,1,17,9500,1,1,1,1,2,38,2,10,141.0,135.4,1,0,0,1,0,0,0,18,0,7,9,7,12.50625,0,0,8,15,5,13.2,0,13.9,-0.3,0.79,1 +Student_03137,1,1,9085,1,1,1,1,38,37,9,7,133.0,120.1,1,0,0,1,0,0,0,18,0,5,8,4,12.75,1,0,5,10,4,11.75,0,12.7,3.7,-1.7,2 +Student_03138,1,39,9085,1,1,3,1,2,3,4,7,150.0,173.3,1,0,0,1,0,0,0,NA,1,6,7,6,16.857142857142858,0,1,6,6,6,16.5,0,13.9,-0.3,0.79,2 +Student_03139,1,1,9773,1,1,1,1,19,19,4,3,136.0,126.2,0,0,0,1,0,0,0,19,0,6,6,6,13.166666666666666,0,0,6,6,6,15.0,0,16.2,0.3,-0.92,2 +Student_03140,1,1,9853,1,1,1,1,19,38,2,7,129.0,126.9,1,0,0,1,0,1,0,19,0,6,9,5,12.2,0,0,6,10,4,11.5,0,7.6,2.6,0.32,1 +Student_03141,1,39,9085,1,1,1,1,19,1,9,10,128.0,157.4,1,0,0,1,0,0,0,26,0,6,7,6,16.5,0,0,6,8,6,14.285714285714286,0,8.9,1.4,3.51,2 +Student_03142,1,17,9147,1,2,1,1,1,19,4,5,131.0,120.2,1,0,0,1,0,0,0,21,0,5,10,4,11.75,0,0,5,6,5,11.6,0,12.4,0.5,1.79,2 +Student_03143,1,1,9147,1,1,1,1,38,38,2,9,130.0,124.8,0,0,0,1,0,0,0,19,0,5,14,1,11.0,0,0,5,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_03144,1,17,9500,1,1,1,1,37,37,9,9,150.0,130.3,0,0,0,1,0,1,0,19,0,8,8,7,15.114285714285714,0,0,8,8,7,15.114285714285714,0,12.7,3.7,-1.7,2 +Student_03145,1,1,9238,1,1,1,1,37,38,9,8,165.0,152.4,1,0,0,1,0,1,0,18,0,6,8,6,15.5,0,0,6,7,6,14.285714285714286,0,16.2,0.3,-0.92,2 +Student_03147,1,1,9238,1,1,1,1,3,1,5,5,126.0,125.7,0,0,0,1,0,1,0,18,0,6,6,6,11.333333333333334,0,0,6,8,6,11.333333333333334,0,15.5,2.8,-4.06,2 +Student_03148,1,1,9500,1,5,1,1,1,1,3,4,101.0,102.4,0,0,0,1,0,0,0,20,0,7,9,5,12.04,0,0,7,9,6,11.77142857142857,0,12.4,0.5,1.79,1 +Student_03149,1,17,9147,1,3,1,1,38,19,7,7,125.0,125.7,0,0,0,1,0,0,0,20,0,5,7,5,11.166666666666666,0,0,5,9,4,10.75,0,15.5,2.8,-4.06,1 +Student_03150,4,39,9670,1,1,1,1,37,37,4,10,100.0,120.0,0,0,1,1,0,1,0,39,0,5,6,5,10.6,0,0,5,7,4,10.75,0,9.4,-0.8,-3.12,2 +Student_03151,1,1,9130,1,1,1,1,1,1,9,9,117.0,109.3,1,0,0,1,0,0,0,20,0,5,10,4,12.5,0,0,5,12,2,13.0,0,12.7,3.7,-1.7,1 +Student_03152,1,1,171,1,1,1,1,3,1,4,4,159.0,162.2,1,0,1,0,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,0 +Student_03153,1,17,NA,1,1,1,1,2,1,123,135,177.0,155.7,0,0,1,1,0,1,0,18,0,6,6,6,15.666666666666666,0,0,6,6,6,13.833333333333334,0,8.9,1.4,3.51,2 +Student_03154,1,1,171,1,1,1,1,3,3,2,2,156.0,147.7,1,0,0,1,0,0,0,21,6,12,12,12,15.333333333333334,0,4,11,15,11,15.0,0,8.9,1.4,3.51,2 +Student_03155,1,1,9500,1,5,1,1,1,1,3,8,125.0,115.6,1,0,0,1,0,0,0,18,0,7,9,6,12.183333333333332,0,0,7,9,6,11.783333333333331,0,16.2,0.3,-0.92,1 +Student_03156,1,1,9147,1,2,1,1,37,37,9,9,130.0,117.8,0,0,0,1,NA,0,0,18,0,5,8,2,10.0,0,0,5,9,3,11.333333333333334,0,7.6,2.6,0.32,1 +Student_03158,1,1,9147,1,1,1,1,19,19,5,5,127.0,129.8,1,0,0,1,0,0,0,22,0,5,8,3,10.333333333333334,0,0,5,11,2,10.0,0,7.6,2.6,0.32,0 +Student_03159,1,17,9254,1,1,1,1,1,1,4,4,121.0,123.1,1,0,0,1,1,0,0,21,0,6,11,6,11.166666666666666,0,0,6,14,3,14.666666666666666,0,7.6,2.6,0.32,1 +Student_03161,1,1,171,1,2,1,1,38,19,9,9,125.0,117.3,1,0,0,1,1,1,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,2 +Student_03162,1,1,9254,1,1,1,41,1,1,9,9,138.0,126.5,1,0,0,1,0,1,1,20,0,6,7,6,12.857142857142858,0,0,6,8,5,11.8,0,8.9,1.4,3.51,2 +Student_03164,1,1,9238,1,1,1,1,1,38,5,7,142.0,127.7,0,0,0,1,0,1,0,20,0,6,7,6,15.0,0,0,6,6,6,16.333333333333332,0,13.9,-0.3,0.79,2 +Student_03165,1,1,9085,1,1,1,1,19,37,9,9,129.0,117.5,1,0,0,1,0,0,0,19,0,5,9,5,13.6,1,0,5,5,5,12.4,0,12.7,3.7,-1.7,2 +Student_03166,1,1,9085,1,1,1,1,1,1,2,7,134.0,128.4,1,0,0,1,0,1,0,18,0,5,12,5,12.857142857142858,2,0,5,8,4,13.25,0,9.4,-0.8,-3.12,2 +Student_03169,1,1,9254,1,1,1,1,1,1,4,2,129.0,126.2,0,0,1,0,0,1,0,21,0,6,7,6,13.428571428571429,0,0,6,8,6,11.333333333333334,0,8.9,1.4,3.51,0 +Student_03170,1,1,9500,1,3,1,1,1,37,8,7,134.0,120.5,1,0,0,1,1,1,0,18,0,7,12,7,11.716666666666663,0,0,8,13,4,10.868,0,15.5,2.8,-4.06,2 +Student_03171,1,17,9147,1,1,1,1,1,37,4,8,127.0,121.1,1,0,0,1,1,1,0,20,0,5,11,4,12.0,0,0,5,5,5,12.8,0,11.1,0.6,2.02,2 +Student_03172,1,18,9853,1,2,1,1,1,3,9,2,123.0,123.7,1,0,1,0,0,0,0,20,0,6,11,5,13.2,0,0,6,8,4,10.75,0,10.8,1.4,1.74,0 +Student_03173,1,17,9254,1,3,1,1,12,38,5,7,127.0,116.9,1,0,1,1,0,0,0,18,0,6,7,5,12.2,0,0,6,10,4,12.25,0,12.4,0.5,1.79,0 +Student_03174,1,39,9556,1,1,1,1,38,19,9,6,133.1,100.0,1,0,0,1,0,1,0,25,0,7,11,5,12.58,0,0,7,9,6,12.157142857142857,0,8.9,1.4,3.51,2 +Student_03177,1,1,9500,1,4,1,1,19,19,9,5,133.0,120.1,1,0,0,1,0,1,0,19,0,7,9,6,12.428571428571429,0,0,8,8,8,14.0,0,13.9,-0.3,0.79,2 +Student_03178,1,1,9670,1,1,1,1,38,38,9,9,133.0,128.1,1,0,0,1,1,1,0,18,0,6,6,6,13.0,0,0,6,6,6,13.0,0,13.9,-0.3,0.79,0 +Student_03180,1,43,9500,1,1,1,1,19,38,9,7,140.0,125.7,1,0,0,1,1,1,0,19,0,7,8,5,11.2,0,0,7,8,5,11.2,0,7.6,2.6,0.32,1 +Student_03181,1,17,9070,1,1,1,1,3,3,3,3,157.0,146.2,0,0,0,1,1,0,0,18,0,6,6,6,16.0,0,0,6,6,6,13.666666666666666,0,12.4,0.5,1.79,2 +Student_03182,1,39,9130,1,1,19,1,19,3,9,2,133.1,140.0,1,0,1,1,1,0,0,24,0,6,13,5,13.142857142857142,0,0,6,15,3,12.666666666666666,0,16.2,0.3,-0.92,0 +Student_03183,1,43,8014,0,1,1,6,34,34,0,0,145.0,134.5,1,0,0,1,1,0,1,25,8,14,23,11,11.6875,0,6,10,20,8,11.142857142857142,0,9.4,-0.8,-3.12,2 +Student_03184,1,39,9119,1,1,1,1,37,3,9,3,130.0,137.0,1,0,0,1,1,0,0,28,0,5,11,4,10.5,0,0,5,12,4,11.0,4,7.6,2.6,0.32,1 +Student_03185,1,1,9085,1,1,1,1,1,38,5,9,111.0,107.5,0,0,0,1,1,1,0,19,0,6,9,6,13.833333333333334,0,0,6,12,5,13.666666666666666,0,11.1,0.6,2.02,2 +Student_03187,1,39,9130,1,1,10,1,12,36,90,90,133.1,128.2,0,0,0,0,1,1,0,30,0,5,13,0,0.0,3,0,5,5,0,0.0,5,9.4,-0.8,-3.12,0 +Student_03188,1,1,9500,1,1,1,1,19,19,4,5,135.0,126.8,1,0,0,1,1,0,0,19,0,7,9,0,0.0,0,0,7,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_03189,1,17,9147,1,1,1,1,19,38,4,4,145.0,132.1,1,0,0,1,1,0,0,21,0,5,10,1,10.0,0,0,5,5,0,0.0,0,11.1,0.6,2.02,0 +Student_03190,1,1,171,1,1,1,1,37,37,3,5,118.0,110.0,0,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_03191,1,39,9003,1,1,1,1,19,19,9,5,130.0,100.0,0,0,0,0,1,0,0,NA,0,6,9,0,0.0,0,0,6,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_03192,1,1,9670,1,1,1,1,19,37,9,9,115.0,114.3,0,0,0,1,1,0,0,18,0,6,7,4,12.6,0,0,6,6,4,13.0,0,12.4,0.5,1.79,0 +Student_03193,1,1,9147,1,2,1,1,1,38,4,5,122.0,116.4,0,0,0,1,1,0,0,21,0,5,10,3,11.25,0,0,5,9,3,11.0,0,15.5,2.8,-4.06,1 +Student_03194,1,42,9070,1,1,1,1,3,2,3,1,120.0,116.9,0,0,0,1,1,0,0,20,6,7,13,7,12.375,0,4,7,8,4,11.25,0,13.9,-0.3,0.79,0 +Student_03195,1,51,9991,0,1,1,1,38,3,5,3,120.0,128.2,0,0,1,1,1,0,0,NA,3,10,15,7,10.714285714285714,0,3,10,11,9,12.555555555555555,0,12.4,0.5,1.79,1 +Student_03196,1,17,9773,1,2,1,1,1,1,2,5,120.0,127.0,1,0,0,0,1,0,0,18,0,6,6,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_03197,1,42,9003,1,1,1,1,1,3,4,2,140.0,140.0,1,0,0,1,1,0,0,23,0,6,14,5,12.0,0,0,6,12,5,12.142857142857142,0,15.5,2.8,-4.06,1 +Student_03199,1,7,9254,1,1,3,1,NA,19,3,3,110.0,110.0,0,0,0,1,1,0,0,35,0,6,7,0,0.0,0,0,6,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_03200,1,1,9500,1,1,1,1,1,1,9,9,148.0,127.0,1,0,0,1,1,0,0,20,0,8,8,7,12.84142857142857,0,0,8,8,7,12.84142857142857,0,10.8,1.4,1.74,2 +Student_03201,2,39,9238,1,1,42,1,19,38,8,8,170.0,159.5,0,0,0,1,1,0,0,33,0,6,6,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_03202,1,1,9773,1,1,1,1,1,3,4,1,146.0,135.2,1,0,0,1,1,0,0,18,0,6,7,6,14.166666666666666,0,0,6,6,6,12.833333333333334,0,9.4,-0.8,-3.12,2 +Student_03204,1,17,9773,1,1,1,1,3,3,2,3,125.0,118.0,1,0,0,1,1,0,0,19,0,6,12,4,10.8,0,0,6,14,3,11.0,0,13.9,-0.3,0.79,0 +Student_03207,1,1,9147,1,1,1,1,5,1,1,5,146.0,144.6,0,0,0,1,1,0,0,18,0,5,5,5,13.0,0,0,5,6,5,13.333333333333334,0,16.2,0.3,-0.92,2 +Student_03208,1,1,9773,1,1,1,1,2,3,3,3,109.0,111.8,1,0,1,1,1,0,0,25,0,6,8,6,11.571428571428571,0,0,6,9,6,11.571428571428571,0,15.5,2.8,-4.06,0 +Student_03211,1,7,9003,1,1,3,1,3,3,6,2,130.0,130.0,1,0,0,1,1,0,0,29,1,6,10,6,17.11111111111111,0,2,6,9,6,15.571428571428571,0,13.9,-0.3,0.79,2 +Student_03212,1,1,171,1,1,1,1,2,2,3,2,124.0,118.4,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,1 +Student_03213,1,1,9254,1,1,1,1,3,2,4,5,115.0,112.6,0,0,0,1,1,1,0,20,0,6,9,6,12.571428571428571,0,0,6,6,6,12.166666666666666,0,8.9,1.4,3.51,2 +Student_03215,1,1,9070,1,4,1,1,3,3,2,2,170.0,165.8,1,0,0,1,1,0,0,18,0,6,7,6,14.5,0,0,6,6,6,15.166666666666666,0,9.4,-0.8,-3.12,2 +Student_03216,1,1,9254,1,6,1,1,3,1,2,2,102.0,101.7,1,0,0,1,1,1,0,21,0,6,6,6,13.5,0,0,6,6,6,12.333333333333334,0,12.4,0.5,1.79,2 +Student_03217,1,17,9254,1,2,1,1,3,3,2,2,140.0,124.3,0,0,0,0,1,0,0,18,0,6,9,5,11.2,0,0,6,14,2,10.0,0,9.4,-0.8,-3.12,0 +Student_03219,1,43,8014,0,1,1,1,37,37,9,9,148.0,134.7,0,0,0,1,0,0,0,23,9,13,15,9,11.0,0,4,11,12,7,11.571428571428571,0,15.5,2.8,-4.06,1 +Student_03221,1,17,9670,1,3,1,1,37,37,8,8,147.0,128.8,0,0,1,1,0,0,0,19,0,5,5,1,10.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03223,1,1,9670,1,1,1,1,19,38,9,7,157.0,146.2,1,0,0,1,0,1,0,20,0,6,8,6,15.25,0,0,6,7,6,14.714285714285714,0,11.1,0.6,2.02,2 +Student_03224,1,17,9991,0,1,1,1,38,3,9,3,120.0,116.9,1,0,1,0,0,0,0,26,0,5,5,0,0.0,0,0,5,6,0,0.0,0,10.8,1.4,1.74,0 +Student_03225,1,39,9147,1,1,12,1,19,37,7,9,133.1,118.2,0,0,0,1,0,0,0,31,0,5,8,1,13.0,2,0,5,9,4,12.25,0,10.8,1.4,1.74,0 +Student_03226,2,43,9500,1,1,1,1,37,37,9,10,140.0,105.7,1,0,0,1,0,0,0,27,0,8,8,8,13.81375,0,0,8,8,8,13.81375,0,9.4,-0.8,-3.12,2 +Student_03227,1,1,9085,1,1,1,1,19,38,9,9,130.0,126.9,0,0,1,1,0,0,0,24,0,6,8,6,13.285714285714286,0,0,6,13,6,12.875,0,11.1,0.6,2.02,2 +Student_03228,1,44,9085,1,1,39,1,19,38,194,193,150.0,150.0,1,0,0,1,0,0,0,23,0,6,11,4,NA,0,0,6,12,4,12.2,0,8.9,1.4,3.51,1 +Student_03230,1,1,9500,1,6,1,1,38,38,5,5,118.0,114.2,1,0,0,1,0,0,0,20,0,7,9,6,13.683333333333332,0,0,8,11,6,13.116666666666667,0,11.1,0.6,2.02,2 +Student_03231,1,39,9500,1,1,1,1,38,1,9,4,130.0,140.0,1,0,0,1,0,0,0,24,0,8,8,7,14.985714285714286,0,0,8,8,7,14.985714285714286,0,12.7,3.7,-1.7,2 +Student_03232,2,39,9147,1,1,1,1,37,37,9,9,130.0,142.5,0,0,0,1,0,0,0,39,0,5,8,4,11.25,0,0,5,8,4,11.5,0,11.1,0.6,2.02,1 +Student_03235,1,1,9500,1,2,1,1,1,1,4,3,130.0,125.1,1,0,0,1,0,0,0,18,0,7,10,7,13.78,0,0,8,10,8,13.661,0,15.5,2.8,-4.06,2 +Student_03237,1,17,9085,1,1,1,1,1,19,4,9,138.0,142.2,1,0,0,1,0,0,0,18,0,5,7,5,13.8,0,0,5,5,5,12.6,0,10.8,1.4,1.74,2 +Student_03238,1,1,9670,1,1,1,1,37,19,9,9,113.0,110.2,1,0,0,1,0,0,0,22,0,5,7,3,12.666666666666666,0,0,5,6,4,12.0,0,7.6,2.6,0.32,1 +Student_03239,1,17,9500,1,4,1,1,1,1,4,4,135.0,127.0,1,0,0,1,0,0,0,18,0,7,7,7,14.424285714285714,0,0,8,8,8,13.9375,0,11.1,0.6,2.02,2 +Student_03240,1,1,9238,1,1,1,1,3,1,4,9,137.0,128.6,0,0,0,1,0,1,0,18,0,6,7,6,13.166666666666666,0,0,6,6,6,12.5,0,12.4,0.5,1.79,2 +Student_03241,4,39,9991,0,1,1,1,37,37,9,9,133.1,130.4,0,0,0,1,0,0,0,30,0,5,10,3,10.666666666666666,0,0,5,8,5,10.4,0,12.7,3.7,-1.7,1 +Student_03242,2,NA,9238,1,1,12,1,37,37,9,9,100.0,134.4,0,0,0,1,0,0,0,34,9,16,20,14,12.071428571428571,1,11,13,13,11,12.272727272727272,0,7.6,2.6,0.32,2 +Student_03243,1,39,8014,0,1,19,1,37,37,9,NA,133.1,100.0,0,0,0,1,0,0,0,38,0,6,10,3,10.25,0,0,6,7,1,12.0,0,13.9,-0.3,0.79,0 +Student_03245,1,17,9853,1,3,1,1,38,38,5,7,140.0,126.7,1,0,0,1,0,0,0,19,0,6,9,5,12.4,0,0,6,10,3,10.666666666666666,0,10.8,1.4,1.74,0 +Student_03246,1,43,9773,1,1,1,1,1,1,4,8,129.0,129.0,0,0,0,0,0,0,0,21,0,6,7,6,12.0,0,0,6,6,6,12.0,0,10.8,1.4,1.74,0 +Student_03247,1,17,9773,1,1,1,1,2,3,2,2,141.0,133.7,1,0,0,1,0,1,0,18,0,6,6,6,14.833333333333334,0,0,6,6,6,13.5,0,11.1,0.6,2.02,2 +Student_03248,1,17,9085,1,5,1,1,1,38,4,7,118.0,122.2,1,0,0,1,0,1,0,20,0,6,7,6,15.428571428571429,0,0,6,7,6,13.5,0,13.9,-0.3,0.79,2 +Student_03249,1,17,9147,1,5,1,1,37,38,5,5,131.0,128.9,0,0,0,1,0,1,0,18,0,5,7,5,11.6,0,0,5,11,5,11.4,4,16.2,0.3,-0.92,2 +Student_03250,1,1,9070,1,3,1,1,38,37,5,5,161.0,154.4,1,0,0,1,0,0,0,18,0,6,6,6,14.166666666666666,0,0,6,6,6,NA,0,16.2,0.3,-0.92,2 +Student_03251,1,7,9556,1,1,2,1,37,37,9,9,130.0,130.0,1,0,0,1,0,1,0,36,0,7,9,1,9.8,0,0,7,7,0,0.0,0,12.7,3.7,-1.7,0 +Student_03253,1,43,9130,1,1,6,1,1,29,4,90,133.1,123.3,1,0,0,1,0,1,0,21,0,5,7,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_03255,1,15,9085,1,1,1,41,3,3,4,2,133.1,101.3,0,0,0,1,0,0,1,18,0,6,13,6,13.0,0,0,6,15,6,12.25,0,11.1,0.6,2.02,2 +Student_03258,2,39,9003,1,1,19,1,37,19,9,4,133.1,140.0,0,0,1,1,0,0,0,29,0,6,11,5,12.6,0,0,6,6,6,12.666666666666666,0,11.1,0.6,2.02,2 +Student_03259,1,44,9147,1,1,39,1,19,1,9,3,130.0,130.0,0,0,0,1,0,1,0,20,4,7,8,7,13.0,0,2,5,5,5,13.4,0,11.1,0.6,2.02,2 +Student_03260,1,17,9500,1,2,1,1,37,37,9,9,140.0,132.5,1,0,0,1,0,0,0,18,0,7,7,6,14.316666666666668,0,0,7,7,6,14.316666666666668,0,7.6,2.6,0.32,2 +Student_03261,1,1,9085,1,1,1,1,2,1,4,10,124.0,117.4,1,0,0,1,0,0,0,19,0,5,7,4,12.75,0,0,5,5,5,12.0,0,10.8,1.4,1.74,2 +Student_03262,1,1,9147,1,3,1,1,1,38,3,8,115.0,109.8,1,0,0,1,0,1,0,19,0,5,5,5,13.4,0,0,5,5,5,12.6,0,8.9,1.4,3.51,2 +Student_03265,1,1,9853,1,1,1,1,19,19,7,7,121.0,113.0,1,0,0,1,NA,0,0,21,0,6,9,5,12.4,0,0,6,11,1,11.0,0,12.7,3.7,-1.7,0 +Student_03266,1,17,9238,1,1,1,1,1,38,144,181,125.0,123.3,0,0,0,1,0,1,0,19,0,6,8,6,11.5,0,0,6,7,6,12.333333333333334,0,12.4,0.5,1.79,2 +Student_03267,1,17,9670,1,2,1,1,3,1,3,1,123.0,116.7,0,0,0,1,0,0,0,19,0,5,5,5,13.4,0,0,5,5,5,14.0,0,9.4,-0.8,-3.12,2 +Student_03268,2,39,9991,0,1,39,1,38,19,9,5,140.0,110.0,0,0,0,1,0,1,0,35,0,5,9,3,11.666666666666666,0,0,5,7,5,11.8,0,12.7,3.7,-1.7,1 +Student_03269,2,39,9500,1,1,NA,1,37,38,9,8,133.1,118.9,0,0,0,1,0,0,0,30,0,7,0,0,0.0,0,0,8,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_03270,1,43,9773,1,2,1,1,34,34,0,0,120.0,103.6,1,0,0,1,0,0,0,27,4,8,11,7,13.285714285714286,0,4,7,13,5,11.6,0,9.4,-0.8,-3.12,0 +Student_03271,2,1,9254,1,1,1,1,37,37,9,9,136.0,122.7,0,0,0,1,0,1,0,45,0,6,10,4,11.5,0,0,6,16,2,10.5,0,7.6,2.6,0.32,0 +Student_03274,1,43,9500,1,1,1,1,37,37,9,6,120.0,NA,1,0,0,1,0,0,0,26,0,7,8,6,12.0,0,0,7,8,6,12.0,0,7.6,2.6,0.32,1 +Student_03275,1,39,9003,1,1,19,1,37,37,9,9,133.1,130.0,0,0,0,1,NA,0,0,44,0,6,10,1,12.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_03276,5,7,9147,1,1,40,1,37,37,9,9,110.0,110.0,0,0,0,1,0,0,0,23,10,15,15,13,10.923076923076923,0,5,10,10,7,11.142857142857142,0,15.5,2.8,-4.06,2 +Student_03278,1,1,9147,1,1,1,1,38,38,9,9,102.0,99.6,1,0,0,1,0,1,0,21,0,5,10,5,13.714285714285714,0,0,5,7,5,14.4,0,11.1,0.6,2.02,2 +Student_03279,1,43,9147,1,3,1,21,3,37,3,3,127.0,117.9,1,0,0,1,0,0,1,22,0,5,8,1,10.0,0,0,5,8,2,13.0,0,7.6,2.6,0.32,0 +Student_03280,4,39,8014,0,1,1,1,37,37,9,8,133.1,113.0,0,0,0,1,0,1,0,32,0,6,18,2,10.333333333333334,0,0,6,7,6,11.5,0,16.2,0.3,-0.92,2 +Student_03281,1,17,9556,1,2,1,41,1,1,7,7,137.0,124.4,1,0,0,1,0,0,1,20,0,7,8,7,12.728571428571428,0,0,8,8,8,14.625,0,15.5,2.8,-4.06,2 +Student_03282,2,7,8014,0,1,3,1,35,35,90,90,130.0,140.0,0,0,0,0,0,0,0,59,10,15,22,12,13.333333333333334,0,8,8,8,8,12.875,0,10.8,1.4,1.74,0 +Student_03283,2,53,9147,1,1,42,1,19,19,175,152,130.0,132.4,0,0,0,1,0,0,0,30,6,11,20,9,12.22222222222222,0,3,9,16,9,11.6,0,8.9,1.4,NA,1 +Student_03284,1,1,9254,1,4,1,1,38,36,9,9,131.0,124.0,1,0,0,1,0,1,0,18,0,6,7,6,11.333333333333334,0,0,6,9,6,10.833333333333334,0,9.4,-0.8,-3.12,2 +Student_03286,4,43,9991,0,1,1,1,NA,37,5,5,140.0,149.8,0,0,0,1,1,0,0,36,0,5,5,5,13.8,0,0,5,6,5,13.8,0,12.7,3.7,-1.7,2 +Student_03288,1,17,9670,1,6,1,1,38,19,0,1,117.0,114.6,0,0,0,0,1,0,0,19,0,6,9,4,11.25,0,0,6,11,3,10.166666666666666,0,10.8,1.4,1.74,0 +Student_03291,1,1,9238,1,1,1,1,1,1,5,5,125.0,128.5,0,0,0,1,1,0,0,20,0,6,13,1,14.0,0,0,6,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_03292,1,39,9003,1,1,1,1,37,37,9,7,130.0,113.0,1,0,0,0,1,0,0,35,0,6,17,1,13.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_03293,1,1,9238,1,1,1,1,37,37,0,0,170.0,150.8,1,0,0,1,0,0,0,27,0,6,13,2,11.0,0,0,6,14,1,11.0,0,7.6,2.6,0.32,0 +Student_03294,1,17,9500,1,3,1,1,19,3,9,5,132.0,130.8,1,0,0,1,0,0,0,18,0,8,8,7,13.68142857142857,0,0,8,8,7,13.68142857142857,0,10.8,1.4,1.74,1 +Student_03295,1,43,9500,1,1,1,1,38,19,9,10,133.1,114.5,0,0,0,1,0,0,0,23,0,7,11,6,12.1,0,0,7,7,6,12.616666666666667,0,16.2,0.3,-0.92,1 +Student_03296,1,17,8014,0,2,1,1,19,1,5,10,120.0,114.8,1,0,0,1,0,0,0,19,0,6,8,4,10.5,0,0,6,8,4,11.25,0,10.8,1.4,1.74,2 +Student_03297,1,17,9500,1,2,1,1,37,37,7,7,NA,126.2,1,0,0,1,0,1,0,18,0,7,10,5,11.94,0,0,7,8,6,12.8,0,11.1,0.6,2.02,1 +Student_03298,1,39,9500,1,1,1,1,19,19,3,7,130.0,129.0,0,0,1,0,0,0,0,26,0,7,11,4,12.86,0,0,7,10,5,11.566666666666668,0,12.4,0.5,1.79,0 +Student_03299,1,17,9238,1,1,1,NA,1,38,9,7,133.1,110.5,0,0,0,1,0,0,0,19,0,6,10,6,14.25,0,0,6,7,6,14.0,0,16.2,0.3,-0.92,2 +Student_03302,1,17,9500,1,1,1,1,19,1,9,7,130.0,130.4,1,0,0,1,0,1,0,19,0,7,7,7,13.894285714285711,0,0,8,8,8,14.3625,0,11.1,0.6,2.02,2 +Student_03303,1,17,9500,1,1,1,1,37,37,9,8,128.0,124.3,1,0,0,1,0,1,0,19,0,7,8,7,13.46875,0,0,8,8,8,13.31375,0,15.5,2.8,-4.06,2 +Student_03304,1,1,9085,1,4,1,1,38,37,9,9,135.0,132.6,1,0,0,1,0,1,0,19,0,5,5,5,13.6,0,0,5,5,5,14.6,0,10.8,1.4,1.74,2 +Student_03305,1,44,8014,0,1,39,1,1,37,9,7,150.0,146.7,0,0,0,1,0,1,0,21,3,6,6,6,14.666666666666666,0,2,6,6,6,13.833333333333334,0,12.4,0.5,1.79,2 +Student_03306,1,1,9773,1,3,1,1,1,1,3,5,135.0,130.1,1,0,0,1,0,0,0,18,0,6,6,6,13.666666666666666,0,0,6,7,6,13.0,0,15.5,2.8,-4.06,2 +Student_03307,2,43,9254,1,1,3,1,38,37,9,3,120.0,120.0,1,0,0,1,0,0,0,33,9,12,22,10,13.3,0,9,11,11,11,13.727272727272728,0,9.4,-0.8,-3.12,2 +Student_03309,1,1,9500,1,6,1,1,19,19,1,4,140.0,133.3,1,0,0,1,0,1,0,17,0,8,8,8,13.41625,0,0,8,8,8,13.41625,0,9.4,-0.8,-3.12,2 +Student_03310,2,39,9500,1,1,1,1,19,19,9,7,140.0,110.5,0,0,0,1,0,0,0,31,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03311,2,39,8014,0,1,1,1,19,19,9,7,140.0,102.5,0,0,0,1,0,1,0,32,0,6,6,6,11.333333333333334,0,0,6,8,5,13.0,0,15.5,2.8,-4.06,2 +Student_03312,1,1,9085,1,2,1,1,40,40,3,7,156.0,150.9,1,0,0,1,0,0,0,18,0,6,8,6,16.0,0,0,6,10,6,14.625,0,11.1,0.6,2.02,0 +Student_03314,1,1,9254,1,1,1,1,1,1,9,10,120.0,118.3,0,0,0,1,1,0,0,20,0,6,8,6,12.857142857142858,0,0,6,9,5,12.4,0,8.9,1.4,3.51,1 +Student_03315,1,43,9991,0,1,1,1,3,19,1,1,100.0,117.9,0,0,0,0,1,0,0,40,0,5,5,0,0.0,0,0,5,6,0,0.0,0,10.8,1.4,1.74,0 +Student_03316,2,1,9991,0,1,1,1,37,19,9,9,120.0,135.0,1,0,0,1,1,0,0,32,0,5,5,5,14.8,0,0,5,5,5,14.2,0,7.6,2.6,0.32,2 +Student_03317,1,7,9119,1,1,3,1,19,19,1,1,120.0,120.0,0,0,0,0,1,0,0,40,1,5,7,1,13.0,0,2,5,5,2,14.0,0,12.7,3.7,-1.7,0 +Student_03318,1,1,171,1,1,1,1,1,1,4,9,172.0,167.1,0,0,0,1,1,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,2 +Student_03319,1,43,9991,0,1,1,1,37,37,9,9,120.0,115.8,0,0,1,0,1,0,0,28,4,9,14,4,10.0,0,1,6,6,1,10.0,0,12.7,3.7,-1.7,0 +Student_03320,1,16,9070,1,2,1,1,1,1,3,1,137.0,141.2,1,0,1,1,1,0,0,19,0,6,11,5,11.2,0,0,6,7,6,12.0,0,9.4,-0.8,-3.12,2 +Student_03322,1,1,9147,1,6,1,1,38,37,7,7,142.0,134.3,0,1,0,1,1,0,0,21,0,5,0,0,0.0,0,0,5,0,0,0.0,0,10.8,1.4,1.74,0 +Student_03325,1,39,171,1,1,1,1,12,3,5,2,110.0,100.0,1,0,0,1,1,0,0,27,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03328,1,39,9130,1,1,39,1,1,3,4,1,150.0,150.0,0,0,0,1,1,0,0,28,0,6,9,0,0.0,0,0,6,8,1,10.0,1,16.2,0.3,-0.92,0 +Student_03329,5,39,9119,1,1,1,1,37,37,9,9,120.0,116.0,0,0,1,1,1,1,0,34,0,5,14,1,17.0,0,0,5,10,2,11.0,0,9.4,-0.8,-3.12,1 +Student_03330,1,17,9147,1,1,1,1,NA,1,4,4,110.0,99.0,0,0,0,NA,1,0,0,21,0,5,5,5,11.0,0,0,5,11,3,11.428571428571429,0,NA,1.4,1.74,1 +Student_03331,1,1,9238,1,1,1,1,1,19,9,9,133.0,132.0,0,0,0,1,1,1,0,20,0,6,11,5,11.142857142857142,0,0,6,9,6,11.571428571428571,0,16.2,0.3,-0.92,2 +Student_03334,1,39,9670,1,2,19,1,34,34,0,0,133.1,100.0,1,0,0,0,1,0,0,27,0,5,8,1,11.0,0,0,5,6,3,10.666666666666666,1,7.6,2.6,0.32,0 +Student_03335,1,1,9773,1,6,1,NA,38,38,9,9,136.0,132.9,1,0,0,1,1,0,0,19,0,6,10,4,13.25,0,0,6,13,5,11.8,0,7.6,2.6,0.32,2 +Student_03336,1,17,9773,1,4,1,1,3,1,2,7,129.0,132.5,1,0,0,1,1,0,0,21,0,6,7,0,0.0,0,0,6,11,1,10.0,0,10.8,1.4,1.74,1 +Student_03337,1,44,9003,1,1,39,1,19,19,4,4,140.0,140.0,1,0,0,0,1,0,0,21,0,6,17,2,12.5,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_03338,1,43,9670,1,1,1,1,34,34,99,99,160.0,100.1,0,0,0,0,1,0,0,35,6,10,10,7,12.142857142857142,0,4,9,9,4,12.25,0,7.6,2.6,0.32,0 +Student_03339,1,39,9085,1,1,1,1,37,36,90,7,133.1,128.2,0,0,0,1,1,0,0,28,0,5,8,3,12.0,0,0,5,10,3,11.333333333333334,0,7.6,2.6,0.32,0 +Student_03340,1,17,9670,1,1,1,1,1,1,4,3,140.0,133.4,0,0,0,1,1,0,0,NA,0,6,6,4,11.25,0,0,6,9,4,10.428571428571429,0,10.8,1.4,1.74,1 +Student_03341,1,1,9773,1,3,1,1,34,1,5,10,142.0,136.1,1,0,0,0,1,0,0,19,0,4,8,0,0.0,1,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03343,1,1,9070,1,1,1,1,3,19,4,4,131.0,130.3,1,0,0,1,1,1,0,20,0,6,6,6,12.833333333333334,0,0,6,8,6,12.666666666666666,2,16.2,0.3,-0.92,2 +Student_03345,1,39,9085,1,1,1,1,40,1,5,6,110.0,142.5,0,0,1,0,1,0,0,37,5,7,7,5,12.0,0,3,7,7,3,11.666666666666666,0,8.9,1.4,3.51,0 +Student_03347,1,39,9500,1,1,1,1,37,37,9,8,120.0,108.5,0,0,0,1,1,0,0,36,0,7,18,0,0.0,0,0,7,7,0,0.0,0,13.9,-0.3,0.79,0 +Student_03348,1,39,9147,1,1,12,1,37,37,9,9,133.1,140.0,0,0,0,1,1,0,0,29,0,5,0,0,0.0,0,0,5,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03350,1,51,9670,1,1,19,1,2,1,3,10,133.1,120.0,0,0,1,1,1,0,0,32,1,6,15,2,12.0,0,0,6,7,0,0.0,0,11.1,0.6,2.02,0 +Student_03351,1,1,8014,0,1,1,1,3,1,2,9,123.0,127.6,1,0,0,1,1,0,0,26,0,6,6,6,11.833333333333334,0,0,6,6,6,11.666666666666666,0,10.8,1.4,1.74,1 +Student_03352,2,44,9003,1,1,39,1,37,37,4,7,140.0,140.0,0,0,0,1,1,0,0,37,0,6,17,1,12.0,0,0,6,23,2,10.5,1,16.2,0.3,-0.92,0 +Student_03354,1,1,9773,1,1,1,1,38,1,5,7,131.0,131.0,1,0,0,1,1,1,0,18,0,6,7,6,12.714285714285714,0,0,6,8,5,11.833333333333334,0,13.9,-0.3,0.79,2 +Student_03355,1,1,9500,1,1,1,1,38,37,9,9,149.0,139.5,0,0,0,1,1,1,0,18,0,8,8,8,15.3,0,0,8,8,8,15.3,0,9.4,-0.8,-3.12,2 +Student_03356,2,39,9003,1,2,19,1,38,19,4,1,133.1,110.0,0,0,0,0,1,0,0,32,2,8,12,2,11.5,2,0,7,9,0,0.0,0,15.5,2.8,-4.06,0 +Student_03357,1,44,9119,1,1,39,1,3,19,3,4,130.0,130.0,0,0,0,1,1,0,0,20,0,5,12,1,13.0,0,0,5,8,3,12.6,0,12.4,0.5,1.79,1 +Student_03358,1,43,9003,1,1,1,1,3,3,1,2,120.0,115.0,0,0,0,1,1,0,0,22,0,6,12,0,0.0,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_03359,4,39,9500,1,1,1,1,1,19,3,3,133.1,154.3,0,0,0,1,0,0,0,32,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.4,0.5,1.79,0 +Student_03360,1,1,9147,1,1,1,1,1,37,9,9,143.0,135.0,1,0,0,1,0,0,0,21,0,5,8,4,11.0,0,0,5,8,5,12.0,0,7.6,2.6,0.32,1 +Student_03363,1,1,9147,1,4,1,1,1,1,9,7,123.0,117.4,1,0,0,1,0,1,0,18,0,5,7,5,12.0,0,0,5,10,5,11.4,0,8.9,1.4,3.51,2 +Student_03364,1,7,9147,1,1,2,1,3,37,2,5,150.0,150.0,1,0,1,0,0,0,0,38,0,5,6,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_03365,1,17,9853,1,3,1,1,34,34,0,0,132.0,131.3,1,0,0,1,0,0,0,21,0,6,8,5,11.8,0,0,6,8,4,10.5,0,7.6,2.6,0.32,0 +Student_03366,1,1,9238,1,1,1,1,34,37,5,5,133.0,120.4,0,0,0,0,0,0,0,21,0,6,12,2,11.5,0,0,6,13,1,13.0,0,9.4,-0.8,-3.12,0 +Student_03367,1,1,9991,0,1,1,1,37,37,9,3,122.0,113.6,0,0,0,1,1,0,0,26,0,5,11,2,11.5,0,0,5,10,3,12.0,0,7.6,2.6,0.32,1 +Student_03368,1,1,9500,1,4,1,NA,19,38,9,3,137.0,125.0,1,0,0,1,0,0,0,19,0,7,7,6,14.616666666666667,0,0,7,7,6,14.616666666666667,0,7.6,2.6,0.32,2 +Student_03369,1,1,9500,1,6,1,1,19,37,9,9,145.0,132.3,1,0,0,1,0,1,0,19,0,8,8,7,14.06,0,0,8,8,7,14.06,0,10.8,1.4,1.74,1 +Student_03370,1,17,9254,1,1,1,1,1,1,9,10,150.0,142.7,0,0,1,1,0,0,0,18,0,6,9,4,11.0,0,0,6,12,3,11.333333333333334,0,7.6,2.6,0.32,0 +Student_03371,1,7,9147,1,1,3,1,37,37,9,9,130.0,130.0,0,0,0,1,0,0,0,25,0,5,0,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03372,1,1,9500,1,6,1,1,37,1,5,4,136.0,120.8,1,0,0,1,0,0,0,19,6,14,22,7,12.192307692307692,5,6,14,22,7,12.192307692307692,5,7.6,2.6,0.32,2 +Student_03373,1,17,9254,1,2,1,1,1,19,9,9,131.0,130.3,1,0,0,NA,0,1,0,18,0,6,6,6,12.833333333333334,0,0,6,7,6,12.333333333333334,0,13.9,-0.3,0.79,2 +Student_03374,1,17,9147,1,1,1,1,37,37,9,7,130.0,119.9,0,0,0,1,0,1,0,19,0,5,8,5,12.875,0,0,5,6,5,11.833333333333334,0,13.9,-0.3,0.79,2 +Student_03375,1,1,9238,1,1,1,1,19,38,9,7,108.0,110.5,1,0,0,1,0,1,0,22,0,6,6,6,12.166666666666666,0,0,6,6,6,12.5,0,12.4,0.5,1.79,2 +Student_03377,1,17,9085,1,1,1,1,19,37,9,9,113.0,118.6,1,0,0,1,0,1,0,21,0,6,6,6,14.5,0,0,6,8,6,14.666666666666666,0,8.9,1.4,3.51,2 +Student_03380,1,1,9500,1,4,1,1,19,19,9,3,148.0,125.0,1,0,0,1,0,0,0,18,0,7,7,6,13.9,0,0,7,7,6,13.9,0,7.6,2.6,0.32,2 +Student_03381,1,39,9500,1,1,1,1,19,19,9,8,130.0,105.8,0,0,0,1,0,0,0,26,0,7,12,3,13.766666666666666,0,0,7,11,3,12.066666666666668,0,13.9,-0.3,0.79,0 +Student_03382,1,26,9147,1,1,2,1,34,34,0,0,133.1,121.5,1,0,0,1,0,0,0,31,13,15,17,13,11.615384615384617,0,11,14,14,11,12.545454545454543,0,7.6,2.6,0.32,0 +Student_03383,1,17,9238,1,1,1,1,37,38,9,8,138.0,134.2,1,0,0,1,0,1,0,18,0,6,6,6,15.166666666666666,0,0,6,7,6,14.142857142857142,0,11.1,0.6,2.02,2 +Student_03384,4,7,9147,1,1,3,1,19,1,5,5,130.0,130.0,0,0,0,1,0,0,0,35,0,5,5,0,0.0,0,0,5,5,0,0.0,0,11.1,0.6,2.02,0 +Student_03386,1,1,9238,1,1,1,1,19,38,7,7,115.0,108.7,0,0,0,1,0,1,0,19,0,6,9,5,10.8,0,0,6,8,6,10.714285714285714,0,15.5,2.8,-4.06,2 +Student_03387,1,1,9500,1,2,1,1,3,1,4,3,147.0,136.7,0,0,0,1,0,0,0,18,0,7,7,7,13.995714285714287,0,0,8,9,8,14.955555555555556,0,11.1,0.6,2.02,2 +Student_03388,1,17,9085,1,1,1,1,38,38,4,9,132.0,119.1,0,0,0,1,0,0,0,20,0,6,8,6,13.285714285714286,0,0,6,16,6,11.8,0,12.4,0.5,1.79,2 +Student_03389,1,1,171,1,4,1,1,1,1,9,5,146.0,151.3,1,0,0,1,0,1,0,19,6,12,12,12,12.75,0,4,11,16,11,13.25,0,8.9,1.4,3.51,2 +Student_03390,1,43,9238,1,1,1,1,19,37,5,5,109.0,108.3,0,0,0,1,0,1,0,21,0,6,15,2,10.5,0,0,6,8,5,12.4,0,10.8,1.4,1.74,1 +Student_03391,1,17,9853,1,1,1,1,38,38,9,9,133.0,127.4,0,0,1,1,0,1,0,18,0,7,7,7,12.714285714285714,0,0,7,7,7,12.285714285714286,0,16.2,0.3,-0.92,2 +Student_03393,1,1,9070,1,1,1,1,1,1,9,9,133.1,155.0,0,0,0,1,0,1,0,21,0,6,7,5,13.0,0,0,6,6,6,12.666666666666666,0,16.2,0.3,-0.92,2 +Student_03394,1,1,9147,1,1,1,1,37,38,9,9,121.0,114.0,0,0,0,1,0,1,0,19,0,5,7,5,12.2,0,0,5,6,5,11.2,0,11.1,0.6,2.02,2 +Student_03396,1,53,9085,1,1,42,1,19,37,4,9,160.0,NA,1,0,0,1,0,0,0,20,7,11,15,11,13.785714285714286,0,4,9,9,9,13.88888888888889,0,8.9,1.4,3.51,2 +Student_03398,1,1,9500,1,1,1,1,37,37,9,7,150.0,136.5,1,0,0,1,0,1,0,18,0,8,8,8,14.50125,0,0,8,8,8,14.50125,0,9.4,-0.8,-3.12,2 +Student_03400,1,17,9070,1,1,1,1,38,19,5,5,133.1,128.0,0,0,0,1,0,1,0,21,0,6,6,6,11.5,0,0,6,6,6,12.333333333333334,0,9.4,-0.8,-3.12,2 +Student_03402,1,1,9670,1,1,1,1,37,19,7,7,126.0,125.7,0,0,0,1,0,0,0,20,0,6,9,6,13.571428571428571,0,0,6,10,5,13.6,0,15.5,2.8,-4.06,1 +Student_03403,1,1,9773,1,1,1,1,19,38,9,5,150.0,143.0,0,0,0,1,0,0,0,18,0,6,6,5,13.0,0,0,6,6,6,13.666666666666666,0,12.7,3.7,-1.7,2 +Student_03404,1,17,9500,1,5,1,1,19,19,9,7,141.0,131.9,1,0,0,1,0,1,0,18,0,7,8,7,13.56875,0,0,8,8,8,14.02625,0,15.5,2.8,-4.06,2 +Student_03405,2,43,9991,0,1,1,1,37,37,9,9,134.0,113.7,0,0,0,1,0,0,0,32,1,5,5,5,10.2,0,0,5,9,4,11.25,0,9.4,-0.8,-3.12,1 +Student_03406,1,17,171,1,2,1,1,3,3,3,3,146.0,155.1,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_03407,1,16,9853,1,3,1,1,19,37,9,9,134.0,121.1,1,0,0,1,0,0,0,NA,0,6,8,5,12.2,0,0,6,8,5,11.8,0,10.8,1.4,1.74,1 +Student_03409,1,1,9500,1,6,1,1,1,1,4,5,136.0,123.3,0,0,0,0,0,0,0,18,0,8,8,0,0.0,8,0,8,8,0,0.0,8,9.4,-0.8,-3.12,0 +Student_03411,1,5,9670,1,1,1,1,1,12,4,4,135.0,140.3,1,0,0,1,0,0,0,19,0,6,7,6,13.428571428571429,0,0,6,6,4,14.0,0,12.4,0.5,1.79,1 +Student_03412,1,17,9500,1,4,1,1,38,37,9,5,129.0,120.0,1,0,0,1,0,0,0,19,0,8,8,7,12.454285714285716,0,0,8,8,7,12.454285714285716,0,10.8,1.4,1.74,2 +Student_03414,1,1,9500,1,4,1,1,1,19,4,7,137.0,126.7,1,0,0,1,0,0,0,18,0,7,0,0,0.0,0,0,8,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_03415,1,17,9500,1,3,1,1,1,19,7,8,138.0,129.3,1,0,0,1,0,1,0,18,0,7,8,6,13.271666666666668,0,0,8,11,7,12.94375,0,12.4,0.5,1.79,2 +Student_03416,1,17,9500,1,6,1,1,3,38,2,9,136.0,125.7,1,0,0,1,0,0,0,20,0,7,8,6,13.548333333333334,0,0,8,11,6,14.775,0,11.1,0.6,2.02,1 +Student_03417,1,1,9773,1,1,1,1,3,3,2,5,143.0,144.8,0,0,0,1,0,0,0,19,0,6,6,6,12.166666666666666,0,0,6,6,6,12.5,0,16.2,0.3,-0.92,1 +Student_03418,1,1,9254,1,1,1,1,38,19,3,3,133.1,98.6,0,0,0,1,0,0,0,21,0,6,16,2,11.0,0,0,6,12,0,0.0,0,12.7,3.7,-1.7,0 +Student_03419,1,1,9853,1,1,1,1,38,37,9,9,136.0,126.9,1,0,0,1,0,1,0,19,0,7,7,7,13.285714285714286,0,0,7,7,7,14.428571428571429,0,11.1,0.6,2.02,2 +Student_03421,1,1,9500,1,1,1,1,1,1,9,4,125.0,117.0,0,0,0,1,0,1,0,21,0,8,8,8,13.2575,0,0,8,8,8,13.2575,0,9.4,-0.8,-3.12,2 +Student_03422,1,44,9085,1,1,39,1,37,38,9,6,130.0,130.0,1,0,0,1,0,0,0,23,0,6,7,0,0.0,0,0,6,7,0,0.0,0,11.1,0.6,2.02,0 +Student_03423,1,17,9238,1,1,1,1,1,38,5,8,137.0,125.8,0,0,0,0,0,1,0,18,0,6,10,6,12.666666666666666,0,0,6,6,2,11.5,0,12.7,3.7,-1.7,0 +Student_03424,2,39,9991,0,1,3,1,3,1,1,10,130.0,160.0,0,0,0,1,0,0,0,30,0,5,5,5,14.6,0,0,5,5,5,15.4,0,12.7,3.7,-1.7,0 +Student_03425,1,1,9085,1,1,1,1,9,19,4,1,130.0,134.2,1,0,0,1,0,0,0,20,0,5,13,0,0.0,5,0,5,5,0,0.0,5,9.4,-0.8,-3.12,0 +Student_03426,2,43,9147,1,2,1,1,37,37,9,9,160.0,96.0,0,0,0,0,0,0,0,29,3,5,7,3,12.333333333333334,0,0,5,8,0,0.0,0,10.8,1.4,1.74,0 +Student_03427,1,18,9147,1,1,1,1,38,38,5,5,100.0,101.8,1,0,0,1,0,0,0,24,0,5,5,5,10.8,0,0,5,11,2,11.0,0,10.8,1.4,1.74,1 +Student_03428,1,1,9238,1,1,1,1,19,1,4,3,136.0,125.2,1,0,0,1,0,0,0,20,0,6,7,6,11.666666666666666,0,0,6,10,6,11.333333333333334,0,7.6,2.6,0.32,2 +Student_03430,2,7,9147,1,1,3,1,37,37,9,9,140.0,140.0,0,0,0,1,0,0,0,23,0,5,0,0,0.0,0,0,5,0,0,0.0,0,7.6,2.6,0.32,0 +Student_03431,1,51,9070,1,1,1,1,19,19,153,153,132.0,120.0,0,0,0,1,0,1,0,23,0,6,6,6,15.333333333333334,0,0,6,6,6,14.166666666666666,0,11.1,0.6,2.02,2 +Student_03433,1,1,9773,1,1,1,1,38,38,9,7,158.0,144.7,1,0,0,1,0,1,0,NA,0,6,6,6,14.833333333333334,0,0,6,6,6,14.666666666666666,0,12.7,3.7,-1.7,2 +Student_03434,1,17,9500,1,6,1,1,19,37,4,9,142.0,131.9,1,0,0,1,0,0,0,19,0,7,7,7,13.642857142857142,0,0,8,8,8,14.3875,0,13.9,-0.3,0.79,0 +Student_03435,1,1,9773,1,1,1,1,NA,38,8,8,143.0,136.7,1,0,0,1,0,1,0,18,0,6,6,6,13.833333333333334,0,0,6,6,6,14.0,0,11.1,0.6,2.02,0 +Student_03436,1,1,9070,1,2,1,1,1,1,4,7,135.0,129.8,1,0,0,1,0,0,0,19,0,6,6,6,11.833333333333334,0,0,6,7,6,13.0,0,9.4,-0.8,-3.12,2 +Student_03437,NA,1,9773,1,1,1,1,1,38,4,7,160.0,146.5,0,0,0,1,0,1,0,18,0,6,7,6,13.428571428571429,0,0,6,10,6,13.5,0,13.9,-0.3,0.79,2 +Student_03438,1,43,9991,0,1,1,1,37,37,9,8,120.0,122.5,1,0,0,1,0,0,0,29,8,13,16,8,10.5,0,8,12,19,9,10.333333333333334,0,9.4,-0.8,-3.12,1 +Student_03440,1,17,9556,1,2,1,1,37,38,9,8,133.1,106.0,1,0,0,1,0,0,0,19,0,7,16,2,12.75,0,0,7,12,2,11.0,0,8.9,1.4,3.51,0 +Student_03442,1,1,9670,1,1,1,1,38,19,4,8,120.0,115.1,0,0,0,1,0,0,0,NA,0,6,8,3,11.666666666666666,0,0,6,11,5,NA,0,10.8,1.4,1.74,1 +Student_03443,1,17,9254,1,4,1,1,37,19,9,7,106.0,116.9,1,0,0,1,0,0,0,20,0,6,7,6,11.5,0,0,6,8,5,12.4,0,11.1,0.6,2.02,2 +Student_03444,1,1,9773,1,2,1,1,1,19,9,9,148.0,141.7,0,0,0,1,0,0,0,18,0,6,6,6,13.833333333333334,0,0,6,6,6,12.666666666666666,0,10.8,1.4,1.74,2 +Student_03445,1,1,9070,1,2,1,1,1,19,3,3,NA,127.7,1,0,0,0,0,0,0,18,1,6,8,6,11.714285714285714,1,0,6,11,4,11.333333333333334,0,13.9,-0.3,0.79,0 +Student_03446,1,1,9500,1,5,1,1,19,1,9,5,130.0,122.1,1,0,0,1,0,1,0,19,0,7,8,7,11.678571428571429,0,0,8,10,7,13.0375,0,12.4,0.5,1.79,2 +Student_03447,1,16,9085,1,1,1,1,3,3,2,1,150.0,153.5,1,0,0,1,0,0,0,19,0,6,7,6,15.714285714285714,0,0,6,6,6,14.666666666666666,0,13.9,-0.3,0.79,0 +Student_03448,1,1,171,1,1,1,1,1,19,5,8,141.0,141.4,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_03450,1,1,9500,1,2,1,1,3,3,2,2,138.0,127.5,1,0,0,1,0,1,0,18,0,7,7,7,14.485714285714286,0,0,8,9,8,14.58888888888889,0,16.2,0.3,-0.92,2 +Student_03452,1,39,9500,1,1,1,1,19,19,5,6,133.1,121.4,0,0,1,1,0,0,0,28,0,7,12,4,13.375,0,0,7,7,5,13.5,0,13.9,-0.3,0.79,1 +Student_03453,1,42,9500,1,1,1,1,1,1,4,4,133.0,100.0,0,0,0,1,0,0,0,20,1,8,8,7,11.571428571428571,0,1,8,8,7,11.571428571428571,0,12.7,3.7,-1.7,2 +Student_03455,1,17,9147,1,1,1,1,37,37,9,9,117.0,109.3,0,0,0,0,0,0,0,22,0,5,9,2,10.0,1,0,5,11,1,10.0,0,9.4,-0.8,-3.12,0 +Student_03457,NA,7,9238,1,1,3,NA,37,37,9,9,140.0,140.0,1,0,0,1,0,0,0,36,10,14,21,13,13.071428571428571,0,4,11,16,11,13.0,0,16.2,0.3,-0.92,2 +Student_03458,1,44,9003,1,1,39,1,37,38,9,7,160.0,160.0,0,0,0,1,0,1,0,19,0,6,7,6,15.333333333333334,0,0,6,9,6,14.0,0,15.5,2.8,-4.06,2 +Student_03459,1,17,NA,1,1,1,1,4,3,1,1,125.0,119.8,0,0,0,1,0,0,0,18,0,6,9,5,11.571428571428571,0,0,6,8,6,12.142857142857142,0,16.2,0.3,-0.92,2 +Student_03461,1,1,9500,1,2,1,1,38,37,9,7,139.0,125.0,1,0,0,1,0,1,0,19,0,7,7,6,12.9,0,0,7,7,6,12.9,0,7.6,2.6,0.32,2 +Student_03462,4,43,9500,1,1,1,1,37,37,9,9,130.0,103.7,0,0,0,1,0,0,0,38,1,8,12,5,13.126,1,1,8,12,5,13.126,1,10.8,1.4,1.74,1 +Student_03463,NA,7,9085,1,1,3,1,37,37,7,7,120.0,120.0,0,0,0,1,0,0,0,32,4,10,20,4,11.5,2,3,9,13,3,11.666666666666666,2,15.5,2.8,-4.06,0 +Student_03465,1,17,9070,1,3,1,1,3,1,4,4,120.0,116.9,1,0,0,1,0,0,0,19,0,6,6,6,13.5,0,0,6,7,6,13.428571428571429,0,8.9,1.4,3.51,2 +Student_03466,2,39,9147,1,1,1,1,NA,37,9,9,130.0,117.9,0,0,0,1,0,0,0,35,0,1,1,0,0.0,1,0,5,0,0,0.0,0,10.8,1.4,1.74,0 +Student_03467,1,1,9147,1,1,NA,1,38,19,3,10,124.0,128.6,1,0,0,1,0,0,0,20,0,5,5,4,12.0,0,0,4,4,2,11.5,0,7.6,2.6,0.32,1 +Student_03468,1,17,9853,1,1,1,1,19,19,3,4,150.0,135.0,0,0,0,1,0,0,0,29,2,8,10,7,11.142857142857142,0,2,8,11,8,11.375,0,12.7,3.7,-1.7,2 +Student_03469,1,1,9991,0,1,1,1,37,37,9,9,140.0,124.6,0,0,0,1,0,0,0,29,0,5,11,5,11.4,0,0,5,10,4,10.25,0,15.5,2.8,-4.06,1 +Student_03470,1,1,9500,1,5,1,NA,37,37,7,7,135.0,124.0,1,0,0,NA,0,1,0,19,0,8,8,7,12.771428571428572,1,0,8,8,7,12.771428571428572,1,9.4,-0.8,-3.12,1 +Student_03471,1,1,9500,1,6,1,1,38,19,7,9,143.0,129.5,1,0,0,1,0,1,0,18,0,8,8,7,13.79857142857143,0,0,8,8,7,13.79857142857143,0,10.8,1.4,1.74,2 +Student_03472,2,39,8014,0,1,19,1,38,19,0,10,100.0,111.3,0,0,1,0,0,0,0,25,0,6,7,6,13.333333333333334,0,0,6,6,6,13.5,0,7.6,2.6,0.32,2 +Student_03473,4,39,8014,0,1,19,1,37,37,9,9,133.1,95.0,0,0,1,0,0,0,0,50,0,6,11,0,0.0,0,0,5,6,0,0.0,0,8.9,1.4,3.51,0 +Student_03474,2,1,9147,1,1,1,1,34,34,0,0,133.1,131.8,0,0,0,1,0,0,0,24,14,15,17,14,11.357142857142858,0,13,14,15,13,12.846153846153848,0,7.6,2.6,0.32,0 +Student_03475,1,1,9119,1,5,1,1,38,19,5,3,132.0,119.1,0,0,0,1,0,0,0,18,0,5,11,0,0.0,0,0,5,8,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03476,1,17,9085,1,1,1,1,38,38,191,174,131.0,125.4,1,0,0,1,0,0,0,20,0,6,13,6,15.692307692307692,0,0,6,13,5,14.428571428571429,0,15.5,2.8,-4.06,2 +Student_03477,1,16,9003,1,1,1,1,1,37,4,9,147.0,140.7,1,0,1,1,0,1,0,20,13,18,19,18,15.052631578947368,0,11,13,13,13,14.538461538461538,0,15.5,2.8,-4.06,2 +Student_03478,1,43,9991,0,1,1,1,37,37,9,9,141.0,131.9,0,0,0,1,0,0,0,21,6,10,20,6,11.5,0,5,10,17,5,12.4,0,9.4,-0.8,-3.12,0 +Student_03480,1,1,9254,1,1,1,1,38,37,9,7,135.0,139.2,0,0,0,1,1,1,0,19,0,6,6,6,13.0,0,0,6,6,6,13.166666666666666,0,12.4,0.5,1.79,2 +Student_03482,1,17,171,1,1,1,1,37,37,9,9,142.0,132.9,0,0,0,1,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_03483,1,44,9003,1,1,39,1,37,37,9,10,130.0,NA,0,0,0,1,1,0,0,25,0,6,6,0,0.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_03484,2,39,9500,1,1,1,1,37,37,9,9,133.1,130.1,0,0,0,0,1,0,0,37,0,7,10,5,13.0,0,0,7,9,5,12.88,0,11.1,0.6,2.02,0 +Student_03485,1,39,9500,1,1,1,1,37,37,7,7,133.1,124.5,0,0,0,0,1,0,0,38,0,7,11,5,12.18,0,0,7,11,4,11.8125,0,11.1,0.6,2.02,0 +Student_03487,1,1,9500,1,2,1,1,19,1,9,9,149.0,137.8,1,0,0,1,1,0,0,18,0,8,8,7,13.0,0,0,8,8,7,13.0,0,12.7,3.7,-1.7,2 +Student_03488,1,1,9670,1,1,1,1,1,1,0,0,130.0,119.5,0,0,0,0,1,0,0,19,0,5,5,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03490,1,1,9238,1,1,1,1,1,1,3,3,106.0,105.0,0,0,0,1,1,0,0,20,0,6,9,5,11.0,0,0,6,9,5,12.166666666666666,0,11.1,0.6,2.02,2 +Student_03491,1,1,171,1,1,1,1,37,37,9,9,162.0,142.8,1,0,0,1,1,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03493,2,39,9991,0,1,19,1,38,38,7,8,133.1,120.0,0,0,0,1,1,0,0,39,0,5,9,0,0.0,0,0,5,5,1,10.0,0,12.7,3.7,-1.7,0 +Student_03494,1,7,9119,1,1,3,1,37,37,9,9,130.0,130.0,0,0,0,0,1,0,0,33,0,5,6,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_03495,1,17,9670,1,2,1,1,37,38,5,8,128.0,121.7,0,0,0,1,1,1,0,20,0,5,5,5,12.4,0,0,5,5,4,10.75,0,9.4,-0.8,-3.12,2 +Student_03496,1,1,9003,1,1,1,1,38,19,9,7,124.0,NA,0,0,0,1,1,0,0,19,0,6,8,6,15.5,0,0,6,10,6,14.1,0,16.2,0.3,-0.92,2 +Student_03497,2,39,9991,0,1,1,1,37,37,5,8,133.1,133.2,0,0,0,0,1,0,0,43,0,5,13,2,11.5,0,0,5,12,3,10.8,0,13.9,-0.3,0.79,0 +Student_03498,2,43,9991,0,1,1,1,37,37,7,8,114.0,116.7,0,0,0,1,1,0,0,49,0,5,7,4,13.333333333333334,0,0,5,9,4,11.6,1,16.2,0.3,-0.92,0 +Student_03499,1,1,9773,1,2,1,1,38,38,5,7,140.0,126.4,1,0,0,1,1,1,0,18,0,6,8,6,12.666666666666666,0,0,6,6,6,13.5,0,12.7,3.7,-1.7,2 +Student_03502,1,39,9070,1,1,1,1,37,37,9,10,140.0,118.0,0,0,1,1,1,1,0,45,0,6,6,6,13.5,0,0,6,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_03503,1,15,9670,1,1,1,1,37,12,9,9,160.0,149.5,1,0,0,0,1,0,0,19,0,6,6,6,13.0,0,0,6,8,6,13.0,0,13.9,-0.3,0.79,2 +Student_03504,1,44,9003,1,1,39,1,1,3,9,6,130.0,130.0,0,0,0,NA,1,1,0,21,0,6,15,6,11.714285714285714,0,0,6,8,4,11.75,0,13.9,-0.3,0.79,2 +Student_03507,1,17,9254,1,1,1,1,37,37,5,1,126.0,126.0,0,0,0,0,1,0,0,29,0,6,12,0,0.0,0,0,6,6,0,0.0,6,9.4,-0.8,-3.12,0 +Student_03508,1,1,9670,1,1,1,1,1,1,4,9,131.0,122.3,0,0,0,1,1,0,0,19,0,5,6,5,11.5,0,0,5,5,5,11.6,0,9.4,-0.8,-3.12,2 +Student_03509,1,1,9147,1,1,1,1,19,19,9,7,130.0,119.5,1,0,0,1,1,1,0,18,0,5,7,4,11.25,0,0,5,6,4,12.25,0,12.4,0.5,1.79,1 +Student_03510,1,44,NA,1,1,39,1,1,1,9,9,130.0,131.8,0,0,0,1,1,1,0,22,2,7,7,7,12.285714285714286,0,5,9,10,8,NA,0,12.4,0.5,1.79,2 +Student_03511,1,17,9500,1,6,1,1,1,1,4,3,140.0,130.7,1,0,0,1,1,1,0,18,0,7,7,7,12.718571428571428,0,0,8,11,8,12.805555555555555,0,11.1,0.6,2.02,0 +Student_03512,1,44,9130,1,1,39,1,1,19,4,7,140.0,140.0,0,0,0,1,1,0,0,20,2,6,12,5,NA,0,1,6,11,2,15.0,0,13.9,-0.3,0.79,1 +Student_03514,4,39,9670,1,1,19,1,37,37,9,7,133.1,130.0,0,0,1,1,1,1,0,29,0,6,16,1,14.0,0,0,6,7,0,0.0,0,11.1,0.6,2.02,0 +Student_03515,1,39,9670,1,1,1,1,11,11,90,4,120.0,114.0,1,0,0,1,1,0,0,29,0,5,10,3,11.666666666666666,0,0,5,8,4,11.25,0,7.6,2.6,0.32,0 +Student_03516,1,43,9773,1,1,1,1,1,1,4,5,121.0,121.0,1,0,0,1,1,0,0,23,0,6,15,1,13.0,0,0,6,8,4,11.25,0,9.4,-0.8,-3.12,1 +Student_03518,1,1,9119,1,1,1,1,38,38,9,9,136.0,121.7,1,0,0,1,1,0,0,18,0,5,10,0,0.0,0,0,5,11,1,12.0,3,7.6,2.6,0.32,0 +Student_03519,2,42,9254,1,1,1,1,2,2,134,112,136.0,130.0,1,0,0,1,1,0,0,22,2,6,13,4,11.5,0,2,6,12,2,12.5,0,7.6,2.6,0.32,0 +Student_03520,1,43,9991,0,1,1,1,37,37,9,9,120.0,120.0,1,0,1,1,1,0,0,34,6,10,10,7,11.714285714285714,0,4,10,10,6,11.5,0,10.8,1.4,1.74,0 +Student_03521,1,43,9991,0,1,4,1,3,3,2,1,160.0,125.0,0,0,0,NA,1,0,0,26,0,5,7,5,12.6,0,0,5,7,5,13.714285714285714,0,13.9,-0.3,0.79,2 +Student_03522,1,17,171,1,1,1,1,37,37,7,9,NA,134.1,1,0,0,1,1,0,0,24,12,17,19,13,11.642857142857142,0,12,17,25,12,11.25,0,11.1,0.6,2.02,0 +Student_03523,1,1,9670,1,1,1,1,1,1,9,8,146.0,149.5,1,0,0,1,1,1,0,17,0,6,8,6,14.875,0,0,6,8,6,13.428571428571429,0,11.1,0.6,2.02,2 +Student_03525,2,39,9991,0,1,1,1,1,4,4,2,150.0,146.0,0,0,0,1,1,0,0,34,0,5,5,5,14.2,0,0,5,5,5,14.6,0,12.7,3.7,-1.7,1 +Student_03526,1,44,9003,1,1,39,1,19,38,6,7,140.0,140.0,1,0,0,1,1,0,0,19,0,6,8,6,12.714285714285714,0,0,6,9,6,13.5,0,12.4,0.5,1.79,2 +Student_03527,2,39,9003,1,1,1,1,1,3,4,2,111.0,162.4,0,0,1,0,1,0,0,49,4,12,16,5,11.6,0,2,7,7,5,11.2,0,8.9,1.4,3.51,0 +Student_03528,1,43,9500,1,1,1,1,2,4,4,5,120.0,136.6,0,0,0,1,1,0,0,23,0,7,14,5,11.94,0,0,7,14,6,12.2,0,13.9,-0.3,0.79,0 +Student_03529,1,18,9119,1,3,1,1,1,19,9,8,111.0,111.0,1,0,0,1,1,0,0,18,0,5,10,4,11.6,0,0,5,9,3,14.2,0,12.4,0.5,1.79,0 +Student_03530,1,1,9500,1,1,1,1,12,1,4,10,118.0,115.7,0,0,0,1,1,0,0,20,0,7,9,5,12.7,0,0,8,9,7,13.475,0,13.9,-0.3,0.79,1 +Student_03532,1,42,9003,1,1,39,NA,3,1,2,6,120.0,128.2,1,0,0,1,1,0,0,24,4,9,13,8,13.333333333333334,0,5,10,12,9,13.11111111111111,0,16.2,0.3,-0.92,1 +Student_03533,1,1,9147,1,1,1,1,1,38,4,7,151.0,137.0,1,0,0,1,1,0,0,18,0,5,5,5,13.4,0,0,5,5,5,15.0,0,8.9,1.4,3.51,2 +Student_03534,2,39,9254,1,1,19,1,34,34,0,0,NA,120.0,0,0,1,0,1,0,0,45,0,6,12,0,0.0,0,0,6,12,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03536,1,51,9991,0,1,39,1,1,4,4,10,120.0,118.1,0,0,0,1,1,0,0,28,13,15,17,13,12.0,0,9,13,13,9,11.333333333333334,0,8.9,1.4,3.51,0 +Student_03537,1,39,9991,0,1,1,1,37,37,9,9,110.0,139.0,0,0,0,1,1,0,0,40,0,5,0,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03538,1,39,9147,1,2,19,1,38,19,4,10,133.1,116.3,0,0,0,0,1,0,0,32,0,5,5,0,0.0,0,0,5,9,0,0.0,0,10.8,1.4,1.74,0 +Student_03539,1,17,9254,1,5,1,1,19,37,5,5,118.0,120.5,1,0,0,1,1,0,0,19,0,6,12,4,12.5,0,0,6,12,4,10.25,0,7.6,2.6,0.32,0 +Student_03540,1,1,9070,1,1,1,1,1,19,3,9,139.0,134.9,1,0,0,1,1,0,0,20,0,6,7,6,13.666666666666666,0,0,6,7,6,12.166666666666666,1,16.2,0.3,-0.92,2 +Student_03541,1,17,9119,1,1,1,1,1,3,4,2,130.0,123.0,0,0,0,1,1,0,0,18,0,5,10,1,10.0,0,0,5,7,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03542,1,17,9670,1,1,1,1,38,37,9,9,132.0,122.9,0,0,0,0,1,0,0,20,0,6,6,6,11.5,0,0,6,9,2,13.0,0,10.8,1.4,1.74,0 +Student_03543,1,39,9991,0,1,1,1,37,38,9,4,100.0,140.0,0,0,0,1,1,0,0,39,0,5,7,4,12.25,0,0,5,7,4,12.75,0,15.5,2.8,-4.06,1 +Student_03544,1,17,9085,1,1,1,1,19,38,4,8,120.0,122.5,0,0,0,0,1,0,0,19,0,6,11,5,13.6,0,0,6,11,5,13.666666666666666,0,11.1,0.6,2.02,1 +Student_03546,1,17,9500,1,3,1,1,19,37,4,9,156.0,132.3,1,0,0,1,1,1,0,18,0,7,7,6,13.266666666666666,0,0,7,7,6,13.266666666666666,0,7.6,2.6,0.32,2 +Student_03549,1,39,9670,1,1,1,1,37,37,9,9,140.0,148.0,1,0,0,0,1,0,0,31,0,6,14,0,0.0,0,0,6,6,0,0.0,0,12.7,3.7,-1.7,0 +Student_03552,1,39,9238,1,1,19,1,37,37,9,9,133.1,139.0,0,0,1,0,1,0,0,33,0,6,8,0,0.0,0,0,5,6,0,NA,0,16.2,0.3,-0.92,0 +Student_03556,1,44,9085,1,1,39,1,38,38,4,1,150.0,150.0,1,0,0,1,1,0,0,20,1,6,11,6,13.8,0,1,6,7,6,13.142857142857142,0,16.2,0.3,-0.92,2 +Student_03557,1,39,9254,1,1,12,1,37,37,5,7,133.1,119.3,1,0,0,1,1,0,0,25,0,6,7,6,11.166666666666666,0,0,6,11,4,11.8,0,9.4,-0.8,-3.12,1 +Student_03558,1,39,9003,1,1,1,1,1,1,9,4,130.0,140.0,0,0,0,0,1,0,0,25,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_03560,1,1,9670,1,1,1,1,2,1,2,4,141.0,140.7,1,0,0,1,NA,0,0,20,0,5,5,5,12.6,0,0,5,6,4,14.5,1,7.6,2.6,0.32,2 +Student_03561,2,39,9500,1,1,19,1,19,19,4,4,133.1,100.0,0,0,0,1,1,0,0,33,0,7,7,5,13.06,0,0,7,9,0,0.0,0,16.2,0.3,-0.92,1 +Student_03562,1,17,NA,1,5,1,1,1,37,5,5,146.0,146.7,1,0,0,1,1,0,0,19,0,6,7,6,13.833333333333334,0,0,6,8,6,13.625,0,7.6,2.6,0.32,2 +Student_03563,1,39,9130,1,1,19,1,34,34,99,99,133.1,96.0,0,0,0,1,1,0,0,31,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_03564,1,44,9119,1,1,39,1,3,38,2,3,160.0,160.0,0,0,1,0,1,0,0,24,2,6,6,2,16.0,0,2,7,7,2,16.0,0,8.9,1.4,3.51,0 +Student_03565,1,44,9119,1,1,39,1,19,3,3,4,130.0,130.0,0,0,1,0,1,0,0,23,0,5,5,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_03566,2,39,9991,0,1,1,1,1,3,1,2,160.0,130.0,0,0,0,0,1,1,0,26,0,5,12,3,10.666666666666666,0,0,5,11,3,10.666666666666666,0,9.4,-0.8,-3.12,0 +Student_03567,2,43,9070,1,1,2,1,37,37,6,6,140.0,140.0,1,0,0,1,1,0,0,38,14,18,18,18,14.5,0,13,18,18,18,14.5,0,16.2,0.3,-0.92,2 +Student_03568,1,1,9119,1,6,1,1,19,19,7,3,126.0,116.6,1,0,0,1,1,1,0,20,0,5,6,5,14.0,0,0,5,7,5,NA,0,8.9,1.4,3.51,2 +Student_03569,1,17,9119,1,5,1,1,1,19,9,9,118.0,120.5,1,0,0,1,1,0,0,20,0,5,10,3,13.333333333333334,0,0,5,11,5,NA,0,12.4,0.5,1.79,2 +Student_03570,1,39,9085,1,1,19,1,3,1,2,5,133.1,103.0,0,0,0,1,1,0,0,25,0,6,0,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_03571,1,17,9070,1,2,1,1,1,19,144,144,121.0,111.9,1,0,0,1,1,0,0,NA,0,6,9,5,12.0,0,0,6,10,4,11.2,0,8.9,1.4,3.51,2 +Student_03572,1,17,9119,1,1,1,1,1,38,4,5,148.0,148.7,0,0,0,1,1,0,0,18,0,5,6,5,16.2,0,0,5,8,5,16.0,0,8.9,1.4,3.51,2 +Student_03575,1,1,9254,1,1,1,1,1,38,9,9,132.0,120.1,1,0,0,1,NA,1,0,20,0,6,7,6,13.571428571428571,0,0,6,8,6,13.166666666666666,0,8.9,1.4,3.51,2 +Student_03576,1,1,9130,1,1,1,1,4,3,3,3,140.0,127.8,0,0,0,1,1,0,0,18,0,6,7,6,14.285714285714286,0,0,6,9,6,14.857142857142858,0,11.1,0.6,2.02,2 +Student_03577,1,17,9147,1,3,1,1,1,1,3,3,112.0,106.4,1,0,0,1,1,0,0,19,0,5,7,5,10.2,0,0,5,6,4,10.5,0,12.4,0.5,1.79,2 +Student_03579,1,17,9085,1,4,1,1,1,3,5,5,126.0,123.9,1,0,0,1,1,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_03583,1,39,9991,0,1,1,1,38,37,9,9,133.1,154.4,0,0,0,1,1,0,0,27,0,5,0,0,0.0,0,0,5,0,0,0.0,0,10.8,1.4,1.74,0 +Student_03584,1,17,9147,1,6,1,1,37,38,9,9,120.0,115.5,1,0,1,0,1,0,0,19,0,5,8,4,12.5,0,0,5,9,5,10.5,0,8.9,1.4,3.51,1 +Student_03585,1,39,8014,0,1,1,1,3,19,4,7,133.1,119.0,0,0,0,1,1,0,0,39,3,9,10,9,13.22222222222222,0,2,7,8,7,13.142857142857142,0,8.9,1.4,3.51,2 +Student_03586,1,39,33,1,1,1,1,19,37,9,9,133.1,96.1,0,0,0,1,1,0,0,25,0,7,13,2,15.0,0,0,7,12,2,11.5,0,12.4,0.5,1.79,0 +Student_03587,1,7,171,1,1,3,1,1,2,9,2,130.0,130.0,0,0,0,0,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03589,1,18,9773,1,1,NA,1,38,37,9,8,124.0,126.8,0,0,0,1,1,1,0,21,0,6,8,5,13.833333333333334,0,0,6,6,4,14.0,0,13.9,-0.3,0.79,2 +Student_03590,1,7,9991,0,1,40,1,1,3,4,NA,130.0,130.0,0,0,0,1,1,0,0,27,0,5,0,0,0.0,0,0,5,0,0,0.0,0,8.9,1.4,3.51,0 +Student_03591,1,1,9147,1,3,1,1,1,1,5,3,124.0,116.7,1,0,0,1,1,0,0,19,0,5,6,0,0.0,0,0,5,6,0,0.0,0,7.6,2.6,0.32,1 +Student_03593,1,7,9670,1,1,3,1,27,37,3,3,110.0,110.0,1,0,0,1,1,0,0,27,7,12,12,9,12.333333333333334,0,6,11,11,6,13.166666666666666,0,9.4,-0.8,-3.12,0 +Student_03595,1,1,9130,1,1,1,1,2,3,9,1,130.0,117.6,0,0,0,1,1,0,0,19,0,5,14,2,11.5,2,0,5,8,5,11.4,3,9.4,-0.8,-3.12,1 +Student_03596,1,44,9003,1,1,39,1,19,38,9,10,140.0,140.0,0,0,0,1,1,0,0,19,0,6,15,3,13.25,0,0,6,9,1,12.0,0,13.9,-0.3,0.79,0 +Student_03597,1,44,9003,1,1,39,1,19,1,1,1,150.0,150.0,0,0,0,1,1,0,0,22,0,6,12,3,13.333333333333334,0,0,6,12,3,12.75,0,15.5,2.8,-4.06,1 +Student_03598,1,16,9238,1,2,1,1,19,38,4,5,133.0,133.7,1,0,0,1,0,0,0,18,0,6,6,6,13.5,0,0,6,6,6,12.166666666666666,0,10.8,1.4,1.74,2 +Student_03599,1,16,9773,1,4,1,1,37,37,9,3,109.0,137.0,1,0,0,1,0,1,0,18,0,6,7,6,12.666666666666666,0,0,6,8,5,12.8,0,10.8,1.4,1.74,2 +Student_03600,1,43,9147,1,1,1,1,4,19,2,1,133.1,128.2,0,0,0,1,0,0,0,23,7,11,18,11,15.090909090909092,1,2,6,7,6,14.5,0,9.4,-0.8,-3.12,0 +Student_03601,1,18,171,1,4,1,1,1,4,9,5,133.0,129.2,1,0,1,0,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03603,1,1,9773,1,4,1,1,19,19,9,7,125.0,129.6,1,0,0,1,1,0,0,18,0,6,6,6,12.833333333333334,0,0,6,8,6,12.833333333333334,0,12.4,0.5,1.79,2 +Student_03604,1,17,9119,1,3,1,1,1,19,141,193,135.0,NA,1,0,0,1,1,0,0,18,0,5,7,5,11.8,0,0,5,9,3,12.0,0,8.9,1.4,3.51,1 +Student_03605,1,17,9773,1,2,1,1,19,1,9,9,132.0,141.8,1,0,0,1,1,0,0,20,0,6,6,6,11.833333333333334,0,0,6,6,6,12.166666666666666,0,12.7,3.7,-1.7,2 +Student_03606,1,1,9773,1,3,1,1,3,1,2,4,135.0,129.8,1,0,0,1,1,0,0,20,0,6,6,5,12.8,0,0,6,11,3,12.75,0,15.5,2.8,-4.06,2 +Student_03607,1,44,9070,1,1,39,1,1,1,4,4,100.0,106.0,0,0,0,1,1,0,0,21,2,7,7,5,11.8,0,5,9,9,5,11.0,0,12.4,0.5,1.79,0 +Student_03608,1,43,171,1,1,1,1,19,19,9,4,144.0,121.6,0,0,0,1,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,1 +Student_03609,1,17,9119,1,1,1,1,19,1,5,4,125.0,121.5,1,0,0,1,1,0,0,20,0,5,7,5,15.8,0,0,5,7,5,14.571428571428571,0,11.1,0.6,NA,0 +Student_03610,1,1,171,1,1,1,1,1,37,9,9,133.1,117.0,0,0,1,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,1 +Student_03611,1,44,9119,1,1,39,1,38,19,9,5,130.0,130.0,1,0,0,1,1,0,0,19,0,5,9,2,12.5,0,0,5,10,3,11.6,0,12.4,0.5,1.79,1 +Student_03612,1,17,9670,1,1,1,1,1,1,4,4,117.0,117.7,1,0,0,1,1,0,0,20,0,6,9,6,14.666666666666666,0,0,6,7,6,13.857142857142858,0,8.9,1.4,3.51,2 +Student_03613,1,44,9085,1,1,39,1,19,37,5,7,140.0,140.0,1,0,0,1,1,0,0,19,2,6,10,4,12.5,0,1,6,16,2,12.0,0,12.4,0.5,1.79,0 +Student_03614,1,1,9119,1,1,1,1,1,12,3,3,132.0,133.1,1,0,0,1,1,0,0,19,0,5,7,3,12.0,0,0,6,10,2,10.5,0,11.1,0.6,2.02,0 +Student_03615,1,15,9119,1,1,1,41,2,2,2,2,133.1,100.0,0,0,1,1,1,0,1,24,2,8,8,7,13.142857142857142,0,1,6,8,6,11.833333333333334,0,8.9,1.4,3.51,1 +Student_03616,1,17,9670,1,1,1,1,19,1,5,4,132.0,119.1,0,0,1,1,1,0,0,18,0,6,6,3,12.666666666666666,0,0,6,11,4,11.142857142857142,0,10.8,1.4,1.74,0 +Student_03618,1,1,9238,1,1,1,1,19,38,9,7,133.0,131.3,1,0,1,1,0,0,0,18,0,6,7,5,13.6,0,0,6,7,5,11.8,0,8.9,1.4,3.51,0 +Student_03620,1,17,9238,1,1,1,1,19,37,9,9,NA,126.2,1,0,0,NA,0,1,0,21,0,6,7,6,13.333333333333334,0,0,6,7,6,13.5,0,12.4,0.5,1.79,2 +Student_03621,1,15,9085,1,1,1,41,37,37,9,9,133.1,109.6,0,0,0,1,0,0,1,18,0,6,13,4,12.25,0,0,6,15,5,11.0,0,11.1,0.6,2.02,0 +Student_03622,1,1,9500,1,1,1,1,1,19,3,3,141.0,131.9,1,0,0,1,0,1,0,18,0,7,7,7,15.101428571428572,0,0,8,8,8,16.09375,0,11.1,0.6,2.02,2 +Student_03623,1,1,9238,1,2,1,1,19,37,9,9,NA,140.7,1,0,0,1,0,1,0,18,0,6,6,6,13.166666666666666,0,0,6,6,6,16.0,0,10.8,1.4,1.74,2 +Student_03626,1,1,9238,1,1,1,1,19,38,7,5,135.0,NA,0,0,0,1,0,0,0,20,0,6,13,1,10.0,0,0,6,13,1,13.0,0,9.4,-0.8,-3.12,1 +Student_03628,1,1,9773,1,6,1,1,1,19,4,4,145.0,131.0,1,0,0,1,0,1,0,18,0,6,6,6,12.166666666666666,0,0,6,10,5,11.2,0,7.6,2.6,0.32,1 +Student_03629,1,1,171,1,1,1,1,3,37,9,9,143.0,142.7,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_03630,1,1,9670,1,1,1,1,19,19,9,8,123.0,125.5,0,0,0,0,0,1,0,19,0,6,6,6,13.833333333333334,0,0,6,7,6,14.285714285714286,0,8.9,1.4,3.51,2 +Student_03631,1,1,9500,1,3,1,NA,19,1,9,3,108.0,107.8,1,0,0,1,0,1,0,20,0,7,10,6,12.357142857142858,0,0,8,9,7,13.0,0,13.9,-0.3,0.79,2 +Student_03632,1,1,9773,1,3,1,1,38,19,7,7,117.0,110.4,1,0,1,0,0,0,0,19,0,6,7,6,12.166666666666666,0,0,6,10,2,10.333333333333334,0,16.2,0.3,-0.92,0 +Student_03633,1,44,9238,1,1,39,1,37,19,191,102,140.0,136.1,1,0,1,1,0,0,0,21,3,6,8,3,12.0,0,2,6,6,2,12.5,0,12.4,0.5,1.79,1 +Student_03634,1,39,9254,1,1,1,1,37,37,4,6,170.0,138.3,0,0,0,1,0,0,0,33,5,10,14,9,12.416666666666666,0,5,9,14,7,13.0,0,10.8,1.4,1.74,2 +Student_03635,1,1,9085,1,2,1,1,3,38,4,6,157.0,142.3,0,0,0,1,0,0,0,18,0,5,7,4,12.75,0,0,5,6,4,12.75,0,7.6,2.6,0.32,2 +Student_03636,1,42,9500,1,1,6,1,37,1,9,4,141.0,145.0,0,0,0,1,0,0,0,21,12,21,33,18,14.933333333333334,12,12,21,33,18,14.933333333333334,12,7.6,2.6,0.32,2 +Student_03637,1,1,9773,1,1,1,1,3,19,2,3,125.0,125.7,1,0,0,1,0,0,0,19,0,6,6,6,13.0,0,0,6,7,6,11.666666666666666,0,8.9,1.4,3.51,2 +Student_03638,4,39,9853,1,1,19,1,38,19,9,9,133.1,108.0,0,0,1,0,0,0,0,33,0,7,7,7,12.857142857142858,0,0,7,8,6,12.666666666666666,0,8.9,1.4,3.51,1 +Student_03639,2,1,9500,1,4,1,1,38,38,5,5,143.0,128.7,1,0,0,1,0,0,0,18,0,7,10,7,14.455000000000002,0,0,8,8,8,13.91,0,15.5,2.8,-4.06,2 +Student_03640,1,1,9670,1,1,1,1,1,19,4,4,142.0,128.0,0,0,0,1,0,1,0,18,0,6,8,6,14.0,0,0,6,7,6,13.285714285714286,0,11.1,0.6,2.02,2 +Student_03641,1,1,9773,1,3,1,1,19,38,4,4,150.0,146.5,1,0,0,1,0,1,0,20,0,6,6,6,13.5,0,0,6,7,6,12.666666666666666,0,11.1,0.6,2.02,2 +Student_03642,1,1,9254,1,2,1,1,37,37,6,6,112.0,106.1,1,0,0,0,0,0,0,20,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03643,1,17,8014,0,2,1,1,19,1,1,1,133.1,118.0,0,0,0,1,0,1,0,20,0,6,6,6,11.666666666666666,0,0,6,12,5,14.0,0,10.8,1.4,1.74,2 +Student_03644,1,17,9085,1,1,1,1,1,37,4,9,125.0,117.0,1,0,0,1,0,1,0,19,0,5,6,4,12.0,0,0,5,8,5,13.333333333333334,1,10.8,1.4,1.74,2 +Student_03645,1,1,9238,1,3,1,1,38,37,8,8,121.0,115.4,1,0,0,1,0,1,0,19,0,6,7,6,11.714285714285714,0,0,6,6,6,11.833333333333334,0,13.9,-0.3,0.79,2 +Student_03646,1,17,9238,1,3,1,1,41,1,2,3,133.1,117.0,1,0,0,1,0,0,0,21,0,6,8,6,12.666666666666666,0,0,6,7,6,12.428571428571429,0,11.1,0.6,2.02,2 +Student_03647,1,39,9085,1,1,1,1,3,3,4,2,133.1,144.9,1,0,0,1,0,0,0,26,0,6,11,3,11.75,0,0,6,19,4,12.8,0,12.4,0.5,1.79,1 +Student_03648,1,17,9238,1,1,1,1,37,37,8,6,135.0,127.0,0,0,0,1,0,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_03649,1,1,9500,1,4,1,1,19,38,5,5,132.0,118.0,1,0,0,1,0,0,0,18,0,8,8,7,12.328571428571427,0,0,8,8,7,12.328571428571427,0,12.7,3.7,-1.7,2 +Student_03650,5,39,9853,1,1,19,1,37,37,9,8,133.1,118.0,0,0,0,1,0,0,0,27,0,7,14,6,11.666666666666666,0,0,7,10,1,10.0,0,12.4,0.5,1.79,0 +Student_03651,1,43,9070,1,1,1,1,1,38,3,9,135.0,126.4,1,0,0,1,0,1,0,20,5,12,12,12,13.25,0,5,12,12,11,12.727272727272728,0,15.5,2.8,-4.06,2 +Student_03652,1,43,9670,1,1,39,1,19,3,7,10,110.0,110.0,0,0,0,1,0,0,0,21,0,6,8,5,11.833333333333334,0,0,6,8,4,13.25,2,16.2,0.3,-0.92,1 +Student_03653,1,17,9556,1,1,1,1,38,37,9,9,133.0,NA,1,0,0,1,0,1,0,18,0,7,7,7,13.3,0,0,8,8,8,15.125,0,15.5,2.8,-4.06,2 +Student_03654,1,44,9085,1,1,39,1,1,19,9,9,140.0,140.0,1,0,0,1,0,0,0,20,1,6,13,6,12.555555555555555,0,1,6,11,5,11.8,0,16.2,0.3,-0.92,1 +Student_03655,1,1,9773,1,1,1,1,1,19,4,10,135.0,129.4,1,0,0,1,0,0,0,18,0,6,6,6,12.833333333333334,0,0,6,7,6,12.166666666666666,0,11.1,0.6,2.02,2 +Student_03656,1,44,9238,1,1,39,1,1,1,3,5,140.0,141.7,0,0,0,1,0,1,0,20,3,6,6,6,12.833333333333334,0,2,6,6,6,12.833333333333334,0,13.9,-0.3,0.79,2 +Student_03657,1,1,9085,1,2,1,1,1,19,4,10,144.0,132.1,1,0,0,1,0,1,0,19,0,5,10,3,12.666666666666666,1,0,5,7,3,13.0,0,12.7,3.7,-1.7,2 +Student_03658,1,1,9500,1,5,1,1,37,3,9,2,122.0,116.8,1,0,0,1,0,0,0,20,0,7,8,6,13.271428571428572,0,0,8,8,7,14.471428571428572,0,13.9,-0.3,0.79,2 +Student_03659,1,1,9991,0,1,1,1,19,37,5,8,143.0,135.0,0,0,0,1,0,1,0,20,0,5,5,5,12.4,0,0,5,6,5,12.833333333333334,0,10.8,1.4,1.74,2 +Student_03660,1,44,9085,1,1,39,1,38,1,5,5,150.0,150.0,0,0,0,1,0,0,0,20,0,5,10,2,14.5,1,0,5,7,4,11.25,0,12.7,3.7,-1.7,1 +Student_03662,1,1,9773,1,1,1,1,3,3,123,122,156.0,155.0,0,0,0,1,0,0,0,18,0,6,7,6,14.285714285714286,0,0,6,8,6,13.25,0,8.9,1.4,3.51,2 +Student_03663,1,1,9085,1,1,1,1,38,38,9,10,142.0,127.0,1,0,0,1,0,0,0,18,0,5,7,3,12.333333333333334,0,0,5,9,5,12.6,0,10.8,1.4,1.74,2 +Student_03664,1,17,9500,1,1,1,1,38,37,9,8,142.0,130.8,1,0,0,1,0,1,0,19,0,7,10,6,12.583333333333334,0,0,8,8,7,12.671428571428573,0,13.9,-0.3,0.79,2 +Student_03665,1,1,9500,1,6,1,1,12,37,5,9,126.0,121.8,1,0,0,1,0,0,0,19,0,7,8,6,13.731666666666667,0,0,8,10,7,13.771428571428572,0,12.4,0.5,1.79,0 +Student_03666,1,39,9003,1,1,19,1,37,37,9,4,133.1,140.0,0,0,0,1,1,0,0,43,0,6,8,6,12.875,0,0,6,14,5,12.142857142857142,0,16.2,0.3,-0.92,1 +Student_03667,2,42,9070,1,1,1,1,37,25,0,4,170.0,148.5,0,0,0,1,1,0,0,47,8,10,14,8,14.625,0,5,7,7,5,13.4,0,9.4,-0.8,-3.12,0 +Student_03668,1,42,9147,1,1,1,1,34,34,99,99,130.0,109.8,1,0,0,0,1,0,0,23,0,3,3,0,0.0,0,0,2,2,0,0.0,0,7.6,2.6,0.32,0 +Student_03670,1,42,9500,1,1,1,1,3,3,2,2,122.0,122.0,1,0,0,1,0,0,0,20,0,8,11,6,12.491666666666667,0,0,8,11,6,12.491666666666667,0,12.7,3.7,-1.7,2 +Student_03671,1,1,171,1,1,1,1,1,3,4,4,138.0,147.5,1,0,0,1,0,1,0,19,6,12,12,12,13.666666666666666,0,4,11,12,11,14.166666666666666,0,8.9,1.4,3.51,2 +Student_03672,1,17,9085,1,1,1,14,37,37,9,9,163.0,150.8,1,0,0,1,0,0,1,19,0,6,13,6,16.0,0,0,6,8,6,14.5,0,NA,2.8,-4.06,2 +Student_03673,1,44,9085,1,1,39,1,19,37,4,7,150.0,150.0,1,0,0,1,0,0,0,19,2,6,8,6,14.142857142857142,0,1,6,7,6,13.0,0,13.9,-0.3,0.79,2 +Student_03674,1,39,8014,0,1,19,1,19,19,144,141,133.1,131.5,0,0,1,1,0,1,0,39,0,6,9,6,11.833333333333334,0,0,6,9,4,13.75,0,11.1,0.6,2.02,2 +Student_03675,1,1,9070,1,1,1,1,1,1,3,5,144.0,127.2,1,0,0,1,0,1,0,20,0,6,6,6,12.666666666666666,0,0,6,8,6,13.0,0,10.8,1.4,1.74,2 +Student_03676,1,17,9070,1,1,1,NA,38,19,9,3,118.0,111.0,1,0,0,1,0,0,0,21,0,6,6,6,12.5,0,0,6,6,6,12.666666666666666,0,7.6,2.6,0.32,2 +Student_03679,1,17,9670,1,1,1,1,1,19,141,114,133.1,140.0,1,0,0,1,0,0,0,22,0,6,6,6,15.166666666666666,0,0,6,6,6,16.0,0,13.9,-0.3,0.79,2 +Student_03682,5,39,9147,1,1,1,1,19,19,9,9,133.1,119.8,0,0,0,1,1,0,0,26,0,5,9,5,12.0,0,0,5,5,5,10.2,0,11.1,0.6,2.02,1 +Student_03683,1,39,9991,0,1,1,1,37,37,9,9,110.0,121.8,0,0,0,0,1,0,0,36,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_03684,1,18,171,1,1,1,1,19,2,5,5,110.0,117.7,1,0,1,1,1,1,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,2 +Student_03687,1,1,9147,1,1,1,1,34,34,0,0,133.1,NA,0,0,0,1,1,0,0,26,11,15,15,11,10.818181818181818,0,12,14,15,11,11.636363636363637,1,7.6,2.6,0.32,0 +Student_03689,5,39,9238,1,1,1,1,19,38,9,10,130.0,146.0,0,0,0,1,1,0,0,34,0,6,8,5,12.6,0,0,6,11,4,11.25,0,12.4,0.5,1.79,2 +Student_03690,1,43,9130,1,1,1,1,1,1,1,1,130.0,130.0,1,0,0,1,1,0,0,33,0,5,12,1,13.0,2,0,5,7,3,14.0,0,9.4,-0.8,-3.12,1 +Student_03692,1,17,9119,1,5,1,1,19,1,4,5,130.0,118.1,1,0,1,0,1,0,0,26,0,5,11,1,10.0,0,0,5,14,1,11.0,0,8.9,1.4,3.51,0 +Student_03693,1,39,9670,1,1,1,1,38,37,7,7,140.0,105.2,0,0,0,1,1,0,0,29,0,6,7,1,14.0,0,0,6,6,0,NA,0,16.2,0.3,-0.92,0 +Student_03694,1,17,9119,1,5,1,1,19,37,9,7,131.0,123.3,1,0,0,1,1,1,0,19,0,5,9,5,12.6,0,0,5,8,2,12.5,0,8.9,1.4,3.51,0 +Student_03696,1,39,9991,0,1,19,1,19,37,9,9,133.1,149.4,0,0,0,0,1,0,0,29,0,5,11,2,11.333333333333334,0,0,5,9,1,12.0,0,11.1,0.6,2.02,0 +Student_03698,1,17,9254,1,1,1,1,1,1,4,10,119.0,125.0,0,0,0,1,1,0,0,19,0,6,7,5,10.8,0,0,6,10,2,10.5,0,10.8,1.4,1.74,1 +Student_03699,1,1,9500,1,1,NA,1,38,38,5,10,133.1,101.0,0,0,0,1,1,0,0,20,0,7,14,5,12.87857142857143,0,0,8,15,7,11.85625,0,15.5,2.8,-4.06,2 +Student_03700,1,1,9085,1,1,1,1,3,1,2,5,123.0,112.9,0,0,0,1,1,0,0,18,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_03701,1,17,9070,1,3,1,1,38,37,5,5,131.0,120.2,1,0,0,1,1,0,0,18,0,6,6,6,12.833333333333334,0,0,6,8,5,11.4,0,15.5,2.8,-4.06,1 +Student_03702,1,1,9147,1,1,1,1,34,34,99,99,120.0,111.6,0,0,1,1,1,1,0,21,0,5,5,5,12.6,0,0,5,9,3,12.833333333333334,0,10.8,1.4,1.74,1 +Student_03703,1,1,9147,1,1,1,1,1,1,4,2,125.0,134.1,1,0,0,1,1,0,0,20,0,5,0,0,0.0,0,0,5,0,0,0.0,0,8.9,1.4,3.51,0 +Student_03704,1,39,9119,1,1,1,1,37,37,9,9,133.1,101.6,0,0,0,1,1,1,0,30,0,5,11,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_03706,1,51,9147,1,1,1,1,1,19,9,6,148.0,118.4,1,0,0,1,1,0,0,30,0,5,7,5,13.4,0,0,5,7,4,13.25,0,8.9,1.4,3.51,0 +Student_03707,1,1,9147,1,1,1,1,38,1,5,5,139.0,127.1,1,0,0,1,1,1,0,22,0,5,8,5,11.2,0,0,5,13,4,11.25,0,12.7,3.7,-1.7,2 +Student_03708,1,17,171,1,3,1,1,37,37,5,10,125.0,120.5,1,0,0,1,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,2 +Student_03709,1,17,9070,1,4,1,1,1,1,9,10,128.0,136.1,1,0,1,0,1,0,0,19,0,6,6,6,12.666666666666666,0,0,6,8,5,11.8,0,11.1,0.6,2.02,0 +Student_03711,1,17,9085,1,4,1,1,38,38,151,151,137.0,141.6,0,0,0,1,1,0,0,21,0,5,7,4,12.25,0,0,5,7,5,12.0,0,7.6,2.6,0.32,2 +Student_03713,1,39,9147,1,1,1,1,1,19,4,7,120.0,110.0,0,0,0,1,1,0,0,27,0,5,13,3,10.75,0,0,5,9,3,10.333333333333334,0,15.5,2.8,-4.06,0 +Student_03714,1,43,33,1,1,1,1,37,37,1,1,134.0,100.0,1,0,0,1,1,0,0,32,0,7,7,0,0.0,0,0,7,8,0,0.0,0,13.9,-0.3,0.79,0 +Student_03715,1,NA,9670,1,1,12,1,37,1,9,3,133.1,120.0,0,0,1,0,1,0,0,40,0,6,13,0,0.0,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_03716,1,1,9147,1,2,1,1,37,1,5,3,116.0,124.8,1,0,0,1,1,0,0,20,0,5,9,2,14.333333333333334,0,0,5,10,2,12.5,0,7.6,2.6,0.32,1 +Student_03718,1,1,171,1,3,1,1,37,37,9,9,140.0,124.3,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,NA,2.6,0.32,2 +Student_03719,1,43,9147,1,1,1,1,1,38,1,7,122.0,118.9,0,0,0,1,1,0,0,21,0,5,11,2,10.5,0,0,5,13,0,0.0,0,12.7,3.7,-1.7,0 +Student_03720,1,17,9670,1,1,1,1,19,37,5,8,141.0,130.2,0,0,0,1,1,0,0,18,0,6,6,6,13.5,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03721,1,44,9003,1,1,1,1,1,3,144,123,120.0,120.0,0,0,0,1,1,0,0,19,0,6,17,1,11.0,0,0,6,19,0,0.0,0,16.2,0.3,-0.92,1 +Student_03722,5,7,9070,1,1,3,1,37,37,7,7,140.0,140.0,0,0,0,0,1,0,0,30,0,6,6,1,10.0,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_03723,1,39,9003,1,1,12,1,19,1,9,1,133.1,130.0,0,0,0,1,1,0,0,29,0,6,17,0,0.0,2,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_03724,1,17,9119,1,2,1,1,1,1,4,4,137.0,130.4,1,0,1,1,1,0,0,18,0,5,10,1,12.0,0,0,5,7,3,10.666666666666666,2,7.6,2.6,0.32,0 +Student_03725,1,1,9670,1,2,1,1,1,1,9,9,122.0,116.1,1,0,0,1,1,1,0,18,0,5,6,4,NA,0,0,5,5,5,12.2,0,9.4,-0.8,-3.12,0 +Student_03726,1,44,9003,1,1,39,1,1,1,3,10,130.0,130.0,0,0,0,1,1,0,0,22,4,10,21,5,11.4,1,2,7,13,6,11.666666666666666,0,15.5,2.8,-4.06,0 +Student_03727,1,43,9991,0,2,1,1,37,37,5,5,140.0,124.3,1,0,0,0,1,0,0,27,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_03728,1,17,9670,1,6,1,1,NA,1,9,7,125.0,125.0,1,0,0,1,1,0,0,20,0,6,8,4,14.25,0,0,6,10,5,14.0,0,10.8,1.4,1.74,2 +Student_03730,1,1,9003,1,1,1,1,38,38,4,8,133.1,115.0,0,0,1,1,1,0,0,21,8,12,13,12,14.538461538461538,0,4,12,14,12,14.461538461538462,0,15.5,2.8,-4.06,2 +Student_03731,1,43,9500,1,1,1,1,1,38,7,7,132.0,NA,0,1,0,1,1,0,0,23,0,7,10,6,12.733333333333334,0,0,8,10,7,11.95,0,16.2,0.3,-0.92,2 +Student_03732,1,51,9070,1,1,1,1,38,38,9,9,122.0,128.8,1,0,0,1,1,0,0,21,4,12,13,5,13.2,0,4,12,12,4,13.5,0,8.9,1.4,3.51,0 +Student_03733,1,1,171,1,3,1,1,4,3,1,1,155.0,144.2,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_03734,2,39,9238,1,1,1,1,37,37,7,7,120.0,134.0,0,0,0,1,1,1,0,40,0,6,7,6,12.333333333333334,0,0,6,10,4,12.75,0,8.9,1.4,3.51,0 +Student_03735,1,43,9147,1,1,1,1,19,1,9,5,129.0,112.0,0,0,0,1,1,0,0,22,5,9,9,5,11.2,0,5,9,14,7,11.25,2,12.7,3.7,-1.7,0 +Student_03736,1,1,9500,1,2,1,1,38,37,9,9,144.0,128.8,1,0,0,1,1,0,0,19,0,7,7,6,13.2,0,0,7,7,6,13.2,0,7.6,2.6,0.32,2 +Student_03737,1,39,9119,1,1,1,1,19,37,9,9,130.0,134.0,0,0,0,1,1,1,0,24,0,5,8,5,11.833333333333334,0,0,5,8,4,14.0,0,12.7,3.7,-1.7,1 +Student_03738,1,1,9254,1,1,1,1,3,1,2,4,133.1,125.0,0,0,0,1,1,0,0,21,0,6,10,5,11.333333333333334,0,0,6,14,2,11.5,0,12.7,3.7,-1.7,1 +Student_03739,1,17,9119,1,4,1,1,3,1,9,3,133.0,123.2,1,0,0,1,1,0,0,18,0,5,5,5,13.6,0,0,5,6,5,14.6,0,8.9,1.4,3.51,2 +Student_03740,1,17,9119,1,3,1,1,37,37,9,7,131.0,NA,0,0,0,1,1,0,0,18,0,5,10,0,0.0,0,0,5,10,2,11.5,4,7.6,2.6,0.32,0 +Student_03741,1,51,9670,1,1,1,1,3,1,3,10,133.1,116.2,0,0,0,1,1,0,0,24,0,6,11,5,12.857142857142858,0,0,6,12,5,13.666666666666666,0,11.1,0.6,2.02,0 +Student_03742,1,39,9119,1,1,1,1,37,19,9,3,133.1,123.0,0,0,0,1,1,1,0,28,0,5,16,3,14.333333333333334,0,0,5,9,5,12.428571428571429,0,9.4,-0.8,-3.12,1 +Student_03743,1,17,9670,1,1,1,1,19,38,7,9,118.0,113.5,1,0,0,1,0,1,0,19,0,6,9,5,13.5,0,0,6,6,6,14.0,0,12.4,0.5,1.79,2 +Student_03744,1,51,9085,1,1,40,1,3,3,4,2,120.0,125.0,0,0,0,1,0,0,0,28,0,6,8,6,14.428571428571429,0,0,6,12,4,15.6,0,11.1,0.6,2.02,1 +Student_03745,1,17,9853,1,3,1,1,12,1,4,0,133.1,134.8,1,0,0,1,0,0,0,18,0,6,12,0,0.0,0,0,6,12,0,0.0,0,7.6,2.6,0.32,0 +Student_03747,1,1,9500,1,1,1,1,1,1,4,4,125.0,119.8,1,0,0,1,0,1,0,19,0,8,8,8,12.82875,0,0,8,8,8,12.82875,0,9.4,-0.8,-3.12,2 +Student_03748,1,43,9130,1,1,1,1,39,3,3,2,125.0,125.0,1,0,0,1,0,0,0,21,0,5,6,0,0.0,5,0,5,6,4,13.75,1,10.8,1.4,1.74,2 +Student_03749,1,1,9500,1,3,1,1,1,19,4,5,148.0,135.1,1,0,1,1,0,0,0,18,0,7,0,0,0.0,0,0,8,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_03751,1,17,9500,1,2,1,1,38,38,7,7,130.0,122.5,1,0,0,1,0,0,0,19,0,8,8,7,13.937142857142858,0,0,8,8,7,13.937142857142858,0,10.8,1.4,1.74,2 +Student_03752,1,1,9070,1,1,1,1,3,1,2,10,148.0,148.0,1,0,0,1,0,0,0,20,7,12,12,10,14.7,0,8,12,12,12,14.583333333333334,0,15.5,2.8,-4.06,2 +Student_03753,1,1,9773,1,2,1,1,1,1,9,4,130.0,126.2,1,0,0,1,0,0,0,18,0,6,6,6,11.666666666666666,0,0,6,6,5,12.2,0,12.7,3.7,-1.7,2 +Student_03754,1,43,9500,1,4,6,1,37,37,9,9,134.0,129.8,1,0,0,1,0,0,0,20,0,7,7,6,14.85,0,0,7,7,6,14.85,0,7.6,2.6,0.32,2 +Student_03755,1,39,9085,1,1,19,1,19,37,7,NA,133.1,104.0,0,0,0,1,0,0,0,26,0,5,11,1,12.0,1,0,5,12,0,0.0,4,10.8,1.4,1.74,0 +Student_03756,1,18,9500,1,4,1,1,3,1,3,4,137.0,126.7,1,0,0,1,0,0,0,18,0,7,8,7,13.6875,0,0,8,9,8,15.622222222222222,0,13.9,-0.3,0.79,0 +Student_03757,1,39,8014,0,1,1,1,37,37,9,9,130.0,120.0,0,0,0,1,0,0,0,58,0,6,14,5,12.4,0,0,6,10,5,11.6,0,9.4,-0.8,-3.12,2 +Student_03759,1,NA,9085,1,1,1,1,1,1,4,3,130.0,130.0,1,0,0,1,0,0,0,20,0,6,13,5,11.8,0,0,6,19,4,12.0,0,12.4,0.5,1.79,1 +Student_03760,1,17,9991,0,1,1,1,38,37,6,7,140.0,127.3,0,0,0,1,0,0,0,20,0,5,0,0,0.0,0,0,5,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03761,1,2,9147,1,1,1,1,37,37,9,9,150.0,122.0,1,0,0,1,0,0,0,29,13,15,19,13,11.76923076923077,0,12,14,17,14,11.928571428571429,0,9.4,-0.8,-3.12,2 +Student_03762,1,7,9238,1,1,3,1,1,1,4,10,130.0,125.1,0,0,1,0,0,0,0,27,0,6,8,0,0.0,0,0,5,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_03765,1,17,9238,1,1,1,1,19,38,3,7,125.0,114.9,0,0,0,1,0,1,0,19,0,6,13,6,11.5,0,0,6,9,5,12.2,0,11.1,0.6,2.02,2 +Student_03766,1,1,9500,1,1,1,1,37,38,6,6,141.0,125.6,1,0,0,1,0,1,0,22,0,7,9,6,13.081666666666669,0,0,8,12,6,13.15,0,11.1,0.6,2.02,2 +Student_03767,1,18,9070,1,3,1,1,38,37,9,7,138.0,125.1,1,0,0,1,0,1,0,19,0,6,6,6,12.666666666666666,0,0,6,6,6,NA,0,15.5,2.8,-4.06,2 +Student_03768,1,17,9773,1,1,1,1,37,1,9,8,116.0,115.7,1,0,1,0,0,0,0,19,0,6,6,3,11.333333333333334,0,0,6,6,0,0.0,0,12.4,0.5,1.79,0 +Student_03769,1,1,9853,1,3,1,1,3,3,2,2,122.0,112.6,1,0,0,1,0,0,0,23,0,6,8,5,13.6,0,0,6,8,5,11.6,0,7.6,2.6,0.32,1 +Student_03770,1,1,9773,1,3,1,1,1,1,4,4,131.0,127.2,1,0,0,1,0,1,0,18,0,6,6,6,13.166666666666666,0,0,6,7,5,13.2,0,12.4,0.5,1.79,0 +Student_03771,1,44,9130,1,1,39,1,1,19,4,8,140.0,140.0,0,0,0,1,NA,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03772,1,44,9003,1,1,39,1,1,1,4,3,140.0,140.0,1,0,0,1,0,0,0,20,0,6,10,5,11.666666666666666,0,0,6,7,5,12.6,0,12.4,0.5,1.79,2 +Student_03774,1,39,9085,1,1,19,1,37,37,9,9,133.1,100.0,1,0,1,0,0,1,0,26,0,6,7,0,0.0,0,0,6,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_03777,1,44,9003,1,1,39,1,3,1,2,6,160.0,160.0,1,0,0,0,0,0,0,20,0,6,10,6,13.375,0,0,6,10,6,13.0,0,16.2,0.3,-0.92,2 +Student_03778,1,1,9070,1,1,1,1,19,2,7,3,128.0,126.3,1,0,0,1,0,0,0,19,0,6,6,6,13.166666666666666,0,0,6,6,6,12.666666666666666,0,15.5,2.8,-4.06,2 +Student_03780,1,43,9556,1,1,1,1,2,3,3,2,126.0,100.0,0,0,0,1,0,0,0,25,2,7,10,3,13.0,0,1,8,10,3,11.666666666666666,4,10.8,1.4,1.74,1 +Student_03782,1,1,9070,1,3,1,1,1,38,4,7,139.0,142.2,1,0,0,1,0,1,0,19,0,6,6,6,12.833333333333334,0,0,6,6,6,12.833333333333334,0,9.4,-0.8,-3.12,2 +Student_03783,1,17,9853,1,2,1,1,1,19,5,5,125.0,119.4,1,0,0,1,0,0,0,18,0,7,10,7,NA,0,0,7,7,7,13.142857142857142,0,12.4,0.5,1.79,2 +Student_03784,1,1,9500,1,2,1,1,1,19,4,4,106.0,106.4,1,0,0,1,0,1,0,19,0,7,9,5,13.34,0,0,7,9,6,12.385714285714286,0,12.4,0.5,1.79,1 +Student_03785,1,7,8014,0,1,40,1,37,19,9,3,120.0,120.0,0,0,0,1,0,0,0,36,6,10,15,4,13.0,0,5,9,10,4,13.75,0,8.9,1.4,3.51,0 +Student_03786,1,44,9003,1,1,39,1,1,38,4,9,150.0,150.0,0,0,0,1,1,1,0,20,0,6,18,3,12.0,0,0,6,17,3,11.666666666666666,0,15.5,2.8,-4.06,1 +Student_03787,1,NA,171,1,2,1,41,1,1,2,3,130.0,148.6,1,0,0,1,1,0,1,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03789,1,44,9003,1,1,39,1,3,1,4,6,130.0,130.0,0,0,0,1,1,0,0,19,0,6,8,5,11.5,0,0,6,11,6,11.333333333333334,0,12.4,0.5,1.79,1 +Student_03790,1,17,9238,1,1,1,NA,1,44,4,2,140.0,124.6,1,0,1,0,1,0,0,20,3,9,9,3,13.333333333333334,0,2,6,6,2,12.5,0,8.9,1.4,3.51,0 +Student_03792,1,44,9130,1,1,39,1,3,1,3,6,130.0,130.0,1,0,1,1,1,0,0,20,2,6,9,4,11.0,0,1,6,13,3,10.666666666666666,0,12.4,0.5,1.79,0 +Student_03793,1,18,9119,1,1,1,1,19,1,90,3,122.0,116.1,1,0,1,0,1,0,0,24,0,5,8,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03794,1,17,9773,1,1,1,1,19,38,5,7,128.0,125.6,1,0,0,1,1,0,0,19,0,6,6,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_03795,1,17,9119,1,1,1,1,19,19,7,9,130.0,121.3,1,0,0,1,1,0,0,18,0,5,9,1,12.0,0,0,5,10,2,12.0,3,7.6,2.6,0.32,0 +Student_03796,1,1,9119,1,3,1,1,4,38,2,7,113.0,107.4,1,0,0,1,1,0,0,18,0,5,8,5,14.0,0,0,5,6,5,13.2,0,8.9,1.4,3.51,2 +Student_03797,1,1,9254,1,1,1,1,1,19,4,4,126.0,116.9,0,0,0,1,1,0,0,18,0,6,8,6,13.571428571428571,0,0,6,7,5,11.8,0,8.9,1.4,3.51,2 +Student_03798,1,43,9670,1,2,1,1,3,19,1,7,135.0,123.5,1,0,0,1,1,0,0,22,0,6,12,0,0.0,0,0,6,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_03799,1,1,9670,1,1,1,1,19,38,9,9,141.0,130.5,0,0,0,1,1,0,0,19,0,6,8,6,14.25,0,0,6,7,6,13.857142857142858,0,11.1,0.6,2.02,2 +Student_03801,1,17,9853,1,1,1,1,34,19,0,3,133.1,117.1,1,0,0,1,0,1,0,21,0,6,12,0,0.0,0,0,6,12,0,0.0,0,7.6,2.6,0.32,0 +Student_03802,1,18,9500,1,1,1,1,37,37,6,6,144.0,127.5,1,0,0,1,0,1,0,19,0,8,8,7,13.542857142857144,0,0,8,8,7,13.542857142857144,0,12.7,3.7,-1.7,2 +Student_03803,4,43,8014,0,1,1,1,38,37,9,9,140.0,126.0,0,0,0,1,0,1,0,39,3,9,9,9,13.11111111111111,0,2,7,10,7,11.714285714285714,0,12.7,3.7,-1.7,2 +Student_03804,1,43,8014,0,1,10,1,34,34,0,0,100.0,113.0,1,0,0,1,0,0,0,30,3,9,11,9,12.666666666666666,0,2,7,7,7,12.142857142857142,0,7.6,2.6,0.32,2 +Student_03805,1,1,9147,1,1,1,1,1,19,5,5,135.0,130.1,1,0,0,1,0,0,0,18,0,5,10,4,10.75,1,0,5,13,2,10.0,0,9.4,-0.8,-3.12,0 +Student_03806,2,43,9991,0,1,1,1,37,37,9,9,130.0,NA,1,0,0,1,0,0,0,38,4,10,14,4,10.75,0,2,10,10,2,10.0,0,7.6,2.6,0.32,0 +Student_03807,1,1,9070,1,3,1,1,34,37,5,7,147.0,NA,1,0,0,1,0,0,0,20,0,6,6,6,13.666666666666666,0,0,6,6,6,13.333333333333334,0,NA,-0.8,-3.12,2 +Student_03808,1,39,8014,0,1,19,1,34,34,0,0,149.0,126.3,0,0,0,1,0,0,0,55,0,6,6,6,13.833333333333334,0,1,6,6,6,12.833333333333334,0,7.6,2.6,0.32,2 +Student_03809,4,27,9070,1,1,2,1,34,34,0,0,130.0,130.0,0,0,0,1,0,0,0,53,15,18,18,17,13.176470588235292,0,13,18,18,16,NA,0,7.6,2.6,0.32,0 +Student_03810,2,39,8014,0,1,1,1,34,34,0,0,NA,104.0,0,0,0,1,0,0,0,54,0,6,8,4,NA,0,0,6,12,5,12.6,0,7.6,2.6,0.32,0 +Student_03811,1,43,9500,1,1,1,1,37,37,9,7,125.0,123.6,1,0,0,1,0,1,0,18,0,7,8,5,12.86,0,0,7,8,5,12.86,0,7.6,2.6,0.32,1 +Student_03812,1,39,8014,0,1,1,1,37,37,9,8,133.1,121.0,0,0,1,0,0,0,0,44,2,8,12,4,12.0,2,2,7,9,4,12.0,2,8.9,1.4,3.51,0 +Student_03813,1,43,9238,1,1,1,1,37,37,9,6,149.0,130.5,1,0,0,1,0,0,0,28,8,11,11,9,11.666666666666666,0,8,11,13,9,12.555555555555555,0,10.8,1.4,1.74,2 +Student_03814,1,7,8014,0,1,43,1,19,19,9,4,180.0,180.0,0,0,0,1,0,0,0,37,12,14,14,14,16.5,0,8,11,11,11,16.90909090909091,0,8.9,1.4,3.51,2 +Student_03815,1,43,9238,1,1,1,1,14,14,90,90,110.0,112.5,1,0,0,1,0,0,0,20,8,10,14,9,12.333333333333334,0,3,7,10,7,11.77777777777778,0,7.6,2.6,0.32,2 +Student_03816,1,1,9500,1,3,1,1,19,3,3,2,131.0,126.1,1,0,0,1,0,0,0,18,0,7,8,7,12.59125,0,0,8,11,7,12.820000000000002,0,15.5,2.8,-4.06,1 +Student_03817,1,1,9238,1,1,1,1,19,19,9,9,117.0,111.8,1,0,0,1,1,0,0,NA,0,6,9,4,11.5,0,0,6,12,3,11.0,0,8.9,1.4,3.51,0 +Student_03818,1,17,9003,1,1,1,1,38,37,5,9,120.0,131.4,1,0,0,1,1,1,0,23,17,18,19,18,11.894736842105264,0,12,13,13,13,12.923076923076923,0,15.5,2.8,-4.06,2 +Student_03819,1,17,9238,1,1,1,1,19,37,6,6,160.0,144.3,0,0,0,1,1,0,0,22,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_03822,1,39,9003,1,1,1,1,1,38,5,6,160.0,168.6,0,0,0,1,1,0,0,26,0,6,9,0,0.0,0,0,6,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_03824,1,44,9130,1,1,39,1,38,19,9,9,130.0,150.0,0,0,0,1,1,0,0,24,2,6,8,4,11.75,0,1,6,8,2,13.5,0,11.1,0.6,2.02,0 +Student_03825,1,1,9119,1,1,1,1,1,38,4,3,142.0,129.8,1,0,0,1,1,0,0,18,0,5,5,0,0.0,0,0,5,6,1,15.0,0,10.8,1.4,1.74,1 +Student_03826,1,1,171,1,1,1,NA,1,38,7,8,130.0,135.6,1,0,0,1,1,0,0,26,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03831,1,1,9500,1,3,1,1,1,1,4,4,143.0,129.0,1,0,0,1,1,0,0,18,0,8,8,7,12.365714285714288,0,0,8,8,7,12.365714285714288,0,10.8,1.4,1.74,2 +Student_03832,1,17,9670,1,1,1,1,37,37,9,9,128.0,135.7,1,0,0,1,1,0,0,19,0,6,7,5,13.2,0,0,6,10,5,13.25,0,10.8,1.4,1.74,1 +Student_03833,1,43,9070,1,1,1,1,37,37,9,9,100.0,108.0,1,0,0,1,1,0,0,34,7,12,12,7,11.428571428571429,0,4,12,12,7,11.857142857142858,0,7.6,2.6,0.32,1 +Student_03834,1,1,9238,1,1,1,1,38,19,8,10,116.0,110.8,1,0,0,1,1,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_03835,1,1,NA,1,1,1,1,1,19,4,4,128.0,124.5,0,0,0,1,1,1,0,19,0,6,10,4,14.0,0,0,6,9,6,12.333333333333334,0,9.4,-0.8,-3.12,2 +Student_03836,2,39,9003,1,1,1,1,2,2,1,4,120.0,100.0,0,0,0,1,1,0,0,30,3,12,12,3,12.0,0,5,12,16,5,11.8,0,15.5,2.8,-4.06,0 +Student_03837,1,43,9773,1,1,1,1,1,3,9,3,121.0,123.8,0,0,0,0,1,0,0,22,0,4,4,0,0.0,4,0,5,8,3,12.0,0,10.8,1.4,1.74,0 +Student_03838,1,17,9147,1,1,1,1,3,38,1,9,137.0,131.4,0,0,0,0,1,0,0,19,0,5,13,4,10.0,0,0,5,7,3,11.333333333333334,0,15.5,2.8,-4.06,0 +Student_03839,1,1,9147,1,1,1,1,38,1,9,8,115.0,118.5,0,0,0,1,1,0,0,21,0,5,9,1,10.0,0,0,5,10,1,10.0,0,7.6,2.6,0.32,0 +Student_03840,1,1,171,1,2,1,1,37,37,9,9,129.0,122.0,1,0,0,0,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,0 +Student_03841,1,1,9254,1,1,1,1,37,37,9,9,125.0,122.9,0,0,0,1,1,1,0,19,0,6,7,6,11.166666666666666,0,0,6,12,3,11.666666666666666,0,10.8,1.4,1.74,1 +Student_03842,1,1,9238,1,1,1,1,19,38,7,7,125.0,118.7,0,0,0,1,1,0,0,20,0,6,12,4,11.75,0,0,6,13,3,11.333333333333334,0,15.5,2.8,-4.06,1 +Student_03843,1,39,9003,1,1,19,1,3,1,2,8,133.1,100.0,1,0,0,1,1,0,0,35,0,6,13,3,11.75,0,0,6,10,0,0.0,0,13.9,-0.3,0.79,0 +Student_03844,1,16,9147,1,2,1,1,37,37,9,9,131.0,135.9,1,0,0,1,1,0,0,20,0,5,8,1,10.0,0,0,5,7,1,11.0,0,7.6,2.6,0.32,0 +Student_03845,1,1,9130,1,1,1,1,6,11,4,5,133.1,138.4,0,0,0,1,1,0,0,21,0,5,8,3,14.0,0,0,5,5,5,12.8,0,7.6,2.6,0.32,2 +Student_03847,1,43,9773,1,1,1,1,37,38,9,5,114.0,107.4,1,0,0,0,1,0,0,26,0,6,12,3,12.0,0,0,6,15,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03848,1,17,9773,1,1,1,1,1,33,3,3,127.0,129.8,0,0,0,0,1,0,0,20,0,6,10,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_03849,1,39,9003,1,1,1,1,37,37,6,6,130.0,100.0,0,0,1,0,1,0,0,28,4,10,19,8,11.88888888888889,0,2,8,17,5,11.6,1,15.5,2.8,-4.06,0 +Student_03850,1,1,9773,1,3,1,1,19,38,9,7,121.0,113.0,1,0,0,1,1,0,0,19,0,6,6,6,13.833333333333334,0,0,6,6,6,13.666666666666666,0,11.1,0.6,2.02,2 +Student_03851,1,43,9991,0,1,1,1,37,19,9,9,120.0,107.0,0,0,0,0,1,0,0,47,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_03852,4,39,9773,1,1,12,1,37,37,4,9,120.0,130.0,0,0,0,0,1,0,0,55,0,6,8,5,11.4,0,0,6,9,5,12.4,0,10.8,1.4,1.74,0 +Student_03853,1,43,9003,1,1,1,1,37,37,5,9,120.0,120.0,1,0,0,1,1,0,0,39,0,6,8,0,NA,0,1,6,8,2,11.0,0,16.2,0.3,-0.92,0 +Student_03854,2,1,9003,1,1,1,1,37,37,9,9,120.0,120.5,1,0,1,1,1,0,0,35,14,17,17,14,10.642857142857142,1,12,12,12,12,10.666666666666666,0,15.5,2.8,-4.06,0 +Student_03856,1,1,9773,1,4,1,1,3,12,2,9,124.0,137.0,1,0,0,1,NA,0,0,20,0,6,6,6,16.833333333333332,0,0,6,6,6,16.666666666666668,0,8.9,1.4,3.51,2 +Student_03858,1,39,9991,0,1,19,1,38,19,9,10,133.1,142.7,0,0,1,1,1,1,0,34,0,5,11,5,14.714285714285714,0,0,5,14,5,14.375,5,16.2,0.3,-0.92,2 +Student_03861,1,39,9003,1,1,19,1,37,19,9,7,133.1,134.3,0,0,0,1,1,0,0,25,0,6,15,1,11.0,0,0,6,13,4,11.75,0,12.4,0.5,1.79,0 +Student_03862,1,18,9773,1,1,1,1,38,38,6,7,167.0,153.0,1,0,0,1,1,1,0,18,0,6,6,1,11.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_03863,1,1,9773,1,1,1,1,19,38,9,9,140.0,132.0,0,0,0,1,1,1,0,18,0,6,6,5,12.0,0,0,6,6,6,12.833333333333334,0,12.7,3.7,-1.7,2 +Student_03865,1,43,9085,1,1,1,1,3,19,4,6,110.0,105.0,0,0,1,0,1,0,0,34,2,6,13,3,11.333333333333334,0,0,6,8,2,11.5,0,13.9,-0.3,0.79,0 +Student_03866,1,17,9773,1,2,1,1,1,1,4,5,150.0,130.8,0,0,0,1,1,0,0,20,0,6,15,2,12.0,0,0,6,12,0,0.0,0,10.8,1.4,1.74,0 +Student_03867,1,1,9500,1,1,1,1,37,37,7,7,123.0,119.7,0,0,0,1,1,0,0,20,0,7,8,0,0.0,1,0,7,7,0,0.0,0,13.9,-0.3,0.79,0 +Student_03868,1,17,9500,1,1,1,1,19,19,4,9,152.0,132.5,0,0,0,1,1,0,0,21,0,8,8,7,14.54,0,0,8,8,7,14.54,0,10.8,1.4,1.74,2 +Student_03869,1,44,9003,1,1,39,1,1,19,3,10,130.0,130.0,1,0,0,1,1,0,0,19,0,6,9,6,12.166666666666666,0,0,6,14,4,13.0,0,12.4,0.5,1.79,2 +Student_03870,1,39,9085,1,1,1,1,1,1,4,4,133.1,120.0,0,0,1,0,1,0,0,31,0,5,13,4,13.5,1,0,5,12,3,11.666666666666666,1,9.4,-0.8,-3.12,0 +Student_03871,1,17,9670,1,1,1,1,1,37,4,5,133.1,150.0,0,0,0,1,1,0,0,21,0,6,8,6,14.75,0,0,6,9,5,14.333333333333334,0,11.1,0.6,2.02,2 +Student_03872,1,1,9147,1,1,1,1,38,38,9,9,124.0,115.6,0,0,0,1,1,1,0,20,0,5,8,5,12.375,0,0,5,7,5,11.666666666666666,0,13.9,-0.3,0.79,2 +Student_03873,1,43,9500,1,2,6,NA,1,19,4,10,119.1,119.1,0,0,0,1,1,0,0,22,0,7,7,6,12.733333333333334,0,0,7,7,6,12.733333333333334,0,7.6,2.6,0.32,2 +Student_03874,1,1,9070,1,2,1,1,19,19,3,3,128.0,123.5,1,1,0,0,1,0,0,19,0,6,9,4,12.5,0,0,6,6,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03875,1,39,9130,1,1,1,NA,1,1,90,1,133.1,120.0,1,0,1,0,1,0,0,41,0,5,5,0,0.0,1,0,5,5,0,0.0,5,12.7,3.7,-1.7,0 +Student_03876,1,43,9500,1,1,19,1,34,34,0,0,133.1,110.0,1,0,0,1,1,0,0,27,0,7,7,0,0.0,6,0,7,7,0,0.0,6,7.6,2.6,0.32,0 +Student_03877,1,17,9500,1,1,1,1,1,1,4,10,NA,131.4,0,0,0,1,0,0,0,19,0,7,7,7,13.44285714285714,0,0,8,8,7,13.771428571428572,0,NA,-0.3,0.79,0 +Student_03879,1,43,9500,1,4,6,1,38,37,5,9,118.9,118.9,1,0,0,1,0,1,0,19,0,7,7,6,13.55,0,0,7,7,6,13.55,0,7.6,2.6,0.32,2 +Student_03880,2,39,9991,0,1,1,1,37,37,9,9,160.0,160.0,0,0,0,1,0,0,0,35,0,5,5,5,NA,0,0,5,6,5,11.166666666666666,0,15.5,2.8,-4.06,2 +Student_03881,1,17,9773,1,5,1,1,19,12,7,3,111.0,115.9,1,0,0,1,0,0,0,22,0,6,7,6,13.571428571428571,0,0,6,7,6,15.285714285714286,0,13.9,-0.3,0.79,2 +Student_03883,1,1,9670,1,1,1,1,37,38,9,9,123.0,113.9,1,0,1,0,0,0,0,18,0,6,7,4,11.25,0,0,6,9,4,10.857142857142858,0,10.8,1.4,1.74,0 +Student_03884,1,1,9238,1,1,1,1,37,37,9,9,133.0,121.8,1,0,0,1,0,1,0,18,0,6,7,5,10.2,0,0,6,9,4,11.25,0,12.4,0.5,1.79,2 +Student_03885,1,7,9500,1,1,3,1,1,37,9,5,140.0,140.0,0,0,0,1,0,0,0,30,0,8,8,7,15.675714285714283,0,0,8,8,7,15.675714285714283,0,10.8,1.4,1.74,2 +Student_03889,1,17,9085,1,1,1,1,38,38,5,3,139.0,NA,0,0,0,1,0,0,0,19,0,5,7,5,13.0,1,0,5,7,5,13.333333333333334,0,7.6,2.6,0.32,2 +Student_03890,1,1,9556,1,2,1,1,1,38,3,8,130.0,119.5,1,0,0,1,0,1,0,21,0,7,7,7,12.242857142857144,0,0,8,8,8,14.125,0,15.5,2.8,-4.06,2 +Student_03891,1,18,9853,1,1,1,1,1,19,141,182,133.1,106.0,1,0,1,1,0,0,0,21,0,7,7,7,13.0,0,0,7,8,6,12.5,0,8.9,1.4,3.51,1 +Student_03892,1,1,9670,1,4,1,1,1,1,9,9,130.0,124.1,1,0,0,1,0,0,0,18,0,6,6,6,14.166666666666666,0,0,6,7,6,13.428571428571429,0,8.9,1.4,3.51,1 +Student_03893,1,1,9147,1,3,1,1,1,1,5,7,143.0,NA,1,0,0,1,0,1,0,18,0,5,11,4,14.25,0,0,5,7,4,12.5,0,12.7,3.7,-1.7,2 +Student_03894,4,39,9085,1,1,NA,1,37,37,90,90,110.0,110.0,0,0,0,0,0,0,0,35,0,5,14,1,12.0,2,0,5,11,2,10.5,1,9.4,-0.8,-3.12,0 +Student_03896,1,1,9500,1,1,1,1,38,37,9,7,140.0,130.0,1,0,0,1,1,1,0,18,0,7,7,6,13.183333333333332,0,0,7,7,6,13.183333333333332,0,7.6,2.6,0.32,2 +Student_03897,1,17,9070,1,5,1,1,19,1,5,5,125.0,122.6,1,0,0,1,1,0,0,22,0,6,6,1,11.0,0,0,6,6,0,0.0,0,9.4,-0.8,-3.12,1 +Student_03899,2,39,9254,1,1,1,1,37,37,4,7,130.0,120.0,1,0,0,1,0,0,0,34,0,6,7,5,12.4,0,0,6,8,5,12.8,0,9.4,-0.8,-3.12,2 +Student_03900,2,7,9147,1,1,3,1,37,37,9,9,120.0,120.0,0,0,0,1,0,0,0,33,3,8,9,5,12.6,2,2,7,13,5,11.25,0,10.8,1.4,1.74,1 +Student_03901,1,1,9500,1,3,1,1,37,38,9,9,142.0,137.3,1,0,0,1,0,1,0,22,0,7,7,6,13.9,0,0,7,7,6,13.9,0,NA,2.6,0.32,2 +Student_03903,2,39,9147,1,1,1,1,37,37,6,10,140.0,131.8,0,0,0,1,0,0,0,35,0,5,6,4,14.2,0,0,5,10,4,11.857142857142858,0,10.8,1.4,1.74,1 +Student_03904,2,39,9147,1,1,1,1,38,37,4,7,140.0,130.0,1,0,0,0,0,0,0,39,0,5,12,3,10.666666666666666,2,0,5,15,3,10.666666666666666,0,9.4,-0.8,-3.12,0 +Student_03905,1,18,9500,1,6,1,1,38,37,9,5,142.0,128.0,1,0,0,0,0,0,0,19,0,7,14,0,0.0,0,0,8,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03906,4,39,9254,1,1,1,1,NA,37,9,8,120.0,95.0,0,0,0,1,0,1,0,36,0,6,10,6,11.0,0,0,6,14,3,11.333333333333334,0,10.8,1.4,1.74,2 +Student_03908,1,1,9238,1,1,1,1,3,38,1,5,157.0,136.7,1,0,0,1,0,0,0,NA,0,6,11,4,12.5,1,0,6,13,3,13.666666666666666,0,9.4,-0.8,-3.12,1 +Student_03910,1,39,9119,1,1,1,1,37,37,90,90,110.0,108.4,1,0,0,1,0,0,0,34,0,5,5,0,0.0,0,0,5,6,0,0.0,0,10.8,1.4,1.74,0 +Student_03911,1,17,9773,1,1,1,1,19,19,4,4,144.0,130.7,1,0,0,1,0,0,0,20,0,6,9,6,11.666666666666666,0,0,6,8,5,11.6,0,7.6,2.6,0.32,1 +Student_03912,2,44,8014,0,1,39,1,37,19,9,10,160.0,155.9,0,0,0,1,0,0,0,33,3,6,7,6,15.714285714285714,0,2,6,7,6,15.5,0,13.9,-0.3,0.79,2 +Student_03913,1,1,9254,1,4,1,1,1,19,9,6,105.0,106.1,1,0,0,1,0,0,0,20,0,6,8,5,11.0,0,0,6,9,5,11.4,0,13.9,-0.3,0.79,2 +Student_03915,2,43,9991,0,1,3,1,37,19,9,4,140.0,140.0,0,0,1,1,0,0,0,34,4,10,25,5,12.2,0,3,9,18,8,12.22222222222222,0,16.2,0.3,-0.92,0 +Student_03916,1,1,9147,1,1,1,1,37,37,9,6,138.0,145.0,1,0,0,1,0,0,0,18,0,5,6,5,13.0,0,0,5,5,5,14.0,0,7.6,2.6,0.32,2 +Student_03917,1,17,8014,0,1,1,1,38,37,6,6,120.0,113.0,0,0,0,1,0,1,0,24,0,6,11,4,12.0,0,0,6,7,6,13.0,0,10.8,1.4,1.74,2 +Student_03919,1,1,9670,1,1,1,1,37,37,10,6,119.0,119.7,1,0,0,1,0,0,0,20,0,5,6,3,13.0,0,0,5,7,3,13.0,1,7.6,2.6,0.32,1 +Student_03920,1,17,9500,1,1,1,1,1,1,4,3,121.0,120.5,1,0,0,1,0,0,0,21,0,8,8,7,12.91,0,0,8,8,7,12.91,0,10.8,1.4,1.74,2 +Student_03921,1,1,9238,1,5,1,1,38,1,9,5,126.0,125.7,1,0,0,1,0,1,0,19,0,6,8,6,11.0,0,0,6,13,3,11.0,0,9.4,-0.8,-3.12,2 +Student_03922,1,17,9500,1,4,1,1,38,19,5,7,132.0,125.5,0,0,0,1,0,1,0,19,0,7,8,6,13.579999999999998,0,0,8,8,8,12.93625,0,15.5,2.8,NA,2 +Student_03923,1,1,9238,1,1,1,1,19,19,5,5,128.0,124.5,1,0,0,1,0,1,0,18,0,6,10,4,12.4,0,0,6,8,6,12.5,0,12.4,0.5,1.79,2 +Student_03924,4,39,8014,0,1,1,1,37,37,5,5,160.0,126.0,0,0,0,1,0,1,0,38,4,9,13,8,12.88888888888889,0,2,7,9,7,13.0,0,13.9,-0.3,0.79,2 +Student_03925,1,1,171,1,1,1,1,19,19,5,4,125.0,136.2,1,0,1,1,1,0,0,21,6,12,12,11,11.545454545454543,0,4,11,18,9,11.7,1,8.9,1.4,3.51,1 +Student_03926,1,43,9147,1,1,1,25,1,5,9,10,127.0,124.2,1,0,0,1,1,0,1,23,0,5,6,1,10.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,1 +Student_03927,1,17,9500,1,5,1,1,19,1,4,3,147.0,138.5,1,0,0,1,0,0,0,19,0,8,8,8,14.34125,0,0,8,8,8,14.34125,0,9.4,-0.8,-3.12,2 +Student_03928,1,1,9773,1,2,1,1,38,37,5,3,130.0,122.3,1,0,1,0,0,0,0,18,0,6,8,6,14.142857142857142,0,0,6,6,5,12.0,0,13.9,-0.3,0.79,0 +Student_03929,1,1,171,1,6,1,1,19,37,5,5,134.0,126.0,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_03930,1,39,9003,1,1,1,1,19,19,9,6,140.0,135.4,1,0,0,1,0,0,0,24,0,6,10,5,11.8,0,0,6,13,4,11.25,0,12.4,0.5,1.79,1 +Student_03931,1,1,9773,1,1,1,2,1,1,5,9,151.0,146.5,0,0,0,1,0,1,1,18,0,6,6,6,13.333333333333334,0,0,6,6,6,14.166666666666666,0,12.7,3.7,-1.7,2 +Student_03932,1,1,9130,1,1,1,1,3,1,4,9,132.0,121.9,1,0,0,1,0,0,0,18,0,6,8,6,14.5,0,0,6,9,6,12.857142857142858,0,13.9,-0.3,0.79,2 +Student_03935,1,18,9670,1,3,1,1,38,38,9,9,119.0,115.2,1,0,0,1,0,1,0,19,0,6,10,0,0.0,0,0,6,6,0,0.0,0,12.7,3.7,-1.7,0 +Student_03938,1,1,9254,1,3,1,1,19,19,9,9,121.0,125.9,1,0,0,1,0,0,0,22,0,6,10,4,10.0,0,0,6,12,2,13.5,0,9.4,-0.8,-3.12,1 +Student_03939,1,1,9500,1,2,1,1,19,1,5,5,138.0,128.0,1,0,0,1,0,0,0,19,0,7,7,7,14.20857142857143,0,0,8,9,8,15.127777777777778,0,11.1,0.6,2.02,2 +Student_03940,1,1,9500,1,5,1,1,3,1,5,10,118.0,113.5,1,0,0,1,0,0,0,20,0,7,7,7,14.30714285714286,0,0,8,8,8,15.0125,0,12.4,0.5,1.79,2 +Student_03942,1,39,9853,1,1,19,1,19,4,9,4,133.1,116.0,1,0,0,1,0,0,0,29,0,7,14,0,0.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_03943,1,17,9238,1,3,1,1,3,3,2,2,141.0,124.9,1,0,0,1,0,0,0,19,0,6,10,6,12.0,0,0,6,12,4,11.0,0,12.7,3.7,-1.7,2 +Student_03946,1,17,9773,1,1,1,1,37,37,9,8,115.0,116.1,1,0,0,1,0,1,0,18,0,6,7,6,13.857142857142858,0,0,6,7,6,14.285714285714286,0,13.9,-0.3,0.79,2 +Student_03947,1,17,171,1,2,1,1,3,1,2,6,142.0,139.4,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,2 +Student_03948,1,17,9556,1,4,1,1,38,37,3,7,135.0,129.0,1,0,0,1,0,0,0,21,0,7,0,0,0.0,0,0,7,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03949,2,39,9670,1,1,1,1,37,19,9,4,150.0,135.6,0,0,0,1,0,1,0,43,0,6,8,5,11.0,0,0,6,9,5,13.0,0,12.4,0.5,1.79,2 +Student_03951,1,18,9085,1,1,1,1,37,37,9,9,153.0,138.0,1,0,0,1,0,1,0,21,0,6,7,6,13.5,0,0,6,6,3,15.333333333333334,0,8.9,1.4,3.51,0 +Student_03952,1,7,9147,1,1,3,1,6,27,1,7,150.0,150.0,0,0,0,1,0,0,0,26,0,5,5,0,0.0,0,0,5,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03953,1,1,9500,1,6,1,1,1,19,9,4,144.0,130.8,1,0,0,1,0,1,0,19,0,8,8,7,14.214285714285714,0,0,8,8,7,14.214285714285714,0,12.7,3.7,-1.7,2 +Student_03954,1,1,9085,1,1,1,1,37,11,90,90,130.0,122.6,0,0,0,1,0,0,0,18,0,5,5,5,13.0,0,0,5,5,5,12.4,0,7.6,2.6,0.32,2 +Student_03955,1,1,9773,1,1,1,1,3,2,2,1,125.0,119.1,1,0,0,1,0,0,0,22,0,6,13,2,12.0,0,0,6,14,1,10.0,0,9.4,-0.8,-3.12,0 +Student_03957,1,1,9147,1,3,1,1,38,19,9,10,133.0,125.0,1,0,0,1,0,0,0,18,0,5,6,5,12.8,1,0,5,6,5,12.6,0,9.4,-0.8,-3.12,2 +Student_03958,1,17,9085,1,1,1,1,37,38,7,9,140.0,129.9,0,0,0,1,0,0,0,19,0,5,11,4,13.6,2,0,5,9,4,12.2,0,9.4,-0.8,-3.12,2 +Student_03959,1,17,9500,1,4,1,1,19,19,3,10,133.0,131.1,1,0,0,1,0,0,0,18,0,7,7,7,13.971428571428572,0,0,8,8,8,15.75,0,13.9,-0.3,0.79,2 +Student_03960,1,1,9085,1,1,1,1,38,37,4,4,154.0,141.4,0,0,0,1,0,1,0,19,0,6,8,6,15.0,0,0,6,9,6,14.857142857142858,0,11.1,0.6,2.02,2 +Student_03961,1,39,9085,1,1,1,1,37,37,9,9,133.1,120.0,0,0,0,0,0,0,0,32,0,6,0,0,0.0,0,0,6,0,0,NA,0,11.1,0.6,2.02,0 +Student_03963,1,17,9500,1,3,1,1,37,37,4,3,132.0,127.3,1,0,0,1,0,0,0,20,0,7,7,6,13.383333333333333,0,0,7,7,6,13.383333333333333,0,7.6,2.6,0.32,2 +Student_03965,1,17,9238,1,1,1,1,19,19,4,5,120.0,114.8,1,0,1,0,0,0,0,19,0,6,10,5,11.714285714285714,0,0,6,13,2,10.666666666666666,0,16.2,0.3,-0.92,0 +Student_03966,1,1,9500,1,3,1,1,19,19,5,5,150.0,132.8,1,0,0,1,0,1,0,18,0,8,8,8,13.01125,0,0,8,8,8,13.01125,0,9.4,-0.8,-3.12,2 +Student_03968,1,1,9500,1,1,1,1,1,19,9,9,103.0,108.3,0,0,0,1,0,1,0,20,0,7,14,0,0.0,0,0,7,15,0,0.0,0,11.1,0.6,2.02,1 +Student_03969,1,44,9085,1,1,39,1,3,19,2,4,150.0,150.0,1,0,0,1,0,0,0,22,1,6,9,6,13.0,0,1,6,18,3,12.666666666666666,0,12.4,0.5,1.79,2 +Student_03970,1,44,9991,0,1,39,1,37,37,9,9,160.0,NA,0,0,0,1,0,0,0,26,0,5,5,5,12.0,0,0,5,7,5,11.4,0,12.7,3.7,-1.7,2 +Student_03971,1,1,9070,1,1,1,1,37,37,3,3,131.0,131.7,1,0,0,1,0,0,0,20,0,6,6,6,12.166666666666666,0,0,6,7,5,13.8,0,12.7,3.7,-1.7,2 +Student_03972,1,1,9500,1,1,1,1,19,38,5,3,114.0,112.6,1,0,0,1,0,0,0,19,0,7,10,6,11.85,0,0,8,10,7,13.65,0,16.2,0.3,-0.92,2 +Student_03974,1,43,9500,1,3,1,1,1,19,9,7,140.0,127.5,1,0,1,1,0,1,0,20,0,7,9,7,12.327777777777778,0,0,8,10,8,11.736,0,15.5,2.8,-4.06,2 +Student_03975,1,43,9085,1,1,1,1,19,38,7,7,130.0,120.2,1,0,0,1,0,0,0,20,0,5,9,4,12.0,0,0,5,10,5,13.428571428571429,1,10.8,1.4,1.74,2 +Student_03976,1,17,9500,1,4,1,1,37,37,5,5,121.0,118.9,1,0,0,1,0,0,0,21,0,7,7,7,14.428571428571429,0,0,8,9,8,14.511111111111113,0,16.2,0.3,-0.92,2 +Student_03978,1,17,9500,1,2,1,1,37,1,9,4,141.0,127.3,1,0,0,1,0,1,0,19,0,7,7,6,13.8,0,0,7,7,6,13.8,0,7.6,2.6,0.32,2 +Student_03979,1,1,9853,1,1,1,1,NA,19,3,7,131.0,127.9,1,0,0,1,0,1,0,NA,0,7,7,7,14.857142857142858,0,0,7,7,7,15.142857142857142,0,13.9,-0.3,0.79,2 +Student_03981,1,17,9238,1,6,1,1,1,38,4,7,117.0,114.6,0,0,0,1,0,1,0,18,0,6,7,6,12.142857142857142,0,0,6,6,6,13.333333333333334,0,13.9,-0.3,0.79,2 +Student_03983,1,17,9500,1,1,1,1,1,19,4,3,131.0,125.4,1,0,0,1,0,0,0,19,0,7,13,5,12.5,0,0,8,14,7,12.166666666666666,0,15.5,2.8,-4.06,2 +Student_03985,1,39,9003,1,1,1,1,38,38,9,6,135.0,138.1,0,0,1,0,0,0,0,28,0,6,6,0,0.0,0,0,6,7,0,0.0,0,8.9,1.4,3.51,0 +Student_03987,1,1,9773,1,2,1,1,NA,37,9,9,122.0,130.8,1,0,0,1,0,0,0,18,0,6,14,4,11.25,0,0,6,9,5,13.0,0,9.4,-0.8,-3.12,2 +Student_03988,1,1,9500,1,2,1,1,1,1,4,3,155.0,140.5,1,0,0,1,0,0,0,18,0,7,7,6,15.25,0,0,7,7,6,15.25,0,7.6,2.6,0.32,2 +Student_03989,1,1,9085,1,1,1,1,19,37,9,9,123.0,124.1,1,0,0,1,0,1,0,20,0,5,13,5,14.0,2,0,5,10,3,12.0,1,9.4,-0.8,-3.12,2 +Student_03990,1,43,9238,1,1,1,1,38,19,9,4,130.0,118.4,0,0,1,1,0,0,0,28,15,16,16,13,12.076923076923077,0,13,13,13,11,12.090909090909092,0,16.2,0.3,-0.92,2 +Student_03991,1,15,9853,1,1,1,41,43,1,153,135,133.1,128.2,0,0,0,1,0,0,1,23,11,16,17,16,14.625,0,6,10,12,9,14.88888888888889,0,8.9,1.4,3.51,2 +Student_03992,1,1,9853,1,1,1,1,19,37,5,5,114.0,109.5,1,0,0,1,0,0,0,19,0,7,10,4,10.5,0,0,7,7,2,10.5,0,16.2,0.3,-0.92,0 +Student_03993,1,17,9238,1,1,1,1,38,19,152,171,137.0,131.1,1,0,0,1,0,1,0,18,0,6,8,6,12.833333333333334,0,0,6,6,6,12.166666666666666,0,8.9,1.4,3.51,2 +Student_03994,1,1,9773,1,3,1,22,37,37,9,9,161.0,137.9,0,0,1,0,0,1,1,20,0,6,6,6,12.5,0,0,6,7,5,11.8,0,10.8,1.4,1.74,2 +Student_03995,1,1,171,1,1,1,1,3,1,2,4,133.1,128.2,1,0,0,1,0,0,0,20,5,12,13,12,11.23076923076923,0,3,11,18,9,12.77777777777778,0,NA,0.6,2.02,2 +Student_03996,2,39,9991,0,1,1,1,37,37,9,9,133.1,126.5,0,0,0,1,0,0,0,27,0,5,5,2,10.5,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_03998,4,39,9556,1,2,19,1,19,19,4,6,133.1,123.0,0,0,0,1,0,1,0,37,0,7,10,7,10.985714285714286,0,0,8,11,8,12.3,0,10.8,1.4,1.74,2 +Student_03999,4,7,9500,1,1,40,1,19,19,4,6,130.0,130.0,0,0,0,0,0,0,0,42,2,7,10,5,12.62,0,3,7,11,3,14.166666666666666,0,12.4,0.5,1.79,0 +Student_04001,2,39,9119,1,1,1,1,34,34,9,9,140.0,140.0,0,0,0,0,1,0,0,34,0,5,5,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_04002,1,42,9119,1,1,1,1,3,3,3,2,140.0,133.6,1,0,0,1,1,0,0,22,0,5,0,0,0.0,0,0,5,0,0,0.0,0,10.8,1.4,1.74,0 +Student_04003,2,39,9254,1,2,NA,1,19,19,9,5,133.1,123.5,0,0,0,NA,1,0,0,39,0,6,6,6,13.5,0,0,6,6,6,13.333333333333334,0,NA,0.5,1.79,2 +Student_04004,1,1,9500,1,1,1,1,37,37,9,9,141.0,136.3,1,0,0,1,1,1,0,18,0,7,7,6,13.516666666666666,0,0,7,7,6,13.516666666666666,0,7.6,2.6,0.32,2 +Student_04005,1,1,9070,1,2,1,1,37,37,9,9,128.0,123.5,1,0,0,1,1,1,0,21,0,6,6,6,13.166666666666666,0,0,6,8,6,13.285714285714286,0,8.9,1.4,3.51,2 +Student_04007,1,44,9003,1,1,39,1,37,37,9,9,160.0,160.0,0,0,0,1,1,1,0,22,0,6,8,6,13.125,0,0,6,10,6,13.0,0,16.2,0.3,-0.92,2 +Student_04008,1,39,9003,1,1,1,1,1,37,4,7,133.1,110.0,0,0,0,1,1,0,0,31,0,6,15,3,14.4,0,0,6,20,0,0.0,0,16.2,0.3,-0.92,0 +Student_04009,1,18,9853,1,3,1,1,38,37,5,9,128.0,116.8,1,0,0,0,1,0,0,19,0,6,10,4,12.0,0,0,6,12,0,0.0,0,10.8,1.4,1.74,0 +Student_04010,1,17,9254,1,5,1,1,38,1,5,9,114.0,109.5,0,0,0,1,1,0,0,19,0,5,5,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_04012,1,5,9147,1,1,1,1,19,38,5,6,126.0,117.3,1,0,0,1,0,0,0,19,0,5,15,3,10.8,0,0,5,6,3,10.5,0,13.9,-0.3,0.79,1 +Student_04013,2,39,9670,1,2,1,41,37,19,9,9,133.1,130.0,0,0,0,1,0,0,1,30,0,6,0,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_04014,1,51,9500,1,1,1,1,37,38,3,3,129.0,137.8,1,0,0,1,0,1,0,20,2,7,7,7,16.13142857142857,0,0,8,9,8,15.52222222222222,0,11.1,0.6,2.02,2 +Student_04015,1,17,9500,1,1,1,1,19,38,7,7,140.0,136.5,1,0,0,1,0,1,0,18,0,7,7,7,14.838571428571427,0,0,8,9,8,14.8,0,12.4,0.5,1.79,2 +Student_04018,4,39,8014,0,1,1,1,37,37,9,7,133.1,140.0,0,0,0,1,0,1,0,43,0,6,6,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_04019,1,17,9254,1,2,1,1,38,38,9,8,132.0,122.6,1,0,0,1,0,1,0,20,0,6,6,6,13.166666666666666,0,0,6,6,6,14.0,0,13.9,-0.3,0.79,2 +Student_04020,1,1,9500,1,2,1,1,1,1,5,9,131.0,129.5,1,0,0,1,0,1,0,19,0,8,8,8,13.9475,0,0,8,8,8,13.9475,0,9.4,-0.8,-3.12,2 +Student_04021,1,1,9670,1,1,1,1,3,1,1,7,133.1,155.0,0,0,0,1,0,0,0,22,0,5,6,3,11.333333333333334,0,0,5,5,0,0.0,0,NA,-0.8,-3.12,0 +Student_04023,1,18,9147,1,1,1,1,19,19,5,8,160.0,137.6,1,0,0,1,0,1,0,19,0,5,6,5,12.6,0,0,5,8,5,11.25,0,10.8,1.4,1.74,2 +Student_04024,1,7,9500,1,1,3,1,19,3,4,2,120.0,120.0,1,0,0,1,0,0,0,29,0,8,8,6,12.25,1,0,8,8,6,12.25,1,12.7,3.7,-1.7,0 +Student_04025,1,15,9556,1,1,1,26,3,19,122,144,114.0,114.0,0,0,0,1,0,0,1,20,0,7,14,0,0.0,6,0,7,12,2,11.666666666666666,0,8.9,1.4,3.51,1 +Student_04026,4,1,9991,0,1,1,1,37,37,9,7,140.0,139.0,0,0,0,1,0,1,0,38,0,5,8,5,11.0,0,0,5,7,5,11.4,0,9.4,-0.8,-3.12,1 +Student_04027,1,39,9003,1,1,1,1,37,37,9,5,100.0,110.0,0,0,0,1,0,0,0,41,8,12,17,12,11.833333333333334,0,3,12,22,9,12.7,0,15.5,2.8,-4.06,2 +Student_04028,1,1,9500,1,6,1,1,19,38,4,9,139.0,128.5,1,0,0,1,0,0,0,19,0,8,10,6,13.066666666666668,0,0,8,10,6,13.066666666666668,0,12.7,3.7,-1.7,0 +Student_04030,4,7,9500,1,1,3,1,3,19,2,3,130.0,130.0,0,0,0,1,0,0,0,43,0,7,7,3,13.833333333333334,1,0,7,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_04031,1,17,9130,1,1,1,1,38,37,9,7,145.0,129.3,1,0,0,1,0,0,0,19,0,5,5,5,11.8,0,0,5,5,5,13.2,0,10.8,1.4,1.74,2 +Student_04032,1,1,171,1,1,1,1,19,38,9,8,133.1,128.2,1,0,0,1,1,1,0,19,6,12,12,12,13.333333333333334,0,4,11,15,10,12.818181818181818,0,8.9,1.4,3.51,1 +Student_04033,1,1,9500,1,6,1,1,2,19,3,9,146.0,130.3,1,0,0,1,1,0,0,18,0,8,8,8,13.74625,0,0,8,8,8,13.74625,0,9.4,-0.8,-3.12,2 +Student_04034,1,1,171,1,1,1,1,3,3,2,2,159.0,162.5,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_04035,2,39,8014,0,1,19,1,34,34,0,0,133.1,130.0,0,0,0,1,1,0,0,38,0,6,0,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_04036,2,7,9130,1,1,2,1,19,19,4,8,110.0,110.0,1,0,0,1,1,0,0,37,0,6,9,0,0.0,0,0,6,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_04038,1,17,9238,1,1,1,1,37,37,9,9,130.0,122.0,1,0,0,1,0,1,0,21,0,6,8,1,10.0,0,0,6,13,5,11.4,0,12.7,3.7,-1.7,1 +Student_04039,1,1,9085,1,3,1,1,1,19,9,9,158.0,153.6,1,0,0,1,0,1,0,18,0,6,7,6,15.666666666666666,0,0,6,8,6,15.285714285714286,0,8.9,1.4,3.51,2 +Student_04040,1,1,9853,1,1,1,1,3,19,2,3,122.0,112.9,0,0,0,1,0,0,0,18,0,7,9,7,11.857142857142858,0,0,7,7,7,11.857142857142858,0,16.2,0.3,-0.92,2 +Student_04041,1,1,9085,1,1,1,1,3,1,2,4,140.0,124.1,0,0,0,1,0,0,0,18,0,5,12,5,14.5,2,0,5,5,5,13.6,0,9.4,-0.8,-3.12,2 +Student_04042,1,17,9238,1,1,1,1,38,1,9,4,136.0,129.7,0,0,0,1,0,0,0,19,0,6,6,6,12.166666666666666,0,0,6,7,6,13.714285714285714,0,15.5,2.8,-4.06,2 +Student_04043,1,1,NA,1,1,1,1,19,19,9,9,111.0,110.0,1,0,0,1,0,0,0,18,0,6,6,5,12.6,0,0,6,8,6,12.0,0,11.1,0.6,2.02,2 +Student_04044,1,17,9500,1,2,1,1,2,38,3,8,145.0,136.3,1,0,0,1,0,0,0,18,0,8,12,7,12.285714285714286,0,0,8,12,7,12.285714285714286,0,12.7,3.7,-1.7,1 +Student_04045,1,17,9238,1,1,1,1,38,38,191,193,133.1,146.0,0,0,1,1,0,1,0,19,0,6,6,6,12.666666666666666,0,0,6,7,6,13.0,0,8.9,1.4,3.51,2 +Student_04046,1,1,9500,1,1,1,1,19,38,7,8,140.0,129.9,0,0,0,1,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_04047,1,1,9254,1,1,1,1,19,1,9,8,140.0,140.9,1,0,0,1,0,1,0,18,0,6,7,6,12.857142857142858,0,0,6,10,4,13.0,0,12.7,3.7,-1.7,2 +Student_04048,2,1,9500,1,1,1,1,1,1,9,10,156.0,135.5,0,0,0,1,0,0,0,18,0,8,8,7,13.9,0,0,8,8,7,13.9,0,12.7,3.7,-1.7,2 +Student_04050,1,53,9556,1,1,42,1,1,19,4,5,140.0,NA,0,0,0,1,0,1,0,22,1,7,10,6,13.314285714285717,0,2,8,10,7,12.875,0,NA,1.4,3.51,2 +Student_04051,1,1,9130,1,1,1,1,34,1,0,0,164.0,163.0,0,0,0,1,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_04052,1,17,9254,1,4,1,1,38,19,7,7,113.0,107.4,1,0,0,1,0,1,0,19,0,6,6,6,12.166666666666666,0,0,6,6,6,12.166666666666666,0,12.4,0.5,1.79,2 +Student_04053,1,1,9254,1,1,1,1,37,37,9,9,122.0,114.3,1,0,0,0,0,1,0,20,0,6,12,4,11.25,0,0,6,12,3,11.333333333333334,0,7.6,2.6,0.32,0 +Student_04054,1,43,9070,1,1,1,1,2,3,3,2,150.0,140.8,0,0,0,1,0,0,0,19,1,6,6,5,12.4,0,0,6,8,6,12.75,0,10.8,1.4,1.74,1 +Student_04056,1,39,9085,1,1,1,1,3,19,2,9,133.1,110.0,0,0,0,1,0,0,0,28,0,6,15,4,12.0,0,0,6,14,4,12.0,0,11.1,0.6,2.02,0 +Student_04057,1,1,9085,1,2,1,1,1,1,193,101,122.0,126.2,0,0,0,1,0,0,0,19,0,6,8,6,14.0,0,0,6,18,3,12.666666666666666,0,12.4,0.5,1.79,2 +Student_04060,1,1,9773,1,3,1,1,19,19,5,5,130.0,157.0,1,0,0,0,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_04061,1,5,9130,1,1,1,1,5,43,2,2,157.0,149.7,1,0,0,1,0,0,0,18,0,6,6,6,15.0,0,0,6,6,6,14.833333333333334,0,8.9,1.4,3.51,2 +Student_04062,1,43,9130,1,1,1,1,2,1,2,3,140.0,140.0,1,0,0,1,0,0,0,22,0,5,11,4,12.25,0,0,5,9,5,13.285714285714286,0,12.7,3.7,-1.7,2 +Student_04063,1,53,9085,1,1,42,1,1,19,4,7,170.0,170.0,0,0,0,1,0,0,0,20,7,11,13,11,15.692307692307692,0,4,9,9,9,15.555555555555555,0,8.9,1.4,3.51,2 +Student_04065,1,17,171,1,1,1,1,1,38,9,9,146.0,135.5,1,0,1,1,0,0,0,22,12,17,19,12,11.833333333333334,0,10,17,22,11,11.25,0,11.1,0.6,2.02,1 +Student_04066,1,43,8014,0,1,1,1,38,19,5,4,120.0,118.3,0,0,0,1,0,0,0,20,2,6,6,6,12.166666666666666,0,0,6,7,5,14.0,0,12.7,3.7,-1.7,1 +Student_04068,2,7,8014,0,1,3,1,38,1,9,9,120.0,120.0,0,0,0,0,0,0,0,35,0,6,0,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_04069,1,1,9670,1,1,1,1,1,1,5,7,154.0,154.7,0,0,0,1,0,1,0,18,0,5,6,5,11.8,0,0,5,5,5,12.6,0,9.4,-0.8,-3.12,2 +Student_04072,1,1,9254,1,2,1,1,1,38,4,9,130.0,122.7,1,0,0,1,0,0,0,18,0,6,10,4,11.75,0,0,6,13,4,10.0,0,7.6,2.6,0.32,0 +Student_04073,2,39,9238,1,1,19,1,1,2,4,6,133.1,130.0,0,0,0,1,0,0,0,31,0,6,6,6,13.166666666666666,0,0,6,8,6,13.0,0,9.4,-0.8,-3.12,1 +Student_04074,1,17,9238,1,1,1,1,19,19,5,7,133.0,123.6,0,0,0,1,0,1,0,19,0,6,7,6,13.5,0,0,6,7,6,14.0,0,15.5,2.8,-4.06,2 +Student_04075,1,18,9500,1,1,1,1,38,37,4,9,143.0,116.5,1,0,0,1,0,1,0,20,0,7,10,7,12.625,0,0,8,8,8,13.0625,0,15.5,2.8,-4.06,2 +Student_04077,1,1,9500,1,3,1,1,19,38,9,7,145.0,136.3,1,0,0,1,0,1,0,18,0,8,8,7,13.971428571428572,0,0,8,8,7,13.971428571428572,0,12.7,3.7,-1.7,2 +Student_04078,1,1,9070,1,5,1,1,34,1,5,7,134.0,129.8,1,0,0,1,0,0,0,18,0,6,7,2,11.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_04079,2,39,9991,0,1,1,1,38,19,4,8,170.0,134.7,0,0,0,1,0,0,0,33,0,5,5,5,12.8,0,0,5,6,5,15.333333333333334,0,10.8,1.4,1.74,2 +Student_04081,1,1,171,1,1,1,1,37,37,7,9,140.0,126.8,1,0,0,0,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_04082,1,1,9085,1,1,1,1,37,37,9,6,131.0,130.7,0,0,1,1,0,0,0,21,0,5,9,2,11.5,0,0,5,13,4,11.0,1,10.8,1.4,1.74,1 +Student_04083,1,17,9254,1,3,1,1,37,19,5,5,115.0,109.8,1,0,0,1,0,0,0,19,0,6,8,4,11.25,0,0,6,8,4,12.0,0,10.8,1.4,1.74,1 +Student_04085,2,39,9147,1,1,1,1,1,19,9,9,130.0,109.9,0,0,0,0,0,0,0,29,0,4,4,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_04086,1,44,9130,1,1,39,1,1,37,3,3,160.0,160.0,1,0,1,0,0,0,0,36,2,6,9,6,12.0,0,1,6,8,3,14.666666666666666,0,12.4,0.5,1.79,0 +Student_04087,1,39,8014,0,1,19,1,37,37,9,7,133.1,106.5,0,0,0,1,0,1,0,32,0,6,7,6,12.666666666666666,0,0,6,7,6,13.333333333333334,0,12.7,3.7,-1.7,2 +Student_04089,2,43,9991,0,1,1,1,37,37,3,10,140.0,107.8,0,0,0,1,0,0,0,33,8,10,15,8,10.375,0,7,10,13,9,10.444444444444445,0,7.6,2.6,0.32,1 +Student_04090,2,NA,8014,0,1,14,1,34,34,0,0,133.1,100.0,0,0,0,0,0,0,0,34,3,7,13,3,12.0,0,2,7,15,1,13.0,1,9.4,-0.8,-3.12,0 +Student_04091,2,39,8014,0,1,1,1,34,34,0,0,150.0,112.5,0,0,0,1,0,0,0,33,0,6,10,5,11.4,0,1,6,7,6,11.166666666666666,0,7.6,2.6,0.32,2 +Student_04092,1,43,9991,0,1,1,1,37,38,9,8,140.0,135.5,0,0,1,0,0,0,0,29,0,5,15,2,13.25,0,0,5,12,3,12.6,3,16.2,0.3,-0.92,0 +Student_04093,1,1,9500,1,1,1,1,1,1,4,10,145.0,145.0,0,0,0,1,0,0,0,18,0,7,7,6,13.861666666666666,0,0,8,16,0,0.0,1,12.4,0.5,1.79,0 +Student_04096,1,1,9500,1,4,1,1,38,37,9,8,135.0,126.3,1,0,0,1,0,1,0,19,0,7,7,6,15.433333333333332,0,0,7,7,6,15.433333333333332,0,7.6,2.6,0.32,2 +Student_04097,4,39,8014,0,1,19,1,37,37,9,9,133.1,113.5,0,0,0,1,0,1,0,39,0,6,6,6,13.833333333333334,0,0,6,6,6,15.5,0,11.1,0.6,2.02,2 +Student_04098,1,43,9991,0,1,3,1,37,37,9,9,120.0,120.0,0,0,0,1,0,0,0,37,7,14,21,12,11.833333333333334,0,11,12,15,11,11.363636363636363,0,12.7,3.7,-1.7,2 +Student_04100,1,18,9238,1,1,1,1,38,34,4,0,147.0,130.2,0,0,0,1,0,0,0,18,0,1,1,0,0.0,1,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_04101,1,43,NA,1,1,1,1,1,1,4,8,149.0,140.2,1,1,0,1,0,0,0,20,1,7,9,7,12.333333333333334,0,0,8,8,8,12.625,0,12.7,3.7,-1.7,1 +Student_04104,1,1,9147,1,2,1,1,1,19,4,9,125.0,124.0,1,0,0,1,0,0,0,19,0,5,5,5,11.2,0,0,5,11,4,11.75,0,10.8,1.4,1.74,1 +Student_04105,1,1,9238,1,1,1,1,37,38,9,10,141.0,138.9,0,0,0,1,0,0,0,18,0,6,9,6,13.714285714285714,0,0,6,6,6,14.166666666666666,0,13.9,-0.3,0.79,2 +Student_04107,1,17,9773,1,4,1,1,1,38,5,7,118.0,120.8,1,0,0,1,0,0,0,20,0,6,9,4,13.25,0,0,6,11,5,11.8,0,12.4,0.5,1.79,2 +Student_04109,1,17,9500,1,3,1,1,37,38,4,5,136.0,126.0,1,0,0,1,0,0,0,19,0,8,8,7,15.11,0,0,8,8,7,15.11,0,10.8,1.4,1.74,2 +Student_04110,1,1,9238,1,2,1,1,1,19,4,5,134.0,126.0,0,0,0,1,0,0,0,18,0,6,10,4,11.0,0,0,6,8,5,11.2,0,10.8,1.4,1.74,2 +Student_04111,1,1,9500,1,1,1,1,38,19,9,5,153.0,138.5,1,0,0,1,0,1,0,20,0,8,8,7,15.798571428571426,0,0,8,8,7,15.798571428571426,0,10.8,1.4,1.74,2 +Student_04112,1,1,9500,1,3,1,1,19,37,9,9,119.0,119.4,1,0,0,1,0,0,0,20,0,7,7,7,13.775714285714288,0,0,8,8,8,15.599999999999998,0,12.4,0.5,1.79,2 +Student_04113,4,39,9500,1,1,1,1,38,37,7,7,140.0,101.5,1,0,0,1,0,0,0,24,0,8,11,7,12.16,0,0,8,11,7,12.16,0,10.8,1.4,1.74,2 +Student_04114,4,39,9556,1,2,1,1,38,37,7,7,133.1,101.5,1,0,0,1,0,0,0,24,0,7,0,0,0.0,0,0,7,0,0,0.0,0,10.8,1.4,1.74,0 +Student_04115,1,17,9773,1,2,1,1,2,1,2,7,130.0,126.2,1,0,0,1,0,0,0,20,0,6,6,6,14.333333333333334,0,0,6,6,6,15.5,0,12.4,0.5,1.79,2 +Student_04116,1,1,9070,1,3,1,1,19,19,3,3,128.0,129.8,1,0,0,1,0,0,0,20,0,6,6,6,11.833333333333334,0,0,6,6,3,13.333333333333334,0,9.4,-0.8,-3.12,1 +Student_04117,1,1,9085,1,1,1,1,38,37,3,9,145.0,138.4,1,0,0,0,0,0,0,18,0,6,7,6,14.833333333333334,0,0,6,8,6,12.5,0,8.9,1.4,3.51,1 +Student_04119,1,1,9085,1,1,1,1,2,1,4,3,119.0,113.1,1,0,0,1,0,0,0,21,0,5,6,5,12.2,0,0,5,5,5,13.2,0,10.8,1.4,1.74,2 +Student_04121,1,17,9500,1,5,1,1,19,1,5,3,144.0,141.0,1,0,0,1,0,1,0,19,0,8,8,7,12.485714285714286,0,0,8,8,7,12.485714285714286,0,12.7,3.7,-1.7,2 +Student_04124,1,1,9500,1,3,1,6,37,37,9,9,153.0,131.8,1,0,0,1,0,0,1,18,0,7,7,6,14.716666666666669,0,0,7,7,6,14.716666666666669,0,7.6,2.6,0.32,2 +Student_04125,1,1,9085,1,1,1,1,37,19,9,5,147.0,133.7,1,0,0,1,0,1,0,19,0,5,10,2,13.5,0,0,5,11,5,11.4,1,10.8,1.4,1.74,1 +Student_04127,1,1,9085,1,3,1,1,38,19,9,5,134.0,129.1,0,0,0,1,0,0,0,19,0,5,7,3,12.0,0,0,5,7,4,13.5,0,7.6,2.6,0.32,1 +Student_04128,1,1,8014,0,1,1,1,38,38,5,2,133.0,135.5,0,0,0,1,0,0,0,34,0,6,7,6,12.333333333333334,0,0,6,6,6,11.666666666666666,0,10.8,1.4,1.74,2 +Student_04130,1,1,9500,1,1,1,1,37,37,7,9,137.0,130.8,1,0,0,1,0,1,0,18,0,7,7,6,12.666666666666666,0,0,7,7,6,12.666666666666666,0,7.6,2.6,0.32,2 +Student_04131,1,1,9500,1,5,1,1,37,37,9,5,143.0,131.6,1,0,0,1,0,1,0,19,0,7,10,7,14.368,0,0,8,8,8,14.44875,0,15.5,2.8,-4.06,2 +Student_04135,1,1,9238,1,1,1,1,34,38,4,7,142.0,127.3,0,0,0,1,0,1,0,18,0,6,12,4,11.0,0,0,6,9,6,11.5,0,9.4,-0.8,-3.12,2 +Student_04136,1,1,8014,0,1,1,1,38,38,9,7,115.0,NA,1,0,0,1,0,0,0,28,0,6,8,5,12.8,0,0,6,8,5,11.0,0,9.4,-0.8,-3.12,2 +Student_04137,5,43,9500,1,1,1,1,1,38,5,5,131.0,118.8,0,0,0,1,0,1,0,18,0,8,8,7,11.857142857142858,0,0,8,8,7,11.857142857142858,0,12.7,3.7,-1.7,2 +Student_04138,2,39,9254,1,1,1,1,37,37,9,9,130.0,125.0,0,0,0,1,0,0,0,41,0,6,8,6,12.285714285714286,0,0,6,10,5,13.0,0,8.9,1.4,3.51,2 +Student_04140,NA,17,9238,1,1,1,1,38,19,7,7,134.0,124.2,0,0,0,1,0,1,0,21,0,6,11,4,11.25,0,0,6,12,4,11.4,0,15.5,2.8,-4.06,2 +Student_04141,4,7,9238,1,1,40,1,34,34,99,NA,130.0,130.0,0,0,1,1,0,0,0,41,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_04143,1,43,8014,0,1,12,1,34,34,0,99,114.0,110.0,0,0,0,1,0,0,0,29,0,6,10,6,11.666666666666666,0,0,6,7,6,11.0,0,7.6,2.6,0.32,2 +Student_04144,1,39,9556,1,1,1,1,19,38,9,8,130.0,113.3,0,0,0,1,0,0,0,24,0,7,15,5,12.4,0,0,8,14,7,12.15,0,12.4,0.5,1.79,1 +Student_04145,1,43,9556,1,1,1,1,38,38,7,NA,128.0,123.5,1,0,0,1,0,0,0,22,0,7,14,6,10.744444444444444,1,0,8,10,8,NA,0,12.7,3.7,-1.7,1 +Student_04146,1,1,9238,1,1,1,1,19,1,1,3,133.1,101.0,0,0,0,1,0,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_04147,2,39,9500,1,1,19,1,37,38,9,10,133.1,120.9,1,0,0,1,0,0,0,39,0,7,12,4,12.0,0,0,7,13,4,12.5625,0,11.1,0.6,2.02,0 +Student_04148,4,39,9085,1,1,1,1,37,37,9,9,140.0,154.6,0,0,0,0,0,1,0,44,0,6,12,4,12.75,0,0,6,15,2,10.0,0,8.9,1.4,3.51,1 +Student_04149,1,1,9147,1,1,1,1,37,37,9,9,117.0,120.2,1,0,0,1,0,0,0,20,0,5,9,2,10.0,0,0,5,10,2,11.0,0,7.6,2.6,0.32,1 +Student_04150,1,43,9500,1,3,1,1,38,37,9,8,139.0,146.5,0,0,0,1,0,0,0,21,11,14,26,12,13.417391304347827,1,11,14,26,12,13.417391304347827,1,7.6,2.6,0.32,2 +Student_04151,1,1,9773,1,1,1,1,34,26,0,6,159.0,160.1,1,0,0,1,0,0,0,18,0,6,6,6,15.166666666666666,0,0,6,7,6,14.857142857142858,0,7.6,2.6,0.32,2 +Student_04152,1,39,9003,1,1,1,1,37,37,5,5,140.0,150.0,0,0,1,1,0,0,0,34,0,6,10,5,13.833333333333334,0,0,6,13,5,12.5,0,16.2,0.3,-0.92,2 +Student_04153,1,1,9085,1,3,1,1,10,19,90,90,140.0,135.8,1,0,0,1,0,0,0,18,0,5,6,5,13.333333333333334,0,0,5,7,4,14.8,0,7.6,2.6,0.32,2 +Student_04154,1,1,171,1,1,1,1,19,4,9,2,135.0,143.8,1,0,1,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,1 +Student_04155,1,1,9853,1,1,1,1,37,19,6,7,NA,116.8,1,0,0,1,0,0,0,18,0,6,11,3,11.666666666666666,0,0,6,11,3,10.666666666666666,0,9.4,-0.8,-3.12,0 +Student_04156,1,1,9085,1,5,1,1,3,19,2,3,124.0,113.9,1,0,0,1,0,0,0,19,0,6,12,5,15.0,0,0,6,9,6,13.428571428571429,0,16.2,0.3,-0.92,2 +Student_04157,1,1,9500,1,3,1,1,37,37,9,9,131.0,118.0,1,0,0,1,0,1,0,18,0,8,8,7,13.242857142857144,0,0,8,8,7,13.242857142857144,0,12.7,3.7,-1.7,1 +Student_04158,1,1,9130,1,5,1,1,3,1,2,9,160.0,150.2,1,0,0,1,0,0,0,19,0,5,13,1,13.0,0,0,5,7,2,12.5,0,12.7,3.7,-1.7,0 +Student_04159,1,1,NA,1,2,1,1,3,37,4,7,120.0,115.1,1,0,0,1,0,1,0,19,0,7,8,6,13.075,0,0,8,10,7,12.05,0,12.4,0.5,1.79,2 +Student_04160,1,1,9670,1,1,1,1,19,19,5,9,140.0,131.3,1,0,0,1,0,1,0,18,0,6,6,6,13.5,0,0,6,9,6,13.666666666666666,0,10.8,1.4,1.74,2 +Student_04161,1,44,9991,0,1,39,1,NA,37,7,7,120.0,120.0,1,0,0,1,0,1,0,23,2,6,8,5,11.8,0,2,6,8,6,12.333333333333334,0,9.4,-0.8,-3.12,2 +Student_04163,4,43,9853,1,1,1,100,19,22,90,90,133.1,100.0,0,0,0,1,0,0,1,33,0,6,6,6,12.166666666666666,0,0,6,9,3,11.0,0,7.6,2.6,0.32,0 +Student_04164,1,17,9238,1,2,1,1,19,38,9,9,111.0,110.7,1,0,0,1,0,0,0,19,0,6,9,6,12.166666666666666,0,0,6,9,6,11.0,0,8.9,1.4,3.51,2 +Student_04165,1,43,171,1,3,1,1,37,38,7,7,140.0,143.4,1,0,0,1,0,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_04166,1,1,9500,1,6,1,1,19,19,9,9,125.0,115.9,0,0,0,1,0,0,0,18,0,7,7,7,13.557142857142855,0,0,8,9,8,13.2,0,12.4,0.5,1.79,2 +Student_04167,1,18,9991,0,1,1,1,38,38,5,5,133.1,145.0,0,0,0,1,0,1,0,21,0,5,6,4,12.25,0,0,5,8,4,11.8,0,10.8,1.4,1.74,1 +Student_04168,1,17,9070,1,2,1,1,19,38,4,7,136.0,140.9,1,0,0,1,0,0,0,19,0,6,6,6,14.333333333333334,0,0,6,6,6,13.5,0,9.4,-0.8,-3.12,2 +Student_04169,1,1,9773,1,2,1,1,34,38,0,5,115.0,108.4,1,0,0,1,0,0,0,20,0,6,10,4,10.5,0,0,6,8,4,11.75,0,7.6,2.6,0.32,2 +Student_04170,1,1,9773,1,1,1,1,37,37,0,5,116.0,114.3,1,0,0,1,0,0,0,20,0,4,8,0,0.0,0,0,4,8,0,0.0,0,7.6,2.6,0.32,0 +Student_04171,1,18,9853,1,5,1,1,19,37,7,7,110.0,110.0,1,0,0,1,0,0,0,20,0,6,10,4,12.75,0,0,6,14,3,11.333333333333334,0,10.8,1.4,1.74,1 +Student_04172,1,1,9238,1,1,1,1,38,38,4,7,135.0,121.7,1,0,0,1,0,1,0,18,0,6,14,0,0.0,0,0,6,9,4,11.0,0,7.6,2.6,0.32,1 +Student_04173,1,43,9147,1,2,1,1,19,37,5,9,131.0,123.7,1,0,0,1,0,0,0,18,0,5,10,1,14.0,0,0,5,10,1,14.0,0,7.6,2.6,0.32,1 +Student_04174,1,1,9500,1,2,1,1,37,37,7,7,124.0,116.5,1,0,0,1,NA,1,0,20,0,7,9,7,14.093333333333332,0,0,8,8,8,15.0,0,11.1,0.6,2.02,2 +Student_04175,1,1,NA,1,1,1,1,37,37,5,6,163.0,155.0,0,0,0,1,0,1,0,21,0,6,6,6,13.333333333333334,0,0,6,8,6,13.166666666666666,0,9.4,-0.8,-3.12,2 +Student_04176,1,43,9500,1,1,1,1,38,19,9,5,137.0,129.3,1,0,0,1,0,0,0,19,0,8,12,7,12.071428571428571,0,0,8,12,7,12.071428571428571,0,12.7,3.7,-1.7,2 +Student_04177,1,1,9254,1,3,1,1,19,1,7,9,128.0,121.7,1,0,0,1,0,1,0,18,0,6,6,6,12.666666666666666,0,0,6,6,6,12.5,0,12.4,0.5,1.79,2 +Student_04178,1,39,9085,1,1,1,1,37,37,9,9,133.1,148.2,1,0,1,1,0,0,0,27,0,6,11,6,12.125,0,0,6,16,5,12.0,0,12.4,0.5,1.79,1 +Student_04179,1,1,9500,1,2,1,1,19,38,7,9,133.1,125.5,1,0,0,1,0,1,0,21,0,7,9,7,13.2,0,0,8,9,7,13.2575,0,15.5,2.8,-4.06,2 +Student_04180,1,17,9500,1,4,1,1,3,19,4,7,148.0,131.9,1,0,0,1,0,1,0,18,0,7,8,7,14.15,0,0,8,8,8,14.51125,0,15.5,2.8,-4.06,2 +Student_04182,1,43,9853,1,1,1,1,37,37,9,9,110.0,107.7,0,0,1,0,0,0,0,28,0,6,0,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_04183,1,39,9556,1,1,1,1,44,40,2,2,133.1,115.5,0,0,0,1,0,0,0,36,0,7,13,5,12.2,0,0,7,14,3,11.4,0,11.1,0.6,2.02,0 +Student_04184,1,1,9085,1,1,1,1,38,38,9,10,145.0,139.8,1,0,0,1,0,0,0,20,0,5,6,5,14.8,1,0,5,6,5,14.0,0,12.7,3.7,-1.7,2 +Student_04185,1,1,9238,1,1,1,1,38,38,0,7,136.0,133.2,1,0,0,1,0,0,0,19,0,6,8,5,11.0,0,0,6,13,5,11.4,0,7.6,2.6,0.32,2 +Student_04186,1,1,9991,0,1,1,1,19,37,9,9,131.0,118.4,1,0,0,1,0,0,0,20,0,5,10,0,0.0,0,0,5,10,0,0.0,3,7.6,2.6,0.32,1 +Student_04187,1,17,9085,1,2,1,1,37,37,9,7,138.0,123.3,1,0,0,1,0,0,0,19,0,5,15,3,14.0,3,0,5,10,4,11.75,1,9.4,-0.8,-3.12,1 +Student_04188,2,39,8014,0,1,1,1,37,38,3,7,NA,134.5,0,0,0,1,0,0,0,28,0,6,8,5,11.833333333333334,0,0,6,6,6,13.0,0,16.2,0.3,-0.92,2 +Student_04190,1,42,9254,1,1,1,1,38,37,1,1,154.0,154.0,1,0,0,1,NA,0,0,28,8,14,22,12,12.333333333333334,0,3,12,20,8,12.0,0,9.4,-0.8,-3.12,2 +Student_04192,1,44,9085,1,1,39,1,1,39,3,9,140.0,140.0,1,0,0,1,0,0,0,20,1,6,9,6,12.666666666666666,0,1,6,10,4,11.5,0,13.9,-0.3,0.79,1 +Student_04193,1,17,9853,1,2,1,1,37,37,5,6,150.0,132.5,1,0,0,1,0,0,0,22,0,6,9,4,12.25,0,0,6,8,5,11.6,0,10.8,1.4,1.74,1 +Student_04194,1,17,9254,1,2,1,1,1,4,4,4,141.0,127.7,0,0,0,1,0,1,0,18,0,6,7,6,11.285714285714286,0,0,6,9,4,13.5,0,16.2,0.3,-0.92,2 +Student_04195,1,1,9147,1,5,1,1,38,38,9,9,122.0,117.5,1,0,1,0,0,0,0,22,0,5,12,2,11.5,0,0,5,12,0,0.0,0,12.7,3.7,-1.7,0 +Student_04196,1,1,9254,1,5,1,1,37,37,9,7,120.0,127.0,1,0,0,1,0,1,0,18,0,6,10,6,11.666666666666666,0,0,6,10,4,12.25,0,9.4,-0.8,-3.12,2 +Student_04197,1,1,9500,1,1,1,1,19,37,5,5,139.0,125.5,0,0,0,1,0,1,0,21,0,8,8,7,13.514285714285714,0,0,8,8,7,13.514285714285714,0,12.7,3.7,-1.7,2 +Student_04198,1,17,9773,1,6,1,1,1,1,4,2,138.0,140.5,1,0,0,1,0,0,0,19,0,6,7,6,13.0,0,0,6,9,6,13.714285714285714,0,7.6,2.6,0.32,2 +Student_04199,1,5,9853,1,1,1,1,1,38,5,8,119.0,118.3,1,0,0,1,0,0,0,22,0,6,11,3,15.0,0,0,6,11,4,10.25,0,9.4,-0.8,-3.12,1 +Student_04200,1,1,9500,1,1,1,1,38,38,5,5,129.0,120.8,1,0,0,1,0,1,0,20,0,8,8,7,12.744285714285716,0,0,8,8,7,12.744285714285716,0,10.8,1.4,1.74,2 +Student_04201,1,1,9147,1,1,1,1,37,37,191,154,133.1,95.0,0,0,0,1,0,0,0,20,0,5,10,4,11.75,0,0,5,8,5,11.8,0,11.1,0.6,2.02,2 +Student_04202,1,17,8014,0,1,1,1,37,37,5,6,125.0,122.2,1,0,1,1,0,0,0,19,0,6,6,6,12.166666666666666,0,0,6,7,6,11.666666666666666,0,10.8,1.4,1.74,2 +Student_04203,1,17,171,1,1,1,1,1,1,7,3,125.0,143.9,1,0,0,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,1 +Student_04204,1,1,9070,1,2,1,1,19,38,9,9,137.0,127.2,1,0,0,1,0,1,0,20,1,6,9,5,13.4,1,0,6,9,6,12.375,0,13.9,-0.3,0.79,2 +Student_04206,1,1,9500,1,3,1,1,1,37,4,9,154.0,134.8,1,0,0,1,0,0,0,19,0,7,7,6,13.533333333333331,0,0,7,7,6,13.533333333333331,0,7.6,2.6,0.32,2 +Student_04207,1,1,9254,1,1,1,1,19,19,9,9,144.0,142.6,1,0,0,1,0,1,0,18,0,6,7,6,14.166666666666666,0,0,6,10,4,14.0,0,15.5,2.8,-4.06,2 +Student_04208,1,1,9500,1,1,1,1,38,37,7,8,153.0,147.9,0,0,0,1,0,1,0,18,0,7,7,7,14.652857142857142,0,0,8,9,8,14.755555555555556,0,12.4,0.5,1.79,2 +Student_04209,1,1,171,1,1,1,1,1,38,4,9,152.0,160.4,1,0,0,0,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,0 +Student_04210,1,1,9147,1,1,1,103,37,37,9,9,150.0,134.6,0,0,0,1,1,0,1,20,0,5,5,5,13.6,0,0,5,7,5,13.0,0,9.4,-0.8,-3.12,2 +Student_04211,1,1,9254,1,1,1,1,19,1,3,7,129.0,121.0,0,0,0,1,0,1,0,22,0,6,9,6,12.833333333333334,0,0,6,6,4,13.25,0,16.2,0.3,-0.92,2 +Student_04212,1,1,9238,1,1,1,NA,19,37,5,4,150.0,142.7,1,0,0,1,0,1,0,18,0,6,6,6,14.666666666666666,0,0,6,6,6,15.166666666666666,0,9.4,-0.8,-3.12,2 +Student_04213,1,17,9773,1,2,1,1,1,1,4,8,125.0,115.6,1,0,0,1,0,0,0,19,0,6,6,6,13.333333333333334,0,0,6,6,6,14.666666666666666,0,12.4,0.5,1.79,2 +Student_04214,1,1,9238,1,1,1,1,19,37,9,9,133.1,130.0,0,0,0,0,0,1,0,20,0,6,10,5,13.4,0,0,6,9,5,11.4,0,10.8,1.4,1.74,2 +Student_04215,1,1,9500,1,2,1,1,38,37,5,6,140.0,124.3,1,0,0,1,0,1,0,19,0,7,9,7,13.3125,0,0,8,8,8,15.6375,0,13.9,-0.3,0.79,2 +Student_04216,1,1,171,1,1,1,1,19,37,5,6,140.0,137.9,1,0,1,0,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,8.9,1.4,3.51,0 +Student_04219,1,17,9773,1,3,1,1,1,19,5,7,135.0,135.0,0,0,0,1,0,0,0,18,0,6,6,6,13.5,0,0,6,6,6,13.333333333333334,0,12.4,0.5,1.79,1 +Student_04220,1,16,9238,1,4,1,1,37,37,9,9,135.0,121.0,1,0,0,1,0,0,0,18,0,6,8,5,13.0,0,0,6,7,6,11.833333333333334,0,10.8,1.4,1.74,2 +Student_04221,1,1,9670,1,1,1,1,34,38,0,4,133.1,147.0,0,0,0,1,0,0,0,22,0,5,6,2,12.5,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_04222,1,1,9238,1,1,1,1,37,37,9,9,168.0,149.5,0,0,0,1,0,0,0,18,0,6,10,6,17.0,0,0,6,11,6,16.0,0,12.4,0.5,1.79,2 +Student_04223,1,1,9238,1,1,1,1,19,1,9,9,NA,144.4,1,0,0,1,0,0,0,20,0,6,7,6,13.5,0,0,6,6,6,13.0,0,10.8,1.4,1.74,2 +Student_04224,1,17,9254,1,2,1,1,19,38,5,5,116.0,116.0,1,0,0,1,0,0,0,19,0,6,7,6,12.714285714285714,0,0,6,6,6,11.833333333333334,0,8.9,1.4,3.51,2 +Student_04225,1,43,9500,1,1,1,1,38,19,5,8,134.0,120.7,0,0,0,1,0,1,0,19,0,7,9,6,13.0,0,0,8,11,8,13.927272727272726,0,16.2,0.3,-0.92,2 +Student_04226,1,44,9238,1,1,39,1,38,19,5,0,140.0,141.8,0,0,0,1,0,0,0,21,3,6,7,6,12.571428571428571,0,2,6,6,6,13.5,0,12.4,0.5,1.79,2 +Student_04227,1,17,8014,0,2,1,1,19,1,5,5,133.0,119.7,1,0,0,1,0,1,0,19,0,6,10,4,11.5,0,0,6,11,6,11.5,0,9.4,-0.8,-3.12,0 +Student_04230,2,39,9085,1,1,1,1,36,36,99,5,133.1,128.2,0,0,0,0,0,1,0,28,0,5,14,1,12.0,3,0,5,5,0,0.0,5,9.4,-0.8,-3.12,0 +Student_04231,2,43,9500,1,1,1,1,3,3,2,2,137.0,115.0,0,0,0,1,0,0,0,28,0,7,8,7,14.95,0,0,8,8,8,14.7375,0,13.9,-0.3,0.79,2 +Student_04232,1,39,9991,0,1,1,1,38,19,9,5,140.0,130.0,0,0,1,1,0,0,0,25,0,5,10,4,11.25,0,0,5,9,4,12.0,0,12.7,3.7,-1.7,1 +Student_04234,1,1,9500,1,5,1,1,38,38,9,5,139.0,130.5,1,0,0,1,0,0,0,19,0,8,8,7,14.992857142857142,0,0,8,8,7,14.992857142857142,0,10.8,1.4,1.74,2 +Student_04236,1,1,9238,1,3,1,1,1,1,9,9,133.1,100.0,1,0,0,1,1,0,0,22,0,6,6,4,11.25,0,0,6,7,3,11.0,0,8.9,1.4,3.51,1 +Student_04237,1,43,9773,1,1,1,1,38,19,9,9,132.0,125.0,1,0,0,1,1,1,0,20,0,6,6,6,12.333333333333334,0,0,6,7,6,14.0,0,12.4,0.5,1.79,2 +Student_04238,1,1,9500,1,4,1,1,19,37,7,7,127.0,121.5,1,0,0,1,1,0,0,20,0,7,7,6,13.016666666666666,0,0,7,7,6,13.016666666666666,0,7.6,2.6,0.32,1 +Student_04239,1,1,9085,1,1,1,1,38,19,4,90,123.0,127.2,0,0,1,0,1,0,0,20,0,5,7,3,11.333333333333334,0,0,5,8,2,11.5,0,7.6,2.6,0.32,0 +Student_04242,1,1,9500,1,3,1,1,37,37,9,9,140.0,141.5,1,0,1,0,0,0,0,19,0,8,8,7,13.327142857142857,0,0,8,8,7,13.327142857142857,0,10.8,1.4,1.74,0 +Student_04243,1,17,9238,1,1,1,1,19,38,3,3,111.0,111.4,1,0,0,0,0,0,0,19,0,6,13,4,11.0,0,0,6,13,2,11.5,0,12.7,3.7,-1.7,0 +Student_04244,1,1,9070,1,1,1,1,4,39,2,2,132.0,NA,1,0,0,1,0,0,0,18,1,6,10,6,11.714285714285714,1,0,6,15,6,10.375,0,13.9,-0.3,0.79,1 +Student_04245,1,1,171,1,1,1,1,3,3,2,5,150.0,154.6,1,0,0,1,0,0,0,19,6,12,13,12,12.333333333333334,0,4,11,12,10,12.727272727272728,0,8.9,1.4,3.51,0 +Student_04246,1,18,9853,1,4,1,1,19,37,9,6,118.0,111.4,1,0,1,0,0,0,0,20,0,7,9,0,0.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_04247,2,43,9991,0,1,1,1,38,19,3,3,150.0,120.1,0,0,0,0,0,0,0,39,11,15,15,12,11.916666666666666,0,8,13,14,8,11.25,0,10.8,1.4,1.74,0 +Student_04248,2,39,8014,0,2,19,1,37,37,4,7,100.0,100.0,0,0,1,1,0,0,0,37,0,6,9,6,11.833333333333334,0,0,6,7,6,11.0,0,7.6,2.6,0.32,2 +Student_04249,2,39,9500,1,1,3,1,1,1,4,6,130.0,140.0,0,0,1,0,0,0,0,30,3,7,11,3,12.333333333333334,0,3,7,9,3,11.666666666666666,0,13.9,-0.3,0.79,0 +Student_04250,2,43,9991,0,1,3,1,37,37,9,9,130.0,130.0,0,0,0,1,0,0,0,41,5,10,11,10,14.3,0,5,10,10,10,14.2,0,12.7,3.7,-1.7,2 +Student_04254,1,18,9853,1,2,1,1,19,37,9,4,120.0,113.7,1,0,1,0,0,0,0,19,0,7,11,5,12.2,0,0,7,13,0,0.0,0,12.4,0.5,1.79,0 +Student_04255,1,1,9670,1,1,1,1,37,37,5,9,121.0,116.5,1,0,0,1,0,0,0,23,0,5,7,3,11.333333333333334,0,0,5,5,4,11.25,0,7.6,2.6,0.32,0 +Student_04256,1,7,8014,0,1,4,1,2,3,2,2,120.0,120.0,0,0,0,1,0,0,0,18,10,16,24,13,13.846153846153848,0,7,11,15,9,12.555555555555555,0,15.5,2.8,-4.06,0 +Student_04259,1,1,9500,1,2,1,1,19,19,7,7,123.0,120.8,1,0,0,1,0,0,0,19,0,8,11,7,12.545714285714286,0,0,8,11,7,12.545714285714286,0,10.8,1.4,1.74,2 +Student_04260,1,1,9773,1,1,1,1,37,19,9,10,134.0,141.4,1,0,0,1,NA,0,0,19,0,6,12,3,13.0,0,0,6,13,2,14.0,0,9.4,-0.8,-3.12,0 +Student_04262,2,43,9991,0,1,2,1,37,37,9,9,120.0,120.0,0,0,0,0,0,0,0,38,9,12,12,9,12.22222222222222,2,9,12,12,9,13.0,0,9.4,-0.8,-3.12,0 +Student_04263,1,17,9147,1,1,1,1,1,37,3,7,131.0,120.2,0,0,0,1,0,0,0,19,0,5,10,5,13.285714285714286,0,0,5,8,5,13.0,0,12.7,3.7,-1.7,2 +Student_04264,2,39,9991,0,1,12,1,37,1,9,4,133.1,138.4,0,0,0,1,1,0,0,30,0,5,7,3,11.666666666666666,0,0,5,8,1,11.0,0,7.6,2.6,0.32,0 +Student_04267,1,44,171,1,1,39,1,1,1,9,9,140.0,140.0,0,0,0,1,1,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,1 +Student_04269,1,1,9991,0,2,1,1,5,1,4,4,143.0,131.5,0,0,0,1,1,0,0,19,0,5,11,4,11.0,0,0,5,8,4,12.25,0,15.5,2.8,-4.06,0 +Student_04270,1,17,9070,1,2,1,1,3,1,2,4,142.0,141.0,1,0,0,1,1,0,0,18,0,6,6,6,13.0,0,0,6,8,1,10.0,0,10.8,1.4,1.74,1 +Student_04272,1,17,9119,1,4,1,1,1,3,1,4,138.0,127.5,1,0,0,1,1,0,0,19,0,5,6,5,14.6,0,0,5,5,5,15.2,0,8.9,1.4,3.51,0 +Student_04273,1,1,9500,1,1,1,1,1,19,9,9,131.0,127.0,0,0,0,1,1,1,0,19,0,8,8,7,12.514285714285714,0,0,8,8,7,12.514285714285714,0,12.7,3.7,-1.7,2 +Student_04274,1,17,9085,1,2,1,1,3,19,2,9,123.0,118.9,0,0,0,1,1,0,0,18,0,5,5,3,14.0,0,0,5,7,3,12.666666666666666,0,7.6,2.6,0.32,1 +Student_04275,1,1,9254,1,1,1,1,37,19,9,9,131.0,134.5,1,0,0,1,1,0,0,25,0,6,8,6,13.166666666666666,0,0,6,8,5,NA,0,7.6,2.6,0.32,1 +Student_04276,1,17,9119,1,1,1,1,37,1,9,2,141.0,133.0,1,0,0,1,1,0,0,18,0,5,10,4,13.0,0,0,5,10,3,12.333333333333334,3,7.6,2.6,0.32,1 +Student_04277,5,39,9147,1,1,1,1,1,19,4,7,133.1,114.0,0,0,0,0,1,0,0,29,0,5,5,1,13.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_04278,1,17,9119,1,1,1,1,19,37,90,5,116.0,116.7,1,0,0,1,1,0,0,21,0,5,10,1,10.0,0,0,5,8,3,13.666666666666666,3,7.6,2.6,0.32,0 +Student_04279,1,1,9773,1,3,1,1,1,1,4,7,123.0,125.1,1,0,1,1,1,1,0,18,0,6,6,6,14.333333333333334,0,0,6,6,6,15.333333333333334,0,11.1,0.6,2.02,2 +Student_04280,1,17,9254,1,1,1,1,19,1,9,9,133.0,137.2,0,0,0,1,1,1,0,20,0,6,6,0,0.0,0,0,6,12,0,0.0,0,10.8,1.4,1.74,0 +Student_04281,1,39,9991,0,1,1,1,19,37,9,7,133.1,111.4,0,0,0,1,1,0,0,27,0,5,7,1,11.0,0,0,5,7,0,0.0,0,13.9,-0.3,0.79,0 +Student_04282,1,1,9085,1,1,1,1,3,1,4,9,133.1,105.0,1,0,0,1,1,0,0,21,0,6,15,3,11.25,0,0,6,9,0,0.0,0,12.4,0.5,1.79,1 +Student_04283,1,18,9147,1,2,1,1,NA,37,5,9,140.0,124.3,1,0,0,1,1,0,0,20,0,5,7,4,10.75,0,0,5,12,3,10.571428571428571,0,10.8,1.4,1.74,0 +Student_04285,1,39,9556,1,2,1,1,37,19,9,8,130.0,110.0,0,0,0,1,1,1,0,24,0,7,13,6,10.857142857142858,0,0,7,7,7,11.857142857142858,0,12.7,3.7,-1.7,1 +Student_04286,1,1,9147,1,5,1,1,3,2,2,2,134.0,134.7,0,0,0,1,1,0,0,22,1,5,10,4,11.75,0,0,5,10,3,11.0,0,7.6,2.6,0.32,1 +Student_04288,1,44,9085,1,1,39,1,1,1,4,4,160.0,160.0,0,0,0,1,1,0,0,21,1,5,15,3,12.333333333333334,2,0,5,7,5,11.4,0,9.4,-0.8,-3.12,2 +Student_04289,1,44,9003,1,1,39,1,1,3,9,2,130.0,130.0,1,0,1,0,1,0,0,23,0,6,12,2,11.333333333333334,0,0,6,8,2,13.0,0,13.9,-0.3,0.79,0 +Student_04292,1,1,171,1,1,1,1,1,38,4,5,137.0,130.4,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,2 +Student_04294,1,1,9254,1,6,1,1,19,19,9,9,119.0,118.7,1,0,0,1,1,0,0,20,0,6,16,3,10.333333333333334,0,0,6,16,1,11.0,0,10.8,1.4,1.74,0 +Student_04295,1,39,9003,1,1,1,1,38,37,7,7,130.0,120.0,0,0,0,1,1,0,0,32,12,18,25,18,13.736842105263158,0,10,13,15,12,13.75,1,15.5,2.8,-4.06,2 +Student_04296,1,39,9003,1,1,1,1,38,19,9,6,130.0,120.0,1,0,0,1,1,0,0,28,7,13,19,8,11.625,0,5,10,17,6,11.0,0,15.5,2.8,-4.06,1 +Student_04298,1,1,9773,1,1,1,1,38,37,9,6,130.0,133.9,0,0,0,1,1,1,0,19,0,6,8,5,14.0,0,0,6,8,6,13.0,0,10.8,1.4,NA,2 +Student_04299,1,39,9991,0,1,39,1,19,19,9,9,150.0,150.3,0,0,0,1,1,0,0,24,0,5,7,3,11.333333333333334,0,0,5,6,0,0.0,0,10.8,1.4,1.74,0 +Student_04300,1,17,9147,1,1,1,1,38,38,9,8,120.0,118.3,0,0,0,1,1,0,0,18,0,5,13,1,10.0,0,0,5,5,1,10.0,0,12.7,3.7,-1.7,0 +Student_04302,1,43,171,1,1,39,1,38,37,9,7,140.0,140.0,0,0,0,0,1,0,0,25,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_04305,1,1,9147,1,1,1,1,19,1,7,5,148.0,138.3,1,0,0,1,1,0,0,19,0,5,6,4,13.75,0,0,5,5,0,0.0,0,12.4,0.5,1.79,0 +Student_04306,1,1,9147,1,5,1,1,19,3,9,9,133.0,123.2,1,0,0,1,1,0,0,18,0,5,14,4,11.0,0,0,5,9,5,10.5,0,13.9,-0.3,0.79,0 +Student_04307,1,42,9147,1,1,1,1,19,1,4,4,135.0,120.0,0,0,0,0,1,0,0,25,0,5,6,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_04309,1,44,171,1,1,39,1,1,1,1,7,110.0,114.2,0,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,0 +Student_04311,1,44,9085,1,1,39,1,38,37,9,4,150.0,150.0,1,0,0,1,1,1,0,22,0,6,9,6,13.428571428571429,0,1,6,12,6,13.625,0,12.4,0.5,1.79,2 +Student_04312,1,1,9119,1,6,1,1,2,1,3,5,135.0,123.5,1,0,0,1,1,0,0,18,0,5,10,0,0.0,0,0,5,10,1,10.0,3,7.6,2.6,0.32,1 +Student_04313,1,7,9991,0,1,3,1,19,19,3,9,130.0,130.0,0,0,0,0,1,0,0,32,0,5,12,4,14.75,0,0,5,9,2,15.0,0,16.2,0.3,-0.92,0 +Student_04314,1,43,9853,1,1,1,1,2,39,2,5,130.0,124.6,0,0,0,1,1,0,0,37,19,21,21,21,12.476190476190476,0,13,19,19,19,12.210526315789474,0,12.4,0.5,1.79,2 +Student_04315,1,17,9119,1,1,1,1,37,37,9,6,132.0,119.4,1,0,0,1,1,0,0,21,0,5,8,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_04317,1,1,9070,1,3,1,1,43,3,123,123,118.0,110.0,1,0,1,1,1,0,0,19,0,6,6,6,12.0,0,0,6,7,6,13.571428571428571,0,8.9,1.4,3.51,2 +Student_04319,1,1,171,1,1,1,41,1,1,9,7,161.0,163.1,1,0,0,0,0,0,1,19,6,12,12,12,15.25,0,4,11,12,11,15.0,0,8.9,1.4,3.51,2 +Student_04321,1,15,9147,1,1,1,26,1,1,9,7,135.0,135.0,0,0,1,1,1,0,1,21,0,5,9,3,12.333333333333334,0,0,5,8,4,11.25,0,8.9,1.4,3.51,1 +Student_04322,4,39,9991,0,1,1,1,19,19,7,8,147.0,147.9,0,0,0,1,0,0,0,28,0,5,8,4,11.5,0,0,5,7,4,12.0,0,10.8,1.4,1.74,1 +Student_04324,1,39,9991,0,1,19,1,37,37,9,6,133.1,105.3,0,0,1,1,0,0,0,28,0,5,14,2,10.5,0,0,5,6,0,0.0,0,12.4,0.5,1.79,0 +Student_04325,1,1,9500,1,1,1,1,19,19,7,9,141.0,139.8,0,0,0,1,0,1,0,19,0,8,8,7,14.4,0,0,8,8,7,14.4,0,12.7,3.7,-1.7,2 +Student_04326,2,7,8014,0,1,3,1,19,38,3,7,130.0,130.0,0,0,0,1,0,0,0,32,8,14,18,13,12.846153846153848,0,7,11,19,10,12.8,0,10.8,1.4,1.74,2 +Student_04327,1,39,8014,0,1,39,1,19,37,9,8,110.0,127.5,0,0,1,0,0,0,0,26,0,6,13,4,12.0,0,0,6,7,5,13.2,0,16.2,0.3,-0.92,0 +Student_04328,2,39,9147,1,1,12,1,37,37,9,9,133.1,120.0,0,0,0,1,0,0,0,25,0,5,0,0,0.0,0,0,5,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_04329,2,43,9853,1,2,1,1,38,31,4,1,130.0,124.2,0,0,0,1,0,0,0,31,3,7,8,6,13.666666666666666,0,1,6,8,5,13.5,0,9.4,-0.8,-3.12,0 +Student_04330,1,17,9238,1,1,1,1,37,1,9,5,120.0,113.4,1,0,0,1,0,1,0,20,0,6,10,5,11.857142857142858,0,0,6,8,6,11.666666666666666,0,12.7,3.7,-1.7,2 +Student_04332,1,17,171,1,1,1,1,37,19,5,9,145.0,130.0,1,0,0,1,0,0,0,23,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,0 +Student_04333,1,1,9238,1,1,1,1,37,1,9,9,131.0,135.9,1,0,0,1,0,0,0,18,0,6,8,5,13.2,0,0,6,6,6,11.333333333333334,0,9.4,-0.8,-3.12,2 +Student_04334,1,1,9238,1,2,1,1,19,38,9,NA,147.0,135.8,1,0,0,1,0,1,0,19,0,6,8,6,12.714285714285714,0,0,6,12,5,11.0,0,13.9,-0.3,0.79,0 +Student_04335,1,1,NA,1,1,1,1,38,19,9,10,138.0,133.1,0,0,0,1,0,0,0,18,0,6,6,6,12.5,0,0,6,6,6,12.666666666666666,0,15.5,2.8,-4.06,2 +Student_04336,1,1,9147,1,1,1,1,1,1,4,6,123.0,118.8,1,0,0,1,0,0,0,21,0,5,9,3,10.666666666666666,0,0,5,13,2,12.5,0,7.6,2.6,0.32,1 +Student_04338,1,1,9085,1,1,1,1,1,19,4,9,125.0,114.5,1,0,0,1,0,0,0,24,0,5,6,5,13.0,1,0,5,9,4,13.25,0,12.7,3.7,-1.7,2 +Student_04339,1,1,9670,1,1,1,1,37,37,9,6,131.0,127.2,0,0,0,1,0,1,0,18,0,5,7,3,12.666666666666666,0,0,5,5,4,12.5,0,9.4,-0.8,-3.12,1 +Student_04340,1,42,9500,1,1,1,1,3,37,2,6,100.0,130.0,1,0,0,1,0,0,0,25,0,14,14,12,13.291666666666666,1,0,14,14,12,13.291666666666666,1,7.6,2.6,0.32,2 +Student_04341,1,17,9085,1,1,1,1,2,3,2,2,120.0,116.1,0,0,0,1,0,0,0,20,0,5,12,3,11.666666666666666,2,0,5,11,4,11.5,1,9.4,-0.8,-3.12,2 +Student_04342,1,17,9500,1,2,1,1,19,37,5,9,145.0,130.5,1,0,0,1,0,0,0,18,0,8,8,7,14.24,0,0,8,8,7,14.24,0,10.8,1.4,1.74,2 +Student_04343,1,39,9670,1,1,1,1,34,34,0,0,120.0,104.0,1,0,0,1,0,0,0,24,0,5,10,3,13.0,0,0,5,11,3,11.333333333333334,0,7.6,2.6,0.32,0 +Student_04344,1,17,9500,1,2,1,1,1,1,5,10,140.0,128.5,1,0,0,1,0,0,0,18,0,7,9,5,14.06,0,0,7,9,6,12.571428571428571,0,12.4,0.5,1.79,1 +Student_04353,1,1,9853,1,6,1,1,38,38,9,7,140.0,137.6,1,0,0,1,0,0,0,18,0,6,7,6,11.666666666666666,0,0,6,7,6,12.333333333333334,0,10.8,1.4,1.74,0 +Student_04354,1,1,171,1,1,1,1,3,1,4,4,141.0,142.8,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,2 +Student_04355,4,39,9991,0,1,1,1,37,38,9,9,150.0,146.2,0,0,0,1,0,0,0,30,0,5,11,3,10.333333333333334,0,0,5,10,4,12.8,0,12.4,0.5,1.79,1 +Student_04356,1,1,9085,1,2,1,1,4,19,2,5,160.0,162.1,1,0,0,1,0,0,0,18,0,5,8,5,16.166666666666668,2,0,5,9,5,14.285714285714286,1,9.4,-0.8,-3.12,2 +Student_04357,1,39,9085,1,1,19,1,37,37,4,8,133.1,140.0,0,0,0,1,0,0,0,35,0,6,11,3,12.666666666666666,0,0,6,7,0,0.0,0,11.1,0.6,2.02,0 +Student_04358,1,39,8014,0,1,1,1,19,37,7,8,133.1,120.0,0,0,1,0,0,0,0,31,0,6,14,2,10.5,0,0,6,6,3,12.333333333333334,0,11.1,0.6,2.02,0 +Student_04359,1,43,9254,1,1,1,1,37,37,9,9,134.0,133.3,1,0,1,1,0,0,0,19,0,6,13,2,11.5,0,0,6,13,1,11.0,0,7.6,2.6,0.32,0 +Student_04360,1,1,9238,1,4,1,1,1,19,4,5,130.0,124.8,1,0,0,1,0,0,0,19,0,6,6,6,13.0,0,0,6,8,5,13.4,0,8.9,1.4,3.51,2 +Student_04362,1,17,9500,1,1,1,1,3,3,2,3,145.0,141.8,0,0,0,1,0,0,0,19,0,8,8,8,13.3475,0,0,8,8,8,13.3475,0,9.4,-0.8,-3.12,2 +Student_04364,1,17,9853,1,3,NA,1,34,34,0,0,133.1,115.0,0,0,0,1,0,0,0,18,0,6,10,2,10.5,0,0,6,13,0,0.0,0,7.6,2.6,0.32,0 +Student_04366,1,1,171,1,2,1,1,38,38,4,9,117.0,120.2,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_04367,1,1,9670,1,1,1,1,3,19,3,9,127.0,127.0,1,0,0,1,1,0,0,18,0,6,9,6,13.571428571428571,0,0,6,11,4,14.0,0,12.4,0.5,1.79,2 +Student_04368,1,17,9085,1,1,1,1,19,19,1,1,134.0,120.4,1,0,0,1,1,0,0,18,0,6,10,6,14.7,0,0,6,10,6,12.0,0,16.2,0.3,-0.92,2 +Student_04369,1,39,9991,0,1,1,1,37,37,9,9,120.0,120.0,1,0,0,0,1,0,0,25,0,5,5,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_04370,1,1,9500,1,1,1,1,2,2,3,3,136.0,120.0,1,0,0,1,1,0,0,18,0,7,8,6,11.833333333333334,0,0,7,8,6,11.833333333333334,0,7.6,2.6,0.32,1 +Student_04371,1,1,171,1,3,1,1,1,3,5,2,137.0,133.9,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_04374,1,1,9238,1,1,1,1,37,37,7,9,124.0,121.2,0,0,0,1,0,0,0,19,0,6,12,2,13.0,0,0,6,9,6,10.833333333333334,0,7.6,2.6,0.32,1 +Student_04375,5,7,9500,1,1,40,1,37,37,4,9,150.0,150.0,0,0,0,1,0,0,0,29,1,8,11,7,13.742857142857144,0,1,8,11,7,13.742857142857144,0,12.7,3.7,-1.7,2 +Student_04376,1,NA,9991,0,1,1,1,37,37,9,9,161.0,100.0,1,0,0,1,0,0,0,27,0,5,5,0,NA,0,0,5,5,0,0.0,0,7.6,2.6,NA,0 +Student_04380,1,39,9991,0,1,1,1,37,37,7,7,110.0,133.9,0,0,0,1,0,0,0,30,0,5,7,5,11.4,0,0,5,6,5,13.666666666666666,0,10.8,1.4,1.74,0 +Student_04381,1,7,9500,1,1,2,1,38,37,7,8,140.0,140.0,0,0,0,1,0,0,0,29,0,8,14,4,11.325,1,0,8,14,4,11.325,1,12.7,3.7,-1.7,0 +Student_04382,1,1,9238,1,2,1,1,1,19,4,8,145.0,121.4,0,0,0,1,0,0,0,20,0,6,13,0,0.0,0,0,5,11,0,0.0,0,9.4,-0.8,-3.12,1 +Student_04383,1,1,9500,1,1,1,1,1,1,9,9,131.0,122.0,0,0,0,1,0,0,0,19,0,8,8,7,15.0,0,0,8,8,7,15.0,0,12.7,3.7,-1.7,2 +Student_04384,1,39,8014,0,2,1,1,37,37,9,9,141.0,150.5,0,0,0,1,0,0,0,29,0,6,7,6,13.166666666666666,0,0,6,8,6,15.625,0,12.4,0.5,1.79,2 +Student_04386,1,1,9238,1,1,1,1,19,19,193,194,122.0,112.6,0,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_04387,1,17,9670,1,1,1,1,37,38,8,7,118.0,115.2,1,0,0,1,0,1,0,21,0,5,7,3,12.333333333333334,0,0,5,5,2,12.5,0,7.6,2.6,0.32,0 +Student_04388,2,1,9991,0,1,1,1,37,37,9,9,150.0,131.8,0,0,0,0,0,0,0,29,0,5,6,4,12.25,0,0,5,6,5,10.166666666666666,0,10.8,1.4,1.74,0 +Student_04389,2,43,9147,1,1,2,1,37,37,9,9,120.0,122.8,0,0,1,0,0,0,0,42,13,13,13,13,11.923076923076923,0,12,12,12,12,12.5,0,15.5,2.8,-4.06,0 +Student_04390,1,1,9238,1,1,1,1,19,19,9,7,167.0,156.2,0,0,0,1,0,1,0,18,0,6,6,6,14.333333333333334,0,0,6,7,6,14.142857142857142,0,15.5,2.8,NA,2 +Student_04391,1,39,9085,1,1,1,1,38,38,9,9,150.0,132.0,1,0,0,1,0,0,0,24,0,5,6,5,12.0,0,0,5,5,5,13.0,0,10.8,1.4,1.74,2 +Student_04392,2,7,9500,1,1,3,1,37,37,9,5,130.0,130.0,0,0,0,1,0,0,0,32,0,7,9,7,13.761111111111113,0,1,8,11,7,12.06375,0,15.5,2.8,-4.06,1 +Student_04393,NA,1,9147,1,1,1,1,37,1,4,10,151.0,138.4,0,0,0,1,NA,0,0,18,0,5,6,4,11.25,0,0,5,8,5,11.0,0,10.8,1.4,1.74,1 +Student_04394,1,39,9991,0,1,1,NA,38,38,5,7,120.0,146.2,0,0,0,1,0,0,0,27,0,5,10,3,12.333333333333334,0,0,5,10,3,10.666666666666666,0,11.1,0.6,2.02,2 +Student_04395,1,1,9500,1,4,1,1,38,1,9,10,168.0,166.0,1,0,0,1,0,0,0,18,0,8,8,8,14.88875,0,0,8,8,8,14.88875,0,9.4,-0.8,-3.12,2 +Student_04396,1,17,9773,1,3,1,1,34,34,99,99,153.0,133.1,1,0,1,1,0,1,0,19,0,6,8,6,12.166666666666666,0,0,6,8,5,12.4,0,9.4,-0.8,-3.12,0 +Student_04397,1,1,9773,1,2,1,1,19,37,9,10,131.0,121.9,1,0,0,1,0,1,0,18,0,6,7,6,12.666666666666666,0,0,6,6,6,13.333333333333334,0,11.1,0.6,2.02,2 +Student_04398,1,5,9853,1,4,1,1,3,38,3,8,116.0,110.4,1,0,0,1,0,0,0,21,0,6,9,5,12.6,0,0,6,9,3,11.666666666666666,0,9.4,-0.8,-3.12,1 +Student_04399,1,39,NA,1,1,1,1,38,38,7,9,160.0,121.4,0,1,0,1,0,1,0,26,0,5,8,4,13.0,0,0,5,10,4,12.25,2,16.2,0.3,-0.92,2 +Student_04400,1,1,9254,1,1,1,1,37,19,9,9,152.0,137.0,1,0,0,1,0,1,0,22,0,6,9,6,13.875,0,0,6,6,6,14.333333333333334,0,9.4,-0.8,-3.12,2 +Student_04401,2,39,9991,0,1,1,1,37,37,6,3,133.1,140.0,0,0,1,1,1,0,0,37,0,5,10,4,10.75,0,0,5,12,3,13.333333333333334,0,9.4,-0.8,-3.12,0 +Student_04402,1,7,9085,1,1,3,1,19,37,90,90,150.0,140.0,0,0,0,1,1,0,0,24,3,5,10,3,14.666666666666666,1,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_04403,1,18,9853,1,2,1,1,1,19,3,9,168.0,126.8,1,0,0,1,1,0,0,18,0,6,7,5,12.6,0,0,6,6,6,13.0,0,10.8,1.4,1.74,1 +Student_04404,1,17,9500,1,3,1,1,1,1,4,10,137.0,124.8,1,0,0,1,1,1,0,19,0,7,11,6,12.4125,0,0,8,12,7,11.2625,0,15.5,2.8,-4.06,2 +Student_04405,2,39,9130,1,1,19,1,2,1,8,NA,133.1,120.0,1,0,1,0,1,0,0,28,0,6,12,1,11.0,0,0,6,9,2,10.5,0,16.2,0.3,-0.92,0 +Student_04406,1,1,9500,1,4,1,1,37,37,7,7,160.0,133.0,1,0,0,1,1,1,0,18,0,8,8,7,14.314285714285717,0,0,8,8,7,14.314285714285717,0,12.7,3.7,-1.7,2 +Student_04407,1,1,9070,1,1,1,1,1,38,5,7,145.0,127.5,1,0,0,1,1,0,0,20,0,6,6,4,12.0,0,0,6,8,2,11.333333333333334,0,10.8,1.4,1.74,1 +Student_04408,1,1,9773,1,1,1,1,1,19,4,4,138.0,131.7,1,0,0,1,1,0,0,18,0,6,6,6,12.833333333333334,0,0,6,7,6,13.285714285714286,0,15.5,2.8,-4.06,2 +Student_04409,2,39,9773,1,1,1,1,37,37,9,9,100.0,133.0,0,0,0,1,1,0,0,47,0,6,8,5,11.4,0,0,6,10,6,NA,0,12.7,3.7,-1.7,0 +Student_04410,2,43,9991,0,1,1,1,37,37,4,1,140.0,122.7,0,0,0,1,1,0,0,NA,0,5,5,5,14.6,0,0,5,6,5,14.333333333333334,0,13.9,-0.3,0.79,2 +Student_04411,1,1,9070,1,1,1,1,37,19,9,4,NA,121.2,0,0,0,1,1,1,0,20,1,6,7,6,13.5,0,1,6,9,5,12.5,0,10.8,1.4,1.74,2 +Student_04412,1,44,9130,1,1,39,1,37,37,9,3,150.0,150.0,1,0,0,1,1,0,0,21,1,6,8,6,12.5,0,0,6,11,3,13.333333333333334,0,13.9,-0.3,0.79,0 +Student_04413,1,43,9070,1,1,1,1,19,19,7,8,125.0,133.4,1,0,0,1,1,1,0,19,4,6,6,4,13.0,0,2,6,7,5,12.2,0,13.9,-0.3,0.79,1 +Student_04414,1,43,33,1,1,1,1,37,1,9,10,143.0,121.2,1,0,0,1,1,0,0,25,5,10,13,5,11.6,0,2,8,10,2,13.0,0,12.4,0.5,1.79,1 +Student_04415,1,1,9130,1,1,1,1,3,38,3,5,137.0,129.3,1,0,0,1,0,0,0,18,0,5,6,5,11.8,1,0,5,8,5,11.6,0,9.4,-0.8,-3.12,2 +Student_04416,4,39,NA,1,1,19,1,37,37,6,6,133.1,117.8,0,0,1,0,0,0,0,46,0,7,14,3,12.333333333333334,0,0,7,12,3,11.083333333333334,0,11.1,0.6,2.02,0 +Student_04417,1,43,9500,1,2,1,1,38,38,9,5,136.0,131.3,0,0,0,1,0,0,0,23,11,14,15,12,12.625,1,11,14,15,12,12.625,1,7.6,2.6,0.32,2 +Student_04418,1,1,9070,1,1,NA,NA,1,1,9,9,132.0,133.8,1,0,0,1,0,1,0,20,0,6,6,6,13.833333333333334,0,0,6,6,6,13.5,0,16.2,0.3,-0.92,2 +Student_04419,1,44,NA,1,1,39,1,3,38,3,9,120.0,120.0,0,0,0,1,1,0,0,20,2,7,7,6,NA,0,5,9,10,7,13.142857142857142,1,16.2,0.3,-0.92,2 +Student_04420,1,1,9773,1,6,1,1,1,1,5,4,125.0,122.2,0,0,0,1,1,0,0,19,0,6,7,5,13.6,0,0,6,8,5,12.666666666666666,0,15.5,2.8,-4.06,2 +Student_04421,1,1,9773,1,2,1,105,1,1,9,9,120.0,119.0,1,0,1,0,0,0,1,18,0,6,6,6,12.0,0,0,6,6,2,11.0,0,11.1,0.6,2.02,0 +Student_04423,1,1,9147,1,1,1,1,37,37,7,4,180.0,153.8,1,0,0,1,0,1,0,20,0,5,5,5,13.8,0,0,5,6,5,12.0,0,9.4,-0.8,-3.12,2 +Student_04424,1,10,9773,1,1,1,22,38,37,5,9,152.0,152.0,1,0,0,1,0,0,1,22,0,6,8,6,11.666666666666666,0,0,6,6,6,13.0,0,12.7,3.7,-1.7,2 diff --git a/data/UCIMulticlassClassification/student_dropout_academic_success_copy.csv b/data/UCIMulticlassClassification/student_dropout_academic_success_copy.csv new file mode 100644 index 00000000..6ab935db --- /dev/null +++ b/data/UCIMulticlassClassification/student_dropout_academic_success_copy.csv @@ -0,0 +1,3540 @@ +InstanceID,MaritalStatus,ApplicationMode,Course,DaytimeEveningAttendance,ApplicationOrder,PreviousQualification,Nationality,MothersQualification,FathersQualification,MothersOccupation,FathersOccupation,PreviousQualificationGrade,AdmissionGrade,Displaced,EducationalSpecialNeeds,Debtor,TuitionFeesUpToDate,Gender,ScholarshipHolder,International,AgeAtEnrollment,CurricularUnits1stSemCredited,CurricularUnits1stSemEnrolled,CurricularUnits1stSemEvaluations,CurricularUnits1stSemApproved,CurricularUnits1stSemGrade,CurricularUnits1stSemWithoutEvaluations,CurricularUnits2ndSemCredited,CurricularUnits2ndSemEnrolled,CurricularUnits2ndSemEvaluations,CurricularUnits2ndSemApproved,CurricularUnits2ndSemGrade,CurricularUnits2ndSemWithoutEvaluations,UnemploymentRate,InflationRate,GDP,Class +Student_00001,1,17,171,1,5,1,1,19,12,5,9,122.0,127.3,1,0,0,1,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_00002,1,15,9254,1,1,1,1,1,3,3,3,160.0,142.5,1,0,0,0,1,0,0,19,0,6,6,6,14.0,0,0,6,6,6,13.666666666666666,0,13.9,-0.3,0.79,2 +Student_00003,1,1,9070,1,5,1,1,37,37,9,9,122.0,124.8,1,0,0,0,1,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_00004,1,17,9773,1,2,1,1,38,37,5,3,NA,119.6,1,0,0,1,0,0,0,20,0,6,8,6,13.428571428571429,0,0,6,10,5,12.4,0,9.4,-0.8,-3.12,2 +Student_00005,2,39,NA,0,1,1,1,37,38,9,9,100.0,141.5,0,0,0,1,0,0,0,45,0,6,9,5,12.333333333333334,0,0,6,6,6,13.0,0,13.9,-0.3,0.79,2 +Student_00006,2,39,9991,0,1,19,1,37,37,9,7,133.1,114.8,0,0,1,1,1,0,0,50,0,5,10,5,11.857142857142858,0,0,5,17,5,11.5,5,16.2,0.3,-0.92,2 +Student_00008,1,18,9254,1,4,1,1,37,37,9,9,119.0,113.1,1,0,0,0,1,0,0,22,0,5,5,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_00010,1,1,9238,1,1,1,1,1,19,4,7,138.0,123.0,1,0,1,0,0,0,0,18,0,6,9,5,11.4,0,0,6,14,2,13.5,0,8.9,1.4,3.51,0 +Student_00011,1,1,9670,1,1,1,1,38,19,5,7,139.0,130.6,1,0,0,1,0,0,0,18,0,6,6,6,12.333333333333334,0,0,6,7,5,14.2,0,13.9,-0.3,0.79,2 +Student_00012,1,1,9500,1,1,1,1,19,38,9,9,136.0,119.3,1,0,0,1,0,1,0,18,0,8,8,7,13.214285714285714,0,0,8,8,7,13.214285714285714,0,12.7,3.7,-1.7,2 +Student_00013,1,1,9853,1,2,1,1,19,37,4,9,133.0,130.2,1,0,0,1,0,0,0,19,0,6,6,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_00014,1,53,9254,1,1,42,1,1,1,4,7,110.0,111.8,1,0,0,1,NA,1,0,21,0,6,7,6,10.571428571428571,0,0,6,8,5,11.0,0,8.9,1.4,3.51,2 +Student_00016,1,1,9773,1,1,1,1,19,37,9,3,127.0,120.7,1,0,0,1,0,0,0,20,0,6,6,5,13.2,0,0,6,7,0,0.0,0,15.5,2.8,-4.06,0 +Student_00018,1,17,9500,1,2,1,1,NA,1,5,4,135.0,127.3,1,0,0,1,0,0,0,18,0,7,8,7,13.30625,0,0,8,8,8,14.545,0,15.5,2.8,-4.06,2 +Student_00019,1,1,9130,1,1,1,1,3,19,3,5,137.0,136.3,1,0,0,1,0,0,0,20,0,5,8,4,12.5,1,0,5,8,4,12.25,2,10.8,1.4,1.74,2 +Student_00020,1,1,9853,1,1,1,1,19,19,7,7,140.0,124.6,1,0,0,1,0,0,0,18,0,7,7,6,11.666666666666666,0,0,7,8,6,13.5,0,16.2,0.3,-0.92,1 +Student_00021,1,1,171,1,3,1,1,1,1,9,8,122.0,120.3,0,0,0,1,0,1,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,2 +Student_00022,1,18,9556,1,4,1,1,1,38,4,7,127.0,121.8,1,0,0,1,0,0,0,20,0,7,14,7,11.4375,0,0,8,9,8,11.425,0,12.7,3.7,-1.7,1 +Student_00023,1,1,9500,1,4,1,1,19,19,1,1,142.0,125.5,1,0,0,1,0,0,0,18,0,8,12,7,12.857142857142858,0,0,8,12,7,12.857142857142858,0,12.7,3.7,-1.7,2 +Student_00024,1,1,9670,1,4,1,1,1,38,4,7,125.0,114.9,1,0,0,1,0,1,0,19,0,6,8,6,13.375,0,0,6,7,6,12.285714285714286,0,11.1,0.6,2.02,2 +Student_00025,1,1,9500,1,1,1,1,19,19,3,7,126.0,123.9,0,0,0,1,0,0,0,19,0,7,8,6,13.296666666666669,0,0,8,9,7,14.114285714285714,0,11.1,0.6,2.02,2 +Student_00029,1,1,9147,1,1,1,1,19,1,9,9,135.0,122.1,1,0,0,1,0,0,0,20,0,5,6,5,12.0,0,0,5,6,5,12.333333333333334,0,16.2,0.3,-0.92,2 +Student_00030,1,17,9500,1,2,1,1,3,3,1,10,127.0,118.8,1,0,0,NA,1,0,0,19,0,7,9,6,12.933333333333332,0,0,7,7,6,13.716666666666669,0,16.2,0.3,-0.92,1 +Student_00031,1,44,9003,1,1,39,1,4,5,4,2,150.0,150.0,0,0,0,1,1,0,0,21,0,6,15,5,11.857142857142858,0,0,6,17,5,10.571428571428571,0,16.2,0.3,-0.92,1 +Student_00032,1,51,9070,1,1,1,1,42,3,125,124,125.0,130.0,1,0,0,1,1,0,0,20,2,6,7,6,12.833333333333334,0,0,6,9,4,13.4,0,8.9,1.4,3.51,2 +Student_00033,1,1,9147,1,1,1,1,1,1,4,6,143.0,138.8,0,0,0,0,1,0,0,18,0,5,9,3,11.333333333333334,0,0,5,8,2,13.5,0,8.9,1.4,3.51,1 +Student_00034,1,18,8014,0,1,1,1,19,1,9,5,138.0,134.5,1,0,0,1,0,0,0,19,0,6,6,6,12.666666666666666,0,0,6,8,6,14.375,0,12.4,0.5,1.79,2 +Student_00035,1,1,9991,0,1,1,1,2,37,3,9,130.0,131.4,0,0,0,1,1,0,0,34,0,5,6,5,12.4,0,0,5,9,5,13.428571428571429,0,13.9,-0.3,0.79,2 +Student_00036,1,39,33,1,1,1,1,38,37,9,6,130.0,102.5,0,0,1,0,1,0,0,37,0,7,7,0,0.0,0,0,7,7,1,10.0,0,8.9,1.4,3.51,0 +Student_00037,1,39,9119,1,1,10,1,34,37,0,0,133.1,128.8,1,0,0,1,1,0,0,43,0,5,0,0,0.0,0,0,5,0,0,0.0,0,7.6,2.6,0.32,0 +Student_00039,4,39,9991,0,1,1,1,19,19,9,3,120.0,113.9,1,0,0,1,0,0,0,39,0,5,8,5,11.0,0,0,5,5,5,11.6,0,7.6,2.6,0.32,2 +Student_00041,1,1,9773,1,5,1,1,3,3,2,2,126.0,121.1,0,0,1,1,0,0,0,18,0,6,6,4,12.75,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_00042,1,1,9147,1,2,1,1,3,19,2,7,133.0,120.4,1,0,0,1,0,0,0,22,0,5,5,5,14.8,0,0,5,5,5,15.8,0,8.9,1.4,3.51,2 +Student_00043,1,1,9500,1,6,1,1,1,3,2,2,103.0,100.6,1,1,0,1,0,0,0,22,0,7,9,5,13.928,0,0,8,9,7,14.342857142857142,0,11.1,0.6,2.02,2 +Student_00044,1,17,9773,1,1,1,1,1,38,5,5,120.0,121.4,0,0,0,0,0,0,0,20,0,6,7,4,13.0,0,0,6,7,5,13.8,0,12.4,0.5,1.79,0 +Student_00045,1,39,9991,0,1,1,1,37,37,9,9,133.1,109.7,0,0,0,1,0,0,0,29,0,5,0,0,0.0,0,0,5,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_00046,1,17,9991,0,1,1,1,38,38,4,5,154.0,NA,0,0,0,1,0,0,0,24,0,5,9,2,11.5,0,0,5,11,3,14.333333333333334,1,7.6,2.6,0.32,1 +Student_00047,1,17,9238,1,2,1,1,19,19,9,9,130.0,127.6,1,0,0,1,0,0,0,18,0,6,6,6,11.666666666666666,0,0,6,8,5,13.2,0,11.1,0.6,2.02,2 +Student_00048,1,17,9500,1,6,1,1,37,19,7,7,132.0,132.4,1,0,0,1,0,1,0,22,0,7,8,6,13.516666666666666,0,0,8,9,7,13.771428571428572,0,11.1,0.6,2.02,2 +Student_00049,1,44,8014,0,1,39,1,1,19,9,9,130.0,133.4,0,0,0,1,0,1,0,NA,3,6,6,6,11.5,0,2,6,7,6,13.285714285714286,0,12.4,0.5,1.79,2 +Student_00050,1,1,9238,1,1,1,1,37,38,9,9,139.0,126.1,0,0,0,1,0,1,0,19,0,6,7,5,12.333333333333334,0,0,6,7,6,12.833333333333334,0,12.7,3.7,-1.7,2 +Student_00051,1,39,9254,1,1,1,1,19,38,9,7,130.0,113.5,0,0,0,1,0,1,0,24,0,6,6,6,13.666666666666666,0,0,6,6,6,14.166666666666666,0,12.4,0.5,1.79,2 +Student_00052,1,1,9500,1,1,1,1,37,38,6,6,139.0,121.3,1,0,0,1,0,1,0,19,0,8,10,6,11.833333333333334,0,0,8,10,6,11.833333333333334,0,9.4,-0.8,-3.12,1 +Student_00054,NA,1,9130,1,3,1,1,37,37,90,90,167.0,159.3,0,0,0,1,0,0,0,19,0,5,7,5,14.714285714285714,0,0,5,5,5,15.8,0,7.6,2.6,0.32,2 +Student_00055,1,39,9991,0,1,1,1,38,38,9,9,130.0,120.0,0,0,0,1,0,0,0,27,0,5,12,5,10.6,0,0,5,10,5,11.0,0,9.4,-0.8,-3.12,0 +Student_00057,2,7,9254,1,1,3,1,1,3,4,3,130.0,130.0,0,0,0,1,0,0,0,39,0,6,10,0,0.0,0,0,6,6,0,0.0,0,12.4,0.5,1.79,0 +Student_00058,1,39,9130,1,1,40,1,3,3,2,2,129.0,155.3,1,0,0,1,0,0,0,27,0,6,9,5,13.0,0,5,11,13,10,12.9,0,12.4,0.5,1.79,0 +Student_00059,1,17,9500,1,1,NA,1,38,38,7,10,141.0,139.8,1,0,0,1,0,0,0,18,0,8,8,8,14.935,0,0,8,8,8,14.935,0,9.4,-0.8,-3.12,2 +Student_00060,1,1,171,1,3,1,1,38,37,4,9,125.0,115.2,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,1 +Student_00062,1,44,9238,1,1,39,1,19,1,9,9,130.0,131.9,0,0,0,1,0,1,0,21,3,6,7,6,12.0,0,2,6,7,6,12.0,0,13.9,-0.3,0.79,2 +Student_00063,1,17,171,1,3,1,1,1,37,4,7,133.0,126.0,1,0,0,1,1,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,1 +Student_00064,1,17,9070,1,1,1,1,1,1,3,4,127.0,130.2,1,0,0,1,1,0,0,19,0,6,6,5,11.4,0,0,6,8,1,10.0,0,10.8,1.4,1.74,1 +Student_00066,4,42,9500,1,1,19,1,1,1,5,5,133.1,126.0,1,0,0,1,1,0,0,29,2,7,10,5,11.9,0,1,8,10,5,11.0,0,13.9,-0.3,0.79,0 +Student_00067,1,1,171,1,3,1,1,19,19,5,3,139.0,128.2,1,0,0,1,1,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,2 +Student_00068,1,44,9003,1,1,39,1,19,37,9,9,130.0,130.0,1,0,0,1,1,0,0,23,0,6,8,6,12.571428571428571,0,0,6,7,6,12.428571428571429,0,8.9,1.4,3.51,2 +Student_00069,1,1,9147,1,3,1,1,1,38,7,7,125.0,120.1,0,0,1,1,1,0,0,19,0,5,8,5,11.2,0,0,5,10,4,10.75,3,16.2,0.3,-0.92,0 +Student_00070,1,39,9254,1,1,1,1,19,37,7,10,160.0,100.0,0,0,0,1,1,0,0,26,0,6,7,6,12.0,0,0,6,8,5,10.8,0,12.7,3.7,-1.7,1 +Student_00071,1,17,9147,1,1,1,1,38,37,5,5,148.0,134.0,0,0,0,1,1,0,0,18,0,5,9,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,1 +Student_00073,1,1,171,1,1,1,1,19,19,5,10,141.0,135.8,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00074,1,17,9254,1,4,1,1,38,37,5,7,118.0,111.7,1,0,0,1,1,0,0,18,0,6,12,3,11.666666666666666,0,0,6,12,1,12.0,0,12.4,0.5,1.79,0 +Student_00075,1,1,9773,1,2,1,1,38,38,9,9,142.0,132.9,1,0,0,1,1,0,0,18,0,6,8,6,12.333333333333334,0,0,6,11,3,12.333333333333334,0,10.8,1.4,1.74,2 +Student_00076,1,17,9147,1,3,1,1,19,19,4,7,120.0,115.5,1,0,1,1,1,0,0,18,0,5,8,3,10.333333333333334,0,0,5,11,3,10.857142857142858,0,10.8,1.4,1.74,0 +Student_00077,1,18,9254,1,4,1,1,19,37,7,NA,106.0,106.0,1,0,0,1,1,1,0,21,0,6,8,4,10.5,0,0,6,11,1,11.0,0,9.4,-0.8,-3.12,0 +Student_00078,1,17,9773,1,4,1,1,1,19,9,8,121.0,120.3,1,0,1,1,1,1,0,19,0,6,6,6,13.666666666666666,0,0,6,6,6,13.333333333333334,0,8.9,1.4,3.51,2 +Student_00079,1,17,9500,1,4,1,1,38,37,9,9,150.0,130.8,0,0,0,1,1,1,0,22,0,7,7,7,14.842857142857142,0,0,8,9,8,15.055555555555555,0,16.2,0.3,-0.92,2 +Student_00080,2,39,8014,0,1,1,1,37,37,9,6,120.0,117.0,0,0,0,NA,1,0,0,33,0,6,8,6,12.0,0,0,6,6,6,11.666666666666666,0,10.8,1.4,1.74,2 +Student_00081,1,1,9853,1,6,1,1,19,19,9,9,114.0,110.2,1,0,0,1,1,0,0,20,0,6,8,5,12.2,0,0,6,7,5,12.2,0,10.8,1.4,1.74,0 +Student_00083,1,39,9003,1,1,4,1,3,3,4,2,160.0,180.4,0,0,1,1,1,0,0,24,6,12,17,6,12.166666666666666,0,7,12,14,10,13.3,0,12.4,0.5,1.79,0 +Student_00084,1,17,9254,1,1,1,1,19,19,4,4,120.0,125.5,0,0,0,1,1,0,0,18,0,5,6,5,12.0,0,0,5,8,3,11.333333333333334,0,NA,3.7,-1.7,1 +Student_00085,2,39,8014,0,1,1,1,37,37,9,6,130.0,110.0,1,0,0,1,0,0,0,33,0,6,7,6,11.0,0,0,6,11,5,11.0,0,9.4,-0.8,-3.12,2 +Student_00086,1,42,9500,1,1,1,1,37,38,9,7,160.0,161.0,1,0,0,1,0,1,0,22,0,8,8,7,13.08,0,0,8,8,7,13.08,0,10.8,1.4,1.74,2 +Student_00087,1,39,9670,1,1,1,1,1,19,4,5,120.0,100.0,0,0,0,1,0,1,0,25,0,5,7,4,10.5,0,0,5,7,5,11.6,0,9.4,-0.8,-3.12,2 +Student_00088,1,17,9070,1,1,1,1,19,38,4,0,124.0,117.6,1,0,0,1,1,0,0,20,0,6,9,6,10.666666666666666,1,0,6,6,5,11.2,0,7.6,2.6,0.32,2 +Student_00089,1,1,9147,1,6,1,1,38,37,9,9,143.0,128.7,1,0,0,1,1,0,0,23,0,5,6,4,14.0,0,0,5,5,5,13.8,0,11.1,0.6,2.02,1 +Student_00090,1,43,9119,1,2,1,1,38,19,9,6,115.0,112.2,1,0,1,1,1,0,0,18,0,5,9,2,10.0,0,0,5,9,0,0.0,0,15.5,2.8,-4.06,1 +Student_00091,1,39,9500,1,1,1,1,1,1,4,10,133.1,100.8,0,0,0,1,1,0,0,24,0,7,18,0,0.0,0,0,7,7,0,0.0,0,13.9,-0.3,0.79,0 +Student_00092,1,17,9773,1,2,1,41,19,1,9,9,133.1,105.0,1,0,0,0,0,0,1,21,0,6,6,6,14.0,0,0,6,6,6,13.5,0,8.9,1.4,3.51,2 +Student_00095,2,39,NA,0,1,1,1,37,19,9,9,133.1,114.0,0,0,0,1,0,0,0,44,2,8,11,8,11.875,0,0,6,7,6,12.333333333333334,0,12.7,3.7,-1.7,2 +Student_00096,1,15,9119,1,1,1,26,38,3,9,2,130.0,137.0,1,0,0,1,1,0,1,19,0,5,9,5,14.0,0,0,5,11,3,13.25,0,13.9,-0.3,0.79,1 +Student_00097,1,1,9773,1,5,1,1,37,1,5,5,135.0,124.9,1,0,0,1,0,0,0,18,0,6,6,6,13.666666666666666,0,0,6,6,6,13.333333333333334,0,8.9,1.4,3.51,2 +Student_00098,1,1,9500,1,5,1,1,37,37,7,7,132.0,120.3,1,0,0,1,0,1,0,18,0,7,7,7,13.75,0,0,8,9,8,14.47777777777778,0,12.4,0.5,1.79,2 +Student_00099,1,1,9085,1,1,1,1,1,2,9,1,135.0,134.3,1,0,0,1,0,0,0,19,0,5,7,5,14.2,2,0,5,7,5,13.8,0,12.7,3.7,-1.7,1 +Student_00100,1,1,9500,1,4,1,1,3,3,2,2,115.0,111.5,1,0,1,0,0,0,0,19,0,7,10,4,11.96,0,0,7,7,0,0.0,0,13.9,-0.3,0.79,0 +Student_00102,1,1,171,1,4,1,1,1,1,9,10,133.1,110.0,1,0,0,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,2 +Student_00103,2,39,8014,0,1,1,1,37,37,6,5,130.0,113.5,1,0,0,1,0,0,0,36,0,6,0,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00104,4,39,9003,1,1,12,1,37,37,9,6,133.1,160.0,0,0,0,1,0,0,0,43,13,18,19,18,14.63157894736842,0,10,13,14,13,NA,1,15.5,2.8,-4.06,2 +Student_00105,1,18,9853,1,1,1,1,19,19,9,7,123.0,117.4,1,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_00106,1,51,9070,1,1,1,1,3,1,2,8,130.0,122.2,0,0,1,1,0,0,0,20,4,10,12,10,13.0,0,5,11,11,11,12.272727272727272,0,11.1,0.6,2.02,2 +Student_00107,1,1,9238,1,2,1,1,37,38,4,7,122.0,118.2,1,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_00109,1,1,9500,1,5,1,1,3,4,4,3,111.0,108.2,1,0,0,1,0,0,0,20,2,7,9,6,13.266666666666666,0,0,7,10,5,12.3,0,12.4,0.5,1.79,0 +Student_00110,1,17,9853,1,2,1,1,19,1,9,3,133.1,107.0,1,0,0,1,0,0,0,20,0,7,12,6,11.666666666666666,0,0,7,10,3,13.0,0,16.2,0.3,-0.92,1 +Student_00111,1,1,9238,1,1,1,1,37,37,6,7,142.0,136.1,1,0,0,1,0,0,0,18,0,6,8,6,13.857142857142858,0,0,6,6,6,15.0,0,13.9,-0.3,0.79,2 +Student_00112,1,17,9147,1,2,1,1,1,38,4,7,123.0,115.3,1,0,0,1,0,1,0,18,0,5,9,3,13.0,0,0,5,11,3,11.0,0,8.9,1.4,3.51,1 +Student_00114,1,1,9773,1,3,1,1,1,38,4,7,158.0,157.0,1,0,0,1,0,0,0,18,0,6,6,6,12.666666666666666,0,0,6,7,6,12.571428571428571,0,10.8,1.4,1.74,2 +Student_00116,1,43,9500,1,1,1,1,38,38,9,5,130.0,100.0,0,0,0,1,0,0,0,20,0,7,11,6,11.616666666666667,0,0,7,7,7,13.0,0,13.9,-0.3,NA,1 +Student_00117,1,17,9238,1,1,1,1,19,37,9,7,154.0,140.4,1,0,0,1,0,1,0,20,0,6,13,2,10.0,0,0,6,12,4,10.75,0,7.6,2.6,0.32,1 +Student_00119,1,1,9085,1,2,1,1,37,38,9,7,140.0,137.0,0,0,0,1,0,0,0,18,0,5,12,5,13.142857142857142,2,0,5,6,5,11.4,0,9.4,-0.8,-3.12,2 +Student_00120,1,1,9147,1,1,1,1,2,19,4,5,127.0,121.8,0,0,0,1,0,0,0,18,0,5,5,5,12.6,0,0,5,5,5,14.0,0,11.1,0.6,2.02,2 +Student_00121,1,17,9254,1,1,1,NA,1,1,4,5,133.1,131.0,1,0,0,1,0,0,0,21,0,6,12,3,11.0,0,0,6,12,2,11.0,0,9.4,-0.8,-3.12,0 +Student_00122,1,1,9147,1,2,1,1,19,19,9,7,120.0,118.6,1,0,0,1,0,0,0,19,0,5,8,5,10.8,0,0,5,9,4,11.25,2,16.2,0.3,-0.92,2 +Student_00123,1,1,171,1,1,1,1,3,19,2,9,137.0,122.3,0,0,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_00124,1,1,9670,1,1,1,1,38,38,9,9,131.0,127.9,0,0,0,1,0,1,0,19,0,5,5,5,12.8,0,0,5,5,5,14.2,0,9.4,-0.8,-3.12,2 +Student_00125,1,1,9085,1,1,1,1,19,38,4,7,130.0,121.3,1,0,0,1,0,0,0,19,0,6,15,6,14.166666666666666,0,0,6,13,6,12.2,0,15.5,2.8,-4.06,2 +Student_00126,1,17,9556,1,6,1,1,1,1,4,5,122.0,117.1,1,0,0,1,0,0,0,19,0,7,12,5,12.1,0,0,7,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_00128,1,1,9853,1,1,1,1,19,38,9,3,146.0,145.3,1,0,0,1,0,1,0,18,0,6,8,5,12.8,0,0,6,7,5,13.4,0,9.4,-0.8,-3.12,1 +Student_00130,1,17,9500,1,6,1,1,1,37,8,9,132.0,128.0,1,0,0,1,0,0,0,19,0,7,7,7,13.467142857142855,0,0,8,9,8,15.011111111111113,0,12.4,0.5,1.79,2 +Student_00132,1,17,9070,1,2,1,1,37,37,9,9,130.0,123.7,1,0,0,1,0,0,0,18,0,6,6,6,12.333333333333334,0,0,6,6,6,13.0,0,7.6,2.6,0.32,2 +Student_00133,1,1,9147,1,4,1,1,1,19,4,8,126.0,120.1,1,0,0,1,0,0,0,19,0,5,7,5,12.4,0,0,5,5,5,14.6,0,8.9,1.4,3.51,2 +Student_00134,1,17,9500,1,6,1,1,1,19,3,3,148.0,131.7,1,0,0,1,0,0,0,19,0,7,8,5,14.0,0,0,7,7,0,0.0,0,13.9,-0.3,0.79,0 +Student_00135,1,43,9238,1,1,1,1,38,37,9,7,130.0,133.2,0,0,0,1,0,0,0,20,5,9,15,9,11.666666666666666,0,2,7,8,7,11.714285714285714,0,7.6,2.6,0.32,2 +Student_00136,1,1,9670,1,1,1,1,1,38,3,9,117.0,109.3,0,0,1,0,0,1,0,19,0,6,7,5,12.0,0,0,6,9,4,12.5,0,12.4,0.5,1.79,0 +Student_00137,1,17,9670,1,1,1,1,19,19,5,5,120.0,113.0,1,0,0,1,0,0,0,20,0,5,7,4,12.2,0,0,5,5,4,11.5,0,7.6,2.6,0.32,2 +Student_00138,1,1,9773,1,1,1,1,1,1,141,175,153.0,157.9,0,0,1,1,0,1,0,18,0,6,6,6,14.833333333333334,0,0,6,6,6,14.833333333333334,0,8.9,1.4,3.51,2 +Student_00139,1,1,9500,1,2,1,1,19,1,4,7,117.0,112.1,0,0,0,1,0,1,0,20,0,7,9,5,13.188,0,0,8,9,7,12.892857142857142,0,11.1,0.6,2.02,1 +Student_00140,1,18,9500,1,1,1,1,19,1,4,8,178.0,174.7,0,0,0,1,0,0,0,18,0,7,8,7,17.125,0,0,8,8,8,17.5875,0,13.9,-0.3,0.79,2 +Student_00141,1,1,9500,1,5,1,1,37,37,9,9,129.0,128.8,1,0,0,1,0,0,0,19,0,7,7,6,12.666666666666666,0,0,7,7,6,12.666666666666666,0,7.6,2.6,0.32,2 +Student_00142,1,1,9773,1,6,1,1,19,1,4,4,116.0,110.1,1,0,0,1,0,1,0,19,0,6,8,6,12.666666666666666,0,0,6,10,5,12.0,0,NA,0.5,1.79,2 +Student_00143,1,51,9147,1,1,1,1,3,1,3,3,99.0,99.7,1,0,1,0,0,0,0,22,0,5,8,0,0.0,0,0,5,7,0,0.0,0,8.9,1.4,3.51,1 +Student_00144,1,1,9238,1,3,1,1,1,12,9,10,135.0,121.0,1,0,0,1,0,1,0,19,0,6,7,6,11.333333333333334,0,0,6,6,6,11.5,0,12.4,0.5,1.79,2 +Student_00145,1,1,9500,1,3,1,1,19,19,9,7,141.0,131.7,1,0,0,1,0,1,0,19,0,7,10,7,13.605,0,0,8,11,8,12.33125,0,15.5,2.8,-4.06,2 +Student_00146,1,17,9853,1,5,1,1,37,38,5,6,132.0,119.1,1,0,0,1,0,1,0,19,0,6,10,5,12.0,0,0,6,9,5,10.8,0,9.4,-0.8,-3.12,2 +Student_00148,1,17,9254,1,1,1,1,1,37,9,10,113.0,117.2,1,0,0,1,0,0,0,20,0,6,8,5,11.2,0,0,6,12,3,11.666666666666666,0,7.6,2.6,0.32,0 +Student_00149,1,1,9147,1,1,1,1,3,19,2,10,134.0,128.8,0,0,0,1,0,0,0,18,0,5,10,5,13.375,0,0,5,9,5,14.166666666666666,0,13.9,-0.3,0.79,2 +Student_00150,1,1,9500,1,1,1,1,1,19,9,9,136.0,131.5,0,0,0,1,0,1,0,20,0,7,8,6,13.863333333333337,0,0,8,9,7,14.178571428571429,0,11.1,0.6,2.02,2 +Student_00151,1,1,171,1,1,1,1,3,37,2,8,136.0,121.7,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,1 +Student_00152,1,1,9085,1,1,1,1,1,38,4,7,129.0,123.4,0,0,0,1,0,0,0,19,0,5,6,5,12.4,0,0,5,6,5,13.4,0,7.6,2.6,0.32,2 +Student_00153,1,17,9853,1,1,1,1,38,38,7,6,138.0,124.7,1,0,0,1,0,0,0,18,0,6,11,3,12.333333333333334,0,0,6,10,5,10.833333333333334,0,9.4,-0.8,-3.12,1 +Student_00154,1,1,9853,1,1,1,1,37,37,9,9,137.0,132.8,1,0,0,1,0,0,0,18,0,6,7,6,13.333333333333334,0,0,6,8,5,11.8,0,7.6,2.6,0.32,2 +Student_00155,1,43,9853,1,1,1,1,3,37,2,5,115.0,108.7,1,0,0,1,0,0,0,21,0,6,10,3,12.666666666666666,0,0,6,12,3,10.0,0,9.4,-0.8,-3.12,0 +Student_00156,1,1,9853,1,1,1,1,38,37,6,6,129.0,138.1,0,0,0,1,0,0,0,19,0,6,8,6,12.0,0,0,6,10,4,11.5,0,7.6,2.6,0.32,0 +Student_00157,1,1,9147,1,1,1,1,38,38,9,9,131.0,126.5,0,0,0,1,0,1,0,18,0,5,5,5,10.6,0,0,5,5,5,11.8,0,12.4,0.5,1.79,2 +Student_00160,1,39,8014,0,1,NA,1,1,19,6,8,120.0,122.0,0,0,0,1,0,1,0,24,0,6,11,5,11.0,0,0,6,9,5,12.6,0,11.1,0.6,2.02,2 +Student_00161,1,1,9670,1,1,1,1,19,1,4,1,128.0,118.2,0,0,0,1,0,0,0,NA,0,6,6,6,13.166666666666666,0,0,6,9,6,13.0,0,10.8,1.4,1.74,0 +Student_00162,1,1,9500,1,1,1,1,19,37,9,7,127.0,123.9,1,0,0,1,0,1,0,18,0,7,9,7,12.855555555555554,0,0,8,12,7,12.761111111111113,0,15.5,2.8,-4.06,2 +Student_00163,1,1,9500,1,2,1,1,19,19,9,9,134.0,125.8,1,0,0,1,0,0,0,18,0,7,8,7,14.91875,0,0,8,8,8,15.355,0,15.5,2.8,-4.06,2 +Student_00165,1,17,9670,1,2,1,1,1,19,5,4,124.0,124.4,0,0,0,1,0,0,0,19,0,5,5,5,14.2,0,0,5,5,5,14.2,0,7.6,2.6,0.32,2 +Student_00166,1,17,9773,1,1,1,1,19,37,7,7,133.1,126.0,0,0,0,1,0,1,0,19,0,6,6,6,12.5,0,0,6,7,6,13.0,0,15.5,2.8,-4.06,2 +Student_00167,3,39,9003,1,1,1,1,1,37,6,6,170.0,170.0,0,0,1,1,0,0,0,47,0,1,1,0,NA,0,0,6,0,0,0.0,0,8.9,1.4,3.51,1 +Student_00168,1,17,9238,1,3,1,1,19,19,7,8,125.0,121.5,0,0,0,1,0,0,0,19,0,6,10,5,11.666666666666666,0,0,6,12,4,11.0,0,13.9,-0.3,0.79,2 +Student_00169,1,39,9500,1,1,3,1,2,2,1,1,130.0,130.0,0,0,0,1,0,0,0,29,1,8,8,7,14.257142857142856,0,1,8,8,7,14.257142857142856,0,12.7,3.7,-1.7,2 +Student_00170,1,43,9238,1,1,1,1,19,19,4,8,125.0,117.0,1,0,0,1,0,0,0,21,0,6,13,3,12.0,0,0,6,12,2,11.333333333333334,0,16.2,0.3,-0.92,0 +Student_00171,1,39,9085,1,1,1,1,37,19,9,7,130.0,130.0,1,0,0,1,0,0,0,28,0,5,13,4,11.25,1,0,5,11,4,10.5,0,12.7,3.7,-1.7,1 +Student_00173,1,17,9500,1,1,NA,1,2,38,4,5,131.0,132.3,1,0,0,1,0,0,0,19,0,7,7,6,11.683333333333332,0,0,7,7,6,11.683333333333332,0,7.6,2.6,0.32,2 +Student_00174,1,42,8014,0,1,1,1,19,2,4,6,150.0,148.0,0,0,0,1,0,0,0,26,0,6,10,3,11.666666666666666,0,0,6,8,5,12.0,0,9.4,-0.8,-3.12,2 +Student_00175,1,17,9254,1,2,1,1,37,37,9,8,125.0,122.6,1,0,1,0,0,0,0,20,0,6,8,4,11.75,0,0,6,6,6,13.166666666666666,0,11.1,0.6,2.02,0 +Student_00176,1,1,9670,1,1,1,1,37,37,9,9,131.0,123.0,1,0,0,1,0,1,0,18,0,5,6,3,11.666666666666666,0,0,5,6,4,13.5,0,7.6,2.6,0.32,1 +Student_00181,1,43,9853,1,1,1,1,3,1,3,3,140.0,128.3,1,0,0,1,0,0,0,35,19,21,21,21,12.61904761904762,0,13,19,19,19,12.789473684210526,0,12.4,0.5,1.79,2 +Student_00182,1,44,9991,0,1,39,1,37,19,9,8,140.0,140.0,0,0,0,1,0,1,0,26,2,6,7,6,12.666666666666666,0,2,6,7,6,13.166666666666666,1,9.4,-0.8,-3.12,1 +Student_00183,1,39,9773,1,1,19,1,19,19,3,4,133.1,104.0,0,0,1,0,0,0,0,27,0,6,6,5,12.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_00184,1,18,9070,1,3,1,1,1,37,5,5,131.0,122.3,1,0,0,0,0,0,0,19,0,6,6,6,12.166666666666666,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_00185,1,17,9254,1,2,1,1,1,19,4,6,143.0,135.0,0,0,0,1,0,0,0,20,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_00187,1,43,9238,1,1,1,1,1,37,5,9,143.0,126.6,0,0,1,0,0,0,0,21,5,10,18,8,11.5,0,0,6,12,4,10.0,0,9.4,-0.8,-3.12,1 +Student_00189,1,39,9085,1,1,1,1,1,19,9,9,133.1,162.3,1,0,0,1,0,0,0,24,0,6,10,2,11.0,0,0,6,6,0,0.0,0,8.9,1.4,3.51,0 +Student_00193,1,39,9147,1,1,1,1,12,3,4,3,140.0,118.0,1,0,0,1,0,0,0,24,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00194,1,51,9853,1,1,1,1,1,1,4,10,139.0,134.0,0,0,0,1,NA,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00195,1,1,9500,1,4,1,1,38,38,9,8,142.0,129.8,1,0,0,1,0,0,0,18,0,8,8,7,12.242857142857144,0,0,8,8,7,12.242857142857144,0,12.7,3.7,-1.7,2 +Student_00197,1,18,9500,1,6,1,1,37,37,5,5,126.0,122.8,1,0,0,1,0,0,0,18,0,8,8,8,12.93375,0,0,8,8,8,12.93375,0,9.4,-0.8,-3.12,2 +Student_00198,1,7,9119,1,1,3,1,3,2,2,2,150.0,150.0,0,0,0,1,0,0,0,35,0,5,0,0,0.0,0,0,5,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_00199,1,1,9853,1,1,1,1,19,19,3,8,130.0,131.8,0,0,0,1,0,0,0,18,0,7,9,7,12.571428571428571,0,0,7,8,7,14.428571428571429,0,11.1,0.6,2.02,2 +Student_00200,1,39,9500,1,1,1,1,1,3,175,121,120.0,105.9,0,0,0,1,0,0,0,35,0,3,4,3,11.816666666666668,0,0,3,3,3,11.333333333333334,0,11.1,0.6,2.02,1 +Student_00202,1,1,9238,1,4,1,1,19,19,4,0,127.0,127.4,1,0,0,1,0,0,0,20,0,6,8,6,11.166666666666666,0,0,6,6,6,11.333333333333334,0,7.6,2.6,0.32,2 +Student_00203,1,1,9500,1,4,1,1,19,19,7,7,140.0,129.5,1,0,0,1,0,0,0,18,0,8,8,7,12.324285714285711,0,0,8,8,7,12.324285714285711,0,10.8,1.4,1.74,2 +Student_00204,1,44,9238,1,1,39,1,38,38,5,10,130.0,126.7,0,0,1,NA,0,0,0,21,3,6,6,6,12.166666666666666,0,2,6,7,6,11.714285714285714,0,13.9,-0.3,0.79,2 +Student_00205,NA,17,9238,1,2,1,1,19,37,9,8,128.0,116.5,0,0,0,1,0,1,0,18,0,6,11,5,11.142857142857142,0,0,6,11,4,11.25,0,16.2,0.3,-0.92,2 +Student_00206,1,1,9238,1,1,1,1,34,34,0,0,132.0,119.1,1,0,0,1,0,0,0,18,0,6,9,4,11.0,0,0,6,9,4,10.75,0,7.6,2.6,0.32,2 +Student_00209,1,1,9085,1,1,1,1,19,1,8,7,120.0,115.1,1,0,0,1,0,0,0,19,0,6,8,6,13.857142857142858,0,0,6,9,5,13.4,0,13.9,-0.3,0.79,2 +Student_00210,1,39,9254,1,1,19,1,3,19,2,3,133.1,124.5,0,0,0,1,0,1,0,36,0,6,7,6,13.714285714285714,0,0,6,6,5,12.8,0,16.2,0.3,-0.92,0 +Student_00211,1,1,9500,1,2,1,1,38,1,7,4,131.0,128.3,1,0,0,1,0,1,0,18,0,8,8,7,12.642857142857142,0,0,8,8,7,NA,0,12.7,3.7,-1.7,2 +Student_00212,1,1,9500,1,1,1,1,37,37,9,9,149.0,136.0,0,0,0,1,0,1,0,18,0,7,7,6,12.916666666666666,0,0,7,7,6,12.916666666666666,0,7.6,2.6,0.32,2 +Student_00213,1,43,9130,1,1,1,1,1,3,9,2,140.0,140.0,1,0,0,1,0,1,0,20,0,6,8,6,15.625,0,0,6,8,6,15.857142857142858,0,13.9,-0.3,0.79,2 +Student_00214,1,39,9991,0,1,1,1,37,37,9,9,133.1,126.3,0,0,0,1,0,1,0,26,0,5,7,0,0.0,0,0,5,8,0,0.0,0,16.2,0.3,-0.92,0 +Student_00215,1,43,9773,1,1,1,1,1,1,4,5,122.0,126.9,0,0,0,1,0,0,0,21,0,6,8,6,11.714285714285714,0,0,6,7,6,12.0,0,7.6,2.6,0.32,2 +Student_00217,1,18,9147,1,1,1,1,19,3,5,5,121.0,115.8,1,0,0,1,0,1,0,19,0,5,7,5,11.6,0,0,5,5,5,11.6,0,12.4,0.5,1.79,2 +Student_00219,1,39,8014,0,1,1,1,1,19,5,4,133.1,102.5,0,0,0,1,0,1,0,27,0,6,16,1,10.0,0,0,6,13,0,0.0,0,8.9,1.4,3.51,0 +Student_00220,1,17,9085,1,1,1,1,19,37,1,3,121.0,131.5,0,0,0,1,0,0,0,21,0,5,10,0,0.0,1,0,5,9,2,13.5,0,7.6,2.6,0.32,0 +Student_00221,1,1,9147,1,1,1,1,38,38,7,7,133.0,147.0,0,0,0,1,0,1,0,18,0,5,7,4,NA,0,0,5,8,3,12.333333333333334,0,9.4,-0.8,-3.12,2 +Student_00222,2,1,9853,1,4,1,1,37,37,5,7,134.0,122.5,0,1,0,1,0,1,0,19,0,6,6,6,13.333333333333334,0,0,6,6,6,14.5,0,10.8,1.4,1.74,2 +Student_00223,1,1,9254,1,3,1,1,1,1,3,3,115.0,117.5,1,0,0,1,0,0,0,18,0,6,9,4,NA,0,0,6,13,2,12.5,0,9.4,-0.8,-3.12,0 +Student_00224,1,51,9500,1,1,1,1,19,1,5,9,127.0,150.0,0,0,0,1,0,1,0,19,0,7,9,5,13.85,0,0,8,9,7,12.19285714285714,0,11.1,0.6,2.02,2 +Student_00225,1,18,9500,1,1,1,1,1,38,4,5,135.0,127.5,1,0,0,1,0,1,0,19,0,7,8,6,13.741666666666667,0,0,8,9,7,14.9125,0,16.2,0.3,-0.92,2 +Student_00226,2,7,9991,0,1,43,1,40,5,3,3,140.0,140.0,0,0,0,1,0,0,0,33,2,6,7,6,15.333333333333334,0,0,5,5,5,15.8,0,11.1,0.6,2.02,2 +Student_00227,2,7,9147,1,1,3,1,1,4,3,10,130.0,130.0,0,0,0,1,NA,0,0,45,0,5,6,5,11.0,0,0,5,5,5,13.8,0,12.4,0.5,1.79,2 +Student_00229,1,39,9670,1,2,1,1,34,34,0,0,140.0,97.0,1,0,0,1,0,0,0,28,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00230,1,43,9500,1,1,1,1,1,1,5,8,120.0,112.0,1,0,0,1,0,1,0,19,0,8,15,7,11.571428571428571,0,0,8,15,7,11.571428571428571,0,12.7,3.7,-1.7,2 +Student_00231,1,1,9254,1,2,1,1,1,37,4,5,140.0,123.6,1,0,0,1,0,0,0,18,0,6,10,6,12.857142857142858,0,0,6,6,3,12.666666666666666,0,12.7,3.7,-1.7,2 +Student_00233,1,1,9670,1,2,1,1,1,3,4,3,135.0,133.3,0,0,0,1,0,0,0,19,0,5,5,5,13.0,0,0,5,5,5,13.2,0,9.4,-0.8,-3.12,2 +Student_00234,1,1,9254,1,1,1,1,1,37,9,9,123.0,132.1,0,0,0,1,0,1,0,21,0,6,9,5,11.0,0,0,6,8,5,12.0,0,15.5,2.8,-4.06,2 +Student_00235,1,1,9147,1,1,1,1,37,1,9,10,133.1,100.0,0,0,0,1,0,0,0,21,0,5,12,3,12.0,0,0,5,12,1,15.0,3,16.2,0.3,-0.92,0 +Student_00236,1,1,9238,1,1,1,1,38,37,9,9,154.0,140.4,0,0,0,1,0,1,0,22,0,6,6,5,12.6,0,0,6,6,6,13.0,0,NA,1.4,1.74,2 +Student_00238,1,17,9238,1,2,1,1,37,37,3,9,133.0,119.7,0,1,0,1,0,1,0,NA,0,6,9,6,11.333333333333334,0,0,6,9,6,11.571428571428571,0,15.5,2.8,-4.06,2 +Student_00239,1,1,9130,1,1,1,1,19,1,9,9,126.0,122.5,1,0,0,0,0,0,0,25,0,5,14,4,13.5,2,0,5,10,4,14.25,0,9.4,-0.8,-3.12,0 +Student_00240,1,39,9085,1,1,19,1,19,19,9,7,133.1,140.0,0,0,1,0,0,0,0,24,2,6,11,3,11.75,0,1,6,14,3,10.333333333333334,0,16.2,0.3,-0.92,0 +Student_00241,1,1,9500,1,3,1,1,3,1,4,4,125.0,119.4,1,0,0,1,0,0,0,19,0,7,10,6,12.471428571428572,0,0,7,8,7,11.4625,0,12.4,0.5,1.79,1 +Student_00243,1,1,9147,1,2,1,1,37,19,5,5,118.0,119.1,1,0,0,1,0,1,0,20,0,5,5,5,11.6,0,0,5,5,5,13.6,0,12.4,0.5,1.79,2 +Student_00244,1,39,9147,1,1,1,1,37,1,9,1,120.0,122.7,0,0,0,0,0,0,0,25,0,5,5,0,0.0,0,0,5,9,0,0.0,0,10.8,1.4,1.74,0 +Student_00245,NA,1,9147,1,1,1,1,38,19,9,10,127.0,117.9,0,0,0,1,0,1,0,20,5,10,13,9,12.9,0,4,10,12,10,12.363636363636363,0,8.9,1.4,3.51,2 +Student_00246,1,7,9500,1,1,3,1,19,38,5,3,130.0,130.0,0,0,0,1,0,0,0,23,0,8,8,8,13.22,0,0,8,8,8,13.22,0,9.4,-0.8,-3.12,2 +Student_00248,1,44,9003,1,1,39,1,37,37,9,10,130.0,130.0,0,0,1,0,0,0,0,29,0,6,13,3,12.75,0,0,6,8,3,11.333333333333334,0,13.9,-0.3,0.79,0 +Student_00249,1,1,9254,1,3,1,1,19,37,4,7,121.0,116.8,1,0,0,1,0,0,0,21,0,6,8,6,11.333333333333334,0,0,6,8,4,12.25,0,11.1,0.6,2.02,2 +Student_00250,1,1,9670,1,1,1,1,19,1,9,8,136.0,123.4,1,0,0,1,0,1,0,18,0,6,10,6,13.25,0,0,6,13,5,14.142857142857142,0,11.1,0.6,2.02,2 +Student_00252,1,1,9773,1,3,1,1,38,37,7,7,131.0,127.2,1,0,0,1,0,1,0,18,0,6,6,6,15.0,0,0,6,6,6,12.833333333333334,0,8.9,1.4,3.51,0 +Student_00253,1,1,9085,1,1,1,1,9,19,90,6,122.0,103.4,0,0,0,1,0,0,0,19,0,5,6,5,14.4,0,0,5,6,5,13.0,0,7.6,2.6,0.32,2 +Student_00254,1,1,9773,1,1,1,1,37,37,9,8,127.0,123.2,1,0,0,1,0,0,0,18,0,6,12,1,11.0,0,0,6,12,0,0.0,0,9.4,-0.8,-3.12,1 +Student_00255,1,17,9147,1,1,1,1,1,1,4,4,136.0,124.1,0,0,0,1,0,0,0,18,0,5,8,5,NA,0,0,5,6,5,10.8,0,8.9,1.4,3.51,2 +Student_00256,2,39,9556,1,1,19,1,38,37,7,7,133.1,99.5,1,0,1,0,0,1,0,37,0,7,13,1,16.0,0,0,7,12,0,0.0,0,8.9,1.4,3.51,0 +Student_00257,1,17,9991,0,1,40,1,37,37,6,6,127.0,124.9,0,0,0,1,0,0,0,29,0,5,10,5,13.571428571428571,0,0,5,14,5,12.333333333333334,3,16.2,0.3,-0.92,2 +Student_00258,1,17,9070,1,3,NA,1,37,37,9,9,116.0,110.8,0,0,0,1,0,0,0,18,0,6,6,6,11.833333333333334,0,0,6,6,6,12.5,0,7.6,2.6,0.32,1 +Student_00261,NA,1,9254,1,1,1,1,37,38,9,7,131.0,137.0,0,0,0,1,0,1,0,20,0,6,8,6,11.166666666666666,0,0,6,10,5,10.6,0,15.5,2.8,-4.06,2 +Student_00262,1,39,8014,0,1,1,1,37,37,99,99,100.0,100.0,0,0,0,1,0,0,0,34,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_00263,1,NA,9119,1,1,1,1,37,38,9,9,130.0,120.0,0,0,1,0,0,0,0,30,8,12,17,8,11.75,0,6,12,19,6,12.166666666666666,2,7.6,2.6,0.32,0 +Student_00264,1,1,9238,1,1,1,1,1,1,4,4,135.0,122.8,0,0,0,1,0,0,0,18,0,6,7,6,14.0,0,0,6,7,6,14.0,0,10.8,1.4,1.74,2 +Student_00266,1,1,9773,1,2,1,1,3,1,1,3,146.0,149.2,1,0,0,1,0,0,0,18,0,6,11,4,12.25,0,0,6,10,3,11.666666666666666,0,9.4,-0.8,-3.12,2 +Student_00267,1,17,9500,1,4,1,1,4,1,2,3,146.0,140.0,1,0,0,1,0,0,0,18,0,8,8,7,14.828571428571427,0,0,8,8,7,14.828571428571427,0,12.7,3.7,-1.7,2 +Student_00268,1,1,9773,1,2,1,1,38,38,9,9,154.0,133.4,1,0,0,1,0,1,0,19,0,6,7,5,11.4,0,0,6,8,5,12.8,0,12.7,3.7,-1.7,2 +Student_00269,1,1,9070,1,1,1,1,37,37,9,9,137.0,126.2,1,0,0,1,0,1,0,19,0,6,6,6,13.0,0,0,6,8,6,12.5,0,10.8,1.4,1.74,2 +Student_00271,1,44,9003,1,1,39,1,37,38,4,8,150.0,150.0,0,0,0,1,0,1,0,21,0,6,9,6,12.666666666666666,0,0,6,8,5,12.8,0,13.9,-0.3,0.79,2 +Student_00272,1,1,9147,1,2,1,1,1,19,9,9,121.0,113.7,1,0,0,0,0,0,0,20,0,5,10,2,10.0,0,0,5,12,1,13.0,0,7.6,2.6,0.32,0 +Student_00273,1,17,9147,1,1,1,1,12,19,4,8,122.0,117.8,1,0,0,1,0,0,0,20,0,5,10,5,13.5,0,0,5,8,5,12.333333333333334,0,13.9,-0.3,0.79,2 +Student_00274,1,1,9500,1,1,1,1,5,1,2,5,143.0,136.7,0,0,0,1,0,0,0,19,2,7,8,7,12.67,0,1,8,8,8,13.55,0,11.1,0.6,2.02,2 +Student_00275,1,1,9238,1,1,1,1,1,38,4,5,152.0,144.7,0,0,0,1,0,0,0,20,0,6,8,6,14.5,0,0,6,7,6,15.428571428571429,0,16.2,0.3,-0.92,2 +Student_00277,1,42,9853,1,1,1,1,37,38,3,3,120.0,113.7,0,0,0,1,0,0,0,20,0,6,8,5,11.0,0,0,6,10,3,10.666666666666666,0,12.7,3.7,-1.7,0 +Student_00278,2,7,9130,1,1,3,1,5,4,2,0,140.0,140.0,0,0,1,0,0,0,0,29,7,9,16,7,11.555555555555555,4,5,7,12,5,13.2,2,7.6,2.6,0.32,0 +Student_00279,1,1,9500,1,1,1,1,19,19,5,6,143.0,142.3,0,0,0,1,0,1,0,18,0,7,7,7,13.79714285714286,0,0,8,8,8,13.775,0,12.4,0.5,1.79,1 +Student_00280,1,1,9500,1,1,1,1,19,19,5,5,129.0,119.6,1,0,0,1,0,1,0,20,0,7,8,7,14.00375,0,0,8,11,7,13.812857142857142,0,15.5,2.8,-4.06,2 +Student_00282,4,1,8014,0,1,1,1,39,19,4,10,133.1,143.0,1,0,0,1,0,1,0,47,0,6,9,5,14.166666666666666,0,0,6,7,6,14.166666666666666,0,16.2,0.3,-0.92,2 +Student_00283,2,51,9991,0,1,1,1,37,37,8,4,127.0,100.1,0,0,0,1,0,0,0,31,1,5,5,5,14.0,0,0,5,5,5,13.8,0,8.9,1.4,3.51,2 +Student_00284,1,1,9070,1,1,1,1,19,37,7,5,126.0,119.4,0,0,0,1,0,1,0,21,0,6,7,5,13.8,0,0,6,6,6,12.833333333333334,0,16.2,0.3,-0.92,2 +Student_00288,1,39,8014,0,1,15,1,34,1,90,2,170.0,101.0,0,0,0,1,0,0,0,32,0,6,9,4,12.0,0,0,6,12,4,11.5,0,7.6,2.6,0.32,2 +Student_00289,1,18,8014,0,2,1,1,3,1,3,4,117.0,111.8,1,0,0,1,0,1,0,19,0,6,8,6,10.833333333333334,0,0,6,9,6,11.5,0,10.8,1.4,1.74,2 +Student_00290,1,39,9500,1,1,1,1,3,3,1,1,140.0,140.0,1,0,0,1,0,0,0,24,0,8,8,8,13.385,0,0,8,8,8,13.385,0,9.4,-0.8,-3.12,2 +Student_00291,1,17,9085,1,4,1,1,19,19,4,10,123.0,124.4,1,0,0,1,0,0,0,19,0,6,14,6,15.666666666666666,0,0,6,9,6,14.5,0,15.5,2.8,-4.06,2 +Student_00292,1,44,9003,1,1,39,1,19,37,6,6,150.0,150.0,0,0,1,1,0,1,0,19,0,6,9,6,14.333333333333334,0,0,6,7,6,13.833333333333334,0,13.9,-0.3,0.79,2 +Student_00293,1,44,9003,1,1,39,1,37,37,9,4,140.0,140.0,0,0,0,1,0,0,0,24,0,6,10,6,11.428571428571429,0,0,6,12,5,13.0,0,12.4,0.5,1.79,1 +Student_00294,1,17,9238,1,4,1,1,19,19,191,144,123.0,116.0,1,0,0,1,0,1,0,18,0,6,9,6,11.666666666666666,0,0,6,8,6,11.666666666666666,0,8.9,1.4,3.51,2 +Student_00295,1,1,9070,1,1,1,1,38,37,3,6,130.0,135.6,1,0,0,1,0,1,0,19,0,6,9,5,12.0,0,0,6,10,2,11.333333333333334,0,8.9,1.4,3.51,0 +Student_00296,2,1,9500,1,1,1,1,3,38,2,4,137.0,121.0,0,0,0,NA,0,1,0,19,0,8,8,7,14.725714285714288,0,0,8,8,7,14.725714285714288,0,10.8,1.4,1.74,2 +Student_00298,1,1,9238,1,1,1,1,1,1,3,3,125.0,125.7,1,0,0,1,0,0,0,18,0,6,10,6,11.571428571428571,0,0,6,8,6,12.333333333333334,0,12.4,0.5,1.79,2 +Student_00299,1,17,9556,1,4,1,1,1,1,4,10,112.0,107.1,1,0,0,1,0,0,0,20,0,7,7,7,12.5,0,0,8,8,8,13.1375,0,12.4,0.5,1.79,2 +Student_00301,1,17,9670,1,4,1,1,38,38,9,7,135.0,127.0,1,0,0,1,0,0,0,18,0,6,10,6,12.25,0,0,6,9,6,13.714285714285714,0,11.1,0.6,2.02,2 +Student_00302,1,1,9085,1,2,1,1,38,37,9,9,117.0,113.5,1,0,0,1,0,1,0,21,0,5,7,4,12.0,0,0,5,5,5,12.2,0,10.8,1.4,1.74,2 +Student_00303,1,1,9500,1,1,1,1,19,19,4,9,160.0,154.4,0,0,0,1,0,1,0,18,0,7,9,7,15.116666666666667,0,0,8,9,8,16.168888888888887,0,15.5,2.8,-4.06,2 +Student_00304,1,51,9670,1,1,1,1,19,19,5,5,136.0,122.0,0,0,1,0,0,0,0,18,0,5,6,2,12.5,0,0,5,6,4,10.25,0,9.4,-0.8,-3.12,0 +Student_00305,1,17,9238,1,2,1,1,1,11,4,3,143.0,128.0,1,0,0,1,0,0,0,19,0,6,11,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00308,1,39,9130,1,1,3,1,3,1,90,90,150.0,150.0,1,0,0,1,0,0,0,34,1,5,6,1,11.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_00309,1,1,9085,1,3,1,1,11,11,90,90,142.0,155.3,0,0,0,1,0,0,0,19,0,5,5,5,15.2,0,0,5,6,5,13.2,0,7.6,2.6,0.32,2 +Student_00310,1,44,9130,1,1,39,1,37,37,7,8,120.0,120.0,1,0,1,0,0,0,0,19,2,6,7,5,11.6,0,1,6,12,2,11.0,0,12.4,0.5,1.79,0 +Student_00311,1,51,9238,1,1,1,1,3,19,2,1,160.0,116.1,0,0,1,1,0,0,0,26,0,6,6,6,14.833333333333334,0,0,6,7,6,15.142857142857142,0,11.1,0.6,2.02,2 +Student_00312,1,17,9853,1,1,1,1,34,34,0,0,133.1,118.9,1,0,0,1,0,0,0,21,0,6,12,3,11.333333333333334,0,0,6,10,3,11.333333333333334,0,7.6,2.6,0.32,0 +Student_00313,1,17,9147,1,2,1,1,19,19,4,8,142.0,127.3,0,0,0,1,0,1,0,18,0,5,5,5,11.2,0,0,5,5,5,11.8,0,11.1,0.6,2.02,2 +Student_00314,1,17,9853,1,4,1,1,38,38,5,7,121.0,113.7,1,0,0,1,NA,1,0,20,0,6,8,5,13.4,0,0,6,9,5,13.666666666666666,0,9.4,-0.8,-3.12,2 +Student_00315,1,51,9147,1,1,1,1,1,1,4,4,135.0,118.5,0,0,0,1,0,0,0,25,0,5,12,2,10.5,0,0,5,5,0,0.0,0,11.1,0.6,2.02,0 +Student_00316,1,1,9147,1,1,1,1,1,38,4,3,153.0,146.7,0,0,0,1,0,0,0,18,0,5,5,5,16.2,0,0,5,5,5,16.4,0,11.1,0.6,2.02,2 +Student_00317,1,1,9500,1,1,1,1,19,19,3,6,140.0,124.3,1,0,0,1,0,1,0,18,0,7,7,7,14.542857142857144,0,0,8,11,8,14.88181818181818,0,16.2,0.3,-0.92,2 +Student_00318,1,1,9500,1,1,1,1,41,19,3,5,152.0,137.8,0,0,0,1,NA,0,0,19,0,7,7,7,13.694285714285714,0,0,8,9,8,14.355555555555554,0,11.1,0.6,2.02,2 +Student_00319,1,1,9238,1,1,1,1,19,38,5,9,120.0,130.2,0,0,0,1,0,1,0,18,0,6,8,6,11.285714285714286,0,0,6,10,6,11.857142857142858,0,12.4,0.5,1.79,2 +Student_00320,1,17,9500,1,1,1,1,38,38,7,7,160.0,147.8,0,0,0,1,0,0,0,20,0,7,11,6,11.757142857142856,0,0,8,12,6,13.083333333333334,0,15.5,2.8,-4.06,1 +Student_00321,1,7,9085,1,1,40,1,19,19,9,5,150.0,150.0,0,0,1,0,0,0,0,26,0,3,3,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_00323,1,1,9500,1,1,1,1,1,1,5,1,150.0,155.6,0,0,0,1,0,0,0,19,0,7,7,7,14.3,0,0,8,9,8,14.055555555555555,0,16.2,0.3,-0.92,2 +Student_00324,1,43,9147,1,4,1,1,37,37,9,9,124.0,117.4,0,0,0,1,0,0,0,19,3,10,15,5,11.8,0,4,10,14,8,12.0,0,7.6,2.6,0.32,2 +Student_00325,1,5,9085,1,3,1,1,1,19,7,5,141.0,128.8,1,0,0,1,0,0,0,19,0,5,9,3,10.333333333333334,1,0,5,8,3,13.0,0,7.6,2.6,0.32,1 +Student_00326,1,1,9254,1,1,1,1,NA,19,5,8,121.0,117.5,1,0,0,1,0,0,0,18,0,6,7,6,10.571428571428571,0,0,6,11,3,11.666666666666666,0,16.2,0.3,-0.92,2 +Student_00327,1,43,9500,1,1,6,1,1,37,9,9,134.0,120.4,1,0,0,NA,0,0,0,19,0,7,7,6,13.333333333333334,0,0,7,7,6,13.333333333333334,0,7.6,2.6,0.32,2 +Student_00329,1,1,9853,1,1,1,1,2,19,4,4,132.0,125.0,1,0,0,1,0,0,0,18,0,6,9,5,12.6,0,0,6,8,5,11.4,0,9.4,-0.8,-3.12,1 +Student_00330,1,1,9085,1,1,1,1,19,38,9,5,135.0,136.8,1,0,0,1,0,0,0,18,0,5,11,5,NA,3,0,5,7,5,11.6,0,9.4,-0.8,-3.12,1 +Student_00331,1,1,9853,1,1,1,1,1,38,9,6,123.0,121.6,1,0,0,1,0,0,0,18,0,7,12,5,12.0,0,0,7,9,6,12.666666666666666,0,11.1,0.6,2.02,1 +Student_00332,1,44,9119,1,1,39,1,19,37,4,7,151.0,151.0,0,0,1,1,0,0,0,26,0,5,6,0,0.0,0,0,5,5,0,0.0,0,16.2,0.3,-0.92,0 +Student_00333,1,1,9238,1,1,1,1,38,38,7,7,107.0,103.5,1,0,0,1,0,0,0,20,0,6,7,6,12.0,0,0,6,7,6,13.0,0,12.4,0.5,1.79,2 +Student_00334,1,1,8014,0,1,1,1,37,38,9,10,126.0,119.4,0,0,0,1,0,0,0,19,0,6,6,6,12.666666666666666,0,0,6,6,6,11.666666666666666,0,12.7,3.7,-1.7,2 +Student_00335,1,1,9238,1,1,1,1,34,37,4,9,133.0,134.4,1,0,0,1,0,1,0,18,0,6,6,6,12.166666666666666,0,0,6,9,6,13.666666666666666,0,9.4,-0.8,-3.12,2 +Student_00336,1,44,9238,1,1,39,1,38,37,7,7,140.0,143.0,0,0,0,1,0,0,0,19,3,6,6,6,13.333333333333334,0,2,6,6,6,14.666666666666666,0,13.9,-0.3,0.79,2 +Student_00338,1,1,9500,1,4,1,1,38,38,7,7,141.0,132.5,1,0,0,1,0,1,0,18,0,8,8,8,13.39125,0,0,8,8,8,13.39125,0,9.4,-0.8,-3.12,2 +Student_00339,1,17,9238,1,1,1,1,3,1,9,10,122.0,114.7,0,0,0,1,0,0,0,19,0,6,9,5,12.166666666666666,0,0,6,8,6,12.428571428571429,0,13.9,-0.3,0.79,2 +Student_00340,1,17,9130,1,1,1,1,2,9,3,5,156.0,166.9,0,0,0,1,0,0,0,18,0,5,9,4,11.25,0,0,5,6,4,12.5,0,7.6,2.6,0.32,2 +Student_00341,1,1,9085,1,1,1,1,1,2,3,1,129.0,125.9,1,0,0,1,0,0,0,19,0,5,13,4,12.0,2,0,5,8,3,12.0,0,9.4,-0.8,-3.12,1 +Student_00342,1,1,171,1,1,1,1,3,3,2,2,188.0,178.3,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00343,2,39,8014,0,1,1,1,37,37,9,9,120.0,117.0,1,0,0,NA,0,0,0,33,0,6,7,6,12.833333333333334,0,0,6,8,6,12.857142857142858,0,12.4,0.5,1.79,2 +Student_00344,1,39,9003,1,1,3,1,3,3,1,2,130.0,150.0,0,0,0,1,0,0,0,35,0,6,10,6,14.0,0,0,6,11,6,13.1,0,16.2,0.3,-0.92,2 +Student_00345,1,42,9147,1,1,1,1,37,38,9,1,130.0,130.0,1,0,0,1,0,0,0,26,3,5,5,4,13.0,0,1,5,7,2,12.0,0,9.4,-0.8,-3.12,1 +Student_00346,1,1,9773,1,1,1,1,19,19,7,5,140.0,135.1,1,0,0,1,0,0,0,18,0,6,7,6,13.5,0,0,6,8,6,12.5,0,9.4,-0.8,-3.12,2 +Student_00347,1,43,9238,1,1,1,1,37,37,9,9,110.0,110.0,0,0,0,1,0,0,0,36,10,16,24,13,10.692307692307692,1,9,13,19,9,12.307692307692308,0,15.5,2.8,-4.06,1 +Student_00348,4,39,9991,0,1,1,1,37,37,6,6,133.1,136.2,0,0,0,1,0,0,0,39,0,5,6,5,11.0,0,0,5,9,5,11.666666666666666,0,10.8,1.4,1.74,2 +Student_00350,1,1,8014,0,2,1,1,3,1,3,9,96.0,100.0,0,0,0,1,0,0,0,20,0,6,10,5,12.0,0,0,6,9,4,11.25,0,9.4,-0.8,-3.12,1 +Student_00351,1,1,9254,1,1,1,1,19,19,9,9,117.0,116.3,1,0,0,1,0,0,0,24,0,6,9,4,12.6,0,0,6,6,4,11.5,0,12.7,3.7,-1.7,0 +Student_00352,1,43,9773,1,1,1,1,19,19,9,8,123.0,134.0,0,0,0,1,0,1,0,20,0,6,6,6,13.666666666666666,0,0,6,6,6,13.333333333333334,0,12.4,0.5,1.79,2 +Student_00353,1,1,171,1,4,1,1,1,1,9,5,127.0,124.2,1,0,0,0,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00354,2,1,9500,1,1,1,1,37,38,9,7,151.0,134.5,0,0,1,1,0,1,0,18,0,7,7,6,14.2,0,0,7,7,6,14.2,0,7.6,2.6,0.32,2 +Student_00355,1,1,9254,1,1,1,1,19,19,4,6,127.0,120.7,0,0,1,0,0,0,0,22,0,6,10,5,11.0,0,0,6,12,0,0.0,0,10.8,1.4,1.74,0 +Student_00358,1,39,9991,0,1,1,1,37,37,90,8,133.1,128.2,0,0,0,1,0,0,0,33,0,5,0,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_00360,1,39,9085,1,1,43,1,3,39,2,3,160.0,172.0,0,0,0,1,0,0,0,26,0,6,0,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_00361,1,17,9853,1,4,1,1,19,38,4,1,140.0,128.5,1,0,0,1,0,0,0,18,0,6,7,6,11.666666666666666,0,0,6,10,6,11.833333333333334,0,10.8,1.4,1.74,2 +Student_00362,1,1,9773,1,1,1,1,37,38,9,7,146.0,128.5,0,0,1,NA,0,0,0,19,0,6,13,3,12.666666666666666,0,0,6,12,2,10.0,0,10.8,1.4,1.74,0 +Student_00363,1,17,9147,1,4,1,1,19,38,9,10,112.0,112.0,1,0,0,1,0,0,0,20,0,5,10,3,10.333333333333334,0,0,5,9,4,11.0,2,16.2,0.3,-0.92,1 +Student_00364,1,53,9085,1,1,42,1,19,37,9,8,140.0,142.5,1,0,0,1,NA,1,0,22,7,11,18,8,13.5,0,4,9,16,7,13.714285714285714,0,8.9,1.4,3.51,2 +Student_00365,1,1,9500,1,4,1,1,1,1,9,1,136.0,133.0,1,0,0,1,0,0,0,19,0,7,8,5,13.98,0,0,7,8,5,13.98,0,7.6,2.6,0.32,1 +Student_00366,1,1,9085,1,1,1,1,37,38,7,5,133.1,106.0,1,0,0,1,0,1,0,21,0,6,13,6,16.153846153846153,0,0,6,10,6,15.75,0,15.5,2.8,-4.06,2 +Student_00368,1,17,9085,1,1,1,1,19,37,2,7,134.0,131.2,0,0,0,1,0,0,0,19,0,5,8,1,11.0,0,0,5,6,5,11.2,0,7.6,2.6,0.32,1 +Student_00369,1,1,9853,1,1,1,1,38,37,191,195,122.0,112.9,1,0,0,1,0,1,0,19,0,7,8,7,13.857142857142858,0,0,7,8,6,13.666666666666666,0,8.9,1.4,3.51,2 +Student_00370,1,1,9500,1,6,1,1,19,19,9,5,138.0,124.8,1,0,0,1,0,0,0,18,0,8,8,7,13.414285714285716,0,0,8,8,7,13.414285714285716,0,12.7,3.7,-1.7,0 +Student_00371,2,43,8014,0,1,1,1,37,39,9,4,160.0,140.9,0,0,0,1,0,0,0,50,7,11,11,11,13.545454545454543,0,3,7,7,7,13.571428571428571,0,16.2,0.3,-0.92,2 +Student_00372,4,39,9991,0,1,1,1,38,19,9,7,130.0,148.0,0,0,0,1,0,1,0,31,0,5,11,4,11.25,0,0,5,10,4,10.833333333333334,0,13.9,-0.3,0.79,1 +Student_00374,4,39,9991,0,1,1,1,1,37,141,192,140.0,129.7,0,0,0,1,0,0,0,35,0,5,8,5,12.0,0,0,5,9,5,12.857142857142858,0,13.9,-0.3,0.79,2 +Student_00375,2,39,9085,1,1,19,1,38,38,4,7,133.1,128.2,0,0,0,1,0,0,0,31,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_00378,1,1,9500,1,1,1,1,1,1,4,4,152.0,141.0,1,0,0,1,0,1,0,18,0,7,7,7,15.135714285714286,0,0,8,8,8,15.287499999999998,0,12.4,0.5,1.79,2 +Student_00379,1,17,9853,1,1,1,1,3,3,3,3,125.0,NA,1,0,0,0,0,1,0,18,0,7,7,7,12.285714285714286,0,0,7,8,6,13.333333333333334,0,8.9,1.4,3.51,1 +Student_00380,1,44,9085,1,1,39,1,37,38,5,6,140.0,140.0,1,0,0,1,0,0,0,21,2,6,16,5,12.666666666666666,0,1,6,15,2,13.5,0,16.2,0.3,-0.92,1 +Student_00381,4,39,9500,1,1,19,1,38,19,5,7,133.1,140.0,0,0,0,1,0,1,0,26,0,7,13,5,12.74,0,0,8,12,6,10.978571428571428,0,16.2,0.3,-0.92,0 +Student_00382,1,43,9500,1,1,1,1,19,37,8,8,170.0,100.0,0,0,0,1,0,0,0,20,0,7,8,6,13.25,0,0,8,8,8,13.75,0,13.9,-0.3,0.79,1 +Student_00384,1,1,9853,1,1,1,1,19,19,5,5,125.0,117.0,0,0,0,1,0,1,0,19,0,6,7,6,13.428571428571429,0,0,6,6,6,13.166666666666666,0,15.5,2.8,-4.06,2 +Student_00385,1,53,9147,1,1,42,1,3,4,2,1,140.0,140.2,0,0,0,1,0,0,0,20,6,11,19,9,12.555555555555555,0,3,9,14,8,11.11111111111111,0,8.9,1.4,3.51,2 +Student_00386,1,1,NA,1,1,1,1,34,34,0,0,124.0,129.3,0,0,0,1,0,0,0,19,0,6,8,6,11.5,0,0,6,7,6,11.166666666666666,0,7.6,2.6,0.32,2 +Student_00387,1,1,9853,1,1,1,1,37,37,9,9,140.0,145.3,0,0,0,1,0,0,0,18,0,6,6,6,13.666666666666666,0,0,6,9,6,12.333333333333334,0,7.6,2.6,0.32,2 +Student_00388,1,39,9991,0,1,3,1,37,37,9,9,130.0,146.2,0,0,0,1,0,0,0,28,10,14,16,11,11.272727272727272,0,6,11,16,10,12.0,0,10.8,1.4,1.74,2 +Student_00389,1,17,9853,1,1,1,1,1,19,4,5,134.0,122.5,1,0,0,1,0,0,0,22,0,6,10,5,13.166666666666666,0,0,6,8,5,12.4,0,15.5,2.8,-4.06,1 +Student_00390,1,44,8014,0,1,39,1,37,37,7,7,160.0,156.1,0,0,0,1,0,1,0,21,3,6,6,6,14.666666666666666,0,2,6,6,6,14.166666666666666,0,13.9,-0.3,0.79,2 +Student_00393,1,1,9773,1,6,1,1,30,37,7,7,141.0,128.4,1,0,1,0,0,0,0,18,0,6,8,5,13.0,0,0,6,8,5,11.4,0,7.6,2.6,0.32,0 +Student_00394,1,17,9085,1,2,1,1,1,1,9,10,120.0,115.0,0,0,0,0,0,0,0,20,0,5,8,2,10.5,0,0,5,8,2,12.333333333333334,0,7.6,2.6,0.32,0 +Student_00395,1,17,9085,1,2,1,1,1,19,4,3,166.0,158.7,0,0,0,1,0,0,0,18,0,6,7,6,14.857142857142858,0,0,6,7,6,14.0,0,11.1,0.6,2.02,2 +Student_00396,1,1,9500,1,4,1,1,1,1,4,9,147.0,124.5,1,0,0,1,0,1,0,19,0,8,11,7,12.86,0,0,8,11,7,12.86,0,10.8,1.4,1.74,2 +Student_00398,1,44,9085,1,1,39,1,38,37,4,6,150.0,150.0,1,0,0,1,0,1,0,22,3,6,11,6,13.142857142857142,0,2,6,10,3,12.0,0,13.9,-0.3,0.79,2 +Student_00399,1,17,9670,1,1,1,1,37,19,5,8,124.0,114.2,1,0,1,1,0,0,0,18,0,6,6,5,11.8,0,0,6,9,4,13.714285714285714,0,10.8,1.4,1.74,0 +Student_00402,1,17,9254,1,1,1,1,37,37,7,7,136.0,121.7,1,0,0,1,0,0,0,20,0,6,13,3,10.333333333333334,0,0,6,12,3,10.333333333333334,0,10.8,1.4,1.74,1 +Student_00403,1,1,9773,1,1,1,1,38,37,9,9,120.0,114.8,1,1,0,1,0,0,0,19,0,6,11,4,12.25,0,0,6,11,3,11.0,0,7.6,2.6,0.32,1 +Student_00404,1,1,9254,1,1,1,1,19,38,9,9,128.0,127.0,0,0,0,1,0,0,0,19,0,6,6,6,12.0,0,0,6,7,4,12.75,0,12.4,0.5,1.79,1 +Student_00405,1,17,9500,1,1,1,1,37,37,5,5,142.0,131.3,1,0,0,1,0,0,0,19,0,8,8,7,14.731428571428571,0,0,8,8,7,14.731428571428571,0,10.8,1.4,1.74,2 +Student_00406,1,1,171,1,1,1,1,1,19,3,9,135.0,137.1,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_00408,1,39,9991,0,1,40,1,1,19,9,9,140.0,139.0,0,0,0,1,0,0,0,27,0,5,5,5,15.8,0,0,5,5,5,14.8,0,8.9,1.4,3.51,2 +Student_00409,1,17,9238,1,1,1,1,1,19,4,4,135.0,129.1,0,0,0,1,0,0,0,19,0,6,6,6,14.666666666666666,0,0,6,7,6,14.571428571428571,0,15.5,2.8,-4.06,2 +Student_00412,1,39,9500,1,1,3,1,19,1,4,8,122.0,NA,0,0,0,1,0,0,0,24,0,8,8,7,NA,0,0,8,8,7,12.401428571428571,0,10.8,1.4,1.74,2 +Student_00413,1,1,9500,1,3,1,1,1,1,4,10,128.0,118.9,1,0,0,1,0,0,0,20,0,7,8,7,11.5875,0,0,8,9,7,14.071428571428571,0,13.9,-0.3,0.79,2 +Student_00414,1,7,9991,0,1,40,1,37,37,6,6,140.0,140.0,0,0,0,1,0,0,0,26,3,5,5,5,14.0,0,1,5,5,5,15.6,0,12.4,0.5,1.79,2 +Student_00415,1,1,9238,1,1,1,NA,1,38,9,7,132.0,127.1,1,0,0,1,0,1,0,20,0,6,9,6,12.333333333333334,0,0,6,6,6,11.833333333333334,0,8.9,1.4,3.51,2 +Student_00416,1,1,9085,1,1,1,1,37,37,90,90,131.0,137.0,0,0,0,1,0,0,0,18,0,5,5,5,14.0,0,0,5,6,5,15.4,0,7.6,2.6,0.32,2 +Student_00417,1,1,9085,1,1,1,1,1,1,9,9,126.0,127.4,1,0,0,NA,0,0,0,19,0,6,13,6,15.23076923076923,0,0,6,10,6,12.375,0,15.5,2.8,-4.06,2 +Student_00418,1,1,9853,1,1,1,1,19,19,9,9,133.1,97.0,1,0,0,1,0,0,0,23,0,6,9,5,11.6,0,0,6,9,3,11.0,0,12.7,3.7,-1.7,0 +Student_00419,1,1,9500,1,4,1,1,37,37,9,9,136.0,126.3,1,0,0,1,0,1,0,18,0,7,7,6,11.6,0,0,7,7,6,11.6,0,7.6,2.6,0.32,2 +Student_00420,1,1,9500,1,4,1,1,1,19,4,5,140.0,127.5,0,0,0,1,0,0,0,18,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_00421,1,1,9500,1,1,1,1,2,1,2,8,135.0,126.6,0,0,0,1,0,1,0,19,0,7,7,7,12.901428571428571,0,0,8,9,8,13.094444444444443,0,11.1,0.6,NA,2 +Student_00422,1,42,9991,0,1,1,1,1,2,4,3,160.0,120.0,0,0,0,1,0,0,0,30,4,7,9,7,14.142857142857142,0,1,5,5,5,14.8,0,7.6,2.6,0.32,2 +Student_00423,1,44,9085,1,1,39,1,1,2,4,6,140.0,140.0,1,0,0,1,0,0,0,29,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00424,1,1,9500,1,6,1,1,3,1,3,3,140.0,131.5,1,0,0,1,0,0,0,19,0,8,8,8,13.25375,0,0,8,8,8,13.25375,0,9.4,-0.8,-3.12,2 +Student_00425,1,17,9556,1,6,1,1,19,2,5,3,115.0,112.2,1,0,0,1,0,0,0,20,0,7,7,7,13.785714285714286,0,0,8,8,8,14.1,0,12.4,0.5,1.79,2 +Student_00426,1,1,9500,1,1,1,1,37,37,9,3,144.0,150.5,0,0,0,1,0,0,0,20,0,7,7,6,13.916666666666666,0,0,7,7,6,13.916666666666666,0,7.6,2.6,0.32,2 +Student_00427,1,1,9670,1,4,1,1,38,38,3,7,128.0,121.0,1,0,0,1,0,0,0,19,0,6,8,6,NA,0,0,6,9,6,13.571428571428571,0,11.1,0.6,2.02,2 +Student_00428,1,17,9147,1,1,1,1,38,2,9,2,116.0,112.2,1,0,0,1,0,0,0,20,0,5,8,3,11.333333333333334,0,0,5,12,2,10.666666666666666,0,10.8,1.4,1.74,1 +Student_00429,3,1,9085,1,2,1,1,19,1,4,4,135.0,129.4,1,0,0,1,0,0,0,21,0,5,8,0,0.0,4,0,5,12,0,0.0,4,10.8,1.4,1.74,0 +Student_00430,1,17,9670,1,1,1,1,19,38,4,10,121.0,114.4,0,0,0,1,0,0,0,19,0,6,10,5,11.5,0,0,6,9,4,14.6,0,11.1,0.6,2.02,2 +Student_00432,1,39,8014,0,1,1,1,37,37,7,8,120.0,120.0,0,0,0,1,0,1,0,27,0,6,8,6,11.833333333333334,0,0,6,10,5,12.8,0,15.5,2.8,-4.06,2 +Student_00434,1,1,9500,1,1,1,1,1,1,90,3,141.0,127.8,0,0,0,1,0,1,0,19,0,7,7,0,0.0,2,0,7,7,0,0.0,2,7.6,2.6,0.32,0 +Student_00435,1,1,9773,1,1,1,1,1,19,4,8,140.0,124.6,1,0,0,1,0,0,0,19,0,6,7,5,14.2,0,0,6,7,6,14.571428571428571,0,15.5,2.8,-4.06,2 +Student_00438,1,1,9670,1,1,1,1,19,37,4,5,130.0,118.8,0,0,0,1,0,1,0,18,0,6,6,6,14.5,0,0,6,8,6,13.666666666666666,0,12.7,3.7,-1.7,2 +Student_00439,1,1,9670,1,5,1,1,9,1,2,4,133.1,133.0,1,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_00440,2,39,9500,1,1,19,1,37,37,9,9,133.1,129.0,1,0,0,1,0,0,0,36,0,7,7,6,11.3,0,0,7,7,6,11.3,0,7.6,2.6,0.32,2 +Student_00441,1,43,9556,1,1,1,1,3,4,3,2,147.0,100.0,0,0,0,1,0,0,0,18,0,2,2,0,0.0,0,0,4,4,1,16.0,0,10.8,1.4,1.74,1 +Student_00442,1,43,9130,1,1,1,1,19,38,4,5,127.0,120.7,1,0,1,1,0,0,0,18,0,5,11,1,12.0,0,0,5,9,3,12.0,0,12.7,3.7,-1.7,1 +Student_00443,1,17,9500,1,6,1,1,19,38,9,3,136.0,132.5,1,0,0,1,0,0,0,19,0,8,9,7,12.3,0,0,8,9,7,12.3,0,12.7,3.7,-1.7,2 +Student_00444,1,1,9500,1,5,1,NA,19,19,7,8,127.0,120.3,1,0,0,1,0,1,0,18,0,8,8,7,12.694285714285714,0,0,8,8,7,12.694285714285714,0,10.8,1.4,1.74,2 +Student_00445,1,17,9670,1,1,1,1,19,19,1,1,123.0,114.6,0,0,0,1,0,0,0,18,0,5,5,4,11.0,0,0,5,5,4,11.0,0,9.4,-0.8,-3.12,2 +Student_00446,1,1,9238,1,1,1,1,37,19,9,3,128.0,116.5,1,0,0,1,0,1,0,19,0,6,6,6,13.0,0,0,6,6,6,14.166666666666666,0,12.4,0.5,1.79,2 +Student_00447,1,1,9500,1,1,1,1,3,1,2,1,128.0,127.8,0,0,0,1,0,1,0,19,0,7,8,7,14.4125,0,0,8,8,8,16.05,0,13.9,-0.3,NA,2 +Student_00450,1,1,9254,1,3,1,1,19,38,3,10,122.0,114.3,1,0,0,1,0,1,0,20,0,6,8,5,12.8,0,0,6,9,5,12.8,0,12.4,0.5,1.79,1 +Student_00451,1,18,9500,1,1,1,1,38,37,5,5,126.0,114.8,1,0,0,1,0,0,0,20,0,8,8,7,14.402857142857142,0,0,8,8,7,14.402857142857142,0,10.8,1.4,1.74,2 +Student_00452,1,1,9500,1,4,1,1,37,37,9,8,135.0,123.0,1,0,0,1,0,1,0,18,0,8,8,7,13.381428571428572,0,0,8,8,7,13.381428571428572,0,10.8,1.4,1.74,2 +Student_00453,1,1,9500,1,2,1,1,19,19,7,5,131.0,122.1,1,0,0,1,0,0,0,18,0,7,8,7,14.13125,0,0,8,8,8,13.98375,0,15.5,2.8,-4.06,2 +Student_00454,1,17,9085,1,4,1,1,19,37,4,7,140.0,123.7,0,0,0,1,0,0,0,19,0,5,11,5,11.714285714285714,2,0,5,6,5,12.6,0,9.4,-0.8,-3.12,2 +Student_00455,1,1,9147,1,3,1,1,19,38,9,7,131.0,132.4,1,0,0,1,0,0,0,19,0,5,5,5,11.8,0,0,5,8,4,11.25,0,9.4,-0.8,-3.12,1 +Student_00456,2,39,8014,0,1,1,1,34,34,99,99,130.0,114.8,0,0,0,1,0,0,0,44,0,6,9,6,11.166666666666666,0,1,6,15,2,11.0,1,7.6,2.6,0.32,2 +Student_00457,1,7,9003,1,1,3,1,38,37,5,6,130.0,130.0,0,0,0,1,0,0,0,32,0,6,7,0,0.0,0,0,6,6,0,0.0,0,12.4,0.5,1.79,0 +Student_00459,2,NA,9003,1,1,1,1,1,19,4,9,130.0,152.4,1,0,0,1,0,0,0,36,4,12,14,12,13.846153846153848,0,5,12,18,11,14.090909090909092,0,8.9,1.4,3.51,2 +Student_00460,1,17,9773,1,1,1,1,37,37,5,7,125.0,120.1,0,0,0,1,0,1,0,18,0,6,7,6,12.5,0,0,6,8,6,13.333333333333334,0,16.2,0.3,-0.92,2 +Student_00461,1,1,9130,1,1,1,1,3,3,3,2,160.0,155.1,1,0,0,1,0,0,0,20,0,5,5,5,16.4,0,0,5,5,5,14.6,0,12.7,3.7,-1.7,2 +Student_00462,1,51,9070,1,1,1,1,19,19,5,7,130.0,124.5,0,0,0,1,0,1,0,20,5,11,11,11,13.818181818181818,0,5,11,11,11,13.454545454545457,0,11.1,0.6,2.02,2 +Student_00464,1,39,9147,1,1,19,1,3,1,3,5,133.1,153.2,1,0,1,1,0,0,0,24,0,5,8,5,10.2,0,0,5,6,5,12.2,0,12.4,0.5,1.79,2 +Student_00465,1,17,9238,1,1,1,1,1,1,4,9,148.0,129.8,0,0,0,1,0,0,0,20,0,6,11,5,10.6,0,0,6,11,4,10.4,0,15.5,2.8,-4.06,1 +Student_00466,1,43,8014,0,1,1,1,NA,3,2,3,133.1,135.0,0,0,0,1,0,0,0,27,7,10,10,9,11.444444444444445,0,4,11,11,5,10.8,0,10.8,1.4,1.74,0 +Student_00467,1,1,9853,1,1,1,1,1,38,5,10,133.0,131.3,1,0,0,1,0,0,0,20,0,6,9,5,14.333333333333334,0,4,8,8,8,12.625,0,15.5,2.8,-4.06,1 +Student_00468,1,43,9238,1,6,1,1,34,34,0,0,129.0,125.2,0,0,0,1,0,1,0,23,15,16,18,16,13.0,0,11,13,15,13,13.266666666666667,0,9.4,-0.8,-3.12,2 +Student_00469,1,1,9500,1,5,1,1,NA,38,4,8,144.0,141.3,1,0,0,1,0,1,0,18,0,8,9,8,13.31,1,0,8,9,8,13.31,1,9.4,-0.8,-3.12,2 +Student_00470,1,17,9238,1,1,1,1,37,37,4,9,120.0,117.1,1,0,0,1,0,1,0,18,0,6,10,5,10.571428571428571,1,0,6,9,5,12.2,0,12.7,3.7,-1.7,2 +Student_00471,1,17,9500,1,3,1,1,1,37,9,9,144.0,126.5,1,0,0,1,0,1,0,20,0,8,8,7,13.487142857142857,0,0,8,8,7,13.487142857142857,0,10.8,1.4,1.74,2 +Student_00472,1,1,9254,1,1,1,1,19,38,9,7,132.0,120.1,0,0,0,1,0,1,0,20,0,6,6,6,12.333333333333334,0,0,6,7,6,11.833333333333334,0,13.9,-0.3,0.79,2 +Student_00473,1,1,9670,1,1,1,1,38,19,7,10,142.0,128.4,0,0,0,1,0,0,0,23,0,6,11,6,11.875,0,0,6,9,5,12.833333333333334,0,11.1,0.6,2.02,0 +Student_00474,1,1,9500,1,2,1,1,19,19,9,9,136.0,140.0,1,0,0,1,0,0,0,20,0,7,7,6,13.966666666666669,0,0,7,7,6,13.966666666666669,0,7.6,2.6,0.32,2 +Student_00475,1,39,9254,1,1,NA,1,34,34,0,0,133.1,110.0,1,0,0,0,0,0,0,28,0,5,10,0,0.0,0,0,5,10,0,0.0,0,7.6,2.6,0.32,0 +Student_00476,1,1,9670,1,1,1,1,1,19,3,5,122.0,116.8,1,0,0,1,0,0,0,21,0,5,8,4,11.5,0,0,5,5,5,12.8,0,7.6,2.6,0.32,2 +Student_00477,1,1,9556,1,2,1,1,19,19,9,9,133.1,104.5,1,0,0,1,0,0,0,21,0,2,2,2,12.5,0,0,7,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00478,1,7,9500,1,1,3,1,34,34,0,0,140.0,140.0,0,0,0,1,0,0,0,28,0,7,0,0,0.0,0,0,8,0,0,0.0,0,7.6,2.6,0.32,0 +Student_00479,1,1,9500,1,1,1,1,3,1,3,3,117.0,113.2,0,1,0,1,0,0,0,18,0,7,10,6,11.98,0,0,8,11,7,13.225,0,16.2,0.3,-0.92,2 +Student_00480,1,17,9238,1,1,1,1,NA,19,191,175,128.0,118.6,1,0,0,1,0,1,0,21,0,6,8,5,13.2,0,0,6,7,5,11.8,0,8.9,1.4,3.51,1 +Student_00482,1,18,9500,1,6,1,1,1,19,1,1,141.0,126.7,1,0,0,1,0,1,0,18,0,8,8,7,14.314285714285717,0,0,8,8,7,14.314285714285717,0,12.7,3.7,-1.7,2 +Student_00483,1,1,9500,1,3,NA,1,3,1,2,5,130.0,133.8,0,0,0,1,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,7.6,2.6,0.32,0 +Student_00484,1,44,9085,1,1,39,1,38,38,9,7,140.0,140.0,0,0,0,1,0,0,0,20,2,6,9,6,12.666666666666666,0,1,6,12,2,13.0,0,13.9,-0.3,0.79,1 +Student_00485,1,1,9500,1,3,1,1,1,19,9,5,102.0,100.6,1,0,0,1,0,1,0,20,0,7,9,6,12.766666666666666,0,0,8,10,7,12.128571428571428,0,12.4,0.5,1.79,2 +Student_00486,1,17,9853,1,1,1,1,1,37,7,9,126.0,132.7,0,0,0,1,0,1,0,18,0,6,7,6,12.666666666666666,0,0,6,7,5,12.2,0,10.8,1.4,1.74,2 +Student_00487,1,43,9670,1,2,1,1,38,19,4,3,125.0,106.6,1,0,0,1,0,0,0,20,4,6,7,6,11.5,0,0,6,10,4,10.571428571428571,0,10.8,1.4,1.74,0 +Student_00489,1,17,9500,1,3,1,1,37,37,9,7,132.0,128.3,1,0,0,1,0,1,0,19,0,7,8,7,14.70625,0,0,8,8,8,14.4775,0,15.5,2.8,-4.06,2 +Student_00491,1,1,9070,1,1,1,1,19,1,3,8,115.0,123.4,0,0,0,1,0,0,0,23,1,6,8,6,13.0,1,0,6,8,6,11.875,0,13.9,-0.3,0.79,2 +Student_00492,1,1,9670,1,1,1,1,37,37,5,5,125.0,124.0,0,0,0,1,0,0,0,19,0,6,7,6,14.857142857142858,0,0,6,6,6,13.333333333333334,0,12.4,0.5,1.79,2 +Student_00493,1,1,9500,1,6,1,1,1,3,3,2,137.0,121.3,1,0,0,1,0,0,0,20,0,7,7,6,12.6,0,0,7,7,6,12.6,0,7.6,2.6,0.32,2 +Student_00494,1,1,9085,1,1,1,1,37,37,9,4,101.0,101.0,1,0,1,1,0,0,0,22,0,6,9,5,13.333333333333334,0,0,6,17,4,11.4,0,12.4,0.5,1.79,1 +Student_00496,1,7,9130,1,3,3,1,19,37,90,5,130.0,130.0,0,0,1,0,0,0,0,27,1,5,6,2,11.5,0,0,5,5,1,11.0,0,12.7,3.7,-1.7,0 +Student_00497,1,39,9556,1,1,19,NA,37,38,9,9,100.0,120.0,0,0,0,1,0,0,0,29,0,7,9,1,10.0,0,0,7,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_00499,1,17,9070,1,1,1,1,19,38,9,7,126.0,118.7,0,0,0,1,0,0,0,18,0,6,7,5,11.8,0,0,6,6,6,12.666666666666666,0,16.2,0.3,-0.92,2 +Student_00500,1,17,9500,1,1,1,1,NA,38,7,7,128.0,131.5,0,0,0,1,0,0,0,18,0,8,8,8,12.77125,0,0,8,8,8,12.77125,0,9.4,-0.8,-3.12,2 +Student_00503,1,1,9070,1,1,1,1,1,1,4,4,125.0,132.0,0,0,0,0,0,0,0,18,1,6,10,5,12.2,1,0,6,11,4,10.833333333333334,0,13.9,-0.3,0.79,1 +Student_00504,1,7,9085,1,2,3,1,3,3,1,1,130.0,130.0,0,0,0,0,0,0,0,28,0,5,9,1,12.0,1,0,4,10,0,0.0,4,10.8,1.4,1.74,0 +Student_00505,1,1,9500,1,2,1,1,37,1,7,7,135.0,132.8,1,0,0,1,0,1,0,18,0,8,12,7,11.721428571428572,0,0,8,12,7,11.721428571428572,0,12.7,3.7,-1.7,2 +Student_00509,1,1,9130,1,1,1,1,5,5,2,2,150.0,146.2,0,0,0,1,0,0,0,18,0,5,12,4,13.0,2,0,5,6,5,14.0,0,9.4,-0.8,-3.12,0 +Student_00510,1,1,9147,1,2,1,1,1,19,4,6,125.0,115.2,0,1,0,1,0,0,0,21,0,5,6,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_00511,1,1,9070,1,2,1,1,4,1,2,3,121.0,120.7,1,0,0,1,0,0,0,NA,0,6,8,4,10.75,0,0,6,9,0,0.0,0,9.4,-0.8,-3.12,1 +Student_00512,2,39,8014,0,1,1,1,34,34,99,99,120.0,101.8,0,0,0,0,0,0,0,32,0,5,5,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_00513,1,39,9670,1,2,1,1,34,34,0,0,140.0,100.0,0,0,0,1,0,0,0,28,0,5,6,4,12.5,0,0,5,7,4,11.75,0,7.6,2.6,0.32,2 +Student_00515,2,18,8014,0,2,1,1,37,37,9,10,140.0,120.4,0,0,1,0,0,0,0,39,0,5,5,0,0.0,0,0,4,4,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00517,2,39,9003,1,1,1,1,37,19,9,4,120.0,148.8,0,0,0,1,0,0,0,50,0,6,7,6,12.5,0,0,6,15,5,12.4,0,8.9,1.4,3.51,2 +Student_00518,1,17,9853,1,2,1,1,1,1,9,4,138.0,123.0,1,0,0,1,0,0,0,23,0,6,10,5,12.8,0,0,6,9,3,11.666666666666666,0,10.8,1.4,1.74,0 +Student_00519,4,39,8014,0,1,19,1,34,34,0,0,133.1,100.0,0,0,0,1,0,0,0,48,0,6,11,1,10.0,0,0,6,11,1,11.0,0,9.4,-0.8,-3.12,0 +Student_00521,1,1,NA,1,6,1,1,37,1,5,5,135.0,126.8,1,0,0,1,0,1,0,18,0,8,8,7,12.61,0,0,8,8,7,12.61,0,10.8,1.4,1.74,2 +Student_00522,1,17,9130,1,1,1,1,3,19,2,9,130.0,115.9,0,0,0,1,0,0,0,18,0,5,14,2,12.0,2,0,5,6,5,12.6,0,9.4,-0.8,-3.12,2 +Student_00524,1,18,9085,1,3,1,103,1,1,9,9,149.0,132.2,1,0,0,1,0,1,1,18,0,5,9,4,12.0,0,0,5,8,5,13.0,0,10.8,1.4,1.74,2 +Student_00525,1,1,9556,1,1,NA,103,5,3,1,1,180.0,183.5,1,0,0,1,0,0,1,18,0,7,8,4,12.0,0,0,8,8,0,0.0,0,16.2,0.3,-0.92,0 +Student_00526,1,43,9119,1,1,1,1,1,1,9,3,133.1,136.0,0,0,0,1,1,0,0,31,0,5,12,1,12.0,0,0,5,9,1,11.0,4,16.2,0.3,-0.92,0 +Student_00527,1,39,9119,1,1,19,1,19,19,5,3,133.1,100.9,1,0,0,1,1,0,0,NA,0,5,9,1,12.0,0,0,5,6,3,10.5,0,10.8,1.4,1.74,1 +Student_00528,1,39,171,1,1,1,1,3,1,2,10,145.0,114.5,1,0,0,1,1,0,0,24,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_00529,1,39,9147,1,1,1,1,37,37,9,9,110.0,110.3,0,0,1,0,1,0,0,26,0,5,5,0,0.0,0,0,5,9,0,0.0,0,10.8,1.4,1.74,0 +Student_00530,1,1,9130,1,1,1,1,3,3,2,2,154.0,137.2,1,0,1,1,1,0,0,18,0,6,11,5,13.625,0,0,6,9,4,11.75,0,16.2,0.3,-0.92,0 +Student_00531,1,17,9147,1,1,1,1,37,37,4,7,126.0,116.9,0,0,0,1,1,1,0,19,0,5,12,3,11.666666666666666,0,0,5,10,3,11.666666666666666,0,12.7,3.7,-1.7,1 +Student_00532,1,17,9670,1,1,1,1,19,37,9,8,133.0,121.8,1,0,0,1,1,0,0,22,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_00533,1,1,9500,1,2,1,1,4,2,2,3,145.0,127.3,1,0,0,1,1,0,0,18,0,8,8,7,11.69,0,0,8,8,7,11.69,0,10.8,1.4,1.74,2 +Student_00534,1,44,9070,1,1,39,1,1,19,4,7,120.0,120.0,0,0,1,0,1,0,0,20,0,6,11,0,0.0,6,0,6,12,0,0.0,12,16.2,0.3,-0.92,0 +Student_00535,1,44,171,1,1,39,1,4,4,2,2,150.0,150.0,0,0,0,1,1,0,0,25,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,2 +Student_00536,1,43,9991,0,1,1,1,3,3,4,4,150.0,100.0,1,0,0,1,1,0,0,24,0,5,10,4,11.5,0,0,5,11,5,11.285714285714286,0,13.9,-0.3,NA,2 +Student_00537,1,39,9119,1,1,1,1,3,3,4,4,150.0,150.0,1,0,0,1,1,0,0,27,0,5,10,1,14.0,0,0,5,0,0,0.0,0,8.9,1.4,3.51,0 +Student_00538,1,17,9254,1,1,1,1,3,19,4,4,127.0,116.9,0,0,0,1,1,0,0,21,0,6,7,5,11.0,0,0,6,7,5,12.4,0,15.5,2.8,-4.06,2 +Student_00539,1,44,9003,1,1,39,1,19,38,3,9,140.0,140.0,1,0,0,1,1,0,0,21,0,6,7,6,12.857142857142858,0,0,6,6,6,13.166666666666666,0,12.4,0.5,1.79,2 +Student_00540,1,18,9773,1,3,1,1,19,1,9,9,128.0,122.1,1,0,0,1,1,0,0,19,0,6,9,4,12.5,0,0,6,6,6,11.333333333333334,0,10.8,1.4,1.74,0 +Student_00541,1,39,9500,1,1,1,1,19,19,5,5,127.0,160.0,0,0,0,1,1,0,0,28,0,7,7,7,14.528571428571428,0,0,8,11,8,15.018181818181818,0,16.2,0.3,-0.92,2 +Student_00542,1,1,9147,1,1,1,1,19,19,5,7,117.0,118.4,0,0,0,1,1,0,0,20,0,5,8,5,10.0,0,0,5,10,2,12.0,0,7.6,2.6,0.32,1 +Student_00545,1,17,9119,1,2,1,1,19,1,9,10,127.0,121.1,1,0,0,1,1,1,0,18,0,5,6,5,13.2,0,0,5,8,5,12.6,0,8.9,1.4,3.51,1 +Student_00546,1,1,9147,1,2,1,1,19,1,5,10,133.0,121.8,0,0,0,1,1,0,0,20,0,5,9,4,10.2,0,0,5,6,3,11.0,0,15.5,2.8,-4.06,1 +Student_00547,1,39,9119,1,1,40,1,1,1,5,10,120.0,146.8,0,0,0,1,1,0,0,25,2,5,6,5,14.2,0,1,5,5,2,13.5,0,16.2,0.3,-0.92,1 +Student_00548,1,1,9670,1,1,1,1,38,19,5,6,133.1,138.0,0,0,1,1,1,0,0,22,0,6,8,6,12.625,0,0,6,11,2,14.5,0,11.1,0.6,2.02,1 +Student_00549,1,1,9500,1,1,1,1,37,37,9,9,149.0,138.0,0,0,0,1,1,0,0,18,0,8,11,6,13.496666666666668,1,0,8,11,6,13.496666666666668,1,9.4,-0.8,-3.12,1 +Student_00550,1,17,9147,1,2,1,1,19,38,9,7,125.0,116.3,1,0,0,1,1,0,0,19,0,5,8,5,13.25,0,0,5,8,5,11.0,0,13.9,-0.3,0.79,2 +Student_00551,1,1,9119,1,5,1,1,12,19,4,5,126.0,122.5,1,0,0,1,1,0,0,19,0,5,12,3,12.0,0,0,5,10,3,12.0,0,12.4,0.5,1.79,0 +Student_00552,1,39,9773,1,1,19,1,19,1,7,9,133.1,115.0,1,0,1,0,1,0,0,25,0,6,10,4,13.0,0,0,6,9,4,13.75,0,12.7,3.7,-1.7,0 +Student_00553,1,43,9070,1,1,NA,1,12,12,1,10,115.0,115.0,0,0,1,1,1,0,0,21,5,11,12,9,11.77777777777778,0,3,8,11,3,13.666666666666666,0,15.5,2.8,-4.06,0 +Student_00554,1,17,9119,1,3,1,1,1,2,3,2,117.0,119.8,1,0,0,1,1,0,0,19,0,5,10,2,11.0,0,0,6,10,0,0.0,0,11.1,0.6,2.02,0 +Student_00556,1,44,9003,1,1,39,1,3,2,2,2,150.0,150.0,0,0,0,1,1,0,0,25,9,14,16,14,12.428571428571429,0,3,9,13,6,10.857142857142858,0,15.5,2.8,-4.06,0 +Student_00557,1,17,9147,1,1,1,1,NA,1,7,4,130.0,117.8,1,0,0,1,1,0,0,20,0,5,8,3,11.0,0,0,5,11,3,12.0,0,10.8,1.4,1.74,1 +Student_00558,1,1,171,1,1,1,1,37,37,9,9,161.0,144.2,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_00559,1,44,9254,1,1,39,1,39,39,194,193,130.0,130.0,1,0,1,1,1,0,0,23,0,6,12,3,11.5,0,0,6,12,3,10.666666666666666,0,8.9,1.4,3.51,1 +Student_00560,1,42,9500,1,1,1,1,1,3,9,10,111.0,128.2,1,0,0,1,1,0,0,23,0,8,8,8,12.5075,0,0,8,8,8,12.5075,0,9.4,-0.8,-3.12,2 +Student_00561,1,53,9003,1,1,42,1,3,38,141,151,140.0,135.3,0,0,0,1,1,0,0,21,7,12,18,11,12.090909090909092,0,5,12,14,11,12.0,0,8.9,1.4,3.51,2 +Student_00563,1,39,9991,0,1,1,1,1,1,4,10,139.0,140.7,0,0,0,1,1,0,0,25,0,5,13,1,NA,0,0,5,8,2,11.333333333333334,0,12.4,0.5,1.79,0 +Student_00564,1,1,9130,1,1,1,1,19,38,9,NA,132.0,130.4,1,0,0,1,1,0,0,18,0,6,6,6,13.5,0,0,6,9,5,13.2,0,8.9,1.4,3.51,2 +Student_00565,1,1,9070,1,6,6,1,1,1,9,9,119.0,123.2,1,0,0,1,1,0,0,22,0,6,6,6,14.166666666666666,0,0,6,8,6,NA,0,10.8,1.4,1.74,2 +Student_00566,1,39,9670,1,1,1,1,19,19,3,9,133.1,118.0,0,0,0,1,1,0,0,27,0,6,7,6,14.0,0,0,6,7,6,14.714285714285714,0,8.9,1.4,3.51,2 +Student_00567,1,39,9003,1,1,NA,1,4,1,2,4,133.1,120.0,0,0,0,1,1,0,0,25,0,3,4,0,0.0,0,0,3,5,0,0.0,0,16.2,0.3,-0.92,0 +Student_00568,1,17,9119,1,4,1,1,34,36,0,5,129.0,118.9,1,0,0,1,1,0,0,18,0,5,9,3,11.666666666666666,0,0,5,10,3,11.333333333333334,4,7.6,2.6,0.32,0 +Student_00569,1,17,9085,1,1,1,1,38,19,8,8,128.0,117.2,0,0,0,1,NA,0,0,20,0,5,7,5,14.6,1,0,5,5,5,14.2,0,12.7,3.7,-1.7,2 +Student_00570,1,NA,9003,1,1,1,1,3,4,2,2,120.0,120.0,0,0,0,1,1,0,0,27,0,6,10,5,13.0,0,0,6,13,5,11.5,0,16.2,0.3,-0.92,2 +Student_00572,1,1,9147,1,1,1,1,38,37,9,9,130.0,124.8,1,0,0,1,1,0,0,22,0,5,9,0,0.0,0,0,5,5,1,12.0,0,7.6,2.6,0.32,0 +Student_00573,1,17,9119,1,6,1,1,19,3,5,10,111.0,106.5,1,0,0,1,1,0,0,19,0,5,10,3,10.5,0,0,5,11,3,10.8,0,12.4,0.5,1.79,0 +Student_00574,1,1,9147,1,6,1,1,3,19,4,5,NA,116.8,0,0,0,1,1,0,0,20,0,5,14,3,12.4,0,0,5,8,5,10.833333333333334,0,13.9,-0.3,0.79,1 +Student_00575,1,43,171,1,4,1,1,19,12,9,10,117.0,109.3,0,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_00576,2,39,9085,1,1,9,1,1,1,4,4,133.1,120.0,1,0,0,0,1,0,0,29,0,5,12,0,0.0,4,0,5,8,0,0.0,1,9.4,-0.8,-3.12,0 +Student_00577,1,1,9500,1,2,1,1,3,1,9,9,149.0,137.5,0,0,0,1,1,0,0,19,0,8,8,7,13.828571428571427,0,0,8,8,7,13.828571428571427,0,12.7,3.7,-1.7,2 +Student_00579,2,1,9238,1,1,1,1,37,37,5,5,134.0,120.4,0,0,0,1,0,0,0,20,0,6,7,6,11.5,0,0,6,6,6,11.666666666666666,0,7.6,2.6,0.32,2 +Student_00581,1,39,8014,0,1,1,NA,34,5,0,1,133.1,118.5,1,0,0,1,0,0,0,31,0,6,12,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_00582,1,17,9500,1,5,NA,1,12,1,5,5,141.0,133.0,1,0,0,1,0,0,0,18,0,7,8,7,12.5375,0,0,8,9,7,12.614285714285714,0,13.9,-0.3,0.79,2 +Student_00583,1,17,9670,1,1,1,1,1,19,8,7,141.0,128.8,1,0,0,1,0,0,0,19,0,6,6,6,14.833333333333334,0,0,6,8,6,13.285714285714286,0,8.9,1.4,3.51,1 +Student_00584,1,1,9147,1,1,1,1,37,38,9,8,148.0,133.0,1,0,0,1,0,0,0,18,0,5,10,4,12.0,0,0,5,9,4,12.8,0,13.9,-0.3,0.79,2 +Student_00586,1,1,9147,1,1,1,1,1,19,3,3,143.0,133.9,0,0,0,1,0,1,0,18,0,5,5,5,15.0,0,0,5,5,5,15.2,0,12.7,3.7,-1.7,2 +Student_00587,1,17,9085,1,1,1,1,38,19,90,90,120.0,127.0,0,0,0,1,0,0,0,19,0,5,7,3,12.0,0,0,5,7,5,13.2,0,7.6,2.6,0.32,2 +Student_00589,1,1,9254,1,3,1,1,37,37,9,3,122.0,124.5,1,0,0,1,0,0,0,19,0,6,12,6,11.666666666666666,0,0,6,14,3,12.0,0,7.6,2.6,0.32,2 +Student_00590,1,1,9556,1,4,1,1,37,1,5,4,122.0,123.9,0,0,0,1,0,0,0,19,0,7,9,7,12.1625,0,0,8,8,8,13.825,0,13.9,-0.3,0.79,2 +Student_00591,1,1,9670,1,2,1,1,19,1,9,3,123.0,117.8,1,0,0,1,0,0,0,18,0,6,6,6,13.833333333333334,0,0,6,11,6,14.555555555555555,0,10.8,1.4,1.74,2 +Student_00592,1,1,9500,1,1,1,1,3,19,2,8,133.0,126.7,0,0,0,1,0,0,0,19,0,7,12,4,12.45,0,0,7,11,5,11.7,0,16.2,0.3,-0.92,1 +Student_00593,1,44,9670,1,1,39,1,37,1,9,4,110.0,110.0,0,0,0,1,0,1,0,20,2,6,9,6,12.125,0,2,6,7,6,13.571428571428571,0,11.1,0.6,2.02,2 +Student_00594,1,17,9670,1,1,1,1,1,19,4,8,155.0,134.7,1,0,0,1,0,0,0,20,0,6,8,5,13.4,0,0,6,10,4,13.0,0,12.7,3.7,-1.7,1 +Student_00596,1,39,9991,0,1,3,1,37,37,9,9,120.0,141.0,0,0,0,1,0,0,0,29,10,15,15,11,11.454545454545457,0,9,13,16,11,11.545454545454543,0,10.8,1.4,1.74,0 +Student_00597,1,17,9853,1,1,1,1,38,12,7,0,133.1,NA,0,0,0,0,0,1,0,20,0,6,10,4,12.0,0,0,6,14,3,10.0,0,7.6,2.6,0.32,0 +Student_00598,4,39,9853,1,1,1,1,37,1,9,10,143.0,140.0,0,0,1,0,0,0,0,31,0,7,8,6,12.666666666666666,0,0,7,9,5,12.6,0,8.9,1.4,3.51,0 +Student_00599,1,17,9670,1,1,1,1,19,37,7,4,149.0,134.3,0,1,0,1,0,0,0,20,0,6,7,6,12.666666666666666,0,0,6,9,6,13.77777777777778,0,10.8,1.4,1.74,2 +Student_00600,1,17,9003,1,1,1,1,38,37,9,9,133.0,125.3,1,0,0,1,0,0,0,21,12,18,22,18,11.88888888888889,1,11,13,13,13,11.461538461538462,0,15.5,2.8,-4.06,2 +Student_00601,1,7,9130,1,1,3,1,19,38,9,NA,140.0,140.0,1,0,0,1,0,0,0,23,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00602,1,17,9070,1,5,1,1,19,38,5,7,122.0,119.6,0,0,1,0,0,0,0,21,0,6,6,4,13.0,0,0,6,8,4,11.6,0,10.8,1.4,1.74,0 +Student_00603,1,7,9500,1,1,40,1,1,1,9,4,170.0,170.0,0,0,0,1,0,0,0,24,4,7,7,7,16.885714285714283,0,3,8,9,8,15.744444444444444,0,16.2,0.3,-0.92,2 +Student_00604,1,39,8014,0,1,1,1,1,1,4,4,120.0,150.5,0,0,0,1,0,0,0,27,0,6,6,6,12.5,0,1,6,6,6,12.333333333333334,0,15.5,2.8,-4.06,2 +Student_00605,1,1,9500,1,1,1,1,1,37,3,8,143.0,128.0,0,0,0,1,0,1,0,18,0,7,9,7,13.055555555555555,0,0,8,8,8,15.8125,0,13.9,-0.3,0.79,2 +Student_00607,1,17,9130,1,1,1,1,19,3,3,2,123.0,121.6,1,0,1,1,0,1,0,19,0,5,7,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00608,1,1,9500,1,6,1,1,38,19,7,7,131.0,125.3,1,0,0,1,0,1,0,19,0,8,8,7,12.355714285714283,0,0,8,8,7,12.355714285714283,0,10.8,1.4,1.74,2 +Student_00609,1,17,9085,1,1,1,1,19,38,194,193,127.0,117.6,0,0,0,1,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00612,2,1,8014,0,1,1,1,1,37,4,7,150.0,139.9,1,0,0,1,0,0,0,24,0,6,9,5,13.0,0,0,6,6,6,14.166666666666666,0,9.4,-0.8,-3.12,2 +Student_00613,1,1,9070,1,1,1,1,1,1,1,1,116.0,110.8,1,0,0,1,0,0,0,20,0,6,6,6,12.833333333333334,0,0,6,10,6,11.166666666666666,0,12.4,0.5,1.79,2 +Student_00615,1,1,9500,1,1,1,1,19,37,9,9,130.0,117.8,1,0,0,1,0,1,0,19,0,8,8,7,12.357142857142858,0,0,8,8,7,12.357142857142858,0,12.7,3.7,-1.7,2 +Student_00616,1,1,9500,1,6,1,1,1,37,9,9,144.0,127.5,1,0,0,1,0,1,0,18,0,8,8,7,13.857142857142858,0,0,8,8,7,13.857142857142858,0,12.7,3.7,-1.7,2 +Student_00618,1,17,9500,1,1,1,NA,37,37,9,8,143.0,130.6,1,0,0,1,0,0,0,20,0,7,8,7,12.847142857142858,0,0,8,10,8,13.788888888888888,0,16.2,0.3,-0.92,2 +Student_00619,1,17,9500,1,2,1,1,19,37,4,7,137.0,126.3,1,0,0,1,0,1,0,19,0,7,9,6,12.339999999999998,0,0,8,9,8,13.01875,0,11.1,0.6,2.02,2 +Student_00620,1,44,9085,1,1,39,1,3,1,2,3,140.0,140.0,1,0,0,1,0,0,0,19,0,6,10,5,12.666666666666666,0,0,6,19,4,11.75,0,12.4,0.5,1.79,1 +Student_00621,1,1,9773,1,1,1,1,3,19,4,5,133.1,105.0,1,0,0,1,0,0,0,20,0,6,6,6,13.833333333333334,0,0,6,6,6,12.5,0,12.7,3.7,-1.7,2 +Student_00623,1,17,9853,1,5,1,1,38,38,9,7,117.0,114.6,1,0,0,1,0,0,0,19,0,6,11,4,13.25,0,0,6,10,4,NA,0,9.4,-0.8,-3.12,0 +Student_00624,1,17,9500,1,1,1,1,38,37,7,5,137.0,131.0,1,0,0,1,0,1,0,18,0,8,8,8,13.73125,0,0,8,8,8,13.73125,0,9.4,-0.8,-3.12,2 +Student_00625,1,17,9070,1,4,1,1,38,37,9,9,116.0,109.0,0,0,0,1,0,1,0,23,0,6,6,6,13.333333333333334,0,0,6,8,3,12.666666666666666,0,11.1,0.6,2.02,0 +Student_00627,1,44,8014,0,1,39,1,37,38,6,6,130.0,130.0,1,0,0,1,0,0,0,23,5,9,10,9,10.88888888888889,0,3,8,10,6,11.333333333333334,0,11.1,0.6,2.02,2 +Student_00628,1,1,9500,1,3,1,1,19,37,9,7,106.0,109.5,1,0,0,1,0,0,0,19,0,7,8,7,13.025,0,0,8,9,8,13.811111111111112,0,13.9,-0.3,0.79,2 +Student_00629,1,17,9773,1,2,1,1,1,38,5,6,125.0,115.9,1,0,0,1,0,0,0,18,0,6,6,6,13.0,0,0,6,6,6,14.166666666666666,0,12.4,0.5,1.79,2 +Student_00631,1,39,9500,1,1,1,1,19,37,9,9,133.1,120.0,0,0,0,1,0,1,0,25,0,8,8,7,12.042857142857144,0,0,8,8,7,12.042857142857144,0,12.7,3.7,-1.7,2 +Student_00632,1,1,9853,1,2,1,1,1,38,4,9,117.0,109.7,1,0,0,1,0,0,0,19,0,6,9,5,12.2,0,0,6,10,4,13.0,0,9.4,-0.8,-3.12,1 +Student_00633,1,1,9500,1,1,1,1,1,19,5,7,136.0,136.4,0,0,0,1,0,1,0,19,0,7,8,7,12.8375,0,0,8,8,8,15.5,0,13.9,-0.3,0.79,2 +Student_00634,1,39,9556,1,1,1,1,38,38,191,193,120.0,120.0,0,0,1,1,0,1,0,24,0,7,13,7,11.0,0,0,8,13,7,11.7,0,12.7,3.7,-1.7,2 +Student_00635,1,1,9670,1,1,1,1,37,37,9,7,135.0,132.6,1,0,0,1,0,1,0,NA,0,6,7,6,13.5,0,0,6,9,5,14.0,0,8.9,1.4,3.51,2 +Student_00637,1,1,9500,1,5,1,1,37,37,9,9,147.0,134.3,0,0,0,1,0,1,0,18,0,8,12,7,12.62857142857143,0,0,8,12,7,12.62857142857143,0,12.7,3.7,-1.7,2 +Student_00639,1,17,9238,1,3,1,1,1,1,4,5,121.0,117.2,0,0,0,1,0,0,0,19,0,6,11,5,11.2,0,0,6,13,5,11.6,0,15.5,2.8,-4.06,2 +Student_00642,1,1,9147,1,6,1,1,37,37,9,9,128.0,116.5,0,0,0,1,0,0,0,18,0,5,9,3,11.666666666666666,0,0,5,15,2,11.0,0,7.6,2.6,0.32,1 +Student_00643,1,1,9147,1,1,1,1,37,38,4,9,129.0,121.0,1,0,0,1,0,0,0,18,0,5,8,2,10.5,0,0,5,7,3,12.333333333333334,0,7.6,2.6,0.32,1 +Student_00644,1,1,9500,1,3,1,1,37,38,7,7,143.0,133.8,1,0,0,1,0,0,0,18,0,8,8,8,14.26875,0,0,8,8,8,14.26875,0,9.4,-0.8,-3.12,1 +Student_00645,1,1,9773,1,2,1,1,38,38,7,7,108.0,115.0,1,0,1,0,0,0,0,20,0,6,0,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_00646,NA,1,9147,1,1,NA,1,19,37,9,9,130.0,131.8,1,0,0,1,0,1,0,19,0,5,8,2,10.5,0,0,5,11,3,13.333333333333334,0,7.6,2.6,0.32,1 +Student_00647,1,1,9238,1,1,1,1,37,1,3,5,135.0,121.0,0,0,0,1,0,0,0,21,0,6,11,5,11.2,0,0,6,15,1,10.0,0,7.6,2.6,0.32,1 +Student_00648,2,39,9991,0,1,3,1,19,19,9,7,140.0,152.4,0,0,0,1,0,0,0,26,0,5,5,5,12.0,0,0,5,6,5,14.833333333333334,0,10.8,1.4,1.74,2 +Student_00649,1,43,9556,1,2,1,1,1,19,4,3,120.0,110.2,0,0,0,1,0,0,0,27,0,7,9,7,12.228571428571428,0,1,8,10,8,13.2125,0,10.8,1.4,1.74,2 +Student_00650,1,1,9670,1,1,1,1,1,38,5,1,117.0,113.5,1,0,0,1,0,0,0,20,0,5,6,4,11.5,0,0,5,5,4,10.75,0,9.4,-0.8,-3.12,2 +Student_00651,1,17,9238,1,1,1,1,19,1,5,0,151.0,144.4,1,0,0,1,0,0,0,18,0,6,8,6,15.375,0,0,6,7,6,16.428571428571427,0,16.2,0.3,-0.92,2 +Student_00652,1,53,9085,1,1,42,1,1,1,5,5,140.0,143.3,1,0,0,0,0,0,0,23,7,12,19,9,13.666666666666666,0,4,9,15,6,13.5,0,8.9,1.4,3.51,1 +Student_00653,1,39,9500,1,1,19,1,1,5,4,3,133.1,100.0,0,0,0,1,0,0,0,24,0,8,11,7,12.614285714285714,0,0,8,11,7,12.614285714285714,0,12.7,3.7,-1.7,2 +Student_00655,1,1,9773,1,1,1,1,19,38,3,5,125.0,115.9,0,0,0,1,0,0,0,19,0,6,13,4,11.75,0,0,6,10,4,11.0,0,10.8,1.4,1.74,2 +Student_00656,1,1,9238,1,4,1,1,19,38,9,6,125.0,114.9,1,0,1,1,0,1,0,19,0,6,9,5,11.4,0,0,6,9,3,10.0,0,8.9,1.4,3.51,1 +Student_00658,1,51,8014,0,1,1,1,1,38,5,7,121.0,112.3,0,0,0,1,0,0,0,22,14,16,16,13,10.923076923076923,0,13,13,13,11,11.454545454545457,0,16.2,0.3,-0.92,2 +Student_00659,1,43,9070,1,1,1,1,1,19,5,10,141.0,127.0,0,0,0,1,0,0,0,20,0,6,6,5,12.4,0,0,6,9,5,12.4,0,12.7,3.7,-1.7,2 +Student_00661,1,44,9003,1,1,39,1,1,3,4,2,180.0,180.0,0,0,0,1,0,0,0,NA,0,6,6,6,15.833333333333334,0,0,6,8,6,15.5,0,15.5,2.8,-4.06,2 +Student_00662,1,1,9500,1,1,1,1,19,19,194,193,117.0,117.4,1,0,0,1,0,0,0,19,0,7,12,5,11.8,0,0,7,9,6,11.708333333333334,0,11.1,0.6,2.02,1 +Student_00663,1,17,9773,1,4,1,1,1,19,4,1,127.0,115.8,1,0,0,1,0,0,0,18,0,6,7,6,12.571428571428571,0,0,6,6,6,13.666666666666666,0,13.9,-0.3,0.79,2 +Student_00664,1,1,9670,1,3,1,1,37,37,0,0,126.0,136.5,1,0,0,1,0,0,0,18,0,5,7,3,12.0,0,0,5,7,4,13.25,1,7.6,2.6,0.32,2 +Student_00665,1,17,9500,1,3,1,1,3,3,9,7,143.0,129.0,1,0,0,1,1,0,0,19,0,7,8,7,13.3625,0,0,8,9,8,14.444444444444445,0,13.9,-0.3,0.79,2 +Student_00666,1,1,9085,1,1,1,13,3,3,6,6,144.0,137.6,1,0,0,1,0,1,1,19,0,5,6,5,15.4,0,0,5,5,5,16.0,0,10.8,1.4,1.74,2 +Student_00667,1,17,9773,1,2,1,1,37,38,5,5,126.0,129.5,1,0,1,0,0,0,0,18,0,6,9,5,12.2,0,0,6,9,4,11.75,0,10.8,1.4,1.74,0 +Student_00668,1,51,9238,1,1,39,1,38,38,5,7,140.0,129.1,1,0,0,1,0,1,0,20,6,11,11,11,12.818181818181818,0,6,11,11,11,13.545454545454543,0,12.4,0.5,1.79,2 +Student_00669,1,17,9500,1,5,1,1,1,19,4,8,148.0,130.2,1,0,0,1,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00670,1,42,9500,1,1,1,1,19,37,5,7,100.0,134.3,1,0,0,1,0,0,0,28,12,17,21,17,13.394736842105264,0,11,17,19,17,13.554736842105264,0,16.2,0.3,-0.92,2 +Student_00671,1,1,9238,1,1,1,1,37,1,9,9,151.0,138.4,1,0,0,1,0,1,0,20,0,6,8,6,NA,0,0,6,8,6,11.0,0,12.7,3.7,-1.7,2 +Student_00672,1,42,8014,0,1,1,1,NA,38,90,7,120.0,120.0,1,0,0,1,0,0,0,30,9,11,19,9,13.444444444444445,1,5,7,7,7,14.714285714285714,0,7.6,2.6,0.32,0 +Student_00673,1,1,9500,1,4,1,1,1,19,9,7,135.0,123.5,1,0,0,1,0,1,0,19,0,7,8,7,12.285714285714286,0,0,8,10,8,11.7375,0,12.4,0.5,1.79,2 +Student_00675,1,1,9254,1,1,1,1,38,38,5,8,116.0,110.8,1,0,0,1,0,0,0,18,0,6,8,6,12.166666666666666,0,0,6,6,6,13.5,0,11.1,0.6,2.02,2 +Student_00676,1,17,9853,1,1,1,1,37,37,9,9,147.0,142.8,1,0,0,1,0,0,0,23,0,6,11,2,10.0,0,0,6,15,2,11.0,0,7.6,2.6,0.32,0 +Student_00678,1,1,9853,1,1,1,1,37,19,7,7,133.0,126.7,1,0,0,1,0,0,0,18,0,6,9,5,11.833333333333334,0,0,6,6,4,12.0,0,15.5,2.8,-4.06,1 +Student_00679,2,39,9773,1,1,19,1,37,37,0,0,100.0,163.5,0,0,1,0,1,0,0,50,0,6,7,1,15.0,0,0,5,12,0,0.0,0,10.8,1.4,1.74,0 +Student_00680,1,1,171,1,1,1,41,3,3,2,5,151.0,161.9,1,0,0,1,0,1,1,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_00681,1,17,9254,1,2,1,41,19,38,9,9,124.0,123.3,1,0,0,1,0,0,1,22,0,6,7,6,10.833333333333334,0,0,6,6,6,10.666666666666666,0,13.9,-0.3,0.79,2 +Student_00682,1,44,9238,1,1,39,41,1,1,4,6,140.0,137.5,0,0,1,1,0,1,1,23,3,6,7,6,13.142857142857142,0,2,6,6,6,14.0,0,12.4,0.5,1.79,2 +Student_00683,1,18,9085,1,4,1,1,1,1,4,5,170.0,166.6,0,0,1,0,0,1,0,20,2,5,8,5,14.4,1,0,5,6,5,14.0,0,12.7,3.7,-1.7,0 +Student_00684,4,39,9238,1,1,19,1,37,37,9,10,133.1,103.5,0,0,0,0,0,0,0,44,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_00685,4,39,9003,1,1,19,1,37,37,9,9,133.1,110.0,0,0,0,1,1,0,0,49,6,12,17,7,12.0,0,3,12,19,9,11.22222222222222,0,15.5,2.8,-4.06,2 +Student_00686,2,43,9991,0,1,1,1,37,37,9,9,100.0,128.2,0,0,0,1,1,0,0,46,6,10,13,9,12.2,0,4,10,12,10,12.8,0,7.6,2.6,0.32,2 +Student_00687,1,39,9085,1,1,39,1,37,37,1,9,120.0,137.7,1,0,0,0,1,0,0,41,3,3,3,3,12.333333333333334,0,2,2,2,2,11.0,0,12.4,0.5,1.79,0 +Student_00688,1,17,9500,1,3,1,1,38,19,9,8,133.0,128.8,1,0,0,1,1,0,0,18,0,7,8,7,NA,0,0,8,9,8,12.48125,0,13.9,-0.3,0.79,2 +Student_00689,3,39,9991,0,1,1,1,37,1,9,2,120.0,170.0,0,0,0,1,1,0,0,43,0,5,5,5,11.8,0,0,5,6,5,14.0,0,9.4,-0.8,-3.12,2 +Student_00690,4,39,9147,1,2,19,1,37,37,9,7,133.1,116.4,0,0,1,0,1,0,0,70,0,5,5,0,0.0,0,0,5,9,0,0.0,0,10.8,1.4,1.74,0 +Student_00692,2,43,9003,1,1,1,1,37,37,9,7,133.1,136.0,0,0,0,1,1,0,0,41,18,19,19,19,12.68421052631579,0,12,13,13,13,12.384615384615383,0,15.5,2.8,-4.06,2 +Student_00694,1,39,33,1,1,1,41,38,37,9,8,100.0,100.0,0,0,1,0,1,0,1,35,0,7,18,3,11.25,0,0,7,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_00695,2,39,9130,1,1,19,1,2,1,2,9,NA,157.0,1,0,0,1,1,0,0,44,1,5,13,4,14.0,3,1,5,9,4,15.5,2,10.8,1.4,1.74,2 +Student_00696,1,1,9147,1,1,1,1,3,1,5,5,143.0,152.1,1,0,1,1,1,0,0,18,0,5,15,4,13.333333333333334,0,0,5,6,2,13.5,0,13.9,-0.3,0.79,0 +Student_00697,2,1,8014,0,1,1,1,37,37,0,0,165.0,162.9,1,0,0,1,1,0,0,45,0,6,7,6,13.666666666666666,0,0,6,6,6,13.666666666666666,0,7.6,2.6,0.32,2 +Student_00698,1,1,9254,1,1,1,1,3,1,2,1,154.0,137.2,0,0,0,1,1,0,0,20,0,6,12,3,10.0,0,0,6,9,5,10.8,0,15.5,2.8,-4.06,1 +Student_00699,1,44,9003,1,1,39,1,1,38,9,1,140.0,140.0,1,0,0,1,1,0,0,22,0,6,12,5,12.6,0,0,6,11,6,11.714285714285714,0,12.4,0.5,1.79,2 +Student_00700,1,43,9119,1,1,1,1,37,38,5,7,140.0,146.5,0,0,0,1,1,0,0,39,0,5,10,3,17.333333333333332,0,0,5,11,1,17.0,0,13.9,-0.3,0.79,0 +Student_00701,1,44,9085,1,1,39,1,2,2,6,6,130.0,130.0,0,0,0,0,1,0,0,20,2,6,10,5,13.2,0,1,6,21,3,12.0,0,12.4,0.5,1.79,1 +Student_00702,2,39,9147,1,1,NA,1,37,19,9,3,133.1,128.0,0,0,0,1,1,0,0,49,0,5,9,3,14.0,0,0,5,8,3,13.666666666666666,0,NA,1.4,3.51,0 +Student_00703,1,7,9556,1,1,4,1,5,5,2,2,190.0,190.0,1,0,0,1,1,0,0,43,4,4,4,4,13.875,0,1,1,1,1,12.5,0,11.1,0.6,2.02,0 +Student_00704,2,39,9991,0,1,1,1,37,37,9,9,120.0,133.2,1,0,0,1,1,0,0,32,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00705,1,39,9238,1,1,12,1,37,37,9,9,100.0,124.3,0,0,0,1,1,0,0,47,3,9,9,9,13.11111111111111,0,3,7,7,7,14.857142857142858,0,10.8,1.4,1.74,2 +Student_00706,5,39,9991,0,1,1,1,37,37,9,9,120.0,138.1,0,0,0,1,1,1,0,37,0,5,8,5,13.0,0,0,5,11,4,13.333333333333334,2,16.2,0.3,-0.92,0 +Student_00708,2,39,9003,1,1,1,1,37,37,9,6,150.0,140.0,0,0,0,1,1,0,0,60,17,18,18,18,14.11111111111111,0,11,13,13,13,14.23076923076923,0,15.5,2.8,-4.06,2 +Student_00709,2,39,9254,1,1,1,1,1,19,9,9,120.0,148.3,0,0,0,1,1,0,0,47,6,11,11,11,14.727272727272728,0,6,9,9,9,15.77777777777778,0,10.8,1.4,1.74,2 +Student_00710,1,39,8014,0,1,1,1,37,11,9,7,133.1,96.0,0,0,1,0,1,0,0,50,0,6,6,0,0.0,0,0,5,6,0,NA,0,12.4,0.5,1.79,0 +Student_00712,1,39,9119,1,1,1,1,37,37,9,8,100.0,160.0,0,0,1,0,1,0,0,45,0,5,5,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_00713,NA,39,9085,1,1,1,1,37,37,90,90,133.1,110.3,0,0,0,1,1,0,0,33,0,5,7,4,13.5,0,0,5,6,5,11.6,0,7.6,2.6,0.32,2 +Student_00714,1,1,9500,1,1,1,1,3,3,2,2,143.0,129.0,0,0,0,1,1,0,0,18,0,8,8,7,13.105714285714283,0,0,8,8,7,13.105714285714283,0,10.8,1.4,1.74,2 +Student_00715,2,39,9085,1,1,1,1,37,37,6,6,120.0,150.0,0,0,0,1,1,0,0,43,0,5,8,5,13.5,2,0,5,5,5,14.4,0,9.4,-0.8,-3.12,2 +Student_00717,1,39,9130,1,1,9,1,34,36,0,90,133.1,107.5,0,0,0,1,1,0,0,29,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00718,4,39,9670,1,1,1,1,2,1,3,9,140.0,170.0,0,0,1,0,1,0,0,53,0,6,11,3,14.333333333333334,0,0,6,6,0,0.0,0,12.7,3.7,-1.7,0 +Student_00719,2,42,9991,0,1,6,1,37,37,9,9,123.0,123.0,0,0,0,1,1,0,0,37,0,5,10,5,15.8,0,0,5,5,5,17.6,0,9.4,-0.8,-3.12,1 +Student_00722,1,1,9254,1,1,1,1,19,1,3,7,115.0,113.6,0,0,0,1,1,0,0,23,0,6,10,6,13.0,0,0,6,9,6,12.0,0,11.1,0.6,2.02,1 +Student_00724,1,39,8014,0,1,1,1,37,37,90,5,140.0,115.5,0,0,0,0,1,0,0,33,0,6,6,1,11.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_00725,1,7,9130,1,3,3,1,37,26,90,10,130.0,130.0,0,0,0,0,1,0,0,41,0,5,9,0,0.0,4,0,5,9,0,0.0,3,10.8,1.4,1.74,0 +Student_00727,1,51,9670,1,1,1,1,12,5,3,3,140.0,126.6,0,0,0,1,1,0,0,19,2,6,7,6,14.428571428571429,0,1,7,8,7,14.375,0,11.1,0.6,2.02,2 +Student_00729,1,1,171,1,2,1,41,19,1,4,7,131.0,131.4,1,0,0,1,1,0,1,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_00730,1,43,9670,1,1,1,1,3,2,2,2,141.0,133.3,1,0,0,1,1,0,0,18,0,6,13,4,13.75,0,0,6,8,5,11.2,0,13.9,-0.3,0.79,1 +Student_00731,1,1,9773,1,1,1,1,19,37,9,9,120.0,118.3,0,0,1,0,1,1,0,18,0,6,11,5,12.166666666666666,0,0,6,15,3,12.0,0,13.9,-0.3,0.79,0 +Student_00732,1,44,9003,1,1,39,1,2,1,4,6,140.0,140.0,0,0,0,1,1,0,0,21,0,6,12,5,12.142857142857142,0,0,6,11,5,11.666666666666666,0,13.9,-0.3,0.79,2 +Student_00733,1,1,9254,1,1,1,1,1,19,6,6,132.0,124.7,1,0,0,1,1,0,0,21,0,6,9,6,12.0,0,0,6,8,5,11.6,0,13.9,-0.3,0.79,2 +Student_00734,2,39,9147,1,2,1,1,19,37,4,7,130.0,140.0,0,0,0,1,1,0,0,34,0,5,10,3,11.666666666666666,1,0,5,7,4,12.75,0,9.4,-0.8,-3.12,2 +Student_00735,4,39,9130,1,1,1,1,37,37,6,7,140.0,150.0,1,0,0,1,1,0,0,34,0,6,9,0,0.0,0,0,6,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_00737,1,43,9773,1,1,1,1,3,37,3,7,140.0,116.9,0,0,0,1,1,0,0,32,6,11,15,7,11.285714285714286,0,5,7,10,6,12.333333333333334,0,13.9,-0.3,0.79,1 +Student_00738,1,17,9254,1,2,1,1,37,37,5,7,130.0,123.4,1,0,0,1,1,0,0,30,0,6,17,2,10.0,0,0,6,15,3,11.333333333333334,0,7.6,2.6,0.32,0 +Student_00740,1,51,9773,1,1,1,1,1,19,8,8,158.0,117.1,1,0,0,1,1,0,0,20,1,7,7,6,13.833333333333334,0,1,6,7,5,13.0,0,8.9,1.4,3.51,0 +Student_00741,1,1,9070,1,1,1,1,19,19,9,7,124.0,113.9,1,0,0,1,1,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00742,1,1,9254,1,1,1,1,3,3,2,2,136.0,128.7,0,0,0,1,1,0,0,19,0,6,7,6,14.428571428571429,0,0,6,6,6,12.5,0,8.9,1.4,3.51,2 +Student_00743,1,17,9500,1,3,1,1,3,3,3,3,142.0,132.9,1,0,0,1,1,0,0,18,0,7,8,5,14.2,0,0,7,9,6,12.4,0,12.4,0.5,1.79,0 +Student_00744,1,39,9991,0,1,1,1,1,19,4,8,150.0,123.0,0,0,0,1,1,0,0,27,0,5,8,4,11.5,0,0,5,9,3,10.333333333333334,0,12.7,3.7,-1.7,0 +Student_00745,1,39,NA,1,1,12,1,1,1,9,9,120.0,129.8,1,0,0,1,1,0,0,52,0,6,7,5,13.0,0,0,6,6,6,15.0,0,9.4,-0.8,-3.12,2 +Student_00746,2,43,9003,1,1,1,1,1,1,4,5,149.0,156.1,1,0,0,0,1,0,0,29,0,6,6,0,0.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_00748,1,43,9085,1,1,1,25,38,38,9,6,110.0,117.2,1,0,0,1,1,0,1,28,13,18,45,18,12.5,12,10,13,26,12,11.428571428571429,6,15.5,2.8,-4.06,2 +Student_00749,1,39,9670,1,1,6,1,1,1,90,3,133.1,107.0,1,0,0,1,1,0,0,30,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00751,1,1,9670,1,2,1,1,38,37,5,5,130.0,123.4,1,0,0,1,0,0,0,21,0,5,5,4,11.75,0,0,5,5,3,13.333333333333334,0,9.4,-0.8,-3.12,2 +Student_00752,1,1,9070,1,1,1,1,37,37,9,9,141.0,126.7,1,0,1,1,0,1,0,20,0,6,9,6,13.333333333333334,0,0,6,10,6,14.666666666666666,0,12.7,3.7,-1.7,2 +Student_00753,1,42,9500,1,1,1,1,37,37,3,3,123.0,123.0,1,0,0,1,0,1,0,21,0,8,8,8,13.105,0,0,8,8,8,13.105,0,9.4,-0.8,-3.12,2 +Student_00754,2,39,9991,0,1,19,1,19,37,7,9,133.1,137.2,0,0,1,0,0,0,0,32,0,5,5,0,0.0,0,0,5,6,0,0.0,0,10.8,1.4,1.74,0 +Student_00755,1,1,9070,1,3,1,1,37,37,9,9,122.0,125.9,1,0,0,1,1,1,0,20,0,6,6,6,15.5,0,0,6,7,6,12.166666666666666,0,12.4,0.5,1.79,2 +Student_00756,1,1,171,1,4,1,1,1,19,4,5,132.0,138.0,1,0,1,0,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00757,1,15,9670,1,1,1,41,1,1,9,5,133.1,128.2,0,0,1,NA,1,0,1,18,0,6,6,4,11.25,0,0,6,7,3,12.333333333333334,0,8.9,1.4,3.51,0 +Student_00758,1,43,9991,0,1,1,1,37,2,9,4,130.0,126.5,1,0,0,0,1,0,0,23,10,15,24,12,11.0,0,10,14,21,11,11.363636363636363,1,7.6,2.6,0.32,0 +Student_00759,1,1,9254,1,1,1,1,1,1,3,3,111.0,112.4,1,0,0,1,1,0,0,20,0,6,10,6,12.333333333333334,0,0,6,9,4,13.0,0,12.4,0.5,1.79,2 +Student_00761,1,17,9003,1,1,1,1,3,3,2,2,125.0,100.0,0,0,0,1,1,0,0,27,16,18,19,18,12.22222222222222,0,9,12,15,12,12.384615384615383,0,15.5,2.8,-4.06,2 +Student_00762,1,5,171,1,1,1,1,3,19,1,10,137.0,144.7,1,0,0,1,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,1 +Student_00764,1,15,9147,1,1,1,21,1,3,192,3,133.1,100.0,0,0,1,1,1,0,1,40,0,5,10,1,11.0,0,0,5,10,1,10.0,0,11.1,0.6,2.02,1 +Student_00765,2,44,8014,0,1,39,NA,1,1,5,5,150.0,154.0,0,0,0,1,1,0,0,37,12,16,17,16,14.125,0,6,11,14,10,13.0,0,12.4,0.5,1.79,2 +Student_00767,1,44,9130,1,1,39,1,1,1,4,4,150.0,150.0,1,0,0,1,0,0,0,20,0,5,7,4,12.0,1,0,5,6,4,12.4,0,10.8,1.4,1.74,1 +Student_00768,NA,7,9991,0,1,40,1,1,37,4,1,133.1,100.0,0,0,0,1,0,0,0,26,8,9,11,9,12.333333333333334,0,4,7,7,7,12.571428571428571,0,12.4,0.5,1.79,2 +Student_00769,2,39,8014,0,1,1,1,37,37,9,7,133.1,162.5,0,0,0,1,1,0,0,54,4,9,9,9,14.333333333333334,0,2,7,7,7,13.857142857142858,0,8.9,1.4,3.51,2 +Student_00770,1,17,9670,1,5,1,1,19,19,5,5,132.0,134.1,1,0,0,1,1,0,0,21,0,6,6,6,15.166666666666666,0,0,6,9,6,14.0,0,10.8,1.4,1.74,2 +Student_00772,1,17,9773,1,6,1,1,1,19,5,5,126.0,119.0,1,0,0,1,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00773,1,1,9500,1,3,1,NA,1,19,4,9,136.0,131.1,1,0,0,1,0,0,0,19,0,7,9,6,13.411428571428573,0,0,8,12,7,13.294444444444444,0,15.5,2.8,-4.06,1 +Student_00774,1,1,9238,1,2,1,1,38,1,4,10,129.0,129.4,1,0,0,1,0,0,0,18,0,6,7,6,12.333333333333334,0,0,6,7,6,12.166666666666666,0,9.4,-0.8,-3.12,2 +Student_00775,1,1,9085,1,1,1,1,3,1,2,8,126.0,123.9,1,0,0,1,0,0,0,19,0,6,13,4,11.8,0,0,6,18,4,12.2,0,12.4,0.5,1.79,1 +Student_00776,1,44,9085,1,1,39,1,1,1,4,7,140.0,140.0,1,0,1,1,0,0,0,22,2,6,9,6,12.0,0,1,6,12,3,12.0,0,13.9,-0.3,0.79,0 +Student_00777,1,43,9085,1,1,1,1,2,1,4,4,162.0,162.0,0,0,0,1,0,0,0,19,0,6,7,6,15.0,0,0,6,8,6,15.625,0,12.4,0.5,1.79,2 +Student_00778,1,1,171,1,1,1,1,3,2,4,2,148.0,131.6,1,0,0,1,0,0,0,21,6,12,12,8,13.875,0,4,11,13,9,12.7,1,8.9,1.4,3.51,0 +Student_00779,1,17,9853,1,1,1,1,3,3,132,132,119.0,110.6,0,0,0,1,0,0,0,20,0,7,9,6,11.833333333333334,0,0,7,7,6,14.333333333333334,0,11.1,0.6,2.02,1 +Student_00780,1,17,9773,1,3,1,1,1,19,5,5,123.0,117.4,1,0,0,1,0,1,0,18,0,6,6,6,12.5,0,0,6,6,6,13.833333333333334,0,16.2,0.3,-0.92,2 +Student_00782,1,17,9670,1,1,1,1,1,1,5,4,113.0,106.7,1,0,1,1,0,0,0,20,0,6,10,2,11.666666666666666,0,0,6,10,4,10.5,0,15.5,2.8,-4.06,0 +Student_00783,1,1,9500,1,1,1,1,19,37,3,8,152.0,156.9,0,0,0,1,0,1,0,18,0,7,10,7,14.668,0,0,8,8,8,14.63375,0,15.5,2.8,-4.06,2 +Student_00784,1,1,9500,1,3,1,1,3,3,1,3,154.0,129.0,1,0,0,1,0,0,0,18,0,8,9,6,13.345,2,0,8,9,6,13.345,2,9.4,-0.8,-3.12,1 +Student_00785,1,1,9773,1,2,1,1,1,34,9,9,130.0,124.8,1,0,0,1,0,1,0,20,0,6,7,5,12.8,0,0,6,6,6,12.333333333333334,0,12.4,0.5,1.79,2 +Student_00788,1,1,9500,1,1,1,1,3,1,4,5,148.0,132.8,0,0,0,1,0,0,0,18,0,8,8,7,14.537142857142856,0,0,8,8,7,14.537142857142856,0,10.8,1.4,1.74,2 +Student_00789,1,5,9085,1,3,1,1,37,37,0,90,143.0,159.1,0,0,1,1,0,1,0,18,0,5,5,5,14.4,0,0,5,5,5,14.0,0,7.6,2.6,0.32,0 +Student_00790,1,17,171,1,3,1,1,19,1,5,4,147.0,137.6,1,0,0,1,0,1,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_00791,1,17,9773,1,1,1,1,1,19,9,9,138.0,124.0,0,0,0,1,0,1,0,19,0,6,6,6,13.166666666666666,0,0,6,6,6,13.833333333333334,0,11.1,0.6,2.02,2 +Student_00792,1,39,9500,1,1,1,1,3,3,2,2,120.0,149.0,0,0,0,0,1,0,0,36,0,6,15,2,11.5,0,0,7,9,0,0.0,0,15.5,2.8,-4.06,0 +Student_00793,NA,17,9238,1,1,1,1,1,40,9,2,145.0,129.6,0,0,0,1,0,1,0,19,0,6,7,6,11.333333333333334,0,0,6,7,6,12.428571428571429,0,11.1,0.6,2.02,2 +Student_00794,1,17,9238,1,3,1,1,3,1,2,5,118.0,110.0,1,0,0,1,0,0,0,18,0,6,6,6,12.0,0,0,6,6,5,13.6,0,8.9,1.4,3.51,2 +Student_00796,1,1,9773,1,3,1,1,38,38,5,8,135.0,133.3,1,0,0,1,0,1,0,18,0,6,6,6,14.833333333333334,0,0,6,6,6,14.166666666666666,0,8.9,1.4,3.51,2 +Student_00798,1,18,9500,1,3,1,1,1,1,4,8,145.0,133.6,1,0,0,1,0,0,0,18,0,7,8,7,13.087142857142856,0,0,8,8,8,12.95,0,11.1,0.6,2.02,2 +Student_00799,1,1,9130,1,1,1,1,1,37,9,9,133.0,123.2,1,0,0,1,0,1,0,19,0,6,8,6,13.333333333333334,0,0,6,7,6,13.666666666666666,0,8.9,1.4,3.51,2 +Student_00800,1,1,9853,1,1,1,1,3,1,3,7,127.0,137.2,1,0,0,1,0,0,0,18,0,6,7,6,12.166666666666666,0,0,6,10,4,12.75,0,10.8,1.4,1.74,1 +Student_00801,1,53,9070,1,1,42,1,40,19,3,5,130.0,130.0,1,0,0,0,0,1,0,22,0,6,8,6,11.0,0,0,6,10,4,12.0,0,8.9,1.4,3.51,1 +Student_00803,1,17,9147,1,4,1,NA,19,19,5,5,125.0,118.0,1,0,0,1,0,0,0,19,0,5,7,5,13.6,0,0,5,6,5,12.2,0,8.9,1.4,3.51,2 +Student_00806,1,17,9147,1,2,1,1,19,1,9,3,118.0,113.5,1,0,1,1,0,0,0,20,0,5,10,2,11.5,0,0,5,8,3,10.0,0,11.1,0.6,2.02,1 +Student_00807,1,17,9070,1,3,1,NA,1,38,3,5,142.0,146.9,1,0,0,1,0,1,0,18,0,6,6,6,13.0,0,0,6,6,6,12.166666666666666,0,16.2,0.3,-0.92,2 +Student_00809,1,1,9773,1,4,1,1,1,3,4,7,143.0,129.7,1,0,0,1,0,0,0,20,0,4,4,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_00810,1,1,9070,1,5,1,1,3,1,9,3,123.0,121.3,1,0,0,1,0,0,0,20,0,6,6,6,11.166666666666666,0,0,6,9,6,11.5,0,12.4,0.5,1.79,1 +Student_00811,1,1,9238,1,1,1,1,1,1,9,4,115.0,109.1,1,0,1,0,0,1,0,22,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_00812,1,17,9853,1,2,1,1,19,38,5,7,112.0,107.1,1,0,0,1,0,1,0,18,0,7,8,7,12.142857142857142,0,0,7,9,6,13.666666666666666,0,11.1,0.6,2.02,2 +Student_00813,1,17,9500,1,1,1,1,19,38,9,9,135.0,129.2,0,0,0,1,0,1,0,18,0,7,7,7,14.145714285714286,0,0,8,9,8,13.627777777777778,0,11.1,0.6,2.02,2 +Student_00814,1,1,9500,1,1,1,1,3,4,3,3,162.0,154.1,0,0,0,1,0,0,0,18,0,7,7,7,14.45,0,0,8,9,8,14.144444444444444,0,11.1,0.6,2.02,2 +Student_00815,1,1,9853,1,1,1,1,19,3,4,4,143.0,147.2,0,0,0,1,0,0,0,18,0,7,7,7,15.714285714285714,0,0,7,7,7,15.0,0,11.1,0.6,2.02,2 +Student_00816,1,51,9147,1,1,1,1,1,1,4,4,130.0,120.0,0,0,0,1,0,0,0,21,0,5,9,5,12.8,0,0,5,11,3,12.666666666666666,0,11.1,0.6,2.02,1 +Student_00818,1,16,9070,1,1,1,1,1,1,4,4,125.0,120.8,1,0,0,1,0,0,0,18,0,6,6,6,14.5,0,0,6,6,6,12.833333333333334,0,12.4,0.5,1.79,2 +Student_00820,1,1,8014,0,1,1,1,34,37,9,NA,123.0,121.3,1,0,0,1,0,0,0,25,0,6,6,6,12.833333333333334,0,0,6,6,6,12.833333333333334,0,7.6,2.6,0.32,2 +Student_00821,1,1,9147,1,1,1,1,19,19,9,9,142.0,127.0,1,0,0,1,0,1,0,18,0,5,10,5,12.0,0,0,5,8,4,11.6,0,13.9,-0.3,0.79,2 +Student_00823,1,1,9085,1,1,1,6,1,19,4,7,140.0,131.6,1,0,0,1,0,0,1,20,0,7,9,6,14.714285714285714,0,1,7,16,6,13.2,0,12.4,0.5,1.79,1 +Student_00824,1,1,9238,1,2,1,1,19,19,9,9,133.1,106.0,1,0,0,1,0,1,0,20,0,6,7,6,12.571428571428571,0,0,6,7,6,13.285714285714286,0,12.4,0.5,NA,2 +Student_00825,1,18,9773,1,4,1,1,1,1,9,9,114.0,111.6,1,0,0,1,0,1,0,21,0,6,6,6,12.5,0,0,6,6,6,11.5,0,11.1,0.6,2.02,2 +Student_00829,1,1,9500,1,4,1,1,19,19,4,5,148.0,137.0,1,0,0,1,0,0,0,18,0,8,8,8,14.25,0,0,8,8,8,14.25,0,9.4,-0.8,-3.12,2 +Student_00830,1,43,9670,1,1,1,1,3,19,3,5,139.0,120.8,0,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00831,1,17,9254,1,1,1,1,39,3,3,3,136.0,128.7,1,0,0,1,0,0,0,20,0,6,8,6,11.666666666666666,0,0,6,10,6,11.0,0,13.9,-0.3,0.79,0 +Student_00832,1,39,9238,1,1,9,1,34,34,0,0,133.1,118.0,0,0,0,1,0,0,0,47,0,6,12,0,0.0,0,0,5,10,0,0.0,0,7.6,2.6,0.32,0 +Student_00833,1,43,9130,1,1,1,6,1,3,9,2,120.0,120.0,0,0,1,1,0,0,1,21,2,5,9,5,13.2,2,0,5,7,2,12.5,2,10.8,1.4,1.74,1 +Student_00834,2,39,9130,1,1,1,1,37,37,9,6,130.0,160.0,0,0,0,1,1,0,0,31,1,6,11,2,12.0,1,1,6,12,1,10.0,1,16.2,0.3,-0.92,0 +Student_00835,2,39,9119,1,1,1,1,37,37,90,5,110.0,150.0,1,0,0,1,1,0,0,46,0,5,6,0,0.0,0,0,5,5,0,NA,0,7.6,2.6,0.32,0 +Student_00836,1,1,9119,1,3,1,1,3,1,3,4,133.0,121.8,1,0,0,1,1,0,0,18,0,5,9,4,12.0,0,0,5,10,2,11.0,0,8.9,1.4,3.51,1 +Student_00838,NA,51,9556,1,1,1,1,1,37,152,193,131.0,126.6,1,0,0,1,1,0,0,23,0,7,11,5,12.414285714285713,0,0,7,13,2,13.5,0,8.9,1.4,3.51,1 +Student_00839,1,44,9130,1,1,39,1,3,1,2,8,150.0,150.0,0,0,0,0,1,0,0,22,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_00840,NA,1,9147,1,1,1,1,38,1,3,10,125.0,114.5,1,0,0,1,1,0,0,19,0,5,5,5,13.8,0,0,5,7,5,12.4,0,9.4,-0.8,-3.12,2 +Student_00841,1,1,9147,1,1,1,41,3,3,9,9,108.0,107.0,0,0,1,0,0,0,1,19,0,5,14,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,NA,0 +Student_00842,1,17,9147,1,1,1,1,3,1,3,4,116.0,115.7,0,0,0,0,1,0,0,22,0,5,10,4,11.5,0,0,5,11,4,14.0,0,8.9,1.4,3.51,1 +Student_00843,1,39,9130,1,1,1,1,3,34,3,0,133.1,120.0,0,0,1,NA,1,0,0,29,0,5,11,0,0.0,4,0,5,6,0,0.0,1,9.4,-0.8,-3.12,0 +Student_00844,1,1,9500,1,3,1,1,37,38,9,5,147.0,134.8,1,0,0,1,0,0,0,18,0,7,7,6,14.016666666666666,0,0,7,7,6,14.016666666666666,0,7.6,2.6,0.32,2 +Student_00845,1,1,9238,1,1,1,1,38,34,9,9,143.0,133.6,1,0,0,1,0,0,0,18,0,6,9,5,11.4,0,0,6,8,5,10.8,0,9.4,-0.8,-3.12,2 +Student_00846,1,1,171,1,1,1,1,37,37,9,8,115.0,129.0,1,0,1,0,0,1,0,23,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00848,1,17,9147,1,1,1,1,19,19,9,9,118.0,122.2,0,0,0,1,0,0,0,19,0,5,11,3,10.666666666666666,0,0,5,9,4,10.25,0,11.1,0.6,2.02,2 +Student_00850,1,17,9500,1,6,1,1,1,19,4,4,143.0,129.9,0,0,0,1,0,1,0,20,3,7,7,7,13.914285714285713,0,5,8,8,8,14.10625,0,11.1,0.6,2.02,2 +Student_00851,1,1,9500,1,6,1,1,3,3,1,1,133.0,126.2,1,0,0,1,0,0,0,19,0,7,9,7,13.761111111111113,0,0,8,11,7,12.82375,0,15.5,2.8,-4.06,2 +Student_00852,1,5,9853,1,2,1,1,19,19,4,5,122.0,112.6,1,0,0,1,0,0,0,22,0,6,10,5,12.6,0,0,6,9,4,11.25,0,12.7,3.7,-1.7,1 +Student_00853,1,1,9238,1,1,1,1,19,19,9,9,164.0,149.0,1,0,0,1,0,1,0,23,0,6,7,6,13.857142857142858,0,0,6,6,6,14.166666666666666,0,10.8,1.4,1.74,2 +Student_00854,2,39,9500,1,1,1,1,1,19,9,9,133.1,120.0,0,0,0,1,1,1,0,34,0,8,8,7,13.842857142857143,0,0,8,8,7,13.842857142857143,0,12.7,3.7,-1.7,2 +Student_00855,1,17,9119,1,4,1,1,19,19,5,5,127.0,120.4,1,0,1,0,1,0,0,18,0,5,12,0,0.0,0,0,5,8,0,0.0,0,9.4,-0.8,-3.12,1 +Student_00856,1,1,9773,1,3,1,1,1,39,4,1,140.0,128.1,1,1,0,1,1,0,0,21,0,6,6,5,11.8,0,0,6,9,0,0.0,0,16.2,0.3,-0.92,0 +Student_00857,1,1,9238,1,1,1,1,1,19,4,3,127.0,141.7,1,0,0,1,1,0,0,22,0,6,6,6,12.666666666666666,0,0,6,6,6,13.833333333333334,0,10.8,1.4,1.74,0 +Student_00858,1,39,9003,1,1,12,1,37,1,9,10,133.1,130.0,0,0,0,1,1,0,0,28,0,6,6,0,0.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_00859,1,5,9119,1,4,1,1,19,37,4,6,115.0,113.3,1,0,0,1,1,0,0,23,0,5,7,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00861,1,18,9119,1,2,1,1,1,2,5,4,136.0,122.7,1,0,0,1,1,0,0,18,0,5,7,5,12.6,0,0,5,9,3,13.25,0,13.9,-0.3,0.79,0 +Student_00862,1,39,9147,1,2,12,1,19,38,9,9,133.1,120.0,1,0,1,0,1,0,0,28,0,5,5,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00863,1,44,9070,1,1,39,1,1,19,5,8,120.0,119.8,0,0,0,1,1,0,0,21,2,7,7,2,12.0,0,5,9,10,7,12.142857142857142,0,12.4,0.5,1.79,0 +Student_00864,1,39,9670,1,1,1,1,38,19,9,8,133.1,122.9,0,0,1,0,1,0,0,25,0,6,7,3,14.0,0,0,6,9,2,14.5,0,13.9,-0.3,0.79,0 +Student_00865,1,44,9085,1,1,39,1,1,1,5,4,160.0,160.0,1,1,0,0,1,0,0,19,2,6,6,6,14.0,0,1,6,11,6,NA,0,12.4,0.5,1.79,0 +Student_00866,1,1,9500,1,4,1,1,1,1,4,10,128.0,125.2,1,0,0,1,1,1,0,18,0,7,7,7,14.682857142857143,0,0,8,9,8,15.055555555555555,0,12.4,0.5,1.79,2 +Student_00867,1,39,9119,1,1,3,1,1,38,90,90,130.0,143.4,0,0,0,1,1,0,0,29,0,3,3,0,0.0,3,0,5,0,0,0.0,0,10.8,1.4,1.74,0 +Student_00868,1,39,9119,1,1,19,1,37,38,3,7,133.1,96.7,0,0,0,1,1,1,0,29,0,5,6,0,0.0,0,0,5,7,0,0.0,0,12.4,0.5,1.79,0 +Student_00869,1,18,9254,1,1,1,1,19,19,4,5,137.0,126.9,0,0,0,1,1,0,0,20,0,6,7,6,13.857142857142858,0,0,6,7,5,12.8,0,16.2,0.3,-0.92,2 +Student_00870,1,1,171,1,1,1,1,19,1,9,7,163.0,143.1,0,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_00871,1,1,9254,1,1,1,1,1,1,191,193,125.0,114.5,0,0,0,1,1,0,0,20,0,6,8,6,13.142857142857142,0,0,6,7,6,12.5,0,8.9,1.4,3.51,2 +Student_00872,2,39,NA,1,1,1,1,34,34,0,0,120.0,140.0,1,0,0,1,1,0,0,33,0,5,14,1,18.0,0,0,5,9,2,13.0,0,9.4,-0.8,-3.12,0 +Student_00873,1,42,9991,0,1,1,1,19,19,5,5,150.0,113.7,0,0,0,1,1,0,0,30,11,15,15,13,11.461538461538462,0,6,11,15,10,11.583333333333334,1,16.2,0.3,-0.92,2 +Student_00875,1,1,9003,1,1,1,1,1,19,194,194,148.0,143.5,0,0,1,1,1,0,0,18,0,6,6,5,15.0,0,0,6,8,4,14.5,0,8.9,1.4,3.51,2 +Student_00877,1,17,9070,1,1,1,1,38,19,9,NA,119.0,115.2,0,0,0,1,1,1,0,21,0,6,8,4,11.5,0,0,6,7,5,11.0,0,15.5,2.8,-4.06,0 +Student_00878,1,39,9556,1,2,1,1,19,19,4,5,130.0,100.0,0,0,0,1,1,1,0,25,0,7,7,2,10.0,0,0,7,7,0,0.0,0,15.5,2.8,-4.06,0 +Student_00879,1,1,9670,1,2,1,1,19,19,7,10,135.0,121.4,0,0,0,1,1,0,0,19,0,5,7,3,12.333333333333334,0,0,5,5,5,11.6,0,9.4,-0.8,-3.12,2 +Student_00880,1,44,9070,1,1,39,1,19,1,9,3,120.0,120.0,1,0,0,1,1,0,0,23,2,7,8,5,12.2,0,5,9,10,7,12.142857142857142,1,16.2,0.3,-0.92,0 +Student_00881,1,17,9070,1,2,1,1,38,38,9,8,126.0,129.9,1,0,0,1,1,1,0,19,0,6,6,6,13.666666666666666,0,0,6,7,5,13.2,0,12.4,0.5,1.79,2 +Student_00882,1,1,171,1,1,1,1,3,2,2,5,149.0,151.1,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_00883,1,39,9003,1,1,1,1,19,37,9,6,110.0,120.0,0,0,1,0,1,0,0,31,0,6,15,1,11.0,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_00884,1,39,9003,1,1,1,1,37,37,4,7,133.1,130.0,0,0,1,0,1,0,0,32,0,6,8,3,13.0,0,4,10,14,6,11.428571428571429,0,16.2,0.3,-0.92,0 +Student_00885,1,16,9500,1,2,1,1,2,38,4,9,127.0,119.0,1,0,0,1,0,1,0,19,0,8,12,7,12.599999999999998,0,0,8,12,7,12.599999999999998,0,10.8,1.4,1.74,2 +Student_00886,1,42,9773,1,1,6,1,34,34,0,0,120.0,122.0,1,0,0,1,NA,0,0,34,8,10,11,10,12.2,0,5,10,12,9,NA,0,7.6,2.6,0.32,2 +Student_00887,1,16,9773,1,6,1,1,38,14,0,0,136.0,129.7,1,0,0,1,0,0,0,21,0,6,6,6,13.166666666666666,0,0,6,6,6,13.0,0,7.6,2.6,0.32,2 +Student_00888,1,43,9238,1,2,1,1,37,37,9,7,110.0,112.5,1,0,0,1,0,1,0,53,4,7,16,6,11.0,0,2,7,9,7,11.0,0,9.4,-0.8,-3.12,2 +Student_00891,1,1,9773,1,2,1,1,1,19,9,9,159.0,151.3,1,0,0,1,0,0,0,18,0,6,6,6,14.0,0,0,6,6,6,14.666666666666666,0,10.8,1.4,1.74,2 +Student_00892,1,39,171,1,1,1,1,37,38,175,193,147.0,133.3,0,0,0,0,0,0,0,32,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_00894,1,7,8014,0,1,3,1,37,12,9,4,140.0,140.0,0,0,0,0,0,0,0,26,0,5,9,0,0.0,0,0,5,10,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00895,1,42,9085,1,1,39,1,1,1,4,7,150.0,150.0,1,0,0,1,0,0,0,26,11,18,45,18,11.833333333333334,10,9,13,27,13,12.461538461538462,5,15.5,2.8,-4.06,2 +Student_00896,2,44,9991,0,1,39,NA,1,37,4,9,130.0,130.0,0,0,0,0,0,0,0,21,0,5,12,3,11.333333333333334,0,0,5,10,1,13.0,0,15.5,2.8,-4.06,0 +Student_00897,1,17,9773,1,1,1,1,37,37,5,5,120.0,125.3,0,0,0,1,0,0,0,18,0,6,9,6,12.5,0,0,6,9,6,13.0,0,7.6,2.6,0.32,2 +Student_00898,1,43,9070,1,1,39,1,19,37,5,9,130.0,124.0,1,0,0,1,0,1,0,21,4,12,12,12,13.333333333333334,0,5,12,12,11,12.545454545454543,0,15.5,2.8,-4.06,2 +Student_00899,1,1,NA,1,1,1,1,38,19,9,5,112.0,113.8,1,0,0,1,0,0,0,21,0,6,10,6,10.833333333333334,0,0,6,10,4,11.0,0,7.6,2.6,0.32,1 +Student_00900,1,17,9670,1,1,1,1,19,19,7,7,128.0,124.4,0,0,0,1,0,1,0,19,0,6,6,6,13.0,0,0,6,6,6,14.0,0,13.9,-0.3,0.79,2 +Student_00901,1,17,9147,1,1,1,1,19,19,9,7,114.0,107.7,0,0,0,1,0,0,0,19,0,5,7,2,10.0,0,0,5,11,2,14.0,0,10.8,1.4,1.74,0 +Student_00902,1,43,9238,1,2,1,1,38,38,5,5,118.0,110.0,0,0,0,1,0,1,0,19,0,6,8,6,11.428571428571429,0,0,6,11,5,11.2,0,10.8,1.4,1.74,2 +Student_00903,1,7,9500,1,1,3,1,37,38,7,7,130.0,130.0,1,0,0,1,0,0,0,27,0,8,8,8,12.8875,0,0,8,8,8,12.8875,0,9.4,-0.8,-3.12,2 +Student_00904,1,1,9500,1,2,1,1,37,1,9,4,145.0,138.8,1,0,0,1,0,1,0,18,0,7,7,6,12.95,0,0,7,7,6,12.95,0,7.6,2.6,0.32,2 +Student_00906,1,1,9500,1,3,1,1,1,1,5,5,114.0,114.5,1,0,0,1,0,1,0,19,0,7,7,7,13.094285714285714,0,0,8,8,8,12.55,0,12.4,0.5,1.79,2 +Student_00908,1,17,9238,1,2,1,1,19,38,7,6,145.0,128.6,1,0,0,1,0,1,0,19,0,6,12,5,11.714285714285714,0,0,6,11,6,11.0,0,12.7,3.7,-1.7,2 +Student_00909,1,17,9238,1,5,1,1,19,1,5,5,130.0,130.0,1,0,0,1,0,0,0,20,0,6,8,4,11.25,0,0,6,15,3,10.0,0,9.4,-0.8,-3.12,1 +Student_00910,1,1,171,1,1,1,1,38,19,7,10,150.0,134.6,0,0,0,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00911,1,1,9853,1,1,1,1,37,37,9,5,145.0,146.8,0,0,0,1,0,0,0,18,0,6,6,6,13.166666666666666,0,0,6,6,6,13.333333333333334,0,7.6,2.6,0.32,2 +Student_00912,1,1,9085,1,1,1,1,19,1,5,4,128.0,135.7,1,0,0,1,0,0,0,20,0,5,7,4,12.75,0,0,5,5,5,13.4,0,10.8,1.4,1.74,2 +Student_00913,NA,39,9991,0,1,1,1,37,37,9,9,140.0,120.0,0,0,0,0,0,0,0,38,0,5,6,5,10.6,0,0,5,9,2,11.0,0,12.7,3.7,-1.7,0 +Student_00915,1,39,9500,1,1,1,1,37,37,9,6,140.0,135.5,0,0,0,1,0,0,0,32,0,7,0,0,0.0,0,0,8,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_00916,1,15,9773,1,1,1,26,19,19,4,5,120.0,120.0,1,0,0,1,0,0,1,22,0,6,6,6,13.0,0,0,6,6,6,13.666666666666666,0,12.4,0.5,1.79,2 +Student_00917,2,39,9991,0,1,NA,1,34,34,90,90,147.0,111.7,1,0,0,NA,0,0,0,28,0,5,10,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00918,2,39,8014,0,1,9,1,37,37,8,10,133.1,100.0,1,0,0,1,0,0,0,37,0,6,0,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00919,2,44,9003,1,1,39,1,37,38,9,4,160.0,160.0,0,0,0,1,0,0,0,43,0,6,8,6,14.166666666666666,0,0,6,9,6,15.0,0,15.5,2.8,-4.06,2 +Student_00921,4,39,8014,0,1,19,1,37,37,9,3,140.0,131.0,0,0,0,1,0,1,0,29,0,6,11,4,11.75,0,0,6,9,5,10.4,0,10.8,1.4,1.74,2 +Student_00922,1,39,8014,0,1,1,1,37,37,9,9,133.1,97.0,0,0,0,1,0,1,0,35,0,6,8,6,10.833333333333334,0,0,6,7,6,11.5,0,10.8,1.4,1.74,2 +Student_00923,1,17,9238,1,6,1,1,1,3,4,2,131.0,131.7,1,0,0,1,0,0,0,18,0,6,8,4,11.75,0,0,6,8,4,12.25,0,9.4,-0.8,-3.12,0 +Student_00924,1,39,9500,1,1,19,1,37,37,9,6,133.1,120.0,0,0,0,0,0,1,0,39,0,7,14,3,11.5,0,0,7,9,2,10.5,0,16.2,0.3,-0.92,0 +Student_00925,4,39,9991,0,1,1,1,37,37,9,9,120.0,110.0,0,0,0,1,0,0,0,37,0,5,14,2,10.0,0,0,5,7,3,11.333333333333334,0,12.7,3.7,-1.7,1 +Student_00926,1,39,9500,1,1,1,1,37,37,9,7,130.0,133.0,1,0,0,1,0,1,0,26,0,7,7,6,13.7,0,0,7,7,6,13.7,0,7.6,2.6,0.32,2 +Student_00927,1,7,9085,1,1,3,1,19,20,4,90,140.0,140.0,1,0,0,1,0,0,0,32,0,5,8,1,14.0,2,0,5,12,0,0.0,4,10.8,1.4,1.74,0 +Student_00928,2,39,8014,0,1,1,1,37,37,6,8,133.1,100.0,0,0,1,1,0,0,0,37,3,8,12,7,11.375,0,2,7,10,6,12.166666666666666,0,13.9,-0.3,0.79,1 +Student_00929,1,39,9085,1,1,1,1,37,19,191,163,140.0,129.3,1,0,1,1,0,0,0,28,0,6,17,0,0.0,0,0,6,6,0,0.0,0,8.9,1.4,3.51,1 +Student_00930,1,1,9238,1,1,1,1,19,37,0,0,133.1,137.0,1,0,0,1,0,0,0,19,0,6,10,0,0.0,4,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_00932,1,1,9853,1,1,1,1,19,38,9,9,115.0,108.0,0,0,0,1,0,1,0,19,0,7,10,6,13.0,0,0,7,7,7,13.285714285714286,0,12.4,0.5,1.79,2 +Student_00933,2,7,9670,1,1,3,1,37,37,7,7,110.0,110.0,0,0,0,1,0,0,0,32,4,11,15,8,13.6,0,2,8,10,8,15.11111111111111,0,13.9,-0.3,0.79,2 +Student_00934,2,39,9147,1,1,1,1,37,37,9,9,140.0,127.7,1,0,0,1,0,0,0,31,0,5,8,3,11.0,0,0,5,9,2,11.5,0,7.6,2.6,0.32,0 +Student_00935,1,39,9500,1,1,1,1,3,1,2,5,100.0,121.3,1,0,0,1,0,0,0,34,0,8,11,7,11.705714285714285,0,0,8,11,7,11.705714285714285,0,10.8,1.4,NA,1 +Student_00939,1,1,NA,1,1,1,1,19,38,4,10,145.0,131.7,1,0,0,1,0,0,0,18,0,6,7,6,12.666666666666666,0,0,6,8,4,NA,0,7.6,2.6,0.32,1 +Student_00940,4,39,8014,0,1,19,1,37,37,90,7,133.1,110.0,0,0,0,0,0,0,0,31,0,6,8,5,11.4,0,0,6,9,3,11.0,0,9.4,-0.8,-3.12,0 +Student_00941,1,1,9773,1,3,1,1,19,19,5,5,110.0,105.5,1,0,0,1,0,0,0,19,0,6,6,6,13.0,0,0,6,8,5,12.4,0,12.4,0.5,1.79,2 +Student_00944,1,7,9085,1,1,3,1,1,19,9,10,130.0,130.0,0,0,0,1,0,0,0,34,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00945,1,16,9556,1,1,1,1,37,37,9,7,137.0,122.7,1,0,0,1,NA,1,0,18,0,7,7,7,15.285714285714286,0,0,8,8,8,16.075,0,12.4,0.5,1.79,2 +Student_00946,1,17,9254,1,2,1,1,37,37,7,NA,123.0,113.9,1,0,0,1,0,0,0,18,0,6,6,6,13.166666666666666,0,0,6,6,6,12.666666666666666,0,11.1,0.6,2.02,2 +Student_00947,1,1,9147,1,1,1,1,3,19,3,3,156.0,151.1,0,0,1,1,1,0,0,19,0,5,7,5,13.6,0,0,5,11,5,12.833333333333334,5,16.2,0.3,-0.92,2 +Student_00948,1,17,9773,1,2,1,1,3,5,0,2,133.1,125.8,1,0,0,0,NA,1,0,22,0,4,8,0,0.0,0,0,4,8,0,0.0,0,7.6,2.6,0.32,0 +Student_00949,2,43,9670,1,1,1,1,34,34,0,0,100.0,128.2,0,0,0,1,1,0,0,32,6,10,12,10,11.4,0,4,9,9,4,11.5,0,7.6,2.6,0.32,2 +Student_00950,1,39,9147,1,1,1,1,37,3,9,2,140.0,135.1,0,0,0,1,1,0,0,61,0,5,0,0,0.0,0,0,5,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00951,1,39,9991,0,1,1,1,37,37,9,9,130.0,120.2,1,0,0,1,1,0,0,30,0,5,7,5,11.0,0,0,5,5,5,11.6,0,7.6,2.6,0.32,2 +Student_00953,1,44,9003,1,1,39,1,1,19,4,8,140.0,140.0,0,0,0,1,1,0,0,20,0,6,7,6,13.571428571428571,0,0,6,6,6,12.666666666666666,0,12.4,0.5,1.79,2 +Student_00954,1,18,9500,1,5,1,1,19,1,1,10,137.0,129.3,0,0,0,1,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00955,1,42,9119,1,1,1,1,3,1,2,9,120.0,108.2,1,0,0,1,1,0,0,26,4,10,14,4,11.25,0,4,11,11,4,12.0,0,7.6,2.6,0.32,0 +Student_00956,1,17,9670,1,4,1,1,1,1,4,90,125.0,125.4,1,0,0,1,1,0,0,19,0,5,6,3,13.333333333333334,0,0,5,5,1,11.0,0,7.6,2.6,0.32,0 +Student_00958,1,1,9773,1,3,1,1,38,1,9,4,115.0,116.1,1,0,0,1,1,0,0,19,0,6,6,6,12.5,0,0,6,7,5,13.0,0,12.4,0.5,1.79,2 +Student_00959,1,1,9147,1,1,1,1,1,19,5,5,150.0,137.8,1,0,0,1,1,1,0,19,0,5,6,5,13.2,0,0,5,6,5,12.666666666666666,0,16.2,0.3,-0.92,2 +Student_00960,1,1,9670,1,3,1,1,14,11,0,0,134.0,128.4,1,0,0,0,1,0,0,19,0,5,5,0,0.0,0,0,4,4,0,0.0,0,7.6,2.6,0.32,0 +Student_00962,1,43,9147,1,1,1,1,37,37,9,9,141.0,130.2,0,0,0,1,1,0,0,24,10,15,16,15,13.466666666666669,1,10,14,14,14,13.642857142857142,0,9.4,-0.8,-3.12,2 +Student_00963,1,1,9130,1,1,1,1,3,1,2,4,133.0,126.0,0,0,0,1,1,0,0,18,0,5,7,3,13.666666666666666,0,0,5,5,5,13.2,0,7.6,2.6,0.32,2 +Student_00964,1,1,9119,1,2,1,1,38,38,5,5,149.0,141.0,0,0,0,1,1,0,0,18,0,5,9,2,11.666666666666666,0,0,5,9,2,12.5,2,7.6,2.6,0.32,1 +Student_00965,1,1,9773,1,1,1,1,1,3,3,7,121.0,113.0,1,0,0,1,1,1,0,18,0,6,7,6,11.666666666666666,0,0,6,12,5,10.2,0,12.4,0.5,1.79,2 +Student_00966,1,44,9003,1,1,39,1,4,1,2,8,120.0,120.0,0,0,0,1,1,0,0,21,0,6,9,5,13.4,0,0,6,9,5,12.4,0,8.9,1.4,3.51,2 +Student_00967,2,39,9991,0,1,1,1,19,37,9,5,148.0,130.9,0,0,0,0,1,0,0,28,0,5,5,0,0.0,0,0,5,6,0,0.0,0,12.4,0.5,1.79,0 +Student_00968,1,39,9003,1,1,12,1,37,19,9,10,133.1,120.0,0,0,0,1,1,0,0,58,0,6,9,0,0.0,0,0,6,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_00969,2,39,9991,0,1,1,1,34,34,0,0,135.0,134.1,1,0,0,0,1,0,0,49,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00970,1,39,9119,1,1,1,1,1,38,3,5,150.0,120.0,0,0,0,1,1,0,0,24,0,5,6,3,10.666666666666666,0,0,5,9,2,10.5,0,15.5,2.8,-4.06,1 +Student_00971,1,43,9670,1,1,1,1,34,34,0,0,130.0,114.8,0,0,0,1,1,0,0,25,0,5,5,4,13.75,0,0,5,5,4,14.75,0,7.6,2.6,0.32,2 +Student_00972,4,42,9147,1,1,1,1,37,38,7,3,133.1,123.0,1,0,0,1,1,0,0,33,0,5,5,1,10.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00973,2,39,9119,1,2,19,1,37,37,7,7,133.1,118.0,0,0,0,0,1,0,0,33,0,5,11,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00974,2,43,9853,1,1,1,1,37,37,7,7,110.0,100.0,0,0,0,1,1,0,0,40,0,2,4,1,16.0,0,0,4,5,4,15.5,0,13.9,-0.3,0.79,2 +Student_00975,2,39,9991,0,1,1,1,37,19,9,3,170.0,151.1,0,0,0,1,1,0,0,48,0,5,9,5,12.285714285714286,0,0,5,8,5,11.125,0,16.2,0.3,-0.92,2 +Student_00977,1,39,9500,1,1,19,1,38,38,9,8,133.1,106.0,1,0,0,1,1,0,0,24,0,7,7,6,12.666666666666666,1,0,7,7,6,12.666666666666666,1,7.6,2.6,0.32,2 +Student_00978,2,1,9085,1,1,1,1,19,19,192,144,139.0,127.1,0,0,0,1,1,1,0,23,0,5,6,5,11.8,0,0,5,7,4,13.25,1,10.8,1.4,1.74,2 +Student_00979,1,39,9991,0,1,19,1,19,37,7,5,133.1,155.5,1,0,1,0,1,0,0,39,0,5,6,5,10.6,0,0,5,7,5,14.666666666666666,0,10.8,1.4,1.74,0 +Student_00980,1,18,9003,1,1,1,1,1,38,9,6,133.1,101.0,0,0,0,1,1,0,0,21,5,11,16,9,11.9,0,3,9,14,8,12.25,0,15.5,2.8,NA,2 +Student_00981,1,42,9119,1,1,6,1,35,35,6,6,120.0,128.2,1,0,0,1,1,0,0,34,4,6,8,4,11.25,0,1,5,8,2,10.5,0,7.6,2.6,0.32,0 +Student_00982,2,39,9991,0,1,1,1,19,19,4,4,100.0,113.0,0,0,0,1,1,1,0,41,0,5,9,4,11.0,0,0,5,6,5,11.4,0,8.9,1.4,3.51,1 +Student_00983,1,1,9773,1,1,1,1,NA,38,4,5,134.0,122.8,0,0,0,1,1,0,0,18,0,6,6,6,12.0,0,0,6,6,6,12.5,0,12.7,3.7,-1.7,2 +Student_00984,2,39,9991,0,1,1,1,38,38,9,3,130.0,145.6,0,0,0,1,1,0,0,34,0,5,10,4,11.75,0,0,5,10,4,10.833333333333334,0,13.9,-0.3,0.79,1 +Student_00985,1,1,9147,1,1,1,1,1,1,2,10,128.0,116.5,0,0,0,1,1,0,0,19,0,5,8,2,10.0,0,0,5,8,1,16.0,0,7.6,2.6,0.32,0 +Student_00988,1,17,9070,1,1,1,1,1,1,5,0,134.0,133.3,1,0,0,1,1,0,0,18,0,6,7,5,10.8,1,0,6,6,0,0.0,0,7.6,2.6,0.32,0 +Student_00989,1,1,9238,1,1,1,1,2,2,3,4,127.0,115.8,1,0,0,1,1,0,0,19,0,6,11,3,12.0,0,0,6,12,2,10.0,0,11.1,0.6,NA,0 +Student_00990,1,17,9085,1,2,1,1,19,38,9,1,133.1,100.0,1,0,1,0,1,0,0,19,0,6,10,5,12.5,0,0,6,19,2,13.5,0,12.4,0.5,1.79,0 +Student_00991,1,17,9500,1,1,1,1,1,3,9,2,130.0,128.6,1,0,0,1,0,0,0,18,0,7,7,7,14.728571428571428,0,0,8,11,8,16.327272727272728,0,16.2,0.3,-0.92,2 +Student_00992,1,1,9130,1,1,NA,1,3,3,2,2,135.0,137.1,1,0,0,1,0,0,0,18,0,6,8,6,12.0,0,0,6,8,5,NA,0,12.4,0.5,1.79,2 +Student_00993,1,1,9773,1,1,1,1,1,3,3,3,143.0,149.0,1,0,0,1,0,0,0,18,0,6,8,6,11.428571428571429,0,0,6,7,6,11.0,0,11.1,0.6,2.02,0 +Student_00994,1,44,9238,1,2,39,1,3,19,4,9,150.0,147.0,1,0,0,1,0,0,0,19,3,6,6,6,14.166666666666666,0,2,6,6,6,13.5,0,12.4,0.5,1.79,2 +Student_00997,1,1,9500,1,3,1,1,3,1,134,135,113.0,107.8,1,0,0,1,0,1,0,20,0,7,10,5,14.46,0,0,7,8,6,13.55,0,12.4,0.5,1.79,1 +Student_00998,1,44,9085,1,1,39,6,19,1,6,4,130.0,130.0,1,0,0,1,0,0,1,22,0,6,12,5,12.8,0,0,6,19,2,11.5,0,12.4,0.5,1.79,1 +Student_00999,1,17,9254,1,1,1,1,1,19,3,3,115.0,109.4,1,0,0,1,0,0,0,19,0,6,8,6,12.666666666666666,0,0,6,8,5,13.4,0,11.1,0.6,2.02,2 +Student_01000,1,1,9070,1,3,1,1,34,34,0,0,146.0,143.6,1,0,0,1,0,0,0,18,0,6,6,6,12.5,0,0,6,6,6,13.0,0,7.6,2.6,0.32,0 +Student_01001,1,17,9070,1,3,1,1,38,1,5,5,132.0,124.3,0,1,0,1,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01002,1,1,9670,1,5,1,1,19,38,9,9,116.0,119.5,1,0,0,0,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_01003,1,1,171,1,1,1,1,3,4,2,5,163.0,175.6,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,2 +Student_01004,1,17,9147,1,2,1,1,19,19,7,7,122.0,116.1,1,0,0,1,0,1,0,19,0,5,8,5,11.2,0,0,5,5,3,11.0,0,12.4,0.5,1.79,2 +Student_01005,1,17,9238,1,2,1,1,1,3,3,4,136.0,126.6,1,0,0,1,0,0,0,18,0,6,6,6,16.5,0,0,6,7,6,17.428571428571427,0,11.1,0.6,2.02,0 +Student_01006,1,17,9085,1,1,1,1,3,19,5,5,142.0,130.8,1,0,0,1,0,0,0,18,0,5,9,3,13.666666666666666,1,0,5,5,5,12.0,0,12.7,3.7,-1.7,2 +Student_01009,1,1,9500,1,1,1,1,19,37,5,5,165.0,142.3,0,0,0,1,0,1,0,18,0,8,8,7,14.428571428571429,0,0,8,8,7,14.428571428571429,0,12.7,3.7,-1.7,2 +Student_01011,1,1,9500,1,2,1,1,19,19,9,10,135.0,122.9,1,0,0,1,0,0,0,18,0,7,10,7,13.128,0,0,8,13,6,13.193333333333332,0,15.5,2.8,-4.06,2 +Student_01012,1,17,9500,1,1,1,1,19,1,4,3,128.0,117.2,1,0,0,1,0,0,0,20,0,7,9,6,11.605,0,0,8,10,7,12.4125,0,16.2,0.3,-0.92,2 +Student_01013,1,17,9147,1,1,1,1,1,38,4,5,139.0,152.0,0,0,0,1,0,1,0,18,0,5,5,5,14.6,0,0,5,8,5,12.0,0,12.7,3.7,-1.7,2 +Student_01014,1,1,9773,1,2,1,1,19,1,4,5,125.0,122.2,1,0,0,1,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_01016,1,17,9254,1,1,1,1,19,19,9,8,116.0,119.9,1,0,0,1,0,0,0,20,0,6,6,6,12.333333333333334,0,0,6,6,6,12.333333333333334,0,12.4,0.5,1.79,2 +Student_01017,1,17,9147,1,1,1,1,37,1,9,9,138.0,123.7,1,0,1,1,0,1,0,19,0,5,5,4,11.0,0,0,5,5,0,0.0,0,11.1,0.6,2.02,0 +Student_01018,1,51,9070,1,1,1,1,3,1,3,5,135.0,121.8,0,0,0,1,0,1,0,19,5,11,11,11,13.181818181818182,0,5,11,11,11,12.909090909090908,0,11.1,0.6,2.02,2 +Student_01021,1,1,9500,1,2,1,1,1,38,4,7,NA,124.3,1,0,0,1,0,1,0,20,0,8,8,8,12.98125,0,0,8,8,8,12.98125,0,9.4,-0.8,-3.12,2 +Student_01022,1,44,9147,1,1,39,1,19,1,4,9,117.4,117.4,1,0,0,1,0,0,0,21,4,7,10,6,11.333333333333334,0,1,5,6,5,11.2,0,11.1,0.6,2.02,2 +Student_01024,1,17,9070,1,1,1,1,38,38,9,9,116.0,123.7,0,0,0,1,0,0,0,20,0,6,6,6,14.5,0,0,6,7,6,13.5,0,11.1,0.6,2.02,2 +Student_01025,1,18,9853,1,2,1,1,38,38,191,171,111.0,105.8,1,0,0,1,0,0,0,19,0,7,7,7,13.142857142857142,0,0,7,8,7,12.857142857142858,0,8.9,1.4,3.51,2 +Student_01026,1,17,9085,1,3,1,1,1,19,4,90,128.0,124.2,0,0,0,0,0,0,0,21,0,5,8,2,11.5,0,0,5,7,2,10.5,0,7.6,2.6,0.32,0 +Student_01028,1,1,9254,1,5,1,1,19,37,9,9,131.0,123.7,0,0,0,1,0,1,0,19,0,6,8,5,11.666666666666666,0,0,6,7,5,12.2,0,8.9,1.4,3.51,2 +Student_01029,1,17,9500,1,2,1,1,19,19,9,4,135.0,129.8,1,0,0,1,0,0,0,18,0,7,8,7,13.175,0,0,8,8,8,14.875,0,13.9,-0.3,0.79,2 +Student_01031,1,1,9147,1,2,NA,1,1,19,4,3,132.0,126.4,1,0,0,1,0,1,0,18,0,5,13,3,10.6,0,0,5,12,3,10.5,0,13.9,-0.3,0.79,2 +Student_01032,1,1,9853,1,1,1,1,19,37,5,7,120.0,115.1,0,0,0,1,0,1,0,18,0,6,11,4,12.0,0,0,6,8,4,10.75,0,15.5,2.8,-4.06,1 +Student_01034,1,17,9085,1,1,1,1,1,37,9,9,129.0,118.2,1,0,0,1,0,1,0,18,0,5,7,4,13.25,0,0,5,8,5,15.571428571428571,0,10.8,1.4,1.74,2 +Student_01035,1,17,9070,1,1,1,1,38,19,7,7,136.0,121.7,1,0,0,1,0,0,0,18,0,6,6,2,NA,0,0,6,6,0,0.0,0,12.4,0.5,NA,0 +Student_01037,1,17,9238,1,1,1,1,1,38,9,7,125.0,119.8,0,0,0,1,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,NA,0 +Student_01038,1,1,9238,1,1,1,1,1,3,4,2,154.0,164.9,0,0,0,1,0,0,0,18,0,6,6,6,14.0,0,0,6,6,6,13.166666666666666,0,10.8,1.4,1.74,2 +Student_01039,1,42,9085,1,1,1,1,1,38,4,9,100.0,100.0,1,0,0,1,0,1,0,20,1,2,2,2,12.0,0,1,6,11,6,12.833333333333334,0,13.9,-0.3,0.79,2 +Student_01041,1,17,9070,1,4,1,1,1,19,4,5,126.0,120.4,1,0,0,1,0,0,0,18,0,6,8,5,11.8,0,0,6,7,5,10.4,1,16.2,0.3,-0.92,2 +Student_01042,1,18,9500,1,6,1,1,37,37,9,7,124.0,117.8,0,0,0,1,0,1,0,20,0,8,8,7,12.791428571428572,1,0,8,8,7,12.791428571428572,1,10.8,1.4,1.74,2 +Student_01043,4,43,9670,1,1,1,1,37,37,9,6,NA,110.0,0,0,0,1,0,0,0,40,4,8,8,8,11.625,0,3,7,12,5,11.2,0,9.4,-0.8,-3.12,2 +Student_01044,1,1,9500,1,6,1,1,38,38,9,9,133.0,128.8,1,0,0,1,0,1,0,18,0,7,11,6,11.994444444444444,0,0,8,11,7,12.43142857142857,0,15.5,2.8,-4.06,2 +Student_01045,1,1,9254,1,5,1,1,19,19,4,7,126.0,116.6,1,0,0,NA,0,0,0,19,0,6,9,5,11.6,0,0,6,12,5,12.2,0,13.9,-0.3,0.79,2 +Student_01046,1,7,9991,0,1,40,1,1,19,4,9,120.0,120.0,0,0,0,1,0,0,0,24,0,5,5,0,NA,0,0,5,6,0,0.0,0,12.4,0.5,1.79,0 +Student_01047,1,1,9773,1,3,1,1,3,38,2,10,175.0,157.5,1,0,0,1,0,0,0,19,0,6,8,6,13.166666666666666,0,0,6,7,6,13.166666666666666,0,10.8,1.4,1.74,0 +Student_01048,1,1,9500,1,6,1,1,2,1,4,4,141.0,136.3,1,0,0,1,0,0,0,19,0,8,8,7,14.1,0,0,8,8,7,14.1,0,10.8,1.4,1.74,2 +Student_01049,1,1,9500,1,1,1,1,1,19,9,6,133.0,121.5,1,0,0,1,0,1,0,20,0,7,8,6,12.396666666666668,0,0,8,9,7,12.94285714285714,0,11.1,0.6,2.02,2 +Student_01050,1,1,9500,1,1,1,1,38,38,5,5,143.0,133.9,0,0,0,1,0,0,0,18,0,7,7,7,15.014285714285714,0,0,8,8,8,16.0875,0,12.4,0.5,1.79,2 +Student_01051,1,1,171,1,1,1,1,1,38,4,8,141.0,136.8,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_01052,1,17,9500,1,2,NA,1,19,37,4,7,134.0,133.5,1,0,0,1,0,0,0,19,0,7,8,7,14.05,0,0,8,8,8,15.1,0,13.9,-0.3,0.79,2 +Student_01053,1,17,9500,1,3,1,1,3,3,4,5,138.0,130.0,1,0,0,1,0,0,0,18,0,7,8,7,14.85,0,0,8,8,8,15.2,0,13.9,-0.3,0.79,0 +Student_01054,1,44,9085,1,1,39,1,3,3,2,2,140.0,140.0,1,0,0,1,0,0,0,19,0,6,10,6,13.0,0,0,6,19,5,13.0,0,12.4,0.5,1.79,2 +Student_01055,1,1,9500,1,2,1,1,37,37,9,7,142.0,132.7,1,0,0,1,0,1,0,19,0,7,8,7,14.7875,0,0,8,8,8,15.8625,0,13.9,-0.3,0.79,2 +Student_01056,1,1,9500,1,1,1,1,19,19,5,7,118.0,117.8,0,0,0,1,0,1,0,19,0,7,7,7,13.7,0,0,8,9,7,14.671428571428574,0,12.4,0.5,1.79,2 +Student_01057,1,1,9500,1,2,1,1,1,37,4,4,131.0,126.1,1,0,0,1,0,1,0,19,0,7,7,7,12.495714285714286,0,0,8,9,7,12.242857142857144,0,11.1,0.6,2.02,0 +Student_01058,1,1,9500,1,1,1,1,1,38,1,7,130.0,120.0,0,0,0,1,0,0,0,19,0,7,7,6,14.566666666666668,0,0,7,7,6,14.566666666666668,0,7.6,2.6,0.32,2 +Student_01059,1,39,9670,1,1,12,1,1,19,1,5,133.1,100.0,1,0,1,0,0,0,0,25,0,5,5,5,11.2,0,0,5,5,4,11.25,0,9.4,-0.8,-3.12,0 +Student_01060,1,1,9500,1,1,1,1,19,19,4,10,130.0,116.8,0,0,0,1,0,0,0,20,0,8,8,7,12.685714285714283,0,0,8,8,7,12.685714285714283,0,12.7,3.7,-1.7,2 +Student_01062,1,1,9070,1,1,1,1,19,19,7,7,133.1,117.0,0,0,0,1,0,0,0,20,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01064,1,1,9500,1,1,1,1,19,1,4,4,149.0,134.8,0,0,0,1,0,0,0,18,0,8,8,8,14.445,0,0,8,8,8,14.445,0,9.4,-0.8,-3.12,2 +Student_01065,1,1,9853,1,1,1,1,19,1,5,10,163.0,146.6,1,0,1,1,0,0,0,18,0,6,9,5,13.6,0,0,6,10,4,11.75,0,9.4,-0.8,-3.12,1 +Student_01066,1,7,8014,0,1,40,1,19,1,5,10,130.0,130.0,1,0,1,0,0,0,0,23,7,12,12,11,14.0,0,4,10,11,8,14.625,0,13.9,-0.3,0.79,0 +Student_01067,1,1,9500,1,6,1,1,38,37,5,6,145.0,127.5,1,0,0,1,0,1,0,19,0,7,7,6,13.416666666666666,0,0,7,7,6,13.416666666666666,0,7.6,2.6,0.32,2 +Student_01068,1,1,9147,1,1,1,1,37,38,3,3,130.0,123.0,0,0,0,1,0,0,0,18,0,5,8,5,12.333333333333334,2,0,5,7,5,11.4,0,15.5,2.8,-4.06,2 +Student_01069,1,43,9500,1,1,1,1,1,19,9,8,128.0,100.0,1,0,0,1,0,0,0,20,0,7,8,7,13.1,0,0,8,8,8,14.8125,0,13.9,-0.3,0.79,2 +Student_01070,1,1,9670,1,2,1,1,19,19,9,9,111.0,114.2,1,0,0,1,0,0,0,18,0,6,9,4,13.2,0,0,6,10,5,12.8,0,12.4,0.5,1.79,2 +Student_01071,1,1,9500,1,1,1,1,1,1,4,4,140.0,123.5,1,0,0,1,0,1,0,19,0,8,8,8,14.75,0,0,8,8,8,14.75,0,9.4,-0.8,-3.12,2 +Student_01072,1,44,9238,1,1,39,1,19,19,8,8,140.0,144.3,1,0,0,NA,0,1,0,19,3,6,7,6,13.142857142857142,0,2,6,6,6,14.333333333333334,0,12.4,0.5,1.79,2 +Student_01073,1,1,9853,1,1,1,1,38,37,5,NA,145.0,142.2,0,0,0,1,0,0,0,19,0,6,9,4,12.5,0,0,6,9,5,12.5,0,9.4,-0.8,-3.12,1 +Student_01075,1,1,9238,1,1,1,1,37,37,9,5,132.0,135.9,0,0,0,1,0,0,0,18,0,6,11,5,12.4,0,0,6,7,6,13.0,0,9.4,-0.8,-3.12,2 +Student_01077,1,2,9853,1,1,1,1,19,38,9,9,120.0,122.5,0,0,0,0,0,0,0,28,11,11,11,11,11.727272727272728,0,8,8,8,8,12.0,0,15.5,2.8,-4.06,0 +Student_01079,1,43,171,1,1,1,1,3,1,2,3,116.0,117.3,1,0,1,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_01080,1,1,9500,1,2,1,1,1,37,4,9,112.0,106.8,1,0,0,1,0,1,0,19,0,7,8,6,13.533333333333331,0,0,8,9,7,13.614285714285714,0,12.4,0.5,1.79,2 +Student_01081,1,1,9070,1,1,1,1,1,19,4,0,126.0,120.1,0,1,0,1,0,1,0,20,0,6,6,6,13.166666666666666,0,0,6,6,6,12.666666666666666,0,11.1,0.6,2.02,2 +Student_01083,1,51,9070,1,1,1,1,5,1,2,10,117.0,120.0,1,0,0,1,0,0,0,21,0,6,7,5,12.2,0,0,6,7,4,12.6,0,8.9,1.4,3.51,1 +Student_01084,1,1,9853,1,1,1,NA,1,19,9,4,153.0,139.7,1,0,0,1,0,1,0,19,0,7,7,7,13.428571428571429,0,0,7,7,7,14.857142857142858,0,11.1,0.6,2.02,2 +Student_01085,1,1,9070,1,2,1,1,19,1,9,3,124.0,123.7,1,0,0,1,0,1,0,18,1,6,8,6,12.714285714285714,1,0,6,8,6,12.625,0,13.9,-0.3,0.79,2 +Student_01086,1,17,9130,1,2,1,1,3,1,2,NA,127.0,116.5,0,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01087,1,17,9670,1,1,1,1,12,38,9,5,126.0,122.2,0,0,0,1,0,1,0,19,0,6,6,6,13.666666666666666,0,0,6,9,6,13.666666666666666,0,8.9,1.4,3.51,2 +Student_01088,1,1,9773,1,1,1,1,38,19,132,103,133.1,146.0,0,0,1,1,0,0,0,20,0,6,6,5,11.0,0,0,6,6,6,13.166666666666666,0,16.2,0.3,-0.92,2 +Student_01089,1,17,9853,1,2,1,1,1,1,4,0,114.0,108.8,1,0,0,1,0,0,0,18,0,7,11,5,11.4,0,0,7,9,6,13.333333333333334,0,13.9,-0.3,0.79,1 +Student_01090,1,43,171,1,1,1,1,19,19,5,7,133.0,133.0,0,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,1 +Student_01093,1,17,9238,1,3,1,1,37,38,0,7,143.0,NA,1,0,0,1,0,0,0,18,0,6,14,5,11.0,0,0,6,6,6,11.666666666666666,0,7.6,2.6,0.32,2 +Student_01094,1,18,9773,1,4,1,1,19,19,4,4,130.0,121.3,1,0,0,1,0,0,0,20,0,6,12,5,12.0,0,0,6,8,6,11.571428571428571,0,15.5,2.8,-4.06,0 +Student_01095,1,17,9500,1,3,1,1,19,1,9,9,136.0,129.0,1,0,0,1,0,1,0,19,0,7,7,7,13.308571428571428,0,0,8,10,8,12.55,0,12.4,0.5,1.79,2 +Student_01096,1,1,9853,1,1,1,1,37,37,9,9,125.0,114.9,1,0,1,0,0,0,0,21,0,6,8,3,13.666666666666666,0,0,6,7,3,10.666666666666666,0,15.5,2.8,-4.06,0 +Student_01097,1,17,9670,1,1,3,1,12,3,5,8,110.0,106.5,1,0,1,0,0,0,0,20,0,6,6,0,0.0,0,0,6,9,0,0.0,0,10.8,1.4,1.74,0 +Student_01098,1,1,9254,1,1,1,1,37,38,9,9,130.0,133.9,1,0,0,1,0,0,0,18,0,6,10,5,12.2,0,0,6,8,4,11.25,0,9.4,-0.8,-3.12,2 +Student_01099,1,1,9773,1,1,1,1,1,4,5,3,135.0,124.9,0,0,0,1,0,1,0,20,0,6,7,6,12.666666666666666,0,0,6,6,6,12.833333333333334,0,10.8,1.4,1.74,2 +Student_01100,1,1,9500,1,2,1,1,19,37,1,9,133.0,128.5,1,0,0,1,0,1,0,19,0,8,8,8,14.07125,0,0,8,8,8,14.07125,0,9.4,-0.8,-3.12,2 +Student_01101,1,1,9085,1,1,6,1,19,19,9,NA,122.0,126.2,1,0,0,1,0,0,0,22,0,5,14,4,14.25,3,0,5,9,5,13.2,4,9.4,-0.8,-3.12,0 +Student_01102,1,17,9130,1,1,1,1,19,19,9,9,122.0,121.7,1,0,0,0,0,0,0,22,0,6,0,0,0.0,0,0,2,2,0,0.0,2,9.4,-0.8,-3.12,0 +Student_01104,1,43,9147,1,1,1,1,3,19,9,9,123.0,113.2,0,0,0,1,0,0,0,21,3,10,18,6,11.166666666666666,2,4,10,16,7,10.571428571428571,0,7.6,2.6,0.32,1 +Student_01106,1,1,171,1,4,1,1,37,38,9,9,139.0,127.8,1,0,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01107,1,1,9500,1,2,1,1,34,34,0,0,124.0,123.3,1,0,0,1,0,1,0,20,0,8,8,7,14.901428571428571,1,0,8,8,7,14.901428571428571,1,9.4,-0.8,-3.12,0 +Student_01109,1,51,9991,0,1,42,1,19,37,5,9,110.0,128.2,0,0,0,0,0,0,0,22,7,12,12,7,11.0,0,5,5,5,5,10.6,0,8.9,1.4,3.51,0 +Student_01110,1,17,9085,1,4,1,1,19,36,90,7,138.0,134.9,1,0,0,1,0,0,0,20,0,5,7,4,12.4,0,0,5,9,5,12.666666666666666,0,7.6,2.6,0.32,2 +Student_01111,1,44,9003,1,1,39,1,38,38,6,6,140.0,140.0,0,0,0,1,0,0,0,19,0,6,7,6,12.0,0,0,6,7,6,12.666666666666666,0,12.4,0.5,1.79,2 +Student_01112,1,1,9500,1,5,1,1,1,19,6,7,126.0,115.5,1,0,0,1,0,1,0,19,0,7,8,7,NA,0,0,8,10,7,13.328571428571427,0,12.4,0.5,1.79,2 +Student_01113,1,1,9500,1,2,1,1,38,19,9,7,113.0,106.7,1,0,0,1,0,1,0,20,0,7,10,5,12.62,0,0,7,8,6,12.5,0,11.1,0.6,2.02,1 +Student_01114,1,39,9991,0,1,1,1,38,38,3,3,120.0,140.0,0,0,0,1,0,0,0,25,0,5,11,3,10.666666666666666,0,0,5,11,3,11.333333333333334,0,15.5,2.8,-4.06,1 +Student_01115,1,1,9500,1,1,1,1,19,19,9,7,145.0,136.6,0,0,0,1,0,1,0,19,0,7,12,6,13.766666666666666,0,0,8,10,7,14.051428571428572,0,15.5,2.8,-4.06,2 +Student_01116,1,18,9500,1,1,1,1,38,37,9,7,124.0,119.3,1,0,0,1,0,0,0,19,0,8,8,8,13.11625,0,0,8,8,8,13.11625,0,9.4,-0.8,-3.12,2 +Student_01117,1,1,9070,1,1,1,1,3,38,1,9,160.0,152.0,1,0,0,0,0,0,0,19,0,5,5,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01119,1,39,9556,1,2,1,1,37,37,9,9,130.0,159.0,1,0,0,1,0,0,0,25,0,7,11,7,11.857142857142858,0,0,8,21,5,11.7,0,12.4,0.5,1.79,1 +Student_01120,1,17,9500,1,1,1,1,19,38,5,9,127.0,129.5,1,0,0,1,0,1,0,20,0,7,7,6,12.333333333333334,0,0,7,7,6,12.333333333333334,0,7.6,2.6,0.32,2 +Student_01121,1,39,9238,1,1,1,1,38,19,9,9,170.0,140.0,1,0,0,1,0,0,0,24,0,6,9,4,15.75,0,0,6,10,5,16.4,0,9.4,-0.8,-3.12,1 +Student_01122,1,1,9670,1,3,1,1,1,1,5,5,111.0,105.4,0,0,0,1,0,0,0,20,0,5,6,5,13.333333333333334,0,0,5,6,5,13.2,0,7.6,2.6,0.32,2 +Student_01126,1,1,9670,1,2,1,1,37,38,9,9,144.0,126.9,0,0,0,1,0,1,0,21,0,5,5,5,13.2,0,0,5,5,4,13.0,0,9.4,-0.8,-3.12,2 +Student_01127,1,39,9500,1,1,3,1,3,37,2,10,133.8,184.0,0,0,0,1,0,0,0,28,0,7,9,7,17.005555555555556,0,1,8,9,8,16.582222222222224,0,15.5,2.8,-4.06,2 +Student_01128,1,1,9238,1,1,1,1,37,38,9,9,125.0,125.0,1,0,1,0,0,1,0,19,0,6,8,5,10.6,0,0,6,8,5,11.0,0,10.8,1.4,1.74,2 +Student_01129,1,1,9147,1,1,1,1,37,37,9,6,150.0,138.5,0,0,0,1,0,1,0,18,0,5,5,5,14.0,0,0,5,6,5,13.6,0,12.4,0.5,1.79,2 +Student_01130,5,17,9500,1,5,1,1,37,38,5,8,143.0,133.5,1,0,0,1,0,1,0,18,0,8,8,7,12.114285714285714,0,0,8,8,7,12.114285714285714,0,12.7,3.7,-1.7,2 +Student_01131,1,1,9500,1,3,1,1,19,37,7,7,145.0,141.5,1,0,0,1,0,1,0,18,0,8,8,8,13.05875,0,0,8,8,8,13.05875,0,9.4,-0.8,-3.12,2 +Student_01133,1,1,9147,1,1,1,1,37,37,194,171,138.0,131.0,1,0,0,1,0,0,0,19,0,5,9,4,11.0,0,0,5,8,3,10.666666666666666,0,12.4,0.5,1.79,1 +Student_01134,1,1,NA,1,1,1,1,19,1,9,5,145.0,145.0,0,0,0,1,0,1,0,NA,0,7,7,7,14.071428571428571,0,0,8,8,8,15.1625,0,13.9,-0.3,0.79,2 +Student_01135,1,17,9254,1,1,1,1,37,37,5,6,122.0,114.3,0,0,0,0,0,0,0,20,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01136,1,44,171,1,1,39,1,37,37,5,6,110.0,108.3,0,0,0,0,0,0,0,26,4,9,9,4,11.25,0,3,10,12,3,11.0,0,12.4,0.5,1.79,0 +Student_01137,1,1,9070,1,3,1,1,37,38,9,9,136.0,125.2,1,0,0,1,0,1,0,18,0,6,6,6,14.0,0,0,6,8,6,13.625,0,10.8,1.4,1.74,2 +Student_01138,1,1,9254,1,1,1,1,1,38,4,9,145.0,131.7,1,0,0,1,0,1,0,21,0,6,8,6,12.166666666666666,0,0,6,11,3,11.666666666666666,0,10.8,1.4,1.74,0 +Student_01141,1,1,9500,1,6,1,1,38,19,5,6,130.0,125.1,1,0,0,1,0,0,0,18,0,7,11,7,13.37,0,0,8,13,7,12.833333333333334,0,15.5,2.8,-4.06,2 +Student_01143,1,1,9670,1,1,1,1,1,1,2,2,128.0,130.8,1,0,0,1,0,0,0,20,0,5,5,4,15.0,0,0,5,5,4,13.75,0,7.6,2.6,0.32,0 +Student_01144,NA,NA,9853,1,1,1,1,19,19,9,5,152.0,154.1,0,0,1,1,0,1,0,18,0,6,6,6,13.333333333333334,0,0,6,7,6,12.571428571428571,0,12.7,3.7,-1.7,2 +Student_01145,1,16,9147,1,2,1,1,37,37,9,9,132.0,122.6,1,0,0,1,0,1,0,20,0,5,8,3,12.0,0,0,5,9,4,12.625,0,10.8,1.4,1.74,1 +Student_01146,1,1,8014,0,2,1,1,19,11,0,0,107.0,103.5,1,0,0,1,0,0,0,22,0,6,7,5,13.4,0,0,6,9,5,12.2,0,7.6,2.6,0.32,2 +Student_01147,1,1,171,1,1,1,1,19,38,4,5,131.0,132.8,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,1 +Student_01148,1,51,9991,0,1,1,1,19,38,5,7,141.0,100.0,0,0,0,1,0,0,0,21,1,5,9,4,11.5,0,1,5,5,5,11.4,0,8.9,1.4,3.51,2 +Student_01149,1,18,9853,1,2,1,NA,1,1,9,0,120.0,115.8,0,0,0,1,0,0,0,18,0,7,12,6,12.0,0,0,7,11,6,12.166666666666666,0,13.9,-0.3,0.79,1 +Student_01150,1,1,9500,1,1,1,1,19,19,4,4,148.0,133.8,0,0,0,1,0,0,0,18,0,8,8,7,13.485714285714284,0,0,8,8,7,13.485714285714284,0,12.7,3.7,-1.7,2 +Student_01152,1,17,171,1,1,1,1,37,37,9,1,145.0,150.3,1,0,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01154,1,1,9500,1,1,1,1,38,1,9,4,138.0,127.5,1,0,0,1,0,0,0,19,0,7,10,5,12.94,0,0,7,7,5,13.76,0,16.2,0.3,-0.92,1 +Student_01155,1,1,9500,1,3,1,1,1,37,7,7,135.0,120.5,1,0,0,1,0,0,0,19,0,8,11,7,13.258571428571427,0,0,8,11,7,13.258571428571427,0,10.8,1.4,1.74,2 +Student_01156,1,1,9147,1,1,1,1,1,2,10,10,118.0,117.3,1,0,0,1,0,0,0,19,0,5,9,4,12.25,0,0,5,10,4,12.0,0,8.9,1.4,3.51,1 +Student_01157,1,17,9254,1,1,1,1,38,37,9,7,123.0,120.6,1,0,0,0,0,0,0,19,0,6,9,3,11.666666666666666,0,0,6,15,1,10.0,0,10.8,1.4,1.74,0 +Student_01159,1,1,9773,1,2,1,41,1,37,9,7,150.0,130.8,0,0,0,1,0,1,1,20,0,6,9,5,11.8,0,0,6,9,5,11.833333333333334,0,15.5,2.8,-4.06,2 +Student_01160,1,1,9147,1,1,1,1,19,19,3,9,121.0,112.6,1,0,0,1,0,1,0,20,0,5,7,5,14.2,0,0,5,7,5,13.285714285714286,0,11.1,0.6,2.02,2 +Student_01161,1,39,9991,0,1,19,1,37,37,9,9,133.1,117.2,0,0,0,1,0,0,0,41,0,5,8,5,11.0,0,0,5,6,5,11.8,1,7.6,2.6,0.32,2 +Student_01162,4,7,9500,1,1,40,1,37,37,3,3,130.0,130.0,1,0,0,1,0,0,0,32,0,7,16,4,13.625,0,0,7,8,7,12.6375,0,12.4,0.5,1.79,1 +Student_01164,4,39,8014,0,1,1,1,37,37,3,4,160.0,97.0,0,0,0,1,0,1,0,35,0,6,9,6,11.333333333333334,0,0,6,6,6,11.333333333333334,0,15.5,2.8,-4.06,2 +Student_01165,1,39,9500,1,1,1,1,37,37,9,9,110.0,130.0,0,0,1,0,0,0,0,32,0,7,12,4,13.7,0,0,7,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_01166,1,39,8014,0,1,40,1,19,37,5,9,140.0,148.0,0,0,0,1,0,0,0,37,7,11,11,11,13.727272727272728,0,4,8,8,8,14.75,0,12.4,0.5,1.79,2 +Student_01167,2,39,9147,1,2,3,1,3,37,9,9,130.0,103.4,0,0,0,1,0,0,0,30,4,7,9,7,11.75,0,3,8,12,7,11.142857142857142,0,12.7,3.7,-1.7,0 +Student_01169,1,17,9773,1,2,1,1,3,1,2,7,139.0,124.0,1,0,0,1,0,1,0,20,0,6,6,6,14.0,0,0,6,7,6,13.857142857142858,0,15.5,2.8,-4.06,0 +Student_01170,1,1,9670,1,1,1,1,19,37,5,7,135.0,121.4,0,0,0,1,1,0,0,21,0,5,7,4,11.5,0,0,5,6,4,11.75,0,9.4,-0.8,-3.12,2 +Student_01171,1,NA,9147,1,1,1,1,38,19,5,7,117.0,118.1,0,0,0,1,1,0,0,19,0,5,6,5,11.2,0,0,5,5,5,13.2,0,12.4,0.5,1.79,2 +Student_01172,1,17,9500,1,4,1,1,1,19,4,3,137.0,121.3,1,0,0,1,1,1,0,18,0,8,8,7,15.07,0,0,8,8,7,15.07,0,10.8,1.4,1.74,2 +Student_01173,1,42,9119,1,1,1,1,34,34,0,0,144.0,119.5,0,0,0,1,1,0,0,18,0,5,6,1,10.0,0,0,5,7,1,12.0,0,10.8,1.4,1.74,0 +Student_01174,1,39,9991,0,1,1,1,1,1,4,10,130.0,115.2,0,0,0,1,1,0,0,24,0,5,5,4,12.0,0,0,5,6,5,12.666666666666666,0,12.4,0.5,1.79,1 +Student_01175,1,18,9670,1,1,1,1,1,37,9,9,140.0,130.2,1,0,0,1,1,0,0,22,0,6,11,4,13.0,0,0,6,11,4,12.6,0,12.7,3.7,-1.7,2 +Student_01176,1,17,9254,1,4,1,1,19,1,5,5,130.0,130.0,1,0,0,1,1,0,0,18,0,6,7,4,11.0,0,0,6,7,3,11.25,0,16.2,0.3,-0.92,0 +Student_01177,1,16,9238,1,2,1,1,37,37,5,6,130.0,126.9,1,0,0,1,0,0,0,18,0,6,8,6,13.571428571428571,0,0,6,11,5,12.166666666666666,0,9.4,-0.8,-3.12,2 +Student_01180,1,18,9556,1,1,1,1,38,37,9,9,140.0,122.8,0,0,0,1,0,1,0,19,0,7,11,7,12.625,0,0,8,11,8,12.5125,0,12.7,3.7,-1.7,2 +Student_01181,6,39,9500,1,1,1,1,37,37,9,9,133.1,110.0,0,0,0,1,0,0,0,36,0,7,12,4,11.5,0,0,7,14,3,12.333333333333334,0,16.2,0.3,-0.92,0 +Student_01182,1,16,9085,1,1,1,1,1,1,9,9,140.0,127.1,1,0,0,1,0,0,0,18,0,5,8,4,13.25,1,0,5,10,4,10.5,0,12.7,3.7,-1.7,2 +Student_01183,1,1,9500,1,3,1,1,19,19,5,5,133.1,108.5,1,0,0,1,0,0,0,19,0,7,9,7,12.60625,0,0,8,12,6,11.9,0,12.4,0.5,1.79,2 +Student_01185,1,1,9500,1,2,1,1,19,38,192,192,133.1,96.0,1,0,0,1,0,0,0,19,0,7,10,6,13.598333333333334,0,0,8,11,6,11.933333333333332,0,11.1,0.6,2.02,1 +Student_01186,1,1,9238,1,1,1,1,19,19,9,9,135.0,124.5,0,0,0,1,0,1,0,18,0,6,11,5,11.142857142857142,0,0,6,8,6,12.285714285714286,0,16.2,0.3,-0.92,2 +Student_01187,2,7,9500,1,1,3,1,37,19,9,7,120.0,120.0,1,0,0,1,0,0,0,45,7,11,11,11,12.7,0,6,10,12,10,12.96818181818182,0,13.9,-0.3,0.79,1 +Student_01188,1,17,9147,1,1,1,1,37,37,9,7,140.0,132.3,1,0,0,1,0,0,0,20,0,5,9,1,10.0,0,0,5,10,1,11.0,0,7.6,2.6,0.32,0 +Student_01189,1,17,9254,1,1,1,1,19,1,5,7,128.0,120.7,1,0,1,1,0,0,0,18,0,6,8,6,11.666666666666666,0,0,6,10,4,11.5,0,13.9,-0.3,0.79,2 +Student_01190,1,1,9670,1,1,1,1,1,19,4,4,141.0,132.6,0,0,0,1,0,1,0,18,0,6,8,6,14.0,0,0,6,7,6,13.142857142857142,0,11.1,0.6,2.02,2 +Student_01191,1,7,9130,1,2,3,1,34,34,0,0,140.0,140.0,0,0,0,1,0,0,0,25,0,5,9,0,0.0,4,0,5,9,0,0.0,3,10.8,1.4,1.74,0 +Student_01192,1,1,9500,1,6,1,1,1,1,4,4,139.0,124.5,1,0,0,1,0,0,0,19,0,8,9,7,12.04142857142857,0,0,8,9,7,12.04142857142857,0,10.8,1.4,1.74,2 +Student_01193,1,1,171,1,1,1,1,19,19,7,7,142.0,142.0,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_01194,1,7,9254,1,1,40,1,1,1,3,6,130.0,130.0,0,0,0,1,0,0,0,39,12,13,14,13,13.76923076923077,0,9,12,16,12,14.583333333333334,0,13.9,-0.3,0.79,2 +Student_01195,2,39,9003,1,1,1,1,38,37,9,9,130.0,144.0,0,0,0,1,0,0,0,29,13,18,20,18,15.444444444444445,0,11,13,13,13,15.307692307692308,0,15.5,2.8,-4.06,2 +Student_01196,1,17,9853,1,1,1,1,19,19,4,7,125.0,128.5,1,0,0,1,0,0,0,18,0,7,9,6,11.5,0,0,7,8,7,12.714285714285714,0,13.9,-0.3,0.79,1 +Student_01197,1,7,9070,1,1,3,1,37,2,9,3,140.0,140.0,0,0,0,0,0,0,0,23,0,3,3,2,10.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01198,1,42,9853,1,1,1,1,1,37,5,5,120.0,113.9,1,0,0,1,0,0,0,21,0,6,8,4,12.25,0,0,6,13,3,10.333333333333334,0,12.7,3.7,-1.7,0 +Student_01199,1,1,9238,1,1,1,1,1,19,4,4,147.0,137.2,0,0,0,0,0,0,0,18,0,6,6,6,14.5,0,0,6,6,6,15.166666666666666,0,10.8,1.4,1.74,2 +Student_01200,1,7,9085,1,1,40,1,1,19,5,5,140.0,140.0,1,0,0,1,0,0,0,23,0,6,7,6,15.571428571428571,0,0,6,8,6,16.375,0,12.4,0.5,1.79,2 +Student_01201,1,1,9130,1,1,1,1,1,19,4,4,161.0,152.3,0,0,0,1,0,0,0,18,0,6,7,6,15.571428571428571,0,0,6,7,6,14.714285714285714,0,11.1,0.6,2.02,2 +Student_01202,2,39,8014,0,1,19,1,37,37,4,8,133.1,112.5,0,0,0,1,0,0,0,32,0,6,8,5,13.8,0,0,6,7,6,12.166666666666666,0,9.4,-0.8,-3.12,2 +Student_01203,2,39,9147,1,2,1,1,19,37,9,7,150.0,101.0,0,0,1,0,0,0,0,29,0,5,8,3,10.666666666666666,0,0,5,14,2,14.8,0,10.8,1.4,1.74,0 +Student_01204,1,1,9238,1,6,1,1,1,38,194,163,113.0,112.3,1,0,1,1,0,1,0,20,0,6,8,5,11.6,0,0,6,8,4,11.75,0,8.9,1.4,3.51,2 +Student_01205,1,39,9238,1,1,1,1,34,34,0,0,140.0,114.0,1,0,0,0,0,0,0,28,0,6,11,1,13.0,0,0,6,12,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01206,1,7,9147,1,1,3,1,38,38,1,9,130.0,130.0,0,0,0,1,0,0,0,27,0,5,9,3,12.0,0,0,5,11,4,13.625,0,10.8,1.4,1.74,2 +Student_01207,1,43,9500,1,2,1,1,37,34,90,0,120.0,121.5,0,0,1,1,0,0,0,22,11,14,14,12,12.333333333333334,2,11,14,14,12,12.333333333333334,2,7.6,2.6,0.32,2 +Student_01208,2,39,9003,1,1,19,1,19,37,9,10,133.1,NA,0,0,1,1,0,0,0,37,0,6,10,6,12.875,0,0,6,12,6,12.9,0,16.2,0.3,-0.92,1 +Student_01210,2,39,9003,1,1,1,1,37,37,9,9,120.0,125.7,0,0,1,0,0,0,0,43,0,6,10,4,12.25,0,0,6,13,4,10.5,0,8.9,1.4,3.51,0 +Student_01211,1,43,9556,1,1,1,1,37,37,9,9,140.0,128.0,1,0,0,0,0,0,0,32,0,7,7,0,0.0,7,0,8,8,0,0.0,7,10.8,1.4,1.74,0 +Student_01213,4,39,9500,1,1,19,1,38,1,9,4,133.1,120.0,0,0,0,1,0,1,0,35,0,8,9,8,13.63,1,0,8,9,8,13.63,1,9.4,-0.8,-3.12,2 +Student_01214,1,1,9670,1,1,1,1,37,37,0,0,130.0,117.8,1,0,0,NA,0,0,0,21,0,5,8,3,13.0,0,0,5,7,4,11.5,1,7.6,2.6,0.32,2 +Student_01216,1,1,9500,1,1,1,1,3,38,3,7,176.0,169.7,0,0,0,1,0,1,0,18,0,7,7,7,16.9,0,0,8,9,8,16.37777777777778,0,16.2,0.3,-0.92,2 +Student_01221,1,1,171,1,2,1,1,39,1,3,4,136.0,134.3,1,0,1,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,0 +Student_01222,1,1,9500,1,1,1,1,19,1,9,5,132.0,123.4,0,0,0,NA,0,1,0,18,0,7,7,7,14.604285714285712,0,0,8,9,8,15.68333333333333,0,11.1,0.6,2.02,2 +Student_01225,1,1,9500,1,3,1,1,19,38,7,7,137.0,126.5,1,0,0,1,0,1,0,19,0,8,8,8,13.57625,0,0,8,8,8,13.57625,0,9.4,-0.8,-3.12,2 +Student_01226,1,17,9238,1,1,1,1,38,38,7,7,153.0,159.7,1,0,0,1,0,1,0,18,0,6,7,6,15.142857142857142,0,0,6,6,6,15.833333333333334,0,12.7,3.7,-1.7,2 +Student_01227,1,1,9147,1,1,1,1,9,19,4,3,160.0,151.3,0,0,0,1,0,0,0,23,0,5,8,3,10.666666666666666,0,0,5,8,5,11.6,0,7.6,2.6,0.32,2 +Student_01228,1,17,9238,1,1,1,1,38,38,5,7,145.0,138.0,1,0,0,1,0,0,0,20,0,6,11,5,11.2,0,0,6,6,6,12.0,0,9.4,-0.8,-3.12,2 +Student_01229,1,1,9500,1,5,1,1,38,38,4,8,137.0,126.5,1,0,0,1,0,0,0,18,0,8,8,8,13.76375,0,0,8,8,8,13.76375,0,9.4,-0.8,-3.12,2 +Student_01230,1,53,9085,1,1,42,1,1,1,4,3,140.0,140.0,1,0,1,1,0,0,0,21,7,9,10,8,13.25,0,4,9,14,5,12.2,0,8.9,1.4,3.51,1 +Student_01231,1,1,9238,1,1,1,1,19,38,5,6,120.0,112.3,0,0,0,1,0,1,0,22,0,6,10,5,10.714285714285714,0,0,6,10,5,12.2,0,12.7,3.7,-1.7,2 +Student_01232,1,1,9238,1,1,1,1,1,19,4,4,122.0,127.3,1,0,1,1,0,0,0,20,0,6,6,6,12.166666666666666,0,0,6,7,6,11.666666666666666,0,9.4,-0.8,-3.12,2 +Student_01233,1,7,9500,1,1,3,1,19,38,4,10,130.0,130.0,1,0,0,1,0,0,0,23,1,7,8,6,14.357142857142858,0,1,7,8,6,14.357142857142858,0,7.6,2.6,0.32,2 +Student_01234,1,17,9773,1,2,1,1,3,1,4,5,133.1,115.0,1,0,0,1,0,0,0,19,0,6,6,6,12.833333333333334,0,0,6,6,6,12.666666666666666,0,16.2,0.3,-0.92,2 +Student_01235,1,17,9500,1,6,1,1,1,37,1,1,150.0,131.5,1,0,0,1,0,0,0,19,0,8,8,7,13.925714285714283,0,0,8,8,7,13.925714285714283,0,10.8,1.4,1.74,2 +Student_01236,1,39,9991,0,1,1,1,19,38,7,4,133.1,125.7,0,0,0,1,0,0,0,NA,0,5,9,2,12.0,0,0,5,9,3,11.0,0,10.8,1.4,1.74,0 +Student_01237,1,1,9500,1,6,1,1,1,37,4,3,141.0,126.8,1,0,0,1,0,0,0,18,0,7,7,7,13.44285714285714,0,0,8,9,8,13.744444444444444,0,16.2,0.3,-0.92,2 +Student_01238,1,18,9119,1,1,1,1,1,37,7,7,146.0,132.4,1,0,0,1,1,0,0,18,0,5,5,1,16.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01239,1,44,9003,1,1,39,1,38,37,9,9,150.0,150.0,1,0,0,1,1,0,0,20,0,6,8,6,13.125,0,0,6,10,6,13.2,0,16.2,0.3,-0.92,2 +Student_01240,1,1,9670,1,1,1,1,3,1,4,4,133.1,95.0,0,0,0,1,1,0,0,19,0,6,7,0,0.0,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_01241,1,43,9991,0,1,1,1,37,37,9,9,120.0,128.2,0,0,0,0,1,0,0,32,5,9,9,5,11.4,0,4,4,4,4,11.0,0,10.8,1.4,1.74,0 +Student_01242,2,39,9130,1,1,1,1,19,19,4,4,150.0,130.0,0,0,0,0,1,0,0,31,0,4,12,2,11.0,2,0,5,9,3,11.666666666666666,0,9.4,-0.8,-3.12,0 +Student_01243,1,39,9119,1,1,19,1,1,19,4,5,133.1,100.0,0,0,0,1,1,0,0,25,0,5,13,1,11.0,0,0,5,11,1,10.0,0,13.9,-0.3,0.79,1 +Student_01245,2,43,9991,0,1,1,1,37,37,4,9,140.0,100.0,0,0,0,0,0,0,0,31,2,6,10,4,11.75,0,0,5,6,1,10.0,0,12.7,3.7,-1.7,0 +Student_01247,1,1,9238,1,1,1,1,19,19,9,9,128.0,120.0,0,0,0,1,0,1,0,18,0,6,8,6,13.5,0,0,6,9,6,12.833333333333334,0,11.1,0.6,2.02,2 +Student_01248,1,1,9238,1,3,1,1,19,19,9,9,117.0,117.0,1,0,1,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_01249,1,53,9670,1,1,42,1,19,37,3,6,140.0,140.0,1,0,1,1,0,0,0,21,0,6,12,1,NA,0,0,6,11,1,11.0,0,8.9,1.4,3.51,1 +Student_01250,1,1,9853,1,2,1,1,38,37,5,3,124.0,118.1,1,0,0,0,0,0,0,18,0,6,11,3,13.0,0,0,6,10,5,11.8,0,9.4,-0.8,-3.12,0 +Student_01251,1,1,9254,1,1,1,1,19,39,4,8,158.0,153.5,1,0,0,1,0,0,0,20,0,6,7,6,14.833333333333334,0,0,6,6,6,16.0,0,11.1,0.6,2.02,2 +Student_01252,1,43,9773,1,1,1,1,38,37,9,5,137.0,127.9,1,0,0,1,0,0,0,NA,0,6,6,6,11.833333333333334,0,0,6,7,6,12.857142857142858,0,15.5,2.8,-4.06,2 +Student_01253,1,17,NA,1,3,1,1,38,38,7,8,123.0,118.8,1,1,0,1,0,1,0,18,0,6,10,5,12.0,0,0,6,11,5,12.333333333333334,0,11.1,0.6,2.02,2 +Student_01254,1,1,9238,1,1,1,1,38,38,7,8,126.0,126.7,1,0,0,1,0,0,0,19,0,6,11,4,12.75,0,0,6,7,6,NA,0,7.6,2.6,0.32,2 +Student_01255,1,43,9085,1,1,1,1,19,19,5,1,170.0,170.0,1,0,0,1,0,0,0,19,0,5,5,0,0.0,5,0,5,7,4,14.75,1,12.7,3.7,-1.7,1 +Student_01256,4,39,9130,1,1,1,1,3,1,5,5,133.1,110.0,1,0,0,1,0,1,0,30,0,6,7,0,0.0,0,0,6,16,1,10.0,0,11.1,0.6,2.02,0 +Student_01257,1,17,9238,1,1,1,1,19,38,5,5,115.0,115.0,1,0,0,1,0,0,0,19,0,6,6,6,12.0,0,0,6,7,6,12.857142857142858,0,11.1,0.6,2.02,2 +Student_01258,1,1,9556,1,3,1,1,38,37,7,7,132.0,119.0,1,0,0,1,0,0,0,19,0,7,9,7,11.677777777777775,0,0,8,8,8,13.8,0,12.7,3.7,-1.7,2 +Student_01259,1,1,9500,1,4,1,1,1,37,4,7,132.0,121.8,1,0,0,1,0,1,0,19,0,8,8,7,13.6,0,0,8,8,7,13.6,0,12.7,3.7,-1.7,2 +Student_01260,1,1,9085,1,1,1,1,19,38,9,9,143.0,133.4,1,0,0,1,0,0,0,19,0,6,7,6,16.0,0,0,6,8,6,15.875,0,12.4,0.5,1.79,2 +Student_01261,1,1,9238,1,3,1,1,1,1,3,3,137.0,131.4,1,0,0,1,0,0,0,20,0,6,9,5,11.8,0,0,6,7,6,11.5,0,7.6,2.6,0.32,2 +Student_01263,1,1,9773,1,2,1,1,19,19,9,9,121.0,122.8,0,0,0,1,1,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_01264,2,39,9853,1,1,1,1,37,19,7,3,130.0,140.0,0,0,1,1,0,1,0,34,0,6,7,6,16.142857142857142,0,0,6,10,6,16.2,0,9.4,-0.8,-3.12,2 +Student_01265,1,18,9500,1,2,1,1,38,37,9,5,135.0,125.3,1,0,0,1,0,1,0,18,0,8,8,7,11.785714285714286,0,0,8,8,7,11.785714285714286,0,12.7,3.7,-1.7,2 +Student_01266,1,1,9500,1,6,1,1,1,1,4,5,137.0,126.3,1,0,0,1,0,1,0,18,0,8,8,8,13.42375,0,0,8,8,8,13.42375,0,9.4,-0.8,-3.12,2 +Student_01267,1,1,9670,1,1,1,1,38,38,9,10,100.0,100.0,0,0,0,NA,0,0,0,20,0,6,8,6,12.5,0,0,6,10,5,14.166666666666666,0,11.1,0.6,2.02,2 +Student_01268,1,17,9500,1,2,1,1,19,37,9,7,127.0,121.3,1,0,0,1,0,1,0,20,0,8,8,7,12.464285714285714,0,0,8,8,7,12.464285714285714,0,10.8,1.4,1.74,2 +Student_01269,1,53,9991,0,1,1,1,NA,38,191,193,140.0,135.0,0,0,1,1,0,0,0,23,6,11,18,8,12.375,0,3,9,15,5,12.6,0,8.9,1.4,3.51,1 +Student_01270,1,39,9670,1,1,1,1,37,37,6,6,140.0,120.0,0,0,0,1,0,0,0,28,0,6,8,1,10.0,0,0,6,9,0,0.0,0,10.8,1.4,1.74,0 +Student_01271,1,17,9773,1,1,1,1,37,19,9,10,121.0,113.7,0,0,0,1,0,0,0,18,0,6,8,5,12.6,0,0,6,10,6,12.428571428571429,0,15.5,2.8,-4.06,1 +Student_01272,1,43,9147,1,1,1,1,19,38,9,9,131.0,129.7,1,0,0,1,0,0,0,19,0,5,5,5,12.6,0,0,5,6,4,12.4,0,16.2,0.3,-0.92,2 +Student_01273,2,1,9147,1,1,1,1,38,37,9,8,151.0,132.1,1,0,0,1,0,0,0,34,0,5,7,2,10.0,0,0,5,6,4,12.0,0,7.6,2.6,0.32,0 +Student_01274,NA,51,9853,1,1,1,1,37,37,7,NA,130.0,120.3,0,0,0,1,0,0,0,35,0,7,7,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_01275,1,7,9991,0,1,40,1,37,37,9,7,120.0,120.0,0,0,0,1,0,0,0,32,0,5,7,5,11.6,0,0,5,8,5,12.333333333333334,0,12.4,0.5,1.79,2 +Student_01276,1,17,9254,1,2,1,1,19,19,4,7,136.0,123.1,1,0,0,1,0,0,0,19,0,6,8,6,12.166666666666666,0,0,6,6,6,13.5,0,11.1,0.6,2.02,2 +Student_01277,1,17,9670,1,5,1,1,1,19,9,7,125.0,119.4,1,0,0,1,0,0,0,18,0,6,10,4,13.6,0,0,6,7,5,12.666666666666666,0,11.1,0.6,2.02,2 +Student_01278,2,39,9147,1,1,1,1,37,37,9,9,133.1,140.0,0,0,0,0,0,0,0,35,0,5,8,4,12.5,1,0,5,8,5,11.8,0,9.4,-0.8,-3.12,0 +Student_01279,1,39,8014,0,1,1,1,1,12,4,5,133.1,116.5,0,0,0,1,1,1,0,24,0,6,6,4,12.25,0,0,6,10,4,11.5,0,12.4,0.5,1.79,1 +Student_01280,1,17,9238,1,1,1,1,19,37,9,9,120.0,113.0,1,0,0,1,0,1,0,20,0,6,7,6,11.714285714285714,0,0,6,8,6,12.625,0,13.9,-0.3,0.79,2 +Student_01281,1,1,9773,1,3,1,11,19,19,4,9,143.0,133.9,1,0,0,1,1,1,1,18,0,6,7,6,13.5,0,0,6,7,6,13.0,0,16.2,0.3,-0.92,2 +Student_01282,1,1,9500,1,3,1,1,38,19,7,9,133.1,115.5,1,0,0,1,1,1,0,20,0,8,8,7,13.024285714285714,0,0,8,8,7,13.024285714285714,0,10.8,1.4,1.74,2 +Student_01284,1,1,9119,1,1,1,1,19,19,4,4,168.0,171.2,0,0,0,1,1,1,0,18,0,5,6,5,17.333333333333332,0,0,5,8,5,18.571428571428573,0,12.4,0.5,1.79,2 +Student_01285,1,1,9670,1,1,1,1,19,37,5,7,124.0,119.1,0,0,0,1,1,1,0,20,0,5,7,4,11.0,0,0,5,7,4,11.5,0,9.4,-0.8,-3.12,2 +Student_01286,1,17,9853,1,2,1,1,19,38,3,3,127.0,121.1,1,0,0,1,1,0,0,19,0,7,10,6,13.666666666666666,0,0,7,9,6,12.5,0,12.4,0.5,1.79,0 +Student_01287,1,1,9070,1,2,1,1,1,1,4,9,129.0,132.9,1,0,0,1,1,1,0,20,0,6,9,6,11.375,0,0,6,6,5,13.8,0,7.6,2.6,0.32,1 +Student_01288,1,1,9238,1,1,1,1,19,1,9,9,137.0,132.8,0,0,0,1,1,0,0,19,0,6,6,6,12.833333333333334,0,0,6,8,6,11.833333333333334,0,10.8,1.4,1.74,2 +Student_01289,1,1,9773,1,1,1,1,36,37,0,0,120.0,126.7,1,0,0,1,1,0,0,20,0,6,9,5,12.6,0,0,6,11,4,11.5,0,7.6,2.6,0.32,2 +Student_01290,1,1,9500,1,1,1,1,NA,19,9,7,110.0,105.8,1,0,0,1,1,0,0,22,0,7,8,6,14.333333333333334,0,0,8,9,7,13.771428571428572,0,11.1,0.6,2.02,2 +Student_01291,1,17,9119,1,2,1,1,1,19,9,8,120.0,117.2,0,0,0,1,1,1,0,18,0,5,8,4,13.5,0,0,6,10,6,13.625,0,11.1,0.6,2.02,1 +Student_01293,1,44,9003,1,1,39,1,1,19,9,NA,120.0,120.0,0,0,0,1,1,0,0,22,2,6,15,3,11.75,0,0,6,12,2,10.0,0,13.9,-0.3,0.79,0 +Student_01294,1,17,9119,1,5,1,11,4,12,2,9,124.0,119.5,1,0,0,1,1,0,1,20,0,5,5,5,14.8,0,0,5,5,5,17.6,0,8.9,1.4,3.51,2 +Student_01295,2,39,9003,1,1,1,1,1,41,9,3,168.0,153.9,0,0,1,0,1,0,0,34,0,6,7,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_01296,2,39,NA,0,1,19,1,1,1,4,4,133.1,130.0,0,0,0,1,1,0,0,24,0,6,14,1,10.0,0,0,5,5,0,0.0,0,16.2,0.3,-0.92,0 +Student_01297,1,39,9670,1,2,1,1,34,34,0,0,150.0,107.0,1,0,0,1,1,0,0,26,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_01298,1,39,9500,1,1,1,1,37,37,9,6,140.0,132.8,0,0,0,1,1,0,0,35,0,7,10,4,12.6,0,0,7,9,5,12.38,0,12.4,0.5,1.79,0 +Student_01299,1,1,9991,0,1,1,1,2,37,4,9,145.0,127.5,1,0,0,1,1,0,0,22,0,5,9,5,12.428571428571429,1,0,5,7,5,11.8,0,7.6,2.6,0.32,2 +Student_01300,1,18,9254,1,1,1,1,38,38,5,5,118.0,123.3,1,0,0,1,1,0,0,26,0,6,10,4,10.0,0,0,6,11,3,12.0,0,9.4,-0.8,-3.12,1 +Student_01302,1,1,9254,1,5,1,1,3,19,3,9,120.0,114.8,1,0,0,0,1,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_01303,1,44,171,1,1,39,1,3,3,2,2,140.0,140.0,0,0,1,1,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,2 +Student_01304,1,51,9670,1,1,1,1,3,3,1,10,126.0,NA,0,0,1,1,1,0,0,21,5,11,12,10,12.1,0,2,8,9,8,13.333333333333334,0,11.1,0.6,2.02,2 +Student_01305,1,1,9773,1,2,1,1,1,19,7,7,137.0,133.2,1,0,0,1,NA,1,0,19,0,6,7,6,14.714285714285714,0,0,6,6,6,15.0,0,13.9,-0.3,0.79,2 +Student_01306,1,1,9773,1,3,1,1,19,19,9,9,130.0,123.0,1,0,0,1,0,0,0,18,0,6,6,6,12.666666666666666,0,0,6,7,6,12.833333333333334,0,12.7,3.7,-1.7,2 +Student_01309,1,18,9500,1,1,1,1,37,38,5,7,140.0,126.0,1,0,0,1,0,0,0,18,0,8,8,7,13.314285714285717,0,0,8,8,7,13.314285714285717,0,12.7,3.7,-1.7,2 +Student_01310,1,1,9500,1,3,1,1,38,38,9,9,132.0,119.3,1,0,0,1,0,0,0,19,0,8,8,7,11.98857142857143,0,0,8,8,7,11.98857142857143,0,10.8,1.4,1.74,2 +Student_01311,1,53,NA,1,1,42,1,1,19,143,172,130.0,133.8,1,0,0,1,0,0,0,21,6,11,17,11,11.545454545454543,0,3,9,13,8,12.88888888888889,0,8.9,1.4,3.51,2 +Student_01312,1,1,9085,1,1,1,1,37,37,9,6,130.0,126.5,1,0,0,1,0,1,0,18,0,6,13,6,16.46153846153846,0,0,6,8,6,13.875,0,15.5,2.8,-4.06,2 +Student_01314,1,1,9500,1,4,1,1,3,39,2,3,144.0,129.0,1,0,0,1,0,0,0,18,0,7,8,7,12.65,0,0,8,9,8,13.411111111111111,0,16.2,0.3,-0.92,0 +Student_01315,1,1,9670,1,1,1,1,19,1,5,7,127.0,118.3,1,0,0,1,0,0,0,18,0,6,7,6,12.333333333333334,0,0,6,10,3,12.0,0,13.9,-0.3,0.79,1 +Student_01316,1,17,9500,1,2,1,1,19,37,9,7,131.0,129.8,1,0,0,1,0,0,0,20,0,7,8,6,14.37,0,0,8,10,7,14.65,0,12.4,0.5,1.79,2 +Student_01317,1,17,9085,1,2,1,1,1,19,4,9,123.0,113.6,1,0,0,1,0,0,0,19,0,5,13,3,12.0,2,0,5,8,4,11.75,0,9.4,-0.8,-3.12,1 +Student_01318,1,1,9773,1,5,1,1,34,38,0,8,130.0,128.3,1,0,0,0,0,1,0,18,0,6,12,3,12.0,0,0,6,15,3,10.666666666666666,0,7.6,2.6,0.32,0 +Student_01320,1,17,9853,1,2,1,1,1,38,4,8,131.0,121.9,1,0,0,1,0,0,0,19,0,6,10,5,12.6,0,0,6,7,5,11.2,0,10.8,1.4,1.74,2 +Student_01321,1,1,9238,1,5,3,1,1,38,9,3,135.0,129.4,0,0,1,1,0,0,0,18,0,6,6,6,12.166666666666666,0,0,6,6,6,12.333333333333334,0,10.8,1.4,1.74,2 +Student_01323,1,1,9500,1,5,1,1,38,38,9,9,145.0,125.5,1,0,0,1,0,1,0,18,0,8,8,8,13.76375,0,0,8,8,8,13.76375,0,9.4,-0.8,-3.12,2 +Student_01324,1,17,NA,1,6,1,1,38,38,5,5,118.0,117.8,1,0,0,NA,0,1,0,19,0,7,11,6,12.4,0,0,7,8,6,12.8,0,11.1,0.6,2.02,2 +Student_01325,1,17,9147,1,3,1,1,3,38,2,10,125.0,118.7,1,0,0,1,0,0,0,18,0,5,16,4,10.666666666666666,0,0,5,11,2,12.0,0,13.9,-0.3,0.79,1 +Student_01326,1,1,9500,1,2,1,1,37,37,9,9,152.0,139.0,1,0,0,1,0,0,0,18,0,7,7,6,14.333333333333334,0,0,7,7,6,14.333333333333334,0,7.6,2.6,0.32,2 +Student_01328,1,17,9254,1,1,1,1,34,38,0,7,137.0,137.7,1,0,1,0,0,0,0,19,0,6,14,1,10.0,0,0,6,13,0,0.0,0,7.6,2.6,0.32,0 +Student_01330,1,1,9085,1,1,1,1,4,1,2,9,120.0,113.4,0,0,0,1,0,0,0,18,0,6,14,4,11.5,0,0,6,17,3,13.75,0,11.1,0.6,2.02,1 +Student_01331,1,17,9556,1,3,1,1,19,38,9,7,131.0,128.5,0,0,0,1,0,1,0,18,0,7,9,7,12.855555555555556,0,0,8,8,8,13.9125,0,12.7,3.7,-1.7,2 +Student_01332,1,1,9500,1,1,1,1,1,1,3,10,141.0,142.8,0,0,0,NA,0,0,0,18,0,7,7,7,13.7,0,0,8,9,8,13.994444444444444,0,11.1,0.6,2.02,2 +Student_01333,1,NA,9130,1,1,1,1,3,1,1,3,144.0,137.7,0,0,0,0,0,0,0,23,0,5,9,0,0.0,3,1,5,10,1,12.0,3,10.8,1.4,1.74,0 +Student_01334,1,1,9238,1,1,1,1,19,37,7,7,107.0,103.5,1,0,0,1,0,0,0,20,0,6,13,3,11.2,0,0,6,9,4,12.0,0,16.2,0.3,-0.92,1 +Student_01335,1,1,9500,1,1,1,1,38,38,5,5,133.0,123.2,0,0,0,1,0,0,0,18,0,7,7,7,13.285714285714286,0,0,8,9,8,13.333333333333334,0,16.2,0.3,-0.92,2 +Student_01336,1,17,9853,1,2,1,1,1,19,2,10,126.0,126.0,1,0,0,1,0,0,0,19,0,6,9,5,13.0,0,0,6,8,5,10.4,0,7.6,2.6,0.32,1 +Student_01337,1,39,9500,1,1,1,1,1,38,3,7,133.1,121.7,0,0,0,1,0,1,0,27,0,7,8,6,12.6,0,0,7,9,6,11.685714285714283,0,12.4,0.5,1.79,1 +Student_01338,1,17,9147,1,1,1,1,37,37,9,6,147.0,142.8,1,0,1,0,0,1,0,19,0,5,5,5,12.8,0,0,5,5,4,12.0,0,11.1,0.6,2.02,1 +Student_01339,1,NA,9130,1,1,1,1,1,19,9,9,120.0,120.0,1,0,0,1,0,0,0,21,0,6,14,5,11.5,1,0,6,13,5,11.0,1,15.5,2.8,-4.06,0 +Student_01340,1,18,9500,1,1,1,1,37,38,7,8,130.0,119.3,1,0,0,1,0,1,0,19,0,8,8,7,11.4,0,0,8,8,7,11.4,0,10.8,1.4,1.74,2 +Student_01342,1,1,9773,1,5,1,1,19,19,9,9,138.0,139.4,1,0,0,1,0,0,0,18,0,6,7,5,12.8,0,0,6,10,4,NA,0,10.8,1.4,1.74,2 +Student_01343,1,17,9085,1,1,1,1,19,38,7,7,124.0,113.9,1,0,0,1,0,1,0,20,0,5,8,5,12.0,1,0,5,8,4,15.0,1,12.7,3.7,-1.7,2 +Student_01344,1,1,9853,1,1,1,1,37,37,9,7,133.0,124.6,1,0,0,1,0,1,0,18,0,6,8,5,13.0,0,0,6,9,5,13.5,0,9.4,-0.8,-3.12,2 +Student_01345,1,17,9070,1,1,1,1,1,1,4,8,122.0,123.8,1,0,1,0,0,1,0,18,0,6,6,6,11.833333333333334,0,0,6,8,6,11.0,0,12.7,3.7,-1.7,0 +Student_01346,1,1,9085,1,3,1,1,1,3,4,4,138.0,126.3,1,0,0,1,0,0,0,18,0,6,8,6,14.0,0,0,6,9,6,13.333333333333334,0,8.9,1.4,3.51,2 +Student_01347,1,17,9773,1,4,1,1,1,1,3,3,134.0,120.4,1,0,0,1,0,1,0,18,0,6,6,6,12.333333333333334,0,0,6,6,6,13.5,0,16.2,0.3,-0.92,2 +Student_01348,1,1,9500,1,3,1,1,1,1,7,7,128.0,120.5,1,0,0,1,0,1,0,19,0,7,10,5,13.04,0,0,7,7,7,12.5,0,12.4,0.5,1.79,1 +Student_01350,1,39,9085,1,1,19,1,19,19,4,9,133.1,139.9,1,0,0,1,0,1,0,24,1,6,7,6,12.5,0,0,6,11,6,12.833333333333334,0,8.9,1.4,3.51,2 +Student_01351,1,1,171,1,1,1,1,1,1,3,3,142.0,133.3,1,0,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,2 +Student_01352,1,1,9500,1,3,1,1,19,19,9,9,141.0,126.0,1,0,0,1,0,0,0,18,0,8,8,7,15.657142857142857,0,0,8,8,7,15.657142857142857,0,12.7,3.7,-1.7,2 +Student_01353,1,1,9070,1,2,NA,1,1,19,4,3,145.0,133.5,0,0,0,1,0,0,0,NA,0,6,6,6,12.166666666666666,0,0,6,6,6,11.333333333333334,0,12.7,3.7,-1.7,2 +Student_01355,1,1,9238,1,1,1,1,1,38,5,8,108.0,105.9,0,0,0,1,0,1,0,20,0,6,11,5,10.6,0,0,6,9,5,11.166666666666666,0,11.1,0.6,2.02,1 +Student_01356,1,1,9085,1,1,1,1,1,12,4,5,132.0,124.3,0,0,0,1,0,0,0,20,0,6,10,6,13.428571428571429,0,0,6,11,5,12.666666666666666,0,13.9,-0.3,0.79,1 +Student_01357,1,39,9773,1,1,1,1,34,37,0,0,140.0,102.5,0,0,0,1,0,0,0,26,0,6,8,4,11.75,0,0,6,12,0,0.0,0,7.6,2.6,0.32,0 +Student_01360,1,42,9119,1,1,1,1,19,37,9,9,120.0,113.8,0,0,0,0,1,0,0,27,0,5,0,0,0.0,0,0,5,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01362,1,1,9500,1,4,1,1,37,38,9,9,139.0,124.0,1,0,0,1,1,1,0,18,0,8,8,7,13.331428571428573,0,0,8,8,7,13.331428571428573,0,10.8,1.4,1.74,2 +Student_01364,1,44,171,1,1,39,1,19,1,9,9,150.0,154.8,1,0,0,1,1,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,2 +Student_01365,1,1,9500,1,1,1,1,19,37,4,9,138.0,141.0,0,0,0,1,1,0,0,19,0,7,7,6,13.7,0,0,7,7,6,13.7,0,7.6,2.6,0.32,2 +Student_01366,1,39,9670,1,1,9,1,6,22,3,3,133.1,120.0,0,0,1,0,1,0,0,26,0,5,5,0,0.0,0,0,5,5,0,0.0,5,9.4,-0.8,-3.12,0 +Student_01369,1,1,9147,1,1,1,1,19,19,7,3,140.0,120.0,1,0,0,1,1,0,0,21,0,5,8,3,10.0,0,0,5,10,4,11.0,0,12.7,3.7,-1.7,0 +Student_01370,1,53,9670,1,1,42,1,1,19,9,9,110.0,114.2,0,0,0,1,1,1,0,23,0,6,7,5,13.0,0,0,6,7,6,12.857142857142858,0,8.9,1.4,3.51,2 +Student_01371,1,39,8014,0,1,38,1,38,37,4,8,133.1,95.5,0,0,0,1,1,0,0,29,0,6,11,6,12.0,0,0,6,6,6,14.0,0,11.1,0.6,2.02,2 +Student_01372,1,1,9500,1,1,1,1,1,1,9,9,129.0,120.0,0,0,0,1,1,0,0,20,0,8,8,7,15.028571428571428,0,0,8,8,7,15.028571428571428,0,12.7,3.7,-1.7,2 +Student_01373,1,1,9238,1,1,1,1,1,19,5,9,116.0,111.1,0,0,0,1,1,0,0,18,0,6,8,6,12.0,0,0,6,7,6,11.714285714285714,0,15.5,2.8,-4.06,2 +Student_01374,1,1,9773,1,1,1,1,1,38,3,5,130.0,128.6,1,0,0,1,1,0,0,19,0,6,8,5,12.0,0,0,6,8,5,12.4,0,9.4,-0.8,-3.12,2 +Student_01375,1,7,9556,1,1,3,1,1,37,4,8,130.0,130.0,0,0,0,0,1,0,0,23,3,7,7,3,NA,0,3,8,8,3,11.333333333333334,4,10.8,1.4,1.74,0 +Student_01376,1,1,171,1,1,1,1,38,1,5,1,116.0,111.1,0,0,0,1,1,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_01377,1,17,9147,1,1,1,1,1,1,9,3,136.0,122.7,1,0,0,1,1,0,0,18,0,5,6,5,12.0,0,0,5,7,4,12.5,0,15.5,2.8,-4.06,1 +Student_01378,1,1,171,1,1,1,1,37,19,7,7,147.0,134.4,1,0,0,1,1,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,2 +Student_01379,1,1,9070,1,5,1,1,19,37,5,5,117.0,131.0,1,0,1,0,1,0,0,21,0,6,6,1,14.0,0,0,6,7,0,0.0,7,9.4,-0.8,-3.12,0 +Student_01380,1,51,9238,1,1,1,1,1,1,5,9,141.0,125.0,0,0,0,1,1,0,0,22,0,6,6,0,0.0,0,0,6,7,0,0.0,0,11.1,0.6,2.02,0 +Student_01381,1,18,9556,1,1,1,1,3,19,2,8,133.1,106.0,1,0,0,1,1,0,0,21,0,7,8,7,12.375,0,0,7,11,5,12.583333333333334,0,8.9,1.4,3.51,2 +Student_01382,1,39,9500,1,1,1,1,38,19,9,9,133.1,128.0,1,0,0,0,1,0,0,32,0,7,0,0,0.0,0,0,8,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_01384,1,1,9500,1,1,1,1,19,38,9,8,148.0,134.8,1,0,0,1,1,0,0,18,0,7,7,6,13.35,0,0,7,7,6,13.35,0,7.6,2.6,0.32,2 +Student_01385,1,39,9070,1,1,1,1,1,1,5,3,130.0,112.0,1,0,0,1,1,1,0,24,0,6,6,6,15.0,0,0,6,6,2,16.0,0,15.5,2.8,-4.06,2 +Student_01386,1,1,9130,1,1,1,1,19,37,1,9,120.0,116.1,1,0,0,1,1,0,0,22,0,5,9,2,10.5,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_01387,1,43,9130,1,1,1,1,2,3,3,2,120.0,120.0,1,0,0,0,1,0,0,22,0,6,0,0,0.0,0,0,4,6,0,0.0,2,10.8,1.4,1.74,0 +Student_01388,1,1,9147,1,3,1,1,37,37,9,5,133.0,119.7,1,0,0,1,1,0,0,19,0,5,8,5,13.25,0,0,5,6,5,11.833333333333334,0,13.9,-0.3,0.79,2 +Student_01389,1,17,9119,1,6,1,1,37,13,4,90,129.0,117.1,1,0,0,1,1,0,0,19,0,5,10,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_01390,1,1,9085,1,2,1,1,1,19,3,3,118.0,112.4,1,0,0,1,1,0,0,21,0,5,7,4,11.5,0,0,5,15,3,10.6,4,10.8,1.4,1.74,1 +Student_01391,1,1,9500,1,2,1,1,1,1,2,7,NA,131.0,1,0,0,1,0,1,0,18,0,8,8,8,13.88125,0,0,8,8,8,13.88125,0,9.4,-0.8,-3.12,2 +Student_01392,1,1,9254,1,2,1,1,3,19,3,10,127.0,130.9,1,0,0,1,0,0,0,18,0,6,8,6,11.333333333333334,0,0,6,8,5,12.6,0,9.4,-0.8,-3.12,2 +Student_01393,1,1,171,1,1,1,1,19,19,9,9,131.0,134.9,1,0,1,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_01394,1,17,9238,1,1,1,1,1,19,4,9,132.0,127.1,1,0,0,1,0,0,0,19,0,6,7,6,12.857142857142858,0,0,6,7,6,13.666666666666666,0,13.9,-0.3,0.79,2 +Student_01395,1,17,9773,1,5,1,1,38,38,191,175,113.0,110.2,1,0,1,1,0,0,0,19,0,6,6,5,11.6,0,0,6,6,6,12.5,0,8.9,1.4,3.51,2 +Student_01396,1,17,9254,1,1,1,1,12,1,9,3,115.0,108.7,1,0,0,1,0,1,0,18,0,6,9,5,11.4,0,0,6,6,6,11.333333333333334,0,12.4,0.5,1.79,2 +Student_01397,1,1,9130,1,1,1,1,1,1,3,9,133.1,138.0,1,0,0,1,0,0,0,20,0,6,11,6,13.333333333333334,0,0,6,10,6,13.0,0,16.2,0.3,-0.92,1 +Student_01398,1,44,9070,1,1,39,1,12,37,3,9,150.0,147.7,0,0,1,1,0,1,0,22,2,7,7,7,13.571428571428571,0,5,9,9,9,13.77777777777778,0,12.4,0.5,1.79,2 +Student_01399,2,39,9556,1,1,19,1,37,38,9,9,133.1,123.0,0,0,0,1,0,0,0,31,0,7,13,6,11.833333333333334,0,0,7,8,7,12.228571428571428,0,12.4,0.5,1.79,2 +Student_01400,1,17,9853,1,1,1,1,19,19,9,8,141.0,142.8,0,0,0,1,0,1,0,19,0,7,7,7,14.428571428571429,0,0,7,7,7,14.142857142857142,0,16.2,0.3,-0.92,2 +Student_01401,1,1,171,1,2,1,1,1,3,3,3,140.0,138.3,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,1 +Student_01402,1,NA,9254,1,2,1,1,38,38,9,7,136.0,125.2,1,0,0,1,0,1,0,18,0,6,8,6,12.285714285714286,0,0,6,9,5,12.4,0,8.9,1.4,3.51,2 +Student_01403,1,1,9085,1,1,1,1,12,1,1,90,140.0,141.8,0,0,0,1,0,0,0,21,0,5,7,5,14.4,0,0,5,5,5,13.8,0,7.6,2.6,0.32,2 +Student_01404,1,17,9500,1,5,1,1,38,1,9,7,143.0,130.6,1,0,0,1,0,1,0,18,0,7,8,7,13.15,0,0,8,9,8,15.06875,0,13.9,-0.3,0.79,2 +Student_01405,1,44,9147,1,1,39,22,2,37,2,8,130.0,130.0,0,0,1,0,1,0,1,25,0,5,6,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_01407,1,18,9500,1,2,1,1,38,37,5,5,129.0,119.0,1,0,0,1,0,1,0,19,0,8,8,7,12.342857142857143,0,0,8,8,7,12.342857142857143,0,10.8,1.4,1.74,2 +Student_01408,1,1,9773,1,2,1,1,38,1,9,9,132.0,124.3,1,0,0,1,0,0,0,19,0,6,6,5,12.2,0,0,6,7,5,10.8,0,10.8,1.4,1.74,1 +Student_01410,1,15,9147,1,1,1,1,38,1,9,1,150.0,150.0,0,0,0,1,1,0,0,19,0,5,5,5,10.6,0,0,5,8,5,11.6,0,12.4,0.5,1.79,2 +Student_01411,1,39,8014,0,1,19,1,37,37,9,5,133.1,135.5,0,0,0,1,0,0,0,58,0,6,6,0,0.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_01413,1,43,9670,1,1,1,22,37,37,9,9,127.0,127.0,1,0,0,1,1,0,1,23,3,9,11,6,10.5,0,4,10,10,10,11.7,0,9.4,-0.8,-3.12,2 +Student_01414,1,1,9773,1,2,1,1,37,37,9,9,122.0,126.9,1,0,0,1,0,1,0,19,0,6,11,4,11.0,0,0,6,11,3,11.666666666666666,0,9.4,-0.8,-3.12,1 +Student_01415,1,18,9500,1,3,1,1,19,1,4,7,131.0,127.5,1,0,0,1,0,0,0,18,0,7,7,7,13.457142857142856,0,0,8,8,8,14.5125,0,13.9,-0.3,0.79,2 +Student_01416,1,1,9085,1,2,1,1,19,19,90,90,130.0,122.0,0,0,0,1,0,0,0,20,0,5,6,5,12.6,0,0,5,8,4,12.333333333333334,0,7.6,2.6,0.32,2 +Student_01417,1,17,9085,1,5,1,1,19,19,90,7,130.0,115.8,0,0,0,0,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_01418,1,17,9670,1,1,1,1,3,19,5,5,130.0,121.6,0,0,0,1,0,0,0,18,0,6,6,6,13.666666666666666,0,0,6,8,5,13.6,0,8.9,1.4,3.51,2 +Student_01419,1,17,9147,1,4,1,1,19,19,5,7,122.0,116.4,1,0,1,1,0,1,0,18,0,5,5,5,11.6,0,0,5,5,5,11.8,0,11.1,0.6,2.02,2 +Student_01420,1,39,9130,1,1,1,1,38,38,9,10,114.0,120.0,0,0,0,1,0,0,0,24,0,6,9,6,12.571428571428571,0,0,6,10,5,12.833333333333334,0,11.1,0.6,2.02,0 +Student_01421,1,17,9853,1,4,1,1,37,37,9,5,143.0,127.3,1,0,0,1,0,0,0,18,0,6,7,5,11.8,0,0,6,7,5,11.4,0,10.8,1.4,1.74,0 +Student_01422,1,1,9147,1,3,1,1,1,38,5,7,127.0,123.5,1,0,0,1,0,1,0,19,0,5,5,5,11.6,0,0,5,11,3,12.666666666666666,0,9.4,-0.8,-3.12,1 +Student_01424,1,1,9254,1,1,1,1,38,38,6,6,129.0,118.5,1,0,0,1,0,0,0,18,0,6,6,6,10.666666666666666,0,0,6,6,6,11.5,0,7.6,2.6,0.32,2 +Student_01425,1,1,9130,1,2,1,1,19,37,9,9,140.0,129.5,1,0,0,1,0,0,0,18,0,5,10,4,13.5,1,0,5,5,5,13.4,0,12.7,3.7,-1.7,1 +Student_01427,1,44,9085,1,1,1,1,4,4,2,6,140.0,140.0,0,0,0,1,0,0,0,22,2,6,9,6,13.333333333333334,0,1,6,9,4,11.5,0,13.9,-0.3,0.79,2 +Student_01428,1,1,9254,1,1,1,1,2,37,1,1,143.0,133.2,1,0,0,1,0,0,0,19,0,6,9,5,13.4,0,0,6,16,2,13.5,0,10.8,1.4,1.74,1 +Student_01429,3,17,9238,1,1,1,1,37,37,9,9,138.0,133.5,1,0,0,1,0,1,0,21,0,6,8,3,10.2,0,0,6,13,4,12.25,0,12.7,3.7,-1.7,1 +Student_01431,1,1,9500,1,3,1,1,38,38,5,7,144.0,128.0,1,0,0,1,0,1,0,18,0,8,11,7,12.90857142857143,0,0,8,11,7,12.90857142857143,0,10.8,1.4,1.74,2 +Student_01432,1,1,9853,1,5,1,1,1,12,4,9,123.0,113.2,1,0,0,1,0,0,0,20,0,6,12,4,12.0,0,0,6,11,1,10.0,0,10.8,1.4,1.74,0 +Student_01433,1,1,9254,1,3,1,1,37,38,7,7,129.0,122.0,1,0,0,1,0,1,0,18,0,6,9,6,10.833333333333334,0,0,6,8,5,11.0,0,7.6,2.6,0.32,1 +Student_01434,1,16,9070,1,3,1,1,1,38,4,8,152.0,156.9,1,0,0,1,0,0,0,19,0,6,6,6,15.333333333333334,0,0,6,9,6,15.833333333333334,0,12.7,3.7,-1.7,2 +Student_01435,1,1,9500,1,2,1,1,1,38,9,9,130.0,125.1,1,0,0,1,0,1,0,18,0,7,9,6,12.816666666666668,0,0,8,11,6,12.875,0,11.1,0.6,2.02,1 +Student_01437,1,15,9119,1,1,1,32,1,3,143,152,160.0,160.0,0,0,1,1,0,0,1,19,0,6,11,2,13.5,1,0,5,11,2,11.0,0,8.9,1.4,3.51,1 +Student_01438,2,39,8014,0,1,1,1,37,37,9,9,140.0,101.0,0,0,0,1,0,0,0,35,0,6,7,6,12.5,0,0,6,6,6,12.166666666666666,0,15.5,2.8,-4.06,2 +Student_01439,1,18,9670,1,1,1,1,1,1,9,9,133.0,121.5,1,0,0,1,0,1,0,19,0,6,7,6,13.0,0,0,6,6,6,14.333333333333334,0,12.4,0.5,1.79,2 +Student_01440,1,1,9085,1,1,1,1,38,37,9,6,138.0,126.8,1,0,0,1,1,0,0,18,0,5,6,4,11.75,0,0,5,10,5,12.571428571428571,1,10.8,1.4,1.74,2 +Student_01441,1,1,9670,1,5,1,1,19,19,7,3,142.0,NA,0,0,0,1,1,0,0,19,0,5,5,4,12.5,0,0,5,5,4,14.25,0,7.6,2.6,0.32,2 +Student_01442,1,1,171,1,1,1,1,1,1,9,9,115.0,134.3,1,0,0,1,1,0,0,25,16,17,19,17,11.61111111111111,0,14,17,22,17,12.055555555555555,0,12.4,0.5,1.79,2 +Student_01443,1,17,9254,1,6,1,1,1,1,4,3,125.0,120.5,1,0,0,1,1,0,0,18,0,6,6,6,14.0,0,0,6,6,6,NA,0,11.1,0.6,2.02,2 +Student_01445,1,43,9991,0,1,1,1,1,1,6,6,140.0,100.0,0,0,0,1,1,0,0,34,0,5,5,5,13.8,0,0,5,6,5,13.833333333333334,0,9.4,-0.8,-3.12,2 +Student_01446,1,1,9254,1,2,1,1,4,19,4,3,110.0,114.8,1,0,0,0,1,0,0,18,0,5,6,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_01447,1,1,171,1,1,1,1,3,29,3,5,114.0,111.9,0,0,0,0,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01448,1,17,9119,1,3,1,1,1,19,4,3,138.0,125.4,1,0,0,1,1,1,0,18,0,5,9,4,12.25,0,0,5,9,3,12.333333333333334,0,8.9,1.4,3.51,0 +Student_01449,1,44,9003,1,1,39,1,37,37,9,4,140.0,140.0,0,0,0,1,1,0,0,20,0,6,12,3,11.5,0,0,6,12,3,13.666666666666666,0,12.4,0.5,1.79,0 +Student_01450,1,44,9070,1,1,39,1,1,19,4,4,140.0,140.0,0,0,0,1,1,0,0,25,2,7,9,6,12.571428571428571,0,5,9,9,9,12.555555555555555,0,16.2,0.3,-0.92,2 +Student_01452,1,1,9003,1,1,1,1,19,37,9,9,148.0,131.6,1,0,0,1,1,0,0,19,8,12,17,11,12.0,2,4,12,21,12,12.307692307692308,0,15.5,2.8,-4.06,2 +Student_01453,1,1,171,1,1,1,1,1,1,4,1,132.0,119.4,1,0,0,1,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01455,1,1,9119,1,1,1,1,3,1,2,3,121.0,114.0,0,0,0,1,1,0,0,20,0,5,9,4,11.6,0,0,5,7,4,12.25,2,7.6,2.6,0.32,1 +Student_01456,1,1,9147,1,2,1,1,1,37,4,9,120.0,113.4,1,0,0,1,1,1,0,19,0,5,5,0,0.0,0,0,5,5,0,0.0,0,11.1,0.6,2.02,0 +Student_01457,1,1,9147,1,1,1,1,1,19,4,5,123.0,117.8,0,0,0,1,1,0,0,20,0,5,9,5,12.0,0,0,5,9,4,13.0,0,8.9,1.4,3.51,1 +Student_01458,1,1,9500,1,6,1,1,1,1,3,7,122.0,114.3,1,0,0,1,1,0,0,18,0,7,8,6,13.976666666666668,0,0,8,12,6,12.041666666666666,1,11.1,0.6,2.02,1 +Student_01459,1,1,9670,1,1,1,1,2,38,143,163,136.0,129.7,1,0,0,1,1,0,0,19,0,6,10,4,12.5,0,0,6,12,1,10.0,3,16.2,0.3,-0.92,1 +Student_01461,1,39,9670,1,1,1,1,38,37,7,7,120.0,140.0,0,0,0,1,1,0,0,24,0,6,15,4,10.5,0,0,6,16,4,12.5,0,15.5,2.8,-4.06,0 +Student_01462,1,44,9003,1,1,39,1,38,38,9,8,150.0,150.0,1,0,0,1,1,0,0,20,0,6,8,5,12.857142857142858,0,0,6,11,6,12.3,0,16.2,0.3,-0.92,2 +Student_01463,1,1,9670,1,3,1,1,3,19,2,8,121.0,122.4,1,0,0,1,NA,0,0,19,0,5,7,3,11.666666666666666,0,0,5,5,4,12.0,0,9.4,-0.8,-3.12,1 +Student_01465,1,17,9254,1,2,1,1,19,19,4,3,135.0,135.0,1,0,0,1,1,0,0,20,0,6,8,6,11.833333333333334,0,0,6,9,5,10.4,0,7.6,2.6,0.32,1 +Student_01466,1,43,8014,0,4,1,1,34,34,0,0,116.0,116.2,0,0,0,1,1,0,0,21,9,11,11,11,12.454545454545457,0,3,11,17,8,12.75,0,9.4,-0.8,-3.12,2 +Student_01467,1,17,9119,1,2,1,1,10,12,9,9,120.0,120.4,1,0,0,1,1,0,0,20,0,5,6,3,11.0,0,0,5,6,0,0.0,0,10.8,1.4,1.74,0 +Student_01468,2,17,9119,1,5,1,1,37,38,4,4,126.0,122.9,1,0,0,1,1,0,0,21,0,5,10,4,13.2,0,0,5,7,4,14.25,2,7.6,2.6,0.32,1 +Student_01469,1,1,9773,1,1,1,1,1,19,9,7,170.0,155.0,0,0,0,1,1,1,0,18,0,6,6,6,15.5,0,0,6,6,6,14.166666666666666,0,11.1,0.6,2.02,2 +Student_01471,1,17,9147,1,1,1,1,3,38,3,7,120.0,124.2,1,0,0,1,1,0,0,18,0,5,13,5,12.0,0,0,5,9,4,11.4,0,13.9,-0.3,0.79,1 +Student_01472,1,44,9003,1,1,39,1,3,3,7,1,130.0,130.0,1,0,0,1,1,0,0,20,0,6,12,4,11.6,0,0,6,11,5,11.5,0,15.5,2.8,-4.06,1 +Student_01474,1,17,9773,1,1,1,1,37,37,0,4,117.0,120.5,1,0,0,1,1,0,0,19,0,6,12,0,0.0,1,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01476,1,17,9130,1,1,1,1,19,38,4,7,130.0,122.5,0,0,0,1,1,0,0,19,0,5,11,4,12.0,1,0,5,9,5,12.6,0,9.4,-0.8,-3.12,2 +Student_01477,1,39,9991,0,1,1,1,37,37,9,5,133.0,139.2,1,0,1,1,1,0,0,33,0,5,11,2,12.5,0,0,5,9,2,11.5,1,12.7,3.7,-1.7,0 +Student_01478,1,51,171,1,1,1,1,2,1,3,3,128.0,131.2,1,0,0,1,1,0,0,21,6,12,12,12,13.666666666666666,0,4,11,16,11,13.0,0,8.9,1.4,3.51,2 +Student_01479,2,39,9003,1,1,1,1,1,19,4,4,133.1,120.0,0,0,1,0,1,0,0,25,0,6,17,2,14.5,2,0,6,13,0,0.0,1,15.5,2.8,-4.06,0 +Student_01480,1,1,9085,1,1,1,1,1,1,4,9,123.0,116.7,1,0,0,1,1,1,0,20,0,6,10,4,13.2,0,0,6,8,0,0.0,0,12.4,0.5,1.79,0 +Student_01482,4,39,9773,1,1,19,1,37,37,9,1,133.1,117.5,0,0,0,1,0,0,0,39,0,6,10,4,11.25,0,0,6,6,6,11.333333333333334,0,10.8,1.4,1.74,2 +Student_01484,1,17,9254,1,1,1,1,1,1,9,9,126.0,124.3,0,0,0,1,0,1,0,19,0,6,8,6,11.166666666666666,0,0,6,7,4,13.4,0,16.2,0.3,-0.92,2 +Student_01485,1,39,9500,1,1,19,1,37,37,9,7,133.1,116.0,0,0,0,1,0,1,0,26,0,7,8,6,10.983333333333334,0,0,7,8,6,10.983333333333334,0,7.6,2.6,0.32,2 +Student_01488,1,17,9670,1,1,1,1,1,37,4,9,133.1,96.0,1,0,0,1,0,1,0,25,0,6,8,6,11.285714285714286,0,0,6,10,5,12.2,0,15.5,2.8,-4.06,1 +Student_01489,1,43,8014,0,1,1,1,19,37,8,5,131.0,125.0,0,0,0,1,1,0,0,24,0,6,13,0,NA,3,0,6,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_01490,1,17,9119,1,6,1,1,19,19,4,0,124.0,126.1,1,0,0,1,1,0,0,20,0,5,7,4,13.0,0,0,5,9,5,14.833333333333334,3,NA,2.6,0.32,2 +Student_01491,2,39,9003,1,1,1,1,37,37,9,9,120.0,155.8,0,0,0,1,1,0,0,29,0,6,9,6,16.11111111111111,0,0,6,7,6,13.5,0,13.9,-0.3,0.79,2 +Student_01492,1,1,9773,1,1,1,1,1,3,9,9,133.1,116.0,0,0,0,1,1,0,0,20,0,6,8,6,11.5,0,0,6,8,6,11.0,0,16.2,0.3,-0.92,2 +Student_01493,1,44,9130,1,1,39,1,3,4,2,2,110.0,110.0,1,0,0,1,1,0,0,20,0,6,15,4,10.75,0,0,6,12,2,10.5,0,13.9,-0.3,0.79,0 +Student_01494,1,39,9670,1,1,19,1,19,1,5,8,133.1,97.2,1,0,0,1,1,1,0,24,0,6,10,4,11.6,0,0,6,8,5,13.0,0,11.1,0.6,2.02,2 +Student_01495,1,39,9500,1,1,19,1,1,3,2,2,133.1,100.0,0,0,1,1,1,0,0,24,0,7,21,0,0.0,3,0,7,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_01496,1,7,9119,1,1,40,1,3,1,2,5,140.0,140.0,0,0,0,1,1,0,0,23,0,5,5,5,13.8,0,0,5,7,5,14.142857142857142,0,11.1,0.6,2.02,2 +Student_01497,1,43,9556,1,1,1,1,1,37,5,5,130.0,128.0,1,0,0,1,1,0,0,20,0,7,8,7,13.585714285714284,0,0,8,8,8,14.6875,0,15.5,2.8,-4.06,2 +Student_01498,1,17,9670,1,2,1,1,1,1,4,10,110.0,115.3,1,0,0,1,1,0,0,19,0,6,8,6,13.857142857142858,0,0,6,8,5,13.0,0,15.5,2.8,-4.06,2 +Student_01499,4,39,9003,1,1,1,1,37,37,9,8,140.0,150.0,0,0,0,1,1,0,0,28,0,6,12,5,12.0,0,0,6,10,6,12.333333333333334,0,11.1,0.6,2.02,1 +Student_01500,1,44,9003,1,1,39,1,1,38,4,4,160.0,160.0,1,0,0,1,1,1,0,20,0,6,9,6,13.444444444444445,0,0,6,9,5,12.6,0,13.9,-0.3,0.79,2 +Student_01501,1,1,9070,1,1,1,1,38,37,3,3,138.0,133.1,0,0,0,1,1,0,0,18,0,6,6,6,14.0,0,0,6,7,6,13.857142857142858,0,8.9,1.4,3.51,2 +Student_01502,1,1,9670,1,1,1,1,1,1,90,90,126.0,119.0,1,0,1,1,1,0,0,20,0,6,10,1,12.0,1,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01503,2,39,9991,0,1,1,1,37,19,5,3,120.0,156.0,1,0,0,1,1,0,0,33,0,5,5,5,14.2,0,0,5,6,5,13.833333333333334,0,10.8,1.4,1.74,2 +Student_01504,2,39,9500,1,1,1,NA,37,37,191,183,130.0,163.7,0,0,0,1,0,0,0,35,0,7,11,5,13.34,0,0,7,9,5,10.84,0,12.4,0.5,1.79,1 +Student_01505,1,39,9500,1,1,40,1,37,37,9,7,130.0,130.0,0,0,0,1,0,0,0,27,3,8,12,7,12.457142857142856,0,3,8,12,7,12.457142857142856,0,12.7,3.7,-1.7,1 +Student_01506,1,17,9773,1,5,1,1,38,38,7,7,122.0,123.1,1,0,0,0,0,0,0,19,0,6,12,3,11.0,0,0,6,12,3,12.0,0,9.4,-0.8,-3.12,0 +Student_01507,1,39,9991,0,1,1,41,37,19,9,9,160.0,160.0,0,0,0,1,0,1,1,31,0,5,13,4,10.5,0,0,5,10,4,10.5,0,15.5,2.8,-4.06,1 +Student_01508,1,1,171,1,1,1,1,19,37,7,7,134.0,136.1,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_01509,1,43,9070,1,1,1,1,19,37,7,7,134.0,132.7,1,0,0,1,1,0,0,22,9,13,13,13,14.0,0,7,12,13,12,13.0,0,15.5,2.8,-4.06,2 +Student_01511,1,17,9254,1,1,1,1,1,1,4,8,127.0,126.7,1,0,0,0,1,0,0,22,0,1,1,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,NA,0 +Student_01513,1,17,171,1,1,1,1,19,37,5,9,143.0,156.3,1,0,0,1,1,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,2 +Student_01514,1,10,9254,1,1,1,24,3,1,9,9,115.0,116.1,1,0,0,1,0,0,1,19,0,6,6,6,13.5,0,0,6,6,6,14.333333333333334,0,12.4,0.5,1.79,2 +Student_01515,1,17,9500,1,1,1,1,19,37,9,9,131.0,123.8,1,0,0,1,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01516,1,1,171,1,1,1,1,19,37,9,7,146.0,153.0,1,0,0,1,0,1,0,21,15,17,18,17,13.38888888888889,0,15,17,18,17,14.88888888888889,0,11.1,0.6,2.02,2 +Student_01517,1,7,9500,1,1,5,1,19,1,4,1,140.0,140.0,1,0,0,0,0,0,0,39,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.4,0.5,NA,0 +Student_01519,1,1,171,1,1,1,1,37,19,9,8,133.0,141.4,0,0,0,1,1,1,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,1 +Student_01521,1,39,9991,0,1,1,1,19,19,9,9,120.0,115.0,1,0,0,1,1,0,0,27,0,5,9,1,10.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_01522,2,39,9991,0,1,1,1,37,37,9,9,133.1,168.0,0,0,0,1,1,0,0,29,0,5,5,5,15.2,0,0,5,5,5,15.2,0,11.1,0.6,2.02,2 +Student_01523,1,17,9085,1,1,1,1,NA,1,9,4,130.0,101.3,1,0,0,1,1,0,0,20,0,6,12,4,12.8,0,0,6,17,0,0.0,0,12.4,0.5,1.79,0 +Student_01524,1,1,9670,1,1,1,1,19,1,7,4,125.0,122.6,0,0,0,1,1,0,0,21,0,5,7,5,11.166666666666666,0,0,5,5,4,11.0,0,9.4,-0.8,-3.12,0 +Student_01525,1,1,171,1,1,1,1,3,2,2,2,134.0,141.7,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,1 +Student_01526,1,1,9500,1,1,1,1,1,1,4,3,151.0,132.3,0,0,0,1,1,0,0,19,0,8,9,7,12.828571428571427,0,0,8,9,7,12.828571428571427,0,12.7,3.7,-1.7,2 +Student_01527,1,17,9773,1,1,1,1,1,1,5,1,112.0,111.7,0,0,1,0,1,0,0,19,0,6,6,6,12.5,0,0,6,10,4,12.6,0,15.5,2.8,-4.06,0 +Student_01529,1,15,9254,1,1,1,26,19,1,9,7,140.0,140.0,1,0,0,0,0,0,1,21,0,6,6,6,11.5,0,0,6,10,4,13.25,0,13.9,-0.3,0.79,2 +Student_01530,1,10,9500,1,1,1,24,3,3,2,9,140.0,140.0,1,0,1,0,0,0,1,23,0,8,11,7,11.328571428571427,0,0,8,11,7,11.328571428571427,0,12.7,3.7,-1.7,0 +Student_01531,4,39,9003,1,1,1,1,19,19,9,4,133.1,100.7,0,0,0,1,0,0,0,39,0,6,15,2,13.0,2,0,6,13,3,13.0,1,15.5,2.8,-4.06,1 +Student_01532,1,17,9500,1,3,1,1,38,1,9,5,143.0,133.8,1,0,0,1,0,0,0,18,0,7,7,6,13.033333333333331,0,0,7,7,6,13.033333333333331,0,7.6,2.6,0.32,2 +Student_01533,2,15,9773,1,1,1,41,37,37,9,6,133.1,100.0,0,0,0,1,0,0,1,59,0,6,8,6,12.166666666666666,0,0,6,7,4,11.75,0,11.1,0.6,2.02,2 +Student_01534,1,7,9119,1,1,4,1,4,3,2,7,180.0,180.0,0,0,1,1,1,0,0,30,0,5,6,4,14.5,0,0,5,10,3,16.2,0,13.9,-0.3,0.79,1 +Student_01535,1,1,9085,1,1,1,1,1,38,9,9,136.0,130.8,1,0,0,1,0,0,0,18,0,5,7,5,14.4,1,0,5,5,5,13.6,0,12.7,3.7,-1.7,2 +Student_01537,1,39,9500,1,1,1,1,37,19,9,8,130.0,106.2,1,0,0,1,0,0,0,27,0,7,14,0,0.0,0,0,7,14,0,0.0,0,11.1,0.6,2.02,0 +Student_01538,1,1,9238,1,1,1,1,38,19,9,10,141.0,125.6,1,0,0,1,0,1,0,18,0,6,6,6,12.666666666666666,0,0,6,6,6,12.0,0,9.4,-0.8,-3.12,2 +Student_01539,1,18,9853,1,5,1,1,38,19,7,7,121.0,117.5,1,0,1,0,0,0,0,20,0,6,14,2,12.0,0,0,6,14,3,11.666666666666666,0,10.8,1.4,1.74,0 +Student_01540,2,39,9119,1,1,3,1,37,37,4,7,120.0,122.5,0,0,0,0,0,0,0,32,0,5,6,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_01541,1,17,9147,1,1,1,1,38,37,3,5,129.0,132.9,1,0,0,1,0,0,0,19,0,5,5,3,11.666666666666666,0,0,5,10,4,10.8,0,9.4,-0.8,-3.12,0 +Student_01544,1,7,9130,1,1,2,6,42,1,4,9,133.1,100.0,0,0,0,1,1,0,1,35,0,7,8,0,0.0,1,0,6,9,0,0.0,0,8.9,1.4,3.51,0 +Student_01548,2,39,9991,0,1,9,1,34,34,0,0,133.1,118.4,0,0,0,0,0,0,0,39,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_01549,2,7,9254,1,1,2,1,37,37,9,9,100.0,100.0,0,0,0,0,0,0,0,37,0,5,5,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_01550,5,39,9500,1,1,1,1,38,38,9,9,110.0,110.0,0,0,0,0,0,0,0,37,0,8,8,0,0.0,1,0,8,8,0,0.0,1,12.7,3.7,-1.7,0 +Student_01551,2,43,8014,0,1,1,1,34,34,0,0,133.1,100.0,0,0,0,1,0,1,0,35,11,16,16,16,12.6875,0,11,13,13,13,12.0,0,9.4,-0.8,-3.12,2 +Student_01552,1,43,9147,1,1,1,1,37,37,9,9,123.0,106.2,0,0,0,1,0,0,0,49,9,13,22,10,10.4,0,4,9,18,6,10.666666666666666,0,12.7,3.7,-1.7,2 +Student_01554,1,1,9085,1,2,1,1,1,38,5,5,130.0,122.3,1,0,0,1,0,0,0,18,0,5,10,5,14.333333333333334,2,0,5,8,5,13.0,1,9.4,-0.8,-3.12,2 +Student_01555,1,39,8014,0,1,1,1,37,37,9,9,133.1,112.5,0,0,0,1,0,1,0,30,0,7,7,6,14.666666666666666,1,0,6,7,6,14.333333333333334,0,10.8,1.4,1.74,2 +Student_01556,1,1,9500,1,2,1,1,NA,19,2,7,97.0,98.1,1,0,0,1,0,0,0,21,0,7,7,7,12.835714285714284,0,0,8,8,8,14.23125,0,11.1,0.6,2.02,2 +Student_01558,1,17,9147,1,1,1,1,1,38,6,6,139.0,143.6,1,0,1,1,NA,0,0,18,0,5,9,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,1 +Student_01559,1,16,171,1,1,1,NA,37,37,9,9,150.0,134.6,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,0 +Student_01560,1,1,9500,1,3,1,NA,3,19,2,10,141.0,126.8,1,0,0,1,1,0,0,18,0,8,8,8,13.24875,0,0,8,8,8,13.24875,0,9.4,-0.8,-3.12,2 +Student_01561,1,15,33,1,1,1,41,2,3,2,4,133.1,100.0,0,0,0,1,1,0,1,20,0,7,10,7,12.857142857142858,0,0,7,7,4,12.75,0,8.9,1.4,3.51,1 +Student_01564,1,44,9130,1,1,39,1,19,19,5,5,140.0,140.0,1,0,1,0,0,0,0,20,1,6,11,3,12.0,0,0,6,11,2,11.0,0,12.4,0.5,1.79,1 +Student_01566,1,17,9238,1,6,1,1,1,19,7,7,135.0,126.6,1,0,0,1,0,1,0,19,0,6,8,6,13.625,0,0,6,7,6,12.166666666666666,0,NA,3.7,-1.7,2 +Student_01567,1,17,9500,1,5,1,1,19,38,9,5,144.0,130.7,1,0,0,1,0,1,0,18,0,7,8,7,14.85,0,0,8,9,8,15.61111111111111,0,13.9,-0.3,0.79,2 +Student_01568,1,1,9147,1,2,1,1,1,19,4,4,108.0,105.9,1,0,0,1,1,0,0,21,0,5,9,4,10.75,0,0,5,6,5,11.4,0,11.1,0.6,2.02,2 +Student_01569,1,15,9556,1,1,1,26,19,1,9,4,137.0,137.0,0,0,1,1,0,0,1,19,0,7,11,0,0.0,4,0,7,11,2,11.666666666666666,0,8.9,1.4,3.51,1 +Student_01570,1,43,9130,1,1,1,NA,37,37,9,6,133.1,100.0,0,0,0,1,0,0,1,37,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,NA,0 +Student_01572,1,39,9003,1,1,19,1,37,37,9,10,NA,120.0,0,0,1,0,1,0,0,38,0,6,8,0,0.0,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_01573,6,39,9991,0,1,12,1,37,37,90,90,130.0,119.0,1,0,0,0,1,0,0,55,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_01575,5,7,9991,0,1,2,1,37,37,6,6,120.0,120.0,0,0,0,1,0,0,0,46,6,8,12,8,12.375,0,4,9,11,5,12.4,0,8.9,1.4,3.51,2 +Student_01576,1,NA,171,1,4,1,1,19,19,4,4,131.0,119.8,1,1,0,1,0,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,2 +Student_01577,2,39,9670,1,2,19,1,37,37,9,9,133.1,135.6,0,0,0,1,0,0,0,46,0,6,10,5,11.4,0,0,6,9,4,13.75,0,12.4,0.5,1.79,0 +Student_01578,1,39,9991,0,1,1,1,19,37,5,5,100.0,120.7,0,0,0,1,0,0,0,28,0,5,9,4,11.25,0,0,5,7,4,13.0,0,7.6,2.6,NA,1 +Student_01580,1,16,171,1,1,1,1,38,37,9,9,158.0,164.3,1,0,0,1,1,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,1 +Student_01581,1,1,9773,1,1,1,1,37,37,9,7,146.0,149.2,1,0,0,1,1,1,0,21,0,6,6,6,13.5,0,0,6,6,6,14.166666666666666,0,12.7,3.7,-1.7,2 +Student_01583,1,43,9991,0,1,1,1,19,37,3,9,120.0,100.0,0,0,0,1,NA,0,0,34,0,5,9,0,0.0,0,0,5,10,1,11.0,0,13.9,-0.3,0.79,0 +Student_01584,1,17,9853,1,1,1,1,37,38,9,9,119.0,125.0,1,0,0,1,0,1,0,21,0,6,9,5,12.0,0,0,6,8,5,11.2,0,10.8,1.4,1.74,0 +Student_01585,1,1,9773,1,1,1,1,37,19,9,9,132.0,131.0,1,0,0,1,0,1,0,18,0,6,8,5,13.0,0,0,6,7,6,13.0,0,15.5,2.8,-4.06,2 +Student_01586,1,1,171,1,1,1,1,29,38,9,8,130.0,122.0,1,0,0,1,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_01587,1,1,9147,1,1,1,1,38,37,7,7,132.0,131.3,1,0,0,1,0,0,0,18,0,5,8,4,12.0,0,0,5,8,4,12.25,0,9.4,-0.8,-3.12,1 +Student_01588,1,17,9119,1,2,1,1,1,2,3,3,133.1,117.0,1,0,0,1,1,0,0,21,0,5,10,5,11.166666666666666,0,0,5,10,3,10.8,0,12.4,0.5,1.79,1 +Student_01590,1,17,8014,0,2,1,1,1,19,4,99,134.0,126.0,1,0,0,1,1,0,0,22,0,6,7,6,12.666666666666666,0,0,6,6,6,12.166666666666666,0,7.6,2.6,0.32,2 +Student_01591,1,44,9003,1,1,39,1,1,19,4,7,120.0,120.0,0,0,0,1,1,0,0,23,1,6,6,1,11.0,0,0,6,8,0,0.0,0,15.5,2.8,NA,0 +Student_01593,1,1,9147,1,4,1,1,19,38,5,5,120.0,NA,1,0,0,1,1,0,0,18,0,5,6,4,11.5,0,0,5,12,2,10.333333333333334,0,10.8,1.4,1.74,1 +Student_01594,1,1,171,1,3,1,1,38,37,9,3,129.0,127.3,1,0,1,0,1,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01595,1,17,9147,1,1,1,1,1,38,9,9,118.0,118.4,1,0,0,1,1,0,0,19,0,5,10,2,10.5,0,0,5,5,4,11.75,0,12.4,0.5,1.79,1 +Student_01596,1,1,9670,1,1,1,1,1,37,4,9,127.0,128.1,0,0,0,1,1,0,0,19,0,5,8,4,12.5,0,0,5,6,4,11.0,0,7.6,2.6,0.32,1 +Student_01597,1,1,9500,1,2,1,1,37,37,9,9,133.1,99.0,1,0,0,1,1,0,0,22,0,7,9,6,12.833333333333334,0,0,8,12,6,12.5,0,16.2,0.3,-0.92,1 +Student_01598,1,1,9773,1,1,1,1,19,1,9,9,164.0,161.2,0,0,0,1,1,1,0,18,0,6,7,6,15.571428571428571,0,0,6,7,6,16.142857142857142,0,13.9,-0.3,0.79,2 +Student_01600,1,17,9773,1,1,1,1,38,38,9,9,117.0,111.1,0,0,1,1,1,0,0,19,0,6,6,4,11.25,0,0,6,6,3,11.333333333333334,0,16.2,0.3,-0.92,0 +Student_01601,1,1,171,1,4,1,1,1,1,0,3,131.0,149.9,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,2 +Student_01602,1,17,9670,1,6,1,1,1,19,4,10,110.0,111.3,0,0,0,1,1,0,0,21,0,6,10,6,12.285714285714286,0,0,6,11,4,14.25,0,15.5,2.8,-4.06,1 +Student_01603,1,1,9254,1,2,1,1,1,19,4,1,125.0,121.5,1,0,0,1,1,0,0,18,0,6,12,5,11.0,0,0,6,11,3,10.333333333333334,0,9.4,-0.8,-3.12,1 +Student_01604,1,44,9003,1,1,39,1,19,38,6,6,120.0,120.0,1,0,0,1,1,0,0,19,0,6,8,6,12.142857142857142,0,0,6,11,5,13.6,0,12.4,0.5,1.79,2 +Student_01605,1,39,9003,1,1,19,1,1,19,9,8,133.1,120.0,0,0,1,0,1,0,0,27,0,6,11,2,11.5,0,0,6,7,0,0.0,0,8.9,1.4,3.51,0 +Student_01606,1,53,9003,1,1,42,1,38,38,9,9,130.0,130.0,1,0,1,1,1,0,0,20,7,12,16,11,12.545454545454543,0,5,10,12,8,11.625,0,8.9,1.4,3.51,1 +Student_01607,1,1,9254,1,5,1,1,3,19,3,9,101.0,98.9,1,0,0,1,1,0,0,20,0,6,10,4,13.0,0,0,6,6,6,13.0,0,12.4,0.5,1.79,2 +Student_01608,1,1,9500,1,6,1,1,4,3,2,1,141.0,136.3,1,0,0,1,1,0,0,18,0,8,9,8,12.8875,1,0,8,9,8,12.8875,1,9.4,-0.8,-3.12,2 +Student_01609,1,17,9773,1,1,1,1,38,19,9,10,128.0,125.2,1,0,0,1,1,0,0,18,0,6,6,6,12.666666666666666,0,0,6,7,5,13.6,0,12.4,0.5,1.79,1 +Student_01610,1,1,9070,1,2,1,1,38,19,7,7,145.0,130.0,1,0,0,1,1,0,0,18,0,6,7,6,12.833333333333334,0,0,6,7,6,12.571428571428571,0,8.9,1.4,3.51,2 +Student_01615,2,39,8014,0,1,1,1,38,37,5,3,NA,110.5,0,0,0,1,0,1,0,36,0,6,6,6,11.833333333333334,0,0,6,6,6,11.5,0,10.8,1.4,1.74,2 +Student_01616,2,39,9085,1,1,19,1,19,19,9,5,133.1,101.0,1,0,0,1,0,0,0,26,0,6,21,3,12.666666666666666,0,0,6,15,2,11.0,0,15.5,2.8,-4.06,0 +Student_01617,1,1,9085,1,1,1,1,37,38,6,9,121.0,121.0,0,0,0,1,0,0,0,19,0,5,9,4,13.75,1,0,5,8,4,14.5,0,7.6,2.6,0.32,2 +Student_01618,1,39,8014,0,1,1,1,37,1,7,4,120.0,95.0,1,0,0,1,0,0,0,24,0,6,8,5,11.4,0,0,6,8,5,11.8,0,15.5,2.8,-4.06,0 +Student_01619,1,1,9773,1,2,1,109,19,1,9,9,130.0,126.9,1,0,0,1,0,1,1,19,0,6,8,6,13.166666666666666,0,0,6,6,6,13.0,0,11.1,0.6,2.02,0 +Student_01620,1,42,9670,1,1,1,1,1,1,9,10,130.0,116.3,1,0,0,1,0,1,0,20,3,7,10,6,12.833333333333334,0,2,8,8,5,11.8,0,12.7,3.7,-1.7,2 +Student_01621,1,18,9670,1,1,1,1,19,3,9,7,128.0,120.0,1,0,0,1,0,0,0,19,0,6,8,6,14.125,0,0,6,10,5,14.5,0,11.1,0.6,2.02,2 +Student_01623,2,39,9556,1,1,1,1,37,37,9,4,120.0,150.0,0,0,0,0,0,0,0,50,0,7,18,6,10.25,0,0,7,14,4,11.25,0,12.7,3.7,-1.7,0 +Student_01625,1,42,9853,1,1,1,1,1,19,4,7,120.0,111.3,0,0,0,1,0,0,0,24,9,13,17,10,11.5,0,7,13,18,9,NA,0,16.2,0.3,-0.92,0 +Student_01627,1,1,9085,1,1,1,1,37,2,9,4,127.0,123.2,1,0,0,1,0,1,0,18,0,6,7,6,15.714285714285714,0,0,6,17,5,12.77777777777778,0,12.4,0.5,1.79,2 +Student_01628,1,44,9991,0,1,39,1,37,37,5,5,130.0,130.0,1,0,0,1,1,0,0,32,2,6,9,4,12.5,0,3,7,7,4,11.0,0,9.4,-0.8,-3.12,0 +Student_01630,1,39,NA,1,1,1,1,37,38,9,8,120.0,100.0,0,0,1,1,1,0,0,24,0,5,11,0,0.0,0,0,5,5,0,0.0,0,16.2,0.3,-0.92,0 +Student_01632,2,39,9773,1,1,19,1,19,19,9,4,NA,131.0,0,0,1,0,1,0,0,42,0,4,5,0,0.0,0,0,4,4,0,0.0,0,13.9,-0.3,0.79,0 +Student_01633,2,39,9991,0,1,12,1,37,37,9,9,133.1,133.8,1,0,0,1,1,0,0,52,0,5,5,5,13.6,0,0,5,5,5,14.2,0,7.6,2.6,0.32,2 +Student_01634,1,43,8014,0,1,1,1,38,3,132,122,130.0,100.0,0,0,0,1,1,0,0,54,9,13,14,13,NA,0,7,11,12,11,12.818181818181818,0,12.7,3.7,-1.7,1 +Student_01637,2,39,9130,1,1,1,1,1,19,6,6,130.0,154.0,1,0,0,1,1,0,0,37,1,5,12,3,12.0,2,1,5,8,4,13.0,1,10.8,1.4,1.74,2 +Student_01638,1,1,9500,1,1,1,1,1,1,4,4,121.0,114.9,0,0,0,1,1,1,0,21,0,7,9,6,13.342857142857143,0,0,8,10,7,11.65,0,12.4,0.5,1.79,2 +Student_01639,1,39,9670,1,1,9,1,37,37,5,3,133.1,110.0,0,0,1,1,1,0,0,26,0,5,5,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01642,1,1,9070,1,2,1,1,38,38,9,7,164.0,165.8,1,0,0,1,0,0,0,18,0,6,7,6,14.166666666666666,0,0,6,7,6,14.857142857142858,0,9.4,-0.8,-3.12,2 +Student_01643,1,17,9500,1,5,1,1,1,1,4,4,137.0,127.6,1,0,0,1,0,0,0,18,0,7,7,7,13.528571428571428,0,0,8,9,8,14.655555555555557,0,12.4,0.5,1.79,2 +Student_01644,1,17,8014,0,2,1,1,37,19,9,9,122.0,123.8,0,0,0,1,0,0,0,20,0,6,8,5,12.0,0,0,6,8,6,11.0,0,10.8,1.4,1.74,2 +Student_01645,1,17,9254,1,4,1,1,3,3,3,3,124.0,126.1,1,0,0,1,0,0,0,20,0,5,5,5,11.4,0,0,6,11,1,11.0,0,10.8,1.4,1.74,0 +Student_01646,1,1,171,1,2,1,1,3,19,4,7,120.0,119.7,1,0,0,1,0,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,8.9,1.4,3.51,0 +Student_01647,1,1,171,1,2,1,1,1,19,3,3,117.0,121.6,1,0,0,1,0,0,0,22,6,12,12,12,12.916666666666666,0,4,11,16,11,14.5,0,8.9,1.4,3.51,2 +Student_01648,1,43,9500,1,1,NA,1,1,38,4,7,140.0,100.0,0,0,0,1,0,1,0,18,0,7,8,7,13.6375,0,0,8,8,8,14.3875,0,13.9,-0.3,0.79,2 +Student_01649,1,1,9500,1,5,1,1,19,37,9,7,130.0,127.6,1,0,0,1,0,0,0,18,0,7,10,7,12.9,0,0,8,15,7,12.142857142857142,0,15.5,2.8,-4.06,0 +Student_01652,1,1,9500,1,3,1,1,1,1,4,7,142.0,131.0,1,0,0,1,0,0,0,18,0,8,8,7,14.7,0,0,8,8,7,14.7,0,10.8,1.4,1.74,2 +Student_01654,1,1,9556,1,3,1,1,19,19,3,10,122.0,113.3,1,0,0,1,0,1,0,20,0,7,7,7,13.0,0,0,8,8,8,15.0625,0,12.4,0.5,1.79,2 +Student_01655,1,1,9853,1,2,1,1,1,1,2,9,131.0,121.9,1,0,0,1,0,0,0,20,0,6,6,6,13.5,0,0,6,6,0,0.0,0,12.7,3.7,-1.7,0 +Student_01656,1,1,9085,1,2,1,1,38,1,9,3,120.0,118.3,1,0,0,1,0,0,0,20,0,5,11,5,12.333333333333334,2,0,5,7,5,12.6,0,9.4,-0.8,-3.12,2 +Student_01657,1,1,9147,1,1,1,1,3,19,1,4,131.0,118.8,0,0,0,1,0,0,0,19,0,5,6,5,13.4,0,0,5,6,5,13.0,0,16.2,0.3,-0.92,2 +Student_01658,1,1,9085,1,2,1,1,37,19,9,8,130.0,129.0,0,0,0,1,0,0,0,20,0,5,7,4,11.75,0,0,5,9,2,10.5,0,7.6,2.6,0.32,1 +Student_01659,1,43,171,1,3,1,1,37,37,9,9,120.0,143.3,1,0,0,1,0,1,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_01661,1,53,9085,1,1,42,1,1,19,4,6,160.0,155.7,1,0,0,1,0,0,0,27,7,12,17,11,14.727272727272728,0,4,9,10,7,14.142857142857142,0,8.9,1.4,3.51,2 +Student_01662,1,1,9085,1,2,1,1,3,3,5,2,157.0,153.9,1,0,0,1,0,0,0,18,0,6,7,6,16.571428571428573,0,0,6,6,6,15.666666666666666,0,13.9,-0.3,0.79,2 +Student_01663,1,1,9500,1,1,1,1,19,1,4,4,150.0,137.8,0,0,0,1,0,0,0,18,0,7,10,7,15.145,0,0,8,8,8,15.7425,0,15.5,2.8,-4.06,2 +Student_01665,1,1,9085,1,1,1,1,37,37,9,1,120.0,123.2,0,0,0,1,0,0,0,20,0,5,8,5,14.166666666666666,2,0,5,6,4,11.75,2,9.4,-0.8,-3.12,2 +Student_01666,1,1,9773,1,1,1,1,1,1,4,4,150.0,138.1,1,0,0,1,0,0,0,19,0,6,7,6,14.0,0,0,6,7,5,15.0,0,11.1,0.6,2.02,1 +Student_01667,1,17,9238,1,1,1,1,1,1,5,6,158.0,140.5,0,0,0,1,0,1,0,20,0,6,9,6,11.333333333333334,0,0,6,6,6,12.333333333333334,0,10.8,1.4,1.74,2 +Student_01668,1,1,9500,1,4,1,1,3,19,1,NA,145.0,130.0,1,0,0,1,0,0,0,18,0,8,8,8,13.76125,0,0,8,8,8,13.76125,0,9.4,-0.8,-3.12,2 +Student_01669,1,44,9070,1,1,39,1,1,38,4,6,100.0,104.8,0,0,1,0,0,0,0,22,2,7,9,5,11.6,0,5,9,9,5,10.0,0,12.4,0.5,1.79,0 +Student_01671,1,39,9991,0,1,1,1,1,1,4,2,133.1,127.7,0,0,0,1,0,0,0,25,0,5,12,4,12.5,0,0,5,10,4,11.0,0,13.9,-0.3,0.79,1 +Student_01672,1,1,9085,1,1,1,1,19,3,4,2,148.0,136.5,0,0,0,1,0,0,0,19,0,6,13,6,15.307692307692308,0,0,6,9,6,14.0,0,15.5,2.8,-4.06,2 +Student_01674,1,39,9500,1,1,40,1,1,1,4,NA,130.0,190.0,1,0,0,1,0,0,0,27,1,7,7,7,14.757142857142856,0,1,8,9,8,14.077777777777778,0,16.2,0.3,-0.92,2 +Student_01675,1,17,9500,1,4,1,1,1,1,4,9,136.0,128.5,1,0,0,1,0,0,0,18,0,7,7,6,12.766666666666666,0,0,7,7,6,12.766666666666666,0,7.6,2.6,0.32,2 +Student_01676,1,17,9254,1,3,1,1,1,1,4,4,122.0,126.6,0,0,0,0,0,0,0,18,0,5,5,5,10.4,0,0,6,13,0,0.0,0,10.8,1.4,1.74,0 +Student_01677,1,17,9556,1,1,1,1,3,3,1,7,140.0,131.6,1,0,0,1,1,0,0,19,0,7,0,0,0.0,0,0,7,0,0,0.0,0,11.1,0.6,2.02,0 +Student_01679,1,17,9085,1,1,1,1,37,36,4,90,130.0,127.6,0,0,0,1,1,0,0,23,0,5,6,4,14.25,0,0,5,6,5,13.4,0,7.6,2.6,0.32,2 +Student_01680,1,39,9500,1,1,1,1,1,37,9,9,133.1,100.0,0,0,0,1,1,0,0,28,0,7,11,3,11.916666666666666,1,0,7,17,0,0.0,0,16.2,0.3,-0.92,0 +Student_01682,1,1,9773,1,1,1,1,1,19,4,4,117.0,109.3,0,0,0,1,1,0,0,19,0,6,11,4,12.25,0,0,6,10,3,12.666666666666666,0,7.6,2.6,0.32,1 +Student_01683,1,1,9670,1,2,1,1,19,1,9,4,124.0,117.7,1,0,1,1,1,0,0,20,0,5,5,4,12.0,0,0,5,6,5,11.6,0,9.4,-0.8,-3.12,0 +Student_01684,1,1,9670,1,1,1,1,2,2,3,3,124.0,124.7,1,0,0,1,1,0,0,21,0,5,7,3,11.0,0,0,5,5,4,12.75,0,7.6,2.6,0.32,0 +Student_01686,1,1,9070,1,5,1,1,3,3,2,2,125.0,140.8,1,0,0,1,1,0,0,22,0,6,6,6,14.666666666666666,0,0,6,6,6,15.0,0,9.4,-0.8,-3.12,2 +Student_01687,1,17,9085,1,3,1,1,38,1,9,9,121.0,111.9,1,0,0,1,1,0,0,21,0,5,11,0,0.0,0,0,5,10,5,12.285714285714286,1,10.8,1.4,1.74,2 +Student_01688,1,7,9556,1,1,3,1,3,3,2,2,140.0,140.0,0,0,1,0,1,0,0,38,0,7,8,3,12.666666666666666,0,0,5,5,0,0.0,0,13.9,-0.3,0.79,0 +Student_01689,1,1,171,1,1,1,1,19,1,9,9,124.0,121.2,1,0,0,1,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,1 +Student_01690,1,43,171,1,4,1,1,37,37,9,9,136.0,123.8,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,0 +Student_01691,1,7,9119,1,1,1,1,34,34,0,0,140.8,134.0,0,0,0,1,1,0,0,24,0,5,0,0,0.0,0,0,5,0,0,0.0,0,7.6,2.6,0.32,0 +Student_01692,1,18,9070,1,3,1,1,1,37,4,7,142.0,130.8,1,0,0,0,1,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_01694,1,1,9147,1,1,1,1,3,19,3,10,131.0,123.3,0,0,0,1,1,0,0,19,0,5,7,5,11.8,0,0,5,8,4,12.4,2,16.2,0.3,-0.92,1 +Student_01695,1,39,9119,1,1,3,1,3,3,3,10,130.0,147.6,0,0,0,1,1,0,0,NA,0,5,0,0,0.0,0,0,5,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01696,1,17,9670,1,1,1,1,38,37,9,8,120.0,113.4,1,0,0,1,1,1,0,19,0,6,6,6,13.333333333333334,0,0,6,7,6,13.285714285714286,0,8.9,1.4,3.51,2 +Student_01697,1,17,9070,1,1,1,1,19,38,4,5,141.0,133.7,1,0,0,1,1,0,0,22,0,6,7,5,11.4,0,0,6,6,6,12.166666666666666,0,7.6,2.6,0.32,2 +Student_01698,1,39,9085,1,1,1,1,34,1,0,2,130.0,128.2,0,0,0,1,1,0,0,25,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_01699,1,1,9500,1,1,1,1,1,1,5,5,168.0,161.0,1,0,0,1,1,0,0,18,0,7,7,7,16.142857142857142,0,0,8,9,0,0.0,0,16.2,0.3,-0.92,0 +Student_01700,1,7,9500,1,1,3,1,37,37,90,90,130.0,130.0,1,0,0,1,1,0,0,30,0,8,8,0,0.0,8,0,8,8,0,0.0,8,9.4,-0.8,-3.12,0 +Student_01701,1,1,9500,1,1,1,1,38,37,9,9,156.0,156.3,0,0,0,1,1,1,0,18,0,8,8,8,15.63375,0,0,8,8,8,15.63375,0,9.4,-0.8,-3.12,2 +Student_01703,1,17,9773,1,6,1,1,34,34,0,0,131.0,129.3,0,0,0,1,1,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_01704,1,1,9238,1,1,1,1,38,38,7,7,130.0,136.3,1,0,0,1,1,0,0,18,0,6,8,6,12.5,0,0,6,7,6,11.5,0,10.8,1.4,1.74,2 +Student_01705,1,39,9670,1,1,1,1,1,19,4,9,133.1,140.0,0,0,0,1,1,1,0,25,0,6,8,6,12.285714285714286,0,0,6,6,6,13.0,0,15.5,2.8,-4.06,2 +Student_01706,1,1,9119,1,1,1,1,3,1,4,1,131.0,135.9,0,0,0,1,1,0,0,18,0,5,10,2,14.0,0,0,5,7,3,11.0,1,7.6,2.6,0.32,1 +Student_01707,1,1,171,1,5,1,1,1,1,4,4,160.0,139.7,0,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_01708,1,1,9147,1,4,1,1,1,38,8,9,117.0,117.0,1,0,0,1,1,0,0,19,0,5,5,4,10.75,0,0,5,6,4,12.25,0,12.4,0.5,1.79,1 +Student_01709,1,39,9556,1,1,19,1,19,1,7,10,133.1,105.0,0,0,0,1,1,0,0,25,0,7,14,4,12.95,1,0,7,11,4,13.125,1,15.5,2.8,-4.06,0 +Student_01710,1,1,9500,1,3,1,1,37,38,9,5,130.0,130.5,1,0,0,1,0,0,0,19,0,7,7,6,12.45,0,0,7,7,6,12.45,0,7.6,2.6,0.32,2 +Student_01711,1,44,9991,0,1,39,1,37,37,9,9,130.0,130.0,0,0,0,1,0,0,0,31,2,6,12,4,12.25,0,3,7,9,7,12.0,0,9.4,-0.8,-3.12,1 +Student_01712,1,1,9500,1,3,1,1,19,19,5,4,137.0,131.5,1,0,0,1,0,1,0,20,0,8,8,8,13.38125,0,0,8,8,8,13.38125,0,9.4,-0.8,-3.12,2 +Student_01713,1,42,9500,1,1,1,41,3,1,3,10,133.1,100.0,1,0,0,0,0,0,1,33,1,7,10,5,12.16,0,0,6,7,5,11.34,0,12.4,0.5,1.79,0 +Student_01714,1,44,9085,1,1,39,1,1,3,9,4,140.0,140.0,0,0,1,0,0,0,0,24,2,6,11,4,12.5,0,1,6,18,2,11.5,0,12.4,0.5,1.79,1 +Student_01715,1,17,9238,1,4,1,1,19,37,9,9,140.0,130.2,1,0,0,1,0,1,0,18,0,6,8,6,12.75,0,0,6,10,6,12.166666666666666,0,12.7,3.7,-1.7,2 +Student_01716,1,17,9500,1,2,1,1,1,19,4,10,135.0,133.5,1,0,0,1,0,0,0,19,0,8,8,8,13.3425,0,0,8,8,8,13.3425,0,9.4,-0.8,-3.12,2 +Student_01717,1,NA,9500,1,4,1,1,38,38,7,7,140.0,133.2,1,0,0,1,0,1,0,20,0,7,10,7,14.175,0,0,8,14,6,13.03125,0,15.5,2.8,-4.06,2 +Student_01718,2,39,9500,1,1,1,1,37,38,4,4,100.0,130.0,0,0,0,1,1,1,0,33,0,8,16,1,10.0,1,0,8,16,1,10.0,1,12.7,3.7,-1.7,1 +Student_01720,1,39,9991,0,1,19,1,2,1,2,4,133.1,100.0,0,0,0,1,1,0,0,24,0,5,7,0,0.0,0,0,5,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_01721,1,17,9085,1,1,1,1,38,37,9,9,128.0,116.5,1,0,0,NA,1,0,0,18,0,5,6,5,12.0,0,0,5,8,5,12.142857142857142,0,10.8,1.4,1.74,2 +Student_01722,1,1,9254,1,2,1,1,37,37,9,9,NA,124.2,1,0,0,1,0,1,0,18,0,6,8,6,10.571428571428571,0,0,6,9,5,11.4,0,16.2,0.3,-0.92,2 +Student_01723,1,51,9085,1,1,1,1,3,3,2,8,127.0,138.8,1,0,0,1,0,0,0,22,4,12,19,11,14.153846153846152,0,5,12,20,12,15.428571428571429,0,8.9,1.4,3.51,2 +Student_01725,1,1,171,1,1,1,1,19,19,3,10,147.0,151.9,1,0,0,1,0,0,0,21,13,17,20,17,12.0,0,14,17,18,17,12.666666666666666,0,11.1,0.6,2.02,2 +Student_01726,2,39,9991,0,1,1,1,37,37,5,NA,110.0,120.0,1,0,0,1,0,0,0,38,0,5,11,3,11.333333333333334,0,0,5,9,4,12.0,0,9.4,-0.8,-3.12,0 +Student_01727,1,43,9238,1,1,1,1,34,34,99,99,142.0,131.9,0,0,0,1,0,1,0,29,9,16,17,16,12.588235294117649,0,10,13,14,13,13.357142857142858,0,9.4,-0.8,-3.12,2 +Student_01728,1,44,9130,1,1,39,1,38,37,4,9,130.0,130.0,1,0,0,1,0,1,0,20,0,6,11,4,12.0,0,0,6,9,4,10.75,0,16.2,0.3,-0.92,1 +Student_01729,1,NA,9254,1,1,1,1,38,37,4,9,131.0,131.7,1,0,0,0,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_01730,2,43,9991,0,1,1,1,37,37,9,9,110.0,132.5,0,0,0,1,1,0,0,37,7,12,13,12,12.25,0,8,13,13,13,12.846153846153848,0,9.4,-0.8,-3.12,2 +Student_01732,1,1,9130,1,1,1,1,19,19,90,8,136.0,133.9,1,0,0,0,1,0,0,20,0,5,7,4,13.0,0,0,5,11,3,12.0,2,10.8,1.4,1.74,0 +Student_01734,2,39,8014,0,1,1,1,37,3,9,10,140.0,172.0,0,0,0,1,1,0,0,44,5,11,21,9,NA,0,8,11,16,9,11.0,0,12.4,0.5,1.79,1 +Student_01735,1,1,9147,1,1,1,1,1,1,9,9,118.0,111.0,0,0,0,0,1,0,0,21,0,5,7,2,11.0,0,0,5,9,3,11.428571428571429,0,10.8,1.4,1.74,0 +Student_01736,1,44,9070,1,1,NA,1,2,19,3,8,120.0,120.0,0,0,0,1,1,0,0,21,2,7,10,6,13.428571428571429,0,5,9,9,8,13.125,0,16.2,0.3,-0.92,2 +Student_01737,1,1,9500,1,6,1,1,3,1,2,1,151.0,129.8,1,0,0,1,1,0,0,18,0,8,10,8,13.05375,2,0,8,10,8,13.05375,2,9.4,-0.8,-3.12,2 +Student_01738,1,1,9500,1,5,1,1,1,3,9,10,130.0,118.1,1,0,0,1,1,0,0,18,0,7,10,6,12.035714285714286,0,0,8,9,7,13.75,0,NA,-0.3,0.79,1 +Student_01739,1,39,9003,1,1,1,1,3,1,5,9,140.0,130.0,0,0,0,1,1,0,0,27,0,6,6,6,14.166666666666666,0,0,6,7,6,13.833333333333334,0,11.1,0.6,2.02,2 +Student_01740,2,39,9070,1,1,19,1,37,37,9,10,133.1,126.3,0,0,0,0,1,0,0,38,0,6,6,0,0.0,0,0,6,8,0,0.0,0,10.8,1.4,1.74,0 +Student_01741,1,18,9130,1,1,1,1,3,3,5,2,146.0,137.8,0,0,0,1,1,0,0,18,0,6,11,5,13.6,0,0,6,13,3,12.666666666666666,0,13.9,-0.3,0.79,0 +Student_01743,1,1,9130,1,1,1,1,3,19,2,9,121.0,115.4,1,0,0,1,1,0,0,18,0,6,8,6,13.714285714285714,0,0,6,7,5,13.333333333333334,0,15.5,2.8,-4.06,0 +Student_01744,1,43,9773,1,1,1,1,1,1,9,6,127.0,110.0,0,0,1,0,1,0,0,19,0,6,10,3,11.666666666666666,0,0,6,11,2,10.0,0,16.2,0.3,-0.92,0 +Student_01745,1,39,9670,1,1,1,1,37,37,90,90,133.1,97.4,0,0,1,0,1,0,0,44,0,6,9,1,14.0,0,0,6,6,0,0.0,0,12.7,3.7,-1.7,0 +Student_01746,1,44,9085,1,1,39,1,1,1,4,4,130.0,130.0,1,1,0,1,1,0,0,26,2,6,20,4,12.5,0,1,6,16,3,10.0,0,15.5,2.8,-4.06,0 +Student_01747,1,43,9130,1,1,1,1,19,1,9,NA,156.0,156.0,0,0,1,0,1,0,0,24,0,6,11,5,11.833333333333334,0,0,6,11,4,11.5,0,15.5,2.8,-4.06,0 +Student_01748,1,39,9003,1,1,1,1,19,1,9,6,130.0,126.1,1,0,0,0,1,0,0,27,0,6,6,0,0.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_01749,1,39,9003,1,1,1,1,1,1,9,4,110.0,120.0,0,0,1,0,1,0,0,27,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_01750,1,43,9070,1,1,1,1,38,38,7,7,108.0,105.2,1,0,0,1,1,0,0,25,11,17,18,13,11.538461538461538,0,10,15,15,10,12.4,0,12.7,3.7,-1.7,0 +Student_01751,1,44,9003,1,1,1,1,3,2,2,6,NA,120.0,1,0,0,1,1,0,0,21,4,9,14,7,11.285714285714286,2,2,8,15,4,12.25,0,12.7,3.7,-1.7,1 +Student_01753,1,17,9070,1,2,1,1,39,39,3,3,152.0,134.2,1,0,0,1,1,0,0,NA,0,6,7,5,11.8,0,0,6,9,4,12.0,0,15.5,2.8,-4.06,1 +Student_01754,1,44,9119,1,1,39,1,19,3,5,2,150.0,150.0,0,0,0,1,1,0,0,20,0,5,16,0,0.0,0,0,5,12,2,10.5,0,12.7,3.7,-1.7,1 +Student_01755,1,17,9119,1,5,1,1,3,1,2,9,123.0,116.0,1,0,1,0,1,0,0,20,0,5,5,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_01756,1,1,9119,1,1,1,NA,1,1,3,3,150.0,143.4,0,0,0,0,1,1,0,18,0,5,5,5,14.2,0,0,5,5,5,14.2,0,8.9,1.4,3.51,1 +Student_01757,1,17,171,1,1,1,1,4,4,3,3,145.0,143.6,0,0,1,1,1,0,0,19,5,12,12,10,12.7,0,4,11,16,10,12.272727272727272,0,8.9,1.4,3.51,1 +Student_01759,1,1,9670,1,4,1,1,4,19,2,5,125.0,118.0,1,0,0,1,0,0,0,19,0,6,7,6,14.428571428571429,0,0,6,8,6,15.0,2,16.2,0.3,-0.92,2 +Student_01760,1,1,9500,1,4,1,1,1,1,4,7,117.0,109.3,1,0,0,1,0,1,0,18,0,7,7,7,13.117142857142856,0,0,8,9,7,12.6,0,11.1,0.6,2.02,2 +Student_01761,1,1,9238,1,2,1,1,19,19,191,171,121.0,119.3,1,0,1,1,0,0,0,20,0,6,7,6,12.666666666666666,0,0,6,7,6,11.833333333333334,0,8.9,1.4,3.51,2 +Student_01764,NA,15,9147,1,1,1,26,37,2,6,4,140.0,140.0,0,0,1,1,1,0,1,19,0,5,12,3,10.5,0,0,5,8,4,11.25,0,12.4,0.5,1.79,2 +Student_01766,1,1,9147,1,1,1,1,19,38,9,9,140.0,129.2,1,0,0,1,0,0,0,26,0,5,6,0,0.0,0,0,5,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01767,1,39,9003,1,1,1,41,1,1,9,9,140.0,100.0,0,0,1,0,0,0,1,29,3,9,9,3,14.333333333333334,0,1,7,8,1,14.0,0,15.5,2.8,-4.06,0 +Student_01768,1,44,9254,1,1,39,1,19,2,9,3,170.0,170.0,0,0,0,0,1,0,0,26,2,8,14,8,15.125,0,1,6,12,6,13.666666666666666,0,11.1,0.6,2.02,1 +Student_01769,1,7,9500,1,1,3,1,3,19,2,6,140.0,140.0,0,0,0,1,1,0,0,27,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.4,0.5,1.79,0 +Student_01770,1,51,9147,1,1,1,1,3,3,2,2,116.0,115.2,0,0,1,1,1,0,0,32,2,7,16,3,12.0,0,3,8,10,3,10.333333333333334,0,8.9,1.4,3.51,1 +Student_01771,1,16,9853,1,3,1,1,37,19,9,5,134.0,121.4,1,0,0,1,0,1,0,23,0,6,10,4,14.25,1,0,6,8,5,12.0,0,7.6,2.6,0.32,1 +Student_01772,1,39,9147,1,1,1,41,38,38,9,8,133.1,134.8,0,0,0,1,0,0,1,24,0,5,12,2,10.5,0,0,5,9,4,10.0,2,16.2,0.3,-0.92,1 +Student_01774,1,42,9003,1,1,1,1,19,19,4,4,140.0,140.0,1,0,0,1,1,0,0,25,0,6,14,5,11.666666666666666,0,0,6,11,4,12.0,0,15.5,2.8,-4.06,1 +Student_01776,1,1,9773,1,3,1,1,1,3,0,0,149.0,148.7,0,0,0,0,1,0,0,20,0,4,4,0,0.0,0,0,4,8,0,0.0,0,10.8,1.4,1.74,0 +Student_01777,2,1,9254,1,1,1,1,19,38,4,7,140.0,133.0,0,0,0,1,1,0,0,33,3,9,11,9,12.8,0,2,7,9,7,11.428571428571429,0,12.7,3.7,-1.7,2 +Student_01778,2,39,9991,0,1,1,1,37,12,9,9,140.0,150.0,0,0,1,1,1,0,0,35,0,5,6,5,10.8,0,0,5,7,5,12.0,2,9.4,-0.8,-3.12,0 +Student_01780,1,1,9500,1,1,1,1,37,19,9,9,125.0,122.4,1,0,0,1,1,0,0,19,0,7,7,7,13.725714285714286,0,0,8,8,8,14.5,0,11.1,0.6,2.02,2 +Student_01781,1,1,9670,1,1,1,1,1,37,9,10,133.1,139.0,0,0,0,1,1,0,0,21,0,6,6,5,12.8,0,0,6,9,5,12.25,0,10.8,1.4,1.74,1 +Student_01783,1,39,9500,1,1,1,1,37,37,3,7,130.0,143.8,0,0,0,1,1,0,0,27,0,8,8,7,15.57,0,0,8,8,7,15.57,0,10.8,1.4,1.74,0 +Student_01784,1,17,9147,1,3,1,1,NA,38,123,171,122.0,116.1,1,0,1,1,1,0,0,19,0,5,10,4,11.0,0,0,5,13,2,12.0,0,8.9,1.4,3.51,1 +Student_01785,1,7,9500,1,2,3,1,37,38,9,9,140.0,138.0,0,0,0,1,1,0,0,28,0,7,7,7,14.114285714285714,0,0,8,9,8,15.91111111111111,0,16.2,0.3,-0.92,0 +Student_01786,1,43,9147,1,1,1,1,37,38,7,7,123.0,110.0,0,0,0,1,1,0,0,25,0,5,12,3,NA,1,0,5,12,4,11.5,0,9.4,-0.8,-3.12,1 +Student_01788,1,7,9991,0,1,3,1,37,37,9,9,140.0,140.0,0,0,0,1,1,0,0,27,0,5,6,4,13.5,0,0,5,6,4,13.75,0,7.6,2.6,0.32,2 +Student_01789,1,1,9070,1,1,1,1,3,3,0,1,116.0,108.7,1,0,0,1,1,0,0,23,0,6,9,4,11.25,1,0,6,10,0,0.0,4,7.6,2.6,0.32,0 +Student_01790,1,17,9254,1,3,1,1,19,1,4,4,118.0,115.9,1,0,0,1,1,1,0,18,0,6,7,6,12.142857142857142,0,0,6,8,6,11.333333333333334,0,8.9,1.4,3.51,2 +Student_01791,2,39,9500,1,1,1,1,37,37,9,4,140.0,127.3,0,0,0,1,1,0,0,26,0,8,8,7,13.075714285714286,0,0,8,8,7,13.075714285714286,0,10.8,1.4,1.74,2 +Student_01794,1,17,9085,1,1,1,1,1,1,4,7,137.0,134.6,1,0,0,1,1,0,0,22,0,6,16,0,0.0,0,0,6,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_01795,1,43,9500,1,1,1,1,19,37,173,183,136.0,118.4,1,0,0,1,0,0,0,21,0,7,12,4,13.125,0,0,7,8,6,12.333333333333334,0,13.9,-0.3,0.79,1 +Student_01796,1,1,9500,1,3,1,1,38,38,7,9,134.0,132.8,1,0,0,1,0,1,0,19,0,8,8,7,13.512857142857142,0,0,8,8,7,13.512857142857142,0,10.8,1.4,1.74,2 +Student_01797,1,1,NA,1,1,1,1,38,37,9,7,160.0,155.5,1,0,0,1,0,1,0,18,0,6,7,6,12.833333333333334,0,0,6,6,6,12.166666666666666,0,10.8,1.4,1.74,2 +Student_01798,1,1,9085,1,3,1,1,38,1,9,9,126.0,132.0,1,0,0,1,0,1,0,NA,0,5,8,3,15.0,2,0,5,9,3,11.666666666666666,0,9.4,-0.8,-3.12,0 +Student_01799,1,39,9003,1,1,19,1,37,38,4,9,133.1,110.0,0,0,1,0,0,0,0,40,0,6,12,5,12.8,0,0,6,16,3,13.333333333333334,0,11.1,0.6,2.02,0 +Student_01800,1,NA,9254,1,3,1,26,38,3,9,3,114.0,127.3,1,0,1,0,0,0,1,20,0,6,14,3,12.333333333333334,0,0,6,16,0,0.0,0,10.8,1.4,1.74,0 +Student_01803,1,1,9147,1,2,1,1,1,1,9,9,131.0,118.8,0,0,0,1,1,1,0,18,0,5,9,4,11.5,0,0,5,5,5,12.8,0,12.4,0.5,1.79,2 +Student_01804,1,43,9670,1,2,1,1,19,1,4,4,130.0,127.6,1,0,0,1,1,0,0,22,4,6,6,6,11.833333333333334,0,0,6,11,4,11.142857142857142,0,10.8,1.4,1.74,0 +Student_01805,1,51,9147,1,1,NA,1,19,19,9,5,133.1,112.1,0,0,1,0,1,0,0,38,0,5,5,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_01807,1,1,9119,1,3,1,1,1,1,3,5,117.0,111.1,0,0,0,1,1,1,0,NA,0,5,10,5,11.8,0,0,5,12,3,11.5,0,11.1,0.6,2.02,1 +Student_01810,1,51,9991,0,1,1,1,1,1,5,3,134.0,120.6,1,0,0,1,1,0,0,27,2,6,6,6,12.333333333333334,0,0,5,5,5,13.0,0,11.1,0.6,2.02,2 +Student_01811,1,39,9254,1,1,1,1,37,37,9,9,130.0,126.5,0,0,0,1,1,0,0,26,0,6,7,6,12.428571428571429,0,0,6,6,6,12.833333333333334,0,7.6,2.6,0.32,2 +Student_01812,1,1,9500,1,6,1,1,1,19,3,3,127.0,120.2,1,0,0,1,0,1,0,19,0,7,7,7,12.765714285714289,0,0,8,9,8,13.544444444444444,0,12.4,0.5,1.79,2 +Student_01813,2,51,9500,1,1,1,1,37,37,5,5,130.0,120.0,0,0,0,1,1,0,0,44,0,7,11,5,12.1,0,0,7,10,5,12.6,0,11.1,0.6,2.02,0 +Student_01814,1,1,9147,1,2,1,1,37,38,9,9,142.0,137.5,1,0,0,1,1,0,0,19,0,5,10,5,12.0,0,0,5,9,5,11.5,0,13.9,-0.3,0.79,2 +Student_01815,1,18,9070,1,1,1,1,1,37,4,7,117.0,127.9,1,0,0,1,1,0,0,20,0,6,6,0,0.0,0,0,6,6,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01817,4,43,9991,0,1,1,1,37,37,6,6,164.0,131.8,0,0,0,1,0,0,0,31,7,14,19,13,11.357142857142858,0,9,14,14,13,12.0,1,9.4,-0.8,-3.12,2 +Student_01818,1,43,9070,1,1,1,1,37,37,9,9,130.0,129.0,1,0,0,1,0,0,0,25,0,6,6,6,13.5,0,0,6,6,6,12.5,0,9.4,-0.8,-3.12,2 +Student_01819,1,17,9773,1,4,1,1,2,37,9,9,127.0,115.8,1,0,1,0,0,0,0,19,0,6,6,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_01820,1,17,9500,1,3,1,1,3,2,3,3,140.0,126.4,1,0,0,1,0,0,0,18,0,7,7,7,13.884285714285712,0,0,8,9,8,14.75,0,11.1,0.6,2.02,0 +Student_01821,1,43,9085,1,1,1,1,19,38,4,9,130.0,130.0,1,0,0,0,0,0,0,19,0,6,12,5,13.0,0,0,6,12,3,11.666666666666666,0,13.9,-0.3,0.79,1 +Student_01823,1,17,9147,1,1,1,1,1,38,4,5,162.0,138.6,1,0,0,1,NA,0,0,19,0,5,10,1,11.0,0,0,5,13,0,0.0,0,12.7,3.7,-1.7,1 +Student_01824,1,39,9670,1,1,1,1,1,1,4,4,133.1,112.9,0,0,0,1,0,0,0,24,0,6,12,2,11.666666666666666,0,0,6,20,2,10.5,6,16.2,0.3,-0.92,0 +Student_01825,1,1,9238,1,1,1,1,3,3,3,3,120.0,111.6,0,0,0,1,0,0,0,20,0,6,6,6,14.5,0,0,6,6,6,12.666666666666666,0,12.4,0.5,1.79,2 +Student_01827,1,1,9238,1,1,1,1,38,1,5,7,141.0,132.6,0,0,0,1,NA,1,0,18,0,6,7,6,13.285714285714286,0,0,6,6,6,14.333333333333334,0,12.4,0.5,1.79,2 +Student_01828,1,17,9085,1,1,1,1,1,38,4,9,125.0,118.4,1,0,0,1,0,0,0,21,0,5,13,3,11.333333333333334,2,0,5,12,2,10.5,1,9.4,-0.8,-3.12,1 +Student_01830,1,1,9147,1,1,1,1,38,37,5,6,128.0,122.1,0,0,0,1,0,1,0,18,0,5,11,4,11.571428571428571,0,0,5,9,5,12.0,0,13.9,-0.3,0.79,1 +Student_01831,1,1,9853,1,1,1,1,37,19,9,8,162.0,142.8,0,0,1,1,0,0,0,18,0,6,10,5,13.0,0,0,6,10,4,11.5,0,12.7,3.7,-1.7,0 +Student_01832,1,1,9238,1,1,1,1,1,1,4,4,130.0,124.8,0,0,0,1,0,1,0,18,0,6,9,6,11.5,0,0,6,11,5,14.0,0,11.1,0.6,2.02,2 +Student_01833,1,17,9147,1,2,1,1,37,19,9,8,134.0,126.3,1,0,0,1,0,1,0,18,0,5,8,5,11.8,0,0,5,10,5,11.6,3,16.2,0.3,-0.92,2 +Student_01834,1,1,9147,1,1,1,1,19,19,9,9,133.1,119.0,1,0,0,0,0,1,0,19,0,5,7,3,10.666666666666666,0,0,5,10,3,12.285714285714286,0,10.8,1.4,1.74,0 +Student_01835,1,17,9500,1,1,1,1,19,38,3,9,137.0,124.9,0,0,0,1,0,1,0,19,0,7,11,6,13.8875,0,0,8,9,8,14.864444444444445,0,15.5,2.8,-4.06,2 +Student_01836,1,1,9238,1,1,1,1,38,38,191,192,133.1,118.0,0,0,1,1,0,1,0,20,0,6,7,5,11.4,0,0,6,9,6,11.5,0,8.9,1.4,3.51,2 +Student_01838,2,39,9500,1,1,1,1,37,37,9,9,133.1,109.0,1,0,0,1,0,0,0,39,0,7,8,5,12.16,0,0,7,8,5,12.16,0,7.6,2.6,0.32,1 +Student_01839,1,17,9500,1,3,1,1,3,19,2,5,133.0,130.8,1,0,0,1,0,0,0,19,0,8,8,8,13.427499999999998,0,0,8,8,8,13.427499999999998,0,9.4,-0.8,-3.12,2 +Student_01840,1,39,9070,1,1,1,1,1,19,4,4,130.0,110.0,1,0,0,1,0,0,0,24,0,6,6,6,15.166666666666666,0,0,6,6,2,15.5,0,15.5,2.8,-4.06,2 +Student_01842,1,17,9130,1,1,1,1,19,19,3,10,125.0,131.0,1,0,0,1,1,0,0,19,0,5,11,2,10.5,2,0,5,9,0,0.0,3,10.8,1.4,1.74,0 +Student_01843,1,1,9147,1,1,1,1,1,38,3,6,158.0,155.2,0,0,0,1,1,1,0,18,0,5,5,5,11.8,0,0,5,8,3,11.0,0,9.4,-0.8,-3.12,2 +Student_01844,1,1,9147,1,2,1,1,3,1,3,3,128.0,121.0,1,1,1,1,1,0,0,20,0,5,6,5,13.2,0,0,5,10,5,11.4,3,16.2,0.3,-0.92,1 +Student_01846,1,1,9130,1,1,1,1,3,19,2,4,138.0,131.0,1,0,0,1,1,0,0,19,0,6,8,4,11.6,0,0,6,14,2,13.0,0,11.1,0.6,2.02,0 +Student_01847,1,17,9003,1,1,1,1,37,3,5,2,126.0,116.9,0,0,0,1,1,0,0,19,0,6,10,6,13.666666666666666,0,0,6,10,4,12.25,0,13.9,-0.3,0.79,0 +Student_01848,2,39,9991,0,1,1,1,36,14,9,10,140.0,130.0,1,0,0,1,1,0,0,41,0,5,9,4,10.75,0,0,5,7,2,10.0,0,9.4,-0.8,-3.12,0 +Student_01849,1,1,9500,1,2,1,1,5,5,2,2,143.0,137.8,0,0,0,1,1,0,0,19,0,7,10,6,13.492857142857144,0,0,8,9,8,12.68888888888889,0,12.4,0.5,1.79,2 +Student_01850,1,43,9254,1,3,1,1,3,3,2,2,135.0,122.1,0,0,0,1,1,0,0,19,0,6,14,3,12.5,0,0,6,9,4,11.0,0,12.7,3.7,-1.7,1 +Student_01851,1,7,9500,1,1,3,1,1,1,7,10,120.0,120.0,1,0,0,0,1,0,0,23,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_01852,1,1,9119,1,1,1,1,19,38,9,7,148.0,133.0,0,0,0,1,1,0,0,18,0,5,12,5,13.285714285714286,0,0,5,16,5,14.8,0,12.4,0.5,1.79,0 +Student_01853,1,1,9147,1,1,1,1,3,19,3,3,126.0,115.2,0,0,0,1,1,0,0,19,0,5,6,5,12.6,0,0,5,13,5,11.8,5,16.2,0.3,-0.92,2 +Student_01856,4,39,9670,1,2,19,1,19,1,90,90,133.1,103.0,0,0,0,0,1,0,0,34,0,6,6,0,0.0,0,0,6,9,0,0.0,0,10.8,1.4,1.74,0 +Student_01857,1,1,9070,1,1,1,1,3,3,9,9,136.0,136.0,1,0,1,0,0,1,0,19,0,6,6,6,11.833333333333334,0,0,6,8,6,12.875,0,10.8,1.4,1.74,2 +Student_01858,1,15,9238,1,1,1,26,19,1,9,9,150.0,146.5,1,0,1,0,1,0,1,22,0,6,10,5,11.5,0,0,6,8,5,12.4,0,13.9,-0.3,0.79,2 +Student_01859,1,17,9070,1,3,1,1,1,4,4,2,130.0,131.4,0,0,0,1,1,0,0,20,0,6,6,6,14.166666666666666,0,0,6,8,6,12.333333333333334,0,11.1,0.6,2.02,2 +Student_01860,2,42,9991,0,1,1,1,3,2,2,2,130.0,130.0,0,0,0,1,1,0,0,27,2,2,2,2,12.5,0,0,5,6,2,12.5,0,12.7,3.7,-1.7,1 +Student_01861,2,39,9119,1,1,1,1,19,19,0,5,110.0,137.0,0,0,1,1,1,0,0,30,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_01862,1,39,9119,1,1,1,1,1,1,4,4,110.0,125.9,0,0,0,1,1,0,0,34,0,5,7,0,0.0,0,0,5,8,1,11.0,0,10.8,1.4,1.74,1 +Student_01863,1,1,9254,1,1,1,1,1,1,5,4,121.0,111.9,1,0,0,0,1,0,0,20,0,6,14,2,10.5,0,0,6,16,0,0.0,0,10.8,1.4,1.74,0 +Student_01864,1,17,9070,1,1,1,1,37,38,9,5,127.0,131.2,1,0,0,1,1,0,0,18,0,6,6,6,11.833333333333334,0,0,6,6,6,13.166666666666666,0,7.6,2.6,NA,2 +Student_01866,1,39,9991,0,1,1,1,1,1,3,7,130.0,140.0,0,0,0,1,1,0,0,26,0,5,5,5,12.4,0,0,5,5,5,12.4,0,15.5,2.8,-4.06,2 +Student_01868,1,39,9991,0,1,1,1,37,37,9,6,100.0,153.5,0,0,1,0,1,0,0,31,0,5,9,0,0.0,0,0,5,6,0,0.0,0,12.4,0.5,1.79,0 +Student_01869,1,1,171,1,3,1,1,37,19,9,8,139.0,142.2,1,0,0,1,1,1,0,20,6,12,12,12,14.583333333333334,0,4,11,14,11,14.333333333333334,0,8.9,1.4,3.51,2 +Student_01870,1,1,9773,1,1,1,1,19,11,0,0,150.0,131.1,1,0,0,1,1,0,0,19,0,6,6,6,11.666666666666666,0,0,6,10,3,12.666666666666666,0,7.6,2.6,0.32,2 +Student_01874,1,39,8014,0,1,1,1,34,34,0,0,133.1,97.5,1,0,0,1,1,0,0,29,0,6,10,0,0.0,1,0,5,10,0,0.0,0,7.6,2.6,0.32,0 +Student_01875,1,1,9773,1,4,1,1,19,19,7,7,133.0,134.4,1,0,0,1,1,1,0,20,0,6,6,6,12.166666666666666,0,0,6,8,4,12.75,0,9.4,-0.8,-3.12,2 +Student_01876,1,1,9500,1,1,NA,1,37,37,9,9,125.0,118.8,0,0,0,1,1,0,0,24,0,7,7,6,13.3,0,0,7,7,6,13.3,0,7.6,2.6,0.32,2 +Student_01877,1,NA,9556,1,1,19,1,42,1,3,7,133.1,110.5,0,0,0,1,1,0,0,37,0,7,15,0,0.0,0,0,7,13,0,0.0,1,11.1,0.6,2.02,0 +Student_01878,1,1,9500,1,5,1,1,37,19,4,4,143.0,123.3,1,0,0,1,1,0,0,18,0,7,0,0,0.0,0,0,8,0,0,0.0,0,7.6,2.6,0.32,0 +Student_01879,1,1,171,1,2,1,1,2,19,5,5,127.0,139.6,1,0,1,0,1,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_01880,1,17,9500,1,1,1,1,19,3,4,9,157.0,138.8,0,0,0,1,1,0,0,18,0,8,8,7,13.55714285714286,0,0,8,8,7,13.55714285714286,0,12.7,3.7,-1.7,2 +Student_01881,2,44,9119,1,1,39,1,37,37,9,9,160.0,160.0,0,0,1,1,1,0,0,41,3,7,15,5,14.333333333333334,0,1,6,16,6,14.636363636363637,0,12.4,0.5,1.79,1 +Student_01882,1,39,9003,1,1,1,1,37,37,9,4,140.0,140.0,0,0,0,1,1,0,0,35,0,6,16,4,12.0,0,0,6,11,3,10.333333333333334,0,13.9,-0.3,0.79,0 +Student_01885,2,39,9500,1,1,1,1,37,37,191,172,133.1,115.2,0,0,0,1,0,0,0,48,0,7,11,4,11.75,0,0,7,14,3,11.725,0,11.1,0.6,2.02,1 +Student_01886,1,1,9500,1,1,NA,1,19,2,9,3,132.0,126.0,1,0,0,1,0,0,0,19,0,7,7,6,12.183333333333332,0,0,7,7,6,12.183333333333332,0,7.6,2.6,0.32,2 +Student_01888,2,43,9773,1,1,1,1,37,37,5,0,160.0,160.0,0,0,1,0,1,0,0,51,0,4,4,0,0.0,0,0,4,4,0,0.0,0,12.7,3.7,-1.7,0 +Student_01889,1,10,9085,1,1,1,22,2,19,2,8,184.4,184.4,0,0,0,1,0,0,1,18,0,6,8,6,15.0,0,0,6,10,5,14.333333333333334,0,11.1,0.6,NA,2 +Student_01890,1,1,171,1,1,1,1,1,1,9,3,149.0,156.0,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,2 +Student_01891,1,1,171,1,1,1,1,40,43,4,4,146.0,150.2,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,2 +Student_01892,1,1,9500,1,5,1,1,38,37,7,7,139.0,126.3,1,0,0,1,0,1,0,18,0,8,8,8,13.435,0,0,8,8,8,13.435,0,9.4,-0.8,-3.12,2 +Student_01893,1,1,9130,1,1,1,1,2,22,4,3,152.0,146.1,1,0,0,1,0,0,0,18,0,5,8,4,13.5,2,0,5,9,0,0.0,3,10.8,1.4,1.74,0 +Student_01894,1,1,171,1,1,1,1,2,3,4,8,147.0,145.3,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,1 +Student_01895,1,18,171,1,1,1,1,1,1,4,3,121.0,116.8,1,0,0,1,0,0,0,NA,15,17,18,17,11.5,0,16,17,17,17,12.176470588235292,0,12.4,0.5,1.79,2 +Student_01896,1,1,9070,1,1,1,1,19,19,7,9,124.0,132.1,1,0,0,1,0,0,0,19,0,6,10,2,10.5,0,0,6,6,3,11.0,0,7.6,2.6,0.32,1 +Student_01898,1,1,9773,1,1,1,1,3,3,2,2,121.0,112.3,1,0,1,0,0,0,0,18,0,6,7,5,12.2,0,0,6,11,4,11.5,0,11.1,0.6,2.02,0 +Student_01899,1,1,171,1,1,1,1,12,12,4,1,143.0,155.3,1,1,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,2 +Student_01901,1,43,9773,1,1,1,1,1,37,3,0,126.0,110.0,0,0,1,1,0,0,0,20,0,6,7,6,13.333333333333334,0,0,6,8,6,12.666666666666666,0,12.4,0.5,1.79,2 +Student_01902,1,42,9085,1,1,1,1,1,9,4,4,133.1,128.2,0,0,0,1,0,0,0,24,5,11,29,9,12.0,6,4,10,21,9,12.555555555555555,0,9.4,-0.8,-3.12,2 +Student_01903,1,1,9130,1,1,1,1,1,1,4,4,127.0,120.4,1,0,0,1,0,0,0,18,0,6,9,6,15.125,0,0,6,9,6,14.0,0,13.9,-0.3,0.79,2 +Student_01904,1,17,9500,1,1,1,1,19,1,4,10,160.0,153.0,1,0,0,1,0,0,0,18,0,7,7,6,13.116666666666667,0,0,7,7,6,13.116666666666667,0,7.6,2.6,0.32,2 +Student_01905,1,1,9773,1,1,1,1,19,1,7,9,121.0,117.9,1,0,0,1,0,0,0,19,0,6,7,6,12.833333333333334,0,0,6,7,6,11.666666666666666,0,11.1,0.6,2.02,2 +Student_01906,NA,44,9238,1,1,39,1,1,37,4,8,150.0,145.6,1,0,0,1,0,1,0,20,3,6,6,6,13.333333333333334,0,2,6,6,6,14.166666666666666,0,13.9,-0.3,0.79,2 +Student_01908,1,NA,9500,1,6,1,1,19,1,9,10,141.0,126.8,1,0,0,1,0,0,0,18,0,8,8,7,12.944285714285714,0,0,8,8,7,12.944285714285714,0,10.8,1.4,1.74,2 +Student_01909,1,17,9853,1,1,1,1,2,19,3,9,112.0,106.1,1,0,0,1,0,0,0,19,0,6,8,5,12.333333333333334,0,0,6,8,5,11.0,0,15.5,2.8,-4.06,1 +Student_01910,1,1,9500,1,1,1,1,3,3,2,2,148.0,137.3,1,0,0,1,0,0,0,19,0,7,7,6,14.266666666666666,0,0,7,7,6,14.266666666666666,0,7.6,2.6,0.32,2 +Student_01911,1,1,9670,1,2,1,1,3,19,4,5,120.0,115.5,1,0,0,1,0,0,0,18,0,6,8,5,13.0,0,0,6,8,5,14.0,0,13.9,-0.3,0.79,2 +Student_01912,1,1,9500,1,2,1,1,37,37,5,7,132.0,127.5,1,0,0,1,0,0,0,20,0,8,8,8,12.48375,0,0,8,8,8,12.48375,0,9.4,-0.8,-3.12,2 +Student_01915,1,1,9853,1,1,1,1,12,12,9,4,142.0,132.6,1,0,0,1,0,0,0,18,0,6,8,5,15.4,0,0,6,7,5,12.2,0,7.6,2.6,0.32,2 +Student_01916,1,1,9500,1,4,1,1,1,37,4,8,148.0,132.0,1,0,0,1,0,0,0,18,0,7,7,6,13.45,0,0,7,7,6,13.45,0,7.6,2.6,0.32,2 +Student_01917,1,17,9500,1,5,1,1,19,38,5,8,136.0,130.3,1,0,0,1,0,1,0,18,0,7,7,6,12.6,0,0,7,7,6,12.6,0,7.6,2.6,0.32,2 +Student_01918,1,1,9500,1,4,1,1,19,38,9,10,123.0,116.7,1,0,0,1,0,0,0,20,0,7,7,7,12.485714285714286,0,0,8,12,8,12.9375,0,16.2,0.3,-0.92,2 +Student_01920,1,43,9670,1,1,1,1,19,19,1,1,151.0,100.0,0,0,1,1,0,0,0,20,0,6,12,5,12.2,0,0,6,8,5,14.6,0,13.9,-0.3,0.79,1 +Student_01922,1,1,9238,1,2,1,1,37,38,9,8,136.0,139.2,1,0,0,1,0,0,0,18,0,6,7,6,13.833333333333334,0,0,6,6,6,14.0,0,9.4,-0.8,-3.12,2 +Student_01923,1,1,9853,1,1,1,1,19,1,9,1,142.0,132.6,0,0,0,1,0,0,0,18,0,6,8,5,12.8,0,0,6,14,3,10.0,0,9.4,-0.8,-3.12,1 +Student_01925,1,17,9670,1,1,1,1,1,38,4,7,NA,125.6,0,0,1,1,0,1,0,18,0,6,7,1,14.0,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_01927,1,1,9085,1,1,1,1,NA,19,9,4,134.0,128.4,1,0,0,1,0,1,0,19,0,5,7,5,12.5,0,0,5,8,5,12.714285714285714,0,10.8,1.4,1.74,2 +Student_01934,1,39,9500,1,1,19,1,19,37,9,4,133.1,120.0,0,0,0,1,0,1,0,25,0,8,8,8,13.3675,0,0,8,8,8,13.3675,0,9.4,-0.8,-3.12,2 +Student_01935,1,1,9500,1,4,1,1,19,38,9,9,133.1,119.6,1,0,0,1,0,1,0,19,0,7,7,6,12.808333333333332,0,0,8,11,7,12.825714285714286,0,12.4,0.5,1.79,2 +Student_01936,1,17,9500,1,6,1,1,1,38,3,3,143.0,133.2,1,0,0,1,0,0,0,18,0,7,7,7,13.918571428571427,0,0,8,9,8,13.8875,0,11.1,0.6,2.02,2 +Student_01937,1,17,9130,1,1,1,NA,4,1,2,10,147.0,141.8,1,0,0,1,0,0,0,19,0,6,8,6,13.0,0,0,6,9,4,12.8,0,13.9,-0.3,0.79,2 +Student_01938,2,1,9500,1,1,1,1,19,38,4,5,142.0,130.3,0,0,0,1,0,0,0,18,0,7,7,6,13.683333333333332,0,0,7,7,6,13.683333333333332,0,7.6,2.6,0.32,2 +Student_01939,1,39,9085,1,1,1,1,19,19,4,10,150.0,100.0,0,0,0,1,0,0,0,24,1,6,11,5,13.0,0,1,6,12,1,12.0,0,13.9,-0.3,0.79,0 +Student_01940,1,1,9773,1,2,1,1,3,3,3,4,124.0,114.6,1,0,0,NA,0,0,0,21,0,6,8,5,12.8,0,0,6,7,5,11.2,0,11.1,0.6,2.02,2 +Student_01941,1,1,9254,1,2,1,1,1,1,9,4,136.0,123.4,1,0,0,1,0,1,0,18,0,6,9,6,13.571428571428571,0,0,6,6,6,12.166666666666666,0,8.9,1.4,3.51,2 +Student_01942,1,1,9238,1,1,1,1,38,38,9,6,116.0,116.4,1,0,0,1,0,0,0,18,0,6,6,6,13.166666666666666,0,0,6,6,6,13.166666666666666,0,8.9,1.4,3.51,2 +Student_01944,1,1,9070,1,1,1,1,4,19,3,5,117.0,123.7,1,0,0,1,0,0,0,19,0,6,6,6,12.666666666666666,0,0,6,8,5,11.4,0,12.4,0.5,1.79,2 +Student_01946,1,1,9500,1,4,1,1,37,37,9,9,129.0,117.1,1,0,0,1,0,0,0,30,0,7,7,7,14.692857142857145,0,0,8,8,8,14.9625,0,12.4,0.5,1.79,2 +Student_01947,1,1,9500,1,1,1,1,19,38,5,3,157.0,149.3,0,0,0,1,0,0,0,18,0,8,8,8,14.035,0,0,8,8,8,14.035,0,9.4,-0.8,-3.12,2 +Student_01948,1,17,9085,1,1,1,1,1,19,4,10,135.0,125.6,1,0,0,1,0,0,0,18,0,5,8,4,11.0,1,0,5,8,3,14.0,0,12.7,3.7,-1.7,2 +Student_01949,1,1,9773,1,1,1,1,38,38,9,9,139.0,145.0,1,0,0,1,0,1,0,18,0,6,6,6,13.333333333333334,0,0,6,6,6,13.333333333333334,0,9.4,-0.8,-3.12,2 +Student_01950,1,18,9500,1,1,1,NA,38,37,5,5,115.0,115.0,0,0,0,1,0,0,0,20,0,7,13,6,11.7725,0,0,8,9,7,12.33,0,15.5,2.8,-4.06,2 +Student_01951,1,1,9254,1,1,1,1,38,38,4,7,123.0,114.3,0,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_01952,1,43,9254,1,2,1,1,19,19,9,9,140.0,126.0,1,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,12,0,0.0,0,10.8,1.4,1.74,0 +Student_01953,1,1,171,1,1,1,1,19,37,7,7,138.0,124.0,1,0,0,0,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01954,1,1,9254,1,4,1,1,1,38,5,6,132.0,122.6,1,0,0,1,0,1,0,18,0,6,7,6,12.285714285714286,0,0,6,6,6,12.0,0,8.9,1.4,3.51,2 +Student_01955,1,1,9500,1,4,1,1,3,19,2,3,140.0,133.8,1,0,0,1,0,0,0,17,0,8,14,5,NA,0,0,8,14,5,12.46,0,10.8,1.4,1.74,1 +Student_01956,1,18,9853,1,1,1,1,19,38,4,NA,117.0,113.5,1,0,0,1,0,0,0,19,0,7,10,6,12.166666666666666,0,0,7,9,6,13.166666666666666,0,12.4,0.5,1.79,2 +Student_01957,1,1,9238,1,4,1,1,19,1,4,5,125.0,122.6,1,1,0,1,0,0,0,18,0,6,9,5,11.833333333333334,0,0,6,8,2,11.5,0,13.9,-0.3,0.79,1 +Student_01958,1,7,9500,1,1,3,1,37,37,4,4,140.0,140.0,0,0,0,1,0,0,0,25,0,8,8,7,14.805714285714286,0,0,8,8,7,14.805714285714286,0,10.8,1.4,1.74,2 +Student_01959,1,1,9238,1,1,1,1,12,38,4,9,133.1,107.0,1,0,0,1,0,0,0,19,0,6,11,5,10.6,0,0,6,10,6,11.714285714285714,0,11.1,0.6,2.02,0 +Student_01960,1,53,9085,1,1,42,1,19,1,9,9,130.0,NA,1,0,1,0,0,0,0,24,7,9,9,8,13.125,0,4,9,13,6,13.0,0,8.9,1.4,3.51,1 +Student_01961,1,1,9238,1,1,1,1,1,1,4,9,134.0,124.2,1,0,1,1,0,1,0,19,0,6,6,6,12.833333333333334,0,0,6,6,6,12.666666666666666,0,9.4,-0.8,-3.12,2 +Student_01962,1,18,9500,1,1,NA,1,19,1,9,4,128.0,125.8,0,0,0,1,0,1,0,20,0,8,8,0,0.0,8,0,8,8,0,0.0,8,9.4,-0.8,-3.12,1 +Student_01963,1,1,9670,1,1,1,1,1,1,5,4,115.0,108.0,1,0,0,1,0,1,0,20,0,6,9,5,13.0,0,0,6,6,5,13.8,0,12.4,0.5,1.79,2 +Student_01964,1,1,9500,1,2,1,1,1,1,4,4,119.0,115.2,1,0,0,1,0,1,0,20,0,7,8,7,12.725,0,0,8,8,8,13.7125,0,13.9,-0.3,0.79,2 +Student_01965,1,17,9085,1,1,1,1,1,3,4,1,131.0,129.3,1,0,0,1,0,0,0,19,0,5,10,4,11.25,1,0,5,10,3,10.333333333333334,0,12.7,3.7,-1.7,2 +Student_01967,1,1,9085,1,1,1,1,1,19,3,4,120.0,116.7,0,0,0,1,0,0,0,20,0,5,12,3,12.333333333333334,2,0,5,8,3,13.0,1,9.4,-0.8,-3.12,2 +Student_01969,1,17,9853,1,1,1,1,1,1,3,4,146.0,128.2,0,0,1,1,0,0,0,18,0,6,8,4,13.25,0,0,6,10,3,10.666666666666666,0,NA,3.7,-1.7,1 +Student_01970,1,1,9670,1,4,1,1,1,2,4,7,133.0,121.1,1,0,0,1,0,0,0,18,0,6,7,6,13.666666666666666,0,0,6,9,5,15.4,0,13.9,-0.3,0.79,2 +Student_01972,1,17,9085,1,1,1,1,2,19,2,4,128.0,123.3,1,0,0,1,0,1,0,20,0,6,6,6,14.833333333333334,0,0,6,8,6,12.142857142857142,0,8.9,1.4,3.51,2 +Student_01974,1,17,9147,1,1,NA,1,19,19,4,6,122.0,119.9,0,0,0,1,0,1,0,21,0,5,6,5,11.4,0,0,5,6,5,12.2,0,12.7,3.7,-1.7,2 +Student_01975,1,1,9500,1,4,1,1,1,12,3,10,140.0,131.6,1,0,0,1,0,0,0,18,0,7,8,7,13.135,0,0,8,9,8,13.244444444444444,0,12.4,0.5,1.79,2 +Student_01976,1,51,9070,1,1,1,1,1,1,4,4,143.0,120.0,1,0,0,1,0,0,0,21,3,10,10,10,13.0,0,5,11,11,10,11.4,0,11.1,0.6,2.02,0 +Student_01977,1,1,9500,1,4,1,1,19,19,3,3,118.0,110.0,1,0,0,1,0,0,0,19,0,7,12,4,12.85,0,0,7,7,7,12.62142857142857,0,11.1,0.6,2.02,1 +Student_01978,1,44,9238,1,1,39,1,1,19,191,102,140.0,143.0,0,0,0,1,0,0,0,20,3,6,6,6,13.5,0,2,6,9,5,12.5,0,NA,-0.3,0.79,2 +Student_01979,1,44,9085,1,1,1,1,1,2,3,3,140.0,140.0,0,0,0,1,0,0,0,20,0,6,7,6,14.285714285714286,0,0,6,9,3,13.0,0,13.9,-0.3,0.79,1 +Student_01981,1,1,9147,1,1,1,1,19,19,9,9,140.0,124.3,1,0,0,1,0,1,0,18,0,5,8,4,10.75,0,0,5,5,5,13.0,0,12.4,0.5,1.79,2 +Student_01983,1,43,9085,1,1,39,1,38,37,6,6,150.0,150.0,1,0,0,1,0,1,0,21,2,7,15,3,13.0,2,1,5,12,5,13.285714285714286,1,10.8,1.4,1.74,2 +Student_01985,1,1,9500,1,1,1,1,19,1,5,5,162.0,147.5,1,0,0,1,0,1,0,18,0,8,8,8,14.14125,0,0,8,8,8,14.14125,0,9.4,-0.8,-3.12,2 +Student_01987,2,42,9500,1,1,2,1,37,37,9,9,130.0,130.0,0,0,0,1,0,1,0,32,0,8,8,8,14.6625,0,0,8,8,8,14.6625,0,9.4,-0.8,-3.12,2 +Student_01989,1,1,9500,1,2,1,1,19,37,3,3,116.0,109.0,1,0,0,1,0,1,0,23,0,7,8,6,12.993333333333334,0,0,8,9,8,12.66875,0,11.1,0.6,2.02,2 +Student_01990,1,1,9670,1,5,1,1,4,1,4,10,120.0,112.0,1,0,0,1,0,0,0,18,0,6,10,4,11.25,0,0,6,11,5,NA,0,8.9,1.4,3.51,1 +Student_01991,1,17,8014,0,1,1,NA,37,19,5,5,132.0,121.2,0,0,0,1,0,0,0,18,0,6,8,5,12.2,0,0,6,10,5,12.8,0,10.8,1.4,1.74,2 +Student_01992,1,43,171,1,1,2,1,37,37,9,9,140.0,140.0,1,0,0,1,0,0,0,34,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01993,1,39,8014,0,1,1,100,1,1,4,7,120.0,119.5,0,0,1,1,0,0,1,25,2,6,6,6,11.333333333333334,0,0,6,6,4,11.75,0,8.9,1.4,3.51,1 +Student_01994,1,1,9147,1,1,1,1,37,38,193,181,136.0,125.9,0,0,0,1,0,0,0,21,0,5,7,5,12.2,0,0,5,7,5,11.8,0,NA,0.6,2.02,2 +Student_01995,1,1,9254,1,1,1,1,19,9,0,0,133.0,121.5,1,0,0,1,0,1,0,20,0,6,12,0,0.0,0,0,6,12,0,0.0,0,7.6,2.6,0.32,0 +Student_01996,1,1,9238,1,5,1,1,30,19,0,2,126.0,121.5,1,0,0,1,0,0,0,18,0,6,8,6,11.333333333333334,0,0,6,6,6,11.666666666666666,0,7.6,2.6,0.32,2 +Student_01997,1,17,9085,1,1,1,1,3,37,4,8,142.0,132.4,1,0,0,1,0,0,0,18,0,6,8,6,13.857142857142858,0,0,6,15,6,13.1,0,12.4,0.5,1.79,2 +Student_01998,1,17,9773,1,1,1,1,37,37,9,9,121.0,122.4,0,0,0,1,0,0,0,18,0,6,7,6,12.857142857142858,0,0,6,6,6,13.333333333333334,0,NA,-0.3,0.79,2 +Student_01999,1,39,8014,0,1,1,1,37,38,4,7,134.0,NA,1,0,0,1,0,0,0,24,0,6,10,1,10.0,0,0,6,12,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02000,1,51,9147,1,1,1,1,19,19,9,7,140.0,120.4,0,0,1,0,0,0,0,32,14,15,17,14,10.214285714285714,0,13,13,13,13,11.384615384615383,0,16.2,0.3,-0.92,2 +Student_02002,1,1,9238,1,1,1,1,38,37,9,NA,157.0,137.8,0,0,0,1,0,1,0,18,0,6,6,6,13.833333333333334,0,0,6,7,0,0.0,0,15.5,2.8,-4.06,0 +Student_02003,1,51,9254,1,1,1,1,38,38,9,9,120.0,118.0,0,0,0,1,0,0,0,28,0,6,8,6,12.857142857142858,0,0,6,8,5,12.6,0,8.9,1.4,3.51,2 +Student_02004,1,17,9853,1,5,1,1,19,38,4,8,134.0,122.1,1,0,0,1,0,1,0,18,0,6,8,6,11.666666666666666,0,0,6,9,4,12.0,0,10.8,1.4,1.74,0 +Student_02005,1,7,9853,1,1,3,1,34,34,0,0,140.0,140.0,1,0,0,0,0,0,0,24,0,6,12,0,0.0,0,0,5,10,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02007,NA,39,8014,0,1,1,1,37,37,9,8,146.0,120.5,0,0,0,1,0,0,0,44,0,6,6,6,14.833333333333334,0,0,6,6,6,14.166666666666666,0,10.8,1.4,1.74,2 +Student_02008,1,16,9085,1,3,1,1,37,37,9,2,130.0,119.5,1,0,0,1,0,1,0,18,0,6,14,6,14.333333333333334,0,0,6,9,6,12.0,0,15.5,2.8,-4.06,2 +Student_02009,1,1,171,1,1,1,1,37,37,9,7,151.0,147.5,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_02010,1,1,9773,1,6,1,1,1,1,90,90,133.1,129.6,0,0,0,1,0,0,0,22,0,6,0,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_02011,1,18,9853,1,1,1,1,37,37,9,5,132.0,126.1,0,0,0,1,0,1,0,18,0,7,9,6,12.333333333333334,0,0,7,7,6,12.666666666666666,0,11.1,0.6,2.02,2 +Student_02013,5,39,9853,1,1,19,1,38,1,5,3,133.1,105.5,0,0,1,1,0,0,0,33,0,6,7,5,13.2,0,0,6,7,5,10.6,0,7.6,2.6,0.32,0 +Student_02014,2,39,9853,1,1,1,1,37,37,9,9,110.0,95.5,0,0,1,0,0,0,0,32,0,6,6,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_02015,2,39,9003,1,1,1,1,19,19,4,4,133.1,107.5,0,0,0,0,0,0,0,35,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_02016,1,1,9238,1,1,1,1,19,19,6,6,105.0,106.1,1,0,0,1,0,0,0,20,0,6,6,6,11.5,0,0,6,7,6,13.285714285714286,0,11.1,0.6,2.02,2 +Student_02017,1,39,9254,1,1,1,1,NA,1,6,6,160.0,116.3,1,0,0,1,0,0,0,24,0,6,8,5,12.6,0,0,6,7,5,12.2,0,9.4,-0.8,-3.12,2 +Student_02019,1,1,9254,1,1,1,1,19,19,5,5,100.0,101.8,1,0,0,1,0,0,0,21,0,6,8,5,11.6,0,0,6,6,5,13.0,0,12.4,0.5,1.79,1 +Student_02020,1,1,9773,1,2,1,1,1,1,4,9,143.0,144.1,1,0,0,1,1,1,0,19,0,6,7,6,13.666666666666666,0,0,6,6,6,13.833333333333334,0,12.7,3.7,-1.7,2 +Student_02021,1,NA,9003,1,1,1,1,19,1,9,5,160.0,107.8,1,0,0,0,1,0,0,27,0,6,10,0,0.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_02022,1,39,9853,1,1,1,1,19,1,9,4,140.0,128.2,0,0,0,0,0,0,0,30,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02023,1,17,171,1,4,1,1,38,38,9,9,133.1,117.0,1,0,0,1,1,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_02024,1,1,9070,1,1,1,1,1,12,5,8,116.0,110.4,1,0,0,1,1,0,0,19,0,6,6,6,11.5,0,0,6,8,6,12.285714285714286,0,8.9,1.4,3.51,2 +Student_02025,2,39,9991,0,1,1,1,37,37,9,10,120.0,170.0,0,0,0,1,0,0,0,34,0,5,12,2,11.5,0,0,5,9,4,11.75,0,9.4,-0.8,-3.12,1 +Student_02026,1,43,9500,1,1,1,1,4,19,4,10,141.0,NA,0,0,0,1,1,0,0,18,0,7,7,7,NA,0,0,8,10,7,12.9125,0,13.9,-0.3,0.79,2 +Student_02028,1,1,171,1,2,1,1,3,39,1,3,127.0,133.5,1,0,0,1,1,0,0,17,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,1 +Student_02029,1,1,9500,1,1,1,1,19,37,4,9,132.0,128.0,1,0,0,1,0,1,0,19,0,7,7,6,12.966666666666669,0,0,7,7,6,12.966666666666669,0,7.6,2.6,0.32,2 +Student_02030,1,1,9773,1,1,1,1,37,38,9,6,135.0,122.1,1,0,0,1,1,0,0,18,0,6,6,6,13.833333333333334,0,0,6,6,6,13.666666666666666,0,12.7,3.7,-1.7,2 +Student_02032,4,39,9254,1,1,1,1,38,37,9,9,140.0,112.0,0,0,1,1,0,0,0,45,4,10,12,5,12.166666666666666,4,2,8,8,0,0.0,2,12.7,3.7,-1.7,0 +Student_02033,1,39,9085,1,1,1,1,19,37,9,6,133.1,130.0,1,0,0,NA,0,0,0,26,0,6,17,6,12.666666666666666,0,0,6,21,4,12.25,0,15.5,2.8,-4.06,2 +Student_02034,2,39,9991,0,2,1,1,37,37,9,9,100.0,100.0,1,0,0,1,1,0,0,51,0,4,4,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02035,2,39,9773,1,1,19,1,37,37,6,6,133.1,162.0,0,0,1,1,1,1,0,49,0,6,8,6,12.285714285714286,0,0,6,7,6,14.166666666666666,0,10.8,1.4,1.74,2 +Student_02036,1,42,9500,1,1,1,1,3,19,2,8,100.0,153.0,0,0,0,1,1,0,0,22,3,6,7,3,14.5,0,4,7,8,4,14.375,0,15.5,2.8,-4.06,1 +Student_02037,1,17,9147,1,1,1,NA,1,37,5,9,137.0,131.4,1,0,0,1,1,0,0,22,0,5,8,2,10.0,0,0,5,7,1,10.0,0,7.6,2.6,0.32,0 +Student_02038,2,7,9130,1,1,3,1,3,3,1,1,120.0,128.2,0,0,0,1,0,0,0,33,1,5,11,2,11.5,1,1,5,8,2,12.0,0,9.4,-0.8,-3.12,0 +Student_02040,1,1,9238,1,4,1,1,38,19,7,7,134.0,128.4,1,0,0,1,0,1,0,18,0,6,6,6,12.5,0,0,6,6,6,11.666666666666666,0,10.8,1.4,1.74,2 +Student_02041,1,1,9853,1,5,1,1,38,37,9,9,128.0,120.3,1,0,1,0,0,0,0,20,0,6,9,3,11.666666666666666,0,0,6,10,2,11.0,0,10.8,1.4,1.74,0 +Student_02042,2,57,9991,0,1,1,41,38,37,4,6,133.1,NA,0,0,0,1,0,0,1,37,5,10,11,7,13.428571428571429,0,5,10,11,10,11.6,0,8.9,1.4,3.51,2 +Student_02043,1,1,9254,1,1,1,2,37,1,9,3,131.0,126.1,1,0,0,1,1,0,1,18,0,6,6,6,13.666666666666666,0,0,6,6,6,13.5,0,7.6,2.6,0.32,2 +Student_02045,1,44,9085,1,1,39,1,1,19,3,3,140.0,140.0,1,0,0,NA,0,0,0,21,2,6,7,6,13.0,0,1,6,15,4,12.8,0,12.4,0.5,1.79,2 +Student_02046,1,1,9500,1,2,1,1,19,1,9,1,133.0,122.2,0,0,0,1,0,0,0,20,0,7,9,6,12.783333333333331,0,0,8,9,7,12.842857142857143,0,13.9,-0.3,0.79,2 +Student_02047,1,1,9500,1,2,1,NA,37,1,7,7,126.0,118.7,1,0,0,1,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02048,1,17,9556,1,2,1,1,38,19,7,7,125.0,121.5,1,0,0,1,0,0,0,20,0,7,13,4,13.5,0,0,7,11,4,11.225,0,11.1,0.6,2.02,0 +Student_02050,1,1,9500,1,4,1,1,1,19,9,7,140.0,127.0,1,0,0,1,0,0,0,19,0,8,8,7,13.44285714285714,0,0,8,8,7,13.44285714285714,0,12.7,3.7,-1.7,2 +Student_02051,1,1,9238,1,1,1,1,37,38,9,3,124.0,114.2,0,0,0,1,0,0,0,18,0,6,13,4,11.0,0,0,6,12,5,10.833333333333334,0,15.5,2.8,-4.06,2 +Student_02052,1,17,9238,1,1,1,1,38,38,7,7,133.0,125.3,1,0,0,1,0,1,0,18,0,6,6,6,11.333333333333334,0,0,6,7,6,12.285714285714286,0,15.5,2.8,-4.06,2 +Student_02053,1,1,9773,1,2,1,1,1,19,4,5,127.0,120.4,1,0,0,1,0,0,0,18,0,5,7,2,10.0,0,0,1,1,0,0.0,0,12.7,3.7,-1.7,0 +Student_02054,1,1,9500,1,6,1,1,1,38,3,9,138.0,123.0,1,0,0,1,0,0,0,19,0,7,10,5,13.44,0,0,7,8,6,13.066666666666668,0,12.4,0.5,1.79,1 +Student_02055,1,1,9556,1,2,1,1,1,19,4,5,142.0,130.5,1,0,0,1,0,1,0,18,0,7,8,7,12.214285714285714,0,0,8,8,8,14.0625,0,16.2,0.3,-0.92,2 +Student_02056,1,1,9070,1,1,1,41,37,19,9,8,130.0,125.5,1,0,0,1,0,1,1,19,0,6,6,6,14.166666666666666,0,0,6,6,6,13.5,0,11.1,0.6,2.02,2 +Student_02057,1,53,9003,1,1,42,1,1,19,9,7,130.0,133.8,0,0,1,1,0,1,0,24,7,12,13,12,12.846153846153848,0,5,11,13,11,12.636363636363637,0,8.9,1.4,3.51,2 +Student_02058,1,44,9085,1,1,39,1,37,37,9,9,150.0,150.0,0,0,0,NA,0,0,0,20,2,6,8,6,13.0,0,1,6,18,2,12.0,0,12.4,0.5,1.79,1 +Student_02059,1,1,9147,1,1,1,1,1,19,5,7,127.0,130.5,1,0,0,1,0,1,0,21,0,5,6,5,12.8,1,0,5,7,4,11.25,0,9.4,-0.8,-3.12,2 +Student_02060,1,44,NA,1,1,39,1,38,37,4,10,140.0,140.0,0,0,1,0,0,0,0,20,1,6,13,4,13.0,0,1,6,11,5,12.0,0,NA,0.3,-0.92,0 +Student_02061,1,17,9500,1,6,1,1,19,37,3,9,126.0,119.4,1,0,0,1,0,1,0,19,0,7,7,7,13.371428571428572,0,0,8,9,8,13.666666666666666,0,16.2,0.3,-0.92,2 +Student_02063,1,1,9500,1,3,1,1,1,1,9,9,141.0,126.3,1,0,0,1,0,0,0,18,0,8,8,7,13.328571428571427,0,0,8,8,7,13.328571428571427,0,12.7,3.7,-1.7,2 +Student_02064,1,1,9085,1,1,1,1,38,38,4,7,120.0,111.6,1,0,0,1,0,0,0,19,0,6,12,5,14.0,0,0,6,14,5,11.0,0,16.2,0.3,-0.92,2 +Student_02065,1,17,9147,1,4,1,1,38,19,9,9,120.0,111.3,1,0,0,1,0,0,0,21,0,5,5,5,12.6,0,0,5,5,5,13.2,0,8.9,1.4,3.51,2 +Student_02066,1,1,9853,1,2,1,1,1,38,9,8,134.0,122.5,1,0,0,1,0,1,0,19,0,6,7,6,14.0,0,0,6,6,6,15.0,0,15.5,2.8,-4.06,2 +Student_02067,1,1,9254,1,5,1,1,19,1,7,10,128.0,116.5,1,0,0,1,0,1,0,18,0,6,7,6,NA,0,0,6,6,6,12.666666666666666,0,8.9,1.4,3.51,2 +Student_02068,1,17,9070,1,5,1,1,4,1,4,4,133.0,132.0,1,1,0,1,0,1,0,17,0,6,6,6,13.0,0,0,6,6,6,12.5,0,15.5,2.8,-4.06,2 +Student_02069,1,18,9853,1,4,1,1,19,38,4,10,123.0,123.7,1,0,0,1,0,0,0,19,0,6,8,5,12.666666666666666,0,0,6,8,5,11.0,0,15.5,2.8,NA,1 +Student_02070,1,17,9147,1,6,1,1,37,1,9,7,118.0,117.0,1,0,0,0,1,0,0,23,0,5,9,3,10.0,1,0,5,9,3,12.333333333333334,0,9.4,-0.8,-3.12,0 +Student_02071,1,1,9670,1,1,1,1,1,37,1,10,113.0,116.5,1,0,0,1,0,0,0,19,0,6,7,6,12.833333333333334,0,0,6,10,6,11.77777777777778,0,8.9,1.4,3.51,2 +Student_02072,1,1,9500,1,1,1,1,19,3,9,4,135.0,121.5,1,0,0,1,0,0,0,18,0,7,7,6,12.916666666666666,0,0,7,7,6,12.916666666666666,0,7.6,2.6,0.32,2 +Student_02073,1,1,9670,1,1,1,1,38,38,5,9,133.1,105.0,1,0,0,1,0,0,0,20,0,6,9,6,13.285714285714286,0,0,6,8,5,13.8,0,15.5,2.8,-4.06,2 +Student_02074,1,1,9085,1,3,1,1,1,19,9,9,130.0,121.3,1,0,0,1,0,1,0,19,0,5,6,5,14.6,0,0,5,5,5,13.8,0,10.8,1.4,1.74,2 +Student_02075,1,1,9238,1,1,1,1,19,38,3,9,135.0,136.1,1,0,0,1,0,1,0,18,0,6,6,6,14.0,0,0,6,6,6,13.666666666666666,0,12.4,0.5,1.79,2 +Student_02076,1,17,9238,1,2,1,1,37,37,9,4,133.0,123.6,0,0,0,1,0,1,0,19,0,6,7,6,14.142857142857142,0,0,6,6,6,15.0,0,13.9,-0.3,0.79,2 +Student_02077,1,1,9238,1,4,1,1,38,1,4,10,123.0,129.0,1,0,0,1,0,0,0,19,0,6,8,6,11.666666666666666,0,0,6,6,6,12.333333333333334,0,10.8,1.4,1.74,2 +Student_02078,1,17,9500,1,1,1,1,19,37,4,8,145.0,136.8,1,0,0,1,0,0,0,18,0,8,9,8,14.3775,1,0,8,9,8,14.3775,1,9.4,-0.8,-3.12,2 +Student_02079,1,17,9500,1,2,1,1,3,3,3,6,146.0,133.4,1,0,0,1,0,0,0,18,0,7,8,7,12.5,0,0,8,9,7,13.042857142857144,0,13.9,-0.3,0.79,2 +Student_02081,1,1,9500,1,1,1,1,38,37,9,9,144.0,125.8,0,0,0,1,0,1,0,19,0,8,12,7,12.471428571428572,0,0,8,12,7,12.471428571428572,0,12.7,3.7,-1.7,2 +Student_02082,1,1,9500,1,1,1,1,4,4,2,1,131.0,120.5,0,0,0,1,0,0,0,19,0,7,7,6,14.15,0,0,7,7,6,14.15,0,7.6,2.6,0.32,2 +Student_02083,1,1,9500,1,2,1,1,37,37,9,8,141.0,130.2,1,0,0,1,0,0,0,21,0,7,11,7,14.072222222222225,0,0,8,8,8,14.0475,0,15.5,2.8,-4.06,2 +Student_02084,1,1,9773,1,3,1,1,3,1,2,3,138.0,135.9,1,0,0,1,0,0,0,18,0,6,7,6,14.857142857142858,0,0,6,6,6,14.666666666666666,0,13.9,-0.3,0.79,2 +Student_02085,1,1,9773,1,1,1,1,19,37,9,9,127.0,116.5,0,0,0,1,0,1,0,19,0,6,7,6,14.285714285714286,0,0,6,6,6,13.166666666666666,0,11.1,0.6,2.02,2 +Student_02088,1,17,9130,1,1,1,1,3,2,3,6,157.0,150.9,1,0,0,1,0,0,0,18,0,6,8,6,15.0,0,0,6,8,5,15.166666666666666,0,13.9,-0.3,0.79,0 +Student_02089,1,1,9500,1,3,1,1,19,19,4,8,129.0,127.3,1,0,0,1,0,1,0,20,0,7,7,6,12.633333333333333,0,0,7,7,6,12.633333333333333,0,7.6,2.6,0.32,2 +Student_02090,1,39,9670,1,1,19,1,1,1,4,7,133.1,100.0,0,0,1,0,0,0,0,25,0,5,5,5,11.2,0,0,5,5,5,12.6,0,9.4,-0.8,-3.12,0 +Student_02091,1,1,9500,1,5,1,1,38,37,5,7,142.0,128.8,1,0,0,1,0,0,0,18,0,7,7,6,14.233333333333334,0,0,7,7,6,14.233333333333334,0,7.6,2.6,0.32,2 +Student_02092,5,1,9085,1,3,1,1,19,19,4,7,133.0,119.7,1,0,0,1,0,0,0,21,0,5,13,5,12.2,2,0,5,10,3,11.333333333333334,1,9.4,-0.8,-3.12,1 +Student_02094,1,1,9500,1,1,1,1,37,37,9,9,151.0,138.0,1,0,0,1,0,0,0,18,0,7,7,6,15.2,0,0,7,7,6,15.2,0,7.6,2.6,0.32,2 +Student_02095,1,17,9853,1,1,1,1,3,3,2,2,135.0,132.9,1,0,0,0,0,0,0,29,0,6,9,6,16.333333333333332,0,0,6,8,5,15.6,0,12.7,3.7,-1.7,0 +Student_02096,1,43,9130,1,1,1,1,3,3,2,2,140.0,140.0,0,0,0,1,0,0,0,20,10,17,29,14,12.5625,4,7,12,24,12,12.857142857142858,1,15.5,2.8,-4.06,2 +Student_02097,1,7,9500,1,1,3,1,3,1,4,4,140.0,140.0,0,0,0,1,0,0,0,26,0,7,0,0,0.0,0,0,8,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02098,1,1,9238,1,2,1,1,38,1,7,7,100.0,99.3,1,0,0,1,0,0,0,21,0,6,8,5,12.4,0,0,6,6,6,12.0,0,12.4,0.5,1.79,2 +Student_02099,1,18,9500,1,1,1,1,37,19,5,5,126.0,119.3,0,0,0,1,0,1,0,19,0,8,9,8,13.78125,1,0,8,9,8,13.78125,1,9.4,-0.8,-3.12,2 +Student_02100,1,17,9254,1,2,1,1,19,19,5,5,123.0,113.2,1,0,1,1,0,0,0,19,0,6,10,6,NA,0,0,6,8,5,11.666666666666666,0,16.2,0.3,-0.92,0 +Student_02103,1,1,9500,1,6,1,1,37,37,9,8,138.0,127.2,1,0,0,1,0,1,0,18,0,7,8,7,13.26,0,0,8,8,8,14.28625,0,15.5,2.8,-4.06,2 +Student_02104,1,1,9773,1,2,1,1,34,19,3,0,128.0,141.0,1,0,0,0,0,0,0,20,0,6,10,4,12.0,0,0,6,15,3,10.666666666666666,0,7.6,2.6,0.32,0 +Student_02105,1,1,9238,1,1,1,1,19,38,9,9,136.0,121.7,0,1,0,1,0,1,0,20,0,6,9,6,11.875,0,0,6,7,6,14.428571428571429,0,16.2,0.3,-0.92,2 +Student_02106,1,43,9500,1,1,1,1,19,19,4,7,127.0,121.1,0,0,0,1,0,1,0,18,0,7,11,5,12.16,0,0,7,7,2,13.4,0,16.2,0.3,-0.92,1 +Student_02107,1,16,9070,1,1,1,1,1,1,3,3,145.0,146.1,1,0,0,1,0,0,0,18,0,6,6,1,15.0,0,0,6,7,4,12.5,0,9.4,-0.8,-3.12,1 +Student_02109,1,17,9085,1,1,1,1,2,19,2,9,138.0,126.8,1,0,0,1,0,0,0,18,0,5,12,2,11.5,0,0,5,12,3,11.8,2,10.8,1.4,1.74,1 +Student_02110,1,44,9085,1,1,39,1,3,3,2,2,150.0,150.0,1,0,0,1,0,0,0,22,2,6,7,6,14.428571428571429,0,1,6,9,5,13.0,0,13.9,-0.3,0.79,2 +Student_02111,1,44,9085,1,3,39,1,1,19,4,1,150.0,150.0,1,0,0,1,0,0,0,19,0,5,10,1,13.0,1,0,5,8,3,15.333333333333334,0,12.7,3.7,-1.7,1 +Student_02112,1,17,9003,1,1,1,1,19,1,9,2,131.0,134.5,1,0,0,1,0,1,0,19,0,6,7,6,15.0,0,0,6,8,6,14.333333333333334,0,12.4,0.5,1.79,2 +Student_02113,1,1,9556,1,2,1,1,19,19,9,9,136.0,129.5,1,0,0,1,0,0,0,18,0,7,9,7,15.155555555555557,0,0,8,8,8,16.8,0,12.7,3.7,-1.7,2 +Student_02114,1,1,9238,1,1,1,1,38,38,175,183,117.0,113.2,1,0,1,1,0,0,0,20,0,6,8,6,10.666666666666666,0,0,6,7,6,11.857142857142858,0,11.1,0.6,2.02,2 +Student_02115,1,17,9853,1,1,1,1,38,37,5,5,158.0,140.2,1,0,0,1,0,0,0,18,0,6,9,5,11.0,0,0,6,9,4,11.25,0,10.8,1.4,1.74,0 +Student_02116,1,17,9670,1,2,1,1,1,19,5,5,129.0,119.2,1,0,0,1,0,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_02117,1,1,9238,1,1,1,1,1,19,4,4,140.0,140.7,0,0,0,1,0,0,0,19,0,6,7,6,12.285714285714286,0,0,6,7,6,12.0,0,NA,0.5,1.79,2 +Student_02118,1,1,9500,1,5,1,1,38,38,9,9,141.0,142.3,1,0,0,1,0,0,0,18,0,8,8,8,12.82875,0,0,8,8,8,12.82875,0,9.4,-0.8,-3.12,0 +Student_02119,1,1,9773,1,4,1,11,12,12,90,4,132.0,129.9,1,0,0,1,0,0,1,18,0,6,6,6,12.666666666666666,0,0,6,8,5,14.4,0,7.6,2.6,0.32,2 +Student_02120,1,17,171,1,1,1,1,1,1,6,7,133.0,134.8,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,1 +Student_02121,1,17,9085,1,1,1,1,19,19,4,9,109.0,104.1,1,0,1,0,0,1,0,21,0,6,16,2,13.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_02122,1,1,9147,1,1,1,1,1,38,5,5,135.0,122.4,0,0,1,1,0,0,0,19,0,5,10,5,10.875,0,0,5,8,4,12.4,0,13.9,-0.3,0.79,2 +Student_02123,1,1,9147,1,1,1,1,37,37,9,7,122.0,120.6,1,0,0,1,0,1,0,19,0,5,5,5,12.8,0,0,5,8,5,11.6,0,9.4,-0.8,-3.12,2 +Student_02125,1,1,171,1,1,1,1,5,3,3,3,174.0,157.9,0,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_02126,1,43,9254,1,1,1,1,38,38,9,9,142.0,125.9,0,0,0,1,0,1,0,19,0,6,0,0,0.0,0,0,6,11,1,10.0,0,10.8,1.4,1.74,0 +Student_02127,1,17,9500,1,2,1,1,38,1,5,7,131.0,118.4,1,0,0,1,0,1,0,20,0,7,9,6,13.766666666666666,0,0,8,9,8,13.744444444444444,0,16.2,0.3,-0.92,0 +Student_02128,1,1,9500,1,3,1,1,18,18,1,1,139.0,130.8,1,0,0,0,0,0,0,18,0,8,9,6,12.758333333333333,1,0,8,9,6,12.758333333333333,1,9.4,-0.8,-3.12,0 +Student_02129,1,1,171,1,1,1,1,19,19,8,8,170.0,176.7,1,0,0,1,0,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,0 +Student_02130,1,1,9070,1,1,1,1,19,1,5,7,182.0,156.8,1,0,0,1,0,0,0,18,0,6,6,6,12.666666666666666,0,0,6,8,6,13.25,0,10.8,1.4,1.74,2 +Student_02131,1,1,9085,1,1,1,1,19,37,3,7,125.0,126.8,0,0,0,1,0,0,0,18,0,6,13,6,12.0,0,0,6,16,4,12.75,0,11.1,0.6,2.02,1 +Student_02132,1,1,9238,1,1,1,1,1,37,5,7,142.0,128.0,0,0,0,1,0,1,0,19,0,6,8,6,NA,0,0,6,8,6,12.0,0,16.2,0.3,-0.92,2 +Student_02133,1,1,9147,1,2,1,1,19,37,4,5,119.0,113.8,1,0,0,1,0,0,0,20,0,5,8,3,11.333333333333334,0,0,5,8,5,12.2,0,7.6,2.6,0.32,2 +Student_02135,1,1,9500,1,3,1,1,19,38,1,1,150.0,130.8,1,0,0,1,0,0,0,18,0,8,8,7,13.614285714285714,0,0,8,8,7,13.614285714285714,0,12.7,3.7,-1.7,2 +Student_02136,1,39,9254,1,1,1,1,19,1,4,1,133.1,101.0,0,0,1,1,0,0,0,25,0,6,6,0,0.0,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_02139,1,17,9556,1,2,1,1,19,38,4,8,122.0,118.3,1,0,0,1,0,1,0,19,0,7,7,7,11.971428571428572,0,0,8,8,8,14.4375,0,15.5,2.8,-4.06,2 +Student_02141,1,17,9500,1,5,1,1,1,1,5,4,137.0,131.1,1,0,0,1,0,0,0,18,0,7,9,7,12.385714285714286,0,0,8,9,7,12.728571428571428,0,13.9,-0.3,0.79,1 +Student_02143,1,17,9238,1,1,1,1,1,1,9,9,123.0,115.7,1,0,0,1,0,0,0,21,0,6,8,6,12.166666666666666,0,0,6,7,6,13.285714285714286,0,11.1,0.6,2.02,2 +Student_02144,1,1,171,1,2,1,1,3,1,2,3,133.1,141.0,1,0,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_02146,1,17,9130,1,1,1,1,3,3,2,2,143.0,131.8,1,0,1,NA,0,0,0,18,0,6,9,5,12.4,0,0,6,12,5,14.166666666666666,0,8.9,1.4,3.51,1 +Student_02147,1,1,9070,1,1,1,1,37,37,9,6,150.0,131.1,0,0,0,1,0,1,0,19,0,6,7,5,13.4,0,0,6,6,6,12.833333333333334,0,15.5,2.8,-4.06,2 +Student_02148,1,1,9254,1,6,1,1,38,19,9,5,129.0,117.8,1,0,0,1,0,0,0,18,0,6,11,6,12.0,0,0,6,11,4,12.5,0,8.9,1.4,3.51,2 +Student_02150,1,1,9238,1,1,1,1,38,37,5,5,133.1,108.0,0,0,0,1,0,1,0,20,0,6,8,6,12.125,0,0,6,7,6,14.428571428571429,0,16.2,0.3,-0.92,2 +Student_02151,1,1,9853,1,1,1,1,1,19,3,3,132.0,122.9,1,0,0,1,0,0,0,20,0,7,7,7,13.857142857142858,0,0,7,7,7,13.285714285714286,0,11.1,0.6,2.02,2 +Student_02153,1,1,NA,1,4,1,1,38,37,7,7,137.0,126.0,1,0,0,1,0,0,0,19,0,7,9,7,14.283333333333337,0,0,8,9,8,13.125555555555556,0,15.5,2.8,-4.06,2 +Student_02154,1,42,9238,1,1,1,1,1,19,4,9,133.1,134.0,0,0,0,1,0,0,0,21,10,13,21,11,13.272727272727272,0,6,11,13,9,13.0,0,7.6,2.6,0.32,2 +Student_02155,1,1,9070,1,1,1,1,38,19,151,193,143.0,134.3,1,1,0,1,0,0,0,19,0,6,6,6,14.666666666666666,0,0,6,7,6,15.142857142857142,0,8.9,1.4,3.51,2 +Student_02156,1,1,9500,1,1,1,1,19,19,9,9,148.0,138.7,0,0,0,1,0,1,0,19,0,7,10,7,15.114999999999998,0,0,8,10,8,15.092,0,15.5,2.8,-4.06,2 +Student_02157,1,17,171,1,2,1,1,1,1,4,1,137.0,143.3,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,1 +Student_02158,1,44,NA,1,1,39,1,37,19,9,10,160.0,160.0,1,0,0,1,0,0,0,22,1,6,13,6,15.0,0,1,6,7,6,13.142857142857142,0,16.2,0.3,-0.92,2 +Student_02159,1,1,9853,1,2,1,1,3,1,3,5,112.0,111.0,0,0,0,1,0,0,0,21,0,6,8,5,13.2,0,0,6,9,5,14.333333333333334,0,9.4,-0.8,-3.12,2 +Student_02160,1,17,9254,1,4,1,1,37,37,5,8,133.0,128.5,1,0,0,1,0,1,0,18,0,6,14,2,11.0,0,0,6,14,3,10.333333333333334,0,7.6,2.6,0.32,0 +Student_02162,1,17,9670,1,2,1,1,34,37,0,0,123.0,114.6,1,0,1,0,0,0,0,18,0,5,8,3,12.0,0,0,5,6,4,10.75,0,7.6,2.6,0.32,0 +Student_02163,1,17,9238,1,1,1,1,19,37,7,NA,103.0,104.1,0,0,0,1,0,0,0,20,0,6,6,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_02164,1,17,9500,1,4,1,1,1,1,3,3,140.0,127.6,1,0,0,1,0,0,0,23,0,7,7,6,13.796666666666669,0,0,8,11,7,13.775,0,12.4,0.5,1.79,2 +Student_02165,1,1,9773,1,2,1,1,1,1,3,3,159.0,151.0,1,0,0,1,0,0,0,18,0,6,6,6,14.833333333333334,0,0,6,6,6,15.333333333333334,0,12.7,3.7,-1.7,2 +Student_02166,1,44,9238,1,1,39,1,1,1,9,3,140.0,135.7,1,0,0,1,0,0,0,20,3,6,6,6,12.833333333333334,0,2,6,6,6,13.833333333333334,0,12.4,0.5,1.79,2 +Student_02167,NA,17,9500,1,1,1,1,38,37,5,NA,148.0,137.8,1,0,0,1,0,1,0,18,0,8,8,7,14.962857142857144,0,0,8,8,7,14.962857142857144,0,10.8,1.4,1.74,2 +Student_02168,1,1,9147,1,6,1,1,38,38,9,9,112.0,117.3,1,0,0,1,0,0,0,20,0,5,8,4,12.0,0,0,5,8,5,11.2,0,11.1,0.6,2.02,2 +Student_02169,1,18,9500,1,2,1,1,1,3,3,2,131.0,121.2,1,0,0,1,0,0,0,18,0,7,8,7,12.4,0,0,8,9,8,12.8,0,16.2,0.3,-0.92,2 +Student_02170,1,NA,9670,1,1,1,1,3,3,2,1,145.0,129.3,1,0,0,1,0,0,0,20,0,6,7,6,15.571428571428571,0,0,6,6,6,17.166666666666668,0,16.2,0.3,-0.92,2 +Student_02171,1,1,9500,1,5,1,1,1,1,5,8,133.1,123.0,1,0,0,1,0,0,0,19,0,8,8,7,13.714285714285714,0,0,8,8,7,13.714285714285714,0,12.7,3.7,-1.7,2 +Student_02173,2,7,9070,1,1,43,1,NA,1,9,NA,140.0,140.0,0,0,0,1,0,0,0,33,0,6,7,6,15.0,0,0,6,8,3,11.0,0,11.1,0.6,2.02,2 +Student_02174,1,1,9085,1,1,1,1,12,2,4,2,150.0,144.6,0,0,1,0,0,0,0,24,0,5,6,1,13.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_02175,1,43,9238,1,1,1,1,1,38,4,3,120.0,118.3,0,0,0,1,NA,1,0,20,8,11,12,11,12.0,0,6,11,14,11,12.75,0,13.9,-0.3,0.79,2 +Student_02176,1,1,171,1,1,1,1,19,38,9,NA,156.0,153.6,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_02177,1,1,9070,1,4,1,1,1,1,7,3,167.0,158.3,1,0,0,1,0,0,0,18,0,6,6,6,15.166666666666666,0,0,6,6,6,14.166666666666666,0,15.5,2.8,-4.06,2 +Student_02179,1,17,9500,1,1,1,1,1,1,5,5,147.0,134.9,0,1,0,1,0,0,0,18,0,7,7,7,13.642857142857142,0,0,8,11,8,14.772727272727272,0,16.2,0.3,-0.92,2 +Student_02180,1,1,9773,1,3,1,1,38,37,5,5,129.0,142.0,1,0,0,1,0,0,0,19,0,6,8,6,12.666666666666666,0,0,6,7,6,12.714285714285714,0,9.4,-0.8,-3.12,2 +Student_02181,1,17,171,1,1,1,1,38,38,7,7,136.0,127.3,1,0,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_02182,1,17,9238,1,1,1,1,19,19,5,4,128.0,116.5,0,0,0,1,0,1,0,18,0,6,8,5,10.8,0,0,6,9,6,10.5,0,12.4,0.5,1.79,2 +Student_02183,1,43,9500,1,1,1,1,19,19,7,7,140.0,138.6,0,0,0,1,0,1,0,19,0,7,9,6,14.25,0,0,8,11,8,13.063636363636364,0,16.2,0.3,-0.92,2 +Student_02184,1,42,9853,1,1,1,1,37,19,9,3,141.0,133.0,0,0,0,1,0,0,0,20,6,14,22,12,12.153846153846152,0,5,12,18,10,12.9,0,10.8,1.4,1.74,0 +Student_02185,1,17,9238,1,2,1,1,2,1,3,4,133.0,136.2,1,0,0,1,0,0,0,19,0,6,14,1,11.5,0,0,6,12,2,10.5,0,7.6,2.6,0.32,1 +Student_02186,1,17,NA,1,1,1,1,19,19,7,5,125.0,118.0,1,0,0,NA,0,1,0,19,0,6,10,4,12.25,0,0,6,9,3,12.333333333333334,0,9.4,-0.8,-3.12,2 +Student_02187,1,1,9070,1,1,1,1,19,37,4,4,124.0,126.8,0,0,0,1,0,1,0,18,1,6,8,6,12.0,1,0,6,12,5,11.142857142857142,0,13.9,-0.3,0.79,1 +Student_02188,1,NA,9500,1,6,1,1,19,38,5,7,140.0,128.5,1,0,0,1,0,1,0,18,0,8,8,8,13.40375,0,0,8,8,8,13.40375,0,9.4,-0.8,-3.12,2 +Student_02189,1,17,9254,1,1,1,1,3,1,2,3,140.0,129.9,0,0,0,1,0,1,0,19,0,6,15,6,11.333333333333334,0,0,6,9,3,12.666666666666666,0,9.4,-0.8,-3.12,2 +Student_02191,1,17,171,1,1,1,1,37,37,9,6,144.0,129.3,1,0,0,1,1,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,1 +Student_02192,1,1,9500,1,6,1,1,4,19,2,3,138.0,124.7,1,0,0,1,1,0,0,18,0,7,0,0,0.0,0,0,8,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_02193,1,39,9003,1,1,1,1,3,1,2,4,130.0,154.9,0,0,1,0,1,0,0,35,0,6,8,5,16.166666666666668,0,0,6,10,4,16.0,0,8.9,1.4,3.51,0 +Student_02195,1,1,171,1,1,1,1,37,19,5,8,136.0,129.0,1,0,0,1,1,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_02199,1,1,9147,1,3,1,1,38,38,9,9,136.0,127.3,1,0,0,1,1,0,0,19,0,5,8,3,11.0,0,0,5,7,2,NA,0,12.7,3.7,-1.7,0 +Student_02200,1,39,9556,1,2,1,1,1,1,9,10,133.1,100.5,0,0,0,1,1,0,0,24,0,7,18,0,0.0,0,0,7,13,0,0.0,1,11.1,0.6,2.02,0 +Student_02201,1,39,8014,0,1,1,1,37,37,9,7,140.0,122.0,1,0,1,0,1,0,0,29,0,6,11,4,12.5,0,0,6,7,0,0.0,0,12.4,0.5,1.79,0 +Student_02202,1,39,9500,1,1,1,1,38,3,9,1,150.0,140.0,0,0,0,1,1,0,0,24,0,7,11,7,11.294444444444444,0,0,8,22,2,12.6,0,15.5,2.8,-4.06,2 +Student_02203,1,17,9254,1,2,1,1,19,38,6,6,121.0,116.1,1,0,0,1,1,0,0,19,0,6,8,5,11.2,0,0,6,11,4,12.5,0,15.5,2.8,-4.06,2 +Student_02204,2,7,171,1,1,3,1,19,19,9,9,120.0,130.0,1,0,0,1,1,0,0,37,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,0 +Student_02205,1,5,9070,1,2,1,1,1,1,4,10,143.0,146.2,1,0,0,1,1,0,0,18,0,6,7,5,13.2,0,0,6,6,5,11.8,0,16.2,0.3,-0.92,2 +Student_02206,1,44,9119,1,1,39,1,1,1,9,8,180.0,180.0,0,0,0,1,1,1,0,20,3,7,12,6,14.142857142857142,0,1,6,10,6,14.125,0,12.4,0.5,1.79,1 +Student_02207,1,1,9147,1,5,1,1,39,39,3,3,132.0,127.8,1,0,0,0,1,0,0,18,0,5,0,0,0.0,0,0,5,0,0,0.0,0,11.1,0.6,2.02,0 +Student_02208,1,43,9147,1,1,1,1,37,19,9,8,130.0,130.8,0,0,0,1,1,0,0,22,0,5,5,0,0.0,0,0,5,9,3,13.333333333333334,2,16.2,0.3,-0.92,1 +Student_02209,1,17,9147,1,2,1,1,38,38,4,7,133.1,109.0,1,0,0,1,1,1,0,22,0,5,7,3,12.333333333333334,0,0,5,9,3,10.571428571428571,0,10.8,1.4,1.74,1 +Student_02210,1,1,9773,1,5,1,1,1,38,9,5,131.0,132.4,1,0,1,0,1,0,0,18,0,6,6,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_02211,1,1,9500,1,3,1,1,1,1,4,4,149.0,129.3,1,0,0,1,1,0,0,18,0,8,8,7,13.1,0,0,8,8,7,13.1,0,12.7,3.7,-1.7,2 +Student_02213,1,1,9119,1,1,1,1,38,19,5,5,126.0,130.2,0,0,0,1,1,0,0,19,0,5,7,5,10.2,0,0,5,8,3,NA,0,10.8,1.4,1.74,1 +Student_02214,1,1,9238,1,1,1,1,19,38,9,9,140.0,132.0,0,0,0,1,1,0,0,19,0,6,10,5,11.571428571428571,0,0,6,10,3,13.0,0,16.2,0.3,-0.92,0 +Student_02215,1,44,9003,1,1,39,1,19,19,9,7,170.0,170.0,1,0,1,1,1,0,0,21,0,6,7,6,15.285714285714286,0,0,6,6,6,15.166666666666666,0,12.4,0.5,1.79,2 +Student_02216,1,1,9773,1,2,1,1,3,1,2,4,133.0,130.2,0,0,0,1,1,0,0,19,0,6,9,5,12.6,0,6,10,16,8,11.0,1,8.9,1.4,3.51,1 +Student_02217,1,18,9556,1,2,1,1,3,3,2,2,126.0,115.5,0,0,0,1,1,0,0,18,0,7,11,6,13.433333333333332,0,0,7,10,4,13.6,0,8.9,1.4,3.51,2 +Student_02220,1,1,9070,1,1,1,1,37,1,9,8,130.0,120.2,1,0,0,1,1,0,0,22,0,6,9,6,14.666666666666666,0,0,6,12,6,14.666666666666666,0,NA,3.7,-1.7,2 +Student_02221,1,39,9500,1,1,1,1,1,1,4,9,130.0,150.0,0,0,0,1,1,0,0,24,0,8,8,7,12.742857142857144,0,0,8,8,7,12.742857142857144,0,12.7,3.7,-1.7,2 +Student_02222,1,1,9500,1,2,1,1,1,3,5,10,99.0,100.0,1,0,0,1,1,0,0,19,0,7,9,7,11.975,0,0,8,9,7,13.12857142857143,0,13.9,-0.3,0.79,2 +Student_02223,1,43,9119,1,1,1,1,3,1,2,3,146.0,100.0,0,0,0,1,1,0,0,18,0,5,9,4,12.25,0,0,5,11,3,11.666666666666666,0,13.9,-0.3,0.79,1 +Student_02224,1,17,171,1,1,1,1,38,37,4,6,129.0,128.0,0,0,0,0,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02227,1,1,9670,1,1,1,1,3,3,3,3,116.0,110.1,1,0,0,1,1,0,0,19,0,6,9,5,13.333333333333334,0,0,6,6,5,13.0,0,12.4,0.5,1.79,2 +Student_02229,2,39,9773,1,1,1,1,37,38,9,3,120.0,155.5,0,0,0,1,1,0,0,47,0,6,12,5,13.8,0,0,6,13,4,14.0,0,12.7,3.7,-1.7,0 +Student_02230,1,1,9070,1,1,1,1,1,1,3,9,117.0,118.4,0,0,0,1,1,0,0,19,0,6,6,6,11.833333333333334,0,0,6,8,4,10.75,2,16.2,0.3,-0.92,2 +Student_02231,1,1,171,1,4,1,1,1,38,4,8,137.0,141.2,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,2 +Student_02232,1,1,171,1,1,1,1,3,3,2,NA,124.0,119.1,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_02233,1,43,9147,1,1,1,1,1,3,1,1,151.0,111.0,0,0,0,1,1,0,0,28,0,5,9,2,10.0,0,0,5,9,0,0.0,0,15.5,2.8,-4.06,0 +Student_02234,1,43,9254,1,1,6,1,34,34,0,0,138.6,138.6,1,0,0,1,1,0,0,20,0,6,10,4,11.5,0,0,6,11,3,11.666666666666666,0,7.6,2.6,0.32,0 +Student_02236,1,1,171,1,1,1,1,19,19,4,8,136.0,150.4,1,0,0,1,1,1,0,NA,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,2 +Student_02237,1,1,9254,1,1,1,1,38,19,9,4,123.0,117.8,0,0,0,1,1,0,0,19,0,6,10,4,12.75,0,0,6,12,2,13.0,0,10.8,1.4,1.74,1 +Student_02238,1,39,9254,1,1,19,1,38,37,4,5,133.1,102.5,0,0,1,0,1,0,0,24,0,6,7,0,0.0,0,0,6,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_02240,1,39,9085,1,1,12,1,38,19,9,8,133.1,138.3,1,0,1,0,1,0,0,25,0,6,6,0,0.0,0,0,6,6,0,0.0,0,8.9,1.4,3.51,1 +Student_02241,1,39,9254,1,1,1,1,3,1,3,4,150.0,122.3,0,0,0,1,1,0,0,28,0,6,10,6,13.0,0,0,6,8,5,12.2,0,13.9,-0.3,0.79,2 +Student_02243,1,43,9119,1,1,1,1,1,38,4,7,128.0,100.0,0,0,0,1,1,0,0,19,0,5,8,5,12.0,0,0,5,12,2,10.5,0,13.9,-0.3,0.79,1 +Student_02244,1,17,9500,1,4,1,1,38,37,5,7,133.0,126.4,1,0,0,1,1,1,0,18,0,7,7,7,13.462857142857144,0,0,8,8,8,13.90625,0,11.1,0.6,2.02,2 +Student_02245,1,39,9254,1,1,19,1,37,37,90,90,133.1,100.0,0,0,0,1,1,0,0,48,0,6,13,3,10.0,0,0,6,15,1,10.0,0,7.6,2.6,0.32,0 +Student_02246,1,17,9238,1,4,1,1,37,37,9,8,129.0,117.1,1,0,0,1,1,0,0,21,0,6,6,6,12.333333333333334,0,0,6,7,6,13.666666666666666,0,8.9,1.4,3.51,2 +Student_02247,1,17,9500,1,1,1,1,1,1,4,5,128.0,124.7,0,0,0,1,1,1,0,19,0,7,11,6,12.528571428571428,0,0,7,10,6,12.416666666666666,0,15.5,2.8,-4.06,1 +Student_02250,1,1,9130,1,1,1,1,1,1,4,10,141.0,NA,1,0,0,1,1,0,0,18,0,5,5,5,13.6,0,0,5,6,4,13.25,1,10.8,1.4,1.74,2 +Student_02252,1,16,171,1,1,1,1,19,37,9,7,122.0,133.9,1,0,0,1,1,0,0,25,9,13,16,10,11.454545454545457,0,5,11,13,7,12.25,0,12.4,0.5,1.79,0 +Student_02253,1,7,9085,1,1,40,1,5,3,2,2,140.0,140.0,0,0,1,1,1,0,0,27,8,13,13,8,13.5,2,5,11,12,5,14.4,0,11.1,0.6,2.02,0 +Student_02254,NA,39,9119,1,1,12,1,34,34,0,0,133.1,95.1,0,0,0,0,1,0,0,49,0,5,5,0,0.0,0,0,5,6,0,0.0,0,10.8,1.4,1.74,0 +Student_02255,1,39,9991,0,1,1,1,19,37,5,5,120.0,128.2,0,0,0,0,1,0,0,31,0,5,5,2,11.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02256,1,39,9254,1,1,1,1,37,37,9,6,133.1,121.5,0,0,0,1,1,0,0,54,0,6,9,6,13.714285714285714,0,0,6,13,5,14.333333333333334,0,16.2,0.3,-0.92,0 +Student_02257,1,7,33,1,1,40,1,38,37,5,6,120.0,120.0,1,0,1,0,1,0,0,25,18,21,26,21,12.363636363636363,0,12,16,21,12,12.25,1,11.1,0.6,2.02,0 +Student_02258,1,44,9003,1,1,39,1,5,3,2,2,130.0,130.0,0,0,0,1,1,0,0,20,1,7,13,3,10.666666666666666,0,0,6,14,2,11.5,0,15.5,2.8,-4.06,1 +Student_02259,1,7,9070,1,1,3,1,4,4,2,2,120.0,120.0,0,0,0,1,1,0,0,28,0,6,9,2,12.0,0,0,6,10,3,12.666666666666666,0,12.7,3.7,-1.7,0 +Student_02260,2,39,8014,0,1,19,1,37,37,9,6,133.1,107.0,0,0,0,1,1,0,0,41,1,7,7,7,12.857142857142858,0,0,6,6,6,13.166666666666666,0,12.7,3.7,-1.7,2 +Student_02261,1,1,9670,1,2,1,1,1,19,4,4,122.0,116.1,0,0,0,1,1,1,0,19,0,6,10,6,13.125,0,0,6,9,6,12.714285714285714,0,11.1,0.6,2.02,1 +Student_02262,1,43,9147,1,1,1,1,1,1,4,4,123.0,114.4,0,0,0,1,1,0,0,22,0,5,6,0,0.0,0,0,5,8,2,11.5,0,15.5,2.8,-4.06,0 +Student_02263,1,1,9254,1,1,1,1,2,1,2,3,178.0,157.7,0,0,0,1,1,0,0,34,0,6,13,2,13.5,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_02264,1,39,9003,1,1,1,1,38,38,9,9,130.0,150.0,0,0,1,0,1,0,0,28,5,11,14,11,15.090909090909092,0,5,10,11,10,15.0,0,NA,0.6,2.02,0 +Student_02265,1,1,9853,1,1,1,1,37,37,9,4,110.0,114.3,1,0,0,1,1,0,0,42,0,6,9,5,12.4,0,0,6,10,5,11.8,0,7.6,2.6,0.32,1 +Student_02266,1,18,9085,1,1,1,1,1,19,3,5,106.0,104.6,0,0,0,0,1,0,0,21,0,6,10,5,14.0,0,0,6,11,4,14.8,0,11.1,0.6,NA,1 +Student_02267,1,7,9003,1,1,3,1,39,39,9,4,140.0,140.0,0,0,0,NA,1,0,0,50,2,6,8,2,13.5,0,1,6,9,1,13.0,0,15.5,2.8,-4.06,0 +Student_02268,1,1,9147,1,4,1,1,3,1,3,4,108.0,109.1,1,0,0,1,1,0,0,19,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.4,0.5,1.79,0 +Student_02269,1,43,9500,1,1,1,1,3,4,2,4,120.0,120.6,0,0,0,1,1,0,0,18,0,7,12,4,12.65,0,0,7,10,3,10.666666666666666,0,16.2,0.3,-0.92,0 +Student_02270,2,39,9991,0,1,1,1,37,37,1,1,100.0,161.9,0,0,0,1,1,0,0,59,0,5,7,0,0.0,0,0,5,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_02271,2,7,9991,0,1,3,1,34,34,99,99,140.0,140.0,1,0,0,0,1,0,0,33,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_02272,1,17,9070,1,2,1,1,37,38,9,10,133.1,NA,1,0,0,1,1,1,0,23,0,6,8,6,13.333333333333334,0,0,6,7,5,12.8,0,9.4,-0.8,-3.12,2 +Student_02273,2,39,9991,0,1,19,1,37,1,5,5,133.1,138.3,0,0,0,1,1,0,0,44,0,5,9,3,11.333333333333334,0,0,5,8,5,11.142857142857142,0,13.9,-0.3,0.79,0 +Student_02274,2,1,8014,0,4,1,1,34,34,0,0,140.0,128.0,1,0,0,1,1,0,0,37,0,6,0,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02275,2,39,171,1,1,19,1,37,37,9,9,100.0,139.0,0,0,0,1,1,0,0,36,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_02276,1,1,9991,0,2,1,1,1,3,4,2,123.0,113.2,0,0,0,0,1,0,0,22,0,5,7,3,11.666666666666666,0,0,5,8,2,10.5,2,7.6,2.6,0.32,0 +Student_02277,NA,39,8014,0,1,19,1,37,37,6,6,133.1,139.0,0,0,0,1,1,0,0,49,0,6,8,6,12.166666666666666,0,0,6,8,6,14.428571428571429,0,12.4,0.5,1.79,2 +Student_02278,1,NA,9773,1,1,1,1,1,42,5,3,135.0,110.0,1,0,0,1,1,0,0,23,0,6,7,6,13.333333333333334,0,0,6,6,4,12.75,0,11.1,0.6,2.02,2 +Student_02279,NA,1,9070,1,1,1,1,1,1,4,9,132.0,136.6,1,0,0,1,1,0,0,19,0,6,7,5,11.4,0,0,6,10,3,11.0,3,7.6,2.6,0.32,1 +Student_02280,2,43,8014,0,1,1,1,37,37,5,5,120.0,161.1,0,0,0,1,1,0,0,47,0,6,9,6,NA,0,0,6,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_02281,1,43,9003,1,1,1,1,1,2,4,2,130.0,130.0,0,0,0,1,1,0,0,28,9,18,36,17,13.058823529411764,1,6,12,15,12,12.307692307692308,0,15.5,2.8,-4.06,2 +Student_02282,1,44,9003,1,1,39,NA,1,38,9,6,140.0,140.0,0,0,0,1,1,0,0,21,0,6,13,4,11.75,0,0,6,15,4,10.5,0,15.5,2.8,-4.06,1 +Student_02283,1,1,9254,1,1,1,1,38,1,9,9,133.1,121.0,0,0,1,0,NA,0,0,21,0,6,9,5,11.833333333333334,0,0,6,8,5,10.0,0,8.9,1.4,3.51,0 +Student_02284,1,43,9238,1,1,39,1,2,1,1,2,120.0,118.6,0,0,0,1,1,0,0,21,9,11,14,10,12.4,0,6,10,13,10,11.8,0,13.9,-0.3,0.79,2 +Student_02285,1,1,9070,1,1,1,1,19,38,4,4,140.0,138.3,0,0,0,1,1,0,0,20,1,6,8,6,13.428571428571429,1,0,6,12,4,NA,0,13.9,-0.3,0.79,1 +Student_02286,2,42,9147,1,1,1,1,37,37,9,9,133.1,115.8,0,0,0,0,1,0,0,49,0,5,5,0,0.0,0,0,5,9,0,0.0,0,10.8,1.4,1.74,0 +Student_02287,1,39,9991,0,1,1,1,19,37,6,8,120.0,160.0,0,0,0,1,NA,0,0,40,0,5,5,5,11.0,0,0,5,5,5,13.4,0,15.5,2.8,-4.06,2 +Student_02288,1,17,9254,1,1,1,1,1,1,3,3,125.0,114.5,0,0,0,1,1,1,0,22,0,6,8,6,13.625,0,0,6,8,6,14.428571428571429,0,11.1,0.6,2.02,2 +Student_02289,1,42,9119,1,1,1,1,1,37,5,5,136.0,117.5,0,0,0,1,1,0,0,19,2,5,6,4,11.8,0,0,5,7,2,11.5,0,15.5,2.8,-4.06,1 +Student_02290,1,39,9991,0,1,1,1,3,38,2,7,133.1,121.7,0,0,0,1,1,0,0,31,0,5,5,0,0.0,0,0,5,7,0,0.0,0,13.9,-0.3,0.79,0 +Student_02292,1,1,9238,1,1,1,1,37,37,5,10,127.0,125.3,0,0,0,1,1,0,0,19,0,6,9,5,10.8,0,0,6,11,5,11.0,0,7.6,2.6,0.32,2 +Student_02293,1,18,9147,1,1,1,1,34,34,90,90,131.0,131.0,0,0,0,1,1,0,0,22,0,5,11,3,13.666666666666666,0,0,5,10,3,11.333333333333334,0,9.4,-0.8,-3.12,0 +Student_02294,1,1,9773,1,1,1,1,19,37,9,9,127.0,126.3,0,0,0,1,1,0,0,19,0,6,8,6,12.833333333333334,0,0,6,8,6,13.333333333333334,0,15.5,2.8,-4.06,2 +Student_02296,1,17,9670,1,3,1,1,1,38,4,7,137.0,138.4,0,0,0,1,1,0,0,19,0,6,8,6,15.125,0,0,6,7,6,13.428571428571429,0,11.1,0.6,2.02,2 +Student_02297,1,43,9147,1,2,1,1,1,19,3,3,126.0,100.0,1,0,0,1,1,0,0,22,0,5,11,0,0.0,0,0,5,7,1,10.0,1,16.2,0.3,-0.92,0 +Student_02298,1,1,9238,1,1,1,1,4,5,2,2,136.0,126.2,0,0,0,1,1,0,0,22,0,6,10,5,11.4,0,0,6,8,5,11.0,0,10.8,1.4,1.74,2 +Student_02299,1,1,9238,1,1,1,1,1,1,4,4,124.0,118.8,0,0,0,1,1,0,0,19,0,6,12,4,12.25,0,0,6,9,6,11.0,0,9.4,-0.8,-3.12,2 +Student_02302,1,17,9070,1,1,1,1,19,19,7,7,131.0,125.1,0,0,0,1,1,0,0,18,0,6,7,6,12.333333333333334,0,0,6,10,5,10.8,4,16.2,0.3,-0.92,1 +Student_02303,1,1,9147,1,1,1,1,37,37,9,9,130.0,118.8,0,0,1,1,1,1,0,22,0,5,8,5,10.666666666666666,0,0,5,11,2,11.0,0,15.5,2.8,-4.06,1 +Student_02304,1,18,9119,1,5,1,1,3,2,2,3,136.0,125.2,1,0,0,1,1,0,0,19,0,5,9,5,11.833333333333334,0,0,5,9,5,14.714285714285714,0,12.4,0.5,1.79,1 +Student_02305,1,17,9147,1,1,1,1,1,19,4,8,133.1,95.0,0,0,0,1,1,0,0,20,0,5,14,0,0.0,0,0,5,5,0,0.0,0,11.1,0.6,2.02,0 +Student_02306,1,1,9070,1,3,1,1,37,37,9,9,110.0,107.6,1,0,0,1,1,1,0,22,0,6,6,6,11.666666666666666,0,0,6,6,6,12.166666666666666,0,7.6,2.6,0.32,1 +Student_02307,1,7,9130,1,1,3,1,2,38,2,3,140.0,140.0,1,0,0,0,1,0,0,18,2,5,7,2,13.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_02308,4,43,9991,0,2,38,1,3,1,2,9,133.1,125.4,0,0,0,1,1,0,0,39,0,2,5,0,0.0,0,0,4,4,0,0.0,0,10.8,1.4,1.74,0 +Student_02309,1,1,9500,1,1,1,1,19,1,90,NA,141.0,128.0,0,0,0,1,1,0,0,18,0,8,8,0,0.0,3,0,8,8,0,0.0,3,10.8,1.4,1.74,0 +Student_02310,1,17,9119,1,3,1,1,1,38,3,3,130.0,129.3,0,0,0,1,1,1,0,18,0,5,5,5,13.0,0,0,5,5,5,14.2,0,8.9,1.4,3.51,2 +Student_02311,1,1,9238,1,1,1,1,19,38,9,9,160.0,152.0,0,0,0,1,1,1,0,19,0,6,7,6,13.857142857142858,0,0,6,6,6,14.0,0,13.9,-0.3,0.79,2 +Student_02312,1,1,9500,1,1,1,1,1,19,9,9,140.0,128.8,0,0,0,1,1,0,0,18,0,7,7,6,13.391666666666666,0,0,8,8,8,12.4875,0,12.4,0.5,1.79,2 +Student_02313,1,1,9147,1,1,1,1,34,19,0,4,150.0,152.8,1,0,0,1,1,1,0,18,0,5,7,4,12.75,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_02314,1,44,9130,1,1,39,1,37,37,6,6,150.0,150.0,1,0,0,1,1,0,0,22,0,5,7,4,14.5,0,0,5,5,5,14.6,0,10.8,1.4,1.74,2 +Student_02315,1,1,9238,1,1,1,1,1,1,3,4,133.1,112.0,0,0,0,1,1,0,0,19,0,6,7,6,12.166666666666666,0,0,6,6,6,12.166666666666666,0,12.4,0.5,1.79,2 +Student_02316,1,1,9130,1,1,1,1,19,37,9,8,152.0,135.6,1,0,0,1,1,0,0,18,0,5,5,5,15.4,0,0,5,5,5,15.6,0,12.7,3.7,-1.7,0 +Student_02317,1,39,9119,1,1,19,1,1,1,4,3,133.1,134.4,0,0,1,0,1,0,0,31,0,5,9,2,13.333333333333334,0,0,5,9,2,16.0,4,16.2,0.3,-0.92,0 +Student_02318,1,39,9991,0,1,1,1,3,1,3,3,130.0,120.5,0,0,0,1,1,0,0,28,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_02319,1,1,9070,1,1,1,1,1,1,4,8,148.0,141.4,0,0,0,1,1,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,NA,0 +Student_02320,1,17,9254,1,1,1,1,1,1,4,8,148.0,145.2,0,0,0,1,1,0,0,20,0,6,7,6,13.714285714285714,0,0,6,8,6,14.714285714285714,0,16.2,0.3,-0.92,2 +Student_02322,1,43,9070,1,1,1,1,1,2,4,2,160.0,100.0,0,0,0,1,1,0,0,38,1,6,9,5,16.0,1,0,6,11,4,16.5,0,13.9,-0.3,0.79,1 +Student_02323,2,39,9991,0,1,1,1,37,37,9,9,130.0,140.0,1,0,0,1,1,0,0,31,0,5,8,1,11.0,0,0,5,5,1,13.0,0,9.4,-0.8,-3.12,0 +Student_02324,1,39,9500,1,1,1,1,1,37,9,9,110.0,126.0,1,0,0,1,1,0,0,27,0,7,7,7,14.085714285714284,0,0,7,7,7,14.085714285714284,0,7.6,2.6,0.32,1 +Student_02325,1,18,9238,1,1,1,1,1,3,9,2,NA,112.6,1,0,0,1,1,0,0,21,0,6,9,6,10.166666666666666,0,0,6,10,6,10.5,0,12.7,3.7,-1.7,2 +Student_02326,2,39,9119,1,1,1,1,37,37,9,9,110.0,106.8,0,0,0,1,1,0,0,34,0,5,8,1,10.0,0,0,5,9,0,0.0,0,8.9,1.4,3.51,0 +Student_02329,1,1,171,1,1,1,1,38,19,9,2,170.0,160.6,1,0,0,1,1,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_02330,2,39,9070,1,1,12,1,37,38,5,10,110.0,130.0,0,0,1,0,1,1,0,46,0,6,6,0,0.0,0,0,6,6,0,0.0,0,15.5,2.8,NA,0 +Student_02332,1,39,9003,1,1,1,1,19,37,9,7,133.1,110.0,1,0,0,1,1,0,0,31,0,6,8,0,0.0,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_02335,1,1,9670,1,1,1,1,38,37,9,NA,137.0,122.3,0,0,0,1,1,1,0,18,0,6,7,6,13.571428571428571,0,0,6,6,6,14.333333333333334,0,12.4,0.5,1.79,2 +Student_02337,1,43,9991,0,1,1,1,NA,19,9,4,100.0,130.0,0,0,0,1,1,0,0,40,1,5,6,4,10.25,0,3,8,18,5,11.2,5,15.5,2.8,-4.06,0 +Student_02338,1,39,9130,1,1,1,1,1,38,9,9,120.0,150.0,0,0,0,1,1,0,0,25,0,6,6,0,0.0,0,0,6,6,0,0.0,0,12.4,0.5,1.79,0 +Student_02339,1,17,9119,1,5,1,1,38,38,5,9,126.0,116.9,1,0,1,1,1,0,0,20,0,5,5,4,14.5,0,0,6,8,3,13.333333333333334,0,11.1,0.6,2.02,0 +Student_02340,1,17,9119,1,1,1,1,19,19,9,9,122.0,114.7,0,0,0,1,1,0,0,20,0,5,6,5,15.8,0,0,5,8,5,13.714285714285714,0,11.1,0.6,2.02,1 +Student_02341,1,39,9003,1,1,1,1,37,37,9,10,111.0,95.8,1,0,0,0,1,0,0,NA,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_02342,1,17,9119,1,4,1,1,37,19,9,4,139.0,133.1,1,0,0,1,1,0,0,18,0,5,8,4,12.5,0,0,5,7,3,14.666666666666666,1,7.6,2.6,0.32,1 +Student_02344,1,17,9991,0,2,1,1,37,19,9,4,116.0,118.5,0,0,0,1,1,0,0,23,0,5,6,4,13.0,0,0,5,5,5,13.0,0,7.6,2.6,0.32,2 +Student_02346,1,53,9085,1,1,42,1,1,19,3,8,150.0,150.3,1,0,0,1,1,1,0,21,7,11,15,9,14.22222222222222,0,4,9,15,7,13.75,0,8.9,1.4,3.51,2 +Student_02347,1,43,9670,1,1,1,1,3,19,4,8,132.0,120.5,0,0,0,1,1,0,0,19,0,6,17,4,12.5,0,0,6,8,4,13.25,0,13.9,-0.3,0.79,1 +Student_02348,1,18,9119,1,1,1,1,1,1,4,3,108.0,105.6,1,0,0,1,1,0,0,20,0,5,7,5,12.166666666666666,0,0,5,7,5,15.285714285714286,0,12.4,0.5,1.79,2 +Student_02350,4,39,9254,1,1,1,1,37,19,9,9,120.0,131.0,1,0,0,1,1,0,0,44,0,6,6,6,12.666666666666666,0,0,6,6,6,11.5,0,12.4,0.5,1.79,2 +Student_02351,1,18,9500,1,1,1,1,19,3,4,9,NA,127.0,0,0,0,1,1,0,0,19,0,8,8,7,13.614285714285714,0,0,8,8,7,13.614285714285714,0,12.7,3.7,-1.7,2 +Student_02352,1,44,9130,1,1,39,1,2,1,3,6,150.0,150.0,1,0,0,1,1,0,0,22,11,18,32,12,12.857142857142858,1,8,12,15,10,14.3,0,16.2,0.3,-0.92,2 +Student_02353,1,1,9130,1,1,1,1,3,3,1,2,160.0,149.2,0,0,0,1,1,0,0,18,0,5,7,4,14.0,0,0,5,5,5,14.2,0,7.6,2.6,0.32,2 +Student_02354,1,17,9670,1,1,1,1,37,37,9,9,125.0,121.5,1,0,0,1,1,1,0,21,0,6,8,4,14.75,0,0,6,6,5,11.8,0,12.7,3.7,-1.7,2 +Student_02355,1,1,9085,1,2,1,1,37,19,90,90,125.0,137.3,0,0,0,1,1,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_02356,1,17,9670,1,4,1,1,3,1,2,3,122.0,119.6,1,0,0,1,1,0,0,18,0,6,8,6,13.625,0,0,6,7,6,14.285714285714286,0,11.1,0.6,2.02,2 +Student_02357,1,1,171,1,1,1,1,1,1,4,3,138.0,141.5,0,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_02358,1,44,9003,1,1,39,1,1,38,6,6,150.0,150.0,1,0,0,1,1,0,0,21,0,6,12,4,11.8,0,0,6,11,4,11.875,0,16.2,0.3,-0.92,0 +Student_02359,1,39,9003,1,1,1,1,3,3,2,2,140.0,110.0,0,0,0,1,1,0,0,31,0,6,8,6,15.125,0,0,6,10,6,14.6,0,16.2,0.3,-0.92,2 +Student_02361,1,39,9119,1,1,1,1,19,19,9,7,139.0,110.3,0,0,1,1,1,0,0,24,0,5,12,1,10.0,0,0,5,11,1,11.0,0,8.9,1.4,3.51,1 +Student_02362,1,42,9773,1,1,1,1,19,6,4,3,133.1,120.0,0,0,0,1,1,0,0,27,0,4,8,0,0.0,0,0,5,10,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02363,1,1,9147,1,5,1,1,19,19,9,9,118.0,114.2,1,0,0,1,1,0,0,20,0,5,9,3,10.333333333333334,0,0,5,6,5,12.8,0,12.4,0.5,1.79,2 +Student_02364,1,44,9119,1,1,39,1,1,19,4,5,140.0,140.0,1,0,0,1,1,0,0,22,0,5,9,0,0.0,0,0,5,6,2,11.666666666666666,0,10.8,1.4,1.74,1 +Student_02365,1,1,9003,1,1,1,1,19,19,9,9,144.0,132.8,0,0,0,1,1,1,0,19,0,6,9,4,12.0,2,0,6,10,4,12.5,0,15.5,2.8,-4.06,1 +Student_02366,1,18,9773,1,1,1,1,1,1,4,7,125.0,121.5,1,0,0,1,1,0,0,19,0,6,6,6,13.833333333333334,0,0,6,6,6,14.5,0,8.9,1.4,3.51,2 +Student_02367,1,1,171,1,1,1,1,1,1,7,4,131.0,127.2,1,0,1,1,1,0,0,23,13,17,19,13,12.153846153846152,0,10,17,28,11,11.909090909090908,1,11.1,0.6,2.02,1 +Student_02369,1,1,9773,1,1,1,1,3,2,4,6,140.0,133.4,1,0,0,0,1,0,0,29,0,6,8,6,16.5,0,0,6,6,5,13.8,0,11.1,0.6,2.02,1 +Student_02371,1,NA,9003,1,1,1,1,1,1,4,5,140.0,140.0,0,0,0,1,1,0,0,20,0,6,11,6,11.285714285714286,0,0,6,12,5,11.77777777777778,0,16.2,0.3,-0.92,1 +Student_02372,1,1,171,1,5,1,1,19,3,9,2,139.0,136.9,1,0,0,1,1,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_02373,1,17,171,1,3,1,1,3,39,2,5,125.0,117.0,1,1,0,1,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,1 +Student_02374,1,1,9670,1,2,1,1,3,1,3,5,117.0,110.7,1,0,0,1,1,0,0,20,0,6,10,5,14.0,0,0,6,10,6,12.0,0,11.1,0.6,2.02,1 +Student_02375,1,39,9130,1,1,1,1,19,19,9,5,150.0,160.0,1,0,0,1,1,0,0,24,0,5,13,4,13.75,1,0,5,9,3,12.0,0,9.4,-0.8,-3.12,1 +Student_02376,1,1,9670,1,1,1,1,37,37,5,8,95.0,95.0,0,0,0,0,1,0,0,21,0,6,9,4,13.25,0,0,6,6,5,11.0,0,12.7,3.7,-1.7,0 +Student_02377,1,39,9147,1,1,1,1,37,1,7,3,150.0,148.8,0,0,0,1,1,1,0,25,0,5,7,4,14.25,0,0,5,7,4,14.75,0,12.7,3.7,-1.7,2 +Student_02378,1,39,9147,1,1,1,1,37,37,9,9,120.0,110.0,0,0,0,0,1,0,0,32,0,5,9,0,0.0,1,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02379,1,43,9991,0,1,1,1,3,4,2,2,136.0,133.9,0,0,0,0,1,0,0,26,8,12,12,8,11.25,0,3,8,8,3,11.333333333333334,0,7.6,2.6,0.32,0 +Student_02380,1,1,9130,1,1,1,1,2,37,9,7,133.0,125.7,1,0,0,1,1,1,0,18,0,6,7,6,13.5,0,0,6,8,6,12.5,0,12.4,0.5,1.79,2 +Student_02382,1,1,9070,1,3,1,1,19,38,5,7,127.0,141.0,1,0,0,1,1,1,0,19,0,6,6,6,15.166666666666666,0,0,6,6,6,12.333333333333334,0,12.4,0.5,1.79,2 +Student_02383,1,7,9119,1,1,40,1,1,1,4,4,130.0,130.0,0,0,0,1,1,0,0,27,4,6,6,6,13.166666666666666,0,2,5,7,5,15.142857142857142,0,11.1,0.6,2.02,0 +Student_02384,1,53,9003,1,1,1,1,19,1,9,9,130.0,130.0,0,0,1,1,1,0,0,21,7,12,20,10,11.8,0,5,12,15,9,11.444444444444445,0,8.9,1.4,3.51,1 +Student_02385,1,17,9119,1,1,1,1,19,1,4,5,127.0,115.8,0,0,0,1,1,0,0,20,0,5,10,4,11.5,0,0,5,11,0,0.0,0,13.9,-0.3,0.79,1 +Student_02386,1,44,9070,1,1,39,1,19,38,4,0,140.0,140.0,1,0,0,1,1,0,0,21,0,6,6,6,14.5,0,0,6,8,6,11.333333333333334,0,12.4,0.5,1.79,2 +Student_02387,1,1,9773,1,5,1,1,37,3,5,2,125.0,126.1,1,0,0,1,1,0,0,22,0,6,10,5,13.4,0,0,6,12,3,10.666666666666666,0,9.4,-0.8,-3.12,1 +Student_02388,1,1,171,1,1,1,1,1,38,5,7,135.0,137.5,1,0,1,0,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_02389,1,17,9147,1,4,1,1,38,19,5,5,132.0,120.8,1,0,0,1,1,1,0,18,0,5,8,4,10.8,0,0,5,10,2,12.5,0,11.1,0.6,2.02,0 +Student_02391,2,39,9003,1,1,1,1,1,37,9,1,130.0,122.0,0,0,1,0,1,0,0,25,3,10,23,6,11.428571428571429,0,2,7,15,4,12.0,1,15.5,2.8,-4.06,0 +Student_02392,1,43,9003,1,1,1,1,37,1,5,4,130.0,130.0,0,0,0,1,1,0,0,25,8,14,24,8,12.5,2,6,13,23,10,11.6,0,15.5,2.8,-4.06,0 +Student_02393,1,1,9147,1,1,1,1,38,19,9,5,135.0,126.3,0,0,0,1,1,0,0,18,0,5,11,2,13.5,0,0,5,11,3,12.333333333333334,0,8.9,1.4,3.51,1 +Student_02394,1,1,9254,1,1,1,1,4,19,4,5,133.1,98.0,0,0,0,1,1,0,0,26,0,6,6,0,0.0,0,0,6,12,0,0.0,0,10.8,1.4,NA,0 +Student_02395,1,17,9147,1,3,1,1,37,37,6,5,135.0,121.0,1,0,0,1,1,1,0,18,0,5,8,5,12.75,0,0,5,7,5,11.5,0,13.9,-0.3,0.79,2 +Student_02396,1,43,9773,1,1,1,1,19,38,9,7,128.0,124.2,1,0,0,1,1,0,0,22,0,6,17,3,11.333333333333334,3,0,6,14,3,12.333333333333334,0,15.5,2.8,-4.06,1 +Student_02397,1,39,9003,1,1,1,1,1,3,4,5,140.0,130.0,0,0,0,1,1,0,0,25,0,6,8,0,0.0,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_02398,1,1,9773,1,2,1,1,3,1,4,4,135.0,136.1,1,0,0,1,1,0,0,19,0,6,9,5,11.4,0,0,6,13,5,12.4,0,8.9,1.4,3.51,1 +Student_02399,1,17,9773,1,2,1,1,3,19,2,3,131.0,132.8,1,0,0,1,1,0,0,19,0,6,7,6,14.428571428571429,0,0,6,7,6,14.571428571428571,0,13.9,-0.3,0.79,2 +Student_02400,1,17,9500,1,1,1,1,1,1,5,5,131.0,126.3,0,0,0,1,1,0,0,19,0,7,9,7,12.492857142857144,0,0,8,10,8,11.7125,0,16.2,0.3,-0.92,2 +Student_02401,4,39,8014,0,1,19,1,1,37,9,1,100.0,111.5,0,0,0,1,1,0,0,45,2,8,10,4,11.5,0,2,8,13,4,11.0,0,10.8,1.4,1.74,0 +Student_02402,NA,39,9991,0,1,1,1,37,37,9,9,140.0,118.2,0,0,0,1,1,0,0,52,0,5,7,5,11.2,0,0,5,6,5,12.8,1,7.6,2.6,0.32,2 +Student_02403,1,1,9147,1,1,1,1,19,19,9,3,124.0,115.6,1,0,0,0,1,0,0,20,0,5,9,3,12.0,1,0,5,7,3,11.0,0,9.4,-0.8,-3.12,0 +Student_02404,1,1,9500,1,1,1,1,38,37,5,10,130.0,117.8,1,0,0,1,1,0,0,19,0,8,8,7,15.885714285714286,0,0,8,8,7,15.885714285714286,0,10.8,1.4,1.74,2 +Student_02405,1,1,NA,1,1,1,1,1,38,9,9,142.0,127.0,0,0,1,0,1,0,0,21,0,7,12,4,12.94,0,0,7,12,4,11.58,0,12.4,0.5,1.79,0 +Student_02406,2,39,8014,0,1,1,1,37,37,9,9,150.0,140.0,0,0,0,0,1,0,0,35,0,6,6,6,14.0,0,0,6,6,6,14.166666666666666,0,9.4,-0.8,-3.12,2 +Student_02408,4,39,9500,1,1,19,1,37,38,5,5,110.0,151.0,0,0,1,0,1,0,0,47,0,7,7,0,0.0,7,0,8,8,0,0.0,8,15.5,2.8,-4.06,0 +Student_02410,2,39,9991,0,1,1,1,37,37,9,9,100.0,125.3,1,0,0,1,1,0,0,41,0,5,8,4,11.25,0,0,5,8,3,11.0,1,7.6,2.6,0.32,0 +Student_02411,1,7,9119,1,1,3,1,34,34,90,90,130.0,130.0,0,0,0,1,1,0,0,26,0,5,5,0,0.0,0,0,5,6,0,0.0,0,NA,1.4,1.74,0 +Student_02415,1,43,9147,1,2,1,1,34,37,9,9,130.0,118.5,1,0,0,1,1,0,0,23,5,10,19,8,11.625,1,4,10,16,10,11.181818181818182,3,7.6,2.6,0.32,2 +Student_02416,1,43,9238,1,2,1,1,34,30,0,5,129.0,118.9,1,0,0,1,1,0,0,22,0,6,11,0,0.0,0,0,5,10,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02419,1,53,171,1,1,42,1,1,19,9,9,130.0,130.0,1,0,0,0,1,1,0,22,5,12,15,11,12.545454545454543,0,4,11,16,11,12.666666666666666,0,8.9,1.4,3.51,2 +Student_02420,1,39,9003,1,1,1,6,1,1,192,144,133.1,129.8,0,0,0,1,1,0,1,24,0,7,7,7,13.571428571428571,0,0,6,9,5,13.4,0,8.9,1.4,3.51,1 +Student_02422,2,39,9991,0,1,19,1,37,37,5,5,133.1,111.9,1,0,0,1,1,0,0,41,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_02423,1,39,9003,1,1,1,1,37,37,9,9,NA,150.1,1,0,0,1,1,0,0,43,0,6,9,6,14.77777777777778,0,0,6,11,5,12.2,0,13.9,-0.3,0.79,2 +Student_02425,1,39,9119,1,2,1,1,37,37,5,5,120.0,128.0,0,0,0,1,1,0,0,30,0,2,2,0,0.0,0,0,2,2,0,0.0,0,7.6,2.6,0.32,0 +Student_02426,1,39,9147,1,2,38,1,19,38,9,9,133.1,102.5,0,0,0,0,1,0,0,26,0,4,4,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02428,2,39,9670,1,2,1,1,37,37,9,9,100.0,110.0,0,0,0,1,1,1,0,36,0,5,5,5,11.4,0,0,5,7,5,11.6,0,9.4,-0.8,-3.12,2 +Student_02429,1,39,9003,1,1,19,1,1,19,4,10,133.1,114.0,0,0,0,1,1,0,0,29,3,9,13,6,11.666666666666666,0,2,7,10,6,10.857142857142858,0,15.5,2.8,-4.06,0 +Student_02430,1,42,9119,1,1,1,1,34,34,0,0,120.0,128.2,1,0,0,1,1,0,0,35,6,10,12,7,11.285714285714286,0,2,8,8,5,13.0,0,9.4,-0.8,-3.12,0 +Student_02431,1,1,9773,1,1,1,1,NA,38,6,3,128.0,116.5,0,0,0,1,1,1,0,18,0,6,12,4,11.5,0,0,6,10,5,12.6,0,10.8,1.4,1.74,2 +Student_02433,1,1,9773,1,3,1,1,38,38,9,7,146.0,134.1,1,0,0,1,1,1,0,18,0,6,6,6,12.5,0,0,6,7,6,12.666666666666666,0,10.8,1.4,1.74,0 +Student_02436,1,42,9119,1,1,1,1,38,37,5,8,150.0,133.5,1,0,0,1,1,0,0,21,0,5,10,5,13.0,0,0,5,10,5,12.6,0,9.4,-0.8,-3.12,2 +Student_02437,1,39,9003,1,1,1,1,1,3,2,6,130.0,110.0,0,0,0,1,1,0,0,32,8,18,27,13,13.714285714285714,1,7,12,18,12,12.083333333333334,0,15.5,2.8,-4.06,2 +Student_02438,1,1,9119,1,4,1,1,37,37,9,5,111.0,107.5,1,0,0,1,1,1,0,22,0,5,9,3,12.333333333333334,0,0,6,14,3,12.5,0,11.1,0.6,2.02,0 +Student_02439,1,7,9003,1,1,3,1,1,38,9,7,130.0,130.0,1,0,0,0,1,0,0,32,11,17,31,11,12.727272727272728,4,10,12,24,10,12.7,1,15.5,2.8,-4.06,0 +Student_02440,1,43,9670,1,1,6,1,34,34,0,0,170.0,111.6,0,0,0,1,1,0,0,35,1,5,5,1,14.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02441,1,18,9147,1,3,1,1,1,38,4,7,133.1,101.0,1,0,0,0,1,0,0,23,0,5,0,0,0.0,0,0,5,0,0,0.0,0,8.9,1.4,3.51,0 +Student_02442,1,39,8014,0,1,1,1,37,37,6,6,100.0,108.3,0,0,0,1,1,0,0,39,0,6,8,5,11.4,0,1,6,12,3,11.0,1,7.6,2.6,0.32,1 +Student_02443,2,43,9670,1,1,1,1,34,34,0,0,120.0,128.2,0,0,0,1,1,0,0,35,0,5,5,0,0.0,0,0,5,5,1,10.0,0,9.4,-0.8,-3.12,0 +Student_02444,2,39,9003,1,1,3,1,3,19,4,6,110.0,150.0,0,0,0,1,1,0,0,32,0,6,8,6,18.875,0,6,12,14,12,17.692307692307693,0,16.2,0.3,-0.92,2 +Student_02445,1,1,NA,1,1,1,1,34,34,0,0,133.1,142.8,0,0,0,1,1,0,0,20,0,6,12,0,0.0,0,0,6,12,0,0.0,0,7.6,2.6,0.32,0 +Student_02446,1,39,9500,1,1,1,1,37,37,9,9,120.0,100.0,0,0,0,1,1,0,0,34,0,7,15,6,11.333333333333334,0,0,7,16,4,12.6,0,16.2,0.3,-0.92,1 +Student_02447,1,7,9991,0,1,40,1,37,37,6,6,150.0,150.0,1,0,0,1,1,0,0,NA,3,7,9,7,13.5,0,0,5,6,5,16.2,0,8.9,1.4,3.51,0 +Student_02449,1,39,9119,1,1,19,1,37,37,9,4,120.0,98.6,0,0,1,0,1,0,0,28,0,5,10,0,0.0,0,0,5,7,0,0.0,0,12.4,0.5,1.79,0 +Student_02450,1,7,9991,0,1,3,1,37,37,9,9,130.0,130.0,0,0,0,1,1,0,0,31,9,9,9,9,14.22222222222222,0,5,5,5,5,12.8,0,12.7,3.7,-1.7,0 +Student_02452,1,39,9003,1,1,1,1,1,3,9,10,100.0,120.0,0,0,1,0,1,0,0,44,2,7,14,4,12.0,2,0,6,16,0,0.0,1,15.5,2.8,-4.06,0 +Student_02453,1,1,9085,1,1,1,1,1,1,9,NA,142.0,127.7,1,0,0,1,1,0,0,19,0,5,9,5,12.6,1,0,5,8,4,12.0,0,12.7,3.7,-1.7,2 +Student_02454,1,15,171,1,1,1,26,1,1,2,9,130.0,130.0,0,0,0,1,1,0,1,21,6,12,12,12,15.083333333333334,0,4,11,15,11,13.083333333333334,0,8.9,1.4,3.51,1 +Student_02455,1,18,9119,1,1,1,1,3,19,3,5,148.0,147.7,0,0,0,1,1,1,0,18,0,5,5,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02456,1,44,9003,1,1,39,1,19,19,5,5,170.0,170.0,1,0,0,1,1,0,0,20,0,6,8,6,14.5,0,0,6,10,6,15.3,0,16.2,0.3,-0.92,2 +Student_02457,1,39,9070,1,1,1,1,37,37,7,7,110.0,110.2,0,0,0,1,1,0,0,55,0,6,6,6,14.5,0,0,6,6,6,13.5,0,11.1,0.6,2.02,2 +Student_02458,1,1,9147,1,1,1,1,19,37,4,NA,166.0,146.4,0,0,0,1,1,0,0,27,0,5,12,3,10.0,0,0,5,12,1,13.0,0,7.6,2.6,0.32,1 +Student_02459,1,17,9119,1,2,1,1,12,19,5,5,135.0,121.0,0,0,0,1,1,0,0,19,0,5,0,0,0.0,0,0,5,0,0,0.0,0,12.4,0.5,1.79,0 +Student_02460,1,1,9147,1,1,1,1,19,37,9,9,133.0,129.9,0,0,0,1,1,0,0,18,0,5,5,5,11.6,0,0,5,5,5,13.2,0,12.4,0.5,1.79,2 +Student_02461,2,39,9773,1,1,1,1,37,37,7,4,NA,132.0,0,0,0,1,1,0,0,43,0,6,10,4,11.75,0,0,6,7,0,0.0,0,15.5,2.8,-4.06,0 +Student_02462,1,18,9254,1,3,1,1,19,19,9,6,121.0,125.9,1,0,0,1,1,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02464,1,17,9254,1,5,1,1,37,38,9,9,130.0,122.7,1,0,1,1,1,1,0,20,0,6,7,0,0.0,0,0,6,6,0,0.0,0,8.9,1.4,3.51,0 +Student_02465,2,39,9991,0,1,1,1,37,19,9,9,121.0,141.4,0,0,1,0,1,0,0,29,0,5,7,4,11.25,0,0,5,8,4,11.8,0,10.8,1.4,1.74,0 +Student_02467,1,1,9119,1,1,1,1,37,37,9,9,146.0,148.5,1,0,0,1,1,0,0,18,0,5,7,4,10.0,0,0,5,8,1,16.0,0,10.8,1.4,1.74,1 +Student_02468,1,44,9003,1,1,39,1,37,37,9,1,140.0,140.0,0,0,0,1,1,1,0,20,0,6,11,5,13.833333333333334,0,0,6,13,6,12.3,0,15.5,2.8,-4.06,1 +Student_02469,1,43,9070,1,1,1,1,38,37,8,7,125.0,131.7,1,0,0,1,1,0,0,20,3,6,6,4,12.75,0,3,9,12,3,12.666666666666666,0,12.4,0.5,1.79,0 +Student_02470,2,39,9147,1,2,1,1,37,37,9,9,120.0,104.7,1,0,0,1,1,0,0,36,0,4,4,0,0.0,0,0,5,9,0,0.0,0,10.8,1.4,1.74,0 +Student_02471,1,44,9130,1,1,39,1,5,1,2,5,150.0,150.0,1,0,0,1,1,0,0,19,1,6,13,5,11.6,0,1,6,12,2,NA,0,13.9,-0.3,0.79,1 +Student_02472,2,39,9085,1,1,19,1,37,37,90,90,110.0,110.0,0,0,0,0,1,0,0,29,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_02473,1,1,9670,1,1,1,1,1,1,9,9,120.0,129.1,1,0,0,1,1,0,0,18,0,6,6,4,11.25,0,0,6,10,3,10.333333333333334,0,10.8,1.4,1.74,0 +Student_02474,1,39,9003,1,1,1,1,1,1,1,6,133.1,120.0,0,0,0,0,1,0,0,24,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02475,1,1,9773,1,1,1,1,3,19,2,5,133.1,127.0,0,0,0,1,1,0,0,20,0,6,6,6,14.333333333333334,0,0,6,7,6,15.0,0,15.5,2.8,-4.06,2 +Student_02476,2,39,8014,0,1,19,1,19,37,9,9,133.1,151.5,0,0,1,0,1,0,0,45,0,6,7,0,0.0,0,0,5,5,0,0.0,0,16.2,0.3,-0.92,0 +Student_02477,1,43,9500,1,2,1,1,38,37,4,4,130.0,126.8,1,0,0,1,1,1,0,28,18,23,23,20,13.5,3,18,23,23,20,13.5,3,7.6,2.6,NA,2 +Student_02478,1,1,9254,1,1,1,1,19,38,9,9,160.0,140.8,1,0,0,1,1,0,0,23,0,6,8,6,12.666666666666666,0,0,6,10,5,12.2,0,7.6,2.6,0.32,1 +Student_02479,1,1,9500,1,1,1,1,1,19,4,NA,128.0,125.6,1,0,0,1,1,0,0,18,0,7,7,7,12.444285714285714,0,0,8,11,7,11.347142857142858,0,12.4,0.5,1.79,2 +Student_02480,1,1,9147,1,2,1,1,19,19,9,4,140.0,127.8,1,0,0,1,1,0,0,23,0,5,7,3,10.666666666666666,1,0,5,7,3,11.333333333333334,0,9.4,-0.8,-3.12,0 +Student_02481,1,43,171,1,1,1,1,3,3,2,2,120.0,120.0,1,0,0,1,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,1 +Student_02482,1,1,9070,1,1,1,1,19,19,5,5,140.0,131.3,0,0,0,1,1,1,0,22,1,6,6,6,12.666666666666666,0,1,6,6,5,12.4,0,12.4,0.5,1.79,2 +Student_02483,1,39,9991,0,1,12,1,37,38,5,5,120.0,155.7,0,0,0,1,1,0,0,33,0,5,5,5,13.2,0,0,5,6,5,14.833333333333334,0,10.8,1.4,1.74,2 +Student_02484,1,53,9003,1,1,42,1,1,38,9,6,130.0,128.5,0,0,0,1,1,0,0,21,7,12,20,10,12.7,0,5,12,14,11,12.181818181818182,0,8.9,1.4,3.51,2 +Student_02485,2,39,9147,1,1,1,1,37,37,9,5,100.0,170.0,0,0,0,1,1,0,0,45,0,5,6,5,14.833333333333334,0,0,5,5,5,14.8,0,15.5,2.8,-4.06,2 +Student_02486,2,39,9003,1,1,1,1,37,37,9,9,133.1,100.0,0,0,0,0,1,0,0,44,4,10,10,4,11.5,0,1,7,8,1,12.0,0,15.5,2.8,-4.06,0 +Student_02487,4,39,9670,1,1,1,1,19,19,90,99,110.0,107.2,0,0,0,1,1,0,0,42,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02489,1,17,9147,1,6,1,1,19,38,5,6,133.0,123.2,1,0,0,1,1,0,0,20,0,5,7,3,12.666666666666666,1,0,5,12,2,12.5,0,9.4,-0.8,-3.12,1 +Student_02492,1,1,9147,1,2,1,1,1,1,9,6,128.0,120.3,0,0,0,1,1,0,0,19,0,5,9,5,10.8,0,0,5,13,2,13.5,0,8.9,1.4,3.51,1 +Student_02493,1,51,8014,0,1,1,1,1,1,4,4,120.0,128.5,0,0,1,0,1,0,0,26,2,8,13,4,10.5,0,5,10,16,7,10.428571428571429,0,12.4,0.5,1.79,0 +Student_02494,2,39,9003,1,1,1,1,37,37,8,7,133.1,150.0,0,0,0,1,1,0,0,31,0,6,10,6,15.0,0,0,6,11,5,12.5,0,13.9,-0.3,0.79,2 +Student_02495,1,1,9773,1,1,1,1,1,19,9,9,142.0,136.1,0,0,1,1,1,1,0,19,0,6,6,6,12.666666666666666,0,0,6,6,6,14.0,0,16.2,0.3,-0.92,2 +Student_02496,1,39,9773,1,1,19,1,37,37,0,0,100.0,128.0,1,0,0,1,1,0,0,28,0,6,7,6,13.166666666666666,0,0,6,6,6,13.666666666666666,0,7.6,2.6,0.32,2 +Student_02497,1,1,171,1,1,1,1,19,37,9,9,149.0,158.1,1,0,0,1,1,1,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,2 +Student_02498,2,1,8014,0,2,1,1,37,1,9,10,110.0,108.7,1,0,0,1,0,0,0,43,0,6,6,6,13.0,0,0,6,6,6,12.5,0,9.4,-0.8,-3.12,2 +Student_02499,1,39,171,1,1,19,101,1,19,2,7,133.1,110.0,0,0,0,1,1,1,1,25,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_02500,1,39,9238,1,1,19,1,37,37,9,9,133.1,120.0,0,1,1,1,0,0,0,40,0,6,13,2,10.0,0,0,6,10,1,15.0,0,16.2,0.3,-0.92,0 +Student_02501,1,44,9085,1,1,39,6,5,4,1,1,150.0,150.0,0,0,0,1,NA,0,1,20,2,6,7,6,13.333333333333334,0,1,6,16,5,13.375,0,12.4,0.5,1.79,2 +Student_02502,2,39,8014,0,1,12,1,37,37,9,1,133.1,113.0,0,0,0,1,0,0,0,46,0,6,13,3,12.333333333333334,0,0,6,6,6,13.333333333333334,0,11.1,0.6,2.02,2 +Student_02503,1,51,33,1,1,1,1,19,37,5,7,121.0,118.6,0,0,0,1,0,0,0,26,14,21,23,20,13.181818181818182,0,10,14,18,14,11.642857142857142,0,8.9,1.4,3.51,2 +Student_02505,1,18,9853,1,3,1,1,38,37,9,5,122.0,120.3,1,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_02507,1,1,9556,1,1,1,1,19,19,4,9,123.0,113.8,1,0,0,1,0,0,0,18,0,7,9,7,11.155555555555557,0,0,8,10,8,11.425,0,12.7,3.7,-1.7,2 +Student_02508,1,39,8014,0,1,1,1,38,37,9,7,120.0,108.0,0,0,0,1,1,1,0,37,1,7,9,6,11.857142857142858,0,1,6,7,5,12.0,0,13.9,-0.3,0.79,2 +Student_02509,1,17,171,1,1,1,1,19,38,9,7,114.0,129.1,0,0,0,1,1,1,0,23,0,0,0,0,0.0,0,0,0,0,0,0.0,0,NA,-0.8,-3.12,2 +Student_02512,1,15,9500,1,1,1,108,3,2,122,4,190.0,190.0,1,0,0,1,0,0,1,18,0,7,15,4,11.575,0,0,7,10,5,12.419999999999998,0,NA,0.5,1.79,1 +Student_02513,1,17,9500,1,4,1,1,3,3,2,2,136.0,132.5,1,0,0,1,0,0,0,19,0,7,8,7,13.198571428571428,0,0,8,8,8,13.0625,0,11.1,0.6,2.02,2 +Student_02514,1,10,9085,1,2,1,22,19,1,4,9,163.3,163.3,0,0,0,1,0,0,1,18,0,6,10,6,13.5,0,0,6,12,6,12.0,0,12.4,0.5,1.79,2 +Student_02515,1,1,9670,1,1,1,1,1,3,4,3,126.0,122.5,1,0,0,1,0,0,0,19,0,6,6,6,13.333333333333334,0,0,6,8,5,12.8,0,8.9,1.4,3.51,0 +Student_02517,1,17,9070,1,1,1,1,1,1,1,5,137.0,131.8,0,0,0,1,0,1,0,22,0,6,7,6,12.166666666666666,0,0,6,9,4,12.0,0,9.4,-0.8,-3.12,2 +Student_02518,1,1,9500,1,3,1,1,19,1,9,5,139.0,135.0,1,0,0,1,0,1,0,18,0,8,8,7,12.214285714285714,0,0,8,8,7,12.214285714285714,0,12.7,3.7,-1.7,2 +Student_02519,1,17,9254,1,1,1,1,19,39,5,4,142.0,141.7,0,0,0,1,0,1,0,18,0,6,8,6,12.666666666666666,0,0,6,6,6,13.0,0,13.9,-0.3,0.79,2 +Student_02520,1,1,9773,1,3,NA,1,38,38,5,5,133.1,131.3,1,0,0,1,0,1,0,18,0,6,7,6,12.285714285714286,0,0,6,6,6,13.5,0,8.9,1.4,3.51,2 +Student_02521,1,1,9254,1,6,1,1,38,37,5,7,126.0,123.9,1,0,0,1,0,1,0,18,0,6,7,6,13.0,0,0,6,6,6,13.0,0,12.4,0.5,1.79,2 +Student_02522,1,1,9254,1,2,1,1,4,3,7,4,131.0,126.1,1,0,0,1,0,0,0,18,0,6,8,6,12.142857142857142,0,0,6,6,6,11.166666666666666,0,8.9,1.4,3.51,2 +Student_02523,1,17,9500,1,6,1,1,1,19,7,7,131.0,126.5,1,0,0,1,0,1,0,19,0,7,8,7,13.875714285714285,0,0,8,9,7,13.085714285714284,0,11.1,0.6,2.02,2 +Student_02524,1,17,9853,1,1,1,1,19,1,5,5,108.0,107.3,0,0,0,1,0,0,0,20,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_02525,1,17,9238,1,4,1,1,1,19,9,5,133.1,95.0,1,0,0,1,0,1,0,19,0,6,12,6,11.666666666666666,0,0,6,7,0,0.0,0,15.5,2.8,-4.06,0 +Student_02526,1,1,9085,1,2,1,1,3,1,4,7,122.0,116.1,1,0,0,NA,0,0,0,18,0,6,13,6,13.153846153846152,0,0,6,12,3,11.0,0,15.5,2.8,-4.06,2 +Student_02528,1,17,9500,1,6,1,1,19,19,7,7,135.0,128.0,1,0,0,1,0,1,0,18,0,7,7,7,14.44142857142857,0,0,8,8,8,13.65625,0,11.1,0.6,2.02,2 +Student_02529,1,17,9773,1,2,1,1,3,38,2,6,148.0,144.2,1,0,0,1,0,0,0,18,0,6,6,6,15.166666666666666,0,0,6,7,6,14.285714285714286,0,12.4,0.5,1.79,2 +Student_02531,1,17,9773,1,1,1,1,1,1,4,7,122.0,116.8,1,0,1,1,0,0,0,18,0,6,6,6,11.666666666666666,0,0,6,6,6,12.333333333333334,0,16.2,0.3,-0.92,2 +Student_02532,1,44,9003,1,1,39,1,37,38,9,6,160.0,160.0,0,0,0,1,0,1,0,20,0,6,8,6,12.625,0,0,6,10,6,13.2,0,16.2,0.3,-0.92,2 +Student_02534,1,17,9130,1,1,1,1,2,19,2,6,NA,126.3,1,0,0,1,0,1,0,18,0,6,7,6,12.833333333333334,1,0,6,8,6,13.0,0,8.9,1.4,3.51,1 +Student_02535,1,1,9238,1,1,1,1,38,38,8,7,115.0,112.9,1,0,0,1,0,1,0,19,0,6,7,6,11.857142857142858,0,0,6,8,6,13.142857142857142,0,12.4,0.5,1.79,2 +Student_02537,1,43,9130,1,1,1,41,3,4,3,2,100.0,100.0,0,0,0,1,0,0,1,19,0,5,10,5,14.857142857142858,2,0,5,7,5,15.142857142857142,0,9.4,-0.8,-3.12,1 +Student_02538,1,1,9670,1,1,1,1,19,19,7,7,130.0,121.6,0,0,0,1,0,0,0,19,0,6,7,6,14.714285714285714,0,0,6,6,6,15.833333333333334,0,12.4,0.5,1.79,2 +Student_02539,1,15,9670,1,1,1,26,42,1,2,7,130.0,130.0,0,1,1,1,0,0,1,20,0,6,6,6,13.5,0,0,6,9,5,13.0,0,8.9,1.4,3.51,2 +Student_02540,1,18,9130,1,1,1,1,38,19,9,5,135.0,121.7,1,0,0,1,0,1,0,18,0,5,7,4,11.5,0,0,5,5,5,12.4,0,10.8,1.4,1.74,2 +Student_02544,1,17,9070,1,1,1,1,19,1,4,3,108.0,111.9,0,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_02545,1,44,9003,1,1,39,1,38,38,6,3,140.0,140.0,0,0,0,1,0,0,0,19,0,6,18,3,11.666666666666666,0,0,6,14,4,11.5,0,15.5,2.8,-4.06,1 +Student_02546,1,1,9773,1,3,1,1,3,1,2,8,153.0,137.6,1,0,0,1,0,0,0,18,0,6,6,6,16.0,0,0,6,7,6,14.333333333333334,0,12.4,0.5,1.79,2 +Student_02547,1,1,9238,1,1,1,1,19,19,9,5,135.0,135.0,1,0,0,1,0,0,0,20,0,6,6,6,13.833333333333334,0,0,6,6,6,11.833333333333334,0,10.8,1.4,1.74,2 +Student_02548,1,1,9500,1,5,1,1,19,37,7,7,146.0,133.8,1,0,0,1,0,0,0,19,0,8,9,8,13.2325,1,0,8,9,8,13.2325,1,9.4,-0.8,-3.12,2 +Student_02549,1,1,9773,1,2,1,1,19,19,9,9,130.0,126.9,1,0,0,1,1,1,0,18,0,6,6,6,14.0,0,0,6,6,6,NA,0,9.4,-0.8,-3.12,2 +Student_02550,1,17,9254,1,2,1,1,1,2,5,3,113.0,106.7,1,0,1,1,1,1,0,19,0,6,14,2,10.0,0,0,6,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_02551,1,43,8014,0,1,1,22,37,37,9,9,145.7,145.7,1,0,0,1,0,0,1,25,8,16,16,15,13.333333333333334,0,11,13,13,11,12.272727272727272,0,13.9,-0.3,0.79,2 +Student_02552,1,17,9070,1,3,1,1,3,3,4,4,145.0,153.1,1,0,0,1,0,1,0,20,0,6,6,6,12.5,0,0,6,6,6,14.333333333333334,0,12.7,3.7,-1.7,1 +Student_02553,1,1,8014,0,1,1,1,38,37,5,5,126.0,118.7,0,0,0,1,0,0,0,19,0,6,6,6,12.5,0,0,6,6,6,11.5,0,12.7,3.7,-1.7,2 +Student_02554,1,17,9991,0,1,NA,1,34,34,0,0,160.0,161.8,1,0,1,1,1,0,0,33,0,5,8,2,10.5,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_02555,1,18,9119,1,4,1,1,19,38,194,175,134.0,124.9,1,0,1,1,1,0,0,18,0,5,11,3,10.666666666666666,0,0,5,9,3,11.333333333333334,0,8.9,1.4,3.51,1 +Student_02558,1,1,171,1,2,1,1,3,3,2,2,165.0,163.6,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,1 +Student_02559,1,43,9147,1,1,1,1,38,19,141,171,142.0,115.0,0,0,0,1,0,0,0,19,0,5,11,5,11.5,0,0,5,9,2,10.666666666666666,0,13.9,-0.3,0.79,1 +Student_02560,1,1,9773,1,1,1,1,19,1,5,10,156.0,136.8,1,0,0,1,0,0,0,18,0,6,6,6,14.0,0,0,6,6,6,13.5,0,11.1,0.6,2.02,0 +Student_02561,1,17,9853,1,5,1,1,3,19,2,7,141.0,130.9,1,0,0,1,0,0,0,18,0,6,7,6,13.5,0,0,6,8,5,12.6,0,7.6,2.6,0.32,2 +Student_02562,1,1,9500,1,3,1,1,19,37,7,7,143.0,127.0,1,0,0,1,0,0,0,18,0,8,8,8,13.07375,0,0,8,8,8,13.07375,0,9.4,-0.8,-3.12,2 +Student_02563,2,39,9500,1,1,19,1,38,38,2,10,133.1,120.0,0,0,0,1,0,0,0,37,0,7,9,2,10.75,0,0,7,9,0,0.0,0,16.2,0.3,-0.92,0 +Student_02564,1,1,9238,1,1,1,1,38,1,2,4,133.0,126.0,0,0,0,1,0,0,0,20,0,6,11,1,12.0,0,0,5,10,0,0.0,0,9.4,-0.8,-3.12,1 +Student_02565,1,1,9254,1,1,1,41,37,37,5,5,172.0,153.8,1,0,0,1,0,1,1,20,0,6,6,6,14.0,0,0,6,6,6,13.333333333333334,0,10.8,1.4,1.74,2 +Student_02566,1,15,9238,1,1,1,26,19,19,9,6,140.0,140.0,0,0,0,1,1,0,1,21,0,6,7,6,12.333333333333334,0,0,6,7,6,13.428571428571429,0,11.1,0.6,2.02,2 +Student_02567,1,17,9500,1,1,1,1,38,1,5,4,142.0,136.6,0,0,0,1,0,1,0,18,0,7,7,7,13.464285714285714,0,0,8,9,8,14.788888888888888,0,12.4,0.5,1.79,2 +Student_02568,1,39,8014,0,1,1,1,19,1,9,8,140.0,105.0,0,0,0,1,0,0,0,26,0,6,14,3,10.666666666666666,1,0,6,9,5,11.2,0,15.5,2.8,-4.06,1 +Student_02569,1,39,9147,1,1,12,1,37,37,9,7,133.1,139.4,0,0,1,1,0,0,0,41,0,5,6,5,11.6,0,0,5,8,5,12.2,0,7.6,2.6,0.32,1 +Student_02570,1,1,9773,1,2,1,1,NA,1,3,9,148.0,140.0,1,0,0,1,NA,1,0,18,0,6,6,6,13.666666666666666,0,0,6,6,6,14.666666666666666,0,16.2,0.3,-0.92,2 +Student_02571,1,1,9500,1,4,1,1,19,37,9,7,137.0,130.8,0,0,1,1,0,0,0,18,0,8,9,8,14.4025,1,0,8,9,8,14.4025,1,9.4,-0.8,-3.12,2 +Student_02573,1,1,9238,1,1,1,1,1,1,4,10,133.1,110.0,0,0,1,1,0,0,0,23,0,6,8,6,12.625,0,0,6,6,6,14.166666666666666,0,12.7,3.7,-1.7,2 +Student_02574,1,1,9500,1,4,1,1,37,19,9,NA,138.0,127.8,1,0,0,1,0,0,0,19,0,7,7,6,14.983333333333334,0,0,7,7,6,14.983333333333334,0,7.6,2.6,0.32,2 +Student_02577,1,44,9085,1,1,39,1,37,37,9,9,120.0,120.0,1,0,1,1,0,0,0,32,0,6,14,4,11.5,0,0,6,14,3,11.0,0,16.2,0.3,-0.92,0 +Student_02580,1,1,9238,1,1,1,1,37,37,9,9,148.0,143.5,0,0,0,1,0,0,0,18,0,6,6,6,13.0,0,0,6,6,6,12.833333333333334,0,10.8,1.4,1.74,2 +Student_02581,1,1,9238,1,1,1,1,19,37,4,7,145.0,148.9,1,0,0,1,0,1,0,18,0,6,6,6,13.666666666666666,0,0,6,6,6,13.0,0,10.8,1.4,1.74,2 +Student_02582,1,39,9003,1,1,1,1,38,38,4,7,133.1,115.6,1,0,0,0,0,0,0,27,0,6,8,0,0.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_02584,1,39,9991,0,1,1,1,19,37,9,8,150.0,138.5,0,0,0,1,0,0,0,26,0,5,10,4,12.0,0,0,5,9,4,11.25,0,12.7,3.7,-1.7,1 +Student_02585,1,NA,9853,1,1,1,1,19,12,9,4,130.0,133.2,1,0,0,1,0,0,0,19,0,6,6,6,14.166666666666666,0,0,6,7,6,13.666666666666666,0,7.6,2.6,NA,2 +Student_02586,1,17,8014,0,2,1,1,37,34,0,0,120.0,117.6,1,0,0,1,0,0,0,19,0,6,8,5,12.2,0,0,6,7,6,12.0,0,7.6,2.6,0.32,2 +Student_02587,1,18,9147,1,2,1,1,1,37,5,5,115.0,108.7,1,0,0,1,0,0,0,21,0,5,8,3,12.0,1,0,5,9,3,12.666666666666666,0,9.4,-0.8,-3.12,1 +Student_02588,1,1,9147,1,4,1,1,1,19,4,6,133.1,106.0,1,0,0,1,0,0,0,24,0,5,11,2,10.5,0,0,5,14,1,11.0,0,12.7,3.7,-1.7,1 +Student_02589,1,17,9853,1,1,1,1,37,37,9,10,120.0,122.6,0,0,0,1,0,0,0,20,0,6,8,3,12.333333333333334,0,0,6,11,2,10.5,0,12.7,3.7,-1.7,0 +Student_02590,1,1,9853,1,4,1,1,19,1,5,9,134.0,127.4,1,0,0,1,0,0,0,18,0,6,7,5,12.2,0,0,6,7,5,12.2,0,10.8,1.4,1.74,1 +Student_02591,1,39,9003,1,1,1,1,19,19,9,NA,133.1,100.0,0,0,0,1,0,0,0,30,0,6,6,0,0.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_02592,1,1,9853,1,1,1,1,NA,37,9,9,133.1,95.0,1,0,1,0,0,0,0,22,0,7,10,6,11.5,0,0,7,8,6,13.166666666666666,0,11.1,0.6,2.02,1 +Student_02594,1,39,9556,1,1,1,1,19,19,4,5,120.0,122.8,0,0,0,1,0,0,0,26,0,7,12,6,12.166666666666666,0,0,8,8,8,11.675,0,13.9,-0.3,0.79,0 +Student_02595,1,17,9147,1,1,1,1,19,19,7,7,115.0,115.0,1,0,0,1,0,0,0,23,0,5,7,2,10.0,1,0,5,9,1,12.0,0,9.4,-0.8,-3.12,1 +Student_02597,1,1,9070,1,1,1,1,1,37,5,9,133.1,143.0,1,0,1,1,0,0,0,21,0,6,9,5,11.4,0,0,6,8,5,12.2,0,12.7,3.7,-1.7,0 +Student_02598,1,43,171,1,1,1,1,19,38,9,9,145.0,100.0,0,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02599,1,17,9085,1,3,1,1,19,37,5,5,130.0,121.3,1,0,0,1,0,0,0,21,0,5,14,2,13.0,2,0,5,8,4,12.0,1,9.4,-0.8,-3.12,1 +Student_02602,1,17,9254,1,1,1,1,1,1,4,9,122.0,112.9,1,0,0,1,0,0,0,22,0,6,14,4,12.25,0,0,6,11,3,11.333333333333334,0,7.6,2.6,0.32,1 +Student_02603,1,1,9238,1,3,1,1,38,19,5,8,126.0,120.8,1,0,0,1,0,0,0,19,0,6,7,6,12.285714285714286,0,0,6,7,6,12.833333333333334,0,12.4,0.5,1.79,2 +Student_02604,1,1,9085,1,5,1,1,38,37,9,8,121.0,114.0,1,0,0,0,0,0,0,19,0,5,12,0,0.0,4,0,5,8,0,0.0,1,9.4,-0.8,-3.12,0 +Student_02605,1,17,9238,1,1,1,1,37,37,7,5,152.0,132.1,1,0,0,1,0,0,0,19,0,6,10,2,10.5,0,0,6,11,1,13.0,0,9.4,-0.8,-3.12,0 +Student_02606,2,44,9085,1,1,39,1,37,37,192,192,160.0,160.0,0,0,0,1,0,0,0,27,0,5,12,3,14.0,2,0,5,8,5,12.0,1,9.4,-0.8,-3.12,2 +Student_02607,1,10,9085,1,1,1,1,37,37,5,5,134.0,134.0,1,0,0,1,0,0,0,22,2,5,7,5,14.2,0,0,5,10,5,12.2,0,12.7,3.7,-1.7,2 +Student_02608,1,1,9773,1,1,1,1,37,1,9,7,128.0,124.2,1,0,0,1,0,0,0,18,0,6,8,5,13.0,0,0,6,7,6,13.142857142857142,0,15.5,2.8,-4.06,0 +Student_02609,1,17,9254,1,4,1,1,38,38,5,5,125.0,115.6,1,0,0,1,0,0,0,20,0,6,6,6,11.0,0,0,6,8,4,12.75,0,9.4,-0.8,-3.12,2 +Student_02610,2,43,9991,0,1,1,1,37,37,9,9,130.0,128.2,0,0,0,1,0,0,0,34,3,8,9,3,11.0,0,2,7,7,2,10.0,0,9.4,-0.8,-3.12,0 +Student_02611,1,17,9500,1,2,1,1,1,38,5,8,138.0,132.8,1,0,0,1,0,0,0,18,0,7,9,6,12.385714285714286,0,0,8,9,8,13.755555555555556,0,13.9,-0.3,0.79,2 +Student_02613,1,1,9130,1,1,1,41,1,19,5,5,134.0,125.6,1,0,0,1,0,0,1,20,0,5,6,5,16.166666666666668,0,0,5,6,5,15.833333333333334,0,12.7,3.7,-1.7,2 +Student_02614,1,39,9991,0,1,1,1,1,38,4,9,130.0,115.0,0,0,0,1,1,0,0,25,0,5,7,0,0.0,0,0,5,8,0,0.0,0,16.2,0.3,-0.92,0 +Student_02615,1,1,9119,1,4,1,1,3,19,2,9,126.0,123.6,1,0,0,1,1,0,0,18,0,5,6,5,12.4,0,0,5,9,3,13.0,0,8.9,1.4,3.51,0 +Student_02616,1,1,9130,1,1,1,1,1,1,9,9,148.0,141.7,0,0,0,0,1,0,0,18,0,6,8,5,11.6,0,0,6,11,4,13.0,0,8.9,1.4,3.51,0 +Student_02619,1,17,9853,1,2,1,1,38,19,5,5,150.0,142.0,1,0,0,1,0,1,0,19,0,6,8,6,12.333333333333334,0,0,6,7,5,12.4,0,10.8,1.4,1.74,0 +Student_02621,1,42,9070,1,1,1,1,3,2,2,2,100.0,115.9,0,0,0,1,0,0,0,29,9,10,15,9,11.555555555555555,0,7,11,17,10,11.9,0,9.4,-0.8,-3.12,1 +Student_02622,1,1,9070,1,1,1,1,1,37,9,9,110.0,105.1,1,0,0,1,0,1,0,20,0,6,6,6,12.0,0,0,6,6,6,11.833333333333334,0,12.4,0.5,1.79,2 +Student_02623,1,51,8014,0,1,42,1,19,37,134,193,140.0,138.0,1,0,1,1,0,1,0,21,13,13,13,11,12.727272727272728,0,9,11,11,10,12.6,0,8.9,1.4,3.51,2 +Student_02624,1,43,9991,0,1,1,41,37,37,9,8,133.1,114.7,0,0,0,1,0,0,1,34,2,2,2,2,10.5,0,1,1,1,1,11.0,0,10.8,1.4,1.74,0 +Student_02625,1,1,9773,1,4,1,22,1,37,3,9,140.0,130.5,1,0,0,1,0,0,1,20,0,6,6,6,12.333333333333334,0,0,6,6,6,12.0,0,12.7,3.7,-1.7,2 +Student_02626,1,39,9991,0,1,1,1,37,37,9,9,110.0,134.3,0,0,0,1,1,0,0,24,0,5,10,0,0.0,0,0,5,7,1,12.0,0,10.8,1.4,1.74,0 +Student_02627,1,1,9500,1,1,1,1,1,1,4,3,148.0,137.5,0,0,0,1,1,0,0,18,0,7,7,7,14.842857142857143,0,0,8,9,8,14.38888888888889,0,16.2,0.3,-0.92,2 +Student_02628,1,1,9500,1,1,1,1,1,19,4,4,137.0,125.3,0,0,0,1,1,0,0,19,0,7,7,7,12.2,0,0,7,7,7,12.2,0,7.6,2.6,0.32,1 +Student_02629,1,1,9147,1,1,1,1,1,19,7,7,120.0,111.3,0,0,0,1,1,1,0,18,0,5,10,4,10.8,0,0,5,10,4,11.75,0,15.5,2.8,-4.06,1 +Student_02630,1,39,9991,0,9,1,1,38,38,9,5,120.0,144.8,0,0,0,1,1,0,0,28,0,5,7,4,12.75,0,0,5,7,5,14.333333333333334,0,10.8,1.4,1.74,1 +Student_02632,1,17,9254,1,1,1,1,38,38,0,5,132.0,126.1,0,0,0,1,1,0,0,20,0,6,9,4,10.75,0,0,6,12,0,0.0,0,7.6,2.6,0.32,0 +Student_02633,1,43,9500,1,1,1,1,1,1,7,4,130.0,136.0,1,0,0,1,1,0,0,22,0,8,9,8,12.55375,1,0,8,9,8,12.55375,1,9.4,-0.8,-3.12,2 +Student_02634,1,1,9500,1,4,1,1,19,1,4,4,128.0,124.3,1,0,0,1,1,0,0,19,0,8,8,7,12.665714285714284,0,0,8,8,7,12.665714285714284,0,10.8,1.4,1.74,2 +Student_02635,1,1,9670,1,1,1,1,1,19,7,5,132.0,129.9,1,0,0,1,1,0,0,20,0,6,10,6,12.714285714285714,0,0,6,8,4,13.0,0,12.4,0.5,1.79,1 +Student_02636,1,39,9556,1,2,1,1,3,1,2,4,133.1,136.1,0,0,0,1,1,0,0,26,0,7,7,2,11.75,0,0,5,10,0,0.0,0,12.4,0.5,1.79,0 +Student_02637,1,1,9254,1,2,1,1,37,37,9,9,120.0,115.1,1,0,0,0,1,0,0,21,0,6,11,3,11.0,0,0,6,14,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02639,1,17,9147,1,1,1,1,37,38,9,7,127.0,115.8,1,0,0,1,1,0,0,18,0,5,5,5,13.4,0,0,5,6,5,12.2,0,11.1,0.6,2.02,2 +Student_02641,2,39,9119,1,1,19,1,37,37,9,9,133.1,100.0,0,0,0,1,1,0,0,36,0,5,0,0,0.0,0,0,5,0,0,NA,0,16.2,0.3,-0.92,0 +Student_02642,1,1,9773,1,1,1,1,38,38,9,9,125.0,133.4,1,0,0,1,1,1,0,20,0,6,8,6,12.0,0,0,6,8,6,11.5,0,13.9,-0.3,0.79,2 +Student_02643,1,17,9670,1,5,1,1,3,4,2,2,127.0,122.8,0,0,0,1,1,0,0,20,0,6,6,3,12.333333333333334,0,0,6,9,0,0.0,0,10.8,1.4,1.74,0 +Student_02645,1,39,9003,1,1,1,1,37,19,6,4,150.0,137.0,0,0,0,1,1,0,0,35,1,6,7,5,12.8,0,1,6,11,5,13.833333333333334,0,15.5,2.8,-4.06,2 +Student_02646,1,1,171,1,1,1,1,1,37,7,7,133.1,118.0,0,0,0,1,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,0 +Student_02648,1,44,9003,1,1,39,1,38,38,9,5,130.0,130.0,0,0,1,0,1,0,0,20,0,6,16,4,11.8,0,0,6,15,2,12.0,0,16.2,0.3,-0.92,0 +Student_02649,1,43,8014,0,1,12,1,37,1,9,10,133.1,112.5,0,0,0,1,1,0,0,50,6,13,13,6,11.333333333333334,0,2,11,11,2,13.5,0,16.2,0.3,-0.92,0 +Student_02650,1,1,9500,1,1,1,1,19,38,9,8,125.0,118.3,0,0,0,1,1,0,0,20,0,8,12,5,12.002,1,0,8,12,5,12.002,1,10.8,1.4,1.74,0 +Student_02651,1,1,9500,1,1,1,1,3,1,2,8,127.0,121.4,0,0,0,1,1,0,0,20,0,7,10,5,13.976666666666668,0,0,8,9,8,13.22222222222222,0,12.4,0.5,1.79,1 +Student_02652,1,7,9003,1,1,3,1,3,19,2,10,140.0,140.0,0,0,0,0,1,0,0,35,0,6,10,5,15.2,0,1,6,9,1,11.0,0,15.5,2.8,-4.06,0 +Student_02653,1,1,9670,1,1,1,1,3,19,4,5,110.0,109.0,0,0,0,1,1,1,0,19,0,6,7,6,13.142857142857142,0,0,6,8,6,14.166666666666666,0,15.5,2.8,-4.06,2 +Student_02654,2,39,9147,1,2,1,1,37,37,5,7,133.1,110.0,0,0,0,1,1,0,0,43,0,5,14,0,0.0,1,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02655,1,17,9500,1,5,1,1,3,38,2,1,124.0,119.8,0,0,0,1,1,0,0,19,0,8,11,7,13.867142857142856,0,0,8,11,7,13.867142857142856,0,10.8,1.4,1.74,2 +Student_02656,1,39,9500,1,1,NA,1,37,37,9,9,114.0,130.0,0,0,0,1,1,0,0,25,0,8,11,6,12.675,0,0,8,11,6,12.675,0,12.7,3.7,-1.7,2 +Student_02657,1,NA,171,1,1,1,1,1,3,5,10,155.0,167.3,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_02658,1,17,9853,1,2,1,1,1,19,9,9,114.0,111.9,1,0,0,1,1,1,0,20,0,6,6,6,12.0,0,0,6,7,6,12.5,0,7.6,2.6,0.32,1 +Student_02659,1,1,171,1,1,1,1,38,37,5,5,133.1,136.0,1,0,0,1,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02660,1,1,9254,1,1,1,1,37,37,3,3,125.0,124.0,0,0,0,1,1,1,0,19,0,6,7,6,11.0,0,0,6,6,5,12.2,0,11.1,0.6,2.02,0 +Student_02661,2,39,9991,0,1,1,1,19,37,3,9,120.0,132.9,0,0,0,1,1,0,0,32,0,5,11,4,10.75,0,0,5,11,4,11.333333333333334,0,13.9,-0.3,0.79,0 +Student_02662,2,39,9773,1,1,38,1,37,37,9,7,100.0,154.0,1,0,0,1,1,0,0,57,0,6,7,5,14.2,0,0,6,6,6,14.166666666666666,0,9.4,-0.8,-3.12,2 +Student_02663,1,1,9500,1,1,1,1,1,19,3,5,133.1,115.0,0,0,0,0,1,0,0,20,0,7,11,4,12.6,0,0,7,7,4,11.575,0,NA,0.3,-0.92,0 +Student_02664,1,39,9991,0,1,1,1,1,1,5,5,120.0,96.0,1,0,0,0,1,0,0,38,0,5,5,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_02665,2,39,9991,0,1,1,1,37,3,9,3,120.0,168.2,0,0,0,1,1,0,0,45,0,5,6,5,14.0,0,0,5,6,5,14.166666666666666,0,12.4,0.5,1.79,2 +Student_02666,2,39,9773,1,1,1,1,37,37,9,10,110.0,140.0,0,0,1,0,1,0,0,43,0,6,16,2,10.0,0,0,6,12,4,12.25,0,10.8,1.4,1.74,0 +Student_02668,2,39,9991,0,1,19,1,19,19,4,4,133.1,150.0,0,0,0,0,1,0,0,49,0,5,8,2,11.0,0,0,5,5,1,11.0,0,15.5,2.8,-4.06,0 +Student_02669,2,39,9500,1,1,19,1,37,38,9,7,133.1,100.5,1,0,0,1,1,0,0,43,0,8,8,7,11.635714285714286,0,0,8,8,7,11.635714285714286,0,10.8,1.4,1.74,1 +Student_02671,1,17,9119,1,5,1,1,19,19,5,5,138.0,123.3,1,0,1,1,1,0,0,18,0,5,9,4,12.5,0,0,5,11,5,11.285714285714286,0,12.4,0.5,1.79,1 +Student_02672,2,39,9991,0,1,1,1,38,38,1,4,120.0,138.7,0,0,0,1,1,0,0,43,0,5,5,5,13.8,0,0,5,6,5,13.666666666666666,0,10.8,1.4,1.74,2 +Student_02673,1,1,9254,1,2,1,1,19,1,9,8,NA,117.2,0,0,0,1,1,0,0,21,0,6,8,3,12.0,0,0,6,9,1,11.0,0,15.5,2.8,-4.06,0 +Student_02674,2,39,9991,0,1,1,1,34,34,99,99,160.0,114.3,0,0,0,1,1,0,0,40,0,5,9,3,11.0,0,0,5,8,4,12.5,1,7.6,2.6,0.32,1 +Student_02675,1,17,9670,1,1,1,1,19,37,5,5,134.0,125.3,1,0,0,1,1,1,0,19,0,6,7,4,13.75,0,0,6,10,6,11.555555555555555,0,10.8,1.4,1.74,2 +Student_02676,1,1,9254,1,1,1,1,37,37,1,1,133.1,97.0,0,0,0,1,1,0,0,27,0,6,6,6,10.666666666666666,0,0,6,8,4,11.25,0,10.8,1.4,1.74,1 +Student_02677,2,42,9556,1,1,1,1,37,37,9,6,110.0,140.0,0,0,0,1,1,0,0,43,0,7,7,0,0.0,0,0,8,13,2,13.15,0,16.2,0.3,-0.92,0 +Student_02678,1,43,9991,0,1,1,1,37,37,9,9,130.0,124.0,0,0,0,1,1,0,0,31,1,5,6,5,NA,0,0,5,7,5,15.4,0,9.4,-0.8,-3.12,2 +Student_02679,1,44,9003,1,1,39,1,38,1,134,134,140.0,140.0,1,0,1,1,1,0,0,26,0,6,6,0,0.0,0,0,6,7,0,0.0,0,8.9,1.4,3.51,1 +Student_02680,1,39,9991,0,1,1,1,37,38,175,103,150.0,127.0,0,0,0,1,1,0,0,34,0,5,5,5,15.8,0,0,5,5,5,16.8,0,8.9,1.4,3.51,2 +Student_02684,1,17,9085,1,1,1,1,1,19,5,9,133.1,130.0,0,0,0,1,1,0,0,22,0,5,8,3,13.0,0,0,5,8,3,10.666666666666666,0,7.6,2.6,0.32,2 +Student_02685,1,7,9003,1,1,3,1,1,19,5,9,130.0,130.0,0,0,0,1,1,0,0,27,0,6,8,0,0.0,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_02687,1,51,9147,1,1,1,1,19,38,9,8,130.0,115.7,0,0,0,1,1,0,0,20,0,5,7,5,11.0,0,0,5,7,3,10.0,0,8.9,1.4,3.51,1 +Student_02688,1,42,9119,1,1,1,1,19,19,90,90,140.0,120.0,0,0,1,0,1,0,0,31,0,4,4,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_02689,1,1,9119,1,1,1,1,37,19,9,9,140.0,166.0,1,0,1,1,1,0,0,20,0,5,7,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,1 +Student_02690,1,17,9773,1,1,1,1,1,38,90,8,145.0,132.8,1,0,0,0,NA,0,0,21,0,6,10,2,12.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_02691,1,17,9147,1,1,1,1,19,19,9,7,133.1,100.0,0,0,0,1,1,0,0,21,0,5,7,4,10.75,0,0,5,10,2,11.0,3,16.2,0.3,-0.92,0 +Student_02692,1,1,9147,1,1,1,1,1,4,9,10,127.0,121.8,0,0,0,1,1,0,0,19,0,5,8,5,11.6,0,0,5,10,4,13.5,3,16.2,0.3,-0.92,2 +Student_02693,1,17,9147,1,4,1,1,19,19,4,4,114.0,109.5,1,0,0,1,1,1,0,20,0,5,6,5,11.8,0,0,5,8,4,11.6,0,8.9,1.4,3.51,2 +Student_02694,1,1,9003,1,1,1,1,38,1,9,4,140.0,138.3,0,0,0,1,1,0,0,18,0,6,7,6,16.0,0,0,6,6,6,15.166666666666666,0,12.4,0.5,1.79,2 +Student_02695,1,1,9773,1,2,1,1,1,1,4,3,140.0,131.6,0,0,0,1,1,1,0,18,0,6,6,6,12.666666666666666,0,0,6,6,6,11.5,0,16.2,0.3,-0.92,2 +Student_02696,1,39,9500,1,1,1,1,1,2,144,123,120.0,125.3,0,0,1,1,1,0,0,30,0,7,12,4,14.4,0,0,7,9,6,13.5,0,12.4,0.5,1.79,1 +Student_02697,1,39,9254,1,1,19,1,19,19,3,1,133.1,101.5,0,0,1,0,1,0,0,34,0,6,6,0,0.0,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_02698,1,17,9670,1,1,1,1,19,19,191,171,115.0,109.1,0,0,1,0,1,0,0,21,0,6,11,4,12.25,0,0,6,9,4,13.4,0,11.1,0.6,2.02,1 +Student_02699,1,44,9070,1,1,39,1,37,1,9,7,123.9,123.9,0,0,0,1,1,0,0,20,2,7,9,5,12.6,0,5,9,10,8,12.75,1,16.2,0.3,-0.92,0 +Student_02700,1,1,9500,1,1,1,1,37,37,9,9,157.0,143.0,0,0,0,1,1,0,0,18,0,8,8,7,13.4,0,0,8,8,7,13.4,0,12.7,3.7,-1.7,2 +Student_02701,1,1,171,1,1,1,1,1,1,4,3,127.0,126.3,1,0,1,1,1,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_02702,2,42,9003,1,1,1,1,3,1,2,2,120.0,113.3,0,0,0,1,1,0,0,26,0,6,9,1,10.0,0,0,6,6,0,0.0,0,12.4,0.5,1.79,0 +Student_02703,1,17,9119,1,1,1,1,38,19,7,3,130.0,119.9,1,0,1,1,1,0,0,20,0,5,5,0,0.0,0,0,5,5,0,0.0,5,9.4,-0.8,-3.12,0 +Student_02704,1,44,9003,1,1,39,1,1,38,1,9,140.0,140.0,0,0,0,1,1,0,0,25,0,6,16,3,11.25,0,0,6,14,4,11.2,0,15.5,2.8,-4.06,0 +Student_02705,1,17,9670,1,1,1,1,1,1,4,4,NA,108.0,0,0,0,1,1,0,0,19,0,5,10,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,1 +Student_02707,1,1,9130,1,1,1,NA,3,3,2,2,125.0,132.4,0,0,0,1,1,0,0,20,0,5,7,4,11.75,0,0,5,5,5,13.4,0,7.6,2.6,0.32,2 +Student_02708,1,1,9147,1,1,1,1,1,3,9,5,136.0,137.1,0,0,0,1,1,0,0,20,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_02712,1,43,8014,0,1,1,1,37,37,0,6,113.0,128.2,0,0,0,0,0,0,0,41,0,6,6,0,0.0,6,0,6,12,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02713,1,1,9147,1,2,1,1,37,38,7,9,130.0,117.8,0,0,1,1,NA,1,0,19,0,5,11,2,11.5,0,0,5,10,0,0.0,0,12.7,3.7,-1.7,0 +Student_02714,1,43,9130,1,1,1,1,3,3,3,4,150.0,150.0,1,0,0,1,0,0,0,21,0,6,10,6,12.0,0,0,6,12,5,12.8,0,13.9,-0.3,0.79,2 +Student_02715,1,39,9085,1,1,1,1,1,1,5,5,110.0,160.0,1,0,1,1,0,0,0,30,0,6,7,6,16.428571428571427,0,0,6,7,6,16.666666666666668,0,13.9,-0.3,0.79,0 +Student_02716,1,1,9500,1,5,1,1,38,38,9,9,101.0,104.5,1,0,0,1,0,1,0,21,0,7,9,5,13.336000000000002,0,0,8,9,7,13.207142857142856,0,11.1,0.6,2.02,2 +Student_02717,2,39,9556,1,2,1,1,19,38,9,9,110.0,112.8,0,0,0,1,0,1,0,26,0,7,7,0,0.0,0,0,8,8,0,0.0,6,10.8,1.4,1.74,1 +Student_02718,1,15,9670,1,1,1,41,1,1,9,4,133.1,100.0,0,0,0,1,0,0,1,21,2,7,9,7,14.666666666666666,0,1,6,8,6,14.0,0,11.1,0.6,2.02,2 +Student_02719,1,1,9500,1,1,1,1,1,1,3,4,138.0,132.5,1,0,0,1,0,0,0,18,0,8,8,7,14.115714285714288,0,0,8,8,7,14.115714285714288,0,10.8,1.4,1.74,2 +Student_02720,1,1,9085,1,4,1,1,3,1,1,4,138.0,123.3,1,0,0,1,0,1,0,19,0,6,7,6,14.857142857142858,0,0,6,10,6,13.11111111111111,0,12.4,0.5,1.79,2 +Student_02722,1,17,9147,1,2,1,1,2,3,2,2,129.0,128.3,1,0,0,NA,0,0,0,19,0,5,10,3,11.0,0,0,5,9,4,11.75,0,12.7,3.7,-1.7,1 +Student_02723,1,43,9085,1,1,1,1,3,3,2,5,127.0,100.0,0,0,0,1,0,0,0,21,0,6,11,4,11.75,0,0,6,12,3,13.666666666666666,0,13.9,-0.3,0.79,1 +Student_02724,1,17,9147,1,2,1,1,19,1,9,3,133.0,120.1,1,0,0,1,0,1,0,18,0,5,15,2,10.0,0,0,5,14,2,12.0,0,13.9,-0.3,0.79,0 +Student_02725,1,39,9500,1,1,1,1,37,37,7,7,100.0,160.0,1,0,0,1,0,1,0,24,0,8,15,6,12.415,0,0,8,15,6,12.415,0,10.8,1.4,1.74,2 +Student_02726,1,1,9130,1,1,1,1,4,5,2,2,138.0,123.0,1,0,0,1,0,0,0,21,0,5,12,1,11.0,0,0,5,9,2,10.5,0,12.7,3.7,-1.7,1 +Student_02727,1,44,9085,1,1,39,1,19,19,9,9,150.0,150.0,1,0,0,1,0,0,0,23,1,6,14,5,14.428571428571429,0,1,6,7,6,13.428571428571429,0,16.2,0.3,-0.92,2 +Student_02729,1,39,9085,1,1,1,1,4,1,2,9,130.0,120.0,0,0,0,0,0,0,0,26,0,6,8,6,15.428571428571429,0,0,6,7,5,14.5,0,11.1,0.6,2.02,1 +Student_02730,1,1,9130,1,1,1,1,38,38,5,8,133.0,120.4,1,0,0,1,0,0,0,20,0,5,9,4,12.0,1,0,5,6,5,13.4,0,9.4,-0.8,-3.12,2 +Student_02731,1,1,9238,1,1,1,1,4,1,5,5,133.0,131.6,0,0,0,1,0,0,0,18,0,6,7,6,13.833333333333334,0,0,6,7,6,13.714285714285714,0,11.1,0.6,2.02,2 +Student_02732,1,1,9238,1,1,1,1,2,12,3,10,107.0,104.2,1,0,0,1,0,0,0,20,0,6,6,6,12.166666666666666,0,0,6,7,6,12.142857142857142,0,11.1,0.6,2.02,2 +Student_02734,1,17,9238,1,2,1,1,1,19,4,10,118.0,110.7,1,1,0,1,0,0,0,18,0,6,15,2,10.333333333333334,3,0,6,13,3,13.333333333333334,0,12.7,3.7,-1.7,1 +Student_02735,1,1,9773,1,4,1,1,1,12,9,10,136.0,121.7,1,0,0,1,0,1,0,22,0,6,7,5,13.2,0,0,6,7,5,13.6,0,12.4,0.5,1.79,2 +Student_02736,1,1,9500,1,1,1,1,37,37,9,9,125.0,126.0,1,0,1,1,0,0,0,20,0,7,7,6,15.4,0,0,7,7,6,15.4,0,7.6,2.6,0.32,2 +Student_02738,1,1,9130,1,1,1,1,3,1,2,4,144.0,134.9,1,0,1,1,0,0,0,18,0,6,13,6,10.857142857142858,0,0,6,10,4,11.0,0,15.5,2.8,-4.06,0 +Student_02739,1,17,9147,1,2,1,1,38,37,6,6,146.0,143.9,0,0,0,1,0,0,0,18,0,5,11,5,11.333333333333334,0,0,5,8,5,12.0,0,13.9,-0.3,0.79,2 +Student_02740,1,1,9085,1,4,1,1,37,1,9,9,145.0,145.0,1,0,0,1,0,1,0,19,0,5,7,4,14.5,0,0,5,5,5,13.6,0,10.8,1.4,1.74,2 +Student_02741,1,1,9070,1,2,1,1,19,38,9,9,126.0,132.0,1,0,0,1,0,1,0,19,0,6,6,6,14.166666666666666,0,0,6,8,6,12.375,0,10.8,1.4,1.74,2 +Student_02742,1,17,8014,0,1,1,1,34,34,0,0,141.0,136.1,0,0,0,1,0,0,0,24,0,6,7,6,12.833333333333334,0,0,6,8,6,12.0,0,7.6,2.6,0.32,2 +Student_02744,1,1,9238,1,1,1,1,1,1,3,3,133.1,102.0,1,0,0,1,0,1,0,20,0,6,7,6,13.666666666666666,0,0,6,7,6,14.571428571428571,0,11.1,0.6,2.02,2 +Student_02745,1,39,9254,1,1,1,1,19,19,4,7,133.1,123.0,0,0,1,0,0,1,0,28,0,6,6,6,10.833333333333334,0,0,6,7,5,11.0,0,13.9,-0.3,0.79,0 +Student_02746,1,1,9853,1,2,1,1,37,19,9,8,NA,137.5,1,0,0,1,0,0,0,21,0,6,7,6,13.428571428571429,0,0,6,8,6,13.142857142857142,0,7.6,2.6,0.32,2 +Student_02747,1,1,9500,1,1,1,1,37,38,191,163,106.0,102.2,1,0,1,1,1,0,0,20,0,7,7,7,12.401428571428571,0,0,8,10,6,11.808333333333332,0,11.1,0.6,2.02,1 +Student_02748,1,42,9003,1,1,1,1,3,2,2,6,130.0,105.3,0,0,0,0,1,0,0,36,0,6,8,0,0.0,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_02749,2,39,9991,0,1,1,1,37,37,9,9,110.0,130.0,0,0,0,0,1,0,0,42,0,4,4,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02750,2,39,9991,0,1,1,1,37,37,9,7,150.0,122.5,0,0,0,1,1,0,0,47,0,5,9,4,11.5,0,0,5,6,5,11.6,1,7.6,2.6,0.32,0 +Student_02751,1,39,9119,1,1,1,1,1,38,4,7,160.0,112.0,0,0,0,0,1,0,0,25,0,5,8,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02752,1,39,9670,1,1,12,1,1,37,3,5,170.0,110.0,0,0,0,1,1,1,0,NA,0,6,8,6,14.142857142857142,0,0,6,6,6,13.5,0,15.5,2.8,-4.06,2 +Student_02753,2,39,8014,0,1,19,1,19,37,6,8,133.1,149.5,0,0,0,1,1,0,0,48,0,6,6,0,0.0,0,0,5,6,0,0.0,0,12.4,0.5,1.79,0 +Student_02754,1,43,9991,0,1,1,1,38,38,9,7,120.0,141.0,0,0,0,1,1,1,0,NA,5,10,12,10,13.8,0,5,10,10,10,12.8,0,10.8,1.4,1.74,2 +Student_02755,1,7,9991,0,1,40,1,38,38,9,7,130.0,130.0,0,0,0,1,1,0,0,38,10,10,10,10,13.6,0,5,10,10,5,13.6,0,8.9,1.4,3.51,0 +Student_02756,1,7,9238,1,1,40,1,37,37,5,5,130.0,130.0,0,0,0,1,1,0,0,37,11,16,23,15,11.733333333333333,0,6,11,17,9,11.88888888888889,0,NA,2.8,-4.06,2 +Student_02757,1,39,9147,1,2,1,1,37,37,9,9,120.0,104.0,0,0,0,0,1,0,0,26,0,5,8,1,10.0,0,0,5,9,1,10.0,0,10.8,1.4,1.74,0 +Student_02758,NA,44,9085,1,1,39,1,3,5,2,2,110.0,110.0,0,0,0,1,1,0,0,23,0,6,19,0,0.0,0,0,6,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_02759,1,44,9003,1,1,39,1,38,19,3,5,120.0,120.0,0,0,0,1,1,0,0,23,0,6,6,0,0.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,1 +Student_02760,1,44,9003,1,1,39,1,2,3,9,6,130.0,130.0,0,0,0,1,1,0,0,20,0,6,12,4,10.8,0,0,6,13,4,12.0,0,12.4,0.5,1.79,1 +Student_02761,1,39,9500,1,1,4,1,3,38,3,7,150.0,127.0,1,0,0,1,1,0,0,26,2,7,8,6,13.046666666666669,0,2,8,10,7,13.30625,0,11.1,0.6,2.02,0 +Student_02762,1,43,8014,0,1,1,1,37,37,9,5,120.0,100.0,0,0,0,1,0,0,0,45,5,9,13,8,11.0,0,3,7,10,6,10.833333333333334,0,12.7,3.7,-1.7,1 +Student_02763,1,39,8014,0,1,19,1,37,37,5,5,100.0,111.0,1,0,0,1,0,1,0,26,0,6,10,3,12.333333333333334,0,0,6,14,3,11.666666666666666,0,7.6,2.6,0.32,1 +Student_02764,1,43,8014,0,1,3,1,9,9,90,90,133.1,130.0,0,0,0,1,0,0,0,26,8,11,16,10,11.8,0,3,7,7,7,13.285714285714286,0,7.6,2.6,0.32,2 +Student_02765,1,39,9991,0,1,1,1,37,37,9,9,130.0,130.1,0,0,0,1,0,0,0,25,0,5,8,3,NA,0,0,5,8,3,11.25,0,10.8,1.4,1.74,1 +Student_02767,1,7,9500,1,1,3,1,37,37,7,7,130.0,130.0,1,0,0,1,0,0,0,27,0,8,8,7,14.414285714285716,0,0,8,8,7,14.414285714285716,0,12.7,3.7,-1.7,2 +Student_02768,6,17,8014,0,3,1,1,19,1,5,90,115.0,115.0,0,0,0,0,0,0,0,24,0,5,5,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_02769,1,17,9147,1,1,1,1,38,19,6,10,124.0,126.8,1,0,0,1,0,0,0,20,0,5,8,5,12.333333333333334,0,0,5,7,5,12.2,0,15.5,2.8,-4.06,2 +Student_02770,1,1,9500,1,1,NA,1,1,19,9,8,124.0,116.7,1,0,0,1,0,1,0,18,0,7,9,0,0.0,0,0,7,8,1,10.0,0,15.5,2.8,-4.06,0 +Student_02771,1,17,9556,1,6,1,1,19,38,7,7,134.0,128.5,1,0,0,1,0,1,0,18,0,7,9,7,14.1,0,0,8,8,8,13.3125,0,12.7,3.7,-1.7,2 +Student_02772,1,1,9500,1,4,1,1,37,37,9,9,137.0,127.5,1,0,0,1,0,0,0,18,0,8,8,8,13.045,0,0,8,8,8,13.045,0,9.4,-0.8,-3.12,2 +Student_02773,1,1,9500,1,1,1,1,19,37,3,8,124.0,117.5,1,0,0,1,1,0,0,19,0,8,10,5,12.858,3,0,8,10,5,12.858,3,9.4,-0.8,-3.12,1 +Student_02774,1,42,9500,1,3,1,1,1,1,4,4,136.0,148.8,1,0,0,1,0,1,0,19,0,8,8,8,14.2525,0,0,8,8,8,14.2525,0,9.4,-0.8,-3.12,2 +Student_02775,1,1,9500,1,4,1,1,12,1,5,10,126.0,120.2,0,0,0,1,0,1,0,19,0,7,9,5,14.06,0,0,7,9,7,11.242857142857142,0,12.4,0.5,1.79,1 +Student_02776,1,1,9500,1,4,1,1,38,37,9,5,142.0,127.3,1,0,0,1,0,0,0,18,0,8,8,7,15.075714285714286,0,0,8,8,7,15.075714285714286,0,10.8,1.4,1.74,2 +Student_02777,1,17,171,1,2,1,1,19,37,9,9,141.0,136.1,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,1 +Student_02778,1,43,9670,1,2,1,1,3,3,5,5,129.0,122.4,1,0,0,1,0,0,0,19,0,5,5,4,13.75,0,0,6,9,5,12.6,0,12.7,3.7,-1.7,1 +Student_02780,1,1,9238,1,2,1,NA,19,19,4,7,136.0,121.7,1,0,0,1,0,1,0,21,0,6,9,5,12.333333333333334,0,0,6,7,5,11.8,0,13.9,-0.3,0.79,2 +Student_02781,1,1,9500,1,3,1,1,38,38,5,7,137.0,122.7,1,0,0,1,0,1,0,18,0,7,8,7,13.778571428571428,0,0,8,10,8,13.122222222222222,0,16.2,0.3,-0.92,2 +Student_02783,1,43,9773,1,1,1,1,19,37,5,5,119.0,105.0,1,0,0,1,0,0,0,23,0,6,11,3,11.333333333333334,0,0,6,7,2,11.0,0,16.2,0.3,-0.92,1 +Student_02784,1,1,9238,1,1,1,1,37,37,9,7,132.0,129.9,1,0,0,1,0,0,0,20,0,6,7,5,13.2,0,0,6,6,6,12.666666666666666,0,10.8,1.4,1.74,1 +Student_02785,1,1,9070,1,1,1,1,37,37,5,7,152.0,136.3,0,0,0,1,0,1,0,18,1,6,8,6,13.571428571428571,1,0,6,11,6,12.375,0,13.9,-0.3,0.79,2 +Student_02789,1,39,9670,1,1,1,1,19,19,7,7,148.0,130.9,0,0,1,0,1,0,0,24,0,6,12,0,0.0,0,0,6,9,0,0.0,0,NA,1.4,1.74,0 +Student_02790,1,39,171,1,1,1,1,37,37,9,7,133.1,100.0,0,0,1,1,1,1,0,33,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_02791,1,17,9147,1,1,1,1,19,37,5,7,115.0,112.9,1,0,0,0,1,0,0,19,0,5,7,2,12.5,0,0,5,13,1,11.0,0,9.4,-0.8,-3.12,0 +Student_02793,4,39,8014,0,1,1,1,37,37,7,7,133.1,143.0,0,0,0,1,1,0,0,37,3,9,13,8,12.0,0,2,7,8,7,11.571428571428571,0,12.7,3.7,-1.7,2 +Student_02794,1,1,171,1,1,1,1,38,37,9,8,168.0,155.1,1,0,1,0,1,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_02795,4,39,9991,0,1,1,1,37,37,9,9,130.0,127.6,0,0,0,1,1,0,0,29,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,1 +Student_02796,2,39,9500,1,1,38,1,37,37,9,3,133.1,146.6,0,0,0,1,1,0,0,37,0,7,8,7,12.828571428571427,0,0,8,8,8,NA,0,13.9,-0.3,0.79,2 +Student_02798,1,1,9670,1,2,1,1,1,38,7,7,123.0,120.6,1,0,0,1,1,0,0,19,0,6,6,6,13.333333333333334,0,0,6,8,5,14.0,0,8.9,1.4,3.51,2 +Student_02799,1,42,9500,1,1,1,1,19,1,9,3,150.0,110.0,1,0,0,1,1,1,0,33,6,14,20,14,13.072857142857144,6,6,14,20,14,13.072857142857144,6,9.4,-0.8,-3.12,2 +Student_02800,1,42,9119,1,1,1,1,1,1,5,7,120.0,108.6,0,0,0,0,1,0,0,34,2,7,13,5,12.0,0,2,7,7,3,11.0,0,15.5,2.8,-4.06,0 +Student_02801,1,1,9254,1,1,1,1,3,19,3,8,145.0,134.9,1,0,0,1,0,0,0,18,0,6,6,6,15.5,0,0,6,6,6,16.0,0,12.4,0.5,1.79,2 +Student_02804,1,1,9085,1,3,1,1,19,19,9,1,147.0,135.6,1,0,0,1,0,0,0,20,0,6,7,6,16.714285714285715,0,0,6,6,6,15.333333333333334,0,13.9,-0.3,0.79,2 +Student_02805,1,1,9238,1,1,1,1,19,19,9,9,125.0,121.5,1,0,0,1,0,1,0,19,0,6,9,6,10.857142857142858,0,0,6,7,6,11.666666666666666,0,12.4,0.5,1.79,2 +Student_02808,1,1,9670,1,1,1,1,12,12,5,7,122.0,126.6,1,0,0,1,0,0,0,18,0,6,8,6,14.625,0,0,6,9,6,14.142857142857142,0,11.1,0.6,2.02,1 +Student_02809,1,1,9773,1,1,1,1,1,38,9,NA,123.0,116.7,0,0,0,1,0,1,0,18,0,6,6,6,12.166666666666666,0,0,6,8,6,12.666666666666666,0,12.4,0.5,1.79,2 +Student_02810,1,1,9500,1,3,1,1,1,19,131,181,126.0,120.1,1,0,0,1,0,0,0,19,0,7,12,4,13.375,0,0,7,8,6,12.116666666666667,0,12.4,0.5,1.79,1 +Student_02811,1,1,9853,1,1,1,1,38,37,9,9,128.0,124.9,0,0,0,1,0,1,0,19,0,6,6,6,12.5,0,0,6,6,6,12.833333333333334,0,12.7,3.7,-1.7,2 +Student_02812,1,39,9500,1,1,1,1,19,1,1,90,100.0,114.0,1,0,1,0,0,0,0,31,0,7,8,5,12.56,0,0,7,8,5,12.56,0,7.6,2.6,0.32,0 +Student_02813,1,17,9500,1,5,1,1,1,1,4,3,140.0,131.1,1,0,0,1,0,0,0,18,0,7,7,7,13.19,0,0,8,8,8,14.23125,0,11.1,0.6,2.02,2 +Student_02814,1,1,9238,1,1,1,1,1,19,9,9,145.0,129.3,0,0,1,1,0,1,0,19,0,6,11,3,11.0,0,0,6,9,4,11.25,0,10.8,1.4,1.74,2 +Student_02815,1,1,171,1,1,1,1,3,38,2,10,143.0,129.7,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_02816,1,17,9238,1,1,1,1,37,38,9,5,132.0,120.8,0,0,0,1,0,1,0,19,0,6,11,5,11.6,0,0,6,10,6,11.714285714285714,0,15.5,2.8,-4.06,2 +Student_02817,1,1,9500,1,1,1,1,19,19,9,6,130.0,135.0,0,0,0,1,0,0,0,19,0,7,7,6,14.266666666666666,0,0,7,7,6,14.266666666666666,0,NA,2.6,0.32,2 +Student_02818,NA,1,9147,1,1,1,1,37,37,9,7,129.0,117.8,0,0,0,1,0,1,0,19,0,5,6,4,11.0,0,0,5,9,4,13.857142857142858,0,10.8,1.4,1.74,1 +Student_02819,2,7,8014,0,1,3,1,37,34,0,0,124.4,130.0,0,0,0,1,0,0,0,30,8,10,11,9,12.666666666666666,0,3,7,7,7,12.428571428571429,1,7.6,2.6,0.32,2 +Student_02820,1,43,9773,1,1,1,1,19,1,5,5,127.0,117.6,1,0,0,1,0,0,0,18,0,6,6,0,0.0,0,0,6,10,3,11.0,0,16.2,0.3,-0.92,1 +Student_02821,1,18,9500,1,6,1,1,1,1,3,6,144.0,130.8,1,0,0,1,0,0,0,18,0,8,11,7,12.771428571428572,0,0,8,11,7,12.771428571428572,0,12.7,3.7,-1.7,2 +Student_02822,1,18,9085,1,5,1,1,5,3,2,3,121.0,111.9,1,0,0,1,0,0,0,21,0,5,12,0,0.0,3,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_02823,1,44,9238,1,1,1,1,1,38,4,9,150.0,145.9,0,0,0,1,0,1,0,19,3,6,6,6,15.5,0,2,6,7,6,13.571428571428571,0,13.9,-0.3,0.79,2 +Student_02825,1,1,9500,1,5,1,1,3,19,4,8,125.0,120.3,1,0,0,1,0,0,0,19,0,7,11,5,11.716666666666669,0,0,7,8,5,13.7,0,13.9,-0.3,0.79,1 +Student_02828,2,39,9991,0,1,1,1,37,37,9,6,140.0,130.2,0,0,0,1,0,1,0,39,0,5,13,4,12.333333333333334,0,0,5,14,2,10.0,4,16.2,0.3,-0.92,2 +Student_02829,1,1,9070,1,2,1,1,3,4,2,2,129.0,136.4,1,0,0,1,0,0,0,18,0,6,6,6,12.333333333333334,0,0,6,6,6,12.833333333333334,0,7.6,2.6,0.32,1 +Student_02830,1,17,171,1,1,1,1,3,1,9,9,130.0,126.9,1,0,0,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02831,1,17,9147,1,5,1,1,19,38,3,10,131.0,119.8,1,0,0,1,0,0,0,19,0,5,8,5,12.6,0,0,5,9,4,11.6,0,8.9,1.4,3.51,2 +Student_02832,1,17,9147,1,3,1,1,1,1,4,7,137.0,124.4,1,0,0,1,NA,0,0,18,0,5,5,5,12.6,0,0,5,5,4,11.0,0,11.1,0.6,2.02,1 +Student_02833,2,39,9003,1,1,1,1,3,3,2,2,150.0,120.0,0,0,1,0,0,0,0,34,1,6,10,6,14.333333333333334,0,0,6,9,6,12.833333333333334,0,11.1,0.6,2.02,1 +Student_02835,1,39,9085,1,1,1,1,19,19,7,7,133.1,130.0,1,0,0,1,0,0,0,24,0,6,7,6,14.857142857142858,0,0,6,10,5,13.6,0,13.9,-0.3,0.79,2 +Student_02836,2,43,9147,1,1,1,1,19,37,7,10,130.0,138.0,0,0,0,1,0,0,0,34,12,15,17,12,11.916666666666666,0,11,13,13,11,13.181818181818182,0,7.6,2.6,0.32,2 +Student_02837,2,39,9991,0,1,1,1,34,34,0,0,110.0,114.6,1,0,0,1,0,0,0,46,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_02838,2,39,9147,1,2,1,1,37,37,9,8,140.0,108.0,0,0,0,1,0,0,0,50,0,5,12,3,13.333333333333334,1,0,5,8,5,12.2,0,9.4,-0.8,-3.12,1 +Student_02839,1,39,9991,0,1,1,1,37,37,9,5,140.0,140.0,0,0,0,0,0,0,0,37,0,5,5,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_02840,1,1,9085,1,2,1,1,38,19,4,9,148.0,134.7,1,0,0,1,0,0,0,18,0,6,6,6,17.0,0,0,6,6,6,15.5,0,8.9,1.4,3.51,2 +Student_02841,1,39,9085,1,1,1,1,37,37,6,6,130.0,110.0,0,0,0,1,0,1,0,25,0,6,13,3,11.666666666666666,0,0,6,14,2,11.333333333333334,0,11.1,0.6,2.02,1 +Student_02843,2,39,9070,1,1,1,1,3,1,2,5,160.0,126.5,0,0,0,1,0,1,0,30,1,6,8,6,13.0,1,0,6,9,5,12.857142857142858,0,13.9,-0.3,0.79,2 +Student_02844,4,1,9991,0,1,1,1,37,37,9,9,130.0,118.1,0,0,1,0,0,0,0,37,0,5,0,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02845,2,39,9991,0,1,1,1,37,37,9,9,120.0,119.9,0,0,0,1,0,0,0,50,0,5,9,2,10.5,0,0,5,7,3,NA,0,12.7,3.7,-1.7,1 +Student_02846,1,44,9003,1,1,39,1,38,38,9,6,160.0,160.0,1,0,0,1,0,0,0,20,0,6,7,6,13.571428571428571,0,0,6,9,6,12.714285714285714,0,12.4,0.5,1.79,2 +Student_02850,1,44,9085,1,1,39,1,3,3,4,2,140.0,140.0,1,0,0,1,0,0,0,19,0,6,8,4,14.4,0,0,6,6,5,13.0,0,13.9,-0.3,0.79,2 +Student_02852,1,1,9773,1,3,1,1,1,37,4,5,130.0,120.9,1,0,1,1,0,0,0,18,0,6,6,6,14.333333333333334,0,0,6,6,6,14.166666666666666,0,8.9,1.4,3.51,2 +Student_02853,1,53,9003,1,1,42,1,1,1,144,144,130.0,125.8,0,0,1,1,0,0,0,21,7,13,21,11,11.909090909090908,0,5,11,14,11,10.727272727272728,0,8.9,1.4,3.51,2 +Student_02854,1,18,9070,1,3,1,1,1,1,5,3,164.0,161.2,1,0,0,1,0,0,0,18,1,6,8,6,13.714285714285714,1,0,6,8,6,14.375,0,13.9,-0.3,0.79,2 +Student_02855,1,1,9500,1,1,1,1,19,19,9,10,125.0,122.0,1,0,1,1,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,11.1,0.6,2.02,0 +Student_02856,1,17,9500,1,1,1,1,1,1,9,9,137.0,127.9,1,0,0,1,0,1,0,18,0,7,10,5,13.46,0,0,7,8,7,12.2375,0,11.1,0.6,2.02,0 +Student_02857,1,1,9773,1,1,1,1,1,3,3,3,133.0,135.8,1,0,0,1,0,0,0,19,0,6,6,6,15.0,0,0,6,6,6,13.333333333333334,0,11.1,0.6,2.02,2 +Student_02858,1,1,171,1,1,1,1,1,1,4,3,163.0,149.7,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02859,1,1,9670,1,2,1,1,2,1,4,4,160.0,137.3,1,0,0,1,0,0,0,19,0,6,7,5,13.4,0,0,6,6,5,12.8,0,12.7,3.7,-1.7,2 +Student_02860,4,43,8014,0,1,12,1,34,34,0,NA,133.1,106.0,1,0,0,1,0,0,0,48,0,6,9,5,13.0,0,0,6,10,4,12.5,0,7.6,2.6,0.32,1 +Student_02861,4,43,9238,1,1,1,1,37,37,9,9,120.0,110.0,0,0,1,1,0,0,0,34,0,6,13,4,11.25,0,0,6,8,4,13.75,0,13.9,-0.3,0.79,2 +Student_02862,1,1,9085,1,1,1,1,3,3,2,2,140.0,146.4,0,0,0,1,0,0,0,18,0,5,5,5,12.6,0,0,5,7,5,11.6,0,7.6,2.6,0.32,2 +Student_02863,2,39,8014,0,1,1,1,37,37,9,9,140.0,121.0,0,0,0,1,0,0,0,50,0,6,8,6,12.666666666666666,0,0,6,6,6,11.833333333333334,0,10.8,1.4,1.74,2 +Student_02864,1,43,9853,1,1,1,1,37,37,6,6,140.0,125.2,0,0,1,1,0,0,0,41,20,21,23,21,12.333333333333334,0,19,19,19,19,12.105263157894736,0,12.4,0.5,1.79,2 +Student_02865,1,17,9773,1,2,1,1,1,1,5,5,115.0,119.6,1,0,0,1,NA,1,0,22,0,6,11,5,12.0,0,0,6,11,5,11.0,0,7.6,2.6,0.32,0 +Student_02866,4,39,9147,1,1,1,1,37,37,9,9,140.0,142.8,0,0,0,1,0,0,0,43,0,5,5,5,16.4,0,0,5,5,5,16.6,0,7.6,2.6,0.32,2 +Student_02868,1,39,9003,1,1,19,1,37,37,9,9,133.1,100.0,0,0,0,1,0,0,0,60,0,6,10,6,12.75,0,0,6,6,4,14.75,0,13.9,-0.3,0.79,2 +Student_02869,2,39,9147,1,1,1,1,37,37,9,10,110.0,140.0,0,0,0,1,0,0,0,41,0,5,14,4,14.5,1,0,5,12,5,13.0,0,9.4,-0.8,-3.12,1 +Student_02870,2,39,9991,0,1,19,1,37,37,9,9,133.1,150.3,0,0,0,1,0,0,0,47,0,5,5,5,14.8,0,0,5,5,5,14.4,0,7.6,2.6,0.32,2 +Student_02871,1,1,171,1,1,3,1,3,3,2,2,116.0,128.2,0,0,0,1,0,0,0,22,12,17,22,17,10.36842105263158,0,14,17,18,17,11.5,0,11.1,0.6,2.02,2 +Student_02872,2,39,9500,1,1,1,1,37,37,9,6,110.0,114.3,0,0,0,1,0,0,0,41,0,7,0,0,0.0,0,0,8,0,0,0.0,0,10.8,1.4,1.74,0 +Student_02873,2,43,9991,0,1,1,1,38,37,5,6,140.0,117.3,0,0,0,1,0,0,0,28,6,10,15,6,10.666666666666666,0,5,10,17,9,11.333333333333334,1,7.6,2.6,0.32,1 +Student_02874,5,42,9254,1,1,2,1,37,37,4,9,120.0,120.0,0,0,0,1,0,0,0,32,9,15,21,13,12.692307692307692,0,12,15,22,13,12.384615384615383,0,10.8,1.4,1.74,2 +Student_02876,1,51,9147,1,1,1,1,1,37,9,10,160.0,118.0,0,0,0,1,0,0,0,53,14,15,15,15,11.8,0,12,13,13,12,11.666666666666666,1,8.9,1.4,3.51,1 +Student_02877,1,39,9556,1,1,1,6,3,3,4,4,133.1,169.2,0,0,1,0,NA,0,1,54,0,7,7,0,0.0,0,0,5,10,0,0.0,0,12.4,0.5,1.79,0 +Student_02878,1,39,8014,0,1,1,1,37,37,9,7,120.0,106.8,0,0,0,1,0,0,0,49,0,6,9,5,12.333333333333334,0,0,6,12,4,11.5,0,13.9,-0.3,0.79,1 +Student_02879,2,42,9853,1,1,1,1,37,37,4,7,133.1,100.0,0,0,0,1,0,0,0,34,6,12,18,11,13.0,0,4,13,22,8,11.875,0,12.7,3.7,-1.7,0 +Student_02880,4,39,8014,0,1,1,1,38,37,5,7,133.1,144.5,0,0,0,1,0,0,0,45,0,6,13,4,12.5,0,0,6,8,3,11.666666666666666,0,16.2,0.3,-0.92,0 +Student_02881,4,39,8014,0,1,19,1,37,37,9,7,133.1,134.5,0,0,0,1,0,1,0,47,0,6,8,5,12.2,0,0,6,10,4,11.25,0,12.4,0.5,1.79,2 +Student_02883,2,39,9991,0,1,1,1,37,37,9,9,133.1,113.4,0,0,0,1,0,0,0,33,0,5,14,1,10.0,0,0,5,13,2,12.0,0,NA,0.5,1.79,0 +Student_02884,2,39,8014,0,1,1,1,37,37,9,9,140.0,128.0,0,0,0,1,0,1,0,43,0,6,7,6,12.333333333333334,0,0,6,8,6,11.5,0,8.9,1.4,3.51,2 +Student_02885,1,7,9003,1,1,3,1,37,37,6,6,120.0,120.0,0,0,0,1,0,0,0,54,9,13,13,13,14.307692307692308,0,5,12,15,12,15.23076923076923,0,15.5,2.8,-4.06,2 +Student_02887,2,39,9991,0,1,1,1,37,37,9,9,120.0,120.7,0,0,0,1,0,0,0,39,0,5,6,5,11.0,0,0,5,5,5,13.2,0,7.6,2.6,0.32,2 +Student_02888,1,1,9853,1,1,1,1,19,37,9,9,153.0,153.7,0,0,0,1,0,1,0,18,0,6,8,6,13.142857142857142,0,0,6,6,6,12.833333333333334,0,15.5,2.8,-4.06,2 +Student_02890,1,17,9670,1,4,1,1,38,19,9,6,126.0,119.4,1,0,0,1,0,1,0,18,0,6,6,6,14.0,0,0,6,9,5,13.8,0,8.9,1.4,3.51,2 +Student_02891,2,39,8014,0,1,12,1,34,34,0,0,110.0,157.8,0,0,0,1,0,0,0,44,5,8,13,8,13.75,0,2,6,9,6,12.5,0,7.6,2.6,0.32,2 +Student_02892,1,39,9991,0,1,1,1,3,1,3,9,150.0,154.0,0,0,0,1,0,0,0,27,0,5,5,0,0.0,0,0,5,6,0,0.0,0,12.4,0.5,1.79,0 +Student_02894,2,43,8014,0,1,1,1,34,34,0,0,130.0,130.0,0,0,0,1,0,0,0,45,10,12,12,9,12.444444444444445,3,4,7,8,6,12.0,0,9.4,-0.8,-3.12,0 +Student_02895,1,17,9853,1,4,1,1,38,37,9,9,122.0,118.9,1,0,0,1,0,0,0,20,0,6,7,6,12.666666666666666,0,0,6,7,5,13.0,0,7.6,2.6,0.32,2 +Student_02896,2,1,8014,0,1,1,1,37,37,9,9,151.0,152.4,0,0,0,1,0,0,0,40,0,6,7,6,11.333333333333334,0,0,6,7,6,10.5,0,10.8,1.4,1.74,2 +Student_02897,1,39,9991,0,1,1,1,37,37,6,6,120.0,147.8,0,0,0,1,0,0,0,40,0,5,9,4,11.25,0,0,5,6,5,12.0,0,13.9,-0.3,0.79,1 +Student_02898,1,43,9500,1,1,1,1,3,3,2,2,136.0,100.0,0,0,0,NA,0,0,0,18,0,7,8,7,13.6125,0,0,8,8,8,14.575,0,13.9,-0.3,0.79,2 +Student_02899,1,18,9500,1,6,1,1,3,19,3,8,140.0,129.0,1,0,0,1,0,0,0,21,0,8,8,7,12.414285714285716,0,0,8,8,7,12.414285714285716,0,12.7,3.7,-1.7,2 +Student_02900,1,17,171,1,2,1,1,2,1,3,3,131.0,148.9,1,0,0,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_02901,2,43,9991,0,1,2,1,37,37,9,8,120.0,120.0,0,0,0,1,0,0,0,36,8,12,21,11,11.5,0,7,12,22,12,11.4375,0,9.4,-0.8,-3.12,1 +Student_02902,2,7,8014,0,1,3,1,19,19,4,4,170.0,170.0,0,0,0,1,0,0,0,27,0,5,5,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02903,2,39,9556,1,1,1,NA,38,38,9,9,100.0,130.0,0,0,0,1,0,0,1,32,0,7,10,7,11.0,0,0,8,8,8,13.125,0,12.7,3.7,-1.7,2 +Student_02904,1,17,9238,1,1,1,1,1,1,3,3,116.0,119.2,1,0,0,1,0,1,0,18,0,6,6,6,14.0,0,0,6,6,6,13.5,0,8.9,1.4,3.51,2 +Student_02905,1,39,8014,0,1,1,1,37,37,9,7,133.1,129.0,0,0,0,1,0,0,0,37,0,6,13,4,12.0,0,0,6,10,3,12.0,0,16.2,0.3,-0.92,0 +Student_02907,4,39,8014,0,2,1,1,37,38,7,5,160.0,115.0,0,0,0,1,0,1,0,41,0,6,8,6,11.333333333333334,0,0,6,9,6,11.333333333333334,0,NA,1.4,1.74,2 +Student_02909,1,43,9085,1,1,1,1,37,37,90,90,130.0,125.1,0,0,0,1,0,0,0,21,2,9,14,8,13.555555555555555,0,2,7,10,7,13.571428571428571,0,7.6,2.6,0.32,2 +Student_02910,1,44,9003,1,1,1,1,1,19,3,9,140.0,140.0,1,0,1,0,0,0,0,23,0,6,13,5,11.6,0,0,6,11,4,12.25,0,12.4,0.5,1.79,0 +Student_02911,1,NA,9773,1,2,1,1,1,1,3,3,123.0,120.9,1,0,0,1,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02913,1,43,9085,1,4,1,1,34,34,99,99,133.1,125.2,0,0,0,1,0,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_02914,1,1,9238,1,2,1,1,22,30,0,8,136.0,135.7,1,0,0,1,0,0,0,19,0,6,8,6,14.375,0,0,6,8,6,14.75,0,7.6,2.6,0.32,2 +Student_02915,6,39,9147,1,2,1,1,37,37,9,9,133.1,110.0,0,0,0,1,0,0,0,47,0,5,0,0,0.0,0,0,5,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02916,6,39,8014,0,1,1,1,37,37,9,9,133.1,119.0,0,0,0,1,0,1,0,48,0,6,7,6,10.666666666666666,0,0,6,9,5,11.8,0,10.8,1.4,1.74,1 +Student_02917,2,7,8014,0,1,3,1,37,37,9,9,110.0,110.0,0,0,0,1,0,0,0,39,9,13,19,12,13.416666666666666,0,4,10,10,10,14.5,0,16.2,0.3,-0.92,2 +Student_02919,1,43,9991,0,1,2,1,37,37,9,9,110.0,112.9,0,0,0,1,0,0,0,38,14,15,16,14,10.928571428571429,0,12,14,16,12,11.833333333333334,0,9.4,-0.8,-3.12,0 +Student_02920,5,39,9003,1,1,19,1,19,1,9,9,133.1,119.4,0,0,1,0,0,0,0,27,0,6,6,0,0.0,0,0,6,7,0,0.0,0,8.9,1.4,3.51,0 +Student_02921,1,1,171,1,1,1,1,19,19,4,7,162.0,152.9,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,2 +Student_02922,1,39,8014,0,1,1,1,19,37,4,5,155.0,117.5,0,0,0,1,0,0,0,34,0,6,6,4,13.25,0,0,6,6,0,0.0,0,12.7,3.7,-1.7,1 +Student_02923,2,39,9238,1,1,19,1,37,37,4,4,133.1,98.5,0,0,0,1,0,0,0,48,0,6,14,6,11.333333333333334,0,0,6,11,5,12.4,0,15.5,2.8,-4.06,0 +Student_02924,1,39,9670,1,1,1,1,34,34,0,0,150.0,108.0,0,0,0,1,0,0,0,25,0,5,6,1,11.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_02925,2,39,9500,1,1,1,1,19,37,6,6,133.1,120.0,0,0,0,1,0,1,0,32,0,8,9,7,12.757142857142856,0,0,8,9,7,12.757142857142856,0,12.7,3.7,-1.7,2 +Student_02927,1,44,8014,0,1,39,1,1,3,4,6,140.0,139.2,0,0,1,1,0,0,0,20,3,6,6,6,13.833333333333334,0,2,6,7,6,14.571428571428571,0,12.4,0.5,1.79,2 +Student_02928,1,1,9147,1,1,1,1,19,37,9,7,158.0,130.0,1,0,0,1,0,0,0,20,0,5,8,4,11.25,0,0,5,7,5,10.4,0,7.6,2.6,0.32,2 +Student_02930,1,1,9500,1,3,1,1,1,1,4,4,136.0,127.0,1,0,0,1,0,0,0,19,0,8,10,1,13.67,7,0,8,10,1,13.67,7,9.4,-0.8,-3.12,1 +Student_02931,1,39,9991,0,1,9,1,37,34,90,90,133.1,118.1,1,0,0,1,0,0,0,39,0,5,9,0,0.0,0,0,5,5,2,12.5,0,7.6,2.6,0.32,0 +Student_02935,2,39,8014,0,1,12,1,34,34,0,0,133.1,135.0,0,0,0,1,0,0,0,51,0,6,12,0,0.0,0,1,6,11,0,0.0,1,7.6,2.6,0.32,0 +Student_02936,1,43,9773,1,1,1,22,34,34,90,90,133.1,130.0,0,0,1,1,0,0,1,23,0,6,11,1,16.0,0,0,6,8,4,12.25,0,7.6,2.6,0.32,0 +Student_02937,1,44,9085,1,1,1,1,29,10,6,6,150.0,150.0,1,0,0,1,0,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_02938,1,43,9853,1,5,1,1,34,34,0,0,150.0,150.2,1,0,0,0,0,0,0,28,0,6,9,4,12.75,1,0,5,5,0,0.0,5,9.4,-0.8,-3.12,0 +Student_02939,2,39,9991,0,1,1,1,37,37,9,3,110.0,127.1,0,0,0,1,0,0,0,34,0,5,9,4,11.0,0,0,5,10,4,10.75,1,7.6,2.6,0.32,1 +Student_02941,NA,39,8014,0,1,3,1,37,37,9,9,100.0,130.0,0,0,0,1,0,1,0,43,0,6,7,5,12.2,0,0,6,6,6,12.333333333333334,0,9.4,-0.8,-3.12,2 +Student_02942,2,39,9556,1,2,1,105,1,3,9,2,133.1,152.8,1,0,0,1,0,0,1,28,0,7,9,7,12.428571428571429,0,0,8,8,8,12.3,0,12.4,0.5,1.79,1 +Student_02943,1,1,171,1,1,1,1,40,1,2,4,145.0,160.1,0,0,0,1,0,1,0,19,6,12,12,12,14.5,0,4,11,15,11,13.583333333333334,0,8.9,1.4,3.51,2 +Student_02945,1,1,9500,1,4,1,1,4,3,2,3,118.0,110.7,1,0,0,1,0,0,0,18,0,7,7,7,11.714285714285714,0,0,8,8,8,12.75,0,12.4,0.5,1.79,2 +Student_02946,2,39,9853,1,1,1,1,37,19,9,5,133.1,138.3,0,0,0,1,0,0,0,45,0,7,12,4,10.25,0,0,7,10,3,13.0,0,11.1,0.6,2.02,0 +Student_02947,1,44,9853,1,1,39,1,3,37,2,7,150.0,150.0,0,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_02948,1,17,9670,1,6,1,1,4,1,3,10,113.0,112.3,0,0,0,1,0,0,0,20,0,6,9,6,12.375,0,0,6,7,6,13.142857142857142,0,11.1,0.6,2.02,2 +Student_02949,1,1,9853,1,6,1,1,1,19,5,5,136.0,122.0,0,0,0,1,0,0,0,18,0,6,6,6,12.666666666666666,0,0,6,6,6,12.0,0,7.6,2.6,0.32,2 +Student_02950,1,39,9085,1,1,1,1,3,3,4,2,140.0,141.7,1,0,0,1,0,0,0,27,0,6,13,3,10.5,0,0,6,19,1,12.0,0,12.4,0.5,1.79,0 +Student_02951,2,1,9003,1,1,1,1,19,38,5,5,131.0,118.4,0,0,0,1,0,0,0,20,0,6,11,6,14.125,0,0,6,10,5,12.6,0,13.9,-0.3,0.79,2 +Student_02952,1,1,9085,1,3,1,1,1,1,4,8,138.0,128.7,1,0,0,1,0,0,0,18,0,6,7,6,14.666666666666666,0,0,6,12,6,13.833333333333334,0,8.9,1.4,3.51,2 +Student_02953,2,39,9670,1,2,1,1,37,37,9,9,100.0,100.0,0,0,0,1,0,0,0,35,0,5,8,5,11.4,0,0,5,7,3,12.333333333333334,0,9.4,-0.8,-3.12,1 +Student_02954,1,39,171,1,1,1,1,37,37,9,9,140.0,100.8,0,1,0,1,0,0,0,26,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_02957,1,7,9500,1,1,3,1,37,37,9,5,130.0,130.0,0,0,0,1,0,0,0,36,0,7,7,0,0.0,7,0,7,7,0,0.0,7,16.2,0.3,NA,0 +Student_02958,2,39,8014,0,1,3,1,37,37,9,9,110.0,160.5,0,0,0,1,0,0,0,38,8,11,11,11,12.636363636363637,0,5,8,8,8,11.0,0,13.9,-0.3,0.79,2 +Student_02960,5,39,9254,1,1,1,1,2,2,2,2,133.1,103.0,0,0,0,1,0,0,0,62,0,6,7,6,15.0,0,0,6,10,6,12.833333333333334,0,10.8,1.4,1.74,2 +Student_02962,1,1,9500,1,1,1,1,19,37,9,9,139.0,131.5,1,0,0,1,0,0,0,18,0,8,8,7,14.13714285714286,0,0,8,8,7,14.13714285714286,0,10.8,1.4,1.74,2 +Student_02963,NA,18,9070,1,3,1,1,1,1,3,4,134.0,121.4,0,0,0,1,0,0,0,18,0,6,6,2,12.0,0,0,6,6,1,11.0,0,9.4,-0.8,-3.12,0 +Student_02965,1,1,9070,1,1,1,1,19,19,9,9,124.0,138.4,1,0,1,1,0,1,0,19,1,6,8,6,13.285714285714286,1,0,6,8,6,12.5,0,13.9,-0.3,0.79,0 +Student_02966,1,17,NA,1,1,1,1,1,3,7,3,137.0,131.1,1,0,1,1,0,1,0,19,0,5,7,5,13.6,0,0,5,5,5,12.6,0,8.9,1.4,3.51,2 +Student_02967,1,42,9500,1,1,1,1,3,3,3,3,157.0,100.0,0,0,0,1,0,0,0,18,0,7,8,7,13.55,0,0,8,8,8,14.1875,0,13.9,-0.3,0.79,2 +Student_02968,1,17,9500,1,4,1,1,4,1,2,1,138.0,133.0,1,0,0,1,0,0,0,18,0,8,8,0,0.0,5,0,8,8,0,NA,5,9.4,-0.8,-3.12,1 +Student_02969,1,39,8014,0,2,1,1,35,37,90,90,100.0,100.0,0,0,0,1,0,0,0,41,0,6,10,4,13.5,0,1,6,7,6,11.166666666666666,0,7.6,2.6,0.32,2 +Student_02970,1,39,9670,1,1,1,1,19,3,4,2,130.0,159.0,0,0,0,1,0,1,0,51,0,6,8,5,11.6,0,0,6,9,5,14.2,0,12.4,0.5,1.79,2 +Student_02972,1,39,9991,0,1,3,1,19,1,9,5,120.0,134.0,0,0,0,1,0,0,0,25,0,5,14,1,11.0,0,0,5,11,2,12.666666666666666,4,16.2,0.3,-0.92,0 +Student_02973,1,5,9085,1,1,1,1,1,1,4,4,150.0,139.4,0,0,0,1,0,0,0,18,0,5,9,3,12.0,1,0,5,6,4,13.0,0,7.6,2.6,0.32,1 +Student_02974,1,16,9147,1,6,NA,1,37,37,9,9,128.0,116.5,1,0,0,1,0,0,0,20,0,5,8,4,11.6,0,0,5,10,3,12.333333333333334,0,7.6,2.6,0.32,2 +Student_02975,1,1,171,1,1,1,1,1,19,123,103,124.0,113.9,1,1,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_02976,5,43,9991,0,1,3,1,3,3,1,1,130.0,130.0,0,0,0,1,0,0,0,41,5,10,14,10,14.636363636363637,0,5,10,13,10,14.6,0,16.2,0.3,-0.92,2 +Student_02977,1,1,9254,1,2,1,1,1,19,9,9,132.0,129.9,1,0,0,1,0,1,0,19,0,6,8,6,13.0,0,0,6,6,6,12.166666666666666,0,8.9,1.4,3.51,2 +Student_02978,1,42,9853,1,1,12,1,1,3,3,2,133.1,133.7,0,0,0,1,0,0,0,28,14,18,23,14,12.785714285714286,2,16,17,18,16,13.875,0,16.2,0.3,-0.92,0 +Student_02979,1,1,9070,1,3,1,1,5,3,5,7,129.0,124.8,1,0,0,1,0,0,0,21,0,6,6,6,14.5,0,0,6,7,5,12.0,0,12.4,0.5,1.79,2 +Student_02980,1,1,9085,1,1,1,1,3,2,1,1,135.0,133.6,1,0,0,0,0,0,0,22,0,5,12,4,14.6,3,0,5,5,4,12.75,1,9.4,-0.8,-3.12,0 +Student_02981,1,17,9773,1,4,1,1,37,19,5,7,138.0,133.5,1,0,0,0,0,0,0,18,0,6,7,6,12.5,0,0,6,6,6,12.166666666666666,0,10.8,1.4,1.74,2 +Student_02982,1,1,9070,1,1,1,1,19,37,9,9,135.0,128.0,1,0,0,1,0,1,0,19,0,6,6,6,14.0,0,0,6,8,6,13.125,0,10.8,1.4,1.74,2 +Student_02983,1,17,9500,1,6,1,1,3,19,5,5,131.0,127.2,1,0,0,1,0,1,0,19,0,7,7,7,13.801428571428572,0,0,8,8,8,14.575,0,11.1,0.6,2.02,2 +Student_02984,1,7,9853,1,1,3,1,19,19,4,5,NA,150.0,0,0,1,0,0,0,0,25,1,6,7,6,14.428571428571429,0,0,6,7,6,13.666666666666666,0,10.8,1.4,1.74,2 +Student_02985,1,42,9500,1,4,6,1,1,19,2,9,133.0,127.8,1,0,0,1,0,1,0,18,0,7,7,6,14.35,0,0,7,7,6,14.35,0,7.6,2.6,0.32,2 +Student_02986,1,17,9070,1,1,1,1,37,19,9,9,135.0,125.2,1,0,0,1,0,0,0,19,0,6,6,6,14.333333333333334,0,0,6,6,6,13.5,0,12.7,3.7,-1.7,2 +Student_02989,1,NA,171,1,1,1,1,3,3,3,3,158.0,151.4,1,0,0,0,0,0,0,19,6,12,12,12,13.0,0,4,11,14,11,13.25,0,8.9,1.4,3.51,2 +Student_02990,1,1,9254,1,2,1,1,38,19,9,7,137.0,125.1,1,0,0,1,0,0,0,18,0,6,10,4,11.75,0,0,6,9,5,11.2,0,7.6,2.6,0.32,1 +Student_02991,1,1,9130,1,1,1,1,19,19,9,9,172.0,163.3,1,0,0,1,0,1,0,18,0,6,8,6,14.5,0,0,6,11,4,13.0,0,13.9,-0.3,0.79,2 +Student_02992,1,18,9500,1,1,1,1,37,37,3,3,123.0,118.0,1,0,0,1,0,1,0,19,0,8,8,7,11.82,0,0,8,8,7,11.82,0,10.8,1.4,1.74,2 +Student_02993,1,1,9773,1,2,1,1,3,3,3,2,144.0,140.2,1,0,0,1,0,0,0,20,0,6,0,0,0.0,0,0,6,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_02995,1,17,9773,1,1,1,1,1,38,9,8,136.0,131.5,1,0,0,1,0,0,0,18,0,6,7,6,12.571428571428571,0,0,6,8,6,11.857142857142858,0,13.9,-0.3,0.79,2 +Student_02996,1,17,9500,1,5,1,1,1,1,5,5,137.0,132.6,1,0,0,1,0,1,0,18,0,7,7,7,13.857142857142858,0,0,8,8,8,14.9,0,13.9,-0.3,0.79,2 +Student_02997,1,17,9238,1,1,1,1,19,1,0,5,128.0,122.1,1,0,0,1,0,0,0,18,0,6,9,5,11.833333333333334,0,0,6,7,5,13.8,0,13.9,-0.3,0.79,2 +Student_02999,1,1,9130,1,1,1,1,3,19,4,8,130.0,133.0,1,0,0,1,0,0,0,19,0,6,6,6,14.666666666666666,0,0,6,8,6,13.666666666666666,0,12.4,0.5,1.79,2 +Student_03000,4,39,8014,0,1,1,1,19,19,90,90,138.0,127.0,0,0,0,0,0,0,0,37,0,4,4,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_03003,1,1,9773,1,3,1,1,3,1,5,3,136.0,129.0,1,0,0,1,0,1,0,19,0,6,7,6,14.0,0,0,6,8,5,12.2,0,13.9,-0.3,0.79,0 +Student_03004,1,17,9556,1,3,1,1,19,19,9,4,126.0,119.0,1,0,0,1,0,1,0,19,0,7,8,7,12.142857142857142,0,0,8,8,8,13.375,0,16.2,0.3,-0.92,0 +Student_03005,1,17,9147,1,1,1,1,37,38,9,9,135.0,128.0,1,0,1,1,0,1,0,18,0,5,5,5,12.8,0,0,5,5,5,13.0,0,11.1,0.6,2.02,2 +Student_03006,1,1,9500,1,4,1,1,19,38,7,7,122.0,117.1,1,0,0,1,0,1,0,18,0,7,7,7,14.572857142857142,0,0,8,9,8,14.955555555555556,0,12.4,0.5,1.79,2 +Student_03007,1,1,9147,1,4,1,1,1,19,4,5,137.0,136.3,0,0,0,1,0,0,0,18,0,5,9,4,11.25,0,0,5,6,4,11.0,0,8.9,1.4,3.51,2 +Student_03008,1,17,9147,1,5,1,1,1,38,4,5,127.0,124.6,1,0,0,1,0,1,0,19,0,5,12,2,10.0,0,0,5,11,4,11.75,0,11.1,0.6,2.02,1 +Student_03009,1,1,9130,1,1,1,1,40,19,2,9,137.0,130.7,1,0,0,1,0,0,0,18,0,6,8,5,14.4,0,0,6,11,4,14.6,0,8.9,1.4,3.51,0 +Student_03013,1,16,9500,1,1,1,1,37,37,9,9,133.1,95.0,1,0,0,1,0,0,0,20,0,7,7,6,13.755,0,0,8,9,7,13.571428571428571,0,12.4,0.5,1.79,2 +Student_03014,1,17,9670,1,1,1,1,1,1,3,3,132.0,119.4,1,0,0,1,0,1,0,18,0,6,7,6,13.833333333333334,0,0,6,11,6,13.5,0,8.9,1.4,3.51,2 +Student_03016,1,1,9500,1,4,1,1,38,1,5,6,136.0,133.9,1,0,0,1,0,0,0,18,0,7,9,7,14.711111111111112,0,0,8,9,8,14.627777777777778,0,15.5,2.8,-4.06,2 +Student_03017,1,53,9085,1,1,42,1,1,19,4,8,150.0,145.2,1,0,0,1,0,0,0,20,7,11,13,11,14.615384615384617,0,4,9,11,9,13.7,0,8.9,1.4,3.51,2 +Student_03018,1,1,9500,1,1,1,1,3,3,1,5,130.0,118.8,0,0,0,1,0,0,0,18,0,7,7,7,13.677142857142858,0,0,8,9,8,14.533333333333331,0,11.1,0.6,2.02,2 +Student_03019,1,16,9085,1,2,1,1,37,37,9,9,136.0,123.4,1,0,0,1,0,1,0,19,0,5,8,5,13.166666666666666,2,0,5,5,5,12.8,0,9.4,-0.8,-3.12,2 +Student_03020,1,17,9238,1,6,1,1,3,3,1,2,138.0,123.0,1,0,0,1,0,0,0,19,0,6,11,5,10.8,0,0,6,12,5,11.333333333333334,0,15.5,2.8,-4.06,2 +Student_03021,1,17,9130,1,1,1,1,19,9,5,3,131.0,118.4,0,0,0,1,0,0,0,19,0,5,8,3,12.0,0,0,5,7,5,12.833333333333334,0,7.6,2.6,0.32,2 +Student_03022,1,1,9500,1,1,1,1,3,1,2,3,147.0,131.6,0,0,0,1,0,0,0,18,0,7,8,6,NA,0,0,8,8,8,14.71875,0,11.1,0.6,2.02,2 +Student_03023,1,17,9853,1,1,1,1,38,19,4,10,140.0,122.3,1,0,0,1,0,0,0,19,0,6,9,4,13.0,0,0,6,9,4,12.25,0,12.7,3.7,-1.7,0 +Student_03024,1,1,171,1,2,1,1,38,19,9,9,152.0,151.7,1,0,0,1,0,1,0,24,0,0,0,0,0.0,0,0,0,0,0,0.0,0,NA,0.6,2.02,2 +Student_03025,1,1,171,1,1,1,1,19,37,9,7,169.0,176.0,1,0,0,NA,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,2 +Student_03026,1,1,9500,1,6,1,1,1,1,4,9,149.0,133.0,1,0,0,1,0,1,0,18,0,8,8,7,14.0,0,0,8,8,7,14.0,0,12.7,3.7,-1.7,2 +Student_03027,1,1,9773,1,4,1,1,3,19,2,3,137.0,139.8,1,1,0,1,0,0,0,18,0,6,10,6,12.571428571428571,0,0,6,11,6,12.571428571428571,0,10.8,1.4,1.74,1 +Student_03029,1,39,8014,0,1,1,1,37,37,9,6,130.0,134.0,0,0,0,1,0,1,0,35,2,8,8,8,13.625,0,1,7,7,7,14.0,0,8.9,1.4,3.51,2 +Student_03030,1,17,9147,1,6,1,1,37,37,9,9,145.0,132.0,1,0,0,1,0,0,0,19,0,5,7,4,12.5,0,0,5,8,4,10.0,1,7.6,2.6,0.32,2 +Student_03031,1,7,9853,1,1,3,1,37,37,9,9,130.0,130.0,0,0,0,1,0,0,0,28,14,15,25,14,12.428571428571429,1,8,14,22,11,11.909090909090908,0,7.6,2.6,0.32,0 +Student_03032,1,43,9500,1,1,1,1,38,3,5,2,157.0,141.4,0,0,0,1,0,0,0,21,3,7,8,7,13.3875,0,2,8,8,8,15.9,0,13.9,-0.3,0.79,2 +Student_03033,1,NA,9500,1,2,1,1,19,1,5,5,135.0,128.9,1,0,0,1,0,1,0,19,0,7,8,6,12.648333333333332,0,0,8,9,8,12.205555555555556,0,11.1,0.6,2.02,2 +Student_03034,1,5,9238,1,2,1,1,40,38,2,9,123.0,118.1,1,0,0,1,0,0,0,19,0,6,6,6,14.0,0,0,6,6,6,13.333333333333334,0,8.9,1.4,3.51,2 +Student_03035,1,1,9085,1,1,1,1,3,4,2,2,139.0,130.6,0,0,0,1,0,0,0,18,0,5,12,5,12.8,2,0,5,10,5,11.857142857142858,1,9.4,-0.8,-3.12,2 +Student_03036,1,1,9254,1,1,1,1,12,1,4,4,136.0,122.0,1,0,0,1,0,0,0,18,0,6,8,6,11.333333333333334,0,0,6,11,6,NA,0,7.6,2.6,0.32,2 +Student_03037,1,1,9500,1,2,1,1,3,3,2,2,135.0,123.0,1,0,0,0,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03038,1,1,9670,1,1,1,1,1,1,9,10,126.0,126.7,1,0,0,1,0,1,0,20,0,6,6,6,14.166666666666666,0,0,6,9,6,13.0,0,8.9,1.4,3.51,2 +Student_03039,1,1,9773,1,1,1,1,38,19,9,9,122.0,126.6,1,0,0,1,0,0,0,18,0,6,6,6,12.833333333333334,0,0,6,6,6,13.833333333333334,0,8.9,1.4,3.51,2 +Student_03040,1,1,9853,1,1,1,1,38,38,9,9,125.0,125.4,0,0,1,0,0,0,0,19,0,7,11,4,12.0,0,0,7,9,6,11.833333333333334,0,16.2,0.3,-0.92,0 +Student_03041,1,1,9773,1,3,1,1,1,19,9,9,134.0,136.1,1,0,0,1,0,1,0,20,0,6,6,6,13.0,0,0,6,7,6,13.142857142857142,0,12.4,0.5,1.79,0 +Student_03042,1,17,9500,1,5,1,1,19,1,9,4,130.0,128.8,1,0,0,1,0,0,0,18,0,7,8,6,13.39,0,0,8,10,7,12.757142857142856,0,11.1,0.6,2.02,1 +Student_03043,1,17,9670,1,4,1,1,1,37,7,7,110.0,111.1,1,0,0,0,0,0,0,18,0,6,6,6,12.333333333333334,0,0,6,8,5,13.6,0,8.9,1.4,3.51,2 +Student_03044,1,1,9070,1,1,1,1,3,3,3,3,131.0,135.9,0,0,0,1,0,1,0,21,1,6,8,6,12.571428571428571,1,0,6,8,6,11.625,0,13.9,-0.3,0.79,2 +Student_03045,1,5,9254,1,5,1,1,1,37,9,7,122.0,119.6,1,0,0,1,0,1,0,19,0,6,6,6,12.333333333333334,0,0,6,6,6,12.833333333333334,0,12.4,0.5,1.79,2 +Student_03047,1,1,9085,1,1,1,1,1,1,9,7,146.0,126.0,0,0,0,1,0,0,0,19,0,5,7,3,12.333333333333334,0,0,5,7,4,10.25,0,7.6,2.6,0.32,1 +Student_03048,1,1,9773,1,4,1,1,37,37,0,90,137.0,134.2,1,0,0,1,0,0,0,18,0,6,6,6,13.166666666666666,0,0,6,8,5,14.2,0,10.8,1.4,1.74,0 +Student_03049,1,1,9147,1,1,1,1,1,19,3,3,130.0,123.0,0,0,0,1,0,1,0,18,0,5,7,5,13.333333333333334,0,0,5,6,5,13.6,0,12.7,3.7,-1.7,2 +Student_03051,2,39,9556,1,1,1,1,37,37,9,6,160.0,120.0,0,0,0,1,0,0,0,31,0,7,21,5,10.9,3,0,8,21,3,11.7,1,12.7,3.7,-1.7,0 +Student_03052,1,42,9147,1,1,1,1,3,38,2,5,139.0,112.3,1,0,0,1,0,0,0,19,0,5,8,2,11.5,0,0,5,10,3,10.857142857142858,0,10.8,1.4,1.74,1 +Student_03053,1,16,9085,1,1,1,1,37,37,9,9,138.0,123.0,1,0,0,1,0,1,0,20,0,6,7,6,15.857142857142858,0,0,6,6,6,16.0,0,13.9,-0.3,0.79,2 +Student_03054,1,17,9085,1,1,1,1,38,19,0,90,137.0,122.3,0,0,0,1,0,1,0,19,0,5,5,5,12.6,0,0,5,9,3,13.0,0,7.6,2.6,0.32,0 +Student_03055,1,17,9238,1,1,1,1,38,38,9,6,127.0,122.8,0,0,0,1,0,1,0,19,0,6,8,6,14.0,0,0,6,7,6,14.571428571428571,0,16.2,0.3,-0.92,2 +Student_03056,5,7,9130,1,1,3,1,19,38,9,6,160.0,160.0,0,0,0,0,0,0,0,27,1,5,8,3,14.666666666666666,2,0,5,7,2,13.0,2,10.8,1.4,1.74,0 +Student_03057,1,17,9773,1,2,1,1,19,19,9,6,132.0,120.1,1,0,0,1,0,1,0,18,0,6,6,6,13.666666666666666,0,0,6,6,6,14.0,0,8.9,1.4,3.51,2 +Student_03058,1,1,8014,0,1,1,1,34,34,0,0,126.0,142.4,0,0,0,1,0,0,0,32,0,6,0,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_03059,1,1,9500,1,4,1,1,38,19,8,7,133.0,127.3,1,0,0,1,0,0,0,18,0,8,8,7,12.628571428571428,0,0,8,8,7,12.628571428571428,0,12.7,3.7,-1.7,2 +Student_03060,1,1,9500,1,3,NA,1,19,37,9,9,140.0,125.5,1,0,0,1,0,1,0,19,0,8,8,7,14.232857142857142,0,0,8,8,7,14.232857142857142,0,10.8,1.4,1.74,2 +Student_03061,1,1,9773,1,2,1,1,19,19,5,6,130.0,137.4,0,0,0,1,0,0,0,19,0,6,6,6,15.0,0,0,6,7,6,14.0,0,15.5,2.8,-4.06,1 +Student_03062,1,17,9254,1,2,1,1,12,37,9,9,129.0,122.0,1,0,0,1,0,0,0,18,0,6,15,2,10.0,0,0,6,12,0,0.0,0,10.8,1.4,1.74,0 +Student_03063,1,17,9670,1,3,1,1,19,1,4,4,110.0,107.5,1,0,0,1,0,1,0,18,0,6,11,4,12.25,0,0,6,10,4,11.0,0,12.7,3.7,-1.7,0 +Student_03064,1,39,NA,1,1,19,1,19,19,171,163,133.1,104.0,0,0,1,0,0,1,0,24,0,6,6,6,13.5,0,0,6,6,6,13.0,0,11.1,0.6,2.02,2 +Student_03067,1,44,9070,1,1,39,1,1,1,4,10,130.0,130.0,1,0,0,1,0,0,0,19,2,7,11,6,12.0,0,5,9,9,8,12.75,0,16.2,0.3,-0.92,2 +Student_03068,1,1,9500,1,3,1,6,2,3,5,2,140.0,124.3,1,0,0,1,0,0,1,19,0,7,9,5,12.32,0,0,7,9,5,11.9,0,12.4,0.5,1.79,1 +Student_03071,1,1,9670,1,3,1,1,1,19,5,5,121.0,111.9,1,0,0,1,1,1,0,20,0,6,7,6,11.333333333333334,0,0,6,10,4,10.571428571428571,0,10.8,1.4,1.74,1 +Student_03072,1,39,8014,0,1,38,1,1,1,4,4,133.1,107.5,0,0,1,0,1,0,0,29,0,6,6,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_03074,1,39,9119,1,1,1,1,19,37,9,4,130.0,149.0,1,0,0,1,1,0,0,33,0,5,10,4,12.0,0,0,5,8,3,13.666666666666666,1,7.6,2.6,0.32,1 +Student_03075,2,2,9147,1,1,2,1,37,37,9,9,120.0,120.0,0,0,0,0,1,0,0,57,12,15,17,12,11.75,0,9,14,16,9,NA,0,9.4,-0.8,-3.12,0 +Student_03076,1,1,9670,1,1,1,1,4,2,123,112,132.0,143.6,1,0,0,1,1,0,0,20,0,6,8,5,12.8,0,0,6,10,5,11.6,0,13.9,-0.3,0.79,1 +Student_03077,1,39,9670,1,1,1,1,1,1,4,4,100.0,120.0,0,0,0,1,1,0,0,26,0,5,7,3,11.333333333333334,0,0,5,7,3,13.666666666666666,0,9.4,-0.8,-3.12,0 +Student_03078,1,43,9119,1,1,1,1,1,1,9,2,130.0,128.0,0,0,1,0,1,0,0,27,0,5,5,0,0.0,0,0,5,7,0,0.0,0,13.9,-0.3,0.79,1 +Student_03079,1,1,9670,1,1,1,1,1,37,4,9,129.0,118.2,0,0,0,1,1,0,0,19,0,5,5,5,10.8,0,0,5,5,4,12.25,0,9.4,-0.8,-3.12,2 +Student_03080,1,44,9085,1,1,39,1,12,38,4,8,160.0,160.0,1,0,0,1,1,0,0,23,1,6,10,5,12.5,0,1,6,8,2,13.5,0,12.4,0.5,1.79,0 +Student_03082,1,1,9500,1,6,1,1,19,37,3,5,122.0,116.6,1,0,1,1,1,1,0,20,0,7,7,7,13.314285714285717,0,0,8,8,8,12.575,0,12.4,0.5,1.79,2 +Student_03083,1,18,9070,1,1,1,1,38,38,7,5,143.0,141.6,0,0,0,1,0,1,0,19,6,12,12,11,13.090909090909092,0,5,11,12,11,12.083333333333334,0,10.8,1.4,1.74,2 +Student_03084,1,1,9130,1,1,1,1,3,19,2,9,110.0,105.5,1,0,1,0,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03085,1,1,9070,1,1,1,1,37,19,9,3,124.0,116.3,1,0,0,1,0,0,0,20,0,6,8,5,12.2,0,0,6,6,6,11.5,0,16.2,0.3,-0.92,2 +Student_03086,2,7,9147,1,1,3,1,19,1,9,9,110.0,110.0,0,0,0,1,0,0,0,33,5,8,10,6,12.833333333333334,0,2,5,8,4,12.0,0,11.1,0.6,2.02,1 +Student_03087,1,43,9991,0,1,1,1,37,37,9,9,130.0,119.5,1,0,0,1,0,0,0,22,9,15,17,15,11.2,0,9,14,15,14,12.428571428571429,0,7.6,2.6,0.32,2 +Student_03088,1,1,9147,1,6,1,1,19,12,4,4,139.0,125.0,1,0,0,1,0,0,0,18,0,5,8,3,12.333333333333334,0,0,5,7,4,12.0,0,7.6,2.6,0.32,2 +Student_03089,5,39,9500,1,1,3,1,37,38,9,9,140.0,160.0,0,0,0,1,0,0,0,27,0,8,8,7,15.94285714285714,0,0,8,8,7,15.94285714285714,0,12.7,3.7,-1.7,2 +Student_03090,1,39,9991,0,1,1,1,37,37,9,7,150.0,150.0,0,0,0,1,0,0,0,27,0,5,0,0,0.0,0,0,5,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_03091,1,1,9238,1,1,1,1,37,37,9,9,123.0,115.0,1,0,0,1,0,0,0,19,0,6,10,4,10.25,0,0,6,8,6,10.714285714285714,0,11.1,0.6,2.02,2 +Student_03093,1,1,8014,0,1,1,1,38,19,6,10,100.0,112.8,0,0,0,1,0,1,0,23,0,6,6,6,14.166666666666666,0,0,6,6,6,12.5,0,12.7,3.7,-1.7,2 +Student_03095,1,17,9254,1,2,1,1,19,19,7,7,130.0,121.6,1,0,0,1,0,1,0,18,0,6,9,1,10.0,1,0,6,6,0,0.0,0,12.7,3.7,-1.7,0 +Student_03096,1,1,9238,1,4,1,1,19,38,9,9,118.0,110.0,0,0,0,1,0,1,0,18,0,6,7,6,12.285714285714286,0,0,6,8,6,11.428571428571429,0,12.4,0.5,1.79,2 +Student_03097,1,39,8014,0,1,1,1,38,38,9,9,120.0,148.5,0,0,0,1,0,1,0,31,0,6,6,6,14.0,0,0,6,6,6,12.333333333333334,0,10.8,1.4,1.74,2 +Student_03099,1,1,9238,1,1,1,1,37,37,9,9,138.0,135.9,1,0,0,1,0,0,0,19,0,6,11,5,11.6,0,0,6,11,6,11.666666666666666,0,7.6,2.6,0.32,1 +Student_03100,1,17,8014,0,1,1,1,19,37,4,7,127.0,115.8,0,0,0,1,0,0,0,24,0,6,12,1,12.0,0,0,6,12,0,0.0,0,10.8,1.4,1.74,0 +Student_03101,NA,1,9500,1,1,1,1,38,19,3,10,134.0,121.2,0,0,0,1,0,0,0,19,0,7,10,7,13.47,0,0,8,8,8,13.32625,0,15.5,2.8,-4.06,2 +Student_03102,1,17,9147,1,4,1,1,1,1,4,5,133.0,136.2,1,0,0,1,0,0,0,19,0,5,6,5,12.4,0,0,5,5,5,12.8,0,7.6,2.6,0.32,2 +Student_03104,1,1,171,1,1,1,41,37,37,9,9,180.0,152.7,1,0,1,0,1,0,1,27,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,0 +Student_03105,1,17,9238,1,4,1,1,NA,19,4,7,129.0,123.1,1,0,0,1,0,0,0,19,0,6,7,6,12.0,0,0,6,7,6,12.428571428571429,0,NA,0.6,2.02,2 +Student_03106,2,39,9085,1,1,1,1,19,19,1,4,NA,130.0,0,0,0,1,0,0,0,29,0,5,8,5,NA,2,0,5,6,5,15.4,0,9.4,-0.8,-3.12,0 +Student_03107,1,1,9500,1,6,1,1,1,38,4,5,141.0,125.0,1,0,0,1,0,1,0,18,0,8,8,8,12.32,0,0,8,8,8,12.32,0,9.4,-0.8,-3.12,2 +Student_03108,1,1,9500,1,1,1,1,1,19,9,10,118.0,113.1,1,0,0,1,0,0,0,19,0,7,7,7,13.79857142857143,0,0,8,8,8,14.75625,0,11.1,0.6,2.02,2 +Student_03109,1,NA,9773,1,5,1,1,38,1,4,5,127.0,121.1,1,0,0,1,0,0,0,18,0,6,6,6,13.166666666666666,0,0,6,6,6,12.5,0,15.5,2.8,-4.06,1 +Student_03110,1,1,9147,1,1,1,1,1,38,3,9,177.0,162.3,0,0,0,1,0,1,0,18,0,5,6,5,16.333333333333332,0,0,5,5,5,15.4,0,15.5,2.8,-4.06,2 +Student_03111,1,42,171,1,1,1,1,1,1,1,4,132.0,132.0,1,0,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03112,1,17,9500,1,4,1,1,4,4,4,4,133.0,130.7,1,0,0,1,0,0,0,19,0,7,7,7,14.757142857142856,0,0,8,9,8,15.366666666666667,0,12.4,0.5,1.79,2 +Student_03113,NA,17,9254,1,4,1,1,1,1,4,4,124.0,122.3,1,0,0,1,0,0,0,19,0,6,7,6,11.666666666666666,0,0,6,6,6,12.333333333333334,0,13.9,-0.3,0.79,0 +Student_03114,1,NA,9670,1,1,1,1,3,38,2,9,143.0,144.1,1,0,0,1,0,0,0,19,0,6,7,5,12.6,0,0,6,10,5,12.375,0,10.8,1.4,1.74,1 +Student_03115,1,1,9773,1,1,1,1,1,19,9,7,128.0,118.2,0,0,0,1,0,0,0,19,0,6,6,6,11.666666666666666,0,0,6,6,6,11.5,0,12.7,3.7,-1.7,2 +Student_03116,1,1,9238,1,1,1,1,19,38,5,8,138.0,133.5,0,0,0,1,0,1,0,19,0,6,6,6,15.0,0,0,6,6,6,13.333333333333334,0,8.9,1.4,3.51,2 +Student_03117,1,1,9500,1,5,1,1,37,37,7,9,144.0,126.8,1,0,1,0,0,0,0,NA,0,7,0,0,0.0,0,0,8,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03119,1,17,9254,1,1,1,1,19,19,3,10,111.0,117.7,0,0,0,1,0,0,0,20,0,6,8,5,10.8,0,0,6,9,4,11.5,0,9.4,-0.8,-3.12,2 +Student_03120,1,1,9085,1,1,1,1,38,37,1,1,133.1,115.0,1,0,0,1,0,0,0,21,0,5,8,3,11.333333333333334,1,0,5,8,3,13.333333333333334,0,12.7,3.7,-1.7,1 +Student_03121,2,1,9991,0,1,2,1,37,37,6,3,120.0,129.2,0,0,0,1,0,0,0,31,4,10,16,5,11.4,0,4,10,10,6,12.833333333333334,0,9.4,-0.8,-3.12,0 +Student_03122,1,1,9556,1,1,1,1,37,38,7,9,135.0,125.8,0,0,0,1,0,1,0,20,0,7,14,7,10.642857142857142,0,0,8,8,8,11.55,0,12.7,3.7,-1.7,2 +Student_03123,1,17,9670,1,5,1,1,19,30,7,7,125.0,118.4,1,0,0,1,0,1,0,19,0,5,8,3,10.5,0,0,5,6,4,11.75,1,7.6,2.6,0.32,1 +Student_03124,1,1,9500,1,1,1,1,38,38,9,9,147.0,142.0,1,0,0,1,0,0,0,18,0,7,7,6,14.65,0,0,7,7,6,14.65,0,7.6,2.6,0.32,2 +Student_03125,1,17,9500,1,3,1,1,19,37,7,7,137.0,126.7,1,0,0,1,0,1,0,19,0,7,7,7,13.714285714285714,0,0,8,11,8,14.863636363636363,0,16.2,0.3,-0.92,2 +Student_03126,1,43,9238,1,1,1,1,34,34,0,0,117.0,109.3,0,0,0,1,0,0,0,30,9,16,19,15,12.266666666666667,0,11,13,14,13,12.071428571428571,0,9.4,-0.8,-3.12,2 +Student_03127,1,17,NA,1,1,1,1,37,19,9,8,126.0,116.9,1,0,0,1,0,0,0,21,0,6,11,6,10.375,0,0,6,12,3,11.666666666666666,0,12.7,3.7,-1.7,1 +Student_03128,1,18,9147,1,1,1,1,19,19,9,5,128.0,121.7,1,0,0,1,0,0,0,19,0,5,8,5,11.0,0,0,5,6,5,15.4,0,12.4,0.5,1.79,2 +Student_03129,1,1,9147,1,6,1,1,1,37,4,9,115.0,117.1,1,0,1,1,0,0,0,22,0,5,5,5,13.8,0,0,5,5,5,13.0,0,7.6,2.6,0.32,2 +Student_03130,1,1,9773,1,1,1,1,1,38,4,9,121.0,114.4,0,0,0,1,0,1,0,18,0,6,6,6,12.666666666666666,0,0,6,6,6,12.833333333333334,0,11.1,0.6,2.02,2 +Student_03131,1,17,9238,1,1,1,1,3,1,3,4,134.0,133.0,1,0,0,1,0,0,0,18,0,6,8,6,11.75,0,0,6,10,5,12.0,0,12.7,3.7,-1.7,2 +Student_03132,1,1,9500,1,3,1,1,38,38,9,8,126.0,118.8,1,0,0,1,0,1,0,19,0,8,8,7,12.785714285714286,0,0,8,8,7,12.785714285714286,0,12.7,3.7,-1.7,2 +Student_03133,1,1,9130,1,1,1,1,3,1,2,4,151.0,151.0,1,0,0,1,0,0,0,18,0,6,11,6,14.444444444444445,0,0,6,6,6,13.333333333333334,0,16.2,0.3,-0.92,2 +Student_03134,1,1,9500,1,6,1,1,1,1,4,4,122.0,119.6,1,0,0,1,NA,0,0,21,0,7,8,6,13.25,0,0,8,8,8,13.8375,0,13.9,-0.3,0.79,1 +Student_03135,1,17,9500,1,1,1,1,2,38,2,10,141.0,135.4,1,0,0,1,0,0,0,18,0,7,9,7,12.50625,0,0,8,15,5,13.2,0,13.9,-0.3,0.79,1 +Student_03137,1,1,9085,1,1,1,1,38,37,9,7,133.0,120.1,1,0,0,1,0,0,0,18,0,5,8,4,12.75,1,0,5,10,4,11.75,0,12.7,3.7,-1.7,2 +Student_03138,1,39,9085,1,1,3,1,2,3,4,7,150.0,173.3,1,0,0,1,0,0,0,NA,1,6,7,6,16.857142857142858,0,1,6,6,6,16.5,0,13.9,-0.3,0.79,2 +Student_03139,1,1,9773,1,1,1,1,19,19,4,3,136.0,126.2,0,0,0,1,0,0,0,19,0,6,6,6,13.166666666666666,0,0,6,6,6,15.0,0,16.2,0.3,-0.92,2 +Student_03140,1,1,9853,1,1,1,1,19,38,2,7,129.0,126.9,1,0,0,1,0,1,0,19,0,6,9,5,12.2,0,0,6,10,4,11.5,0,7.6,2.6,0.32,1 +Student_03141,1,39,9085,1,1,1,1,19,1,9,10,128.0,157.4,1,0,0,1,0,0,0,26,0,6,7,6,16.5,0,0,6,8,6,14.285714285714286,0,8.9,1.4,3.51,2 +Student_03142,1,17,9147,1,2,1,1,1,19,4,5,131.0,120.2,1,0,0,1,0,0,0,21,0,5,10,4,11.75,0,0,5,6,5,11.6,0,12.4,0.5,1.79,2 +Student_03143,1,1,9147,1,1,1,1,38,38,2,9,130.0,124.8,0,0,0,1,0,0,0,19,0,5,14,1,11.0,0,0,5,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_03144,1,17,9500,1,1,1,1,37,37,9,9,150.0,130.3,0,0,0,1,0,1,0,19,0,8,8,7,15.114285714285714,0,0,8,8,7,15.114285714285714,0,12.7,3.7,-1.7,2 +Student_03145,1,1,9238,1,1,1,1,37,38,9,8,165.0,152.4,1,0,0,1,0,1,0,18,0,6,8,6,15.5,0,0,6,7,6,14.285714285714286,0,16.2,0.3,-0.92,2 +Student_03147,1,1,9238,1,1,1,1,3,1,5,5,126.0,125.7,0,0,0,1,0,1,0,18,0,6,6,6,11.333333333333334,0,0,6,8,6,11.333333333333334,0,15.5,2.8,-4.06,2 +Student_03148,1,1,9500,1,5,1,1,1,1,3,4,101.0,102.4,0,0,0,1,0,0,0,20,0,7,9,5,12.04,0,0,7,9,6,11.77142857142857,0,12.4,0.5,1.79,1 +Student_03149,1,17,9147,1,3,1,1,38,19,7,7,125.0,125.7,0,0,0,1,0,0,0,20,0,5,7,5,11.166666666666666,0,0,5,9,4,10.75,0,15.5,2.8,-4.06,1 +Student_03150,4,39,9670,1,1,1,1,37,37,4,10,100.0,120.0,0,0,1,1,0,1,0,39,0,5,6,5,10.6,0,0,5,7,4,10.75,0,9.4,-0.8,-3.12,2 +Student_03151,1,1,9130,1,1,1,1,1,1,9,9,117.0,109.3,1,0,0,1,0,0,0,20,0,5,10,4,12.5,0,0,5,12,2,13.0,0,12.7,3.7,-1.7,1 +Student_03152,1,1,171,1,1,1,1,3,1,4,4,159.0,162.2,1,0,1,0,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,0 +Student_03153,1,17,NA,1,1,1,1,2,1,123,135,177.0,155.7,0,0,1,1,0,1,0,18,0,6,6,6,15.666666666666666,0,0,6,6,6,13.833333333333334,0,8.9,1.4,3.51,2 +Student_03154,1,1,171,1,1,1,1,3,3,2,2,156.0,147.7,1,0,0,1,0,0,0,21,6,12,12,12,15.333333333333334,0,4,11,15,11,15.0,0,8.9,1.4,3.51,2 +Student_03155,1,1,9500,1,5,1,1,1,1,3,8,125.0,115.6,1,0,0,1,0,0,0,18,0,7,9,6,12.183333333333332,0,0,7,9,6,11.783333333333331,0,16.2,0.3,-0.92,1 +Student_03156,1,1,9147,1,2,1,1,37,37,9,9,130.0,117.8,0,0,0,1,NA,0,0,18,0,5,8,2,10.0,0,0,5,9,3,11.333333333333334,0,7.6,2.6,0.32,1 +Student_03158,1,1,9147,1,1,1,1,19,19,5,5,127.0,129.8,1,0,0,1,0,0,0,22,0,5,8,3,10.333333333333334,0,0,5,11,2,10.0,0,7.6,2.6,0.32,0 +Student_03159,1,17,9254,1,1,1,1,1,1,4,4,121.0,123.1,1,0,0,1,1,0,0,21,0,6,11,6,11.166666666666666,0,0,6,14,3,14.666666666666666,0,7.6,2.6,0.32,1 +Student_03161,1,1,171,1,2,1,1,38,19,9,9,125.0,117.3,1,0,0,1,1,1,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,2 +Student_03162,1,1,9254,1,1,1,41,1,1,9,9,138.0,126.5,1,0,0,1,0,1,1,20,0,6,7,6,12.857142857142858,0,0,6,8,5,11.8,0,8.9,1.4,3.51,2 +Student_03164,1,1,9238,1,1,1,1,1,38,5,7,142.0,127.7,0,0,0,1,0,1,0,20,0,6,7,6,15.0,0,0,6,6,6,16.333333333333332,0,13.9,-0.3,0.79,2 +Student_03165,1,1,9085,1,1,1,1,19,37,9,9,129.0,117.5,1,0,0,1,0,0,0,19,0,5,9,5,13.6,1,0,5,5,5,12.4,0,12.7,3.7,-1.7,2 +Student_03166,1,1,9085,1,1,1,1,1,1,2,7,134.0,128.4,1,0,0,1,0,1,0,18,0,5,12,5,12.857142857142858,2,0,5,8,4,13.25,0,9.4,-0.8,-3.12,2 +Student_03169,1,1,9254,1,1,1,1,1,1,4,2,129.0,126.2,0,0,1,0,0,1,0,21,0,6,7,6,13.428571428571429,0,0,6,8,6,11.333333333333334,0,8.9,1.4,3.51,0 +Student_03170,1,1,9500,1,3,1,1,1,37,8,7,134.0,120.5,1,0,0,1,1,1,0,18,0,7,12,7,11.716666666666663,0,0,8,13,4,10.868,0,15.5,2.8,-4.06,2 +Student_03171,1,17,9147,1,1,1,1,1,37,4,8,127.0,121.1,1,0,0,1,1,1,0,20,0,5,11,4,12.0,0,0,5,5,5,12.8,0,11.1,0.6,2.02,2 +Student_03172,1,18,9853,1,2,1,1,1,3,9,2,123.0,123.7,1,0,1,0,0,0,0,20,0,6,11,5,13.2,0,0,6,8,4,10.75,0,10.8,1.4,1.74,0 +Student_03173,1,17,9254,1,3,1,1,12,38,5,7,127.0,116.9,1,0,1,1,0,0,0,18,0,6,7,5,12.2,0,0,6,10,4,12.25,0,12.4,0.5,1.79,0 +Student_03174,1,39,9556,1,1,1,1,38,19,9,6,133.1,100.0,1,0,0,1,0,1,0,25,0,7,11,5,12.58,0,0,7,9,6,12.157142857142857,0,8.9,1.4,3.51,2 +Student_03177,1,1,9500,1,4,1,1,19,19,9,5,133.0,120.1,1,0,0,1,0,1,0,19,0,7,9,6,12.428571428571429,0,0,8,8,8,14.0,0,13.9,-0.3,0.79,2 +Student_03178,1,1,9670,1,1,1,1,38,38,9,9,133.0,128.1,1,0,0,1,1,1,0,18,0,6,6,6,13.0,0,0,6,6,6,13.0,0,13.9,-0.3,0.79,0 +Student_03180,1,43,9500,1,1,1,1,19,38,9,7,140.0,125.7,1,0,0,1,1,1,0,19,0,7,8,5,11.2,0,0,7,8,5,11.2,0,7.6,2.6,0.32,1 +Student_03181,1,17,9070,1,1,1,1,3,3,3,3,157.0,146.2,0,0,0,1,1,0,0,18,0,6,6,6,16.0,0,0,6,6,6,13.666666666666666,0,12.4,0.5,1.79,2 +Student_03182,1,39,9130,1,1,19,1,19,3,9,2,133.1,140.0,1,0,1,1,1,0,0,24,0,6,13,5,13.142857142857142,0,0,6,15,3,12.666666666666666,0,16.2,0.3,-0.92,0 +Student_03183,1,43,8014,0,1,1,6,34,34,0,0,145.0,134.5,1,0,0,1,1,0,1,25,8,14,23,11,11.6875,0,6,10,20,8,11.142857142857142,0,9.4,-0.8,-3.12,2 +Student_03184,1,39,9119,1,1,1,1,37,3,9,3,130.0,137.0,1,0,0,1,1,0,0,28,0,5,11,4,10.5,0,0,5,12,4,11.0,4,7.6,2.6,0.32,1 +Student_03185,1,1,9085,1,1,1,1,1,38,5,9,111.0,107.5,0,0,0,1,1,1,0,19,0,6,9,6,13.833333333333334,0,0,6,12,5,13.666666666666666,0,11.1,0.6,2.02,2 +Student_03187,1,39,9130,1,1,10,1,12,36,90,90,133.1,128.2,0,0,0,0,1,1,0,30,0,5,13,0,0.0,3,0,5,5,0,0.0,5,9.4,-0.8,-3.12,0 +Student_03188,1,1,9500,1,1,1,1,19,19,4,5,135.0,126.8,1,0,0,1,1,0,0,19,0,7,9,0,0.0,0,0,7,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_03189,1,17,9147,1,1,1,1,19,38,4,4,145.0,132.1,1,0,0,1,1,0,0,21,0,5,10,1,10.0,0,0,5,5,0,0.0,0,11.1,0.6,2.02,0 +Student_03190,1,1,171,1,1,1,1,37,37,3,5,118.0,110.0,0,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_03191,1,39,9003,1,1,1,1,19,19,9,5,130.0,100.0,0,0,0,0,1,0,0,NA,0,6,9,0,0.0,0,0,6,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_03192,1,1,9670,1,1,1,1,19,37,9,9,115.0,114.3,0,0,0,1,1,0,0,18,0,6,7,4,12.6,0,0,6,6,4,13.0,0,12.4,0.5,1.79,0 +Student_03193,1,1,9147,1,2,1,1,1,38,4,5,122.0,116.4,0,0,0,1,1,0,0,21,0,5,10,3,11.25,0,0,5,9,3,11.0,0,15.5,2.8,-4.06,1 +Student_03194,1,42,9070,1,1,1,1,3,2,3,1,120.0,116.9,0,0,0,1,1,0,0,20,6,7,13,7,12.375,0,4,7,8,4,11.25,0,13.9,-0.3,0.79,0 +Student_03195,1,51,9991,0,1,1,1,38,3,5,3,120.0,128.2,0,0,1,1,1,0,0,NA,3,10,15,7,10.714285714285714,0,3,10,11,9,12.555555555555555,0,12.4,0.5,1.79,1 +Student_03196,1,17,9773,1,2,1,1,1,1,2,5,120.0,127.0,1,0,0,0,1,0,0,18,0,6,6,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_03197,1,42,9003,1,1,1,1,1,3,4,2,140.0,140.0,1,0,0,1,1,0,0,23,0,6,14,5,12.0,0,0,6,12,5,12.142857142857142,0,15.5,2.8,-4.06,1 +Student_03199,1,7,9254,1,1,3,1,NA,19,3,3,110.0,110.0,0,0,0,1,1,0,0,35,0,6,7,0,0.0,0,0,6,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_03200,1,1,9500,1,1,1,1,1,1,9,9,148.0,127.0,1,0,0,1,1,0,0,20,0,8,8,7,12.84142857142857,0,0,8,8,7,12.84142857142857,0,10.8,1.4,1.74,2 +Student_03201,2,39,9238,1,1,42,1,19,38,8,8,170.0,159.5,0,0,0,1,1,0,0,33,0,6,6,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_03202,1,1,9773,1,1,1,1,1,3,4,1,146.0,135.2,1,0,0,1,1,0,0,18,0,6,7,6,14.166666666666666,0,0,6,6,6,12.833333333333334,0,9.4,-0.8,-3.12,2 +Student_03204,1,17,9773,1,1,1,1,3,3,2,3,125.0,118.0,1,0,0,1,1,0,0,19,0,6,12,4,10.8,0,0,6,14,3,11.0,0,13.9,-0.3,0.79,0 +Student_03207,1,1,9147,1,1,1,1,5,1,1,5,146.0,144.6,0,0,0,1,1,0,0,18,0,5,5,5,13.0,0,0,5,6,5,13.333333333333334,0,16.2,0.3,-0.92,2 +Student_03208,1,1,9773,1,1,1,1,2,3,3,3,109.0,111.8,1,0,1,1,1,0,0,25,0,6,8,6,11.571428571428571,0,0,6,9,6,11.571428571428571,0,15.5,2.8,-4.06,0 +Student_03211,1,7,9003,1,1,3,1,3,3,6,2,130.0,130.0,1,0,0,1,1,0,0,29,1,6,10,6,17.11111111111111,0,2,6,9,6,15.571428571428571,0,13.9,-0.3,0.79,2 +Student_03212,1,1,171,1,1,1,1,2,2,3,2,124.0,118.4,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,1 +Student_03213,1,1,9254,1,1,1,1,3,2,4,5,115.0,112.6,0,0,0,1,1,1,0,20,0,6,9,6,12.571428571428571,0,0,6,6,6,12.166666666666666,0,8.9,1.4,3.51,2 +Student_03215,1,1,9070,1,4,1,1,3,3,2,2,170.0,165.8,1,0,0,1,1,0,0,18,0,6,7,6,14.5,0,0,6,6,6,15.166666666666666,0,9.4,-0.8,-3.12,2 +Student_03216,1,1,9254,1,6,1,1,3,1,2,2,102.0,101.7,1,0,0,1,1,1,0,21,0,6,6,6,13.5,0,0,6,6,6,12.333333333333334,0,12.4,0.5,1.79,2 +Student_03217,1,17,9254,1,2,1,1,3,3,2,2,140.0,124.3,0,0,0,0,1,0,0,18,0,6,9,5,11.2,0,0,6,14,2,10.0,0,9.4,-0.8,-3.12,0 +Student_03219,1,43,8014,0,1,1,1,37,37,9,9,148.0,134.7,0,0,0,1,0,0,0,23,9,13,15,9,11.0,0,4,11,12,7,11.571428571428571,0,15.5,2.8,-4.06,1 +Student_03221,1,17,9670,1,3,1,1,37,37,8,8,147.0,128.8,0,0,1,1,0,0,0,19,0,5,5,1,10.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03223,1,1,9670,1,1,1,1,19,38,9,7,157.0,146.2,1,0,0,1,0,1,0,20,0,6,8,6,15.25,0,0,6,7,6,14.714285714285714,0,11.1,0.6,2.02,2 +Student_03224,1,17,9991,0,1,1,1,38,3,9,3,120.0,116.9,1,0,1,0,0,0,0,26,0,5,5,0,0.0,0,0,5,6,0,0.0,0,10.8,1.4,1.74,0 +Student_03225,1,39,9147,1,1,12,1,19,37,7,9,133.1,118.2,0,0,0,1,0,0,0,31,0,5,8,1,13.0,2,0,5,9,4,12.25,0,10.8,1.4,1.74,0 +Student_03226,2,43,9500,1,1,1,1,37,37,9,10,140.0,105.7,1,0,0,1,0,0,0,27,0,8,8,8,13.81375,0,0,8,8,8,13.81375,0,9.4,-0.8,-3.12,2 +Student_03227,1,1,9085,1,1,1,1,19,38,9,9,130.0,126.9,0,0,1,1,0,0,0,24,0,6,8,6,13.285714285714286,0,0,6,13,6,12.875,0,11.1,0.6,2.02,2 +Student_03228,1,44,9085,1,1,39,1,19,38,194,193,150.0,150.0,1,0,0,1,0,0,0,23,0,6,11,4,NA,0,0,6,12,4,12.2,0,8.9,1.4,3.51,1 +Student_03230,1,1,9500,1,6,1,1,38,38,5,5,118.0,114.2,1,0,0,1,0,0,0,20,0,7,9,6,13.683333333333332,0,0,8,11,6,13.116666666666667,0,11.1,0.6,2.02,2 +Student_03231,1,39,9500,1,1,1,1,38,1,9,4,130.0,140.0,1,0,0,1,0,0,0,24,0,8,8,7,14.985714285714286,0,0,8,8,7,14.985714285714286,0,12.7,3.7,-1.7,2 +Student_03232,2,39,9147,1,1,1,1,37,37,9,9,130.0,142.5,0,0,0,1,0,0,0,39,0,5,8,4,11.25,0,0,5,8,4,11.5,0,11.1,0.6,2.02,1 +Student_03235,1,1,9500,1,2,1,1,1,1,4,3,130.0,125.1,1,0,0,1,0,0,0,18,0,7,10,7,13.78,0,0,8,10,8,13.661,0,15.5,2.8,-4.06,2 +Student_03237,1,17,9085,1,1,1,1,1,19,4,9,138.0,142.2,1,0,0,1,0,0,0,18,0,5,7,5,13.8,0,0,5,5,5,12.6,0,10.8,1.4,1.74,2 +Student_03238,1,1,9670,1,1,1,1,37,19,9,9,113.0,110.2,1,0,0,1,0,0,0,22,0,5,7,3,12.666666666666666,0,0,5,6,4,12.0,0,7.6,2.6,0.32,1 +Student_03239,1,17,9500,1,4,1,1,1,1,4,4,135.0,127.0,1,0,0,1,0,0,0,18,0,7,7,7,14.424285714285714,0,0,8,8,8,13.9375,0,11.1,0.6,2.02,2 +Student_03240,1,1,9238,1,1,1,1,3,1,4,9,137.0,128.6,0,0,0,1,0,1,0,18,0,6,7,6,13.166666666666666,0,0,6,6,6,12.5,0,12.4,0.5,1.79,2 +Student_03241,4,39,9991,0,1,1,1,37,37,9,9,133.1,130.4,0,0,0,1,0,0,0,30,0,5,10,3,10.666666666666666,0,0,5,8,5,10.4,0,12.7,3.7,-1.7,1 +Student_03242,2,NA,9238,1,1,12,1,37,37,9,9,100.0,134.4,0,0,0,1,0,0,0,34,9,16,20,14,12.071428571428571,1,11,13,13,11,12.272727272727272,0,7.6,2.6,0.32,2 +Student_03243,1,39,8014,0,1,19,1,37,37,9,NA,133.1,100.0,0,0,0,1,0,0,0,38,0,6,10,3,10.25,0,0,6,7,1,12.0,0,13.9,-0.3,0.79,0 +Student_03245,1,17,9853,1,3,1,1,38,38,5,7,140.0,126.7,1,0,0,1,0,0,0,19,0,6,9,5,12.4,0,0,6,10,3,10.666666666666666,0,10.8,1.4,1.74,0 +Student_03246,1,43,9773,1,1,1,1,1,1,4,8,129.0,129.0,0,0,0,0,0,0,0,21,0,6,7,6,12.0,0,0,6,6,6,12.0,0,10.8,1.4,1.74,0 +Student_03247,1,17,9773,1,1,1,1,2,3,2,2,141.0,133.7,1,0,0,1,0,1,0,18,0,6,6,6,14.833333333333334,0,0,6,6,6,13.5,0,11.1,0.6,2.02,2 +Student_03248,1,17,9085,1,5,1,1,1,38,4,7,118.0,122.2,1,0,0,1,0,1,0,20,0,6,7,6,15.428571428571429,0,0,6,7,6,13.5,0,13.9,-0.3,0.79,2 +Student_03249,1,17,9147,1,5,1,1,37,38,5,5,131.0,128.9,0,0,0,1,0,1,0,18,0,5,7,5,11.6,0,0,5,11,5,11.4,4,16.2,0.3,-0.92,2 +Student_03250,1,1,9070,1,3,1,1,38,37,5,5,161.0,154.4,1,0,0,1,0,0,0,18,0,6,6,6,14.166666666666666,0,0,6,6,6,NA,0,16.2,0.3,-0.92,2 +Student_03251,1,7,9556,1,1,2,1,37,37,9,9,130.0,130.0,1,0,0,1,0,1,0,36,0,7,9,1,9.8,0,0,7,7,0,0.0,0,12.7,3.7,-1.7,0 +Student_03253,1,43,9130,1,1,6,1,1,29,4,90,133.1,123.3,1,0,0,1,0,1,0,21,0,5,7,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_03255,1,15,9085,1,1,1,41,3,3,4,2,133.1,101.3,0,0,0,1,0,0,1,18,0,6,13,6,13.0,0,0,6,15,6,12.25,0,11.1,0.6,2.02,2 +Student_03258,2,39,9003,1,1,19,1,37,19,9,4,133.1,140.0,0,0,1,1,0,0,0,29,0,6,11,5,12.6,0,0,6,6,6,12.666666666666666,0,11.1,0.6,2.02,2 +Student_03259,1,44,9147,1,1,39,1,19,1,9,3,130.0,130.0,0,0,0,1,0,1,0,20,4,7,8,7,13.0,0,2,5,5,5,13.4,0,11.1,0.6,2.02,2 +Student_03260,1,17,9500,1,2,1,1,37,37,9,9,140.0,132.5,1,0,0,1,0,0,0,18,0,7,7,6,14.316666666666668,0,0,7,7,6,14.316666666666668,0,7.6,2.6,0.32,2 +Student_03261,1,1,9085,1,1,1,1,2,1,4,10,124.0,117.4,1,0,0,1,0,0,0,19,0,5,7,4,12.75,0,0,5,5,5,12.0,0,10.8,1.4,1.74,2 +Student_03262,1,1,9147,1,3,1,1,1,38,3,8,115.0,109.8,1,0,0,1,0,1,0,19,0,5,5,5,13.4,0,0,5,5,5,12.6,0,8.9,1.4,3.51,2 +Student_03265,1,1,9853,1,1,1,1,19,19,7,7,121.0,113.0,1,0,0,1,NA,0,0,21,0,6,9,5,12.4,0,0,6,11,1,11.0,0,12.7,3.7,-1.7,0 +Student_03266,1,17,9238,1,1,1,1,1,38,144,181,125.0,123.3,0,0,0,1,0,1,0,19,0,6,8,6,11.5,0,0,6,7,6,12.333333333333334,0,12.4,0.5,1.79,2 +Student_03267,1,17,9670,1,2,1,1,3,1,3,1,123.0,116.7,0,0,0,1,0,0,0,19,0,5,5,5,13.4,0,0,5,5,5,14.0,0,9.4,-0.8,-3.12,2 +Student_03268,2,39,9991,0,1,39,1,38,19,9,5,140.0,110.0,0,0,0,1,0,1,0,35,0,5,9,3,11.666666666666666,0,0,5,7,5,11.8,0,12.7,3.7,-1.7,1 +Student_03269,2,39,9500,1,1,NA,1,37,38,9,8,133.1,118.9,0,0,0,1,0,0,0,30,0,7,0,0,0.0,0,0,8,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_03270,1,43,9773,1,2,1,1,34,34,0,0,120.0,103.6,1,0,0,1,0,0,0,27,4,8,11,7,13.285714285714286,0,4,7,13,5,11.6,0,9.4,-0.8,-3.12,0 +Student_03271,2,1,9254,1,1,1,1,37,37,9,9,136.0,122.7,0,0,0,1,0,1,0,45,0,6,10,4,11.5,0,0,6,16,2,10.5,0,7.6,2.6,0.32,0 +Student_03274,1,43,9500,1,1,1,1,37,37,9,6,120.0,NA,1,0,0,1,0,0,0,26,0,7,8,6,12.0,0,0,7,8,6,12.0,0,7.6,2.6,0.32,1 +Student_03275,1,39,9003,1,1,19,1,37,37,9,9,133.1,130.0,0,0,0,1,NA,0,0,44,0,6,10,1,12.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_03276,5,7,9147,1,1,40,1,37,37,9,9,110.0,110.0,0,0,0,1,0,0,0,23,10,15,15,13,10.923076923076923,0,5,10,10,7,11.142857142857142,0,15.5,2.8,-4.06,2 +Student_03278,1,1,9147,1,1,1,1,38,38,9,9,102.0,99.6,1,0,0,1,0,1,0,21,0,5,10,5,13.714285714285714,0,0,5,7,5,14.4,0,11.1,0.6,2.02,2 +Student_03279,1,43,9147,1,3,1,21,3,37,3,3,127.0,117.9,1,0,0,1,0,0,1,22,0,5,8,1,10.0,0,0,5,8,2,13.0,0,7.6,2.6,0.32,0 +Student_03280,4,39,8014,0,1,1,1,37,37,9,8,133.1,113.0,0,0,0,1,0,1,0,32,0,6,18,2,10.333333333333334,0,0,6,7,6,11.5,0,16.2,0.3,-0.92,2 +Student_03281,1,17,9556,1,2,1,41,1,1,7,7,137.0,124.4,1,0,0,1,0,0,1,20,0,7,8,7,12.728571428571428,0,0,8,8,8,14.625,0,15.5,2.8,-4.06,2 +Student_03282,2,7,8014,0,1,3,1,35,35,90,90,130.0,140.0,0,0,0,0,0,0,0,59,10,15,22,12,13.333333333333334,0,8,8,8,8,12.875,0,10.8,1.4,1.74,0 +Student_03283,2,53,9147,1,1,42,1,19,19,175,152,130.0,132.4,0,0,0,1,0,0,0,30,6,11,20,9,12.22222222222222,0,3,9,16,9,11.6,0,8.9,1.4,NA,1 +Student_03284,1,1,9254,1,4,1,1,38,36,9,9,131.0,124.0,1,0,0,1,0,1,0,18,0,6,7,6,11.333333333333334,0,0,6,9,6,10.833333333333334,0,9.4,-0.8,-3.12,2 +Student_03286,4,43,9991,0,1,1,1,NA,37,5,5,140.0,149.8,0,0,0,1,1,0,0,36,0,5,5,5,13.8,0,0,5,6,5,13.8,0,12.7,3.7,-1.7,2 +Student_03288,1,17,9670,1,6,1,1,38,19,0,1,117.0,114.6,0,0,0,0,1,0,0,19,0,6,9,4,11.25,0,0,6,11,3,10.166666666666666,0,10.8,1.4,1.74,0 +Student_03291,1,1,9238,1,1,1,1,1,1,5,5,125.0,128.5,0,0,0,1,1,0,0,20,0,6,13,1,14.0,0,0,6,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_03292,1,39,9003,1,1,1,1,37,37,9,7,130.0,113.0,1,0,0,0,1,0,0,35,0,6,17,1,13.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_03293,1,1,9238,1,1,1,1,37,37,0,0,170.0,150.8,1,0,0,1,0,0,0,27,0,6,13,2,11.0,0,0,6,14,1,11.0,0,7.6,2.6,0.32,0 +Student_03294,1,17,9500,1,3,1,1,19,3,9,5,132.0,130.8,1,0,0,1,0,0,0,18,0,8,8,7,13.68142857142857,0,0,8,8,7,13.68142857142857,0,10.8,1.4,1.74,1 +Student_03295,1,43,9500,1,1,1,1,38,19,9,10,133.1,114.5,0,0,0,1,0,0,0,23,0,7,11,6,12.1,0,0,7,7,6,12.616666666666667,0,16.2,0.3,-0.92,1 +Student_03296,1,17,8014,0,2,1,1,19,1,5,10,120.0,114.8,1,0,0,1,0,0,0,19,0,6,8,4,10.5,0,0,6,8,4,11.25,0,10.8,1.4,1.74,2 +Student_03297,1,17,9500,1,2,1,1,37,37,7,7,NA,126.2,1,0,0,1,0,1,0,18,0,7,10,5,11.94,0,0,7,8,6,12.8,0,11.1,0.6,2.02,1 +Student_03298,1,39,9500,1,1,1,1,19,19,3,7,130.0,129.0,0,0,1,0,0,0,0,26,0,7,11,4,12.86,0,0,7,10,5,11.566666666666668,0,12.4,0.5,1.79,0 +Student_03299,1,17,9238,1,1,1,NA,1,38,9,7,133.1,110.5,0,0,0,1,0,0,0,19,0,6,10,6,14.25,0,0,6,7,6,14.0,0,16.2,0.3,-0.92,2 +Student_03302,1,17,9500,1,1,1,1,19,1,9,7,130.0,130.4,1,0,0,1,0,1,0,19,0,7,7,7,13.894285714285711,0,0,8,8,8,14.3625,0,11.1,0.6,2.02,2 +Student_03303,1,17,9500,1,1,1,1,37,37,9,8,128.0,124.3,1,0,0,1,0,1,0,19,0,7,8,7,13.46875,0,0,8,8,8,13.31375,0,15.5,2.8,-4.06,2 +Student_03304,1,1,9085,1,4,1,1,38,37,9,9,135.0,132.6,1,0,0,1,0,1,0,19,0,5,5,5,13.6,0,0,5,5,5,14.6,0,10.8,1.4,1.74,2 +Student_03305,1,44,8014,0,1,39,1,1,37,9,7,150.0,146.7,0,0,0,1,0,1,0,21,3,6,6,6,14.666666666666666,0,2,6,6,6,13.833333333333334,0,12.4,0.5,1.79,2 +Student_03306,1,1,9773,1,3,1,1,1,1,3,5,135.0,130.1,1,0,0,1,0,0,0,18,0,6,6,6,13.666666666666666,0,0,6,7,6,13.0,0,15.5,2.8,-4.06,2 +Student_03307,2,43,9254,1,1,3,1,38,37,9,3,120.0,120.0,1,0,0,1,0,0,0,33,9,12,22,10,13.3,0,9,11,11,11,13.727272727272728,0,9.4,-0.8,-3.12,2 +Student_03309,1,1,9500,1,6,1,1,19,19,1,4,140.0,133.3,1,0,0,1,0,1,0,17,0,8,8,8,13.41625,0,0,8,8,8,13.41625,0,9.4,-0.8,-3.12,2 +Student_03310,2,39,9500,1,1,1,1,19,19,9,7,140.0,110.5,0,0,0,1,0,0,0,31,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03311,2,39,8014,0,1,1,1,19,19,9,7,140.0,102.5,0,0,0,1,0,1,0,32,0,6,6,6,11.333333333333334,0,0,6,8,5,13.0,0,15.5,2.8,-4.06,2 +Student_03312,1,1,9085,1,2,1,1,40,40,3,7,156.0,150.9,1,0,0,1,0,0,0,18,0,6,8,6,16.0,0,0,6,10,6,14.625,0,11.1,0.6,2.02,0 +Student_03314,1,1,9254,1,1,1,1,1,1,9,10,120.0,118.3,0,0,0,1,1,0,0,20,0,6,8,6,12.857142857142858,0,0,6,9,5,12.4,0,8.9,1.4,3.51,1 +Student_03315,1,43,9991,0,1,1,1,3,19,1,1,100.0,117.9,0,0,0,0,1,0,0,40,0,5,5,0,0.0,0,0,5,6,0,0.0,0,10.8,1.4,1.74,0 +Student_03316,2,1,9991,0,1,1,1,37,19,9,9,120.0,135.0,1,0,0,1,1,0,0,32,0,5,5,5,14.8,0,0,5,5,5,14.2,0,7.6,2.6,0.32,2 +Student_03317,1,7,9119,1,1,3,1,19,19,1,1,120.0,120.0,0,0,0,0,1,0,0,40,1,5,7,1,13.0,0,2,5,5,2,14.0,0,12.7,3.7,-1.7,0 +Student_03318,1,1,171,1,1,1,1,1,1,4,9,172.0,167.1,0,0,0,1,1,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,2 +Student_03319,1,43,9991,0,1,1,1,37,37,9,9,120.0,115.8,0,0,1,0,1,0,0,28,4,9,14,4,10.0,0,1,6,6,1,10.0,0,12.7,3.7,-1.7,0 +Student_03320,1,16,9070,1,2,1,1,1,1,3,1,137.0,141.2,1,0,1,1,1,0,0,19,0,6,11,5,11.2,0,0,6,7,6,12.0,0,9.4,-0.8,-3.12,2 +Student_03322,1,1,9147,1,6,1,1,38,37,7,7,142.0,134.3,0,1,0,1,1,0,0,21,0,5,0,0,0.0,0,0,5,0,0,0.0,0,10.8,1.4,1.74,0 +Student_03325,1,39,171,1,1,1,1,12,3,5,2,110.0,100.0,1,0,0,1,1,0,0,27,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03328,1,39,9130,1,1,39,1,1,3,4,1,150.0,150.0,0,0,0,1,1,0,0,28,0,6,9,0,0.0,0,0,6,8,1,10.0,1,16.2,0.3,-0.92,0 +Student_03329,5,39,9119,1,1,1,1,37,37,9,9,120.0,116.0,0,0,1,1,1,1,0,34,0,5,14,1,17.0,0,0,5,10,2,11.0,0,9.4,-0.8,-3.12,1 +Student_03330,1,17,9147,1,1,1,1,NA,1,4,4,110.0,99.0,0,0,0,NA,1,0,0,21,0,5,5,5,11.0,0,0,5,11,3,11.428571428571429,0,NA,1.4,1.74,1 +Student_03331,1,1,9238,1,1,1,1,1,19,9,9,133.0,132.0,0,0,0,1,1,1,0,20,0,6,11,5,11.142857142857142,0,0,6,9,6,11.571428571428571,0,16.2,0.3,-0.92,2 +Student_03334,1,39,9670,1,2,19,1,34,34,0,0,133.1,100.0,1,0,0,0,1,0,0,27,0,5,8,1,11.0,0,0,5,6,3,10.666666666666666,1,7.6,2.6,0.32,0 +Student_03335,1,1,9773,1,6,1,NA,38,38,9,9,136.0,132.9,1,0,0,1,1,0,0,19,0,6,10,4,13.25,0,0,6,13,5,11.8,0,7.6,2.6,0.32,2 +Student_03336,1,17,9773,1,4,1,1,3,1,2,7,129.0,132.5,1,0,0,1,1,0,0,21,0,6,7,0,0.0,0,0,6,11,1,10.0,0,10.8,1.4,1.74,1 +Student_03337,1,44,9003,1,1,39,1,19,19,4,4,140.0,140.0,1,0,0,0,1,0,0,21,0,6,17,2,12.5,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_03338,1,43,9670,1,1,1,1,34,34,99,99,160.0,100.1,0,0,0,0,1,0,0,35,6,10,10,7,12.142857142857142,0,4,9,9,4,12.25,0,7.6,2.6,0.32,0 +Student_03339,1,39,9085,1,1,1,1,37,36,90,7,133.1,128.2,0,0,0,1,1,0,0,28,0,5,8,3,12.0,0,0,5,10,3,11.333333333333334,0,7.6,2.6,0.32,0 +Student_03340,1,17,9670,1,1,1,1,1,1,4,3,140.0,133.4,0,0,0,1,1,0,0,NA,0,6,6,4,11.25,0,0,6,9,4,10.428571428571429,0,10.8,1.4,1.74,1 +Student_03341,1,1,9773,1,3,1,1,34,1,5,10,142.0,136.1,1,0,0,0,1,0,0,19,0,4,8,0,0.0,1,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03343,1,1,9070,1,1,1,1,3,19,4,4,131.0,130.3,1,0,0,1,1,1,0,20,0,6,6,6,12.833333333333334,0,0,6,8,6,12.666666666666666,2,16.2,0.3,-0.92,2 +Student_03345,1,39,9085,1,1,1,1,40,1,5,6,110.0,142.5,0,0,1,0,1,0,0,37,5,7,7,5,12.0,0,3,7,7,3,11.666666666666666,0,8.9,1.4,3.51,0 +Student_03347,1,39,9500,1,1,1,1,37,37,9,8,120.0,108.5,0,0,0,1,1,0,0,36,0,7,18,0,0.0,0,0,7,7,0,0.0,0,13.9,-0.3,0.79,0 +Student_03348,1,39,9147,1,1,12,1,37,37,9,9,133.1,140.0,0,0,0,1,1,0,0,29,0,5,0,0,0.0,0,0,5,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03350,1,51,9670,1,1,19,1,2,1,3,10,133.1,120.0,0,0,1,1,1,0,0,32,1,6,15,2,12.0,0,0,6,7,0,0.0,0,11.1,0.6,2.02,0 +Student_03351,1,1,8014,0,1,1,1,3,1,2,9,123.0,127.6,1,0,0,1,1,0,0,26,0,6,6,6,11.833333333333334,0,0,6,6,6,11.666666666666666,0,10.8,1.4,1.74,1 +Student_03352,2,44,9003,1,1,39,1,37,37,4,7,140.0,140.0,0,0,0,1,1,0,0,37,0,6,17,1,12.0,0,0,6,23,2,10.5,1,16.2,0.3,-0.92,0 +Student_03354,1,1,9773,1,1,1,1,38,1,5,7,131.0,131.0,1,0,0,1,1,1,0,18,0,6,7,6,12.714285714285714,0,0,6,8,5,11.833333333333334,0,13.9,-0.3,0.79,2 +Student_03355,1,1,9500,1,1,1,1,38,37,9,9,149.0,139.5,0,0,0,1,1,1,0,18,0,8,8,8,15.3,0,0,8,8,8,15.3,0,9.4,-0.8,-3.12,2 +Student_03356,2,39,9003,1,2,19,1,38,19,4,1,133.1,110.0,0,0,0,0,1,0,0,32,2,8,12,2,11.5,2,0,7,9,0,0.0,0,15.5,2.8,-4.06,0 +Student_03357,1,44,9119,1,1,39,1,3,19,3,4,130.0,130.0,0,0,0,1,1,0,0,20,0,5,12,1,13.0,0,0,5,8,3,12.6,0,12.4,0.5,1.79,1 +Student_03358,1,43,9003,1,1,1,1,3,3,1,2,120.0,115.0,0,0,0,1,1,0,0,22,0,6,12,0,0.0,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_03359,4,39,9500,1,1,1,1,1,19,3,3,133.1,154.3,0,0,0,1,0,0,0,32,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.4,0.5,1.79,0 +Student_03360,1,1,9147,1,1,1,1,1,37,9,9,143.0,135.0,1,0,0,1,0,0,0,21,0,5,8,4,11.0,0,0,5,8,5,12.0,0,7.6,2.6,0.32,1 +Student_03363,1,1,9147,1,4,1,1,1,1,9,7,123.0,117.4,1,0,0,1,0,1,0,18,0,5,7,5,12.0,0,0,5,10,5,11.4,0,8.9,1.4,3.51,2 +Student_03364,1,7,9147,1,1,2,1,3,37,2,5,150.0,150.0,1,0,1,0,0,0,0,38,0,5,6,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_03365,1,17,9853,1,3,1,1,34,34,0,0,132.0,131.3,1,0,0,1,0,0,0,21,0,6,8,5,11.8,0,0,6,8,4,10.5,0,7.6,2.6,0.32,0 +Student_03366,1,1,9238,1,1,1,1,34,37,5,5,133.0,120.4,0,0,0,0,0,0,0,21,0,6,12,2,11.5,0,0,6,13,1,13.0,0,9.4,-0.8,-3.12,0 +Student_03367,1,1,9991,0,1,1,1,37,37,9,3,122.0,113.6,0,0,0,1,1,0,0,26,0,5,11,2,11.5,0,0,5,10,3,12.0,0,7.6,2.6,0.32,1 +Student_03368,1,1,9500,1,4,1,NA,19,38,9,3,137.0,125.0,1,0,0,1,0,0,0,19,0,7,7,6,14.616666666666667,0,0,7,7,6,14.616666666666667,0,7.6,2.6,0.32,2 +Student_03369,1,1,9500,1,6,1,1,19,37,9,9,145.0,132.3,1,0,0,1,0,1,0,19,0,8,8,7,14.06,0,0,8,8,7,14.06,0,10.8,1.4,1.74,1 +Student_03370,1,17,9254,1,1,1,1,1,1,9,10,150.0,142.7,0,0,1,1,0,0,0,18,0,6,9,4,11.0,0,0,6,12,3,11.333333333333334,0,7.6,2.6,0.32,0 +Student_03371,1,7,9147,1,1,3,1,37,37,9,9,130.0,130.0,0,0,0,1,0,0,0,25,0,5,0,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03372,1,1,9500,1,6,1,1,37,1,5,4,136.0,120.8,1,0,0,1,0,0,0,19,6,14,22,7,12.192307692307692,5,6,14,22,7,12.192307692307692,5,7.6,2.6,0.32,2 +Student_03373,1,17,9254,1,2,1,1,1,19,9,9,131.0,130.3,1,0,0,NA,0,1,0,18,0,6,6,6,12.833333333333334,0,0,6,7,6,12.333333333333334,0,13.9,-0.3,0.79,2 +Student_03374,1,17,9147,1,1,1,1,37,37,9,7,130.0,119.9,0,0,0,1,0,1,0,19,0,5,8,5,12.875,0,0,5,6,5,11.833333333333334,0,13.9,-0.3,0.79,2 +Student_03375,1,1,9238,1,1,1,1,19,38,9,7,108.0,110.5,1,0,0,1,0,1,0,22,0,6,6,6,12.166666666666666,0,0,6,6,6,12.5,0,12.4,0.5,1.79,2 +Student_03377,1,17,9085,1,1,1,1,19,37,9,9,113.0,118.6,1,0,0,1,0,1,0,21,0,6,6,6,14.5,0,0,6,8,6,14.666666666666666,0,8.9,1.4,3.51,2 +Student_03380,1,1,9500,1,4,1,1,19,19,9,3,148.0,125.0,1,0,0,1,0,0,0,18,0,7,7,6,13.9,0,0,7,7,6,13.9,0,7.6,2.6,0.32,2 +Student_03381,1,39,9500,1,1,1,1,19,19,9,8,130.0,105.8,0,0,0,1,0,0,0,26,0,7,12,3,13.766666666666666,0,0,7,11,3,12.066666666666668,0,13.9,-0.3,0.79,0 +Student_03382,1,26,9147,1,1,2,1,34,34,0,0,133.1,121.5,1,0,0,1,0,0,0,31,13,15,17,13,11.615384615384617,0,11,14,14,11,12.545454545454543,0,7.6,2.6,0.32,0 +Student_03383,1,17,9238,1,1,1,1,37,38,9,8,138.0,134.2,1,0,0,1,0,1,0,18,0,6,6,6,15.166666666666666,0,0,6,7,6,14.142857142857142,0,11.1,0.6,2.02,2 +Student_03384,4,7,9147,1,1,3,1,19,1,5,5,130.0,130.0,0,0,0,1,0,0,0,35,0,5,5,0,0.0,0,0,5,5,0,0.0,0,11.1,0.6,2.02,0 +Student_03386,1,1,9238,1,1,1,1,19,38,7,7,115.0,108.7,0,0,0,1,0,1,0,19,0,6,9,5,10.8,0,0,6,8,6,10.714285714285714,0,15.5,2.8,-4.06,2 +Student_03387,1,1,9500,1,2,1,1,3,1,4,3,147.0,136.7,0,0,0,1,0,0,0,18,0,7,7,7,13.995714285714287,0,0,8,9,8,14.955555555555556,0,11.1,0.6,2.02,2 +Student_03388,1,17,9085,1,1,1,1,38,38,4,9,132.0,119.1,0,0,0,1,0,0,0,20,0,6,8,6,13.285714285714286,0,0,6,16,6,11.8,0,12.4,0.5,1.79,2 +Student_03389,1,1,171,1,4,1,1,1,1,9,5,146.0,151.3,1,0,0,1,0,1,0,19,6,12,12,12,12.75,0,4,11,16,11,13.25,0,8.9,1.4,3.51,2 +Student_03390,1,43,9238,1,1,1,1,19,37,5,5,109.0,108.3,0,0,0,1,0,1,0,21,0,6,15,2,10.5,0,0,6,8,5,12.4,0,10.8,1.4,1.74,1 +Student_03391,1,17,9853,1,1,1,1,38,38,9,9,133.0,127.4,0,0,1,1,0,1,0,18,0,7,7,7,12.714285714285714,0,0,7,7,7,12.285714285714286,0,16.2,0.3,-0.92,2 +Student_03393,1,1,9070,1,1,1,1,1,1,9,9,133.1,155.0,0,0,0,1,0,1,0,21,0,6,7,5,13.0,0,0,6,6,6,12.666666666666666,0,16.2,0.3,-0.92,2 +Student_03394,1,1,9147,1,1,1,1,37,38,9,9,121.0,114.0,0,0,0,1,0,1,0,19,0,5,7,5,12.2,0,0,5,6,5,11.2,0,11.1,0.6,2.02,2 +Student_03396,1,53,9085,1,1,42,1,19,37,4,9,160.0,NA,1,0,0,1,0,0,0,20,7,11,15,11,13.785714285714286,0,4,9,9,9,13.88888888888889,0,8.9,1.4,3.51,2 +Student_03398,1,1,9500,1,1,1,1,37,37,9,7,150.0,136.5,1,0,0,1,0,1,0,18,0,8,8,8,14.50125,0,0,8,8,8,14.50125,0,9.4,-0.8,-3.12,2 +Student_03400,1,17,9070,1,1,1,1,38,19,5,5,133.1,128.0,0,0,0,1,0,1,0,21,0,6,6,6,11.5,0,0,6,6,6,12.333333333333334,0,9.4,-0.8,-3.12,2 +Student_03402,1,1,9670,1,1,1,1,37,19,7,7,126.0,125.7,0,0,0,1,0,0,0,20,0,6,9,6,13.571428571428571,0,0,6,10,5,13.6,0,15.5,2.8,-4.06,1 +Student_03403,1,1,9773,1,1,1,1,19,38,9,5,150.0,143.0,0,0,0,1,0,0,0,18,0,6,6,5,13.0,0,0,6,6,6,13.666666666666666,0,12.7,3.7,-1.7,2 +Student_03404,1,17,9500,1,5,1,1,19,19,9,7,141.0,131.9,1,0,0,1,0,1,0,18,0,7,8,7,13.56875,0,0,8,8,8,14.02625,0,15.5,2.8,-4.06,2 +Student_03405,2,43,9991,0,1,1,1,37,37,9,9,134.0,113.7,0,0,0,1,0,0,0,32,1,5,5,5,10.2,0,0,5,9,4,11.25,0,9.4,-0.8,-3.12,1 +Student_03406,1,17,171,1,2,1,1,3,3,3,3,146.0,155.1,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_03407,1,16,9853,1,3,1,1,19,37,9,9,134.0,121.1,1,0,0,1,0,0,0,NA,0,6,8,5,12.2,0,0,6,8,5,11.8,0,10.8,1.4,1.74,1 +Student_03409,1,1,9500,1,6,1,1,1,1,4,5,136.0,123.3,0,0,0,0,0,0,0,18,0,8,8,0,0.0,8,0,8,8,0,0.0,8,9.4,-0.8,-3.12,0 +Student_03411,1,5,9670,1,1,1,1,1,12,4,4,135.0,140.3,1,0,0,1,0,0,0,19,0,6,7,6,13.428571428571429,0,0,6,6,4,14.0,0,12.4,0.5,1.79,1 +Student_03412,1,17,9500,1,4,1,1,38,37,9,5,129.0,120.0,1,0,0,1,0,0,0,19,0,8,8,7,12.454285714285716,0,0,8,8,7,12.454285714285716,0,10.8,1.4,1.74,2 +Student_03414,1,1,9500,1,4,1,1,1,19,4,7,137.0,126.7,1,0,0,1,0,0,0,18,0,7,0,0,0.0,0,0,8,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_03415,1,17,9500,1,3,1,1,1,19,7,8,138.0,129.3,1,0,0,1,0,1,0,18,0,7,8,6,13.271666666666668,0,0,8,11,7,12.94375,0,12.4,0.5,1.79,2 +Student_03416,1,17,9500,1,6,1,1,3,38,2,9,136.0,125.7,1,0,0,1,0,0,0,20,0,7,8,6,13.548333333333334,0,0,8,11,6,14.775,0,11.1,0.6,2.02,1 +Student_03417,1,1,9773,1,1,1,1,3,3,2,5,143.0,144.8,0,0,0,1,0,0,0,19,0,6,6,6,12.166666666666666,0,0,6,6,6,12.5,0,16.2,0.3,-0.92,1 +Student_03418,1,1,9254,1,1,1,1,38,19,3,3,133.1,98.6,0,0,0,1,0,0,0,21,0,6,16,2,11.0,0,0,6,12,0,0.0,0,12.7,3.7,-1.7,0 +Student_03419,1,1,9853,1,1,1,1,38,37,9,9,136.0,126.9,1,0,0,1,0,1,0,19,0,7,7,7,13.285714285714286,0,0,7,7,7,14.428571428571429,0,11.1,0.6,2.02,2 +Student_03421,1,1,9500,1,1,1,1,1,1,9,4,125.0,117.0,0,0,0,1,0,1,0,21,0,8,8,8,13.2575,0,0,8,8,8,13.2575,0,9.4,-0.8,-3.12,2 +Student_03422,1,44,9085,1,1,39,1,37,38,9,6,130.0,130.0,1,0,0,1,0,0,0,23,0,6,7,0,0.0,0,0,6,7,0,0.0,0,11.1,0.6,2.02,0 +Student_03423,1,17,9238,1,1,1,1,1,38,5,8,137.0,125.8,0,0,0,0,0,1,0,18,0,6,10,6,12.666666666666666,0,0,6,6,2,11.5,0,12.7,3.7,-1.7,0 +Student_03424,2,39,9991,0,1,3,1,3,1,1,10,130.0,160.0,0,0,0,1,0,0,0,30,0,5,5,5,14.6,0,0,5,5,5,15.4,0,12.7,3.7,-1.7,0 +Student_03425,1,1,9085,1,1,1,1,9,19,4,1,130.0,134.2,1,0,0,1,0,0,0,20,0,5,13,0,0.0,5,0,5,5,0,0.0,5,9.4,-0.8,-3.12,0 +Student_03426,2,43,9147,1,2,1,1,37,37,9,9,160.0,96.0,0,0,0,0,0,0,0,29,3,5,7,3,12.333333333333334,0,0,5,8,0,0.0,0,10.8,1.4,1.74,0 +Student_03427,1,18,9147,1,1,1,1,38,38,5,5,100.0,101.8,1,0,0,1,0,0,0,24,0,5,5,5,10.8,0,0,5,11,2,11.0,0,10.8,1.4,1.74,1 +Student_03428,1,1,9238,1,1,1,1,19,1,4,3,136.0,125.2,1,0,0,1,0,0,0,20,0,6,7,6,11.666666666666666,0,0,6,10,6,11.333333333333334,0,7.6,2.6,0.32,2 +Student_03430,2,7,9147,1,1,3,1,37,37,9,9,140.0,140.0,0,0,0,1,0,0,0,23,0,5,0,0,0.0,0,0,5,0,0,0.0,0,7.6,2.6,0.32,0 +Student_03431,1,51,9070,1,1,1,1,19,19,153,153,132.0,120.0,0,0,0,1,0,1,0,23,0,6,6,6,15.333333333333334,0,0,6,6,6,14.166666666666666,0,11.1,0.6,2.02,2 +Student_03433,1,1,9773,1,1,1,1,38,38,9,7,158.0,144.7,1,0,0,1,0,1,0,NA,0,6,6,6,14.833333333333334,0,0,6,6,6,14.666666666666666,0,12.7,3.7,-1.7,2 +Student_03434,1,17,9500,1,6,1,1,19,37,4,9,142.0,131.9,1,0,0,1,0,0,0,19,0,7,7,7,13.642857142857142,0,0,8,8,8,14.3875,0,13.9,-0.3,0.79,0 +Student_03435,1,1,9773,1,1,1,1,NA,38,8,8,143.0,136.7,1,0,0,1,0,1,0,18,0,6,6,6,13.833333333333334,0,0,6,6,6,14.0,0,11.1,0.6,2.02,0 +Student_03436,1,1,9070,1,2,1,1,1,1,4,7,135.0,129.8,1,0,0,1,0,0,0,19,0,6,6,6,11.833333333333334,0,0,6,7,6,13.0,0,9.4,-0.8,-3.12,2 +Student_03437,NA,1,9773,1,1,1,1,1,38,4,7,160.0,146.5,0,0,0,1,0,1,0,18,0,6,7,6,13.428571428571429,0,0,6,10,6,13.5,0,13.9,-0.3,0.79,2 +Student_03438,1,43,9991,0,1,1,1,37,37,9,8,120.0,122.5,1,0,0,1,0,0,0,29,8,13,16,8,10.5,0,8,12,19,9,10.333333333333334,0,9.4,-0.8,-3.12,1 +Student_03440,1,17,9556,1,2,1,1,37,38,9,8,133.1,106.0,1,0,0,1,0,0,0,19,0,7,16,2,12.75,0,0,7,12,2,11.0,0,8.9,1.4,3.51,0 +Student_03442,1,1,9670,1,1,1,1,38,19,4,8,120.0,115.1,0,0,0,1,0,0,0,NA,0,6,8,3,11.666666666666666,0,0,6,11,5,NA,0,10.8,1.4,1.74,1 +Student_03443,1,17,9254,1,4,1,1,37,19,9,7,106.0,116.9,1,0,0,1,0,0,0,20,0,6,7,6,11.5,0,0,6,8,5,12.4,0,11.1,0.6,2.02,2 +Student_03444,1,1,9773,1,2,1,1,1,19,9,9,148.0,141.7,0,0,0,1,0,0,0,18,0,6,6,6,13.833333333333334,0,0,6,6,6,12.666666666666666,0,10.8,1.4,1.74,2 +Student_03445,1,1,9070,1,2,1,1,1,19,3,3,NA,127.7,1,0,0,0,0,0,0,18,1,6,8,6,11.714285714285714,1,0,6,11,4,11.333333333333334,0,13.9,-0.3,0.79,0 +Student_03446,1,1,9500,1,5,1,1,19,1,9,5,130.0,122.1,1,0,0,1,0,1,0,19,0,7,8,7,11.678571428571429,0,0,8,10,7,13.0375,0,12.4,0.5,1.79,2 +Student_03447,1,16,9085,1,1,1,1,3,3,2,1,150.0,153.5,1,0,0,1,0,0,0,19,0,6,7,6,15.714285714285714,0,0,6,6,6,14.666666666666666,0,13.9,-0.3,0.79,0 +Student_03448,1,1,171,1,1,1,1,1,19,5,8,141.0,141.4,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_03450,1,1,9500,1,2,1,1,3,3,2,2,138.0,127.5,1,0,0,1,0,1,0,18,0,7,7,7,14.485714285714286,0,0,8,9,8,14.58888888888889,0,16.2,0.3,-0.92,2 +Student_03452,1,39,9500,1,1,1,1,19,19,5,6,133.1,121.4,0,0,1,1,0,0,0,28,0,7,12,4,13.375,0,0,7,7,5,13.5,0,13.9,-0.3,0.79,1 +Student_03453,1,42,9500,1,1,1,1,1,1,4,4,133.0,100.0,0,0,0,1,0,0,0,20,1,8,8,7,11.571428571428571,0,1,8,8,7,11.571428571428571,0,12.7,3.7,-1.7,2 +Student_03455,1,17,9147,1,1,1,1,37,37,9,9,117.0,109.3,0,0,0,0,0,0,0,22,0,5,9,2,10.0,1,0,5,11,1,10.0,0,9.4,-0.8,-3.12,0 +Student_03457,NA,7,9238,1,1,3,NA,37,37,9,9,140.0,140.0,1,0,0,1,0,0,0,36,10,14,21,13,13.071428571428571,0,4,11,16,11,13.0,0,16.2,0.3,-0.92,2 +Student_03458,1,44,9003,1,1,39,1,37,38,9,7,160.0,160.0,0,0,0,1,0,1,0,19,0,6,7,6,15.333333333333334,0,0,6,9,6,14.0,0,15.5,2.8,-4.06,2 +Student_03459,1,17,NA,1,1,1,1,4,3,1,1,125.0,119.8,0,0,0,1,0,0,0,18,0,6,9,5,11.571428571428571,0,0,6,8,6,12.142857142857142,0,16.2,0.3,-0.92,2 +Student_03461,1,1,9500,1,2,1,1,38,37,9,7,139.0,125.0,1,0,0,1,0,1,0,19,0,7,7,6,12.9,0,0,7,7,6,12.9,0,7.6,2.6,0.32,2 +Student_03462,4,43,9500,1,1,1,1,37,37,9,9,130.0,103.7,0,0,0,1,0,0,0,38,1,8,12,5,13.126,1,1,8,12,5,13.126,1,10.8,1.4,1.74,1 +Student_03463,NA,7,9085,1,1,3,1,37,37,7,7,120.0,120.0,0,0,0,1,0,0,0,32,4,10,20,4,11.5,2,3,9,13,3,11.666666666666666,2,15.5,2.8,-4.06,0 +Student_03465,1,17,9070,1,3,1,1,3,1,4,4,120.0,116.9,1,0,0,1,0,0,0,19,0,6,6,6,13.5,0,0,6,7,6,13.428571428571429,0,8.9,1.4,3.51,2 +Student_03466,2,39,9147,1,1,1,1,NA,37,9,9,130.0,117.9,0,0,0,1,0,0,0,35,0,1,1,0,0.0,1,0,5,0,0,0.0,0,10.8,1.4,1.74,0 +Student_03467,1,1,9147,1,1,NA,1,38,19,3,10,124.0,128.6,1,0,0,1,0,0,0,20,0,5,5,4,12.0,0,0,4,4,2,11.5,0,7.6,2.6,0.32,1 +Student_03468,1,17,9853,1,1,1,1,19,19,3,4,150.0,135.0,0,0,0,1,0,0,0,29,2,8,10,7,11.142857142857142,0,2,8,11,8,11.375,0,12.7,3.7,-1.7,2 +Student_03469,1,1,9991,0,1,1,1,37,37,9,9,140.0,124.6,0,0,0,1,0,0,0,29,0,5,11,5,11.4,0,0,5,10,4,10.25,0,15.5,2.8,-4.06,1 +Student_03470,1,1,9500,1,5,1,NA,37,37,7,7,135.0,124.0,1,0,0,NA,0,1,0,19,0,8,8,7,12.771428571428572,1,0,8,8,7,12.771428571428572,1,9.4,-0.8,-3.12,1 +Student_03471,1,1,9500,1,6,1,1,38,19,7,9,143.0,129.5,1,0,0,1,0,1,0,18,0,8,8,7,13.79857142857143,0,0,8,8,7,13.79857142857143,0,10.8,1.4,1.74,2 +Student_03472,2,39,8014,0,1,19,1,38,19,0,10,100.0,111.3,0,0,1,0,0,0,0,25,0,6,7,6,13.333333333333334,0,0,6,6,6,13.5,0,7.6,2.6,0.32,2 +Student_03473,4,39,8014,0,1,19,1,37,37,9,9,133.1,95.0,0,0,1,0,0,0,0,50,0,6,11,0,0.0,0,0,5,6,0,0.0,0,8.9,1.4,3.51,0 +Student_03474,2,1,9147,1,1,1,1,34,34,0,0,133.1,131.8,0,0,0,1,0,0,0,24,14,15,17,14,11.357142857142858,0,13,14,15,13,12.846153846153848,0,7.6,2.6,0.32,0 +Student_03475,1,1,9119,1,5,1,1,38,19,5,3,132.0,119.1,0,0,0,1,0,0,0,18,0,5,11,0,0.0,0,0,5,8,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03476,1,17,9085,1,1,1,1,38,38,191,174,131.0,125.4,1,0,0,1,0,0,0,20,0,6,13,6,15.692307692307692,0,0,6,13,5,14.428571428571429,0,15.5,2.8,-4.06,2 +Student_03477,1,16,9003,1,1,1,1,1,37,4,9,147.0,140.7,1,0,1,1,0,1,0,20,13,18,19,18,15.052631578947368,0,11,13,13,13,14.538461538461538,0,15.5,2.8,-4.06,2 +Student_03478,1,43,9991,0,1,1,1,37,37,9,9,141.0,131.9,0,0,0,1,0,0,0,21,6,10,20,6,11.5,0,5,10,17,5,12.4,0,9.4,-0.8,-3.12,0 +Student_03480,1,1,9254,1,1,1,1,38,37,9,7,135.0,139.2,0,0,0,1,1,1,0,19,0,6,6,6,13.0,0,0,6,6,6,13.166666666666666,0,12.4,0.5,1.79,2 +Student_03482,1,17,171,1,1,1,1,37,37,9,9,142.0,132.9,0,0,0,1,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_03483,1,44,9003,1,1,39,1,37,37,9,10,130.0,NA,0,0,0,1,1,0,0,25,0,6,6,0,0.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_03484,2,39,9500,1,1,1,1,37,37,9,9,133.1,130.1,0,0,0,0,1,0,0,37,0,7,10,5,13.0,0,0,7,9,5,12.88,0,11.1,0.6,2.02,0 +Student_03485,1,39,9500,1,1,1,1,37,37,7,7,133.1,124.5,0,0,0,0,1,0,0,38,0,7,11,5,12.18,0,0,7,11,4,11.8125,0,11.1,0.6,2.02,0 +Student_03487,1,1,9500,1,2,1,1,19,1,9,9,149.0,137.8,1,0,0,1,1,0,0,18,0,8,8,7,13.0,0,0,8,8,7,13.0,0,12.7,3.7,-1.7,2 +Student_03488,1,1,9670,1,1,1,1,1,1,0,0,130.0,119.5,0,0,0,0,1,0,0,19,0,5,5,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03490,1,1,9238,1,1,1,1,1,1,3,3,106.0,105.0,0,0,0,1,1,0,0,20,0,6,9,5,11.0,0,0,6,9,5,12.166666666666666,0,11.1,0.6,2.02,2 +Student_03491,1,1,171,1,1,1,1,37,37,9,9,162.0,142.8,1,0,0,1,1,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03493,2,39,9991,0,1,19,1,38,38,7,8,133.1,120.0,0,0,0,1,1,0,0,39,0,5,9,0,0.0,0,0,5,5,1,10.0,0,12.7,3.7,-1.7,0 +Student_03494,1,7,9119,1,1,3,1,37,37,9,9,130.0,130.0,0,0,0,0,1,0,0,33,0,5,6,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_03495,1,17,9670,1,2,1,1,37,38,5,8,128.0,121.7,0,0,0,1,1,1,0,20,0,5,5,5,12.4,0,0,5,5,4,10.75,0,9.4,-0.8,-3.12,2 +Student_03496,1,1,9003,1,1,1,1,38,19,9,7,124.0,NA,0,0,0,1,1,0,0,19,0,6,8,6,15.5,0,0,6,10,6,14.1,0,16.2,0.3,-0.92,2 +Student_03497,2,39,9991,0,1,1,1,37,37,5,8,133.1,133.2,0,0,0,0,1,0,0,43,0,5,13,2,11.5,0,0,5,12,3,10.8,0,13.9,-0.3,0.79,0 +Student_03498,2,43,9991,0,1,1,1,37,37,7,8,114.0,116.7,0,0,0,1,1,0,0,49,0,5,7,4,13.333333333333334,0,0,5,9,4,11.6,1,16.2,0.3,-0.92,0 +Student_03499,1,1,9773,1,2,1,1,38,38,5,7,140.0,126.4,1,0,0,1,1,1,0,18,0,6,8,6,12.666666666666666,0,0,6,6,6,13.5,0,12.7,3.7,-1.7,2 +Student_03502,1,39,9070,1,1,1,1,37,37,9,10,140.0,118.0,0,0,1,1,1,1,0,45,0,6,6,6,13.5,0,0,6,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_03503,1,15,9670,1,1,1,1,37,12,9,9,160.0,149.5,1,0,0,0,1,0,0,19,0,6,6,6,13.0,0,0,6,8,6,13.0,0,13.9,-0.3,0.79,2 +Student_03504,1,44,9003,1,1,39,1,1,3,9,6,130.0,130.0,0,0,0,NA,1,1,0,21,0,6,15,6,11.714285714285714,0,0,6,8,4,11.75,0,13.9,-0.3,0.79,2 +Student_03507,1,17,9254,1,1,1,1,37,37,5,1,126.0,126.0,0,0,0,0,1,0,0,29,0,6,12,0,0.0,0,0,6,6,0,0.0,6,9.4,-0.8,-3.12,0 +Student_03508,1,1,9670,1,1,1,1,1,1,4,9,131.0,122.3,0,0,0,1,1,0,0,19,0,5,6,5,11.5,0,0,5,5,5,11.6,0,9.4,-0.8,-3.12,2 +Student_03509,1,1,9147,1,1,1,1,19,19,9,7,130.0,119.5,1,0,0,1,1,1,0,18,0,5,7,4,11.25,0,0,5,6,4,12.25,0,12.4,0.5,1.79,1 +Student_03510,1,44,NA,1,1,39,1,1,1,9,9,130.0,131.8,0,0,0,1,1,1,0,22,2,7,7,7,12.285714285714286,0,5,9,10,8,NA,0,12.4,0.5,1.79,2 +Student_03511,1,17,9500,1,6,1,1,1,1,4,3,140.0,130.7,1,0,0,1,1,1,0,18,0,7,7,7,12.718571428571428,0,0,8,11,8,12.805555555555555,0,11.1,0.6,2.02,0 +Student_03512,1,44,9130,1,1,39,1,1,19,4,7,140.0,140.0,0,0,0,1,1,0,0,20,2,6,12,5,NA,0,1,6,11,2,15.0,0,13.9,-0.3,0.79,1 +Student_03514,4,39,9670,1,1,19,1,37,37,9,7,133.1,130.0,0,0,1,1,1,1,0,29,0,6,16,1,14.0,0,0,6,7,0,0.0,0,11.1,0.6,2.02,0 +Student_03515,1,39,9670,1,1,1,1,11,11,90,4,120.0,114.0,1,0,0,1,1,0,0,29,0,5,10,3,11.666666666666666,0,0,5,8,4,11.25,0,7.6,2.6,0.32,0 +Student_03516,1,43,9773,1,1,1,1,1,1,4,5,121.0,121.0,1,0,0,1,1,0,0,23,0,6,15,1,13.0,0,0,6,8,4,11.25,0,9.4,-0.8,-3.12,1 +Student_03518,1,1,9119,1,1,1,1,38,38,9,9,136.0,121.7,1,0,0,1,1,0,0,18,0,5,10,0,0.0,0,0,5,11,1,12.0,3,7.6,2.6,0.32,0 +Student_03519,2,42,9254,1,1,1,1,2,2,134,112,136.0,130.0,1,0,0,1,1,0,0,22,2,6,13,4,11.5,0,2,6,12,2,12.5,0,7.6,2.6,0.32,0 +Student_03520,1,43,9991,0,1,1,1,37,37,9,9,120.0,120.0,1,0,1,1,1,0,0,34,6,10,10,7,11.714285714285714,0,4,10,10,6,11.5,0,10.8,1.4,1.74,0 +Student_03521,1,43,9991,0,1,4,1,3,3,2,1,160.0,125.0,0,0,0,NA,1,0,0,26,0,5,7,5,12.6,0,0,5,7,5,13.714285714285714,0,13.9,-0.3,0.79,2 +Student_03522,1,17,171,1,1,1,1,37,37,7,9,NA,134.1,1,0,0,1,1,0,0,24,12,17,19,13,11.642857142857142,0,12,17,25,12,11.25,0,11.1,0.6,2.02,0 +Student_03523,1,1,9670,1,1,1,1,1,1,9,8,146.0,149.5,1,0,0,1,1,1,0,17,0,6,8,6,14.875,0,0,6,8,6,13.428571428571429,0,11.1,0.6,2.02,2 +Student_03525,2,39,9991,0,1,1,1,1,4,4,2,150.0,146.0,0,0,0,1,1,0,0,34,0,5,5,5,14.2,0,0,5,5,5,14.6,0,12.7,3.7,-1.7,1 +Student_03526,1,44,9003,1,1,39,1,19,38,6,7,140.0,140.0,1,0,0,1,1,0,0,19,0,6,8,6,12.714285714285714,0,0,6,9,6,13.5,0,12.4,0.5,1.79,2 +Student_03527,2,39,9003,1,1,1,1,1,3,4,2,111.0,162.4,0,0,1,0,1,0,0,49,4,12,16,5,11.6,0,2,7,7,5,11.2,0,8.9,1.4,3.51,0 +Student_03528,1,43,9500,1,1,1,1,2,4,4,5,120.0,136.6,0,0,0,1,1,0,0,23,0,7,14,5,11.94,0,0,7,14,6,12.2,0,13.9,-0.3,0.79,0 +Student_03529,1,18,9119,1,3,1,1,1,19,9,8,111.0,111.0,1,0,0,1,1,0,0,18,0,5,10,4,11.6,0,0,5,9,3,14.2,0,12.4,0.5,1.79,0 +Student_03530,1,1,9500,1,1,1,1,12,1,4,10,118.0,115.7,0,0,0,1,1,0,0,20,0,7,9,5,12.7,0,0,8,9,7,13.475,0,13.9,-0.3,0.79,1 +Student_03532,1,42,9003,1,1,39,NA,3,1,2,6,120.0,128.2,1,0,0,1,1,0,0,24,4,9,13,8,13.333333333333334,0,5,10,12,9,13.11111111111111,0,16.2,0.3,-0.92,1 +Student_03533,1,1,9147,1,1,1,1,1,38,4,7,151.0,137.0,1,0,0,1,1,0,0,18,0,5,5,5,13.4,0,0,5,5,5,15.0,0,8.9,1.4,3.51,2 +Student_03534,2,39,9254,1,1,19,1,34,34,0,0,NA,120.0,0,0,1,0,1,0,0,45,0,6,12,0,0.0,0,0,6,12,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03536,1,51,9991,0,1,39,1,1,4,4,10,120.0,118.1,0,0,0,1,1,0,0,28,13,15,17,13,12.0,0,9,13,13,9,11.333333333333334,0,8.9,1.4,3.51,0 +Student_03537,1,39,9991,0,1,1,1,37,37,9,9,110.0,139.0,0,0,0,1,1,0,0,40,0,5,0,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03538,1,39,9147,1,2,19,1,38,19,4,10,133.1,116.3,0,0,0,0,1,0,0,32,0,5,5,0,0.0,0,0,5,9,0,0.0,0,10.8,1.4,1.74,0 +Student_03539,1,17,9254,1,5,1,1,19,37,5,5,118.0,120.5,1,0,0,1,1,0,0,19,0,6,12,4,12.5,0,0,6,12,4,10.25,0,7.6,2.6,0.32,0 +Student_03540,1,1,9070,1,1,1,1,1,19,3,9,139.0,134.9,1,0,0,1,1,0,0,20,0,6,7,6,13.666666666666666,0,0,6,7,6,12.166666666666666,1,16.2,0.3,-0.92,2 +Student_03541,1,17,9119,1,1,1,1,1,3,4,2,130.0,123.0,0,0,0,1,1,0,0,18,0,5,10,1,10.0,0,0,5,7,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03542,1,17,9670,1,1,1,1,38,37,9,9,132.0,122.9,0,0,0,0,1,0,0,20,0,6,6,6,11.5,0,0,6,9,2,13.0,0,10.8,1.4,1.74,0 +Student_03543,1,39,9991,0,1,1,1,37,38,9,4,100.0,140.0,0,0,0,1,1,0,0,39,0,5,7,4,12.25,0,0,5,7,4,12.75,0,15.5,2.8,-4.06,1 +Student_03544,1,17,9085,1,1,1,1,19,38,4,8,120.0,122.5,0,0,0,0,1,0,0,19,0,6,11,5,13.6,0,0,6,11,5,13.666666666666666,0,11.1,0.6,2.02,1 +Student_03546,1,17,9500,1,3,1,1,19,37,4,9,156.0,132.3,1,0,0,1,1,1,0,18,0,7,7,6,13.266666666666666,0,0,7,7,6,13.266666666666666,0,7.6,2.6,0.32,2 +Student_03549,1,39,9670,1,1,1,1,37,37,9,9,140.0,148.0,1,0,0,0,1,0,0,31,0,6,14,0,0.0,0,0,6,6,0,0.0,0,12.7,3.7,-1.7,0 +Student_03552,1,39,9238,1,1,19,1,37,37,9,9,133.1,139.0,0,0,1,0,1,0,0,33,0,6,8,0,0.0,0,0,5,6,0,NA,0,16.2,0.3,-0.92,0 +Student_03556,1,44,9085,1,1,39,1,38,38,4,1,150.0,150.0,1,0,0,1,1,0,0,20,1,6,11,6,13.8,0,1,6,7,6,13.142857142857142,0,16.2,0.3,-0.92,2 +Student_03557,1,39,9254,1,1,12,1,37,37,5,7,133.1,119.3,1,0,0,1,1,0,0,25,0,6,7,6,11.166666666666666,0,0,6,11,4,11.8,0,9.4,-0.8,-3.12,1 +Student_03558,1,39,9003,1,1,1,1,1,1,9,4,130.0,140.0,0,0,0,0,1,0,0,25,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_03560,1,1,9670,1,1,1,1,2,1,2,4,141.0,140.7,1,0,0,1,NA,0,0,20,0,5,5,5,12.6,0,0,5,6,4,14.5,1,7.6,2.6,0.32,2 +Student_03561,2,39,9500,1,1,19,1,19,19,4,4,133.1,100.0,0,0,0,1,1,0,0,33,0,7,7,5,13.06,0,0,7,9,0,0.0,0,16.2,0.3,-0.92,1 +Student_03562,1,17,NA,1,5,1,1,1,37,5,5,146.0,146.7,1,0,0,1,1,0,0,19,0,6,7,6,13.833333333333334,0,0,6,8,6,13.625,0,7.6,2.6,0.32,2 +Student_03563,1,39,9130,1,1,19,1,34,34,99,99,133.1,96.0,0,0,0,1,1,0,0,31,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_03564,1,44,9119,1,1,39,1,3,38,2,3,160.0,160.0,0,0,1,0,1,0,0,24,2,6,6,2,16.0,0,2,7,7,2,16.0,0,8.9,1.4,3.51,0 +Student_03565,1,44,9119,1,1,39,1,19,3,3,4,130.0,130.0,0,0,1,0,1,0,0,23,0,5,5,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_03566,2,39,9991,0,1,1,1,1,3,1,2,160.0,130.0,0,0,0,0,1,1,0,26,0,5,12,3,10.666666666666666,0,0,5,11,3,10.666666666666666,0,9.4,-0.8,-3.12,0 +Student_03567,2,43,9070,1,1,2,1,37,37,6,6,140.0,140.0,1,0,0,1,1,0,0,38,14,18,18,18,14.5,0,13,18,18,18,14.5,0,16.2,0.3,-0.92,2 +Student_03568,1,1,9119,1,6,1,1,19,19,7,3,126.0,116.6,1,0,0,1,1,1,0,20,0,5,6,5,14.0,0,0,5,7,5,NA,0,8.9,1.4,3.51,2 +Student_03569,1,17,9119,1,5,1,1,1,19,9,9,118.0,120.5,1,0,0,1,1,0,0,20,0,5,10,3,13.333333333333334,0,0,5,11,5,NA,0,12.4,0.5,1.79,2 +Student_03570,1,39,9085,1,1,19,1,3,1,2,5,133.1,103.0,0,0,0,1,1,0,0,25,0,6,0,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_03571,1,17,9070,1,2,1,1,1,19,144,144,121.0,111.9,1,0,0,1,1,0,0,NA,0,6,9,5,12.0,0,0,6,10,4,11.2,0,8.9,1.4,3.51,2 +Student_03572,1,17,9119,1,1,1,1,1,38,4,5,148.0,148.7,0,0,0,1,1,0,0,18,0,5,6,5,16.2,0,0,5,8,5,16.0,0,8.9,1.4,3.51,2 +Student_03575,1,1,9254,1,1,1,1,1,38,9,9,132.0,120.1,1,0,0,1,NA,1,0,20,0,6,7,6,13.571428571428571,0,0,6,8,6,13.166666666666666,0,8.9,1.4,3.51,2 +Student_03576,1,1,9130,1,1,1,1,4,3,3,3,140.0,127.8,0,0,0,1,1,0,0,18,0,6,7,6,14.285714285714286,0,0,6,9,6,14.857142857142858,0,11.1,0.6,2.02,2 +Student_03577,1,17,9147,1,3,1,1,1,1,3,3,112.0,106.4,1,0,0,1,1,0,0,19,0,5,7,5,10.2,0,0,5,6,4,10.5,0,12.4,0.5,1.79,2 +Student_03579,1,17,9085,1,4,1,1,1,3,5,5,126.0,123.9,1,0,0,1,1,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_03583,1,39,9991,0,1,1,1,38,37,9,9,133.1,154.4,0,0,0,1,1,0,0,27,0,5,0,0,0.0,0,0,5,0,0,0.0,0,10.8,1.4,1.74,0 +Student_03584,1,17,9147,1,6,1,1,37,38,9,9,120.0,115.5,1,0,1,0,1,0,0,19,0,5,8,4,12.5,0,0,5,9,5,10.5,0,8.9,1.4,3.51,1 +Student_03585,1,39,8014,0,1,1,1,3,19,4,7,133.1,119.0,0,0,0,1,1,0,0,39,3,9,10,9,13.22222222222222,0,2,7,8,7,13.142857142857142,0,8.9,1.4,3.51,2 +Student_03586,1,39,33,1,1,1,1,19,37,9,9,133.1,96.1,0,0,0,1,1,0,0,25,0,7,13,2,15.0,0,0,7,12,2,11.5,0,12.4,0.5,1.79,0 +Student_03587,1,7,171,1,1,3,1,1,2,9,2,130.0,130.0,0,0,0,0,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03589,1,18,9773,1,1,NA,1,38,37,9,8,124.0,126.8,0,0,0,1,1,1,0,21,0,6,8,5,13.833333333333334,0,0,6,6,4,14.0,0,13.9,-0.3,0.79,2 +Student_03590,1,7,9991,0,1,40,1,1,3,4,NA,130.0,130.0,0,0,0,1,1,0,0,27,0,5,0,0,0.0,0,0,5,0,0,0.0,0,8.9,1.4,3.51,0 +Student_03591,1,1,9147,1,3,1,1,1,1,5,3,124.0,116.7,1,0,0,1,1,0,0,19,0,5,6,0,0.0,0,0,5,6,0,0.0,0,7.6,2.6,0.32,1 +Student_03593,1,7,9670,1,1,3,1,27,37,3,3,110.0,110.0,1,0,0,1,1,0,0,27,7,12,12,9,12.333333333333334,0,6,11,11,6,13.166666666666666,0,9.4,-0.8,-3.12,0 +Student_03595,1,1,9130,1,1,1,1,2,3,9,1,130.0,117.6,0,0,0,1,1,0,0,19,0,5,14,2,11.5,2,0,5,8,5,11.4,3,9.4,-0.8,-3.12,1 +Student_03596,1,44,9003,1,1,39,1,19,38,9,10,140.0,140.0,0,0,0,1,1,0,0,19,0,6,15,3,13.25,0,0,6,9,1,12.0,0,13.9,-0.3,0.79,0 +Student_03597,1,44,9003,1,1,39,1,19,1,1,1,150.0,150.0,0,0,0,1,1,0,0,22,0,6,12,3,13.333333333333334,0,0,6,12,3,12.75,0,15.5,2.8,-4.06,1 +Student_03598,1,16,9238,1,2,1,1,19,38,4,5,133.0,133.7,1,0,0,1,0,0,0,18,0,6,6,6,13.5,0,0,6,6,6,12.166666666666666,0,10.8,1.4,1.74,2 +Student_03599,1,16,9773,1,4,1,1,37,37,9,3,109.0,137.0,1,0,0,1,0,1,0,18,0,6,7,6,12.666666666666666,0,0,6,8,5,12.8,0,10.8,1.4,1.74,2 +Student_03600,1,43,9147,1,1,1,1,4,19,2,1,133.1,128.2,0,0,0,1,0,0,0,23,7,11,18,11,15.090909090909092,1,2,6,7,6,14.5,0,9.4,-0.8,-3.12,0 +Student_03601,1,18,171,1,4,1,1,1,4,9,5,133.0,129.2,1,0,1,0,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03603,1,1,9773,1,4,1,1,19,19,9,7,125.0,129.6,1,0,0,1,1,0,0,18,0,6,6,6,12.833333333333334,0,0,6,8,6,12.833333333333334,0,12.4,0.5,1.79,2 +Student_03604,1,17,9119,1,3,1,1,1,19,141,193,135.0,NA,1,0,0,1,1,0,0,18,0,5,7,5,11.8,0,0,5,9,3,12.0,0,8.9,1.4,3.51,1 +Student_03605,1,17,9773,1,2,1,1,19,1,9,9,132.0,141.8,1,0,0,1,1,0,0,20,0,6,6,6,11.833333333333334,0,0,6,6,6,12.166666666666666,0,12.7,3.7,-1.7,2 +Student_03606,1,1,9773,1,3,1,1,3,1,2,4,135.0,129.8,1,0,0,1,1,0,0,20,0,6,6,5,12.8,0,0,6,11,3,12.75,0,15.5,2.8,-4.06,2 +Student_03607,1,44,9070,1,1,39,1,1,1,4,4,100.0,106.0,0,0,0,1,1,0,0,21,2,7,7,5,11.8,0,5,9,9,5,11.0,0,12.4,0.5,1.79,0 +Student_03608,1,43,171,1,1,1,1,19,19,9,4,144.0,121.6,0,0,0,1,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,1 +Student_03609,1,17,9119,1,1,1,1,19,1,5,4,125.0,121.5,1,0,0,1,1,0,0,20,0,5,7,5,15.8,0,0,5,7,5,14.571428571428571,0,11.1,0.6,NA,0 +Student_03610,1,1,171,1,1,1,1,1,37,9,9,133.1,117.0,0,0,1,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,1 +Student_03611,1,44,9119,1,1,39,1,38,19,9,5,130.0,130.0,1,0,0,1,1,0,0,19,0,5,9,2,12.5,0,0,5,10,3,11.6,0,12.4,0.5,1.79,1 +Student_03612,1,17,9670,1,1,1,1,1,1,4,4,117.0,117.7,1,0,0,1,1,0,0,20,0,6,9,6,14.666666666666666,0,0,6,7,6,13.857142857142858,0,8.9,1.4,3.51,2 +Student_03613,1,44,9085,1,1,39,1,19,37,5,7,140.0,140.0,1,0,0,1,1,0,0,19,2,6,10,4,12.5,0,1,6,16,2,12.0,0,12.4,0.5,1.79,0 +Student_03614,1,1,9119,1,1,1,1,1,12,3,3,132.0,133.1,1,0,0,1,1,0,0,19,0,5,7,3,12.0,0,0,6,10,2,10.5,0,11.1,0.6,2.02,0 +Student_03615,1,15,9119,1,1,1,41,2,2,2,2,133.1,100.0,0,0,1,1,1,0,1,24,2,8,8,7,13.142857142857142,0,1,6,8,6,11.833333333333334,0,8.9,1.4,3.51,1 +Student_03616,1,17,9670,1,1,1,1,19,1,5,4,132.0,119.1,0,0,1,1,1,0,0,18,0,6,6,3,12.666666666666666,0,0,6,11,4,11.142857142857142,0,10.8,1.4,1.74,0 +Student_03618,1,1,9238,1,1,1,1,19,38,9,7,133.0,131.3,1,0,1,1,0,0,0,18,0,6,7,5,13.6,0,0,6,7,5,11.8,0,8.9,1.4,3.51,0 +Student_03620,1,17,9238,1,1,1,1,19,37,9,9,NA,126.2,1,0,0,NA,0,1,0,21,0,6,7,6,13.333333333333334,0,0,6,7,6,13.5,0,12.4,0.5,1.79,2 +Student_03621,1,15,9085,1,1,1,41,37,37,9,9,133.1,109.6,0,0,0,1,0,0,1,18,0,6,13,4,12.25,0,0,6,15,5,11.0,0,11.1,0.6,2.02,0 +Student_03622,1,1,9500,1,1,1,1,1,19,3,3,141.0,131.9,1,0,0,1,0,1,0,18,0,7,7,7,15.101428571428572,0,0,8,8,8,16.09375,0,11.1,0.6,2.02,2 +Student_03623,1,1,9238,1,2,1,1,19,37,9,9,NA,140.7,1,0,0,1,0,1,0,18,0,6,6,6,13.166666666666666,0,0,6,6,6,16.0,0,10.8,1.4,1.74,2 +Student_03626,1,1,9238,1,1,1,1,19,38,7,5,135.0,NA,0,0,0,1,0,0,0,20,0,6,13,1,10.0,0,0,6,13,1,13.0,0,9.4,-0.8,-3.12,1 +Student_03628,1,1,9773,1,6,1,1,1,19,4,4,145.0,131.0,1,0,0,1,0,1,0,18,0,6,6,6,12.166666666666666,0,0,6,10,5,11.2,0,7.6,2.6,0.32,1 +Student_03629,1,1,171,1,1,1,1,3,37,9,9,143.0,142.7,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_03630,1,1,9670,1,1,1,1,19,19,9,8,123.0,125.5,0,0,0,0,0,1,0,19,0,6,6,6,13.833333333333334,0,0,6,7,6,14.285714285714286,0,8.9,1.4,3.51,2 +Student_03631,1,1,9500,1,3,1,NA,19,1,9,3,108.0,107.8,1,0,0,1,0,1,0,20,0,7,10,6,12.357142857142858,0,0,8,9,7,13.0,0,13.9,-0.3,0.79,2 +Student_03632,1,1,9773,1,3,1,1,38,19,7,7,117.0,110.4,1,0,1,0,0,0,0,19,0,6,7,6,12.166666666666666,0,0,6,10,2,10.333333333333334,0,16.2,0.3,-0.92,0 +Student_03633,1,44,9238,1,1,39,1,37,19,191,102,140.0,136.1,1,0,1,1,0,0,0,21,3,6,8,3,12.0,0,2,6,6,2,12.5,0,12.4,0.5,1.79,1 +Student_03634,1,39,9254,1,1,1,1,37,37,4,6,170.0,138.3,0,0,0,1,0,0,0,33,5,10,14,9,12.416666666666666,0,5,9,14,7,13.0,0,10.8,1.4,1.74,2 +Student_03635,1,1,9085,1,2,1,1,3,38,4,6,157.0,142.3,0,0,0,1,0,0,0,18,0,5,7,4,12.75,0,0,5,6,4,12.75,0,7.6,2.6,0.32,2 +Student_03636,1,42,9500,1,1,6,1,37,1,9,4,141.0,145.0,0,0,0,1,0,0,0,21,12,21,33,18,14.933333333333334,12,12,21,33,18,14.933333333333334,12,7.6,2.6,0.32,2 +Student_03637,1,1,9773,1,1,1,1,3,19,2,3,125.0,125.7,1,0,0,1,0,0,0,19,0,6,6,6,13.0,0,0,6,7,6,11.666666666666666,0,8.9,1.4,3.51,2 +Student_03638,4,39,9853,1,1,19,1,38,19,9,9,133.1,108.0,0,0,1,0,0,0,0,33,0,7,7,7,12.857142857142858,0,0,7,8,6,12.666666666666666,0,8.9,1.4,3.51,1 +Student_03639,2,1,9500,1,4,1,1,38,38,5,5,143.0,128.7,1,0,0,1,0,0,0,18,0,7,10,7,14.455000000000002,0,0,8,8,8,13.91,0,15.5,2.8,-4.06,2 +Student_03640,1,1,9670,1,1,1,1,1,19,4,4,142.0,128.0,0,0,0,1,0,1,0,18,0,6,8,6,14.0,0,0,6,7,6,13.285714285714286,0,11.1,0.6,2.02,2 +Student_03641,1,1,9773,1,3,1,1,19,38,4,4,150.0,146.5,1,0,0,1,0,1,0,20,0,6,6,6,13.5,0,0,6,7,6,12.666666666666666,0,11.1,0.6,2.02,2 +Student_03642,1,1,9254,1,2,1,1,37,37,6,6,112.0,106.1,1,0,0,0,0,0,0,20,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03643,1,17,8014,0,2,1,1,19,1,1,1,133.1,118.0,0,0,0,1,0,1,0,20,0,6,6,6,11.666666666666666,0,0,6,12,5,14.0,0,10.8,1.4,1.74,2 +Student_03644,1,17,9085,1,1,1,1,1,37,4,9,125.0,117.0,1,0,0,1,0,1,0,19,0,5,6,4,12.0,0,0,5,8,5,13.333333333333334,1,10.8,1.4,1.74,2 +Student_03645,1,1,9238,1,3,1,1,38,37,8,8,121.0,115.4,1,0,0,1,0,1,0,19,0,6,7,6,11.714285714285714,0,0,6,6,6,11.833333333333334,0,13.9,-0.3,0.79,2 +Student_03646,1,17,9238,1,3,1,1,41,1,2,3,133.1,117.0,1,0,0,1,0,0,0,21,0,6,8,6,12.666666666666666,0,0,6,7,6,12.428571428571429,0,11.1,0.6,2.02,2 +Student_03647,1,39,9085,1,1,1,1,3,3,4,2,133.1,144.9,1,0,0,1,0,0,0,26,0,6,11,3,11.75,0,0,6,19,4,12.8,0,12.4,0.5,1.79,1 +Student_03648,1,17,9238,1,1,1,1,37,37,8,6,135.0,127.0,0,0,0,1,0,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_03649,1,1,9500,1,4,1,1,19,38,5,5,132.0,118.0,1,0,0,1,0,0,0,18,0,8,8,7,12.328571428571427,0,0,8,8,7,12.328571428571427,0,12.7,3.7,-1.7,2 +Student_03650,5,39,9853,1,1,19,1,37,37,9,8,133.1,118.0,0,0,0,1,0,0,0,27,0,7,14,6,11.666666666666666,0,0,7,10,1,10.0,0,12.4,0.5,1.79,0 +Student_03651,1,43,9070,1,1,1,1,1,38,3,9,135.0,126.4,1,0,0,1,0,1,0,20,5,12,12,12,13.25,0,5,12,12,11,12.727272727272728,0,15.5,2.8,-4.06,2 +Student_03652,1,43,9670,1,1,39,1,19,3,7,10,110.0,110.0,0,0,0,1,0,0,0,21,0,6,8,5,11.833333333333334,0,0,6,8,4,13.25,2,16.2,0.3,-0.92,1 +Student_03653,1,17,9556,1,1,1,1,38,37,9,9,133.0,NA,1,0,0,1,0,1,0,18,0,7,7,7,13.3,0,0,8,8,8,15.125,0,15.5,2.8,-4.06,2 +Student_03654,1,44,9085,1,1,39,1,1,19,9,9,140.0,140.0,1,0,0,1,0,0,0,20,1,6,13,6,12.555555555555555,0,1,6,11,5,11.8,0,16.2,0.3,-0.92,1 +Student_03655,1,1,9773,1,1,1,1,1,19,4,10,135.0,129.4,1,0,0,1,0,0,0,18,0,6,6,6,12.833333333333334,0,0,6,7,6,12.166666666666666,0,11.1,0.6,2.02,2 +Student_03656,1,44,9238,1,1,39,1,1,1,3,5,140.0,141.7,0,0,0,1,0,1,0,20,3,6,6,6,12.833333333333334,0,2,6,6,6,12.833333333333334,0,13.9,-0.3,0.79,2 +Student_03657,1,1,9085,1,2,1,1,1,19,4,10,144.0,132.1,1,0,0,1,0,1,0,19,0,5,10,3,12.666666666666666,1,0,5,7,3,13.0,0,12.7,3.7,-1.7,2 +Student_03658,1,1,9500,1,5,1,1,37,3,9,2,122.0,116.8,1,0,0,1,0,0,0,20,0,7,8,6,13.271428571428572,0,0,8,8,7,14.471428571428572,0,13.9,-0.3,0.79,2 +Student_03659,1,1,9991,0,1,1,1,19,37,5,8,143.0,135.0,0,0,0,1,0,1,0,20,0,5,5,5,12.4,0,0,5,6,5,12.833333333333334,0,10.8,1.4,1.74,2 +Student_03660,1,44,9085,1,1,39,1,38,1,5,5,150.0,150.0,0,0,0,1,0,0,0,20,0,5,10,2,14.5,1,0,5,7,4,11.25,0,12.7,3.7,-1.7,1 +Student_03662,1,1,9773,1,1,1,1,3,3,123,122,156.0,155.0,0,0,0,1,0,0,0,18,0,6,7,6,14.285714285714286,0,0,6,8,6,13.25,0,8.9,1.4,3.51,2 +Student_03663,1,1,9085,1,1,1,1,38,38,9,10,142.0,127.0,1,0,0,1,0,0,0,18,0,5,7,3,12.333333333333334,0,0,5,9,5,12.6,0,10.8,1.4,1.74,2 +Student_03664,1,17,9500,1,1,1,1,38,37,9,8,142.0,130.8,1,0,0,1,0,1,0,19,0,7,10,6,12.583333333333334,0,0,8,8,7,12.671428571428573,0,13.9,-0.3,0.79,2 +Student_03665,1,1,9500,1,6,1,1,12,37,5,9,126.0,121.8,1,0,0,1,0,0,0,19,0,7,8,6,13.731666666666667,0,0,8,10,7,13.771428571428572,0,12.4,0.5,1.79,0 +Student_03666,1,39,9003,1,1,19,1,37,37,9,4,133.1,140.0,0,0,0,1,1,0,0,43,0,6,8,6,12.875,0,0,6,14,5,12.142857142857142,0,16.2,0.3,-0.92,1 +Student_03667,2,42,9070,1,1,1,1,37,25,0,4,170.0,148.5,0,0,0,1,1,0,0,47,8,10,14,8,14.625,0,5,7,7,5,13.4,0,9.4,-0.8,-3.12,0 +Student_03668,1,42,9147,1,1,1,1,34,34,99,99,130.0,109.8,1,0,0,0,1,0,0,23,0,3,3,0,0.0,0,0,2,2,0,0.0,0,7.6,2.6,0.32,0 +Student_03670,1,42,9500,1,1,1,1,3,3,2,2,122.0,122.0,1,0,0,1,0,0,0,20,0,8,11,6,12.491666666666667,0,0,8,11,6,12.491666666666667,0,12.7,3.7,-1.7,2 +Student_03671,1,1,171,1,1,1,1,1,3,4,4,138.0,147.5,1,0,0,1,0,1,0,19,6,12,12,12,13.666666666666666,0,4,11,12,11,14.166666666666666,0,8.9,1.4,3.51,2 +Student_03672,1,17,9085,1,1,1,14,37,37,9,9,163.0,150.8,1,0,0,1,0,0,1,19,0,6,13,6,16.0,0,0,6,8,6,14.5,0,NA,2.8,-4.06,2 +Student_03673,1,44,9085,1,1,39,1,19,37,4,7,150.0,150.0,1,0,0,1,0,0,0,19,2,6,8,6,14.142857142857142,0,1,6,7,6,13.0,0,13.9,-0.3,0.79,2 +Student_03674,1,39,8014,0,1,19,1,19,19,144,141,133.1,131.5,0,0,1,1,0,1,0,39,0,6,9,6,11.833333333333334,0,0,6,9,4,13.75,0,11.1,0.6,2.02,2 +Student_03675,1,1,9070,1,1,1,1,1,1,3,5,144.0,127.2,1,0,0,1,0,1,0,20,0,6,6,6,12.666666666666666,0,0,6,8,6,13.0,0,10.8,1.4,1.74,2 +Student_03676,1,17,9070,1,1,1,NA,38,19,9,3,118.0,111.0,1,0,0,1,0,0,0,21,0,6,6,6,12.5,0,0,6,6,6,12.666666666666666,0,7.6,2.6,0.32,2 +Student_03679,1,17,9670,1,1,1,1,1,19,141,114,133.1,140.0,1,0,0,1,0,0,0,22,0,6,6,6,15.166666666666666,0,0,6,6,6,16.0,0,13.9,-0.3,0.79,2 +Student_03682,5,39,9147,1,1,1,1,19,19,9,9,133.1,119.8,0,0,0,1,1,0,0,26,0,5,9,5,12.0,0,0,5,5,5,10.2,0,11.1,0.6,2.02,1 +Student_03683,1,39,9991,0,1,1,1,37,37,9,9,110.0,121.8,0,0,0,0,1,0,0,36,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_03684,1,18,171,1,1,1,1,19,2,5,5,110.0,117.7,1,0,1,1,1,1,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,2 +Student_03687,1,1,9147,1,1,1,1,34,34,0,0,133.1,NA,0,0,0,1,1,0,0,26,11,15,15,11,10.818181818181818,0,12,14,15,11,11.636363636363637,1,7.6,2.6,0.32,0 +Student_03689,5,39,9238,1,1,1,1,19,38,9,10,130.0,146.0,0,0,0,1,1,0,0,34,0,6,8,5,12.6,0,0,6,11,4,11.25,0,12.4,0.5,1.79,2 +Student_03690,1,43,9130,1,1,1,1,1,1,1,1,130.0,130.0,1,0,0,1,1,0,0,33,0,5,12,1,13.0,2,0,5,7,3,14.0,0,9.4,-0.8,-3.12,1 +Student_03692,1,17,9119,1,5,1,1,19,1,4,5,130.0,118.1,1,0,1,0,1,0,0,26,0,5,11,1,10.0,0,0,5,14,1,11.0,0,8.9,1.4,3.51,0 +Student_03693,1,39,9670,1,1,1,1,38,37,7,7,140.0,105.2,0,0,0,1,1,0,0,29,0,6,7,1,14.0,0,0,6,6,0,NA,0,16.2,0.3,-0.92,0 +Student_03694,1,17,9119,1,5,1,1,19,37,9,7,131.0,123.3,1,0,0,1,1,1,0,19,0,5,9,5,12.6,0,0,5,8,2,12.5,0,8.9,1.4,3.51,0 +Student_03696,1,39,9991,0,1,19,1,19,37,9,9,133.1,149.4,0,0,0,0,1,0,0,29,0,5,11,2,11.333333333333334,0,0,5,9,1,12.0,0,11.1,0.6,2.02,0 +Student_03698,1,17,9254,1,1,1,1,1,1,4,10,119.0,125.0,0,0,0,1,1,0,0,19,0,6,7,5,10.8,0,0,6,10,2,10.5,0,10.8,1.4,1.74,1 +Student_03699,1,1,9500,1,1,NA,1,38,38,5,10,133.1,101.0,0,0,0,1,1,0,0,20,0,7,14,5,12.87857142857143,0,0,8,15,7,11.85625,0,15.5,2.8,-4.06,2 +Student_03700,1,1,9085,1,1,1,1,3,1,2,5,123.0,112.9,0,0,0,1,1,0,0,18,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_03701,1,17,9070,1,3,1,1,38,37,5,5,131.0,120.2,1,0,0,1,1,0,0,18,0,6,6,6,12.833333333333334,0,0,6,8,5,11.4,0,15.5,2.8,-4.06,1 +Student_03702,1,1,9147,1,1,1,1,34,34,99,99,120.0,111.6,0,0,1,1,1,1,0,21,0,5,5,5,12.6,0,0,5,9,3,12.833333333333334,0,10.8,1.4,1.74,1 +Student_03703,1,1,9147,1,1,1,1,1,1,4,2,125.0,134.1,1,0,0,1,1,0,0,20,0,5,0,0,0.0,0,0,5,0,0,0.0,0,8.9,1.4,3.51,0 +Student_03704,1,39,9119,1,1,1,1,37,37,9,9,133.1,101.6,0,0,0,1,1,1,0,30,0,5,11,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_03706,1,51,9147,1,1,1,1,1,19,9,6,148.0,118.4,1,0,0,1,1,0,0,30,0,5,7,5,13.4,0,0,5,7,4,13.25,0,8.9,1.4,3.51,0 +Student_03707,1,1,9147,1,1,1,1,38,1,5,5,139.0,127.1,1,0,0,1,1,1,0,22,0,5,8,5,11.2,0,0,5,13,4,11.25,0,12.7,3.7,-1.7,2 +Student_03708,1,17,171,1,3,1,1,37,37,5,10,125.0,120.5,1,0,0,1,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,2 +Student_03709,1,17,9070,1,4,1,1,1,1,9,10,128.0,136.1,1,0,1,0,1,0,0,19,0,6,6,6,12.666666666666666,0,0,6,8,5,11.8,0,11.1,0.6,2.02,0 +Student_03711,1,17,9085,1,4,1,1,38,38,151,151,137.0,141.6,0,0,0,1,1,0,0,21,0,5,7,4,12.25,0,0,5,7,5,12.0,0,7.6,2.6,0.32,2 +Student_03713,1,39,9147,1,1,1,1,1,19,4,7,120.0,110.0,0,0,0,1,1,0,0,27,0,5,13,3,10.75,0,0,5,9,3,10.333333333333334,0,15.5,2.8,-4.06,0 +Student_03714,1,43,33,1,1,1,1,37,37,1,1,134.0,100.0,1,0,0,1,1,0,0,32,0,7,7,0,0.0,0,0,7,8,0,0.0,0,13.9,-0.3,0.79,0 +Student_03715,1,NA,9670,1,1,12,1,37,1,9,3,133.1,120.0,0,0,1,0,1,0,0,40,0,6,13,0,0.0,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_03716,1,1,9147,1,2,1,1,37,1,5,3,116.0,124.8,1,0,0,1,1,0,0,20,0,5,9,2,14.333333333333334,0,0,5,10,2,12.5,0,7.6,2.6,0.32,1 +Student_03718,1,1,171,1,3,1,1,37,37,9,9,140.0,124.3,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,NA,2.6,0.32,2 +Student_03719,1,43,9147,1,1,1,1,1,38,1,7,122.0,118.9,0,0,0,1,1,0,0,21,0,5,11,2,10.5,0,0,5,13,0,0.0,0,12.7,3.7,-1.7,0 +Student_03720,1,17,9670,1,1,1,1,19,37,5,8,141.0,130.2,0,0,0,1,1,0,0,18,0,6,6,6,13.5,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03721,1,44,9003,1,1,1,1,1,3,144,123,120.0,120.0,0,0,0,1,1,0,0,19,0,6,17,1,11.0,0,0,6,19,0,0.0,0,16.2,0.3,-0.92,1 +Student_03722,5,7,9070,1,1,3,1,37,37,7,7,140.0,140.0,0,0,0,0,1,0,0,30,0,6,6,1,10.0,0,0,6,6,0,0.0,0,15.5,2.8,-4.06,0 +Student_03723,1,39,9003,1,1,12,1,19,1,9,1,133.1,130.0,0,0,0,1,1,0,0,29,0,6,17,0,0.0,2,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_03724,1,17,9119,1,2,1,1,1,1,4,4,137.0,130.4,1,0,1,1,1,0,0,18,0,5,10,1,12.0,0,0,5,7,3,10.666666666666666,2,7.6,2.6,0.32,0 +Student_03725,1,1,9670,1,2,1,1,1,1,9,9,122.0,116.1,1,0,0,1,1,1,0,18,0,5,6,4,NA,0,0,5,5,5,12.2,0,9.4,-0.8,-3.12,0 +Student_03726,1,44,9003,1,1,39,1,1,1,3,10,130.0,130.0,0,0,0,1,1,0,0,22,4,10,21,5,11.4,1,2,7,13,6,11.666666666666666,0,15.5,2.8,-4.06,0 +Student_03727,1,43,9991,0,2,1,1,37,37,5,5,140.0,124.3,1,0,0,0,1,0,0,27,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_03728,1,17,9670,1,6,1,1,NA,1,9,7,125.0,125.0,1,0,0,1,1,0,0,20,0,6,8,4,14.25,0,0,6,10,5,14.0,0,10.8,1.4,1.74,2 +Student_03730,1,1,9003,1,1,1,1,38,38,4,8,133.1,115.0,0,0,1,1,1,0,0,21,8,12,13,12,14.538461538461538,0,4,12,14,12,14.461538461538462,0,15.5,2.8,-4.06,2 +Student_03731,1,43,9500,1,1,1,1,1,38,7,7,132.0,NA,0,1,0,1,1,0,0,23,0,7,10,6,12.733333333333334,0,0,8,10,7,11.95,0,16.2,0.3,-0.92,2 +Student_03732,1,51,9070,1,1,1,1,38,38,9,9,122.0,128.8,1,0,0,1,1,0,0,21,4,12,13,5,13.2,0,4,12,12,4,13.5,0,8.9,1.4,3.51,0 +Student_03733,1,1,171,1,3,1,1,4,3,1,1,155.0,144.2,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_03734,2,39,9238,1,1,1,1,37,37,7,7,120.0,134.0,0,0,0,1,1,1,0,40,0,6,7,6,12.333333333333334,0,0,6,10,4,12.75,0,8.9,1.4,3.51,0 +Student_03735,1,43,9147,1,1,1,1,19,1,9,5,129.0,112.0,0,0,0,1,1,0,0,22,5,9,9,5,11.2,0,5,9,14,7,11.25,2,12.7,3.7,-1.7,0 +Student_03736,1,1,9500,1,2,1,1,38,37,9,9,144.0,128.8,1,0,0,1,1,0,0,19,0,7,7,6,13.2,0,0,7,7,6,13.2,0,7.6,2.6,0.32,2 +Student_03737,1,39,9119,1,1,1,1,19,37,9,9,130.0,134.0,0,0,0,1,1,1,0,24,0,5,8,5,11.833333333333334,0,0,5,8,4,14.0,0,12.7,3.7,-1.7,1 +Student_03738,1,1,9254,1,1,1,1,3,1,2,4,133.1,125.0,0,0,0,1,1,0,0,21,0,6,10,5,11.333333333333334,0,0,6,14,2,11.5,0,12.7,3.7,-1.7,1 +Student_03739,1,17,9119,1,4,1,1,3,1,9,3,133.0,123.2,1,0,0,1,1,0,0,18,0,5,5,5,13.6,0,0,5,6,5,14.6,0,8.9,1.4,3.51,2 +Student_03740,1,17,9119,1,3,1,1,37,37,9,7,131.0,NA,0,0,0,1,1,0,0,18,0,5,10,0,0.0,0,0,5,10,2,11.5,4,7.6,2.6,0.32,0 +Student_03741,1,51,9670,1,1,1,1,3,1,3,10,133.1,116.2,0,0,0,1,1,0,0,24,0,6,11,5,12.857142857142858,0,0,6,12,5,13.666666666666666,0,11.1,0.6,2.02,0 +Student_03742,1,39,9119,1,1,1,1,37,19,9,3,133.1,123.0,0,0,0,1,1,1,0,28,0,5,16,3,14.333333333333334,0,0,5,9,5,12.428571428571429,0,9.4,-0.8,-3.12,1 +Student_03743,1,17,9670,1,1,1,1,19,38,7,9,118.0,113.5,1,0,0,1,0,1,0,19,0,6,9,5,13.5,0,0,6,6,6,14.0,0,12.4,0.5,1.79,2 +Student_03744,1,51,9085,1,1,40,1,3,3,4,2,120.0,125.0,0,0,0,1,0,0,0,28,0,6,8,6,14.428571428571429,0,0,6,12,4,15.6,0,11.1,0.6,2.02,1 +Student_03745,1,17,9853,1,3,1,1,12,1,4,0,133.1,134.8,1,0,0,1,0,0,0,18,0,6,12,0,0.0,0,0,6,12,0,0.0,0,7.6,2.6,0.32,0 +Student_03747,1,1,9500,1,1,1,1,1,1,4,4,125.0,119.8,1,0,0,1,0,1,0,19,0,8,8,8,12.82875,0,0,8,8,8,12.82875,0,9.4,-0.8,-3.12,2 +Student_03748,1,43,9130,1,1,1,1,39,3,3,2,125.0,125.0,1,0,0,1,0,0,0,21,0,5,6,0,0.0,5,0,5,6,4,13.75,1,10.8,1.4,1.74,2 +Student_03749,1,1,9500,1,3,1,1,1,19,4,5,148.0,135.1,1,0,1,1,0,0,0,18,0,7,0,0,0.0,0,0,8,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_03751,1,17,9500,1,2,1,1,38,38,7,7,130.0,122.5,1,0,0,1,0,0,0,19,0,8,8,7,13.937142857142858,0,0,8,8,7,13.937142857142858,0,10.8,1.4,1.74,2 +Student_03752,1,1,9070,1,1,1,1,3,1,2,10,148.0,148.0,1,0,0,1,0,0,0,20,7,12,12,10,14.7,0,8,12,12,12,14.583333333333334,0,15.5,2.8,-4.06,2 +Student_03753,1,1,9773,1,2,1,1,1,1,9,4,130.0,126.2,1,0,0,1,0,0,0,18,0,6,6,6,11.666666666666666,0,0,6,6,5,12.2,0,12.7,3.7,-1.7,2 +Student_03754,1,43,9500,1,4,6,1,37,37,9,9,134.0,129.8,1,0,0,1,0,0,0,20,0,7,7,6,14.85,0,0,7,7,6,14.85,0,7.6,2.6,0.32,2 +Student_03755,1,39,9085,1,1,19,1,19,37,7,NA,133.1,104.0,0,0,0,1,0,0,0,26,0,5,11,1,12.0,1,0,5,12,0,0.0,4,10.8,1.4,1.74,0 +Student_03756,1,18,9500,1,4,1,1,3,1,3,4,137.0,126.7,1,0,0,1,0,0,0,18,0,7,8,7,13.6875,0,0,8,9,8,15.622222222222222,0,13.9,-0.3,0.79,0 +Student_03757,1,39,8014,0,1,1,1,37,37,9,9,130.0,120.0,0,0,0,1,0,0,0,58,0,6,14,5,12.4,0,0,6,10,5,11.6,0,9.4,-0.8,-3.12,2 +Student_03759,1,NA,9085,1,1,1,1,1,1,4,3,130.0,130.0,1,0,0,1,0,0,0,20,0,6,13,5,11.8,0,0,6,19,4,12.0,0,12.4,0.5,1.79,1 +Student_03760,1,17,9991,0,1,1,1,38,37,6,7,140.0,127.3,0,0,0,1,0,0,0,20,0,5,0,0,0.0,0,0,5,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03761,1,2,9147,1,1,1,1,37,37,9,9,150.0,122.0,1,0,0,1,0,0,0,29,13,15,19,13,11.76923076923077,0,12,14,17,14,11.928571428571429,0,9.4,-0.8,-3.12,2 +Student_03762,1,7,9238,1,1,3,1,1,1,4,10,130.0,125.1,0,0,1,0,0,0,0,27,0,6,8,0,0.0,0,0,5,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_03765,1,17,9238,1,1,1,1,19,38,3,7,125.0,114.9,0,0,0,1,0,1,0,19,0,6,13,6,11.5,0,0,6,9,5,12.2,0,11.1,0.6,2.02,2 +Student_03766,1,1,9500,1,1,1,1,37,38,6,6,141.0,125.6,1,0,0,1,0,1,0,22,0,7,9,6,13.081666666666669,0,0,8,12,6,13.15,0,11.1,0.6,2.02,2 +Student_03767,1,18,9070,1,3,1,1,38,37,9,7,138.0,125.1,1,0,0,1,0,1,0,19,0,6,6,6,12.666666666666666,0,0,6,6,6,NA,0,15.5,2.8,-4.06,2 +Student_03768,1,17,9773,1,1,1,1,37,1,9,8,116.0,115.7,1,0,1,0,0,0,0,19,0,6,6,3,11.333333333333334,0,0,6,6,0,0.0,0,12.4,0.5,1.79,0 +Student_03769,1,1,9853,1,3,1,1,3,3,2,2,122.0,112.6,1,0,0,1,0,0,0,23,0,6,8,5,13.6,0,0,6,8,5,11.6,0,7.6,2.6,0.32,1 +Student_03770,1,1,9773,1,3,1,1,1,1,4,4,131.0,127.2,1,0,0,1,0,1,0,18,0,6,6,6,13.166666666666666,0,0,6,7,5,13.2,0,12.4,0.5,1.79,0 +Student_03771,1,44,9130,1,1,39,1,1,19,4,8,140.0,140.0,0,0,0,1,NA,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03772,1,44,9003,1,1,39,1,1,1,4,3,140.0,140.0,1,0,0,1,0,0,0,20,0,6,10,5,11.666666666666666,0,0,6,7,5,12.6,0,12.4,0.5,1.79,2 +Student_03774,1,39,9085,1,1,19,1,37,37,9,9,133.1,100.0,1,0,1,0,0,1,0,26,0,6,7,0,0.0,0,0,6,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_03777,1,44,9003,1,1,39,1,3,1,2,6,160.0,160.0,1,0,0,0,0,0,0,20,0,6,10,6,13.375,0,0,6,10,6,13.0,0,16.2,0.3,-0.92,2 +Student_03778,1,1,9070,1,1,1,1,19,2,7,3,128.0,126.3,1,0,0,1,0,0,0,19,0,6,6,6,13.166666666666666,0,0,6,6,6,12.666666666666666,0,15.5,2.8,-4.06,2 +Student_03780,1,43,9556,1,1,1,1,2,3,3,2,126.0,100.0,0,0,0,1,0,0,0,25,2,7,10,3,13.0,0,1,8,10,3,11.666666666666666,4,10.8,1.4,1.74,1 +Student_03782,1,1,9070,1,3,1,1,1,38,4,7,139.0,142.2,1,0,0,1,0,1,0,19,0,6,6,6,12.833333333333334,0,0,6,6,6,12.833333333333334,0,9.4,-0.8,-3.12,2 +Student_03783,1,17,9853,1,2,1,1,1,19,5,5,125.0,119.4,1,0,0,1,0,0,0,18,0,7,10,7,NA,0,0,7,7,7,13.142857142857142,0,12.4,0.5,1.79,2 +Student_03784,1,1,9500,1,2,1,1,1,19,4,4,106.0,106.4,1,0,0,1,0,1,0,19,0,7,9,5,13.34,0,0,7,9,6,12.385714285714286,0,12.4,0.5,1.79,1 +Student_03785,1,7,8014,0,1,40,1,37,19,9,3,120.0,120.0,0,0,0,1,0,0,0,36,6,10,15,4,13.0,0,5,9,10,4,13.75,0,8.9,1.4,3.51,0 +Student_03786,1,44,9003,1,1,39,1,1,38,4,9,150.0,150.0,0,0,0,1,1,1,0,20,0,6,18,3,12.0,0,0,6,17,3,11.666666666666666,0,15.5,2.8,-4.06,1 +Student_03787,1,NA,171,1,2,1,41,1,1,2,3,130.0,148.6,1,0,0,1,1,0,1,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03789,1,44,9003,1,1,39,1,3,1,4,6,130.0,130.0,0,0,0,1,1,0,0,19,0,6,8,5,11.5,0,0,6,11,6,11.333333333333334,0,12.4,0.5,1.79,1 +Student_03790,1,17,9238,1,1,1,NA,1,44,4,2,140.0,124.6,1,0,1,0,1,0,0,20,3,9,9,3,13.333333333333334,0,2,6,6,2,12.5,0,8.9,1.4,3.51,0 +Student_03792,1,44,9130,1,1,39,1,3,1,3,6,130.0,130.0,1,0,1,1,1,0,0,20,2,6,9,4,11.0,0,1,6,13,3,10.666666666666666,0,12.4,0.5,1.79,0 +Student_03793,1,18,9119,1,1,1,1,19,1,90,3,122.0,116.1,1,0,1,0,1,0,0,24,0,5,8,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03794,1,17,9773,1,1,1,1,19,38,5,7,128.0,125.6,1,0,0,1,1,0,0,19,0,6,6,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_03795,1,17,9119,1,1,1,1,19,19,7,9,130.0,121.3,1,0,0,1,1,0,0,18,0,5,9,1,12.0,0,0,5,10,2,12.0,3,7.6,2.6,0.32,0 +Student_03796,1,1,9119,1,3,1,1,4,38,2,7,113.0,107.4,1,0,0,1,1,0,0,18,0,5,8,5,14.0,0,0,5,6,5,13.2,0,8.9,1.4,3.51,2 +Student_03797,1,1,9254,1,1,1,1,1,19,4,4,126.0,116.9,0,0,0,1,1,0,0,18,0,6,8,6,13.571428571428571,0,0,6,7,5,11.8,0,8.9,1.4,3.51,2 +Student_03798,1,43,9670,1,2,1,1,3,19,1,7,135.0,123.5,1,0,0,1,1,0,0,22,0,6,12,0,0.0,0,0,6,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_03799,1,1,9670,1,1,1,1,19,38,9,9,141.0,130.5,0,0,0,1,1,0,0,19,0,6,8,6,14.25,0,0,6,7,6,13.857142857142858,0,11.1,0.6,2.02,2 +Student_03801,1,17,9853,1,1,1,1,34,19,0,3,133.1,117.1,1,0,0,1,0,1,0,21,0,6,12,0,0.0,0,0,6,12,0,0.0,0,7.6,2.6,0.32,0 +Student_03802,1,18,9500,1,1,1,1,37,37,6,6,144.0,127.5,1,0,0,1,0,1,0,19,0,8,8,7,13.542857142857144,0,0,8,8,7,13.542857142857144,0,12.7,3.7,-1.7,2 +Student_03803,4,43,8014,0,1,1,1,38,37,9,9,140.0,126.0,0,0,0,1,0,1,0,39,3,9,9,9,13.11111111111111,0,2,7,10,7,11.714285714285714,0,12.7,3.7,-1.7,2 +Student_03804,1,43,8014,0,1,10,1,34,34,0,0,100.0,113.0,1,0,0,1,0,0,0,30,3,9,11,9,12.666666666666666,0,2,7,7,7,12.142857142857142,0,7.6,2.6,0.32,2 +Student_03805,1,1,9147,1,1,1,1,1,19,5,5,135.0,130.1,1,0,0,1,0,0,0,18,0,5,10,4,10.75,1,0,5,13,2,10.0,0,9.4,-0.8,-3.12,0 +Student_03806,2,43,9991,0,1,1,1,37,37,9,9,130.0,NA,1,0,0,1,0,0,0,38,4,10,14,4,10.75,0,2,10,10,2,10.0,0,7.6,2.6,0.32,0 +Student_03807,1,1,9070,1,3,1,1,34,37,5,7,147.0,NA,1,0,0,1,0,0,0,20,0,6,6,6,13.666666666666666,0,0,6,6,6,13.333333333333334,0,NA,-0.8,-3.12,2 +Student_03808,1,39,8014,0,1,19,1,34,34,0,0,149.0,126.3,0,0,0,1,0,0,0,55,0,6,6,6,13.833333333333334,0,1,6,6,6,12.833333333333334,0,7.6,2.6,0.32,2 +Student_03809,4,27,9070,1,1,2,1,34,34,0,0,130.0,130.0,0,0,0,1,0,0,0,53,15,18,18,17,13.176470588235292,0,13,18,18,16,NA,0,7.6,2.6,0.32,0 +Student_03810,2,39,8014,0,1,1,1,34,34,0,0,NA,104.0,0,0,0,1,0,0,0,54,0,6,8,4,NA,0,0,6,12,5,12.6,0,7.6,2.6,0.32,0 +Student_03811,1,43,9500,1,1,1,1,37,37,9,7,125.0,123.6,1,0,0,1,0,1,0,18,0,7,8,5,12.86,0,0,7,8,5,12.86,0,7.6,2.6,0.32,1 +Student_03812,1,39,8014,0,1,1,1,37,37,9,8,133.1,121.0,0,0,1,0,0,0,0,44,2,8,12,4,12.0,2,2,7,9,4,12.0,2,8.9,1.4,3.51,0 +Student_03813,1,43,9238,1,1,1,1,37,37,9,6,149.0,130.5,1,0,0,1,0,0,0,28,8,11,11,9,11.666666666666666,0,8,11,13,9,12.555555555555555,0,10.8,1.4,1.74,2 +Student_03814,1,7,8014,0,1,43,1,19,19,9,4,180.0,180.0,0,0,0,1,0,0,0,37,12,14,14,14,16.5,0,8,11,11,11,16.90909090909091,0,8.9,1.4,3.51,2 +Student_03815,1,43,9238,1,1,1,1,14,14,90,90,110.0,112.5,1,0,0,1,0,0,0,20,8,10,14,9,12.333333333333334,0,3,7,10,7,11.77777777777778,0,7.6,2.6,0.32,2 +Student_03816,1,1,9500,1,3,1,1,19,3,3,2,131.0,126.1,1,0,0,1,0,0,0,18,0,7,8,7,12.59125,0,0,8,11,7,12.820000000000002,0,15.5,2.8,-4.06,1 +Student_03817,1,1,9238,1,1,1,1,19,19,9,9,117.0,111.8,1,0,0,1,1,0,0,NA,0,6,9,4,11.5,0,0,6,12,3,11.0,0,8.9,1.4,3.51,0 +Student_03818,1,17,9003,1,1,1,1,38,37,5,9,120.0,131.4,1,0,0,1,1,1,0,23,17,18,19,18,11.894736842105264,0,12,13,13,13,12.923076923076923,0,15.5,2.8,-4.06,2 +Student_03819,1,17,9238,1,1,1,1,19,37,6,6,160.0,144.3,0,0,0,1,1,0,0,22,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_03822,1,39,9003,1,1,1,1,1,38,5,6,160.0,168.6,0,0,0,1,1,0,0,26,0,6,9,0,0.0,0,0,6,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_03824,1,44,9130,1,1,39,1,38,19,9,9,130.0,150.0,0,0,0,1,1,0,0,24,2,6,8,4,11.75,0,1,6,8,2,13.5,0,11.1,0.6,2.02,0 +Student_03825,1,1,9119,1,1,1,1,1,38,4,3,142.0,129.8,1,0,0,1,1,0,0,18,0,5,5,0,0.0,0,0,5,6,1,15.0,0,10.8,1.4,1.74,1 +Student_03826,1,1,171,1,1,1,NA,1,38,7,8,130.0,135.6,1,0,0,1,1,0,0,26,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03831,1,1,9500,1,3,1,1,1,1,4,4,143.0,129.0,1,0,0,1,1,0,0,18,0,8,8,7,12.365714285714288,0,0,8,8,7,12.365714285714288,0,10.8,1.4,1.74,2 +Student_03832,1,17,9670,1,1,1,1,37,37,9,9,128.0,135.7,1,0,0,1,1,0,0,19,0,6,7,5,13.2,0,0,6,10,5,13.25,0,10.8,1.4,1.74,1 +Student_03833,1,43,9070,1,1,1,1,37,37,9,9,100.0,108.0,1,0,0,1,1,0,0,34,7,12,12,7,11.428571428571429,0,4,12,12,7,11.857142857142858,0,7.6,2.6,0.32,1 +Student_03834,1,1,9238,1,1,1,1,38,19,8,10,116.0,110.8,1,0,0,1,1,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_03835,1,1,NA,1,1,1,1,1,19,4,4,128.0,124.5,0,0,0,1,1,1,0,19,0,6,10,4,14.0,0,0,6,9,6,12.333333333333334,0,9.4,-0.8,-3.12,2 +Student_03836,2,39,9003,1,1,1,1,2,2,1,4,120.0,100.0,0,0,0,1,1,0,0,30,3,12,12,3,12.0,0,5,12,16,5,11.8,0,15.5,2.8,-4.06,0 +Student_03837,1,43,9773,1,1,1,1,1,3,9,3,121.0,123.8,0,0,0,0,1,0,0,22,0,4,4,0,0.0,4,0,5,8,3,12.0,0,10.8,1.4,1.74,0 +Student_03838,1,17,9147,1,1,1,1,3,38,1,9,137.0,131.4,0,0,0,0,1,0,0,19,0,5,13,4,10.0,0,0,5,7,3,11.333333333333334,0,15.5,2.8,-4.06,0 +Student_03839,1,1,9147,1,1,1,1,38,1,9,8,115.0,118.5,0,0,0,1,1,0,0,21,0,5,9,1,10.0,0,0,5,10,1,10.0,0,7.6,2.6,0.32,0 +Student_03840,1,1,171,1,2,1,1,37,37,9,9,129.0,122.0,1,0,0,0,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,0 +Student_03841,1,1,9254,1,1,1,1,37,37,9,9,125.0,122.9,0,0,0,1,1,1,0,19,0,6,7,6,11.166666666666666,0,0,6,12,3,11.666666666666666,0,10.8,1.4,1.74,1 +Student_03842,1,1,9238,1,1,1,1,19,38,7,7,125.0,118.7,0,0,0,1,1,0,0,20,0,6,12,4,11.75,0,0,6,13,3,11.333333333333334,0,15.5,2.8,-4.06,1 +Student_03843,1,39,9003,1,1,19,1,3,1,2,8,133.1,100.0,1,0,0,1,1,0,0,35,0,6,13,3,11.75,0,0,6,10,0,0.0,0,13.9,-0.3,0.79,0 +Student_03844,1,16,9147,1,2,1,1,37,37,9,9,131.0,135.9,1,0,0,1,1,0,0,20,0,5,8,1,10.0,0,0,5,7,1,11.0,0,7.6,2.6,0.32,0 +Student_03845,1,1,9130,1,1,1,1,6,11,4,5,133.1,138.4,0,0,0,1,1,0,0,21,0,5,8,3,14.0,0,0,5,5,5,12.8,0,7.6,2.6,0.32,2 +Student_03847,1,43,9773,1,1,1,1,37,38,9,5,114.0,107.4,1,0,0,0,1,0,0,26,0,6,12,3,12.0,0,0,6,15,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03848,1,17,9773,1,1,1,1,1,33,3,3,127.0,129.8,0,0,0,0,1,0,0,20,0,6,10,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_03849,1,39,9003,1,1,1,1,37,37,6,6,130.0,100.0,0,0,1,0,1,0,0,28,4,10,19,8,11.88888888888889,0,2,8,17,5,11.6,1,15.5,2.8,-4.06,0 +Student_03850,1,1,9773,1,3,1,1,19,38,9,7,121.0,113.0,1,0,0,1,1,0,0,19,0,6,6,6,13.833333333333334,0,0,6,6,6,13.666666666666666,0,11.1,0.6,2.02,2 +Student_03851,1,43,9991,0,1,1,1,37,19,9,9,120.0,107.0,0,0,0,0,1,0,0,47,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_03852,4,39,9773,1,1,12,1,37,37,4,9,120.0,130.0,0,0,0,0,1,0,0,55,0,6,8,5,11.4,0,0,6,9,5,12.4,0,10.8,1.4,1.74,0 +Student_03853,1,43,9003,1,1,1,1,37,37,5,9,120.0,120.0,1,0,0,1,1,0,0,39,0,6,8,0,NA,0,1,6,8,2,11.0,0,16.2,0.3,-0.92,0 +Student_03854,2,1,9003,1,1,1,1,37,37,9,9,120.0,120.5,1,0,1,1,1,0,0,35,14,17,17,14,10.642857142857142,1,12,12,12,12,10.666666666666666,0,15.5,2.8,-4.06,0 +Student_03856,1,1,9773,1,4,1,1,3,12,2,9,124.0,137.0,1,0,0,1,NA,0,0,20,0,6,6,6,16.833333333333332,0,0,6,6,6,16.666666666666668,0,8.9,1.4,3.51,2 +Student_03858,1,39,9991,0,1,19,1,38,19,9,10,133.1,142.7,0,0,1,1,1,1,0,34,0,5,11,5,14.714285714285714,0,0,5,14,5,14.375,5,16.2,0.3,-0.92,2 +Student_03861,1,39,9003,1,1,19,1,37,19,9,7,133.1,134.3,0,0,0,1,1,0,0,25,0,6,15,1,11.0,0,0,6,13,4,11.75,0,12.4,0.5,1.79,0 +Student_03862,1,18,9773,1,1,1,1,38,38,6,7,167.0,153.0,1,0,0,1,1,1,0,18,0,6,6,1,11.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_03863,1,1,9773,1,1,1,1,19,38,9,9,140.0,132.0,0,0,0,1,1,1,0,18,0,6,6,5,12.0,0,0,6,6,6,12.833333333333334,0,12.7,3.7,-1.7,2 +Student_03865,1,43,9085,1,1,1,1,3,19,4,6,110.0,105.0,0,0,1,0,1,0,0,34,2,6,13,3,11.333333333333334,0,0,6,8,2,11.5,0,13.9,-0.3,0.79,0 +Student_03866,1,17,9773,1,2,1,1,1,1,4,5,150.0,130.8,0,0,0,1,1,0,0,20,0,6,15,2,12.0,0,0,6,12,0,0.0,0,10.8,1.4,1.74,0 +Student_03867,1,1,9500,1,1,1,1,37,37,7,7,123.0,119.7,0,0,0,1,1,0,0,20,0,7,8,0,0.0,1,0,7,7,0,0.0,0,13.9,-0.3,0.79,0 +Student_03868,1,17,9500,1,1,1,1,19,19,4,9,152.0,132.5,0,0,0,1,1,0,0,21,0,8,8,7,14.54,0,0,8,8,7,14.54,0,10.8,1.4,1.74,2 +Student_03869,1,44,9003,1,1,39,1,1,19,3,10,130.0,130.0,1,0,0,1,1,0,0,19,0,6,9,6,12.166666666666666,0,0,6,14,4,13.0,0,12.4,0.5,1.79,2 +Student_03870,1,39,9085,1,1,1,1,1,1,4,4,133.1,120.0,0,0,1,0,1,0,0,31,0,5,13,4,13.5,1,0,5,12,3,11.666666666666666,1,9.4,-0.8,-3.12,0 +Student_03871,1,17,9670,1,1,1,1,1,37,4,5,133.1,150.0,0,0,0,1,1,0,0,21,0,6,8,6,14.75,0,0,6,9,5,14.333333333333334,0,11.1,0.6,2.02,2 +Student_03872,1,1,9147,1,1,1,1,38,38,9,9,124.0,115.6,0,0,0,1,1,1,0,20,0,5,8,5,12.375,0,0,5,7,5,11.666666666666666,0,13.9,-0.3,0.79,2 +Student_03873,1,43,9500,1,2,6,NA,1,19,4,10,119.1,119.1,0,0,0,1,1,0,0,22,0,7,7,6,12.733333333333334,0,0,7,7,6,12.733333333333334,0,7.6,2.6,0.32,2 +Student_03874,1,1,9070,1,2,1,1,19,19,3,3,128.0,123.5,1,1,0,0,1,0,0,19,0,6,9,4,12.5,0,0,6,6,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03875,1,39,9130,1,1,1,NA,1,1,90,1,133.1,120.0,1,0,1,0,1,0,0,41,0,5,5,0,0.0,1,0,5,5,0,0.0,5,12.7,3.7,-1.7,0 +Student_03876,1,43,9500,1,1,19,1,34,34,0,0,133.1,110.0,1,0,0,1,1,0,0,27,0,7,7,0,0.0,6,0,7,7,0,0.0,6,7.6,2.6,0.32,0 +Student_03877,1,17,9500,1,1,1,1,1,1,4,10,NA,131.4,0,0,0,1,0,0,0,19,0,7,7,7,13.44285714285714,0,0,8,8,7,13.771428571428572,0,NA,-0.3,0.79,0 +Student_03879,1,43,9500,1,4,6,1,38,37,5,9,118.9,118.9,1,0,0,1,0,1,0,19,0,7,7,6,13.55,0,0,7,7,6,13.55,0,7.6,2.6,0.32,2 +Student_03880,2,39,9991,0,1,1,1,37,37,9,9,160.0,160.0,0,0,0,1,0,0,0,35,0,5,5,5,NA,0,0,5,6,5,11.166666666666666,0,15.5,2.8,-4.06,2 +Student_03881,1,17,9773,1,5,1,1,19,12,7,3,111.0,115.9,1,0,0,1,0,0,0,22,0,6,7,6,13.571428571428571,0,0,6,7,6,15.285714285714286,0,13.9,-0.3,0.79,2 +Student_03883,1,1,9670,1,1,1,1,37,38,9,9,123.0,113.9,1,0,1,0,0,0,0,18,0,6,7,4,11.25,0,0,6,9,4,10.857142857142858,0,10.8,1.4,1.74,0 +Student_03884,1,1,9238,1,1,1,1,37,37,9,9,133.0,121.8,1,0,0,1,0,1,0,18,0,6,7,5,10.2,0,0,6,9,4,11.25,0,12.4,0.5,1.79,2 +Student_03885,1,7,9500,1,1,3,1,1,37,9,5,140.0,140.0,0,0,0,1,0,0,0,30,0,8,8,7,15.675714285714283,0,0,8,8,7,15.675714285714283,0,10.8,1.4,1.74,2 +Student_03889,1,17,9085,1,1,1,1,38,38,5,3,139.0,NA,0,0,0,1,0,0,0,19,0,5,7,5,13.0,1,0,5,7,5,13.333333333333334,0,7.6,2.6,0.32,2 +Student_03890,1,1,9556,1,2,1,1,1,38,3,8,130.0,119.5,1,0,0,1,0,1,0,21,0,7,7,7,12.242857142857144,0,0,8,8,8,14.125,0,15.5,2.8,-4.06,2 +Student_03891,1,18,9853,1,1,1,1,1,19,141,182,133.1,106.0,1,0,1,1,0,0,0,21,0,7,7,7,13.0,0,0,7,8,6,12.5,0,8.9,1.4,3.51,1 +Student_03892,1,1,9670,1,4,1,1,1,1,9,9,130.0,124.1,1,0,0,1,0,0,0,18,0,6,6,6,14.166666666666666,0,0,6,7,6,13.428571428571429,0,8.9,1.4,3.51,1 +Student_03893,1,1,9147,1,3,1,1,1,1,5,7,143.0,NA,1,0,0,1,0,1,0,18,0,5,11,4,14.25,0,0,5,7,4,12.5,0,12.7,3.7,-1.7,2 +Student_03894,4,39,9085,1,1,NA,1,37,37,90,90,110.0,110.0,0,0,0,0,0,0,0,35,0,5,14,1,12.0,2,0,5,11,2,10.5,1,9.4,-0.8,-3.12,0 +Student_03896,1,1,9500,1,1,1,1,38,37,9,7,140.0,130.0,1,0,0,1,1,1,0,18,0,7,7,6,13.183333333333332,0,0,7,7,6,13.183333333333332,0,7.6,2.6,0.32,2 +Student_03897,1,17,9070,1,5,1,1,19,1,5,5,125.0,122.6,1,0,0,1,1,0,0,22,0,6,6,1,11.0,0,0,6,6,0,0.0,0,9.4,-0.8,-3.12,1 +Student_03899,2,39,9254,1,1,1,1,37,37,4,7,130.0,120.0,1,0,0,1,0,0,0,34,0,6,7,5,12.4,0,0,6,8,5,12.8,0,9.4,-0.8,-3.12,2 +Student_03900,2,7,9147,1,1,3,1,37,37,9,9,120.0,120.0,0,0,0,1,0,0,0,33,3,8,9,5,12.6,2,2,7,13,5,11.25,0,10.8,1.4,1.74,1 +Student_03901,1,1,9500,1,3,1,1,37,38,9,9,142.0,137.3,1,0,0,1,0,1,0,22,0,7,7,6,13.9,0,0,7,7,6,13.9,0,NA,2.6,0.32,2 +Student_03903,2,39,9147,1,1,1,1,37,37,6,10,140.0,131.8,0,0,0,1,0,0,0,35,0,5,6,4,14.2,0,0,5,10,4,11.857142857142858,0,10.8,1.4,1.74,1 +Student_03904,2,39,9147,1,1,1,1,38,37,4,7,140.0,130.0,1,0,0,0,0,0,0,39,0,5,12,3,10.666666666666666,2,0,5,15,3,10.666666666666666,0,9.4,-0.8,-3.12,0 +Student_03905,1,18,9500,1,6,1,1,38,37,9,5,142.0,128.0,1,0,0,0,0,0,0,19,0,7,14,0,0.0,0,0,8,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03906,4,39,9254,1,1,1,1,NA,37,9,8,120.0,95.0,0,0,0,1,0,1,0,36,0,6,10,6,11.0,0,0,6,14,3,11.333333333333334,0,10.8,1.4,1.74,2 +Student_03908,1,1,9238,1,1,1,1,3,38,1,5,157.0,136.7,1,0,0,1,0,0,0,NA,0,6,11,4,12.5,1,0,6,13,3,13.666666666666666,0,9.4,-0.8,-3.12,1 +Student_03910,1,39,9119,1,1,1,1,37,37,90,90,110.0,108.4,1,0,0,1,0,0,0,34,0,5,5,0,0.0,0,0,5,6,0,0.0,0,10.8,1.4,1.74,0 +Student_03911,1,17,9773,1,1,1,1,19,19,4,4,144.0,130.7,1,0,0,1,0,0,0,20,0,6,9,6,11.666666666666666,0,0,6,8,5,11.6,0,7.6,2.6,0.32,1 +Student_03912,2,44,8014,0,1,39,1,37,19,9,10,160.0,155.9,0,0,0,1,0,0,0,33,3,6,7,6,15.714285714285714,0,2,6,7,6,15.5,0,13.9,-0.3,0.79,2 +Student_03913,1,1,9254,1,4,1,1,1,19,9,6,105.0,106.1,1,0,0,1,0,0,0,20,0,6,8,5,11.0,0,0,6,9,5,11.4,0,13.9,-0.3,0.79,2 +Student_03915,2,43,9991,0,1,3,1,37,19,9,4,140.0,140.0,0,0,1,1,0,0,0,34,4,10,25,5,12.2,0,3,9,18,8,12.22222222222222,0,16.2,0.3,-0.92,0 +Student_03916,1,1,9147,1,1,1,1,37,37,9,6,138.0,145.0,1,0,0,1,0,0,0,18,0,5,6,5,13.0,0,0,5,5,5,14.0,0,7.6,2.6,0.32,2 +Student_03917,1,17,8014,0,1,1,1,38,37,6,6,120.0,113.0,0,0,0,1,0,1,0,24,0,6,11,4,12.0,0,0,6,7,6,13.0,0,10.8,1.4,1.74,2 +Student_03919,1,1,9670,1,1,1,1,37,37,10,6,119.0,119.7,1,0,0,1,0,0,0,20,0,5,6,3,13.0,0,0,5,7,3,13.0,1,7.6,2.6,0.32,1 +Student_03920,1,17,9500,1,1,1,1,1,1,4,3,121.0,120.5,1,0,0,1,0,0,0,21,0,8,8,7,12.91,0,0,8,8,7,12.91,0,10.8,1.4,1.74,2 +Student_03921,1,1,9238,1,5,1,1,38,1,9,5,126.0,125.7,1,0,0,1,0,1,0,19,0,6,8,6,11.0,0,0,6,13,3,11.0,0,9.4,-0.8,-3.12,2 +Student_03922,1,17,9500,1,4,1,1,38,19,5,7,132.0,125.5,0,0,0,1,0,1,0,19,0,7,8,6,13.579999999999998,0,0,8,8,8,12.93625,0,15.5,2.8,NA,2 +Student_03923,1,1,9238,1,1,1,1,19,19,5,5,128.0,124.5,1,0,0,1,0,1,0,18,0,6,10,4,12.4,0,0,6,8,6,12.5,0,12.4,0.5,1.79,2 +Student_03924,4,39,8014,0,1,1,1,37,37,5,5,160.0,126.0,0,0,0,1,0,1,0,38,4,9,13,8,12.88888888888889,0,2,7,9,7,13.0,0,13.9,-0.3,0.79,2 +Student_03925,1,1,171,1,1,1,1,19,19,5,4,125.0,136.2,1,0,1,1,1,0,0,21,6,12,12,11,11.545454545454543,0,4,11,18,9,11.7,1,8.9,1.4,3.51,1 +Student_03926,1,43,9147,1,1,1,25,1,5,9,10,127.0,124.2,1,0,0,1,1,0,1,23,0,5,6,1,10.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,1 +Student_03927,1,17,9500,1,5,1,1,19,1,4,3,147.0,138.5,1,0,0,1,0,0,0,19,0,8,8,8,14.34125,0,0,8,8,8,14.34125,0,9.4,-0.8,-3.12,2 +Student_03928,1,1,9773,1,2,1,1,38,37,5,3,130.0,122.3,1,0,1,0,0,0,0,18,0,6,8,6,14.142857142857142,0,0,6,6,5,12.0,0,13.9,-0.3,0.79,0 +Student_03929,1,1,171,1,6,1,1,19,37,5,5,134.0,126.0,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_03930,1,39,9003,1,1,1,1,19,19,9,6,140.0,135.4,1,0,0,1,0,0,0,24,0,6,10,5,11.8,0,0,6,13,4,11.25,0,12.4,0.5,1.79,1 +Student_03931,1,1,9773,1,1,1,2,1,1,5,9,151.0,146.5,0,0,0,1,0,1,1,18,0,6,6,6,13.333333333333334,0,0,6,6,6,14.166666666666666,0,12.7,3.7,-1.7,2 +Student_03932,1,1,9130,1,1,1,1,3,1,4,9,132.0,121.9,1,0,0,1,0,0,0,18,0,6,8,6,14.5,0,0,6,9,6,12.857142857142858,0,13.9,-0.3,0.79,2 +Student_03935,1,18,9670,1,3,1,1,38,38,9,9,119.0,115.2,1,0,0,1,0,1,0,19,0,6,10,0,0.0,0,0,6,6,0,0.0,0,12.7,3.7,-1.7,0 +Student_03938,1,1,9254,1,3,1,1,19,19,9,9,121.0,125.9,1,0,0,1,0,0,0,22,0,6,10,4,10.0,0,0,6,12,2,13.5,0,9.4,-0.8,-3.12,1 +Student_03939,1,1,9500,1,2,1,1,19,1,5,5,138.0,128.0,1,0,0,1,0,0,0,19,0,7,7,7,14.20857142857143,0,0,8,9,8,15.127777777777778,0,11.1,0.6,2.02,2 +Student_03940,1,1,9500,1,5,1,1,3,1,5,10,118.0,113.5,1,0,0,1,0,0,0,20,0,7,7,7,14.30714285714286,0,0,8,8,8,15.0125,0,12.4,0.5,1.79,2 +Student_03942,1,39,9853,1,1,19,1,19,4,9,4,133.1,116.0,1,0,0,1,0,0,0,29,0,7,14,0,0.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_03943,1,17,9238,1,3,1,1,3,3,2,2,141.0,124.9,1,0,0,1,0,0,0,19,0,6,10,6,12.0,0,0,6,12,4,11.0,0,12.7,3.7,-1.7,2 +Student_03946,1,17,9773,1,1,1,1,37,37,9,8,115.0,116.1,1,0,0,1,0,1,0,18,0,6,7,6,13.857142857142858,0,0,6,7,6,14.285714285714286,0,13.9,-0.3,0.79,2 +Student_03947,1,17,171,1,2,1,1,3,1,2,6,142.0,139.4,1,0,0,1,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,2 +Student_03948,1,17,9556,1,4,1,1,38,37,3,7,135.0,129.0,1,0,0,1,0,0,0,21,0,7,0,0,0.0,0,0,7,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03949,2,39,9670,1,1,1,1,37,19,9,4,150.0,135.6,0,0,0,1,0,1,0,43,0,6,8,5,11.0,0,0,6,9,5,13.0,0,12.4,0.5,1.79,2 +Student_03951,1,18,9085,1,1,1,1,37,37,9,9,153.0,138.0,1,0,0,1,0,1,0,21,0,6,7,6,13.5,0,0,6,6,3,15.333333333333334,0,8.9,1.4,3.51,0 +Student_03952,1,7,9147,1,1,3,1,6,27,1,7,150.0,150.0,0,0,0,1,0,0,0,26,0,5,5,0,0.0,0,0,5,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03953,1,1,9500,1,6,1,1,1,19,9,4,144.0,130.8,1,0,0,1,0,1,0,19,0,8,8,7,14.214285714285714,0,0,8,8,7,14.214285714285714,0,12.7,3.7,-1.7,2 +Student_03954,1,1,9085,1,1,1,1,37,11,90,90,130.0,122.6,0,0,0,1,0,0,0,18,0,5,5,5,13.0,0,0,5,5,5,12.4,0,7.6,2.6,0.32,2 +Student_03955,1,1,9773,1,1,1,1,3,2,2,1,125.0,119.1,1,0,0,1,0,0,0,22,0,6,13,2,12.0,0,0,6,14,1,10.0,0,9.4,-0.8,-3.12,0 +Student_03957,1,1,9147,1,3,1,1,38,19,9,10,133.0,125.0,1,0,0,1,0,0,0,18,0,5,6,5,12.8,1,0,5,6,5,12.6,0,9.4,-0.8,-3.12,2 +Student_03958,1,17,9085,1,1,1,1,37,38,7,9,140.0,129.9,0,0,0,1,0,0,0,19,0,5,11,4,13.6,2,0,5,9,4,12.2,0,9.4,-0.8,-3.12,2 +Student_03959,1,17,9500,1,4,1,1,19,19,3,10,133.0,131.1,1,0,0,1,0,0,0,18,0,7,7,7,13.971428571428572,0,0,8,8,8,15.75,0,13.9,-0.3,0.79,2 +Student_03960,1,1,9085,1,1,1,1,38,37,4,4,154.0,141.4,0,0,0,1,0,1,0,19,0,6,8,6,15.0,0,0,6,9,6,14.857142857142858,0,11.1,0.6,2.02,2 +Student_03961,1,39,9085,1,1,1,1,37,37,9,9,133.1,120.0,0,0,0,0,0,0,0,32,0,6,0,0,0.0,0,0,6,0,0,NA,0,11.1,0.6,2.02,0 +Student_03963,1,17,9500,1,3,1,1,37,37,4,3,132.0,127.3,1,0,0,1,0,0,0,20,0,7,7,6,13.383333333333333,0,0,7,7,6,13.383333333333333,0,7.6,2.6,0.32,2 +Student_03965,1,17,9238,1,1,1,1,19,19,4,5,120.0,114.8,1,0,1,0,0,0,0,19,0,6,10,5,11.714285714285714,0,0,6,13,2,10.666666666666666,0,16.2,0.3,-0.92,0 +Student_03966,1,1,9500,1,3,1,1,19,19,5,5,150.0,132.8,1,0,0,1,0,1,0,18,0,8,8,8,13.01125,0,0,8,8,8,13.01125,0,9.4,-0.8,-3.12,2 +Student_03968,1,1,9500,1,1,1,1,1,19,9,9,103.0,108.3,0,0,0,1,0,1,0,20,0,7,14,0,0.0,0,0,7,15,0,0.0,0,11.1,0.6,2.02,1 +Student_03969,1,44,9085,1,1,39,1,3,19,2,4,150.0,150.0,1,0,0,1,0,0,0,22,1,6,9,6,13.0,0,1,6,18,3,12.666666666666666,0,12.4,0.5,1.79,2 +Student_03970,1,44,9991,0,1,39,1,37,37,9,9,160.0,NA,0,0,0,1,0,0,0,26,0,5,5,5,12.0,0,0,5,7,5,11.4,0,12.7,3.7,-1.7,2 +Student_03971,1,1,9070,1,1,1,1,37,37,3,3,131.0,131.7,1,0,0,1,0,0,0,20,0,6,6,6,12.166666666666666,0,0,6,7,5,13.8,0,12.7,3.7,-1.7,2 +Student_03972,1,1,9500,1,1,1,1,19,38,5,3,114.0,112.6,1,0,0,1,0,0,0,19,0,7,10,6,11.85,0,0,8,10,7,13.65,0,16.2,0.3,-0.92,2 +Student_03974,1,43,9500,1,3,1,1,1,19,9,7,140.0,127.5,1,0,1,1,0,1,0,20,0,7,9,7,12.327777777777778,0,0,8,10,8,11.736,0,15.5,2.8,-4.06,2 +Student_03975,1,43,9085,1,1,1,1,19,38,7,7,130.0,120.2,1,0,0,1,0,0,0,20,0,5,9,4,12.0,0,0,5,10,5,13.428571428571429,1,10.8,1.4,1.74,2 +Student_03976,1,17,9500,1,4,1,1,37,37,5,5,121.0,118.9,1,0,0,1,0,0,0,21,0,7,7,7,14.428571428571429,0,0,8,9,8,14.511111111111113,0,16.2,0.3,-0.92,2 +Student_03978,1,17,9500,1,2,1,1,37,1,9,4,141.0,127.3,1,0,0,1,0,1,0,19,0,7,7,6,13.8,0,0,7,7,6,13.8,0,7.6,2.6,0.32,2 +Student_03979,1,1,9853,1,1,1,1,NA,19,3,7,131.0,127.9,1,0,0,1,0,1,0,NA,0,7,7,7,14.857142857142858,0,0,7,7,7,15.142857142857142,0,13.9,-0.3,0.79,2 +Student_03981,1,17,9238,1,6,1,1,1,38,4,7,117.0,114.6,0,0,0,1,0,1,0,18,0,6,7,6,12.142857142857142,0,0,6,6,6,13.333333333333334,0,13.9,-0.3,0.79,2 +Student_03983,1,17,9500,1,1,1,1,1,19,4,3,131.0,125.4,1,0,0,1,0,0,0,19,0,7,13,5,12.5,0,0,8,14,7,12.166666666666666,0,15.5,2.8,-4.06,2 +Student_03985,1,39,9003,1,1,1,1,38,38,9,6,135.0,138.1,0,0,1,0,0,0,0,28,0,6,6,0,0.0,0,0,6,7,0,0.0,0,8.9,1.4,3.51,0 +Student_03987,1,1,9773,1,2,1,1,NA,37,9,9,122.0,130.8,1,0,0,1,0,0,0,18,0,6,14,4,11.25,0,0,6,9,5,13.0,0,9.4,-0.8,-3.12,2 +Student_03988,1,1,9500,1,2,1,1,1,1,4,3,155.0,140.5,1,0,0,1,0,0,0,18,0,7,7,6,15.25,0,0,7,7,6,15.25,0,7.6,2.6,0.32,2 +Student_03989,1,1,9085,1,1,1,1,19,37,9,9,123.0,124.1,1,0,0,1,0,1,0,20,0,5,13,5,14.0,2,0,5,10,3,12.0,1,9.4,-0.8,-3.12,2 +Student_03990,1,43,9238,1,1,1,1,38,19,9,4,130.0,118.4,0,0,1,1,0,0,0,28,15,16,16,13,12.076923076923077,0,13,13,13,11,12.090909090909092,0,16.2,0.3,-0.92,2 +Student_03991,1,15,9853,1,1,1,41,43,1,153,135,133.1,128.2,0,0,0,1,0,0,1,23,11,16,17,16,14.625,0,6,10,12,9,14.88888888888889,0,8.9,1.4,3.51,2 +Student_03992,1,1,9853,1,1,1,1,19,37,5,5,114.0,109.5,1,0,0,1,0,0,0,19,0,7,10,4,10.5,0,0,7,7,2,10.5,0,16.2,0.3,-0.92,0 +Student_03993,1,17,9238,1,1,1,1,38,19,152,171,137.0,131.1,1,0,0,1,0,1,0,18,0,6,8,6,12.833333333333334,0,0,6,6,6,12.166666666666666,0,8.9,1.4,3.51,2 +Student_03994,1,1,9773,1,3,1,22,37,37,9,9,161.0,137.9,0,0,1,0,0,1,1,20,0,6,6,6,12.5,0,0,6,7,5,11.8,0,10.8,1.4,1.74,2 +Student_03995,1,1,171,1,1,1,1,3,1,2,4,133.1,128.2,1,0,0,1,0,0,0,20,5,12,13,12,11.23076923076923,0,3,11,18,9,12.77777777777778,0,NA,0.6,2.02,2 +Student_03996,2,39,9991,0,1,1,1,37,37,9,9,133.1,126.5,0,0,0,1,0,0,0,27,0,5,5,2,10.5,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_03998,4,39,9556,1,2,19,1,19,19,4,6,133.1,123.0,0,0,0,1,0,1,0,37,0,7,10,7,10.985714285714286,0,0,8,11,8,12.3,0,10.8,1.4,1.74,2 +Student_03999,4,7,9500,1,1,40,1,19,19,4,6,130.0,130.0,0,0,0,0,0,0,0,42,2,7,10,5,12.62,0,3,7,11,3,14.166666666666666,0,12.4,0.5,1.79,0 +Student_04001,2,39,9119,1,1,1,1,34,34,9,9,140.0,140.0,0,0,0,0,1,0,0,34,0,5,5,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_04002,1,42,9119,1,1,1,1,3,3,3,2,140.0,133.6,1,0,0,1,1,0,0,22,0,5,0,0,0.0,0,0,5,0,0,0.0,0,10.8,1.4,1.74,0 +Student_04003,2,39,9254,1,2,NA,1,19,19,9,5,133.1,123.5,0,0,0,NA,1,0,0,39,0,6,6,6,13.5,0,0,6,6,6,13.333333333333334,0,NA,0.5,1.79,2 +Student_04004,1,1,9500,1,1,1,1,37,37,9,9,141.0,136.3,1,0,0,1,1,1,0,18,0,7,7,6,13.516666666666666,0,0,7,7,6,13.516666666666666,0,7.6,2.6,0.32,2 +Student_04005,1,1,9070,1,2,1,1,37,37,9,9,128.0,123.5,1,0,0,1,1,1,0,21,0,6,6,6,13.166666666666666,0,0,6,8,6,13.285714285714286,0,8.9,1.4,3.51,2 +Student_04007,1,44,9003,1,1,39,1,37,37,9,9,160.0,160.0,0,0,0,1,1,1,0,22,0,6,8,6,13.125,0,0,6,10,6,13.0,0,16.2,0.3,-0.92,2 +Student_04008,1,39,9003,1,1,1,1,1,37,4,7,133.1,110.0,0,0,0,1,1,0,0,31,0,6,15,3,14.4,0,0,6,20,0,0.0,0,16.2,0.3,-0.92,0 +Student_04009,1,18,9853,1,3,1,1,38,37,5,9,128.0,116.8,1,0,0,0,1,0,0,19,0,6,10,4,12.0,0,0,6,12,0,0.0,0,10.8,1.4,1.74,0 +Student_04010,1,17,9254,1,5,1,1,38,1,5,9,114.0,109.5,0,0,0,1,1,0,0,19,0,5,5,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_04012,1,5,9147,1,1,1,1,19,38,5,6,126.0,117.3,1,0,0,1,0,0,0,19,0,5,15,3,10.8,0,0,5,6,3,10.5,0,13.9,-0.3,0.79,1 +Student_04013,2,39,9670,1,2,1,41,37,19,9,9,133.1,130.0,0,0,0,1,0,0,1,30,0,6,0,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_04014,1,51,9500,1,1,1,1,37,38,3,3,129.0,137.8,1,0,0,1,0,1,0,20,2,7,7,7,16.13142857142857,0,0,8,9,8,15.52222222222222,0,11.1,0.6,2.02,2 +Student_04015,1,17,9500,1,1,1,1,19,38,7,7,140.0,136.5,1,0,0,1,0,1,0,18,0,7,7,7,14.838571428571427,0,0,8,9,8,14.8,0,12.4,0.5,1.79,2 +Student_04018,4,39,8014,0,1,1,1,37,37,9,7,133.1,140.0,0,0,0,1,0,1,0,43,0,6,6,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_04019,1,17,9254,1,2,1,1,38,38,9,8,132.0,122.6,1,0,0,1,0,1,0,20,0,6,6,6,13.166666666666666,0,0,6,6,6,14.0,0,13.9,-0.3,0.79,2 +Student_04020,1,1,9500,1,2,1,1,1,1,5,9,131.0,129.5,1,0,0,1,0,1,0,19,0,8,8,8,13.9475,0,0,8,8,8,13.9475,0,9.4,-0.8,-3.12,2 +Student_04021,1,1,9670,1,1,1,1,3,1,1,7,133.1,155.0,0,0,0,1,0,0,0,22,0,5,6,3,11.333333333333334,0,0,5,5,0,0.0,0,NA,-0.8,-3.12,0 +Student_04023,1,18,9147,1,1,1,1,19,19,5,8,160.0,137.6,1,0,0,1,0,1,0,19,0,5,6,5,12.6,0,0,5,8,5,11.25,0,10.8,1.4,1.74,2 +Student_04024,1,7,9500,1,1,3,1,19,3,4,2,120.0,120.0,1,0,0,1,0,0,0,29,0,8,8,6,12.25,1,0,8,8,6,12.25,1,12.7,3.7,-1.7,0 +Student_04025,1,15,9556,1,1,1,26,3,19,122,144,114.0,114.0,0,0,0,1,0,0,1,20,0,7,14,0,0.0,6,0,7,12,2,11.666666666666666,0,8.9,1.4,3.51,1 +Student_04026,4,1,9991,0,1,1,1,37,37,9,7,140.0,139.0,0,0,0,1,0,1,0,38,0,5,8,5,11.0,0,0,5,7,5,11.4,0,9.4,-0.8,-3.12,1 +Student_04027,1,39,9003,1,1,1,1,37,37,9,5,100.0,110.0,0,0,0,1,0,0,0,41,8,12,17,12,11.833333333333334,0,3,12,22,9,12.7,0,15.5,2.8,-4.06,2 +Student_04028,1,1,9500,1,6,1,1,19,38,4,9,139.0,128.5,1,0,0,1,0,0,0,19,0,8,10,6,13.066666666666668,0,0,8,10,6,13.066666666666668,0,12.7,3.7,-1.7,0 +Student_04030,4,7,9500,1,1,3,1,3,19,2,3,130.0,130.0,0,0,0,1,0,0,0,43,0,7,7,3,13.833333333333334,1,0,7,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_04031,1,17,9130,1,1,1,1,38,37,9,7,145.0,129.3,1,0,0,1,0,0,0,19,0,5,5,5,11.8,0,0,5,5,5,13.2,0,10.8,1.4,1.74,2 +Student_04032,1,1,171,1,1,1,1,19,38,9,8,133.1,128.2,1,0,0,1,1,1,0,19,6,12,12,12,13.333333333333334,0,4,11,15,10,12.818181818181818,0,8.9,1.4,3.51,1 +Student_04033,1,1,9500,1,6,1,1,2,19,3,9,146.0,130.3,1,0,0,1,1,0,0,18,0,8,8,8,13.74625,0,0,8,8,8,13.74625,0,9.4,-0.8,-3.12,2 +Student_04034,1,1,171,1,1,1,1,3,3,2,2,159.0,162.5,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_04035,2,39,8014,0,1,19,1,34,34,0,0,133.1,130.0,0,0,0,1,1,0,0,38,0,6,0,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_04036,2,7,9130,1,1,2,1,19,19,4,8,110.0,110.0,1,0,0,1,1,0,0,37,0,6,9,0,0.0,0,0,6,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_04038,1,17,9238,1,1,1,1,37,37,9,9,130.0,122.0,1,0,0,1,0,1,0,21,0,6,8,1,10.0,0,0,6,13,5,11.4,0,12.7,3.7,-1.7,1 +Student_04039,1,1,9085,1,3,1,1,1,19,9,9,158.0,153.6,1,0,0,1,0,1,0,18,0,6,7,6,15.666666666666666,0,0,6,8,6,15.285714285714286,0,8.9,1.4,3.51,2 +Student_04040,1,1,9853,1,1,1,1,3,19,2,3,122.0,112.9,0,0,0,1,0,0,0,18,0,7,9,7,11.857142857142858,0,0,7,7,7,11.857142857142858,0,16.2,0.3,-0.92,2 +Student_04041,1,1,9085,1,1,1,1,3,1,2,4,140.0,124.1,0,0,0,1,0,0,0,18,0,5,12,5,14.5,2,0,5,5,5,13.6,0,9.4,-0.8,-3.12,2 +Student_04042,1,17,9238,1,1,1,1,38,1,9,4,136.0,129.7,0,0,0,1,0,0,0,19,0,6,6,6,12.166666666666666,0,0,6,7,6,13.714285714285714,0,15.5,2.8,-4.06,2 +Student_04043,1,1,NA,1,1,1,1,19,19,9,9,111.0,110.0,1,0,0,1,0,0,0,18,0,6,6,5,12.6,0,0,6,8,6,12.0,0,11.1,0.6,2.02,2 +Student_04044,1,17,9500,1,2,1,1,2,38,3,8,145.0,136.3,1,0,0,1,0,0,0,18,0,8,12,7,12.285714285714286,0,0,8,12,7,12.285714285714286,0,12.7,3.7,-1.7,1 +Student_04045,1,17,9238,1,1,1,1,38,38,191,193,133.1,146.0,0,0,1,1,0,1,0,19,0,6,6,6,12.666666666666666,0,0,6,7,6,13.0,0,8.9,1.4,3.51,2 +Student_04046,1,1,9500,1,1,1,1,19,38,7,8,140.0,129.9,0,0,0,1,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_04047,1,1,9254,1,1,1,1,19,1,9,8,140.0,140.9,1,0,0,1,0,1,0,18,0,6,7,6,12.857142857142858,0,0,6,10,4,13.0,0,12.7,3.7,-1.7,2 +Student_04048,2,1,9500,1,1,1,1,1,1,9,10,156.0,135.5,0,0,0,1,0,0,0,18,0,8,8,7,13.9,0,0,8,8,7,13.9,0,12.7,3.7,-1.7,2 +Student_04050,1,53,9556,1,1,42,1,1,19,4,5,140.0,NA,0,0,0,1,0,1,0,22,1,7,10,6,13.314285714285717,0,2,8,10,7,12.875,0,NA,1.4,3.51,2 +Student_04051,1,1,9130,1,1,1,1,34,1,0,0,164.0,163.0,0,0,0,1,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,7.6,2.6,0.32,0 +Student_04052,1,17,9254,1,4,1,1,38,19,7,7,113.0,107.4,1,0,0,1,0,1,0,19,0,6,6,6,12.166666666666666,0,0,6,6,6,12.166666666666666,0,12.4,0.5,1.79,2 +Student_04053,1,1,9254,1,1,1,1,37,37,9,9,122.0,114.3,1,0,0,0,0,1,0,20,0,6,12,4,11.25,0,0,6,12,3,11.333333333333334,0,7.6,2.6,0.32,0 +Student_04054,1,43,9070,1,1,1,1,2,3,3,2,150.0,140.8,0,0,0,1,0,0,0,19,1,6,6,5,12.4,0,0,6,8,6,12.75,0,10.8,1.4,1.74,1 +Student_04056,1,39,9085,1,1,1,1,3,19,2,9,133.1,110.0,0,0,0,1,0,0,0,28,0,6,15,4,12.0,0,0,6,14,4,12.0,0,11.1,0.6,2.02,0 +Student_04057,1,1,9085,1,2,1,1,1,1,193,101,122.0,126.2,0,0,0,1,0,0,0,19,0,6,8,6,14.0,0,0,6,18,3,12.666666666666666,0,12.4,0.5,1.79,2 +Student_04060,1,1,9773,1,3,1,1,19,19,5,5,130.0,157.0,1,0,0,0,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_04061,1,5,9130,1,1,1,1,5,43,2,2,157.0,149.7,1,0,0,1,0,0,0,18,0,6,6,6,15.0,0,0,6,6,6,14.833333333333334,0,8.9,1.4,3.51,2 +Student_04062,1,43,9130,1,1,1,1,2,1,2,3,140.0,140.0,1,0,0,1,0,0,0,22,0,5,11,4,12.25,0,0,5,9,5,13.285714285714286,0,12.7,3.7,-1.7,2 +Student_04063,1,53,9085,1,1,42,1,1,19,4,7,170.0,170.0,0,0,0,1,0,0,0,20,7,11,13,11,15.692307692307692,0,4,9,9,9,15.555555555555555,0,8.9,1.4,3.51,2 +Student_04065,1,17,171,1,1,1,1,1,38,9,9,146.0,135.5,1,0,1,1,0,0,0,22,12,17,19,12,11.833333333333334,0,10,17,22,11,11.25,0,11.1,0.6,2.02,1 +Student_04066,1,43,8014,0,1,1,1,38,19,5,4,120.0,118.3,0,0,0,1,0,0,0,20,2,6,6,6,12.166666666666666,0,0,6,7,5,14.0,0,12.7,3.7,-1.7,1 +Student_04068,2,7,8014,0,1,3,1,38,1,9,9,120.0,120.0,0,0,0,0,0,0,0,35,0,6,0,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_04069,1,1,9670,1,1,1,1,1,1,5,7,154.0,154.7,0,0,0,1,0,1,0,18,0,5,6,5,11.8,0,0,5,5,5,12.6,0,9.4,-0.8,-3.12,2 +Student_04072,1,1,9254,1,2,1,1,1,38,4,9,130.0,122.7,1,0,0,1,0,0,0,18,0,6,10,4,11.75,0,0,6,13,4,10.0,0,7.6,2.6,0.32,0 +Student_04073,2,39,9238,1,1,19,1,1,2,4,6,133.1,130.0,0,0,0,1,0,0,0,31,0,6,6,6,13.166666666666666,0,0,6,8,6,13.0,0,9.4,-0.8,-3.12,1 +Student_04074,1,17,9238,1,1,1,1,19,19,5,7,133.0,123.6,0,0,0,1,0,1,0,19,0,6,7,6,13.5,0,0,6,7,6,14.0,0,15.5,2.8,-4.06,2 +Student_04075,1,18,9500,1,1,1,1,38,37,4,9,143.0,116.5,1,0,0,1,0,1,0,20,0,7,10,7,12.625,0,0,8,8,8,13.0625,0,15.5,2.8,-4.06,2 +Student_04077,1,1,9500,1,3,1,1,19,38,9,7,145.0,136.3,1,0,0,1,0,1,0,18,0,8,8,7,13.971428571428572,0,0,8,8,7,13.971428571428572,0,12.7,3.7,-1.7,2 +Student_04078,1,1,9070,1,5,1,1,34,1,5,7,134.0,129.8,1,0,0,1,0,0,0,18,0,6,7,2,11.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_04079,2,39,9991,0,1,1,1,38,19,4,8,170.0,134.7,0,0,0,1,0,0,0,33,0,5,5,5,12.8,0,0,5,6,5,15.333333333333334,0,10.8,1.4,1.74,2 +Student_04081,1,1,171,1,1,1,1,37,37,7,9,140.0,126.8,1,0,0,0,0,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_04082,1,1,9085,1,1,1,1,37,37,9,6,131.0,130.7,0,0,1,1,0,0,0,21,0,5,9,2,11.5,0,0,5,13,4,11.0,1,10.8,1.4,1.74,1 +Student_04083,1,17,9254,1,3,1,1,37,19,5,5,115.0,109.8,1,0,0,1,0,0,0,19,0,6,8,4,11.25,0,0,6,8,4,12.0,0,10.8,1.4,1.74,1 +Student_04085,2,39,9147,1,1,1,1,1,19,9,9,130.0,109.9,0,0,0,0,0,0,0,29,0,4,4,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_04086,1,44,9130,1,1,39,1,1,37,3,3,160.0,160.0,1,0,1,0,0,0,0,36,2,6,9,6,12.0,0,1,6,8,3,14.666666666666666,0,12.4,0.5,1.79,0 +Student_04087,1,39,8014,0,1,19,1,37,37,9,7,133.1,106.5,0,0,0,1,0,1,0,32,0,6,7,6,12.666666666666666,0,0,6,7,6,13.333333333333334,0,12.7,3.7,-1.7,2 +Student_04089,2,43,9991,0,1,1,1,37,37,3,10,140.0,107.8,0,0,0,1,0,0,0,33,8,10,15,8,10.375,0,7,10,13,9,10.444444444444445,0,7.6,2.6,0.32,1 +Student_04090,2,NA,8014,0,1,14,1,34,34,0,0,133.1,100.0,0,0,0,0,0,0,0,34,3,7,13,3,12.0,0,2,7,15,1,13.0,1,9.4,-0.8,-3.12,0 +Student_04091,2,39,8014,0,1,1,1,34,34,0,0,150.0,112.5,0,0,0,1,0,0,0,33,0,6,10,5,11.4,0,1,6,7,6,11.166666666666666,0,7.6,2.6,0.32,2 +Student_04092,1,43,9991,0,1,1,1,37,38,9,8,140.0,135.5,0,0,1,0,0,0,0,29,0,5,15,2,13.25,0,0,5,12,3,12.6,3,16.2,0.3,-0.92,0 +Student_04093,1,1,9500,1,1,1,1,1,1,4,10,145.0,145.0,0,0,0,1,0,0,0,18,0,7,7,6,13.861666666666666,0,0,8,16,0,0.0,1,12.4,0.5,1.79,0 +Student_04096,1,1,9500,1,4,1,1,38,37,9,8,135.0,126.3,1,0,0,1,0,1,0,19,0,7,7,6,15.433333333333332,0,0,7,7,6,15.433333333333332,0,7.6,2.6,0.32,2 +Student_04097,4,39,8014,0,1,19,1,37,37,9,9,133.1,113.5,0,0,0,1,0,1,0,39,0,6,6,6,13.833333333333334,0,0,6,6,6,15.5,0,11.1,0.6,2.02,2 +Student_04098,1,43,9991,0,1,3,1,37,37,9,9,120.0,120.0,0,0,0,1,0,0,0,37,7,14,21,12,11.833333333333334,0,11,12,15,11,11.363636363636363,0,12.7,3.7,-1.7,2 +Student_04100,1,18,9238,1,1,1,1,38,34,4,0,147.0,130.2,0,0,0,1,0,0,0,18,0,1,1,0,0.0,1,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_04101,1,43,NA,1,1,1,1,1,1,4,8,149.0,140.2,1,1,0,1,0,0,0,20,1,7,9,7,12.333333333333334,0,0,8,8,8,12.625,0,12.7,3.7,-1.7,1 +Student_04104,1,1,9147,1,2,1,1,1,19,4,9,125.0,124.0,1,0,0,1,0,0,0,19,0,5,5,5,11.2,0,0,5,11,4,11.75,0,10.8,1.4,1.74,1 +Student_04105,1,1,9238,1,1,1,1,37,38,9,10,141.0,138.9,0,0,0,1,0,0,0,18,0,6,9,6,13.714285714285714,0,0,6,6,6,14.166666666666666,0,13.9,-0.3,0.79,2 +Student_04107,1,17,9773,1,4,1,1,1,38,5,7,118.0,120.8,1,0,0,1,0,0,0,20,0,6,9,4,13.25,0,0,6,11,5,11.8,0,12.4,0.5,1.79,2 +Student_04109,1,17,9500,1,3,1,1,37,38,4,5,136.0,126.0,1,0,0,1,0,0,0,19,0,8,8,7,15.11,0,0,8,8,7,15.11,0,10.8,1.4,1.74,2 +Student_04110,1,1,9238,1,2,1,1,1,19,4,5,134.0,126.0,0,0,0,1,0,0,0,18,0,6,10,4,11.0,0,0,6,8,5,11.2,0,10.8,1.4,1.74,2 +Student_04111,1,1,9500,1,1,1,1,38,19,9,5,153.0,138.5,1,0,0,1,0,1,0,20,0,8,8,7,15.798571428571426,0,0,8,8,7,15.798571428571426,0,10.8,1.4,1.74,2 +Student_04112,1,1,9500,1,3,1,1,19,37,9,9,119.0,119.4,1,0,0,1,0,0,0,20,0,7,7,7,13.775714285714288,0,0,8,8,8,15.599999999999998,0,12.4,0.5,1.79,2 +Student_04113,4,39,9500,1,1,1,1,38,37,7,7,140.0,101.5,1,0,0,1,0,0,0,24,0,8,11,7,12.16,0,0,8,11,7,12.16,0,10.8,1.4,1.74,2 +Student_04114,4,39,9556,1,2,1,1,38,37,7,7,133.1,101.5,1,0,0,1,0,0,0,24,0,7,0,0,0.0,0,0,7,0,0,0.0,0,10.8,1.4,1.74,0 +Student_04115,1,17,9773,1,2,1,1,2,1,2,7,130.0,126.2,1,0,0,1,0,0,0,20,0,6,6,6,14.333333333333334,0,0,6,6,6,15.5,0,12.4,0.5,1.79,2 +Student_04116,1,1,9070,1,3,1,1,19,19,3,3,128.0,129.8,1,0,0,1,0,0,0,20,0,6,6,6,11.833333333333334,0,0,6,6,3,13.333333333333334,0,9.4,-0.8,-3.12,1 +Student_04117,1,1,9085,1,1,1,1,38,37,3,9,145.0,138.4,1,0,0,0,0,0,0,18,0,6,7,6,14.833333333333334,0,0,6,8,6,12.5,0,8.9,1.4,3.51,1 +Student_04119,1,1,9085,1,1,1,1,2,1,4,3,119.0,113.1,1,0,0,1,0,0,0,21,0,5,6,5,12.2,0,0,5,5,5,13.2,0,10.8,1.4,1.74,2 +Student_04121,1,17,9500,1,5,1,1,19,1,5,3,144.0,141.0,1,0,0,1,0,1,0,19,0,8,8,7,12.485714285714286,0,0,8,8,7,12.485714285714286,0,12.7,3.7,-1.7,2 +Student_04124,1,1,9500,1,3,1,6,37,37,9,9,153.0,131.8,1,0,0,1,0,0,1,18,0,7,7,6,14.716666666666669,0,0,7,7,6,14.716666666666669,0,7.6,2.6,0.32,2 +Student_04125,1,1,9085,1,1,1,1,37,19,9,5,147.0,133.7,1,0,0,1,0,1,0,19,0,5,10,2,13.5,0,0,5,11,5,11.4,1,10.8,1.4,1.74,1 +Student_04127,1,1,9085,1,3,1,1,38,19,9,5,134.0,129.1,0,0,0,1,0,0,0,19,0,5,7,3,12.0,0,0,5,7,4,13.5,0,7.6,2.6,0.32,1 +Student_04128,1,1,8014,0,1,1,1,38,38,5,2,133.0,135.5,0,0,0,1,0,0,0,34,0,6,7,6,12.333333333333334,0,0,6,6,6,11.666666666666666,0,10.8,1.4,1.74,2 +Student_04130,1,1,9500,1,1,1,1,37,37,7,9,137.0,130.8,1,0,0,1,0,1,0,18,0,7,7,6,12.666666666666666,0,0,7,7,6,12.666666666666666,0,7.6,2.6,0.32,2 +Student_04131,1,1,9500,1,5,1,1,37,37,9,5,143.0,131.6,1,0,0,1,0,1,0,19,0,7,10,7,14.368,0,0,8,8,8,14.44875,0,15.5,2.8,-4.06,2 +Student_04135,1,1,9238,1,1,1,1,34,38,4,7,142.0,127.3,0,0,0,1,0,1,0,18,0,6,12,4,11.0,0,0,6,9,6,11.5,0,9.4,-0.8,-3.12,2 +Student_04136,1,1,8014,0,1,1,1,38,38,9,7,115.0,NA,1,0,0,1,0,0,0,28,0,6,8,5,12.8,0,0,6,8,5,11.0,0,9.4,-0.8,-3.12,2 +Student_04137,5,43,9500,1,1,1,1,1,38,5,5,131.0,118.8,0,0,0,1,0,1,0,18,0,8,8,7,11.857142857142858,0,0,8,8,7,11.857142857142858,0,12.7,3.7,-1.7,2 +Student_04138,2,39,9254,1,1,1,1,37,37,9,9,130.0,125.0,0,0,0,1,0,0,0,41,0,6,8,6,12.285714285714286,0,0,6,10,5,13.0,0,8.9,1.4,3.51,2 +Student_04140,NA,17,9238,1,1,1,1,38,19,7,7,134.0,124.2,0,0,0,1,0,1,0,21,0,6,11,4,11.25,0,0,6,12,4,11.4,0,15.5,2.8,-4.06,2 +Student_04141,4,7,9238,1,1,40,1,34,34,99,NA,130.0,130.0,0,0,1,1,0,0,0,41,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_04143,1,43,8014,0,1,12,1,34,34,0,99,114.0,110.0,0,0,0,1,0,0,0,29,0,6,10,6,11.666666666666666,0,0,6,7,6,11.0,0,7.6,2.6,0.32,2 +Student_04144,1,39,9556,1,1,1,1,19,38,9,8,130.0,113.3,0,0,0,1,0,0,0,24,0,7,15,5,12.4,0,0,8,14,7,12.15,0,12.4,0.5,1.79,1 +Student_04145,1,43,9556,1,1,1,1,38,38,7,NA,128.0,123.5,1,0,0,1,0,0,0,22,0,7,14,6,10.744444444444444,1,0,8,10,8,NA,0,12.7,3.7,-1.7,1 +Student_04146,1,1,9238,1,1,1,1,19,1,1,3,133.1,101.0,0,0,0,1,0,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_04147,2,39,9500,1,1,19,1,37,38,9,10,133.1,120.9,1,0,0,1,0,0,0,39,0,7,12,4,12.0,0,0,7,13,4,12.5625,0,11.1,0.6,2.02,0 +Student_04148,4,39,9085,1,1,1,1,37,37,9,9,140.0,154.6,0,0,0,0,0,1,0,44,0,6,12,4,12.75,0,0,6,15,2,10.0,0,8.9,1.4,3.51,1 +Student_04149,1,1,9147,1,1,1,1,37,37,9,9,117.0,120.2,1,0,0,1,0,0,0,20,0,5,9,2,10.0,0,0,5,10,2,11.0,0,7.6,2.6,0.32,1 +Student_04150,1,43,9500,1,3,1,1,38,37,9,8,139.0,146.5,0,0,0,1,0,0,0,21,11,14,26,12,13.417391304347827,1,11,14,26,12,13.417391304347827,1,7.6,2.6,0.32,2 +Student_04151,1,1,9773,1,1,1,1,34,26,0,6,159.0,160.1,1,0,0,1,0,0,0,18,0,6,6,6,15.166666666666666,0,0,6,7,6,14.857142857142858,0,7.6,2.6,0.32,2 +Student_04152,1,39,9003,1,1,1,1,37,37,5,5,140.0,150.0,0,0,1,1,0,0,0,34,0,6,10,5,13.833333333333334,0,0,6,13,5,12.5,0,16.2,0.3,-0.92,2 +Student_04153,1,1,9085,1,3,1,1,10,19,90,90,140.0,135.8,1,0,0,1,0,0,0,18,0,5,6,5,13.333333333333334,0,0,5,7,4,14.8,0,7.6,2.6,0.32,2 +Student_04154,1,1,171,1,1,1,1,19,4,9,2,135.0,143.8,1,0,1,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,1 +Student_04155,1,1,9853,1,1,1,1,37,19,6,7,NA,116.8,1,0,0,1,0,0,0,18,0,6,11,3,11.666666666666666,0,0,6,11,3,10.666666666666666,0,9.4,-0.8,-3.12,0 +Student_04156,1,1,9085,1,5,1,1,3,19,2,3,124.0,113.9,1,0,0,1,0,0,0,19,0,6,12,5,15.0,0,0,6,9,6,13.428571428571429,0,16.2,0.3,-0.92,2 +Student_04157,1,1,9500,1,3,1,1,37,37,9,9,131.0,118.0,1,0,0,1,0,1,0,18,0,8,8,7,13.242857142857144,0,0,8,8,7,13.242857142857144,0,12.7,3.7,-1.7,1 +Student_04158,1,1,9130,1,5,1,1,3,1,2,9,160.0,150.2,1,0,0,1,0,0,0,19,0,5,13,1,13.0,0,0,5,7,2,12.5,0,12.7,3.7,-1.7,0 +Student_04159,1,1,NA,1,2,1,1,3,37,4,7,120.0,115.1,1,0,0,1,0,1,0,19,0,7,8,6,13.075,0,0,8,10,7,12.05,0,12.4,0.5,1.79,2 +Student_04160,1,1,9670,1,1,1,1,19,19,5,9,140.0,131.3,1,0,0,1,0,1,0,18,0,6,6,6,13.5,0,0,6,9,6,13.666666666666666,0,10.8,1.4,1.74,2 +Student_04161,1,44,9991,0,1,39,1,NA,37,7,7,120.0,120.0,1,0,0,1,0,1,0,23,2,6,8,5,11.8,0,2,6,8,6,12.333333333333334,0,9.4,-0.8,-3.12,2 +Student_04163,4,43,9853,1,1,1,100,19,22,90,90,133.1,100.0,0,0,0,1,0,0,1,33,0,6,6,6,12.166666666666666,0,0,6,9,3,11.0,0,7.6,2.6,0.32,0 +Student_04164,1,17,9238,1,2,1,1,19,38,9,9,111.0,110.7,1,0,0,1,0,0,0,19,0,6,9,6,12.166666666666666,0,0,6,9,6,11.0,0,8.9,1.4,3.51,2 +Student_04165,1,43,171,1,3,1,1,37,38,7,7,140.0,143.4,1,0,0,1,0,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_04166,1,1,9500,1,6,1,1,19,19,9,9,125.0,115.9,0,0,0,1,0,0,0,18,0,7,7,7,13.557142857142855,0,0,8,9,8,13.2,0,12.4,0.5,1.79,2 +Student_04167,1,18,9991,0,1,1,1,38,38,5,5,133.1,145.0,0,0,0,1,0,1,0,21,0,5,6,4,12.25,0,0,5,8,4,11.8,0,10.8,1.4,1.74,1 +Student_04168,1,17,9070,1,2,1,1,19,38,4,7,136.0,140.9,1,0,0,1,0,0,0,19,0,6,6,6,14.333333333333334,0,0,6,6,6,13.5,0,9.4,-0.8,-3.12,2 +Student_04169,1,1,9773,1,2,1,1,34,38,0,5,115.0,108.4,1,0,0,1,0,0,0,20,0,6,10,4,10.5,0,0,6,8,4,11.75,0,7.6,2.6,0.32,2 +Student_04170,1,1,9773,1,1,1,1,37,37,0,5,116.0,114.3,1,0,0,1,0,0,0,20,0,4,8,0,0.0,0,0,4,8,0,0.0,0,7.6,2.6,0.32,0 +Student_04171,1,18,9853,1,5,1,1,19,37,7,7,110.0,110.0,1,0,0,1,0,0,0,20,0,6,10,4,12.75,0,0,6,14,3,11.333333333333334,0,10.8,1.4,1.74,1 +Student_04172,1,1,9238,1,1,1,1,38,38,4,7,135.0,121.7,1,0,0,1,0,1,0,18,0,6,14,0,0.0,0,0,6,9,4,11.0,0,7.6,2.6,0.32,1 +Student_04173,1,43,9147,1,2,1,1,19,37,5,9,131.0,123.7,1,0,0,1,0,0,0,18,0,5,10,1,14.0,0,0,5,10,1,14.0,0,7.6,2.6,0.32,1 +Student_04174,1,1,9500,1,2,1,1,37,37,7,7,124.0,116.5,1,0,0,1,NA,1,0,20,0,7,9,7,14.093333333333332,0,0,8,8,8,15.0,0,11.1,0.6,2.02,2 +Student_04175,1,1,NA,1,1,1,1,37,37,5,6,163.0,155.0,0,0,0,1,0,1,0,21,0,6,6,6,13.333333333333334,0,0,6,8,6,13.166666666666666,0,9.4,-0.8,-3.12,2 +Student_04176,1,43,9500,1,1,1,1,38,19,9,5,137.0,129.3,1,0,0,1,0,0,0,19,0,8,12,7,12.071428571428571,0,0,8,12,7,12.071428571428571,0,12.7,3.7,-1.7,2 +Student_04177,1,1,9254,1,3,1,1,19,1,7,9,128.0,121.7,1,0,0,1,0,1,0,18,0,6,6,6,12.666666666666666,0,0,6,6,6,12.5,0,12.4,0.5,1.79,2 +Student_04178,1,39,9085,1,1,1,1,37,37,9,9,133.1,148.2,1,0,1,1,0,0,0,27,0,6,11,6,12.125,0,0,6,16,5,12.0,0,12.4,0.5,1.79,1 +Student_04179,1,1,9500,1,2,1,1,19,38,7,9,133.1,125.5,1,0,0,1,0,1,0,21,0,7,9,7,13.2,0,0,8,9,7,13.2575,0,15.5,2.8,-4.06,2 +Student_04180,1,17,9500,1,4,1,1,3,19,4,7,148.0,131.9,1,0,0,1,0,1,0,18,0,7,8,7,14.15,0,0,8,8,8,14.51125,0,15.5,2.8,-4.06,2 +Student_04182,1,43,9853,1,1,1,1,37,37,9,9,110.0,107.7,0,0,1,0,0,0,0,28,0,6,0,0,0.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_04183,1,39,9556,1,1,1,1,44,40,2,2,133.1,115.5,0,0,0,1,0,0,0,36,0,7,13,5,12.2,0,0,7,14,3,11.4,0,11.1,0.6,2.02,0 +Student_04184,1,1,9085,1,1,1,1,38,38,9,10,145.0,139.8,1,0,0,1,0,0,0,20,0,5,6,5,14.8,1,0,5,6,5,14.0,0,12.7,3.7,-1.7,2 +Student_04185,1,1,9238,1,1,1,1,38,38,0,7,136.0,133.2,1,0,0,1,0,0,0,19,0,6,8,5,11.0,0,0,6,13,5,11.4,0,7.6,2.6,0.32,2 +Student_04186,1,1,9991,0,1,1,1,19,37,9,9,131.0,118.4,1,0,0,1,0,0,0,20,0,5,10,0,0.0,0,0,5,10,0,0.0,3,7.6,2.6,0.32,1 +Student_04187,1,17,9085,1,2,1,1,37,37,9,7,138.0,123.3,1,0,0,1,0,0,0,19,0,5,15,3,14.0,3,0,5,10,4,11.75,1,9.4,-0.8,-3.12,1 +Student_04188,2,39,8014,0,1,1,1,37,38,3,7,NA,134.5,0,0,0,1,0,0,0,28,0,6,8,5,11.833333333333334,0,0,6,6,6,13.0,0,16.2,0.3,-0.92,2 +Student_04190,1,42,9254,1,1,1,1,38,37,1,1,154.0,154.0,1,0,0,1,NA,0,0,28,8,14,22,12,12.333333333333334,0,3,12,20,8,12.0,0,9.4,-0.8,-3.12,2 +Student_04192,1,44,9085,1,1,39,1,1,39,3,9,140.0,140.0,1,0,0,1,0,0,0,20,1,6,9,6,12.666666666666666,0,1,6,10,4,11.5,0,13.9,-0.3,0.79,1 +Student_04193,1,17,9853,1,2,1,1,37,37,5,6,150.0,132.5,1,0,0,1,0,0,0,22,0,6,9,4,12.25,0,0,6,8,5,11.6,0,10.8,1.4,1.74,1 +Student_04194,1,17,9254,1,2,1,1,1,4,4,4,141.0,127.7,0,0,0,1,0,1,0,18,0,6,7,6,11.285714285714286,0,0,6,9,4,13.5,0,16.2,0.3,-0.92,2 +Student_04195,1,1,9147,1,5,1,1,38,38,9,9,122.0,117.5,1,0,1,0,0,0,0,22,0,5,12,2,11.5,0,0,5,12,0,0.0,0,12.7,3.7,-1.7,0 +Student_04196,1,1,9254,1,5,1,1,37,37,9,7,120.0,127.0,1,0,0,1,0,1,0,18,0,6,10,6,11.666666666666666,0,0,6,10,4,12.25,0,9.4,-0.8,-3.12,2 +Student_04197,1,1,9500,1,1,1,1,19,37,5,5,139.0,125.5,0,0,0,1,0,1,0,21,0,8,8,7,13.514285714285714,0,0,8,8,7,13.514285714285714,0,12.7,3.7,-1.7,2 +Student_04198,1,17,9773,1,6,1,1,1,1,4,2,138.0,140.5,1,0,0,1,0,0,0,19,0,6,7,6,13.0,0,0,6,9,6,13.714285714285714,0,7.6,2.6,0.32,2 +Student_04199,1,5,9853,1,1,1,1,1,38,5,8,119.0,118.3,1,0,0,1,0,0,0,22,0,6,11,3,15.0,0,0,6,11,4,10.25,0,9.4,-0.8,-3.12,1 +Student_04200,1,1,9500,1,1,1,1,38,38,5,5,129.0,120.8,1,0,0,1,0,1,0,20,0,8,8,7,12.744285714285716,0,0,8,8,7,12.744285714285716,0,10.8,1.4,1.74,2 +Student_04201,1,1,9147,1,1,1,1,37,37,191,154,133.1,95.0,0,0,0,1,0,0,0,20,0,5,10,4,11.75,0,0,5,8,5,11.8,0,11.1,0.6,2.02,2 +Student_04202,1,17,8014,0,1,1,1,37,37,5,6,125.0,122.2,1,0,1,1,0,0,0,19,0,6,6,6,12.166666666666666,0,0,6,7,6,11.666666666666666,0,10.8,1.4,1.74,2 +Student_04203,1,17,171,1,1,1,1,1,1,7,3,125.0,143.9,1,0,0,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,1 +Student_04204,1,1,9070,1,2,1,1,19,38,9,9,137.0,127.2,1,0,0,1,0,1,0,20,1,6,9,5,13.4,1,0,6,9,6,12.375,0,13.9,-0.3,0.79,2 +Student_04206,1,1,9500,1,3,1,1,1,37,4,9,154.0,134.8,1,0,0,1,0,0,0,19,0,7,7,6,13.533333333333331,0,0,7,7,6,13.533333333333331,0,7.6,2.6,0.32,2 +Student_04207,1,1,9254,1,1,1,1,19,19,9,9,144.0,142.6,1,0,0,1,0,1,0,18,0,6,7,6,14.166666666666666,0,0,6,10,4,14.0,0,15.5,2.8,-4.06,2 +Student_04208,1,1,9500,1,1,1,1,38,37,7,8,153.0,147.9,0,0,0,1,0,1,0,18,0,7,7,7,14.652857142857142,0,0,8,9,8,14.755555555555556,0,12.4,0.5,1.79,2 +Student_04209,1,1,171,1,1,1,1,1,38,4,9,152.0,160.4,1,0,0,0,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,0 +Student_04210,1,1,9147,1,1,1,103,37,37,9,9,150.0,134.6,0,0,0,1,1,0,1,20,0,5,5,5,13.6,0,0,5,7,5,13.0,0,9.4,-0.8,-3.12,2 +Student_04211,1,1,9254,1,1,1,1,19,1,3,7,129.0,121.0,0,0,0,1,0,1,0,22,0,6,9,6,12.833333333333334,0,0,6,6,4,13.25,0,16.2,0.3,-0.92,2 +Student_04212,1,1,9238,1,1,1,NA,19,37,5,4,150.0,142.7,1,0,0,1,0,1,0,18,0,6,6,6,14.666666666666666,0,0,6,6,6,15.166666666666666,0,9.4,-0.8,-3.12,2 +Student_04213,1,17,9773,1,2,1,1,1,1,4,8,125.0,115.6,1,0,0,1,0,0,0,19,0,6,6,6,13.333333333333334,0,0,6,6,6,14.666666666666666,0,12.4,0.5,1.79,2 +Student_04214,1,1,9238,1,1,1,1,19,37,9,9,133.1,130.0,0,0,0,0,0,1,0,20,0,6,10,5,13.4,0,0,6,9,5,11.4,0,10.8,1.4,1.74,2 +Student_04215,1,1,9500,1,2,1,1,38,37,5,6,140.0,124.3,1,0,0,1,0,1,0,19,0,7,9,7,13.3125,0,0,8,8,8,15.6375,0,13.9,-0.3,0.79,2 +Student_04216,1,1,171,1,1,1,1,19,37,5,6,140.0,137.9,1,0,1,0,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,8.9,1.4,3.51,0 +Student_04219,1,17,9773,1,3,1,1,1,19,5,7,135.0,135.0,0,0,0,1,0,0,0,18,0,6,6,6,13.5,0,0,6,6,6,13.333333333333334,0,12.4,0.5,1.79,1 +Student_04220,1,16,9238,1,4,1,1,37,37,9,9,135.0,121.0,1,0,0,1,0,0,0,18,0,6,8,5,13.0,0,0,6,7,6,11.833333333333334,0,10.8,1.4,1.74,2 +Student_04221,1,1,9670,1,1,1,1,34,38,0,4,133.1,147.0,0,0,0,1,0,0,0,22,0,5,6,2,12.5,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_04222,1,1,9238,1,1,1,1,37,37,9,9,168.0,149.5,0,0,0,1,0,0,0,18,0,6,10,6,17.0,0,0,6,11,6,16.0,0,12.4,0.5,1.79,2 +Student_04223,1,1,9238,1,1,1,1,19,1,9,9,NA,144.4,1,0,0,1,0,0,0,20,0,6,7,6,13.5,0,0,6,6,6,13.0,0,10.8,1.4,1.74,2 +Student_04224,1,17,9254,1,2,1,1,19,38,5,5,116.0,116.0,1,0,0,1,0,0,0,19,0,6,7,6,12.714285714285714,0,0,6,6,6,11.833333333333334,0,8.9,1.4,3.51,2 +Student_04225,1,43,9500,1,1,1,1,38,19,5,8,134.0,120.7,0,0,0,1,0,1,0,19,0,7,9,6,13.0,0,0,8,11,8,13.927272727272726,0,16.2,0.3,-0.92,2 +Student_04226,1,44,9238,1,1,39,1,38,19,5,0,140.0,141.8,0,0,0,1,0,0,0,21,3,6,7,6,12.571428571428571,0,2,6,6,6,13.5,0,12.4,0.5,1.79,2 +Student_04227,1,17,8014,0,2,1,1,19,1,5,5,133.0,119.7,1,0,0,1,0,1,0,19,0,6,10,4,11.5,0,0,6,11,6,11.5,0,9.4,-0.8,-3.12,0 +Student_04230,2,39,9085,1,1,1,1,36,36,99,5,133.1,128.2,0,0,0,0,0,1,0,28,0,5,14,1,12.0,3,0,5,5,0,0.0,5,9.4,-0.8,-3.12,0 +Student_04231,2,43,9500,1,1,1,1,3,3,2,2,137.0,115.0,0,0,0,1,0,0,0,28,0,7,8,7,14.95,0,0,8,8,8,14.7375,0,13.9,-0.3,0.79,2 +Student_04232,1,39,9991,0,1,1,1,38,19,9,5,140.0,130.0,0,0,1,1,0,0,0,25,0,5,10,4,11.25,0,0,5,9,4,12.0,0,12.7,3.7,-1.7,1 +Student_04234,1,1,9500,1,5,1,1,38,38,9,5,139.0,130.5,1,0,0,1,0,0,0,19,0,8,8,7,14.992857142857142,0,0,8,8,7,14.992857142857142,0,10.8,1.4,1.74,2 +Student_04236,1,1,9238,1,3,1,1,1,1,9,9,133.1,100.0,1,0,0,1,1,0,0,22,0,6,6,4,11.25,0,0,6,7,3,11.0,0,8.9,1.4,3.51,1 +Student_04237,1,43,9773,1,1,1,1,38,19,9,9,132.0,125.0,1,0,0,1,1,1,0,20,0,6,6,6,12.333333333333334,0,0,6,7,6,14.0,0,12.4,0.5,1.79,2 +Student_04238,1,1,9500,1,4,1,1,19,37,7,7,127.0,121.5,1,0,0,1,1,0,0,20,0,7,7,6,13.016666666666666,0,0,7,7,6,13.016666666666666,0,7.6,2.6,0.32,1 +Student_04239,1,1,9085,1,1,1,1,38,19,4,90,123.0,127.2,0,0,1,0,1,0,0,20,0,5,7,3,11.333333333333334,0,0,5,8,2,11.5,0,7.6,2.6,0.32,0 +Student_04242,1,1,9500,1,3,1,1,37,37,9,9,140.0,141.5,1,0,1,0,0,0,0,19,0,8,8,7,13.327142857142857,0,0,8,8,7,13.327142857142857,0,10.8,1.4,1.74,0 +Student_04243,1,17,9238,1,1,1,1,19,38,3,3,111.0,111.4,1,0,0,0,0,0,0,19,0,6,13,4,11.0,0,0,6,13,2,11.5,0,12.7,3.7,-1.7,0 +Student_04244,1,1,9070,1,1,1,1,4,39,2,2,132.0,NA,1,0,0,1,0,0,0,18,1,6,10,6,11.714285714285714,1,0,6,15,6,10.375,0,13.9,-0.3,0.79,1 +Student_04245,1,1,171,1,1,1,1,3,3,2,5,150.0,154.6,1,0,0,1,0,0,0,19,6,12,13,12,12.333333333333334,0,4,11,12,10,12.727272727272728,0,8.9,1.4,3.51,0 +Student_04246,1,18,9853,1,4,1,1,19,37,9,6,118.0,111.4,1,0,1,0,0,0,0,20,0,7,9,0,0.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_04247,2,43,9991,0,1,1,1,38,19,3,3,150.0,120.1,0,0,0,0,0,0,0,39,11,15,15,12,11.916666666666666,0,8,13,14,8,11.25,0,10.8,1.4,1.74,0 +Student_04248,2,39,8014,0,2,19,1,37,37,4,7,100.0,100.0,0,0,1,1,0,0,0,37,0,6,9,6,11.833333333333334,0,0,6,7,6,11.0,0,7.6,2.6,0.32,2 +Student_04249,2,39,9500,1,1,3,1,1,1,4,6,130.0,140.0,0,0,1,0,0,0,0,30,3,7,11,3,12.333333333333334,0,3,7,9,3,11.666666666666666,0,13.9,-0.3,0.79,0 +Student_04250,2,43,9991,0,1,3,1,37,37,9,9,130.0,130.0,0,0,0,1,0,0,0,41,5,10,11,10,14.3,0,5,10,10,10,14.2,0,12.7,3.7,-1.7,2 +Student_04254,1,18,9853,1,2,1,1,19,37,9,4,120.0,113.7,1,0,1,0,0,0,0,19,0,7,11,5,12.2,0,0,7,13,0,0.0,0,12.4,0.5,1.79,0 +Student_04255,1,1,9670,1,1,1,1,37,37,5,9,121.0,116.5,1,0,0,1,0,0,0,23,0,5,7,3,11.333333333333334,0,0,5,5,4,11.25,0,7.6,2.6,0.32,0 +Student_04256,1,7,8014,0,1,4,1,2,3,2,2,120.0,120.0,0,0,0,1,0,0,0,18,10,16,24,13,13.846153846153848,0,7,11,15,9,12.555555555555555,0,15.5,2.8,-4.06,0 +Student_04259,1,1,9500,1,2,1,1,19,19,7,7,123.0,120.8,1,0,0,1,0,0,0,19,0,8,11,7,12.545714285714286,0,0,8,11,7,12.545714285714286,0,10.8,1.4,1.74,2 +Student_04260,1,1,9773,1,1,1,1,37,19,9,10,134.0,141.4,1,0,0,1,NA,0,0,19,0,6,12,3,13.0,0,0,6,13,2,14.0,0,9.4,-0.8,-3.12,0 +Student_04262,2,43,9991,0,1,2,1,37,37,9,9,120.0,120.0,0,0,0,0,0,0,0,38,9,12,12,9,12.22222222222222,2,9,12,12,9,13.0,0,9.4,-0.8,-3.12,0 +Student_04263,1,17,9147,1,1,1,1,1,37,3,7,131.0,120.2,0,0,0,1,0,0,0,19,0,5,10,5,13.285714285714286,0,0,5,8,5,13.0,0,12.7,3.7,-1.7,2 +Student_04264,2,39,9991,0,1,12,1,37,1,9,4,133.1,138.4,0,0,0,1,1,0,0,30,0,5,7,3,11.666666666666666,0,0,5,8,1,11.0,0,7.6,2.6,0.32,0 +Student_04267,1,44,171,1,1,39,1,1,1,9,9,140.0,140.0,0,0,0,1,1,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,1 +Student_04269,1,1,9991,0,2,1,1,5,1,4,4,143.0,131.5,0,0,0,1,1,0,0,19,0,5,11,4,11.0,0,0,5,8,4,12.25,0,15.5,2.8,-4.06,0 +Student_04270,1,17,9070,1,2,1,1,3,1,2,4,142.0,141.0,1,0,0,1,1,0,0,18,0,6,6,6,13.0,0,0,6,8,1,10.0,0,10.8,1.4,1.74,1 +Student_04272,1,17,9119,1,4,1,1,1,3,1,4,138.0,127.5,1,0,0,1,1,0,0,19,0,5,6,5,14.6,0,0,5,5,5,15.2,0,8.9,1.4,3.51,0 +Student_04273,1,1,9500,1,1,1,1,1,19,9,9,131.0,127.0,0,0,0,1,1,1,0,19,0,8,8,7,12.514285714285714,0,0,8,8,7,12.514285714285714,0,12.7,3.7,-1.7,2 +Student_04274,1,17,9085,1,2,1,1,3,19,2,9,123.0,118.9,0,0,0,1,1,0,0,18,0,5,5,3,14.0,0,0,5,7,3,12.666666666666666,0,7.6,2.6,0.32,1 +Student_04275,1,1,9254,1,1,1,1,37,19,9,9,131.0,134.5,1,0,0,1,1,0,0,25,0,6,8,6,13.166666666666666,0,0,6,8,5,NA,0,7.6,2.6,0.32,1 +Student_04276,1,17,9119,1,1,1,1,37,1,9,2,141.0,133.0,1,0,0,1,1,0,0,18,0,5,10,4,13.0,0,0,5,10,3,12.333333333333334,3,7.6,2.6,0.32,1 +Student_04277,5,39,9147,1,1,1,1,1,19,4,7,133.1,114.0,0,0,0,0,1,0,0,29,0,5,5,1,13.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_04278,1,17,9119,1,1,1,1,19,37,90,5,116.0,116.7,1,0,0,1,1,0,0,21,0,5,10,1,10.0,0,0,5,8,3,13.666666666666666,3,7.6,2.6,0.32,0 +Student_04279,1,1,9773,1,3,1,1,1,1,4,7,123.0,125.1,1,0,1,1,1,1,0,18,0,6,6,6,14.333333333333334,0,0,6,6,6,15.333333333333334,0,11.1,0.6,2.02,2 +Student_04280,1,17,9254,1,1,1,1,19,1,9,9,133.0,137.2,0,0,0,1,1,1,0,20,0,6,6,0,0.0,0,0,6,12,0,0.0,0,10.8,1.4,1.74,0 +Student_04281,1,39,9991,0,1,1,1,19,37,9,7,133.1,111.4,0,0,0,1,1,0,0,27,0,5,7,1,11.0,0,0,5,7,0,0.0,0,13.9,-0.3,0.79,0 +Student_04282,1,1,9085,1,1,1,1,3,1,4,9,133.1,105.0,1,0,0,1,1,0,0,21,0,6,15,3,11.25,0,0,6,9,0,0.0,0,12.4,0.5,1.79,1 +Student_04283,1,18,9147,1,2,1,1,NA,37,5,9,140.0,124.3,1,0,0,1,1,0,0,20,0,5,7,4,10.75,0,0,5,12,3,10.571428571428571,0,10.8,1.4,1.74,0 +Student_04285,1,39,9556,1,2,1,1,37,19,9,8,130.0,110.0,0,0,0,1,1,1,0,24,0,7,13,6,10.857142857142858,0,0,7,7,7,11.857142857142858,0,12.7,3.7,-1.7,1 +Student_04286,1,1,9147,1,5,1,1,3,2,2,2,134.0,134.7,0,0,0,1,1,0,0,22,1,5,10,4,11.75,0,0,5,10,3,11.0,0,7.6,2.6,0.32,1 +Student_04288,1,44,9085,1,1,39,1,1,1,4,4,160.0,160.0,0,0,0,1,1,0,0,21,1,5,15,3,12.333333333333334,2,0,5,7,5,11.4,0,9.4,-0.8,-3.12,2 +Student_04289,1,44,9003,1,1,39,1,1,3,9,2,130.0,130.0,1,0,1,0,1,0,0,23,0,6,12,2,11.333333333333334,0,0,6,8,2,13.0,0,13.9,-0.3,0.79,0 +Student_04292,1,1,171,1,1,1,1,1,38,4,5,137.0,130.4,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,2 +Student_04294,1,1,9254,1,6,1,1,19,19,9,9,119.0,118.7,1,0,0,1,1,0,0,20,0,6,16,3,10.333333333333334,0,0,6,16,1,11.0,0,10.8,1.4,1.74,0 +Student_04295,1,39,9003,1,1,1,1,38,37,7,7,130.0,120.0,0,0,0,1,1,0,0,32,12,18,25,18,13.736842105263158,0,10,13,15,12,13.75,1,15.5,2.8,-4.06,2 +Student_04296,1,39,9003,1,1,1,1,38,19,9,6,130.0,120.0,1,0,0,1,1,0,0,28,7,13,19,8,11.625,0,5,10,17,6,11.0,0,15.5,2.8,-4.06,1 +Student_04298,1,1,9773,1,1,1,1,38,37,9,6,130.0,133.9,0,0,0,1,1,1,0,19,0,6,8,5,14.0,0,0,6,8,6,13.0,0,10.8,1.4,NA,2 +Student_04299,1,39,9991,0,1,39,1,19,19,9,9,150.0,150.3,0,0,0,1,1,0,0,24,0,5,7,3,11.333333333333334,0,0,5,6,0,0.0,0,10.8,1.4,1.74,0 +Student_04300,1,17,9147,1,1,1,1,38,38,9,8,120.0,118.3,0,0,0,1,1,0,0,18,0,5,13,1,10.0,0,0,5,5,1,10.0,0,12.7,3.7,-1.7,0 +Student_04302,1,43,171,1,1,39,1,38,37,9,7,140.0,140.0,0,0,0,0,1,0,0,25,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_04305,1,1,9147,1,1,1,1,19,1,7,5,148.0,138.3,1,0,0,1,1,0,0,19,0,5,6,4,13.75,0,0,5,5,0,0.0,0,12.4,0.5,1.79,0 +Student_04306,1,1,9147,1,5,1,1,19,3,9,9,133.0,123.2,1,0,0,1,1,0,0,18,0,5,14,4,11.0,0,0,5,9,5,10.5,0,13.9,-0.3,0.79,0 +Student_04307,1,42,9147,1,1,1,1,19,1,4,4,135.0,120.0,0,0,0,0,1,0,0,25,0,5,6,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_04309,1,44,171,1,1,39,1,1,1,1,7,110.0,114.2,0,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,0 +Student_04311,1,44,9085,1,1,39,1,38,37,9,4,150.0,150.0,1,0,0,1,1,1,0,22,0,6,9,6,13.428571428571429,0,1,6,12,6,13.625,0,12.4,0.5,1.79,2 +Student_04312,1,1,9119,1,6,1,1,2,1,3,5,135.0,123.5,1,0,0,1,1,0,0,18,0,5,10,0,0.0,0,0,5,10,1,10.0,3,7.6,2.6,0.32,1 +Student_04313,1,7,9991,0,1,3,1,19,19,3,9,130.0,130.0,0,0,0,0,1,0,0,32,0,5,12,4,14.75,0,0,5,9,2,15.0,0,16.2,0.3,-0.92,0 +Student_04314,1,43,9853,1,1,1,1,2,39,2,5,130.0,124.6,0,0,0,1,1,0,0,37,19,21,21,21,12.476190476190476,0,13,19,19,19,12.210526315789474,0,12.4,0.5,1.79,2 +Student_04315,1,17,9119,1,1,1,1,37,37,9,6,132.0,119.4,1,0,0,1,1,0,0,21,0,5,8,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_04317,1,1,9070,1,3,1,1,43,3,123,123,118.0,110.0,1,0,1,1,1,0,0,19,0,6,6,6,12.0,0,0,6,7,6,13.571428571428571,0,8.9,1.4,3.51,2 +Student_04319,1,1,171,1,1,1,41,1,1,9,7,161.0,163.1,1,0,0,0,0,0,1,19,6,12,12,12,15.25,0,4,11,12,11,15.0,0,8.9,1.4,3.51,2 +Student_04321,1,15,9147,1,1,1,26,1,1,9,7,135.0,135.0,0,0,1,1,1,0,1,21,0,5,9,3,12.333333333333334,0,0,5,8,4,11.25,0,8.9,1.4,3.51,1 +Student_04322,4,39,9991,0,1,1,1,19,19,7,8,147.0,147.9,0,0,0,1,0,0,0,28,0,5,8,4,11.5,0,0,5,7,4,12.0,0,10.8,1.4,1.74,1 +Student_04324,1,39,9991,0,1,19,1,37,37,9,6,133.1,105.3,0,0,1,1,0,0,0,28,0,5,14,2,10.5,0,0,5,6,0,0.0,0,12.4,0.5,1.79,0 +Student_04325,1,1,9500,1,1,1,1,19,19,7,9,141.0,139.8,0,0,0,1,0,1,0,19,0,8,8,7,14.4,0,0,8,8,7,14.4,0,12.7,3.7,-1.7,2 +Student_04326,2,7,8014,0,1,3,1,19,38,3,7,130.0,130.0,0,0,0,1,0,0,0,32,8,14,18,13,12.846153846153848,0,7,11,19,10,12.8,0,10.8,1.4,1.74,2 +Student_04327,1,39,8014,0,1,39,1,19,37,9,8,110.0,127.5,0,0,1,0,0,0,0,26,0,6,13,4,12.0,0,0,6,7,5,13.2,0,16.2,0.3,-0.92,0 +Student_04328,2,39,9147,1,1,12,1,37,37,9,9,133.1,120.0,0,0,0,1,0,0,0,25,0,5,0,0,0.0,0,0,5,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_04329,2,43,9853,1,2,1,1,38,31,4,1,130.0,124.2,0,0,0,1,0,0,0,31,3,7,8,6,13.666666666666666,0,1,6,8,5,13.5,0,9.4,-0.8,-3.12,0 +Student_04330,1,17,9238,1,1,1,1,37,1,9,5,120.0,113.4,1,0,0,1,0,1,0,20,0,6,10,5,11.857142857142858,0,0,6,8,6,11.666666666666666,0,12.7,3.7,-1.7,2 +Student_04332,1,17,171,1,1,1,1,37,19,5,9,145.0,130.0,1,0,0,1,0,0,0,23,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,0 +Student_04333,1,1,9238,1,1,1,1,37,1,9,9,131.0,135.9,1,0,0,1,0,0,0,18,0,6,8,5,13.2,0,0,6,6,6,11.333333333333334,0,9.4,-0.8,-3.12,2 +Student_04334,1,1,9238,1,2,1,1,19,38,9,NA,147.0,135.8,1,0,0,1,0,1,0,19,0,6,8,6,12.714285714285714,0,0,6,12,5,11.0,0,13.9,-0.3,0.79,0 +Student_04335,1,1,NA,1,1,1,1,38,19,9,10,138.0,133.1,0,0,0,1,0,0,0,18,0,6,6,6,12.5,0,0,6,6,6,12.666666666666666,0,15.5,2.8,-4.06,2 +Student_04336,1,1,9147,1,1,1,1,1,1,4,6,123.0,118.8,1,0,0,1,0,0,0,21,0,5,9,3,10.666666666666666,0,0,5,13,2,12.5,0,7.6,2.6,0.32,1 +Student_04338,1,1,9085,1,1,1,1,1,19,4,9,125.0,114.5,1,0,0,1,0,0,0,24,0,5,6,5,13.0,1,0,5,9,4,13.25,0,12.7,3.7,-1.7,2 +Student_04339,1,1,9670,1,1,1,1,37,37,9,6,131.0,127.2,0,0,0,1,0,1,0,18,0,5,7,3,12.666666666666666,0,0,5,5,4,12.5,0,9.4,-0.8,-3.12,1 +Student_04340,1,42,9500,1,1,1,1,3,37,2,6,100.0,130.0,1,0,0,1,0,0,0,25,0,14,14,12,13.291666666666666,1,0,14,14,12,13.291666666666666,1,7.6,2.6,0.32,2 +Student_04341,1,17,9085,1,1,1,1,2,3,2,2,120.0,116.1,0,0,0,1,0,0,0,20,0,5,12,3,11.666666666666666,2,0,5,11,4,11.5,1,9.4,-0.8,-3.12,2 +Student_04342,1,17,9500,1,2,1,1,19,37,5,9,145.0,130.5,1,0,0,1,0,0,0,18,0,8,8,7,14.24,0,0,8,8,7,14.24,0,10.8,1.4,1.74,2 +Student_04343,1,39,9670,1,1,1,1,34,34,0,0,120.0,104.0,1,0,0,1,0,0,0,24,0,5,10,3,13.0,0,0,5,11,3,11.333333333333334,0,7.6,2.6,0.32,0 +Student_04344,1,17,9500,1,2,1,1,1,1,5,10,140.0,128.5,1,0,0,1,0,0,0,18,0,7,9,5,14.06,0,0,7,9,6,12.571428571428571,0,12.4,0.5,1.79,1 +Student_04353,1,1,9853,1,6,1,1,38,38,9,7,140.0,137.6,1,0,0,1,0,0,0,18,0,6,7,6,11.666666666666666,0,0,6,7,6,12.333333333333334,0,10.8,1.4,1.74,0 +Student_04354,1,1,171,1,1,1,1,3,1,4,4,141.0,142.8,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,2 +Student_04355,4,39,9991,0,1,1,1,37,38,9,9,150.0,146.2,0,0,0,1,0,0,0,30,0,5,11,3,10.333333333333334,0,0,5,10,4,12.8,0,12.4,0.5,1.79,1 +Student_04356,1,1,9085,1,2,1,1,4,19,2,5,160.0,162.1,1,0,0,1,0,0,0,18,0,5,8,5,16.166666666666668,2,0,5,9,5,14.285714285714286,1,9.4,-0.8,-3.12,2 +Student_04357,1,39,9085,1,1,19,1,37,37,4,8,133.1,140.0,0,0,0,1,0,0,0,35,0,6,11,3,12.666666666666666,0,0,6,7,0,0.0,0,11.1,0.6,2.02,0 +Student_04358,1,39,8014,0,1,1,1,19,37,7,8,133.1,120.0,0,0,1,0,0,0,0,31,0,6,14,2,10.5,0,0,6,6,3,12.333333333333334,0,11.1,0.6,2.02,0 +Student_04359,1,43,9254,1,1,1,1,37,37,9,9,134.0,133.3,1,0,1,1,0,0,0,19,0,6,13,2,11.5,0,0,6,13,1,11.0,0,7.6,2.6,0.32,0 +Student_04360,1,1,9238,1,4,1,1,1,19,4,5,130.0,124.8,1,0,0,1,0,0,0,19,0,6,6,6,13.0,0,0,6,8,5,13.4,0,8.9,1.4,3.51,2 +Student_04362,1,17,9500,1,1,1,1,3,3,2,3,145.0,141.8,0,0,0,1,0,0,0,19,0,8,8,8,13.3475,0,0,8,8,8,13.3475,0,9.4,-0.8,-3.12,2 +Student_04364,1,17,9853,1,3,NA,1,34,34,0,0,133.1,115.0,0,0,0,1,0,0,0,18,0,6,10,2,10.5,0,0,6,13,0,0.0,0,7.6,2.6,0.32,0 +Student_04366,1,1,171,1,2,1,1,38,38,4,9,117.0,120.2,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_04367,1,1,9670,1,1,1,1,3,19,3,9,127.0,127.0,1,0,0,1,1,0,0,18,0,6,9,6,13.571428571428571,0,0,6,11,4,14.0,0,12.4,0.5,1.79,2 +Student_04368,1,17,9085,1,1,1,1,19,19,1,1,134.0,120.4,1,0,0,1,1,0,0,18,0,6,10,6,14.7,0,0,6,10,6,12.0,0,16.2,0.3,-0.92,2 +Student_04369,1,39,9991,0,1,1,1,37,37,9,9,120.0,120.0,1,0,0,0,1,0,0,25,0,5,5,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_04370,1,1,9500,1,1,1,1,2,2,3,3,136.0,120.0,1,0,0,1,1,0,0,18,0,7,8,6,11.833333333333334,0,0,7,8,6,11.833333333333334,0,7.6,2.6,0.32,1 +Student_04371,1,1,171,1,3,1,1,1,3,5,2,137.0,133.9,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,2 +Student_04374,1,1,9238,1,1,1,1,37,37,7,9,124.0,121.2,0,0,0,1,0,0,0,19,0,6,12,2,13.0,0,0,6,9,6,10.833333333333334,0,7.6,2.6,0.32,1 +Student_04375,5,7,9500,1,1,40,1,37,37,4,9,150.0,150.0,0,0,0,1,0,0,0,29,1,8,11,7,13.742857142857144,0,1,8,11,7,13.742857142857144,0,12.7,3.7,-1.7,2 +Student_04376,1,NA,9991,0,1,1,1,37,37,9,9,161.0,100.0,1,0,0,1,0,0,0,27,0,5,5,0,NA,0,0,5,5,0,0.0,0,7.6,2.6,NA,0 +Student_04380,1,39,9991,0,1,1,1,37,37,7,7,110.0,133.9,0,0,0,1,0,0,0,30,0,5,7,5,11.4,0,0,5,6,5,13.666666666666666,0,10.8,1.4,1.74,0 +Student_04381,1,7,9500,1,1,2,1,38,37,7,8,140.0,140.0,0,0,0,1,0,0,0,29,0,8,14,4,11.325,1,0,8,14,4,11.325,1,12.7,3.7,-1.7,0 +Student_04382,1,1,9238,1,2,1,1,1,19,4,8,145.0,121.4,0,0,0,1,0,0,0,20,0,6,13,0,0.0,0,0,5,11,0,0.0,0,9.4,-0.8,-3.12,1 +Student_04383,1,1,9500,1,1,1,1,1,1,9,9,131.0,122.0,0,0,0,1,0,0,0,19,0,8,8,7,15.0,0,0,8,8,7,15.0,0,12.7,3.7,-1.7,2 +Student_04384,1,39,8014,0,2,1,1,37,37,9,9,141.0,150.5,0,0,0,1,0,0,0,29,0,6,7,6,13.166666666666666,0,0,6,8,6,15.625,0,12.4,0.5,1.79,2 +Student_04386,1,1,9238,1,1,1,1,19,19,193,194,122.0,112.6,0,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_04387,1,17,9670,1,1,1,1,37,38,8,7,118.0,115.2,1,0,0,1,0,1,0,21,0,5,7,3,12.333333333333334,0,0,5,5,2,12.5,0,7.6,2.6,0.32,0 +Student_04388,2,1,9991,0,1,1,1,37,37,9,9,150.0,131.8,0,0,0,0,0,0,0,29,0,5,6,4,12.25,0,0,5,6,5,10.166666666666666,0,10.8,1.4,1.74,0 +Student_04389,2,43,9147,1,1,2,1,37,37,9,9,120.0,122.8,0,0,1,0,0,0,0,42,13,13,13,13,11.923076923076923,0,12,12,12,12,12.5,0,15.5,2.8,-4.06,0 +Student_04390,1,1,9238,1,1,1,1,19,19,9,7,167.0,156.2,0,0,0,1,0,1,0,18,0,6,6,6,14.333333333333334,0,0,6,7,6,14.142857142857142,0,15.5,2.8,NA,2 +Student_04391,1,39,9085,1,1,1,1,38,38,9,9,150.0,132.0,1,0,0,1,0,0,0,24,0,5,6,5,12.0,0,0,5,5,5,13.0,0,10.8,1.4,1.74,2 +Student_04392,2,7,9500,1,1,3,1,37,37,9,5,130.0,130.0,0,0,0,1,0,0,0,32,0,7,9,7,13.761111111111113,0,1,8,11,7,12.06375,0,15.5,2.8,-4.06,1 +Student_04393,NA,1,9147,1,1,1,1,37,1,4,10,151.0,138.4,0,0,0,1,NA,0,0,18,0,5,6,4,11.25,0,0,5,8,5,11.0,0,10.8,1.4,1.74,1 +Student_04394,1,39,9991,0,1,1,NA,38,38,5,7,120.0,146.2,0,0,0,1,0,0,0,27,0,5,10,3,12.333333333333334,0,0,5,10,3,10.666666666666666,0,11.1,0.6,2.02,2 +Student_04395,1,1,9500,1,4,1,1,38,1,9,10,168.0,166.0,1,0,0,1,0,0,0,18,0,8,8,8,14.88875,0,0,8,8,8,14.88875,0,9.4,-0.8,-3.12,2 +Student_04396,1,17,9773,1,3,1,1,34,34,99,99,153.0,133.1,1,0,1,1,0,1,0,19,0,6,8,6,12.166666666666666,0,0,6,8,5,12.4,0,9.4,-0.8,-3.12,0 +Student_04397,1,1,9773,1,2,1,1,19,37,9,10,131.0,121.9,1,0,0,1,0,1,0,18,0,6,7,6,12.666666666666666,0,0,6,6,6,13.333333333333334,0,11.1,0.6,2.02,2 +Student_04398,1,5,9853,1,4,1,1,3,38,3,8,116.0,110.4,1,0,0,1,0,0,0,21,0,6,9,5,12.6,0,0,6,9,3,11.666666666666666,0,9.4,-0.8,-3.12,1 +Student_04399,1,39,NA,1,1,1,1,38,38,7,9,160.0,121.4,0,1,0,1,0,1,0,26,0,5,8,4,13.0,0,0,5,10,4,12.25,2,16.2,0.3,-0.92,2 +Student_04400,1,1,9254,1,1,1,1,37,19,9,9,152.0,137.0,1,0,0,1,0,1,0,22,0,6,9,6,13.875,0,0,6,6,6,14.333333333333334,0,9.4,-0.8,-3.12,2 +Student_04401,2,39,9991,0,1,1,1,37,37,6,3,133.1,140.0,0,0,1,1,1,0,0,37,0,5,10,4,10.75,0,0,5,12,3,13.333333333333334,0,9.4,-0.8,-3.12,0 +Student_04402,1,7,9085,1,1,3,1,19,37,90,90,150.0,140.0,0,0,0,1,1,0,0,24,3,5,10,3,14.666666666666666,1,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_04403,1,18,9853,1,2,1,1,1,19,3,9,168.0,126.8,1,0,0,1,1,0,0,18,0,6,7,5,12.6,0,0,6,6,6,13.0,0,10.8,1.4,1.74,1 +Student_04404,1,17,9500,1,3,1,1,1,1,4,10,137.0,124.8,1,0,0,1,1,1,0,19,0,7,11,6,12.4125,0,0,8,12,7,11.2625,0,15.5,2.8,-4.06,2 +Student_04405,2,39,9130,1,1,19,1,2,1,8,NA,133.1,120.0,1,0,1,0,1,0,0,28,0,6,12,1,11.0,0,0,6,9,2,10.5,0,16.2,0.3,-0.92,0 +Student_04406,1,1,9500,1,4,1,1,37,37,7,7,160.0,133.0,1,0,0,1,1,1,0,18,0,8,8,7,14.314285714285717,0,0,8,8,7,14.314285714285717,0,12.7,3.7,-1.7,2 +Student_04407,1,1,9070,1,1,1,1,1,38,5,7,145.0,127.5,1,0,0,1,1,0,0,20,0,6,6,4,12.0,0,0,6,8,2,11.333333333333334,0,10.8,1.4,1.74,1 +Student_04408,1,1,9773,1,1,1,1,1,19,4,4,138.0,131.7,1,0,0,1,1,0,0,18,0,6,6,6,12.833333333333334,0,0,6,7,6,13.285714285714286,0,15.5,2.8,-4.06,2 +Student_04409,2,39,9773,1,1,1,1,37,37,9,9,100.0,133.0,0,0,0,1,1,0,0,47,0,6,8,5,11.4,0,0,6,10,6,NA,0,12.7,3.7,-1.7,0 +Student_04410,2,43,9991,0,1,1,1,37,37,4,1,140.0,122.7,0,0,0,1,1,0,0,NA,0,5,5,5,14.6,0,0,5,6,5,14.333333333333334,0,13.9,-0.3,0.79,2 +Student_04411,1,1,9070,1,1,1,1,37,19,9,4,NA,121.2,0,0,0,1,1,1,0,20,1,6,7,6,13.5,0,1,6,9,5,12.5,0,10.8,1.4,1.74,2 +Student_04412,1,44,9130,1,1,39,1,37,37,9,3,150.0,150.0,1,0,0,1,1,0,0,21,1,6,8,6,12.5,0,0,6,11,3,13.333333333333334,0,13.9,-0.3,0.79,0 +Student_04413,1,43,9070,1,1,1,1,19,19,7,8,125.0,133.4,1,0,0,1,1,1,0,19,4,6,6,4,13.0,0,2,6,7,5,12.2,0,13.9,-0.3,0.79,1 +Student_04414,1,43,33,1,1,1,1,37,1,9,10,143.0,121.2,1,0,0,1,1,0,0,25,5,10,13,5,11.6,0,2,8,10,2,13.0,0,12.4,0.5,1.79,1 +Student_04415,1,1,9130,1,1,1,1,3,38,3,5,137.0,129.3,1,0,0,1,0,0,0,18,0,5,6,5,11.8,1,0,5,8,5,11.6,0,9.4,-0.8,-3.12,2 +Student_04416,4,39,NA,1,1,19,1,37,37,6,6,133.1,117.8,0,0,1,0,0,0,0,46,0,7,14,3,12.333333333333334,0,0,7,12,3,11.083333333333334,0,11.1,0.6,2.02,0 +Student_04417,1,43,9500,1,2,1,1,38,38,9,5,136.0,131.3,0,0,0,1,0,0,0,23,11,14,15,12,12.625,1,11,14,15,12,12.625,1,7.6,2.6,0.32,2 +Student_04418,1,1,9070,1,1,NA,NA,1,1,9,9,132.0,133.8,1,0,0,1,0,1,0,20,0,6,6,6,13.833333333333334,0,0,6,6,6,13.5,0,16.2,0.3,-0.92,2 +Student_04419,1,44,NA,1,1,39,1,3,38,3,9,120.0,120.0,0,0,0,1,1,0,0,20,2,7,7,6,NA,0,5,9,10,7,13.142857142857142,1,16.2,0.3,-0.92,2 +Student_04420,1,1,9773,1,6,1,1,1,1,5,4,125.0,122.2,0,0,0,1,1,0,0,19,0,6,7,5,13.6,0,0,6,8,5,12.666666666666666,0,15.5,2.8,-4.06,2 +Student_04421,1,1,9773,1,2,1,105,1,1,9,9,120.0,119.0,1,0,1,0,0,0,1,18,0,6,6,6,12.0,0,0,6,6,2,11.0,0,11.1,0.6,2.02,0 +Student_04423,1,1,9147,1,1,1,1,37,37,7,4,180.0,153.8,1,0,0,1,0,1,0,20,0,5,5,5,13.8,0,0,5,6,5,12.0,0,9.4,-0.8,-3.12,2 +Student_04424,1,10,9773,1,1,1,22,38,37,5,9,152.0,152.0,1,0,0,1,0,0,1,22,0,6,8,6,11.666666666666666,0,0,6,6,6,13.0,0,12.7,3.7,-1.7,2 diff --git a/data/UCIRegression/auto_mpg.csv b/data/UCIRegression/auto_mpg.csv new file mode 100644 index 00000000..0e82e885 --- /dev/null +++ b/data/UCIRegression/auto_mpg.csv @@ -0,0 +1,319 @@ +InstanceID,Cylinders,Displacement,Horsepower,Weight,Acceleration,ModelYear,Origin,MPG +AutoMPG_0001,8,307,130,3504,12,70,1,18 +AutoMPG_0002,8,350,165,3693,11.5,70,1,15 +AutoMPG_0003,8,318,150,3436,11,70,1,18 +AutoMPG_0004,8,304,150,3433,12,70,1,16 +AutoMPG_0006,8,429,198,4341,10,70,1,15 +AutoMPG_0008,8,440,215,4312,8.5,70,1,14 +AutoMPG_0009,8,455,225,4425,10,70,1,14 +AutoMPG_0010,8,390,190,3850,8.5,70,1,15 +AutoMPG_0011,8,383,170,3563,10,70,1,15 +AutoMPG_0013,8,400,150,3761,9.5,70,1,15 +AutoMPG_0014,8,455,225,3086,10,70,1,14 +AutoMPG_0015,4,113,95,2372,15,70,3,24 +AutoMPG_0016,6,198,95,2833,15.5,70,1,22 +AutoMPG_0017,6,199,97,2774,15.5,70,1,18 +AutoMPG_0018,6,200,85,2587,16,70,1,21 +AutoMPG_0019,4,97,88,2130,14.5,70,3,27 +AutoMPG_0020,4,97,46,1835,20.5,70,2,26 +AutoMPG_0021,4,110,87,2672,17.5,70,2,25 +AutoMPG_0022,4,107,90,2430,14.5,70,2,24 +AutoMPG_0023,4,104,95,2375,17.5,70,2,25 +AutoMPG_0024,4,121,113,2234,12.5,70,2,26 +AutoMPG_0026,8,360,215,4615,14,70,1,10 +AutoMPG_0028,8,318,210,4382,13.5,70,1,11 +AutoMPG_0029,8,304,193,4732,18.5,70,1,9 +AutoMPG_0031,4,140,90,2264,15.5,71,1,28 +AutoMPG_0032,4,113,95,2228,14,71,3,25 +AutoMPG_0035,6,225,105,3439,15.5,71,1,16 +AutoMPG_0038,6,232,100,3288,15.5,71,1,18 +AutoMPG_0040,8,400,175,4464,11.5,71,1,14 +AutoMPG_0041,8,351,153,4154,13.5,71,1,14 +AutoMPG_0043,8,383,180,4955,11.5,71,1,12 +AutoMPG_0044,8,400,170,4746,12,71,1,13 +AutoMPG_0045,8,400,175,5140,12,71,1,13 +AutoMPG_0046,6,258,110,2962,13.5,71,1,18 +AutoMPG_0047,4,140,72,2408,19,71,1,22 +AutoMPG_0048,6,250,100,3282,15,71,1,19 +AutoMPG_0049,6,250,88,3139,14.5,71,1,18 +AutoMPG_0050,4,122,86,2220,14,71,1,23 +AutoMPG_0051,4,116,90,2123,14,71,2,28 +AutoMPG_0052,4,79,70,2074,19.5,71,2,30 +AutoMPG_0053,4,88,76,2065,14.5,71,2,30 +AutoMPG_0055,4,72,69,1613,18,71,3,35 +AutoMPG_0056,4,97,60,1834,19,71,2,27 +AutoMPG_0058,4,113,95,2278,15.5,72,3,24 +AutoMPG_0059,4,97.5,80,2126,17,72,1,25 +AutoMPG_0060,4,97,54,2254,23.5,72,2,23 +AutoMPG_0061,4,140,90,2408,19.5,72,1,20 +AutoMPG_0062,4,122,86,2226,16.5,72,1,21 +AutoMPG_0063,8,350,165,4274,12,72,1,13 +AutoMPG_0064,8,400,175,4385,12,72,1,14 +AutoMPG_0065,8,318,150,4135,13.5,72,1,15 +AutoMPG_0066,8,351,153,4129,13,72,1,14 +AutoMPG_0068,8,429,208,4633,11,72,1,11 +AutoMPG_0069,8,350,155,4502,13.5,72,1,13 +AutoMPG_0071,8,400,190,4422,12.5,72,1,13 +AutoMPG_0072,3,70,97,2330,13.5,72,3,19 +AutoMPG_0073,8,304,150,3892,12.5,72,1,15 +AutoMPG_0074,8,307,130,4098,14,72,1,13 +AutoMPG_0075,8,302,140,4294,16,72,1,13 +AutoMPG_0076,8,318,150,4077,14,72,1,14 +AutoMPG_0077,4,121,112,2933,14.5,72,2,18 +AutoMPG_0078,4,121,76,2511,18,72,2,22 +AutoMPG_0079,4,120,87,2979,19.5,72,2,21 +AutoMPG_0080,4,96,69,2189,18,72,2,26 +AutoMPG_0081,4,122,86,2395,16,72,1,22 +AutoMPG_0082,4,97,92,2288,17,72,3,28 +AutoMPG_0084,4,98,80,2164,15,72,1,28 +AutoMPG_0085,4,97,88,2100,16.5,72,3,27 +AutoMPG_0087,8,304,150,3672,11.5,73,1,14 +AutoMPG_0088,8,350,145,3988,13,73,1,13 +AutoMPG_0090,8,318,150,3777,12.5,73,1,15 +AutoMPG_0091,8,429,198,4952,11.5,73,1,12 +AutoMPG_0092,8,400,150,4464,12,73,1,13 +AutoMPG_0094,8,318,150,4237,14.5,73,1,14 +AutoMPG_0095,8,440,215,4735,11,73,1,13 +AutoMPG_0096,8,455,225,4951,11,73,1,12 +AutoMPG_0097,8,360,175,3821,11,73,1,13 +AutoMPG_0098,6,225,105,3121,16.5,73,1,18 +AutoMPG_0099,6,250,100,3278,18,73,1,16 +AutoMPG_0100,6,232,100,2945,16,73,1,18 +AutoMPG_0101,6,250,88,3021,16.5,73,1,18 +AutoMPG_0104,8,400,150,4997,14,73,1,11 +AutoMPG_0107,8,350,180,4499,12.5,73,1,12 +AutoMPG_0108,6,232,100,2789,15,73,1,18 +AutoMPG_0109,4,97,88,2279,19,73,3,20 +AutoMPG_0110,4,140,72,2401,19.5,73,1,21 +AutoMPG_0111,4,108,94,2379,16.5,73,3,22 +AutoMPG_0112,3,70,90,2124,13.5,73,3,18 +AutoMPG_0113,4,122,85,2310,18.5,73,1,19 +AutoMPG_0114,6,155,107,2472,14,73,1,21 +AutoMPG_0115,4,98,90,2265,15.5,73,2,26 +AutoMPG_0116,8,350,145,4082,13,73,1,15 +AutoMPG_0117,8,400,230,4278,9.5,73,1,16 +AutoMPG_0118,4,68,49,1867,19.5,73,2,29 +AutoMPG_0119,4,116,75,2158,15.5,73,2,24 +AutoMPG_0120,4,114,91,2582,14,73,2,20 +AutoMPG_0121,4,121,112,2868,15.5,73,2,19 +AutoMPG_0122,8,318,150,3399,11,73,1,15 +AutoMPG_0123,4,121,110,2660,14,73,2,24 +AutoMPG_0124,6,156,122,2807,13.5,73,3,20 +AutoMPG_0125,8,350,180,3664,11,73,1,11 +AutoMPG_0126,6,198,95,3102,16.5,74,1,20 +AutoMPG_0127,6,200,NA,2875,17,74,1,21 +AutoMPG_0128,6,232,100,2901,16,74,1,19 +AutoMPG_0129,6,250,100,3336,17,74,1,15 +AutoMPG_0130,4,79,67,1950,19,74,3,31 +AutoMPG_0131,4,122,80,2451,16.5,74,1,26 +AutoMPG_0132,4,71,65,1836,21,74,3,32 +AutoMPG_0133,4,140,75,2542,17,74,1,25 +AutoMPG_0134,6,250,100,3781,17,74,1,16 +AutoMPG_0135,6,258,110,3632,18,74,1,16 +AutoMPG_0136,6,225,105,3613,16.5,74,1,18 +AutoMPG_0137,8,302,140,4141,14,74,1,16 +AutoMPG_0139,8,318,150,4457,13.5,74,1,14 +AutoMPG_0140,8,302,140,4638,16,74,1,14 +AutoMPG_0141,8,304,150,4257,15.5,74,1,14 +AutoMPG_0142,4,98,83,2219,16.5,74,2,29 +AutoMPG_0143,4,79,67,1963,15.5,74,2,26 +AutoMPG_0146,4,83,61,2003,19,74,3,32 +AutoMPG_0147,4,90,75,2125,14.5,74,1,28 +AutoMPG_0148,4,90,75,2108,15.5,74,2,24 +AutoMPG_0149,4,116,75,2246,14,74,2,26 +AutoMPG_0150,4,120,97,2489,15,74,3,24 +AutoMPG_0152,4,79,67,2000,16,74,2,31 +AutoMPG_0153,6,225,95,3264,16,75,1,19 +AutoMPG_0154,6,250,105,3459,16,75,1,18 +AutoMPG_0155,6,250,72,3432,21,75,1,15 +AutoMPG_0156,6,250,72,3158,19.5,75,1,15 +AutoMPG_0157,8,400,170,4668,11.5,75,1,16 +AutoMPG_0158,8,350,145,4440,14,75,1,15 +AutoMPG_0160,8,351,148,4657,13.5,75,1,14 +AutoMPG_0161,6,231,110,3907,21,75,1,17 +AutoMPG_0162,6,250,105,3897,18.5,75,1,16 +AutoMPG_0163,6,258,110,3730,19,75,1,15 +AutoMPG_0164,6,225,95,3785,19,75,1,18 +AutoMPG_0165,6,231,110,3039,15,75,1,21 +AutoMPG_0166,8,262,110,3221,13.5,75,1,20 +AutoMPG_0168,4,97,75,2171,16,75,3,29 +AutoMPG_0169,4,140,83,2639,17,75,1,23 +AutoMPG_0171,4,140,78,2592,18.5,75,1,23 +AutoMPG_0172,4,134,96,2702,13.5,75,3,24 +AutoMPG_0173,4,90,71,2223,16.5,75,2,25 +AutoMPG_0174,4,119,97,2545,17,75,3,24 +AutoMPG_0175,6,171,97,2984,14.5,75,1,18 +AutoMPG_0176,4,90,70,1937,14,75,2,29 +AutoMPG_0177,6,232,90,3211,17,75,1,19 +AutoMPG_0179,4,120,88,2957,17,75,2,23 +AutoMPG_0180,4,121,98,2945,14.5,75,2,22 +AutoMPG_0181,4,121,115,2671,13.5,75,2,25 +AutoMPG_0182,4,91,53,1795,17.5,75,3,33 +AutoMPG_0183,4,107,86,2464,15.5,76,2,28 +AutoMPG_0185,4,140,92,2572,14.9,76,1,25 +AutoMPG_0186,4,98,79,2255,17.7,76,1,26 +AutoMPG_0187,4,101,83,2202,15.3,76,2,27 +AutoMPG_0188,8,305,140,4215,13,76,1,17.5 +AutoMPG_0191,8,351,152,4215,12.8,76,1,14.5 +AutoMPG_0192,6,225,100,3233,15.4,76,1,22 +AutoMPG_0193,6,250,105,3353,14.5,76,1,22 +AutoMPG_0194,6,200,81,3012,17.6,76,1,24 +AutoMPG_0195,6,232,90,3085,17.6,76,1,22.5 +AutoMPG_0196,4,85,52,2035,22.2,76,1,29 +AutoMPG_0197,4,98,60,2164,22.1,76,1,24.5 +AutoMPG_0198,4,90,70,1937,14.2,76,2,29 +AutoMPG_0199,4,91,53,1795,17.4,76,3,33 +AutoMPG_0200,6,225,100,3651,17.7,76,1,20 +AutoMPG_0201,6,250,78,3574,21,76,1,18 +AutoMPG_0202,6,250,110,3645,16.2,76,1,18.5 +AutoMPG_0203,6,258,95,3193,17.8,76,1,17.5 +AutoMPG_0204,4,97,71,1825,12.2,76,2,29.5 +AutoMPG_0205,4,85,70,1990,17,76,3,32 +AutoMPG_0206,4,97,75,2155,16.4,76,3,28 +AutoMPG_0207,4,140,72,2565,13.6,76,1,26.5 +AutoMPG_0208,4,130,102,3150,15.7,76,2,20 +AutoMPG_0210,4,120,88,3270,21.9,76,2,19 +AutoMPG_0211,6,156,108,2930,15.5,76,3,19 +AutoMPG_0212,6,168,120,3820,16.7,76,2,16.5 +AutoMPG_0213,8,350,180,4380,12.1,76,1,16.5 +AutoMPG_0215,8,302,130,3870,15,76,1,13 +AutoMPG_0216,8,318,150,3755,14,76,1,13 +AutoMPG_0217,4,98,68,2045,18.5,77,3,31.5 +AutoMPG_0219,4,79,58,1825,18.6,77,2,36 +AutoMPG_0220,4,122,96,2300,15.5,77,1,25.5 +AutoMPG_0221,4,85,70,1945,16.8,77,3,33.5 +AutoMPG_0222,8,305,145,3880,12.5,77,1,17.5 +AutoMPG_0224,8,318,145,4140,13.7,77,1,15.5 +AutoMPG_0225,8,302,130,4295,14.9,77,1,15 +AutoMPG_0226,6,250,110,3520,16.4,77,1,17.5 +AutoMPG_0227,6,231,105,3425,16.9,77,1,20.5 +AutoMPG_0228,6,225,100,3630,17.7,77,1,19 +AutoMPG_0229,6,250,98,3525,19,77,1,18.5 +AutoMPG_0230,8,400,180,4220,11.1,77,1,16 +AutoMPG_0231,8,350,170,4165,11.4,77,1,15.5 +AutoMPG_0232,8,400,190,4325,12.2,77,1,15.5 +AutoMPG_0233,8,351,149,4335,14.5,77,1,16 +AutoMPG_0235,4,151,88,2740,16,77,1,24.5 +AutoMPG_0236,4,97,75,2265,18.2,77,3,26 +AutoMPG_0237,4,140,89,2755,15.8,77,1,25.5 +AutoMPG_0238,4,98,63,2051,17,77,1,30.5 +AutoMPG_0239,4,98,83,2075,15.9,77,1,33.5 +AutoMPG_0241,4,97,78,2190,14.1,77,2,30.5 +AutoMPG_0242,6,146,97,2815,14.5,77,3,22 +AutoMPG_0243,4,121,110,2600,12.8,77,2,21.5 +AutoMPG_0245,4,90,48,1985,21.5,78,2,43.1 +AutoMPG_0246,4,98,66,1800,14.4,78,1,36.1 +AutoMPG_0248,4,85,70,2070,18.6,78,3,39.4 +AutoMPG_0249,4,91,60,1800,16.4,78,3,36.1 +AutoMPG_0250,8,260,110,3365,15.5,78,1,19.9 +AutoMPG_0251,8,318,140,3735,13.2,78,1,19.4 +AutoMPG_0253,6,231,105,3535,19.2,78,1,19.2 +AutoMPG_0254,6,200,95,3155,18.2,78,1,20.5 +AutoMPG_0255,6,200,85,2965,15.8,78,1,20.2 +AutoMPG_0256,4,140,88,2720,15.4,78,1,25.1 +AutoMPG_0258,6,232,90,3210,17.2,78,1,19.4 +AutoMPG_0259,6,231,105,3380,15.8,78,1,20.6 +AutoMPG_0260,6,200,85,3070,16.7,78,1,20.8 +AutoMPG_0262,6,258,120,3410,15.1,78,1,18.1 +AutoMPG_0265,8,302,139,3205,11.2,78,1,18.1 +AutoMPG_0267,4,98,68,2155,16.5,78,1,30 +AutoMPG_0268,4,134,95,2560,14.2,78,3,27.5 +AutoMPG_0269,4,119,97,2300,14.7,78,3,27.2 +AutoMPG_0270,4,105,75,2230,14.5,78,1,30.9 +AutoMPG_0271,4,134,95,2515,14.8,78,3,21.1 +AutoMPG_0272,4,156,105,2745,16.7,78,1,23.2 +AutoMPG_0273,4,151,85,2855,17.6,78,1,23.8 +AutoMPG_0274,4,119,97,2405,14.9,78,3,23.9 +AutoMPG_0276,6,163,125,3140,13.6,78,2,17 +AutoMPG_0277,4,121,115,2795,15.7,78,2,21.6 +AutoMPG_0278,6,163,133,3410,15.8,78,2,16.2 +AutoMPG_0279,4,89,71,1990,14.9,78,2,31.5 +AutoMPG_0280,4,98,68,2135,16.6,78,3,29.5 +AutoMPG_0281,6,231,115,3245,15.4,79,1,21.5 +AutoMPG_0283,4,140,88,2890,17.3,79,1,22.3 +AutoMPG_0284,6,232,90,3265,18.2,79,1,20.2 +AutoMPG_0285,6,225,110,3360,16.6,79,1,20.6 +AutoMPG_0286,8,305,130,3840,15.4,79,1,17 +AutoMPG_0287,8,302,129,3725,13.4,79,1,17.6 +AutoMPG_0288,8,351,138,3955,13.2,79,1,16.5 +AutoMPG_0289,8,318,135,3830,15.2,79,1,18.2 +AutoMPG_0290,8,350,155,4360,14.9,79,1,16.9 +AutoMPG_0291,8,351,142,4054,14.3,79,1,15.5 +AutoMPG_0292,8,267,125,3605,15,79,1,19.2 +AutoMPG_0294,4,89,71,1925,14,79,2,31.9 +AutoMPG_0296,4,98,80,1915,14.4,79,1,35.7 +AutoMPG_0297,4,121,80,2670,15,79,1,27.4 +AutoMPG_0298,5,183,77,3530,20.1,79,2,25.4 +AutoMPG_0299,8,350,125,3900,17.4,79,1,23 +AutoMPG_0302,4,105,70,2200,13.2,79,1,34.2 +AutoMPG_0303,4,105,70,2150,14.9,79,1,34.5 +AutoMPG_0304,4,85,65,2020,19.2,79,3,31.8 +AutoMPG_0306,4,151,90,2670,16,79,1,28.4 +AutoMPG_0307,6,173,115,2595,11.3,79,1,28.8 +AutoMPG_0308,6,173,115,2700,12.9,79,1,26.8 +AutoMPG_0309,4,151,90,2556,13.2,79,1,33.5 +AutoMPG_0311,4,89,60,1968,18.8,80,3,38.1 +AutoMPG_0312,4,98,70,2120,15.5,80,1,32.1 +AutoMPG_0314,4,151,90,2678,16.5,80,1,28 +AutoMPG_0315,4,140,88,2870,18.1,80,1,26.4 +AutoMPG_0317,6,225,90,3381,18.7,80,1,19.1 +AutoMPG_0318,4,97,78,2188,15.8,80,2,34.3 +AutoMPG_0320,4,120,75,2542,17.5,80,3,31.3 +AutoMPG_0322,4,108,75,2265,15.2,80,3,32.2 +AutoMPG_0324,4,156,105,2800,14.4,80,1,27.9 +AutoMPG_0326,4,90,48,2085,21.7,80,2,44.3 +AutoMPG_0327,4,90,48,2335,23.7,80,2,43.4 +AutoMPG_0330,4,91,67,1850,13.8,80,3,44.6 +AutoMPG_0332,4,97,67,2145,18,80,3,33.8 +AutoMPG_0334,6,168,132,2910,11.4,80,3,32.7 +AutoMPG_0335,3,70,100,2420,12.5,80,3,23.7 +AutoMPG_0336,4,122,88,2500,15.1,80,2,35 +AutoMPG_0337,4,140,NA,2905,14.3,80,1,23.6 +AutoMPG_0338,4,107,72,2290,17,80,3,32.4 +AutoMPG_0339,4,135,84,2490,15.7,81,1,27.2 +AutoMPG_0340,4,151,84,2635,16.4,81,1,26.6 +AutoMPG_0341,4,156,92,2620,14.4,81,1,25.8 +AutoMPG_0342,6,173,110,2725,12.6,81,1,23.5 +AutoMPG_0343,4,135,84,2385,12.9,81,1,30 +AutoMPG_0344,4,79,58,1755,16.9,81,3,39.1 +AutoMPG_0346,4,81,60,1760,16.1,81,3,35.1 +AutoMPG_0347,4,97,67,2065,17.8,81,3,32.3 +AutoMPG_0348,4,85,65,1975,19.4,81,3,37 +AutoMPG_0349,4,89,62,2050,17.3,81,3,37.7 +AutoMPG_0350,4,91,68,1985,16,81,3,34.1 +AutoMPG_0351,4,105,63,2215,14.9,81,1,34.7 +AutoMPG_0352,4,98,65,2045,16.2,81,1,34.4 +AutoMPG_0353,4,98,65,2380,20.7,81,1,29.9 +AutoMPG_0355,4,100,NA,2320,15.8,81,2,34.5 +AutoMPG_0357,4,108,75,2350,16.8,81,3,32.4 +AutoMPG_0358,4,119,100,2615,14.8,81,3,32.9 +AutoMPG_0359,4,120,74,2635,18.3,81,3,31.6 +AutoMPG_0360,4,141,80,3230,20.4,81,2,28.1 +AutoMPG_0362,6,168,116,2900,12.6,81,3,25.4 +AutoMPG_0363,6,146,120,2930,13.8,81,3,24.2 +AutoMPG_0364,6,231,110,3415,15.8,81,1,22.4 +AutoMPG_0365,8,350,105,3725,19,81,1,26.6 +AutoMPG_0366,6,200,88,3060,17.1,81,1,20.2 +AutoMPG_0367,6,225,85,3465,16.6,81,1,17.6 +AutoMPG_0368,4,112,88,2605,19.6,82,1,28 +AutoMPG_0369,4,112,88,2640,18.6,82,1,27 +AutoMPG_0370,4,112,88,2395,18,82,1,34 +AutoMPG_0371,4,112,85,2575,16.2,82,1,31 +AutoMPG_0373,4,151,90,2735,18,82,1,27 +AutoMPG_0375,4,151,NA,3035,20.5,82,1,23 +AutoMPG_0377,4,91,68,2025,18.2,82,3,37 +AutoMPG_0378,4,91,68,1970,17.6,82,3,31 +AutoMPG_0380,4,98,70,2125,17.3,82,1,36 +AutoMPG_0381,4,120,88,2160,14.5,82,3,36 +AutoMPG_0383,4,108,70,2245,16.9,82,3,34 +AutoMPG_0385,4,91,67,1965,15.7,82,3,32 +AutoMPG_0387,6,181,110,2945,16.4,82,1,25 +AutoMPG_0388,6,262,85,3015,17,82,1,38 +AutoMPG_0389,4,156,92,2585,14.5,82,1,26 +AutoMPG_0390,6,232,112,2835,14.7,82,1,22 +AutoMPG_0391,4,144,96,2665,13.9,82,3,32 +AutoMPG_0392,4,135,84,2370,13,82,1,36 +AutoMPG_0393,4,151,90,2950,17.3,82,1,27 +AutoMPG_0395,4,97,52,2130,24.6,82,2,44 +AutoMPG_0397,4,120,79,2625,18.6,82,1,28 +AutoMPG_0398,4,119,82,2720,19.4,82,1,31 diff --git a/data/UCIRegression/auto_mpg_copy.csv b/data/UCIRegression/auto_mpg_copy.csv new file mode 100644 index 00000000..0e82e885 --- /dev/null +++ b/data/UCIRegression/auto_mpg_copy.csv @@ -0,0 +1,319 @@ +InstanceID,Cylinders,Displacement,Horsepower,Weight,Acceleration,ModelYear,Origin,MPG +AutoMPG_0001,8,307,130,3504,12,70,1,18 +AutoMPG_0002,8,350,165,3693,11.5,70,1,15 +AutoMPG_0003,8,318,150,3436,11,70,1,18 +AutoMPG_0004,8,304,150,3433,12,70,1,16 +AutoMPG_0006,8,429,198,4341,10,70,1,15 +AutoMPG_0008,8,440,215,4312,8.5,70,1,14 +AutoMPG_0009,8,455,225,4425,10,70,1,14 +AutoMPG_0010,8,390,190,3850,8.5,70,1,15 +AutoMPG_0011,8,383,170,3563,10,70,1,15 +AutoMPG_0013,8,400,150,3761,9.5,70,1,15 +AutoMPG_0014,8,455,225,3086,10,70,1,14 +AutoMPG_0015,4,113,95,2372,15,70,3,24 +AutoMPG_0016,6,198,95,2833,15.5,70,1,22 +AutoMPG_0017,6,199,97,2774,15.5,70,1,18 +AutoMPG_0018,6,200,85,2587,16,70,1,21 +AutoMPG_0019,4,97,88,2130,14.5,70,3,27 +AutoMPG_0020,4,97,46,1835,20.5,70,2,26 +AutoMPG_0021,4,110,87,2672,17.5,70,2,25 +AutoMPG_0022,4,107,90,2430,14.5,70,2,24 +AutoMPG_0023,4,104,95,2375,17.5,70,2,25 +AutoMPG_0024,4,121,113,2234,12.5,70,2,26 +AutoMPG_0026,8,360,215,4615,14,70,1,10 +AutoMPG_0028,8,318,210,4382,13.5,70,1,11 +AutoMPG_0029,8,304,193,4732,18.5,70,1,9 +AutoMPG_0031,4,140,90,2264,15.5,71,1,28 +AutoMPG_0032,4,113,95,2228,14,71,3,25 +AutoMPG_0035,6,225,105,3439,15.5,71,1,16 +AutoMPG_0038,6,232,100,3288,15.5,71,1,18 +AutoMPG_0040,8,400,175,4464,11.5,71,1,14 +AutoMPG_0041,8,351,153,4154,13.5,71,1,14 +AutoMPG_0043,8,383,180,4955,11.5,71,1,12 +AutoMPG_0044,8,400,170,4746,12,71,1,13 +AutoMPG_0045,8,400,175,5140,12,71,1,13 +AutoMPG_0046,6,258,110,2962,13.5,71,1,18 +AutoMPG_0047,4,140,72,2408,19,71,1,22 +AutoMPG_0048,6,250,100,3282,15,71,1,19 +AutoMPG_0049,6,250,88,3139,14.5,71,1,18 +AutoMPG_0050,4,122,86,2220,14,71,1,23 +AutoMPG_0051,4,116,90,2123,14,71,2,28 +AutoMPG_0052,4,79,70,2074,19.5,71,2,30 +AutoMPG_0053,4,88,76,2065,14.5,71,2,30 +AutoMPG_0055,4,72,69,1613,18,71,3,35 +AutoMPG_0056,4,97,60,1834,19,71,2,27 +AutoMPG_0058,4,113,95,2278,15.5,72,3,24 +AutoMPG_0059,4,97.5,80,2126,17,72,1,25 +AutoMPG_0060,4,97,54,2254,23.5,72,2,23 +AutoMPG_0061,4,140,90,2408,19.5,72,1,20 +AutoMPG_0062,4,122,86,2226,16.5,72,1,21 +AutoMPG_0063,8,350,165,4274,12,72,1,13 +AutoMPG_0064,8,400,175,4385,12,72,1,14 +AutoMPG_0065,8,318,150,4135,13.5,72,1,15 +AutoMPG_0066,8,351,153,4129,13,72,1,14 +AutoMPG_0068,8,429,208,4633,11,72,1,11 +AutoMPG_0069,8,350,155,4502,13.5,72,1,13 +AutoMPG_0071,8,400,190,4422,12.5,72,1,13 +AutoMPG_0072,3,70,97,2330,13.5,72,3,19 +AutoMPG_0073,8,304,150,3892,12.5,72,1,15 +AutoMPG_0074,8,307,130,4098,14,72,1,13 +AutoMPG_0075,8,302,140,4294,16,72,1,13 +AutoMPG_0076,8,318,150,4077,14,72,1,14 +AutoMPG_0077,4,121,112,2933,14.5,72,2,18 +AutoMPG_0078,4,121,76,2511,18,72,2,22 +AutoMPG_0079,4,120,87,2979,19.5,72,2,21 +AutoMPG_0080,4,96,69,2189,18,72,2,26 +AutoMPG_0081,4,122,86,2395,16,72,1,22 +AutoMPG_0082,4,97,92,2288,17,72,3,28 +AutoMPG_0084,4,98,80,2164,15,72,1,28 +AutoMPG_0085,4,97,88,2100,16.5,72,3,27 +AutoMPG_0087,8,304,150,3672,11.5,73,1,14 +AutoMPG_0088,8,350,145,3988,13,73,1,13 +AutoMPG_0090,8,318,150,3777,12.5,73,1,15 +AutoMPG_0091,8,429,198,4952,11.5,73,1,12 +AutoMPG_0092,8,400,150,4464,12,73,1,13 +AutoMPG_0094,8,318,150,4237,14.5,73,1,14 +AutoMPG_0095,8,440,215,4735,11,73,1,13 +AutoMPG_0096,8,455,225,4951,11,73,1,12 +AutoMPG_0097,8,360,175,3821,11,73,1,13 +AutoMPG_0098,6,225,105,3121,16.5,73,1,18 +AutoMPG_0099,6,250,100,3278,18,73,1,16 +AutoMPG_0100,6,232,100,2945,16,73,1,18 +AutoMPG_0101,6,250,88,3021,16.5,73,1,18 +AutoMPG_0104,8,400,150,4997,14,73,1,11 +AutoMPG_0107,8,350,180,4499,12.5,73,1,12 +AutoMPG_0108,6,232,100,2789,15,73,1,18 +AutoMPG_0109,4,97,88,2279,19,73,3,20 +AutoMPG_0110,4,140,72,2401,19.5,73,1,21 +AutoMPG_0111,4,108,94,2379,16.5,73,3,22 +AutoMPG_0112,3,70,90,2124,13.5,73,3,18 +AutoMPG_0113,4,122,85,2310,18.5,73,1,19 +AutoMPG_0114,6,155,107,2472,14,73,1,21 +AutoMPG_0115,4,98,90,2265,15.5,73,2,26 +AutoMPG_0116,8,350,145,4082,13,73,1,15 +AutoMPG_0117,8,400,230,4278,9.5,73,1,16 +AutoMPG_0118,4,68,49,1867,19.5,73,2,29 +AutoMPG_0119,4,116,75,2158,15.5,73,2,24 +AutoMPG_0120,4,114,91,2582,14,73,2,20 +AutoMPG_0121,4,121,112,2868,15.5,73,2,19 +AutoMPG_0122,8,318,150,3399,11,73,1,15 +AutoMPG_0123,4,121,110,2660,14,73,2,24 +AutoMPG_0124,6,156,122,2807,13.5,73,3,20 +AutoMPG_0125,8,350,180,3664,11,73,1,11 +AutoMPG_0126,6,198,95,3102,16.5,74,1,20 +AutoMPG_0127,6,200,NA,2875,17,74,1,21 +AutoMPG_0128,6,232,100,2901,16,74,1,19 +AutoMPG_0129,6,250,100,3336,17,74,1,15 +AutoMPG_0130,4,79,67,1950,19,74,3,31 +AutoMPG_0131,4,122,80,2451,16.5,74,1,26 +AutoMPG_0132,4,71,65,1836,21,74,3,32 +AutoMPG_0133,4,140,75,2542,17,74,1,25 +AutoMPG_0134,6,250,100,3781,17,74,1,16 +AutoMPG_0135,6,258,110,3632,18,74,1,16 +AutoMPG_0136,6,225,105,3613,16.5,74,1,18 +AutoMPG_0137,8,302,140,4141,14,74,1,16 +AutoMPG_0139,8,318,150,4457,13.5,74,1,14 +AutoMPG_0140,8,302,140,4638,16,74,1,14 +AutoMPG_0141,8,304,150,4257,15.5,74,1,14 +AutoMPG_0142,4,98,83,2219,16.5,74,2,29 +AutoMPG_0143,4,79,67,1963,15.5,74,2,26 +AutoMPG_0146,4,83,61,2003,19,74,3,32 +AutoMPG_0147,4,90,75,2125,14.5,74,1,28 +AutoMPG_0148,4,90,75,2108,15.5,74,2,24 +AutoMPG_0149,4,116,75,2246,14,74,2,26 +AutoMPG_0150,4,120,97,2489,15,74,3,24 +AutoMPG_0152,4,79,67,2000,16,74,2,31 +AutoMPG_0153,6,225,95,3264,16,75,1,19 +AutoMPG_0154,6,250,105,3459,16,75,1,18 +AutoMPG_0155,6,250,72,3432,21,75,1,15 +AutoMPG_0156,6,250,72,3158,19.5,75,1,15 +AutoMPG_0157,8,400,170,4668,11.5,75,1,16 +AutoMPG_0158,8,350,145,4440,14,75,1,15 +AutoMPG_0160,8,351,148,4657,13.5,75,1,14 +AutoMPG_0161,6,231,110,3907,21,75,1,17 +AutoMPG_0162,6,250,105,3897,18.5,75,1,16 +AutoMPG_0163,6,258,110,3730,19,75,1,15 +AutoMPG_0164,6,225,95,3785,19,75,1,18 +AutoMPG_0165,6,231,110,3039,15,75,1,21 +AutoMPG_0166,8,262,110,3221,13.5,75,1,20 +AutoMPG_0168,4,97,75,2171,16,75,3,29 +AutoMPG_0169,4,140,83,2639,17,75,1,23 +AutoMPG_0171,4,140,78,2592,18.5,75,1,23 +AutoMPG_0172,4,134,96,2702,13.5,75,3,24 +AutoMPG_0173,4,90,71,2223,16.5,75,2,25 +AutoMPG_0174,4,119,97,2545,17,75,3,24 +AutoMPG_0175,6,171,97,2984,14.5,75,1,18 +AutoMPG_0176,4,90,70,1937,14,75,2,29 +AutoMPG_0177,6,232,90,3211,17,75,1,19 +AutoMPG_0179,4,120,88,2957,17,75,2,23 +AutoMPG_0180,4,121,98,2945,14.5,75,2,22 +AutoMPG_0181,4,121,115,2671,13.5,75,2,25 +AutoMPG_0182,4,91,53,1795,17.5,75,3,33 +AutoMPG_0183,4,107,86,2464,15.5,76,2,28 +AutoMPG_0185,4,140,92,2572,14.9,76,1,25 +AutoMPG_0186,4,98,79,2255,17.7,76,1,26 +AutoMPG_0187,4,101,83,2202,15.3,76,2,27 +AutoMPG_0188,8,305,140,4215,13,76,1,17.5 +AutoMPG_0191,8,351,152,4215,12.8,76,1,14.5 +AutoMPG_0192,6,225,100,3233,15.4,76,1,22 +AutoMPG_0193,6,250,105,3353,14.5,76,1,22 +AutoMPG_0194,6,200,81,3012,17.6,76,1,24 +AutoMPG_0195,6,232,90,3085,17.6,76,1,22.5 +AutoMPG_0196,4,85,52,2035,22.2,76,1,29 +AutoMPG_0197,4,98,60,2164,22.1,76,1,24.5 +AutoMPG_0198,4,90,70,1937,14.2,76,2,29 +AutoMPG_0199,4,91,53,1795,17.4,76,3,33 +AutoMPG_0200,6,225,100,3651,17.7,76,1,20 +AutoMPG_0201,6,250,78,3574,21,76,1,18 +AutoMPG_0202,6,250,110,3645,16.2,76,1,18.5 +AutoMPG_0203,6,258,95,3193,17.8,76,1,17.5 +AutoMPG_0204,4,97,71,1825,12.2,76,2,29.5 +AutoMPG_0205,4,85,70,1990,17,76,3,32 +AutoMPG_0206,4,97,75,2155,16.4,76,3,28 +AutoMPG_0207,4,140,72,2565,13.6,76,1,26.5 +AutoMPG_0208,4,130,102,3150,15.7,76,2,20 +AutoMPG_0210,4,120,88,3270,21.9,76,2,19 +AutoMPG_0211,6,156,108,2930,15.5,76,3,19 +AutoMPG_0212,6,168,120,3820,16.7,76,2,16.5 +AutoMPG_0213,8,350,180,4380,12.1,76,1,16.5 +AutoMPG_0215,8,302,130,3870,15,76,1,13 +AutoMPG_0216,8,318,150,3755,14,76,1,13 +AutoMPG_0217,4,98,68,2045,18.5,77,3,31.5 +AutoMPG_0219,4,79,58,1825,18.6,77,2,36 +AutoMPG_0220,4,122,96,2300,15.5,77,1,25.5 +AutoMPG_0221,4,85,70,1945,16.8,77,3,33.5 +AutoMPG_0222,8,305,145,3880,12.5,77,1,17.5 +AutoMPG_0224,8,318,145,4140,13.7,77,1,15.5 +AutoMPG_0225,8,302,130,4295,14.9,77,1,15 +AutoMPG_0226,6,250,110,3520,16.4,77,1,17.5 +AutoMPG_0227,6,231,105,3425,16.9,77,1,20.5 +AutoMPG_0228,6,225,100,3630,17.7,77,1,19 +AutoMPG_0229,6,250,98,3525,19,77,1,18.5 +AutoMPG_0230,8,400,180,4220,11.1,77,1,16 +AutoMPG_0231,8,350,170,4165,11.4,77,1,15.5 +AutoMPG_0232,8,400,190,4325,12.2,77,1,15.5 +AutoMPG_0233,8,351,149,4335,14.5,77,1,16 +AutoMPG_0235,4,151,88,2740,16,77,1,24.5 +AutoMPG_0236,4,97,75,2265,18.2,77,3,26 +AutoMPG_0237,4,140,89,2755,15.8,77,1,25.5 +AutoMPG_0238,4,98,63,2051,17,77,1,30.5 +AutoMPG_0239,4,98,83,2075,15.9,77,1,33.5 +AutoMPG_0241,4,97,78,2190,14.1,77,2,30.5 +AutoMPG_0242,6,146,97,2815,14.5,77,3,22 +AutoMPG_0243,4,121,110,2600,12.8,77,2,21.5 +AutoMPG_0245,4,90,48,1985,21.5,78,2,43.1 +AutoMPG_0246,4,98,66,1800,14.4,78,1,36.1 +AutoMPG_0248,4,85,70,2070,18.6,78,3,39.4 +AutoMPG_0249,4,91,60,1800,16.4,78,3,36.1 +AutoMPG_0250,8,260,110,3365,15.5,78,1,19.9 +AutoMPG_0251,8,318,140,3735,13.2,78,1,19.4 +AutoMPG_0253,6,231,105,3535,19.2,78,1,19.2 +AutoMPG_0254,6,200,95,3155,18.2,78,1,20.5 +AutoMPG_0255,6,200,85,2965,15.8,78,1,20.2 +AutoMPG_0256,4,140,88,2720,15.4,78,1,25.1 +AutoMPG_0258,6,232,90,3210,17.2,78,1,19.4 +AutoMPG_0259,6,231,105,3380,15.8,78,1,20.6 +AutoMPG_0260,6,200,85,3070,16.7,78,1,20.8 +AutoMPG_0262,6,258,120,3410,15.1,78,1,18.1 +AutoMPG_0265,8,302,139,3205,11.2,78,1,18.1 +AutoMPG_0267,4,98,68,2155,16.5,78,1,30 +AutoMPG_0268,4,134,95,2560,14.2,78,3,27.5 +AutoMPG_0269,4,119,97,2300,14.7,78,3,27.2 +AutoMPG_0270,4,105,75,2230,14.5,78,1,30.9 +AutoMPG_0271,4,134,95,2515,14.8,78,3,21.1 +AutoMPG_0272,4,156,105,2745,16.7,78,1,23.2 +AutoMPG_0273,4,151,85,2855,17.6,78,1,23.8 +AutoMPG_0274,4,119,97,2405,14.9,78,3,23.9 +AutoMPG_0276,6,163,125,3140,13.6,78,2,17 +AutoMPG_0277,4,121,115,2795,15.7,78,2,21.6 +AutoMPG_0278,6,163,133,3410,15.8,78,2,16.2 +AutoMPG_0279,4,89,71,1990,14.9,78,2,31.5 +AutoMPG_0280,4,98,68,2135,16.6,78,3,29.5 +AutoMPG_0281,6,231,115,3245,15.4,79,1,21.5 +AutoMPG_0283,4,140,88,2890,17.3,79,1,22.3 +AutoMPG_0284,6,232,90,3265,18.2,79,1,20.2 +AutoMPG_0285,6,225,110,3360,16.6,79,1,20.6 +AutoMPG_0286,8,305,130,3840,15.4,79,1,17 +AutoMPG_0287,8,302,129,3725,13.4,79,1,17.6 +AutoMPG_0288,8,351,138,3955,13.2,79,1,16.5 +AutoMPG_0289,8,318,135,3830,15.2,79,1,18.2 +AutoMPG_0290,8,350,155,4360,14.9,79,1,16.9 +AutoMPG_0291,8,351,142,4054,14.3,79,1,15.5 +AutoMPG_0292,8,267,125,3605,15,79,1,19.2 +AutoMPG_0294,4,89,71,1925,14,79,2,31.9 +AutoMPG_0296,4,98,80,1915,14.4,79,1,35.7 +AutoMPG_0297,4,121,80,2670,15,79,1,27.4 +AutoMPG_0298,5,183,77,3530,20.1,79,2,25.4 +AutoMPG_0299,8,350,125,3900,17.4,79,1,23 +AutoMPG_0302,4,105,70,2200,13.2,79,1,34.2 +AutoMPG_0303,4,105,70,2150,14.9,79,1,34.5 +AutoMPG_0304,4,85,65,2020,19.2,79,3,31.8 +AutoMPG_0306,4,151,90,2670,16,79,1,28.4 +AutoMPG_0307,6,173,115,2595,11.3,79,1,28.8 +AutoMPG_0308,6,173,115,2700,12.9,79,1,26.8 +AutoMPG_0309,4,151,90,2556,13.2,79,1,33.5 +AutoMPG_0311,4,89,60,1968,18.8,80,3,38.1 +AutoMPG_0312,4,98,70,2120,15.5,80,1,32.1 +AutoMPG_0314,4,151,90,2678,16.5,80,1,28 +AutoMPG_0315,4,140,88,2870,18.1,80,1,26.4 +AutoMPG_0317,6,225,90,3381,18.7,80,1,19.1 +AutoMPG_0318,4,97,78,2188,15.8,80,2,34.3 +AutoMPG_0320,4,120,75,2542,17.5,80,3,31.3 +AutoMPG_0322,4,108,75,2265,15.2,80,3,32.2 +AutoMPG_0324,4,156,105,2800,14.4,80,1,27.9 +AutoMPG_0326,4,90,48,2085,21.7,80,2,44.3 +AutoMPG_0327,4,90,48,2335,23.7,80,2,43.4 +AutoMPG_0330,4,91,67,1850,13.8,80,3,44.6 +AutoMPG_0332,4,97,67,2145,18,80,3,33.8 +AutoMPG_0334,6,168,132,2910,11.4,80,3,32.7 +AutoMPG_0335,3,70,100,2420,12.5,80,3,23.7 +AutoMPG_0336,4,122,88,2500,15.1,80,2,35 +AutoMPG_0337,4,140,NA,2905,14.3,80,1,23.6 +AutoMPG_0338,4,107,72,2290,17,80,3,32.4 +AutoMPG_0339,4,135,84,2490,15.7,81,1,27.2 +AutoMPG_0340,4,151,84,2635,16.4,81,1,26.6 +AutoMPG_0341,4,156,92,2620,14.4,81,1,25.8 +AutoMPG_0342,6,173,110,2725,12.6,81,1,23.5 +AutoMPG_0343,4,135,84,2385,12.9,81,1,30 +AutoMPG_0344,4,79,58,1755,16.9,81,3,39.1 +AutoMPG_0346,4,81,60,1760,16.1,81,3,35.1 +AutoMPG_0347,4,97,67,2065,17.8,81,3,32.3 +AutoMPG_0348,4,85,65,1975,19.4,81,3,37 +AutoMPG_0349,4,89,62,2050,17.3,81,3,37.7 +AutoMPG_0350,4,91,68,1985,16,81,3,34.1 +AutoMPG_0351,4,105,63,2215,14.9,81,1,34.7 +AutoMPG_0352,4,98,65,2045,16.2,81,1,34.4 +AutoMPG_0353,4,98,65,2380,20.7,81,1,29.9 +AutoMPG_0355,4,100,NA,2320,15.8,81,2,34.5 +AutoMPG_0357,4,108,75,2350,16.8,81,3,32.4 +AutoMPG_0358,4,119,100,2615,14.8,81,3,32.9 +AutoMPG_0359,4,120,74,2635,18.3,81,3,31.6 +AutoMPG_0360,4,141,80,3230,20.4,81,2,28.1 +AutoMPG_0362,6,168,116,2900,12.6,81,3,25.4 +AutoMPG_0363,6,146,120,2930,13.8,81,3,24.2 +AutoMPG_0364,6,231,110,3415,15.8,81,1,22.4 +AutoMPG_0365,8,350,105,3725,19,81,1,26.6 +AutoMPG_0366,6,200,88,3060,17.1,81,1,20.2 +AutoMPG_0367,6,225,85,3465,16.6,81,1,17.6 +AutoMPG_0368,4,112,88,2605,19.6,82,1,28 +AutoMPG_0369,4,112,88,2640,18.6,82,1,27 +AutoMPG_0370,4,112,88,2395,18,82,1,34 +AutoMPG_0371,4,112,85,2575,16.2,82,1,31 +AutoMPG_0373,4,151,90,2735,18,82,1,27 +AutoMPG_0375,4,151,NA,3035,20.5,82,1,23 +AutoMPG_0377,4,91,68,2025,18.2,82,3,37 +AutoMPG_0378,4,91,68,1970,17.6,82,3,31 +AutoMPG_0380,4,98,70,2125,17.3,82,1,36 +AutoMPG_0381,4,120,88,2160,14.5,82,3,36 +AutoMPG_0383,4,108,70,2245,16.9,82,3,34 +AutoMPG_0385,4,91,67,1965,15.7,82,3,32 +AutoMPG_0387,6,181,110,2945,16.4,82,1,25 +AutoMPG_0388,6,262,85,3015,17,82,1,38 +AutoMPG_0389,4,156,92,2585,14.5,82,1,26 +AutoMPG_0390,6,232,112,2835,14.7,82,1,22 +AutoMPG_0391,4,144,96,2665,13.9,82,3,32 +AutoMPG_0392,4,135,84,2370,13,82,1,36 +AutoMPG_0393,4,151,90,2950,17.3,82,1,27 +AutoMPG_0395,4,97,52,2130,24.6,82,2,44 +AutoMPG_0397,4,120,79,2625,18.6,82,1,28 +AutoMPG_0398,4,119,82,2720,19.4,82,1,31 diff --git a/data/UCIRepBinaryClassification/hcc_survival_rep.csv b/data/UCIRepBinaryClassification/hcc_survival_rep.csv new file mode 100644 index 00000000..ae74ee95 --- /dev/null +++ b/data/UCIRepBinaryClassification/hcc_survival_rep.csv @@ -0,0 +1,34 @@ +InstanceID,Gender,Symptoms,Alcohol,HepatitisBSurfaceAntigen,HepatitisBeAntigen,HepatitisBCoreAntibody,HepatitisCVirusAntibody,Cirrhosis,EndemicCountries,Smoking,Diabetes,Obesity,Hemochromatosis,ArterialHypertension,ChronicRenalInsufficiency,HIV,NASH,EsophagealVarices,Splenomegaly,PortalHypertension,PortalVeinThrombosis,LiverMetastasis,RadiologicalHallmark,AgeAtDiagnosis,GramsAlcoholPerDay,PacksCigarettesPerYear,PerformanceStatus,EncephalopathyDegree,AscitesDegree,InternationalNormalisedRatio,AlphaFetoprotein,Hemoglobin,MeanCorpuscularVolume,Leukocytes,Platelets,Albumin,TotalBilirubin,AlanineTransaminase,AspartateTransaminase,GammaGlutamylTransferase,AlkalinePhosphatase,TotalProteins,Creatinine,NumberOfNodules,MajorDimensionOfNodule,DirectBilirubin,Iron,OxygenSaturation,Ferritin,Class +HCC_0005,1,1,1,1,0,1,0,1,0,1,0,0,0,1,1,0,0,0,0,0,0,0,1,76,100,30,0,1,1,0.94,49,14.3,95.1,6.4,199,4.1,0.7,147,306,173,109,6.9,1.8,1,9,NA,59,15,22,1 +HCC_0014,1,NA,0,0,0,0,1,1,NA,NA,0,0,0,0,0,0,0,0,0,0,0,0,1,56,0,NA,0,1,1,1.2,6.6,13.7,93.8,4.1,91000,4.5,1,103,96,205,70,8.8,0.88,1,22,NA,82,24,NA,1 +HCC_0016,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,1,41,100,0,1,1,2,1.61,4.6,10.2,89.6,5.5,161,3.1,3.1,24,57,163,176,5,0.8,2,2.6,1.3,25,13,60,1 +HCC_0018,1,1,1,0,0,0,0,1,0,1,0,0,NA,0,0,0,NA,1,1,1,1,1,1,60,100,60,2,1,1,1.05,9.2,10.3,103.7,5.4,159,3.8,0.5,56,91,459,146,5.4,1.23,5,13.5,3.8,187,58,443,1 +HCC_0035,1,1,1,1,0,1,0,1,NA,0,0,0,0,1,0,0,0,1,0,1,0,0,0,62,NA,0,0,1,1,1.28,5689,14.3,99.6,6.8,77,3.8,1.7,154,102,184,184,6.9,0.89,2,3,0.77,NA,NA,NA,1 +HCC_0038,1,1,1,0,0,0,0,1,NA,1,1,0,NA,1,0,0,NA,NA,0,1,0,0,1,84,200,30,1,1,2,1.24,633,13,96.5,7200,143000,2.3,1.1,40,58,322,209,6.7,1.4,5,4.9,0.2,57,25,134,0 +HCC_0043,0,0,1,0,0,0,0,1,NA,NA,0,0,0,0,0,0,0,NA,0,0,0,1,0,86,NA,NA,3,1,1,1.2,185203,15,85.5,8.8,183,3.6,1,49,117,442,278,7.2,0.86,5,15.8,0.3,21,9,279,0 +HCC_0050,1,NA,1,0,NA,1,0,1,0,1,0,0,0,0,0,0,0,1,1,1,0,0,0,58,NA,40,0,1,1,1.49,20,15,96.7,9,78,4.6,2.1,40,49,137,109,7.6,0.8,1,2,0.4,184,59,905,1 +HCC_0052,0,0,1,NA,NA,NA,1,1,NA,0,1,0,0,0,0,0,0,NA,1,1,0,1,0,73,100,0,0,1,1,1.2,41470,12.6,91.4,12,275000,3.11,2.3,55,94,394,350,7.3,1.7,5,NA,0.8,84,37,497,0 +HCC_0053,1,1,1,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,73,NA,0,0,1,1,1.33,4.7,11.8,80.2,3.7,99,4.1,0.7,50,47,67,62,7.4,0.77,1,2.3,NA,104,37,635,1 +HCC_0055,1,1,1,0,0,0,1,1,NA,1,0,NA,NA,0,0,0,NA,1,1,1,1,0,1,51,100,30,3,1,2,1.35,1898,12.4,95.1,9.8,216,2.7,8.2,164,523,433,397,6.7,0.82,1,2.1,5.5,56,27,742,0 +HCC_0056,0,1,0,NA,NA,NA,1,0,0,0,1,0,NA,1,0,NA,NA,0,NA,0,0,1,1,78,0,0,1,1,1,1.32,77,10.8,88,6000,174000,3.2,0.9,48,19,171,923,5.4,1.31,3,15.4,NA,NA,NA,NA,0 +HCC_0059,1,NA,1,0,0,0,0,1,0,0,1,NA,NA,0,0,0,NA,1,1,1,0,0,1,72,70,0,3,2,2,1.96,12,10.9,102,4.1,99,1.9,4.2,73,85,470,263,7,0.99,1,8.5,1.9,44,20,176,0 +HCC_0060,1,1,0,NA,NA,NA,NA,0,0,1,1,0,NA,1,1,NA,0,0,0,0,0,0,0,82,0,NA,0,1,1,1.11,NA,18.7,92.4,6900,270000,4,0.9,35,73,115,103,6.8,1.24,1,10,NA,NA,NA,NA,0 +HCC_0073,1,1,1,0,0,0,0,1,NA,1,0,0,0,1,0,0,0,NA,1,1,1,1,0,82,50,48,2,1,2,1.53,33502,14.4,101.1,11.6,109,3.1,2.3,27,80,177,1.28,6.7,1.5,5,4,0.8,26,15,227,1 +HCC_0077,1,1,1,0,0,0,0,1,0,NA,0,0,0,1,0,0,0,1,0,1,1,0,0,67,NA,NA,2,1,2,3.16,4181,9.1,103.6,5.1,128000,3,2.2,57,91,115,165,7.7,0.83,1,4.5,1.2,72,29.5,355,0 +HCC_0079,1,1,1,0,0,0,0,1,0,NA,0,0,0,0,0,0,0,NA,0,1,0,1,1,52,80,NA,3,1,1,1.34,345,9.8,81.8,13.6,561,2.6,0.5,43,43,23,88,5.6,NA,5,4.7,0.5,19,8,141,1 +HCC_0082,1,0,1,0,NA,0,0,1,0,NA,1,0,0,0,0,0,0,1,1,1,0,0,1,56,100,NA,1,2,1,1.63,5.04,15.8,99,5.8,75000,3.5,4.6,93,85,193,165,6.6,0.7,1,6,1.7,200,87,316,1 +HCC_0083,1,0,1,0,0,0,0,1,0,0,NA,NA,NA,1,1,0,0,0,NA,1,0,0,0,64,100,0,1,1,3,1.71,3.7,14.8,104.3,5.8,56000,2.7,2.6,74,157,311,280,8,0.8,2,3,1.4,NA,1.52,859,1 +HCC_0099,1,0,1,0,NA,0,0,1,0,NA,0,0,0,1,0,0,0,0,0,0,0,0,0,73,NA,NA,0,1,1,1.23,5.5,13.1,89.6,6.1,160000,3.2,0.8,28,30,90,92,6.3,0.86,5,NA,NA,93,25,29,1 +HCC_0102,1,1,0,0,0,0,1,1,0,NA,0,0,0,1,0,0,0,NA,1,1,0,1,1,52,0,NA,1,1,3,1.04,6574,13.5,98,4800,77000,3.5,28.9,56,192,464,262,6.9,1.2,5,4,19.5,121,27,749,0 +HCC_0113,1,0,1,0,0,0,0,1,0,NA,0,0,0,0,0,0,0,1,1,1,0,0,1,74,100,NA,0,1,1,1.36,18,15.3,90.9,4.9,81000,4.2,1.7,35,49,97,109,7.3,1.02,1,3.5,0.3,NA,NA,NA,1 +HCC_0115,1,1,1,0,0,0,0,1,0,NA,1,0,NA,0,0,0,0,1,1,1,1,0,1,60,100,NA,3,3,2,1.87,28274,10.3,94.7,11.1,109000,2.4,5.7,25,111,55,128,7,1.3,1,1.5,1.9,51,18,56,0 +HCC_0117,1,1,1,0,0,0,0,1,0,1,1,0,NA,1,0,0,0,1,1,1,0,0,0,57,96,60,0,1,3,1.17,1009,13.8,93.2,3100,137000,3,0.7,25,55,343,235,NA,0.79,2,20,NA,NA,NA,NA,0 +HCC_0118,1,1,1,1,1,1,0,1,0,NA,0,0,0,0,0,0,0,NA,1,1,0,0,0,63,120,NA,4,3,2,2.42,22475,12,111.4,9.9,70000,3.28,19,134,178,54,146,8,3.23,1,NA,9.7,106,67,2165,0 +HCC_0121,1,1,0,1,0,NA,0,1,1,0,1,0,0,1,0,NA,NA,NA,NA,NA,0,0,0,63,0,0,1,1,1,1.14,14177,10.2,96.1,6000,109000,2.6,4.9,70,113,833,980,7.5,0.78,5,9,2.8,NA,NA,NA,1 +HCC_0129,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,NA,NA,0,0,0,0,72,0,510,2,1,1,1.13,2.1,12.6,95.1,8.7,254000,3.68,0.7,26,38,161,127,6.9,1.11,2,4.3,NA,28,10,308,0 +HCC_0132,0,0,1,NA,NA,NA,0,1,0,NA,0,0,0,0,0,0,0,1,0,1,0,0,1,55,100,NA,2,2,2,2.5,7.5,11.3,119.6,13.1,135000,3.2,8.6,62,94,82,147,6.5,1,5,2.6,3.8,NA,NA,NA,1 +HCC_0139,0,1,0,0,0,1,0,1,NA,NA,NA,NA,0,NA,NA,0,1,0,0,0,0,0,1,55,0,NA,0,1,1,1.19,4.9,13.6,97.3,5400,133000,4.5,0.9,54,63,487,89,7.8,0.78,2,3.32,NA,78,30,220,1 +HCC_0151,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,36,0,0,0,1,1,1.12,3204,16.1,92,10.5,182,4.3,0.7,46,31,92,79,7.3,1,1,NA,0.2,NA,NA,NA,1 +HCC_0153,1,1,1,0,0,0,1,1,0,1,1,0,0,0,1,0,0,1,1,1,0,1,1,47,250,18,1,1,3,1.39,695,11.1,93.9,5.4,88000,2.7,1,31,73,38,44,7,0.96,5,3.5,NA,NA,NA,NA,1 +HCC_0155,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,1,1,0,0,0,36,0,0,0,1,1,1.52,615,11.7,99.7,5.6,70000,2.82,3,66,50,120,318,6.4,0.64,5,1.9,1,NA,NA,NA,1 +HCC_0161,0,0,1,NA,NA,NA,1,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,40,NA,NA,0,1,1,0.84,NA,15.4,109.2,9.3,184000,4.6,0.5,35,40,449,109,7.6,0.7,5,3,NA,NA,NA,NA,1 diff --git a/data/UCIRepMulticlassClassification/student_dropout_academic_success_rep.csv b/data/UCIRepMulticlassClassification/student_dropout_academic_success_rep.csv new file mode 100644 index 00000000..85f9bd41 --- /dev/null +++ b/data/UCIRepMulticlassClassification/student_dropout_academic_success_rep.csv @@ -0,0 +1,886 @@ +InstanceID,MaritalStatus,ApplicationMode,Course,DaytimeEveningAttendance,ApplicationOrder,PreviousQualification,Nationality,MothersQualification,FathersQualification,MothersOccupation,FathersOccupation,PreviousQualificationGrade,AdmissionGrade,Displaced,EducationalSpecialNeeds,Debtor,TuitionFeesUpToDate,Gender,ScholarshipHolder,International,AgeAtEnrollment,CurricularUnits1stSemCredited,CurricularUnits1stSemEnrolled,CurricularUnits1stSemEvaluations,CurricularUnits1stSemApproved,CurricularUnits1stSemGrade,CurricularUnits1stSemWithoutEvaluations,CurricularUnits2ndSemCredited,CurricularUnits2ndSemEnrolled,CurricularUnits2ndSemEvaluations,CurricularUnits2ndSemApproved,CurricularUnits2ndSemGrade,CurricularUnits2ndSemWithoutEvaluations,UnemploymentRate,InflationRate,GDP,Class +Student_00007,1,1,9500,1,1,1,1,19,38,7,10,142.0,128.4,1,0,0,1,0,1,0,18,0,7,9,7,13.3,0,0,8,8,8,14.345,0,15.5,2.8,-4.06,2 +Student_00009,1,1,9238,1,3,1,62,1,1,9,9,137.0,129.3,0,0,0,1,0,1,1,21,0,6,8,6,13.875,0,0,6,7,6,14.142857142857142,0,16.2,0.3,-0.92,2 +Student_00015,1,1,9085,1,1,1,1,38,37,5,5,149.0,137.1,1,0,0,1,0,1,0,18,0,5,7,4,13.25,0,0,5,5,5,12.0,0,10.8,1.4,1.74,2 +Student_00017,1,18,9238,1,1,1,1,19,38,5,8,137.0,137.4,1,0,0,1,0,0,0,18,0,6,10,1,12.0,0,0,6,14,2,11.0,0,10.8,1.4,1.74,1 +Student_00026,1,1,9238,1,1,1,1,19,38,9,9,151.0,157.0,1,0,1,1,0,1,0,18,0,6,8,5,11.6,0,0,6,12,4,11.0,0,7.6,2.6,0.32,1 +Student_00027,1,17,NA,1,2,1,1,19,38,7,8,115.0,116.4,1,0,0,1,0,0,0,21,0,6,9,6,11.375,0,0,6,9,6,13.285714285714286,0,16.2,0.3,-0.92,2 +Student_00028,1,1,9085,1,1,1,1,19,19,3,3,138.0,131.0,1,0,0,1,0,0,0,18,0,5,9,5,12.666666666666666,2,0,5,7,4,13.0,0,9.4,-0.8,-3.12,1 +Student_00038,1,43,9147,1,1,1,1,37,37,6,6,140.0,122.9,0,0,0,1,0,0,0,55,0,5,10,1,10.0,0,0,5,8,2,12.0,2,16.2,0.3,-0.92,0 +Student_00040,1,44,9130,1,1,39,6,4,4,3,6,120.0,120.0,0,0,1,0,0,0,1,20,2,6,13,3,11.666666666666666,0,1,6,11,3,12.0,0,12.4,0.5,1.79,0 +Student_00053,1,1,9773,1,1,1,1,1,19,7,7,127.0,121.8,1,0,0,1,0,1,0,20,0,6,11,4,14.0,0,0,6,12,3,11.0,0,9.4,-0.8,-3.12,1 +Student_00056,1,1,9500,1,1,1,1,1,19,5,5,130.0,129.1,1,0,0,1,0,0,0,18,0,7,9,7,13.044444444444444,0,0,8,10,8,13.595,0,15.5,2.8,-4.06,2 +Student_00061,1,1,9500,1,2,1,1,19,19,9,9,125.0,114.9,0,0,0,1,0,0,0,18,0,7,8,6,13.133333333333333,0,0,8,12,7,12.221428571428572,0,16.2,0.3,-0.92,2 +Student_00065,1,43,9070,1,1,1,1,1,1,3,NA,116.0,120.9,0,0,0,1,1,0,0,24,0,6,6,0,0.0,0,0,6,6,0,0.0,0,12.7,3.7,-1.7,1 +Student_00072,1,17,9500,1,1,1,1,37,19,8,4,150.0,130.8,0,0,0,1,1,0,0,24,0,7,8,7,11.975,0,0,8,8,8,13.75,0,13.9,-0.3,0.79,2 +Student_00082,1,39,9991,0,1,2,1,3,3,2,2,140.0,155.7,1,0,0,1,1,0,0,35,0,1,1,0,0.0,1,0,5,0,0,0.0,0,10.8,1.4,1.74,0 +Student_00093,1,15,9130,1,1,1,41,1,1,4,4,133.1,100.0,0,0,0,1,0,0,1,26,0,6,7,2,12.0,1,0,6,6,0,0.0,0,8.9,1.4,3.51,0 +Student_00094,2,39,9853,1,1,10,1,37,34,0,0,133.1,115.5,0,0,0,1,0,0,0,39,0,6,12,3,12.666666666666666,0,0,6,14,0,0.0,1,7.6,2.6,0.32,0 +Student_00101,1,53,9085,1,1,42,1,38,38,9,9,130.0,128.8,0,0,0,1,0,0,0,21,7,10,12,8,12.875,0,4,9,14,5,13.4,0,8.9,1.4,NA,0 +Student_00108,1,1,9085,1,1,1,1,1,1,4,4,113.0,106.7,1,0,0,1,0,0,0,20,0,6,15,4,14.2,0,0,6,17,4,13.25,0,15.5,2.8,-4.06,0 +Student_00113,1,1,9085,1,1,1,1,19,19,9,9,131.0,139.8,1,0,0,1,0,0,0,19,0,5,6,5,13.4,0,0,5,5,5,12.8,0,10.8,1.4,1.74,2 +Student_00115,1,17,9500,1,2,1,1,37,37,9,9,122.0,131.0,1,0,0,1,0,0,0,18,0,7,7,6,12.516666666666666,1,0,7,7,6,12.516666666666666,1,7.6,2.6,0.32,0 +Student_00118,1,17,9147,1,1,1,1,19,19,3,3,120.0,113.4,0,0,0,1,0,0,0,20,0,5,11,3,10.333333333333334,0,0,5,10,3,10.666666666666666,0,12.4,0.5,1.79,1 +Student_00127,1,44,9085,1,1,39,1,37,37,9,9,160.0,160.0,1,0,0,1,0,0,0,20,1,6,7,6,14.166666666666666,0,1,6,17,5,13.77777777777778,0,12.4,0.5,1.79,2 +Student_00129,1,17,9238,1,3,1,1,1,39,5,3,131.0,122.6,1,0,0,1,0,0,0,18,0,6,7,6,13.0,0,0,6,6,6,13.666666666666666,0,12.4,0.5,1.79,2 +Student_00131,1,1,9500,1,3,1,1,19,19,5,8,138.0,124.9,1,0,0,1,0,1,0,18,0,7,9,7,13.2375,0,0,8,9,7,13.742857142857144,0,13.9,-0.3,0.79,0 +Student_00147,1,1,9254,1,4,1,1,12,19,9,9,132.0,124.7,1,0,0,1,0,0,0,19,0,5,10,0,0.0,0,0,5,10,0,0.0,0,7.6,2.6,0.32,0 +Student_00158,1,17,9238,1,2,1,1,1,37,7,9,133.0,127.4,1,0,0,1,0,1,0,18,0,6,8,6,12.25,0,0,6,7,6,11.857142857142858,0,12.7,3.7,-1.7,2 +Student_00159,1,1,9238,1,3,1,1,19,1,9,10,125.0,123.6,1,0,0,1,0,0,0,20,0,6,10,4,NA,0,0,6,9,6,11.833333333333334,0,9.4,-0.8,-3.12,2 +Student_00164,1,17,9853,1,5,1,1,12,12,4,4,132.0,123.3,1,0,0,1,0,0,0,21,0,6,13,4,11.5,0,0,6,10,3,11.0,0,10.8,1.4,1.74,0 +Student_00172,1,17,9556,1,2,1,1,37,37,3,10,133.1,108.0,0,0,0,1,0,0,0,20,0,7,8,7,12.457142857142856,0,0,8,8,8,13.5625,0,15.5,2.8,-4.06,2 +Student_00177,1,39,9853,1,1,1,1,37,19,9,5,130.0,102.5,0,0,0,1,0,0,0,27,0,6,9,5,13.2,0,0,6,10,5,12.0,0,7.6,2.6,0.32,2 +Student_00178,1,1,9500,1,2,1,1,34,34,90,90,123.0,113.3,1,0,0,1,0,0,0,20,0,7,8,4,11.95,0,0,7,8,4,11.95,0,7.6,2.6,0.32,0 +Student_00179,1,1,9853,1,5,1,1,37,19,9,5,141.0,133.0,1,0,0,1,0,0,0,18,0,6,8,5,12.4,0,0,6,12,5,10.4,0,9.4,-0.8,-3.12,0 +Student_00180,1,7,9500,1,1,3,1,1,1,9,5,140.0,140.0,0,0,0,1,0,0,0,33,2,7,8,6,14.35,0,3,8,10,6,14.583333333333334,0,16.2,0.3,-0.92,0 +Student_00186,1,18,9147,1,2,1,1,3,3,5,7,132.0,119.1,1,0,1,0,0,0,0,20,0,5,9,3,10.0,0,0,5,9,3,10.571428571428571,0,10.8,1.4,1.74,0 +Student_00188,1,17,9500,1,3,1,1,38,1,9,4,141.0,129.0,1,0,0,1,0,1,0,18,0,7,7,6,13.05,0,0,7,7,6,13.05,0,7.6,2.6,0.32,2 +Student_00190,1,17,9070,1,4,1,1,1,3,4,1,148.0,163.4,1,0,0,1,0,0,0,20,0,6,7,6,11.5,0,0,6,6,6,12.0,0,16.2,0.3,-0.92,2 +Student_00191,1,1,9254,1,1,1,1,19,38,9,8,125.0,121.5,0,0,0,1,0,1,0,21,0,6,7,6,12.0,0,0,6,6,6,12.5,0,13.9,-0.3,0.79,2 +Student_00192,1,1,8014,0,1,1,1,1,37,7,3,120.0,122.8,0,0,0,1,0,0,0,23,0,6,13,2,10.0,0,0,5,12,1,10.0,0,9.4,-0.8,-3.12,1 +Student_00196,1,39,9991,0,1,40,1,19,1,3,4,130.0,152.0,1,0,0,1,0,0,0,27,0,5,0,0,0.0,0,0,5,0,0,0.0,0,8.9,1.4,3.51,0 +Student_00201,1,1,9085,1,1,1,1,1,1,4,7,138.0,NA,1,0,0,1,0,0,0,19,0,5,9,4,13.75,0,0,5,13,4,14.333333333333334,2,10.8,1.4,1.74,2 +Student_00207,1,1,9500,1,2,1,1,19,38,9,9,149.0,126.5,1,0,0,1,0,0,0,18,0,8,8,7,12.914285714285713,0,0,8,8,7,12.914285714285713,0,12.7,3.7,-1.7,2 +Student_00208,1,1,9773,1,4,1,1,3,19,1,4,155.0,149.8,1,0,0,1,0,1,0,18,0,6,6,6,13.833333333333334,0,0,6,6,6,14.166666666666666,0,16.2,0.3,-0.92,2 +Student_00216,1,39,9556,1,1,40,1,1,1,4,5,130.0,145.0,0,0,0,1,0,0,0,25,0,7,10,6,12.125,0,0,8,9,8,13.3125,0,15.5,2.8,-4.06,1 +Student_00218,NA,39,8014,0,1,1,1,19,37,8,7,120.0,100.0,1,0,0,1,0,0,0,24,0,6,11,1,10.0,0,0,6,6,0,0.0,6,9.4,-0.8,-3.12,0 +Student_00228,1,1,9238,1,1,1,1,1,1,9,9,135.0,133.3,0,0,0,1,0,1,0,20,0,6,6,6,12.0,0,0,6,7,6,12.857142857142858,0,11.1,0.6,2.02,2 +Student_00232,1,39,9254,1,1,3,1,19,19,4,6,133.1,130.5,0,0,0,1,0,0,0,38,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00237,1,1,9853,1,1,1,1,19,19,5,7,148.0,141.7,0,0,0,1,0,1,0,18,0,6,8,5,13.4,0,0,6,7,6,13.166666666666666,0,9.4,-0.8,-3.12,2 +Student_00242,1,16,171,1,1,1,1,3,3,3,3,145.0,155.0,1,0,0,1,0,0,0,24,11,17,19,11,12.909090909090908,0,9,13,15,9,13.555555555555555,0,12.4,0.5,1.79,1 +Student_00247,1,17,9500,1,3,1,1,19,37,7,6,129.0,120.0,1,0,0,1,0,1,0,19,0,8,8,7,13.151428571428571,0,0,8,8,7,13.151428571428571,0,10.8,1.4,1.74,2 +Student_00251,1,1,9070,1,3,1,1,19,38,9,9,125.0,125.4,1,0,0,1,0,0,0,19,0,6,7,5,12.4,0,0,6,6,5,12.4,0,9.4,-0.8,-3.12,1 +Student_00259,1,1,9238,1,1,1,1,1,1,9,8,121.0,118.9,1,0,0,1,0,1,0,19,0,6,8,5,11.666666666666666,0,0,6,9,5,12.666666666666666,0,12.4,0.5,1.79,2 +Student_00260,1,43,9238,1,1,1,1,1,1,3,1,124.0,118.8,1,0,1,0,0,0,0,22,6,10,16,6,11.833333333333334,0,2,7,8,2,13.0,0,16.2,0.3,-0.92,0 +Student_00265,1,1,9238,1,1,1,1,38,19,9,5,130.0,121.6,0,0,0,1,0,0,0,18,0,6,6,6,12.833333333333334,0,0,6,6,6,12.0,0,12.4,0.5,1.79,2 +Student_00270,1,1,9500,1,5,1,1,1,1,9,9,151.0,127.8,0,0,0,1,0,1,0,18,0,8,8,7,13.671428571428573,0,0,8,8,7,13.671428571428573,0,12.7,3.7,-1.7,2 +Student_00276,1,17,9500,1,3,1,1,12,1,4,10,145.0,139.8,1,0,0,1,0,0,0,18,0,7,7,7,13.685714285714283,0,0,8,8,8,15.3875,0,13.9,-0.3,0.79,2 +Student_00281,1,16,9147,1,2,1,1,38,37,9,9,139.0,123.7,1,0,0,1,0,1,0,22,0,5,8,4,12.0,0,0,5,8,4,11.4,2,16.2,0.3,-0.92,2 +Student_00285,1,1,8014,0,1,1,1,38,38,0,0,128.0,122.1,0,0,0,1,0,0,0,21,0,6,8,5,12.8,0,0,6,10,6,11.857142857142858,0,7.6,2.6,0.32,2 +Student_00286,2,39,9773,1,1,12,1,1,1,4,4,100.0,100.0,0,0,0,1,0,0,0,24,0,6,6,6,12.166666666666666,0,0,6,6,6,13.833333333333334,0,7.6,2.6,0.32,2 +Student_00287,1,17,9070,1,1,1,1,4,37,2,9,123.0,113.9,0,0,0,1,0,0,0,18,0,6,8,6,12.5,0,0,6,6,6,12.333333333333334,0,15.5,2.8,-4.06,1 +Student_00297,1,17,9773,1,2,1,1,19,38,9,8,126.0,118.7,1,0,0,1,0,1,0,18,0,6,6,6,14.166666666666666,0,0,6,6,6,13.666666666666666,0,12.4,0.5,1.79,2 +Student_00300,1,1,9500,1,1,1,1,19,38,5,7,141.0,125.5,0,0,0,1,0,0,0,18,0,8,10,8,12.86,2,0,8,10,8,12.86,2,9.4,-0.8,-3.12,2 +Student_00306,1,1,9670,1,1,1,1,1,19,4,10,119.0,115.5,1,0,0,1,0,0,0,19,0,6,8,4,11.0,0,0,6,9,4,11.0,0,10.8,1.4,1.74,1 +Student_00307,1,17,9670,1,4,1,1,1,19,5,5,120.0,117.2,1,0,0,1,0,0,0,18,0,6,8,6,11.875,0,0,6,11,4,14.6,0,11.1,0.6,2.02,2 +Student_00322,1,42,9500,1,1,1,1,37,37,7,9,100.0,100.0,1,0,0,1,0,1,0,19,0,8,8,7,13.058571428571428,0,0,8,8,7,13.058571428571428,0,10.8,1.4,1.74,2 +Student_00328,1,1,9238,1,1,1,1,1,1,9,6,134.0,130.9,0,0,1,1,0,0,0,18,0,6,10,6,11.857142857142858,0,0,6,9,5,11.0,0,13.9,-0.3,0.79,2 +Student_00337,1,7,9853,1,1,40,1,41,3,2,1,110.0,110.0,0,0,1,1,0,0,0,40,0,7,8,7,15.0,0,0,7,7,7,NA,0,12.4,0.5,1.79,2 +Student_00349,2,39,9238,1,1,1,1,37,37,9,9,120.0,116.0,0,0,0,1,0,0,0,44,0,6,8,6,13.0,0,0,6,6,6,13.833333333333334,0,12.7,3.7,-1.7,2 +Student_00356,NA,17,9085,1,1,1,1,19,1,4,5,133.0,127.1,1,0,0,1,0,0,0,18,0,6,7,6,15.0,0,0,6,7,6,16.428571428571427,0,11.1,0.6,2.02,2 +Student_00357,1,39,9500,1,1,19,1,38,37,9,9,133.1,133.0,0,0,0,1,0,0,0,24,0,7,9,6,12.585714285714284,0,0,8,9,7,13.44285714285714,0,13.9,-0.3,0.79,2 +Student_00359,1,39,9003,1,1,1,1,37,37,3,8,133.1,130.0,0,0,1,1,0,1,0,30,0,6,6,0,0.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,1 +Student_00367,1,1,9500,1,4,1,1,19,38,4,8,136.0,125.5,1,0,0,1,0,1,0,21,0,7,7,6,14.033333333333331,0,0,7,7,6,14.033333333333331,0,7.6,2.6,0.32,2 +Student_00373,1,17,9773,1,1,1,1,1,19,4,7,161.0,148.4,0,0,0,1,0,1,0,19,0,6,6,6,13.833333333333334,0,0,6,7,6,14.428571428571429,0,15.5,2.8,NA,2 +Student_00376,2,NA,8014,0,1,19,1,37,37,9,9,133.1,104.0,0,0,1,1,0,0,0,42,5,11,14,10,11.9,0,5,11,14,10,12.8,0,11.1,0.6,2.02,1 +Student_00377,1,18,9147,1,4,1,1,37,37,9,9,130.0,119.9,1,0,0,0,0,0,0,34,0,5,5,0,0.0,0,0,5,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00383,1,1,9238,1,1,1,1,38,38,5,7,135.0,121.0,0,0,0,1,0,0,0,19,0,6,13,3,10.333333333333334,0,0,6,12,3,10.333333333333334,0,7.6,2.6,0.32,1 +Student_00391,1,44,9085,1,1,39,1,4,38,4,5,140.0,140.0,1,0,0,1,0,0,0,21,0,6,11,4,12.75,0,0,6,19,1,11.0,0,12.4,0.5,1.79,1 +Student_00392,1,39,9500,1,1,1,1,1,19,5,3,150.0,140.0,0,1,0,1,0,0,0,26,0,7,11,5,11.2,0,0,8,13,5,12.14,0,16.2,0.3,-0.92,1 +Student_00397,1,51,9238,1,1,1,1,3,19,3,10,121.0,111.9,1,0,0,1,0,0,0,20,5,11,12,11,11.727272727272728,0,5,11,14,11,12.0,0,12.4,0.5,1.79,2 +Student_00400,1,17,9147,1,1,1,1,38,37,6,4,96.0,96.0,1,0,0,1,0,0,0,19,0,5,10,3,10.666666666666666,0,0,5,9,0,0.0,3,16.2,0.3,-0.92,0 +Student_00401,1,17,9070,1,4,1,1,1,3,3,3,125.0,128.9,0,0,0,1,0,1,0,18,0,6,9,5,11.6,0,0,6,8,4,11.2,0,8.9,1.4,3.51,1 +Student_00407,1,7,9070,1,1,40,1,1,19,3,9,120.0,120.0,1,0,0,1,0,0,0,21,9,13,14,13,13.615384615384617,1,6,12,12,12,14.25,0,13.9,-0.3,0.79,2 +Student_00410,4,39,9085,1,1,1,1,34,34,0,0,133.1,128.2,0,0,0,1,0,0,0,25,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00411,1,1,9500,1,2,1,1,NA,19,7,7,137.0,120.8,1,0,0,1,0,1,0,18,0,8,8,7,14.654285714285717,0,0,8,8,7,14.654285714285717,0,10.8,1.4,1.74,2 +Student_00431,1,1,9500,1,3,1,1,37,38,9,9,134.0,120.3,1,0,0,1,0,1,0,18,0,8,8,7,12.082857142857142,0,0,8,8,7,12.082857142857142,0,10.8,1.4,1.74,2 +Student_00433,1,17,9147,1,2,1,1,38,38,6,8,125.0,114.5,1,0,0,1,0,1,0,19,0,5,6,5,13.4,0,0,5,5,5,12.4,0,12.4,0.5,1.79,2 +Student_00436,1,1,9500,1,6,1,1,19,19,5,5,144.0,130.3,1,0,0,1,0,1,0,18,0,8,8,7,13.814285714285717,0,0,8,8,7,13.814285714285717,0,12.7,3.7,-1.7,2 +Student_00437,1,17,9254,1,1,1,1,19,19,5,5,122.0,118.2,0,0,0,1,0,1,0,20,0,6,10,4,11.25,0,0,6,6,6,10.5,0,12.4,0.5,1.79,1 +Student_00448,1,1,9500,1,2,1,1,1,19,7,7,140.0,129.9,1,0,0,1,0,0,0,18,0,7,8,7,12.92875,0,0,8,8,8,14.0625,0,15.5,2.8,-4.06,0 +Student_00449,1,1,9773,1,2,1,1,1,19,9,7,121.0,118.9,1,0,0,1,0,0,0,20,0,6,6,6,13.333333333333334,0,0,6,10,5,12.8,0,11.1,0.6,2.02,2 +Student_00458,1,43,9853,1,1,1,1,37,19,9,8,140.0,122.3,0,0,0,1,0,0,0,22,0,6,9,5,13.6,0,0,6,8,5,12.0,0,12.7,3.7,-1.7,0 +Student_00463,1,17,9238,1,1,1,1,3,1,2,3,144.0,126.9,0,0,0,1,0,0,0,19,0,6,8,5,10.6,0,0,6,11,4,10.5,0,15.5,2.8,-4.06,2 +Student_00481,1,1,9500,1,1,1,1,NA,1,4,4,136.0,123.8,0,0,0,1,0,0,0,19,0,7,10,6,11.614285714285714,0,0,8,8,8,14.0375,0,13.9,-0.3,0.79,2 +Student_00488,1,39,9670,1,1,1,1,1,19,5,4,120.0,140.4,0,0,0,1,0,0,0,31,2,6,13,5,11.4,0,0,6,14,4,11.75,0,13.9,-0.3,0.79,0 +Student_00490,1,1,9500,1,3,1,1,38,38,5,5,128.0,118.6,1,0,0,1,0,1,0,19,0,7,9,6,11.814285714285717,0,0,8,8,7,13.542857142857144,0,13.9,-0.3,0.79,2 +Student_00495,1,1,9853,1,1,1,1,3,1,2,5,126.0,116.9,1,1,0,1,0,0,0,18,0,7,10,6,10.666666666666666,0,0,7,12,6,12.833333333333334,0,13.9,-0.3,0.79,1 +Student_00498,1,17,9254,1,1,1,1,1,19,4,3,122.0,130.4,1,0,0,1,0,0,0,18,0,6,10,5,11.8,0,0,6,10,5,12.2,0,11.1,0.6,2.02,2 +Student_00501,1,17,9085,1,3,1,1,37,38,9,9,134.0,120.4,1,0,0,1,0,0,0,20,0,5,13,3,11.333333333333334,2,0,5,8,5,12.6,0,9.4,-0.8,-3.12,1 +Student_00502,1,17,9254,1,2,1,1,38,38,9,9,128.0,129.1,1,0,0,1,0,0,0,18,0,6,6,6,12.666666666666666,0,0,6,7,5,14.6,0,11.1,0.6,2.02,2 +Student_00506,1,39,9500,1,1,19,1,37,38,151,161,133.1,143.7,0,0,0,1,0,0,0,27,0,7,12,4,14.0,0,0,7,14,3,12.525,0,12.4,0.5,1.79,1 +Student_00507,1,39,33,1,1,1,1,3,1,2,4,140.0,152.8,0,0,0,1,0,0,0,26,0,7,9,7,14.75,0,0,7,12,5,13.8,3,16.2,0.3,-0.92,1 +Student_00508,1,1,9773,1,2,1,1,19,1,9,3,138.0,133.5,1,0,0,1,0,0,0,18,0,6,6,6,12.666666666666666,0,0,6,6,6,13.666666666666666,0,12.7,3.7,-1.7,2 +Student_00514,1,39,9991,0,1,1,1,37,19,9,2,100.0,121.9,0,0,0,0,0,0,0,40,0,4,4,0,0.0,0,0,5,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_00516,2,18,9238,1,2,1,1,37,37,9,10,140.0,120.4,0,0,1,0,0,0,0,39,0,6,0,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00520,1,17,9853,1,2,1,1,37,37,9,9,118.0,112.1,1,0,0,1,0,0,0,23,0,6,11,4,11.25,0,0,6,10,5,10.2,0,7.6,2.6,0.32,0 +Student_00523,1,15,9238,1,1,1,26,3,37,2,8,150.0,132.5,1,0,0,0,0,0,1,20,0,6,9,5,13.0,0,0,6,7,6,13.5,0,13.9,-0.3,0.79,2 +Student_00543,1,NA,9003,1,1,39,1,1,19,4,10,150.0,150.0,0,0,0,1,1,1,0,21,0,6,8,6,13.0,0,0,6,10,6,12.625,0,15.5,2.8,-4.06,2 +Student_00544,1,1,9500,1,1,1,1,1,1,5,3,154.0,144.9,0,0,0,1,1,1,0,18,0,7,7,7,15.957142857142856,0,0,8,9,8,15.188888888888888,0,16.2,0.3,-0.92,2 +Student_00555,1,17,9147,1,2,1,1,1,1,4,4,133.1,95.0,0,0,0,1,1,0,0,20,0,5,14,0,0.0,0,0,5,5,0,0.0,0,11.1,0.6,2.02,0 +Student_00562,1,1,9130,1,1,1,1,NA,1,3,3,132.0,143.9,1,0,0,1,1,0,0,20,0,5,14,2,11.0,3,0,5,9,3,12.666666666666666,0,9.4,-0.8,-3.12,1 +Student_00571,1,1,8014,0,1,1,1,1,1,9,9,130.0,118.1,0,0,0,1,1,0,0,20,0,6,7,6,12.166666666666666,0,0,6,9,6,12.0,0,7.6,2.6,0.32,2 +Student_00578,1,39,9991,0,2,1,1,19,37,9,8,172.0,150.0,1,0,0,1,0,1,0,28,0,5,7,5,10.6,0,0,5,6,5,10.2,0,9.4,-0.8,-3.12,1 +Student_00580,1,1,9070,1,4,1,1,37,37,9,8,136.0,136.7,1,0,0,1,0,0,0,20,0,6,6,4,13.5,0,0,6,8,6,13.625,0,10.8,1.4,1.74,2 +Student_00585,1,NA,9254,1,1,1,1,37,37,7,7,102.0,102.0,0,0,0,1,0,0,0,19,0,6,8,5,11.8,0,0,6,8,5,11.6,0,10.8,1.4,1.74,2 +Student_00588,1,17,9773,1,1,1,1,38,38,9,8,121.0,120.4,1,0,0,1,0,1,0,18,0,6,6,6,12.833333333333334,0,0,6,7,6,12.285714285714286,0,15.5,2.8,-4.06,2 +Student_00595,1,17,9003,1,1,1,1,37,37,4,NA,119.0,113.2,0,0,1,1,0,0,0,20,0,6,8,6,13.333333333333334,0,0,6,8,5,14.0,0,11.1,0.6,2.02,1 +Student_00606,1,1,171,1,3,1,1,9,1,6,6,115.0,108.7,1,0,0,0,0,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_00610,1,43,9500,1,3,1,1,38,37,6,5,126.0,124.3,1,0,0,1,0,1,0,18,0,7,8,5,11.98,0,0,7,8,5,11.98,0,7.6,2.6,0.32,1 +Student_00611,1,1,9853,1,2,1,1,37,37,191,182,112.0,106.1,1,0,1,1,0,1,0,20,0,7,7,7,13.857142857142858,0,0,7,8,7,12.571428571428571,0,8.9,1.4,3.51,2 +Student_00614,1,17,9147,1,3,1,1,1,19,5,7,118.0,118.0,0,0,0,1,0,0,0,20,0,5,11,4,11.0,0,0,5,7,5,13.2,0,12.4,0.5,1.79,1 +Student_00617,1,17,9238,1,2,3,1,37,37,7,8,105.0,129.7,1,0,0,NA,0,1,0,20,0,6,6,6,12.333333333333334,0,0,6,6,6,10.666666666666666,0,9.4,-0.8,-3.12,2 +Student_00622,1,17,9147,1,2,1,1,1,38,4,3,116.0,114.6,1,0,0,1,0,0,0,19,0,5,15,2,10.75,0,0,5,11,2,10.0,0,13.9,-0.3,0.79,0 +Student_00626,1,1,9853,1,1,1,1,19,19,9,8,133.1,132.0,1,0,0,1,0,0,0,21,0,6,8,5,12.0,0,0,6,9,5,10.8,0,12.7,3.7,-1.7,0 +Student_00630,1,1,9773,1,1,1,1,19,37,9,9,134.0,131.6,1,1,0,1,0,0,0,19,0,6,10,5,11.8,0,0,6,10,5,12.0,0,10.8,1.4,1.74,2 +Student_00636,1,17,9238,1,5,1,1,37,37,7,5,122.0,112.9,1,0,0,1,0,1,0,19,0,6,8,6,12.125,0,0,6,7,6,12.714285714285714,0,16.2,0.3,-0.92,2 +Student_00638,1,39,9991,0,1,1,1,38,1,9,4,120.0,123.2,0,0,0,1,0,0,0,27,0,5,9,3,10.666666666666666,0,0,5,7,4,11.4,0,10.8,1.4,1.74,1 +Student_00640,1,18,9773,1,1,1,1,1,1,3,3,135.0,129.8,0,0,0,1,0,1,0,18,0,6,6,6,12.666666666666666,0,0,6,6,6,11.833333333333334,0,12.7,3.7,-1.7,0 +Student_00641,2,39,9670,1,1,1,1,37,37,9,0,130.0,158.0,0,0,1,0,0,0,0,34,0,6,7,4,13.5,0,0,6,6,0,0.0,6,12.7,3.7,-1.7,0 +Student_00654,1,NA,9238,1,1,39,1,38,38,6,9,130.0,126.3,1,0,0,1,0,1,0,19,3,6,7,5,12.2,0,2,6,6,6,11.5,0,13.9,-0.3,0.79,2 +Student_00657,1,1,9238,1,1,1,1,NA,19,5,10,135.0,121.0,0,0,1,1,0,0,0,18,0,6,10,5,10.6,0,0,6,14,2,10.0,0,7.6,2.6,0.32,1 +Student_00660,1,39,9003,1,1,1,1,19,19,9,9,130.0,120.0,0,0,0,1,0,0,0,25,0,6,6,0,0.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_00674,1,1,9070,1,2,1,1,19,19,3,3,121.0,116.1,1,0,0,1,0,0,0,22,0,6,7,6,11.666666666666666,0,0,6,7,5,13.2,0,12.7,3.7,-1.7,2 +Student_00677,1,17,9070,1,4,1,1,1,19,5,7,160.0,155.5,1,0,0,1,0,0,0,18,0,6,6,6,14.0,0,0,6,6,6,15.0,0,11.1,0.6,2.02,2 +Student_00691,4,39,9130,1,1,19,1,37,38,9,4,133.1,100.9,0,0,0,1,1,0,0,48,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_00693,1,1,9254,1,1,1,1,19,19,9,3,140.0,130.0,0,0,0,1,1,0,0,21,0,6,8,6,12.571428571428571,0,0,6,10,4,13.0,0,12.7,3.7,-1.7,1 +Student_00707,2,39,8014,0,1,1,1,19,1,4,8,133.1,144.3,0,0,0,1,1,0,0,41,6,10,10,10,12.5,0,3,7,7,7,12.142857142857142,0,10.8,1.4,1.74,2 +Student_00711,2,39,9991,0,1,19,1,38,38,90,90,133.1,121.7,1,0,0,1,1,0,0,45,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_00716,1,43,8014,0,1,1,1,19,37,4,10,161.0,100.0,0,0,0,1,1,0,0,44,9,13,18,13,11.846153846153848,0,9,11,11,11,12.0,0,12.7,3.7,-1.7,2 +Student_00720,1,43,9670,1,1,1,1,38,1,8,10,142.0,138.5,1,0,0,1,1,0,0,18,0,6,16,5,13.8,0,0,6,7,5,12.4,0,13.9,-0.3,0.79,1 +Student_00721,1,43,33,1,1,19,1,38,38,4,4,133.1,140.0,0,0,1,1,1,0,0,35,3,10,18,6,12.666666666666666,0,1,9,11,3,12.0,2,16.2,0.3,-0.92,0 +Student_00723,1,1,171,1,1,1,1,19,38,9,5,156.0,170.0,1,0,0,1,1,0,0,22,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_00726,4,7,9500,1,1,3,1,37,38,9,7,140.0,140.0,0,0,0,1,1,0,0,51,4,7,7,7,15.2,0,6,8,8,8,16.575,0,13.9,-0.3,0.79,2 +Student_00728,1,39,9991,0,1,1,1,37,37,9,9,133.1,143.2,0,0,0,1,1,0,0,35,0,5,5,0,0.0,0,0,5,5,0,0.0,0,11.1,0.6,2.02,0 +Student_00736,1,17,9670,1,2,1,1,3,3,4,10,110.0,115.6,1,0,0,1,1,0,0,21,0,6,10,6,11.875,0,0,6,8,5,12.0,0,11.1,0.6,2.02,2 +Student_00739,1,1,171,1,1,1,1,1,3,3,7,137.0,146.5,1,0,1,1,1,0,0,19,6,12,13,11,12.0,0,4,11,15,10,11.181818181818182,0,8.9,1.4,3.51,1 +Student_00747,1,51,9003,1,1,39,1,1,19,4,4,130.0,120.0,1,0,1,0,1,0,0,22,0,6,12,3,11.333333333333334,0,0,6,13,2,11.0,0,8.9,1.4,3.51,0 +Student_00750,1,1,9500,1,2,1,1,1,1,5,3,134.0,128.4,1,0,0,1,0,0,0,18,0,7,7,7,13.471428571428572,0,0,8,9,8,13.944444444444445,0,16.2,0.3,-0.92,2 +Student_00760,NA,43,9147,1,2,1,1,37,37,9,9,133.1,109.0,1,0,0,1,0,0,0,46,4,9,18,8,11.375,2,0,5,11,5,11.8,0,9.4,-0.8,-3.12,2 +Student_00763,2,43,8014,0,3,19,1,37,37,9,9,100.0,120.0,1,0,0,1,1,0,0,41,5,9,11,9,12.0,0,3,7,8,6,12.0,0,NA,-0.8,-3.12,2 +Student_00766,1,1,9147,1,4,1,1,38,38,5,10,NA,111.3,0,0,0,1,1,0,0,20,0,5,8,5,10.2,0,0,5,7,5,11.2,0,12.4,0.5,1.79,1 +Student_00771,1,1,9085,1,1,1,1,1,1,9,9,134.0,133.0,1,0,0,1,0,1,0,20,0,6,8,6,15.142857142857142,0,0,6,8,6,15.142857142857142,0,11.1,0.6,2.02,2 +Student_00781,1,17,9773,1,1,1,1,38,38,7,7,150.0,137.8,1,0,0,1,0,1,0,18,0,6,6,6,15.0,0,0,6,6,6,15.5,0,8.9,1.4,3.51,2 +Student_00786,1,1,9238,1,1,1,1,1,1,1,1,121.0,115.1,1,0,0,1,0,0,0,19,0,6,10,6,10.833333333333334,0,0,6,7,6,12.142857142857142,0,11.1,0.6,2.02,2 +Student_00787,1,1,9070,1,1,1,1,3,3,1,2,153.0,146.7,1,0,0,1,0,0,0,18,0,6,6,6,13.666666666666666,0,0,6,6,5,14.0,0,12.7,3.7,-1.7,2 +Student_00795,1,1,9773,1,3,1,NA,19,19,3,3,121.0,116.1,0,0,0,1,0,1,0,18,0,6,6,6,13.166666666666666,0,0,6,6,6,12.166666666666666,0,12.4,0.5,1.79,2 +Student_00797,1,44,9070,1,1,1,1,1,1,9,8,140.0,144.3,1,0,0,1,0,0,0,19,2,7,7,7,13.0,0,5,9,9,9,13.22222222222222,0,12.4,0.5,1.79,2 +Student_00802,1,1,9238,1,2,1,1,19,1,9,8,117.0,110.0,1,0,1,0,0,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_00804,1,1,9773,1,1,1,1,38,38,9,9,141.0,128.4,1,0,0,1,0,0,0,18,0,6,6,6,15.5,0,0,6,6,6,14.0,0,11.1,0.6,2.02,2 +Student_00805,1,1,9853,1,3,1,1,1,3,5,3,122.0,113.6,0,0,0,1,0,0,0,19,0,7,7,7,13.857142857142858,0,0,7,7,7,14.285714285714286,0,11.1,0.6,2.02,2 +Student_00808,1,1,9130,1,1,1,1,3,3,2,10,143.0,141.3,0,0,1,0,0,0,0,23,0,6,10,6,14.0,0,0,6,11,4,13.0,0,11.1,0.6,2.02,1 +Student_00817,1,17,9070,1,1,1,1,1,37,4,5,136.0,130.8,0,0,0,1,0,0,0,20,0,6,6,6,12.5,0,0,6,8,6,11.5,0,10.8,1.4,1.74,1 +Student_00819,1,17,9500,1,2,1,1,19,37,3,5,132.0,125.4,1,0,0,0,0,1,0,20,0,7,7,7,13.462857142857144,0,0,8,10,7,13.164285714285716,0,11.1,0.6,2.02,1 +Student_00822,1,1,171,1,3,1,1,12,19,9,3,147.0,151.6,1,0,0,1,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_00826,1,17,9670,1,3,1,1,1,3,4,3,125.0,117.3,1,0,0,1,0,0,0,18,0,6,8,6,14.0,0,0,6,9,5,14.0,0,8.9,1.4,3.51,2 +Student_00827,1,17,9853,1,1,1,1,1,1,5,7,127.0,121.4,1,0,0,1,0,0,0,18,0,7,8,7,11.571428571428571,0,0,7,9,6,13.166666666666666,0,11.1,0.6,2.02,0 +Student_00828,1,NA,9070,1,3,1,1,1,3,9,7,132.0,126.1,1,0,0,1,0,1,0,18,0,6,6,6,15.833333333333334,0,0,6,6,6,15.333333333333334,0,11.1,0.6,2.02,2 +Student_00837,1,17,9119,1,3,1,1,3,3,3,4,138.0,125.4,1,1,0,1,1,0,0,19,0,5,10,3,13.333333333333334,0,0,5,9,4,10.75,0,8.9,1.4,3.51,0 +Student_00847,2,39,9991,0,1,1,1,1,1,194,131,160.0,128.4,0,0,0,1,0,0,0,34,0,5,12,5,10.4,0,0,5,11,5,12.0,0,12.4,0.5,1.79,2 +Student_00849,1,1,9085,1,1,1,1,1,1,2,NA,122.0,113.3,1,0,0,1,0,0,0,18,0,5,9,4,14.25,0,0,5,8,5,12.714285714285714,0,10.8,1.4,1.74,1 +Student_00860,1,1,9773,1,1,1,1,34,38,0,3,108.0,105.9,0,0,0,1,1,0,0,20,0,6,11,4,10.75,0,0,6,13,2,10.0,0,7.6,2.6,0.32,0 +Student_00874,1,1,9556,1,1,1,1,1,1,1,1,135.0,NA,0,0,0,1,1,1,0,21,0,7,14,5,11.2,0,0,8,11,6,11.583333333333334,0,16.2,0.3,-0.92,1 +Student_00876,1,1,9500,1,1,1,1,38,38,9,9,138.0,126.8,0,0,0,1,1,1,0,19,0,7,9,7,14.244444444444444,0,0,8,12,8,12.233333333333333,0,15.5,2.8,-4.06,2 +Student_00889,1,1,9500,1,1,1,1,19,19,4,7,136.0,136.0,0,0,0,1,NA,1,0,19,0,7,7,7,14.014285714285714,0,0,8,8,8,15.35,0,13.9,-0.3,0.79,2 +Student_00890,1,1,9773,1,3,1,1,38,38,9,5,145.0,133.1,0,0,0,1,0,1,0,20,0,6,9,4,13.0,0,0,6,13,4,11.25,0,10.8,1.4,1.74,2 +Student_00893,1,43,9500,1,1,1,1,37,37,9,9,150.0,130.8,1,0,0,1,0,1,0,21,0,8,8,7,14.428571428571429,0,0,8,8,7,14.428571428571429,0,12.7,3.7,-1.7,2 +Student_00905,1,1,9147,1,2,1,1,19,19,9,9,121.0,126.3,1,0,0,1,0,0,0,20,0,5,12,1,10.0,2,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_00907,1,1,9670,1,4,1,1,1,1,7,7,127.0,116.5,1,0,0,1,0,0,0,20,0,6,7,0,0.0,0,0,6,6,0,0.0,0,16.2,0.3,-0.92,0 +Student_00914,4,39,NA,0,1,1,1,37,37,9,7,130.0,138.0,0,0,0,1,0,0,0,42,0,6,8,5,11.2,0,0,6,6,6,12.0,0,8.9,1.4,3.51,2 +Student_00920,6,39,8014,0,1,1,1,37,1,9,7,133.1,114.8,0,0,0,1,0,1,0,41,0,6,10,5,12.833333333333334,0,0,6,6,6,12.333333333333334,0,13.9,-0.3,0.79,2 +Student_00931,1,1,9147,1,5,1,1,37,38,7,7,125.0,122.2,1,0,0,1,0,0,0,18,0,5,9,1,11.0,0,0,5,9,2,12.5,0,7.6,2.6,0.32,1 +Student_00936,1,1,171,1,3,1,1,1,1,3,3,145.0,140.1,1,0,0,1,0,0,0,20,6,12,12,12,13.25,0,4,11,14,11,14.333333333333334,0,8.9,1.4,3.51,2 +Student_00937,1,39,9500,1,1,19,1,38,38,9,9,133.1,114.8,0,0,0,1,0,0,0,28,0,7,15,1,10.75,0,0,7,10,1,10.0,0,13.9,-0.3,0.79,0 +Student_00938,1,44,9991,0,1,39,1,37,37,6,6,150.0,150.0,0,0,0,1,0,0,0,31,2,6,8,6,NA,0,2,7,8,7,13.428571428571429,0,9.4,-0.8,-3.12,1 +Student_00942,1,1,9238,1,1,1,1,37,19,9,4,128.0,127.3,1,0,0,1,0,1,0,19,0,6,8,6,14.0,0,0,6,8,6,12.285714285714286,0,16.2,0.3,-0.92,2 +Student_00943,2,39,9238,1,1,19,1,37,37,9,9,133.1,130.0,1,0,0,1,0,0,0,31,0,6,11,0,0.0,0,0,5,10,0,0.0,0,9.4,-0.8,-3.12,1 +Student_00952,2,39,9991,0,1,1,1,37,37,9,9,133.1,132.8,0,0,1,0,1,0,0,45,0,5,9,0,0.0,0,0,5,11,0,0.0,0,12.4,0.5,1.79,0 +Student_00957,1,17,9773,1,1,1,1,19,37,9,9,130.0,140.2,0,0,0,1,1,1,0,19,0,6,6,6,12.0,0,0,6,7,6,11.666666666666666,0,16.2,0.3,-0.92,2 +Student_00961,1,39,9670,1,1,1,1,34,34,0,0,120.0,106.0,1,0,0,0,1,0,0,28,0,5,7,3,11.666666666666666,0,0,5,8,2,11.5,1,7.6,2.6,0.32,0 +Student_00976,1,17,9119,1,3,1,1,1,19,9,3,120.0,116.9,1,0,1,0,1,0,0,18,0,5,10,3,12.0,0,0,5,8,3,10.333333333333334,0,8.9,1.4,3.51,1 +Student_00986,1,1,9500,1,1,1,1,19,19,3,3,154.0,142.0,0,0,0,1,1,0,0,19,0,8,8,7,13.714285714285714,0,0,8,8,7,13.714285714285714,0,12.7,3.7,-1.7,2 +Student_00987,1,7,9003,1,1,4,1,1,1,4,6,150.0,150.0,0,0,0,1,1,0,0,28,0,6,14,6,14.875,0,0,6,12,6,15.8,0,16.2,0.3,-0.92,2 +Student_00995,2,7,9238,1,1,3,1,37,37,191,192,150.0,NA,0,0,0,1,0,0,0,31,1,6,12,5,12.5,0,0,6,10,5,14.6,0,12.7,3.7,-1.7,2 +Student_00996,1,39,8014,0,1,1,1,37,37,9,8,130.0,103.5,0,0,0,1,0,1,0,33,0,6,6,6,14.166666666666666,0,0,6,6,6,14.333333333333334,0,12.7,3.7,-1.7,2 +Student_01007,1,17,9500,1,6,1,1,37,37,9,6,139.0,133.5,1,0,0,1,0,1,0,18,0,8,8,7,15.228571428571428,0,0,8,8,7,15.228571428571428,0,12.7,3.7,-1.7,2 +Student_01008,1,53,9238,1,1,42,1,37,37,9,10,140.0,136.9,1,0,0,1,0,0,0,21,5,9,10,9,12.77777777777778,0,4,9,9,9,13.22222222222222,0,8.9,1.4,3.51,2 +Student_01010,1,17,9670,1,3,1,1,1,38,3,3,122.0,114.3,1,0,0,1,0,0,0,18,0,6,8,6,13.875,0,0,6,7,6,13.714285714285714,0,11.1,0.6,2.02,2 +Student_01015,1,18,9147,1,2,1,1,37,38,191,143,102.0,101.7,1,0,0,1,0,1,0,20,0,5,6,5,11.8,0,0,5,6,5,11.6,0,8.9,1.4,3.51,2 +Student_01019,1,17,9670,1,4,1,1,19,37,9,99,110.0,106.1,1,1,1,0,0,1,0,18,0,6,6,1,11.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_01020,1,17,9773,1,3,1,1,1,1,4,9,132.0,124.3,1,0,1,1,0,1,0,19,0,6,6,6,11.833333333333334,0,0,6,7,6,12.285714285714286,0,15.5,2.8,-4.06,2 +Student_01023,NA,43,9500,1,2,1,1,41,3,2,2,120.0,112.7,0,0,0,1,0,0,0,21,0,8,12,6,11.68,0,0,8,12,6,11.68,0,10.8,1.4,1.74,2 +Student_01027,1,1,9085,1,1,1,1,30,19,4,90,123.0,122.3,0,0,0,1,0,0,0,18,0,5,6,5,14.2,0,0,5,7,5,11.8,0,7.6,2.6,0.32,2 +Student_01030,1,1,9500,1,4,1,1,1,1,9,9,136.0,123.8,1,0,0,1,0,1,0,19,0,8,8,7,13.314285714285717,0,0,8,8,7,13.314285714285717,0,12.7,3.7,-1.7,2 +Student_01033,1,1,9773,1,1,1,1,37,37,8,8,144.0,138.4,0,0,0,1,0,0,0,18,0,6,7,6,13.428571428571429,0,0,6,7,6,14.142857142857142,0,13.9,-0.3,0.79,2 +Student_01036,1,1,9070,1,3,1,1,1,38,9,7,125.0,118.0,0,0,0,1,0,1,0,18,0,6,6,6,14.333333333333334,0,0,6,7,6,14.0,0,11.1,0.6,2.02,1 +Student_01040,1,1,9853,1,1,1,1,3,1,2,5,124.0,121.6,0,0,0,1,0,0,0,18,0,6,9,5,12.333333333333334,0,0,6,10,5,10.6,0,15.5,2.8,-4.06,1 +Student_01061,1,53,9238,1,1,42,1,1,19,5,5,130.0,128.3,0,0,1,0,0,0,0,23,5,9,12,7,13.571428571428571,0,4,9,14,4,13.25,0,8.9,1.4,3.51,0 +Student_01063,1,39,8014,0,1,1,1,37,11,9,10,130.0,131.5,0,0,0,1,0,0,0,27,0,6,8,5,11.0,0,0,6,7,6,11.166666666666666,0,11.1,0.6,2.02,2 +Student_01074,1,1,9085,1,1,1,1,3,3,1,90,151.0,161.9,0,0,0,1,0,0,0,18,0,5,6,4,13.75,0,0,5,8,5,14.857142857142858,0,7.6,2.6,0.32,2 +Student_01076,1,1,9773,1,2,1,1,19,19,4,7,116.0,110.1,1,0,0,1,0,0,0,18,0,6,6,6,13.333333333333334,0,0,6,6,6,12.0,0,11.1,0.6,2.02,2 +Student_01078,1,17,9254,1,1,1,1,37,37,5,9,158.0,138.1,1,0,0,1,0,0,0,19,0,6,8,4,12.5,0,0,6,11,1,14.0,0,7.6,2.6,0.32,0 +Student_01082,1,1,9254,1,2,1,1,19,19,9,9,120.0,116.5,1,0,0,1,0,1,0,19,0,6,9,5,13.2,0,0,6,8,5,11.0,0,12.4,0.5,1.79,2 +Student_01091,1,17,9130,1,1,1,1,1,1,4,5,130.0,123.8,0,0,0,1,0,0,0,18,0,5,7,4,12.0,0,0,5,6,5,12.0,0,7.6,2.6,0.32,2 +Student_01092,1,17,9773,1,3,1,1,19,19,5,8,127.0,120.0,0,0,0,1,0,0,0,18,0,6,6,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_01103,1,1,9853,1,2,1,1,38,38,7,5,121.0,120.0,1,0,0,1,0,0,0,18,0,6,10,3,12.0,0,0,6,8,4,10.25,0,10.8,1.4,1.74,1 +Student_01105,1,1,9238,1,1,1,1,19,19,0,5,128.0,120.3,1,0,0,1,0,0,0,19,0,6,12,2,13.0,0,0,6,8,5,11.6,0,7.6,2.6,0.32,2 +Student_01108,1,1,9500,1,3,1,1,38,19,8,8,135.0,126.3,1,0,1,1,0,1,0,18,0,7,8,7,12.65,0,0,8,9,8,12.445555555555554,0,15.5,2.8,-4.06,2 +Student_01118,1,1,9500,1,1,1,1,38,19,9,5,138.0,144.3,0,0,0,1,0,0,0,20,0,7,9,6,12.7,0,0,8,8,7,13.571428571428571,0,13.9,-0.3,0.79,2 +Student_01123,1,42,9500,1,1,1,1,1,19,4,8,100.0,136.0,1,0,0,1,0,0,0,21,4,7,9,7,14.355555555555554,0,5,8,8,8,13.49375,0,15.5,2.8,-4.06,2 +Student_01124,1,44,9003,1,1,39,1,37,38,9,9,160.0,160.0,0,0,1,1,0,1,0,19,0,6,8,6,13.0,0,0,6,11,5,13.0,0,15.5,2.8,-4.06,2 +Student_01125,1,1,9773,1,1,1,1,38,37,9,9,152.0,139.1,0,0,0,1,0,1,0,19,0,6,6,6,12.833333333333334,0,0,6,6,6,13.5,0,16.2,0.3,-0.92,2 +Student_01132,1,42,9500,1,1,1,1,1,2,9,3,120.0,130.0,1,0,0,1,0,0,0,22,4,8,8,7,13.285714285714286,0,4,8,8,7,13.285714285714286,0,12.7,3.7,-1.7,2 +Student_01139,1,17,9500,1,4,1,1,38,37,3,3,141.0,126.3,1,0,0,1,0,0,0,18,0,8,8,7,13.297142857142855,0,0,8,8,7,13.297142857142855,0,10.8,1.4,1.74,2 +Student_01140,1,1,9085,1,1,1,1,19,19,4,6,149.0,147.6,1,0,0,1,0,0,0,20,0,6,14,6,13.923076923076923,0,0,6,9,6,14.25,0,15.5,2.8,-4.06,2 +Student_01142,1,17,9147,1,6,1,1,19,38,7,9,121.0,123.8,0,0,0,1,0,1,0,19,0,5,5,5,12.4,0,0,5,8,3,11.0,0,12.7,3.7,-1.7,1 +Student_01151,1,1,9070,1,1,1,1,12,19,4,5,130.0,118.5,0,1,0,1,0,1,0,18,0,6,6,6,12.0,0,0,6,8,6,11.285714285714286,0,8.9,1.4,3.51,2 +Student_01153,1,17,9147,1,3,1,1,1,19,3,5,112.0,107.8,1,0,0,1,0,0,0,19,0,5,7,3,10.333333333333334,0,0,5,11,3,14.428571428571429,0,10.8,1.4,1.74,1 +Student_01158,1,16,9254,1,4,1,1,38,37,9,7,126.0,118.7,1,0,0,1,0,1,0,21,0,6,7,6,13.571428571428571,0,0,6,6,6,12.5,0,8.9,1.4,3.51,2 +Student_01163,1,17,9500,1,3,1,1,38,1,9,5,139.0,131.8,1,0,0,1,0,0,0,18,0,8,8,7,14.652857142857142,0,0,8,8,7,14.652857142857142,0,10.8,1.4,1.74,2 +Student_01168,1,43,9773,1,2,1,1,19,19,0,0,132.0,127.1,0,0,0,1,1,0,0,23,0,6,9,6,12.333333333333334,0,0,6,11,5,13.0,0,7.6,2.6,0.32,2 +Student_01178,1,1,9070,1,2,1,101,2,1,9,1,152.0,168.5,1,0,0,1,1,0,1,21,0,6,7,5,14.6,0,0,6,6,5,14.2,0,16.2,0.3,-0.92,2 +Student_01179,4,39,9500,1,1,1,1,37,37,9,9,133.1,130.0,0,0,1,1,0,0,0,38,0,7,13,3,11.833333333333334,0,0,7,14,2,10.0,0,16.2,0.3,-0.92,0 +Student_01184,1,53,9085,1,1,42,1,19,38,9,9,140.0,138.2,0,0,1,0,0,0,0,21,7,10,15,8,13.75,0,4,9,17,5,13.2,0,8.9,1.4,3.51,0 +Student_01209,1,7,8014,0,1,3,1,37,38,0,5,130.0,NA,0,0,0,0,0,0,0,28,0,6,12,1,11.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_01212,1,17,9238,1,1,1,1,1,1,9,9,123.0,113.2,0,0,0,1,0,1,0,20,0,6,11,4,10.75,0,0,6,13,5,11.5,0,15.5,2.8,-4.06,1 +Student_01215,1,1,9500,1,4,1,1,19,19,7,9,126.0,121.3,1,0,0,1,0,1,0,18,0,7,9,6,13.533333333333331,0,0,7,7,7,12.228571428571428,0,12.4,0.5,1.79,1 +Student_01217,1,17,9238,1,4,1,1,19,19,5,8,124.0,117.7,1,0,0,1,0,0,0,18,0,6,10,5,12.0,0,0,6,11,4,12.0,0,16.2,0.3,-0.92,2 +Student_01218,1,44,8014,0,1,39,1,19,37,7,6,120.0,121.8,1,0,0,1,0,0,0,22,3,6,6,6,12.5,0,2,6,7,6,13.285714285714286,0,12.4,0.5,1.79,2 +Student_01219,1,1,9500,1,2,1,1,1,1,4,10,140.0,128.3,1,0,0,1,0,0,0,19,0,8,8,7,12.764285714285714,0,0,8,8,7,12.764285714285714,0,10.8,1.4,1.74,2 +Student_01220,1,18,9147,1,2,1,1,19,38,9,7,143.0,132.2,1,0,0,1,0,1,0,18,0,5,8,5,13.75,0,0,5,6,5,12.166666666666666,0,13.9,-0.3,0.79,2 +Student_01223,2,39,9991,0,1,19,1,19,39,5,3,133.1,121.7,0,0,1,0,0,0,0,31,0,5,7,0,0.0,0,0,5,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_01224,2,39,8014,0,1,19,1,1,19,1,5,100.0,130.0,0,0,1,1,0,1,0,33,0,6,9,5,13.833333333333334,0,0,6,7,6,12.5,0,9.4,-0.8,-3.12,2 +Student_01244,1,42,9085,1,1,39,1,19,3,9,1,140.0,159.9,1,0,0,1,0,0,0,21,2,6,14,5,13.666666666666666,0,2,6,10,5,13.0,0,16.2,0.3,-0.92,2 +Student_01246,2,39,9853,1,1,1,1,37,37,5,5,133.1,116.5,0,0,0,1,0,0,0,34,0,7,11,1,10.0,0,0,7,7,1,13.0,0,16.2,0.3,-0.92,0 +Student_01262,1,42,9119,1,1,1,1,19,37,9,3,130.0,135.0,0,0,1,1,1,0,0,25,0,5,5,0,0.0,0,2,6,7,2,14.0,0,13.9,-0.3,0.79,0 +Student_01283,1,17,9254,1,5,1,1,1,19,4,7,121.0,116.5,1,0,0,0,1,0,0,18,0,6,12,0,0.0,0,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01292,1,1,9500,1,1,1,1,38,38,9,9,143.0,140.0,0,0,0,1,1,0,0,19,0,8,8,7,14.285714285714286,0,0,8,8,7,14.285714285714286,0,12.7,3.7,-1.7,2 +Student_01301,1,17,9147,1,1,1,1,1,19,3,4,123.0,122.0,0,0,0,1,1,0,0,19,0,5,7,3,12.333333333333334,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_01307,1,53,9003,1,1,42,1,1,38,8,8,150.0,150.0,0,0,0,1,0,1,0,23,7,12,14,12,14.384615384615383,0,5,10,12,10,13.3,0,8.9,1.4,3.51,2 +Student_01308,NA,17,9147,1,3,1,1,19,38,5,7,147.0,132.3,1,0,0,1,0,1,0,18,0,5,5,5,13.4,0,0,5,6,5,12.2,0,12.7,3.7,-1.7,2 +Student_01313,1,1,9773,1,1,1,1,38,37,9,5,151.0,138.4,1,0,0,1,0,1,0,24,0,6,7,6,13.666666666666666,0,0,6,6,6,12.833333333333334,0,10.8,1.4,1.74,2 +Student_01319,1,43,9254,1,1,1,1,1,19,5,7,130.0,130.0,0,0,0,1,0,1,0,19,0,6,11,4,12.0,0,0,6,14,3,11.0,0,10.8,1.4,1.74,0 +Student_01322,1,1,9853,1,2,1,1,19,1,194,103,123.0,115.3,1,0,0,1,0,0,0,20,0,7,8,6,13.5,0,0,7,8,6,14.0,0,11.1,0.6,2.02,1 +Student_01327,1,1,9085,1,1,1,1,1,37,4,9,101.0,98.9,1,0,0,1,0,0,0,21,0,6,12,4,12.5,0,0,6,13,2,12.666666666666666,0,11.1,0.6,2.02,1 +Student_01329,1,1,9500,1,4,1,1,1,1,3,3,123.0,113.6,1,0,0,1,0,0,0,21,0,7,8,7,14.69625,0,0,8,9,8,14.622222222222224,0,12.4,0.5,1.79,2 +Student_01341,1,44,9238,1,1,1,1,37,37,6,9,120.0,121.0,0,0,0,1,0,1,0,21,3,6,6,6,12.333333333333334,0,2,6,8,6,11.333333333333334,0,13.9,-0.3,0.79,2 +Student_01349,1,53,9085,1,1,42,1,NA,38,8,9,140.0,144.9,1,0,1,0,0,0,0,23,7,11,18,11,13.166666666666666,0,4,9,15,8,13.333333333333334,0,8.9,1.4,3.51,1 +Student_01354,1,17,9853,1,2,1,1,38,19,4,9,145.0,127.9,1,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01358,1,39,9254,1,1,19,1,19,1,9,5,133.1,97.0,0,0,1,0,1,0,0,36,0,5,10,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_01359,1,17,171,1,1,1,1,1,1,4,10,128.0,134.7,0,0,0,0,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_01361,1,1,9119,1,4,1,1,3,1,123,152,120.0,116.9,0,0,0,1,1,0,0,18,0,5,9,1,13.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_01363,1,39,9070,1,1,1,1,NA,38,5,5,139.3,117.5,0,0,0,1,1,0,0,28,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_01367,1,51,9119,1,1,1,1,1,19,3,5,136.0,133.6,1,0,0,1,1,0,0,20,4,9,12,9,13.454545454545457,0,2,7,9,6,13.875,0,11.1,0.6,2.02,0 +Student_01368,1,1,9500,1,6,1,1,38,38,9,9,134.0,122.0,1,0,0,1,1,0,0,19,0,8,8,7,12.2,0,0,8,8,7,12.2,0,12.7,3.7,-1.7,2 +Student_01383,1,7,9003,1,1,3,1,1,19,4,1,120.0,120.0,1,0,0,1,1,0,0,27,14,18,21,18,11.421052631578949,0,10,13,16,13,11.076923076923077,1,15.5,2.8,-4.06,2 +Student_01406,1,15,9119,1,1,1,41,1,3,5,8,133.1,100.0,0,0,1,1,1,0,1,21,0,5,5,0,0.0,0,0,6,8,0,0.0,0,11.1,0.6,2.02,0 +Student_01409,1,17,9254,1,1,1,1,11,34,5,0,118.0,122.2,1,0,0,1,0,0,0,22,0,6,10,4,10.5,0,0,6,14,1,11.0,0,7.6,2.6,0.32,0 +Student_01412,1,16,9238,1,2,1,1,19,37,9,7,122.0,127.3,1,0,0,1,0,1,0,19,0,6,8,4,11.25,0,0,6,6,6,12.0,0,10.8,1.4,1.74,2 +Student_01423,1,17,9238,1,3,1,1,19,38,9,7,141.0,125.6,1,0,0,1,0,1,0,19,0,6,8,6,11.333333333333334,0,0,6,6,6,11.833333333333334,0,8.9,1.4,3.51,2 +Student_01426,1,1,171,1,1,1,1,19,19,5,5,NA,134.6,1,0,0,1,0,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,2 +Student_01430,1,17,9773,1,1,1,1,19,38,9,7,120.0,117.9,1,0,0,1,0,1,0,21,0,6,6,5,13.0,0,0,6,7,6,12.833333333333334,0,8.9,1.4,3.51,2 +Student_01436,1,15,9147,1,1,1,41,41,1,3,4,133.1,100.0,0,0,1,0,1,0,1,26,6,7,7,6,13.0,0,2,6,6,2,14.0,0,11.1,0.6,2.02,0 +Student_01444,1,17,9003,1,1,1,1,1,4,9,5,170.0,144.1,1,0,1,0,1,0,0,26,0,6,8,0,0.0,0,0,6,10,0,0.0,0,16.2,0.3,-0.92,0 +Student_01451,1,17,9130,1,1,1,1,2,1,4,1,132.0,127.8,0,0,0,NA,1,0,0,18,0,6,9,6,12.0,0,0,6,10,5,12.166666666666666,0,11.1,0.6,2.02,0 +Student_01454,1,18,9238,1,2,1,1,19,37,5,7,126.0,129.9,1,0,0,1,1,1,0,20,1,7,9,6,12.0,0,2,6,6,6,11.166666666666666,0,10.8,1.4,1.74,2 +Student_01460,1,18,9147,1,1,1,1,37,37,7,7,119.0,112.0,1,0,0,0,1,0,0,20,0,5,5,0,0.0,0,0,5,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01464,1,51,NA,1,1,1,1,1,19,4,4,140.0,150.0,0,0,0,1,1,0,0,23,0,5,7,2,13.0,0,0,5,11,1,10.0,0,8.9,1.4,3.51,0 +Student_01470,1,1,9254,1,3,1,1,1,1,4,3,123.0,123.4,1,0,0,NA,1,0,0,18,0,6,8,6,12.333333333333334,0,0,6,6,6,13.666666666666666,0,11.1,0.6,NA,2 +Student_01473,1,17,9773,1,1,1,1,19,38,4,9,130.0,126.2,0,0,0,1,1,1,0,18,0,6,7,6,11.333333333333334,0,0,6,8,6,12.285714285714286,0,16.2,0.3,-0.92,2 +Student_01475,1,17,9119,1,1,1,1,1,3,9,10,131.0,123.7,1,0,0,1,1,0,0,20,0,5,7,4,12.0,0,0,5,8,2,12.5,0,10.8,1.4,1.74,1 +Student_01481,1,53,9085,1,1,42,1,1,1,9,4,150.0,150.0,1,0,0,1,1,1,0,22,1,7,11,5,12.166666666666666,0,4,8,14,5,14.8,0,8.9,1.4,3.51,0 +Student_01483,1,1,9670,1,2,1,1,3,1,2,6,140.0,137.6,1,0,0,1,1,1,0,21,0,6,8,6,15.166666666666666,0,0,6,7,6,14.428571428571429,0,8.9,1.4,3.51,2 +Student_01486,1,18,9238,1,2,1,1,19,1,4,3,121.0,121.4,1,0,0,1,0,1,0,19,0,6,8,4,10.75,0,0,6,11,5,11.5,0,15.5,2.8,-4.06,2 +Student_01487,1,53,9085,1,1,42,1,1,3,4,2,140.0,142.8,1,0,0,0,0,1,0,20,7,12,15,11,13.384615384615383,0,4,9,13,7,14.285714285714286,0,8.9,1.4,3.51,2 +Student_01510,1,43,9500,1,1,1,100,1,1,6,6,140.0,128.2,0,0,0,1,0,0,1,39,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_01512,2,39,9991,0,1,1,1,37,19,9,10,133.1,150.0,0,0,0,1,1,0,0,47,0,5,8,4,10.0,0,0,5,8,4,12.5,0,9.4,-0.8,-3.12,1 +Student_01518,1,17,171,1,1,1,1,19,1,4,1,135.0,131.9,1,0,0,1,1,0,0,19,6,12,12,12,13.583333333333334,0,4,11,12,11,13.583333333333334,0,8.9,1.4,3.51,2 +Student_01520,1,39,9147,1,1,12,1,1,1,9,4,133.1,140.0,1,0,1,0,1,0,0,24,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_01528,1,39,9119,1,1,1,1,37,37,9,9,120.0,98.7,0,0,0,1,1,1,0,28,0,5,12,3,10.0,0,0,5,10,3,12.4,0,12.4,0.5,1.79,2 +Student_01536,2,44,9991,0,1,39,1,37,37,9,9,140.0,140.0,0,0,0,1,0,0,0,41,2,6,10,4,12.25,0,3,7,9,6,12.5,0,9.4,-0.8,-3.12,1 +Student_01542,2,39,9853,1,1,12,1,37,37,7,8,133.1,103.0,0,0,0,1,0,0,0,41,0,6,0,0,0.0,0,0,6,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_01543,4,17,8014,0,5,1,1,19,19,90,90,100.0,107.0,0,0,0,1,0,0,0,38,0,5,12,1,10.0,0,0,5,10,0,0.0,0,10.8,1.4,1.74,0 +Student_01545,1,39,8014,0,1,1,1,34,34,0,0,133.1,100.0,1,0,0,1,0,0,0,27,0,6,11,4,12.25,0,0,6,16,3,12.0,0,7.6,2.6,0.32,0 +Student_01546,1,17,9070,1,1,1,1,1,37,4,9,139.0,131.3,1,0,0,1,0,0,0,19,0,6,10,4,12.0,1,0,6,6,6,12.5,0,7.6,2.6,0.32,2 +Student_01547,1,18,9773,1,1,1,1,19,37,9,5,125.0,122.2,0,0,0,0,0,0,0,18,0,6,7,5,12.6,0,0,6,6,5,11.8,0,11.1,0.6,2.02,1 +Student_01553,1,7,9147,1,1,40,1,37,37,9,9,110.0,110.0,0,0,0,1,0,0,0,52,11,15,26,14,10.466666666666669,0,9,12,16,12,10.923076923076923,0,13.9,-0.3,0.79,2 +Student_01557,1,1,9119,1,1,1,1,37,19,9,5,130.0,140.2,1,0,0,1,1,0,0,20,0,5,5,0,0.0,0,0,5,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01562,1,17,9130,1,1,1,1,38,19,5,7,137.0,130.0,1,0,0,1,0,0,0,21,0,6,12,5,13.6,0,0,6,10,4,14.25,0,12.4,0.5,1.79,1 +Student_01563,1,1,9147,1,4,1,1,1,1,3,4,116.0,113.6,1,0,0,1,0,1,0,22,0,5,6,3,14.0,0,0,5,8,5,12.4,0,11.1,0.6,2.02,2 +Student_01565,1,17,9085,1,4,1,1,37,1,3,9,106.0,106.0,0,0,0,1,0,0,0,20,0,6,9,6,13.166666666666666,0,0,6,8,4,14.0,0,13.9,-0.3,0.79,1 +Student_01571,2,1,8014,0,1,1,1,37,37,9,9,121.0,114.4,1,0,0,1,0,0,0,45,8,12,14,12,14.0,0,2,7,12,7,13.857142857142858,0,7.6,2.6,0.32,1 +Student_01574,5,39,9003,1,1,1,1,37,37,9,7,133.1,110.0,0,0,1,0,0,0,0,28,0,6,17,5,13.0,0,0,6,11,4,11.75,0,13.9,-0.3,0.79,0 +Student_01579,1,1,9085,1,3,1,1,37,19,9,8,131.0,136.3,1,0,1,0,0,0,0,18,0,5,7,3,13.0,0,0,5,8,3,12.0,0,7.6,2.6,0.32,0 +Student_01582,1,16,9070,1,2,1,1,1,3,4,2,133.0,122.5,1,0,0,1,0,0,0,18,0,6,11,1,11.0,1,0,6,11,4,11.0,4,7.6,2.6,0.32,1 +Student_01589,1,17,9254,1,1,1,1,37,37,5,4,119.0,118.0,1,0,0,1,1,0,0,19,0,6,13,2,10.5,0,0,6,11,1,12.0,0,10.8,1.4,1.74,0 +Student_01592,1,17,171,1,4,1,1,3,1,2,10,172.0,155.6,1,0,0,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01599,1,17,9238,1,1,1,1,37,37,7,7,136.0,140.9,1,0,0,1,1,0,0,18,0,6,10,4,12.0,0,0,6,7,5,11.8,0,9.4,-0.8,-3.12,0 +Student_01611,1,1,9147,1,1,1,1,1,38,4,7,160.0,141.5,1,0,0,1,1,0,0,18,0,5,10,3,10.666666666666666,1,0,5,11,2,12.5,0,9.4,-0.8,-3.12,0 +Student_01612,1,16,9085,1,5,1,1,19,37,8,8,134.0,123.9,1,0,0,1,1,0,0,18,0,5,11,5,13.0,2,0,5,7,5,12.4,0,9.4,-0.8,-3.12,1 +Student_01613,1,17,9500,1,2,1,1,19,19,5,5,125.0,114.5,1,0,0,1,0,0,0,18,0,7,11,6,11.983333333333334,0,0,8,12,8,12.28125,0,16.2,0.3,-0.92,2 +Student_01614,1,39,8014,0,1,15,1,34,34,0,0,133.1,100.0,1,0,0,0,0,0,0,37,0,5,9,0,0.0,0,0,5,5,0,0.0,5,9.4,-0.8,-3.12,0 +Student_01622,1,1,9085,1,1,1,1,38,37,9,9,126.0,123.6,1,0,0,1,0,0,0,21,0,5,10,3,11.666666666666666,0,0,5,5,5,13.0,0,10.8,1.4,1.74,2 +Student_01624,2,39,9556,1,1,1,1,37,37,9,9,100.0,120.0,0,0,0,1,0,0,0,47,1,7,16,6,12.514285714285716,0,0,7,15,4,11.75,0,12.7,3.7,-1.7,0 +Student_01626,1,39,9991,0,1,1,1,37,37,7,10,110.0,150.0,0,0,0,0,0,0,0,48,0,5,5,1,10.0,0,0,5,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_01629,NA,1,9670,1,1,1,1,19,3,4,0,141.0,137.9,1,0,0,0,1,0,0,20,0,5,6,3,12.0,0,0,5,5,4,12.75,0,7.6,2.6,0.32,0 +Student_01631,2,39,9130,1,1,19,1,37,38,9,9,133.1,120.0,0,0,0,1,1,0,0,53,0,5,9,4,12.25,2,0,5,8,4,11.75,0,9.4,-0.8,-3.12,2 +Student_01635,2,39,9991,0,1,1,1,37,37,9,10,110.0,150.0,0,0,0,1,NA,0,0,49,0,5,6,5,12.2,0,0,5,9,5,11.8,0,15.5,2.8,-4.06,2 +Student_01636,1,17,9670,1,1,1,1,38,37,7,5,125.0,126.4,0,0,0,1,1,1,0,18,0,6,7,6,12.285714285714286,0,0,6,7,6,13.333333333333334,1,16.2,0.3,-0.92,2 +Student_01640,1,1,9070,1,1,1,1,3,1,2,3,147.0,149.8,1,0,0,1,1,0,0,20,5,12,12,11,14.272727272727272,0,5,12,12,11,14.818181818181818,0,16.2,0.3,-0.92,2 +Student_01641,1,1,9500,1,4,1,1,1,37,4,3,128.0,117.9,1,0,0,1,0,1,0,19,0,7,9,7,12.1375,0,0,8,9,8,12.91111111111111,0,12.4,0.5,1.79,2 +Student_01650,1,1,9500,1,1,1,1,1,38,4,9,138.0,132.5,1,0,0,1,0,1,0,19,0,8,8,7,14.36,0,0,8,8,7,14.36,0,10.8,1.4,1.74,2 +Student_01651,1,1,9500,1,1,1,1,3,1,9,9,141.0,124.3,0,0,0,1,0,0,0,19,0,8,8,7,14.514285714285714,0,0,8,8,7,14.514285714285714,0,12.7,3.7,-1.7,1 +Student_01653,1,7,9991,0,1,40,1,43,3,3,3,120.0,120.0,0,0,0,1,0,0,0,27,0,5,5,5,15.2,0,0,5,6,5,14.0,0,11.1,0.6,2.02,1 +Student_01660,1,1,171,1,1,1,1,3,3,1,2,136.0,152.5,1,0,0,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,1 +Student_01664,1,17,9500,1,1,1,1,1,37,9,7,148.0,143.3,0,0,0,1,0,1,0,18,0,7,7,7,13.44285714285714,0,0,8,8,8,15.075,0,13.9,-0.3,0.79,2 +Student_01670,1,17,8014,0,1,1,1,37,37,5,8,136.0,132.5,0,0,1,1,0,1,0,22,1,6,7,4,12.75,0,1,6,8,5,13.0,0,13.9,-0.3,0.79,2 +Student_01673,1,44,9130,1,1,39,1,3,1,4,1,130.0,130.0,1,0,0,0,0,0,0,21,1,6,12,5,13.285714285714286,0,0,6,10,4,12.0,0,16.2,0.3,-0.92,0 +Student_01678,5,39,9991,0,1,1,1,1,1,3,3,110.0,119.0,0,0,0,1,1,1,0,35,0,5,10,4,10.5,0,0,5,6,5,12.6,0,8.9,1.4,3.51,2 +Student_01681,1,1,9119,1,1,1,1,38,38,9,7,128.0,124.5,1,0,0,1,1,0,0,19,0,5,10,3,10.666666666666666,0,0,5,9,2,14.0,2,7.6,2.6,0.32,1 +Student_01685,1,17,9070,1,3,1,1,37,37,5,5,128.0,124.5,1,0,0,1,1,0,0,18,0,6,6,6,14.166666666666666,0,0,6,8,5,13.0,0,10.8,1.4,1.74,2 +Student_01693,1,1,9500,1,1,1,1,37,38,9,9,133.0,130.2,1,0,0,1,1,1,0,19,0,7,7,7,13.7,0,0,8,9,8,14.022222222222222,0,16.2,0.3,-0.92,2 +Student_01702,1,1,9773,1,1,1,1,1,1,5,5,137.0,129.3,1,0,0,1,1,0,0,18,0,6,6,6,13.666666666666666,0,0,6,6,6,14.5,0,12.7,3.7,-1.7,2 +Student_01719,1,39,9119,1,1,1,1,38,37,7,7,160.0,129.0,0,0,0,1,1,0,0,24,0,5,9,0,0.0,0,0,5,8,2,14.5,2,7.6,2.6,0.32,0 +Student_01724,1,1,9773,1,1,1,1,2,1,9,9,132.0,126.4,1,1,0,1,0,1,0,18,0,6,9,6,11.166666666666666,0,0,6,11,5,12.4,0,10.8,1.4,1.74,2 +Student_01731,1,1,9147,1,3,1,1,3,3,5,10,128.0,116.5,0,0,0,1,1,0,0,20,0,5,7,5,11.6,0,0,5,5,5,12.8,0,12.4,0.5,1.79,2 +Student_01733,2,39,9119,1,1,1,1,37,38,9,10,120.0,145.4,0,0,1,1,1,0,0,40,0,5,11,3,10.666666666666666,0,0,5,5,2,12.5,0,16.2,0.3,-0.92,0 +Student_01742,1,NA,9254,1,4,1,1,1,1,4,2,122.0,116.1,1,0,0,1,1,0,0,19,0,6,7,5,12.2,0,0,6,12,2,12.0,0,7.6,2.6,0.32,1 +Student_01752,1,1,171,1,1,1,1,NA,19,9,9,150.0,137.8,1,0,0,1,1,1,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,2 +Student_01758,1,44,9130,1,1,39,1,1,37,4,8,150.0,150.0,1,0,0,0,0,0,0,22,1,6,10,3,12.666666666666666,0,0,6,7,0,0.0,0,15.5,2.8,-4.06,0 +Student_01762,1,17,171,1,1,1,41,1,1,5,7,140.0,146.3,1,0,0,1,0,1,1,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_01763,1,39,9773,1,1,1,1,1,19,1,3,130.0,161.5,0,0,0,1,1,0,0,36,0,6,7,6,15.285714285714286,0,0,6,6,6,16.5,0,10.8,1.4,1.74,2 +Student_01765,1,53,9147,1,1,42,1,1,1,6,6,140.0,142.2,0,0,0,1,1,1,0,21,6,11,11,11,12.636363636363637,0,3,9,11,9,12.6,0,8.9,1.4,3.51,2 +Student_01773,1,1,9773,1,2,1,1,1,1,9,9,140.0,136.9,1,0,0,1,0,1,0,19,0,6,7,6,13.5,0,0,6,7,6,14.428571428571429,0,16.2,0.3,NA,2 +Student_01775,1,17,9254,1,6,1,1,1,19,4,5,108.0,112.2,1,0,0,1,1,0,0,19,0,6,13,5,10.8,0,0,6,12,3,10.0,0,9.4,-0.8,-3.12,1 +Student_01779,1,1,9147,1,1,1,1,37,38,7,7,133.1,98.0,1,0,0,1,1,0,0,23,0,5,8,4,11.4,0,0,5,7,4,11.0,0,11.1,0.6,2.02,2 +Student_01782,1,1,9070,1,5,1,1,1,19,3,3,133.1,112.0,1,0,0,1,1,1,0,21,0,6,6,6,13.5,0,0,6,6,6,11.166666666666666,0,11.1,0.6,2.02,2 +Student_01787,2,39,9238,1,1,19,1,37,37,9,4,133.1,103.5,0,0,0,1,1,0,0,42,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01792,NA,1,9147,1,4,1,1,3,1,3,10,146.0,138.7,0,0,0,1,1,0,0,18,0,5,0,0,0.0,0,0,5,0,0,0.0,0,8.9,1.4,3.51,0 +Student_01793,1,39,9991,0,1,1,1,3,5,2,2,150.0,NA,0,0,1,1,1,0,0,29,1,5,9,3,11.0,0,0,5,11,2,13.5,0,12.7,3.7,-1.7,0 +Student_01801,1,1,9500,1,3,1,1,3,1,4,1,139.0,126.0,1,0,0,1,1,0,0,18,0,8,15,5,12.288,1,0,8,15,5,12.288,1,10.8,1.4,1.74,0 +Student_01802,1,43,8014,0,2,3,1,34,34,0,0,130.0,130.0,0,0,0,1,1,0,0,31,8,12,21,12,12.333333333333334,0,6,10,13,7,13.285714285714286,2,7.6,2.6,0.32,2 +Student_01806,NA,43,9991,0,1,3,1,3,1,2,9,130.0,130.0,0,0,0,1,1,0,0,33,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_01808,1,17,9670,1,1,1,1,3,3,1,1,127.0,121.4,0,0,0,1,1,0,0,18,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_01809,1,1,9119,1,5,1,1,1,19,4,7,131.0,126.8,0,0,0,0,1,1,0,18,0,5,6,5,12.2,0,0,5,8,4,12.0,0,8.9,1.4,3.51,1 +Student_01816,1,39,9003,1,1,19,1,19,37,1,1,133.1,140.0,0,0,1,1,1,0,0,24,0,6,10,6,14.88888888888889,0,0,6,11,6,13.727272727272728,0,NA,0.3,-0.92,1 +Student_01822,1,1,9500,1,3,1,1,3,1,4,3,122.0,114.8,1,0,0,1,0,1,0,19,0,7,11,4,12.65,0,0,7,9,5,11.1,0,12.4,0.5,1.79,1 +Student_01826,1,17,9254,1,1,1,1,19,37,5,3,160.0,152.0,0,0,0,1,0,0,0,18,0,6,7,6,14.714285714285714,0,0,6,7,6,14.166666666666666,0,12.7,3.7,-1.7,2 +Student_01829,NA,7,9500,1,1,3,1,37,37,4,5,120.0,120.0,0,0,1,0,0,0,0,28,0,7,7,0,0.0,7,0,7,7,0,0.0,7,13.9,-0.3,0.79,0 +Student_01837,2,43,8014,0,1,1,1,37,19,9,3,110.0,100.0,0,0,0,1,0,0,0,34,9,11,17,9,NA,0,3,7,12,7,12.142857142857142,0,9.4,-0.8,-3.12,2 +Student_01841,1,10,9773,1,1,NA,22,38,37,0,5,NA,151.0,1,0,0,1,0,0,1,18,0,6,12,0,0.0,1,0,6,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_01845,1,1,9500,1,6,1,1,1,1,9,9,133.0,119.7,1,1,1,1,1,0,0,19,2,7,8,7,13.075,0,1,8,11,8,12.36111111111111,0,12.4,0.5,1.79,2 +Student_01854,1,44,9003,1,1,39,1,3,3,2,10,160.0,160.0,1,0,0,1,1,0,0,20,0,6,7,6,14.0,0,0,6,7,6,14.666666666666666,0,12.4,0.5,1.79,2 +Student_01855,1,39,9085,1,1,1,1,37,37,90,90,140.0,106.3,0,0,1,0,1,0,0,35,0,5,7,2,11.5,0,0,5,8,2,10.5,0,7.6,2.6,0.32,0 +Student_01865,1,1,9130,1,1,1,1,9,19,4,4,140.0,131.2,0,0,0,1,NA,1,0,26,0,5,9,0,0.0,0,0,5,6,0,0.0,0,7.6,2.6,0.32,0 +Student_01867,1,NA,9147,1,2,1,1,19,19,5,9,130.0,121.5,0,0,0,0,1,0,0,26,0,5,5,2,10.5,0,0,5,9,0,0.0,0,10.8,1.4,1.74,0 +Student_01871,1,17,9670,1,1,1,1,34,3,7,2,133.1,130.6,1,0,1,0,1,0,0,23,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_01872,1,1,9500,1,6,1,1,1,1,4,4,119.0,115.0,1,0,0,1,1,1,0,20,0,7,14,1,13.0,0,0,7,15,0,0.0,0,11.1,0.6,2.02,0 +Student_01873,1,51,9500,1,1,1,1,1,1,4,10,170.0,125.0,0,0,0,1,1,0,0,20,0,7,7,7,15.66,0,7,10,11,9,15.011111111111113,0,11.1,0.6,2.02,2 +Student_01883,1,17,9254,1,1,1,1,19,38,9,9,128.0,118.2,0,0,0,1,0,0,0,19,0,5,5,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_01884,1,1,171,1,1,1,1,1,19,10,5,145.0,150.6,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,2 +Student_01887,1,44,9003,1,1,39,1,37,37,9,7,160.0,160.0,1,0,0,0,1,0,0,30,4,9,18,6,11.833333333333334,0,1,8,21,4,11.0,0,15.5,2.8,-4.06,0 +Student_01897,1,1,9085,1,1,1,1,19,37,8,8,105.0,102.6,0,1,0,1,0,0,0,21,0,6,13,4,12.0,0,0,6,17,2,11.5,0,11.1,0.6,2.02,1 +Student_01900,1,53,9085,1,1,42,1,3,1,2,8,150.0,153.8,1,0,0,1,0,0,0,21,7,11,15,10,14.5,0,4,9,15,8,14.0,0,8.9,1.4,3.51,2 +Student_01907,1,1,9500,1,6,1,1,4,12,5,9,117.0,119.8,1,0,0,1,0,0,0,18,0,7,7,7,13.877142857142855,0,0,8,8,8,15.6625,0,12.4,0.5,1.79,2 +Student_01913,1,1,9556,1,2,1,1,38,1,9,3,125.0,116.3,1,0,0,1,0,0,0,18,0,7,8,7,13.428571428571429,0,0,8,8,8,15.3125,0,16.2,0.3,-0.92,2 +Student_01914,2,17,8014,0,3,1,1,19,37,3,3,123.0,113.2,0,0,1,0,0,0,0,18,0,6,9,3,10.666666666666666,0,0,6,12,0,0.0,0,7.6,2.6,0.32,0 +Student_01919,1,1,9070,1,2,1,1,19,37,9,9,135.0,134.0,1,0,0,1,0,1,0,22,0,6,10,5,10.8,0,0,6,7,5,12.8,0,12.7,3.7,-1.7,2 +Student_01921,1,44,9085,1,1,39,1,1,1,3,7,140.0,140.0,1,0,0,1,0,0,0,NA,2,6,11,5,14.2,0,0,6,12,2,13.5,0,13.9,-0.3,0.79,1 +Student_01924,1,17,9147,1,3,1,1,37,38,5,1,142.0,129.4,0,0,0,1,0,0,0,18,0,5,5,5,13.2,0,0,5,6,4,12.5,0,9.4,-0.8,-3.12,2 +Student_01926,1,17,9238,1,1,1,1,1,1,4,10,131.0,129.3,0,0,0,1,0,0,0,19,4,8,8,8,13.875,0,1,6,8,5,14.0,0,11.1,0.6,2.02,2 +Student_01928,1,17,9773,1,2,1,1,19,19,9,9,142.0,139.9,0,0,0,1,0,1,0,18,0,6,7,6,13.428571428571429,0,0,6,6,6,12.5,0,13.9,-0.3,0.79,2 +Student_01929,1,1,9070,1,1,1,1,38,38,9,5,123.0,124.8,0,0,0,0,0,1,0,18,0,6,7,5,11.8,0,0,6,7,5,13.0,0,8.9,1.4,3.51,1 +Student_01930,1,17,9500,1,3,1,1,1,1,9,9,133.0,128.5,1,0,0,1,0,1,0,18,0,7,7,7,14.868571428571428,0,0,8,9,8,15.11111111111111,0,11.1,0.6,2.02,2 +Student_01931,1,1,9500,1,4,1,1,19,1,1,1,125.0,117.8,1,0,0,1,0,0,0,18,0,7,10,7,13.03,0,0,8,8,8,13.21875,0,15.5,2.8,-4.06,2 +Student_01932,1,17,9670,1,1,1,1,38,38,5,7,120.0,115.1,1,0,0,1,0,0,0,19,0,6,7,6,14.571428571428571,0,0,6,7,6,12.333333333333334,0,12.4,0.5,1.79,2 +Student_01933,1,17,9238,1,2,1,1,19,19,3,3,125.0,118.0,1,0,0,1,0,0,0,18,0,6,9,5,11.0,0,0,6,9,4,11.25,0,8.9,1.4,3.51,2 +Student_01943,2,1,9070,1,1,1,1,12,19,9,9,127.0,123.2,0,0,0,1,0,1,0,20,0,6,6,6,15.0,0,0,6,6,6,14.5,0,11.1,0.6,2.02,2 +Student_01945,1,1,9773,1,2,1,1,1,19,4,7,116.0,127.6,1,0,0,1,0,1,0,19,0,6,7,6,13.857142857142858,0,0,6,7,6,13.142857142857142,0,13.9,-0.3,0.79,0 +Student_01966,1,7,9003,1,1,4,1,3,1,2,4,120.0,120.0,1,0,0,1,0,0,0,31,8,12,12,11,13.818181818181818,0,4,12,16,12,13.461538461538462,0,15.5,2.8,-4.06,2 +Student_01968,1,1,9085,1,3,1,1,3,2,4,3,135.0,121.0,1,0,0,1,0,0,0,18,0,5,14,3,12.333333333333334,2,0,5,8,5,11.6,0,9.4,-0.8,-3.12,1 +Student_01971,1,51,9238,1,1,1,1,19,3,5,2,122.0,112.6,0,0,1,1,0,0,0,20,5,11,18,8,12.625,0,4,10,10,3,11.0,0,11.1,0.6,2.02,1 +Student_01973,1,17,9670,1,2,1,1,19,19,5,4,129.0,129.4,0,0,0,1,0,1,0,19,0,6,7,5,11.2,0,0,6,10,5,13.125,0,10.8,1.4,1.74,0 +Student_01980,1,1,9670,1,1,1,1,12,1,9,9,123.0,119.2,1,0,0,1,0,1,0,18,0,6,8,5,13.5,0,0,6,6,6,14.5,0,12.4,0.5,1.79,2 +Student_01982,1,17,9238,1,1,1,1,19,19,7,7,116.0,111.1,1,0,0,1,0,1,0,18,0,6,9,6,11.333333333333334,0,0,6,9,6,11.833333333333334,0,8.9,1.4,3.51,2 +Student_01984,1,1,9500,1,1,1,1,38,19,5,8,147.0,147.3,0,0,0,1,0,0,0,18,0,7,7,6,13.966666666666669,0,0,7,7,6,13.966666666666669,0,7.6,2.6,0.32,2 +Student_01986,1,17,9254,1,2,1,1,37,37,9,7,108.0,108.0,1,0,0,1,0,1,0,20,0,6,10,4,11.6,0,0,6,10,4,11.75,0,12.7,3.7,-1.7,2 +Student_01988,2,39,9991,0,1,1,1,37,37,9,10,140.0,130.0,0,0,0,1,0,0,0,34,0,5,5,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,1 +Student_02001,1,39,9254,1,1,1,1,1,1,9,6,133.1,105.0,1,0,1,0,0,0,0,24,0,6,14,6,11.285714285714286,0,0,6,16,3,10.333333333333334,0,8.9,1.4,3.51,0 +Student_02006,1,NA,9085,1,1,1,1,1,37,4,10,133.0,NA,0,0,0,1,0,0,0,19,0,5,7,5,14.4,0,0,5,6,5,13.2,0,7.6,2.6,0.32,2 +Student_02012,2,39,9991,0,1,1,1,37,37,9,4,110.0,160.0,0,0,0,1,0,0,0,44,0,5,5,5,11.8,0,0,5,5,5,NA,0,15.5,2.8,-4.06,2 +Student_02018,1,1,9500,1,1,1,1,38,1,9,10,144.0,137.4,0,0,0,1,0,0,0,19,0,7,7,7,13.542857142857144,0,0,8,9,8,14.22222222222222,0,16.2,0.3,-0.92,2 +Student_02027,1,1,171,1,1,1,1,3,2,3,3,110.0,117.0,1,0,0,1,1,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,2 +Student_02031,1,17,9500,1,2,NA,1,19,19,9,10,135.0,133.4,1,0,0,1,0,0,0,19,0,7,7,7,14.125714285714285,0,0,8,8,8,14.36875,0,11.1,0.6,2.02,2 +Student_02039,1,10,9670,1,1,1,22,37,37,9,9,148.9,148.9,0,0,0,1,0,0,1,20,0,5,6,5,11.6,0,0,5,6,4,11.5,0,9.4,-0.8,-3.12,2 +Student_02044,1,1,9254,1,3,1,1,1,19,9,9,118.0,111.7,1,0,0,1,0,0,0,19,0,6,6,6,12.5,0,0,6,6,6,12.166666666666666,0,12.4,0.5,1.79,2 +Student_02049,1,17,9500,1,4,1,1,3,1,2,5,138.0,134.5,1,0,0,1,0,0,0,18,0,7,7,7,13.457142857142856,0,0,8,8,8,15.125,0,13.9,-0.3,0.79,2 +Student_02062,1,17,9556,1,5,1,1,19,19,9,8,139.0,121.3,1,0,0,1,0,1,0,19,0,7,8,7,13.385714285714286,0,0,8,8,8,13.3875,0,10.8,1.4,1.74,2 +Student_02080,1,1,9500,1,5,1,1,38,38,7,7,144.0,136.0,1,0,0,1,0,1,0,19,0,7,7,6,14.15,0,0,7,7,6,14.15,0,7.6,2.6,0.32,2 +Student_02086,1,1,9773,1,4,1,1,19,37,99,90,124.0,124.0,0,0,0,0,0,0,0,18,0,4,4,0,0.0,0,0,4,4,0,0.0,0,12.7,3.7,-1.7,0 +Student_02087,1,7,8014,0,1,3,1,1,1,4,4,140.0,140.0,0,0,0,1,NA,0,0,30,0,6,0,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_02093,1,1,9500,1,1,1,1,5,4,2,1,156.0,140.8,0,0,0,1,0,0,0,18,0,8,8,7,15.7,0,0,8,8,7,15.7,0,12.7,3.7,-1.7,2 +Student_02101,1,17,9773,1,1,1,1,38,38,9,5,133.1,117.0,0,0,0,1,0,0,0,21,0,6,8,5,11.8,0,0,6,8,5,11.833333333333334,0,15.5,2.8,-4.06,1 +Student_02102,1,18,8014,0,1,1,1,1,1,4,3,137.0,123.0,0,0,1,1,0,0,0,20,0,6,13,4,10.8,0,0,6,15,4,12.0,0,16.2,0.3,-0.92,2 +Student_02108,1,1,9773,1,1,1,1,37,37,9,9,140.0,142.5,1,0,0,1,0,0,0,18,0,6,6,6,13.333333333333334,0,0,6,9,5,13.2,0,9.4,-0.8,-3.12,2 +Student_02124,1,17,9238,1,3,1,1,1,19,4,10,118.0,NA,1,0,0,1,0,0,0,19,0,6,10,5,11.285714285714286,0,0,6,7,0,0.0,0,16.2,0.3,-0.92,0 +Student_02134,1,17,9500,1,5,1,1,1,1,4,5,128.0,120.8,1,0,0,1,0,1,0,19,0,7,9,7,13.507142857142856,0,0,8,12,8,13.05,0,16.2,0.3,-0.92,2 +Student_02137,1,17,9070,1,5,1,1,37,37,9,NA,131.0,126.1,1,0,0,0,0,0,0,18,0,6,9,4,11.5,1,0,6,6,6,12.166666666666666,0,7.6,2.6,0.32,2 +Student_02138,1,1,9773,1,5,1,1,38,19,9,9,118.0,113.8,1,0,0,1,0,0,0,19,0,6,7,6,12.333333333333334,0,0,6,7,6,12.5,0,8.9,1.4,3.51,2 +Student_02140,1,1,9147,1,1,1,1,19,19,5,8,116.0,127.9,0,0,1,0,NA,1,0,20,0,5,12,2,13.0,1,0,5,13,2,11.5,0,9.4,-0.8,-3.12,0 +Student_02142,1,17,9085,1,4,1,1,38,37,4,9,128.0,117.9,1,0,0,1,0,0,0,20,0,5,12,2,13.5,0,0,5,12,5,11.285714285714286,1,10.8,1.4,1.74,2 +Student_02145,2,39,8014,0,1,12,1,37,37,7,9,110.0,120.0,0,0,0,1,0,0,0,42,0,6,6,6,11.666666666666666,0,0,6,6,6,13.666666666666666,0,10.8,1.4,1.74,2 +Student_02149,1,10,9085,1,1,1,1,19,19,4,5,140.0,140.0,1,0,0,1,0,0,0,21,0,5,6,5,14.2,0,0,5,5,5,14.8,0,10.8,1.4,1.74,2 +Student_02152,1,44,9085,1,1,39,1,3,1,2,9,130.0,130.0,1,0,0,1,0,0,0,21,1,6,13,3,11.75,0,1,6,13,5,12.333333333333334,0,12.4,0.5,1.79,1 +Student_02161,1,1,9500,1,4,1,1,1,3,1,2,142.0,133.0,0,0,0,1,0,1,0,20,0,8,8,7,14.565714285714288,0,0,8,8,7,14.565714285714288,0,10.8,1.4,1.74,2 +Student_02172,1,44,9085,1,1,NA,1,1,19,4,4,140.0,140.0,0,0,0,1,0,0,0,21,2,6,9,6,13.142857142857142,0,0,6,9,6,12.166666666666666,0,13.9,-0.3,0.79,2 +Student_02178,1,43,8014,0,1,6,1,34,34,0,0,133.1,100.0,0,0,1,1,0,0,0,29,1,6,9,4,12.0,0,1,6,13,2,10.5,0,7.6,2.6,0.32,0 +Student_02190,1,17,9773,1,4,1,1,1,1,5,5,137.0,125.8,0,0,1,1,1,0,0,20,0,6,7,5,12.2,0,0,6,6,6,12.333333333333334,0,12.7,3.7,-1.7,0 +Student_02194,1,NA,9119,1,1,1,1,19,38,9,7,142.0,127.3,0,0,0,1,1,0,0,18,0,5,10,3,11.0,0,0,5,6,3,11.0,1,16.2,0.3,-0.92,1 +Student_02196,1,1,9773,1,2,1,1,38,19,4,7,133.1,98.0,1,0,0,1,1,1,0,19,0,6,8,4,12.0,0,0,6,8,6,12.285714285714286,0,15.5,2.8,-4.06,1 +Student_02197,1,17,9147,1,2,1,1,1,38,5,7,130.0,122.0,1,0,0,1,1,0,0,20,0,5,8,2,10.5,0,0,5,11,4,12.25,0,10.8,1.4,1.74,1 +Student_02198,1,43,9070,1,1,1,1,1,1,4,7,117.0,112.5,1,0,0,1,1,0,0,19,3,6,7,3,11.666666666666666,0,1,6,13,4,10.333333333333334,0,13.9,-0.3,0.79,1 +Student_02212,1,NA,9070,1,1,1,1,37,37,9,9,124.0,125.4,1,0,0,1,1,0,0,19,0,6,6,6,13.5,0,0,6,6,6,13.166666666666666,0,9.4,-0.8,-3.12,2 +Student_02218,1,16,9147,1,2,1,1,19,19,4,9,129.0,127.6,1,0,0,1,1,0,0,19,0,5,8,5,11.6,0,0,5,9,3,11.0,0,10.8,1.4,1.74,0 +Student_02219,1,7,9773,1,1,43,1,19,1,4,8,140.0,140.0,0,0,0,1,1,0,0,25,0,6,6,6,14.666666666666666,0,0,6,6,6,13.5,0,11.1,0.6,2.02,2 +Student_02225,1,1,9500,1,2,1,1,19,19,9,7,132.0,128.0,1,0,0,1,1,1,0,19,0,8,8,7,14.935714285714283,0,0,8,8,7,14.935714285714283,0,10.8,1.4,1.74,2 +Student_02226,1,43,9254,1,3,1,1,37,37,9,9,110.0,107.2,1,0,0,1,1,0,0,NA,1,6,16,2,10.5,0,0,6,15,4,10.0,0,7.6,2.6,0.32,0 +Student_02228,1,43,9003,1,1,1,1,37,37,9,6,119.0,119.0,0,0,1,1,1,0,0,23,0,6,6,0,0.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_02235,1,17,9254,1,2,1,1,19,19,5,7,118.0,121.2,0,0,0,1,1,1,0,18,0,6,12,3,10.666666666666666,0,0,6,9,4,12.0,0,15.5,2.8,-4.06,1 +Student_02239,1,39,9130,1,1,1,1,19,1,191,144,130.0,110.0,0,0,0,1,1,0,0,24,0,6,11,6,11.333333333333334,0,0,6,12,3,11.333333333333334,0,16.2,0.3,-0.92,1 +Student_02242,2,39,9991,0,1,1,1,37,37,9,9,130.0,127.8,0,0,0,1,1,0,0,37,0,5,7,4,10.75,0,0,5,7,3,11.333333333333334,0,7.6,2.6,0.32,1 +Student_02248,1,43,9500,1,2,1,1,19,1,9,10,136.0,124.1,0,0,0,1,1,1,0,21,0,8,8,0,0.0,8,0,8,8,0,0.0,8,9.4,-0.8,NA,1 +Student_02249,1,44,9119,1,1,1,1,37,12,9,8,130.0,129.4,1,0,1,0,1,0,0,23,0,5,6,0,0.0,0,0,5,7,0,0.0,0,13.9,-0.3,0.79,0 +Student_02251,1,44,9238,1,1,39,1,1,1,4,3,140.0,138.6,0,0,0,1,1,0,0,22,3,6,7,6,12.333333333333334,0,2,6,6,2,14.0,0,13.9,-0.3,0.79,0 +Student_02291,1,42,9119,1,1,1,1,5,5,2,2,120.0,115.0,0,0,0,1,1,0,0,30,1,6,9,2,15.0,0,1,6,7,2,13.5,0,NA,2.8,-4.06,0 +Student_02295,1,17,171,1,1,1,1,1,37,4,9,132.0,127.1,0,0,0,0,1,0,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,0 +Student_02300,1,39,9254,1,1,39,1,1,1,5,10,137.0,124.5,0,0,0,0,1,0,0,26,0,6,0,0,0.0,0,0,6,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_02301,1,44,9119,1,1,39,1,5,41,3,2,140.0,140.0,0,0,0,1,1,0,0,23,3,7,12,3,14.0,0,1,6,12,1,14.0,0,12.4,0.5,1.79,1 +Student_02321,4,39,9238,1,1,1,1,19,3,9,2,130.0,140.0,0,0,0,1,1,0,0,50,0,6,7,4,12.25,0,0,6,7,0,0.0,0,8.9,1.4,3.51,0 +Student_02327,1,51,9119,1,1,1,1,2,37,2,9,129.0,121.6,1,0,0,1,1,0,0,19,0,5,10,0,0.0,0,0,5,7,1,10.0,0,7.6,2.6,0.32,1 +Student_02328,2,39,9991,0,1,1,1,37,37,1,4,110.0,120.0,1,0,0,0,1,0,0,40,0,5,10,2,10.5,0,0,5,5,3,10.666666666666666,0,9.4,-0.8,-3.12,0 +Student_02331,1,43,8014,0,5,1,1,34,34,0,0,110.0,110.0,0,0,0,1,1,0,0,37,0,6,12,0,0.0,0,0,5,10,0,0.0,0,7.6,2.6,0.32,0 +Student_02333,1,39,9003,1,1,1,1,1,19,4,10,133.1,145.8,0,0,0,1,1,0,0,34,0,6,15,5,13.333333333333334,0,0,6,15,5,12.4,0,12.4,0.5,1.79,2 +Student_02334,1,1,171,1,6,1,1,10,10,4,4,126.0,130.2,1,0,0,1,1,1,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02336,1,17,9070,1,4,1,1,1,1,3,3,117.0,125.4,1,0,0,1,1,1,0,19,0,6,6,6,12.833333333333334,0,0,6,7,6,11.166666666666666,0,11.1,0.6,2.02,2 +Student_02343,1,43,9003,1,1,1,1,2,4,4,1,150.0,150.0,0,0,0,1,1,0,0,35,16,18,22,18,11.666666666666666,0,12,13,13,12,11.5,1,15.5,2.8,-4.06,2 +Student_02345,1,17,9500,1,1,1,1,3,3,2,2,130.0,131.1,0,0,0,1,1,0,0,19,0,7,8,7,12.12142857142857,0,0,9,12,8,11.50625,0,12.4,0.5,1.79,2 +Student_02349,1,39,9670,1,1,1,1,19,19,3,3,133.1,125.3,0,1,0,1,1,1,0,30,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_02360,1,17,9254,1,5,1,1,1,1,2,3,113.0,110.2,1,0,0,1,1,0,0,21,0,6,10,4,11.5,0,0,6,10,2,10.5,0,9.4,-0.8,-3.12,0 +Student_02368,1,17,9130,1,1,1,1,12,12,2,8,131.0,128.2,1,0,0,1,1,0,0,18,0,6,7,6,14.0,0,0,6,8,6,13.666666666666666,0,12.4,0.5,1.79,2 +Student_02370,1,39,9130,1,1,1,1,1,19,4,5,133.1,120.0,1,0,0,1,1,0,0,29,0,5,11,1,18.0,2,0,5,10,3,13.333333333333334,2,10.8,1.4,1.74,0 +Student_02381,1,17,9254,1,1,1,1,1,19,4,7,125.0,116.6,0,0,0,1,1,1,0,19,0,6,8,5,12.666666666666666,0,0,6,10,6,12.857142857142858,0,16.2,0.3,-0.92,2 +Student_02390,1,39,9238,1,2,1,1,19,1,5,5,110.0,136.5,0,0,0,1,1,0,0,28,0,5,6,0,0.0,0,0,5,5,0,0.0,0,13.9,-0.3,0.79,0 +Student_02407,2,39,171,1,1,12,1,37,37,7,7,110.0,106.0,1,0,0,1,1,0,0,36,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_02409,1,18,9991,0,1,1,1,43,40,2,2,112.0,106.4,0,0,0,1,1,0,0,22,0,5,0,0,0.0,0,0,5,0,0,0.0,0,8.9,1.4,3.51,0 +Student_02412,2,39,8014,0,1,1,1,34,34,90,90,133.1,116.0,0,0,0,0,0,0,0,51,0,6,13,4,11.25,0,0,6,12,0,0.0,1,10.8,1.4,1.74,0 +Student_02413,2,39,9991,0,2,1,1,37,37,9,9,150.0,120.0,0,0,0,1,0,0,0,43,0,5,11,3,10.666666666666666,0,1,5,10,4,12.5,0,9.4,-0.8,-3.12,1 +Student_02414,2,39,8014,0,2,1,1,34,34,0,0,100.0,100.0,1,0,0,1,0,0,0,41,0,6,9,5,11.8,0,1,6,10,3,10.666666666666666,1,7.6,2.6,0.32,2 +Student_02417,1,17,9070,1,2,1,1,37,37,9,9,127.0,119.3,1,1,0,1,1,1,0,25,0,6,8,4,10.25,0,0,6,6,4,11.25,0,12.7,3.7,-1.7,0 +Student_02418,1,43,9991,0,1,1,1,37,37,9,9,140.0,135.8,1,0,0,1,1,0,0,25,14,15,16,15,10.8,0,13,14,14,14,11.357142857142858,0,9.4,-0.8,-3.12,2 +Student_02421,1,39,9085,1,1,2,1,38,38,9,10,140.0,150.0,0,0,0,1,1,0,0,47,0,6,0,0,0.0,0,0,6,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_02424,1,39,9003,1,1,1,1,1,37,9,8,133.1,130.0,0,0,0,1,1,0,0,29,0,3,4,0,0.0,0,0,4,8,0,0.0,0,16.2,0.3,-0.92,0 +Student_02427,1,39,9991,0,2,1,1,19,38,9,9,133.1,102.5,0,0,0,0,1,0,0,27,0,5,10,0,0.0,0,0,5,5,0,0.0,0,15.5,2.8,NA,0 +Student_02432,1,1,9991,0,1,1,1,38,37,9,9,172.0,149.3,0,0,0,1,1,1,0,24,0,5,5,5,16.0,0,0,5,5,5,16.0,0,8.9,1.4,3.51,2 +Student_02434,1,17,9119,1,4,1,1,38,37,5,7,135.0,126.6,1,0,0,1,1,0,0,18,0,5,7,4,12.0,0,0,5,10,3,13.0,3,7.6,2.6,0.32,1 +Student_02435,2,43,9085,1,1,1,1,37,37,9,7,160.0,120.0,0,0,0,1,1,0,0,21,0,5,11,0,0.0,2,0,5,11,3,11.666666666666666,1,9.4,-0.8,-3.12,1 +Student_02448,2,39,9254,1,1,19,1,37,19,9,10,133.1,156.5,0,0,0,1,1,0,0,53,7,11,12,2,15.0,7,4,9,10,3,10.0,4,16.2,0.3,-0.92,2 +Student_02451,1,1,171,1,1,1,1,1,38,5,9,130.0,118.1,0,0,1,0,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,1 +Student_02463,1,1,171,1,1,1,1,3,3,2,2,159.0,165.7,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02466,1,39,9130,1,1,19,1,37,37,9,10,NA,156.4,1,0,1,1,1,0,0,44,0,6,9,5,11.571428571428571,0,0,6,11,0,0.0,0,13.9,-0.3,0.79,0 +Student_02488,1,18,9147,1,1,1,1,19,1,9,7,147.0,139.3,1,0,0,1,1,0,0,20,0,5,0,0,0.0,0,0,5,0,0,0.0,0,12.4,0.5,1.79,0 +Student_02490,1,1,9254,1,2,1,1,1,38,2,8,NA,122.3,1,0,0,1,1,1,0,20,0,6,7,6,14.714285714285714,0,0,6,6,6,12.5,0,8.9,1.4,3.51,2 +Student_02491,1,17,9773,1,2,1,1,1,1,4,4,124.0,127.9,1,0,0,1,1,0,0,20,0,6,11,3,13.666666666666666,0,0,6,13,4,10.25,0,9.4,-0.8,-3.12,1 +Student_02504,2,39,9500,1,1,1,1,3,1,5,5,133.1,148.8,0,0,0,1,0,1,0,34,0,7,7,6,12.513333333333334,0,0,8,9,7,13.071428571428571,0,12.4,0.5,1.79,2 +Student_02506,1,1,9500,1,6,1,1,19,19,9,9,143.0,127.0,1,0,0,1,0,1,0,18,0,8,8,7,13.585714285714284,0,0,8,8,7,13.585714285714284,0,12.7,3.7,-1.7,2 +Student_02510,1,43,9070,1,1,1,1,19,38,9,7,114.0,135.9,0,0,0,1,1,0,0,26,9,14,14,14,14.0,0,7,13,13,13,13.615384615384617,0,15.5,2.8,-4.06,2 +Student_02511,1,10,9773,1,2,1,22,19,38,3,5,154.4,154.4,1,0,0,0,0,0,1,18,0,6,8,5,12.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_02516,1,17,9119,1,4,1,62,1,1,191,171,122.0,121.0,1,0,0,1,1,0,1,20,0,5,10,4,14.25,0,0,5,14,1,10.0,0,8.9,1.4,3.51,1 +Student_02527,1,1,9070,1,4,1,1,1,1,9,7,143.0,134.6,1,0,0,1,0,1,0,18,0,6,6,6,14.5,0,0,6,6,6,12.833333333333334,0,12.4,0.5,1.79,0 +Student_02530,1,17,9147,1,1,1,1,19,38,4,8,134.0,129.5,0,0,0,1,0,1,0,18,0,5,5,5,11.6,0,0,5,12,4,12.625,0,10.8,1.4,1.74,2 +Student_02533,1,16,9238,1,2,1,1,38,37,3,5,126.0,127.1,1,0,0,1,0,1,0,19,0,6,14,3,12.666666666666666,0,0,6,7,6,11.0,0,9.4,-0.8,-3.12,2 +Student_02536,1,17,9853,1,2,1,1,3,1,1,5,141.0,130.2,1,0,0,1,0,0,0,19,0,6,8,5,11.4,1,0,6,7,4,10.75,0,12.7,3.7,-1.7,1 +Student_02541,1,7,9147,1,1,3,1,1,39,4,7,120.0,120.0,0,0,0,1,0,0,0,33,2,5,9,2,14.0,0,0,5,5,0,0.0,0,12.4,0.5,1.79,0 +Student_02542,1,1,9853,1,1,1,1,19,19,4,5,148.0,143.5,0,0,0,1,0,1,0,19,0,7,8,6,12.833333333333334,0,0,6,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_02543,1,17,9556,1,2,1,1,1,1,9,9,NA,128.3,0,0,0,1,0,1,0,18,0,7,7,7,13.428571428571429,0,0,8,8,8,14.75,0,15.5,2.8,-4.06,2 +Student_02556,1,1,9119,1,1,1,1,19,37,5,8,163.0,150.8,1,0,0,1,1,0,0,18,0,5,9,4,10.5,0,0,5,11,2,NA,3,7.6,2.6,0.32,1 +Student_02557,1,15,9147,1,1,1,26,1,1,2,3,130.0,130.0,0,0,0,1,0,0,1,19,0,5,10,4,12.0,0,0,5,6,5,11.4,0,11.1,0.6,2.02,2 +Student_02572,1,1,9500,1,1,1,1,38,38,9,9,NA,138.8,1,0,0,1,0,0,0,31,0,7,9,7,15.46875,0,0,8,8,8,16.3875,0,11.1,0.6,2.02,2 +Student_02575,1,16,9773,1,3,1,1,37,38,4,9,138.0,134.2,1,0,0,1,0,1,0,20,0,6,6,6,15.0,0,0,6,6,6,13.0,0,11.1,0.6,2.02,2 +Student_02576,2,39,8014,0,1,1,1,37,37,7,5,150.0,143.0,0,0,0,1,0,0,0,40,5,9,9,9,15.88888888888889,0,3,7,7,7,14.142857142857142,0,12.7,3.7,-1.7,2 +Student_02578,1,NA,9254,1,4,1,1,37,37,9,7,110.0,113.2,1,0,0,1,0,0,0,24,0,6,14,2,10.5,0,0,6,11,1,10.0,0,10.8,1.4,1.74,0 +Student_02579,1,17,9500,1,4,1,1,19,37,5,8,146.0,135.8,1,0,0,1,0,0,0,18,0,7,7,6,13.983333333333334,0,0,7,7,6,13.983333333333334,0,7.6,2.6,0.32,2 +Student_02583,1,1,9147,1,1,1,1,38,37,9,5,160.0,159.3,0,0,0,1,0,0,0,18,0,5,5,5,14.4,0,0,5,5,5,15.4,0,7.6,2.6,0.32,2 +Student_02593,1,7,9147,1,1,3,1,37,19,9,8,130.0,130.0,0,0,0,1,0,0,0,21,4,9,9,9,10.88888888888889,0,3,10,18,10,11.615384615384617,0,10.8,1.4,1.74,2 +Student_02596,1,17,9070,1,1,1,1,19,37,5,9,135.0,145.9,0,0,0,1,0,1,0,18,0,6,6,6,12.666666666666666,0,0,6,6,6,12.166666666666666,0,16.2,0.3,-0.92,2 +Student_02600,1,17,9853,1,3,1,1,38,38,7,7,118.0,NA,1,0,0,1,0,0,0,18,0,6,8,5,13.4,0,0,6,7,5,12.0,0,7.6,2.6,0.32,1 +Student_02601,1,17,9853,1,3,1,1,37,37,5,9,138.0,125.1,1,1,0,1,0,1,0,19,0,6,6,6,13.5,0,0,6,8,5,12.8,0,12.7,3.7,-1.7,0 +Student_02612,1,17,9773,1,2,1,1,1,1,5,5,121.0,123.1,1,0,0,1,1,0,0,20,0,6,12,4,14.75,0,0,6,7,4,12.25,0,9.4,-0.8,-3.12,2 +Student_02617,1,17,9853,1,1,1,1,19,38,5,7,160.0,139.0,1,0,0,1,0,1,0,18,0,6,8,5,12.2,0,0,6,13,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02618,1,17,9254,1,1,1,1,1,19,5,4,118.0,118.0,0,0,0,1,0,1,0,19,0,6,7,5,11.0,0,0,6,7,5,12.8,0,12.4,0.5,1.79,2 +Student_02620,1,44,9238,1,1,1,1,1,1,5,5,140.0,143.4,0,0,0,1,0,1,0,NA,3,6,6,6,14.833333333333334,0,2,6,7,6,12.571428571428571,0,13.9,-0.3,0.79,2 +Student_02631,1,39,9991,0,1,1,1,1,1,9,7,130.0,152.1,0,0,0,1,1,0,0,28,0,5,13,2,11.0,0,0,5,12,1,12.0,0,11.1,0.6,2.02,0 +Student_02638,1,16,171,1,2,1,1,3,3,2,2,145.0,143.6,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.4,0.5,1.79,2 +Student_02640,1,1,171,1,2,1,1,19,19,4,7,NA,149.0,1,0,0,1,1,0,0,22,14,17,21,17,12.578947368421051,0,15,17,20,17,12.117647058823527,0,11.1,0.6,2.02,2 +Student_02644,1,39,9991,0,1,1,1,37,1,5,4,133.1,151.2,0,0,0,1,1,0,0,25,0,5,11,4,11.5,0,0,5,11,3,13.5,0,12.4,0.5,1.79,0 +Student_02647,1,43,9070,1,1,1,1,3,39,3,7,150.0,126.4,0,0,0,1,1,0,0,26,5,7,8,7,13.285714285714286,0,3,8,11,7,12.142857142857142,0,12.4,0.5,1.79,1 +Student_02667,1,17,9070,1,4,1,1,38,1,9,9,144.0,137.4,1,0,0,1,1,0,0,19,0,6,6,6,13.833333333333334,0,0,6,8,6,13.125,0,10.8,1.4,1.74,2 +Student_02670,1,39,8014,0,1,1,1,37,38,9,9,133.1,148.5,0,0,0,1,1,0,0,34,0,6,6,4,12.25,0,0,5,5,0,0.0,0,11.1,0.6,2.02,0 +Student_02681,4,43,9500,1,1,19,1,34,34,0,0,100.0,110.0,0,0,0,1,1,0,0,30,11,14,26,12,12.52608695652174,1,11,14,26,12,12.52608695652174,1,7.6,2.6,0.32,2 +Student_02682,2,39,9500,1,1,19,1,38,38,7,8,133.1,170.0,0,0,0,1,1,0,0,36,0,7,9,6,NA,0,0,8,11,0,0.0,0,16.2,0.3,-0.92,0 +Student_02683,1,7,9991,0,1,3,1,37,37,6,7,120.0,120.0,0,0,1,0,1,0,0,46,0,5,5,0,0.0,0,0,5,5,1,10.0,0,11.1,0.6,2.02,0 +Student_02686,1,1,9119,1,2,1,1,1,38,141,192,126.0,122.5,1,0,0,1,1,0,0,20,0,5,7,5,10.8,0,0,5,9,3,12.0,0,8.9,1.4,3.51,1 +Student_02706,1,39,9147,1,2,1,1,19,5,4,1,143.0,100.0,1,0,0,1,1,0,0,24,0,5,8,3,10.666666666666666,1,0,5,5,1,14.0,0,9.4,-0.8,-3.12,0 +Student_02709,1,5,9070,1,3,1,1,3,1,9,6,157.0,138.1,1,0,0,1,0,0,0,18,0,6,6,6,12.666666666666666,0,0,6,8,6,14.125,0,10.8,1.4,1.74,2 +Student_02710,4,39,9556,1,1,1,1,19,3,9,2,160.0,130.0,0,0,0,1,0,0,0,25,0,7,14,7,11.95,0,0,8,15,7,12.042857142857144,0,NA,3.7,-1.7,1 +Student_02711,1,17,9254,1,1,1,1,38,37,9,6,116.0,109.7,1,0,0,1,0,0,0,NA,0,6,7,5,14.0,0,0,6,6,6,15.666666666666666,0,11.1,0.6,2.02,2 +Student_02721,1,1,9085,1,2,1,1,1,38,9,8,141.0,128.9,1,0,0,1,0,1,0,18,0,6,7,6,13.833333333333334,0,0,6,10,6,13.714285714285714,0,8.9,1.4,3.51,2 +Student_02728,1,17,9500,1,2,1,1,38,19,5,7,129.0,124.0,1,0,0,1,0,1,0,18,0,8,8,7,14.312857142857142,0,0,8,8,7,14.312857142857142,0,10.8,1.4,1.74,2 +Student_02733,1,1,9500,1,1,1,1,19,19,4,4,131.0,122.0,1,0,0,NA,0,0,0,20,0,8,8,7,14.014285714285714,0,0,8,8,7,14.014285714285714,0,12.7,3.7,-1.7,1 +Student_02737,1,17,9500,1,4,1,1,1,37,9,9,137.0,128.4,1,0,0,1,0,1,0,19,0,7,7,7,13.385714285714286,0,0,8,8,8,15.925,0,13.9,-0.3,0.79,2 +Student_02743,1,1,9238,1,1,1,1,37,37,4,4,141.0,138.9,0,0,0,1,0,0,0,21,0,6,7,6,13.333333333333334,0,0,6,6,6,14.5,0,10.8,1.4,1.74,2 +Student_02766,1,16,9500,1,4,1,1,1,1,4,4,145.0,127.5,1,0,0,1,0,0,0,18,0,8,8,8,13.11,0,0,8,8,8,13.11,0,9.4,-0.8,-3.12,2 +Student_02779,1,7,9003,1,0,3,1,1,37,4,9,130.0,130.0,1,0,0,1,0,0,0,23,10,17,28,17,13.15,2,8,12,22,12,13.214285714285714,0,15.5,2.8,-4.06,2 +Student_02782,1,1,9853,1,1,1,1,34,37,9,9,125.0,129.2,1,0,1,0,0,0,0,20,0,6,12,3,10.333333333333334,0,0,6,14,1,11.0,0,10.8,1.4,1.74,0 +Student_02786,1,1,8014,0,1,1,1,37,37,9,7,125.0,114.9,0,0,0,1,0,0,0,29,8,11,14,11,12.75,0,3,7,7,7,13.428571428571429,0,9.4,-0.8,-3.12,2 +Student_02787,1,39,NA,1,1,9,1,38,1,5,4,133.1,102.0,1,0,0,1,1,0,0,28,0,6,11,3,13.0,0,0,6,15,1,12.0,0,7.6,2.6,0.32,0 +Student_02788,NA,1,9670,1,3,1,1,37,37,7,7,120.0,111.3,1,0,0,1,1,0,0,19,0,5,7,3,11.333333333333334,0,0,5,7,4,11.0,0,9.4,-0.8,-3.12,1 +Student_02792,1,1,9085,1,1,1,1,38,19,9,3,120.0,112.7,0,0,0,1,1,0,0,19,0,6,7,6,14.857142857142858,0,0,6,8,6,14.142857142857142,0,11.1,0.6,NA,2 +Student_02797,1,39,9500,1,1,1,1,37,37,9,9,137.0,141.0,0,0,0,1,1,0,0,36,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.4,0.5,1.79,0 +Student_02802,1,44,9130,1,1,39,1,3,1,2,4,120.0,120.0,1,0,0,1,0,0,0,20,0,6,6,0,0.0,0,0,6,6,0,0.0,0,12.4,0.5,1.79,0 +Student_02803,1,1,9773,1,1,1,1,19,37,4,7,142.0,141.3,0,0,0,1,0,1,0,19,0,6,7,6,14.714285714285714,0,0,6,6,6,15.166666666666666,0,13.9,-0.3,0.79,2 +Student_02806,1,1,9500,1,4,1,1,19,19,9,9,126.0,125.0,1,0,0,1,0,0,0,19,0,7,8,6,11.658333333333331,0,0,8,11,6,12.416666666666666,0,12.4,0.5,1.79,2 +Student_02807,1,18,9773,1,2,1,24,37,19,9,7,132.0,119.1,1,0,0,1,0,1,1,22,0,6,8,5,11.6,0,0,6,7,6,12.0,0,9.4,-0.8,-3.12,2 +Student_02824,1,17,9670,1,1,1,1,1,1,4,4,115.0,109.1,1,0,0,1,0,1,0,19,0,6,7,6,13.285714285714286,0,0,6,9,5,14.6,0,12.4,0.5,1.79,1 +Student_02826,1,17,9130,1,1,1,1,19,19,4,4,117.0,113.5,1,0,0,1,0,0,0,19,0,6,8,6,11.333333333333334,0,0,6,12,4,13.75,0,8.9,1.4,3.51,0 +Student_02827,1,1,9670,1,2,1,1,1,19,4,7,121.0,135.4,1,0,0,1,0,1,0,19,0,6,6,6,13.333333333333334,0,0,6,10,5,13.4,0,8.9,1.4,3.51,2 +Student_02834,1,1,9670,1,2,1,1,37,37,9,9,117.0,111.8,0,0,0,1,0,0,0,22,0,5,8,3,12.0,0,0,5,9,2,11.0,1,7.6,2.6,0.32,1 +Student_02842,2,39,9003,1,1,1,1,37,37,9,6,140.0,104.8,0,0,0,1,0,0,0,46,14,19,24,19,12.210526315789474,0,11,13,13,13,11.384615384615383,0,15.5,2.8,-4.06,2 +Student_02847,2,39,9556,1,2,12,1,34,34,99,99,133.1,100.5,0,0,0,1,0,0,0,39,0,3,7,1,14.0,0,0,2,4,0,0.0,0,11.1,0.6,2.02,0 +Student_02848,2,39,9773,1,1,19,1,37,37,9,6,133.1,110.0,0,0,0,0,0,0,0,53,0,5,5,0,0.0,0,0,4,5,0,0.0,0,15.5,2.8,-4.06,0 +Student_02849,2,42,9147,1,1,1,1,37,37,9,9,100.0,100.0,1,0,0,1,0,0,0,54,13,15,20,13,12.461538461538462,1,10,13,13,10,11.1,1,15.5,2.8,-4.06,0 +Student_02851,1,18,9773,1,2,1,1,1,1,4,4,109.0,109.0,1,0,0,0,0,0,0,20,0,6,6,0,0.0,0,0,6,0,0,0.0,0,8.9,1.4,3.51,0 +Student_02867,2,39,8014,0,1,19,1,3,19,90,90,133.1,123.5,0,0,0,1,0,0,0,50,0,1,1,0,NA,1,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_02875,2,39,9991,0,1,12,1,37,34,90,90,133.1,110.7,1,0,0,1,0,0,0,50,0,5,0,0,0.0,0,0,5,0,0,0.0,0,7.6,2.6,0.32,0 +Student_02882,1,43,9238,1,1,1,1,19,19,5,5,122.0,114.3,1,0,0,1,0,0,0,NA,5,10,15,8,11.0,0,2,7,16,5,11.2,0,9.4,-0.8,-3.12,1 +Student_02886,1,39,8014,0,1,2,1,37,37,5,7,130.0,147.5,0,0,0,1,0,0,0,39,7,11,13,11,14.454545454545457,0,6,8,8,8,13.5,0,12.7,3.7,-1.7,2 +Student_02889,1,17,9238,1,1,1,1,37,37,9,7,131.0,121.9,0,0,0,1,0,1,0,19,0,6,8,6,13.75,0,0,6,7,6,11.857142857142858,0,16.2,0.3,-0.92,2 +Student_02893,1,1,9670,1,2,1,1,1,19,4,7,131.0,135.9,1,0,0,1,0,1,0,18,0,6,6,6,13.166666666666666,0,0,6,8,6,12.428571428571429,0,8.9,1.4,3.51,2 +Student_02906,1,17,9773,1,1,1,1,3,1,2,3,136.0,132.5,1,0,0,1,0,0,0,19,0,6,7,6,12.5,0,0,6,7,6,12.5,0,10.8,1.4,1.74,2 +Student_02908,2,1,9500,1,4,1,1,1,37,4,9,140.0,128.0,0,0,0,1,0,1,0,18,0,7,7,6,14.066666666666668,0,0,7,7,6,14.066666666666668,0,7.6,2.6,0.32,2 +Student_02912,1,1,9500,1,6,1,1,19,19,4,4,143.0,135.3,1,0,0,1,0,0,0,18,0,8,8,8,13.27625,0,0,8,8,8,13.27625,0,9.4,-0.8,-3.12,2 +Student_02918,1,1,9500,1,1,1,1,38,38,7,7,118.0,115.2,1,0,0,1,0,0,0,19,0,7,9,6,12.97166666666667,0,0,8,9,7,12.321428571428571,0,11.1,0.6,2.02,2 +Student_02926,1,1,9773,1,1,1,1,37,37,9,7,154.0,150.2,0,0,0,1,0,1,0,18,0,6,6,6,14.5,0,0,6,6,6,14.666666666666666,0,16.2,0.3,-0.92,2 +Student_02929,1,1,171,1,1,1,1,37,37,9,3,122.0,115.7,1,0,0,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,9.4,-0.8,-3.12,0 +Student_02932,1,1,9130,1,1,1,1,6,6,0,4,132.0,119.1,1,0,1,NA,0,0,0,29,0,5,10,1,13.0,4,0,5,14,0,0.0,8,10.8,1.4,1.74,0 +Student_02933,1,39,9991,0,1,1,1,37,37,6,6,130.0,111.9,0,0,1,1,0,0,0,36,0,5,5,0,0.0,0,0,5,5,0,0.0,0,12.7,3.7,-1.7,0 +Student_02934,1,1,9500,1,6,1,1,19,19,9,9,144.0,130.5,1,0,0,1,0,0,0,18,0,8,12,7,11.971428571428572,0,0,8,12,7,11.971428571428572,0,12.7,3.7,-1.7,2 +Student_02940,1,39,8014,0,1,1,1,37,37,6,5,100.0,107.5,0,0,0,1,0,0,0,41,0,2,2,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_02944,1,39,9003,1,1,1,1,19,19,9,1,130.0,140.0,0,0,0,1,0,0,0,26,6,12,13,6,13.0,0,4,12,14,11,13.833333333333334,0,15.5,2.8,-4.06,2 +Student_02955,4,39,9238,1,1,1,1,37,37,9,9,120.0,125.5,1,0,0,1,0,1,0,39,0,6,7,6,14.0,0,0,6,7,5,14.8,0,12.7,3.7,-1.7,2 +Student_02956,1,1,171,1,1,1,1,37,37,9,9,139.0,124.0,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,2 +Student_02959,2,39,9853,1,1,19,1,37,19,3,7,133.1,100.0,0,0,0,1,0,0,0,45,0,6,11,3,12.333333333333334,0,0,6,13,2,11.0,0,7.6,2.6,0.32,0 +Student_02961,1,1,9670,1,1,1,1,1,1,9,1,133.1,103.0,1,0,0,1,0,1,0,20,0,6,8,4,11.75,0,0,6,10,6,12.666666666666666,0,10.8,1.4,1.74,2 +Student_02964,2,1,9991,0,1,3,1,1,3,4,9,160.0,137.3,0,0,0,1,0,0,0,23,0,5,5,5,10.8,0,0,5,9,4,11.5,0,9.4,-0.8,-3.12,2 +Student_02971,1,43,9238,1,2,1,1,19,19,4,5,133.1,120.6,1,0,0,1,0,0,0,24,6,10,16,10,12.5,0,2,7,9,4,12.6,0,16.2,0.3,-0.92,2 +Student_02987,1,43,9853,1,2,1,1,19,1,5,4,118.0,110.0,1,0,0,1,0,0,0,20,0,6,10,4,12.25,0,0,6,8,4,11.5,0,10.8,1.4,1.74,1 +Student_02988,2,39,8014,0,1,19,1,34,34,0,0,100.0,100.0,0,0,0,NA,0,0,0,46,0,6,9,6,13.333333333333334,0,0,6,6,6,11.833333333333334,0,7.6,2.6,0.32,2 +Student_02994,2,39,8014,0,1,1,1,37,37,5,6,140.0,128.5,0,0,0,1,0,1,0,38,0,6,6,5,12.4,0,0,6,7,6,12.666666666666666,0,9.4,-0.8,-3.12,2 +Student_02998,1,17,9147,1,1,1,1,3,3,2,2,120.0,112.0,0,0,0,1,0,0,0,20,0,5,10,4,11.0,0,0,5,7,4,11.5,0,15.5,2.8,-4.06,1 +Student_03001,1,39,9500,1,1,1,1,3,19,2,5,148.0,130.0,0,0,0,1,0,0,0,24,0,8,12,7,12.714285714285714,0,0,8,12,7,12.714285714285714,0,12.7,3.7,-1.7,1 +Student_03002,1,1,9500,1,2,1,1,4,1,2,10,139.0,136.4,1,0,0,1,0,0,0,19,0,7,9,7,13.422222222222224,0,0,8,11,7,12.18888888888889,0,15.5,2.8,-4.06,2 +Student_03010,1,1,9500,1,4,1,1,1,12,3,6,125.0,115.2,1,0,0,1,0,0,0,20,0,7,7,7,12.982857142857142,0,0,8,8,8,14.4625,0,12.4,0.5,1.79,2 +Student_03011,1,17,9085,1,1,1,1,3,2,2,3,141.0,130.2,1,0,0,1,0,0,0,20,0,6,14,6,15.75,0,0,6,8,6,13.0,0,15.5,2.8,-4.06,2 +Student_03012,1,1,9085,1,1,1,1,2,2,6,6,132.0,128.5,0,0,0,1,0,0,0,18,0,6,11,5,12.285714285714286,0,0,6,19,3,14.0,1,12.4,0.5,1.79,0 +Student_03015,1,1,9500,1,6,1,1,1,37,7,7,142.0,123.5,1,0,0,1,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03028,1,1,9773,1,4,1,1,41,1,4,NA,122.0,119.6,1,0,0,1,0,0,0,19,0,6,6,4,12.0,0,0,6,11,3,11.333333333333334,0,11.1,0.6,2.02,0 +Student_03046,1,17,9853,1,2,1,1,1,1,3,9,123.0,116.7,1,0,0,1,0,0,0,19,0,6,8,5,13.0,0,0,6,8,4,10.75,0,9.4,-0.8,-3.12,2 +Student_03050,1,1,9085,1,2,1,1,38,37,5,7,127.0,123.9,1,0,0,1,0,0,0,18,0,5,9,4,13.0,0,0,5,8,5,13.142857142857142,0,10.8,1.4,1.74,2 +Student_03065,1,17,9238,1,2,1,1,38,1,7,7,132.0,133.1,1,0,0,1,0,1,0,19,0,6,8,5,12.2,0,0,6,7,6,11.5,0,9.4,-0.8,-3.12,2 +Student_03066,1,17,9254,1,2,1,1,19,19,9,7,115.0,113.3,1,0,1,1,0,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03069,1,39,9556,1,1,1,1,37,37,9,8,140.0,105.0,1,0,0,1,0,1,0,36,0,7,11,6,12.35,0,0,7,12,5,12.5,0,8.9,1.4,3.51,2 +Student_03070,1,39,9085,1,1,12,1,37,37,10,9,133.1,144.0,0,0,0,1,1,0,0,51,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.4,0.5,1.79,0 +Student_03073,1,44,9238,1,1,39,1,1,19,4,5,130.0,127.4,0,0,1,0,1,0,0,27,3,6,8,5,11.6,0,2,6,9,5,12.0,0,13.9,-0.3,0.79,0 +Student_03081,1,39,9991,0,1,1,1,19,38,5,5,120.0,152.4,0,0,0,1,1,0,0,27,0,5,5,5,15.2,0,0,5,6,5,14.166666666666666,0,10.8,1.4,1.74,2 +Student_03092,1,17,9853,1,1,1,1,38,38,9,7,128.0,128.4,1,0,0,1,0,1,0,20,0,6,10,5,13.2,0,0,6,12,5,12.833333333333334,0,9.4,-0.8,-3.12,1 +Student_03094,1,43,9500,1,1,1,1,29,38,90,3,148.0,131.0,1,0,0,1,0,1,0,22,18,23,23,20,14.575,3,18,23,23,20,14.575,3,7.6,2.6,0.32,2 +Student_03098,1,17,9773,1,4,1,1,38,19,9,9,119.0,118.3,0,0,0,1,0,0,0,19,0,6,8,4,11.25,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_03103,1,39,9670,1,1,1,1,37,37,9,9,133.1,100.2,1,0,0,0,0,0,0,26,0,6,9,3,11.75,0,0,6,11,4,11.5,3,16.2,0.3,-0.92,0 +Student_03118,1,1,9773,1,4,1,1,19,19,9,7,122.0,121.0,1,0,0,1,0,0,0,20,0,6,7,6,13.571428571428571,0,0,6,6,6,13.333333333333334,0,13.9,-0.3,0.79,2 +Student_03136,1,1,171,1,1,1,1,1,40,4,3,138.0,149.9,1,0,0,1,0,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,11.1,0.6,2.02,2 +Student_03146,2,43,9991,0,1,1,1,37,37,9,7,133.1,NA,0,0,0,1,0,1,0,32,3,10,12,7,11.142857142857142,0,4,10,10,8,12.0,0,10.8,1.4,1.74,2 +Student_03157,1,43,9003,1,1,1,1,1,38,4,7,125.0,125.0,1,0,0,1,0,0,0,21,9,14,23,9,12.0,2,6,12,21,8,11.25,0,15.5,2.8,-4.06,2 +Student_03160,1,43,9070,1,1,1,1,19,19,9,9,135.0,122.8,1,0,0,1,1,1,0,20,0,6,8,3,11.0,0,0,6,8,2,11.333333333333334,0,10.8,1.4,1.74,1 +Student_03163,1,1,9500,1,4,1,1,19,38,9,9,136.0,123.0,1,0,0,1,0,0,0,19,0,8,8,7,14.328571428571427,0,0,8,8,7,14.328571428571427,0,10.8,1.4,1.74,2 +Student_03167,1,17,9853,1,2,1,1,3,1,2,3,123.0,124.1,1,0,0,1,0,0,0,18,0,6,7,2,14.5,0,0,6,6,1,10.0,0,15.5,2.8,-4.06,0 +Student_03168,1,39,9991,0,1,1,1,19,38,9,8,150.0,140.9,0,1,0,1,0,0,0,24,0,5,7,3,10.666666666666666,0,0,5,7,3,10.5,0,10.8,1.4,1.74,0 +Student_03175,1,17,9238,1,5,1,1,19,37,5,7,131.0,120.2,1,0,0,1,0,1,0,19,0,6,9,5,11.333333333333334,0,0,6,6,6,10.833333333333334,0,13.9,-0.3,0.79,1 +Student_03176,2,39,33,1,1,1,1,38,1,9,5,120.0,153.8,0,0,1,1,1,0,0,35,0,7,9,0,0.0,0,0,7,8,0,0.0,0,11.1,0.6,2.02,0 +Student_03179,1,1,9500,1,1,1,1,3,19,3,10,143.0,126.8,0,0,0,1,1,0,0,19,0,8,8,7,14.535714285714286,0,0,8,8,7,14.535714285714286,0,10.8,1.4,1.74,2 +Student_03186,1,17,9119,1,2,1,1,19,1,9,7,116.0,112.2,0,0,0,1,1,0,0,NA,0,5,0,0,0.0,0,0,5,0,0,0.0,0,16.2,0.3,-0.92,0 +Student_03198,1,1,9147,1,6,1,1,1,19,1,6,127.0,120.0,1,0,0,1,1,0,0,19,0,5,6,5,12.6,0,0,5,8,3,12.666666666666666,0,8.9,1.4,3.51,2 +Student_03203,1,1,9773,1,1,1,1,5,3,4,4,127.0,122.8,1,0,0,1,1,0,0,20,0,6,7,6,12.166666666666666,0,0,6,9,3,12.0,0,12.4,0.5,1.79,1 +Student_03205,1,17,9773,1,5,1,1,38,1,4,4,139.0,123.6,1,0,0,1,1,0,0,18,0,6,6,6,13.0,0,0,6,12,0,0.0,0,7.6,2.6,0.32,0 +Student_03206,1,39,9991,0,1,1,1,37,37,7,9,133.1,111.0,0,0,0,0,1,0,0,28,0,5,0,0,0.0,0,0,5,0,0,0.0,0,8.9,1.4,3.51,0 +Student_03209,1,1,9238,1,1,1,1,1,38,4,6,135.0,122.1,0,1,1,0,1,0,0,19,0,6,6,4,11.5,0,0,6,6,5,11.0,0,8.9,1.4,3.51,0 +Student_03210,1,18,9070,1,2,1,1,38,19,5,5,122.0,119.9,0,0,0,1,1,0,0,18,0,6,8,5,11.0,0,0,6,6,4,10.75,0,9.4,-0.8,-3.12,2 +Student_03214,1,44,9003,1,1,39,1,3,19,2,6,150.0,150.0,0,0,0,1,1,0,0,20,0,6,6,0,0.0,0,0,6,8,0,0.0,0,15.5,2.8,-4.06,0 +Student_03218,1,1,9119,1,5,1,1,37,37,90,90,135.0,122.1,1,0,0,1,1,0,0,20,0,5,10,3,10.666666666666666,0,0,5,5,4,12.25,0,7.6,2.6,0.32,2 +Student_03220,1,39,9991,0,1,1,1,1,37,9,8,140.0,154.5,0,0,0,1,0,0,0,26,0,1,2,0,0.0,0,0,5,8,0,0.0,0,16.2,0.3,-0.92,0 +Student_03222,1,39,9556,1,1,1,1,37,38,9,9,140.0,106.0,1,0,1,0,0,1,0,24,0,7,14,5,12.36,0,1,8,15,5,12.0,0,8.9,1.4,3.51,0 +Student_03229,1,1,9500,1,2,1,1,38,38,9,8,115.0,108.4,1,0,0,1,0,1,0,20,0,7,8,7,11.9625,0,0,8,9,8,13.044444444444444,0,13.9,-0.3,0.79,2 +Student_03233,1,1,9773,1,2,1,1,19,38,3,9,130.0,126.5,1,0,0,1,0,0,0,18,0,6,8,4,12.5,0,0,6,6,5,12.6,0,12.7,3.7,-1.7,2 +Student_03234,1,17,9085,1,3,1,1,37,38,9,9,120.0,111.3,0,0,0,1,0,0,0,20,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03236,1,1,9500,1,2,1,1,37,37,9,7,141.0,126.3,1,0,0,1,0,0,0,19,0,7,10,7,13.805,0,0,8,8,8,14.2725,0,15.5,2.8,-4.06,2 +Student_03244,1,1,9500,1,1,1,1,37,19,7,7,142.0,133.0,1,0,0,1,0,1,0,19,0,8,8,8,14.11,0,0,8,8,8,14.11,0,9.4,-0.8,-3.12,2 +Student_03252,1,17,9147,1,4,1,1,38,37,6,7,121.0,113.0,1,0,0,1,0,1,0,18,0,5,12,4,10.714285714285714,0,0,5,9,4,11.0,0,13.9,-0.3,0.79,2 +Student_03254,1,44,9130,1,1,39,1,1,3,9,2,130.0,130.0,1,0,1,1,0,1,0,21,1,6,13,3,12.333333333333334,0,1,6,12,1,13.0,0,13.9,-0.3,0.79,0 +Student_03256,1,17,9670,1,6,1,1,1,14,4,5,120.0,113.7,1,0,0,1,0,0,0,18,0,5,7,4,11.4,0,0,5,5,4,11.25,0,9.4,-0.8,-3.12,2 +Student_03257,1,1,9500,1,2,1,1,38,38,9,7,140.0,138.8,1,0,0,1,0,0,0,19,0,7,7,6,12.766666666666666,0,0,7,7,6,12.766666666666666,0,7.6,2.6,0.32,2 +Student_03263,1,39,8014,0,1,1,1,12,5,9,4,100.0,116.5,0,0,1,0,0,0,0,37,0,6,6,0,0.0,0,0,5,5,0,0.0,0,8.9,1.4,3.51,0 +Student_03264,1,1,9085,1,2,1,1,37,1,9,9,162.0,165.2,1,0,0,1,0,1,0,18,0,5,6,4,15.75,0,0,5,5,5,13.8,0,10.8,1.4,1.74,2 +Student_03272,2,39,NA,0,1,1,1,38,38,9,9,133.1,113.5,0,0,0,1,0,1,0,50,3,9,11,8,13.25,0,2,7,8,7,11.714285714285714,0,12.7,3.7,-1.7,2 +Student_03273,4,42,9147,1,1,1,1,37,37,9,9,110.0,128.2,0,0,0,1,0,0,0,41,8,14,24,11,12.25,3,5,10,12,10,13.4,0,9.4,-0.8,-3.12,2 +Student_03277,1,51,33,1,1,1,1,19,19,9,9,130.0,117.7,0,0,0,1,0,0,0,34,10,12,12,10,12.0,0,5,10,11,5,11.0,0,11.1,0.6,2.02,0 +Student_03285,2,39,9991,0,1,1,1,37,37,9,6,162.0,132.0,0,0,1,1,1,0,0,25,0,5,8,4,11.0,0,0,5,7,4,12.0,0,7.6,2.6,0.32,1 +Student_03287,1,NA,9556,1,1,43,1,38,19,9,9,160.0,160.0,0,0,0,1,1,0,0,36,0,7,16,1,12.0,0,0,7,13,0,0.0,1,11.1,0.6,2.02,0 +Student_03289,1,39,9991,0,1,1,1,1,37,4,6,150.0,120.0,0,0,0,1,1,0,0,25,0,5,6,4,10.5,0,0,5,6,5,12.0,0,9.4,-0.8,-3.12,2 +Student_03290,1,39,9003,1,1,19,1,37,37,9,7,133.1,100.0,0,0,0,1,1,0,0,35,17,18,20,18,11.555555555555555,0,11,13,13,13,11.615384615384617,0,15.5,2.8,-4.06,2 +Student_03300,1,1,9500,1,5,1,1,38,19,7,7,141.0,132.5,1,0,0,0,0,0,0,19,0,7,0,0,0.0,0,0,8,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03301,1,1,171,1,1,1,1,19,19,5,1,138.0,130.7,1,0,0,1,0,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_03308,1,7,8014,0,1,3,1,NA,37,5,3,120.0,121.3,0,0,0,1,0,0,0,32,7,11,13,11,13.454545454545457,0,5,11,13,7,12.428571428571429,0,12.7,3.7,-1.7,2 +Student_03313,1,51,9070,1,1,12,1,37,19,3,7,133.1,106.6,0,0,1,1,0,0,0,NA,2,6,8,5,11.0,0,4,6,12,6,10.166666666666666,0,NA,1.4,3.51,1 +Student_03321,1,1,9773,1,1,1,1,1,37,5,9,117.0,118.4,0,0,0,1,1,1,0,19,0,6,8,6,11.833333333333334,0,0,6,11,3,13.0,0,15.5,2.8,-4.06,2 +Student_03323,1,17,9147,1,4,1,1,19,1,0,4,135.0,128.7,1,0,0,1,1,0,0,22,0,5,8,2,10.5,0,0,5,10,0,0.0,0,7.6,2.6,0.32,0 +Student_03324,1,17,9119,1,3,1,1,3,1,3,3,115.0,116.1,1,0,0,0,1,0,0,18,0,5,8,5,12.5,0,0,5,7,5,13.571428571428571,0,12.4,0.5,1.79,0 +Student_03326,1,1,171,1,1,1,1,1,3,2,2,123.0,118.8,0,0,0,1,1,0,0,19,4,10,10,5,11.0,0,2,7,8,2,10.0,0,8.9,1.4,3.51,1 +Student_03327,2,43,9991,0,1,1,1,37,37,9,9,NA,130.0,1,0,0,1,1,0,0,30,6,10,14,9,12.333333333333334,0,7,10,12,8,12.0,0,9.4,-0.8,-3.12,2 +Student_03332,1,43,9254,1,1,1,1,12,19,9,9,110.0,125.0,0,0,0,0,1,0,0,31,3,8,19,5,12.166666666666666,0,3,7,12,5,12.0,0,7.6,2.6,0.32,0 +Student_03333,1,17,9119,1,1,1,1,1,1,9,9,126.0,116.2,0,0,1,0,1,0,0,21,0,5,9,2,11.0,0,0,5,8,2,11.5,2,7.6,2.6,0.32,0 +Student_03342,1,17,9670,1,1,1,1,1,1,4,8,138.0,123.0,0,0,1,0,1,0,0,20,0,6,7,5,12.4,0,0,6,8,4,13.0,0,13.9,-0.3,0.79,1 +Student_03344,1,1,9119,1,1,1,1,37,37,9,6,160.0,153.7,0,0,0,1,1,0,0,19,0,5,7,1,13.0,0,0,5,7,2,10.0,0,9.4,-0.8,-3.12,1 +Student_03346,1,1,9254,1,1,1,1,37,38,9,8,NA,114.6,1,0,0,1,1,0,0,19,0,6,13,2,12.0,0,0,6,12,1,13.0,0,7.6,2.6,0.32,0 +Student_03349,1,39,9003,1,1,1,1,38,37,9,4,133.1,120.0,0,0,0,1,1,0,0,30,0,6,10,6,11.375,0,0,6,10,5,11.6,0,13.9,-0.3,0.79,2 +Student_03353,1,39,9119,1,1,1,1,1,12,4,3,138.7,111.3,0,0,0,1,1,0,0,27,1,6,7,3,12.0,0,2,6,7,2,11.0,0,13.9,-0.3,0.79,0 +Student_03361,1,17,9670,1,4,1,1,1,1,4,7,126.0,115.2,0,0,0,0,0,0,0,19,0,6,7,3,12.666666666666666,0,0,6,10,5,13.125,0,10.8,1.4,1.74,0 +Student_03362,1,1,9773,1,1,1,1,19,1,9,9,125.0,130.6,1,0,0,1,0,1,0,18,0,6,6,6,13.5,0,0,6,6,6,14.0,0,8.9,1.4,3.51,2 +Student_03376,1,44,9003,1,1,39,1,38,38,6,6,160.0,160.0,1,0,0,1,0,0,0,21,0,6,11,6,13.428571428571429,0,0,6,12,6,12.857142857142858,0,15.5,2.8,-4.06,2 +Student_03378,1,1,9853,1,1,1,1,38,38,3,7,113.0,112.3,0,0,0,NA,0,1,0,20,0,7,7,7,12.142857142857142,0,0,7,7,7,12.857142857142858,0,11.1,0.6,2.02,2 +Student_03379,2,1,9147,1,1,1,1,19,37,9,9,137.0,124.4,0,0,0,1,0,0,0,19,0,5,6,4,11.25,0,0,5,10,3,11.714285714285714,0,10.8,1.4,1.74,1 +Student_03385,1,1,9085,1,1,1,1,37,37,9,9,127.0,122.8,1,0,0,1,0,0,0,19,0,5,10,2,14.5,1,0,5,9,3,11.333333333333334,0,12.7,3.7,-1.7,1 +Student_03392,1,42,9500,1,1,1,1,19,19,4,9,124.0,124.0,0,0,0,1,0,0,0,23,0,8,8,8,12.88625,0,0,8,8,8,12.88625,0,9.4,-0.8,-3.12,2 +Student_03395,1,1,9147,1,2,1,1,38,19,3,7,129.0,118.9,1,0,0,1,0,0,0,19,0,5,8,4,12.8,0,0,5,10,3,14.5,0,10.8,1.4,1.74,1 +Student_03397,1,43,9147,1,1,1,1,3,19,2,9,131.0,126.1,0,0,0,1,0,0,0,18,0,5,5,0,0.0,0,0,5,9,4,13.25,2,16.2,0.3,-0.92,1 +Student_03399,2,1,9500,1,5,1,1,1,19,4,4,130.0,122.3,0,0,0,1,0,0,0,NA,0,7,7,6,14.35,0,0,7,7,6,14.35,0,7.6,2.6,0.32,2 +Student_03401,1,1,9238,1,1,1,1,38,38,9,9,154.0,156.5,1,1,0,1,0,1,0,18,0,6,8,6,11.714285714285714,0,0,6,6,6,14.666666666666666,0,12.7,3.7,-1.7,2 +Student_03408,1,1,9500,1,3,1,1,1,19,9,3,139.0,130.3,1,0,0,1,0,1,0,18,0,8,8,8,14.15375,0,0,8,8,8,14.15375,0,9.4,-0.8,-3.12,2 +Student_03410,1,1,9773,1,5,1,1,19,38,3,5,110.0,117.4,1,0,0,1,0,0,0,20,0,6,7,6,13.833333333333334,0,0,6,6,6,12.833333333333334,0,11.1,0.6,2.02,2 +Student_03413,1,17,9147,1,1,1,1,38,38,7,5,139.0,133.4,0,0,0,1,0,0,0,18,0,5,9,1,11.0,1,0,5,10,0,0.0,0,9.4,-0.8,-3.12,1 +Student_03420,1,17,9238,1,1,1,1,19,38,4,9,139.0,146.7,1,0,0,1,0,1,0,20,0,6,6,6,13.333333333333334,0,0,6,7,6,14.0,0,15.5,2.8,-4.06,2 +Student_03429,1,43,8014,0,1,1,1,37,37,9,9,117.0,100.0,0,0,0,1,0,0,0,27,0,6,6,4,12.5,0,0,6,6,6,14.333333333333334,0,13.9,-0.3,0.79,0 +Student_03432,1,1,9500,1,3,1,1,1,1,4,4,147.0,134.3,1,0,0,1,0,0,0,18,0,8,8,7,14.2,0,0,8,8,7,14.2,0,12.7,3.7,-1.7,2 +Student_03439,1,39,9556,1,2,19,1,37,37,3,7,133.1,117.8,0,0,0,1,0,0,0,24,0,7,10,6,11.416666666666666,0,0,8,9,8,11.9625,0,13.9,-0.3,0.79,2 +Student_03441,1,17,9556,1,1,1,1,1,38,4,9,133.0,119.0,0,0,0,1,0,0,0,19,0,7,10,6,11.15,0,0,7,7,7,12.814285714285717,0,12.7,3.7,-1.7,1 +Student_03449,1,1,9773,1,1,1,1,19,37,9,6,140.0,135.8,1,0,0,1,0,1,0,19,0,6,6,6,13.0,0,0,6,7,6,13.0,0,10.8,1.4,1.74,2 +Student_03451,1,39,9991,0,1,1,1,37,37,9,9,130.0,151.6,0,0,0,1,0,0,0,24,0,5,9,5,12.285714285714286,0,0,5,8,5,12.125,0,16.2,0.3,-0.92,1 +Student_03454,1,1,9500,1,6,1,1,37,38,9,9,150.0,131.5,1,0,0,1,0,1,0,19,0,8,8,7,NA,0,0,8,8,7,12.657142857142857,0,12.7,3.7,-1.7,2 +Student_03456,1,1,9238,1,1,1,1,19,1,6,5,145.0,127.9,1,0,0,1,0,0,0,19,0,6,7,6,13.714285714285714,0,0,6,6,6,13.166666666666666,0,12.7,3.7,-1.7,2 +Student_03460,4,43,9991,0,4,12,1,37,37,9,9,133.1,153.0,0,0,0,0,0,0,0,40,0,5,10,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_03464,1,1,9853,1,1,1,1,1,37,9,9,160.0,146.0,1,0,0,1,0,0,0,19,0,6,11,3,10.333333333333334,0,0,6,10,5,11.8,0,9.4,-0.8,-3.12,1 +Student_03479,1,39,9238,1,1,1,1,38,1,9,3,160.0,124.0,0,0,1,1,1,0,0,28,2,8,15,7,11.0,0,0,6,17,1,10.0,0,10.8,1.4,1.74,1 +Student_03481,1,1,9500,1,1,1,1,37,37,9,7,133.0,121.8,0,0,0,1,1,1,0,18,0,8,8,8,12.93875,0,0,8,8,8,12.93875,0,9.4,-0.8,-3.12,2 +Student_03486,2,39,9670,1,1,1,1,19,38,9,9,130.0,162.3,0,0,0,1,1,0,0,36,0,6,13,3,11.333333333333334,0,0,6,12,5,11.4,0,NA,-0.3,0.79,0 +Student_03489,1,39,9130,1,1,1,1,1,1,4,10,150.0,110.0,0,0,1,1,1,0,0,24,0,5,13,2,12.5,2,0,5,8,3,12.333333333333334,0,9.4,-0.8,-3.12,0 +Student_03492,2,43,9991,0,3,1,1,37,37,9,9,120.0,128.2,1,0,0,1,1,0,0,32,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_03500,1,39,9003,1,1,1,1,1,37,191,193,160.0,140.0,0,0,0,1,1,0,0,27,0,6,6,0,0.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,1 +Student_03501,1,1,9147,1,1,1,1,1,19,9,9,122.0,120.3,1,0,0,1,1,1,0,19,0,5,8,5,12.6,0,0,5,9,5,13.6,0,8.9,1.4,3.51,0 +Student_03505,1,1,9670,1,1,1,1,1,1,5,9,141.0,126.3,0,0,0,1,1,1,0,18,0,6,8,6,12.166666666666666,0,0,6,7,5,13.0,0,13.9,-0.3,0.79,2 +Student_03506,1,17,9147,1,3,1,1,37,37,5,7,127.0,116.2,0,0,0,1,1,0,0,18,0,5,10,0,0.0,1,0,5,13,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03513,1,1,171,1,1,1,1,19,19,1,1,140.0,129.5,1,0,0,1,1,0,0,20,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_03517,1,17,171,1,1,1,1,3,12,2,9,123.0,116.4,1,0,1,1,1,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,10.8,1.4,1.74,0 +Student_03524,1,43,9670,1,4,1,1,3,3,4,4,117.0,113.2,0,0,0,1,1,0,0,21,0,5,11,2,10.0,0,0,5,10,3,10.333333333333334,0,9.4,-0.8,-3.12,1 +Student_03531,1,1,9670,1,3,1,1,3,1,2,3,106.0,105.7,1,0,0,1,1,0,0,19,0,6,6,6,13.333333333333334,0,0,6,9,5,13.8,0,8.9,1.4,3.51,2 +Student_03535,1,39,9991,0,1,1,1,34,34,0,0,120.0,120.5,1,0,0,1,1,0,0,30,0,5,5,2,11.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_03545,1,39,9991,0,1,12,1,37,37,9,9,133.1,121.5,0,0,0,1,1,0,0,38,0,5,11,2,10.5,0,0,5,9,3,11.333333333333334,1,7.6,2.6,0.32,1 +Student_03547,1,17,9500,1,4,1,1,19,38,9,6,143.0,131.5,1,0,0,1,1,1,0,18,0,7,8,7,12.5125,0,0,8,8,8,14.1875,0,13.9,-0.3,0.79,2 +Student_03548,2,43,9130,1,1,9,1,34,34,0,0,133.1,128.2,0,0,0,1,1,0,0,28,0,5,9,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,0.32,0 +Student_03550,1,1,9500,1,1,1,1,2,19,3,9,127.0,121.5,0,0,0,1,1,0,0,23,0,7,7,6,13.483333333333334,0,0,7,7,6,13.483333333333334,0,7.6,2.6,0.32,2 +Student_03551,1,1,9500,1,1,1,1,38,19,194,193,135.0,135.4,1,0,0,1,1,0,0,21,0,7,9,6,12.565,0,0,8,12,5,12.16,0,11.1,0.6,2.02,1 +Student_03553,1,43,9147,1,1,1,1,37,37,5,3,120.0,113.4,0,0,0,1,1,0,0,22,0,5,9,3,13.0,0,0,5,9,3,11.666666666666666,0,12.7,3.7,-1.7,0 +Student_03554,1,44,9119,1,1,39,1,19,37,9,9,150.0,150.0,1,0,1,1,1,0,0,20,0,5,6,5,16.5,0,0,5,7,5,17.714285714285715,0,12.4,0.5,1.79,0 +Student_03555,1,17,9670,1,1,1,1,37,38,3,3,123.0,122.0,0,0,1,1,1,0,0,19,0,6,7,6,13.166666666666666,0,0,6,9,5,13.2,0,8.9,1.4,3.51,1 +Student_03559,1,1,9070,1,4,1,1,4,19,2,10,140.0,125.0,1,0,0,1,1,0,0,19,0,6,7,6,12.666666666666666,0,0,6,8,6,12.142857142857142,0,9.4,-0.8,-3.12,1 +Student_03573,1,43,9991,0,1,12,1,12,12,9,9,133.1,120.0,0,0,0,1,NA,0,0,28,7,13,13,7,10.285714285714286,0,5,11,13,5,10.6,0,10.8,1.4,1.74,0 +Student_03574,1,1,9119,1,2,1,1,19,19,9,9,140.0,125.7,1,0,0,1,1,0,0,18,0,5,5,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,1 +Student_03578,1,42,9500,1,1,1,1,19,19,9,9,100.0,100.0,0,0,1,1,1,0,0,24,0,8,16,2,10.25,1,0,8,16,2,10.25,1,12.7,3.7,-1.7,0 +Student_03580,1,1,9670,1,1,1,1,3,37,4,7,150.0,139.5,0,0,0,1,1,1,0,20,0,6,7,6,14.833333333333334,0,0,6,6,6,14.833333333333334,0,12.7,3.7,-1.7,2 +Student_03581,1,44,9003,1,1,39,1,19,1,9,8,150.0,150.0,1,0,0,1,1,0,0,21,0,6,12,5,13.625,0,0,6,6,5,12.6,0,13.9,-0.3,0.79,2 +Student_03582,2,1,9556,1,1,1,1,19,19,193,144,144.0,139.8,0,0,1,1,1,0,0,24,0,7,7,7,12.271428571428572,0,0,8,10,7,13.657142857142857,0,10.8,1.4,1.74,2 +Student_03588,1,43,9070,1,1,1,1,1,2,9,2,133.0,128.8,0,0,0,1,1,0,0,19,6,12,12,12,13.166666666666666,0,6,12,12,12,13.0,0,10.8,1.4,1.74,2 +Student_03592,1,17,9500,1,3,1,1,3,1,2,7,132.0,125.5,1,0,0,1,1,0,0,18,0,8,8,7,13.154285714285717,0,0,8,8,7,13.154285714285717,0,10.8,1.4,1.74,1 +Student_03594,1,1,9773,1,3,1,1,19,38,8,3,127.0,133.7,1,0,1,1,1,0,0,18,0,6,6,6,13.0,0,0,6,7,5,11.8,0,12.7,3.7,-1.7,0 +Student_03602,1,17,9773,1,3,1,1,2,1,3,3,134.0,129.5,1,0,0,1,1,0,0,18,0,6,7,6,13.166666666666666,0,0,6,7,6,12.666666666666666,0,16.2,0.3,-0.92,2 +Student_03617,1,1,9119,1,1,1,1,19,19,9,8,148.0,129.8,0,0,0,0,1,1,0,18,0,5,6,5,15.0,0,0,5,6,5,14.2,0,8.9,1.4,3.51,1 +Student_03619,1,17,9773,1,5,1,1,1,1,7,7,143.0,136.7,1,0,0,1,0,0,0,18,0,6,6,6,12.5,0,0,6,6,6,13.833333333333334,0,8.9,1.4,3.51,2 +Student_03624,1,18,8014,0,6,1,1,3,19,2,4,134.0,120.7,1,0,0,1,0,0,0,23,0,6,8,4,11.0,0,0,6,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_03625,1,1,9147,1,2,1,1,3,19,2,4,118.0,113.8,1,0,0,1,0,0,0,21,0,5,9,3,11.666666666666666,0,0,5,9,4,11.75,0,8.9,1.4,3.51,2 +Student_03627,1,17,8014,0,1,1,1,34,34,0,0,119.0,112.4,1,0,0,1,0,0,0,26,4,7,15,7,11.571428571428571,0,2,6,14,2,11.0,0,7.6,2.6,0.32,0 +Student_03661,1,1,9238,1,3,1,1,19,1,7,10,124.0,116.0,1,0,1,1,0,0,0,19,0,6,7,0,0.0,0,0,5,5,0,0.0,0,13.9,-0.3,0.79,0 +Student_03669,1,1,9238,1,1,1,41,19,19,9,9,133.0,119.7,1,0,1,1,0,1,1,19,0,6,8,6,12.666666666666666,0,0,6,7,6,12.666666666666666,0,8.9,1.4,3.51,2 +Student_03677,1,43,9238,1,5,1,24,37,19,9,7,101.0,119.9,1,0,1,0,0,0,1,22,5,11,16,9,10.88888888888889,0,2,10,20,4,11.25,1,9.4,-0.8,-3.12,2 +Student_03678,1,1,9773,1,2,1,1,19,38,5,0,133.0,133.7,1,0,0,1,0,0,0,19,0,6,11,1,13.0,0,0,5,10,0,0.0,0,7.6,2.6,0.32,0 +Student_03680,NA,5,9853,1,2,1,1,19,19,3,3,124.0,113.9,1,0,0,1,0,1,0,19,0,6,8,6,12.666666666666666,0,0,6,7,6,12.0,0,12.7,3.7,-1.7,2 +Student_03681,1,1,171,1,1,1,1,37,38,9,9,127.0,120.7,1,0,1,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,0 +Student_03685,2,39,9147,1,1,1,1,37,37,9,7,160.0,110.0,0,0,0,1,1,0,0,30,0,5,8,2,11.0,0,0,5,6,4,11.5,0,15.5,2.8,-4.06,0 +Student_03686,1,43,9003,1,1,1,1,1,1,4,10,120.0,134.4,0,0,0,1,1,0,0,24,0,6,7,6,15.714285714285714,0,0,6,10,6,15.9,0,15.5,2.8,-4.06,0 +Student_03688,1,1,9147,1,1,1,1,19,38,9,7,132.0,119.1,0,0,0,0,1,0,0,19,0,5,16,1,12.0,0,0,5,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_03691,1,17,9147,1,6,1,1,19,1,9,4,129.0,122.0,1,0,0,1,1,0,0,19,0,5,8,5,11.6,1,0,5,10,4,10.75,0,9.4,-0.8,-3.12,2 +Student_03695,1,17,171,1,1,1,1,1,1,9,9,129.0,124.8,1,0,0,1,1,0,0,18,0,0,0,0,0.0,0,0,0,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_03697,1,43,9254,1,1,1,1,37,37,9,9,112.0,108.5,0,0,0,1,1,0,0,21,0,6,6,6,12.666666666666666,0,0,6,7,5,11.4,0,9.4,-0.8,-3.12,2 +Student_03705,1,18,9670,1,2,1,1,37,38,4,1,121.0,111.9,1,0,0,1,1,0,0,19,0,6,6,6,14.166666666666666,0,0,6,6,6,14.0,0,13.9,-0.3,0.79,2 +Student_03710,1,17,9670,1,2,1,1,1,19,5,3,132.0,124.0,1,0,0,1,1,0,0,21,0,5,7,3,12.333333333333334,0,0,5,5,4,11.25,0,7.6,2.6,0.32,0 +Student_03712,1,44,171,1,1,39,1,19,38,9,9,160.0,160.0,1,0,1,1,1,1,0,21,0,0,0,0,0.0,0,0,0,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_03717,1,44,NA,1,1,39,1,4,4,2,10,140.0,140.0,1,0,0,1,1,0,0,20,1,5,8,2,11.5,0,1,5,13,2,11.5,0,12.7,3.7,-1.7,0 +Student_03729,1,51,8014,0,1,2,1,19,38,9,10,110.0,110.0,0,0,0,1,1,0,0,42,8,12,12,11,14.454545454545457,0,7,11,11,10,14.2,0,11.1,0.6,2.02,2 +Student_03746,1,1,171,1,1,1,1,3,1,4,NA,145.0,149.9,1,0,0,0,0,0,0,19,0,0,0,0,0.0,0,0,0,0,0,0.0,0,16.2,0.3,-0.92,2 +Student_03750,1,1,9070,1,4,1,1,3,19,1,5,139.0,138.3,1,0,0,1,0,0,0,19,0,6,6,6,14.666666666666666,0,0,6,6,6,13.166666666666666,0,9.4,-0.8,-3.12,2 +Student_03758,1,1,9500,1,2,1,1,1,3,4,3,137.0,124.6,0,0,0,1,0,0,0,18,0,7,10,7,13.398,0,0,8,8,8,13.5425,0,15.5,2.8,-4.06,2 +Student_03763,1,1,9085,1,1,1,1,19,38,5,7,133.1,110.0,1,0,0,1,0,1,0,21,0,6,8,6,13.285714285714286,0,0,6,11,6,13.0,0,11.1,0.6,2.02,2 +Student_03764,NA,1,9238,1,1,1,1,1,19,4,9,134.0,129.8,0,0,0,1,0,1,0,20,0,6,6,6,11.666666666666666,0,0,6,8,6,11.166666666666666,0,15.5,2.8,-4.06,2 +Student_03773,1,1,9238,1,4,1,1,1,38,9,7,127.0,120.4,1,0,0,1,0,1,0,19,0,6,6,6,13.5,0,0,6,7,6,13.428571428571429,0,11.1,0.6,2.02,2 +Student_03775,1,1,9238,1,1,1,1,1,19,4,7,117.0,113.5,1,0,0,1,0,1,0,18,0,6,6,6,13.166666666666666,0,0,6,7,6,14.142857142857142,0,11.1,0.6,2.02,2 +Student_03776,1,1,9085,1,1,1,1,37,37,4,9,150.0,132.1,1,0,1,1,0,0,0,29,4,5,11,4,12.5,2,1,5,11,2,12.5,0,12.7,3.7,-1.7,0 +Student_03779,1,44,9085,1,1,39,1,1,1,4,4,160.0,160.0,1,0,0,1,0,0,0,23,1,6,12,4,13.4,0,1,6,17,2,13.5,0,12.4,0.5,1.79,1 +Student_03781,1,18,9500,1,1,1,1,3,3,1,1,135.0,125.8,1,0,0,1,0,0,0,18,0,8,8,7,13.154285714285717,0,0,8,8,7,13.154285714285717,0,10.8,1.4,1.74,2 +Student_03788,1,1,9238,1,1,1,1,38,38,9,8,116.0,108.7,1,0,0,1,1,0,0,18,0,6,9,5,11.0,0,0,6,12,0,0.0,0,11.1,0.6,2.02,0 +Student_03791,1,1,9500,1,2,1,1,19,19,4,7,134.0,131.0,1,0,0,1,1,0,0,18,0,7,9,7,14.594444444444443,0,0,8,10,8,13.472,0,15.5,2.8,-4.06,2 +Student_03800,2,39,9085,1,1,12,1,1,39,5,3,133.1,140.0,1,0,1,0,0,0,0,32,0,6,7,0,0.0,0,0,6,6,0,0.0,0,13.9,-0.3,0.79,0 +Student_03820,1,39,9254,1,1,1,1,3,19,3,5,100.0,115.0,0,0,0,0,1,0,0,24,0,6,0,0,0.0,0,0,6,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03821,1,44,9003,1,1,39,1,4,4,4,2,140.0,120.0,1,0,0,1,1,0,0,22,0,6,13,5,13.0,0,0,6,13,2,11.5,0,12.4,0.5,1.79,1 +Student_03823,1,17,9773,1,6,1,1,37,37,5,5,141.0,127.7,1,0,0,1,1,0,0,18,0,6,6,6,15.166666666666666,0,0,6,6,6,14.833333333333334,0,9.4,-0.8,-3.12,2 +Student_03827,1,39,9254,1,1,19,1,37,37,9,4,133.1,100.0,0,0,0,1,1,0,0,27,0,6,11,3,11.333333333333334,0,0,6,10,3,14.75,0,16.2,0.3,-0.92,0 +Student_03828,1,44,9003,1,1,39,1,37,37,9,6,140.0,140.0,1,0,0,1,1,1,0,20,0,6,10,5,12.6,0,0,6,6,5,13.2,0,12.4,0.5,1.79,2 +Student_03829,1,1,9119,1,1,1,1,12,1,4,10,129.0,124.1,1,0,0,1,1,0,0,NA,0,5,10,0,0.0,0,0,5,10,1,14.0,3,7.6,2.6,0.32,0 +Student_03830,1,1,9085,1,1,1,1,38,38,4,9,148.0,131.6,0,0,0,1,1,1,0,18,0,6,8,6,15.5,0,0,6,9,4,15.5,0,11.1,0.6,2.02,0 +Student_03846,1,39,9085,1,1,12,1,34,34,99,99,133.1,128.2,0,0,1,0,1,0,0,27,0,5,5,0,0.0,0,0,5,5,0,0.0,0,7.6,2.6,NA,0 +Student_03855,1,39,9238,1,1,1,1,37,29,0,4,133.1,120.5,0,0,0,0,1,0,0,32,0,6,10,2,11.0,0,0,6,12,0,0.0,0,7.6,2.6,0.32,0 +Student_03857,1,39,9254,1,1,1,1,37,37,9,9,150.0,115.0,0,0,0,1,1,0,0,36,0,6,8,6,13.571428571428571,0,0,6,9,5,13.2,0,12.7,3.7,-1.7,2 +Student_03859,1,1,9670,1,1,1,1,38,19,0,2,116.0,116.7,1,0,0,1,1,0,0,21,0,5,8,0,0.0,0,0,5,5,0,0.0,0,9.4,-0.8,-3.12,0 +Student_03860,1,43,9991,0,1,1,1,37,19,3,10,133.1,136.1,0,0,0,1,1,1,0,42,0,5,14,1,10.0,0,0,5,14,1,11.0,0,13.9,-0.3,0.79,0 +Student_03864,1,1,9238,1,2,1,1,38,19,9,7,124.0,129.6,1,0,0,1,1,0,0,19,0,6,10,6,11.125,0,0,6,7,6,11.857142857142858,0,7.6,2.6,0.32,2 +Student_03878,1,18,9500,1,2,1,24,1,1,4,3,141.0,126.8,1,0,0,1,0,1,1,20,0,8,8,8,14.2,0,0,8,8,8,14.2,0,9.4,-0.8,-3.12,2 +Student_03882,1,1,9254,1,2,1,1,1,19,5,7,111.0,109.3,1,0,0,1,0,1,0,20,0,6,6,6,13.833333333333334,0,0,6,6,6,15.0,0,11.1,0.6,2.02,2 +Student_03886,1,18,9238,1,1,1,1,38,38,9,7,122.0,114.7,0,0,1,1,0,1,0,18,0,6,9,6,10.833333333333334,0,0,6,8,6,12.0,0,11.1,0.6,2.02,2 +Student_03887,1,1,9254,1,1,1,1,19,19,7,8,128.0,120.0,1,0,0,1,0,1,0,20,0,6,6,6,14.5,0,0,6,7,5,15.0,0,12.4,0.5,1.79,1 +Student_03888,1,1,9238,1,1,1,1,19,38,9,9,108.0,107.3,0,1,0,1,0,1,0,19,0,6,12,4,10.4,0,0,6,11,4,10.75,0,12.4,0.5,1.79,1 +Student_03895,1,1,9500,1,6,1,41,1,1,9,6,120.0,114.8,1,0,0,1,0,0,1,21,0,7,11,4,13.25,0,0,7,9,5,13.82,0,11.1,0.6,2.02,1 +Student_03898,1,17,9500,1,1,1,1,38,1,9,6,134.0,133.5,1,0,0,1,1,1,0,20,0,7,8,7,11.9725,0,0,8,8,8,12.65125,0,15.5,2.8,-4.06,2 +Student_03902,1,17,9254,1,3,1,1,37,37,9,6,127.0,123.5,1,0,0,1,0,1,0,20,0,6,11,4,11.5,0,0,6,12,3,11.0,0,7.6,2.6,0.32,1 +Student_03907,1,1,9500,1,2,1,1,37,37,9,9,124.0,116.0,1,0,0,1,0,1,0,21,0,8,8,7,13.957142857142856,0,0,8,8,7,13.957142857142856,0,12.7,3.7,-1.7,2 +Student_03909,2,39,9238,1,1,1,1,38,38,9,7,126.6,107.5,0,0,1,1,0,1,0,42,0,6,8,6,13.333333333333334,0,0,6,7,6,15.285714285714286,0,11.1,0.6,2.02,2 +Student_03914,1,1,9670,1,2,1,1,26,30,0,5,130.0,128.6,1,0,1,1,0,0,0,19,0,5,8,4,12.25,0,0,5,7,4,12.75,2,7.6,2.6,NA,2 +Student_03918,1,1,9853,1,1,1,1,19,12,9,7,135.0,137.1,1,0,0,1,0,0,0,18,0,6,6,6,13.333333333333334,0,0,6,7,6,12.333333333333334,0,7.6,2.6,0.32,2 +Student_03933,1,7,9991,0,1,40,1,19,19,7,3,130.0,130.0,0,0,0,1,0,0,0,26,5,10,13,8,12.666666666666666,0,5,10,12,10,13.4,0,11.1,0.6,2.02,2 +Student_03934,1,1,9147,1,1,1,1,19,19,9,9,126.0,115.2,0,0,1,1,0,0,0,19,0,5,13,1,10.0,0,0,5,8,2,10.0,0,12.4,0.5,1.79,1 +Student_03936,1,1,9254,1,1,1,1,38,37,5,5,123.0,125.1,0,0,0,1,0,0,0,19,0,6,12,4,11.0,0,0,6,6,4,12.5,0,16.2,0.3,-0.92,1 +Student_03937,1,1,9130,1,1,1,1,37,37,9,9,106.0,108.0,1,0,1,1,0,0,0,20,0,5,10,2,12.0,2,0,5,9,4,11.0,0,9.4,-0.8,-3.12,0 +Student_03941,2,39,9147,1,1,1,1,37,37,5,5,120.0,124.6,0,0,0,1,0,0,0,36,0,5,8,3,11.0,0,0,5,12,4,13.375,0,10.8,1.4,1.74,1 +Student_03944,5,39,9147,1,1,1,1,NA,1,4,8,180.0,140.5,0,0,1,0,0,0,0,24,0,5,0,0,0.0,0,0,5,0,0,0.0,0,13.9,-0.3,0.79,0 +Student_03945,5,39,9003,1,1,1,1,1,1,4,8,180.0,179.6,0,0,1,0,0,0,0,27,0,6,6,0,0.0,0,0,6,7,0,0.0,0,8.9,1.4,3.51,0 +Student_03950,1,43,9147,1,1,1,1,1,19,9,10,153.0,147.8,0,0,0,1,0,1,0,18,0,5,9,5,13.2,0,0,5,13,5,14.4,5,16.2,0.3,-0.92,2 +Student_03956,1,39,9500,1,1,19,1,1,19,4,10,133.1,111.8,1,0,0,1,0,0,0,27,0,7,0,0,0.0,0,0,8,0,0,0.0,0,11.1,0.6,2.02,0 +Student_03962,1,42,9500,1,1,1,1,37,1,9,4,168.0,133.4,1,0,0,1,0,0,0,23,20,26,27,26,15.07777777777778,0,14,17,17,17,15.023529411764704,0,15.5,2.8,-4.06,2 +Student_03964,1,1,171,1,1,1,1,19,38,5,5,133.1,131.8,1,0,1,1,0,0,0,20,6,12,12,12,13.25,0,4,11,16,10,13.090909090909092,0,8.9,1.4,3.51,2 +Student_03967,1,44,9003,1,1,39,1,19,19,9,4,140.0,140.0,0,0,0,1,0,0,0,21,0,6,12,3,10.666666666666666,2,0,6,12,4,12.0,0,15.5,2.8,NA,0 +Student_03973,1,39,9991,0,1,1,1,37,37,9,9,120.0,111.1,0,0,0,1,0,0,0,31,0,5,8,4,11.0,0,0,5,6,5,11.2,0,7.6,2.6,0.32,2 +Student_03977,1,1,9500,1,4,1,NA,19,19,9,7,130.0,119.9,1,0,0,1,0,0,0,18,0,7,7,7,13.78,0,0,8,8,8,12.6125,0,12.4,0.5,1.79,2 +Student_03980,4,39,9773,1,1,38,1,19,19,7,9,133.1,133.0,0,0,0,1,0,0,0,40,0,6,8,5,13.0,0,0,6,7,5,12.6,0,16.2,0.3,-0.92,1 +Student_03982,1,1,9085,1,2,NA,1,40,4,2,2,151.0,144.5,1,0,0,1,0,0,0,18,0,6,7,6,15.666666666666666,0,0,6,6,6,14.833333333333334,0,8.9,1.4,3.51,2 +Student_03984,1,17,9238,1,1,1,1,38,38,9,7,145.0,145.0,0,0,0,1,0,1,0,19,0,6,7,6,12.833333333333334,0,0,6,6,6,13.166666666666666,0,12.4,0.5,1.79,2 +Student_03986,1,17,9070,1,1,1,1,37,38,9,8,119.0,124.6,1,0,0,1,0,0,0,20,0,6,6,6,12.5,0,0,6,6,6,12.666666666666666,0,7.6,2.6,0.32,2 +Student_03997,1,1,9853,1,1,1,1,1,1,9,9,128.0,120.0,1,0,0,1,0,0,0,18,0,6,11,3,12.0,0,0,6,13,2,12.0,0,12.7,3.7,-1.7,0 +Student_04000,1,17,9500,1,6,1,1,1,38,4,8,147.0,141.1,1,0,0,1,0,0,0,NA,0,7,9,6,13.0,0,0,8,8,8,14.2125,0,13.9,-0.3,0.79,0 +Student_04006,2,39,9085,1,1,1,1,37,37,90,10,150.0,112.0,0,0,0,1,1,0,0,34,0,6,0,0,0.0,0,0,6,0,0,0.0,0,10.8,1.4,1.74,0 +Student_04011,1,39,9556,1,1,19,1,37,37,9,10,133.1,100.0,0,0,0,1,1,0,0,31,0,7,7,0,0.0,0,0,7,7,0,0.0,0,15.5,2.8,-4.06,0 +Student_04016,4,39,9991,0,1,1,1,37,37,5,5,133.1,138.7,0,0,0,1,0,0,0,31,0,5,7,3,10.333333333333334,0,0,5,6,3,NA,0,10.8,1.4,1.74,0 +Student_04017,1,17,9254,1,1,1,1,19,1,9,4,134.0,124.9,1,0,0,1,0,0,0,19,0,6,11,3,12.0,0,0,6,11,4,11.25,0,7.6,2.6,0.32,0 +Student_04022,1,1,8014,0,1,1,1,3,1,1,7,133.1,100.0,0,0,0,1,0,0,0,26,2,8,11,7,12.75,0,2,7,7,7,12.285714285714286,0,16.2,0.3,NA,2 +Student_04029,1,1,9070,1,1,1,1,1,38,4,5,136.0,132.2,0,0,1,1,0,0,0,19,0,6,6,6,13.833333333333334,0,0,6,8,6,13.875,0,10.8,1.4,NA,2 +Student_04037,1,39,9670,1,1,1,1,1,19,4,10,120.0,142.3,1,0,0,1,0,1,0,26,0,6,6,6,13.333333333333334,0,0,6,10,5,14.5,0,10.8,1.4,1.74,2 +Student_04049,1,1,9500,1,1,1,1,38,37,9,7,132.0,122.0,1,0,0,1,0,1,0,20,0,8,8,7,13.817142857142857,0,0,8,8,7,13.817142857142857,0,10.8,1.4,1.74,2 +Student_04055,1,1,9773,1,2,1,1,37,37,5,5,135.0,126.3,1,1,0,1,0,1,0,20,0,6,6,6,14.666666666666666,0,0,6,7,6,14.571428571428571,0,8.9,1.4,3.51,2 +Student_04058,1,42,9003,1,1,39,1,19,1,5,5,140.0,140.0,0,0,0,1,0,0,0,22,0,6,10,6,12.571428571428571,0,0,6,12,4,13.666666666666666,0,15.5,2.8,-4.06,1 +Student_04059,1,1,9085,1,1,1,1,1,3,9,1,138.0,123.0,1,0,0,1,0,0,0,19,1,6,14,6,15.538461538461538,0,0,6,9,6,12.625,0,15.5,2.8,-4.06,2 +Student_04064,1,39,9991,0,1,1,1,1,37,9,7,150.0,130.2,0,0,0,1,0,1,0,24,0,5,7,5,12.285714285714286,0,0,5,9,5,12.75,1,16.2,0.3,-0.92,2 +Student_04067,1,1,9556,1,1,1,1,19,38,9,9,118.0,116.3,1,0,0,1,0,1,0,20,0,7,10,7,11.88888888888889,0,0,8,10,8,11.95625,0,12.7,3.7,-1.7,2 +Student_04070,1,17,9238,1,2,1,1,2,3,3,3,139.0,132.7,1,0,0,1,0,0,0,19,0,6,7,6,11.166666666666666,0,0,6,9,6,11.666666666666666,0,9.4,-0.8,-3.12,2 +Student_04071,1,18,9500,1,1,1,1,3,3,3,3,136.0,130.8,0,0,0,1,0,0,0,18,0,7,7,7,14.05714285714286,0,0,8,9,8,14.6,0,16.2,0.3,-0.92,2 +Student_04076,1,17,9085,1,3,1,1,19,38,5,7,117.0,111.1,0,0,0,1,0,0,0,21,0,6,0,0,0.0,0,0,6,0,0,0.0,0,15.5,2.8,-4.06,0 +Student_04080,1,1,9670,1,2,1,1,37,37,9,7,143.0,131.8,1,0,0,1,0,1,0,18,0,6,8,6,13.571428571428571,0,0,6,6,5,12.8,0,12.4,0.5,1.79,1 +Student_04084,1,7,9991,0,1,3,1,3,19,2,3,130.0,133.9,0,0,0,1,0,0,0,28,0,5,7,5,13.714285714285714,0,0,5,7,5,13.142857142857142,0,16.2,0.3,-0.92,2 +Student_04088,1,39,9500,1,1,1,1,38,37,5,7,130.0,120.0,1,0,0,1,0,1,0,25,0,8,11,7,13.29,3,0,8,11,7,13.29,3,9.4,-0.8,-3.12,1 +Student_04094,1,1,9773,1,1,1,1,37,38,7,7,126.0,119.0,0,0,0,1,0,1,0,18,0,6,6,6,12.166666666666666,0,0,6,7,6,12.142857142857142,0,15.5,2.8,-4.06,2 +Student_04095,2,7,9238,1,1,3,1,37,19,4,5,130.0,130.0,0,0,0,1,0,0,0,38,0,6,17,4,13.75,0,0,6,15,6,14.5,0,16.2,0.3,-0.92,2 +Student_04099,1,17,9556,1,2,1,1,37,37,5,5,120.0,111.3,1,0,0,1,0,0,0,32,0,7,7,0,0.0,0,0,8,8,0,0.0,0,16.2,0.3,-0.92,0 +Student_04102,1,1,9070,1,5,1,1,37,37,9,9,124.0,113.9,1,0,0,1,0,0,0,20,0,6,6,6,11.166666666666666,0,0,6,6,6,12.166666666666666,0,7.6,2.6,0.32,2 +Student_04103,1,17,9085,1,1,1,1,37,37,9,9,133.1,99.0,1,0,0,1,0,1,0,23,0,6,6,6,14.666666666666666,0,0,6,8,6,12.428571428571429,0,8.9,1.4,3.51,2 +Student_04106,1,1,9147,1,1,1,1,38,19,9,9,131.0,130.0,1,0,0,1,1,0,0,19,0,5,5,5,12.8,0,0,5,10,5,11.444444444444445,0,10.8,1.4,1.74,2 +Student_04108,1,1,9500,1,6,1,1,37,19,9,7,129.0,127.8,1,0,0,1,0,0,0,19,0,8,10,6,13.78,1,0,8,10,6,13.78,1,9.4,-0.8,-3.12,0 +Student_04118,1,1,9500,1,1,1,1,1,37,9,9,146.0,129.3,0,0,0,1,0,0,0,18,0,8,8,7,14.2,0,0,8,8,7,14.2,0,12.7,3.7,-1.7,2 +Student_04120,1,17,9853,1,1,1,1,NA,38,4,10,160.0,144.3,1,0,0,1,0,0,0,18,0,6,10,4,13.0,0,0,6,9,5,13.666666666666666,0,9.4,-0.8,-3.12,2 +Student_04122,1,7,9085,1,1,40,1,1,1,4,4,130.0,130.0,1,0,0,1,0,0,0,22,0,6,7,6,17.0,0,0,6,7,6,16.285714285714285,0,11.1,0.6,2.02,2 +Student_04123,1,17,9238,1,3,1,1,19,19,7,7,122.0,117.5,1,0,0,1,0,0,0,19,0,6,7,5,10.8,0,0,6,9,6,10.166666666666666,0,8.9,1.4,3.51,2 +Student_04126,1,43,9500,1,1,1,1,38,19,5,5,121.0,115.4,1,0,0,1,0,1,0,24,0,8,8,7,11.971428571428572,0,0,8,8,7,11.971428571428572,0,12.7,3.7,-1.7,1 +Student_04129,1,17,9085,1,5,1,1,38,38,9,9,118.0,112.4,1,0,0,1,0,0,0,19,0,12,22,6,15.307692307692308,0,0,10,13,6,13.875,0,15.5,2.8,-4.06,2 +Student_04132,1,39,9500,1,1,1,1,19,1,1,1,123.0,140.8,0,0,0,1,0,0,0,25,0,8,8,7,12.084285714285716,0,0,8,8,7,12.084285714285716,0,10.8,1.4,1.74,2 +Student_04133,1,44,9085,1,1,39,1,3,38,2,9,140.0,140.0,1,0,0,1,0,0,0,21,7,12,18,8,12.25,0,4,12,27,8,12.2,0,12.4,0.5,1.79,1 +Student_04134,1,1,9254,1,1,1,1,37,37,7,7,118.0,114.2,0,0,0,1,0,0,0,18,0,6,10,5,12.2,0,0,6,10,5,11.6,0,16.2,0.3,-0.92,1 +Student_04139,1,17,9853,1,2,1,1,37,37,5,0,133.1,111.5,0,0,0,1,0,0,0,18,0,6,11,3,12.333333333333334,0,0,6,11,4,13.5,0,7.6,2.6,0.32,0 +Student_04142,1,7,9070,1,1,3,1,3,5,2,2,133.1,120.0,1,0,0,1,0,0,0,32,0,3,3,2,16.0,0,0,3,3,1,16.0,0,7.6,2.6,0.32,0 +Student_04162,1,17,9254,1,2,1,22,19,37,9,9,118.0,110.3,1,0,0,0,0,0,1,18,0,6,7,5,12.6,0,0,6,6,5,11.8,0,11.1,0.6,2.02,1 +Student_04181,1,17,9853,1,1,1,1,38,37,5,7,127.0,121.8,1,0,1,1,0,0,0,18,0,6,12,4,13.5,0,0,6,14,3,10.666666666666666,0,10.8,1.4,1.74,1 +Student_04189,1,1,9670,1,1,1,1,37,1,7,0,112.0,110.6,0,0,0,1,0,0,0,20,0,5,7,4,11.75,0,0,5,7,5,11.8,1,7.6,2.6,0.32,2 +Student_04191,1,43,9991,0,1,39,1,37,37,9,9,160.0,160.0,0,0,0,1,0,0,0,24,3,10,16,3,11.666666666666666,0,3,10,24,6,11.833333333333334,0,9.4,-0.8,-3.12,0 +Student_04205,1,1,9238,1,1,1,1,34,38,0,7,123.0,120.2,1,0,0,1,0,0,0,20,0,6,9,5,11.8,0,0,6,10,4,11.5,0,7.6,2.6,0.32,0 +Student_04217,1,1,9773,1,6,1,1,1,37,3,3,133.1,100.0,1,0,1,0,0,0,0,20,0,4,4,0,0.0,0,0,5,5,0,0.0,0,12.4,0.5,1.79,0 +Student_04218,1,1,9773,1,2,1,1,1,2,9,3,132.0,128.2,1,0,0,1,0,1,0,19,0,6,7,6,12.333333333333334,0,0,6,6,6,13.5,0,9.4,-0.8,-3.12,2 +Student_04228,1,1,9238,1,6,1,1,38,1,7,4,125.0,118.4,1,0,0,1,0,1,0,19,0,6,6,6,13.5,0,0,6,7,6,13.285714285714286,0,11.1,0.6,2.02,2 +Student_04229,2,39,8014,0,1,1,1,37,37,5,4,133.1,134.5,0,0,0,1,0,0,0,45,0,6,8,5,13.6,0,0,6,7,5,13.0,0,15.5,2.8,-4.06,1 +Student_04233,1,43,9670,1,1,1,1,1,38,4,4,134.0,120.7,0,0,1,0,0,0,0,19,0,6,13,3,10.666666666666666,0,0,6,6,4,12.25,0,NA,2.8,-4.06,0 +Student_04235,1,1,9147,1,2,1,1,38,38,9,5,113.0,107.4,1,0,0,1,1,0,0,20,0,5,12,3,10.5,0,0,5,10,4,11.25,0,12.4,0.5,1.79,1 +Student_04240,1,39,9085,1,1,NA,1,3,2,3,2,130.0,160.0,1,0,0,1,0,0,0,27,0,6,7,6,16.142857142857142,0,0,6,7,6,14.666666666666666,0,13.9,-0.3,0.79,2 +Student_04241,1,51,9085,1,1,1,1,1,1,9,4,125.0,120.0,0,0,0,1,0,0,0,22,0,6,8,6,14.833333333333334,0,0,6,10,5,13.833333333333334,0,11.1,0.6,2.02,2 +Student_04251,4,39,9500,1,1,19,1,37,37,5,7,133.1,100.0,0,0,0,0,0,0,0,40,0,8,11,5,11.832,4,0,8,11,5,11.832,4,9.4,-0.8,-3.12,0 +Student_04252,1,1,9147,1,1,1,1,9,22,4,3,112.0,106.1,0,0,0,1,0,0,0,20,0,5,13,2,10.0,1,0,5,10,0,0.0,0,9.4,-0.8,-3.12,0 +Student_04253,2,1,9991,0,1,1,1,19,19,9,9,144.0,151.4,0,0,0,1,0,0,0,28,0,5,5,5,12.0,0,0,5,6,5,11.6,0,7.6,2.6,0.32,2 +Student_04257,1,39,9500,1,1,1,1,1,19,4,8,100.0,122.0,0,0,0,1,0,0,0,24,0,8,8,7,12.412857142857144,0,0,8,8,7,12.412857142857144,0,10.8,1.4,1.74,2 +Student_04258,1,17,9670,1,5,1,1,1,19,5,5,115.0,117.1,0,0,0,1,0,0,0,21,0,5,7,3,12.666666666666666,0,0,5,6,4,12.75,1,7.6,2.6,0.32,1 +Student_04261,1,39,9003,1,1,1,1,37,37,9,9,123.0,110.0,0,0,1,0,0,0,0,48,0,6,6,0,0.0,0,0,6,6,0,0.0,0,11.1,0.6,2.02,0 +Student_04265,1,44,9003,1,1,39,1,37,19,9,9,150.0,150.0,0,0,0,1,1,1,0,24,0,6,9,6,13.555555555555555,0,0,6,7,6,12.666666666666666,0,13.9,-0.3,0.79,2 +Student_04266,1,17,9773,1,5,1,1,1,19,9,5,134.0,121.8,1,0,0,1,1,0,0,19,0,6,6,6,13.166666666666666,0,0,6,8,6,12.428571428571429,0,16.2,0.3,-0.92,2 +Student_04268,1,1,9254,1,1,1,1,1,1,5,5,117.0,116.3,1,0,0,1,1,1,0,21,0,6,6,6,11.666666666666666,0,0,6,7,5,12.2,0,10.8,1.4,1.74,2 +Student_04271,1,17,9070,1,1,1,1,37,38,9,7,132.0,NA,0,0,0,1,1,1,0,18,0,6,6,6,13.666666666666666,0,0,6,6,6,12.0,0,12.4,0.5,1.79,2 +Student_04284,1,39,9147,1,1,19,1,38,19,7,9,100.0,132.0,0,0,1,0,1,0,0,28,0,5,7,1,11.0,0,0,5,9,0,0.0,0,10.8,1.4,1.74,0 +Student_04287,1,1,9085,1,1,1,1,37,19,9,9,134.0,136.8,1,0,0,1,1,0,0,20,0,5,8,5,12.8,0,0,5,9,4,13.666666666666666,1,10.8,1.4,1.74,2 +Student_04290,1,1,9238,1,1,1,1,19,1,7,3,141.0,128.8,1,0,0,1,1,0,0,18,0,6,10,5,11.6,0,0,6,6,6,11.166666666666666,0,10.8,1.4,1.74,2 +Student_04291,1,1,171,1,1,1,1,1,12,4,4,147.0,148.4,1,0,0,1,1,1,0,20,8,14,15,12,10.923076923076923,0,7,13,14,11,12.181818181818182,0,11.1,0.6,2.02,2 +Student_04293,2,39,9500,1,1,3,1,1,1,4,6,130.0,126.0,0,0,0,1,1,0,0,32,0,7,7,7,13.62857142857143,0,0,8,8,8,13.9125,0,13.9,-0.3,0.79,2 +Student_04297,1,44,9070,1,1,39,1,1,38,5,5,120.0,116.3,1,1,0,1,1,1,0,21,2,7,7,4,11.5,0,5,9,10,7,12.142857142857142,0,12.4,0.5,1.79,2 +Student_04301,1,44,9003,1,1,39,1,1,37,6,6,130.0,130.0,1,0,0,1,1,0,0,20,0,6,14,5,11.714285714285714,0,0,6,15,5,12.0,0,16.2,0.3,-0.92,2 +Student_04303,1,17,9147,1,6,1,1,37,37,9,9,130.0,110.4,1,0,0,1,1,0,0,25,13,15,15,13,10.76923076923077,0,11,14,15,12,11.833333333333334,0,7.6,2.6,0.32,0 +Student_04304,1,17,9773,1,4,1,1,1,1,4,5,147.0,139.7,1,0,0,1,1,0,0,18,0,6,10,5,11.6,0,0,6,6,6,12.0,0,9.4,-0.8,-3.12,0 +Student_04308,1,39,171,1,1,1,1,34,34,0,0,116.0,127.0,1,0,0,1,1,0,0,38,0,0,0,0,0.0,0,0,0,0,0,0.0,0,7.6,2.6,0.32,0 +Student_04310,1,1,9773,1,4,1,1,1,19,9,9,133.0,119.7,1,0,0,1,1,0,0,19,0,6,7,6,12.333333333333334,0,0,6,10,5,13.2,0,16.2,0.3,-0.92,2 +Student_04316,1,1,9254,1,1,1,1,1,3,4,1,125.0,121.9,1,0,0,1,1,0,0,18,0,6,15,3,11.666666666666666,0,0,6,14,2,12.5,0,10.8,1.4,1.74,0 +Student_04318,1,17,9670,1,1,1,1,1,19,4,8,118.0,118.7,0,0,0,1,1,1,0,19,0,6,7,6,12.0,0,0,6,6,6,14.0,0,12.4,0.5,1.79,2 +Student_04320,1,17,9773,1,1,1,1,19,38,9,9,136.0,121.7,1,0,0,1,1,1,0,19,0,6,9,5,12.4,0,0,6,6,6,13.166666666666666,0,12.7,3.7,-1.7,2 +Student_04323,1,1,9773,1,1,NA,17,1,1,3,5,124.0,118.1,1,0,1,0,0,0,1,19,0,6,8,5,12.2,0,0,6,6,4,11.75,0,16.2,0.3,-0.92,0 +Student_04331,1,1,9238,1,4,1,1,1,37,8,9,133.1,118.0,1,0,0,1,0,0,0,19,0,6,0,0,0.0,0,0,6,0,0,0.0,0,12.7,3.7,-1.7,0 +Student_04337,1,1,9773,1,2,1,1,37,37,9,7,129.0,117.1,1,0,0,1,0,0,0,20,0,6,12,1,17.0,0,0,6,12,1,17.0,0,9.4,-0.8,-3.12,1 +Student_04345,1,17,NA,1,5,1,1,38,37,9,9,134.0,126.0,0,0,1,0,0,0,0,21,0,6,10,5,11.833333333333334,0,0,6,10,5,13.2,0,13.9,-0.3,0.79,0 +Student_04346,1,1,9773,1,1,1,1,1,19,5,10,140.0,141.1,1,0,0,1,0,0,0,18,0,6,6,6,12.833333333333334,0,0,6,6,6,13.333333333333334,0,9.4,-0.8,-3.12,2 +Student_04347,1,17,9254,1,2,1,1,12,19,5,5,107.0,102.8,1,0,0,1,0,0,0,20,0,6,16,1,10.0,0,0,6,12,0,0.0,0,10.8,1.4,1.74,0 +Student_04348,1,17,9147,1,5,1,1,1,1,4,4,133.0,129.2,1,0,0,1,0,0,0,19,0,5,9,2,11.0,0,0,5,12,2,10.0,0,7.6,2.6,0.32,0 +Student_04349,1,1,9500,1,1,1,1,3,1,2,9,127.0,119.3,1,0,0,1,0,0,0,20,0,7,7,7,14.105714285714289,0,0,8,8,8,13.6625,0,11.1,0.6,2.02,2 +Student_04350,1,1,9500,1,5,1,1,38,19,9,6,141.0,126.3,1,0,0,1,0,0,0,20,0,8,12,7,12.471428571428572,0,0,8,12,7,12.471428571428572,0,NA,3.7,-1.7,2 +Student_04351,1,44,9085,1,1,39,1,NA,1,4,3,140.0,140.0,1,0,0,1,0,1,0,20,2,6,11,6,11.833333333333334,0,1,6,17,5,11.857142857142858,0,12.4,0.5,1.79,2 +Student_04352,1,1,9070,1,3,1,1,1,1,4,8,150.0,NA,1,0,0,1,0,0,0,20,0,6,6,6,12.5,0,0,6,6,6,12.833333333333334,0,7.6,2.6,0.32,2 +Student_04361,1,17,9500,1,4,1,1,19,37,4,8,140.0,133.3,1,0,0,1,0,0,0,19,0,7,7,6,11.966666666666669,0,0,7,7,6,11.966666666666669,0,7.6,2.6,0.32,2 +Student_04363,1,1,9085,1,3,1,1,1,38,9,90,133.0,128.2,0,0,0,1,0,0,0,21,0,5,7,5,12.0,0,0,5,7,4,12.5,0,7.6,2.6,0.32,2 +Student_04365,1,17,9238,1,1,1,1,37,37,9,9,132.0,123.6,1,0,0,1,0,0,0,18,0,6,9,4,11.5,0,0,6,10,4,NA,0,7.6,2.6,0.32,1 +Student_04372,1,1,9500,1,6,1,1,38,19,3,3,118.0,113.5,1,0,0,1,1,0,0,18,0,7,7,7,13.175714285714289,0,0,8,8,8,14.925,0,12.4,0.5,1.79,2 +Student_04373,1,39,9003,1,1,1,1,12,12,9,9,130.0,126.1,0,0,0,1,1,0,0,24,0,6,7,0,0.0,0,0,6,10,0,0.0,0,12.4,0.5,1.79,0 +Student_04377,1,17,9500,1,6,1,1,38,1,9,10,143.0,127.3,1,0,0,1,0,0,0,18,0,7,8,7,12.217142857142855,0,0,8,11,7,12.11875,0,11.1,0.6,2.02,2 +Student_04378,2,43,9991,0,1,1,1,37,37,9,9,130.0,103.8,0,0,0,1,0,0,0,28,14,15,15,14,11.071428571428571,0,12,14,16,12,11.333333333333334,1,9.4,-0.8,-3.12,0 +Student_04379,2,39,9853,1,1,19,1,37,37,9,9,133.1,131.0,0,0,0,1,0,1,0,32,0,7,10,7,13.428571428571429,0,2,8,8,8,13.25,0,13.9,-0.3,0.79,2 +Student_04385,2,1,9238,1,1,1,1,37,34,9,7,145.0,139.4,0,0,0,0,0,0,0,27,0,6,12,2,11.0,0,0,6,14,4,10.5,0,9.4,-0.8,-3.12,0 +Student_04422,1,1,9500,1,1,1,1,37,37,9,9,154.0,149.5,1,0,0,1,0,1,0,30,0,7,8,7,14.9125,0,0,8,9,1,13.5,0,13.9,-0.3,0.79,0 diff --git a/data/UCIRepRegression/auto_mpg_rep.csv b/data/UCIRepRegression/auto_mpg_rep.csv new file mode 100644 index 00000000..b702585f --- /dev/null +++ b/data/UCIRepRegression/auto_mpg_rep.csv @@ -0,0 +1,81 @@ +InstanceID,Cylinders,Displacement,Horsepower,Weight,Acceleration,ModelYear,Origin,MPG +AutoMPG_0005,8,302,140,3449,10.5,70,1,17 +AutoMPG_0007,8,454,220,4354,9,70,1,14 +AutoMPG_0012,8,340,160,3609,8,70,1,14 +AutoMPG_0025,6,199,90,2648,15,70,1,21 +AutoMPG_0027,8,307,200,4376,15,70,1,10 +AutoMPG_0030,4,97,88,2130,14.5,71,3,27 +AutoMPG_0033,4,98,NA,2046,19,71,1,25 +AutoMPG_0034,6,232,100,2634,13,71,1,19 +AutoMPG_0036,6,250,100,3329,15.5,71,1,17 +AutoMPG_0037,6,250,88,3302,15.5,71,1,19 +AutoMPG_0039,8,350,165,4209,12,71,1,14 +AutoMPG_0042,8,318,150,4096,13,71,1,14 +AutoMPG_0054,4,71,65,1773,19,71,3,31 +AutoMPG_0057,4,91,70,1955,20.5,71,1,26 +AutoMPG_0067,8,304,150,3672,11.5,72,1,17 +AutoMPG_0070,8,350,160,4456,13.5,72,1,12 +AutoMPG_0083,4,120,97,2506,14.5,72,3,23 +AutoMPG_0086,8,350,175,4100,13,73,1,13 +AutoMPG_0089,8,302,137,4042,14.5,73,1,14 +AutoMPG_0093,8,351,158,4363,13,73,1,13 +AutoMPG_0102,6,198,95,2904,16,73,1,23 +AutoMPG_0103,4,97,46,1950,21,73,2,26 +AutoMPG_0105,8,400,167,4906,12.5,73,1,12 +AutoMPG_0106,8,360,170,4654,13,73,1,13 +AutoMPG_0138,8,350,150,4699,14.5,74,1,13 +AutoMPG_0144,4,97,78,2300,14.5,74,2,26 +AutoMPG_0145,4,76,52,1649,16.5,74,3,31 +AutoMPG_0151,4,108,93,2391,15.5,74,3,26 +AutoMPG_0159,8,318,150,4498,14.5,75,1,16 +AutoMPG_0167,8,302,129,3169,12,75,1,13 +AutoMPG_0170,6,232,100,2914,16,75,1,20 +AutoMPG_0178,4,115,95,2694,15,75,2,23 +AutoMPG_0184,4,116,81,2220,16.9,76,2,25 +AutoMPG_0189,8,318,150,4190,13,76,1,16 +AutoMPG_0190,8,304,120,3962,13.9,76,1,15.5 +AutoMPG_0209,8,318,150,3940,13.2,76,1,13 +AutoMPG_0214,8,350,145,4055,12,76,1,13 +AutoMPG_0218,4,111,80,2155,14.8,77,1,30 +AutoMPG_0223,8,260,110,4060,19,77,1,17 +AutoMPG_0234,4,97,78,1940,14.5,77,2,29 +AutoMPG_0240,4,97,67,1985,16.4,77,3,30 +AutoMPG_0244,3,80,110,2720,13.5,77,3,21.5 +AutoMPG_0247,4,78,52,1985,19.4,78,3,32.8 +AutoMPG_0252,8,302,139,3570,12.8,78,1,20.2 +AutoMPG_0257,6,225,100,3430,17.2,78,1,20.5 +AutoMPG_0261,6,225,110,3620,18.7,78,1,18.6 +AutoMPG_0263,8,305,145,3425,13.2,78,1,19.2 +AutoMPG_0264,6,231,165,3445,13.4,78,1,17.7 +AutoMPG_0266,8,318,140,4080,13.7,78,1,17.5 +AutoMPG_0275,5,131,103,2830,15.9,78,2,20.3 +AutoMPG_0282,6,200,85,2990,18.2,79,1,19.8 +AutoMPG_0293,8,360,150,3940,13,79,1,18.5 +AutoMPG_0295,4,86,65,1975,15.2,79,3,34.1 +AutoMPG_0300,4,141,71,3190,24.8,79,2,27.2 +AutoMPG_0301,8,260,90,3420,22.2,79,1,23.9 +AutoMPG_0305,4,91,69,2130,14.7,79,2,37.3 +AutoMPG_0310,4,98,76,2144,14.7,80,2,41.5 +AutoMPG_0313,4,86,65,2019,16.4,80,3,37.2 +AutoMPG_0316,4,151,90,3003,20.1,80,1,24.3 +AutoMPG_0319,4,134,90,2711,15.5,80,3,29.8 +AutoMPG_0321,4,119,92,2434,15,80,3,37 +AutoMPG_0323,4,86,65,2110,17.9,80,3,46.6 +AutoMPG_0325,4,85,65,2110,19.2,80,3,40.8 +AutoMPG_0328,5,121,67,2950,19.9,80,2,36.4 +AutoMPG_0329,4,146,67,3250,21.8,80,2,30 +AutoMPG_0331,4,85,NA,1835,17.3,80,2,40.9 +AutoMPG_0333,4,89,62,1845,15.3,80,2,29.8 +AutoMPG_0345,4,86,64,1875,16.4,81,1,39 +AutoMPG_0354,4,105,74,2190,14.2,81,2,33 +AutoMPG_0356,4,107,75,2210,14.4,81,3,33.7 +AutoMPG_0361,6,145,76,3160,19.6,81,2,30.7 +AutoMPG_0372,4,135,84,2525,16,82,1,29 +AutoMPG_0374,4,140,92,2865,16.4,82,1,24 +AutoMPG_0376,4,105,74,1980,15.3,82,2,36 +AutoMPG_0379,4,105,63,2125,14.7,82,1,38 +AutoMPG_0382,4,107,75,2205,14.5,82,3,36 +AutoMPG_0384,4,91,67,1965,15,82,3,38 +AutoMPG_0386,4,91,67,1995,16.2,82,3,38 +AutoMPG_0394,4,140,86,2790,15.6,82,1,27 +AutoMPG_0396,4,135,84,2295,11.6,82,1,32 diff --git a/data/UCI_DemoDatasets_README.md b/data/UCI_DemoDatasets_README.md new file mode 100644 index 00000000..dde124fa --- /dev/null +++ b/data/UCI_DemoDatasets_README.md @@ -0,0 +1,43 @@ +# UCI Demo Datasets for STREAMLINE + +These datasets are normalized from official UCI Machine Learning Repository sources into the same style used by the built-in demo data: one task-specific data folder with CSV files, plus optional feature-type CSVs. Each dataset is split deterministically with seed 42: the normal demo folder contains the 80% training split and the matching `UCIRep*` folder contains the held-out 20% replication split. Classification splits are stratified by `Class`; the regression split is random. + +## Selected datasets + +| STREAMLINE task | Local CSV | UCI source | Outcome | Notes | +| --- | --- | --- | --- | --- | +| Binary classification | `data/UCIBinaryClassification/hcc_survival.csv` and `_copy.csv` | HCC Survival | `Class` | 132 training rows and 33 held-out replication rows. The target is one-year survival, encoded as `0=dies` and `1=lives`. Missing `?` values are stored as `NA`. | +| Multiclass classification | `data/UCIMulticlassClassification/student_dropout_academic_success.csv` and `_copy.csv` | Predict Students' Dropout and Academic Success | `Class` | 3539 training rows and 885 held-out replication rows. The original labels are normalized as `0=Dropout`, `1=Enrolled`, and `2=Graduate`. UCI reports no missing values after preprocessing; this demo adds deterministic synthetic missingness with seed 42 to selected categorical and quantitative features and stores those cells as `NA`. | +| Regression | `data/UCIRegression/auto_mpg.csv` and `_copy.csv` | Auto MPG | `MPG` | 318 training rows and 80 held-out replication rows. Predicts miles per gallon from mixed vehicle attributes. The high-cardinality UCI `car_name` field is dropped from the modeling CSV. Missing horsepower values are stored as `NA`. | + +## Source URLs + +- HCC Survival: https://archive.ics.uci.edu/dataset/423/hcc+survival +- HCC Survival raw zip file: https://archive.ics.uci.edu/static/public/423/hcc+survival.zip +- Predict Students' Dropout and Academic Success: https://archive.ics.uci.edu/dataset/697/predict+students+dropout+and+academic+success +- Predict Students' Dropout and Academic Success raw zip file: https://archive.ics.uci.edu/static/public/697/predict+students+dropout+and+academic+success.zip +- Auto MPG: https://archive.ics.uci.edu/dataset/9/auto+mpg +- Auto MPG raw data file: https://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data + + +## Replication demo folders + +The following folders mirror the cleaned schemas above and contain held-out 20% replication splits for Phase 10 examples: + +- `data/UCIRepBinaryClassification/hcc_survival_rep.csv` +- `data/UCIRepMulticlassClassification/student_dropout_academic_success_rep.csv` +- `data/UCIRepRegression/auto_mpg_rep.csv` + +## Feature-type files + +The files in `data/UCIFeatureTypes/` are one-column CSVs with header `Feature`, which matches the Phase 1 CLI path-based `--categorical_features` and `--quantitative_features` loaders. + +## Example Phase 1 commands + +```bash +python -m streamline.p1_data_process.p1_cli --data_path data/UCIBinaryClassification --output_path out --experiment_name UCIHCCSurvival --outcome_label Class --outcome_type Binary --instance_label InstanceID --categorical_features data/UCIFeatureTypes/hcc_survival_categorical_features.csv --quantitative_features data/UCIFeatureTypes/hcc_survival_quantitative_features.csv + +python -m streamline.p1_data_process.p1_cli --data_path data/UCIMulticlassClassification --output_path out --experiment_name UCIStudentDropout --outcome_label Class --outcome_type Multiclass --instance_label InstanceID --categorical_features data/UCIFeatureTypes/student_dropout_categorical_features.csv --quantitative_features data/UCIFeatureTypes/student_dropout_quantitative_features.csv + +python -m streamline.p1_data_process.p1_cli --data_path data/UCIRegression --output_path out --experiment_name UCIAutoMPG --outcome_label MPG --outcome_type Continuous --instance_label InstanceID --categorical_features data/UCIFeatureTypes/auto_mpg_categorical_features.csv --quantitative_features data/UCIFeatureTypes/auto_mpg_quantitative_features.csv +``` diff --git a/docs/requirements.txt b/docs/requirements.txt new file mode 100644 index 00000000..e1ef96fa --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1,3 @@ +sphinx>=7 +sphinx-rtd-theme>=2 +myst-parser>=2 diff --git a/docs/source/about.md b/docs/source/about.md index 16e798d4..086623a1 100644 --- a/docs/source/about.md +++ b/docs/source/about.md @@ -1,149 +1,63 @@ -# About (FAQs) - -*** -## Can I run STREAMLINE as is? -Yes, as an automated machine learning pipeline, users can easily run the pipeline in it's entirety or one phase at a time. We have set up STREAMLINE to include -reasonably reliable default pipeline run parameters that users can optionally change to suite their needs. However the overall pipeline has been designed to operated -in a specific order utilizing a fixed set of data science elements/steps to ensure consistency and adherence to best practices. - -*** -## What can STREAMLINE be used for? -STREAMLINE can be used as: -1. A tool to quickly run a rigorous ML data analysis over one or more datasets using one or more of the included modeling algorithms -2. A framework to compare established scikit-learn compatible ML modeling algorithms to each other or to new algorithms -3. A baseline standard of comparison (i.e. positive control) with which to evaluate other AutoML tools that seek to optimize ML pipeline assembly as part of their methodology -4. A framework to quickly run exploratory analysis, data processing, and/or feature importance estimation/feature selection prior to using some other methodology for ML modeling -5. An educational example of how to integrate some of the many amazing Python-based data science tools currently available (in particular pandas, scipy, optuna, and scikit-learn). -6. A framework from which to create a new, expanded, adapted, or modified ML analysis pipeline -7. A framework to add and evaluate new modeling algorithms (see 'Adding New Modeling Algorithms') - -*** -## What level of computing skill is required for use? -STREAMLINE offers a variety of use options making it accessible to those with little or no coding experience as well as the seasoned programmer/data scientist. While there is currently no graphical user interface (GUI), the most naive user needs only know how to navigate their computer file system, specify folder/file paths, and have a Google Drive account (to run STREAMLINE serially on Google Colab). - -Those with a very basic knowledge of python and computer environments can apply STREAMLINE locally/serially using the included jupyter notebook. - -Those comfortable with command lines should run STREAMLINE locally (either serially or with CPU core parallellization) or (if available) on a computing cluster (HPC) in parallel. - -*** -## How is STREAMLINE different from other AutoML tools? -Unlike most other AutoML tools, STREAMLINE was designed as an end-to-end framework to rigorously apply -and compare a variety of ML modeling algorithms and collectively learn from them as opposed -to only identifying a best performing model and/or attempting to optimize the analysis pipeline -configuration itself. STREAMLINE adopts a fixed series of purposefully selected steps/phases -in line with data science best practices. It seeks to automate all domain generalizable -elements of an ML analysis pipeline with a specific focus on biomedical data mining challenges. -This tool can be run or utilized in a number of ways to suite a variety experience levels and -levels of problem/data complexity. Furthermore, STREAMLINE is currently the only autoML pipeline tool that includes [learning classifier system (LCS)](https://www.youtube.com/watch?v=CRge_cZ2cJc) rule-based ML modeling algorithms for interpretable modeling in data with complex associations. This includes an LCS algorithm developed by our lab ([ExSTraCS](https://github.com/UrbsLab/scikit-ExSTraCS)), that has been specifically implemented to address the challenges of biomedical data analysis. - -*** -## What does STREAMLINE automate? -Currently, STREAMLINE automates the following aspects of a machine learning analysis pipeline (see [schematic](index.rst)): - 1. Exploratory analysis (on the initial and processed dataset) - 2. Data processing - * Basic data cleaning: instances with no outcome, features users want to ignore, features and instances with high missingness (i.e. # of missing values), and one of each pair of highly correlated features. - * Basic feature engineering: add/encode missingness features and apply one-hot encoding to categorical features. - * CV partitioning - * Missing value imputation - * Scaling of features (using standard scalar) - 4. Feature processing - * Filter-based feature importance estimation (Mutual information & MultiSURF) - * Feature selection (using a 'collective', i.e. multi-algorithm approach) - 4. Modeling with 'Optuna' hyperparameter optimization using the 16 implemented ML algorithms (see below) - 5. Evaluation of all modeles on respective testing datasets using 16 classification metrics and model feature importance estimation - 6. Generates and organizes all results and other outputs including: - * Tables (Model evaluations, runtimes, selected hyperparameters, etc.) - * Publication-ready plots/figures & model visualizations - * Trained models (stored as pickled objects for re-use) - * Training and testing CV datasets (for external reproducibility) - 7. Non-parametric statistical comparisons across ML algorithms and analyzed datasets - 8. Summary report generation (as pre-formatted PDF) including: - * STREAMLINE run settings used - * Dataset characteristics summary - * Key figures and model evaluation results averaged over CV runs - * Runtime summary - 9. Applying and evaluating all STREAMLINE-trained models on further/future - hold out replication data - -The following 16 scikit-learn compatible ML modeling algorithms are currently included as options: -1. Naive Bayes (NB) -2. Logistic Regression (LR) -3. Elastic Net (EN) -4. Decision Tree (DT) -5. Random Forest (RF) -6. Gradient Boosting (GB) -7. XGBoost (XGB) -8. LGBoost (LGB) -9. CatBoost (CGB) -10. Support Vector Machine (SVM) -11. Artificial Neural Network (ANN) -12. K-Nearest Neighbors (k-NN) -13. Genetic Programming (GP) -14. Educational Learning Classifier System (eLCS) -15. 'X' Classifier System (XCS) -16. Extended Supervised Tracking and Classifying System (ExSTraCS). - -Classification-relevant hyperparameter values and ranges have been carefully -selected for each algorithm and have been pre-specified for the automated (Optuna-driven) -automated hyperparameter sweep. Thus, the user does not need to specify any algorithm hyperparameters or value options. - -The automatically formatted PDF reports generated by STREAMLINE are intended -to give a brief summary of pipeline settings and key results. -An 'experiment folder' is also output containing all results, statistical analyses publication-ready plots/figures, -models, and other outputs is also saved allowing users to carefully examine all aspects of -analysis performance in a transparent manner. - -Notably, STREAMLINE does NOT automate the following elements, as they are still best -completed by human experts: (1) accounting for bias or fairness in data -collection, (2) feature engineering and data cleaning that requires domain knowledge. -We recommend users consider conducting these items, as needed, prior to applying STREAMLINE. - -*** -## Does STREAMLINE always run the entire pipeline? -No. By default most of the pipeline will run; with the exception of (1) dataset comparison (Phase 7), which only runs when more than one 'target datasets' are run at a time, or (2) replication analysis (Phase 8), when replication data are not available. However the user can also choose to run STREAMLINE one phase at a time, which can often be advantageous. - -For example, a user could just run Phase 1 to conduct an exploratory analysis of new data. Or they could just run Phases 1-4 to generate processed, training and testing datasets to apply to modeling outside of STREAMLINE. - -One caveate is that STREAMLINE Phases are designed to run in sequence (one after the other). - -*** -## Can I do more with the STREAMLINE output after it completes? -Yes, we have assempled a variety of 'useful' Jupyter Notebooks -designed to operate on an experiment folder allowing users to do even more -with the pipeline output. Examples include: -1. Accessing prediction probabilities. -2. Regenerating figures to user-specifications. -3. Trying out the effect of different prediction thresholds on selected - models with an interactive slider. -4. Re-evaluating models when applying a new prediction threshold. -5. Generating an interactive model feature importance ranking visualization across - all ML algorithms. -6. Generating an interpretable model vizualization for either decision tree or genetic programming models. - -See [doing more with STREAMLINE](more.md#doing-more-with-streamline) for additional information. - -*** -## How does STREAMLINE avoid data leakage? -Assembling a machine learning pipeline unfortunately affords a user many opportunities to incorrectly allow data leakage. -Data leakage is when information that wouldn't normally be available or that comes from outside the training dataset is used to create the model. - -First, STREAMLINE makes it easy for a user to exclude features from a dataset that may contribute to data leakage (e.g. a feature that would not -be available when applying the model to make predictions). A user can specify features to be excluded from modeling using the [`ignore_features_path`](parameters.md#ignore-features-path) parameter. - -Second, STREAMLINE's pipeline is set up to specifically avoid learning any information that might eventually be a part of a testing data partition. Following CV partitioning, all learning required to conduct imputation, scaling, feature importance evaluation, feature selection, and modeling is done using the respective training partition alone. For imputation, the same trained imputation strategy is applied to the respective testing data. For scaling, the same trained scalar is applied to the respective testing data. For feature selection, the same features removed from the training data are removed from the testing data. And for modeling, the testing data is only used for model evaluation. - -This same strategy is applied to replication data later in the pipeline. When evaluating a given trained model on replication data, that dataset is imputed and scaled in the same way as the original training dataset for that model. And further, the same features that were removed during feature selection on the training data are removed for that replication dataset evaluation. - -*** -## Is STREAMLINE reproducible? -Yes, STREAMLINE is completely reproducible when the [`timeout`](parameters.md#timeout) parameter is set to `None`, and. This also assumes that STREAMLINE is being run on the same datasets, with the same run parameters (including [`random_state`](parameters.md#random-state)). However, STREAMLINE is expected to take longer to run when [`timeout`](parameters.md#timeout) = `None`. - -*** -## Which STREAMLINE run mode should I use? -STREAMLINE has been set up with multiple 'run-mode' options to suite different needs, computational resources, and user skill levels. -1. **Google Colab Notebook:** Can easily be run by anyone, even those with no coding experience. STREAMLINE output can easily be viewed within the notebook as it runs. However this mode is computationally limited by the free Google Cloud resources it has access to. This mode is best for demonstration, educational purposes, and running STREAMLINE on small datasets, or applying a limited number of machine learning modeling algorithms. -2. **Jupyter Notebook:** The advantages are mostly the same as the Colab Notebook, however this mode relies on the computing resources of your local computer, which may (or possibly not) have a faster CPU and memory. However, to use this mode you will need to know how to set up your computing environment with Anaconda, etc, which can take some troubleshooting for a beginner. This mode is best for those who want a little more control over STREAMLINE, but still wish to run it within a notebook. -3. **Command Line (Local):** As with Jupyter Notebook, this mode relies on the computing resources of your local computer. This mode is best for those who don't care about seeing output within the notebook and who know (or are willing to learn) how to work from a command line, but who may not have access to a computing cluster. -4. **Command Line (HPC Cluster):** STREAMLINE is an embarrassingly parallel package, that can parallelize individual phases as HPC jobs at the level of target datasets, CV partitions, and algorithms. This mode is best if you have access to a dask-compatible computing cluster. It is the fastest most efficient way to run STREAMLINE, particularly on larger datasets, or when users want to run all pipeline algorithms and elements. - -For more details on the advantages and disadvantages of different run modes, see '[Picking a Run Mode](running.md#picking-a-run-mode)'. +# About STREAMLINE + +STREAMLINE was built to make reproducible supervised machine learning workflows +more accessible for biomedical and general tabular datasets. The current +refactor keeps the original end-to-end spirit while separating the pipeline +into explicit P1-P11 phase modules. + +STREAMLINE is best thought of as a transparent analysis framework rather than +a black-box model picker. It applies a consistent pipeline, runs multiple +modeling perspectives, saves intermediate artifacts, and generates reports so +users can inspect what happened at every stage. + +## What STREAMLINE Is Useful For + +* running a structured supervised-learning analysis on tabular data +* comparing multiple algorithms under the same CV and preprocessing design +* producing baseline models and summary reports for a new dataset +* evaluating feature importance and selected features across folds +* applying trained workflows to replication data +* teaching or demonstrating an end-to-end AutoML-style workflow + +## What STREAMLINE Automates + +* Dataset loading and exploratory summaries +* Cross-validation partitioning +* Missing-value imputation and scaling +* Optional SMOTE/SMOTENC oversampling +* Feature learning +* Feature importance scoring +* Feature selection +* Base model training and evaluation +* Classification ensembles +* Summary statistics and dataset comparison +* External replication +* Standard and replication PDF reporting + +## What Users Still Control + +Users should still make scientific and domain-specific decisions about: + +* Outcome definition +* Feature inclusion and exclusion +* Feature type declarations +* Leakage checks +* Metric choice +* Class-label interpretation +* Replication dataset suitability + +STREAMLINE does not replace domain review. Users should still check for data +leakage, unclear outcome definitions, inappropriate feature encodings, +collection bias, and metrics that do not match the scientific question. + +## Current Learning Tasks + +STREAMLINE supports binary classification, multiclass classification, and +regression. P7 ensembles are currently classification-only. + +## What STREAMLINE Does Not Automate + +STREAMLINE does not perform feature extraction from unstructured text, images, +audio, video, or raw time-series streams. It also does not decide whether a +feature is scientifically valid, whether a dataset is biased, or whether a +replication cohort is comparable to the training cohort. diff --git a/docs/source/changelog.md b/docs/source/changelog.md new file mode 100644 index 00000000..a58faac8 --- /dev/null +++ b/docs/source/changelog.md @@ -0,0 +1,221 @@ +# Changelog + +This page summarizes the major STREAMLINE release anchors in newest-first order. +STREAMLINE v1.0.0 is the current main release documented by this site. STREAMLINE +v0.3.4 is the previous tested and stable public release. STREAMLINE v0.2.5 is the +legacy release anchor for the original implementation line. + +For smaller patch-level and development notes, see the official +[GitHub Releases](https://github.com/UrbsLab/STREAMLINE/releases) page. + +## v1.0.0 Main Release + +**Tag reference:** `v1.0.0` when this release is tagged on `main`. + +STREAMLINE v1.0.0 is a major reorganization, expansion, and modernization of the +pipeline. It keeps STREAMLINE's original goal of transparent end-to-end tabular +AutoML, while broadening the supported tasks, making phases easier to extend, +and refreshing the notebooks, tests, reports, and documentation around the new +workflow. + +### Architecture And Run Workflow + +* Refactored STREAMLINE into explicit P1-P11 phase modules: data processing, + imputation/scaling/balancing, feature learning, feature importance, feature + selection, modeling, classification ensembles, summary statistics, dataset + comparison, replication, and reporting. +* Added config-driven full-pipeline execution with `.cfg` files, while keeping + phase-by-phase command-line and notebook workflows available. +* Standardized parameter names across config files, command-line arguments, + notebooks, and saved run-command metadata. +* Added run-command pickle support so repeated phase calls can reuse the + parameters that were actually used, while allowing users to override or ignore + saved values when needed. +* Added `Parallel` local multiprocessing-style execution in addition to + `Serial`, local Dask through `Local`, and supported cluster submission modes. +* Reorganized code around registries so users can add or swap methods more + cleanly across phases, including Phase 2 imputers/scalers, Phase 3 learners, + Phase 4 feature-importance methods, Phase 5 selectors, Phase 6 models, and + Phase 7 ensembles. + +### Binary, Multiclass, And Regression Support + +* Extended STREAMLINE beyond the earlier primarily binary-classification + workflow to support binary classification, multiclass classification, and + regression as first-class task types. +* Added UCI-based demo datasets and matching held-out replication splits for + binary classification, multiclass classification, and regression tutorials and + tests. +* Updated P1 task handling so user-specified `outcome_type` is respected instead + of being re-inferred only from the number of outcome values. +* Updated P6 model loading and evaluation around task-specific model registries + for binary, multiclass, and regression runs. +* Added multiclass evaluation support, including macro/micro metrics and + multiclass ROC/PR curve summaries where applicable. +* Added regression evaluation support, including regression metrics such as + explained variance, Pearson correlation, MAE, MSE, median absolute error, max + error, residual outputs, and actual-vs-predicted style reporting. +* Updated reports and summary statistics so metric names, no-skill baselines, + curves, and plots are task-aware instead of assuming binary classification. +* Clarified that P7 ensemble modeling is currently classification-only, so + regression workflows proceed from P6 modeling to P8 summary statistics. + +### Data Processing, Feature Types, And Preprocessing + +* Added clearer feature-type handling for categorical and quantitative features, + including optional user-supplied feature type files and inferred feature types. +* Added optional SMOTE/SMOTENC balancing after Phase 2 imputation and scaling, + with SMOTENC used when categorical features are present. +* Added support for bypassing one-hot encoding when using models that can handle + categorical features natively. +* Added explicit native-categorical model controls so unsupported models are + rejected when one-hot encoding is disabled instead of silently receiving an + incompatible representation. +* Kept preprocessing extensible through the Phase 2 registry, so users can add + scalers such as `MaxAbsScaler` or custom imputers without changing the rest of + the pipeline. + +### Feature Learning, Importance, And Selection + +* Added P3 feature learning as a dedicated phase, including PCA-style learned + feature outputs and manifests. +* Updated replication handling to use the saved training workflow artifacts and + feature manifests more consistently. +* Updated Phase 4 so feature-importance methods write scores without mutating + shared CV datasets, avoiding order-dependent outputs and parallel race risks. +* Updated scikit-rebate integration for the current package behavior, including + passing STREAMLINE's categorical feature indexes to ReBATE methods. +* Added MultiSWRFDB and MultiSWRFDB* feature-importance methods. +* Updated default feature-importance/selection behavior around mutual + information, MultiSWRFDB, and MultiSWRFDB*. +* Improved Phase 5 feature selection so rankings can be combined across all + feature-importance methods that were run, not only a fixed pair of methods. +* Added or restored `instance_subset` support for expensive feature-importance + methods so large runs can be controlled from config/CLI parameters. + +### Modeling And Native Categorical Algorithms + +* Reworked Phase 6 modeling around clearer dataset/model/CV execution units for + serial, parallel, Dask, and cluster runs. +* Added Decision Tree support for classification workflows. +* Added or updated HEROS wrappers and optional TabPFN wrappers. +* Added TabPFN token handling: if `TABPFN_TOKEN` is not set, requested TabPFN + models are skipped with a warning while HEROS and other requested models + continue. +* Updated ExSTraCS categorical initialization so categorical and continuous + attributes can be passed through its supported `discrete_attribute_limit` and + `specified_attributes` parameters. +* Improved native categorical model handling for compatible algorithms such as + CatBoost/CGB and ExSTraCS. +* Added Optuna trial accounting so reports can show how many trials actually ran + within the requested `n_trials` and `timeout` budgets. +* Standardized model defaults across config, command-line, and notebook run + modes, including removal of deprecated/default-only legacy methods where + appropriate. + +### Reporting, Replication, And Outputs + +* Added standard and replication PDF report improvements, including clearer + first-page summaries, experiment names, resolved/default parameter display, + and report-mode-specific text. +* Added dedicated replication report naming and clearer replication report + content so replication outputs are not confused with standard CV reports. +* Improved report language around categorical handling, scaling/imputation, + feature learning, feature selection, and metric interpretation. +* Added feature-learning and feature-selection summary tables modeled after the + data-processing/feature-engineering summary style. +* Improved feature-importance figure layout, including more square plots and + clearer ordering emphasis. +* Updated metric highlighting to use shading rather than only bold text. +* Added no-skill ROC/PR legend notes and label-aware baseline handling for + multiclass or non-stratified/random CV settings. +* Improved output organization and report data JSON so reports are easier to + debug and regenerate. + +### Notebooks, Documentation, Tests, And Release Readiness + +* Updated the Google Colab notebook and local Jupyter notebook for the v1.0.0 + workflow, including parameter blocks for binary, multiclass, regression, and + custom dataset runs. +* Rebuilt the documentation website around the v1.0.0 workflow as the new main + documentation site. +* Added Sphinx/autodoc documentation build support. +* Added GitHub pytest workflows for Python 3.10, 3.11, and 3.12. Python 3.9 was + skipped because TabPFN does not support it. +* Added optional TabPFN-specific pytest coverage for no-token skip behavior and + token-gated wrapper fitting. +* Added macOS installation guidance for conda-forge compiled dependencies such + as Graphviz, WeasyPrint/Cairo/Pango, LightGBM, XGBoost, and CatBoost. +* Removed or de-emphasized old main-era documentation paths and files that are + no longer part of the maintained v1.0.0 workflow. + +## v0.3.4 Tested Stable Release + +**Tag references:** `v0.3.0-beta`, `v0.3.1-beta`, `v0.3.2-beta`, +`v0.3.3-beta`, `v0.3.4-beta`. + +The v0.3.x public beta line is the previous tested and stable STREAMLINE +version. Its latest release was `v0.3.4-beta`. + +Notable updates across the v0.3.x line: + +* Added Dask jobqueue support for multiple HPC cluster systems. +* Expanded the original Phase 1 EDA flow into numerical encoding, automated + cleaning, missingness feature engineering, one-hot encoding, correlation + feature cleaning, processed-data EDA, and data-process summaries. +* Added configuration-file support and whole-pipeline command-line execution. +* Modularized modeling algorithms into classes and added Elastic Net. +* Improved Google Colab workflows for easier data selection and output access. +* Added replication processing parity for categorical and missingness handling. +* Added invariant feature removal and matching replication behavior. +* Improved PDF report formatting, first-page summaries, run-parameter display, + and multi-dataset report layout. +* Fixed command-line, legacy cluster, replication, missingness naming, and + unseen categorical-value edge cases. + +Release highlights: + +| Tag | Date | Summary | +| --- | --- | --- | +| `v0.3.4-beta` | 2023-09-28 | PDF formatting improvements and legacy replication/report fixes. | +| `v0.3.3-beta` | 2023-09-23 | Invariant feature removal, replication parity fixes, notebook ordering fixes, and report text updates. | +| `v0.3.2-beta` | 2023-09-13 | Legacy command-line argument fixes, job-status docs, schematic and PDF naming updates. | +| `v0.3.1-beta` | 2023-09-07 | Replication imputation fallback and alphabetized model legends. | +| `v0.3.0-beta` | 2023-08-06 | Major command-line, cluster, Phase 1, replication, config, modeling, Colab, and report updates. | + +## v0.2.5 Legacy Release + +**Tag references:** `v0.1.0-alpha`, `v0.1.1-alpha`, `v0.1.2-alpha`, +`v0.1.3-alpha`, `v0.2.0-beta`, `v0.2.1-beta`, `v0.2.2-beta`, +`v0.2.3-beta`, `v0.2.4-beta`, `v0.2.5-beta`. + +The v0.2.x line covers the first public STREAMLINE implementation and early beta +stabilization work. Its latest release was `v0.2.5-beta`. + +Notable updates across the v0.2.x line: + +* Introduced the first stable STREAMLINE implementation inherited from + AutoMLPipe-BC concepts. +* Moved the codebase into the `streamline` package folder. +* Updated default Optuna parameters and documented reproducibility limitations + when parallel optimization uses timeouts. +* Fixed serial Linux command-line execution and several command-line phase + issues. +* Improved composite feature-importance behavior, feature-selection options, + report formatting, and Optuna plotting failure handling. +* Added support for replication input as `.csv` or `.txt`. +* Switched feature-importance summary reporting between mean and median during + early beta refinements based on collaborator feedback. +* Added small statistical-comparison and no-missing-data imputation fixes. + +Release highlights: + +| Tag | Date | Summary | +| --- | --- | --- | +| `v0.2.5-beta` | 2022-06-24 | Statistical-comparison edge-case catch and cleanup. | +| `v0.2.4-beta` | 2022-06-15 | No-missing-data imputation fix, replication file support, and FI/report summary updates. | +| `v0.2.3-beta` | 2022-05-20 | Stable Linux serial command-line beta. | +| `v0.2.2-beta` | 2022-05-19 | Composite FI, metric weighting, serial CLI, report formatting, and Optuna fixes. | +| `v0.2.1-beta` | 2022-05-17 | Package layout, Optuna default, reproducibility, and scaled-data rounding updates. | +| `v0.2.0-beta` | 2022-05-14 | First beta for external use. | +| `v0.1.x-alpha` | 2022-05-12 | Initial alpha releases and early Anaconda/scipy compatibility fixes. | diff --git a/docs/source/citation.md b/docs/source/citation.md index 3df3968c..f934b2e8 100644 --- a/docs/source/citation.md +++ b/docs/source/citation.md @@ -1,215 +1,21 @@ -# Citing STREAMLINE +# Citation -If you use STREAMLINE in a scientific publication, please consider citing the following paper as well as noting the *release* applied within the manuscript. +If you use STREAMLINE in academic work, please cite the relevant STREAMLINE +publication and note the repository version or commit used for the analysis. -The most recent release (Beta 0.3.4) was applied in the most recent pre-print below: +The first publication describing STREAMLINE is: -[Urbanowicz, Ryan, et al. "STREAMLINE: An Automated Machine Learning Pipeline for Biomedicine Applied to Examine the Utility of Photography-Based Phenotypes for OSA Prediction Across International Sleep Centers." arXiv preprint arXiv:2312.05461.](https://doi.org/10.48550/arXiv.2312.05461) +* STREAMLINE: A simple, transparent, end-to-end automated machine learning pipeline facilitating data analysis and algorithm comparison. -BibTeX Citation: -``` -@article{urbanowicz2023streamlineosa, - title={STREAMLINE: An Automated Machine Learning Pipeline for Biomedicine Applied to Examine the Utility of Photography-Based Phenotypes for OSA Prediction Across International Sleep Centers}, - author={Urbanowicz, Ryan J and Bandhey, Harsh and Keenan, Brendan T and Maislin, Greg and Hwang, Sy and Mowery, Danielle L and Lynch, Shannon M and Mazzotti, Diego R and Han, Fang and Li, Quing Yun and Penzel, Thomas and Tufik, Sergio and Bittencourt, Lia and Gislason, Thorarinn and de Chazal, Philip and Singh, Bhajan and McArdle, Nigel and Chen, Ning-Hung and Pack, Allan and Schwab, Richard J and Cistulli, Peter A and Magalang, Ulysses J}, - journal={arXiv preprint arXiv:2312.05461}, - year={2023} -} -``` +Related links: -The first STREAMLINE publication (Beta 0.2.4 release was applied in the publication below): +* [Springer chapter](https://link.springer.com/chapter/10.1007/978-981-19-8460-0_9) +* [arXiv preprint](https://arxiv.org/abs/2206.12002) -[Urbanowicz, Ryan, et al. "STREAMLINE: A Simple, Transparent, End-To-End Automated Machine Learning Pipeline Facilitating Data Analysis and Algorithm Comparison." Genetic Programming Theory and Practice XIX. Singapore: Springer Nature Singapore, 2023. 201-231.](https://link.springer.com/chapter/10.1007/978-981-19-8460-0_9) +For reproducibility, report: -BibTeX Citation: -``` -@incollection{urbanowicz2023streamline, - title={STREAMLINE: A Simple, Transparent, End-To-End Automated Machine Learning Pipeline Facilitating Data Analysis and Algorithm Comparison}, - author={Urbanowicz, Ryan and Zhang, Robert and Cui, Yuhan and Suri, Pranshu}, - booktitle={Genetic Programming Theory and Practice XIX}, - pages={201--231}, - year={2023}, - publisher={Springer} -} -``` - -If you wish to cite the STREAMLINE codebase instead, please use the following (indicating the release used in the link, for example, v0.3.4-beta): -``` -@misc{streamline2023, - author = {Urbanowicz, Ryan and Zhang, Robert}, - title = {STREAMLINE: A Simple, Transparent, End-To-End Automated Machine Learning Pipeline}, - year = {2023}, - publisher = {GitHub}, - journal = {GitHub repository}, - howpublished = {\url{https://github.com/UrbsLab/STREAMLINE/releases/tag/v0.3.4-beta} } -} -``` -## STREAMLINE Applications -This section provides citations to publications applying STREAMLINE in recent research. - -* [Exploring Automated Machine Learning for Cognitive Outcome Prediction from Multimodal Brain Imaging using STREAMLINE](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC10283099/) -``` -@article{wang2023exploring, - title={Exploring Automated Machine Learning for Cognitive Outcome Prediction from Multimodal Brain Imaging using STREAMLINE}, - author={Wang, Xinkai and Feng, Yanbo and Tong, Boning and Bao, Jingxuan and Ritchie, Marylyn D and Saykin, Andrew J and Moore, Jason H and Urbanowicz, Ryan and Shen, Li}, - journal={AMIA Summits on Translational Science Proceedings}, - volume={2023}, - pages={544}, - year={2023}, - publisher={American Medical Informatics Association} -} -``` - -* [Comparing Amyloid Imaging Normalization Strategies for Alzheimer’s Disease Classification using an Automated Machine Learning Pipeline](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC10283108/) -``` -@article{tong2023comparing, - title={Comparing Amyloid Imaging Normalization Strategies for Alzheimer’s Disease Classification using an Automated Machine Learning Pipeline}, - author={Tong, Boning and Risacher, Shannon L and Bao, Jingxuan and Feng, Yanbo and Wang, Xinkai and Ritchie, Marylyn D and Moore, Jason H and Urbanowicz, Ryan and Saykin, Andrew J and Shen, Li}, - journal={AMIA Summits on Translational Science Proceedings}, - volume={2023}, - pages={525}, - year={2023}, - publisher={American Medical Informatics Association} -} -``` - -* [Toward Predicting 30-Day Readmission Among Oncology Patients: Identifying Timely and Actionable Risk Factors](https://ascopubs.org/doi/abs/10.1200/CCI.22.00097) -``` -@article{hwang2023toward, - title={Toward Predicting 30-Day Readmission Among Oncology Patients: Identifying Timely and Actionable Risk Factors}, - author={Hwang, Sy and Urbanowicz, Ryan and Lynch, Selah and Vernon, Tawnya and Bresz, Kellie and Giraldo, Carolina and Kennedy, Erin and Leabhart, Max and Bleacher, Troy and Ripchinski, Michael R and others}, - journal={JCO Clinical Cancer Informatics}, - volume={7}, - pages={e2200097}, - year={2023}, - publisher={Wolters Kluwer Health} -} -``` - -*[A Data-Driven Analysis of Ward Capacity Strain Metrics That Predict Clinical Outcomes Among Survivors of Acute Respiratory Failure](https://link.springer.com/article/10.1007/s10916-023-01978-5) - -Kohn, R., Harhay, M.O., Weissman, G.E. et al. A Data-Driven Analysis of Ward Capacity Strain Metrics That Predict Clinical Outcomes Among Survivors of Acute Respiratory Failure. J Med Syst 47, 83 (2023). - -* [Identifying Barriers to Post-Acute Care Referral and Characterizing Negative Patient Preferences Among Hospitalized Older Adults Using Natural Language Processing](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC10148308/) -``` -@inproceedings{kennedy2022identifying, - title={Identifying Barriers to Post-Acute Care Referral and Characterizing Negative Patient Preferences Among Hospitalized Older Adults Using Natural Language Processing}, - author={Kennedy, Erin E and Davoudi, Anahita and Hwang, Sy and Freda, Philip J and Urbanowicz, Ryan and Bowles, Kathryn H and Mowery, Danielle L}, - booktitle={AMIA Annual Symposium Proceedings}, - volume={2022}, - pages={606}, - year={2022}, - organization={American Medical Informatics Association} -} -``` - -## Other STREAMLINE Related Research -In developing STREAMLINE we integrated a number of methods and lessons learned from our lab's previous research. We briefly summarize and provide citations for each. - -### A rigorous ML pipeline for binary classification -A [preprint](https://arxiv.org/abs/2008.12829) describing an early version of what would become STREAMLINE applied to pancreatic cancer. - -``` -@article{urbanowicz2020rigorous, - title={A Rigorous Machine Learning Analysis Pipeline for Biomedical Binary Classification: Application in Pancreatic Cancer Nested Case-control Studies with Implications for Bias Assessments}, - author={Urbanowicz, Ryan J and Suri, Pranshu and Cui, Yuhan and Moore, Jason H and Ruth, Karen and Stolzenberg-Solomon, Rachael and Lynch, Shannon M}, - journal={arXiv preprint arXiv:2008.12829v2}, - year={2020} -} -``` - -The STREAMLINE (v0.2.4) [preprint](https://arxiv.org/abs/2206.12002). -``` -@article{urbanowicz2022streamline, - title={STREAMLINE: A Simple, Transparent, End-To-End Automated Machine Learning Pipeline Facilitating Data Analysis and Algorithm Comparison}, - author={Urbanowicz, Ryan J and Zhang, Robert and Cui, Yuhan and Suri, Pranshu}, - journal={arXiv preprint arXiv:2206.12002v1}, - year={2022} -} -``` - -### Relief-based feature importance estimation -One of the two feature importance algorithms used by STREAMLINE is MultiSURF, a Relief-based filter feature importance algorithm that can prioritize features involved in either univariate or multivariate feature interactions associated with outcome. We believe that it is important to have at least one 'interaction-sensitive' feature importance algorithm involved in feature selection prior such that relevant features involved in complex associations are not filtered out prior to modeling. The [paper below](https://www.sciencedirect.com/science/article/pii/S1532046418301400) is an introduction and review of Relief-based algorithms. -``` -@article{urbanowicz2018relief, - title={Relief-based feature selection: Introduction and review}, - author={Urbanowicz, Ryan J and Meeker, Melissa and La Cava, William and Olson, Randal S and Moore, Jason H}, - journal={Journal of biomedical informatics}, - volume={85}, - pages={189--203}, - year={2018}, - publisher={Elsevier} -} -``` -This [next published research paper](https://www.sciencedirect.com/science/article/pii/S1532046418301412) compared a number of Relief-based algorithms and demonstrated best overall performance with MultiSURF out of all evaluated. This second paper also introduced 'ReBATE', a scikit-learn package of Releif-based feature importance/selection algorithms (used by STREAMLINE). -``` -@article{urbanowicz2018benchmarking, - title={Benchmarking relief-based feature selection methods for bioinformatics data mining}, - author={Urbanowicz, Ryan J and Olson, Randal S and Schmitt, Peter and Meeker, Melissa and Moore, Jason H}, - journal={Journal of biomedical informatics}, - volume={85}, - pages={168--188}, - year={2018}, - publisher={Elsevier} -} -``` - -### Collective feature selection -Following feature importance estimation, STREAMLINE adopts an ensemble approach to determining which features to select. The utility of this kind of 'collective' feature selection, was introduced in the [next publication](https://link.springer.com/article/10.1186/s13040-018-0168-6). -``` -@article{verma2018collective, - title={Collective feature selection to identify crucial epistatic variants}, - author={Verma, Shefali S and Lucas, Anastasia and Zhang, Xinyuan and Veturi, Yogasudha and Dudek, Scott and Li, Binglan and Li, Ruowang and Urbanowicz, Ryan and Moore, Jason H and Kim, Dokyoon and others}, - journal={BioData mining}, - volume={11}, - number={1}, - pages={1--22}, - year={2018}, - publisher={Springer} -} -``` - -### Learning classifier systems -STREAMLINE currently incorporates 15 ML classification modeling algorithms that can be run. Our own research has closely followed a subfield of evolutionary algorithms that discover a set of rules that collectively constitute a trained model. The appeal of such 'rule-based machine learning algorithms' (e.g. learning classifier systems) is that they can model complex associations while also offering human interpretable models. In the [first paper below](https://link.springer.com/article/10.1007/s12065-015-0128-8) we introduced 'ExSTraCS', a learning classifier system geared towards bioinformatics data analysis. ExSTraCS was the first ML algorithm demonstrated to be able to tackle the long-standing 135-bit multiplexer problem directly, largely due to it's ability to use prior feature importance estimates from a Relief algorithm to guide the evolutionary rule search. -``` -@article{urbanowicz2015exstracs, - title={ExSTraCS 2.0: description and evaluation of a scalable learning classifier system}, - author={Urbanowicz, Ryan J and Moore, Jason H}, - journal={Evolutionary intelligence}, - volume={8}, - number={2}, - pages={89--116}, - year={2015}, - publisher={Springer} -} -``` - -In the [next published pre-print](https://arxiv.org/abs/2104.12844) we introduced a scikit-learn implementation of ExSTraCS (used by STREAMLINE) as well as a pipeline (LCS-DIVE) to take ExSTraCS output and characterize different patterns association between features and outcome. Future work will demonstrate how STREAMLINE can be linked with LCS-DIVE to better understand the relationship between features and outcome captured by rule-based modeling. -``` -@article{zhang2021lcs, - title={LCS-DIVE: An Automated Rule-based Machine Learning Visualization Pipeline for Characterizing Complex Associations in Classification}, - author={Zhang, Robert and Stolzenberg-Solomon, Rachael and Lynch, Shannon M and Urbanowicz, Ryan J}, - journal={arXiv preprint arXiv:2104.12844}, - year={2021} -} -``` - -In the [next publication](https://dl.acm.org/doi/abs/10.1145/3377929.3398097) we introduced the first scikit-learn compatible implementation of an LCS algorithm. Specifically this paper implemented eLCS, an educational learning classifier system. This eLCS algorithm is a direct descendant of the UCS algorithm. -``` -@inproceedings{zhang2020scikit, - title={A scikit-learn compatible learning classifier system}, - author={Zhang, Robert F and Urbanowicz, Ryan J}, - booktitle={Proceedings of the 2020 Genetic and Evolutionary Computation Conference Companion}, - pages={1816--1823}, - year={2020} -} -``` - -eLCS was originally developed as a very simple supervised learning LCS implementation primarily as an educational resource pairing with the following [published textbook](https://books.google.com/books?hl=en&lr=&id=C6QxDwAAQBAJ&oi=fnd&pg=PR5&dq=Introduction+to+learning+classifier+systems&ots=pTcnuuYQPE&sig=wNgZmWkcne9m3LQgDzuBu30uQ1Y#v=onepage&q=Introduction%20to%20learning%20classifier%20systems&f=false). -``` -@book{urbanowicz2017introduction, - title={Introduction to learning classifier systems}, - author={Urbanowicz, Ryan J and Browne, Will N}, - year={2017}, - publisher={Springer} -} -``` +* STREAMLINE branch or commit hash +* run configuration file +* dataset version/source +* outcome type and metric +* whether replication/P10 was run diff --git a/docs/source/codedocs/streamline.dataprep.data_process.rst b/docs/source/codedocs/streamline.dataprep.data_process.rst deleted file mode 100644 index c1309d61..00000000 --- a/docs/source/codedocs/streamline.dataprep.data_process.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.dataprep.data\_process module -======================================== - -.. automodule:: streamline.dataprep.data_process - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.dataprep.exploratory_analysis.rst b/docs/source/codedocs/streamline.dataprep.exploratory_analysis.rst deleted file mode 100644 index 138ca4de..00000000 --- a/docs/source/codedocs/streamline.dataprep.exploratory_analysis.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.dataprep.exploratory\_analysis module -================================================ - -.. automodule:: streamline.dataprep.exploratory_analysis - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.dataprep.kfold_partitioning.rst b/docs/source/codedocs/streamline.dataprep.kfold_partitioning.rst deleted file mode 100644 index 5016f752..00000000 --- a/docs/source/codedocs/streamline.dataprep.kfold_partitioning.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.dataprep.kfold\_partitioning module -============================================== - -.. automodule:: streamline.dataprep.kfold_partitioning - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.dataprep.rst b/docs/source/codedocs/streamline.dataprep.rst deleted file mode 100644 index 7f215d68..00000000 --- a/docs/source/codedocs/streamline.dataprep.rst +++ /dev/null @@ -1,17 +0,0 @@ -streamline.dataprep package -=========================== - -.. automodule:: streamline.dataprep - :members: - :undoc-members: - :show-inheritance: - -Submodules ----------- - -.. toctree:: - :maxdepth: 4 - - streamline.dataprep.data_process - streamline.dataprep.exploratory_analysis - streamline.dataprep.kfold_partitioning diff --git a/docs/source/codedocs/streamline.featurefns.importance.rst b/docs/source/codedocs/streamline.featurefns.importance.rst deleted file mode 100644 index a9828ce0..00000000 --- a/docs/source/codedocs/streamline.featurefns.importance.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.featurefns.importance module -======================================= - -.. automodule:: streamline.featurefns.importance - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.featurefns.rst b/docs/source/codedocs/streamline.featurefns.rst deleted file mode 100644 index f11079f3..00000000 --- a/docs/source/codedocs/streamline.featurefns.rst +++ /dev/null @@ -1,16 +0,0 @@ -streamline.featurefns package -============================= - -.. automodule:: streamline.featurefns - :members: - :undoc-members: - :show-inheritance: - -Submodules ----------- - -.. toctree:: - :maxdepth: 4 - - streamline.featurefns.importance - streamline.featurefns.selection diff --git a/docs/source/codedocs/streamline.featurefns.selection.rst b/docs/source/codedocs/streamline.featurefns.selection.rst deleted file mode 100644 index 6bf745ba..00000000 --- a/docs/source/codedocs/streamline.featurefns.selection.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.featurefns.selection module -====================================== - -.. automodule:: streamline.featurefns.selection - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.modeling.basemodel.rst b/docs/source/codedocs/streamline.modeling.basemodel.rst deleted file mode 100644 index 069419a6..00000000 --- a/docs/source/codedocs/streamline.modeling.basemodel.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.modeling.basemodel module -==================================== - -.. automodule:: streamline.modeling.basemodel - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.modeling.load_models.rst b/docs/source/codedocs/streamline.modeling.load_models.rst deleted file mode 100644 index 15405862..00000000 --- a/docs/source/codedocs/streamline.modeling.load_models.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.modeling.load\_models module -======================================= - -.. automodule:: streamline.modeling.load_models - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.modeling.modeljob.rst b/docs/source/codedocs/streamline.modeling.modeljob.rst deleted file mode 100644 index ab6ae61e..00000000 --- a/docs/source/codedocs/streamline.modeling.modeljob.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.modeling.modeljob module -=================================== - -.. automodule:: streamline.modeling.modeljob - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.modeling.parameters.rst b/docs/source/codedocs/streamline.modeling.parameters.rst deleted file mode 100644 index 223acfb2..00000000 --- a/docs/source/codedocs/streamline.modeling.parameters.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.modeling.parameters module -===================================== - -.. automodule:: streamline.modeling.parameters - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.modeling.rst b/docs/source/codedocs/streamline.modeling.rst deleted file mode 100644 index cd896e05..00000000 --- a/docs/source/codedocs/streamline.modeling.rst +++ /dev/null @@ -1,19 +0,0 @@ -streamline.modeling package -=========================== - -.. automodule:: streamline.modeling - :members: - :undoc-members: - :show-inheritance: - -Submodules ----------- - -.. toctree:: - :maxdepth: 4 - - streamline.modeling.basemodel - streamline.modeling.load_models - streamline.modeling.modeljob - streamline.modeling.parameters - streamline.modeling.utils diff --git a/docs/source/codedocs/streamline.modeling.utils.rst b/docs/source/codedocs/streamline.modeling.utils.rst deleted file mode 100644 index 82757333..00000000 --- a/docs/source/codedocs/streamline.modeling.utils.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.modeling.utils module -================================ - -.. automodule:: streamline.modeling.utils - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.models.artificial_neural_network.rst b/docs/source/codedocs/streamline.models.artificial_neural_network.rst deleted file mode 100644 index 255d2aef..00000000 --- a/docs/source/codedocs/streamline.models.artificial_neural_network.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.models.artificial\_neural\_network module -==================================================== - -.. automodule:: streamline.models.artificial_neural_network - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.models.decision_tree.rst b/docs/source/codedocs/streamline.models.decision_tree.rst deleted file mode 100644 index a2b85993..00000000 --- a/docs/source/codedocs/streamline.models.decision_tree.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.models.decision\_tree module -======================================= - -.. automodule:: streamline.models.decision_tree - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.models.elastic_net.rst b/docs/source/codedocs/streamline.models.elastic_net.rst deleted file mode 100644 index 19fcd2c8..00000000 --- a/docs/source/codedocs/streamline.models.elastic_net.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.models.elastic\_net module -===================================== - -.. automodule:: streamline.models.elastic_net - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.models.genetic_programming.rst b/docs/source/codedocs/streamline.models.genetic_programming.rst deleted file mode 100644 index 4df7caa3..00000000 --- a/docs/source/codedocs/streamline.models.genetic_programming.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.models.genetic\_programming module -============================================= - -.. automodule:: streamline.models.genetic_programming - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.models.gradient_boosting.rst b/docs/source/codedocs/streamline.models.gradient_boosting.rst deleted file mode 100644 index b4c8edb7..00000000 --- a/docs/source/codedocs/streamline.models.gradient_boosting.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.models.gradient\_boosting module -=========================================== - -.. automodule:: streamline.models.gradient_boosting - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.models.learning_based.rst b/docs/source/codedocs/streamline.models.learning_based.rst deleted file mode 100644 index 618980bc..00000000 --- a/docs/source/codedocs/streamline.models.learning_based.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.models.learning\_based module -======================================== - -.. automodule:: streamline.models.learning_based - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.models.linear_model.rst b/docs/source/codedocs/streamline.models.linear_model.rst deleted file mode 100644 index 81af7d99..00000000 --- a/docs/source/codedocs/streamline.models.linear_model.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.models.linear\_model module -====================================== - -.. automodule:: streamline.models.linear_model - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.models.naive_bayes.rst b/docs/source/codedocs/streamline.models.naive_bayes.rst deleted file mode 100644 index 6ce72e92..00000000 --- a/docs/source/codedocs/streamline.models.naive_bayes.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.models.naive\_bayes module -===================================== - -.. automodule:: streamline.models.naive_bayes - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.models.neighbouring.rst b/docs/source/codedocs/streamline.models.neighbouring.rst deleted file mode 100644 index b5acc007..00000000 --- a/docs/source/codedocs/streamline.models.neighbouring.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.models.neighbouring module -===================================== - -.. automodule:: streamline.models.neighbouring - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.models.random_forest.rst b/docs/source/codedocs/streamline.models.random_forest.rst deleted file mode 100644 index 5a9f2210..00000000 --- a/docs/source/codedocs/streamline.models.random_forest.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.models.random\_forest module -======================================= - -.. automodule:: streamline.models.random_forest - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.models.rst b/docs/source/codedocs/streamline.models.rst deleted file mode 100644 index 8e549c15..00000000 --- a/docs/source/codedocs/streamline.models.rst +++ /dev/null @@ -1,25 +0,0 @@ -streamline.models package -========================= - -.. automodule:: streamline.models - :members: - :undoc-members: - :show-inheritance: - -Submodules ----------- - -.. toctree:: - :maxdepth: 4 - - streamline.models.artificial_neural_network - streamline.models.decision_tree - streamline.models.elastic_net - streamline.models.genetic_programming - streamline.models.gradient_boosting - streamline.models.learning_based - streamline.models.linear_model - streamline.models.naive_bayes - streamline.models.neighbouring - streamline.models.random_forest - streamline.models.support_vector_machine diff --git a/docs/source/codedocs/streamline.models.support_vector_machine.rst b/docs/source/codedocs/streamline.models.support_vector_machine.rst deleted file mode 100644 index dce4fc59..00000000 --- a/docs/source/codedocs/streamline.models.support_vector_machine.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.models.support\_vector\_machine module -================================================= - -.. automodule:: streamline.models.support_vector_machine - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.postanalysis.dataset_compare.rst b/docs/source/codedocs/streamline.postanalysis.dataset_compare.rst deleted file mode 100644 index 1bd34c06..00000000 --- a/docs/source/codedocs/streamline.postanalysis.dataset_compare.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.postanalysis.dataset\_compare module -=============================================== - -.. automodule:: streamline.postanalysis.dataset_compare - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.postanalysis.gererate_report.rst b/docs/source/codedocs/streamline.postanalysis.gererate_report.rst deleted file mode 100644 index 2a56c36f..00000000 --- a/docs/source/codedocs/streamline.postanalysis.gererate_report.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.postanalysis.gererate\_report module -=============================================== - -.. automodule:: streamline.postanalysis.gererate_report - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.postanalysis.model_replicate.rst b/docs/source/codedocs/streamline.postanalysis.model_replicate.rst deleted file mode 100644 index be0a88b5..00000000 --- a/docs/source/codedocs/streamline.postanalysis.model_replicate.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.postanalysis.model\_replicate module -=============================================== - -.. automodule:: streamline.postanalysis.model_replicate - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.postanalysis.rst b/docs/source/codedocs/streamline.postanalysis.rst deleted file mode 100644 index ec53bfe0..00000000 --- a/docs/source/codedocs/streamline.postanalysis.rst +++ /dev/null @@ -1,18 +0,0 @@ -streamline.postanalysis package -=============================== - -.. automodule:: streamline.postanalysis - :members: - :undoc-members: - :show-inheritance: - -Submodules ----------- - -.. toctree:: - :maxdepth: 4 - - streamline.postanalysis.dataset_compare - streamline.postanalysis.gererate_report - streamline.postanalysis.model_replicate - streamline.postanalysis.statistics diff --git a/docs/source/codedocs/streamline.postanalysis.statistics.rst b/docs/source/codedocs/streamline.postanalysis.statistics.rst deleted file mode 100644 index 5c148622..00000000 --- a/docs/source/codedocs/streamline.postanalysis.statistics.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.postanalysis.statistics module -========================================= - -.. automodule:: streamline.postanalysis.statistics - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.rst b/docs/source/codedocs/streamline.rst deleted file mode 100644 index 7ef52677..00000000 --- a/docs/source/codedocs/streamline.rst +++ /dev/null @@ -1,21 +0,0 @@ -streamline package -================== - -.. automodule:: streamline - :members: - :undoc-members: - :show-inheritance: - -Subpackages ------------ - -.. toctree:: - :maxdepth: 4 - - streamline.dataprep - streamline.featurefns - streamline.modeling - streamline.models - streamline.postanalysis - streamline.runners - streamline.utils diff --git a/docs/source/codedocs/streamline.runners.clean_runner.rst b/docs/source/codedocs/streamline.runners.clean_runner.rst deleted file mode 100644 index ee3ccdef..00000000 --- a/docs/source/codedocs/streamline.runners.clean_runner.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.runners.clean\_runner module -======================================= - -.. automodule:: streamline.runners.clean_runner - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.runners.compare_runner.rst b/docs/source/codedocs/streamline.runners.compare_runner.rst deleted file mode 100644 index a8d08590..00000000 --- a/docs/source/codedocs/streamline.runners.compare_runner.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.runners.compare\_runner module -========================================= - -.. automodule:: streamline.runners.compare_runner - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.runners.dataprocess_runner.rst b/docs/source/codedocs/streamline.runners.dataprocess_runner.rst deleted file mode 100644 index faecba12..00000000 --- a/docs/source/codedocs/streamline.runners.dataprocess_runner.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.runners.dataprocess\_runner module -============================================= - -.. automodule:: streamline.runners.dataprocess_runner - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.runners.eda_runner.rst b/docs/source/codedocs/streamline.runners.eda_runner.rst deleted file mode 100644 index 7f66f93f..00000000 --- a/docs/source/codedocs/streamline.runners.eda_runner.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.runners.eda\_runner module -===================================== - -.. automodule:: streamline.runners.eda_runner - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.runners.feature_runner.rst b/docs/source/codedocs/streamline.runners.feature_runner.rst deleted file mode 100644 index 295f961b..00000000 --- a/docs/source/codedocs/streamline.runners.feature_runner.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.runners.feature\_runner module -========================================= - -.. automodule:: streamline.runners.feature_runner - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.runners.model_runner.rst b/docs/source/codedocs/streamline.runners.model_runner.rst deleted file mode 100644 index 9f05215e..00000000 --- a/docs/source/codedocs/streamline.runners.model_runner.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.runners.model\_runner module -======================================= - -.. automodule:: streamline.runners.model_runner - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.runners.replicate_runner.rst b/docs/source/codedocs/streamline.runners.replicate_runner.rst deleted file mode 100644 index 503c6543..00000000 --- a/docs/source/codedocs/streamline.runners.replicate_runner.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.runners.replicate\_runner module -=========================================== - -.. automodule:: streamline.runners.replicate_runner - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.runners.report_runner.rst b/docs/source/codedocs/streamline.runners.report_runner.rst deleted file mode 100644 index 89bcbbd8..00000000 --- a/docs/source/codedocs/streamline.runners.report_runner.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.runners.report\_runner module -======================================== - -.. automodule:: streamline.runners.report_runner - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.runners.rst b/docs/source/codedocs/streamline.runners.rst deleted file mode 100644 index 5dbff4b4..00000000 --- a/docs/source/codedocs/streamline.runners.rst +++ /dev/null @@ -1,23 +0,0 @@ -streamline.runners package -========================== - -.. automodule:: streamline.runners - :members: - :undoc-members: - :show-inheritance: - -Submodules ----------- - -.. toctree:: - :maxdepth: 4 - - streamline.runners.clean_runner - streamline.runners.compare_runner - streamline.runners.dataprocess_runner - streamline.runners.eda_runner - streamline.runners.feature_runner - streamline.runners.model_runner - streamline.runners.replicate_runner - streamline.runners.report_runner - streamline.runners.stats_runner diff --git a/docs/source/codedocs/streamline.runners.stats_runner.rst b/docs/source/codedocs/streamline.runners.stats_runner.rst deleted file mode 100644 index 0ca0f768..00000000 --- a/docs/source/codedocs/streamline.runners.stats_runner.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.runners.stats\_runner module -======================================= - -.. automodule:: streamline.runners.stats_runner - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.utils.checker.rst b/docs/source/codedocs/streamline.utils.checker.rst deleted file mode 100644 index e464033d..00000000 --- a/docs/source/codedocs/streamline.utils.checker.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.utils.checker module -=============================== - -.. automodule:: streamline.utils.checker - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.utils.cleanup.rst b/docs/source/codedocs/streamline.utils.cleanup.rst deleted file mode 100644 index 2d627a25..00000000 --- a/docs/source/codedocs/streamline.utils.cleanup.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.utils.cleanup module -=============================== - -.. automodule:: streamline.utils.cleanup - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.utils.cluster.rst b/docs/source/codedocs/streamline.utils.cluster.rst deleted file mode 100644 index 260b8818..00000000 --- a/docs/source/codedocs/streamline.utils.cluster.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.utils.cluster module -=============================== - -.. automodule:: streamline.utils.cluster - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.utils.dataset.rst b/docs/source/codedocs/streamline.utils.dataset.rst deleted file mode 100644 index ab2ea488..00000000 --- a/docs/source/codedocs/streamline.utils.dataset.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.utils.dataset module -=============================== - -.. automodule:: streamline.utils.dataset - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.utils.evaluation.rst b/docs/source/codedocs/streamline.utils.evaluation.rst deleted file mode 100644 index 40d728f5..00000000 --- a/docs/source/codedocs/streamline.utils.evaluation.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.utils.evaluation module -================================== - -.. automodule:: streamline.utils.evaluation - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.utils.job.rst b/docs/source/codedocs/streamline.utils.job.rst deleted file mode 100644 index 1e82e565..00000000 --- a/docs/source/codedocs/streamline.utils.job.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.utils.job module -=========================== - -.. automodule:: streamline.utils.job - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.utils.parser.rst b/docs/source/codedocs/streamline.utils.parser.rst deleted file mode 100644 index 76217489..00000000 --- a/docs/source/codedocs/streamline.utils.parser.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.utils.parser module -============================== - -.. automodule:: streamline.utils.parser - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/codedocs/streamline.utils.rst b/docs/source/codedocs/streamline.utils.rst deleted file mode 100644 index f4d033a9..00000000 --- a/docs/source/codedocs/streamline.utils.rst +++ /dev/null @@ -1,22 +0,0 @@ -streamline.utils package -======================== - -.. automodule:: streamline.utils - :members: - :undoc-members: - :show-inheritance: - -Submodules ----------- - -.. toctree:: - :maxdepth: 4 - - streamline.utils.checker - streamline.utils.cleanup - streamline.utils.cluster - streamline.utils.dataset - streamline.utils.evaluation - streamline.utils.job - streamline.utils.parser - streamline.utils.runners diff --git a/docs/source/codedocs/streamline.utils.runners.rst b/docs/source/codedocs/streamline.utils.runners.rst deleted file mode 100644 index 61836c90..00000000 --- a/docs/source/codedocs/streamline.utils.runners.rst +++ /dev/null @@ -1,7 +0,0 @@ -streamline.utils.runners module -=============================== - -.. automodule:: streamline.utils.runners - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/conf.py b/docs/source/conf.py index 329c2059..00d124e6 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -1,64 +1,63 @@ -# Configuration file for the Sphinx documentation builder. -# -# This file only contains a selection of the most common options. For a full -# list see the documentation: -# https://www.sphinx-doc.org/en/master/usage/configuration.html +from __future__ import annotations -# -- Path setup -------------------------------------------------------------- - -# If extensions (or modules to document with autodoc) are in another directory, -# add these directories to sys.path here. If the directory is relative to the -# documentation root, use os.path.abspath to make it absolute, like shown here. -# import os import sys -sys.path.insert(0, os.path.abspath('../../')) - - -# -- Project information ----------------------------------------------------- - -project = 'STREAMLINE' -copyright = '2023, Ryan Urbanowicz, Harsh Bandhey' -author = 'Ryan Urbanowicz, Harsh Bandhey' - -# The full version, including alpha/beta/rc tags -release = '2' +repo_root = os.environ.get("STREAMLINE_DOCS_REPO_ROOT", os.path.abspath("../..")) +sys.path.insert(0, repo_root) -# -- General configuration --------------------------------------------------- +project = "STREAMLINE" +copyright = "2026, Ryan Urbanowicz, Harsh Bandhey" +author = "Ryan Urbanowicz, Harsh Bandhey" +release = "1.0.0" -# Add any Sphinx extension module names here, as strings. They can be -# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom -# ones. extensions = [ - 'sphinx.ext.autodoc', - 'sphinx.ext.viewcode', - 'sphinx.ext.napoleon' + "sphinx.ext.autodoc", + "sphinx.ext.autosummary", + "sphinx.ext.napoleon", + "sphinx.ext.viewcode", + "myst_parser", ] -extensions += ['myst_parser'] +autosummary_generate = True +autoclass_content = "both" +autodoc_member_order = "bysource" +autodoc_typehints = "description" myst_heading_anchors = 3 +source_suffix = { + ".rst": "restructuredtext", + ".md": "markdown", +} +root_doc = "index" + +templates_path = ["_templates"] +exclude_patterns = ["build", "Thumbs.db", ".DS_Store"] + +autodoc_mock_imports = [ + "catboost", + "dask", + "dask_jobqueue", + "fpdf", + "gplearn", + "graphviz", + "lightgbm", + "matplotlib", + "mlxtend", + "optuna", + "plotly", + "seaborn", + "skrebate", + "tqdm", + "xgboost", +] -source_suffix = ['.rst', '.md'] - -# Add any paths that contain templates here, relative to this directory. -templates_path = ['_templates'] - -# List of patterns, relative to source directory, that match files and -# directories to ignore when looking for source files. -# This pattern also affects html_static_path and html_extra_path. -exclude_patterns = [] -autoclass_content = 'both' - - -# -- Options for HTML output ------------------------------------------------- +try: + import sphinx_rtd_theme # noqa: F401 -# The theme to use for HTML and HTML Help pages. See the documentation for -# a list of builtin themes. -# -html_theme = 'sphinx_rtd_theme' + html_theme = "sphinx_rtd_theme" +except Exception: + html_theme = "alabaster" -# Add any paths that contain custom static files (such as style sheets) here, -# relative to this directory. They are copied after the builtin static files, -# so a file named "default. css" will overwrite the builtin "default.css". html_static_path = [] +html_logo = "pictures/STREAMLINE_Logo_NoText.png" +html_title = "STREAMLINE" diff --git a/docs/source/contributing.md b/docs/source/contributing.md index 71549d10..4bcadd07 100644 --- a/docs/source/contributing.md +++ b/docs/source/contributing.md @@ -1,109 +1,40 @@ # Contributing -We welcome you to [check the existing issues](https://github.com/UrbsLab/STREAMLINE/issues/) for bugs or enhancements to work on. -If you have an idea for an extension to STREAMLINE, please [file a new issue](https://github.com/UrbsLab/STREAMLINE/issues//new), -or email harsh.bandhey@cshs.org to discuss it. -*** -## Project Layout -The latest release of STREAMLINE is on the [main branch](https://github.com/UrbsLab/STREAMLINE/tree/main), -whereas the legacy/Beta 0.2.5 version of STREAMLINE is on the [legacy branch](https://github.com/STREAMLINE/tree/legacy). +Contributions are welcome, especially focused fixes, tests, documentation +improvements, and new registry-backed methods. -The in-development code is stored in the [development branch](https://github.com/STREAMLINE/tree/dev) -Make sure you are looking at and working on the correct branch if you're looking to contribute code. +## Before Opening A Pull Request -In terms of directory structure: +1. Start from `main` or the target release branch. +2. Keep changes scoped to the phase or feature being changed. +3. Add or update tests for behavior changes. +4. Update docs, configs, or notebooks when parameter names or user workflows change. +5. Run the relevant tests locally. -* All of STREAMLINE's code sources are in the `streamline` directory -* The documentation sources are in the `docs/source` directory -* Unit tests for STREAMLINE are in the `streamline/tests` module +## Useful Checks -Make sure to familiarize yourself with the project layout before making any major contributions. +```bash +pytest streamline/tests/test_complete_binary.py +pytest streamline/tests/test_complete_multiclass.py +pytest streamline/tests/test_complete_regression.py +sphinx-build -b html docs/source docs/build/html +``` -*** -## How to Contribute -The preferred way to contribute to STREAMLINE is to fork the -[main repository](https://github.com/UrbsLab/STREAMLINE/) on -GitHub: +## Documentation Contributions -1. Fork the [project repository](https://github.com/UrbsLab/STREAMLINE/): - click on the 'Fork' button near the top of the page. This creates - a copy of the code under your account on the GitHub server. +When updating docs: -2. Clone this copy to your local disk: +* Prefer current P1-P11 phase names. +* Keep config names, CLI names, and notebook names aligned. +* Avoid reintroducing outdated phase names. +* Update `sample_runcommands.txt` and `run_configs/` if examples change. - $ git clone git@github.com:YourLogin/STREAMLINE.git - $ cd STREAMLINE +## Reporting Bugs -3. Create a branch to hold your changes: +When reporting a bug, include: - $ git checkout -b my-contribution - -4. Make sure your local environment is set up correctly for development. Installation instructions are almost identical to [the user instructions](install.md) - - $ pip install -r requirements - -5. Start making changes on your newly created branch, remembering to never work on the ``main`` branch! Work on this copy on your computer using Git to do the version control. - -6. Once some changes are saved locally, you can use your tweaked version of STREAMLINE by navigating to the project's base directory and running STREAMLINE in a script. - -7. To check your changes haven't broken any existing tests and to check new tests you've added pass run the following (note, you must have the `pytest` package installed within your dev environment for this to work): - - $ pytest --log-cli-level=INFO - -8. When you're done editing and local testing, run: - - $ git add - $ git commit -m - - to record your changes in Git, then push them to GitHub with: - - $ git push -u origin my-contribution - -Finally, go to the web page of your fork of the STREAMLINE repo, and click 'Pull Request' (PR) to send your changes to the maintainers for review. Make sure that you send your PR to the `dev` branch, as the `main` branch is reserved for the latest stable release. This will start the CI server to check all the project's unit tests run and send an email to the maintainers. - -(For details on the above look up the [Git documentation](http://git-scm.com/documentation) on the web.) - -*** -## Before Submitting a Pull Request -Before you submit a pull request for your contribution, please work through this checklist to make sure that you have done everything necessary so we can efficiently review and accept your changes. - -If your contribution changes STREAMLINE in any way: - -* Update the [documentation](https://github.com/UrbsLab/STREAMLINE/tree/main/docs/source) so all of your changes are reflected there. - -* Update the [README](https://github.com/UrbsLab/STREAMLINE/blob/main/README.md) if anything there has changed. - -If your contribution involves any code changes: - -* Update the [project unit tests](https://github.com/UrbsLab/STREAMLINE/tree/main/streamine/tests) to test your code changes. - -* Make sure that your code is properly commented with [docstrings](https://www.python.org/dev/peps/pep-0257/) and comments explaining your rationale behind non-obvious coding practices. - -If your contribution requires a new library dependency: - -* Double-check that the new dependency is easy to install via `pip`. -* Add it to the `requirements.txt` file. - -*** -## Updating the Documentation -We use [sphinx](https://www.sphinx-doc.org/) to manage our [documentation](https://urbslab.github.io/STREAMLINE/). -This allows us to write the docs in Markdown and compile them to HTML as needed. -Below are a few useful tips/commands to know when updating the documentation. - -* Install additional documentation packages to generate documentation locally - - $ pip install sphinx sphinx_rtd_theme myst-parser - -* Edit/Add markdown or reST files in the `docs/source` folder. -* Each new added markdown or reST file needs to be added into the `toctree` in `docs/source/index.rst` file. - -* You can use the following command to creates a fresh build of the documentation in HTML. Always run this before deploying the documentation to GitHub. - - $ sphinx-build -b html docs/source docs/build/html -E -a - -*** -## After Submitting a Pull Request -After submitting your pull request, GitHub Actions will automatically run unit tests on your changes and make sure that your updated code runs. - -Check back shortly after submitting your pull request to make sure that your code passes these checks. -If any of the checks come back with a red X, then do your best to address the errors. \ No newline at end of file +* STREAMLINE branch or commit +* operating system and Python version +* command or config used +* traceback or warning output +* a minimal dataset/config example when possible diff --git a/docs/source/data.md b/docs/source/data.md index cc05dcab..466ff748 100644 --- a/docs/source/data.md +++ b/docs/source/data.md @@ -1,105 +1,91 @@ # Datasets -*** ## Input Data Requirements -Here we specify the formatting requirements for datasets when running STREAMLINE. -1. Dataset files are in comma-separated or tab-delimited format with the extension `.txt`, `.csv`, or `.tsv`. -2. Data columns should represent variables, and rows should represent instances (i.e. samples). -3. Any missing values in the dataset should be left blank (i.e. NaN) or indicated with the text 'NA'. - * Do not leave placeholder values for missing values such as 99, -99, or text other than 'NA'. -4. Dataset files should include a header that gives column names. -5. Data columns should only include the following (column order does not matter): - * Outcome/Class Label (i.e. the dependant variable) - column indicated by [`class_label`](parameters.md#class-label) - * Instance Label (i.e. unique identifiers for each instance/row in the dataset) \[Optional] - column indicated by [`instance_label`](parameters.md#instance-label) - * Match Label (i.e. an instance group identifier used to keep instances of the same group together during k-fold CV using the group stratification option) column indicated by [`match_label`](parameters.md#match-label) - * Features (i.e. independant variables) - all other columns in dataset are assumed to be features (except those excluded using [`ignore_features_path`](parameters.md#ignore-features-path)) -6. The outcome/class column includes only two possible values (i.e. a binary outcome) [Note: STREAMLINE will soon be expanded to allow for multi-class and quantiative outcomes] -7. If multiple target datasets are being analyzed they must each have the same [`class_label`](parameters.md#class-label) (e.g. `Class`), and (if present), the same [`instance_label`](parameters.md#instance-label) (e.g. 'ID') and [`match_label`](parameters.md#match-label) (e.g. 'Match_ID'). The same is true for any 'replication datasets' (if present) when using Phase 8. - -*** -### Additional Considerations -#### Specifying Feature Types -Users are strongly encouraged to specify which features should be treated as categorical or quantitative using [`quantitative_feature_path`](parameters.md#quantitative-feature-path) or [`categorical_feature_path`](parameters.md#categorical-feature-path), or setting the [`categorical_cutoff`](parameters.md#categorical-cutoff) to a value that will correctly assign feature types automatically (i.e. if all features in the dataset have 3 possible values and [`categorical_cutoff`](parameters.md#categorical-cutoff) is set to 4, all features would be treated as categorical). If multiple target datasets are being analyzed, then [`quantitative_feature_path`](parameters.md#quantitative-feature-path) or [`categorical_feature_path`](parameters.md#categorical-feature-path) should include the names of all features to be treated as categorical vs. quanatative across all datasets. - -#### Text-valued Features -STREAMLINE allows datasets to be loaded that have text-valued (i.e. non-numeric) entries. However be aware of how the pipeline will treat different columns: -* Outcome Label - if text, will be numerically encoded (0 or 1) based on alphabetical order -* Instance Label - is commonly non-numeric and is not changed by STREAMLINE -* Match Label - is commonly non-numeric and is not changed by STREAMLINE -* Features - if text, will be numerically encoded based on alphabetical order and will automatically be treated as categorical features (overriding any user specification with [`quantitative_feature_path`](parameters.md#quantitative-feature-path) or [`categorical_feature_path`](parameters.md#categorical-feature-path)) - -#### Previously Unseen Categorical Values in Replication Data -While 'new' unique values observed in the quantitative features of any replication data are not of concern, those in categorical features require some additional decisions, in particular when encoding categorical features with one-hot-encoding. For example, imagine there is a hypothetical feature in the dataset for 'hair color'. In the original target datset, values for this hypothetical categorical features include \[black, brown, blond, grey]. However a given replication dataset, also includes the previously unseen value of 'red' for that same feature. One-hot encoding normally creates a new column/feature for each categorical value, however a column for 'red' would not have existed in processed dataset, or any of the trained models. STREAMLINE addresses this in one of two ways in processing replication data. If the new unique value ocurrs in a categorical feature with... -1. More than two categories, one-hot-encoding does not add a new column to the dataset, and the value for each one-hot-encoded feature for that instance is set to 0 (e.g. not black, brown, blond, or grey). -2. Exactly two categories, one-hot-encoding does not add a new column to the dataset, and the values for each one-hot-encoded feature for that instance is set to 'missing-value', leaving value assignment to mode imputation. - -#### Binary Class Labels -STREAMLINE assumes that instances with class 0 are *negative* and those with class 1 are *positive* with respect to true positive, true negative, false positive, false negative metrics. This also impacts PRC plots, which focus on the classification of *positives*. Often, accurate prediction of the *positive* class is of greater interest than the *negative* class. Additionally, it is common in datasets for there to be a larger number of *negative* instances than *postitive* ones. - -*** -### Pre-STREAMLINE Data Processing -STREAMLINE seeks to automate many of the common elements of a machine learning data science pipeline, but every dataset and analysis can have it's own unique needs and challenges. While not required by STREAMLINE to run, we recommmend users consider if any of the following steps apply and should be conducted prior to running as they can impact model interpretation and conclusions. - -#### Text-valued Ordinal Features -Some features values in data may be encoded as text entries, but have a natural quantitative ordering to them (i.e. ordinal features), but the distances between these values is not known. Since STREAMLINE will automatically treat any text-valued features as categorical, users that wish to have these features treated quanatitatively should first numerically encode these features in the data with values that seem most appropriate given the feature and relevant domain experience. - -For example, a feature could be the answer to a survey question with the values {strongly disagree, weakly disagree, neutral, weakly agree, or strongly agree}. These might intuitively be encoded by the user as {0,1,2,3,4}, however another user may have reason to encode these values as {0,3,5,7,10}. - -#### Class Label Encoding -As indicated above, STREAMLINE will automatically numerically encode a text-based outcome value based on alphabetical order. However, this can break the assumption being made by STREAMLINE that class 0 is *negative* and class 1 is *positive* based on the given dataset and outcome values. - -For example, if the outcome values were 'negative' and 'positive', STREAMLINE would automatically, and correctly numerically encode them as 0 and 1, respectively. However if the outcome values were 'well' and 'sick', these would be encoded as 1 and 0, respectively. - -To avoid missinterpretation, we recommend users numerically encode class labels ahead of time based on their own needs for *negative* and *positive* lables. - -#### Outliers -Of note, outlier values within a feature or anomolous instances do not always reflect poor data quality, but may just reflect extreame true observations. As this aspect of data processing can not be reliably automated, we recommend users examine their data for possible outliers and remove them based on their own judgement prior to running STREAMLINE. This could involve replacing impossible feature value (e.g. age of 235 in a human) with a missing value, or removing entire instances from the dataset. - -#### Feature Extraction -STREAMLINE does not currently tackle any feature extraction aspects of data science. If your raw data is in an unstructured or non-tabular data format (e.g. images, video, time-series data, natural language text), we recommend looking into relevant approaches to create structured features from these data sources prior to running STREAMLINE. - -#### Feature Engineering -Traditionally, good feature engineering requires domain knowledge about the target problem or dataset. STREAMLINE automates a couple basic feature engineering elements, however we encourage users to consider other strategies to engineer features (in a manner that does not look at the outcome label). A simple example of this might be taking features representing start and end dates of a drug treatment and engineering a feature that indicates the time duration. - -#### Feature Transformation -While STREAMLINE uses a standard scalar to transform features in this pipeline, many other transformations are possible (for various reasons). Users that wish to apply these alternative transformations should do so before running STREAMLINE and then optionally turn of the standard scaling with [`scale_data`](parameters.md#scale-data). - -*** -## Demonstration Data -For demonstration and quick code-testing purposes, the STREAMLINE repository includes two small 'target datasets' that would be used in Phases 1-7, as well as a small 'replication dataset' that would be used in Phase 8. These datasets can be found in `./data/DemoData` and `./data/DemoRepData`, respectively. - -New users can easily run STREAMLINE on these datasets in whatever run-mode desired. Instructions for running STREAMLINE are given using this demo data as an example for each run-mode (see [here](running.md)). Details on each of the demonstration datasets are given below. - -*** -### Real-World HCC Dataset -The first demo dataset (`hcc_data.csv`) is an example of a real-world biomedical classification task. This is a [Hepatocellular Carcinoma (HCC)](https://archive.ics.uci.edu/dataset/423/hcc+survival) dataset taken from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/). It includes 165 instances, 49 features, and a binary class label. It also includes a mix of categorical and quantitative features (however all categorical features are binary), about 10% missing values, and class imbalance, i.e. 63 deceased (class = 1), and 102 survived (class 0). - -*** -### Custom Extension of HCC Dataset -The second demo dataset (`hcc_data_custom.csv`) is similar to the first, but we have made a number of modifications to it in order to test the data cleaning and feature engineering functionalities of STREAMLINE. - -Modifications include the following: -1. Removal of covariate features (i.e. 'Gender' and 'Age at diagnosis') -2. Addition of two simulated instances with a missing class label (to test basic data cleaning) -3. Addition of two simulated instances with a high proportion of missing values (to test instance missingness data cleaning) -4. Addition of three simulated, numerically encoded categorical features with 2, 3, or 4 unique values, respectively (to test one-hot-encoding) -5. Addition of three simulated, text-valued categorical features with 2, 3, or 4 unique values, respectively (to test one-hot-encoding of text-based features) -6. Addition of three simulated quantiative features with high missingness (to test feature missingness data cleaning) -7. Addition of three pairs of correlated quanatiative features (6 features added in total), with correlations of -1.0, 0.9, and 1.0, respectively (to test high correlation data cleaning) -8. Addition of three simulated features with (1) invariant feature values, (2) all missing values, and (3) a mix of invariant values and missing values. - -These simulated features and instances have been clearly identified in the feature names and instances IDs of this dataset. - -*** -### Simulated Replication Dataset -The last demo dataset (`hcc_data_custom_rep.csv`) was simulated as a mock replication dataset for `hcc_data_custom.csv`. To generate this dataset we first took `hcc_data_custom.csv` and for 30% of instances randomly generated realistic looking new values for each feature and class outcome (effectively adding noise to this data). Furthermore we simulated further instances that test the ability of STREAMLINE's one-hot-encoding to ignore new (as-of-yet unseen) categorical features values during STREAMLINE's replication phase. If this were to happen, the new value would be ignored (i.e. no new feature columns added). - -Modifications included adding a simulated instance that includes a new (as-of-yet unseen) value for the following previously simulated features: -1. The binary text-valued categorical feature -2. The 3-value text-valued categorical feature -3. The binary numerically encoded categorical feature -4. The 3-value numerically encoded categorical feature - -We also added a new, previously unseen feature value to each of the invariant feature columns. - -The code to generate the additional features and instances within the custom `hcc_data_custom.csv` and `hcc_data_custom_rep.csv` can be found in the notebook at `/data/Generate_Expanded_HCC_dataset.ipynb`. \ No newline at end of file + +STREAMLINE expects tabular supervised learning datasets. + +1. Use `.csv`, `.tsv`, or `.txt` files with a header row. +2. Rows are instances and columns are variables. +3. Include one outcome column specified by `outcome_label`. +4. Include an optional instance identifier column specified by `instance_label`. +5. Include optional feature-type files listing categorical and quantitative feature names. +6. Encode missing values as blank cells, `NA`, `NaN`, or `?`; avoid numeric placeholders such as `-99` unless they are real values. +7. Keep replication datasets aligned with the original dataset's feature names and outcome/instance labels. + +Recommended preparation before P1: + +* Remove free-text, image, raw time-series, or other unstructured columns unless you have already converted them to tabular features. +* Decide whether high-cardinality identifier-like fields should be `instance_label`, ignored, or removed before modeling. +* Check that the outcome column has the interpretation you expect. Binary labels should be documented so downstream metrics are not ambiguous. +* Keep a copy of the raw source data outside the STREAMLINE output directory. + +The current code supports: + +| Task | Example `outcome_type` | Notes | +| --- | --- | --- | +| Binary classification | `Binary` | Standard classification metrics, ROC, PRC, and calibration outputs. | +| Multiclass classification | `Multiclass` | Macro/micro summaries where applicable. | +| Regression | `Continuous` | Regression metrics and residual-style outputs. | + +## Feature Types + +You can provide feature type files through: + +```text +categorical_features = path/to/categorical_features.csv +quantitative_features = path/to/quantitative_features.csv +``` + +Each file should contain feature names, one per row or in a single column. If +feature type files are omitted, P1 can infer categorical features using +`categorical_cutoff`. + +Supplying feature-type files is recommended for real analyses because numeric +codes are common in biomedical and administrative data. A coded feature such as +`1`, `2`, `3` may be categorical even though it looks numeric to Python. + +### One-Hot Encoding And Native Categorical Models + +By default, P1 one-hot encodes non-binary categorical features. Set +`one_hot_encoding = False` when you want later models to handle raw categorical +columns directly. + +When `one_hot_encoding` is false, P6 only runs models listed in +`native_categorical_models` by default. Unsupported explicitly requested models +raise an error instead of silently changing the feature representation. + +## Included UCI Demo Datasets + +The repository includes deterministic 80:20 train/replication splits for three +UCI-derived demos: + +| Task | Training folder | Replication folder | Outcome | +| --- | --- | --- | --- | +| Binary classification | `data/UCIBinaryClassification` | `data/UCIRepBinaryClassification` | `Class` | +| Multiclass classification | `data/UCIMulticlassClassification` | `data/UCIRepMulticlassClassification` | `Class` | +| Regression | `data/UCIRegression` | `data/UCIRepRegression` | `MPG` | + +The demo sources are: + +* HCC survival: [UCI HCC Survival](https://archive.ics.uci.edu/dataset/423/hcc+survival) +* Student dropout and academic success: [UCI Predict Students' Dropout and Academic Success](https://archive.ics.uci.edu/dataset/697/predict+students+dropout+and+academic+success) +* Auto MPG: [UCI Auto MPG](https://archive.ics.uci.edu/dataset/9/auto+mpg) + +Feature type files for the demos live in `data/UCIFeatureTypes/`. + +The normal demo folders contain training/development splits. The matching +`UCIRep*` folders contain held-out replication splits created for STREAMLINE +demonstration and testing. + +## Replication Data + +Replication datasets are external validation inputs for P10. They are not +assumed to be official test splits from UCI. The included demo replication +folders are deterministic held-out 20% splits made to exercise P10 and +replication reporting. + +## Ignored Columns + +Identifier-like fields should be supplied as `instance_label` or ignored before +modeling. For Auto MPG, the car name is treated as an identifier-like field in +the demo preparation rather than a normal predictive feature. diff --git a/docs/source/development.md b/docs/source/development.md index a48c5a94..f4ab825b 100644 --- a/docs/source/development.md +++ b/docs/source/development.md @@ -1,148 +1,83 @@ -# Development Notes -This section summarizes the past, present, and future development of STREAMLINE. - -*** -## Release History - -### Current Release - Beta 0.3.4 (September 28, 2023) -#### Minor Updates -* Improved PDF report formatting to more clearly display first page, and account for having a larger number of datasets analyzed at once. -* Fixed edge case bug for running multiple separate replication and replication report phases in legacy mode. - - -### Beta 0.3.3 (September 22, 2023) -#### Major Updates -* Added a new data cleaning element - removal of invariant features. During C2 cleaning phase of data processing, features with only one value, only Nans or a mix of one value and Nan are removed from the dataset. This has been similarly updated for the replication phase, removing the same features that were removed during the original Phase 1 data cleaning. -#### Minor Updates -* Fix to algorithm ordering in figures within Jupyter notebook and Google Colab notebook run modes. -* Updated replication phase PDF report to simplify the data processing report -* Fixed handling of (as of yet) unseen values in binary categorical variables during replication phase. Now these are converted to Nans, since we can't introduce a new feature at this point (since it was not included in modeling) -* Fixed issue with naming of engineered missingness features -* Fixed issue with running STREAMLINE on cluster in legacy mode without specifying files for categorical or quantitative features. -* Updated text size on first page of PDF report - -### Beta 0.3.2 (September 13, 2023) -#### Minor Updates -* Fixed command line argument passage for legacy run mode of STREAMLINE -* Updated legacy run mode of STREAMLINE to submit jobs then end the script instead of waiting for those jobs to complete. -* Updated STREAMLINE schematic -* Updated naming of PDF summary file -* Added description of 'checking job status' in documentation. - -### Beta 0.3.1 (August 25, 2023) -#### Minor Updates -* Updated the replication phase to handle a special case where no missing value data imputation was conducted for a feature in the training data, but one or more missing values were present for that feature in the replication dataset. Now, when this occurs, a relevant simple imputation strategy is applied to estimate the replication data missing values. Mean imputation is used for quantitative features, and mode imputation is used for categorical features. Imputation operations are using the pandas `mean()` and `median()` function within `model_replicate.py`. -* The legends in all the plots including the Composite Feature Importance plots are now ordered alphabetically based on the full name of the models. - - -### Beta 0.3.0 (August 2023) -#### Major Updates -* Extended to be able to run in parallel on 7 different types of HPC clusters using `dask_jobqueue` as documented [here](https://jobqueue.dask.org/en/latest/api.html) -* Extended Phase 1 (previously EDA), to included numerical data encoding, automated data cleaning, feature engineering, and a second round of EDA: - * Added numerical encoding for any binary, text-valued features, with a map file `Numerical_Encoding_Map.csv` output to document this numerical mapping of original text-values - * Added [quantitative_feature_path](parameters.md#quantitative-feature_path) parameter in addition to [categorical_feature_path](parameters.md#categorical-feature_path) allowing users to indicate which features to treat as categorical vs. quantitative (or specify one list and all other features will be treated as the other type). New `.csv` output files are also generated to identify what features were treated as one feature type or the other after data processing. - * Added automated feature engineering of 'missingness' features to evaluate missingness as being predictive (assuming [MNAR](https://en.wikipedia.org/wiki/Missing_data)) along with [featureeng_missingness](parameters.md#featureeng-missingness) parameter to control this function. `Missingness_Engineered_Features.csv` is output to document what features were added to the processed dataset as a result. - * Added automated cleaning of features with high 'missingness'; with [cleaning_missingness](parameters.md#cleaning-missingness) parameter added to control this function. `Missingness_Feature_Cleaning.csv` is output to document what features were removed from the processed dataset as a result. - * Added automated cleaning of instances with high 'missingness'; with [cleaning_missingness](parameters.md#cleaning-missingness) parameter added to control this function. - * Added automated one-hot-encoding of all numerical and text-valued categorical features (with 3 or more values) so that they will be treated as such throughout all STREAMLINE phases. - * Added automated cleaning of highly correlated features (one feature randomly removed out of a highly correlated feature pair); with [correlation_removal_threshold](#correlation-removal-threshold) parameter added to control this function. `correlation_feature_cleaning.csv` is output to document what features were removed in this way. - * Added `DataProcessSummary.csv` output file to document changes in feature, feature type, instance, class, and missing value counts during each new cleaning/engineering step. - * Added a secondary EDA applied to the processed dataset, saved with separate output files to the 'initial' EDA. -* Adapted the 'replication' phase of STREAMLINE to process the replication data in the same way as the initial 'target dataset' ensuring that the same features are present. This accounts for any new 'as-of-yet' unseen values for categorical features that had previously been one-hot-encoded. -* Added ability to run the whole pipeline as a single command in the different command line run modes (i.e. from the command line locally or on an HPC). This includes the addition of a variety of new command-line specific run parameters. -* Added support for running STREAMLINE from the command line using a configuration file (in addition to commandline parameters) -* Modularize all ML modeling algorithms within classes, which adds the ability for users to (relatively easily) add other scikit-learn-compatible classification modeling algorithms to the STREAMLINE code-base by making a python file in `streamine/models/` based on the base model template. This allows code-savy users to easily add other algorithms we have not yet included, including their own. -* As a demonstration of the ability to add new ML algorithms in this way, we've added Elastic Net (EN) as the 16th ML algorithm included within STREAMLINE. -* Extended Google Colab Notebook to (1) automatically download the latest version of STREAMLINE, (2) offer separate 'Easy' and 'Manual' run modes for users to apply the notebook to their own data, where 'Easy' mode uses a prompt to gather essential run parameter information including a file navigation window to select the target dataset folder, (3) automatically download the output experiment folder and open the PDF summary reports on their screen (with user permission). - -#### Minor Updates -* Reverted back to using mean (rather than median) to present and sort model feature importances in plots (which was changed in Beta 0.2.4). This is to prevent confusion when running the notebook demos on the [demonstration datasets](data.md#demonstration-data), where using 3-fold CV yields median = 0 for all decision tree model feature importance scores which confuses picking and sorting the top features for plotting, as well as eliminates decision trees from the composite feature importance plots. We have added a hard-coded option to revert back to median ranking within the `fi_stats()` function within `statistics.py`. -* Updated repository folder hierarchy, filenames, and some outputfile names. -* Updated STREAMLINE phase groupings/numberings. -* Updated the STREAMLINE schematic figure to reflect all major changes and new phase grouping. -* Updated the feature correlation heatmap outputs: (1) color scheme used (for clarity), (2) view the non-redundant triangle vs. the full square (3) scale the feature names to avoid overlap, and don't show names at all when there are a large number of features (such that names would be unreadable) -* Feature correlation results are now also documented within `FeatureCorrelations.csv`. -* Reformatted the PDF output summary files to (1) add and re-organize all run parameters on the first page, (2) indicate the STREAMLINE version on the bottom of the page, and (3) include the new data processing/counts summary. -* Univariate analysis output files now include the test run and test score in addition to p-values. -* Updated the STREAMLINE Jupyter Notebook and other 'Useful Notebooks' to function with this new code framework. -* Created a new `hcc_data_custom.csv` dataset for the demo that adds simulated features and instances to `hcc_data.csv` to explicitly test (and demonstrate the functionality of) the new automatic data cleaning and engineering steps in STREAMLINE phase 1. Similarly created a replication dataset `hcc_data_custom_rep.csv` which adds some noise to `hcc_data_custom.csv` and some other custom additions to demonstrate replication functionality. The code to generate these 'custom' datasets from `hcc_data.csv` are included in the `data` folder as the notebook `Generate_expanded_HCC_Dataset`. - -*** -### Beta 0.2.5 (June 24, 2022) -* Added a minor additional catch to prevent statistical comparison results failure under specific situations. (in StatsJob.py and DataCompareJob.py) -* Cleaned up commented out old code - -### Beta 0.2.4 (June 15, 2022) -* Fix - Special case when running data with no missing data and imputation was 'True', apply model error when looking for non existent imputation file. Code fixed so that importing imputed file is in try/except loop to prevent fail. Also updated apply model so that both .csv and .txt replication data can be loaded. -* At recommendation of collaborator, switched from mean to median scores for feature importance figures. Also now outputs median algorithm performance summary, and adds median performance to pdf summary. Also now present median values in statistical significance output since this pairs more appropriately with non-parametric statistics than mean and standard deviation. - -### Beta 0.2.3 (May 19, 2022) -* Added fixes for (and confirmed functionality of) code to run STREAMLINE serially via the command line (in Linux - does not support Windows command line use). -* This release is considered stable and fully functional based on all tests and user feedback since the alpha release. We will make additional updates as needed for any other reported special case bugs/issues, as well as expand STREAMLINE further in future releases. - -### Beta 0.2.2 (May 19, 2022) -This latest Beta update addresses key functionality issues for running STREAMLINE serially from the command line, as well as a number of other minor functionality fixes and improvements. - -* Composite FI no longer fails when one algorithm used -* Composite FI plots now support weighting with both balanced accuracy and roc_auc -* Fixed major issues preventing running certain phases of STREAMLINE serially from command line -* Removed 'None' option for max features in feature selection -* Fixed pdf summary page 1 formatting issue -* Updated Optuna optimization for LR to avoid invalid hyperparameter combinations -* Enforced use of Optuna 2.0.0 for generating hyperparameter optimization figure generation, and added try catches to all algorithms so that STREAMLINE does not completely fail when there are lingering issues with Optuna versions in generating these figures. -* Updated notebooks accordingly - -### Beta 0.2.1 (May 17, 2022) -* Moved codebase into 'streamline' folder and updated code accordingly -* Updated default run parameters for Optuna -* Identified that STREAMLINE does not guarantee complete replicability (due to Optuna) when parallelized. -* Ensured replicability of cv data following scaling by rounding scaled data to 7 decimal places to avoid float rounding errors beyond the control of random seed fixing. - -### Beta 0.2.0 (May 14, 2022) -* After initial alpha testing with colleagues using different platforms and anaconda installations this first beta release of STREAMLINE has been demonstrated functional in all configurations tested. STREAMLINE is ready for external use, but it is still possible that there may be unforeseen issues run using configurations outside of those explicitly tested. Please let us know if you run into issues, noting the run mode, Anaconda version, and errors you are encountering so we can address such issues. - -* We plan to continue to expand and improve STREAMLINE, so we recommend users keep an eye out for new releases in the upcoming months, and update to the newest release whenever it's available. After much testing and application this software is believed to be ready for general use. If investigators apply this pipeline to research submitted for publication we ask that they check this repository for the newest STREAMLINE citation reference. We welcome investigators to reach out for assistance in using and interpreting STREAMLINE output in their research. We hope this tool will lead to many new collaborations and opportunities to publish new research. - -### Alpha 0.1.3 (May 12, 2022) -* Updated Readme installation instructions and default setting for model feature importance estimation. Code has been tested on the most recent Linux version of Anaconda. - -### Alpha 0.1.2 (May 12, 2022) -* Fix for Anaconda version issue regarding scipy in exploratory analysis. - -### Alpha 0.1.1 (May 12, 2022) -* Addressed upcoming scipy depreciation warning by replacing scipy.interp() with numpy.interp(). - -### Alpha Release (May 12, 2022) -* The first stable, bug-tested implementation of STREAMLINE. The bulk of the underlying code is inherited from AutoMLPipe-BC. This version has been demonstrated to operate properly only under the specific version of Anaconda, and the specified versions of other installed packages. It has not yet been tested on any MAC devices, only Windows and Linux. - -*** -## Planned Improvements - -### Known issues -* Repair probable bugs in eLCS and XCS ML modeling algorithms (outside of STREAMLINE). Currently, we have intentionally set both to 'False' by default, so they will not run unless user explicitly turns them on. -* Set up STREAMLINE to be able to run (as an option) through all phases even if some CV model training runs have failed (as an option). -* Optuna currently prevents a guarantee of reproducibility of STREAMLINE when run in parallel, unless the user specifies `None` for the `timeout` parameter. This is explained in the Optuna documentation as an inherent result of running Optuna in parallel, since it is possible for a different optimal configuration to be found if a greater number of optimization trials are completed from one run to the next. We will consider alternative strategies for running STREAMLINE hyperparameter optimization as options in the future. -* Optuna generated visualization of hyper-parameter sweep results fails to operate correctly under certain situations (i.e. for GP most often, and for LR when using a version of Optuna other than 2.0.0) It looks like Optuna developers intend to fix these issues in the future, and we will update STREAMLINE accordingly when they do. - -### Logistical extensions -* Set up code to be run easily on cloud computing options such as AWS, Azure, or Google Cloud. -* Set up option to use STREAMLINE within Docker. - -### Capabilities extensions -* Support multiclass and quantitative endpoints (in [development branch](https://github.com/STREAMLINE/tree/dev)): - * Requires significant extensions to most phases of the pipeline including exploratory analysis, CV partitioning, feature importance/selection, modeling, statistics analysis, and visualizations -* Shapley value calculation and visualizations -* Create ensemble model from all trained models which can then be evaluated on hold out replication data -* Expand available model visualization opportunities for model interpretation (i.e. Logistic Regression) -* Improve Catboost integration: - * Allow it to use internal feature importance estimates as an option - * Give it the list of features to be treated as categorical -* New code providing even more post-run data visualizations and customizations -* Clearly identify which algorithms can be run with missing values present, when user does not wish to apply [`impute_data`](parameters.md#impute-data) (not yet fully tested) -* Create a smarter approach to hyper-parameter optimization: (1) avoid hyperparameter combinations that are invalid (i.e. as seen when using Logistic Regression), (2) intelligently exclude key hyperparameters known to improve overall performance as they get larger, and apply a user defined value for these in the final model training after all other hyperparameters have been optimized (i.e. evolutionary algorithms such as genetic programming and ExSTraCS almost always benefit from larger population sizes and learning cycles. Given that we know these parameters improve performance, including them in hyperparameter optimization only slows down the process with little informational gain) - -### Algorithmic extensions -* Refinement of pre-configured ML algorithm hyperparameter options considered using Optuna -* Expanded feature importance estimation algorithm options and improved, more flexible feature selection strategy improving high-order feature interaction detection -* New rule-based machine learning algorithm (in development) +# Development +The refactored codebase is organized by pipeline phase. Each phase generally +contains: + +* a CLI module, for example `p6_cli.py` +* a runner module, for example `p6_runner.py` +* implementation modules and registries +* optional job-submission helpers for cluster modes + +## Source Layout + +```text +streamline/ + p1_data_process/ + p2_impute_scale/ + p3_feature_learning/ + p4_feature_importance/ + p5_feature_selection/ + p6_modeling/ + p7_ensembles/ + p8_summary_statistics/ + p9_compare_datasets/ + p10_replication/ + p11_reporting/ + pipeline/ + utils/ +``` + +## Adding Methods + +Prefer the existing registry patterns when adding new components: + +| Area | Location | +| --- | --- | +| Imputers/scalers | `streamline/p2_impute_scale/registry` | +| Feature learners | `streamline/p3_feature_learning/registry` | +| Feature importance methods | `streamline/p4_feature_importance/registry` | +| Feature selectors | `streamline/p5_feature_selection/registry` | +| Models | `streamline/p6_modeling/models` | +| Ensembles | `streamline/p7_ensembles/registry` | + +## Tests + +The default pytest configuration collects only the current main end-to-end +tests. Legacy and phase-level subtests were removed from the maintained v1.0.0 +test path so routine testing stays focused on the binary, multiclass, and +regression demo pipelines. + +Run one main test while developing: + +```bash +pytest streamline/tests/test_complete_binary.py +pytest streamline/tests/test_complete_multiclass.py +pytest streamline/tests/test_complete_regression.py +``` + +Run the default main suite when changing shared phase behavior: + +```bash +pytest +``` + +Run the optional TabPFN smoke test directly when changing TabPFN handling: + +```bash +pytest streamline/tests/subtests/tabpfn_smoke.py -q -rs +``` + +STREAMLINE supports Python 3.10 and newer. The CI pytest workflow exercises the +main suite on Python 3.10, 3.11, 3.12, and 3.13. + +## Documentation + +Build the docs locally with: + +```bash +pip install -r docs/requirements.txt +sphinx-build -b html docs/source docs/build/html +``` + +Keep examples synchronized with `run_configs/`, `sample_runcommands.txt`, and +the notebook parameter names. diff --git a/docs/source/index.rst b/docs/source/index.rst index c2c4f7c9..70a297a8 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -5,70 +5,148 @@ STREAMLINE Overview -------------------------------------- -STREAMLINE is an end-to-end automated machine learning (AutoML) pipeline -that empowers anyone to easily train, interpret, and apply a variety of predictive models as -part of a rigorous and optionally customizable data mining analysis. It is programmed in -Python 3 using many common libraries including `Pandas `_ -and `scikit-learn `_. -The schematic below summarizes the automated STREAMLINE analysis pipeline with individual elements organized into 9 phases. +STREAMLINE is an end-to-end automated machine learning pipeline for +supervised tabular data. The v1.0.0 main release supports binary classification, +multiclass classification, and regression, with integrated +data processing, imputation, scaling, feature learning, feature importance, +feature selection, model training, classification ensembles, summary +statistics, dataset comparison, replication, and PDF reporting. + +The schematic below summarizes the STREAMLINE v1.0.0 workflow. + +.. image:: pictures/STREAMLINE_v3_paper_new_lightcolor.png + :alt: STREAMLINE v1.0.0 automated machine learning pipeline overview + :width: 100% + +The repository is organized around eleven explicit phases: + +.. list-table:: + :header-rows: 1 + + * - Phase + - Name + - Purpose + * - P1 + - Data Process + - Load data, infer or apply feature types, run exploratory summaries, and create CV partitions. + * - P2 + - Impute and Scale + - Impute missing values, scale quantitative features, and optionally apply SMOTE/SMOTENC to training folds. + * - P3 + - Feature Learning + - Learn transformed features such as PCA components and record feature-learning manifests. + * - P4 + - Feature Importance + - Score features with filter-style feature-importance methods. + * - P5 + - Feature Selection + - Select reduced feature sets for downstream modeling. + * - P6 + - Modeling + - Train and evaluate base models with Optuna accounting and optional native categorical handling. + * - P7 + - Ensembles + - Train classification ensembles on top of base model predictions. + * - P8 + - Summary Statistics + - Aggregate metrics and summarize model and feature behavior. + * - P9 + - Compare Datasets + - Compare results across datasets within an experiment. + * - P10 + - Replication + - Apply trained workflows to external replication datasets. + * - P11 + - Reporting + - Generate standard and replication PDF reports. + +Recommended Starting Points +-------------------------------------- -.. image:: pictures/STREAMLINE_paper_new_lightcolor.png +* Use :doc:`install` if you are setting up a local environment. +* Use :doc:`running` if you want to run a demo immediately. +* Use :doc:`data` if you are preparing a custom dataset. +* Use :doc:`parameters` when editing a ``.cfg`` file or notebook parameter block. +* Use :doc:`output` after a run to find reports, metrics, figures, and saved models. -* We recommend reviewing this documentation to gain a deeper understanding of STREAMLINE with respect to it's overall design, what it includes, how it works, what it can be used for, and implementation highlights that differentiate it from other AutoML tools. +Quick Start +-------------------------------------- -* Start with a simple demonstration of STREAMLINE on example biomedical data in our ready-to-run in a Google Colab Notebook `here `_. +For most users, the easiest local route is: -Current Limitations -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -* At present, STREAMLINE is limited to supervised learning on tabular, binary classification data. We are currently expanding STREAMLINE to multi-class and regression outcome data. +.. code-block:: bash -* STREAMLINE also does not automate feature extraction from unstructured data (e.g. text, images, video, time-series data), or handle more advanced aspects of data cleaning or feature engineering that would likely require domain expertise for a given dataset. + conda create -n streamline python=3.11 pip + conda activate streamline + pip install -r requirements.txt + python run.py -c run_configs/uci_binary_hcc.cfg --dry_run + python run.py -c run_configs/uci_binary_hcc.cfg -* As STREAMLINE is currently in its 'beta' release, we recommend users first check that they have downloaded the most recent release of STREAMLINE before use. We are actively updating this software as feedback is received. +The notebooks expose the same major settings as the config files and are a +better starting point for interactive tutorials, Colab demos, and custom data +exploration. -Disclaimer +How This Documentation Is Organized -------------------------------------- -We make no claim that this is the best or only viable way to assemble an ML analysis pipeline for a given classification -problem, nor that the included ML modeling algorithms will yield the best performance possible. -We intend many expansions/improvements to this pipeline in the future. We welcome feedback, suggestions, and contributions for improvement. -Contact +* Use :doc:`install` to prepare a local environment. +* Use :doc:`data` to format custom datasets and understand the included UCI demos. +* Use :doc:`running` for notebooks, config-driven runs, and phase-by-phase CLI commands. +* Use :doc:`parameters` when editing ``.cfg`` files or command-line calls. +* Use :doc:`output` to navigate experiment folders and reports. +* Use :doc:`pipeline` for a phase-by-phase explanation of what STREAMLINE does. +* Use :doc:`changelog` to understand how v1.0.0 differs from v0.3.4 and v0.2.5. + +Version History -------------------------------------- -We welcome ideas, suggestions on improving the pipeline, `code-contributions `_, and collaborations! -For general questions, or to discuss potential collaborations (applying, or extending STREAMLINE); contact Ryan Urbanowicz at ryan.urbanowicz@cshs.org. +This site documents the STREAMLINE v1.0.0 main release. See +:doc:`changelog` for the v1.0.0, v0.3.4, and v0.2.5 release-line summary. + +Current Scope +-------------------------------------- -For questions on the code-base, installing/running STREAMLINE, report bugs, or discuss other troubleshooting issues; contact Harsh Bandhey at harsh.bandhey@cshs.org. +STREAMLINE is intended for supervised learning on tabular datasets. It does +not automate feature extraction from unstructured data such as free text, +images, audio, video, or raw time-series streams. Regression runs should skip +P7 because the current ensemble registry is classification-only. -Acknowledgements +Disclaimer +-------------------------------------- + +STREAMLINE assembles a practical, reproducible machine learning workflow, but +it is not a guarantee that the included preprocessing choices, models, or +metrics are optimal for every scientific question. Users should still review +input data quality, feature definitions, leakage risk, metric choice, and +domain-specific interpretation. + +Contact -------------------------------------- -The development of STREAMLINE benefited from feedback across multiple biomedical research collaborators at the University of Pennsylvania, Fox Chase Cancer Center, Cedars Sinai Medical Center, and the University of Kansas Medical Center. -The bulk of the coding was completed by Ryan Urbanowicz, Robert Zhang and Harsh Bandhey. Special thanks to -Yuhan Cui, Pranshu Suri, Patryk Orzechowski, Trang Le, Sy Hwang, Richard Zhang, Wilson Zhang, -and Pedro Ribeiro for their code contributions and feedback. -We also thank the following collaborators for their feedback on application -of the pipeline during development: Shannon Lynch, Rachael Stolzenberg-Solomon, -Ulysses Magalang, Allan Pack, Brendan Keenan, Danielle Mowery, Jason Moore, and Diego Mazzotti. +For general questions and collaborations, contact Ryan Urbanowicz at +``ryan.urbanowicz@cshs.org``. +For codebase, installation, running, troubleshooting, and implementation +questions, contact Harsh Bandhey at ``harsh.bandhey@cshs.org``. .. toctree:: :maxdepth: 2 :hidden: :caption: Table of Contents: - self about + changelog pipeline data install + tabpfn_token running parameters output + tips more development contributing citation - modules diff --git a/docs/source/install.md b/docs/source/install.md index a27eea70..b566fbaf 100644 --- a/docs/source/install.md +++ b/docs/source/install.md @@ -1,98 +1,110 @@ # Installation -Installation instructions for different run modes of STREAMLINE. -*** -## Google Colab Notebook -No installation is required to run STREAMLINE in the included Google Colab Notebook. The only other step is to make sure that you have a Google account (free) and click the link below: +STREAMLINE can be run from Google Colab, a local notebook, or the command +line. Local command-line and notebook use should be done from the repository +root so Python can import the `streamline` package. -[https://colab.research.google.com/drive/14AEfQ5hUPihm9JB2g730Fu3LiQ15Hhj2?usp=sharing](https://colab.research.google.com/drive/14AEfQ5hUPihm9JB2g730Fu3LiQ15Hhj2?usp=sharing) +## Google Colab -*** -## Local Installation -The instructions below are for installing STREAMINE locally in order to run it either in the included Jupyter Noteook or from the command line. +No local installation is required for Colab. Open the current notebook and run +the setup cells: -### Prerequisites -First, be sure to install or confirm previous installation of the following prerequisites. +[Open the STREAMLINE Colab notebook](https://colab.research.google.com/drive/1ByQuU805GzDGAAGzbUYz8wahnOTUuzvg?usp=sharing) -#### Git -Install git (if not already installed). +The notebook clones the repository with `--depth 1`, installs requirements, +and exposes a parameter block for binary, multiclass, regression, and custom +dataset runs. -* You can test for an existing installation by typing `git` in your command-line. +## Local Conda Environment -* Git installation instructions can be found [here](https://github.com/git-guides/install-git). +The recommended local setup is a dedicated conda environment: -#### Anaconda -We recommend installing the most recent stable version of Anaconda3 appropriate for your operating system (if not already installed) which automatically includes Python3 and a number of other common packages used by STREAMLINE (e.g. pandas, scikit-learn, etc.). Python3 is the most essential prerequisite here. Additional required Python packages will automatically be installed by the installation commands (below). +STREAMLINE supports Python 3.10 and newer. Python 3.11 is the recommended +default for local demos because it works well across the current scientific +Python stack while remaining close to common notebook runtimes. -* You can test for an existing installation by typing `conda` on your command-line. -* Anaconda installation instructions can be found [here](https://docs.anaconda.com/anaconda/install/index.html) -* If you already have Anaconda installed, we recommend updating conda and anaconda (as follows) prior to running STREAMLINE to avoid downstream module/environment errors +```bash +git clone --single-branch https://github.com/UrbsLab/STREAMLINE.git +cd STREAMLINE +conda create -n streamline python=3.11 pip +conda activate streamline +conda install pytorch=2.6 -y +pip install -r requirements.txt ``` -conda update conda -conda update anaconda + +Then confirm that the config runner is available: + +```bash +python run.py --help ``` -While STREAMLINE can run on native Python3, this is not generally recomended, since issue resolution becomes complex, especially in MacOS based systems. +TabPFN is optional and is not required for the default STREAMLINE demos. Install +it separately with `pip install tabpfn` before running TabPFN models. TabPFN +also requires a Prior Labs token before model weights can be downloaded; see +[TabPFN Token Setup](tabpfn_token.md). -### Installation Commands -After confirming that you have the prerequisites above, navigate to the directory where you want to save STREAMLINE, and use the following commands in the command-line terminal: +## Local venv Environment -``` -git clone --single-branch https://github.com/UrbsLab/STREAMLINE +A standard Python virtual environment also works: + +```bash +git clone --single-branch https://github.com/UrbsLab/STREAMLINE.git cd STREAMLINE +python -m venv .venv +source .venv/bin/activate +pip install --upgrade pip pip install -r requirements.txt ``` -The above 3 commands do the following: -1. Download the most recent release repository of STREAMLINE -2. Navigate to the root STREAMLINE directory from where the package can run -3. Install all other packages required to run STREAMLINE on the local system (see `requirements.txt` for the complete list of these packages) - -Now the STREAMLINE package can be run from the STREAMLINE root directory. +## Building The Documentation -#### Troubleshooting -If you see errors or warnings when running the above commands, this may indicate that the required packages might not be installing properly, which may prevent STREAMLINE from running to completion. We recommend always testing the STREAMLINE installation first by [running](running.md) it (in the desired [run mode](running.md#picking-a-run-mode)) on the [demonstration](sample.md#demonstration-data) data with included/example default run parameters. Issues related to installation will be evident if you get 'module' related errors when running STREAMLINE. This is most likely to happen if you are working from a previous installation of Anaconda, and you should update both `conda` and `anaconda` first and then retry the commands above. +Install the docs-only packages and run Sphinx: -### Jupyter Notebook -If you with to run STREAMLINE using the included Jupyter Notebook, additionally do the following: +```bash +pip install -r docs/requirements.txt +sphinx-build -b html docs/source docs/build/html +``` -1. Make sure the jupyter package is installed using the following command: - ``` - pip install jupyter - ``` -2. Run Jupyter Notebook using the command `jupyter notebook` -3. Within the web page that opens, navigate into the saved STREAMLINE folder and open the `STREAMLINE-Notebook.ipynb` file. +The generated site opens from: -For more information on Jupyter Notebook, click [here](https://jupyter.org/). +```text +docs/build/html/index.html +``` -*** -## Cluster Installation -STREAMLINE installation for a CPU computing cluster (i.e. HPC) is essentially the same as for local installation, but may include extra steps or troubleshooting based on your HPC setup. As for local installation, generally within your cluster home/working directory, you'll want to install Git, Anaconda (with Python3), and use the installation commands to download STREAMLINE and other required Python packages. +## Local Jupyter -### Cluster Compatability -We have set up STREAMLINE to be able to able to run on 7 different types of HPC clusters using `dask_jobqueue` including [LSF, SLURM, PBS, OAR, Moab, SGE, HTCondor] as documented [here](https://jobqueue.dask.org/en/latest/api.html). To date we have explicitly tested STREAMLINE only on LSF and SLURM clusters. +Install Jupyter if it is not already available: -### Additional Tools -Here we recommend additional tools that may help in running big jobs across all STREAMLINE phases, from a single command. These tool include terminal emulators like `tmux` and `screen` and terminal text editors like `nano` and `vim`. In most likelihood these would already be installed in your cluster or available as modules in your cluster. +```bash +pip install jupyter +jupyter notebook +``` -#### Terminal Emulators -A terminal emulator is particularly important when you want to run all phases of STREAMLINE automatically from a single command. To achieve this, STREAMLINE runs a script on the head node (i.e. job submission node) that monitors phase completion and submits new jobs for the next phase. Typically, closing your terminal would interupt this process. +Open `STREAMLINE_Notebook.ipynb` from the repository root. The notebook keeps a +parameter block at the top so the same notebook can run binary, multiclass, +regression, or custom datasets. -Terminal emulator programs allow you to create several "pseudo terminals" from a single terminal. They decouple your programs from the main terminal, protecting them from accidentally disconnecting. You can detach `tmux` or `screen` from the login terminal, and all your programs will continue to run safely in the background. Later, we can reattach them to the same or a different terminal to monitor the process. +## Cluster Notes -These are also very useful for running multiple programs with a single connection, such as when you're remotely connecting to a machine using Secure Shell (SSH). +Cluster use is environment-specific. The phase CLIs and config runner accept +`run_cluster` settings such as `Serial`, `Local`, `Parallel`, `BashSLURM`, and `BashLSF` +depending on phase support. For long runs, use a persistent terminal session +such as `tmux` or `screen` so orchestration is not interrupted if your SSH +connection drops. -We recommend using `tmux` as a terminal emulator. A quick guide on using it can be found [here](https://www.redhat.com/sysadmin/introduction-tmux-linux). +## Known Installation Issues -#### Terminal Text Editors -Terminal text editors are simple text editor programs that allow you to edit files through the terminal. These are particularly useful here for quickly editing the configuration file that specifies all STREAMLINE run parameters for running all phases from a single command. +Some modeling and reporting packages include compiled dependencies. On macOS, +especially on Apple Silicon or fresh Conda environments, install the compiled +pieces through conda-forge first if pip reports build, linker, Graphviz, or +WeasyPrint errors: -We recommend using `nano` as a text editor. A quick guide on using it can be found [here](https://www.hostinger.com/tutorials/how-to-install-and-use-nano-text-editor) +```bash +conda install -c conda-forge lightgbm xgboost catboost -y +conda install -c conda-forge graphviz python-graphviz -y +conda install -c conda-forge weasyprint cairocffi cairo pango gdk-pixbuf libffi -y +pip install -r requirements.txt +``` -*** -## Known Installation Issues -1. Scipy version error, the way the STREAMLINE is set up it needs scipy>=1.8.0. If you find this is not true or - get a version error output, please run `pip install --upgrade scipy` -2. The lightgbm package on pypi doesn't work out of the box using pip on MacOS. The following command should solve the problem: - ```conda install -c conda-forge lightgbm``` -3. The most recent skrebate package (0.7) does not install correctly with the standard `pip install skrebate` command, however it does with `pip install skrebate==0.7`. \ No newline at end of file +If the failure is isolated to one package, install only that package from +conda-forge and rerun `pip install -r requirements.txt`. diff --git a/docs/source/modules.rst b/docs/source/modules.rst deleted file mode 100644 index 822be2a4..00000000 --- a/docs/source/modules.rst +++ /dev/null @@ -1,16 +0,0 @@ -Code Documentation -================================= - -Each of the Phases in the research architecture is -divided into a packages within streamline which can be run independently -or run together using the runners package. - -The API documentation for each of them is given below for complementing further -development with STREAMLINE. - -========== - -.. toctree:: - :maxdepth: 4 - - codedocs/streamline diff --git a/docs/source/more.md b/docs/source/more.md index c226624d..df9b3339 100644 --- a/docs/source/more.md +++ b/docs/source/more.md @@ -1,105 +1,17 @@ -# Doing More with STREAMLINE -Before, or after running STREAMLINE, there are a number of things a user can do to get even more out of this framework and it's main phases. +# Additional Resources -*** -## Useful Notebooks -Included in the STREAMLINE repository is the folder `UsefulNotebooks` containing a variety of Jupyter Notebooks, each designed to work with an 'experiment' folder containing the output of a STREAMLINE run. As an overview, these notebooks are designed to: -1. Regenerate key plots based on user specifications -2. Reporting model prediction probabilities for testing and replication dataset instances -3. Generate additional figures, including: - * A feature imporance rank heatmap - * Model vizualizations for decision tree and genetic programming models -4. Examining the impact of using decision thresholds other than the default 0.5. -5. Run a complete training data evaluation of all models. +## Included Files -Below we detail what each of these notebooks do (in alphabetical order): -* `DecisionThreshold_Interactive.ipynb`: allow users to interactively examine different decision thresholds for a target model, and see how this new threshold impacts confusion matrix metrics (i.e. TP, TN, FP, FN). -* `DecisionThreshold_TestEval.ipynb`: allow users to (1) re-evaluate all trained models on the respective testing datasets using a decision threshold other than the default 0.5, (2) re-generate metric evaluation boxplots comparing algorithm performance using this new decision threshold, and (3) re-run statistical significance analyses comparing algorithm performance using this new decision threshold. -* `DecisionThreshold_TrainEval.ipynb`: allow users to (1) re-evaluate all trained models on respective training datasets using the standard decision threshold of 0.5 or some other threshold, (2) re-generate metric evaluation boxplots comparing algorithm performance using this new decision threshold, and (3) re-run statistical significance analyses comparing algorithm performance using this new decision threshold. -* `GenPlots_CompositeFI.ipynb`: allow users to generate custom variations of the composite feature importance plots. -* `GenPlots_FI_Heatmap.ipynb`: allow users to generate an interactive html visualization of ranked feature importance estimates across algorithms. -* `GenPlots_ROC_PRC.ipynb`: allow users to generate (1) ROC and PRC plots for each algorithm (over all CV partitions) if this function was previously turned off in the pipeline, (2) all ROC and PRC plots with the legend inside the plot rather than to the upper right, and (3) allow code-savy users to easily modify this notebook to regenerate these plots to their own specifications. -* `ModelViz_DT_GP.ipynb`: allow users to generate a direct visualization of the models generated by algorithms that create directly interpretable models (i.e. decision tree, and genetic programming). -* `PredictionProbs_Replication.ipynb`: will generate model (class 1) prediction probabilities for instances of respective replication dataset. -* `PredictionProbs_Test_EvalMetricAccess.ipynb`: will (1) show users how to access all model evaluation metrics from internal pickle files, and (2) generate model (class 1) prediction probabilities for instances of the respective testing dataset. +| File or folder | Purpose | +| --- | --- | +| `README.md` | High-level current project overview. | +| `sample_runcommands.txt` | Command cookbook for config and phase CLI runs. | +| `run_configs/` | Editable UCI demo `.cfg` files. | +| `STREAMLINE_Notebook.ipynb` | Local Jupyter workflow. | +| `STREAMLINE_ColabNotebook.ipynb` | Colab-oriented workflow. | +| `usefulnotebooks/` | Post-run analysis and visualization notebooks. | +| `data/UCI_DemoDatasets_README.md` | Demo dataset source and preparation notes. | -* *Note: Users can run these notebooks 'as-is' if they ran the demo code for the [demonstration datasets](data.md#demonstration-data), or they can modify the notebook parameters to run on a different experiment folder, or change the notebook code to further customize their output.* +## Version History -*** -## Updating Modeling Algorithm Hyperparameter Options -The hard-coded range of hyperparameter options and their value options/ranges for each algorithm can be found within `streamline/modeling/parameters.py`. -Code-savy users can adjust these value option/ranges for each ML algorithm if desired. However if you do so, and publish results of running STREAMLINE we stongly recommend indicating this or any other code changes for reproducibility. - - -*** -## Adding New Modeling Algorithms - -New models can easily be added to STREAMLINE by creating a custom class -and wrapping it as warped class derived form the STREAMLINE `BaseModel` with -specific information such as name, plot colors and hyper parameters for the sweep. - -An example wrapped code is given below. This is also given as file in the -info directory of the github [here](https://github.com/UrbsLab/STREAMLINE/blob/main/docs/source/elastic_net.py) - - -``` -from abc import ABC -from streamline.modeling.basemodel import BaseModel -from sklearn.linear_model import SGDClassifier as SGD - - -class ElasticNetClassifier(BaseModel, ABC): - model_name = "Elastic Net" - small_name = "EN" - color = "aquamarine" - - def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', - metric_direction='maximize', random_state=None, cv=None, n_jobs=None): - super().__init__(SGD, "Elastic Net", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = {'penalty': ['elasticnet'], 'loss': ['log_loss', 'modified_huber'], 'alpha': [0.04, 0.05], - 'max_iter': [1000, 2000], 'l1_ratio': [0.001, 0.1], 'class_weight': [None, 'balanced'], - 'random_state': [random_state, ]} - self.small_name = "EN" - self.color = "aquamarine" - self.n_jobs = n_jobs - - def objective(self, trial, params=None): - self.params = {'penalty': trial.suggest_categorical('penalty', self.param_grid['penalty']), - 'loss': trial.suggest_categorical('loss', self.param_grid['loss']), - 'alpha': trial.suggest_float('alpha', self.param_grid['alpha'][0], - self.param_grid['l1_ratio'][1]), - 'max_iter': trial.suggest_int('max_iter', self.param_grid['max_iter'][0], - self.param_grid['max_iter'][1]), - 'l1_ratio': trial.suggest_float('l1_ratio', self.param_grid['l1_ratio'][0], - self.param_grid['l1_ratio'][1]), - 'class_weight': trial.suggest_categorical('class_weight', self.param_grid['class_weight']), - 'random_state': trial.suggest_categorical('random_state', self.param_grid['random_state'])} - - mean_cv_score = self.hyper_eval() - return mean_cv_score -``` - -This .py file can be kept in the `streamline/models` folders and it will be automatically picked up by the STREAMLINE -pipeline dynamically - -To make your own model make an arbitrarily named Class Derived form the `BaseModel` class in STREAMLINE. - -The base class should be given it's own - -* `model_name` -* `small_name` -* `color` -* `param_grid` - -And initialized with an sklearn compatible model class such as `SGD` here. - -The init and super class init parameters should be the same as above. - -An objective function should also be written for optuna such that all the parameters are suggested -through an optuna trial. All the parameters should be suggested in a proper form using the most proper -type of the variable and the proper function in the API documentation of -Trial as described [here](https://optuna.readthedocs.io/en/stable/reference/generated/optuna.trial.Trial.html) - -Specifically we want to correctly parameters should be categorical, integer, or -discrete or continuous in linear or log domain and their ranges. -The parameters that go in these functions should be what is defined in the param_grid variable. +See [Changelog](changelog.md) for the v1.0.0, v0.3.4, and v0.2.5 release-line summary. diff --git a/docs/source/output.md b/docs/source/output.md index 9d36bfd6..811ed6c8 100644 --- a/docs/source/output.md +++ b/docs/source/output.md @@ -1,210 +1,102 @@ -# Navigating STREAMLINE Output -This section covers the different outputs generated by STREAMLINE. The sections below will use the demo run of STREAMLINE on two [demonstration datasets](data.md#demonstration-data) as a specific example for navigating the output files generated. - -*** -## Notebooks -During or after the notebook runs, users can inspect the individual code and text (i.e. markdown) cells of the notebook. Individual cells can be collapsed or expanded by clicking on the small arrowhead on the left side of each cell. The first set of cells include basic notebook instructions and then specify all run parameters (which a user can edit direclty within the notebook). Later cells run the underlying STREAMLINE code for up to 9 phases, plus output folder cleaning (and downloading output files in the case of the Colab Notebook). - -These later code cells will automatically display many of the notifications, results, and output figures generated by STREAMLINE. - -As mentioned, the Google Colab notebook will automatically download the output folder as a zipped folder, as well as automatically open the testing and replication PDF reports on your computer. Users can then extract this downloaded output folder and view all individual output files arranged into analysis subdirectories. You can also view output files in Google Colab by opening the file-explorer pane on the left side of the notebook. - -*** -## Experiment Folder (Hierarchy) -After running STREAMLINE you will find the 'experiment folder' (named by the [`experiment_name`](parameters.md#experiment-name) parameter) saved to folder specified by [`output_path`](parameters.md#output-path). In the Colab Notebook demo, this would be `/content/DemoOutput/demo_experiment/`. - -Opening the above experiment folder you will find the following folder/file hierarchy: -* `DatasetComparisons` - all statistical significance results and plots for comparing modeling performance across multiple 'target datasets' run - * `dataCompBoxplots` - all data comparison boxplots -* `hcc_data` - all output specific to the first 'target dataset' analyzed - * `CVDatasets` - copies of all training and testing datasets in .csv format (as well as intermediate files if [`overwrite_cv`](parameters.md#overwrite-cv) = `False`) - * `exploratory` - all phase 1 exploratory data analysis (EDA) output, files at this level are post-processed EDA output - * `initial` - all pre-processed EDA output - * `univariate_analyses` - all univariate analysis results and plots - * `feature_selection` - all phase 3 & 4 output (feature importance estimation and feature selection) - * `multisurf` - MultiSURF scores and a summary figure - * `mutual_information` - mutual information scores and a summary figure - * `model_evaluation` - all model evaluation output (phase 6) - * `feature_importance` - all model feature importance estimation scores and figures - * `metricBoxplots` - all evaluation metric boxplots comparing algorithm performance - * `pickled_metrics` - all evaluation metrics pickled separately for each algorithm and CV dataset combo - * `statistical_comparisons` - all statistical significance results comparing algorithm performance - * `models` - all model output (phase 5), including pickled model objects and selected hyperparameter settings for each algorithm and CV dataset combo - * `pickledModels` - all models saved as pickled objects - * `scale_impute` - all trained imputation and scaling maps saved as pickled objects -* `hcc_data_custom` - contains all output specific to the second 'target dataset' analyzed - * *Has the same folder hierarchy as `hcc_data` above with the addition of a `replication` folder* - * `replication` - all phase 8 (i.e. replication) output for the second 'target dataset' analyzed - * `hcc_data_custom_rep` - all replication output for the this specific 'replication dataset' (in this demo there was only one) - * `exploratory` - all exploratory data analysis (EDA) output for this 'replication dataset', files at this level are post-processed EDA output - * `initial` - all pre-processed EDA output for this 'replication dataset' - * `model_evaluation` - all model evaluation output for this 'replication dataset' - * `metricBoxplots` - all evaluation metric boxplots comparing algorithm performance for this 'replication dataset' - * `pickled_metrics` - all evaluation metrics pickled separately for each algorithm and CV dataset combo (for this 'replication dataset') - * `statistical_comparisons` - all statistical significance results comparing algorithm performance (for this 'replication dataset') -* `jobs` - contains cluster job submission files *(empty if output 'cleaning' applied)* -* `jobsCompleted` - contains cluster checks for job completion *(empty if output 'cleaning' applied)* -* `logs` - contains cluster job output and error logs *(empty if output 'cleaning' applied)* - -Notice that the folders `hcc_data` and `hcc_data_custom` have similar contents, but represent the analysis for each 'target' dataset run at once with STREAMLINE. If a user were to include 4 datasets in the folder specified by the [`dataset_path`](parameters.md#dataset-path) parameter (each conforming to the [Input Data Requirements](data.md#input-data-requirements)) they would find 4 respective folders in their experiment fold, each named after a respective dataset. - -*** -## Output File Details -This section will take a deeper dive into the individual output files within an experiment folder. - -### PDF Report(s) -#### Testing Evaluation Report -When you first open the experiment folder, you will find the file `demo_experiment_ML_Pipeline_Report.pdf`. This is an automatically formatted PDF summarizing key findings during the model training and evaluation. It conveniently documents all STREAMLINE run parameters, and summarizes key results for data processing, processed data EDA, model evaluation, feature importance, algorithm comparisons, dataset comparisons, and runtime. - -#### Replication Evaluation Report -A simpler 'replication report' is generated for each 'replication dataset' applied to the models trained by a single 'target dataset'. You can find the demo replication report at the following path: `/demo_experiment/hcc_data_custom/replication/hcc_data_custom_rep/demo_experiment_ML_Pipeline_Replication_Report.pdf`. This report differs from the testing evaluation report in that it excludes the following irrelevant elements: (1) univariate analysis summary, (2) feature importance summary, (3) dataset comparison summary, and (4) runtime summary. - -### Experiment Meta Info -When you first open the experiment folder, you will also find `algInfo.pickle` and `metadata.pickle` which are used internally by STREAMLINE across most phases, as well as by the 'Useful Notebooks', covered in [Doing More with STREAMLINE](more.md#doing-more-with-streamline). - -### DatasetComparisons -At the beginning of the [testing evaluation report](#testing-evaluation-report), each dataset is assigned an abbreviated designation of 'D#' (e.g. D1, D2, etc) based on the alphabetical order of each dataset name. These designations are used in some of the files included within this folder. - -#### Statistical Significance Comparisons -When you first open this folder you will find `.csv` files containing all statistical significance results comparing modeling performance across two or more 'target datasets' run at once with STREAMLINE. - -STREAMLINE applies three non-parametric tests of significance: -1. [Kruskal Wallis one-way analysis of variance](https://en.wikipedia.org/wiki/Kruskal%E2%80%93Wallis_one-way_analysis_of_variance) - used for comparing two or more independent samples of equal or different sample sizes -2. [Mann-Whitney U test](https://en.wikipedia.org/wiki/Mann%E2%80%93Whitney_U_test) (aka Wicoxon rank-sum test) - used for pair-wise independent sample comparisons -3. [Wilcoxon signed-rank test](https://en.wikipedia.org/wiki/Wilcoxon_signed-rank_test) - used for pair-wise dependent sample comparisons. - -The `.csv` files in this folder include the above significance tests' results comparing model performance between 'target datasets': -* `BestCompare` files: (1) apply the given test to each evalution metric, (2) only compares the models from the 'top-performing-algorithm' for a given metric/dataset - determined by which had the best median metric value for in a 'sample' (3) where a 'sample' is the set of *k* trained CV models for a given algorithm -* `KruskalWallis` files: (1) applies Kruskal Wallis to each evalution metric for a given algorithm across dataset 'samples', (2) where a 'sample' is the set of *k* trained CV models for that algorithm -* `MannWhitney` files: (1) applies Mann-Whitney to each evalution metric for a given algorithm examining pairs of dataset 'samples', (2) where a 'sample' is the set of *k* trained CV models for that algorithm -* `WilcoxonRank` files: (1) applies Wilcoxon to each evalution metric for a given algorithm examining pairs of dataset 'samples', (2) where a 'sample' is the set of *k* trained CV models for that algorithm - -#### dataCompBoxplots -This folder contains two different types of box plots comparing dataset performance: -1. `DataCompare`: (1) one plot for each combination of algorithm + evaluation metric (only ROC-AUC, and PRC-AUC metrics), (2) the 'sample' making up each individual box-and-whisker is the set of *k* trained CV models for that algorithm -2. `DataCompareAllModels`: (1) one plot for each evaluation metric (all 16 classification metrics), (2) the 'sample' making up each individual box-and-whisker is the set of median algorithm performances, (3) lines are overlaid on the boxplot to illustrate differences in median performance between datasets for all algorithms. - -### hcc-data_custom -We will focus on the `hcc_data_custom` folder to walk through the remaining files, since (unlike the `hcc_data` folder) also includes the results of a replication analyis. However, note that you will find mostly the same set of files within `hcc_data` or for any uniquely named dataset in the folder specified by the [`dataset_path`](parameters.md#dataset-path) parameter. - -The only file you will see when opening this folder is `runtimes.csv` which documents STREAMLINE's runtime on different phases and machine learning modeling algorithms. - -#### CVDatasets -This folder contains all training and testing datsets (named as `[DATANAME]_CV_[PARTITION]_[Train or Test].csv`). These cross validation (CV) datasets have undergone processing, imputation, scaling, and feature selection, and are the datasets used for model training and evaluation in phase 5. - -Additionally, if [`overwrite_cv`](parameters.md#overwrite-cv) and [`del_old_cv`](parameters.md#del-old-cv) were both `False`, you will see two additional sets of CV datasets with either `CVOnly` or `CVPre` in their filenames. These are intermediary versions of the CV datasets (included as a further sanity check), allowing users to examine how these datasets have changed prior to phase 2 (scaling and imputation), and phase 4 (feature selection).`CVOnly` identifies CV datasets that have undergone phase 1 processing (i.e. cleaning, feature engineering, and CV partitioning). `CVPre` identifies CV datasets that have additionally undergone phase 2 (scaling and imputation). - -#### exploratory -We will begin by explaining the files you see when first opening this folder. All of these files represent exploratory data analysis (EDA) of the 'processed data' (i.e. after automated cleaning and feature engineering). - -##### exploratory (plots) -* `ClassCountsBarPlot` - a simple bar plot illustrating class balance or imbalance -* `DataMissingnessHistogram` - a histogram illustrating the frequency of data missingness across features -* `FeatureCorrelations` - a pearson feature correlation heatmap - -##### exploratory (.csv) -* `ClassCounts` - documents the number of instances in the data for each class -* `correlation_feature_cleaning` - documents feature pairs that met the [`correlation_removal_threshold`](parameters.md#correlation-removal-threshold) identifying which feature was retained vs deleted from the dataset -* `DataCounts` - documents dataset counts for number of instances, features, feature types, and missing values -* `DataMissingness` - documents missing value counts for all columns in the dataset -* `DataProcessSummary` - documents incremental changes to instance, feature, feature type, missing value, and class counts during the individual cleaning and feature engineering steps in phase 1 -* `DescribeDataset` - output from standard pandas `describe()` function -* `DtypesDataset` - output from standard pandas `dtypes()` function -* `FeatureCorrelations` - documents all pearson feature correlations -* `Missingness_Engineered_Features` - documents any newly engineered 'missingness' features added to the dataset based on the [`featureeng_missingness`](parameters.md#featureeng-missingness) cutoff -* `Missingness_Feature_Cleaning` - documents any features that have been removed from the data because their missingness was >= [`cleaning_missingness`](parameters.md#cleaning-missingness) -* `Numerical_Encoding_Map` - documents the numerical encoding mapping for any binary text-valued features in the dataset -* `NumUniqueDataset` - output from standard pandas `nunique()` function -* `OriginalFeatureNames` - documents all original feature names from the 'target dataset' prior to any processing -* `processed_categorical_features` - documents all processed feature names that were be treated as categorical -* `processed_quantitative_features` - documents all processed feature names that were be treated as quantitative -* `ProcessedFeatureNames` - documents all feature names for the processed 'target dataset' - -##### exploratory (pickle) -A variety of other pickle files can be found in this folder, used internally for data processing in the replication phase. - -##### initial -This subfolder includes a subset of the same files found in `exploratory`, however these files represent the 'initial' exploratory data analysis (EDA) prior to cleaning and feature engineering. +# Output -##### univariate analysis -This subfolder includes plots and a `.csv` report focused on exploratory univariate analyses on the given processed 'target dataset'. +STREAMLINE writes outputs under: -##### univariate analysis (plots) -* `Barplot` plots: simple barplots illustrating the relationship between a given categorical feature and outcome if the [Chi Square Test](https://en.wikipedia.org/wiki/Chi-squared_test) was significant based on [`sig_cutoff`](parameters.md#sig-cutoff) -* `Boxplot` plots: simple boxplots illustrating the relationship between a given quantitative feature and outcome if the [Mann-Whitney U test](https://en.wikipedia.org/wiki/Mann%E2%80%93Whitney_U_test) was significant based on [`sig_cutoff`](parameters.md#sig-cutoff) +```text +// +``` -##### univariate analysis (.csv) -`Univariate_Signifiance.csv` documents the p-value, test statistic, and test name applied across all processed features in the 'target dataset' +For example: -#### feature_selection -Includes all output for phases 3 and 4 (feature importance estimation and feature selection). +```text +out/UCIHCCPipeline/ +``` -* When first opening this folder you will find `InformativeFeatureSummary.csv` which summarizes feature counts kept or removed during feature selection (i.e. Informative vs. Uninformative) for each individual CV partition. +## Experiment-Level Files -##### multisurf -This subfolder includes (1) `.csv` files with MultiSURF scores for each CV partition and (2) `TopAverageScores`, a plot of the top ([`top_fi_features`](parameters.md#top-fi-features)) features (based on median MultiSURF score over CV paritions) +Common experiment-level outputs include: -##### mutual_information -This subfolder includes (1) `.csv` files with mutual information scores for each CV partition and (2) `TopAverageScores`, a plot of the top ([`top_fi_features`](parameters.md#top-fi-features)) features (based on median mutual information score over CV paritions) +| Path | Description | +| --- | --- | +| `run_commands.pickle` | Saved resolved phase arguments for repeat runs. | +| `DatasetComparisons/` | P9 cross-dataset comparison outputs. | +| `reporting/_STREAMLINE_Report.pdf` | Standard P11 report. | +| `reporting_replication/_STREAMLINE_Replication_Report.pdf` | Replication P11 report. | +| `jobsCompleted/` | Completion markers for orchestration. | -#### model_evaluation -We will begin by explaining the files you see when first opening this folder. +## How To Check A Run Quickly -##### model_evaluation (plots) -* `[ALGORITHM]_ROC` plots: [reciever operating characteristic (ROC)](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) plot for a given algorithm illustrating performance across all CV partitions (i.e. 'folds'), as well as the mean ROC curve and +- 1 standard deviation of the CV partitions. -* `[ALGORITHM]_PRC` plots: [precision-recall curve (ROC)](https://scikit-learn.org/stable/auto_examples/model_selection/plot_precision_recall.html#:~:text=The%20precision%2Drecall%20curve%20shows,a%20low%20false%20negative%20rate.) plot for a given algorithm illustrating performance across all CV partitions (i.e. 'folds'), as well as the mean PRC and +- 1 standard deviation of the CV partitions. -* `Summary_ROC` plot - [reciever operating characteristic (ROC)](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) plot comparing mean (CV partition) ROC curves across all algorithms. -* `Summary_PRC` plot - [precision-recall curve (ROC)](https://scikit-learn.org/stable/auto_examples/model_selection/plot_precision_recall.html#:~:text=The%20precision%2Drecall%20curve%20shows,a%20low%20false%20negative%20rate.) plot comparing mean (CV partition) PRCs across all algorithms. +After a full demo run, check for these files first: -##### model_evaluation (.csv) -* `[ALGORITHM]_performance`: documents the 16 model performance metrics for each CV partition for this algorithm -* `Summary_performance_mean` - documents the 16 performance metrics (*mean* across CV partition) for each algorithm -* `Summary_performance_median` - documents the 16 performance metrics (*median* across CV partition) for each algorithm -* `Summary_performance_std` - documents the 16 performance metrics (*standard deviation* across CV partitions) for each algorithm +```text +///model_evaluation/Summary_performance_mean.csv +//reporting/_STREAMLINE_Report.pdf +``` -##### feature_importance -This subfolder includes all model specific feature importance outputs including plots and `.csv` files for the 'target dataset'. +If P10/P11 replication ran, also check: -Plots are as follows: -* `Compare_FI_Norm` - composite feature importance plot illustrating *normalized* model feature importance scores across all algorithms run. [`top_fi_features`](parameters.md#top-fi-features) features are displayed and ranked based on the across-algorithm sum of mean *normalized* and *weighted* feature importance scores. This *weighting* is based on the model performance indicated by ['metric_weight'](parameters.md#metric-weight). -* `Compare_FI_Norm_Weight` - composite feature importance plot illustrating *normalized* and *weighted* model feature importance scores across all algorithms run. [`top_fi_features`](parameters.md#top-fi-features) features are displayed and ranked based on the across-algorithm sum of mean *normalized* and *weighted* feature importance scores. This *weighting* is based on the model performance indicated by ['metric_weight'](parameters.md#metric-weight). -* `[ALGORITHM]_boxplot` plots: boxplot of model feature importance scores (for a given algorithm). [`top_fi_features`](parameters.md#top-fi-features) features are displayed, ranked by mean model feature importance scores (across CV partitions). -* `[ALGORITHM]_histogram` plots: histogram illustrating the distribution of the mean (across CV partitions) model feature importance scores (for a given algorithm). +```text +///replication//model_evaluation/Summary_performance_mean.csv +//reporting_replication/_STREAMLINE_Replication_Report.pdf +``` -The `.csv` files are as follows: -* `[ALGORITHM]_FI`: documents all model feature importance estimates (for the full list of processed features) for each CV partition (for a given algorithm) +## Dataset-Level Folders -##### metricBoxplots -This subfolder contains separate boxplox plots for each model evaluation metric. Each plot compares the set of algorithms run across all CV partitions. +Each dataset gets a folder under the experiment directory: -##### pickled_metrics -This subfolder contains pickle files (used internally) to store evaluation metrics for each algorithm and CV partition combination. +| Folder | Produced by | Description | +| --- | --- | --- | +| `exploratory/` | P1 | DataProcessSummary, missingness, feature typing, class counts, and EDA summaries. | +| `CVDatasets/` | P1-P5 | Train/test CV datasets, including selected feature versions. | +| `impute_scale/` | P2 | Imputation/scaling metadata and artifacts. | +| `feature_learning/` | P3 | Learned feature manifests and feature lists. | +| `feature_importance/` | P4 | Feature score files by method and CV. | +| `feature_selection/` | P5 | Informative feature summaries and selected feature artifacts. | +| `models/` | P6 | Fitted models, predictions, metrics, and Optuna accounting. | +| `model_evaluation/` | P6/P8 | Summary metrics and model plots. | +| `ensemble_evaluation/` | P7/P8 | Ensemble metrics and plots for classification runs. | +| `runtime/` | multiple | Runtime summaries. | +| `replication/` | P10 | Replication predictions, metrics, and plots. | -##### statistical_comparisons -This subfolder contains `.csv` files documenting statistical significance tests comparing algorithm performance on the given 'target dataset'. -* `KruskalWallis` - documents [Kruskal Wallis](https://en.wikipedia.org/wiki/Kruskal%E2%80%93Wallis_one-way_analysis_of_variance) applied to each evalution metric between algorithm 'samples', (2) where a 'sample' is the set of *k* trained CV models for that algorithm -* `MannWhitneyU` files: documents [Mann-Whitney](https://en.wikipedia.org/wiki/Mann%E2%80%93Whitney_U_test) applied to a given evalution metric between pairs of algorithm 'samples', (2) where a 'sample' is the set of *k* trained CV models for that algorithm -* `WilcoxonRank` files: documents [Wilcoxon](https://en.wikipedia.org/wiki/Wilcoxon_signed-rank_test) applied to a given evalution metric between pairs of algorithm 'samples', (2) where a 'sample' is the set of *k* trained CV models for that algorithm +## Reports -* *Note: `MannWhitneyU` and `WilcoxonRank` files are only generated for a given evaluation metric if the `KruskalWallis` test for that metric was significant.* +P11 can generate two report scopes: -#### models -Upon opening this folder you will see `.csv` files for each algorithm and CV partition combination documenting the 'best' hyperparameter settings identified by [Optuna](https://optuna.org/) and used to train each respective final model. +```bash +python -m streamline.p11_reporting.p11_cli \ + --experiment_path out/UCIHCCPipeline \ + --report_mode standard -Also included is the `pickledModels` subfolder containing all trained and pickled model objects for each algorithm and CV partition combination. Beyond the testing and replication data performance evaluation output by STREAMLINE, these models can be unpickled and applied in the future to document (1) training performance on the training datasets, (2) further replication datasets, and (3) applied to unlabled data to make outcome predictions. +python -m streamline.p11_reporting.p11_cli \ + --experiment_path out/UCIHCCPipeline \ + --report_mode replication +``` -#### replication -This folder will include a subfolder for every 'replication dataset' being applied to a given 'target dataset'. In the demo, this only includes `hcc_data_custom_rep`. Within this folder you will find a subset of relevant the folders and output files we have already covered; plotting and documenting the given replication dataset and the findings when evaluating all trained models using this replication dataset. This includes the PDF [Replication Evaluation Report](#replication-evaluation-report) and a 'processed' copy of the given 'replication dataset'. +The standard report focuses on training/CV experiment outputs. The replication +report focuses on external validation outputs under the dataset replication +folders. -#### runtime -This folder includes `.txt` files documenting the runtimes spent on different phases and algorithms within STREAMLINE. As previously mentioned, these times are summarized within `runtimes.csv` generated for each 'target dataset' (e.g. `/demo_experiment/hcc_data_custom/runtimes.csv`). +The first page of each report is intended to answer the practical questions +users ask first: what dataset was run, what phases were run, which settings +were used, what task type was evaluated, and where the strongest or tied metric +results appear. -#### scale_impute -This folder includes all pickled trained mappings used internally for missing value imputation and applying standard scaling to new data. +## Report Data -## Figures Summary -Below is an example overview of the different figures generated by STREAMLINE for binary classification data. Note that these current images were generated from the Beta 0.2.5 release, and have been improved, updated and expanded since. +Each report directory also includes `report_data.json`. This JSON is the +structured input used to build the PDF and is useful for debugging report +content without parsing the PDF. -![alttext](pictures/STREAMLINE_Figures.png) +## Figures +The reporting phase can either reuse existing generated figures or generate +missing figures: +```bash +python -m streamline.p11_reporting.p11_cli \ + --experiment_path out/UCIHCCPipeline \ + --enable_plots 1 \ + --reuse_existing_figures 1 +``` + +Set `--enable_plots 0` when you want a faster report-only smoke test. diff --git a/docs/source/parameters.md b/docs/source/parameters.md index 2f04ebf8..dd96c221 100644 --- a/docs/source/parameters.md +++ b/docs/source/parameters.md @@ -1,731 +1,132 @@ # Run Parameters -Here we review the run parameters available across the 9 phases of STREAMLINE. We begin with a quick guide/summary of all run parameters according to run mode along with their default values (when applicable). Then we provide further descriptions, formatting, valid values, and guidance (as needed) for each run parameter. Lastly, we provide overall guidance on setting STEAMLINE run parameters. -*** -## Quick Guide -The quick guide below distinguishes essential from non-essential run parameters within streamline, and further breaks down non-essential run paramters by pipeline phase. The name of each parameter is given for the command-line, configuration file, and notebooks (same for both Colab and Jupyter Notebooks), as well as the internal STREAMLINE default value (which ocassionally differ from the default values used in the notebooks for the [demonstration datasets](data.md#demonstration-data)). -* Run parameters without default values are incidated with 'no default'. -* Run parameters that are not used in one of the run modes are indicated with 'NA'. -* All run parameters include quick links to their respective details in [Parameter Details](#parameter-details), including their description, format, values, and other tips. - -### Essential Parameters (Phases 1-9) - -| Command-line Parameter | Config File Parameter | Notebook Parameter | Default | -|---------------------------|---------------------------------------------------------|----------------------------------------------|------------| -| -\\-data-path | [dataset_path](#dataset-path) | data_path | no default | -| -\\-out-path | [output_path](#output-path) | output_path | no default | -| -\\-exp-name | [experiment_name](#experiment-name) | experiment_name | no default | -| -\\-class-label | [class_label](#class-label) | class_label | 'Class' | -| -\\-inst-label | [instance_label](#instance-label) | instance_label | None | -| -\\-match-label | [match_label](#match-label) | match_label | None | -| -\\-fi | [ignore_features_path](#ignore-features-path) | ignore_features | None | -| -\\-cf | [categorical_feature_path](#categorical-feature_path) | categorical_feature_headers | None | -| -\\-qf | [quantitative_feature_path](#quantitative-feature_path) | quantitiative_feature_headers | None | -| -\\-rep-path | [rep_data_path](#rep-data-path) | rep_data_path | no default | -| -\\-dataset | [dataset_for_rep](#dataset-for-rep) | dataset_for_rep | no default | -| [-\\-config](#config) or -c | NA | NA | no default | -| -\\-do-till-report or -dtr | [do_till_report](#do-till-report) | NA | False | -| -\\-do-eda | [do_eda](#do-eda) | NA | False | -| -\\-do-dataprep | [do_dataprep](#do-dataprep) | NA | False | -| -\\-do-feat-imp | [do_feat_imp](#do-feat_imp) | NA | False | -| -\\-do-feat-sel | [do_feat_sel](#do-feat_sel) | NA | False | -| -\\-do-model | [do_model](#do-model) | NA | False | -| -\\-do-stats | [do_stats](#do-stats) | NA | False | -| -\\-do-compare-dataset | [do_compare_dataset](#do-compare-dataset) | NA | False | -| -\\-do-report | [do_report](#do-report) | NA | False | -| -\\-do-replicate | [do_replicate](#do-replicate) | NA | False | -| -\\-do-rep-report | [do_rep_report](#do-rep-report) | NA | False | -| -\\-do-cleanup | [do_cleanup](#do-cleanup) | NA | False | -| NA | NA | [applyToReplication](#applyToReplication) | True | -| NA | NA | [demo_run](#demo-run) | True | -| NA | NA | [use_data_prompt](#use-data-prompt) (Colab) | True | - -### General Parameters (Phase 1) - -| Command-line Parameter | Config File Parameter | Notebook Parameter | Default | -|---------------------------|-------------------------------------------|-----------------------------------|--------------| -| -\\-cv | [cv_partitions](#cv-partitions) | n_splits | 10 | -| -\\-part | [partition_method](#partition-method) | partition_method | 'Stratified' | -| -\\-cat-cutoff | [categorical_cutoff](#categorical-cutoff) | categorical_cutoff | 10 | -| -\\-sig | [sig_cutoff](#sig-cutoff) | sig_cutoff | 0.05 | -| -\\-rand-state | [random_state](#random-state) | random_state | 42 | - -### Data Processing Parameters (Phase 1) - -| Command-line Parameter | Config File Parameter | Notebook Parameter | Default | -|---------------------------|------------------------------------------------------------------|-----------------------------------|------------| -| -\\-exclude-eda-output | [exclude_eda_output](#exclude-eda-output) | exclude_eda_output | None | -| -\\-top-uni-feature | [top_uni_features](#top-uni-features) | top_uni_features | 20 | -| -\\-feat_miss | [featureeng_missingness](#featureeng-missingness) | featureeng_missingness | 0.5 | -| -\\-clean_miss | [cleaning_missingness](#cleaning-missingness) | cleaning_missingness | 0.5 | -| -\\-corr_thresh | [correlation_removal_threshold](#correlation-removal-threshold) | correlation_removal_threshold | 1.0 | - - -### Imputation & Scaling Parameters (Phase 2) - -| Command-line Parameter | Config File Parameter | Notebook Parameter | Default | -|------------------------|--------------------------------|-----------------------------|---------| -| -\\-impute | [impute_data](#impute-data) | impute_data | True | -| -\\-multi-impute | [multi_impute](#multi-impute) | multi_impute | True | -| -\\-scale | [scale_data](#scale-data) | scale_data | True | -| -\\-over-cv | [overwrite_cv](#overwrite-cv) | overwrite_cv | True | - -### Feature Importance Estimation Parameters (Phase 3) - -| Command-line Parameter | Config File Parameter | Notebook Parameter | Default | -|------------------------|--------------------------------------|-----------------------------------------------|---------| -| -\\-do-mi | [do_mutual_info](#do-mutual-info) | do_mutual_info | True | -| -\\-do-ms | [do_multisurf](#do-multisurf) | do_multisurf | True | -| -\\-use-turf | [use_turf](#use-turf) | use_TURF | False | -| -\\-turf-pct | [turf_pct](#turf-pct) | TURF_pct | 0.5 | -| -\\-inst-sub | [instance_subset](#instance-subset) | instance_subset | 2000 | -| -\\-n-jobs | [n_jobs](#n-jobs) | cores | 1 | - -### Feature Selection Parameters (Phase 4) - -| Command-line Parameter | Config File Parameter | Notebook Parameter | Default | -|------------------------|------------------------------------------------|-----------------------------------------------|---------| -| -\\-filter-feat | [filter_poor_features](#filter-poor-features) | filter_poor_features | True | -| -\\-max-feat | [max_features_to_keep](#max-features-to-keep) | max_features_to_keep | 2000 | -| -\\-export-scores | [export_scores](#export-scores) | export_scores | True | -| -\\-top-fi-features | [top_fi_features](#top-fi-features) | top_fi_features | 40 | -| -\\-over-cv-feat | [overwrite_cv_feat](#overwrite-cv-feat) | overwrite_cv_feat | True | - -### Modeling Parameters (Phase 5) - Command-line Parameter | Config File Parameter | Notebook Parameter | Default | -|------------------------|-------------------------------------------------------|------------------------------------|---------------------------| -| -\\-algorithms | [algorithms](#algorithms) | algorithms | None | -| -\\-exclude | [exclude](#exclude) | exclude | 'eLCS,XCS' | -| -\\-subsample | [training_subsample](#training-subsample) | training_subsample | 0 | -| -\\-use-uniformFI | [use_uniform_fi](#use-uniform-fi) | use_uniform_FI | True | -| -\\-metric | [primary_metric](#primary-metric) | primary_metric | 'balanced_accuracy' | -| -\\-metric-direction | [metric_direction](#metric-direction) | metric_direction | 'maximize' | -| -\\-n-trials | [n_trials](#n-trials) | n_trials | 200 | -| -\\-timeout | [timeout](#timeout) | timeout | 900 | -| -\\-export-hyper-sweep | [export_hyper_sweep_plots](#export-hyper-sweep-plots) | export_hyper_sweep_plots | False | -| -\\-do-LCS-sweep | [do_lcs_sweep](#do-lcs-sweep) | do_lcs_sweep | False | -| -\\-nu | [lcs_nu](#lcs-nu) | lcs_nu | 1 | -| -\\-iter | [lcs_iterations](#lcs-iterations) | lcs_iterations | 200000 | -| -\\-N | [lcs_n](#lcs-n) | lcs_N | 2000 | -| -\\-lcs-timeout | [lcs_timeout](#lcs-timeout) | lcs_timeout | 1200 | -| -\\-model-resubmit | [model_resubmit](#model-resubmit) | NA | False | - -### Post-Analysis Parameters (Phase 6) -| Command-line Parameter | Config File Parameter | Notebook Parameter | Default | -|--------------------------|--------------------------------------------------|-------------------------|---------------------| -| -\\-exclude-plots | [exclude_plots](#exclude-plots) | exclude_plots | None | -| -\\-metric-weight | [metric_weight](#metric-weight) | metric_weight | 'balanced_accuracy' | -| -\\-top-model-fi-features | [top_model_fi_features](#top-model-fi-features) | top_model_fi_features | 40 | - -### Compare Data Parameters (Phase 7) -There are currently no run parameters to adjust for this phase. - -### Replication Parameters (Phase 8) - -| Command-line Parameter | Config File Parameter | Notebook Parameter | Default | -|------------------------|------------------------------------------|---------------------|---------| -| -\\-exclude-rep-plots | [exclude_rep_plots](#exclude-rep-plots) | exclude_rep_plots | None | - -### Summary Report Parameters (Phase 9) -There are currently no run parameters to adjust for this phase. - -### Cleanup Parameters - -| Command-line Parameter | Config File Parameter | Notebook Parameter | Default | -|------------------------|----------------------------|--------------------|---------| -| -\\-del-time | [del_time](#del-time) | del_time | True | -| -\\-del-old-cv | [del_old_cv](#del-old-cv) | del_old_cv | True | - -### Multiprocessing Parameters - -| Command-line Parameter | Config File Parameter | Notebook Parameter | Default | -|------------------------|--------------------------------------|---------------------|---------| -| -\\-run-parallel | [run_parallel](#run-parallel) | NA | False | -| -\\-run-cluster | [run_cluster](#run-cluster) | NA | "SLURM" | -| -\\-res-mem | [reserved_memory](#reserved-memory) | NA | 4 | -| -\\-queue | [queue](#queue) | NA | "defq" | - -### Logging Parameters -| Command-line Parameter | Config File Parameter | Notebook Parameter | Default | -|---------------------------|-------------------------------------------|-----------------------------------|--------------| -| -\\-verbose | [verbose](#verbose) | NA | False | -| -\\-logging-level | [logging_level](#logging-level) | NA | 'INFO' | - -*** -## Parameter Details -This section will go into greater depth for each run parameter, primarily using the configuration file parameter name to identify each. -* *Parameters identified as (str) format should be entered with single quotation marks within notebooks, or when using a configuration file, but without them when using command line arguments (CLA).* - -*** -### Essential Parameters (Phase 1-9) - -#### dataset_path -* **Description:** path to the folder containing one or more 'target datasets' to be analyzed that meet dataset [formatting requirements](data.md#input-data-requirements) -* **Format:** (str), e.g. `'/content/STREAMLINE/data/DemoData'` -* **Values:** must be a valid folder-path -* **Tips:** STREAMLINE automatically detects the number of 'target datasets' in this folder and will run a complete analysis on each, comparing dataset performance in phase 7 - -#### output_path -* **Description:** path to an output folder where STREAMLINE will save the experiment folder (containing all output files) -* **Format:** (str), e.g. `'/content/DemoOutput'` -* **Values:** must be a valid folder-path, however the lowest level of the folder (e.g. DemoOutput) does not already have to exist, and will be automatically created if it does not -* **Tips:** When running multiple STREAMLINE experiments, it's convenient to leave this parameter the same and just update `experiment_name` - -#### experiment_name -* **Description:** a unique name for the current STREAMLINE experiment output folder that will be created within `output_path` -* **Format:** (str), e.g. `'demo_experiment'` -* **Values:** any string value name (avoid spaces) -* **Tips:** a short, unique, and descriptive name is encouraged - -#### class_label -* **Description:** the name of the class/outcome column found in the dataset header -* **Format:** (str), e.g. `'Class'` -* **Values:** the case-sensitive name used in the dataset to identify the outcome labels column - -#### instance_label -* **Description:** the name of the instance ID column that may (or may not) be included in the dataset -* **Format:** (str), e.g. `'InstanceID'` -* **Values:** `None`, or the case-sensitive name used in the dataset to identify the instance ID column (if present) -* **Tips:** having an instance ID column in the data allows users to later identify model predictions for specific instances in the dataset, as well as reverse-engineer instance subgroups in the dataset downstream using the ExSTraCS modeling algorithm's capability to detect and characterize heterogeneous associations. This may not be necessesary for most users. - -#### match_label -* **Description:** the name of the match/group ID column that can be included in a dataset to keep instances with the same match label together within the same CV partition -* **Format:** (str), e.g. `'MatchID'` -* **Values:** `None`, or the case-sensitive name used in the dataset to identify the match/group ID column (if present) -* **Tips:** having a match/group ID column in the data allows users to apply machine learning modeling to datasets where instances with different outcomes have been matched based on other covariates that the user wants to account for (e.g. age, sex, race, etc) - -#### ignore_features_path -* **Description:** a list of feature names for STREAMLINE to immediately drop from the target datasets -* **Format:** - 1. for notebook or config file modes: provide a (list) of (str) feature names that can be found in any of the 'target datasets', e.g. `['IgnoredFeature1','IgnoredFeature2']` - 2. for command line arguments: provide a (str) path to a `.csv` file including a row of feature names that can be found in any of the 'target datasets', e.g. `'/content/STREAMLINE/data/MadeUp/ignoreFeat.csv'` -* **Values:** `None`, or (for either format) should include case-sensitive feature names found in at least one of the 'target datasets' -* **Tips:** useful for easily dropping features found in the datasets that users may wish to exclude if those features might lead to data leakage, or for other data quality reasons - -#### categorical_feature_path -* **Description:** a list of feature names for STREAMLINE to explicitly treat as categorical feature types -* **Format:** - 1. for notebook or config file modes: provide a (list) of (str) feature names that can be found in any of the 'target datasets', e.g. `['Feature1','Feature7']` - 2. for command line arguments: provide a (str) path to a `.csv` file including a row of feature names that can be found in any of the 'target datasets', e.g. `'/content/STREAMLINE/data/DemoFeatureTypes/hcc_cat_feat.csv'` -* **Values:** `None`, or (for either format) should include case-sensitive feature names found in at least one of the 'target datasets' -* **Tips:** - * When specifying `categorical_feature_path` feature names and leaving `quantiative_feature_path = None` all other features will be automatically treated as quanatiative - * When specifying `quantiative_feature_path` feature names and leaving `categorical_feature_path = None` all other features will be automatically treated as categorical - * When specifying feature names for both `categorical_feature_path` and `quantiative_feature_path`, any features in the data not specified by one of theses lists will have it's feature type determined automatically using [categorical_cutoff](#categorical_cutoff) - * Note: any text-valued features in a dataset will automatically be numerically encoded and treated as categorical features (overriding any other user specifications) - -#### quantitative_feature_path -* **Description:** a list of feature names for STREAMLINE to explicitly treat as quantitative feature types - * All other aspects of this parameter are the same as for [categorical_feature_path](#categorical_feature_path) - -#### rep_data_path -* **Description:** path to the folder containing one or more 'replication datasets' to be evaluated using previously trained models for a specific 'target dataset' (see [data formatting requirements](data.md#input-data-requirements)) -* **Format:** (str), e.g. `'/content/STREAMLINE/data/DemoRepData'` -* **Values:** must be a valid folder-path -* **Tips:** STREAMLINE automatically detects the number of 'replication datasets' in this folder and will run a complete evaluation on each. - -#### dataset_for_rep -* **Description:** path to the individual 'target dataset' file used to train the models which you want to evaluate with the above 'replication datasets' (see [data formatting requirements](data.md#input-data-requirements)) -* **Format:** (str), e.g. `'/content/STREAMLINE/data/DemoData/hcc_data_custom.csv'` -* **Values:** must be a valid file-path -* **Tips:** STREAMLINE's replication phase is set up to evaluate all models trained from a single 'target datasets' at once using one or more replication datasets, specific to that 'target dataset'. The replication phase can be run multiple times, each for a new 'target dataset', and it's own respective 'replication dataset(s)'. - -#### config -* **Description:** path to the configuration file used to run STREAMLINE from the command line using a configuration file [locally](running.md#using-a-configuration-file-locally) or on a [cluster](running.md#using-a-configuration-file-cluster) -* **Format:** (str), e.g. `run_configs/local.cfg` -* **Values:** must be a valid file-path to a properly formatted configuration file - -#### do_till_report -* **Description:** boolean flag telling STREAMLINE to automatically run all phases excluding phase 8 (i.e. replication), and part of phase 9 (i.e. PDF report for replication) -* **Format:** [Command Line Argument] just use flag (i.e. `--do-till-report`), [Configuration File] (bool) -* **Values:** `True` or `False` - -#### do_eda -* **Description:** boolean flag telling STREAMLINE to run phase 1 (i.e. EDA and Processing) -* **Format:** [Command Line Argument] just use flag (i.e. `--do-eda`), [Configuration File] (bool) -* **Values:** `True` or `False` - -#### do_dataprep -* **Description:** boolean flag telling STREAMLINE to run phase 2 (i.e. Imputation and Scaling) -* **Format:** [Command Line Argument] just use flag (i.e. `--do-dataprep`), [Configuration File] (bool) -* **Values:** `True` or `False` - -#### do_feat_imp -* **Description:** boolean flag telling STREAMLINE to run phase 3 (i.e. Feature Importance Estimation) -* **Format:** [Command Line Argument] just use flag (i.e. `--do-feat-imp`), [Configuration File] (bool) -* **Values:** `True` or `False` - -#### do_feat_sel -* **Description:** boolean flag telling STREAMLINE to run phase 4 (i.e. Feature Selection) -* **Format:** [Command Line Argument] just use flag (i.e. `--do-feat-sel`), [Configuration File] (bool) -* **Values:** `True` or `False` - -#### do_model -* **Description:** boolean flag telling STREAMLINE to run phase 5 (i.e. Modeling) -* **Format:** [Command Line Argument] just use flag (i.e. `--do-model`), [Configuration File] (bool) -* **Values:** `True` or `False` - -#### do_stats -* **Description:** boolean flag telling STREAMLINE to run phase 6 (i.e. Post-Analysis) -* **Format:** [Command Line Argument] just use flag (i.e. `--do-stats`), [Configuration File] (bool) -* **Values:** `True` or `False` - -#### do_compare_dataset -* **Description:** boolean flag telling STREAMLINE to run phase 7 (i.e. Compare Datasets) -* **Format:** [Command Line Argument] just use flag (i.e. `--do-compare-dataset`), [Configuration File] (bool) -* **Values:** `True` or `False` - -#### do_report -* **Description:** boolean flag telling STREAMLINE to run phase 9 (i.e. Summary Report) specific to phases 1-7 -* **Format:** [Command Line Argument] just use flag (i.e. `--do-report`), [Configuration File] (bool) -* **Values:** `True` or `False` - -#### do_replicate -* **Description:** boolean flag telling STREAMLINE to run phase 8 (i.e. Replication) specific to phases 1-7 -* **Format:** [Command Line Argument] just use flag (i.e. `--do-replicate`), [Configuration File] (bool) -* **Values:** `True` or `False` - -#### do_rep_report -* **Description:** boolean flag telling STREAMLINE to run phase 9 (i.e. Summary Report) specific to phase 8 -* **Format:** [Command Line Argument] just use flag (i.e. `--do-rep-report`), [Configuration File] (bool) -* **Values:** `True` or `False` - -#### do_cleanup -* **Description:** boolean flag telling STREAMLINE to run output file cleanup (optional) -* **Format:** [Command Line Argument] just use flag (i.e. `--do-cleanup`), [Configuration File] (bool) -* **Values:** `True` or `False` - -#### applyToReplication -* **Description:** a notebook-specific parameter indicating whether to include running phase 8 (i.e. Replication) -* **Format:** (bool) -* **Values:** `True` or `False` - -#### demo_run -* **Description:** a notebook-specific parameter indicating whether to automatically run the notebook on the [demonstration datasets](data.md#demonstration-data) -* **Format:** (bool) -* **Values:** `True` or `False` - -#### use_data_prompt -* **Description:** a notebook-specific parameter that activates a notebook prompt to gather essential run parameter information directly from the user rather than have them manually update code cells -* **Format:** (bool) -* **Values:** `True` or `False` - -*** -### General Parameters (Phase 1) - -#### cv_partitions -* **Description:** *k*, the number of *k*-fold cross validation training/testing data partitions to create and apply throughout pipeline -* **Format:** (int) -* **Values:** an integer between `3` and `10` is recommended -* **Tips:** smaller values will yield shorter STREAMLINE run times, but training datasets will have a smaller number of instances - -#### partition_method -* **Description:** the cross validation strategy used -* **Format:** (str) -* **Values:** `'Stratified'`, `'Random'`, or `'Group'` -* **Tips:** `'Stratified'` is generally recommended in order to keep class balance as similar as possible within respective partitions, however `'Group'` can be selected when `match_label` has been specified to keep instances with the same match/group ID together within a respective partition - -#### categorical_cutoff -* **Description:** the number of unique values observed for a given feature in a 'target dataset' after which a variable is automatcially considered to be quantitative -* **Format:** (int) -* **Values:** an integer between `3` and `10` is generally recommended, but should be set in a dataset-specific manner -* **Tips:** this parameter will only be used if the user hasn't specifically indicated which features to treat as categorical or quantitative using [categorical_feature_path](#categorical_feature_path) and/or [quantitative_feature_path](#quantitative_feature_path), respectively. However depending on the specific dataset, users can sometimes conveniently set this parameter to correctly assign variable types, e.g. if all categorical features in the dataset have fewer than 5 unique values, but quantitative ones all have more than 10 unique values, setting `categorical_cutoff = 7` will make correct feature type assignments automatically. - -#### sig_cutoff -* **Description:** the statistical significance cutoff used throughout the pipeline used in deciding whether to run pair-wise non-parametric statistical comparisons following group comparisons, and for identifying significant results in output files with a '*' -* **Format:** (float) -* **Values:** a value <= `0.05` is recommended -* **Tips:** Note: STREAMLINE does not currently automatically account for multiple testing - users should take this into consideration themselves - -#### random_state -* **Description:** sets a specific random seed for the STREAMLINE run (important for pipeline reproducibility) -* **Format:** (int) -* **Values:** any positive integer value is fine -* **Tips:** make sure to use the same value for `random_state` in a separate run along with the same datasets and run parameters to obtain reproducible pipeline results - -*** -### Data Processing Parameters (Phase 1) - -#### exclude_eda_output -* **Description:** allows users to exclude some of the outputs automatically generated by STREAMLINE during phase 1 -* **Format:** - 1. for notebook or config file modes: provide a (list) of valid options (str) , e.g. `['describe','univariate_plots','correlation_plots']` - 2. for command line arguments: provide as a list of comma separated values with no spaces, e.g. `describe,univariate_plots,correlation_plots` -* **Values:** `None`, or [`'describe'`, `'univariate_plots'`, or `'correlation_plots'`] - provided in format above - * `describe` - don't run or output the set of standard pandas functions (i.e. `Describe()`, `Dtypes()`, and `nunique()`) as `.csv` files - * `univariate_plots` - don't output individual univariate analysis plots illustrating features vs. outcome (by default STREAMLINE outputs these plots for any feature with a significant univariate association based on [`sig_cutoff`](#sig-cutoff)) - * `correlation_plots` - don't output feature correlation heatmaps for the 'initial' or 'processed' data EDA - -#### top_uni_features -* **Description:** number of most significant features to report in the notebook and PDF summary -* **Format:** (int) -* **Values:** an integer between `10` and `40` is recommended - -#### featureeng_missingness -* **Description:** the proportion of missing values within a feature (*above which*) a new binary categorical feature is generated that indicates if the value for an instance was missing or not -* **Format:** (float) -* **Values:** (`0.0` - `1.0`) -* **Tips:** this parameter controls automated feature engineering of a new 'missingness' feature, generated for another pre-existing feature in the 'target dataset'. It's useful for identifying the potentially predictive value of any feature who's missingness is not completely at random (NCAR) - -#### cleaning_missingness -* **Description:** the proportion of missing values, within a feature or instance, (*at which*) the given feature or instance will be automatically cleaned (i.e. removed) from the processed 'target dataset' -* **Format:** (float) -* **Values:** (`0.0` - `1.0`) -* **Tips:** this parameter controls automated data cleaning based on feature or instance 'missingness'. STREAMLINE will first remove features with high missingness, then subsequently remove any instances with missingness over this proportion. - -#### correlation_removal_threshold -* **Description:** the (pearson) feature correlation at which one out of a pair of features is randomly removed from the processed 'target dataset' -* **Format:** (float) -* **Values:** (`0.0` - `1.0`) -* **Tips:** this parameter controls automated data cleaning based on feature correlation. The safest setting (to avoid missing predictive information) is the default of 1.0 (i.e. perfect correlation between two features). Note: STREAMLINE interprets this parameter as both a positive and negative correlation threshold. - -*** -### Imputation & Scaling Parameters (Phase 2) - -#### impute_data -* **Description:** indicates whether or not to apply missing data imputation to features in the data or not -* **Format:** (bool) -* **Values:** `True` or `False` -* **Tips:** leaving to the default value of `True` is recommended but not always neccessary depending on whether missing data is present in the original datasets or what algorithms a user wishes to run (e.g. ExSTraCS can handle missing values in data) - -#### multi_impute -* **Description:** indicates whether or not to apply multiple imputation using scikit-learn's [IterativeImputer](https://scikit-learn.org/stable/modules/generated/sklearn.impute.IterativeImputer.html) for imputing missing values in quantiative features. Mode imputation is always applied for categorical features. -* **Format:** (bool) -* **Values:** `True` or `False` -* **Tips:** for larger datasets, multiple imputation can run very slowly, and take up alot of disk space in the pickled imputation files that are automatically stored for downstream imputation of replication data or further external application of the models. When `False`, median imputation is instead used for quantiative features. - -#### scale_data -* **Description:** indicates whether or not to apply standard scaling to features in the data or not -* **Format:** (bool) -* **Values:** `True` or `False` -* **Tips:** leaving to the default value of `True` is recommended but not always neccessary depending on what algorithms a user wishes to run (see [Imputation and Scaling](pipeline.md#Phase-2-imputation-and-scaling)) - -#### overwrite_cv -* **Description:** indicates whether or not to overwrite the phase 1 version of CV (training and testing) datasets with newly imputed and scaled CV datasets -* **Format:** (bool) -* **Values:** `True` or `False` -* **Tips:** `True` will reduce the number of output files generated (and storage space) keeping only the final processed, imputed, scaled, and feature selected CV datasets, however `False` allows users to view intermediary CV datasets following phase one data processing and CV partitioning - -*** -### Feature Importance Estimation Parameters (Phase 3) - -#### do_mutual_info -* **Description:** indicates whether or not to run mutual information as a feature importance estimation algorithm (prior to modeling) -* **Format:** (bool) -* **Values:** `True` or `False` -* **Tips:** mutual information is good at detecting univariate association between a given feature and outcome. While we recommend running both feature importance algorithms, users should specify `True` for at least one algorithm. - -#### do_multisurf -* **Description:** indicates whether or not to run MultiSURF as a feature importance estimation algorithm (prior to modeling) -* **Format:** (bool) -* **Values:** `True` or `False` -* **Tips:** MultiSURF is good at detecting both features involved in an interaction and univariate association with outcome. While we recommend running both feature importance algorithms, users should specify `True` for at least one algorithm. - -#### use_turf -* **Description:** indicates whether or not to run TuRF, a wrapper algorithm that operates around MultiSURF, improving it's ability to detect feature interactions in data with larger numbers of features -* **Format:** (bool) -* **Values:** `True` or `False` -* **Tips:** using TuRF is strongly recommended in datasets with >10,000 features, but can improve feature importance rankings in datasets with fewer features as well - -#### turf_pct -* **Description:** this parameter currently serves two functions: (1) it determines the propotion of instances removed from consideration during a TuRF iteration, and (2) it dictates the number of TuRF iteractions (where the nubmer of iterations is 1/`turf_pct`) -* **Format:** (float) -* **Values:** (`0.01`- `0.5`) -* **Tips:** setting `turf_pct` to 0.5 will run MultiSURF twice, removing the lowest scoring half of features in the first iteration (and giving them a very low feature importance score), then running MultiSURF again on the remaining features to rescore them. A setting of 0.2 would remove 20% of features each iteration, over 5 iterations. Thus lower values for this parameter will increase run time. - -#### instance_subset -* **Description:** the number of randomly chosen instances in the training data used to use for running MultiSURF -* **Format:** (int) -* **Values:** any integer above `500` is recommended, but the default of `2000` seems to be a reasonable trade-off in many cases between run time and performance -* **Tips:** the MultiSURF algorithm scales quadratically with the number of features in the data, but linearly with the number of features. Thus a dataset with a large number of training instances can make MultiSURF run very slowly. However, MultiSURF does not necessarily need to see all training instances to reasonably estimate feature imporance. If this parameter is set larger than the number of instances in a given training dataset, it will simply use all available training instances. - -#### n_jobs -* **Description:** the number of CPU cores dedicated to running MultiSURF -* **Format:** (int) -* **Values:** `-1`, or a positive integer <= the number of cores available on your machine -* **Tips:** -1 will run MultiSURF on all available cores when run locally - -*** -### Feature Selection Parameters (Phase 4) - -#### filter_poor_features -* **Description:** indicates whether or not to apply feature selection to the dataset -* **Format:** (bool) -* **Values:** `True` or `False` -* **Tips:** when set to `False` all features will be preserved in the datasets for phase 5 modeling - -#### max_features_to_keep -* **Description:** indicates the maximum number of top scorign features to retain in the datasets prior to phase 5 modeling (based on the scores of the feature importance estimation algorithms, i.e. Mutual Information and MultiSURF) -* **Format:** (int or `None`) -* **Values:** any positive integer > `1` is acceptable -* **Tips:** we have set the default of this parameter to `2000` primarily to limit the computational burden of modeling. Users should use their own judgment in setting this parameter for the dataset/task in hand. When set to `None` and [`filter_poor_features`](#filter-poor-features) = `True`, STREAMLINE will automatically remove any feature that scored <= 0 for each feature importance estimation algorithm run. When set to an integer such as `2000` and [`filter_poor_features`](#filter-poor-features) = `True`, STREAMLINE will first remove any feature that scored <= `0` for each feature importance estimation algorithm run, then alternate between the sets of feature importance rankings keeping the top scoring (non-redundant) features from each algorithm. - -#### export_scores -* **Description:** indicates whether or not to export barplots for the feature importance estimation algorithms (Mutual Information and MultiSURF) summarizing average feature importance scores over CV training partitions -* **Format:** (bool) -* **Values:** `True` or `False` - -#### top_fi_features -* **Description:** number of top scoring features (mean over CV runs) to illustrate in the above feature importance estimation bar plots generated when [`export_scores'](#export-scores) = `True` -* **Format:** (int) -* **Values:** an integer between `10` and `40` is recommended - -#### overwrite_cv_feat -* **Description:** indicates whether or not to overwrite the phase 2 version of CV (training and testing) datasets with newly feature selected CV datasets -* **Format:** (bool) -* **Values:** `True` or `False` -* **Tips:** `True` will reduce the number of output files generated (and storage space) keeping only the final processed, imputed, scaled, and feature selected CV datasets, however `False` allows users to view intermediary CV datasets following phase two imputation and scaling - -*** -### Modeling Parameters (Phase 5) - -#### algorithms -* **Description:** used to specify which machine learning modeling algorithms will be applied -* **Format:** (list of 'str' values, or `None`) - 1. for notebook or config file modes: provide a (list) of (str) algorithm identifiers, e.g. `['NB','LR','EN','DT','RF','XGB','SVM','ANN','KNN','GP','ExSTraCS]` - 2. for command line arguments: provide as a list of comma separated values with no spaces, e.g. `NB,LR,EN,DT,RF,XGB,SVM,ANN,KNN,GP,ExSTraCS` -* **Values:** `None`, or any subset of the following ['NB','LR','EN','DT','RF','GB','XGB','LBG','CGB','SVM','ANN','KNN','GP','eLCS','XCS','ExSTraCS], where: - * Naive Bayes (NB) - * Logistic Regression (LR) - * Elastic Net (EN) - * Decision Tree (DT) - * Random Forest (RF) - * Gradient Boosting (GB) - * Extreame Gradient Boosting (XGB) - * Light Gradient Boosting (LGB) - * Category Gradient Boosting (CGB) - * Support Vector Machines (SVM) - * Artificial Neural Networks (ANN) - * K-Nearest Neighbors (KNN) - * Genetic Programming, i.e. symbolic classification (GP) - * Educational Learning Classifier System (eLCS) - * 'X' Classifier System (XCS) - * Extended Supervised Tracking Classifier System (ExSTraCS) -* **Tips:** setting this parameter to `None` will run all algorithms in STREAMLINE with the exception of any algorithms specified within [`exclude`](#exclude). To run a fairly comprehensive subset of algorithms (without running them all), we recommend `['NB','LR','EN','DT','RF','XGB','SVM','ANN','KNN','GP','ExSTraCS]`. Specifying algorithms using this parameter is most convenient when you want to run a small subset of algorithms, e.g. `['NB','LR','DT']` - -#### exclude -* **Description:** used to specify which machine learning modeling algorithms to exclude from analysis -* **Format:** (list of 'str' values, or `None`) - 1. for notebook or config file modes: provide a (list) of (str) algorithm identifiers, e.g. `['eLCS','XCS']` - 2. for command line arguments: provide as a list of comma separated values with no spaces, e.g. `eLCS,XCS` -* **Values:** same as for `algorithms` above -* **Tips:** setting this parameter to `None` just tells STREAMLINE not to exclude any additional algorithms not already specified within [`algorithms`](#algorithms). Currently, by default STREAMLINE excludes `eLCS` and `XCS` from an analysis. Specifying algorithms using this parameter is most convenient when you want to exclude a small subset of algorithms, e.g. `['SVM','eLCS','XCS']`. - -#### training_subsample -* **Description:** the number of randomly chosen instances in the training data used to use for training certain longer running algorithms (i.e. XGB,SVM,KN,ANN,LR,eLCS,XCS,ExStraCS) -* **Format:** (`0`, or another int) -* **Values:** the default of `0` will use all training data. Otherwise, any positive integer is acceptable. -* **Tips:** In general, we recommend leaving this parameter to `0`, however some algorithms may take a very long time to run. If you're worried about this recommend setting this parameter to `2000` as a reasonable trade-off in many cases between run time and performance. - -#### use_uniform_fi -* **Description:** indicates whether or not to override any available (modeling-algorithm-specific) model-feature-importance estimation methods, instead using scikit-learn's [permutation importance](https://scikit-learn.org/stable/modules/permutation_importance.html) estimator uniformly for all algorithms -* **Format:** (bool) -* **Values:** `True` or `False` -* **Tips:** when `True`, model feature importance will be estimated in the same way for all models/algorithms. However, when `False` the following algorithms have their own unique strategies of estimating model feature importance, that will be used instead: (i.e. LR,DT,RF,XGB,LGB,GB,eLCS,XCS,ExSTraCS). Any algorithms without an internal strategy for estimating model feature importance will rely on permuation importance by default. - -#### primary_metric -* **Description:** the evaluation metric used to optimize hyperparameters -* **Format:** (str) -* **Values:** We recommend `'balanced_accuracy'`, `'roc_auc'`, or `'f1'` (based on the users needs/priorities), however it can be any available metric identifier from (https://scikit-learn.org/stable/modules/model_evaluation.html#scoring-parameter) - -#### metric_direction -* **Description:** indicates whether the [`primary_metric`](#primary_metric) should be maximized or minimized during hyperparameter optimization -* **Format:** (str) -* **Values:** `maximize` or `minimize` -* **Tips:** For almost all metrics (including `'balanced_accuracy'`, `'roc_auc'`, or `'f1'`), this should be `maximize` - -#### n_trials -* **Description:** an [Optuna](https://optuna.org/) parameter controlling the number of hyperparameter optimization trials to be conducted -* **Format:** (int) -* **Values:** any positive integer > `1`, (`200` by default) -* **Tips:** When this parameter is set to a larger value, hyperparameter optimization will take longer to complete, but a broader range of hyperparameter configurations will be considered which can improve algorithm modeling performance - -#### timeout -* **Description:** an [Optuna](https://optuna.org/) parameter controlling the total number of *seconds* until a given hyperparameter sweep stops running new trials -* **Format:** (int, or `None`) -* **Values:** any positive integer > `1`, (`900` by default, i.e. 15 minutes), or `None` -* **Tips:** To ensure STREAMLINE reproducibility, this parameter must be set to `None`, however this will force all algorithms to fully complete the number of trials specified by [`n_trials`](#n-trials). When set to an integer, Optuna will submit new trials (as previous ones complete), up until this time limit, and then only use the hyperparameter sweep trials it has completed to pick the best hyperparameter settings for the given algorithm. Any trial already started after this time limit is reached, will continue to run until completion. This means that one algorithm can spend more total time on hyperparameter trials than another, when this parameter is given a time limit. - -#### export_hyper_sweep_plots -* **Description:** indicates whether or not to generate an [Optuna](https://optuna.org/)-plot visualizing the hyperparameter sweep of an algorithm on a given dataset -* **Format:** (bool) -* **Values:** `True` or `False` - -#### do_lcs_sweep -* **Description:** indicates whether or not to apply an [Optuna](https://optuna.org/) hyperparameter sweep to one of the rule-based ML algorithms, i.e. (eLCS, XCS, ExSTraCS) -* **Format:** (bool) -* **Values:** `True` or `False` -* **Tips:** Learning classifier system (LCS), i.e. rule-based ML modeling algorithms can be computationally expensive, but have fairly reliable default run parameter settings. This parameter allow users to avoid a hyperparameter sweep, and train each LCS algorithm only once on manually specified run parameters. To save run time, in general we recommend leaving this parameter to `False` and specifying the LCS run parameters described below. Watch this [video](https://www.youtube.com/watch?v=CRge_cZ2cJc) to learn LCS basics. - -#### lcs_nu -* **Description:** specifies the *nu* parameter used by LCS algorithms (i.e. eLCS,XCS,ExSTraCS) -* **Format:** (int) -* **Values:** (`1` - `10`) -* **Tips:** higher values place more pressure for these algorithms to generate perfectly accurate rules, which easily leads to overfitting in noisy problems. Unless you know that your models should be able to achieve 100% testing accuracy on the target data, we recommend leaving this parameter to the default of `1`. Watch this [video](https://www.youtube.com/watch?v=CRge_cZ2cJc) to learn LCS basics. - -#### lcs_iterations -* **Description:** specifies the number of learning iterations an LCS algorithm will run (i.e. eLCS,XCS,ExSTraCS) -* **Format:** (int) -* **Values:** a positive integer at least two times larger than the number of training instances in the target data -* **Tips:** each iteration, an LCS algorithm focuses on one instance in the training dataset, thus this parameter should always be larger (ideally much larger) than the number of training instances in the data. For most users we recommend the default value of `200000` as a starting point, however, as a key run parameter, more learning iterations is typically expected to improve LCS algorithm performance. Watch this [video](https://www.youtube.com/watch?v=CRge_cZ2cJc) to learn LCS basics. - -#### lcs_N -* **Description:** specifies the maximum rule-population size for an LCS algorithm (i.e. eLCS,XCS,ExSTraCS) -* **Format:** (int) -* **Values:** a positive integer > `50` -* **Tips:** LCS algorithms learn a population (i.e set) of rules that collectively constitute the learned model. When this parameter is larger, LCS will take longer to run. However, LCS algorithms require a larger rule-population to solve more complex problems or analyze larger datasets. For most users we recommend the default value of `2000` as a starting point, however, as a key run parameter, a larger rule-population is typically expected to improve LCS algorithm performance. Watch this [video](https://www.youtube.com/watch?v=CRge_cZ2cJc) to learn LCS basics. - -#### lcs_timeout -* **Description:** similar to [`timeout`](#timeout), this [Optuna](https://optuna.org/) parameter controlling the total number of *seconds* until an LCS algorithm hyperparameter sweep stops running new trials. LCS uses a separate run parameter for this since it can take alot longer to run an LCS hyperparameter sweep. -* **Format:** (int, or `None`) -* **Values:** any positive integer > `1`, (`1200` by default, i.e. 20 minutes), or `None` -* **Tips:** To ensure STREAMLINE reproducibility, this parameter must be set to `None` if [`do_lcs_sweep`](#do-lcs-sweep) = `True`, however this will force LCS algorithms to fully complete the number of trials specified by [`n_trials`](#n-trials). When set to an integer, Optuna will submit new trials (as previous ones complete), up until this time limit, and then only use the hyperparameter sweep trials it has completed to pick the best hyperparameter settings for the given LCS algorithm. Any trial already started after this time limit is reached, will continue to run until completion. This means that one LCS algorithm can spend more total time on hyperparameter trials than another, when this parameter is given a time limit. - -#### model_resubmit -* **Description:** boolean flag telling STREAMLINE that this is a secondary run attempt of phase 5 (i.e. modeling) -* **Format:** [Command Line Argument] just use flag (i.e. `--model-resubmit`), [Configuration File] (bool) -* **Values:** `True` or `False` -* **Tips:** set this parameter to `True` either because (1) one of the previous model training jobs timed-out, or failed and the user wants to re-submit them or (2) the user had previously run phase 5 on a subset of available algorithms, but now they'd like to run additional algorithms - -*** -### Post-Analysis Parameters (Phase 6) - -#### exclude_plots -* **Description:** allows users to exclude some of the outputs automatically generated by STREAMLINE during phase 6 (post-analysis) -* **Format:** - 1. for notebook or config file modes: provide a (list) of valid options (str), e.g. `['plot_ROC','plot_PRC']` - 2. for command line arguments: provide as a list of comma separated values with no spaces, e.g. `plot_ROC,plot_PRC` -* **Values:** `None`, or [`'plot_ROC'`, `'plot_PRC'`, `'plot_FI_box'`, or `'plot_metric_boxplots'`] - provided in format above - * `plot_ROC` - don't output ROC plots individually for each algorithm including all CV results and averages - * `plot_PRC` - don't output PRC plots individually for each algorithm including all CV results and averages - * `plot_FI_box` - don't output model feature importance boxplots for each algorithm - * `plot_metric_boxplots` - don't output evaluation metric boxplots for each metric comparing algorithm performance - -#### metric_weight -* **Description:** the evaluation metric used to weigh model feature importance estimates in the composite feature importance plots -* **Format:** (str) -* **Values:** `balanced_accuracy` or `roc_auc` -* **Tips:** we recommend setting the this parameter the same as [`primary_metric`](#primary-metric) if possible - -#### top_model_fi_features -* **Description:** the number of top scoring features (based on model feature importance estimates) to illustrate in feature importance figures (i.e. feature importance boxplots, and composite feature importance plots) -* **Format:** (int) -* **Values:** an integer between `10` and `40` is recommended -* **Tips:** - -*** -### Replication Parameters (Phase 8) - -#### exclude_rep_plots -* **Description:** allows users to exclude some of the outputs automatically generated by STREAMLINE during phase 8 (replication) -* **Format:** - 1. for notebook or config file modes: provide a (list) of valid options (str), e.g. `['plot_ROC', 'plot_PRC']` - 2. for command line arguments: provide as a list of comma separated values with no spaces, e.g. `plot_ROC,plot_PRC` -* **Values:** `None`, or [`'feature_correlations'`,`'plot_ROC'`, `'plot_PRC'`, or `'plot_metric_boxplots'`] - provided in format above - * `feature_correlations` - don't output feature correlation heatmaps for the replication datasets during replication EDA - * `plot_ROC` - don't output ROC plots individually for each algorithm including all CV results and averages - * `plot_PRC` - don't output PRC plots individually for each algorithm including all CV results and averages - * `plot_metric_boxplots` - don't output evaluation metric boxplots for each metric comparing algorithm performance - -*** -### Cleanup Parameters - -#### del_time -* **Description:** boolean flag telling STREAMLINE to delete individual runtime files from the output experiment folder -* **Format:** [Command Line Argument] just use flag (i.e. `--del-time`), [Configuration File] (bool) -* **Values:** `True` or `False` - -#### del_old_cv -* **Description:** boolean flag telling STREAMLINE to delete intermediary cross validation datasets (i.e. training and testing datasets prior to completed data processing, imputation, scaling, and feature selection) form the output experiment folder -* **Format:** [Command Line Argument] just use flag (i.e. `--del-old-cv`), [Configuration File] (bool) -* **Values:** `True` or `False` -* **Tips:** this parameter is only relevant if [`overwrite_cv`](#overwrite-cv) was set to `False` - -*** -### Multiprocessing Parameters - -#### run_parallel -* **Description:** indicates whether or not to run STREAMLINE in parallel (locally) with CPU core multiprocessing -* **Format:** (bool) -* **Values:** `True` or `False` -* **Tips:** this parameter is only relevant when [`run_cluster](#run-cluster) = `False` - -#### run_cluster -* **Description:** indicates whether or not to run STREAMLINE on an dask-compatible computing cluster (HPC) -* **Format:** (bool or str) -* **Values:** `False`, or a string identifying the cluster type from options below: - * `LSF` - LSFCluster - * `SLURM` - SLURMCluster - * `HTCondor` - HTCondorCluster - * `Moab` - MoabCluster - * `OAR` - OARCluster - * `PBS` - PBSCluster - * `SGE` - SGECluster - * `UGE` - SGECluster variant used at our institution - * `Local` - LocalCluster - * `SLURMOld` - Legacy job submission for SLURMCluster - * `LSFOld` - Legacy job submission for LSFCluster -* **Tips:** The default of `"SLURM"` is specific to our institutions HPC hardware/software, and may not be relevant to many users - -#### reserved_memory -* **Description:** the memory (in Gigabytes) reserved for STREAMLINE jobs -* **Format:** (int) -* **Values:** an integer generally > `1` or < the maximum memory available for an HPC job on your system (consult your cluster documentation or administrator) - -#### queue -* **Description:** indiates the queue within your HPC where your STREAMLINE jobs will be scheduled to run -* **Format:** (str) -* **Values:** any viable str name for a queue you have access to at your institution -* **Tips:** The default of `"defq"` is specific to our institutions HPC hardware/software, and may not be relevant to many users - -*** -### Logging Parameters - -#### verbose -* **Description:** boolean flag telling STREAMLINE to send all print output and warnings to the command line output -* **Format:** [Command Line Argument] just use flag (i.e. `--verbose`), [Configuration File] (bool) -* **Values:** `True` or `False` - -#### logging_level -* **Description:** boolean flag telling STREAMLINE what loggin level to use in the command line output -* **Format:** [Command Line Argument] just use flag (i.e. `--logging-level`), [Configuration File] (bool) -* **Values:** `True` or `False` - -*** -## Guidelines for Setting Parameters - -### Ensuring Output Reproducibility -STREAMLINE is completely reproducible when the [`timeout`](#timeout) parameter is set to `None`, and. This also assumes that STREAMLINE is being run on the same datasets, with the same run parameters (including [`random_state`](#random-state)). - -When [`timeout`](#timeout) is *not* set to `None`, STREAMLINE output can sometimes vary slightly (particularly when parallelized) since Optuna (for hyperparameter optimization) may not complete the same number of optimization trials within the user specified time limit on different -computing resources. - -However, having a [`timeout`](#timeout) value specified helps ensure STREAMLINE run completion within a reasonable time frame. - -### Reducing Runtime and Memory Use -Conducting a more effective ML analysis typically demands a much larger amount of computing power and runtime. However, we provide general guidelines here for limiting overall runtime of a STREAMLINE experiment. -1. Run/include a fewer number of datasets in [`dataset_path`](#dataset_path) at once. -2. Run using fewer ML [`algorithms`](#algorithms) at once: - * Naive Bayes, Logistic Regression, and Decision Trees are typically fastest. - * Genetic Programming, eLCS, XCS, and ExSTraCS often take the longest (however other algorithms such as SVM, KNN, and ANN can take even longer when the number of instances is very large). -3. Run using a smaller number of [`cv_partitions`](#cv-partitions). -4. Run without generating additional plots (see [`exclude_eda_output`](#exclude-eda-output), [`export_hyper_sweep_plots`](#export-hyper-sweep-plots),[`exclude_plots`](#exclude-plots), [`exclude_rep_plots`](#exclude-rep-plots)). -5. In large datasets with missing values, set [`multi_impute`](#multi-impute) to `False`. This will apply simple mean imputation to numerical features instead (saving computational time, memory and output file space). -6. Set [`use_TURF`](#use-turf) as `False`. However we strongly recommend setting this to `True` in feature spaces > 10,000 in order to avoid missing feature interactions during feature selection. -7. Set [`TURF_pct`](#turf-pct) no lower than 0.5. Setting at 0.5 is by far the fastest, but it will operate more effectively in very large feature spaces when set lower. -8. Set [`instance_subset`](#instance-subset) at or below `2000` (speeds up multiSURF feature importance evaluation at potential expense of performance). -9. Set [`max_features_to_keep`](#max-features-to-keep) at or below `2000` and [`filter_poor_features`](#filter-poor-features) = `True` (this limits the maximum number of features that can be passed on to ML modeling). -10. Set [`training_subsample`](#training-subsample) at or below `2000` (this limits the number of sample used to train particularly expensive ML modeling algorithms). However avoid setting this too low, or ML algorithms may not have enough training instances to effectively learn. -11. Set [`n_trials`](#n-trials) and/or [`timeout`](#timeout) to lower values (this limits the time spent on hyperparameter optimization). -12. If using eLCS, XCS, or ExSTraCS, set [`do_lcs_sweep`](#do-lcs-sweep) to `False`, [`lcs_iterations`](#lcs_iterations) at or below `200000`, and [`lcs_n`](#lcs-n) at or below `2000`. - -### Improving Modeling Performance -* Generally speaking, the more computational time you are willing to spend on ML, the better the results. Doing the opposite of the above tips for reducing runtime, will likely improve performance. -* In certain situations, setting [`filter_poor_features`](#filter-poor-features) to `False`, and relying on the ML algorithms alone to identify relevant features can possibly yield better performance. However, this may only be computationally practical when the total number of features in an original dataset is smaller (e.g. under 2000). -* Note that eLCS, XCS, and ExSTraCS are newer algorithm implementations developed by our research group. As such, their algorithm performance may not yet be optimized in contrast to the other well established and widely utilized options. These learning classifier system (LCS) algorithms are unique however, in their ability to model very complex associations in data, while offering a largely interpretable model made up of simple, human readable IF:THEN rules. They have also been demonstrated to be able to tackle both complex feature interactions as well as heterogeneous patterns of association (i.e. different features are predictive in different subsets of the training data). -* In problems with no noise (i.e. datasets where it is possible to achieve 100% testing accuracy), LCS algorithms (i.e. eLCS, XCS, and ExSTraCS) perform better when [`lcs_nu`](#lcs-nu) is set larger than `1` (i.e. `5` or `10` recommended). This applies significantly more pressure for individual rules to achieve perfect accuracy. In noisy problems this may lead to significant overfitting. - -### Other Guidelines -* SVM and ANN modeling should only be applied when data scaling is applied by the pipeline. -* Logistic Regression' baseline model feature importance estimation is determined by the exponential of the feature's coefficient. This should only be used if data scaling is applied by the pipeline. Otherwise [`use_uniform_fi`](#use_uniform_fi) should be `True`. -* While the STREAMLINE includes [`impute_data`](#impute-data) as an option that can be turned off in phase 2, most algorithm implementations (all those standard in scikit-learn) cannot handle missing data values with the exception of eLCS, XCS, and ExSTraCS. In general, STREAMLINE is expected to fail with an errors if run on data with missing values, while [`impute_data`](#impute-data) is set to `False`. +STREAMLINE parameters can be supplied through notebooks, `.cfg` files, or +phase CLI flags. The `.cfg` names intentionally match the command-line names +where possible. + +## Shared Run Parameters + +| Parameter | Typical value | Used by | Description | +| --- | --- | --- | --- | +| `output_path` | `out` | all phases | Parent folder for experiment outputs. | +| `experiment_name` | `UCIHCCPipeline` | all phases | Experiment folder name. | +| `outcome_label` | `Class`, `MPG` | P1, P6, P8, P9, P11 | Outcome column. | +| `outcome_type` | `Binary`, `Multiclass`, `Continuous` | P1, P6, P8, P9, P11 | Learning task type. | +| `instance_label` | `InstanceID` | P1, P6-P11 | Optional row identifier column. | +| `n_splits` | `3`, `5`, `10` | CV-aware phases | Number of CV folds. | +| `run_cluster` | `Serial`, `Local`, `Parallel`, `BashSLURM`, `BashLSF` | all phases | Execution mode. `Local` uses a local Dask cluster; `Parallel` uses local joblib parallelism. | +| `random_state` | `42` | stochastic phases | Seed for reproducibility. | + +## Phase Toggles + +The `[phases]` section controls which phases run: + +```ini +[phases] +phase_order = p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11 +do_p1 = True +do_p2 = True +do_p3 = True +do_p4 = True +do_p5 = True +do_p6 = True +do_p7 = True +do_p8 = True +do_p9 = True +do_p10 = True +do_p11 = True +``` + +The runner also accepts old-style broad flags such as `do_till_report`. + +## P1 Data Process + +| Parameter | Default or example | Description | +| --- | --- | --- | +| `data_path` | `data/UCIBinaryClassification` | Folder containing one or more input datasets. | +| `categorical_features` | `data/UCIFeatureTypes/hcc_survival_categorical_features.csv` | Optional feature-name file. | +| `quantitative_features` | `data/UCIFeatureTypes/hcc_survival_quantitative_features.csv` | Optional feature-name file. | +| `ignore_features` | empty | Optional feature-name file/list to drop. | +| `partition_method` | `Stratified` or `Random` | CV partitioning strategy. | +| `categorical_cutoff` | `10` | Inference threshold when feature type files are absent. | +| `one_hot_encoding` | `True` | Expand categorical features in P1. | +| `force` | `False` | Overwrite existing phase outputs. | + +## P2 Impute And Scale + +| Parameter | Default or example | Description | +| --- | --- | --- | +| `imputer_id` | phase default | Registry imputer. | +| `scaler_id` | phase default | Registry scaler. | +| `smote` | `False` | Apply training-fold oversampling after imputation/scaling. | +| `smote_method` | `auto` | Use `SMOTENC` when categorical features are present, otherwise `SMOTE`. | + +## P3 Feature Learning + +| Parameter | Default or example | Description | +| --- | --- | --- | +| `learner_id` | `pca` | Feature learner registry ID. | +| `learner_params` | `{}` | JSON/Python-literal dictionary of learner parameters. | +| `keep_original_features` | `True` | Keep input features alongside learned features. | + +## P4 Feature Importance + +| Parameter | Default or example | Description | +| --- | --- | --- | +| `models` | all registered methods | Feature-importance methods to run. | +| `models_params` | method dictionary | Per-method parameter dictionary. STREAMLINE injects ReBATE `categorical_features` from saved feature-type artifacts. | +| `instance_subset` | not used unless provided | Optional sampling limit for expensive methods. | + +## P5 Feature Selection + +| Parameter | Default or example | Description | +| --- | --- | --- | +| `selector_id` | `default` | Feature selector registry ID. | +| `algorithms` | `auto` | Feature-importance methods considered by selector logic. | +| `top_features` | `20` | Number of features to keep when applicable. | + +## P6 Modeling + +| Parameter | Default or example | Description | +| --- | --- | --- | +| `outcome_type` | `Binary`, `Multiclass`, `Continuous` | Modeling task. `model_type` is still accepted as a backward-compatible alias. | +| `models` | `NB,LR,DT` | Model registry IDs. | +| `scoring_metric` | `balanced_accuracy`, `explained_variance` | Optuna/evaluation metric. | +| `metric_direction` | `maximize` or `minimize` | Optimization direction. | +| `n_trials` | `200` | Optuna trial budget. | +| `timeout` | `900` | Optuna time budget in seconds. | +| `training_subsample` | `0` | Optional training subset size. | +| `calibrate` | `0` or `1` | Classification calibration toggle. | +| `bypass_one_hot_for_native_models` | `True` | Allow native categorical model path. | +| `native_categorical_models` | `CGB,ExSTraCS` | Models allowed when P1 did not one-hot encode. | + +P6 records Optuna trial accounting in model outputs so reports can show how +many trials actually ran within the requested budget. + +## P7 Ensembles + +P7 is classification-only in the current codebase. + +| Parameter | Default or example | Description | +| --- | --- | --- | +| `ensembles` | `hard_voting,soft_voting,stack_lr` | Ensemble registry IDs. | +| `base_models` | `NB,LR,DT` | Base model predictions to combine. | +| `meta_train_source` | `train` | Source for stacking meta-training. | + +## P8 To P11 + +| Phase | Key parameters | Notes | +| --- | --- | --- | +| P8 Summary | `scoring_metric`, `metric_weight`, `top_features`, `include_ensembles` | Aggregates model, ensemble, and feature outputs. | +| P9 Compare | `sig_cutoff`, `show_plots` | Compares datasets in an experiment. | +| P10 Replication | `rep_data_path`, `dataset_for_rep`, `show_plots` | Applies trained workflows to external data. | +| P11 Reporting | `report_modes`, `report_mode`, `make_pdf`, `enable_plots`, `reuse_existing_figures` | Builds standard and replication reports. | + +## Saved Run Command Controls + +All phase CLIs support: + +| Flag | Behavior | +| --- | --- | +| `--ignore_saved_run_command` | Ignore `run_commands.pickle` for this run. | +| `--no_update_saved_run_command` | Do not update `run_commands.pickle` after the run. | diff --git a/docs/source/pictures/STREAMLINE_Figures.png b/docs/source/pictures/STREAMLINE_Figures.png deleted file mode 100644 index 0f22a4cc..00000000 Binary files a/docs/source/pictures/STREAMLINE_Figures.png and /dev/null differ diff --git a/docs/source/pictures/STREAMLINE_paper_new_lightcolor.png b/docs/source/pictures/STREAMLINE_paper_new_lightcolor.png deleted file mode 100644 index abe3bc2d..00000000 Binary files a/docs/source/pictures/STREAMLINE_paper_new_lightcolor.png and /dev/null differ diff --git a/docs/source/pictures/STREAMLINE_v3_paper_new_lightcolor.png b/docs/source/pictures/STREAMLINE_v3_paper_new_lightcolor.png new file mode 100644 index 00000000..31870af7 Binary files /dev/null and b/docs/source/pictures/STREAMLINE_v3_paper_new_lightcolor.png differ diff --git a/docs/source/pipeline.md b/docs/source/pipeline.md index 38099360..a626e6fb 100644 --- a/docs/source/pipeline.md +++ b/docs/source/pipeline.md @@ -1,201 +1,212 @@ -# Detailed Pipeline Walkthrough -This section is for users who want a more detailed understanding of (1) what STREAMLINE does, (2) what happens in durring each phase, (3) why it's designed the way it has been, (4) what user options are available to customize a run, and (5) what to expect when running a given phase. Phases 1-6 make up the core automated pipeline, with Phase 7 and beyond being run optionally based on user needs. Phases are organized to both encapsulate related pipeline elements, as well as to address practical computational needs. STREAMLINE includes reliable default run parameters so that it can easily be used 'as-is', but these parameters can be adjusted for further customization. We refer to a single run of the entire STREAMLINE pipeline as an 'experiment', with all outputs saved to a single 'experiment folder' for later examination and re-use. +# Detailed Pipeline Walkthrough + +This page explains what STREAMLINE does during a run, why the phases are +separated, what users can customize, and which outputs to expect. A single +STREAMLINE run is called an **experiment**. Each experiment can contain one or +more datasets, and each dataset is processed through cross-validation folds so +that model evaluation stays separated from model training. + +The current v1.0.0 pipeline has eleven phases. P1-P8 are the core training and +summary workflow, P9 compares multiple datasets inside an experiment, P10 +applies trained workflows to external replication data, and P11 produces PDF +reports. -To avoid confusion on 'dataset' terminology we briefly review our definitions here: -1. **Target dataset** - A whole dataset (minus any instances the user may wish to hold out for replication) that has not yet undergone any other data partitioning and is intended to be used in the training and testing of models within STREAMLINE. Could also be referred to as the 'development dataset'. -2. **Training dataset** - A generally larger partition of the target dataset used in training a model -3. **Testing dataset** - A generally smaller partition of the target dataset used to evaluate the trained model -4. **Validation dataset** - The temporary, secondary hold-out partition of a given training dataset used for hyperparameter optimization. This is the product of using nested (aka double) cross-validation in STREAMLINE as a whole. -5. **Replication dataset** - Further data that is withheld from STREAMLINE phases 1-7 to (1) compare model evaluations on the same hold-out data and (2) verify the replicatability and generalizability of model performance on data collected from other sites or sample populations. A replication dataset should have at least all of the features present in the target dataset which it seeks to replicate. +## Dataset Terms -*** -## Phase 1: Data Exploration & Processing -This phase; (1) provides the user with key information about the target dataset(s) they wish to analyze, via an initial exploratory data analysis (EDA) (2) numerically encodes any text-based feature values in the data, (3) applies basic data cleaning and feature engineering to process the data, (4) informs the user how the data has been changed by the data processing, via a secondary, more in-depth EDA, and then (5) partitions the data using k-fold cross validation. +| Term | Meaning | +| --- | --- | +| Target dataset | The input dataset supplied to P1 for model development. | +| Training fold | The fold-specific subset used to fit preprocessing, feature learning, feature selection, and models. | +| Testing fold | The fold-specific subset held out for model evaluation. | +| Validation split | The internal split made inside model training for Optuna hyperparameter search. | +| Replication dataset | An external or held-out dataset used in P10 after the main training/CV workflow has already produced fitted artifacts. | -* **Parallelizability:** Runs once for each target dataset to be analyzed -* **Run Time:** Typically fast, except when evaluating and visualizing feature correlation in datasets with a large number of features +Replication data should not be used to tune model choices. It is meant to +evaluate whether the trained workflow generalizes beyond the original CV test +folds. -### Initial EDA -Characterizes the orignal dataset as loaded by the user, including: data dimensions, feature type counts, missing value counts, class balance, other standard pandas data summaries (i.e. describe(), dtypes(), nunique()) and feature correlations (pearson). +## Phase Summary -For precision, we strongly suggest users identify which features in their data should be treated as categorical vs. quantitative using the [`categorical_feature_path`](parameters.md#categorical-feature-path) and/or [`quantitative_feature_path`](parameters.md#quantitative-feature-path) run parameters. However, if not specified by the user, STREAMLINE will attempt to automatically determine feature types relying on the [`categorical_cutoff`](parameters.md#categorical-cutoff) parameter. Any features with fewer unique values than [`categorical_cutoff`](parameters.md#categorical-cutoff) will be treated as categorical, and all others will be treated as quantitative. +| Phase | Module | Main CLI | Summary | +| --- | --- | --- | --- | +| P1 | `streamline.p1_data_process` | `python -m streamline.p1_data_process.p1_cli` | Load datasets, clean/encode columns, generate EDA outputs, and create CV folds. | +| P2 | `streamline.p2_impute_scale` | `python -m streamline.p2_impute_scale.p2_cli` | Impute, scale, and optionally apply SMOTE/SMOTENC to training folds. | +| P3 | `streamline.p3_feature_learning` | `python -m streamline.p3_feature_learning.p3_cli` | Add learned features such as PCA components and save fitted transformers/manifests. | +| P4 | `streamline.p4_feature_importance` | `python -m streamline.p4_feature_importance.p4_cli` | Score features without mutating shared CV datasets. | +| P5 | `streamline.p5_feature_selection` | `python -m streamline.p5_feature_selection.p5_cli` | Select informative features and persist selected CV datasets. | +| P6 | `streamline.p6_modeling` | `python -m streamline.p6_modeling.p6_cli` | Train base models, tune with Optuna, evaluate CV metrics, and save predictions. | +| P7 | `streamline.p7_ensembles` | `python -m streamline.p7_ensembles.p7_cli` | Build classification ensembles from base model predictions. | +| P8 | `streamline.p8_summary_statistics` | `python -m streamline.p8_summary_statistics.p8_cli` | Aggregate performance, feature importance, and model summaries. | +| P9 | `streamline.p9_compare_datasets` | `python -m streamline.p9_compare_datasets.p9_cli` | Compare dataset-level outputs within an experiment. | +| P10 | `streamline.p10_replication` | `python -m streamline.p10_replication.p10_cli` | Apply trained workflows to replication datasets. | +| P11 | `streamline.p11_reporting` | `python -m streamline.p11_reporting.p11_cli` | Generate standard and replication PDF reports. | -* **Output:** (1) CSV files for all above data characteristics, (2) bar plot of class balance, (3) histogram of missing values in data, (4) feature correlation heatmap +## P1: Data Process -### Numerical Encoding of Text-based Features -Detects any features in the data with non-numeric values and applies [LabelEncoder](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.LabelEncoder.html) to make them numeric as required by scikit-learn machine learning packages. +P1 loads one or more tabular datasets, applies initial cleaning and feature +engineering, records exploratory summaries, and creates cross-validation +train/test folds. -### Basic Data Cleaning and Feature Engineering -Applies the following steps to the target data, keeping track of changes to all data counts along the way: -1. Remove any instances that are missing an outcome label (as these can not be used while conducting supervised learning) -2. Remove any features identified by the user with [`ignore_features_path`](parameters.md#ignore-features-path) (a convenience for users that may wish to exclude one or more features from the analysis without changing the original dataset) -3. Engineer/add 'missingness' features. Any original feature with a missing value proportion greater than [`featureeng_missingness`](parameters.md#featureeng-missingness) will have a new feature added to the dataset that encodes missingness with 0 = not missing and 1 = missing. This allows the user to examine whether missingness is ['not at random' (MNAR)](https://en.wikipedia.org/wiki/Missing_data), and is predictive of outcome itself. -4. Remove any features that have invariant values (i.e. they are always the same), or that have only one value in addition to missing values. Then remove any features with a missingness greater than [`cleaning_missingness`](parameters.md#cleaning-missingness). Afterwards, remove any instances in the data that may have a missingness greater than [`cleaning_missingness`](parameters.md#cleaning-missingness). -5. Engineer/add [one-hot-encoding](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html) for any categorical features in the data. This ensures that all categorical features are treated as such throughout all aspects of the pipeline. For example, a single categorical feature with 3 possible states will be encoded as 3 separate binary-valued features indicating whether an instance has that feature's state or not. Feature names are automatically updated by STREAMLINE to reflect this change. -6. Remove highly correlated features based on [`correlation_removal_threshold`](parameters.md#correlation-removal-threshold). Randomly removes one feature of a highly correlated feature pair (Pearson). While perfectly correlated features can be safely cleaned in this way, there is a chance of information loss when removing less correlated features. +Common work in P1 includes: -* **Output:** CSV file summarizing changes to data counts during these cleaning and engineering steps. +* removing instances with missing outcomes +* excluding identifier or user-ignored columns +* applying user-provided or inferred feature types +* adding missingness indicator features when requested +* removing invariant, high-missingness, or highly correlated features +* optionally one-hot encoding categorical features +* creating stratified, random, grouped, or provided CV folds -### Processed Data EDA -Completes a more comprehensive EDA of the processed dataset including: everything examined in the initial EDA, as well as a univariate association analysis of all features using Chi-Square (for categorical features), or Mann-Whitney U-Test (for quantitative features). +Important settings include `outcome_label`, `outcome_type`, `instance_label`, +`categorical_features`, `quantitative_features`, `ignore_features`, +`partition_method`, `n_splits`, `one_hot_encoding`, and `force`. -* **Output:** (1) CSV files for all above data characteristics, (2) bar plot of class balance, (3) histogram of missing values in data, (4) feature correlation heatmap, (5) a CSV file summarizing the univariate analyses including the test applied, test statistic, and p-value for each feature, (6) for any feature with a univariate analysis p-value less than [`sig_cutoff`](parameters.md#sig-cutoff) (i.e. significant association with outcome), a bar-plot will be generated if it is categorical, and a box-plot will be generated if it is quantitative. +Outputs include dataset summaries, feature-type artifacts, EDA tables/figures, +and the initial `CVDatasets/` train/test files used by later phases. -### k-fold Cross Validation (CV) Partitioning -For k-fold CV, STREAMLINE uses 'Stratified' partitioning by default, which aims to maintain the same/similar class balance within the 'k' training and testing datasets. The value of 'k' can be adjusted with [`cv_partitions`](parameters.md#cv-partitions). However using [`partition_method`](parameters.md#partition-method), users can also select 'Random' or 'Group' partitioning. +## P2: Impute, Scale, And Balance -Of note, 'Group' partitioning requires the dataset to include a column identified by [`match_label`](parameters.md#match-label). This column includes a group membership identifier for each instance which indicates that any instance with the same group ID should be kept within the same partition during cross validation. This was originally intended for running STREAMLINE on epidemiological data that had been matched for one or more covariates (e.g. age, sex, race) in order to adjust for their effects during modeling. +P2 learns missing-value imputation and feature scaling from each training fold +and applies the learned transformations to the corresponding test fold. This +prevents leakage from test data into preprocessing. -* **Output:** CSV files for each training and testing dataset generated following partitioning. Note, by default STREAMLINE will overwrite these files as the working datasets undergo imputation, scaling and feature selection in subsequent phases. However, the user can keep copies of these intermediary CV datasets for review using the parameter [`overwrite_cv`](parameters.md#overwrite-cv). +P2 can also apply SMOTE/SMOTENC to training folds after imputation and scaling. +This is intended for classification tasks with meaningful class imbalance. +When `smote_method = auto`, STREAMLINE uses SMOTENC when categorical features +are present and standard SMOTE otherwise. -*** -## Phase 2: Imputation and Scaling -This phase conducts additional data preparation elements of the pipeline that occur after CV partitioning, i.e. missing value imputation and feature scaling. Both elements are 'trained' and applied separately to each individual training dataset. The respective testing datasets are not looked at when running imputation or feature scaling learning to avoid potential data leakage. However the learned imputation and scaling patterns are applied in the same way to the testing data as they were in the training data. Both imputation and scaling can optionally be turned off using the parameters [`impute_data`](parameters.md#impute-data) and [`scale_data`](parameters.md#scale-data), respectively for some specific use cases, however imputation must be on when missing data is present in order to run most scikit-learn modeling algorithms, and scaling should be on for certain modeling algorithms learn effectively (e.g. artificial neural networks), and for if the user wishes to infer feature importances directly from certain algorithm's internal estimators (e.g. logistic regression). +Outputs include transformed CV datasets and saved imputation/scaling metadata. -* **Parallelizability:** Runs 'k' times for each target dataset being analyzed (where k is number of CV partitions) -* **Run Time:** Typically fast, with the exception of imputing larger datasets with many missing values +## P3: Feature Learning -### Imputation -This phase first conducts imputation to replace any remaining missing values in the dataset with a 'value guess'. While missing value imputation could be reasonably viewed as data manufacturing, it is a common practice and viewed here as a necessary 'evil' in order to run scikit-learn modeling algorithms downstream (which mostly require complete datasets). Imputation is completed prior to scaling since it can influence the correct center and scale to be used. +P3 applies feature-learning methods such as PCA. Learned transformations are +fit on training folds and applied consistently to test folds and replication +data. -Missing value imputation seeks to make a reasonable, educated guess as to the value of a given missing data entry. By default, STREAMLINE uses 'mode imputation' for all categorical values, and [multivariate imputation](https://scikit-learn.org/stable/modules/generated/sklearn.impute.IterativeImputer.html) for all quantitative features. However, for larger datasets, multivariate imputation can be slow and require alot of memory. Therefore, the user can deactivate multiple imputation with the [`multi_impute`](parameters.md#multi-impute) -parameter, and STREAMLINE will use median imputation for quantitative features instead. +Users can choose whether learned features replace the original feature set or +are added alongside original features. P3 writes manifests so later phases know +which columns were learned and how to reproduce them. -### Scaling -Second, this phase conducts feature scaling with [StandardScalar](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html) to transform features to have a mean at zero with unit variance. This is only necessary for certain modeling algorithms, but it should not hinder the performance of other algorithms. The primary drawback to scaling prior to modeling is that any future data applied to the model will need to be scaled in the same way prior to making predictions. Furthermore, for algorithms that have directly interpretable models (e.g. decision tree), the values specified by these models need to be un-scaled in order to understand the model in the context of the original data values. STREAMLINE includes a [Useful Notebook](more.md) that can generate direct model visualizations for decision tree and genetic programming models. This code automatically un-scales the values specified in these models so they retain their interpretability. +## P4: Feature Importance -* **Output:** (1) Learned imputation and scaling strategies for each training dataset are saved as pickled objects allowing any replication or other future data to be identically processed prior to running it through the model. (2) If [`overwrite_cv`](parameters.md#overwrite-cv) is False, new imputed and scaled copies of the training and testing datasets are saved as CSV output files, otherwise the old dataset files are overwritten with these new ones to save space. +P4 runs filter-style feature-importance methods on each training fold. Current +methods include mutual information and ReBATE-based methods such as MultiSURF, +MultiSURF*, MultiSWRFDB, and MultiSWRFDB*. -*** -## Phase 3: Feature Importance Estimation -This phase applies feature importance estimation algorithms (i.e. [Mutual information (MI)](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.mutual_info_classif.html) and [MultiSURF](https://github.com/UrbsLab/scikit-rebate), found in the ReBATE software package) often used as filter-based feature selection algorithms. Both algorithms are run by default, however the user can deactivate either using [`do_mutual_info`](parameters.md#do-mutual-info) or [`do_multisurf`](parameters.md#do-multisurf), respectively. MI scores features based on their univariate association with outcome, while MultiSURF scores features in a manner that is sensitive to both univariate and epistatic (i.e. multivariate feature interaction) associations. +P4 writes feature scores only. It does not mutate the shared CV datasets, +which keeps model-specific feature-importance runs independent and avoids +race conditions in parallel execution. -For datasets with a larger number of features (i.e. > 10,000) we recommend turning on the TuRF wrapper algorithm with [`use_turf`](parameters.md#use-turf), which has been shown to improve the sensitivity of MultiSURF to interactions, particularly in larger feature spaces. Users can increase the number of TuRF iterations (and performance) by decreasing [`turf_pct`](parameters.md#turf-pct) from 0.5, to approaching 0. However, this will significantly increase MultiSURF run time. +Use `instance_subset` when a feature-importance method would be too slow on +all training instances. ReBATE methods receive categorical feature indexes +from STREAMLINE feature-type artifacts. -Overall, this phase is important not only for subsequent feature selection, but as an opportunity to evaluate feature importance estimates prior to modeling outside of the initial univariate analyses (conducted on the entire dataset). Further, comparing feature rankings between MI, and MultiSURF can highlight features that may have little or no univariate effects, but that are involved in epistatic interactions that are predictive of outcome. +## P5: Feature Selection -* **Parallelizability:** Runs 'k' times for each algorithm (MI and MultiSURF) and each target dataset being analyzed (where k is number of CV partitions) -* **Run Time:** Typically reasonably fast, but takes more time to run MultiSURF, in particular as the number of training instances approaches the default [`instance_subset`](parameters.md#instance-subset) parameter of 2000 instances, or if this parameter set higher in larger datasets. This is because MultiSURF scales quadratically with the number of training instances. +P5 consumes P4 rankings and creates selected-feature CV datasets. The default +selector can combine rankings from every feature-importance method that was +run, not only a fixed pair of methods. -* **Output:** CSV files of feature importance scores for both algorithms and each CV partition ranked from largest to smallest scores. +Important settings include `algorithms`, `selector_id`, `top_features`, +`max_features_to_keep`, and `filter_poor_features`. -*** -## Phase 4: Feature Selection -This phase uses the feature importance estimates learned in the prior phase to conduct feature selection using a 'collective' feature selection approach. By default, STREAMLINE will remove any features from the training data that scored 0 or less by both feature importance algorithms (i.e. features deemed uninformative). Users can optionally ensure retention of all features prior to modeling by setting [`filter_poor_features`](parameters.md#filter-poor-features) to False. Users can also specify a maximum number of features to retain in each training dataset using [`max_features_to_keep`](parameters.md#max-features-to_keep) (which can help reduce overall pipeline runtime and make learning easier for modeling algorithms). If after removing 'uninformative features' there are still more features present than the user specified maximum, STREAMLINE will pick the unique top scoring features from one algorithm then the next until the maximum is reached and all other features are removed. Any features identified for removal from the training data are similarly removed from the testing data. +Outputs include selected train/test folds and feature-selection summary files. -* **Parallelizability:** Runs 'k' times for each target dataset being analyzed (where k is number of CV partitions) -* **Run Time:** Fast +## P6: Modeling -* **Output:** (1) CSV files summarizing feature selection for a target dataset (i.e. how many features were identified as informative or uninformative within each CV partition) and (2) a barplot of average feature importance scores (across CV partitions). The user can specify the maximum number of top scoring features to be plotted using [`top_fi_features`](parameters.md#top-fi-features). +P6 trains and evaluates base models for binary classification, multiclass +classification, or regression. Model IDs are loaded from the registry for the +selected `outcome_type`. -*** -## Phase 5: Machine Learning (ML) Modeling -At the heart of STREAMLINE, this phase conducts (1) machine learning modeling using the training data, (2) model feature importance estimation (also with the training data), and (3) model evaluation on testing data. STREAMLINE uniquely includes 3 rule-based machine learning algorithms: ExSTraCS, XCS, and eLCS. These 'learning classifier systems' have been demonstrated to be able to detect complex associations while providing human interpretable models in the form of IF:THEN rule-sets. The ExSTraCS algorithm was developed by our research group to specifically handle the challenges of scalability, noise, and detection of epistasis and genetic heterogeneity in biomedical data mining. +For models with tunable hyperparameters, STREAMLINE uses Optuna with +`n_trials` and `timeout` budgets. P6 records how many trials actually ran, so +the report can distinguish requested budget from completed search. -* **Parallelizability:** Runs 'k' times for each algorithm and each target dataset being analyzed (where k is number of CV partitions) -* **Run Time:** Slowest phase, but can be sped up by reducing the set of ML methods selected to run, or deactivating ML methods that run slowly on large datasets +P6 also supports native categorical handling. If P1 was run with +`one_hot_encoding = False`, P6 defaults to native categorical models such as +CatBoost/CGB and ExSTraCS. Explicitly requesting an unsupported model raises an +error instead of silently changing the data representation. -### Model Selection -The first step is to decide which modeling algorithms to run. By default, STREAMLINE applies 14 of the 16 algorithms (excluding eLCS and XCS) it currently has built in. eLCS and XCS are currently experimental implementations of rule-based ML algorithms. Users can specify a specific subset of algorithms to run using [`algorithms`](parameters.md#algorithms), or alternatively indicate a list of algorithms to exclude from all available algorithms using [`exclude`](parameters.md#exclude). STREAMLINE is also set up so that more advanced users can add other scikit-learn compatible modeling algorithms to run within the pipeline (as explained in [Adding New Modeling Algorithms](models.md)). This allows STREAMLINE to be used as a rigorous framework to easily benchmark new modeling algorithms in comparison to other established algorithms. +Outputs include fitted model pickles, predictions, per-fold metrics, feature +importance estimates, and Optuna trial summaries. -Modeling algorithms vary in the implicit or explicit assumptions they make, the manner in which they learn, how they represent a solution (as a model), how well they handle different patterns of association in the data, how long they take to run, and how complex and/or interpretable the resulting model can be. To reduce runtime in datasets with a large number of training instances, users can specify a limited random number of training instances to use in training algorithms that run slowly in such datasets using [`training_subsample`](parameters.md#training-subsample). +## P7: Ensemble Modeling -In the STREAMLINE demo, we run only the fastest/simplest three algorithms (Naive Bayes, Logistic Regression, and Decision Tree), however these algorithms all have known limitations in their ability to detect complex associations in data. We encourage users to utilize a wider variety of the 14 established available algorithms, in their analyses, to give STREAMLINE the best opportunity to identify a best performing model for the given task (which is effectively impossible to predict for a given dataset ahead of time). +P7 builds classification ensembles from P6 base model predictions. Current +ensemble methods include hard voting, soft voting, and logistic-regression +stacking. -We recommend users utilize at least the following set of algorithms within STREAMLINE: Naive Bayes, Logistic Regression, Decision Tree, Random Forest, XGBoost, SVM, ANN, and ExSTraCS as we have found these to be a reliable set of algorithms with an array of complementary strengths and weaknesses on different problems. [ExSTraCS](https://github.com/UrbsLab/scikit-ExSTraCS) is a rule-based machine learning algorithm in the sub-family of algorithms called [learning classifier systems (LCS)](https://www.youtube.com/watch?v=CRge_cZ2cJc) that has been specifically adapted to the challenges of biomedical data analysis. +P7 is classification-only in the current v1.0.0 implementation. Regression +workflows should skip P7 and continue from P6 to P8. -### Hyperparameter Optimization -Most machine learning algorithms have a variety of hyperparameter options that influence how the algorithm runs and performs on a given dataset. In designing STREAMLINE we sought to identify the full set of important hyperparameters for each algorithm, along with a comprehensive range of possible settings and hard-coded these into the pipeline. STREAMLINE adopts the [Optuna](https://optuna.org/) package to conduct automated Bayesian optimization of hyperparameters for most algorithms by default. The evaluation metric 'balanced accuracy' is used to optimize hyperparameters as it takes class imbalance into account and places equal weight on the accurate prediction of both class outcomes. However, users can select an alternative metric with [`primary_metric`](parameters.md#primary-metric) and whether that metric needs to be maximized or minimized using the [`metric_direction`](parameters.md#metric-direction) parameter. To conduct the hyperparameter sweep, Optuna splits a given training dataset further, applying 3-fold cross validation to generate further internal training and validation partitions with which to evaluate different hyperparameter combinations. +## P8: Summary Statistics -Users can also configure how Optuna operates in STREAMLINE with [`n_trials`](parameters.md#n-trials) and [`timeout`](parameters.md#timeout) which controls the target number of hyperparameter value combination trials to conduct, as well as how much total time to try and complete these trials before picking the best hyperparameters found. To ensure reproducibility of the pipeline, note that [`timeout`](parameters.md#timeout) should be set to 'None' (however this can take much longer to complete depending on other pipeline settings). +P8 aggregates performance metrics and feature-importance outputs across folds. +It produces model summary tables, curve plots for classification, regression +diagnostic plots, composite feature-importance plots, and statistical +comparison tables where applicable. -Notable exceptions to most algorithms; Naive Bayes has no parameters to optimize, and rule-based (i.e. LCS) ML algorithms including ExSTraCS, eLCS, and XCS can be computationally expensive thus STREAMLINE is set to use their default hyperparameter settings without a sweep unless the user updates [`do_lcs_sweep`](parameters.md#do-lcs-sweep) and [`lcs_timeout`](parameters.md#lcs-timeout). While these LCS algorithms have many possible hyperparameters to manipulate they have largely stable performance when leaving most of their parameters to default values. Exceptions to this include the key LCS hyperparameters (1) number of learning iterations, (2) maximum rule-population size, and (3) accuracy pressure (nu), which can be manually controlled without a hyperparameter sweep by [`lcs_iterations`](parameters.md#lcs-iterations), [`lcs_N`](parameters.md#lcs-n), and [`lcs_nu`](parameters.md#lcs-nu), respectively. +For classification reports, no-skill ROC/PR baselines are computed from the +actual evaluation labels, so the baselines remain appropriate for multiclass +or non-stratified/random CV settings. -* **Output:** CSV files specifying the optimized hyperparameter settings found by Optuna for each partition and algorithm combination. +## P9: Compare Datasets -### Train 'Optimized' Model -Having selected the best hyperparameter combination identified for a given training dataset and algorithm, STREAMLINE now retrains each model on the entire training dataset using those respective hyperparameter settings. This yields a total of 'k' potentially 'optimized' models for each algorithm. +P9 compares datasets inside the same experiment. It is useful when an +experiment runs multiple related datasets or feature sets and the user wants +the same statistical summaries and visual comparisons across them. -* **Output:** All trained models are pickled as python objects that can be loaded and applied later. +If an experiment contains only one dataset, P9 may still run but has less to +compare. -### Model Feature Importance Estimation -Next, STREAMINE estimates and summarizes model feature importance scores for every algorithm run. This is distinct from the initial feature importance estimation phase, in that these estimates are specific to a given model as a useful part of model interpretation/explanation. By default, STREAMLINE employes [permutation feature importance](https://scikit-learn.org/stable/modules/permutation_importance.html) for estimating feature importances scores in the same uniform manner across all algorithms. Some ML algorithms that have a build in strategy to gather model feature importance estimates (i.e. LR,DT,RF,XGB,LGB,GB,eLCS,XCS,ExSTraCS). The user can instead use these estimates by setting [`use_uniform_fi`](parameters.md#use-uniform-fi) to `False`. This will direct STREAMLINE to report any available internal feature importance estimate for a given algorithm, while still utilizing permutation feature importance for algorithms with no such internal estimator. +## P10: Replication -* **Output:** All feature importance scores are pickled as python objects for use in the next phase of the pipeline. +P10 applies trained preprocessing, feature-learning, feature-selection, and +modeling artifacts to external replication datasets. This phase should be used +for data that were not part of training or CV evaluation. -### Evaluate Performance -The last step in this phase is to evaluate all trained models using their respective testing datasets. A total of 16 standard classification metrics calculated for each model including: balanced accuracy, standard accuracy, F1 Score, sensitivity (recall), specificity, precision (positive predictive value), true positives, true negatives, false postitives, false negatives, negative predictive value, likeliehood ratio positive, likeliehood ratio negative, area under the ROC, area under the PRC, and average precision of PRC. +The replication dataset must contain the required feature columns from the +training dataset schema. Replication outputs are written under each target +dataset's `replication/` folder. -* **Output:** All evaluation metrics are pickled as python objects for use in the next phase of the pipeline. +## P11: Reporting -*** -## Phase 6: Post-Analysis -This phase combines all modeling results to generate summary statistics files, generate results plots, and conduct non-parametric statistical significance analysis comparing ML performance across CV runs. +P11 builds standard and replication PDF reports from the experiment outputs. +The standard report focuses on P1-P9 training/CV results. The replication +report focuses on P10 external-validation results and uses a filename that +includes `Replication_Report`. -* **Output (Evaluation Metrics):** - 1. Testing data evaluation metrics for each CV partition - CSV file for each modeling algorithm - 2. Average testing data evaluation metrics for each modeling algorithm - CSV file for mean, median, and standard deviation - 3. ROC and PRC curves for each CV partition in contrast with the average curve - ROC and PRC plot for each modeling algorithm - * The generation of these plots can be turned off with [`exclude_plots`](parameters.md#exclude-plots) - 4. Summary ROC and PRC plots - compares average ROC or PRC curves over all CV partitions for each modeling algorithm - 5. Boxplots for each evaluation metric - comparing algorithm performance over all CV partitions - * The generation of these plots can be turned off with [`exclude_plots`](parameters.md#exclude-plots) +Each report directory also contains `report_data.json`, which is useful for +debugging report content without parsing the PDF. -* **Output (Model Feature Importance):** - 1. Model feature importance estimates for each CV partition - CSV file for each modeling algorithm - 2. Boxplots comparing feature importance scores for each CV partition - CSV file for each modeling algorithm - 3. Composite feature importance barplots illustrating average feature importance scores across all algorithms (2 versions) - 1. Feature importance scores are normalized prior to visualization - 2. Feature importance scores are normalized and weighted by average model performance metric (balanced accuracy by default) - * The metric used to weight this plot can be changed with [`metric_weight`](parameters.md#metric-weight) - * Number of top scoring features illustrated in feature importance plots is controled by [`top_model_fi_features`](parameters.md#top-model-fi-features) +## Config Runner -* **Output (Statistical Significance):** - 1. Kruskal Wallis test results assessing whether there is a significant difference for each performance metric among all algorithms - CSV file - * For any metric that yields a significant difference based on [`sig_cutoff`](parameters.md#sig-cutoff), pairwise statistical tests between algorithms will be conducted using both the Mann Whitney U-test and the Wilcoxon Rank Test - 2. Pairwise statistical tests between algorithms using both the Mann Whitney U-test and the Wilcoxon Rank Test - CSV file for each statistic and significance test. +`run.py` wraps `streamline.pipeline.pipeline_cli` and runs one or more phases +from a `.cfg` file: -* **Parallelizability:** Runs once for each target dataset being analyzed. -* **Run Time:** Moderately fast - turning off some figure generation can make this phase faster +```bash +python run.py -c run_configs/uci_binary_hcc.cfg --dry_run +python run.py -c run_configs/uci_binary_hcc.cfg +``` -*** -## Phase 7: Compare Datasets -This phase should be run when STREAMLINE was applied to more than one target dataset during the 'experiment'. It applies further non-parametric statistical significance testing between datasets to identify if performance differences were observed among datasets comparing (1) the best performing algorithms or (2) on an algorithm-by-algorithm basis. It also generates plots to compare performance across datasets and examine algorithm performance consistency. +Useful partial-run controls: -* **Parallelizability:** Runs once - not parallelizable -* **Run Time:** Fast +```bash +python run.py -c run_configs/uci_binary_hcc.cfg --start_at p4 +python run.py -c run_configs/uci_binary_hcc.cfg --stop_after p8 +python run.py -c run_configs/uci_binary_hcc.cfg --only p6,p8,p11 +python run.py -c run_configs/uci_binary_hcc.cfg --skip p3,p4 +``` -* **Output (Comparing Best Performing Algorithms for each Metric):** - 1. Kruskal Wallis test results assessing whether there is a significant difference between median CV performance metric among all datasets focused on the best performing algorithm for each dataset - CSV file - * For any metric that yields a significant difference based on [`sig_cutoff`](parameters.md#sig-cutoff), pairwise statistical tests between datasets will be conducted using both the Mann Whitney U-test and the Wilcoxon Rank Test - 2. Pairwise statistical tests between datasets focused on the best performing algorithm for each dataset using both the Mann Whitney U-test and the Wilcoxon Rank Test - CSV file for each significance test. +## Saved Run Commands -* **Output (Comparing Algorithms Independently):** - 1. Kruskal Wallis test results assessing whether there is a significant difference for each median CV performance metric among all datasets - CSV file for each algorithm - * For any metric that yields a significant difference based on [`sig_cutoff`](parameters.md#sig-cutoff), pairwise statistical tests between datasets will be conducted using both the Mann Whitney U-test and the Wilcoxon Rank Test - 2. Pairwise statistical tests between datasets using both the Mann Whitney U-test and the Wilcoxon Rank Test - CSV file for each significance test and algorithm +Each phase records resolved arguments in: -*** -## Phase 8: Replication -This phase of STREAMLINE is only run when the user has further hold out data , i.e. one or more 'replication' datasets, which will be used to re-evaluate all models trained on a given target dataset. This means that this phase would need to be run once to evaluate the models of each original target dataset Notably, this phase would be the first time that all models are evaluated on the same set of data which is useful for more confidently picking a 'best' model and further evaluating model generalizability and it's ability to replicate performance on data collected at different times, sites, or populations. -To run this phase the user needs to specify the filepath to the target dataset to be replicated with [`dataset_for_rep`](parameters.md#dataset-for-rep) as well as the folderpath to the folder containing one or more replication datasets using [`rep_data_path`](parameters.md#rep-data-path). +```text +//run_commands.pickle +``` -This phase begins by conducting an initial exploratory data analysis (EDA) on the new replication dataset(s), followed by processing the dataset in the same way as the original target dataset, yielding the same number of features (but not necessarily the same number of instances). This processing includes cleaning, feature engineering, missing value imputation, feature scaling, and feature selection. Then EDA is repeated to confirm processing of the replication dataset and generate a feature correlation heatmap, however univariate analyses are not repeated on the replication data. - -Next all models previously trained for the target dataset are re-evaluated across all metrics using each replication dataset with results saved separately. Similarly all model evaluation plots (with the exception of feature importance plots) are automatically generated. As before non-parametric statistical tests are applied to examine differences in algorithm performance. - -* **Parallelizability:** Runs once for each replication dataset being analyzed for a given target dataset. -* **Run Time:** Moderately fast - -* **Output:** Similar outputs to Phase 1 minus univariate analyses, and similar outputs to Phase 6 minus feature importance assessments. - -*** -## Phase 9: Summary Report -This final phase generates a pre-formatted PDF report summarizing (1) STREAMLINE run parameters, (2) key exploratory analysis for the processed target data, (3) key ML modeling results (including metrics and feature importances), (4) dataset comparisons (if relevant), (5) key statistical significance comparisons, and (6) runtime. STREAMLINE collects run-time information on each phase of the pipeline and for the training of each ML algorithm model. - -Separate reports are generated representing the findings from running Phases 1-7, i.e. 'Testing Data Evaluation Report', as well as for Phase 8 if run on replication data, i.e. 'Replication Data Evaluation Report'. - -* **Parallelizability:** Runs once - not parallelizable -* **Run Time:** About a minute - -* **Output:** One or more PDF reports \ No newline at end of file +Later runs reuse saved values for omitted options, while explicitly supplied +command-line values override and update the saved entry. Use +`--ignore_saved_run_command` for a fresh parser/default run and +`--no_update_saved_run_command` to avoid modifying the pickle. diff --git a/docs/source/running.md b/docs/source/running.md index fc835b04..ea55c063 100644 --- a/docs/source/running.md +++ b/docs/source/running.md @@ -1,488 +1,213 @@ # Running STREAMLINE -This section details how to run STREAMLINE in any of its run modes. These include: -1. **Google Colab Notebook:** (run remotely on free google cloud resources) - * *Both an 'easy' and 'manual' run mode is available for users run their own data* -2. **Jupyter Notebook:** (run locally on your PC) -3. **Command Line Interface:** (locally or on a 'dask-compatable' CPU Computing Cluster) - -While the notebooks only allow STREAMLINE to be run serially, it can be '[embarrassingly](https://en.wikipedia.org/wiki/Embarrassingly_parallel)' parallelized when run from the command line in one of two ways: -* **Local command line:** basic CPU core parallelization -* **CPU Computing Cluster:** job submission parallelization - -When run from the command line, STREAMLINE can be run in one of two ways: -* **Using a Configuration File:** run all, or any number of phases using a single command that points to a 'configuration file' with all necessary run parameters -* **Using Command-Line Arguments:** run all, or any number of phases using command line arguments - -For more details and guidelines on selecting a run mode, see '[Picking a Run Mode](#picking-a-run-mode)'. - -All users may benefit from reviewing the '[Guidelines for Setting Run Parameters](tips.md)' section for tips on (1) ensuring reproducibility (2) reducing runtime, and (3) improving modeling performance. Details on the variety of outputs generated by STREAMLINE can be found in '[Navigating STREAMLINE Output](output.md)'. - -Once you've completed the [installation](install.md) instructions for the run mode desired, follow the mode-specific directions below for running STREAMLINE. - -*** -## Google Colab Notebook -This run mode is best for (1) easily trying out STREAMLINE on demonstration data, (2) running analyses on small datasets, or (3) educational purposes. Check out this [tutorial](https://www.tutorialspoint.com/google_colab/index.htm) to lean the basics of a [Google Colab Notebook](https://research.google.com/colaboratory/). - -Below we first detail how to run the Colab Notebook on the included [demonstration datasets](data.md#demonstration-data), then how to adapt this notebook to run on your own dataset(s) as well as change STREAMLINE run parameters if desired. - -### Running the Demo (Colab) -The STREAMLINE Google Colab Notebook is set up to run a limited analysis applying all 9 phases of the pipeline. This includes 3-fold cross validation, and applying only three of the faster ML modeling algorithms to 2 example 'target datasets', and a 'replication dataset' relevant to only one of the target datasets. These datasets are detailed in [Demonstration Data](data.md#demonstration-data). This demo should take 6-7 minutes to run on Google Cloud, with results viewable in the notebook. The notebook will also automatically download the PDF summary reports, and the zipped 'experiment folder' with all output files, with the user's permission. - -To run this demo, do the following: -1. Set up a Google account (if you don't already have one). Click [here]( https://support.google.com/accounts/answer/27441?hl=en) for help. -2. Open the STREAMLINE Google Colab Notebook by clicking the link below: -[https://colab.research.google.com/drive/14AEfQ5hUPihm9JB2g730Fu3LiQ15Hhj2?usp=sharing](https://colab.research.google.com/drive/14AEfQ5hUPihm9JB2g730Fu3LiQ15Hhj2?usp=sharing) -3. \[Optional] Open the `Runtime` menu and select `Disconnect and delete runtime`. *This clears the memory of the previous notebook run. This is only necessary when the underlying base code is modified, but it may be useful to troubleshoot if modifications to the notebook do not seem to have an effect.* -4. Open the `Runtime` menu and select `Run all`. *This will run all code cells of the notebook, i.e. all phases of STREAMLINE.* - -At this point the notebook will do the following automatically: -* Reserve a limited amount of free memory (RAM) and disk space on Google Cloud. -* Load the most recent STREAMLINE repository into memory from Github. *The STREAMLINE release version is automatically indicated in the summary PDF reports.* -* Install other necessary python packages in the Google Colab Environment. -* Run the entirety of STREAMLINE on the [demonstration datasets](sample.md#demonstration-data). -* Download the PDF 'testing evaluation' and the 'replication evaluation' summary reports automatically. *Google will ask for user permission the first time* -* Download the zipped 'experiment folder' with all output files to your local computer. - -See '[Notebook Output](output.md#notebooks)' for more on examining output within the notebook and '[Output Files](output.md#output-files)' - -### Running Your Own Datasets (Colab) -Before running STREAMLINE on new data, make sure it adheres to '[Input Data Requirements](data.md#input-data-requirements)'. To update the STREAMLINE Colab Notebook to run on one or more user specified 'target datasets', users can chose between an 'easy' and 'manual mode. - -As above, begin by opening the STREAMLINE Google Colab Notebook by clicking the link below: -[https://colab.research.google.com/drive/14AEfQ5hUPihm9JB2g730Fu3LiQ15Hhj2?usp=sharing](https://colab.research.google.com/drive/14AEfQ5hUPihm9JB2g730Fu3LiQ15Hhj2?usp=sharing) - -Before running, update the run parameters within the 'STREAMLINE RUN PARAMETERS' section of the notebook as indicated below. - -*Note that, for brevity, some parameter names used in the notebook (used below) are slightly different from those used in the command line. Details on STREAMLINE run parameters are given [here](parameters.md).* - -#### Easy Mode -This mode is most convenient if you want to run the notebook on other data, but want to be prompted to enter/select essential parameter information instead of adjusting parameters within run parameter code cells. This mode will prompt the user for essential 'experiment' and dataset-specific run parameter values. This mode is also convenient as it allows you to select datasets directly from your local computer rather than creating new folders within the temporary Colab Notebook workspace. All other non-essential run parmameters need to be updated within respective code cells. - -1. In the first code cell, set ([`demo_run`](parameters.md#demo-run) = `False`) and ([`use_data_prompt'](parameters.md#use-data-prompt) = `True`) - * *This tells the notebook that you don't want to run the demo datasets, and you want to be 'prompted' to enter/select essential run parameters rather than edit the respective code cells* -2. \[Optional] Update non-essential run parameters (within respective code cells) to the users specifications - * *Most commonly, this would include [`n_splits`](parameters.md#cv-partitions), [`categorical_cutoff`](parameters.md#categorical-cutoff), and [`algorithms`](parameters.md#algorithms) - * *We also strongly recommend specifying [`categorical_feature_headers`](parameters.md#categorical-feature-path) and/or [`quantitiative_feature_headers`](parameters.md#quantitative-feature-path) as lists of feature names in the dataset(s) headers that should be treated as either categorical or quanatiative* - * *If only one of these lists is specified, all features not specified in that list will be treated as the other feature type by default* -3. Open the `Runtime` menu and select `Run all`. -4. Reply to the prompts requesting the following essential parameter values: - * [`experiment_name`](parameters.md#experiment-name) - a unique name for the ouput folder for the current STREAMLINE 'experiment' - * [`data_path`](parameters.md#dataset-path) - use file navigation window to select the folder containing one or more 'target datasets' to be analyzed - * *These datasets must adhere to the formatting detailed in '[Input Data Requirements](data.md#input-data-requirements)'* - * [`class_label`](parameters.md#class-label) - specify the header name for the outcome column in the dataset(s), e.g. 'Class' - * [`instance_label`](parameters.md#instance-label) - specify the header name for the unique instance IDs in the dataset(s) or specify `None` if not relevant - * [`match_label`](parameters.md#match-label) - specify the header name for the match/group column in the dataset(s) or specify `None` if not relevant - * [`applyToReplication`](parameters.md#applytoreplication) - indicate `True` or `False` as to whether 'replication data' is available for the replication phase - * [`rep_data_path`](parameters.md#rep-data-path) - use file navigation window to select the folder containing one or more 'replication datasets' to be analyzed - * *All datasets in this folder should be replicates for a single 'target dataset', and similarly adhere to [formatting](data.md#input-data-requirements) requirments* - * [`dataset_for_rep`](parameters.md#dataset-for-rep) - specify the filename (with extension) of the original 'target dataset' to indicate which models the replication data will be applied to -* *After providing valid entries for these prompts, all phases of STREAMLINE will run in sequence within the notebook.* -* *STREAMLINE outputfiles are automatically saved to the output 'experiment folder' named `UserOutput` within the temporary notebook workspace, as well as optionally downloaded to the users computer after completion* - -#### Manual Mode -1. In the first code cell, set ([`demo_run`](parameters.md#demo-run) = `False`) and ([`use_data_prompt'](parameters.md#use-data-prompt) = `False`) - * *This tells the notebook that you don't want to run the demo datasets, but you want update all run parameters (essential and non-essential) within respective code cells* -2. Click on the 'Files' tab on the left side of the notebook (pictured as a blank folder), and right-click on 'content' folder (i.e. the temporary google colab workspace) and create a 'New Folder' to contain your target dataset(s), called `UserData` (or some other name if you also update the [`data_path`](parameters.md#dataset-path) parameter) -3. Save your [formatted](data.md#input-data-requirements) target dataset(s) within this folder - * *Note: We recommend making sure datasets run within Google Colab do not contain any sensitive or protected health information (PHI)* -4. \[Optional] Repeat steps 2-3 for any replication dataset(s) you wish to apply to the models trained for a specific 'target dataset' - * *If you have no replication data, make sure to update the [`applyToReplication`](parameters.md#applytoreplication) parameter to `False`* -5. Update (essential and non-essential) run parameter code cells to the dataset and users specifications - * *Note: You can leave [`output_path`](parameters.md#output-path) as `/content/UserOutput` and all output will be saved to this automatically created folder* - * *If you run more than one STREAMLINE 'experiments' in a single session, make sure to update [`experiment_name`](parameters.md#experiment-name) each time to avoid overwriting a prior experiment* -6. Open the `Runtime` menu and select `Run all` -* *Note: Common errors preventing the notebook from running to completion include issues with file/path names, dataset formatting, or other incorrect changes to other run parameter settings* -* *The notebook includes comments after each run parameter, indicating the format and value options for each* - -*** -## Jupyter Notebook -This run mode is best for (1) confirming successful STREAMLINE installation for local computer use, (2) running STREAMLINE in a notebook on your own computer's resources (generally faster than Colab Notebook), (3) running analyses on small to moderately sized datasets, (4) viewing output directly within a notebook, or (5) educational purposes. Click [here](https://jupyter.readthedocs.io/en/latest/running.html) to learn the basics of Jupyter Notebook. - -Running STREAMLINE in Jupyter Notebook is largely the same as for running it in Google Colab. Below we specify how to run the Jupyter Notebook on the included [demonstration datasets](data.md#demonstration-data), then how to adapt it to run on your own dataset(s). - -### Running the Demo (Jupyter) -The STREAMLINE Jupyter Notebook is also set up to run a limited analysis applying all 9 phases of the pipeline. This includes 3-fold cross validation, and applying only three of the faster ML modeling algorithms to 2 example 'target datasets', and a 'replication dataset' relevant to only one of the target datasets. These datasets are detailed in [Demonstration Data](data.md#demonstration-data). This demo should take about 2-5 minutes to run (depending on your computer hardware), with results viewable in the notebook. The notebook will automatically save the 'experiment folder' (named `DemoOutput`) with all output files (including PDF reports). - -1. From your command line, open Jupyter Notebook by typing `jupyter notebook`. -2. Within the Jupyter local file browser that opens, navigate into the previously saved/installed `STREAMLINE` directory where you find the file named `STREAMLINE-Notebook.ipypnb`. -3. Click to open `STREAMLINE-Notebook.ipypnb` as a Jupyter Notebook in a new page open in your web browser. -4. Open the `Kernel` menu and select `Restart & Run All`. *This will run all code cells of the notebook, i.e. all phases of STREAMLINE.* - -At this point the notebook will do the following automatically: -* Run the entirety of STREAMLINE on the [demonstration datasets](sample.md#demonstration-data). -* Save all output files (including PDF reports) as an 'experiment folder' named `DemoOutput` within the `STREAMLINE` directory. - -See '[Notebook Output](output.md#notebooks)' for more on examining output within the notebook and '[Output Files](output.md#output-files)' - -### Running Your Own Datasets (Jupyter) -Begin by opening `STREAMLINE-Notebook.ipypnb` as a Jupyter Notebook (steps 1-3 above). Before running, update the run parameters within the 'STREAMLINE RUN PARAMETERS' section of the notebook as indicated below. - -*Note that, for brevity, some parameter names used in the notebook (used below) are slightly different from those used in the command line. Details on STREAMLINE run parameters are given [here](parameters.md).* - -1. In the first code cell, set ([`demo_run'](parameters.md#demo-run) = `False`) - * *This tells the notebook that you don't want to run the demo datasets, and you want to be 'prompted' to enter/select essential run parameters rather than edit the respective code cells* -2. Update essential run parameters (within respective code cells) to the user/dataset's specifications - * [`experiment_name`](parameters.md#experiment-name) - a unique name for the ouput folder for the current STREAMLINE 'experiment' - * [`data_path`](parameters.md#dataset-path) - path to the folder containing one or more 'target datasets' to be analyzed - * *These datasets must adhere to the formatting detailed in '[Input Data Requirements](data.md#input-data-requirements)'* - * [`output_path`](parameters.md#output-path) - path to the folder (that will be automatically created if it doesn't yet exist) in which the 'experiment folder' including all STREAMLINE output will be saved - * *Note: You can leave [`output_path`](parameters.md#output-path) as `./UserOutput` if you've named this folder `UserOutput`* - * [`class_label`](parameters.md#class-label) - the header name for the outcome column in the dataset(s), e.g. 'Class' - * [`instance_label`](parameters.md#instance-label) - the header name for the unique instance IDs in the dataset(s) or specify `None` if not relevant - * [`match_label`](parameters.md#match-label) - the header name for the match/group column in the dataset(s) or specify `None` if not relevant - * [`ignore_features`](parameters.md#ignore-features-path) - list of text-valued feature names in target datasets that you want STREAMLINE to drop from the analysis, or specify `None` if not relevant - * [`categorical_feature_headers`](parameters.md#categorical-feature-path) - list of text-valued feature names in the dataset(s) headers that should be treated as categorical or specify `None` if [`quantitiative_feature_headers`](parameters.md#quantitative-feature-path) were specified and you want all other features to be treated as categorical, or you want feature types to be automatically decided using [`categorical_cutoff`](parameters.md#categorical-cutoff) - * [`quantitiative_feature_headers`](parameters.md#quantitative-feature-path) - list of text-valued feature names in the dataset(s) headers that should be treated as quantitative or specify `None` if [`categorical_feature_headers`](parameters.md#categorical-feature-path) were specified and you want all other features to be treated as quantitative, or you want feature types to be automatically decided using [`categorical_cutoff`](parameters.md#categorical-cutoff) - * [`applyToReplication`](parameters.md#applytoreplication) - indicate `True` or `False` as to whether 'replication data' is available for the replication phase - * [`rep_data_path`](parameters.md#rep-data-path) - path to folder containing one or more 'replication datasets' to be analyzed - * *All datasets in this folder should be replicates for a single 'target dataset', and similarly adhere to [formatting](data.md#input-data-requirements) requirments* - * [`dataset_for_rep`](parameters.md#dataset-for-rep) - path to the file (with extension) of the original 'target dataset' to indicate which models the replication data will be applied to -3. \[Optional] Update non-essential run parameters (within respective code cells) to the users specifications - * *Most commonly, this would include [`n_splits`](parameters.md#cv-partitions), [`categorical_cutoff`](parameters.md#categorical-cutoff), and [`algorithms`](parameters.md#algorithms) -4. Open the `Kernel` menu and select `Restart & Run All`. *This will run all code cells of the notebook, i.e. all phases of STREAMLINE.* -* *Note: It can take multiple hours or longer to run this notebook on larger datasets and/or using all machine learning modeling algorithms. We recommend using a computing cluster for such tasks if possible.* - -*** -## Command Line Interface -This run mode is best for (1) most efficiently running STREAMLINE with parallelization options, (2) users comfortable with command lines, or (3) running moderate to large datasets and/or more exhaustive run parameter configurations. - -Running STREAMLINE from the command line can be done locally (with or without CPU core parallelization), or on a dask-compatable CPU computing cluster. Any of these scenarios can also be run from a single command (i.e. all phases at once) using a 'configuration file', or separately one phase at a time. Below we indicate how to run all of these possible command line run configurations using the [demonstration datasets](data.md#demonstration-data) as an example. As for Google Colab and Jupyter Notebook run modes, to run STREAMLINE on datasets other than the [demonstration datasets](data.md#demonstration-data), essential run parameters should be specified/updated accordingly. STREAMLINE command line run parameters specified in a configuration file, or as command line arguments have slightly different names as detailed within the [run parameters section](parameters.md). - -### Locally -This section explains running STREAMLINE locally using the command line interface. - -#### Using a Configuration File (Locally) -All phases of STREAMLINE can be run (in sequence) with a single simple command by editing and calling an associated configuration file (`run_configs/local.cfg`) as indicated below. -* *Note: This approach also allows users to run any subset of sequential STREAMLINE phases (e.g. Phase 1 alone for EDA, or Phases 1-4 for EDA, data processing, and feature selection) using the different 'phases to run' flags within the configuration file.* - -1. Open your command line interface and navigate to the installed `STREAMLINE` directory. -2. To run the [demonstration datasets](data.md#demonstration-data), skip to step 5. To view the pre-specified configuration file, click [here](https://github.com/UrbsLab/STREAMLINE/blob/main/run_configs/local.cfg). -3. Assuming you want to run your own dataset(s), further navigate into the `run_configs` folder and open `local.cfg` in a text editor to update the essential and non-essential run parameters accordingly (see [run parameters](parameters.md) and [terminal text editors](install.md#terminal-text-editors) for help). - * *Under 'phases to run' the [`do_till_report`](parameters.md#do-till-report) parameter (when set to `True`) will automatically run all phases up until [`do_replicate`](parameters.md#do-replicate) by default. [`do_replicate`](parameters.md#do-replicate), [`do_rep_report`](parameters.md#do-rep-report) and [`do_cleanup`](parameters.md#do-cleanup) must all be specified individually* - * *To run a subset of phases (e.g. phases 1-4), set [`do_till_report`](parameters.md#do-till-report) = `False`, and [`do_eda`](parameters.md#do-eda), [`do_dataprep`](parameters.md#do-dataprep), [`do_feat_imp`](parameters.md#do-feat-imp), and [`do_feat_sel`](paramters.md#do-feat-sel) each to `True` and the other 'do' phases to `False`* - * *Make sure to keep [`run_cluster'](parameters.md#run-cluster) = `False`, which tells STREAMLINE to be run locally rather than on a CPU computing cluster* - * *Optionally set [`run_parallel'](parameters.md#run-parallel) = `False`, which will turn off local multi-core CPU parallelization* -4. Navigate back to the `STREAMLINE` base directory. -5. Run the following command within the `STREAMLINE` base directory: -``` -python run.py -c run_configs/local.cfg -``` -* *Note: You can save your own `.cfg` files to call with this command. We recommend copying renaming, and editing `local.cfg` and then calling this new configuration file as an argument to `run.py`* +STREAMLINE can be run through: -#### Using Command-Line Arguments (Locally) -STREAMLINE phases can also be called individually from the command line without a configuration file (instead specifying run parameters as arguments). This can be helpful, in particular, if you want to run a big analysis, and would like to look at the output of phases along the way without committing to running the whole pipeline upfront. Similar to any other run mode, make sure to specify arguments for all 'essential' run parameters for a given dataset. -* *Note: Command line run parameters have slightly different identifiers than for the configuration file (see [run parameters](parameters.md))* -* *Note: Any unspecified non-essential run parameters will be assigned their default values for a given STREAMLINE run* - * *Make sure to specify [`--run-cluster`](parameters.md#run-cluster) = `False`, which tells STREAMLINE to be run locally rather than on a CPU computing cluster* - * *Optionally specify [`--run-parallel`](parameters.md#run-parallel) = `False`, which will turn off local multi-core CPU parallelization* -* *Note: When specifying [`--fi`](parameters.md#ignore-features-path), [`--cf`](parameters.md#categorical_feature_path), or [`--qf`](parameters.md#quantitative_feature_path) using this run approach, it is necessary to pass a file-path to a `.csv` file including a list of feature names for that parameter, rather than directly listing these feature names. We use this approach in the examples below using `.csv` files found in `STREAMLINE/data/DemoFeatureTypes`.* +* Google Colab +* Local Jupyter notebook +* Config-driven full pipeline runs +* Phase-by-phase command-line calls -1. Open your command line interface and navigate to the installed `STREAMLINE` directory. -2. The subsections below provide different example scenarios running `run.py` on the [demonstration datasets](data.md#demonstration-data). These scenarios run STREAMLINE similarly to our other demo run mode examples above, but we set [`--run-cluster`](parameters.md#run-cluster) = `False` (necessary) and optionally [`--run-parallel`](parameters.md#run-parallel) = `True` for each example. +For most command-line work, start with the `.cfg` runner. It keeps shared +settings, phase toggles, and phase-specific parameters in one editable file. -##### All Phases at Once (Replication Data Included) -``` -python run.py --do-till-report --do-rep-report --do-clean --data-path ./data/DemoData --out-path DemoOutput --exp-name demo_experiment --class-label Class --inst-label InstanceID --cf ./data/DemoFeatureTypes/hcc_cat_feat.csv --qf ./data/DemoFeatureTypes/hcc_quant_feat.csv --cv 3 --algorithms=NB,LR,DT --do-replicate --rep-path ./data/DemoRepData --dataset ./data/DemoData/hcc_data_custom.csv --run-cluster False --run-parallel True -``` +## Choose A Run Path -##### All Main Phases at Once (No Replication Data) -``` -python run.py --do-till-report --do-clean --data-path ./data/DemoData --out-path DemoOutput --exp-name demo_experiment --class-label Class --inst-label InstanceID --cf ./data/DemoFeatureTypes/hcc_cat_feat.csv --qf ./data/DemoFeatureTypes/hcc_quant_feat.csv --cv 3 --algorithms=NB,LR,DT --run-cluster False --run-parallel True -``` +| Use case | Recommended path | +| --- | --- | +| Conference tutorial or first demo | Google Colab notebook | +| Interactive local exploration | `STREAMLINE_Notebook.ipynb` | +| Reproducible full pipeline run | `python run.py -c run_configs/.cfg` | +| Debugging one phase | Phase CLI command | +| Faster local execution without Dask | `run_cluster = Parallel` | +| Local Dask execution | `run_cluster = Local` | +| HPC execution | `BashSLURM`, `BashLSF`, or a site-specific Dask cluster setting | -##### One Phase at a Time -The following commands can be run one after the other (in sequence), waiting for the previous command to complete. +## Google Colab -###### Phase 1 - Data Exploration & Processing: -``` -python run.py --do-eda --data-path ./data/DemoData --out-path DemoOutput --exp-name demo_experiment --class-label Class --inst-label InstanceID --cf ./data/DemoFeatureTypes/hcc_cat_feat.csv --qf ./data/DemoFeatureTypes/hcc_quant_feat.csv --cv 3 --run-cluster False --run-parallel True -``` -###### Phase 2 - Imputation and Scaling: -``` -python run.py --do-dataprep --out-path DemoOutput --exp-name demo_experiment --run-cluster False --run-parallel True -``` +Open the Colab notebook: -###### Phase 3 - Feature Importance Estimation -``` -python run.py --do-feat-imp --out-path DemoOutput --exp-name demo_experiment --run-cluster False --run-parallel True -``` +[Open the STREAMLINE Colab notebook](https://colab.research.google.com/drive/1ByQuU805GzDGAAGzbUYz8wahnOTUuzvg?usp=sharing) -###### Phase 4 - Feature Selection -``` -python run.py --do-feat-sel --out-path DemoOutput --exp-name demo_experiment --run-cluster False --run-parallel True -``` +At the top of the notebook, set the demo/run parameters. The notebook supports +binary, multiclass, regression, and custom data modes. -###### Phase 5 - Machine Learning (ML) Modeling -``` -python run.py --do-model --out-path DemoOutput --exp-name demo_experiment --algorithms NB,LR,DT --run-cluster False --run-parallel True -``` +## Local Jupyter -###### Phase 6 - Post-Analysis -``` -python run.py --do-stats --out-path DemoOutput --exp-name demo_experiment --run-cluster False --run-parallel True -``` +From the repository root: -###### Phase 7 - Compare Datasets -If there is only one 'target dataset' in the given analysis, skip this command. -``` -python run.py --do-compare-dataset --out-path DemoOutput --exp-name demo_experiment --run-cluster False --run-parallel True +```bash +conda activate streamline +jupyter notebook ``` -###### Phase 8 - Replication -If there are no replication datasets, skip this command. If you have multiple 'target datasets' each with one or more associated replication datasets, run this command once for each original target dataset (updating [`--rep-path`](parameters.md#rep-data-path) and [`--dataset`](parameters.md#dataset-for-rep) for each). -``` -python run.py --do-replicate --out-path DemoOutput --exp-name demo_experiment --rep-path ./data/DemoRepData --dataset ./data/DemoData/hcc_data_custom.csv --run-cluster False --run-parallel True -``` +Open `STREAMLINE_Notebook.ipynb`. The top parameter block controls which demo +or custom dataset is run. -###### Phase 9 - Summary Report(s) -Run the following command to generate the main PDF report (summarizing testing data evaluations of the models). -``` -python run.py --do-report --out-path DemoOutput --exp-name demo_experiment --run-cluster False --run-parallel True -``` +## Config-Driven Runs -If the models of a STREAMLINE experiment were applied to replication data in phase 8 you can generate a report for the replication of a single target dataset using the following command. If you have multiple 'target datasets' each with one or more associated replication datasets, run this command once for each original target dataset (updating [`--rep-path`](parameters.md#rep-data-path) and [`--dataset`](parameters.md#dataset-for-rep) for each). -``` -python run.py --do-rep-report --out-path DemoOutput --exp-name demo_experiment --rep-path ./data/DemoRepData --dataset ./data/DemoData/hcc_data_custom.csv --run-cluster False --run-parallel True -``` - -###### Optional Clean-up -``` -python run.py --do-clean --out-path DemoOutput --exp-name demo_experiment --del-time --del-old-cv --run-cluster False --run-parallel True -``` +Dry-run a config first: -### CPU Computing Cluster -This section explains running STREAMLINE remotely on a dask-compatible CPU computing cluster (i.e. HPC). - -#### Helpful Tools -First let's discuss the role of a couple helpful tools mentioned in the [installation](install.md#additional-tools) section for running STREAMLINE on a computing cluster. - -##### nano -GNU nano is a text editor for Unix-like computing systems or operating environments using a command line interface. This would be incredibly handy for editing the configuration file through a ssh terminal when running STREAMLINE with a configuration file. - -A detailed guide can be found [here](https://www.hostinger.com/tutorials/how-to-install-and-use-nano-text-editor) - -A gist of the application is that you can edit a configuration file such as e.g. `run_configs/cedars.cfg` using the following steps: -1. Go to the root `STREAMLINE` folder. -2. Type `nano run_configs/cedars.cfg` in the terminal to open the file in nano. -3. Edit the configuration file as needed. -4. Press `Ctrl + X` to close the file and `Y` to save the changes. - -##### tmux -tmux is a terminal multiplexer/emulator. It lets you switch easily between several programs in one terminal, detach them (they keep running in the background) and reattach them to a different terminal. This is particularly important when you want to run all phases of STREAMLINE automatically from a single command. To achieve this, STREAMLINE runs a script on the head node (i.e. job submission node) that monitors phase completion and submits new jobs for the next phase. A terminal emulator allows you to start a full pipeline run and close the window without killing the job. - -A detailed guide on using it can be found [here](https://www.redhat.com/sysadmin/introduction-tmux-linux) - -A gist of the application is that you can open a new terminal that will stay open even if you disconnect and close your terminal using the following steps: -1. Go to the root streamline folder. -2. Type and run `tmux new -s mysession` -3. Open the required config file using nano (e.g. `run_configs/cedars.cfg`) -4. Make the necessary in the changes in the config file. -5. Press `Ctrl + X` to close the file and `Y` to save the changes. -6. Run required commands. -7. Press `Ctrl + b` and then the `d` key to close the terminal. - -#### Cluster-Specific Run Parameters -You should be aware of 3 cluster-specific run parameters: -* [`run-cluster`](parameters.md#run-cluster): flag for type of cluster, discussed in detail below (when not `False`, this over-rides any value specified for `run-parallel`) -* [`queue`](parameters.md#queue): the partition queue used for job submissions -* [`reserved_memory`](parameters.md#reserved-memory): memory (in GB) reserved per job - -##### Run Cluster Parameter -The [`run-cluster`](parameters.md#run-cluster) parameter is the most important parameter here. It should be set to `False` when running locally, but to use a cluster, specify as a string value for the cluster-type. Currently, clusters supported by [dask-jobqueue](https://jobqueue.dask.org/en/latest/api.html) are supported with the following settings options for [`run-cluster`](parameters.md#run-cluster): -* `LSF`: LSFCluster -* `SLURM`: SLURMCluster -* `HTCondor`: HTCondorCluster -* `Moab`: MoabCluster -* `OAR`: OARCluster -* `PBS`: PBSCluster -* `SGE`: SGECluster -* `UGE`: SGECluster variant used at our institution -* `Local`: LocalCluster - -Additionally, the earlier/legacy method of STREAMLINE manual job submission is supported for `SLURM` and `LSF` using the string values below for [`run-cluster`](parameters.md#run-cluster). This will generate and submit jobs using shell files as was used in *STREAMLINE release 0.2.5* and earlier. This legacy option ensures that minimal memory/computation is used on the head node (i.e. job-submit node). -* `SLURMOld`: Legacy job submission for SLURMCluster -* `LSFOld` Legacy job submission for LSFCluster - -##### Queue and Memory Parameters -Check with your cluster administrator on how to set these these cluster-specific parameters. We have set defaults for these parameters for use on our own institution's HPC (i.e. [`queue`](parameters.md#queue) = `defq`, and [`reserved_memory`](parameters.md#reserved-memory) = `4`). - -#### Using a Configuration File (Cluster) -This is largely the same as running STREAMLINE from a [configuration file locally](#using-a-configuration-file-locally), with the addition of three cluster-specific parameters ( [`run-cluster`](parameters.md#run-cluster),[`queue`](parameters.md#queue), and [`reserved_memory`](parameters.md#reserved-memory)). - -1. Open your command line interface within your HPC and navigate to the installed `STREAMLINE` directory. -2. Edit any run parameters within a configuration file according to your needs (making sure to update [`run-cluster`](parameters.md#run-cluster),[`queue`](parameters.md#queue), and [`reserved_memory`](parameters.md#reserved-memory) within the multiprocessing section). - * *We have included example configuration files set up to run the [demonstration datasets](data.md#demonstration-data) on three different clusters we utilize (i.e. `cedars.cfg` `cedars_old.cfg` and `upenn.cfg`), using `SLURM`, `UGE`, and `LSF`, respectively. We will focus here on `SLURM` as an example with the respective configuration file (`cedars.cfg`) found [here](https://github.com/UrbsLab/STREAMLINE/blob/main/run_configs/cedars.cfg)* -2. Run the following command within the `STREAMLINE` base directory: +```bash +python run.py -c run_configs/uci_binary_hcc.cfg --dry_run ``` -python run.py -c run_configs/cedars.cfg -``` - -* *Note: The configuration filename and location can be anything as long as it's a valid configuration file set up to run on your dask-compatable cluster.* -* *Note: When using this run strategy, it is strongly recommended to use a [terminal emulator](#tmux) and check with your cluster administrator to make sure that your system allows light weight, but longer duration code to be run from the head node that monitors job completion and can submit new jobs. If not, we recommend running STREAMLINE one phase at a time in legacy mode (i.e. `run-cluster` = `SLURMOld` or `LSFOld`) which only uses the head node to submit jobs.* - -#### Using Command-Line Arguments (Cluster) -This is largely the same as running STREAMLINE using [command-line arguments locally](#using-command-line-arguments) with the addition of three cluster-specific parameters ( [`--run-cluster`](parameters.md#run-cluster),[`queue`](parameters.md#queue), and [`--res-mem`](parameters.md#reserved-memory)), and users can ignore [`--run-parallel`](parameters.md#run-parallel). -1. Open your command line interface within your HPC and navigate to the installed `STREAMLINE` directory. -2. The subsections below provide different example scenarios running `run.py` on the [demonstration datasets](data.md#demonstration-data), however users can adjust these arguments for their own data. Also, here [`--run-parallel`](parameters.md#run-parallel) is automatically overridden by [`--run-cluster`](parameters.md#run-cluster) = `SLURM` (or whatever cluster-name is specified or than `False`). - * *Note: Any unspecified non-essential run parameters will be assigned their default values for a given STREAMLINE run* - * *Note: When specifying [`--fi`](parameters.md#ignore-features-path), [`--cf`](parameters.md#categorical_feature_path), or [`--qf`](parameters.md#quantitative_feature_path) using this run approach, it is necessary to pass a file-path to a `.csv` file including a list of feature names for that parameter, rather than directly listing these feature names. We use this approach in the examples below using `.csv` files found in `STREAMLINE/data/DemoFeatureTypes`.* +Run a full binary demo: -##### All Phases at Once (Replication Data Included) -* *Notice: this approach will run a lightweight script on the headnode monitoring job completion and submitting jobs for subsequent phases until completion of all phases.* -``` -python run.py --do-till-report --do-rep-report --do-clean --data-path ./data/DemoData --out-path DemoOutput --exp-name demo_experiment --class-label Class --inst-label InstanceID --cf ./data/DemoFeatureTypes/hcc_cat_feat.csv --qf ./data/DemoFeatureTypes/hcc_quant_feat.csv --cv 3 --algorithms=NB,LR,DT --do-replicate --rep-path ./data/DemoRepData --dataset ./data/DemoData/hcc_data_custom.csv --run-cluster SLURM --res-mem 4 --queue defq +```bash +python run.py -c run_configs/uci_binary_hcc.cfg ``` -##### All Main Phases at Once (No Replication Data) -* *Notice: this approach will run a lightweight script on the headnode monitoring job completion and submitting jobs for subsequent phases until completion of all phases.* -``` -python run.py --do-till-report --do-clean --data-path ./data/DemoData --out-path DemoOutput --exp-name demo_experiment --class-label Class --inst-label InstanceID --cf ./data/DemoFeatureTypes/hcc_cat_feat.csv --qf ./data/DemoFeatureTypes/hcc_quant_feat.csv --cv 3 --algorithms=NB,LR,DT --run-cluster SLURM --res-mem 4 --queue defq +Run the multiclass and regression demos: + +```bash +python run.py -c run_configs/uci_multiclass_student.cfg +python run.py -c run_configs/uci_regression_auto_mpg.cfg ``` -##### One Phase at a Time -The following commands can be run one after the other (in sequence), waiting for all jobs of the previous phase to complete successfully. For minimal head node overhead, we recommend running these jobs using [`--run-cluster`](parameters.md#run-cluster) = `SLURMOld` or `LSFOld`` rather than `SLURM` (if available to you). +The included configs are designed as reproducible examples. For a short +notebook or Colab demonstration, use the notebook parameter block, which uses a +smaller modeling budget and shows plots by default. -###### Phase 1 - Data Exploration & Processing: -``` -python run.py --do-eda --data-path ./data/DemoData --out-path DemoOutput --exp-name demo_experiment --class-label Class --inst-label InstanceID --cf ./data/DemoFeatureTypes/hcc_cat_feat.csv --qf ./data/DemoFeatureTypes/hcc_quant_feat.csv --cv 3 --run-cluster SLURM --res-mem 4 --queue defq -``` -###### Phase 2 - Imputation and Scaling: -``` -python run.py --do-dataprep --out-path DemoOutput --exp-name demo_experiment --run-cluster SLURM --res-mem 4 --queue defq -``` +Partial-run examples: -###### Phase 3 - Feature Importance Estimation -``` -python run.py --do-feat-imp --out-path DemoOutput --exp-name demo_experiment --run-cluster SLURM --res-mem 4 --queue defq +```bash +python run.py -c run_configs/uci_binary_hcc.cfg --start_at p4 +python run.py -c run_configs/uci_binary_hcc.cfg --stop_after p8 +python run.py -c run_configs/uci_binary_hcc.cfg --only p6,p8,p11 +python run.py -c run_configs/uci_binary_hcc.cfg --skip p3,p4 ``` -###### Phase 4 - Feature Selection -``` -python run.py --do-feat-sel --out-path DemoOutput --exp-name demo_experiment --run-cluster SLURM --res-mem 4 --queue defq -``` +## Config File Layout -###### Phase 5 - Machine Learning (ML) Modeling -``` -python run.py --do-model --out-path DemoOutput --exp-name demo_experiment --algorithms NB,LR,DT --run-cluster SLURM --res-mem 4 --queue defq -``` +Each config uses sections like: -###### Phase 6 - Post-Analysis -``` -python run.py --do-stats --out-path DemoOutput --exp-name demo_experiment --run-cluster SLURM --res-mem 4 --queue defq -``` +```ini +[run] +output_path = out +experiment_name = UCIHCCPipeline +outcome_label = Class +outcome_type = Binary +instance_label = InstanceID +n_splits = 3 +run_cluster = Serial +random_state = 42 -###### Phase 7 - Compare Datasets -If there is only one 'target dataset' in the given analysis, skip this command. -``` -python run.py --do-compare-dataset --out-path DemoOutput --exp-name demo_experiment --run-cluster SLURM --res-mem 4 --queue defq -``` +[phases] +phase_order = p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11 +do_p1 = True +do_p2 = True +do_p3 = True +do_p4 = True +do_p5 = True +do_p6 = True +do_p7 = True +do_p8 = True +do_p9 = True +do_p10 = True +do_p11 = True -###### Phase 8 - Replication -If there are no replication datasets, skip this command. If you have multiple 'target datasets' each with one or more associated replication datasets, run this command once for each original target dataset (updating [`--rep-path`](parameters.md#rep-data-path) and [`--dataset`](parameters.md#rep-data-path) for each). -``` -python run.py --do-replicate --out-path DemoOutput --exp-name demo_experiment --rep-path ./data/DemoRepData --dataset ./data/DemoData/hcc_data_custom.csv --run-cluster SLURM --res-mem 4 --queue defq +[p6] +outcome_type = Binary +models = NB,LR,DT +scoring_metric = balanced_accuracy +metric_direction = maximize +n_trials = 200 +timeout = 900 ``` -###### Phase 9 - Summary Report(s) -Run the following command to generate the main PDF report (summarizing testing data evaluations of the models). -``` -python run.py --do-report --out-path DemoOutput --exp-name demo_experiment --run-cluster SLURM --res-mem 4 --queue defq -``` +Use `run_cluster = Local` for a local Dask cluster, or `run_cluster = Parallel` +for local joblib parallelism without Dask. -If the models of a STREAMLINE experiment were applied to replication data in phase 8 you can generate a report for the replication of a single target dataset using the following command. If you have multiple 'target datasets' each with one or more associated replication datasets, run this command once for each original target dataset (updating [`--rep-path`](parameters.md#rep-data-path) and [`--dataset`](parameters.md#rep-data-path) for each). -``` -python run.py --do-rep-report --out-path DemoOutput --exp-name demo_experiment --rep-path ./data/DemoRepData --dataset ./data/DemoData/hcc_data_custom.csv --run-cluster SLURM --res-mem 4 --queue defq -``` +`Parallel` and Dask-backed runs show progress when `tqdm`/Dask progress support is +available. Set `STREAMLINE_PROGRESS=0` to disable these progress displays. -###### Optional Clean-up -``` -python run.py --do-clean --out-path DemoOutput --exp-name demo_experiment --del-time --del-old-cv --run-cluster SLURM --res-mem 4 --queue defq -``` +Use the included configs as templates: -#### Checking STREAMLINE Job Completion -Whether running STREAMLINE from the configuration file or using command-line arguments, users may wish to check on the job completion status for jobs within a given phase. For example; (1) if running STREAMLINE one phase at a time, users will want to ensure that all jobs of the current phase have completed before inintiating the next, or (2) if the modeling phase is taking a long time to complete, you may wish to know what algorithms are still training. This can be accomplished using the included `checker.py` script. +* `run_configs/uci_binary_hcc.cfg` +* `run_configs/uci_multiclass_student.cfg` +* `run_configs/uci_regression_auto_mpg.cfg` -First, make sure you are in the installed `STREAMLINE` directory. Then you can check the parameter options of `checker.py` with: +## Rerunning Phases -``` -python checker.py --help -``` +STREAMLINE stores resolved phase arguments in `run_commands.pickle` inside the +experiment folder. If you rerun a phase and omit an option, the saved value can +be reused. Explicit command-line or config values override the saved value. -As an example, let's say the user wants to check the status of modeling jobs on their cluster during phase 5. They could run the following command which assumes we are running the demonstration data, as above. +Use this control when you need a clean rerun: -``` -python checker.py --out-path DemoOutput --exp-name demo_experiment --phase 5 --count-only True +```bash +python -m streamline.p6_modeling.p6_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --outcome_type Binary \ + --ignore_saved_run_command ``` -This would return the number of STREAMLINE jobs that have not yet completed (or failed to run) within phase 5. +Use `--no_update_saved_run_command` when you want to run with temporary +settings without changing the saved command summary. -Alternatively, the command below would output the names of the jobs that have not completed, which (in the case of phase 5) would inform the user which algorithms were still running. +## Phase CLI Commands -``` -python checker.py --out-path DemoOutput --exp-name demo_experiment --phase 5 -``` +Each phase can also be run independently. A binary classification example: + +```bash +python -m streamline.p1_data_process.p1_cli \ + --data_path data/UCIBinaryClassification \ + --output_path out \ + --experiment_name DemoBinary \ + --outcome_label Class \ + --outcome_type Binary \ + --instance_label InstanceID \ + --categorical_features data/UCIFeatureTypes/hcc_survival_categorical_features.csv \ + --quantitative_features data/UCIFeatureTypes/hcc_survival_quantitative_features.csv \ + --n_splits 3 \ + --force true + +python -m streamline.p2_impute_scale.p2_cli --output_path out --experiment_name DemoBinary +python -m streamline.p3_feature_learning.p3_cli --output_path out --experiment_name DemoBinary +python -m streamline.p4_feature_importance.p4_cli --output_path out --experiment_name DemoBinary +python -m streamline.p5_feature_selection.p5_cli --output_path out --experiment_name DemoBinary + +python -m streamline.p6_modeling.p6_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --outcome_label Class \ + --outcome_type Binary \ + --instance_label InstanceID \ + --models NB,LR,DT \ + --scoring_metric balanced_accuracy \ + --metric_direction maximize + +python -m streamline.p7_ensembles.p7_cli --output_path out --experiment_name DemoBinary +python -m streamline.p8_summary_statistics.p8_cli --output_path out --experiment_name DemoBinary +python -m streamline.p9_compare_datasets.p9_cli --output_path out --experiment_name DemoBinary + +python -m streamline.p10_replication.p10_cli \ + --rep_data_path data/UCIRepBinaryClassification \ + --dataset_for_rep data/UCIBinaryClassification/hcc_survival.csv \ + --output_path out \ + --experiment_name DemoBinary + +python -m streamline.p11_reporting.p11_cli \ + --experiment_path out/DemoBinary \ + --report_mode standard + +python -m streamline.p11_reporting.p11_cli \ + --experiment_path out/DemoBinary \ + --report_mode replication +``` + +More examples are available in `sample_runcommands.txt`. + +## Discovery Commands -## Picking a Run Mode - -### Why run STREAMLINE on Google Colab? -Running STREAMLINE on Google Colab is best for: -1. Running the STREAMLINE demonstration on the included demo data -2. Users with little to no coding experience -3. Users that want the quickest/easiest approach to running STREAMLINE -4. Users that do not have access to a very powerful computer or compute cluster. -5. Applying STREAMLINE to smaller-scale analyses (in particular when only using free/limited Google Cloud resources): - * Smaller datasets (e.g. < 500 instances and features) - * A small number of total datasets (e.g. 1 or 2) - * Only using the simplest/quickest modeling algorithms (e.g. Naive Bayes, Decision Trees, Logistic Regression) - * Only using 1 or 2 modeling algorithms - -1. **Google Colab Notebook** - on free Google Cloud resources [Anyone can run]: - * Advantages - * No coding or PC environment experience needed - * Automatically installs and uses the most recent version of STREAMLINE - * Computing can performed directly on Google Cloud from anywhere - * One-click run of whole pipeline (all phases) - * Offers in-notebook viewing of results and ability to save notebook as documentation of analysis - * Allows easy customizability of nearly all aspects of the pipeline with minimal coding/environment experience - * Disadvantages: - * Can only run pipeline serially - * Slowest of the run options - * Limited by google cloud computing allowances (may only work for smaller datasets) - * Notes: Requires a Google account (free) - -2. **Jupyter Notebook** - locally [Basic experience]: - * Advantages: - * Does not rely on free computing limitations of Google Cloud (but rather your own computer's limitations) - * One-click run of whole pipeline (all phases) - * Offers in-notebook viewing of results and ability to save notebook as documentation of analysis - * Allows easy customizability of all aspects of the pipeline with minimal coding/environment experience - * Disadvantages: - * Can only run pipeline serially - * Slower runtime than from command-line - * Beginners have to set up their computing environment - * Notes: Requires Anaconda3, Python3, and several other minor Python package installations - -3. **Command Line (Local)** [Command-line Users]: - * Advantages: - * Typically runs faster than within Jupyter Notebook - * A more versatile option for those with command-line experience - * One-command run of whole pipeline available when using a configuration file to run - * Can optionally run the pipeline one phase at a time - * Disadvantages: - * Can only run pipeline serially or with limited local cpu core parallelization - * Command-line experience recommended - * Notes: Requires Anaconda3, Python3, and several other minor Python package installations - -4. **Command Line (HPC Cluster)** [Computing Cluster Users]: - * Advantages: - * By far the fastest, most efficient way to run STREAMLINE - * Offers ability to run STREAMLINE over 7 types of HPC systems - * One-command run of whole pipeline available when using a configuration file to run - * Can optionally run the pipeline one phase at a time - * Disadvantages: - * Experience with command-line and dask-compatible clusters recommended - * Access to a computing cluster required - * Notes: Requires Anaconda3, Python3, and several other minor Python package installations. Cluster runs of STREAMLINE were set up using `dask-jobqueue` and thus should support 7 types of clusters as described in the [dask documentation](https://jobqueue.dask.org/en/latest/api.html). Currently we have only directly tested STREAMLINE on SLURM and LSF clusters. Further codebase adaptation may be needed for clusters types not on the above link. +Several phases can list registry options: +```bash +python -m streamline.p2_impute_scale.p2_cli --output_path out --experiment_name DemoBinary --list-imputers +python -m streamline.p2_impute_scale.p2_cli --output_path out --experiment_name DemoBinary --list-scalers +python -m streamline.p3_feature_learning.p3_cli --output_path out --experiment_name DemoBinary --list-learners +python -m streamline.p4_feature_importance.p4_cli --output_path out --experiment_name DemoBinary --list-models +python -m streamline.p6_modeling.p6_cli --output_path out --experiment_name DemoBinary --outcome_type Binary --list_models +python -m streamline.p7_ensembles.p7_cli --output_path out --experiment_name DemoBinary --list_ensembles +``` diff --git a/docs/source/tabpfn_token.md b/docs/source/tabpfn_token.md new file mode 100644 index 00000000..4a041aa0 --- /dev/null +++ b/docs/source/tabpfn_token.md @@ -0,0 +1,98 @@ +# TabPFN Token Setup + +TabPFN is optional in STREAMLINE. Install it separately when you want to run +TabPFN models: + +```bash +pip install tabpfn +``` + +TabPFN requires a one-time Prior Labs license acceptance before it can download +model weights for local inference. STREAMLINE can import and configure TabPFN +without this token, but Phase 6 skips requested TabPFN models until +`TABPFN_TOKEN` is available in the environment. + +```{warning} +If `TABPFN_TOKEN` is not set, Phase 6 warns and skips requested TabPFN models +instead of failing the full run. Other requested models, including HEROS, still +run normally. A passing run with skipped TabPFN means TabPFN was not fit. +``` + +## Get A Token + +1. Open `https://ux.priorlabs.ai` in a browser. +2. Log in or create an account. +3. Accept the TabPFN license on the Licenses tab. +4. Copy the API key from `https://ux.priorlabs.ai/account`. + +Do not commit this token to git, notebooks, config files, shared shell history, +or issue trackers. + +## Set The Token For One Terminal Session + +Activate your STREAMLINE environment and export the token before running +TabPFN models: + +```bash +conda activate streamline +export TABPFN_TOKEN="paste-your-api-key-here" +``` + +Confirm Python can see it: + +```bash +python -c "import os; print('TABPFN_TOKEN set:', bool(os.environ.get('TABPFN_TOKEN')))" +``` + +## Make The Token Persistent For A Conda Environment + +Create conda activation scripts so the token is set whenever the environment is +activated and removed when it is deactivated: + +```bash +conda activate streamline +mkdir -p "$CONDA_PREFIX/etc/conda/activate.d" "$CONDA_PREFIX/etc/conda/deactivate.d" +printf 'export TABPFN_TOKEN="paste-your-api-key-here"\n' > "$CONDA_PREFIX/etc/conda/activate.d/tabpfn_token.sh" +printf 'unset TABPFN_TOKEN\n' > "$CONDA_PREFIX/etc/conda/deactivate.d/tabpfn_token.sh" +chmod 600 "$CONDA_PREFIX/etc/conda/activate.d/tabpfn_token.sh" +``` + +Restart the terminal or run: + +```bash +conda deactivate +conda activate streamline +``` + +## Run The TabPFN-Specific Pytest + +The TabPFN pytest is intentionally explicit-only so the main test suite does +not run a heavyweight model download or fit by accident. Run it directly: + +```bash +pytest streamline/tests/subtests/tabpfn_smoke.py -q -rs +``` + +Without `TABPFN_TOKEN`, the no-token skip behavior is tested and the actual +TabPFN fit test is skipped with a visible reason. With `TABPFN_TOKEN` set, the +same command also runs the TabPFN binary wrapper fit smoke test. + +## Use TabPFN In Notebooks + +For local notebooks, set the token before launching Jupyter from the same shell: + +```bash +conda activate streamline +export TABPFN_TOKEN="paste-your-api-key-here" +jupyter notebook +``` + +For Colab, store the token in Colab secrets or set it in a private cell before +running TabPFN models: + +```python +import os +os.environ["TABPFN_TOKEN"] = "paste-your-api-key-here" +``` + +Avoid saving notebooks with a real token embedded in a code cell. diff --git a/docs/source/tips.md b/docs/source/tips.md index 89a7da61..0d3eeb5e 100644 --- a/docs/source/tips.md +++ b/docs/source/tips.md @@ -1,29 +1,64 @@ -# Guidelines for Setting Parameters - -## Reducing runtime -Conducting a more effective ML analysis typically demands a much larger amount of computing power and runtime. However, we provide general guidelines here for limiting overall runtime of a STREAMLINE experiment. -1. Run on a fewer number of datasets at once. -2. Run using fewer ML algorithms at once: - * Naive Bayes, Logistic Regression, and Decision Trees are typically fastest. - * Genetic Programming, eLCS, XCS, and ExSTraCS often take the longest (however other algorithms such as SVM, KNN, and ANN can take even longer when the number of instances is very large). -3. Run using a smaller number of `cv_partitions` (however keep in mind that this will impact the power of statistical significance testing in comparing algorithm and dataset formance, since it relies on the sample from multiple CV partitions) -4. Run without generating plots (i.e. `export_feature_correlations`, `export_univariate_plots`, `plot_PRC`, `plot_ROC`, `plot_FI_box`, `plot_metric_boxplots`). -5. In large datasets with missing values, set `multi_impute` to 'False'. This will apply simple mean imputation to numerical features instead. -6. Set `use_TURF` as 'False'. However we strongly recommend setting this to 'True' in feature spaces > 10,000 in order to avoid missing feature interactions during feature selection. -7. Set `TURF_pct` no lower than 0.5. Setting at 0.5 is by far the fastest, but it will operate more effectively in very large feature spaces when set lower. -8. Set `instance_subset` at or below 2000 (speeds up multiSURF feature importance evaluation at potential expense of performance). -9. Set `max_features_to_keep` at or below 2000 and `filter_poor_features` = 'True' (this limits the maximum number of features that can be passed on to ML modeling). -10. Set `training_subsample` at or below 2000 (this limits the number of sample used to train particularly expensive ML modeling algorithms). However avoid setting this too low, or ML algorithms may not have enough training instances to effectively learn. -11. Set `n_trials` and/or timeout to lower values (this limits the time spent on hyperparameter optimization). -12. If using eLCS, XCS, or ExSTraCS, set `do_lcs_sweep` to 'False', `iterations` at or below 200000, and `N` at or below 2000. - -## Improving Modeling Performance -* Generally speaking, the more computational time you are willing to spend on ML, the better the results. Doing the opposite of the above tips for reducing runtime, will likely improve performance. -* In certain situations, setting `feature_selection` to 'False', and relying on the ML algorithms alone to identify relevant features will yield better performance. However, this may only be computationally practical when the total number of features in an original dataset is smaller (e.g. under 2000). -* Note that eLCS, XCS, and ExSTraCS are newer algorithm implementations developed by our research group. As such, their algorithm performance may not yet be optimized in contrast to the other well established and widely utilized options. These learning classifier system (LCS) algorithms are unique however, in their ability to model very complex associations in data, while offering a largely interpretable model made up of simple, human readable IF:THEN rules. They have also been demonstrated to be able to tackle both complex feature interactions as well as heterogeneous patterns of association (i.e. different features are predictive in different subsets of the training data). -* In problems with no noise (i.e. datasets where it is possible to achieve 100% testing accuracy), LCS algorithms (i.e. eLCS, XCS, and ExSTraCS) perform better when `nu` is set larger than 1 (i.e. 5 or 10 recommended). This applies significantly more pressure for individual rules to achieve perfect accuracy. In noisy problems this may lead to significant overfitting. - -## Other Guidelines -* SVM and ANN modeling should only be applied when data scaling is applied by the pipeline. -* Logistic Regression' baseline model feature importance estimation is determined by the exponential of the feature's coefficient. This should only be used if data scaling is applied by the pipeline. Otherwise `use_uniform_FI` should be True. -* While the STREAMLINE includes `impute_data` as an option that can be turned off in `DataPreprocessing`, most algorithm implementations (all those standard in scikit-learn) cannot handle missing data values with the exception of eLCS, XCS, and ExSTraCS. In general, STREAMLINE is expected to fail with an errors if run on data with missing values, while `impute_data` is set to 'False'. \ No newline at end of file +# Tips + +## Start With A Dry Run + +Before launching a full config, inspect the resolved phase calls: + +```bash +python run.py -c run_configs/uci_binary_hcc.cfg --dry_run +``` + +This catches most path, phase toggle, and parameter-name mistakes early. + +## Keep Parameter Names Consistent + +The current notebooks, `.cfg` files, and CLI arguments are aligned around the +same parameter names where possible. Prefer copying one of the included UCI +configs and editing values rather than starting from an empty file. + +## Choose Metrics By Task + +Good defaults: + +| Task | Metric | +| --- | --- | +| Binary classification | `balanced_accuracy` | +| Multiclass classification | `balanced_accuracy` | +| Regression | `explained_variance` or `pearson_correlation` | + +Use `metric_direction = maximize` for these defaults. Use `minimize` for error +metrics such as mean absolute error. + +## Use Replication As External Validation + +P10 should be used for data that were not part of training/CV. The included UCI +replication folders are deterministic held-out splits for demonstration. + +## SMOTE Guidance + +Enable P2 SMOTE only for classification tasks and only when class imbalance is +large enough to justify oversampling: + +```ini +[p2] +smote = True +smote_method = auto +``` + +`auto` chooses SMOTENC when categorical features are present. + +## Native Categorical Handling + +If P1 uses `one_hot_encoding = False`, P6 should run only native categorical +models unless you explicitly add support for another model. The default native +categorical list includes CatBoost/CGB and ExSTraCS. + +## Faster Test Runs + +For quick smoke tests: + +* Use `n_splits = 3`. +* Use a small model list such as `NB,LR,DT`. +* Lower `n_trials`. +* Set report `enable_plots = False` when checking report logic only. +* Use `--only` or `--stop_after` for targeted config runs. diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 00000000..e89e4a87 --- /dev/null +++ b/pytest.ini @@ -0,0 +1,13 @@ +[pytest] +minversion = 7.0 +testpaths = streamline/tests +python_files = test_complete_*.py +norecursedirs = + __pycache__ + old + subtests +addopts = + --ignore=streamline/tests/old + --ignore=streamline/tests/subtests +markers = + integration: end-to-end STREAMLINE pipeline tests. diff --git a/requirements.txt b/requirements.txt index 96c1568b..d3da4c32 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,16 +1,18 @@ matplotlib -numpy<2.0.0 +numpy optuna -sqlalchemy<2.0 -plotly>=4.0.0 -pandas>=1.5.2 +sqlalchemy +plotly +pandas pip pycodestyle -scikit-learn>=1.1.3,<1.3.0 -threadpoolctl==3.1.0 -scipy>=1.8.0 -seaborn>=0.11.0 -skrebate==0.7 +scikit-learn +imbalanced-learn +threadpoolctl +scipy +seaborn +skrebate==0.8.2 +mlxtend tqdm wheel pytest @@ -19,14 +21,20 @@ lightgbm catboost gplearn ipython -fpdf +fpdf2 scikit-XCS scikit-ExSTraCS scikit-eLCS +skheros +tabpfn +wittgenstein kaleido dask-jobqueue dask joblib +group-lasso graphviz bokeh ipywidgets +cairocffi +weasyprint diff --git a/run.py b/run.py index 062ce66f..99a89aa8 100644 --- a/run.py +++ b/run.py @@ -1,279 +1,5 @@ -import os -import sys -import time -import optuna -import logging -from streamline.utils.parser import parser_function -from streamline.utils.checker import check_phase -from streamline.utils.runners import check_if_single_phase -import warnings +from streamline.pipeline.pipeline_cli import main -warnings.filterwarnings("ignore") -optuna.logging.set_verbosity(optuna.logging.WARNING) - -logger = logging.getLogger() -logger.setLevel(logging.INFO) -formatter = logging.Formatter('%(asctime)s | %(levelname)s | %(message)s') - -phase_list = ["", "Exploratory", "Data Process", "Feature Imp.", - "Feature Sel.", "Modeling", "Post-Analysis", "Dataset Compare", - "Testing Evaluation Report", "Replication", - "Replication Evaluation Report", "Cleaning"] - -phase_number = [' ', 1, 2, 3, 4, 5, 6, 7, 9, 8, 9, ' '] -for idx in range(len(phase_number)): - if type(phase_number[idx]) == int: - phase_number[idx] = " (" + str(phase_number[idx]) + ") " - - -def runner(obj, phase, run_parallel=True, params=None): - start = time.time() - - phase_str = phase_list[phase] - phase_nu = phase_number[phase] - print() - if params['run_cluster'] and phase != 11: - print("Running " + phase_str + " Phase " + str(phase_nu) - + " with " + str(params['run_cluster']) + " Setup") - else: - print("Running " + phase_str + " Stage" + str(phase_nu) - + "with " + "Local" + " Setup") - how = "with " + str(params['run_cluster']) + " Manual Jobs" - if params['run_cluster'] == "SLURMOld" or params['run_cluster'] == "LSFOld": - obj.run(run_parallel=run_parallel) - try: - rep_data_path = params['rep_data_path'] - dataset_for_rep = params['dataset_for_rep'] - except KeyError: - rep_data_path = None - dataset_for_rep = None - if phase == 1: - time.sleep(5) - while len(check_phase(params['output_path'], params['experiment_name'], - phase=phase, len_only=True, - rep_data_path=rep_data_path, - dataset_for_rep=dataset_for_rep, - output=True)) != 0: - print() - if check_if_single_phase(params): - print("Only one phase submitted using bash scripts, the runner can submit jobs and exit") - print("Exiting") - sys.exit() - print("Waiting for " + phase_str + " Manual Jobs to Finish") - time.sleep(5) - print() - else: - obj.run(run_parallel=run_parallel) - if not run_parallel or run_parallel == "False": - how = "serially" - elif run_parallel in ["multiprocessing", "True", True] \ - and str(params['run_cluster']) == "False": - how = "parallely" - if str(params['run_cluster']) != "False": - how = "with " + str(params['run_cluster']) + " dask cluster" - - print("Ran " + phase_str + " Phase " + how + " in " + str(time.time() - start)) - if str(params['run_cluster']) == "LSF": - time.sleep(2) - del obj - - -def len_datasets(output_path, experiment_name): - datasets = os.listdir(output_path + '/' + experiment_name) - remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle', - 'jobsCompleted', 'logs', 'jobs', 'DatasetComparisons', - 'UsefulNotebooks', 'dask_logs', - experiment_name + '_STREAMLINE_Report.pdf'] - for text in remove_list: - if text in datasets: - datasets.remove(text) - return len(datasets) - - -def run(params): - start_g = time.time() - - if params['do_eda']: - from streamline.runners.dataprocess_runner import DataProcessRunner - eda = DataProcessRunner(params['dataset_path'], params['output_path'], params['experiment_name'], - exclude_eda_output=params['exclude_eda_output'], - class_label=params['class_label'], instance_label=params['instance_label'], - match_label=params['match_label'], - n_splits=params['cv_partitions'], - partition_method=params['partition_method'], - ignore_features=params['ignore_features_path'], - categorical_features=params['categorical_feature_path'], - quantitative_features=params['quantitative_feature_path'], - top_features=params['top_uni_features'], - categorical_cutoff=params['categorical_cutoff'], - sig_cutoff=params['sig_cutoff'], - featureeng_missingness=params['featureeng_missingness'], - cleaning_missingness=params['cleaning_missingness'], - correlation_removal_threshold=params['correlation_removal_threshold'], - random_state=params['random_state'], - run_cluster=params['run_cluster'], - queue=params['queue'], - reserved_memory=params['reserved_memory']) - - runner(eda, 1, run_parallel=params['run_parallel'], params=params) - - if params['do_dataprep']: - from streamline.runners.imputation_runner import ImputationRunner - dpr = ImputationRunner(params['output_path'], params['experiment_name'], scale_data=params['scale_data'], - impute_data=params['impute_data'], - multi_impute=params['multi_impute'], overwrite_cv=params['overwrite_cv'], - class_label=params['class_label'], - instance_label=params['instance_label'], random_state=params['random_state'], - run_cluster=params['run_cluster'], - queue=params['queue'], - reserved_memory=params['reserved_memory']) - runner(dpr, 2, run_parallel=params['run_parallel'], params=params) - - if params['do_feat_imp']: - from streamline.runners.feature_runner import FeatureImportanceRunner - f_imp = FeatureImportanceRunner(params['output_path'], params['experiment_name'], - class_label=params['class_label'], - instance_label=params['instance_label'], - instance_subset=params['instance_subset'], algorithms=params['feat_algorithms'], - use_turf=params['use_turf'], - turf_pct=params['turf_pct'], - random_state=params['random_state'], n_jobs=params['n_jobs'], - run_cluster=params['run_cluster'], - queue=params['queue'], - reserved_memory=params['reserved_memory']) - runner(f_imp, 3, run_parallel=params['run_parallel'], params=params) - - if params['do_feat_sel']: - from streamline.runners.feature_runner import FeatureSelectionRunner - f_sel = FeatureSelectionRunner(params['output_path'], params['experiment_name'], - algorithms=params['feat_algorithms'], - class_label=params['class_label'], - instance_label=params['instance_label'], - max_features_to_keep=params['max_features_to_keep'], - filter_poor_features=params['filter_poor_features'], - top_features=params['top_fi_features'], export_scores=params['export_scores'], - overwrite_cv=params['overwrite_cv_feat'], random_state=params['random_state'], - n_jobs=params['n_jobs'], - run_cluster=params['run_cluster'], - queue=params['queue'], - reserved_memory=params['reserved_memory']) - runner(f_sel, 4, run_parallel=params['run_parallel'], params=params) - - if params['do_model']: - from streamline.runners.model_runner import ModelExperimentRunner - model = ModelExperimentRunner(params['output_path'], params['experiment_name'], - algorithms=params['algorithms'], exclude=params['exclude'], - class_label=params['class_label'], - instance_label=params['instance_label'], scoring_metric=params['primary_metric'], - metric_direction=params['metric_direction'], - training_subsample=params['training_subsample'], - use_uniform_fi=params['use_uniform_fi'], - n_trials=params['n_trials'], - timeout=params['timeout'], save_plots=False, do_lcs_sweep=params['do_lcs_sweep'], - lcs_nu=params['lcs_nu'], - lcs_n=params['lcs_n'], - lcs_iterations=params['lcs_iterations'], - lcs_timeout=params['lcs_timeout'], resubmit=params['model_resubmit'], - random_state=params['random_state'], n_jobs=params['n_jobs'], - run_cluster=params['run_cluster'], - queue=params['queue'], - reserved_memory=params['reserved_memory']) - - runner(model, 5, run_parallel=params['run_parallel'], params=params) - - if params['do_stats']: - from streamline.runners.stats_runner import StatsRunner - stats = StatsRunner(params['output_path'], params['experiment_name'], algorithms=params['algorithms'], - exclude=params['exclude'], - class_label=params['class_label'], instance_label=params['instance_label'], - scoring_metric=params['primary_metric'], - top_features=params['top_model_fi_features'], sig_cutoff=params['sig_cutoff'], - metric_weight=params['metric_weight'], - scale_data=params['scale_data'], - exclude_plots=params['exclude_plots'], show_plots=False, - run_cluster=params['run_cluster'], - queue=params['queue'], - reserved_memory=params['reserved_memory']) - runner(stats, 6, run_parallel=params['run_parallel'], params=params) - - if params['do_compare_dataset']: - if len_datasets(params['output_path'], params['experiment_name']) > 1: - from streamline.runners.compare_runner import CompareRunner - compare = CompareRunner(params['output_path'], params['experiment_name'], experiment_path=None, - algorithms=params['algorithms'], - exclude=params['exclude'], - class_label=params['class_label'], instance_label=params['instance_label'], - sig_cutoff=params['sig_cutoff'], - show_plots=False, - run_cluster=params['run_cluster'], - queue=params['queue'], - reserved_memory=params['reserved_memory']) - runner(compare, 7, run_parallel=params['run_parallel'], params=params) - - if params['do_report']: - from streamline.runners.report_runner import ReportRunner - report = ReportRunner(output_path=params['output_path'], experiment_name=params['experiment_name'], - experiment_path=None, - algorithms=params['algorithms'], exclude=params['exclude'], - run_cluster=params['run_cluster'], - queue=params['queue'], - reserved_memory=params['reserved_memory']) - runner(report, 8, run_parallel=params['run_parallel'], params=params) - - if params['do_replicate']: - from streamline.runners.replicate_runner import ReplicationRunner - replicate = ReplicationRunner(params['rep_data_path'], params['dataset_for_rep'], params['output_path'], - params['experiment_name'], - class_label=params['class_label'], instance_label=params['instance_label'], - match_label=params['match_label'], - algorithms=params['algorithms'], load_algo=True, - exclude=params['exclude'], - exclude_plots=params['exclude_rep_plots'], - run_cluster=params['run_cluster'], - queue=params['queue'], - reserved_memory=params['reserved_memory']) - runner(replicate, 9, run_parallel=params['run_parallel'], params=params) - - if params['do_rep_report']: - from streamline.runners.report_runner import ReportRunner - report = ReportRunner(output_path=params['output_path'], experiment_name=params['experiment_name'], - experiment_path=None, - algorithms=params['algorithms'], exclude=params['exclude'], training=False, - rep_data_path=params['rep_data_path'], - dataset_for_rep=params['dataset_for_rep'], - run_cluster=params['run_cluster'], - queue=params['queue'], - reserved_memory=params['reserved_memory']) - runner(report, 10, run_parallel=params['run_parallel'], params=params) - - if params['do_cleanup']: - from streamline.runners.clean_runner import CleanRunner - clean = CleanRunner(params['output_path'], params['experiment_name'], - del_time=params['del_time'], del_old_cv=params['del_old_cv']) - runner(clean, 11, run_parallel=params['run_parallel'], params=params) - - print("DONE!!!") - print("Ran in " + str(time.time() - start_g)) - - -if __name__ == '__main__': - - # NOTE: All keys must be small - config_dict = parser_function(sys.argv) - - if not os.path.exists(config_dict['output_path']): - os.mkdir(str(config_dict['output_path'])) - - if config_dict['verbose']: - stdout_handler = logging.StreamHandler(sys.stdout) - stdout_handler.setLevel(logging.INFO) - stdout_handler.setFormatter(formatter) - logger.addHandler(stdout_handler) - else: - file_handler = logging.FileHandler(str(config_dict['output_path']) + '/logs.log') - file_handler.setLevel(logging.INFO) - file_handler.setFormatter(formatter) - logger.addHandler(file_handler) - - sys.exit(run(config_dict)) +if __name__ == "__main__": + main() diff --git a/run_configs/cedars.cfg b/run_configs/cedars.cfg deleted file mode 100644 index c3f60c08..00000000 --- a/run_configs/cedars.cfg +++ /dev/null @@ -1,111 +0,0 @@ -[essential run parameters - preset for included demonstration datasets - phases 1-9] -dataset_path = './data/DemoData' -output_path = 'DemoOutput' -experiment_name = 'demo_experiment' -class_label = 'Class' -instance_label = 'InstanceID' -match_label = None -ignore_features_path = None -categorical_feature_path = ['Gender','Symptoms','Alcohol','Hepatitis B Surface Antigen','Hepatitis B e Antigen','Hepatitis B Core Antibody','Hepatitis C Virus Antibody','Cirrhosis', - 'Endemic Countries','Smoking','Diabetes','Obesity','Hemochromatosis','Arterial Hypertension','Chronic Renal Insufficiency','Human Immunodeficiency Virus', - 'Nonalcoholic Steatohepatitis','Esophageal Varices','Splenomegaly','Portal Hypertension','Portal Vein Thrombosis','Liver Metastasis','Radiological Hallmark', - 'Sim_Cat_2','Sim_Cat_3','Sim_Cat_4','Sim_Text_Cat_2','Sim_Text_Cat_3','Sim_Text_Cat_4','Invariant_Val','Invariant_NA','Invariant_Val_NA'] -quantitative_feature_path = ['Age at diagnosis','Grams of Alcohol per day','Packs of cigarets per year', 'Performance Status*', 'Encephalopathy degree*','Ascites degree*', - 'International Normalised Ratio*','Alpha-Fetoprotein (ng/mL)','Haemoglobin (g/dL)','Mean Corpuscular Volume', 'Leukocytes(G/L)', - 'Platelets','Albumin (mg/dL)','Total Bilirubin(mg/dL)','Alanine transaminase (U/L)','Aspartate transaminase (U/L)','Gamma glutamyl transferase (U/L)', - 'Alkaline phosphatase (U/L)', 'Total Proteins (g/dL)', 'Creatinine (mg/dL)','Number of Nodules','Major dimension of nodule (cm)','Direct Bilirubin (mg/dL)', - 'Iron', 'Oxygen Saturation (%%)','Ferritin (ng/mL)','Sim_Miss_0.6','Sim_Miss_0.7','Sim_Cor_-1.0_A','Sim_Cor_-1.0_B','Sim_Cor_0.9_A', 'Sim_Cor_0.9_B', - 'Sim_Cor_1.0_A','Sim_Cor_1.0_B'] -rep_data_path = './data/DemoRepData' -dataset_for_rep = './data/DemoData/hcc_data_custom.csv' - -[essential run parameters - phases to run - phases 1-9] -# If True, automatically runs all phases below up until and including do_report, automatically running 'compare_dataset' only if multiple target datasets included -do_till_report = True - -# Individual phases (do_report and do_rep_report are both part of phase 9) -do_eda = False -do_dataprep = False -do_feat_imp = False -do_feat_sel = False -do_model = False -do_stats = False -do_compare_dataset = False -do_report = False -do_replicate = True -do_rep_report = True -do_cleanup = True - -[general - phase 1] -cv_partitions = 3 -partition_method = 'Stratified' -categorical_cutoff = 10 -sig_cutoff = 0.05 -random_state = 42 - -[data processing - phase 1] -exclude_eda_output = None -top_uni_features = 40 -featureeng_missingness = 0.5 -cleaning_missingness = 0.5 -correlation_removal_threshold = 1.0 - -[imputing and scaling - phase 2] -impute_data = True -scale_data = True -multi_impute = True -overwrite_cv = False - -[feature importance estimation - phase 3] -do_mutual_info = True -do_multisurf = True -use_turf = False -turf_pct = 0.5 -instance_subset = 2000 -n_jobs = 1 - -[feature selection - phase 4] -filter_poor_features = True -max_features_to_keep = 2000 -export_scores = True -top_fi_features = 40 -overwrite_cv_feat = True - -[modeling - phase 5] -algorithms = ['LR', 'NB', 'DT'] -exclude = ['eLCS', 'XCS'] -training_subsample = 0 -use_uniform_fi = True -primary_metric = 'balanced_accuracy' -metric_direction = 'maximize' -n_trials = 200 -timeout = 900 -export_hyper_sweep_plots = False -do_lcs_sweep = False -lcs_nu = 1 -lcs_iterations = 200000 -lcs_n = 2000 -lcs_timeout = 1200 -model_resubmit = False - -[post-analysis - phase 6] -exclude_plots = None -metric_weight = 'balanced_accuracy' -top_model_fi_features = 40 - -[replication - phase 8] -exclude_rep_plots = None - -[cleanup] -del_time = False -del_old_cv = False - -[multiprocessing] -run_parallel = True -run_cluster = "SLURM" -reserved_memory = 4 -queue = 'defq' - -[logging] -logging_level = 'INFO' -verbose = False \ No newline at end of file diff --git a/run_configs/cedars_old.cfg b/run_configs/cedars_old.cfg deleted file mode 100644 index 2ff28d8b..00000000 --- a/run_configs/cedars_old.cfg +++ /dev/null @@ -1,111 +0,0 @@ -[essential run parameters - preset for included demonstration datasets - phases 1-9] -dataset_path = './data/DemoData' -output_path = 'DemoOutput' -experiment_name = 'demo_experiment' -class_label = 'Class' -instance_label = 'InstanceID' -match_label = None -ignore_features_path = None -categorical_feature_path = ['Gender','Symptoms','Alcohol','Hepatitis B Surface Antigen','Hepatitis B e Antigen','Hepatitis B Core Antibody','Hepatitis C Virus Antibody','Cirrhosis', - 'Endemic Countries','Smoking','Diabetes','Obesity','Hemochromatosis','Arterial Hypertension','Chronic Renal Insufficiency','Human Immunodeficiency Virus', - 'Nonalcoholic Steatohepatitis','Esophageal Varices','Splenomegaly','Portal Hypertension','Portal Vein Thrombosis','Liver Metastasis','Radiological Hallmark', - 'Sim_Cat_2','Sim_Cat_3','Sim_Cat_4','Sim_Text_Cat_2','Sim_Text_Cat_3','Sim_Text_Cat_4','Invariant_Val','Invariant_NA','Invariant_Val_NA'] -quantitative_feature_path = ['Age at diagnosis','Grams of Alcohol per day','Packs of cigarets per year', 'Performance Status*', 'Encephalopathy degree*','Ascites degree*', - 'International Normalised Ratio*','Alpha-Fetoprotein (ng/mL)','Haemoglobin (g/dL)','Mean Corpuscular Volume', 'Leukocytes(G/L)', - 'Platelets','Albumin (mg/dL)','Total Bilirubin(mg/dL)','Alanine transaminase (U/L)','Aspartate transaminase (U/L)','Gamma glutamyl transferase (U/L)', - 'Alkaline phosphatase (U/L)', 'Total Proteins (g/dL)', 'Creatinine (mg/dL)','Number of Nodules','Major dimension of nodule (cm)','Direct Bilirubin (mg/dL)', - 'Iron', 'Oxygen Saturation (%%)','Ferritin (ng/mL)','Sim_Miss_0.6','Sim_Miss_0.7','Sim_Cor_-1.0_A','Sim_Cor_-1.0_B','Sim_Cor_0.9_A', 'Sim_Cor_0.9_B', - 'Sim_Cor_1.0_A','Sim_Cor_1.0_B'] -rep_data_path = './data/DemoRepData' -dataset_for_rep = './data/DemoData/hcc_data_custom.csv' - -[essential run parameters - phases to run - phases 1-9] -# If True, automatically runs all phases below up until and including do_report, automatically running 'compare_dataset' only if multiple target datasets included -do_till_report = True - -# Individual phases (do_report and do_rep_report are both part of phase 9) -do_eda = False -do_dataprep = False -do_feat_imp = False -do_feat_sel = False -do_model = False -do_stats = False -do_compare_dataset = False -do_report = False -do_replicate = True -do_rep_report = True -do_cleanup = True - -[general - phase 1] -cv_partitions = 3 -partition_method = 'Stratified' -categorical_cutoff = 10 -sig_cutoff = 0.05 -random_state = 42 - -[data processing - phase 1] -exclude_eda_output = None -top_uni_features = 40 -featureeng_missingness = 0.5 -cleaning_missingness = 0.5 -correlation_removal_threshold = 1.0 - -[imputing and scaling - phase 2] -impute_data = True -scale_data = True -multi_impute = True -overwrite_cv = False - -[feature importance estimation - phase 3] -do_mutual_info = True -do_multisurf = True -use_turf = False -turf_pct = 0.5 -instance_subset = 2000 -n_jobs = 1 - -[feature selection - phase 4] -filter_poor_features = True -max_features_to_keep = 2000 -export_scores = True -top_fi_features = 40 -overwrite_cv_feat = True - -[modeling - phase 5] -algorithms = ['LR', 'NB', 'DT'] -exclude = ['eLCS', 'XCS'] -training_subsample = 0 -use_uniform_fi = True -primary_metric = 'balanced_accuracy' -metric_direction = 'maximize' -n_trials = 200 -timeout = 900 -export_hyper_sweep_plots = False -do_lcs_sweep = False -lcs_nu = 1 -lcs_iterations = 200000 -lcs_n = 2000 -lcs_timeout = 1200 -model_resubmit = False - -[post-analysis - phase 6] -exclude_plots = None -metric_weight = 'balanced_accuracy' -top_model_fi_features = 40 - -[replication - phase 8] -exclude_rep_plots = None - -[cleanup] -del_time = False -del_old_cv = False - -[multiprocessing] -run_parallel = True -run_cluster = "UGE" -reserved_memory = 4 -queue = 'all.q' - -[logging] -logging_level = 'INFO' -verbose = False \ No newline at end of file diff --git a/run_configs/local.cfg b/run_configs/local.cfg deleted file mode 100644 index 0e330e26..00000000 --- a/run_configs/local.cfg +++ /dev/null @@ -1,120 +0,0 @@ -[essential run parameters - preset for included demonstration datasets - phases 1-9] -dataset_path = './data/DemoData' -output_path = 'DemoOutput' -experiment_name = 'demo_experiment' -class_label = 'Class' -instance_label = 'InstanceID' -match_label = None -ignore_features_path = None -categorical_feature_path = ['Gender','Symptoms','Alcohol','Hepatitis B Surface Antigen','Hepatitis B e Antigen','Hepatitis B Core Antibody','Hepatitis C Virus Antibody','Cirrhosis', - 'Endemic Countries','Smoking','Diabetes','Obesity','Hemochromatosis','Arterial Hypertension','Chronic Renal Insufficiency','Human Immunodeficiency Virus', - 'Nonalcoholic Steatohepatitis','Esophageal Varices','Splenomegaly','Portal Hypertension','Portal Vein Thrombosis','Liver Metastasis','Radiological Hallmark', - 'Sim_Cat_2','Sim_Cat_3','Sim_Cat_4','Sim_Text_Cat_2','Sim_Text_Cat_3','Sim_Text_Cat_4','Invariant_Val','Invariant_NA','Invariant_Val_NA'] -quantitative_feature_path = ['Age at diagnosis','Grams of Alcohol per day','Packs of cigarets per year', 'Performance Status*', 'Encephalopathy degree*','Ascites degree*', - 'International Normalised Ratio*','Alpha-Fetoprotein (ng/mL)','Haemoglobin (g/dL)','Mean Corpuscular Volume', 'Leukocytes(G/L)', - 'Platelets','Albumin (mg/dL)','Total Bilirubin(mg/dL)','Alanine transaminase (U/L)','Aspartate transaminase (U/L)','Gamma glutamyl transferase (U/L)', - 'Alkaline phosphatase (U/L)', 'Total Proteins (g/dL)', 'Creatinine (mg/dL)','Number of Nodules','Major dimension of nodule (cm)','Direct Bilirubin (mg/dL)', - 'Iron', 'Oxygen Saturation (%%)','Ferritin (ng/mL)','Sim_Miss_0.6','Sim_Miss_0.7','Sim_Cor_-1.0_A','Sim_Cor_-1.0_B','Sim_Cor_0.9_A', 'Sim_Cor_0.9_B', - 'Sim_Cor_1.0_A','Sim_Cor_1.0_B'] -rep_data_path = './data/DemoRepData' -dataset_for_rep = './data/DemoData/hcc_data_custom.csv' - -[essential run parameters - phases to run - phases 1-9] -# If True, automatically runs all phases below up until and including do_report, automatically running 'compare_dataset' only if multiple target datasets included -do_till_report = True - -# Individual phases (do_report and do_rep_report are both part of phase 9) -do_eda = False -do_dataprep = False -do_feat_imp = False -do_feat_sel = False -do_model = False -do_stats = False -do_compare_dataset = False -do_report = False -do_replicate = True -do_rep_report = True -do_cleanup = True - -[general - phase 1] -cv_partitions = 3 -partition_method = 'Stratified' -categorical_cutoff = 10 -sig_cutoff = 0.05 -random_state = 42 - -[data processing - phase 1] -exclude_eda_output = None -top_uni_features = 40 -featureeng_missingness = 0.5 -cleaning_missingness = 0.5 -correlation_removal_threshold = 1.0 - -[imputing and scaling - phase 2] -impute_data = True -scale_data = True -multi_impute = True -overwrite_cv = False - -[feature importance estimation - phase 3] -do_mutual_info = True -do_multisurf = True -use_turf = False -turf_pct = 0.5 -instance_subset = 2000 -n_jobs = 1 - -[feature selection - phase 4] -filter_poor_features = True -max_features_to_keep = 2000 -export_scores = True -top_fi_features = 40 -overwrite_cv_feat = True - -[modeling - phase 5] -algorithms = ['LR', 'NB', 'DT'] -exclude = ['eLCS', 'XCS'] -training_subsample = 0 -use_uniform_fi = True -primary_metric = 'balanced_accuracy' -metric_direction = 'maximize' -n_trials = 200 -timeout = 900 -export_hyper_sweep_plots = False -do_lcs_sweep = False -lcs_nu = 1 -lcs_iterations = 200000 -lcs_n = 2000 -lcs_timeout = 1200 -model_resubmit = False - -[post-analysis - phase 6] -exclude_plots = None -metric_weight = 'balanced_accuracy' -top_model_fi_features = 40 - -[replication - phase 8] -exclude_rep_plots = None - -[cleanup] -del_time = False -del_old_cv = False - -[multiprocessing] -run_parallel = True -run_cluster = False -reserved_memory = 4 -queue = 'defq' - -[logging] -logging_level = 'INFO' -verbose = False - - - - - - - - - diff --git a/run_configs/lsf_run.sh b/run_configs/lsf_run.sh deleted file mode 100644 index ac272986..00000000 --- a/run_configs/lsf_run.sh +++ /dev/null @@ -1,9 +0,0 @@ -#!/bin/bash -#BSUB -p i2c2_normal -#BSUB -J STREAMLINE -#BSUB -R -"rusage[mem=1G]" -#BSUB -M 1G -#BSUB -o job.o -#BSUB -e job.e -#BSUB --time=48:00:00 -python run.py -c upenn.cfg diff --git a/run_configs/slurm_run.sh b/run_configs/slurm_run.sh deleted file mode 100644 index af7801a5..00000000 --- a/run_configs/slurm_run.sh +++ /dev/null @@ -1,11 +0,0 @@ -#!/bin/bash -#SBATCH -p defq -#SBATCH --job-name=STREAMLINE -#SBATCH --mem=1G -#SBATCH -o job.o -#SBATCH -e job.e -#SBATCH --time=48:00:00 -#SBATCH --nodes=1 -#SBATCH --ntasks=1 -#SBATCH --cpus-per-task=1 -srun python run.py -c cedars.cfg diff --git a/run_configs/uci_binary_hcc.cfg b/run_configs/uci_binary_hcc.cfg new file mode 100644 index 00000000..1ac20d72 --- /dev/null +++ b/run_configs/uci_binary_hcc.cfg @@ -0,0 +1,155 @@ +[run] +output_path = out +experiment_name = UCIHCCPipeline +outcome_label = Class +outcome_type = Binary +instance_label = InstanceID +n_splits = 3 +# Options: Serial, Local (Dask), Parallel (joblib), BashSLURM, BashLSF, or a named Dask cluster. +run_cluster = Serial +queue = defq +reserved_memory = 4 +random_state = 42 + +[phases] +phase_order = p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11 +do_p1 = True +do_p2 = True +do_p3 = True +do_p4 = True +do_p5 = True +do_p6 = True +do_p7 = True +do_p8 = True +do_p9 = True +do_p10 = True +do_p11 = True + +[p1] +data_path = data/UCIBinaryClassification +exclude_eda_output = None +match_label = None +ignore_features = None +categorical_features = data/UCIFeatureTypes/hcc_survival_categorical_features.csv +quantitative_features = data/UCIFeatureTypes/hcc_survival_quantitative_features.csv +top_features = 20 +categorical_cutoff = 10 +sig_cutoff = 0.05 +featureeng_missingness = 0.5 +cleaning_missingness = 0.5 +correlation_removal_threshold = 1.0 +partition_method = Stratified +show_plots = False +one_hot_encoding = True +cv_provided = False +cv_input_root = None +enable_plots = False +plot_missingness = False +plot_class_counts = False +plot_correlation = False +correlation_plot_max_features = 200 +plot_univariate = False +univariate_top_k = 20 +plot_anomalies = False +force = True + +[p2] +scale_data = True +impute_data = True +multi_impute = False +overwrite_cv = True +imputer_id = None +imputer_params = {} +scaler_id = None +scaler_params = {} +smote = False +smote_method = auto +smote_sampling_strategy = auto +smote_k_neighbors = 5 + +[p3] +learner_id = pca +learner_params = {} +feature_namespace = FL_PCA +keep_original_features = True +overwrite_cv = True + +[p4] +models = mutualinformation,multiswrfdb +models_params = {'mutualinformation': {'outcome_type': 'Binary'}, 'multiswrfdb': {'n_jobs': 1}} +top_k = None +threshold = None +keep_original_features = False +overwrite_cv = True +instance_subset = None + +[p5] +algorithms = auto +n_splits = 3 +max_features_to_keep = 2000 +filter_poor_features = True +overwrite_cv = False +selector_id = default +selector_params = {} +export_scores = True +top_features = 20 +show_plots = False +strict_discovery = False + +[p6] +outcome_type = Binary +model_type = None +models = NB,LR,DT +model_params_json = None +calibrate = False +calibrate_method = sigmoid +calibrate_cv = 5 +scoring_metric = balanced_accuracy +metric_direction = maximize +n_trials = 200 +timeout = 900 +training_subsample = 0 +uniform_fi = False +save_plot = False +bypass_one_hot_for_native_models = False +native_categorical_models = CGB,ExSTraCS + +[p7] +ensembles = hard_voting,soft_voting,stack_lr +base_models = NB,LR,DT +meta_train_source = train +calibrate = 0 +calibrate_method = sigmoid +calibrate_cv = 5 + +[p8] +scoring_metric = balanced_accuracy +metric_weight = balanced_accuracy +top_features = 40 +sig_cutoff = 0.05 +scale_data = True +exclude_plots = None +show_plots = False +include_ensembles = True +multiclass_average = micro + +[p9] +sig_cutoff = 0.05 +show_plots = False + +[p10] +rep_data_path = data/UCIRepBinaryClassification +dataset_for_rep = data/UCIBinaryClassification/hcc_survival.csv +match_label = None +exclude_plots = None +show_plots = False + +[p11] +report_modes = standard,replication +reporting_dir = None +outcome_label = Class +outcome_type = Binary +instance_label = InstanceID +make_pdf = True +enable_plots = True +reuse_existing_figures = True diff --git a/run_configs/uci_multiclass_student.cfg b/run_configs/uci_multiclass_student.cfg new file mode 100644 index 00000000..30ea85e9 --- /dev/null +++ b/run_configs/uci_multiclass_student.cfg @@ -0,0 +1,155 @@ +[run] +output_path = out +experiment_name = UCIStudentPipeline +outcome_label = Class +outcome_type = Multiclass +instance_label = InstanceID +n_splits = 3 +# Options: Serial, Local (Dask), Parallel (joblib), BashSLURM, BashLSF, or a named Dask cluster. +run_cluster = Serial +queue = defq +reserved_memory = 4 +random_state = 42 + +[phases] +phase_order = p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11 +do_p1 = True +do_p2 = True +do_p3 = True +do_p4 = True +do_p5 = True +do_p6 = True +do_p7 = True +do_p8 = True +do_p9 = True +do_p10 = True +do_p11 = True + +[p1] +data_path = data/UCIMulticlassClassification +exclude_eda_output = None +match_label = None +ignore_features = None +categorical_features = data/UCIFeatureTypes/student_dropout_categorical_features.csv +quantitative_features = data/UCIFeatureTypes/student_dropout_quantitative_features.csv +top_features = 20 +categorical_cutoff = 10 +sig_cutoff = 0.05 +featureeng_missingness = 0.5 +cleaning_missingness = 0.5 +correlation_removal_threshold = 1.0 +partition_method = Stratified +show_plots = False +one_hot_encoding = True +cv_provided = False +cv_input_root = None +enable_plots = False +plot_missingness = False +plot_class_counts = False +plot_correlation = False +correlation_plot_max_features = 200 +plot_univariate = False +univariate_top_k = 20 +plot_anomalies = False +force = True + +[p2] +scale_data = True +impute_data = True +multi_impute = False +overwrite_cv = True +imputer_id = None +imputer_params = {} +scaler_id = None +scaler_params = {} +smote = False +smote_method = auto +smote_sampling_strategy = auto +smote_k_neighbors = 5 + +[p3] +learner_id = pca +learner_params = {} +feature_namespace = FL_PCA +keep_original_features = True +overwrite_cv = True + +[p4] +models = mutualinformation,multiswrfdb +models_params = {'mutualinformation': {'outcome_type': 'Multiclass'}, 'multiswrfdb': {'n_jobs': 1}} +top_k = None +threshold = None +keep_original_features = False +overwrite_cv = True +instance_subset = 1000 + +[p5] +algorithms = auto +n_splits = 3 +max_features_to_keep = 2000 +filter_poor_features = True +overwrite_cv = False +selector_id = default +selector_params = {} +export_scores = True +top_features = 20 +show_plots = False +strict_discovery = False + +[p6] +outcome_type = Multiclass +model_type = None +models = NB,LR,DT +model_params_json = None +calibrate = False +calibrate_method = sigmoid +calibrate_cv = 5 +scoring_metric = balanced_accuracy +metric_direction = maximize +n_trials = 200 +timeout = 900 +training_subsample = 0 +uniform_fi = False +save_plot = False +bypass_one_hot_for_native_models = False +native_categorical_models = CGB,ExSTraCS + +[p7] +ensembles = hard_voting,soft_voting,stack_lr +base_models = NB,LR,DT +meta_train_source = train +calibrate = 0 +calibrate_method = sigmoid +calibrate_cv = 5 + +[p8] +scoring_metric = balanced_accuracy +metric_weight = balanced_accuracy +top_features = 40 +sig_cutoff = 0.05 +scale_data = True +exclude_plots = None +show_plots = False +include_ensembles = True +multiclass_average = micro + +[p9] +sig_cutoff = 0.05 +show_plots = False + +[p10] +rep_data_path = data/UCIRepMulticlassClassification +dataset_for_rep = data/UCIMulticlassClassification/student_dropout_academic_success.csv +match_label = None +exclude_plots = None +show_plots = False + +[p11] +report_modes = standard,replication +reporting_dir = None +outcome_label = Class +outcome_type = Multiclass +instance_label = InstanceID +make_pdf = True +enable_plots = True +reuse_existing_figures = True diff --git a/run_configs/uci_regression_auto_mpg.cfg b/run_configs/uci_regression_auto_mpg.cfg new file mode 100644 index 00000000..15c709dc --- /dev/null +++ b/run_configs/uci_regression_auto_mpg.cfg @@ -0,0 +1,156 @@ +[run] +output_path = out +experiment_name = UCIAutoMPGPipeline +outcome_label = MPG +outcome_type = Continuous +instance_label = InstanceID +n_splits = 3 +# Options: Serial, Local (Dask), Parallel (joblib), BashSLURM, BashLSF, or a named Dask cluster. +run_cluster = Serial +queue = defq +reserved_memory = 4 +random_state = 42 + +[phases] +phase_order = p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11 +do_p1 = True +do_p2 = True +do_p3 = True +do_p4 = True +do_p5 = True +do_p6 = True +do_p7 = False +do_p8 = True +do_p9 = True +do_p10 = True +do_p11 = True + +[p1] +data_path = data/UCIRegression +exclude_eda_output = None +match_label = None +ignore_features = None +categorical_features = data/UCIFeatureTypes/auto_mpg_categorical_features.csv +quantitative_features = data/UCIFeatureTypes/auto_mpg_quantitative_features.csv +top_features = 20 +categorical_cutoff = 10 +sig_cutoff = 0.05 +featureeng_missingness = 0.5 +cleaning_missingness = 0.5 +correlation_removal_threshold = 1.0 +partition_method = Random +show_plots = False +one_hot_encoding = True +cv_provided = False +cv_input_root = None +enable_plots = False +plot_missingness = False +plot_class_counts = False +plot_correlation = False +correlation_plot_max_features = 200 +plot_univariate = False +univariate_top_k = 20 +plot_anomalies = False +force = True + +[p2] +scale_data = True +impute_data = True +multi_impute = False +overwrite_cv = True +imputer_id = None +imputer_params = {} +scaler_id = None +scaler_params = {} +smote = False +smote_method = auto +smote_sampling_strategy = auto +smote_k_neighbors = 5 + +[p3] +learner_id = pca +learner_params = {} +feature_namespace = FL_PCA +keep_original_features = True +overwrite_cv = True + +[p4] +models = mutualinformation,multiswrfdb +models_params = {'mutualinformation': {'outcome_type': 'Continuous'}, 'multiswrfdb': {'n_jobs': 1}} +top_k = None +threshold = None +keep_original_features = False +overwrite_cv = True +instance_subset = None + +[p5] +algorithms = auto +n_splits = 3 +max_features_to_keep = 2000 +filter_poor_features = True +overwrite_cv = False +selector_id = default +selector_params = {} +export_scores = True +top_features = 20 +show_plots = False +strict_discovery = False + +[p6] +outcome_type = Continuous +model_type = None +models = LR,RF +model_params_json = None +calibrate = False +calibrate_method = sigmoid +calibrate_cv = 5 +scoring_metric = explained_variance +metric_direction = maximize +n_trials = 200 +timeout = 900 +training_subsample = 0 +uniform_fi = False +save_plot = False +bypass_one_hot_for_native_models = False +native_categorical_models = CGB,ExSTraCS + +[p7] +enabled = False +ensembles = hard_voting,soft_voting,stack_lr +base_models = LR,RF +meta_train_source = train +calibrate = 0 +calibrate_method = sigmoid +calibrate_cv = 5 + +[p8] +scoring_metric = explained_variance +metric_weight = explained_variance +top_features = 40 +sig_cutoff = 0.05 +scale_data = True +exclude_plots = None +show_plots = False +include_ensembles = False +multiclass_average = micro + +[p9] +sig_cutoff = 0.05 +show_plots = False + +[p10] +rep_data_path = data/UCIRepRegression +dataset_for_rep = data/UCIRegression/auto_mpg.csv +match_label = None +exclude_plots = None +show_plots = False + +[p11] +report_modes = standard,replication +reporting_dir = None +outcome_label = MPG +outcome_type = Continuous +instance_label = InstanceID +make_pdf = True +enable_plots = True +reuse_existing_figures = True diff --git a/run_configs/upenn.cfg b/run_configs/upenn.cfg deleted file mode 100644 index d90e031a..00000000 --- a/run_configs/upenn.cfg +++ /dev/null @@ -1,111 +0,0 @@ -[essential run parameters - preset for included demonstration datasets - phases 1-9] -dataset_path = './data/DemoData' -output_path = 'DemoOutput' -experiment_name = 'demo_experiment' -class_label = 'Class' -instance_label = 'InstanceID' -match_label = None -ignore_features_path = None -categorical_feature_path = ['Gender','Symptoms','Alcohol','Hepatitis B Surface Antigen','Hepatitis B e Antigen','Hepatitis B Core Antibody','Hepatitis C Virus Antibody','Cirrhosis', - 'Endemic Countries','Smoking','Diabetes','Obesity','Hemochromatosis','Arterial Hypertension','Chronic Renal Insufficiency','Human Immunodeficiency Virus', - 'Nonalcoholic Steatohepatitis','Esophageal Varices','Splenomegaly','Portal Hypertension','Portal Vein Thrombosis','Liver Metastasis','Radiological Hallmark', - 'Sim_Cat_2','Sim_Cat_3','Sim_Cat_4','Sim_Text_Cat_2','Sim_Text_Cat_3','Sim_Text_Cat_4','Invariant_Val','Invariant_NA','Invariant_Val_NA'] -quantitative_feature_path = ['Age at diagnosis','Grams of Alcohol per day','Packs of cigarets per year', 'Performance Status*', 'Encephalopathy degree*','Ascites degree*', - 'International Normalised Ratio*','Alpha-Fetoprotein (ng/mL)','Haemoglobin (g/dL)','Mean Corpuscular Volume', 'Leukocytes(G/L)', - 'Platelets','Albumin (mg/dL)','Total Bilirubin(mg/dL)','Alanine transaminase (U/L)','Aspartate transaminase (U/L)','Gamma glutamyl transferase (U/L)', - 'Alkaline phosphatase (U/L)', 'Total Proteins (g/dL)', 'Creatinine (mg/dL)','Number of Nodules','Major dimension of nodule (cm)','Direct Bilirubin (mg/dL)', - 'Iron', 'Oxygen Saturation (%%)','Ferritin (ng/mL)','Sim_Miss_0.6','Sim_Miss_0.7','Sim_Cor_-1.0_A','Sim_Cor_-1.0_B','Sim_Cor_0.9_A', 'Sim_Cor_0.9_B', - 'Sim_Cor_1.0_A','Sim_Cor_1.0_B'] -rep_data_path = './data/DemoRepData' -dataset_for_rep = './data/DemoData/hcc_data_custom.csv' - -[essential run parameters - phases to run - phases 1-9] -# If True, automatically runs all phases below up until and including do_report, automatically running 'compare_dataset' only if multiple target datasets included -do_till_report = True - -# Individual phases (do_report and do_rep_report are both part of phase 9) -do_eda = False -do_dataprep = False -do_feat_imp = False -do_feat_sel = False -do_model = False -do_stats = False -do_compare_dataset = False -do_report = False -do_replicate = True -do_rep_report = True -do_cleanup = True - -[general - phase 1] -cv_partitions = 3 -partition_method = 'Stratified' -categorical_cutoff = 10 -sig_cutoff = 0.05 -random_state = 42 - -[data processing - phase 1] -exclude_eda_output = None -top_uni_features = 40 -featureeng_missingness = 0.5 -cleaning_missingness = 0.5 -correlation_removal_threshold = 1.0 - -[imputing and scaling - phase 2] -impute_data = True -scale_data = True -multi_impute = True -overwrite_cv = False - -[feature importance estimation - phase 3] -do_mutual_info = True -do_multisurf = True -use_turf = False -turf_pct = 0.5 -instance_subset = 2000 -n_jobs = 1 - -[feature selection - phase 4] -filter_poor_features = True -max_features_to_keep = 2000 -export_scores = True -top_fi_features = 40 -overwrite_cv_feat = True - -[modeling - phase 5] -algorithms = ['LR', 'NB', 'DT'] -exclude = ['eLCS', 'XCS'] -training_subsample = 0 -use_uniform_fi = True -primary_metric = 'balanced_accuracy' -metric_direction = 'maximize' -n_trials = 200 -timeout = 900 -export_hyper_sweep_plots = False -do_lcs_sweep = False -lcs_nu = 1 -lcs_iterations = 200000 -lcs_n = 2000 -lcs_timeout = 1200 -model_resubmit = False - -[post-analysis - phase 6] -exclude_plots = None -metric_weight = 'balanced_accuracy' -top_model_fi_features = 40 - -[replication - phase 8] -exclude_rep_plots = None - -[cleanup] -del_time = False -del_old_cv = False - -[multiprocessing] -run_parallel = True -run_cluster = "LSF" -reserved_memory = 4 -queue = 'i2c2_normal' - -[logging] -logging_level = 'INFO' -verbose = False diff --git a/sample_runcommands.txt b/sample_runcommands.txt new file mode 100644 index 00000000..ca73c6e3 --- /dev/null +++ b/sample_runcommands.txt @@ -0,0 +1,452 @@ +# ---------------------------------------------------------- +# STREAMLINE SAMPLE RUN COMMANDS +# ---------------------------------------------------------- +# +# This file gives example command-line workflows for the current +# refactored STREAMLINE pipeline (P1-P11). +# +# Notes: +# - Commands below are examples, not the only valid configuration. +# - Replace `out` and experiment names with your own paths as needed. +# - Some phases accept metadata defaults when labels / types are omitted. +# - Reporting can be run in standard mode or replication mode. +# - Replication requires that phases 1-9 have already completed. +# - Phase 7 ensembles are classification-only; skip Phase 7 for regression. +# +# Demo data included in this repository: +# - Binary classification: data/UCIBinaryClassification +# - Multiclass classification: data/UCIMulticlassClassification +# - Regression: data/UCIRegression +# - Replication: data/UCIRepBinaryClassification, data/UCIRepMulticlassClassification, data/UCIRepRegression +# ---------------------------------------------------------- + + +# ========================================================== +# 0. Config-driven full pipeline examples +# ========================================================== +# These run the same P1-P11 runner classes used by the phase +# commands below, with shared and phase-specific arguments loaded +# from editable .cfg files. Use --dry_run first to inspect resolved calls. + +python run.py \ + -c run_configs/uci_binary_hcc.cfg \ + --dry_run + +python run.py \ + -c run_configs/uci_binary_hcc.cfg + +python run.py \ + -c run_configs/uci_multiclass_student.cfg + +python run.py \ + -c run_configs/uci_regression_auto_mpg.cfg + +# Useful partial-run controls: +python run.py \ + -c run_configs/uci_binary_hcc.cfg \ + --start_at p4 + +python run.py \ + -c run_configs/uci_binary_hcc.cfg \ + --stop_after p8 + +python run.py \ + -c run_configs/uci_binary_hcc.cfg \ + --only p6,p8,p11 + +python run.py \ + -c run_configs/uci_binary_hcc.cfg \ + --skip p3,p4 + + +# ========================================================== +# 1. Optional discovery commands +# ========================================================== + +python -m streamline.p2_impute_scale.p2_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --list-imputers + +python -m streamline.p2_impute_scale.p2_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --list-scalers + +python -m streamline.p3_feature_learning.p3_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --list-learners + +python -m streamline.p4_feature_importance.p4_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --list-models + +python -m streamline.p6_modeling.p6_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --outcome_type Binary \ + --list_models + +python -m streamline.p7_ensembles.p7_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --n_splits 5 \ + --list_ensembles + + +# ========================================================== +# 2. Classification workflow example +# ========================================================== +# Demo input folder: +# data/UCIBinaryClassification +# Example experiment output: +# out/DemoBinary + + +# ---------------------- +# Phase 1 - Data Process +# ---------------------- +python -m streamline.p1_data_process.p1_cli \ + --data_path data/UCIBinaryClassification \ + --output_path out \ + --experiment_name DemoBinary \ + --outcome_label Class \ + --outcome_type Binary \ + --instance_label InstanceID \ + --categorical_features data/UCIFeatureTypes/hcc_survival_categorical_features.csv \ + --quantitative_features data/UCIFeatureTypes/hcc_survival_quantitative_features.csv \ + --n_splits 5 \ + --top_features 20 \ + --sig_cutoff 0.05 \ + --force true + + +# ---------------------------- +# Phase 2 - Impute and Scale +# ---------------------------- +python -m streamline.p2_impute_scale.p2_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --random_state 42 + +# Optional: enable post-imputation/scaling SMOTE on training folds only. +# `auto` uses SMOTENC when processed categorical features are present, otherwise SMOTE. +# python -m streamline.p2_impute_scale.p2_cli \ +# --output_path out \ +# --experiment_name DemoBinary \ +# --smote 1 \ +# --smote_method auto \ +# --random_state 42 + + +# ---------------------------- +# Phase 3 - Feature Learning +# ---------------------------- +python -m streamline.p3_feature_learning.p3_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --learner_id pca \ + --learner_params '{}' \ + --keep_original_features true \ + --random_state 42 + + +# -------------------------------- +# Phase 4 - Feature Importance +# -------------------------------- +python -m streamline.p4_feature_importance.p4_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --models "mutualinformation,multiswrfdb,multiswrfdbstar" \ + --models_params '{"mutualinformation":{"outcome_type":"Binary"},"multiswrfdb":{"n_jobs":1},"multiswrfdbstar":{"n_jobs":1}}' \ + --random_state 42 + + +# --------------------------------- +# Phase 5 - Feature Selection +# --------------------------------- +python -m streamline.p5_feature_selection.p5_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --algorithms auto \ + --n_splits 5 \ + --selector_id default \ + --top_features 20 \ + --show_plots 0 + + +# ---------------------- +# Phase 6 - Modeling +# ---------------------- +python -m streamline.p6_modeling.p6_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --outcome_label Class \ + --outcome_type Binary \ + --instance_label InstanceID \ + --n_splits 5 \ + --models NB,LR,DT \ + --calibrate 1 \ + --calibrate_method sigmoid \ + --calibrate_cv 5 \ + --scoring_metric balanced_accuracy \ + --metric_direction maximize \ + --n_trials 200 \ + --timeout 900 \ + --training_subsample 0 \ + --uniform_fi 0 \ + --save_plot 0 \ + --random_state 42 \ + --run_cluster Serial + + +# ------------------------ +# Phase 7 - Ensembles +# ------------------------ +python -m streamline.p7_ensembles.p7_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --n_splits 5 \ + --outcome_label Class \ + --instance_label InstanceID \ + --ensembles hard_voting,soft_voting,stack_lr \ + --base_models NB,LR,DT \ + --meta_train_source train \ + --calibrate 0 \ + --random_state 42 + + +# --------------------------- +# Phase 8 - Summary Statistics +# --------------------------- +python -m streamline.p8_summary_statistics.p8_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --outcome_label Class \ + --outcome_type Binary \ + --instance_label InstanceID \ + --n_splits 5 \ + --scoring_metric balanced_accuracy \ + --metric_weight balanced_accuracy \ + --top_features 40 \ + --sig_cutoff 0.05 \ + --scale_data 1 \ + --show_plots 0 \ + --include_ensembles 1 + + +# --------------------------------------- +# Phase 9 - Dataset Comparison +# --------------------------------------- +python -m streamline.p9_compare_datasets.p9_cli \ + --output_path out \ + --experiment_name DemoBinary \ + --outcome_label Class \ + --outcome_type Binary \ + --instance_label InstanceID \ + --sig_cutoff 0.05 \ + --show_plots 0 + + +# --------------------------------------- +# Phase 10 - Replication / External Validation +# --------------------------------------- +# Reuses the trained workflow from: +# data/UCIBinaryClassification/hcc_survival.csv +# Applies it to replication datasets under: +# data/UCIRepBinaryClassification +python -m streamline.p10_replication.p10_cli \ + --rep_data_path data/UCIRepBinaryClassification \ + --dataset_for_rep data/UCIBinaryClassification/hcc_survival.csv \ + --output_path out \ + --experiment_name DemoBinary \ + --show_plots 0 + + +# --------------------------------------- +# Phase 11 - Reporting (standard datasets) +# --------------------------------------- +python -m streamline.p11_reporting.p11_cli \ + --experiment_path out/DemoBinary \ + --report_mode standard \ + --make_pdf 1 \ + --enable_plots 1 \ + --reuse_existing_figures 1 + + +# --------------------------------------- +# Phase 11 - Reporting (replication datasets) +# --------------------------------------- +python -m streamline.p11_reporting.p11_cli \ + --experiment_path out/DemoBinary \ + --report_mode replication \ + --make_pdf 1 \ + --enable_plots 1 \ + --reuse_existing_figures 1 + + +# ========================================================== +# 3. Regression workflow example +# ========================================================== +# Demo input folder: +# data/UCIRegression +# Example experiment output: +# out/DemoRegression + + +# ---------------------- +# Phase 1 - Data Process +# ---------------------- +python -m streamline.p1_data_process.p1_cli \ + --data_path data/UCIRegression \ + --output_path out \ + --experiment_name DemoRegression \ + --outcome_label MPG \ + --outcome_type Continuous \ + --instance_label InstanceID \ + --categorical_features data/UCIFeatureTypes/auto_mpg_categorical_features.csv \ + --quantitative_features data/UCIFeatureTypes/auto_mpg_quantitative_features.csv \ + --n_splits 5 \ + --partition_method Random \ + --top_features 20 \ + --sig_cutoff 0.05 \ + --force true + + +# ---------------------------- +# Phase 2 - Impute and Scale +# ---------------------------- +python -m streamline.p2_impute_scale.p2_cli \ + --output_path out \ + --experiment_name DemoRegression \ + --random_state 42 + + +# ---------------------------- +# Phase 3 - Feature Learning +# ---------------------------- +python -m streamline.p3_feature_learning.p3_cli \ + --output_path out \ + --experiment_name DemoRegression \ + --learner_id pca \ + --learner_params '{}' \ + --keep_original_features true \ + --random_state 42 + + +# -------------------------------- +# Phase 4 - Feature Importance +# -------------------------------- +python -m streamline.p4_feature_importance.p4_cli \ + --output_path out \ + --experiment_name DemoRegression \ + --models "mutualinformation,multiswrfdb,multiswrfdbstar" \ + --models_params '{"mutualinformation":{"outcome_type":"Continuous"},"multiswrfdb":{"n_jobs":1},"multiswrfdbstar":{"n_jobs":1}}' \ + --outcome_type Continuous \ + --random_state 42 + + +# --------------------------------- +# Phase 5 - Feature Selection +# --------------------------------- +python -m streamline.p5_feature_selection.p5_cli \ + --output_path out \ + --experiment_name DemoRegression \ + --algorithms auto \ + --n_splits 5 \ + --selector_id default \ + --top_features 20 \ + --show_plots 0 + + +# ---------------------- +# Phase 6 - Modeling +# ---------------------- +python -m streamline.p6_modeling.p6_cli \ + --output_path out \ + --experiment_name DemoRegression \ + --outcome_label MPG \ + --outcome_type Continuous \ + --instance_label InstanceID \ + --n_splits 5 \ + --models LR,RF \ + --scoring_metric explained_variance \ + --metric_direction maximize \ + --n_trials 200 \ + --timeout 900 \ + --training_subsample 0 \ + --uniform_fi 0 \ + --save_plot 0 \ + --random_state 42 \ + --run_cluster Serial + + +# Phase 7 is intentionally skipped for regression because ensembles are +# currently classification-only. + + +# --------------------------- +# Phase 8 - Summary Statistics +# --------------------------- +python -m streamline.p8_summary_statistics.p8_cli \ + --output_path out \ + --experiment_name DemoRegression \ + --outcome_label MPG \ + --outcome_type Continuous \ + --instance_label InstanceID \ + --n_splits 5 \ + --scoring_metric explained_variance \ + --metric_weight explained_variance \ + --top_features 40 \ + --sig_cutoff 0.05 \ + --scale_data 1 \ + --show_plots 0 \ + --include_ensembles 0 + + +# --------------------------------------- +# Phase 9 - Dataset Comparison +# --------------------------------------- +python -m streamline.p9_compare_datasets.p9_cli \ + --output_path out \ + --experiment_name DemoRegression \ + --outcome_label MPG \ + --outcome_type Continuous \ + --instance_label InstanceID \ + --sig_cutoff 0.05 \ + --show_plots 0 + + +# --------------------------------------- +# Phase 10 - Replication / External Validation +# --------------------------------------- +python -m streamline.p10_replication.p10_cli \ + --rep_data_path data/UCIRepRegression \ + --dataset_for_rep data/UCIRegression/auto_mpg.csv \ + --output_path out \ + --experiment_name DemoRegression \ + --show_plots 0 + + +# --------------------------------------- +# Phase 11 - Reporting (standard datasets) +# --------------------------------------- +python -m streamline.p11_reporting.p11_cli \ + --experiment_path out/DemoRegression \ + --report_mode standard \ + --make_pdf 1 \ + --enable_plots 1 \ + --reuse_existing_figures 1 + + +# --------------------------------------- +# Phase 11 - Reporting (replication datasets) +# --------------------------------------- +python -m streamline.p11_reporting.p11_cli \ + --experiment_path out/DemoRegression \ + --report_mode replication \ + --make_pdf 1 \ + --enable_plots 1 \ + --reuse_existing_figures 1 diff --git a/streamline/__init__.py b/streamline/__init__.py index b7520359..c948509a 100644 --- a/streamline/__init__.py +++ b/streamline/__init__.py @@ -1,8 +1,8 @@ """ Simple Transparent End-To-End Automated Machine Learning -Pipeline for Supervised Learning in Tabular Binary Classification Data +Pipeline for Supervised Learning in Tabular Classification and Regression Data """ -__version__ = "0.3.4" +__version__ = "1.0.0" __author__ = 'Harsh Bandhey and Ryan Urbanowicz' __credits__ = 'UrbsLabs' diff --git a/streamline/dataprep/data_process.py b/streamline/dataprep/data_process.py deleted file mode 100644 index 1a278c53..00000000 --- a/streamline/dataprep/data_process.py +++ /dev/null @@ -1,1038 +0,0 @@ -import csv -import os -import time -import pickle -import random -import logging -import numpy as np -import pandas as pd -import matplotlib.pyplot as plt - -from streamline.utils.job import Job -from streamline.utils.dataset import Dataset -from streamline.dataprep.kfold_partitioning import KFoldPartitioner -from scipy.stats import chi2_contingency, mannwhitneyu -import seaborn as sns - -sns.set_theme() - - -class DataProcess(Job): - """ - Exploratory Data Analysis Class for the EDA/Phase 1 step of STREAMLINE - """ - - def __init__(self, dataset, experiment_path, ignore_features=None, - categorical_features=None, quantitative_features=None, exclude_eda_output=None, - categorical_cutoff=10, sig_cutoff=0.05, featureeng_missingness=0.5, - cleaning_missingness=0.5, correlation_removal_threshold=1.0, - partition_method="Stratified", n_splits=10, - random_state=None, show_plots=False): - """ - Initialization function for Exploratory Data Analysis Class. Parameters are defined below. - - Args: - dataset: a streamline.utils.dataset.Dataset object or a path to dataset text file - experiment_path: path to experiment the logging directory folder - ignore_features: list of string of column names of features to ignore or \ - path to .csv file with feature labels to be ignored in analysis (default=None) - categorical_features: list of string of column names of features to ignore or \ - path to .csv file with feature labels specified to be treated as categorical where possible\ - (default=None) - categorical_cutoff: number of unique values for a variable is considered to be quantitative vs categorical\ - (default=10) - exclude_eda_output: list of names of analysis to do while doing EDA (must be in set X) - categorical_cutoff: categorical cut off to consider a feature categorical by analysis, default=10 - sig_cutoff: significance cutoff for continuous variables, default=0.05 - featureeng_missingness: the proportion of missing values within a feature (above which) a new - binary categorical feature is generated that indicates if the - value for an instance was missing or not - cleaning_missingness: the proportion of missing values, within a feature or instance, (at which) the - given feature or instance will be automatically cleaned (i.e. removed) - from the processed ‘target dataset’ - correlation_removal_threshold: the (pearson) feature correlation at which one out of a pair of - features is randomly removed from the processed ‘target dataset’ - random_state: random state to set seeds for reproducibility of algorithms - """ - super().__init__() - if type(dataset) != Dataset: - raise (Exception("dataset input is not of type Dataset")) - self.dataset = dataset - self.dataset_path = dataset.path - self.experiment_path = experiment_path - self.random_state = random_state - - known_exclude_options = ['describe_csv', 'univariate_plots', 'correlation_plots'] - - explorations_list = ["Describe", "Univariate Analysis", "Feature Correlation"] - plot_list = ["Describe", "Univariate Analysis", "Feature Correlation"] - - if exclude_eda_output is not None: - for x in exclude_eda_output: - if x not in known_exclude_options: - logging.warning("Unknown EDA exclusion option " + str(x)) - if 'describe_csv' in exclude_eda_output: - explorations_list.remove("Describe") - plot_list.remove("Describe") - if 'univariate_plots' in exclude_eda_output: - plot_list.remove("Univariate Analysis") - if 'correlation_plots' in exclude_eda_output: - plot_list.remove("Feature Correlation") - - for item in plot_list: - if item not in explorations_list: - logging.warning("Notice: Need to run analysis before plotting a result," - + item + " plot will be skipped") - - # Set up ignore_features: Allows user to specify features that should be ignored. - if ignore_features is None: - self.ignore_features = [] - elif type(ignore_features) == str: - ignore_features = pd.read_csv(ignore_features, sep=',') - self.ignore_features = list(ignore_features) - elif type(ignore_features) == list: - self.ignore_features = ignore_features - else: - raise Exception - - # Allows user to specify features that should be treated as categorical whenever possible, - # rather than relying on pipelines automated strategy for distinguishing categorical vs. - # quantitative features using the categorical_cutoff parameter. - if categorical_features is None: - self.specified_categorical = None # List of feature names specified by user to be treated as categorical - elif type(categorical_features) == str and not categorical_features == '': - categorical_features = pd.read_csv(categorical_features, sep=',') - self.specified_categorical = list(categorical_features) - elif type(categorical_features) == list: - self.specified_categorical = list(categorical_features) - elif categorical_features == '': - self.specified_categorical = None - else: - raise Exception - if quantitative_features is None: - self.specified_quantitative = None # List of feature names specified by user to be treated as quantitative - elif type(quantitative_features) == str and not quantitative_features == '': - quantitative_features = pd.read_csv(quantitative_features, sep=',') - self.specified_quantitative = list(quantitative_features) - elif type(quantitative_features) == list: - self.specified_quantitative = list(quantitative_features) - elif quantitative_features == '': - self.specified_quantitative = None - else: - raise Exception - - self.quantitative_features = [] # List of feature names in dataset to be treated as quantitative - self.categorical_features = [] # List of feature names in dataset to be treated as categorical - - self.engineered_features = list() - self.one_hot_features = list() - self.categorical_cutoff = categorical_cutoff - self.featureeng_missingness = featureeng_missingness - self.cleaning_missingness = cleaning_missingness - self.correlation_removal_threshold = correlation_removal_threshold - self.sig_cutoff = sig_cutoff - self.show_plots = show_plots - - self.explorations = explorations_list - self.plots = plot_list - - self.cv_partitioner = None - self.partition_method = partition_method - self.n_splits = n_splits - - def run(self, top_features=20): - """ - Wrapper function to run_explore and KFoldPartitioner - - Args: - top_features: no of top features to consider (default=20) - - """ - self.job_start_time = time.time() - - # Conduct Exploratory Analysis, Data Cleaning, and Feature Engineering - self.run_process(top_features) - - # Conduct k-fold partitioning and generate CV datasets - self.cv_partitioner = KFoldPartitioner(self.dataset, self.partition_method, - self.experiment_path, self.n_splits, self.random_state) - self.cv_partitioner.run() - self.save_runtime() - - def run_process(self, top_features=20): - """ - Run Exploratory Data Process accordingly on the EDA Object - - Args: - top_features: no of top features to consider (default=20) - """ - # Random seed for reproducibility - random.seed(self.random_state) - np.random.seed(self.random_state) - - # Make analysis folder for target dataset and a folder for the respective exploratory analysis within it - self.make_log_folders() - - # Account for possibility that only one dataset in folder has a match label. - # Check for presence of match label (this allows multiple datasets to be analyzed - # in the pipeline where not all of them have match labels if specified) - if (self.dataset.match_label is None) or (self.dataset.match_label not in self.dataset.data.columns): - self.dataset.match_label = None - self.partition_method = 'Stratified' - logging.warning("Warning: Specified 'Match label' could not be found in dataset. " - "Analysis moving forward assuming there is no 'match label' column using " - "stratified (S) CV partitioning.") - - # Pass user defined lists of categorical and quantitative features to dataset object - # self.dataset.categorical_variables = self.categorical_features - # self.dataset.quantitative_variables = self.quantitative_features - - # Identify and save feature types (i.e. categorical vs. quantitative) - self.identify_feature_types() # Completed - - # Run initial EDA from the Dataset Class - logging.info("Running Initial EDA:") - self.dataset.initial_eda(self.experiment_path) - - # Running all data manipulation steps: cleaning and feature engineering - self.data_manipulation() - - # Running EDA after all data manipulation - self.second_eda(top_features) - - def make_log_folders(self): - """ - Makes folders for logging exploratory data analysis - """ - if not os.path.exists(self.experiment_path + '/' + self.dataset.name): - os.makedirs(self.experiment_path + '/' + self.dataset.name) - if not os.path.exists(self.experiment_path + '/' + self.dataset.name + '/exploratory'): - os.makedirs(self.experiment_path + '/' + self.dataset.name + '/exploratory') - if not os.path.exists(self.experiment_path + '/' + self.dataset.name + '/exploratory/initial'): - os.makedirs(self.experiment_path + '/' + self.dataset.name + '/exploratory/initial') - - def identify_feature_types(self, x_data=None): - """ - Automatically identify categorical vs. quantitative features/variables - Takes a dataframe (of independent variables) with column labels and - returns a list of column names identified as - being categorical based on user defined cutoff (categorical_cutoff). - """ - # Validate and Identify categorical variables in dataset - logging.info("Validating and Identifying Feature Types...") - - # Strip whitespace off user-specified feature names for consistency with dataset loading - if self.specified_categorical is not None: - self.specified_categorical = [s.strip() for s in self.specified_categorical] - if self.specified_quantitative is not None: - self.specified_quantitative = [s.strip() for s in self.specified_quantitative] - logging.debug("spec cat: " + str(self.specified_categorical)) # Testing - logging.debug("spec quant: " + str(self.specified_quantitative)) # Testing - # Quality control of user-specified feature lists: duplicates check and warnings - if self.specified_quantitative is not None and self.specified_categorical is not None: - duplicates = list(set(self.specified_categorical) & set(self.specified_quantitative)) - if len(duplicates) > 0: - raise Exception( - "Following feature(s) assigned by user as both categorical and quantitative:" + str(duplicates)) - logging.warning( - "User specified both categorical vs quantitative features; any unspecified binary features will be " - "treated as categorical, and any remaining features will have their feature types automatically " - "assigned based on categorical_cutoff parameter") - if self.specified_quantitative is None and self.specified_categorical is None: - logging.warning( - "User did not specify categorical vs quantitative features; feature types will be automatically " - "assigned based on categorical_cutoff parameter") - - # Get feature data - if x_data is None: - x_data = self.dataset.feature_only_data() - - # Quality control of user-specified feature lists: remove specified features not in target dataset - headers = list(x_data.columns) # Get feature names included in target dataset - logging.debug("data features: " + str(headers)) # TESTING - cat_not_in_data = [] - quant_not_in_data = [] - if self.specified_categorical is not None: - cat_not_in_data = list(set(self.specified_categorical) - set(headers)) - for feat in cat_not_in_data: - self.specified_categorical.remove(feat) - if self.specified_quantitative is not None: - quant_not_in_data = list(set(self.specified_quantitative) - set(headers)) - for feat in quant_not_in_data: - self.specified_quantitative.remove(feat) - # Since some datasets might be very large, report this warning as a summary - if len(cat_not_in_data) > 0: - logging.warning( - "Following features specified as categorical were not in target dataset: " + str(cat_not_in_data)) - if len(quant_not_in_data) > 0: - logging.warning( - "Following features specified as quantitative were not in target dataset: " + str(quant_not_in_data)) - logging.debug("cleaned spec cat: " + str(self.specified_categorical)) # Testing - logging.debug("cleaned spec quant: " + str(self.specified_quantitative)) # Testing - - # Assign all binary features categorical list - quant_to_cat = [] - unassigned_to_cat = [] - - binary_categoricals_dict = dict() - - for each in x_data: - unique_vals = list(x_data[each].unique()) - unique_vals = [x for x in unique_vals if not pd.isnull(x)] - if len(unique_vals) == 2: - if str(x_data[each].dtype) != 'object': - binary_categoricals_dict[each] = list(unique_vals) - self.categorical_features.append(each) - if self.specified_quantitative is not None and each in self.specified_quantitative: - quant_to_cat.append(each) - self.specified_quantitative.remove(each) # update user specified list - if self.specified_categorical is not None and each not in self.specified_categorical: - unassigned_to_cat.append(each) - if self.specified_categorical is not None and each in self.specified_categorical: - self.specified_categorical.remove(each) # update user specified list - - logging.debug("binary cat: " + str(self.categorical_features)) # TESTING - - with open(self.experiment_path + '/' + self.dataset.name + - '/exploratory/binary_categorical_dict.pickle', 'wb') as outfile: - pickle.dump(binary_categoricals_dict, outfile) - - # Since some datasets might be very large, report this warning as a summary - if len(quant_to_cat) > 0: - logging.warning( - "Following binary feature(s) specified as quantitative, " - "but will be treated it as categorical: " + str(quant_to_cat)) - if len(unassigned_to_cat) > 0: - logging.warning( - "Following binary feature(s) were not in the categorical list, " - "but will be treated as categorical: " + str(unassigned_to_cat)) - - # Assign remaining user specified features as categorical or quantitative - if self.specified_categorical is not None and self.specified_quantitative is None: - logging.warning( - "No quantitative features specified; non-binary features not specified as categorical will be treated " - "as quantitative unless they are binary") - self.categorical_features = self.categorical_features + self.specified_categorical - self.quantitative_features = list(set(self.dataset.get_headers()) - set( - self.categorical_features)) # All other features assigned as quantitative - - if self.specified_quantitative is not None and self.specified_categorical is None: - logging.warning( - "No categorical features specified; features not specified as quantitative will be treated as " - "categorical") - self.quantitative_features = self.specified_quantitative - self.categorical_features = list(set(self.dataset.get_headers()) - set(self.quantitative_features)) - - if self.specified_quantitative is not None and self.specified_categorical is not None: # both lists specified - self.quantitative_features = self.specified_quantitative - self.categorical_features = self.categorical_features + self.specified_categorical - logging.debug("assigned cat: " + str(self.categorical_features)) # TESTING - logging.debug("assigned quant: " + str(self.quantitative_features)) # TESTING - - # Any remaining unassigned features will be assigned to categorical or quantitative lists based on user - # specified categorical cutoff - for each in x_data: - if each not in self.categorical_features and each not in self.quantitative_features: - if x_data[each].nunique() <= self.categorical_cutoff or not pd.api.types.is_numeric_dtype(x_data[each]): - self.categorical_features.append(each) - else: - self.quantitative_features.append(each) - logging.debug("final cat: " + str(self.categorical_features)) # TESTING - logging.debug("final quant: " + str(self.quantitative_features)) # TESTING - - # Assign feature type lists to dataset object - self.dataset.categorical_variables = self.categorical_features - self.dataset.quantitative_variables = self.quantitative_features - - # Pickle feature type lists #Ryan - where/how do these get used? - with open(self.experiment_path + '/' + self.dataset.name + - '/exploratory/initial/initial_categorical_features.pickle', 'wb') as outfile: - pickle.dump(self.categorical_features, outfile) - with open(self.experiment_path + '/' + self.dataset.name + - '/exploratory/initial/initial_quantitative_features.pickle', 'wb') as outfile: - pickle.dump(self.quantitative_features, outfile) - - with open(self.experiment_path + '/' + self.dataset.name + - '/exploratory/initial/initial_categorical_features.csv', 'w') as outfile: - writer = csv.writer(outfile, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) - writer.writerow(self.categorical_features) - with open(self.experiment_path + '/' + self.dataset.name + - '/exploratory/initial/initial_quantitative_features.csv', 'w') as outfile: - writer = csv.writer(outfile, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) - writer.writerow(self.quantitative_features) - - return self.categorical_features, self.quantitative_features - - def data_manipulation(self): - """ - Wrapper function for all data cleaning and feature engineering data manipulation - """ - # Create features-only version of original dataset as .csv - self.dataset.set_original_headers(self.experiment_path) # Already Completed - - # Dataframe to record feature statistics - transition_df = pd.DataFrame(columns=['Instances', 'Total Features', - 'Categorical Features', - 'Quantitative Features', 'Missing Values', - 'Missing Percent', 'Class 0', 'Class 1']) - - transition_df.loc["Original"] = self.counts_summary(save=False) - - # ordinal encode the labels - self.label_encoder() - - # Dropping rows with missing target variable and users specified features to ignore - self.drop_ignored_rowcols() # Completed - transition_df.loc["C1"] = self.counts_summary(save=False) - - # Generating categorical features for features with missingness greater that featureeng_missingness percentage - self.feature_engineering() # Completed - transition_df.loc["E1"] = self.counts_summary(save=False) - - # Remove features with missingness greater than cleaning_missingness percentage - self.drop_invariant() # Completed - self.feature_removal() # Completed - transition_df.loc["C2"] = self.counts_summary(save=False) - - # Remove instances with more features missing greater than cleaning_missingness percentage - self.instance_removal() # Completed - transition_df.loc["C3"] = self.counts_summary(save=False) - - # Generated onehot categorical feature encoding - self.categorical_feature_encoding_pandas() - transition_df.loc["E2"] = self.counts_summary(save=False) - - # Drop highly correlated features with correlation greater that max_correlation - self.drop_highly_correlated_features() # Completed - transition_df.loc["C4"] = self.counts_summary(save=False) - - # Create features-only version of processed dataset and save as .csv - self.dataset.set_processed_headers(self.experiment_path) # Already Completed - - # Save Transition Summary of the data manipulation process - - transition_df.to_csv(self.experiment_path + '/' + self.dataset.name + '/exploratory/' - + 'DataProcessSummary.csv', index=True) - - # Pickle list of feature names to be treated as categorical variables - with open(self.experiment_path + '/' + self.dataset.name + - '/exploratory/categorical_features.pickle', 'wb') as outfile: - pickle.dump(self.categorical_features, outfile) - - # Pickle list of processed feature names - with open(self.experiment_path + '/' + self.dataset.name + - '/exploratory/post_processed_features.pickle', 'wb') as outfile: - pickle.dump(list(self.dataset.data.columns), outfile) - # with open(self.experiment_path + '/' + self.dataset.name + - # '/exploratory/ProcessedFeatureNames.csv', 'w') as outfile: - # writer = csv.writer(outfile, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) - # writer.writerow(list(self.dataset.data.columns)) - - def counts_summary(self, total_missing=None, plot=False, save=True, replicate=False): - """ - Reports various dataset counts: i.e. number of instances, total features, categorical features, quantitative - features, and class counts. Also saves a simple bar graph of class counts if user specified. - - Args: - save: - total_missing: total missing values (optional, runs again if not given) - plot: flag to output bar graph in the experiment log folder - replicate: - Returns: - - """ - # Calculate, print, and export instance and feature counts - f_count = self.dataset.data.shape[1] - 1 - if not (self.dataset.instance_label is None): - f_count -= 1 - if not (self.dataset.match_label is None): - f_count -= 1 - if total_missing is None: - total_missing = self.dataset.missingness_counts(self.experiment_path, save=False) - percent_missing = int(total_missing) / float(self.dataset.data.shape[0] * f_count) - # n_categorical_variables = len(list(self.categorical_features)) \ - # + len(list(self.engineered_features)) + len(list(self.one_hot_features)) - summary = [['instances', self.dataset.data.shape[0]], - ['features', f_count], - ['categorical_features', len(self.categorical_features)], - ['quantitative_features', len(self.quantitative_features)], - ['missing_values', total_missing], - ['missing_percent', round(percent_missing, 5)]] - - summary_df = pd.DataFrame(summary, columns=['Variable', 'Count']) - class_counts = self.dataset.data[self.dataset.class_label].value_counts() - - if save: - summary_df.to_csv(self.experiment_path + '/' + self.dataset.name + '/exploratory/' + 'DataCounts.csv', - index=False) - # Calculate, print, and export class counts - class_counts.to_csv(self.experiment_path + '/' + self.dataset.name + - '/exploratory/' + 'ClassCounts.csv', header=['Count'], - index_label='Class') - - logging.info('Processed Data Counts: ----------------') - logging.info('Instance Count = ' + str(self.dataset.data.shape[0])) - logging.info('Feature Count = ' + str(f_count)) - logging.info(' Categorical = ' + str(len(self.categorical_features))) - logging.info(' Quantitative = ' + str(len(self.quantitative_features))) - logging.info('Missing Count = ' + str(total_missing)) - logging.info(' Missing Percent = ' + str(percent_missing)) - logging.info('Class Counts: ----------------') - logging.info('Class Count Information') - df_value_counts = pd.DataFrame(class_counts) - df_value_counts = df_value_counts.reset_index() - df_value_counts.columns = ['Class', 'Instances'] - logging.info("\n" + df_value_counts.to_string()) - - if not replicate: - logging.info("Categorical Features: " + str(self.categorical_features)) - logging.info("\t Engineered Features: " + str(self.engineered_features)) - logging.info("\t One Hot Features: " + str(self.one_hot_features)) - logging.info("Quantitative Features: " + str(self.quantitative_features)) - logging.info("Final List of Features:") - logging.info(list(self.dataset.get_headers())) - else: - logging.info("Final List of Features:") - logging.info(list(self.dataset.get_headers())) - - # Generate and export class count bar graph - if plot: - class_counts.plot(kind='bar') - plt.ylabel('Count') - plt.title('Class Counts') - plt.savefig(self.experiment_path + '/' + self.dataset.name + '/exploratory/' + 'ClassCountsBarPlot.png', - bbox_inches='tight') - if self.show_plots: - plt.show() - else: - plt.close('all') - # plt.cla() # not required - return list(summary_df['Count']) + [class_counts[0], class_counts[1]] - - def label_encoder(self): - """ - Numerical Data Encoder: - for any features in the data (other than the instanceID, but including the class column) if the - feature (which should also be considered to be categorical - so check that feature is in the list of features - being treated as categorical, and if not add it to that list) has any non-numerical values, numerically encode - these values based on alphabetical order of the feature values. - As we do this we create a new output .csv file (called Numerical_Encoding_Map.csv), - where each row provides the feature that was numerically encoded, - and the subsequent columns provide a mapping of the original values to new numerical values. - """ - - string_type_columns = list() - dtypes_dict = self.dataset.data.dtypes.to_dict() - for feat, typ in dtypes_dict.items(): - if self.dataset.instance_label and feat == self.dataset.instance_label: - continue - if str(typ) == 'object': - string_type_columns.append(feat) - - ord_label = pd.DataFrame(columns=['Category', 'Encoding']) - if len(string_type_columns) > 0: - logging.info("Ordinal encoding the following features:") - for feat in string_type_columns: - if feat in self.quantitative_features \ - and not (feat == self.dataset.class_label or - (self.dataset.match_label and feat == self.dataset.match_label)): - raise Exception("Text values specified as quantitative, any text value features that need to be " - "treated as quantitative need to be numerically encoded by the user before " - "running STREAMLINE") - if feat not in self.categorical_features \ - and not (feat == self.dataset.class_label or - (self.dataset.match_label and feat == self.dataset.match_label)): - self.categorical_features.append(feat) - logging.warning("Textual Unknown Feature Added as Categorical") - - # Not encoding anything except class labels and binary text categorical variable - # to preserve label in figures - - if feat == self.dataset.class_label: - logging.info('\t' + feat) - self.dataset.data[feat], labels = pd.factorize(self.dataset.data[feat]) - ord_label.loc[feat] = [list(labels), list(range(len(labels)))] - elif self.dataset.data[feat].nunique() <= 2: - logging.info('\t' + feat) - self.dataset.data[feat], labels = pd.factorize(self.dataset.data[feat]) - ord_label.loc[feat] = [list(labels), list(range(len(labels)))] - else: - # Do we fake numerical encode a dataset? - # labels = pd.factorize(self.dataset.data[feat]) - # ord_label.loc[feat] = [list(labels), list(range(len(labels)))] - pass - - ord_label.to_csv(self.experiment_path + '/' + self.dataset.name + - '/exploratory/Numerical_Encoding_Map.csv') - - with open(self.experiment_path + '/' + self.dataset.name + - '/exploratory/ordinal_encoding.pickle', 'wb') as outfile: - pickle.dump(ord_label, outfile) - else: - logging.info("No textual categorical features, skipping label encoding") - - def drop_ignored_rowcols(self, ignored_features=None): - """ - Basic data cleaning: Drops any instances with a missing outcome - value as well as any features (ignore_features) specified by user - """ - # Remove features that are specified to be dropped - if ignored_features is None: - ignored_features = self.ignore_features - for feat in ignored_features: - if feat in self.categorical_features: - self.categorical_features.remove(feat) - if feat in self.quantitative_features: - self.quantitative_features.remove(feat) - self.dataset.clean_data(self.ignore_features) - - def drop_invariant(self): - """ - Basic data cleaning: Drops any invariant features found by pandas - """ - try: - invariant_columns = list(self.dataset.data.columns[self.dataset.data.nunique(dropna=True) <= 1]) - except Exception: - invariant_columns = [] - if invariant_columns: - logging.info("Dropping the following Invariant Columns:") - for feat in invariant_columns: - logging.info('\t' + feat) - if feat in self.categorical_features: - self.categorical_features.remove(feat) - if feat in self.quantitative_features: - self.quantitative_features.remove(feat) - if feat in self.engineered_features: - self.engineered_features.remove(feat) - if feat in self.one_hot_features: - self.one_hot_features.remove(feat) - self.dataset.data.drop(invariant_columns, axis=1, inplace=True) - - def feature_engineering(self): - """ - Feature Engineering - Missingness as a feature (missingness feature engineering phase) - - Using the used run parameter we define the minimum missingness of a variable at which - streamline will automatically engineer a new feature (i.e. 0 not missing vs. 1 missing). - - This parameter would have value of 0-1 and default of 0.5 meaning any feature with a - missingness of >50% will have a corresponding missingness feature added. - - This new feature would have the inserted label of “Miss_”+originalFeatureName. - The list of feature names for which a missingness feature was constructed - is saved in self.engineered_features. In the ‘apply’ phase, we use this feature list - to build similar new missingness features added to the replication dataset. - """ - - logging.info("Running Feature Engineering") - - # Calculating missingness for values in a feature - missingness = self.dataset.data.isnull().sum() / len(self.dataset.data) - - # Finding features with missingness greater than featureeng_missingness - high_missingness_features = missingness[missingness > self.featureeng_missingness] - high_missingness_features = list(high_missingness_features.index) - # self.high_missingness_features = high_missingness_features - self.engineered_features = ['Miss_' + feat for feat in high_missingness_features] - - # For each Feature with high missingness creating a categorical feature. - for feat in high_missingness_features: - self.dataset.data['Miss_' + feat] = self.dataset.data[feat].isnull().astype(int) - self.categorical_features.append('Miss_' + feat) - - if high_missingness_features: - logging.info("Engineering the following Features for missingness:") - for feat in high_missingness_features: - logging.info('\t Miss_' + feat) - - with open(self.experiment_path + '/' + self.dataset.name + - '/exploratory/engineered_features.pickle', 'wb') as outfile: - pickle.dump(high_missingness_features, outfile) - - with open(self.experiment_path + '/' + self.dataset.name + - '/exploratory/Missingness_Engineered_Features.csv', 'w') as outfile: - outfile.write("\n".join(self.engineered_features)) - else: - logging.info("No Features with high missingness found") - - def feature_removal(self): - original_features = self.dataset.get_headers() - self.dataset.data.dropna(thresh=int(self.dataset.data.shape[0] * self.cleaning_missingness) - 1, - axis=1, inplace=True) - new_features = self.dataset.get_headers() - removed_variables = [item for item in original_features if item not in new_features] - for feat in removed_variables: - if feat in self.categorical_features: - self.categorical_features.remove(feat) - if feat in self.engineered_features: - self.engineered_features.remove(feat) - if feat in self.one_hot_features: - self.one_hot_features.remove(feat) - if feat in self.quantitative_features: - self.quantitative_features.remove(feat) - - if removed_variables: - logging.info("Removing the following Features due to Missingness:") - for feat in removed_variables: - logging.info('\t' + feat) - with open(self.experiment_path + '/' + self.dataset.name + - '/exploratory/removed_features.pickle', 'wb') as outfile: - pickle.dump(removed_variables, outfile) - with open(self.experiment_path + '/' + self.dataset.name + - '/exploratory/Missingness_Feature_Cleaning.csv', 'w') as outfile: - outfile.write("\n".join(removed_variables)) - else: - logging.info("Not removing any features due to high missingness") - - def instance_removal(self): - """ - dropping instances with feature/columns missingness greater that cleaning missingness percentage - """ - f_count = self.dataset.data.shape[1] - 1 - if not (self.dataset.instance_label is None): - f_count -= 1 - if not (self.dataset.match_label is None): - f_count -= 1 - self.dataset.data = self.dataset.data[self.dataset.data.isnull().sum(axis=1) < - int(self.cleaning_missingness * f_count)] - - def categorical_feature_encoding(self): - """ - Categorical feature encoding using sklearn onehot encoder - not used/implemented - """ - # enc = OneHotEncoder(handle_unknown='ignore', drop='if_binary', sparse_output=False) - # enc.fit(self.dataset.feature_only_data(), self.dataset.data[self.dataset.class_label]) - # logging.warning(enc.categories_) - # feature_only_data = pd.DataFrame(enc.transform(self.dataset.feature_only_data()), - # columns=enc.categories_) - # label_data = self.dataset.non_feature_data() - # logging.warning(type(feature_only_data)) - # self.dataset.data = pd.concat([feature_only_data, label_data], axis=1) - # with open(self.experiment_path + '/' + self.dataset.name - # + '/exploratory/one_hot_encoder.pickle') as file: - # pickle.dump(enc, file) - raise NotImplementedError - - def categorical_feature_encoding_pandas(self): - """ - Categorical feature encoding using pandas get_dummies function - """ - # Identify non-binary categorical features to apply one-hot-encoding to - non_binary_categorical = list() - for feat in self.categorical_features: - if feat in self.dataset.data.columns: - if self.dataset.data[feat].nunique() > 2: - non_binary_categorical.append(feat) - - # Apply one-hot encoding - if len(non_binary_categorical) > 0: - logging.info("One-hot encoding the following features:") - for feat in non_binary_categorical: - logging.info('\t' + feat) - # Run one-hot encoding - one_hot_df = pd.get_dummies(self.dataset.data[non_binary_categorical], - columns=non_binary_categorical) - # Ryan - make it so all new features have same naming convention - self.one_hot_features = list(one_hot_df.columns) - # Remove original feature from dataset - self.dataset.data.drop(non_binary_categorical, axis=1, inplace=True) - # Add new one-hot-encoded features to the right columns of the dataset - self.dataset.data = pd.concat([self.dataset.data, one_hot_df], axis=1) - for feat in non_binary_categorical: - if feat in self.categorical_features: - self.categorical_features.remove(feat) - self.categorical_features += self.one_hot_features - - with open(self.experiment_path + '/' + self.dataset.name + - '/exploratory/one_hot_feature.pickle', 'wb') as outfile: - pickle.dump(self.one_hot_features, outfile) - else: - logging.info("No non-binary categorical features, skipping categorical encoding") - - def drop_highly_correlated_features(self): - # Ryan - if we are recalculating the correlation matrix this is - # wasted time since it was already calculated for initial correlation plot. - df_corr = self.dataset.feature_only_data().corr() - df_corr_org = df_corr.copy(deep=True) - - # calculate the correlation matrix and reshape - df_corr = df_corr.stack().reset_index() - - # rename the columns - df_corr.columns = ['Removed_Feature', 'Correlated_Feature', 'Correlation'] - - # create a mask to identify rows with duplicate features as mentioned above - mask_dups = (df_corr[['Removed_Feature', 'Correlated_Feature']].apply(frozenset, axis=1).duplicated()) | ( - df_corr['Removed_Feature'] == df_corr['Correlated_Feature']) - - # apply the mask to clean the correlation dataframe - df_corr = df_corr[~mask_dups] - - df_corr = df_corr.sort_values(by='Correlation', key=abs, ascending=False) - - logging.info('Top 10 Correlated Features') - logging.info("\n" + df_corr.head(10).to_string()) - - df_corr = df_corr[abs(df_corr['Correlation']) >= self.correlation_removal_threshold] - - features_to_drop = list(df_corr['Removed_Feature']) - - for feat in features_to_drop: - if feat not in self.dataset.data.columns: - features_to_drop.remove(feat) - - self.dataset.clean_data(features_to_drop) - - if len(features_to_drop) > 0: - logging.info("Removing the following Features due to high correlation:") - for feat in features_to_drop: - logging.info(feat) - for feat in features_to_drop: - if feat in self.categorical_features: - self.categorical_features.remove(feat) - if feat in self.engineered_features: - self.engineered_features.remove(feat) - if feat in self.one_hot_features: - self.one_hot_features.remove(feat) - if feat in self.quantitative_features: - self.quantitative_features.remove(feat) - - with open(self.experiment_path + '/' + self.dataset.name + - '/exploratory/correlated_features.pickle', 'wb') as outfile: - pickle.dump(features_to_drop, outfile) - - all_features = set(self.dataset.get_headers()) - features_kept = list(all_features - set(features_to_drop)) - - # logging.warning(df_corr_org.columns) - - with open(self.experiment_path + '/' + self.dataset.name + - '/exploratory/correlation_feature_cleaning.csv', 'w', newline='') as file: - writer = csv.writer(file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) - writer.writerow(['Retained Feature', 'Deleted Features', ]) - for feat in features_kept: - corr_feat = list(df_corr_org[abs(df_corr_org[feat]) >= self.correlation_removal_threshold].index) - corr_feat.remove(feat) - if len(corr_feat) != 0: - writer.writerow([feat, ] + corr_feat) - else: - logging.info("No Features with correlation higher that parameter") - - def second_eda(self, top_features=20): - # Running EDA after all the new data processing/manipulation - logging.info("Running Basic Exploratory Analysis...") - - # Describe and save description if user specified - if "Describe" in self.explorations: - self.dataset.describe_data(self.experiment_path) - total_missing = self.dataset.missingness_counts(self.experiment_path) - plot = False - if "Describe" in self.plots: - plot = True - self.dataset.missing_count_plot(self.experiment_path) - self.counts_summary(total_missing, plot) - - # Export feature correlation plot if user specified - if "Feature Correlation" in self.explorations: - logging.info("Generating Feature Correlation Heatmap...") - if "Feature Correlation" in self.plots: - plot = True - x_data = self.dataset.feature_only_data() - self.dataset.feature_correlation(self.experiment_path, x_data, plot=plot, show_plots=self.show_plots) - del x_data - - # Conduct uni-variate analyses of association between individual features and class - if "Univariate Analysis" in self.explorations: - logging.info("Running Univariate Analyses...") - sorted_p_list = self.univariate_analysis(top_features) - # Export uni-variate association plots (for significant features) if user specifies - if "Univariate Analysis" in self.plots: - logging.info("Generating Univariate Analysis Plots...") - self.univariate_plots(sorted_p_list) - - pd.DataFrame(self.categorical_features, columns=['Feature']).to_csv( - self.experiment_path + '/' + self.dataset.name + - '/exploratory/processed_categorical_features.csv', index=False) - pd.DataFrame(self.quantitative_features, columns=['Feature']).to_csv( - self.experiment_path + '/' + self.dataset.name + - '/exploratory/processed_quantitative_features.csv', index=False) - - def univariate_analysis(self, top_features=20): - """ - Calculates univariate association significance between each individual feature and class outcome. - Assumes categorical outcome using Chi-square test for - categorical features and Mann-Whitney Test for quantitative features. - - Args: - top_features: no of top features to show/consider - - """ - try: - # Try loop added to deal with versions specific change to using - # mannwhitneyu in scipy and avoid STREAMLINE crash in those circumstances. - # Create folder for univariate analysis results - if not os.path.exists(self.experiment_path + '/' + self.dataset.name - + '/exploratory/univariate_analyses'): - os.mkdir(self.experiment_path + '/' + self.dataset.name - + '/exploratory/univariate_analyses') - # Generate dictionary of p-values for each feature using appropriate test (via test_selector) - p_value_dict = {} - for column in self.dataset.data: - if column != self.dataset.class_label and column != self.dataset.instance_label: - p_value_dict[column] = self.test_selector(column) - - dict_items = list(p_value_dict.items()) - sorted_p_list = sorted(dict_items, key=lambda item: float(item[1][0])) - sorted_p_list = [(item[0], float(item[1][0])) for item in sorted_p_list] - # Save p-values to file - pval_df = pd.DataFrame.from_dict(p_value_dict, orient='index') - pval_df.to_csv( - self.experiment_path + '/' + self.dataset.name - + '/exploratory/univariate_analyses/Univariate_Significance.csv', - index_label='Feature', header=['p-value', 'Test-statistic', 'Test-name'], na_rep='NaN') - - # Print results for top features across univariate analyses - f_count = self.dataset.data.shape[1] - 1 - if not (self.dataset.instance_label is None): - f_count -= 1 - if not (self.dataset.match_label is None): - f_count -= 1 - - min_num = min(top_features, f_count) - sorted_p_list_temp = sorted_p_list[: min_num] - logging.info('Plotting top significant ' + str(min_num) + ' features.') - logging.info('###################################################') - logging.info('Significant Univariate Associations:') - for each in sorted_p_list_temp[:min_num]: - logging.info(each[0] + ": (p-val = " + str(each[1]) + ")") - - except Exception: - sorted_p_list = [] # won't actually be sorted - logging.warning('WARNING: Exploratory univariate analysis failed due to scipy package ' - 'version error when running mannwhitneyu test. ' - 'To fix, we recommend updating scipy to version 1.8.0 or greater ' - 'using: pip install --upgrade scipy') - for column in self.dataset.data: - if column != self.dataset.class_label and column != self.dataset.instance_label: - sorted_p_list.append([column, 'None']) - - return sorted_p_list - - def test_selector(self, feature_name): - """ - Selects and applies appropriate univariate association test for a given feature. Returns resulting p-value - - Args: - feature_name: name of feature column operation is running on - """ - # test_name, test_stat = None, None - class_label = self.dataset.class_label - # Feature and Outcome are discrete/categorical/binary - if feature_name in self.dataset.categorical_variables: - # Calculate Contingency Table - Counts - table_temp = pd.crosstab(self.dataset.data[feature_name], self.dataset.data[class_label]) - # Univariate association test (Chi Square Test of Independence - Non-parametric) - c, p, dof, expected = chi2_contingency(table_temp) - p_val = p - test_stat = c - test_name = "Chi Square Test" - # Feature is continuous and Outcome is discrete/categorical/binary - else: - # Univariate association test (Mann-Whitney Test - Non-parametric) - try: # works in scipy 1.5.0 - c, p = mannwhitneyu( - x=self.dataset.data[feature_name].loc[self.dataset.data[class_label] == 0], - y=self.dataset.data[feature_name].loc[self.dataset.data[class_label] == 1], nan_policy='omit') - except Exception as e: # for scipy 1.8.0 - logging.error(e) - raise Exception("Exception in scipy, must have scipy version>=1.8.0") - p_val = p - test_stat = c - test_name = "Mann-Whitney U Test" - return p_val, test_stat, test_name - - def univariate_plots(self, sorted_p_list=None, top_features=20): - """ - Checks whether p-value of each feature is less than or equal to significance cutoff. - If so, calls graph_selector to generate an appropriate plot. - - Args: - sorted_p_list: sorted list of p-values - top_features: no of top features to consider (default=20) - - """ - - if sorted_p_list is None: - sorted_p_list = self.univariate_analysis(top_features) - - for i in sorted_p_list: # each feature in sorted p-value dictionary - if i[1] == 'None': - pass - else: - for j in self.dataset.data: # each feature - if j == i[0] and i[1] <= self.sig_cutoff: # ONLY EXPORTS SIGNIFICANT FEATURES - self.graph_selector(j) - - def graph_selector(self, feature_name): - """ - Assuming a categorical class outcome, a - barplot is generated given a categorical feature, and a boxplot is generated given a quantitative feature. - - Args: - feature_name: feature name of the column the function is doing operation on - - """ - # Feature and Outcome are discrete/categorical/binary - if feature_name in self.dataset.categorical_variables: - # Generate contingency table count bar plot. - # Calculate Contingency Table - Counts - table = pd.crosstab(self.dataset.data[feature_name], self.dataset.data[self.dataset.class_label]) - geom_bar_data = pd.DataFrame(table) - geom_bar_data.plot(kind='bar') - plt.ylabel('Count') - else: - # Feature is continuous and Outcome is discrete/categorical/binary - # Generate boxplot - self.dataset.data.boxplot(column=feature_name, by=self.dataset.class_label) - plt.ylabel(feature_name) - plt.title('') - - # Deal with the dataset specific characters causing problems in this dataset. - if not os.path.exists(self.experiment_path + '/' + self.dataset.name - + '/exploratory/univariate_analyses/'): - os.makedirs(self.experiment_path + '/' + self.dataset.name - + '/exploratory/univariate_analyses/') - - new_feature_name = feature_name.replace(" ", "") - new_feature_name = new_feature_name.replace("*", "") - new_feature_name = new_feature_name.replace("/", "") - if feature_name in self.dataset.categorical_variables: - plt.savefig(self.experiment_path + '/' + self.dataset.name - + '/exploratory/univariate_analyses/' + 'Barplot_' + - str(new_feature_name) + ".png", bbox_inches="tight", format='png') - plt.close('all') - else: - plt.savefig(self.experiment_path + '/' + self.dataset.name - + '/exploratory/univariate_analyses/' + 'Boxplot_' + - str(new_feature_name) + ".png", bbox_inches="tight", format='png') - plt.close('all') - # plt.cla() # not required - - def save_runtime(self): - """ - Export runtime for this phase of the pipeline on current target dataset - """ - runtime = str(time.time() - self.job_start_time) - logging.log(0, "PHASE 1 Completed: Runtime=" + str(runtime)) - if not os.path.exists(self.experiment_path + '/' + self.dataset.name + '/runtime'): - os.mkdir(self.experiment_path + '/' + self.dataset.name + '/runtime') - runtime_file = open(self.experiment_path + '/' + self.dataset.name + '/runtime/runtime_exploratory.txt', 'w') - runtime_file.write(runtime) - runtime_file.close() - - def start(self, top_features=20): - self.run(top_features) - - def join(self): - pass diff --git a/streamline/dataprep/kfold_partitioning.py b/streamline/dataprep/kfold_partitioning.py deleted file mode 100644 index 5718d139..00000000 --- a/streamline/dataprep/kfold_partitioning.py +++ /dev/null @@ -1,148 +0,0 @@ -import os -import csv -from streamline.utils.job import Job -from streamline.utils.dataset import Dataset -from sklearn.model_selection import KFold, StratifiedKFold -from sklearn.model_selection import StratifiedGroupKFold - - -class KFoldPartitioner(Job): - """ - Base class for KFold CrossValidation Operations on dataset, Initialization for KFoldPartitioner base class - """ - - def __init__(self, dataset, partition_method, experiment_path, n_splits=10, random_state=None): - """ - - Args: - dataset: a streamline.utils.dataset.Dataset object or a path to dataset text file - partition_method: KFold CV method used for partitioning, must be one of ["Random", "Stratified", "Group"] - experiment_path: path to experiment the logging directory folder - n_splits: number of splits in k-fold cross validation - random_state: random seed parameter for data reproducibility - """ - super().__init__() - assert (type(dataset) == Dataset) - self.dataset = dataset - self.dataset_path = dataset.path - self.experiment_path = experiment_path - self.n_splits = n_splits - self.random_state = random_state - - self.supported_ptn_methods = ["Random", "Stratified", "Group"] - - if partition_method not in self.supported_ptn_methods: - raise Exception('Error: Unknown partition method.') - if partition_method == "Group" and self.dataset.match_label is None: - raise Exception("No Match Label in dataset") - - self.partition_method = partition_method - self.train_dfs = None - self.test_dfs = None - self.cv = None - - def cv_partitioner(self, return_dfs=True, save_dfs=True, partition_method=None): - """ - - Takes data frame (data), number of cv partitions, partition method (R, S, or M), class label, - and the column name used for matched CV. Returns list of training and testing dataframe partitions. - - Args: - return_dfs: flag to return splits as list of dataframe, returns empty list if set to False - save_dfs: save dataframes in experiment path folder - partition_method: override default partition method - - Returns: train_df, test_df both list of dataframes of train and test splits - - """ - - if partition_method: - self.partition_method = partition_method - - train_dfs, test_dfs = list(), list() - - # Random Partitioning Method - if self.partition_method == 'Random': - cv = KFold(n_splits=self.n_splits, shuffle=True, random_state=self.random_state) - # Stratified Partitioning Method - elif self.partition_method == 'Stratified': - cv = StratifiedKFold(n_splits=self.n_splits, shuffle=True, random_state=self.random_state) - # Group Partitioning Method - elif self.partition_method == 'Group': - cv = StratifiedGroupKFold(n_splits=self.n_splits, shuffle=True, random_state=self.random_state) - else: - raise Exception('Error: Requested partition method not found.') - - self.cv = cv - - if return_dfs: - if self.partition_method == "Group": - if self.dataset.match_label is None: - raise Exception("No Match Label in dataset") - for train_index, test_index in cv.split(self.dataset.feature_only_data(), - self.dataset.data[self.dataset.class_label], - self.dataset.data[self.dataset.match_label]): - train_dfs.append(self.dataset.data.iloc[train_index, :]) - test_dfs.append(self.dataset.data.iloc[test_index, :]) - else: - for train_index, test_index in cv.split(self.dataset.feature_only_data(), - self.dataset.data[self.dataset.class_label]): - train_dfs.append(self.dataset.data.iloc[train_index, :]) - test_dfs.append(self.dataset.data.iloc[test_index, :]) - self.train_dfs = train_dfs - self.test_dfs = test_dfs - - if save_dfs: - self.save_datasets(self.experiment_path, self.train_dfs, self.test_dfs) - - return self.train_dfs, self.test_dfs - - def save_datasets(self, experiment_path=None, train_dfs=None, test_dfs=None): - """ Saves individual training and testing CV datasets as .csv files""" - # Generate folder to contain generated CV datasets - - if experiment_path is None: - experiment_path = self.experiment_path - - train_dfs, test_dfs = train_dfs, test_dfs - - if train_dfs is None and test_dfs is None: - if self.train_dfs is None and self.test_dfs is None: - train_dfs, test_dfs = list(), list() - if self.partition_method == "Group": - for train_index, test_index in self.cv.split(self.dataset.feature_only_data(), - self.dataset.data[self.dataset.class_label], - self.dataset.data[self.dataset.match_label]): - train_dfs.append(self.dataset.data.iloc[train_index, :]) - test_dfs.append(self.dataset.data.iloc[test_index, :]) - else: - for train_index, test_index in self.cv.split(self.dataset.feature_only_data(), - self.dataset.data[self.dataset.class_label]): - train_dfs.append(self.dataset.data.iloc[train_index, :]) - test_dfs.append(self.dataset.data.iloc[test_index, :]) - else: - train_dfs, test_dfs = self.train_dfs, self.test_dfs - - if not os.path.exists(experiment_path + '/' + self.dataset.name + '/CVDatasets'): - os.makedirs(experiment_path + '/' + self.dataset.name + '/CVDatasets') - - # Export training datasets - counter = 0 - for df in train_dfs: - file = experiment_path + '/' + self.dataset.name + '/CVDatasets/' + self.dataset.name \ - + '_CV_' + str(counter) + "_Train.csv" - df.to_csv(file, index=False) - counter += 1 - - counter = 0 - for df in test_dfs: - file = experiment_path + '/' + self.dataset.name + '/CVDatasets/' + self.dataset.name \ - + '_CV_' + str(counter) + "_Test.csv" - df.to_csv(file, index=False) - counter += 1 - - def run(self): - self.cv_partitioner() - job_file = open(self.experiment_path + '/jobsCompleted/job_exploratory_' + self.dataset.name + '.txt', 'w') - job_file.write('complete') - job_file.close() diff --git a/streamline/dataprep/scale_and_impute.py b/streamline/dataprep/scale_and_impute.py deleted file mode 100644 index bff7bba5..00000000 --- a/streamline/dataprep/scale_and_impute.py +++ /dev/null @@ -1,301 +0,0 @@ -import os -import time -import pickle -import random -import logging -import numpy as np -import pandas as pd -from sklearn.experimental import enable_iterative_imputer -from sklearn.impute import IterativeImputer -from sklearn.preprocessing import StandardScaler -from streamline.utils.job import Job - - -class ScaleAndImpute(Job): - """ - Data Processing Job Class for Scaling and Imputation of CV Datasets - """ - - def __init__(self, cv_train_path, cv_test_path, experiment_path, scale_data=True, impute_data=True, - multi_impute=True, overwrite_cv=True, class_label="Class", instance_label=None, random_state=None): - """ - - Args: - cv_train_path: - cv_test_path: - experiment_path: - scale_data: - impute_data: - multi_impute: - overwrite_cv: - class_label: - instance_label: - random_state: - """ - super().__init__() - self.cv_train_path = cv_train_path - self.cv_test_path = cv_test_path - self.experiment_path = experiment_path - self.scale_data = scale_data - self.impute_data = impute_data - self.multi_impute = multi_impute - self.overwrite_cv = overwrite_cv - self.class_label = class_label - self.instance_label = instance_label - self.categorical_variables = None - self.dataset_name = None - self.cv_count = None - self.random_state = random_state - - def run(self): - """ - Run all elements of the data preprocessing: data scaling and missing value imputation - (mode imputation for categorical features and MICE-based iterative imputing for - quantitative features) - """ - # Set random seeds for repeatability - random.seed(self.random_state) - np.random.seed(self.random_state) - # Load target training and testing datasets - data_train, data_test = self.load_data() - # Grab header labels for features only - header = data_train.columns.values.tolist() - header.remove(self.class_label) - if not (self.instance_label is None): - header.remove(self.instance_label) - logging.info('Preparing Train and Test for: ' + str(self.dataset_name) + "_CV_" + str(self.cv_count)) - # Temporarily separate class column to be merged back into training and testing datasets later - y_train = data_train[self.class_label] - y_test = data_test[self.class_label] - # If present, temporarily separate instance label to be merged back into training and testing datasets later - if not (self.instance_label is None): - i_train = data_train[self.instance_label] - i_test = data_test[self.instance_label] - # Create features-only version of training and testing datasets for scaling and imputation - if self.instance_label is None: - x_train = data_train.drop([self.class_label], axis=1) # exclude class column - x_test = data_test.drop([self.class_label], axis=1) # exclude class column - else: - x_train = data_train.drop([self.class_label, self.instance_label], axis=1) # exclude class column - x_test = data_test.drop([self.class_label, self.instance_label], axis=1) # exclude class column - del data_train # memory cleanup - del data_test # memory cleanup - # Load previously identified list of categorical variables - # and create an index list to identify respective columns - file = open(self.experiment_path + '/' + self.dataset_name + '/exploratory/categorical_features.pickle', 'rb') - self.categorical_variables = pickle.load(file) - # Impute Missing Values in training and testing data if specified by user - if self.impute_data: - logging.info('Imputing Missing Values...') - # Confirm that there are missing values in original dataset to bother with imputation - data_counts = pd.read_csv(self.experiment_path + '/' + self.dataset_name + '/exploratory/DataCounts.csv', - na_values='NA', sep=',') - missing_values = int(data_counts['Count'].values[4]) - if missing_values != 0: - x_train, x_test = self.impute_cv_data(x_train, x_test) - x_train = pd.DataFrame(x_train, columns=header) - x_test = pd.DataFrame(x_test, columns=header) - else: # No missing data found in dataset - logging.info('Notice: No missing values found. Imputation skipped.') - # Scale training and testing datasets if specified by user - if self.scale_data: - logging.info('Scaling Data Values...') - x_train, x_test = self.data_scaling(x_train, x_test) - # Remerge features with class and instance label in training and testing data - if self.instance_label is None: - data_train = pd.concat([ - pd.DataFrame(y_train, columns=[self.class_label]), - pd.DataFrame(x_train, columns=header) - ], - axis=1, sort=False) - data_test = pd.concat([ - pd.DataFrame(y_test, columns=[self.class_label]), - pd.DataFrame(x_test, columns=header) - ], - axis=1, sort=False) - else: - data_train = pd.concat([ - pd.DataFrame(y_train, columns=[self.class_label]), - pd.DataFrame(i_train, columns=[self.instance_label]), - pd.DataFrame(x_train, columns=header) - ], - axis=1, sort=False) - data_test = pd.concat([ - pd.DataFrame(y_test, columns=[self.class_label]), - pd.DataFrame(i_test, columns=[self.instance_label]), - pd.DataFrame(x_test, columns=header) - ], - axis=1, sort=False) - del x_train # memory cleanup - del x_test # memory cleanup - - # Export imputed and/or scaled cv data - logging.info('Saving Processed Train and Test Data...') - if self.impute_data or self.scale_data: - self.write_cv_files(data_train, data_test) - # Save phase runtime - self.save_runtime() - # Print phase completion - logging.info(self.dataset_name + " Phase 2 complete") - job_file = open( - self.experiment_path + '/jobsCompleted/job_preprocessing_' - + self.dataset_name + '_' + str(self.cv_count) + '.txt', 'w') - job_file.write('complete') - job_file.close() - - def load_data(self): - """ - Load the target training and testing datasets and return respective dataframes, - feature header labels, dataset name, and specific cv partition number for this dataset pair. - """ - # Grab path name components - self.dataset_name = self.cv_train_path.split('/')[-3] - self.cv_count = self.cv_train_path.split('/')[-1].split("_")[-2] - # Load training and testing datasets - data_train = pd.read_csv(self.cv_train_path, na_values='NA', sep=',') - data_test = pd.read_csv(self.cv_test_path, na_values='NA', sep=',') - return data_train, data_test - - def impute_cv_data(self, x_train, x_test): - """ - Begin by imputing categorical variables with simple 'mode' imputation - - Args: - x_train: pandas dataframe with train set data - x_test: pandas dataframe with test set data - - Returns: Imputed x_train and x_test - - """ - mode_dict = {} - for c in x_train.columns: - if c in self.categorical_variables: - train_mode = x_train[c].mode().iloc[0] - x_train[c].fillna(train_mode, inplace=True) - mode_dict[c] = train_mode - for c in x_test.columns: - if c in self.categorical_variables: - x_test[c].fillna(mode_dict[c], inplace=True) - # Save impute map for downstream use. - outfile = open( - self.experiment_path + '/' + self.dataset_name - + "/scale_impute/categorical_imputer_cv" + str(self.cv_count) + '.pickle', "wb") - pickle.dump(mode_dict, outfile) - outfile.close() - - if self.multi_impute: - # Impute quantitative features (x) using iterative imputer (multiple imputation) - imputer = IterativeImputer(random_state=self.random_state, max_iter=30) - imputer = imputer.fit(x_train) - x_train = imputer.transform(x_train) - x_test = imputer.transform(x_test) - # Save impute map for downstream use. - outfile = open( - self.experiment_path + '/' + self.dataset_name + - '/scale_impute/ordinal_imputer_cv' + str(self.cv_count) + '.pickle', 'wb') - pickle.dump(imputer, outfile) - outfile.close() - else: # Impute quantitative features (x) with simple median imputation - median_dict = {} - for c in x_train.columns: - if not (c in self.categorical_variables): - train_median = x_train[c].median() - x_train[c].fillna(train_median, inplace=True) - median_dict[c] = train_median - for c in x_test.columns: - if not (c in self.categorical_variables): - x_test[c].fillna(median_dict[c], inplace=True) - # Save impute map for downstream use. - outfile = open( - self.experiment_path + '/' + self.dataset_name - + '/scale_impute/ordinal_imputer_cv' + str(self.cv_count) + '.pickle', 'wb') - pickle.dump(median_dict, outfile) - outfile.close() - - return x_train, x_test - - def data_scaling(self, x_train, x_test): - """ - Conducts data scaling using scikit-learn StandardScalar method which standardizes featuers by removing - the mean and scaling to unit variance. - - This scaling transformation is determined (i.e. fit) based on the training dataset alone - then the same scaling is applied (i.e. transform) to both the training and testing datasets. - The fit scaling is pickled so that it can be applied identically to data in the future for model application. - - Args: - x_train: pandas dataframe with train set data - x_test: pandas dataframe with test set data - - Returns: Scaled x_train and x_test - - """ - # number of decimal places to round scaled values to - # (Important to avoid float round errors, and thus pipeline reproducibility) - decimal_places = 7 - - # Scale features (x) using training data - scaler = StandardScaler() - scaler.fit(x_train) - - x_train = pd.DataFrame(scaler.transform(x_train).round(decimal_places), columns=x_train.columns) - # Avoid float value rounding errors with large numbers of decimal places. - # Important for pipeline reproducibility - # x_train = x_train.round(decimal_places) - # Scale features (x) using fit scalar in corresponding testing dataset - - x_test = pd.DataFrame(scaler.transform(x_test).round(decimal_places), columns=x_test.columns) - # Avoid float value rounding errors with large numbers of decimal places. - # Important for pipeline reproducibility - # x_test = x_test.round(decimal_places) - - # Save scalar for future use - outfile = open(self.experiment_path + '/' + self.dataset_name - + '/scale_impute/scaler_cv' + str(self.cv_count) + '.pickle', 'wb') - pickle.dump(scaler, outfile) - outfile.close() - return x_train, x_test - - def write_cv_files(self, data_train, data_test): - """ - Exports new training and testing datasets following imputation and/or scaling. - Includes option to overwrite original dataset (to save space) or preserve a copy of - training and testing dataset with CVOnly (for comparison and quality control). - - Args: - data_train: pandas dataframe with train set data - data_test: pandas dataframe with test set data - - Returns: None - - """ - if self.overwrite_cv: - # Remove old CV files - os.remove(self.cv_train_path) - os.remove(self.cv_test_path) - else: - # Rename old CV files - os.rename(self.cv_train_path, - self.experiment_path + '/' + self.dataset_name - + '/CVDatasets/' + self.dataset_name + '_CVOnly_' - + str(self.cv_count) + "_Train.csv") - os.rename(self.cv_test_path, - self.experiment_path + '/' + self.dataset_name - + '/CVDatasets/' + self.dataset_name + '_CVOnly_' - + str(self.cv_count) + "_Test.csv") - - # Write new CV files - data_train.to_csv(self.cv_train_path, index=False) - data_test.to_csv(self.cv_test_path, index=False) - - def save_runtime(self): - """ Save runtime for this phase """ - if not os.path.exists(self.experiment_path + '/' + self.dataset_name - + '/runtime/'): - os.mkdir(self.experiment_path + '/' + self.dataset_name - + '/runtime/') - runtime_file = open(self.experiment_path + '/' + self.dataset_name - + '/runtime/runtime_preprocessing' - + self.cv_count + '.txt', 'w+') - runtime_file.write(str(time.time() - self.job_start_time)) - runtime_file.close() diff --git a/streamline/featurefns/importance.py b/streamline/featurefns/importance.py deleted file mode 100644 index cf0680e9..00000000 --- a/streamline/featurefns/importance.py +++ /dev/null @@ -1,251 +0,0 @@ -import os -import csv -import time -import random -import pickle -import logging -import numpy as np -from sklearn.feature_selection import mutual_info_classif -from skrebate import MultiSURF, TURF -from streamline.utils.job import Job -from streamline.utils.dataset import Dataset -from streamline.modeling.utils import num_cores - - -class FeatureImportance(Job): - """ - Initializer for Feature Importance Job - """ - - def __init__(self, cv_train_path, experiment_path, class_label, instance_label=None, instance_subset=2000, - algorithm="MS", use_turf=True, turf_pct=True, random_state=None, n_jobs=None): - """ - - Args: - cv_train_path: path for the cross-validation dataset created - experiment_path: - class_label: - instance_label: - instance_subset: - algorithm: - use_turf: - turf_pct: - random_state: - n_jobs: - - """ - super().__init__() - self.cv_count = None - self.dataset = None - self.cv_train_path = cv_train_path - self.experiment_path = experiment_path - self.class_label = class_label - self.instance_label = instance_label - self.instance_subset = instance_subset - self.algorithm = algorithm - self.use_turf = use_turf - self.turf_pct = turf_pct - self.random_state = random_state - self.n_jobs = n_jobs - - def run(self): - """ - Run all elements of the feature importance evaluation: - applies either mutual information and multisurf and saves a sorted dictionary - of features with associated scores - - """ - - self.job_start_time = time.time() - random.seed(self.random_state) - np.random.seed(self.random_state) - self.prepare_data() - logging.info('Prepared Train and Test for: ' + str(self.dataset.name) + "_CV_" + str(self.cv_count)) - - assert (self.algorithm == 'MI' or self.algorithm == 'MS') - # Apply mutual information if specified by user - if self.algorithm == 'MI': - logging.info('Running Mutual Information...') - scores, output_path, alg_name = self.run_mutual_information() - # Apply MultiSURF if specified by user - elif self.algorithm == 'MS': - logging.info('Running MultiSURF...') - scores, output_path, alg_name = self.run_multi_surf() - else: - raise Exception("Feature importance algorithm not found") - - logging.info('Sort and pickle feature importance scores...') - header = self.dataset.data.columns.values.tolist() - header.remove(self.class_label) - if self.instance_label is not None: - header.remove(self.instance_label) - # Save sorted feature importance scores: - score_dict, score_sorted_features = self.sort_save_fi_scores(scores, header, alg_name) - # Pickle feature importance information to be used in Phase 4 (feature selection) - self.pickle_scores(alg_name, scores, score_dict, score_sorted_features) - # Save phase runtime - self.save_runtime(alg_name) - # Print phase completion - logging.info(self.dataset.name + " CV" + str(self.cv_count) + " phase 3 " - + alg_name + " evaluation complete") - job_file = open( - self.experiment_path + '/jobsCompleted/job_' + alg_name + '_' - + self.dataset.name + '_' + str(self.cv_count) + '.txt', 'w') - job_file.write('complete') - job_file.close() - - def prepare_data(self): - """ - Loads target cv training dataset, separates class from features and removes instance labels. - """ - self.dataset = Dataset(self.cv_train_path, self.class_label, instance_label=self.instance_label) - self.dataset.name = self.cv_train_path.split('/')[-3] - self.dataset.instance_label = self.instance_label - self.dataset.class_label = self.class_label - self.cv_count = self.cv_train_path.split('/')[-1].split("_")[-2] - - def run_mutual_information(self): - """ - Run mutual information on target training dataset and return scores as well as file path/name information. - """ - alg_name = "mutual_information" - output_path = self.experiment_path + '/' + self.dataset.name + "/feature_selection/" \ - + alg_name + '/' + alg_name + "_scores_cv_" + str(self.cv_count) + '.csv' - if not os.path.exists(self.experiment_path + '/' + self.dataset.name + "/feature_selection/" + alg_name + "/"): - os.makedirs(self.experiment_path + '/' + self.dataset.name + "/feature_selection/" + alg_name + "/") - scores = mutual_info_classif(self.dataset.feature_only_data(), self.dataset.get_outcome(), - random_state=self.random_state) - return scores, output_path, alg_name - - def run_multi_surf(self): - """ - Run multiSURF (a Relief-based feature importance algorithm able to detect both univariate - and interaction effects) and return scores as well as file path/name information - """ - # Format instance sampled dataset (prevents MultiSURF from running a very long time in large instance spaces) - - ############# - # Code portion that's problematic - # TODO: Debug - # data_features = self.dataset.feature_only_data() - # print(data_features.shape, self.dataset.get_outcome().shape, self.dataset.data.shape) - # print(len(self.dataset.data.columns)) - # print(len(data_features.columns)) - # print(data_features.shape, self.dataset.get_outcome().shape) - # formatted = np.insert(data_features, data_features.shape[1], self.dataset.get_outcome(), 1) - # - # choices = np.random.choice(formatted.shape[0], min(self.instance_subset, formatted.shape[0]), replace=False) - # new_l = list() - # for i in choices: - # new_l.append(formatted[i]) - # formatted = np.array(new_l) - # data_features = np.delete(formatted, -1, axis=1) - # data_phenotypes = formatted[:, -1] - ############## - - # New code - headers = list(self.dataset.data.columns) - if self.instance_label: - headers.remove(self.instance_label) - headers.remove(self.class_label) - - data_features = self.dataset.data[headers + [self.class_label, ]] - n = data_features.shape[0] - if self.instance_subset is not None: - n = min(data_features.shape[0], self.instance_subset) - data_features = data_features.sample(n) - data_phenotypes = data_features[self.class_label] - data_features = data_features.drop(self.class_label, axis=1) - - # Run MultiSURF - alg_name = "multisurf" - if not os.path.exists(self.experiment_path + '/' + self.dataset.name + "/feature_selection/" + alg_name + "/"): - os.makedirs(self.experiment_path + '/' + self.dataset.name + "/feature_selection/" + alg_name + "/") - output_path = self.experiment_path + '/' + self.dataset.name + "/feature_selection/" + alg_name + "/" \ - + alg_name + "_scores_cv_" + str(self.cv_count) + '.csv' - - if self.n_jobs is None: - self.n_jobs = 1 - - if self.use_turf: - try: - clf = TURF(MultiSURF(n_jobs=self.n_jobs), pct=self.turf_pct).fit(data_features.values, - data_phenotypes.values) - except ModuleNotFoundError: - raise Exception("sk-rebate version error") - else: - clf = MultiSURF(n_jobs=self.n_jobs).fit(data_features.values, data_phenotypes.values) - scores = clf.feature_importances_ - return scores, output_path, alg_name - - def pickle_scores(self, output_name, scores, score_dict, score_sorted_features): - """ - Pickle the scores, score dictionary and features sorted by score to be used primarily - in phase 4 (feature selection) of pipeline - """ - # Save Scores to pickled file for later use - outfile = open( - self.experiment_path + '/' + self.dataset.name + "/feature_selection/" + output_name - + "/pickledForPhase4/" + str(self.cv_count) + '.pickle', 'wb') - pickle.dump([scores, score_dict, score_sorted_features], outfile) - outfile.close() - - def save_runtime(self, output_name): - """ - Save phase runtime - Args: - output_name: name of the output tag - """ - runtime_file = open( - self.experiment_path + '/' + self.dataset.name + '/runtime/runtime_' + output_name + '_CV_' - + str(self.cv_count) + '.txt', 'w') - runtime_file.write(str(time.time() - self.job_start_time)) - runtime_file.close() - - def sort_save_fi_scores(self, scores, ordered_feature_names, alg_name): - """ - Creates a feature score dictionary and a dictionary sorted by decreasing feature importance scores. - - Args: - scores: - ordered_feature_names: - alg_name: - - Returns: score_dict, score_sorted_features - dictionary of scores and score sorted name of features - - """ - # Put list of scores in dictionary - score_dict = {} - i = 0 - for each in ordered_feature_names: - score_dict[each] = scores[i] - i += 1 - # Sort features by decreasing score - filename = self.experiment_path + '/' \ - + self.dataset.name + "/feature_selection/" \ - + alg_name + '/' + alg_name + "_scores_cv_" + str(self.cv_count) + '.csv' - - score_sorted_features = sorted(score_dict, key=lambda x: score_dict[x], reverse=True) - # Save scores to 'formatted' file - with open(filename, mode='w', newline="") as file: - writer = csv.writer(file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) - writer.writerow(["Sorted " + alg_name + " Scores"]) - for k in score_sorted_features: - writer.writerow([k, score_dict[k]]) - file.close() - return score_dict, score_sorted_features - - # def __getstate__(self): - # """called when pickling - this hack allows subprocesses to - # be spawned without the AuthenticationString raising an error""" - # state = self.__dict__.copy() - # conf = state['_config'] - # if 'authkey' in conf: - # # del conf['authkey'] - # conf['authkey'] = bytes(conf['authkey']) - # return state - # - # def __setstate__(self, state): - # """for unpickling""" - # state['_config']['authkey'] = state['_config']['authkey'] - # self.__dict__.update(state) diff --git a/streamline/featurefns/selection.py b/streamline/featurefns/selection.py deleted file mode 100644 index 748bbf61..00000000 --- a/streamline/featurefns/selection.py +++ /dev/null @@ -1,341 +0,0 @@ -import os -import time -import copy -import logging -import pickle -import numpy as np -import pandas as pd -import matplotlib.pyplot as plt -from statistics import median -from streamline.utils.job import Job -import seaborn as sns -sns.set_theme() - - -class FeatureSelection(Job): - """ - Feature Selection Job for CV Data Splits - """ - def __init__(self, full_path, n_splits, algorithms, class_label, instance_label, export_scores=True, - top_features=20, max_features_to_keep=2000, filter_poor_features=True, overwrite_cv=False, - show_plots=False): - """ - - Args: - export_scores: flag to export top feature scores (default=True) - top_features: number of top features to consider (default=20) - max_features_to_keep: maximum number of features to keep (default=2000) - filter_poor_features: flag to filter poor features (default=True) - overwrite_cv: overwrite last cross validation dataset (default=False) - show_plots: flag to show plots (default=False) - - """ - super().__init__() - self.full_path = full_path - self.algorithms = algorithms - self.n_splits = n_splits - self.class_label = class_label - self.instance_label = instance_label - self.export_scores = export_scores - self.top_features = top_features - self.max_features_to_keep = max_features_to_keep - self.filter_poor_features = filter_poor_features - self.overwrite_cv = overwrite_cv - self.show_plots = show_plots - - def run(self): - """ - Run all elements of the feature selection: reports average feature importance scores across - CV sets and applies collective feature selection to generate new feature selected datasets - """ - # def job(full_path,do_mutual_info,do_multisurf,max_features_to_keep, - # filter_poor_features,top_features,export_scores,class_label, - # instance_label,cv_partitions,overwrite_cv,jupyterRun): - - self.job_start_time = time.time() - dataset_name = self.full_path.split('/')[-1] - selected_feature_lists = {} - meta_feature_ranks = {} - # total_features = 0 - logging.info('Plotting Feature Importance Scores...') - # Manage and summarize mutual information feature importance scores - # logging.warning("MI in algorithms" + str("MI" in self.algorithms)) - # logging.warning("MS in algorithms" + str("MS" in self.algorithms)) - # logging.warning("len(algorithms):" + str(len(self.algorithms))) - if "MI" in self.algorithms: - selected_feature_lists, meta_feature_ranks = self.report_ave_fs("MI", - "mutual_information", - selected_feature_lists, meta_feature_ranks) - # Manage and summarize MultiSURF feature importance scores - if "MS" in self.algorithms: - selected_feature_lists, meta_feature_ranks = self.report_ave_fs("MS", "multisurf", - selected_feature_lists, meta_feature_ranks) - # Conduct collective feature selection - logging.info('Applying collective feature selection...') - if len(self.algorithms) != 0: - if self.filter_poor_features: - # Identify top feature subset for each cv - cv_selected_list, informative_feature_counts, uninformative_feature_counts = \ - self.select_features(selected_feature_lists, - self.max_features_to_keep, meta_feature_ranks) - # Save count of features identified as informative for each CV partitions - self.report_informative_features(informative_feature_counts, uninformative_feature_counts) - # Generate new datasets with selected feature subsets - self.gen_filtered_datasets(cv_selected_list, self.full_path + '/CVDatasets', - dataset_name, self.overwrite_cv) - # Save phase runtime - self.save_runtime(self.full_path) - # Print phase completion - logging.info(dataset_name + " Phase 4 Complete") - experiment_path = '/'.join(self.full_path.split('/')[:-1]) - job_file = open(experiment_path + '/jobsCompleted/job_featureselection_' + dataset_name + '.txt', 'w') - job_file.write('complete') - job_file.close() - - def report_informative_features(self, informative_feature_counts, uninformative_feature_counts): - """ - Saves counts of informative vs uninformative features (i.e. those with feature - importance scores <= 0) in an csv file. - Args: - informative_feature_counts: count of informative features to save - uninformative_feature_counts: count of uninformative features to save - """ - counts = {'Informative': informative_feature_counts, 'Uninformative': uninformative_feature_counts} - count_df = pd.DataFrame(counts) - count_df.to_csv(self.full_path + "/feature_selection/InformativeFeatureSummary.csv", - index_label='CV_Partition') - - def report_ave_fs(self, algorithm, algorithmlabel, - selected_feature_lists, meta_feature_ranks): - """ - Loads feature importance results from phase 3, stores sorted feature importance scores for all - cvs, creates a list of all feature names that have a feature importance score greater than 0 - (i.e. some evidence that it may be informative), and creates a barplot of average - feature importance scores. - - Args: - algorithm: name of algorithm reporting for - algorithmlabel: label of algorithm reporting for (used for saving logs) - selected_feature_lists: list of selected features for processing (dictionary for data storage) - meta_feature_ranks: dictionary for data storage - - Returns: - - """ - # Load and manage feature importance scores ------------------------------------------------------------------ - counter = 0 - cv_keep_list = [] - feature_name_ranks = [] # stores sorted feature importance dictionaries for all CVs - cv_score_dict = {} - for i in range(0, self.n_splits): - score_info = self.full_path + "/feature_selection/" + algorithmlabel + "/pickledForPhase4/" + str( - i) + '.pickle' - file = open(score_info, 'rb') - raw_data = pickle.load(file) - file.close() - score_dict = raw_data[1] # dictionary of feature importance scores (original feature order) - score_sorted_features = raw_data[2] # dictionary of feature importance scores (in decreasing order) - feature_name_ranks.append(score_sorted_features) - # update cv_score_dict so there is a list of scores (from CV runs) for each feature - if counter == 0: - cv_score_dict = copy.deepcopy(score_dict) - for each in cv_score_dict: - cv_score_dict[each] = [cv_score_dict[each]] - else: - for each in raw_data[1]: - cv_score_dict[each].append(score_dict[each]) - counter += 1 - """ - # Update score_dict so it includes feature importance sums across all cvs. - if counter == 0: - scoreSum = copy.deepcopy(scoreDict) - else: - for each in raw_data[1]: - scoreSum[each] += score_dict[each] - """ - keep_list = [] - for each in score_dict: - if score_dict[each] > 0: - keep_list.append(each) - cv_keep_list.append(keep_list) - selected_feature_lists[algorithm] = cv_keep_list # stores feature names to keep for all algorithms and CVs - # stores sorted feature importance dictionaries for all algorithms and CVs - meta_feature_ranks[algorithm] = feature_name_ranks - - # Generate barplot of average scores------------------------------------------------------------------------ - if self.export_scores: - # Get median score for each features - for v in cv_score_dict: - cv_score_dict[v] = median(cv_score_dict[v]) - df_string = pd.DataFrame(cv_score_dict.items(), columns=['Feature', 'Importance'])\ - .sort_values('Importance', ascending=False).head(10).to_string() - logging.info(df_string) - """ - # Make the sum of scores an average - for v in scoreSum: - scoreSum[v] = scoreSum[v] / float(cv_partitions) - """ - # Sort averages (decreasing order and print top 'n' and plot top 'n' - f_names = [] - f_scores = [] - for each in cv_score_dict: - f_names.append(each) - f_scores.append(cv_score_dict[each]) - names_scores = {'Names': f_names, 'Scores': f_scores} - ns = pd.DataFrame(names_scores) - ns = ns.sort_values(by='Scores', ascending=False) - # Select top 'n' to report and plot - ns = ns.head(self.top_features) - # Visualize sorted feature scores - try: - ns['Scores'].plot(kind='barh', figsize=(6, 12)) - except Exception: - plt.figure(figsize=(6, 12)) - plt.barh(ns['Names'], ns['Scores']) - plt.ylabel('Features') - algorithm_name = "" - if algorithm == "MI": - algorithm_name = "Mutual Information" - elif algorithm == "MS": - algorithm_name = "MultiSURF" - plt.xlabel(str(algorithm_name) + ' Median Score') - plt.yticks(np.arange(len(ns['Names'])), ns['Names']) - plt.title('Sorted Median ' + str(algorithm_name) + ' Scores') - logging.info("Saved Feature Importance Plots at") - logging.info(self.full_path + "/feature_selection/" + algorithmlabel + "/TopAverageScores.png") - plt.savefig((self.full_path + "/feature_selection/" + algorithmlabel + "/TopAverageScores.png"), - bbox_inches="tight") - if self.show_plots: - plt.show() - else: - plt.close('all') - # plt.cla() # not required - return selected_feature_lists, meta_feature_ranks - - def select_features(self, selected_feature_lists, max_features_to_keep, meta_feature_ranks): - """ - Function to select features - - Identifies feature to keep for each cv. - If more than one feature importance algorithm was applied, collective feature selection - is applied so that the union of informative features is preserved. - Overall, only informative features (i.e. those with a score > 0 are preserved). - If there are more informative features than the max_features_to_keep, - then only those top scoring features are preserved. - To reduce the feature list to some max limit, we alternate between algorithm ranked feature - lists grabbing the top features from each until the max limit is reached. - - Args: - selected_feature_lists: dictionary fpr data storage - max_features_to_keep: number of maximum features to keep - meta_feature_ranks: dictionary for data storage - - Returns: - cv_selected_list, informative_feature_counts, uninformative_feature_counts - list of final selected features for each cv - - """ - cv_selected_list = [] # final list of selected features for each cv (list of lists) - num_algorithms = len(self.algorithms) - informative_feature_counts = [] - uninformative_feature_counts = [] - total_features = len(meta_feature_ranks[self.algorithms[0]][0]) - # 'Interesting' features determined by union of feature selection results (from different algorithms) - if num_algorithms > 1: - for i in range(self.n_splits): - # grab first algorithm's lists of feature names to keep - # Determine union - union_list = selected_feature_lists[self.algorithms[0]][i] - for j in range(1, num_algorithms): # number of union comparisons - union_list = list(set(union_list) | set(selected_feature_lists[self.algorithms[j]][i])) - informative_feature_counts.append(len(union_list)) - uninformative_feature_counts.append(total_features - len(union_list)) - # Further reduce selected feature set if it is larger than max_features_to_keep - if len(union_list) > max_features_to_keep: # Apply further filtering if more than max features remains - # Create score list dictionary with indexes in union list - new_feature_list = [] - k = 0 - while len(new_feature_list) < max_features_to_keep: - for each in meta_feature_ranks: - target_feature = meta_feature_ranks[each][i][k] - if target_feature not in new_feature_list: - new_feature_list.append(target_feature) - if len(new_feature_list) < max_features_to_keep: - break - k += 1 - union_list = new_feature_list - union_list.sort() # Added to ensure script random seed reproducibility - cv_selected_list.append(union_list) - else: # Only one algorithm applied (collective feature selection not applied) - for i in range(self.n_splits): - feature_list = selected_feature_lists[self.algorithms[0]][i] # grab first algorithm's lists - informative_feature_counts.append(len(feature_list)) - uninformative_feature_counts.append(total_features - informative_feature_counts) - # Apply further filtering if more than max features remains - if len(feature_list) > max_features_to_keep: - # Create score list dictionary with indexes in union list - new_feature_list = [] - k = 0 - while len(new_feature_list) < max_features_to_keep: - target_feature = meta_feature_ranks[self.algorithms[0]][i][k] - new_feature_list.append(target_feature) - k += 1 - feature_list = new_feature_list - cv_selected_list.append(feature_list) - return cv_selected_list, informative_feature_counts, uninformative_feature_counts - - def gen_filtered_datasets(self, cv_selected_list, path_to_csv, dataset_name, overwrite_cv): - """ - Takes the lists of final features to be kept and creates new filtered cv training and - testing datasets including only those features. - - Args: - cv_selected_list: list of list for name of features selected for each cv - path_to_csv: path to cv splits from the last phase - dataset_name: name of dataset - overwrite_cv: rename or overwrite old cv splits - - - """ - # create lists to hold training and testing set dataframes. - train_list = [] - test_list = [] - for i in range(self.n_splits): - # Load training partition - train_set = pd.read_csv(path_to_csv + '/' + dataset_name + '_CV_' + str(i) - + "_Train.csv", na_values='NA', sep=",") - train_list.append(train_set) - # Load testing partition - test_set = pd.read_csv(path_to_csv + '/' + dataset_name + '_CV_' + str(i) - + "_Test.csv", na_values='NA', sep=",") - test_list.append(test_set) - # Training datasets - label_list = [self.class_label] - if not (self.instance_label is None): - label_list.append(self.instance_label) - label_list = label_list + cv_selected_list[i] - td_train = train_list[i][label_list] - td_test = test_list[i][label_list] - if overwrite_cv: - # Remove old CV files - os.remove(path_to_csv + '/' + dataset_name + '_CV_' + str(i) + "_Train.csv") - os.remove(path_to_csv + '/' + dataset_name + '_CV_' + str(i) + "_Test.csv") - else: - # Rename old CV files - os.rename(path_to_csv + '/' + dataset_name + '_CV_' + str(i) + - "_Train.csv", path_to_csv + '/' + dataset_name + '_CVPre_' + str(i) + "_Train.csv") - os.rename(path_to_csv + '/' + dataset_name + '_CV_' + str(i) + - "_Test.csv", path_to_csv + '/' + dataset_name + '_CVPre_' + str(i) + "_Test.csv") - - td_train.to_csv(path_to_csv + '/' + dataset_name + '_CV_' + str(i) + "_Train.csv", index=False) - td_test.to_csv(path_to_csv + '/' + dataset_name + '_CV_' + str(i) + "_Test.csv", index=False) - - def save_runtime(self, full_path): - """ - Save phase runtime - Args: - full_path: full path of current experiment - """ - runtime_file = open(full_path + '/runtime/runtime_featureselection.txt', 'w') - runtime_file.write(str(time.time() - self.job_start_time)) - runtime_file.close() diff --git a/streamline/legacy/CompareJobSubmit.py b/streamline/legacy/CompareJobSubmit.py deleted file mode 100644 index 5ee45a70..00000000 --- a/streamline/legacy/CompareJobSubmit.py +++ /dev/null @@ -1,38 +0,0 @@ -import os -import sys -import pickle -from pathlib import Path - -SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) -sys.path.append(str(Path(SCRIPT_DIR).parent.parent)) - -from streamline.postanalysis.dataset_compare import CompareJob - - -def run_cluster(argv): - output_path = argv[1] - experiment_name = argv[2] - experiment_path = argv[3] if argv[3] != "None" else None - file = open(output_path + '/' + experiment_name + '/' + "algInfo.pickle", 'rb') - alg_info = pickle.load(file) - file.close() - temp_algo = [] - for key in alg_info: - if alg_info[key][0]: - temp_algo.append(key) - algorithms = temp_algo - algorithms = sorted(algorithms) - - exclude = None - class_label = argv[6] - instance_label = argv[7] if argv[7] != "None" else None - sig_cutoff = float(argv[8]) - show_plots = eval(argv[9]) - - job_obj = CompareJob(output_path, experiment_name, experiment_path, algorithms, exclude, - class_label, instance_label, sig_cutoff, show_plots) - job_obj.run() - - -if __name__ == "__main__": - sys.exit(run_cluster(sys.argv)) diff --git a/streamline/legacy/DataJobSubmit.py b/streamline/legacy/DataJobSubmit.py deleted file mode 100644 index b411230f..00000000 --- a/streamline/legacy/DataJobSubmit.py +++ /dev/null @@ -1,31 +0,0 @@ -import os -import sys -from pathlib import Path - -SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) -sys.path.append(str(Path(SCRIPT_DIR).parent.parent)) - -from streamline.dataprep.scale_and_impute import ScaleAndImpute - - -def run_cluster(argv): - cv_train_path = argv[1] - cv_test_path = argv[2] - full_path = argv[3] - scale_data = eval(argv[4]) - impute_data = eval(argv[5]) - multi_impute = eval(argv[6]) - overwrite_cv = eval(argv[7]) - class_label = argv[8] if argv[8] != "None" else None - instance_label = argv[9] if argv[9] != "None" else None - random_state = int(argv[10]) if argv[10] != "None" else None - - job_obj = ScaleAndImpute(cv_train_path, cv_test_path, - full_path, - scale_data, impute_data, multi_impute, overwrite_cv, - class_label, instance_label, random_state) - job_obj.run() - - -if __name__ == "__main__": - sys.exit(run_cluster(sys.argv)) diff --git a/streamline/legacy/EDAJobSubmit.py b/streamline/legacy/EDAJobSubmit.py deleted file mode 100644 index fb98de51..00000000 --- a/streamline/legacy/EDAJobSubmit.py +++ /dev/null @@ -1,50 +0,0 @@ -import os -import sys -from pathlib import Path - -SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) -sys.path.append(str(Path(SCRIPT_DIR).parent.parent)) - -from streamline.dataprep.data_process import DataProcess -from streamline.dataprep.kfold_partitioning import KFoldPartitioner -from streamline.utils.dataset import Dataset -from streamline.utils.parser_helpers import process_cli_param - - -def run_cluster(argv): - dataset_path = argv[1] - output_path = argv[2] - experiment_name = argv[3] - if argv[4] != 'None': - exclude_eda_output = argv[4].split(',') - exclude_eda_output = [x.strip() for x in exclude_eda_output] - else: - exclude_eda_output = None - class_label = argv[5] - instance_label = argv[6] if argv[6] != "None" else None - match_label = argv[7] if argv[7] != "None" else None - n_splits = int(argv[8]) - partition_method = argv[9] - ignore_features = process_cli_param(argv[10]) - categorical_features = process_cli_param(argv[11]) - quantitative_features = process_cli_param(argv[12]) - top_features = int(argv[13]) - categorical_cutoff = int(argv[14]) - sig_cutoff = float(argv[15]) - featureeng_missingness = float(argv[16]) - cleaning_missingness = float(argv[17]) - correlation_removal_threshold = float(argv[18]) - random_state = None if argv[19] == "None" else int(argv[19]) - - dataset = Dataset(dataset_path, class_label, match_label, instance_label) - eda_obj = DataProcess(dataset, output_path + '/' + experiment_name, - ignore_features, - categorical_features, quantitative_features, exclude_eda_output, - categorical_cutoff, sig_cutoff, featureeng_missingness, - cleaning_missingness, correlation_removal_threshold, partition_method, n_splits, - random_state) - eda_obj.run(top_features) - - -if __name__ == "__main__": - sys.exit(run_cluster(sys.argv)) diff --git a/streamline/legacy/FImpJobSubmit.py b/streamline/legacy/FImpJobSubmit.py deleted file mode 100644 index b96a309a..00000000 --- a/streamline/legacy/FImpJobSubmit.py +++ /dev/null @@ -1,30 +0,0 @@ -import os -import sys -from pathlib import Path - -SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) -sys.path.append(str(Path(SCRIPT_DIR).parent.parent)) - -from streamline.featurefns.importance import FeatureImportance - - -def run_cluster(argv): - cv_train_path = argv[1] - experiment_path = argv[2] - class_label = argv[3] - instance_label = argv[4] if argv[4] != "None" else None - instance_subset = None if argv[5] == "None" else eval(argv[5]) - algorithm = argv[6] - use_turf = eval(argv[7]) - turf_pct = eval(argv[8]) - random_state = None if argv[9] == "None" else int(argv[9]) - n_jobs = None if argv[10] == "None" else int(argv[10]) - - job_obj = FeatureImportance(cv_train_path, experiment_path, class_label, - instance_label, instance_subset, algorithm, - use_turf, turf_pct, random_state, n_jobs) - job_obj.run() - - -if __name__ == "__main__": - sys.exit(run_cluster(sys.argv)) diff --git a/streamline/legacy/FSelJobSubmit.py b/streamline/legacy/FSelJobSubmit.py deleted file mode 100644 index 3fae2989..00000000 --- a/streamline/legacy/FSelJobSubmit.py +++ /dev/null @@ -1,33 +0,0 @@ -import os -import sys -from pathlib import Path - -SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) -sys.path.append(str(Path(SCRIPT_DIR).parent.parent)) - -from streamline.featurefns.selection import FeatureSelection - - -def run_cluster(argv): - full_path = argv[1] - n_datasets = int(argv[2]) - MI, MS = "MI", "MS" - algorithms = None if argv[3] == "None" else eval(argv[3]) - print(algorithms) - class_label = argv[4] - instance_label = argv[5] if argv[5] != "None" else None - export_scores = eval(argv[6]) - top_features = int(argv[7]) - max_features_to_keep = int(argv[8]) - filter_poor_features = eval(argv[9]) - overwrite_cv = eval(argv[10]) - - job_obj = FeatureSelection(full_path, n_datasets, algorithms, - class_label, instance_label, export_scores, - top_features, max_features_to_keep, - filter_poor_features, overwrite_cv) - job_obj.run() - - -if __name__ == "__main__": - sys.exit(run_cluster(sys.argv)) diff --git a/streamline/legacy/ModelJobSubmit.py b/streamline/legacy/ModelJobSubmit.py deleted file mode 100644 index e86190f2..00000000 --- a/streamline/legacy/ModelJobSubmit.py +++ /dev/null @@ -1,94 +0,0 @@ -import os -import pickle -import sys -from pathlib import Path - -SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) -sys.path.append(str(Path(SCRIPT_DIR).parent.parent)) - -from streamline.modeling.modeljob import ModelJob -from streamline.modeling.utils import model_str_to_obj -from streamline.modeling.utils import get_fi_for_ExSTraCS - - -def run_cluster(argv): - full_path = argv[1] - output_path = argv[2] - experiment_name = argv[3] - cv_count = int(argv[4]) - class_label = argv[5] - instance_label = argv[6] if argv[6] != "None" else None - scoring_metric = argv[7] - metric_direction = argv[8] - n_trials = int(argv[9]) - timeout = int(argv[10]) - training_subsample = int(argv[11]) - uniform_fi = eval(argv[12]) - save_plot = eval(argv[13]) - random_state = None if argv[14] == "None" else int(argv[14]) - algorithm = argv[15] - n_jobs = None if argv[16] == "None" else int(argv[16]) - do_lcs_sweep = eval(argv[17]) - lcs_iterations = int(argv[18]) - lcs_n = int(argv[19]) - lcs_nu = int(argv[20]) - - file = open(output_path + '/' + experiment_name + '/' + "metadata.pickle", 'rb') - metadata = pickle.load(file) - filter_poor_features = metadata['Filter Poor Features'] - file.close() - - dataset_directory_path = full_path.split('/')[-1] - - job_obj = ModelJob(full_path, output_path, experiment_name, cv_count, class_label, - instance_label, scoring_metric, metric_direction, n_trials, - timeout, training_subsample, uniform_fi, save_plot, random_state) - - if algorithm not in ['eLCS', 'XCS', 'ExSTraCS']: - model = model_str_to_obj(algorithm)(cv_folds=3, - scoring_metric=scoring_metric, - metric_direction=metric_direction, - random_state=random_state, - cv=None, n_jobs=n_jobs) - else: - if algorithm == 'ExSTraCS': - expert_knowledge = get_fi_for_ExSTraCS(output_path, experiment_name, - dataset_directory_path, - class_label, instance_label, cv_count, - filter_poor_features) - if do_lcs_sweep: - model = model_str_to_obj(algorithm)(cv_folds=3, - scoring_metric=scoring_metric, - metric_direction=metric_direction, - random_state=random_state, - cv=None, n_jobs=n_jobs, - expert_knowledge=expert_knowledge) - else: - model = model_str_to_obj(algorithm)(cv_folds=3, - scoring_metric=scoring_metric, - metric_direction=metric_direction, - random_state=random_state, - cv=None, n_jobs=n_jobs, - iterations=lcs_iterations, - N=lcs_n, nu=lcs_nu, - expert_knowledge=expert_knowledge) - else: - if do_lcs_sweep: - model = model_str_to_obj(algorithm)(cv_folds=3, - scoring_metric=scoring_metric, - metric_direction=metric_direction, - random_state=random_state, - cv=None, n_jobs=n_jobs) - else: - model = model_str_to_obj(algorithm)(cv_folds=3, - scoring_metric=scoring_metric, - metric_direction=metric_direction, - random_state=random_state, - cv=None, n_jobs=n_jobs, - iterations=lcs_iterations, - N=lcs_n, nu=lcs_nu) - job_obj.run(model) - - -if __name__ == "__main__": - sys.exit(run_cluster(sys.argv)) diff --git a/streamline/legacy/RepJobSubmit.py b/streamline/legacy/RepJobSubmit.py deleted file mode 100644 index 1a071de5..00000000 --- a/streamline/legacy/RepJobSubmit.py +++ /dev/null @@ -1,57 +0,0 @@ -import os -import sys -import pickle -from pathlib import Path - -SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) -sys.path.append(str(Path(SCRIPT_DIR).parent.parent)) - -from streamline.postanalysis.model_replicate import ReplicateJob - - -def run_cluster(argv): - dataset_filename = argv[1] - dataset_for_rep = argv[2] - full_path = argv[3] - class_label = argv[4] - instance_label = argv[5] if argv[5] != "None" else None - match_label = argv[6] if argv[6] != "None" else None - experiment_path = '/'.join(full_path.split('/')[:-1]) - file = open(experiment_path + '/' + "algInfo.pickle", 'rb') - alg_info = pickle.load(file) - file.close() - temp_algo = [] - for key in alg_info: - if alg_info[key][0]: - temp_algo.append(key) - algorithms = temp_algo - file = open(experiment_path + '/' + "metadata.pickle", 'rb') - metadata = pickle.load(file) - file.close() - ignore_features = metadata['Ignored Features'] - exclude = None - len_cv = int(argv[9]) - if argv != 'None': - exclude_options = argv[10].split(',') - exclude_options = [x.strip() for x in exclude_options] - else: - exclude_options = None - categorical_cutoff = int(argv[11]) if argv[11] != "None" else None - sig_cutoff = float(argv[12]) if argv[12] != "None" else None - scale_data = eval(argv[13]) - impute_data = eval(argv[14]) - multi_impute = eval(argv[15]) - show_plots = eval(argv[16]) - scoring_metric = argv[17] - random_state = eval(argv[18]) - - job_obj = ReplicateJob(dataset_filename, dataset_for_rep, full_path, class_label, instance_label, - match_label, ignore_features, algorithms, exclude, len_cv, - exclude_options, - categorical_cutoff, sig_cutoff, scale_data, impute_data, - multi_impute, show_plots, scoring_metric, random_state) - job_obj.run() - - -if __name__ == "__main__": - sys.exit(run_cluster(sys.argv)) diff --git a/streamline/legacy/ReportJobSubmit.py b/streamline/legacy/ReportJobSubmit.py deleted file mode 100644 index cafc1a04..00000000 --- a/streamline/legacy/ReportJobSubmit.py +++ /dev/null @@ -1,36 +0,0 @@ -import os -import sys -import pickle -from pathlib import Path - -SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) -sys.path.append(str(Path(SCRIPT_DIR).parent.parent)) - -from streamline.postanalysis.gererate_report import ReportJob - - -def run_cluster(argv): - output_path = argv[1] - experiment_name = argv[2] - experiment_path = None - algorithms = None - file = open(output_path + '/' + experiment_name + '/' + "algInfo.pickle", 'rb') - alg_info = pickle.load(file) - file.close() - temp_algo = [] - for key in alg_info: - if alg_info[key][0]: - temp_algo.append(key) - algorithms = temp_algo - exclude = None - training = eval(argv[6]) - train_data_path = None if argv[7] == "None" else argv[7] - rep_data_path = None if argv[8] == "None" else argv[8] - - job_obj = ReportJob(output_path, experiment_name, experiment_path, algorithms, exclude, - training, train_data_path, rep_data_path) - job_obj.run() - - -if __name__ == "__main__": - sys.exit(run_cluster(sys.argv)) diff --git a/streamline/legacy/StatsJobSubmit.py b/streamline/legacy/StatsJobSubmit.py deleted file mode 100644 index 8c52b1c5..00000000 --- a/streamline/legacy/StatsJobSubmit.py +++ /dev/null @@ -1,49 +0,0 @@ -import os -import sys -import pickle -from pathlib import Path - -SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) -sys.path.append(str(Path(SCRIPT_DIR).parent.parent)) - -from streamline.postanalysis.statistics import StatsJob - - -def run_cluster(argv): - full_path = argv[1] - experiment_path = '/'.join(full_path.split('/')[:-1]) - algorithms = None - file = open(experiment_path + '/' + "algInfo.pickle", 'rb') - alg_info = pickle.load(file) - file.close() - temp_algo = [] - for key in alg_info: - if alg_info[key][0]: - temp_algo.append(key) - algorithms = temp_algo - algorithms = sorted(algorithms) - - class_label = argv[3] - instance_label = argv[4] if argv[4] != "None" else None - scoring_metric = argv[5] - len_cv = int(argv[6]) - top_features = int(argv[7]) if argv[7] != "None" else None - sig_cutoff = float(argv[8]) if argv[8] != "None" else None - metric_weight = argv[9] if argv[9] != "None" else None - scale_data = eval(argv[10]) - if argv[11] != 'None': - exclude_options = argv[11].split(',') - exclude_options = [x.strip() for x in exclude_options] - else: - exclude_options = None - show_plots = eval(argv[12]) - - job_obj = StatsJob(full_path, algorithms, class_label, instance_label, scoring_metric, - len_cv, top_features, sig_cutoff, metric_weight, scale_data, - exclude_options, - show_plots) - job_obj.run() - - -if __name__ == "__main__": - sys.exit(run_cluster(sys.argv)) diff --git a/streamline/modeling/basemodel.py b/streamline/modeling/basemodel.py deleted file mode 100644 index e474241c..00000000 --- a/streamline/modeling/basemodel.py +++ /dev/null @@ -1,187 +0,0 @@ -import copy -import logging -import optuna -from sklearn import metrics -from sklearn.metrics import auc -from streamline.utils.evaluation import class_eval -from sklearn.utils._testing import ignore_warnings -from sklearn.exceptions import ConvergenceWarning -from sklearn.model_selection import StratifiedKFold, cross_val_score -import warnings -warnings.filterwarnings(action='ignore', module='sklearn') -warnings.filterwarnings(action='ignore', module='scipy') -warnings.filterwarnings(action='ignore', module='optuna') -warnings.filterwarnings(action="ignore", category=ConvergenceWarning, module="sklearn") - - -class BaseModel: - def __init__(self, model, model_name, - cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', - random_state=None, cv=None, sampler=None, n_jobs=None): - """ - Base Model Class for all ML Models - - Args: - model: - model_name: - cv_folds: - scoring_metric: - metric_direction: - random_state: - cv: - sampler: - n_jobs: - """ - self.is_single = True - if model is not None: - self.model = model() - self.small_name = model_name.replace(" ", "_") - self.model_name = model_name - self.y_train = None - self.x_train = None - self.param_grid = None - self.params = None - self.random_state = random_state - self.scoring_metric = scoring_metric - self.metric_direction = metric_direction - if cv is None: - self.cv = StratifiedKFold(n_splits=cv_folds, shuffle=True, random_state=self.random_state) - else: - self.cv = cv - - if sampler is None: - self.sampler = optuna.samplers.TPESampler(seed=self.random_state) - else: - self.sampler = sampler - self.study = None - optuna.logging.set_verbosity(optuna.logging.WARNING) - self.n_jobs = n_jobs - - def objective(self, trial, params=None): - """ - Unimplemented objective function stub, needs to be overridden - Args: - trial: optuna trial object - params: dict of optional params or None - """ - raise NotImplementedError - - @ignore_warnings(category=ConvergenceWarning) - def optimize(self, x_train, y_train, n_trails, timeout, feature_names=None): - """ - Common model optimization function - - Args: - x_train: train data - y_train: label data - n_trails: number of optuna trials - timeout: maximum time for optuna trial timeout - feature_names: header/name of features - - """ - self.x_train = x_train - self.y_train = y_train - for key, value in self.param_grid.items(): - if len(value) > 1 and key != 'expert_knowledge': - self.is_single = False - break - - if not self.is_single: - optuna.logging.set_verbosity(optuna.logging.WARNING) - self.study = optuna.create_study(direction=self.metric_direction, sampler=self.sampler) - if self.model_name in ["Extreme Gradient Boosting", "Light Gradient Boosting"]: - pos_inst = sum(y_train) - neg_inst = len(y_train) - pos_inst - class_weight = neg_inst / float(pos_inst) - self.study.optimize(lambda trial: self.objective(trial, params={'class_weight': class_weight}), - n_trials=n_trails, timeout=timeout, - catch=(ValueError,)) - elif self.model_name == "Genetic Programming": - self.study.optimize(lambda trial: self.objective(trial, params={'feature_names': feature_names}), - n_trials=n_trails, timeout=timeout, - catch=(ValueError,)) - else: - self.study.optimize(lambda trial: self.objective(trial), n_trials=n_trails, timeout=timeout, - catch=(ValueError,)) - - logging.info('Best trial:') - best_trial = self.study.best_trial - logging.info(' Value: ' + str(best_trial.value)) - logging.info(' Params: ') - for key, value in best_trial.params.items(): - logging.info(' {}: {}'.format(key, value)) - # Specify model with optimized hyperparameters - # Export final model hyperparamters to csv file - self.params = best_trial.params - self.model = copy.deepcopy(self.model).set_params(**best_trial.params) - else: - self.params = copy.deepcopy(self.param_grid) - for key, value in self.param_grid.items(): - self.params[key] = value[0] - self.model = copy.deepcopy(self.model).set_params(**self.params) - - def feature_importance(self): - """ - Unimplemented feature importance function stub - """ - raise NotImplementedError - - def hyper_eval(self): - """ - Hyper eval for objective function - Returns: Returns hyper eval for objective function - """ - logging.debug("Trial Parameters" + str(self.params)) - try: - model = copy.deepcopy(self.model).set_params(**self.params) - mean_cv_score = cross_val_score(model, self.x_train, self.y_train, - scoring=self.scoring_metric, - cv=self.cv, n_jobs=self.n_jobs).mean() - except Exception as e: - logging.error("KeyError while copying model " + self.model_name) - logging.error(str(e)) - model_class = self.model.__class__ - model = model_class(**self.params) - mean_cv_score = cross_val_score(model, self.x_train, self.y_train, - scoring=self.scoring_metric, - cv=self.cv, n_jobs=self.n_jobs).mean() - logging.debug("Trail Completed") - return mean_cv_score - - def model_evaluation(self, x_test, y_test): - """ - Runs commands to gather all evaluations for later summaries and plots. - """ - # Prediction evaluation - y_pred = self.model.predict(x_test) - metric_list = class_eval(y_test, y_pred) - # Determine probabilities of class predictions for each test instance - # (this will be used much later in calculating an ROC curve) - probas_ = self.model.predict_proba(x_test) - # Compute ROC curve and area the curve - fpr, tpr, thresholds = metrics.roc_curve(y_test, probas_[:, 1]) - roc_auc = auc(fpr, tpr) - # Compute Precision/Recall curve and AUC - prec, recall, thresholds = metrics.precision_recall_curve(y_test, probas_[:, 1]) - prec, recall, thresholds = prec[::-1], recall[::-1], thresholds[::-1] - prec_rec_auc = auc(recall, prec) - ave_prec = metrics.average_precision_score(y_test, probas_[:, 1]) - return metric_list, fpr, tpr, roc_auc, prec, recall, prec_rec_auc, ave_prec, probas_ - - def fit(self, x_train, y_train, n_trails, timeout, feature_names=None): - """ - Caller function to optimize - """ - self.optimize(x_train, y_train, n_trails, timeout, feature_names) - self.model.fit(x_train, y_train) - - def predict(self, x_in): - """ - Function to predict with trained model - Args: - x_in: input data - - Returns: predictions y_pred - - """ - return self.model.predict(x_in) diff --git a/streamline/modeling/load_models.py b/streamline/modeling/load_models.py deleted file mode 100644 index 8399bef8..00000000 --- a/streamline/modeling/load_models.py +++ /dev/null @@ -1,17 +0,0 @@ -import os -from pathlib import Path - - -def load_class_from_folder(path=None): - if path is None: - path = os.path.join(Path(__file__).parent.parent, 'models/') - - classes = list() - for py in [f[:-3] for f in os.listdir(path) if f.endswith('.py') and f != '__init__.py']: - mod = __import__('.'.join(['streamline.models', py]), fromlist=[py]) - classes_list = [getattr(mod, x) for x in dir(mod) if isinstance(getattr(mod, x), type)] - for cls in classes_list: - if ('streamline' in str(cls)) and not ('basemodel' in str(cls)): - classes.append(cls) - # logging.warning(classes) - return sorted(classes, key=lambda x: x.model_name) diff --git a/streamline/modeling/modeljob.py b/streamline/modeling/modeljob.py deleted file mode 100644 index 1069d13c..00000000 --- a/streamline/modeling/modeljob.py +++ /dev/null @@ -1,209 +0,0 @@ -import os -import logging -import pickle -import random -import time -import numpy as np -import optuna -import pandas as pd -from sklearn.inspection import permutation_importance -from sklearn.model_selection import StratifiedShuffleSplit - -from streamline.utils.job import Job - - -class ModelJob(Job): - def __init__(self, full_path, output_path, experiment_name, cv_count, class_label="Class", - instance_label=None, scoring_metric='balanced_accuracy', metric_direction='maximize', n_trials=200, - timeout=900, training_subsample=0, uniform_fi=False, save_plot=False, random_state=None): - """ - - Args: - full_path: - output_path: - experiment_name: - cv_count: - class_label: - instance_label: - scoring_metric: - metric_direction: - n_trials: - timeout: - uniform_fi: - save_plot: - random_state: - """ - super().__init__() - self.algorithm = "" - self.output_path = output_path - self.experiment_name = experiment_name - self.class_label = class_label - self.instance_label = instance_label - self.scoring_metric = scoring_metric - self.metric_direction = metric_direction - self.full_path = full_path - self.cv_count = cv_count - self.data_name = self.full_path.split('/')[-1] - self.train_file_path = self.full_path + '/CVDatasets/' + self.data_name \ - + '_CV_' + str(self.cv_count) + '_Train.csv' - self.test_file_path = self.full_path + '/CVDatasets/' + self.data_name \ - + '_CV_' + str(self.cv_count) + '_Test.csv' - - feature_names = pd.read_csv(self.train_file_path).columns.values.tolist() - if self.instance_label is not None: - feature_names.remove(self.instance_label) - feature_names.remove(self.class_label) - self.feature_names = feature_names - - # Argument checks - if not os.path.exists(self.output_path): - raise Exception("Output path must exist (from phase 1) before phase 5 can begin") - if not os.path.exists(self.output_path + '/' + self.experiment_name): - raise Exception("Experiment must exist (from phase 1) before phase 5 can begin") - - self.n_trials = n_trials - self.timeout = timeout - self.training_subsample = training_subsample - self.random_state = random_state - self.uniform_fi = uniform_fi - self.feature_importance = None - self.save_plot = save_plot - self.param_grid = None - - def run(self, model): - """ - - Args: - model: model object - - """ - self.job_start_time = time.time() # for tracking phase runtime - self.algorithm = model.small_name - logging.info('Running ' + str(self.algorithm) + ' on ' + str(self.train_file_path)) - ret = self.run_model(model) - - # Pickle all evaluation metrics for ML model training and evaluation - pickle.dump(ret, open(self.full_path - + '/model_evaluation/pickled_metrics/' - + self.algorithm + '_CV_' + str(self.cv_count) + "_metrics.pickle", 'wb')) - - # Save runtime of ml algorithm training and evaluation - self.save_runtime() - - # Print phase completion - logging.info(self.full_path.split('/')[-1] + " [CV_" + str(self.cv_count) + "] (" + self.algorithm - + ") training complete. ------------------------------------") - experiment_path = '/'.join(self.full_path.split('/')[:-1]) - job_file = open(experiment_path + '/jobsCompleted/job_model_' + self.full_path.split('/')[-1] - + '_' + str(self.cv_count) + '_' + self.algorithm + '.txt', 'w') - job_file.write('complete') - job_file.close() - - def run_model(self, model): - """ - - Args: - model: model object - - Returns: list of metrics [metric_list, fpr, tpr, roc_auc, prec, recall, prec_rec_auc, ave_prec, fi, probas] - - """ - # Set random seeds for reproducibility - random.seed(self.random_state) - np.random.seed(self.random_state) - # Load training and testing datasets separating features from outcome for scikit-learn-based modeling - x_train, y_train, x_test, y_test = self.data_prep() - model.fit(x_train, y_train, self.n_trials, self.timeout, self.feature_names) - if 0 < self.training_subsample < x_train.shape[0] and model.small_name in ['XGB', 'SVM', 'ANN', 'KNN']: - sss = StratifiedShuffleSplit(n_splits=1, train_size=self.training_subsample, random_state=self.random_state) - for train_index, _ in sss.split(x_train, y_train): - x_train = x_train[train_index] - y_train = y_train[train_index] - logging.warning('For ' + model.small_name - + ', training sample reduced to ' + str(x_train.shape[0]) + ' instances') - - if not os.path.exists(self.full_path + '/models/'): - os.makedirs(self.full_path + '/models/') - - if not model.is_single: - if self.save_plot: - try: - fig = optuna.visualization.plot_parallel_coordinate(model.study) - fig.write_image(self.full_path + '/models/' + self.algorithm + - '_ParamOptimization_' + str(self.cv_count) + '.png') - except Exception as e: - logging.warning(str(e)) - logging.warning('Warning: Optuna Optimization Visualization Generation Failed for ' - 'Due to Known Release Issue. ' - 'Please install Optuna 2.0.0 to avoid this issue.') - # Print results and hyperparamter values for best hyperparameter sweep trial - self.export_best_params(self.full_path + '/models/' + self.algorithm + - '_bestparams' + str(self.cv_count) + '.csv', - model.params) - else: # Specify hyperparameter values (no sweep) - self.export_best_params(self.full_path + '/models/' + self.algorithm + - '_usedparams' + str(self.cv_count) + '.csv', - model.params) - - if self.uniform_fi: - results = permutation_importance(model.model, x_train, y_train, n_repeats=10, random_state=self.random_state, - scoring=self.scoring_metric) - self.feature_importance = results.importances_mean - else: - try: - self.feature_importance = model.model.feature_importances_ - except AttributeError: - results = permutation_importance(model.model, x_train, y_train, n_repeats=10, - random_state=self.random_state, - scoring=self.scoring_metric) - self.feature_importance = results.importances_mean - - if not os.path.exists(self.full_path + '/models/pickledModels/'): - os.makedirs(self.full_path + '/models/pickledModels/') - - with open(self.full_path + '/models/pickledModels/' + self.algorithm + - '_' + str(self.cv_count) + '.pickle', 'wb') as file: - pickle.dump(model.model, file) - - metric_list, fpr, tpr, roc_auc, prec, recall, \ - prec_rec_auc, ave_prec, probas_ = model.model_evaluation(x_test, y_test) - fi = self.feature_importance - - return [metric_list, fpr, tpr, roc_auc, prec, recall, prec_rec_auc, ave_prec, fi, probas_] - - def data_prep(self): - """ - Loads target cv training dataset, separates class from features and removes instance labels. - """ - train = pd.read_csv(self.train_file_path) - test = pd.read_csv(self.test_file_path) - if self.instance_label is not None: - train = train.drop(self.instance_label, axis=1) - test = test.drop(self.instance_label, axis=1) - x_train = train.drop(self.class_label, axis=1).values - y_train = train[self.class_label].values - x_test = test.drop(self.class_label, axis=1).values - y_test = test[self.class_label].values - del train # memory cleanup - del test # memory cleanup - return x_train, y_train, x_test, y_test - - def save_runtime(self): - """ - Save ML algorithm training and evaluation runtime for this phase. - """ - runtime_file = open(self.full_path + '/runtime/runtime_' + self.algorithm + '_CV' + str(self.cv_count) + '.txt', - 'w') - runtime_file.write(str(time.time() - self.job_start_time)) - runtime_file.close() - - @staticmethod - def export_best_params(file_name, param_grid): - """ - Exports the best hyperparameter scores to output file. - """ - best_params_copy = param_grid - for best in best_params_copy: - best_params_copy[best] = [best_params_copy[best]] - df = pd.DataFrame.from_dict(best_params_copy) - df.to_csv(file_name, index=False) diff --git a/streamline/modeling/parameters.py b/streamline/modeling/parameters.py deleted file mode 100644 index 324284f9..00000000 --- a/streamline/modeling/parameters.py +++ /dev/null @@ -1,141 +0,0 @@ -parameters = {'Naive Bayes': {}, - 'Logistic Regression': {'penalty': ['l2', 'l1'], - 'C': [1e-05, 100000.0], - 'dual': [True, False], - 'solver': ['newton-cg', 'lbfgs', 'liblinear', 'sag', 'saga'], - 'class_weight': [None, 'balanced'], - 'max_iter': [10, 1000]}, - 'Decision Tree': {'criterion': ['gini', 'entropy'], - 'splitter': ['best', 'random'], - 'max_depth': [1, 30], - 'min_samples_split': [2, 50], - 'min_samples_leaf': [1, 50], - 'max_features': [None, 'auto', 'log2'], - 'class_weight': [None, 'balanced']}, - 'Random Forest': {'n_estimators': [10, 1000], - 'criterion': ['gini', 'entropy'], - 'max_depth': [1, 30], - 'min_samples_split': [2, 50], - 'min_samples_leaf': [1, 50], - 'max_features': [None, 'auto', 'log2'], - 'bootstrap': [True], - 'oob_score': [False, True], - 'class_weight': [None, 'balanced']}, - 'Gradient Boosting': {'n_estimators': [10, 1000], - 'loss': ['deviance', 'exponential'], - 'learning_rate': [0.0001, 0.3], - 'min_samples_leaf': [1, 50], - 'min_samples_split': [2, 50], - 'max_depth': [1, 30]}, - 'Extreme Gradient Boosting': {'booster': ['gbtree'], - 'objective': ['binary:logistic'], - 'verbosity': [0], - 'reg_lambda': [1e-08, 1.0], - 'alpha': [1e-08, 1.0], - 'eta': [1e-08, 1.0], - 'gamma': [1e-08, 1.0], - 'max_depth': [1, 30], - 'grow_policy': ['depthwise', 'lossguide'], - 'n_estimators': [10, 1000], - 'min_samples_split': [2, 50], - 'min_samples_leaf': [1, 50], - 'subsample': [0.5, 1.0], - 'min_child_weight': [0.1, 10], - 'colsample_bytree': [0.1, 1.0], - 'nthread': [1]}, - 'Light Gradient Boosting': {'objective': ['binary'], - 'metric': ['binary_logloss'], - 'verbosity': [-1], - 'boosting_type': ['gbdt'], - 'num_leaves': [2, 256], - 'max_depth': [1, 30], - 'reg_alpha': [1e-08, 10.0], - 'reg_lambda': [1e-08, 10.0], - 'colsample_bytree': [0.4, 1.0], - 'subsample': [0.4, 1.0], - 'subsample_freq': [1, 7], - 'min_child_samples': [5, 100], - 'n_estimators': [10, 1000], - 'num_threads': [1]}, - 'Category Gradient Boosting': {'learning_rate': [0.0001, 0.3], - 'iterations': [10, 500], - 'depth': [1, 10], - 'l2_leaf_reg': [1, 9], - 'loss_function': ['Logloss'], - 'verbose': [False]}, - 'Support Vector Machine': {'kernel': ['linear', 'poly', 'rbf'], - 'C': [0.1, 1000], - 'gamma': ['scale'], - 'degree': [1, 6], - 'probability': [True], - 'class_weight': [None, 'balanced']}, - 'Artificial Neural Network': {'n_layers': [1, 3], - 'layer_size': [1, 100], - 'activation': ['identity', 'logistic', 'tanh', 'relu'], - 'learning_rate': ['constant', 'invscaling', 'adaptive'], - 'momentum': [0.1, 0.9], - 'solver': ['sgd', 'adam'], - 'batch_size': ['auto'], - 'alpha': [0.0001, 0.05], - 'max_iter': [200]}, - 'K-Nearest Neighbors': {'n_neighbors': [1, 100], - 'weights': ['uniform', 'distance'], - 'p': [1, 5], - 'metric': ['euclidean', 'minkowski']}, - 'Genetic Programming': {'population_size': [100, 1000], - 'generations': [10, 500], - 'tournament_size': [3, 50], - 'init_method': ['grow', 'full', 'half and half'], - 'function_set': [['add', 'sub', 'mul', 'div'], - ['add', - 'sub', - 'mul', - 'div', - 'sqrt', - 'log', - 'abs', - 'neg', - 'inv', - 'max', - 'min'], - ['add', - 'sub', - 'mul', - 'div', - 'sqrt', - 'log', - 'abs', - 'neg', - 'inv', - 'max', - 'min', - 'sin', - 'cos', - 'tan']], - 'parsimony_coefficient': [0.001, 0.01], - 'low_memory': [True]}, - - # eLCS - "eLCS": {'learning_iterations': [100000, 200000, 500000], 'N': [1000, 2000, 5000], - 'nu': [1, 10], }, - # XCS - "XCS": {'learning_iterations': [100000, 200000, 500000], 'N': [1000, 2000, 5000], - 'nu': [1, 10], }, - # ExSTraCS - "ExSTraCS": {'learning_iterations': [100000, 200000, 500000], 'N': [1000, 2000, 5000], - 'nu': [1, 10], - 'rule_compaction': [None, 'QRF'], - 'expert_knowledge': [None, ]} - } - - -def get_parameters(algorithm_name): - """ - Get default model parameter range by model name - Args: - algorithm_name: name of model - - Returns: default parameter grid as dict - - """ - return parameters[algorithm_name] diff --git a/streamline/modeling/utils.py b/streamline/modeling/utils.py deleted file mode 100644 index 87c52ed8..00000000 --- a/streamline/modeling/utils.py +++ /dev/null @@ -1,86 +0,0 @@ -import os -import pickle -import logging -import pandas as pd -import multiprocessing -from streamline.modeling.load_models import load_class_from_folder - -num_cores = int(os.environ.get('SLURM_CPUS_PER_TASK', multiprocessing.cpu_count())) - -SUPPORTED_MODELS_OBJ = load_class_from_folder() - -SUPPORTED_MODELS = [m.model_name for m in SUPPORTED_MODELS_OBJ] - -# logging.warning(SUPPORTED_MODELS) - - -SUPPORTED_MODELS_SMALL = [m.small_name for m in SUPPORTED_MODELS_OBJ] - -COLOR_LIST = [m.color for m in SUPPORTED_MODELS_OBJ] - -MODEL_DICT = dict(zip(SUPPORTED_MODELS + SUPPORTED_MODELS_SMALL, - SUPPORTED_MODELS_OBJ + SUPPORTED_MODELS_OBJ)) - -LABELS = dict(zip(SUPPORTED_MODELS + SUPPORTED_MODELS_SMALL, - SUPPORTED_MODELS + SUPPORTED_MODELS)) - -ABBREVIATION = dict(zip(SUPPORTED_MODELS, SUPPORTED_MODELS_SMALL)) - -COLORS = dict(zip(SUPPORTED_MODELS, COLOR_LIST)) - - -def is_supported_model(string): - try: - return LABELS[string] - except KeyError: - raise Exception("Unknown Model") - - -def model_str_to_obj(string): - assert is_supported_model(string) - return MODEL_DICT[string] - - -def get_fi_for_ExSTraCS(output_path, experiment_name, dataset_name, class_label, instance_label, - cv, filter_poor_features): - """ - For ExSTraCS, gets the MultiSURF (or MI if MS not available) FI scores for the feature subset being analyzed - here in modeling - """ - scores = [] # to be filled in, in fitted dataset order. - full_path = output_path + '/' + experiment_name + '/' + dataset_name - # If MultiSURF was done previously - if os.path.exists(full_path + "/feature_selection/multisurf/pickledForPhase4/"): - algorithm_label = 'multisurf' - elif os.path.exists(full_path + "/feature_selection/mutual_information/pickledForPhase4/"): - # If MI was done previously and MS wasn't: - algorithm_label = 'mutual_information' - else: - scores = None - return scores - - if filter_poor_features: - # obtain feature importance scores for feature subset analyzed (in correct training dataset order) - # Load current data ordered_feature_names - header = pd.read_csv( - full_path + '/CVDatasets/' + dataset_name + '_CV_' + str(cv) + '_Test.csv').columns.values.tolist() - if instance_label is not None: - header.remove(instance_label) - header.remove(class_label) - # Load original dataset multisurf scores - score_info = full_path + "/feature_selection/" + algorithm_label + "/pickledForPhase4/" + str(cv) + '.pickle' - file = open(score_info, 'rb') - raw_data = pickle.load(file) - file.close() - score_dict = raw_data[1] - # Generate filtered multisurf score list with same order as working datasets - for each in header: - scores.append(score_dict[each]) - else: # obtain feature importance scores for all features (i.e. no feature selection was conducted) - # Load original dataset multisurf scores - score_info = full_path + "/feature_selection/" + algorithm_label + "/pickledForPhase4/" + str(cv) + '.pickle' - file = open(score_info, 'rb') - raw_data = pickle.load(file) - file.close() - scores = raw_data[0] - return scores diff --git a/streamline/models/TODO_Model_Readme.txt b/streamline/models/TODO_Model_Readme.txt deleted file mode 100644 index d3f5a12f..00000000 --- a/streamline/models/TODO_Model_Readme.txt +++ /dev/null @@ -1 +0,0 @@ - diff --git a/streamline/models/__init__.py b/streamline/models/__init__.py deleted file mode 100644 index 713d47b9..00000000 --- a/streamline/models/__init__.py +++ /dev/null @@ -1,8 +0,0 @@ -import glob -from os.path import dirname, basename, isfile, join -from pathlib import Path - -name = __name__ -modules = glob.glob(join(dirname(__file__), "*.py")) -modules = [str(Path(path)) for path in modules] -__all__ = [basename(f)[:-3] for f in modules if isfile(f) and not f.endswith('__init__.py')] diff --git a/streamline/old_versions/p11_reporting/dashboard_app.py b/streamline/old_versions/p11_reporting/dashboard_app.py new file mode 100644 index 00000000..d5726b8f --- /dev/null +++ b/streamline/old_versions/p11_reporting/dashboard_app.py @@ -0,0 +1,657 @@ +# streamline/reporting/dashboard_app.py + +from __future__ import annotations + +import json +import os +import numpy as np +from pathlib import Path +from typing import Dict, List, Optional + +import pandas as pd +import plotly.express as px +import plotly.graph_objects as go +import streamlit as st + + +# ------------------------------------------------------------------- +# Helpers +# ------------------------------------------------------------------- +def safe_read_csv(path: Path, **kwargs) -> Optional[pd.DataFrame]: + try: + if path.is_file(): + return pd.read_csv(path, **kwargs) + except Exception as e: + st.warning(f"Failed to read CSV: {path} ({e})") + return None + + +def safe_read_json(path: Path) -> Optional[dict]: + try: + if path.is_file(): + with path.open("r") as f: + return json.load(f) + except Exception as e: + st.warning(f"Failed to read JSON: {path} ({e})") + return None + + +def discover_datasets(exp_root: Path) -> List[Path]: + """Return dataset folders (have CVDatasets).""" + if not exp_root.is_dir(): + return [] + ds = [] + for p in sorted(exp_root.iterdir()): + if p.is_dir() and (p / "CVDatasets").is_dir(): + ds.append(p) + return ds + + +# ------------------------------------------------------------------- +# Phase 1–2: exploratory / preprocessing +# ------------------------------------------------------------------- +def render_phase12_exploratory(ds_dir: Path): + st.subheader("Phase 1: Exploratory Analysis") + + exp_dir = ds_dir / "exploratory" + if not exp_dir.is_dir(): + st.info("No exploratory outputs found for this dataset.") + return + + # 1) Class counts + class_counts = safe_read_csv(exp_dir / "ClassCounts.csv") + if class_counts is not None and {"Class", "Count"}.issubset(class_counts.columns): + fig = px.bar( + class_counts, + x="Class", + y="Count", + title="Class Distribution", + ) + st.plotly_chart(fig, use_container_width=True) + + # 2) Missingness + missing = safe_read_csv(exp_dir / "DataMissingness.csv") + if missing is not None and {"Variable", "Count"}.issubset(missing.columns): + fig = px.bar( + missing.sort_values("Count", ascending=False), + x="Variable", + y="Count", + title="Missingness Count in Dataset", + ) + fig.update_layout(xaxis_tickangle=-45) + st.plotly_chart(fig, use_container_width=True) + else: + st.info("Could not infer feature / missingness columns from DataMissingness.csv.") + + # 3) Correlation heatmap + corr_csv = exp_dir / "FeatureCorrelations.csv" + df_corr = safe_read_csv(corr_csv) + if df_corr is not None and not df_corr.empty: + st.subheader("Feature correlation heatmap") + try: + # Assume wide correlation matrix with feature names in first column and header + mat = df_corr.set_index(df_corr.columns[0]) + fig = px.imshow( + mat, + color_continuous_scale="RdBu", + zmin=-1, + zmax=1, + title="Feature correlation (Phase 1)", + + ) + fig.layout.update( + width=800, height=800, + xaxis_showgrid=False, + yaxis_showgrid=False, + yaxis_autorange='reversed', + dragmode='pan', + ) + fig.update_xaxes(type='category') + fig.update_yaxes(type='category') + + st.plotly_chart(fig, use_container_width=False, config = {'scrollZoom': True}) + except Exception as e: + st.warning(f"Could not build correlation heatmap from {corr_csv.name}: {e}") + + # 4) Univariate significance + uni_dir = exp_dir / "univariate_analyses" + uni = safe_read_csv(uni_dir / "Univariate_Significance.csv") + if uni is not None and {"Feature", "p_value"}.issubset(uni.columns): + fig = px.bar( + uni.sort_values("p_value"), + x="Feature", + y="p_value", + title="Univariate Significance (sorted by p-value)", + ) + fig.update_layout(xaxis_tickangle=-45) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 3: feature learning +# ------------------------------------------------------------------- +def render_phase3_feature_learning(ds_dir: Path): + st.subheader("Phase 3: Feature Learning") + + fl_dir = ds_dir / "feature_learning" + if not fl_dir.is_dir(): + st.info("No feature learning outputs found.") + return + + # Count engineered features per CV from feature_manifest_cv*.json + rows = [] + for p in sorted(fl_dir.glob("feature_manifest_cv*.json")): + manifest = safe_read_json(p) + if not manifest: + continue + cv_id = p.stem.replace("feature_manifest_", "") + # Try some generic keys, fallback to len of feature list if present + n_feat = manifest.get("n_features") or manifest.get("num_features") + if n_feat is None: + feats = manifest.get("features") or manifest.get("feature_list") + if isinstance(feats, list): + n_feat = len(feats) + if n_feat is not None: + rows.append({"cv": cv_id, "n_features": n_feat}) + + if rows: + df = pd.DataFrame(rows) + fig = px.bar( + df, + x="cv", + y="n_features", + title="Number of Learned Features per CV Fold", + ) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 4–5: feature importance & selection +# ------------------------------------------------------------------- +def render_phase45_feature_importance(ds_dir: Path): + st.subheader("Phase 4–5: Feature Importance & Selection") + + fi_phase_dir = ds_dir / "feature_importance" + sel_dir = ds_dir / "feature_selection" + + # P4: MultiSURF & Mutual information (top mean scores) + ms_dir = fi_phase_dir / "multisurf" + mi_dir = fi_phase_dir / "mutualinformation" + + def _aggregate_fi_scores(root: Path, label: str) -> Optional[pd.DataFrame]: + if not root.is_dir(): + return None + frames = [] + for p in sorted(root.glob("*_scores_cv_*.csv")): + df = safe_read_csv(p) + if df is None: + continue + cv = p.stem.split("_cv_")[-1] + if "Feature" in df.columns and "Score" in df.columns: + df = df[["Feature", "Score"]].copy() + df["cv"] = cv + frames.append(df) + if not frames: + return None + all_scores = pd.concat(frames, ignore_index=True) + agg = all_scores.groupby("Feature")["Score"].mean().reset_index() + agg["method"] = label + return agg + + ms_agg = _aggregate_fi_scores(ms_dir, "MultiSURF") + mi_agg = _aggregate_fi_scores(mi_dir, "Mutual Information") + + agg_all = None + if ms_agg is not None and mi_agg is not None: + agg_all = pd.concat([ms_agg, mi_agg], ignore_index=True) + elif ms_agg is not None: + agg_all = ms_agg + elif mi_agg is not None: + agg_all = mi_agg + + if agg_all is not None: + top = ( + agg_all.sort_values("Score", ascending=False) + .groupby("method") + .head(20) + ) + fig = px.bar( + top, + x="Feature", + y="Score", + color="method", + barmode="group", + title="Global Feature Importance (Phase 4)", + ) + fig.update_layout(xaxis_tickangle=-45) + st.plotly_chart(fig, use_container_width=True) + + # P5: Informative feature summary + if sel_dir.is_dir(): + info = safe_read_csv(sel_dir / "InformativeFeatureSummary.csv") + if info is not None and "Feature" in info.columns: + # Use any importance/score-like columns if present + score_cols = [ + c + for c in info.columns + if c.lower().startswith("score") + or "importance" in c.lower() + or "rank" in c.lower() + ] + if score_cols: + col = score_cols[0] + top_sel = info.sort_values(col, ascending=False).head(20) + fig = px.bar( + top_sel, + x="Feature", + y=col, + title=f"Selected Features (Phase 5) – {col}", + ) + fig.update_layout(xaxis_tickangle=-45) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 6: modeling +# ------------------------------------------------------------------- +def render_phase6_modeling(ds_dir: Path): + st.subheader("Phase 6: Base Models") + + me_dir = ds_dir / "model_evaluation" + if not me_dir.is_dir(): + st.info("No model_evaluation folder found.") + return + + summary_mean = safe_read_csv(me_dir / "Summary_performance_mean.csv", index_col=0) + if summary_mean is not None: + summary_mean = summary_mean.reset_index().rename(columns={"index": "Model"}) + # Melt for metric comparison + df_long = summary_mean.melt( + id_vars="Model", + var_name="Metric", + value_name="Score", + ) + fig = px.bar( + df_long, + x="Model", + y="Score", + color="Metric", + barmode="group", + title="Mean CV Performance per Model", + ) + st.plotly_chart(fig, use_container_width=True) + + # Per-CV performance (metrics_by_cv JSON) + metrics_dir = me_dir / "metrics_by_cv" + if metrics_dir.is_dir(): + rows = [] + for p in sorted(metrics_dir.glob("*.json")): + m = safe_read_json(p) + if not m: + continue + base = p.stem # e.g., LR_CV_0 + try: + model_id, cv_id = base.split("_CV_") + except ValueError: + continue + # assume flat dict of metrics + for metric, val in m.items(): + if isinstance(val, (int, float)): + rows.append( + { + "Model": model_id, + "CV": cv_id, + "Metric": metric, + "Score": float(val), + } + ) + if rows: + df = pd.DataFrame(rows) + metric_sel = st.selectbox( + "Metric (Phase 6 CV performance)", + sorted(df["Metric"].unique()), + key=f"p6_metric_{ds_dir.name}", + ) + sub = df[df["Metric"] == metric_sel] + fig = px.line( + sub, + x="CV", + y="Score", + color="Model", + markers=True, + title=f"Per-CV {metric_sel} by Model", + ) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 7: ensembles +# ------------------------------------------------------------------- +def render_phase7_ensembles(ds_dir: Path): + st.subheader("Phase 7: Ensembles") + + ens_dir = ds_dir / "ensemble_evaluation" + if not ens_dir.is_dir(): + st.info("No ensemble_evaluation folder found.") + return + + summary_mean = safe_read_csv(ens_dir / "Ensembles_performance_mean.csv", index_col=0) + if summary_mean is not None: + summary_mean = summary_mean.reset_index().rename(columns={"index": "Ensemble"}) + df_long = summary_mean.melt( + id_vars="Ensemble", + var_name="Metric", + value_name="Score", + ) + fig = px.bar( + df_long, + x="Ensemble", + y="Score", + color="Metric", + barmode="group", + title="Mean CV Performance per Ensemble", + ) + st.plotly_chart(fig, use_container_width=True) + + # Per-CV ensemble metrics + cv_dir = ens_dir / "metrics_by_cv" + if cv_dir.is_dir(): + rows = [] + for p in sorted(cv_dir.glob("*.json")): + m = safe_read_json(p) + if not m: + continue + base = p.stem # e.g., HEV_CV_0 + try: + ens_id, cv_id = base.split("_CV_") + except ValueError: + continue + for metric, val in m.items(): + if isinstance(val, (int, float)): + rows.append( + { + "Ensemble": ens_id, + "CV": cv_id, + "Metric": metric, + "Score": float(val), + } + ) + if rows: + df = pd.DataFrame(rows) + metric_sel = st.selectbox( + "Metric (Phase 7 CV performance)", + sorted(df["Metric"].unique()), + key=f"p7_metric_{ds_dir.name}", + ) + sub = df[df["Metric"] == metric_sel] + fig = px.line( + sub, + x="CV", + y="Score", + color="Ensemble", + markers=True, + title=f"Per-CV {metric_sel} by Ensemble", + ) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 8: summary statistics +# ------------------------------------------------------------------- +def render_phase8_stats(ds_dir: Path): + st.subheader("Phase 8: Statistics & Model Comparisons") + + me_dir = ds_dir / "model_evaluation" + if not me_dir.is_dir(): + st.info("No model_evaluation folder for stats.") + return + + # Metric comparison boxplots built from Summary_performance_mean + summary_mean = safe_read_csv(me_dir / "Summary_performance_mean.csv", index_col=0) + if summary_mean is not None: + summary_mean = summary_mean.reset_index().rename(columns={"index": "Model"}) + metric_sel = st.selectbox( + "Metric for model comparison (Phase 8)", + [c for c in summary_mean.columns if c != "Model"], + key=f"p8_metric_{ds_dir.name}", + ) + sub = summary_mean[["Model", metric_sel]] + fig = px.box( + sub, + x="Model", + y=metric_sel, + points="all", + title=f"Model Comparison for {metric_sel}", + ) + st.plotly_chart(fig, use_container_width=True) + + # Statistical tests (Mann-Whitney / Wilcoxon) present under statistical_comparisons + stats_dir = me_dir / "statistical_comparisons" + if stats_dir.is_dir(): + mw_files = sorted(stats_dir.glob("MannWhitneyU_*.csv")) + if mw_files: + mw_file = st.selectbox( + "Mann-WhitneyU result file", + mw_files, + format_func=lambda p: p.name, + key=f"p8_mw_{ds_dir.name}", + ) + df = safe_read_csv(mw_file) + if df is not None and {"Model1", "Model2", "P-Value"}.issubset(df.columns): + sig = df[df["P-Value"] < 0.05] + if not sig.empty: + fig = px.scatter( + sig, + x="Model1", + y="Model2", + size="-log10(P-Value)" if "-log10(P-Value)" in sig.columns else "P-Value", + color="P-Value", + title="Significant Pairwise Differences (Mann-WhitneyU)", + ) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 9: dataset comparisons (experiment-level) +# ------------------------------------------------------------------- +def render_phase9_dataset_comparisons(exp_root: Path): + st.subheader("Phase 9: Dataset Comparisons") + + dc_dir = exp_root / "DatasetComparisons" + if not dc_dir.is_dir(): + st.info("No DatasetComparisons folder at experiment root.") + return + + # 1) BestCompare_KruskalWallis summary + best_kw = safe_read_csv(dc_dir / "BestCompare_KruskalWallis.csv") + if best_kw is not None: + metric = st.selectbox( + "Metric (BestCompare Kruskal-Wallis)", + [m for m in best_kw.index] if isinstance(best_kw.index, pd.Index) else best_kw["Metric"].unique(), + key="p9_metric_kw", + ) + row = best_kw.loc[metric] + cols = [c for c in best_kw.columns if c.startswith("Mean_D")] + data = [] + for i, c in enumerate(cols, start=1): + data.append( + { + "DatasetIdx": f"D{i}", + "MeanScore": float(row[c]) if pd.notnull(row[c]) else None, + "BestAlg": row.get(f"Best_Alg_D{i}", None), + } + ) + df = pd.DataFrame(data).dropna(subset=["MeanScore"]) + if not df.empty: + fig = px.bar( + df, + x="DatasetIdx", + y="MeanScore", + color="BestAlg", + title=f"Best Algorithm per Dataset – {metric}", + ) + st.plotly_chart(fig, use_container_width=True) + + # 2) Global Mann-Whitney & Wilcoxon across datasets + for label, fname in [ + ("Mann-Whitney Across Datasets", "MannWhitney_all.csv"), + ("Wilcoxon Rank Across Datasets", "WilcoxonRank_all.csv"), + ]: + df = safe_read_csv(dc_dir / fname) + if df is not None and {"Metric", "Data1", "Data2", "P-Value"}.issubset(df.columns): + st.markdown(f"#### {label}") + sig = df[df["P-Value"] < 0.05].copy() + if sig.empty: + st.write("No significant differences at p < 0.05.") + continue + sig["pair"] = sig["Data1"].astype(str) + " vs " + sig["Data2"].astype(str) + fig = px.scatter( + sig, + x="Metric", + y="pair", + size=-np.log10(sig["P-Value"]) if "np" in globals() else sig["P-Value"], + color="P-Value", + title=f"Significant Dataset Pairs ({label})", + ) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Reporting phase (Phase 11) artifacts +# ------------------------------------------------------------------- +def render_phase11_reporting(exp_root: Path): + st.subheader("Phase 11: Reporting") + + rep_dir = exp_root / "reporting" + if not rep_dir.is_dir(): + st.info("No reporting folder found.") + return + + html_path = rep_dir / "report.html" + pdf_path = rep_dir / "report.pdf" + if html_path.is_file(): + st.markdown(f"[Download HTML report]({html_path.as_posix()})") + if pdf_path.is_file(): + st.markdown(f"[Download PDF report]({pdf_path.as_posix()})") + + + report_data = safe_read_json(rep_dir / "report_data.json") + if report_data: + st.json(report_data) + +# ------------------------------------------------------------------- +# Phase runtimes per dataset +# ------------------------------------------------------------------- +def render_runtimes(ds_dir: Path): + st.subheader("Phase Runtimes (per dataset)") + + rt_csv = safe_read_csv(ds_dir / "runtimes.csv") + if rt_csv is not None and {"Phase", "RuntimeSeconds"}.issubset(rt_csv.columns): + fig = px.bar( + rt_csv, + x="Phase", + y="RuntimeSeconds", + title="Runtime per Phase", + ) + fig.update_layout(xaxis_tickangle=-45) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Main app +# ------------------------------------------------------------------- +def main(): + st.set_page_config(page_title="STREAMLINE Experiment Dashboard", layout="wide") + + st.title("STREAMLINE Experiment Dashboard") + + default_root = "out/DemoRun" + exp_root_str = st.sidebar.text_input( + "Experiment root path", + value=default_root, + help="Top-level folder containing dataset subfolders, DatasetComparisons, reporting, etc.", + ) + exp_root = Path(exp_root_str).expanduser().resolve() + + st.sidebar.write(f"Using experiment root: `{exp_root}`") + + if not exp_root.is_dir(): + st.error("Experiment root does not exist.") + return + + datasets = discover_datasets(exp_root) + if not datasets: + st.error("No dataset subfolders with CVDatasets found under this experiment root.") + return + + ds_names = [d.name for d in datasets] + selected_ds_names = st.sidebar.multiselect( + "Datasets to display", + ds_names, + default=ds_names, + ) + selected_ds = [d for d in datasets if d.name in selected_ds_names] + + if not selected_ds: + st.warning("No datasets selected.") + return + + top_tabs = st.tabs( + [ + "Per-dataset (P1–P8)", + "Dataset Comparisons (P9)", + "Reporting (P11)", + ] + ) + + # ------------------------------ + # Tab 1: per-dataset dashboard + # ------------------------------ + with top_tabs[0]: + st.header("Per-dataset Dashboard") + + # One accordion per dataset, each with phase tabs + for ds in selected_ds: + with st.expander(f"Dataset: {ds.name}", expanded=(len(selected_ds) == 1)): + phase_tabs = st.tabs( + [ + "Exploratory (P1–P2)", + "Feature Learning (P3)", + "Feature Importance/Selection (P4–P5)", + "Modeling (P6)", + "Ensembles (P7)", + "Summary Stats (P8)", + "Runtimes", + ] + ) + + with phase_tabs[0]: + render_phase12_exploratory(ds) + with phase_tabs[1]: + render_phase3_feature_learning(ds) + with phase_tabs[2]: + render_phase45_feature_importance(ds) + with phase_tabs[3]: + render_phase6_modeling(ds) + with phase_tabs[4]: + render_phase7_ensembles(ds) + with phase_tabs[5]: + render_phase8_stats(ds) + with phase_tabs[6]: + render_runtimes(ds) + + # ------------------------------ + # Tab 2: experiment-level dataset comparisons + # ------------------------------ + with top_tabs[1]: + render_phase9_dataset_comparisons(exp_root) + + # ------------------------------ + # Tab 3: reporting artifacts + # ------------------------------ + with top_tabs[2]: + render_phase11_reporting(exp_root) + + +if __name__ == "__main__": + main() diff --git a/streamline/old_versions/p11_reporting/p11_cli.py b/streamline/old_versions/p11_reporting/p11_cli.py new file mode 100644 index 00000000..2c2709f7 --- /dev/null +++ b/streamline/old_versions/p11_reporting/p11_cli.py @@ -0,0 +1,47 @@ +from __future__ import annotations + +import argparse +import logging + +from streamline.p11_reporting.p11_runner import P11Runner + +logging.basicConfig(level=logging.INFO) + + +def main(): + ap = argparse.ArgumentParser( + "STREAMLINE Phase 11 (Reporting)", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + ap.add_argument("--output_path", required=True) + ap.add_argument("--experiment_name", required=True) + ap.add_argument("--outcome_label", default="Class") + ap.add_argument("--outcome_type", default="Binary") + ap.add_argument("--instance_label", default=None) + ap.add_argument("--make_pdf", type=int, default=1, + help="1 to generate PDF via WeasyPrint if available; 0 to skip.") + ap.add_argument( + "--run_cluster", + default="Serial", + help="Serial | Local | BashSLURM | BashLSF | ", + ) + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", type=int, default=4) + args = ap.parse_args() + + job = P11Runner( + output_path=args.output_path, + experiment_name=args.experiment_name, + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + instance_label=args.instance_label, + make_pdf=bool(args.make_pdf), + run_cluster=args.run_cluster, + queue=args.queue, + reserved_memory=args.reserved_memory, + ) + job.run() + + +if __name__ == "__main__": + main() diff --git a/streamline/old_versions/p11_reporting/p11_jobsubmit.py b/streamline/old_versions/p11_reporting/p11_jobsubmit.py new file mode 100644 index 00000000..0e1fdc8c --- /dev/null +++ b/streamline/old_versions/p11_reporting/p11_jobsubmit.py @@ -0,0 +1,101 @@ +from __future__ import annotations + +import argparse + +from streamline.p11_reporting.p11_runner import P11Runner + + +def _none_if_empty(val: str | None) -> str | None: + """ + Normalize 'empty-ish' CLI values back to None. + """ + if val is None: + return None + val_str = str(val).strip() + if val_str == "" or val_str.lower() in {"none", "null"}: + return None + return val_str + + +def main(): + """ + Entry point for Phase 10 reporting when launched on a compute node + via a SLURM/LSF bash wrapper. + + This script intentionally forces run_cluster="Serial"; the parallelism is + handled by the scheduler that launched this process. + """ + ap = argparse.ArgumentParser( + "STREAMLINE Phase 10 (Reporting)", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + + ap.add_argument("--output_path", required=True, help="Top-level output directory") + ap.add_argument("--experiment_name", required=True, help="Experiment folder name") + + ap.add_argument("--outcome_label", default="Class") + ap.add_argument( + "--outcome_type", + default="Binary", + choices=["Binary", "Multiclass", "Continuous"], + help="Outcome type to drive metric/plot selection in the report", + ) + ap.add_argument( + "--instance_label", + default=None, + help="Optional instance ID column used in earlier phases", + ) + + ap.add_argument( + "--report_name", + default="STREAMLINE_Report", + help="Base name for the generated report (HTML/PDF)", + ) + + ap.add_argument( + "--sig_cutoff", + type=float, + default=0.05, + help="Significance cutoff used when annotating stats in the report", + ) + + ap.add_argument( + "--show_plots", + type=int, + default=0, + help="1 = keep Streamlit UI open / debug locally; 0 = non-interactive export only", + ) + + ap.add_argument( + "--run_cluster", + default="Serial", + help="Serial | Local | BashSLURM | BashLSF | ", + ) + + ap.add_argument( + "--make_pdf", + type=int, + default=1, + help="1 = export PDF; 0 = skip PDF", + ) + + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", type=int, default=4) + + args = ap.parse_args() + + P11Runner( + output_path=args.output_path, + experiment_name=args.experiment_name, + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + instance_label=args.instance_label, + make_pdf=bool(args.make_pdf), + run_cluster=args.run_cluster, + queue=args.queue, + reserved_memory=args.reserved_memory, + ).run() + + +if __name__ == "__main__": + main() diff --git a/streamline/old_versions/p11_reporting/p11_runner.py b/streamline/old_versions/p11_reporting/p11_runner.py new file mode 100644 index 00000000..a3b0bad7 --- /dev/null +++ b/streamline/old_versions/p11_reporting/p11_runner.py @@ -0,0 +1,144 @@ +# streamline/p10_reporting/p10_runner.py +from __future__ import annotations + +import os +import time +from pathlib import Path +from typing import Optional + +import dask +from dask.distributed import Client, LocalCluster + +from streamline.utils.cluster import get_cluster +from streamline.utils.runners import num_cores +from streamline.p11_reporting.reporting import ReportPhaseJob + + +class P11Runner: + """ + Phase 10 Runner: experiment-level HTML/PDF reporting (all datasets, models, ensembles). + This is a single job per experiment (not per dataset), similar to P9Runner. + """ + + def __init__( + self, + output_path: str, + experiment_name: str, + outcome_label: str = "Class", + outcome_type: str = "Binary", + instance_label: Optional[str] = None, + make_pdf: bool = True, + # micro_average: str = "micro", # "micro" or "macro", passed through to plots, all are micro by default + # include_ensembles: bool = True, # Whether to include ensemble results in the report, always True for now + run_cluster: str = "Serial", # Serial | Local | BashSLURM | BashLSF | + queue: str = "defq", + reserved_memory: int = 4, + ): + self.output_path = output_path + self.experiment_name = experiment_name + self.exp_root = Path(output_path) / experiment_name + if not self.exp_root.is_dir(): + raise Exception(f"Experiment folder not found: {self.exp_root}") + + # kwargs handed directly to ReportingPhaseJob + self.kw = dict( + output_path=output_path, + experiment_name=experiment_name, + outcome_label=outcome_label, + outcome_type=outcome_type, + instance_label=instance_label, + make_pdf=make_pdf, + # micro_average=micro_average, + # include_ensembles=bool(include_ensembles), + ) + + self.run_cluster = run_cluster or "Serial" + self.queue = queue + self.reserved_memory = int(reserved_memory) + + # ------------------------------------------------------------------ + # Public entry + # ------------------------------------------------------------------ + def run(self): + """ + Phase 10 is a single experiment-level job (like Phase 9). + """ + if self.run_cluster == "Serial": + self._run_one() + + elif self.run_cluster == "Local": + # Local dask (mainly for dev on multi-core machines) + with LocalCluster(processes=True, n_workers=num_cores, threads_per_worker=1) as cluster: + with Client(cluster) as client: + dask.compute( + [dask.delayed(self._run_one)()], + scheduler=client, + ) + + elif self.run_cluster in ("BashSLURM", "BashLSF"): + # Legacy-style bash script submission for SLURM / LSF + self._submit_bash() + + else: + # Named dask cluster (e.g. a shared HPC scheduler) + client: Client = get_cluster( + self.run_cluster, str(self.exp_root), self.queue, self.reserved_memory + ) + dask.compute( + [dask.delayed(self._run_one)()], + scheduler=client, + ) + + # ------------------------------------------------------------------ + # Internal helpers + # ------------------------------------------------------------------ + def _run_one(self): + ReportPhaseJob(**self.kw).run() + + def _submit_bash(self): + """ + Submit a single experiment-level job via SLURM or LSF, using p10_jobsubmit.py. + Mirrors P9Runner._submit_bash. + """ + job_ref = str(time.time()) + jobs = self.exp_root / "jobs" + logs = self.exp_root / "logs" + os.makedirs(jobs, exist_ok=True) + os.makedirs(logs, exist_ok=True) + + sh = jobs / f"P11_{job_ref}_run.sh" + launcher = "sbatch" if self.run_cluster == "BashSLURM" else "bsub <" + script = Path(__file__).with_name("p11_jobsubmit.py") + + args = [ + "python", + str(script), + "--output_path", self.output_path, + "--experiment_name", self.experiment_name, + "--outcome_label", self.kw["outcome_label"], + "--outcome_type", self.kw["outcome_type"], + "--instance_label", self.kw["instance_label"] or "", + # "--micro_average", self.kw.get("micro_average", "micro"), + # "--include_ensembles", str(int(bool(self.kw.get("include_ensembles", True)))), + ] + arg_str = " ".join(args) + + with open(sh, "w") as f: + f.write("#!/bin/bash\n") + if self.run_cluster == "BashSLURM": + f.write(f"#SBATCH -p {self.queue}\n") + f.write(f"#SBATCH --job-name={job_ref}\n") + f.write(f"#SBATCH --mem={self.reserved_memory}G\n") + f.write(f"#SBATCH -o {logs}/P10_{job_ref}.o\n") + f.write(f"#SBATCH -e {logs}/P10_{job_ref}.e\n") + f.write(f"srun {arg_str}\n") + else: # BashLSF + f.write(f"#BSUB -q {self.queue}\n") + f.write(f"#BSUB -J {job_ref}\n") + f.write(f"#BSUB -R \"rusage[mem={self.reserved_memory}G]\"\n") + f.write(f"#BSUB -M {self.reserved_memory}GB\n") + f.write(f"#BSUB -o {logs}/P10_{job_ref}.o\n") + f.write(f"#BSUB -e {logs}/P10_{job_ref}.e\n") + f.write(f"{arg_str}\n") + + os.system(f"{launcher} {sh}") diff --git a/streamline/old_versions/p11_reporting/reporting.py b/streamline/old_versions/p11_reporting/reporting.py new file mode 100644 index 00000000..fc082caa --- /dev/null +++ b/streamline/old_versions/p11_reporting/reporting.py @@ -0,0 +1,1983 @@ +from __future__ import annotations + +import json +import logging +import math +import pickle +import re +import time +from pathlib import Path +from typing import Any, Dict, List, Optional, Sequence, Tuple, Union + +import pandas as pd +from fpdf import FPDF + +logger = logging.getLogger(__name__) + +Number = Union[int, float] + + +# ============================================================ +# Plot export helper (fallback-only; prefer precomputed PNGs) +# ============================================================ + +def _safe_plotly_to_png(fig, out_path: Path, scale: int = 2) -> bool: + """ + Export a Plotly figure to PNG using kaleido. + + This is a fallback path only: the report prefers precomputed PNGs + already present in the experiment output tree. + """ + try: + import plotly.io as pio # type: ignore + + out_path.parent.mkdir(parents=True, exist_ok=True) + pio.write_image(fig, str(out_path), format="png", scale=scale) + return True + except Exception as e: + logger.warning("Plotly export failed for %s: %r", out_path, e) + return False + + +def _now_iso_local() -> str: + return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) + + +def _try_streamline_version() -> str: + try: + import importlib.metadata as im + + return im.version("streamline") + except Exception: + return "unknown" + + +# ============================================================ +# Precision formatting +# ============================================================ + +def _is_nan(x: Any) -> bool: + try: + return isinstance(x, float) and math.isnan(x) + except Exception: + return False + + +def format_number( + x: Any, + *, + decimals: int = 3, + sci_small: float = 1e-3, + sci_decimals: int = 3, +) -> str: + """ + Canonical formatting for numeric table cells. + + - ints -> "42" + - floats -> fixed decimals unless abs(x) < sci_small (and non-zero), then scientific + - numeric strings -> parsed & formatted + - other strings -> unchanged + """ + if x is None or _is_nan(x): + return "" + + if isinstance(x, bool): + return "True" if x else "False" + + if isinstance(x, int): + return str(x) + + if isinstance(x, float): + if x == 0.0: + return f"{0:.{decimals}f}" + ax = abs(x) + if ax < sci_small: + return f"{x:.{sci_decimals}e}" + return f"{x:.{decimals}f}" + + if isinstance(x, str): + s = x.strip() + if s == "": + return "" + try: + f = float(s) + return format_number(f, decimals=decimals, sci_small=sci_small, sci_decimals=sci_decimals) + except Exception: + return x + + return str(x) + + +# ============================================================ +# Paths +# ============================================================ + +class ReportPaths: + def __init__(self, reporting_dir: Path, data_json: Path, pdf: Path, figures_dir: Path, metadata_txt: Path): + self.reporting_dir = reporting_dir + self.data_json = data_json + self.pdf = pdf + self.figures_dir = figures_dir + self.metadata_txt = metadata_txt + + +# ============================================================ +# Main job +# ============================================================ + +class ReportPhaseJob: + """ + Phase 11: Reporting (FPDF) + + Layout rules: + - Cover page: legacy-style two-column parameter boxes. + - Metadata also written to reporting/metadata.txt (plain text). + + - Per-dataset order: + 1) EDA - Page 1 + - Univariate (only if informative) + - Class Balance + Missingness (grid) + - Cleaning (C) and Engineering (E) Elements (text box) + 1b) Correlation Matrix (full page, if present) + 2) Feature Learning (all FI methods) + 3) Performance (combined models + ensembles; ensemble rows renamed with suffix; no wrap) + 4) Evaluation Results (summary ROC/PRC only; no per-algorithm ROC/PRC pages) + 5) Runtime Summary + + Rendering rules: + - Prefer precomputed PNGs in the experiment output tree. + - Fallback to plotting into reporting/figures only if originals are missing. + - Keep Times / Times New Roman core fonts; sanitize text to ASCII-safe equivalents. + - Do not render any placeholder panels for missing figures (skip silently). + - No em-dashes and no ellipsis in outputs. + """ + + def __init__( + self, + output_path: Optional[str] = None, + experiment_name: Optional[str] = None, + experiment_path: Optional[str] = None, + outcome_label: Optional[str] = None, + outcome_type: Optional[str] = None, + instance_label: Optional[str] = None, + make_pdf: bool = True, + float_decimals: int = 3, + ): + assert (output_path and experiment_name) or experiment_path, ( + "Provide (output_path, experiment_name) or experiment_path." + ) + + if experiment_path: + self.exp_root = Path(experiment_path) + self.output_path = str(self.exp_root.parent) + self.experiment_name = self.exp_root.name + else: + self.output_path = str(output_path) + self.experiment_name = str(experiment_name) + self.exp_root = Path(self.output_path) / self.experiment_name + + if not self.exp_root.is_dir(): + raise FileNotFoundError(f"Experiment folder not found: {self.exp_root}") + + self.title = f"STREAMLINE Testing Data Evaluation Report: {_now_iso_local()}" + + self.make_pdf = make_pdf + self.job_start_time: Optional[float] = None + + self.outcome_label = outcome_label + self.outcome_type = outcome_type + self.instance_label = instance_label + + self.float_decimals = int(float_decimals) + self.paths = self._init_paths() + + def _init_paths(self) -> ReportPaths: + reporting_dir = self.exp_root / "reporting" + figures_dir = reporting_dir / "figures" + reporting_dir.mkdir(exist_ok=True) + figures_dir.mkdir(parents=True, exist_ok=True) + return ReportPaths( + reporting_dir=reporting_dir, + data_json=reporting_dir / "report_data.json", + pdf=reporting_dir / "report.pdf", + figures_dir=figures_dir, + metadata_txt=reporting_dir / "metadata.txt", + ) + + # ---------------------------- + # File readers + # ---------------------------- + def _read_csv_if_exists(self, path: Path) -> Optional[pd.DataFrame]: + try: + if path.is_file(): + return pd.read_csv(path) + except Exception as e: + logger.warning("Failed reading CSV %s: %r", path, e) + return None + + def _read_json_if_exists(self, path: Path) -> Optional[Dict[str, Any]]: + try: + if path.is_file(): + return json.loads(path.read_text()) + except Exception as e: + logger.warning("Failed reading JSON %s: %r", path, e) + return None + + def _read_pickle_if_exists(self, path: Path) -> Optional[Any]: + try: + if path.is_file(): + with path.open("rb") as f: + return pickle.load(f) + except Exception as e: + logger.warning("Failed reading pickle %s: %r", path, e) + return None + + # ---------------------------- + # Utilities: normalize/flatten/merge/pretty print + # ---------------------------- + def _flatten_mapping( + self, + obj: Any, + *, + prefix: str = "", + sep: str = " · ", + max_depth: int = 5, + _depth: int = 0, + ) -> Dict[str, Any]: + out: Dict[str, Any] = {} + if _depth > max_depth: + if prefix: + out[prefix] = str(obj) + return out + + if isinstance(obj, dict): + for k, v in obj.items(): + kk = str(k) + new_prefix = f"{prefix}{sep}{kk}" if prefix else kk + out.update(self._flatten_mapping(v, prefix=new_prefix, sep=sep, max_depth=max_depth, _depth=_depth + 1)) + return out + + if isinstance(obj, (list, tuple)): + if prefix: + out[prefix] = ", ".join(str(x) for x in obj) + return out + + if prefix: + out[prefix] = obj + return out + + def _merge_union_dicts(self, *dicts: Dict[str, Any]) -> Dict[str, Any]: + out: Dict[str, Any] = {} + for d in dicts: + for k, v in (d or {}).items(): + if k not in out: + out[k] = v + else: + if str(out[k]) != str(v): + alt_k = f"{k} (alt)" + i = 2 + while alt_k in out: + alt_k = f"{k} (alt {i})" + i += 1 + out[alt_k] = v + return out + + def _normalize_bool(self, v: Any) -> Optional[bool]: + if isinstance(v, bool): + return v + if isinstance(v, (int, float)) and v in (0, 1): + return bool(v) + if isinstance(v, str): + s = v.strip().lower() + if s in {"true", "t", "yes", "y", "1"}: + return True + if s in {"false", "f", "no", "n", "0"}: + return False + return None + + def _as_compact_str(self, v: Any) -> str: + if v is None: + return "None" + b = self._normalize_bool(v) + if b is not None: + return "True" if b else "False" + if isinstance(v, (int, float)): + return format_number(v, decimals=self.float_decimals) + if isinstance(v, (list, tuple)): + return "[" + ", ".join(str(x) for x in v) + "]" + return str(v) + + def _is_timestampy_key(self, k: str) -> bool: + s = k.lower() + if any(x in s for x in ["generated_at", "generated at", "epoch", "timestamp", "time stamp"]): + return True + if re.search(r"\b20\d{2}[-_/]\d{2}[-_/]\d{2}\b", s): + return True + if re.search(r"\b\d{2}:\d{2}:\d{2}\b", s): + return True + return False + + def _pretty_cover_key(self, k: str) -> str: + parts = [p.strip() for p in str(k).split("·")] + last = parts[-1] if parts else str(k) + last = last.strip().replace("_", " ") + last = re.sub(r"\s+", " ", last).strip() + return last + + def _should_drop_identifier_code(self, k: str) -> bool: + s = k.lower() + return any(x in s for x in ["identifier code", "identifier_code", "run id", "run_id", "uuid", "guid", "hash", "job id", "job_id"]) + + def _write_metadata_text(self, *, cover_boxes: Dict[str, List[Tuple[str, str]]], enriched_meta: Dict[str, Any]) -> None: + lines: List[str] = [] + lines.append(self.title) + lines.append(f"Experiment Root: {self.exp_root}") + lines.append(f"Experiment Name: {self.experiment_name}") + lines.append(f"Generated At: {_now_iso_local()}") + lines.append(f"STREAMLINE Version: {_try_streamline_version()}") + lines.append("") + + lines.append("=== COVER PARAMETERS (grouped) ===") + for section, items in (cover_boxes or {}).items(): + lines.append(f"[{section}]") + for k, v in items: + lines.append(f"- {k}: {v}") + lines.append("") + + lines.append("=== FULL METADATA UNION (flattened) ===") + for k in sorted(enriched_meta.keys(), key=lambda s: str(s).lower()): + lines.append(f"{k}: {self._as_compact_str(enriched_meta.get(k))}") + + self.paths.metadata_txt.write_text("\n".join(lines)) + + # ---------------------------- + # Dataset discovery + # ---------------------------- + def _list_datasets(self) -> List[Path]: + ignore = { + "jobs", + "logs", + "jobsCompleted", + "dask_logs", + "runtime", + "DatasetComparisons", + "reporting", + } + ds: List[Path] = [] + for p in sorted(self.exp_root.iterdir()): + if not p.is_dir(): + continue + if p.name in ignore: + continue + if (p / "CVDatasets").is_dir(): + ds.append(p) + return ds + + # ============================================================ + # Prefer-original figure resolution + # ============================================================ + + def _first_existing(self, candidates: Sequence[Path]) -> Optional[str]: + for p in candidates: + try: + if p.is_file(): + return str(p) + except Exception: + continue + return None + + def _figure_path_exploratory_class_balance(self, ds_dir: Path) -> Optional[str]: + return self._first_existing([ + ds_dir / "exploratory" / "ClassCountsBarPlot.png", + ds_dir / "exploratory" / "ClassCountsBarplot.png", + ds_dir / "exploratory" / "ClassCounts.png", + ]) + + def _figure_path_exploratory_missingness(self, ds_dir: Path) -> Optional[str]: + return self._first_existing([ + ds_dir / "exploratory" / "DataMissingness.png", + ds_dir / "exploratory" / "Missingness.png", + ds_dir / "exploratory" / "MissingnessTop25.png", + ]) + + def _figure_path_exploratory_correlation_matrix(self, ds_dir: Path) -> Optional[str]: + return self._first_existing([ + ds_dir / "exploratory" / "FeatureCorrelationMatrix.png", + ds_dir / "exploratory" / "FeatureCorrelation.png", + ds_dir / "exploratory" / "CorrelationMatrix.png", + ds_dir / "exploratory" / "CorrelationHeatmap.png", + ds_dir / "exploratory" / "feature_correlation" / "CorrelationMatrix.png", + ds_dir / "exploratory" / "feature_correlation" / "FeatureCorrelationMatrix.png", + ds_dir / "exploratory" / "FeatureCorrelation" / "CorrelationMatrix.png", + ]) + + def _figure_path_model_summary_roc_prc(self, ds_dir: Path, kind: str) -> Optional[str]: + if kind.lower() == "roc": + return self._first_existing([ds_dir / "model_evaluation" / "Summary_ROC.png"]) + return self._first_existing([ds_dir / "model_evaluation" / "Summary_PRC.png"]) + + def _figure_path_model_metric_boxplot(self, ds_dir: Path, preferred_metric: str) -> Optional[str]: + return self._first_existing([ + ds_dir / "model_evaluation" / "metricBoxplots" / f"Compare_{preferred_metric}.png", + ]) + + def _figure_path_ensemble_summary(self, ds_dir: Path, kind: str) -> Optional[str]: + if kind.lower() == "roc": + return self._first_existing([ds_dir / "ensemble_evaluation" / "Summary_ROC_ensembles.png"]) + return self._first_existing([ds_dir / "ensemble_evaluation" / "Summary_PRC_ensembles.png"]) + + def _figure_paths_fs_top_scores(self, ds_dir: Path) -> List[Dict[str, str]]: + base = ds_dir / "feature_importance" + if not base.is_dir(): + return [] + hits = sorted(base.glob("*/TopAverageScores.png"), key=lambda p: p.parent.name.lower()) + out: List[Dict[str, str]] = [] + for p in hits: + try: + if p.is_file(): + out.append({"method": p.parent.name, "path": str(p)}) + except Exception: + continue + return out + + def _figure_path_dataset_comparisons_any(self) -> Optional[str]: + box_dir = self.exp_root / "DatasetComparisons" / "dataCompBoxplots" + return self._first_existing([ + box_dir / "DataCompareAllModels_Balanced Accuracy.png", + box_dir / "DataCompareAllModels_ROC AUC.png", + box_dir / "DataCompareAllModels_PRC AUC.png", + box_dir / "DataCompareAllModels_Accuracy.png", + ]) + + # ============================================================ + # Plot builders (fallback only) + # ============================================================ + + def _plot_class_counts(self, class_counts: pd.DataFrame, title: str): + import plotly.express as px # type: ignore + + df = class_counts.copy() + low = {c.lower(): c for c in df.columns} + label_col = None + count_col = None + + for cand in ["class", "label", "outcome", "y", "group"]: + if cand in low: + label_col = low[cand] + break + for cand in ["count", "n", "num", "frequency", "freq"]: + if cand in low: + count_col = low[cand] + break + + if label_col is None: + label_col = df.columns[0] + if count_col is None: + count_col = df.columns[1] if len(df.columns) > 1 else df.columns[0] + + df = df[[label_col, count_col]].dropna() + df[count_col] = pd.to_numeric(df[count_col], errors="coerce") + df = df.dropna() + fig = px.bar(df, x=label_col, y=count_col, title=title) + fig.update_layout(xaxis_title="Class", yaxis_title="Count") + return fig + + def _plot_missingness(self, missingness: pd.DataFrame, title: str): + import plotly.express as px # type: ignore + + df = missingness.copy() + low = {c.lower(): c for c in df.columns} + fcol = low.get("feature", df.columns[0]) + + pcol = None + for cand in ["missingpercent", "missing_percent", "percentmissing", "pct_missing", "missingpct"]: + if cand in low: + pcol = low[cand] + break + ccol = None + for cand in ["missingcount", "missing_count", "countmissing", "n_missing"]: + if cand in low: + ccol = low[cand] + break + + val_col = pcol or ccol or df.columns[-1] + df = df[[fcol, val_col]].dropna() + df[val_col] = pd.to_numeric(df[val_col], errors="coerce") + df = df.dropna().sort_values(val_col, ascending=False).head(25) + + fig = px.bar(df.iloc[::-1], x=val_col, y=fcol, orientation="h", title=title) + fig.update_layout(xaxis_title=val_col, yaxis_title="Feature") + return fig + + def _plot_correlation_matrix_from_csv(self, corr_df: pd.DataFrame, title: str): + import plotly.express as px # type: ignore + + df = corr_df.copy() + if df.shape[1] > 1 and str(df.columns[0]).lower() in {"unnamed: 0", "feature", "var", "variable"}: + df = df.set_index(df.columns[0]) + df = df.apply(pd.to_numeric, errors="coerce") + df = df.dropna(axis=0, how="all").dropna(axis=1, how="all") + + fig = px.imshow(df, aspect="auto", title=title, color_continuous_scale="RdBu", zmin=-1, zmax=1) + fig.update_layout(margin=dict(l=10, r=10, t=40, b=10)) + return fig + + # ============================================================ + # Table building + # ============================================================ + + def _infer_alg_col(self, df: pd.DataFrame) -> str: + low = {c.lower(): c for c in df.columns} + for key in ["ml algorithm", "ml_algorithm", "algorithm", "model"]: + if key in low: + return low[key] + return df.columns[0] + + def _build_mean_std_table( + self, + mean_df: Optional[pd.DataFrame], + std_df: Optional[pd.DataFrame], + highlight_metric_candidates: List[str], + max_rows: int = 50, + ) -> Dict[str, Any]: + if mean_df is None or mean_df.empty or std_df is None or std_df.empty: + return {"present": False} + + m = mean_df.copy() + s = std_df.copy() + + alg_col_m = self._infer_alg_col(m) + alg_col_s = self._infer_alg_col(s) + if alg_col_m != "Algorithm": + m = m.rename(columns={alg_col_m: "Algorithm"}) + if alg_col_s != "Algorithm": + s = s.rename(columns={alg_col_s: "Algorithm"}) + + highlight_metric = None + for cand in highlight_metric_candidates: + if cand in m.columns: + highlight_metric = cand + break + + common_metrics = [c for c in m.columns if c != "Algorithm" and c in s.columns] + if not common_metrics: + return {"present": False} + + merged = m[["Algorithm"] + common_metrics].merge( + s[["Algorithm"] + common_metrics], + on="Algorithm", + how="inner", + suffixes=("_mean", "_std"), + ) + + columns = ["Algorithm"] + common_metrics + + best_alg = None + if highlight_metric and f"{highlight_metric}_mean" in merged.columns: + try: + best_idx = merged[f"{highlight_metric}_mean"].astype(float).idxmax() + best_alg = str(merged.loc[best_idx, "Algorithm"]) + except Exception: + best_alg = None + + rows = [] + for _, r in merged.head(max_rows).iterrows(): + cells = [] + for c in columns: + if c == "Algorithm": + alg = str(r["Algorithm"]) + cells.append({"value": alg, "best": bool(best_alg and alg == best_alg)}) + else: + mv = r.get(f"{c}_mean", None) + sv = r.get(f"{c}_std", None) + cells.append({"value": (mv, sv), "best": False}) + rows.append({"cells": cells}) + + return { + "present": True, + "columns": columns, + "rows": rows, + "highlight_metric": highlight_metric, + "best_algorithm": best_alg, + } + + def _build_plain_table(self, df: Optional[pd.DataFrame], max_rows: int = 100) -> Dict[str, Any]: + if df is None or df.empty: + return {"present": False} + df2 = df.head(max_rows).copy() + df2 = df2.where(pd.notnull(df2), None) + return {"present": True, "columns": list(df2.columns), "rows": df2.values.tolist()} + + def _univariate_is_informative(self, uni: Optional[pd.DataFrame]) -> bool: + if uni is None or uni.empty: + return False + if len(uni) < 3: + return False + + low = {c.lower(): c for c in uni.columns} + pcol = None + for cand in ["p", "p-value", "p_value", "pvalue", "pval"]: + if cand in low: + pcol = low[cand] + break + if pcol is None: + return uni.shape[1] >= 2 and len(uni) >= 5 + + try: + pv = pd.to_numeric(uni[pcol], errors="coerce").dropna() + if pv.empty: + return False + return bool((pv < 0.10).any()) + except Exception: + return False + + # ============================================================ + # Combine model + ensemble performance (Mean +/- SD) + # - NO new column + # - ensemble rows renamed: " - Ensemble" + # ============================================================ + + def _combine_model_and_ensemble_perf( + self, + models_mean_std: Dict[str, Any], + ensembles_mean_std: Dict[str, Any], + *, + drop_if_needed: Sequence[str] = ("Brier Score",), + ensemble_suffix: str = " - Ensemble", + ) -> Dict[str, Any]: + ms = models_mean_std or {} + es = ensembles_mean_std or {} + + if not ms.get("present") and not es.get("present"): + return {"present": False} + + ms_cols = list(ms.get("columns") or []) if ms.get("present") else [] + es_cols = list(es.get("columns") or []) if es.get("present") else [] + + ms_metrics = [c for c in ms_cols if c != "Algorithm"] + es_metrics = [c for c in es_cols if c != "Algorithm"] + + metrics: List[str] = [] + for c in ms_metrics + es_metrics: + if c not in metrics: + metrics.append(c) + + # Too wide? columns are Algorithm + metrics + too_wide = (1 + len(metrics)) >= 11 + if too_wide: + for drop_col in drop_if_needed: + if drop_col in metrics: + metrics.remove(drop_col) + break + + def _row_map(mean_std_tbl: Dict[str, Any]) -> Dict[str, Dict[str, Tuple[Any, Any]]]: + out: Dict[str, Dict[str, Tuple[Any, Any]]] = {} + if not mean_std_tbl.get("present"): + return out + cols = list(mean_std_tbl.get("columns") or []) + for row in mean_std_tbl.get("rows") or []: + cells = row.get("cells") or [] + if not cells: + continue + alg = str((cells[0] or {}).get("value", "")).strip() + if not alg: + continue + m: Dict[str, Tuple[Any, Any]] = {} + for j, col in enumerate(cols): + if col == "Algorithm": + continue + if j >= len(cells): + continue + v = (cells[j] or {}).get("value") + if isinstance(v, tuple) and len(v) == 2: + m[col] = (v[0], v[1]) + out[alg] = m + return out + + ms_map = _row_map(ms) + es_map = _row_map(es) + + columns = ["Algorithm"] + metrics + rows: List[Dict[str, Any]] = [] + + # Models + for alg in sorted(ms_map.keys(), key=lambda s: s.lower()): + metric_map = ms_map[alg] + cells: List[Dict[str, Any]] = [{"value": alg, "best": False}] + for met in metrics: + if met in metric_map: + mv, sv = metric_map[met] + cells.append({"value": (mv, sv), "best": False}) + else: + cells.append({"value": ("", ""), "best": False}) + rows.append({"cells": cells}) + + # Ensembles (renamed) + for alg in sorted(es_map.keys(), key=lambda s: s.lower()): + alg2 = f"{alg}{ensemble_suffix}" + metric_map = es_map[alg] + cells = [{"value": alg2, "best": False}] + for met in metrics: + if met in metric_map: + mv, sv = metric_map[met] + cells.append({"value": (mv, sv), "best": False}) + else: + cells.append({"value": ("", ""), "best": False}) + rows.append({"cells": cells}) + + highlight_metric = None + for cand in ["Balanced Accuracy", "ROC AUC", "PRC AUC", "Accuracy"]: + if cand in metrics: + highlight_metric = cand + break + + return { + "present": True, + "columns": columns, + "rows": rows, + "highlight_metric": highlight_metric, + "best_algorithm": None, + } + + # ============================================================ + # Combine model + ensemble medians (same renaming) + # ============================================================ + + def _combine_model_and_ensemble_median( + self, + models_median: Dict[str, Any], + ensembles_median: Dict[str, Any], + *, + drop_if_needed: Sequence[str] = ("Brier Score",), + ensemble_suffix: str = " - Ensemble", + ) -> Dict[str, Any]: + mm = models_median or {} + em = ensembles_median or {} + + if not mm.get("present") and not em.get("present"): + return {"present": False} + + mm_cols = list(mm.get("columns") or []) if mm.get("present") else [] + em_cols = list(em.get("columns") or []) if em.get("present") else [] + + if not mm_cols and not em_cols: + return {"present": False} + + def infer_alg_col(columns: List[str]) -> str: + low = {c.lower(): c for c in columns} + for key in ["ml algorithm", "ml_algorithm", "algorithm", "model"]: + if key in low: + return low[key] + return columns[0] if columns else "Algorithm" + + mm_alg = infer_alg_col(mm_cols) if mm_cols else "Algorithm" + em_alg = infer_alg_col(em_cols) if em_cols else "Algorithm" + + mm_metrics = [c for c in mm_cols if c != mm_alg] + em_metrics = [c for c in em_cols if c != em_alg] + + metrics: List[str] = [] + for c in mm_metrics + em_metrics: + if c not in metrics: + metrics.append(c) + + too_wide = (1 + len(metrics)) >= 11 + if too_wide: + for drop_col in drop_if_needed: + if drop_col in metrics: + metrics.remove(drop_col) + break + + def to_map(tbl: Dict[str, Any], alg_col: str) -> Dict[str, Dict[str, Any]]: + out: Dict[str, Dict[str, Any]] = {} + if not tbl.get("present"): + return out + cols = list(tbl.get("columns") or []) + rows = list(tbl.get("rows") or []) + if not cols or not rows: + return out + idx = {c: i for i, c in enumerate(cols)} + alg_i = idx.get(alg_col, 0) + + for r in rows: + if r is None: + continue + rr = list(r) + if alg_i >= len(rr): + continue + alg = str(rr[alg_i]).strip() + if not alg: + continue + m: Dict[str, Any] = {} + for met in metrics: + j = idx.get(met) + if j is None or j >= len(rr): + continue + m[met] = rr[j] + out[alg] = m + return out + + mm_map = to_map(mm, mm_alg) + em_map = to_map(em, em_alg) + + columns = ["Algorithm"] + metrics + out_rows: List[List[Any]] = [] + + for alg in sorted(mm_map.keys(), key=lambda s: s.lower()): + m = mm_map[alg] + out_rows.append([alg] + [m.get(met, "") for met in metrics]) + + for alg in sorted(em_map.keys(), key=lambda s: s.lower()): + alg2 = f"{alg}{ensemble_suffix}" + m = em_map[alg] + out_rows.append([alg2] + [m.get(met, "") for met in metrics]) + + return {"present": True, "columns": columns, "rows": out_rows} + + # ============================================================ + # Cover page grouping (legacy categories) + # ============================================================ + + def _categorize_cover_items( + self, + meta_pickle_flat: Dict[str, Any], + run_params_flat: Dict[str, Any], + *, + exp_root: Path, + ) -> Dict[str, List[Tuple[str, str]]]: + combined = self._merge_union_dicts(run_params_flat or {}, meta_pickle_flat or {}) + + def add(cat: str, k: str, v: Any): + if self._is_timestampy_key(k): + return + if self._should_drop_identifier_code(k): + return + pretty_k = self._pretty_cover_key(k) + if pretty_k.strip() == "": + return + out.setdefault(cat, []).append((pretty_k, self._as_compact_str(v))) + + out: Dict[str, List[Tuple[str, str]]] = {} + + ds_names = [p.name for p in self._list_datasets()] + if ds_names: + items = [(f"D{i+1}", nm) for i, nm in enumerate(ds_names)] + out["Target Dataset(s):"] = [(f"{k}", f"= {v}") for k, v in items] + + for key in [ + "data path", "input path", "dataset path", + "output path", + "experiment name", + "class label", + "instance label", + "match label", + "ignored features", + "specified categorical features", + "specified quantitative features", + ]: + for kk in list(combined.keys()): + if str(kk).strip().lower() == key: + add("Target Data Settings:", kk, combined[kk]) + + for kk, vv in combined.items(): + k = str(kk).lower() + if any(x in k for x in ["cv", "partition", "seed", "random", "categorical cutoff", "statistical", "significance", "notebook"]): + if any(x in k for x in ["plot", "export", "roc", "prc", "figure", "boxplot"]): + continue + add("General Pipeline Settings:", kk, vv) + + for kk, vv in combined.items(): + k = str(kk).lower() + if any(x in k for x in ["missing", "imput", "scale", "correlation", "describe", "univariate", "eda", "processing", "clean"]): + if any(x in k for x in ["feature importance", "feature_selection", "feature selection", "multisurf", "mutual", "turf"]): + continue + add("EDA and Processing Settings:", kk, vv) + + for kk, vv in combined.items(): + k = str(kk).lower() + if any(x in k for x in ["feature importance", "feature selection", "multisurf", "mutual", "turf", "max features", "top features", "filter poor"]): + add("Feature Importance/Selection Settings:", kk, vv) + + algo_items: List[Tuple[str, str]] = [] + algo_keys = [ + "logistic", "naive", "bayes", "random forest", "svm", "support vector", + "xgboost", "gradient boosting", "lightgbm", "catboost", + "decision tree", "elastic", "knn", "k-nearest", + "ann", "neural", "exstracs", "xcs", "elcs", "genetic programming", + ] + for kk, vv in combined.items(): + k = str(kk).lower() + if any(a in k for a in algo_keys): + b = self._normalize_bool(vv) + if b is None: + continue + algo_items.append((self._pretty_cover_key(kk), "True" if b else "False")) + if algo_items: + algo_items.sort(key=lambda t: (t[1] != "True", t[0].lower())) + out["ML Modeling Algorithms:"] = algo_items + + for kk, vv in combined.items(): + k = str(kk).lower() + if any(x in k for x in ["primary metric", "hyperparameter", "trials", "timeout", "subsample", "uniform feature importance"]): + add("Modeling Settings:", kk, vv) + + for kk, vv in combined.items(): + k = str(kk).lower() + if any(x in k for x in ["lcs", "xcs", "elcs", "exstracs", "rule population", "training iterations", "nu"]): + add("LCS Settings (eLCS, XCS, ExSTraCS):", kk, vv) + + for kk, vv in combined.items(): + k = str(kk).lower() + if any(x in k for x in ["export", "roc", "prc", "boxplot", "figure", "plot", "correlation", "top model features", "metric weighting"]): + add("Stats and Figure Settings:", kk, vv) + + for cat, items in list(out.items()): + seen = set() + dedup: List[Tuple[str, str]] = [] + for k, v in items: + if k in seen: + continue + seen.add(k) + dedup.append((k, v)) + out[cat] = dedup + + ordered = [ + "General Pipeline Settings:", + "EDA and Processing Settings:", + "Feature Importance/Selection Settings:", + "ML Modeling Algorithms:", + "Modeling Settings:", + "LCS Settings (eLCS, XCS, ExSTraCS):", + "Stats and Figure Settings:", + "Target Dataset(s):", + "Target Data Settings:", + ] + out2: Dict[str, List[Tuple[str, str]]] = {} + for cat in ordered: + if cat in out and out[cat]: + out2[cat] = out[cat] + for cat, items in out.items(): + if cat not in out2 and items: + out2[cat] = items + return out2 + + # ============================================================ + # Data assembly (tables + figs) + # ============================================================ + + def _collect_dataset_block(self, ds_dir: Path) -> Dict[str, Any]: + name = ds_dir.name + figs: Dict[str, Any] = {} + + explore = ds_dir / "exploratory" + class_counts = self._read_csv_if_exists(explore / "ClassCounts.csv") + missingness = self._read_csv_if_exists(explore / "DataMissingness.csv") + univariate = self._read_csv_if_exists(explore / "univariate_analyses" / "Univariate_Significance.csv") + + # Correlation matrix + corr_png = self._figure_path_exploratory_correlation_matrix(ds_dir) or "" + if not corr_png: + corr_csv = self._first_existing([ + explore / "FeatureCorrelationMatrix.csv", + explore / "CorrelationMatrix.csv", + explore / "FeatureCorrelation.csv", + explore / "feature_correlation" / "CorrelationMatrix.csv", + explore / "FeatureCorrelation" / "CorrelationMatrix.csv", + ]) + if corr_csv: + try: + corr_df = pd.read_csv(corr_csv) + fig = self._plot_correlation_matrix_from_csv(corr_df, f"{name}: Feature Correlation Matrix") + out = self.paths.figures_dir / f"{name}_corr_matrix.png" + if _safe_plotly_to_png(fig, out): + corr_png = str(out) + except Exception as e: + logger.warning("Correlation matrix fallback plot failed for %s: %r", name, e) + figs["correlation_matrix"] = corr_png + + # Univariate (optional) + uni_use = self._univariate_is_informative(univariate) + univariate_top10 = univariate.head(10) if (uni_use and univariate is not None and not univariate.empty) else None + + # Performance tables + model_eval = ds_dir / "model_evaluation" + summary_mean = self._read_csv_if_exists(model_eval / "Summary_performance_mean.csv") + summary_std = self._read_csv_if_exists(model_eval / "Summary_performance_std.csv") + summary_median = self._read_csv_if_exists(model_eval / "Summary_performance_median.csv") + + ens_eval = ds_dir / "ensemble_evaluation" + ens_mean = self._read_csv_if_exists(ens_eval / "Ensembles_performance_mean.csv") + ens_std = self._read_csv_if_exists(ens_eval / "Ensembles_performance_std.csv") + ens_median = self._read_csv_if_exists(ens_eval / "Ensembles_performance_median.csv") + + # Feature learning / selection tables + feat_sel = self._read_csv_if_exists(ds_dir / "feature_selection" / "InformativeFeatureSummary.csv") + runtimes = self._read_csv_if_exists(ds_dir / "runtimes.csv") + + # Figures (EDA) + figs["class_balance"] = self._figure_path_exploratory_class_balance(ds_dir) or "" + if not figs["class_balance"] and class_counts is not None and not class_counts.empty: + try: + fig = self._plot_class_counts(class_counts, f"{name}: Class Balance") + out = self.paths.figures_dir / f"{name}_class_balance.png" + if _safe_plotly_to_png(fig, out): + figs["class_balance"] = str(out) + except Exception as e: + logger.warning("Class balance plot failed for %s: %r", name, e) + + figs["missingness"] = self._figure_path_exploratory_missingness(ds_dir) or "" + if not figs["missingness"] and missingness is not None and not missingness.empty: + try: + fig = self._plot_missingness(missingness, f"{name}: Missingness (Top 25 Features)") + out = self.paths.figures_dir / f"{name}_missingness_top25.png" + if _safe_plotly_to_png(fig, out): + figs["missingness"] = str(out) + except Exception as e: + logger.warning("Missingness plot failed for %s: %r", name, e) + + # CV distribution boxplot + figs["models_cv_box"] = "" + chosen_metric = None + if summary_mean is not None and not summary_mean.empty: + for preferred in ["Balanced Accuracy", "ROC AUC", "PRC AUC", "Accuracy"]: + if preferred in summary_mean.columns: + chosen_metric = preferred + break + if chosen_metric: + box = self._figure_path_model_metric_boxplot(ds_dir, chosen_metric) + if box: + figs["models_cv_box"] = box + + # Summary curves only + figs["models_roc_overlay"] = self._figure_path_model_summary_roc_prc(ds_dir, "roc") or "" + figs["models_prc_overlay"] = self._figure_path_model_summary_roc_prc(ds_dir, "prc") or "" + figs["ensembles_roc"] = self._figure_path_ensemble_summary(ds_dir, "roc") or "" + figs["ensembles_prc"] = self._figure_path_ensemble_summary(ds_dir, "prc") or "" + + # Feature learning figures (all methods) + figs["fi_top_scores"] = self._figure_paths_fs_top_scores(ds_dir) + + # Tables (mean/std + median) + models_mean_std = self._build_mean_std_table( + summary_mean, + summary_std, + highlight_metric_candidates=["Balanced Accuracy", "ROC AUC", "PRC AUC", "Accuracy"], + ) + ensembles_mean_std = self._build_mean_std_table( + ens_mean, + ens_std, + highlight_metric_candidates=["Balanced Accuracy", "ROC AUC", "PRC AUC", "Accuracy"], + ) + combined_mean_std = self._combine_model_and_ensemble_perf( + models_mean_std, + ensembles_mean_std, + drop_if_needed=("Brier Score",), + ensemble_suffix=" - Ensemble", + ) + + models_median = self._build_plain_table(summary_median, max_rows=200) + ensembles_median = self._build_plain_table(ens_median, max_rows=200) + combined_median = self._combine_model_and_ensemble_median( + models_median, + ensembles_median, + drop_if_needed=("Brier Score",), + ensemble_suffix=" - Ensemble", + ) + + return { + "dataset_name": name, + "dataset_dir": str(ds_dir), + "tables": { + "univariate_top10": self._build_plain_table(univariate_top10, max_rows=10), + "informative_feature_summary": self._build_plain_table(feat_sel, max_rows=200), + "runtimes": self._build_plain_table(runtimes, max_rows=500), + }, + "perf": { + "combined_mean_std": combined_mean_std, + "combined_median": combined_median, + }, + "figures": figs, + } + + def _collect_dataset_comparisons_block(self) -> Dict[str, Any]: + dc = self.exp_root / "DatasetComparisons" + if not dc.is_dir(): + return {"present": False} + + best_kw = self._read_csv_if_exists(dc / "BestCompare_KruskalWallis.csv") + best_mw = self._read_csv_if_exists(dc / "BestCompare_MannWhitney.csv") + best_wx = self._read_csv_if_exists(dc / "BestCompare_WilcoxonRank.csv") + + figs: Dict[str, str] = {} + any_plot = self._figure_path_dataset_comparisons_any() + if any_plot: + figs["overview"] = any_plot + + return { + "present": True, + "tables": { + "best_kw": self._build_plain_table(best_kw, max_rows=200), + "best_mw": self._build_plain_table(best_mw, max_rows=200), + "best_wx": self._build_plain_table(best_wx, max_rows=200), + }, + "figures": figs, + } + + # ============================================================ + # PDF render + # ============================================================ + + def _write_pdf(self, report_data: Dict[str, Any]) -> None: + pdf = _StreamlinePDF( + title=str(report_data.get("title", "")), + streamline_version=str(report_data.get("streamline_version", "")), + float_decimals=self.float_decimals, + ) + pdf.alias_nb_pages() + + # COVER + pdf.add_page() + pdf.cover_banner_title(str(report_data.get("title", ""))) + pdf.cover_two_column_boxes(report_data.get("cover_boxes", {}) or {}) + + # DATASETS + for ds in report_data.get("datasets", []) or []: + ds_name = str(ds.get("dataset_name", "")) + ds_dir = str(ds.get("dataset_dir", "")) + + figs = ds.get("figures", {}) or {} + tables = ds.get("tables", {}) or {} + perf = ds.get("perf", {}) or {} + + # ------------------------- + # EDA - PAGE 1 + # ------------------------- + pdf.add_page() + pdf.panel_title(f"Dataset: {ds_name}") + pdf.set_font("Times", "", 10) + if ds_dir: + pdf.multi_cell(0, 5, pdf.s(ds_dir)) + pdf.ln(1.0) + + pdf.panel_title("EDA") + + # Univariate (optional) + uni = tables.get("univariate_top10", {}) or {} + if uni.get("present"): + pdf.subheader("Univariate Analysis (Top 10)") + pdf.draw_table(uni.get("columns", []), uni.get("rows", []), max_rows=10, no_wrap=True) + + # EDA grid (skip missing panels silently) + pdf.figure_grid_2x2( + titles=["Class Balance", "Missingness (Top 25 Features)", "", ""], + paths=[figs.get("class_balance") or None, figs.get("missingness") or None, None, None], + cell_h=66.0, + gap=4.0, + title_h=6.0, + keep_aspect=True, + ) + + # Cleaning/Engineering elements + pdf.panel_title("Cleaning (C) and Engineering (E) Elements") + pdf.cleaning_engineering_box( + [ + "C1 - Remove instances with no outcome and features to ignore", + "E1 - Add missingness features", + "C2 - Remove features with invariance or high missingness", + "C3 - Remove instances with high missingness", + "E2 - Add one-hot-encoding of categorical features", + "C4 - Remove highly correlated features", + ] + ) + + # Correlation matrix full page (if present) + corr = figs.get("correlation_matrix") or "" + if corr and Path(corr).exists(): + pdf.add_page() + pdf.panel_title(f"Dataset: {ds_name}") + pdf.panel_title("Feature Correlation Matrix") + pdf.figure_single("", corr, h=175.0, title_h=0.0, keep_aspect=True) + + # ------------------------- + # Feature Learning + # ------------------------- + pdf.add_page() + pdf.panel_title(f"Dataset: {ds_name}") + pdf.panel_title("Feature Learning") + + fi_list = figs.get("fi_top_scores") or [] + norm: List[Dict[str, str]] = [] + for item in fi_list: + if isinstance(item, dict) and "path" in item and item.get("path"): + p = str(item["path"]) + if Path(p).exists(): + norm.append({"method": str(item.get("method") or "method"), "path": p}) + + if norm: + if len(norm) == 1: + pdf.figure_single( + f"Top Scores ({norm[0]['method']})", norm[0]["path"], h=130.0, title_h=6.0, keep_aspect=True + ) + elif len(norm) == 2: + pdf.figure_row_2( + titles=[f"Top Scores ({norm[0]['method']})", f"Top Scores ({norm[1]['method']})"], + paths=[norm[0]["path"], norm[1]["path"]], + h=95.0, + gap=4.0, + title_h=6.0, + keep_aspect=True, + ) + else: + for i in range(0, len(norm), 4): + chunk = norm[i : i + 4] + titles = [f"Top Scores ({c['method']})" for c in chunk] + paths = [c["path"] for c in chunk] + while len(titles) < 4: + titles.append("") + paths.append(None) + pdf.figure_grid_2x2( + titles=titles, + paths=paths, + cell_h=66.0, + gap=4.0, + title_h=6.0, + keep_aspect=True, + ) + if i + 4 < len(norm): + pdf.add_page() + pdf.panel_title(f"Dataset: {ds_name}") + pdf.panel_title("Feature Learning") + + inf = tables.get("informative_feature_summary", {}) or {} + if inf.get("present"): + pdf.panel_title("Informative Feature Summary") + pdf.draw_table(inf.get("columns", []), inf.get("rows", []), max_rows=200, no_wrap=True) + + # ------------------------- + # Performance (combined mean/std + combined median) + # ------------------------- + pdf.add_page() + pdf.panel_title(f"Dataset: {ds_name}") + pdf.panel_title("Performance (Cross-Validation)") + + cmb = perf.get("combined_mean_std", {}) or {} + if cmb.get("present"): + pdf.subheader("Model and Ensemble Performance (Mean plus SD)") + pdf.draw_mean_std_table(cmb, no_wrap=True) + + med = perf.get("combined_median", {}) or {} + if med.get("present"): + pdf.subheader("Median (Combined)") + pdf.draw_table(med.get("columns", []), med.get("rows", []), max_rows=200, no_wrap=True) + + cv_box = figs.get("models_cv_box") or "" + if cv_box and Path(cv_box).exists(): + pdf.panel_title("Performance Distribution") + pdf.figure_single("Model Comparison", cv_box, h=110.0, title_h=6.0, keep_aspect=True) + + # ------------------------- + # Evaluation results (summary only) + # ------------------------- + pdf.add_page() + pdf.panel_title(f"Dataset: {ds_name}") + pdf.panel_title("Evaluation Results (Curves)") + + roc = figs.get("models_roc_overlay") or "" + prc = figs.get("models_prc_overlay") or "" + eroc = figs.get("ensembles_roc") or "" + eprc = figs.get("ensembles_prc") or "" + + if (roc and Path(roc).exists()) or (prc and Path(prc).exists()): + pdf.figure_row_2( + titles=["Summary ROC", "Summary PRC"], + paths=[ + roc if (roc and Path(roc).exists()) else None, + prc if (prc and Path(prc).exists()) else None, + ], + h=85.0, + gap=4.0, + title_h=6.0, + keep_aspect=True, + ) + + if (eroc and Path(eroc).exists()) or (eprc and Path(eprc).exists()): + pdf.panel_title("Ensembles (Summary Curves)") + pdf.figure_row_2( + titles=["Ensembles ROC", "Ensembles PRC"], + paths=[ + eroc if (eroc and Path(eroc).exists()) else None, + eprc if (eprc and Path(eprc).exists()) else None, + ], + h=85.0, + gap=4.0, + title_h=6.0, + keep_aspect=True, + ) + + # ------------------------- + # Runtimes + # ------------------------- + pdf.add_page() + pdf.panel_title(f"Dataset: {ds_name}") + pdf.panel_title("Runtime Summary") + rt = tables.get("runtimes", {}) or {} + if rt.get("present"): + pdf.draw_table(rt.get("columns", []), rt.get("rows", []), max_rows=500, no_wrap=True) + + # DATASET COMPARISONS + dc = report_data.get("dataset_comparisons", {}) or {} + if dc.get("present"): + pdf.add_page() + pdf.panel_title("Dataset Comparisons") + + overview = (dc.get("figures", {}) or {}).get("overview") or "" + if overview and Path(overview).exists(): + pdf.figure_single("Comparison Overview (All Datasets)", overview, h=120.0, title_h=6.0, keep_aspect=True) + + kw = (dc.get("tables", {}) or {}).get("best_kw", {}) or {} + if kw.get("present"): + pdf.panel_title("Best Comparisons - Kruskal-Wallis") + pdf.draw_table(kw.get("columns", []), kw.get("rows", []), max_rows=200, no_wrap=True) + + mw = (dc.get("tables", {}) or {}).get("best_mw", {}) or {} + if mw.get("present"): + pdf.panel_title("Best Comparisons - Mann-Whitney U") + pdf.draw_table(mw.get("columns", []), mw.get("rows", []), max_rows=200, no_wrap=True) + + wx = (dc.get("tables", {}) or {}).get("best_wx", {}) or {} + if wx.get("present"): + pdf.panel_title("Best Comparisons - Wilcoxon Rank-Sum") + pdf.draw_table(wx.get("columns", []), wx.get("rows", []), max_rows=200, no_wrap=True) + + pdf.output(str(self.paths.pdf)) + + # ---------------------------- + # Runtime bookkeeping + # ---------------------------- + def save_runtime(self): + rt_dir = self.exp_root / "runtime" + rt_dir.mkdir(exist_ok=True) + (rt_dir / "runtime_report.txt").write_text(str(time.time() - (self.job_start_time or time.time()))) + + def run(self): + self.job_start_time = time.time() + + datasets = self._list_datasets() + if not datasets: + raise RuntimeError(f"No dataset folders (with CVDatasets/) found under: {self.exp_root}") + + dataset_blocks = [self._collect_dataset_block(ds) for ds in datasets] + dc_block = self._collect_dataset_comparisons_block() + + meta_pickle_obj = self._read_pickle_if_exists(self.exp_root / "metadata.pickle") + run_params_obj = self._read_pickle_if_exists(self.exp_root / "run_params.pickle") + + meta_pickle_dict: Dict[str, Any] = meta_pickle_obj if isinstance(meta_pickle_obj, dict) else ( + {"metadata.pickle": str(meta_pickle_obj)} if meta_pickle_obj is not None else {} + ) + run_params_dict: Dict[str, Any] = run_params_obj if isinstance(run_params_obj, dict) else ( + {"run_params.pickle": str(run_params_obj)} if run_params_obj is not None else {} + ) + + meta_flat = self._flatten_mapping(meta_pickle_dict, sep=" · ", max_depth=6) if meta_pickle_dict else {} + params_flat = self._flatten_mapping(run_params_dict, sep=" · ", max_depth=6) if run_params_dict else {} + + cover_boxes = self._categorize_cover_items(meta_flat, params_flat, exp_root=self.exp_root) + + base_meta: Dict[str, Any] = { + "Experiment Root": str(self.exp_root), + "Output Path": str(self.exp_root.parent), + "Experiment Name": self.experiment_name, + "Datasets Found": len(datasets), + "Generated At": _now_iso_local(), + } + if self.outcome_label: + base_meta["Outcome Label"] = self.outcome_label + if self.instance_label: + base_meta["Instance Label"] = self.instance_label + if self.outcome_type: + base_meta["Outcome Type"] = self.outcome_type + + enriched_meta = self._merge_union_dicts(base_meta, meta_flat, params_flat) + + report_data: Dict[str, Any] = { + "title": self.title, + "experiment_name": self.experiment_name, + "experiment_root": str(self.exp_root), + "generated_at": _now_iso_local(), + "generated_at_epoch": int(time.time()), + "streamline_version": _try_streamline_version(), + "metadata": enriched_meta, + "metadata_pickle_flat": meta_flat, + "run_params_flat": params_flat, + "cover_boxes": cover_boxes, + "datasets": dataset_blocks, + "dataset_comparisons": dc_block, + } + + self.paths.data_json.write_text(json.dumps(report_data, indent=2)) + self._write_metadata_text(cover_boxes=cover_boxes, enriched_meta=enriched_meta) + + if self.make_pdf: + self._write_pdf(report_data) + + jc = self.exp_root / "jobsCompleted" + jc.mkdir(exist_ok=True) + (jc / "job_reporting.txt").write_text("complete") + + self.save_runtime() + logger.info("Phase 11 reporting complete: %s", self.paths.pdf) + + +# ============================================================ +# PDF renderer (Times; ASCII sanitization; skip missing figures) +# ============================================================ + +class _StreamlinePDF(FPDF): + """ + Keep core Times font, but sanitize smart punctuation to ASCII-safe equivalents. + + Also: + - Do not draw placeholder panels for missing figures (skip silently). + - No em-dashes and no ellipsis in rendered strings. + - Performance tables: no wrapping; use truncation and tuned column widths. + """ + + def __init__(self, *, title: str, streamline_version: str, float_decimals: int = 3): + super().__init__(orientation="P", unit="mm", format="A4") + self._title = title + self._streamline_version = streamline_version + self._decimals = int(float_decimals) + + self.set_margins(10, 10, 10) + self.set_auto_page_break(auto=True, margin=14) + self.set_line_width(0.2) + + self._use_running_header = False + + # table layout + self._tbl_pad_x = 1.2 + self._tbl_pad_y = 0.8 + self._tbl_line_h = 3.4 + self._gap_after_table = 1.2 + + # figure panel padding + self._panel_pad = 2.0 + self._panel_title_text_pad_x = 1.4 + self._panel_title_text_pad_y = 1.4 + self._panel_content_pad_top = 2.2 + + self.set_font("Times", "", 10) + + # ----------------------------- + # Sanitization (no smart punctuation, no em-dash, no ellipsis) + # ----------------------------- + def s(self, txt: Any) -> str: + if txt is None: + return "" + t = str(txt) + + repl = { + "\u201c": '"', + "\u201d": '"', + "\u2018": "'", + "\u2019": "'", + "\u2013": "-", + "\u2014": "-", + "\u2022": "-", + "\u00A0": " ", + "\u2026": "", + } + for k, v in repl.items(): + t = t.replace(k, v) + + t = t.encode("latin-1", "ignore").decode("latin-1") + t = re.sub(r"[ \t]+", " ", t) + t = re.sub(r"\s+\n", "\n", t) + return t.strip() + + # ----------------------------- + # Header / Footer + # ----------------------------- + def header(self): + if not self._use_running_header: + return + self.set_font("Times", "", 9) + x = self.l_margin + y = self.t_margin + w = self.w - self.l_margin - self.r_margin + self.set_xy(x, y - 2) + self.line(x, y, x + w, y) + self.set_xy(x, y) + self.cell(w, 4, self.s(self._title), border=0, ln=1, align="L") + self.ln(2) + + def footer(self): + self.set_y(-10) + self.set_font("Times", "I", 8) + left = self.s(f"Generated with STREAMLINE ({self._streamline_version})") + right = self.s(f"Page {self.page_no()}/{{nb}}") + self.set_x(self.l_margin) + self.cell(0, 5, left, border=0, ln=0, align="L") + self.set_x(self.l_margin) + self.cell(self.w - self.l_margin - self.r_margin, 5, right, border=0, ln=0, align="R") + + # ----------------------------- + # Cover + # ----------------------------- + def cover_banner_title(self, title: str): + x = self.l_margin + y = self.t_margin + w = self.w - self.l_margin - self.r_margin + h = 12 + + self.set_font("Times", "B", 14) + self.set_xy(x, y) + self.rect(x, y, w, h) + self.set_xy(x + 2, y + 3.2) + self.cell(w - 4, 6, self.s(title), border=0, ln=1, align="L") + self.ln(3) + + def _cover_section_box( + self, + title: str, + items: Sequence[Tuple[str, str]], + *, + x: float, + y: float, + w: float, + max_items: Optional[int] = None, + title_h: float = 6.0, + row_h: float = 4.6, + font_size: int = 9, + ) -> float: + if max_items is not None: + items = items[:max_items] + + content_h = max(1, len(items)) * row_h + h = title_h + content_h + 1.4 + + if y + h > (self.h - self.b_margin - 2): + self.add_page() + y = self.get_y() + + self.rect(x, y, w, h) + self.rect(x, y, w, title_h) + + self.set_font("Times", "B", 11) + self.set_xy(x + 1.6, y + 1.6) + self.cell(w - 3.2, title_h - 3.2, self.s(title), border=0, ln=0, align="L") + + self.set_font("Times", "", font_size) + cy = y + title_h + 0.6 + for k, v in items: + line = self.s(f"{k}: {v}") + self.set_xy(x + 1.8, cy) + self.multi_cell(w - 3.6, row_h, line, border=0) + cy += row_h + + return h + + def cover_two_column_boxes(self, boxes: Dict[str, List[Tuple[str, str]]]): + page_w = self.w - self.l_margin - self.r_margin + gap = 4.0 + col_w = (page_w - gap) / 2.0 + + xL = self.l_margin + xR = self.l_margin + col_w + gap + + left_order = [ + "General Pipeline Settings:", + "Feature Importance/Selection Settings:", + "ML Modeling Algorithms:", + "Modeling Settings:", + "LCS Settings (eLCS, XCS, ExSTraCS):", + "Stats and Figure Settings:", + ] + right_order = [ + "EDA and Processing Settings:", + "Target Dataset(s):", + "Target Data Settings:", + ] + + y_start = self.get_y() + yL = y_start + yR = y_start + + for title in left_order: + items = boxes.get(title) or [] + if not items: + continue + h = self._cover_section_box(title, items, x=xL, y=yL, w=col_w, title_h=6.0, row_h=4.6, font_size=9) + yL += h + 2.0 + + for title in right_order: + items = boxes.get(title) or [] + if not items: + continue + font_size = 8 if title in {"EDA and Processing Settings:", "Target Data Settings:"} else 9 + row_h = 4.4 if font_size == 8 else 4.6 + h = self._cover_section_box(title, items, x=xR, y=yR, w=col_w, title_h=6.0, row_h=row_h, font_size=font_size) + yR += h + 2.0 + + self.set_y(max(yL, yR) + 1.0) + + # ----------------------------- + # Section typography + # ----------------------------- + def panel_title(self, title: str, *, h: float = 6.0): + w = self.w - self.l_margin - self.r_margin + if self.get_y() + h + 2 > self.page_break_trigger: + self.add_page() + + x = self.l_margin + y = self.get_y() + self.set_font("Times", "B", 10) + self.rect(x, y, w, h) + self.set_xy(x + 1.4, y + 1.4) + self.cell(w - 2.8, h - 2.8, self.s(title), border=0, ln=1, align="L") + self.ln(1.2) + + def subheader(self, text: str): + self.set_font("Times", "B", 10) + self.multi_cell(0, 5, self.s(text)) + self.ln(0.8) + + def cleaning_engineering_box(self, lines: Sequence[str]): + w = self.w - self.l_margin - self.r_margin + x = self.l_margin + y = self.get_y() + + line_h = 5.0 + pad = 2.0 + h = pad + len(lines) * line_h + pad + + if y + h > self.page_break_trigger: + self.add_page() + x = self.l_margin + y = self.get_y() + + self.rect(x, y, w, h) + self.set_font("Times", "", 10) + cy = y + pad + for ln in lines: + self.set_xy(x + pad, cy) + self.multi_cell(w - 2 * pad, line_h, self.s(ln), border=0) + cy += line_h + self.ln(2.0) + + # ----------------------------- + # Formatting helpers + # ----------------------------- + def _cell_str(self, v: Any) -> str: + return self.s(format_number(v, decimals=self._decimals)) + + def _truncate_to_width(self, s: str, w_mm: float) -> str: + if s is None: + return "" + s = self.s(s) + if self.get_string_width(s) <= w_mm: + return s + if w_mm <= 0: + return "" + lo, hi = 0, len(s) + best = "" + while lo <= hi: + mid = (lo + hi) // 2 + cand = s[:mid] + if self.get_string_width(cand) <= w_mm: + best = cand + lo = mid + 1 + else: + hi = mid - 1 + return best + + # ----------------------------- + # Tables + # ----------------------------- + def _col_widths_model_perf(self, columns: Sequence[str], table_w: float) -> List[float]: + """ + Widths for wide performance tables with: + columns = ["Algorithm", metric1, metric2, ...] + No wrapping: we rely on truncation to fit each cell. + """ + n = len(columns) + if n <= 1: + return [table_w] + + alg_w = min(max(36.0, 0.20 * table_w), 52.0) + rest = max(0.0, table_w - alg_w) + + metric_cols = list(columns[1:]) + weights: List[float] = [] + for c in metric_cols: + cl = str(c).lower() + w = 1.0 + min(1.6, len(str(c)) / 16.0) + if any(x in cl for x in ["sensitivity", "precision", "specificity"]): + w *= 1.25 + if "balanced" in cl: + w *= 1.10 + if "roc" in cl or "prc" in cl: + w *= 1.10 + weights.append(w) + + sw = sum(weights) if sum(weights) > 0 else float(max(1, len(weights))) + raw = [rest * (w / sw) for w in weights] + + min_metric = 18.0 + raw = [max(min_metric, r) for r in raw] + + s2 = sum(raw) + scale = (rest / s2) if s2 > 0 else 1.0 + metrics = [r * scale for r in raw] + + widths = [alg_w] + metrics + widths[-1] += (table_w - sum(widths)) + return widths + + def draw_mean_std_table(self, mean_std: Dict[str, Any], *, no_wrap: bool = True): + cols = mean_std.get("columns", []) + rows_out: List[List[Any]] = [] + + for row in mean_std.get("rows", []) or []: + out_row: List[Any] = [] + for cell in row.get("cells", []): + val = cell.get("value") + if isinstance(val, tuple) and len(val) == 2: + mv, sv = val + out_row.append(self.s(f"{format_number(mv, decimals=self._decimals)} +/- {format_number(sv, decimals=self._decimals)}")) + else: + out_row.append(self.s(val)) + rows_out.append(out_row) + + table_w = self.w - self.l_margin - self.r_margin + col_widths = self._col_widths_model_perf(cols, table_w) + + ncol = len(cols) + font_size = 6 if ncol >= 10 else 7 + + self.draw_table(cols, rows_out, col_widths=col_widths, font_size=font_size, no_wrap=no_wrap) + + def _auto_col_widths(self, columns: Sequence[str], rows: Sequence[Sequence[str]], table_w: float) -> List[float]: + n = len(columns) + if n == 1: + return [table_w] + + weights: List[float] = [] + for j, c in enumerate(columns): + w = max(3.0, float(len(self.s(c)))) + for r in rows[:15]: + if j < len(r): + w = max(w, min(44.0, float(len(self.s(r[j]))))) + if j == 0: + w *= 1.6 + weights.append(w) + + sw = sum(weights) if sum(weights) > 0 else float(n) + raw = [table_w * (w / sw) for w in weights] + + min_w = 14.0 if n <= 4 else 10.0 + raw = [max(min_w, w) for w in raw] + + s2 = sum(raw) + scale = (table_w / s2) if s2 > 0 else 1.0 + out = [w * scale for w in raw] + out[-1] += (table_w - sum(out)) + return out + + def draw_table( + self, + columns: Sequence[str], + rows: Sequence[Sequence[Any]], + *, + col_widths: Optional[Sequence[float]] = None, + max_rows: Optional[int] = None, + font_size: Optional[int] = None, + no_wrap: bool = False, + ): + if not columns: + return + + table_w = self.w - self.l_margin - self.r_margin + ncol = len(columns) + + formatted_rows: List[List[str]] = [[self._cell_str(v) for v in r] for r in rows] + if max_rows is not None: + formatted_rows = formatted_rows[:max_rows] + + if font_size is None: + font_size = 8 if ncol <= 5 else (7 if ncol <= 8 else (6 if ncol <= 11 else 5)) + self.set_font("Times", "", font_size) + + if col_widths is None: + col_widths = self._auto_col_widths(columns, formatted_rows, table_w) + col_widths = list(col_widths) + + header_h = 5.0 + line_h = self._tbl_line_h + + def draw_header(): + self.set_font("Times", "B", font_size) + y0 = self.get_y() + x0 = self.l_margin + for j, col in enumerate(columns): + wj = col_widths[j] + self.rect(x0, y0, wj, header_h) + self.set_xy(x0 + self._tbl_pad_x, y0 + self._tbl_pad_y) + txt = self._truncate_to_width(str(col), wj - 2 * self._tbl_pad_x) if no_wrap else self.s(col) + self.cell(wj - 2 * self._tbl_pad_x, header_h - 2 * self._tbl_pad_y, txt, border=0, ln=0, align="C") + x0 += wj + self.set_xy(self.l_margin, y0 + header_h) + self.set_font("Times", "", font_size) + + if self.get_y() + header_h + 2 > self.page_break_trigger: + self.add_page() + draw_header() + + row_h = max(4.4, line_h + 2 * self._tbl_pad_y) + for cells in formatted_rows: + if self.get_y() + row_h > self.page_break_trigger: + self.add_page() + draw_header() + + y0 = self.get_y() + x0 = self.l_margin + for j, txt in enumerate(cells): + wj = col_widths[j] + self.rect(x0, y0, wj, row_h) + self.set_xy(x0 + self._tbl_pad_x, y0 + self._tbl_pad_y) + t = self._truncate_to_width(txt, wj - 2 * self._tbl_pad_x) if no_wrap else self.s(txt) + self.cell(wj - 2 * self._tbl_pad_x, line_h, t, border=0, ln=0, align="L") + x0 += wj + self.set_y(y0 + row_h) + + self.ln(self._gap_after_table) + + # ----------------------------- + # Figures (skip missing entirely; keep aspect if supported) + # ----------------------------- + def _image_panel( + self, + title: str, + path: Optional[str], + *, + x: float, + y: float, + w: float, + h: float, + title_h: float, + keep_aspect: bool = True, + ) -> bool: + if not path: + return False + p = Path(path) + if not p.exists(): + return False + + self.rect(x, y, w, h) + if title_h > 0: + self.rect(x, y, w, title_h) + self.set_font("Times", "B", 8) + self.set_xy(x + self._panel_title_text_pad_x, y + self._panel_title_text_pad_y) + self.cell( + w - 2 * self._panel_title_text_pad_x, + title_h - 2 * self._panel_title_text_pad_y, + self.s(title), + border=0, + ln=0, + align="L", + ) + + inner_x = x + self._panel_pad + inner_y = y + title_h + (self._panel_content_pad_top if title_h > 0 else self._panel_pad) + inner_w = w - 2 * self._panel_pad + inner_h = h - title_h - ((self._panel_content_pad_top if title_h > 0 else 0) + self._panel_pad) + + try: + if keep_aspect: + try: + self.image(str(p), x=inner_x, y=inner_y, w=inner_w, h=inner_h, keep_aspect_ratio=True) # type: ignore + except TypeError: + self.image(str(p), x=inner_x, y=inner_y, w=inner_w, h=inner_h) + else: + self.image(str(p), x=inner_x, y=inner_y, w=inner_w, h=inner_h) + except Exception: + return False + + return True + + def figure_grid_2x2( + self, + titles: Sequence[str], + paths: Sequence[Optional[str]], + *, + cell_h: float = 66.0, + gap: float = 4.0, + title_h: float = 6.0, + keep_aspect: bool = True, + ): + page_w = self.w - self.l_margin - self.r_margin + cell_w = (page_w - gap) / 2.0 + + x0 = self.l_margin + y0 = self.get_y() + + needed_h = cell_h * 2 + gap + 2 + if y0 + needed_h > self.page_break_trigger: + self.add_page() + y0 = self.get_y() + + self._image_panel(titles[0], paths[0] if len(paths) > 0 else None, x=x0, y=y0, w=cell_w, h=cell_h, title_h=title_h, keep_aspect=keep_aspect) + self._image_panel(titles[1], paths[1] if len(paths) > 1 else None, x=x0 + cell_w + gap, y=y0, w=cell_w, h=cell_h, title_h=title_h, keep_aspect=keep_aspect) + + y1 = y0 + cell_h + gap + self._image_panel(titles[2], paths[2] if len(paths) > 2 else None, x=x0, y=y1, w=cell_w, h=cell_h, title_h=title_h, keep_aspect=keep_aspect) + self._image_panel(titles[3], paths[3] if len(paths) > 3 else None, x=x0 + cell_w + gap, y=y1, w=cell_w, h=cell_h, title_h=title_h, keep_aspect=keep_aspect) + + self.set_y(y1 + cell_h + 2) + + def figure_row_2( + self, + titles: Sequence[str], + paths: Sequence[Optional[str]], + *, + h: float = 80.0, + gap: float = 4.0, + title_h: float = 6.0, + keep_aspect: bool = True, + ): + page_w = self.w - self.l_margin - self.r_margin + cell_w = (page_w - gap) / 2.0 + y0 = self.get_y() + if y0 + h + 2 > self.page_break_trigger: + self.add_page() + y0 = self.get_y() + + x0 = self.l_margin + self._image_panel(titles[0], paths[0] if len(paths) > 0 else None, x=x0, y=y0, w=cell_w, h=h, title_h=title_h, keep_aspect=keep_aspect) + self._image_panel(titles[1], paths[1] if len(paths) > 1 else None, x=x0 + cell_w + gap, y=y0, w=cell_w, h=h, title_h=title_h, keep_aspect=keep_aspect) + self.set_y(y0 + h + 2) + + def figure_single( + self, + title: str, + path: Optional[str], + *, + h: float = 90.0, + title_h: float = 6.0, + keep_aspect: bool = True, + ): + if not path: + return + p = Path(path) + if not p.exists(): + return + + page_w = self.w - self.l_margin - self.r_margin + y0 = self.get_y() + if y0 + h + 2 > self.page_break_trigger: + self.add_page() + y0 = self.get_y() + + self._image_panel(title, str(p), x=self.l_margin, y=y0, w=page_w, h=h, title_h=title_h, keep_aspect=keep_aspect) + self.set_y(y0 + h + 2) diff --git a/streamline/old_versions/p11_reporting/reporting_old.py b/streamline/old_versions/p11_reporting/reporting_old.py new file mode 100644 index 00000000..7b00ec7f --- /dev/null +++ b/streamline/old_versions/p11_reporting/reporting_old.py @@ -0,0 +1,1836 @@ +from __future__ import annotations + +import json +import logging +import math +import pickle +import re +import time +from pathlib import Path +from typing import Any, Dict, List, Optional, Sequence, Tuple, Union + +import pandas as pd +from fpdf import FPDF + +logger = logging.getLogger(__name__) + +Number = Union[int, float] + + +# ============================================================ +# Plot export helper (fallback-only; prefer precomputed PNGs) +# ============================================================ + +def _safe_plotly_to_png(fig, out_path: Path, scale: int = 2) -> bool: + """ + Export a Plotly figure to PNG using kaleido. + + This is a fallback path only: the report prefers precomputed PNGs + already present in the experiment output tree. + """ + try: + import plotly.io as pio # type: ignore + + out_path.parent.mkdir(parents=True, exist_ok=True) + pio.write_image(fig, str(out_path), format="png", scale=scale) + return True + except Exception as e: + logger.warning("Plotly export failed for %s: %r", out_path, e) + return False + + +def _now_iso_local() -> str: + return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) + + +def _try_streamline_version() -> str: + try: + import importlib.metadata as im + + return im.version("streamline") + except Exception: + return "unknown" + + +# ============================================================ +# Precision formatting +# ============================================================ + +def _is_nan(x: Any) -> bool: + try: + return isinstance(x, float) and math.isnan(x) + except Exception: + return False + + +def format_number( + x: Any, + *, + decimals: int = 3, + sci_small: float = 1e-3, + sci_decimals: int = 3, +) -> str: + """ + Canonical formatting for numeric table cells. + + - ints -> "42" + - floats -> fixed decimals unless abs(x) < sci_small (and non-zero), then scientific + - numeric strings -> parsed & formatted + - other strings -> unchanged + """ + if x is None or _is_nan(x): + return "" + + if isinstance(x, bool): + return "True" if x else "False" + + if isinstance(x, int): + return str(x) + + if isinstance(x, float): + if x == 0.0: + return f"{0:.{decimals}f}" + ax = abs(x) + if ax < sci_small: + return f"{x:.{sci_decimals}e}" + return f"{x:.{decimals}f}" + + if isinstance(x, str): + s = x.strip() + if s == "": + return "" + try: + f = float(s) + return format_number(f, decimals=decimals, sci_small=sci_small, sci_decimals=sci_decimals) + except Exception: + return x + + return str(x) + + +# ============================================================ +# Paths +# ============================================================ + +class ReportPaths: + def __init__(self, reporting_dir: Path, data_json: Path, pdf: Path, figures_dir: Path, metadata_txt: Path): + self.reporting_dir = reporting_dir + self.data_json = data_json + self.pdf = pdf + self.figures_dir = figures_dir + self.metadata_txt = metadata_txt + + +# ============================================================ +# Main job +# ============================================================ + +class ReportPhaseJob: + """ + Phase 11: Reporting (FPDF) + + Layout changes (per your request): + - Cover page looks like the legacy report (two-column parameter boxes). + - Metadata is also written as a plain text file (reporting/metadata.txt). + - Per-dataset order: + 1) EDA page (Page 1 for the dataset): class balance, missingness, (optional) univariate + 2) Feature learning page: feature importance/selection (all methods) + informative features table + 3) Performance page: combined model + ensemble performance tables (no wrapping; widths + truncation) + 4) Evaluation results page: ROC/PRC summary with original aspect ratio + (optional) per-model curves + - Univariate appears in EDA; automatically omitted if not informative. + + Data rules: + - Prefer precomputed PNGs already present in experiment outputs. + - Fallback to plotting/exporting into reporting/figures only if originals are missing. + """ + + def __init__( + self, + output_path: Optional[str] = None, + experiment_name: Optional[str] = None, + experiment_path: Optional[str] = None, + outcome_label: Optional[str] = None, + outcome_type: Optional[str] = None, + instance_label: Optional[str] = None, + make_pdf: bool = True, + float_decimals: int = 3, + ): + assert (output_path and experiment_name) or experiment_path, ( + "Provide (output_path, experiment_name) or experiment_path." + ) + + if experiment_path: + self.exp_root = Path(experiment_path) + self.output_path = str(self.exp_root.parent) + self.experiment_name = self.exp_root.name + else: + self.output_path = str(output_path) + self.experiment_name = str(experiment_name) + self.exp_root = Path(self.output_path) / self.experiment_name + + if not self.exp_root.is_dir(): + raise FileNotFoundError(f"Experiment folder not found: {self.exp_root}") + + # Match legacy cover title style + self.title = f"STREAMLINE Testing Data Evaluation Report: {_now_iso_local()}" + + self.make_pdf = make_pdf + self.job_start_time: Optional[float] = None + + self.outcome_label = outcome_label + self.outcome_type = outcome_type + self.instance_label = instance_label + + self.float_decimals = int(float_decimals) + self.paths = self._init_paths() + + def _init_paths(self) -> ReportPaths: + reporting_dir = self.exp_root / "reporting" + figures_dir = reporting_dir / "figures" + reporting_dir.mkdir(exist_ok=True) + figures_dir.mkdir(parents=True, exist_ok=True) + return ReportPaths( + reporting_dir=reporting_dir, + data_json=reporting_dir / "report_data.json", + pdf=reporting_dir / "report.pdf", + figures_dir=figures_dir, + metadata_txt=reporting_dir / "metadata.txt", + ) + + # ---------------------------- + # File readers + # ---------------------------- + def _read_csv_if_exists(self, path: Path) -> Optional[pd.DataFrame]: + try: + if path.is_file(): + return pd.read_csv(path) + except Exception as e: + logger.warning("Failed reading CSV %s: %r", path, e) + return None + + def _read_json_if_exists(self, path: Path) -> Optional[Dict[str, Any]]: + try: + if path.is_file(): + return json.loads(path.read_text()) + except Exception as e: + logger.warning("Failed reading JSON %s: %r", path, e) + return None + + def _read_pickle_if_exists(self, path: Path) -> Optional[Any]: + try: + if path.is_file(): + with path.open("rb") as f: + return pickle.load(f) + except Exception as e: + logger.warning("Failed reading pickle %s: %r", path, e) + return None + + # ---------------------------- + # Utilities: normalize/flatten/merge/pretty print + # ---------------------------- + def _flatten_mapping( + self, + obj: Any, + *, + prefix: str = "", + sep: str = " · ", + max_depth: int = 5, + _depth: int = 0, + ) -> Dict[str, Any]: + out: Dict[str, Any] = {} + if _depth > max_depth: + if prefix: + out[prefix] = str(obj) + return out + + if isinstance(obj, dict): + for k, v in obj.items(): + kk = str(k) + new_prefix = f"{prefix}{sep}{kk}" if prefix else kk + out.update(self._flatten_mapping(v, prefix=new_prefix, sep=sep, max_depth=max_depth, _depth=_depth + 1)) + return out + + if isinstance(obj, (list, tuple)): + if prefix: + out[prefix] = ", ".join(str(x) for x in obj) + return out + + if prefix: + out[prefix] = obj + return out + + def _merge_union_dicts(self, *dicts: Dict[str, Any]) -> Dict[str, Any]: + out: Dict[str, Any] = {} + for d in dicts: + for k, v in (d or {}).items(): + if k not in out: + out[k] = v + else: + if str(out[k]) != str(v): + alt_k = f"{k} (alt)" + i = 2 + while alt_k in out: + alt_k = f"{k} (alt {i})" + i += 1 + out[alt_k] = v + return out + + def _normalize_bool(self, v: Any) -> Optional[bool]: + if isinstance(v, bool): + return v + if isinstance(v, (int, float)) and v in (0, 1): + return bool(v) + if isinstance(v, str): + s = v.strip().lower() + if s in {"true", "t", "yes", "y", "1"}: + return True + if s in {"false", "f", "no", "n", "0"}: + return False + return None + + def _as_compact_str(self, v: Any) -> str: + if v is None: + return "None" + b = self._normalize_bool(v) + if b is not None: + return "True" if b else "False" + if isinstance(v, (int, float)): + return format_number(v, decimals=self.float_decimals) + if isinstance(v, (list, tuple)): + return "[" + ", ".join(str(x) for x in v) + "]" + return str(v) + + def _is_timestampy_key(self, k: str) -> bool: + s = k.lower() + if any(x in s for x in ["generated_at", "generated at", "epoch", "timestamp", "time stamp"]): + return True + # e.g., 2023-09-26 12:57:00.921630 or ISO-ish fragments in keys + if re.search(r"\b20\d{2}[-_/]\d{2}[-_/]\d{2}\b", s): + return True + if re.search(r"\b\d{2}:\d{2}:\d{2}\b", s): + return True + return False + + def _pretty_cover_key(self, k: str) -> str: + """ + Remove identifier-like prefixes and flatten separators for the cover page. + + - Drops leading "run_params ·" / "metadata ·" segments by taking last segment. + - Replaces underscores with spaces. + - Strips common "identifier_code"/"identifier" style keys. + """ + parts = [p.strip() for p in str(k).split("·")] + last = parts[-1] if parts else str(k) + last = last.strip() + last = last.replace("_", " ") + last = re.sub(r"\s+", " ", last).strip() + return last + + def _should_drop_identifier_code(self, k: str) -> bool: + s = k.lower() + # user: "remove the identifier code (code like variable name)" + # heuristics: keys that look like internal IDs / hashes / uid fields + if any(x in s for x in ["identifier code", "identifier_code", "run id", "run_id", "uuid", "guid", "hash", "job id", "job_id"]): + return True + # If key itself looks like a variable name but value looks like a hash/uid + return False + + def _write_metadata_text(self, *, cover_boxes: Dict[str, List[Tuple[str, str]]], enriched_meta: Dict[str, Any]) -> None: + """ + Write a plain text metadata file for easy grepping/logging. + """ + lines: List[str] = [] + lines.append(self.title) + lines.append(f"Experiment Root: {self.exp_root}") + lines.append(f"Experiment Name: {self.experiment_name}") + lines.append(f"Generated At: {_now_iso_local()}") + lines.append(f"STREAMLINE Version: {_try_streamline_version()}") + lines.append("") + + lines.append("=== COVER PARAMETERS (grouped) ===") + for section, items in (cover_boxes or {}).items(): + lines.append(f"[{section}]") + for k, v in items: + lines.append(f"- {k}: {v}") + lines.append("") + + lines.append("=== FULL METADATA UNION (flattened) ===") + for k in sorted(enriched_meta.keys(), key=lambda s: str(s).lower()): + lines.append(f"{k}: {self._as_compact_str(enriched_meta.get(k))}") + + self.paths.metadata_txt.write_text("\n".join(lines)) + + # ---------------------------- + # Dataset discovery + # ---------------------------- + def _list_datasets(self) -> List[Path]: + ignore = { + "jobs", + "logs", + "jobsCompleted", + "dask_logs", + "runtime", + "DatasetComparisons", + "reporting", + } + ds: List[Path] = [] + for p in sorted(self.exp_root.iterdir()): + if not p.is_dir(): + continue + if p.name in ignore: + continue + if (p / "CVDatasets").is_dir(): + ds.append(p) + return ds + + # ============================================================ + # Prefer-original figure resolution + # ============================================================ + + def _first_existing(self, candidates: Sequence[Path]) -> Optional[str]: + for p in candidates: + try: + if p.is_file(): + return str(p) + except Exception: + continue + return None + + def _figure_path_exploratory_class_balance(self, ds_dir: Path) -> Optional[str]: + return self._first_existing([ + ds_dir / "exploratory" / "ClassCountsBarPlot.png", + ds_dir / "exploratory" / "ClassCountsBarplot.png", + ds_dir / "exploratory" / "ClassCounts.png", + ]) + + def _figure_path_exploratory_missingness(self, ds_dir: Path) -> Optional[str]: + return self._first_existing([ + ds_dir / "exploratory" / "DataMissingness.png", + ds_dir / "exploratory" / "Missingness.png", + ds_dir / "exploratory" / "MissingnessTop25.png", + ]) + + def _figure_path_model_summary_roc_prc(self, ds_dir: Path, kind: str) -> Optional[str]: + if kind.lower() == "roc": + return self._first_existing([ds_dir / "model_evaluation" / "Summary_ROC.png"]) + return self._first_existing([ds_dir / "model_evaluation" / "Summary_PRC.png"]) + + def _figure_path_model_metric_boxplot(self, ds_dir: Path, preferred_metric: str) -> Optional[str]: + return self._first_existing([ + ds_dir / "model_evaluation" / "metricBoxplots" / f"Compare_{preferred_metric}.png", + ]) + + def _figure_path_ensemble_summary(self, ds_dir: Path, kind: str) -> Optional[str]: + if kind.lower() == "roc": + return self._first_existing([ds_dir / "ensemble_evaluation" / "Summary_ROC_ensembles.png"]) + return self._first_existing([ds_dir / "ensemble_evaluation" / "Summary_PRC_ensembles.png"]) + + def _figure_paths_fs_top_scores(self, ds_dir: Path) -> List[Dict[str, str]]: + """ + Return ALL existing TopAverageScores.png figures under feature_importance/*. + """ + base = ds_dir / "feature_importance" + if not base.is_dir(): + return [] + hits = sorted(base.glob("*/TopAverageScores.png"), key=lambda p: p.parent.name.lower()) + out: List[Dict[str, str]] = [] + for p in hits: + try: + if p.is_file(): + out.append({"method": p.parent.name, "path": str(p)}) + except Exception: + continue + return out + + def _figure_paths_model_curves(self, ds_dir: Path) -> Dict[str, List[str]]: + """ + Collect per-model ROC/PRC curves if present, e.g. LR_ROC.png, LR_PRC.png. + """ + out: Dict[str, List[str]] = {"roc": [], "prc": []} + me = ds_dir / "model_evaluation" + if not me.is_dir(): + return out + + for p in sorted(me.glob("*_ROC.png")): + if p.name.lower().startswith("summary_"): + continue + out["roc"].append(str(p)) + + for p in sorted(me.glob("*_PRC.png")): + if p.name.lower().startswith("summary_"): + continue + out["prc"].append(str(p)) + + return out + + def _figure_path_dataset_comparisons_any(self) -> Optional[str]: + box_dir = self.exp_root / "DatasetComparisons" / "dataCompBoxplots" + return self._first_existing([ + box_dir / "DataCompareAllModels_Balanced Accuracy.png", + box_dir / "DataCompareAllModels_ROC AUC.png", + box_dir / "DataCompareAllModels_PRC AUC.png", + box_dir / "DataCompareAllModels_Accuracy.png", + ]) + + # ============================================================ + # Plot builders (fallback only) + # ============================================================ + + def _plot_model_summary_bars(self, summary_mean: pd.DataFrame, metric: str, title: str): + import plotly.express as px # type: ignore + + df = summary_mean.copy() + if df.columns[0].lower() not in {"unnamed: 0", "model", "algorithm", "ml algorithm", "ml_algorithm"}: + if df.index.name is not None: + df = df.reset_index() + name_col = df.columns[0] + + if metric not in df.columns: + raise KeyError(metric) + + df = df[[name_col, metric]].dropna() + df = df.sort_values(metric, ascending=False) + + fig = px.bar(df, x=name_col, y=metric, title=title) + fig.update_layout(xaxis_title="Model", yaxis_title=metric) + return fig + + def _plot_class_counts(self, class_counts: pd.DataFrame, title: str): + import plotly.express as px # type: ignore + + df = class_counts.copy() + low = {c.lower(): c for c in df.columns} + label_col = None + count_col = None + + for cand in ["class", "label", "outcome", "y", "group"]: + if cand in low: + label_col = low[cand] + break + for cand in ["count", "n", "num", "frequency", "freq"]: + if cand in low: + count_col = low[cand] + break + + if label_col is None: + label_col = df.columns[0] + if count_col is None: + count_col = df.columns[1] if len(df.columns) > 1 else df.columns[0] + + df = df[[label_col, count_col]].dropna() + df[count_col] = pd.to_numeric(df[count_col], errors="coerce") + df = df.dropna() + fig = px.bar(df, x=label_col, y=count_col, title=title) + fig.update_layout(xaxis_title="Class", yaxis_title="Count") + return fig + + def _plot_missingness(self, missingness: pd.DataFrame, title: str): + import plotly.express as px # type: ignore + + df = missingness.copy() + low = {c.lower(): c for c in df.columns} + fcol = low.get("feature", df.columns[0]) + + pcol = None + for cand in ["missingpercent", "missing_percent", "percentmissing", "pct_missing", "missingpct"]: + if cand in low: + pcol = low[cand] + break + ccol = None + for cand in ["missingcount", "missing_count", "countmissing", "n_missing"]: + if cand in low: + ccol = low[cand] + break + + val_col = pcol or ccol or df.columns[-1] + df = df[[fcol, val_col]].dropna() + df[val_col] = pd.to_numeric(df[val_col], errors="coerce") + df = df.dropna().sort_values(val_col, ascending=False).head(25) + + fig = px.bar(df.iloc[::-1], x=val_col, y=fcol, orientation="h", title=title) + fig.update_layout(xaxis_title=val_col, yaxis_title="Feature") + return fig + + # ============================================================ + # Table building + # ============================================================ + + def _infer_alg_col(self, df: pd.DataFrame) -> str: + low = {c.lower(): c for c in df.columns} + for key in ["ml algorithm", "ml_algorithm", "algorithm", "model"]: + if key in low: + return low[key] + return df.columns[0] + + def _build_mean_std_table( + self, + mean_df: Optional[pd.DataFrame], + std_df: Optional[pd.DataFrame], + highlight_metric_candidates: List[str], + max_rows: int = 50, + ) -> Dict[str, Any]: + if mean_df is None or mean_df.empty or std_df is None or std_df.empty: + return {"present": False} + + m = mean_df.copy() + s = std_df.copy() + + alg_col_m = self._infer_alg_col(m) + alg_col_s = self._infer_alg_col(s) + if alg_col_m != "Algorithm": + m = m.rename(columns={alg_col_m: "Algorithm"}) + if alg_col_s != "Algorithm": + s = s.rename(columns={alg_col_s: "Algorithm"}) + + highlight_metric = None + for cand in highlight_metric_candidates: + if cand in m.columns: + highlight_metric = cand + break + + common_metrics = [c for c in m.columns if c != "Algorithm" and c in s.columns] + if not common_metrics: + return {"present": False} + + merged = m[["Algorithm"] + common_metrics].merge( + s[["Algorithm"] + common_metrics], + on="Algorithm", + how="inner", + suffixes=("_mean", "_std"), + ) + + columns = ["Algorithm"] + common_metrics + + best_alg = None + if highlight_metric and f"{highlight_metric}_mean" in merged.columns: + try: + best_idx = merged[f"{highlight_metric}_mean"].astype(float).idxmax() + best_alg = str(merged.loc[best_idx, "Algorithm"]) + except Exception: + best_alg = None + + rows = [] + for _, r in merged.head(max_rows).iterrows(): + cells = [] + for c in columns: + if c == "Algorithm": + alg = str(r["Algorithm"]) + cells.append({"value": alg, "best": bool(best_alg and alg == best_alg)}) + else: + mv = r.get(f"{c}_mean", None) + sv = r.get(f"{c}_std", None) + cells.append({"value": (mv, sv), "best": False}) + rows.append({"cells": cells}) + + return { + "present": True, + "columns": columns, + "rows": rows, + "highlight_metric": highlight_metric, + "best_algorithm": best_alg, + } + + def _build_plain_table(self, df: Optional[pd.DataFrame], max_rows: int = 100) -> Dict[str, Any]: + if df is None or df.empty: + return {"present": False} + df2 = df.head(max_rows).copy() + df2 = df2.where(pd.notnull(df2), None) + return {"present": True, "columns": list(df2.columns), "rows": df2.values.tolist()} + + def _univariate_is_informative(self, uni: Optional[pd.DataFrame]) -> bool: + """ + Drop univariate if it doesn't add much: + - missing/empty -> False + - <3 rows -> False + - if a p-value column exists, require at least one p < 0.10 + """ + if uni is None or uni.empty: + return False + if len(uni) < 3: + return False + + low = {c.lower(): c for c in uni.columns} + pcol = None + for cand in ["p", "p-value", "p_value", "pvalue", "pval"]: + if cand in low: + pcol = low[cand] + break + if pcol is None: + # If no p-values, still consider it useful if it has at least 2+ columns and non-trivial rows + return uni.shape[1] >= 2 and len(uni) >= 5 + + try: + pv = pd.to_numeric(uni[pcol], errors="coerce").dropna() + if pv.empty: + return False + return bool((pv < 0.10).any()) + except Exception: + return False + + # ============================================================ + # Cover page grouping (match legacy report categories) + # ============================================================ + + def _categorize_cover_items( + self, + meta_pickle_flat: Dict[str, Any], + run_params_flat: Dict[str, Any], + *, + exp_root: Path, + ) -> Dict[str, List[Tuple[str, str]]]: + """ + Create the cover page boxes in the same spirit as the legacy report, + while removing duplicate timestamped params and identifier-code-ish fields. + """ + combined = self._merge_union_dicts(run_params_flat or {}, meta_pickle_flat or {}) + + def add(cat: str, k: str, v: Any): + # Clean and filter keys + if self._is_timestampy_key(k): + return + if self._should_drop_identifier_code(k): + return + + pretty_k = self._pretty_cover_key(k) + + # If key is still ugly variable-ish, keep it but at least space it. + if pretty_k.strip() == "": + return + + out.setdefault(cat, []).append((pretty_k, self._as_compact_str(v))) + + out: Dict[str, List[Tuple[str, str]]] = {} + + # --- Target Dataset(s): infer from folder structure if not present + ds_names = [p.name for p in self._list_datasets()] + if ds_names: + items = [(f"D{i+1}", nm) for i, nm in enumerate(ds_names)] + out["Target Dataset(s):"] = [(f"{k}", f"= {v}") for k, v in items] + + # --- Target Data Settings (paths/labels) + for key in [ + "data path", "input path", "dataset path", + "output path", + "experiment name", + "class label", + "instance label", + "match label", + "ignored features", + "specified categorical features", + "specified quantitative features", + ]: + for kk in list(combined.keys()): + if str(kk).strip().lower() == key: + add("Target Data Settings:", kk, combined[kk]) + + # --- General Pipeline Settings + for kk, vv in combined.items(): + k = str(kk).lower() + if any(x in k for x in ["cv", "partition", "seed", "random", "categorical cutoff", "statistical", "significance", "notebook"]): + if any(x in k for x in ["plot", "export", "roc", "prc", "figure", "boxplot"]): + continue + add("General Pipeline Settings:", kk, vv) + + # --- EDA and Processing Settings + for kk, vv in combined.items(): + k = str(kk).lower() + if any(x in k for x in ["missing", "imput", "scale", "correlation", "describe", "univariate", "eda", "processing", "clean"]): + if any(x in k for x in ["feature importance", "feature_selection", "feature selection", "multisurf", "mutual", "turf"]): + continue + add("EDA and Processing Settings:", kk, vv) + + # --- Feature Importance/Selection Settings + for kk, vv in combined.items(): + k = str(kk).lower() + if any(x in k for x in ["feature importance", "feature selection", "multisurf", "mutual", "turf", "max features", "top features", "filter poor"]): + add("Feature Importance/Selection Settings:", kk, vv) + + # --- ML Modeling Algorithms (boolean toggles) + algo_items: List[Tuple[str, str]] = [] + algo_keys = [ + "logistic", "naive", "bayes", "random forest", "svm", "support vector", + "xgboost", "gradient boosting", "lightgbm", "catboost", + "decision tree", "elastic", "knn", "k-nearest", + "ann", "neural", "exstracs", "xcs", "elcs", "genetic programming", + ] + for kk, vv in combined.items(): + k = str(kk).lower() + if any(a in k for a in algo_keys): + b = self._normalize_bool(vv) + if b is None: + continue + algo_items.append((self._pretty_cover_key(kk), "True" if b else "False")) + if algo_items: + algo_items.sort(key=lambda t: (t[1] != "True", t[0].lower())) + out["ML Modeling Algorithms:"] = algo_items + + # --- Modeling Settings + for kk, vv in combined.items(): + k = str(kk).lower() + if any(x in k for x in ["primary metric", "hyperparameter", "trials", "timeout", "subsample", "uniform feature importance"]): + add("Modeling Settings:", kk, vv) + + # --- LCS Settings + for kk, vv in combined.items(): + k = str(kk).lower() + if any(x in k for x in ["lcs", "xcs", "elcs", "exstracs", "rule population", "training iterations", "nu"]): + add("LCS Settings (eLCS, XCS, ExSTraCS):", kk, vv) + + # --- Stats and Figure Settings + for kk, vv in combined.items(): + k = str(kk).lower() + if any(x in k for x in ["export", "roc", "prc", "boxplot", "figure", "plot", "correlation", "top model features", "metric weighting"]): + add("Stats and Figure Settings:", kk, vv) + + # Deduplicate by key within sections (keep first) + for cat, items in list(out.items()): + seen = set() + dedup: List[Tuple[str, str]] = [] + for k, v in items: + if k in seen: + continue + seen.add(k) + dedup.append((k, v)) + out[cat] = dedup + + # Ensure legacy order + ordered = [ + "General Pipeline Settings:", + "EDA and Processing Settings:", + "Feature Importance/Selection Settings:", + "ML Modeling Algorithms:", + "Modeling Settings:", + "LCS Settings (eLCS, XCS, ExSTraCS):", + "Stats and Figure Settings:", + "Target Dataset(s):", + "Target Data Settings:", + ] + out2: Dict[str, List[Tuple[str, str]]] = {} + for cat in ordered: + if cat in out and out[cat]: + out2[cat] = out[cat] + for cat, items in out.items(): + if cat not in out2 and items: + out2[cat] = items + return out2 + + # ============================================================ + # Data assembly (tables + figs) + # ============================================================ + + def _collect_dataset_block(self, ds_dir: Path) -> Dict[str, Any]: + name = ds_dir.name + figs: Dict[str, Any] = {} + + explore = ds_dir / "exploratory" + data_process_summary = self._read_csv_if_exists(explore / "DataProcessSummary.csv") + class_counts = self._read_csv_if_exists(explore / "ClassCounts.csv") + missingness = self._read_csv_if_exists(explore / "DataMissingness.csv") + univariate = self._read_csv_if_exists(explore / "univariate_analyses" / "Univariate_Significance.csv") + + # Univariate: keep only if informative; show Top 10 + uni_use = self._univariate_is_informative(univariate) + univariate_top10 = univariate.head(10) if (uni_use and univariate is not None and not univariate.empty) else None + + model_eval = ds_dir / "model_evaluation" + summary_mean = self._read_csv_if_exists(model_eval / "Summary_performance_mean.csv") + summary_std = self._read_csv_if_exists(model_eval / "Summary_performance_std.csv") + summary_median = self._read_csv_if_exists(model_eval / "Summary_performance_median.csv") + + ens_eval = ds_dir / "ensemble_evaluation" + ens_mean = self._read_csv_if_exists(ens_eval / "Ensembles_performance_mean.csv") + ens_std = self._read_csv_if_exists(ens_eval / "Ensembles_performance_std.csv") + ens_median = self._read_csv_if_exists(ens_eval / "Ensembles_performance_median.csv") + + feat_sel = self._read_csv_if_exists(ds_dir / "feature_selection" / "InformativeFeatureSummary.csv") + runtimes = self._read_csv_if_exists(ds_dir / "runtimes.csv") + + # Figures: EDA (prefer originals) + figs["class_balance"] = self._figure_path_exploratory_class_balance(ds_dir) or "" + if not figs["class_balance"] and class_counts is not None and not class_counts.empty: + try: + fig = self._plot_class_counts(class_counts, f"{name}: Class Balance") + out = self.paths.figures_dir / f"{name}_class_balance.png" + if _safe_plotly_to_png(fig, out): + figs["class_balance"] = str(out) + except Exception as e: + logger.warning("Class balance plot failed for %s: %r", name, e) + + figs["missingness"] = self._figure_path_exploratory_missingness(ds_dir) or "" + if not figs["missingness"] and missingness is not None and not missingness.empty: + try: + fig = self._plot_missingness(missingness, f"{name}: Missingness (Top 25 Features)") + out = self.paths.figures_dir / f"{name}_missingness_top25.png" + if _safe_plotly_to_png(fig, out): + figs["missingness"] = str(out) + except Exception as e: + logger.warning("Missingness plot failed for %s: %r", name, e) + + # Performance: prefer summary/boxplots + figs["models_mean_bar"] = "" + figs["models_cv_box"] = "" + + chosen_metric = None + if summary_mean is not None and not summary_mean.empty: + for preferred in ["Balanced Accuracy", "ROC AUC", "PRC AUC", "Accuracy"]: + if preferred in summary_mean.columns: + chosen_metric = preferred + break + + if chosen_metric: + box = self._figure_path_model_metric_boxplot(ds_dir, chosen_metric) + if box: + figs["models_cv_box"] = box + if box and not figs["models_mean_bar"]: + figs["models_mean_bar"] = box + if not figs["models_mean_bar"]: + try: + fig = self._plot_model_summary_bars(summary_mean, chosen_metric, f"{name}: Mean {chosen_metric} (Models)") + out = self.paths.figures_dir / f"{name}_models_mean_{chosen_metric.replace(' ', '_')}.png" + if _safe_plotly_to_png(fig, out): + figs["models_mean_bar"] = str(out) + except Exception as e: + logger.warning("Model mean bar plot failed for %s (%s): %r", name, chosen_metric, e) + + # Evaluation results: ROC/PRC summaries (and per-model curves) + figs["models_roc_overlay"] = self._figure_path_model_summary_roc_prc(ds_dir, "roc") or "" + figs["models_prc_overlay"] = self._figure_path_model_summary_roc_prc(ds_dir, "prc") or "" + + figs["ensembles_roc"] = self._figure_path_ensemble_summary(ds_dir, "roc") or "" + figs["ensembles_prc"] = self._figure_path_ensemble_summary(ds_dir, "prc") or "" + + figs["model_curves"] = self._figure_paths_model_curves(ds_dir) # {"roc":[...], "prc":[...]} + + # Feature learning: ALL FI methods + fi_methods = self._figure_paths_fs_top_scores(ds_dir) + figs["fi_top_scores"] = fi_methods + + # Tables + models_mean_std = self._build_mean_std_table( + summary_mean, + summary_std, + highlight_metric_candidates=["Balanced Accuracy", "ROC AUC", "PRC AUC", "Accuracy"], + ) + models_median = self._build_plain_table(summary_median, max_rows=100) + + ensembles_mean_std = self._build_mean_std_table( + ens_mean, + ens_std, + highlight_metric_candidates=["Balanced Accuracy", "ROC AUC", "PRC AUC", "Accuracy"], + ) + ensembles_median = self._build_plain_table(ens_median, max_rows=100) + + return { + "dataset_name": name, + "dataset_dir": str(ds_dir), + "tables": { + "data_process_summary": self._build_plain_table(data_process_summary, max_rows=50), + "univariate_top10": self._build_plain_table(univariate_top10, max_rows=10), + "informative_feature_summary": self._build_plain_table(feat_sel, max_rows=200), + "runtimes": self._build_plain_table(runtimes, max_rows=500), + }, + "perf": { + "models_mean_std": models_mean_std, + "models_median": models_median, + "ensembles_mean_std": ensembles_mean_std, + "ensembles_median": ensembles_median, + }, + "figures": figs, + } + + def _collect_dataset_comparisons_block(self) -> Dict[str, Any]: + dc = self.exp_root / "DatasetComparisons" + if not dc.is_dir(): + return {"present": False} + + best_kw = self._read_csv_if_exists(dc / "BestCompare_KruskalWallis.csv") + best_mw = self._read_csv_if_exists(dc / "BestCompare_MannWhitney.csv") + best_wx = self._read_csv_if_exists(dc / "BestCompare_WilcoxonRank.csv") + + figs: Dict[str, str] = {} + any_plot = self._figure_path_dataset_comparisons_any() + if any_plot: + figs["overview"] = any_plot + + return { + "present": True, + "tables": { + "best_kw": self._build_plain_table(best_kw, max_rows=200), + "best_mw": self._build_plain_table(best_mw, max_rows=200), + "best_wx": self._build_plain_table(best_wx, max_rows=200), + }, + "figures": figs, + } + + # ============================================================ + # PDF render + # ============================================================ + + def _write_pdf(self, report_data: Dict[str, Any]) -> None: + pdf = _StreamlinePDF( + title=str(report_data.get("title", "")), + streamline_version=str(report_data.get("streamline_version", "")), + float_decimals=self.float_decimals, + ) + pdf.alias_nb_pages() + + # COVER (legacy-like) + pdf.add_page() + pdf.cover_banner_title(str(report_data.get("title", ""))) + pdf.cover_two_column_boxes(report_data.get("cover_boxes", {}) or {}) + + # DATASETS (per-dataset page order you requested) + for ds in report_data.get("datasets", []) or []: + ds_name = str(ds.get("dataset_name", "")) + ds_dir = str(ds.get("dataset_dir", "")) + + figs = ds.get("figures", {}) or {} + tables = ds.get("tables", {}) or {} + perf = ds.get("perf", {}) or {} + + # ------------------------- + # EDA - PAGE 1 (per dataset) + # ------------------------- + pdf.add_page() + pdf.panel_title(f"Dataset: {ds_name}") + pdf.set_font("Times", "", 10) + if ds_dir: + pdf.multi_cell(0, 5, ds_dir) + pdf.ln(1.0) + + pdf.panel_title("EDA") + pdf.figure_row_2( + titles=["Class Balance", "Missingness (Top 25 Features)"], + paths=[figs.get("class_balance") or None, figs.get("missingness") or None], + h=82.0, + gap=4.0, + title_h=6.0, + ) + + # Univariate first (and drop if not useful; already filtered) + uni = tables.get("univariate_top10", {}) or {} + if uni.get("present"): + pdf.panel_title("Univariate Analysis (Top 10)") + pdf.draw_table(uni.get("columns", []), uni.get("rows", []), max_rows=10) + + # Optional: data process summary fits naturally under EDA + dps = tables.get("data_process_summary", {}) or {} + if dps.get("present"): + pdf.panel_title("Data Processing Summary") + pdf.draw_table(dps.get("columns", []), dps.get("rows", []), max_rows=50) + + # ------------------------- + # Feature Learning + # ------------------------- + pdf.add_page() + pdf.panel_title(f"Dataset: {ds_name}") + pdf.panel_title("Feature Learning") + + fi_list = figs.get("fi_top_scores") or [] + norm: List[Dict[str, str]] = [] + for item in fi_list: + if isinstance(item, dict) and "path" in item: + norm.append({"method": str(item.get("method") or "method"), "path": str(item["path"])}) + elif isinstance(item, str): + norm.append({"method": "method", "path": item}) + + if not norm: + pdf.muted("Missing: feature_importance/*/TopAverageScores.png") + elif len(norm) == 1: + pdf.figure_single(f"Top Scores ({norm[0]['method']})", norm[0]["path"], h=130.0, title_h=6.0) + elif len(norm) == 2: + pdf.figure_row_2( + titles=[f"Top Scores ({norm[0]['method']})", f"Top Scores ({norm[1]['method']})"], + paths=[norm[0]["path"], norm[1]["path"]], + h=95.0, + gap=4.0, + title_h=6.0, + ) + else: + # 2x2 pages for many methods + for i in range(0, len(norm), 4): + chunk = norm[i: i + 4] + titles = [f"Top Scores ({c['method']})" for c in chunk] + paths = [c["path"] for c in chunk] + while len(titles) < 4: + titles.append("") + paths.append(None) + pdf.figure_grid_2x2(titles=titles, paths=paths, cell_h=66.0, gap=4.0, title_h=6.0) + if i + 4 < len(norm): + pdf.add_page() + pdf.panel_title(f"Dataset: {ds_name}") + pdf.panel_title("Feature Learning") + + # Informative feature summary (selection output) + inf = tables.get("informative_feature_summary", {}) or {} + if inf.get("present"): + pdf.panel_title("Informative Feature Summary") + pdf.draw_table(inf.get("columns", []), inf.get("rows", []), max_rows=200) + else: + pdf.muted("Missing: feature_selection/InformativeFeatureSummary.csv") + + # ------------------------- + # Performance (CV-based): combine model + ensemble tables + # - no wrapping (truncate) + # - column widths driven by tuned allocation + # ------------------------- + pdf.add_page() + pdf.panel_title(f"Dataset: {ds_name}") + pdf.panel_title("Performance (Cross-Validation)") + + ms = perf.get("models_mean_std", {}) or {} + es = perf.get("ensembles_mean_std", {}) or {} + mm = perf.get("models_median", {}) or {} + em = perf.get("ensembles_median", {}) or {} + + pdf.subheader("Model + Ensemble Performance (Mean ± SD)") + if ms.get("present"): + pdf.draw_mean_std_table(ms, no_wrap=True) + else: + pdf.muted("Missing: model_evaluation/Summary_performance_mean.csv and/or Summary_performance_std.csv") + + if es.get("present"): + pdf.draw_mean_std_table(es, no_wrap=True) + + # Optional: median tables (often redundant). Keep only if present and not huge. + if mm.get("present") or em.get("present"): + pdf.subheader("Median (optional)") + if mm.get("present"): + pdf.draw_table(mm.get("columns", []), mm.get("rows", []), max_rows=80, no_wrap=True) + if em.get("present"): + pdf.draw_table(em.get("columns", []), em.get("rows", []), max_rows=80, no_wrap=True) + + # If a boxplot exists, show it here as the “distribution” companion + if figs.get("models_cv_box") or figs.get("models_mean_bar"): + pdf.panel_title("Performance Distribution / Comparison Plot") + pdf.figure_single( + "Model Comparison / Boxplot", + figs.get("models_cv_box") or figs.get("models_mean_bar") or None, + h=110.0, + title_h=6.0, + keep_aspect=True, + ) + + # ------------------------- + # Evaluation results (post-CV): ROC/PRC summary + per-model curves + # Use original aspect ratio where possible. + # ------------------------- + pdf.add_page() + pdf.panel_title(f"Dataset: {ds_name}") + pdf.panel_title("Evaluation Results (Curves)") + + pdf.figure_row_2( + titles=["Summary ROC", "Summary PRC"], + paths=[figs.get("models_roc_overlay") or None, figs.get("models_prc_overlay") or None], + h=85.0, + gap=4.0, + title_h=6.0, + keep_aspect=True, + ) + + if figs.get("ensembles_roc") or figs.get("ensembles_prc"): + pdf.panel_title("Ensembles (Summary Curves)") + pdf.figure_row_2( + titles=["Ensembles ROC", "Ensembles PRC"], + paths=[figs.get("ensembles_roc") or None, figs.get("ensembles_prc") or None], + h=85.0, + gap=4.0, + title_h=6.0, + keep_aspect=True, + ) + + # Per-model ROC/PRC (show a compact selection) + curves = figs.get("model_curves") or {} + roc_list = list(curves.get("roc") or []) + prc_list = list(curves.get("prc") or []) + if roc_list or prc_list: + # Show up to 4 ROC + 4 PRC over pages + def take_chunks(xs: List[str], n: int) -> List[List[str]]: + return [xs[i:i + n] for i in range(0, len(xs), n)] + + roc_chunks = take_chunks(roc_list[:8], 4) + prc_chunks = take_chunks(prc_list[:8], 4) + + # Interleave ROC then PRC pages + for chunk in roc_chunks: + pdf.panel_title("Per-Model ROC Curves (sample)") + titles = [Path(p).stem for p in chunk] + paths = chunk + while len(titles) < 4: + titles.append("") + paths.append(None) + pdf.figure_grid_2x2(titles=titles, paths=paths, cell_h=66.0, gap=4.0, title_h=6.0, keep_aspect=True) + if chunk is not roc_chunks[-1] or prc_chunks: + pdf.add_page() + pdf.panel_title(f"Dataset: {ds_name}") + pdf.panel_title("Evaluation Results (Curves)") + + for chunk in prc_chunks: + pdf.panel_title("Per-Model PRC Curves (sample)") + titles = [Path(p).stem for p in chunk] + paths = chunk + while len(titles) < 4: + titles.append("") + paths.append(None) + pdf.figure_grid_2x2(titles=titles, paths=paths, cell_h=66.0, gap=4.0, title_h=6.0, keep_aspect=True) + if chunk is not prc_chunks[-1]: + pdf.add_page() + pdf.panel_title(f"Dataset: {ds_name}") + pdf.panel_title("Evaluation Results (Curves)") + + # ------------------------- + # Runtimes (still its own page) + # ------------------------- + pdf.add_page() + pdf.panel_title(f"Dataset: {ds_name}") + pdf.panel_title("Runtime Summary") + rt = tables.get("runtimes", {}) or {} + if rt.get("present"): + pdf.draw_table(rt.get("columns", []), rt.get("rows", []), max_rows=500, no_wrap=True) + else: + pdf.muted("Missing: runtimes.csv") + + # DATASET COMPARISONS (global) + dc = report_data.get("dataset_comparisons", {}) or {} + if dc.get("present"): + pdf.add_page() + pdf.panel_title("Dataset Comparisons") + + overview = (dc.get("figures", {}) or {}).get("overview") + pdf.figure_single("Comparison Overview (All Datasets)", overview or None, h=120.0, title_h=6.0, keep_aspect=True) + + kw = (dc.get("tables", {}) or {}).get("best_kw", {}) or {} + if kw.get("present"): + pdf.panel_title("Best Comparisons - Kruskal-Wallis") + pdf.draw_table(kw.get("columns", []), kw.get("rows", []), max_rows=200, no_wrap=True) + + mw = (dc.get("tables", {}) or {}).get("best_mw", {}) or {} + if mw.get("present"): + pdf.panel_title("Best Comparisons - Mann-Whitney U") + pdf.draw_table(mw.get("columns", []), mw.get("rows", []), max_rows=200, no_wrap=True) + + wx = (dc.get("tables", {}) or {}).get("best_wx", {}) or {} + if wx.get("present"): + pdf.panel_title("Best Comparisons - Wilcoxon Rank-Sum") + pdf.draw_table(wx.get("columns", []), wx.get("rows", []), max_rows=200, no_wrap=True) + + pdf.output(str(self.paths.pdf)) + + # ---------------------------- + # Runtime bookkeeping + # ---------------------------- + def save_runtime(self): + rt_dir = self.exp_root / "runtime" + rt_dir.mkdir(exist_ok=True) + (rt_dir / "runtime_report.txt").write_text(str(time.time() - (self.job_start_time or time.time()))) + + def run(self): + self.job_start_time = time.time() + + datasets = self._list_datasets() + if not datasets: + raise RuntimeError(f"No dataset folders (with CVDatasets/) found under: {self.exp_root}") + + dataset_blocks = [self._collect_dataset_block(ds) for ds in datasets] + dc_block = self._collect_dataset_comparisons_block() + + # Pickles for cover metadata/params + meta_pickle_obj = self._read_pickle_if_exists(self.exp_root / "metadata.pickle") + run_params_obj = self._read_pickle_if_exists(self.exp_root / "run_params.pickle") + + meta_pickle_dict: Dict[str, Any] = meta_pickle_obj if isinstance(meta_pickle_obj, dict) else ({"metadata.pickle": str(meta_pickle_obj)} if meta_pickle_obj is not None else {}) + run_params_dict: Dict[str, Any] = run_params_obj if isinstance(run_params_obj, dict) else ({"run_params.pickle": str(run_params_obj)} if run_params_obj is not None else {}) + + meta_flat = self._flatten_mapping(meta_pickle_dict, sep=" · ", max_depth=6) if meta_pickle_dict else {} + params_flat = self._flatten_mapping(run_params_dict, sep=" · ", max_depth=6) if run_params_dict else {} + + cover_boxes = self._categorize_cover_items(meta_flat, params_flat, exp_root=self.exp_root) + + base_meta: Dict[str, Any] = { + "Experiment Root": str(self.exp_root), + "Output Path": str(self.exp_root.parent), + "Experiment Name": self.experiment_name, + "Datasets Found": len(datasets), + "Generated At": _now_iso_local(), + } + if self.outcome_label: + base_meta["Outcome Label"] = self.outcome_label + if self.instance_label: + base_meta["Instance Label"] = self.instance_label + if self.outcome_type: + base_meta["Outcome Type"] = self.outcome_type + + enriched_meta = self._merge_union_dicts(base_meta, meta_flat, params_flat) + + report_data: Dict[str, Any] = { + "title": self.title, + "experiment_name": self.experiment_name, + "experiment_root": str(self.exp_root), + "generated_at": _now_iso_local(), + "generated_at_epoch": int(time.time()), + "streamline_version": _try_streamline_version(), + "metadata": enriched_meta, + "metadata_pickle_flat": meta_flat, + "run_params_flat": params_flat, + "cover_boxes": cover_boxes, + "datasets": dataset_blocks, + "dataset_comparisons": dc_block, + } + + # JSON for downstream debugging (kept) + self.paths.data_json.write_text(json.dumps(report_data, indent=2)) + + # Metadata as text file (requested) + self._write_metadata_text(cover_boxes=cover_boxes, enriched_meta=enriched_meta) + + if self.make_pdf: + self._write_pdf(report_data) + + jc = self.exp_root / "jobsCompleted" + jc.mkdir(exist_ok=True) + (jc / "job_reporting.txt").write_text("complete") + + self.save_runtime() + logger.info("Phase 11 reporting complete: %s", self.paths.pdf) + + +# ============================================================ +# PDF renderer (legacy-like cover + boxed sections) +# ============================================================ + +class _StreamlinePDF(FPDF): + def __init__(self, *, title: str, streamline_version: str, float_decimals: int = 3): + super().__init__(orientation="P", unit="mm", format="A4") + self._title = title + self._streamline_version = streamline_version + self._decimals = int(float_decimals) + + self.set_margins(10, 10, 10) + self.set_auto_page_break(auto=True, margin=14) + self.set_line_width(0.2) + + self._use_running_header = False + + # table layout + self._tbl_pad_x = 1.2 + self._tbl_pad_y = 0.8 + self._tbl_line_h = 3.4 + self._gap_after_table = 1.2 + + # figure panel padding + self._panel_pad = 2.0 + self._panel_title_text_pad_x = 1.4 + self._panel_title_text_pad_y = 1.4 + self._panel_content_pad_top = 2.2 + + def header(self): + if not self._use_running_header: + return + self.set_font("Times", "", 9) + x = self.l_margin + y = self.t_margin + w = self.w - self.l_margin - self.r_margin + self.set_xy(x, y - 2) + self.line(x, y, x + w, y) + self.set_xy(x, y) + self.cell(w, 4, self._title, border=0, ln=1, align="L") + self.ln(2) + + def footer(self): + self.set_y(-10) + self.set_font("Times", "I", 8) + left = f"Generated with STREAMLINE ({self._streamline_version})" + right = f"Page {self.page_no()}/{{nb}}" + self.set_x(self.l_margin) + self.cell(0, 5, left, border=0, ln=0, align="L") + self.set_x(self.l_margin) + self.cell(self.w - self.l_margin - self.r_margin, 5, right, border=0, ln=0, align="R") + + # ----------------------------- + # Legacy-like cover + # ----------------------------- + def cover_banner_title(self, title: str): + x = self.l_margin + y = self.t_margin + w = self.w - self.l_margin - self.r_margin + h = 12 + + self.set_font("Times", "B", 14) + self.set_xy(x, y) + self.rect(x, y, w, h) + self.set_xy(x + 2, y + 3.2) + self.cell(w - 4, 6, title, border=0, ln=1, align="L") + self.ln(3) + + def _cover_section_box( + self, + title: str, + items: Sequence[Tuple[str, str]], + *, + x: float, + y: float, + w: float, + max_items: Optional[int] = None, + title_h: float = 6.0, + row_h: float = 4.6, + font_size: int = 9, + ) -> float: + if max_items is not None: + items = items[:max_items] + + content_h = max(1, len(items)) * row_h + h = title_h + content_h + 1.4 + + if y + h > (self.h - self.b_margin - 2): + self.add_page() + y = self.get_y() + + self.rect(x, y, w, h) + self.rect(x, y, w, title_h) + + self.set_font("Times", "B", 11) + self.set_xy(x + 1.6, y + 1.6) + self.cell(w - 3.2, title_h - 3.2, title, border=0, ln=0, align="L") + + self.set_font("Times", "", font_size) + cy = y + title_h + 0.6 + for k, v in items: + line = f"{k}: {v}" + self.set_xy(x + 1.8, cy) + self.multi_cell(w - 3.6, row_h, line, border=0) + cy += row_h + + return h + + def cover_two_column_boxes(self, boxes: Dict[str, List[Tuple[str, str]]]): + page_w = self.w - self.l_margin - self.r_margin + gap = 4.0 + col_w = (page_w - gap) / 2.0 + + xL = self.l_margin + xR = self.l_margin + col_w + gap + + left_order = [ + "General Pipeline Settings:", + "Feature Importance/Selection Settings:", + "ML Modeling Algorithms:", + "Modeling Settings:", + "LCS Settings (eLCS, XCS, ExSTraCS):", + "Stats and Figure Settings:", + ] + right_order = [ + "EDA and Processing Settings:", + "Target Dataset(s):", + "Target Data Settings:", + ] + + y_start = self.get_y() + yL = y_start + yR = y_start + + for title in left_order: + items = boxes.get(title) or [] + if not items: + continue + h = self._cover_section_box(title, items, x=xL, y=yL, w=col_w, title_h=6.0, row_h=4.6, font_size=9) + yL += h + 2.0 + + for title in right_order: + items = boxes.get(title) or [] + if not items: + continue + font_size = 8 if title in {"EDA and Processing Settings:", "Target Data Settings:"} else 9 + row_h = 4.4 if font_size == 8 else 4.6 + h = self._cover_section_box(title, items, x=xR, y=yR, w=col_w, title_h=6.0, row_h=row_h, font_size=font_size) + yR += h + 2.0 + + self.set_y(max(yL, yR) + 1.0) + + # ----------------------------- + # Section typography + # ----------------------------- + def panel_title(self, title: str, *, h: float = 6.0): + w = self.w - self.l_margin - self.r_margin + if self.get_y() + h + 2 > self.page_break_trigger: + self.add_page() + + x = self.l_margin + y = self.get_y() + self.set_font("Times", "B", 10) + self.rect(x, y, w, h) + self.set_xy(x + 1.4, y + 1.4) + self.cell(w - 2.8, h - 2.8, title, border=0, ln=1, align="L") + self.ln(1.2) + + def subheader(self, text: str): + self.set_font("Times", "B", 10) + self.multi_cell(0, 5, text) + self.ln(0.8) + + def muted(self, text: str): + self.set_font("Times", "", 9) + self.multi_cell(0, 4.5, text) + self.ln(0.8) + + def _cell_str(self, v: Any) -> str: + return format_number(v, decimals=self._decimals) + + # ----------------------------- + # No-wrap table rendering (truncate to fit) + # ----------------------------- + def _truncate_to_width(self, s: str, w_mm: float) -> str: + """ + Truncate string to fit inside width (mm) using current font metrics. + """ + if s is None: + return "" + s = str(s) + if self.get_string_width(s) <= w_mm: + return s + if w_mm <= self.get_string_width("..."): + return "" + # binary-ish shrink + ell = "..." + lo, hi = 0, len(s) + best = "" + while lo <= hi: + mid = (lo + hi) // 2 + cand = s[:mid] + ell + if self.get_string_width(cand) <= w_mm: + best = cand + lo = mid + 1 + else: + hi = mid - 1 + return best or ell + + # ----------------------------- + # Tables + # ----------------------------- + def _col_widths_model_perf(self, columns: Sequence[str], table_w: float) -> List[float]: + """ + Performance tables: prioritize metric columns to reduce need for wrapping. + """ + n = len(columns) + if n <= 1: + return [table_w] + + # shrink Algorithm column more than before + first = min(max(32.0, 0.16 * table_w), 46.0) + + metric_cols = list(columns[1:]) + weights: List[float] = [] + for c in metric_cols: + cl = c.lower() + w = 1.0 + min(1.6, len(c) / 16.0) + if "sensitivity" in cl or "precision" in cl or "specificity" in cl: + w *= 1.25 + if "balanced" in cl: + w *= 1.10 + if "roc" in cl or "prc" in cl: + w *= 1.10 + weights.append(w) + + rest = max(0.0, table_w - first) + sw = sum(weights) if sum(weights) > 0 else float(len(weights)) + raw = [rest * (w / sw) for w in weights] + + # enforce larger minimum metric width to avoid wraps + min_metric = 18.0 + raw = [max(min_metric, r) for r in raw] + + s2 = sum(raw) + scale = (rest / s2) if s2 > 0 else 1.0 + metrics = [r * scale for r in raw] + + widths = [first] + metrics + widths[-1] += (table_w - sum(widths)) + return widths + + def draw_mean_std_table(self, mean_std: Dict[str, Any], *, no_wrap: bool = True): + cols = mean_std.get("columns", []) + rows_out: List[List[Any]] = [] + + for row in mean_std.get("rows", []) or []: + out_row: List[Any] = [] + for cell in row.get("cells", []): + val = cell.get("value") + if isinstance(val, tuple) and len(val) == 2: + mv, sv = val + out_row.append(f"{self._cell_str(mv)} ± {self._cell_str(sv)}") + else: + out_row.append(val) + rows_out.append(out_row) + + table_w = self.w - self.l_margin - self.r_margin + col_widths = self._col_widths_model_perf(cols, table_w) + + ncol = len(cols) + font_size = 6 if ncol >= 9 else 7 + + self.draw_table(cols, rows_out, col_widths=col_widths, font_size=font_size, no_wrap=no_wrap) + + def _auto_col_widths(self, columns: Sequence[str], rows: Sequence[Sequence[str]], table_w: float) -> List[float]: + n = len(columns) + if n == 1: + return [table_w] + + weights: List[float] = [] + for j, c in enumerate(columns): + w = max(3.0, float(len(str(c)))) + for r in rows[:15]: + if j < len(r): + w = max(w, min(44.0, float(len(r[j])))) + if j == 0: + w *= 1.6 + weights.append(w) + + sw = sum(weights) if sum(weights) > 0 else float(n) + raw = [table_w * (w / sw) for w in weights] + + min_w = 14.0 if n <= 4 else 10.0 + raw = [max(min_w, w) for w in raw] + + s2 = sum(raw) + scale = (table_w / s2) if s2 > 0 else 1.0 + out = [w * scale for w in raw] + out[-1] += (table_w - sum(out)) + return out + + def draw_table( + self, + columns: Sequence[str], + rows: Sequence[Sequence[Any]], + *, + col_widths: Optional[Sequence[float]] = None, + max_rows: Optional[int] = None, + font_size: Optional[int] = None, + no_wrap: bool = False, + ): + if not columns: + self.muted("No table columns.") + return + + table_w = self.w - self.l_margin - self.r_margin + ncol = len(columns) + + formatted_rows: List[List[str]] = [[self._cell_str(v) for v in r] for r in rows] + if max_rows is not None: + formatted_rows = formatted_rows[:max_rows] + + if font_size is None: + font_size = 8 if ncol <= 5 else (7 if ncol <= 8 else (6 if ncol <= 11 else 5)) + self.set_font("Times", "", font_size) + + if col_widths is None: + col_widths = self._auto_col_widths(columns, formatted_rows, table_w) + col_widths = list(col_widths) + + header_h = 5.0 + line_h = self._tbl_line_h + + def draw_header(): + self.set_font("Times", "B", font_size) + y0 = self.get_y() + x0 = self.l_margin + for j, col in enumerate(columns): + wj = col_widths[j] + self.rect(x0, y0, wj, header_h) + self.set_xy(x0 + self._tbl_pad_x, y0 + self._tbl_pad_y) + txt = self._truncate_to_width(str(col), wj - 2 * self._tbl_pad_x) if no_wrap else str(col) + self.cell(wj - 2 * self._tbl_pad_x, header_h - 2 * self._tbl_pad_y, txt, border=0, ln=0, align="C") + x0 += wj + self.set_xy(self.l_margin, y0 + header_h) + self.set_font("Times", "", font_size) + + if self.get_y() + header_h + 2 > self.page_break_trigger: + self.add_page() + + draw_header() + + if no_wrap: + # Fixed row height (single line) + row_h = max(4.4, line_h + 2 * self._tbl_pad_y) + + for cells in formatted_rows: + if self.get_y() + row_h > self.page_break_trigger: + self.add_page() + draw_header() + + y0 = self.get_y() + x0 = self.l_margin + for j, txt in enumerate(cells): + wj = col_widths[j] + self.rect(x0, y0, wj, row_h) + self.set_xy(x0 + self._tbl_pad_x, y0 + self._tbl_pad_y) + t = self._truncate_to_width(txt, wj - 2 * self._tbl_pad_x) + self.cell(wj - 2 * self._tbl_pad_x, line_h, t, border=0, ln=0, align="L") + x0 += wj + self.set_y(y0 + row_h) + + self.ln(self._gap_after_table) + return + + # Wrapping version (kept for non-performance tables) + def split_lines(txt: str, width_mm: float) -> List[str]: + s = "" if txt is None else str(txt) + usable_w = max(1e-6, float(width_mm)) + try: + lines = self.multi_cell(usable_w, line_h, s, border=0, align="L", split_only=True) + return [ln if ln is not None else "" for ln in lines] or [""] + except TypeError: + parts = s.splitlines() or [s] + out: List[str] = [] + for part in parts: + sw = self.get_string_width(part) if part else 0.0 + n = max(1, int(math.ceil(sw / usable_w))) + out.extend([""] * n) + return out or [""] + + def row_height(cells: Sequence[str]) -> float: + counts: List[int] = [] + for j, txt in enumerate(cells): + usable_w = col_widths[j] - 2 * self._tbl_pad_x + counts.append(len(split_lines(txt, usable_w))) + return max(counts) * line_h + 2 * self._tbl_pad_y + + for cells in formatted_rows: + rh = row_height(cells) + if self.get_y() + rh > self.page_break_trigger: + self.add_page() + draw_header() + + y0 = self.get_y() + x0 = self.l_margin + + for j, txt in enumerate(cells): + wj = col_widths[j] + self.rect(x0, y0, wj, rh) + self.set_xy(x0 + self._tbl_pad_x, y0 + self._tbl_pad_y) + self.multi_cell(wj - 2 * self._tbl_pad_x, line_h, txt, border=0, align="L") + x0 += wj + self.set_xy(x0, y0) + + self.set_y(y0 + rh) + + self.ln(self._gap_after_table) + + # ----------------------------- + # Figures (aspect ratio control) + # ----------------------------- + def _image_panel( + self, + title: str, + path: Optional[str], + *, + x: float, + y: float, + w: float, + h: float, + title_h: float, + keep_aspect: bool = False, + ): + self.rect(x, y, w, h) + self.rect(x, y, w, title_h) + + self.set_font("Times", "B", 8) + self.set_xy(x + self._panel_title_text_pad_x, y + self._panel_title_text_pad_y) + self.cell( + w - 2 * self._panel_title_text_pad_x, + title_h - 2 * self._panel_title_text_pad_y, + title, + border=0, + ln=0, + align="L", + ) + + inner_x = x + self._panel_pad + inner_y = y + title_h + self._panel_content_pad_top + inner_w = w - 2 * self._panel_pad + inner_h = h - title_h - (self._panel_content_pad_top + self._panel_pad) + + if inner_w < 5 or inner_h < 5: + self.set_font("Times", "", 8) + self.set_xy(x + 1, y + title_h + 1) + self.multi_cell(w - 2, 3.5, "Panel too small.", border=0) + return + + if path and Path(path).exists(): + try: + # Prefer keeping aspect ratio (fpdf2 supports keep_aspect_ratio in image()). + if keep_aspect: + try: + self.image(path, x=inner_x, y=inner_y, w=inner_w, h=inner_h, keep_aspect_ratio=True) # type: ignore + except TypeError: + # fallback: let FPDF decide; still uses both w/h + self.image(path, x=inner_x, y=inner_y, w=inner_w, h=inner_h) + else: + self.image(path, x=inner_x, y=inner_y, w=inner_w, h=inner_h) + except Exception: + self.set_font("Times", "", 8) + self.set_xy(inner_x, inner_y) + self.multi_cell(inner_w, 3.5, "Unable to render figure.", border=0) + else: + self.set_font("Times", "", 8) + self.set_xy(inner_x, inner_y) + self.multi_cell(inner_w, 3.5, "Figure not found.", border=0) + + def figure_grid_2x2( + self, + titles: Sequence[str], + paths: Sequence[Optional[str]], + *, + cell_h: float = 66.0, + gap: float = 4.0, + title_h: float = 6.0, + keep_aspect: bool = False, + ): + page_w = self.w - self.l_margin - self.r_margin + cell_w = (page_w - gap) / 2.0 + + x0 = self.l_margin + y0 = self.get_y() + + needed_h = cell_h * 2 + gap + 2 + if y0 + needed_h > self.page_break_trigger: + self.add_page() + y0 = self.get_y() + + self._image_panel(titles[0], paths[0] if len(paths) > 0 else None, x=x0, y=y0, w=cell_w, h=cell_h, title_h=title_h, keep_aspect=keep_aspect) + self._image_panel(titles[1], paths[1] if len(paths) > 1 else None, x=x0 + cell_w + gap, y=y0, w=cell_w, h=cell_h, title_h=title_h, keep_aspect=keep_aspect) + + y1 = y0 + cell_h + gap + self._image_panel(titles[2], paths[2] if len(paths) > 2 else None, x=x0, y=y1, w=cell_w, h=cell_h, title_h=title_h, keep_aspect=keep_aspect) + self._image_panel(titles[3], paths[3] if len(paths) > 3 else None, x=x0 + cell_w + gap, y=y1, w=cell_w, h=cell_h, title_h=title_h, keep_aspect=keep_aspect) + + self.set_y(y1 + cell_h + 2) + + def figure_row_2( + self, + titles: Sequence[str], + paths: Sequence[Optional[str]], + *, + h: float = 80.0, + gap: float = 4.0, + title_h: float = 6.0, + keep_aspect: bool = False, + ): + page_w = self.w - self.l_margin - self.r_margin + cell_w = (page_w - gap) / 2.0 + y0 = self.get_y() + if y0 + h + 2 > self.page_break_trigger: + self.add_page() + y0 = self.get_y() + + x0 = self.l_margin + self._image_panel(titles[0], paths[0] if len(paths) > 0 else None, x=x0, y=y0, w=cell_w, h=h, title_h=title_h, keep_aspect=keep_aspect) + self._image_panel(titles[1], paths[1] if len(paths) > 1 else None, x=x0 + cell_w + gap, y=y0, w=cell_w, h=h, title_h=title_h, keep_aspect=keep_aspect) + self.set_y(y0 + h + 2) + + def figure_single(self, title: str, path: Optional[str], *, h: float = 90.0, title_h: float = 6.0, keep_aspect: bool = False): + page_w = self.w - self.l_margin - self.r_margin + y0 = self.get_y() + if y0 + h + 2 > self.page_break_trigger: + self.add_page() + y0 = self.get_y() + self._image_panel(title, path, x=self.l_margin, y=y0, w=page_w, h=h, title_h=title_h, keep_aspect=keep_aspect) + self.set_y(y0 + h + 2) diff --git a/streamline/dataprep/__init__.py b/streamline/old_versions/p11_reporting_old/__init__.py similarity index 100% rename from streamline/dataprep/__init__.py rename to streamline/old_versions/p11_reporting_old/__init__.py diff --git a/streamline/old_versions/p11_reporting_old/dashboard_app.py b/streamline/old_versions/p11_reporting_old/dashboard_app.py new file mode 100644 index 00000000..d5726b8f --- /dev/null +++ b/streamline/old_versions/p11_reporting_old/dashboard_app.py @@ -0,0 +1,657 @@ +# streamline/reporting/dashboard_app.py + +from __future__ import annotations + +import json +import os +import numpy as np +from pathlib import Path +from typing import Dict, List, Optional + +import pandas as pd +import plotly.express as px +import plotly.graph_objects as go +import streamlit as st + + +# ------------------------------------------------------------------- +# Helpers +# ------------------------------------------------------------------- +def safe_read_csv(path: Path, **kwargs) -> Optional[pd.DataFrame]: + try: + if path.is_file(): + return pd.read_csv(path, **kwargs) + except Exception as e: + st.warning(f"Failed to read CSV: {path} ({e})") + return None + + +def safe_read_json(path: Path) -> Optional[dict]: + try: + if path.is_file(): + with path.open("r") as f: + return json.load(f) + except Exception as e: + st.warning(f"Failed to read JSON: {path} ({e})") + return None + + +def discover_datasets(exp_root: Path) -> List[Path]: + """Return dataset folders (have CVDatasets).""" + if not exp_root.is_dir(): + return [] + ds = [] + for p in sorted(exp_root.iterdir()): + if p.is_dir() and (p / "CVDatasets").is_dir(): + ds.append(p) + return ds + + +# ------------------------------------------------------------------- +# Phase 1–2: exploratory / preprocessing +# ------------------------------------------------------------------- +def render_phase12_exploratory(ds_dir: Path): + st.subheader("Phase 1: Exploratory Analysis") + + exp_dir = ds_dir / "exploratory" + if not exp_dir.is_dir(): + st.info("No exploratory outputs found for this dataset.") + return + + # 1) Class counts + class_counts = safe_read_csv(exp_dir / "ClassCounts.csv") + if class_counts is not None and {"Class", "Count"}.issubset(class_counts.columns): + fig = px.bar( + class_counts, + x="Class", + y="Count", + title="Class Distribution", + ) + st.plotly_chart(fig, use_container_width=True) + + # 2) Missingness + missing = safe_read_csv(exp_dir / "DataMissingness.csv") + if missing is not None and {"Variable", "Count"}.issubset(missing.columns): + fig = px.bar( + missing.sort_values("Count", ascending=False), + x="Variable", + y="Count", + title="Missingness Count in Dataset", + ) + fig.update_layout(xaxis_tickangle=-45) + st.plotly_chart(fig, use_container_width=True) + else: + st.info("Could not infer feature / missingness columns from DataMissingness.csv.") + + # 3) Correlation heatmap + corr_csv = exp_dir / "FeatureCorrelations.csv" + df_corr = safe_read_csv(corr_csv) + if df_corr is not None and not df_corr.empty: + st.subheader("Feature correlation heatmap") + try: + # Assume wide correlation matrix with feature names in first column and header + mat = df_corr.set_index(df_corr.columns[0]) + fig = px.imshow( + mat, + color_continuous_scale="RdBu", + zmin=-1, + zmax=1, + title="Feature correlation (Phase 1)", + + ) + fig.layout.update( + width=800, height=800, + xaxis_showgrid=False, + yaxis_showgrid=False, + yaxis_autorange='reversed', + dragmode='pan', + ) + fig.update_xaxes(type='category') + fig.update_yaxes(type='category') + + st.plotly_chart(fig, use_container_width=False, config = {'scrollZoom': True}) + except Exception as e: + st.warning(f"Could not build correlation heatmap from {corr_csv.name}: {e}") + + # 4) Univariate significance + uni_dir = exp_dir / "univariate_analyses" + uni = safe_read_csv(uni_dir / "Univariate_Significance.csv") + if uni is not None and {"Feature", "p_value"}.issubset(uni.columns): + fig = px.bar( + uni.sort_values("p_value"), + x="Feature", + y="p_value", + title="Univariate Significance (sorted by p-value)", + ) + fig.update_layout(xaxis_tickangle=-45) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 3: feature learning +# ------------------------------------------------------------------- +def render_phase3_feature_learning(ds_dir: Path): + st.subheader("Phase 3: Feature Learning") + + fl_dir = ds_dir / "feature_learning" + if not fl_dir.is_dir(): + st.info("No feature learning outputs found.") + return + + # Count engineered features per CV from feature_manifest_cv*.json + rows = [] + for p in sorted(fl_dir.glob("feature_manifest_cv*.json")): + manifest = safe_read_json(p) + if not manifest: + continue + cv_id = p.stem.replace("feature_manifest_", "") + # Try some generic keys, fallback to len of feature list if present + n_feat = manifest.get("n_features") or manifest.get("num_features") + if n_feat is None: + feats = manifest.get("features") or manifest.get("feature_list") + if isinstance(feats, list): + n_feat = len(feats) + if n_feat is not None: + rows.append({"cv": cv_id, "n_features": n_feat}) + + if rows: + df = pd.DataFrame(rows) + fig = px.bar( + df, + x="cv", + y="n_features", + title="Number of Learned Features per CV Fold", + ) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 4–5: feature importance & selection +# ------------------------------------------------------------------- +def render_phase45_feature_importance(ds_dir: Path): + st.subheader("Phase 4–5: Feature Importance & Selection") + + fi_phase_dir = ds_dir / "feature_importance" + sel_dir = ds_dir / "feature_selection" + + # P4: MultiSURF & Mutual information (top mean scores) + ms_dir = fi_phase_dir / "multisurf" + mi_dir = fi_phase_dir / "mutualinformation" + + def _aggregate_fi_scores(root: Path, label: str) -> Optional[pd.DataFrame]: + if not root.is_dir(): + return None + frames = [] + for p in sorted(root.glob("*_scores_cv_*.csv")): + df = safe_read_csv(p) + if df is None: + continue + cv = p.stem.split("_cv_")[-1] + if "Feature" in df.columns and "Score" in df.columns: + df = df[["Feature", "Score"]].copy() + df["cv"] = cv + frames.append(df) + if not frames: + return None + all_scores = pd.concat(frames, ignore_index=True) + agg = all_scores.groupby("Feature")["Score"].mean().reset_index() + agg["method"] = label + return agg + + ms_agg = _aggregate_fi_scores(ms_dir, "MultiSURF") + mi_agg = _aggregate_fi_scores(mi_dir, "Mutual Information") + + agg_all = None + if ms_agg is not None and mi_agg is not None: + agg_all = pd.concat([ms_agg, mi_agg], ignore_index=True) + elif ms_agg is not None: + agg_all = ms_agg + elif mi_agg is not None: + agg_all = mi_agg + + if agg_all is not None: + top = ( + agg_all.sort_values("Score", ascending=False) + .groupby("method") + .head(20) + ) + fig = px.bar( + top, + x="Feature", + y="Score", + color="method", + barmode="group", + title="Global Feature Importance (Phase 4)", + ) + fig.update_layout(xaxis_tickangle=-45) + st.plotly_chart(fig, use_container_width=True) + + # P5: Informative feature summary + if sel_dir.is_dir(): + info = safe_read_csv(sel_dir / "InformativeFeatureSummary.csv") + if info is not None and "Feature" in info.columns: + # Use any importance/score-like columns if present + score_cols = [ + c + for c in info.columns + if c.lower().startswith("score") + or "importance" in c.lower() + or "rank" in c.lower() + ] + if score_cols: + col = score_cols[0] + top_sel = info.sort_values(col, ascending=False).head(20) + fig = px.bar( + top_sel, + x="Feature", + y=col, + title=f"Selected Features (Phase 5) – {col}", + ) + fig.update_layout(xaxis_tickangle=-45) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 6: modeling +# ------------------------------------------------------------------- +def render_phase6_modeling(ds_dir: Path): + st.subheader("Phase 6: Base Models") + + me_dir = ds_dir / "model_evaluation" + if not me_dir.is_dir(): + st.info("No model_evaluation folder found.") + return + + summary_mean = safe_read_csv(me_dir / "Summary_performance_mean.csv", index_col=0) + if summary_mean is not None: + summary_mean = summary_mean.reset_index().rename(columns={"index": "Model"}) + # Melt for metric comparison + df_long = summary_mean.melt( + id_vars="Model", + var_name="Metric", + value_name="Score", + ) + fig = px.bar( + df_long, + x="Model", + y="Score", + color="Metric", + barmode="group", + title="Mean CV Performance per Model", + ) + st.plotly_chart(fig, use_container_width=True) + + # Per-CV performance (metrics_by_cv JSON) + metrics_dir = me_dir / "metrics_by_cv" + if metrics_dir.is_dir(): + rows = [] + for p in sorted(metrics_dir.glob("*.json")): + m = safe_read_json(p) + if not m: + continue + base = p.stem # e.g., LR_CV_0 + try: + model_id, cv_id = base.split("_CV_") + except ValueError: + continue + # assume flat dict of metrics + for metric, val in m.items(): + if isinstance(val, (int, float)): + rows.append( + { + "Model": model_id, + "CV": cv_id, + "Metric": metric, + "Score": float(val), + } + ) + if rows: + df = pd.DataFrame(rows) + metric_sel = st.selectbox( + "Metric (Phase 6 CV performance)", + sorted(df["Metric"].unique()), + key=f"p6_metric_{ds_dir.name}", + ) + sub = df[df["Metric"] == metric_sel] + fig = px.line( + sub, + x="CV", + y="Score", + color="Model", + markers=True, + title=f"Per-CV {metric_sel} by Model", + ) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 7: ensembles +# ------------------------------------------------------------------- +def render_phase7_ensembles(ds_dir: Path): + st.subheader("Phase 7: Ensembles") + + ens_dir = ds_dir / "ensemble_evaluation" + if not ens_dir.is_dir(): + st.info("No ensemble_evaluation folder found.") + return + + summary_mean = safe_read_csv(ens_dir / "Ensembles_performance_mean.csv", index_col=0) + if summary_mean is not None: + summary_mean = summary_mean.reset_index().rename(columns={"index": "Ensemble"}) + df_long = summary_mean.melt( + id_vars="Ensemble", + var_name="Metric", + value_name="Score", + ) + fig = px.bar( + df_long, + x="Ensemble", + y="Score", + color="Metric", + barmode="group", + title="Mean CV Performance per Ensemble", + ) + st.plotly_chart(fig, use_container_width=True) + + # Per-CV ensemble metrics + cv_dir = ens_dir / "metrics_by_cv" + if cv_dir.is_dir(): + rows = [] + for p in sorted(cv_dir.glob("*.json")): + m = safe_read_json(p) + if not m: + continue + base = p.stem # e.g., HEV_CV_0 + try: + ens_id, cv_id = base.split("_CV_") + except ValueError: + continue + for metric, val in m.items(): + if isinstance(val, (int, float)): + rows.append( + { + "Ensemble": ens_id, + "CV": cv_id, + "Metric": metric, + "Score": float(val), + } + ) + if rows: + df = pd.DataFrame(rows) + metric_sel = st.selectbox( + "Metric (Phase 7 CV performance)", + sorted(df["Metric"].unique()), + key=f"p7_metric_{ds_dir.name}", + ) + sub = df[df["Metric"] == metric_sel] + fig = px.line( + sub, + x="CV", + y="Score", + color="Ensemble", + markers=True, + title=f"Per-CV {metric_sel} by Ensemble", + ) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 8: summary statistics +# ------------------------------------------------------------------- +def render_phase8_stats(ds_dir: Path): + st.subheader("Phase 8: Statistics & Model Comparisons") + + me_dir = ds_dir / "model_evaluation" + if not me_dir.is_dir(): + st.info("No model_evaluation folder for stats.") + return + + # Metric comparison boxplots built from Summary_performance_mean + summary_mean = safe_read_csv(me_dir / "Summary_performance_mean.csv", index_col=0) + if summary_mean is not None: + summary_mean = summary_mean.reset_index().rename(columns={"index": "Model"}) + metric_sel = st.selectbox( + "Metric for model comparison (Phase 8)", + [c for c in summary_mean.columns if c != "Model"], + key=f"p8_metric_{ds_dir.name}", + ) + sub = summary_mean[["Model", metric_sel]] + fig = px.box( + sub, + x="Model", + y=metric_sel, + points="all", + title=f"Model Comparison for {metric_sel}", + ) + st.plotly_chart(fig, use_container_width=True) + + # Statistical tests (Mann-Whitney / Wilcoxon) present under statistical_comparisons + stats_dir = me_dir / "statistical_comparisons" + if stats_dir.is_dir(): + mw_files = sorted(stats_dir.glob("MannWhitneyU_*.csv")) + if mw_files: + mw_file = st.selectbox( + "Mann-WhitneyU result file", + mw_files, + format_func=lambda p: p.name, + key=f"p8_mw_{ds_dir.name}", + ) + df = safe_read_csv(mw_file) + if df is not None and {"Model1", "Model2", "P-Value"}.issubset(df.columns): + sig = df[df["P-Value"] < 0.05] + if not sig.empty: + fig = px.scatter( + sig, + x="Model1", + y="Model2", + size="-log10(P-Value)" if "-log10(P-Value)" in sig.columns else "P-Value", + color="P-Value", + title="Significant Pairwise Differences (Mann-WhitneyU)", + ) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 9: dataset comparisons (experiment-level) +# ------------------------------------------------------------------- +def render_phase9_dataset_comparisons(exp_root: Path): + st.subheader("Phase 9: Dataset Comparisons") + + dc_dir = exp_root / "DatasetComparisons" + if not dc_dir.is_dir(): + st.info("No DatasetComparisons folder at experiment root.") + return + + # 1) BestCompare_KruskalWallis summary + best_kw = safe_read_csv(dc_dir / "BestCompare_KruskalWallis.csv") + if best_kw is not None: + metric = st.selectbox( + "Metric (BestCompare Kruskal-Wallis)", + [m for m in best_kw.index] if isinstance(best_kw.index, pd.Index) else best_kw["Metric"].unique(), + key="p9_metric_kw", + ) + row = best_kw.loc[metric] + cols = [c for c in best_kw.columns if c.startswith("Mean_D")] + data = [] + for i, c in enumerate(cols, start=1): + data.append( + { + "DatasetIdx": f"D{i}", + "MeanScore": float(row[c]) if pd.notnull(row[c]) else None, + "BestAlg": row.get(f"Best_Alg_D{i}", None), + } + ) + df = pd.DataFrame(data).dropna(subset=["MeanScore"]) + if not df.empty: + fig = px.bar( + df, + x="DatasetIdx", + y="MeanScore", + color="BestAlg", + title=f"Best Algorithm per Dataset – {metric}", + ) + st.plotly_chart(fig, use_container_width=True) + + # 2) Global Mann-Whitney & Wilcoxon across datasets + for label, fname in [ + ("Mann-Whitney Across Datasets", "MannWhitney_all.csv"), + ("Wilcoxon Rank Across Datasets", "WilcoxonRank_all.csv"), + ]: + df = safe_read_csv(dc_dir / fname) + if df is not None and {"Metric", "Data1", "Data2", "P-Value"}.issubset(df.columns): + st.markdown(f"#### {label}") + sig = df[df["P-Value"] < 0.05].copy() + if sig.empty: + st.write("No significant differences at p < 0.05.") + continue + sig["pair"] = sig["Data1"].astype(str) + " vs " + sig["Data2"].astype(str) + fig = px.scatter( + sig, + x="Metric", + y="pair", + size=-np.log10(sig["P-Value"]) if "np" in globals() else sig["P-Value"], + color="P-Value", + title=f"Significant Dataset Pairs ({label})", + ) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Reporting phase (Phase 11) artifacts +# ------------------------------------------------------------------- +def render_phase11_reporting(exp_root: Path): + st.subheader("Phase 11: Reporting") + + rep_dir = exp_root / "reporting" + if not rep_dir.is_dir(): + st.info("No reporting folder found.") + return + + html_path = rep_dir / "report.html" + pdf_path = rep_dir / "report.pdf" + if html_path.is_file(): + st.markdown(f"[Download HTML report]({html_path.as_posix()})") + if pdf_path.is_file(): + st.markdown(f"[Download PDF report]({pdf_path.as_posix()})") + + + report_data = safe_read_json(rep_dir / "report_data.json") + if report_data: + st.json(report_data) + +# ------------------------------------------------------------------- +# Phase runtimes per dataset +# ------------------------------------------------------------------- +def render_runtimes(ds_dir: Path): + st.subheader("Phase Runtimes (per dataset)") + + rt_csv = safe_read_csv(ds_dir / "runtimes.csv") + if rt_csv is not None and {"Phase", "RuntimeSeconds"}.issubset(rt_csv.columns): + fig = px.bar( + rt_csv, + x="Phase", + y="RuntimeSeconds", + title="Runtime per Phase", + ) + fig.update_layout(xaxis_tickangle=-45) + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Main app +# ------------------------------------------------------------------- +def main(): + st.set_page_config(page_title="STREAMLINE Experiment Dashboard", layout="wide") + + st.title("STREAMLINE Experiment Dashboard") + + default_root = "out/DemoRun" + exp_root_str = st.sidebar.text_input( + "Experiment root path", + value=default_root, + help="Top-level folder containing dataset subfolders, DatasetComparisons, reporting, etc.", + ) + exp_root = Path(exp_root_str).expanduser().resolve() + + st.sidebar.write(f"Using experiment root: `{exp_root}`") + + if not exp_root.is_dir(): + st.error("Experiment root does not exist.") + return + + datasets = discover_datasets(exp_root) + if not datasets: + st.error("No dataset subfolders with CVDatasets found under this experiment root.") + return + + ds_names = [d.name for d in datasets] + selected_ds_names = st.sidebar.multiselect( + "Datasets to display", + ds_names, + default=ds_names, + ) + selected_ds = [d for d in datasets if d.name in selected_ds_names] + + if not selected_ds: + st.warning("No datasets selected.") + return + + top_tabs = st.tabs( + [ + "Per-dataset (P1–P8)", + "Dataset Comparisons (P9)", + "Reporting (P11)", + ] + ) + + # ------------------------------ + # Tab 1: per-dataset dashboard + # ------------------------------ + with top_tabs[0]: + st.header("Per-dataset Dashboard") + + # One accordion per dataset, each with phase tabs + for ds in selected_ds: + with st.expander(f"Dataset: {ds.name}", expanded=(len(selected_ds) == 1)): + phase_tabs = st.tabs( + [ + "Exploratory (P1–P2)", + "Feature Learning (P3)", + "Feature Importance/Selection (P4–P5)", + "Modeling (P6)", + "Ensembles (P7)", + "Summary Stats (P8)", + "Runtimes", + ] + ) + + with phase_tabs[0]: + render_phase12_exploratory(ds) + with phase_tabs[1]: + render_phase3_feature_learning(ds) + with phase_tabs[2]: + render_phase45_feature_importance(ds) + with phase_tabs[3]: + render_phase6_modeling(ds) + with phase_tabs[4]: + render_phase7_ensembles(ds) + with phase_tabs[5]: + render_phase8_stats(ds) + with phase_tabs[6]: + render_runtimes(ds) + + # ------------------------------ + # Tab 2: experiment-level dataset comparisons + # ------------------------------ + with top_tabs[1]: + render_phase9_dataset_comparisons(exp_root) + + # ------------------------------ + # Tab 3: reporting artifacts + # ------------------------------ + with top_tabs[2]: + render_phase11_reporting(exp_root) + + +if __name__ == "__main__": + main() diff --git a/streamline/old_versions/p11_reporting_old/dashboard_app_old.py b/streamline/old_versions/p11_reporting_old/dashboard_app_old.py new file mode 100644 index 00000000..c5693b1a --- /dev/null +++ b/streamline/old_versions/p11_reporting_old/dashboard_app_old.py @@ -0,0 +1,762 @@ +# streamline/p11_reporting/dashboard_app.py + +from __future__ import annotations + +import argparse +import json +from pathlib import Path +from typing import Optional, List, Dict, Any + +import numpy as np +import pandas as pd +import plotly.express as px +import plotly.graph_objects as go +import streamlit as st + + +# ------------------------------------------------------------------- +# Helpers +# ------------------------------------------------------------------- + +def _safe_read_csv(path: Path) -> Optional[pd.DataFrame]: + try: + if path.is_file(): + return pd.read_csv(path) + except Exception as e: + st.warning(f"Failed to read CSV: {path} ({e})") + return None + + +def _safe_read_json(path: Path) -> Optional[Dict[str, Any]]: + try: + if path.is_file(): + with path.open("r") as f: + return json.load(f) + except Exception as e: + st.warning(f"Failed to read JSON: {path} ({e})") + return None + + +def _list_datasets(exp_root: Path) -> List[Path]: + return [ + p for p in sorted(exp_root.iterdir()) + if p.is_dir() + and (p / "CVDatasets").is_dir() + and p.name not in {"DatasetComparisons", "jobs", "jobsCompleted", "logs", "runtime", "reporting"} + ] + + +# ------------------------------------------------------------------- +# Phase 1 - Exploratory / Data processing views +# ------------------------------------------------------------------- + +def view_phase1_exploratory(dataset_dir: Path) -> None: + st.header("Phase 1 - Exploratory / Data Processing") + + exp_dir = dataset_dir / "exploratory" + if not exp_dir.is_dir(): + st.info("No exploratory directory found for this dataset.") + return + + # 1) Class distribution + class_counts_csv = exp_dir / "ClassCounts.csv" + df_class = _safe_read_csv(class_counts_csv) + if df_class is not None and not df_class.empty: + st.subheader("Class distribution") + # Try some sensible defaults, fall back to generic + if {"Class", "Count"}.issubset(df_class.columns): + fig = px.bar( + df_class, + x="Class", + y="Count", + title="Class counts", + ) + else: + melted = df_class.melt(var_name="Category", value_name="Value") + fig = px.bar(melted, x="Category", y="Value", title="ClassCounts (raw)") + st.plotly_chart(fig, use_container_width=True) + + # 2) Feature missingness + miss_csv = exp_dir / "DataMissingness.csv" + df_miss = _safe_read_csv(miss_csv) + if df_miss is not None and not df_miss.empty: + st.subheader("Feature missingness") + # try to infer feature / percent columns + col_feature = None + col_pct = None + for c in df_miss.columns: + lc = c.lower() + if col_feature is None and ("feature" in lc or "variable" in lc or "name" in lc): + col_feature = c + if col_pct is None and ("percent" in lc or "pct" in lc): + col_pct = c + if col_feature and col_pct: + df_miss_sorted = df_miss.sort_values(col_pct, ascending=False) + fig = px.bar( + df_miss_sorted, + x=col_feature, + y=col_pct, + title="Missingness by feature", + ) + fig.update_layout(xaxis_tickangle=-45) + st.plotly_chart(fig, use_container_width=True) + else: + st.info("Could not infer feature / missingness columns from DataMissingness.csv.") + + # 3) Correlation heatmap + corr_csv = exp_dir / "FeatureCorrelations.csv" + df_corr = _safe_read_csv(corr_csv) + if df_corr is not None and not df_corr.empty: + st.subheader("Feature correlation heatmap") + try: + # Assume wide correlation matrix or edge-list + # If "Feature1", "Feature2", "Correlation", pivot + if {"Feature1", "Feature2", "Correlation"}.issubset(df_corr.columns): + mat = df_corr.pivot(index="Feature1", columns="Feature2", values="Correlation") + else: + # try to interpret as square matrix + mat = df_corr.set_index(df_corr.columns[0]) + fig = px.imshow( + mat, + color_continuous_scale="RdBu", + zmin=-1, + zmax=1, + title="Feature correlation (Phase 1)", + ) + st.plotly_chart(fig, use_container_width=True) + except Exception as e: + st.warning(f"Could not build correlation heatmap from {corr_csv.name}: {e}") + + +# ------------------------------------------------------------------- +# Phase 2 - Impute & scale (preprocessing runtime / components) +# ------------------------------------------------------------------- + +def view_phase2_impute_scale(dataset_dir: Path) -> None: + st.header("Phase 2 - Impute & Scale") + + # Use runtimes.csv and runtime_preprocessingX.txt to show per-fold preprocessing runtime + runtimes_csv = dataset_dir / "runtimes.csv" + df_rt = _safe_read_csv(runtimes_csv) + if df_rt is not None and not df_rt.empty: + st.subheader("Pipeline runtimes (all phases)") + fig = px.bar( + df_rt, + x=df_rt.columns[0], + y=df_rt.columns[1], + title="Per-phase runtimes", + ) + st.plotly_chart(fig, use_container_width=True) + + # More detailed preprocessing runtimes (one text file per CV) + runtime_dir = dataset_dir / "runtime" + if runtime_dir.is_dir(): + files = sorted(runtime_dir.glob("runtime_preprocessing*.txt")) + records = [] + for f in files: + try: + fold = int("".join(filter(str.isdigit, f.stem))) + except Exception: + fold = None + try: + val = float(f.read_text().strip()) + except Exception: + val = None + records.append({"Fold": fold, "RuntimeSeconds": val}) + df_pre = pd.DataFrame(records).dropna() + if not df_pre.empty: + st.subheader("Preprocessing runtime per fold") + fig2 = px.bar(df_pre, x="Fold", y="RuntimeSeconds", + title="Preprocessing runtime by CV fold") + st.plotly_chart(fig2, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 3 - Feature learning +# ------------------------------------------------------------------- + +def view_phase3_feature_learning(dataset_dir: Path) -> None: + st.header("Phase 3 - Feature Learning") + + fl_dir = dataset_dir / "feature_learning" + if not fl_dir.is_dir(): + st.info("No feature_learning directory found for this dataset.") + return + + # 1) Number of learned features per fold + records = [] + for j in range(0, 100): # arbitrary upper bound; break when missing + manifest = fl_dir / f"feature_manifest_cv{j}.json" + if not manifest.is_file(): + continue + data = _safe_read_json(manifest) + if not data: + continue + # Try to interpret: assume 'features' key or list + if isinstance(data, dict) and "features" in data: + n_feat = len(data["features"]) + elif isinstance(data, list): + n_feat = len(data) + else: + # fallback: count keys + n_feat = len(data) + records.append({"Fold": j, "NumLearnedFeatures": n_feat}) + df_feat = pd.DataFrame(records) + if not df_feat.empty: + st.subheader("Number of learned features per CV fold") + fig = px.bar(df_feat, x="Fold", y="NumLearnedFeatures", + title="Feature learning - features per fold") + st.plotly_chart(fig, use_container_width=True) + + # 2) Simple feature frequency (across text files features_cvX.txt) + freq: Dict[str, int] = {} + for j in range(0, 100): + feat_txt = fl_dir / f"features_cv{j}.txt" + if not feat_txt.is_file(): + continue + try: + for line in feat_txt.read_text().splitlines(): + name = line.strip() + if not name: + continue + freq[name] = freq.get(name, 0) + 1 + except Exception: + continue + if freq: + df_freq = ( + pd.DataFrame( + [{"Feature": k, "Count": v} for k, v in freq.items()] + ) + .sort_values("Count", ascending=False) + .head(30) + ) + st.subheader("Most frequently learned features (top 30)") + fig2 = px.bar(df_freq, x="Feature", y="Count", + title="Feature learning - frequency", + labels={"Count": "Number of folds"}) + fig2.update_layout(xaxis_tickangle=-45) + st.plotly_chart(fig2, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 4 & 5 - Feature importance / selection +# ------------------------------------------------------------------- + +def view_phase4_5_feature_importance_selection(dataset_dir: Path) -> None: + st.header("Phases 4 & 5 - Feature Importance and Selection") + + fi_root = dataset_dir / "feature_importance" + if fi_root.is_dir(): + st.subheader("Feature importance across CVs") + + # Two methods: multisurf and mutualinformation + for method in ("multisurf", "mutualinformation"): + method_dir = fi_root / method + if not method_dir.is_dir(): + continue + + # Collect scores across folds + scores = [] + for csv_path in sorted(method_dir.glob(f"{method}_scores_cv_*.csv")): + df = _safe_read_csv(csv_path) + if df is None or df.empty: + continue + # Guess columns: first column feature name, second score + if df.shape[1] >= 2: + feat_col = df.columns[0] + score_col = df.columns[1] + fold = int("".join(filter(str.isdigit, csv_path.stem))) + tmp = df[[feat_col, score_col]].copy() + tmp.columns = ["Feature", "Score"] + tmp["Fold"] = fold + scores.append(tmp) + if not scores: + continue + + df_scores = pd.concat(scores, ignore_index=True) + # Aggregate mean / std + agg = ( + df_scores.groupby("Feature")["Score"] + .agg(["mean", "std", "count"]) + .reset_index() + .sort_values("mean", ascending=False) + .head(30) + ) + fig = px.bar( + agg, + x="Feature", + y="mean", + error_y="std", + title=f"Top 30 features by {method} (mean ± std over CV)", + labels={"mean": "Importance (mean score)"}, + ) + fig.update_layout(xaxis_tickangle=-45) + st.plotly_chart(fig, use_container_width=True) + + # Feature selection summary + fs_csv = dataset_dir / "feature_selection" / "InformativeFeatureSummary.csv" + df_fs = _safe_read_csv(fs_csv) + if df_fs is not None and not df_fs.empty: + st.subheader("Selected / informative features") + + # Assume columns like Feature, Selected, Method, etc. Fall back gracefully. + cols = df_fs.columns + if "Feature" in cols and "Selected" in cols: + fig = px.histogram( + df_fs, + x="Feature", + color="Selected", + title="Selected vs non-selected features", + ) + fig.update_layout(xaxis_tickangle=-60) + st.plotly_chart(fig, use_container_width=True) + + # Distribution of number of methods supporting a feature, if that column exists + method_count_col = None + for c in cols: + if "num" in c.lower() and "method" in c.lower(): + method_count_col = c + break + if method_count_col: + fig2 = px.histogram( + df_fs, + x=method_count_col, + nbins=10, + title=f"Support across methods ({method_count_col})", + ) + st.plotly_chart(fig2, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 6 - Base modeling (per-dataset) +# ------------------------------------------------------------------- + +def _plot_summary_metrics(summary_csv: Path, title_prefix: str) -> None: + df = _safe_read_csv(summary_csv) + if df is None or df.empty: + st.info(f"No summary file found at {summary_csv}") + return + # Assume first column is algorithm, others metrics + alg_col = df.columns[0] + metric_cols = [c for c in df.columns[1:] if isinstance(c, str)] + + st.subheader(f"{title_prefix}: metric overview") + + metric = st.selectbox( + "Metric", + metric_cols, + key=f"{title_prefix}_metric_select", + ) + df_metric = df[[alg_col, metric]].copy() + fig = px.bar( + df_metric.sort_values(metric, ascending=False), + x=alg_col, + y=metric, + title=f"{title_prefix}: {metric}", + ) + st.plotly_chart(fig, use_container_width=True) + + +def _plot_curves_from_json(curves_dir: Path, title_prefix: str) -> None: + if not curves_dir.is_dir(): + st.info(f"No curves_by_cv directory found at {curves_dir}") + return + + # Expect files like MODEL_CV_k_prc.json / MODEL_CV_k_roc.json + files = list(curves_dir.glob("*_CV_*_roc.json")) + list(curves_dir.glob("*_CV_*_prc.json")) + if not files: + st.info("No curve JSON files found.") + return + + # Identify available models and curve types + models = sorted({f.name.split("_CV_")[0] for f in files}) + curve_types = ["roc", "prc"] + + model = st.selectbox("Model", models, key=f"{title_prefix}_curve_model") + curve_type = st.radio("Curve type", curve_types, horizontal=True, + key=f"{title_prefix}_curve_type") + + # Aggregate all folds for that model + curve_type + traces = [] + for f in sorted(curves_dir.glob(f"{model}_CV_*_{curve_type}.json")): + data = _safe_read_json(f) + if not data: + continue + x = data.get("fpr") or data.get("recall") or data.get("x") or [] + y = data.get("tpr") or data.get("precision") or data.get("y") or [] + if not x or not y: + continue + fold_name = f.stem.split("_CV_")[1].split("_")[0] + traces.append((fold_name, x, y)) + + if not traces: + st.info("No usable curve data found for this selection.") + return + + fig = go.Figure() + for fold, x, y in traces: + fig.add_trace( + go.Scatter( + x=x, + y=y, + mode="lines", + name=f"CV {fold}", + ) + ) + fig.update_layout( + title=f"{title_prefix}: {model} - {curve_type.upper()} curves", + xaxis_title="False Positive Rate" if curve_type == "roc" else "Recall", + yaxis_title="True Positive Rate" if curve_type == "roc" else "Precision", + ) + st.plotly_chart(fig, use_container_width=True) + + +def view_phase6_modeling(dataset_dir: Path) -> None: + st.header("Phase 6 - Base Modeling") + + me_root = dataset_dir / "model_evaluation" + + # Summary metrics across models + summary_mean = me_root / "Summary_performance_mean.csv" + if summary_mean.is_file(): + _plot_summary_metrics(summary_mean, title_prefix="Base models (mean)") + else: + st.info("Summary_performance_mean.csv not found for base models.") + + # CV curve plots (ROC / PRC) + st.subheader("Cross-validation ROC / PRC curves") + curves_dir = me_root / "curves_by_cv" + _plot_curves_from_json(curves_dir, title_prefix="Base models") + + +# ------------------------------------------------------------------- +# Phase 7 - Ensembles (per-dataset) +# ------------------------------------------------------------------- + +def view_phase7_ensembles(dataset_dir: Path) -> None: + st.header("Phase 7 - Ensembles") + + ens_root = dataset_dir / "ensemble_evaluation" + if not ens_root.is_dir(): + st.info("No ensemble_evaluation directory found for this dataset.") + return + + # Summary ensemble metrics + ens_summary = ens_root / "Ensembles_performance_mean.csv" + if ens_summary.is_file(): + _plot_summary_metrics(ens_summary, title_prefix="Ensembles (mean)") + else: + st.info("Ensembles_performance_mean.csv not found for this dataset.") + + # Ensemble ROC / PRC curves + st.subheader("Ensemble ROC / PRC curves") + curves_dir = ens_root / "curves_by_cv" + _plot_curves_from_json(curves_dir, title_prefix="Ensembles") + + +# ------------------------------------------------------------------- +# Phase 8 - Summary statistics / model comparisons +# ------------------------------------------------------------------- + +def view_phase8_statistics(dataset_dir: Path) -> None: + st.header("Phase 8 - Summary Statistics") + + me_root = dataset_dir / "model_evaluation" + stats_dir = me_root / "statistical_comparisons" + if not stats_dir.is_dir(): + st.info("No statistical_comparisons directory found.") + return + + # 1) Kruskal-Wallis per metric (algorithm comparisons) + kw_csv = stats_dir / "KruskalWallis.csv" + df_kw = _safe_read_csv(kw_csv) + if df_kw is not None and not df_kw.empty: + st.subheader("Kruskal-Wallis test results") + # assume columns Metric, Statistic, P-Value, Sig(*) + metric_col = None + stat_col = None + p_col = None + for c in df_kw.columns: + lc = c.lower() + if metric_col is None and "metric" in lc: + metric_col = c + if stat_col is None and "statistic" in lc: + stat_col = c + if p_col is None and ("p-value" in lc or "p value" in lc or lc == "p"): + p_col = c + if metric_col and p_col: + df_kw["-log10(p)"] = -np.log10(df_kw[p_col].replace(0, np.nan)) + fig = px.bar( + df_kw.sort_values(p_col), + x=metric_col, + y="-log10(p)", + title="Kruskal-Wallis significance by metric (-log10 p)", + ) + st.plotly_chart(fig, use_container_width=True) + st.dataframe(df_kw) + + # 2) Mann-Whitney and Wilcoxon per metric + mw_files = sorted(stats_dir.glob("MannWhitneyU_*.csv")) + sorted( + stats_dir.glob("MannWhitneyU_*.csv") + ) + if mw_files: + st.subheader("Mann-Whitney U results") + f = st.selectbox("Select Mann-WhitneyU result file", [p.name for p in mw_files]) + df_mw = _safe_read_csv(stats_dir / f) + if df_mw is not None and not df_mw.empty: + st.dataframe(df_mw.head(200)) + + w_files = sorted(stats_dir.glob("WilcoxonRank_*.csv")) + if w_files: + st.subheader("Wilcoxon rank-sum results") + f2 = st.selectbox("Select Wilcoxon result file", [p.name for p in w_files]) + df_w = _safe_read_csv(stats_dir / f2) + if df_w is not None and not df_w.empty: + st.dataframe(df_w.head(200)) + + +# ------------------------------------------------------------------- +# Phase 9 - Dataset comparisons (experiment-level) +# ------------------------------------------------------------------- + +def view_phase9_dataset_comparisons(exp_root: Path) -> None: + st.header("Phase 9 - Dataset Comparisons") + + dc_dir = exp_root / "DatasetComparisons" + if not dc_dir.is_dir(): + st.info("No DatasetComparisons directory found at experiment root.") + return + + # 1) BestCompare_KruskalWallis (best algorithm per dataset, per metric) + best_kw = dc_dir / "BestCompare_KruskalWallis.csv" + df_best_kw = _safe_read_csv(best_kw) + if df_best_kw is not None and not df_best_kw.empty: + st.subheader("Best algorithm per dataset - Kruskal-Wallis") + + metric_options = list(df_best_kw.index) if df_best_kw.index.name else list( + df_best_kw[df_best_kw.columns[0]].unique() + ) + metric = st.selectbox("Metric", metric_options, key="p9_metric") + if df_best_kw.index.name: + # DataFrame indexed by metric + row = df_best_kw.loc[metric] + else: + row = df_best_kw[df_best_kw[df_best_kw.columns[0]] == metric].iloc[0] + + # Extract dataset-level stats + cols = list(df_best_kw.columns) + ds_stats = [] + ds_idx = 1 + while True: + alg_col = f"Best_Alg_D{ds_idx}" + mean_col = f"Mean_D{ds_idx}" + std_col = f"Std_D{ds_idx}" + if alg_col not in cols: + break + alg = row.get(alg_col, None) + mean_val = row.get(mean_col, None) + std_val = row.get(std_col, None) + if pd.isna(mean_val): + break + ds_stats.append( + { + "Dataset": f"D{ds_idx}", + "BestAlgorithm": alg, + "MeanScore": float(mean_val), + "StdScore": float(std_val) if not pd.isna(std_val) else None, + } + ) + ds_idx += 1 + + if ds_stats: + df_stats = pd.DataFrame(ds_stats) + fig = px.bar( + df_stats, + x="Dataset", + y="MeanScore", + color="BestAlgorithm", + error_y="StdScore", + barmode="group", + title=f"Best algorithm per dataset - {metric}", + ) + st.plotly_chart(fig, use_container_width=True) + st.dataframe(df_stats) + + # 2) MannWhitney_all / WilcoxonRank_all - dataset pairwise comparisons + mw_all = dc_dir / "MannWhitney_all.csv" + df_mw_all = _safe_read_csv(mw_all) + if df_mw_all is not None and not df_mw_all.empty: + st.subheader("Pairwise dataset comparisons - Mann-Whitney U (all algorithms)") + metric_col = "Metric" if "Metric" in df_mw_all.columns else df_mw_all.columns[0] + metric = st.selectbox("Metric (Mann-Whitney)", sorted(df_mw_all[metric_col].unique())) + df_sub = df_mw_all[df_mw_all[metric_col] == metric] + # Build heatmap of -log10(p) per dataset pair + d1 = df_sub["Data1"].astype(str) + d2 = df_sub["Data2"].astype(str) + p_vals = df_sub["P-Value"] if "P-Value" in df_sub.columns else df_sub[df_sub.columns[4]] + df_heat = pd.DataFrame({"Data1": d1, "Data2": d2, "p": p_vals}) + ds = sorted(set(df_heat["Data1"]).union(set(df_heat["Data2"]))) + mat = pd.DataFrame(index=ds, columns=ds, dtype=float) + for _, row in df_heat.iterrows(): + mat.loc[row["Data1"], row["Data2"]] = -np.log10(max(row["p"], 1e-12)) + mat.loc[row["Data2"], row["Data1"]] = mat.loc[row["Data1"], row["Data2"]] + np.fill_diagonal(mat.values, 0.0) + fig_hm = px.imshow( + mat, + title=f"Mann-Whitney U - dataset pairwise significance (-log10 p) for {metric}", + color_continuous_scale="Viridis", + ) + st.plotly_chart(fig_hm, use_container_width=True) + + +# ------------------------------------------------------------------- +# Phase 11 - High-level reporting overview +# ------------------------------------------------------------------- + +def view_phase_11_reporting(exp_root: Path) -> None: + st.header("Phases 11 - Reporting") + + rep_dir = exp_root / "reporting" + if not rep_dir.is_dir(): + st.info("No reporting directory found.") + return + + report_json = rep_dir / "report_data.json" + data = _safe_read_json(report_json) + if data: + st.subheader("Report summary (JSON)") + st.json(data) + else: + st.info("report_data.json not found or empty.") + + # Runtime of reporting / compare phase + rt_dir = exp_root / "runtime" + if rt_dir.is_dir(): + runtimes = [] + for f in ["runtime_report.txt", "runtime_compare_datasets.txt"]: + path = rt_dir / f + if path.is_file(): + try: + val = float(path.read_text().strip()) + runtimes.append({"Phase": f.replace(".txt", ""), "RuntimeSeconds": val}) + except Exception: + continue + if runtimes: + df = pd.DataFrame(runtimes) + fig = px.bar(df, x="Phase", y="RuntimeSeconds", title="Reporting-related runtimes") + st.plotly_chart(fig, use_container_width=True) + + +# ------------------------------------------------------------------- +# Main App +# ------------------------------------------------------------------- + +def main(exp_root: Path) -> None: + st.set_page_config(page_title="STREAMLINE Reporting Dashboard", layout="wide") + st.title("STREAMLINE Reporting Dashboard (Plotly + Streamlit)") + + if not exp_root.is_dir(): + st.error(f"Experiment root not found: {exp_root}") + return + + datasets = _list_datasets(exp_root) + dataset_names = [p.name for p in datasets] + + st.sidebar.header("Navigation") + dataset_name = st.sidebar.selectbox("Dataset", dataset_names, index=0 if dataset_names else None) + phase = st.sidebar.radio( + "Phase", + [ + "Overview", + "P1 - Exploratory Analysis", + "P2 - Impute & Scale", + "P3 - Feature Learning", + "P4 - Feature Importance", + "P6 - Base Modeling", + "P7 - Ensembles", + "P8 - Summary Statistics", + "P9 - Dataset Comparisons", + "P11 - Reporting", + ], + ) + + dataset_dir = exp_root / dataset_name + + if phase == "Overview": + st.header("Experiment Overview") + st.write(f"Selected dataset: `{dataset_name}`") + + # Simple overview: show runtimes.csv for both datasets in one plot + overview_records = [] + for ds in datasets: + rt = _safe_read_csv(ds / "runtimes.csv") + if rt is None or rt.empty: + continue + # Assume two columns: Phase, RuntimeSeconds (or similar) + if rt.shape[1] >= 2: + phase_col = rt.columns[0] + val_col = rt.columns[1] + tmp = rt[[phase_col, val_col]].copy() + tmp.columns = ["Phase", "RuntimeSeconds"] + tmp["Dataset"] = ds.name + overview_records.append(tmp) + if overview_records: + df_over = pd.concat(overview_records, ignore_index=True) + fig = px.bar( + df_over, + x="Phase", + y="RuntimeSeconds", + color="Dataset", + barmode="group", + title="Runtimes by phase and dataset", + ) + fig.update_layout(xaxis_tickangle=-45) + st.plotly_chart(fig, use_container_width=True) + else: + st.info("No runtimes.csv found for overview plot.") + + elif phase == "P1 - Data Process / Exploratory": + view_phase1_exploratory(dataset_dir) + + elif phase == "P2 - Impute & Scale": + view_phase2_impute_scale(dataset_dir) + + elif phase == "P3 - Feature Learning": + view_phase3_feature_learning(dataset_dir) + + elif phase == "P4&5 - Feature Importance / Selection": + view_phase4_5_feature_importance_selection(dataset_dir) + + elif phase == "P6 - Base Modeling": + view_phase6_modeling(dataset_dir) + + elif phase == "P7 - Ensembles": + view_phase7_ensembles(dataset_dir) + + elif phase == "P8 - Summary Statistics": + view_phase8_statistics(dataset_dir) + + elif phase == "P9 - Dataset Comparisons": + view_phase9_dataset_comparisons(exp_root) + + elif phase == "P11 - Reporting": + view_phase_11_reporting(exp_root) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument( + "--exp_root", + type=str, + default="./out/", + help="Path to experiments root", + ) + parser.add_argument( + "--experiment_name", + type=str, + default="DemoRun", + help="Experiment name", + ) + + args, _ = parser.parse_known_args() + main(Path(args.exp_root + "/" + args.experiment_name)) diff --git a/streamline/old_versions/p11_reporting_old/p11_cli.py b/streamline/old_versions/p11_reporting_old/p11_cli.py new file mode 100644 index 00000000..094c537f --- /dev/null +++ b/streamline/old_versions/p11_reporting_old/p11_cli.py @@ -0,0 +1,47 @@ +from __future__ import annotations + +import argparse +import logging + +from streamline.p11_reporting_old.p11_runner import P11Runner + +logging.basicConfig(level=logging.INFO) + + +def main(): + ap = argparse.ArgumentParser( + "STREAMLINE Phase 10 (Reporting)", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + ap.add_argument("--output_path", required=True) + ap.add_argument("--experiment_name", required=True) + ap.add_argument("--outcome_label", default="Class") + ap.add_argument("--outcome_type", default="Binary") + ap.add_argument("--instance_label", default=None) + ap.add_argument("--make_pdf", type=int, default=1, + help="1 to generate PDF via WeasyPrint if available; 0 to skip.") + ap.add_argument( + "--run_cluster", + default="Serial", + help="Serial | Local | BashSLURM | BashLSF | ", + ) + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", type=int, default=4) + args = ap.parse_args() + + job = P11Runner( + output_path=args.output_path, + experiment_name=args.experiment_name, + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + instance_label=args.instance_label, + make_pdf=bool(args.make_pdf), + run_cluster=args.run_cluster, + queue=args.queue, + reserved_memory=args.reserved_memory, + ) + job.run() + + +if __name__ == "__main__": + main() diff --git a/streamline/old_versions/p11_reporting_old/p11_jobsubmit.py b/streamline/old_versions/p11_reporting_old/p11_jobsubmit.py new file mode 100644 index 00000000..1de5d7b4 --- /dev/null +++ b/streamline/old_versions/p11_reporting_old/p11_jobsubmit.py @@ -0,0 +1,101 @@ +from __future__ import annotations + +import argparse + +from streamline.p11_reporting_old.p11_runner import P11Runner + + +def _none_if_empty(val: str | None) -> str | None: + """ + Normalize 'empty-ish' CLI values back to None. + """ + if val is None: + return None + val_str = str(val).strip() + if val_str == "" or val_str.lower() in {"none", "null"}: + return None + return val_str + + +def main(): + """ + Entry point for Phase 10 reporting when launched on a compute node + via a SLURM/LSF bash wrapper. + + This script intentionally forces run_cluster="Serial"; the parallelism is + handled by the scheduler that launched this process. + """ + ap = argparse.ArgumentParser( + "STREAMLINE Phase 10 (Reporting)", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + + ap.add_argument("--output_path", required=True, help="Top-level output directory") + ap.add_argument("--experiment_name", required=True, help="Experiment folder name") + + ap.add_argument("--outcome_label", default="Class") + ap.add_argument( + "--outcome_type", + default="Binary", + choices=["Binary", "Multiclass", "Continuous"], + help="Outcome type to drive metric/plot selection in the report", + ) + ap.add_argument( + "--instance_label", + default=None, + help="Optional instance ID column used in earlier phases", + ) + + ap.add_argument( + "--report_name", + default="STREAMLINE_Report", + help="Base name for the generated report (HTML/PDF)", + ) + + ap.add_argument( + "--sig_cutoff", + type=float, + default=0.05, + help="Significance cutoff used when annotating stats in the report", + ) + + ap.add_argument( + "--show_plots", + type=int, + default=0, + help="1 = keep Streamlit UI open / debug locally; 0 = non-interactive export only", + ) + + ap.add_argument( + "--run_cluster", + default="Serial", + help="Serial | Local | BashSLURM | BashLSF | ", + ) + + ap.add_argument( + "--make_pdf", + type=int, + default=1, + help="1 = export PDF; 0 = skip PDF", + ) + + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", type=int, default=4) + + args = ap.parse_args() + + P11Runner( + output_path=args.output_path, + experiment_name=args.experiment_name, + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + instance_label=args.instance_label, + make_pdf=bool(args.make_pdf), + run_cluster=args.run_cluster, + queue=args.queue, + reserved_memory=args.reserved_memory, + ).run() + + +if __name__ == "__main__": + main() diff --git a/streamline/old_versions/p11_reporting_old/p11_runner.py b/streamline/old_versions/p11_reporting_old/p11_runner.py new file mode 100644 index 00000000..eda4e0bd --- /dev/null +++ b/streamline/old_versions/p11_reporting_old/p11_runner.py @@ -0,0 +1,144 @@ +# streamline/p10_reporting/p10_runner.py +from __future__ import annotations + +import os +import time +from pathlib import Path +from typing import Optional + +import dask +from dask.distributed import Client, LocalCluster + +from streamline.utils.cluster import get_cluster +from streamline.utils.runners import num_cores +from streamline.p11_reporting_old.reporting_old import ReportPhaseJob + + +class P11Runner: + """ + Phase 10 Runner: experiment-level HTML/PDF reporting (all datasets, models, ensembles). + This is a single job per experiment (not per dataset), similar to P9Runner. + """ + + def __init__( + self, + output_path: str, + experiment_name: str, + outcome_label: str = "Class", + outcome_type: str = "Binary", + instance_label: Optional[str] = None, + make_pdf: bool = True, + # micro_average: str = "micro", # "micro" or "macro", passed through to plots, all are micro by default + # include_ensembles: bool = True, # Whether to include ensemble results in the report, always True for now + run_cluster: str = "Serial", # Serial | Local | BashSLURM | BashLSF | + queue: str = "defq", + reserved_memory: int = 4, + ): + self.output_path = output_path + self.experiment_name = experiment_name + self.exp_root = Path(output_path) / experiment_name + if not self.exp_root.is_dir(): + raise Exception(f"Experiment folder not found: {self.exp_root}") + + # kwargs handed directly to ReportingPhaseJob + self.kw = dict( + output_path=output_path, + experiment_name=experiment_name, + outcome_label=outcome_label, + outcome_type=outcome_type, + instance_label=instance_label, + make_pdf=make_pdf, + # micro_average=micro_average, + # include_ensembles=bool(include_ensembles), + ) + + self.run_cluster = run_cluster or "Serial" + self.queue = queue + self.reserved_memory = int(reserved_memory) + + # ------------------------------------------------------------------ + # Public entry + # ------------------------------------------------------------------ + def run(self): + """ + Phase 10 is a single experiment-level job (like Phase 9). + """ + if self.run_cluster == "Serial": + self._run_one() + + elif self.run_cluster == "Local": + # Local dask (mainly for dev on multi-core machines) + with LocalCluster(processes=True, n_workers=num_cores, threads_per_worker=1) as cluster: + with Client(cluster) as client: + dask.compute( + [dask.delayed(self._run_one)()], + scheduler=client, + ) + + elif self.run_cluster in ("BashSLURM", "BashLSF"): + # Legacy-style bash script submission for SLURM / LSF + self._submit_bash() + + else: + # Named dask cluster (e.g. a shared HPC scheduler) + client: Client = get_cluster( + self.run_cluster, str(self.exp_root), self.queue, self.reserved_memory + ) + dask.compute( + [dask.delayed(self._run_one)()], + scheduler=client, + ) + + # ------------------------------------------------------------------ + # Internal helpers + # ------------------------------------------------------------------ + def _run_one(self): + ReportPhaseJob(**self.kw).run() + + def _submit_bash(self): + """ + Submit a single experiment-level job via SLURM or LSF, using p10_jobsubmit.py. + Mirrors P9Runner._submit_bash. + """ + job_ref = str(time.time()) + jobs = self.exp_root / "jobs" + logs = self.exp_root / "logs" + os.makedirs(jobs, exist_ok=True) + os.makedirs(logs, exist_ok=True) + + sh = jobs / f"P11_{job_ref}_run.sh" + launcher = "sbatch" if self.run_cluster == "BashSLURM" else "bsub <" + script = Path(__file__).with_name("p11_jobsubmit.py") + + args = [ + "python", + str(script), + "--output_path", self.output_path, + "--experiment_name", self.experiment_name, + "--outcome_label", self.kw["outcome_label"], + "--outcome_type", self.kw["outcome_type"], + "--instance_label", self.kw["instance_label"] or "", + # "--micro_average", self.kw.get("micro_average", "micro"), + # "--include_ensembles", str(int(bool(self.kw.get("include_ensembles", True)))), + ] + arg_str = " ".join(args) + + with open(sh, "w") as f: + f.write("#!/bin/bash\n") + if self.run_cluster == "BashSLURM": + f.write(f"#SBATCH -p {self.queue}\n") + f.write(f"#SBATCH --job-name={job_ref}\n") + f.write(f"#SBATCH --mem={self.reserved_memory}G\n") + f.write(f"#SBATCH -o {logs}/P10_{job_ref}.o\n") + f.write(f"#SBATCH -e {logs}/P10_{job_ref}.e\n") + f.write(f"srun {arg_str}\n") + else: # BashLSF + f.write(f"#BSUB -q {self.queue}\n") + f.write(f"#BSUB -J {job_ref}\n") + f.write(f"#BSUB -R \"rusage[mem={self.reserved_memory}G]\"\n") + f.write(f"#BSUB -M {self.reserved_memory}GB\n") + f.write(f"#BSUB -o {logs}/P10_{job_ref}.o\n") + f.write(f"#BSUB -e {logs}/P10_{job_ref}.e\n") + f.write(f"{arg_str}\n") + + os.system(f"{launcher} {sh}") diff --git a/streamline/old_versions/p11_reporting_old/reporting.py b/streamline/old_versions/p11_reporting_old/reporting.py new file mode 100644 index 00000000..626b4c6c --- /dev/null +++ b/streamline/old_versions/p11_reporting_old/reporting.py @@ -0,0 +1,493 @@ +from __future__ import annotations + +import logging +import math +import os +import pickle +import re +from datetime import datetime +from pathlib import Path +from typing import Any, Dict, List, Optional, Tuple + +import pandas as pd +from jinja2 import Environment, FileSystemLoader, select_autoescape +from weasyprint import HTML + +from streamline import __version__ as version + + +EXCLUDE_TOP_LEVEL = { + ".DS_Store", + ".idea", + "jobs", + "jobsCompleted", + "logs", + "dask_logs", + "reporting", + "runtime", + "DatasetComparisons", + "metadata.pickle", + "metadata.csv", + # "algInfo.pickle", + "run_params.pickle", +} + +# Keys where "lower is better" (to decide best-cell highlighting) +LOWER_IS_BETTER = { + "FP", "FN", "LR-", + "Max Error", "Mean Absolute Error", "Mean Squared Error", "Median Absolute Error", +} + +# A4-ish defaults (WeasyPrint @page handles margins, but we use these for plot sizing, etc.) +DEFAULT_DPI = 150 + + +def slugify(s: str) -> str: + s = s.strip().lower() + s = re.sub(r"[^a-z0-9]+", "-", s) + return re.sub(r"-+", "-", s).strip("-") + + +def safe_abs_posix(path: Path) -> str: + return str(path.resolve().as_posix()) + + +def list_datasets(experiment_root: Path) -> List[Path]: + datasets: List[Path] = [] + for p in experiment_root.iterdir(): + if not p.is_dir(): + continue + if p.name in EXCLUDE_TOP_LEVEL: + continue + datasets.append(p) + return sorted(datasets, key=lambda x: x.name) + + +def read_csv_df(path: Path, index_col: Optional[int] = None) -> Optional[pd.DataFrame]: + if not path.exists(): + return None + try: + return pd.read_csv(path, index_col=index_col) + except Exception: + return None + + +def read_csv_records(path: Path, limit: Optional[int] = None) -> List[Dict[str, Any]]: + df = read_csv_df(path) + if df is None: + return [] + if limit is not None: + df = df.head(limit) + # ensure 3-decimal formatting consistently in records too + df = format_df_3dp(df) + return df.to_dict(orient="records") + + +def format_df_3dp(df: pd.DataFrame) -> pd.DataFrame: + """Format all numeric columns to 3 decimals (as strings).""" + out = df.copy() + for col in out.columns: + # don't break non-numeric columns + series = pd.to_numeric(out[col], errors="coerce") + if series.notna().any(): + out[col] = [ + "" if pd.isna(v) else f"{float(v):.3f}" + for v in series + ] + return out + + +def compute_best_cells(mean_df: pd.DataFrame) -> Dict[Tuple[int, str], bool]: + """ + Returns mapping (row_index, column_name) -> True if best in column (ties included). + Expects first col = label (model/ensemble name), others numeric. + """ + best_map: Dict[Tuple[int, str], bool] = {} + if mean_df is None or mean_df.empty: + return best_map + + df = mean_df.copy() + for col in df.columns[1:]: + df[col] = pd.to_numeric(df[col], errors="coerce") + + for col in df.columns[1:]: + s = df[col] + if s.dropna().empty: + continue + best_val = s.min(skipna=True) if col in LOWER_IS_BETTER else s.max(skipna=True) + for idx, val in s.items(): + if pd.isna(val): + continue + if float(val) == float(best_val): + best_map[(idx, col)] = True + return best_map + + +def merge_mean_std_tables(mean_df: Optional[pd.DataFrame], std_df: Optional[pd.DataFrame]) -> Optional[pd.DataFrame]: + """ + Builds a table where numeric cells are "mean ± std" (3dp). + If std missing: numeric cells are "mean" (3dp). + """ + if mean_df is None or mean_df.empty: + return None + + m = mean_df.copy() + s = std_df.copy() if (std_df is not None and not std_df.empty) else None + + key = m.columns[0] + if s is None: + # just format mean to 3dp + return format_df_3dp(m) + + # Align by key if possible + if key in s.columns: + s_map = {str(r[key]): r for _, r in s.iterrows()} + rows = [] + for _, r in m.iterrows(): + rr = r.copy() + sid = str(r[key]) + sr = s_map.get(sid) + for col in m.columns[1:]: + mv = pd.to_numeric(r.get(col), errors="coerce") + sv = pd.to_numeric(sr.get(col), errors="coerce") if sr is not None else math.nan + if pd.isna(mv): + rr[col] = "" + elif pd.isna(sv): + rr[col] = f"{float(mv):.3f}" + else: + rr[col] = f"{float(mv):.3f} ± {float(sv):.3f}" + rows.append(rr) + return pd.DataFrame(rows, columns=m.columns) + + # Fallback index alignment + out = m.copy() + for col in out.columns[1:]: + mv = pd.to_numeric(m[col], errors="coerce") + sv = pd.to_numeric(s[col], errors="coerce") if col in s.columns else pd.Series([math.nan] * len(m)) + col_out: List[str] = [] + for i in range(len(out)): + a = mv.iloc[i] if i < len(mv) else math.nan + b = sv.iloc[i] if i < len(sv) else math.nan + if pd.isna(a): + col_out.append("") + elif pd.isna(b): + col_out.append(f"{float(a):.3f}") + else: + col_out.append(f"{float(a):.3f} ± {float(b):.3f}") + out[col] = col_out + return out + + +def _df_to_table_payload( + df: Optional[pd.DataFrame], + best_map: Optional[Dict[Tuple[int, str], bool]] = None, +) -> Dict[str, Any]: + """ + Payload for Jinja rendering: + { + "present": bool, + "columns": [...], + "rows": [{"cells":[{"value":..., "best":bool}, ...]}, ...] + } + """ + if df is None or df.empty: + return {"present": False, "columns": [], "rows": []} + + columns = list(df.columns) + rows: List[Dict[str, Any]] = [] + + for ridx in range(len(df)): + cells: List[Dict[str, Any]] = [] + for cidx, col in enumerate(columns): + val = df.iloc[ridx, cidx] + v = "" if pd.isna(val) else str(val) + is_best = False + if best_map is not None and cidx > 0: + is_best = best_map.get((ridx, col), False) + cells.append({"value": v, "best": bool(is_best)}) + rows.append({"cells": cells}) + + return {"present": True, "columns": columns, "rows": rows} + + +# ----------------------------- +# Plot generation (only if missing) +# ----------------------------- +def ensure_class_counts_plot(exploratory_dir: Path) -> Optional[Path]: + png = exploratory_dir / "ClassCountsBarPlot.png" + if png.exists(): + return png + + csv_path = exploratory_dir / "ClassCounts.csv" + if not csv_path.exists(): + return None + + try: + import matplotlib.pyplot as plt + + df = pd.read_csv(csv_path) + # try common patterns: either columns [Class, Count] or first two columns + if df.shape[1] >= 2: + x = df.iloc[:, 0].astype(str).tolist() + y = pd.to_numeric(df.iloc[:, 1], errors="coerce").fillna(0).tolist() + else: + return None + + plt.figure() + plt.bar(x, y) + plt.xticks(rotation=45, ha="right") + plt.tight_layout() + png.parent.mkdir(parents=True, exist_ok=True) + plt.savefig(png, dpi=DEFAULT_DPI) + plt.close() + return png + except Exception as e: + logging.warning("Failed to generate ClassCountsBarPlot.png: %s", e) + return None + + +def ensure_feature_correlation_plot(exploratory_dir: Path) -> Optional[Path]: + png = exploratory_dir / "FeatureCorrelations.png" + if png.exists(): + return png + + csv_path = exploratory_dir / "FeatureCorrelations.csv" + if not csv_path.exists(): + return None + + try: + import matplotlib.pyplot as plt + import numpy as np + + df = pd.read_csv(csv_path, index_col=0) + mat = df.values.astype(float) + plt.figure() + plt.imshow(mat, aspect="auto") + plt.colorbar() + # keep labels small; big matrices will be unreadable anyway + plt.xticks([]) + plt.yticks([]) + plt.tight_layout() + png.parent.mkdir(parents=True, exist_ok=True) + plt.savefig(png, dpi=DEFAULT_DPI) + plt.close() + return png + except Exception as e: + logging.warning("Failed to generate FeatureCorrelations.png: %s", e) + return None + + +class ReportPhaseJob: + """ + Generates a multi-dataset STREAMLINE PDF report using Jinja2 + WeasyPrint. + + - Corrects filenames to match your tree + - Adds model + ensemble performance tables (mean±std, median) + - Applies 3dp formatting everywhere + - Highlights best cells like old FPDF + - Improves pagination via CSS in template + - Generates a couple plots from CSV if missing + """ + + def __init__( + self, + output_path: Optional[str] = None, + experiment_name: Optional[str] = None, + experiment_path: Optional[str] = None, + training: bool = True, + make_pdf: bool = True, + template_name: str = "report.html.j2", + ): + if experiment_path: + self.experiment_root = Path(experiment_path) + self.experiment_name = self.experiment_root.name + else: + if output_path is None or experiment_name is None: + raise ValueError("Provide either experiment_path OR (output_path and experiment_name).") + self.experiment_root = Path(output_path) / str(experiment_name) + self.experiment_name = str(experiment_name) + + self.training = bool(training) + self.make_pdf = bool(make_pdf) + + self.template_dir = Path(__file__).parent / "templates" + self.template_name = template_name + + self.metadata = self._load_pickle(self.experiment_root / "metadata.pickle") or {} + # self.alg_info = self._load_pickle(self.experiment_root / "algInfo.pickle") or {} + self.outcome_type = self.metadata.get("Outcome Type", "Unknown") + + def _load_pickle(self, path: Path) -> Any: + if not path.exists(): + return None + try: + with open(path, "rb") as f: + return pickle.load(f) + except Exception as e: + logging.warning("Failed to load pickle %s: %s", path, e) + return None + + def run(self): + self.job() + + def job(self): + logging.info("Starting ReportPhaseJob for %s", self.experiment_root) + + generated_at = datetime.now() + + ds_dirs = list_datasets(self.experiment_root) + datasets: List[Dict[str, Any]] = [] + for ds in ds_dirs: + datasets.append(self._build_dataset_section(ds)) + + comparisons = self._build_dataset_comparisons_section() + + env = Environment( + loader=FileSystemLoader(str(self.template_dir)), + autoescape=select_autoescape(["html", "xml"]), + ) + template = env.get_template(self.template_name) + + html_str = template.render( + title="STREAMLINE Evaluation Report", + experiment_name=self.experiment_name, + experiment_root=safe_abs_posix(self.experiment_root), + generated_at=generated_at.strftime("%Y-%m-%d %H:%M:%S"), + streamline_version=version, + training=self.training, + outcome_type=self.outcome_type, + metadata=self.metadata, + # alg_info=self.alg_info, + datasets=datasets, + dataset_comparisons=comparisons, + ) + + out_dir = self.experiment_root / "reporting" + out_dir.mkdir(parents=True, exist_ok=True) + out_pdf = out_dir / f"{self.experiment_name}_STREAMLINE_Report.pdf" + + if self.make_pdf: + HTML(string=html_str, base_url=str(self.experiment_root.resolve().as_uri())).write_pdf(str(out_pdf)) + logging.info("Wrote PDF: %s", out_pdf) + + # completion marker + try: + jc = self.experiment_root / "jobsCompleted" + jc.mkdir(exist_ok=True, parents=True) + (jc / "job_p11_reporting.txt").write_text("complete") + except Exception: + pass + + def _build_dataset_section(self, dataset_dir: Path) -> Dict[str, Any]: + ds_name = dataset_dir.name + ds_slug = slugify(ds_name) + + exploratory_dir = dataset_dir / "exploratory" + model_eval_dir = dataset_dir / "model_evaluation" + ensemble_eval_dir = dataset_dir / "ensemble_evaluation" + + # generate a couple plots from CSV if missing + if exploratory_dir.exists(): + ensure_class_counts_plot(exploratory_dir) + ensure_feature_correlation_plot(exploratory_dir) + + figures: Dict[str, Optional[str]] = {} + + # Exploratory + figures["class_counts"] = safe_abs_posix(exploratory_dir / "ClassCountsBarPlot.png") if (exploratory_dir / "ClassCountsBarPlot.png").exists() else None + figures["feature_correlations"] = safe_abs_posix(exploratory_dir / "FeatureCorrelations.png") if (exploratory_dir / "FeatureCorrelations.png").exists() else None + + # Model evaluation summaries + figures["summary_roc"] = safe_abs_posix(model_eval_dir / "Summary_ROC.png") if (model_eval_dir / "Summary_ROC.png").exists() else None + figures["summary_prc"] = safe_abs_posix(model_eval_dir / "Summary_PRC.png") if (model_eval_dir / "Summary_PRC.png").exists() else None + + mb = model_eval_dir / "metricBoxplots" + figures["compare_roc_auc"] = safe_abs_posix(mb / "Compare_ROC AUC.png") if (mb / "Compare_ROC AUC.png").exists() else None + figures["compare_prc_auc"] = safe_abs_posix(mb / "Compare_PRC AUC.png") if (mb / "Compare_PRC AUC.png").exists() else None + + # Ensemble evaluation summaries (your tree: Summary_*_ensembles.png) + figures["summary_roc_ensembles"] = safe_abs_posix(ensemble_eval_dir / "Summary_ROC_ensembles.png") if (ensemble_eval_dir / "Summary_ROC_ensembles.png").exists() else None + figures["summary_prc_ensembles"] = safe_abs_posix(ensemble_eval_dir / "Summary_PRC_ensembles.png") if (ensemble_eval_dir / "Summary_PRC_ensembles.png").exists() else None + + # Feature importance plots (your tree uses: feature_importance/multisurf and feature_importance/mutualinformation) + fi_mi = dataset_dir / "feature_importance" / "mutualinformation" / "TopAverageScores.png" + fi_ms = dataset_dir / "feature_importance" / "multisurf" / "TopAverageScores.png" + figures["fi_mutualinformation"] = safe_abs_posix(fi_mi) if fi_mi.exists() else None + figures["fi_multisurf"] = safe_abs_posix(fi_ms) if fi_ms.exists() else None + + # Tables + tables: Dict[str, Any] = {} + tables["data_process_summary"] = read_csv_records(exploratory_dir / "DataProcessSummary.csv") + tables["univariate_top10"] = read_csv_records(exploratory_dir / "univariate_analyses" / "Univariate_Significance.csv", limit=10) + tables["informative_feature_summary"] = read_csv_records(dataset_dir / "feature_selection" / "InformativeFeatureSummary.csv") + tables["runtimes"] = read_csv_records(dataset_dir / "runtimes.csv") + + # Performance tables (models + ensembles): mean±std together; median separate + perf: Dict[str, Any] = {} + + # Models + m_mean = read_csv_df(model_eval_dir / "Summary_performance_mean.csv", index_col=0) + m_median = read_csv_df(model_eval_dir / "Summary_performance_median.csv", index_col=0) + m_std = read_csv_df(model_eval_dir / "Summary_performance_std.csv", index_col=0) + + # reset to include algorithm column again + if m_mean is not None: + m_mean = m_mean.reset_index() + if m_median is not None: + m_median = m_median.reset_index() + if m_std is not None: + m_std = m_std.reset_index() + + m_best_map = compute_best_cells(m_mean) if m_mean is not None else {} + m_mean_std = merge_mean_std_tables(m_mean, m_std) + if m_median is not None: + m_median = format_df_3dp(m_median) + + perf["models_mean_std"] = _df_to_table_payload(m_mean_std, best_map=m_best_map) + perf["models_median"] = _df_to_table_payload(m_median, best_map=None) + + # Ensembles + e_mean = read_csv_df(ensemble_eval_dir / "Ensembles_performance_mean.csv", index_col=0) + e_median = read_csv_df(ensemble_eval_dir / "Ensembles_performance_median.csv", index_col=0) + e_std = read_csv_df(ensemble_eval_dir / "Ensembles_performance_std.csv", index_col=0) + + if e_mean is not None: + e_mean = e_mean.reset_index() + if e_median is not None: + e_median = e_median.reset_index() + if e_std is not None: + e_std = e_std.reset_index() + + e_best_map = compute_best_cells(e_mean) if e_mean is not None else {} + e_mean_std = merge_mean_std_tables(e_mean, e_std) + if e_median is not None: + e_median = format_df_3dp(e_median) + + perf["ensembles_mean_std"] = _df_to_table_payload(e_mean_std, best_map=e_best_map) + perf["ensembles_median"] = _df_to_table_payload(e_median, best_map=None) + + return { + "dataset_name": ds_name, + "dataset_slug": ds_slug, + "dataset_dir": safe_abs_posix(dataset_dir), + "figures": figures, + "tables": tables, + "perf": perf, + } + + def _build_dataset_comparisons_section(self) -> Dict[str, Any]: + dc_dir = self.experiment_root / "DatasetComparisons" + if not dc_dir.exists(): + return {"present": False, "figures": {}, "tables": {}} + + figures: Dict[str, Optional[str]] = {} + tables: Dict[str, Any] = {} + + box_dir = dc_dir / "dataCompBoxplots" + figures["allmodels_roc_auc"] = safe_abs_posix(box_dir / "DataCompareAllModels_ROC AUC.png") if (box_dir / "DataCompareAllModels_ROC AUC.png").exists() else None + figures["allmodels_prc_auc"] = safe_abs_posix(box_dir / "DataCompareAllModels_PRC AUC.png") if (box_dir / "DataCompareAllModels_PRC AUC.png").exists() else None + + # Table(s) + tables["best_kw"] = read_csv_records(dc_dir / "BestCompare_KruskalWallis.csv") + + return {"present": True, "figures": figures, "tables": tables} diff --git a/streamline/old_versions/p11_reporting_old/reporting_old.py b/streamline/old_versions/p11_reporting_old/reporting_old.py new file mode 100644 index 00000000..665707be --- /dev/null +++ b/streamline/old_versions/p11_reporting_old/reporting_old.py @@ -0,0 +1,691 @@ +from __future__ import annotations + +import json +import logging +import time +from dataclasses import dataclass +from pathlib import Path +from typing import Any, Dict, List, Optional, Tuple + +import pandas as pd + +logger = logging.getLogger(__name__) + +from jinja2 import Environment, FileSystemLoader, select_autoescape +from weasyprint import HTML # noqa: F401 + + +def _safe_plotly_to_png(fig, out_path: Path, scale: int = 2) -> bool: + """ + Try to export plotly fig to PNG (kaleido). Return True if success. + """ + try: + import plotly.io as pio # type: ignore + + out_path.parent.mkdir(parents=True, exist_ok=True) + pio.write_image(fig, str(out_path), format="png", scale=scale) + return True + except Exception as e: + logger.warning("Plotly export failed for %s: %r", out_path, e) + return False + + +def _now_iso_local() -> str: + return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) + + +def _try_streamline_version() -> str: + try: + import importlib.metadata as im + + return im.version("streamline") + except Exception: + return "unknown" + + +def _rel_to_reporting(reporting_dir: Path, p: Path) -> str: + """ + WeasyPrint base_url is reporting_dir, so all src= should be relative to it. + """ + try: + return str(p.relative_to(reporting_dir)) + except Exception: + return str(p) + + +@dataclass +class ReportPaths: + reporting_dir: Path + data_json: Path + html: Path + pdf: Path + figures_dir: Path + + +class ReportPhaseJob: + """ + Phase 11: Reporting + + Generates a multi-page HTML report (Jinja2) and prints to PDF (WeasyPrint), + with multi-image mosaics per page. + + IMPORTANT: This version does NOT try to locate “legacy” plots. + It replots from available CSV/JSON artifacts and exports PNGs for the report. + """ + + def __init__( + self, + output_path: Optional[str] = None, + experiment_name: Optional[str] = None, + experiment_path: Optional[str] = None, + outcome_label: Optional[str] = None, + outcome_type: Optional[str] = None, + instance_label: Optional[str] = None, + make_pdf: bool = True, + ): + assert (output_path and experiment_name) or experiment_path, ( + "Provide (output_path, experiment_name) or experiment_path." + ) + + if experiment_path: + self.exp_root = Path(experiment_path) + self.output_path = str(self.exp_root.parent) + self.experiment_name = self.exp_root.name + else: + self.output_path = str(output_path) + self.experiment_name = str(experiment_name) + self.exp_root = Path(self.output_path) / self.experiment_name + + if not self.exp_root.is_dir(): + raise FileNotFoundError(f"Experiment folder not found: {self.exp_root}") + + self.title = f"{self.experiment_name} - STREAMLINE Report" + self.make_pdf = make_pdf + self.job_start_time: Optional[float] = None + + self.outcome_label = outcome_label + self.outcome_type = outcome_type + self.instance_label = instance_label + + self.paths = self._init_paths() + + def _init_paths(self) -> ReportPaths: + reporting_dir = self.exp_root / "reporting" + figures_dir = reporting_dir / "figures" + reporting_dir.mkdir(exist_ok=True) + figures_dir.mkdir(parents=True, exist_ok=True) + return ReportPaths( + reporting_dir=reporting_dir, + data_json=reporting_dir / "report_data.json", + html=reporting_dir / "report.html", + pdf=reporting_dir / "report.pdf", + figures_dir=figures_dir, + ) + + # ---------------------------- + # Discovery helpers + # ---------------------------- + def _list_datasets(self) -> List[Path]: + ignore = { + "jobs", + "logs", + "jobsCompleted", + "dask_logs", + "runtime", + "DatasetComparisons", + "reporting", + } + ds = [] + for p in sorted(self.exp_root.iterdir()): + if not p.is_dir(): + continue + if p.name in ignore: + continue + if (p / "CVDatasets").is_dir(): + ds.append(p) + return ds + + def _read_csv_if_exists(self, path: Path) -> Optional[pd.DataFrame]: + try: + if path.is_file(): + return pd.read_csv(path) + except Exception as e: + logger.warning("Failed reading CSV %s: %r", path, e) + return None + + def _read_json_if_exists(self, path: Path) -> Optional[Dict[str, Any]]: + try: + if path.is_file(): + return json.loads(path.read_text()) + except Exception as e: + logger.warning("Failed reading JSON %s: %r", path, e) + return None + + # ---------------------------- + # Plot builders (replot everything) + # ---------------------------- + def _plot_model_summary_bars(self, summary_mean: pd.DataFrame, metric: str, title: str): + import plotly.express as px # type: ignore + + df = summary_mean.copy() + # rehydrate index if needed + if df.columns[0].lower() not in {"unnamed: 0", "model", "algorithm", "ml algorithm", "ml_algorithm"}: + if df.index.name is not None: + df = df.reset_index() + name_col = df.columns[0] + + if metric not in df.columns: + raise KeyError(metric) + + df = df[[name_col, metric]].dropna() + df = df.sort_values(metric, ascending=False) + + fig = px.bar(df, x=name_col, y=metric, title=title) + fig.update_layout(xaxis_title="Model", yaxis_title=metric) + return fig + + def _plot_cv_metric_distribution(self, metrics_by_cv_dir: Path, metric: str, title: str): + import plotly.express as px # type: ignore + + rows = [] + for fn in sorted(metrics_by_cv_dir.glob("*.json")): + blob = self._read_json_if_exists(fn) + if not blob: + continue + alg = fn.name.split("_CV_")[0] + val = blob.get(metric) + if val is None: + continue + rows.append({"Model": alg, "Value": float(val)}) + + df = pd.DataFrame(rows) + if df.empty: + raise RuntimeError(f"No per-CV metric values found for metric={metric} under {metrics_by_cv_dir}") + + fig = px.box(df, x="Model", y="Value", points="all", title=title) + fig.update_layout(xaxis_title="Model", yaxis_title=metric) + return fig + + def _extract_xy_from_curve_blob( + self, blob: Dict[str, Any], curve_kind: str + ) -> Tuple[Optional[List[float]], Optional[List[float]]]: + if curve_kind == "roc": + for a, b in [("fpr", "tpr"), ("x", "y")]: + if a in blob and b in blob: + return list(map(float, blob[a])), list(map(float, blob[b])) + else: + for a, b in [("recall", "precision"), ("x", "y")]: + if a in blob and b in blob: + return list(map(float, blob[a])), list(map(float, blob[b])) + return None, None + + def _plot_roc_prc_from_curve_json(self, curves_dir: Path, curve_kind: str, title: str): + import plotly.graph_objects as go # type: ignore + + groups: Dict[str, List[Dict[str, Any]]] = {} + for fn in sorted(curves_dir.glob(f"*_{curve_kind}.json")): + alg = fn.name.split("_CV_")[0] + blob = self._read_json_if_exists(fn) + if not blob: + continue + groups.setdefault(alg, []).append(blob) + + if not groups: + raise RuntimeError(f"No curve json found for {curve_kind} under {curves_dir}") + + fig = go.Figure() + for alg, blobs in groups.items(): + for i, b in enumerate(blobs): + x, y = self._extract_xy_from_curve_blob(b, curve_kind) + if x is None or y is None: + continue + fig.add_trace( + go.Scatter( + x=x, + y=y, + mode="lines", + name=f"{alg}", + showlegend=(i == 0), + opacity=0.30 if i > 0 else 0.90, + ) + ) + + xlab = "False Positive Rate" if curve_kind == "roc" else "Recall" + ylab = "True Positive Rate" if curve_kind == "roc" else "Precision" + fig.update_layout(title=title, xaxis_title=xlab, yaxis_title=ylab) + return fig + + def _plot_class_counts(self, class_counts: pd.DataFrame, title: str): + """ + Best-effort class balance bar plot from exploratory/ClassCounts.csv + """ + import plotly.express as px # type: ignore + + df = class_counts.copy() + # Common layouts vary; try to find label/count columns + low = {c.lower(): c for c in df.columns} + label_col = None + count_col = None + + for cand in ["class", "label", "outcome", "y", "group"]: + if cand in low: + label_col = low[cand] + break + for cand in ["count", "n", "num", "frequency", "freq"]: + if cand in low: + count_col = low[cand] + break + + if label_col is None: + label_col = df.columns[0] + if count_col is None: + # if two columns, assume second is count + count_col = df.columns[1] if len(df.columns) > 1 else df.columns[0] + + df = df[[label_col, count_col]].dropna() + df[count_col] = pd.to_numeric(df[count_col], errors="coerce") + df = df.dropna() + fig = px.bar(df, x=label_col, y=count_col, title=title) + fig.update_layout(xaxis_title="Class", yaxis_title="Count") + return fig + + def _plot_missingness(self, missingness: pd.DataFrame, title: str): + """ + Best-effort missingness bar plot from exploratory/DataMissingness.csv + """ + import plotly.express as px # type: ignore + + df = missingness.copy() + # likely columns: Feature, MissingCount or MissingPercent + low = {c.lower(): c for c in df.columns} + fcol = low.get("feature", df.columns[0]) + pcol = None + for cand in ["missingpercent", "missing_percent", "percentmissing", "pct_missing", "missingpct"]: + if cand in low: + pcol = low[cand] + break + ccol = None + for cand in ["missingcount", "missing_count", "countmissing", "n_missing"]: + if cand in low: + ccol = low[cand] + break + + val_col = pcol or ccol or df.columns[-1] + df = df[[fcol, val_col]].dropna() + df[val_col] = pd.to_numeric(df[val_col], errors="coerce") + df = df.dropna().sort_values(val_col, ascending=False).head(25) + + fig = px.bar(df.iloc[::-1], x=val_col, y=fcol, orientation="h", title=title) + fig.update_layout(xaxis_title=val_col, yaxis_title="Feature") + return fig + + # ---------------------------- + # Formatting helpers (tables) + # ---------------------------- + def _infer_alg_col(self, df: pd.DataFrame) -> str: + low = {c.lower(): c for c in df.columns} + for key in ["ml algorithm", "ml_algorithm", "algorithm", "model"]: + if key in low: + return low[key] + return df.columns[0] + + def _build_mean_std_table( + self, + mean_df: Optional[pd.DataFrame], + std_df: Optional[pd.DataFrame], + highlight_metric_candidates: List[str], + max_rows: int = 50, + ) -> Dict[str, Any]: + if mean_df is None or mean_df.empty or std_df is None or std_df.empty: + return {"present": False} + + m = mean_df.copy() + s = std_df.copy() + + alg_col_m = self._infer_alg_col(m) + alg_col_s = self._infer_alg_col(s) + if alg_col_m != "Algorithm": + m = m.rename(columns={alg_col_m: "Algorithm"}) + if alg_col_s != "Algorithm": + s = s.rename(columns={alg_col_s: "Algorithm"}) + + highlight_metric = None + for cand in highlight_metric_candidates: + if cand in m.columns: + highlight_metric = cand + break + + common_metrics = [c for c in m.columns if c != "Algorithm" and c in s.columns] + if not common_metrics: + return {"present": False} + + merged = m[["Algorithm"] + common_metrics].merge( + s[["Algorithm"] + common_metrics], + on="Algorithm", + how="inner", + suffixes=("_mean", "_std"), + ) + + columns = ["Algorithm"] + common_metrics + + best_alg = None + if highlight_metric and f"{highlight_metric}_mean" in merged.columns: + try: + best_idx = merged[f"{highlight_metric}_mean"].astype(float).idxmax() + best_alg = str(merged.loc[best_idx, "Algorithm"]) + except Exception: + best_alg = None + + rows = [] + for _, r in merged.head(max_rows).iterrows(): + cells = [] + for c in columns: + if c == "Algorithm": + val = str(r["Algorithm"]) + cells.append({"value": val, "best": bool(best_alg and val == best_alg)}) + else: + mv = r.get(f"{c}_mean", None) + sv = r.get(f"{c}_std", None) + try: + mvf = float(mv) + svf = float(sv) if sv is not None else float("nan") + val = f"{mvf:.3f} ± {svf:.3f}" + except Exception: + val = str(mv) + cells.append({"value": val, "best": False}) + rows.append({"cells": cells}) + + return { + "present": True, + "columns": columns, + "rows": rows, + "highlight_metric": highlight_metric, + "best_algorithm": best_alg, + } + + def _build_plain_table(self, df: Optional[pd.DataFrame], max_rows: int = 100) -> Dict[str, Any]: + if df is None or df.empty: + return {"present": False} + cols = list(df.columns) + rows = df.head(max_rows).fillna("").astype(str).values.tolist() + return {"present": True, "columns": cols, "rows": rows} + + # ---------------------------- + # Data assembly (and plot export) + # ---------------------------- + def _collect_dataset_block(self, ds_dir: Path) -> Dict[str, Any]: + name = ds_dir.name + figs: Dict[str, str] = {} + + # Phase 1 tables + explore = ds_dir / "exploratory" + data_process_summary = self._read_csv_if_exists(explore / "DataProcessSummary.csv") + class_counts = self._read_csv_if_exists(explore / "ClassCounts.csv") + missingness = self._read_csv_if_exists(explore / "DataMissingness.csv") + univariate = self._read_csv_if_exists(explore / "univariate_analyses" / "Univariate_Significance.csv") + univariate_top10 = univariate.head(10) if (univariate is not None and not univariate.empty) else None + + # Phase 8 model evaluation tables + sources for plots + model_eval = ds_dir / "model_evaluation" + summary_mean = self._read_csv_if_exists(model_eval / "Summary_performance_mean.csv") + summary_std = self._read_csv_if_exists(model_eval / "Summary_performance_std.csv") + summary_median = self._read_csv_if_exists(model_eval / "Summary_performance_median.csv") + + # Ensemble tables + ens_eval = ds_dir / "ensemble_evaluation" + ens_mean = self._read_csv_if_exists(ens_eval / "Ensembles_performance_mean.csv") + ens_std = self._read_csv_if_exists(ens_eval / "Ensembles_performance_std.csv") + ens_median = self._read_csv_if_exists(ens_eval / "Ensembles_performance_median.csv") + + # Feature selection + feat_sel = self._read_csv_if_exists(ds_dir / "feature_selection" / "InformativeFeatureSummary.csv") + + # Runtimes + runtimes = self._read_csv_if_exists(ds_dir / "runtimes.csv") + + # ----------------- + # Replot figures + # ----------------- + # Exploratory: class counts + missingness + if class_counts is not None and not class_counts.empty: + try: + fig = self._plot_class_counts(class_counts, f"{name}: Class Balance") + out = self.paths.figures_dir / f"{name}_class_balance.png" + if _safe_plotly_to_png(fig, out): + figs["class_balance"] = _rel_to_reporting(self.paths.reporting_dir, out) + except Exception as e: + logger.warning("Class balance plot failed for %s: %r", name, e) + + if missingness is not None and not missingness.empty: + try: + fig = self._plot_missingness(missingness, f"{name}: Missingness (Top 25)") + out = self.paths.figures_dir / f"{name}_missingness_top25.png" + if _safe_plotly_to_png(fig, out): + figs["missingness"] = _rel_to_reporting(self.paths.reporting_dir, out) + except Exception as e: + logger.warning("Missingness plot failed for %s: %r", name, e) + + # Model mean bar (pick best available metric) + chosen_metric = None + if summary_mean is not None and not summary_mean.empty: + for preferred in ["Balanced Accuracy", "ROC AUC", "PRC AUC", "Accuracy"]: + if preferred in summary_mean.columns: + chosen_metric = preferred + try: + fig = self._plot_model_summary_bars( + summary_mean, preferred, f"{name}: Mean {preferred} (Models)" + ) + out = self.paths.figures_dir / f"{name}_models_mean_{preferred.replace(' ', '_')}.png" + if _safe_plotly_to_png(fig, out): + figs["models_mean_bar"] = _rel_to_reporting(self.paths.reporting_dir, out) + figs["models_mean_metric"] = preferred + except Exception as e: + logger.warning("Model mean bar plot failed for %s (%s): %r", name, preferred, e) + break + + # CV distribution boxplot + mbc = model_eval / "metrics_by_cv" + if mbc.is_dir(): + for preferred in ["Balanced Accuracy", "ROC AUC", "PRC AUC"]: + try: + fig = self._plot_cv_metric_distribution( + mbc, preferred, f"{name}: CV Distribution ({preferred}) - Models" + ) + out = self.paths.figures_dir / f"{name}_models_cv_box_{preferred.replace(' ', '_')}.png" + if _safe_plotly_to_png(fig, out): + figs["models_cv_box"] = _rel_to_reporting(self.paths.reporting_dir, out) + figs["models_cv_metric"] = preferred + break + except Exception: + continue + + # ROC/PRC overlays from curves_by_cv + curves = model_eval / "curves_by_cv" + if curves.is_dir(): + for kind in ["roc", "prc"]: + try: + fig = self._plot_roc_prc_from_curve_json(curves, kind, f"{name}: {kind.upper()} Curves (Models)") + out = self.paths.figures_dir / f"{name}_models_{kind}_overlay.png" + if _safe_plotly_to_png(fig, out): + figs[f"models_{kind}_overlay"] = _rel_to_reporting(self.paths.reporting_dir, out) + except Exception: + pass + + # Feature importance top-20 (from *_FI.csv) + fi_dir = model_eval / "feature_importance" + fi_files = sorted(fi_dir.glob("*_FI.csv")) if fi_dir.is_dir() else [] + if fi_files: + try: + import plotly.express as px # type: ignore + + fi_df = pd.read_csv(fi_files[0]) + cols = [c.lower() for c in fi_df.columns] + fcol = fi_df.columns[cols.index("feature")] if "feature" in cols else fi_df.columns[0] + icol = fi_df.columns[cols.index("importance")] if "importance" in cols else fi_df.columns[-1] + top = fi_df[[fcol, icol]].dropna() + top[icol] = pd.to_numeric(top[icol], errors="coerce") + top = top.dropna().sort_values(icol, ascending=False).head(20) + fig = px.bar( + top.iloc[::-1], x=icol, y=fcol, orientation="h", + title=f"{name}: Top 20 Feature Importance" + ) + out = self.paths.figures_dir / f"{name}_fi_top20.png" + if _safe_plotly_to_png(fig, out): + figs["fi_top20"] = _rel_to_reporting(self.paths.reporting_dir, out) + except Exception as e: + logger.warning("FI top20 plot failed for %s: %r", name, e) + + # ----------------- + # Tables (classic) + # ----------------- + models_mean_std = self._build_mean_std_table( + summary_mean, summary_std, + highlight_metric_candidates=["Balanced Accuracy", "ROC AUC", "PRC AUC", "Accuracy"], + ) + models_median = self._build_plain_table(summary_median, max_rows=100) + + ensembles_mean_std = self._build_mean_std_table( + ens_mean, ens_std, + highlight_metric_candidates=["Balanced Accuracy", "ROC AUC", "PRC AUC", "Accuracy"], + ) + ensembles_median = self._build_plain_table(ens_median, max_rows=100) + + return { + "dataset_name": name, + "dataset_dir": str(ds_dir), + "tables": { + "data_process_summary": self._build_plain_table(data_process_summary, max_rows=50), + "univariate_top10": self._build_plain_table(univariate_top10, max_rows=10), + "informative_feature_summary": self._build_plain_table(feat_sel, max_rows=200), + "runtimes": self._build_plain_table(runtimes, max_rows=500), + }, + "perf": { + "models_mean_std": models_mean_std, + "models_median": models_median, + "ensembles_mean_std": ensembles_mean_std, + "ensembles_median": ensembles_median, + }, + "figures": figs, + } + + def _collect_dataset_comparisons_block(self) -> Dict[str, Any]: + dc = self.exp_root / "DatasetComparisons" + if not dc.is_dir(): + return {"present": False} + + best_kw = self._read_csv_if_exists(dc / "BestCompare_KruskalWallis.csv") + best_mw = self._read_csv_if_exists(dc / "BestCompare_MannWhitney.csv") + best_wx = self._read_csv_if_exists(dc / "BestCompare_WilcoxonRank.csv") + + figs: Dict[str, str] = {} + + # Replot: KW p-values bar if possible + if best_kw is not None and not best_kw.empty: + try: + import plotly.express as px # type: ignore + + df = best_kw.copy() + # try to find p-value column + low = {c.lower(): c for c in df.columns} + pcol = None + for cand in ["p-value", "p_value", "pvalue", "p"]: + if cand in low: + pcol = low[cand] + break + if pcol is None: + # if only one column, treat it as p + if df.shape[1] == 1: + pcol = df.columns[0] + if pcol is not None: + df = df[[pcol]].copy() + df[pcol] = pd.to_numeric(df[pcol], errors="coerce") + df = df.dropna().reset_index(drop=True) + df["Metric"] = [f"M{i+1}" for i in range(len(df))] + fig = px.bar(df, x="Metric", y=pcol, title="DatasetComparison: Kruskal-Wallis P-Values") + out = self.paths.figures_dir / "datasetcompare_kw_pvalues.png" + if _safe_plotly_to_png(fig, out): + figs["kw_pvalues"] = _rel_to_reporting(self.paths.reporting_dir, out) + except Exception as e: + logger.warning("Dataset comparisons plot failed: %r", e) + + return { + "present": True, + "tables": { + "best_kw": self._build_plain_table(best_kw, max_rows=200), + "best_mw": self._build_plain_table(best_mw, max_rows=200), + "best_wx": self._build_plain_table(best_wx, max_rows=200), + }, + "figures": figs, + } + + # ---------------------------- + # Render + # ---------------------------- + def _render_html(self, report_data: Dict[str, Any]) -> str: + templates_dir = Path(__file__).with_name("templates") + env = Environment( + loader=FileSystemLoader(str(templates_dir)), + autoescape=select_autoescape(["html", "xml"]), + ) + tpl = env.get_template("report.html.j2") + return tpl.render(**report_data) + + def _write_pdf(self, html_text: str): + base_url = str(self.paths.reporting_dir) + HTML(string=html_text, base_url=base_url).write_pdf(str(self.paths.pdf)) + + def save_runtime(self): + rt_dir = self.exp_root / "runtime" + rt_dir.mkdir(exist_ok=True) + (rt_dir / "runtime_report.txt").write_text( + str(time.time() - (self.job_start_time or time.time())) + ) + + def run(self): + self.job_start_time = time.time() + + datasets = self._list_datasets() + if not datasets: + raise RuntimeError(f"No dataset folders (with CVDatasets/) found under: {self.exp_root}") + + dataset_blocks = [self._collect_dataset_block(ds) for ds in datasets] + dc_block = self._collect_dataset_comparisons_block() + + metadata = { + "Experiment Root": str(self.exp_root), + "Output Path": str(self.exp_root.parent), + "Experiment Name": self.experiment_name, + } + if self.outcome_label: + metadata["Outcome Label"] = self.outcome_label + if self.instance_label: + metadata["Instance Label"] = self.instance_label + if self.outcome_type: + metadata["Outcome Type"] = self.outcome_type + + report_data: Dict[str, Any] = { + "title": self.title, + "experiment_name": self.experiment_name, + "experiment_root": str(self.exp_root), + "generated_at": _now_iso_local(), + "generated_at_epoch": int(time.time()), + "streamline_version": _try_streamline_version(), + "metadata": metadata, + "datasets": dataset_blocks, + "dataset_comparisons": dc_block, + } + + self.paths.data_json.write_text(json.dumps(report_data, indent=2)) + + html_text = self._render_html(report_data) + self.paths.html.write_text(html_text, encoding="utf-8") + + if self.make_pdf: + self._write_pdf(html_text) + + jc = self.exp_root / "jobsCompleted" + jc.mkdir(exist_ok=True) + (jc / "job_reporting.txt").write_text("complete") + + self.save_runtime() + logger.info("Phase 11 reporting complete: %s", self.paths.pdf) diff --git a/streamline/old_versions/p11_reporting_old/reporting_old2.py b/streamline/old_versions/p11_reporting_old/reporting_old2.py new file mode 100644 index 00000000..626b4c6c --- /dev/null +++ b/streamline/old_versions/p11_reporting_old/reporting_old2.py @@ -0,0 +1,493 @@ +from __future__ import annotations + +import logging +import math +import os +import pickle +import re +from datetime import datetime +from pathlib import Path +from typing import Any, Dict, List, Optional, Tuple + +import pandas as pd +from jinja2 import Environment, FileSystemLoader, select_autoescape +from weasyprint import HTML + +from streamline import __version__ as version + + +EXCLUDE_TOP_LEVEL = { + ".DS_Store", + ".idea", + "jobs", + "jobsCompleted", + "logs", + "dask_logs", + "reporting", + "runtime", + "DatasetComparisons", + "metadata.pickle", + "metadata.csv", + # "algInfo.pickle", + "run_params.pickle", +} + +# Keys where "lower is better" (to decide best-cell highlighting) +LOWER_IS_BETTER = { + "FP", "FN", "LR-", + "Max Error", "Mean Absolute Error", "Mean Squared Error", "Median Absolute Error", +} + +# A4-ish defaults (WeasyPrint @page handles margins, but we use these for plot sizing, etc.) +DEFAULT_DPI = 150 + + +def slugify(s: str) -> str: + s = s.strip().lower() + s = re.sub(r"[^a-z0-9]+", "-", s) + return re.sub(r"-+", "-", s).strip("-") + + +def safe_abs_posix(path: Path) -> str: + return str(path.resolve().as_posix()) + + +def list_datasets(experiment_root: Path) -> List[Path]: + datasets: List[Path] = [] + for p in experiment_root.iterdir(): + if not p.is_dir(): + continue + if p.name in EXCLUDE_TOP_LEVEL: + continue + datasets.append(p) + return sorted(datasets, key=lambda x: x.name) + + +def read_csv_df(path: Path, index_col: Optional[int] = None) -> Optional[pd.DataFrame]: + if not path.exists(): + return None + try: + return pd.read_csv(path, index_col=index_col) + except Exception: + return None + + +def read_csv_records(path: Path, limit: Optional[int] = None) -> List[Dict[str, Any]]: + df = read_csv_df(path) + if df is None: + return [] + if limit is not None: + df = df.head(limit) + # ensure 3-decimal formatting consistently in records too + df = format_df_3dp(df) + return df.to_dict(orient="records") + + +def format_df_3dp(df: pd.DataFrame) -> pd.DataFrame: + """Format all numeric columns to 3 decimals (as strings).""" + out = df.copy() + for col in out.columns: + # don't break non-numeric columns + series = pd.to_numeric(out[col], errors="coerce") + if series.notna().any(): + out[col] = [ + "" if pd.isna(v) else f"{float(v):.3f}" + for v in series + ] + return out + + +def compute_best_cells(mean_df: pd.DataFrame) -> Dict[Tuple[int, str], bool]: + """ + Returns mapping (row_index, column_name) -> True if best in column (ties included). + Expects first col = label (model/ensemble name), others numeric. + """ + best_map: Dict[Tuple[int, str], bool] = {} + if mean_df is None or mean_df.empty: + return best_map + + df = mean_df.copy() + for col in df.columns[1:]: + df[col] = pd.to_numeric(df[col], errors="coerce") + + for col in df.columns[1:]: + s = df[col] + if s.dropna().empty: + continue + best_val = s.min(skipna=True) if col in LOWER_IS_BETTER else s.max(skipna=True) + for idx, val in s.items(): + if pd.isna(val): + continue + if float(val) == float(best_val): + best_map[(idx, col)] = True + return best_map + + +def merge_mean_std_tables(mean_df: Optional[pd.DataFrame], std_df: Optional[pd.DataFrame]) -> Optional[pd.DataFrame]: + """ + Builds a table where numeric cells are "mean ± std" (3dp). + If std missing: numeric cells are "mean" (3dp). + """ + if mean_df is None or mean_df.empty: + return None + + m = mean_df.copy() + s = std_df.copy() if (std_df is not None and not std_df.empty) else None + + key = m.columns[0] + if s is None: + # just format mean to 3dp + return format_df_3dp(m) + + # Align by key if possible + if key in s.columns: + s_map = {str(r[key]): r for _, r in s.iterrows()} + rows = [] + for _, r in m.iterrows(): + rr = r.copy() + sid = str(r[key]) + sr = s_map.get(sid) + for col in m.columns[1:]: + mv = pd.to_numeric(r.get(col), errors="coerce") + sv = pd.to_numeric(sr.get(col), errors="coerce") if sr is not None else math.nan + if pd.isna(mv): + rr[col] = "" + elif pd.isna(sv): + rr[col] = f"{float(mv):.3f}" + else: + rr[col] = f"{float(mv):.3f} ± {float(sv):.3f}" + rows.append(rr) + return pd.DataFrame(rows, columns=m.columns) + + # Fallback index alignment + out = m.copy() + for col in out.columns[1:]: + mv = pd.to_numeric(m[col], errors="coerce") + sv = pd.to_numeric(s[col], errors="coerce") if col in s.columns else pd.Series([math.nan] * len(m)) + col_out: List[str] = [] + for i in range(len(out)): + a = mv.iloc[i] if i < len(mv) else math.nan + b = sv.iloc[i] if i < len(sv) else math.nan + if pd.isna(a): + col_out.append("") + elif pd.isna(b): + col_out.append(f"{float(a):.3f}") + else: + col_out.append(f"{float(a):.3f} ± {float(b):.3f}") + out[col] = col_out + return out + + +def _df_to_table_payload( + df: Optional[pd.DataFrame], + best_map: Optional[Dict[Tuple[int, str], bool]] = None, +) -> Dict[str, Any]: + """ + Payload for Jinja rendering: + { + "present": bool, + "columns": [...], + "rows": [{"cells":[{"value":..., "best":bool}, ...]}, ...] + } + """ + if df is None or df.empty: + return {"present": False, "columns": [], "rows": []} + + columns = list(df.columns) + rows: List[Dict[str, Any]] = [] + + for ridx in range(len(df)): + cells: List[Dict[str, Any]] = [] + for cidx, col in enumerate(columns): + val = df.iloc[ridx, cidx] + v = "" if pd.isna(val) else str(val) + is_best = False + if best_map is not None and cidx > 0: + is_best = best_map.get((ridx, col), False) + cells.append({"value": v, "best": bool(is_best)}) + rows.append({"cells": cells}) + + return {"present": True, "columns": columns, "rows": rows} + + +# ----------------------------- +# Plot generation (only if missing) +# ----------------------------- +def ensure_class_counts_plot(exploratory_dir: Path) -> Optional[Path]: + png = exploratory_dir / "ClassCountsBarPlot.png" + if png.exists(): + return png + + csv_path = exploratory_dir / "ClassCounts.csv" + if not csv_path.exists(): + return None + + try: + import matplotlib.pyplot as plt + + df = pd.read_csv(csv_path) + # try common patterns: either columns [Class, Count] or first two columns + if df.shape[1] >= 2: + x = df.iloc[:, 0].astype(str).tolist() + y = pd.to_numeric(df.iloc[:, 1], errors="coerce").fillna(0).tolist() + else: + return None + + plt.figure() + plt.bar(x, y) + plt.xticks(rotation=45, ha="right") + plt.tight_layout() + png.parent.mkdir(parents=True, exist_ok=True) + plt.savefig(png, dpi=DEFAULT_DPI) + plt.close() + return png + except Exception as e: + logging.warning("Failed to generate ClassCountsBarPlot.png: %s", e) + return None + + +def ensure_feature_correlation_plot(exploratory_dir: Path) -> Optional[Path]: + png = exploratory_dir / "FeatureCorrelations.png" + if png.exists(): + return png + + csv_path = exploratory_dir / "FeatureCorrelations.csv" + if not csv_path.exists(): + return None + + try: + import matplotlib.pyplot as plt + import numpy as np + + df = pd.read_csv(csv_path, index_col=0) + mat = df.values.astype(float) + plt.figure() + plt.imshow(mat, aspect="auto") + plt.colorbar() + # keep labels small; big matrices will be unreadable anyway + plt.xticks([]) + plt.yticks([]) + plt.tight_layout() + png.parent.mkdir(parents=True, exist_ok=True) + plt.savefig(png, dpi=DEFAULT_DPI) + plt.close() + return png + except Exception as e: + logging.warning("Failed to generate FeatureCorrelations.png: %s", e) + return None + + +class ReportPhaseJob: + """ + Generates a multi-dataset STREAMLINE PDF report using Jinja2 + WeasyPrint. + + - Corrects filenames to match your tree + - Adds model + ensemble performance tables (mean±std, median) + - Applies 3dp formatting everywhere + - Highlights best cells like old FPDF + - Improves pagination via CSS in template + - Generates a couple plots from CSV if missing + """ + + def __init__( + self, + output_path: Optional[str] = None, + experiment_name: Optional[str] = None, + experiment_path: Optional[str] = None, + training: bool = True, + make_pdf: bool = True, + template_name: str = "report.html.j2", + ): + if experiment_path: + self.experiment_root = Path(experiment_path) + self.experiment_name = self.experiment_root.name + else: + if output_path is None or experiment_name is None: + raise ValueError("Provide either experiment_path OR (output_path and experiment_name).") + self.experiment_root = Path(output_path) / str(experiment_name) + self.experiment_name = str(experiment_name) + + self.training = bool(training) + self.make_pdf = bool(make_pdf) + + self.template_dir = Path(__file__).parent / "templates" + self.template_name = template_name + + self.metadata = self._load_pickle(self.experiment_root / "metadata.pickle") or {} + # self.alg_info = self._load_pickle(self.experiment_root / "algInfo.pickle") or {} + self.outcome_type = self.metadata.get("Outcome Type", "Unknown") + + def _load_pickle(self, path: Path) -> Any: + if not path.exists(): + return None + try: + with open(path, "rb") as f: + return pickle.load(f) + except Exception as e: + logging.warning("Failed to load pickle %s: %s", path, e) + return None + + def run(self): + self.job() + + def job(self): + logging.info("Starting ReportPhaseJob for %s", self.experiment_root) + + generated_at = datetime.now() + + ds_dirs = list_datasets(self.experiment_root) + datasets: List[Dict[str, Any]] = [] + for ds in ds_dirs: + datasets.append(self._build_dataset_section(ds)) + + comparisons = self._build_dataset_comparisons_section() + + env = Environment( + loader=FileSystemLoader(str(self.template_dir)), + autoescape=select_autoescape(["html", "xml"]), + ) + template = env.get_template(self.template_name) + + html_str = template.render( + title="STREAMLINE Evaluation Report", + experiment_name=self.experiment_name, + experiment_root=safe_abs_posix(self.experiment_root), + generated_at=generated_at.strftime("%Y-%m-%d %H:%M:%S"), + streamline_version=version, + training=self.training, + outcome_type=self.outcome_type, + metadata=self.metadata, + # alg_info=self.alg_info, + datasets=datasets, + dataset_comparisons=comparisons, + ) + + out_dir = self.experiment_root / "reporting" + out_dir.mkdir(parents=True, exist_ok=True) + out_pdf = out_dir / f"{self.experiment_name}_STREAMLINE_Report.pdf" + + if self.make_pdf: + HTML(string=html_str, base_url=str(self.experiment_root.resolve().as_uri())).write_pdf(str(out_pdf)) + logging.info("Wrote PDF: %s", out_pdf) + + # completion marker + try: + jc = self.experiment_root / "jobsCompleted" + jc.mkdir(exist_ok=True, parents=True) + (jc / "job_p11_reporting.txt").write_text("complete") + except Exception: + pass + + def _build_dataset_section(self, dataset_dir: Path) -> Dict[str, Any]: + ds_name = dataset_dir.name + ds_slug = slugify(ds_name) + + exploratory_dir = dataset_dir / "exploratory" + model_eval_dir = dataset_dir / "model_evaluation" + ensemble_eval_dir = dataset_dir / "ensemble_evaluation" + + # generate a couple plots from CSV if missing + if exploratory_dir.exists(): + ensure_class_counts_plot(exploratory_dir) + ensure_feature_correlation_plot(exploratory_dir) + + figures: Dict[str, Optional[str]] = {} + + # Exploratory + figures["class_counts"] = safe_abs_posix(exploratory_dir / "ClassCountsBarPlot.png") if (exploratory_dir / "ClassCountsBarPlot.png").exists() else None + figures["feature_correlations"] = safe_abs_posix(exploratory_dir / "FeatureCorrelations.png") if (exploratory_dir / "FeatureCorrelations.png").exists() else None + + # Model evaluation summaries + figures["summary_roc"] = safe_abs_posix(model_eval_dir / "Summary_ROC.png") if (model_eval_dir / "Summary_ROC.png").exists() else None + figures["summary_prc"] = safe_abs_posix(model_eval_dir / "Summary_PRC.png") if (model_eval_dir / "Summary_PRC.png").exists() else None + + mb = model_eval_dir / "metricBoxplots" + figures["compare_roc_auc"] = safe_abs_posix(mb / "Compare_ROC AUC.png") if (mb / "Compare_ROC AUC.png").exists() else None + figures["compare_prc_auc"] = safe_abs_posix(mb / "Compare_PRC AUC.png") if (mb / "Compare_PRC AUC.png").exists() else None + + # Ensemble evaluation summaries (your tree: Summary_*_ensembles.png) + figures["summary_roc_ensembles"] = safe_abs_posix(ensemble_eval_dir / "Summary_ROC_ensembles.png") if (ensemble_eval_dir / "Summary_ROC_ensembles.png").exists() else None + figures["summary_prc_ensembles"] = safe_abs_posix(ensemble_eval_dir / "Summary_PRC_ensembles.png") if (ensemble_eval_dir / "Summary_PRC_ensembles.png").exists() else None + + # Feature importance plots (your tree uses: feature_importance/multisurf and feature_importance/mutualinformation) + fi_mi = dataset_dir / "feature_importance" / "mutualinformation" / "TopAverageScores.png" + fi_ms = dataset_dir / "feature_importance" / "multisurf" / "TopAverageScores.png" + figures["fi_mutualinformation"] = safe_abs_posix(fi_mi) if fi_mi.exists() else None + figures["fi_multisurf"] = safe_abs_posix(fi_ms) if fi_ms.exists() else None + + # Tables + tables: Dict[str, Any] = {} + tables["data_process_summary"] = read_csv_records(exploratory_dir / "DataProcessSummary.csv") + tables["univariate_top10"] = read_csv_records(exploratory_dir / "univariate_analyses" / "Univariate_Significance.csv", limit=10) + tables["informative_feature_summary"] = read_csv_records(dataset_dir / "feature_selection" / "InformativeFeatureSummary.csv") + tables["runtimes"] = read_csv_records(dataset_dir / "runtimes.csv") + + # Performance tables (models + ensembles): mean±std together; median separate + perf: Dict[str, Any] = {} + + # Models + m_mean = read_csv_df(model_eval_dir / "Summary_performance_mean.csv", index_col=0) + m_median = read_csv_df(model_eval_dir / "Summary_performance_median.csv", index_col=0) + m_std = read_csv_df(model_eval_dir / "Summary_performance_std.csv", index_col=0) + + # reset to include algorithm column again + if m_mean is not None: + m_mean = m_mean.reset_index() + if m_median is not None: + m_median = m_median.reset_index() + if m_std is not None: + m_std = m_std.reset_index() + + m_best_map = compute_best_cells(m_mean) if m_mean is not None else {} + m_mean_std = merge_mean_std_tables(m_mean, m_std) + if m_median is not None: + m_median = format_df_3dp(m_median) + + perf["models_mean_std"] = _df_to_table_payload(m_mean_std, best_map=m_best_map) + perf["models_median"] = _df_to_table_payload(m_median, best_map=None) + + # Ensembles + e_mean = read_csv_df(ensemble_eval_dir / "Ensembles_performance_mean.csv", index_col=0) + e_median = read_csv_df(ensemble_eval_dir / "Ensembles_performance_median.csv", index_col=0) + e_std = read_csv_df(ensemble_eval_dir / "Ensembles_performance_std.csv", index_col=0) + + if e_mean is not None: + e_mean = e_mean.reset_index() + if e_median is not None: + e_median = e_median.reset_index() + if e_std is not None: + e_std = e_std.reset_index() + + e_best_map = compute_best_cells(e_mean) if e_mean is not None else {} + e_mean_std = merge_mean_std_tables(e_mean, e_std) + if e_median is not None: + e_median = format_df_3dp(e_median) + + perf["ensembles_mean_std"] = _df_to_table_payload(e_mean_std, best_map=e_best_map) + perf["ensembles_median"] = _df_to_table_payload(e_median, best_map=None) + + return { + "dataset_name": ds_name, + "dataset_slug": ds_slug, + "dataset_dir": safe_abs_posix(dataset_dir), + "figures": figures, + "tables": tables, + "perf": perf, + } + + def _build_dataset_comparisons_section(self) -> Dict[str, Any]: + dc_dir = self.experiment_root / "DatasetComparisons" + if not dc_dir.exists(): + return {"present": False, "figures": {}, "tables": {}} + + figures: Dict[str, Optional[str]] = {} + tables: Dict[str, Any] = {} + + box_dir = dc_dir / "dataCompBoxplots" + figures["allmodels_roc_auc"] = safe_abs_posix(box_dir / "DataCompareAllModels_ROC AUC.png") if (box_dir / "DataCompareAllModels_ROC AUC.png").exists() else None + figures["allmodels_prc_auc"] = safe_abs_posix(box_dir / "DataCompareAllModels_PRC AUC.png") if (box_dir / "DataCompareAllModels_PRC AUC.png").exists() else None + + # Table(s) + tables["best_kw"] = read_csv_records(dc_dir / "BestCompare_KruskalWallis.csv") + + return {"present": True, "figures": figures, "tables": tables} diff --git a/streamline/old_versions/p11_reporting_old/templates/report.html copy.j2 b/streamline/old_versions/p11_reporting_old/templates/report.html copy.j2 new file mode 100644 index 00000000..202c0ede --- /dev/null +++ b/streamline/old_versions/p11_reporting_old/templates/report.html copy.j2 @@ -0,0 +1,403 @@ + + + + + {{ title }} - {{ experiment_name }} + + + + + +
+

STREAMLINE Evaluation Report

+
+ Experiment: {{ experiment_name }}
+ Generated at: {{ generated_at }}
+ Report Version: {{ streamline_version }} +
+
+ +
+
Metadata
+ + + + {% for k, v in metadata.items() %} + + + + + {% endfor %} + +
KeyValue
{{ k }}{{ v }}
+
+ + {% for ds in datasets %} +
+ +
+

Dataset: {{ ds.dataset_name }}

+
{{ ds.dataset_dir }}
+
+ + +
+
Exploratory + Performance Summary (Mosaic)
+ + + + + + + + + + + +
+
Class Balance
+
+ {% if ds.figures.class_balance %} + + {% else %} +
ClassCounts.csv missing or could not be plotted.
+ {% endif %} +
+ 		+
Missingness (Top 25)
+
+ {% if ds.figures.missingness %} + + {% else %} +
DataMissingness.csv missing or could not be plotted.
+ {% endif %} +
+
+
Models: Mean Performance
+
+ {% if ds.figures.models_mean_bar %} + + {% else %} +
Summary_performance_mean.csv missing or could not be plotted.
+ {% endif %} +
+ 		+
Models: CV Distribution
+
+ {% if ds.figures.models_cv_box %} + + {% else %} +
metrics_by_cv not found or could not be plotted.
+ {% endif %} +
+
+
+ + +
+
Model Performance
+ + {% if ds.perf.models_mean_std.present %} +
Mean ± Std
+ + + + {% for c in ds.perf.models_mean_std.columns %} + + {% endfor %} + + + + {% for row in ds.perf.models_mean_std.rows %} + + {% for cell in row.cells %} + + {% endfor %} + + {% endfor %} + +
{{ c }}
{{ cell.value }}
+ {% else %} +
Summary_performance_mean/std.csv not found.
+ {% endif %} + +
+ + {% if ds.perf.models_median.present %} +
Median
+ + + + {% for c in ds.perf.models_median.columns %} + + {% endfor %} + + + + {% for row in ds.perf.models_median.rows %} + + {% for cell in row %} + + {% endfor %} + + {% endfor %} + +
{{ c }}
{{ cell }}
+ {% else %} +
Summary_performance_median.csv not found.
+ {% endif %} +
+ + +
+
Model Curves (Side-by-Side)
+ + + + + + +
+
ROC Overlay
+
+ {% if ds.figures.models_roc_overlay %} + + {% else %} +
curves_by_cv/*_roc.json missing or could not be plotted.
+ {% endif %} +
+ 		+
PRC Overlay
+
+ {% if ds.figures.models_prc_overlay %} + + {% else %} +
curves_by_cv/*_prc.json missing or could not be plotted.
+ {% endif %} +
+
+
+ + +
+
Feature Importance
+
+ {% if ds.figures.fi_top20 %} + + {% else %} +
No *_FI.csv found under model_evaluation/feature_importance/.
+ {% endif %} +
+
+ + +
+
Univariate Significance (Top 10)
+ {% if ds.tables.univariate_top10.present %} + + + + {% for col in ds.tables.univariate_top10.columns %} + + {% endfor %} + + + + {% for row in ds.tables.univariate_top10.rows %} + + {% for cell in row %} + + {% endfor %} + + {% endfor %} + +
{{ col }}
{{ cell }}
+ {% else %} +
Univariate_Significance.csv not found.
+ {% endif %} +
+ + +
+
Informative Feature Summary
+ {% if ds.tables.informative_feature_summary.present %} + + + + {% for col in ds.tables.informative_feature_summary.columns %} + + {% endfor %} + + + + {% for row in ds.tables.informative_feature_summary.rows %} + + {% for cell in row %} + + {% endfor %} + + {% endfor %} + +
{{ col }}
{{ cell }}
+ {% else %} +
feature_selection/InformativeFeatureSummary.csv not found.
+ {% endif %} +
+ + +
+
Runtime Summary (runtimes.csv)
+ {% if ds.tables.runtimes.present %} + + + + {% for col in ds.tables.runtimes.columns %} + + {% endfor %} + + + + {% for row in ds.tables.runtimes.rows %} + + {% for cell in row %} + + {% endfor %} + + {% endfor %} + +
{{ col }}
{{ cell }}
+ {% else %} +
runtimes.csv not found.
+ {% endif %} +
+ + {% endfor %} + + {% if dataset_comparisons.present %} +
+ +
+

Dataset Comparisons

+
+ +
+
Kruskal-Wallis Summary
+
+ {% if dataset_comparisons.figures.kw_pvalues %} + + {% else %} +
Could not plot KW p-values (BestCompare_KruskalWallis.csv).
+ {% endif %} +
+
+ +
+
BestCompare_KruskalWallis.csv
+ {% if dataset_comparisons.tables.best_kw.present %} + + + + {% for col in dataset_comparisons.tables.best_kw.columns %} + + {% endfor %} + + + + {% for row in dataset_comparisons.tables.best_kw.rows %} + + {% for cell in row %} + + {% endfor %} + + {% endfor %} + +
{{ col }}
{{ cell }}
+ {% else %} +
BestCompare_KruskalWallis.csv not found.
+ {% endif %} +
+ {% endif %} + + + diff --git a/streamline/old_versions/p11_reporting_old/templates/report.html.j2 b/streamline/old_versions/p11_reporting_old/templates/report.html.j2 new file mode 100644 index 00000000..bac5bcfb --- /dev/null +++ b/streamline/old_versions/p11_reporting_old/templates/report.html.j2 @@ -0,0 +1,447 @@ + + + + + {{ title }} - {{ experiment_name }} + + + + + + + +
+ STREAMLINE Evaluation Report +
+ +
+
+ Experiment: {{ experiment_name }}
+ Generated at: {{ generated_at }}
+ Report Version: {{ streamline_version }} +
+
+ + +
+
Metadata
+ + + + {% for k, v in metadata.items() %} + + + + + {% endfor %} + +
KeyValue
{{ k }}{{ v }}
+
+ + {% for ds in datasets %} +
+ +
+ Dataset: {{ ds.dataset_name }} +
+ +
+
{{ ds.dataset_dir }}
+
+ + +
+
Exploratory + Performance Summary (Mosaic)
+ + + + + + + + + + + +
+
Class Balance
+
+ {% if ds.figures.class_balance %} + + {% else %} +
ClassCounts.csv missing or could not be plotted.
+ {% endif %} +
+ 		+
Missingness (Top 25)
+
+ {% if ds.figures.missingness %} + + {% else %} +
DataMissingness.csv missing or could not be plotted.
+ {% endif %} +
+
+
Models: Mean Performance
+
+ {% if ds.figures.models_mean_bar %} + + {% else %} +
Summary_performance_mean.csv missing or could not be plotted.
+ {% endif %} +
+ 		+
Models: CV Distribution
+
+ {% if ds.figures.models_cv_box %} + + {% else %} +
metrics_by_cv not found or could not be plotted.
+ {% endif %} +
+
+
+ + +
+
Model Performance
+ + {% if ds.perf.models_mean_std.present %} +
Mean ± Std
+ + + + {% for c in ds.perf.models_mean_std.columns %} + + {% endfor %} + + + + {% for row in ds.perf.models_mean_std.rows %} + + {% for cell in row.cells %} + + {% endfor %} + + {% endfor %} + +
{{ c }}
{{ cell.value }}
+ {% else %} +
Summary_performance_mean/std.csv not found.
+ {% endif %} + +
+ + {% if ds.perf.models_median.present %} +
Median
+ + + + {% for c in ds.perf.models_median.columns %} + + {% endfor %} + + + + {% for row in ds.perf.models_median.rows %} + + {% for cell in row %} + + {% endfor %} + + {% endfor %} + +
{{ c }}
{{ cell }}
+ {% else %} +
Summary_performance_median.csv not found.
+ {% endif %} +
+ + +
+
Model Curves (Side-by-Side)
+ + + + + + +
+
ROC Overlay
+
+ {% if ds.figures.models_roc_overlay %} + + {% else %} +
curves_by_cv/*_roc.json missing or could not be plotted.
+ {% endif %} +
+ 		+
PRC Overlay
+
+ {% if ds.figures.models_prc_overlay %} + + {% else %} +
curves_by_cv/*_prc.json missing or could not be plotted.
+ {% endif %} +
+
+
+ + +
+
Feature Importance
+
+ {% if ds.figures.fi_top20 %} + + {% else %} +
No *_FI.csv found under model_evaluation/feature_importance/.
+ {% endif %} +
+
+ + +
+
Univariate Significance (Top 10)
+ {% if ds.tables.univariate_top10.present %} + + + + {% for col in ds.tables.univariate_top10.columns %} + + {% endfor %} + + + + {% for row in ds.tables.univariate_top10.rows %} + + {% for cell in row %} + + {% endfor %} + + {% endfor %} + +
{{ col }}
{{ cell }}
+ {% else %} +
Univariate_Significance.csv not found.
+ {% endif %} +
+ + +
+
Informative Feature Summary
+ {% if ds.tables.informative_feature_summary.present %} + + + + {% for col in ds.tables.informative_feature_summary.columns %} + + {% endfor %} + + + + {% for row in ds.tables.informative_feature_summary.rows %} + + {% for cell in row %} + + {% endfor %} + + {% endfor %} + +
{{ col }}
{{ cell }}
+ {% else %} +
feature_selection/InformativeFeatureSummary.csv not found.
+ {% endif %} +
+ + +
+
Runtime Summary (runtimes.csv)
+ {% if ds.tables.runtimes.present %} + + + + {% for col in ds.tables.runtimes.columns %} + + {% endfor %} + + + + {% for row in ds.tables.runtimes.rows %} + + {% for cell in row %} + + {% endfor %} + + {% endfor %} + +
{{ col }}
{{ cell }}
+ {% else %} +
runtimes.csv not found.
+ {% endif %} +
+ + {% endfor %} + + {% if dataset_comparisons.present %} +
+ +
+ Dataset Comparisons +
+ +
+
Kruskal-Wallis Summary
+
+ {% if dataset_comparisons.figures.kw_pvalues %} + + {% else %} +
Could not plot KW p-values (BestCompare_KruskalWallis.csv).
+ {% endif %} +
+
+ +
+
BestCompare_KruskalWallis.csv
+ {% if dataset_comparisons.tables.best_kw.present %} + + + + {% for col in dataset_comparisons.tables.best_kw.columns %} + + {% endfor %} + + + + {% for row in dataset_comparisons.tables.best_kw.rows %} + + {% for cell in row %} + + {% endfor %} + + {% endfor %} + +
{{ col }}
{{ cell }}
+ {% else %} +
BestCompare_KruskalWallis.csv not found.
+ {% endif %} +
+ {% endif %} + + + diff --git a/streamline/old_versions/p11_reporting_old/templates/report.html.j2.old b/streamline/old_versions/p11_reporting_old/templates/report.html.j2.old new file mode 100644 index 00000000..c6b1f88f --- /dev/null +++ b/streamline/old_versions/p11_reporting_old/templates/report.html.j2.old @@ -0,0 +1,273 @@ + + + + + {{ title }} + + + + + +

{{ title }}

+
+ Experiment: {{ experiment_name }}
+ Root: {{ experiment_root }}
+ Generated: {{ generated_at_epoch }} +
+ +
+

Contents

+
    +
  1. Datasets
    2. +
  2. Dataset Comparisons
    3. +
+
    + {% for ds in datasets %} +
  1. {{ ds.dataset_name }}
    2. + {% endfor %} +
+
+ +
+ + +

Datasets

+
Each dataset section summarizes key artifacts from all phases. Figures are regenerated (Plotly→PNG) for this report.
+ + {% for ds in datasets %} +
+

{{ ds.dataset_name }}

+
{{ ds.paths.dataset_dir }}
+ +
+ +
+

Model Performance

+ + {% if ds.figures.get('models_mean_Balanced Accuracy') %} + + {% elif ds.figures.get('models_mean_ROC AUC') %} + + {% elif ds.figures.get('models_mean_PRC AUC') %} + + {% elif ds.figures.get('models_mean_Accuracy') %} + + {% else %} +
No model summary figure available.
+ {% endif %} + + {% if ds.figures.get('models_cv_Balanced Accuracy') %} +
+ + {% elif ds.figures.get('models_cv_ROC AUC') %} +
+ + {% elif ds.figures.get('models_cv_PRC AUC') %} +
+ + {% endif %} +
+ +
+

Ensemble Performance (if present)

+ + {% if ds.figures.get('ensembles_mean_Balanced Accuracy') %} + + {% elif ds.figures.get('ensembles_mean_ROC AUC') %} + + {% elif ds.figures.get('ensembles_mean_PRC AUC') %} + + {% elif ds.figures.get('ensembles_mean_Accuracy') %} + + {% else %} +
No ensembles detected or no ensemble summary figure available.
+ {% endif %} + + {% if ds.figures.get('ensembles_cv_Balanced Accuracy') %} +
+ + {% elif ds.figures.get('ensembles_cv_ROC AUC') %} +
+ + {% elif ds.figures.get('ensembles_cv_PRC AUC') %} +
+ + {% endif %} +
+ +
+ +
+
+

Curves

+ {% if ds.figures.get('models_roc_overlay') %} +

Models ROC

+ + {% endif %} + {% if ds.figures.get('models_prc_overlay') %} +

Models PRC

+ + {% endif %} + {% if ds.figures.get('ensembles_roc_overlay') %} +

Ensembles ROC

+ + {% endif %} + {% if ds.figures.get('ensembles_prc_overlay') %} +

Ensembles PRC

+ + {% endif %} + {% if not ds.figures.get('models_roc_overlay') + and not ds.figures.get('models_prc_overlay') + and not ds.figures.get('ensembles_roc_overlay') + and not ds.figures.get('ensembles_prc_overlay') %} +
No curve JSONs found for models/ensembles.
+ {% endif %} +
+ +
+

Feature Importance (sample)

+ {% if ds.figures.get('fi_top20') %} + + {% else %} +
No FI files found under model_evaluation/feature_importance.
+ {% endif %} +
+
+ +
+

Key Tables

+ + {% if ds.tables.get('class_counts') %} +

Class Counts

+ + + {% for k in ds.tables.get('class_counts')[0].keys() %} + + {% endfor %} + + {% for row in ds.tables.get('class_counts') %} + + {% for v in row.values() %} + + {% endfor %} + + {% endfor %} +
{{ k }}
{{ v }}
+ {% endif %} + + {% if ds.tables.get('feature_selection') %} +

Informative Feature Summary

+ + + {% for k in ds.tables.get('feature_selection')[0].keys() %} + + {% endfor %} + + {% for row in ds.tables.get('feature_selection')[:20] %} + + {% for v in row.values() %} + + {% endfor %} + + {% endfor %} +
{{ k }}
{{ v }}
+
Showing first 20 rows.
+ {% endif %} +
+ + {% endfor %} + + +
+

Dataset Comparisons

+ + {% if dataset_comparisons.present %} + {% if dataset_comparisons.figures.get('best_kw_pvalues') %} +
+

Best-Model Kruskal-Wallis P-Values

+ +
+ {% endif %} + + {% if dataset_comparisons.tables.get('best_kw') %} +
+

BestCompare_KruskalWallis.csv

+ + + {% for k in dataset_comparisons.tables.get('best_kw')[0].keys() %} + + {% endfor %} + + {% for row in dataset_comparisons.tables.get('best_kw') %} + + {% for v in row.values() %} + + {% endfor %} + + {% endfor %} +
{{ k }}
{{ v }}
+
+ {% endif %} + {% else %} +
No DatasetComparisons/ folder found.
+ {% endif %} + + + diff --git a/streamline/old_versions/p11_reporting_old/templates/report.html.j2.old2 b/streamline/old_versions/p11_reporting_old/templates/report.html.j2.old2 new file mode 100644 index 00000000..8aad8060 --- /dev/null +++ b/streamline/old_versions/p11_reporting_old/templates/report.html.j2.old2 @@ -0,0 +1,484 @@ + + + + + {{ title }} - {{ experiment_name }} + + + + + + +
+

STREAMLINE Evaluation Report

+
+ Experiment: {{ experiment_name }}
+ Generated at: {{ generated_at }}
+ Mode: {{ "Training" if training else "Replication/Testing" }}
+ Outcome Type: {{ outcome_type }} +
+
+ +
+
Metadata
+ + + + {% for k, v in metadata.items() %} + + + + + {% endfor %} + +
KeyValue
{{ k }}{{ v }}
+
+ + {% if alg_info %} +
+
Algorithm Info
+ + + + {% for k in alg_info.keys()|sort %} + + + + + {% endfor %} + +
AlgorithmEnabled
{{ k }}{{ alg_info[k][0] }}
+
+ {% endif %} + + + {% for ds in datasets %} +
+ +
+

Dataset: {{ ds.dataset_name }}

+
{{ ds.dataset_dir }}
+
+ +
+
+
Exploratory
+ {% if ds.figures.class_counts %} +
Class Balance (Processed)
+ + {% else %} +
ClassCountsBarPlot.png not found.
+ {% endif %} + +
+ + {% if ds.figures.feature_correlations %} +
Feature Correlations
+ + {% else %} +
FeatureCorrelations.png not found.
+ {% endif %} +
+ +
+
Data Processing Summary
+ {% if ds.tables.data_process_summary and ds.tables.data_process_summary|length > 0 %} + + + + {% for col in ds.tables.data_process_summary[0].keys() %} + + {% endfor %} + + + + {% for r in ds.tables.data_process_summary %} + + {% for col, val in r.items() %} + + {% endfor %} + + {% endfor %} + +
{{ col }}
{{ val }}
+ {% else %} +
DataProcessSummary.csv not found or empty.
+ {% endif %} +
+
+ +
+
Univariate Significance (Top 10)
+ {% if ds.tables.univariate_top10 and ds.tables.univariate_top10|length > 0 %} + + + + {% for col in ds.tables.univariate_top10[0].keys() %} + + {% endfor %} + + + + {% for r in ds.tables.univariate_top10 %} + + {% for col, val in r.items() %} + + {% endfor %} + + {% endfor %} + +
{{ col }}
{{ val }}
+ {% else %} +
Univariate_Significance.csv not found.
+ {% endif %} +
+ +
+
Model Performance
+ + {% if ds.perf.models_mean_std.present %} +
Mean ± Std
+ + + + {% for c in ds.perf.models_mean_std.columns %} + + {% endfor %} + + + + {% for row in ds.perf.models_mean_std.rows %} + + {% for cell in row.cells %} + + {% endfor %} + + {% endfor %} + +
{{ c }}
{{ cell.value }}
+ {% else %} +
Summary_performance_mean/std.csv not found.
+ {% endif %} + +
+ + {% if ds.perf.models_median.present %} +
Median
+ + + + {% for c in ds.perf.models_median.columns %} + + {% endfor %} + + + + {% for row in ds.perf.models_median.rows %} + + {% for cell in row.cells %} + + {% endfor %} + + {% endfor %} + +
{{ c }}
{{ cell.value }}
+ {% else %} +
Summary_performance_median.csv not found.
+ {% endif %} +
+ +
+
Ensemble Performance
+ + {% if ds.perf.ensembles_mean_std.present %} +
Mean ± Std
+ + + + {% for c in ds.perf.ensembles_mean_std.columns %} + + {% endfor %} + + + + {% for row in ds.perf.ensembles_mean_std.rows %} + + {% for cell in row.cells %} + + {% endfor %} + + {% endfor %} + +
{{ c }}
{{ cell.value }}
+ {% else %} +
Ensembles_performance_mean/std.csv not found.
+ {% endif %} + +
+ + {% if ds.perf.ensembles_median.present %} +
Median
+ + + + {% for c in ds.perf.ensembles_median.columns %} + + {% endfor %} + + + + {% for row in ds.perf.ensembles_median.rows %} + + {% for cell in row.cells %} + + {% endfor %} + + {% endfor %} + +
{{ c }}
{{ cell.value }}
+ {% else %} +
Ensembles_performance_median.csv not found.
+ {% endif %} +
+ +
+
+
Model Summary Curves
+ {% if ds.figures.summary_roc %} +
ROC (All Models)
+ + {% else %} +
Summary_ROC.png not found.
+ {% endif %} +
+ {% if ds.figures.summary_prc %} +
PRC (All Models)
+ + {% else %} +
Summary_PRC.png not found.
+ {% endif %} +
+ +
+
Ensemble Summary Curves
+ {% if ds.figures.summary_roc_ensembles %} +
ROC (Ensembles)
+ + {% else %} +
Summary_ROC_ensembles.png not found.
+ {% endif %} +
+ {% if ds.figures.summary_prc_ensembles %} +
PRC (Ensembles)
+ + {% else %} +
Summary_PRC_ensembles.png not found.
+ {% endif %} +
+
+ +
+
Informative Feature Summary
+ {% if ds.tables.informative_feature_summary and ds.tables.informative_feature_summary|length > 0 %} + + + + {% for col in ds.tables.informative_feature_summary[0].keys() %} + + {% endfor %} + + + + {% for r in ds.tables.informative_feature_summary %} + + {% for col, val in r.items() %} + + {% endfor %} + + {% endfor %} + +
{{ col }}
{{ val }}
+ {% else %} +
feature_selection/InformativeFeatureSummary.csv not found.
+ {% endif %} +
+ +
+
+
Feature Importance (Mutual Information)
+ {% if ds.figures.fi_mutualinformation %} + + {% else %} +
feature_importance/mutualinformation/TopAverageScores.png not found.
+ {% endif %} +
+
+
Feature Importance (MultiSURF)
+ {% if ds.figures.fi_multisurf %} + + {% else %} +
feature_importance/multisurf/TopAverageScores.png not found.
+ {% endif %} +
+
+ +
+
Runtime Summary (runtimes.csv)
+ {% if ds.tables.runtimes and ds.tables.runtimes|length > 0 %} + + + + {% for col in ds.tables.runtimes[0].keys() %} + + {% endfor %} + + + + {% for r in ds.tables.runtimes %} + + {% for col, val in r.items() %} + + {% endfor %} + + {% endfor %} + +
{{ col }}
{{ val }}
+ {% else %} +
runtimes.csv not found.
+ {% endif %} +
+ + {% endfor %} + + + {% if dataset_comparisons.present %} +
+ +
+

Compare ML Performance Across Datasets

+
+ +
+
+ {% if dataset_comparisons.figures.allmodels_roc_auc %} +
All Models: ROC AUC
+ + {% else %} +
DataCompareAllModels_ROC AUC.png not found.
+ {% endif %} +
+
+ {% if dataset_comparisons.figures.allmodels_prc_auc %} +
All Models: PRC AUC
+ + {% else %} +
DataCompareAllModels_PRC AUC.png not found.
+ {% endif %} +
+
+ +
+
BestCompare_KruskalWallis.csv
+ {% if dataset_comparisons.tables.best_kw and dataset_comparisons.tables.best_kw|length > 0 %} + + + + {% for col in dataset_comparisons.tables.best_kw[0].keys() %} + + {% endfor %} + + + + {% for r in dataset_comparisons.tables.best_kw %} + + {% for col, val in r.items() %} + + {% endfor %} + + {% endfor %} + +
{{ col }}
{{ val }}
+ {% else %} +
BestCompare_KruskalWallis.csv not found.
+ {% endif %} +
+ {% endif %} + + + diff --git a/streamline/old_versions/p11_reporting_old/utils/pdf_layout.py b/streamline/old_versions/p11_reporting_old/utils/pdf_layout.py new file mode 100644 index 00000000..3af49e03 --- /dev/null +++ b/streamline/old_versions/p11_reporting_old/utils/pdf_layout.py @@ -0,0 +1,162 @@ +from __future__ import annotations + +from dataclasses import dataclass +from pathlib import Path +from typing import Iterable, Sequence + +from reportlab.lib.pagesizes import letter +from reportlab.lib.units import inch +from reportlab.lib.utils import ImageReader +from reportlab.pdfgen import canvas + + +@dataclass(frozen=True) +class GridSpec: + rows: int + cols: int + hgap: float = 0.12 * inch + vgap: float = 0.12 * inch + cell_pad: float = 0.06 * inch + + +def _fit_into(w: float, h: float, max_w: float, max_h: float) -> tuple[float, float]: + """Scale (w,h) to fit within (max_w,max_h) preserving aspect ratio.""" + if w <= 0 or h <= 0: + return max_w, max_h + s = min(max_w / w, max_h / h) + return w * s, h * s + + +def _draw_box(c: canvas.Canvas, x: float, y: float, w: float, h: float, lw: float = 1.0) -> None: + c.setLineWidth(lw) + c.rect(x, y, w, h, stroke=1, fill=0) + + +def _draw_header( + c: canvas.Canvas, + title: str, + subtitle: str | None = None, + left: float = 0.75 * inch, + top: float = 10.75 * inch, + width: float = 7.0 * inch, +) -> float: + """ + Draw a boxed header similar to the attached report. + Returns the y coordinate below the header block. + """ + header_h = 0.55 * inch if subtitle else 0.40 * inch + y = top - header_h + + _draw_box(c, left, y, width, header_h, lw=1.2) + + c.setFont("Helvetica-Bold", 11) + c.drawString(left + 0.12 * inch, y + header_h - 0.26 * inch, title) + + if subtitle: + c.setFont("Helvetica", 9) + c.drawString(left + 0.12 * inch, y + 0.12 * inch, subtitle) + + return y - 0.15 * inch + + +def draw_image_grid_page( + c: canvas.Canvas, + title: str, + images: Sequence[tuple[str, Path]], + gridspec: GridSpec, + subtitle: str | None = None, + page_size=letter, + footer: str | None = "Generated with STREAMLINE", +) -> None: + """ + Draw a single page with: + - boxed header + - a grid of images with optional captions + - optional footer + """ + page_w, page_h = page_size + + margin_l = 0.75 * inch + margin_r = 0.75 * inch + margin_b = 0.65 * inch + top = page_h - 0.65 * inch + content_w = page_w - margin_l - margin_r + + y0 = _draw_header(c, title=title, subtitle=subtitle, left=margin_l, top=top, width=content_w) + + # Grid bounding box (leave room for footer) + footer_h = 0.28 * inch if footer else 0.0 + grid_top = y0 + grid_bottom = margin_b + footer_h + grid_h = grid_top - grid_bottom + + cell_w = (content_w - (gridspec.cols - 1) * gridspec.hgap) / gridspec.cols + cell_h = (grid_h - (gridspec.rows - 1) * gridspec.vgap) / gridspec.rows + + # Place images in row-major order + for idx, (caption, img_path) in enumerate(images[: gridspec.rows * gridspec.cols]): + r = idx // gridspec.cols + col = idx % gridspec.cols + + x = margin_l + col * (cell_w + gridspec.hgap) + y = grid_top - (r + 1) * cell_h - r * gridspec.vgap + + # cell outline (matches “boxed sections” vibe) + _draw_box(c, x, y, cell_w, cell_h, lw=1.0) + + # reserve a small caption strip at top of each cell + cap_h = 0.22 * inch if caption else 0.0 + if caption: + c.setFont("Helvetica-Bold", 9) + c.drawString(x + gridspec.cell_pad, y + cell_h - cap_h + 0.06 * inch, caption) + + # image area + img_x = x + gridspec.cell_pad + img_y = y + gridspec.cell_pad + img_max_w = cell_w - 2 * gridspec.cell_pad + img_max_h = cell_h - 2 * gridspec.cell_pad - cap_h + + ir = ImageReader(str(img_path)) + iw, ih = ir.getSize() + dw, dh = _fit_into(iw, ih, img_max_w, img_max_h) + + # center within image area + cx = img_x + (img_max_w - dw) / 2.0 + cy = img_y + (img_max_h - dh) / 2.0 + c.drawImage(ir, cx, cy, width=dw, height=dh, preserveAspectRatio=True, mask="auto") + + if footer: + c.setFont("Helvetica-Oblique", 8) + c.drawCentredString(page_w / 2.0, margin_b - 0.10 * inch, footer) + + +def build_pdf( + pdf_path: Path, + pages: Iterable[dict], + page_size=letter, +) -> None: + """ + pages: each dict describes a page: + { + "title": str, + "subtitle": str|None, + "images": list[ (caption: str, img_path: Path) ], + "grid": GridSpec(...) + } + """ + pdf_path.parent.mkdir(parents=True, exist_ok=True) + c = canvas.Canvas(str(pdf_path), pagesize=page_size) + + for p in pages: + draw_image_grid_page( + c, + title=p["title"], + subtitle=p.get("subtitle"), + images=p["images"], + gridspec=p["grid"], + page_size=page_size, + footer=p.get("footer", "Generated with STREAMLINE"), + ) + c.showPage() + + c.save() diff --git a/streamline/featurefns/__init__.py b/streamline/p10_replication/__init__.py similarity index 100% rename from streamline/featurefns/__init__.py rename to streamline/p10_replication/__init__.py diff --git a/streamline/p10_replication/p10_cli.py b/streamline/p10_replication/p10_cli.py new file mode 100644 index 00000000..c7b5c8e8 --- /dev/null +++ b/streamline/p10_replication/p10_cli.py @@ -0,0 +1,83 @@ +from __future__ import annotations + +import argparse + +from streamline.p10_replication.p10_runner import P10Runner +from streamline.utils.run_commands import ( + add_run_command_args, + apply_saved_run_command, + require_args, + save_run_command_from_args, + snapshot_args, +) + + +def main() -> None: + parser = argparse.ArgumentParser( + "STREAMLINE Phase 10 (Replication / External Validation)", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + + parser.add_argument( + "--rep_data_path", + default=None, + help="Directory containing replication datasets (.csv/.tsv/.txt)", + ) + parser.add_argument( + "--dataset_for_rep", + default=None, + help="Path to the original training dataset file whose trained pipeline is reused", + ) + parser.add_argument("--output_path", required=True, help="STREAMLINE output root") + parser.add_argument("--experiment_name", required=True, help="Experiment name") + + parser.add_argument("--outcome_label", default=None, help="Override outcome label") + parser.add_argument("--instance_label", default=None, help="Override instance label") + parser.add_argument("--match_label", default=None, help="Override match label") + + parser.add_argument( + "--exclude_plots", + default="", + help=( + "Comma-separated list of plots to exclude " + "(plot_ROC,plot_PRC,plot_metric_boxplots,plot_FI_box,feature_correlations)" + ), + ) + + parser.add_argument( + "--run_cluster", + default="Serial", + help="Serial | Local | Parallel | BashSLURM | BashLSF | ", + ) + parser.add_argument("--queue", default="defq") + parser.add_argument("--reserved_memory", type=int, default=4) + parser.add_argument("--show_plots", type=int, default=0) + add_run_command_args(parser) + + args = parser.parse_args() + args = apply_saved_run_command(parser, args, "p10_replication") + require_args(parser, args, ["rep_data_path", "dataset_for_rep"]) + run_command_args = snapshot_args(args) + + exclude_plots = [x.strip() for x in args.exclude_plots.split(",") if x.strip()] + + runner = P10Runner( + rep_data_path=args.rep_data_path, + dataset_for_rep=args.dataset_for_rep, + output_path=args.output_path, + experiment_name=args.experiment_name, + outcome_label=args.outcome_label, + instance_label=args.instance_label, + match_label=args.match_label, + exclude_plots=exclude_plots, + run_cluster=args.run_cluster, + queue=args.queue, + reserved_memory=args.reserved_memory, + show_plots=bool(args.show_plots), + ) + runner.run() + save_run_command_from_args(args, "p10_replication", run_command_args, runner=runner) + + +if __name__ == "__main__": + main() diff --git a/streamline/p10_replication/p10_jobsubmit.py b/streamline/p10_replication/p10_jobsubmit.py new file mode 100644 index 00000000..653ec529 --- /dev/null +++ b/streamline/p10_replication/p10_jobsubmit.py @@ -0,0 +1,60 @@ +from __future__ import annotations + +import argparse +import pickle +from pathlib import Path + +from streamline.p10_replication.replication import ReplicationJob + + +def main() -> None: + parser = argparse.ArgumentParser("STREAMLINE Phase 10 Replication JobSubmit") + parser.add_argument("--dataset_filename", required=True) + parser.add_argument("--dataset_for_rep", required=True) + parser.add_argument("--output_path", required=True) + parser.add_argument("--experiment_name", required=True) + parser.add_argument("--outcome_label", default=None) + parser.add_argument("--instance_label", default=None) + parser.add_argument("--match_label", default=None) + parser.add_argument("--exclude_plots", default="") + parser.add_argument("--show_plots", type=int, default=0) + args = parser.parse_args() + + exp_root = Path(args.output_path) / args.experiment_name + with (exp_root / "metadata.pickle").open("rb") as f: + metadata = pickle.load(f) + + outcome_label = args.outcome_label or metadata["Outcome Label"] + instance_label = args.instance_label or metadata.get("Instance Label") + outcome_type = metadata["Outcome Type"] + + train_name = Path(args.dataset_for_rep).stem + train_dataset_root = exp_root / train_name + + job = ReplicationJob( + dataset_filename=args.dataset_filename, + dataset_for_rep=args.dataset_for_rep, + full_path=str(train_dataset_root), + outcome_label=outcome_label, + outcome_type=outcome_type, + instance_label=instance_label, + match_label=args.match_label, + ignore_features=metadata.get("Ignored Features", []), + cv_partitions=metadata.get("CV Partitions", 5), + exclude_plots=[x.strip() for x in args.exclude_plots.split(",") if x.strip()], + categorical_cutoff=metadata.get("Categorical Cutoff", 10), + sig_cutoff=metadata.get("Statistical Significance Cutoff", 0.05), + featureeng_missingness=metadata.get("Engineering Missingness Cutoff", 0.5), + cleaning_missingness=metadata.get("Cleaning Missingness Cutoff", 0.5), + scale_data=metadata.get("Use Data Scaling", True), + impute_data=metadata.get("Use Data Imputation", True), + multi_impute=metadata.get("Use Multivariate Imputation", False), + show_plots=bool(args.show_plots), + scoring_metric=metadata.get("Primary Metric", "balanced_accuracy"), + random_state=metadata.get("Random Seed"), + ) + job.run() + + +if __name__ == "__main__": + main() diff --git a/streamline/p10_replication/p10_runner.py b/streamline/p10_replication/p10_runner.py new file mode 100644 index 00000000..bae89d5e --- /dev/null +++ b/streamline/p10_replication/p10_runner.py @@ -0,0 +1,241 @@ +from __future__ import annotations + +import glob +import logging +import os +import pickle +import time +from pathlib import Path +from typing import List, Optional + +import dask +from dask.distributed import Client, LocalCluster + +from streamline.p10_replication.replication import ReplicationJob +from streamline.utils.cluster import get_cluster +from streamline.utils.runners import num_cores, run_dask_tasks, run_parallel_items, runner_fn + + +class P10Runner: + """ + Phase 10 runner (Replication / External Validation). + + Applies a trained dataset pipeline to one or more external replication datasets. + """ + + def __init__( + self, + rep_data_path: str, + dataset_for_rep: str, + output_path: str, + experiment_name: str, + outcome_label: Optional[str] = None, + instance_label: Optional[str] = None, + match_label: Optional[str] = None, + exclude_plots: Optional[List[str]] = None, + run_cluster: str = "Serial", # Serial | Local | Parallel | BashSLURM | BashLSF | + queue: str = "defq", + reserved_memory: int = 4, + show_plots: bool = False, + ): + self.rep_data_path = rep_data_path + self.dataset_for_rep = dataset_for_rep + self.output_path = output_path + self.experiment_name = experiment_name + self.run_cluster = run_cluster or "Serial" + self.queue = queue + self.reserved_memory = int(reserved_memory) + self.show_plots = bool(show_plots) + self.match_label = match_label + + known_exclude_options = [ + "plot_ROC", + "plot_PRC", + "plot_metric_boxplots", + "plot_FI_box", + "feature_correlations", + ] + if exclude_plots is None: + exclude_plots = [] + for entry in exclude_plots: + if entry not in known_exclude_options: + logging.warning("Unknown plot exclusion option: %s", entry) + self.exclude_plots = exclude_plots + + self.exp_root = Path(self.output_path) / self.experiment_name + if not self.exp_root.is_dir(): + raise Exception("Experiment must exist (from phases 1-9) before replication can begin") + + with (self.exp_root / "metadata.pickle").open("rb") as f: + metadata = pickle.load(f) + + self.outcome_type = metadata["Outcome Type"] + self.outcome_label = outcome_label or metadata["Outcome Label"] + self.instance_label = instance_label or metadata.get("Instance Label") + self.ignore_features = metadata.get("Ignored Features", []) + self.categorical_cutoff = metadata.get("Categorical Cutoff", 10) + self.sig_cutoff = metadata.get("Statistical Significance Cutoff", 0.05) + self.featureeng_missingness = metadata.get("Engineering Missingness Cutoff", 0.5) + self.cleaning_missingness = metadata.get("Cleaning Missingness Cutoff", 0.5) + self.cv_partitions = metadata.get("CV Partitions", 5) + self.scale_data = metadata.get("Use Data Scaling", True) + self.impute_data = metadata.get("Use Data Imputation", True) + self.multi_impute = metadata.get("Use Multivariate Imputation", False) + self.scoring_metric = metadata.get("Primary Metric", "balanced_accuracy") + self.random_state = metadata.get("Random Seed") + + self.train_data_name = Path(self.dataset_for_rep).stem + self.train_dataset_root = self.exp_root / self.train_data_name + if not self.train_dataset_root.is_dir(): + raise Exception( + f"Training dataset directory does not exist in experiment output: {self.train_dataset_root}" + ) + + (self.train_dataset_root / "replication").mkdir(parents=True, exist_ok=True) + + if self.run_cluster in {"BashSLURM", "BashLSF"}: + (self.exp_root / "jobs").mkdir(parents=True, exist_ok=True) + (self.exp_root / "logs").mkdir(parents=True, exist_ok=True) + + # ------------------------------------------------------------------ + # Main run + # ------------------------------------------------------------------ + + def run(self) -> None: + files = sorted(glob.glob(os.path.join(self.rep_data_path, "*"))) + jobs: List[ReplicationJob] = [] + seen_names = set() + + for dataset_filename in files: + ext = Path(dataset_filename).suffix.lower() + if ext not in {".csv", ".tsv", ".txt"}: + continue + + apply_name = Path(dataset_filename).stem + if apply_name in seen_names: + continue + seen_names.add(apply_name) + + if self.run_cluster in {"BashSLURM", "BashLSF"}: + self._submit_bash(dataset_filename) + continue + + jobs.append(self._build_job(dataset_filename)) + + if not jobs and self.run_cluster not in {"BashSLURM", "BashLSF"}: + raise Exception( + "There must be at least one .txt, .csv, or .tsv dataset in rep_data_path" + ) + + if self.run_cluster == "Serial": + for job in jobs: + job.run() + elif self.run_cluster == "Local": + with LocalCluster(processes=True, n_workers=num_cores, threads_per_worker=1) as cluster: + with Client(cluster) as client: + run_dask_tasks( + [dask.delayed(runner_fn)(job) for job in jobs], + client, + label="Phase 10 Dask jobs", + ) + elif self.run_cluster == "Parallel": + run_parallel_items(runner_fn, jobs, label="Phase 10 Parallel jobs") + elif self.run_cluster in {"BashSLURM", "BashLSF"}: + return + else: + client: Client = get_cluster( + self.run_cluster, + str(self.exp_root), + self.queue, + self.reserved_memory, + ) + run_dask_tasks( + [dask.delayed(runner_fn)(job) for job in jobs], + client, + label="Phase 10 Dask jobs", + ) + + def _build_job(self, dataset_filename: str) -> ReplicationJob: + return ReplicationJob( + dataset_filename=dataset_filename, + dataset_for_rep=self.dataset_for_rep, + full_path=str(self.train_dataset_root), + outcome_label=self.outcome_label, + outcome_type=self.outcome_type, + instance_label=self.instance_label, + match_label=self.match_label, + ignore_features=self.ignore_features, + cv_partitions=self.cv_partitions, + exclude_plots=self.exclude_plots, + categorical_cutoff=self.categorical_cutoff, + sig_cutoff=self.sig_cutoff, + featureeng_missingness=self.featureeng_missingness, + cleaning_missingness=self.cleaning_missingness, + scale_data=self.scale_data, + impute_data=self.impute_data, + multi_impute=self.multi_impute, + show_plots=self.show_plots, + scoring_metric=self.scoring_metric, + random_state=self.random_state, + ) + + # ------------------------------------------------------------------ + # Bash submission + # ------------------------------------------------------------------ + + def _submit_bash(self, dataset_filename: str) -> None: + job_ref = str(time.time()) + jobs_dir = self.exp_root / "jobs" + logs_dir = self.exp_root / "logs" + jobs_dir.mkdir(parents=True, exist_ok=True) + logs_dir.mkdir(parents=True, exist_ok=True) + + sh_path = jobs_dir / f"P10_{job_ref}_run.sh" + submit_script = Path(__file__).with_name("p10_jobsubmit.py") + + args = " ".join( + [ + "python", + str(submit_script), + "--dataset_filename", + dataset_filename, + "--dataset_for_rep", + self.dataset_for_rep, + "--output_path", + str(self.output_path), + "--experiment_name", + self.experiment_name, + "--outcome_label", + self.outcome_label, + "--instance_label", + self.instance_label or "", + "--match_label", + self.match_label or "", + "--exclude_plots", + ",".join(self.exclude_plots) if self.exclude_plots else "", + "--show_plots", + str(int(self.show_plots)), + ] + ) + + with sh_path.open("w") as f: + f.write("#!/bin/bash\n") + if self.run_cluster == "BashSLURM": + f.write(f"#SBATCH -p {self.queue}\n") + f.write(f"#SBATCH --job-name={job_ref}\n") + f.write(f"#SBATCH --mem={self.reserved_memory}G\n") + f.write(f"#SBATCH -o {logs_dir}/P10_{job_ref}.o\n") + f.write(f"#SBATCH -e {logs_dir}/P10_{job_ref}.e\n") + f.write(f"srun {args}\n") + launch_cmd = f"sbatch {sh_path}" + else: + f.write(f"#BSUB -q {self.queue}\n") + f.write(f"#BSUB -J {job_ref}\n") + f.write(f"#BSUB -R \"rusage[mem={self.reserved_memory}G]\"\n") + f.write(f"#BSUB -M {self.reserved_memory}GB\n") + f.write(f"#BSUB -o {logs_dir}/P10_{job_ref}.o\n") + f.write(f"#BSUB -e {logs_dir}/P10_{job_ref}.e\n") + f.write(f"{args}\n") + launch_cmd = f"bsub < {sh_path}" + + os.system(launch_cmd) diff --git a/streamline/p10_replication/replication.py b/streamline/p10_replication/replication.py new file mode 100644 index 00000000..dd64f83f --- /dev/null +++ b/streamline/p10_replication/replication.py @@ -0,0 +1,1494 @@ +from __future__ import annotations + +import json +import logging +import os +import pickle +import re +import shutil +from pathlib import Path +from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple + +import numpy as np +import pandas as pd +from pandas.api.types import is_numeric_dtype +from sklearn.metrics import brier_score_loss + +from streamline.p1_data_process.data_process import DataProcess +from streamline.p6_modeling.utils.submodels import ( + BinaryClassificationModel, + MulticlassClassificationModel, + RegressionModel, +) +from streamline.p6_modeling.utils.support import multiclass_brier_score +from streamline.p7_ensembles.ensembles import ( + _calc_basic_metrics, + _calc_curves_scores_from_proba, +) +from streamline.p8_summary_statistics.statistics import StatisticsPhaseJob + + +logger = logging.getLogger(__name__) + + +def _normalize_outcome_type(outcome_type: str) -> str: + """Normalize multiple aliases to STREAMLINE internal outcome type labels.""" + value = (outcome_type or "").strip().lower() + if value in {"binary", "bin", "classification_binary"}: + return "Binary" + if value in {"multiclass", "multi", "classification_multiclass"}: + return "Multiclass" + if value in {"continuous", "regression", "numeric"}: + return "Continuous" + return outcome_type + + +def _read_table(file_path: str) -> pd.DataFrame: + """Read CSV/TSV/TXT input consistently with phase-1 behavior.""" + ext = Path(file_path).suffix.lower() + if ext == ".csv": + return pd.read_csv(file_path, na_values="NA", sep=",") + if ext == ".tsv": + return pd.read_csv(file_path, na_values="NA", sep="\t") + if ext == ".txt": + return pd.read_csv(file_path, na_values="NA", delim_whitespace=True) + raise ValueError(f"Unsupported replication file extension: {ext}") + + +def _safe_pickle_load(path: Path, default: Any) -> Any: + if not path.exists(): + return default + with path.open("rb") as f: + return pickle.load(f) + + +def _jsonify(value: Any) -> Any: + """Convert numpy/pandas scalar containers to JSON-safe python values.""" + if isinstance(value, dict): + return {str(k): _jsonify(v) for k, v in value.items()} + if isinstance(value, (list, tuple)): + return [_jsonify(v) for v in value] + if isinstance(value, np.ndarray): + return [_jsonify(v) for v in value.tolist()] + if isinstance(value, (np.integer,)): + return int(value) + if isinstance(value, (np.floating,)): + if np.isnan(value) or np.isinf(value): + return None + return float(value) + if isinstance(value, pd.Series): + return [_jsonify(v) for v in value.tolist()] + if isinstance(value, pd.DataFrame): + return _jsonify(value.to_dict(orient="records")) + if isinstance(value, float): + if np.isnan(value) or np.isinf(value): + return None + return value + return value + + +class ReplicationJob: + """ + Phase 10 replication job. + + For one replication dataset, this job: + 1. Replays the p1 data-processing decisions learned on the train dataset. + 2. Replays p2 imputation/scaling per CV split. + 3. Applies p6 trained base models and writes p8-compatible metrics/curves artifacts. + 4. Applies p7 trained ensembles (classification only) and writes ensemble artifacts. + 5. Runs p8 statistics on replication outputs. + + The produced tree is rooted at: + /replication// + """ + + def __init__( + self, + dataset_filename: str, + dataset_for_rep: str, + full_path: str, + outcome_label: str, + outcome_type: str, + instance_label: Optional[str], + match_label: Optional[str], + ignore_features: Optional[List[str]] = None, + cv_partitions: int = 3, + exclude_plots: Optional[List[str]] = None, + categorical_cutoff: int = 10, + sig_cutoff: float = 0.05, + featureeng_missingness: float = 0.5, + cleaning_missingness: float = 0.5, + scale_data: bool = True, + impute_data: bool = True, + multi_impute: bool = True, + show_plots: bool = False, + scoring_metric: str = "balanced_accuracy", + random_state: Optional[int] = None, + ): + self.dataset_filename = dataset_filename + self.dataset_for_rep = dataset_for_rep + self.train_root = Path(full_path) + self.experiment_root = self.train_root.parent + + self.outcome_label = outcome_label + self.outcome_type = _normalize_outcome_type(outcome_type) + self.instance_label = instance_label + self.match_label = match_label + + self.ignore_features = ignore_features or [] + self.cv_partitions = int(cv_partitions) + self.exclude_plots = exclude_plots or [] + self.categorical_cutoff = int(categorical_cutoff) + self.sig_cutoff = float(sig_cutoff) + self.featureeng_missingness = float(featureeng_missingness) + self.cleaning_missingness = float(cleaning_missingness) + self.scale_data = bool(scale_data) + self.impute_data = bool(impute_data) + self.multi_impute = bool(multi_impute) + self.show_plots = bool(show_plots) + self.scoring_metric = scoring_metric + self.random_state = random_state + + self.train_name = self.train_root.name + self.apply_name = Path(self.dataset_filename).stem + self.rep_root = self.train_root / "replication" / self.apply_name + + self.exploratory_dir = self.rep_root / "exploratory" + self.cv_dir = self.rep_root / "CVDatasets" + self.model_eval_dir = self.rep_root / "model_evaluation" + self.model_metrics_dir = self.model_eval_dir / "metrics_by_cv" + self.model_curves_dir = self.model_eval_dir / "curves_by_cv" + self.model_pickled_metrics_dir = self.model_eval_dir / "pickled_metrics" + self.ensemble_root = self.rep_root / "ensemble_evaluation" + self.ensemble_metrics_dir = self.ensemble_root / "metrics_by_cv" + self.ensemble_curves_dir = self.ensemble_root / "curves_by_cv" + self.ensemble_pickled_dir = self.ensemble_root / "pickled_ensembles" + + self.algorithms, self.abbrev = self._load_algorithms() + + # ------------------------------------------------------------------ + # Public entry + # ------------------------------------------------------------------ + + def run(self) -> None: + self._prepare_dirs() + self._auto_correct_labels_from_training_cv() + + rep_raw = _read_table(self.dataset_filename) + rep_raw.columns = rep_raw.columns.str.strip() + + raw_train_columns = self._load_training_raw_columns() + missing_cols = [c for c in raw_train_columns if c not in rep_raw.columns] + if missing_cols: + raise Exception( + "Replication dataset is missing one or more training columns: " + + ", ".join(missing_cols) + ) + rep_raw = rep_raw[raw_train_columns].copy() + + if self.instance_label and self.instance_label not in rep_raw.columns: + logger.warning("Instance label '%s' not in replication dataset; ignoring.", self.instance_label) + self.instance_label = None + if self.match_label and self.match_label not in rep_raw.columns: + logger.warning("Match label '%s' not in replication dataset; ignoring.", self.match_label) + self.match_label = None + + if self.outcome_label not in rep_raw.columns: + raise Exception(f"Outcome label '{self.outcome_label}' is missing in replication dataset") + + processed, cat_features, quant_features, transition_df = self._replay_data_processing(rep_raw) + + self._write_processed_dataset(processed, cat_features, quant_features, transition_df) + self._write_eda_artifacts(processed, cat_features, quant_features) + + fold_map = self._resolve_fold_map() + if not fold_map: + raise Exception("No CV train folds found in training dataset; cannot run replication") + + self._evaluate_models(processed, cat_features, quant_features, fold_map) + + if self.outcome_type in {"Binary", "Multiclass"}: + self._evaluate_ensembles(processed, fold_map) + + self._run_statistics(cv_partitions=len(fold_map)) + + logger.info("Replication complete for %s", self.apply_name) + jobs_completed = self.experiment_root / "jobsCompleted" + jobs_completed.mkdir(parents=True, exist_ok=True) + with (jobs_completed / f"job_apply_{self.apply_name}.txt").open("w") as f: + f.write("complete") + + # ------------------------------------------------------------------ + # Setup and discovery + # ------------------------------------------------------------------ + + def _prepare_dirs(self) -> None: + self.exploratory_dir.mkdir(parents=True, exist_ok=True) + self.cv_dir.mkdir(parents=True, exist_ok=True) + self.model_metrics_dir.mkdir(parents=True, exist_ok=True) + self.model_curves_dir.mkdir(parents=True, exist_ok=True) + self.model_pickled_metrics_dir.mkdir(parents=True, exist_ok=True) + + + def _auto_correct_labels_from_training_cv(self) -> None: + """ + Guard against stale metadata labels by inferring labels from training CV files. + + - Outcome label is expected to be the first column in CV train files. + - Instance label must be highly unique; otherwise treat it as a feature. + """ + cv_train_files = sorted((self.train_root / "CVDatasets").glob(f"{self.train_name}_CV_*_Train.csv")) + if not cv_train_files: + return + + train_df = pd.read_csv(cv_train_files[0], nrows=500, na_values="NA", sep=",") + if train_df.empty: + return + + first_col = str(train_df.columns[0]) + if first_col and self.outcome_label != first_col: + logger.warning( + "Outcome label '%s' does not match training CV schema; using '%s' for replication.", + self.outcome_label, + first_col, + ) + self.outcome_label = first_col + + if self.instance_label: + if self.instance_label == self.outcome_label: + logger.warning( + "Instance label '%s' equals outcome label; ignoring instance label for replication.", + self.instance_label, + ) + self.instance_label = None + elif self.instance_label in train_df.columns: + uniq = train_df[self.instance_label].nunique(dropna=True) + ratio = float(uniq) / float(max(1, len(train_df))) + if ratio < 0.95: + logger.warning( + "Instance label '%s' is not near-unique in training CV data; treating it as a regular feature.", + self.instance_label, + ) + self.instance_label = None + else: + logger.warning( + "Instance label '%s' not found in training CV schema; ignoring.", + self.instance_label, + ) + self.instance_label = None + + if self.match_label and self.match_label not in train_df.columns: + logger.warning("Match label '%s' not found in training CV schema; ignoring.", self.match_label) + self.match_label = None + + if self.outcome_type == "Continuous": + valid_regression_metrics = { + "explained_variance", + "max_error", + "mean_absolute_error", + "mean_squared_error", + "median_absolute_error", + "pearson_correlation", + } + metric_name = str(self.scoring_metric).strip().lower() if self.scoring_metric is not None else "" + if metric_name not in valid_regression_metrics: + self.scoring_metric = "explained_variance" + + def _load_algorithms(self) -> Tuple[List[str], Dict[str, str]]: + """ + Discover active base algorithms and their short names. + + Priority: + 1) experiment-level algInfo.pickle + 2) model pickle filenames under train dataset + """ + alg_info_path = self.experiment_root / "algInfo.pickle" + algorithms: List[str] = [] + abbrev: Dict[str, str] = {} + + if alg_info_path.exists(): + with alg_info_path.open("rb") as f: + alg_info = pickle.load(f) + for algorithm, payload in alg_info.items(): + if not isinstance(payload, (list, tuple)) or len(payload) == 0: + continue + use_flag = bool(payload[0]) + short_name = payload[1] if len(payload) > 1 and payload[1] else algorithm + if use_flag: + algorithms.append(algorithm) + abbrev[algorithm] = short_name + + if algorithms: + return algorithms, abbrev + + model_dir = self.train_root / "models" / "pickledModels" + if model_dir.exists(): + shorts = sorted( + { + m.group(1) + for fn in model_dir.glob("*.pickle") + for m in [re.match(r"(.+?)_\d+\.pickle$", fn.name)] + if m + } + ) + algorithms = shorts + abbrev = {s: s for s in shorts} + + return algorithms, abbrev + + def _load_training_raw_columns(self) -> List[str]: + """Recover training raw-column order, including labels.""" + train_file = Path(self.dataset_for_rep) + if train_file.exists(): + train_df = _read_table(str(train_file)) + train_df.columns = train_df.columns.str.strip() + return list(train_df.columns) + + # Fallback to p1 artifact if original raw file path is not available. + original_names = self.train_root / "exploratory" / "initial" / "OriginalFeatureNames.csv" + if original_names.exists(): + row = pd.read_csv(original_names, header=None).iloc[0].dropna().tolist() + cols = [str(x) for x in row] + for lbl in (self.outcome_label, self.instance_label, self.match_label): + if lbl and lbl not in cols: + cols.append(lbl) + return cols + + raise Exception( + "Could not determine training raw columns. " + "Provide dataset_for_rep as the original training dataset file path." + ) + + def _resolve_fold_map(self) -> List[Tuple[int, int]]: + """ + Map contiguous replication fold ids to source training fold ids with strict parity. + + Returns list of tuples: (replication_cv_id, source_training_cv_id) + """ + cv_files = sorted((self.train_root / "CVDatasets").glob(f"{self.train_name}_CV_*_Train.csv")) + source_ids = [] + for path in cv_files: + match = re.search(r"_CV_(\d+)_Train\.csv$", path.name) + if match: + source_ids.append(int(match.group(1))) + + source_ids = sorted(set(source_ids)) + if not source_ids: + return [] + + # Strictly align expected folds to metadata-defined CV partitions when available. + if self.cv_partitions > 0: + expected_source_ids = list(range(self.cv_partitions)) + missing_cv_files = [cv for cv in expected_source_ids if cv not in source_ids] + if missing_cv_files: + raise Exception( + "Strict fold parity failed: missing training CV files for folds " + + ", ".join(str(cv) for cv in missing_cv_files) + ) + source_ids = expected_source_ids + + # Strictly require all expected folds for every active base algorithm. + model_dir = self.train_root / "models" / "pickledModels" + if not model_dir.exists(): + raise Exception("Strict fold parity failed: models/pickledModels directory is missing") + + if self.algorithms: + for algorithm in self.algorithms: + small = self.abbrev.get(algorithm, algorithm) + ids = { + int(m.group(1)) + for pattern in (f"{small}_*.pickle", f"{algorithm}_*.pickle") + for p in model_dir.glob(pattern) + for m in [re.match(r".+?_(\d+)\.pickle$", p.name)] + if m + } + missing_model_folds = [cv for cv in source_ids if cv not in ids] + if missing_model_folds: + raise Exception( + "Strict fold parity failed: missing trained model pickles for " + f"algorithm={algorithm}, folds={missing_model_folds}" + ) + + return [(idx, source_cv) for idx, source_cv in enumerate(source_ids)] + + # ------------------------------------------------------------------ + # p1 replay on replication data + # ------------------------------------------------------------------ + + def _replay_data_processing( + self, + raw_df: pd.DataFrame, + ) -> Tuple[pd.DataFrame, List[str], List[str], pd.DataFrame]: + data = raw_df.copy() + + initial_cat = _safe_pickle_load( + self.train_root / "exploratory" / "initial" / "initial_categorical_features.pickle", + [], + ) + initial_quant = _safe_pickle_load( + self.train_root / "exploratory" / "initial" / "initial_quantitative_features.pickle", + [], + ) + + categorical_features = [f for f in initial_cat if f in data.columns and f != self.outcome_label] + quantitative_features = [f for f in initial_quant if f in data.columns and f != self.outcome_label] + + class_count = self._load_training_class_count(default=data[self.outcome_label].nunique(dropna=True)) + transition_columns = self._build_transition_columns(class_count) + transition_df = pd.DataFrame(columns=transition_columns) + + transition_df.loc["Original"] = self._counts_summary_row( + data, categorical_features, quantitative_features, class_count + ) + + # C1 - label alignment, remove ignored and missing outcome rows + data = self._apply_ordinal_encoding(data) + self._apply_binary_consistency(data) + data = self._drop_ignored_and_missing_outcome(data) + categorical_features, quantitative_features = self._sync_feature_lists( + data, categorical_features, quantitative_features + ) + transition_df.loc["C1"] = self._counts_summary_row( + data, categorical_features, quantitative_features, class_count + ) + + # E1 - engineered missingness indicators from training + data, categorical_features = self._apply_engineered_missingness(data, categorical_features) + transition_df.loc["E1"] = self._counts_summary_row( + data, categorical_features, quantitative_features, class_count + ) + + # C2 - invariant + training-removed features + data, categorical_features, quantitative_features = self._drop_invariant_features( + data, categorical_features, quantitative_features + ) + data, categorical_features, quantitative_features = self._drop_training_removed_features( + data, categorical_features, quantitative_features + ) + transition_df.loc["C2"] = self._counts_summary_row( + data, categorical_features, quantitative_features, class_count + ) + + # C3 - remove high-missingness rows + data = self._drop_high_missing_rows(data) + transition_df.loc["C3"] = self._counts_summary_row( + data, categorical_features, quantitative_features, class_count + ) + + # E2 - one hot encode multi-level categoricals + data, categorical_features = self._apply_one_hot_encoding(data, categorical_features) + categorical_features, quantitative_features = self._sync_feature_lists( + data, categorical_features, quantitative_features + ) + transition_df.loc["E2"] = self._counts_summary_row( + data, categorical_features, quantitative_features, class_count + ) + + # C4 - remove correlated features from training + final feature alignment + data, categorical_features, quantitative_features = self._drop_training_correlated_features( + data, categorical_features, quantitative_features + ) + data, categorical_features, quantitative_features = self._align_to_training_processed_features( + data, categorical_features, quantitative_features + ) + transition_df.loc["C4"] = self._counts_summary_row( + data, categorical_features, quantitative_features, class_count + ) + + return data, categorical_features, quantitative_features, transition_df + + def _load_training_class_count(self, default: int) -> int: + class_counts_path = self.train_root / "exploratory" / "ClassCounts.csv" + if not class_counts_path.exists(): + return max(2, int(default)) if self.outcome_type == "Multiclass" else int(default) + try: + class_counts = pd.read_csv(class_counts_path) + if class_counts.shape[0] > 0: + return int(class_counts.shape[0]) + except Exception: + pass + return max(2, int(default)) if self.outcome_type == "Multiclass" else int(default) + + def _build_transition_columns(self, class_count: int) -> List[str]: + base = [ + "Instances", + "Total Features", + "Categorical Features", + "Quantitative Features", + "Missing Values", + "Missing Percent", + ] + if self.outcome_type == "Binary": + return base + ["Class 0", "Class 1"] + if self.outcome_type == "Multiclass": + n_classes = max(2, int(class_count)) + return base + [f"Class {i}" for i in range(n_classes)] + return base + + def _counts_summary_row( + self, + data: pd.DataFrame, + categorical_features: Sequence[str], + quantitative_features: Sequence[str], + class_count: int, + ) -> List[float]: + feature_count = data.shape[1] - 1 + if self.instance_label and self.instance_label in data.columns: + feature_count -= 1 + if self.match_label and self.match_label in data.columns: + feature_count -= 1 + + total_missing = int(data.isnull().sum().sum()) + denom = max(1, data.shape[0] * max(1, feature_count)) + missing_percent = total_missing / float(denom) + + row: List[float] = [ + int(data.shape[0]), + int(max(0, feature_count)), + int(len(categorical_features)), + int(len(quantitative_features)), + int(total_missing), + float(round(missing_percent, 5)), + ] + + if self.outcome_type == "Binary": + vc = data[self.outcome_label].value_counts(dropna=False) + row.extend([int(vc.get(0, 0)), int(vc.get(1, 0))]) + elif self.outcome_type == "Multiclass": + counts = data[self.outcome_label].value_counts(dropna=False).sort_index().tolist() + n_classes = max(2, int(class_count)) + row.extend([int(counts[i]) if i < len(counts) else 0 for i in range(n_classes)]) + + return row + + def _sync_feature_lists( + self, + data: pd.DataFrame, + categorical_features: Sequence[str], + quantitative_features: Sequence[str], + ) -> Tuple[List[str], List[str]]: + labels = {self.outcome_label, self.instance_label, self.match_label} + labels = {x for x in labels if x} + + cat = [f for f in categorical_features if f in data.columns and f not in labels] + quant = [f for f in quantitative_features if f in data.columns and f not in labels and f not in cat] + + # Any remaining numeric feature not already listed should be treated as quantitative. + for col in data.columns: + if col in labels or col in cat or col in quant: + continue + if is_numeric_dtype(data[col]): + quant.append(col) + else: + cat.append(col) + + return cat, quant + + def _apply_ordinal_encoding(self, data: pd.DataFrame) -> pd.DataFrame: + ord_map_path = self.train_root / "exploratory" / "ordinal_encoding.pickle" + if not ord_map_path.exists(): + return data + + ord_map = _safe_pickle_load(ord_map_path, pd.DataFrame()) + if not isinstance(ord_map, pd.DataFrame) or ord_map.empty: + return data + + for feat in ord_map.index: + if feat not in data.columns: + continue + + categories = ord_map.loc[feat, "Category"] + encodings = ord_map.loc[feat, "Encoding"] + if not isinstance(categories, (list, tuple)) or not isinstance(encodings, (list, tuple)): + continue + + values = data[feat].dropna() + if values.empty: + continue + + # Skip if already encoded numerically with the same coding range. + if is_numeric_dtype(values): + try: + enc_set = {int(x) for x in encodings if x is not None} + val_set = {int(x) for x in values.astype(float).tolist()} + if val_set.issubset(enc_set): + continue + except Exception: + pass + + mapping = {cat: enc for cat, enc in zip(categories, encodings)} + before_non_na = int(data[feat].notna().sum()) + data[feat] = data[feat].map(mapping) + after_non_na = int(data[feat].notna().sum()) + + if after_non_na < before_non_na: + logger.warning( + "Replication feature '%s' contained unseen labels; mapped to NaN for %d rows", + feat, + before_non_na - after_non_na, + ) + + return data + + def _apply_binary_consistency(self, data: pd.DataFrame) -> None: + binary_map_path = self.train_root / "exploratory" / "binary_categorical_dict.pickle" + binary_map = _safe_pickle_load(binary_map_path, {}) + if not isinstance(binary_map, dict): + return + + for feat, train_values in binary_map.items(): + if feat not in data.columns: + continue + if not isinstance(train_values, (list, tuple, set)): + continue + train_set = set(train_values) + observed = set(data[feat].dropna().unique().tolist()) + new_values = observed - train_set + if new_values: + logger.warning( + "Replication binary feature '%s' has unseen values; replacing with NaN: %s", + feat, + sorted(new_values), + ) + data.loc[data[feat].isin(list(new_values)), feat] = np.nan + + def _drop_ignored_and_missing_outcome(self, data: pd.DataFrame) -> pd.DataFrame: + cleaned = data.dropna(axis=0, how="any", subset=[self.outcome_label]).reset_index(drop=True) + if self.ignore_features: + cleaned = cleaned.drop(columns=[f for f in self.ignore_features if f in cleaned.columns], errors="ignore") + + # Match p1 behavior: cast classification outcome to int when possible. + if self.outcome_type in {"Binary", "Multiclass"}: + try: + cleaned[self.outcome_label] = cleaned[self.outcome_label].astype("int64") + except Exception: + pass + + return cleaned + + def _apply_engineered_missingness( + self, + data: pd.DataFrame, + categorical_features: Sequence[str], + ) -> Tuple[pd.DataFrame, List[str]]: + train_engineered = _safe_pickle_load( + self.train_root / "exploratory" / "engineered_features.pickle", + [], + ) + if not isinstance(train_engineered, (list, tuple)): + return data, list(categorical_features) + + cat = list(categorical_features) + for source_feat in train_engineered: + if source_feat in data.columns: + miss_feat = f"Miss_{source_feat}" + data[miss_feat] = data[source_feat].isnull().astype(int) + if miss_feat not in cat: + cat.append(miss_feat) + + return data, cat + + def _drop_invariant_features( + self, + data: pd.DataFrame, + categorical_features: Sequence[str], + quantitative_features: Sequence[str], + ) -> Tuple[pd.DataFrame, List[str], List[str]]: + invariant = [c for c in data.columns if data[c].nunique(dropna=True) <= 1 and c != self.outcome_label] + if invariant: + data = data.drop(columns=invariant, errors="ignore") + cat = [c for c in categorical_features if c not in invariant] + quant = [c for c in quantitative_features if c not in invariant] + return data, cat, quant + + def _drop_training_removed_features( + self, + data: pd.DataFrame, + categorical_features: Sequence[str], + quantitative_features: Sequence[str], + ) -> Tuple[pd.DataFrame, List[str], List[str]]: + removed = _safe_pickle_load(self.train_root / "exploratory" / "removed_features.pickle", []) + if not isinstance(removed, (list, tuple)): + removed = [] + + removed_set = set(removed) + data = data.drop(columns=[c for c in removed if c in data.columns], errors="ignore") + cat = [c for c in categorical_features if c not in removed_set] + quant = [c for c in quantitative_features if c not in removed_set] + return data, cat, quant + + def _drop_high_missing_rows(self, data: pd.DataFrame) -> pd.DataFrame: + feature_count = data.shape[1] - 1 + if self.instance_label and self.instance_label in data.columns: + feature_count -= 1 + if self.match_label and self.match_label in data.columns: + feature_count -= 1 + + threshold = int(self.cleaning_missingness * max(1, feature_count)) + if threshold <= 0: + return data + return data[data.isnull().sum(axis=1) < threshold].reset_index(drop=True) + + def _apply_one_hot_encoding( + self, + data: pd.DataFrame, + categorical_features: Sequence[str], + ) -> Tuple[pd.DataFrame, List[str]]: + non_binary = [ + c + for c in categorical_features + if c in data.columns and data[c].nunique(dropna=True) > 2 + ] + + cat = list(categorical_features) + if not non_binary: + return data, cat + + one_hot_df = pd.get_dummies(data[non_binary], columns=non_binary) + data = data.drop(columns=non_binary, errors="ignore") + data = pd.concat([data, one_hot_df], axis=1) + + cat = [c for c in cat if c not in non_binary] + cat.extend(list(one_hot_df.columns)) + return data, cat + + def _drop_training_correlated_features( + self, + data: pd.DataFrame, + categorical_features: Sequence[str], + quantitative_features: Sequence[str], + ) -> Tuple[pd.DataFrame, List[str], List[str]]: + correlated = _safe_pickle_load( + self.train_root / "exploratory" / "correlated_features.pickle", + [], + ) + if not isinstance(correlated, (list, tuple)): + correlated = [] + + correlated_set = set(correlated) + data = data.drop(columns=[c for c in correlated if c in data.columns], errors="ignore") + cat = [c for c in categorical_features if c not in correlated_set] + quant = [c for c in quantitative_features if c not in correlated_set] + return data, cat, quant + + def _align_to_training_processed_features( + self, + data: pd.DataFrame, + categorical_features: Sequence[str], + quantitative_features: Sequence[str], + ) -> Tuple[pd.DataFrame, List[str], List[str]]: + post_processed = _safe_pickle_load( + self.train_root / "exploratory" / "post_processed_features.pickle", + [], + ) + + if not isinstance(post_processed, (list, tuple)) or len(post_processed) == 0: + post_processed = list(data.columns) + + # Ensure labels are present in final schema. + for lbl in (self.outcome_label, self.instance_label, self.match_label): + if lbl and lbl not in post_processed: + post_processed = [lbl] + list(post_processed) + + for feat in post_processed: + if feat not in data.columns: + data[feat] = 0 + + data = data[[c for c in post_processed if c in data.columns]].copy() + + cat, quant = self._sync_feature_lists(data, categorical_features, quantitative_features) + return data, cat, quant + + # ------------------------------------------------------------------ + # Artifact writing for exploratory outputs + # ------------------------------------------------------------------ + + def _write_processed_dataset( + self, + processed: pd.DataFrame, + categorical_features: Sequence[str], + quantitative_features: Sequence[str], + transition_df: pd.DataFrame, + ) -> None: + self.exploratory_dir.mkdir(parents=True, exist_ok=True) + (self.exploratory_dir / "initial").mkdir(parents=True, exist_ok=True) + + transition_df.to_csv(self.exploratory_dir / "DataProcessSummary.csv", index=True) + + with (self.exploratory_dir / "categorical_features.pickle").open("wb") as f: + pickle.dump(list(categorical_features), f) + + with (self.exploratory_dir / "post_processed_features.pickle").open("wb") as f: + pickle.dump(list(processed.columns), f) + + # p1 format: one-row CSV with feature names only (no labels). + feature_headers = [c for c in processed.columns if c not in self._label_columns(processed)] + pd.DataFrame([feature_headers]).to_csv( + self.exploratory_dir / "ProcessedFeatureNames.csv", + index=False, + header=False, + ) + + processed.to_csv(self.rep_root / f"{self.apply_name}_Processed.csv", index=False) + + # Preserve initial feature-type artifacts for compatibility. + initial_cat = _safe_pickle_load( + self.train_root / "exploratory" / "initial" / "initial_categorical_features.pickle", + [], + ) + initial_quant = _safe_pickle_load( + self.train_root / "exploratory" / "initial" / "initial_quantitative_features.pickle", + [], + ) + with (self.exploratory_dir / "initial" / "initial_categorical_features.pickle").open("wb") as f: + pickle.dump([c for c in initial_cat if c in processed.columns], f) + with (self.exploratory_dir / "initial" / "initial_quantitative_features.pickle").open("wb") as f: + pickle.dump([c for c in initial_quant if c in processed.columns], f) + + def _write_eda_artifacts( + self, + processed: pd.DataFrame, + categorical_features: Sequence[str], + quantitative_features: Sequence[str], + ) -> None: + """Generate p1-style exploratory CSV outputs used downstream by reporting.""" + experiment_path = str(self.train_root / "replication") + + eda = DataProcess( + data=processed.copy(), + experiment_path=experiment_path, + outcome_label=self.outcome_label, + outcome_type=self.outcome_type, + match_label=self.match_label, + instance_label=self.instance_label, + categorical_cutoff=self.categorical_cutoff, + sig_cutoff=self.sig_cutoff, + random_state=self.random_state, + show_plots=self.show_plots, + dataset_name=self.apply_name, + enable_plots=False, + ) + eda.outcome_type = self.outcome_type + eda.categorical_features = list(categorical_features) + eda.quantitative_features = list(quantitative_features) + eda.make_log_folders() + + eda.describe_data() + total_missing = eda.missingness_counts() + eda.counts_summary(total_missing=total_missing, save=True, replicate=True) + + if "feature_correlations" not in self.exclude_plots: + try: + eda.feature_correlation(x_data=eda.feature_only_data()) + except Exception as exc: + logger.warning("Failed to compute feature correlation for replication set: %s", exc) + + try: + eda.univariate_analysis(top_features=20) + except Exception as exc: + logger.warning("Failed to compute univariate analysis for replication set: %s", exc) + + # ------------------------------------------------------------------ + # p2/p6 replay and p7 replication evaluation + # ------------------------------------------------------------------ + + def _evaluate_models( + self, + processed: pd.DataFrame, + categorical_features: Sequence[str], + quantitative_features: Sequence[str], + fold_map: Sequence[Tuple[int, int]], + ) -> None: + if not self.algorithms: + raise Exception("No trained algorithms found to evaluate on replication dataset") + + for rep_cv_idx, source_cv_idx in fold_map: + train_cv_path = self.train_root / "CVDatasets" / f"{self.train_name}_CV_{source_cv_idx}_Train.csv" + if not train_cv_path.exists(): + raise Exception( + "Strict fold parity failed: missing training CV fold file " + f"{train_cv_path}" + ) + + train_cv_df = pd.read_csv(train_cv_path, na_values="NA", sep=",") + rep_cv_df = processed.copy() + + base_feature_columns = [ + c + for c in rep_cv_df.columns + if c not in self._label_columns(rep_cv_df) + ] + + if self.impute_data: + rep_cv_df = self._apply_imputation( + rep_cv_df, + base_feature_columns, + source_cv_idx, + train_cv_df, + categorical_features, + quantitative_features, + ) + + if self.scale_data: + rep_cv_df = self._apply_scaling(rep_cv_df, base_feature_columns, source_cv_idx, train_cv_df) + + rep_cv_df = self._apply_feature_learning(rep_cv_df, source_cv_idx, train_cv_df) + + # Align exactly to training fold columns. + missing_cols = [col for col in train_cv_df.columns if col not in rep_cv_df.columns] + if missing_cols: + learned_cols = set(self._read_feature_learning_outputs(source_cv_idx)) + missing_learned = [c for c in missing_cols if c in learned_cols] + if missing_learned: + raise Exception( + "Cannot align replication fold because learned Phase 3 features are missing after replay: " + + ", ".join(missing_learned[:20]) + ) + filler = pd.DataFrame(0, index=rep_cv_df.index, columns=missing_cols) + rep_cv_df = pd.concat([rep_cv_df, filler], axis=1) + rep_cv_df = rep_cv_df[list(train_cv_df.columns)].copy() + + # Persist CV artifacts in replication dataset namespace. + rep_test_path = self.cv_dir / f"{self.apply_name}_CV_{rep_cv_idx}_Test.csv" + rep_train_path = self.cv_dir / f"{self.apply_name}_CV_{rep_cv_idx}_Train.csv" + rep_cv_df.to_csv(rep_test_path, index=False) + shutil.copy2(train_cv_path, rep_train_path) + + eval_df = rep_cv_df.copy() + if self.instance_label and self.instance_label in eval_df.columns: + eval_df = eval_df.drop(columns=[self.instance_label]) + + if self.outcome_label not in eval_df.columns: + raise Exception( + "Strict fold parity failed: outcome label " + f"'{self.outcome_label}' missing in replication fold {rep_cv_idx}" + ) + + x_test = eval_df.drop(columns=[self.outcome_label]).values + y_test = eval_df[self.outcome_label].values + + for algorithm in self.algorithms: + small = self.abbrev.get(algorithm, algorithm) + model_path_candidates = [ + self.train_root / "models" / "pickledModels" / f"{small}_{source_cv_idx}.pickle", + self.train_root / "models" / "pickledModels" / f"{algorithm}_{source_cv_idx}.pickle", + ] + model_path = next((p for p in model_path_candidates if p.exists()), None) + if model_path is None: + raise Exception( + "Strict fold parity failed: missing trained model pickle for " + f"algorithm={algorithm}, source_cv={source_cv_idx}" + ) + + with model_path.open("rb") as f: + model = pickle.load(f) + + fi_list = self._load_training_feature_importance( + small_name=small, + source_cv_idx=source_cv_idx, + expected_len=x_test.shape[1], + ) + + if self.outcome_type == "Binary": + evaluator = BinaryClassificationModel(None, algorithm, scoring_metric=self.scoring_metric) + evaluator.model = model + metrics_dict, curves_dict = evaluator.model_evaluation(x_test, y_test) + self._write_base_outputs(rep_cv_idx, small, metrics_dict, curves_dict, fi_list) + elif self.outcome_type == "Multiclass": + evaluator = MulticlassClassificationModel(None, algorithm, scoring_metric=self.scoring_metric) + evaluator.model = model + metrics_dict, curves_dict = evaluator.model_evaluation(x_test, y_test) + self._write_base_outputs(rep_cv_idx, small, metrics_dict, curves_dict, fi_list) + else: + evaluator = RegressionModel(None, algorithm, scoring_metric=self.scoring_metric) + evaluator.model = model + metrics_dict = evaluator.model_evaluation(x_test, y_test) + y_pred = evaluator.predict(x_test) + residual_test = y_test - y_pred + self._write_base_outputs( + rep_cv_idx, + small, + metrics_dict, + None, + fi_list, + residual_test=residual_test, + y_pred=y_pred, + y_true=y_test, + ) + + def _label_columns(self, df: pd.DataFrame) -> List[str]: + labels = [self.outcome_label] + if self.instance_label and self.instance_label in df.columns: + labels.append(self.instance_label) + if self.match_label and self.match_label in df.columns: + labels.append(self.match_label) + return labels + + def _read_feature_learning_manifest(self, source_cv_idx: int) -> Dict[str, Any]: + manifest_path = self.train_root / "feature_learning" / f"feature_manifest_cv{source_cv_idx}.json" + if not manifest_path.exists(): + return {} + try: + with manifest_path.open("r") as f: + payload = json.load(f) + return payload if isinstance(payload, dict) else {} + except Exception as exc: + logger.warning("Failed to read feature-learning manifest for CV %s: %s", source_cv_idx, exc) + return {} + + def _read_feature_learning_outputs(self, source_cv_idx: int) -> List[str]: + manifest = self._read_feature_learning_manifest(source_cv_idx) + outputs = manifest.get("output_features") + if isinstance(outputs, list): + return [str(c) for c in outputs] + + features_path = self.train_root / "feature_learning" / f"features_cv{source_cv_idx}.txt" + if not features_path.exists(): + return [] + return [line.strip() for line in features_path.read_text().splitlines() if line.strip()] + + def _apply_feature_learning( + self, + data: pd.DataFrame, + source_cv_idx: int, + train_cv_df: pd.DataFrame, + ) -> pd.DataFrame: + fl_dir = self.train_root / "feature_learning" + if not fl_dir.exists(): + return data + + learned_cols = self._read_feature_learning_outputs(source_cv_idx) + fitted_path = fl_dir / f"fitted_learner_cv{source_cv_idx}.pickle" + if not fitted_path.exists(): + missing_learned = [c for c in learned_cols if c in train_cv_df.columns and c not in data.columns] + if missing_learned: + raise Exception( + "Cannot replay Phase 3 feature learning for replication: fitted learner artifact is missing " + f"for CV {source_cv_idx}. Re-run Phase 3 with fitted_learner artifacts before replication." + ) + return data + + learner = _safe_pickle_load(fitted_path, None) + if learner is None or not hasattr(learner, "transform"): + raise Exception(f"Invalid fitted feature-learning artifact: {fitted_path}") + + labels = self._label_columns(data) + x_data = data.drop(columns=[c for c in labels if c in data.columns], errors="ignore") + manifest = self._read_feature_learning_manifest(source_cv_idx) + input_features = manifest.get("input_features") + if isinstance(input_features, list) and input_features: + missing_inputs = [c for c in input_features if c not in x_data.columns] + if missing_inputs: + raise Exception( + "Replication data is missing Phase 3 input features for " + f"CV {source_cv_idx}: {', '.join(map(str, missing_inputs[:20]))}" + ) + x_for_transform = x_data[input_features].copy() + else: + x_for_transform = x_data.copy() + + z = learner.transform(x_for_transform) + if not isinstance(z, pd.DataFrame): + z = pd.DataFrame(z, index=data.index) + z = z.reset_index(drop=True) + + out_cols = learned_cols + if len(out_cols) != z.shape[1]: + namespace = str(manifest.get("namespace", "FL")) + out_cols = [f"{namespace}_PC{i + 1}" for i in range(z.shape[1])] + z.columns = out_cols + + keep_original = bool(manifest.get("keep_original_features", True)) + if keep_original: + x_out = pd.concat([x_data.reset_index(drop=True), z], axis=1) + else: + x_out = z + + label_df = data[[c for c in labels if c in data.columns]].reset_index(drop=True) + return pd.concat([label_df, x_out], axis=1) + + def _apply_imputation( + self, + data: pd.DataFrame, + feature_columns: Sequence[str], + source_cv_idx: int, + train_cv_df: pd.DataFrame, + categorical_features: Sequence[str], + quantitative_features: Sequence[str], + ) -> pd.DataFrame: + active_features = [c for c in feature_columns if c in data.columns] + if not active_features: + return data + + # 1) Categorical mode imputer from p2 + cat_path = self.train_root / "impute_scale" / f"categorical_imputer_cv{source_cv_idx}.pickle" + cat_imputer = _safe_pickle_load(cat_path, {}) + if isinstance(cat_imputer, dict): + for c, fill_val in cat_imputer.items(): + if c in active_features: + data[c] = data[c].fillna(fill_val) + + # 2) Numeric imputer from p2 + ord_path = self.train_root / "impute_scale" / f"ordinal_imputer_cv{source_cv_idx}.pickle" + ord_imputer = _safe_pickle_load(ord_path, None) + + transformed = False + if ord_imputer is not None and hasattr(ord_imputer, "transform"): + try: + x = data[active_features].copy() + expected_features = getattr(ord_imputer, "feature_names_in_", None) + if expected_features is not None: + expected_features = list(expected_features) + missing_expected = [c for c in expected_features if c not in x.columns] + if missing_expected: + raise ValueError( + f"Missing {len(missing_expected)} imputer-fit features (fallback imputation will be used)" + ) + x = x[expected_features] + + xt = ord_imputer.transform(x) + if isinstance(xt, pd.DataFrame): + for col in xt.columns: + if col in data.columns: + data[col] = xt[col].values + else: + xt_df = pd.DataFrame(xt, columns=list(x.columns), index=data.index) + for col in xt_df.columns: + if col in data.columns: + data[col] = xt_df[col].values + transformed = True + except Exception as exc: + logger.warning( + "Failed to apply ordinal imputer transform on replication CV %s: %s", + source_cv_idx, + exc, + ) + + if not transformed and isinstance(ord_imputer, dict): + # Legacy median-dict style: {feature: value} + if "id" not in ord_imputer: + for c, fill_val in ord_imputer.items(): + if c in active_features: + data[c] = data[c].fillna(fill_val) + transformed = True + + # Fallback for remaining NaNs in active feature columns. + if data[active_features].isnull().sum().sum() > 0: + train_features = [c for c in active_features if c in train_cv_df.columns] + train_num = train_cv_df[train_features].copy() if train_features else pd.DataFrame(index=train_cv_df.index) + for col in active_features: + if data[col].isnull().sum() == 0: + continue + if col in categorical_features: + source = train_num[col] if col in train_num.columns else data[col] + mode = source.mode(dropna=True) + if not mode.empty: + data[col] = data[col].fillna(mode.iloc[0]) + elif col in quantitative_features or (col in train_num.columns and is_numeric_dtype(train_num[col])): + source = train_num[col] if col in train_num.columns else data[col] + data[col] = data[col].fillna(source.median()) + else: + source = train_num[col] if col in train_num.columns else data[col] + mode = source.mode(dropna=True) + if not mode.empty: + data[col] = data[col].fillna(mode.iloc[0]) + + return data + + def _apply_scaling( + self, + data: pd.DataFrame, + feature_columns: Sequence[str], + source_cv_idx: int, + train_cv_df: pd.DataFrame, + ) -> pd.DataFrame: + active_features = [c for c in feature_columns if c in data.columns] + if not active_features: + return data + + scale_path = self.train_root / "impute_scale" / f"scaler_cv{source_cv_idx}.pickle" + scaler = _safe_pickle_load(scale_path, None) + + if scaler is not None and hasattr(scaler, "transform"): + try: + x = data[active_features].copy() + expected_features = getattr(scaler, "feature_names_in_", None) + if expected_features is not None: + expected_features = list(expected_features) + missing_expected = [c for c in expected_features if c not in x.columns] + if missing_expected: + raise ValueError( + f"Missing {len(missing_expected)} scaler-fit features (fallback scaling will be used)" + ) + x = x[expected_features] + + xt = scaler.transform(x) + if isinstance(xt, pd.DataFrame): + for col in xt.columns: + if col in data.columns: + data[col] = xt[col].values + else: + xt_df = pd.DataFrame(xt, columns=list(x.columns), index=data.index) + for col in xt_df.columns: + if col in data.columns: + data[col] = xt_df[col].values + return data + except Exception as exc: + logger.warning( + "Failed to apply scaler transform on replication CV %s: %s", + source_cv_idx, + exc, + ) + + # Fallback: if scaler object was not serializable with fit-state, use train-fold z-score. + train_features = [c for c in active_features if c in train_cv_df.columns] + train_x = train_cv_df[train_features].copy() if train_features else pd.DataFrame(index=train_cv_df.index) + for col in active_features: + if col not in train_x.columns or not is_numeric_dtype(train_x[col]): + continue + mean = pd.to_numeric(train_x[col], errors="coerce").mean() + std = pd.to_numeric(train_x[col], errors="coerce").std(ddof=0) + if std is None or np.isnan(std) or std == 0: + continue + data[col] = (pd.to_numeric(data[col], errors="coerce") - mean) / std + + return data + + def _load_training_feature_importance( + + self, + small_name: str, + source_cv_idx: int, + expected_len: int, + ) -> List[float]: + metrics_path = self.train_root / "model_evaluation" / "metrics_by_cv" / f"{small_name}_CV_{source_cv_idx}.json" + if not metrics_path.exists(): + return [0.0] * int(expected_len) + + try: + with metrics_path.open("r") as f: + payload = json.load(f) + fi = payload.get("feature_importance", []) + fi = [float(x) for x in fi] + except Exception: + fi = [0.0] * int(expected_len) + + if len(fi) < expected_len: + fi = fi + [0.0] * (expected_len - len(fi)) + elif len(fi) > expected_len: + fi = fi[:expected_len] + + return fi + + def _write_base_outputs( + self, + rep_cv_idx: int, + small_name: str, + metrics_dict: Dict[str, Any], + curves_dict: Optional[Dict[str, Any]], + fi_list: Sequence[float], + residual_test: Optional[np.ndarray] = None, + y_pred: Optional[np.ndarray] = None, + y_true: Optional[np.ndarray] = None, + ) -> None: + payload = { + "metrics": _jsonify(metrics_dict), + "feature_importance": _jsonify(list(fi_list)), + } + with (self.model_metrics_dir / f"{small_name}_CV_{rep_cv_idx}.json").open("w") as f: + json.dump(payload, f, indent=2) + + if curves_dict: + roc = curves_dict.get("roc", {}) + prc = curves_dict.get("prc", {}) + with (self.model_curves_dir / f"{small_name}_CV_{rep_cv_idx}_roc.json").open("w") as f: + json.dump(_jsonify(roc), f, indent=2) + with (self.model_curves_dir / f"{small_name}_CV_{rep_cv_idx}_prc.json").open("w") as f: + json.dump(_jsonify(prc), f, indent=2) + + if self.outcome_type == "Continuous" and residual_test is not None and y_pred is not None and y_true is not None: + # Keep p6 payload shape for compatibility with p8 residual plotting. + residual_payload = [ + np.array([], dtype=float), # train residual (not available in replication) + np.asarray(residual_test, dtype=float), + np.array([], dtype=float), # train predictions (not available) + np.asarray(y_pred, dtype=float), + np.array([], dtype=float), # y_train (not available) + np.asarray(y_true, dtype=float), + ] + with (self.model_pickled_metrics_dir / f"{small_name}_CV_{rep_cv_idx}_residuals.pickle").open("wb") as f: + pickle.dump(residual_payload, f) + + def _evaluate_ensembles( + self, + processed: pd.DataFrame, + fold_map: Sequence[Tuple[int, int]], + ) -> None: + src_pickled = self.train_root / "ensemble_evaluation" / "pickled_ensembles" + if not src_pickled.exists(): + return + + source_fold_ids = [source_cv for _, source_cv in fold_map] + ensemble_fold_map: Dict[str, set] = {} + for ens_pickle in sorted(src_pickled.glob("*.pickle")): + match = re.match(r"(.+?)_(\d+)\.pickle$", ens_pickle.name) + if not match: + continue + ens_id = match.group(1) + fold_id = int(match.group(2)) + ensemble_fold_map.setdefault(ens_id, set()).add(fold_id) + + # If ensemble pickles are present, enforce strict fold parity for each ensemble id. + for ens_id, folds in ensemble_fold_map.items(): + missing_folds = [cv for cv in source_fold_ids if cv not in folds] + if missing_folds: + raise Exception( + "Strict fold parity failed: missing ensemble pickles for " + f"ensemble={ens_id}, folds={missing_folds}" + ) + + self.ensemble_metrics_dir.mkdir(parents=True, exist_ok=True) + self.ensemble_curves_dir.mkdir(parents=True, exist_ok=True) + self.ensemble_pickled_dir.mkdir(parents=True, exist_ok=True) + + for rep_cv_idx, source_cv_idx in fold_map: + rep_test_path = self.cv_dir / f"{self.apply_name}_CV_{rep_cv_idx}_Test.csv" + if not rep_test_path.exists(): + raise Exception( + "Strict fold parity failed: missing replication CV test file " + f"{rep_test_path}" + ) + + test_df = pd.read_csv(rep_test_path, na_values="NA", sep=",") + eval_df = test_df.copy() + if self.instance_label and self.instance_label in eval_df.columns: + eval_df = eval_df.drop(columns=[self.instance_label]) + + if self.outcome_label not in eval_df.columns: + raise Exception( + "Strict fold parity failed: outcome label " + f"'{self.outcome_label}' missing in replication fold {rep_cv_idx}" + ) + + x_test = eval_df.drop(columns=[self.outcome_label]).values + y_test = eval_df[self.outcome_label].values + + for ens_id in sorted(ensemble_fold_map.keys()): + ens_pickle = src_pickled / f"{ens_id}_{source_cv_idx}.pickle" + if not ens_pickle.exists(): + raise Exception( + "Strict fold parity failed: missing ensemble pickle " + f"{ens_pickle}" + ) + + with ens_pickle.open("rb") as f: + model = pickle.load(f) + + # Keep a copy of ensemble pickle for traceability in replication outputs. + dst_pickle = self.ensemble_pickled_dir / f"{ens_id}_{rep_cv_idx}.pickle" + with dst_pickle.open("wb") as f: + pickle.dump(model, f) + + y_pred = model.predict(x_test) + metrics = _calc_basic_metrics(y_test, y_pred) + + roc_curve_dict = None + prc_curve_dict = None + roc_auc_val = None + prc_auc_val = None + aps_val = None + brier_val = None + + proba = None + if hasattr(model, "predict_proba"): + try: + proba = model.predict_proba(x_test) + except Exception as exc: + logger.warning("predict_proba failed for ensemble %s: %s", ens_id, exc) + proba = None + elif hasattr(model, "decision_function"): + try: + score = np.asarray(model.decision_function(x_test)) + if score.ndim == 1: + score = (score - score.min()) / (score.max() - score.min() + 1e-12) + proba = np.column_stack([1.0 - score, score]) + else: + s_min = score.min(axis=0, keepdims=True) + s_max = score.max(axis=0, keepdims=True) + proba = (score - s_min) / (s_max - s_min + 1e-12) + except Exception as exc: + logger.warning("decision_function failed for ensemble %s: %s", ens_id, exc) + proba = None + + if proba is not None: + classes = getattr(model, "classes_", None) + roc_curve_dict, prc_curve_dict, roc_auc_val, prc_auc_val, aps_val = _calc_curves_scores_from_proba( + y_test, + proba, + classes=classes, + ) + + try: + proba_arr = np.asarray(proba) + unique_classes = np.unique(y_test) + if proba_arr.ndim == 1 and len(unique_classes) == 2: + brier_val = brier_score_loss(y_test, proba_arr) + elif proba_arr.ndim == 2 and len(unique_classes) == 2 and proba_arr.shape[1] >= 2: + brier_val = brier_score_loss(y_test, proba_arr[:, 1]) + elif proba_arr.ndim == 2 and len(unique_classes) > 2: + brier_val = multiclass_brier_score(y_test, proba_arr) + except Exception: + brier_val = None + + if roc_auc_val is not None: + metrics["ROC AUC"] = float(roc_auc_val) + if prc_auc_val is not None: + metrics["PRC AUC"] = float(prc_auc_val) + if aps_val is not None: + metrics["PRC APS"] = float(aps_val) + if brier_val is not None: + metrics["Brier Score"] = float(brier_val) + + with (self.ensemble_metrics_dir / f"{ens_id}_CV_{rep_cv_idx}.json").open("w") as f: + json.dump(_jsonify(metrics), f, indent=2) + + if roc_curve_dict: + with (self.ensemble_curves_dir / f"{ens_id}_CV_{rep_cv_idx}_roc.json").open("w") as f: + json.dump(_jsonify(roc_curve_dict), f, indent=2) + if prc_curve_dict: + with (self.ensemble_curves_dir / f"{ens_id}_CV_{rep_cv_idx}_prc.json").open("w") as f: + json.dump(_jsonify(prc_curve_dict), f, indent=2) + + # ------------------------------------------------------------------ + # p8 on replication outputs + # ------------------------------------------------------------------ + + def _run_statistics(self, cv_partitions: int) -> None: + if self.outcome_type == "Continuous": + metric_weight = "explained_variance" + else: + metric_weight = "balanced_accuracy" + + # StatisticsPhaseJob writes completion flags under /jobsCompleted. + (self.rep_root.parent / "jobsCompleted").mkdir(parents=True, exist_ok=True) + + scoring_metric = self.scoring_metric + if self.outcome_type == "Continuous": + scoring_metric = "explained_variance" + + stats = StatisticsPhaseJob( + full_path=str(self.rep_root), + outcome_label=self.outcome_label, + outcome_type=self.outcome_type, + instance_label=self.instance_label, + scoring_metric=scoring_metric, + cv_partitions=cv_partitions, + top_features=40, + sig_cutoff=self.sig_cutoff, + metric_weight=metric_weight, + scale_data=self.scale_data, + exclude_plots=self.exclude_plots, + show_plots=self.show_plots, + include_ensembles=self.outcome_type in {"Binary", "Multiclass"}, + ) + stats.run() diff --git a/streamline/p11_reporting/p11_cli.py b/streamline/p11_reporting/p11_cli.py new file mode 100644 index 00000000..80072c0b --- /dev/null +++ b/streamline/p11_reporting/p11_cli.py @@ -0,0 +1,97 @@ +from __future__ import annotations + +import argparse +import logging + +from streamline.p11_reporting.p11_runner import P11Runner +from streamline.utils.run_commands import ( + add_run_command_args, + apply_saved_run_command, + save_run_command_from_args, + snapshot_args, +) + +logging.basicConfig(level=logging.INFO) + + +def _none_if_empty(val: str | None) -> str | None: + if val is None: + return None + text = str(val).strip() + if text == "" or text.lower() in {"none", "null"}: + return None + return text + + +def main(): + ap = argparse.ArgumentParser( + "STREAMLINE Phase 11 (Reporting)", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + + ap.add_argument("--experiment_path", default=None, help="Path to experiment output directory") + ap.add_argument("--output_path", default=None, help="Parent output directory") + ap.add_argument("--experiment_name", default=None, help="Experiment folder name") + ap.add_argument( + "--reporting_dir", + default=None, + help="Optional output directory for report artifacts (report_data.json, experiment-named PDF, figures)", + ) + ap.add_argument( + "--report_mode", + default="standard", + choices=["standard", "replication"], + help="Reporting scope: standard (training datasets) or replication (datasets under replication folders)", + ) + + ap.add_argument("--outcome_label", default=None) + ap.add_argument("--outcome_type", default=None) + ap.add_argument("--instance_label", default=None) + + ap.add_argument("--make_pdf", type=int, default=1, help="1 = export PDF; 0 = skip PDF") + ap.add_argument("--enable_plots", type=int, default=1, help="1 = generate missing plots; 0 = disable plot generation") + ap.add_argument( + "--reuse_existing_figures", + type=int, + default=1, + help="1 = reuse existing report PNGs when present; 0 = regenerate", + ) + + ap.add_argument( + "--run_cluster", + default="Serial", + help="Serial | Local | Parallel | BashSLURM | BashLSF | ", + ) + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", type=int, default=4) + add_run_command_args(ap) + + args = ap.parse_args() + args = apply_saved_run_command(ap, args, "p11_reporting") + run_command_args = snapshot_args(args) + + if not args.experiment_path and not (args.output_path and args.experiment_name): + ap.error("Provide --experiment_path OR both --output_path and --experiment_name") + + job = P11Runner( + output_path=_none_if_empty(args.output_path), + experiment_name=_none_if_empty(args.experiment_name), + experiment_path=_none_if_empty(args.experiment_path), + reporting_dir=_none_if_empty(args.reporting_dir), + report_mode=args.report_mode, + outcome_label=_none_if_empty(args.outcome_label), + outcome_type=_none_if_empty(args.outcome_type), + instance_label=_none_if_empty(args.instance_label), + make_pdf=bool(args.make_pdf), + enable_plots=bool(args.enable_plots), + reuse_existing_figures=bool(args.reuse_existing_figures), + run_cluster=args.run_cluster, + queue=args.queue, + reserved_memory=args.reserved_memory, + ) + job.run() + save_run_command_from_args(args, "p11_reporting", run_command_args, runner=job) + + +if __name__ == "__main__": + main() diff --git a/streamline/p11_reporting/p11_jobsubmit.py b/streamline/p11_reporting/p11_jobsubmit.py new file mode 100644 index 00000000..d171bba9 --- /dev/null +++ b/streamline/p11_reporting/p11_jobsubmit.py @@ -0,0 +1,85 @@ +from __future__ import annotations + +import argparse + +from streamline.p11_reporting.p11_runner import P11Runner + + +def _none_if_empty(val: str | None) -> str | None: + if val is None: + return None + val_str = str(val).strip() + if val_str == "" or val_str.lower() in {"none", "null"}: + return None + return val_str + + +def main(): + """ + Entry point for Phase 11 reporting when launched on a compute node via + a SLURM/LSF bash wrapper. + + This script intentionally forces run_cluster="Serial"; scheduler-level + parallelism is handled outside this process. + """ + ap = argparse.ArgumentParser( + "STREAMLINE Phase 11 (Reporting)", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + + ap.add_argument("--experiment_path", default=None, help="Path to experiment output directory") + ap.add_argument("--output_path", default=None, help="Parent output directory") + ap.add_argument("--experiment_name", default=None, help="Experiment folder name") + ap.add_argument( + "--reporting_dir", + default=None, + help="Optional output directory for report artifacts (report_data.json, experiment-named PDF, figures)", + ) + ap.add_argument( + "--report_mode", + default="standard", + choices=["standard", "replication"], + help="Reporting scope: standard (training datasets) or replication (datasets under replication folders)", + ) + + ap.add_argument("--outcome_label", default=None) + ap.add_argument("--outcome_type", default=None) + ap.add_argument("--instance_label", default=None) + + ap.add_argument("--make_pdf", type=int, default=1, help="1 = export PDF; 0 = skip PDF") + ap.add_argument("--enable_plots", type=int, default=1, help="1 = generate missing plots; 0 = disable plot generation") + ap.add_argument( + "--reuse_existing_figures", + type=int, + default=1, + help="1 = reuse existing report PNGs when present; 0 = regenerate", + ) + + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", type=int, default=4) + + args = ap.parse_args() + + if not args.experiment_path and not (args.output_path and args.experiment_name): + ap.error("Provide --experiment_path OR both --output_path and --experiment_name") + + P11Runner( + output_path=_none_if_empty(args.output_path), + experiment_name=_none_if_empty(args.experiment_name), + experiment_path=_none_if_empty(args.experiment_path), + reporting_dir=_none_if_empty(args.reporting_dir), + report_mode=args.report_mode, + outcome_label=_none_if_empty(args.outcome_label), + outcome_type=_none_if_empty(args.outcome_type), + instance_label=_none_if_empty(args.instance_label), + make_pdf=bool(args.make_pdf), + enable_plots=bool(args.enable_plots), + reuse_existing_figures=bool(args.reuse_existing_figures), + run_cluster="Serial", + queue=args.queue, + reserved_memory=args.reserved_memory, + ).run() + + +if __name__ == "__main__": + main() diff --git a/streamline/p11_reporting/p11_runner.py b/streamline/p11_reporting/p11_runner.py new file mode 100644 index 00000000..9ba41e11 --- /dev/null +++ b/streamline/p11_reporting/p11_runner.py @@ -0,0 +1,173 @@ +# streamline/p11_reporting/p11_runner.py +from __future__ import annotations + +import os +import shlex +import time +from pathlib import Path +from typing import Optional + +import dask +from dask.distributed import Client, LocalCluster + +from streamline.p11_reporting.reporting import ReportPhaseJob +from streamline.utils.cluster import get_cluster +from streamline.utils.runners import num_cores, run_dask_tasks, run_parallel_functions + + +class P11Runner: + """ + Phase 11 runner for experiment-level report generation. + + Supports both path styles: + - experiment_path + - output_path + experiment_name + """ + + def __init__( + self, + output_path: Optional[str] = None, + experiment_name: Optional[str] = None, + experiment_path: Optional[str] = None, + reporting_dir: Optional[str] = None, + report_mode: str = "standard", # standard | replication + outcome_label: Optional[str] = "Class", + outcome_type: Optional[str] = "Binary", + instance_label: Optional[str] = None, + make_pdf: bool = True, + enable_plots: bool = True, + reuse_existing_figures: bool = True, + run_cluster: str = "Serial", # Serial | Local | Parallel | BashSLURM | BashLSF | + queue: str = "defq", + reserved_memory: int = 4, + ): + if experiment_path: + self.exp_root = Path(experiment_path).resolve() + if output_path is None: + output_path = str(self.exp_root.parent) + if experiment_name is None: + experiment_name = self.exp_root.name + else: + if not output_path or not experiment_name: + raise ValueError("Provide experiment_path OR (output_path and experiment_name).") + self.exp_root = (Path(output_path) / experiment_name).resolve() + + if not self.exp_root.is_dir(): + raise FileNotFoundError(f"Experiment folder not found: {self.exp_root}") + + self.output_path = str(output_path) if output_path else str(self.exp_root.parent) + self.experiment_name = str(experiment_name) if experiment_name else self.exp_root.name + + report_mode_norm = str(report_mode or "standard").strip().lower() + if report_mode_norm not in {"standard", "replication"}: + raise ValueError("report_mode must be one of: standard, replication") + + # kwargs handed directly to ReportPhaseJob + self.kw = dict( + output_path=self.output_path, + experiment_name=self.experiment_name, + experiment_path=str(self.exp_root), + reporting_dir=reporting_dir, + report_mode=report_mode_norm, + outcome_label=outcome_label, + outcome_type=outcome_type, + instance_label=instance_label, + make_pdf=bool(make_pdf), + enable_plots=bool(enable_plots), + reuse_existing_figures=bool(reuse_existing_figures), + ) + + self.run_cluster = run_cluster or "Serial" + self.queue = queue + self.reserved_memory = int(reserved_memory) + + def run(self): + """Phase 11 is a single experiment-level job.""" + if self.run_cluster == "Serial": + self._run_one() + + elif self.run_cluster == "Local": + # Local dask (mainly for development on multi-core machines) + with LocalCluster(processes=True, n_workers=num_cores, threads_per_worker=1) as cluster: + with Client(cluster) as client: + run_dask_tasks([dask.delayed(self._run_one)()], client, label="Phase 11 Dask jobs") + + elif self.run_cluster == "Parallel": + run_parallel_functions([self._run_one], label="Phase 11 Parallel jobs") + + elif self.run_cluster in ("BashSLURM", "BashLSF"): + self._submit_bash() + + else: + # Named dask cluster (e.g. a shared HPC scheduler) + client: Client = get_cluster( + self.run_cluster, str(self.exp_root), self.queue, self.reserved_memory + ) + run_dask_tasks([dask.delayed(self._run_one)()], client, label="Phase 11 Dask jobs") + + def _run_one(self): + ReportPhaseJob(**self.kw).run() + + def _submit_bash(self): + """ + Submit a single experiment-level job via SLURM or LSF using p11_jobsubmit.py. + """ + job_ref = str(time.time()) + jobs = self.exp_root / "jobs" + logs = self.exp_root / "logs" + os.makedirs(jobs, exist_ok=True) + os.makedirs(logs, exist_ok=True) + + sh = jobs / f"P11_{job_ref}_run.sh" + launcher = "sbatch" if self.run_cluster == "BashSLURM" else "bsub <" + script = Path(__file__).with_name("p11_jobsubmit.py") + + args = [ + "python", + str(script), + "--experiment_path", + str(self.exp_root), + "--outcome_label", + str(self.kw.get("outcome_label") or ""), + "--outcome_type", + str(self.kw.get("outcome_type") or ""), + "--instance_label", + str(self.kw.get("instance_label") or ""), + "--make_pdf", + str(int(bool(self.kw.get("make_pdf", True)))), + "--enable_plots", + str(int(bool(self.kw.get("enable_plots", True)))), + "--reuse_existing_figures", + str(int(bool(self.kw.get("reuse_existing_figures", True)))), + "--queue", + str(self.queue), + "--reserved_memory", + str(int(self.reserved_memory)), + ] + + reporting_dir = self.kw.get("reporting_dir") + if reporting_dir: + args.extend(["--reporting_dir", str(reporting_dir)]) + args.extend(["--report_mode", str(self.kw.get("report_mode") or "standard")]) + + arg_str = " ".join(shlex.quote(a) for a in args) + + with sh.open("w", encoding="utf-8") as f: + f.write("#!/bin/bash\n") + if self.run_cluster == "BashSLURM": + f.write(f"#SBATCH -p {self.queue}\n") + f.write(f"#SBATCH --job-name={job_ref}\n") + f.write(f"#SBATCH --mem={self.reserved_memory}G\n") + f.write(f"#SBATCH -o {logs}/P11_{job_ref}.o\n") + f.write(f"#SBATCH -e {logs}/P11_{job_ref}.e\n") + f.write(f"srun {arg_str}\n") + else: # BashLSF + f.write(f"#BSUB -q {self.queue}\n") + f.write(f"#BSUB -J {job_ref}\n") + f.write(f"#BSUB -R \"rusage[mem={self.reserved_memory}G]\"\n") + f.write(f"#BSUB -M {self.reserved_memory}GB\n") + f.write(f"#BSUB -o {logs}/P11_{job_ref}.o\n") + f.write(f"#BSUB -e {logs}/P11_{job_ref}.e\n") + f.write(f"{arg_str}\n") + + os.system(f"{launcher} {sh}") diff --git a/streamline/p11_reporting/reporting.py b/streamline/p11_reporting/reporting.py new file mode 100644 index 00000000..bfb2c3c8 --- /dev/null +++ b/streamline/p11_reporting/reporting.py @@ -0,0 +1,4297 @@ +from __future__ import annotations + +import argparse +import csv +import importlib.metadata +import json +import logging +import math +import os +import pickle +import re +import shutil +import statistics +import time +from dataclasses import dataclass +from pathlib import Path +from typing import Any, Dict, Iterable, List, Optional, Sequence, Set, Tuple + +from streamline.p6_modeling.utils.categorical import NATIVE_CATEGORICAL_MODELS_DEFAULT +from streamline.utils.run_commands import RUN_COMMANDS_FILENAME, load_run_commands + +logger = logging.getLogger(__name__) + + +try: + from fpdf import FPDF # type: ignore +except Exception: # pragma: no cover + FPDF = None # type: ignore + + +PHASE_LABELS = { + "1": "EDA / Exploratory Analysis", + "2": "Scale and Impute", + "3": "Feature Learning", + "4": "Feature Selection", + "5": "Modeling", + "8": "Stats Summary", +} + +RUN_COMMAND_PHASE_ORDER = [ + "p1_data_process", + "p2_impute_scale", + "p3_feature_learning", + "p4_feature_importance", + "p5_feature_selection", + "p6_modeling", + "p7_ensembles", + "p8_summary_statistics", + "p9_compare_datasets", + "p10_replication", + "p11_reporting", +] + +RUN_COMMAND_PHASE_LABELS = { + "p1_data_process": "P1 Data Processing", + "p2_impute_scale": "P2 Impute / Scale", + "p3_feature_learning": "P3 Feature Learning", + "p4_feature_importance": "P4 Feature Importance", + "p5_feature_selection": "P5 Feature Selection", + "p6_modeling": "P6 Modeling", + "p7_ensembles": "P7 Ensembles", + "p8_summary_statistics": "P8 Summary Statistics", + "p9_compare_datasets": "P9 Dataset Comparison", + "p10_replication": "P10 Replication", + "p11_reporting": "P11 Reporting", +} + +LEGACY_NOT_RECORDED = "Not recorded in legacy output" +NOT_RUN = "Not run" +NO_VALUE = object() + +ENSEMBLE_SMALL_NAME_TO_ID = { + "HEV": "hard_voting", + "SEV": "soft_voting", + "STK_LR": "stack_lr", + "STK_DT": "stack_dt", + "STK_RF": "stack_rf", +} + +CLASSIFICATION_METRICS = [ + "Balanced Accuracy", + "Accuracy", + "F1 Score", + "Sensitivity (Recall)", + "Precision (PPV)", + "Brier Score", + "ROC AUC", + "PRC AUC", + "PRC APS", +] + +REGRESSION_METRICS = [ + "Explained Variance", + "Pearson Correlation", + "Mean Absolute Error", + "Mean Squared Error", + "Median Absolute Error", + "Max Error", +] + +REGRESSION_DEFAULT_METRIC = "explained_variance" + +CLASSIFICATION_ONLY_METRIC_KEYS = { + "balanced_accuracy", + "accuracy", + "f1", + "f1_macro", + "recall", + "recall_macro", + "precision", + "precision_macro", + "roc_auc", + "roc_auc_macro", + "average_precision", + "average_precision_macro", + "prc_auc", + "prc_aps", +} + +METRIC_DIRECTION_HIGHER_IS_BETTER = { + "Balanced Accuracy": True, + "Accuracy": True, + "F1 Score": True, + "Sensitivity (Recall)": True, + "Precision (PPV)": True, + "ROC AUC": True, + "PRC AUC": True, + "PRC APS": True, + "Brier Score": False, + "Explained Variance": True, + "Pearson Correlation": True, + "Mean Absolute Error": False, + "Mean Squared Error": False, + "Median Absolute Error": False, + "Max Error": False, +} + +METRIC_JSON_KEYS = { + "Balanced Accuracy": "balanced_accuracy", + "Accuracy": "accuracy", + "F1 Score": "f1", + "Sensitivity (Recall)": "recall_macro", + "Precision (PPV)": "precision_macro", + "Brier Score": "brier_score", + "ROC AUC": "roc_auc_macro", + "PRC AUC": "average_precision_macro", + "PRC APS": "average_precision_macro", + "Explained Variance": "explained_variance", + "Pearson Correlation": "pearson_correlation", + "Mean Absolute Error": "mean_absolute_error", + "Mean Squared Error": "mean_squared_error", + "Median Absolute Error": "median_absolute_error", + "Max Error": "max_error", +} + +FEATURE_LEARNING_METHODS: List[Dict[str, Any]] = [ + { + "key": "mutual_info", + "label": "Mutual Information", + "dir_aliases": ["mutualinformation", "mutual_information"], + "score_patterns": ["mutualinformation_scores_cv_*.csv", "mutual_information_scores_cv_*.csv"], + }, + { + "key": "multisurf", + "label": "MultiSURF", + "dir_aliases": ["multisurf", "multi_surf"], + "score_patterns": ["multisurf_scores_cv_*.csv", "multi_surf_scores_cv_*.csv"], + }, + { + "key": "multisurfstar", + "label": "MultiSURFstar", + "dir_aliases": ["multisurfstar", "multisurf_star", "multi_surfstar", "multi_surf_star"], + "score_patterns": ["multisurfstar_scores_cv_*.csv", "multisurf_star_scores_cv_*.csv"], + }, +] + + +def _now_iso_local() -> str: + return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) + + +def _try_streamline_version() -> str: + try: + return importlib.metadata.version("streamline") + except Exception: + return "unknown" + + +def _first_existing(paths: Sequence[Path]) -> Optional[Path]: + for p in paths: + if p.is_file(): + return p + return None + + +def _safe_float(value: Any) -> Optional[float]: + try: + if value is None: + return None + text = str(value).strip() + if text == "": + return None + return float(text) + except Exception: + return None + + +def _format_number(value: Any, *, is_pvalue: bool = False) -> str: + f = _safe_float(value) + if f is None: + return str(value) if value is not None else "" + if not math.isfinite(f): + return str(f) + if is_pvalue and abs(f) < 0.001 and f != 0: + return f"{f:.2e}" + rounded = round(f, 3) + if abs(rounded) < 0.0005: + return "0" + if abs(rounded - round(rounded)) < 1e-12: + return str(int(round(rounded))) + text = f"{rounded:.3f}".rstrip("0").rstrip(".") + if text == "-0": + return "0" + return text + + +def _is_pvalue_col(name: str) -> bool: + n = name.strip().lower() + return n in {"p", "p-value", "p_value", "pvalue"} or "p-value" in n + + +def _is_numeric_text(value: str) -> bool: + try: + float(value) + return True + except Exception: + return False + + +def _shorten(text: str, width: int = 46) -> str: + if len(text) <= width: + return text + return text[: max(0, width - 3)] + "..." + + + +def _linspace(start: float, end: float, num: int) -> List[float]: + if num <= 1: + return [start] + step = (end - start) / float(num - 1) + return [start + i * step for i in range(num)] + + +def _auc_trapezoid(x: Sequence[float], y: Sequence[float]) -> float: + if len(x) < 2 or len(y) < 2 or len(x) != len(y): + return 0.0 + total = 0.0 + for i in range(1, len(x)): + dx = x[i] - x[i - 1] + total += dx * (y[i] + y[i - 1]) * 0.5 + return total + + +def _interp_sorted(x: Sequence[float], y: Sequence[float], x_new: Sequence[float]) -> List[float]: + if not x or not y or len(x) != len(y): + return [0.0 for _ in x_new] + + pairs = sorted(zip(x, y), key=lambda t: t[0]) + xs = [pairs[0][0]] + ys = [pairs[0][1]] + for px, py in pairs[1:]: + if px == xs[-1]: + ys[-1] = py + else: + xs.append(px) + ys.append(py) + + out: List[float] = [] + j = 0 + n = len(xs) + for xv in x_new: + if xv <= xs[0]: + out.append(ys[0]) + continue + if xv >= xs[-1]: + out.append(ys[-1]) + continue + while j + 1 < n and xs[j + 1] < xv: + j += 1 + x0, x1 = xs[j], xs[j + 1] + y0, y1 = ys[j], ys[j + 1] + if x1 == x0: + out.append(y1) + else: + t = (xv - x0) / (x1 - x0) + out.append(y0 + t * (y1 - y0)) + return out + + +@dataclass +class ReportPaths: + reporting_dir: Path + data_json: Path + pdf: Path + figures_dir: Path + + +def safe_report_filename_part(value: Any) -> str: + text = re.sub(r"[^A-Za-z0-9._-]+", "_", str(value or "").strip()).strip("._-") + return text or "STREAMLINE" + + +@dataclass +class TableData: + columns: List[str] + rows: List[Dict[str, str]] + + +if FPDF is not None: + + class _StreamlinePDF(FPDF): # type: ignore[misc] + def __init__(self, footer_text: str): + super().__init__(orientation="P", unit="mm", format="A4") + self.footer_text = footer_text + + def footer(self): + self.set_y(-10) + self.set_font("Times", "I", 7) + self.cell(0, 4, self.footer_text, border=0, ln=0, align="L") + self.set_font("Times", "", 8) + self.cell(0, 4, f"Page {self.page_no()}/{{nb}}", border=0, ln=0, align="R") + +else: + + class _StreamlinePDF: # pragma: no cover + def __init__(self, *_args, **_kwargs): + raise ImportError("fpdf2 is required for PDF rendering. Install `fpdf2`.") + + +class ReportPhaseJob: + """ + STREAMLINE Testing Data Evaluation Report generator. + + This implementation covers binary/multiclass/regression outputs and + follows the master reporting specification provided by the user. + """ + + def __init__( + self, + output_path: Optional[str] = None, + experiment_name: Optional[str] = None, + experiment_path: Optional[str] = None, + reporting_dir: Optional[str] = None, + report_mode: str = "standard", # standard | replication + outcome_label: Optional[str] = None, + outcome_type: Optional[str] = None, + instance_label: Optional[str] = None, + make_pdf: bool = True, + enable_plots: bool = True, + reuse_existing_figures: bool = True, + ): + assert (output_path and experiment_name) or experiment_path, ( + "Provide (output_path, experiment_name) or experiment_path." + ) + + if experiment_path: + self.exp_root = Path(experiment_path).resolve() + self.output_path = str(self.exp_root.parent) + self.experiment_name = self.exp_root.name + else: + self.output_path = str(output_path) + self.experiment_name = str(experiment_name) + self.exp_root = (Path(self.output_path) / self.experiment_name).resolve() + + if not self.exp_root.is_dir(): + raise FileNotFoundError(f"Experiment folder not found: {self.exp_root}") + + self.outcome_label = outcome_label + self.outcome_type = outcome_type + self.instance_label = instance_label + self.report_mode = str(report_mode or "standard").strip().lower() + if self.report_mode not in {"standard", "replication"}: + raise ValueError("report_mode must be one of: standard, replication") + self.make_pdf = make_pdf + self.enable_plots = enable_plots + self.reuse_existing_figures = reuse_existing_figures + self.job_start_time: Optional[float] = None + self.reporting_dir_override = Path(reporting_dir).resolve() if reporting_dir else None + self.paths = self._init_paths() + + self._mpl_ready: Optional[bool] = None + + def _init_paths(self) -> ReportPaths: + if self.reporting_dir_override: + reporting_dir = self.reporting_dir_override + else: + if self.report_mode == "replication": + reporting_dir = self.exp_root / "reporting_replication" + else: + reporting_dir = self.exp_root / "reporting" + figures_dir = reporting_dir / "figures" + reporting_dir.mkdir(exist_ok=True) + figures_dir.mkdir(parents=True, exist_ok=True) + return ReportPaths( + reporting_dir=reporting_dir, + data_json=reporting_dir / "report_data.json", + pdf=reporting_dir / self.report_pdf_filename(), + figures_dir=figures_dir, + ) + + def report_pdf_filename(self) -> str: + experiment = safe_report_filename_part(self.experiment_name) + if self.report_mode == "replication": + return f"{experiment}_STREAMLINE_Replication_Report.pdf" + return f"{experiment}_STREAMLINE_Report.pdf" + + def _read_pickle_if_exists(self, path: Path) -> Optional[Dict[str, Any]]: + try: + if path.is_file(): + blob = pickle.load(path.open("rb")) + if isinstance(blob, dict): + return blob + except Exception as exc: + logger.warning("Failed reading pickle %s: %r", path, exc) + return None + + def _latest_run_params(self, run_params: Dict[str, Any]) -> Dict[str, Any]: + if not run_params: + return {} + try: + key = sorted(run_params.keys())[-1] + val = run_params.get(key) + if isinstance(val, dict): + return val + except Exception: + pass + return {} + + def load_run_command_context(self) -> Dict[str, Any]: + path = self.exp_root / RUN_COMMANDS_FILENAME + store = load_run_commands(self.exp_root) + phases_blob = store.get("phases", {}) if isinstance(store, dict) else {} + phases = phases_blob if isinstance(phases_blob, dict) else {} + + records: Dict[str, Dict[str, Any]] = {} + for phase, phase_store in phases.items(): + if not isinstance(phase_store, dict): + continue + latest = phase_store.get("latest", {}) + if not isinstance(latest, dict): + continue + args = latest.get("args") or {} + safe_args = json.loads(json.dumps(args, default=str)) if isinstance(args, dict) else {} + records[str(phase)] = { + "phase": str(phase), + "label": RUN_COMMAND_PHASE_LABELS.get(str(phase), str(phase)), + "updated_at": latest.get("updated_at", ""), + "command": latest.get("command", ""), + "args": safe_args, + } + + ordered_phases = [ + phase + for phase in RUN_COMMAND_PHASE_ORDER + if phase in records + ] + sorted( + phase + for phase in records + if phase not in set(RUN_COMMAND_PHASE_ORDER) + ) + latest_phase = "" + latest_updated_at = "" + for phase in ordered_phases: + updated = str(records[phase].get("updated_at") or "") + if updated >= latest_updated_at: + latest_phase = phase + latest_updated_at = updated + + return { + "present": path.is_file() and bool(records), + "path": str(path), + "recorded_phase_count": len(records), + "recorded_phases": ordered_phases, + "latest_phase": latest_phase, + "latest_phase_label": RUN_COMMAND_PHASE_LABELS.get(latest_phase, latest_phase), + "latest_updated_at": latest_updated_at, + "records": records, + } + + def phase_args_from_records(self, records: Dict[str, Any], phase: str) -> Dict[str, Any]: + record = records.get(phase, {}) if isinstance(records, dict) else {} + args = record.get("args", {}) if isinstance(record, dict) else {} + return args if isinstance(args, dict) else {} + + def value_is_present(self, value: Any) -> bool: + return value is not None and value != "" + + def first_present_value(self, *values: Any, default: Any = NO_VALUE) -> Any: + for value in values: + if self.value_is_present(value): + return value + if default is not NO_VALUE: + return default + return None + + def phase_summary_value( + self, + phase_ran: bool, + *values: Any, + default: Any = NO_VALUE, + ) -> Any: + if not phase_ran: + return NOT_RUN + value = self.first_present_value(*values) + if self.value_is_present(value): + return value + if default is not NO_VALUE: + return default + return LEGACY_NOT_RECORDED + + def truthy_config_value(self, value: Any) -> Optional[bool]: + if value in (NOT_RUN, LEGACY_NOT_RECORDED) or not self.value_is_present(value): + return None + if isinstance(value, bool): + return value + if isinstance(value, (int, float)): + return bool(value) + text = str(value).strip().lower() + if text in {"1", "true", "yes", "y", "on"}: + return True + if text in {"0", "false", "no", "n", "off"}: + return False + return None + + def report_is_regression(self, metadata: Dict[str, Any], dataset_blocks: Sequence[Dict[str, Any]]) -> bool: + outcome_type = str(metadata.get("Outcome Type") or "").strip().lower() + if outcome_type in {"continuous", "regression", "numeric", "real", "float"}: + return True + return any(str(ds.get("task_type") or "").strip().lower() == "regression" for ds in dataset_blocks) + + def report_metric_for_outcome(self, value: Any, is_regression: bool, *, default: str) -> Any: + if value in (NOT_RUN, LEGACY_NOT_RECORDED): + return value + if not self.value_is_present(value): + return default + if not is_regression: + return value + + metric = str(value).strip() + metric_key = metric.lower().replace(" ", "_").replace("-", "_") + if metric_key in CLASSIFICATION_ONLY_METRIC_KEYS: + return default + return value + + def categorical_handling_summary( + self, + *, + p1_ran: bool, + p6_ran: bool, + p1: Dict[str, Any], + p6: Dict[str, Any], + metadata_pickle: Dict[str, Any], + ) -> Any: + one_hot = self.phase_summary_value( + p1_ran, + p1.get("one_hot_encoding"), + metadata_pickle.get("One Hot Encoding"), + default=True, + ) + bypass = self.phase_summary_value( + p6_ran, + p6.get("bypass_one_hot_for_native_models"), + default=True, + ) + native_models = self.phase_summary_value( + p6_ran, + p6.get("native_categorical_models"), + default=NATIVE_CATEGORICAL_MODELS_DEFAULT, + ) + + one_hot_bool = self.truthy_config_value(one_hot) + bypass_bool = self.truthy_config_value(bypass) + native_text = self.report_value(native_models) + + if one_hot == NOT_RUN and bypass == NOT_RUN: + return NOT_RUN + if one_hot_bool is True and bypass_bool is True: + return f"One-hot encoding enabled; native categorical models may bypass it ({native_text})." + if one_hot_bool is True: + return "One-hot encoding enabled for all modeling features." + if one_hot_bool is False and bypass_bool is True: + return f"One-hot encoding disabled; categorical features are passed to native-capable models ({native_text})." + if one_hot_bool is False: + return "One-hot encoding disabled; no native categorical bypass was recorded." + if bypass_bool is True: + return f"Native categorical bypass enabled for {native_text}." + return LEGACY_NOT_RECORDED + + def feature_summary_page_title(self, *, continued: bool = False) -> str: + title = "Feature Learning, Importance, and Selection" + return f"{title} (continued)" if continued else title + + def performance_page_title(self) -> str: + if self.report_mode == "replication": + return "Replication Performance" + return "Cross-Validation Performance" + + def evaluation_page_title(self, ds: Dict[str, Any]) -> str: + is_regression = str(ds.get("task_type") or "").strip().lower() == "regression" + if self.report_mode == "replication": + return "Replication Regression Evaluation" if is_regression else "Replication ROC/PRC Evaluation" + return "Regression Evaluation" if is_regression else "ROC/PRC Evaluation" + + def run_params_by_phase(self, run_params_all: Dict[str, Any]) -> Dict[str, Dict[str, Any]]: + if not isinstance(run_params_all, dict): + return {} + + by_phase: Dict[str, Dict[str, Any]] = {} + for timestamp in sorted(run_params_all): + params = run_params_all.get(timestamp) + if not isinstance(params, dict): + continue + + phase = str(params.get("phase") or "") + if not phase and any( + key in params + for key in ( + "data_path", + "n_splits", + "partition_method", + "one_hot_encoding", + "categorical_features", + "quantitative_features", + ) + ): + phase = "p1_data_process" + if not phase: + continue + by_phase[phase] = params + return by_phase + + def merged_phase_args( + self, + command_args: Dict[str, Any], + run_param_args: Dict[str, Any], + ) -> Dict[str, Any]: + merged = dict(run_param_args or {}) + for key, value in (command_args or {}).items(): + if self.value_is_present(value): + merged[key] = value + return merged + + def summary_dataset_paths(self) -> Dict[str, List[Path]]: + primary = self._list_primary_datasets() + replication = self._list_replication_datasets() + return { + "primary": primary, + "replication": replication, + } + + def summary_cv_split_count(self, dataset_dirs: Sequence[Path]) -> Optional[int]: + for ds_dir in dataset_dirs: + cv_dir = ds_dir / "CVDatasets" + if cv_dir.is_dir(): + count = len(list(cv_dir.glob("*_Train.csv"))) + if count: + return count + return None + + def summary_feature_importance_models(self, dataset_dirs: Sequence[Path]) -> List[str]: + models: Set[str] = set() + for ds_dir in dataset_dirs: + root = ds_dir / "feature_importance" + if not root.is_dir(): + continue + for child in sorted(root.iterdir()): + if child.is_dir() and any(child.iterdir()): + models.add(child.name) + return sorted(models) + + def summary_model_ids(self, dataset_dirs: Sequence[Path]) -> List[str]: + ids: Set[str] = set() + for ds_dir in dataset_dirs: + for path in (ds_dir / "models" / "pickledModels").glob("*.pickle"): + model_id = re.sub(r"_(?:CV_)?\d+$", "", path.stem) + if model_id: + ids.add(model_id) + if ids: + continue + table = self._read_csv_table(ds_dir / "model_evaluation" / "Summary_performance_mean.csv") + if table and table.rows and table.columns: + name_col = table.columns[0] + for row in table.rows: + name = str(row.get(name_col, "")).strip() + if name: + ids.add(name) + return sorted(ids) + + def summary_ensemble_ids(self, dataset_dirs: Sequence[Path]) -> List[str]: + ids: Set[str] = set() + for ds_dir in dataset_dirs: + for path in (ds_dir / "ensemble_evaluation" / "metrics_by_cv").glob("*.json"): + small = re.sub(r"_CV_\d+$", "", path.stem) + ids.add(ENSEMBLE_SMALL_NAME_TO_ID.get(small, small)) + for path in (ds_dir / "ensemble_evaluation" / "pickled_ensembles").glob("*.pickle"): + small = re.sub(r"_\d+$", "", path.stem) + ids.add(ENSEMBLE_SMALL_NAME_TO_ID.get(small, small)) + return sorted(ids) + + def summary_optuna_trials(self, dataset_dirs: Sequence[Path]) -> Optional[str]: + counts: List[int] = [] + for ds_dir in dataset_dirs: + for path in (ds_dir / "models" / "optuna_trials").glob("*_optuna_trials*.csv"): + try: + with path.open("r", newline="", encoding="utf-8-sig") as handle: + row_count = max(sum(1 for _ in handle) - 1, 0) + counts.append(row_count) + except Exception as exc: + logger.warning("Could not count Optuna trials in %s: %r", path, exc) + if not counts: + return None + total = sum(counts) + return f"{total} completed across {len(counts)} model/CV runs" + + def summary_replication_labels(self, replication_dirs: Sequence[Path]) -> str: + labels: List[str] = [] + for rep_dir in replication_dirs[:5]: + parent = rep_dir.parents[1].name if len(rep_dir.parents) > 1 else "" + labels.append(f"{rep_dir.name} from {parent}" if parent else rep_dir.name) + if len(replication_dirs) > 5: + labels.append(f"... ({len(replication_dirs)} total)") + return ", ".join(labels) + + def report_value(self, value: Any, *, max_len: int = 120) -> str: + if value is None: + return "None" + if isinstance(value, bool): + return "True" if value else "False" + if isinstance(value, (list, tuple, set)): + items = [str(item) for item in value] + if not items: + return "None" + if len(items) > 5: + text = ", ".join(items[:5]) + f", ... ({len(items)} total)" + else: + text = ", ".join(items) + elif isinstance(value, dict): + text = json.dumps(value, sort_keys=True, default=str) + else: + text = str(value) + + text = " ".join(text.split()) + if text == "": + return "None" + return _shorten(text, max_len) + + def add_summary_line( + self, + lines: List[str], + label: str, + value: Any, + *, + max_len: int = 120, + ) -> None: + lines.append(f"{label}: {self.report_value(value, max_len=max_len)}") + + def build_dataset_summary_lines(self, dataset_blocks: Sequence[Dict[str, Any]]) -> List[str]: + if not dataset_blocks: + return ["No datasets discovered"] + + lines = [ + f"Dataset Count: {len(dataset_blocks)}", + ] + for ds in dataset_blocks[:6]: + dataset_id = str(ds.get("dataset_id") or "") + dataset_name = str(ds.get("dataset_name") or "") + dataset_path = str(ds.get("dataset_path") or "") + if "/replication/" in dataset_path: + parent = Path(dataset_path).parents[1].name if len(Path(dataset_path).parents) > 1 else "" + suffix = f" from {parent}" if parent else "" + label = f"{dataset_id} = {dataset_name}{suffix}" + else: + label = f"{dataset_id} = {dataset_name}" + lines.append(_shorten(label, 120)) + if len(dataset_blocks) > 6: + lines.append(f"... {len(dataset_blocks) - 6} more datasets") + return lines + + def build_run_command_summary( + self, + *, + metadata: Dict[str, Any], + metadata_pickle: Dict[str, Any], + run_params_all: Dict[str, Any], + run_params: Dict[str, Any], + dataset_blocks: Sequence[Dict[str, Any]], + ) -> Dict[str, Any]: + context = self.load_run_command_context() + records = context.get("records", {}) + run_phase_args = self.run_params_by_phase(run_params_all) + + p1 = self.merged_phase_args(self.phase_args_from_records(records, "p1_data_process"), run_phase_args.get("p1_data_process", {})) + p2 = self.merged_phase_args(self.phase_args_from_records(records, "p2_impute_scale"), run_phase_args.get("p2_impute_scale", {})) + p3 = self.merged_phase_args(self.phase_args_from_records(records, "p3_feature_learning"), run_phase_args.get("p3_feature_learning", {})) + p4 = self.merged_phase_args(self.phase_args_from_records(records, "p4_feature_importance"), run_phase_args.get("p4_feature_importance", {})) + p5 = self.merged_phase_args(self.phase_args_from_records(records, "p5_feature_selection"), run_phase_args.get("p5_feature_selection", {})) + p6 = self.merged_phase_args(self.phase_args_from_records(records, "p6_modeling"), run_phase_args.get("p6_modeling", {})) + p7 = self.merged_phase_args(self.phase_args_from_records(records, "p7_ensembles"), run_phase_args.get("p7_ensembles", {})) + p8 = self.merged_phase_args(self.phase_args_from_records(records, "p8_summary_statistics"), run_phase_args.get("p8_summary_statistics", {})) + p10 = self.merged_phase_args(self.phase_args_from_records(records, "p10_replication"), run_phase_args.get("p10_replication", {})) + + summary_paths = self.summary_dataset_paths() + primary_dirs = summary_paths["primary"] + replication_dirs = summary_paths["replication"] + recovered_cv_splits = self.summary_cv_split_count(primary_dirs) + recovered_fi_models = self.summary_feature_importance_models(primary_dirs) + recovered_model_ids = self.summary_model_ids(primary_dirs) + recovered_ensemble_ids = self.summary_ensemble_ids(primary_dirs) + recovered_optuna_trials = self.summary_optuna_trials(primary_dirs) + recovered_replication_labels = self.summary_replication_labels(replication_dirs) + is_regression = self.report_is_regression(metadata, dataset_blocks) + default_metric = REGRESSION_DEFAULT_METRIC if is_regression else "balanced_accuracy" + + p1_ran = bool(p1 or primary_dirs or metadata_pickle) + p2_ran = bool(p2 or any((ds / "impute_scale").is_dir() and any((ds / "impute_scale").iterdir()) for ds in primary_dirs)) + p3_ran = bool(p3 or any((ds / "feature_learning").is_dir() and any((ds / "feature_learning").iterdir()) for ds in primary_dirs)) + p4_ran = bool(p4 or recovered_fi_models) + p5_ran = bool(p5 or any((ds / "feature_selection" / "InformativeFeatureSummary.csv").is_file() for ds in primary_dirs)) + p6_ran = bool(p6 or recovered_model_ids) + p7_ran = bool(p7 or recovered_ensemble_ids) + p8_ran = bool(p8 or any((ds / "runtime" / "runtime_Stats.txt").is_file() or (ds / "model_evaluation" / "Summary_performance_mean.csv").is_file() for ds in primary_dirs)) + p10_ran = bool(p10 or replication_dirs) + + overview: List[str] = [] + self.add_summary_line(overview, "Report Mode", self.report_mode) + self.add_summary_line(overview, "Experiment Name", self.experiment_name) + self.add_summary_line(overview, "Outcome Label", metadata.get("Outcome Label")) + self.add_summary_line(overview, "Outcome Type", metadata.get("Outcome Type")) + self.add_summary_line(overview, "Instance Label", metadata.get("Instance Label")) + self.add_summary_line(overview, "STREAMLINE Version", _try_streamline_version()) + + data_cv: List[str] = [] + self.add_summary_line(data_cv, "Data Path", self.phase_summary_value(p1_ran, p1.get("data_path"), metadata_pickle.get("Data Path"))) + self.add_summary_line(data_cv, "CV Splits", self.phase_summary_value(p1_ran, p1.get("n_splits"), p6.get("n_splits"), metadata_pickle.get("CV Partitions"), run_params.get("CV Partitions"), recovered_cv_splits)) + self.add_summary_line(data_cv, "Partition Method", self.phase_summary_value(p1_ran, p1.get("partition_method"), metadata_pickle.get("Partition Method"), run_params.get("Partition Method"), default="Stratified")) + self.add_summary_line(data_cv, "Categorical Cutoff", self.phase_summary_value(p1_ran, p1.get("categorical_cutoff"), metadata_pickle.get("Categorical Cutoff"), default=10)) + self.add_summary_line(data_cv, "Ignored Features", self.phase_summary_value(p1_ran, p1.get("ignore_features"), metadata_pickle.get("Ignored Features"), default=[])) + self.add_summary_line(data_cv, "Categorical Features", self.phase_summary_value(p1_ran, p1.get("categorical_features"), metadata_pickle.get("Specified Categorical Features"), default=[]), max_len=120) + self.add_summary_line(data_cv, "Quantitative Features", self.phase_summary_value(p1_ran, p1.get("quantitative_features"), metadata_pickle.get("Specified Quantitative Features"), default=[]), max_len=120) + + processing: List[str] = [] + self.add_summary_line(processing, "Scale Data", self.phase_summary_value(p2_ran, p2.get("scale_data"), metadata_pickle.get("Use Data Scaling"), default=True)) + self.add_summary_line(processing, "Impute Data", self.phase_summary_value(p2_ran, p2.get("impute_data"), metadata_pickle.get("Use Data Imputation"), default=True)) + self.add_summary_line(processing, "Multivariate Imputation", self.phase_summary_value(p2_ran, p2.get("multi_impute"), metadata_pickle.get("Use Multivariate Imputation"), default=False)) + self.add_summary_line(processing, "Overwrite CV", self.phase_summary_value(p2_ran, p2.get("overwrite_cv"), metadata_pickle.get("Overwrite CV Datasets"), default=True)) + self.add_summary_line(processing, "SMOTE", self.phase_summary_value(p2_ran, p2.get("smote"), metadata_pickle.get("Use SMOTE"), default=False)) + self.add_summary_line(processing, "SMOTE Method", self.phase_summary_value(p2_ran, p2.get("smote_method"), metadata_pickle.get("P2 SMOTE Method"), default="auto")) + self.add_summary_line(processing, "Missingness Cutoff", self.phase_summary_value(p1_ran, p1.get("featureeng_missingness"), metadata_pickle.get("Engineering Missingness Cutoff"), default=0.5)) + self.add_summary_line(processing, "Correlation Removal", self.phase_summary_value(p1_ran, p1.get("correlation_removal_threshold"), metadata_pickle.get("Correlation Removal Threshold"), default=1.0)) + + feature_selection: List[str] = [] + self.add_summary_line(feature_selection, "Feature Learner", self.phase_summary_value(p3_ran, p3.get("learner_id"), metadata_pickle.get("P3 Learner Id"), default="pca")) + self.add_summary_line(feature_selection, "Keep Original Features", self.phase_summary_value(p3_ran, p3.get("keep_original_features"), metadata_pickle.get("P3 Keep Original Features"), default=True)) + self.add_summary_line(feature_selection, "FI Models", self.phase_summary_value(p4_ran, p4.get("models"), metadata_pickle.get("P4 Models"), recovered_fi_models, default="all registered FI methods")) + self.add_summary_line(feature_selection, "FI Params", self.phase_summary_value(p4_ran, p4.get("models_params"), metadata_pickle.get("P4 Models Params"), default={}), max_len=130) + self.add_summary_line(feature_selection, "FI Instance Subset", self.phase_summary_value(p4_ran, p4.get("instance_subset"), metadata_pickle.get("P4 Instance Subset"), default="Not used")) + self.add_summary_line(feature_selection, "P5 Algorithms", self.phase_summary_value(p5_ran, p5.get("algorithms"), recovered_fi_models, default="auto")) + self.add_summary_line(feature_selection, "Max Features To Keep", self.phase_summary_value(p5_ran, p5.get("max_features_to_keep"), metadata_pickle.get("Max Features to Keep"), default=2000)) + self.add_summary_line(feature_selection, "Top Features To Display", self.phase_summary_value(p5_ran or p8_ran, p5.get("top_features"), p8.get("top_features"), metadata_pickle.get("Top Model Features to Display"), default=20)) + + modeling: List[str] = [] + self.add_summary_line(modeling, "P6 Outcome Type", self.phase_summary_value(p6_ran, p6.get("outcome_type"), p6.get("model_type"), metadata.get("Outcome Type"))) + self.add_summary_line(modeling, "Models", self.phase_summary_value(p6_ran, p6.get("models"), recovered_model_ids, default="auto/default")) + scoring_metric = self.phase_summary_value(p6_ran or p8_ran, p6.get("scoring_metric"), p8.get("scoring_metric"), metadata_pickle.get("Primary Metric"), default=default_metric) + self.add_summary_line(modeling, "Scoring Metric", self.report_metric_for_outcome(scoring_metric, is_regression, default=default_metric)) + self.add_summary_line(modeling, "Metric Direction", self.phase_summary_value(p6_ran, p6.get("metric_direction"), default="maximize")) + if self.value_is_present(p6.get("n_trials")): + self.add_summary_line(modeling, "Optuna Trials Requested", p6.get("n_trials")) + if self.value_is_present(p6.get("timeout")): + self.add_summary_line(modeling, "Optuna Timeout Seconds", p6.get("timeout")) + self.add_summary_line(modeling, "Optuna Trials Completed", self.phase_summary_value(p6_ran, recovered_optuna_trials, default="0 completed")) + self.add_summary_line(modeling, "Training Subsample", self.phase_summary_value(p6_ran, p6.get("training_subsample"), default=0)) + self.add_summary_line(modeling, "Calibration", self.phase_summary_value(p6_ran, p6.get("calibrate"), default=False)) + self.add_summary_line(modeling, "Categorical Handling", self.categorical_handling_summary(p1_ran=p1_ran, p6_ran=p6_ran, p1=p1, p6=p6, metadata_pickle=metadata_pickle), max_len=150) + self.add_summary_line(modeling, "Ensembles", self.phase_summary_value(p7_ran, p7.get("ensembles"), recovered_ensemble_ids, default="hard_voting,soft_voting,stack_lr")) + self.add_summary_line(modeling, "Base Models", self.phase_summary_value(p7_ran, p7.get("base_models"), p6.get("models"), recovered_model_ids, default="auto/default")) + + replication: List[str] = [] + if self.report_mode == "replication": + self.add_summary_line(replication, "Replication Data Path", self.phase_summary_value(p10_ran, p10.get("rep_data_path"), recovered_replication_labels), max_len=130) + self.add_summary_line(replication, "Training Dataset For Rep", self.phase_summary_value(p10_ran, p10.get("dataset_for_rep"), [ds.name for ds in primary_dirs]), max_len=130) + self.add_summary_line(replication, "Match Label", self.phase_summary_value(p10_ran, p10.get("match_label"), metadata_pickle.get("Match Label"), default="None")) + self.add_summary_line(replication, "P10 Show Plots", self.phase_summary_value(p10_ran, p10.get("show_plots"), default=False)) + self.add_summary_line(replication, "Rep Report Focus", "Held-out/external replication folders only") + + reporting: List[str] = [] + self.add_summary_line(reporting, "Report Mode", self.report_mode) + self.add_summary_line(reporting, "Make PDF", self.make_pdf) + self.add_summary_line(reporting, "Enable Plots", self.enable_plots) + self.add_summary_line(reporting, "Reuse Existing Figures", self.reuse_existing_figures) + p8_metric_weight = self.phase_summary_value(p8_ran, p8.get("metric_weight"), default=default_metric) + self.add_summary_line(reporting, "P8 Metric Weight", self.report_metric_for_outcome(p8_metric_weight, is_regression, default=default_metric)) + self.add_summary_line(reporting, "P8 Include Ensembles", self.phase_summary_value(p8_ran, p8.get("include_ensembles"), default=True)) + + dataset_lines = self.build_dataset_summary_lines(dataset_blocks) + + sections = [ + {"title": "Run Overview", "lines": overview}, + {"title": "P1 Data Processing and CV", "lines": data_cv}, + {"title": "P1-P2 EDA, Scaling, Imputation, and SMOTE", "lines": processing}, + {"title": "P3-P5 Feature Learning, Importance, and Selection", "lines": feature_selection}, + {"title": "P6-P8 Modeling, Ensembles, and Metrics", "lines": modeling}, + ] + if replication: + sections.append({"title": "P10 Replication Settings", "lines": replication}) + sections.extend( + [ + {"title": "P11 Reporting Settings", "lines": reporting}, + {"title": "Target Dataset(s)", "lines": dataset_lines}, + ] + ) + + return { + **context, + "sections": sections, + } + + def _read_csv_table(self, path: Path) -> Optional[TableData]: + if not path.is_file(): + return None + try: + with path.open("r", newline="", encoding="utf-8-sig") as f: + reader = csv.reader(f) + header = next(reader, None) + if not header: + return None + columns = [(h or "").strip() for h in header] + if columns and columns[0] == "": + columns[0] = "Algorithm" + rows: List[Dict[str, str]] = [] + for raw in reader: + if not raw: + continue + if len(raw) < len(columns): + raw = raw + [""] * (len(columns) - len(raw)) + row = {columns[i]: (raw[i] if i < len(raw) else "").strip() for i in range(len(columns))} + rows.append(row) + return TableData(columns=columns, rows=rows) + except Exception as exc: + logger.warning("Failed reading csv %s: %r", path, exc) + return None + + def _read_json(self, path: Path) -> Optional[Dict[str, Any]]: + if not path.is_file(): + return None + try: + return json.loads(path.read_text()) + except Exception: + return None + + def _report_figure_candidates(self, filename: str, ds_dir: Optional[Path] = None) -> List[Path]: + """ + Candidate locations for figures generated by reporting itself. + """ + candidates: List[Path] = [ + self.paths.figures_dir / filename, + self.exp_root / "reporting" / "figures" / filename, + self.exp_root / "reporting_replication" / "figures" / filename, + ] + if ds_dir is not None: + # Legacy dataset-local reporting location kept for backwards compatibility. + candidates.append(ds_dir / "reporting" / "figures" / filename) + + # Keep order stable but remove duplicates. + out: List[Path] = [] + seen: Set[Path] = set() + for p in candidates: + rp = p.resolve() if p.exists() else p + if rp in seen: + continue + seen.add(rp) + out.append(p) + return out + + def _reuse_generated_report_figure(self, filename: str, ds_dir: Optional[Path] = None) -> Optional[Path]: + """ + Reuse a previously generated reporting figure across standard/replication modes. + If found in another report folder, copy into the current report folder for portability. + """ + current = self.paths.figures_dir / filename + if current.is_file(): + return current + + existing = _first_existing(self._report_figure_candidates(filename, ds_dir=ds_dir)) + if existing is None: + return None + + try: + if existing.resolve() != current.resolve(): + current.parent.mkdir(parents=True, exist_ok=True) + shutil.copy2(existing, current) + return current + except Exception as exc: + logger.warning("Could not copy reused figure %s -> %s: %r", existing, current, exc) + return existing + + def _list_primary_datasets(self) -> List[Path]: + datasets: List[Path] = [] + ignore = { + "jobs", + "logs", + "jobsCompleted", + "dask_logs", + "runtime", + "DatasetComparisons", + "reporting", + "reporting_replication", + } + for p in sorted(self.exp_root.iterdir()): + if not p.is_dir(): + continue + if p.name in ignore: + continue + if (p / "exploratory").is_dir() and (p / "model_evaluation").is_dir(): + datasets.append(p) + return datasets + + def _list_replication_datasets(self) -> List[Path]: + datasets: List[Path] = [] + seen: Set[Path] = set() + + # Primary expected layout: + # //replication// + for train_ds in self._list_primary_datasets(): + rep_root = train_ds / "replication" + if not rep_root.is_dir(): + continue + for rep_ds in sorted(rep_root.iterdir()): + if not rep_ds.is_dir(): + continue + if (rep_ds / "exploratory").is_dir() and (rep_ds / "model_evaluation").is_dir(): + r = rep_ds.resolve() + if r not in seen: + datasets.append(rep_ds) + seen.add(r) + + # Fallback: search recursively for replication folders that match expected artifacts. + if not datasets: + for rep_root in sorted(self.exp_root.glob("**/replication")): + if not rep_root.is_dir(): + continue + for rep_ds in sorted(rep_root.iterdir()): + if not rep_ds.is_dir(): + continue + if (rep_ds / "exploratory").is_dir() and (rep_ds / "model_evaluation").is_dir(): + r = rep_ds.resolve() + if r not in seen: + datasets.append(rep_ds) + seen.add(r) + + return datasets + + def _list_datasets(self) -> List[Path]: + if self.report_mode == "replication": + return self._list_replication_datasets() + return self._list_primary_datasets() + + def _is_regression_from_values(self, values: Sequence[str]) -> bool: + cleaned = [v for v in values if str(v).strip() != ""] + if not cleaned: + return False + numeric = [] + for v in cleaned: + fv = _safe_float(v) + if fv is None: + return False + numeric.append(fv) + unique = len(set(numeric)) + unique_fraction = unique / float(len(numeric)) + return unique > 20 or unique_fraction > 0.2 + + def _find_target_column(self, header: Sequence[str], metadata: Dict[str, Any]) -> str: + cols = [str(c).strip() for c in header if str(c).strip() != ""] + if not cols: + return header[0] if header else "" + + low_map = {c.lower(): c for c in cols} + + def _match_col(name: Any) -> Optional[str]: + txt = str(name or "").strip() + if txt == "": + return None + if txt in cols: + return txt + return low_map.get(txt.lower()) + + instance_col = _match_col(self.instance_label) or _match_col(metadata.get("Instance Label")) + outcome_col = _match_col(self.outcome_label) or _match_col(metadata.get("Outcome Label")) + outcome_type = str(self.outcome_type or metadata.get("Outcome Type") or "").strip().lower() + + # Use explicit outcome label only when it does not collide with instance id. + if outcome_col and (not instance_col or outcome_col.lower() != instance_col.lower()): + return outcome_col + + is_regression_like = outcome_type in {"continuous", "regression", "numeric", "real", "float"} + if is_regression_like: + semantic_tokens = ("target", "outcome", "score", "response", "phenotype", "label", "y") + id_like_names = {"class", "id", "instanceid", "instance_id", "sampleid", "sample_id"} + + for col in cols: + cl = col.lower() + if instance_col and cl == instance_col.lower(): + continue + if cl in id_like_names: + continue + if any(tok in cl for tok in semantic_tokens): + return col + + for col in cols: + cl = col.lower() + if instance_col and cl == instance_col.lower(): + continue + if cl in id_like_names: + continue + if cl.endswith("_id") or cl.endswith("id") or "instance" in cl: + continue + return col + + class_col = _match_col("Class") + if class_col: + return class_col + + if outcome_col: + return outcome_col + + if instance_col: + for col in cols: + if col.lower() != instance_col.lower(): + return col + + return cols[0] + + def _detect_task_from_train(self, ds_dir: Path, metadata: Dict[str, Any]) -> str: + cv_dir = ds_dir / "CVDatasets" + train_files = sorted(cv_dir.glob("*_Train.csv")) + if not train_files: + return "Binary Classification" + train = train_files[0] + try: + with train.open("r", newline="", encoding="utf-8-sig") as f: + reader = csv.reader(f) + header = next(reader, None) + if not header: + return "Binary Classification" + target = self._find_target_column(header, metadata) + try: + idx = list(header).index(target) + except ValueError: + idx = 0 + values: List[str] = [] + for row in reader: + if idx < len(row): + values.append(row[idx].strip()) + if len(values) >= 5000: + break + unique_vals = sorted(set([v for v in values if v != ""])) + unique = len(unique_vals) + if self._is_regression_from_values(values): + return "Regression" + if unique == 2: + return "Binary Classification" + if unique > 2: + return "Multiclass Classification" + except Exception as exc: + logger.warning("Task detection fallback failed for %s: %r", ds_dir, exc) + return "Binary Classification" + + def _detect_task_type(self, ds_dir: Path, metadata: Dict[str, Any]) -> str: + # Rule priority: + # 1) ClassCounts.csv if clearly binary. + # 2) ClassCounts with high-cardinality numeric labels can indicate regression. + # 3) Otherwise infer from *_Train.csv target values. + cc = self._read_csv_table(ds_dir / "exploratory" / "ClassCounts.csv") + if cc and cc.rows: + label_col = cc.columns[0] + labels = [row.get(label_col, "") for row in cc.rows if row.get(label_col, "").strip() != ""] + unique = len(set(labels)) + if unique == 2: + return "Binary Classification" + if unique > 2: + # Keep ClassCounts-driven behavior aligned with classification first. + # Only treat as regression here when cardinality is clearly continuous-like. + if len(set(labels)) > 20 and all(_safe_float(v) is not None for v in labels): + return "Regression" + return "Multiclass Classification" + return self._detect_task_from_train(ds_dir, metadata) + + def _metric_list_for_task(self, task_type: str) -> List[str]: + if task_type == "Regression": + return REGRESSION_METRICS[:] + return CLASSIFICATION_METRICS[:] + + def _metric_default_distribution(self, task_type: str, columns: Sequence[str]) -> Optional[str]: + if task_type == "Regression": + if "Pearson Correlation" in columns: + return "Pearson Correlation" + if "Mean Absolute Error" in columns: + return "Mean Absolute Error" + return columns[0] if columns else None + if "Balanced Accuracy" in columns: + return "Balanced Accuracy" + if "Accuracy" in columns: + return "Accuracy" + return columns[0] if columns else None + + def _find_algorithm_col(self, columns: Sequence[str]) -> str: + preferred = {"algorithm", "ml algorithm", "model", "ensemble"} + for c in columns: + if c.strip().lower() in preferred: + return c + return columns[0] if columns else "Algorithm" + + def _extract_class_count_info(self, class_counts: Optional[TableData]) -> Tuple[List[str], List[float]]: + if not class_counts or not class_counts.rows: + return [], [] + label_col = class_counts.columns[0] + count_col = class_counts.columns[1] if len(class_counts.columns) > 1 else class_counts.columns[0] + labels: List[str] = [] + counts: List[float] = [] + for row in class_counts.rows: + label = row.get(label_col, "") + count = _safe_float(row.get(count_col, "")) + if label.strip() == "" or count is None: + continue + labels.append(label) + counts.append(count) + return labels, counts + + @staticmethod + def positive_label_text(values: Sequence[str]) -> str: + cleaned = [str(v).strip() for v in values if str(v).strip() != ""] + if not cleaned: + return "1" + if "1" in cleaned: + return "1" + if "True" in cleaned: + return "True" + if "true" in cleaned: + return "true" + try: + return sorted(set(cleaned), key=lambda x: float(x))[-1] + except Exception: + return sorted(set(cleaned))[-1] + + def no_skill_from_outcome_folds( + self, + folds: Sequence[Sequence[str]], + task_type: Optional[str] = None, + class_count_labels: Optional[Sequence[str]] = None, + ) -> Optional[float]: + non_empty = [ + [str(v).strip() for v in fold if str(v).strip() != ""] + for fold in folds + ] + non_empty = [fold for fold in non_empty if fold] + if not non_empty: + return None + + all_values = [value for fold in non_empty for value in fold] + labels = sorted(set(all_values)) + if "multiclass" in str(task_type or "").lower() or len(labels) > 2: + class_count = max(len(labels), len(class_count_labels or []), 1) + return max(1e-6, min(1.0, 1.0 / float(class_count))) + + positive = self.positive_label_text(all_values) + fold_rates = [ + sum(1 for value in fold if value == positive) / float(len(fold)) + for fold in non_empty + ] + if not fold_rates: + return None + return max(1e-6, min(1.0, sum(fold_rates) / float(len(fold_rates)))) + + def cv_test_outcome_folds(self, ds_dir: Optional[Path], outcome_label: str) -> List[List[str]]: + if ds_dir is None: + return [] + cv_dir = ds_dir / "CVDatasets" + if not cv_dir.is_dir(): + return [] + + folds: List[List[str]] = [] + for path in sorted(cv_dir.glob(f"{ds_dir.name}_CV_*_Test.csv")): + try: + with path.open("r", newline="", encoding="utf-8-sig") as f: + reader = csv.DictReader(f) + fieldnames = reader.fieldnames or [] + low = {name.lower(): name for name in fieldnames} + target = outcome_label if outcome_label in fieldnames else low.get(outcome_label.lower()) + if not target: + continue + values = [ + str(row.get(target, "")).strip() + for row in reader + if str(row.get(target, "")).strip() != "" + ] + if values: + folds.append(values) + except Exception as exc: + logger.warning("Could not read CV outcomes for no-skill baseline from %s: %r", path, exc) + return folds + + def _classification_no_skill( + self, + class_counts: Optional[TableData], + ds_dir: Optional[Path] = None, + outcome_label: str = "Class", + task_type: Optional[str] = None, + ) -> float: + cv_baseline = self.no_skill_from_outcome_folds( + self.cv_test_outcome_folds(ds_dir, outcome_label), + task_type=task_type, + class_count_labels=self._extract_class_count_info(class_counts)[0], + ) + if cv_baseline is not None: + return cv_baseline + + labels, counts = self._extract_class_count_info(class_counts) + if not counts: + return 0.5 + total = sum(counts) + if total <= 0: + return 0.5 + if len(labels) == 2: + # Prefer class label "1" if available, else second class. + if "1" in labels: + idx = labels.index("1") + return max(1e-6, min(1.0, counts[idx] / total)) + return max(1e-6, min(1.0, counts[1] / total)) + return max(1e-6, min(1.0, 1.0 / float(len(labels)))) + + def _mpl_ok(self) -> bool: + if not self.enable_plots: + return False + if self._mpl_ready is not None: + return self._mpl_ready + try: + mpl_cfg = self.paths.reporting_dir / ".mplconfig" + mpl_cfg.mkdir(parents=True, exist_ok=True) + mpl_cache = self.paths.reporting_dir / ".cache" + mpl_cache.mkdir(parents=True, exist_ok=True) + os.environ.setdefault("MPLCONFIGDIR", str(mpl_cfg)) + os.environ.setdefault("XDG_CACHE_HOME", str(mpl_cache)) + import matplotlib # type: ignore + + matplotlib.use("Agg") + matplotlib.rcParams.update( + { + "font.family": "sans-serif", + "font.sans-serif": ["DejaVu Sans", "Arial", "Helvetica"], + "axes.titlesize": 10, + "axes.titleweight": "normal", + "axes.labelsize": 9, + "xtick.labelsize": 8, + "ytick.labelsize": 8, + "legend.fontsize": 8, + } + ) + self._mpl_ready = True + except Exception as exc: + logger.warning("Matplotlib not available. Figure auto-generation disabled: %r", exc) + self._mpl_ready = False + return self._mpl_ready + + def _save_simple_placeholder(self, out: Path, title: str, body: str) -> Optional[str]: + if self._mpl_ok(): + try: + import matplotlib.pyplot as plt # type: ignore + + out.parent.mkdir(parents=True, exist_ok=True) + fig, ax = plt.subplots(figsize=(7.5, 4.0)) + ax.axis("off") + ax.text(0.5, 0.50, body, ha="center", va="center", fontsize=10) + fig.tight_layout() + fig.savefig(out, dpi=180) + plt.close(fig) + return str(out) + except Exception as exc: + logger.warning("Matplotlib placeholder figure failed for %s: %r", out, exc) + return None + + def _plot_missingness_top25(self, table: Optional[TableData], out: Path, title: str) -> Optional[str]: + if not table or not table.rows: + return None + low = {c.lower(): c for c in table.columns} + feature_col = low.get("feature") or low.get("variable") or table.columns[0] + value_col = low.get("count") or low.get("missing_count") or low.get("missingcount") or table.columns[-1] + rows: List[Tuple[str, float]] = [] + for row in table.rows: + feat = row.get(feature_col, "") + val = _safe_float(row.get(value_col, "")) + if feat and val is not None: + rows.append((feat, val)) + if not rows: + return None + rows = sorted(rows, key=lambda x: x[1], reverse=True)[:25] + labels = [x[0] for x in rows][::-1] + vals = [x[1] for x in rows][::-1] + + if self._mpl_ok(): + try: + import matplotlib.pyplot as plt # type: ignore + + out.parent.mkdir(parents=True, exist_ok=True) + fig_h = max(4.0, 0.18 * len(labels)) + fig, ax = plt.subplots(figsize=(8.0, fig_h)) + ax.barh(labels, vals, color="#4C78A8") + ax.set_xlabel(value_col) + ax.set_ylabel("Feature") + fig.tight_layout() + fig.savefig(out, dpi=180) + plt.close(fig) + return str(out) + except Exception as exc: + logger.warning("Missingness plot generation failed with matplotlib: %r", exc) + return None + + def _plot_class_balance(self, table: Optional[TableData], out: Path, title: str) -> Optional[str]: + if not table or not table.rows: + return None + labels, counts = self._extract_class_count_info(table) + if not counts: + return None + + if self._mpl_ok(): + try: + import matplotlib.pyplot as plt # type: ignore + + out.parent.mkdir(parents=True, exist_ok=True) + fig, ax = plt.subplots(figsize=(7.2, 4.4)) + ax.bar(labels, counts, color="#59A14F") + ax.set_xlabel("Class") + ax.set_ylabel("Count") + for tick in ax.get_xticklabels(): + tick.set_rotation(35) + tick.set_ha("right") + fig.tight_layout() + fig.savefig(out, dpi=180) + plt.close(fig) + return str(out) + except Exception as exc: + logger.warning("Class balance plot generation failed with matplotlib: %r", exc) + return None + + def _plot_target_distribution(self, ds_dir: Path, metadata: Dict[str, Any], out: Path, title: str) -> Optional[str]: + cv_dir = ds_dir / "CVDatasets" + train_files = sorted(cv_dir.glob("*_Train.csv")) + if not train_files: + return None + try: + with train_files[0].open("r", newline="", encoding="utf-8-sig") as f: + reader = csv.reader(f) + header = next(reader, None) + if not header: + return None + target = self._find_target_column(header, metadata) + idx = list(header).index(target) if target in header else 0 + vals: List[float] = [] + for row in reader: + if idx < len(row): + fv = _safe_float(row[idx].strip()) + if fv is not None: + vals.append(fv) + if not vals: + return None + if self._mpl_ok(): + import matplotlib.pyplot as plt # type: ignore + + out.parent.mkdir(parents=True, exist_ok=True) + fig, ax = plt.subplots(figsize=(7.2, 4.4)) + bins = min(40, max(12, int(round(math.sqrt(len(vals)))))) + ax.hist(vals, bins=bins, histtype="bar", color="#E15759", alpha=0.9, edgecolor="#FFFFFF", linewidth=0.6) + ax.set_xlabel("Target value") + ax.set_ylabel("Frequency") + fig.tight_layout() + fig.savefig(out, dpi=180) + plt.close(fig) + return str(out) + except Exception as exc: + logger.warning("Target distribution plot generation failed with matplotlib path: %r", exc) + return None + + def _figure_path_exploratory_correlation_matrix(self, ds_dir: Path) -> Optional[Path]: + reused = self._reuse_generated_report_figure(f"{ds_dir.name}_corr_matrix.png", ds_dir=ds_dir) \ + if self.reuse_existing_figures else None + return _first_existing( + [ + ds_dir / "exploratory" / "FeatureCorrelationMatrix.png", + ds_dir / "exploratory" / "FeatureCorrelation.png", + ds_dir / "exploratory" / "CorrelationMatrix.png", + ds_dir / "exploratory" / "CorrelationHeatmap.png", + ds_dir / "exploratory" / "feature_correlation" / "CorrelationMatrix.png", + ds_dir / "exploratory" / "feature_correlation" / "FeatureCorrelationMatrix.png", + ds_dir / "exploratory" / "FeatureCorrelation" / "CorrelationMatrix.png", + reused if reused is not None else (self.paths.figures_dir / f"{ds_dir.name}_corr_matrix.png"), + ] + ) + + def _find_exploratory_correlation_csv(self, ds_dir: Path) -> Optional[Path]: + return _first_existing( + [ + ds_dir / "exploratory" / "FeatureCorrelations.csv", + ds_dir / "exploratory" / "FeatureCorrelationMatrix.csv", + ds_dir / "exploratory" / "CorrelationMatrix.csv", + ds_dir / "exploratory" / "FeatureCorrelation.csv", + ds_dir / "exploratory" / "feature_correlation" / "CorrelationMatrix.csv", + ds_dir / "exploratory" / "FeatureCorrelation" / "CorrelationMatrix.csv", + ds_dir / "exploratory" / "initial" / "FeatureCorrelations.csv", + ] + ) + + def _read_correlation_matrix_csv(self, path: Path) -> Tuple[List[str], List[List[float]]]: + labels: List[str] = [] + matrix: List[List[float]] = [] + try: + with path.open("r", newline="", encoding="utf-8-sig") as f: + rows = list(csv.reader(f)) + if not rows: + return labels, matrix + + header = rows[0] + has_row_label_col = bool(header) and (header[0].strip() == "" or header[0].strip().lower() in {"feature", "variable", "var", "unnamed: 0"}) + col_labels = [h.strip() for h in (header[1:] if has_row_label_col else header)] + if not col_labels: + return labels, matrix + + for idx, row in enumerate(rows[1:]): + if not row: + continue + if has_row_label_col and len(row) >= 2: + row_label = row[0].strip() or f"R{idx+1}" + vals_raw = row[1:] + else: + row_label = col_labels[idx] if idx < len(col_labels) else f"R{idx+1}" + vals_raw = row + vals: List[float] = [] + for j, v in enumerate(vals_raw): + fv = _safe_float(v) + if fv is None or math.isnan(fv): + # Keep matrix dense for plotting. + if row_label in col_labels and j < len(col_labels) and col_labels[j] == row_label: + fv = 1.0 + else: + fv = 0.0 + vals.append(float(fv)) + if vals: + matrix.append(vals) + labels.append(row_label) + + if not matrix: + return [], [] + + # Make matrix rectangular and then square by clipping/padding. + max_cols = max(len(r) for r in matrix) + for r in matrix: + if len(r) < max_cols: + r.extend([0.0] * (max_cols - len(r))) + + n = min(len(matrix), max_cols, len(col_labels)) + matrix = [row[:n] for row in matrix[:n]] + labels = col_labels[:n] if len(col_labels) >= n else labels[:n] + return labels, matrix + except Exception as exc: + logger.warning("Could not read correlation matrix CSV %s: %r", path, exc) + return [], [] + + def _plot_correlation_matrix_from_csv(self, csv_path: Path, out: Path, title: str) -> Optional[str]: + labels, matrix = self._read_correlation_matrix_csv(csv_path) + if not labels or not matrix: + return None + if self._mpl_ok(): + try: + import matplotlib.pyplot as plt # type: ignore + + n = len(labels) + fig_size = min(11.0, max(5.8, 0.18 * n)) + out.parent.mkdir(parents=True, exist_ok=True) + fig, ax = plt.subplots(figsize=(fig_size, fig_size)) + img = ax.imshow(matrix, cmap="coolwarm", vmin=-1.0, vmax=1.0, aspect="equal", interpolation="nearest") + if n <= 30: + ax.set_xticks(list(range(n))) + ax.set_yticks(list(range(n))) + ax.set_xticklabels(labels, fontsize=6, rotation=90) + ax.set_yticklabels(labels, fontsize=6) + else: + ax.set_xticks([]) + ax.set_yticks([]) + ax.tick_params(length=0) + cbar = fig.colorbar(img, ax=ax, fraction=0.046, pad=0.04) + cbar.ax.tick_params(labelsize=7) + fig.tight_layout() + fig.savefig(out, dpi=180) + plt.close(fig) + return str(out) + except Exception as exc: + logger.warning("Correlation matrix plot generation failed with matplotlib for %s: %r", csv_path, exc) + return None + + def _parse_mutual_info_scores(self, ds_dir: Path) -> List[Tuple[str, float]]: + candidates = [ + ds_dir / "feature_importance" / "mutualinformation", + ds_dir / "feature_importance" / "mutual_information", + ds_dir / "feature_selection" / "mutualinformation", + ds_dir / "feature_selection" / "mutual_information", + ] + score_map: Dict[str, List[float]] = {} + for base in candidates: + if not base.is_dir(): + continue + for path in sorted(base.glob("mutualinformation_scores_cv_*.csv")): + table = self._read_csv_table(path) + if not table or not table.rows: + continue + low = {c.lower(): c for c in table.columns} + fcol = low.get("feature") or table.columns[0] + scol = low.get("score") or table.columns[-1] + for row in table.rows: + feat = row.get(fcol, "").strip() + score = _safe_float(row.get(scol, "")) + if feat and score is not None: + score_map.setdefault(feat, []).append(score) + medians: List[Tuple[str, float]] = [] + for feat, vals in score_map.items(): + if vals: + medians.append((feat, statistics.median(vals))) + medians.sort(key=lambda t: t[1], reverse=True) + return medians + + def _plot_mutual_info_top(self, ds_dir: Path, out: Path, top_n: int = 20) -> Optional[str]: + data = self._parse_mutual_info_scores(ds_dir) + if not data: + return None + data = data[:top_n] + labels = [d[0] for d in data][::-1] + vals = [d[1] for d in data][::-1] + if self._mpl_ok(): + try: + import matplotlib.pyplot as plt # type: ignore + + out.parent.mkdir(parents=True, exist_ok=True) + fig_side = max(5.8, min(7.2, 0.25 * len(labels) + 2.4)) + labels = [ + f"{rank}. {feature}" + for rank, (feature, _score) in enumerate(data, start=1) + ][::-1] + fig, ax = plt.subplots(figsize=(fig_side, fig_side)) + ax.barh(labels, vals, color="#86A8CA", height=0.55) + ax.set_xlabel("Median score across CV folds") + ax.set_ylabel("Ranked feature order") + ax.grid(axis="x", color="#E1E5EA", linewidth=0.7) + ax.spines["top"].set_visible(False) + ax.spines["right"].set_visible(False) + fig.subplots_adjust(left=0.42, right=0.97, top=0.96, bottom=0.12) + fig.savefig(out, dpi=180) + plt.close(fig) + return str(out) + except Exception as exc: + logger.warning("Mutual information plot generation failed with matplotlib: %r", exc) + return None + + def _parse_feature_scores_method( + self, + ds_dir: Path, + *, + dir_aliases: Sequence[str], + score_patterns: Sequence[str], + ) -> List[Tuple[str, float]]: + score_map: Dict[str, List[float]] = {} + for root_name in ("feature_importance", "feature_selection"): + root = ds_dir / root_name + if not root.is_dir(): + continue + for alias in dir_aliases: + method_dir = root / alias + if not method_dir.is_dir(): + continue + files: List[Path] = [] + for pattern in score_patterns: + files.extend(sorted(method_dir.glob(pattern))) + if not files: + files.extend(sorted(method_dir.glob("*scores_cv_*.csv"))) + + for path in files: + table = self._read_csv_table(path) + if not table or not table.rows: + continue + low = {c.lower(): c for c in table.columns} + fcol = low.get("feature") or table.columns[0] + scol = low.get("score") or low.get("importance") or table.columns[-1] + for row in table.rows: + feat = row.get(fcol, "").strip() + score = _safe_float(row.get(scol, "")) + if feat and score is not None: + score_map.setdefault(feat, []).append(score) + + medians: List[Tuple[str, float]] = [] + for feat, vals in score_map.items(): + if vals: + medians.append((feat, statistics.median(vals))) + medians.sort(key=lambda t: t[1], reverse=True) + return medians + + def _plot_feature_scores_method_top( + self, + ds_dir: Path, + out: Path, + *, + dir_aliases: Sequence[str], + score_patterns: Sequence[str], + top_n: int = 20, + ) -> Optional[str]: + data = self._parse_feature_scores_method( + ds_dir, + dir_aliases=dir_aliases, + score_patterns=score_patterns, + ) + if not data: + return None + data = data[:top_n] + labels = [d[0] for d in data][::-1] + vals = [d[1] for d in data][::-1] + if self._mpl_ok(): + try: + import matplotlib.pyplot as plt # type: ignore + + out.parent.mkdir(parents=True, exist_ok=True) + fig_side = max(5.8, min(7.2, 0.25 * len(labels) + 2.4)) + labels = [ + f"{rank}. {feature}" + for rank, (feature, _score) in enumerate(data, start=1) + ][::-1] + fig, ax = plt.subplots(figsize=(fig_side, fig_side)) + ax.barh(labels, vals, color="#86A8CA", height=0.55) + ax.set_xlabel("Median score across CV folds") + ax.set_ylabel("Ranked feature order") + ax.grid(axis="x", color="#E1E5EA", linewidth=0.7) + ax.spines["top"].set_visible(False) + ax.spines["right"].set_visible(False) + fig.subplots_adjust(left=0.42, right=0.97, top=0.96, bottom=0.12) + fig.savefig(out, dpi=180) + plt.close(fig) + return str(out) + except Exception as exc: + logger.warning("Feature score plot generation failed with matplotlib: %r", exc) + return None + + def _resolve_feature_learning_panels(self, ds_dir: Path, dataset_name: str) -> List[Dict[str, str]]: + panels: List[Dict[str, str]] = [] + for spec in FEATURE_LEARNING_METHODS: + method_key = str(spec.get("key", "")).strip() + if method_key == "": + continue + label = str(spec.get("label", method_key)).strip() + dir_aliases = [str(x) for x in spec.get("dir_aliases", [])] + score_patterns = [str(x) for x in spec.get("score_patterns", [])] + out = self.paths.figures_dir / f"{dataset_name}_{method_key}_top20.png" + + fig_path: Optional[str] = None + if self.reuse_existing_figures: + reused = self._reuse_generated_report_figure( + f"{dataset_name}_{method_key}_top20.png", + ds_dir=ds_dir, + ) + if reused is not None: + fig_path = str(reused) + if fig_path is None and self.enable_plots: + if method_key == "mutual_info": + fig_path = self._plot_mutual_info_top(ds_dir, out, top_n=20) + else: + fig_path = self._plot_feature_scores_method_top( + ds_dir, + out, + dir_aliases=dir_aliases, + score_patterns=score_patterns, + top_n=20, + ) + if fig_path is None and out.is_file(): + fig_path = str(out) + + if fig_path: + panels.append({"key": method_key, "title": f"Top Scores ({label})", "path": fig_path}) + + return panels + + def format_feature_summary_value(self, values: Sequence[float]) -> str: + clean_values = [float(v) for v in values if v is not None and math.isfinite(float(v))] + if not clean_values: + return "" + mean_value = statistics.mean(clean_values) + if len(clean_values) == 1: + return _format_number(mean_value) + sd_value = statistics.stdev(clean_values) + if abs(sd_value) < 1e-12: + return _format_number(mean_value) + return f"{_format_number(mean_value)} +/- {_format_number(sd_value)}" + + def labels_match(self, value: Any, label: str) -> bool: + value_text = str(value).strip() + label_text = str(label).strip() + if value_text == label_text: + return True + value_float = _safe_float(value_text) + label_float = _safe_float(label_text) + return value_float is not None and label_float is not None and abs(value_float - label_float) < 1e-12 + + def feature_summary_columns(self, data_process_summary: Optional[TableData]) -> List[str]: + if data_process_summary and len(data_process_summary.columns) > 1: + return ["Step"] + list(data_process_summary.columns[1:]) + return [ + "Step", + "Instances", + "Total Features", + "Categorical Features", + "Quantitative Features", + "Missing Values", + "Missing Percent", + ] + + def cv_train_files(self, ds_dir: Path, *, pre_selection: bool) -> List[Path]: + dataset_name = ds_dir.name + cv_dir = ds_dir / "CVDatasets" + if not cv_dir.is_dir(): + return [] + if pre_selection: + return sorted(cv_dir.glob(f"{dataset_name}_CVPre_*_Train.csv")) + return sorted(path for path in cv_dir.glob(f"{dataset_name}_CV_*_Train.csv") if "_CVPre_" not in path.name) + + def summarize_cv_train_files( + self, + files: Sequence[Path], + metadata: Dict[str, Any], + columns: Sequence[str], + ) -> Dict[str, str]: + if not files: + return {} + + outcome_label = str(metadata.get("Outcome Label") or metadata.get("outcome_label") or self.outcome_label or "Class") + instance_label = str(metadata.get("Instance Label") or metadata.get("instance_label") or self.instance_label or "InstanceID") + class_columns = [col for col in columns if col.lower().startswith("class ")] + numeric_values: Dict[str, List[float]] = {col: [] for col in columns if col != "Step"} + + missing_tokens = {"", "?", "na", "n/a", "nan", "none", "null"} + for path in files: + try: + with path.open("r", encoding="utf-8-sig", newline="") as handle: + reader = csv.DictReader(handle) + fieldnames = list(reader.fieldnames or []) + rows = list(reader) + except OSError: + continue + if not fieldnames: + continue + + outcome_col = outcome_label if outcome_label in fieldnames else None + if outcome_col is None: + lowered = {col.lower(): col for col in fieldnames} + outcome_col = lowered.get(outcome_label.lower()) or lowered.get("class") + instance_col = instance_label if instance_label in fieldnames else None + if instance_col is None: + lowered = {col.lower(): col for col in fieldnames} + instance_col = lowered.get(instance_label.lower()) or lowered.get("instanceid") + + excluded = {col for col in (outcome_col, instance_col) if col} + feature_cols = [col for col in fieldnames if col not in excluded] + instances = float(len(rows)) + total_features = float(len(feature_cols)) + missing_values = 0.0 + for row in rows: + for feature in feature_cols: + if str(row.get(feature, "")).strip().lower() in missing_tokens: + missing_values += 1.0 + total_cells = instances * total_features + + if "Instances" in numeric_values: + numeric_values["Instances"].append(instances) + if "Total Features" in numeric_values: + numeric_values["Total Features"].append(total_features) + if "Missing Values" in numeric_values: + numeric_values["Missing Values"].append(missing_values) + if "Missing Percent" in numeric_values: + numeric_values["Missing Percent"].append(missing_values / total_cells if total_cells else 0.0) + + if outcome_col: + for class_col in class_columns: + label = class_col.split("Class ", 1)[1].strip() + count = sum(1 for row in rows if self.labels_match(row.get(outcome_col, ""), label)) + numeric_values.setdefault(class_col, []).append(float(count)) + + return {col: self.format_feature_summary_value(vals) for col, vals in numeric_values.items() if vals} + + def last_data_process_row(self, data_process_summary: Optional[TableData], columns: Sequence[str]) -> Dict[str, str]: + if not data_process_summary or not data_process_summary.rows: + return {} + source = data_process_summary.rows[-1] + row: Dict[str, str] = {"Step": "Post Processing"} + for col in columns[1:]: + row[col] = source.get(col, "") + return row + + def read_feature_manifests(self, ds_dir: Path) -> List[Dict[str, Any]]: + feature_dir = ds_dir / "feature_learning" + if not feature_dir.is_dir(): + return [] + manifests: List[Dict[str, Any]] = [] + for path in sorted(feature_dir.glob("feature_manifest_cv*.json")): + blob = self._read_json(path) + if blob: + manifests.append(blob) + return manifests + + def feature_input_summary_from_manifests( + self, + manifests: Sequence[Dict[str, Any]], + columns: Sequence[str], + cv_context: Dict[str, str], + ) -> Dict[str, str]: + if not manifests: + return {} + input_counts: List[float] = [] + instance_counts: List[float] = [] + for manifest in manifests: + input_count = _safe_float(manifest.get("input_feature_count")) + if input_count is not None: + input_counts.append(input_count) + train_shape = manifest.get("train_shape") + if isinstance(train_shape, (list, tuple)) and train_shape: + instance_count = _safe_float(train_shape[0]) + if instance_count is not None: + instance_counts.append(instance_count) + + summary: Dict[str, str] = {} + if "Instances" in columns: + summary["Instances"] = self.format_feature_summary_value(instance_counts) + if "Total Features" in columns: + summary["Total Features"] = self.format_feature_summary_value(input_counts) + for col in ("Missing Values", "Missing Percent"): + if col in columns: + summary[col] = cv_context.get(col, "0") + for col in columns: + if col.lower().startswith("class "): + summary[col] = cv_context.get(col, "") + return {key: value for key, value in summary.items() if value != ""} + + def feature_rows_from_manifests( + self, + manifests: Sequence[Dict[str, Any]], + columns: Sequence[str], + base_row: Dict[str, str], + cv_context: Dict[str, str], + ) -> List[Dict[str, str]]: + if not manifests: + return [] + + rows: List[Dict[str, str]] = [] + final_counts: List[float] = [] + instance_counts: List[float] = [] + keep_original_values: List[bool] = [] + for manifest in manifests: + final_count = _safe_float(manifest.get("final_feature_count")) + if final_count is not None: + final_counts.append(final_count) + train_shape = manifest.get("train_shape") + if isinstance(train_shape, (list, tuple)) and train_shape: + instance_count = _safe_float(train_shape[0]) + if instance_count is not None: + instance_counts.append(instance_count) + params = manifest.get("params") + if isinstance(params, dict): + keep_original_values.append(bool(params.get("keep_original_features", True))) + + categorical_base = _safe_float(base_row.get("Categorical Features", "")) + treat_as_all_engineered = bool(keep_original_values) and not any(keep_original_values) + categorical_values: List[float] = [] + quantitative_values: List[float] = [] + if final_counts: + if treat_as_all_engineered: + categorical_values = [0.0 for _ in final_counts] + quantitative_values = list(final_counts) + elif categorical_base is not None: + categorical_values = [categorical_base for _ in final_counts] + quantitative_values = [max(0.0, count - categorical_base) for count in final_counts] + + for step in ("P3 Feature Learning", "P4 Feature Importance"): + row: Dict[str, str] = {col: "" for col in columns} + row["Step"] = step + if "Instances" in row: + row["Instances"] = self.format_feature_summary_value(instance_counts) + if "Total Features" in row: + row["Total Features"] = self.format_feature_summary_value(final_counts) + if "Categorical Features" in row: + row["Categorical Features"] = self.format_feature_summary_value(categorical_values) + if "Quantitative Features" in row: + row["Quantitative Features"] = self.format_feature_summary_value(quantitative_values) + for col in ("Missing Values", "Missing Percent"): + if col in row: + row[col] = "0" + for col in columns: + if col.lower().startswith("class "): + row[col] = cv_context.get(col, "") + rows.append(row) + return rows + + def feature_selection_counts(self, ds_dir: Path) -> List[float]: + table = self._read_csv_table(ds_dir / "feature_selection" / "InformativeFeatureSummary.csv") + if not table or not table.rows: + return [] + informative_col = None + for col in table.columns: + low = col.lower() + if "informative" in low and "uninformative" not in low: + informative_col = col + break + if informative_col is None: + return [] + counts: List[float] = [] + for row in table.rows: + value = _safe_float(row.get(informative_col, "")) + if value is not None: + counts.append(value) + return counts + + def feature_learning_selection_cv_summary( + self, + ds_dir: Path, + metadata: Dict[str, Any], + data_process_summary: Optional[TableData], + ) -> Optional[TableData]: + columns = self.feature_summary_columns(data_process_summary) + rows: List[Dict[str, str]] = [] + + pre_cv_summary = self.summarize_cv_train_files(self.cv_train_files(ds_dir, pre_selection=True), metadata, columns) + final_cv_summary = self.summarize_cv_train_files(self.cv_train_files(ds_dir, pre_selection=False), metadata, columns) + manifests = self.read_feature_manifests(ds_dir) + cv_context = pre_cv_summary or final_cv_summary + + base_row = self.last_data_process_row(data_process_summary, columns) + input_summary = self.feature_input_summary_from_manifests(manifests, columns, cv_context) + if base_row or input_summary: + row = {col: "" for col in columns} + row.update(base_row) + row["Step"] = "Post Processing" + for col in columns[1:]: + if col in input_summary: + row[col] = input_summary[col] + rows.append(row) + + rows.extend(self.feature_rows_from_manifests(manifests, columns, base_row, cv_context)) + + selection_counts = self.feature_selection_counts(ds_dir) + if selection_counts or final_cv_summary: + row = {col: "" for col in columns} + row["Step"] = "P5 Feature Selection" + for col in columns[1:]: + if col in final_cv_summary: + row[col] = final_cv_summary[col] + if "Total Features" in row and selection_counts: + row["Total Features"] = self.format_feature_summary_value(selection_counts) + rows.append(row) + + if not rows: + return None + return TableData(columns=columns, rows=rows) + + def _load_metrics_by_cv(self, metrics_dir: Path, metric_name: str) -> Dict[str, List[float]]: + key = METRIC_JSON_KEYS.get(metric_name, metric_name) + out: Dict[str, List[float]] = {} + if not metrics_dir.is_dir(): + return out + for path in sorted(metrics_dir.glob("*.json")): + blob = self._read_json(path) + if not blob: + continue + alg = path.name.split("_CV_")[0] + metrics = blob.get("metrics") + val = None + if isinstance(metrics, dict): + if key in metrics: + val = _safe_float(metrics.get(key)) + else: + # Compatibility fallbacks + for alt in [key.lower(), key.upper(), metric_name, metric_name.lower()]: + if alt in metrics: + val = _safe_float(metrics.get(alt)) + break + elif key in blob: + val = _safe_float(blob.get(key)) + if val is not None: + out.setdefault(alg, []).append(val) + return out + + def _plot_metric_distribution(self, metrics_dir: Path, metric_name: str, out: Path, title: str) -> Optional[str]: + data = self._load_metrics_by_cv(metrics_dir, metric_name) + if not data: + return None + labels = sorted(data.keys()) + series = [data[k] for k in labels] + if self._mpl_ok(): + try: + import matplotlib.pyplot as plt # type: ignore + + out.parent.mkdir(parents=True, exist_ok=True) + fig, ax = plt.subplots(figsize=(8.6, 4.8)) + ax.boxplot(series, tick_labels=labels, vert=True, patch_artist=True) + ax.set_ylabel(metric_name) + for tick in ax.get_xticklabels(): + tick.set_rotation(35) + tick.set_ha("right") + fig.tight_layout() + fig.savefig(out, dpi=180) + plt.close(fig) + return str(out) + except Exception as exc: + logger.warning("Metric distribution plot generation failed with matplotlib: %r", exc) + return None + + def _extract_cv_index(self, filename: str) -> Optional[int]: + m = re.search(r"_CV_([0-9]+)", filename) + if not m: + return None + try: + return int(m.group(1)) + except Exception: + return None + + def _load_metric_values_by_cv(self, metrics_dir: Path, metric_name: str) -> Dict[int, List[float]]: + key = METRIC_JSON_KEYS.get(metric_name, metric_name) + out: Dict[int, List[float]] = {} + if not metrics_dir.is_dir(): + return out + for path in sorted(metrics_dir.glob("*.json")): + blob = self._read_json(path) + if not blob: + continue + metrics = blob.get("metrics") + val = None + if isinstance(metrics, dict): + if key in metrics: + val = _safe_float(metrics.get(key)) + else: + for alt in [key.lower(), key.upper(), metric_name, metric_name.lower()]: + if alt in metrics: + val = _safe_float(metrics.get(alt)) + break + elif key in blob: + val = _safe_float(blob.get(key)) + if val is None: + continue + cv_idx = self._extract_cv_index(path.stem) + if cv_idx is None: + cv_idx = len(out) + out.setdefault(cv_idx, []).append(val) + return out + + def _dataset_metric_series_for_overview(self, ds_dir: Path, metric_name: str) -> List[float]: + by_cv: Dict[int, List[float]] = {} + for metrics_dir in [ + ds_dir / "model_evaluation" / "metrics_by_cv", + ds_dir / "ensemble_evaluation" / "metrics_by_cv", + ]: + cv_map = self._load_metric_values_by_cv(metrics_dir, metric_name) + for cv_idx, values in cv_map.items(): + by_cv.setdefault(cv_idx, []).extend(values) + if not by_cv: + return [] + + higher = METRIC_DIRECTION_HIGHER_IS_BETTER.get(metric_name, True) + series: List[float] = [] + for cv_idx in sorted(by_cv.keys()): + values = [v for v in by_cv[cv_idx] if v is not None] + if not values: + continue + series.append(max(values) if higher else min(values)) + return series + + def _plot_dataset_comparison_overview( + self, + dataset_blocks: Sequence[Dict[str, Any]], + metric_name: str, + out: Path, + ) -> Optional[str]: + labels: List[str] = [] + series: List[List[float]] = [] + for ds in dataset_blocks: + ds_id = str(ds.get("dataset_id", "")) + ds_path = Path(str(ds.get("dataset_path", ""))) + if not ds_id or not ds_path.is_dir(): + continue + vals = self._dataset_metric_series_for_overview(ds_path, metric_name) + if vals: + labels.append(ds_id) + series.append(vals) + + if not labels or not series: + return None + + if self._mpl_ok(): + try: + import matplotlib.pyplot as plt # type: ignore + + out.parent.mkdir(parents=True, exist_ok=True) + fig, ax = plt.subplots(figsize=(8.6, 4.8)) + ax.boxplot(series, tick_labels=labels, vert=True, patch_artist=True) + ax.set_xlabel("Dataset") + ax.set_ylabel(metric_name) + fig.tight_layout() + fig.savefig(out, dpi=180) + plt.close(fig) + return str(out) + except Exception as exc: + logger.warning( + "Dataset comparison overview generation failed with matplotlib for %s: %r", + metric_name, + exc, + ) + return None + + def _extract_curve_xy(self, blob: Dict[str, Any], curve_kind: str) -> Tuple[Optional[List[float]], Optional[List[float]], Optional[str]]: + if curve_kind == "roc": + keys = ("fpr", "tpr") + else: + keys = ("recall", "precision") + + if keys[0] in blob and keys[1] in blob: + try: + x = [float(v) for v in blob[keys[0]]] + y = [float(v) for v in blob[keys[1]]] + return x, y, None + except Exception: + pass + + preferred = ["micro", "macro"] + for key in preferred + list(blob.keys()): + sub = blob.get(key) + if isinstance(sub, dict) and keys[0] in sub and keys[1] in sub: + try: + x = [float(v) for v in sub[keys[0]]] + y = [float(v) for v in sub[keys[1]]] + return x, y, str(key) + except Exception: + continue + return None, None, None + + def _curve_alg_from_filename(self, filename: str, curve_kind: str) -> str: + # Parse algorithm name using the *last* _CV__.json pattern. + # This avoids collapsing names that may themselves contain "_CV_". + pat = re.compile(rf"^(.*)_CV_[0-9]+_{re.escape(curve_kind)}\.json$", re.IGNORECASE) + m = pat.match(filename) + if m: + return m.group(1) + suffix = f"_{curve_kind}.json" + if filename.lower().endswith(suffix): + return filename[: -len(suffix)] + return Path(filename).stem + + def _is_class_like_key(self, key: str) -> bool: + k = str(key).strip() + if k == "": + return False + if k.isdigit(): + return True + try: + float(k) + return True + except Exception: + return False + + def _extract_curve_entries( + self, + blob: Dict[str, Any], + curve_kind: str, + default_alg: str, + ) -> List[Tuple[str, List[float], List[float], Optional[str]]]: + # 1) Direct or micro/macro-compatible payload. + x, y, tag = self._extract_curve_xy(blob, curve_kind) + if x and y and len(x) == len(y) and len(x) > 1: + return [(default_alg, x, y, tag)] + + # 2) One-level nested payload. + one_level: List[Tuple[str, List[float], List[float], Optional[str]]] = [] + for key, sub in blob.items(): + if not isinstance(sub, dict): + continue + sx, sy, stag = self._extract_curve_xy(sub, curve_kind) + if sx and sy and len(sx) == len(sy) and len(sx) > 1: + one_level.append((str(key), sx, sy, stag)) + + if one_level: + keys = [k for k, _, _, _ in one_level] + if all(self._is_class_like_key(k) for k in keys): + # Class-wise nested curves for one algorithm. + # Aggregate to a single representative (macro-like) curve. + x_grid = _linspace(0.0, 1.0, 250) + interpolated: List[List[float]] = [] + for _, sx, sy, _ in one_level: + yi = _interp_sorted(sx, sy, x_grid) + yi = [max(0.0, min(1.0, v)) for v in yi] + interpolated.append(yi) + if interpolated: + mean_y = [ + sum(vals[i] for vals in interpolated) / float(len(interpolated)) + for i in range(len(x_grid)) + ] + return [(default_alg, x_grid, mean_y, "macro")] + return [] + + # Treat keys as algorithm names in combined files. + entries: List[Tuple[str, List[float], List[float], Optional[str]]] = [] + for key, sx, sy, stag in one_level: + alg = key.strip() or default_alg + entries.append((alg, sx, sy, stag)) + return entries + + # 3) Two-level nested payload (algorithm -> class -> curve) + entries: List[Tuple[str, List[float], List[float], Optional[str]]] = [] + for outer_key, outer_val in blob.items(): + if not isinstance(outer_val, dict): + continue + nested: List[Tuple[str, List[float], List[float], Optional[str]]] = [] + for inner_key, inner_val in outer_val.items(): + if not isinstance(inner_val, dict): + continue + sx, sy, stag = self._extract_curve_xy(inner_val, curve_kind) + if sx and sy and len(sx) == len(sy) and len(sx) > 1: + nested.append((str(inner_key), sx, sy, stag)) + if not nested: + continue + + inner_keys = [k for k, _, _, _ in nested] + alg_name = str(outer_key).strip() or default_alg + if all(self._is_class_like_key(k) for k in inner_keys): + x_grid = _linspace(0.0, 1.0, 250) + interpolated: List[List[float]] = [] + for _, sx, sy, _ in nested: + yi = _interp_sorted(sx, sy, x_grid) + yi = [max(0.0, min(1.0, v)) for v in yi] + interpolated.append(yi) + if interpolated: + mean_y = [ + sum(vals[i] for vals in interpolated) / float(len(interpolated)) + for i in range(len(x_grid)) + ] + entries.append((alg_name, x_grid, mean_y, "macro")) + else: + for inner_name, sx, sy, stag in nested: + name = inner_name.strip() or alg_name + entries.append((name, sx, sy, stag)) + return entries + + def _load_curves_grouped(self, curves_dir: Path, curve_kind: str) -> Dict[str, List[Tuple[List[float], List[float], Optional[str]]]]: + groups: Dict[str, List[Tuple[List[float], List[float], Optional[str]]]] = {} + if not curves_dir.is_dir(): + return groups + for path in sorted(curves_dir.glob(f"*_{curve_kind}.json")): + blob = self._read_json(path) + if not blob: + continue + default_alg = self._curve_alg_from_filename(path.name, curve_kind) + entries = self._extract_curve_entries(blob, curve_kind, default_alg) + for alg, x, y, tag in entries: + if x and y and len(x) == len(y) and len(x) > 1: + groups.setdefault(alg, []).append((x, y, tag)) + return groups + + def _plot_curve_summary( + self, + curves_dir: Path, + out: Path, + *, + curve_kind: str, + title: str, + no_skill: float = 0.5, + ) -> Optional[str]: + groups = self._load_curves_grouped(curves_dir, curve_kind) + if not groups: + return None + x_grid = _linspace(0.0, 1.0, 250) + plot_lines: List[Tuple[str, List[float], Optional[str], float]] = [] + for alg in sorted(groups.keys()): + curves = groups[alg] + interpolated: List[List[float]] = [] + tags: List[str] = [] + for x, y, tag in curves: + yi = _interp_sorted(x, y, x_grid) + yi = [max(0.0, min(1.0, v)) for v in yi] + interpolated.append(yi) + if tag: + tags.append(tag) + if not interpolated: + continue + mean_y = [ + sum(vals[i] for vals in interpolated) / float(len(interpolated)) + for i in range(len(x_grid)) + ] + auc_val = _auc_trapezoid(x_grid, mean_y) + label_suffix = "" + if tags: + if "micro" in tags: + label_suffix = " (micro)" + elif "macro" in tags: + label_suffix = " (macro)" + label = f"{alg}{label_suffix} (AUC={_format_number(auc_val)})" + plot_lines.append((label, mean_y, label_suffix or None, auc_val)) + + if not plot_lines: + return None + + if self._mpl_ok(): + try: + import matplotlib.pyplot as plt # type: ignore + + out.parent.mkdir(parents=True, exist_ok=True) + fig, ax = plt.subplots(figsize=(7.6, 5.4)) + for label, mean_y, _tag, _auc in plot_lines: + ax.plot(x_grid, mean_y, linewidth=1.6, label=label) + + if curve_kind == "roc": + ax.plot( + [0.0, 1.0], + [0.0, 1.0], + linestyle="--", + color="black", + linewidth=1.0, + label="No Skill (AUROC=0.500)", + ) + ax.set_xlabel("False Positive Rate") + ax.set_ylabel("True Positive Rate") + else: + y_base = max(0.0, min(1.0, no_skill)) + ax.plot( + [0.0, 1.0], + [y_base, y_base], + linestyle="--", + color="black", + linewidth=1.0, + label=f"No Skill (AUPRC={_format_number(y_base)})", + ) + ax.set_xlabel("Recall") + ax.set_ylabel("Precision") + ax.set_xlim(0.0, 1.0) + ax.set_ylim(0.0, 1.02) + ax.legend(loc="lower right", fontsize=8) + fig.tight_layout() + fig.savefig(out, dpi=180) + plt.close(fig) + return str(out) + except Exception as exc: + logger.warning("Curve summary generation failed with matplotlib (%s): %r", curve_kind, exc) + return None + + def _plot_regression_residual_fallbacks(self, ds_dir: Path, dataset_name: str) -> Dict[str, Optional[str]]: + out: Dict[str, Optional[str]] = { + "actual_vs_predicted": None, + "residual_distribution": None, + "test_residual": None, + } + test = self._read_csv_table(ds_dir / "model_evaluation" / "residual_test.csv") + if not test: + return out + + def residuals_from(table: Optional[TableData]) -> List[float]: + if not table: + return [] + low = {c.lower(): c for c in table.columns} + rcol = low.get("residual") or (table.columns[1] if len(table.columns) > 1 else table.columns[0]) + vals: List[float] = [] + for row in table.rows: + rv = _safe_float(row.get(rcol, "")) + if rv is not None: + vals.append(rv) + return vals + + test_vals = residuals_from(test) + + def actual_pred_from(table: Optional[TableData]) -> Tuple[List[float], List[float], List[str]]: + if not table: + return [], [], [] + low = {c.lower(): c for c in table.columns} + pred_col = low.get("predicted") or low.get("prediction") or low.get("pred") or low.get("y_pred") + actual_col = low.get("actual") or low.get("outcome") or low.get("observed") or low.get("y_test") + alg_col = low.get("algorithm") or low.get("model") + if not pred_col or not actual_col: + return [], [], [] + preds: List[float] = [] + actuals: List[float] = [] + algs: List[str] = [] + for row in table.rows: + pv = _safe_float(row.get(pred_col, "")) + av = _safe_float(row.get(actual_col, "")) + if pv is None or av is None: + continue + preds.append(pv) + actuals.append(av) + algs.append(row.get(alg_col, "").strip() if alg_col else "") + return preds, actuals, algs + + preds, actuals, pred_algs = actual_pred_from(test) + if self._mpl_ok(): + try: + import matplotlib.pyplot as plt # type: ignore + + if test_vals: + dist_out = self.paths.figures_dir / f"{dataset_name}_residual_distribution_fallback.png" + fig, ax = plt.subplots(figsize=(7.2, 4.2)) + ax.hist(test_vals, bins=35, alpha=0.85, color="#E15759") + ax.set_xlabel("Residual") + ax.set_ylabel("Frequency") + fig.tight_layout() + fig.savefig(dist_out, dpi=180) + plt.close(fig) + out["residual_distribution"] = str(dist_out) + + if test_vals: + test_out = self.paths.figures_dir / f"{dataset_name}_test_residual_fallback.png" + fig, ax = plt.subplots(figsize=(7.2, 4.2)) + vals_sorted = sorted(test_vals) + n = len(vals_sorted) + if n > 1: + theo = [statistics.NormalDist().inv_cdf((i + 0.5) / n) for i in range(n)] + ax.scatter(theo, vals_sorted, s=8, alpha=0.6, color="#E15759") + else: + ax.scatter([0.0], vals_sorted, s=8, alpha=0.6, color="#E15759") + ax.set_xlabel("Theoretical Quantiles") + ax.set_ylabel("Ordered Residual") + fig.tight_layout() + fig.savefig(test_out, dpi=180) + plt.close(fig) + out["test_residual"] = str(test_out) + + if preds and actuals: + avp_out = self.paths.figures_dir / f"{dataset_name}_actual_vs_predicted_fallback.png" + fig, ax = plt.subplots(figsize=(7.2, 4.2)) + if pred_algs and any(a for a in pred_algs): + for alg in sorted(set([a for a in pred_algs if a])): + idxs = [i for i, a in enumerate(pred_algs) if a == alg] + xvals = [preds[i] for i in idxs] + yvals = [actuals[i] for i in idxs] + ax.scatter(xvals, yvals, s=10, alpha=0.45, label=alg) + ax.legend(loc="upper right", fontsize=7) + else: + ax.scatter(preds, actuals, s=10, alpha=0.45) + ax.set_xlabel("Predicted Outcome") + ax.set_ylabel("Actual Outcome") + fig.tight_layout() + fig.savefig(avp_out, dpi=180) + plt.close(fig) + out["actual_vs_predicted"] = str(avp_out) + except Exception as exc: + logger.warning("Regression fallback plot generation failed with matplotlib for %s: %r", ds_dir, exc) + + if out["actual_vs_predicted"] is None: + out["actual_vs_predicted"] = self._save_simple_placeholder( + self.paths.figures_dir / f"{dataset_name}_actual_vs_predicted_fallback.png", + "Actual vs Predicted", + "Predictions not found in exported CSVs.", + ) + return out + + def _format_rows_for_display(self, table: Optional[TableData]) -> Optional[TableData]: + if not table: + return None + rows: List[Dict[str, str]] = [] + for row in table.rows: + clean: Dict[str, str] = {} + for col in table.columns: + val = row.get(col, "") + fv = _safe_float(val) + if fv is not None: + clean[col] = _format_number(fv, is_pvalue=_is_pvalue_col(col)) + else: + clean[col] = val + rows.append(clean) + return TableData(columns=table.columns[:], rows=rows) + + def _univariate_top10(self, table: Optional[TableData]) -> Optional[TableData]: + if not table or not table.rows: + return None + low = {c.lower(): c for c in table.columns} + pcol = low.get("p-value") or low.get("p_value") or "p-value" + stat_col = low.get("test-statistic") or low.get("test_statistic") + + rows = table.rows[:] + rows.sort(key=lambda r: (_safe_float(r.get(pcol, "")) if _safe_float(r.get(pcol, "")) is not None else 999.0)) + top = rows[:10] + + formatted: List[Dict[str, str]] = [] + for row in top: + out = {} + for col in table.columns: + val = row.get(col, "") + if col == pcol: + out[col] = _format_number(val, is_pvalue=True) + elif stat_col and col == stat_col: + out[col] = _format_number(val) + else: + fv = _safe_float(val) + out[col] = _format_number(fv) if fv is not None else val + formatted.append(out) + return TableData(columns=table.columns[:], rows=formatted) + + def _combine_perf_tables( + self, + task_type: str, + models_mean: Optional[TableData], + models_std: Optional[TableData], + models_median: Optional[TableData], + ens_mean: Optional[TableData], + ens_std: Optional[TableData], + ens_median: Optional[TableData], + ) -> Dict[str, Any]: + metrics = self._metric_list_for_task(task_type) + + def as_map(table: Optional[TableData], alg_label_hint: str) -> Tuple[str, Dict[str, Dict[str, str]]]: + if not table: + return alg_label_hint, {} + alg_col = self._find_algorithm_col(table.columns) + mapping: Dict[str, Dict[str, str]] = {} + for row in table.rows: + alg = row.get(alg_col, "").strip() + if alg: + mapping[alg] = row + return alg_col, mapping + + _, m_map = as_map(models_mean, "Algorithm") + _, s_map = as_map(models_std, "Algorithm") + _, md_map = as_map(models_median, "Algorithm") + + _, em_map = as_map(ens_mean, "Ensemble") + _, es_map = as_map(ens_std, "Ensemble") + _, ed_map = as_map(ens_median, "Ensemble") + + ordered_algs = list(m_map.keys()) + ordered_ens = list(em_map.keys()) + + available_metrics: List[str] = [] + for metric in metrics: + present = False + for row in list(m_map.values()) + list(em_map.values()): + if metric in row: + present = True + break + if present: + available_metrics.append(metric) + + # Build mean/std combined rows + mean_rows: List[List[str]] = [] + raw_means: Dict[str, Dict[str, float]] = {} + for alg in ordered_algs: + row = [alg] + raw_means[alg] = {} + for metric in available_metrics: + mval = _safe_float(m_map.get(alg, {}).get(metric, "")) + sval = _safe_float(s_map.get(alg, {}).get(metric, "")) + if mval is None: + row.append("") + continue + raw_means[alg][metric] = mval + if sval is None: + row.append(_format_number(mval)) + else: + row.append(f"{_format_number(mval)} +/- {_format_number(sval)}") + mean_rows.append(row) + + for ens in ordered_ens: + label = ens if ens.endswith("- Ensemble") else f"{ens} - Ensemble" + row = [label] + raw_means[label] = {} + for metric in available_metrics: + mval = _safe_float(em_map.get(ens, {}).get(metric, "")) + sval = _safe_float(es_map.get(ens, {}).get(metric, "")) + if mval is None: + row.append("") + continue + raw_means[label][metric] = mval + if sval is None: + row.append(_format_number(mval)) + else: + row.append(f"{_format_number(mval)} +/- {_format_number(sval)}") + mean_rows.append(row) + + mean_columns = ["Algorithm"] + available_metrics + + # Highlight best mean per metric with tie handling at 3 decimals. + mean_highlight_cells: Set[Tuple[int, int]] = set() + for c_idx, metric in enumerate(available_metrics, start=1): + scored: List[Tuple[int, float]] = [] + for r_idx, row in enumerate(mean_rows, start=1): + raw_name = row[0] + val = raw_means.get(raw_name, {}).get(metric) + if val is not None: + scored.append((r_idx, round(val, 3))) + if not scored: + continue + higher = METRIC_DIRECTION_HIGHER_IS_BETTER.get(metric, True) + best_val = max(v for _, v in scored) if higher else min(v for _, v in scored) + for r_idx, v in scored: + if v == best_val: + mean_highlight_cells.add((r_idx, c_idx)) + + # Combined median rows. + median_rows: List[List[str]] = [] + median_raw: Dict[str, Dict[str, float]] = {} + for alg in ordered_algs: + row = [alg] + median_raw[alg] = {} + for metric in available_metrics: + val = _safe_float(md_map.get(alg, {}).get(metric, "")) + if val is None: + row.append("") + else: + row.append(_format_number(val)) + median_raw[alg][metric] = val + median_rows.append(row) + for ens in ordered_ens: + label = ens if ens.endswith("- Ensemble") else f"{ens} - Ensemble" + row = [label] + median_raw[label] = {} + for metric in available_metrics: + val = _safe_float(ed_map.get(ens, {}).get(metric, "")) + if val is None: + row.append("") + else: + row.append(_format_number(val)) + median_raw[label][metric] = val + median_rows.append(row) + + median_columns = ["Algorithm"] + available_metrics + median_highlight_cells: Set[Tuple[int, int]] = set() + for c_idx, metric in enumerate(available_metrics, start=1): + scored: List[Tuple[int, float]] = [] + for r_idx, row in enumerate(median_rows, start=1): + raw_name = row[0] + val = median_raw.get(raw_name, {}).get(metric) + if val is not None: + scored.append((r_idx, round(val, 3))) + if not scored: + continue + higher = METRIC_DIRECTION_HIGHER_IS_BETTER.get(metric, True) + best_val = max(v for _, v in scored) if higher else min(v for _, v in scored) + for r_idx, v in scored: + if v == best_val: + median_highlight_cells.add((r_idx, c_idx)) + + return { + "mean_columns": mean_columns, + "mean_rows": mean_rows, + "mean_highlight_cells": [(r, c) for r, c in sorted(mean_highlight_cells)], + "mean_bold_cells": [(r, c) for r, c in sorted(mean_highlight_cells)], + "median_columns": median_columns, + "median_rows": median_rows, + "median_highlight_cells": [(r, c) for r, c in sorted(median_highlight_cells)], + "median_bold_cells": [(r, c) for r, c in sorted(median_highlight_cells)], + } + + def _resolve_dataset_images( + self, + ds_dir: Path, + dataset_name: str, + task_type: str, + metadata: Dict[str, Any], + class_counts: Optional[TableData], + missingness_table: Optional[TableData], + perf_metric_default: Optional[str], + ) -> Dict[str, Any]: + figs: Dict[str, Any] = {} + + # Missingness top 25 + figs["missingness_top25"] = None + reused_missing = self._reuse_generated_report_figure( + f"{dataset_name}_missingness_top25.png", + ds_dir=ds_dir, + ) if self.reuse_existing_figures else None + existing_missing = _first_existing( + [ + ds_dir / "exploratory" / "DataMissingness.png", + ds_dir / "exploratory" / "Missingness.png", + ds_dir / "exploratory" / "MissingnessTop25.png", + reused_missing if reused_missing is not None else (self.paths.figures_dir / f"{dataset_name}_missingness_top25.png"), + ] + ) + if self.reuse_existing_figures and existing_missing: + figs["missingness_top25"] = str(existing_missing) + elif self.enable_plots: + out = self.paths.figures_dir / f"{dataset_name}_missingness_top25.png" + figs["missingness_top25"] = self._plot_missingness_top25( + missingness_table, out, f"{dataset_name}: Missingness Top 25 Features" + ) + + # Correlation matrix (prefer existing exploratory PNG; generate from CSV if missing) + figs["correlation_matrix"] = None + corr_png = self._figure_path_exploratory_correlation_matrix(ds_dir) + if self.reuse_existing_figures and corr_png is not None: + figs["correlation_matrix"] = str(corr_png) + else: + corr_csv = self._find_exploratory_correlation_csv(ds_dir) + if corr_csv is not None: + figs["correlation_matrix"] = self._plot_correlation_matrix_from_csv( + corr_csv, + self.paths.figures_dir / f"{dataset_name}_corr_matrix.png", + f"{dataset_name}: Feature Correlation Matrix", + ) + if figs["correlation_matrix"] is None and corr_png is not None: + figs["correlation_matrix"] = str(corr_png) + + # Class balance or target distribution + if task_type == "Regression": + out_path = self.paths.figures_dir / f"{dataset_name}_target_distribution.png" + # Prefer a freshly generated histogram for regression target distribution. + if self.enable_plots: + figs["target_distribution"] = self._plot_target_distribution( + ds_dir, + metadata, + out_path, + f"{dataset_name}: Target Distribution Histogram", + ) + else: + figs["target_distribution"] = None + if figs["target_distribution"] is None: + reused_target = self._reuse_generated_report_figure( + f"{dataset_name}_target_distribution.png", + ds_dir=ds_dir, + ) if self.reuse_existing_figures else None + existing = _first_existing( + [ + reused_target if reused_target is not None else out_path, + out_path, + ds_dir / "exploratory" / "TargetDistribution.png", + ds_dir / "exploratory" / "target_distribution.png", + ] + ) + figs["target_distribution"] = str(existing) if existing else None + figs["class_balance"] = None + else: + reused_class = self._reuse_generated_report_figure( + f"{dataset_name}_class_balance.png", + ds_dir=ds_dir, + ) if self.reuse_existing_figures else None + existing = _first_existing( + [ + ds_dir / "exploratory" / "ClassCountsBarPlot.png", + ds_dir / "exploratory" / "ClassCountsBarplot.png", + ds_dir / "exploratory" / "ClassCounts.png", + reused_class if reused_class is not None else (self.paths.figures_dir / f"{dataset_name}_class_balance.png"), + ] + ) + if self.reuse_existing_figures and existing: + figs["class_balance"] = str(existing) + else: + figs["class_balance"] = self._plot_class_balance( + class_counts, + self.paths.figures_dir / f"{dataset_name}_class_balance.png", + f"{dataset_name}: Class Balance", + ) + figs["target_distribution"] = None + + # Feature learning is omitted from replication-mode reports. + if self.report_mode == "replication": + figs["feature_learning_panels"] = [] + figs["mutual_info"] = None + else: + # Feature learning FI methods: deterministic report outputs per method. + fi_panels = self._resolve_feature_learning_panels(ds_dir, dataset_name) + figs["feature_learning_panels"] = fi_panels + figs["mutual_info"] = None + for panel in fi_panels: + if panel.get("key") == "mutual_info": + figs["mutual_info"] = panel.get("path") + break + + # Performance distribution + figs["performance_distribution"] = None + if perf_metric_default: + perf_fig_name = f"{dataset_name}_distribution_{perf_metric_default.replace(' ', '_')}.png" + reused_perf = self._reuse_generated_report_figure(perf_fig_name, ds_dir=ds_dir) \ + if self.reuse_existing_figures else None + existing_box = _first_existing( + [ + ds_dir / "model_evaluation" / "metricBoxplots" / f"Compare_{perf_metric_default}.png", + reused_perf if reused_perf is not None else (self.paths.figures_dir / perf_fig_name), + ] + ) + if existing_box and self.reuse_existing_figures: + figs["performance_distribution"] = str(existing_box) + else: + figs["performance_distribution"] = self._plot_metric_distribution( + ds_dir / "model_evaluation" / "metrics_by_cv", + perf_metric_default, + self.paths.figures_dir / perf_fig_name, + f"{dataset_name}: {perf_metric_default} Distribution", + ) + + # Classification curve pages + if task_type != "Regression": + # Model curves: reuse summary if present, else generate. + mroc = _first_existing([ds_dir / "model_evaluation" / "Summary_ROC.png"]) + mprc = _first_existing([ds_dir / "model_evaluation" / "Summary_PRC.png"]) + outcome_label = str( + self.outcome_label + or metadata.get("Outcome Label") + or metadata.get("outcome_label") + or "Class" + ) + no_skill = self._classification_no_skill( + class_counts, + ds_dir=ds_dir, + outcome_label=outcome_label, + task_type=task_type, + ) + + reused_models_roc = self._reuse_generated_report_figure( + f"{dataset_name}_models_roc_summary.png", + ds_dir=ds_dir, + ) if self.reuse_existing_figures else None + if self.reuse_existing_figures and (mroc or reused_models_roc): + figs["models_roc"] = str(mroc if mroc is not None else reused_models_roc) + else: + figs["models_roc"] = self._plot_curve_summary( + ds_dir / "model_evaluation" / "curves_by_cv", + self.paths.figures_dir / f"{dataset_name}_models_roc_summary.png", + curve_kind="roc", + title=f"{dataset_name}: Summary ROC (Models)", + no_skill=no_skill, + ) + if figs["models_roc"] is None and mroc: + figs["models_roc"] = str(mroc) + + reused_models_prc = self._reuse_generated_report_figure( + f"{dataset_name}_models_prc_summary.png", + ds_dir=ds_dir, + ) if self.reuse_existing_figures else None + if self.reuse_existing_figures and (mprc or reused_models_prc): + figs["models_prc"] = str(mprc if mprc is not None else reused_models_prc) + else: + figs["models_prc"] = self._plot_curve_summary( + ds_dir / "model_evaluation" / "curves_by_cv", + self.paths.figures_dir / f"{dataset_name}_models_prc_summary.png", + curve_kind="prc", + title=f"{dataset_name}: Summary PRC (Models)", + no_skill=no_skill, + ) + if figs["models_prc"] is None and mprc: + figs["models_prc"] = str(mprc) + + # Ensemble curves: prefer generating even if png exists. + figs["ensembles_roc"] = self._plot_curve_summary( + ds_dir / "ensemble_evaluation" / "curves_by_cv", + self.paths.figures_dir / f"{dataset_name}_ensembles_roc_summary.png", + curve_kind="roc", + title=f"{dataset_name}: Summary ROC (Ensembles)", + no_skill=no_skill, + ) + figs["ensembles_prc"] = self._plot_curve_summary( + ds_dir / "ensemble_evaluation" / "curves_by_cv", + self.paths.figures_dir / f"{dataset_name}_ensembles_prc_summary.png", + curve_kind="prc", + title=f"{dataset_name}: Summary PRC (Ensembles)", + no_skill=no_skill, + ) + if figs["ensembles_roc"] is None: + reused_ens_roc = self._reuse_generated_report_figure( + f"{dataset_name}_ensembles_roc_summary.png", + ds_dir=ds_dir, + ) if self.reuse_existing_figures else None + fallback = _first_existing([ + ds_dir / "ensemble_evaluation" / "Summary_ROC_ensembles.png", + reused_ens_roc if reused_ens_roc is not None else (self.paths.figures_dir / f"{dataset_name}_ensembles_roc_summary.png"), + ]) + figs["ensembles_roc"] = str(fallback) if fallback else None + if figs["ensembles_prc"] is None: + reused_ens_prc = self._reuse_generated_report_figure( + f"{dataset_name}_ensembles_prc_summary.png", + ds_dir=ds_dir, + ) if self.reuse_existing_figures else None + fallback = _first_existing([ + ds_dir / "ensemble_evaluation" / "Summary_PRC_ensembles.png", + reused_ens_prc if reused_ens_prc is not None else (self.paths.figures_dir / f"{dataset_name}_ensembles_prc_summary.png"), + ]) + figs["ensembles_prc"] = str(fallback) if fallback else None + else: + # Regression eval plots + figs["reg_actual_vs_pred"] = None + figs["reg_residual_dist"] = None + figs["reg_test_resid"] = None + eval_dir = ds_dir / "model_evaluation" / "evalPlots" + figs["reg_actual_vs_pred"] = str(eval_dir / "actual_vs_predict_all_algorithms.png") if (eval_dir / "actual_vs_predict_all_algorithms.png").is_file() else None + figs["reg_residual_dist"] = str(eval_dir / "residual_distrib_all_algorithms.png") if (eval_dir / "residual_distrib_all_algorithms.png").is_file() else None + figs["reg_test_resid"] = str(eval_dir / "probability_test_residual_all_algorithms.png") if (eval_dir / "probability_test_residual_all_algorithms.png").is_file() else None + if not all([figs["reg_actual_vs_pred"], figs["reg_residual_dist"], figs["reg_test_resid"]]): + fb = self._plot_regression_residual_fallbacks(ds_dir, dataset_name) + if figs["reg_actual_vs_pred"] is None: + figs["reg_actual_vs_pred"] = fb.get("actual_vs_predicted") + if figs["reg_residual_dist"] is None: + figs["reg_residual_dist"] = fb.get("residual_distribution") + if figs["reg_test_resid"] is None: + figs["reg_test_resid"] = fb.get("test_residual") + + # Composite feature score plot: reuse only, never auto-generate. + composite = _first_existing([ds_dir / "model_evaluation" / "feature_importance" / "Compare_FI_Norm_Weight.png"]) + figs["composite_feature_scores"] = str(composite) if composite else None + + return figs + + def _format_runtime_table(self, runtimes: Optional[TableData]) -> Optional[TableData]: + if not runtimes or not runtimes.rows: + return None + cols = runtimes.columns[:] + phase_col = None + for c in cols: + if c.strip().lower() == "phase": + phase_col = c + break + if phase_col is None: + return self._format_rows_for_display(runtimes) + rows = runtimes.rows[:] + rows.sort(key=lambda r: (_safe_float(r.get(phase_col, "")) if _safe_float(r.get(phase_col, "")) is not None else 999.0)) + + formatted: List[Dict[str, str]] = [] + for row in rows: + out: Dict[str, str] = {} + for c in cols: + if c == phase_col: + phase_raw = row.get(c, "") + phase_key = str(int(_safe_float(phase_raw))) if _safe_float(phase_raw) is not None else str(phase_raw) + label = PHASE_LABELS.get(phase_key) + out[c] = f"{phase_key} - {label}" if label else phase_key + elif _is_numeric_text(row.get(c, "")): + out[c] = _format_number(row.get(c, "")) + else: + out[c] = row.get(c, "") + formatted.append(out) + return TableData(columns=cols, rows=formatted) + + def _collect_dataset_block( + self, + ds_dir: Path, + dataset_id: str, + metadata: Dict[str, Any], + ) -> Dict[str, Any]: + dataset_name = ds_dir.name + task_type = self._detect_task_type(ds_dir, metadata) + + explore = ds_dir / "exploratory" + univariate = self._read_csv_table(explore / "univariate_analyses" / "Univariate_Significance.csv") + univariate_top10 = self._univariate_top10(univariate) + class_counts = self._read_csv_table(explore / "ClassCounts.csv") + missingness_table = self._format_rows_for_display(self._read_csv_table(explore / "DataMissingness.csv")) + informative_summary = self._format_rows_for_display(self._read_csv_table(ds_dir / "feature_selection" / "InformativeFeatureSummary.csv")) + data_process_summary = self._format_rows_for_display(self._read_csv_table(explore / "DataProcessSummary.csv")) + if data_process_summary and data_process_summary.columns and data_process_summary.columns[0] == "Algorithm": + old_col = data_process_summary.columns[0] + data_process_summary.columns[0] = "Step" + for row in data_process_summary.rows: + row["Step"] = row.pop(old_col, "") + feature_cv_summary = self.feature_learning_selection_cv_summary(ds_dir, metadata, data_process_summary) + runtimes = self._format_runtime_table(self._read_csv_table(ds_dir / "runtimes.csv")) + + model_eval = ds_dir / "model_evaluation" + summary_mean = self._read_csv_table(model_eval / "Summary_performance_mean.csv") + summary_std = self._read_csv_table(model_eval / "Summary_performance_std.csv") + summary_median = self._read_csv_table(model_eval / "Summary_performance_median.csv") + + ens_eval = ds_dir / "ensemble_evaluation" + ens_mean = self._read_csv_table(ens_eval / "Ensembles_performance_mean.csv") + ens_std = self._read_csv_table(ens_eval / "Ensembles_performance_std.csv") + ens_median = self._read_csv_table(ens_eval / "Ensembles_performance_median.csv") + + perf_combined = self._combine_perf_tables( + task_type=task_type, + models_mean=summary_mean, + models_std=summary_std, + models_median=summary_median, + ens_mean=ens_mean, + ens_std=ens_std, + ens_median=ens_median, + ) + + perf_metric_default = self._metric_default_distribution(task_type, perf_combined.get("mean_columns", [])[1:]) + figures = self._resolve_dataset_images( + ds_dir=ds_dir, + dataset_name=dataset_name, + task_type=task_type, + metadata=metadata, + class_counts=class_counts, + missingness_table=missingness_table, + perf_metric_default=perf_metric_default, + ) + + tables = { + "univariate_top10": { + "columns": univariate_top10.columns if univariate_top10 else [], + "rows": [[row.get(c, "") for c in univariate_top10.columns] for row in (univariate_top10.rows if univariate_top10 else [])], + }, + "informative_feature_summary": { + "columns": informative_summary.columns if informative_summary else [], + "rows": [[row.get(c, "") for c in informative_summary.columns] for row in (informative_summary.rows if informative_summary else [])], + }, + "feature_cv_summary": { + "columns": feature_cv_summary.columns if feature_cv_summary else [], + "rows": [[row.get(c, "") for c in feature_cv_summary.columns] for row in (feature_cv_summary.rows if feature_cv_summary else [])], + }, + "data_process_summary": { + "columns": data_process_summary.columns if data_process_summary else [], + "rows": [[row.get(c, "") for c in data_process_summary.columns] for row in (data_process_summary.rows if data_process_summary else [])], + }, + "runtime": { + "columns": runtimes.columns if runtimes else [], + "rows": [[row.get(c, "") for c in runtimes.columns] for row in (runtimes.rows if runtimes else [])], + }, + } + + return { + "dataset_id": dataset_id, + "dataset_name": dataset_name, + "dataset_path": str(ds_dir.resolve()), + "task_type": task_type, + "figures": figures, + "tables": tables, + "performance": perf_combined, + "performance_distribution_metric": perf_metric_default, + } + + def _resolve_dataset_comparison_images( + self, + task_type: str, + dataset_blocks: Sequence[Dict[str, Any]], + ) -> Dict[str, Optional[str]]: + dc_dir = self.exp_root / "DatasetComparisons" / "dataCompBoxplots" + figs: Dict[str, Optional[str]] = {} + if task_type == "Regression": + metrics = [ + "Pearson Correlation", + "Explained Variance", + "Mean Absolute Error", + "Mean Squared Error", + "Median Absolute Error", + "Max Error", + ] + else: + metrics = [ + "Balanced Accuracy", + "ROC AUC", + "PRC AUC", + "F1 Score", + ] + for metric in metrics: + key = f"overview_{metric}" + existing = _first_existing( + [ + dc_dir / f"DataCompareAllModels_{metric}.png", + self.paths.figures_dir / f"DataCompareAllModels_{metric}.png", + ] + ) + if existing is not None and self.reuse_existing_figures: + figs[key] = str(existing) + continue + generated = self._plot_dataset_comparison_overview( + dataset_blocks, + metric, + self.paths.figures_dir / f"DataCompareAllModels_{metric}.png", + ) + figs[key] = generated if generated is not None else (str(existing) if existing is not None else None) + return figs + + def _format_comparison_table(self, table: Optional[TableData]) -> Dict[str, Any]: + if not table or not table.rows: + return {"columns": [], "rows": [], "bold_cells": []} + rows_out: List[List[str]] = [] + bold_cells: Set[Tuple[int, int]] = set() + p_idx = None + sig_idx = None + for i, c in enumerate(table.columns): + cl = c.strip().lower() + if p_idx is None and (cl == "p-value" or cl == "p_value" or cl == "pvalue"): + p_idx = i + if sig_idx is None and "sig" in cl: + sig_idx = i + + for r_i, row in enumerate(table.rows, start=1): + out_row: List[str] = [] + p_val = None + for c_i, col in enumerate(table.columns): + raw = row.get(col, "") + fv = _safe_float(raw) + if fv is not None: + text = _format_number(fv, is_pvalue=_is_pvalue_col(col)) + else: + text = raw + out_row.append(text) + if c_i == p_idx: + p_val = _safe_float(raw) + if p_val is not None and p_val < 0.05: + if p_idx is not None: + bold_cells.add((r_i, p_idx)) + if sig_idx is not None: + bold_cells.add((r_i, sig_idx)) + rows_out.append(out_row) + + return { + "columns": table.columns[:], + "rows": rows_out, + "bold_cells": [(r, c) for r, c in sorted(bold_cells)], + } + + def _collect_dataset_comparisons( + self, + task_type: str, + dataset_blocks: Sequence[Dict[str, Any]], + ) -> Dict[str, Any]: + dc = self.exp_root / "DatasetComparisons" + if not dc.is_dir(): + return {"present": False} + kw = self._read_csv_table(dc / "BestCompare_KruskalWallis.csv") + mw = self._read_csv_table(dc / "BestCompare_MannWhitney.csv") + wx = self._read_csv_table(dc / "BestCompare_WilcoxonRank.csv") + + out = { + "present": True, + "figures": self._resolve_dataset_comparison_images(task_type, dataset_blocks), + "tables": { + "kw": self._format_comparison_table(kw), + "mw": self._format_comparison_table(mw), + "wx": self._format_comparison_table(wx), + }, + } + + # Optional KW p-value visualization + kw_table = out["tables"]["kw"] + if kw_table["columns"] and kw_table["rows"] and self.enable_plots: + cols = kw_table["columns"] + rows = kw_table["rows"] + p_idx = None + metric_idx = 0 + for i, c in enumerate(cols): + if _is_pvalue_col(c): + p_idx = i + break + if p_idx is not None: + vals: List[float] = [] + labels: List[str] = [] + for row in rows: + pv = _safe_float(row[p_idx]) + if pv is None: + continue + labels.append(row[metric_idx] if metric_idx < len(row) else f"M{len(labels)+1}") + vals.append(pv) + if labels and vals: + pfig = self.paths.figures_dir / "datasetcompare_kw_pvalues.png" + generated = False + if self._mpl_ok(): + try: + import matplotlib.pyplot as plt # type: ignore + + fig, ax = plt.subplots(figsize=(8.2, 4.5)) + ax.bar(labels, vals, color="#4E79A7") + ax.axhline(0.05, linestyle="--", color="red", linewidth=1.0) + ax.set_ylabel("P-Value") + for tick in ax.get_xticklabels(): + tick.set_rotation(35) + tick.set_ha("right") + fig.tight_layout() + fig.savefig(pfig, dpi=180) + plt.close(fig) + generated = True + except Exception as exc: + logger.warning("Could not generate KW p-value visualization with matplotlib: %r", exc) + + if generated: + out["figures"]["kw_pvalues"] = str(pfig) + return out + + def _image_dimensions_px(self, path: Path) -> Optional[Tuple[int, int]]: + try: + with path.open("rb") as f: + head = f.read(32) + if len(head) >= 24 and head.startswith(b"\x89PNG\r\n\x1a\n"): + w = int.from_bytes(head[16:20], "big") + h = int.from_bytes(head[20:24], "big") + if w > 0 and h > 0: + return (w, h) + except Exception: + pass + + try: + with path.open("rb") as f: + head = f.read(10) + if len(head) >= 10 and (head[:6] in {b"GIF87a", b"GIF89a"}): + w = int.from_bytes(head[6:8], "little") + h = int.from_bytes(head[8:10], "little") + if w > 0 and h > 0: + return (w, h) + except Exception: + pass + + try: + with path.open("rb") as f: + if f.read(2) != b"\xff\xd8": + return None + sof_markers = { + b"\xc0", + b"\xc1", + b"\xc2", + b"\xc3", + b"\xc5", + b"\xc6", + b"\xc7", + b"\xc9", + b"\xca", + b"\xcb", + b"\xcd", + b"\xce", + b"\xcf", + } + while True: + b = f.read(1) + if not b: + break + if b != b"\xff": + continue + marker = f.read(1) + while marker == b"\xff": + marker = f.read(1) + if not marker: + break + if marker in {b"\xd8", b"\xd9"}: + continue + seg_len_raw = f.read(2) + if len(seg_len_raw) != 2: + break + seg_len = int.from_bytes(seg_len_raw, "big") + if seg_len < 2: + break + if marker in sof_markers: + data = f.read(5) + if len(data) != 5: + break + h = int.from_bytes(data[1:3], "big") + w = int.from_bytes(data[3:5], "big") + if w > 0 and h > 0: + return (w, h) + break + f.seek(seg_len - 2, 1) + except Exception: + pass + + return None + + def _fit_image_in_box( + self, + img_w_px: int, + img_h_px: int, + box_x: float, + box_y: float, + box_w: float, + box_h: float, + ) -> Tuple[float, float, float, float]: + ratio = float(img_w_px) / float(img_h_px) + box_ratio = box_w / box_h + if ratio >= box_ratio: + draw_w = box_w + draw_h = box_w / ratio + else: + draw_h = box_h + draw_w = box_h * ratio + draw_x = box_x + (box_w - draw_w) * 0.5 + draw_y = box_y + (box_h - draw_h) * 0.5 + return draw_x, draw_y, draw_w, draw_h + + def _render_table( + self, + pdf: _StreamlinePDF, + *, + x: float, + y: float, + width: float, + columns: List[str], + rows: List[List[str]], + font_size: float = 6.0, + row_h: float = 3.8, + bold_cells: Optional[Set[Tuple[int, int]]] = None, + shade_cells: Optional[Set[Tuple[int, int]]] = None, + max_first_col_width: float = 42.0, + ) -> float: + if not columns: + return y + n = len(columns) + shaded = shade_cells if shade_cells is not None else (bold_cells or set()) + + if n == 1: + col_widths = [width] + else: + if n <= 3: + first_frac = 0.38 + elif n <= 6: + first_frac = 0.31 + else: + first_frac = 0.22 + first_w = min(max_first_col_width, width * first_frac) + rest_w = max(1.0, width - first_w) + + weights: List[float] = [] + sample_rows = rows[: min(len(rows), 40)] + for c_i in range(1, n): + max_len = len(str(columns[c_i])) + for row in sample_rows: + if c_i < len(row): + max_len = max(max_len, len(str(row[c_i]))) + weights.append(float(max(6, min(max_len, 28)))) + w_sum = sum(weights) if weights else 1.0 + col_widths = [first_w] + [rest_w * (w / w_sum) for w in weights] + + def _cell_numeric(v: Any) -> bool: + txt = str(v).strip() + if txt == "": + return False + if "+/-" in txt: + txt = txt.split("+/-", 1)[0].strip() + return _safe_float(txt) is not None + + numeric_cols: Set[int] = set() + for c_i in range(1, n): + non_empty = 0 + numeric = 0 + for row in rows: + if c_i >= len(row): + continue + text = str(row[c_i]).strip() + if text == "": + continue + non_empty += 1 + if _cell_numeric(text): + numeric += 1 + if non_empty > 0 and (numeric / float(non_empty)) >= 0.80: + numeric_cols.add(c_i) + + def draw_row(r_i: int, row: Sequence[Any]): + pdf.set_x(x) + for c_i in range(n): + txt = row[c_i] if c_i < len(row) else "" + max_chars = max(8, int(col_widths[c_i] * 2.2)) + txt = _shorten(str(txt), width=max_chars) + style = "B" if r_i == 0 else "" + align = "R" if (r_i > 0 and c_i in numeric_cols) else "L" + fill = r_i > 0 and (r_i, c_i) in shaded + if fill: + pdf.set_fill_color(230, 230, 230) + pdf.set_font("Times", style, font_size) + pdf.cell(col_widths[c_i], row_h, txt, border=1, ln=0, align=align, fill=fill) + pdf.ln(row_h) + + # Paginate long tables and repeat header on each new page. + page_bottom = pdf.h - pdf.b_margin + pdf.set_xy(x, y) + draw_row(0, columns) + for idx, row in enumerate(rows, start=1): + if pdf.get_y() + row_h > page_bottom: + pdf.add_page() + pdf.set_xy(x, 20) + draw_row(0, columns) + draw_row(idx, row) + return pdf.get_y() + + def _render_box(self, pdf: _StreamlinePDF, *, x: float, y: float, w: float, title: str, lines: List[str]) -> float: + pdf.set_xy(x, y) + pdf.set_font("Times", "B", 9) + pdf.cell(w, 5, title, border=1, ln=1, align="L") + pdf.set_x(x) + pdf.set_font("Times", "", 7) + body = "\n".join(lines) if lines else "Not available" + pdf.multi_cell(w, 3.7, body, border=1, align="L") + return pdf.get_y() + + def _draw_image_panel( + self, + pdf: _StreamlinePDF, + *, + x: float, + y: float, + w: float, + h: float, + title: str, + img_path: Optional[str], + ) -> float: + pdf.set_xy(x, y) + pdf.set_font("Times", "B", 9) + pdf.cell(w, 5, title, border=1, ln=1, align="L") + body_y = pdf.get_y() + pdf.set_xy(x, body_y) + pdf.cell(w, h, "", border=0, ln=0) + + if img_path: + p = Path(img_path) + if not p.is_absolute(): + p = (self.paths.reporting_dir / p).resolve() + if p.is_file(): + try: + inner_x = x + 1.2 + inner_y = body_y + 1.2 + inner_w = w - 2.4 + inner_h = h - 2.4 + + # Keep original figure aspect ratio and center inside panel. + dims = self._image_dimensions_px(p) + if dims is not None: + draw_x, draw_y, draw_w, draw_h = self._fit_image_in_box( + dims[0], dims[1], inner_x, inner_y, inner_w, inner_h + ) + pdf.image(str(p), x=draw_x, y=draw_y, w=draw_w, h=draw_h) + else: + # fpdf2 can preserve aspect if available. + try: + pdf.image( + str(p), + x=inner_x, + y=inner_y, + w=inner_w, + h=inner_h, + keep_aspect_ratio=True, + ) + except TypeError: + # Last-resort fallback preserves aspect by fixing width only. + pdf.image(str(p), x=inner_x, y=inner_y, w=inner_w) + return body_y + h + except Exception as exc: + logger.warning("Could not render image %s: %r", p, exc) + pdf.set_xy(x + 1.5, body_y + 2.0) + pdf.set_font("Times", "", 7) + pdf.multi_cell(w - 3.0, 3.6, "Figure not available", border=0, align="L") + return body_y + h + + def _render_global_summary(self, pdf: _StreamlinePDF, report_data: Dict[str, Any]): + pdf.add_page() + pdf.set_font("Times", "B", 12) + pdf.cell( + 190, + 8, + f"{report_data.get('title', 'STREAMLINE Testing Data Evaluation Report')}: {report_data.get('generated_at')}", + border=1, + ln=1, + align="L", + ) + pdf.ln(1) + + left_x, left_w = 10.0, 92.0 + right_x, right_w = 108.0, 92.0 + y0 = pdf.get_y() + column_y = [y0, y0] + column_x = [left_x, right_x] + column_w = [left_w, right_w] + + summary = report_data.get("run_command_summary", {}) or {} + sections = summary.get("sections") or [] + if not sections: + sections = [ + { + "title": "Run Overview", + "lines": [ + f"Experiment Name: {report_data.get('experiment_name', '')}", + f"Experiment Root: {report_data.get('experiment_root', '')}", + f"Report Mode: {report_data.get('report_mode', '')}", + ], + } + ] + + for section in sections: + if not isinstance(section, dict): + continue + title = str(section.get("title") or "Summary") + lines = [ + str(line) + for line in (section.get("lines") or []) + if str(line).strip() != "" + ] + column = 0 if column_y[0] <= column_y[1] else 1 + if column_y[column] > 260: + pdf.add_page() + column_y = [20.0, 20.0] + column = 0 + column_y[column] = ( + self._render_box( + pdf, + x=column_x[column], + y=column_y[column], + w=column_w[column], + title=title, + lines=lines, + ) + + 1 + ) + + def _render_dataset_header(self, pdf: _StreamlinePDF, ds: Dict[str, Any], section_title: str): + pdf.add_page() + pdf.set_font("Times", "B", 11) + pdf.cell(190, 6, section_title, border=1, ln=1, align="L") + pdf.set_font("Times", "B", 10) + pdf.set_fill_color(235, 238, 242) + pdf.cell(190, 6.5, f"{ds.get('dataset_id')} | Dataset: {ds.get('dataset_name')}", border=1, ln=1, align="L", fill=True) + pdf.set_font("Times", "", 7.5) + pdf.cell(190, 5, f"Dataset Path: {ds.get('dataset_path')}", border=1, ln=1, align="L") + + def _render_dataset_eda_page(self, pdf: _StreamlinePDF, ds: Dict[str, Any]): + self._render_dataset_header(pdf, ds, "EDA and Feature Engineering") + y_start = 34.0 + + uv = ds.get("tables", {}).get("univariate_top10", {}) + uv_cols = uv.get("columns", []) + uv_rows = uv.get("rows", []) + pdf.set_xy(10, y_start) + pdf.set_font("Times", "B", 9) + pdf.cell(190, 5, "Univariate Analysis (Top 10)", border=1, ln=1, align="L") + y_after = self._render_table( + pdf, + x=10, + y=pdf.get_y(), + width=190, + columns=uv_cols, + rows=uv_rows, + font_size=6.0, + row_h=3.6, + max_first_col_width=58.0, + ) + + figs = ds.get("figures", {}) + left_bottom = self._draw_image_panel( + pdf, + x=10, + y=y_after + 1, + w=94, + h=74, + title="Missingness Overview (Top 25 Features)", + img_path=figs.get("missingness_top25"), + ) + if ds.get("task_type") == "Regression": + right_title = "Target Distribution (Histogram)" + right_img = figs.get("target_distribution") + else: + right_title = "Class Balance (Observed)" + right_img = figs.get("class_balance") + right_bottom = self._draw_image_panel( + pdf, + x=106, + y=y_after + 1, + w=94, + h=74, + title=right_title, + img_path=right_img, + ) + + y_next = max(left_bottom, right_bottom) + 1 + + corr_bottom = self._draw_image_panel( + pdf, + x=10, + y=y_next, + w=190, + h=72, + title="Feature Correlation Matrix (Pearson Coefficients)", + img_path=figs.get("correlation_matrix"), + ) + y_next = corr_bottom + 1 + + dps = ds.get("tables", {}).get("data_process_summary", {}) + dps_cols = dps.get("columns", []) + dps_rows = dps.get("rows", []) + dps_changed_cells: Set[Tuple[int, int]] = set() + for r_idx in range(1, len(dps_rows)): + current = dps_rows[r_idx] + previous = dps_rows[r_idx - 1] + for c_idx in range(1, min(len(dps_cols), len(current))): + current_value = str(current[c_idx]).strip() + previous_value = str(previous[c_idx]).strip() if c_idx < len(previous) else "" + current_float = _safe_float(current_value) + previous_float = _safe_float(previous_value) + if current_float is not None and previous_float is not None: + if abs(current_float - previous_float) > 1e-12: + dps_changed_cells.add((r_idx + 1, c_idx)) + elif current_value != previous_value: + dps_changed_cells.add((r_idx + 1, c_idx)) + + ce_lines = [ + "C1 - Remove instances with no outcome and features to ignore", + "E1 - Feature engineering: add missingness features", + "C2 - Remove features with invariance or high missingness", + "C3 - Remove instances with high missingness", + "E2 - Feature engineering: add or bypass categorical one-hot encoding as configured", + "C4 - Remove highly correlated features", + "Gray cells mark values that changed from the previous step.", + ] + + # Keep the DataProcessSummary + legend together and avoid overlap. + est_table_h = 5.0 + 3.4 * float(max(2, len(dps_rows) + 1)) + est_legend_h = 5.0 + 3.7 * float(max(2, len(ce_lines))) + if y_next + est_table_h + est_legend_h > 270: + self._render_dataset_header(pdf, ds, "EDA and Feature Engineering (continued)") + y_next = 34.0 + + pdf.set_xy(10, y_next) + pdf.set_font("Times", "B", 9) + pdf.cell(190, 5, "Data Process and Feature Engineering Summary", border=1, ln=1, align="L") + if dps_cols: + y_next = self._render_table( + pdf, + x=10, + y=pdf.get_y(), + width=190, + columns=dps_cols, + rows=dps_rows, + font_size=5.4, + row_h=3.4, + shade_cells=dps_changed_cells, + max_first_col_width=30.0, + ) + else: + pdf.set_x(10) + pdf.set_font("Times", "", 7) + pdf.multi_cell(190, 3.6, "DataProcessSummary.csv not found.", border=1, align="L") + y_next = pdf.get_y() + + legend_title = "DataProcessSummary Step Key (C = cleaning, E = feature engineering)" + self._render_box( + pdf, + x=10, + y=y_next + 2, + w=190, + title=legend_title, + lines=ce_lines, + ) + + def _render_feature_learning_page(self, pdf: _StreamlinePDF, ds: Dict[str, Any]): + self._render_dataset_header(pdf, ds, "Feature Learning and Feature Selection") + figs = ds.get("figures", {}) + panels = [p for p in (figs.get("feature_learning_panels") or []) if isinstance(p, dict) and p.get("path")] + + if len(panels) >= 2: + left_bottom = self._draw_image_panel( + pdf, + x=10, + y=34, + w=90, + h=88, + title=str(panels[0].get("title") or "Top Scores (Method 1)"), + img_path=str(panels[0].get("path") or ""), + ) + right_bottom = self._draw_image_panel( + pdf, + x=110, + y=34, + w=90, + h=88, + title=str(panels[1].get("title") or "Top Scores (Method 2)"), + img_path=str(panels[1].get("path") or ""), + ) + y_next = max(left_bottom, right_bottom) + 3 + elif len(panels) == 1: + y_next = self._draw_image_panel( + pdf, + x=52, + y=34, + w=106, + h=96, + title=str(panels[0].get("title") or "Top Scores"), + img_path=str(panels[0].get("path") or ""), + ) + 3 + else: + y_next = self._draw_image_panel( + pdf, + x=52, + y=34, + w=106, + h=96, + title="Top Feature Importance Scores", + img_path=figs.get("mutual_info"), + ) + 3 + + cv_summary = ds.get("tables", {}).get("feature_cv_summary", {}) + cv_cols = cv_summary.get("columns", []) + cv_rows = cv_summary.get("rows", []) + if cv_cols: + pdf.set_xy(10, y_next) + pdf.set_font("Times", "B", 9) + pdf.cell(190, 5, "Feature Learning / Selection CV Summary", border=1, ln=1, align="L") + y_next = self._render_table( + pdf, + x=10, + y=pdf.get_y(), + width=190, + columns=cv_cols, + rows=cv_rows, + font_size=5.6, + row_h=3.7, + max_first_col_width=34.0, + ) + 3 + else: + y_next = max(y_next, 133) + + t = ds.get("tables", {}).get("informative_feature_summary", {}) + cols = t.get("columns", []) + rows = t.get("rows", []) + pdf.set_xy(10, y_next) + pdf.set_font("Times", "B", 9) + pdf.cell(190, 5, "Informative Feature Summary", border=1, ln=1, align="L") + self._render_table( + pdf, + x=10, + y=pdf.get_y(), + width=190, + columns=cols, + rows=rows, + font_size=6.5, + row_h=4.0, + max_first_col_width=62.0, + ) + + # Render additional FI method panels on continuation pages when present. + if len(panels) > 2: + remaining = panels[2:] + slots = [(10, 34), (110, 34), (10, 132), (110, 132)] + for i in range(0, len(remaining), 4): + self._render_dataset_header(pdf, ds, "Feature Learning and Feature Selection (continued)") + chunk = remaining[i : i + 4] + for panel, (x, y) in zip(chunk, slots): + self._draw_image_panel( + pdf, + x=x, + y=y, + w=90, + h=88, + title=str(panel.get("title") or "Top Scores"), + img_path=str(panel.get("path") or ""), + ) + + def _render_performance_page(self, pdf: _StreamlinePDF, ds: Dict[str, Any]): + self._render_dataset_header(pdf, ds, self.performance_page_title()) + perf = ds.get("performance", {}) + figs = ds.get("figures", {}) + mean_cols = perf.get("mean_columns", []) + mean_rows = perf.get("mean_rows", []) + mean_highlight = set( + (int(r), int(c)) + for r, c in perf.get("mean_highlight_cells", perf.get("mean_bold_cells", [])) + ) + med_cols = perf.get("median_columns", []) + med_rows = perf.get("median_rows", []) + med_highlight = set( + (int(r), int(c)) + for r, c in perf.get("median_highlight_cells", perf.get("median_bold_cells", [])) + ) + + y = 34.0 + pdf.set_xy(10, y) + pdf.set_font("Times", "B", 9) + pdf.cell(190, 5, "Model and Ensemble Performance (Mean +/- SD; gray = best/tied metric)", border=1, ln=1, align="L") + y = self._render_table( + pdf, + x=10, + y=pdf.get_y(), + width=190, + columns=mean_cols, + rows=mean_rows, + font_size=5.5, + row_h=3.4, + shade_cells=mean_highlight, + max_first_col_width=46.0, + ) + + y += 2 + pdf.set_xy(10, y) + pdf.set_font("Times", "B", 9) + pdf.cell(190, 5, "Model and Ensemble Performance (Median; gray = best/tied metric)", border=1, ln=1, align="L") + y = self._render_table( + pdf, + x=10, + y=pdf.get_y(), + width=190, + columns=med_cols, + rows=med_rows, + font_size=5.5, + row_h=3.4, + shade_cells=med_highlight, + max_first_col_width=46.0, + ) + + y = max(y + 2, 178) + metric = ds.get("performance_distribution_metric") or "" + distribution_title = f"{metric} Distribution by Algorithm" if metric else "Performance Distribution by Algorithm" + composite_path = figs.get("composite_feature_scores") + distribution_path = figs.get("performance_distribution") + + if composite_path and distribution_path: + self._draw_image_panel( + pdf, + x=10, + y=y, + w=94, + h=78, + title="Permutation Feature Importance (Composite)", + img_path=composite_path, + ) + self._draw_image_panel( + pdf, + x=106, + y=y, + w=94, + h=78, + title=distribution_title, + img_path=distribution_path, + ) + elif composite_path: + self._draw_image_panel( + pdf, + x=10, + y=y, + w=190, + h=78, + title="Permutation Feature Importance (Composite)", + img_path=composite_path, + ) + else: + self._draw_image_panel( + pdf, + x=10, + y=y, + w=190, + h=78, + title=distribution_title, + img_path=distribution_path, + ) + + def _render_evaluation_page(self, pdf: _StreamlinePDF, ds: Dict[str, Any]): + if ds.get("task_type") == "Regression": + self._render_dataset_header(pdf, ds, self.evaluation_page_title(ds)) + figs = ds.get("figures", {}) + self._draw_image_panel( + pdf, + x=10, + y=34, + w=94, + h=104, + title="Actual vs Predicted (Test Set)", + img_path=figs.get("reg_actual_vs_pred"), + ) + self._draw_image_panel( + pdf, + x=106, + y=34, + w=94, + h=104, + title="Test Residual Q-Q Plot", + img_path=figs.get("reg_test_resid"), + ) + self._draw_image_panel( + pdf, + x=10, + y=142, + w=190, + h=104, + title="Residual Distribution (Test Set)", + img_path=figs.get("reg_residual_dist"), + ) + return + + self._render_dataset_header(pdf, ds, self.evaluation_page_title(ds)) + figs = ds.get("figures", {}) + self._draw_image_panel( + pdf, + x=10, + y=34, + w=94, + h=104, + title="ROC Summary (Base Models)", + img_path=figs.get("models_roc"), + ) + self._draw_image_panel( + pdf, + x=106, + y=34, + w=94, + h=104, + title="PRC Summary (Base Models)", + img_path=figs.get("models_prc"), + ) + self._draw_image_panel( + pdf, + x=10, + y=142, + w=94, + h=104, + title="ROC Summary (Ensembles)", + img_path=figs.get("ensembles_roc"), + ) + self._draw_image_panel( + pdf, + x=106, + y=142, + w=94, + h=104, + title="PRC Summary (Ensembles)", + img_path=figs.get("ensembles_prc"), + ) + + def _render_runtime_page(self, pdf: _StreamlinePDF, ds: Dict[str, Any]): + self._render_dataset_header(pdf, ds, "Runtime Summary") + rt = ds.get("tables", {}).get("runtime", {}) + cols = rt.get("columns", []) + rows = rt.get("rows", []) + self._render_table( + pdf, + x=10, + y=34, + width=190, + columns=cols, + rows=rows, + font_size=6.5, + row_h=4.0, + max_first_col_width=72.0, + ) + + def _render_dataset_comparison_pages(self, pdf: _StreamlinePDF, block: Dict[str, Any], task_type: str): + if not block.get("present"): + return + + pdf.add_page() + pdf.set_font("Times", "B", 11) + pdf.cell(190, 6, "Dataset Comparisons", border=1, ln=1, align="L") + pdf.set_font("Times", "", 9) + pdf.cell(190, 5, "Comparison Overview (All Datasets)", border=1, ln=1, align="L") + + figs = block.get("figures", {}) + if task_type == "Regression": + keys = [ + "overview_Pearson Correlation", + "overview_Explained Variance", + "overview_Mean Absolute Error", + "overview_Mean Squared Error", + ] + else: + keys = [ + "overview_Balanced Accuracy", + "overview_ROC AUC", + "overview_PRC AUC", + "overview_F1 Score", + ] + + # Compact overview layout so DatasetComparisons consumes fewer pages. + panels = [ + (10, 34, 94, 82, keys[0], "Overview 1"), + (106, 34, 94, 82, keys[1], "Overview 2"), + (10, 120, 94, 82, keys[2], "Overview 3"), + (106, 120, 94, 82, keys[3], "Overview 4"), + ] + for x, y, w, h, key, fallback_title in panels: + if key.startswith("overview_"): + metric_label = key.replace("overview_", "") + title = f"Across Datasets: {metric_label}" + else: + title = fallback_title + self._draw_image_panel(pdf, x=x, y=y, w=w, h=h, title=title, img_path=figs.get(key)) + + if figs.get("kw_pvalues"): + pdf.set_xy(10, 206) + pdf.set_font("Times", "B", 9) + pdf.cell(190, 5, "Dataset Comparisons: Kruskal-Wallis P-Values", border=1, ln=1, align="L") + self._draw_image_panel( + pdf, + x=10, + y=211, + w=190, + h=48, + title="Kruskal-Wallis P-Value Overview", + img_path=figs.get("kw_pvalues"), + ) + + table_specs = [ + ("Best Comparisons - Kruskal-Wallis", "kw"), + ("Best Comparisons - Mann-Whitney U", "mw"), + ("Best Comparisons - Wilcoxon Rank-Sum", "wx"), + ] + # Render all stats tables across as few pages as possible. + pdf.add_page() + y = 24.0 + for title, key in table_specs: + t = block.get("tables", {}).get(key, {}) + cols = t.get("columns", []) + rows = t.get("rows", []) + if not cols: + continue + bold = set((int(r), int(c)) for r, c in t.get("bold_cells", [])) + est_h = 5.0 + 3.2 * float(max(2, len(rows) + 1)) + if y + est_h > 274: + pdf.add_page() + y = 24.0 + pdf.set_xy(10, y) + pdf.set_font("Times", "B", 11) + pdf.cell(190, 6, title, border=1, ln=1, align="L") + y = self._render_table( + pdf, + x=10, + y=pdf.get_y(), + width=190, + columns=cols, + rows=rows, + font_size=5.0, + row_h=3.2, + bold_cells=bold, + max_first_col_width=28.0, + ) + y += 3.0 + + def _render_pdf(self, report_data: Dict[str, Any]): + if FPDF is None: + raise ImportError("fpdf2 is required for PDF rendering. Install `fpdf2`.") + footer_text = ( + f"Generated with STREAMLINE ({report_data.get('streamline_version', 'unknown')}): " + "(https://github.com/UrbsLab/STREAMLINE)" + ) + pdf = _StreamlinePDF(footer_text=footer_text) + pdf.alias_nb_pages() + pdf.set_auto_page_break(auto=True, margin=12) + pdf.set_margins(10, 8, 10) + + self._render_global_summary(pdf, report_data) + + datasets = report_data.get("datasets", []) + is_replication_report = str(report_data.get("report_mode", "standard")).strip().lower() == "replication" + for ds in datasets: + self._render_dataset_eda_page(pdf, ds) + if not is_replication_report: + self._render_feature_learning_page(pdf, ds) + self._render_performance_page(pdf, ds) + self._render_evaluation_page(pdf, ds) + self._render_runtime_page(pdf, ds) + + dc = report_data.get("dataset_comparisons", {}) + task_type = datasets[0].get("task_type", "Multiclass Classification") if datasets else "Multiclass Classification" + self._render_dataset_comparison_pages(pdf, dc, task_type) + + pdf.output(str(self.paths.pdf)) + + def save_runtime(self): + rt_dir = self.exp_root / "runtime" + try: + rt_dir.mkdir(exist_ok=True) + elapsed = time.time() - (self.job_start_time or time.time()) + (rt_dir / "runtime_report.txt").write_text(str(elapsed)) + except PermissionError: + logger.warning("Could not write runtime_report.txt under %s (permission denied).", rt_dir) + + def run(self): + self.job_start_time = time.time() + + datasets = self._list_datasets() + if not datasets: + if self.report_mode == "replication": + raise RuntimeError( + "No replication dataset folders found. Expected " + "/replication// with exploratory/ and model_evaluation/." + ) + raise RuntimeError( + "No dataset folders found. Expected subdirectories containing exploratory/ and model_evaluation/." + ) + + metadata_pickle = self._read_pickle_if_exists(self.exp_root / "metadata.pickle") or {} + alg_info = self._read_pickle_if_exists(self.exp_root / "algInfo.pickle") or {} + run_params_all = self._read_pickle_if_exists(self.exp_root / "run_params.pickle") or {} + run_params = self._latest_run_params(run_params_all) + + # Optional metadata fallback to constructor values. + metadata = { + "Experiment Root": str(self.exp_root), + "Output Path": str(self.exp_root.parent), + "Experiment Name": self.experiment_name, + "Outcome Label": self.outcome_label or metadata_pickle.get("Outcome Label", ""), + "Outcome Type": self.outcome_type or metadata_pickle.get("Outcome Type", ""), + "Instance Label": self.instance_label or metadata_pickle.get("Instance Label", ""), + } + + dataset_blocks: List[Dict[str, Any]] = [] + for idx, ds_dir in enumerate(datasets, start=1): + dataset_id = f"D{idx}" + dataset_blocks.append(self._collect_dataset_block(ds_dir, dataset_id, metadata_pickle)) + + primary_task = dataset_blocks[0].get("task_type", "Multiclass Classification") + if self.report_mode == "replication": + # Replication mode focuses on available replication outputs only. + dc_block = {"present": False} + else: + dc_block = ( + self._collect_dataset_comparisons(primary_task, dataset_blocks) + if len(dataset_blocks) > 1 + else {"present": False} + ) + + if self.report_mode == "replication": + report_title = "STREAMLINE Replication Data Evaluation Report" + else: + report_title = "STREAMLINE Testing Data Evaluation Report" + + run_command_summary = self.build_run_command_summary( + metadata=metadata, + metadata_pickle=metadata_pickle, + run_params_all=run_params_all, + run_params=run_params, + dataset_blocks=dataset_blocks, + ) + + report_data: Dict[str, Any] = { + "title": report_title, + "generated_at": _now_iso_local(), + "generated_at_epoch": int(time.time()), + "streamline_version": _try_streamline_version(), + "experiment_name": self.experiment_name, + "experiment_root": str(self.exp_root), + "report_mode": self.report_mode, + "metadata": metadata, + "metadata_pickle": metadata_pickle, + "alg_info": alg_info, + "run_params": run_params, + "run_command_summary": run_command_summary, + "datasets": dataset_blocks, + "dataset_comparisons": dc_block, + } + + self.paths.data_json.write_text(json.dumps(report_data, indent=2)) + + if self.make_pdf: + self._render_pdf(report_data) + + jobs_completed = self.exp_root / "jobsCompleted" + try: + jobs_completed.mkdir(exist_ok=True) + (jobs_completed / "job_reporting.txt").write_text("complete") + except PermissionError: + logger.warning("Could not write job completion marker under %s (permission denied).", jobs_completed) + self.save_runtime() + logger.info("Reporting phase complete: %s", self.paths.pdf) + + +ReportPhaseJobPdfFlow = ReportPhaseJob + + +def _build_arg_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(description="Generate STREAMLINE Testing Data Evaluation PDF report.") + parser.add_argument("--experiment-path", help="Path to experiment output directory.") + parser.add_argument("--output-path", help="Parent output path containing experiment directory.") + parser.add_argument("--experiment-name", help="Experiment folder name.") + parser.add_argument( + "--reporting-dir", + default=None, + help="Optional output directory for report artifacts (report_data.json, experiment-named PDF, figures).", + ) + parser.add_argument( + "--report-mode", + default="standard", + choices=["standard", "replication"], + help="Report scope: standard datasets or replication datasets under replication/ folders.", + ) + parser.add_argument("--outcome-label", default=None) + parser.add_argument("--outcome-type", default=None) + parser.add_argument("--instance-label", default=None) + parser.add_argument("--no-pdf", action="store_true", help="Skip PDF generation and only build report_data.json.") + parser.add_argument("--no-plots", action="store_true", help="Disable on-the-fly figure generation.") + parser.add_argument( + "--no-reuse-figures", + action="store_true", + help="Do not reuse existing PNGs from report/figure locations before generation.", + ) + return parser + + +def main(): + parser = _build_arg_parser() + args = parser.parse_args() + job = ReportPhaseJob( + output_path=args.output_path, + experiment_name=args.experiment_name, + experiment_path=args.experiment_path, + reporting_dir=args.reporting_dir, + report_mode=args.report_mode, + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + instance_label=args.instance_label, + make_pdf=not args.no_pdf, + enable_plots=not args.no_plots, + reuse_existing_figures=not args.no_reuse_figures, + ) + job.run() + + +if __name__ == "__main__": + main() diff --git a/streamline/legacy/__init__.py b/streamline/p1_data_process/__init__.py similarity index 100% rename from streamline/legacy/__init__.py rename to streamline/p1_data_process/__init__.py diff --git a/streamline/p1_data_process/data_process.py b/streamline/p1_data_process/data_process.py new file mode 100644 index 00000000..b95f3ddf --- /dev/null +++ b/streamline/p1_data_process/data_process.py @@ -0,0 +1,1049 @@ +# dataprocess.py (your refactored DataProcess file) + +import copy +import csv +import os +import time +import pickle +import random +import logging +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +from sklearn.covariance import EllipticEnvelope +from sklearn.ensemble import IsolationForest +from sklearn.experimental import enable_iterative_imputer # noqa: F401 +from sklearn.impute import IterativeImputer +from sklearn.neighbors import LocalOutlierFactor +from sklearn.preprocessing import StandardScaler + +from streamline.p1_data_process.utils.kfold_partitioning import KFoldPartitioner +from scipy.stats import chi2_contingency, fisher_exact, mannwhitneyu, f_oneway, kruskal, spearmanr, skew, kurtosis +from pandas.api.types import is_numeric_dtype +import seaborn as sns +import warnings + +from streamline.p1_data_process.utils.validators import find_cv_pairs, validate_cv_pair +from streamline.p1_data_process.utils.features_meta import build_feature_meta, save_feature_meta + +warnings.filterwarnings(action='ignore', category=UserWarning) +warnings.filterwarnings(action='ignore', category=RuntimeWarning) + +sns.set_theme() + + +class DataProcess: + """ + STREAMLINE Phase-1 (DataFrame-only). Heavy plots are disabled by default; + produce CSV artifacts first, then use render_plots_from_artifacts.py to plot later. + """ + + def __init__( + self, + data: pd.DataFrame, + experiment_path: str, + outcome_label: str, + outcome_type: "str | None" = None, + match_label: "str | None" = None, + instance_label: "str | None" = None, + ignore_features=None, + categorical_features=None, + quantitative_features=None, + exclude_eda_output=None, + categorical_cutoff: int = 10, + sig_cutoff: float = 0.05, + featureeng_missingness: float = 0.5, + cleaning_missingness: float = 0.5, + correlation_removal_threshold: float = 1.0, + partition_method: str = "Stratified", + n_splits: int = 10, + one_hot_encoding: bool = True, + cv_provided: bool = False, + cv_input_path: "str | None" = None, + random_state: "int | None" = None, + show_plots: bool = False, + dataset_name: str = "dataset", + + # NEW: plotting flags (all default False) + enable_plots: bool = False, + plot_missingness: bool = False, + plot_class_counts: bool = False, + plot_correlation: bool = False, + correlation_plot_max_features: int = 200, + plot_univariate: bool = False, + univariate_top_k: int = 20, + plot_anomalies: bool = False, + ): + if not isinstance(data, pd.DataFrame): + raise TypeError("`data` must be a pandas DataFrame.") + if outcome_label not in data.columns: + raise ValueError(f"Outcome column '{outcome_label}' not found in data.") + + self.data = data.copy() + self.experiment_path = experiment_path + self.name = dataset_name + + # labels + self.outcome_label = outcome_label + self.match_label = match_label if (match_label in self.data.columns) else None + self.instance_label = instance_label if (instance_label in self.data.columns) else None + + # outcome type: respect an explicit user/config override, otherwise infer. + explicit_outcome_type = self._normalize_outcome_type(outcome_type) + if explicit_outcome_type is not None: + self.outcome_type = explicit_outcome_type + else: + n_unique = self.data[self.outcome_label].nunique() + if n_unique == 2: + self.outcome_type = "Binary" + elif 2 < n_unique <= categorical_cutoff: + self.outcome_type = "Multiclass" + else: + self.outcome_type = "Continuous" + + # keep explorations (CSV-producing analyses) + explorations_list = ["Describe", "Univariate Analysis", "Feature Correlation"] + if exclude_eda_output is not None: + known_exclude_options = ['describe_csv', 'correlation'] + for x in exclude_eda_output: + if x not in known_exclude_options: + logging.warning("Unknown EDA exclusion option %s", x) + if 'describe_csv' in exclude_eda_output and "Describe" in explorations_list: + explorations_list.remove("Describe") + if 'correlation' in exclude_eda_output and "Feature Correlation" in explorations_list: + explorations_list.remove("Feature Correlation") + # we no longer treat *_plots here; plotting is controlled only by `plots` below + + self.explorations = explorations_list + + # ignore features + if ignore_features is None: + self.ignore_features = [] + elif isinstance(ignore_features, str): + self.ignore_features = list(pd.read_csv(ignore_features, sep=',').iloc[:, 0]) + elif isinstance(ignore_features, list): + self.ignore_features = ignore_features + else: + raise ValueError("`ignore_features` must be None, path to CSV, or list of strings.") + + # user-specified categorical/quantitative + if categorical_features is None: + self.specified_categorical = None + elif isinstance(categorical_features, str) and categorical_features != '': + self.specified_categorical = list(pd.read_csv(categorical_features, sep=',').iloc[:, 0]) + elif isinstance(categorical_features, list): + self.specified_categorical = list(categorical_features) + elif categorical_features == '': + self.specified_categorical = None + else: + raise ValueError("`categorical_features` must be None, path, list, or ''.") + + if quantitative_features is None: + self.specified_quantitative = None + elif isinstance(quantitative_features, str) and quantitative_features != '': + self.specified_quantitative = list(pd.read_csv(quantitative_features, sep=',').iloc[:, 0]) + elif isinstance(quantitative_features, list): + self.specified_quantitative = list(quantitative_features) + elif quantitative_features == '': + self.specified_quantitative = None + else: + raise ValueError("`quantitative_features` must be None, path, list, or ''.") + + # state + self.quantitative_features: list[str] = [] + self.categorical_features: list[str] = [] + self.engineered_features: list[str] = [] + self.one_hot_features: list[str] = [] + self.categorical_cutoff = int(categorical_cutoff) + self.featureeng_missingness = float(featureeng_missingness) + self.cleaning_missingness = float(cleaning_missingness) + self.correlation_removal_threshold = correlation_removal_threshold + self.sig_cutoff = float(sig_cutoff) + + # NEW: plotting controls + self.enable_plots = bool(enable_plots) + self.plot_missingness = bool(plot_missingness) + self.plot_class_counts = bool(plot_class_counts) + self.plot_correlation = bool(plot_correlation) + self.correlation_plot_max_features = int(correlation_plot_max_features) + self.plot_univariate = bool(plot_univariate) + self.univariate_top_k = int(univariate_top_k) + self.plot_anomalies = bool(plot_anomalies) + + self.show_plots = bool(show_plots) # interactive display toggle + + # CV config + self.cv_partitioner = None + self.partition_method = partition_method + if self.outcome_type == "Continuous": + self.partition_method = "Random" + self.n_splits = int(n_splits) + self.one_hot_encoding = bool(one_hot_encoding) + self.cv_provided = bool(cv_provided) + self.cv_input_path = cv_input_path + + self.random_state = random_state + self.job_start_time = None # runtime + + @staticmethod + def _normalize_outcome_type(value): + if value is None or str(value).strip() == "": + return None + normalized = str(value).strip().lower() + aliases = { + "binary": "Binary", + "bin": "Binary", + "classification_binary": "Binary", + "multiclass": "Multiclass", + "multi": "Multiclass", + "classification_multiclass": "Multiclass", + "continuous": "Continuous", + "regression": "Continuous", + "numeric": "Continuous", + } + if normalized not in aliases: + raise ValueError( + "outcome_type must be one of Binary, Multiclass, Continuous, " + f"or a supported alias; got {value!r}" + ) + return aliases[normalized] + + # ---------------------------- + # Main flow + # ---------------------------- + def run(self, top_features=20): + self.job_start_time = time.time() + + if self.cv_provided: + self.run_process(top_features) + self.import_user_cv() + else: + self.run_process(top_features) + self.cv_partitioner = KFoldPartitioner( + data=self.data, + partition_method=self.partition_method, + experiment_path=self.experiment_path, + n_splits=self.n_splits, + random_state=self.random_state, + outcome_label=self.outcome_label, + match_label=self.match_label, + dataset_name=self.name, + ) + self.cv_partitioner.run() + + self.save_runtime() + + def run_process(self, top_features=20): + random.seed(self.random_state); np.random.seed(self.random_state) + self.make_log_folders() + + if self.match_label is None or self.match_label not in self.data.columns: + self.match_label = None + self.partition_method = 'Stratified' + logging.warning("Specified 'match_label' not found; defaulting to Stratified CV.") + + if self.outcome_type == "Continuous": + self.partition_method = 'Random' + logging.warning("Continuous outcome detected; defaulting to Random CV.") + + self.identify_feature_types() + + logging.info("Running Initial EDA:") + self.initial_eda(initial='initial/') + + self.data_manipulation_steps(top_features) + + # self.anomaly_detection() + + self.second_eda(top_features) + + def data_manipulation_steps(self, top_features=20): + self.set_original_headers() + + # Transition table + if self.outcome_type == "Binary": + cols = ['Instances','Total Features','Categorical Features','Quantitative Features', + 'Missing Values','Missing Percent','Class 0','Class 1'] + elif self.outcome_type == "Multiclass": + n_class = len(self.counts_summary(save=False)) - 6 + cols = ['Instances','Total Features','Categorical Features','Quantitative Features', + 'Missing Values','Missing Percent'] + [f'Class {i}' for i in range(n_class)] + else: + cols = ['Instances','Total Features','Categorical Features','Quantitative Features', + 'Missing Values','Missing Percent'] + transition_df = pd.DataFrame(columns=cols) + + transition_df.loc["Original"] = self.counts_summary(save=False) + + self.label_encoder() + self.drop_ignored_rowcols() + transition_df.loc["C1"] = self.counts_summary(save=False) + + self.feature_engineering() + transition_df.loc["E1"] = self.counts_summary(save=False) + + self.drop_invariant() + self.feature_removal() + transition_df.loc["C2"] = self.counts_summary(save=False) + + self.instance_removal() + transition_df.loc["C3"] = self.counts_summary(save=False) + + self.categorical_feature_encoding_pandas() + transition_df.loc["E2"] = self.counts_summary(save=False) + + if (self.correlation_removal_threshold is not None + and self.correlation_removal_threshold <= 1 + and "Feature Correlation" in self.explorations): + self.drop_highly_correlated_features() + transition_df.loc["C4"] = self.counts_summary(save=False) + + self.set_processed_headers() + transition_df.to_csv(os.path.join(self.experiment_path, self.name, 'exploratory', 'DataProcessSummary.csv'), + index=True) + + with open(os.path.join(self.experiment_path, self.name, 'exploratory', 'categorical_features.pickle'), 'wb') as f: + pickle.dump(self.categorical_features, f) + with open(os.path.join(self.experiment_path, self.name, 'exploratory', 'post_processed_features.pickle'), 'wb') as f: + pickle.dump(list(self.data.columns), f) + + # ---------------------------- + # Inlined helpers + # ---------------------------- + def feature_only_data(self): + drop_cols = [self.outcome_label] + if self.instance_label and self.instance_label in self.data.columns: + drop_cols.append(self.instance_label) + if self.match_label and self.match_label in self.data.columns: + drop_cols.append(self.match_label) + return self.data.drop(columns=[c for c in drop_cols if c in self.data.columns], errors="ignore") + + def non_feature_data(self): + cols = [self.outcome_label] + if self.instance_label and self.instance_label in self.data.columns: + cols.append(self.instance_label) + if self.match_label and self.match_label in self.data.columns: + cols.append(self.match_label) + return self.data[cols] + + def get_outcome(self): + return self.data[self.outcome_label] + + def clean_data(self, ignore_features: "list[str] | None"): + self.data = self.data.dropna(axis=0, how='any', subset=[self.outcome_label]).reset_index(drop=True) + try: + if self.outcome_type in ("Binary", "Multiclass"): + self.data[self.outcome_label] = self.data[self.outcome_label].astype('int8') + except Exception: + pass + if ignore_features: + self.data = self.data.drop(ignore_features, axis=1, errors='ignore') + + def get_headers(self): + headers = list(self.data.columns) + for c in [self.outcome_label, self.match_label, self.instance_label]: + if c and c in headers: + headers.remove(c) + return headers + + def set_original_headers(self, phase: str = "exploratory", initial: str = "initial/"): + path = os.path.join(self.experiment_path, self.name, phase) + os.makedirs(path, exist_ok=True) + + headers = self.get_headers() + + # Represent headers as a single-row DataFrame to preserve original layout + df = pd.DataFrame([headers]) + + out_path = os.path.join(path, f"{initial}OriginalFeatureNames.csv") + df.to_csv(out_path, index=False, header=False) + + return headers + + + def set_processed_headers(self, phase: str = "exploratory", initial: str = ""): + path = os.path.join(self.experiment_path, self.name, phase) + os.makedirs(path, exist_ok=True) + + headers = self.get_headers() + + df = pd.DataFrame([headers]) + + out_path = os.path.join(path, f"{initial}ProcessedFeatureNames.csv") + df.to_csv(out_path, index=False, header=False) + + return headers + + def describe_data(self, initial=''): + path = os.path.join(self.experiment_path, self.name, 'exploratory') + os.makedirs(path, exist_ok=True) + self.data.describe().to_csv(os.path.join(path, initial + 'DescribeDataset.csv')) + self.data.dtypes.to_csv(os.path.join(path, initial + 'DtypesDataset.csv'), + header=['DataType'], index_label='Variable') + self.data.nunique().to_csv(os.path.join(path, initial + 'NumUniqueDataset.csv'), + header=['Count'], index_label='Variable') + + def missingness_counts(self, initial='', save=True): + missing_count = self.data.isnull().sum() + total_missing = int(missing_count.sum()) + if save: + path = os.path.join(self.experiment_path, self.name, 'exploratory') + os.makedirs(path, exist_ok=True) + missing_count.to_csv(os.path.join(path, initial + 'DataMissingness.csv'), + header=['Count'], index_label='Variable') + return total_missing + + def missing_count_plot(self, initial=''): + """PNG only if enabled.""" + if not (self.enable_plots and self.plot_missingness): + return + path = os.path.join(self.experiment_path, self.name, 'exploratory') + os.makedirs(path, exist_ok=True) + missing_count = self.data.isnull().sum() + plt.hist(missing_count, bins=100) + plt.xlabel("Missing Value Counts") + plt.ylabel("Frequency") + plt.title("Histogram of Missing Value Counts in Dataset") + plt.savefig(os.path.join(path, initial + 'DataMissingnessHistogram.png'), bbox_inches='tight') + if self.show_plots: + plt.show() + plt.close('all') + + def feature_correlation(self, x_data: "pd.DataFrame | None" = None, initial=''): + """Always writes CSV; PNG heatmap only if enabled and within feature limit.""" + if x_data is None: + x_data = self.feature_only_data() + path = os.path.join(self.experiment_path, self.name, 'exploratory') + os.makedirs(path, exist_ok=True) + + corr = x_data.corr(method='pearson', numeric_only=True) + corr.to_csv(os.path.join(path, initial + 'FeatureCorrelations.csv')) + + # plot if allowed and not too wide + if self.enable_plots and self.plot_correlation and x_data.shape[1] <= self.correlation_plot_max_features: + import numpy as np + mask = np.zeros_like(corr, dtype=bool) + mask[np.triu_indices_from(mask)] = True + num_features = len(x_data.columns) + sns.set_style("white") + fig_size = (max(6, num_features // 2), max(6, num_features // 2)) + plt.subplots(figsize=fig_size) + sns.heatmap(corr, mask=mask, vmax=1, vmin=-1, square=True, cmap='RdBu', cbar_kws={"shrink": .75}) + plt.savefig(os.path.join(path, initial + 'FeatureCorrelations.png'), bbox_inches='tight') + if self.show_plots: + plt.show() + plt.close('all') + sns.set_theme() + + + def import_user_cv(self): + if not self.cv_input_path: + raise Exception("cv_input_path must be provided when cv_provided=True") + + ds_root = os.path.join(self.experiment_path, self.name) + cv_src = os.path.join(self.cv_input_path, "CVDatasets") + cv_dst = os.path.join(ds_root, "CVDatasets") + + if not os.path.isdir(cv_src): + raise Exception(f"Expected CVDatasets/ under: {self.cv_input_path}") + + os.makedirs(cv_dst, exist_ok=True) + + pairs = find_cv_pairs(cv_src) + if not pairs: + raise Exception(f"No complete Train/Test fold pairs found under {cv_src}") + + outcome = self.outcome_label + instance = self.instance_label + + for fold, files in pairs.items(): + df_tr = pd.read_csv(files["Train"], na_values="NA") + df_te = pd.read_csv(files["Test"], na_values="NA") + validate_cv_pair(df_tr, df_te, outcome, instance) + + out_train = os.path.join(cv_dst, f"{self.name}_CV_{fold}_Train.csv") + out_test = os.path.join(cv_dst, f"{self.name}_CV_{fold}_Test.csv") + df_tr.to_csv(out_train, index=False) + df_te.to_csv(out_test, index=False) + + idx_path = os.path.join(ds_root, f"cv_index_cv{fold}.csv") + pd.DataFrame({"split": "Train", "index": df_tr.index}).to_csv(idx_path, index=False, mode="w") + pd.DataFrame({"split": "Test", "index": df_te.index}).to_csv(idx_path, index=False, mode="a", header=False) + + # try feature_meta + try: + feature_meta = { + "dataset_name": self.name, + "outcome_label": self.outcome_label, + "match_label": self.match_label, + "instance_label": self.instance_label, + "categorical_features": list(self.categorical_features), + "quantitative_features": list(self.quantitative_features), + "one_hot": self.one_hot_encoding, + "one_hot_features": list(self.one_hot_features), + "engineered_features": list(self.engineered_features), + "columns": list(self.data.columns), + } + save_feature_meta(self.experiment_path, self.name, feature_meta) + except Exception as e: + logging.warning(f"Feature meta not saved via util; ({e})") + + with open(os.path.join(ds_root, "phase_done.json"), "w") as f: + f.write('{"phase":"p1_data","mode":"import_user_cv"}') + + def make_log_folders(self): + base = os.path.join(self.experiment_path, self.name) + os.makedirs(os.path.join(base), exist_ok=True) + os.makedirs(os.path.join(base, 'exploratory'), exist_ok=True) + os.makedirs(os.path.join(base, 'exploratory', 'anomaly_detection'), exist_ok=True) + os.makedirs(os.path.join(base, 'exploratory', 'initial'), exist_ok=True) + + def identify_feature_types(self, x_data: "pd.DataFrame | None" = None): + logging.info("Validating and Identifying Feature Types...") + + if self.specified_categorical is not None: + self.specified_categorical = [s.strip() for s in self.specified_categorical] + if self.specified_quantitative is not None: + self.specified_quantitative = [s.strip() for s in self.specified_quantitative] + + if self.specified_quantitative is not None and self.specified_categorical is not None: + dup = list(set(self.specified_categorical) & set(self.specified_quantitative)) + if dup: + raise Exception("Features specified as both categorical and quantitative: " + str(dup)) + logging.warning("Both cat/quant lists provided; binaries treated as categorical; remaining auto-assigned.") + + if self.specified_quantitative is None and self.specified_categorical is None: + logging.warning("No user lists; auto-assign based on cutoff and dtype.") + + if x_data is None: + x_data = self.feature_only_data() + + headers = list(x_data.columns) + if self.specified_categorical is not None: + self.specified_categorical = [f for f in self.specified_categorical if f in headers] + if self.specified_quantitative is not None: + self.specified_quantitative = [f for f in self.specified_quantitative if f in headers] + + # binaries => categorical + binary_categoricals_dict = {} + for col in headers: + unique_vals = x_data[col].dropna().unique().tolist() + if len(unique_vals) == 2: + if str(x_data[col].dtype) != 'object': + binary_categoricals_dict[col] = unique_vals + self.categorical_features.append(col) + if self.specified_quantitative and col in self.specified_quantitative: + self.specified_quantitative.remove(col) + + with open(os.path.join(self.experiment_path, self.name, 'exploratory', 'binary_categorical_dict.pickle'), 'wb') as f: + pickle.dump(binary_categoricals_dict, f) + + if self.specified_categorical is not None and self.specified_quantitative is None: + logging.warning("Only categorical list provided; others quantitative unless binary.") + self.categorical_features = list(set(self.categorical_features + self.specified_categorical)) + self.quantitative_features = list(set(self.get_headers()) - set(self.categorical_features)) + + if self.specified_quantitative is not None and self.specified_categorical is None: + logging.warning("Only quantitative list provided; others categorical.") + self.quantitative_features = list(self.specified_quantitative) + self.categorical_features = list(set(self.get_headers()) - set(self.quantitative_features)) + + if self.specified_quantitative is not None and self.specified_categorical is not None: + self.quantitative_features = list(set(self.specified_quantitative)) + self.categorical_features = list(set(self.categorical_features + self.specified_categorical)) + + # auto assign remaining + for col in headers: + if col not in self.categorical_features and col not in self.quantitative_features: + if x_data[col].nunique() <= self.categorical_cutoff or not pd.api.types.is_numeric_dtype(x_data[col]): + self.categorical_features.append(col) + else: + self.quantitative_features.append(col) + + init_dir = os.path.join(self.experiment_path, self.name, 'exploratory', 'initial') + os.makedirs(init_dir, exist_ok=True) + with open(os.path.join(init_dir, 'initial_categorical_features.pickle'), 'wb') as f: + pickle.dump(self.categorical_features, f) + with open(os.path.join(init_dir, 'initial_quantitative_features.pickle'), 'wb') as f: + pickle.dump(self.quantitative_features, f) + with open(os.path.join(init_dir, 'initial_categorical_features.csv'), 'w', newline="") as f: + csv.writer(f).writerow(self.categorical_features) + with open(os.path.join(init_dir, 'initial_quantitative_features.csv'), 'w', newline="") as f: + csv.writer(f).writerow(self.quantitative_features) + + def counts_summary(self, total_missing=None, save=True, replicate=False): + f_count = self.data.shape[1] - 1 + if self.instance_label is not None and self.instance_label in self.data.columns: + f_count -= 1 + if self.match_label is not None and self.match_label in self.data.columns: + f_count -= 1 + + if total_missing is None: + total_missing = self.missingness_counts(save=False) + percent_missing = int(total_missing) / float(self.data.shape[0] * max(1, f_count)) + + summary = [ + ['instances', self.data.shape[0]], + ['features', f_count], + ['categorical_features', len(self.categorical_features)], + ['quantitative_features', len(self.quantitative_features)], + ['missing_values', total_missing], + ['missing_percent', round(percent_missing, 5)] + ] + summary_df = pd.DataFrame(summary, columns=['Variable', 'Count']) + class_counts = self.data[self.outcome_label].value_counts() + + if save: + out_dir = os.path.join(self.experiment_path, self.name, 'exploratory') + os.makedirs(out_dir, exist_ok=True) + summary_df.to_csv(os.path.join(out_dir, 'DataCounts.csv'), index=False) + + if self.outcome_type in ("Binary", "Multiclass"): + df_value_counts = pd.DataFrame(class_counts).reset_index() + df_value_counts.columns = ['Class', 'Instances'] + class_counts.to_csv(os.path.join(out_dir, 'ClassCounts.csv'), header=['Count'], index_label='Class') + else: + df_value_counts = pd.DataFrame(class_counts).reset_index() + df_value_counts.columns = ['Top Occurring Values', 'Counts'] + class_counts.to_csv(os.path.join(out_dir, 'ClassCounts.csv'), header=['Count'], index_label='Label') + logging.info("Skewness: %s", str(skew(self.data[self.outcome_label]))) + logging.info("Kurtosis: %s", str(kurtosis(self.data[self.outcome_label]))) + + if not replicate: + logging.info("Categorical: %s", self.categorical_features) + logging.info("Quantitative: %s", self.quantitative_features) + + # PNG only if enabled + if self.enable_plots and self.plot_class_counts: + if self.outcome_type in ("Binary", "Multiclass"): + class_counts.plot(kind='bar') + plt.ylabel('Count') + plt.title('Class Counts') + else: + plt.figure() + plt.hist(self.data[self.outcome_label], bins=100) + plt.ylabel('Count'); plt.xlabel('Label'); plt.title('Label Counts') + plt.savefig(os.path.join(out_dir, 'ClassCountsBarPlot.png'), bbox_inches='tight') + if self.show_plots: plt.show() + plt.close('all') + + if self.outcome_type == "Binary": + return list(summary_df['Count']) + [class_counts.get(0, 0), class_counts.get(1, 0)] + elif self.outcome_type == "Multiclass": + class_counts_list = [class_counts[i] for i in class_counts.index] + return list(summary_df['Count']) + class_counts_list + else: + return list(summary_df['Count']) + + def label_encoder(self): + string_cols = [feat for feat, typ in self.data.dtypes.to_dict().items() + if str(typ) == 'object' and (self.instance_label is None or feat != self.instance_label)] + + ord_label = pd.DataFrame(columns=['Category', 'Encoding']) + if len(string_cols) > 0: + logging.info("Ordinal encoding textual features...") + for feat in string_cols: + if feat in self.quantitative_features \ + and not (feat == self.outcome_label or (self.match_label and feat == self.match_label)): + raise Exception("Text feature specified as quantitative; please encode it before running.") + if feat not in self.categorical_features \ + and not (feat == self.outcome_label or (self.match_label and feat == self.match_label)): + self.categorical_features.append(feat) + + if feat == self.outcome_label: + self.data[feat], labels = pd.factorize(self.data[feat]) + ord_label.loc[feat] = [list(labels), list(range(len(labels)))] + elif self.data[feat].nunique() <= 2: + self.data[feat], labels = pd.factorize(self.data[feat]) + ord_label.loc[feat] = [list(labels), list(range(len(labels)))] + + out_dir = os.path.join(self.experiment_path, self.name, 'exploratory') + os.makedirs(out_dir, exist_ok=True) + ord_label.to_csv(os.path.join(out_dir, 'Numerical_Encoding_Map.csv')) + with open(os.path.join(out_dir, 'ordinal_encoding.pickle'), 'wb') as f: + pickle.dump(ord_label, f) + + def drop_ignored_rowcols(self, ignored_features=None): + if ignored_features is None: + ignored_features = self.ignore_features + for feat in ignored_features: + if feat in self.categorical_features: self.categorical_features.remove(feat) + if feat in self.quantitative_features: self.quantitative_features.remove(feat) + self.clean_data(ignored_features) + + def drop_invariant(self): + try: + invariant_columns = list(self.data.columns[self.data.nunique(dropna=True) <= 1]) + except Exception: + invariant_columns = [] + if invariant_columns: + for feat in list(invariant_columns): + for lst in (self.categorical_features, self.quantitative_features, + self.engineered_features, self.one_hot_features): + if feat in lst: + lst.remove(feat) + self.data.drop(invariant_columns, axis=1, inplace=True) + + def feature_engineering(self): + missingness = self.data.isnull().sum() / len(self.data) + high_missing = list(missingness[missingness > self.featureeng_missingness].index) + self.engineered_features = ['Miss_' + f for f in high_missing] + for feat in high_missing: + newf = 'Miss_' + feat + self.data[newf] = self.data[feat].isnull().astype(int) + self.categorical_features.append(newf) + out_dir = os.path.join(self.experiment_path, self.name, 'exploratory') + os.makedirs(out_dir, exist_ok=True) + if high_missing: + with open(os.path.join(out_dir, 'engineered_features.pickle'), 'wb') as f: + pickle.dump(high_missing, f) + with open(os.path.join(out_dir, 'Missingness_Engineered_Features.csv'), 'w') as f: + f.write("\n".join(self.engineered_features)) + + def feature_removal(self): + original = self.get_headers() + thresh = int(self.data.shape[0] * self.cleaning_missingness) - 1 + self.data.dropna(thresh=thresh, axis=1, inplace=True) + new_features = self.get_headers() + removed = [c for c in original if c not in new_features] + for feat in removed: + for lst in (self.categorical_features, self.engineered_features, + self.one_hot_features, self.quantitative_features): + if feat in lst: + lst.remove(feat) + out_dir = os.path.join(self.experiment_path, self.name, 'exploratory') + if removed: + with open(os.path.join(out_dir, 'removed_features.pickle'), 'wb') as f: + pickle.dump(removed, f) + with open(os.path.join(out_dir, 'Missingness_Feature_Cleaning.csv'), 'w') as f: + f.write("\n".join(removed)) + + def instance_removal(self): + f_count = self.data.shape[1] - 1 + if self.instance_label is not None and self.instance_label in self.data.columns: + f_count -= 1 + if self.match_label is not None and self.match_label in self.data.columns: + f_count -= 1 + self.data = self.data[self.data.isnull().sum(axis=1) < int(self.cleaning_missingness * max(1, f_count))] + + def categorical_feature_encoding_pandas(self): + non_binary_categorical = [] + for feat in list(self.categorical_features): + if feat in self.data.columns and self.data[feat].nunique() > 2: + non_binary_categorical.append(feat) + + if len(non_binary_categorical) > 0 and self.one_hot_encoding: + one_hot_df = pd.get_dummies(self.data[non_binary_categorical], columns=non_binary_categorical) + self.one_hot_features = list(one_hot_df.columns) + self.data.drop(non_binary_categorical, axis=1, inplace=True) + self.data = pd.concat([self.data, one_hot_df], axis=1) + for feat in non_binary_categorical: + if feat in self.categorical_features: + self.categorical_features.remove(feat) + self.categorical_features += self.one_hot_features + + out_dir = os.path.join(self.experiment_path, self.name, 'exploratory') + with open(os.path.join(out_dir, 'one_hot_feature.pickle'), 'wb') as f: + pickle.dump(self.one_hot_features, f) + + def drop_highly_correlated_features(self): + df_corr_org = self.feature_only_data().corr() + df_corr = df_corr_org.stack().reset_index() + df_corr.columns = ['Removed_Feature', 'Correlated_Feature', 'Correlation'] + mask_dups = (df_corr[['Removed_Feature', 'Correlated_Feature']].apply(frozenset, axis=1).duplicated()) | \ + (df_corr['Removed_Feature'] == df_corr['Correlated_Feature']) + df_corr = df_corr[~mask_dups].sort_values(by='Correlation', key=abs, ascending=False) + df_corr = df_corr[abs(df_corr['Correlation']) >= float(self.correlation_removal_threshold)] + features_to_drop = [f for f in df_corr['Removed_Feature'] if f in self.data.columns] + + if features_to_drop: + for feat in features_to_drop: + for lst in (self.categorical_features, self.engineered_features, + self.one_hot_features, self.quantitative_features): + if feat in lst: + lst.remove(feat) + self.data.drop(columns=features_to_drop, inplace=True, errors='ignore') + + out_dir = os.path.join(self.experiment_path, self.name, 'exploratory') + with open(os.path.join(out_dir, 'correlated_features.pickle'), 'wb') as f: + pickle.dump(features_to_drop, f) + + all_features = set(self.get_headers()) + features_kept = list(all_features - set(features_to_drop)) + with open(os.path.join(out_dir, 'correlation_feature_cleaning.csv'), 'w', newline='') as file: + writer = csv.writer(file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) + writer.writerow(['Retained Feature', 'Deleted Features']) + for feat in features_kept: + if feat in df_corr_org.columns: + corr_feat = list(df_corr_org[abs(df_corr_org[feat]) >= float(self.correlation_removal_threshold)].index) + if feat in corr_feat: corr_feat.remove(feat) + if corr_feat: + writer.writerow([feat] + corr_feat) + + def initial_eda(self, initial='initial/'): + logging.info(self.experiment_path) + if "Describe" in self.explorations: + self.describe_data(initial=initial) + _ = self.missingness_counts(initial=initial) + self.missing_count_plot(initial=initial) # will only plot if flags allow + if "Feature Correlation" in self.explorations: + self.feature_correlation(initial=initial) # CSV always; PNG gated + + def second_eda(self, top_features=20): + logging.info("Running Post-Processing EDA...") + + if "Describe" in self.explorations: + self.describe_data() + total_missing = self.missingness_counts() + self.counts_summary(total_missing, save=True, replicate=False) + self.missing_count_plot() # gated + + if "Feature Correlation" in self.explorations: + x_data = self.feature_only_data() + self.feature_correlation(x_data) # CSV always; PNG gated + + if "Univariate Analysis" in self.explorations: + sorted_p_list = self.univariate_analysis(top_features) + if self.enable_plots and self.plot_univariate: + self.univariate_plots(sorted_p_list[: self.univariate_top_k]) + + pd.DataFrame(self.categorical_features, columns=['Feature']).to_csv( + os.path.join(self.experiment_path, self.name, 'exploratory', 'processed_categorical_features.csv'), + index=False + ) + pd.DataFrame(self.quantitative_features, columns=['Feature']).to_csv( + os.path.join(self.experiment_path, self.name, 'exploratory', 'processed_quantitative_features.csv'), + index=False + ) + + def univariate_analysis(self, top_features=20): + try: + out_dir = os.path.join(self.experiment_path, self.name, 'exploratory', 'univariate_analyses') + os.makedirs(out_dir, exist_ok=True) + + p_value_dict = {} + for column in self.data.columns: + if column != self.outcome_label and column != self.instance_label: + p_value_dict[column] = self.test_selector(column) + + dict_items = list(p_value_dict.items()) + sorted_p_list = sorted(dict_items, key=lambda item: float(item[1][0])) + sorted_p_list = [(item[0], float(item[1][0])) for item in sorted_p_list] + + pval_df = pd.DataFrame.from_dict(p_value_dict, orient='index') + pval_df.to_csv(os.path.join(out_dir, 'Univariate_Significance.csv'), + index_label='Feature', header=['p-value', 'Test-statistic', 'Test-name'], na_rep='NaN') + + except Exception as e: + sorted_p_list = [] + logging.warning('Univariate analysis failed (scipy compat). Consider scipy>=1.8.0.') + for column in self.data.columns: + if column != self.outcome_label and column != self.instance_label: + sorted_p_list.append([column, 'None']) + + return sorted_p_list + + def test_selector(self, feature_name): + outcome = self.outcome_label + p_val, test_stat, test_name = None, None, None + + try: + # Work on rows where both vars are present + df = self.data[[feature_name, outcome]].dropna() + if df.empty: + raise ValueError(f"No non-NaN data for {feature_name} vs {outcome}.") + + is_feature_cat = feature_name in getattr(self, "categorical_features", set()) \ + or not is_numeric_dtype(df[feature_name]) + # NOTE: trust caller's self.outcome_type, but still infer basic properties + outcome_unique = df[outcome].unique() + + if self.outcome_type in ("Binary", "Multiclass"): + if is_feature_cat: + # Categorical x Categorical -> Chi-square (fallback to Fisher for 2x2 with small expected) + table = pd.crosstab(df[feature_name], df[outcome]) + if table.shape[0] < 2 or table.shape[1] < 2: + raise ValueError("Contingency table must be at least 2x2.") + # Check expected counts + chi2, p, dof, expected = chi2_contingency(table) + if table.shape == (2, 2) and (expected < 5).any(): + # Use Fisher’s exact for small counts + # Flatten to [[a,b],[c,d]] + a, b = table.iloc[0, 0], table.iloc[0, 1] + c, d = table.iloc[1, 0], table.iloc[1, 1] + odds, p = fisher_exact([[a, b], [c, d]], alternative="two-sided") + p_val, test_stat, test_name = p, odds, "Fisher's Exact Test (2x2)" + else: + p_val, test_stat, test_name = p, chi2, "Chi-Square Test" + else: + # Numeric feature vs categorical outcome + if len(outcome_unique) == 2: + # Don’t assume classes are 0/1; take the two labels + cls_a, cls_b = outcome_unique[:2] + x = df.loc[df[outcome] == cls_a, feature_name].astype(float) + y = df.loc[df[outcome] == cls_b, feature_name].astype(float) + # Guard for zero-length or constant vectors (MWU will error or be meaningless) + if len(x) == 0 or len(y) == 0: + raise ValueError("Empty group for Mann-Whitney U.") + if x.nunique() <= 1 and y.nunique() <= 1 and float(x.iloc[0]) == float(y.iloc[0]): + # Completely constant and equal → non-differentiable + p_val, test_stat, test_name = 1.0, 0.0, "Mann-Whitney U Test" + else: + u, p = mannwhitneyu(x, y, alternative="two-sided", method="auto") + p_val, test_stat, test_name = p, u, "Mann-Whitney U Test" + else: + # >2 classes: one-way ANOVA (fallback to Kruskal if any group size < 2) + groups = [df.loc[df[outcome] == cat, feature_name].astype(float) for cat in outcome_unique] + # Remove empty groups after dropna + groups = [g for g in groups if len(g) > 0] + if len(groups) < 2: + raise ValueError("Need at least two non-empty groups for ANOVA.") + if any(len(g) < 2 for g in groups): + H, p = kruskal(*groups) + p_val, test_stat, test_name = p, H, "Kruskal-Wallis H Test" + else: + F, p = f_oneway(*groups) + p_val, test_stat, test_name = p, F, "One-way ANOVA" + elif self.outcome_type == "Continuous": + if is_feature_cat: + # Compare continuous outcome across feature categories + cats = df[feature_name].unique() + groups = [df.loc[df[feature_name] == cat, outcome].astype(float) for cat in cats] + groups = [g for g in groups if len(g) > 0] + if len(groups) < 2: + raise ValueError("Need at least two non-empty groups for ANOVA.") + if any(len(g) < 2 for g in groups): + H, p = kruskal(*groups) + p_val, test_stat, test_name = p, H, "Kruskal-Wallis H Test" + else: + F, p = f_oneway(*groups) + p_val, test_stat, test_name = p, F, "One-way ANOVA" + else: + # Numeric vs numeric: Spearman default (robust to monotone nonlinearity) + res = spearmanr(df[feature_name].astype(float), df[outcome].astype(float), nan_policy="omit") + p_val, test_stat, test_name = float(res.pvalue), float(res.statistic), "Spearman Correlation" + else: + raise ValueError(f"Unknown outcome_type: {self.outcome_type}") + + except Exception as e: + logging.error("Stat test failure for %s vs %s: %s", feature_name, outcome, e) + raise Exception("Stat test error (likely data/assumption issue).") + + return p_val, test_stat, test_name + + def univariate_plots(self, sorted_p_list=None, top_features=20): + if sorted_p_list is None: + sorted_p_list = self.univariate_analysis(top_features) + # Only called if gated; generate PNGs here. + out_dir = os.path.join(self.experiment_path, self.name, 'exploratory', 'univariate_analyses') + os.makedirs(out_dir, exist_ok=True) + + for name, pval in sorted_p_list: + if pval == 'None' or pval > self.sig_cutoff: + continue + if self.outcome_type == "Binary" or self.outcome_type == "Multiclass": + if name in self.categorical_features: + table = pd.crosstab(self.data[name], self.data[self.outcome_label]) + table.plot(kind='bar'); plt.ylabel('Contingency Table Count') + fname = f'Barplot_{name.replace(" ", "").replace("*", "").replace("/", "")}.png' + else: + self.data.boxplot(column=name, by=self.outcome_label); plt.ylabel(name); plt.title('') + fname = f'Boxplot_{name.replace(" ", "").replace("*", "").replace("/", "")}.png' + elif self.outcome_type == "Continuous": + if name in self.categorical_features: + self.data.boxplot(column=self.outcome_label, by=name); plt.ylabel(self.outcome_label); plt.title('') + fname = f'Boxplot_{name.replace(" ", "").replace("*", "").replace("/", "")}.png' + else: + self.data.plot(x=name, y=self.outcome_label, kind='scatter') + fname = f'Scatter_{name.replace(" ", "").replace("*", "").replace("/", "")}.png' + plt.savefig(os.path.join(out_dir, fname), bbox_inches="tight", format='png') + if self.show_plots: plt.show() + plt.close('all') + + # ---------------------------- + # Optional: Anomaly detection (CSV-first, plots gated) + # ---------------------------- + def anomaly_detection(self, use_normalized_data=True, num_instances_to_show=50): + logging.info('Running anomaly detection.') + imputed_data = copy.deepcopy(self.data) + + imputer = IterativeImputer(random_state=self.random_state) + imputed_data[self.quantitative_features] = imputer.fit_transform(imputed_data[self.quantitative_features]) + + if use_normalized_data: + scaler = StandardScaler() + normalized_imputed_data = scaler.fit_transform(imputed_data[self.quantitative_features]) + normalized_imputed_data = pd.DataFrame(normalized_imputed_data, columns=self.quantitative_features) + else: + normalized_imputed_data = imputed_data[self.quantitative_features] + + plot_dir = os.path.join(self.experiment_path, self.name, 'exploratory', 'anomaly_detection') + os.makedirs(plot_dir, exist_ok=True) + + imputed_isolation_forest = IsolationForest(contamination='auto', random_state=self.random_state) + imputed_isolation_forest.fit(normalized_imputed_data) + iso_scores = imputed_isolation_forest.decision_function(normalized_imputed_data) + + lof = LocalOutlierFactor(n_neighbors=15, novelty=True, contamination='auto') + lof_scores = lof.fit(normalized_imputed_data).negative_outlier_factor_ + + ee = EllipticEnvelope(contamination=0.05, support_fraction=0.75, random_state=self.random_state) + ee.fit(normalized_imputed_data) + ee_scores = ee.decision_function(normalized_imputed_data) + + scores_df = pd.DataFrame({ + 'Isolation Forest': iso_scores, + 'Local Outlier Factor': lof_scores, + 'Elliptic Envelope': ee_scores + }) + scores_df.to_csv(os.path.join(plot_dir, 'imputed_anomaly_scores.csv'), index=False) + + imputed_data.index = range(len(imputed_data)) + imputed_data.to_csv(os.path.join(plot_dir, 'raw_unnormalized_scores.csv'), index=False) + + ranked = scores_df.rank(axis=0, ascending=False) + ranks_df = ranked.copy() + ranks_df.index = range(len(ranks_df)) + ranks_df['Avg_Rank'] = ranks_df.mean(axis=1) + ranks_df = ranks_df.sort_values(by='Avg_Rank') + ranks_path = os.path.join(plot_dir, 'rankings.csv') + ranks_df.to_csv(ranks_path, index=False) + + # PNGs only if enabled + if self.enable_plots and self.plot_anomalies: + plt.figure(figsize=(8, 6)); plt.hist(iso_scores, bins=30, edgecolor='black', range=(-1, 1)) + plt.title('Histogram of Isolation Forest Anomaly Scores'); plt.xlabel('Anomaly Score'); plt.ylabel('Frequency') + plt.tight_layout(); plt.savefig(os.path.join(plot_dir, 'isolation_forest_histogram.png')); + if self.show_plots: plt.show(); plt.close() + + plt.figure(figsize=(8, 6)); plt.hist(lof_scores, bins=30, edgecolor='black') + plt.title('Histogram of Local Outlier Factor Anomaly Scores'); plt.xlabel('Anomaly Score'); plt.ylabel('Frequency') + plt.tight_layout(); plt.savefig(os.path.join(plot_dir, 'local_outlier_factor_histogram.png')) + if self.show_plots: plt.show(); plt.close() + + plt.figure(figsize=(8, 6)); plt.hist(ee_scores, bins=30, edgecolor='black') + plt.title('Histogram of Elliptic Envelope Anomaly Scores'); plt.xlabel('Anomaly Score'); plt.ylabel('Frequency') + plt.tight_layout(); plt.savefig(os.path.join(plot_dir, 'elliptic_envelope_histogram.png')) + if self.show_plots: plt.show(); plt.close() + + # Heatmaps + boxplots can be regenerated later via the renderer; skip here to keep runs light. + + logging.info("Anomaly detection completed.") + + # ---------------------------- + # Runtime + # ---------------------------- + + def save_runtime(self): + runtime = str(time.time() - self.job_start_time) + logging.log(0, "PHASE 1 Completed: Runtime=" + str(runtime)) + run_dir = os.path.join(self.experiment_path, self.name, 'runtime') + os.makedirs(run_dir, exist_ok=True) + with open(os.path.join(run_dir, 'runtime_exploratory.txt'), 'w') as f: + f.write(runtime) + + def start(self, top_features=20): + self.run(top_features) + + def join(self): + pass diff --git a/streamline/p1_data_process/p1_cli.py b/streamline/p1_data_process/p1_cli.py new file mode 100644 index 00000000..bae7729e --- /dev/null +++ b/streamline/p1_data_process/p1_cli.py @@ -0,0 +1,175 @@ +# streamline/phases/p1_data_process/cli.py +import argparse +import json +from typing import List, Optional + +from streamline.p1_data_process.p1_runner import P1Runner +from streamline.utils.run_commands import ( + add_run_command_args, + apply_saved_run_command, + save_run_command_from_args, + snapshot_args, +) + + +def _csv_or_list(v: Optional[str]) -> Optional[List[str]]: + if v is None or v == "": + return None + # allow JSON array OR comma-separated + v = v.strip() + if v.startswith("["): + try: + arr = json.loads(v) + return [str(x) for x in arr] + except Exception: + pass + return [x.strip() for x in v.split(",") if x.strip() != ""] + + +def _csv_or_str(v: Optional[str]): + # for features that allow either single string or list + if v is None: + return None + v = v.strip() + return v if ("," not in v and not v.startswith("[")) else _csv_or_list(v) + + +def _bool(v: Optional[str], default: bool = False) -> bool: + if v is None: + return default + vl = str(v).strip().lower() + if vl in ("1", "true", "t", "yes", "y"): + return True + if vl in ("0", "false", "f", "no", "n"): + return False + return default + + +def main(): + ap = argparse.ArgumentParser( + "STREAMLINE Phase 1 Runner (dataset-free, Dask-aware)", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + # Core paths + ap.add_argument("--data_path", default=None) + ap.add_argument("--output_path", required=True) + ap.add_argument("--experiment_name", required=True) + + # Labels & schema + ap.add_argument("--outcome_label", default="Class") + ap.add_argument("--outcome_type", default=None) + ap.add_argument("--instance_label", default=None) + ap.add_argument("--match_label", default=None) + ap.add_argument("--ignore_features", default=None) + ap.add_argument("--categorical_features", default=None) + ap.add_argument("--quantitative_features", default=None) + ap.add_argument("--categorical_cutoff", default=10, type=int) + ap.add_argument( + "--one_hot_encoding", + default="true", + help="Set false/0 to keep non-binary categorical features unexpanded for model-stage handling.", + ) + + # CV + ap.add_argument("--n_splits", default=10, type=int) + ap.add_argument("--partition_method", default="Stratified") + + # EDA / thresholds + ap.add_argument("--top_features", default=20, type=int) + ap.add_argument("--sig_cutoff", default=0.05, type=float) + ap.add_argument("--featureeng_missingness", default=0.5, type=float) + ap.add_argument("--cleaning_missingness", default=0.5, type=float) + ap.add_argument("--correlation_removal_threshold", default=1.0, type=float) + + # Execution + ap.add_argument("--run_cluster", default="Serial", help='Serial | Local | Parallel | BashSLURM | BashLSF | ""') + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", default=4, type=int) + ap.add_argument("--random_state", default=None, type=int) + ap.add_argument("--show_plots", default="false") + ap.add_argument("--force", default="false") + + # Import-only CV + ap.add_argument("--cv_provided", default="false") + ap.add_argument("--cv_input_root", default=None) + + # EDA outputs & plotting flags + ap.add_argument("--exclude_eda_output", default=None, help='JSON array or comma list (e.g. ["describe_csv","correlation"])') + ap.add_argument("--enable_plots", default="false") + ap.add_argument("--plot_missingness", default="false") + ap.add_argument("--plot_class_counts", default="false") + ap.add_argument("--plot_correlation", default="false") + ap.add_argument("--correlation_plot_max_features", default=200, type=int) + ap.add_argument("--plot_univariate", default="false") + ap.add_argument("--univariate_top_k", default=20, type=int) + ap.add_argument("--plot_anomalies", default="false") + add_run_command_args(ap) + + args = ap.parse_args() + args = apply_saved_run_command(ap, args, "p1_data_process") + run_command_args = snapshot_args(args) + + runner = P1Runner( + data_path=args.data_path, + output_path=args.output_path, + experiment_name=args.experiment_name, + exclude_eda_output=_csv_or_list(args.exclude_eda_output), + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + instance_label=args.instance_label, + match_label=args.match_label, + n_splits=args.n_splits, + partition_method=args.partition_method, + ignore_features=_csv_or_str(args.ignore_features), + categorical_features=_csv_or_str(args.categorical_features), + quantitative_features=_csv_or_str(args.quantitative_features), + top_features=args.top_features, + categorical_cutoff=args.categorical_cutoff, + sig_cutoff=args.sig_cutoff, + featureeng_missingness=args.featureeng_missingness, + cleaning_missingness=args.cleaning_missingness, + correlation_removal_threshold=args.correlation_removal_threshold, + random_state=args.random_state, + run_cluster=args.run_cluster if args.run_cluster not in (None, "Serial", "False", "false") else False, + queue=args.queue, + reserved_memory=args.reserved_memory, + show_plots=_bool(args.show_plots, False), + one_hot_encoding=_bool(args.one_hot_encoding, True), + cv_provided=_bool(args.cv_provided, False), + cv_input_root=args.cv_input_root, + enable_plots=_bool(args.enable_plots, False), + plot_missingness=_bool(args.plot_missingness, False), + plot_class_counts=_bool(args.plot_class_counts, False), + plot_correlation=_bool(args.plot_correlation, False), + correlation_plot_max_features=args.correlation_plot_max_features, + plot_univariate=_bool(args.plot_univariate, False), + univariate_top_k=args.univariate_top_k, + plot_anomalies=_bool(args.plot_anomalies, False), + force=_bool(args.force, False), + ) + + runner.run() + save_run_command_from_args(args, "p1_data_process", run_command_args, runner=runner) + + +if __name__ == "__main__": + # # Serial + # python -m streamline.p1_data_process.p1_cli \ + # --data_path ./data/UCIBinaryClassification \ + # --output_path ./test \ + # --experiment_name MyExp \ + # --outcome_label Class \ + # --outcome_type Binary \ + # --instance_label InstanceID + + # # Local Dask with 1 worker per core + # python -m streamline.p1_data_process.p1_cli \ + # --data_path ./data/UCIBinaryClassification \ + # --output_path ./test \ + # --experiment_name MyExp \ + # --outcome_label Class \ + # --outcome_type Binary \ + # --instance_label InstanceID \ + # --run_cluster Local + + main() diff --git a/streamline/p1_data_process/p1_jobsubmit.py b/streamline/p1_data_process/p1_jobsubmit.py new file mode 100644 index 00000000..7dba59fd --- /dev/null +++ b/streamline/p1_data_process/p1_jobsubmit.py @@ -0,0 +1,123 @@ +import argparse +import os +import pandas as pd + +from streamline.p1_data_process.data_process import DataProcess + + +def _maybe_list(s): + if s is None or s == '': + return None + return [x.strip() for x in s.split(',') if x.strip()] + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument('--dataset_path', default='') + ap.add_argument('--dataset_name', default='') + ap.add_argument('--output_path', required=True) + ap.add_argument('--experiment_name', required=True) + ap.add_argument('--exclude', default='') + + ap.add_argument('--outcome_label', required=True) + ap.add_argument('--outcome_type', default='') + ap.add_argument('--instance_label', default='') + ap.add_argument('--match_label', default='') + + ap.add_argument('--n_splits', type=int, default=10) + ap.add_argument('--partition_method', default='Stratified') + + ap.add_argument('--ignore_features', default='') + ap.add_argument('--categorical_features', default='') + ap.add_argument('--quantitative_features', default='') + ap.add_argument('--top_features', type=int, default=20) + + ap.add_argument('--categorical_cutoff', type=int, default=10) + ap.add_argument('--sig_cutoff', type=float, default=0.05) + ap.add_argument('--featureeng_missingness', type=float, default=0.5) + ap.add_argument('--cleaning_missingness', type=float, default=0.5) + ap.add_argument('--correlation_removal_threshold', type=float, default=1.0) + ap.add_argument('--random_state', default='') + ap.add_argument('--one_hot_encoding', type=int, default=1) + ap.add_argument('--cv_provided', type=int, default=0) + ap.add_argument('--cv_input_root', default='') + + # plotting flags + ap.add_argument('--enable_plots', type=int, default=0) + ap.add_argument('--plot_missingness', type=int, default=0) + ap.add_argument('--plot_class_counts', type=int, default=0) + ap.add_argument('--plot_correlation', type=int, default=0) + ap.add_argument('--correlation_plot_max_features', type=int, default=200) + ap.add_argument('--plot_univariate', type=int, default=0) + ap.add_argument('--univariate_top_k', type=int, default=20) + ap.add_argument('--plot_anomalies', type=int, default=0) + args = ap.parse_args() + + if args.dataset_path: + ext = args.dataset_path.split('.')[-1].lower() + if ext == 'csv': + df = pd.read_csv(args.dataset_path, na_values='NA', sep=',') + elif ext == 'tsv': + df = pd.read_csv(args.dataset_path, na_values='NA', sep='\t') + else: + df = pd.read_csv(args.dataset_path, na_values='NA', delim_whitespace=True) + dataset_name = args.dataset_name or os.path.basename(args.dataset_path).split('.')[0] + else: + if not args.cv_provided or not args.cv_input_root: + raise ValueError("dataset_path is required unless cv_provided=1 and cv_input_root is set") + cv_dir = os.path.join(args.cv_input_root, "CVDatasets") + if not os.path.isdir(cv_dir): + raise ValueError(f"Expected CVDatasets/ under cv_input_root: {args.cv_input_root}") + train_files = sorted( + f for f in os.listdir(cv_dir) + if f.endswith("_Train.csv") and "_CV_" in f + ) + if not train_files: + raise ValueError(f"No Train split CSVs found under {cv_dir}") + df = pd.read_csv(os.path.join(cv_dir, train_files[0]), na_values='NA', sep=',') + dataset_name = args.dataset_name or os.path.basename(args.cv_input_root.rstrip(os.sep)) + df.columns = df.columns.str.strip() + + experiment_path = os.path.join(args.output_path, args.experiment_name) + + dp = DataProcess( + data=df, + experiment_path=experiment_path, + outcome_label=args.outcome_label, + outcome_type=(args.outcome_type or None), + match_label=(args.match_label if args.match_label in df.columns else None) or None, + instance_label=(args.instance_label if args.instance_label in df.columns else None) or None, + ignore_features=_maybe_list(args.ignore_features), + categorical_features=_maybe_list(args.categorical_features), + quantitative_features=_maybe_list(args.quantitative_features), + exclude_eda_output=_maybe_list(args.exclude), + categorical_cutoff=args.categorical_cutoff, + sig_cutoff=args.sig_cutoff, + featureeng_missingness=args.featureeng_missingness, + cleaning_missingness=args.cleaning_missingness, + correlation_removal_threshold=args.correlation_removal_threshold, + partition_method=args.partition_method, + n_splits=args.n_splits, + one_hot_encoding=bool(args.one_hot_encoding), + random_state=(int(args.random_state) if args.random_state != '' else None), + show_plots=False, # batch jobs shouldn't pop plots + cv_provided=bool(args.cv_provided), + cv_input_path=(args.cv_input_root or None), + dataset_name=dataset_name, + + # plotting flags + enable_plots=bool(args.enable_plots), + plot_missingness=bool(args.plot_missingness), + plot_class_counts=bool(args.plot_class_counts), + plot_correlation=bool(args.plot_correlation), + correlation_plot_max_features=int(args.correlation_plot_max_features), + plot_univariate=bool(args.plot_univariate), + univariate_top_k=int(args.univariate_top_k), + plot_anomalies=bool(args.plot_anomalies), + ) + + dp.run(top_features=int(args.top_features)) + + +if __name__ == "__main__": + main() diff --git a/streamline/p1_data_process/p1_runner.py b/streamline/p1_data_process/p1_runner.py new file mode 100644 index 00000000..be88cb83 --- /dev/null +++ b/streamline/p1_data_process/p1_runner.py @@ -0,0 +1,503 @@ +import logging +import os +import pickle +import re +import glob +import time +import pandas as pd +from pathlib import Path +from datetime import datetime + +import dask +import logging +from dask.distributed import Client, LocalCluster +logger = logging.getLogger("distributed.worker") +logger.setLevel(logging.WARNING) + +from streamline.p1_data_process.data_process import DataProcess +from streamline.utils.runners import parallel_eda_call, num_cores, run_dask_tasks, run_parallel_jobs +from streamline.utils.cluster import get_cluster # must return a connected Dask Client + + +class P1Runner: + """ + Phase 1 runner (dataset-free, flag-driven plotting, Dask-aware). + + Modes (set via run_cluster): + • "Local" → local Dask parallelization. + • "Parallel" → local joblib parallelization. + • "BashSLURM" → submit a bash script (sbatch) that runs p1_jobsubmit.py per dataset. + • "BashLSF" → submit a bash script (bsub) that runs p1_jobsubmit.py per dataset. + • any other str → modern Dask cluster name; get_cluster(name, ...) returns a connected Client (works in Jupyter). + + If no raw datasets are found and cv_provided=True, it runs in import-only mode by discovering + //CVDatasets folders and seeding schema from the first *_Train.csv. + """ + + def __init__( + self, + data_path, + output_path, + experiment_name, + exclude_eda_output=None, + outcome_label="Class", + outcome_type=None, + instance_label=None, + match_label=None, + n_splits=10, + partition_method="Stratified", + ignore_features=None, + categorical_features=None, + quantitative_features=None, + top_features=20, + categorical_cutoff=10, + sig_cutoff=0.05, + featureeng_missingness=0.5, + cleaning_missingness=0.5, + correlation_removal_threshold=1.0, + random_state=None, + run_cluster=False, # False | "Local" | "Parallel" | "BashSLURM" | "BashLSF" | "" + queue='defq', + reserved_memory=4, + show_plots=False, + + # DataProcess controls + one_hot_encoding=True, + cv_provided=False, + cv_input_root=None, + + # plotting flags (forwarded to DataProcess) + enable_plots=False, + plot_missingness=False, + plot_class_counts=False, + plot_correlation=False, + correlation_plot_max_features=200, + plot_univariate=False, + univariate_top_k=20, + plot_anomalies=False, + + # force flag + force=False + ): + self.data_path = data_path + self.output_path = output_path + self.experiment_name = experiment_name + self.outcome_label = outcome_label + self.outcome_type = DataProcess._normalize_outcome_type(outcome_type) if outcome_type else None + self.instance_label = instance_label + self.match_label = match_label + self.ignore_features = ignore_features + self.categorical_cutoff = categorical_cutoff + self.categorical_features = categorical_features + self.quantitative_features = quantitative_features + self.featureeng_missingness = featureeng_missingness + self.cleaning_missingness = cleaning_missingness + self.correlation_removal_threshold = correlation_removal_threshold + self.top_features = top_features + self.exclude_eda_output = exclude_eda_output + + # DataProcess + self.one_hot_encoding = bool(one_hot_encoding) + self.cv_provided = bool(cv_provided) + self.cv_input_root = cv_input_root + + # Analysis excludes only (plots are flag-gated) + known_exclude_options = ['describe_csv', 'correlation'] + exploration_list = ["Describe", "Univariate Analysis", "Feature Correlation"] + if exclude_eda_output is not None: + for x in exclude_eda_output: + if x not in known_exclude_options: + logging.warning("Unknown EDA exclusion option " + str(x)) + if 'describe_csv' in exclude_eda_output and "Describe" in exploration_list: + exploration_list.remove("Describe") + if 'correlation' in exclude_eda_output and "Feature Correlation" in exploration_list: + exploration_list.remove("Feature Correlation") + self.exploration_list = exploration_list + + self.n_splits = n_splits + self.partition_method = partition_method + if self.outcome_type == "Continuous": + self.partition_method = "Random" + self.run_cluster = run_cluster # see modes above + self.queue = queue + self.reserved_memory = reserved_memory + self.show_plots = show_plots + self.random_state = random_state + self.sig_cutoff = sig_cutoff + + # Plot flags + self.enable_plots = bool(enable_plots) + self.plot_missingness = bool(plot_missingness) + self.plot_class_counts = bool(plot_class_counts) + self.plot_correlation = bool(plot_correlation) + self.correlation_plot_max_features = int(correlation_plot_max_features) + self.plot_univariate = bool(plot_univariate) + self.univariate_top_k = int(univariate_top_k) + self.plot_anomalies = bool(plot_anomalies) + + self.force = bool(force) + + self.make_dir_tree() + self.save_metadata() + + # ---------------------------- + # Main + # ---------------------------- + def run(self): + job_obj_list = [] + unique_datanames = [] + file_count = 0 + + discovered_files = [] + if self.data_path and os.path.exists(self.data_path): + discovered_files = glob.glob(self.data_path.rstrip('/') + '/*') + + # MODE 1: raw datasets + for dataset_path in discovered_files: + dataset_path = str(Path(dataset_path).as_posix()) + file_extension = dataset_path.split('/')[-1].split('.')[-1].lower() + data_name = dataset_path.split('/')[-1].split('.')[0] + if file_extension not in ('txt', 'csv', 'tsv'): + continue + if data_name in unique_datanames: + continue + unique_datanames.append(data_name) + file_count += 1 + + ds_out_dir = os.path.join(self.output_path, self.experiment_name, data_name) + os.makedirs(ds_out_dir, exist_ok=True) + + # Load DataFrame + if file_extension == 'csv': + df = pd.read_csv(dataset_path, na_values='NA', sep=',') + elif file_extension == 'tsv': + df = pd.read_csv(dataset_path, na_values='NA', sep='\t') + else: # txt + df = pd.read_csv(dataset_path, na_values='NA', delim_whitespace=True) + df.columns = df.columns.str.strip() + + # Set outcome_type if needed + if self.outcome_type is None and self.outcome_label in df.columns: + nunique = df[self.outcome_label].nunique() + self.outcome_type = "Binary" if nunique == 2 else ("Multiclass" if 2 < nunique <= self.categorical_cutoff else "Continuous") + if self.outcome_type == "Continuous": + self.partition_method = "Random" + self.save_metadata() + + if self.run_cluster in ("BashSLURM", "BashLSF"): + self._submit_bash_job(dataset_path) + continue + + dp = self._build_dataprocess(df, data_name, cv_path=self.cv_input_root) + job_obj_list.append(dp) + + # MODE 2: import-only (no raw data) + if self.cv_provided and (file_count == 0): + if not self.cv_input_root or not os.path.isdir(self.cv_input_root): + raise Exception("cv_input_root must point to /CVDatasets when cv_provided=True and no raw datasets are found") + + candidate_dirs = [] + if os.path.isdir(os.path.join(self.cv_input_root, 'CVDatasets')): + candidate_dirs = [self.cv_input_root] + else: + for name in os.listdir(self.cv_input_root): + ds_dir = os.path.join(self.cv_input_root, name) + if os.path.isdir(os.path.join(ds_dir, 'CVDatasets')): + candidate_dirs.append(ds_dir) + if not candidate_dirs: + raise Exception(f"No /CVDatasets folders found under cv_input_root: {self.cv_input_root}") + + for ds_dir in candidate_dirs: + ds_name = os.path.basename(ds_dir.rstrip('/')) + ds_out_dir = os.path.join(self.output_path, self.experiment_name, ds_name) + os.makedirs(ds_out_dir, exist_ok=True) + + # seed df from first Train split + cv_glob = glob.glob(os.path.join(ds_dir, 'CVDatasets', f'{ds_name}_CV_*_Train.csv')) or \ + glob.glob(os.path.join(ds_dir, 'CVDatasets', '*_Train.csv')) + if not cv_glob: + raise Exception(f"No Train splits found in {os.path.join(ds_dir, 'CVDatasets')}") + + df = pd.read_csv(sorted(cv_glob)[0], na_values='NA') + df.columns = df.columns.str.strip() + + # Set outcome_type if needed + if self.outcome_type is None and self.outcome_label in df.columns: + nunique = df[self.outcome_label].nunique() + self.outcome_type = "Binary" if nunique == 2 else ("Multiclass" if 2 < nunique <= self.categorical_cutoff else "Continuous") + if self.outcome_type == "Continuous": + self.partition_method = "Random" + self.save_metadata() + + if self.run_cluster in ("BashSLURM", "BashLSF"): + self._submit_bash_job( + dataset_path=None, + dataset_name=ds_name, + cv_input_root=ds_dir, + ) + continue + + dp = self._build_dataprocess(df, ds_name, cv_path=ds_dir, force_import_only=True) + job_obj_list.append(dp) + + # error if expected raw data but none + if not self.cv_provided and file_count == 0: + raise Exception("There must be at least one .txt, .tsv, or .csv dataset in data_path directory") + + # ---- EXECUTION STRATEGY ---- + run_mode = str(self.run_cluster) if self.run_cluster else "Serial" + if run_mode == "Local": + # Local Dask parallelization + n_workers = num_cores + with LocalCluster(processes=True, n_workers=n_workers, threads_per_worker=1) as cluster: + with Client(cluster) as client: + tasks = [dask.delayed(parallel_eda_call)(job_obj, {'top_features': self.top_features}) for job_obj in job_obj_list] + run_dask_tasks(tasks, client, label="Phase 1 Dask jobs") + elif run_mode == "Parallel": + run_parallel_jobs( + parallel_eda_call, + [(job_obj, {'top_features': self.top_features}) for job_obj in job_obj_list], + label="Phase 1 Parallel jobs", + ) + elif self.run_cluster and self.run_cluster != "Serial" and self.run_cluster not in ("BashSLURM", "BashLSF"): + # Modern Dask cluster (works in Jupyter) + client: Client = get_cluster(self.run_cluster, + os.path.join(self.output_path, self.experiment_name), + self.queue, self.reserved_memory) + tasks = [dask.delayed(parallel_eda_call)(job_obj, {'top_features': self.top_features}) for job_obj in job_obj_list] + run_dask_tasks(tasks, client, label="Phase 1 Dask jobs") + else: + # Serial + for job_obj in job_obj_list: + job_obj.run(self.top_features) + + self.save_run_params() + + # ---------------------------- + # Helpers + # ---------------------------- + def _build_dataprocess(self, df: pd.DataFrame, dataset_name: str, cv_path: "str | None", force_import_only: bool = False): + return DataProcess( + data=df, + experiment_path=os.path.join(self.output_path, self.experiment_name), + outcome_label=self.outcome_label, + outcome_type=self.outcome_type, + match_label=self.match_label if (self.match_label in df.columns) else None, + instance_label=self.instance_label if (self.instance_label in df.columns) else None, + ignore_features=self.ignore_features, + categorical_features=self.categorical_features, + quantitative_features=self.quantitative_features, + exclude_eda_output=self.exclude_eda_output, + categorical_cutoff=self.categorical_cutoff, + sig_cutoff=self.sig_cutoff, + featureeng_missingness=self.featureeng_missingness, + cleaning_missingness=self.cleaning_missingness, + correlation_removal_threshold=self.correlation_removal_threshold, + partition_method=self.partition_method, + n_splits=self.n_splits, + one_hot_encoding=self.one_hot_encoding, + random_state=self.random_state, + show_plots=self.show_plots, + cv_provided=(self.cv_provided or force_import_only), + cv_input_path=cv_path, + dataset_name=dataset_name, + # plot flags + enable_plots=self.enable_plots, + plot_missingness=self.plot_missingness, + plot_class_counts=self.plot_class_counts, + plot_correlation=self.plot_correlation, + correlation_plot_max_features=self.correlation_plot_max_features, + plot_univariate=self.plot_univariate, + univariate_top_k=self.univariate_top_k, + plot_anomalies=self.plot_anomalies, + ) + + def make_dir_tree(self): + """ + Validates and creates experiment structure. + data_path can be missing when cv_provided=True (import-only). + """ + if not self.cv_provided: + if not self.data_path or not os.path.exists(self.data_path): + raise Exception("Provided data_path does not exist") + + exp_dir = os.path.join(self.output_path, self.experiment_name) + if os.path.exists(exp_dir): + if not self.force: + raise Exception( + f"Error: Experiment folder already exists: {exp_dir} (use force=True to overwrite)." + ) + else: + import shutil + logging.warning(f"Force flag set: removing existing experiment folder {exp_dir}") + shutil.rmtree(exp_dir) + + if not re.match(r'^[A-Za-z0-9_]+$', self.experiment_name): + raise Exception('Experiment Name must be alphanumeric') + + os.makedirs(self.output_path, exist_ok=True) + os.mkdir(exp_dir) + os.mkdir(exp_dir + '/jobsCompleted') + os.mkdir(exp_dir + '/jobs') + os.mkdir(exp_dir + '/logs') + + def save_metadata(self): + metadata = dict() + metadata['Data Path'] = self.data_path + metadata['Output Path'] = self.output_path + metadata['Experiment Name'] = self.experiment_name + metadata['Outcome Label'] = self.outcome_label + metadata['Outcome Type'] = self.outcome_type + metadata['Instance Label'] = self.instance_label + metadata['Match Label'] = self.match_label + metadata['Ignored Features'] = self.ignore_features + metadata['Specified Categorical Features'] = self.categorical_features + metadata['Specified Quantitative Features'] = self.quantitative_features + metadata['CV Partitions'] = self.n_splits + metadata['Partition Method'] = self.partition_method + metadata['Categorical Cutoff'] = self.categorical_cutoff + metadata['Statistical Significance Cutoff'] = self.sig_cutoff + metadata['Engineering Missingness Cutoff'] = self.featureeng_missingness + metadata['Cleaning Missingness Cutoff'] = self.cleaning_missingness + metadata['Correlation Removal Threshold'] = self.correlation_removal_threshold + metadata['List of Exploratory Analysis Ran'] = self.exploration_list + metadata['Random Seed'] = self.random_state + metadata['Run From Notebook'] = self.show_plots + with open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'wb') as f: + pickle.dump(metadata, f) + + def save_run_params(self, run_parallel=False): + """Save or update run parameters in a single pickle file (dict keyed by timestamp).""" + run_params = { + "run_parallel": run_parallel, + "data_path": self.data_path, + "output_path": self.output_path, + "experiment_name": self.experiment_name, + "outcome_label": self.outcome_label, + "outcome_type": self.outcome_type, + "instance_label": self.instance_label, + "match_label": self.match_label, + "n_splits": self.n_splits, + "partition_method": self.partition_method, + "ignore_features": self.ignore_features, + "categorical_features": self.categorical_features, + "quantitative_features": self.quantitative_features, + "categorical_cutoff": self.categorical_cutoff, + "sig_cutoff": self.sig_cutoff, + "featureeng_missingness": self.featureeng_missingness, + "cleaning_missingness": self.cleaning_missingness, + "correlation_removal_threshold": self.correlation_removal_threshold, + "random_state": self.random_state, + "run_cluster": self.run_cluster, + "queue": self.queue, + "reserved_memory": self.reserved_memory, + "show_plots": self.show_plots, + "one_hot_encoding": self.one_hot_encoding, + "cv_provided": self.cv_provided, + "cv_input_root": self.cv_input_root, + "exclude_eda_output": self.exclude_eda_output, + } + + exp_root = os.path.join(self.output_path, self.experiment_name) + os.makedirs(exp_root, exist_ok=True) + params_file = os.path.join(exp_root, "run_params.pickle") + + # Load existing dictionary if file exists, else start new + if os.path.exists(params_file): + with open(params_file, "rb") as f: + all_params = pickle.load(f) + else: + all_params = {} + + ts = datetime.now().isoformat() + all_params[ts] = run_params + + with open(params_file, "wb") as f: + pickle.dump(all_params, f) + + logging.info(f"Updated run parameters in {params_file}") + + # ---------------------------- + # Bash submission (uses p1_jobsubmit.py) + # ---------------------------- + def _submit_bash_job(self, dataset_path, dataset_name=None, cv_input_root=None): + job_ref = str(time.time()) + run_dir = self.output_path + '/' + self.experiment_name + os.makedirs(run_dir + '/jobs', exist_ok=True) + os.makedirs(run_dir + '/logs', exist_ok=True) + job_name = run_dir + f'/jobs/P1_{job_ref}_run.sh' + + + if self.run_cluster == "BashSLURM": + launcher = 'sbatch' + elif self.run_cluster == "BashLSF": + launcher = 'bsub <' + else: + raise Exception("Bash submission of HPC type unsupported") + + with open(job_name, 'w') as sh: + if self.run_cluster == "BashSLURM": + sh.write('#!/bin/bash\n') + sh.write('#SBATCH -p ' + self.queue + '\n') + sh.write('#SBATCH --job-name=' + job_ref + '\n') + sh.write('#SBATCH --mem=' + str(self.reserved_memory) + 'G' + '\n') + sh.write('#SBATCH -o ' + run_dir + f'/logs/P1_{job_ref}.o\n') + sh.write('#SBATCH -e ' + run_dir + f'/logs/P1_{job_ref}.e\n') + cmd = self._bash_submit_command(dataset_path, dataset_name=dataset_name, cv_input_root=cv_input_root) + sh.write('srun ' + cmd + '\n') + else: + sh.write('#!/bin/bash\n') + sh.write('#BSUB -q ' + self.queue + '\n') + sh.write('#BSUB -J ' + job_ref + '\n') + sh.write('#BSUB -R "rusage[mem=' + str(self.reserved_memory) + 'G]"' + '\n') + sh.write('#BSUB -M ' + str(self.reserved_memory) + 'GB' + '\n') + sh.write('#BSUB -o ' + run_dir + f'/logs/P1_{job_ref}.o\n') + sh.write('#BSUB -e ' + run_dir + f'/logs/P1_{job_ref}.e\n') + cmd = self._bash_submit_command(dataset_path, dataset_name=dataset_name, cv_input_root=cv_input_root) + sh.write(cmd + '\n') + + os.system(f'{launcher} {job_name}') + + def _bash_submit_command(self, dataset_path, dataset_name=None, cv_input_root=None): + """ + Build command to run a single-dataset job via p1_jobsubmit.py (bash path). + p1_jobsubmit.py must parse args and run DataProcess once. + """ + script_path = str(Path(__file__).parent / "p1_jobsubmit.py") + args = [ + 'python', script_path, + '--dataset_path', dataset_path or '', + '--dataset_name', dataset_name or '', + '--output_path', self.output_path, + '--experiment_name', self.experiment_name, + '--exclude', ','.join(self.exclude_eda_output) if self.exclude_eda_output else '', + '--outcome_label', self.outcome_label or '', + '--outcome_type', self.outcome_type or '', + '--instance_label', self.instance_label or '', + '--match_label', self.match_label or '', + '--n_splits', str(self.n_splits), + '--partition_method', self.partition_method, + '--ignore_features', ','.join(self.ignore_features) if isinstance(self.ignore_features, list) else (self.ignore_features or ''), + '--categorical_features', ','.join(self.categorical_features) if isinstance(self.categorical_features, list) else (self.categorical_features or ''), + '--quantitative_features', ','.join(self.quantitative_features) if isinstance(self.quantitative_features, list) else (self.quantitative_features or ''), + '--top_features', str(self.top_features), + '--categorical_cutoff', str(self.categorical_cutoff), + '--sig_cutoff', str(self.sig_cutoff), + '--featureeng_missingness', str(self.featureeng_missingness), + '--cleaning_missingness', str(self.cleaning_missingness), + '--correlation_removal_threshold', str(self.correlation_removal_threshold), + '--random_state', str(self.random_state) if self.random_state is not None else '', + '--one_hot_encoding', str(int(self.one_hot_encoding)), + '--cv_provided', str(int(self.cv_provided)), + '--cv_input_root', cv_input_root or self.cv_input_root or '', + # plotting flags + '--enable_plots', str(int(self.enable_plots)), + '--plot_missingness', str(int(self.plot_missingness)), + '--plot_class_counts', str(int(self.plot_class_counts)), + '--plot_correlation', str(int(self.plot_correlation)), + '--correlation_plot_max_features', str(int(self.correlation_plot_max_features)), + '--plot_univariate', str(int(self.plot_univariate)), + '--univariate_top_k', str(int(self.univariate_top_k)), + '--plot_anomalies', str(int(self.plot_anomalies)), + ] + return ' '.join(args) diff --git a/streamline/p1_data_process/utils/features_meta.py b/streamline/p1_data_process/utils/features_meta.py new file mode 100644 index 00000000..187ce80b --- /dev/null +++ b/streamline/p1_data_process/utils/features_meta.py @@ -0,0 +1,36 @@ +import os +import json +import pickle + +def build_feature_meta(dataset, categorical_features, quantitative_features, + one_hot, one_hot_features, engineered_features): + # Build masks in final column order of dataset.data + cols = list(dataset.data.columns) + outcome = dataset.outcome_label + instance = dataset.instance_label + feature_cols = [c for c in cols if c not in [outcome, instance]] + + cat_set = set(categorical_features) + quant_set = set(quantitative_features) + + meta = { + "feature_names": feature_cols, + "categorical_mask": [c in cat_set for c in feature_cols], + "quantitative_mask": [c in quant_set for c in feature_cols], + "original_dtypes": {c: str(dataset.data[c].dtype) for c in cols}, + "one_hot": bool(one_hot), + "one_hot_features": list(one_hot_features), + "engineered_features": list(engineered_features), + "outcome_label": outcome, + "instance_label": instance, + } + return meta + +def save_feature_meta(experiment_path, dataset_name, feature_meta): + exp_ds = os.path.join(experiment_path, dataset_name, "exploratory") + if not os.path.exists(exp_ds): + os.makedirs(exp_ds) + with open(os.path.join(exp_ds, "feature_meta.pickle"), "wb") as f: + pickle.dump(feature_meta, f) + with open(os.path.join(exp_ds, "feature_meta.json"), "w") as f: + json.dump(feature_meta, f) diff --git a/streamline/p1_data_process/utils/kfold_partitioning.py b/streamline/p1_data_process/utils/kfold_partitioning.py new file mode 100644 index 00000000..599c7ce2 --- /dev/null +++ b/streamline/p1_data_process/utils/kfold_partitioning.py @@ -0,0 +1,191 @@ +import os +from typing import Optional, Tuple, List + +import pandas as pd +from sklearn.model_selection import KFold, StratifiedKFold, StratifiedGroupKFold + + +class KFoldPartitioner: + """ + K-fold CV partitioner that operates on a pandas.DataFrame only. + + Parameters + ---------- + data : pd.DataFrame + The full dataset including the outcome column (and optional match column). + experiment_path : str + Directory where CV splits are saved. + dataset_name : str + Name used in output filenames and directories. + outcome_label : str, default="Class" + Column name for the outcome/target. + match_label : str, optional + Grouping column name used only when partition_method="Group". + partition_method : {"Random", "Stratified", "Group"}, default="Stratified" + The CV splitting strategy. + n_splits : int, default=10 + Number of folds. + random_state : int, optional + RNG seed for reproducibility. + """ + + SUPPORTED_METHODS = ("Random", "Stratified", "Group") + + def __init__( + self, + data: pd.DataFrame, + experiment_path: str, + dataset_name: str, + outcome_label: str = "Class", + match_label: Optional[str] = None, + partition_method: str = "Stratified", + n_splits: int = 10, + random_state: Optional[int] = None, + + ): + if not isinstance(data, pd.DataFrame): + raise TypeError("`data` must be a pandas.DataFrame.") + if not outcome_label: + raise ValueError("`outcome_label` is required.") + if partition_method not in self.SUPPORTED_METHODS: + raise ValueError(f"Unknown partition method '{partition_method}'. Choose from {self.SUPPORTED_METHODS}.") + + # Column checks + if outcome_label not in data.columns: + raise ValueError(f"Outcome column '{outcome_label}' not found in data.") + if partition_method == "Group": + if match_label is None: + raise ValueError("partition_method='Group' requires `match_label`.") + if match_label not in data.columns: + raise ValueError(f"Match column '{match_label}' not found in data.") + + self.data = data + self.outcome_label = outcome_label + self.match_label = match_label + self.name = dataset_name + + self.partition_method = partition_method + self.experiment_path = experiment_path + self.n_splits = int(n_splits) + self.random_state = random_state + + self.train_dfs: Optional[List[pd.DataFrame]] = None + self.test_dfs: Optional[List[pd.DataFrame]] = None + self.cv = None # sklearn splitter instance + + + # ------------------------- + # Main Run Function + # ------------------------- + + def run(self) -> Tuple[List[pd.DataFrame], List[pd.DataFrame]]: + """Convenience wrapper to generate and save splits; returns (train_dfs, test_dfs).""" + train_dfs, test_dfs = self.cv_partitioner(return_dfs=True, save_dfs=True) + return train_dfs, test_dfs + + + # ------------------------- + # Helpers + # ------------------------- + def feature_only_data(self) -> pd.DataFrame: + """Return features-only DataFrame (drops outcome and optional match columns if present).""" + drop_cols = [self.outcome_label] + if self.match_label is not None and self.match_label in self.data.columns: + drop_cols.append(self.match_label) + return self.data.drop(columns=[c for c in drop_cols if c in self.data.columns], errors="ignore") + + def make_splitter(self): + if self.partition_method == "Random": + return KFold(n_splits=self.n_splits, shuffle=True, random_state=self.random_state) + if self.partition_method == "Stratified": + return StratifiedKFold(n_splits=self.n_splits, shuffle=True, random_state=self.random_state) + if self.partition_method == "Group": + return StratifiedGroupKFold(n_splits=self.n_splits, shuffle=True, random_state=self.random_state) + # unreachable given validation + raise RuntimeError("Unexpected partition method") + + # ------------------------- + # Public API + # ------------------------- + def cv_partitioner( + self, + return_dfs: bool = True, + save_dfs: bool = True, + partition_method: Optional[str] = None, + ) -> Tuple[Optional[List[pd.DataFrame]], Optional[List[pd.DataFrame]]]: + """ + Create CV splits. + + Parameters + ---------- + return_dfs : bool, default=True + If True, store and return (train_dfs, test_dfs); otherwise returns (None, None). + save_dfs : bool, default=True + If True, write CSVs to {experiment_path}/{dataset_name}/CVDatasets. + partition_method : str, optional + Override the initialized method (must still be one of SUPPORTED_METHODS). + + Returns + ------- + (train_dfs, test_dfs) or (None, None) + """ + if partition_method: + if partition_method not in self.SUPPORTED_METHODS: + raise ValueError(f"Unknown partition method '{partition_method}'.") + if partition_method == "Group" and self.match_label is None: + raise ValueError("partition_method='Group' requires `match_label`.") + self.partition_method = partition_method + + self.cv = self.make_splitter() + + x = self.feature_only_data() + y = self.data[self.outcome_label] + groups = self.data[self.match_label] if (self.partition_method == "Group") else None + + train_dfs: List[pd.DataFrame] = [] + test_dfs: List[pd.DataFrame] = [] + + if return_dfs: + if self.partition_method == "Group": + for tr_idx, te_idx in self.cv.split(x, y, groups): + train_dfs.append(self.data.iloc[tr_idx, :]) + test_dfs.append(self.data.iloc[te_idx, :]) + else: + for tr_idx, te_idx in self.cv.split(x, y): + train_dfs.append(self.data.iloc[tr_idx, :]) + test_dfs.append(self.data.iloc[te_idx, :]) + + self.train_dfs = train_dfs + self.test_dfs = test_dfs + + if save_dfs: + self.save_datasets(self.experiment_path, self.train_dfs, self.test_dfs) + + return (self.train_dfs, self.test_dfs) if return_dfs else (None, None) + + def save_datasets( + self, + experiment_path: Optional[str] = None, + train_dfs: Optional[List[pd.DataFrame]] = None, + test_dfs: Optional[List[pd.DataFrame]] = None, + ) -> None: + """Save train/test folds as CSV files.""" + experiment_path = experiment_path or self.experiment_path + + if train_dfs is None or test_dfs is None: + if self.train_dfs is None or self.test_dfs is None: + if self.cv is None: + # Build splits on the fly + self.cv_partitioner(return_dfs=True, save_dfs=False) + train_dfs, test_dfs = self.train_dfs, self.test_dfs + else: + train_dfs, test_dfs = self.train_dfs, self.test_dfs + + out_dir = os.path.join(experiment_path, self.name, "CVDatasets") + os.makedirs(out_dir, exist_ok=True) + + for i, df in enumerate(train_dfs or []): + df.to_csv(os.path.join(out_dir, f"{self.name}_CV_{i}_Train.csv"), index=False) + + for i, df in enumerate(test_dfs or []): + df.to_csv(os.path.join(out_dir, f"{self.name}_CV_{i}_Test.csv"), index=False) diff --git a/streamline/p1_data_process/utils/render_from_artifacts.py b/streamline/p1_data_process/utils/render_from_artifacts.py new file mode 100644 index 00000000..b4f761de --- /dev/null +++ b/streamline/p1_data_process/utils/render_from_artifacts.py @@ -0,0 +1,289 @@ +# render_plots_from_artifacts.py + +import os +import json +import logging +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +import seaborn as sns + + +def _exploratory_dir(experiment_path: str, dataset_name: str) -> str: + return os.path.join(experiment_path, dataset_name, "exploratory") + + +def render_missingness_hist(experiment_path: str, dataset_name: str, show: bool = False): + """Render Missingness histogram from DataMissingness.csv.""" + exp_dir = _exploratory_dir(experiment_path, dataset_name) + inp = os.path.join(exp_dir, "DataMissingness.csv") + out = os.path.join(exp_dir, "DataMissingnessHistogram.png") + df = pd.read_csv(inp, index_col=0) + counts = df["Count"].values + plt.figure() + plt.hist(counts, bins=100) + plt.xlabel("Missing Value Counts") + plt.ylabel("Frequency") + plt.title("Histogram of Missing Value Counts in Dataset") + plt.tight_layout() + plt.savefig(out, bbox_inches="tight") + if show: plt.show() + plt.close() + + +def render_class_counts_bar(experiment_path: str, dataset_name: str, show: bool = False, outcome_type: "str | None" = None): + """Render class count bar chart from ClassCounts.csv.""" + exp_dir = _exploratory_dir(experiment_path, dataset_name) + inp = os.path.join(exp_dir, "ClassCounts.csv") + out = os.path.join(exp_dir, "ClassCountsBarPlot.png") + df = pd.read_csv(inp, index_col=0) + plt.figure() + if outcome_type == "Continuous": + plt.hist(df.index.astype(float), bins=100, weights=df["Count"].values) + plt.ylabel("Count"); plt.xlabel("Label"); plt.title("Label Counts") + else: + df["Count"].plot(kind="bar") + plt.ylabel("Count"); plt.title("Class Counts") + plt.tight_layout() + plt.savefig(out, bbox_inches="tight") + if show: plt.show() + plt.close() + + +def render_correlation_heatmap(experiment_path: str, dataset_name: str, initial: str = "", show: bool = False): + """Render heatmap from FeatureCorrelations.csv.""" + exp_dir = _exploratory_dir(experiment_path, dataset_name) + inp = os.path.join(exp_dir, f"{initial}FeatureCorrelations.csv") + out = os.path.join(exp_dir, f"{initial}FeatureCorrelations.png") + corr = pd.read_csv(inp, index_col=0) + sns.set_style("white") + plt.figure(figsize=(max(6, corr.shape[0] // 2), max(6, corr.shape[1] // 2))) + mask = np.zeros_like(corr, dtype=bool) + mask[np.triu_indices_from(mask)] = True + sns.heatmap(corr, mask=mask, vmax=1, vmin=-1, square=True, cmap="RdBu", cbar_kws={"shrink": .75}) + plt.tight_layout() + plt.savefig(out, bbox_inches="tight") + if show: plt.show() + plt.close() + sns.set_theme() + + +def render_univariate_topk(experiment_path: str, dataset_name: str, data_csv: str, + outcome_label: str, categorical_features: list[str], + top_k: int = 20, sig_cutoff: float = 0.05, show: bool = False): + """ + Plot top-k significant features using Univariate_Significance.csv and the processed data CSV. + """ + exp_dir = _exploratory_dir(experiment_path, dataset_name) + uni_path = os.path.join(exp_dir, "univariate_analyses", "Univariate_Significance.csv") + df = pd.read_csv(uni_path, index_col=0) + df = df.sort_values(by="p-value", ascending=True).head(top_k) + data = pd.read_csv(data_csv) + + out_dir = os.path.join(exp_dir, "univariate_analyses") + os.makedirs(out_dir, exist_ok=True) + + for feat, row in df.iterrows(): + pval = row["p-value"] + if pd.isna(pval) or pval > sig_cutoff: + continue + safe = feat.replace(" ", "").replace("*", "").replace("/", "") + if feat in categorical_features: + table = pd.crosstab(data[feat], data[outcome_label]) + table.plot(kind="bar"); plt.ylabel("Contingency Table Count") + out = os.path.join(out_dir, f"Barplot_{safe}.png") + else: + if data[outcome_label].nunique() == 2: + data.boxplot(column=feat, by=outcome_label); plt.ylabel(feat); plt.title("") + out = os.path.join(out_dir, f"Boxplot_{safe}.png") + else: + data.plot(x=feat, y=outcome_label, kind="scatter") + out = os.path.join(out_dir, f"Scatter_{safe}.png") + plt.tight_layout(); plt.savefig(out, bbox_inches="tight") + if show: plt.show() + plt.close('all') + + +def render_anomaly_histograms(experiment_path: str, dataset_name: str, show: bool = False): + """Recreate IF/LOF/EE histograms from imputed_anomaly_scores.csv.""" + base = os.path.join(_exploratory_dir(experiment_path, dataset_name), "anomaly_detection") + scores = pd.read_csv(os.path.join(base, "imputed_anomaly_scores.csv")) + for col in scores.columns: + plt.figure(figsize=(8, 6)) + plt.hist(scores[col].values, bins=30, edgecolor='black') + plt.title(f'Histogram of {col} Anomaly Scores') + plt.xlabel('Anomaly Score'); plt.ylabel('Frequency') + plt.tight_layout() + plt.savefig(os.path.join(base, f'{col.lower().replace(" ", "_")}_histogram.png')) + if show: plt.show() + plt.close() + + +def render_anomaly_rank_heatmap(experiment_path: str, dataset_name: str, top_n: int | None = None, show: bool = False): + """Recreate anomaly rank heatmap (optionally top-n instances) from rankings.csv.""" + base = os.path.join(_exploratory_dir(experiment_path, dataset_name), "anomaly_detection") + ranks = pd.read_csv(os.path.join(base, "rankings.csv")) + # Normalize 0-1 (1 most anomalous) + norm = 1 - (ranks.drop(columns=["Avg_Rank"], errors="ignore") / ranks.drop(columns=["Avg_Rank"], errors="ignore").values.max()) + if top_n is not None and top_n < len(norm): + # pick rows with smallest Avg_Rank + top_idx = ranks["Avg_Rank"].nsmallest(top_n).index + norm = norm.loc[top_idx] + + plt.figure(figsize=(14, 10)) + sns.heatmap(norm, annot=False, cmap=sns.diverging_palette(220, 10, as_cmap=True), + cbar_kws={'label': 'Anomaly Score (1.0 - Most, 0.0 - Least)'}, + yticklabels=True) + plt.yticks(rotation=0) + plt.title('Anomaly Detection Heatmap') + plt.xlabel('Algorithm'); plt.ylabel('Instance ID') + plt.tight_layout() + suffix = f"_top_{top_n}" if top_n else "" + plt.savefig(os.path.join(base, f'anomaly_detection_heatmap{suffix}.png')) + if show: plt.show() + plt.close() + + +def render_all(experiment_path: str, dataset_name: str, + *, + initial: bool = False, + data_csv: "str | None" = None, + outcome_label: "str | None" = None, + categorical_features_csv: "str | None" = None, + outcome_type: "str | None" = None, + univariate_top_k: int = 20, + sig_cutoff: float = 0.05, + show: bool = False): + """ + Convenience wrapper to render common plots from artifacts. + - If you want univariate plots, provide data_csv, outcome_label, categorical_features_csv. + - If you want initial-correlation heatmap, set initial=True. + """ + init_prefix = "initial/" if initial else "" + + # Missingness + Class counts + Correlation + try: render_missingness_hist(experiment_path, dataset_name, show=show) + except Exception as e: logging.warning(f"Missingness plot skipped: {e}") + try: render_class_counts_bar(experiment_path, dataset_name, show=show, outcome_type=outcome_type) + except Exception as e: logging.warning(f"Class counts plot skipped: {e}") + try: render_correlation_heatmap(experiment_path, dataset_name, initial=init_prefix, show=show) + except Exception as e: logging.warning(f"Correlation heatmap skipped: {e}") + + # Univariate (optional) + if data_csv and outcome_label and categorical_features_csv: + try: + cat = list(pd.read_csv(categorical_features_csv)['Feature']) + except Exception: + # also allow one-line headerless CSV with features + cat = list(pd.read_csv(categorical_features_csv, header=None).iloc[0].dropna()) + try: + render_univariate_topk( + experiment_path, dataset_name, data_csv, + outcome_label, cat, top_k=univariate_top_k, sig_cutoff=sig_cutoff, show=show + ) + except Exception as e: + logging.warning(f"Univariate plots skipped: {e}") + + # Anomaly (if available) + try: render_anomaly_histograms(experiment_path, dataset_name, show=show) + except Exception as e: logging.info(f"Anomaly histograms skipped: {e}") + try: render_anomaly_rank_heatmap(experiment_path, dataset_name, top_n=None, show=show) + except Exception as e: logging.info(f"Anomaly heatmap skipped: {e}") + +# --- CLI stub --- +if __name__ == "__main__": + import argparse + import sys + + parser = argparse.ArgumentParser( + description="Render STREAMLINE P1 plots from saved CSV artifacts." + ) + parser.add_argument("--experiment_path", "-e", required=True, help="Root experiments folder") + parser.add_argument("--dataset_name", "-d", required=True, help="Dataset folder name under experiments") + + # global toggles + parser.add_argument("--show", action="store_true", help="Display figures interactively") + parser.add_argument("--all", action="store_true", help="Render all available plots (CSV must exist)") + + # individual plot switches + parser.add_argument("--missingness", action="store_true", help="Render missingness histogram") + parser.add_argument("--class_counts", action="store_true", help="Render class-counts bar chart") + parser.add_argument("--correlation", action="store_true", help="Render correlation heatmap") + parser.add_argument("--initial", action="store_true", help="Use initial/ prefix for correlation heatmap") + + # univariate options + parser.add_argument("--univariate", action="store_true", help="Render top-k univariate plots") + parser.add_argument("--data_csv", help="Path to processed data CSV (for univariate plots)") + parser.add_argument("--outcome_label", help="Outcome column name in data_csv") + parser.add_argument("--categorical_features_csv", help="Path to processed_categorical_features.csv") + parser.add_argument("--univariate_top_k", type=int, default=20, help="Top-k features to plot (default: 20)") + parser.add_argument("--sig_cutoff", type=float, default=0.05, help="p-value cutoff (default: 0.05)") + + # class counts rendering hint + parser.add_argument("--outcome_type", choices=["Binary", "Multiclass", "Continuous"], + help="Outcome type (improves class-counts rendering)") + + # anomaly options + parser.add_argument("--anomaly_hists", action="store_true", help="Render anomaly histograms (IF/LOF/EE)") + parser.add_argument("--anomaly_heatmap", action="store_true", help="Render anomaly rank heatmap") + parser.add_argument("--anomaly_top_n", type=int, default=None, + help="Limit anomaly heatmap to top-N most anomalous instances") + + args = parser.parse_args() + + # convenience: --all flips the right switches + if args.all: + args.missingness = True + args.class_counts = True + args.correlation = True + args.univariate = args.univariate or (args.data_csv and args.outcome_label and args.categorical_features_csv) + args.anomaly_hists = True + args.anomaly_heatmap = True + + # dispatch + try: + if args.missingness: + render_missingness_hist(args.experiment_path, args.dataset_name, show=args.show) + + if args.class_counts: + render_class_counts_bar(args.experiment_path, args.dataset_name, + outcome_type=args.outcome_type, show=args.show) + + if args.correlation: + render_correlation_heatmap(args.experiment_path, args.dataset_name, + initial=("initial/" if args.initial else ""), show=args.show) + + if args.univariate: + if not (args.data_csv and args.outcome_label and args.categorical_features_csv): + print("--univariate requires --data_csv, --outcome_label, and --categorical_features_csv", file=sys.stderr) + sys.exit(2) + try: + cat = list(pd.read_csv(args.categorical_features_csv)['Feature']) + except Exception: + cat = list(pd.read_csv(args.categorical_features_csv, header=None).iloc[0].dropna()) + render_univariate_topk( + experiment_path=args.experiment_path, + dataset_name=args.dataset_name, + data_csv=args.data_csv, + outcome_label=args.outcome_label, + categorical_features=cat, + top_k=args.univariate_top_k, + sig_cutoff=args.sig_cutoff, + show=args.show, + ) + + if args.anomaly_hists: + render_anomaly_histograms(args.experiment_path, args.dataset_name, show=args.show) + + if args.anomaly_heatmap: + render_anomaly_rank_heatmap(args.experiment_path, args.dataset_name, + top_n=args.anomaly_top_n, show=args.show) + + # if nothing selected, hint usage + if not any([args.missingness, args.class_counts, args.correlation, + args.univariate, args.anomaly_hists, args.anomaly_heatmap, args.all]): + parser.print_help() + + except Exception as exc: + logging.exception("Rendering failed: %s", exc) + sys.exit(1) diff --git a/streamline/p1_data_process/utils/validators.py b/streamline/p1_data_process/utils/validators.py new file mode 100644 index 00000000..e36fc015 --- /dev/null +++ b/streamline/p1_data_process/utils/validators.py @@ -0,0 +1,31 @@ +import os +import re +import pandas as pd + +PAIR_RE = re.compile(r"^(?P.+)_CV_(?P.+)_(?PTrain|Test)\.csv$") + +def find_cv_pairs(cv_dataset_dir): + pairs = {} + for fname in os.listdir(cv_dataset_dir): + m = PAIR_RE.match(fname) + if not m: + continue + fold = str(m.group("fold")) + split = m.group("split") + pairs.setdefault(fold, {}) + pairs[fold][split] = os.path.join(cv_dataset_dir, fname) + return {k: v for k, v in pairs.items() if "Train" in v and "Test" in v} + +def validate_cv_pair(train_df, test_df, outcome_label, instance_label=None): + # columns/order identical + if list(train_df.columns) != list(test_df.columns): + raise ValueError("Train/Test columns differ or are in different order") + # outcome present + if outcome_label not in train_df.columns or outcome_label not in test_df.columns: + raise ValueError("Outcome column '%s' missing in Train or Test" % outcome_label) + # disjoint instances + if instance_label and instance_label in train_df.columns and instance_label in test_df.columns: + a = set(train_df[instance_label].astype(str).tolist()) + b = set(test_df[instance_label].astype(str).tolist()) + if a & b: + raise ValueError("Instance leakage across Train/Test for label '%s'" % instance_label) diff --git a/streamline/modeling/__init__.py b/streamline/p2_impute_scale/__init__.py similarity index 100% rename from streamline/modeling/__init__.py rename to streamline/p2_impute_scale/__init__.py diff --git a/streamline/p2_impute_scale/impute_scale.py b/streamline/p2_impute_scale/impute_scale.py new file mode 100644 index 00000000..0dcd9f52 --- /dev/null +++ b/streamline/p2_impute_scale/impute_scale.py @@ -0,0 +1,459 @@ +# streamline/phases/p2_impute_scale/job.py +import os +import time +import pickle +import random +import logging +import importlib +import numpy as np +import pandas as pd +from sklearn.experimental import enable_iterative_imputer # noqa: F401 +from sklearn.impute import IterativeImputer +from sklearn.preprocessing import StandardScaler +from streamline.p2_impute_scale.utils.impute_loader import load_imputer +from streamline.p2_impute_scale.utils.scale_loader import load_scaler + + +class ImputeAndScale: + """ + Phase 2: Scaling and Imputation of CV Datasets + - Backwards compatible with the original behavior + - Optional registry-driven imputer selection + """ + + def __init__( + self, + cv_train_path, + cv_test_path, + experiment_path, + scale_data: bool = True, + impute_data: bool = True, + multi_impute: bool = False, # original flag: if True uses IterativeImputer + overwrite_cv: bool = True, + outcome_label: str = "Class", + instance_label=None, + random_state: "int | None" = None, + # NEW (optional) + imputer_id: "str | None" = "iterative", # e.g., "simple", "knn", "iterative", "median_map" + imputer_params: "dict | None" = None, # params forwarded to registry imputer + # NEW (optional) + scaler_id: "str | None" = None, + scaler_params: "dict | None" = None, + outcome_type: "str | None" = None, + smote: bool = False, + smote_method: str = "auto", + smote_sampling_strategy: "str | dict | float" = "auto", + smote_k_neighbors: int = 5, + ): + self.cv_train_path = cv_train_path + self.cv_test_path = cv_test_path + self.experiment_path = experiment_path + self.scale_data = scale_data + self.impute_data = impute_data + self.multi_impute = multi_impute + self.overwrite_cv = overwrite_cv + self.outcome_label = outcome_label + self.instance_label = instance_label + self.categorical_variables = None + self.dataset_name = None + self.cv_count = None + self.random_state = random_state + self.imputer_id = imputer_id + self.imputer_params = imputer_params or {} + self.scaler_id = scaler_id + self.scaler_params = scaler_params or {} + self.outcome_type = outcome_type + self.smote = bool(smote) + self.smote_method = str(smote_method or "auto").strip().lower() + self.smote_sampling_strategy = smote_sampling_strategy + self.smote_k_neighbors = int(smote_k_neighbors) + + + def run(self): + self.job_start_time = time.time() + # Seeds for repeatability + random.seed(self.random_state) + np.random.seed(self.random_state) + + + # Load CV fold train/test + data_train, data_test = self.load_data() + + # Feature header (exclude outcome/instance) + header = data_train.columns.tolist() + header.remove(self.outcome_label) + if self.instance_label is not None and self.instance_label in header: + header.remove(self.instance_label) + + logging.info('Preparing Train and Test for: %s_CV_%s', self.dataset_name, self.cv_count) + + y_train = data_train[self.outcome_label] + y_test = data_test[self.outcome_label] + + i_train = i_test = None + if self.instance_label is not None: + i_train = data_train[self.instance_label] + i_test = data_test[self.instance_label] + + if self.instance_label is None: + x_train = data_train.drop([self.outcome_label], axis=1) + x_test = data_test.drop([self.outcome_label], axis=1) + else: + x_train = data_train.drop([self.outcome_label, self.instance_label], axis=1) + x_test = data_test.drop([self.outcome_label, self.instance_label], axis=1) + del data_train, data_test + + # Load categorical features list + with open(os.path.join(self.experiment_path, self.dataset_name, 'exploratory', 'categorical_features.pickle'), 'rb') as f: + self.categorical_variables = pickle.load(f) + + # Imputation + if self.impute_data: + logging.info('Imputing Missing Values...') + data_counts = pd.read_csv( + os.path.join(self.experiment_path, self.dataset_name, 'exploratory', 'DataCounts.csv'), + na_values='NA', sep=',' + ) + missing_values = int(data_counts['Count'].values[4]) + if missing_values != 0: + x_train, x_test = self.impute_cv_data(x_train, x_test) + x_train = pd.DataFrame(x_train, columns=header) + x_test = pd.DataFrame(x_test, columns=header) + else: + logging.info('Notice: No missing values found. Imputation skipped.') + + # Scaling + if self.scale_data: + logging.info('Scaling Data Values...') + x_train, x_test = self.data_scaling(x_train, x_test) + + # SMOTE is intentionally applied after imputation/scaling and only to train. + if self.smote: + logging.info('Applying SMOTE to training fold...') + x_train, y_train, i_train = self.apply_smote(x_train, y_train, i_train) + + # Reassemble + if self.instance_label is None: + data_train = pd.concat([pd.DataFrame(y_train, columns=[self.outcome_label]), + pd.DataFrame(x_train, columns=header)], axis=1, sort=False) + data_test = pd.concat([pd.DataFrame(y_test, columns=[self.outcome_label]), + pd.DataFrame(x_test, columns=header)], axis=1, sort=False) + else: + data_train = pd.concat([pd.DataFrame(y_train, columns=[self.outcome_label]), + pd.DataFrame(i_train, columns=[self.instance_label]), + pd.DataFrame(x_train, columns=header)], axis=1, sort=False) + data_test = pd.concat([pd.DataFrame(y_test, columns=[self.outcome_label]), + pd.DataFrame(i_test, columns=[self.instance_label]), + pd.DataFrame(x_test, columns=header)], axis=1, sort=False) + del x_train, x_test + + # Export & finalize + logging.info('Saving Processed Train and Test Data...') + if self.impute_data or self.scale_data or self.smote: + self.write_cv_files(data_train, data_test) + + self.save_runtime() + logging.info('%s Phase 2 complete', self.dataset_name) + with open(os.path.join(self.experiment_path, 'jobsCompleted', + f'job_preprocessing_{self.dataset_name}_{self.cv_count}.txt'), 'w') as jf: + jf.write('complete') + + def load_data(self): + self.dataset_name = self.cv_train_path.split('/')[-3] + self.cv_count = self.cv_train_path.split('/')[-1].split("_")[-2] + data_train = pd.read_csv(self.cv_train_path, na_values='NA', sep=',') + data_test = pd.read_csv(self.cv_test_path, na_values='NA', sep=',') + return data_train, data_test + + def impute_cv_data(self, x_train: pd.DataFrame, x_test: pd.DataFrame): + """ + Categorical: mode imputation (train mode applied to test). + Quantitative: either IterativeImputer (multi_impute) or registry-selected imputer; + fallback to 'median_map' if requested. + """ + # 1) Categorical mode map (saved) + mode_dict = {} + for c in x_train.columns: + if c in self.categorical_variables: + train_mode = x_train[c].mode(dropna=True).iloc[0] + x_train[c] = x_train[c].fillna(train_mode) + mode_dict[c] = train_mode + for c in x_test.columns: + if c in self.categorical_variables: + x_test[c] = x_test[c].fillna(mode_dict[c]) + + out_cat = os.path.join(self.experiment_path, self.dataset_name, "impute_scale", + f"categorical_imputer_cv{self.cv_count}.pickle") + os.makedirs(os.path.dirname(out_cat), exist_ok=True) + with open(out_cat, "wb") as f: + pickle.dump(mode_dict, f) + + # 2) Quantitative + # If an explicit registry imputer is requested, use it: + if self.imputer_id: + if self.imputer_params: + imp = load_imputer(self.imputer_id, **self.imputer_params) + else: + imp = load_imputer(self.imputer_id) + imp = imp.fit(x_train.select_dtypes(include=['number'])) + Xtr_num = imp.transform(x_train.select_dtypes(include=['number'])) + Xte_num = imp.transform(x_test.select_dtypes(include=['number'])) + # put back numeric columns + x_train.loc[:, Xtr_num.columns] = Xtr_num + x_test.loc[:, Xte_num.columns] = Xte_num + + out_num = os.path.join(self.experiment_path, self.dataset_name, "impute_scale", + f"ordinal_imputer_cv{self.cv_count}.pickle") + with open(out_num, "wb") as f: + pickle.dump({"id": self.imputer_id, "params": imp.get_params()}, f) + return x_train, x_test + + # Otherwise, preserve original behavior + else: + if self.multi_impute: + imputer = IterativeImputer(random_state=self.random_state, max_iter=30) + imputer = imputer.fit(x_train.select_dtypes(include=['number'])) + Xtr_num = imputer.transform(x_train.select_dtypes(include=['number'])) + Xte_num = imputer.transform(x_test.select_dtypes(include=['number'])) + x_train.loc[:, x_train.select_dtypes(include=['number']).columns] = Xtr_num + x_test.loc[:, x_test.select_dtypes(include=['number']).columns] = Xte_num + out_num = os.path.join(self.experiment_path, self.dataset_name, 'impute_scale', + f'ordinal_imputer_cv{self.cv_count}.pickle') + with open(out_num, 'wb') as f: + pickle.dump(imputer, f) + else: + # median_map fallback for numeric + median_dict = {} + num_cols = x_train.select_dtypes(include=['number']).columns + for c in num_cols: + m = x_train[c].median() + x_train[c] = x_train[c].fillna(m) + median_dict[c] = m + for c in num_cols: + x_test[c] = x_test[c].fillna(median_dict[c]) + + out_num = os.path.join(self.experiment_path, self.dataset_name, 'impute_scale', + f'ordinal_imputer_cv{self.cv_count}.pickle') + with open(out_num, 'wb') as f: + pickle.dump(median_dict, f) + + return x_train, x_test + + def data_scaling(self, x_train, x_test): + decimal_places = 7 + + if self.scaler_id: + # use registry scaler (fits on numeric columns internally) + scaler = load_scaler(self.scaler_id, **(self.scaler_params or {})).fit(x_train) + x_train = scaler.transform(x_train).round(decimal_places) + x_test = scaler.transform(x_test).round(decimal_places) + out_scl = os.path.join(self.experiment_path, self.dataset_name, + 'impute_scale', f'scaler_cv{self.cv_count}.pickle') + with open(out_scl, 'wb') as f: + pickle.dump({"id": self.scaler_id, "params": scaler.get_params()}, f) + return x_train, x_test + + # original default (StandardScaler on numeric only) + else: + from sklearn.preprocessing import StandardScaler + scaler = StandardScaler() + scaler.fit(x_train.select_dtypes(include=['number'])) + + num_cols = x_train.select_dtypes(include=['number']).columns + x_train_num = pd.DataFrame( + scaler.transform(x_train[num_cols]).round(decimal_places), + columns=num_cols, index=x_train.index + ) + x_test_num = pd.DataFrame( + scaler.transform(x_test[num_cols]).round(decimal_places), + columns=num_cols, index=x_test.index + ) + x_train = x_train.astype(x_train_num.dtypes.to_dict()) + x_test = x_test.astype(x_test_num.dtypes.to_dict()) + x_train.loc[:, num_cols] = x_train_num + x_test.loc[:, num_cols] = x_test_num + + out_scl = os.path.join(self.experiment_path, self.dataset_name, + 'impute_scale', f'scaler_cv{self.cv_count}.pickle') + with open(out_scl, 'wb') as f: + pickle.dump(scaler, f) + return x_train, x_test + + def apply_smote(self, x_train: pd.DataFrame, y_train: pd.Series, i_train: "pd.Series | None"): + if self.outcome_type == "Continuous": + raise ValueError("SMOTE is only supported for Binary and Multiclass outcomes, not Continuous outcomes.") + + class_counts = y_train.value_counts(dropna=False).to_dict() + if len(class_counts) < 2: + logging.warning("SMOTE skipped for %s CV%s because only one class is present.", self.dataset_name, self.cv_count) + self.save_smote_metadata("none", False, class_counts, class_counts, [], "only one class present") + return x_train, y_train, i_train + + smallest_class_count = min(class_counts.values()) + largest_class_count = max(class_counts.values()) + if smallest_class_count == largest_class_count: + logging.info("SMOTE skipped for %s CV%s because classes are already balanced.", self.dataset_name, self.cv_count) + self.save_smote_metadata("none", False, class_counts, class_counts, [], "classes already balanced") + return x_train, y_train, i_train + if smallest_class_count < 2: + logging.warning("SMOTE skipped for %s CV%s because at least one class has fewer than 2 rows.", self.dataset_name, self.cv_count) + self.save_smote_metadata("none", False, class_counts, class_counts, [], "class count below 2") + return x_train, y_train, i_train + + try: + from imblearn.over_sampling import SMOTE, SMOTENC + except ImportError as exc: + raise ImportError( + "SMOTE requires the optional dependency imbalanced-learn. " + "Install it with `pip install imbalanced-learn` or use the project requirements." + ) from exc + + categorical_columns = [ + col for col in (self.categorical_variables or []) + if col in x_train.columns + ] + categorical_indices = [x_train.columns.get_loc(col) for col in categorical_columns] + resolved_method = self.resolve_smote_method(categorical_indices, x_train) + neighbors = min(max(int(self.smote_k_neighbors), 1), smallest_class_count - 1) + + if resolved_method == "smotenc": + sampler = SMOTENC( + categorical_features=categorical_indices, + sampling_strategy=self.smote_sampling_strategy, + k_neighbors=neighbors, + random_state=self.random_state, + ) + else: + sampler = SMOTE( + sampling_strategy=self.smote_sampling_strategy, + k_neighbors=neighbors, + random_state=self.random_state, + ) + + original_rows = len(x_train) + x_resampled, y_resampled = sampler.fit_resample(x_train, y_train) + x_resampled = pd.DataFrame(x_resampled, columns=x_train.columns) + y_resampled = pd.Series(y_resampled, name=self.outcome_label) + self.restore_resampled_dtypes(x_resampled, x_train, categorical_columns) + + if i_train is not None: + original_ids = list(pd.Series(i_train).astype(str)) + synthetic_count = len(x_resampled) - original_rows + synthetic_ids = [ + f"{self.dataset_name}_CV_{self.cv_count}_SMOTE_{idx + 1:06d}" + for idx in range(synthetic_count) + ] + i_resampled = pd.Series(original_ids + synthetic_ids, name=self.instance_label) + else: + i_resampled = None + + after_counts = y_resampled.value_counts(dropna=False).to_dict() + self.save_smote_metadata( + resolved_method, + True, + class_counts, + after_counts, + categorical_columns, + None, + neighbors, + len(x_resampled) - original_rows, + ) + logging.info( + "SMOTE complete for %s CV%s: %s rows -> %s rows", + self.dataset_name, + self.cv_count, + original_rows, + len(x_resampled), + ) + + return ( + x_resampled.reset_index(drop=True), + y_resampled.reset_index(drop=True), + None if i_resampled is None else i_resampled.reset_index(drop=True), + ) + + def resolve_smote_method(self, categorical_indices, x_train): + if self.smote_method not in {"auto", "smote", "smotenc"}: + raise ValueError("smote_method must be one of: auto, smote, smotenc") + + if self.smote_method == "auto": + if categorical_indices: + if len(categorical_indices) == len(x_train.columns): + raise ValueError("SMOTENC requires at least one non-categorical feature.") + return "smotenc" + return "smote" + + if self.smote_method == "smotenc" and not categorical_indices: + raise ValueError("smote_method='smotenc' requires at least one categorical feature.") + + if self.smote_method == "smotenc" and len(categorical_indices) == len(x_train.columns): + raise ValueError("SMOTENC requires at least one non-categorical feature.") + + return self.smote_method + + def restore_resampled_dtypes(self, x_resampled, x_original, categorical_columns): + categorical_set = set(categorical_columns) + for col in x_resampled.columns: + if col in categorical_set: + try: + x_resampled[col] = x_resampled[col].astype(x_original[col].dtype) + except Exception: + pass + else: + x_resampled[col] = pd.to_numeric(x_resampled[col], errors="coerce") + + def save_smote_metadata( + self, + method, + applied, + class_counts_before, + class_counts_after, + categorical_columns, + reason=None, + k_neighbors=None, + synthetic_rows=0, + ): + out_path = os.path.join( + self.experiment_path, + self.dataset_name, + "impute_scale", + f"smote_cv{self.cv_count}.pickle", + ) + os.makedirs(os.path.dirname(out_path), exist_ok=True) + with open(out_path, "wb") as f: + pickle.dump( + { + "applied": bool(applied), + "method": method, + "requested_method": self.smote_method, + "sampling_strategy": self.smote_sampling_strategy, + "k_neighbors": k_neighbors, + "synthetic_rows": int(synthetic_rows), + "categorical_features": list(categorical_columns), + "class_counts_before": dict(class_counts_before), + "class_counts_after": dict(class_counts_after), + "reason": reason, + }, + f, + ) + + + def write_cv_files(self, data_train, data_test): + if self.overwrite_cv: + os.remove(self.cv_train_path) + os.remove(self.cv_test_path) + else: + os.rename(self.cv_train_path, + os.path.join(self.experiment_path, self.dataset_name, + 'CVDatasets', f'{self.dataset_name}_CVOnly_{self.cv_count}_Train.csv')) + os.rename(self.cv_test_path, + os.path.join(self.experiment_path, self.dataset_name, + 'CVDatasets', f'{self.dataset_name}_CVOnly_{self.cv_count}_Test.csv')) + data_train.to_csv(self.cv_train_path, index=False) + data_test.to_csv(self.cv_test_path, index=False) + + def save_runtime(self): + rt_dir = os.path.join(self.experiment_path, self.dataset_name, 'runtime') + os.makedirs(rt_dir, exist_ok=True) + with open(os.path.join(rt_dir, f'runtime_preprocessing{self.cv_count}.txt'), 'w+') as f: + f.write(str(time.time() - self.job_start_time)) diff --git a/streamline/p2_impute_scale/p2_cli.py b/streamline/p2_impute_scale/p2_cli.py new file mode 100644 index 00000000..7b5500bb --- /dev/null +++ b/streamline/p2_impute_scale/p2_cli.py @@ -0,0 +1,165 @@ +# streamline/phases/p2_impute_scale/cli.py +import argparse +import json +from typing import Optional, Dict, Any + +from streamline.p2_impute_scale.p2_runner import P2Runner +from streamline.p2_impute_scale.utils.impute_loader import list_imputers +from streamline.p2_impute_scale.utils.scale_loader import list_scalers +from streamline.utils.run_commands import ( + add_run_command_args, + apply_saved_run_command, + save_run_command_from_args, + snapshot_args, +) + + +def _maybe_json(v: Optional[str]) -> Dict[str, Any]: + if v in (None, "", "{}", "null"): + return {} + try: + return json.loads(v) + except Exception: + return {} + + +def _bool(v: Optional[str], default: bool = False) -> bool: + if v is None: + return default + vl = str(v).strip().lower() + if vl in ("1", "true", "t", "yes", "y"): + return True + if vl in ("0", "false", "f", "no", "n"): + return False + return default + + +def parse_sampling_strategy(value): + if value in (None, "", "auto"): + return "auto" + try: + return json.loads(value) + except Exception: + try: + return float(value) + except Exception: + return value + + +def main(): + ap = argparse.ArgumentParser( + "STREAMLINE Phase 2 Runner (CV-based, Dask-aware)", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + ap.add_argument("--output_path", required=True) + ap.add_argument("--experiment_name", required=True) + + # Optional overrides; if omitted, pulled from metadata.pickle + ap.add_argument("--scale_data", default=None) + ap.add_argument("--impute_data", default=None) + ap.add_argument("--multi_impute", default=None) + ap.add_argument("--overwrite_cv", default=None) + ap.add_argument("--outcome_label", default=None) + ap.add_argument("--outcome_type", default=None, choices=["Binary", "Multiclass", "Continuous"]) + ap.add_argument("--instance_label", default=None) + ap.add_argument("--random_state", default=None, type=int) + + # Imputer registry + ap.add_argument("--imputer_id", default=None) + ap.add_argument("--imputer_params", default="{}") + + # Scaler registry + ap.add_argument("--scaler_id", default=None) + ap.add_argument("--scaler_params", default="{}") + + # SMOTE/SMOTENC oversampling; applied after imputation/scaling to train folds only. + ap.add_argument("--smote", default=None, help="1/true enables SMOTE for classification training folds") + ap.add_argument("--smote_method", default="auto", choices=["auto", "smote", "smotenc"]) + ap.add_argument("--smote_sampling_strategy", default="auto") + ap.add_argument("--smote_k_neighbors", default=5, type=int) + + # Execution/modes + ap.add_argument("--run_cluster", default="Serial", help='Serial | Local | Parallel | BashSLURM | BashLSF | ""') + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", default=4, type=int) + + # Discovery-only flags + ap.add_argument("--list-imputers", action="store_true", help="List dynamically discovered imputers and exit") + ap.add_argument("--list-scalers", action="store_true", help="List dynamically discovered scalers and exit") + add_run_command_args(ap) + + args = ap.parse_args() + args = apply_saved_run_command(ap, args, "p2_impute_scale") + run_command_args = snapshot_args(args) + + if args.list_imputers: + imps = list_imputers() + print("Available imputers:") + for k, cls in sorted(imps.items()): + print(f" {k:15s} -> {cls.__module__}.{cls.__name__}") + return + + if args.list_scalers: + scs = list_scalers() + print("Available scalers:") + for k, cls in sorted(scs.items()): + print(f" {k:15s} -> {cls.__module__}.{cls.__name__}") + return + + runner = P2Runner( + output_path=args.output_path, + experiment_name=args.experiment_name, + # overrides (None → take from metadata) + scale_data=None if args.scale_data is None else _bool(args.scale_data, True), + impute_data=None if args.impute_data is None else _bool(args.impute_data, True), + multi_impute=None if args.multi_impute is None else _bool(args.multi_impute, False), + overwrite_cv=None if args.overwrite_cv is None else _bool(args.overwrite_cv, True), + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + instance_label=args.instance_label, + random_state=args.random_state, + # registries + imputer_id=args.imputer_id, + imputer_params=_maybe_json(args.imputer_params), + scaler_id=args.scaler_id, + scaler_params=_maybe_json(args.scaler_params), + smote=None if args.smote is None else _bool(args.smote, False), + smote_method=args.smote_method, + smote_sampling_strategy=parse_sampling_strategy(args.smote_sampling_strategy), + smote_k_neighbors=args.smote_k_neighbors, + # execution + run_cluster=args.run_cluster if args.run_cluster not in (None, "Serial", "False", "false") else False, + queue=args.queue, + reserved_memory=args.reserved_memory, + ) + runner.run() + save_run_command_from_args(args, "p2_impute_scale", run_command_args, runner=runner) + + +if __name__ == "__main__": + # Inspect dynamic components + # python -m streamline.p2_impute_scale.p2_cli --output_path ./out --experiment_name MyExp --list-imputers + # python -m streamline.p2_impute_scale.p2_cli --output_path ./out --experiment_name MyExp --list-scalers + + # # Serial run (use defaults from metadata.pickle) + # python -m streamline.p2_impute_scale.p2_cli \ + # --output_path ./test \ + # --experiment_name MyExp + + # # Force specific imputer & scaler (with params) + # python -m streamline.p2_impute_scale.p2_cli \ + # --output_path ./out \ + # --experiment_name MyExp \ + # --imputer_id knn \ + # --imputer_params '{"n_neighbors": 7, "weights": "distance"}' \ + # --scaler_id minmax \ + # --scaler_params '{"feature_range":[0,1]}' + + # # Enable post-imputation/scaling SMOTE for train folds only + # python -m streamline.p2_impute_scale.p2_cli \ + # --output_path ./out \ + # --experiment_name MyExp \ + # --smote 1 \ + # --smote_method auto + + main() diff --git a/streamline/p2_impute_scale/p2_jobsubmit.py b/streamline/p2_impute_scale/p2_jobsubmit.py new file mode 100644 index 00000000..fdd695b3 --- /dev/null +++ b/streamline/p2_impute_scale/p2_jobsubmit.py @@ -0,0 +1,157 @@ +# streamline/phases/p2_impute_scale/p2_jobsubmit.py +import argparse +import json +import os +import pickle +from typing import Any, Dict, Optional + +from streamline.p2_impute_scale.impute_scale import ImputeAndScale + + +def _coalesce_bool(v: Optional[str], default: bool) -> bool: + if v is None or v == '': + return default + if isinstance(v, str): + vl = v.strip().lower() + if vl in ('1', 'true', 'yes', 'y'): + return True + if vl in ('0', 'false', 'no', 'n'): + return False + return bool(v) + + +def _load_metadata(exp_path: str) -> Dict[str, Any]: + meta_path = os.path.join(exp_path, "metadata.pickle") + if os.path.exists(meta_path): + with open(meta_path, "rb") as f: + try: + return pickle.load(f) or {} + except Exception: + return {} + return {} + + +def parse_sampling_strategy(value): + if value in (None, "", "auto"): + return "auto" + try: + return json.loads(value) + except Exception: + try: + return float(value) + except Exception: + return value + + +def main(): + ap = argparse.ArgumentParser("P2 single-CV-pair jobsubmit") + ap.add_argument("--cv_train_path", required=True) + ap.add_argument("--cv_test_path", required=True) + ap.add_argument("--experiment_path", required=True) + + # Optional overrides (can be empty strings; we fallback to metadata) + ap.add_argument("--scale_data", default=None) # "1"/"0" or "true"/"false" + ap.add_argument("--impute_data", default=None) + ap.add_argument("--multi_impute", default=None) + ap.add_argument("--overwrite_cv", default=None) + + ap.add_argument("--outcome_label", default=None) + ap.add_argument("--outcome_type", default=None) + ap.add_argument("--instance_label", default=None) + ap.add_argument("--random_state", default=None) + + ap.add_argument("--imputer_id", default=None) + ap.add_argument("--imputer_params", default="{}") # JSON string + + ap.add_argument("--scaler_id", default=None) + ap.add_argument("--scaler_params", default="{}") # JSON string + + ap.add_argument("--smote", default=None) + ap.add_argument("--smote_method", default="auto") + ap.add_argument("--smote_sampling_strategy", default="auto") + ap.add_argument("--smote_k_neighbors", default=5) + + args = ap.parse_args() + exp_path = args.experiment_path + + meta = _load_metadata(exp_path) + + # coalesce params + scale_data = _coalesce_bool(args.scale_data, meta.get('Use Data Scaling', True)) + impute_data = _coalesce_bool(args.impute_data, meta.get('Use Data Imputation', True)) + multi_impute = _coalesce_bool(args.multi_impute, meta.get('Use Multivariate Imputation', False)) + overwrite_cv = _coalesce_bool(args.overwrite_cv, True) + + outcome_label = args.outcome_label or meta.get('Outcome Label', 'Class') + outcome_type = args.outcome_type if args.outcome_type not in (None, '') else meta.get('Outcome Type', None) + instance_label = args.instance_label if args.instance_label not in (None, '') else meta.get('Instance Label', None) + random_state = None + if args.random_state not in (None, ''): + try: + random_state = int(args.random_state) + except Exception: + random_state = meta.get('Random Seed', 0) + else: + random_state = meta.get('Random Seed', 0) + + # imputer choices (CLI overrides metadata) + imputer_id = args.imputer_id if args.imputer_id not in (None, '') else meta.get('P2 Imputer Id', None) + try: + imputer_params_cli = json.loads(args.imputer_params or "{}") + except Exception: + imputer_params_cli = {} + mp = meta.get('P2 Imputer Params', '{}') + if isinstance(mp, str): + try: + mp = json.loads(mp or "{}") + except Exception: + mp = {} + imputer_params = imputer_params_cli or mp or {} + + scaler_id = args.scaler_id if args.scaler_id not in (None, '') else meta.get('P2 Scaler Id', None) + try: + scaler_params_cli = json.loads(args.scaler_params or "{}") + except Exception: + scaler_params_cli = {} + sp = meta.get('P2 Scaler Params', '{}') + if isinstance(sp, str): + try: sp = json.loads(sp or "{}") + except Exception: sp = {} + scaler_params = scaler_params_cli or sp or {} + + smote = _coalesce_bool(args.smote, meta.get('Use SMOTE', False)) + smote_method = args.smote_method or meta.get('P2 SMOTE Method', 'auto') + smote_sampling_strategy = parse_sampling_strategy(args.smote_sampling_strategy) + if smote_sampling_strategy == "auto": + smote_sampling_strategy = meta.get('P2 SMOTE Sampling Strategy', 'auto') + try: + smote_k_neighbors = int(args.smote_k_neighbors) + except Exception: + smote_k_neighbors = int(meta.get('P2 SMOTE K Neighbors', 5)) + + job = ImputeAndScale( + cv_train_path=args.cv_train_path, + cv_test_path=args.cv_test_path, + experiment_path=exp_path, + scale_data=scale_data, + impute_data=impute_data, + multi_impute=multi_impute, + overwrite_cv=overwrite_cv, + outcome_label=outcome_label, + outcome_type=outcome_type, + instance_label=instance_label, + random_state=random_state, + imputer_id=imputer_id, + imputer_params=imputer_params, + scaler_id=scaler_id, + scaler_params=scaler_params, + smote=smote, + smote_method=smote_method, + smote_sampling_strategy=smote_sampling_strategy, + smote_k_neighbors=smote_k_neighbors, + ) + job.run() + + +if __name__ == "__main__": + main() diff --git a/streamline/p2_impute_scale/p2_runner.py b/streamline/p2_impute_scale/p2_runner.py new file mode 100644 index 00000000..d45d41a7 --- /dev/null +++ b/streamline/p2_impute_scale/p2_runner.py @@ -0,0 +1,355 @@ +# streamline/phases/p2_impute_scale/runner.py +import logging +import os +import re +import glob +import json +import time +import pickle +from pathlib import Path +from typing import Dict, Any, Iterable, Tuple, List + +import pandas as pd + +import dask +from dask.distributed import Client, LocalCluster +logger = logging.getLogger("distributed.worker") +logger.setLevel(logging.WARNING) + +from streamline.utils.runners import num_cores, run_dask_tasks, run_parallel_jobs # runner_fn not needed; we call job.run() +from streamline.utils.cluster import get_cluster # must return a connected Dask Client +from streamline.p2_impute_scale.impute_scale import ImputeAndScale +from streamline.p2_impute_scale.utils.impute_loader import list_imputers + + + +class P2Runner: + """ + Phase 2 runner (CV-based, Dask-aware, bash-job submission capable). + + Modes (set via run_cluster): + • "Local" → local Dask parallelization. + • "Parallel" → local joblib parallelization. + • "Parallel" → local joblib parallelization. + • "BashSLURM" → submit a bash script (sbatch) that runs p2_jobsubmit.py per CV pair. + • "BashLSF" → submit a bash script (bsub) that runs p2_jobsubmit.py per CV pair. + • any other str → modern Dask cluster name; get_cluster(name, ...) returns a connected Client (works in Jupyter). + • False/None → Serial. + """ + + def __init__( + self, + output_path: str, + experiment_name: str, + + # Phase-2 flags (if None, we pull from metadata.pickle) + scale_data: "bool | None" = None, + impute_data: "bool | None" = None, + multi_impute: "bool | None" = None, + overwrite_cv: "bool | None" = None, + outcome_label: "str | None" = None, + outcome_type: "str | None" = None, + instance_label: "str | None" = None, + random_state: "int | None" = None, + + # optional registry-driven imputer + imputer_id: "str | None" = None, + imputer_params: "Dict[str, Any] | None" = None, + scaler_id: "str | None" = None, + scaler_params: "Dict[str, Any] | None" = None, + smote: "bool | None" = None, + smote_method: "str | None" = None, + smote_sampling_strategy: "str | dict | float | None" = None, + smote_k_neighbors: "int | None" = None, + + # execution mode + run_cluster: "str | bool" = False, # False | "Local" | "Parallel" | "BashSLURM" | "BashLSF" | "" + queue: str = 'defq', + reserved_memory: int = 4, + ): + self.output_path = output_path + self.experiment_name = experiment_name + + # read metadata defaults; overrides apply if user provided explicit values + meta = self._load_metadata() + + self.scale_data = self._coalesce_bool(scale_data, meta.get('Use Data Scaling', True)) + self.impute_data = self._coalesce_bool(impute_data, meta.get('Use Data Imputation', True)) + self.multi_impute = self._coalesce_bool(multi_impute, meta.get('Use Multivariate Imputation', False)) + self.overwrite_cv = self._coalesce_bool(overwrite_cv, True) + + self.outcome_label = outcome_label or meta.get('Outcome Label', 'Class') + self.outcome_type = outcome_type or meta.get('Outcome Type', None) + self.instance_label = instance_label if (instance_label is not None) else meta.get('Instance Label', None) + self.random_state = random_state if (random_state is not None) else meta.get('Random Seed', 0) + + # phase-2 imputer choices (metadata may contain saved prior selection) + self.imputer_id = imputer_id or meta.get('P2 Imputer Id', None) + mp = meta.get('P2 Imputer Params', '{}') + if isinstance(mp, str): + try: + mp = json.loads(mp or "{}") + except Exception: + mp = {} + self.imputer_params = imputer_params or mp or {} + self.scaler_id = (scaler_id if 'scaler_id' in locals() else None) or meta.get('P2 Scaler Id', None) + sp = meta.get('P2 Scaler Params', '{}') + if isinstance(sp, str): + try: sp = json.loads(sp or "{}") + except Exception: sp = {} + self.scaler_params = (scaler_params or {}) or sp + + self.smote = self._coalesce_bool(smote, meta.get('Use SMOTE', False)) + self.smote_method = smote_method if smote_method is not None else meta.get('P2 SMOTE Method', 'auto') + self.smote_sampling_strategy = smote_sampling_strategy if smote_sampling_strategy is not None else meta.get('P2 SMOTE Sampling Strategy', 'auto') + self.smote_k_neighbors = int(smote_k_neighbors if smote_k_neighbors is not None else meta.get('P2 SMOTE K Neighbors', 5)) + + + # execution + self.run_cluster = run_cluster + self.queue = queue + self.reserved_memory = reserved_memory + + # sanity checks + exp_root = os.path.join(self.output_path, self.experiment_name) + if not os.path.exists(exp_root): + raise Exception("Experiment must exist (from phase 1) before phase 2 can begin") + + # ---------------------------- + # Main + # ---------------------------- + def run(self): + exp_root = os.path.join(self.output_path, self.experiment_name) + + # discover datasets (folders directly under experiment root) + dataset_dirs = [] + for name in os.listdir(exp_root): + ds_dir = os.path.join(exp_root, name) + if not os.path.isdir(ds_dir): + continue + if name in {'jobsCompleted', 'jobs', 'logs', 'dask_logs', 'DatasetComparisons'}: + continue + dataset_dirs.append(ds_dir) + + # build all CV jobs (train/test pairs) + jobs: List[Tuple[str, str]] = [] + for ds_dir in dataset_dirs: + os.makedirs(os.path.join(ds_dir, 'impute_scale'), exist_ok=True) + ds_name = os.path.basename(ds_dir.rstrip('/')) + cv_dir = os.path.join(ds_dir, "CVDatasets") + if not os.path.isdir(cv_dir): + logging.warning(f"Skipping {ds_name}: no CVDatasets folder") + continue + for tr in sorted(glob.glob(os.path.join(cv_dir, f"*Train.csv"))): + te = tr.replace("Train.csv", "Test.csv") + if os.path.exists(te): + jobs.append((tr, te)) + + if not jobs: + raise Exception("No CV Train/Test CSV pairs found under experiment CVDatasets folders.") + + # ---- EXECUTION STRATEGY ---- + run_mode = str(self.run_cluster) if self.run_cluster else "Serial" + + if run_mode == "Local": + # Local Dask parallelization + n_workers = num_cores + with LocalCluster(processes=True, n_workers=n_workers, threads_per_worker=1) as cluster: + with Client(cluster) as client: + tasks = [ + dask.delayed(self._run_one_pair)(tr, te) for (tr, te) in jobs + ] + run_dask_tasks(tasks, client, label="Phase 2 Dask jobs") + + elif run_mode == "Parallel": + run_parallel_jobs(self._run_one_pair, jobs, label="Phase 2 Parallel jobs") + + elif self.run_cluster and self.run_cluster != "Serial" and self.run_cluster!= "Serial" and self.run_cluster not in ("BashSLURM", "BashLSF"): + # Modern Dask cluster (works in Jupyter) + client: Client = get_cluster( + self.run_cluster, + exp_root, + self.queue, + self.reserved_memory + ) + tasks = [ + dask.delayed(self._run_one_pair)(tr, te) for (tr, te) in jobs + ] + run_dask_tasks(tasks, client, label="Phase 2 Dask jobs") + + elif self.run_cluster in ("BashSLURM", "BashLSF"): + # Bash scripts that call p2_jobsubmit.py per CV pair + for (tr, te) in jobs: + self._submit_bash_job(tr, te) + else: + # Serial + for (tr, te) in jobs: + self._run_one_pair(tr, te) + + self.save_run_params(run_mode=run_mode) + + # ---------------------------- + # Helpers + # ---------------------------- + def _run_one_pair(self, cv_train_path: str, cv_test_path: str): + exp_root = os.path.join(self.output_path, self.experiment_name) + job = ImputeAndScale( + cv_train_path=cv_train_path, + cv_test_path=cv_test_path, + experiment_path=exp_root, + scale_data=self.scale_data, + impute_data=self.impute_data, + multi_impute=self.multi_impute, + overwrite_cv=self.overwrite_cv, + outcome_label=self.outcome_label, + outcome_type=self.outcome_type, + instance_label=self.instance_label, + random_state=self.random_state, + imputer_id=self.imputer_id, + imputer_params=self.imputer_params, + scaler_id=self.scaler_id, + scaler_params=self.scaler_params, + smote=self.smote, + smote_method=self.smote_method, + smote_sampling_strategy=self.smote_sampling_strategy, + smote_k_neighbors=self.smote_k_neighbors, + ) + job.run() + + def _load_metadata(self) -> Dict[str, Any]: + """Load metadata.pickle from the experiment root if present.""" + meta_path = os.path.join(self.output_path, self.experiment_name, "metadata.pickle") + if os.path.exists(meta_path): + with open(meta_path, "rb") as f: + try: + return pickle.load(f) or {} + except Exception: + return {} + return {} + + @staticmethod + def _coalesce_bool(v, default): + return default if (v is None) else bool(v) + + def save_run_params(self, run_mode: str): + """Append this run's parameters into a single pickle dict keyed by ISO timestamp.""" + from datetime import datetime + exp_root = os.path.join(self.output_path, self.experiment_name) + os.makedirs(exp_root, exist_ok=True) + params_file = os.path.join(exp_root, "run_params.pickle") + + this_run = { + "phase": "p2_impute_scale", + "run_mode": run_mode, + "output_path": self.output_path, + "experiment_name": self.experiment_name, + "scale_data": self.scale_data, + "impute_data": self.impute_data, + "multi_impute": self.multi_impute, + "overwrite_cv": self.overwrite_cv, + "outcome_label": self.outcome_label, + "outcome_type": self.outcome_type, + "instance_label": self.instance_label, + "random_state": self.random_state, + "imputer_id": self.imputer_id, + "imputer_params": self.imputer_params, + "scaler_id": self.scaler_id, + "scaler_params": self.scaler_params, + "smote": self.smote, + "smote_method": self.smote_method, + "smote_sampling_strategy": self.smote_sampling_strategy, + "smote_k_neighbors": self.smote_k_neighbors, + "queue": self.queue, + "reserved_memory": self.reserved_memory, + } + + if os.path.exists(params_file): + with open(params_file, "rb") as f: + try: + all_params = pickle.load(f) + except Exception: + all_params = {} + else: + all_params = {} + + ts = datetime.now().isoformat() + all_params[ts] = this_run + + with open(params_file, "wb") as f: + pickle.dump(all_params, f) + + logging.info(f"Updated run parameters in {params_file}") + + # ---------------------------- + # Bash submission (uses p2_jobsubmit.py) + # ---------------------------- + def _submit_bash_job(self, cv_train_path: str, cv_test_path: str): + job_ref = str(time.time()) + run_dir = os.path.join(self.output_path, self.experiment_name) + os.makedirs(os.path.join(run_dir, 'jobs'), exist_ok=True) + os.makedirs(os.path.join(run_dir, 'logs'), exist_ok=True) + job_name = os.path.join(run_dir, f'jobs/P2_{job_ref}_run.sh') + + if self.run_cluster == "BashSLURM": + launcher = 'sbatch' + elif self.run_cluster == "BashLSF": + launcher = 'bsub <' + else: + raise Exception("Bash submission of HPC type unsupported") + + with open(job_name, 'w') as sh: + sh.write('#!/bin/bash\n') + if self.run_cluster == "BashSLURM": + sh.write('#SBATCH -p ' + self.queue + '\n') + sh.write('#SBATCH --job-name=' + job_ref + '\n') + sh.write('#SBATCH --mem=' + str(self.reserved_memory) + 'G' + '\n') + sh.write('#SBATCH -o ' + run_dir + f'/logs/P2_{job_ref}.o\n') + sh.write('#SBATCH -e ' + run_dir + f'/logs/P2_{job_ref}.e\n') + cmd = self._bash_submit_command(cv_train_path, cv_test_path) + sh.write('srun ' + cmd + '\n') + else: + sh.write('#BSUB -q ' + self.queue + '\n') + sh.write('#BSUB -J ' + job_ref + '\n') + sh.write('#BSUB -R "rusage[mem=' + str(self.reserved_memory) + 'G]"' + '\n') + sh.write('#BSUB -M ' + str(self.reserved_memory) + 'GB' + '\n') + sh.write('#BSUB -o ' + run_dir + f'/logs/P2_{job_ref}.o\n') + sh.write('#BSUB -e ' + run_dir + f'/logs/P2_{job_ref}.e\n') + cmd = self._bash_submit_command(cv_train_path, cv_test_path) + sh.write(cmd + '\n') + + os.system(f'{launcher} {job_name}') + + def _bash_submit_command(self, cv_train_path: str, cv_test_path: str) -> str: + """ + Build command to run a single-CV-pair job via p2_jobsubmit.py (bash path). + p2_jobsubmit.py must parse args and run ImputeAndScale once. + Unspecified flags are resolved inside p2_jobsubmit.py by reading metadata.pickle. + """ + script_path = str(Path(__file__).parent / "p2_jobsubmit.py") + exp_root = os.path.join(self.output_path, self.experiment_name) + args = [ + 'python', script_path, + '--cv_train_path', cv_train_path, + '--cv_test_path', cv_test_path, + '--experiment_path', exp_root, + + # Optional overrides; these can be empty and p2_jobsubmit.py will fill from metadata + '--scale_data', str(int(self.scale_data)) if self.scale_data is not None else '', + '--impute_data', str(int(self.impute_data)) if self.impute_data is not None else '', + '--multi_impute', str(int(self.multi_impute)) if self.multi_impute is not None else '', + '--overwrite_cv', str(int(self.overwrite_cv)) if self.overwrite_cv is not None else '', + '--outcome_label', self.outcome_label or '', + '--outcome_type', self.outcome_type or '', + '--instance_label', self.instance_label or '', + '--random_state', str(self.random_state) if self.random_state is not None else '', + '--imputer_id', self.imputer_id or '', + '--imputer_params', json.dumps(self.imputer_params or {}), + '--scaler_id', self.scaler_id or '', + '--scaler_params', json.dumps(self.scaler_params or {}), + '--smote', str(int(self.smote)) if self.smote is not None else '', + '--smote_method', self.smote_method or 'auto', + '--smote_sampling_strategy', json.dumps(self.smote_sampling_strategy) if isinstance(self.smote_sampling_strategy, (dict, list)) else str(self.smote_sampling_strategy), + '--smote_k_neighbors', str(self.smote_k_neighbors), + ] + return ' '.join(args) + diff --git a/streamline/p2_impute_scale/registry/impute/iterative_imputer.py b/streamline/p2_impute_scale/registry/impute/iterative_imputer.py new file mode 100644 index 00000000..ec84720f --- /dev/null +++ b/streamline/p2_impute_scale/registry/impute/iterative_imputer.py @@ -0,0 +1,19 @@ +from __future__ import annotations +from typing import Dict, Any +import pandas as pd +from sklearn.impute import IterativeImputer +from streamline.p2_impute_scale.utils.base_impute_scale import Imputer + +class Iterative(Imputer): + id = "iterative" + def __init__(self, random_state: int = 0, max_iter: int = 30): + self.random_state = random_state + self.max_iter = max_iter + self._impl = IterativeImputer(random_state=random_state, max_iter=max_iter) + def fit(self, X: pd.DataFrame, y=None) -> "Iterative": + self._impl.fit(X); return self + def transform(self, X: pd.DataFrame) -> pd.DataFrame: + Xt = self._impl.transform(X) + return pd.DataFrame(Xt, index=X.index, columns=X.columns) + def get_params(self) -> Dict[str, Any]: + return {"random_state": self.random_state, "max_iter": self.max_iter} diff --git a/streamline/p2_impute_scale/registry/impute/knn_imputer.py b/streamline/p2_impute_scale/registry/impute/knn_imputer.py new file mode 100644 index 00000000..0d2042ff --- /dev/null +++ b/streamline/p2_impute_scale/registry/impute/knn_imputer.py @@ -0,0 +1,19 @@ +from __future__ import annotations +from typing import Dict, Any +import pandas as pd +from sklearn.impute import KNNImputer +from streamline.p2_impute_scale.utils.base_impute_scale import Imputer + +class KNN(Imputer): + id = "knn" + def __init__(self, n_neighbors: int = 5, weights: str = "uniform"): + self.n_neighbors = n_neighbors + self.weights = weights + self._impl = KNNImputer(n_neighbors=n_neighbors, weights=weights) + def fit(self, X: pd.DataFrame, y=None) -> "KNN": + self._impl.fit(X); return self + def transform(self, X: pd.DataFrame) -> pd.DataFrame: + Xt = self._impl.transform(X) + return pd.DataFrame(Xt, index=X.index, columns=X.columns) + def get_params(self) -> Dict[str, Any]: + return {"n_neighbors": self.n_neighbors, "weights": self.weights} diff --git a/streamline/p2_impute_scale/registry/impute/median_imputer.py b/streamline/p2_impute_scale/registry/impute/median_imputer.py new file mode 100644 index 00000000..7c75e9ac --- /dev/null +++ b/streamline/p2_impute_scale/registry/impute/median_imputer.py @@ -0,0 +1,37 @@ +# streamline/phases/p2_impute_scale/registry/median.py +from __future__ import annotations +from typing import Dict, Any, Optional +import pandas as pd +import numpy as np +from sklearn.impute import SimpleImputer +from streamline.p2_impute_scale.utils.base_impute_scale import Imputer + +REGISTRY: Dict[str, type] = {} + +class MedianMap(Imputer): + """ + Median-map for numeric columns (manual, dataframe-friendly). + Mirrors your reference 'median_dict' pathway for quantitative features. + """ + id = "median_map" + + def __init__(self): + self._medians: Dict[str, float] = {} + + def fit(self, X: pd.DataFrame, y=None) -> "MedianMap": + for c in X.columns: + if pd.api.types.is_numeric_dtype(X[c]): + self._medians[c] = float(X[c].median(skipna=True)) + return self + + def transform(self, X: pd.DataFrame) -> pd.DataFrame: + Xc = X.copy() + for c, v in self._medians.items(): + if c in Xc.columns: + Xc[c] = Xc[c].fillna(v) + return Xc + + def get_params(self) -> Dict[str, Any]: + return {"n_medians": len(self._medians)} + +REGISTRY[MedianMap.id] = MedianMap diff --git a/streamline/p2_impute_scale/registry/impute/simple_imputer.py b/streamline/p2_impute_scale/registry/impute/simple_imputer.py new file mode 100644 index 00000000..4b6d7a5a --- /dev/null +++ b/streamline/p2_impute_scale/registry/impute/simple_imputer.py @@ -0,0 +1,30 @@ +# streamline/phases/p2_impute_scale/registry/simple.py +from __future__ import annotations +from typing import Dict, Any, Optional +import pandas as pd +import numpy as np +from sklearn.impute import SimpleImputer +from streamline.p2_impute_scale.utils.base_impute_scale import Imputer + +class Simple(Imputer): + """ + Wrapper around sklearn's SimpleImputer. + strategy: mean | median | most_frequent | constant + """ + id = "simple" + + def __init__(self, strategy: str = "median", fill_value: Optional[float] = None): + self.strategy = strategy + self.fill_value = fill_value + self._impl = SimpleImputer(strategy=strategy, fill_value=fill_value) + + def fit(self, X: pd.DataFrame, y=None) -> "Simple": + self._impl.fit(X) + return self + + def transform(self, X: pd.DataFrame) -> pd.DataFrame: + Xt = self._impl.transform(X) + return pd.DataFrame(Xt, index=X.index, columns=X.columns) + + def get_params(self) -> Dict[str, Any]: + return {"strategy": self.strategy, "fill_value": self.fill_value} diff --git a/streamline/p2_impute_scale/registry/scale/minmax_scaler.py b/streamline/p2_impute_scale/registry/scale/minmax_scaler.py new file mode 100644 index 00000000..fd69b70f --- /dev/null +++ b/streamline/p2_impute_scale/registry/scale/minmax_scaler.py @@ -0,0 +1,23 @@ +from __future__ import annotations +from typing import Dict, Any +import pandas as pd +from sklearn.preprocessing import MinMaxScaler as _MinMax + +class MinMax: + id = "minmax" + def __init__(self, **kwargs): + self.kwargs = kwargs + self.impl = _MinMax(**kwargs) + self._cols = None + def fit(self, X: pd.DataFrame, y=None): + self._cols = X.select_dtypes(include=["number"]).columns + self.impl.fit(X[self._cols]) + return self + def transform(self, X: pd.DataFrame) -> pd.DataFrame: + if self._cols is None: + return X + Xt = X.copy() + Xt.loc[:, self._cols] = self.impl.transform(Xt[self._cols]) + return Xt + def get_params(self) -> Dict[str, Any]: + return dict(self.kwargs) diff --git a/streamline/p2_impute_scale/registry/scale/robust_scaler.py b/streamline/p2_impute_scale/registry/scale/robust_scaler.py new file mode 100644 index 00000000..88b34b2d --- /dev/null +++ b/streamline/p2_impute_scale/registry/scale/robust_scaler.py @@ -0,0 +1,23 @@ +from __future__ import annotations +from typing import Dict, Any +import pandas as pd +from sklearn.preprocessing import RobustScaler as _Robust + +class Robust: + id = "robust" + def __init__(self, **kwargs): + self.kwargs = kwargs + self.impl = _Robust(**kwargs) + self._cols = None + def fit(self, X: pd.DataFrame, y=None): + self._cols = X.select_dtypes(include=["number"]).columns + self.impl.fit(X[self._cols]) + return self + def transform(self, X: pd.DataFrame) -> pd.DataFrame: + if self._cols is None: + return X + Xt = X.copy() + Xt.loc[:, self._cols] = self.impl.transform(Xt[self._cols]) + return Xt + def get_params(self) -> Dict[str, Any]: + return dict(self.kwargs) diff --git a/streamline/p2_impute_scale/registry/scale/standard_scaler.py b/streamline/p2_impute_scale/registry/scale/standard_scaler.py new file mode 100644 index 00000000..a78ac8d3 --- /dev/null +++ b/streamline/p2_impute_scale/registry/scale/standard_scaler.py @@ -0,0 +1,23 @@ +from __future__ import annotations +from typing import Dict, Any +import pandas as pd +from sklearn.preprocessing import StandardScaler as _Standard + +class Standard: + id = "standard" + def __init__(self, **kwargs): + self.kwargs = kwargs + self.impl = _Standard(**kwargs) + self._cols = None + def fit(self, X: pd.DataFrame, y=None): + self._cols = X.select_dtypes(include=["number"]).columns + self.impl.fit(X[self._cols]) + return self + def transform(self, X: pd.DataFrame) -> pd.DataFrame: + if self._cols is None: # not fitted + return X + Xt = X.copy() + Xt.loc[:, self._cols] = self.impl.transform(Xt[self._cols]) + return Xt + def get_params(self) -> Dict[str, Any]: + return dict(self.kwargs) diff --git a/streamline/p2_impute_scale/utils/base_impute_scale.py b/streamline/p2_impute_scale/utils/base_impute_scale.py new file mode 100644 index 00000000..f8d80dcb --- /dev/null +++ b/streamline/p2_impute_scale/utils/base_impute_scale.py @@ -0,0 +1,64 @@ +# Phase 2: Imputation & Scaling — base interfaces (no typing, no shared base) + +class Imputer: + """ + Base interface for imputers. + Contract: + - fit(X, y, feature_meta) learns imputation statistics. + - transform(X) applies them without reordering columns. + """ + + def __init__(self, component_id="imputer", random_state=None, **kwargs): + self.id = component_id + self.random_state = random_state + self.params = dict(kwargs) + + # capability flags (override in subclasses or set via set_params) + self.supports_nan_in_fit = True # can learn with NaNs present + self.preserves_dtype = False # try to keep dtype if possible + + def get_params(self): + return dict(self.params) + + def set_params(self, **params): + self.params.update(params) + return self + + # --- to implement --- + def fit(self, X, y=None, feature_meta=None): + raise NotImplementedError("Imputer.fit must be implemented") + + def transform(self, X): + raise NotImplementedError("Imputer.transform must be implemented") + + +class Scaler: + """ + Base interface for scalers. + Contract: + - fit(X, y, feature_meta) learns scaling params. + - transform(X) applies them without reordering columns. + """ + + def __init__(self, component_id="scaler", random_state=None, **kwargs): + self.id = component_id + self.random_state = random_state + self.params = dict(kwargs) + + # capability flags + self.requires_dense = True # most scalers need dense inputs + self.scale_only_quantitative = True # ignore categoricals by default + + def get_params(self): + return dict(self.params) + + def set_params(self, **params): + self.params.update(params) + return self + + # --- to implement --- + def fit(self, X, y=None, feature_meta=None): + raise NotImplementedError("Scaler.fit must be implemented") + + def transform(self, X): + raise NotImplementedError("Scaler.transform must be implemented") diff --git a/streamline/p2_impute_scale/utils/impute_loader.py b/streamline/p2_impute_scale/utils/impute_loader.py new file mode 100644 index 00000000..68e819a4 --- /dev/null +++ b/streamline/p2_impute_scale/utils/impute_loader.py @@ -0,0 +1,79 @@ +from __future__ import annotations +import importlib +import inspect +import os +from pathlib import Path +from types import ModuleType +from typing import Dict, Type, Optional + +# We keep everything phase-local. +PKG_BASE = "streamline.p2_impute_scale.registry.impute" +FOLDER = Path(__file__).parent.parent / "registry" / "impute" + +# Simple cache so we only scan once per process. +__CACHE: Optional[Dict[str, Type]] = None + + +def _is_imputer_class(cls: Type) -> bool: + """ + Heuristic check: class has 'id' attr (str), and methods fit/transform/get_params. + We don't import the Protocol to avoid circular deps; duck-typing is fine here. + """ + if not inspect.isclass(cls): + return False + if not hasattr(cls, "id"): + return False + # minimal surface + return all(hasattr(cls, m) for m in ("fit", "transform", "get_params")) + + +def _iter_py_modules(): + for entry in os.listdir(FOLDER): + if not entry.endswith(".py"): + continue + if entry == "__init__.py": + continue + modname = f"{PKG_BASE}.{entry[:-3]}" + yield modname + + +def _load_module(modname: str) -> Optional[ModuleType]: + try: + return importlib.import_module(modname) + except Exception: + # Swallow import errors so one bad file doesn't stop discovery. + return None + + +def _discover() -> Dict[str, Type]: + found: Dict[str, Type] = {} + for modname in _iter_py_modules(): + mod = _load_module(modname) + if not mod: + continue + for name in dir(mod): + obj = getattr(mod, name) + if _is_imputer_class(obj): + # prefer classes defined in this module + if getattr(obj, "__module__", "").startswith(modname): + imputer_id = getattr(obj, "id", None) + if isinstance(imputer_id, str) and imputer_id: + # last-one-wins if duplicate ids; you can warn here if you like + found[imputer_id] = obj + return found + + +def list_imputers() -> Dict[str, Type]: + """Return {imputer_id: class} discovered under registry/ (cached).""" + global __CACHE + if __CACHE is None: + __CACHE = _discover() + return dict(__CACHE) + + +def load_imputer(imputer_id: str, **params): + """Instantiate an imputer by id using dynamic discovery.""" + imps = list_imputers() + if imputer_id not in imps: + raise ValueError(f"Imputer '{imputer_id}' not found. Available: {', '.join(sorted(imps))}") + return imps[imputer_id](**params) diff --git a/streamline/p2_impute_scale/utils/scale_loader.py b/streamline/p2_impute_scale/utils/scale_loader.py new file mode 100644 index 00000000..bbf24a82 --- /dev/null +++ b/streamline/p2_impute_scale/utils/scale_loader.py @@ -0,0 +1,79 @@ +from __future__ import annotations +import importlib +import inspect +import os +from pathlib import Path +from types import ModuleType +from typing import Dict, Type, Optional + +# We keep everything phase-local. +PKG_BASE = "streamline.p2_impute_scale.registry.scale" +FOLDER = Path(__file__).parent.parent / "registry" / "scale" + +# Simple cache so we only scan once per process. +__CACHE: Optional[Dict[str, Type]] = None + + +def _is_scaler_class(cls: Type) -> bool: + """ + Heuristic check: class has 'id' attr (str), and methods fit/transform/get_params. + We don't import the Protocol to avoid circular deps; duck-typing is fine here. + """ + if not inspect.isclass(cls): + return False + if not hasattr(cls, "id"): + return False + # minimal surface + return all(hasattr(cls, m) for m in ("fit", "transform", "get_params")) + + +def _iter_py_modules(): + for entry in os.listdir(FOLDER): + if not entry.endswith(".py"): + continue + if entry == "__init__.py": + continue + modname = f"{PKG_BASE}.{entry[:-3]}" + yield modname + + +def _load_module(modname: str) -> Optional[ModuleType]: + try: + return importlib.import_module(modname) + except Exception: + # Swallow import errors so one bad file doesn't stop discovery. + return None + + +def _discover() -> Dict[str, Type]: + found: Dict[str, Type] = {} + for modname in _iter_py_modules(): + mod = _load_module(modname) + if not mod: + continue + for name in dir(mod): + obj = getattr(mod, name) + if _is_scaler_class(obj): + # prefer classes defined in this module + if getattr(obj, "__module__", "").startswith(modname): + scaler_id = getattr(obj, "id", None) + if isinstance(scaler_id, str) and scaler_id: + # last-one-wins if duplicate ids; you can warn here if you like + found[scaler_id] = obj + return found + + +def list_scalers() -> Dict[str, Type]: + """Return {scaler_id: class} discovered under registry/ (cached).""" + global __CACHE + if __CACHE is None: + __CACHE = _discover() + return dict(__CACHE) + + +def load_scaler(scaler_id: str, **params): + """Instantiate an scaler by id using dynamic discovery.""" + imps = list_scalers() + if scaler_id not in imps: + raise ValueError(f"scaler '{scaler_id}' not found. Available: {', '.join(sorted(imps))}") + return imps[scaler_id](**params) diff --git a/streamline/postanalysis/__init__.py b/streamline/p3_feature_learning/__init__.py similarity index 100% rename from streamline/postanalysis/__init__.py rename to streamline/p3_feature_learning/__init__.py diff --git a/streamline/p3_feature_learning/feature_learn.py b/streamline/p3_feature_learning/feature_learn.py new file mode 100644 index 00000000..a37d4171 --- /dev/null +++ b/streamline/p3_feature_learning/feature_learn.py @@ -0,0 +1,206 @@ +# streamline/phases/p3_feature_learning/job.py +from __future__ import annotations +import os, time, json, pickle, random, logging +from typing import Optional, Dict, Any, Tuple +import numpy as np +import pandas as pd +from streamline.p3_feature_learning.utils.fl_loader import load_learner + +class FeatureLearn: + """ + Phase 3: Feature Learning (PCA only in this initial version). + Fit on TRAIN, transform TRAIN/TEST, write updated CV CSVs and artifacts. + """ + def __init__( + self, + cv_train_path: str, + cv_test_path: str, + experiment_path: str, + *, + learner_id: str = "pca", + learner_params: Dict[str, Any] | None = None, + feature_namespace: str = "FL_PCA", + keep_original_features: bool = True, + overwrite_cv: bool = True, + outcome_label: str = "Class", + instance_label: Optional[str] = None, + random_state: Optional[int] = None, + ): + self.cv_train_path = cv_train_path + self.cv_test_path = cv_test_path + self.experiment_path = experiment_path + self.learner_id = learner_id + self.learner_params = learner_params or {} + self.feature_namespace = feature_namespace + self.keep_original_features = keep_original_features + self.overwrite_cv = overwrite_cv + self.outcome_label = outcome_label + self.instance_label = instance_label + self.random_state = random_state + + self.dataset_name: Optional[str] = None + self.cv_count: Optional[str] = None + self.job_start_time = time.time() + + # ------------ main ------------ + def run(self): + random.seed(self.random_state); np.random.seed(self.random_state) + + data_train, data_test = self._load_data() + logging.info("Prepared Train and Test for: %s_CV_%s", self.dataset_name, self.cv_count) + y_train = data_train[self.outcome_label] + y_test = data_test[self.outcome_label] + + i_train = i_test = None + if self.instance_label is not None and self.instance_label in data_train.columns: + i_train = data_train[self.instance_label] + i_test = data_test[self.instance_label] + + # X = features-only + drop_cols = [self.outcome_label] + ([self.instance_label] if self.instance_label in data_train.columns else []) + X_train = data_train.drop(columns=drop_cols, errors="ignore") + X_test = data_test.drop(columns=drop_cols, errors="ignore") + + # Fit PCA on TRAIN (numeric-only inside learner) + logging.info("Running Feature Learning (%s)...", self.learner_id) + learner = load_learner(self.learner_id, random_state=self.random_state, **self.learner_params) + learner.fit(X_train) + Z_train = learner.transform(X_train) + Z_test = learner.transform(X_test) + pc_added = int(Z_train.shape[1]) + pca_impl = getattr(learner, "_impl", None) + evr = getattr(pca_impl, "explained_variance_ratio_", None) + if evr is not None and len(evr) > 0: + logging.info( + "Principal components added: %d (cumulative explained variance: %.3f)", + pc_added, + float(np.sum(evr)), + ) + else: + logging.info("Principal components added: %d", pc_added) + + # Name engineered columns + # if PCA decided n_components at fit-time, use that + out_cols = learner.get_feature_names(X_train.columns.tolist(), self.feature_namespace) + if len(out_cols) != Z_train.shape[1]: # guard in case automatic n_components used + out_cols = [f"{self.feature_namespace}_PC{i+1}"] * 0 + [f"{self.feature_namespace}_PC{i+1}" for i in range(Z_train.shape[1])] + Z_train.columns = out_cols + Z_test.columns = out_cols + + # Concatenate with original features or replace + if self.keep_original_features: + X_train_out = pd.concat([X_train.reset_index(drop=True), Z_train.reset_index(drop=True)], axis=1) + X_test_out = pd.concat([X_test.reset_index(drop=True), Z_test.reset_index(drop=True)], axis=1) + else: + X_train_out, X_test_out = Z_train, Z_test + + # Reassemble + if self.instance_label is None or self.instance_label not in data_train.columns: + train_out = pd.concat([y_train.reset_index(drop=True), X_train_out], axis=1) + test_out = pd.concat([y_test.reset_index(drop=True), X_test_out], axis=1) + else: + train_out = pd.concat([y_train.reset_index(drop=True), i_train.reset_index(drop=True), X_train_out], axis=1) + test_out = pd.concat([y_test.reset_index(drop=True), i_test.reset_index(drop=True), X_test_out], axis=1) + + # Write + self._write_cv_files(train_out, test_out) + self._write_artifacts( + learner, + out_cols, + X_train.columns.tolist(), + X_train.shape[1], + Z_train.shape[1], + train_out.shape, + test_out.shape, + ) + final_feature_count = int(train_out.shape[1] - 1 if self.instance_label is None else train_out.shape[1] - 2) + logging.info( + "Feature learning summary for %s_CV_%s: input=%d, PCs=%d, keep_original=%s, final_features=%d, train_shape=%s, test_shape=%s", + self.dataset_name, + self.cv_count, + int(X_train.shape[1]), + pc_added, + bool(self.keep_original_features), + final_feature_count, + tuple(train_out.shape), + tuple(test_out.shape), + ) + self._save_runtime() + self._complete_flag() + logging.info( + "%s CV%s phase 3 %s evaluation complete", + self.dataset_name, + self.cv_count, + self.learner_id, + ) + + # ------------ helpers ------------ + def _load_data(self) -> Tuple[pd.DataFrame, pd.DataFrame]: + self.dataset_name = self.cv_train_path.split('/')[-3] + self.cv_count = self.cv_train_path.split('/')[-1].split("_")[-2] + logging.info("-------------------------------------------------------") + logging.info("Loading Dataset: %s_CV_%s_Train", self.dataset_name, self.cv_count) + tr = pd.read_csv(self.cv_train_path, na_values='NA', sep=',') + te = pd.read_csv(self.cv_test_path, na_values='NA', sep=',') + return tr, te + + def _write_cv_files(self, data_train: pd.DataFrame, data_test: pd.DataFrame): + if self.overwrite_cv: + os.remove(self.cv_train_path); os.remove(self.cv_test_path) + else: + cvdir = os.path.join(self.experiment_path, self.dataset_name, "CVDatasets") + os.rename(self.cv_train_path, os.path.join(cvdir, f"{self.dataset_name}_CVOnly_{self.cv_count}_Train.csv")) + os.rename(self.cv_test_path, os.path.join(cvdir, f"{self.dataset_name}_CVOnly_{self.cv_count}_Test.csv")) + data_train.to_csv(self.cv_train_path, index=False) + data_test.to_csv(self.cv_test_path, index=False) + + def _write_artifacts(self, learner, out_cols, input_cols, in_feat_count, eng_feat_count, train_shape, test_shape): + base = os.path.join(self.experiment_path, self.dataset_name, "feature_learning") + os.makedirs(base, exist_ok=True) + + # Save learner as id+params (registry flavor) + with open(os.path.join(base, f"learner_cv{self.cv_count}.pickle"), "wb") as f: + pickle.dump({"id": self.learner_id, "params": learner.get_params()}, f) + with open(os.path.join(base, f"fitted_learner_cv{self.cv_count}.pickle"), "wb") as f: + pickle.dump(learner, f) + + # Feature names + with open(os.path.join(base, f"features_cv{self.cv_count}.txt"), "w") as f: + f.write("\n".join(out_cols)) + with open(os.path.join(base, f"input_features_cv{self.cv_count}.txt"), "w") as f: + f.write("\n".join(input_cols)) + + manifest = { + "dataset": self.dataset_name, + "cv": int(self.cv_count), + "namespace": self.feature_namespace, + "keep_original_features": bool(self.keep_original_features), + "learner": {"id": self.learner_id, "params": learner.get_params()}, + "input_features": list(input_cols), + "output_features": list(out_cols), + "input_feature_count": int(in_feat_count), + "engineered_feature_count": int(eng_feat_count), + "principal_components_added": int(eng_feat_count), + "final_feature_count": int(train_shape[1] - 1 if self.instance_label is None else train_shape[1] - 2), + "train_shape": list(train_shape), + "test_shape": list(test_shape), + "random_state": self.random_state, + } + pca_impl = getattr(learner, "_impl", None) + evr = getattr(pca_impl, "explained_variance_ratio_", None) + if evr is not None: + manifest["pca_explained_variance_ratio_sum"] = float(np.sum(evr)) + with open(os.path.join(base, f"feature_manifest_cv{self.cv_count}.json"), "w") as f: + json.dump(manifest, f, indent=2) + + def _save_runtime(self): + rt_dir = os.path.join(self.experiment_path, self.dataset_name, 'runtime') + os.makedirs(rt_dir, exist_ok=True) + with open(os.path.join(rt_dir, f"runtime_feature_learning{self.cv_count}.txt"), "w+") as f: + f.write(str(time.time() - self.job_start_time)) + + def _complete_flag(self): + jobs_dir = os.path.join(self.experiment_path, "jobsCompleted") + os.makedirs(jobs_dir, exist_ok=True) + with open(os.path.join(jobs_dir, f"job_feature_learning_{self.dataset_name}_{self.cv_count}.txt"), "w") as f: + f.write("complete") diff --git a/streamline/p3_feature_learning/p3_cli.py b/streamline/p3_feature_learning/p3_cli.py new file mode 100644 index 00000000..1aa1f0e3 --- /dev/null +++ b/streamline/p3_feature_learning/p3_cli.py @@ -0,0 +1,82 @@ +# streamline/phases/p3_feature_learning/cli.py +import argparse, json +from streamline.p3_feature_learning.p3_runner import P3Runner +from streamline.p3_feature_learning.utils.fl_loader import list_learners +from streamline.utils.run_commands import ( + add_run_command_args, + apply_saved_run_command, + save_run_command_from_args, + snapshot_args, +) + +def _maybe_json(s: str): + try: return json.loads(s or "{}") + except Exception: return {} + +def _maybe_bool(s, default=None): + if s is None: return default + v = str(s).lower() + if v in ("1","true","t","yes","y"): return True + if v in ("0","false","f","no","n"): return False + return default + +def main(): + ap = argparse.ArgumentParser("STREAMLINE Phase 3 (PCA) CLI", + formatter_class=argparse.ArgumentDefaultsHelpFormatter) + ap.add_argument("--output_path", required=True) + ap.add_argument("--experiment_name", required=True) + + ap.add_argument("--learner_id", default=None) + ap.add_argument("--learner_params", default=None) + ap.add_argument("--feature_namespace", default=None) + ap.add_argument("--keep_original_features", default=None) + ap.add_argument("--overwrite_cv", default=None) + ap.add_argument("--outcome_label", default=None) + ap.add_argument("--instance_label", default=None) + ap.add_argument("--random_state", default=None, type=int) + + ap.add_argument("--run_cluster", default="Serial", + help="Serial | Local | Parallel | BashSLURM | BashLSF | ") + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", default=4, type=int) + + ap.add_argument("--list-learners", action="store_true") + add_run_command_args(ap) + + args = ap.parse_args() + args = apply_saved_run_command(ap, args, "p3_feature_learning") + run_command_args = snapshot_args(args) + + if args.list_learners: + learners = list_learners() + print("Available learners:") + for k, cls in sorted(learners.items()): + print(f" {k:10s} -> {cls.__module__}.{cls.__name__}") + return + + runner = P3Runner( + output_path=args.output_path, + experiment_name=args.experiment_name, + learner_id=args.learner_id, + learner_params=_maybe_json(args.learner_params) if args.learner_params else None, + feature_namespace=args.feature_namespace, + keep_original_features=_maybe_bool(args.keep_original_features), + overwrite_cv=_maybe_bool(args.overwrite_cv), + outcome_label=args.outcome_label, + instance_label=args.instance_label, + random_state=args.random_state, + run_cluster=args.run_cluster if args.run_cluster not in (None, "Serial", "False", "false") else False, + queue=args.queue, + reserved_memory=args.reserved_memory, + ) + runner.run() + save_run_command_from_args(args, "p3_feature_learning", run_command_args, runner=runner) + +if __name__ == "__main__": + main() + + + # # Serial run (use defaults from metadata.pickle) + # python -m streamline.p3_feature_learning.p3_cli \ + # --output_path ./test \ + # --experiment_name MyExp diff --git a/streamline/p3_feature_learning/p3_jobsubmit.py b/streamline/p3_feature_learning/p3_jobsubmit.py new file mode 100644 index 00000000..899dba07 --- /dev/null +++ b/streamline/p3_feature_learning/p3_jobsubmit.py @@ -0,0 +1,42 @@ +# streamline/phases/p3_feature_learning/p3_jobsubmit.py +import argparse, json, os, pickle +from streamline.p3_feature_learning.feature_learn import FeatureLearn + +def _maybe_json(s: str): + try: return json.loads(s or "{}") + except Exception: return {} + +def main(): + ap = argparse.ArgumentParser("P3 single-CV-pair jobsubmit") + ap.add_argument("--cv_train_path", required=True) + ap.add_argument("--cv_test_path", required=True) + ap.add_argument("--experiment_path", required=True) + + ap.add_argument("--learner_id", default="pca") + ap.add_argument("--learner_params", default="{}") + ap.add_argument("--feature_namespace", default="FL_PCA") + ap.add_argument("--keep_original_features", default="1") + ap.add_argument("--overwrite_cv", default="1") + ap.add_argument("--outcome_label", default="Class") + ap.add_argument("--instance_label", default=None) + ap.add_argument("--random_state", default=None) + + args = ap.parse_args() + + job = FeatureLearn( + cv_train_path=args.cv_train_path, + cv_test_path=args.cv_test_path, + experiment_path=args.experiment_path, + learner_id=args.learner_id or "pca", + learner_params=_maybe_json(args.learner_params), + feature_namespace=args.feature_namespace, + keep_original_features=(str(args.keep_original_features).strip() not in ("0","false","False")), + overwrite_cv=(str(args.overwrite_cv).strip() not in ("0","false","False")), + outcome_label=args.outcome_label or "Class", + instance_label=(None if args.instance_label in (None,"") else args.instance_label), + random_state=(None if args.random_state in (None,"") else int(args.random_state)), + ) + job.run() + +if __name__ == "__main__": + main() diff --git a/streamline/p3_feature_learning/p3_runner.py b/streamline/p3_feature_learning/p3_runner.py new file mode 100644 index 00000000..02996a83 --- /dev/null +++ b/streamline/p3_feature_learning/p3_runner.py @@ -0,0 +1,206 @@ +# streamline/phases/p3_feature_learning/runner.py +import os, glob, json, time, pickle, logging +from pathlib import Path +from typing import Dict, Any, List, Tuple + +import dask +from dask.distributed import Client, LocalCluster + +from streamline.utils.runners import num_cores, run_dask_tasks, run_parallel_jobs +from streamline.utils.cluster import get_cluster +from streamline.p3_feature_learning.feature_learn import FeatureLearn +from streamline.p3_feature_learning.utils.fl_loader import list_learners + +class P3Runner: + def __init__( + self, + output_path: str, + experiment_name: str, + *, + learner_id: "str | None" = None, + learner_params: "Dict[str, Any] | None" = None, + feature_namespace: "str | None" = None, + keep_original_features: "bool | None" = None, + overwrite_cv: "bool | None" = None, + outcome_label: "str | None" = None, + instance_label: "str | None" = None, + random_state: "int | None" = None, + run_cluster: "str | bool" = False, # False | Local | Parallel | BashSLURM | BashLSF | "" + queue: str = "defq", + reserved_memory: int = 4, + ): + self.output_path = output_path + self.experiment_name = experiment_name + self.run_cluster = run_cluster + self.queue = queue + self.reserved_memory = reserved_memory + + meta = self._load_metadata() + self.learner_id = learner_id or meta.get("P3 Learner Id", "pca") + self.learner_params = learner_params or json.loads(meta.get("P3 Learner Params", "{}") or "{}") + self.feature_namespace = feature_namespace or meta.get("P3 Feature Namespace", "FL_PCA") + self.keep_original_features = bool(keep_original_features if keep_original_features is not None else meta.get("P3 Keep Original Features", True)) + self.overwrite_cv = bool(overwrite_cv if overwrite_cv is not None else True) + self.outcome_label = outcome_label or meta.get("Outcome Label", "Class") + self.instance_label = instance_label if instance_label is not None else meta.get("Instance Label", None) + self.random_state = random_state if random_state is not None else meta.get("Random Seed", 0) + + exp_root = os.path.join(self.output_path, self.experiment_name) + if not os.path.exists(exp_root): + raise Exception("Experiment must exist (from previous phases) before phase 3 can begin") + + # ---- main ---- + def run(self): + exp_root = os.path.join(self.output_path, self.experiment_name) + jobs: List[Tuple[str, str]] = [] + logging.info( + "Phase 3 starting for experiment '%s' with learner '%s' and namespace '%s'.", + self.experiment_name, + self.learner_id, + self.feature_namespace, + ) + dataset_names = set() + + # discover CV pairs + for name in os.listdir(exp_root): + ds_dir = os.path.join(exp_root, name) + if not os.path.isdir(ds_dir): continue + if name in {"jobsCompleted", "jobs", "logs", "dask_logs", "DatasetComparisons"}: continue + os.makedirs(os.path.join(ds_dir, "feature_learning"), exist_ok=True) + for tr in sorted(glob.glob(os.path.join(ds_dir, "CVDatasets/*Train.csv"))): + te = tr.replace("Train.csv", "Test.csv") + if os.path.exists(te): + jobs.append((tr, te)) + dataset_names.add(name) + if not jobs: raise Exception("No CV Train/Test CSV pairs found for Phase 3.") + logging.info( + "Phase 3 discovered %d CV train/test pairs across %d dataset(s): %s", + len(jobs), + len(dataset_names), + ", ".join(sorted(dataset_names)), + ) + + mode = str(self.run_cluster) if self.run_cluster else "Serial" + logging.info("Phase 3 submitting %d jobs in mode '%s'.", len(jobs), mode) + if mode == "Local": + with LocalCluster(processes=True, n_workers=num_cores, threads_per_worker=1) as cluster: + with Client(cluster) as client: + tasks = [dask.delayed(self._run_one)(tr, te) for tr, te in jobs] + run_dask_tasks(tasks, client, label="Phase 3 Dask jobs") + elif mode == "Parallel": + run_parallel_jobs(self._run_one, jobs, label="Phase 3 Parallel jobs") + elif self.run_cluster and self.run_cluster != "Serial" and self.run_cluster not in ("BashSLURM", "BashLSF"): + client: Client = get_cluster(self.run_cluster, exp_root, self.queue, self.reserved_memory) + tasks = [dask.delayed(self._run_one)(tr, te) for tr, te in jobs] + run_dask_tasks(tasks, client, label="Phase 3 Dask jobs") + elif self.run_cluster in ("BashSLURM", "BashLSF"): + for tr, te in jobs: self._submit_bash_job(tr, te) + else: + for tr, te in jobs: self._run_one(tr, te) + + self._save_run_params(mode) + logging.info("Phase 3 completed: %d jobs finished.", len(jobs)) + + # ---- helpers ---- + def _run_one(self, tr: str, te: str): + exp_root = os.path.join(self.output_path, self.experiment_name) + FeatureLearn( + cv_train_path=tr, + cv_test_path=te, + experiment_path=exp_root, + learner_id=self.learner_id, + learner_params=self.learner_params, + feature_namespace=self.feature_namespace, + keep_original_features=self.keep_original_features, + overwrite_cv=self.overwrite_cv, + outcome_label=self.outcome_label, + instance_label=self.instance_label, + random_state=self.random_state, + ).run() + + def _load_metadata(self): + path = os.path.join(self.output_path, self.experiment_name, "metadata.pickle") + if os.path.exists(path): + with open(path, "rb") as f: + try: return pickle.load(f) or {} + except Exception: return {} + return {} + + def _save_run_params(self, mode: str): + from datetime import datetime + exp_root = os.path.join(self.output_path, self.experiment_name) + params_file = os.path.join(exp_root, "run_params.pickle") + this_run = { + "phase": "p3_feature_learning", + "run_mode": mode, + "learner_id": self.learner_id, + "learner_params": self.learner_params, + "feature_namespace": self.feature_namespace, + "keep_original_features": self.keep_original_features, + "overwrite_cv": self.overwrite_cv, + "outcome_label": self.outcome_label, + "instance_label": self.instance_label, + "random_state": self.random_state, + } + all_params = {} + if os.path.exists(params_file): + with open(params_file, "rb") as f: + try: all_params = pickle.load(f) + except Exception: all_params = {} + all_params[datetime.now().isoformat()] = this_run + with open(params_file, "wb") as f: pickle.dump(all_params, f) + + # ---- bash submit ---- + def _submit_bash_job(self, cv_train_path: str, cv_test_path: str): + job_ref = str(time.time()) + run_dir = os.path.join(self.output_path, self.experiment_name) + os.makedirs(os.path.join(run_dir, "jobs"), exist_ok=True) + os.makedirs(os.path.join(run_dir, "logs"), exist_ok=True) + job_name = os.path.join(run_dir, f"jobs/P3_{job_ref}_run.sh") + + if self.run_cluster == "BashSLURM": + launcher = "sbatch" + else: + launcher = "bsub <" + + with open(job_name, "w") as sh: + sh.write("#!/bin/bash\n") + if self.run_cluster == "BashSLURM": + sh.write(f"#SBATCH -p {self.queue}\n") + sh.write(f"#SBATCH --job-name={job_ref}\n") + sh.write(f"#SBATCH --mem={self.reserved_memory}G\n") + sh.write(f"#SBATCH -o {run_dir}/logs/P3_{job_ref}.o\n") + sh.write(f"#SBATCH -e {run_dir}/logs/P3_{job_ref}.e\n") + cmd = self._bash_submit_command(cv_train_path, cv_test_path) + sh.write("srun " + cmd + "\n") + else: + sh.write(f"#BSUB -q {self.queue}\n") + sh.write(f"#BSUB -J {job_ref}\n") + sh.write(f"#BSUB -R \"rusage[mem={self.reserved_memory}G]\"\n") + sh.write(f"#BSUB -M {self.reserved_memory}GB\n") + sh.write(f"#BSUB -o {run_dir}/logs/P3_{job_ref}.o\n") + sh.write(f"#BSUB -e {run_dir}/logs/P3_{job_ref}.e\n") + cmd = self._bash_submit_command(cv_train_path, cv_test_path) + sh.write(cmd + "\n") + + os.system(f"{launcher} {job_name}") + logging.info("Phase 3 submitted cluster job script: %s", job_name) + + def _bash_submit_command(self, tr: str, te: str) -> str: + script_path = str(Path(__file__).parent / "p3_jobsubmit.py") + exp_root = os.path.join(self.output_path, self.experiment_name) + args = [ + "python", script_path, + "--cv_train_path", tr, + "--cv_test_path", te, + "--experiment_path", exp_root, + "--learner_id", self.learner_id or "pca", + "--learner_params", json.dumps(self.learner_params or {}), + "--feature_namespace", self.feature_namespace, + "--keep_original_features", str(int(self.keep_original_features)), + "--overwrite_cv", str(int(self.overwrite_cv)), + "--outcome_label", self.outcome_label or "", + "--instance_label", self.instance_label or "", + "--random_state", str(self.random_state) if self.random_state is not None else "", + ] + return " ".join(args) diff --git a/streamline/p3_feature_learning/registry/pca_learner.py b/streamline/p3_feature_learning/registry/pca_learner.py new file mode 100644 index 00000000..fa0e5402 --- /dev/null +++ b/streamline/p3_feature_learning/registry/pca_learner.py @@ -0,0 +1,46 @@ +# streamline/phases/p3_feature_learning/learners/pca.py +from __future__ import annotations +from typing import Dict, Any, List, Optional +import pandas as pd +from sklearn.decomposition import PCA + +class PCALearner: + id = "pca" + def __init__(self, n_components: int | float | None = None, random_state: Optional[int] = None, **kwargs): + self.n_components = n_components + self.random_state = random_state + self.kwargs = kwargs + self._cols: Optional[pd.Index] = None + self._impl: Optional[PCA] = None + + def fit(self, X: pd.DataFrame, y=None) -> "PCALearner": + # numeric-only by default + self._cols = X.select_dtypes(include=["number"]).columns + self._impl = PCA(n_components=self.n_components, random_state=self.random_state, **self.kwargs) + self._impl.fit(X[self._cols]) + return self + + def transform(self, X: pd.DataFrame) -> pd.DataFrame: + if self._impl is None or self._cols is None: + raise RuntimeError("PCALearner must be fit before transform.") + Xt = self._impl.transform(X[self._cols]) + # column names filled by job using get_feature_names (needs n_components) + return pd.DataFrame(Xt, index=X.index) + + def get_feature_names(self, input_cols: List[str], namespace: str) -> List[str]: + # Determine output dimensionality + if self._impl is None: + # fallback on n_components; if None, PCA would infer min(n_samples,n_features) + # the job will re-name using transformed shape + if isinstance(self.n_components, int) and self.n_components > 0: + out = self.n_components + else: + out = len(input_cols) + else: + out = self._impl.n_components_ + return [f"{namespace}_PC{i+1}" for i in range(out)] + + def get_params(self) -> Dict[str, Any]: + p = {"n_components": self.n_components, "random_state": self.random_state} + p.update(self.kwargs or {}) + return p diff --git a/streamline/p3_feature_learning/utils/base_feature_learning.py b/streamline/p3_feature_learning/utils/base_feature_learning.py new file mode 100644 index 00000000..238cf4f9 --- /dev/null +++ b/streamline/p3_feature_learning/utils/base_feature_learning.py @@ -0,0 +1,58 @@ +# Phase 3: Feature Learning — base interface (no typing, flags on self) + +class FeatureLearner(object): + """ + Base interface for optional feature learning / transformation steps. + Examples: PCA/ICA/NMF, polynomial features, random features, FIBERS, etc. + + Contract: + - fit(X, y, feature_meta) learns transform parameters. + - transform(X) applies them; must preserve row order. + - get_feature_names_out(input_features) returns names for output columns. + - get_parent_map(output_features) maps produced features -> source columns. + """ + + def __init__(self, component_id="feature_learner", random_state=None, **kwargs): + # identifiers & params + self.id = component_id + self.random_state = random_state + self.params = dict(kwargs) + + # capability flags (override in subclasses or via set_params) + self.needs_quantitative = False # True if input must be numeric-only + self.is_supervised = False # True if y is required during fit + self.produces_sparse = False # True if transform returns sparse + + # ---------- lifecycle ---------- + def get_params(self): + return dict(self.params) + + def set_params(self, **params): + self.params.update(params) + return self + + # ---------- fit/transform ---------- + def fit(self, X, y=None, feature_meta=None): + raise NotImplementedError("FeatureLearner.fit must be implemented") + + def transform(self, X): + raise NotImplementedError("FeatureLearner.transform must be implemented") + + def fit_transform(self, X, y=None, feature_meta=None): + self.fit(X, y, feature_meta) + return self.transform(X) + + # ---------- names & lineage ---------- + def get_feature_names_out(self, input_features): + """ + Return names for columns produced by transform(). + Default: identity (no change). + """ + return list(input_features) + + def get_parent_map(self, output_features): + """ + Map each produced feature -> list of parent input feature names. + Default: identity mapping. + """ + return dict((name, [name]) for name in output_features) diff --git a/streamline/p3_feature_learning/utils/fl_loader.py b/streamline/p3_feature_learning/utils/fl_loader.py new file mode 100644 index 00000000..8fd79a41 --- /dev/null +++ b/streamline/p3_feature_learning/utils/fl_loader.py @@ -0,0 +1,48 @@ +# streamline/phases/p3_feature_learning/loader.py +from __future__ import annotations +import importlib, inspect, os +from pathlib import Path +from types import ModuleType +from typing import Dict, Type, Optional + +PKG_BASE = "streamline.p3_feature_learning.registry" +FOLDER = Path(__file__).parent.parent / "registry" +__CACHE: Optional[Dict[str, Type]] = None + +def _is_learner_class(cls: Type) -> bool: + if not inspect.isclass(cls): return False + if not hasattr(cls, "id"): return False + return all(hasattr(cls, m) for m in ("fit", "transform", "get_feature_names", "get_params")) + +def _iter_py_modules(): + for entry in os.listdir(FOLDER): + if entry.endswith(".py") and entry != "__init__.py": + yield f"{PKG_BASE}.{entry[:-3]}" + +def _load_module(modname: str) -> Optional[ModuleType]: + try: return importlib.import_module(modname) + except Exception: return None + +def _discover() -> Dict[str, Type]: + found: Dict[str, Type] = {} + for modname in _iter_py_modules(): + mod = _load_module(modname) + if not mod: continue + for name in dir(mod): + obj = getattr(mod, name) + if _is_learner_class(obj) and getattr(obj, "__module__", "").startswith(modname): + lid = getattr(obj, "id", None) + if isinstance(lid, str) and lid: + found[lid] = obj + return found + +def list_learners() -> Dict[str, Type]: + global __CACHE + if __CACHE is None: __CACHE = _discover() + return dict(__CACHE) + +def load_learner(learner_id: str, **params): + learners = list_learners() + if learner_id not in learners: + raise ValueError(f"Learner '{learner_id}' not found. Available: {', '.join(sorted(learners))}") + return learners[learner_id](**params) diff --git a/streamline/runners/__init__.py b/streamline/p4_feature_importance/__init__.py similarity index 100% rename from streamline/runners/__init__.py rename to streamline/p4_feature_importance/__init__.py diff --git a/streamline/p4_feature_importance/importance.py b/streamline/p4_feature_importance/importance.py new file mode 100644 index 00000000..6d0e1f50 --- /dev/null +++ b/streamline/p4_feature_importance/importance.py @@ -0,0 +1,322 @@ +# streamline/p4_feature_importance/importance.py +from __future__ import annotations +import os, time, json, pickle, random, logging +from typing import Optional, Dict, Any, Tuple, List +import numpy as np +import pandas as pd +from streamline.p4_feature_importance.utils.fi_loader import ( + load_importance, + normalize_importance_key, + resolve_importance_id, +) + +REBATE_MODEL_IDS = {"multisurf", "multisurfstar", "multiswrfdb", "multiswrfdbstar"} +OUTCOME_TYPE_TO_REBATE_LABEL = { + "binary": "binary", + "multiclass": "multiclass", + "continuous": "continuous", + "regression": "continuous", +} + +class FeatureImportance: + """ + Run a single feature-importance model on one CV pair. + Saves: + - feature_importance//_scores_cv_.csv + - feature_importance//selector_cv.pickle ({id, params}) + - jobsCompleted flag + Optionally writes model-specific selected CV copies if top_k/threshold supplied. + """ + def __init__( + self, + cv_train_path: str, + cv_test_path: str, + experiment_path: str, + *, + model_id: str, + model_params: Dict[str, Any] | None = None, + top_k: "int | None" = None, + threshold: "float | None" = None, + keep_original_features: bool = False, + overwrite_cv: bool = True, + outcome_label: str = "Class", + outcome_type: Optional[str] = None, # for MI + instance_label: Optional[str] = None, + random_state: Optional[int] = None, + instance_subset: int | None = None, + ): + self.cv_train_path = cv_train_path + self.cv_test_path = cv_test_path + self.experiment_path = experiment_path + self.model_id = model_id + self.model_params = model_params or {} + self.top_k = top_k + self.threshold = threshold + self.keep_original_features = keep_original_features + self.overwrite_cv = overwrite_cv + self.outcome_label = outcome_label + self.outcome_type = outcome_type + self.instance_label = instance_label + self.random_state = random_state + self.instance_subset = int(instance_subset) if instance_subset not in (None, "") else None + + self.dataset_name: Optional[str] = None + self.cv_count: Optional[str] = None + self.job_start_time = time.time() + + def run(self): + random.seed(self.random_state); np.random.seed(self.random_state) + tr, te = self._load_data() + logging.info("Prepared Train and Test for: %s_CV_%s", self.dataset_name, self.cv_count) + + y_tr = tr[self.outcome_label]; y_te = te[self.outcome_label] + if self.instance_label and self.instance_label in tr.columns: + inst_tr = tr[self.instance_label]; inst_te = te[self.instance_label] + else: + inst_tr = inst_te = None + + drop_cols = [self.outcome_label] + ([self.instance_label] if self.instance_label in tr.columns else []) + Xtr = tr.drop(columns=drop_cols, errors="ignore") + Xte = te.drop(columns=drop_cols, errors="ignore") + + params = dict(self.model_params) + rebate_categorical_names: List[str] = [] + rebate_categorical_indices: List[int] = [] + if self.model_id == "mutualinformation" and self.outcome_type and "outcome_type" not in params: + params["outcome_type"] = self.outcome_type + if self.is_rebate_model(self.model_id): + params, rebate_categorical_names, rebate_categorical_indices = self.configure_rebate_params( + params, + list(Xtr.columns), + ) + + logging.info("Running %s...", self.model_id) + model = load_importance(self.model_id, **params) + X_fit, y_fit = self.sample_instances_for_model(model, Xtr, y_tr) + model.fit(X_fit, y_fit) + + # write scores CSV for this model + logging.info("Sort and pickle feature importance scores...") + self._write_scores_csv(model, Xtr.columns) + + # save params artifact + base = self._model_dir(model) + selector_payload = { + "id": getattr(model, "id", self.model_id), + "params": model.get_params(), + "model_name": getattr(model, "model_name", self.model_id), + "small_name": getattr(model, "small_name", self.model_id), + "instance_subset": self.instance_subset, + "instances_fit": int(len(X_fit)), + } + if self.is_rebate_model(self.model_id): + selector_payload["categorical_features"] = rebate_categorical_names + selector_payload["categorical_feature_indices"] = rebate_categorical_indices + with open(os.path.join(base, f"selector_cv{self.cv_count}.pickle"), "wb") as f: + pickle.dump(selector_payload, f) + + if self.top_k is not None or self.threshold is not None: + Xtr_sel = model.transform(Xtr, top_k=self.top_k, threshold=self.threshold) + Xte_sel = Xte.loc[:, Xtr_sel.columns] + if self.keep_original_features: + Xtr_out = pd.concat([Xtr.reset_index(drop=True), Xtr_sel.reset_index(drop=True)], axis=1) + Xte_out = pd.concat([Xte.reset_index(drop=True), Xte_sel.reset_index(drop=True)], axis=1) + else: + Xtr_out, Xte_out = Xtr_sel, Xte_sel + + if inst_tr is None: + train_out = pd.concat([y_tr.reset_index(drop=True), Xtr_out], axis=1) + test_out = pd.concat([y_te.reset_index(drop=True), Xte_out], axis=1) + else: + train_out = pd.concat([y_tr.reset_index(drop=True), inst_tr.reset_index(drop=True), Xtr_out], axis=1) + test_out = pd.concat([y_te.reset_index(drop=True), inst_te.reset_index(drop=True), Xte_out], axis=1) + + self._write_selected_cv_files(model, train_out, test_out) + + self._save_runtime(model) + self._complete_flag(model) + logging.info( + "%s CV%s phase 4 %s evaluation complete", + self.dataset_name, + self.cv_count, + self.model_id, + ) + + # ---- helpers ---- + def _load_data(self) -> Tuple[pd.DataFrame, pd.DataFrame]: + self.dataset_name = self.cv_train_path.split('/')[-3] + self.cv_count = self.cv_train_path.split('/')[-1].split("_")[-2] + logging.info("-------------------------------------------------------") + logging.info("Loading Dataset: %s_CV_%s_Train", self.dataset_name, self.cv_count) + tr = pd.read_csv(self.cv_train_path, na_values='NA', sep=',') + te = pd.read_csv(self.cv_test_path, na_values='NA', sep=',') + return tr, te + + @staticmethod + def is_rebate_model(model_id: str) -> bool: + resolved = resolve_importance_id(model_id) or model_id + return resolved in REBATE_MODEL_IDS or normalize_importance_key(model_id) in { + "multisurf", + "multisurfstar", + "multiswrfdb", + "multiswrfdbstar", + } + + def load_categorical_feature_names(self) -> List[str]: + path = os.path.join( + self.experiment_path, + self.dataset_name, + "exploratory", + "categorical_features.pickle", + ) + if not os.path.exists(path): + logging.warning( + "STREAMLINE categorical feature list not found at %s; passing an empty " + "categorical_features list to %s.", + path, + self.model_id, + ) + return [] + try: + with open(path, "rb") as f: + values = pickle.load(f) or [] + except Exception as e: + logging.warning( + "Could not read STREAMLINE categorical feature list at %s (%s); passing " + "an empty categorical_features list to %s.", + path, + e, + self.model_id, + ) + return [] + return [str(v) for v in values if str(v).strip()] + + def categorical_feature_indices(self, feature_columns: List[str]) -> Tuple[List[str], List[int]]: + categorical_names = self.load_categorical_feature_names() + categorical_set = set(categorical_names) + indices = [idx for idx, col in enumerate(feature_columns) if col in categorical_set] + kept_names = [feature_columns[idx] for idx in indices] + logging.info( + "Phase 4 %s passing %d STREAMLINE categorical feature index(es) to ReBATE.", + self.model_id, + len(indices), + ) + return kept_names, indices + + def rebate_label_type(self) -> Optional[str]: + if not self.outcome_type: + return None + return OUTCOME_TYPE_TO_REBATE_LABEL.get(str(self.outcome_type).strip().lower()) + + def configure_rebate_params(self, params: Dict[str, Any], feature_columns: List[str]): + params = dict(params) + categorical_names, categorical_indices = self.categorical_feature_indices(feature_columns) + if "categorical_features" in params and list(params.get("categorical_features") or []) != categorical_indices: + logging.warning( + "Ignoring user-supplied categorical_features for %s; using STREAMLINE's " + "categorical_features.pickle list.", + self.model_id, + ) + params["categorical_features"] = categorical_indices + label_type = self.rebate_label_type() + if label_type and "label_type" not in params: + params["label_type"] = label_type + return params, categorical_names, categorical_indices + + @staticmethod + def uses_instance_subset(model, model_id: str) -> bool: + identifiers = { + model_id, + getattr(model, "id", ""), + getattr(model, "path_name", ""), + getattr(model, "small_name", ""), + getattr(model, "model_name", ""), + } + normalized = { + str(identifier).lower().replace(" ", "").replace("_", "").replace("-", "").replace("*", "star") + for identifier in identifiers + if str(identifier).strip() + } + subset_ids = { + "multisurf", "ms", + "multisurfstar", "mss", + "multiswrfdb", "mswrfdb", + "multiswrfdbstar", "mswrfdbstar", + } + return bool(getattr(model, "uses_instance_subset", False)) or bool(normalized.intersection(subset_ids)) + + def sample_instances_for_model(self, model, Xtr: pd.DataFrame, y_tr: pd.Series) -> Tuple[pd.DataFrame, pd.Series]: + if not self.uses_instance_subset(model, self.model_id): + return Xtr, y_tr + if self.instance_subset is None or int(self.instance_subset) <= 0: + return Xtr, y_tr + n = min(len(Xtr), int(self.instance_subset)) + if n >= len(Xtr): + return Xtr, y_tr + idx = Xtr.sample(n, random_state=self.random_state).index + logging.info( + "Phase 4 %s using instance_subset=%s (%s of %s training instances).", + self.model_id, + self.instance_subset, + n, + len(Xtr), + ) + return Xtr.loc[idx], y_tr.loc[idx] + + def _model_dir(self, model) -> str: + path_name = getattr(model, "path_name", self.model_id) + out_dir = os.path.join(self.experiment_path, self.dataset_name, "feature_importance", path_name) + os.makedirs(out_dir, exist_ok=True) + return out_dir + + def _write_scores_csv(self, model, in_cols): + import pandas as pd + base = self._model_dir(model) + path_name = getattr(model, "path_name", self.model_id) + out_csv = os.path.join(base, f"{path_name}_scores_cv_{self.cv_count}.csv") + scores = model.get_scores() + df = pd.DataFrame({ + "feature": list(in_cols), + "score": [float(scores.get(c, 0.0)) for c in in_cols] + }).sort_values("score", ascending=False) + df.to_csv(out_csv, index=False) + + def _write_cv_files(self, train: pd.DataFrame, test: pd.DataFrame): + if self.overwrite_cv: + os.remove(self.cv_train_path); os.remove(self.cv_test_path) + else: + cvdir = os.path.join(self.experiment_path, self.dataset_name, "CVDatasets") + os.rename(self.cv_train_path, os.path.join(cvdir, f"{self.dataset_name}_CVOnly_{self.cv_count}_Train.csv")) + os.rename(self.cv_test_path, os.path.join(cvdir, f"{self.dataset_name}_CVOnly_{self.cv_count}_Test.csv")) + train.to_csv(self.cv_train_path, index=False) + test.to_csv(self.cv_test_path, index=False) + + def _write_selected_cv_files(self, model, train: pd.DataFrame, test: pd.DataFrame): + path_name = getattr(model, "path_name", self.model_id) + out_dir = os.path.join( + self.experiment_path, + self.dataset_name, + "feature_importance", + path_name, + "selected_cv", + ) + os.makedirs(out_dir, exist_ok=True) + train.to_csv(os.path.join(out_dir, f"{self.dataset_name}_CV_{self.cv_count}_Train.csv"), index=False) + test.to_csv(os.path.join(out_dir, f"{self.dataset_name}_CV_{self.cv_count}_Test.csv"), index=False) + + def _save_runtime(self, model): + rt = os.path.join(self.experiment_path, self.dataset_name, "runtime") + os.makedirs(rt, exist_ok=True) + elapsed = str(time.time() - self.job_start_time) + path_name = getattr(model, "path_name", self.model_id) + with open(os.path.join(rt, f"runtime_feature_importance_{path_name}_cv{self.cv_count}.txt"), "w+") as f: + f.write(elapsed) + with open(os.path.join(rt, f"runtime_feature_importance{self.cv_count}.txt"), "w+") as f: + f.write(elapsed) + + def _complete_flag(self, model): + done = os.path.join(self.experiment_path, "jobsCompleted") + os.makedirs(done, exist_ok=True) + path_name = getattr(model, "path_name", self.model_id) + with open(os.path.join(done, f"job_feature_importance_{path_name}_{self.dataset_name}_{self.cv_count}.txt"), "w") as f: + f.write("complete") diff --git a/streamline/p4_feature_importance/p4_cli.py b/streamline/p4_feature_importance/p4_cli.py new file mode 100644 index 00000000..544bcf17 --- /dev/null +++ b/streamline/p4_feature_importance/p4_cli.py @@ -0,0 +1,105 @@ +# streamline/p4_feature_importance/cli.py +import argparse, json +from streamline.p4_feature_importance.p4_runner import P4Runner +from streamline.p4_feature_importance.utils.fi_loader import list_importances +from streamline.utils.run_commands import ( + add_run_command_args, + apply_saved_run_command, + save_run_command_from_args, + snapshot_args, +) + +def _parse_models_csv(s: str): + if not s: return [] + return [m.strip() for m in s.split(",") if m.strip()] + +def _maybe_json(s: str): + import json + try: + v = json.loads(s or "{}") + return v if isinstance(v, dict) else {} + except Exception: + return {} + +def _maybe_bool(s, default=None): + if s is None: return default + v = str(s).lower() + if v in ("1","true","t","yes","y"): return True + if v in ("0","false","f","no","n"): return False + return default + +def main(): + ap = argparse.ArgumentParser("STREAMLINE Phase 4 (Feature Importance) CLI", + formatter_class=argparse.ArgumentDefaultsHelpFormatter) + ap.add_argument("--output_path", required=True) + ap.add_argument("--experiment_name", required=True) + + # NOW: comma-separated only (e.g., "mutualinformation,multiswrfdb,multiswrfdbstar") + ap.add_argument("--models", required=False, help='Comma-separated: e.g. "mutualinformation,multiswrfdb,multiswrfdbstar"') + # keep JSON dict for params (per-model) + ap.add_argument( + "--models_params", + default=None, + help='JSON dict: {"mutualinformation": {...}, "multiswrfdb": {...}}; ReBATE categorical_features is injected by STREAMLINE.', + ) + + ap.add_argument("--top_k", default=None, type=int) + ap.add_argument("--threshold", default=None, type=float) + ap.add_argument("--keep_original_features", default=None) + ap.add_argument("--overwrite_cv", default=None) + ap.add_argument("--outcome_label", default=None) + ap.add_argument("--outcome_type", default=None) + ap.add_argument("--instance_label", default=None) + ap.add_argument("--random_state", default=None, type=int) + ap.add_argument("--instance_subset", default=None, type=int) + + ap.add_argument("--run_cluster", default="Serial", + help="Serial | Local | Parallel | BashSLURM | BashLSF | ") + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", default=4, type=int) + + ap.add_argument("--list-models", action="store_true") + add_run_command_args(ap) + + args = ap.parse_args() + args = apply_saved_run_command(ap, args, "p4_feature_importance") + run_command_args = snapshot_args(args) + + if args.list_models: + models = list_importances() + print("Available feature-importance models:") + for k, cls in sorted(models.items()): + model_name = getattr(cls, "model_name", k) + small = getattr(cls, "small_name", k) + print(f" {k:16s} -> {cls.__module__}.{cls.__name__} [{model_name} | {small}]") + return + + runner = P4Runner( + output_path=args.output_path, + experiment_name=args.experiment_name, + models=_parse_models_csv(args.models) if args.models else None, + models_params=_maybe_json(args.models_params) if args.models_params else None, + top_k=args.top_k, + threshold=args.threshold, + keep_original_features=_maybe_bool(args.keep_original_features), + overwrite_cv=_maybe_bool(args.overwrite_cv), + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + instance_label=args.instance_label, + random_state=args.random_state, + instance_subset=args.instance_subset, + run_cluster=args.run_cluster if args.run_cluster not in (None,"Serial","False","false") else False, + queue=args.queue, + reserved_memory=args.reserved_memory, + ) + runner.run() + save_run_command_from_args(args, "p4_feature_importance", run_command_args, runner=runner) + +if __name__ == "__main__": + # # run three models (comma-separated), pass params to one ReBATE method via JSON + # python -m streamline.p4_feature_importance.p4_cli \ + # --output_path ./test --experiment_name MyExp \ + # --models "mutualinformation,multiswrfdb,multiswrfdbstar" \ + # --models_params '{"multiswrfdb":{"use_turf": true, "turf_pct": 0.5, "n_jobs": 1}}' \ + # --top_k 100 --instance_subset 2000 # optional sampling limit + main() diff --git a/streamline/p4_feature_importance/p4_jobsubmit.py b/streamline/p4_feature_importance/p4_jobsubmit.py new file mode 100644 index 00000000..9f35ba09 --- /dev/null +++ b/streamline/p4_feature_importance/p4_jobsubmit.py @@ -0,0 +1,50 @@ +# streamline/p4_feature_importance/p4_jobsubmit.py +import argparse, json +from streamline.p4_feature_importance.importance import FeatureImportance + +def _maybe_json(s: str): + try: return json.loads(s or "{}") + except Exception: return {} + +def _maybe_int(s): return None if s in (None,"") else int(s) +def _maybe_float(s): return None if s in (None,"") else float(s) + +def main(): + ap = argparse.ArgumentParser("P4 feature-importance single-CV jobsubmit") + ap.add_argument("--cv_train_path", required=True) + ap.add_argument("--cv_test_path", required=True) + ap.add_argument("--experiment_path", required=True) + + ap.add_argument("--model_id", required=True) + ap.add_argument("--model_params", default="{}") + ap.add_argument("--top_k", default=None) + ap.add_argument("--threshold", default=None) + ap.add_argument("--keep_original_features", default="0") + ap.add_argument("--overwrite_cv", default="1") + ap.add_argument("--outcome_label", default="Class") + ap.add_argument("--outcome_type", default=None) + ap.add_argument("--instance_label", default=None) + ap.add_argument("--random_state", default=None) + ap.add_argument("--instance_subset", default=None) + + args = ap.parse_args() + + FeatureImportance( + cv_train_path=args.cv_train_path, + cv_test_path=args.cv_test_path, + experiment_path=args.experiment_path, + model_id=args.model_id, + model_params=_maybe_json(args.model_params), + top_k=_maybe_int(args.top_k), + threshold=_maybe_float(args.threshold), + keep_original_features=(str(args.keep_original_features).lower() not in ("0","false","no")), + overwrite_cv=(str(args.overwrite_cv).lower() not in ("0","false","no")), + outcome_label=args.outcome_label or "Class", + outcome_type=args.outcome_type, + instance_label=(None if args.instance_label in (None,"") else args.instance_label), + random_state=_maybe_int(args.random_state), + instance_subset=_maybe_int(args.instance_subset), + ).run() + +if __name__ == "__main__": + main() diff --git a/streamline/p4_feature_importance/p4_runner.py b/streamline/p4_feature_importance/p4_runner.py new file mode 100644 index 00000000..ad9ca24c --- /dev/null +++ b/streamline/p4_feature_importance/p4_runner.py @@ -0,0 +1,278 @@ +# streamline/p4_feature_importance/runner.py +import os, glob, json, time, pickle, logging +from copy import deepcopy +from pathlib import Path +from typing import Dict, Any, List, Tuple + +import dask +from dask.distributed import Client, LocalCluster + +from streamline.utils.runners import num_cores, run_dask_tasks, run_parallel_jobs +from streamline.utils.cluster import get_cluster +from streamline.p4_feature_importance.importance import FeatureImportance +from streamline.p4_feature_importance.utils.fi_loader import list_importances, resolve_importance_id + +DEFAULT_P4_MODELS_PARAMS = { + "multisurf": {"n_jobs": 1}, + "multisurfstar": {"n_jobs": 1}, + "multiswrfdb": {"n_jobs": 1}, + "multiswrfdbstar": {"n_jobs": 1}, +} + +class P4Runner: + """ + Phase 4: Feature Importance + - models: list[str] of model ids (e.g., ["mutualinformation","multiswrfdb","multiswrfdbstar"]) + - models_params: dict id->params (JSON) + """ + def __init__( + self, + output_path: str, + experiment_name: str, + *, + models: "List[str] | None" = None, + models_params: "Dict[str, Dict[str, Any]] | None" = None, + top_k: "int | None" = None, + threshold: "float | None" = None, + keep_original_features: "bool | None" = None, + overwrite_cv: "bool | None" = None, + outcome_label: "str | None" = None, + outcome_type: "str | None" = None, + instance_label: "str | None" = None, + random_state: "int | None" = None, + instance_subset: "int | None" = None, + run_cluster: "str | bool" = False, + queue: str = "defq", + reserved_memory: int = 4, + ): + self.output_path = output_path + self.experiment_name = experiment_name + self.run_cluster = run_cluster + self.queue = queue + self.reserved_memory = reserved_memory + + # defaults + models = self._csv_to_list(models) + meta = self._load_metadata() + metadata_models = meta.get("P4 Models", None) + self.models = models or metadata_models or sorted(list_importances().keys()) + # if metadata also stores CSV, normalize that too + if isinstance(self.models, str): + self.models = self._csv_to_list(self.models) + self.models = [resolve_importance_id(m) or m for m in self.models] + raw_model_params = models_params + if raw_model_params is None: + metadata_params = meta.get("P4 Models Params", "{}") or "{}" + raw_model_params = json.loads(metadata_params) if isinstance(metadata_params, str) else metadata_params + self.models_params = self.apply_default_model_params(self.normalize_model_params(raw_model_params)) + self.top_k = top_k if top_k is not None else meta.get("P4 TopK", None) + self.threshold = threshold if threshold is not None else meta.get("P4 Threshold", None) + self.keep_original_features = bool(keep_original_features if keep_original_features is not None else meta.get("P4 Keep Original Features", False)) + self.overwrite_cv = bool(overwrite_cv if overwrite_cv is not None else True) + self.outcome_label = outcome_label or meta.get("Outcome Label", "Class") + self.outcome_type = outcome_type or meta.get("Outcome Type", None) + self.instance_label = instance_label if instance_label is not None else meta.get("Instance Label", None) + self.random_state = random_state if random_state is not None else meta.get("Random Seed", 0) + self.instance_subset = instance_subset if instance_subset is not None else meta.get("P4 Instance Subset", None) + + exp_root = os.path.join(self.output_path, self.experiment_name) + if not os.path.exists(exp_root): + raise Exception("Experiment must exist before phase 4 can begin") + + def run(self): + exp_root = os.path.join(self.output_path, self.experiment_name) + jobs: List[Tuple[str,str,str]] = [] # (model_id, tr, te) + logging.info( + "Phase 4 starting for experiment '%s' with models: %s", + self.experiment_name, + ", ".join(self.models) if self.models else "(none)", + ) + + # discover CV pairs + pairs: List[Tuple[str,str]] = [] + for name in os.listdir(exp_root): + ds_dir = os.path.join(exp_root, name) + if not os.path.isdir(ds_dir): continue + if name in {"jobsCompleted","jobs","logs","dask_logs","DatasetComparisons"}: continue + for tr in sorted(glob.glob(os.path.join(ds_dir, "CVDatasets/*Train.csv"))): + te = tr.replace("Train.csv","Test.csv") + if os.path.exists(te): pairs.append((tr, te)) + + if not pairs: raise Exception("No CV Train/Test pairs found for Phase 4.") + if not self.models: raise Exception("No feature-importance models specified.") + logging.info("Phase 4 discovered %d CV train/test pairs.", len(pairs)) + + # ensure model ids exist + available = list_importances() + for m in self.models: + if m not in available: + raise ValueError(f"Unknown model '{m}'. Available: {', '.join(sorted(available))}") + + # expand tasks: every (pair × model) + for tr, te in pairs: + for m in self.models: + jobs.append((m, tr, te)) + + mode = str(self.run_cluster) if self.run_cluster else "Serial" + logging.info("Phase 4 submitting %d jobs in mode '%s'.", len(jobs), mode) + if mode == "Local": + with LocalCluster(processes=True, n_workers=num_cores, threads_per_worker=1) as cluster: + with Client(cluster) as client: + tasks = [dask.delayed(self._run_one)(m, tr, te) for (m,tr,te) in jobs] + run_dask_tasks(tasks, client, label="Phase 4 Dask jobs") + elif mode == "Parallel": + run_parallel_jobs(self._run_one, jobs, label="Phase 4 Parallel jobs") + elif self.run_cluster and self.run_cluster != "Serial" and self.run_cluster not in ("BashSLURM","BashLSF"): + client: Client = get_cluster(self.run_cluster, exp_root, self.queue, self.reserved_memory) + tasks = [dask.delayed(self._run_one)(m, tr, te) for (m,tr,te) in jobs] + run_dask_tasks(tasks, client, label="Phase 4 Dask jobs") + elif self.run_cluster in ("BashSLURM","BashLSF"): + for m,tr,te in jobs: self._submit_bash_job(m, tr, te) + else: + for m,tr,te in jobs: self._run_one(m, tr, te) + + self._save_run_params(mode) + logging.info("Phase 4 completed: %d jobs finished.", len(jobs)) + + def _run_one(self, model_id: str, tr: str, te: str): + exp_root = os.path.join(self.output_path, self.experiment_name) + train_path = Path(tr) + dataset_name = train_path.parents[1].name if len(train_path.parents) > 1 else "unknown_dataset" + cv_label = train_path.stem.replace("_Train", "") + logging.info("Phase 4 running model '%s' on %s [%s].", model_id, dataset_name, cv_label) + FeatureImportance( + cv_train_path=tr, + cv_test_path=te, + experiment_path=exp_root, + model_id=model_id, + model_params=self.models_params.get(model_id, {}), + top_k=self.top_k, + threshold=self.threshold, + keep_original_features=self.keep_original_features, + overwrite_cv=self.overwrite_cv, + outcome_label=self.outcome_label, + outcome_type=self.outcome_type, + instance_label=self.instance_label, + random_state=self.random_state, + instance_subset=self.instance_subset, + ).run() + logging.info("Phase 4 completed model '%s' on %s [%s].", model_id, dataset_name, cv_label) + + def _load_metadata(self): + path = os.path.join(self.output_path, self.experiment_name, "metadata.pickle") + if os.path.exists(path): + with open(path,"rb") as f: + try: return pickle.load(f) or {} + except Exception: return {} + return {} + + def _csv_to_list(self, v): + if v is None: return None + if isinstance(v, list): return v + if isinstance(v, str): + return [m.strip() for m in v.split(",") if m.strip()] + return v + + def normalize_model_params(self, params): + if not isinstance(params, dict): + return {} + normalized = {} + for model_id, model_params in params.items(): + resolved = resolve_importance_id(model_id) or model_id + normalized[resolved] = model_params + return normalized + + def apply_default_model_params(self, params): + merged = { + model_id: deepcopy(DEFAULT_P4_MODELS_PARAMS[model_id]) + for model_id in self.models + if model_id in DEFAULT_P4_MODELS_PARAMS + } + for model_id, model_params in (params or {}).items(): + resolved = resolve_importance_id(model_id) or model_id + base = merged.setdefault(resolved, {}) + if isinstance(model_params, dict): + base.update(model_params) + else: + merged[resolved] = {} + return merged + + def _save_run_params(self, mode: str): + from datetime import datetime + exp_root = os.path.join(self.output_path, self.experiment_name) + params_file = os.path.join(exp_root, "run_params.pickle") + this_run = { + "phase": "p4_feature_importance", + "run_mode": mode, + "models": self.models, + "models_params": self.models_params, + "top_k": self.top_k, + "threshold": self.threshold, + "keep_original_features": self.keep_original_features, + "overwrite_cv": self.overwrite_cv, + "outcome_label": self.outcome_label, + "outcome_type": self.outcome_type, + "instance_label": self.instance_label, + "random_state": self.random_state, + "instance_subset": self.instance_subset, + } + all_params = {} + if os.path.exists(params_file): + with open(params_file,"rb") as f: + try: all_params = pickle.load(f) + except Exception: all_params = {} + all_params[datetime.now().isoformat()] = this_run + with open(params_file,"wb") as f: pickle.dump(all_params, f) + + # ---- bash submit: one job per (model × CV pair) ---- + def _submit_bash_job(self, model_id: str, tr: str, te: str): + job_ref = str(time.time()) + run_dir = os.path.join(self.output_path, self.experiment_name) + os.makedirs(os.path.join(run_dir,"jobs"), exist_ok=True) + os.makedirs(os.path.join(run_dir,"logs"), exist_ok=True) + job_name = os.path.join(run_dir, f"jobs/P4_{model_id}_{job_ref}_run.sh") + launcher = "sbatch" if self.run_cluster == "BashSLURM" else "bsub <" + + with open(job_name, "w") as sh: + sh.write("#!/bin/bash\n") + if self.run_cluster == "BashSLURM": + sh.write(f"#SBATCH -p {self.queue}\n") + sh.write(f"#SBATCH --job-name={job_ref}\n") + sh.write(f"#SBATCH --mem={self.reserved_memory}G\n") + sh.write(f"#SBATCH -o {run_dir}/logs/P4_{model_id}_{job_ref}.o\n") + sh.write(f"#SBATCH -e {run_dir}/logs/P4_{model_id}_{job_ref}.e\n") + sh.write("srun " + self._bash_cmd(model_id, tr, te) + "\n") + else: + sh.write(f"#BSUB -q {self.queue}\n") + sh.write(f"#BSUB -J {job_ref}\n") + sh.write(f"#BSUB -R \"rusage[mem={self.reserved_memory}G]\"\n") + sh.write(f"#BSUB -M {self.reserved_memory}GB\n") + sh.write(f"#BSUB -o {run_dir}/logs/P4_{model_id}_{job_ref}.o\n") + sh.write(f"#BSUB -e {run_dir}/logs/P4_{model_id}_{job_ref}.e\n") + sh.write(self._bash_cmd(model_id, tr, te) + "\n") + + os.system(f"{launcher} {job_name}") + logging.info("Phase 4 submitted cluster job script: %s", job_name) + + def _bash_cmd(self, model_id: str, tr: str, te: str) -> str: + script_path = str(Path(__file__).parent / "p4_jobsubmit.py") + exp_root = os.path.join(self.output_path, self.experiment_name) + params = json.dumps(self.models_params.get(model_id, {}) or {}) + args = [ + "python", script_path, + "--cv_train_path", tr, + "--cv_test_path", te, + "--experiment_path", exp_root, + "--model_id", model_id, + "--model_params", params, + "--top_k", str(self.top_k) if self.top_k is not None else "", + "--threshold", str(self.threshold) if self.threshold is not None else "", + "--keep_original_features", str(int(self.keep_original_features)), + "--overwrite_cv", str(int(self.overwrite_cv)), + "--outcome_label", self.outcome_label or "", + "--outcome_type", self.outcome_type or "", + "--instance_label", self.instance_label or "", + "--random_state", str(self.random_state) if self.random_state is not None else "", + "--instance_subset", str(self.instance_subset) if self.instance_subset is not None else "", + ] + return " ".join(args) diff --git a/streamline/p4_feature_importance/registry/multisurf.py b/streamline/p4_feature_importance/registry/multisurf.py new file mode 100644 index 00000000..a7d63b11 --- /dev/null +++ b/streamline/p4_feature_importance/registry/multisurf.py @@ -0,0 +1,178 @@ +from __future__ import annotations + +from typing import Any, Dict, List, Optional + +import numpy as np +import pandas as pd + +from streamline.p4_feature_importance.utils.input_normalization import ( + normalize_feature_matrix, + normalize_target_vector, +) + + +class MultiSURF: + id = "multisurf" + model_name = "MultiSURF" + small_name = "MS" + path_name = "multisurf" + uses_instance_subset = True + + def __init__( + self, + n_features_to_select: Optional[int] = None, + n_neighbors: int | float = 100, + categorical_features: Optional[List[int]] = None, + categorical_threshold: int = 10, + multiclass_threshold: int = 10, + verbose: bool = False, + n_jobs: Optional[int] = None, + weight_final_scores: bool = False, + rank_absolute: bool = False, + label_type: Optional[str] = None, + random_state: Optional[int] = None, + use_turf: bool = False, + turf_pct: int | float | None = None, + turf_num_scores_to_return: Optional[int] = None, + **kwargs, + ): + self.n_features_to_select = n_features_to_select + self.n_neighbors = n_neighbors + self.categorical_features = list(categorical_features or []) + self.categorical_threshold = categorical_threshold + self.multiclass_threshold = multiclass_threshold + self.verbose = verbose + self.n_jobs = n_jobs if n_jobs is not None else 1 + self.weight_final_scores = weight_final_scores + self.rank_absolute = rank_absolute + self.label_type = label_type + self.random_state = random_state + self.use_turf = bool(use_turf) + self.turf_pct = turf_pct + self.turf_num_scores_to_return = turf_num_scores_to_return + self.kwargs = kwargs + self.columns: List[str] = [] + self.scores: Dict[str, float] = {} + self.implementation = None + + def fit(self, X: pd.DataFrame, y: pd.Series): + self.columns = X.columns.tolist() + X_array = self.normalize_rebate_matrix(X) + y_array = normalize_target_vector(y) + try: + from skrebate import MultiSURF as RebateModel, TURF + except (ModuleNotFoundError, ImportError) as e: + raise Exception("MultiSURF requires 'skrebate==0.8.2'.") from e + + base = RebateModel(**self.build_rebate_params(len(self.columns))) + if self.use_turf: + turf_pct = 0.5 if self.turf_pct is None else self.turf_pct + score_count = self.turf_num_scores_to_return or len(self.columns) + self.implementation = TURF( + base, + pct=turf_pct, + num_scores_to_return=int(score_count), + ).fit(X_array, y_array) + else: + self.implementation = base.fit(X_array, y_array) + + self.scores = self.build_scores(getattr(self.implementation, "feature_importances_", None)) + return self + + def normalize_rebate_matrix(self, X: pd.DataFrame) -> np.ndarray: + X_rebate = X.copy() + for idx in self.categorical_feature_indexes(): + if idx >= len(self.columns): + continue + col = self.columns[idx] + series = X_rebate[col] + numeric = pd.to_numeric(series, errors="coerce") + non_missing = series.notna() + if numeric[non_missing].notna().all(): + X_rebate[col] = numeric + else: + codes, _ = pd.factorize(series, sort=True, use_na_sentinel=True) + coded = codes.astype(float) + coded[codes == -1] = np.nan + X_rebate[col] = coded + _, X_array = normalize_feature_matrix(X_rebate) + return X_array + + def categorical_feature_indexes(self) -> List[int]: + indexes = [] + for value in self.categorical_features: + try: + index = int(value) + except (TypeError, ValueError): + continue + if index >= 0: + indexes.append(index) + return indexes + + def build_rebate_params(self, feature_count: int) -> Dict[str, Any]: + params = { + "n_features_to_select": self.n_features_to_select or feature_count, + "categorical_features": self.categorical_feature_indexes(), + "categorical_threshold": self.categorical_threshold, + "multiclass_threshold": self.multiclass_threshold, + "verbose": self.verbose, + "n_jobs": self.n_jobs, + "weight_final_scores": self.weight_final_scores, + "rank_absolute": self.rank_absolute, + "label_type": self.label_type, + } + params.update(self.kwargs or {}) + return params + + def build_scores(self, importances) -> Dict[str, float]: + if importances is None: + values = np.zeros(len(self.columns), dtype=float) + else: + values = np.asarray(importances, dtype=float) + if len(values) < len(self.columns): + values = np.pad(values, (0, len(self.columns) - len(values)), constant_values=0.0) + elif len(values) > len(self.columns): + values = values[: len(self.columns)] + return {c: float(s) for c, s in zip(self.columns, values)} + + def ranked_features(self) -> List[str]: + return sorted(self.columns, key=lambda c: self.scores.get(c, 0.0), reverse=True) + + def get_support_mask(self, *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> List[bool]: + if top_k is not None: + keep = set(self.ranked_features()[:int(top_k)]) + return [c in keep for c in self.columns] + if threshold is not None: + return [self.scores.get(c, 0.0) >= float(threshold) for c in self.columns] + return [True] * len(self.columns) + + def get_support_names(self, cols: List[str], *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> List[str]: + mask = self.get_support_mask(top_k=top_k, threshold=threshold) + return [c for c, m in zip(self.columns, mask) if m] + + def transform(self, X: pd.DataFrame, *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> pd.DataFrame: + names = self.get_support_names(self.columns, top_k=top_k, threshold=threshold) + return X.loc[:, names] + + def get_scores(self) -> Dict[str, float]: + return dict(self.scores) + + def get_params(self) -> Dict[str, Any]: + params = { + "n_features_to_select": self.n_features_to_select, + "n_neighbors": self.n_neighbors, + "categorical_features": self.categorical_feature_indexes(), + "categorical_threshold": self.categorical_threshold, + "multiclass_threshold": self.multiclass_threshold, + "verbose": self.verbose, + "n_jobs": self.n_jobs, + "weight_final_scores": self.weight_final_scores, + "rank_absolute": self.rank_absolute, + "label_type": self.label_type, + "random_state": self.random_state, + "use_turf": self.use_turf, + "turf_pct": self.turf_pct, + "turf_num_scores_to_return": self.turf_num_scores_to_return, + } + params.update(self.kwargs or {}) + return params diff --git a/streamline/p4_feature_importance/registry/multisurfstar.py b/streamline/p4_feature_importance/registry/multisurfstar.py new file mode 100644 index 00000000..ac34c414 --- /dev/null +++ b/streamline/p4_feature_importance/registry/multisurfstar.py @@ -0,0 +1,178 @@ +from __future__ import annotations + +from typing import Any, Dict, List, Optional + +import numpy as np +import pandas as pd + +from streamline.p4_feature_importance.utils.input_normalization import ( + normalize_feature_matrix, + normalize_target_vector, +) + + +class MultiSURFStar: + id = "multisurfstar" + model_name = "MultiSURF*" + small_name = "MS*" + path_name = "multisurfstar" + uses_instance_subset = True + + def __init__( + self, + n_features_to_select: Optional[int] = None, + n_neighbors: int | float = 100, + categorical_features: Optional[List[int]] = None, + categorical_threshold: int = 10, + multiclass_threshold: int = 10, + verbose: bool = False, + n_jobs: Optional[int] = None, + weight_final_scores: bool = False, + rank_absolute: bool = False, + label_type: Optional[str] = None, + random_state: Optional[int] = None, + use_turf: bool = False, + turf_pct: int | float | None = None, + turf_num_scores_to_return: Optional[int] = None, + **kwargs, + ): + self.n_features_to_select = n_features_to_select + self.n_neighbors = n_neighbors + self.categorical_features = list(categorical_features or []) + self.categorical_threshold = categorical_threshold + self.multiclass_threshold = multiclass_threshold + self.verbose = verbose + self.n_jobs = n_jobs if n_jobs is not None else 1 + self.weight_final_scores = weight_final_scores + self.rank_absolute = rank_absolute + self.label_type = label_type + self.random_state = random_state + self.use_turf = bool(use_turf) + self.turf_pct = turf_pct + self.turf_num_scores_to_return = turf_num_scores_to_return + self.kwargs = kwargs + self.columns: List[str] = [] + self.scores: Dict[str, float] = {} + self.implementation = None + + def fit(self, X: pd.DataFrame, y: pd.Series): + self.columns = X.columns.tolist() + X_array = self.normalize_rebate_matrix(X) + y_array = normalize_target_vector(y) + try: + from skrebate import MultiSURFstar as RebateModel, TURF + except (ModuleNotFoundError, ImportError) as e: + raise Exception("MultiSURF* requires 'skrebate==0.8.2'.") from e + + base = RebateModel(**self.build_rebate_params(len(self.columns))) + if self.use_turf: + turf_pct = 0.5 if self.turf_pct is None else self.turf_pct + score_count = self.turf_num_scores_to_return or len(self.columns) + self.implementation = TURF( + base, + pct=turf_pct, + num_scores_to_return=int(score_count), + ).fit(X_array, y_array) + else: + self.implementation = base.fit(X_array, y_array) + + self.scores = self.build_scores(getattr(self.implementation, "feature_importances_", None)) + return self + + def normalize_rebate_matrix(self, X: pd.DataFrame) -> np.ndarray: + X_rebate = X.copy() + for idx in self.categorical_feature_indexes(): + if idx >= len(self.columns): + continue + col = self.columns[idx] + series = X_rebate[col] + numeric = pd.to_numeric(series, errors="coerce") + non_missing = series.notna() + if numeric[non_missing].notna().all(): + X_rebate[col] = numeric + else: + codes, _ = pd.factorize(series, sort=True, use_na_sentinel=True) + coded = codes.astype(float) + coded[codes == -1] = np.nan + X_rebate[col] = coded + _, X_array = normalize_feature_matrix(X_rebate) + return X_array + + def categorical_feature_indexes(self) -> List[int]: + indexes = [] + for value in self.categorical_features: + try: + index = int(value) + except (TypeError, ValueError): + continue + if index >= 0: + indexes.append(index) + return indexes + + def build_rebate_params(self, feature_count: int) -> Dict[str, Any]: + params = { + "n_features_to_select": self.n_features_to_select or feature_count, + "categorical_features": self.categorical_feature_indexes(), + "categorical_threshold": self.categorical_threshold, + "multiclass_threshold": self.multiclass_threshold, + "verbose": self.verbose, + "n_jobs": self.n_jobs, + "weight_final_scores": self.weight_final_scores, + "rank_absolute": self.rank_absolute, + "label_type": self.label_type, + } + params.update(self.kwargs or {}) + return params + + def build_scores(self, importances) -> Dict[str, float]: + if importances is None: + values = np.zeros(len(self.columns), dtype=float) + else: + values = np.asarray(importances, dtype=float) + if len(values) < len(self.columns): + values = np.pad(values, (0, len(self.columns) - len(values)), constant_values=0.0) + elif len(values) > len(self.columns): + values = values[: len(self.columns)] + return {c: float(s) for c, s in zip(self.columns, values)} + + def ranked_features(self) -> List[str]: + return sorted(self.columns, key=lambda c: self.scores.get(c, 0.0), reverse=True) + + def get_support_mask(self, *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> List[bool]: + if top_k is not None: + keep = set(self.ranked_features()[:int(top_k)]) + return [c in keep for c in self.columns] + if threshold is not None: + return [self.scores.get(c, 0.0) >= float(threshold) for c in self.columns] + return [True] * len(self.columns) + + def get_support_names(self, cols: List[str], *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> List[str]: + mask = self.get_support_mask(top_k=top_k, threshold=threshold) + return [c for c, m in zip(self.columns, mask) if m] + + def transform(self, X: pd.DataFrame, *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> pd.DataFrame: + names = self.get_support_names(self.columns, top_k=top_k, threshold=threshold) + return X.loc[:, names] + + def get_scores(self) -> Dict[str, float]: + return dict(self.scores) + + def get_params(self) -> Dict[str, Any]: + params = { + "n_features_to_select": self.n_features_to_select, + "n_neighbors": self.n_neighbors, + "categorical_features": self.categorical_feature_indexes(), + "categorical_threshold": self.categorical_threshold, + "multiclass_threshold": self.multiclass_threshold, + "verbose": self.verbose, + "n_jobs": self.n_jobs, + "weight_final_scores": self.weight_final_scores, + "rank_absolute": self.rank_absolute, + "label_type": self.label_type, + "random_state": self.random_state, + "use_turf": self.use_turf, + "turf_pct": self.turf_pct, + "turf_num_scores_to_return": self.turf_num_scores_to_return, + } + params.update(self.kwargs or {}) + return params diff --git a/streamline/p4_feature_importance/registry/multiswrfdb.py b/streamline/p4_feature_importance/registry/multiswrfdb.py new file mode 100644 index 00000000..a59dbe87 --- /dev/null +++ b/streamline/p4_feature_importance/registry/multiswrfdb.py @@ -0,0 +1,179 @@ +from __future__ import annotations + +from typing import Any, Dict, List, Optional + +import numpy as np +import pandas as pd + +from streamline.p4_feature_importance.utils.input_normalization import ( + normalize_feature_matrix, + normalize_target_vector, +) + + +class MultiSWRFDB: + id = "multiswrfdb" + model_name = "MultiSWRFDB" + small_name = "MSWRFDB" + path_name = "multiswrfdb" + uses_instance_subset = True + + def __init__( + self, + n_features_to_select: Optional[int] = None, + n_neighbors: int | float = 100, + categorical_features: Optional[List[int]] = None, + categorical_threshold: int = 10, + multiclass_threshold: int = 10, + verbose: bool = False, + n_jobs: Optional[int] = None, + weight_final_scores: bool = False, + rank_absolute: bool = False, + label_type: Optional[str] = None, + random_state: Optional[int] = None, + use_turf: bool = False, + turf_pct: int | float | None = None, + turf_num_scores_to_return: Optional[int] = None, + **kwargs, + ): + self.n_features_to_select = n_features_to_select + self.n_neighbors = n_neighbors + self.categorical_features = list(categorical_features or []) + self.categorical_threshold = categorical_threshold + self.multiclass_threshold = multiclass_threshold + self.verbose = verbose + self.n_jobs = n_jobs if n_jobs is not None else 1 + self.weight_final_scores = weight_final_scores + self.rank_absolute = rank_absolute + self.label_type = label_type + self.random_state = random_state + self.use_turf = bool(use_turf) + self.turf_pct = turf_pct + self.turf_num_scores_to_return = turf_num_scores_to_return + self.kwargs = kwargs + self.columns: List[str] = [] + self.scores: Dict[str, float] = {} + self.implementation = None + + def fit(self, X: pd.DataFrame, y: pd.Series): + self.columns = X.columns.tolist() + X_array = self.normalize_rebate_matrix(X) + y_array = normalize_target_vector(y) + try: + from skrebate import MultiSWRFDB as RebateModel, TURF + except (ModuleNotFoundError, ImportError) as e: + raise Exception("MultiSWRFDB requires 'skrebate==0.8.2'.") from e + + base = RebateModel(**self.build_rebate_params(len(self.columns))) + if self.use_turf: + turf_pct = 0.5 if self.turf_pct is None else self.turf_pct + score_count = self.turf_num_scores_to_return or len(self.columns) + self.implementation = TURF( + base, + pct=turf_pct, + num_scores_to_return=int(score_count), + ).fit(X_array, y_array) + else: + self.implementation = base.fit(X_array, y_array) + + self.scores = self.build_scores(getattr(self.implementation, "feature_importances_", None)) + return self + + def normalize_rebate_matrix(self, X: pd.DataFrame) -> np.ndarray: + X_rebate = X.copy() + for idx in self.categorical_feature_indexes(): + if idx >= len(self.columns): + continue + col = self.columns[idx] + series = X_rebate[col] + numeric = pd.to_numeric(series, errors="coerce") + non_missing = series.notna() + if numeric[non_missing].notna().all(): + X_rebate[col] = numeric + else: + codes, _ = pd.factorize(series, sort=True, use_na_sentinel=True) + coded = codes.astype(float) + coded[codes == -1] = np.nan + X_rebate[col] = coded + _, X_array = normalize_feature_matrix(X_rebate) + return X_array + + def categorical_feature_indexes(self) -> List[int]: + indexes = [] + for value in self.categorical_features: + try: + index = int(value) + except (TypeError, ValueError): + continue + if index >= 0: + indexes.append(index) + return indexes + + def build_rebate_params(self, feature_count: int) -> Dict[str, Any]: + params = { + "n_features_to_select": self.n_features_to_select or feature_count, + "n_neighbors": self.n_neighbors, + "categorical_features": self.categorical_feature_indexes(), + "categorical_threshold": self.categorical_threshold, + "multiclass_threshold": self.multiclass_threshold, + "verbose": self.verbose, + "n_jobs": self.n_jobs, + "weight_final_scores": self.weight_final_scores, + "rank_absolute": self.rank_absolute, + "label_type": self.label_type, + } + params.update(self.kwargs or {}) + return params + + def build_scores(self, importances) -> Dict[str, float]: + if importances is None: + values = np.zeros(len(self.columns), dtype=float) + else: + values = np.asarray(importances, dtype=float) + if len(values) < len(self.columns): + values = np.pad(values, (0, len(self.columns) - len(values)), constant_values=0.0) + elif len(values) > len(self.columns): + values = values[: len(self.columns)] + return {c: float(s) for c, s in zip(self.columns, values)} + + def ranked_features(self) -> List[str]: + return sorted(self.columns, key=lambda c: self.scores.get(c, 0.0), reverse=True) + + def get_support_mask(self, *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> List[bool]: + if top_k is not None: + keep = set(self.ranked_features()[:int(top_k)]) + return [c in keep for c in self.columns] + if threshold is not None: + return [self.scores.get(c, 0.0) >= float(threshold) for c in self.columns] + return [True] * len(self.columns) + + def get_support_names(self, cols: List[str], *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> List[str]: + mask = self.get_support_mask(top_k=top_k, threshold=threshold) + return [c for c, m in zip(self.columns, mask) if m] + + def transform(self, X: pd.DataFrame, *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> pd.DataFrame: + names = self.get_support_names(self.columns, top_k=top_k, threshold=threshold) + return X.loc[:, names] + + def get_scores(self) -> Dict[str, float]: + return dict(self.scores) + + def get_params(self) -> Dict[str, Any]: + params = { + "n_features_to_select": self.n_features_to_select, + "n_neighbors": self.n_neighbors, + "categorical_features": self.categorical_feature_indexes(), + "categorical_threshold": self.categorical_threshold, + "multiclass_threshold": self.multiclass_threshold, + "verbose": self.verbose, + "n_jobs": self.n_jobs, + "weight_final_scores": self.weight_final_scores, + "rank_absolute": self.rank_absolute, + "label_type": self.label_type, + "random_state": self.random_state, + "use_turf": self.use_turf, + "turf_pct": self.turf_pct, + "turf_num_scores_to_return": self.turf_num_scores_to_return, + } + params.update(self.kwargs or {}) + return params diff --git a/streamline/p4_feature_importance/registry/multiswrfdbstar.py b/streamline/p4_feature_importance/registry/multiswrfdbstar.py new file mode 100644 index 00000000..e29b5289 --- /dev/null +++ b/streamline/p4_feature_importance/registry/multiswrfdbstar.py @@ -0,0 +1,179 @@ +from __future__ import annotations + +from typing import Any, Dict, List, Optional + +import numpy as np +import pandas as pd + +from streamline.p4_feature_importance.utils.input_normalization import ( + normalize_feature_matrix, + normalize_target_vector, +) + + +class MultiSWRFDBStar: + id = "multiswrfdbstar" + model_name = "MultiSWRFDB*" + small_name = "MSWRFDB*" + path_name = "multiswrfdbstar" + uses_instance_subset = True + + def __init__( + self, + n_features_to_select: Optional[int] = None, + n_neighbors: int | float = 100, + categorical_features: Optional[List[int]] = None, + categorical_threshold: int = 10, + multiclass_threshold: int = 10, + verbose: bool = False, + n_jobs: Optional[int] = None, + weight_final_scores: bool = False, + rank_absolute: bool = False, + label_type: Optional[str] = None, + random_state: Optional[int] = None, + use_turf: bool = False, + turf_pct: int | float | None = None, + turf_num_scores_to_return: Optional[int] = None, + **kwargs, + ): + self.n_features_to_select = n_features_to_select + self.n_neighbors = n_neighbors + self.categorical_features = list(categorical_features or []) + self.categorical_threshold = categorical_threshold + self.multiclass_threshold = multiclass_threshold + self.verbose = verbose + self.n_jobs = n_jobs if n_jobs is not None else 1 + self.weight_final_scores = weight_final_scores + self.rank_absolute = rank_absolute + self.label_type = label_type + self.random_state = random_state + self.use_turf = bool(use_turf) + self.turf_pct = turf_pct + self.turf_num_scores_to_return = turf_num_scores_to_return + self.kwargs = kwargs + self.columns: List[str] = [] + self.scores: Dict[str, float] = {} + self.implementation = None + + def fit(self, X: pd.DataFrame, y: pd.Series): + self.columns = X.columns.tolist() + X_array = self.normalize_rebate_matrix(X) + y_array = normalize_target_vector(y) + try: + from skrebate import MultiSWRFDBstar as RebateModel, TURF + except (ModuleNotFoundError, ImportError) as e: + raise Exception("MultiSWRFDB* requires 'skrebate==0.8.2'.") from e + + base = RebateModel(**self.build_rebate_params(len(self.columns))) + if self.use_turf: + turf_pct = 0.5 if self.turf_pct is None else self.turf_pct + score_count = self.turf_num_scores_to_return or len(self.columns) + self.implementation = TURF( + base, + pct=turf_pct, + num_scores_to_return=int(score_count), + ).fit(X_array, y_array) + else: + self.implementation = base.fit(X_array, y_array) + + self.scores = self.build_scores(getattr(self.implementation, "feature_importances_", None)) + return self + + def normalize_rebate_matrix(self, X: pd.DataFrame) -> np.ndarray: + X_rebate = X.copy() + for idx in self.categorical_feature_indexes(): + if idx >= len(self.columns): + continue + col = self.columns[idx] + series = X_rebate[col] + numeric = pd.to_numeric(series, errors="coerce") + non_missing = series.notna() + if numeric[non_missing].notna().all(): + X_rebate[col] = numeric + else: + codes, _ = pd.factorize(series, sort=True, use_na_sentinel=True) + coded = codes.astype(float) + coded[codes == -1] = np.nan + X_rebate[col] = coded + _, X_array = normalize_feature_matrix(X_rebate) + return X_array + + def categorical_feature_indexes(self) -> List[int]: + indexes = [] + for value in self.categorical_features: + try: + index = int(value) + except (TypeError, ValueError): + continue + if index >= 0: + indexes.append(index) + return indexes + + def build_rebate_params(self, feature_count: int) -> Dict[str, Any]: + params = { + "n_features_to_select": self.n_features_to_select or feature_count, + "n_neighbors": self.n_neighbors, + "categorical_features": self.categorical_feature_indexes(), + "categorical_threshold": self.categorical_threshold, + "multiclass_threshold": self.multiclass_threshold, + "verbose": self.verbose, + "n_jobs": self.n_jobs, + "weight_final_scores": self.weight_final_scores, + "rank_absolute": self.rank_absolute, + "label_type": self.label_type, + } + params.update(self.kwargs or {}) + return params + + def build_scores(self, importances) -> Dict[str, float]: + if importances is None: + values = np.zeros(len(self.columns), dtype=float) + else: + values = np.asarray(importances, dtype=float) + if len(values) < len(self.columns): + values = np.pad(values, (0, len(self.columns) - len(values)), constant_values=0.0) + elif len(values) > len(self.columns): + values = values[: len(self.columns)] + return {c: float(s) for c, s in zip(self.columns, values)} + + def ranked_features(self) -> List[str]: + return sorted(self.columns, key=lambda c: self.scores.get(c, 0.0), reverse=True) + + def get_support_mask(self, *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> List[bool]: + if top_k is not None: + keep = set(self.ranked_features()[:int(top_k)]) + return [c in keep for c in self.columns] + if threshold is not None: + return [self.scores.get(c, 0.0) >= float(threshold) for c in self.columns] + return [True] * len(self.columns) + + def get_support_names(self, cols: List[str], *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> List[str]: + mask = self.get_support_mask(top_k=top_k, threshold=threshold) + return [c for c, m in zip(self.columns, mask) if m] + + def transform(self, X: pd.DataFrame, *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> pd.DataFrame: + names = self.get_support_names(self.columns, top_k=top_k, threshold=threshold) + return X.loc[:, names] + + def get_scores(self) -> Dict[str, float]: + return dict(self.scores) + + def get_params(self) -> Dict[str, Any]: + params = { + "n_features_to_select": self.n_features_to_select, + "n_neighbors": self.n_neighbors, + "categorical_features": self.categorical_feature_indexes(), + "categorical_threshold": self.categorical_threshold, + "multiclass_threshold": self.multiclass_threshold, + "verbose": self.verbose, + "n_jobs": self.n_jobs, + "weight_final_scores": self.weight_final_scores, + "rank_absolute": self.rank_absolute, + "label_type": self.label_type, + "random_state": self.random_state, + "use_turf": self.use_turf, + "turf_pct": self.turf_pct, + "turf_num_scores_to_return": self.turf_num_scores_to_return, + } + params.update(self.kwargs or {}) + return params diff --git a/streamline/p4_feature_importance/registry/mutualinformation.py b/streamline/p4_feature_importance/registry/mutualinformation.py new file mode 100644 index 00000000..dcbbcb07 --- /dev/null +++ b/streamline/p4_feature_importance/registry/mutualinformation.py @@ -0,0 +1,77 @@ +# streamline/p4_feature_importance/registry/mutual_information.py +from __future__ import annotations +from typing import Dict, Any, List, Optional +import numpy as np +import pandas as pd +from sklearn.feature_selection import mutual_info_classif, mutual_info_regression + +from streamline.p4_feature_importance.utils.input_normalization import ( + normalize_feature_matrix, + normalize_target_vector, +) + +class MutualInformation: + id = "mutualinformation" + model_name = "Mutual Information" + small_name = "MI" + path_name = "mutualinformation" + + def __init__(self, outcome_type: str = "Binary", n_neighbors: int = 3, random_state: int | None = None, **kwargs): + self.outcome_type = outcome_type + self.n_neighbors = int(n_neighbors) + self.random_state = random_state + self.kwargs = kwargs + self._cols: List[str] = [] + self._scores: Dict[str, float] = {} + + def fit(self, X: pd.DataFrame, y: pd.Series): + self._cols = X.columns.tolist() + Xn = X.select_dtypes(include=["number"]) + cols = Xn.columns.tolist() + _, X_array = normalize_feature_matrix(Xn) + y_array = normalize_target_vector(y) + if self.outcome_type in ("Binary", "Multiclass"): + scores = mutual_info_classif( + X_array, + y_array, + n_neighbors=self.n_neighbors, + random_state=self.random_state, + ) + else: + scores = mutual_info_regression( + X_array, + y_array, + n_neighbors=self.n_neighbors, + random_state=self.random_state, + ) + self._scores = {c: float(s) for c, s in zip(cols, scores)} + for c in self._cols: + self._scores.setdefault(c, 0.0) + return self + + def _ranked(self) -> List[str]: + return sorted(self._cols, key=lambda c: self._scores.get(c,0.0), reverse=True) + + def get_support_mask(self, *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> List[bool]: + if top_k is not None: + keep = set(self._ranked()[:int(top_k)]) + return [c in keep for c in self._cols] + if threshold is not None: + return [self._scores.get(c,0.0) >= float(threshold) for c in self._cols] + return [True]*len(self._cols) + + def get_support_names(self, cols: List[str], *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> List[str]: + mask = self.get_support_mask(top_k=top_k, threshold=threshold) + return [c for c, m in zip(self._cols, mask) if m] + + def transform(self, X: pd.DataFrame, *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> pd.DataFrame: + names = self.get_support_names(self._cols, top_k=top_k, threshold=threshold) + return X.loc[:, names] + + def get_scores(self) -> Dict[str, float]: + return dict(self._scores) + + def get_params(self) -> Dict[str, Any]: + p = {"outcome_type": self.outcome_type, "n_neighbors": self.n_neighbors, "random_state": self.random_state} + p.update(self.kwargs or {}) + return p diff --git a/streamline/p4_feature_importance/utils/base_feature_importance.py b/streamline/p4_feature_importance/utils/base_feature_importance.py new file mode 100644 index 00000000..4ef2f634 --- /dev/null +++ b/streamline/p4_feature_importance/utils/base_feature_importance.py @@ -0,0 +1,21 @@ +# streamline/phases/p4_feature_selection/interface.py +from __future__ import annotations +from typing import Protocol, Dict, Any, Optional, List +import pandas as pd + +class Selector(Protocol): + id: str + def __init__(self, **params: Any): + pass + def fit(self, X: pd.DataFrame, y: pd.Series) -> "Selector": + pass + def transform(self, X: pd.DataFrame, *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> pd.DataFrame: + pass + def get_support_mask(self, *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> List[bool]: + pass + def get_support_names(self, cols: List[str], *, top_k: Optional[int] = None, threshold: Optional[float] = None) -> List[str]: + pass + def get_scores(self) -> Dict[str, float]: + pass + def get_params(self) -> Dict[str, Any]: + pass diff --git a/streamline/p4_feature_importance/utils/fi_loader.py b/streamline/p4_feature_importance/utils/fi_loader.py new file mode 100644 index 00000000..ff80ef24 --- /dev/null +++ b/streamline/p4_feature_importance/utils/fi_loader.py @@ -0,0 +1,75 @@ +# streamline/p4_feature_importance/utils/fi_loader.py +from __future__ import annotations +import importlib, inspect, os +from pathlib import Path +from types import ModuleType +from typing import Dict, Type, Optional + +PKG_BASE = "streamline.p4_feature_importance.registry" +FOLDER = Path(__file__).parent.parent / "registry" +__CACHE: Optional[Dict[str, Type]] = None + +def _is_selector_class(cls: type) -> bool: + need = ("fit","transform","get_support_mask","get_support_names","get_scores","get_params") + return inspect.isclass(cls) and hasattr(cls,"id") and all(hasattr(cls, m) for m in need) + +def _iter_modules(): + for f in os.listdir(FOLDER): + if f.endswith(".py") and f != "__init__.py": + yield f"{PKG_BASE}.{f[:-3]}" + +def _load(modname: str) -> Optional[ModuleType]: + try: return importlib.import_module(modname) + except Exception: return None + +def _discover() -> Dict[str, Type]: + found: Dict[str, Type] = {} + for modname in _iter_modules(): + mod = _load(modname) + if not mod: continue + for name in dir(mod): + cls = getattr(mod, name) + if _is_selector_class(cls) and getattr(cls, "__module__", "").startswith(modname): + found[cls.id] = cls + return found + +def list_importances() -> Dict[str, Type]: + global __CACHE + if __CACHE is None: __CACHE = _discover() + return dict(__CACHE) + +def normalize_importance_key(value: str) -> str: + return ( + str(value) + .strip() + .lower() + .replace(" ", "") + .replace("_", "") + .replace("-", "") + .replace("*", "star") + ) + +def resolve_importance_id(model_id: str) -> Optional[str]: + models = list_importances() + if model_id in models: + return model_id + + aliases: Dict[str, str] = {} + for mid, cls in models.items(): + for key in filter(None, [ + mid, + getattr(cls, "path_name", ""), + getattr(cls, "small_name", ""), + getattr(cls, "model_name", ""), + getattr(cls, "__name__", ""), + ]): + aliases[str(key).strip().lower()] = mid + aliases[normalize_importance_key(str(key))] = mid + return aliases.get(str(model_id).strip().lower()) or aliases.get(normalize_importance_key(model_id)) + +def load_importance(model_id: str, **params): + models = list_importances() + resolved = resolve_importance_id(model_id) + if resolved not in models: + raise ValueError(f"Feature-importance model '{model_id}' not found. Available: {', '.join(sorted(models))}") + return models[resolved](**params) diff --git a/streamline/p4_feature_importance/utils/input_normalization.py b/streamline/p4_feature_importance/utils/input_normalization.py new file mode 100644 index 00000000..e3c92b9d --- /dev/null +++ b/streamline/p4_feature_importance/utils/input_normalization.py @@ -0,0 +1,34 @@ +from __future__ import annotations + +from typing import Tuple + +import numpy as np +import pandas as pd + + +def normalize_feature_matrix(X: pd.DataFrame) -> Tuple[pd.DataFrame, np.ndarray]: + """ + Coerce a pandas feature matrix to a NumPy-friendly numeric representation. + + This keeps the DataFrame form for column bookkeeping inside STREAMLINE while + also producing a float64 ndarray for older third-party libraries that expect + plain numeric NumPy inputs. + """ + X_numeric = X.apply(pd.to_numeric, errors="coerce") + X_array = X_numeric.to_numpy(dtype=np.float64, na_value=np.nan) + return X_numeric, X_array + + +def normalize_target_vector(y: pd.Series) -> np.ndarray: + """ + Coerce outcome labels to a NumPy-friendly vector. + + Numeric targets stay numeric. Non-numeric classification labels are + factorized so NumPy/scikit-compatible arrays are always produced. + """ + if pd.api.types.is_numeric_dtype(y): + return pd.to_numeric(y, errors="coerce").to_numpy(dtype=np.float64, na_value=np.nan) + + labels, _ = pd.factorize(y) + return labels.astype(np.int64, copy=False) + diff --git a/streamline/p5_feature_selection/__init__.py b/streamline/p5_feature_selection/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/streamline/p5_feature_selection/feature_selection.py b/streamline/p5_feature_selection/feature_selection.py new file mode 100644 index 00000000..0413b01d --- /dev/null +++ b/streamline/p5_feature_selection/feature_selection.py @@ -0,0 +1,87 @@ +from __future__ import annotations +import os, time +import logging +from streamline.p5_feature_selection.utils.fs_loader import load_strategy + +class FeatureSelection: + """ + Phase 5: loads a selection strategy from registry (default: 'default') + and delegates the whole selection process. + """ + + def __init__( + self, + *, + dataset_dir: str, # // + n_splits: int, + algorithms: "list[str] | str", + outcome_label: str = "Class", + instance_label: "str | None" = None, + max_features_to_keep: int = 2000, + filter_poor_features: bool = True, + overwrite_cv: bool = False, + # strategy selection + selector_id: str = "default", + selector_params: "dict | None" = None, + # plotting / summary (forwarded to default strategy) + export_scores: bool = True, + top_features: int = 20, + show_plots: bool = False, + ): + self.dataset_dir = dataset_dir + self.dataset_name = os.path.basename(dataset_dir.rstrip("/")) + self.n_splits = int(n_splits) + self.algorithms = self._csv_to_list(algorithms) + self.outcome_label = outcome_label + self.instance_label = instance_label + self.max_features_to_keep = int(max_features_to_keep) + self.filter_poor_features = bool(filter_poor_features) + self.overwrite_cv = bool(overwrite_cv) + self.selector_id = selector_id or "default" + self.selector_params = selector_params or {} + # convenience forwarding defaults + self.selector_params.setdefault("export_scores", bool(export_scores)) + self.selector_params.setdefault("top_features", int(top_features)) + self.selector_params.setdefault("show_plots", bool(show_plots)) + self.job_start_time = time.time() + + def run(self): + logging.info( + "Phase 5 running selector '%s' for dataset '%s' with algorithms: %s", + self.selector_id, + self.dataset_name, + ", ".join(self.algorithms) if self.algorithms else "(none)", + ) + strat = load_strategy(self.selector_id, **self.selector_params) + strat.select( + dataset_dir=self.dataset_dir, + dataset_name=self.dataset_name, + n_splits=self.n_splits, + algorithms=self.algorithms, + outcome_label=self.outcome_label, + instance_label=self.instance_label, + max_features_to_keep=self.max_features_to_keep, + filter_poor_features=self.filter_poor_features, + overwrite_cv=self.overwrite_cv, + ) + self._save_runtime(); self._complete_flag() + logging.info("%s Phase 5 complete", self.dataset_name) + + # ---- helpers ---- + def _save_runtime(self): + rt_dir = os.path.join(self.dataset_dir, "runtime"); os.makedirs(rt_dir, exist_ok=True) + with open(os.path.join(rt_dir, "runtime_featureselection.txt"), "w") as f: + f.write(str(time.time() - self.job_start_time)) + + def _complete_flag(self): + exp_dir = os.path.dirname(self.dataset_dir.rstrip("/")) + os.makedirs(os.path.join(exp_dir, "jobsCompleted"), exist_ok=True) + with open(os.path.join(exp_dir, f"jobsCompleted/job_featureselection_{self.dataset_name}.txt"), "w") as f: + f.write("complete") + + @staticmethod + def _csv_to_list(v): + if v is None: return [] + if isinstance(v, list): return v + if isinstance(v, str): return [x.strip() for x in v.split(",") if x.strip()] + return list(v) diff --git a/streamline/p5_feature_selection/p5_cli.py b/streamline/p5_feature_selection/p5_cli.py new file mode 100644 index 00000000..593d242a --- /dev/null +++ b/streamline/p5_feature_selection/p5_cli.py @@ -0,0 +1,91 @@ +# streamline/phases/p5_feature_selection/cli.py (additions) +import argparse, json, os +from streamline.p5_feature_selection.p5_runner import P5Runner +from streamline.p5_feature_selection.utils.fi_resolver import _discover_algorithms +from streamline.utils.run_commands import ( + add_run_command_args, + apply_saved_run_command, + require_args, + save_run_command_from_args, + snapshot_args, +) + +def main(): + ap = argparse.ArgumentParser("STREAMLINE Phase 5 (Feature Selection) CLI", + formatter_class=argparse.ArgumentDefaultsHelpFormatter) + ap.add_argument("--output_path", required=True) + ap.add_argument("--experiment_name", required=True) + + # default now "auto" + ap.add_argument("--algorithms", default="auto", + help='Comma-separated (e.g. "MI,MS") OR "auto" to discover from feature_importance/*/') + ap.add_argument("--n_splits", default=None, type=int) + ap.add_argument("--outcome_label", default="Class") + ap.add_argument("--instance_label", default=None) + + ap.add_argument("--max_features_to_keep", default=2000, type=int) + ap.add_argument("--filter_poor_features", default=1, type=int) + ap.add_argument("--overwrite_cv", default=0, type=int) + + ap.add_argument("--selector_id", default="default") + ap.add_argument("--selector_params", default=None) + + ap.add_argument("--export_scores", default=1, type=int) + ap.add_argument("--top_features", default=20, type=int) + ap.add_argument("--show_plots", default=0, type=int) + + ap.add_argument("--run_cluster", default="Serial", help='Serial | Local | Parallel | BashSLURM | BashLSF | ') + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", default=4, type=int) + + # Convenience: print discovered algorithms and exit + ap.add_argument("--list-algorithms", action="store_true", + help="List discovered algorithms per dataset (ignores --run_cluster)") + add_run_command_args(ap) + + args = ap.parse_args() + args = apply_saved_run_command(ap, args, "p5_feature_selection") + require_args(ap, args, ["n_splits"]) + run_command_args = snapshot_args(args) + + if args.list_algorithms: + exp_root = os.path.join(args.output_path, args.experiment_name) + for name in sorted(os.listdir(exp_root)): + ds_dir = os.path.join(exp_root, name) + if not os.path.isdir(os.path.join(ds_dir, "CVDatasets")): + continue + algs = _discover_algorithms(ds_dir, args.n_splits, strict=False) + print(f"{name}: {', '.join(algs) if algs else '(none)'}") + return + + runner = P5Runner( + output_path=args.output_path, + experiment_name=args.experiment_name, + algorithms=args.algorithms, # "auto" supported + n_splits=args.n_splits, + outcome_label=args.outcome_label, + instance_label=args.instance_label, + max_features_to_keep=args.max_features_to_keep, + filter_poor_features=bool(args.filter_poor_features), + overwrite_cv=bool(args.overwrite_cv), + selector_id=args.selector_id or "default", + selector_params=json.loads(args.selector_params) if args.selector_params else None, + export_scores=bool(args.export_scores), + top_features=args.top_features, + show_plots=bool(args.show_plots), + run_cluster=args.run_cluster or "Serial", + queue=args.queue, + reserved_memory=args.reserved_memory, + ) + runner.run() + save_run_command_from_args(args, "p5_feature_selection", run_command_args, runner=runner) + + +if __name__ == "__main__": + + # # Serial run (use defaults from metadata.pickle) + # python -m streamline.p5_feature_selection.p5_cli \ + # --output_path ./test \ + # --experiment_name MyExp --show_plots 1 + + main() diff --git a/streamline/p5_feature_selection/p5_jobsubmit.py b/streamline/p5_feature_selection/p5_jobsubmit.py new file mode 100644 index 00000000..7dff19c8 --- /dev/null +++ b/streamline/p5_feature_selection/p5_jobsubmit.py @@ -0,0 +1,97 @@ +#!/usr/bin/env python +""" +STREAMLINE — Phase 5 (Feature Selection) job-submit +Runs a single dataset directory with the Phase 5 FeatureSelectionJob. +Intended to be launched by bash submit scripts (SLURM/LSF) or directly. +""" + +import argparse +import json +from streamline.p5_feature_selection.feature_selection import FeatureSelection + + +def _to_bool(v, default=False): + if v is None: + return default + if isinstance(v, bool): + return v + s = str(v).strip().lower() + if s in ("1", "true", "t", "yes", "y"): + return True + if s in ("0", "false", "f", "no", "n"): + return False + return default + + +def _to_dict(s): + if s is None: + return {} + if isinstance(s, dict): + return s + try: + d = json.loads(s) + return d if isinstance(d, dict) else {} + except Exception: + return {} + + +def build_parser(): + ap = argparse.ArgumentParser("P5 Feature Selection jobsubmit (single dataset)") + # Required + ap.add_argument("--dataset_dir", required=True, + help="Path to a single dataset folder: //") + ap.add_argument("--n_splits", required=True, type=int, + help="Number of CV splits") + ap.add_argument("--algorithms", default="auto", + help='Comma-separated ids/names or "auto" to discover from feature_importance/*') + + # Labels + ap.add_argument("--outcome_label", default="Class") + ap.add_argument("--instance_label", default=None) + + # Selection controls + ap.add_argument("--max_features_to_keep", default=2000, type=int) + ap.add_argument("--filter_poor_features", default="1", + help="Keep only features with score > 0 before capping (1/0, true/false)") + ap.add_argument("--overwrite_cv", default="0", + help="Overwrite CV CSVs instead of renaming to *_CVPre_* (1/0, true/false)") + + # Strategy (registry) + ap.add_argument("--selector_id", default="default", + help='Strategy id from registry (default: "default")') + ap.add_argument("--selector_params", default=None, + help="JSON dict of extra params for the strategy (e.g., {'export_scores': true})") + + # Plotting/summary (forwarded to default strategy) + ap.add_argument("--export_scores", default="1", + help="Write TopAverageScores.png per algorithm (1/0, true/false)") + ap.add_argument("--top_features", default=20, type=int, + help="Top-N features to visualize in the median score plot") + ap.add_argument("--show_plots", default="0", + help="Render plots to screen (usually off on HPC) (1/0, true/false)") + return ap + + +def main(): + ap = build_parser() + args = ap.parse_args() + + FeatureSelection( + dataset_dir=args.dataset_dir, + n_splits=int(args.n_splits), + algorithms=args.algorithms, # CSV string OK + outcome_label=args.outcome_label, + instance_label=(args.instance_label if args.instance_label else None), + max_features_to_keep=int(args.max_features_to_keep), + filter_poor_features=_to_bool(args.filter_poor_features, True), + overwrite_cv=_to_bool(args.overwrite_cv, False), + selector_id=(args.selector_id or "default"), + selector_params=_to_dict(args.selector_params), + export_scores=_to_bool(args.export_scores, True), + top_features=int(args.top_features), + show_plots=_to_bool(args.show_plots, False), + ).run() + + +if __name__ == "__main__": + main() diff --git a/streamline/p5_feature_selection/p5_runner.py b/streamline/p5_feature_selection/p5_runner.py new file mode 100644 index 00000000..7a615dc3 --- /dev/null +++ b/streamline/p5_feature_selection/p5_runner.py @@ -0,0 +1,221 @@ +# streamline/phases/p5_feature_selection/runner.py (replace the class with this version) +from __future__ import annotations +import os, time, json +from pathlib import Path +from typing import Optional, List + +import dask +from dask.distributed import Client, LocalCluster +import logging + +from streamline.utils.runners import num_cores, run_dask_tasks, run_parallel_items +from streamline.utils.cluster import get_cluster +from streamline.p5_feature_selection.feature_selection import FeatureSelection +from streamline.p5_feature_selection.utils.fi_resolver import _normalize_algorithms, _discover_algorithms + + + +class P5Runner: + """ + Phase 5 runner: one job per dataset directory. + + run_cluster modes: + • "Serial" (default) + • "Local" + • "Parallel" + • "BashSLURM" + • "BashLSF" + • "" → use get_cluster(name, ...) + """ + def __init__( + self, + output_path: str, + experiment_name: str, + *, + algorithms: "List[str] | str | None" = "auto", # <-- default auto + n_splits: int = 10, + outcome_label: str = "Class", + instance_label: Optional[str] = None, + max_features_to_keep: int = 2000, + filter_poor_features: bool = True, + overwrite_cv: bool = False, + # strategy + selector_id: str = "default", + selector_params: "dict | None" = None, + # plotting/summary + export_scores: bool = True, + top_features: int = 20, + show_plots: bool = False, + # submission / cluster + run_cluster: str = "Serial", + queue: str = "defq", + reserved_memory: int = 4, + # discovery behavior + strict_discovery: bool = False, # require all n_splits files present for an algorithm + ): + self.output_path = output_path + self.experiment_name = experiment_name + self._algorithms_raw = algorithms # keep raw for "auto" + self.n_splits = int(n_splits) + self.outcome_label = outcome_label + self.instance_label = instance_label + self.max_features_to_keep = int(max_features_to_keep) + self.filter_poor_features = bool(filter_poor_features) + self.overwrite_cv = bool(overwrite_cv) + self.selector_id = selector_id or "default" + self.selector_params = selector_params or {} + self.export_scores = bool(export_scores) + self.top_features = int(top_features) + self.show_plots = bool(show_plots) + + self.run_cluster = run_cluster or "Serial" + self.queue = queue + self.reserved_memory = int(reserved_memory) + self.strict_discovery = bool(strict_discovery) + + self.exp_root = os.path.join(self.output_path, self.experiment_name) + if not os.path.isdir(self.exp_root): + raise Exception("Experiment must exist before phase 5 can begin") + + if self.run_cluster in ("BashSLURM","BashLSF"): + os.makedirs(os.path.join(self.exp_root, "jobs"), exist_ok=True) + os.makedirs(os.path.join(self.exp_root, "logs"), exist_ok=True) + + # ---------------------------- + # Main + # ---------------------------- + def run(self): + logging.info("Phase 5 starting for experiment '%s'.", self.experiment_name) + datasets = [ + os.path.join(self.exp_root, name) + for name in sorted(os.listdir(self.exp_root)) + if os.path.isdir(os.path.join(self.exp_root, name)) + and name not in {"jobsCompleted","jobs","logs","dask_logs","DatasetComparisons"} + and os.path.isdir(os.path.join(self.exp_root, name, "CVDatasets")) + ] + if not datasets: + logging.warning("No datasets found for Phase 5 under %s", self.exp_root) + return + logging.info("Phase 5 discovered %d dataset(s).", len(datasets)) + + mode = str(self.run_cluster) + if mode == "Serial": + for ds_dir in datasets: + self._run_one(ds_dir) + elif mode == "Local": + n_workers = num_cores + with LocalCluster(processes=True, n_workers=n_workers, threads_per_worker=1) as cluster: + with Client(cluster) as client: + tasks = [dask.delayed(self._run_one)(ds_dir) for ds_dir in datasets] + run_dask_tasks(tasks, client, label="Phase 5 Dask jobs") + elif mode == "Parallel": + run_parallel_items(self._run_one, datasets, label="Phase 5 Parallel jobs") + elif mode in ("BashSLURM","BashLSF"): + for ds_dir in datasets: + # discover now so the submitted script has a concrete list + algs = self._resolve_algorithms_for_dataset(ds_dir) + if not algs: + logging.warning("Skipping dataset with no discovered algorithms: %s", ds_dir) + continue + self._submit_bash_job(ds_dir, mode, algs) + else: + client: Client = get_cluster( + mode, + os.path.join(self.output_path, self.experiment_name), + self.queue, + self.reserved_memory + ) + tasks = [dask.delayed(self._run_one)(ds_dir) for ds_dir in datasets] + run_dask_tasks(tasks, client, label="Phase 5 Dask jobs") + logging.info("Phase 5 completed for experiment '%s'.", self.experiment_name) + + # ---------------------------- + # Helpers + # ---------------------------- + def _resolve_algorithms_for_dataset(self, dataset_dir: str) -> List[str]: + """Return algorithms to use for this dataset.""" + if self._algorithms_raw in (None, "", "auto", "AUTO", "Auto"): + algs = _discover_algorithms(dataset_dir, self.n_splits, strict=self.strict_discovery) + if not algs: + logging.warning("Phase 5 auto-discovery found no algorithms in %s/feature_importance", dataset_dir) + else: + logging.info("Phase 5 discovered algorithms for %s: %s", + os.path.basename(dataset_dir), ", ".join(algs)) + return algs + # normalize any user-specified list/CSV (map MI→mutualinformation etc.) + return _normalize_algorithms(self._algorithms_raw) + + def _run_one(self, dataset_dir: str): + algs = self._resolve_algorithms_for_dataset(dataset_dir) + if not algs: + logging.warning("No algorithms to run in dataset %s; skipping.", dataset_dir) + return + dataset_name = os.path.basename(dataset_dir) + logging.info( + "Phase 5 running on dataset %s with algorithms: %s", + dataset_name, + ", ".join(algs), + ) + + FeatureSelection( + dataset_dir=dataset_dir, + n_splits=self.n_splits, + algorithms=algs, # pass concrete list + outcome_label=self.outcome_label, + instance_label=self.instance_label, + max_features_to_keep=self.max_features_to_keep, + filter_poor_features=self.filter_poor_features, + overwrite_cv=self.overwrite_cv, + selector_id=self.selector_id, + selector_params=self.selector_params, + export_scores=self.export_scores, + top_features=self.top_features, + show_plots=self.show_plots, + ).run() + logging.info("Phase 5 completed for dataset %s.", dataset_name) + + def _submit_bash_job(self, dataset_dir: str, mode: str, algorithms_for_ds: List[str]): + job_ref = str(time.time()) + run_dir = self.exp_root + job_name = os.path.join(run_dir, f'jobs/P5_{job_ref}_run.sh') + launcher = 'sbatch' if mode == "BashSLURM" else 'bsub <' + + script_path = str(Path(__file__).parent / "p5_jobsubmit.py") + args = [ + "python", script_path, + "--dataset_dir", dataset_dir, + "--n_splits", str(self.n_splits), + "--algorithms", ",".join(algorithms_for_ds), + "--outcome_label", self.outcome_label or "Class", + "--instance_label", self.instance_label or "", + "--max_features_to_keep", str(self.max_features_to_keep), + "--filter_poor_features", "1" if self.filter_poor_features else "0", + "--overwrite_cv", "1" if self.overwrite_cv else "0", + "--selector_id", self.selector_id or "default", + "--selector_params", json.dumps(self.selector_params or {}), + "--export_scores", "1" if self.export_scores else "0", + "--top_features", str(self.top_features), + "--show_plots", "1" if self.show_plots else "0", + ] + cmd = " ".join(args) + + with open(job_name, "w") as sh: + sh.write("#!/bin/bash\n") + if mode == "BashSLURM": + sh.write(f"#SBATCH -p {self.queue}\n") + sh.write(f"#SBATCH --job-name={job_ref}\n") + sh.write(f"#SBATCH --mem={self.reserved_memory}G\n") + sh.write(f"#SBATCH -o {run_dir}/logs/P5_{job_ref}.o\n") + sh.write(f"#SBATCH -e {run_dir}/logs/P5_{job_ref}.e\n") + sh.write("srun " + cmd + "\n") + else: + sh.write(f"#BSUB -q {self.queue}\n") + sh.write(f"#BSUB -J {job_ref}\n") + sh.write(f"#BSUB -R \"rusage[mem={self.reserved_memory}G]\"\n") + sh.write(f"#BSUB -M {self.reserved_memory}GB\n") + sh.write(f"#BSUB -o {run_dir}/logs/P5_{job_ref}.o\n") + sh.write(f"#BSUB -e {run_dir}/logs/P5_{job_ref}.e\n") + sh.write(cmd + "\n") + + os.system(f"{launcher} {job_name}") + logging.info("Phase 5 submitted cluster job script: %s", job_name) diff --git a/streamline/p5_feature_selection/registry/default.py b/streamline/p5_feature_selection/registry/default.py new file mode 100644 index 00000000..e50326ce --- /dev/null +++ b/streamline/p5_feature_selection/registry/default.py @@ -0,0 +1,209 @@ +from __future__ import annotations +import os +import logging +from typing import Dict, List, Tuple, Optional +import pandas as pd +import numpy as np +import matplotlib +import seaborn as sns +sns.set_theme(style="whitegrid") +import matplotlib.pyplot as plt +from statistics import median +from streamline.p5_feature_selection.utils.fi_resolver import resolve_algorithms + + +class DefaultFeatureSelector: + """ + Implements Phase-5 selection: + • load P4 scores (per-CV, per-alg) from CSV + • median-aggregate, plot top-N (optional) + • union of informative (score>0) per CV across algs + • cap via round-robin of ranked lists to max_features_to_keep + • write filtered CV CSVs + """ + id = "default" + model_name = "Default Feature Selection" + small_name = "Default" + path_name = "default" + + def __init__(self, *, export_scores: bool = True, top_features: int = 20, show_plots: bool = False): + self.export_scores = bool(export_scores) + self.top_features = int(top_features) + self.show_plots = bool(show_plots) + + # ---- public API expected by the job ---- + def select( + self, + *, + dataset_dir: str, + dataset_name: str, + n_splits: int, + algorithms: List[str], + outcome_label: str, + instance_label: str | None, + max_features_to_keep: int, + filter_poor_features: bool, + overwrite_cv: bool, + ): + algs = resolve_algorithms(dataset_dir, algorithms) + fs_root = os.path.join(dataset_dir, "feature_importance") + out_root = os.path.join(dataset_dir, "feature_selection") + os.makedirs(out_root, exist_ok=True) + + selected_feature_lists: Dict[str, List[List[str]]] = {} + meta_feature_ranks: Dict[str, List[List[str]]] = {} + for alg in algs: + keep_per_cv, ranks_per_cv, med_table = self._collect_scores(fs_root, alg, n_splits) + selected_feature_lists[alg] = keep_per_cv + meta_feature_ranks[alg] = ranks_per_cv + if self.export_scores and med_table is not None: + logging.info("Plotting Feature Importance Scores for %s...", alg) + logging.info("%s", med_table.head(10).to_string(index=False)) + self._plot_top_medians(fs_root, alg, med_table) + logging.info("Saved Feature Importance Plots at") + logging.info("%s", os.path.join(fs_root, alg, "TopAverageScores.png")) + + if not filter_poor_features or not algs: + return # nothing else to do + + logging.info("Applying collective feature selection...") + cv_selected_list, informative_counts, uninformative_counts = self._select_union_cap( + selected_feature_lists, max_features_to_keep, meta_feature_ranks, algs, n_splits + ) + self._write_info_counts(out_root, informative_counts, uninformative_counts) + self._write_filtered_cv(dataset_dir, dataset_name, n_splits, outcome_label, instance_label, cv_selected_list, overwrite_cv) + + # ---- internals ---- + def _score_csv(self, root: str, alg: str, cv: int) -> str: + return os.path.join(root, alg, f"{alg}_scores_cv_{cv}.csv") + + def _collect_scores(self, root: str, alg: str, n_splits: int): + keep_per_cv: List[List[str]] = [] + ranks_per_cv: List[List[str]] = [] + per_feature: Dict[str, List[float]] = {} + + for i in range(n_splits): + path = self._score_csv(root, alg, i) + if not os.path.exists(path): + raise FileNotFoundError(f"Missing Phase 4 scores: {path}") + df = pd.read_csv(path).dropna(subset=["feature"]).copy() + if "score" not in df.columns: + df["score"] = 0.0 + df["score"] = df["score"].astype(float) + df_sorted = df.sort_values("score", ascending=False) + ranks_per_cv.append(df_sorted["feature"].tolist()) + keep_per_cv.append(df_sorted.loc[df_sorted["score"] > 0.0, "feature"].tolist()) + for _, r in df.iterrows(): + per_feature.setdefault(str(r["feature"]), []).append(float(r["score"])) + + med_table = None + if self.export_scores: + med_table = ( + pd.DataFrame([(f, median(v)) for f, v in per_feature.items()], columns=["Feature", "Importance"]) + .sort_values("Importance", ascending=False) + ) + return keep_per_cv, ranks_per_cv, med_table + + def _plot_top_medians(self, root: str, alg: str, table: pd.DataFrame): + out_dir = os.path.join(root, alg); os.makedirs(out_dir, exist_ok=True) + ns = table.head(self.top_features) + plt.figure(figsize=(7, max(4, 0.35 * len(ns)))) + plt.barh(ns["Feature"][::-1], ns["Importance"][::-1]) + title = {"mutualinformation": "Mutual Information", + "multisurf": "MultiSURF", + "multisurfstar": "MultiSURF*", + "multiswrfdb": "MultiSWRFDB", + "multiswrfdbstar": "MultiSWRFDB*"}.get(alg, alg) + plt.xlabel("Median Score"); plt.title(f"Sorted Median {title} Scores") + plt.tight_layout(); plt.savefig(os.path.join(out_dir, "TopAverageScores.png"), bbox_inches="tight") + if self.show_plots: plt.show() + plt.close() + + def _select_union_cap( + self, + selected_feature_lists: Dict[str, List[List[str]]], + max_features_to_keep: int, + meta_feature_ranks: Dict[str, List[List[str]]], + alg_order: List[str], + n_splits: int, + ): + cv_selected_list: List[List[str]] = [] + informative_counts: List[int] = [] + uninformative_counts: List[int] = [] + try: + total_features = len(meta_feature_ranks[alg_order[0]][0]) + except Exception: + total_features = 0 + + if len(alg_order) > 1: + for i in range(n_splits): + union = set() + for alg in alg_order: union.update(selected_feature_lists[alg][i]) + union_list = list(union) + informative_counts.append(len(union_list)) + uninformative_counts.append(max(0, total_features - len(union_list))) + if len(union_list) > max_features_to_keep: + new_list, seen, k = [], set(), 0 + while len(new_list) < max_features_to_keep: + progressed = False + for alg in alg_order: + rl = meta_feature_ranks[alg][i] + if k < len(rl): + cand = rl[k] + if cand not in seen and cand in union: + new_list.append(cand); seen.add(cand); progressed = True + if len(new_list) >= max_features_to_keep: break + if not progressed: break + k += 1 + union_list = new_list + union_list.sort() + cv_selected_list.append(union_list) + else: + single = alg_order[0] + for i in range(n_splits): + base = list(selected_feature_lists[single][i]) + informative_counts.append(len(base)) + uninformative_counts.append(max(0, total_features - len(base))) + if len(base) > max_features_to_keep: + rl = meta_feature_ranks[single][i] + new_list, k = [], 0 + while len(new_list) < max_features_to_keep and k < len(rl): + if rl[k] in base: new_list.append(rl[k]) + k += 1 + base = new_list + base.sort(); cv_selected_list.append(base) + + return cv_selected_list, informative_counts, uninformative_counts + + def _write_info_counts(self, out_root: str, inf: List[int], uninf: List[int]): + pd.DataFrame({"Informative": inf, "Uninformative": uninf}).to_csv( + os.path.join(out_root, "InformativeFeatureSummary.csv"), index_label="CV_Partition" + ) + + def _write_filtered_cv( + self, + dataset_dir: str, + dataset_name: str, + n_splits: int, + outcome_label: str, + instance_label: "str | None", + cv_selected_list: List[List[str]], + overwrite_cv: bool, + ): + cv_dir = os.path.join(dataset_dir, "CVDatasets") + for i in range(n_splits): + tr = os.path.join(cv_dir, f"{dataset_name}_CV_{i}_Train.csv") + te = os.path.join(cv_dir, f"{dataset_name}_CV_{i}_Test.csv") + if not (os.path.exists(tr) and os.path.exists(te)): + raise FileNotFoundError(f"Missing CV files for i={i}: {tr} / {te}") + df_tr = pd.read_csv(tr, na_values="NA"); df_te = pd.read_csv(te, na_values="NA") + labels = [outcome_label] + ([instance_label] if (instance_label and instance_label in df_tr.columns) else []) + feat_keep = [f for f in cv_selected_list[i] if f in df_tr.columns] + td_train = df_tr.loc[:, labels + feat_keep]; td_test = df_te.loc[:, labels + feat_keep] + if overwrite_cv: + os.remove(tr); os.remove(te) + else: + os.rename(tr, os.path.join(cv_dir, f"{dataset_name}_CVPre_{i}_Train.csv")) + os.rename(te, os.path.join(cv_dir, f"{dataset_name}_CVPre_{i}_Test.csv")) + td_train.to_csv(os.path.join(cv_dir, f"{dataset_name}_CV_{i}_Train.csv"), index=False) + td_test.to_csv(os.path.join(cv_dir, f"{dataset_name}_CV_{i}_Test.csv"), index=False) diff --git a/streamline/p5_feature_selection/utils/fi_resolver.py b/streamline/p5_feature_selection/utils/fi_resolver.py new file mode 100644 index 00000000..8819853f --- /dev/null +++ b/streamline/p5_feature_selection/utils/fi_resolver.py @@ -0,0 +1,176 @@ +# streamline/phases/p5_feature_selection/utils.py +from __future__ import annotations +import os +from typing import Dict, List, Tuple, Optional + +def normalize_algorithm_key(value: str) -> str: + return ( + str(value) + .strip() + .lower() + .replace(" ", "") + .replace("_", "") + .replace("-", "") + .replace("*", "star") + ) + +def _safe_list_models() -> Dict[str, type]: + """ + Try to import the Phase-4 loader and list models (id -> class). + Falls back to {} if p4 is not installed/available. + """ + try: + from streamline.p4_feature_importance.utils.fi_loader import list_importances # type: ignore + return list_importances() or {} + except Exception: + return {} + +def _build_alias_map(models: Dict[str, type]) -> Dict[str, str]: + """ + Build a dictionary mapping aliases (id, small_name, path_name, model_name) + to the canonical path_name (i.e., folder name under feature_importance/). + """ + alias: Dict[str, str] = {} + for mid, cls in models.items(): + path_name = getattr(cls, "path_name", mid).strip().lower() + small = getattr(cls, "small_name", "").strip() + mname = getattr(cls, "model_name", "").strip() + + for key in filter(None, [ + mid, + path_name, + small, + mname, + getattr(cls, "__name__", "").strip(), + ]): + alias[key.lower()] = path_name + alias[normalize_algorithm_key(key)] = path_name + return alias + +def _scan_fs_algorithms(fs_root: str) -> List[str]: + """ + Return a list of subfolders under feature_importance/, which correspond to available algorithms. + """ + if not os.path.isdir(fs_root): + return [] + return sorted([ + name for name in os.listdir(fs_root) + if os.path.isdir(os.path.join(fs_root, name)) + and not name.startswith(".") + ]) + +def resolve_algorithms(dataset_dir: str, algorithms: Optional[str | List[str]]) -> List[str]: + """ + Resolve user-provided algorithms to Phase-4 path_names, dynamically. + - If algorithms is None or 'auto', discover from filesystem: feature_importance/*/ . + - Else, map each token against P4 registry (id/small_name/path_name/model_name), + falling back to filesystem names when needed. + Returns a list of unique path_names (folder names). + """ + fs_root = os.path.join(dataset_dir, "feature_importance") + models = _safe_list_models() + alias = _build_alias_map(models) # alias -> path_name + available_fs = set(_scan_fs_algorithms(fs_root)) + + # Auto-discover everything present + if algorithms is None or (isinstance(algorithms, str) and algorithms.strip().lower() == "auto"): + return sorted(list(available_fs)) + + # Normalize CSV/string/list to tokens + if isinstance(algorithms, str): + tokens = [t.strip() for t in algorithms.split(",") if t.strip()] + else: + tokens = [str(t).strip() for t in algorithms if str(t).strip()] + + resolved: List[str] = [] + seen = set() + for tok in tokens: + key = tok.lower() + # try registry alias (id/small/safe names) + pn = alias.get(key) or alias.get(normalize_algorithm_key(tok)) + if pn is None: + # if user passed a folder name, and it exists, accept it + if key in available_fs: + pn = key + else: + # last resort: strip spaces/normalize and see if present + key2 = key.replace(" ", "") + pn = key2 if key2 in available_fs else None + if pn and pn not in seen: + resolved.append(pn) + seen.add(pn) + + # If nothing resolved AND user asked explicitly, surface a helpful error + if not resolved: + msg = "No algorithms resolved. Known (P4 registry): " + if alias: + msg += ", ".join(sorted(set(alias.keys()))) + ". " + if available_fs: + msg += "Found on disk: " + ", ".join(sorted(available_fs)) + raise ValueError(msg) + + return resolved + +# streamline/phases/p5_feature_selection/runner.py (add near top) +import glob +import logging + +# If someone passes small names, map → folder names used by Phase 4 +ALG_MAP = { + "MI": "mutualinformation", + "MS": "multisurf", + "MS*": "multisurfstar", + "MSS": "multisurfstar", + "MULTISURF": "multisurf", + "MULTISURF*": "multisurfstar", + "MULTISURFSTAR": "multisurfstar", + "MSWRFDB": "multiswrfdb", + "MSWRFDB*": "multiswrfdbstar", + "MULTISWRFDB": "multiswrfdb", + "MULTISWRFDB*": "multiswrfdbstar", + "MULTISWRFDBSTAR": "multiswrfdbstar", +} + +def _normalize_algorithms(algorithms): + """Accept list or CSV; map small names to path names; dedupe/preserve order.""" + if algorithms is None: + return None + if isinstance(algorithms, str): + algorithms = [a.strip() for a in algorithms.split(",") if a.strip()] + out, seen = [], set() + for a in algorithms: + key = str(a).strip() + a = ALG_MAP.get( + key, + ALG_MAP.get(key.upper(), ALG_MAP.get(normalize_algorithm_key(key).upper(), key)), + ) + if a not in seen: + out.append(a); seen.add(a) + return out + +def _discover_algorithms(dataset_dir: str, n_splits: int, strict: bool = False): + """ + Scan /feature_importance/*/ for *_scores_cv_*.csv files. + If strict=True, require exactly n_splits files per algorithm. + Returns list of folder names (e.g., ["mutualinformation","multisurf"]). + """ + root = os.path.join(dataset_dir, "feature_importance") + if not os.path.isdir(root): + return [] + algs = [] + for name in sorted(os.listdir(root)): + alg_dir = os.path.join(root, name) + if not os.path.isdir(alg_dir): + continue + # match the Phase 4 file convention + pattern = os.path.join(alg_dir, f"{name}_scores_cv_*.csv") + files = glob.glob(pattern) + if not files: + continue + if strict: + # keep only if we have all splits 0..n_splits-1 + expected = [os.path.join(alg_dir, f"{name}_scores_cv_{i}.csv") for i in range(n_splits)] + if not all(os.path.exists(p) for p in expected): + continue + algs.append(name) + return algs diff --git a/streamline/p5_feature_selection/utils/fs_loader.py b/streamline/p5_feature_selection/utils/fs_loader.py new file mode 100644 index 00000000..be5d8915 --- /dev/null +++ b/streamline/p5_feature_selection/utils/fs_loader.py @@ -0,0 +1,43 @@ +from __future__ import annotations +import importlib, inspect, os +from pathlib import Path +from types import ModuleType +from typing import Dict, Type, Optional + +PKG = "streamline.p5_feature_selection.registry" +FOLDER = Path(__file__).parent.parent / "registry" +_CACHE: Optional[Dict[str, Type]] = None + +def _is_strategy(cls: type) -> bool: + need = ("select",) # one public entrypoint + return inspect.isclass(cls) and hasattr(cls, "id") and all(hasattr(cls, m) for m in need) + +def _iter_modules(): + for f in os.listdir(FOLDER): + if f.endswith(".py") and f not in {"__init__.py", "loader.py"}: + yield f"{PKG}.{f[:-3]}" + +def _try_import(modname: str) -> Optional[ModuleType]: + try: return importlib.import_module(modname) + except Exception: return None + +def _discover() -> Dict[str, Type]: + found: Dict[str, Type] = {} + for mod in map(_try_import, _iter_modules()): + if not mod: continue + for name in dir(mod): + cls = getattr(mod, name) + if _is_strategy(cls) and getattr(cls, "__module__", "").startswith(mod.__name__): + found[cls.id] = cls + return found + +def list_strategies() -> Dict[str, Type]: + global _CACHE + if _CACHE is None: _CACHE = _discover() + return dict(_CACHE) + +def load_strategy(selector_id: str, **params): + strategies = list_strategies() + if selector_id not in strategies: + raise ValueError(f"Unknown P5 selector '{selector_id}'. Available: {', '.join(sorted(strategies))}") + return strategies[selector_id](**params) diff --git a/streamline/p6_modeling/__init__.py b/streamline/p6_modeling/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/streamline/p6_modeling/modeling.py b/streamline/p6_modeling/modeling.py new file mode 100644 index 00000000..1507e5c2 --- /dev/null +++ b/streamline/p6_modeling/modeling.py @@ -0,0 +1,396 @@ +from __future__ import annotations +import os +import json +import logging +import pickle +import warnings +from typing import List, Optional, Dict, Any +from streamline.p6_modeling.utils.modeljob import ModelJob +from streamline.p6_modeling.utils.loader import load_default_model_classes, get_model_by_id +from streamline.p6_modeling.utils.categorical import ( + NATIVE_CATEGORICAL_MODEL_IDS_DEFAULT, + NATIVE_CATEGORICAL_MODELS_DEFAULT, + normalize_model_id, + parse_model_id_csv, +) + +def csv_to_list(v): + if v is None: return None + if isinstance(v, list): return v + return [x.strip() for x in str(v).split(",") if x.strip()] + + +def parse_model_params_json(model_params_json) -> Dict[str, Dict[str, Any]]: + model_params: Dict[str, Dict[str, Any]] = {} + if not model_params_json: + return model_params + try: + parsed = model_params_json if isinstance(model_params_json, dict) else json.loads(model_params_json) + except Exception as exc: + logging.error("[P6] Failed to parse model_params_json: %r", exc) + raise + + if isinstance(parsed, dict): + return { + str(key).lower(): (value if isinstance(value, dict) else {}) + for key, value in parsed.items() + } + logging.warning( + "[P6] model_params_json must be a JSON object mapping model ids → dicts; got %r", + type(parsed), + ) + return model_params + + +def load_feature_metadata(dataset_dir: str, dataset_name: str | None = None) -> Dict[str, Any]: + exploratory = os.path.join(dataset_dir, "exploratory") + meta_pickle = os.path.join(exploratory, "feature_meta.pickle") + meta_json = os.path.join(exploratory, "feature_meta.json") + try: + if os.path.exists(meta_pickle): + with open(meta_pickle, "rb") as f: + payload = pickle.load(f) + return payload if isinstance(payload, dict) else {} + if os.path.exists(meta_json): + with open(meta_json, "r") as f: + payload = json.load(f) + return payload if isinstance(payload, dict) else {} + except Exception as exc: + label = dataset_name or os.path.basename(dataset_dir.rstrip("/")) + logging.warning("[P6] Could not read feature metadata for %s: %s", label, exc) + return {} + + +def p1_one_hot_is_disabled(feature_meta: Dict[str, Any]) -> bool: + if "one_hot" not in feature_meta: + return False + value = feature_meta.get("one_hot") + if isinstance(value, bool): + return not value + return str(value).strip().lower() in {"0", "false", "f", "no", "n"} + + +def model_class_label(ModelCls) -> str: + small = getattr(ModelCls, "small_name", "") + name = getattr(ModelCls, "model_name", "") + if small and name: + return f"{small} ({name})" + return small or name or str(ModelCls) + + +def model_class_is_tabpfn(ModelCls) -> bool: + ids = { + normalize_model_id(getattr(ModelCls, "small_name", "")), + normalize_model_id(getattr(ModelCls, "model_name", "")), + } + return any("tabpfn" in value for value in ids) + + +def model_class_supports_native_categorical(ModelCls, native_categorical_model_ids) -> bool: + ids = { + normalize_model_id(getattr(ModelCls, "small_name", "")), + normalize_model_id(getattr(ModelCls, "model_name", "")), + } + return bool(ids.intersection(native_categorical_model_ids)) + + +def skip_tabpfn_models_without_token(model_classes, dataset_name: str): + if os.environ.get("TABPFN_TOKEN"): + return model_classes + + kept = [] + skipped = [] + for ModelCls in model_classes: + if model_class_is_tabpfn(ModelCls): + skipped.append(model_class_label(ModelCls)) + else: + kept.append(ModelCls) + + if skipped: + message = ( + "WARNING: TABPFN_TOKEN is not set, so Phase 6 will skip " + f"TabPFN model fitting for {', '.join(skipped)}. HEROS and " + "other requested non-TabPFN models will still run. See " + "docs/source/tabpfn_token.md." + ) + logging.warning(message) + warnings.warn(message, RuntimeWarning, stacklevel=2) + + if not kept: + logging.warning( + "[P6] No models remain for %s after skipping token-gated models.", + dataset_name, + ) + return kept + + +def resolve_model_classes_for_dataset( + *, + dataset_dir: str, + model_type: str, + models: List[str] | str | None, + bypass_one_hot_for_native_models: bool, + native_categorical_models: List[str] | str | None, +): + dataset_name = os.path.basename(dataset_dir.rstrip("/")) + requested_models = csv_to_list(models) + native_model_ids = parse_model_id_csv( + native_categorical_models, + default=NATIVE_CATEGORICAL_MODEL_IDS_DEFAULT, + ) + one_hot_disabled = p1_one_hot_is_disabled(load_feature_metadata(dataset_dir, dataset_name)) + if one_hot_disabled and not bypass_one_hot_for_native_models: + raise ValueError( + "P1 feature metadata shows one_hot_encoding=False. Phase 6 must use " + "native categorical models in this mode; keep " + "--bypass_one_hot_for_native_models enabled or rerun P1 with " + "--one_hot_encoding 1." + ) + + if requested_models: + model_classes = [get_model_by_id(model_type, model_id) for model_id in requested_models] + if one_hot_disabled: + unsupported = [ + cls for cls in model_classes + if not model_class_supports_native_categorical(cls, native_model_ids) + ] + if unsupported: + raise ValueError( + "P1 feature metadata shows one_hot_encoding=False, so Phase 6 " + "can only run models listed in --native_categorical_models. " + "Unsupported requested model(s): " + + ", ".join(model_class_label(cls) for cls in unsupported) + + ". Native categorical model ids: " + + ", ".join(sorted(native_model_ids)) + ) + else: + model_classes = load_default_model_classes(model_type) + if one_hot_disabled: + original_count = len(model_classes) + model_classes = [ + cls for cls in model_classes + if model_class_supports_native_categorical(cls, native_model_ids) + ] + if not model_classes: + raise ValueError( + "P1 feature metadata shows one_hot_encoding=False, but no " + f"{model_type} models match native_categorical_models=" + f"{sorted(native_model_ids)}." + ) + logging.info( + "[P6] P1 one_hot_encoding=False for %s; limiting auto-discovered " + "models from %s to native categorical models: %s", + dataset_name, + original_count, + ", ".join(model_class_label(cls) for cls in model_classes), + ) + + return skip_tabpfn_models_without_token(model_classes, dataset_name) + + +def model_overrides_for_class(ModelCls, model_params: Dict[str, Dict[str, Any]]) -> Dict[str, Any]: + overrides: Dict[str, Any] = {} + small = getattr(ModelCls, "small_name", "").lower() + model_name = getattr(ModelCls, "model_name", "").lower() + + for key in (small, model_name): + if key and key in model_params: + config = model_params[key] + if isinstance(config, dict): + overrides.update(config) + + return overrides + + +def create_model_instance(ModelCls, *, random_state, scoring_metric, metric_direction, model_params): + model = ModelCls( + random_state=random_state, + n_jobs=None, + scoring_metric=scoring_metric, + metric_direction=metric_direction, + ) + + for attr, value in model_overrides_for_class(ModelCls, model_params).items(): + setattr(model, attr, value) + + return model + + +def model_class_matching_id(model_classes, model_id: str): + requested = str(model_id or "") + for ModelCls in model_classes: + if requested in { + getattr(ModelCls, "small_name", ""), + getattr(ModelCls, "model_name", ""), + }: + return ModelCls + return None + + +def model_cv_flag_path(dataset_dir: str, model_small_name: str, cv_idx: int): + dataset_name = os.path.basename(dataset_dir.rstrip("/")) + return os.path.join( + os.path.dirname(dataset_dir), + "jobsCompleted", + f"job_model_{dataset_name}_{cv_idx}_{model_small_name}.txt", + ) + + +def mark_modeling_phase_complete(dataset_dir: str): + dataset_name = os.path.basename(dataset_dir.rstrip("/")) + jobs_completed_dir = os.path.join(os.path.dirname(dataset_dir), "jobsCompleted") + os.makedirs(jobs_completed_dir, exist_ok=True) + with open(os.path.join(jobs_completed_dir, f"job_modeling_{dataset_name}.txt"), "w") as f: + f.write("complete") + + +def mark_modeling_phase_complete_if_all_model_cv_jobs_finished(dataset_dir: str, model_classes, n_splits: int): + expected_flags = [ + model_cv_flag_path(dataset_dir, getattr(ModelCls, "small_name", ""), cv_idx) + for ModelCls in model_classes + for cv_idx in range(int(n_splits)) + ] + if expected_flags and all(os.path.exists(path) for path in expected_flags): + mark_modeling_phase_complete(dataset_dir) + + +class ModelingPhaseJob: + def __init__( + self, + *, + dataset_dir: str, # // + outcome_label: str = "Class", + model_type: str = "Binary", # "Binary" | "Multiclass" | "Regression" + instance_label: Optional[str] = None, + n_splits: int = 10, + models: List[str] | str | None = None, # CSV or list; if None -> auto-discover defaults + model_params_json: Optional[str] = None, + # calibration + calibrate: bool = False, + calibrate_method: str = "sigmoid", + calibrate_cv: int = 5, + # legacy knobs (forwarded to ModelJob) + output_path: Optional[str] = None, + experiment_name: Optional[str] = None, + scoring_metric: str = "balanced_accuracy", + metric_direction: str = "maximize", + n_trials: int = 200, + timeout: int = 900, + training_subsample: int = 0, + uniform_fi: bool = False, + save_plot: bool = False, + random_state: Optional[int] = None, + bypass_one_hot_for_native_models: bool = True, + native_categorical_models: List[str] | str | None = NATIVE_CATEGORICAL_MODELS_DEFAULT, + ): + self.dataset_dir = dataset_dir + self.dataset_name = os.path.basename(dataset_dir.rstrip("/")) + self.outcome_label = outcome_label + self.model_type = model_type + self.instance_label = instance_label + self.n_splits = int(n_splits) + self.models = csv_to_list(models) + + self.calibrate = bool(calibrate) + self.calibrate_method = calibrate_method + self.calibrate_cv = int(calibrate_cv) + + exp_dir = os.path.dirname(dataset_dir.rstrip("/")) + self.output_path = output_path or os.path.dirname(exp_dir) + self.experiment_name = experiment_name or os.path.basename(exp_dir) + + self.scoring_metric = scoring_metric + self.metric_direction = metric_direction + self.n_trials = int(n_trials) + self.timeout = int(timeout) + self.training_subsample = int(training_subsample) + self.uniform_fi = bool(uniform_fi) + self.save_plot = bool(save_plot) + self.random_state = random_state + self.bypass_one_hot_for_native_models = bool(bypass_one_hot_for_native_models) + self.native_categorical_models = native_categorical_models + self.native_categorical_model_ids = parse_model_id_csv( + native_categorical_models, + default=NATIVE_CATEGORICAL_MODEL_IDS_DEFAULT, + ) + self.resolved_model_classes = None + self.model_params = parse_model_params_json(model_params_json) + + def run_all_model_cv_jobs(self): + for model_job, model in self.create_model_cv_executions(): + model_job.run(model) + + self.mark_phase_complete() + + def resolve_model_classes(self): + if self.resolved_model_classes is not None: + return list(self.resolved_model_classes) + + self.resolved_model_classes = resolve_model_classes_for_dataset( + dataset_dir=self.dataset_dir, + model_type=self.model_type, + models=self.models, + bypass_one_hot_for_native_models=self.bypass_one_hot_for_native_models, + native_categorical_models=self.native_categorical_models, + ) + return list(self.resolved_model_classes) + + def model_cv_specs(self, cv_indices=None): + specs = [] + indices = list(range(self.n_splits)) if cv_indices is None else list(cv_indices) + for ModelCls in self.resolve_model_classes(): + for cv_idx in indices: + specs.append((ModelCls, cv_idx)) + return specs + + def create_model_cv_executions(self, cv_indices=None): + executions = [] + for ModelCls, cv_idx in self.model_cv_specs(cv_indices): + executions.append(( + self.create_model_job_for_cv(cv_idx), + create_model_instance( + ModelCls, + random_state=self.random_state, + scoring_metric=self.scoring_metric, + metric_direction=self.metric_direction, + model_params=self.model_params, + ), + )) + return executions + + def create_model_job_for_cv(self, cv_idx: int): + return ModelJob( + full_path=self.dataset_dir, + output_path=self.output_path, + experiment_name=self.experiment_name, + cv_count=cv_idx, + outcome_label=self.outcome_label, + instance_label=self.instance_label, + scoring_metric=self.scoring_metric, + metric_direction=self.metric_direction, + n_trials=self.n_trials, + timeout=self.timeout, + training_subsample=self.training_subsample, + uniform_fi=self.uniform_fi, + save_plot=self.save_plot, + random_state=self.random_state, + bypass_one_hot_for_native_models=self.bypass_one_hot_for_native_models, + native_categorical_models=self.native_categorical_models, + calibrate=self.calibrate, + calibrate_method=self.calibrate_method, + calibrate_cv=self.calibrate_cv, + ) + + def run_single_model_cv(self, ModelCls, cv_idx: int): + model_job = self.create_model_job_for_cv(cv_idx) + model = create_model_instance( + ModelCls, + random_state=self.random_state, + scoring_metric=self.scoring_metric, + metric_direction=self.metric_direction, + model_params=self.model_params, + ) + model_job.run(model) + + def mark_phase_complete(self): + mark_modeling_phase_complete(self.dataset_dir) diff --git a/streamline/p6_modeling/models/__init__.py b/streamline/p6_modeling/models/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/streamline/p6_modeling/models/binary_classification/__init__.py b/streamline/p6_modeling/models/binary_classification/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/streamline/models/artificial_neural_network.py b/streamline/p6_modeling/models/binary_classification/artificial_neural_network.py similarity index 62% rename from streamline/models/artificial_neural_network.py rename to streamline/p6_modeling/models/binary_classification/artificial_neural_network.py index 65b13e0d..9ffc66ff 100644 --- a/streamline/models/artificial_neural_network.py +++ b/streamline/p6_modeling/models/binary_classification/artificial_neural_network.py @@ -1,10 +1,9 @@ from abc import ABC -from streamline.modeling.basemodel import BaseModel -from streamline.modeling.parameters import get_parameters +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel from sklearn.neural_network import MLPClassifier as MLP -class MLPClassifier(BaseModel, ABC): +class MLPClassifier(BinaryClassificationModel, ABC): model_name = "Artificial Neural Network" small_name = "ANN" color = "red" @@ -12,8 +11,11 @@ class MLPClassifier(BaseModel, ABC): def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', random_state=None, cv=None, n_jobs=None): super().__init__(MLP, "Artificial Neural Network", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = get_parameters(self.model_name) - self.param_grid['random_state'] = [random_state, ] + self.param_grid = {'n_layers': [1, 3], 'layer_size': [1, 100], + 'activation': ['identity', 'logistic', 'tanh', 'relu'], + 'learning_rate': ['constant', 'invscaling', 'adaptive'], 'momentum': [0.1, 0.9], + 'solver': ['sgd', 'adam'], 'batch_size': ['auto'], 'alpha': [0.0001, 0.05], + 'max_iter': [200], 'random_state': [random_state, ]} self.small_name = "ANN" self.color = "red" self.n_jobs = n_jobs @@ -29,5 +31,12 @@ def objective(self, trial, params=None): self.param_grid['alpha'][1], log=True), 'max_iter': trial.suggest_categorical('max_iter', self.param_grid['max_iter']), 'random_state': trial.suggest_categorical('random_state', self.param_grid['random_state'])} + n_layers = trial.suggest_int('n_layers', self.param_grid['n_layers'][0], self.param_grid['n_layers'][1]) + layers = [] + for i in range(n_layers): + layers.append( + trial.suggest_int('n_units_l{}'.format(i), self.param_grid['layer_size'][0], + self.param_grid['layer_size'][1])) + self.params['hidden_layer_sizes'] = tuple(layers) mean_cv_score = self.hyper_eval() return mean_cv_score diff --git a/streamline/models/decision_tree.py b/streamline/p6_modeling/models/binary_classification/decision_tree.py similarity index 78% rename from streamline/models/decision_tree.py rename to streamline/p6_modeling/models/binary_classification/decision_tree.py index 03a96294..ea1b63c4 100644 --- a/streamline/models/decision_tree.py +++ b/streamline/p6_modeling/models/binary_classification/decision_tree.py @@ -1,10 +1,9 @@ from abc import ABC -from streamline.modeling.basemodel import BaseModel -from streamline.modeling.parameters import get_parameters +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel from sklearn.tree import DecisionTreeClassifier as DT -class DecisionTreeClassifier(BaseModel, ABC): +class DecisionTreeClassifier(BinaryClassificationModel, ABC): model_name = "Decision Tree" small_name = "DT" color = "yellow" @@ -12,8 +11,10 @@ class DecisionTreeClassifier(BaseModel, ABC): def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', random_state=None, cv=None, n_jobs=None): super().__init__(DT, "Decision Tree", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = get_parameters(self.model_name) - self.param_grid['random_state'] = [random_state, ] + self.param_grid = {'criterion': ['gini', 'entropy'], 'splitter': ['best', 'random'], 'max_depth': [1, 30], + 'min_samples_split': [2, 50], 'min_samples_leaf': [1, 50], + 'max_features': [None, 'sqrt', 'log2'], 'class_weight': [None, 'balanced'], + 'random_state': [random_state, ]} self.small_name = "DT" self.color = "yellow" self.n_jobs = n_jobs diff --git a/docs/source/elastic_net.py b/streamline/p6_modeling/models/binary_classification/elastic_net.py similarity index 93% rename from docs/source/elastic_net.py rename to streamline/p6_modeling/models/binary_classification/elastic_net.py index a4f435a9..b9432ae7 100644 --- a/docs/source/elastic_net.py +++ b/streamline/p6_modeling/models/binary_classification/elastic_net.py @@ -1,9 +1,9 @@ from abc import ABC -from streamline.modeling.basemodel import BaseModel +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel from sklearn.linear_model import SGDClassifier as SGD -class ElasticNetClassifier(BaseModel, ABC): +class ElasticNetClassifier(BinaryClassificationModel, ABC): model_name = "Elastic Net" small_name = "EN" color = "aquamarine" diff --git a/streamline/models/genetic_programming.py b/streamline/p6_modeling/models/binary_classification/genetic_programming.py similarity index 70% rename from streamline/models/genetic_programming.py rename to streamline/p6_modeling/models/binary_classification/genetic_programming.py index 64f9e22f..f16edda1 100644 --- a/streamline/models/genetic_programming.py +++ b/streamline/p6_modeling/models/binary_classification/genetic_programming.py @@ -1,10 +1,9 @@ from abc import ABC -from streamline.modeling.basemodel import BaseModel -from streamline.modeling.parameters import get_parameters +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel from gplearn.genetic import SymbolicClassifier as GP -class GPClassifier(BaseModel, ABC): +class GPClassifier(BinaryClassificationModel, ABC): model_name = "Genetic Programming" small_name = "GP" color = "purple" @@ -12,8 +11,15 @@ class GPClassifier(BaseModel, ABC): def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', random_state=None, cv=None, n_jobs=None): super().__init__(GP, "Genetic Programming", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = get_parameters(self.model_name) - self.param_grid['random_state'] = [random_state, ] + self.param_grid = {'population_size': [100, 1000], 'generations': [10, 500], 'tournament_size': [3, 50], + 'init_method': ['grow', 'full', 'half and half'], + 'function_set': [['add', 'sub', 'mul', 'div'], + ['add', 'sub', 'mul', 'div', 'sqrt', 'log', + 'abs', 'neg', 'inv', 'max', 'min'], + ['add', 'sub', 'mul', 'div', 'sqrt', 'log', + 'abs', 'neg', 'inv', 'max', 'min', 'sin', 'cos', 'tan']], + 'parsimony_coefficient': [0.001, 0.01], 'low_memory': [True], + 'random_state': [random_state, ]} self.small_name = "GP" self.color = "purple" self.n_jobs = n_jobs diff --git a/streamline/models/gradient_boosting.py b/streamline/p6_modeling/models/binary_classification/gradient_boosting.py similarity index 83% rename from streamline/models/gradient_boosting.py rename to streamline/p6_modeling/models/binary_classification/gradient_boosting.py index 24f46e6e..a456c53c 100644 --- a/streamline/models/gradient_boosting.py +++ b/streamline/p6_modeling/models/binary_classification/gradient_boosting.py @@ -1,13 +1,12 @@ from abc import ABC -from streamline.modeling.basemodel import BaseModel -from streamline.modeling.parameters import get_parameters +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel from sklearn.ensemble import GradientBoostingClassifier as GB from xgboost import XGBClassifier as XGB from lightgbm import LGBMClassifier as LGB from catboost import CatBoostClassifier as CGB -class GBClassifier(BaseModel, ABC): +class GBClassifier(BinaryClassificationModel, ABC): model_name = "Gradient Boosting" small_name = "GB" color = "cornflowerblue" @@ -15,8 +14,9 @@ class GBClassifier(BaseModel, ABC): def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', random_state=None, cv=None, n_jobs=None): super().__init__(GB, "Gradient Boosting", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = get_parameters(self.model_name) - self.param_grid['random_state'] = [random_state, ] + self.param_grid = {'n_estimators': [10, 1000], 'loss': ['deviance', 'exponential'], + 'learning_rate': [0.0001, 0.3], 'min_samples_leaf': [1, 50], 'min_samples_split': [2, 50], + 'max_depth': [1, 30], 'random_state': [random_state, ]} self.small_name = "GB" self.color = "cornflowerblue" self.n_jobs = n_jobs @@ -40,7 +40,7 @@ def objective(self, trial, params=None): return mean_cv_score -class XGBClassifier(BaseModel, ABC): +class XGBClassifier(BinaryClassificationModel, ABC): model_name = "Extreme Gradient Boosting" small_name = "XGB" color = "cyan" @@ -48,8 +48,12 @@ class XGBClassifier(BaseModel, ABC): def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', random_state=None, cv=None, n_jobs=None): super().__init__(XGB, "Extreme Gradient Boosting", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = get_parameters(self.model_name) - self.param_grid['random_state'] = [random_state, ] + self.param_grid = {'booster': ['gbtree'], 'objective': ['binary:logistic'], 'verbosity': [0], + 'reg_lambda': [1e-08, 1.0], 'alpha': [1e-08, 1.0], 'eta': [1e-08, 1.0], + 'gamma': [1e-08, 1.0], 'max_depth': [1, 30], 'grow_policy': ['depthwise', 'lossguide'], + 'n_estimators': [10, 1000], 'min_samples_split': [2, 50], 'min_samples_leaf': [1, 50], + 'subsample': [0.5, 1.0], 'min_child_weight': [0.1, 10], 'colsample_bytree': [0.1, 1.0], + 'nthread': [1], 'random_state': [random_state, ]} self.small_name = "XGB" self.color = "cyan" self.n_jobs = n_jobs @@ -89,7 +93,7 @@ def objective(self, trial, params=None): return mean_cv_score -class LGBClassifier(BaseModel, ABC): +class LGBClassifier(BinaryClassificationModel, ABC): model_name = "Light Gradient Boosting" small_name = "LGB" color = "pink" @@ -97,8 +101,11 @@ class LGBClassifier(BaseModel, ABC): def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', random_state=None, cv=None, n_jobs=None): super().__init__(LGB, "Light Gradient Boosting", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = get_parameters(self.model_name) - self.param_grid['random_state'] = [random_state, ] + self.param_grid = {'objective': ['binary'], 'metric': ['binary_logloss'], 'verbosity': [-1], + 'boosting_type': ['gbdt'], 'num_leaves': [2, 256], 'max_depth': [1, 30], + 'reg_alpha': [1e-08, 10.0], 'reg_lambda': [1e-08, 10.0], 'colsample_bytree': [0.4, 1.0], + 'subsample': [0.4, 1.0], 'subsample_freq': [1, 7], 'min_child_samples': [5, 100], + 'n_estimators': [10, 1000], 'num_threads': [1], 'random_state': [random_state, ]} self.small_name = "LGB" self.color = "pink" self.n_jobs = n_jobs @@ -136,7 +143,7 @@ def objective(self, trial, params=None): return mean_cv_score -class CGBClassifier(BaseModel, ABC): +class CGBClassifier(BinaryClassificationModel, ABC): model_name = "Category Gradient Boosting" small_name = "CGB" color = "magenta" @@ -145,8 +152,9 @@ def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', random_state=None, cv=None, n_jobs=None): super().__init__(CGB, "Category Gradient Boosting", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = get_parameters(self.model_name) - self.param_grid['random_state'] = [random_state, ] + self.param_grid = {'learning_rate': [0.0001, 0.3], 'iterations': [10, 500], 'depth': [1, 10], + 'l2_leaf_reg': [1, 9], 'loss_function': ['Logloss'], 'verbose': [False], + 'random_state': [random_state, ]} self.small_name = "CGB" self.color = "magenta" self.n_jobs = n_jobs diff --git a/streamline/p6_modeling/models/binary_classification/heros.py b/streamline/p6_modeling/models/binary_classification/heros.py new file mode 100644 index 00000000..77d19cf6 --- /dev/null +++ b/streamline/p6_modeling/models/binary_classification/heros.py @@ -0,0 +1,75 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel +from skheros.heros import HEROS + + +class HEROSClassifier(BinaryClassificationModel, ABC): + model_name = "HEROS" + small_name = "HEROS" + color = "darkgreen" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None, + iterations=None, pop_size=None, model_iterations=None, + model_pop_size=None, nu=None): + super().__init__(HEROS, "HEROS", cv_folds, scoring_metric, metric_direction, random_state, cv) + + # Defaults grounded in HEROS docs: + # iterations default 100000 + # pop_size default 1000 + # model_iterations default 500 + # model_pop_size default 100 + # nu default 1 + # + # Following our LCS wrappers, using discrete grids + allow overrides. + self.param_grid = { + 'iterations': [10000, 50000, 100000], + 'pop_size': [500, 1000], + 'model_iterations': [100, 250, 500], + 'model_pop_size': [50, 100], + 'nu': [1], # docs recommend 1 unless you *know* the problem is noise-free + } + + # Optional overrides in the same style as (iterations, N, nu) in eLCS/XCS/ExSTraCS + if iterations is not None: + self.param_grid['iterations'] = [iterations] + if pop_size is not None: + self.param_grid['pop_size'] = [pop_size] + if model_iterations is not None: + self.param_grid['model_iterations'] = [model_iterations] + if model_pop_size is not None: + self.param_grid['model_pop_size'] = [model_pop_size] + if nu is not None: + self.param_grid['nu'] = [nu] + + # Keep random_state consistent with other wrappers + self.param_grid['random_state'] = [random_state] + + self.small_name = "HEROS" + self.color = "darkgreen" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = { + 'iterations': trial.suggest_categorical( + 'iterations', self.param_grid['iterations'] + ), + 'pop_size': trial.suggest_categorical( + 'pop_size', self.param_grid['pop_size'] + ), + 'model_iterations': trial.suggest_categorical( + 'model_iterations', self.param_grid['model_iterations'] + ), + 'model_pop_size': trial.suggest_categorical( + 'model_pop_size', self.param_grid['model_pop_size'] + ), + 'nu': trial.suggest_categorical( + 'nu', self.param_grid['nu'] + ), + 'random_state': trial.suggest_categorical( + 'random_state', self.param_grid['random_state'] + ), + } + + mean_cv_score = self.hyper_eval() + return mean_cv_score diff --git a/streamline/models/learning_based.py b/streamline/p6_modeling/models/binary_classification/learning_based.py similarity index 85% rename from streamline/models/learning_based.py rename to streamline/p6_modeling/models/binary_classification/learning_based.py index 980e96ec..40cc846c 100644 --- a/streamline/models/learning_based.py +++ b/streamline/p6_modeling/models/binary_classification/learning_based.py @@ -1,13 +1,12 @@ import logging from abc import ABC -from streamline.modeling.basemodel import BaseModel -from streamline.modeling.parameters import get_parameters +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel from skeLCS import eLCS from skXCS import XCS from skExSTraCS import ExSTraCS -class eLCSClassifier(BaseModel, ABC): +class eLCSClassifier(BinaryClassificationModel, ABC): model_name = "eLCS" small_name = "eLCS" color = "green" @@ -16,7 +15,8 @@ def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', random_state=None, cv=None, n_jobs=None, iterations=None, N=None, nu=None): super().__init__(eLCS, "eLCS", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = get_parameters(self.model_name) + self.param_grid = {'learning_iterations': [100000, 200000, 500000], 'N': [1000, 2000, 5000], + 'nu': [1, 10], } if iterations: self.param_grid['learning_iterations'] = [iterations, ] if N: @@ -39,7 +39,7 @@ def objective(self, trial, params=None): return mean_cv_score -class XCSClassifier(BaseModel, ABC): +class XCSClassifier(BinaryClassificationModel, ABC): model_name = "XCS" small_name = "XCS" color = "olive" @@ -48,7 +48,8 @@ def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', random_state=None, cv=None, n_jobs=None, iterations=None, N=None, nu=None): super().__init__(XCS, "XCS", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = get_parameters(self.model_name) + self.param_grid = {'learning_iterations': [100000, 200000, 500000], 'N': [1000, 2000, 5000], + 'nu': [1, 10], } if iterations: self.param_grid['learning_iterations'] = [iterations, ] if N: @@ -72,7 +73,7 @@ def objective(self, trial, params=None): return mean_cv_score -class ExSTraCSClassifier(BaseModel, ABC): +class ExSTraCSClassifier(BinaryClassificationModel, ABC): model_name = "ExSTraCS" small_name = "ExSTraCS" color = "lawngreen" @@ -81,7 +82,9 @@ def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', random_state=None, cv=None, n_jobs=None, iterations=None, N=None, nu=None, expert_knowledge=None): super().__init__(ExSTraCS, "ExSTraCS", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = get_parameters(self.model_name) + self.param_grid = {'learning_iterations': [100000, 200000, 500000], 'N': [1000, 2000, 5000], + 'nu': [1, 10], + 'rule_compaction': ['None', 'QRF']} if iterations: self.param_grid['learning_iterations'] = [iterations, ] if N: diff --git a/streamline/p6_modeling/models/binary_classification/linear_model.py b/streamline/p6_modeling/models/binary_classification/linear_model.py new file mode 100644 index 00000000..1a7bcd33 --- /dev/null +++ b/streamline/p6_modeling/models/binary_classification/linear_model.py @@ -0,0 +1,42 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel +from sklearn.linear_model import LogisticRegression as LogR + + +class LogisticRegression(BinaryClassificationModel, ABC): + model_name = "Logistic Regression" + small_name = "LR" + color = "dimgrey" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(LogR, "Logistic Regression", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'penalty': ['l2', 'l1'], 'C': [1e-05, 100000.0], 'dual': [True, False], + 'solver': ['newton-cg', 'lbfgs', 'liblinear', 'sag', 'saga'], + 'class_weight': [None, 'balanced'], 'max_iter': [10, 1000], 'random_state': [random_state, ]} + self.small_name = "LR" + self.color = "dimgrey" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = { + 'solver': trial.suggest_categorical('solver', self.param_grid['solver']), + 'C': trial.suggest_float('C', self.param_grid['C'][0], self.param_grid['C'][1], log=True), + 'class_weight': trial.suggest_categorical('class_weight', self.param_grid['class_weight']), + 'max_iter': trial.suggest_int('max_iter', self.param_grid['max_iter'][0], + self.param_grid['max_iter'][1], log=True), + 'random_state': trial.suggest_categorical('random_state', self.param_grid['random_state'])} + if self.params['solver'] == 'liblinear': + self.params['penalty'] = trial.suggest_categorical('penalty', self.param_grid['penalty']) + if self.params['penalty'] == 'l2': + self.params['dual'] = trial.suggest_categorical('dual', self.param_grid['dual']) + + mean_cv_score = self.hyper_eval() + # logging.debug("Trial Parameters" + str(self.params)) + # model = copy.deepcopy(self.model).set_params(**self.params) + # + # mean_cv_score = cross_val_score(model, self.x_train, self.y_train, + # scoring=self.scoring_metric, + # cv=self.cv, n_jobs=self.n_jobs).mean() + # logging.debug("Trail Completed") + return mean_cv_score diff --git a/streamline/models/naive_bayes.py b/streamline/p6_modeling/models/binary_classification/naive_bayes.py similarity index 75% rename from streamline/models/naive_bayes.py rename to streamline/p6_modeling/models/binary_classification/naive_bayes.py index 87c2e3b4..d8dea147 100644 --- a/streamline/models/naive_bayes.py +++ b/streamline/p6_modeling/models/binary_classification/naive_bayes.py @@ -1,10 +1,9 @@ from abc import ABC -from streamline.modeling.basemodel import BaseModel -from streamline.modeling.parameters import get_parameters +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel from sklearn.naive_bayes import GaussianNB as NB -class NaiveBayesClassifier(BaseModel, ABC): +class NaiveBayesClassifier(BinaryClassificationModel, ABC): model_name = "Naive Bayes" small_name = "NB" color = "silver" @@ -12,7 +11,7 @@ class NaiveBayesClassifier(BaseModel, ABC): def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', random_state=None, cv=None, n_jobs=None): super().__init__(NB, "Naive Bayes", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = get_parameters(self.model_name) + self.param_grid = {} self.small_name = "NB" self.color = "silver" self.n_jobs = n_jobs diff --git a/streamline/models/neighbouring.py b/streamline/p6_modeling/models/binary_classification/neighbouring.py similarity index 77% rename from streamline/models/neighbouring.py rename to streamline/p6_modeling/models/binary_classification/neighbouring.py index dd7a6a7b..c9a44c62 100644 --- a/streamline/models/neighbouring.py +++ b/streamline/p6_modeling/models/binary_classification/neighbouring.py @@ -1,10 +1,9 @@ from abc import ABC -from streamline.modeling.basemodel import BaseModel -from streamline.modeling.parameters import get_parameters +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel from sklearn.neighbors import KNeighborsClassifier as KNN -class KNNClassifier(BaseModel, ABC): +class KNNClassifier(BinaryClassificationModel, ABC): model_name = "K-Nearest Neighbors" small_name = "KNN" color = "chocolate" @@ -12,8 +11,8 @@ class KNNClassifier(BaseModel, ABC): def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', random_state=None, cv=None, n_jobs=None): super().__init__(KNN, "K-Nearest Neighbors", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = get_parameters(self.model_name) - self.param_grid['random_state'] = [random_state, ] + self.param_grid = {'n_neighbors': [1, 100], 'weights': ['uniform', 'distance'], 'p': [1, 5], + 'metric': ['euclidean', 'minkowski'], 'random_state': [random_state, ]} self.small_name = "KNN" self.color = "chocolate" self.n_jobs = n_jobs diff --git a/streamline/models/random_forest.py b/streamline/p6_modeling/models/binary_classification/random_forest.py similarity index 79% rename from streamline/models/random_forest.py rename to streamline/p6_modeling/models/binary_classification/random_forest.py index 8e8868e8..41432e21 100644 --- a/streamline/models/random_forest.py +++ b/streamline/p6_modeling/models/binary_classification/random_forest.py @@ -1,10 +1,9 @@ from abc import ABC -from streamline.modeling.basemodel import BaseModel -from streamline.modeling.parameters import get_parameters +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel from sklearn.ensemble import RandomForestClassifier as RF -class RandomForestClassifier(BaseModel, ABC): +class RandomForestClassifier(BinaryClassificationModel, ABC): model_name = "Random Forest" small_name = "RF" color = "blue" @@ -12,8 +11,10 @@ class RandomForestClassifier(BaseModel, ABC): def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', random_state=None, cv=None, n_jobs=None): super().__init__(RF, "Random Forest", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = get_parameters(self.model_name) - self.param_grid['random_state'] = [random_state, ] + self.param_grid = {'n_estimators': [10, 1000], 'criterion': ['gini', 'entropy'], 'max_depth': [1, 30], + 'min_samples_split': [2, 50], 'min_samples_leaf': [1, 50], + 'max_features': [None, 'sqrt', 'log2'], 'bootstrap': [True], 'oob_score': [False, True], + 'class_weight': [None, 'balanced'], 'random_state': [random_state, ]} self.small_name = "RF" self.color = "blue" self.n_jobs = n_jobs diff --git a/streamline/p6_modeling/models/binary_classification/ripper.py b/streamline/p6_modeling/models/binary_classification/ripper.py new file mode 100644 index 00000000..30bd55a0 --- /dev/null +++ b/streamline/p6_modeling/models/binary_classification/ripper.py @@ -0,0 +1,67 @@ +from abc import ABC + +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel + +try: + # pip install wittgenstein + from wittgenstein import RIPPER +except ImportError as e: + raise ImportError( + "RIPPERClassifier requires the 'wittgenstein' package. " + "Install it with `pip install wittgenstein`." + ) from e + + +class RIPPERClassifier(BinaryClassificationModel, ABC): + model_name = "RIPPER" + small_name = "RIPPER" + color = "darkred" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None, + k=None, prune_size=None): + """ + STREAMLINE wrapper for the RIPPER rule learner using the + 'wittgenstein' implementation. + + Parameters exposed for tuning mirror the core RIPPER knobs: + + - k: loss ratio parameter (class imbalance / rule preference) + - prune_size: fraction of data used for pruning + """ + super().__init__(RIPPER, "RIPPER", cv_folds, scoring_metric, metric_direction, random_state, cv) + + # Modest search space (categorical grid) similar to eLCS/XCS/ExSTraCS style. + self.param_grid = { + 'k': [1.0, 2.0, 3.0], # typical range for Ripper-style learners + 'prune_size': [0.25, 0.33, 0.5], # 0.33 is a common default + } + + # Optional overrides (same pattern as iterations/N/nu in your LCS models) + if k is not None: + self.param_grid['k'] = [k] + if prune_size is not None: + self.param_grid['prune_size'] = [prune_size] + + # Keep random_state consistent with other models + self.param_grid['random_state'] = [random_state] + + self.small_name = "RIPPER" + self.color = "darkred" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + """ + Optuna objective for RIPPER. + + RIPPER follows a sklearn-like API, so we only need to set + constructor params; feature_names etc. are not required here. + """ + self.params = { + 'k': trial.suggest_categorical('k', self.param_grid['k']), + 'prune_size': trial.suggest_categorical('prune_size', self.param_grid['prune_size']), + 'random_state': trial.suggest_categorical('random_state', self.param_grid['random_state']), + } + + mean_cv_score = self.hyper_eval() + return mean_cv_score diff --git a/streamline/models/support_vector_machine.py b/streamline/p6_modeling/models/binary_classification/support_vector_machine.py similarity index 79% rename from streamline/models/support_vector_machine.py rename to streamline/p6_modeling/models/binary_classification/support_vector_machine.py index 1ac327a3..b7e54f30 100644 --- a/streamline/models/support_vector_machine.py +++ b/streamline/p6_modeling/models/binary_classification/support_vector_machine.py @@ -1,10 +1,9 @@ from abc import ABC -from streamline.modeling.basemodel import BaseModel -from streamline.modeling.parameters import get_parameters +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel from sklearn.svm import SVC as SVC -class SupportVectorClassifier(BaseModel, ABC): +class SupportVectorClassifier(BinaryClassificationModel, ABC): model_name = "Support Vector Machine" small_name = "SVM" color = "orange" @@ -12,8 +11,8 @@ class SupportVectorClassifier(BaseModel, ABC): def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', random_state=None, cv=None, n_jobs=None): super().__init__(SVC, "Support Vector Machine", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = get_parameters(self.model_name) - self.param_grid['random_state'] = [random_state, ] + self.param_grid = {'kernel': ['linear', 'poly', 'rbf'], 'C': [0.1, 1000], 'gamma': ['scale'], 'degree': [1, 6], + 'probability': [True], 'class_weight': [None, 'balanced'], 'random_state': [random_state, ]} self.small_name = "SVM" self.color = "orange" self.n_jobs = n_jobs diff --git a/streamline/p6_modeling/models/binary_classification/tabpfn.py b/streamline/p6_modeling/models/binary_classification/tabpfn.py new file mode 100644 index 00000000..9b54bfc6 --- /dev/null +++ b/streamline/p6_modeling/models/binary_classification/tabpfn.py @@ -0,0 +1,144 @@ +from __future__ import annotations + +import inspect +import os +from abc import ABC +from typing import Any, Dict + +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel + +try: + # Local OSS package (not the hosted tabpfn-client) + from tabpfn import TabPFNClassifier as _TabPFNClassifier +except Exception: # pragma: no cover + _TabPFNClassifier = None + + +def supported_kwargs(callable_obj, kwargs: Dict[str, Any]) -> Dict[str, Any]: + """ + Filter kwargs to those supported by callable_obj's signature (robust across TabPFN versions). + """ + try: + sig = inspect.signature(callable_obj) + except Exception: + return kwargs + + # If **kwargs is present, no need to filter. + if any(p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()): + return kwargs + + allowed = set(sig.parameters.keys()) + return {k: v for k, v in kwargs.items() if k in allowed} + + +def tabpfn_ensemble_param(callable_obj) -> str: + try: + params = set(inspect.signature(callable_obj).parameters) + except Exception: + return "N_ensemble_configurations" + if "n_estimators" in params: + return "n_estimators" + return "N_ensemble_configurations" + + +class TabPFNClassifier(BinaryClassificationModel, ABC): + """ + TabPFN (CPU-only) wrapper. + + Notes: + - Forces device='cpu' always. + - TabPFN is designed for small/medium tabular problems; CPU can be slow. + - If you must run CPU on larger datasets, you can set allow_cpu_large_dataset=True + which sets TABPFN_ALLOW_CPU_LARGE_DATASET=true (very slow). + """ + + model_name = "TabPFN" + small_name = "TabPFN" + color = "purple" + + def __init__( + self, + cv_folds: int = 3, + scoring_metric: str = "balanced_accuracy", + metric_direction: str = "maximize", + random_state: int | None = None, + cv=None, + n_jobs=None, + # TabPFN knobs (kept intentionally small) + n_ensemble_configurations: int = 32, + fit_mode: str | None = None, + # Environment/config convenience + model_cache_dir: str | None = None, + allow_cpu_large_dataset: bool = False, + ): + if _TabPFNClassifier is None: + raise ImportError( + "TabPFN is not installed. Install the local package with: pip install tabpfn" + ) + + # Optional caching dir (TabPFN uses env vars for cache location in newer versions) + if model_cache_dir: + os.environ["TABPFN_MODEL_CACHE_DIR"] = str(model_cache_dir) + + # Optional override for CPU limitation on larger datasets + if allow_cpu_large_dataset: + os.environ["TABPFN_ALLOW_CPU_LARGE_DATASET"] = "true" + + super().__init__( + _TabPFNClassifier, + "TabPFN", + cv_folds, + scoring_metric, + metric_direction, + random_state, + cv, + ) + + self.n_jobs = n_jobs # unused by TabPFN; kept for interface consistency + self.small_name = "TabPFN" + self.color = "purple" + + # Build a conservative param grid. We'll filter by the installed TabPFN signature anyway. + ensemble_param = tabpfn_ensemble_param(_TabPFNClassifier) + self.param_grid: Dict[str, Any] = { + ensemble_param: [8, 16, 32, 64], + "fit_mode": ["fit_preprocessors", "fit_with_cache"], + "device": ["cpu"], + } + + self._base_params = { + "device": "cpu", + ensemble_param: int(n_ensemble_configurations), + } + if fit_mode is not None: + self._base_params["fit_mode"] = fit_mode + + # Ensure base params are compatible with the installed TabPFN version + self._base_params = supported_kwargs(_TabPFNClassifier, self._base_params) + + def objective(self, trial, params: Dict[str, Any] | None = None): + # Start from CPU-only base params + cand = dict(self._base_params) + + # Tune ensemble size + ensemble_param = tabpfn_ensemble_param(_TabPFNClassifier) + ensemble_values = self.param_grid.get(ensemble_param) or self.param_grid.get("N_ensemble_configurations", [8]) + cand[ensemble_param] = trial.suggest_categorical(ensemble_param, ensemble_values) + + # Tune fit_mode only if supported by the installed TabPFN signature + cand_with_fit_mode = dict(cand) + cand_with_fit_mode["fit_mode"] = trial.suggest_categorical( + "fit_mode", self.param_grid["fit_mode"] + ) + cand_with_fit_mode = supported_kwargs(_TabPFNClassifier, cand_with_fit_mode) + + # If fit_mode got filtered out, don't record it (keeps Optuna tidy) + cand = cand_with_fit_mode + + # Always force CPU (even if someone tries to pass something in) + cand["device"] = "cpu" + cand = supported_kwargs(_TabPFNClassifier, cand) + + self.params = cand + mean_cv_score = self.hyper_eval() + return mean_cv_score diff --git a/streamline/p6_modeling/models/multiclass_classification/__init__.py b/streamline/p6_modeling/models/multiclass_classification/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/streamline/p6_modeling/models/multiclass_classification/artificial_neural_network.py b/streamline/p6_modeling/models/multiclass_classification/artificial_neural_network.py new file mode 100644 index 00000000..24b601a3 --- /dev/null +++ b/streamline/p6_modeling/models/multiclass_classification/artificial_neural_network.py @@ -0,0 +1,42 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import MulticlassClassificationModel +from sklearn.neural_network import MLPClassifier as MLP + + +class MLPClassifier(MulticlassClassificationModel, ABC): + model_name = "Artificial Neural Network" + small_name = "ANN" + color = "red" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(MLP, "Artificial Neural Network", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'n_layers': [1, 3], 'layer_size': [1, 100], + 'activation': ['identity', 'logistic', 'tanh', 'relu'], + 'learning_rate': ['constant', 'invscaling', 'adaptive'], 'momentum': [0.1, 0.9], + 'solver': ['sgd', 'adam'], 'batch_size': ['auto'], 'alpha': [0.0001, 0.05], + 'max_iter': [200], 'random_state': [random_state, ]} + self.small_name = "ANN" + self.color = "red" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {'activation': trial.suggest_categorical('activation', self.param_grid['activation']), + 'learning_rate': trial.suggest_categorical('learning_rate', self.param_grid['learning_rate']), + 'momentum': trial.suggest_uniform('momentum', self.param_grid['momentum'][0], + self.param_grid['momentum'][1]), + 'solver': trial.suggest_categorical('solver', self.param_grid['solver']), + 'batch_size': trial.suggest_categorical('batch_size', self.param_grid['batch_size']), + 'alpha': trial.suggest_float('alpha', self.param_grid['alpha'][0], + self.param_grid['alpha'][1], log=True), + 'max_iter': trial.suggest_categorical('max_iter', self.param_grid['max_iter']), + 'random_state': trial.suggest_categorical('random_state', self.param_grid['random_state'])} + n_layers = trial.suggest_int('n_layers', self.param_grid['n_layers'][0], self.param_grid['n_layers'][1]) + layers = [] + for i in range(n_layers): + layers.append( + trial.suggest_int('n_units_l{}'.format(i), self.param_grid['layer_size'][0], + self.param_grid['layer_size'][1])) + self.params['hidden_layer_sizes'] = tuple(layers) + mean_cv_score = self.hyper_eval() + return mean_cv_score diff --git a/streamline/p6_modeling/models/multiclass_classification/decision_tree.py b/streamline/p6_modeling/models/multiclass_classification/decision_tree.py new file mode 100644 index 00000000..b7550d98 --- /dev/null +++ b/streamline/p6_modeling/models/multiclass_classification/decision_tree.py @@ -0,0 +1,37 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import MulticlassClassificationModel +from sklearn.tree import DecisionTreeClassifier as DT + + +class DecisionTreeClassifier(MulticlassClassificationModel, ABC): + model_name = "Decision Tree" + small_name = "DT" + color = "yellow" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(DT, "Decision Tree", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'criterion': ['gini', 'entropy'], 'splitter': ['best', 'random'], 'max_depth': [1, 30], + 'min_samples_split': [2, 50], 'min_samples_leaf': [1, 50], + 'max_features': [None, 'sqrt', 'log2'], 'class_weight': [None, 'balanced'], + 'random_state': [random_state, ]} + self.small_name = "DT" + self.color = "yellow" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {'criterion': trial.suggest_categorical('criterion', self.param_grid['criterion']), + 'splitter': trial.suggest_categorical('splitter', self.param_grid['splitter']), + 'max_depth': trial.suggest_int('max_depth', self.param_grid['max_depth'][0], + self.param_grid['max_depth'][1]), + 'min_samples_split': trial.suggest_int('min_samples_split', + self.param_grid['min_samples_split'][0], + self.param_grid['min_samples_split'][1]), + 'min_samples_leaf': trial.suggest_int('min_samples_leaf', self.param_grid['min_samples_leaf'][0], + self.param_grid['min_samples_leaf'][1]), + 'max_features': trial.suggest_categorical('max_features', self.param_grid['max_features']), + 'class_weight': trial.suggest_categorical('class_weight', self.param_grid['class_weight']), + 'random_state': trial.suggest_categorical('random_state', self.param_grid['random_state'])} + + mean_cv_score = self.hyper_eval() + return mean_cv_score diff --git a/streamline/models/elastic_net.py b/streamline/p6_modeling/models/multiclass_classification/elastic_net.py similarity index 92% rename from streamline/models/elastic_net.py rename to streamline/p6_modeling/models/multiclass_classification/elastic_net.py index a4f435a9..4f7c7af9 100644 --- a/streamline/models/elastic_net.py +++ b/streamline/p6_modeling/models/multiclass_classification/elastic_net.py @@ -1,9 +1,9 @@ from abc import ABC -from streamline.modeling.basemodel import BaseModel +from streamline.p6_modeling.utils.submodels import MulticlassClassificationModel from sklearn.linear_model import SGDClassifier as SGD -class ElasticNetClassifier(BaseModel, ABC): +class ElasticNetClassifier(MulticlassClassificationModel, ABC): model_name = "Elastic Net" small_name = "EN" color = "aquamarine" diff --git a/streamline/p6_modeling/models/multiclass_classification/genetic_programming.py b/streamline/p6_modeling/models/multiclass_classification/genetic_programming.py new file mode 100644 index 00000000..9d765b9d --- /dev/null +++ b/streamline/p6_modeling/models/multiclass_classification/genetic_programming.py @@ -0,0 +1,44 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import MulticlassClassificationModel +from gplearn.genetic import SymbolicClassifier as GP + + +class GPClassifier(MulticlassClassificationModel, ABC): + model_name = "Genetic Programming" + small_name = "GP" + color = "purple" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(GP, "Genetic Programming", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'population_size': [100, 1000], 'generations': [10, 500], 'tournament_size': [3, 50], + 'init_method': ['grow', 'full', 'half and half'], + 'function_set': [['add', 'sub', 'mul', 'div'], + ['add', 'sub', 'mul', 'div', 'sqrt', 'log', + 'abs', 'neg', 'inv', 'max', 'min'], + ['add', 'sub', 'mul', 'div', 'sqrt', 'log', + 'abs', 'neg', 'inv', 'max', 'min', 'sin', 'cos', 'tan']], + 'parsimony_coefficient': [0.001, 0.01], 'low_memory': [True], + 'random_state': [random_state, ]} + self.small_name = "GP" + self.color = "purple" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + feature_names = params['feature_names'] + self.params = {'population_size': trial.suggest_int('population_size', self.param_grid['population_size'][0], + self.param_grid['population_size'][1]), + 'generations': trial.suggest_int('generations', self.param_grid['generations'][0], + self.param_grid['generations'][1]), + 'tournament_size': trial.suggest_int('tournament_size', self.param_grid['tournament_size'][0], + self.param_grid['tournament_size'][1]), + 'function_set': trial.suggest_categorical('function_set', self.param_grid['function_set']), + 'init_method': trial.suggest_categorical('init_method', self.param_grid['init_method']), + 'parsimony_coefficient': trial.suggest_float('parsimony_coefficient', + self.param_grid['parsimony_coefficient'][0], + self.param_grid['parsimony_coefficient'][1]), + 'feature_names': trial.suggest_categorical('feature_names', [feature_names]), + 'low_memory': trial.suggest_categorical('low_memory', self.param_grid['low_memory']), + 'random_state': trial.suggest_categorical('random_state', self.param_grid['random_state'])} + mean_cv_score = self.hyper_eval() + return mean_cv_score diff --git a/streamline/p6_modeling/models/multiclass_classification/gradient_boosting.py b/streamline/p6_modeling/models/multiclass_classification/gradient_boosting.py new file mode 100644 index 00000000..18c9e611 --- /dev/null +++ b/streamline/p6_modeling/models/multiclass_classification/gradient_boosting.py @@ -0,0 +1,173 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import MulticlassClassificationModel +from sklearn.ensemble import GradientBoostingClassifier as GB +from xgboost import XGBClassifier as XGB +from lightgbm import LGBMClassifier as LGB +from catboost import CatBoostClassifier as CGB + + +class GBClassifier(MulticlassClassificationModel, ABC): + model_name = "Gradient Boosting" + small_name = "GB" + color = "cornflowerblue" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(GB, "Gradient Boosting", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'n_estimators': [10, 1000], 'loss': ['deviance', 'exponential'], + 'learning_rate': [0.0001, 0.3], 'min_samples_leaf': [1, 50], 'min_samples_split': [2, 50], + 'max_depth': [1, 30], 'random_state': [random_state, ]} + self.small_name = "GB" + self.color = "cornflowerblue" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {'n_estimators': trial.suggest_int('n_estimators', self.param_grid['n_estimators'][0], + self.param_grid['n_estimators'][1]), + 'loss': trial.suggest_categorical('loss', self.param_grid['loss']), + 'learning_rate': trial.suggest_float('learning_rate', self.param_grid['learning_rate'][0], + self.param_grid['learning_rate'][1], log=True), + 'min_samples_leaf': trial.suggest_int('min_samples_leaf', self.param_grid['min_samples_leaf'][0], + self.param_grid['min_samples_leaf'][1]), + 'min_samples_split': trial.suggest_int('min_samples_split', + self.param_grid['min_samples_split'][0], + self.param_grid['min_samples_split'][1]), + 'max_depth': trial.suggest_int('max_depth', self.param_grid['max_depth'][0], + self.param_grid['max_depth'][1]), + 'random_state': trial.suggest_categorical('random_state', self.param_grid['random_state'])} + + mean_cv_score = self.hyper_eval() + return mean_cv_score + + +class XGBClassifier(MulticlassClassificationModel, ABC): + model_name = "Extreme Gradient Boosting" + small_name = "XGB" + color = "cyan" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(XGB, "Extreme Gradient Boosting", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'booster': ['gbtree'], 'objective': ['multi:softprob'], 'eval_metric': ['mlogloss'], 'verbosity': [0], + 'reg_lambda': [1e-08, 1.0], 'alpha': [1e-08, 1.0], 'eta': [1e-08, 1.0], + 'gamma': [1e-08, 1.0], 'max_depth': [1, 30], 'grow_policy': ['depthwise', 'lossguide'], + 'n_estimators': [10, 1000], 'min_samples_split': [2, 50], 'min_samples_leaf': [1, 50], + 'subsample': [0.5, 1.0], 'min_child_weight': [0.1, 10], 'colsample_bytree': [0.1, 1.0], + 'nthread': [1], 'random_state': [random_state, ]} + self.small_name = "XGB" + self.color = "cyan" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + param_grid = self.param_grid + self.params = {'booster': trial.suggest_categorical('booster', param_grid['booster']), + 'objective': trial.suggest_categorical('objective', param_grid['objective']), + 'eval_metric': trial.suggest_categorical('eval_metric', param_grid['eval_metric']), + 'verbosity': trial.suggest_categorical('verbosity', param_grid['verbosity']), + 'reg_lambda': trial.suggest_float('reg_lambda', param_grid['reg_lambda'][0], + param_grid['reg_lambda'][1], log=True), + 'alpha': trial.suggest_float('alpha', param_grid['alpha'][0], param_grid['alpha'][1], log=True), + 'eta': trial.suggest_float('eta', param_grid['eta'][0], param_grid['eta'][1], log=True), + 'gamma': trial.suggest_float('gamma', param_grid['gamma'][0], param_grid['gamma'][1], log=True), + 'max_depth': trial.suggest_int('max_depth', param_grid['max_depth'][0], + param_grid['max_depth'][1]), + 'grow_policy': trial.suggest_categorical('grow_policy', param_grid['grow_policy']), + 'n_estimators': trial.suggest_int('n_estimators', param_grid['n_estimators'][0], + param_grid['n_estimators'][1]), + 'min_samples_split': trial.suggest_int('min_samples_split', param_grid['min_samples_split'][0], + param_grid['min_samples_split'][1]), + 'min_samples_leaf': trial.suggest_int('min_samples_leaf', param_grid['min_samples_leaf'][0], + param_grid['min_samples_leaf'][1]), + 'subsample': trial.suggest_uniform('subsample', param_grid['subsample'][0], + param_grid['subsample'][1]), + 'min_child_weight': trial.suggest_float('min_child_weight', + param_grid['min_child_weight'][0], + param_grid['min_child_weight'][1], log=True), + 'colsample_bytree': trial.suggest_uniform('colsample_bytree', param_grid['colsample_bytree'][0], + param_grid['colsample_bytree'][1]), + 'nthread': trial.suggest_categorical('nthread', param_grid['nthread']), + 'random_state': trial.suggest_categorical('random_state', param_grid['random_state']), } + + mean_cv_score = self.hyper_eval() + return mean_cv_score + + +class LGBClassifier(MulticlassClassificationModel, ABC): + model_name = "Light Gradient Boosting" + small_name = "LGB" + color = "pink" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(LGB, "Light Gradient Boosting", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'objective': ['multiclass'], 'metric': ['multi_logloss'], 'verbosity': [-1], + 'boosting_type': ['gbdt'], 'num_leaves': [2, 256], 'max_depth': [1, 30], + 'reg_alpha': [1e-08, 10.0], 'reg_lambda': [1e-08, 10.0], 'colsample_bytree': [0.4, 1.0], + 'subsample': [0.4, 1.0], 'subsample_freq': [1, 7], 'min_child_samples': [5, 100], + 'n_estimators': [10, 1000], 'num_threads': [1], 'random_state': [random_state, ]} + self.small_name = "LGB" + self.color = "pink" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + param_grid = self.param_grid + self.params = {'objective': trial.suggest_categorical('objective', param_grid['objective']), + 'metric': trial.suggest_categorical('metric', param_grid['metric']), + 'verbosity': trial.suggest_categorical('verbosity', param_grid['verbosity']), + 'boosting_type': trial.suggest_categorical('boosting_type', param_grid['boosting_type']), + 'num_leaves': trial.suggest_int('num_leaves', param_grid['num_leaves'][0], + param_grid['num_leaves'][1]), + 'max_depth': trial.suggest_int('max_depth', param_grid['max_depth'][0], + param_grid['max_depth'][1]), + 'reg_alpha': trial.suggest_float('reg_alpha', param_grid['reg_alpha'][0], + param_grid['reg_alpha'][1], log=True), + 'reg_lambda': trial.suggest_float('reg_lambda', param_grid['reg_lambda'][0], + param_grid['reg_lambda'][1], log=True), + 'colsample_bytree': trial.suggest_uniform('colsample_bytree', param_grid['colsample_bytree'][0], + param_grid['colsample_bytree'][1]), + 'subsample': trial.suggest_uniform('subsample', param_grid['subsample'][0], + param_grid['subsample'][1]), + 'subsample_freq': trial.suggest_int('subsample_freq', param_grid['subsample_freq'][0], + param_grid['subsample_freq'][1]), + 'min_child_samples': trial.suggest_int('min_child_samples', param_grid['min_child_samples'][0], + param_grid['min_child_samples'][1]), + 'n_estimators': trial.suggest_int('n_estimators', param_grid['n_estimators'][0], + param_grid['n_estimators'][1]), + 'random_state': trial.suggest_categorical('random_state', param_grid['random_state']), + } + # print(self.model.get_params()) + mean_cv_score = self.hyper_eval() + return mean_cv_score + + +class CGBClassifier(MulticlassClassificationModel, ABC): + model_name = "Category Gradient Boosting" + small_name = "CGB" + color = "magenta" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(CGB, "Category Gradient Boosting", cv_folds, scoring_metric, metric_direction, random_state, + cv) + self.param_grid = {'learning_rate': [0.0001, 0.3], 'iterations': [10, 500], 'depth': [1, 10], + 'l2_leaf_reg': [1, 9], 'loss_function': ['Logloss'], 'verbose': [False], + 'random_state': [random_state, ]} + self.small_name = "CGB" + self.color = "magenta" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {'learning_rate': trial.suggest_float('learning_rate', self.param_grid['learning_rate'][0], + self.param_grid['learning_rate'][1], log=True), + 'iterations': trial.suggest_int('iterations', self.param_grid['iterations'][0], + self.param_grid['iterations'][1]), + 'depth': trial.suggest_int('depth', self.param_grid['depth'][0], self.param_grid['depth'][1]), + 'l2_leaf_reg': trial.suggest_int('l2_leaf_reg', self.param_grid['l2_leaf_reg'][0], + self.param_grid['l2_leaf_reg'][1]), + 'loss_function': trial.suggest_categorical('loss_function', self.param_grid['loss_function']), + 'random_state': trial.suggest_categorical('random_state', self.param_grid['random_state']), + 'verbose': trial.suggest_categorical('verbose', self.param_grid['verbose']), + } + + mean_cv_score = self.hyper_eval() + return mean_cv_score diff --git a/streamline/p6_modeling/models/multiclass_classification/heros.py b/streamline/p6_modeling/models/multiclass_classification/heros.py new file mode 100644 index 00000000..8af81291 --- /dev/null +++ b/streamline/p6_modeling/models/multiclass_classification/heros.py @@ -0,0 +1,69 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import MulticlassClassificationModel +from skheros.heros import HEROS + + +class HEROSMulticlassClassifier(MulticlassClassificationModel, ABC): + model_name = "HEROS" + small_name = "HEROS" + color = "darkgreen" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None, + iterations=None, pop_size=None, model_iterations=None, + model_pop_size=None, nu=None): + super().__init__(HEROS, "HEROS", cv_folds, scoring_metric, metric_direction, random_state, cv) + + # Same parameter philosophy as the binary version + self.param_grid = { + 'iterations': [10000, 50000, 100000], + 'pop_size': [500, 1000], + 'model_iterations': [100, 250, 500], + 'model_pop_size': [50, 100], + 'nu': [1], # recommended default from HEROS docs + } + + # Optional user overrides + if iterations is not None: + self.param_grid['iterations'] = [iterations] + if pop_size is not None: + self.param_grid['pop_size'] = [pop_size] + if model_iterations is not None: + self.param_grid['model_iterations'] = [model_iterations] + if model_pop_size is not None: + self.param_grid['model_pop_size'] = [model_pop_size] + if nu is not None: + self.param_grid['nu'] = [nu] + + # Consistent with other STREAMLINE rule-based learners + self.param_grid['random_state'] = [random_state] + + self.small_name = "HEROS" + self.color = "darkgreen" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + # HEROS accepts multiclass labels naturally through sklearn API + self.params = { + 'iterations': trial.suggest_categorical( + 'iterations', self.param_grid['iterations'] + ), + 'pop_size': trial.suggest_categorical( + 'pop_size', self.param_grid['pop_size'] + ), + 'model_iterations': trial.suggest_categorical( + 'model_iterations', self.param_grid['model_iterations'] + ), + 'model_pop_size': trial.suggest_categorical( + 'model_pop_size', self.param_grid['model_pop_size'] + ), + 'nu': trial.suggest_categorical( + 'nu', self.param_grid['nu'] + ), + 'random_state': trial.suggest_categorical( + 'random_state', self.param_grid['random_state'] + ), + } + + mean_cv_score = self.hyper_eval() + return mean_cv_score diff --git a/streamline/p6_modeling/models/multiclass_classification/learning_based.py b/streamline/p6_modeling/models/multiclass_classification/learning_based.py new file mode 100644 index 00000000..a7ab5608 --- /dev/null +++ b/streamline/p6_modeling/models/multiclass_classification/learning_based.py @@ -0,0 +1,87 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import MulticlassClassificationModel +from skeLCS import eLCS +from skXCS import XCS +from skExSTraCS import ExSTraCS + + +class eLCSClassifier(MulticlassClassificationModel, ABC): + model_name = "eLCS" + small_name = "eLCS" + color = "green" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None, + iterations=None, N=None, nu=None): + super().__init__(eLCS, "eLCS", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'learning_iterations': [100000, 200000, 500000], 'N': [1000, 2000, 5000], + 'nu': [1, 10], } + if iterations: + self.param_grid['learning_iterations'] = [iterations, ] + if N: + self.param_grid['N'] = [N, ] + if nu: + self.param_grid['nu'] = [nu, ] + self.small_name = "eLCS" + self.color = "green" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {} + mean_cv_score = self.hyper_eval() + return mean_cv_score + + +class XCSClassifier(MulticlassClassificationModel, ABC): + model_name = "XCS" + small_name = "XCS" + color = "olive" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None, + iterations=None, N=None, nu=None): + super().__init__(XCS, "XCS", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'learning_iterations': [100000, 200000, 500000], 'N': [1000, 2000, 5000], + 'nu': [1, 10], } + if iterations: + self.param_grid['learning_iterations'] = [iterations, ] + if N: + self.param_grid['N'] = [N, ] + if nu: + self.param_grid['nu'] = [nu, ] + self.small_name = "XCS" + self.color = "olive" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {} + mean_cv_score = self.hyper_eval() + return mean_cv_score + + +class ExSTraCSClassifier(MulticlassClassificationModel, ABC): + model_name = "ExSTraCS" + small_name = "ExSTraCS" + color = "lawngreen" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None, + iterations=None, N=None, nu=None): + super().__init__(ExSTraCS, "ExSTraCS", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'learning_iterations': [100000, 200000, 500000], 'N': [1000, 2000, 5000], + 'nu': [1, 10], + 'rule_compaction': ['None', 'QRF']} + if iterations: + self.param_grid['learning_iterations'] = [iterations, ] + if N: + self.param_grid['N'] = [N, ] + if nu: + self.param_grid['nu'] = [nu, ] + self.small_name = "ExSTraCS" + self.color = "lawngreen" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {} + mean_cv_score = self.hyper_eval() + return mean_cv_score diff --git a/streamline/models/linear_model.py b/streamline/p6_modeling/models/multiclass_classification/linear_model.py similarity index 81% rename from streamline/models/linear_model.py rename to streamline/p6_modeling/models/multiclass_classification/linear_model.py index b5fdfc14..17f169a8 100644 --- a/streamline/models/linear_model.py +++ b/streamline/p6_modeling/models/multiclass_classification/linear_model.py @@ -1,10 +1,9 @@ from abc import ABC -from streamline.modeling.basemodel import BaseModel -from streamline.modeling.parameters import get_parameters +from streamline.p6_modeling.utils.submodels import MulticlassClassificationModel from sklearn.linear_model import LogisticRegression as LogR -class LogisticRegression(BaseModel, ABC): +class LogisticRegression(MulticlassClassificationModel, ABC): model_name = "Logistic Regression" small_name = "LR" color = "dimgrey" @@ -12,8 +11,9 @@ class LogisticRegression(BaseModel, ABC): def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', metric_direction='maximize', random_state=None, cv=None, n_jobs=None): super().__init__(LogR, "Logistic Regression", cv_folds, scoring_metric, metric_direction, random_state, cv) - self.param_grid = get_parameters(self.model_name) - self.param_grid['random_state'] = [random_state, ] + self.param_grid = {'penalty': ['l2', 'l1'], 'C': [1e-05, 100000.0], 'dual': [True, False], + 'solver': ['newton-cg', 'lbfgs', 'sag', 'saga'], + 'class_weight': [None, 'balanced'], 'max_iter': [10, 1000], 'random_state': [random_state, ]} self.small_name = "LR" self.color = "dimgrey" self.n_jobs = n_jobs diff --git a/streamline/p6_modeling/models/multiclass_classification/naive_bayes.py b/streamline/p6_modeling/models/multiclass_classification/naive_bayes.py new file mode 100644 index 00000000..fbdc8716 --- /dev/null +++ b/streamline/p6_modeling/models/multiclass_classification/naive_bayes.py @@ -0,0 +1,22 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import MulticlassClassificationModel +from sklearn.naive_bayes import GaussianNB as NB + + +class NaiveBayesClassifier(MulticlassClassificationModel, ABC): + model_name = "Naive Bayes" + small_name = "NB" + color = "silver" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(NB, "Naive Bayes", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {} + self.small_name = "NB" + self.color = "silver" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {} + mean_cv_score = self.hyper_eval() + return mean_cv_score diff --git a/streamline/p6_modeling/models/multiclass_classification/neighbouring.py b/streamline/p6_modeling/models/multiclass_classification/neighbouring.py new file mode 100644 index 00000000..e43a0f54 --- /dev/null +++ b/streamline/p6_modeling/models/multiclass_classification/neighbouring.py @@ -0,0 +1,28 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import MulticlassClassificationModel +from sklearn.neighbors import KNeighborsClassifier as KNN + + +class KNNClassifier(MulticlassClassificationModel, ABC): + model_name = "K-Nearest Neighbors" + small_name = "KNN" + color = "chocolate" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(KNN, "K-Nearest Neighbors", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'n_neighbors': [1, 100], 'weights': ['uniform', 'distance'], 'p': [1, 5], + 'metric': ['euclidean', 'minkowski'], 'random_state': [random_state, ]} + self.small_name = "KNN" + self.color = "chocolate" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = { + 'n_neighbors': trial.suggest_int('n_neighbors', self.param_grid['n_neighbors'][0], + self.param_grid['n_neighbors'][1]), + 'weights': trial.suggest_categorical('weights', self.param_grid['weights']), + 'p': trial.suggest_int('p', self.param_grid['p'][0], self.param_grid['p'][1]), + 'metric': trial.suggest_categorical('metric', self.param_grid['metric'])} + mean_cv_score = self.hyper_eval() + return mean_cv_score diff --git a/streamline/p6_modeling/models/multiclass_classification/random_forest.py b/streamline/p6_modeling/models/multiclass_classification/random_forest.py new file mode 100644 index 00000000..9cf70ba1 --- /dev/null +++ b/streamline/p6_modeling/models/multiclass_classification/random_forest.py @@ -0,0 +1,40 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import MulticlassClassificationModel +from sklearn.ensemble import RandomForestClassifier as RF + + +class RandomForestClassifier(MulticlassClassificationModel, ABC): + model_name = "Random Forest" + small_name = "RF" + color = "blue" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(RF, "Random Forest", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'n_estimators': [10, 1000], 'criterion': ['gini', 'entropy'], 'max_depth': [1, 30], + 'min_samples_split': [2, 50], 'min_samples_leaf': [1, 50], + 'max_features': [None, 'sqrt', 'log2'], 'bootstrap': [True], 'oob_score': [False, True], + 'class_weight': [None, 'balanced'], 'random_state': [random_state, ]} + self.small_name = "RF" + self.color = "blue" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {'n_estimators': trial.suggest_int('n_estimators', self.param_grid['n_estimators'][0], + self.param_grid['n_estimators'][1]), + 'criterion': trial.suggest_categorical('criterion', self.param_grid['criterion']), + 'max_depth': trial.suggest_int('max_depth', self.param_grid['max_depth'][0], + self.param_grid['max_depth'][1]), + 'min_samples_split': trial.suggest_int('min_samples_split', + self.param_grid['min_samples_split'][0], + self.param_grid['min_samples_split'][1]), + 'min_samples_leaf': trial.suggest_int('min_samples_leaf', self.param_grid['min_samples_leaf'][0], + self.param_grid['min_samples_leaf'][1]), + 'max_features': trial.suggest_categorical('max_features', self.param_grid['max_features']), + 'bootstrap': trial.suggest_categorical('bootstrap', self.param_grid['bootstrap']), + 'oob_score': trial.suggest_categorical('oob_score', self.param_grid['oob_score']), + 'class_weight': trial.suggest_categorical('class_weight', self.param_grid['class_weight']), + 'random_state': trial.suggest_categorical('random_state', self.param_grid['random_state'])} + + mean_cv_score = self.hyper_eval() + return mean_cv_score diff --git a/streamline/p6_modeling/models/multiclass_classification/support_vector_machine.py b/streamline/p6_modeling/models/multiclass_classification/support_vector_machine.py new file mode 100644 index 00000000..7e7417ca --- /dev/null +++ b/streamline/p6_modeling/models/multiclass_classification/support_vector_machine.py @@ -0,0 +1,30 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import MulticlassClassificationModel +from sklearn.svm import SVC as SVC + + +class SupportVectorClassifier(MulticlassClassificationModel, ABC): + model_name = "Support Vector Machine" + small_name = "SVM" + color = "orange" + + def __init__(self, cv_folds=3, scoring_metric='balanced_accuracy', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(SVC, "Support Vector Machine", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'kernel': ['linear', 'poly', 'rbf'], 'C': [0.1, 1000], 'gamma': ['scale'], 'degree': [1, 6], + 'probability': [True], 'class_weight': [None, 'balanced'], 'random_state': [random_state, ]} + self.small_name = "SVM" + self.color = "orange" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {'kernel': trial.suggest_categorical('kernel', self.param_grid['kernel']), + 'C': trial.suggest_float('C', self.param_grid['C'][0], self.param_grid['C'][1], log=True), + 'gamma': trial.suggest_categorical('gamma', self.param_grid['gamma']), + 'degree': trial.suggest_int('degree', self.param_grid['degree'][0], + self.param_grid['degree'][1]), + 'probability': trial.suggest_categorical('probability', self.param_grid['probability']), + 'class_weight': trial.suggest_categorical('class_weight', self.param_grid['class_weight']), + 'random_state': trial.suggest_categorical('random_state', self.param_grid['random_state'])} + mean_cv_score = self.hyper_eval() + return mean_cv_score diff --git a/streamline/p6_modeling/models/multiclass_classification/tabpfn.py b/streamline/p6_modeling/models/multiclass_classification/tabpfn.py new file mode 100644 index 00000000..5f691cfa --- /dev/null +++ b/streamline/p6_modeling/models/multiclass_classification/tabpfn.py @@ -0,0 +1,125 @@ +from __future__ import annotations + +import inspect +import os +from abc import ABC +from typing import Any, Dict + +from streamline.p6_modeling.utils.submodels import MulticlassClassificationModel + +try: + # Local OSS package (not tabpfn-client) + from tabpfn import TabPFNClassifier as _TabPFNClassifier +except Exception: # pragma: no cover + _TabPFNClassifier = None + + +def supported_kwargs(callable_obj, kwargs: Dict[str, Any]) -> Dict[str, Any]: + """ + Filter kwargs to those supported by callable_obj's signature (robust across TabPFN versions). + """ + try: + sig = inspect.signature(callable_obj) + except Exception: + return kwargs + + if any(p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()): + return kwargs + + allowed = set(sig.parameters.keys()) + return {k: v for k, v in kwargs.items() if k in allowed} + + +def tabpfn_ensemble_param(callable_obj) -> str: + try: + params = set(inspect.signature(callable_obj).parameters) + except Exception: + return "N_ensemble_configurations" + if "n_estimators" in params: + return "n_estimators" + return "N_ensemble_configurations" + + +class TabPFNMultiClassClassifier(MulticlassClassificationModel, ABC): + """ + TabPFN Multiclass Classifier (CPU-only). + + Notes: + - Forces device='cpu'. + - If allow_cpu_large_dataset=True, sets TABPFN_ALLOW_CPU_LARGE_DATASET=true (can be very slow). + """ + + model_name = "TabPFN" + small_name = "TabPFN" + color = "purple" + + def __init__( + self, + cv_folds: int = 3, + scoring_metric: str = "balanced_accuracy", + metric_direction: str = "maximize", + random_state: int | None = None, + cv=None, + n_jobs=None, + # TabPFN knobs + n_ensemble_configurations: int = 32, + fit_mode: str | None = None, + # Env/config convenience + model_cache_dir: str | None = None, + allow_cpu_large_dataset: bool = False, + ): + if _TabPFNClassifier is None: + raise ImportError("TabPFN is not installed. Install with: pip install tabpfn") + + if model_cache_dir: + os.environ["TABPFN_MODEL_CACHE_DIR"] = str(model_cache_dir) + + if allow_cpu_large_dataset: + os.environ["TABPFN_ALLOW_CPU_LARGE_DATASET"] = "true" + + super().__init__( + _TabPFNClassifier, + self.model_name, + cv_folds, + scoring_metric, + metric_direction, + random_state, + cv, + ) + + self.n_jobs = n_jobs # unused by TabPFN; kept for interface consistency + + ensemble_param = tabpfn_ensemble_param(_TabPFNClassifier) + self.param_grid: Dict[str, Any] = { + ensemble_param: [8, 16, 32, 64], + "fit_mode": ["fit_preprocessors", "fit_with_cache"], + "device": ["cpu"], + } + + self._base_params = { + "device": "cpu", + ensemble_param: int(n_ensemble_configurations), + } + if fit_mode is not None: + self._base_params["fit_mode"] = fit_mode + + self._base_params = supported_kwargs(_TabPFNClassifier, self._base_params) + + def objective(self, trial, params: Dict[str, Any] | None = None): + cand = dict(self._base_params) + + ensemble_param = tabpfn_ensemble_param(_TabPFNClassifier) + ensemble_values = self.param_grid.get(ensemble_param) or self.param_grid.get("N_ensemble_configurations", [8]) + cand[ensemble_param] = trial.suggest_categorical(ensemble_param, ensemble_values) + + # Only keep fit_mode if your installed TabPFN supports it + cand2 = dict(cand) + cand2["fit_mode"] = trial.suggest_categorical("fit_mode", self.param_grid["fit_mode"]) + cand2 = supported_kwargs(_TabPFNClassifier, cand2) + cand = cand2 + + cand["device"] = "cpu" + cand = supported_kwargs(_TabPFNClassifier, cand) + + self.params = cand + return self.hyper_eval() diff --git a/streamline/p6_modeling/models/regression/__init__.py b/streamline/p6_modeling/models/regression/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/streamline/p6_modeling/models/regression/adaboost.py b/streamline/p6_modeling/models/regression/adaboost.py new file mode 100644 index 00000000..3d3ce5f1 --- /dev/null +++ b/streamline/p6_modeling/models/regression/adaboost.py @@ -0,0 +1,35 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import RegressionModel +from sklearn.ensemble import AdaBoostRegressor as ABR + + +class AdaBoostRegressor(RegressionModel, ABC): + model_name = "AdaBoost" + small_name = "AB" + color = "teal" + + def __init__(self, cv_folds=3, scoring_metric='explained_variance', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(ABR, "AdaBoost", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'n_estimators': [10, 1000], 'learning_rate': [.0001, 0.3], + 'loss': ['linear', 'square', 'exponential'], 'random_state': [random_state, ]} + self.small_name = "AB" + self.color = "teal" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {'n_estimators': trial.suggest_int('n_estimators', self.param_grid['n_estimators'][0], + self.param_grid['n_estimators'][1]), + 'learning_rate': trial.suggest_float('learning_rate', self.param_grid['learning_rate'][0], + self.param_grid['learning_rate'][1]), + 'loss': trial.suggest_categorical('loss', self.param_grid['loss'])} + + mean_cv_score = self.hyper_eval() + return mean_cv_score + + def residual_record(self, x_train, y_train, x_test, y_test): + y_train_pred = self.predict(x_train) + y_pred = self.predict(x_test) + residual_train = y_train - y_train_pred + residual_test = y_test - y_pred + return residual_train, residual_test, y_train_pred, y_pred diff --git a/streamline/p6_modeling/models/regression/elastic_net.py b/streamline/p6_modeling/models/regression/elastic_net.py new file mode 100644 index 00000000..dbb4d03e --- /dev/null +++ b/streamline/p6_modeling/models/regression/elastic_net.py @@ -0,0 +1,35 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import RegressionModel +from sklearn.linear_model import ElasticNet as EN + + +class ElasticNet(RegressionModel, ABC): + model_name = "Elastic Net" + small_name = "EN" + color = "steelblue" + + def __init__(self, cv_folds=3, scoring_metric='explained_variance', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(EN, "Elastic Net", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'alpha': [1e-3, 1], 'l1_ratio': [0, 1], 'max_iter': [2000, 2500], + 'random_state': [random_state, ]} + self.small_name = "EN" + self.color = "steelblue" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {'alpha': trial.suggest_float('alpha', self.param_grid['alpha'][0], self.param_grid['alpha'][1]), + 'l1_ratio': trial.suggest_float('l1_ratio', self.param_grid['l1_ratio'][0], + self.param_grid['l1_ratio'][1]), + 'max_iter': trial.suggest_int('max_iter', self.param_grid['max_iter'][0], + self.param_grid['max_iter'][1])} + + mean_cv_score = self.hyper_eval() + return mean_cv_score + + def residual_record(self, x_train, y_train, x_test, y_test): + y_train_pred = self.predict(x_train) + y_pred = self.predict(x_test) + residual_train = y_train - y_train_pred + residual_test = y_test - y_pred + return residual_train, residual_test, y_train_pred, y_pred diff --git a/streamline/p6_modeling/models/regression/grad_boost.py b/streamline/p6_modeling/models/regression/grad_boost.py new file mode 100644 index 00000000..1c3835a6 --- /dev/null +++ b/streamline/p6_modeling/models/regression/grad_boost.py @@ -0,0 +1,41 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import RegressionModel +from sklearn.ensemble import GradientBoostingRegressor as GBR + + +class GradientBoostingRegressor(RegressionModel, ABC): + model_name = "GradBoost" + small_name = "GB" + color = "olive" + + def __init__(self, cv_folds=3, scoring_metric='explained_variance', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(GBR, "GradBoost", cv_folds, scoring_metric, metric_direction, + random_state, cv) + self.param_grid = {'learning_rate': [.0001, 0.3], 'n_estimators': [10, 1000], 'min_samples_leaf': [1, 50], + 'min_samples_split': [2, 50], 'max_depth': [1, 30], 'random_state': [random_state, ]} + self.small_name = "GB" + self.color = "olive" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {'learning_rate': trial.suggest_float('learning_rate', self.param_grid['learning_rate'][0], + self.param_grid['learning_rate'][1]), + 'n_estimators': trial.suggest_int('n_estimators', self.param_grid['n_estimators'][0], + self.param_grid['n_estimators'][1]), + 'min_samples_leaf': trial.suggest_int('min_samples_leaf', self.param_grid['min_samples_leaf'][0], + self.param_grid['min_samples_leaf'][1]), + 'min_samples_split': trial.suggest_int('min_samples_split', self.param_grid['min_samples_split'][0], + self.param_grid['min_samples_split'][1]), + 'max_depth': trial.suggest_int('max_depth', self.param_grid['max_depth'][0], + self.param_grid['max_depth'][1])} + + mean_cv_score = self.hyper_eval() + return mean_cv_score + + def residual_record(self, x_train, y_train, x_test, y_test): + y_train_pred = self.predict(x_train) + y_pred = self.predict(x_test) + residual_train = y_train - y_train_pred + residual_test = y_test - y_pred + return residual_train, residual_test, y_train_pred, y_pred diff --git a/streamline/p6_modeling/models/regression/group_lasso.py b/streamline/p6_modeling/models/regression/group_lasso.py new file mode 100644 index 00000000..a474aebe --- /dev/null +++ b/streamline/p6_modeling/models/regression/group_lasso.py @@ -0,0 +1,39 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import RegressionModel +from group_lasso import GroupLasso as GL + + +class GroupLasso(RegressionModel, ABC): + model_name = "Group Lasso" + small_name = "GL" + color = "orange" + + def __init__(self, cv_folds=3, scoring_metric='explained_variance', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(GL, "Group Lasso", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'group_reg': [1e-3, 1], 'n_iter': [2000, 2500], + 'scale_reg': ['group_size', 'none', 'inverse_group_size'], 'random_state': [random_state, ], + # 'subsampling_scheme': [0.1,0.9], + # 'frobenius_lipschitz': [True], + } + self.small_name = "GL" + self.color = "orange" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {'group_reg': trial.suggest_float('group_reg', self.param_grid['group_reg'][0], + self.param_grid['group_reg'][1]), + 'n_iter': trial.suggest_int('n_iter', self.param_grid['n_iter'][0], + self.param_grid['n_iter'][1]), + 'scale_reg': trial.suggest_categorical('scale_reg', self.param_grid['scale_reg']), + 'random_state': trial.suggest_categorical('random_state', self.param_grid['random_state'])} + + mean_cv_score = self.hyper_eval() + return mean_cv_score + + def residual_record(self, x_train, y_train, x_test, y_test): + y_train_pred = self.predict(x_train) + y_pred = self.predict(x_test) + residual_train = y_train - y_train_pred + residual_test = y_test - y_pred + return residual_train, residual_test, y_train_pred, y_pred diff --git a/streamline/p6_modeling/models/regression/linear_regrssion.py b/streamline/p6_modeling/models/regression/linear_regrssion.py new file mode 100644 index 00000000..75e9133c --- /dev/null +++ b/streamline/p6_modeling/models/regression/linear_regrssion.py @@ -0,0 +1,31 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import RegressionModel +from sklearn.linear_model import LinearRegression as LRModel + + +class LinearRegression(RegressionModel, ABC): + model_name = "Linear Regression" + small_name = "LR" + color = "red" + + def __init__(self, cv_folds=3, scoring_metric='explained_variance', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(LRModel, "Linear Regression", cv_folds, scoring_metric, metric_direction, random_state, cv) + self.param_grid = {} + # self.param_grid['random_state'] = [random_state, ] + self.small_name = "LR" + self.color = "red" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {} + + mean_cv_score = self.hyper_eval() + return mean_cv_score + + def residual_record(self, x_train, y_train, x_test, y_test): + y_train_pred = self.predict(x_train) + y_pred = self.predict(x_test) + residual_train = y_train - y_train_pred + residual_test = y_test - y_pred + return residual_train, residual_test, y_train_pred, y_pred diff --git a/streamline/p6_modeling/models/regression/random_forest.py b/streamline/p6_modeling/models/regression/random_forest.py new file mode 100644 index 00000000..c7e0a16c --- /dev/null +++ b/streamline/p6_modeling/models/regression/random_forest.py @@ -0,0 +1,46 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import RegressionModel +from sklearn.ensemble import RandomForestRegressor + + +class RFRegressor(RegressionModel, ABC): + model_name = "Random Forest" + small_name = "RF" + color = "navy" + + def __init__(self, cv_folds=3, scoring_metric='explained_variance', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(RandomForestRegressor, "Random Forest", cv_folds, + scoring_metric, metric_direction, random_state, cv) + self.param_grid = {'n_estimators': [10, 1000], 'max_depth': [1, 30], 'min_samples_split': [2, 50], + 'min_samples_leaf': [1, 50], 'max_features': [None, 'auto', 'log2'], 'bootstrap': [True], + 'oob_score': [False, True], 'random_state': [random_state, ]} + self.small_name = "RF" + self.color = "navy" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {'n_estimators': trial.suggest_int('n_estimators', self.param_grid['n_estimators'][0], + self.param_grid['n_estimators'][1]), + 'max_depth': trial.suggest_int('max_depth', self.param_grid['max_depth'][0], + self.param_grid['max_depth'][1]), + 'min_samples_split': trial.suggest_int('min_samples_split', + self.param_grid['min_samples_split'][0], + self.param_grid['min_samples_split'][1]), + 'min_samples_leaf': trial.suggest_int('min_samples_leaf', + self.param_grid['min_samples_leaf'][0], + self.param_grid['min_samples_leaf'][1]), + 'max_features': trial.suggest_categorical('max_features', + self.param_grid['max_features']), + 'bootstrap': trial.suggest_categorical('bootstrap', self.param_grid['bootstrap']), + 'oob_score': trial.suggest_categorical('oob_score', self.param_grid['oob_score'])} + + mean_cv_score = self.hyper_eval() + return mean_cv_score + + def residual_record(self, x_train, y_train, x_test, y_test): + y_train_pred = self.predict(x_train) + y_pred = self.predict(x_test) + residual_train = y_train - y_train_pred + residual_test = y_test - y_pred + return residual_train, residual_test, y_train_pred, y_pred diff --git a/streamline/p6_modeling/models/regression/svr.py b/streamline/p6_modeling/models/regression/svr.py new file mode 100644 index 00000000..8c340758 --- /dev/null +++ b/streamline/p6_modeling/models/regression/svr.py @@ -0,0 +1,36 @@ +from abc import ABC +from streamline.p6_modeling.utils.submodels import RegressionModel +from sklearn.svm import SVR as SVRModel + + +class SVR(RegressionModel, ABC): + model_name = "Support Vector Regression" + small_name = "SVR" + color = "rosybrown" + + def __init__(self, cv_folds=3, scoring_metric='explained_variance', + metric_direction='maximize', random_state=None, cv=None, n_jobs=None): + super().__init__(SVRModel, "Support Vector Regression", cv_folds, scoring_metric, metric_direction, + random_state, cv) + self.param_grid = {'kernel': ['poly', 'rbf'], 'C': [0.1, 1000], 'gamma': ['scale'], 'degree': [1, 6], + 'random_state': [random_state, ]} + self.small_name = "SVR" + self.color = "rosybrown" + self.n_jobs = n_jobs + + def objective(self, trial, params=None): + self.params = {'kernel': trial.suggest_categorical('kernel', self.param_grid['kernel']), + 'C': trial.suggest_float('C', self.param_grid['C'][0], self.param_grid['C'][1]), + 'gamma': trial.suggest_categorical('gamma', self.param_grid['gamma']), + 'degree': trial.suggest_int('degree', + self.param_grid['degree'][0], self.param_grid['degree'][1])} + + mean_cv_score = self.hyper_eval() + return mean_cv_score + + def residual_record(self, x_train, y_train, x_test, y_test): + y_train_pred = self.predict(x_train) + y_pred = self.predict(x_test) + residual_train = y_train - y_train_pred + residual_test = y_test - y_pred + return residual_train, residual_test, y_train_pred, y_pred diff --git a/streamline/p6_modeling/models/regression/tabpfn.py b/streamline/p6_modeling/models/regression/tabpfn.py new file mode 100644 index 00000000..4d10d5ab --- /dev/null +++ b/streamline/p6_modeling/models/regression/tabpfn.py @@ -0,0 +1,124 @@ +from __future__ import annotations + +import inspect +import os +from abc import ABC +from typing import Any, Dict + +from streamline.p6_modeling.utils.submodels import RegressionModel + +try: + from tabpfn import TabPFNRegressor as _TabPFNRegressor +except Exception: # pragma: no cover + _TabPFNRegressor = None + + +def supported_kwargs(callable_obj, kwargs: Dict[str, Any]) -> Dict[str, Any]: + """ + Filter kwargs to those supported by callable_obj's signature (robust across TabPFN versions). + """ + try: + sig = inspect.signature(callable_obj) + except Exception: + return kwargs + + if any(p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()): + return kwargs + + allowed = set(sig.parameters.keys()) + return {k: v for k, v in kwargs.items() if k in allowed} + + +def tabpfn_ensemble_param(callable_obj) -> str: + try: + params = set(inspect.signature(callable_obj).parameters) + except Exception: + return "N_ensemble_configurations" + if "n_estimators" in params: + return "n_estimators" + return "N_ensemble_configurations" + + +class TabPFNRegressor(RegressionModel, ABC): + """ + TabPFN Regressor (CPU-only). + + Notes: + - Forces device='cpu'. + - If allow_cpu_large_dataset=True, sets TABPFN_ALLOW_CPU_LARGE_DATASET=true (can be very slow). + """ + + model_name = "TabPFN (Regression)" + small_name = "TabPFN-R" + color = "purple" + + def __init__( + self, + cv_folds: int = 3, + scoring_metric: str = "neg_mean_squared_error", + metric_direction: str = "maximize", + random_state: int | None = None, + cv=None, + n_jobs=None, + # TabPFN knobs + n_ensemble_configurations: int = 32, + fit_mode: str | None = None, + # Env/config convenience + model_cache_dir: str | None = None, + allow_cpu_large_dataset: bool = False, + ): + if _TabPFNRegressor is None: + raise ImportError("TabPFN is not installed. Install with: pip install tabpfn") + + if model_cache_dir: + os.environ["TABPFN_MODEL_CACHE_DIR"] = str(model_cache_dir) + + if allow_cpu_large_dataset: + os.environ["TABPFN_ALLOW_CPU_LARGE_DATASET"] = "true" + + super().__init__( + _TabPFNRegressor, + self.model_name, + cv_folds, + scoring_metric, + metric_direction, + random_state, + cv, + ) + + self.n_jobs = n_jobs # unused by TabPFN; kept for interface consistency + + ensemble_param = tabpfn_ensemble_param(_TabPFNRegressor) + self.param_grid: Dict[str, Any] = { + ensemble_param: [8, 16, 32, 64], + "fit_mode": ["fit_preprocessors", "fit_with_cache"], + "device": ["cpu"], + } + + self._base_params = { + "device": "cpu", + ensemble_param: int(n_ensemble_configurations), + } + if fit_mode is not None: + self._base_params["fit_mode"] = fit_mode + + self._base_params = supported_kwargs(_TabPFNRegressor, self._base_params) + + def objective(self, trial, params: Dict[str, Any] | None = None): + cand = dict(self._base_params) + + ensemble_param = tabpfn_ensemble_param(_TabPFNRegressor) + ensemble_values = self.param_grid.get(ensemble_param) or self.param_grid.get("N_ensemble_configurations", [8]) + cand[ensemble_param] = trial.suggest_categorical(ensemble_param, ensemble_values) + + # Only keep fit_mode if your installed TabPFN supports it + cand2 = dict(cand) + cand2["fit_mode"] = trial.suggest_categorical("fit_mode", self.param_grid["fit_mode"]) + cand2 = supported_kwargs(_TabPFNRegressor, cand2) + cand = cand2 + + cand["device"] = "cpu" + cand = supported_kwargs(_TabPFNRegressor, cand) + + self.params = cand + return self.hyper_eval() diff --git a/streamline/p6_modeling/p6_cli.py b/streamline/p6_modeling/p6_cli.py new file mode 100644 index 00000000..8caa4501 --- /dev/null +++ b/streamline/p6_modeling/p6_cli.py @@ -0,0 +1,136 @@ +import argparse +from streamline.p6_modeling.p6_runner import P6Runner +from streamline.p6_modeling.utils.categorical import NATIVE_CATEGORICAL_MODELS_DEFAULT +from streamline.p6_modeling.utils.loader import list_models, list_all_models, normalize_modeling_type +from streamline.utils.run_commands import ( + add_run_command_args, + apply_saved_run_command, + require_args, + save_run_command_from_args, + snapshot_args, +) + +def _print_models(entries, title: str): + print(f"\n{title}") + if not entries: + print(" (none found)") + return + # neat, one-per-line: () - [module] + for e in entries: + alt = f" ({e['alt_id']})" if e.get("alt_id") else "" + mod = f" [{e['module']}]" if e.get("module") else "" + print(f" {e['model_type']:<24} {e['small_name']:<12} {e['model_name']}") + print("") + +def main(): + ap = argparse.ArgumentParser("STREAMLINE Phase 6 (Modeling) CLI", + formatter_class=argparse.ArgumentDefaultsHelpFormatter) + ap.add_argument("--output_path", required=True) + ap.add_argument("--experiment_name", required=True) + + ap.add_argument("--outcome_label", default="Class") + ap.add_argument("--outcome_type", default=None, + help="Binary | Multiclass | Continuous") + ap.add_argument("--model_type", default=None, + help="Deprecated alias for --outcome_type. Binary | Multiclass | Regression") + ap.add_argument("--instance_label", default=None) + ap.add_argument("--n_splits", type=int, default=None) + ap.add_argument("--models", default=None, + help="CSV of model ids (small_name or underscored model_name). Omit to auto-discover default models; eLCS is not included by default.") + # NEW: per-model JSON overrides + ap.add_argument( + "--model_params_json", + default=None, + help="JSON string mapping model ids (small_name or model_name) to dicts of attribute overrides.", + ) + + # calibration + ap.add_argument("--calibrate", type=int, default=0, help="1 to enable probability calibration") + ap.add_argument("--calibrate_method", default="sigmoid", help="sigmoid | isotonic") + ap.add_argument("--calibrate_cv", type=int, default=5) + + # ModelJob controls + ap.add_argument("--scoring_metric", default="balanced_accuracy") + ap.add_argument("--metric_direction", default="maximize") + ap.add_argument("--n_trials", type=int, default=200) + ap.add_argument("--timeout", type=int, default=900) + ap.add_argument("--training_subsample", type=int, default=0) + ap.add_argument("--uniform_fi", type=int, default=0) + ap.add_argument("--save_plot", type=int, default=0) + ap.add_argument("--random_state", default=None) + ap.add_argument( + "--bypass_one_hot_for_native_models", + type=int, + default=1, + help="1 allows native categorical models to consume raw categoricals when P1 one_hot_encoding is false.", + ) + ap.add_argument( + "--native_categorical_models", + default=NATIVE_CATEGORICAL_MODELS_DEFAULT, + help="CSV of model ids allowed to run when P1 one_hot_encoding is false.", + ) + + # execution + ap.add_argument("--run_cluster", default="Serial", + help="Serial | Local | Parallel | BashSLURM | BashLSF | ") + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", type=int, default=4) + + ap.add_argument("--list_models_all", action="store_true") + ap.add_argument("--list_models", action="store_true") + add_run_command_args(ap) + + args = ap.parse_args() + args = apply_saved_run_command(ap, args, "p6_modeling") + run_command_args = snapshot_args(args) + + # ---- NEW: handle listing and exit ---- + if args.list_models_all: + entries = list_all_models() + _print_models(entries, title="Available models (ALL types):") + return + + if args.list_models: + modeling_type = normalize_modeling_type(outcome_type=args.outcome_type, model_type=args.model_type) + entries = list_models(modeling_type) + _print_models(entries, title=f"Available models ({modeling_type}):") + return + + require_args(ap, args, ["n_splits"]) + + # ---- normal run ---- + runner = P6Runner( + output_path=args.output_path, + experiment_name=args.experiment_name, + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + model_type=args.model_type, + instance_label=args.instance_label, + n_splits=args.n_splits, + models=args.models, + model_params_json=args.model_params_json, + + calibrate=bool(args.calibrate), + calibrate_method=args.calibrate_method, + calibrate_cv=args.calibrate_cv, + + scoring_metric=args.scoring_metric, + metric_direction=args.metric_direction, + n_trials=args.n_trials, + timeout=args.timeout, + training_subsample=args.training_subsample, + uniform_fi=bool(args.uniform_fi), + save_plot=bool(args.save_plot), + random_state=(int(args.random_state) if (args.random_state not in (None, "", "None")) else None), + bypass_one_hot_for_native_models=bool(args.bypass_one_hot_for_native_models), + native_categorical_models=args.native_categorical_models, + + run_cluster=args.run_cluster, + queue=args.queue, + reserved_memory=args.reserved_memory, + ) + runner.run() + save_run_command_from_args(args, "p6_modeling", run_command_args, runner=runner) + +if __name__ == "__main__": + main() diff --git a/streamline/p6_modeling/p6_jobsubmit.py b/streamline/p6_modeling/p6_jobsubmit.py new file mode 100644 index 00000000..68dd3ac0 --- /dev/null +++ b/streamline/p6_modeling/p6_jobsubmit.py @@ -0,0 +1,154 @@ +import argparse +import logging +import sys +from pathlib import Path + +try: + from .modeling import ( + create_model_instance, + mark_modeling_phase_complete, + mark_modeling_phase_complete_if_all_model_cv_jobs_finished, + model_class_matching_id, + parse_model_params_json, + resolve_model_classes_for_dataset, + ) + from .utils.categorical import NATIVE_CATEGORICAL_MODELS_DEFAULT + from .utils.loader import normalize_modeling_type + from .utils.modeljob import ModelJob +except ImportError: + sys.path.insert(0, str(Path(__file__).resolve().parents[2])) + from streamline.p6_modeling.modeling import ( + create_model_instance, + mark_modeling_phase_complete, + mark_modeling_phase_complete_if_all_model_cv_jobs_finished, + model_class_matching_id, + parse_model_params_json, + resolve_model_classes_for_dataset, + ) + from streamline.p6_modeling.utils.categorical import NATIVE_CATEGORICAL_MODELS_DEFAULT + from streamline.p6_modeling.utils.loader import normalize_modeling_type + from streamline.p6_modeling.utils.modeljob import ModelJob + +def parse_bool(x): + if x is None: return False + return str(x).strip().lower() in ("1", "true", "t", "yes", "y") + +def main(): + ap = argparse.ArgumentParser("P6 Modeling jobsubmit (single dataset)") + ap.add_argument("--dataset_dir", required=True) + ap.add_argument("--outcome_label", default="Class") + ap.add_argument("--outcome_type", default=None) + ap.add_argument("--model_type", default=None) + ap.add_argument("--instance_label", default=None) + ap.add_argument("--n_splits", type=int, required=True) + ap.add_argument("--models", default=None) + ap.add_argument("--model_id", default=None) + ap.add_argument("--cv_idx", type=int, default=None) + # JSON: per-model overrides + ap.add_argument( + "--model_params_json", + default=None, + help="JSON string mapping model ids to dicts of attribute overrides.", + ) + + # calibration + ap.add_argument("--calibrate", default="0") + ap.add_argument("--calibrate_method", default="sigmoid") + ap.add_argument("--calibrate_cv", type=int, default=5) + + # ModelJob controls + ap.add_argument("--output_path", required=True) + ap.add_argument("--experiment_name", required=True) + ap.add_argument("--scoring_metric", default="balanced_accuracy") + ap.add_argument("--metric_direction", default="maximize") + ap.add_argument("--n_trials", type=int, default=200) + ap.add_argument("--timeout", type=int, default=900) + ap.add_argument("--training_subsample", type=int, default=0) + ap.add_argument("--uniform_fi", default="0") + ap.add_argument("--save_plot", default="0") + ap.add_argument("--random_state", default=None) + ap.add_argument("--bypass_one_hot_for_native_models", default="1") + ap.add_argument("--native_categorical_models", default=NATIVE_CATEGORICAL_MODELS_DEFAULT) + + args = ap.parse_args() + modeling_type = normalize_modeling_type(outcome_type=args.outcome_type, model_type=args.model_type) + instance_label = args.instance_label if args.instance_label else None + n_splits = int(args.n_splits) + random_state = int(args.random_state) if (args.random_state not in (None, "", "None")) else None + bypass_native = parse_bool(args.bypass_one_hot_for_native_models) + model_params = parse_model_params_json(args.model_params_json) + + model_classes = resolve_model_classes_for_dataset( + dataset_dir=args.dataset_dir, + model_type=modeling_type, + models=args.models, + bypass_one_hot_for_native_models=bypass_native, + native_categorical_models=args.native_categorical_models, + ) + + if (args.model_id is None) != (args.cv_idx is None): + ap.error("--model_id and --cv_idx must be provided together for a single submitted model/CV job.") + + if args.model_id is not None: + ModelCls = model_class_matching_id(model_classes, args.model_id) + if ModelCls is None: + logging.warning( + "Phase 6 jobsubmit found no runnable model '%s' after model filtering.", + args.model_id, + ) + mark_modeling_phase_complete_if_all_model_cv_jobs_finished( + args.dataset_dir, + model_classes, + n_splits, + ) + return + jobs_to_run = [(ModelCls, int(args.cv_idx))] + else: + jobs_to_run = [ + (ModelCls, cv_idx) + for ModelCls in model_classes + for cv_idx in range(n_splits) + ] + + for ModelCls, cv_idx in jobs_to_run: + model_job = ModelJob( + full_path=args.dataset_dir, + output_path=args.output_path, + experiment_name=args.experiment_name, + cv_count=int(cv_idx), + outcome_label=args.outcome_label, + instance_label=instance_label, + scoring_metric=args.scoring_metric, + metric_direction=args.metric_direction, + n_trials=int(args.n_trials), + timeout=int(args.timeout), + training_subsample=int(args.training_subsample), + uniform_fi=parse_bool(args.uniform_fi), + save_plot=parse_bool(args.save_plot), + random_state=random_state, + bypass_one_hot_for_native_models=bypass_native, + native_categorical_models=args.native_categorical_models, + calibrate=parse_bool(args.calibrate), + calibrate_method=args.calibrate_method, + calibrate_cv=int(args.calibrate_cv), + ) + model = create_model_instance( + ModelCls, + random_state=random_state, + scoring_metric=args.scoring_metric, + metric_direction=args.metric_direction, + model_params=model_params, + ) + model_job.run(model) + + if args.model_id is not None: + mark_modeling_phase_complete_if_all_model_cv_jobs_finished( + args.dataset_dir, + model_classes, + n_splits, + ) + else: + mark_modeling_phase_complete(args.dataset_dir) + +if __name__ == "__main__": + main() diff --git a/streamline/p6_modeling/p6_runner.py b/streamline/p6_modeling/p6_runner.py new file mode 100644 index 00000000..2003f488 --- /dev/null +++ b/streamline/p6_modeling/p6_runner.py @@ -0,0 +1,302 @@ +from __future__ import annotations +import json +import os, time +import shlex +from pathlib import Path +from typing import Optional, List +import logging + +import dask +from dask.distributed import Client, LocalCluster +logger = logging.getLogger("distributed.worker"); logger.setLevel(logging.WARNING) + +from streamline.p6_modeling.modeling import ModelingPhaseJob +from streamline.p6_modeling.utils.categorical import NATIVE_CATEGORICAL_MODELS_DEFAULT +from streamline.p6_modeling.utils.loader import modeling_type_to_outcome_type, normalize_modeling_type +from streamline.utils.runners import num_cores, run_dask_tasks, run_parallel_jobs +from streamline.utils.cluster import get_cluster # must return a connected Dask Client + + +class P6Runner: + """ + Phase 6 runner (modeling). + Modes via run_cluster: + • "Serial" + • "Local" + • "Parallel" + • "BashSLURM" | "BashLSF" + • "" (get_cluster(...) provides a connected Client) + """ + def __init__( + self, + output_path: str, + experiment_name: str, + *, + outcome_label: str = "Class", + outcome_type: Optional[str] = None, # "Binary" | "Multiclass" | "Continuous" + model_type: Optional[str] = None, # Backward-compatible alias; use outcome_type. + instance_label: Optional[str] = None, + n_splits: int = 10, + models: List[str] | str | None = None, # CSV/list; None = auto-discover defaults + model_params_json: Optional[str] = None, + + + # calibration (now handled inside BaseModel.fit) + calibrate: bool = False, + calibrate_method: str = "sigmoid", + calibrate_cv: int = 5, + + # ModelJob controls + scoring_metric: str = "balanced_accuracy", + metric_direction: str = "maximize", + n_trials: int = 200, + timeout: int = 900, + training_subsample: int = 0, + uniform_fi: bool = False, + save_plot: bool = False, + random_state: Optional[int] = None, + bypass_one_hot_for_native_models: bool = True, + native_categorical_models: str | List[str] | None = NATIVE_CATEGORICAL_MODELS_DEFAULT, + + # execution + run_cluster: str = "Serial", # "Serial" | "Local" | "Parallel" | "BashSLURM" | "BashLSF" | "" + queue: str = "defq", + reserved_memory: int = 4, + ): + self.output_path = output_path + self.experiment_name = experiment_name + self.outcome_label = outcome_label + self.model_type = normalize_modeling_type(outcome_type=outcome_type, model_type=model_type) + self.outcome_type = outcome_type or modeling_type_to_outcome_type(self.model_type) + self.instance_label = instance_label + self.n_splits = int(n_splits) + self.models = models + self.model_params_json = model_params_json + + + self.calibrate = bool(calibrate) + self.calibrate_method = calibrate_method + self.calibrate_cv = int(calibrate_cv) + + self.scoring_metric = scoring_metric + self.metric_direction = metric_direction + self.n_trials = int(n_trials) + self.timeout = int(timeout) + self.training_subsample = int(training_subsample) + self.uniform_fi = bool(uniform_fi) + self.save_plot = bool(save_plot) + self.random_state = random_state + self.bypass_one_hot_for_native_models = bool(bypass_one_hot_for_native_models) + self.native_categorical_models = native_categorical_models + + self.run_cluster = run_cluster or "Serial" + self.queue = queue + self.reserved_memory = int(reserved_memory) + + self.exp_root = os.path.join(self.output_path, self.experiment_name) + if not os.path.isdir(self.exp_root): + raise Exception("Experiment must exist before Phase 6 can begin") + + if self.run_cluster in ("BashSLURM", "BashLSF"): + os.makedirs(os.path.join(self.exp_root, "jobs"), exist_ok=True) + os.makedirs(os.path.join(self.exp_root, "logs"), exist_ok=True) + + def run(self): + datasets = self.find_modeling_dataset_dirs() + if not datasets: + logging.warning("No datasets found for Phase 6 under %s", self.exp_root) + return + + mode = self.run_cluster + if mode == "Serial": + self.run_modeling_phase_jobs_serially(datasets) + elif mode == "Local": + jobs, model_counts = self.collect_model_cv_jobs(datasets) + label = self.format_model_cv_progress_label("Dask", jobs, model_counts) + if not jobs: + logging.warning("No Phase 6 model/CV jobs to run.") + self.mark_modeling_phase_complete(datasets) + return + with LocalCluster(processes=True, n_workers=num_cores, threads_per_worker=1) as cluster: + with Client(cluster) as client: + tasks = [ + dask.delayed(self.run_model_cv_job)(dataset_dir, ModelCls, cv_idx) + for dataset_dir, ModelCls, cv_idx in jobs + ] + run_dask_tasks(tasks, client, label=label) + self.mark_modeling_phase_complete(datasets) + elif mode == "Parallel": + jobs, model_counts = self.collect_model_cv_jobs(datasets) + label = self.format_model_cv_progress_label("Parallel", jobs, model_counts) + if not jobs: + logging.warning("No Phase 6 model/CV jobs to run.") + self.mark_modeling_phase_complete(datasets) + return + run_parallel_jobs(self.run_model_cv_job, jobs, label=label) + self.mark_modeling_phase_complete(datasets) + elif mode in ("BashSLURM", "BashLSF"): + jobs, model_counts = self.collect_model_cv_jobs(datasets) + logging.info(self.format_model_cv_progress_label(mode, jobs, model_counts)) + for dataset_dir, ModelCls, cv_idx in jobs: + self.submit_bash_model_job(dataset_dir, ModelCls, cv_idx, mode) + else: + jobs, model_counts = self.collect_model_cv_jobs(datasets) + label = self.format_model_cv_progress_label("Dask", jobs, model_counts) + if not jobs: + logging.warning("No Phase 6 model/CV jobs to run.") + self.mark_modeling_phase_complete(datasets) + return + client: Client = get_cluster(mode, self.exp_root, self.queue, self.reserved_memory) + tasks = [ + dask.delayed(self.run_model_cv_job)(ds, ModelCls, cv_idx) + for ds, ModelCls, cv_idx in jobs + ] + run_dask_tasks(tasks, client, label=label) + self.mark_modeling_phase_complete(datasets) + + def find_modeling_dataset_dirs(self): + return [ + os.path.join(self.exp_root, name) + for name in sorted(os.listdir(self.exp_root)) + if os.path.isdir(os.path.join(self.exp_root, name)) + and name not in {"jobsCompleted","jobs","logs","dask_logs","DatasetComparisons"} + and os.path.isdir(os.path.join(self.exp_root, name, "CVDatasets")) + ] + + def run_modeling_phase_jobs_serially(self, datasets): + for dataset_dir in datasets: + self.make_modeling_phase_job(dataset_dir).run_all_model_cv_jobs() + + def make_modeling_phase_job(self, dataset_dir: str): + return ModelingPhaseJob( + dataset_dir=dataset_dir, + outcome_label=self.outcome_label, + model_type=self.model_type, + instance_label=self.instance_label, + n_splits=self.n_splits, + models=self.models, + model_params_json=self.model_params_json, + + + # pass through to BaseModel via Job → Model construction + calibrate=self.calibrate, + calibrate_method=self.calibrate_method, + calibrate_cv=self.calibrate_cv, + + output_path=self.output_path, + experiment_name=self.experiment_name, + scoring_metric=self.scoring_metric, + metric_direction=self.metric_direction, + n_trials=self.n_trials, + timeout=self.timeout, + training_subsample=self.training_subsample, + uniform_fi=self.uniform_fi, + save_plot=self.save_plot, + random_state=self.random_state, + bypass_one_hot_for_native_models=self.bypass_one_hot_for_native_models, + native_categorical_models=self.native_categorical_models, + ) + + def collect_model_cv_jobs(self, datasets): + jobs = [] + model_counts = {} + for dataset_dir in datasets: + phase_job = self.make_modeling_phase_job(dataset_dir) + model_classes = phase_job.resolve_model_classes() + model_counts[dataset_dir] = len(model_classes) + for ModelCls, cv_idx in phase_job.model_cv_specs(): + jobs.append((dataset_dir, ModelCls, cv_idx)) + return jobs, model_counts + + def run_model_cv_job(self, dataset_dir: str, ModelCls, cv_idx: int): + self.make_modeling_phase_job(dataset_dir).run_single_model_cv(ModelCls, cv_idx) + + def mark_modeling_phase_complete(self, datasets): + for dataset_dir in datasets: + self.make_modeling_phase_job(dataset_dir).mark_phase_complete() + + def format_model_cv_progress_label(self, mode: str, jobs, model_counts): + dataset_count = len(model_counts) + model_count = sum(model_counts.values()) + return ( + f"Phase 6 {mode} jobs: {len(jobs)} model/CV jobs " + f"({model_count} model(s) across {dataset_count} dataset(s), " + f"{self.n_splits} CV split(s))" + ) + + def model_ids_csv(self): + if isinstance(self.models, list): + return ",".join(self.models) + return self.models or "" + + def submit_bash_model_job(self, dataset_dir: str, ModelCls, cv_idx: int, mode: str): + job_ref = str(time.time()) + jobs = os.path.join(self.exp_root, "jobs") + logs = os.path.join(self.exp_root, "logs") + os.makedirs(jobs, exist_ok=True); os.makedirs(logs, exist_ok=True) + + model_id = getattr(ModelCls, "small_name", getattr(ModelCls, "model_name", "model")) + dataset_name = os.path.basename(dataset_dir.rstrip("/")) + sh_path = os.path.join(jobs, f"P6_{dataset_name}_{model_id}_CV{cv_idx}_{job_ref}_run.sh") + launcher = "sbatch" if mode == "BashSLURM" else "bsub <" + + script = str(Path(__file__).parent / "p6_jobsubmit.py") + args = [ + "python", script, + "--dataset_dir", dataset_dir, + "--outcome_label", self.outcome_label, + "--outcome_type", self.outcome_type, + "--instance_label", self.instance_label or "", + "--n_splits", str(self.n_splits), + "--models", self.model_ids_csv(), + "--model_id", model_id, + "--cv_idx", str(cv_idx), + + "--calibrate", "1" if self.calibrate else "0", + "--calibrate_method", self.calibrate_method, + "--calibrate_cv", str(self.calibrate_cv), + + "--output_path", self.output_path, + "--experiment_name", self.experiment_name, + "--scoring_metric", self.scoring_metric, + "--metric_direction", self.metric_direction, + "--n_trials", str(self.n_trials), + "--timeout", str(self.timeout), + "--training_subsample", str(self.training_subsample), + "--uniform_fi", "1" if self.uniform_fi else "0", + "--save_plot", "1" if self.save_plot else "0", + "--random_state", str(self.random_state) if self.random_state is not None else "", + "--bypass_one_hot_for_native_models", "1" if self.bypass_one_hot_for_native_models else "0", + "--native_categorical_models", ( + ",".join(self.native_categorical_models) + if isinstance(self.native_categorical_models, list) + else (self.native_categorical_models or "") + ), + ] + if self.model_params_json: + json_arg = ( + json.dumps(self.model_params_json) + if isinstance(self.model_params_json, dict) + else str(self.model_params_json) + ) + args.extend(["--model_params_json", json_arg]) + cmd = " ".join(shlex.quote(str(arg)) for arg in args) + + with open(sh_path, "w") as sh: + sh.write("#!/bin/bash\n") + if mode == "BashSLURM": + sh.write(f"#SBATCH -p {self.queue}\n") + sh.write(f"#SBATCH --job-name=P6_{model_id}_{cv_idx}_{job_ref}\n") + sh.write(f"#SBATCH --mem={self.reserved_memory}G\n") + sh.write(f"#SBATCH -o {logs}/P6_{dataset_name}_{model_id}_CV{cv_idx}_{job_ref}.o\n") + sh.write(f"#SBATCH -e {logs}/P6_{dataset_name}_{model_id}_CV{cv_idx}_{job_ref}.e\n") + sh.write("srun " + cmd + "\n") + else: + sh.write(f"#BSUB -q {self.queue}\n") + sh.write(f"#BSUB -J P6_{model_id}_{cv_idx}_{job_ref}\n") + sh.write(f"#BSUB -R \"rusage[mem={self.reserved_memory}G]\"\n") + sh.write(f"#BSUB -M {self.reserved_memory}GB\n") + sh.write(f"#BSUB -o {logs}/P6_{dataset_name}_{model_id}_CV{cv_idx}_{job_ref}.o\n") + sh.write(f"#BSUB -e {logs}/P6_{dataset_name}_{model_id}_CV{cv_idx}_{job_ref}.e\n") + sh.write(cmd + "\n") + os.system(f"{launcher} {sh_path}") diff --git a/streamline/p6_modeling/utils/basemodel.py b/streamline/p6_modeling/utils/basemodel.py new file mode 100644 index 00000000..b74d2f76 --- /dev/null +++ b/streamline/p6_modeling/utils/basemodel.py @@ -0,0 +1,236 @@ +import copy +import logging +import warnings +import optuna + +from sklearn.utils._testing import ignore_warnings +from sklearn.exceptions import ConvergenceWarning +from sklearn.model_selection import StratifiedKFold, cross_val_score +from sklearn.calibration import CalibratedClassifierCV + +warnings.filterwarnings(action='ignore', module='sklearn') +warnings.filterwarnings(action='ignore', module='scipy') +warnings.filterwarnings(action='ignore', module='optuna') +warnings.filterwarnings(action="ignore", category=ConvergenceWarning, module="sklearn") + + +class BaseModel: + """ + Phase-6 BaseModel with: + • Optuna hyper-eval API (unchanged) + • Built-in optional probability calibration (CalibratedClassifierCV) + • Default model_evaluation() that returns exactly what ModelJob expects + - Regression: returns a metrics dict + - Binary/Multiclass: returns (metrics, fpr, tpr, roc_auc, prec, recall, pr_auc, ave_prec, probs) + Subclasses must set: + - self.model_type in {"Binary", "Multiclass", "Regression"} + - self.param_grid (dict of lists) + - implement objective(trial, params=None) + - call super().__init__(model=, model_name=, ...) + """ + + def __init__( + self, + model, + model_name, + cv_folds=3, + scoring_metric='balanced_accuracy', + metric_direction='maximize', + random_state=None, + cv=None, + sampler=None, + n_jobs=None, + # NEW: calibration knobs (classification only) + # Don't need this because we have calibration in ModelJob now + # calibrate: bool = False, + # calibrate_method: str = "sigmoid", # "sigmoid" | "isotonic" + # calibrate_cv: int = 5, + ): + self.is_single = True + if model is not None: + self.model = model() + self.small_name = model_name.replace(" ", "_") + self.model_name = model_name + self.y_train = None + self.x_train = None + self.param_grid = None + self.params = None + self.random_state = random_state + self.scoring_metric = scoring_metric + self.metric_direction = metric_direction + if cv is None: + self.cv = StratifiedKFold(n_splits=cv_folds, shuffle=True, random_state=self.random_state) + else: + self.cv = cv + + if sampler is None: + self.sampler = optuna.samplers.TPESampler(seed=self.random_state) + else: + self.sampler = sampler + self.study = None + optuna.logging.set_verbosity(optuna.logging.WARNING) + self.n_jobs = n_jobs + self.optuna_report = {} + + # Calibration config + # self.calibrate = bool(calibrate) + # self.calibrate_method = calibrate_method + # self.calibrate_cv = calibrate_cv + + # expected from subclass: self.model_type in {"Binary","Multiclass","Regression"} + + # ----- to be implemented by subclasses ----- + def objective(self, trial, params=None): + raise NotImplementedError + + # ----- hyper-optimization ----- + @ignore_warnings(category=ConvergenceWarning) + def optimize(self, x_train, y_train, n_trails, timeout, feature_names=None): + self.x_train = x_train + self.y_train = y_train + self.optuna_report = self._initial_optuna_report(n_trails, timeout) + for key, value in self.param_grid.items(): + if len(value) > 1 and key != 'expert_knowledge': + self.is_single = False + break + + if not self.is_single: + self.optuna_report["optuna_used"] = True + self.study = optuna.create_study(direction=self.metric_direction, sampler=self.sampler) + if self.model_type == "Binary" and self.model_name in ["Extreme Gradient Boosting", "Light Gradient Boosting"]: + pos_inst = sum(y_train) + neg_inst = len(y_train) - pos_inst + class_weight = neg_inst / float(pos_inst) + self.study.optimize(lambda trial: self.objective(trial, params={'class_weight': class_weight}), + n_trials=n_trails, timeout=timeout, catch=(ValueError,)) + elif self.model_name == "Genetic Programming": + self.study.optimize(lambda trial: self.objective(trial, params={'feature_names': feature_names}), + n_trials=n_trails, timeout=timeout, catch=(ValueError,)) + else: + self.study.optimize(lambda trial: self.objective(trial), + n_trials=n_trails, timeout=timeout, catch=(ValueError,)) + + self._finalize_optuna_report() + logging.info('Best trial:') + best_trial = self.study.best_trial + logging.info(' Value: ' + str(best_trial.value)) + logging.info(' Params: ') + for key, value in best_trial.params.items(): + logging.info(' {}: {}'.format(key, value)) + if self.small_name == "ANN": + layers = [] + for j in range(best_trial.params['n_layers']): + layer_name = 'n_units_l' + str(j) + layers.append(best_trial.params[layer_name]) + del best_trial.params[layer_name] + best_trial.params['hidden_layer_sizes'] = tuple(layers) + del best_trial.params['n_layers'] + self.params = best_trial.params + self.optuna_report["best_params"] = dict(self.params) + self.model = copy.deepcopy(self.model).set_params(**best_trial.params) + else: + self.optuna_report["optuna_used"] = False + self.params = copy.deepcopy(self.param_grid) + for key, value in self.param_grid.items(): + self.params[key] = value[0] + self.model = copy.deepcopy(self.model).set_params(**self.params) + + @staticmethod + def _initial_optuna_report(n_trials, timeout): + return { + "optuna_used": False, + "requested_trials": n_trials, + "timeout_seconds": timeout, + "trials_run": 0, + "trials_complete": 0, + "trials_pruned": 0, + "trials_failed": 0, + "trial_state_counts": {}, + "best_trial_number": None, + "best_value": None, + "best_params": {}, + } + + def _finalize_optuna_report(self): + if self.study is None: + return + trials = list(self.study.trials) + state_counts = {} + for trial in trials: + state = getattr(trial, "state", None) + state_name = getattr(state, "name", str(state)) + state_counts[state_name] = state_counts.get(state_name, 0) + 1 + + self.optuna_report.update({ + "trials_run": len(trials), + "trials_complete": state_counts.get("COMPLETE", 0), + "trials_pruned": state_counts.get("PRUNED", 0), + "trials_failed": state_counts.get("FAIL", 0), + "trial_state_counts": state_counts, + }) + + try: + best_trial = self.study.best_trial + self.optuna_report.update({ + "best_trial_number": best_trial.number, + "best_value": best_trial.value, + "best_params": dict(best_trial.params), + }) + except Exception: + pass + + # ----- shared utilities ----- + def hyper_eval(self): + logging.debug("Trial Parameters: " + str(self.params)) + logging.debug("Trial Metric: " + str(self.scoring_metric)) + try: + model = copy.deepcopy(self.model).set_params(**self.params) + mean_cv_score = cross_val_score(model, self.x_train, self.y_train, + scoring=self.scoring_metric, + cv=self.cv, n_jobs=self.n_jobs).mean() + except Exception as e: + logging.error("KeyError while copying model " + self.model_name) + logging.error(str(e)) + model_class = self.model.__class__ + model = model_class(**self.params) + if self.scoring_metric.startswith('mean_'): + cv_scoring_metric = 'neg_'+self.scoring_metric + else: + cv_scoring_metric = self.scoring_metric + mean_cv_score = cross_val_score(model, self.x_train, self.y_train, + scoring=cv_scoring_metric, + cv=self.cv, n_jobs=self.n_jobs).mean() + logging.debug("Trail Completed") + logging.debug("Mean CV Score:" + str(mean_cv_score)) + return mean_cv_score + + def fit(self, x_train, y_train, n_trails, timeout, feature_names=None): + """ + Optimize → fit → (optional) calibrate for classifiers + """ + self.optimize(x_train, y_train, n_trails, timeout, feature_names) + self.model.fit(x_train, y_train) + + # Optional probability calibration for classification models + # Don't need this because we have calibration in ModelJob now + # if self.calibrate and getattr(self, "model_type", None) in {"Binary", "Multiclass"}: + # try: + # cal = CalibratedClassifierCV( + # estimator=self.model, + # method=self.calibrate_method, + # cv=self.calibrate_cv + # ) + # cal.fit(x_train, y_train) + # self.model = cal + # logging.info(f"Calibrated {self.small_name} with {self.calibrate_method} (cv={self.calibrate_cv})") + # except Exception as e: + # logging.warning(f"Calibration failed for {self.small_name}: {e}") + + def predict(self, x_in): + return self.model.predict(x_in) + + def predict_proba(self, x_in): + proba = getattr(self.model, "predict_proba", None) + if proba is None: + return None + return proba(x_in) diff --git a/streamline/p6_modeling/utils/categorical.py b/streamline/p6_modeling/utils/categorical.py new file mode 100644 index 00000000..9df30090 --- /dev/null +++ b/streamline/p6_modeling/utils/categorical.py @@ -0,0 +1,181 @@ +from __future__ import annotations + +from typing import Iterable, List, Optional + +import numpy as np +import pandas as pd +from pandas.api.types import is_bool_dtype +from sklearn.base import BaseEstimator + + +MISSING_CATEGORY_TOKEN = "__STREAMLINE_MISSING__" +NATIVE_CATEGORICAL_MODELS_DEFAULT = "CGB,ExSTraCS" +NATIVE_CATEGORICAL_MODEL_IDS_DEFAULT = ( + "CGB", + "Category Gradient Boosting", + "ExSTraCS", +) + + +def normalize_model_id(value: object) -> str: + return str(value or "").strip().lower().replace(" ", "_").replace("-", "_") + + +def parse_model_id_csv(value: object, default: Optional[Iterable[str]] = None) -> set[str]: + if value is None: + tokens = list(default or []) + elif isinstance(value, (list, tuple, set)): + tokens = list(value) + else: + tokens = [x.strip() for x in str(value).split(",") if x.strip()] + return {normalize_model_id(token) for token in tokens if str(token).strip()} + + +def cast_native_categoricals(df: pd.DataFrame, categorical_columns: Iterable[str]) -> pd.DataFrame: + out = df.copy() + for col in categorical_columns: + if col in out.columns: + out[col] = out[col].where(out[col].notna(), MISSING_CATEGORY_TOKEN).astype(str) + return out + + +def one_hot_align( + train_or_input: pd.DataFrame, + categorical_columns: Iterable[str], + encoded_feature_names: Optional[List[str]] = None, +) -> pd.DataFrame: + categorical_columns = [c for c in categorical_columns if c in train_or_input.columns] + encoded = pd.get_dummies(train_or_input, columns=categorical_columns) + if encoded_feature_names is not None: + encoded = encoded.reindex(columns=encoded_feature_names, fill_value=0) + for col in encoded.columns: + if is_bool_dtype(encoded[col]): + encoded[col] = encoded[col].astype(int) + encoded = encoded.apply(pd.to_numeric, errors="coerce") + return encoded + + +def to_numeric_matrix(data) -> np.ndarray: + if isinstance(data, pd.DataFrame): + frame = data + else: + arr = np.asarray(data) + if arr.ndim == 1: + arr = arr.reshape(1, -1) + frame = pd.DataFrame(arr) + return frame.apply(pd.to_numeric, errors="coerce").to_numpy(dtype=float, na_value=np.nan) + + +class FeatureTypeModelWrapper(BaseEstimator): + """ + Prediction-time adapter for models trained from raw categorical CV columns. + + P6 may train non-native estimators on one-hot-expanded features or native + categorical estimators on raw categorical columns. The saved estimator needs + to remember that preparation because later phases load only the pickle. + """ + + def __init__( + self, + estimator, + *, + mode: str, + raw_feature_names: Iterable[str], + categorical_columns: Iterable[str], + encoded_feature_names: Optional[Iterable[str]] = None, + ): + self.estimator = estimator + self.mode = mode + self.raw_feature_names = list(raw_feature_names) + self.categorical_columns = list(categorical_columns) + self.encoded_feature_names = ( + list(encoded_feature_names) if encoded_feature_names is not None else None + ) + + def _as_raw_frame(self, X) -> pd.DataFrame: + if isinstance(X, pd.DataFrame): + missing = [c for c in self.raw_feature_names if c not in X.columns] + if missing: + return X.copy() + return X.loc[:, self.raw_feature_names].copy() + + arr = np.asarray(X) + if arr.ndim == 1: + arr = arr.reshape(1, -1) + if arr.shape[1] == len(self.raw_feature_names): + return pd.DataFrame(arr, columns=self.raw_feature_names) + return pd.DataFrame(arr) + + def _prepare(self, X): + if self.mode == "numeric": + if isinstance(X, pd.DataFrame): + missing = [c for c in self.raw_feature_names if c not in X.columns] + if not missing: + X = X.loc[:, self.raw_feature_names] + return to_numeric_matrix(X) + + if self.mode == "one_hot": + arr = np.asarray(X) + if ( + not isinstance(X, pd.DataFrame) + and arr.ndim == 2 + and arr.shape[1] == len(self.raw_feature_names) + ): + raw = self._as_raw_frame(X) + return one_hot_align( + raw, + self.categorical_columns, + self.encoded_feature_names, + ).to_numpy(dtype=float, na_value=np.nan) + if ( + not isinstance(X, pd.DataFrame) + and arr.ndim == 2 + and self.encoded_feature_names is not None + and arr.shape[1] == len(self.encoded_feature_names) + ): + return to_numeric_matrix(X) + if isinstance(X, pd.DataFrame) and self.encoded_feature_names is not None: + if all(c in X.columns for c in self.encoded_feature_names): + return to_numeric_matrix(X.loc[:, self.encoded_feature_names]) + raw = self._as_raw_frame(X) + return one_hot_align( + raw, + self.categorical_columns, + self.encoded_feature_names, + ).to_numpy(dtype=float, na_value=np.nan) + + if self.mode == "native": + raw = self._as_raw_frame(X) + return cast_native_categoricals(raw, self.categorical_columns) + + return X + + def fit(self, X, y=None, **fit_params): + self.estimator.fit(self._prepare(X), y, **fit_params) + return self + + def predict(self, X): + return self.estimator.predict(self._prepare(X)) + + def transform_features(self, X): + return self._prepare(X) + + @property + def classes_(self): + return getattr(self.estimator, "classes_") + + @property + def feature_importances_(self): + return getattr(self.estimator, "feature_importances_") + + def __getattr__(self, name): + if name.startswith("__"): + raise AttributeError(name) + if name in {"predict_proba", "decision_function", "predict_log_proba", "score"}: + estimator_method = getattr(self.estimator, name) + + def _wrapped(X, *args, **kwargs): + return estimator_method(self._prepare(X), *args, **kwargs) + + return _wrapped + return getattr(self.estimator, name) diff --git a/streamline/p6_modeling/utils/loader.py b/streamline/p6_modeling/utils/loader.py new file mode 100644 index 00000000..f01e42eb --- /dev/null +++ b/streamline/p6_modeling/utils/loader.py @@ -0,0 +1,242 @@ +from __future__ import annotations +import importlib +import inspect +import os +import sys +from pathlib import Path +from types import ModuleType +from typing import List, Optional, Type, Dict + + +if __name__ == "__main__" and __package__ is None: + print("Adjusting sys.path for standalone execution...") + repo_root = Path(__file__).resolve().parent.parent.parent.parent + print(f" Repo root: {repo_root}") + sys.path.insert(0, str(repo_root)) + +PKG_ROOT = "streamline.p6_modeling.models" + +SUBDIR = { + "Binary": "binary_classification", + "Multiclass": "multiclass_classification", + "Regression": "regression", +} + +OUTCOME_TYPE_TO_MODEL_TYPE = { + "binary": "Binary", + "binaryclassification": "Binary", + "binary_classification": "Binary", + "multiclass": "Multiclass", + "multiclassclassification": "Multiclass", + "multiclass_classification": "Multiclass", + "continuous": "Regression", + "regression": "Regression", +} + +DEFAULT_EXCLUDED_MODEL_IDS = {"elcs"} + + +def normalize_modeling_type(outcome_type: Optional[str] = None, model_type: Optional[str] = None) -> str: + value = outcome_type if outcome_type not in (None, "") else model_type + if value in (None, ""): + return "Binary" + + text = str(value).strip() + normalized = OUTCOME_TYPE_TO_MODEL_TYPE.get(text.lower()) + if normalized: + return normalized + if text in SUBDIR: + return text + + known = ", ".join(["Binary", "Multiclass", "Continuous", "Regression"]) + raise ValueError(f"Unknown outcome_type/model_type '{value}'. Expected one of: {known}") + + +def modeling_type_to_outcome_type(model_type: Optional[str]) -> str: + normalized = normalize_modeling_type(model_type=model_type) + return "Continuous" if normalized == "Regression" else normalized + + +def _get_models_root() -> Path: + """ + Get the filesystem path corresponding to PKG_ROOT. + This avoids relying on __file__ of the current module. + """ + pkg = importlib.import_module(PKG_ROOT) + pkg_file = getattr(pkg, "__file__", None) + if not pkg_file: + raise RuntimeError(f"Cannot determine filesystem path for package {PKG_ROOT!r}") + return Path(pkg_file).parent + + +def _iter_modnames(folder: Path, package: str): + for fn in os.listdir(folder): + if fn.endswith(".py") and fn != "__init__.py": + yield f"{package}.{fn[:-3]}" + + +def _try_import(modname: str) -> Optional[ModuleType]: + try: + return importlib.import_module(modname) + except Exception as e: + print(f" [WARN] Failed to import module {modname!r}") + print(f" Exception: {e!r}") + return None + + +def load_model_classes(model_type: str) -> List[Type]: + sub = SUBDIR.get(model_type) + if sub is None: + raise ValueError(f"Unknown model_type '{model_type}'") + + root = _get_models_root() + folder = root / sub + package = f"{PKG_ROOT}.{sub}" + + classes: List[Type] = [] + if not folder.exists(): + return classes + + for modname in _iter_modnames(folder, package): + mod = _try_import(modname) + if not mod: + continue + for name in dir(mod): + obj = getattr(mod, name) + if inspect.isclass(obj) and getattr(obj, "__module__", "").startswith(mod.__name__): + # Must expose these attrs (used by Phase 6) + required = ("small_name", "model_name", "model_type") + if all(hasattr(obj, k) for k in required): + classes.append(obj) + + return sorted(classes, key=lambda c: getattr(c, "model_name", str(c))) + + +def model_class_ids(model_class: Type) -> set[str]: + return { + str(getattr(model_class, "small_name", "")).strip().lower(), + str(getattr(model_class, "model_name", "")).strip().lower(), + } + + +def is_default_excluded_model(model_class: Type) -> bool: + return bool(model_class_ids(model_class).intersection(DEFAULT_EXCLUDED_MODEL_IDS)) + + +def load_default_model_classes(model_type: str) -> List[Type]: + return [ + model_class for model_class in load_model_classes(model_type) + if not is_default_excluded_model(model_class) + ] + + +def get_model_by_id(model_type: str, model_id: str) -> Type: + mid = (model_id or "").strip().lower() + for cls in load_model_classes(model_type): + aliases = { + getattr(cls, "small_name", "").lower(), + getattr(cls, "model_name", "").lower().replace("_", " "), + } + # print(aliases, mid) + if mid in aliases: + return cls + raise ValueError(f"Model '{model_id}' not found for type '{model_type}'") + + +# ----------------------------- +# NEW: listing helpers +# ----------------------------- +def _class_to_entry(cls: Type) -> Dict[str, str]: + """Return a human/CLI-friendly entry for a discovered model class.""" + return { + "small_name": getattr(cls, "small_name", ""), + "alt_id": getattr(cls, "model_name", "").replace("_", " "), + "model_name": getattr(cls, "model_name", ""), + "model_type": getattr(cls, "model_type", ""), + "module": getattr(cls, "__module__", ""), + "qualname": f"{cls.__module__}.{cls.__name__}", + } + + +def list_models(model_type: str) -> List[Dict[str, str]]: + """ + List available models for a given model_type. + Returns a list of dict entries with: + {id, alt_id, name, type, module, qualname} + """ + return [_class_to_entry(c) for c in load_model_classes(model_type)] + + +def list_all_models() -> List[Dict[str, str]]: + """ + List all models across Binary, Multiclass, Regression. + """ + out: List[Dict[str, str]] = [] + for mt in SUBDIR.keys(): + out.extend(list_models(mt)) + return out + + +if __name__ == "__main__": + """ + Simple self-test / debug runner. + + Usage: + python -m streamline.p6_modeling.model_registry + + or, from the repo root (if this file is model_registry.py): + python -m streamline.p6_modeling.model_registry + """ + import pprint + import sys + + print("=== Model registry self-test ===") + print(f"PKG_ROOT = {PKG_ROOT!r}") + + # 1) Sanity: list all models + try: + all_models = list_all_models() + except Exception as e: + print("ERROR: failed to list models:", repr(e)) + sys.exit(1) + + print(f"Discovered {len(all_models)} models in total.") + if not all_models: + print("No models were discovered. Check that:") + print(" - The package", PKG_ROOT, "exists and is importable.") + print(" - Subdirectories binary_classification, multiclass_classification, regression exist.") + print(" - Each model file defines a class with small_name, model_name, model_type.") + sys.exit(0) + + print("\nDiscovered models:") + pprint.pprint(all_models) + + # 2) Round-trip: make sure get_model_by_id works for each entry with an id + print("\nRunning round-trip get_model_by_id checks...") + ok_count = 0 + for entry in all_models: + mt = entry.get("model_type") or "" + mid = entry.get("model_name") or "" + + + if not mt or not mid: + # skip entries without required info + continue + try: + cls = get_model_by_id(mt, mid) + except Exception as e: + print(f" [FAIL] type={mt!r} id={mid!r}: {e!r}") + continue + + if getattr(cls, "small_name", None) != mid and getattr(cls, "model_name", None) != mid: + print( + f" [FAIL] type={mt!r} id={mid!r}: " + f"resolved class small_name={getattr(cls, 'small_name', None)!r}" + ) + continue + + ok_count += 1 + print(f" [OK] type={mt!r} id={mid!r} -> {cls.__module__}.{cls.__name__}") + + print(f"\nRound-trip checks completed. Successful lookups: {ok_count}") + print("=== Self-test done ===") diff --git a/streamline/p6_modeling/utils/modeljob.py b/streamline/p6_modeling/utils/modeljob.py new file mode 100644 index 00000000..16cf1ba9 --- /dev/null +++ b/streamline/p6_modeling/utils/modeljob.py @@ -0,0 +1,599 @@ +import os +import logging +import pickle +import random +import time +import json +import numpy as np +import optuna +import pandas as pd +from sklearn.inspection import permutation_importance +from sklearn.model_selection import StratifiedShuffleSplit +from sklearn.calibration import CalibratedClassifierCV +from pandas.api.types import is_object_dtype, is_string_dtype + +from streamline.p6_modeling.utils.categorical import ( + FeatureTypeModelWrapper, + NATIVE_CATEGORICAL_MODEL_IDS_DEFAULT, + cast_native_categoricals, + normalize_model_id, + one_hot_align, + parse_model_id_csv, + to_numeric_matrix, +) + + +class ModelJob: + def __init__(self, full_path, output_path, experiment_name, cv_count, outcome_label="Class", + instance_label=None, scoring_metric='balanced_accuracy', metric_direction='maximize', n_trials=200, + timeout=900, training_subsample=0, uniform_fi=False, save_plot=False, random_state=None, + bypass_one_hot_for_native_models=True, native_categorical_models=None, + # NEW: calibration controls (classification only) + calibrate=False, calibrate_method="sigmoid", calibrate_cv=5): + """ + Phase-local ModelJob with optional probability calibration. + """ + super().__init__() + self.algorithm = "" + self.output_path = output_path + self.experiment_name = experiment_name + self.outcome_label = outcome_label + self.instance_label = instance_label + self.scoring_metric = scoring_metric + self.metric_direction = metric_direction + self.full_path = full_path + self.cv_count = cv_count + self.data_name = self.full_path.split('/')[-1] + self.train_file_path = self.full_path + '/CVDatasets/' + self.data_name \ + + '_CV_' + str(self.cv_count) + '_Train.csv' + self.test_file_path = self.full_path + '/CVDatasets/' + self.data_name \ + + '_CV_' + str(self.cv_count) + '_Test.csv' + + feature_names = pd.read_csv(self.train_file_path).columns.values.tolist() + if self.instance_label is not None: + try: + feature_names.remove(self.instance_label) + except ValueError: + pass + if self.outcome_label in feature_names: + feature_names.remove(self.outcome_label) + self.feature_names = feature_names + + if not os.path.exists(self.output_path): + raise Exception("Output path must exist (from phase 1) before phase 6 can begin") + if not os.path.exists(self.output_path + '/' + self.experiment_name): + raise Exception("Experiment must exist (from phase 1) before phase 6 can begin") + + self.n_trials = n_trials + self.timeout = timeout + self.training_subsample = training_subsample + self.random_state = random_state + self.uniform_fi = uniform_fi + self.feature_importance = None + self.save_plot = save_plot + self.param_grid = None + self.bypass_one_hot_for_native_models = bool(bypass_one_hot_for_native_models) + self.native_categorical_models = parse_model_id_csv( + native_categorical_models, + default=NATIVE_CATEGORICAL_MODEL_IDS_DEFAULT, + ) + self.raw_feature_names = list(self.feature_names) + self.raw_categorical_feature_names = [] + self.categorical_feature_names = [] + self.categorical_encoding_mode = "none" + self.encoded_feature_names = list(self.feature_names) + + # calibration + self.calibrate = bool(calibrate) + self.calibrate_method = calibrate_method + self.calibrate_cv = calibrate_cv + + def run(self, model): + self.job_start_time = time.time() + self.algorithm = model.small_name + logging.info('Running ' + str(self.algorithm) + ' on ' + str(self.train_file_path)) + + metrics_dir = os.path.join(self.full_path, 'model_evaluation', 'metrics_by_cv') + curves_dir = os.path.join(self.full_path, 'model_evaluation', 'curves_by_cv') + os.makedirs(metrics_dir, exist_ok=True) + os.makedirs(curves_dir, exist_ok=True) + + if model.model_type != "Regression": + metrics_payload, curves_payload = self.run_model(model) + + # ---- JSON metrics ---- + mpath = os.path.join( + metrics_dir, + f"{self.algorithm}_CV_{self.cv_count}.json", + ) + with open(mpath, "w") as f: + json.dump(metrics_payload, f, indent=2) + + # ---- JSON curves (ROC + PRC) ---- + if curves_payload is not None: + roc = curves_payload.get("roc", {}) + prc = curves_payload.get("prc", {}) + + if roc: + rpath = os.path.join( + curves_dir, + f"{self.algorithm}_CV_{self.cv_count}_roc.json", + ) + with open(rpath, "w") as f: + json.dump(roc, f, indent=2) + + if prc: + ppath = os.path.join( + curves_dir, + f"{self.algorithm}_CV_{self.cv_count}_prc.json", + ) + with open(ppath, "w") as f: + json.dump(prc, f, indent=2) + + else: + metrics_payload, residuals = self.run_model(model) + + # ---- JSON metrics (regression) ---- + mpath = os.path.join( + metrics_dir, + f"{self.algorithm}_CV_{self.cv_count}.json", + ) + with open(mpath, "w") as f: + json.dump(metrics_payload, f, indent=2) + + # ---- residuals still pickled (not metrics) ---- + rpath = os.path.join( + self.full_path, + 'model_evaluation', + 'pickled_metrics', + f"{self.algorithm}_CV_{self.cv_count}_residuals.pickle", + ) + with open(rpath, "wb") as f: + pickle.dump(residuals, f) + + self.save_runtime() + logging.info(self.full_path.split('/')[-1] + " [CV_" + str(self.cv_count) + "] (" + self.algorithm + + ") training complete. ------------------------------------") + experiment_path = '/'.join(self.full_path.split('/')[:-1]) + os.makedirs(experiment_path + '/jobsCompleted/', exist_ok=True) + job_file = open(experiment_path + '/jobsCompleted/job_model_' + self.full_path.split('/')[-1] + + '_' + str(self.cv_count) + '_' + self.algorithm + '.txt', 'w') + job_file.write('complete') + job_file.close() + + + def run_model(self, model): + random.seed(self.random_state) + np.random.seed(self.random_state) + x_train, y_train, x_test, y_test = self.data_prep(model) + self._configure_native_categorical_model(model) + + # optional training subsample for certain models + if 0 < self.training_subsample < x_train.shape[0] and model.small_name in ['XGB', 'SVM', 'ANN', 'KNN']: + sss = StratifiedShuffleSplit(n_splits=1, train_size=self.training_subsample, random_state=self.random_state) + for train_index, _ in sss.split(x_train, y_train): + x_train = self._take_rows(x_train, train_index) + y_train = y_train[train_index] + logging.warning('For ' + model.small_name + + ', training sample reduced to ' + str(x_train.shape[0]) + ' instances') + + try: + model.fit(x_train, y_train, self.n_trials, self.timeout, self.feature_names) + except Exception: + if ( + self.categorical_encoding_mode == "native" + and self.bypass_one_hot_for_native_models + and not self._p1_one_hot_disabled() + ): + logging.warning( + "Native categorical fit failed for %s; retrying with one-hot encoded categoricals.", + model.small_name, + exc_info=True, + ) + x_train, y_train, x_test, y_test = self.data_prep(model, force_one_hot=True) + self._configure_native_categorical_model(model) + model.fit(x_train, y_train, self.n_trials, self.timeout, self.feature_names) + else: + raise + + os.makedirs(self.full_path + '/models/', exist_ok=True) + os.makedirs(self.full_path + '/models/pickledModels/', exist_ok=True) + # keep pickled_metrics only for residuals (regression) + if not os.path.exists(self.full_path + '/model_evaluation/pickled_metrics/'): + os.makedirs(self.full_path + '/model_evaluation/pickled_metrics/', exist_ok=True) + # NEW: JSON outputs + if not os.path.exists(self.full_path + '/model_evaluation/metrics_by_cv/'): + os.makedirs(self.full_path + '/model_evaluation/metrics_by_cv/', exist_ok=True) + if not os.path.exists(self.full_path + '/model_evaluation/curves_by_cv/'): + os.makedirs(self.full_path + '/model_evaluation/curves_by_cv/', exist_ok=True) + + self.export_optuna_report(model) + + # Export tuned / used params + if not model.is_single: + if self.save_plot: + try: + fig = optuna.visualization.plot_parallel_coordinate(model.study) + fig.write_image(self.full_path + '/models/' + self.algorithm + + '_ParamOptimization_' + str(self.cv_count) + '.png') + except Exception as e: + logging.warning(str(e)) + logging.warning('Warning: Optuna plot failed. Consider optuna==2.0.0.') + self.export_best_params(self.full_path + '/models/' + self.algorithm + + '_bestparams' + str(self.cv_count) + '.csv', + model.params) + else: + self.export_best_params(self.full_path + '/models/' + self.algorithm + + '_usedparams' + str(self.cv_count) + '.csv', + model.params) + + # ---------- NEW: probability calibration (classification only) ---------- + if self.calibrate and model.model_type in ["Binary", "Multiclass"]: + try: + cal = CalibratedClassifierCV(estimator=model.model, + method=self.calibrate_method, + cv=self.calibrate_cv) + cal.fit(x_train, y_train) + model.model = cal + logging.info(f"Calibrated {self.algorithm} with {self.calibrate_method} (cv={self.calibrate_cv})") + except Exception as e: + logging.warning(f"Calibration failed for {self.algorithm}: {e}") + + # Feature importance + perm_scoring_metric = self.scoring_metric + if self.scoring_metric.startswith('mean_'): + perm_scoring_metric = 'neg_'+self.scoring_metric + + if self.uniform_fi: + results = permutation_importance(model.model, x_train, y_train, n_repeats=10, + random_state=self.random_state, scoring=perm_scoring_metric) + self.feature_importance = results.importances_mean + else: + try: + self.feature_importance = model.model.feature_importances_ + except AttributeError: + results = permutation_importance(model.model, x_train, y_train, n_repeats=10, + random_state=self.random_state, scoring=perm_scoring_metric) + self.feature_importance = results.importances_mean + self.feature_importance = self._feature_importance_for_report(self.feature_importance) + + # Persist model + persisted_model = self._wrap_model_if_needed(model.model) + with open(self.full_path + '/models/pickledModels/' + self.algorithm + + '_' + str(self.cv_count) + '.pickle', 'wb') as file: + pickle.dump(persisted_model, file) + + fi = self.feature_importance + # convert FI to plain list for JSON + if hasattr(fi, "tolist"): + fi_list = fi.tolist() + else: + fi_list = [float(x) for x in fi] + + # Evaluate (uses each model’s own model_evaluation) + if model.model_type == "Regression": + metric_dict = model.model_evaluation(x_test, y_test) + + y_train_pred = model.predict(x_train) + y_pred = model.predict(x_test) + residual_train = y_train - y_train_pred + residual_test = y_test - y_pred + + metrics_payload = { + "metrics": metric_dict, + "feature_importance": fi_list, + "optuna": self._json_safe(getattr(model, "optuna_report", {})), + "categorical_feature_handling": self._categorical_report(), + } + + # curves are not defined for regression + curves_payload = None + + return metrics_payload, [residual_train, residual_test, y_train_pred, y_pred, y_train, y_test] + + elif model.model_type in ["Binary", "Multiclass"]: + metric_dict, curves_dict = model.model_evaluation(x_test, y_test) + + metrics_payload = { + "metrics": metric_dict, + "feature_importance": fi_list, + "optuna": self._json_safe(getattr(model, "optuna_report", {})), + "categorical_feature_handling": self._categorical_report(), + } + curves_payload = curves_dict + + return metrics_payload, curves_payload + + + def data_prep(self, model=None, force_one_hot=False): + train = pd.read_csv(self.train_file_path) + test = pd.read_csv(self.test_file_path) + if self.instance_label is not None: + train = train.drop(self.instance_label, axis=1) + test = test.drop(self.instance_label, axis=1) + x_train = train.drop(self.outcome_label, axis=1) + y_train = train[self.outcome_label].values + x_test = test.drop(self.outcome_label, axis=1) + y_test = test[self.outcome_label].values + self.raw_feature_names = list(x_train.columns) + + categorical_cols = self._categorical_columns(x_train, x_test) + self.raw_categorical_feature_names = list(categorical_cols) + + use_native = ( + bool(categorical_cols) + and not force_one_hot + and self.bypass_one_hot_for_native_models + and model is not None + and self._model_allows_native_categorical(model) + ) + + if use_native: + x_train = cast_native_categoricals(x_train, categorical_cols) + x_test = cast_native_categoricals(x_test, categorical_cols) + self.feature_names = list(x_train.columns) + self.encoded_feature_names = list(x_train.columns) + self.categorical_feature_names = list(categorical_cols) + self.categorical_encoding_mode = "native" + del train; del test + return x_train, y_train, x_test, y_test + + if categorical_cols and self._p1_one_hot_disabled(): + model_name = self._model_label(model) + raise ValueError( + "P1 feature metadata shows one_hot_encoding=False, so Phase 6 cannot " + f"one-hot encode raw categorical columns for {model_name}. " + "Only models listed in --native_categorical_models may run in this mode. " + "Native categorical model ids: " + + ", ".join(sorted(self.native_categorical_models)) + ) + + if categorical_cols: + x_train = one_hot_align(x_train, categorical_cols) + x_test = one_hot_align(x_test, categorical_cols, list(x_train.columns)) + self.feature_names = list(x_train.columns) + self.encoded_feature_names = list(x_train.columns) + self.categorical_feature_names = [] + self.categorical_encoding_mode = "one_hot" + del train; del test + return to_numeric_matrix(x_train), y_train, to_numeric_matrix(x_test), y_test + + self.feature_names = list(x_train.columns) + self.encoded_feature_names = list(x_train.columns) + self.categorical_feature_names = [] + self.categorical_encoding_mode = "none" + del train; del test + return to_numeric_matrix(x_train), y_train, to_numeric_matrix(x_test), y_test + + @staticmethod + def _take_rows(x, indices): + if hasattr(x, "iloc"): + return x.iloc[indices].reset_index(drop=True) + return x[indices] + + def _load_feature_meta(self): + meta_pickle = os.path.join(self.full_path, "exploratory", "feature_meta.pickle") + meta_json = os.path.join(self.full_path, "exploratory", "feature_meta.json") + try: + if os.path.exists(meta_pickle): + with open(meta_pickle, "rb") as f: + return pickle.load(f) + if os.path.exists(meta_json): + with open(meta_json, "r") as f: + return json.load(f) + except Exception as exc: + logging.warning("Could not load feature metadata for categorical handling: %s", exc) + return {} + + def _p1_one_hot_disabled(self): + meta = self._load_feature_meta() + if "one_hot" not in meta: + return False + value = meta.get("one_hot") + if isinstance(value, bool): + return not value + return str(value).strip().lower() in {"0", "false", "f", "no", "n"} + + @staticmethod + def _model_label(model): + if model is None: + return "this model" + small = getattr(model, "small_name", "") + name = getattr(model, "model_name", "") + if small and name: + return f"{small} ({name})" + return small or name or "this model" + + def _metadata_categorical_columns(self, feature_columns): + meta = self._load_feature_meta() + names = meta.get("feature_names", []) + mask = meta.get("categorical_mask", []) + one_hot_features = set(meta.get("one_hot_features", [])) + declared_features = meta.get("categorical_features", []) + if isinstance(declared_features, str): + declared_features = [declared_features] + categorical = { + name + for name, is_categorical in zip(names, mask) + if is_categorical and name not in one_hot_features + } + categorical.update(declared_features) + return [col for col in feature_columns if col in categorical] + + @staticmethod + def _dtype_categorical_columns(df): + cols = [] + for col in df.columns: + dtype = df[col].dtype + if is_object_dtype(dtype) or is_string_dtype(dtype) or isinstance(dtype, pd.CategoricalDtype): + cols.append(col) + return cols + + def _categorical_columns(self, x_train, x_test): + feature_columns = list(x_train.columns) + categorical = set(self._metadata_categorical_columns(feature_columns)) + categorical.update(self._dtype_categorical_columns(x_train)) + categorical.update(self._dtype_categorical_columns(x_test)) + return [col for col in feature_columns if col in categorical] + + def _model_allows_native_categorical(self, model): + ids = { + normalize_model_id(getattr(model, "small_name", "")), + normalize_model_id(getattr(model, "model_name", "")), + } + return bool(ids.intersection(self.native_categorical_models)) + + def _configure_native_categorical_model(self, model): + estimator = getattr(model, "model", None) + if estimator is None or not hasattr(estimator, "set_params"): + return + + try: + params = estimator.get_params() + except Exception: + params = {} + + model_ids = { + normalize_model_id(getattr(model, "small_name", "")), + normalize_model_id(getattr(model, "model_name", "")), + } + module = estimator.__class__.__module__.lower() + name = estimator.__class__.__name__.lower() + supports_cat_features = "cat_features" in params or "catboost" in module or "catboost" in name + supports_exstracs_discrete_attributes = ( + self.categorical_encoding_mode == "native" + and ( + "exstracs" in model_ids + or "exstracs" in module + or "exstracs" in name + or ( + "discrete_attribute_limit" in params + and "specified_attributes" in params + ) + ) + ) + if not supports_cat_features and not supports_exstracs_discrete_attributes: + return + + if supports_cat_features: + cat_features = list(self.categorical_feature_names) + try: + estimator.set_params(cat_features=cat_features) + except Exception as exc: + logging.warning("Could not set cat_features on %s: %s", model.small_name, exc) + + if supports_exstracs_discrete_attributes: + categorical_indices = [ + self.feature_names.index(col) + for col in self.categorical_feature_names + if col in self.feature_names + ] + try: + estimator.set_params( + discrete_attribute_limit="d", + specified_attributes=np.asarray(categorical_indices, dtype=int), + ) + except Exception as exc: + logging.warning("Could not set ExSTraCS categorical attributes on %s: %s", model.small_name, exc) + + def _wrap_model_if_needed(self, estimator): + mode = self.categorical_encoding_mode + if mode not in {"one_hot", "native"}: + mode = "numeric" + return FeatureTypeModelWrapper( + estimator, + mode=mode, + raw_feature_names=self.raw_feature_names, + categorical_columns=self.raw_categorical_feature_names, + encoded_feature_names=self.encoded_feature_names, + ) + + def _categorical_report(self): + return { + "mode": self.categorical_encoding_mode, + "raw_feature_count": len(self.raw_feature_names), + "encoded_feature_count": len(self.encoded_feature_names), + "categorical_features": list(self.raw_categorical_feature_names), + "native_categorical_features": list(self.categorical_feature_names), + "native_categorical_indices": [ + self.feature_names.index(col) + for col in self.categorical_feature_names + if col in self.feature_names + ], + "native_categorical_models": sorted(self.native_categorical_models), + "bypass_one_hot_for_native_models": bool(self.bypass_one_hot_for_native_models), + } + + def _feature_importance_for_report(self, fi): + if self.categorical_encoding_mode != "one_hot": + return fi + if len(fi) != len(self.encoded_feature_names): + return fi + + fi_by_encoded = pd.Series(fi, index=self.encoded_feature_names, dtype="float64") + raw_values = [] + categorical = set(self.raw_categorical_feature_names) + for raw_name in self.raw_feature_names: + if raw_name in categorical: + prefix = raw_name + "_" + encoded_cols = [c for c in self.encoded_feature_names if c.startswith(prefix)] + raw_values.append(float(fi_by_encoded.loc[encoded_cols].sum()) if encoded_cols else 0.0) + elif raw_name in fi_by_encoded.index: + raw_values.append(float(fi_by_encoded.loc[raw_name])) + else: + raw_values.append(0.0) + return np.asarray(raw_values) + + @staticmethod + def _json_safe(value): + if isinstance(value, dict): + return {str(k): ModelJob._json_safe(v) for k, v in value.items()} + if isinstance(value, (list, tuple, set)): + return [ModelJob._json_safe(v) for v in value] + if isinstance(value, np.generic): + return value.item() + if isinstance(value, np.ndarray): + return value.tolist() + return value + + def export_optuna_report(self, model): + report = self._json_safe(getattr(model, "optuna_report", {})) + if not report: + return + out_dir = os.path.join(self.full_path, "models", "optuna_trials") + os.makedirs(out_dir, exist_ok=True) + row = { + "algorithm": self.algorithm, + "model_name": getattr(model, "model_name", self.algorithm), + "cv": self.cv_count, + **report, + } + for key, value in list(row.items()): + if isinstance(value, (dict, list, tuple, set)): + row[key] = json.dumps(self._json_safe(value), sort_keys=True) + out_path = os.path.join(out_dir, f"{self.algorithm}_optuna_trials{self.cv_count}.csv") + pd.DataFrame([row]).to_csv(out_path, index=False) + if report.get("optuna_used"): + logging.info( + "%s CV_%s Optuna trials: %s run, %s complete, requested=%s, timeout=%s", + self.algorithm, + self.cv_count, + report.get("trials_run"), + report.get("trials_complete"), + report.get("requested_trials"), + report.get("timeout_seconds"), + ) + + def save_runtime(self): + os.makedirs(self.full_path + '/runtime/models/' , exist_ok=True) + runtime_file = open(self.full_path + '/runtime/models/runtime_' + self.algorithm + '_CV' + str(self.cv_count) + '.txt','w') + runtime_file.write(str(time.time() - self.job_start_time)) + runtime_file.close() + + @staticmethod + def export_best_params(file_name, param_grid): + best_params_copy = param_grid + for best in best_params_copy: + best_params_copy[best] = [best_params_copy[best]] + df = pd.DataFrame.from_dict(best_params_copy) + df.to_csv(file_name, index=False) diff --git a/streamline/p6_modeling/utils/submodels.py b/streamline/p6_modeling/utils/submodels.py new file mode 100644 index 00000000..c7762938 --- /dev/null +++ b/streamline/p6_modeling/utils/submodels.py @@ -0,0 +1,456 @@ +from abc import ABC +import warnings + +import numpy as np +import optuna +import pandas as pd +from typing import Any, Dict +from scipy.stats import pearsonr +from sklearn import metrics +from sklearn.exceptions import ConvergenceWarning +from sklearn.metrics import ( + auc, + max_error, + mean_absolute_error, + mean_squared_error, + median_absolute_error, + explained_variance_score, + brier_score_loss, + accuracy_score, + balanced_accuracy_score, + f1_score, + precision_score, + recall_score, + confusion_matrix, + roc_auc_score, + average_precision_score, +) +from sklearn.model_selection import KFold +from sklearn.preprocessing import label_binarize + +# Phase-6 BaseModel (with calibration) +from streamline.p6_modeling.utils.basemodel import BaseModel +from streamline.p6_modeling.utils.support import _get_probas_or_decision, multiclass_brier_score + +# --------------------------------------------------------------------- +# Global warning configuration +# --------------------------------------------------------------------- +warnings.filterwarnings(action="ignore", module="sklearn") +warnings.filterwarnings(action="ignore", module="scipy") +warnings.filterwarnings(action="ignore", module="optuna") +warnings.filterwarnings( + action="ignore", category=ConvergenceWarning, module="sklearn" +) + +optuna.logging.set_verbosity(optuna.logging.WARNING) + +# --------------------------------------------------------------------- +# BinaryClassificationModel +# --------------------------------------------------------------------- +class BinaryClassificationModel(BaseModel, ABC): + model_type = "Binary" + + def __init__( + self, + model, + model_name, + cv_folds: int = 3, + scoring_metric: str = "balanced_accuracy", + metric_direction: str = "maximize", + random_state=None, + cv=None, + sampler=None, + n_jobs=None, + ): + super().__init__( + model=model, + model_name=model_name, + cv_folds=cv_folds, + scoring_metric=scoring_metric, + metric_direction=metric_direction, + random_state=random_state, + cv=cv, + sampler=sampler, + n_jobs=n_jobs, + ) + + def model_evaluation(self, x_test, y_test): + """ + Binary evaluation returning: + - metrics_dict: flat dict of scalar metrics + - curves_dict: { + "roc": {"micro": {"fpr": [...], "tpr": [...], "auc": float}}, + "prc": {"micro": {"precision": [...], "recall": [...], + "pr_auc": float, "aps": float}} + } + + This is what Phase 6 will serialize to JSON. + """ + probas_ = _get_probas_or_decision(self.model, x_test) + y_pred = self.model.predict(x_test) + + # --- base metrics that don't require probabilities --- + cm = confusion_matrix(y_test, y_pred) + if cm.size == 4: + tn, fp, fn, tp = cm.ravel() + else: + # defensive fallback + tn = fp = fn = tp = 0.0 + + tn = float(tn) + fp = float(fp) + fn = float(fn) + tp = float(tp) + + specificity = tn / (tn + fp) if (tn + fp) > 0 else 0.0 + npv = tn / (tn + fn) if (tn + fn) > 0 else 0.0 + lr_plus = (tp / (tp + fn)) / (fp / (fp + tn)) if (tp + fn) > 0 and (fp + tn) > 0 and fp > 0 else 0.0 + lr_minus = (fn / (tp + fn)) / (tn / (fp + tn)) if (tp + fn) > 0 and (fp + tn) > 0 and tn > 0 else 0.0 + + metrics_dict = { + "balanced_accuracy": float(balanced_accuracy_score(y_test, y_pred)), + "accuracy": float(accuracy_score(y_test, y_pred)), + "f1": float(f1_score(y_test, y_pred)), + "recall": float(recall_score(y_test, y_pred)), + "specificity": float(specificity), + "precision": float(precision_score(y_test, y_pred)), + "tp": tp, + "tn": tn, + "fp": fp, + "fn": fn, + "npv": float(npv), + "lr_plus": float(lr_plus), + "lr_minus": float(lr_minus), + # These will be filled in below if probs / scores are available + "brier_score": None, + "roc_auc": None, + "prc_auc": None, + "prc_aps": None, + } + + curves_dict = {"roc": {}, "prc": {}} + + # --- if we have probability-like scores, compute curve-based metrics --- + if probas_ is None: + return metrics_dict, curves_dict + + probas_ = np.asarray(probas_) + # If 1D, treat as positive-class score; if 2D, assume column 1 is positive class + if probas_.ndim == 1: + pos_score = probas_ + else: + # If shape is (n_samples, 2+) use column 1, else last column as positive class + if probas_.shape[1] >= 2: + pos_score = probas_[:, 1] + else: + pos_score = probas_[:, -1] + + # Brier score (if scores look like probabilities) + try: + brier = brier_score_loss(y_test, pos_score) + except Exception: + brier = float("nan") + + metrics_dict["brier_score"] = float(brier) if np.isfinite(brier) else None + + # ROC / PRC curves + fpr, tpr, _ = metrics.roc_curve(y_test, pos_score) + roc_auc_val = roc_auc_score(y_test, pos_score) + + prec, rec, _ = metrics.precision_recall_curve(y_test, pos_score) + # AUCs on the natural orientation + prc_auc_val = auc(rec, prec) + aps_val = average_precision_score(y_test, pos_score) + + metrics_dict["roc_auc"] = float(roc_auc_val) + metrics_dict["prc_auc"] = float(prc_auc_val) + metrics_dict["prc_aps"] = float(aps_val) + + curves_dict["roc"]["micro"] = { + "fpr": fpr.tolist(), + "tpr": tpr.tolist(), + "auc": float(roc_auc_val), + } + curves_dict["prc"]["micro"] = { + "precision": prec.tolist(), + "recall": rec.tolist(), + "pr_auc": float(prc_auc_val), + "aps": float(aps_val), + } + + return metrics_dict, curves_dict + + +# --------------------------------------------------------------------- +# MulticlassClassificationModel +# --------------------------------------------------------------------- +class MulticlassClassificationModel(BaseModel, ABC): + model_type = "Multiclass" + + def __init__( + self, + model, + model_name, + cv_folds: int = 3, + scoring_metric: str = "balanced_accuracy", + metric_direction: str = "maximize", + random_state=None, + cv=None, + sampler=None, + n_jobs=None, + ): + super().__init__( + model=model, + model_name=model_name, + cv_folds=cv_folds, + scoring_metric=scoring_metric, + metric_direction=metric_direction, + random_state=random_state, + cv=cv, + sampler=sampler, + n_jobs=n_jobs, + ) + + def model_evaluation(self, x_test, y_test): + """ + Rich multiclass evaluation. + + Returns: + metrics_dict: flat dict of scalar metrics (macro/micro variants) + curves_dict: { + "roc": { + "micro": {fpr,tpr,auc}, + "macro": {fpr,tpr,auc} + }, + "prc": { + "micro": {precision,recall,pr_auc,aps}, + "macro": {precision,recall,pr_auc,aps} + } + } + """ + probas_ = _get_probas_or_decision(self.model, x_test) + if probas_ is None: + # no probability-like scores; fall back to plain prediction metrics + y_pred = self.model.predict(x_test) + metrics_dict = { + "balanced_accuracy": float(balanced_accuracy_score(y_test, y_pred)), + "accuracy": float(accuracy_score(y_test, y_pred)), + "f1": float(f1_score(y_test, y_pred, average="macro")), + "brier_score": None, + "f1_macro": float(f1_score(y_test, y_pred, average="macro")), + "f1_micro": float(f1_score(y_test, y_pred, average="micro")), + "precision_macro": float(precision_score(y_test, y_pred, average="macro")), + "precision_micro": float(precision_score(y_test, y_pred, average="micro")), + "recall_macro": float(recall_score(y_test, y_pred, average="macro")), + "recall_micro": float(recall_score(y_test, y_pred, average="micro")), + "roc_auc_macro": None, + "roc_auc_micro": None, + "average_precision_macro": None, + "average_precision_micro": None, + } + return metrics_dict, {"roc": {}, "prc": {}} + + probas_ = np.asarray(probas_) + if probas_.ndim != 2: + raise ValueError( + "Unexpected probability shape in MulticlassClassificationModel.model_evaluation" + ) + + y_pred = self.model.predict(x_test) + classes = np.asarray(getattr(self.model, "classes_", np.unique(y_test))) + if classes.size != probas_.shape[1]: + inferred_classes = np.unique(y_test) + if inferred_classes.size == probas_.shape[1]: + classes = inferred_classes + else: + raise ValueError( + "Multiclass probability columns do not align with class labels in " + "MulticlassClassificationModel.model_evaluation" + ) + + y_test_bin = label_binarize(np.asarray(y_test), classes=classes) + if y_test_bin.ndim == 1: + y_test_bin = np.column_stack([1 - y_test_bin, y_test_bin]) + + # --- metrics dict (as you sketched) --- + metrics_dict = { + "balanced_accuracy": float(balanced_accuracy_score(y_test, y_pred)), + "accuracy": float(accuracy_score(y_test, y_pred)), + "f1": float(f1_score(y_test, y_pred, average="macro")), + "brier_score": float(multiclass_brier_score(y_test, probas_, classes=classes)), + # Additional multiclass metrics to compare + "f1_macro": float(f1_score(y_test, y_pred, average="macro")), + "f1_micro": float(f1_score(y_test, y_pred, average="micro")), + "precision_macro": float(precision_score(y_test, y_pred, average="macro")), + "precision_micro": float(precision_score(y_test, y_pred, average="micro")), + "recall_macro": float(recall_score(y_test, y_pred, average="macro")), + "recall_micro": float(recall_score(y_test, y_pred, average="micro")), + "roc_auc_macro": None, + "roc_auc_micro": None, + "average_precision_macro": None, + "average_precision_micro": None, + } + + # --- per-class & micro/macro ROC / PR curves --- + fpr: Dict[Any, np.ndarray] = {} + tpr: Dict[Any, np.ndarray] = {} + roc_auc: Dict[Any, float] = {} + prec: Dict[Any, np.ndarray] = {} + recall: Dict[Any, np.ndarray] = {} + prec_rec_auc: Dict[Any, float] = {} + ave_prec: Dict[Any, float] = {} + + n_classes = len(classes) + + # per-class ROC/PR + for i in range(n_classes): + fpr_i, tpr_i, _ = metrics.roc_curve(y_test_bin[:, i], probas_[:, i]) + fpr[i] = fpr_i + tpr[i] = tpr_i + roc_auc[i] = auc(fpr_i, tpr_i) + + p_i, r_i, _ = metrics.precision_recall_curve( + y_test_bin[:, i], probas_[:, i] + ) + prec[i] = p_i + recall[i] = r_i + prec_rec_auc[i] = auc(r_i, p_i) + ave_prec[i] = metrics.average_precision_score( + y_test_bin[:, i], probas_[:, i] + ) + + # micro ROC/PR + fpr_micro, tpr_micro, _ = metrics.roc_curve( + y_test_bin.ravel(), probas_.ravel() + ) + roc_auc_micro = auc(fpr_micro, tpr_micro) + + p_micro, r_micro, _ = metrics.precision_recall_curve( + y_test_bin.ravel(), probas_.ravel() + ) + pr_auc_micro = auc(r_micro, p_micro) + aps_micro = metrics.average_precision_score( + y_test_bin, probas_, average="micro" + ) + + # macro ROC via mean TPR on common grid + fpr_grid = np.linspace(0.0, 1.0, 1000) + mean_tpr = np.zeros_like(fpr_grid) + for i in range(n_classes): + mean_tpr += np.interp(fpr_grid, fpr[i], tpr[i]) + mean_tpr /= n_classes + roc_auc_macro = auc(fpr_grid, mean_tpr) + + # macro PR via mean precision on common recall grid + recall_grid = np.linspace(0.0, 1.0, 1000) + mean_prec = np.zeros_like(recall_grid) + for i in range(n_classes): + mean_prec += np.interp(recall_grid, recall[i], prec[i]) + mean_prec /= n_classes + pr_auc_macro = auc(recall_grid, mean_prec) + aps_macro = metrics.average_precision_score( + y_test_bin, probas_, average="macro" + ) + + metrics_dict["roc_auc_macro"] = float(roc_auc_macro) + metrics_dict["roc_auc_micro"] = float(roc_auc_micro) + metrics_dict["average_precision_macro"] = float(aps_macro) + metrics_dict["average_precision_micro"] = float(aps_micro) + + curves_dict = { + "roc": { + "micro": { + "fpr": fpr_micro.tolist(), + "tpr": tpr_micro.tolist(), + "auc": float(roc_auc_micro), + }, + "macro": { + "fpr": fpr_grid.tolist(), + "tpr": mean_tpr.tolist(), + "auc": float(roc_auc_macro), + }, + }, + "prc": { + "micro": { + "precision": p_micro.tolist(), + "recall": r_micro.tolist(), + "pr_auc": float(pr_auc_micro), + "aps": float(aps_micro), + }, + "macro": { + "precision": mean_prec.tolist(), + "recall": recall_grid.tolist(), + "pr_auc": float(pr_auc_macro), + "aps": float(aps_macro), + }, + }, + } + + return metrics_dict, curves_dict + + + +# --------------------------------------------------------------------- +# RegressionModel +# --------------------------------------------------------------------- +class RegressionModel(BaseModel, ABC): + model_type = "Regression" + + def __init__( + self, + model, + model_name, + cv_folds: int = 3, + scoring_metric: str = "explained_variance", + metric_direction: str = "maximize", + random_state=None, + cv=None, + sampler=None, + n_jobs=None, + ): + super().__init__( + model=model, + model_name=model_name, + cv_folds=cv_folds, + scoring_metric=scoring_metric, + metric_direction=metric_direction, + random_state=random_state, + cv=cv, + sampler=sampler, + n_jobs=n_jobs, + ) + self.cv = KFold( + n_splits=cv_folds, shuffle=True, random_state=self.random_state + ) + + def model_evaluation(self, x_test, y_test): + """ + Regression evaluation returning a flat metric dict: + + { + "max_error": ..., + "mean_absolute_error": ..., + "mean_squared_error": ..., + "median_absolute_error": ..., + "explained_variance": ..., + "pearson_correlation": ... + } + """ + y_pred = self.predict(x_test) + y_true = np.asarray(y_test) + + me = max_error(y_true, y_pred) + mae = mean_absolute_error(y_true, y_pred) + mse = mean_squared_error(y_true, y_pred) + mdae = median_absolute_error(y_true, y_pred) + evs = explained_variance_score(y_true, y_pred) + p_corr = pearsonr(y_true, y_pred)[0] + + return { + "max_error": float(me), + "mean_absolute_error": float(mae), + "mean_squared_error": float(mse), + "median_absolute_error": float(mdae), + "explained_variance": float(evs), + "pearson_correlation": float(p_corr), + } diff --git a/streamline/p6_modeling/utils/support.py b/streamline/p6_modeling/utils/support.py new file mode 100644 index 00000000..b01dbca6 --- /dev/null +++ b/streamline/p6_modeling/utils/support.py @@ -0,0 +1,61 @@ +import logging + +import numpy as np +from sklearn.preprocessing import label_binarize + + + +# --------------------------------------------------------------------- +# Support Functions +# --------------------------------------------------------------------- + +def _get_probas_or_decision(model, x): + """ + Try predict_proba, then decision_function. + + Returns: + array-like or None if neither method is available. + """ + proba_fn = getattr(model, "predict_proba", None) + if proba_fn is not None: + return proba_fn(x) + + decision_fn = getattr(model, "decision_function", None) + if decision_fn is not None: + return decision_fn(x) + + return None + +def multiclass_brier_score(y_true, y_prob, classes=None): + """ + y_true: (n_samples,) integer labels + y_prob: (n_samples, n_classes) predicted probabilities + https://stats.stackexchange.com/questions/403544/how-to-compute-the-brier-score-for-more-than-two-classes + """ + y_true = np.asarray(y_true) + y_prob = np.asarray(y_prob) + + if y_prob.ndim != 2: + raise ValueError("Multiclass Brier score expects a 2D probability array.") + + if classes is None: + classes = np.unique(y_true) + classes = np.asarray(classes) + + if classes.size != y_prob.shape[1]: + inferred_classes = np.unique(y_true) + if inferred_classes.size == y_prob.shape[1]: + classes = inferred_classes + else: + raise ValueError( + f"Multiclass Brier score class/probability mismatch: " + f"{classes.size} classes vs {y_prob.shape[1]} probability columns." + ) + + y_true_onehot = label_binarize(y_true, classes=classes) + if y_true_onehot.ndim == 1: + y_true_onehot = np.column_stack([1 - y_true_onehot, y_true_onehot]) + y_true_onehot = y_true_onehot.astype(float, copy=False) + + # Compute multiclass Brier score + return np.mean(np.sum((y_prob - y_true_onehot) ** 2, axis=1)) diff --git a/streamline/p7_ensembles/__init__.py b/streamline/p7_ensembles/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/streamline/p7_ensembles/ensembles.py b/streamline/p7_ensembles/ensembles.py new file mode 100644 index 00000000..cc50b843 --- /dev/null +++ b/streamline/p7_ensembles/ensembles.py @@ -0,0 +1,851 @@ +from __future__ import annotations +import os, re, pickle, logging, json +from pathlib import Path +from typing import List, Tuple, Optional, Dict, Any + +import numpy as np +import pandas as pd + +from sklearn.calibration import CalibratedClassifierCV +from sklearn.metrics import ( + accuracy_score, balanced_accuracy_score, f1_score, precision_score, recall_score, + confusion_matrix, roc_auc_score, precision_recall_curve, roc_curve, average_precision_score, auc +) + +from sklearn.metrics import brier_score_loss +from streamline.p6_modeling.utils.support import multiclass_brier_score +from streamline.p7_ensembles.utils.loader import get_ensemble_by_id + + +class EnsemblePhaseJob: + """ + Phase 7: Ensemble Learning on top of Phase 6 models. + Loads pickled base models per CV split, builds requested ensembles, fits on CV-Train, evaluates on CV-Test. + - Fits on CV Train and evaluates on CV Test + - Saves per-CV metrics & ROC/PRC curves to dataset_dir/ensemble_evaluation + """ + def __init__( + self, + dataset_dir: str, # // + n_splits: int, + outcome_label: str = "Class", + outcome_type: Optional[str] = None, + instance_label: Optional[str] = None, + # ensembles: CSV of ids (hard_voting,soft_voting,stack_lr,stack_dt,stack_rf) + ensembles: Optional[str] = "hard_voting,soft_voting,stack_lr", + base_models: Optional[str] = None, # comma list of small names filter (e.g., "LR,SVM,NB") + meta_train_source: str = "train", # "train" or "test" + calibrate: int = 0, + calibrate_method: str = "sigmoid", + calibrate_cv: int = 5, + random_state: Optional[int] = 0, + ): + self.ds_dir = Path(dataset_dir) + self.dataset_name = self.ds_dir.name + self.n_splits = int(n_splits) + self.outcome_label = outcome_label + self.outcome_type = _normalize_outcome_type(outcome_type) + if self.outcome_type == "Continuous": + raise NotImplementedError( + "Phase 7 ensembles currently support binary and multiclass classification only. " + "Regression ensembles are not implemented." + ) + self.instance_label = instance_label + self.ensemble_ids = [e.strip() for e in (ensembles or "").split(",") if e.strip()] + self.base_filter = [s.strip() for s in (base_models or "").split(",") if s.strip()] or None + self.meta_train_source = meta_train_source + self.calibrate = bool(calibrate) + self.calibrate_method = calibrate_method + self.calibrate_cv = int(calibrate_cv) + self.random_state = random_state + + # output dirs + self.out_root = self.ds_dir / "ensemble_evaluation" + _ensure_dir(self.out_root) + _ensure_dir(self.out_root / "pickled_ensembles") + _ensure_dir(self.out_root / "metrics_by_cv") + _ensure_dir(self.out_root / "curves_by_cv") + + def run(self): + for cv in range(self.n_splits): + logging.info(f"[P7] {self.dataset_name} CV={cv}: loading base estimators...") + base_ests = _load_base_estimators(self.ds_dir, cv, self.base_filter) + if not base_ests: + logging.warning(f"[P7] No base estimators found for CV {cv}. Skipping.") + continue + + train_df, test_df = _load_cv_df(self.ds_dir, self.dataset_name, cv) + train_df = _drop_instance(train_df, self.instance_label) + test_df = _drop_instance(test_df, self.instance_label) + X_train, y_train = _prep_xy(train_df, self.outcome_label) + X_test, y_test = _prep_xy(test_df, self.outcome_label) + + for ens_id in self.ensemble_ids: + Ens = get_ensemble_by_id(ens_id) + ens_small = getattr(Ens, "small_name", ens_id) + ens_name = getattr(Ens, "model_name", ens_id) + + logging.info(f"[P7] Building ensemble: {ens_name} using {len(base_ests)} base models") + model = Ens(base_estimators=base_ests, random_state=self.random_state) + + if ens_id in ("hard_voting", "soft_voting"): + # ------- Voting ensembles ------- + if self.calibrate: + model_cv = CalibratedClassifierCV( + base_estimator=model, method=self.calibrate_method, cv=self.calibrate_cv + ) + model_cv.fit(X_train, y_train) # calibration fits wrapper + model = model_cv # use calibrated version + else: + model.fit(X_train, y_train) + # (metrics/curves saving stays as before) + else: + # ------- Manual stacking ------- + logging.info(f"[P7] Building ensemble (stacking): {ens_name} [meta on {self.meta_train_source}]") + meta = model._default_meta() + + # choose meta training split + if self.meta_train_source == "train": + # Xm_train = _stack_meta_features(base_ests, X_train, prefer_proba=True) + Xm_train = X_train + ym_train = y_train + else: # "test" + logging.warning("[P7] meta_train_source='test' will leak; using test for meta training by request.") + # Xm_train = _stack_meta_features(base_ests, X_test, prefer_proba=True) + Xm_train = X_test + ym_train = y_test + + # optional calibration ON THE META space (no CV of bases) + if self.calibrate: + model_cv = CalibratedClassifierCV( + base_estimator=meta, method=self.calibrate_method, cv=self.calibrate_cv + ) + model_cv.fit(Xm_train, ym_train) # calibration fits wrapper + model = model_cv # use calibrated version + else: + model.fit(Xm_train, ym_train) + + + # Persist ensemble for this CV + with open(self.out_root / "pickled_ensembles" / f"{ens_small}_{cv}.pickle", "wb") as f: + pickle.dump(model, f) + + # Predictions + y_pred = model.predict(X_test) + + try: + y_pred_proba = model.predict_proba(X_test) + except Exception as e: + # logging.warning("predict_proba failed; setting y_pred_proba=None.") + # logging.warning(str(e)) + y_pred_proba = None + + # Metrics (discrete) + metrics = _calc_basic_metrics(y_test, y_pred) + + # Curves & probabilistic metrics + roc_curve_dict = None + prc_curve_dict = None + roc_auc_val = None + prc_auc_val = None + aps_val = None + brier_val = None + + if ens_id == "hard_voting": + roc_curve_dict, prc_curve_dict, roc_auc_val, prc_auc_val, aps_val = \ + _hard_voting_threshold_sweep(base_ests, X_test, y_test) + + # --- Brier score for hard voting --- + # Use mean predicted probability across base models as the ensemble probability. + # Binary: use P(class=1). Multiclass: use full P over classes. + try: + y_true = np.asarray(y_test) + classes = np.unique(y_true) + n_classes = classes.size + + base_probas_list = [] + for _, est in base_ests: + proba = None + if hasattr(est, "predict_proba"): + proba = est.predict_proba(X_test) + elif hasattr(est, "decision_function"): + s = np.asarray(est.decision_function(X_test)) + if s.ndim == 1: + s = (s - s.min()) / (s.max() - s.min() + 1e-12) + proba = np.column_stack([1 - s, s]) + else: + s_min = s.min(axis=0, keepdims=True) + s_max = s.max(axis=0, keepdims=True) + proba = (s - s_min) / (s_max - s_min + 1e-12) + + if proba is None: + continue + + proba = np.asarray(proba) + + # Align estimator proba columns to global `classes` if possible + est_classes = getattr(est, "classes_", None) + if est_classes is not None: + est_classes = np.asarray(est_classes) + idx = [] + ok = True + for c in classes: + m = np.where(est_classes == c)[0] + if m.size == 0: + ok = False + break + idx.append(int(m[0])) + if not ok: + continue + proba = proba[:, idx] + else: + # If no classes_, require same column count + if proba.ndim != 2 or proba.shape[1] != n_classes: + continue + + base_probas_list.append(proba) + + if base_probas_list: + mean_proba = np.mean(np.stack(base_probas_list, axis=2), axis=2) # (n, n_classes) + + if n_classes == 2: + # Brier score (binary) on positive class probability + brier_val = brier_score_loss(y_true, mean_proba[:, 1]) + else: + # Multiclass brier (use your Phase-6 helper) + brier_val = multiclass_brier_score(y_true, mean_proba) + except Exception as e: + logging.warning("Failed to compute Brier Score for hard voting; setting to None.") + logging.warning(str(e)) + brier_val = None + + # For reporting parity, also compute "naive" AUC using y_pred + try: + metrics["ROC AUC (hard from preds)"] = roc_auc_score(y_test, y_pred_proba, multi_class='ovr') + except Exception as e: + logging.warning("Failed to compute ROC AUC from hard predictions; setting to None.") + logging.warning(str(e)) + metrics["ROC AUC (hard from preds)"] = None + + else: + # ------- Soft-voting & stacking: expose proba / scores ------- + proba = None + if hasattr(model, "predict_proba"): + # For multiclass, this is (n_samples, n_classes) + try: + proba = model.predict_proba(X_test) + except Exception as e: + logging.warning("predict_proba failed; setting proba=None.") + logging.warning(str(e)) + proba = None + elif hasattr(model, "decision_function"): + try: + s = model.decision_function(X_test) + s = np.asarray(s) + # Min-max scale per column to [0,1] + if s.ndim == 1: + proba = (s - s.min()) / (s.max() - s.min() + 1e-12) + else: + s_min = s.min(axis=0, keepdims=True) + s_max = s.max(axis=0, keepdims=True) + proba = (s - s_min) / (s_max - s_min + 1e-12) + except Exception as e: + logging.warning("decision_function failed; setting proba=None.") + logging.warning(str(e)) + proba = None + + if proba is not None: + classes = getattr(model, "classes_", None) + roc_curve_dict, prc_curve_dict, roc_auc_val, prc_auc_val, aps_val = \ + _calc_curves_scores_from_proba(y_test, proba, classes=classes) + + # --- Brier score for soft/stacking --- + try: + y_true = np.asarray(y_test) + proba_arr = np.asarray(proba) + n_classes = np.unique(y_true).size + + if proba_arr.ndim == 1 and n_classes == 2: + # decision_function scaled to [0,1] as "pos prob" + brier_val = brier_score_loss(y_true, proba_arr) + elif proba_arr.ndim == 2 and n_classes == 2 and proba_arr.shape[1] >= 2: + brier_val = brier_score_loss(y_true, proba_arr[:, 1]) + elif proba_arr.ndim == 2 and n_classes > 2: + brier_val = multiclass_brier_score(y_true, proba_arr) + else: + brier_val = None + except Exception as e: + logging.warning("Failed to compute Brier Score; setting to None.") + logging.warning(str(e)) + brier_val = None + + # --- write metrics fields --- + if brier_val is not None: + metrics["Brier Score"] = float(brier_val) + + if roc_auc_val is not None: + metrics["ROC AUC"] = float(roc_auc_val) + if prc_auc_val is not None: + metrics["PRC AUC"] = float(prc_auc_val) + if aps_val is not None: + metrics["PRC APS"] = float(aps_val) + # Save metrics (per CV per ensemble) + mpath = self.out_root / "metrics_by_cv" / f"{ens_small}_CV_{cv}.json" + with open(mpath, "w") as f: + json.dump(metrics, f, indent=2) + + # Save curves (if available) + if roc_curve_dict: + with open(self.out_root / "curves_by_cv" / f"{ens_small}_CV_{cv}_roc.json", "w") as f: + json.dump(roc_curve_dict, f) + if prc_curve_dict: + with open(self.out_root / "curves_by_cv" / f"{ens_small}_CV_{cv}_prc.json", "w") as f: + json.dump(prc_curve_dict, f) + + logging.info(f"[P7] Saved ensemble metrics/curves for {ens_small} CV={cv}") + + + +def _ensure_dir(p: Path): + p.mkdir(parents=True, exist_ok=True) + +def _load_cv_df(dataset_dir: Path, dataset_name: str, cv_idx: int): + train = pd.read_csv(dataset_dir / "CVDatasets" / f"{dataset_name}_CV_{cv_idx}_Train.csv", na_values="NA") + test = pd.read_csv(dataset_dir / "CVDatasets" / f"{dataset_name}_CV_{cv_idx}_Test.csv", na_values="NA") + return train, test + +def _drop_instance(df: pd.DataFrame, instance_label: Optional[str]): + if instance_label and instance_label in df.columns: + return df.drop(columns=[instance_label]) + return df + +def _normalize_outcome_type(value: Optional[str]) -> Optional[str]: + if value is None or str(value).strip() == "": + return None + text = str(value).strip().lower() + if text in {"binary", "bin", "classification_binary"}: + return "Binary" + if text in {"multiclass", "multi", "classification_multiclass"}: + return "Multiclass" + if text in {"continuous", "regression", "numeric"}: + return "Continuous" + return str(value) + +def _prep_xy(df: pd.DataFrame, outcome_label: str): + X = df.drop(columns=[outcome_label]).copy() + y = df[outcome_label].values + return X, y + +def _load_base_estimators(dataset_dir: Path, cv_idx: int, allow_list: Optional[List[str]]) -> List[Tuple[str, Any]]: + pm = dataset_dir / "models" / "pickledModels" + if not pm.exists(): + return [] + out: List[Tuple[str, Any]] = [] + for fn in os.listdir(pm): + if not fn.endswith(".pickle"): + continue + m = re.match(r"(.+?)_([0-9]+)\.pickle$", fn) + if not m: + continue + small, fold = m.group(1), int(m.group(2)) + if fold != cv_idx: + continue + if allow_list and small not in allow_list: + continue + with open(pm / fn, "rb") as f: + try: + est = pickle.load(f) + except Exception as e: + logging.warning(f"Skipping model {fn}: {e}") + continue + out.append((small, est)) + return sorted(out, key=lambda t: t[0]) + +# def _calc_basic_metrics(y_true, y_pred) -> Dict[str, float]: +# """ +# For binary classification: +# - return Accuracy, Balanced Accuracy, F1, Precision, Recall +# - plus confusion-matrix-derived TP, TN, FP, FN, NPV, LR+, LR- +# For multiclass: +# - return Accuracy, Balanced Accuracy +# - macro-averaged F1, Precision, Recall +# - omit TP/TN/FP/FN/NPV/LR+/- (not uniquely defined for multiclass) +# """ +# y_true = np.asarray(y_true) +# y_pred = np.asarray(y_pred) + +# labels = np.unique(np.concatenate([np.unique(y_true), np.unique(y_pred)])) +# cm = confusion_matrix(y_true, y_pred, labels=labels) + +# # Binary case: keep your original behavior +# if labels.size == 2: +# tn, fp, fn, tp = cm.ravel() +# npv = tn / (tn + fn) if (tn + fn) > 0 else 0.0 +# lr_plus = tp / (tp + fp) if (tp + fp) > 0 else 0.0 +# lr_minus = fn / (tn + fn) if (tn + fn) > 0 else 0.0 +# return { +# "Balanced Accuracy": balanced_accuracy_score(y_true, y_pred), +# "Accuracy": accuracy_score(y_true, y_pred), +# "F1": f1_score(y_true, y_pred), +# "Precision": precision_score(y_true, y_pred), +# "Recall": recall_score(y_true, y_pred), +# "TP": float(tp), "TN": float(tn), "FP": float(fp), "FN": float(fn), +# "NPV": npv, "LR+": lr_plus, "LR-": lr_minus, +# } + +# # Multiclass case: use macro-averaged metrics +# return { +# "Balanced Accuracy": balanced_accuracy_score(y_true, y_pred), +# "Accuracy": accuracy_score(y_true, y_pred), +# "F1": f1_score(y_true, y_pred, average="macro"), +# "Precision": precision_score(y_true, y_pred, average="macro"), +# "Recall": recall_score(y_true, y_pred, average="macro"), +# } + +def _calc_basic_metrics(y_true, y_pred) -> Dict[str, Any]: + """ + Phase-7 basic metrics with Phase-7 (legacy) naming. + + Multiclass results keys: + 'Balanced Accuracy', 'Accuracy', 'F1 Score', 'Sensitivity (Recall)', + 'Precision (PPV)' + + Binary results keys (adds): + 'Specificity', 'TP','TN','FP','FN','NPV','LR+','LR-' + + Notes: + - Computes discrete metrics from y_true/y_pred. + - Brier/AUC/PRC metrics require probability-like scores; set to None here + (fill later if you have proba). If you pass proba elsewhere, compute there. + - Any computation error returns None for that field. + """ + y_true = np.asarray(y_true) + y_pred = np.asarray(y_pred) + + def _safe(fn, *args, **kwargs): + try: + v = fn(*args, **kwargs) + except Exception: + return None + if v is None: + return None + try: + v = float(v) + if not np.isfinite(v): + return None + return v + except Exception: + return None + + # Base (shared) discrete stats + s_bac = _safe(balanced_accuracy_score, y_true, y_pred) + s_ac = _safe(accuracy_score, y_true, y_pred) + # F1/Recall/Precision: binary uses default, multiclass uses macro + labels = np.unique(np.concatenate([np.unique(y_true), np.unique(y_pred)])) + is_binary = labels.size == 2 + + if is_binary: + s_f1 = _safe(f1_score, y_true, y_pred) + s_re = _safe(recall_score, y_true, y_pred) # sensitivity + s_pr = _safe(precision_score, y_true, y_pred) # PPV + else: + s_f1 = _safe(f1_score, y_true, y_pred, average="macro") + s_re = _safe(recall_score, y_true, y_pred, average="macro") + s_pr = _safe(precision_score, y_true, y_pred, average="macro") + + # Probabilistic metrics placeholders here (compute later from proba if available) + s_bs = None + + # ----------------------- + # Multiclass + # ----------------------- + if not is_binary: + return { + "Balanced Accuracy": s_bac, + "Accuracy": s_ac, + "F1 Score": s_f1, + "Sensitivity (Recall)": s_re, + "Precision (PPV)": s_pr, + "Brier Score": s_bs, + } + + # ----------------------- + # Binary + # ----------------------- + # Use confusion matrix in the same way your earlier code does (ravel) + try: + cm = confusion_matrix(y_true, y_pred, labels=labels) + except Exception: + cm = None + if cm is None: + # Can happen if something pathological; return best-effort with None extras + return { + "Balanced Accuracy": s_bac, + "Accuracy": s_ac, + "F1 Score": s_f1, + "Sensitivity (Recall)": s_re, + "Specificity": None, + "Precision (PPV)": s_pr, + "Brier Score": s_bs, + "TP": None, + "TN": None, + "FP": None, + "FN": None, + "NPV": None, + "LR+": None, + "LR-": None, + } + + try: + tn, fp, fn, tp = cm.ravel() + tn = float(tn); fp = float(fp); fn = float(fn); tp = float(tp) + except Exception: + tn = fp = fn = tp = None + + # Specificity and NPV + if tn is not None and fp is not None and (tn + fp) > 0: + s_sp = float(tn / (tn + fp)) + else: + s_sp = None + + if tn is not None and fn is not None and (tn + fn) > 0: + s_npv = float(tn / (tn + fn)) + else: + s_npv = None + + # LR+/LR- using your Phase-6-style definitions (from your BinaryClassificationModel) + # LR+ = (TPR) / (FPR) + if tp is not None and fn is not None and fp is not None and tn is not None: + if (tp + fn) > 0 and (fp + tn) > 0 and fp > 0: + tpr = tp / (tp + fn) + fpr = fp / (fp + tn) + s_lrp = float(tpr / fpr) if fpr > 0 else None + else: + s_lrp = 0.0 + # LR- = (FNR) / (TNR) + if (tp + fn) > 0 and (fp + tn) > 0 and tn > 0: + fnr = fn / (tp + fn) + tnr = tn / (fp + tn) + s_lrm = float(fnr / tnr) if tnr > 0 else None + else: + s_lrm = 0.0 + else: + s_lrp = None + s_lrm = None + + return { + "Balanced Accuracy": s_bac, + "Accuracy": s_ac, + "F1 Score": s_f1, + "Sensitivity (Recall)": s_re, + "Specificity": s_sp, + "Precision (PPV)": s_pr, + "Brier Score": s_bs, + "TP": tp, + "TN": tn, + "FP": fp, + "FN": fn, + "NPV": s_npv, + "LR+": s_lrp, + "LR-": s_lrm, + } + +def _calc_curves_scores_from_proba(y_true, y_proba, classes=None): + """ + Binary: + - y_proba: 1D or 2D (n_samples, 1 or 2); returns single ROC/PRC and AUC/AP. + Multiclass: + - y_proba: 2D (n_samples, n_classes) + - classes: sequence of class labels aligned with columns of y_proba + - returns per-class ROC/PRC curves in dictionaries, plus macro-averaged AUC/AP. + """ + y_true = np.asarray(y_true) + y_proba = np.asarray(y_proba) + + n_unique = np.unique(y_true).size + + # ------- Binary case ------- + if y_proba.ndim == 1 or (y_proba.ndim == 2 and y_proba.shape[1] in (1, 2) and n_unique == 2): + if y_proba.ndim == 2: + # If 2 cols, use column 1 as "positive" class score + if y_proba.shape[1] == 2: + y_score = y_proba[:, 1] + else: + y_score = y_proba[:, 0] + else: + y_score = y_proba + + fpr, tpr, _ = roc_curve(y_true, y_score) + roc = auc(fpr, tpr) + prec, rec, _ = precision_recall_curve(y_true, y_score) + sidx = np.argsort(rec) + prc_auc = auc(rec[sidx], prec[sidx]) + aps = average_precision_score(y_true, y_score) + return ( + {"fpr": fpr.tolist(), "tpr": tpr.tolist()}, + {"precision": prec.tolist(), "recall": rec.tolist()}, + float(roc), + float(prc_auc), + float(aps), + ) + + # ------- Multiclass case: one-vs-rest curves ------- + if classes is None: + classes = np.unique(y_true) + classes = np.array(classes) + n_classes = classes.size + + if y_proba.ndim != 2: + raise ValueError("Multiclass probabilities must be 2D (n_samples, n_classes).") + + if y_proba.shape[1] != n_classes: + logging.warning( + "y_proba has %d columns but there are %d classes; " + "using min(n_cols, n_classes) for alignment.", + y_proba.shape[1], + n_classes, + ) + n = min(y_proba.shape[1], n_classes) + y_proba = y_proba[:, :n] + classes = classes[:n] + n_classes = n + + roc_curve_dict: Dict[str, Dict[str, List[float]]] = {} + prc_curve_dict: Dict[str, Dict[str, List[float]]] = {} + roc_aucs: List[float] = [] + prc_aucs: List[float] = [] + aps_list: List[float] = [] + + for idx, cls in enumerate(classes): + y_bin = (y_true == cls).astype(int) + y_score = y_proba[:, idx] + + # ROC + fpr, tpr, _ = roc_curve(y_bin, y_score) + roc_val = auc(fpr, tpr) + # PRC + prec, rec, _ = precision_recall_curve(y_bin, y_score) + sidx = np.argsort(rec) + prc_auc_val = auc(rec[sidx], prec[sidx]) + aps_val = average_precision_score(y_bin, y_score) + + key = str(cls) + roc_curve_dict[key] = {"fpr": fpr.tolist(), "tpr": tpr.tolist()} + prc_curve_dict[key] = {"precision": prec.tolist(), "recall": rec.tolist()} + + roc_aucs.append(float(roc_val)) + prc_aucs.append(float(prc_auc_val)) + aps_list.append(float(aps_val)) + + roc_macro = float(np.mean(roc_aucs)) if roc_aucs else None + prc_macro = float(np.mean(prc_aucs)) if prc_aucs else None + aps_macro = float(np.mean(aps_list)) if aps_list else None + + return roc_curve_dict, prc_curve_dict, roc_macro, prc_macro, aps_macro + +def _hard_voting_threshold_sweep(base_estimators, X_test, y_test, thresholds=None): + """ + Build ROC/PRC for hard-vote by thresholding each base model's probabilities then majority vote. + + - Binary: + returns single ROC and PRC curves (same as original behavior). + + - Multiclass: + performs one-vs-rest in a micro-averaged fashion: + * for each class c, and each sample i, treat (i, c) as a binary problem: + y_true_bin[i, c] = 1 if y_test[i] == c else 0 + y_pred_bin[i, c] = 1 if ensemble votes for c at given threshold else 0 + * aggregate TP/FP/FN/TN across all classes at each threshold + * compute one global TPR/FPR/precision/recall per threshold + returns a single ROC/PR curve, just like in the binary case. + """ + y_test = np.asarray(y_test) + classes = np.unique(y_test) + n_classes = classes.size + + if thresholds is None: + thresholds = np.linspace(0.0, 1.0, 101) + + # Collect per-base probabilities aligned to `classes` + base_probas_list = [] + for _, est in base_estimators: + proba = None + + if hasattr(est, "predict_proba"): + proba = est.predict_proba(X_test) + elif hasattr(est, "decision_function"): + s = est.decision_function(X_test) + s = np.asarray(s) + if s.ndim == 1: + # Binary decision_function -> map to 2-col "probabilities" + s = (s - s.min()) / (s.max() - s.min() + 1e-12) + proba = np.column_stack([1 - s, s]) + else: + # Multiclass decision_function -> min-max per column + s_min = s.min(axis=0, keepdims=True) + s_max = s.max(axis=0, keepdims=True) + proba = (s - s_min) / (s_max - s_min + 1e-12) + + if proba is None: + continue + + # Align columns of proba to global `classes` + est_classes = getattr(est, "classes_", None) + if est_classes is not None: + est_classes = np.asarray(est_classes) + idx = [] + ok = True + for c in classes: + matches = np.where(est_classes == c)[0] + if matches.size == 0: + ok = False + break + idx.append(matches[0]) + if not ok: + logging.warning( + "Skipping estimator in _hard_voting_threshold_sweep due to class mismatch." + ) + continue + proba = proba[:, idx] + else: + # Fallback: require same number of classes and same order + if proba.shape[1] != n_classes: + logging.warning( + "Estimator proba columns (%d) != n_classes (%d) and no classes_; skipping.", + proba.shape[1], n_classes + ) + continue + + base_probas_list.append(proba) + + if not base_probas_list: + logging.warning( + "No probability-capable base estimators for hard voting threshold sweep." + ) + return None, None, None, None, None + + # base_probas: (n_samples, n_bases, n_classes) + base_probas = np.stack(base_probas_list, axis=1) + n_samples = base_probas.shape[0] + n_bases = base_probas.shape[1] + + # ------------------------------------------------------------------------- + # Binary case: keep original behavior + # ------------------------------------------------------------------------- + if n_classes == 2: + pos_cls = classes[1] + base_pos = base_probas[..., 1] # (n_samples, n_bases) + + tpr_list, fpr_list, prec_list, rec_list = [], [], [], [] + y_true_bin = (y_test == pos_cls).astype(int) + + for th in thresholds: + votes = (base_pos >= th).astype(int) # (n_samples, n_bases) + y_pred_bin = (votes.mean(axis=1) >= 0.5).astype(int) + + cm = confusion_matrix(y_true_bin, y_pred_bin, labels=[0, 1]) + tn, fp, fn, tp = cm.ravel() + tpr = tp / (tp + fn + 1e-12) + fpr = fp / (tn + fp + 1e-12) + prec = tp / (tp + fp + 1e-12) + rec = tpr + + tpr_list.append(tpr) + fpr_list.append(fpr) + prec_list.append(prec) + rec_list.append(rec) + + fpr_arr = np.array(fpr_list) + tpr_arr = np.array(tpr_list) + prec_arr = np.array(prec_list) + rec_arr = np.array(rec_list) + + # ROC AUC + sidx = np.argsort(fpr_arr) + roc = auc(fpr_arr[sidx], tpr_arr[sidx]) + # PRC AUC + sidx2 = np.argsort(rec_arr) + prc_auc = auc(rec_arr[sidx2], prec_arr[sidx2]) + # APS-like + aps = float(np.mean(prec_arr)) + + roc_curve_dict = {"fpr": fpr_arr[sidx].tolist(), "tpr": tpr_arr[sidx].tolist()} + prc_curve_dict = { + "precision": prec_arr[sidx2].tolist(), + "recall": rec_arr[sidx2].tolist(), + } + return roc_curve_dict, prc_curve_dict, float(roc), float(prc_auc), aps + + # ------------------------------------------------------------------------- + # Multiclass case: micro-averaged one-vs-rest + # ------------------------------------------------------------------------- + tpr_list, fpr_list, prec_list, rec_list = [], [], [], [] + + # Precompute one-vs-rest true labels for all (sample, class) + # y_true_bin: (n_samples, n_classes) in {0,1} + y_true_bin = (y_test[:, None] == classes[None, :]).astype(int) + + for th in thresholds: + # votes: (n_samples, n_bases, n_classes) -> 0/1 per base, class, sample + votes = (base_probas >= th).astype(int) + # majority vote per class (one-vs-rest): (n_samples, n_classes) + y_pred_bin = (votes.mean(axis=1) >= 0.5).astype(int) + + # Flatten across classes to do micro-averaging + y_true_flat = y_true_bin.ravel() + y_pred_flat = y_pred_bin.ravel() + + cm = confusion_matrix(y_true_flat, y_pred_flat, labels=[0, 1]) + tn, fp, fn, tp = cm.ravel() + + tpr = tp / (tp + fn + 1e-12) if (tp + fn) > 0 else 0.0 # micro TPR (a.k.a. recall) + fpr = fp / (tn + fp + 1e-12) if (tn + fp) > 0 else 0.0 + prec = tp / (tp + fp + 1e-12) if (tp + fp) > 0 else 0.0 + rec = tpr + + tpr_list.append(tpr) + fpr_list.append(fpr) + prec_list.append(prec) + rec_list.append(rec) + + fpr_arr = np.array(fpr_list) + tpr_arr = np.array(tpr_list) + prec_arr = np.array(prec_list) + rec_arr = np.array(rec_list) + + # ROC AUC (micro) + sidx = np.argsort(fpr_arr) + roc = auc(fpr_arr[sidx], tpr_arr[sidx]) + # PRC AUC (micro over thresholds) + sidx2 = np.argsort(rec_arr) + prc_auc = auc(rec_arr[sidx2], prec_arr[sidx2]) + aps = float(np.mean(prec_arr)) + + roc_curve_dict = {"fpr": fpr_arr[sidx].tolist(), "tpr": tpr_arr[sidx].tolist()} + prc_curve_dict = { + "precision": prec_arr[sidx2].tolist(), + "recall": rec_arr[sidx2].tolist(), + } + return roc_curve_dict, prc_curve_dict, float(roc), float(prc_auc), aps + +# Class to use if we remove stacking class from mlextend + +def _stack_meta_features(base_estimators, X, prefer_proba=True): + """ + Build meta features from frozen base estimators without refitting them: + - if predict_proba: use positive-class probs + - elif decision_function: min-max to [0,1] + - else: use predicted labels (0/1) + Returns: (n_samples, n_bases) numpy array + """ + cols = [] + for _, est in base_estimators: + if prefer_proba and hasattr(est, "predict_proba"): + cols.append(est.predict_proba(X)[:, 1]) + elif hasattr(est, "decision_function"): + s = est.decision_function(X) + s = (s - s.min()) / (s.max() - s.min() + 1e-12) + cols.append(s) + else: + cols.append(est.predict(X).astype(float)) + return np.column_stack(cols) if cols else np.empty((X.shape[0], 0)) diff --git a/streamline/p7_ensembles/p7_cli.py b/streamline/p7_ensembles/p7_cli.py new file mode 100644 index 00000000..cc96ace9 --- /dev/null +++ b/streamline/p7_ensembles/p7_cli.py @@ -0,0 +1,101 @@ +import argparse +from streamline.p7_ensembles.p7_runner import P7Runner +from streamline.p7_ensembles.utils.loader import list_ensembles +from streamline.utils.run_commands import ( + add_run_command_args, + apply_saved_run_command, + require_args, + save_run_command_from_args, + snapshot_args, +) + +def _print_ens(): + print("\nAvailable ensembles:") + for e in list_ensembles(): + print(f" {e['id']:<10} - {e['name']} [{e['module']}]") + print("") + +def main(): + ap = argparse.ArgumentParser("STREAMLINE Phase 7 (Ensembles)", formatter_class=argparse.ArgumentDefaultsHelpFormatter) + ap.add_argument("--output_path", required=True) + ap.add_argument("--experiment_name", required=True) + ap.add_argument("--n_splits", type=int, default=None) + ap.add_argument("--outcome_label", default="Class") + ap.add_argument("--outcome_type", default=None, help="Binary | Multiclass | Continuous; defaults to metadata, Continuous is rejected") + ap.add_argument("--instance_label", default=None) + ap.add_argument("--ensembles", default="hard_voting,soft_voting,stack_lr") + ap.add_argument("--base_models", default=None) + ap.add_argument("--meta_train_source", choices=["train","test"], default="train", + help="Where to train stacking meta-classifier from base outputs (no CV, no base refit)") + ap.add_argument("--calibrate", type=int, default=0) + ap.add_argument("--calibrate_method", default="sigmoid") + ap.add_argument("--calibrate_cv", type=int, default=5) + ap.add_argument("--run_cluster", default="Serial", + help="Serial | Local | Parallel | BashSLURM | BashLSF | ") + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", type=int, default=4) + ap.add_argument("--random_state", default=0) + ap.add_argument("--list_ensembles", action="store_true") + add_run_command_args(ap) + args = ap.parse_args() + args = apply_saved_run_command(ap, args, "p7_ensembles") + run_command_args = snapshot_args(args) + + if args.list_ensembles: + _print_ens() + return + + require_args(ap, args, ["n_splits"]) + + runner = P7Runner( + output_path=args.output_path, + experiment_name=args.experiment_name, + n_splits=args.n_splits, + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + instance_label=args.instance_label, + ensembles=args.ensembles, + base_models=args.base_models, + meta_train_source=args.meta_train_source, + # scoring_metric=args.scoring_metric, + # metric_direction=args.metric_direction, + # stack_tune=bool(args.stack_tune), + # stack_trials=args.stack_trials, + # stack_timeout=args.stack_timeout, + calibrate=args.calibrate, + calibrate_method=args.calibrate_method, + calibrate_cv=args.calibrate_cv, + run_cluster=args.run_cluster, + queue=args.queue, + reserved_memory=args.reserved_memory, + random_state=(int(args.random_state) if str(args.random_state).lower() not in {"", "none"} else None), + ) + runner.run() + save_run_command_from_args(args, "p7_ensembles", run_command_args, runner=runner) + +if __name__ == "__main__": + + ## List available ensembles + + # python -m streamline.p7_ensembles.p7_cli \ + # --output_path test --experiment_name DemoBinary --n_splits 5 --list_ensembles + + + ## Plain (no tuning), include calibration + + # python -m streamline.p7_ensembles.p7_cli \ + # --output_path test --experiment_name DemoBinary --n_splits 5 \ + # --ensembles hard_voting,soft_voting,stack_lr \ + # --base_models LR,SVM,NB \ + # --calibrate 1 --calibrate_method sigmoid --calibrate_cv 5 + + + ## Tune stacking meta-LR (30 trials / 10 min) + + # python -m streamline.p7_ensembles.p7_cli \ + # --output_path test --experiment_name DemoBinary --n_splits 5 \ + # --ensembles stack_lr \ + # --base_models LR,SVM,NB \ + # --stack_tune 1 --stack_trials 30 --stack_timeout 600 + + main() diff --git a/streamline/p7_ensembles/p7_jobsubmit.py b/streamline/p7_ensembles/p7_jobsubmit.py new file mode 100644 index 00000000..84e43f17 --- /dev/null +++ b/streamline/p7_ensembles/p7_jobsubmit.py @@ -0,0 +1,75 @@ +import argparse +from streamline.p7_ensembles.ensembles import EnsemblePhaseJob +from streamline.p7_ensembles.p7_runner import P7Runner +from streamline.p7_ensembles.utils.loader import list_ensembles + +def _print_ensembles(): + print("\nAvailable ensembles:") + for e in list_ensembles(): + print(f" {e['id']:<10} - {e['name']} [{e['module']}]") + print("") + +def main(): + ap = argparse.ArgumentParser("STREAMLINE Phase 7 (Ensembles)", formatter_class=argparse.ArgumentDefaultsHelpFormatter) + ap.add_argument("--dataset_dir", default=None) + ap.add_argument("--output_path", required=True) + ap.add_argument("--experiment_name", required=True) + ap.add_argument("--n_splits", type=int, required=True) + ap.add_argument("--outcome_label", default="Class") + ap.add_argument("--outcome_type", default=None, help="Binary | Multiclass | Continuous; defaults to metadata") + ap.add_argument("--instance_label", default=None) + ap.add_argument("--ensembles", default="hard_voting,soft_voting,stack_lr") + ap.add_argument("--base_models", default=None, help="Comma list of base model small_names filter (e.g., LR,SVM,NB)") + ap.add_argument("--meta_train_source", choices=["train","test"], default="train") + ap.add_argument("--calibrate", type=int, default=0) + ap.add_argument("--calibrate_method", default="sigmoid") + ap.add_argument("--calibrate_cv", type=int, default=5) + ap.add_argument("--run_cluster", default="Serial", help="Serial | Local | Parallel | BashSLURM | BashLSF | ") + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", type=int, default=4) + ap.add_argument("--random_state", type=int, default=0) + ap.add_argument("--list_ensembles", action="store_true") + args = ap.parse_args() + + if args.list_ensembles: + _print_ensembles() + return + + if args.dataset_dir: + EnsemblePhaseJob( + dataset_dir=args.dataset_dir, + n_splits=args.n_splits, + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + instance_label=args.instance_label, + ensembles=args.ensembles, + base_models=args.base_models, + meta_train_source=args.meta_train_source, + calibrate=args.calibrate, + calibrate_method=args.calibrate_method, + calibrate_cv=args.calibrate_cv, + random_state=args.random_state, + ).run() + return + + P7Runner( + output_path=args.output_path, + experiment_name=args.experiment_name, + n_splits=args.n_splits, + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + instance_label=args.instance_label, + ensembles=args.ensembles, + base_models=args.base_models, + meta_train_source=args.meta_train_source, + calibrate=args.calibrate, + calibrate_method=args.calibrate_method, + calibrate_cv=args.calibrate_cv, + run_cluster=args.run_cluster, + queue=args.queue, + reserved_memory=args.reserved_memory, + random_state=args.random_state, + ).run() + +if __name__ == "__main__": + main() diff --git a/streamline/p7_ensembles/p7_runner.py b/streamline/p7_ensembles/p7_runner.py new file mode 100644 index 00000000..f7897dca --- /dev/null +++ b/streamline/p7_ensembles/p7_runner.py @@ -0,0 +1,101 @@ +from __future__ import annotations +import os, time, logging, pickle +from pathlib import Path +import dask +from dask.distributed import Client, LocalCluster +from streamline.utils.cluster import get_cluster +from streamline.utils.runners import num_cores, run_dask_tasks, run_parallel_items +from streamline.p7_ensembles.ensembles import EnsemblePhaseJob + +class P7Runner: + def __init__( + self, output_path, experiment_name, n_splits, + outcome_label="Class", outcome_type=None, instance_label=None, + ensembles="hard_voting,soft_voting,stack_lr", base_models=None, + meta_train_source="train", + calibrate=0, calibrate_method="sigmoid", calibrate_cv=5, + run_cluster="Serial", queue="defq", reserved_memory=4, + random_state=0, + ): + self.exp_root = Path(output_path) / experiment_name + if not self.exp_root.is_dir(): + raise Exception("Experiment folder not found.") + self.output_path = output_path + self.experiment_name = experiment_name + metadata = self._load_metadata() + resolved_outcome_type = outcome_type if outcome_type is not None else metadata.get("Outcome Type") + self.kw = dict( + n_splits=int(n_splits), + outcome_label=outcome_label, + outcome_type=resolved_outcome_type, + instance_label=instance_label, + ensembles=ensembles, base_models=base_models, + meta_train_source=meta_train_source, + calibrate=bool(calibrate), calibrate_method=calibrate_method, calibrate_cv=int(calibrate_cv), + random_state=random_state, + ) + self.run_cluster = run_cluster or "Serial" + self.queue = queue; self.reserved_memory = int(reserved_memory) + + def run(self): + datasets = [p for p in sorted(self.exp_root.iterdir()) + if p.is_dir() and (p / "CVDatasets").is_dir() + and p.name not in {"jobs","logs","jobsCompleted","dask_logs","DatasetComparisons"}] + if self.run_cluster == "Serial": + for ds in datasets: self._run_one(ds) + elif self.run_cluster == "Local": + with LocalCluster(processes=True, n_workers=num_cores, threads_per_worker=1) as cluster: + with Client(cluster) as client: + run_dask_tasks([dask.delayed(self._run_one)(ds) for ds in datasets], client, label="Phase 7 Dask jobs") + elif self.run_cluster == "Parallel": + run_parallel_items(self._run_one, datasets, label="Phase 7 Parallel jobs") + elif self.run_cluster in ("BashSLURM","BashLSF"): + for ds in datasets: self._submit_bash(ds) + else: + client: Client = get_cluster(self.run_cluster, str(self.exp_root), self.queue, self.reserved_memory) + run_dask_tasks([dask.delayed(self._run_one)(ds) for ds in datasets], client, label="Phase 7 Dask jobs") + + def _run_one(self, ds): + EnsemblePhaseJob(dataset_dir=str(ds), **self.kw).run() + + def _load_metadata(self): + meta_path = self.exp_root / "metadata.pickle" + if not meta_path.exists(): + return {} + try: + with meta_path.open("rb") as f: + return pickle.load(f) or {} + except Exception: + return {} + + def _submit_bash(self, ds): + job_ref = str(time.time()); jobs = self.exp_root / "jobs"; logs = self.exp_root / "logs" + os.makedirs(jobs, exist_ok=True); os.makedirs(logs, exist_ok=True) + sh = jobs / f"P7_{job_ref}_run.sh" + launcher = "sbatch" if self.run_cluster=="BashSLURM" else "bsub <" + script = Path(__file__).with_name("p7_jobsubmit.py") + args = " ".join([ + "python", str(script), + "--dataset_dir", str(ds), + "--n_splits", str(self.kw["n_splits"]), + "--outcome_label", self.kw["outcome_label"], + "--outcome_type", self.kw["outcome_type"] or "", + "--instance_label", self.kw["instance_label"] or "", + "--ensembles", self.kw["ensembles"] or "", + "--base_models", self.kw["base_models"] or "", + "--meta_train_source", self.kw.get("meta_train_source","train"), + "--calibrate", str(int(self.kw["calibrate"])), + "--calibrate_method", self.kw["calibrate_method"], + "--calibrate_cv", str(self.kw["calibrate_cv"]), + "--output_path", self.output_path, + "--experiment_name", self.experiment_name, + ]) + with open(sh, "w") as f: + f.write("#!/bin/bash\n") + if self.run_cluster=="BashSLURM": + f.write(f"#SBATCH -p {self.queue}\n#SBATCH --job-name={job_ref}\n#SBATCH --mem={self.reserved_memory}G\n") + f.write(f"#SBATCH -o {logs}/P7_{job_ref}.o\n#SBATCH -e {logs}/P7_{job_ref}.e\nsrun {args}\n") + else: + f.write(f"#BSUB -q {self.queue}\n#BSUB -J {job_ref}\n#BSUB -R \"rusage[mem={self.reserved_memory}G]\"\n") + f.write(f"#BSUB -M {self.reserved_memory}GB\n#BSUB -o {logs}/P7_{job_ref}.o\n#BSUB -e {logs}/P7_{job_ref}.e\n{args}\n") + os.system(f"{launcher} {sh}") diff --git a/streamline/p7_ensembles/registry/__init__.py b/streamline/p7_ensembles/registry/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/streamline/p7_ensembles/registry/stacking.py b/streamline/p7_ensembles/registry/stacking.py new file mode 100644 index 00000000..569bb731 --- /dev/null +++ b/streamline/p7_ensembles/registry/stacking.py @@ -0,0 +1,167 @@ +from __future__ import annotations +from typing import List, Tuple, Optional, Dict, Any +import numpy as np +import optuna + +from sklearn.linear_model import LogisticRegression +from sklearn.tree import DecisionTreeClassifier +from sklearn.ensemble import RandomForestClassifier + +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel +from streamline.p7_ensembles.utils.stacking_model import StackingClassifier + +def _base_list(pairs: List[Tuple[str, object]]): + return [est for _, est in pairs] + +class _StackingBase(BinaryClassificationModel): + """ + Reusable stacking scaffold: + - If tune=False → no-op optimize; fixed meta model + - If tune=True → Optuna objective tunes meta params only, using BaseModel.hyper_eval() + """ + + def __init__(self, + base_estimators: List[Tuple[str, object]], + tune: bool = False, + **kw): + self._base_estimators = base_estimators + self._tune = bool(tune) + super().__init__(model=lambda: self._build(meta_params=None), + model_name=self.model_name, **kw) + # Set param_grid only when tuning; BaseModel uses this to decide single vs sweep + self.param_grid = self._param_grid() if self._tune else {} + + # ---- hooks every subclass must provide --------------------------------- + def _default_meta(self): + raise NotImplementedError + + def _param_grid(self) -> Dict[str, Any]: + """Return Optuna search space description (keys only).""" + return {} + + def _trial_params(self, trial: optuna.trial.Trial) -> Dict[str, Any]: + """Translate _param_grid into concrete trial params.""" + return {} + + def fit(self, x_train, y_train, n_trails=100, timeout=450, feature_names=None): + """Optimize → fit → (optional) calibrate for classifiers.""" + self.optimize(x_train, y_train, n_trails, timeout, feature_names) + self.model.fit(x_train, y_train) + + # ---- Stacking builder --------------------------------------------------- + def _build(self, meta_params: Optional[Dict[str, Any]]): + # build meta clf + if meta_params is None: + meta = self._default_meta() + else: + meta = self._default_meta().__class__(**meta_params) + + return StackingClassifier( + classifiers=_base_list(self._base_estimators), + meta_classifier=meta, + use_probas=False, + use_clones=True, + fit_base_estimators=False, + ) + + # ---- BaseModel integration ---------------------------------------------- + def optimize(self, x_train, y_train, n_trails, timeout, feature_names=None): + """If tune is off → just instantiate once. Else → run normal Optuna path.""" + self.x_train = x_train + self.y_train = y_train + if not self._tune: + # single-fit path + if callable(self.model): + self.model = self.model() + self.params = {} + return + # tuning path → let BaseModel handle study lifecycle via objective() + super().optimize(x_train, y_train, n_trails, timeout, feature_names) + + def objective(self, trial: optuna.trial.Trial, params=None): + # produce trial params for the meta-classifier only + mp = self._trial_params(trial) + # set model to a fresh StackingClassifier(meta=mp) + self.model = self._build(meta_params=mp) + self.params = mp # for logging/export + return self.hyper_eval() + +# ------------------ concrete stackers --------------------------------------- + +class StackLR(_StackingBase): + id = "stack_lr" + model_name = "StackingLogReg" + small_name = "STK_LR" + + def _default_meta(self): + return LogisticRegression(solver="lbfgs", max_iter=1000) + + def _param_grid(self): + # keys only; values/ranges provided in _trial_params + return {"C": (), "penalty": (), "solver": (), "max_iter": (), "class_weight": ()} + + def _trial_params(self, trial): + solver = trial.suggest_categorical("solver", ["lbfgs", "liblinear", "saga", "newton-cg", "sag"]) + params = { + "C": trial.suggest_float("C", 1e-4, 1e3, log=True), + "max_iter": trial.suggest_int("max_iter", 100, 2000, log=True), + "class_weight": trial.suggest_categorical("class_weight", [None, "balanced"]), + "solver": solver, + } + # penalty depends on solver + if solver in ("lbfgs", "newton-cg", "sag"): + params["penalty"] = "l2" + elif solver == "liblinear": + params["penalty"] = trial.suggest_categorical("penalty", ["l1", "l2"]) + else: # saga + params["penalty"] = trial.suggest_categorical("penalty", ["l1", "l2"]) + return params + +class StackDT(_StackingBase): + id = "stack_dt" + model_name = "Stacking DecisionTree" + small_name = "STK_DT" + + def _default_meta(self): + return DecisionTreeClassifier(random_state=self.random_state) + + def _param_grid(self): + return {"criterion": (), "splitter": (), "max_depth": (), "min_samples_split": (), + "min_samples_leaf": (), "max_features": (), "class_weight": ()} + + def _trial_params(self, trial): + return { + "criterion": trial.suggest_categorical("criterion", ["gini", "entropy", "log_loss"]), + "splitter": trial.suggest_categorical("splitter", ["best", "random"]), + "max_depth": trial.suggest_int("max_depth", 1, 50), + "min_samples_split": trial.suggest_int("min_samples_split", 2, 50), + "min_samples_leaf": trial.suggest_int("min_samples_leaf", 1, 50), + "max_features": trial.suggest_categorical("max_features", [None, "sqrt", "log2"]), + "class_weight": trial.suggest_categorical("class_weight", [None, "balanced"]), + } + +class StackRF(_StackingBase): + id = "stack_rf" + model_name = "Stacking RandomForest" + small_name = "STK_RF" + + def _default_meta(self): + return RandomForestClassifier(n_estimators=200, random_state=self.random_state) + + def _param_grid(self): + return {"n_estimators": (), "criterion": (), "max_depth": (), "min_samples_split": (), + "min_samples_leaf": (), "max_features": (), "bootstrap": (), "oob_score": (), + "class_weight": ()} + + def _trial_params(self, trial): + return { + "n_estimators": trial.suggest_int("n_estimators", 50, 1000, log=True), + "criterion": trial.suggest_categorical("criterion", ["gini", "entropy", "log_loss"]), + "max_depth": trial.suggest_int("max_depth", 1, 50), + "min_samples_split": trial.suggest_int("min_samples_split", 2, 50), + "min_samples_leaf": trial.suggest_int("min_samples_leaf", 1, 50), + "max_features": trial.suggest_categorical("max_features", [None, "sqrt", "log2"]), + "bootstrap": trial.suggest_categorical("bootstrap", [True, False]), + "oob_score": trial.suggest_categorical("oob_score", [False, True]), + "class_weight": trial.suggest_categorical("class_weight", [None, "balanced"]), + } diff --git a/streamline/p7_ensembles/registry/voting.py b/streamline/p7_ensembles/registry/voting.py new file mode 100644 index 00000000..bbf2e934 --- /dev/null +++ b/streamline/p7_ensembles/registry/voting.py @@ -0,0 +1,46 @@ +from __future__ import annotations +from typing import List, Tuple +from mlxtend.classifier import EnsembleVoteClassifier +from streamline.p6_modeling.utils.submodels import BinaryClassificationModel + +class HardVoting(BinaryClassificationModel): + id = "hard_voting" + model_name = "Hard Ensemble Voting" + small_name = "HEV" + + def __init__(self, base_estimators: List[Tuple[str, object]], **kw): + # BaseModel expects a callable or None; we’ll pass a lambda that returns the estimator + super().__init__(model=lambda: EnsembleVoteClassifier( + clfs=[m for _, m in base_estimators], + fit_base_estimators=False, voting='hard', use_clones=True + ), model_name=self.model_name, **kw) + self.param_grid = {} # no hyperopt + + def optimize(self, *args, **kwargs): + # No hyper-parameters; ensure self.model is a concrete estimator + if callable(self.model): + self.model = self.model() + + def fit(self, x_train, y_train, n_trails=None, timeout=None, feature_names=None): + self.optimize(x_train, y_train, n_trails, timeout, feature_names) + self.model.fit(x_train, y_train) + +class SoftVoting(BinaryClassificationModel): + id = "soft_voting" + model_name = "Soft Ensemble Voting" + small_name = "SEV" + + def __init__(self, base_estimators: List[Tuple[str, object]], **kw): + super().__init__(model=lambda: EnsembleVoteClassifier( + clfs=[m for _, m in base_estimators], + fit_base_estimators=False, voting='soft', use_clones=True + ), model_name=self.model_name, **kw) + self.param_grid = {} + + def optimize(self, *args, **kwargs): + if callable(self.model): + self.model = self.model() + + def fit(self, x_train, y_train, n_trails=None, timeout=None, feature_names=None): + self.optimize(x_train, y_train, n_trails, timeout, feature_names) + self.model.fit(x_train, y_train) diff --git a/streamline/p7_ensembles/utils/__init__.py b/streamline/p7_ensembles/utils/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/streamline/p7_ensembles/utils/loader.py b/streamline/p7_ensembles/utils/loader.py new file mode 100644 index 00000000..d80c55b8 --- /dev/null +++ b/streamline/p7_ensembles/utils/loader.py @@ -0,0 +1,166 @@ +from __future__ import annotations +import importlib +import inspect +import os +import sys +from pathlib import Path +from typing import List, Dict, Type, Optional + + +# Allow running this file directly for debugging: +if __name__ == "__main__" and __package__ is None: + print("Adjusting sys.path for standalone execution...") + # Heuristic: repo root = 4 levels up from this file + repo_root = Path(__file__).resolve().parent.parent.parent.parent + print(f" Repo root: {repo_root}") + sys.path.insert(0, str(repo_root)) + +PKG_ROOT = "streamline.p7_ensembles.registry" + +def _get_models_root() -> Path: + """ + Get the filesystem path corresponding to PKG_ROOT. + This avoids relying on __file__ of the current module. + """ + pkg = importlib.import_module(PKG_ROOT) + pkg_file = getattr(pkg, "__file__", None) + if not pkg_file: + raise RuntimeError(f"Cannot determine filesystem path for package {PKG_ROOT!r}") + return Path(pkg_file).parent + + +ROOT = _get_models_root() + + +def _iter_modnames() -> List[str]: + """ + Yield fully-qualified module names under the ensemble registry package. + """ + if not ROOT.exists(): + return + for fn in os.listdir(ROOT): + if fn.endswith(".py") and fn not in {"__init__.py", "loader.py"}: + yield f"{PKG_ROOT}.{fn[:-3]}" + + +def _safe_import(name: str): + try: + return importlib.import_module(name) + except Exception: + return None + + +def load_ensemble_classes() -> List[Type]: + """ + Discover ensemble classes under streamline.p7_ensemble.registry. + + A valid ensemble class must: + - Live in a module under PKG_ROOT + - Define attributes: id, name, build_model + (or adjust if you standardize to .build instead) + """ + classes: List[Type] = [] + for modname in _iter_modnames() or []: + mod = _safe_import(modname) + if not mod: + continue + for name in dir(mod): + obj = getattr(mod, name) + if inspect.isclass(obj) and getattr(obj, "__module__", "").startswith(mod.__name__): + required = ("id", "model_name") + if all(hasattr(obj, k) for k in required) and name not in {"_StackingBase"}: + classes.append(obj) + return sorted(classes, key=lambda c: getattr(c, "name", str(c))) + + +def get_ensemble_by_id(ens_id: str) -> Type: + """ + Resolve an ensemble class by its string id (case-insensitive). + """ + target = (ens_id or "").strip().lower() + for cls in load_ensemble_classes(): + cid = getattr(cls, "id", "").strip().lower() + if cid == target: + return cls + raise ValueError(f"Unknown ensemble id: {ens_id!r}") + + +def list_ensembles() -> List[Dict[str, str]]: + """ + List discovered ensembles, returning CLI / debug-friendly entries: + {id, name, module, qualname} + """ + out: List[Dict[str, str]] = [] + for c in load_ensemble_classes(): + out.append({ + "id": getattr(c, "id", ""), + "model_name": getattr(c, "model_name", ""), + "small_name": getattr(c, "small_name", ""), + "module": getattr(c, "__module__", ""), + "qualname": f"{c.__module__}.{c.__name__}", + }) + return out + + +# --------------------------------------------------------------------- +# Self-test / debug runner +# --------------------------------------------------------------------- +if __name__ == "__main__": + """ + Simple self-test for the ensemble registry. + + Examples (from repo root): + python -m streamline.p7_ensemble.utils.loader + or: + python streamline/p7_ensemble/utils/loader.py + """ + import pprint + + print("=== Ensemble registry self-test ===") + print(f"PKG_ROOT = {PKG_ROOT!r}") + print(f"ROOT = {ROOT!r}") + + # 1) Discover ensembles + try: + ensembles = list_ensembles() + except Exception as e: + print("ERROR: failed to list ensembles:", repr(e)) + sys.exit(1) + + print(f"Discovered {len(ensembles)} ensembles in total.") + if not ensembles: + print("No ensembles were discovered. Check that:") + print(f" - The package {PKG_ROOT} exists and is importable") + print(f" - The directory {ROOT} exists and contains *.py modules") + print(" - Each ensemble class defines: id, name, build_model") + sys.exit(0) + + print("\nDiscovered ensembles:") + pprint.pprint(ensembles) + + # 2) Round-trip: ensure get_ensemble_by_id works for each discovered id + print("\nRunning round-trip get_ensemble_by_id checks...") + ok = 0 + for entry in ensembles: + eid = entry.get("id") or "" + if not eid: + continue + try: + cls = get_ensemble_by_id(eid) + except Exception as e: + print(f" [FAIL] id={eid!r}: {e!r}") + continue + + resolved_id = getattr(cls, "id", None) + if (resolved_id or "").lower() != eid.lower(): + print( + f" [FAIL] id={eid!r}: resolved class id={resolved_id!r} " + f"({cls.__module__}.{cls.__name__})" + ) + continue + + ok += 1 + print(f" [OK] id={eid!r} -> {cls.__module__}.{cls.__name__}") + + print(f"\nRound-trip checks completed. Successful lookups: {ok}") + print("=== Self-test done ===") diff --git a/streamline/p7_ensembles/utils/model_utils.py b/streamline/p7_ensembles/utils/model_utils.py new file mode 100644 index 00000000..53e99507 --- /dev/null +++ b/streamline/p7_ensembles/utils/model_utils.py @@ -0,0 +1,77 @@ +from collections import defaultdict +from sklearn.exceptions import NotFittedError +from sklearn.utils.metaestimators import _BaseComposition + +class _BaseXComposition(_BaseComposition): + """ + parameter handler for list of estimators + """ + + def _set_params(self, attr, named_attr, **params): + # Ordered parameter replacement + # 1. root parameter + if attr in params: + setattr(self, attr, params.pop(attr)) + + # 2. single estimator replacement + items = getattr(self, named_attr) + names = [] + if items: + names, estimators = zip(*items) + estimators = list(estimators) + for name in list(params.keys()): + if "__" not in name and name in names: + # replace single estimator and re-build the + # root estimators list + for i, est_name in enumerate(names): + if est_name == name: + new_val = params.pop(name) + if new_val is None: + del estimators[i] + else: + estimators[i] = new_val + break + # replace the root estimators + setattr(self, attr, estimators) + + # 3. estimator parameters and other initialisation arguments + super(_BaseXComposition, self).set_params(**params) + return self + +def check_is_fitted(estimator, attributes, msg=None, all_or_any=all): + """Perform is_fitted validation for estimator. """ + if msg is None: + msg = ( + "This %(name)s instance is not fitted yet. Call 'fit' with " + "appropriate arguments before using this method." + ) + + if not hasattr(estimator, "fit"): + raise TypeError("%s is not an estimator instance." % (estimator)) + + if not isinstance(attributes, (list, tuple)): + attributes = [attributes] + + if not all_or_any([hasattr(estimator, attr) for attr in attributes]): + raise NotFittedError(msg % {"name": type(estimator).__name__}) + +def _name_estimators(estimators): + """Generate names for estimators.""" + + names = [type(estimator).__name__.lower() for estimator in estimators] + namecount = defaultdict(int) + for _, name in zip(estimators, names): + namecount[name] += 1 + + for k, v in list(namecount.items()): + if v == 1: + del namecount[k] + + for i in reversed(range(len(estimators))): + name = names[i] + if name in namecount: + names[i] += "-%d" % namecount[name] + namecount[name] -= 1 + + return list(zip(names, estimators)) + diff --git a/streamline/p7_ensembles/utils/stacking_model.py b/streamline/p7_ensembles/utils/stacking_model.py new file mode 100644 index 00000000..4bd9dac6 --- /dev/null +++ b/streamline/p7_ensembles/utils/stacking_model.py @@ -0,0 +1,349 @@ +# Stacking classifier + +# Adapted from mlxtend Machine Learning Library Extensions, Sebastian Raschka 2014-2024 +# +# An ensemble-learning meta-classifier for stacking +# +# License: BSD 3 clause + +import warnings + +import numpy as np +from scipy import sparse +from sklearn.base import TransformerMixin, ClassifierMixin, clone +from sklearn.preprocessing import LabelEncoder + + +from streamline.p7_ensembles.utils.model_utils import check_is_fitted +from streamline.p7_ensembles.utils.model_utils import _name_estimators +from streamline.p7_ensembles.utils.model_utils import _BaseXComposition + +class _BaseStackingClassifier(ClassifierMixin): + """Base class of stacking classifiers""" + + def _do_predict(self, X, predict_fn): + meta_features = self.predict_meta_features(X) + + if not self.use_features_in_secondary: + return predict_fn(meta_features) + elif sparse.issparse(X): + return predict_fn(sparse.hstack((X, meta_features))) + else: + return predict_fn(np.hstack((X, meta_features))) + + def predict(self, X): + """Predict target values for X. + + Parameters + ---------- + X : numpy array, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + + Returns + ---------- + labels : array-like, shape = [n_samples] + Predicted class labels. + + """ + check_is_fitted(self, ["clfs_", "meta_clf_"]) + + return self._do_predict(X, self.meta_clf_.predict) + + def predict_proba(self, X): + """ Predict class probabilities for X. + + Parameters + ---------- + X : {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + + Returns + ---------- + proba : array-like, shape = [n_samples, n_classes] or a list of \ + n_outputs of such arrays if n_outputs > 1. + Probability for each class per sample. + + """ + check_is_fitted(self, ["clfs_", "meta_clf_"]) + + return self._do_predict(X, self.meta_clf_.predict_proba) + + def decision_function(self, X): + """ Predict class confidence scores for X. + + Parameters + ---------- + X : {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + + Returns + ---------- + scores : shape=(n_samples,) if n_classes == 2 else \ + (n_samples, n_classes). + Confidence scores per (sample, class) combination. In the binary + case, confidence score for self.classes_[1] where >0 means this + class would be predicted. + + """ + check_is_fitted(self, ["clfs_", "meta_clf_"]) + + return self._do_predict(X, self.meta_clf_.decision_function) + +class StackingClassifier(_BaseXComposition, _BaseStackingClassifier, TransformerMixin): + """A Stacking classifier for scikit-learn estimators for classification. + + Parameters + ---------- + classifiers : array-like, shape = [n_classifiers] + A list of classifiers. + Invoking the `fit` method on the `StackingClassifer` will fit clones + of these original classifiers that will + be stored in the class attribute + `self.clfs_` if `use_clones=True` (default) and + `fit_base_estimators=True` (default). + meta_classifier : object + The meta-classifier to be fitted on the ensemble of + classifiers + use_probas : bool (default: False) + If True, trains meta-classifier based on predicted probabilities + instead of class labels. + drop_proba_col : string (default: None) + Drops extra "probability" column in the feature set, because it is + redundant: + p(y_c) = 1 - p(y_1) + p(y_2) + ... + p(y_{c-1}). + This can be useful for meta-classifiers that are sensitive to perfectly + collinear features. + If 'last', drops last probability column. + If 'first', drops first probability column. + Only relevant if `use_probas=True`. + average_probas : bool (default: False) + Averages the probabilities as meta features if `True`. + Only relevant if `use_probas=True`. + verbose : int, optional (default=0) + Controls the verbosity of the building process. + - `verbose=0` (default): Prints nothing + - `verbose=1`: Prints the number & name of the regressor being fitted + - `verbose=2`: Prints info about the parameters of the + regressor being fitted + - `verbose>2`: Changes `verbose` param of the underlying regressor to + self.verbose - 2 + use_features_in_secondary : bool (default: False) + If True, the meta-classifier will be trained both on the predictions + of the original classifiers and the original dataset. + If False, the meta-classifier will be trained only on the predictions + of the original classifiers. + store_train_meta_features : bool (default: False) + If True, the meta-features computed from the training data used + for fitting the meta-classifier stored in the + `self.train_meta_features_` array, which can be + accessed after calling `fit`. + use_clones : bool (default: True) + Clones the classifiers for stacking classification if True (default) + or else uses the original ones, which will be refitted on the dataset + upon calling the `fit` method. Hence, if use_clones=True, the original + input classifiers will remain unmodified upon using the + StackingClassifier's `fit` method. + Setting `use_clones=False` is + recommended if you are working with estimators that are supporting + the scikit-learn fit/predict API interface but are not compatible + to scikit-learn's `clone` function. + fit_base_estimators: bool (default: True) + Refits classifiers in `classifiers` if True; uses references to the + `classifiers`, otherwise (assumes that the classifiers were + already fit). + Note: fit_base_estimators=False will enforce use_clones to be False, + and is incompatible to most scikit-learn wrappers! + For instance, if any form of cross-validation is performed + this would require the re-fitting classifiers to training folds, which + would raise a NotFitterError if fit_base_estimators=False. + (New in mlxtend v0.6.) + + Attributes + ---------- + clfs_ : list, shape=[n_classifiers] + Fitted classifiers (clones of the original classifiers) + meta_clf_ : estimator + Fitted meta-classifier (clone of the original meta-estimator) + classes_ : ndarray of shape (n_classes,) or list of ndarray if `y` \ + is of type `"multilabel-indicator"`. + Class labels. + train_meta_features : numpy array, shape = [n_samples, n_classifiers] + meta-features for training data, where n_samples is the + number of samples + in training data and n_classifiers is the number of classfiers. + + Examples + ----------- + For usage examples, please see + https://rasbt.github.io/mlxtend/user_guide/classifier/StackingClassifier/ + """ + + def __init__( + self, + classifiers, + meta_classifier, + use_probas=True, + drop_proba_col=None, + average_probas=False, + verbose=0, + use_features_in_secondary=False, + store_train_meta_features=False, + use_clones=True, + fit_base_estimators=False, + ): + self.classifiers = classifiers + self.meta_classifier = meta_classifier + self.use_probas = use_probas + + allowed = {None, "first", "last"} + if drop_proba_col not in allowed: + raise ValueError( + "`drop_proba_col` must be in %s. Got %s" % (allowed, drop_proba_col) + ) + self.drop_proba_col = drop_proba_col + + self.average_probas = average_probas + self.verbose = verbose + self.use_features_in_secondary = use_features_in_secondary + self.store_train_meta_features = store_train_meta_features + self.use_clones = use_clones + self.fit_base_estimators = fit_base_estimators + + @property + def named_classifiers(self): + return _name_estimators(self.classifiers) + + def fit(self, X, y, sample_weight=None): + """Fit ensemble classifers and the meta-classifier. + + Parameters + ---------- + X : {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + y : array-like, shape = [n_samples] or [n_samples, n_outputs] + Target values. + sample_weight : array-like, shape = [n_samples], optional + Sample weights passed as sample_weights to each regressor + in the regressors list as well as the meta_regressor. + Raises error if some regressor does not support + sample_weight in the fit() method. + + Returns + ------- + self : object + + """ + if not self.fit_base_estimators: + warnings.warn( + "fit_base_estimators=False " "enforces use_clones to be `False`" + ) + self.use_clones = False + + if self.use_clones: + self.clfs_ = clone(self.classifiers) + self.meta_clf_ = clone(self.meta_classifier) + else: + self.clfs_ = self.classifiers + self.meta_clf_ = self.meta_classifier + + if y.ndim > 1: + self._label_encoder = [LabelEncoder().fit(yk) for yk in y.T] + self.classes_ = [le.classes_ for le in self._label_encoder] + else: + self._label_encoder = LabelEncoder().fit(y) + self.classes_ = self._label_encoder.classes_ + + if self.fit_base_estimators: + if self.verbose > 0: + print("Fitting %d classifiers..." % (len(self.classifiers))) + + for clf in self.clfs_: + if self.verbose > 0: + i = self.clfs_.index(clf) + 1 + print( + "Fitting classifier%d: %s (%d/%d)" + % (i, _name_estimators((clf,))[0][0], i, len(self.clfs_)) + ) + + if self.verbose > 2: + if hasattr(clf, "verbose"): + clf.set_params(verbose=self.verbose - 2) + + if self.verbose > 1: + print(_name_estimators((clf,))[0][1]) + if sample_weight is None: + clf.fit(X, y) + else: + clf.fit(X, y, sample_weight=sample_weight) + + meta_features = self.predict_meta_features(X) + + if self.store_train_meta_features: + self.train_meta_features_ = meta_features + + if not self.use_features_in_secondary: + pass + elif sparse.issparse(X): + meta_features = sparse.hstack((X, meta_features)) + else: + meta_features = np.hstack((X, meta_features)) + + if sample_weight is None: + self.meta_clf_.fit(meta_features, y) + else: + self.meta_clf_.fit(meta_features, y, sample_weight=sample_weight) + + return self + + def get_params(self, deep=True): + """Return estimator parameter names for GridSearch support.""" + return self._get_params("named_classifiers", deep=deep) + + def set_params(self, **params): + """Set the parameters of this estimator. + + Valid parameter keys can be listed with ``get_params()``. + + Returns + ------- + self + """ + self._set_params("classifiers", "named_classifiers", **params) + return self + + def predict_meta_features(self, X): + """Get meta-features of test-data. + + Parameters + ---------- + X : numpy array, shape = [n_samples, n_features] + Test vectors, where n_samples is the number of samples and + n_features is the number of features. + + Returns + ------- + meta-features : numpy array, shape = [n_samples, n_classifiers] + Returns the meta-features for test data. + + """ + check_is_fitted(self, "clfs_") + if self.use_probas: + if self.drop_proba_col == "last": + probas = np.asarray( + [clf.predict_proba(X)[:, :-1] for clf in self.clfs_] + ) + elif self.drop_proba_col == "first": + probas = np.asarray([clf.predict_proba(X)[:, 1:] for clf in self.clfs_]) + else: + probas = np.asarray([clf.predict_proba(X) for clf in self.clfs_]) + if self.average_probas: + vals = np.average(probas, axis=0) + else: + vals = np.concatenate(probas, axis=1) + else: + vals = np.column_stack([clf.predict(X) for clf in self.clfs_]) + return vals \ No newline at end of file diff --git a/streamline/p8_summary_statistics/__init__.py b/streamline/p8_summary_statistics/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/streamline/p8_summary_statistics/p8_cli.py b/streamline/p8_summary_statistics/p8_cli.py new file mode 100644 index 00000000..0cf02230 --- /dev/null +++ b/streamline/p8_summary_statistics/p8_cli.py @@ -0,0 +1,76 @@ +import argparse +from streamline.p8_summary_statistics.p8_runner import P8Runner +from streamline.utils.run_commands import ( + add_run_command_args, + apply_saved_run_command, + require_args, + save_run_command_from_args, + snapshot_args, +) + + +def main(): + ap = argparse.ArgumentParser("STREAMLINE Phase 8 (Statistics) CLI", + formatter_class=argparse.ArgumentDefaultsHelpFormatter) + ap.add_argument("--output_path", required=True) + ap.add_argument("--experiment_name", required=True) + + ap.add_argument("--outcome_label", default="Class") + ap.add_argument("--outcome_type", default=None, + help="Binary | Multiclass | Continuous; " + "if omitted, loaded from experiment metadata.pickle") + ap.add_argument("--instance_label", default=None) + ap.add_argument("--n_splits", type=int, default=None) + + ap.add_argument("--scoring_metric", default="balanced_accuracy") + ap.add_argument("--metric_weight", default="balanced_accuracy", + help="Metric used to weight composite FI (e.g. balanced_accuracy, explained_variance)") + ap.add_argument("--top_features", type=int, default=40) + ap.add_argument("--sig_cutoff", type=float, default=0.05) + ap.add_argument("--scale_data", type=int, default=1) + ap.add_argument("--exclude_plots", default="", + help="Comma-separated subset of: plot_ROC,plot_PRC,plot_FI_box,plot_metric_boxplots") + ap.add_argument("--show_plots", type=int, default=0) + ap.add_argument("--include_ensembles", type=int, default=1, + help="1 to summarize ensembles from Phase 7 if present") + ap.add_argument("--multiclass_average", default="micro", + help="Averaging method for multiclass metrics: micro | macro") + + # execution + ap.add_argument("--run_cluster", default="Serial", + help="Serial | Local | Parallel | BashSLURM | BashLSF | ") + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", type=int, default=4) + add_run_command_args(ap) + + args = ap.parse_args() + args = apply_saved_run_command(ap, args, "p8_summary_statistics") + require_args(ap, args, ["n_splits"]) + run_command_args = snapshot_args(args) + + runner = P8Runner( + output_path=args.output_path, + experiment_name=args.experiment_name, + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + instance_label=args.instance_label, + n_splits=args.n_splits, + scoring_metric=args.scoring_metric, + metric_weight=args.metric_weight, + top_features=args.top_features, + sig_cutoff=args.sig_cutoff, + scale_data=bool(args.scale_data), + exclude_plots=args.exclude_plots, + show_plots=bool(args.show_plots), + include_ensembles=bool(args.include_ensembles), + multiclass_average=args.multiclass_average, + run_cluster=args.run_cluster, + queue=args.queue, + reserved_memory=args.reserved_memory, + ) + runner.run() + save_run_command_from_args(args, "p8_summary_statistics", run_command_args, runner=runner) + + +if __name__ == "__main__": + main() diff --git a/streamline/p8_summary_statistics/p8_jobsubmit.py b/streamline/p8_summary_statistics/p8_jobsubmit.py new file mode 100644 index 00000000..1dd6ee2e --- /dev/null +++ b/streamline/p8_summary_statistics/p8_jobsubmit.py @@ -0,0 +1,54 @@ +import argparse +from streamline.p8_summary_statistics.statistics import StatisticsPhaseJob + + +def _b(x): + if x is None: + return False + return str(x).strip().lower() in ("1", "true", "t", "yes", "y") + + +def main(): + ap = argparse.ArgumentParser("P8 Statistics jobsubmit (single dataset)") + ap.add_argument("--dataset_dir", required=True) + ap.add_argument("--outcome_label", default="Class") + ap.add_argument("--outcome_type", default="Binary") # Binary | Multiclass | Continuous + ap.add_argument("--instance_label", default=None) + ap.add_argument("--n_splits", type=int, required=True) + + ap.add_argument("--scoring_metric", default="balanced_accuracy") + ap.add_argument("--metric_weight", default="balanced_accuracy") + ap.add_argument("--top_features", type=int, default=40) + ap.add_argument("--sig_cutoff", type=float, default=0.05) + ap.add_argument("--scale_data", default="1") + ap.add_argument("--exclude_plots", default="") + ap.add_argument("--show_plots", default="0") + ap.add_argument("--include_ensembles", default="1") + ap.add_argument("--multiclass_average", default="micro") + + args = ap.parse_args() + + exclude_plots = [ + x.strip() for x in args.exclude_plots.split(",") if x.strip() + ] if args.exclude_plots else [] + + StatisticsPhaseJob( + dataset_dir=args.dataset_dir, + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + instance_label=(args.instance_label if args.instance_label else None), + scoring_metric=args.scoring_metric, + cv_partitions=int(args.n_splits), + top_features=int(args.top_features), + sig_cutoff=float(args.sig_cutoff), + metric_weight=args.metric_weight, + scale_data=_b(args.scale_data), + exclude_plots=exclude_plots, + show_plots=_b(args.show_plots), + include_ensembles=_b(args.include_ensembles), + multiclass_average=args.multiclass_average, + ).run() + + +if __name__ == "__main__": + main() diff --git a/streamline/p8_summary_statistics/p8_runner.py b/streamline/p8_summary_statistics/p8_runner.py new file mode 100644 index 00000000..7935f9df --- /dev/null +++ b/streamline/p8_summary_statistics/p8_runner.py @@ -0,0 +1,193 @@ +from __future__ import annotations +import os +import time +import pickle +import logging +from pathlib import Path +from typing import Optional, List + +import dask +from dask.distributed import Client, LocalCluster + +from streamline.p8_summary_statistics.statistics import StatisticsPhaseJob +from streamline.utils.runners import num_cores, run_dask_tasks, run_parallel_items +from streamline.utils.cluster import get_cluster # returns connected Dask Client + +logger = logging.getLogger("distributed.worker") +logger.setLevel(logging.WARNING) + + +class P8Runner: + """ + Phase 8 runner (Statistics). + Modes via run_cluster: + • "Serial" + • "Local" + • "Parallel" + • "BashSLURM" | "BashLSF" + • "" (get_cluster(...) provides a connected Client) + """ + + def __init__( + self, + output_path: str, + experiment_name: str, + *, + outcome_label: str = "Class", + outcome_type: Optional[str] = None, # auto from metadata.pickle if None + instance_label: Optional[str] = None, + n_splits: int = 10, + scoring_metric: str = "balanced_accuracy", + metric_weight: str = "balanced_accuracy", + top_features: int = 40, + sig_cutoff: float = 0.05, + scale_data: bool = True, + exclude_plots: Optional[str] = None, # CSV: "plot_ROC,plot_PRC" + show_plots: bool = False, + include_ensembles: bool = True, + multiclass_average: str = "micro", + # execution + run_cluster: str = "Serial", # "Serial" | "Local" | "Parallel" | "BashSLURM" | "BashLSF" | "" + queue: str = "defq", + reserved_memory: int = 4, + ): + self.output_path = output_path + self.experiment_name = experiment_name + self.outcome_label = outcome_label + self.instance_label = instance_label + self.n_splits = int(n_splits) + self.scoring_metric = scoring_metric + self.metric_weight = metric_weight + self.top_features = int(top_features) + self.sig_cutoff = float(sig_cutoff) + self.scale_data = bool(scale_data) + self.show_plots = bool(show_plots) + self.include_ensembles = bool(include_ensembles) + self.multiclass_average = multiclass_average + + self.run_cluster = run_cluster or "Serial" + self.queue = queue + self.reserved_memory = int(reserved_memory) + + self.exp_root = os.path.join(self.output_path, self.experiment_name) + if not os.path.isdir(self.exp_root): + raise Exception("Experiment must exist before Phase 8 can begin") + + # outcome_type: from metadata.pickle if not provided + if outcome_type is None: + meta_path = os.path.join(self.exp_root, "metadata.pickle") + if not os.path.exists(meta_path): + raise Exception("metadata.pickle not found at experiment root") + with open(meta_path, "rb") as f: + metadata = pickle.load(f) + self.outcome_type = metadata.get("Outcome Type", "Binary") + else: + self.outcome_type = outcome_type + + if exclude_plots: + self.exclude_plots: List[str] = [x.strip() for x in exclude_plots.split(",") if x.strip()] + else: + self.exclude_plots = [] + + if self.run_cluster in ("BashSLURM", "BashLSF"): + os.makedirs(os.path.join(self.exp_root, "jobs"), exist_ok=True) + os.makedirs(os.path.join(self.exp_root, "logs"), exist_ok=True) + + def run(self): + datasets = [ + os.path.join(self.exp_root, name) + for name in sorted(os.listdir(self.exp_root)) + if os.path.isdir(os.path.join(self.exp_root, name)) + and name not in {"jobsCompleted", "jobs", "logs", "dask_logs", "DatasetComparisons"} + and os.path.isdir(os.path.join(self.exp_root, name, "CVDatasets")) + ] + if not datasets: + logging.warning("No datasets found for Phase 8 under %s", self.exp_root) + return + + mode = self.run_cluster + if mode == "Serial": + for ds in datasets: + self._run_one(ds) + elif mode == "Local": + with LocalCluster(processes=True, n_workers=num_cores, threads_per_worker=1) as cluster: + with Client(cluster) as client: + tasks = [dask.delayed(self._run_one)(ds) for ds in datasets] + run_dask_tasks(tasks, client, label="Phase 8 Dask jobs") + elif mode == "Parallel": + run_parallel_items(self._run_one, datasets, label="Phase 8 Parallel jobs") + elif mode in ("BashSLURM", "BashLSF"): + for ds in datasets: + self._submit_bash(ds, mode) + else: + client: Client = get_cluster(mode, self.exp_root, self.queue, self.reserved_memory) + tasks = [dask.delayed(self._run_one)(ds) for ds in datasets] + run_dask_tasks(tasks, client, label="Phase 8 Dask jobs") + + def _run_one(self, dataset_dir: str): + StatisticsPhaseJob( + full_path=dataset_dir, + outcome_label=self.outcome_label, + outcome_type=self.outcome_type, + instance_label=self.instance_label, + scoring_metric=self.scoring_metric, + cv_partitions=self.n_splits, + top_features=self.top_features, + sig_cutoff=self.sig_cutoff, + metric_weight=self.metric_weight, + scale_data=self.scale_data, + exclude_plots=self.exclude_plots, + show_plots=self.show_plots, + include_ensembles=self.include_ensembles, + multiclass_average=self.multiclass_average, + + ).run() + + def _submit_bash(self, dataset_dir: str, mode: str): + import pickle # local to avoid circular imports in __init__ + job_ref = str(time.time()) + jobs = os.path.join(self.exp_root, "jobs") + logs = os.path.join(self.exp_root, "logs") + os.makedirs(jobs, exist_ok=True) + os.makedirs(logs, exist_ok=True) + sh_path = os.path.join(jobs, f"P8_{job_ref}_run.sh") + launcher = "sbatch" if mode == "BashSLURM" else "bsub <" + + script = str(Path(__file__).parent / "p8_jobsubmit.py") + args = [ + "python", script, + "--dataset_dir", dataset_dir, + "--outcome_label", self.outcome_label, + "--outcome_type", self.outcome_type, + "--instance_label", self.instance_label or "", + "--n_splits", str(self.n_splits), + "--scoring_metric", self.scoring_metric, + "--metric_weight", self.metric_weight, + "--top_features", str(self.top_features), + "--sig_cutoff", str(self.sig_cutoff), + "--scale_data", "1" if self.scale_data else "0", + "--exclude_plots", ",".join(self.exclude_plots) if self.exclude_plots else "", + "--show_plots", "1" if self.show_plots else "0", + "--include_ensembles", "1" if self.include_ensembles else "0", + "--multiclass_average", self.multiclass_average, + ] + cmd = " ".join(args) + + with open(sh_path, "w") as sh: + sh.write("#!/bin/bash\n") + if mode == "BashSLURM": + sh.write(f"#SBATCH -p {self.queue}\n") + sh.write(f"#SBATCH --job-name={job_ref}\n") + sh.write(f"#SBATCH --mem={self.reserved_memory}G\n") + sh.write(f"#SBATCH -o {logs}/P8_{job_ref}.o\n") + sh.write(f"#SBATCH -e {logs}/P8_{job_ref}.e\n") + sh.write("srun " + cmd + "\n") + else: + sh.write(f"#BSUB -q {self.queue}\n") + sh.write(f"#BSUB -J {job_ref}\n") + sh.write(f"#BSUB -R \"rusage[mem={self.reserved_memory}G]\"\n") + sh.write(f"#BSUB -M {self.reserved_memory}GB\n") + sh.write(f"#BSUB -o {logs}/P8_{job_ref}.o\n") + sh.write(f"#BSUB -e {logs}/P8_{job_ref}.e\n") + sh.write(cmd + "\n") + os.system(f"{launcher} {sh_path}") diff --git a/streamline/p8_summary_statistics/statistics.py b/streamline/p8_summary_statistics/statistics.py new file mode 100644 index 00000000..f3ae362b --- /dev/null +++ b/streamline/p8_summary_statistics/statistics.py @@ -0,0 +1,1767 @@ +from __future__ import annotations + +import csv +import glob +import os +import re +import pickle +import time +import json +import logging +from pathlib import Path +from statistics import mean, median, stdev +from typing import List, Dict, Tuple, Optional, Any +from sklearn.metrics import auc + +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +from matplotlib import rc +from streamline.p8_summary_statistics.utils.plot_curves import ( + plot_model_roc, + plot_model_prc, + plot_summary_roc, + plot_summary_prc, + plot_metric_boxplots, + plot_ensemble_roc_summary, + plot_ensemble_prc_summary, +) +from streamline.p8_summary_statistics.utils.plot_fi import ( + plot_fi_boxplots, + plot_fi_histogram, + plot_composite_fi, +) +from streamline.p8_summary_statistics.utils.fi_core import ( + prep_fi, + select_for_composite_viz, + get_fi_to_viz_sorted, + frac_fi, + weight_fi, + weight_frac_fi, +) +from streamline.p8_summary_statistics.utils.plot_regression import residuals_regression + + +from scipy import stats +from scipy.stats import kruskal, wilcoxon, mannwhitneyu +from streamline.p6_modeling.utils.loader import list_models, get_model_by_id + +import seaborn as sns + +sns.set_theme() +logger = logging.getLogger(__name__) + + +class StatisticsPhaseJob: + """ + Phase 8: Statistics & post-analysis summary for STREAMLINE3. + + This is the modernized version of the legacy StatsJob, adapted so that: + * algorithms are discovered from model_evaluation/pickled_metrics + * ensemble summaries can be added on top (if present from Phase 7) + """ + + def __init__( + self, + full_path: str, + outcome_label: str, + outcome_type: str, + instance_label: Optional[str], + scoring_metric: str = "balanced_accuracy", + cv_partitions: int = 5, + top_features: int = 40, + sig_cutoff: float = 0.05, + metric_weight: str = "balanced_accuracy", + scale_data: bool = True, + exclude_plots: Optional[List[str]] = None, + show_plots: bool = False, + include_ensembles: bool = True, + multiclass_average: str = "micro", + ): + """ + Args: + full_path: path to dataset dir: // + outcome_label: column name of outcome (e.g. 'Class') + outcome_type: 'Binary' | 'Multiclass' | 'Continuous' + instance_label: e.g. 'InstanceID' or None + scoring_metric: sklearn metric name used in modeling + cv_partitions: number of CV splits + top_features: number of top features for FI visualisations + sig_cutoff: alpha for Kruskal / Wilcoxon / Mann-Whitney + metric_weight: metric used for composite FI weighting + scale_data: kept for API parity (not used directly here) + exclude_plots: list of strings from + ['plot_ROC', 'plot_PRC', 'plot_FI_box', 'plot_metric_boxplots'] + show_plots: whether to show figures interactively + include_ensembles: if True, also summarize Phase 7 ensemble metrics if present + """ + self.full_path = full_path + self.outcome_label = outcome_label + self.outcome_type = outcome_type + self.instance_label = instance_label + self.data_name = self.full_path.split("/")[-1] + self.experiment_path = "/".join(self.full_path.split("/")[:-1]) + self.cv_partitions = cv_partitions + self.scale_data = scale_data + self.scoring_metric = scoring_metric + self.top_features = top_features + self.sig_cutoff = sig_cutoff + self.metric_weight = metric_weight + self.show_plots = show_plots + self.include_ensembles = include_ensembles + + # multiclass averaging choice + self.multiclass_average = multiclass_average + if self.outcome_type == "Multiclass" and self.multiclass_average not in ("micro", "macro"): + raise ValueError( + f"multiclass_average must be 'micro' or 'macro', got {self.multiclass_average!r}" + ) + + # Plot exclusions + known_exclude_options = [ + "plot_ROC", + "plot_PRC", + "plot_FI_box", + "plot_metric_boxplots", + ] + if exclude_plots is not None: + for x in exclude_plots: + if x not in known_exclude_options: + logging.warning("Unknown exclusion option %s", x) + else: + exclude_plots = [] + + self.plot_roc = "plot_ROC" not in exclude_plots + self.plot_prc = "plot_PRC" not in exclude_plots + self.plot_metric_boxplots = "plot_metric_boxplots" not in exclude_plots + self.plot_fi_box = "plot_FI_box" not in exclude_plots + + # Map metric_weight from sklearn name to human-friendly text used in plots + if self.outcome_type == "Continuous" and ( + self.scoring_metric != "explained_variance" + or self.metric_weight != "explained_variance" + ): + logging.warning( + "Unsupported scoring_metric %s or metric_weight %s for Continuous outcome; defaulting both to explained_variance", + self.scoring_metric, + self.metric_weight, + ) + self.metric_weight = "explained_variance" + self.scoring_metric = "explained_variance" + elif self.outcome_type in ("Binary", "Multiclass") and self.metric_weight not in ( + "balanced_accuracy", "accuracy", "f1", "recall", "precision", "roc_auc"): + logging.warning( + "Unsupported metric_weight %s for outcome_type %s; defaulting to balanced_accuracy", + self.metric_weight, + self.outcome_type, + ) + self.metric_weight = "balanced_accuracy" + self.scoring_metric = "balanced_accuracy" + + if self.outcome_type == "Binary": + metric_term_dict = { + "balanced_accuracy": "Balanced Accuracy", + "accuracy": "Accuracy", + "f1": "F1 Score", + "recall": "Sensitivity (Recall)", + "precision": "Precision (PPV)", + "roc_auc": "ROC AUC", + } + elif self.outcome_type == "Continuous": + metric_term_dict = { + "max_error": "Max Error", + "mean_absolute_error": "Mean Absolute Error", + "mean_squared_error": "Mean Squared Error", + "median_absolute_error": "Median Absolute Error", + "explained_variance": "Explained Variance", + "pearson_correlation": "Pearson Correlation", + "f1": "F1 Score", + } + elif self.outcome_type == "Multiclass": + metric_term_dict = { + "balanced_accuracy": "Balanced Accuracy", + "accuracy": "Accuracy", + "f1": "F1 Score", + "recall": "Sensitivity (Recall)", + "precision": "Precision (PPV)", + "roc_auc": "ROC AUC", + } + else: + raise ValueError(f"Unknown outcome_type: {self.outcome_type}") + + self.metric_weight = metric_term_dict[self.metric_weight] + + # Prepare feature headers + if self.plot_fi_box: + self.feature_headers = pd.read_csv( + self.full_path + "/exploratory/ProcessedFeatureNames.csv", sep="," + ).columns.values.tolist() + self.original_headers = self.feature_headers + else: + try: + self.feature_headers = pd.read_csv( + self.full_path + "/exploratory/ProcessedFeatureNames.csv", sep="," + ).columns.values.tolist() + self.original_headers = self.feature_headers + except Exception: + self.original_headers = None + self.feature_headers = None + + # NEW: discover algorithms purely from model_evaluation outputs + ( + self.algorithms, + self.abbrev, + self.colors, + ) = self._discover_algorithms_from_metrics() + + if not self.algorithms: + logging.warning( + "No algorithms discovered in %s; stats will be limited.", + self.full_path, + ) + + # ------------------------------------------------------------------ + # NEW: Algorithm discovery + # ------------------------------------------------------------------ + def _discover_algorithms_from_metrics( + self, + ) -> Tuple[List[str], Dict[str, str], Dict[str, Tuple[float, float, float]]]: + """ + Discover modeling algorithms for statistics from: + /model_evaluation/pickled_metrics/_CV__metrics.pickle + + Returns: + algorithms: list of small_names (e.g. "LR", "SVM") + abbrev: mapping algorithm -> abbrev used in file names (here same as algorithm) + colors: mapping algorithm -> RGB triple for plotting + """ + metrics_dir = Path(self.full_path) / "model_evaluation" / "metrics_by_cv" + present_algs: List[str] = [] + + if metrics_dir.is_dir(): + for fn in os.listdir(metrics_dir): + if not fn.endswith(".json"): + continue + # Expect pattern "_CV_.json" + parts = fn.split("_CV_") + if len(parts) != 2: + continue + alg = parts[0] + if alg: + present_algs.append(alg) + + present_set = set(present_algs) + if not present_set: + logging.warning( + "StatsPhaseJob: no modeling metrics found under %s", metrics_dir + ) + + # Registry-driven discovery + algorithms: List[str] = [] + abbrev: Dict[str, str] = {} + colors: Dict[str, Tuple[float, float, float]] = {} + + registry_entries = [] + if list_models is not None: + try: + registry_entries = list_models(self.outcome_type) + except Exception as e: + if self.outcome_type in ("Continuous"): + registry_entries = list_models("Regression") + else: + logging.warning("StatsPhaseJob: list_models() failed for outcome_type %s: %r", self.outcome_type, e) + + # Build a quick lookup: small_name -> (model_type, entry) + entries_by_small = {} + for entry in registry_entries: + small = (entry.get("small_name") or "").strip() + mt = (entry.get("model_type") or "").strip() + if small: + entries_by_small[small] = (mt, entry) + + for alg in sorted(present_set): + mt, entry = entries_by_small.get(alg, ("", {})) + cls = None + if get_model_by_id is not None and mt: + # Try resolving the model class to read color attribute + try: + cls = get_model_by_id(mt, alg) # small_name + except Exception: + # Fallback: try model_name / alt_id if small_name lookup fails + model_name = entry.get("model_name") or entry.get("alt_id") or alg + try: + cls = get_model_by_id(mt, model_name) + except Exception: + cls = None + + alg_name = cls.model_name if cls is not None else alg + algorithms.append(alg_name) + abbrev[alg_name] = cls.small_name if cls is not None else alg + + if cls is not None and hasattr(cls, "color"): + colors[alg_name] = cls.color # expect either named color or RGB tuple + + # ----------------------------- + # Color fallback using seaborn + # ----------------------------- + if algorithms: + palette = sns.color_palette("tab10", n_colors=len(algorithms)) + for i, alg in enumerate(algorithms): + if alg not in colors: + colors[alg] = palette[i % len(palette)] + else: + # Keep old behavior (empty but valid return) + algorithms = sorted(present_set) + abbrev = {a: a for a in algorithms} + palette = sns.color_palette("tab10", n_colors=max(len(algorithms), 1)) + colors = {a: palette[i % len(palette)] for i, a in enumerate(algorithms)} + + return algorithms, abbrev, colors + + # ------------------------------------------------------------------ + # PUBLIC ENTRY + # ------------------------------------------------------------------ + def run(self): + self.job_start_time = time.time() + logging.info("Running Statistics Summary for %s", self.data_name) + + # Ensure dirs exist + self.preparation() + + # Core stats for base models (phase 6) + if self.outcome_type == "Binary": + result_table, metric_dict = self.primary_stats_classification() + elif self.outcome_type == "Multiclass": + result_table, metric_dict = self.primary_stats_multiclass() + elif self.outcome_type == "Continuous": + result_table, metric_dict = self.primary_stats_regression() + else: + raise ValueError(f"Unknown outcome_type: {self.outcome_type}") + + # Summary ROC / PRC across algorithms + if self.outcome_type in ("Binary", "Multiclass"): + if self.plot_roc: + plot_summary_roc( + full_path=self.full_path, + colors=self.colors, + result_table=result_table, + show_plots=self.show_plots, + ) + if self.plot_prc: + plot_summary_prc( + full_path=self.full_path, + colors=self.colors, + result_table=result_table, + outcome_label=self.outcome_label, + data_name=self.data_name, + instance_label=self.instance_label, + rep_data=None, + replicate=False, + outcome_type=self.outcome_type, + cv_partitions=self.cv_partitions, + show_plots=self.show_plots, + ) + else: + # Regression residual plots + residuals_regression( + full_path=self.full_path, + algorithms=self.algorithms, + abbrev=self.abbrev, + cv_partitions=self.cv_partitions, + colors=self.colors, + show_plots=self.show_plots, + ) + + # Summaries of metrics across CV folds + metrics = list(metric_dict[self.algorithms[0]].keys()) + logging.info("Saving Metric Summaries...") + self.save_metric_stats(metrics, metric_dict) + + # Metric boxplots + if self.plot_metric_boxplots: + logging.info("Generating Metric Boxplots...") + plot_metric_boxplots( + full_path=self.full_path, + algorithms=self.algorithms, + metrics=metrics, + metric_dict=metric_dict, + show_plots=self.show_plots, + ) + + # Non-parametric tests (Kruskal, Wilcoxon, Mann-Whitney) + if len(self.algorithms) > 1: + logging.info( + "Running Non-Parametric Statistical Significance Analysis..." + ) + kruskal_summary = self.kruskal_wallis(metrics, metric_dict) + self.wilcoxon_rank(metrics, metric_dict, kruskal_summary) + self.mann_whitney_u(metrics, metric_dict, kruskal_summary) + + # Feature-importance stats & plots + ave_or_median = ( + "median" if self.outcome_type in ("Binary", "Multiclass") else "mean" + ) + self.fi_stats(metric_dict, ave_or_median) + + # Optional: summarize ensembles (Phase 7) if present + if self.include_ensembles: + try: + self.ensemble_stats_summary() + except Exception as e: + logging.warning( + "Ensemble summary failed (non-fatal): %s", str(e) + ) + + # Save runtime for this phase + self.save_runtime() + self.parse_runtime() + + logging.info("%s statistics phase complete", self.data_name) + job_file = open( + self.experiment_path + + "/jobsCompleted/job_stats_" + + self.data_name + + ".txt", + "w", + ) + job_file.write("complete") + job_file.close() + + def preparation(self): + """ + Creates directory for all results files, decodes included ML modeling + algorithms that were run + """ + if not os.path.exists(self.full_path + "/model_evaluation"): + os.mkdir(self.full_path + "/model_evaluation") + if not os.path.exists(self.full_path + "/model_evaluation/feature_importance/"): + os.mkdir(self.full_path + "/model_evaluation/feature_importance/") + + + def residuals_regression(self, result_file=None): + s_res_trains = [] # training residual + s_res_tests = [] # testing residual + s_y_train_preds = [] # training prediction + s_y_test_preds = [] # testing prediction + s_y_trains = [] # training label + s_y_tests = [] # testing label + + m_trains = [] # slope of training plot + b_trains = [] # intercept of training plot + m_tests = [] # slope of testing plot + b_tests = [] # intercept of testing plot + for algorithm in self.algorithms: + s_res_train = [] + s_res_test = [] + s_y_train_pred = [] + s_y_test_pred = [] + s_y_train = [] + s_y_test = [] + for cv_count in range(0, self.cv_partitions): + if result_file is None: + result_file = self.full_path + '/model_evaluation/pickled_metrics/' + self.abbrev[algorithm] \ + + "_CV_" + str(cv_count) + "_residuals.pickle" + file = open(result_file, 'rb') + results = pickle.load(file) + file.close() + # logging.warning(len(results)) + res_train = results[0] + res_test = results[1] + y_train_pred = results[2] + y_test_pred = results[3] + y_train = results[4] + y_test = results[5] + + s_res_train = np.stack([res_train], axis=0) + s_res_test = np.stack([res_test], axis=0) + s_y_train_pred = np.stack([y_train_pred], axis=0) + s_y_test_pred = np.stack([y_test_pred], axis=0) + s_y_train = np.stack([y_train], axis=0) + s_y_test = np.stack([y_test], axis=0) + + s_res_train = s_res_train[0] + s_res_test = s_res_test[0] + s_y_train_pred = s_y_train_pred[0] + s_y_test_pred = s_y_test_pred[0] + s_y_train = s_y_train[0] + s_y_test = s_y_test[0] + + s_res_trains.append(s_res_train) + s_res_tests.append(s_res_test) + s_y_train_preds.append(y_train_pred) + s_y_test_preds.append(y_test_pred) + s_y_trains.append(y_train) + s_y_tests.append(s_y_test) + + plt.figure() + plt.rcdefaults() + if not os.path.exists(self.full_path + '/model_evaluation/evalPlots'): + os.mkdir(self.full_path + '/model_evaluation/evalPlots') + + m_1, b_1 = np.polyfit(s_y_train_pred, s_y_train, 1) + m_2, b_2 = np.polyfit(s_y_test_pred, s_y_test, 1) + m_trains.append(m_1) + m_tests.append(m_2) + b_trains.append(b_1) + b_tests.append(b_2) + + train_df = [] + test_df = [] + for i in range(len(self.algorithms)): + df = pd.DataFrame([s_res_trains[i], [self.algorithms[i]] * len(s_res_trains[i]), + ["Training"] * len(s_res_trains[i])]).transpose() + df.columns = ["Residual", "Algorithm", "Type"] + train_df.append(df) + train_df = pd.concat(train_df).reset_index(drop=True) + for i in range(len(self.algorithms)): + df = pd.DataFrame( + [s_res_tests[i], [self.algorithms[i]] * len(s_res_tests[i]), + ["Testing"] * len(s_res_tests[i])]).transpose() + df.columns = ["Residual", "Algorithm", "Type"] + test_df.append(df) + test_df = pd.concat(test_df).reset_index(drop=True) + + train_df.to_csv(self.full_path + '/model_evaluation/residual_train.csv') + train_df = pd.read_csv(self.full_path + '/model_evaluation/residual_train.csv') + test_df.to_csv(self.full_path + '/model_evaluation/residual_test.csv') + test_df = pd.read_csv(self.full_path + '/model_evaluation/residual_test.csv') + + fig_2, axes_2 = plt.subplots(2, 2, sharey='all', figsize=[20, 15]) + for i in range(len(self.algorithms)): + axes_2[0, 0].scatter(s_y_train_preds[i], s_res_trains[i], alpha=0.4, c=self.colors[self.algorithms[i]], + label=self.algorithms[i]) + axes_2[1, 0].scatter(s_y_test_preds[i], s_res_tests[i], alpha=0.4, c=self.colors[self.algorithms[i]]) + + axes_2[0, 0].axhline(y=0, color='black', linestyle='-') + axes_2[0, 1].axhline(y=0, color='black', linestyle='-') + axes_2[1, 0].axhline(y=0, color='black', linestyle='-') + sns.violinplot(x='Algorithm', y='Residual', data=train_df, color='b', ax=axes_2[0, 1]) + sns.violinplot(x='Algorithm', y='Residual', data=test_df, color='r', ax=axes_2[1, 1]) + axes_2[1, 1].axhline(y=0, color='black', linestyle='-') + axes_2[0, 0].title.set_text("Residual vs Predicted Outcome (Training)") + axes_2[1, 0].title.set_text("Residual vs Predicted Outcome (Testing)") + axes_2[0, 1].title.set_text("Residual Distribution (Training)") + axes_2[1, 1].title.set_text("Residual Distribution (Testing)") + axes_2[0, 0].set_ylabel('Residual') + axes_2[1, 0].set_ylabel('Residual') + axes_2[1, 0].set_xlabel('Predicted Outcome') + fig_2.legend(loc='upper right') + fig_2.savefig(self.full_path + '/model_evaluation/evalPlots/residual_distrib_all_algorithms.png') + if self.show_plots: + plt.show() + else: + plt.close('all') + + fig_3, axes_3 = plt.subplots(1, 2, sharey='all', figsize=[20, 10]) + for i in range(len(self.algorithms)): + axes_3[0].scatter(s_y_train_preds[i], s_y_trains[i], alpha=0.3, c=self.colors[self.algorithms[i]]) + axes_3[1].scatter(s_y_test_preds[i], s_y_tests[i], alpha=0.3, c=self.colors[self.algorithms[i]]) + axes_3[0].plot(s_y_train_preds[i], m_trains[i] * s_y_train_preds[i] + b_trains[i], + color=self.colors[self.algorithms[i]], label=self.algorithms[i]) + axes_3[1].plot(s_y_test_preds[i], m_tests[i] * s_y_test_preds[i] + b_tests[i], + color=self.colors[self.algorithms[i]]) + axes_3[0].title.set_text('Actual Outcome vs. Predicted Outcome (Train)') + axes_3[1].title.set_text('Actual Outcome vs. Predicted Outcome (Test)') + axes_3[0].set_ylabel('Actual Outcome') + axes_3[0].set_xlabel('Predicted Outcome') + axes_3[1].set_xlabel('Predicted Outcome') + fig_3.legend(loc='upper right') + fig_3.savefig(self.full_path + '/model_evaluation/evalPlots/actual_vs_predict_all_algorithms.png') + if self.show_plots: + plt.show() + else: + plt.close('all') + + fig_4, axes_4 = plt.subplots(1, 1, figsize=(10, 10)) + for i in range(len(self.algorithms)): + stats.probplot(s_res_trains[i], dist=stats.norm, sparams=(2, 3), plot=plt, fit=False) + for i in range(len(self.algorithms)): + axes_4.get_lines()[i].set_markerfacecolor(self.colors[self.algorithms[i]]) + axes_4.get_lines()[i].set_alpha(0.5) + axes_4.get_lines()[i].set_color(self.colors[self.algorithms[i]]) + axes_4.get_lines()[i].set_label(self.algorithms[i]) + axes_4.title.set_text("Probability Plot of Training Residual") + axes_4.set_xlabel("Theoretical Quantiles") + axes_4.set_ylabel("Ordered Residual") + axes_4.legend(loc='upper right') + fig_4.savefig(self.full_path + '/model_evaluation/evalPlots/probability_train_residual_all_algorithms.png') + if self.show_plots: + plt.show() + else: + plt.close('all') + + fig_5, axes_5 = plt.subplots(1, 1, figsize=(10, 10)) + for i in range(len(self.algorithms)): + stats.probplot(s_res_tests[i], dist=stats.norm, sparams=(2, 3), plot=plt, fit=False) + for i in range(len(self.algorithms)): + axes_5.get_lines()[i].set_markerfacecolor(self.colors[self.algorithms[i]]) + axes_5.get_lines()[i].set_alpha(0.5) + axes_5.get_lines()[i].set_color(self.colors[self.algorithms[i]]) + axes_5.get_lines()[i].set_label(self.algorithms[i]) + axes_5.title.set_text("Probability Plot of Testing Residual") + axes_5.set_xlabel("Theoretical Quantiles") + axes_5.set_ylabel("Ordered Residual") + axes_5.legend(loc='upper right') + fig_5.savefig(self.full_path + '/model_evaluation/evalPlots/probability_test_residual_all_algorithms.png') + if self.show_plots: + plt.show() + else: + plt.close('all') + + def fi_stats(self, metric_dict, ave_or_median='median'): + # metric_ranking = 'median' # ave_or_median ## median #this can be changable #mean and median of the feature importance values + # metric_weighting = 'median' # ave_or_median ## mean #mean and median of the metric for weighting across algorithms cv/algo + + metric_ranking = ave_or_median + metric_weighting = ave_or_median + + logging.info('Preparing for Model Feature Importance Plotting...') + + ( + fi_df_list, + fi_med_list, + fi_med_norm_list, + med_metric_list, + all_feature_list, + non_zero_union_features, + non_zero_union_indexes, + ) = prep_fi( + full_path=self.full_path, + algorithms=self.algorithms, + abbrev=self.abbrev, + metric_dict=metric_dict, + metric_ranking=metric_ranking, + metric_weighting=metric_weighting, + metric_weight_name=self.metric_weight, + ) + + # Select 'top' features for composite visualisation + features_to_viz = select_for_composite_viz( + non_zero_union_features=non_zero_union_features, + non_zero_union_indexes=non_zero_union_indexes, + ave_metric_list=med_metric_list, + fi_ave_norm_list=fi_med_norm_list, + algorithms=self.algorithms, + top_features=self.top_features, + ) + + # per-algorithm FI plots + if self.plot_fi_box: + logging.info('Generating Feature Importance Boxplot and Histograms...') + plot_fi_boxplots( + full_path=self.full_path, + algorithms=self.algorithms, + feature_headers=self.feature_headers, + fi_df_list=fi_df_list, + fi_med_list=fi_med_list, + metric_ranking=metric_ranking, + show_plots=self.show_plots, + ) + plot_fi_histogram( + full_path=self.full_path, + algorithms=self.algorithms, + fi_med_list=fi_med_list, + metric_ranking=metric_ranking, + show_plots=self.show_plots, + ) + + # composite FI + logging.info('Generating Composite Feature Importance Plots...') + + # Take top feature names to visualize and get associated feature importance values + top_fi_med_norm_list, all_feature_list_to_viz = get_fi_to_viz_sorted( + features_to_viz=features_to_viz, + all_feature_list=all_feature_list, + fi_med_norm_list=fi_med_norm_list, + algorithms=self.algorithms, + ) + + if metric_ranking == 'mean': + y_label = 'Normalized Mean Feature Importance' + elif metric_ranking == 'median': + y_label = 'Normalized Median Feature Importance' + else: + raise Exception("Error: metric_ranking selection not found (must be mean or median)") + + # normalized composite FI + plot_composite_fi( + full_path=self.full_path, + algorithms=self.algorithms, + colors=self.colors, + fi_list=top_fi_med_norm_list, + all_feature_list_to_viz=all_feature_list_to_viz, + fig_name='Norm', + y_label_text=y_label, + metric_ranking=metric_ranking, + metric_weighting=metric_weighting, + metric_weight_label=self.metric_weight, + show_plots=self.show_plots, + ) + + # Weighted FI (performance-weighted) + fi_weight_mode = "balanced_accuracy" + if self.outcome_type == "Continuous" and self.metric_weight == "Explained Variance": + fi_weight_mode = "explained_variance" + + weighted_lists, weights = weight_fi( + med_metric_list=med_metric_list, + top_fi_med_norm_list=top_fi_med_norm_list, + weight_mode=fi_weight_mode, + ) + + # Generate Normalized and Weighted Composite FI plot + if metric_ranking == 'mean': + y_label_w = 'Normalized and Weighted Mean Feature Importance' + else: + y_label_w = 'Normalized and Weighted Median Feature Importance' + + plot_composite_fi( + full_path=self.full_path, + algorithms=self.algorithms, + colors=self.colors, + fi_list=weighted_lists, + all_feature_list_to_viz=all_feature_list_to_viz, + fig_name='Norm_Weight', + y_label_text=y_label_w, + metric_ranking=metric_ranking, + metric_weighting=metric_weighting, + metric_weight_label=self.metric_weight, + show_plots=self.show_plots, + ) + + # Code comments for fractionated composite FI - commented out for now + # Fractionated composite FI + # Weight the Fractionated FI scores for normalized,fractionated, and weighted compound FI plot + # weighted_frac_lists = weight_frac_fi(frac_lists,weights) + + # Generate Normalized, Fractionated, and Weighted Compound FI plot + # plot_composite_fi( + # full_path=self.full_path, + # algorithms=self.algorithms, + # colors=self.colors, + # fi_list=weighted_frac_lists, + # all_feature_list_to_viz=all_feature_list_to_viz, + # fig_name='Norm_Frac_Weight', + # y_label_text='Normalized, Fractionated, and Weighted Feature Importance', + # metric_ranking=metric_ranking, + # metric_weighting=metric_weighting, + # metric_weight_label=self.metric_weight, + # show_plots=self.show_plots, + # ) + # all_feature_list_to_viz, 'Norm_Frac_Weight', + # 'Normalized, Fractionated, and Weighted Feature Importance') + + def preparation(self): + """ + Creates directory for all results files, decodes included ML modeling + algorithms that were run + """ + # Create Directory + if not os.path.exists(self.full_path + '/model_evaluation'): + os.mkdir(self.full_path + '/model_evaluation') + if not os.path.exists(self.full_path + '/model_evaluation/feature_importance/'): + os.mkdir(self.full_path + '/model_evaluation/feature_importance/') + + def primary_stats_regression(self, master_list=None): + """ + Combine regression metrics and model feature importance scores across all CV datasets. + Now reads JSON from metrics_by_cv. + """ + result_table = [] + metric_dict: Dict[str, Dict[str, List[float]]] = {} + + metrics_dir = Path(self.full_path) / "model_evaluation" / "metrics_by_cv" + + for algorithm in self.algorithms: + fi_all = [] + mes, maes, mses, mdaes, evss, corrs = [[] for _ in range(6)] + + for cv_count in range(0, self.cv_partitions): + if master_list is None: + mpath = metrics_dir / f"{self.abbrev[algorithm]}_CV_{cv_count}.json" + if not mpath.exists(): + continue + with mpath.open("r") as f: + payload = json.load(f) + metric_payload = payload.get("metrics", payload) + fi = payload.get("feature_importance", []) + else: + results = master_list[cv_count][algorithm] + metric_payload = results[0] + fi = results[1] + + me = metric_payload.get("max_error") + mae = metric_payload.get("mean_absolute_error") + mse = metric_payload.get("mean_squared_error") + mdae = metric_payload.get("median_absolute_error") + evs = metric_payload.get("explained_variance") + corr = metric_payload.get("pearson_correlation") + + mes.append(me) + maes.append(mae) + mses.append(mse) + mdaes.append(mdae) + evss.append(evs) + corrs.append(corr) + + if master_list is None: + temp_list = [] + headers = pd.read_csv( + self.full_path + '/CVDatasets/' + self.data_name + + '_CV_' + str(cv_count) + '_Test.csv').columns.values.tolist() + if self.instance_label is not None and self.instance_label in headers: + headers.remove(self.instance_label) + headers.remove(self.outcome_label) + + if self.original_headers is None: + self.original_headers = headers.copy() + + for each in self.original_headers: + if each in headers: + f_index = headers.index(each) + temp_list.append(fi[f_index] if f_index < len(fi) else 0.0) + else: + temp_list.append(0.0) + fi_all.append(temp_list) + + logging.info("Running stats for " + algorithm) + + mean_me = np.mean(mes, axis=0) if mes else float("nan") + mean_mae = np.mean(maes, axis=0) if maes else float("nan") + mean_mse = np.mean(mses, axis=0) if mses else float("nan") + mean_mdae = np.mean(mdaes, axis=0) if mdaes else float("nan") + mean_evs = np.mean(evss, axis=0) if evss else float("nan") + mean_corr = np.mean(corrs, axis=0) if corrs else float("nan") + + results = { + 'Max Error': mes, + 'Mean Absolute Error': maes, + 'Mean Squared Error': mses, + 'Median Absolute Error': mdaes, + 'Explained Variance': evss, + 'Pearson Correlation': corrs, + } + dr = pd.DataFrame(results) + filepath = self.full_path + '/model_evaluation/' + self.abbrev[algorithm] + "_performance.csv" + dr.to_csv(filepath, header=True, index=False) + metric_dict[algorithm] = results + + if master_list is None: + self.save_fi(fi_all, self.abbrev[algorithm], self.original_headers) + + result_dict = { + 'algorithm': algorithm, + 'max_error': mean_me, + 'mean_absolute_error': mean_mae, + 'mean_squared_error': mean_mse, + 'median_absolute_error': mean_mdae, + 'explained_variance': mean_evs, + 'pearson_correlation': mean_corr, + } + result_table.append(result_dict) + + result_table = pd.DataFrame.from_dict(result_table) + if not result_table.empty: + result_table.set_index('algorithm', inplace=True) + return result_table, metric_dict + + + def _get_multiclass_avg_metric(self, metrics_payload: Dict[str, Any], base: str): + """ + Helper: pick the right averaged metric for multiclass. + + Preference order: + requested (micro/macro) -> macro -> micro -> base + """ + if self.outcome_type != "Multiclass": + return metrics_payload.get(base) + + suffix = "_" + self.multiclass_average + candidates = [base + suffix, base + "_macro", base + "_micro", base] + for key in candidates: + if key in metrics_payload: + return metrics_payload.get(key) + return None + + def primary_stats_multiclass(self, master_list=None, rep_data=None): + """ + Multiclass classification stats using JSON metrics/curves. + + Metrics: + - Lets you choose micro vs macro averaging for F1 / Recall / Precision + via self.multiclass_average ("micro" or "macro"). + Curves: + - Uses the same averaging key when available (e.g. "micro" or "macro" + in the saved curve JSONs), otherwise falls back gracefully. + """ + result_table = [] + metric_dict: Dict[str, Dict[str, List[float]]] = {} + + metrics_dir = Path(self.full_path) / "model_evaluation" / "metrics_by_cv" + curves_dir = Path(self.full_path) / "model_evaluation" / "curves_by_cv" + + avg_key = self.multiclass_average if self.outcome_type == "Multiclass" else "micro" + + for algorithm in self.algorithms: + alg_result_table = [] + + s_bac, s_ac, s_f1, s_re, s_pr, s_bs = [[] for _ in range(6)] + fi_all = [] + + tprs = [] + aucs = [] + mean_fpr = np.linspace(0, 1, 100) + mean_recall = np.linspace(0, 1, 100) + precs = [] + praucs = [] + aveprecs = [] + + for cv_count in range(0, self.cv_partitions): + if master_list is None: + mpath = metrics_dir / f"{self.abbrev[algorithm]}_CV_{cv_count}.json" + if not mpath.exists(): + continue + with mpath.open("r") as f: + payload = json.load(f) + metrics_payload = payload.get("metrics", payload) + fi = payload.get("feature_importance", []) + + roc_path = curves_dir / f"{self.abbrev[algorithm]}_CV_{cv_count}_roc.json" + prc_path = curves_dir / f"{self.abbrev[algorithm]}_CV_{cv_count}_prc.json" + if roc_path.exists(): + with roc_path.open("r") as f: + roc_all = json.load(f) + else: + roc_all = {} + if prc_path.exists(): + with prc_path.open("r") as f: + prc_all = json.load(f) + else: + prc_all = {} + + # curves may hold multiple averages (micro/macro) or none + roc_m = roc_all.get(avg_key) or roc_all.get("micro") or roc_all.get("macro") or (roc_all or {}) + prc_m = prc_all.get(avg_key) or prc_all.get("micro") or prc_all.get("macro") or (prc_all or {}) + + fpr = np.asarray(roc_m.get("fpr", []), dtype=float) + tpr = np.asarray(roc_m.get("tpr", []), dtype=float) + roc_auc = float(roc_m.get("auc", np.nan)) + + prec = np.asarray(prc_m.get("precision", []), dtype=float) + recall = np.asarray(prc_m.get("recall", []), dtype=float) + prec_rec_auc = float(prc_m.get("pr_auc", np.nan)) + ave_prec = float(prc_m.get("aps", np.nan)) + else: + raise NotImplementedError("master_list not implemented for multiclass yet") + + # metrics + s_bac.append(metrics_payload.get("balanced_accuracy")) + s_ac.append(metrics_payload.get("accuracy")) + s_f1.append(self._get_multiclass_avg_metric(metrics_payload, "f1")) + s_re.append(self._get_multiclass_avg_metric(metrics_payload, "recall")) + s_pr.append(self._get_multiclass_avg_metric(metrics_payload, "precision")) + s_bs.append(metrics_payload.get("brier_score")) + + alg_result_table.append([fpr, tpr, roc_auc, prec, recall, prec_rec_auc, ave_prec]) + + if fpr.size > 0 and tpr.size > 0: + tprs.append(np.interp(mean_fpr, fpr, tpr)) + tprs[-1][0] = 0.0 + aucs.append(roc_auc) + + if recall.size > 0 and prec.size > 0: + precs.append(np.interp(mean_recall, recall, prec)) + praucs.append(prec_rec_auc) + aveprecs.append(ave_prec) + + if master_list is None: + temp_list = [] + headers = pd.read_csv( + self.full_path + '/CVDatasets/' + self.data_name + + '_CV_' + str(cv_count) + '_Test.csv').columns.values.tolist() + if self.instance_label is not None and self.instance_label in headers: + headers.remove(self.instance_label) + headers.remove(self.outcome_label) + if self.original_headers is None: + self.original_headers = headers.copy() + for each in self.original_headers: + if each in headers: + f_index = headers.index(each) + temp_list.append(fi[f_index] if f_index < len(fi) else 0.0) + else: + temp_list.append(0.0) + fi_all.append(temp_list) + + logging.info("Running stats on " + algorithm) + + # mean ROC curve + per-model ROC plot + if tprs: + mean_tpr = np.mean(tprs, axis=0) + mean_tpr[-1] = 1.0 + mean_auc = np.mean(aucs) + if self.plot_roc: + plot_model_roc( + full_path=self.full_path, + algorithm=algorithm, + abbrev=self.abbrev[algorithm], + color=self.colors[algorithm], + cv_partitions=self.cv_partitions, + mean_fpr=mean_fpr, + tprs=tprs, + aucs=aucs, + alg_result_table=alg_result_table, + show_plots=self.show_plots, + ) + else: + mean_tpr = np.zeros_like(mean_fpr) + mean_auc = float("nan") + + # mean PRC curve + per-model PRC plot + if precs: + mean_prec = np.mean(precs, axis=0) + mean_pr_auc = np.mean(praucs) + if self.plot_prc: + plot_model_prc( + full_path=self.full_path, + algorithm=algorithm, + abbrev=self.abbrev[algorithm], + color=self.colors[algorithm], + cv_partitions=self.cv_partitions, + mean_recall=mean_recall, + precs=precs, + praucs=praucs, + alg_result_table=alg_result_table, + outcome_label=self.outcome_label, + data_name=self.data_name, + instance_label=self.instance_label, + rep_data=rep_data, + replicate=bool(master_list is not None), + outcome_type=self.outcome_type, + show_plots=self.show_plots, + ) + else: + mean_prec = np.zeros_like(mean_recall) + mean_pr_auc = float("nan") + + results = { + 'Balanced Accuracy': s_bac, + 'Accuracy': s_ac, + 'F1 Score': s_f1, + 'Sensitivity (Recall)': s_re, + 'Precision (PPV)': s_pr, + 'Brier Score': s_bs, + 'ROC AUC': aucs, + 'PRC AUC': praucs, + 'PRC APS': aveprecs, + } + dr = pd.DataFrame(results) + filepath = self.full_path + '/model_evaluation/' + self.abbrev[algorithm] + "_performance.csv" + dr.to_csv(filepath, header=True, index=False) + metric_dict[algorithm] = results + + if master_list is None: + self.save_fi(fi_all, self.abbrev[algorithm], self.original_headers) + + mean_ave_prec = np.mean(aveprecs) if aveprecs else float("nan") + result_dict = { + 'algorithm': algorithm, + 'fpr': mean_fpr, + 'tpr': mean_tpr, + 'auc': mean_auc, + 'prec': mean_prec, + 'recall': mean_recall, + 'pr_auc': mean_pr_auc, + 'ave_prec': mean_ave_prec, + } + result_table.append(result_dict) + + result_table = pd.DataFrame.from_dict(result_table) + if not result_table.empty: + result_table.set_index('algorithm', inplace=True) + return result_table, metric_dict + + + + def primary_stats_classification(self, master_list=None, rep_data=None): + """ + Combine binary classification metrics and FI + ROC/PRC data across CVs. + + Reads: + metrics_by_cv/_CV_.json + curves_by_cv/_CV__roc.json + curves_by_cv/_CV__prc.json + """ + result_table = [] + metric_dict: Dict[str, Dict[str, List[float]]] = {} + + metrics_dir = Path(self.full_path) / "model_evaluation" / "metrics_by_cv" + curves_dir = Path(self.full_path) / "model_evaluation" / "curves_by_cv" + + for algorithm in self.algorithms: + alg_result_table = [] + + # lists of per-CV metrics (we keep the legacy names used in CSVs) + s_bac, s_ac, s_f1, s_re, s_sp, s_pr, s_bs = [[] for _ in range(7)] + s_tp, s_tn, s_fp, s_fn, s_npv, s_lrp, s_lrm = [[] for _ in range(7)] + + fi_all = [] + + tprs = [] + aucs = [] + mean_fpr = np.linspace(0, 1, 100) + mean_recall = np.linspace(0, 1, 100) + precs = [] + praucs = [] + aveprecs = [] + + for cv_count in range(0, self.cv_partitions): + if master_list is None: + mpath = metrics_dir / f"{self.abbrev[algorithm]}_CV_{cv_count}.json" + if not mpath.exists(): + continue + with mpath.open("r") as f: + payload = json.load(f) + + metrics_payload = payload.get("metrics", payload) + fi = payload.get("feature_importance", []) + + # curves + roc_path = curves_dir / f"{self.abbrev[algorithm]}_CV_{cv_count}_roc.json" + prc_path = curves_dir / f"{self.abbrev[algorithm]}_CV_{cv_count}_prc.json" + if roc_path.exists(): + with roc_path.open("r") as f: + roc_data = json.load(f) + else: + roc_data = {} + + if prc_path.exists(): + with prc_path.open("r") as f: + prc_data = json.load(f) + else: + prc_data = {} + + # For binary we store everything under "micro" + roc_m = roc_data.get("micro", roc_data or {}) + prc_m = prc_data.get("micro", prc_data or {}) + + fpr = np.asarray(roc_m.get("fpr", []), dtype=float) + tpr = np.asarray(roc_m.get("tpr", []), dtype=float) + roc_auc = float(roc_m.get("auc", np.nan)) + + prec = np.asarray(prc_m.get("precision", []), dtype=float) + recall = np.asarray(prc_m.get("recall", []), dtype=float) + prec_rec_auc = float(prc_m.get("pr_auc", np.nan)) + ave_prec = float(prc_m.get("aps", np.nan)) + else: + # legacy master_list path (if you still use it programmatically) + raise Exception("master_list parameter not supported with JSON metrics files") + + # map from JSON metric names to legacy Stats series + s_bac.append(metrics_payload.get("balanced_accuracy")) + s_ac.append(metrics_payload.get("accuracy")) + s_f1.append(metrics_payload.get("f1")) + s_re.append(metrics_payload.get("recall")) + s_sp.append(metrics_payload.get("specificity")) + s_pr.append(metrics_payload.get("precision")) + s_tp.append(metrics_payload.get("tp")) + s_tn.append(metrics_payload.get("tn")) + s_fp.append(metrics_payload.get("fp")) + s_fn.append(metrics_payload.get("fn")) + s_npv.append(metrics_payload.get("npv")) + s_lrp.append(metrics_payload.get("lr_plus")) + s_lrm.append(metrics_payload.get("lr_minus")) + s_bs.append(metrics_payload.get("brier_score")) + + alg_result_table.append([fpr, tpr, roc_auc, prec, recall, prec_rec_auc, ave_prec]) + + if fpr.size > 0 and tpr.size > 0: + tprs.append(np.interp(mean_fpr, fpr, tpr)) + tprs[-1][0] = 0.0 + aucs.append(roc_auc) + + if recall.size > 0 and prec.size > 0: + precs.append(np.interp(mean_recall, recall, prec)) + praucs.append(prec_rec_auc) + aveprecs.append(ave_prec) + + if master_list is None: + # FI alignment as before + temp_list = [] + headers = pd.read_csv( + self.full_path + '/CVDatasets/' + self.data_name + + '_CV_' + str(cv_count) + '_Test.csv').columns.values.tolist() + if self.instance_label is not None and self.instance_label in headers: + headers.remove(self.instance_label) + headers.remove(self.outcome_label) + if self.original_headers is None: + self.original_headers = headers.copy() + for each in self.original_headers: + if each in headers: + f_index = headers.index(each) + temp_list.append(fi[f_index] if f_index < len(fi) else 0.0) + else: + temp_list.append(0.0) + fi_all.append(temp_list) + + logging.info("Running stats on " + algorithm) + + # mean ROC curve + plot via helper + if tprs: + mean_tpr = np.mean(tprs, axis=0) + mean_tpr[-1] = 1.0 + mean_auc = np.mean(aucs) + if self.plot_roc: + plot_model_roc( + full_path=self.full_path, + algorithm=algorithm, + abbrev=self.abbrev[algorithm], + color=self.colors[algorithm], + cv_partitions=self.cv_partitions, + mean_fpr=mean_fpr, + tprs=tprs, + aucs=aucs, + alg_result_table=alg_result_table, + show_plots=self.show_plots, + ) + else: + mean_tpr = np.zeros_like(mean_fpr) + mean_auc = float("nan") + + # mean PRC curve + plot via helper + if precs: + mean_prec = np.mean(precs, axis=0) + mean_pr_auc = np.mean(praucs) + if self.plot_prc: + plot_model_prc( + full_path=self.full_path, + algorithm=algorithm, + abbrev=self.abbrev[algorithm], + color=self.colors[algorithm], + cv_partitions=self.cv_partitions, + mean_recall=mean_recall, + precs=precs, + praucs=praucs, + alg_result_table=alg_result_table, + outcome_label=self.outcome_label, + data_name=self.data_name, + instance_label=self.instance_label, + rep_data=rep_data, + replicate=bool(master_list is not None), + outcome_type=self.outcome_type, + show_plots=self.show_plots, + ) + else: + mean_prec = np.zeros_like(mean_recall) + mean_pr_auc = float("nan") + + results = { + 'Balanced Accuracy': s_bac, + 'Accuracy': s_ac, + 'F1 Score': s_f1, + 'Sensitivity (Recall)': s_re, + 'Specificity': s_sp, + 'Precision (PPV)': s_pr, + 'Brier Score': s_bs, + 'TP': s_tp, + 'TN': s_tn, + 'FP': s_fp, + 'FN': s_fn, + 'NPV': s_npv, + 'LR+': s_lrp, + 'LR-': s_lrm, + 'ROC AUC': aucs, + 'PRC AUC': praucs, + 'PRC APS': aveprecs, + } + dr = pd.DataFrame(results) + filepath = self.full_path + '/model_evaluation/' + self.abbrev[algorithm] + "_performance.csv" + dr.to_csv(filepath, header=True, index=False) + metric_dict[algorithm] = results + + if master_list is None: + if self.feature_headers is None: + self.feature_headers = self.original_headers + self.save_fi(fi_all, self.abbrev[algorithm], self.feature_headers) + + mean_ave_prec = np.mean(aveprecs) if aveprecs else float("nan") + result_dict = { + 'algorithm': algorithm, + 'fpr': mean_fpr, + 'tpr': mean_tpr, + 'auc': mean_auc, + 'prec': mean_prec, + 'recall': mean_recall, + 'pr_auc': mean_pr_auc, + 'ave_prec': mean_ave_prec, + } + result_table.append(result_dict) + + result_table = pd.DataFrame.from_dict(result_table) + if not result_table.empty: + result_table.set_index('algorithm', inplace=True) + return result_table, metric_dict + + + def save_fi(self, fi_all, algorithm, global_feature_list): + """ + Creates directory to store model feature importance results and, + for each algorithm, exports a file of feature importance scores from each CV. + """ + dr = pd.DataFrame(fi_all) + if not os.path.exists(self.full_path + '/model_evaluation/feature_importance/'): + os.mkdir(self.full_path + '/model_evaluation/feature_importance/') + filepath = self.full_path + '/model_evaluation/feature_importance/' + algorithm + "_FI.csv" + dr.to_csv(filepath, header=global_feature_list, index=False) + + def save_metric_stats(self, metrics, metric_dict): + """ + Exports csv files with mean, median and std dev metric values + (over all CVs) for each ML modeling algorithm. + + Parameters + ---------- + metrics : list[str] + List of metric names (e.g. ["balanced_accuracy", "f1", ...]). + metric_dict : dict + Nested dict of metric values per algorithm. + """ + + # Initialize empty DataFrames for each statistic + # Index: algorithm names, Columns: metrics + algorithms = list(metric_dict.keys()) + df_median = pd.DataFrame(index=algorithms, columns=metrics, dtype="float64") + df_mean = pd.DataFrame(index=algorithms, columns=metrics, dtype="float64") + df_std = pd.DataFrame(index=algorithms, columns=metrics, dtype="float64") + + for algorithm, metric_values in metric_dict.items(): + for metric in metrics: + # Get list of values for this metric, default to empty list + values = metric_values.get(metric, []) + + # Convert to numeric, coercing non-numeric (including None) to NaN + s = pd.to_numeric(pd.Series(values), errors="coerce") + + # Drop NaNs so statistics ignore None / invalid entries + s = s.dropna() + + if s.empty: + # If no valid numeric values, leave as NaN + median_val = float("nan") + mean_val = float("nan") + std_val = float("nan") + else: + median_val = s.median() + mean_val = s.mean() + # Match statistics.stdev behavior: sample std (ddof=1) + std_val = s.std(ddof=1) if len(s) > 1 else float("nan") + + df_median.loc[algorithm, metric] = median_val + df_mean.loc[algorithm, metric] = mean_val + df_std.loc[algorithm, metric] = std_val + + out_dir = os.path.join(self.full_path, "model_evaluation") + os.makedirs(out_dir, exist_ok=True) + + df_median.to_csv(os.path.join(out_dir, "Summary_performance_median.csv"), index_label="") + df_mean.to_csv(os.path.join(out_dir, "Summary_performance_mean.csv"), index_label="") + df_std.to_csv(os.path.join(out_dir, "Summary_performance_std.csv"), index_label="") + + def kruskal_wallis(self, metrics, metric_dict): + """ + Apply non-parametric Kruskal Wallis one-way ANOVA on ranks. + Determines if there is a statistically significant difference in algorithm performance across CV runs. + Completed for each standard metric separately. + """ + # Create directory to store significance testing results (used for both Kruskal Wallis and MannWhitney U-test) + if not os.path.exists(self.full_path + '/model_evaluation/statistical_comparisons'): + os.mkdir(self.full_path + '/model_evaluation/statistical_comparisons') + # Create dataframe to store analysis results for each metric + label = ['Statistic', 'P-Value', 'Sig(*)'] + kruskal_summary = pd.DataFrame(index=metrics, columns=label) + # Apply Kruskal Wallis test for each metric + for metric in metrics: + temp_array = [] + for algorithm in self.algorithms: + temp_array.append(metric_dict[algorithm][metric]) + try: + result = kruskal(*temp_array) + except Exception: + result = [np.nan, 1] + kruskal_summary.at[metric, 'Statistic'] = str(round(result[0], 6)) + kruskal_summary.at[metric, 'P-Value'] = str(round(result[1], 6)) + if result[1] < self.sig_cutoff: + kruskal_summary.at[metric, 'Sig(*)'] = str('*') + else: + kruskal_summary.at[metric, 'Sig(*)'] = str('') + # Export analysis summary to .csv file + kruskal_summary.to_csv(self.full_path + '/model_evaluation/statistical_comparisons/KruskalWallis.csv') + return kruskal_summary + + def wilcoxon_rank(self, metrics, metric_dict, kruskal_summary): + """ + Apply non-parametric Wilcoxon signed-rank test (pairwise comparisons). + If a significant Kruskal Wallis algorithm difference was found for a + given metric, Wilcoxon tests individual algorithm pairs + to determine if there is a statistically significant difference in + algorithm performance across CV runs. Test statistic will be zero if + all scores from one set are + larger than the other. + """ + for metric in metrics: + if kruskal_summary['Sig(*)'][metric] == '*': + wilcoxon_stats = [] + done = [] + for algorithm1 in self.algorithms: + for algorithm2 in self.algorithms: + if (not [algorithm1, algorithm2] in done) and \ + (not [algorithm2, algorithm1] in done) and (algorithm1 != algorithm2): + set1 = metric_dict[algorithm1][metric] + set2 = metric_dict[algorithm2][metric] + # handle error when metric values are equal for both algorithms + if set1 == set2: # Check if all nums are equal in sets + report = ['NA', 1] + else: # Apply Wilcoxon Rank Sum test + try: + report = wilcoxon(set1, set2) + except Exception: + report = ['NA_error', 1] + # Summarize test information in list + tempstats = [algorithm1, algorithm2, report[0], report[1], ''] + if report[1] < self.sig_cutoff: + tempstats[4] = '*' + wilcoxon_stats.append(tempstats) + done.append([algorithm1, algorithm2]) + # Export test results + wilcoxon_stats_df = pd.DataFrame(wilcoxon_stats) + wilcoxon_stats_df.columns = ['Algorithm 1', 'Algorithm 2', 'Statistic', 'P-Value', 'Sig(*)'] + wilcoxon_stats_df.to_csv(self.full_path + + '/model_evaluation/statistical_comparisons/' + 'WilcoxonRank_' + metric + '.csv', index=False) + + def mann_whitney_u(self, metrics, metric_dict, kruskal_summary): + """ + Apply non-parametric Mann Whitney U-test (pairwise comparisons). + If a significant Kruskal Wallis algorithm difference was found for + a given metric, Mann Whitney tests individual algorithm pairs + to determine if there is a statistically significant difference + in algorithm performance across CV runs. Test statistic will be + zero if all scores from one set are larger than the other. + """ + for metric in metrics: + if kruskal_summary['Sig(*)'][metric] == '*': + mann_stats = [] + done = [] + for algorithm1 in self.algorithms: + for algorithm2 in self.algorithms: + if (not [algorithm1, algorithm2] in done) and \ + (not [algorithm2, algorithm1] in done) and (algorithm1 != algorithm2): + set1 = metric_dict[algorithm1][metric] + set2 = metric_dict[algorithm2][metric] + if set1 == set2: # Check if all nums are equal in sets + report = ['NA', 1] + else: # Apply Mann Whitney U test + try: + report = mannwhitneyu(set1, set2) + except Exception: + report = ['NA_error', 1] + # Summarize test information in list + tempstats = [algorithm1, algorithm2, report[0], report[1], ''] + if report[1] < self.sig_cutoff: + tempstats[4] = '*' + mann_stats.append(tempstats) + done.append([algorithm1, algorithm2]) + # Export test results + mann_stats_df = pd.DataFrame(mann_stats) + mann_stats_df.columns = ['Algorithm 1', 'Algorithm 2', 'Statistic', 'P-Value', 'Sig(*)'] + mann_stats_df.to_csv(self.full_path + + '/model_evaluation/' + 'statistical_comparisons/MannWhitneyU_' + metric + '.csv', index=False) + + def ensemble_stats_summary(self): + """ + Summarize ensembles created in Phase 7 (if any exist) and + generate ensemble-only ROC / PRC summary plots + metrics tables. + + Uses IO-only helpers: + - _collect_ensemble_metrics_core + - _plot_ensemble_roc_summary + - _plot_ensemble_prc_summary + """ + ens_root = Path(self.full_path) / "ensemble_evaluation" + metrics_dir = ens_root / "metrics_by_cv" + curves_dir = ens_root / "curves_by_cv" + + if not metrics_dir.exists(): + logging.info("No ensemble_evaluation/metrics_by_cv found. Skipping ensemble summary.") + return + + logging.info("Collecting ensemble statistics from %s", str(ens_root)) + + metrics_by_ens, metric_names = self._collect_ensemble_metrics_core(metrics_dir) + if not metrics_by_ens: + logging.info("No ensemble metrics found. Skipping ensemble summary.") + return + + # write ensemble-only summary tables + self._write_ensemble_metric_summaries(ens_root, metrics_by_ens, metric_names) + + # curves summary & plots + roc_summary, prc_summary = self._collect_ensemble_curves_core(curves_dir, metrics_by_ens.keys()) + if self.plot_roc and roc_summary: + plot_ensemble_roc_summary( + ens_root=ens_root, + roc_summary=roc_summary, + show_plots=self.show_plots, + ) + if self.plot_prc and prc_summary: + plot_ensemble_prc_summary( + ens_root=ens_root, + prc_summary=prc_summary, + full_path=self.full_path, + data_name=self.data_name, + outcome_label=self.outcome_label, + instance_label=self.instance_label, + outcome_type=self.outcome_type, + cv_partitions=self.cv_partitions, + show_plots=self.show_plots, + ) + + # ------------------- ensemble core helpers ------------------------- + def _collect_ensemble_metrics_core(self, metrics_dir: Path) -> Tuple[Dict[str, Dict[str, List[float]]], List[str]]: + """ + Collect per-CV JSON metrics for each ensemble id. + Returns: + metrics_by_ens: {ens_id: {metric_name: [values across CVs]}} + metric_names: list of metric names (from first ensemble) + """ + metrics_by_ens: Dict[str, Dict[str, List[float]]] = {} + for fn in metrics_dir.glob("*.json"): + # pattern: _CV_.json + m = re.match(r"(.+?)_CV_(\d+)\.json$", fn.name) + if not m: + continue + ens_id = m.group(1) + with open(fn, "r") as f: + data = json.load(f) + md = metrics_by_ens.setdefault(ens_id, {}) + for k, v in data.items(): + try: + val = float(v) + except Exception: + continue + md.setdefault(k, []).append(val) + + if not metrics_by_ens: + return {}, [] + + # Metric names from first ensemble + first_ens = next(iter(metrics_by_ens.keys())) + metric_names = metrics_by_ens[first_ens].keys() + return metrics_by_ens, metric_names + + def _write_ensemble_metric_summaries( + self, + ens_root: Path, + metrics_by_ens: Dict[str, Dict[str, List[float]]], + metric_names: List[str], + ): + """ + IO helper: write mean/median/std summary CSVs for ensemble metrics. + + Parameters + ---------- + ens_root : Path + Directory where the summary CSVs will be written. + metrics_by_ens : dict + Nested dict of metric values per ensemble ID. + metric_names : list[str] + List of metric names to summarize (columns). + """ + + ens_root.mkdir(parents=True, exist_ok=True) + + out_mean = ens_root / "Ensembles_performance_mean.csv" + out_median = ens_root / "Ensembles_performance_median.csv" + out_std = ens_root / "Ensembles_performance_std.csv" + + ensemble_ids = list(metrics_by_ens.keys()) + + # DataFrames: index = ensemble IDs, columns = metrics + df_mean = pd.DataFrame(index=ensemble_ids, columns=metric_names, dtype="float64") + df_median = pd.DataFrame(index=ensemble_ids, columns=metric_names, dtype="float64") + df_std = pd.DataFrame(index=ensemble_ids, columns=metric_names, dtype="float64") + + for ens_id, md in metrics_by_ens.items(): + for m in metric_names: + vals = md.get(m, []) + + # Convert to numeric, coercing None / bad values to NaN + s = pd.to_numeric(pd.Series(vals), errors="coerce").dropna() + + if s.empty: + mean_val = float("nan") + median_val = float("nan") + std_val = float("nan") + else: + mean_val = s.mean() + median_val = s.median() + # Sample std (like statistics.stdev), NaN if fewer than 2 valid values + std_val = s.std(ddof=1) if len(s) > 1 else float("nan") + + df_mean.loc[ens_id, m] = mean_val + df_median.loc[ens_id, m] = median_val + df_std.loc[ens_id, m] = std_val + + # Write CSVs, keeping "Ensemble" as the first column header and using "nan" for missing + df_mean.to_csv(out_mean, index_label="Ensemble", na_rep="nan") + df_median.to_csv(out_median, index_label="Ensemble", na_rep="nan") + df_std.to_csv(out_std, index_label="Ensemble", na_rep="nan") + + def _collect_ensemble_curves_core( + self, + curves_dir: Path, + ensemble_ids, + ) -> Tuple[Dict[str, Dict[str, Any]], Dict[str, Dict[str, Any]]]: + """ + Core: aggregate ROC/PRC curves over CV for each ensemble id. + + Returns: + roc_summary: {ens_id: {"fpr": common_fpr, "tpr": mean_tpr, "auc": mean_auc}} + prc_summary: {ens_id: {"recall": common_rec, "precision": mean_prec, + "pr_auc": mean_pr_auc, "aps": mean_aps}} + """ + roc_summary: Dict[str, Dict[str, Any]] = {} + prc_summary: Dict[str, Dict[str, Any]] = {} + + common_fpr = np.linspace(0.0, 1.0, 200) + common_rec = np.linspace(0.0, 1.0, 200) + + for ens_id in ensemble_ids: + # ROC + tprs = [] + aucs = [] + for roc_file in curves_dir.glob(f"{ens_id}_CV_*_roc.json"): + with roc_file.open("r") as f: + roc_data = json.load(f) + fpr = np.array(roc_data.get("fpr", []), dtype=float) + tpr = np.array(roc_data.get("tpr", []), dtype=float) + if fpr.size == 0 or tpr.size == 0: + continue + tinterp = np.interp(common_fpr, fpr, tpr) + tinterp[0] = 0.0 + tinterp[-1] = 1.0 + tprs.append(tinterp) + aucs.append(auc(fpr, tpr)) + if tprs: + mean_tpr = np.mean(tprs, axis=0) + mean_tpr[-1] = 1.0 + roc_summary[ens_id] = { + "fpr": common_fpr, + "tpr": mean_tpr, + "auc": float(np.mean(aucs)), + } + + # PRC + precs = [] + pr_aucs = [] + aps_list = [] + for prc_file in curves_dir.glob(f"{ens_id}_CV_*_prc.json"): + with prc_file.open("r") as f: + prc_data = json.load(f) + prec = np.array(prc_data.get("precision", []), dtype=float) + rec = np.array(prc_data.get("recall", []), dtype=float) + if rec.size == 0 or prec.size == 0: + continue + sidx = np.argsort(rec) + rec_sorted = rec[sidx] + prec_sorted = prec[sidx] + pinterp = np.interp(common_rec, rec_sorted, prec_sorted) + precs.append(pinterp) + pr_aucs.append(auc(rec_sorted, prec_sorted)) + # approximate APS by simple average (we don't have raw y/proba here) + aps_list.append(float(np.mean(prec_sorted))) + if precs: + mean_prec = np.mean(precs, axis=0) + prc_summary[ens_id] = { + "recall": common_rec, + "precision": mean_prec, + "pr_auc": float(np.mean(pr_aucs)), + "aps": float(np.mean(aps_list)) if aps_list else float("nan"), + } + + return roc_summary, prc_summary + + def parse_runtime(self): + """ + Loads runtime summaries from the entire pipeline and parses them into + a single CSV runtime report. + + This implementation no longer relies on pickle; it just + aggregates by the token after 'runtime_' in the filename. For model + runtimes, this will be the algorithm small_name (e.g. 'LR', 'SVM'). + """ + dict_obj: Dict[str, float] = {} + dict_obj["preprocessing"] = 0.0 + + runtime_dir = Path(self.full_path) / "runtime" + for file_path in glob.glob(str(runtime_dir / "runtime_*.txt")) \ + + glob.glob(str(runtime_dir / "models/runtime_*.txt")): + file_path = str(Path(file_path).as_posix()) + with open(file_path, "r") as f: + try: + val = float(f.readline()) + except Exception: + continue + + # file name: runtime_[_...].txt + fname = os.path.basename(file_path) + parts = fname.split("_") + if len(parts) < 2: + continue + ref = parts[1].split(".")[0] # e.g. 'exploratory', 'Stats', 'LR' + + if "preprocessing" in ref: + dict_obj["preprocessing"] = dict_obj.get("preprocessing", 0.0) + val + else: + dict_obj[ref] = dict_obj.get(ref, 0.0) + val + + with open(self.full_path + "/runtimes.csv", mode="w", newline="") as file: + writer = csv.writer( + file, delimiter=",", quotechar='"', quoting=csv.QUOTE_MINIMAL + ) + writer.writerow(["Pipeline Component", "Phase", "Time (sec)"]) + + # Phase 1 & 2 names are kept for backward compatibility + if "exploratory" in dict_obj: + writer.writerow(["Exploratory Analysis", 1, dict_obj["exploratory"]]) + writer.writerow(["Scale and Impute", 2, dict_obj.get("preprocessing", 0.0)]) + + if "mutual" in dict_obj: + writer.writerow(["Mutual Information (Feature Importance)", 3, dict_obj["mutual"]]) + if "multisurf" in dict_obj: + writer.writerow(["MultiSURF (Feature Importance)", 3, dict_obj["multisurf"]]) + + if "featureselection" in dict_obj: + writer.writerow(["Feature Selection", 4, dict_obj["featureselection"]]) + + # Any other keys that match algorithm small_names => Phase 6 Modeling + for alg in self.algorithms: + if alg in dict_obj: + writer.writerow( + [f"{alg} (Modeling)", 6, dict_obj[alg]] + ) + + # Stats phase itself + if "Stats" in dict_obj: + writer.writerow(["Stats Summary", 8, dict_obj["Stats"]]) + + def save_runtime(self): + """ + Save phase runtime + """ + os.makedirs(self.full_path + '/runtime/' , exist_ok=True) + runtime_file = open( + self.full_path + "/runtime/runtime_Stats.txt", "w" + ) + runtime_file.write(str(time.time() - self.job_start_time)) + runtime_file.close() diff --git a/streamline/p8_summary_statistics/utils/fi_core.py b/streamline/p8_summary_statistics/utils/fi_core.py new file mode 100644 index 00000000..31562c56 --- /dev/null +++ b/streamline/p8_summary_statistics/utils/fi_core.py @@ -0,0 +1,288 @@ +from __future__ import annotations + +from statistics import mean, median +from typing import Dict, List, Tuple + +import numpy as np +import pandas as pd + + +def prep_fi( + full_path: str, + algorithms: List[str], + abbrev: Dict[str, str], + metric_dict: Dict[str, Dict[str, List[float]]], + metric_ranking: str, + metric_weighting: str, + metric_weight_name: str, +) -> Tuple[ + List[pd.DataFrame], + List[List[float]], + List[List[float]], + List[float], + List[str], + List[str], + List[int], +]: + """ + Load and organize feature-importance data from per-algorithm FI CSVs. + + Parameters + ---------- + full_path + Dataset root (//). + algorithms + List of algorithm display names (StatisticsPhaseJob.algorithms). + abbrev + Map from algorithm display name -> small_name / abbrev used in filenames. + metric_dict + Per-algorithm metric lists, as produced by primary_stats_*. + metric_ranking + 'mean' or 'median' - how to summarize FI across CVs. + metric_weighting + 'mean' or 'median' - how to summarize model performance for weighting FI. + metric_weight_name + Human-readable metric key in metric_dict to weight FI with + (e.g. 'Balanced Accuracy', 'Explained Variance'). + + Returns + ------- + fi_df_list + List of DataFrames (one per algorithm) with FI per CV. + fi_med_list + List of per-algorithm lists of median/mean FI per feature. + fi_med_norm_list + Same, but normalized to [0, 1] within each algorithm. + med_metric_list + Per-algorithm scalar metric used for weighting FI. + all_feature_list + List of feature names as they appear in FI CSV columns. + non_zero_union_features + Features that have non-zero FI in at least one algorithm. + non_zero_union_indexes + Indexes in all_feature_list for non_zero_union_features. + """ + # algorithm feature importance dataframe list (used to generate FI boxplot for each algorithm) + fi_df_list: List[pd.DataFrame] = [] + # algorithm feature importance medians list (used to generate composite FI barplots) + fi_med_list: List[List[float]] = [] + # algorithm focus metric medians list (used in weighted FI viz) + med_metric_list: List[float] = [] + # list of feature names as they appear in FI reports + all_feature_list: List[str] = [] + + # --- Load FI CSVs and compute per-feature medians/means --- + for idx, algorithm in enumerate(algorithms): + fi_path = ( + f"{full_path}/model_evaluation/feature_importance/" + f"{abbrev[algorithm]}_FI.csv" + ) + temp_df = pd.read_csv(fi_path) # CV FI scores for all original features + if idx == 0: + all_feature_list = temp_df.columns.tolist() + + fi_df_list.append(temp_df) + + if metric_ranking == "mean": + fi_med_list.append(temp_df.mean().tolist()) + elif metric_ranking == "median": + fi_med_list.append(temp_df.median().tolist()) + else: + raise ValueError("metric_ranking must be 'mean' or 'median'") + + # Get relevant performance metric info (for weighting) + metric_vals = metric_dict[algorithm][metric_weight_name] + if metric_weighting == "mean": + med_ba = mean(metric_vals) + elif metric_weighting == "median": + med_ba = median(metric_vals) + else: + raise ValueError("metric_weighting must be 'mean' or 'median'") + med_metric_list.append(med_ba) + + # --- Normalize FI (within each algorithm) --- + fi_med_norm_list: List[List[float]] = [] + for each in fi_med_list: # each algorithm + norm_list: List[float] = [] + max_val = max(each) if each else 0.0 + for val in each: + if val <= 0 or max_val <= 0: + norm_list.append(0.0) + else: + norm_list.append(val / max_val) + fi_med_norm_list.append(norm_list) + + # --- Identify union of non-zero features across algorithms --- + alg_non_zero_fi_list: List[List[str]] = [] + for each in fi_med_list: # each algorithm + temp_non_zero_list: List[str] = [] + for i, val in enumerate(each): + if val > 0.0: + temp_non_zero_list.append(all_feature_list[i]) + alg_non_zero_fi_list.append(temp_non_zero_list) + + if alg_non_zero_fi_list: + non_zero_union_features = list(alg_non_zero_fi_list[0]) + for j in range(1, len(algorithms)): + non_zero_union_features = list( + set(non_zero_union_features) | set(alg_non_zero_fi_list[j]) + ) + else: + non_zero_union_features = [] + + non_zero_union_indexes: List[int] = [ + all_feature_list.index(f) for f in non_zero_union_features + ] + + return ( + fi_df_list, + fi_med_list, + fi_med_norm_list, + med_metric_list, + all_feature_list, + non_zero_union_features, + non_zero_union_indexes, + ) + + +def select_for_composite_viz( + non_zero_union_features: List[str], + non_zero_union_indexes: List[int], + ave_metric_list: List[float], + fi_ave_norm_list: List[List[float]], + algorithms: List[str], + top_features: int, +) -> List[str]: + """ + Determine which features to visualize in composite FI plots. + + Score for feature f is: + sum_over_algorithms( normalized_FI[alg, f] * performance_weight[alg] ) + + If there are fewer than `top_features` features, all non-zero features are used. + """ + score_sum_dict: Dict[str, float] = {} + for i, feat_name in enumerate(non_zero_union_features): + idx = non_zero_union_indexes[i] + for j in range(len(algorithms)): + score = fi_ave_norm_list[j][idx] + weight = ave_metric_list[j] + score *= weight + if feat_name not in score_sum_dict: + score_sum_dict[feat_name] = score + else: + score_sum_dict[feat_name] += score + + # Sort by decreasing score + score_sum_dict_features = sorted( + score_sum_dict, key=lambda x: score_sum_dict[x], reverse=True + ) + if len(non_zero_union_features) > top_features: + features_to_viz = score_sum_dict_features[:top_features] + else: + features_to_viz = score_sum_dict_features + + return features_to_viz + + +def get_fi_to_viz_sorted( + features_to_viz: List[str], + all_feature_list: List[str], + fi_med_norm_list: List[List[float]], + algorithms: List[str], +) -> Tuple[List[List[float]], List[str]]: + """ + Given selected feature names, pull their normalized FI values in the same + order for all algorithms, ready for stacked-bar plotting. + """ + # Indexes of selected features in the full list + feature_index_to_viz: List[int] = [ + all_feature_list.index(f) for f in features_to_viz + ] + + # Build list-of-lists: per-algorithm FI values for the selected features + top_fi_med_norm_list: List[List[float]] = [] + for i in range(len(algorithms)): + temp_list: List[float] = [] + for j in feature_index_to_viz: + temp_list.append(fi_med_norm_list[i][j]) + top_fi_med_norm_list.append(temp_list) + + all_feature_list_to_viz = features_to_viz + return top_fi_med_norm_list, all_feature_list_to_viz + + +def frac_fi(top_fi_med_norm_list: List[List[float]]) -> List[List[float]]: + """ + Fractionate FI scores so that they sum to 1 over all features for a given algorithm. + Useful if you want to equalize 'total bar area' per algorithm. + """ + frac_lists: List[List[float]] = [] + for each in top_fi_med_norm_list: # each algorithm + total = sum(each) + if total == 0: + frac_lists.append([0.0 for _ in each]) + else: + frac_lists.append([val / total for val in each]) + return frac_lists + + +def weight_fi( + med_metric_list: List[float], + top_fi_med_norm_list: List[List[float]], + weight_mode: str = "balanced_accuracy", +) -> Tuple[List[List[float]], List[float]]: + """ + Weight normalized FI scores by algorithm performance. + + Supported modes: + - balanced_accuracy: any metric <= 0.5 is treated as 0; remaining values + are linearly scaled from [0.5, 1] -> [0, 1]. + - explained_variance: any metric <= 0 is treated as 0; positive values are + used directly and clipped to [0, 1]. + """ + # Prepare weights + metrics = list(med_metric_list) # copy so we don't mutate caller's list + weights: List[float] = [] + + if weight_mode == "explained_variance": + for v in metrics: + if v <= 0.0: + weights.append(0.0) + elif v >= 1.0: + weights.append(1.0) + else: + weights.append(v) + else: + # Legacy/default behavior for balanced_accuracy-style weighting. + for i, v in enumerate(metrics): + if v <= 0.5: + metrics[i] = 0.0 + + for v in metrics: + if v == 0: + weights.append(0.0) + else: + weights.append((v - 0.5) / 0.5) + + # Weight normalized FI + weighted_lists: List[List[float]] = [] + for i, fi_vals in enumerate(top_fi_med_norm_list): + w = weights[i] if i < len(weights) else 0.0 + weighted_lists.append(np.multiply(w, fi_vals).tolist()) + + return weighted_lists, weights + + +def weight_frac_fi( + frac_lists: List[List[float]], + weights: List[float], +) -> List[List[float]]: + """ + Weight normalized and fractionated feature importances by performance weights. + """ + weighted_frac_lists: List[List[float]] = [] + for i, frac_vals in enumerate(frac_lists): + w = weights[i] if i < len(weights) else 0.0 + weighted_frac_lists.append(np.multiply(w, frac_vals).tolist()) + return weighted_frac_lists diff --git a/streamline/p8_summary_statistics/utils/plot_curves.py b/streamline/p8_summary_statistics/utils/plot_curves.py new file mode 100644 index 00000000..c3b5873e --- /dev/null +++ b/streamline/p8_summary_statistics/utils/plot_curves.py @@ -0,0 +1,523 @@ +from __future__ import annotations + +from pathlib import Path +from typing import Dict, Any, List + +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt + +import seaborn as sns + +sns.set_theme() + + +def positive_label(values: np.ndarray): + non_missing = pd.Series(values).dropna() + uniques = list(pd.unique(non_missing)) + if not uniques: + return 1 + for preferred in (1, "1", True): + for value in uniques: + if value == preferred or str(value) == str(preferred): + return value + try: + return sorted(uniques)[-1] + except Exception: + return uniques[-1] + + +def binary_prevalence(values: np.ndarray) -> float: + if len(values) == 0: + return float("nan") + positive = positive_label(values) + return float(np.mean([value == positive or str(value) == str(positive) for value in values])) + + +def cv_test_outcomes( + full_path: str, + data_name: str, + outcome_label: str, + cv_partitions: int | None = None, + rep_data: pd.DataFrame | None = None, + replicate: bool = False, +) -> List[np.ndarray]: + if replicate and rep_data is not None and outcome_label in rep_data.columns: + return [rep_data[outcome_label].dropna().to_numpy()] + + cv_dir = Path(full_path) / "CVDatasets" + if cv_partitions is None: + paths = sorted(cv_dir.glob(f"{data_name}_CV_*_Test.csv")) + else: + paths = [ + cv_dir / f"{data_name}_CV_{cv_idx}_Test.csv" + for cv_idx in range(cv_partitions) + ] + + outcomes: List[np.ndarray] = [] + for path in paths: + if not path.exists(): + continue + try: + test = pd.read_csv(path) + except Exception: + continue + if outcome_label in test.columns: + outcomes.append(test[outcome_label].dropna().to_numpy()) + return outcomes + + +def class_count_labels(full_path: str) -> List[Any]: + path = Path(full_path) / "exploratory" / "ClassCounts.csv" + if not path.exists(): + return [] + try: + counts = pd.read_csv(path) + except Exception: + return [] + if counts.empty: + return [] + label_col = counts.columns[0] + return [value for value in counts[label_col].dropna().to_list() if str(value).strip() != ""] + + +def prc_no_skill_baseline( + full_path: str, + data_name: str, + outcome_label: str, + *, + cv_partitions: int | None = None, + outcome_type: str | None = None, + rep_data: pd.DataFrame | None = None, + replicate: bool = False, +) -> float: + fold_outcomes = cv_test_outcomes( + full_path=full_path, + data_name=data_name, + outcome_label=outcome_label, + cv_partitions=cv_partitions, + rep_data=rep_data, + replicate=replicate, + ) + if not fold_outcomes: + return 0.5 + + non_empty = [y for y in fold_outcomes if len(y) > 0] + if not non_empty: + return 0.5 + + combined = np.concatenate(non_empty) + if combined.size == 0: + return 0.5 + + unique_classes = pd.unique(pd.Series(combined).dropna()) + is_multiclass = "multiclass" in str(outcome_type or "").strip().lower() + if is_multiclass or len(unique_classes) > 2: + class_count = max(len(unique_classes), len(class_count_labels(full_path)), 1) + return float(1.0 / class_count) + + fold_rates = [ + binary_prevalence(y) + for y in fold_outcomes + if len(y) > 0 + ] + fold_rates = [rate for rate in fold_rates if np.isfinite(rate)] + if not fold_rates: + return 0.5 + return float(np.mean(fold_rates)) + + +def plot_model_roc( + full_path: str, + algorithm: str, + abbrev: str, + color, + cv_partitions: int, + mean_fpr: np.ndarray, + tprs: List[np.ndarray], + aucs: List[float], + alg_result_table: List[List[Any]], + show_plots: bool = False, +): + """ + Per-algorithm ROC plot across CV folds. + """ + # Define values for the mean ROC line (mean of individual CVs) + mean_tpr = np.mean(tprs, axis=0) + mean_tpr[-1] = 1.0 + mean_auc = np.mean(aucs) + + plt.rcParams["figure.figsize"] = (6, 6) + + for i, row in enumerate(alg_result_table): + plt.plot( + row[0], + row[1], + lw=1, + alpha=0.3, + label="ROC fold %d (AUC = %0.3f)" % (i, row[2]), + ) + + # No-skill line + plt.plot( + [0, 1], + [0, 1], + linestyle="--", + lw=2, + color="black", + label="No-Skill (AUROC = 0.500)", + alpha=0.8, + ) + + # Mean ROC + std_auc = np.std(aucs) + plt.plot( + mean_fpr, + mean_tpr, + color=color, + label=r"Mean ROC (AUC = %0.3f $\pm$ %0.3f)" % (float(mean_auc), float(std_auc)), + lw=2, + alpha=0.8, + ) + + std_tpr = np.std(tprs, axis=0) + tprs_upper = np.minimum(mean_tpr + std_tpr, 1) + tprs_lower = np.maximum(mean_tpr - std_tpr, 0) + plt.fill_between(mean_fpr, tprs_lower, tprs_upper, color="grey", alpha=0.2, label=r"$\pm$ 1 std. dev.") + + plt.xlim([-0.05, 1.05]) + plt.ylim([-0.05, 1.05]) + plt.xlabel("False Positive Rate") + plt.ylabel("True Positive Rate") + plt.title(algorithm) + plt.legend(loc="upper left", bbox_to_anchor=(1.01, 1)) + + out = Path(full_path) / "model_evaluation" / f"{abbrev}_ROC.png" + plt.savefig(out.as_posix(), bbox_inches="tight") + if show_plots: + plt.show() + else: + plt.close("all") + + +def plot_model_prc( + full_path: str, + algorithm: str, + abbrev: str, + color, + cv_partitions: int, + mean_recall: np.ndarray, + precs: List[np.ndarray], + praucs: List[float], + alg_result_table: List[List[Any]], + outcome_label: str, + data_name: str, + instance_label: str | None = None, + rep_data: pd.DataFrame | None = None, + replicate: bool = False, + outcome_type: str | None = None, + show_plots: bool = False, +): + """ + Per-algorithm PRC plot across CV folds. + """ + mean_prec = np.mean(precs, axis=0) + mean_pr_auc = np.mean(praucs) + + plt.rcParams["figure.figsize"] = (6, 6) + + for i, row in enumerate(alg_result_table): + plt.plot( + row[4], + row[3], + lw=1, + alpha=0.3, + label="PRC fold %d (AUC = %0.3f)" % (i, row[5]), + ) + + no_skill = prc_no_skill_baseline( + full_path=full_path, + data_name=data_name, + outcome_label=outcome_label, + cv_partitions=cv_partitions, + outcome_type=outcome_type, + rep_data=rep_data, + replicate=replicate, + ) + plt.plot( + [0, 1], + [no_skill, no_skill], + color="black", + linestyle="--", + label=f"No-Skill (AUPRC = {float(no_skill):0.3f})", + alpha=0.8, + ) + + std_pr_auc = np.std(praucs) + plt.plot( + mean_recall, + mean_prec, + color=color, + label=r"Mean PRC (AUC = %0.3f $\pm$ %0.3f)" % (float(mean_pr_auc), float(std_pr_auc)), + lw=2, + alpha=0.8, + ) + + std_prec = np.std(precs, axis=0) + precs_upper = np.minimum(mean_prec + std_prec, 1) + precs_lower = np.maximum(mean_prec - std_prec, 0) + plt.fill_between( + mean_recall, + precs_lower, + precs_upper, + color="grey", + alpha=0.2, + label=r"$\pm$ 1 std. dev.", + ) + + plt.xlim([-0.05, 1.05]) + plt.ylim([-0.05, 1.05]) + plt.xlabel("Recall (Sensitivity)") + plt.ylabel("Precision (PPV)") + plt.title(algorithm) + plt.legend(loc="upper left", bbox_to_anchor=(1.01, 1)) + + out = Path(full_path) / "model_evaluation" / f"{abbrev}_PRC.png" + plt.savefig(out.as_posix(), bbox_inches="tight") + if show_plots: + plt.show() + else: + plt.close("all") + + +def plot_summary_roc( + full_path: str, + colors: Dict[str, Any], + result_table: pd.DataFrame, + show_plots: bool = False, +): + """ + Summary ROC over algorithms (already averaged across CVs). + """ + for alg in result_table.index: + plt.plot( + result_table.loc[alg]["fpr"], + result_table.loc[alg]["tpr"], + color=colors[alg], + label="{}, AUC={:.3f}".format(alg, result_table.loc[alg]["auc"]), + ) + + plt.rcParams["figure.figsize"] = (6, 6) + plt.plot( + [0, 1], + [0, 1], + color="black", + linestyle="--", + label="No-Skill (AUROC = 0.500)", + alpha=0.8, + ) + plt.xticks(np.arange(0.0, 1.1, step=0.1)) + plt.xlabel("False Positive Rate", fontsize=15) + plt.yticks(np.arange(0.0, 1.1, step=0.1)) + plt.ylabel("True Positive Rate", fontsize=15) + plt.legend(loc="upper left", bbox_to_anchor=(1.01, 1)) + + out = Path(full_path) / "model_evaluation" / "Summary_ROC.png" + plt.savefig(out.as_posix(), bbox_inches="tight") + if show_plots: + plt.show() + else: + plt.close("all") + + +def plot_summary_prc( + full_path: str, + colors: Dict[str, Any], + result_table: pd.DataFrame, + outcome_label: str, + data_name: str, + instance_label: str | None = None, + rep_data: pd.DataFrame | None = None, + replicate: bool = False, + outcome_type: str | None = None, + cv_partitions: int | None = None, + show_plots: bool = False, +): + """ + Summary PRC over algorithms (already averaged across CVs). + """ + for alg in result_table.index: + plt.plot( + result_table.loc[alg]["recall"], + result_table.loc[alg]["prec"], + color=colors[alg], + label="{}, AUC={:.3f}, APS={:.3f}".format( + alg, result_table.loc[alg]["pr_auc"], result_table.loc[alg]["ave_prec"] + ), + ) + + no_skill = prc_no_skill_baseline( + full_path=full_path, + data_name=data_name, + outcome_label=outcome_label, + cv_partitions=cv_partitions, + outcome_type=outcome_type, + rep_data=rep_data, + replicate=replicate, + ) + plt.plot( + [0, 1], + [no_skill, no_skill], + color="black", + linestyle="--", + label=f"No-Skill (AUPRC = {float(no_skill):0.3f})", + alpha=0.8, + ) + + plt.xticks(np.arange(0.0, 1.1, step=0.1)) + plt.xlabel("Recall (Sensitivity)", fontsize=15) + plt.yticks(np.arange(0.0, 1.1, step=0.1)) + plt.ylabel("Precision (PPV)", fontsize=15) + plt.legend(loc="upper left", bbox_to_anchor=(1.01, 1)) + + out = Path(full_path) / "model_evaluation" / "Summary_PRC.png" + plt.savefig(out.as_posix(), bbox_inches="tight") + if show_plots: + plt.show() + else: + plt.close("all") + + +def plot_metric_boxplots( + full_path: str, + algorithms: List[str], + metrics: List[str], + metric_dict: Dict[str, Dict[str, List[float]]], + show_plots: bool = False, +): + """ + Export boxplots comparing algorithm performance for each metric. + """ + out_dir = Path(full_path) / "model_evaluation" / "metricBoxplots" + out_dir.mkdir(parents=True, exist_ok=True) + + for metric in metrics: + temp_list = [] + for alg in algorithms: + temp_list.append(metric_dict[alg][metric]) + + td = pd.DataFrame(temp_list).transpose().astype("float") + td.columns = algorithms + + ax = td.plot(kind="box", rot=90) + ax.set_ylabel(str(metric)) + ax.set_xlabel("ML Algorithm") + + out = out_dir / f"Compare_{metric}.png" + plt.savefig(out.as_posix(), bbox_inches="tight") + if show_plots: + plt.show() + else: + plt.close("all") + + +def plot_ensemble_roc_summary( + ens_root: Path, + roc_summary: Dict[str, Dict[str, Any]], + show_plots: bool = False, +): + if not roc_summary: + return + + plt.figure(figsize=(6, 6)) + color_cycle = plt.rcParams["axes.prop_cycle"].by_key()["color"] + + for idx, ens_id in enumerate(sorted(roc_summary.keys())): + c = color_cycle[idx % len(color_cycle)] + d = roc_summary[ens_id] + plt.plot( + d["fpr"], + d["tpr"], + color=c, + label=f"{ens_id}, AUC={d['auc']:.3f}", + ) + + plt.plot( + [0, 1], + [0, 1], + color="black", + linestyle="--", + label="No-Skill (AUROC = 0.500)", + alpha=0.8, + ) + plt.xticks(np.arange(0.0, 1.1, step=0.1)) + plt.yticks(np.arange(0.0, 1.1, step=0.1)) + plt.xlabel("False Positive Rate", fontsize=15) + plt.ylabel("True Positive Rate", fontsize=15) + plt.legend(loc="lower right", fontsize=8) + plt.title("Ensemble ROC Summary") + + out_path = ens_root / "Summary_ROC_ensembles.png" + plt.savefig(out_path.as_posix(), bbox_inches="tight") + if show_plots: + plt.show() + else: + plt.close("all") + + +def plot_ensemble_prc_summary( + ens_root: Path, + prc_summary: Dict[str, Dict[str, Any]], + full_path: str, + data_name: str, + outcome_label: str, + instance_label: str | None = None, + outcome_type: str | None = None, + cv_partitions: int | None = None, + show_plots: bool = False, +): + if not prc_summary: + return + + no_skill = prc_no_skill_baseline( + full_path=full_path, + data_name=data_name, + outcome_label=outcome_label, + cv_partitions=cv_partitions, + outcome_type=outcome_type, + ) + + plt.figure(figsize=(6, 6)) + color_cycle = plt.rcParams["axes.prop_cycle"].by_key()["color"] + + for idx, ens_id in enumerate(sorted(prc_summary.keys())): + c = color_cycle[idx % len(color_cycle)] + d = prc_summary[ens_id] + plt.plot( + d["recall"], + d["precision"], + color=c, + label=f"{ens_id}, AUC={d['pr_auc']:.3f}, APS={d['aps']:.3f}", + ) + + plt.plot( + [0, 1], + [no_skill, no_skill], + color="black", + linestyle="--", + label=f"No-Skill (AUPRC = {float(no_skill):0.3f})", + alpha=0.8, + ) + plt.xticks(np.arange(0.0, 1.1, step=0.1)) + plt.yticks(np.arange(0.0, 1.1, step=0.1)) + plt.xlabel("Recall (Sensitivity)", fontsize=15) + plt.ylabel("Precision (PPV)", fontsize=15) + plt.legend(loc="lower left", fontsize=8) + plt.title("Ensemble PRC Summary") + + out_path = ens_root / "Summary_PRC_ensembles.png" + plt.savefig(out_path.as_posix(), bbox_inches="tight") + if show_plots: + plt.show() + else: + plt.close("all") diff --git a/streamline/p8_summary_statistics/utils/plot_fi.py b/streamline/p8_summary_statistics/utils/plot_fi.py new file mode 100644 index 00000000..c82fb070 --- /dev/null +++ b/streamline/p8_summary_statistics/utils/plot_fi.py @@ -0,0 +1,178 @@ +from __future__ import annotations + +from pathlib import Path +from typing import List, Dict, Any + +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +from matplotlib import rc + +import seaborn as sns + +sns.set_theme() + + +def plot_fi_boxplots( + full_path: str, + algorithms: List[str], + feature_headers: List[str], + fi_df_list: List[pd.DataFrame], + fi_med_list: List[List[float]], + metric_ranking: str = "median", + show_plots: bool = False, +): + """ + Boxplots of feature importance per algorithm. + """ + out_dir = Path(full_path) / "model_evaluation" / "feature_importance" + out_dir.mkdir(parents=True, exist_ok=True) + + for alg_idx, algorithm in enumerate(algorithms): + score_dict = {} + for idx, med_score in enumerate(fi_med_list[alg_idx]): + score_dict[feature_headers[idx]] = med_score + + score_dict_features = sorted(score_dict, key=lambda x: score_dict[x], reverse=True) + if len(feature_headers) > 0: + top_n = min(len(score_dict_features), len(feature_headers)) + else: + top_n = len(score_dict_features) + features_to_viz = score_dict_features[:top_n] + + df = fi_df_list[alg_idx] + viz_df = df[features_to_viz] + + plt.figure(figsize=(15, 4)) + viz_df.boxplot(rot=90) + plt.title(algorithm) + plt.ylabel("Feature Importance") + if metric_ranking == "mean": + plt.xlabel("Features (Mean Ranking)") + elif metric_ranking == "median": + plt.xlabel("Features (Median Ranking)") + else: + plt.xlabel("Features") + + plt.xticks(np.arange(1, len(features_to_viz) + 1), features_to_viz, rotation="vertical") + out = out_dir / f"{algorithm}_boxplot.png" + plt.savefig(out.as_posix(), bbox_inches="tight") + if show_plots: + plt.show() + else: + plt.close("all") + + +def plot_fi_histogram( + full_path: str, + algorithms: List[str], + fi_med_list: List[List[float]], + metric_ranking: str = "median", + show_plots: bool = False, +): + """ + Histogram of median/mean FI scores per algorithm. + """ + out_dir = Path(full_path) / "model_evaluation" / "feature_importance" + out_dir.mkdir(parents=True, exist_ok=True) + + for alg_idx, algorithm in enumerate(algorithms): + med_scores = fi_med_list[alg_idx] + plt.hist(med_scores, bins=100) + if metric_ranking == "mean": + plt.xlabel("Mean Feature Importance") + elif metric_ranking == "median": + plt.xlabel("Median Feature Importance") + else: + plt.xlabel("Feature Importance") + plt.ylabel("Frequency") + plt.title(str(algorithm)) + plt.xticks(rotation="vertical") + out = out_dir / f"{algorithm}_histogram.png" + plt.savefig(out.as_posix(), bbox_inches="tight") + if show_plots: + plt.show() + else: + plt.close("all") + + +def plot_composite_fi( + full_path: str, + algorithms: List[str], + colors: Dict[str, Any], + fi_list: List[List[float]], + all_feature_list_to_viz: List[str], + fig_name: str, + y_label_text: str, + metric_ranking: str, + metric_weighting: str, + metric_weight_label: str, + show_plots: bool = False, +): + """ + Composite stacked-bar FI plot across algorithms. + """ + # sort algorithms + lists together to keep consistent ordering + alg_colors = [colors[k] for k in algorithms] + algorithms, alg_colors, fi_list = (list(t) for t in zip(*sorted( + zip(algorithms, alg_colors, fi_list), + reverse=True, + ))) + + rc("font", weight="bold", size=16) + + r = all_feature_list_to_viz + bar_width = 0.75 + plt.figure(figsize=(24, 12)) + + # base bar + p1 = plt.bar(r, fi_list[0], color=alg_colors[0], edgecolor="white", width=bar_width) + + bottoms = [] + bottom = None + for i in range(len(algorithms) - 1): + for j in range(i + 1): + if j == 0: + bottom = np.array(fi_list[0]).astype("float64") + else: + bottom += np.array(fi_list[j]).astype("float64") + bottoms.append(bottom) + if not isinstance(bottoms, list): + bottoms = bottoms.tolist() + + if len(algorithms) > 1: + ps = [p1[0]] + for i in range(len(algorithms) - 1): + p = plt.bar( + r, + fi_list[i + 1], + bottom=bottoms[i], + color=alg_colors[i + 1], + edgecolor="white", + width=bar_width, + ) + ps.append(p[0]) + lines = tuple(ps) + else: + lines = (p1[0],) + + plt.xticks(np.arange(len(all_feature_list_to_viz)), all_feature_list_to_viz, rotation="vertical") + plt.xlabel( + "Features (ranked by sum of " + + metric_ranking + + " feature importance: weighted by " + + metric_weighting + + " model " + + metric_weight_label.lower() + + ")", + fontsize=20, + ) + plt.ylabel(y_label_text, fontsize=20) + plt.legend(lines[::-1], algorithms[::-1], loc="upper left", bbox_to_anchor=(1.01, 1)) + + out = Path(full_path) / "model_evaluation" / "feature_importance" / f"Compare_FI_{fig_name}.png" + plt.savefig(out.as_posix(), bbox_inches="tight") + if show_plots: + plt.show() + else: + plt.close("all") diff --git a/streamline/p8_summary_statistics/utils/plot_regression.py b/streamline/p8_summary_statistics/utils/plot_regression.py new file mode 100644 index 00000000..986dfa7a --- /dev/null +++ b/streamline/p8_summary_statistics/utils/plot_regression.py @@ -0,0 +1,230 @@ +from __future__ import annotations + +import os +from typing import Dict, List, Tuple + +import pickle +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import seaborn as sns +from scipy import stats + +sns.set_theme() + + +def residuals_regression( + full_path: str, + algorithms: List[str], + abbrev: Dict[str, str], + cv_partitions: int, + colors: Dict[str, Tuple[float, float, float]], + show_plots: bool = False, +) -> None: + """ + Generate residual-related regression plots across all algorithms. + + This is factored out from StatisticsPhaseJob.residuals_regression and + kept IO-compatible: it still reads residual pickles and writes + PNGs under /model_evaluation/evalPlots. + """ + + s_res_tests: List[np.ndarray] = [] # testing residual + s_y_test_preds: List[np.ndarray] = [] # testing prediction + s_y_tests: List[np.ndarray] = [] # testing label + m_tests: List[float] = [] # slope of testing fit line + b_tests: List[float] = [] # intercept of testing fit line + valid_algorithms: List[str] = [] + + eval_plots_dir = os.path.join(full_path, "model_evaluation", "evalPlots") + os.makedirs(eval_plots_dir, exist_ok=True) + + for algorithm in algorithms: + res_test_parts: List[np.ndarray] = [] + y_test_pred_parts: List[np.ndarray] = [] + y_test_parts: List[np.ndarray] = [] + + for cv_count in range(cv_partitions): + cv_result_file = f"{full_path}/model_evaluation/pickled_metrics/" \ + f"{abbrev[algorithm]}_CV_{cv_count}_residuals.pickle" + with open(cv_result_file, "rb") as f: + results = pickle.load(f) + + # Regression residual pickle payload order: + # 0 train residual, 1 test residual, 2 train pred, 3 test pred, 4 train y, 5 test y + res_test = np.asarray(results[1], dtype=float).ravel() + y_test_pred = np.asarray(results[3], dtype=float).ravel() + y_test = np.asarray(results[5], dtype=float).ravel() + + if res_test.size == 0 or y_test_pred.size == 0 or y_test.size == 0: + continue + res_test_parts.append(res_test) + y_test_pred_parts.append(y_test_pred) + y_test_parts.append(y_test) + + if not res_test_parts: + continue + + s_res_test = np.concatenate(res_test_parts) + s_y_test_pred = np.concatenate(y_test_pred_parts) + s_y_test = np.concatenate(y_test_parts) + + finite_mask = ( + np.isfinite(s_res_test) + & np.isfinite(s_y_test_pred) + & np.isfinite(s_y_test) + ) + s_res_test = s_res_test[finite_mask] + s_y_test_pred = s_y_test_pred[finite_mask] + s_y_test = s_y_test[finite_mask] + + if s_res_test.size < 2: + continue + + if np.unique(s_y_test_pred).size > 1: + m_test, b_test = np.polyfit(s_y_test_pred, s_y_test, 1) + else: + m_test, b_test = 0.0, float(np.nanmean(s_y_test)) + + valid_algorithms.append(algorithm) + s_res_tests.append(s_res_test) + s_y_test_preds.append(s_y_test_pred) + s_y_tests.append(s_y_test) + m_tests.append(float(m_test)) + b_tests.append(float(b_test)) + + if not valid_algorithms: + return + + # Build testing residual dataframe + test_df_parts = [] + for i, alg in enumerate(valid_algorithms): + test_df_parts.append( + pd.DataFrame( + { + "Residual": s_res_tests[i], + "Algorithm": alg, + "Type": "Testing", + } + ) + ) + test_df = pd.concat(test_df_parts, ignore_index=True) + test_df["Residual"] = pd.to_numeric(test_df["Residual"], errors="raise") + # test_df = test_df[np.isfinite(test_df["Residual"])].reset_index(drop=True) + + # Keep only testing outputs for regression evaluation artifacts. + test_df.to_csv( + os.path.join(full_path, "model_evaluation", "residual_test.csv"), + index=False, + ) + stale_train_csv = os.path.join(full_path, "model_evaluation", "residual_train.csv") + if os.path.exists(stale_train_csv): + os.remove(stale_train_csv) + stale_train_prob_plot = os.path.join( + eval_plots_dir, "probability_train_residual_all_algorithms.png" + ) + if os.path.exists(stale_train_prob_plot): + os.remove(stale_train_prob_plot) + + # --- Fig 1: test residual vs predicted + test violin distribution --- + fig_1, axes_1 = plt.subplots(1, 2, figsize=[20, 8]) + for i, alg in enumerate(valid_algorithms): + axes_1[0].scatter( + s_y_test_preds[i], + s_res_tests[i], + alpha=0.35, + c=colors[alg], + label=alg, + s=16, + ) + axes_1[0].axhline(y=0, color="black", linestyle="-") + axes_1[0].set_title("Residual vs Predicted Outcome (Testing)") + axes_1[0].set_ylabel("Residual") + axes_1[0].set_xlabel("Predicted Outcome") + + sns.violinplot( + x="Algorithm", + y="Residual", + data=test_df, + order=valid_algorithms, + color="r", + ax=axes_1[1], + inner="quartile", + cut=0, + bw_adjust=0.8, + linewidth=1.0, + ) + axes_1[1].axhline(y=0, color="black", linestyle="-") + axes_1[1].set_title("Residual Distribution (Testing)") + axes_1[1].set_xlabel("Algorithm") + axes_1[1].set_ylabel("Residual") + + fig_1.legend(loc="upper right") + fig_1.tight_layout(rect=[0, 0, 0.95, 1]) + fig_1.savefig( + os.path.join(eval_plots_dir, "residual_distrib_all_algorithms.png") + ) + if show_plots: + plt.show() + else: + plt.close(fig_1) + + # --- Fig 2: test actual vs predicted with fitted lines --- + fig_2, ax2 = plt.subplots(1, 1, figsize=[12, 10]) + for i, alg in enumerate(valid_algorithms): + ax2.scatter( + s_y_test_preds[i], + s_y_tests[i], + alpha=0.3, + c=colors[alg], + s=16, + ) + x_sorted = np.sort(s_y_test_preds[i]) + ax2.plot( + x_sorted, + m_tests[i] * x_sorted + b_tests[i], + color=colors[alg], + label=alg, + ) + ax2.set_title("Actual Outcome vs. Predicted Outcome (Test)") + ax2.set_ylabel("Actual Outcome") + ax2.set_xlabel("Predicted Outcome") + fig_2.legend(loc="upper right") + fig_2.tight_layout() + fig_2.savefig( + os.path.join(eval_plots_dir, "actual_vs_predict_all_algorithms.png") + ) + if show_plots: + plt.show() + else: + plt.close(fig_2) + + # --- Fig 3: probability plot of test residuals --- + fig_3, ax3 = plt.subplots(1, 1, figsize=(10, 10)) + for i, alg in enumerate(valid_algorithms): + qq_x, qq_y = stats.probplot( + s_res_tests[i], + dist=stats.norm, + sparams=(2, 3), + fit=False, + ) + ax3.scatter( + qq_x, + qq_y, + alpha=0.5, + c=[colors[alg]], + s=16, + label=alg, + ) + ax3.set_title("Probability Plot of Testing Residual") + ax3.set_xlabel("Theoretical Quantiles") + ax3.set_ylabel("Ordered Residual") + ax3.legend(loc="upper right") + fig_3.tight_layout() + fig_3.savefig( + os.path.join(eval_plots_dir, "probability_test_residual_all_algorithms.png") + ) + if show_plots: + plt.show() + else: + plt.close(fig_3) diff --git a/streamline/p9_compare_datasets/__init__init.py b/streamline/p9_compare_datasets/__init__init.py new file mode 100644 index 00000000..e69de29b diff --git a/streamline/p9_compare_datasets/compare_datasets.py b/streamline/p9_compare_datasets/compare_datasets.py new file mode 100644 index 00000000..7f3f11b0 --- /dev/null +++ b/streamline/p9_compare_datasets/compare_datasets.py @@ -0,0 +1,827 @@ +# streamline/p9_compare_datasets/compare_datasets.py +from __future__ import annotations + +import os +import time +import logging +import json +from pathlib import Path +from typing import List, Dict, Tuple, Any, Optional + +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +from scipy.stats import kruskal, wilcoxon, mannwhitneyu + +import seaborn as sns + +from streamline.p6_modeling.utils.loader import list_models, get_model_by_id + +sns.set_theme() +logger = logging.getLogger(__name__) + + +class DatasetCompareJob: + """ + Phase 9: Dataset-level performance comparison across all datasets + in an experiment. + + Modernized CompareJob that: + * discovers base models from Phase 6 / 8 outputs + registry + * **optionally includes Phase 7 ensembles** if ensemble_evaluation + artifacts are present in the datasets. + """ + + def __init__( + self, + output_path: Optional[str] = None, + experiment_name: Optional[str] = None, + experiment_path: Optional[str] = None, + outcome_label: str = "Class", + outcome_type: str = "Binary", + instance_label: Optional[str] = None, + sig_cutoff: float = 0.05, + show_plots: bool = False, + ): + super().__init__() + assert (output_path is not None and experiment_name is not None) or ( + experiment_path is not None + ), "Either (output_path, experiment_name) or experiment_path must be provided." + + if experiment_path is None: + self.output_path = output_path + self.experiment_name = experiment_name + self.experiment_path = os.path.join(self.output_path, self.experiment_name) + else: + self.experiment_path = experiment_path + self.experiment_name = Path(self.experiment_path).name + self.output_path = str(Path(self.experiment_path).parent) + + self.outcome_label = outcome_label + self.outcome_type = outcome_type + self.instance_label = instance_label + self.sig_cutoff = sig_cutoff + self.show_plots = show_plots + + self.exp_root = os.path.join(self.output_path, self.experiment_name) + if not os.path.isdir(self.exp_root): + raise Exception("Experiment must exist before Phase 9 can begin") + + # Collect dataset dirs that have CVDatasets + datasets = [ + os.path.join(self.exp_root, name) + for name in sorted(os.listdir(self.exp_root)) + if os.path.isdir(os.path.join(self.exp_root, name)) + and name + not in { + "jobsCompleted", + "jobs", + "logs", + "dask_logs", + "runtime", + "DatasetComparisons", + } + and os.path.isdir(os.path.join(self.exp_root, name, "CVDatasets")) + ] + if not datasets: + logging.warning("No datasets found for Phase 9 under %s", self.exp_root) + return + + self.datasets: List[str] = [Path(d).name for d in datasets] + self.dataset_directory_paths: List[str] = datasets + + if not self.dataset_directory_paths: + raise RuntimeError( + f"No dataset folders found under experiment: {self.experiment_path}" + ) + + # Discover base models from Phase 6 metrics + ( + base_algorithms, + base_abbrev, + base_colors, + ) = self._discover_algorithms_from_metrics( + Path(self.dataset_directory_paths[0]), self.outcome_type + ) + + # Discover ensembles (if any) from Phase 7 artifacts + ( + ensemble_algorithms, + ensemble_abbrev, + ensemble_colors, + ) = self._discover_ensembles_from_metrics(Path(self.dataset_directory_paths[0])) + + self.base_algorithms: List[str] = sorted(base_algorithms) + self.ensemble_algorithms: List[str] = sorted(ensemble_algorithms) + + # merge base + ensembles into unified view + self.algorithms: List[str] = sorted(self.base_algorithms + self.ensemble_algorithms) + self.abbrev: Dict[str, str] = {} + self.abbrev.update(base_abbrev) + self.abbrev.update(ensemble_abbrev) + + self.colors: Dict[str, Any] = {} + self.colors.update(base_colors) + self.colors.update(ensemble_colors) + + self.metrics: Optional[List[str]] = None + + # ------------------------------------------------------------------ + # Algorithm discovery (base models, from model_evaluation/metrics_by_cv) + # ------------------------------------------------------------------ + def _discover_algorithms_from_metrics( + self, + dataset_dir: Path, + outcome_type: str, + ) -> Tuple[List[str], Dict[str, str], Dict[str, Any]]: + """ + Discover base modeling algorithms for dataset comparison from: + /model_evaluation/metrics_by_cv/_CV_.json + + Returns: + algorithms: list of model_name + abbrev: mapping model_name -> small_name (file prefix) + colors: mapping model_name -> color (named or RGB tuples) + """ + metrics_dir = dataset_dir / "model_evaluation" / "metrics_by_cv" + present_algs: List[str] = [] + + if metrics_dir.is_dir(): + for fn in os.listdir(metrics_dir): + if not fn.endswith(".json"): + continue + # Expect pattern "_CV_.json" + parts = fn.split("_CV_") + if len(parts) != 2: + continue + alg = parts[0] + if alg: + present_algs.append(alg) + + present_set = set(present_algs) + if not present_set: + logger.warning( + "DatasetComparePhaseJob: no base-model metrics found under %s", + metrics_dir, + ) + + algorithms: List[str] = [] + abbrev: Dict[str, str] = {} + colors: Dict[str, Any] = {} + + registry_entries: List[Dict[str, Any]] = [] + if list_models is not None: + try: + registry_entries = list_models(outcome_type) + except Exception as e: + logger.warning( + "DatasetComparePhaseJob: list_models(%s) failed: %r", + outcome_type, + e, + ) + + # small_name -> (model_type, entry) + by_small: Dict[str, Tuple[str, Dict[str, Any]]] = {} + for entry in registry_entries: + small = (entry.get("small_name") or "").strip() + mt = (entry.get("model_type") or "").strip() + if small: + by_small[small] = (mt, entry) + + for small in sorted(present_set): + mt, entry = by_small.get(small, ("", {})) + cls = None + if get_model_by_id is not None and mt: + # try by small_name first + try: + cls = get_model_by_id(mt, small) + except Exception: + model_name = entry.get("model_name") or entry.get("alt_id") or small + try: + cls = get_model_by_id(mt, model_name) + except Exception: + cls = None + + model_name = cls.model_name if cls is not None else small + algorithms.append(model_name) + abbrev[model_name] = cls.small_name if cls is not None else small + + if cls is not None and hasattr(cls, "color"): + colors[model_name] = cls.color + + # Fallback colors via seaborn palette + if algorithms: + palette = sns.color_palette("tab10", n_colors=len(algorithms)) + for i, alg in enumerate(algorithms): + colors.setdefault(alg, palette[i % len(algorithms)]) + else: + algorithms = sorted(present_set) + abbrev = {a: a for a in algorithms} + palette = sns.color_palette("tab10", n_colors=max(len(algorithms), 1)) + colors = {a: palette[i % len(algorithms)] for i, a in enumerate(algorithms)} + + return algorithms, abbrev, colors + + # ------------------------------------------------------------------ + # Ensemble discovery (from ensemble_evaluation/metrics_by_cv + summaries) + # ------------------------------------------------------------------ + def _discover_ensembles_from_metrics( + self, + dataset_dir: Path, + ) -> Tuple[List[str], Dict[str, str], Dict[str, Any]]: + """ + Discover ensembles for dataset comparison. + + Uses: + /ensemble_evaluation/metrics_by_cv/_CV_.json + + and additionally the summary tables: + /ensemble_evaluation/Ensembles_performance_mean.csv + /ensemble_evaluation/Ensembles_performance_median.csv + /ensemble_evaluation/Ensembles_performance_std.csv + + to detect presence and ensure metric names line up, but we rely on + metrics_by_cv for per-CV distributions. + """ + ens_root = dataset_dir / "ensemble_evaluation" + metrics_dir = ens_root / "metrics_by_cv" + + present_ens: List[str] = [] + + if metrics_dir.is_dir(): + for fn in os.listdir(metrics_dir): + if not fn.endswith(".json"): + continue + # Expect pattern "_CV_.json" + parts = fn.split("_CV_") + if len(parts) != 2: + continue + ens_id = parts[0] + if ens_id: + present_ens.append(ens_id) + + present_set = sorted(set(present_ens)) + if not present_set: + # No ensembles; this is fine. + return [], {}, {} + + algorithms: List[str] = [] + abbrev: Dict[str, str] = {} + colors: Dict[str, Any] = {} + + # For now, just use ensemble ID as both name and abbrev. + for ens_id in present_set: + algorithms.append(ens_id) + abbrev[ens_id] = ens_id + + # Colors: append to existing palette after base models + palette = sns.color_palette("tab10", n_colors=max(len(algorithms), 1)) + for i, ens in enumerate(algorithms): + colors[ens] = palette[i % len(algorithms)] + + return algorithms, abbrev, colors + + # ------------------------------------------------------------------ + # PUBLIC ENTRY + # ------------------------------------------------------------------ + def run(self): + self.job_start_time = time.time() + logger.info( + "Running dataset comparison (Phase 9) for experiment %s", + self.experiment_name, + ) + + # metrics from first dataset (Summary_performance_mean) + first_summary = ( + Path(self.dataset_directory_paths[0]) + / "model_evaluation" + / "Summary_performance_mean.csv" + ) + if not first_summary.is_file(): + raise RuntimeError( + f"Expected Summary_performance_mean.csv under {first_summary.parent}" + ) + data = pd.read_csv(first_summary, sep=",") + self.metrics = data.columns.values.tolist()[1:] + + # Create output directory + dc_dir = Path(self.experiment_path) / "DatasetComparisons" + dc_dir.mkdir(exist_ok=True) + + logger.info("Running Kruskal-Wallis across datasets...") + self.kruscall_wallis() + + logger.info("Running Mann-Whitney U across datasets...") + self.mann_whitney_u() + + logger.info("Running Wilcoxon rank-sum across datasets...") + self.wilcoxon_rank() + + logger.info("Running 'best algorithm per dataset' Kruskal-Wallis...") + global_data = self.best_kruscall_wallis() + + logger.info("Running 'best algorithm per dataset' Mann-Whitney...") + self.best_mann_whitney_u(global_data) + + logger.info("Running 'best algorithm per dataset' Wilcoxon rank...") + self.best_wilcoxon_rank(global_data) + + logger.info("Generating dataset comparison boxplots (all models)...") + self.data_compare_bp_all() + + logger.info("Generating dataset comparison boxplots (per algorithm)...") + self.data_compare_bp() + + self.save_runtime() + logger.info("Phase 9 dataset comparison complete.") + jobs_dir = Path(self.experiment_path) / "jobsCompleted" + jobs_dir.mkdir(exist_ok=True) + with open(jobs_dir / "job_compare_datasets.txt", "w") as f: + f.write("complete") + + # ------------------------------------------------------------------ + # Core comparison methods + # ------------------------------------------------------------------ + def kruscall_wallis(self): + label = ["Statistic", "P-Value", "Sig(*)"] + for i in range(1, len(self.datasets) + 1): + label.append(f"Median_D{i}") + label.append(f"Mean_D{i}") + label.append(f"Std_D{i}") + + dc_dir = Path(self.experiment_path) / "DatasetComparisons" + + for algorithm in self.algorithms: + kruskal_summary = pd.DataFrame(index=self.metrics, columns=label) + for metric in self.metrics: + temp_array = [] + med_list = [] + mean_list = [] + std_list = [] + + for dataset_path in self.dataset_directory_paths: + td = self._load_performance_df(dataset_path, algorithm) + if metric not in td.columns: + # If ensemble/base is missing this metric, skip this dataset for it. + continue + vals = td[metric].astype(float) + temp_array.append(vals) + med_list.append(vals.median()) + mean_list.append(vals.mean()) + std_list.append(vals.std()) + + if not temp_array: + # nothing to compare for this metric / algorithm + kruskal_summary.at[metric, "Statistic"] = "NA" + kruskal_summary.at[metric, "P-Value"] = "1.0" + kruskal_summary.at[metric, "Sig(*)"] = "" + continue + + try: + result = kruskal(*temp_array) + except Exception: + result = ["NA", 1.0] + + try: + kruskal_summary.at[metric, "Statistic"] = str(round(result[0], 6)) + except TypeError: + kruskal_summary.at[metric, "Statistic"] = "NA" + kruskal_summary.at[metric, "P-Value"] = str(round(result[1], 6)) + kruskal_summary.at[metric, "Sig(*)"] = ( + "*" if result[1] < self.sig_cutoff else "" + ) + + for j in range(len(med_list)): + kruskal_summary.at[metric, f"Median_D{j+1}"] = str( + round(med_list[j], 6) + ) + for j in range(len(mean_list)): + kruskal_summary.at[metric, f"Mean_D{j+1}"] = str( + round(mean_list[j], 6) + ) + for j in range(len(std_list)): + kruskal_summary.at[metric, f"Std_D{j+1}"] = str( + round(std_list[j], 6) + ) + + out = dc_dir / f"KruskalWallis_{self.abbrev[algorithm]}.csv" + kruskal_summary.to_csv(out) + + def wilcoxon_rank(self): + label = ["Metric", "Data1", "Data2", "Statistic", "P-Value", "Sig(*)"] + for i in range(1, 3): + label.append(f"Median_Data{i}") + label.append(f"Mean_Data{i}") + label.append(f"Std_Data{i}") + + master: List[List[Any]] = [] + for algorithm in self.algorithms: + master.extend(self.inter_set_fn(wilcoxon, algorithm)) + + df = pd.DataFrame(master, columns=label) + out = Path(self.experiment_path) / "DatasetComparisons" / "WilcoxonRank_all.csv" + df.to_csv(out, index=False) + + def mann_whitney_u(self): + label = ["Metric", "Data1", "Data2", "Statistic", "P-Value", "Sig(*)"] + for i in range(1, 3): + label.append(f"Median_Data{i}") + label.append(f"Mean_Data{i}") + label.append(f"Std_Data{i}") + + master: List[List[Any]] = [] + for algorithm in self.algorithms: + master.extend(self.inter_set_fn(mannwhitneyu, algorithm)) + + df = pd.DataFrame(master, columns=label) + out = Path(self.experiment_path) / "DatasetComparisons" / "MannWhitney_all.csv" + df.to_csv(out, index=False) + + def best_kruscall_wallis(self): + label = ["Statistic", "P-Value", "Sig(*)"] + for i in range(1, len(self.datasets) + 1): + label.append(f"Best_Alg_D{i}") + label.append(f"Median_D{i}") + label.append(f"Mean_D{i}") + label.append(f"Std_D{i}") + + dc_dir = Path(self.experiment_path) / "DatasetComparisons" + kruskal_summary = pd.DataFrame(index=self.metrics, columns=label) + global_data: List[Any] = [] + + for metric in self.metrics: + best_list = [] + best_data = [] + + for dataset_path in self.dataset_directory_paths: + alg_med = [] + alg_mean = [] + alg_std = [] + alg_data = [] + alg_names = [] + + for algorithm in self.algorithms: + td = self._load_performance_df(dataset_path, algorithm) + if metric not in td.columns: + continue + vals = td[metric].astype(float) + alg_med.append(vals.median()) + alg_mean.append(vals.mean()) + alg_std.append(vals.std()) + alg_data.append(vals) + alg_names.append(algorithm) + + if not alg_mean: + # no algorithm has this metric for this dataset + continue + + best_mean = max(alg_mean) + best_index = alg_mean.index(best_mean) + best_alg = alg_names[best_index] + best_data.append(alg_data[best_index]) + best_list.append( + [ + best_alg, + alg_med[best_index], + alg_mean[best_index], + alg_std[best_index], + ] + ) + + global_data.append([best_data, best_list]) + + if not best_data: + kruskal_summary.at[metric, "Statistic"] = str(round(np.nan, 6)) + kruskal_summary.at[metric, "P-Value"] = str(round(np.nan, 6)) + kruskal_summary.at[metric, "Sig(*)"] = "" + continue + + try: + result = kruskal(*best_data) + kruskal_summary.at[metric, "Statistic"] = str(round(result[0], 6)) + kruskal_summary.at[metric, "P-Value"] = str(round(result[1], 6)) + kruskal_summary.at[metric, "Sig(*)"] = ( + "*" if result[1] < self.sig_cutoff else "" + ) + except ValueError: + kruskal_summary.at[metric, "Statistic"] = str(round(np.nan, 6)) + kruskal_summary.at[metric, "P-Value"] = str(round(np.nan, 6)) + kruskal_summary.at[metric, "Sig(*)"] = "" + + for j, (alg, medv, meanv, stdv) in enumerate(best_list): + kruskal_summary.at[metric, f"Best_Alg_D{j+1}"] = str(alg) + kruskal_summary.at[metric, f"Median_D{j+1}"] = str(round(medv, 6)) + kruskal_summary.at[metric, f"Mean_D{j+1}"] = str(round(meanv, 6)) + kruskal_summary.at[metric, f"Std_D{j+1}"] = str(round(stdv, 6)) + + out = dc_dir / "BestCompare_KruskalWallis.csv" + kruskal_summary.to_csv(out) + return global_data + + def best_mann_whitney_u(self, global_data): + df = self.inter_set_best_fn(mannwhitneyu, global_data) + out = Path(self.experiment_path) / "DatasetComparisons" / "BestCompare_MannWhitney.csv" + df.to_csv(out, index=False) + + def best_wilcoxon_rank(self, global_data): + df = self.inter_set_best_fn(wilcoxon, global_data) + out = Path(self.experiment_path) / "DatasetComparisons" / "BestCompare_WilcoxonRank.csv" + df.to_csv(out, index=False) + + def data_compare_bp_all(self): + """ + For each metric, generate boxplots comparing algorithm performance across datasets. + Includes both base models and ensembles (if present). + + Uses: + model_evaluation/Summary_performance_mean.csv + + ensemble_evaluation/Ensembles_performance_mean.csv (if present) + """ + dc_bp_dir = ( + Path(self.experiment_path) / "DatasetComparisons" / "dataCompBoxplots" + ) + dc_bp_dir.mkdir(parents=True, exist_ok=True) + + for metric in self.metrics: + df = pd.DataFrame() + data_name_list: List[str] = [] + alg_values_dict: Dict[str, List[float]] = {alg: [] for alg in self.algorithms} + + for each in self.dataset_directory_paths: + data_name_list.append(Path(each).name) + + # Base model summary + base_path = ( + Path(each) + / "model_evaluation" + / "Summary_performance_mean.csv" + ) + if not base_path.is_file(): + continue + data = pd.read_csv(base_path, sep=",", index_col=0) + + # Append ensemble summary if present + ens_path = ( + Path(each) + / "ensemble_evaluation" + / "Ensembles_performance_mean.csv" + ) + if ens_path.is_file(): + ens_df = pd.read_csv(ens_path, sep=",") + if "Ensemble" in ens_df.columns: + ens_df = ens_df.set_index("Ensemble") + # align on metric columns if needed + if metric in ens_df.columns: + data = pd.concat([data, ens_df], axis=0) + + if metric not in data.columns: + # no values for this metric in this dataset + col = pd.Series([], dtype=float) + else: + col = data[metric] + + col_list = col.tolist() + rownames = list(data.index.values) + + # record per-algorithm trajectories + for j, alg in enumerate(rownames): + if j < len(col_list): + val = col_list[j] + alg_values_dict.setdefault(alg, []).append(val) + + df = pd.concat([df, col], axis=1) + + if df.empty: + continue + + df.columns = data_name_list + df.boxplot(column=data_name_list, rot=90) + + # overlay algorithm trajectories + for alg in self.algorithms: + vals = alg_values_dict.get(alg) + if not vals or len(vals) != len(self.dataset_directory_paths): + continue + plt.plot( + np.arange(len(self.dataset_directory_paths)) + 1, + vals, + color=self.colors.get(alg, "C0"), + label=alg, + ) + + plt.ylabel(str(metric)) + plt.xlabel("Dataset") + plt.legend(loc="upper left", bbox_to_anchor=(1.01, 1.0)) + out = dc_bp_dir / f"DataCompareAllModels_{metric}.png" + plt.savefig(out, bbox_inches="tight") + if self.show_plots: + plt.show() + else: + plt.close("all") + + def data_compare_bp(self): + """ + Per-algorithm boxplots comparing distributions of a target metric + across datasets. Works for both base models and ensembles. + """ + dc_bp_dir = ( + Path(self.experiment_path) / "DatasetComparisons" / "dataCompBoxplots" + ) + dc_bp_dir.mkdir(parents=True, exist_ok=True) + + if self.outcome_type == "Binary": + metric_list = ["ROC AUC", "PRC AUC"] + else: + metric_list = [ + "Max Error", + "Mean Absolute Error", + "Mean Squared Error", + "Median Absolute Error", + "Explained Variance", + "Pearson Correlation", + ] + + for algorithm in self.algorithms: + for metric in metric_list: + df = pd.DataFrame() + data_name_list: List[str] = [] + for each in self.dataset_directory_paths: + td = self._load_performance_df(each, algorithm) + if metric not in td.columns: + continue + col = td[metric].astype(float) + df = pd.concat([df, col], axis=1) + data_name_list.append(Path(each).name) + + if df.empty: + continue + + df.columns = data_name_list + df.boxplot(column=data_name_list, rot=90) + plt.ylabel(str(metric)) + plt.xlabel("Dataset") + plt.title(algorithm) + out = dc_bp_dir / f"DataCompare_{self.abbrev[algorithm]}_{metric}.png" + plt.savefig(out, bbox_inches="tight") + if self.show_plots: + plt.show() + else: + plt.close("all") + + def save_runtime(self): + runtime_dir = Path(self.experiment_path) / "runtime" + runtime_dir.mkdir(exist_ok=True) + runtime_file = runtime_dir / "runtime_compare_datasets.txt" + with runtime_file.open("w") as f: + f.write(str(time.time() - self.job_start_time)) + + # ------------------------------------------------------------------ + # Shared helper methods + # ------------------------------------------------------------------ + def _load_performance_df(self, dataset_path: str, algorithm: str) -> pd.DataFrame: + """ + Unified loader for per-CV performance metrics for both base models + and ensembles. + + Base models: + /model_evaluation/_performance.csv + + Ensembles: + /ensemble_evaluation/metrics_by_cv/_CV_.json + -> converted on the fly to a DataFrame with one row per CV. + """ + ds = Path(dataset_path) + abbr = self.abbrev[algorithm] + + if algorithm in self.base_algorithms: + path = ds / "model_evaluation" / f"{abbr}_performance.csv" + if not path.is_file(): + # fallback: empty DF + return pd.DataFrame() + return pd.read_csv(path) + + # ensembles + metrics_dir = ds / "ensemble_evaluation" / "metrics_by_cv" + if not metrics_dir.is_dir(): + return pd.DataFrame() + + rows = [] + for fn in sorted(metrics_dir.glob(f"{abbr}_CV_*.json")): + with fn.open("r") as f: + data = json.load(f) + # Accept both flat dicts and {"Balanced Accuracy": ..., ...} + # They should already be flat from Phase 7. + rows.append(data) + + if not rows: + return pd.DataFrame() + + df = pd.DataFrame(rows) + # ensure numeric where possible + for c in df.columns: + df[c] = pd.to_numeric(df[c], errors="coerce") + return df + + def inter_set_fn(self, fn, algorithm: str) -> List[List[Any]]: + master_list: List[List[Any]] = [] + for metric in self.metrics: + for x in range(0, len(self.dataset_directory_paths) - 1): + for y in range(x + 1, len(self.dataset_directory_paths)): + td1 = self._load_performance_df( + self.dataset_directory_paths[x], algorithm + ) + td2 = self._load_performance_df( + self.dataset_directory_paths[y], algorithm + ) + if metric not in td1.columns or metric not in td2.columns: + continue + + set1 = td1[metric].astype(float) + med1 = set1.median() + mean1 = set1.mean() + std1 = set1.std() + + set2 = td2[metric].astype(float) + med2 = set2.median() + mean2 = set2.mean() + std2 = set2.std() + + temp_list = self.temp_summary(set1, set2, x, y, metric, fn) + temp_list.extend( + [ + str(round(med1, 6)), + str(round(med2, 6)), + str(round(mean1, 6)), + str(round(mean2, 6)), + str(round(std1, 6)), + str(round(std2, 6)), + ] + ) + master_list.append(temp_list) + return master_list + + def inter_set_best_fn(self, fn, global_data) -> pd.DataFrame: + label = ["Metric", "Data1", "Data2", "Statistic", "P-Value", "Sig(*)"] + for i in range(1, 3): + label.append(f"Best_Alg_Data{i}") + label.append(f"Median_Data{i}") + label.append(f"Mean_Data{i}") + label.append(f"Std_Data{i}") + + master_list: List[List[Any]] = [] + for j, metric in enumerate(self.metrics): + for x in range(0, len(self.datasets) - 1): + for y in range(x + 1, len(self.datasets)): + if not global_data[j][0]: + continue + set1 = global_data[j][0][x] + med1 = global_data[j][1][x][1] + mean1 = global_data[j][1][x][2] + std1 = global_data[j][1][x][3] + + set2 = global_data[j][0][y] + med2 = global_data[j][1][y][1] + mean2 = global_data[j][1][y][2] + std2 = global_data[j][1][y][3] + + temp_list = self.temp_summary(set1, set2, x, y, metric, fn) + + temp_list.append(global_data[j][1][x][0]) + temp_list.append(str(round(med1, 6))) + temp_list.append(str(round(mean1, 6))) + temp_list.append(str(round(std1, 6))) + temp_list.append(global_data[j][1][y][0]) + temp_list.append(str(round(med2, 6))) + temp_list.append(str(round(mean2, 6))) + temp_list.append(str(round(std2, 6))) + master_list.append(temp_list) + + df = pd.DataFrame(master_list, columns=label) + return df + + def temp_summary(self, set1, set2, x, y, metric, fn) -> List[Any]: + temp_list: List[Any] = [] + if set1.equals(set2): + result = ["NA", 1.0] + else: + try: + result = fn(set1, set2) + except Exception: + result = ["NA_error", 1.0] + + temp_list.append(str(metric)) + temp_list.append(f"D{x+1}") + temp_list.append(f"D{y+1}") + + if set1.equals(set2): + temp_list.append(result[0]) + else: + try: + temp_list.append(str(round(result[0], 6))) + except Exception: + temp_list.append(result[0]) + + temp_list.append(str(round(result[1], 6))) + temp_list.append("*" if result[1] < self.sig_cutoff else "") + + return temp_list diff --git a/streamline/p9_compare_datasets/p9_cli.py b/streamline/p9_compare_datasets/p9_cli.py new file mode 100644 index 00000000..759cb41f --- /dev/null +++ b/streamline/p9_compare_datasets/p9_cli.py @@ -0,0 +1,80 @@ +# streamline/p9_compare_datasets/p9_cli.py +from __future__ import annotations + +import argparse + +from streamline.p9_compare_datasets.p9_runner import P9Runner +from streamline.utils.run_commands import ( + add_run_command_args, + apply_saved_run_command, + save_run_command_from_args, + snapshot_args, +) + + +def main(): + ap = argparse.ArgumentParser( + "STREAMLINE Phase 9 (Dataset Comparisons)", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + ap.add_argument("--output_path", required=True) + ap.add_argument("--experiment_name", required=True) + ap.add_argument( + "--outcome_label", + default="Class", + help="Outcome column name.", + ) + ap.add_argument( + "--outcome_type", + choices=["Binary", "Multiclass", "Continuous"], + default="Binary", + help="Outcome type (affects metric list / plots).", + ) + ap.add_argument( + "--instance_label", + default=None, + help="Optional instance ID column name.", + ) + ap.add_argument( + "--sig_cutoff", + type=float, + default=0.05, + help="Significance cutoff for non-parametric tests.", + ) + ap.add_argument( + "--show_plots", + type=int, + default=0, + help="1 to show plots interactively, 0 to only save to disk.", + ) + ap.add_argument( + "--run_cluster", + default="Serial", + help="Serial | Local | Parallel | BashSLURM | BashLSF | ", + ) + ap.add_argument("--queue", default="defq") + ap.add_argument("--reserved_memory", type=int, default=4) + add_run_command_args(ap) + + args = ap.parse_args() + args = apply_saved_run_command(ap, args, "p9_compare_datasets") + run_command_args = snapshot_args(args) + + runner = P9Runner( + output_path=args.output_path, + experiment_name=args.experiment_name, + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + instance_label=args.instance_label, + sig_cutoff=args.sig_cutoff, + show_plots=bool(args.show_plots), + run_cluster=args.run_cluster, + queue=args.queue, + reserved_memory=args.reserved_memory, + ) + runner.run() + save_run_command_from_args(args, "p9_compare_datasets", run_command_args, runner=runner) + + +if __name__ == "__main__": + main() diff --git a/streamline/p9_compare_datasets/p9_jobsubmit.py b/streamline/p9_compare_datasets/p9_jobsubmit.py new file mode 100644 index 00000000..1644d656 --- /dev/null +++ b/streamline/p9_compare_datasets/p9_jobsubmit.py @@ -0,0 +1,42 @@ +# streamline/p9_compare_datasets/p9_jobsubmit.py +from __future__ import annotations + +import argparse + +from streamline.p9_compare_datasets.p9_runner import P9Runner + + +def main(): + ap = argparse.ArgumentParser( + "STREAMLINE Phase 9 (Dataset Comparisons) jobsubmit", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + ap.add_argument("--output_path", required=True) + ap.add_argument("--experiment_name", required=True) + ap.add_argument("--outcome_label", default="Class") + ap.add_argument( + "--outcome_type", + choices=["Binary", "Multiclass", "Continuous"], + default="Binary", + ) + ap.add_argument("--instance_label", default=None) + ap.add_argument("--sig_cutoff", type=float, default=0.05) + ap.add_argument("--show_plots", type=int, default=0) + + args = ap.parse_args() + + # On the compute node we just run serially; scheduling is handled by SLURM/LSF. + P9Runner( + output_path=args.output_path, + experiment_name=args.experiment_name, + outcome_label=args.outcome_label, + outcome_type=args.outcome_type, + instance_label=args.instance_label, + sig_cutoff=args.sig_cutoff, + show_plots=bool(args.show_plots), + run_cluster="Serial", + ).run() + + +if __name__ == "__main__": + main() diff --git a/streamline/p9_compare_datasets/p9_runner.py b/streamline/p9_compare_datasets/p9_runner.py new file mode 100644 index 00000000..5f7a6804 --- /dev/null +++ b/streamline/p9_compare_datasets/p9_runner.py @@ -0,0 +1,132 @@ +# streamline/p9_compare_datasets/p9_runner.py +from __future__ import annotations + +import os +import time +from pathlib import Path +from typing import Optional + +import dask +from dask.distributed import Client, LocalCluster + +from streamline.utils.cluster import get_cluster +from streamline.p9_compare_datasets.compare_datasets import DatasetCompareJob +from streamline.utils.runners import num_cores, run_dask_tasks, run_parallel_functions + + +class P9Runner: + """ + Phase 9 Runner: dataset-level comparison across all datasets in an experiment. + """ + + def __init__( + self, + output_path: str, + experiment_name: str, + outcome_label: str = "Class", + outcome_type: str = "Binary", + instance_label: Optional[str] = None, + sig_cutoff: float = 0.05, + show_plots: bool = False, + run_cluster: str = "Serial", + queue: str = "defq", + reserved_memory: int = 4, + ): + self.output_path = output_path + self.experiment_name = experiment_name + self.exp_root = Path(output_path) / experiment_name + if not self.exp_root.is_dir(): + raise Exception(f"Experiment folder not found: {self.exp_root}") + + self.kw = dict( + output_path=output_path, + experiment_name=experiment_name, + experiment_path=str(self.exp_root), + outcome_label=outcome_label, + outcome_type=outcome_type, + instance_label=instance_label, + sig_cutoff=float(sig_cutoff), + show_plots=bool(show_plots), + ) + + self.run_cluster = run_cluster or "Serial" + self.queue = queue + self.reserved_memory = int(reserved_memory) + + def run(self): + """ + Phase 9 is a single job per experiment (not per dataset). + """ + if self.run_cluster == "Serial": + self._run_one() + elif self.run_cluster == "Local": + with LocalCluster(processes=True, n_workers=num_cores, threads_per_worker=1) as cluster: + with Client(cluster) as client: + run_dask_tasks([dask.delayed(self._run_one)()], client, label="Phase 9 Dask jobs") + elif self.run_cluster == "Parallel": + run_parallel_functions([self._run_one], label="Phase 9 Parallel jobs") + elif self.run_cluster in ("BashSLURM", "BashLSF"): + self._submit_bash() + else: + client: Client = get_cluster( + self.run_cluster, str(self.exp_root), self.queue, self.reserved_memory + ) + run_dask_tasks([dask.delayed(self._run_one)()], client, label="Phase 9 Dask jobs") + + def _run_one(self): + DatasetCompareJob(**self.kw).run() + + def _submit_bash(self): + """ + Submit a single experiment-level job via SLURM or LSF, using p9_jobsubmit.py. + """ + job_ref = str(time.time()) + jobs = self.exp_root / "jobs" + logs = self.exp_root / "logs" + os.makedirs(jobs, exist_ok=True) + os.makedirs(logs, exist_ok=True) + + sh = jobs / f"P9_{job_ref}_run.sh" + launcher = "sbatch" if self.run_cluster == "BashSLURM" else "bsub <" + script = Path(__file__).with_name("p9_jobsubmit.py") + + args = " ".join( + [ + "python", + str(script), + "--output_path", + self.output_path, + "--experiment_name", + self.experiment_name, + "--outcome_label", + self.kw["outcome_label"], + "--outcome_type", + self.kw["outcome_type"], + "--instance_label", + self.kw["instance_label"] or "", + "--sig_cutoff", + str(self.kw["sig_cutoff"]), + "--show_plots", + str(int(self.kw["show_plots"])), + ] + ) + + with open(sh, "w") as f: + f.write("#!/bin/bash\n") + if self.run_cluster == "BashSLURM": + f.write(f"#SBATCH -p {self.queue}\n") + f.write(f"#SBATCH --job-name={job_ref}\n") + f.write(f"#SBATCH --mem={self.reserved_memory}G\n") + f.write(f"#SBATCH -o {logs}/P9_{job_ref}.o\n") + f.write(f"#SBATCH -e {logs}/P9_{job_ref}.e\n") + f.write(f"srun {args}\n") + else: # BashLSF + f.write(f"#BSUB -q {self.queue}\n") + f.write(f"#BSUB -J {job_ref}\n") + f.write(f"#BSUB -R \"rusage[mem={self.reserved_memory}G]\"\n") + f.write(f"#BSUB -M {self.reserved_memory}GB\n") + f.write(f"#BSUB -o {logs}/P9_{job_ref}.o\n") + f.write(f"#BSUB -e {logs}/P9_{job_ref}.e\n") + f.write(f"{args}\n") + + os.system(f"{launcher} {sh}") diff --git a/streamline/pipeline/__init__.py b/streamline/pipeline/__init__.py new file mode 100644 index 00000000..462201f7 --- /dev/null +++ b/streamline/pipeline/__init__.py @@ -0,0 +1,2 @@ +"""Config-driven STREAMLINE pipeline orchestration.""" + diff --git a/streamline/pipeline/pipeline_cli.py b/streamline/pipeline/pipeline_cli.py new file mode 100644 index 00000000..f2a13e64 --- /dev/null +++ b/streamline/pipeline/pipeline_cli.py @@ -0,0 +1,35 @@ +from __future__ import annotations + +import argparse +import logging + +from streamline.pipeline.pipeline_runner import PipelineRunner, normalize_phase_list + + +def main() -> None: + parser = argparse.ArgumentParser( + "STREAMLINE config-driven pipeline runner", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + parser.add_argument("-c", "--config", required=True, help="Path to a .cfg STREAMLINE config file") + parser.add_argument("--dry_run", action="store_true", help="Print resolved phase calls without running them") + parser.add_argument("--start_at", default=None, help="Start at a phase alias, e.g. p4 or p4_feature_importance") + parser.add_argument("--stop_after", default=None, help="Stop after a phase alias, e.g. p8") + parser.add_argument("--only", default=None, help="Comma-separated phase aliases to run") + parser.add_argument("--skip", default=None, help="Comma-separated phase aliases to skip") + parser.add_argument("--log_level", default="INFO", help="Python logging level") + args = parser.parse_args() + + logging.basicConfig(level=getattr(logging, str(args.log_level).upper(), logging.INFO)) + PipelineRunner( + config_path=args.config, + dry_run=args.dry_run, + start_at=args.start_at, + stop_after=args.stop_after, + only=normalize_phase_list(args.only) if args.only else None, + skip=normalize_phase_list(args.skip) if args.skip else None, + ).run() + + +if __name__ == "__main__": + main() diff --git a/streamline/pipeline/pipeline_runner.py b/streamline/pipeline/pipeline_runner.py new file mode 100644 index 00000000..f71a19c3 --- /dev/null +++ b/streamline/pipeline/pipeline_runner.py @@ -0,0 +1,411 @@ +from __future__ import annotations + +import ast +import configparser +import inspect +import logging +import os +from copy import deepcopy +from pathlib import Path +from typing import Any + +from streamline.p1_data_process.p1_runner import P1Runner +from streamline.p2_impute_scale.p2_runner import P2Runner +from streamline.p3_feature_learning.p3_runner import P3Runner +from streamline.p4_feature_importance.p4_runner import P4Runner +from streamline.p5_feature_selection.p5_runner import P5Runner +from streamline.p6_modeling.p6_runner import P6Runner +from streamline.p7_ensembles.p7_runner import P7Runner +from streamline.p8_summary_statistics.p8_runner import P8Runner +from streamline.p9_compare_datasets.p9_runner import P9Runner +from streamline.p10_replication.p10_runner import P10Runner +from streamline.p11_reporting.p11_runner import P11Runner +from streamline.p6_modeling.utils.loader import normalize_modeling_type +from streamline.utils.run_commands import save_phase_run_command, snapshot_effective_args + + +PHASE_ALIASES = { + "p1": "p1_data_process", + "p1_data": "p1_data_process", + "p1_data_process": "p1_data_process", + "p2": "p2_impute_scale", + "p2_impute_scale": "p2_impute_scale", + "p3": "p3_feature_learning", + "p3_feature_learning": "p3_feature_learning", + "p4": "p4_feature_importance", + "p4_feature_importance": "p4_feature_importance", + "p5": "p5_feature_selection", + "p5_feature_selection": "p5_feature_selection", + "p6": "p6_modeling", + "p6_modeling": "p6_modeling", + "p7": "p7_ensembles", + "p7_ensembles": "p7_ensembles", + "p8": "p8_summary_statistics", + "p8_summary_statistics": "p8_summary_statistics", + "p9": "p9_compare_datasets", + "p9_compare_datasets": "p9_compare_datasets", + "p10": "p10_replication", + "p10_replication": "p10_replication", + "p11": "p11_reporting", + "p11_reporting": "p11_reporting", +} + +DEFAULT_PHASE_ORDER = [ + "p1_data_process", + "p2_impute_scale", + "p3_feature_learning", + "p4_feature_importance", + "p5_feature_selection", + "p6_modeling", + "p7_ensembles", + "p8_summary_statistics", + "p9_compare_datasets", + "p10_replication", + "p11_reporting", +] + +PHASE_RUNNERS = { + "p1_data_process": P1Runner, + "p2_impute_scale": P2Runner, + "p3_feature_learning": P3Runner, + "p4_feature_importance": P4Runner, + "p5_feature_selection": P5Runner, + "p6_modeling": P6Runner, + "p7_ensembles": P7Runner, + "p8_summary_statistics": P8Runner, + "p9_compare_datasets": P9Runner, + "p10_replication": P10Runner, + "p11_reporting": P11Runner, +} + +CONTROL_KEYS = { + "enabled", + "report_modes", + "skip_for_outcome_types", +} + +PHASE_TOGGLE_KEYS = { + "p1_data_process": ("do_p1", "do_data_process", "do_eda"), + "p2_impute_scale": ("do_p2", "do_impute_scale", "do_dataprep"), + "p3_feature_learning": ("do_p3", "do_feature_learning"), + "p4_feature_importance": ("do_p4", "do_feature_importance", "do_feat_imp"), + "p5_feature_selection": ("do_p5", "do_feature_selection", "do_feat_sel"), + "p6_modeling": ("do_p6", "do_modeling", "do_model"), + "p7_ensembles": ("do_p7", "do_ensembles"), + "p8_summary_statistics": ("do_p8", "do_summary_statistics", "do_stats"), + "p9_compare_datasets": ("do_p9", "do_compare_datasets", "do_compare_dataset"), + "p10_replication": ("do_p10", "do_replication", "do_replicate"), + "p11_reporting": ("do_p11", "do_reporting", "do_report", "do_rep_report"), +} + +PHASES_THROUGH_STANDARD_REPORT = { + "p1_data_process", + "p2_impute_scale", + "p3_feature_learning", + "p4_feature_importance", + "p5_feature_selection", + "p6_modeling", + "p7_ensembles", + "p8_summary_statistics", + "p9_compare_datasets", + "p11_reporting", +} + + +def load_config(config_path: str | Path) -> dict[str, Any]: + path = Path(config_path) + suffix = path.suffix.lower() + if suffix not in {".cfg", ".ini"}: + raise ValueError("STREAMLINE pipeline configs must end in .cfg or .ini") + loaded = load_cfg_config(path) + if not isinstance(loaded, dict): + raise ValueError("STREAMLINE config root must be a mapping/object.") + return expand_config_values(loaded) + + +def load_cfg_config(path: Path) -> dict[str, Any]: + parser = configparser.ConfigParser(interpolation=None, inline_comment_prefixes=("#", ";")) + parser.optionxform = str + with path.open() as file: + parser.read_file(file) + + loaded: dict[str, Any] = {"run": {}, "phase_controls": {}, "phases": {}} + for section in parser.sections(): + section_key = section.strip() + normalized_section = section_key.lower() + values = { + key.strip(): parse_cfg_value(value) + for key, value in parser.items(section) + } + if normalized_section in {"run", "global"}: + loaded[normalized_section] = values + elif normalized_section in {"phases", "phase_controls"}: + loaded["phase_controls"].update(values) + elif normalized_section in PHASE_ALIASES: + loaded["phases"][normalized_section] = values + else: + raise ValueError( + f"Unknown config section [{section_key}]. Use [run], [phases], or a phase section like [p1]." + ) + return loaded + + +def parse_cfg_value(value: str) -> Any: + text = value.strip() + if text == "": + return "" + lowered = text.lower() + if lowered == "none": + return None + if lowered == "true": + return True + if lowered == "false": + return False + try: + return ast.literal_eval(text) + except (SyntaxError, ValueError): + return text + + +def expand_config_values(value: Any) -> Any: + if isinstance(value, dict): + return {key: expand_config_values(item) for key, item in value.items()} + if isinstance(value, list): + return [expand_config_values(item) for item in value] + if isinstance(value, str): + return os.path.expandvars(os.path.expanduser(value)) + return value + + +def normalize_phase_name(name: str) -> str: + normalized = PHASE_ALIASES.get(str(name).strip()) + if normalized is None: + known = ", ".join(sorted(PHASE_ALIASES)) + raise ValueError(f"Unknown phase '{name}'. Known phases: {known}") + return normalized + + +def normalize_phase_list(values: Any) -> list[str]: + if values in (None, "", []): + return [] + if isinstance(values, str): + values = [item.strip() for item in values.split(",") if item.strip()] + return [normalize_phase_name(value) for value in values] + + +def parse_config_mapping(value: Any, label: str) -> dict[str, Any]: + if value is None: + return {} + if not isinstance(value, dict): + raise ValueError(f"{label} must be a mapping/object.") + return dict(value) + + +def runner_constructor_defaults(runner_class) -> dict[str, Any]: + signature = inspect.signature(runner_class.__init__) + kwargs: dict[str, Any] = {} + for name, parameter in signature.parameters.items(): + if name == "self": + continue + if parameter.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD): + continue + if parameter.default is not inspect.Parameter.empty: + kwargs[name] = deepcopy(parameter.default) + return kwargs + + +def runner_kwargs(runner_class, common_config: dict[str, Any], phase_config: dict[str, Any]) -> dict[str, Any]: + signature = inspect.signature(runner_class.__init__) + allowed = {name for name in signature.parameters if name != "self"} + kwargs = runner_constructor_defaults(runner_class) + kwargs.update({key: value for key, value in common_config.items() if key in allowed}) + kwargs.update({key: value for key, value in phase_config.items() if key in allowed and key not in CONTROL_KEYS}) + return kwargs + + +class PipelineRunner: + def __init__( + self, + config_path: str | Path | None = None, + config: dict[str, Any] | None = None, + *, + dry_run: bool = False, + start_at: str | None = None, + stop_after: str | None = None, + only: list[str] | str | None = None, + skip: list[str] | str | None = None, + ): + if config is None: + if config_path is None: + raise ValueError("Provide config_path or config.") + config = load_config(config_path) + self.config_path = None if config_path is None else str(config_path) + self.config = deepcopy(config) + self.dry_run = bool(dry_run) + self.start_at = normalize_phase_name(start_at) if start_at else None + self.stop_after = normalize_phase_name(stop_after) if stop_after else None + self.only = normalize_phase_list(only) + self.skip = set(normalize_phase_list(skip)) + + global_config = parse_config_mapping(self.config.get("global"), "global") + run_config = parse_config_mapping(self.config.get("run"), "run") + self.common_config = {**global_config, **run_config} + self.phase_configs = parse_config_mapping(self.config.get("phases"), "phases") + self.phase_controls = parse_config_mapping(self.config.get("phase_controls"), "phase_controls") + + def run(self) -> list[str]: + phases = self.resolve_phase_order() + completed = [] + logging.info("STREAMLINE pipeline phase order: %s", ", ".join(phases)) + for phase in phases: + if not self.phase_is_enabled(phase): + logging.info("Skipping disabled phase: %s", phase) + continue + if self.should_skip_regression_ensemble(phase): + logging.info("Skipping Phase 7 because regression/continuous ensembles are not supported.") + continue + self.run_phase(phase) + completed.append(phase) + return completed + + def resolve_phase_order(self) -> list[str]: + if self.only: + phases = list(self.only) + else: + phases = normalize_phase_list( + self.common_config.get("phase_order") + or self.phase_controls.get("phase_order") + or self.common_config.get("phases") + or DEFAULT_PHASE_ORDER + ) + if self.start_at: + if self.start_at not in phases: + raise ValueError(f"start_at phase '{self.start_at}' is not present in the configured phase order.") + phases = phases[phases.index(self.start_at):] + if self.stop_after: + if self.stop_after not in phases: + raise ValueError(f"stop_after phase '{self.stop_after}' is not present in the configured phase order.") + phases = phases[: phases.index(self.stop_after) + 1] + return [phase for phase in phases if phase not in self.skip] + + def phase_config(self, phase: str) -> dict[str, Any]: + merged: dict[str, Any] = {} + aliases = [alias for alias, canonical in PHASE_ALIASES.items() if canonical == phase] + for source in (self.config, self.phase_configs): + for alias in aliases: + value = source.get(alias) + if isinstance(value, dict): + merged.update(value) + return merged + + def phase_is_enabled(self, phase: str) -> bool: + config = self.phase_config(phase) + if "enabled" in config: + return bool(config["enabled"]) + toggle = self.phase_toggle_value(phase) + if toggle is not None: + return bool(toggle) + if phase == "p10_replication": + return bool(config.get("rep_data_path") and config.get("dataset_for_rep")) + return True + + def phase_toggle_value(self, phase: str) -> Any: + for key in PHASE_TOGGLE_KEYS[phase]: + if key in self.phase_controls: + return self.phase_controls[key] + if "do_all" in self.phase_controls: + return self.phase_controls["do_all"] + if "do_till_report" in self.phase_controls: + if phase in PHASES_THROUGH_STANDARD_REPORT: + return self.phase_controls["do_till_report"] + if phase == "p10_replication": + return self.phase_controls.get("do_replicate", False) + return None + + def should_skip_regression_ensemble(self, phase: str) -> bool: + if phase != "p7_ensembles": + return False + outcome_type = str(self.common_config.get("outcome_type", "")).lower() + p6_config = self.phase_config("p6_modeling") + p6_outcome_type = p6_config.get("outcome_type", self.common_config.get("outcome_type")) + p6_model_type = p6_config.get("model_type", self.common_config.get("model_type")) + model_type = normalize_modeling_type(outcome_type=p6_outcome_type, model_type=p6_model_type) + return outcome_type in {"continuous", "regression"} or model_type == "Regression" + + def run_phase(self, phase: str) -> None: + runner_class = PHASE_RUNNERS[phase] + config = self.phase_config(phase) + if phase == "p6_modeling": + self.apply_p6_defaults(config) + kwargs = runner_kwargs(runner_class, self.common_config, config) + if phase == "p11_reporting": + self.run_reporting(kwargs, config) + return + + logging.info("Starting %s", phase) + if self.dry_run: + print(f"[dry-run] {phase}: {runner_class.__name__}({kwargs})") + return + runner = runner_class(**kwargs) + runner.run() + self.save_phase_run_arguments(phase, snapshot_effective_args(kwargs, runner)) + logging.info("Finished %s", phase) + + def experiment_root_from_kwargs(self, kwargs: dict[str, Any]) -> Path | None: + experiment_path = kwargs.get("experiment_path") + if experiment_path: + return Path(str(experiment_path)) + output_path = kwargs.get("output_path") + experiment_name = kwargs.get("experiment_name") + if output_path and experiment_name: + return Path(str(output_path)) / str(experiment_name) + common_output = self.common_config.get("output_path") + common_name = self.common_config.get("experiment_name") + if common_output and common_name: + return Path(str(common_output)) / str(common_name) + return None + + def config_command_argv(self, phase: str) -> list[str]: + argv = ["run.py"] + if self.config_path: + argv.extend(["--config", self.config_path]) + argv.extend(["--only", phase]) + return argv + + def save_phase_run_arguments(self, phase: str, kwargs: dict[str, Any]) -> None: + exp_root = self.experiment_root_from_kwargs(kwargs) + if exp_root is None: + logging.info("run_commands.pickle not updated for %s: experiment path could not be resolved.", phase) + return + save_phase_run_command( + exp_root=exp_root, + phase=phase, + args=dict(kwargs), + argv=self.config_command_argv(phase), + ) + + def apply_p6_defaults(self, phase_config: dict[str, Any]) -> None: + if "outcome_type" in phase_config: + return + outcome_type = self.common_config.get("outcome_type") + if outcome_type: + phase_config["outcome_type"] = outcome_type + + def run_reporting(self, kwargs: dict[str, Any], config: dict[str, Any]) -> None: + modes = config.get("report_modes") + if modes is None: + report_mode = config.get("report_mode", kwargs.get("report_mode", "standard")) + modes = [report_mode] + if isinstance(modes, str): + modes = [item.strip() for item in modes.split(",") if item.strip()] + for mode in modes: + mode_kwargs = dict(kwargs) + mode_kwargs["report_mode"] = mode + logging.info("Starting p11_reporting (%s)", mode) + if self.dry_run: + print(f"[dry-run] p11_reporting: P11Runner({mode_kwargs})") + continue + runner = P11Runner(**mode_kwargs) + runner.run() + self.save_phase_run_arguments("p11_reporting", snapshot_effective_args(mode_kwargs, runner)) + logging.info("Finished p11_reporting (%s)", mode) diff --git a/streamline/postanalysis/dataset_compare.py b/streamline/postanalysis/dataset_compare.py deleted file mode 100644 index a08f88a5..00000000 --- a/streamline/postanalysis/dataset_compare.py +++ /dev/null @@ -1,452 +0,0 @@ -import os -import time -import logging -import numpy as np -import pandas as pd -import matplotlib.pyplot as plt -from scipy.stats import kruskal, wilcoxon, mannwhitneyu -from streamline.utils.job import Job -from streamline.modeling.utils import ABBREVIATION, COLORS, is_supported_model -from streamline.modeling.utils import SUPPORTED_MODELS -import seaborn as sns -sns.set_theme() - - -class CompareJob(Job): - """ - This 'Job' script is called by DataCompareMain.py which runs non-parametric statistical analysis - comparing ML algorithm performance between all target datasets included in the original Phase 1 data folder, - for each evaluation metric. - Also compares the best overall model for each target dataset, for each evaluation metric. - This runs once for the entire pipeline analysis. - """ - def __init__(self, output_path=None, experiment_name=None, experiment_path=None, algorithms=None, - exclude=("XCS", "eLCS"), - class_label="Class", instance_label=None, sig_cutoff=0.05, show_plots=False): - super().__init__() - assert (output_path is not None and experiment_name is not None) or (experiment_path is not None) - if output_path is not None and experiment_name is not None: - self.output_path = output_path - self.experiment_name = experiment_name - self.experiment_path = self.output_path + '/' + self.experiment_name - else: - self.experiment_path = experiment_path - self.experiment_name = self.experiment_path.split('/')[-1] - self.output_path = self.experiment_path.split('/')[-2] - - datasets = os.listdir(self.experiment_path) - remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle', - 'jobsCompleted', 'logs', 'jobs', 'DatasetComparisons', - 'UsefulNotebooks', 'dask_logs', - self.experiment_name + '_STREAMLINE_Report.pdf'] - for text in remove_list: - if text in datasets: - datasets.remove(text) - # ensures consistent ordering of datasets and assignment of temporary identifier - self.datasets = sorted(datasets) - - dataset_directory_paths = [] - for dataset in self.datasets: - full_path = self.experiment_path + "/" + dataset - dataset_directory_paths.append(full_path) - - self.dataset_directory_paths = dataset_directory_paths - - self.class_label = class_label - self.instance_label = instance_label - self.sig_cutoff = sig_cutoff - - if algorithms is None: - self.algorithms = SUPPORTED_MODELS - if exclude is not None: - for algorithm in exclude: - try: - self.algorithms.remove(algorithm) - except Exception: - Exception("Unknown algorithm in exclude: " + str(algorithm)) - else: - self.algorithms = list() - for algorithm in algorithms: - self.algorithms.append(is_supported_model(algorithm)) - - self.algorithms = sorted(algorithms) - - self.show_plots = show_plots - self.abbrev = dict((k, ABBREVIATION[k]) for k in self.algorithms if k in ABBREVIATION) - self.colors = dict((k, COLORS[k]) for k in self.algorithms if k in COLORS) - self.metrics = None - - def run(self): - self.job_start_time = time.time() # for tracking phase runtime - - data = pd.read_csv(self.dataset_directory_paths[0] + '/model_evaluation/Summary_performance_mean.csv', sep=',') - self.metrics = data.columns.values.tolist()[1:] - - # Create directory to store dataset statistical comparisons - if not os.path.exists(self.experiment_path + '/DatasetComparisons'): - os.mkdir(self.experiment_path + '/DatasetComparisons') - - logging.info('Running Statistical Significance Comparisons Between Multiple Datasets...') - - self.kruscall_wallis() - - self.mann_whitney_u() - - self.wilcoxon_rank() - - global_data = self.best_kruscall_wallis() - - self.best_mann_whitney_u(global_data) - - self.best_wilcoxon_rank(global_data) - - logging.info('Generate Boxplots Comparing Dataset Performance...') - # Generate boxplots comparing average algorithm performance - # (for a given metric) across all dataset comparisons - self.data_compare_bp_all() - - # Generate boxplots comparing a specific algorithm's CV performance ( - # for AUC_ROC or AUC_PRC) across all dataset comparisons - self.data_compare_bp() - # Print phase completion - logging.info("Phase 7 complete") - job_file = open(self.experiment_path + '/jobsCompleted/job_data_compare' + '.txt', 'w') - job_file.write('complete') - job_file.close() - - def kruscall_wallis(self): - """ - For each algorithm apply non-parametric Kruskal Wallis one-way ANOVA on ranks. - Determines if there is a statistically significant difference in performance - between original target datasets across CV runs. - Completed for each standard metric separately. - """ - - label = ['Statistic', 'P-Value', 'Sig(*)'] - for i in range(1, len(self.datasets) + 1): - label.append('Median_D' + str(i)) - - for algorithm in self.algorithms: - kruskal_summary = pd.DataFrame(index=self.metrics, columns=label) - for metric in self.metrics: - temp_array = [] - med_list = [] - for dataset_path in self.dataset_directory_paths: - filename = dataset_path + '/model_evaluation/' + self.abbrev[algorithm] + '_performance.csv' - td = pd.read_csv(filename) - temp_array.append(td[metric]) - med_list.append(td[metric].median()) - try: # Run kruskal Wallis - result = kruskal(*temp_array) - except Exception: - result = ['NA', 1] - try: - kruskal_summary.at[metric, 'Statistic'] = str(round(result[0], 6)) - except TypeError: - kruskal_summary.at[metric, 'Statistic'] = 'NA' - kruskal_summary.at[metric, 'P-Value'] = str(round(result[1], 6)) - if result[1] < self.sig_cutoff: - kruskal_summary.at[metric, 'Sig(*)'] = str('*') - else: - kruskal_summary.at[metric, 'Sig(*)'] = str('') - for j in range(len(med_list)): - kruskal_summary.at[metric, 'Median_D' + str(j + 1)] = str(round(med_list[j], 6)) - # Export analysis summary to .csv file - kruskal_summary.to_csv(self.experiment_path + '/DatasetComparisons/KruskalWallis_' + algorithm + '.csv') - - def wilcoxon_rank(self): - """ - For each algorithm, apply non-parametric Wilcoxon Rank Sum (pairwise comparisons). - This tests individual algorithm pairs of original target datasets (for each metric) - to determine if there is a statistically significant difference in performance across CV runs. - Test statistic will be zero if all scores from one set are - larger than the other. - """ - - label = ['Metric', 'Data1', 'Data2', 'Statistic', 'P-Value', 'Sig(*)'] - for i in range(1, 3): - label.append('Median_Data' + str(i)) - - for algorithm in self.algorithms: - master_list = self.inter_set_fn(wilcoxon, algorithm) - # Export test results - df = pd.DataFrame(master_list) - df.columns = label - df.to_csv(self.experiment_path + '/DatasetComparisons/WilcoxonRank_' + algorithm + '.csv', index=False) - - def mann_whitney_u(self): - """ - For each algorithm, apply non-parametric Mann Whitney U-test (pairwise comparisons). - Mann Whitney tests dataset pairs (for each metric) - to determine if there is a statistically significant difference in performance across CV runs. - Test statistic will be zero if all scores from one set are - larger than the other. - """ - - label = ['Metric', 'Data1', 'Data2', 'Statistic', 'P-Value', 'Sig(*)'] - for i in range(1, 3): - label.append('Median_Data' + str(i)) - for algorithm in self.algorithms: - # Export test results - master_list = self.inter_set_fn(mannwhitneyu, algorithm) - df = pd.DataFrame(master_list) - df.columns = label - df.to_csv(self.experiment_path + '/DatasetComparisons/MannWhitney_' + algorithm + '.csv', index=False) - - def best_kruscall_wallis(self): - """ - For best performing algorithm on a given metric and dataset, apply non-parametric - Kruskal Wallis one-way ANOVA on ranks. - Determines if there is a statistically significant difference in performance - between original target datasets across CV runs - on best algorithm for given metric. - """ - - label = ['Statistic', 'P-Value', 'Sig(*)'] - for i in range(1, len(self.datasets) + 1): - label.append('Best_Alg_D' + str(i)) - label.append('Median_D' + str(i)) - - kruskal_summary = pd.DataFrame(index=self.metrics, columns=label) - global_data = [] - - for metric in self.metrics: - best_list = [] - best_data = [] - for dataset_path in self.dataset_directory_paths: - alg_med = [] - alg_data = [] - for algorithm in self.algorithms: - filename = dataset_path + '/model_evaluation/' + self.abbrev[algorithm] + '_performance.csv' - td = pd.read_csv(filename) - alg_med.append(td[metric].median()) - alg_data.append(td[metric]) - # Find the best algorithm for given metric based on average - best_med = max(alg_med) - best_index = alg_med.index(best_med) - best_alg = self.algorithms[best_index] - best_data.append(alg_data[best_index]) - best_list.append([best_alg, best_med]) - global_data.append([best_data, best_list]) - try: - result = kruskal(*best_data) - kruskal_summary.at[metric, 'Statistic'] = str(round(result[0], 6)) - kruskal_summary.at[metric, 'P-Value'] = str(round(result[1], 6)) - if result[1] < self.sig_cutoff: - kruskal_summary.at[metric, 'Sig(*)'] = str('*') - else: - kruskal_summary.at[metric, 'Sig(*)'] = str('') - except ValueError: - kruskal_summary.at[metric, 'Statistic'] = str(round(np.nan, 6)) - kruskal_summary.at[metric, 'P-Value'] = str(round(np.nan, 6)) - kruskal_summary.at[metric, 'Sig(*)'] = str('') - for j in range(len(best_list)): - kruskal_summary.at[metric, 'Best_Alg_D' + str(j + 1)] = str(best_list[j][0]) - kruskal_summary.at[metric, 'Median_D' + str(j + 1)] = str(round(best_list[j][1], 6)) - # Export analysis summary to .csv file - kruskal_summary.to_csv(self.experiment_path + '/DatasetComparisons/BestCompare_KruskalWallis.csv') - return global_data - - def best_mann_whitney_u(self, global_data): - """ - For best performing algorithm on a given metric and dataset, - apply non-parametric Mann Whitney U-test (pairwise comparisons). - Mann Whitney tests dataset pairs (for each metric) - to determine if there is a statistically significant difference - in performance across CV runs. Test statistic will be zero if all scores from one set are - larger than the other. - """ - df = self.inter_set_best_fn(mannwhitneyu, global_data) - df.to_csv(self.experiment_path + '/DatasetComparisons/BestCompare_MannWhitney.csv', index=False) - - def best_wilcoxon_rank(self, global_data): - """ - For best performing algorithm on a given metric and dataset, apply - non-parametric Mann Whitney U-test (pairwise comparisons). - Mann Whitney tests dataset pairs (for each metric) - to determine if there is a statistically significant difference in - performance across CV runs. Test statistic will be zero if all scores from one set are - larger than the other. - """ - df = self.inter_set_best_fn(wilcoxon, global_data) - df.to_csv(self.experiment_path + '/DatasetComparisons/BestCompare_WilcoxonRank.csv', index=False) - - def data_compare_bp_all(self): - """ - Generate a boxplot comparing algorithm performance (CV average of each target metric) - across all target datasets to be compared. - """ - - if not os.path.exists(self.experiment_path + '/DatasetComparisons/dataCompBoxplots'): - os.mkdir(self.experiment_path + '/DatasetComparisons/dataCompBoxplots') - - # One boxplot generated for each available metric - for metric in self.metrics: - df = pd.DataFrame() - data_name_list = [] - alg_values_dict = {} - # Dictionary of all algorithms run that will each have a list of respective mean metric value - for algorithm in self.algorithms: - # Used to generate algorithm lines on top of boxplot - alg_values_dict[algorithm] = [] - # For each target dataset - for each in self.dataset_directory_paths: - data_name_list.append(each.split('/')[-1]) - data = pd.read_csv(each + '/model_evaluation/Summary_performance_mean.csv', sep=',', index_col=0) - rownames = data.index.values # makes a list of algorithm names from file - rownames = list(rownames) - # Grab data in metric column - col = data[metric] # Dataframe of average target metric values for each algorithm - col_list = data[metric].tolist() # List of average target metric values for each algorithm - for j in range(len(rownames)): # For each algorithm - alg_values_dict[rownames[j]].append(col_list[j]) - # Create dataframe of average target metric where columns are datasets, and rows are algorithms - df = pd.concat([df, col], axis=1) - df.columns = data_name_list - # Generate boxplot (with legend for each box) --------------------------------------- - # Plot boxplots - df.boxplot(column=data_name_list, rot=90) - # Plot lines for each algorithm (to illustrate algorithm performance trajectories between datasets) - for i in range(len(self.algorithms)): - plt.plot(np.arange(len(self.dataset_directory_paths)) + 1, alg_values_dict[self.algorithms[i]], - color=self.colors[self.algorithms[i]], label=self.algorithms[i]) - # Specify plot labels - plt.ylabel(str(metric)) - plt.xlabel('Dataset') - plt.legend(loc="upper left", bbox_to_anchor=(1.01, 1)) - # Export and/or show plot - plt.savefig( - self.experiment_path + '/DatasetComparisons/dataCompBoxplots/DataCompareAllModels_' + metric + '.png', - bbox_inches="tight") - if self.show_plots: - plt.show() - else: - plt.close('all') - # plt.cla() # not required - - def data_compare_bp(self): - """ - Generate a boxplot comparing average algorithm performance (for a given target metric) - across all target datasets to be compared. - """ - metric_list = ['ROC AUC', 'PRC AUC'] # Hard coded - if not os.path.exists(self.experiment_path + '/DatasetComparisons/dataCompBoxplots'): - os.mkdir(self.experiment_path + '/DatasetComparisons/dataCompBoxplots') - for algorithm in self.algorithms: - for metric in metric_list: - df = pd.DataFrame() - data_name_list = [] - for each in self.dataset_directory_paths: - data_name_list.append(each.split('/')[-1]) - data = pd.read_csv(each + '/model_evaluation/' + self.abbrev[algorithm] + '_performance.csv', - sep=',') - # Grab data in metric column - col = data[metric] - df = pd.concat([df, col], axis=1) - df.columns = data_name_list - # Generate boxplot (with legend for each box) - df.boxplot(column=data_name_list, rot=90) - # Specify plot labels - plt.ylabel(str(metric)) - plt.xlabel('Dataset') - plt.title(algorithm) - # Export and/or show plot - plt.savefig(self.experiment_path + '/DatasetComparisons/dataCompBoxplots/DataCompare_' + self.abbrev[ - algorithm] + '_' + metric + '.png', bbox_inches="tight") - if self.show_plots: - plt.show() - else: - plt.close('all') - # plt.cla() # not required - - def save_runtime(self): - """ - Save phase runtime - """ - runtime_file = open(self.experiment_path + '/runtime/runtime_compare.txt', 'w') - runtime_file.write(str(time.time() - self.job_start_time)) - runtime_file.close() - - def inter_set_fn(self, fn, algorithm): - master_list = list() - for metric in self.metrics: - for x in range(0, len(self.dataset_directory_paths) - 1): - for y in range(x + 1, len(self.dataset_directory_paths)): - # Grab info on first dataset - file1 = self.dataset_directory_paths[x] + '/model_evaluation/' + self.abbrev[ - algorithm] + '_performance.csv' - td1 = pd.read_csv(file1) - set1 = td1[metric] - med1 = td1[metric].median() - # Grab info on second dataset - file2 = self.dataset_directory_paths[y] + '/model_evaluation/' + self.abbrev[ - algorithm] + '_performance.csv' - td2 = pd.read_csv(file2) - set2 = td2[metric] - med2 = td2[metric].median() - - temp_list = self.temp_summary(set1, set2, x, y, metric, fn) - - temp_list.append(str(round(med1, 6))) - temp_list.append(str(round(med2, 6))) - master_list.append(temp_list) - return master_list - - def inter_set_best_fn(self, fn, global_data): - label = ['Metric', 'Data1', 'Data2', 'Statistic', 'P-Value', 'Sig(*)'] - for i in range(1, 3): - label.append('Best_Alg_Data' + str(i)) - label.append('Median_Data' + str(i)) - - master_list = list() - for j in range(len(self.metrics)): - metric = self.metrics[j] - for x in range(0, len(self.datasets) - 1): - for y in range(x + 1, len(self.datasets)): - set1 = global_data[j][0][x] - med1 = global_data[j][1][x][1] - set2 = global_data[j][0][y] - med2 = global_data[j][1][y][1] - - temp_list = self.temp_summary(set1, set2, x, y, metric, fn) - - temp_list.append(global_data[j][1][x][0]) - temp_list.append(str(round(med1, 6))) - temp_list.append(global_data[j][1][y][0]) - temp_list.append(str(round(med2, 6))) - master_list.append(temp_list) - - # Export analysis summary to .csv file - df = pd.DataFrame(master_list) - df.columns = label - return df - - def temp_summary(self, set1, set2, x, y, metric, fn): - - temp_list = list() - # handle error when metric values are equal for both algorithms - if set1.equals(set2): # Check if all nums are equal in sets - result = ['NA', 1] - else: - try: - result = fn(set1, set2) - except Exception: - result = ['NA_error', 1] - # Summarize test information in list - temp_list.append(str(metric)) - temp_list.append('D' + str(x + 1)) - temp_list.append('D' + str(y + 1)) - if set1.equals(set2): - temp_list.append(result[0]) - else: - try: - temp_list.append(str(round(result[0], 6))) - except Exception: - temp_list.append(result[0]) - temp_list.append(str(round(result[1], 6))) - if result[1] < self.sig_cutoff: - temp_list.append(str('*')) - else: - temp_list.append(str('')) - - return temp_list diff --git a/streamline/postanalysis/gererate_report.py b/streamline/postanalysis/gererate_report.py deleted file mode 100644 index c333db21..00000000 --- a/streamline/postanalysis/gererate_report.py +++ /dev/null @@ -1,1516 +0,0 @@ -import glob -import logging -import math -import os -import pickle -import csv -from datetime import datetime -from pathlib import Path - -from streamline import __version__ as version -import pandas as pd -from fpdf import FPDF - -from streamline.modeling.utils import ABBREVIATION, COLORS, is_supported_model, SUPPORTED_MODELS -from streamline.utils.job import Job - - -class ReportJob(Job): - """ - This 'Job' script is called by PDF_ReportMain.py which generates a formatted PDF summary report of key - pipeline results It is run once for the whole pipeline analysis. - """ - - def __init__(self, output_path=None, experiment_name=None, experiment_path=None, algorithms=None, - exclude=("XCS", "eLCS"), - training=True, data_path=None, rep_data_path=None, load_algo=True): - super().__init__() - self.time = None - assert (output_path is not None and experiment_name is not None) or (experiment_path is not None) - if output_path is not None and experiment_name is not None: - self.output_path = output_path - self.experiment_name = experiment_name - self.experiment_path = self.output_path + '/' + self.experiment_name - else: - self.experiment_path = experiment_path - self.experiment_name = self.experiment_path.split('/')[-1] - self.output_path = self.experiment_path.split('/')[-2] - - self.training = training - - self.train_name = None - # Find folders inside directory - if self.training: - self.datasets = os.listdir(self.experiment_path) - remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle', - 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs', - 'KeyFileCopy', 'dask_logs', - experiment_name + '_STREAMLINE_Report.pdf'] - for item in remove_list: - if item in self.datasets: - self.datasets.remove(item) - if '.idea' in self.datasets: - self.datasets.remove('.idea') - self.datasets = sorted(self.datasets) - else: - self.train_name = data_path.split('/')[-1].split('.')[0] - self.datasets = [] - for dataset_filename in glob.glob(rep_data_path + '/*'): - dataset_filename = str(Path(dataset_filename).as_posix()) - # dataset_filename = str(dataset_filename).replace('\\', '/') - # Save unique dataset names so that analysis is run only once if there is both a - # .txt and .csv version of dataset with same name. - apply_name = dataset_filename.split('/')[-1].split('.')[0] - self.datasets.append(apply_name) - self.datasets = sorted(self.datasets) - - dataset_directory_paths = [] - for dataset in self.datasets: - full_path = self.experiment_path + "/" + dataset - dataset_directory_paths.append(full_path) - - self.dataset_directory_paths = dataset_directory_paths - - if algorithms is None: - self.algorithms = SUPPORTED_MODELS - if exclude is not None: - for algorithm in exclude: - try: - self.algorithms.remove(algorithm) - except Exception: - Exception("Unknown algorithm in exclude: " + str(algorithm)) - else: - self.algorithms = list() - for algorithm in algorithms: - self.algorithms.append(is_supported_model(algorithm)) - - # Unpickle metadata from previous phase - file = open(self.experiment_path + '/' + "metadata.pickle", 'rb') - self.metadata = pickle.load(file) - file.close() - - file = open(self.experiment_path + '/' + "algInfo.pickle", 'rb') - self.alg_info = pickle.load(file) - file.close() - # self.metadata = {} - - if load_algo: - temp_algo = [] - for key in self.alg_info: - if self.alg_info[key][0]: - temp_algo.append(key) - self.algorithms = temp_algo - - self.abbrev = dict((k, ABBREVIATION[k]) for k in self.algorithms if k in ABBREVIATION) - self.colors = dict((k, COLORS[k]) for k in self.algorithms if k in COLORS) - self.metrics = None - - self.analysis_report = FPDF('P', 'mm', 'A4') - - def run(self): - self.job() - - def job(self): - - self.job_start_time = datetime.now() - self.time = datetime.now() - - # Turn metadata dictionary into text list - ars_dic = [] - for key in self.metadata: - ars_dic.append(str(key) + ':') - ars_dic.append(str(self.metadata[key])) - ars_dic.append('\n') - - # Turn alg_info dictionary into text list - ars_dic_2 = [] - for key in sorted(self.alg_info.keys()): - ars_dic_2.append(str(key) + ':') - ars_dic_2.append(str(self.alg_info[key][0])) - ars_dic_2.append('\n') - - # Analysis Settings, Global Analysis Settings, ML Modeling Algorithms - self.analysis_report.set_margins(left=10, top=5, right=10, ) - self.analysis_report.add_page(orientation='P') - - # PDF page dimension reference - # page width = 210 and page height down to start of footer = 285 (these are estimates) - # FRONT PAGE - Summary of Pipeline settings - # ------------------------------------------------------------------------------------------------------- - logging.info("Starting Report") - - targetdata = ars_dic[0:27] # Data-path to Specified Quantitative Features - cv = ars_dic[27:33] # cv partitions to partition Method - cat_cut = ars_dic[33:36] # categorical cutoff - stat_cut = ars_dic[36:39] # statistical significance cutoff - process = ars_dic[39:54] # feature missingness cutoff to list of exploratory plots saved - general = ars_dic[54:60] # random seed to run from notebooks - process2 = ars_dic[60:69] # use data scaling to use multivariate imputation - featsel = ars_dic[69:96] # use mutual info to export feature importance plots - overwrite = ars_dic[96:99] # overwrite cv - modeling = ars_dic[99:117] # primary metric to export hyperparameter sweep plots - lcs = ars_dic[117:132] - stats = ars_dic[132:153] - - #targetdata = ars_dic[0:21] # Data-path to instance label - #cv = ars_dic[21:27] # cv partitions to partition Method - #match = ars_dic[27:30] # match label - #cat_cut = ars_dic[30:33] # categorical cutoff - #stat_cut = ars_dic[33:36] # statistical significance cutoff - #process = ars_dic[36:51] # feature missingness cutoff to list of exploratory plots saved - #general = ars_dic[51:57] # random seed to run from notebooks - #process2 = ars_dic[57:66] # use data scaling to use multivariate imputation - #featsel = ars_dic[66:93] # use mutual info to export feature importance plots - #overwrite = ars_dic[93:96] # overwrite cv - #modeling = ars_dic[96:114] # primary metric to export hyperparameter sweep plots - #lcs = ars_dic[114:129] - #stats = ars_dic[129:150] - - ls2 = ars_dic_2 - # Report Title - self.analysis_report.set_font('Times', 'B', 12) - if self.training: - self.analysis_report.cell(w=180, h=8, txt='STREAMLINE Testing Data Evaluation Report: ' + str(self.time), ln=2, - border=1, align='L') - else: - self.analysis_report.cell(w=180, h=8, txt='STREAMLINE Replication Data Evaluation Report: ' + str(self.time), - ln=2, border=1, align='L') - - self.analysis_report.y += 2 # Margin below page header - - #Begin Settings - top_of_list = self.analysis_report.y # Page height for start of algorithm settings - self.analysis_report.set_font('Times', 'B', 9) - self.analysis_report.multi_cell(w=69, h=4, txt='General Pipeline Settings:', border=1, align='L') - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 7) - self.analysis_report.multi_cell(w=69, h=4, - txt=' ' + list_to_string(cv) + ' ' + list_to_string( - cat_cut) + ' ' + list_to_string(stat_cut) + ' ' + list_to_string( - general), - border=1, align='L') - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', 'B', 9) - self.analysis_report.multi_cell(w=69, h=4, txt='Feature Importance/Selection Settings:', border=1, align='L') - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 7) - self.analysis_report.multi_cell(w=69, h=4, - txt=' ' + list_to_string(featsel), - border=1, align='L') - - self.analysis_report.set_font('Times', 'B', 9) - self.analysis_report.multi_cell(w=69, h=4, txt='ML Modeling Algorithms:', border=1, align='L') - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 7) - self.analysis_report.multi_cell(w=69, h=4, txt=' ' + list_to_string(ls2), border=1, align='L') - self.analysis_report.y += 1 - - self.analysis_report.set_font('Times', 'B', 9) - self.analysis_report.multi_cell(w=69, h=4, txt='Modeling Settings:', border=1, align='L') - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 7) - self.analysis_report.multi_cell(w=69, h=4, txt=' ' + list_to_string(modeling), border=1, align='L') - self.analysis_report.y += 1 - - self.analysis_report.set_font('Times', 'B', 9) - self.analysis_report.multi_cell(w=69, h=4, txt='LCS Settings (eLCS,XCS,ExSTraCS):', border=1, align='L') - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 7) - self.analysis_report.multi_cell(w=69, h=4, txt=' ' + list_to_string(lcs), border=1, align='L') - self.analysis_report.y += 1 - - self.analysis_report.set_font('Times', 'B', 9) - self.analysis_report.multi_cell(w=69, h=4, txt='Stats and Figure Settings:', border=1, align='L') - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 7) - self.analysis_report.multi_cell(w=69, h=4, txt=' ' + list_to_string(stats), border=1, align='L') - - self.analysis_report.x += 70 - self.analysis_report.y = top_of_list # 96 - self.analysis_report.set_font('Times', 'B', 9) - self.analysis_report.multi_cell(w=110, h=4, txt='EDA and Processing Settings:', border=1, align='L') - self.analysis_report.x += 70 - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 7) - self.analysis_report.multi_cell(w=110, h=4, - txt=' ' + list_to_string(process) + ' ' + list_to_string( - process2) + ' ' + list_to_string(overwrite), - border=1, align='L') - self.analysis_report.y += 1 # Space below section header - self.analysis_report.x += 70 - if self.training: - # Get names of self.datasets run in analysis - list_datasets = '' - i = 1 - for each in self.datasets: - list_datasets = list_datasets + ('D' + str(i) + ' = ' + str(each) + '\n') - i += 1 - # Report self.datasets - self.analysis_report.set_font('Times', 'B', 9) - self.analysis_report.multi_cell(w=110, h=4, txt='Target Dataset(s):', border=1, align='L') - self.analysis_report.x += 70 - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 7) - self.analysis_report.multi_cell(w=110, h=4, txt=list_datasets, border=1, align='L') - else: - list_datasets = '' - i = 1 - for each in self.datasets: - list_datasets = list_datasets + ('D' + str(i) + ' = ' + str(each) + '\n') - i += 1 - self.analysis_report.set_font('Times', 'B', 9) - self.analysis_report.multi_cell(w=110, h=4, txt='Target Training Dataset:', border=1, align='L') - self.analysis_report.x += 70 - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 7) - self.analysis_report.multi_cell(w=110, h=4, txt=self.train_name, border=1, align='L') - - #self.analysis_report.y += 5 - #self.analysis_report.x = 70 #10 - self.analysis_report.x += 70 - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', 'B', 9) - - self.analysis_report.multi_cell(w=110, h=4, txt='Applied to Following Replication Dataset(s):', border=1, align='L') - self.analysis_report.x += 70 - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 7) - self.analysis_report.multi_cell(w=110, h=4, txt= list_datasets, border=1, align='L') - #self.analysis_report.multi_cell(w=180, h=4, txt='Applied to Following Replication Dataset(s): ' + '\n' + list_datasets, border=1, align='L') - - self.analysis_report.x += 70 - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', 'B', 9) - self.analysis_report.multi_cell(w=110, h=4, txt='Target Data Settings:', border=1, align='L') - self.analysis_report.x += 70 - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 7) - self.analysis_report.multi_cell(w=110, h=4, - txt=' ' + list_to_string(targetdata), - border=1, align='L') - - - #self.analysis_report.y += 2 # Margin below Datasets - #self.analysis_report.y += 2 # Margin below Datasets - - #self.analysis_report.set_font('Times', 'B', 10) - #self.analysis_report.cell(w=180, h=4, txt='STREAMLINE Run Settings', ln=2, border=1, align='L') - - - #bottom_of_list = self.analysis_report.y - #self.analysis_report.y = bottom_of_list + 2 - - - """ - try_again = True - try: - self.analysis_report.image('info/Pictures/STREAMLINE_LOGO.png', 102, 150, 90) - try_again = False - except Exception: - pass - if try_again: - try: # Running on Google Colab - self.analysis_report.image('/content/drive/MyDrive/STREAMLINE/info/Pictures/STREAMLINE_LOGO.png', 102, 150, - 90) - except Exception: - pass - """ - - - - """ - ls1 = ars_dic[0:87] # DataPath to OverwriteCVDatasets - filter poor [0:87] - # ls2 = ars_dic[87:132] # ML modeling algorithms (NaiveB - ExSTraCS) [87:132] - ls2 = ars_dic_2 - ls3 = ars_dic[87:105] # primary metric - Export Hyperparameter SweepPLot [132:150] - ls4 = ars_dic[105:129] # DoLCS Hyperparameter Sweep LCS hyper-sweep timeout) [150:165] - ls5 = ars_dic[129:147] # ExportROCPlot to Top Model Features to Display [165:180] - - self.analysis_report.set_font('Times', 'B', 12) - if self.training: - self.analysis_report.cell(w=180, h=8, txt='STREAMLINE Testing Evaluation Report: ' + str(self.time), ln=2, - border=1, align='L') - else: - self.analysis_report.cell(w=180, h=8, txt='STREAMLINE Replication Evaluation Report: ' + str(self.time), - ln=2, border=1, align='L') - self.analysis_report.y += 2 # Margin below page header - top_of_list = self.analysis_report.y # Page height for start of algorithm settings - self.analysis_report.set_font('Times', 'B', 10) - self.analysis_report.multi_cell(w=90, h=4, txt='General Pipeline Settings:', border=1, align='L') - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 8) - self.analysis_report.multi_cell(w=90, h=4, - txt=' ' + list_to_string(ls1) + ' ' + list_to_string( - ls3) + ' ' + list_to_string( - ls5), - border=1, align='L') - bottom_of_list = self.analysis_report.y - self.analysis_report.x += 90 - self.analysis_report.y = top_of_list # 96 - self.analysis_report.set_font('Times', 'B', 10) - self.analysis_report.multi_cell(w=90, h=4, txt='ML Modeling Algorithms:', border=1, align='L') - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 8) - self.analysis_report.x += 90 - self.analysis_report.multi_cell(w=90, h=4, txt=' ' + list_to_string(ls2), border=1, align='L') - self.analysis_report.x += 90 - self.analysis_report.y += 2 - self.analysis_report.set_font('Times', 'B', 10) - self.analysis_report.multi_cell(w=90, h=4, txt='LCS Settings (eLCS,XCS,ExSTraCS):', border=1, align='L') - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 8) - self.analysis_report.x += 90 - self.analysis_report.multi_cell(w=90, h=4, txt=' ' + list_to_string(ls4), border=1, align='L') - self.analysis_report.y = bottom_of_list + 2 - - try_again = True - try: - self.analysis_report.image('info/Pictures/STREAMLINE_LOGO.png', 102, 150, 90) - try_again = False - except Exception: - pass - if try_again: - try: # Running on Google Colab - self.analysis_report.image('/content/drive/MyDrive/STREAMLINE/info/Pictures/STREAMLINE_LOGO.png', 102, 150, - 90) - except Exception: - pass - - if self.training: - # Get names of self.datasets run in analysis - list_datasets = '' - i = 1 - for each in self.datasets: - list_datasets = list_datasets + ('D' + str(i) + ' = ' + str(each) + '\n') - i += 1 - # Report self.datasets - self.analysis_report.set_font('Times', 'B', 10) - self.analysis_report.multi_cell(w=180, h=4, txt='Datasets', border=1, align='L') - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 8) - self.analysis_report.multi_cell(w=180, h=4, txt=list_datasets, border=1, align='L') - else: - self.analysis_report.cell(w=180, h=4, txt='Target Training Dataset: ' + self.train_name, border=1, - align='L') - self.analysis_report.y += 5 - self.analysis_report.x = 10 - - list_datasets = '' - i = 1 - for each in self.datasets: - list_datasets = list_datasets + ('D' + str(i) + ' = ' + str(each) + '\n') - i += 1 - self.analysis_report.multi_cell(w=180, h=4, txt='Applied self.datasets: ' + '\n' + list_datasets, border=1, - align='L') - """ - self.footer() - - # NEXT PAGE(S) - Exploratory Univariate Analysis for each Dataset - # ------------------------------------------------------------------ - if self.training: - logging.info("Publishing Univariate Analysis") - result_limit = 5 # Limits to this many dataset results per page - dataset_count = len(self.datasets) - # Determine number of pages needed for univariate results - page_count = dataset_count / float(result_limit) - page_count = math.ceil(page_count) # rounds up to next full integer - for page in range(0, page_count): # generate each page - self.pub_univariate(page, result_limit, page_count) - - # NEXT PAGE(S) Data and Model Prediction Summary - # -------------------------------------------------------------------------------------- - M = None - logging.info("Publishing Model Prediction Summary") - for m in range(len(self.datasets)): - M = m - # Create PDF and Set Options - self.analysis_report.set_margins(left=1, top=1, right=1, ) - self.analysis_report.add_page() - self.analysis_report.set_font('Times', 'B', 12) - self.analysis_report.cell(w=0, h=8, - txt="Dataset and Model Prediction Summary: D" + str(m + 1) + " = " + - self.datasets[m], - border=1, align="L", ln=2) - self.analysis_report.set_font(family='times', size=8) - - # Exploratory Analysis ---------------------------- - # Image placement notes: - # upper left hand coordinates (x,y), then image width then height (image fit to space) - # upper left hand coordinates (x,y), then image width with height based on image dimensions - # (retain original image ratio) - - # Insert Data Processing Count Summary - self.analysis_report.set_font('Times', 'B', 10) - self.analysis_report.x = 1 - self.analysis_report.y = 10 - self.analysis_report.cell(119, 4, 'Data Processing/Counts Summary', 1, align="L") - - self.analysis_report.x = 1 - self.analysis_report.y = 15 - self.analysis_report.set_font('Times', '', 7) - self.analysis_report.set_fill_color(200) - - if self.training: - data_process_path = self.experiment_path + '/' + self.datasets[ - m] + "/exploratory/DataProcessSummary.csv" - else: - data_process_path = self.experiment_path + '/' + self.train_name + '/replication/' + self.datasets[ - m] + "/exploratory/DataProcessSummary.csv" - - table1 = [] # Initialize an empty list to store the data - - with open(data_process_path, "r") as csv_file: - csv_reader = csv.reader(csv_file) - for row in csv_reader: - table1.append(row) - # Format - # data_summary = data_summary.round(3) - th = self.analysis_report.font_size - col_width_list = [13, 13, 13, 14, 14, 13, 13, 13, 13] # 91 x space total - - # Print table header first - row_count = 0 - col_count = 0 - previous_row = None - - for row in table1: # each row - # Make header - if row_count == 0: - for datum in row: # Print first row - entry_list = str(datum).split(' ') - self.analysis_report.cell(col_width_list[col_count], th, entry_list[0], border=0, align="C") - col_count += 1 - self.analysis_report.ln(th) # critical - col_count = 0 - for datum in row: # Print second row - entry_list = str(datum).split(' ') - try: - self.analysis_report.cell(col_width_list[col_count], th, entry_list[1], border=0, align="C") - except Exception: - self.analysis_report.cell(col_width_list[col_count], th, ' ', border=0, align="C") - col_count += 1 - self.analysis_report.ln(th) # critical - col_count = 0 - # Fill in data - elif row_count == 1: - previous_row = row - for datum in row: - if col_count == 0: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1, align="L", - fill=True) - elif col_count == 6: # missing percent column - self.analysis_report.cell(col_width_list[col_count], th, str(round(float(datum), 4)), - border=1, align="L", fill=True) - else: - self.analysis_report.cell(col_width_list[col_count], th, str(int(float(datum))), border=1, - align="L", fill=True) - col_count += 1 - self.analysis_report.ln(th) # critical - col_count = 0 - else: - for datum in row: - if col_count == 0: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1, align="L") - elif str(previous_row[col_count]) == str(row[col_count]): # Value unchanged - if col_count == 6: # missing percent column - self.analysis_report.cell(col_width_list[col_count], th, str(round(float(datum), 4)), - border=1, align="L") - else: - self.analysis_report.cell(col_width_list[col_count], th, str(int(float(datum))), - border=1, align="L") - else: - if col_count == 6: # missing percent column - self.analysis_report.cell(col_width_list[col_count], th, str(round(float(datum), 4)), - border=1, align="L", fill=True) - else: - self.analysis_report.cell(col_width_list[col_count], th, str(int(float(datum))), - border=1, align="L", fill=True) - col_count += 1 - self.analysis_report.ln(th) # critical - col_count = 0 - previous_row = row - row_count += 1 - row_count -= 1 - for datum in table1[row_count]: - if col_count == 0: - self.analysis_report.cell(col_width_list[col_count], th, 'Processed', border=1, align="L", - fill=True) - else: - if col_count == 6: # missing percent column - self.analysis_report.cell(col_width_list[col_count], th, str(round(float(datum), 4)), border=1, - align="L", fill=True) - else: - self.analysis_report.cell(col_width_list[col_count], th, str(int(float(datum))), border=1, - align="L", fill=True) - col_count += 1 - if self.training: - self.analysis_report.set_font('Times', 'B', 8) - self.analysis_report.x = 1 - self.analysis_report.y = 41 - self.analysis_report.cell(90, 4, 'Cleaning (C) and Engineering (E) Elements', 0, align="L") - self.analysis_report.set_font('Times', '', 7) - self.analysis_report.ln(th) # critical - self.analysis_report.cell(90, 4, ' * C1 - Remove instances with no outcome and features to ignore', 0, - align="L") - self.analysis_report.ln(th) # critical - self.analysis_report.cell(90, 4, ' * E1 - Add missingness features', - 0, align="L") - self.analysis_report.ln(th) # critical - self.analysis_report.cell(90, 4, ' * C2 - Remove features with invariance or high missingness', 0, align="L") - self.analysis_report.ln(th) # critical - self.analysis_report.cell(90, 4, ' * C3 - Remove instances with high missingness', 0, align="L") - self.analysis_report.ln(th) # critical - self.analysis_report.cell(90, 4, ' * E2 - Add one-hot-encoding of categorical features', 0, align="L") - self.analysis_report.ln(th) # critical - self.analysis_report.cell(90, 4, ' * C4 - Remove highly correlated features', 0, align="L") - else: - self.analysis_report.set_font('Times', 'B', 8) - self.analysis_report.x = 1 - self.analysis_report.y = 41 - self.analysis_report.cell(90, 4, 'Cleaning (C) and Replication (R) Elements', 0, align="L") - self.analysis_report.set_font('Times', '', 7) - self.analysis_report.ln(th) # critical - self.analysis_report.cell(90, 4, ' * C1 - Remove instances with no outcome', 0, - align="L") - self.analysis_report.ln(th) # critical - self.analysis_report.cell(90, 4, ' * R1 - Add/remove same features as Phase 1', - 0, align="L") - - # Insert Class Imbalance barplot - self.analysis_report.set_font('Times', 'B', 10) - self.analysis_report.x = 70 - self.analysis_report.y = 42 - self.analysis_report.cell(45, 4, 'Class Balance (Processed)', 1, align="L") - self.analysis_report.set_font('Times', '', 8) - if self.training: - self.analysis_report.image( - self.experiment_path + '/' + self.datasets[m] + '/exploratory/ClassCountsBarPlot.png', 68, 47, 45, - 35) - # upper left hand coordinates (x,y), then image width then height (image fit to space) - else: - self.analysis_report.image( - self.experiment_path + '/' + self.train_name + '/replication/' + self.datasets[ - m] + '/exploratory/ClassCountsBarPlot.png', 68, 47, 45, 35) - # upper left hand coordinates (x,y), then image width then height (image fit to space) - - # Insert Feature Correlation Plot - try: - self.analysis_report.set_font('Times', 'B', 10) - self.analysis_report.x = 143 - self.analysis_report.y = 42 - self.analysis_report.cell(50, 4, 'Feature Correlations (Pearson)', 1, align="L") - self.analysis_report.set_font('Times', '', 8) - if self.training: - self.analysis_report.image( - self.experiment_path + '/' + self.datasets[m] + '/exploratory/FeatureCorrelations.png', - 120, 47, 89, 70) - # self.experiment_path + '/' + self.datasets[m] + '/exploratory/FeatureCorrelations.png', - # 85, 15, 125, 100) - # upper left hand coordinates (x,y), - # then image width with hight based on image dimensions (retain original image ratio) - else: - self.analysis_report.image( - self.experiment_path + '/' + self.train_name + '/replication/' + self.datasets[ - m] + '/exploratory/FeatureCorrelations.png', 120, 47, 89, 70) - # self.experiment_path + '/' + self.train_name + '/applymodel/' + self.datasets[ - # m] + '/exploratory/FeatureCorrelations.png', 85, 15, 125, 100) - # upper left hand coordinates (x,y), - # then image width with hight based on image dimensions (retain original image ratio) - except Exception: - self.analysis_report.x = 135 - self.analysis_report.y = 60 - self.analysis_report.cell(35, 4, 'No Feature Correlation Plot', 1, align="L") - pass - - """ #REMOVED FOR REFORMATTING - if self.training: - data_summary = pd.read_csv( - self.experiment_path + '/' + self.datasets[m] + "/exploratory/DataCounts.csv") - else: - data_summary = pd.read_csv( - self.experiment_path + '/' + self.train_name + '/applymodel/' + self.datasets[ - m] + "/exploratory/DataCounts.csv") - info_ls = [] - for i in range(len(data_summary)): - info_ls.append(data_summary.iloc[i, 0] + ': ') - info_ls.append(str(data_summary.iloc[i, 1])) - info_ls.append('\n') - self.analysis_report.x = 1 - self.analysis_report.y = 52 - self.analysis_report.set_font('Times', 'B', 8) - self.analysis_report.multi_cell(w=60, h=4, txt='Dataset Counts Summary:', border=1, align='L') - self.analysis_report.set_font('Times', '', 8) - self.analysis_report.multi_cell(w=60, h=4, txt=' ' + list_to_string(info_ls), border=1, align='L') - """ - - # Report Best Algorithms by metric - if self.training: - summary_performance = pd.read_csv( - self.experiment_path + '/' + self.datasets[m] + "/model_evaluation/Summary_performance_mean.csv") - else: - summary_performance = pd.read_csv( - self.experiment_path + '/' + self.train_name + '/replication/' + self.datasets[ - m] + "/model_evaluation/Summary_performance_mean.csv") - summary_performance['ROC AUC'] = summary_performance['ROC AUC'].astype(float) - highest_roc = summary_performance['ROC AUC'].max() - algorithm = summary_performance[summary_performance['ROC AUC'] == highest_roc].index.values - best_alg_roc = summary_performance.iloc[algorithm, 0] - - summary_performance['Balanced Accuracy'] = summary_performance['Balanced Accuracy'].astype(float) - highest_ba = summary_performance['Balanced Accuracy'].max() - algorithm = summary_performance[summary_performance['Balanced Accuracy'] == highest_ba].index.values - best_alg_ba = summary_performance.iloc[algorithm, 0] - - summary_performance['F1 Score'] = summary_performance['F1 Score'].astype(float) - highest_f1 = summary_performance['F1 Score'].max() - algorithm = summary_performance[summary_performance['F1 Score'] == highest_f1].index.values - best_alg_f1 = summary_performance.iloc[algorithm, 0] - - summary_performance['PRC AUC'] = summary_performance['PRC AUC'].astype(float) - highest_prc = summary_performance['PRC AUC'].max() - algorithm = summary_performance[summary_performance['PRC AUC'] == highest_prc].index.values - best_alg_prc = summary_performance.iloc[algorithm, 0] - - summary_performance['PRC APS'] = summary_performance['PRC APS'].astype(float) - highest_aps = summary_performance['PRC APS'].max() - algorithm = summary_performance[summary_performance['PRC APS'] == highest_aps].index.values - best_alg_aps = summary_performance.iloc[algorithm, 0] - - self.analysis_report.x = 1 - self.analysis_report.y = 85 - self.analysis_report.set_font('Times', 'B', 8) - self.analysis_report.multi_cell(w=80, h=4, txt='Top ML Algorithm Results (Averaged Over CV Runs):', - border=1, - align='L') - self.analysis_report.set_font('Times', '', 8) - - if len(best_alg_roc.values) > 1: - self.analysis_report.multi_cell(w=80, h=4, - txt="Best (ROC_AUC): " + str( - best_alg_roc.values[0]) + ' (TIE) = ' + str( - "{:.3f}".format(highest_roc)), border=1, align='L') - else: - self.analysis_report.multi_cell(w=80, h=4, - txt="Best (ROC_AUC): " + str(best_alg_roc.values[0]) + ' = ' + str( - "{:.3f}".format(highest_roc)), border=1, align='L') - - if len(best_alg_ba.values) > 1: - self.analysis_report.multi_cell(w=80, h=4, - txt="Best (Balanced Acc.): " + str( - best_alg_ba.values[0]) + ' (TIE) = ' + str( - "{:.3f}".format(highest_ba)), border=1, align='L') - else: - self.analysis_report.multi_cell(w=80, h=4, - txt="Best (Balanced Acc.): " + str(best_alg_ba.values[0]) + ' = ' + str( - "{:.3f}".format(highest_ba)), border=1, align='L') - - if len(best_alg_f1.values) > 1: - self.analysis_report.multi_cell(w=80, h=4, - txt="Best (F1 Score): " + str( - best_alg_f1.values[0]) + ' (TIE) = ' + str( - "{:.3f}".format(highest_f1)), border=1, align='L') - else: - self.analysis_report.multi_cell(w=80, h=4, - txt="Best (F1 Score): " + str(best_alg_f1.values[0]) + ' = ' + str( - "{:.3f}".format(highest_f1)), border=1, align='L') - - if len(best_alg_prc.values) > 1: - self.analysis_report.multi_cell(w=80, h=4, - txt="Best (PRC AUC): " + str( - best_alg_prc.values[0]) + ' (TIE) = ' + str( - "{:.3f}".format(highest_prc)), border=1, align='L') - else: - self.analysis_report.multi_cell(w=80, h=4, - txt="Best (PRC AUC): " + str(best_alg_prc.values[0]) + ' = ' + str( - "{:.3f}".format(highest_prc)), border=1, align='L') - - if len(best_alg_aps.values) > 1: - self.analysis_report.multi_cell(w=80, h=4, - txt="Best (PRC APS): " + str( - best_alg_aps.values[0]) + ' (TIE) = ' + str( - "{:.3f}".format(highest_aps)), border=1, align='L') - else: - self.analysis_report.multi_cell(w=80, h=4, - txt="Best (PRC APS): " + str(best_alg_aps.values[0]) + ' = ' + str( - "{:.3f}".format(highest_aps)), border=1, align='L') - - # self.analysis_report.multi_cell( - # w=80, h=4, - # txt="Best (ROC_AUC): " - # + str(best_alg_roc.values) + ' = ' - # + str("{:.3f}".format(highest_roc)) - # + '\n' + "Best (Balanced Acc.): " - # + str(best_alg_ba.values) - # + ' = ' + str("{:.3f}".format(highest_ba)) - # + '\n' + "Best (F1 Score): " - # + str(best_alg_f1.values) + ' = ' - # + str("{:.3f}".format(highest_f1)) - # + '\n' + "Best (PRC AUC): " - # + str(best_alg_prc.values) + ' = ' - # + str("{:.3f}".format(highest_prc)) - # + '\n' + "Best (PRC APS): " - # + str(best_alg_aps.values) + ' = ' - # + str("{:.3f}".format(highest_aps)), border=1, align='L') - - self.analysis_report.set_font('Times', 'B', 10) - # ROC - # ------------------------------- - self.analysis_report.x = 1 - self.analysis_report.y = 112 - self.analysis_report.cell(10, 4, 'ROC', 1, align="L") - if self.training: - self.analysis_report.image( - self.experiment_path + '/' + self.datasets[m] + '/model_evaluation/Summary_ROC.png', 4, 118, - 120) - self.analysis_report.image( - self.experiment_path + '/' + self.datasets[ - m] + '/model_evaluation/metricBoxplots/Compare_ROC AUC.png', 124, - 118, - 82, 85) - else: - self.analysis_report.image( - self.experiment_path + '/' + self.train_name + '/replication/' + self.datasets[ - m] + '/model_evaluation/Summary_ROC.png', - 4, 118, 120) - self.analysis_report.image( - self.experiment_path + '/' + self.train_name + '/replication/' + self.datasets[ - m] + '/model_evaluation/metricBoxplots/Compare_ROC AUC.png', 124, 118, 82, 85) - - # PRC------------------------------- - self.analysis_report.x = 1 - self.analysis_report.y = 200 - self.analysis_report.cell(10, 4, 'PRC', 1, align="L") - if self.training: - self.analysis_report.image( - self.experiment_path + '/' + self.datasets[m] + '/model_evaluation/Summary_PRC.png', 4, 206, - 133) # wider to account for more text - self.analysis_report.image( - self.experiment_path + '/' + self.datasets[ - m] + '/model_evaluation/metricBoxplots/Compare_PRC AUC.png', 138, - 205, - 68, 80) - else: - self.analysis_report.image( - self.experiment_path + '/' + self.train_name + '/replication/' + self.datasets[ - m] + '/model_evaluation/Summary_PRC.png', - 4, 206, 133) # wider to account for more text - self.analysis_report.image( - self.experiment_path + '/' + self.train_name + '/replication/' + self.datasets[ - m] + '/model_evaluation/metricBoxplots/Compare_PRC AUC.png', 138, 205, 68, 80) - self.footer() - - # NEXT PAGE(S) - Average Model Prediction Statistics - # -------------------------------------------------------------------------------------- - logging.info("Publishing Average Model Prediction Statistics") - result_limit = 5 # Limits to this many dataset results per page - dataset_count = len(self.datasets) - # Determine number of pages needed for univariate results - page_count = dataset_count / float(result_limit) - page_count = math.ceil(page_count) # rounds up to next full integer - self.analysis_report.set_fill_color(200) - for page in range(0, page_count): # generate each page - self.pub_model_mean_stats(page, result_limit, page_count) - - # NEXT PAGE(S) - Median Model Prediction Statistics - # -------------------------------------------------------------------------------------- - logging.info("Publishing Median Model Prediction Statistics") - result_limit = 5 # Limits to this many dataset results per page - dataset_count = len(self.datasets) - # Determine number of pages needed for univariate results - page_count = dataset_count / float(result_limit) - page_count = math.ceil(page_count) # rounds up to next full integer - self.analysis_report.set_fill_color(200) - for page in range(0, page_count): # generate each page - self.pub_model_median_stats(page, result_limit, page_count) - - # NEXT PAGE(S) - ML Dataset Feature Importance Summary - # ---------------------------------------------------------------- - if self.training: - logging.info("Publishing Feature Importance Summaries") - for k in range(len(self.datasets)): - self.analysis_report.add_page() - self.analysis_report.set_font('Times', 'B', 12) - self.analysis_report.cell(w=0, h=8, - txt="Feature Importance Summary: D" + str(k + 1) + ' = ' + self.datasets[k], - border=1, align="L", ln=2) - self.analysis_report.set_font(family='times', size=9) - self.analysis_report.image( - self.experiment_path + '/' + self.datasets[ - k] + '/feature_selection/mutual_information/TopAverageScores.png', - 5, - 12, 100, 135) # Images adjusted to fit a width of 100 and length of 135 - self.analysis_report.image( - self.experiment_path + '/' + self.datasets[k] + '/feature_selection/multisurf/TopAverageScores.png', - 105, 12, - 100, - 135) - self.analysis_report.x = 0 - self.analysis_report.y = 150 - self.analysis_report.cell(0, 8, - "Composite Feature Importance Plot (Normalized and Performance Weighted)", 1, - align="L") - self.analysis_report.image( - self.experiment_path + '/' + self.datasets[ - k] + '/model_evaluation/feature_importance/Compare_FI_Norm_Weight.png', - 1, 159, 208, 125) # 130 added - self.footer() - - # NEXT PAGE - Create Dataset Boxplot Comparison Page - # --------------------------------------- - if self.training: - logging.info("Publishing Dataset Comparison Boxplots") - self.analysis_report.add_page() - self.analysis_report.set_font('Times', 'B', 12) - self.analysis_report.cell(w=0, h=8, txt="Compare ML Performance Across Datasets", border=1, align="L", - ln=2) - self.analysis_report.set_font(family='times', size=9) - if len(self.datasets) > 1: - self.analysis_report.image( - self.experiment_path + '/DatasetComparisons/dataCompBoxplots/' + 'DataCompareAllModels_ROC AUC.png', - 1, - 12, - 208, 130) # Images adjusted to fit a width of 100 and length of 135 - self.analysis_report.image( - self.experiment_path + '/DatasetComparisons/dataCompBoxplots/' + 'DataCompareAllModels_PRC AUC.png', - 1, - 150, - 208, 130) # Images adjusted to fit a width of 100 and length of 135 - self.footer() - - # NEXT PAGE(S) -Create Best Kruskall Wallis Dataset Comparison Page - # --------------------------------------- - if self.training: - logging.info("Publishing Statistical Analysis") - self.analysis_report.add_page(orientation='P') - self.analysis_report.set_margins(left=1, top=10, right=1, ) - - d = [] - for i in range(len(self.datasets)): - d.append('Data ' + str(i + 1) + '= ' + self.datasets[i]) - d.append('\n') - - self.analysis_report.set_font('Times', 'B', 12) - if len(self.datasets) < 19: - self.analysis_report.cell(w=0, h=8, - txt='Using Best Performing Algorithms (Kruskall Wallis Compare Datasets)', - border=1, align="L", ln=2) - else: - self.analysis_report.cell(w=0, h=8, - txt='Using Best Performing Algorithms (Kruskall Wallis Compare Datasets): Page 1', - border=1, align="L", ln=2) - self.analysis_report.set_font(family='times', size=7) - - # Dataset list Key - #list_datasets = '' - #i = 1 - #for each in self.datasets: - # list_datasets = list_datasets + ('D' + str(i) + ' = ' + str(each) + '\n') - # i += 1 - #self.analysis_report.x = 5 - #self.analysis_report.y = 14 - #self.analysis_report.multi_cell(w=0, h=4, txt='Datasets: ' + '\n' + list_datasets, border=1, align='L') - self.analysis_report.y += 2 - - success = False - kruskal_wallis_datasets = None - try: - # Kruskal Wallis Table - # A table can take at most 4 self.datasets to fit comfortably with these settings - kruskal_wallis_datasets = pd.read_csv(self.experiment_path + '/DatasetComparisons/' + - 'BestCompare_KruskalWallis.csv', sep=',', index_col=0) - kruskal_wallis_datasets = kruskal_wallis_datasets.round(4) - success = True - except Exception: - pass - - if success: - # Process - # for i in range(len(self.datasets)): - # kruskal_wallis_datasets = kruskal_wallis_datasets.drop('Std_D'+str(i+1),1) - kruskal_wallis_datasets = kruskal_wallis_datasets.drop('Statistic', axis=1) - kruskal_wallis_datasets = kruskal_wallis_datasets.drop('Sig(*)', axis=1) - - # Format - kruskal_wallis_datasets.reset_index(inplace=True) - temp_df = pd.concat([kruskal_wallis_datasets.columns.to_frame().T, kruskal_wallis_datasets]) - temp_df.iloc[0, 0] = 'Metrics' - kruskal_wallis_datasets = temp_df - kruskal_wallis_datasets.columns = range(len(kruskal_wallis_datasets.columns)) - # epw = 208 # Amount of Space (width) Available - th = self.analysis_report.font_size - # col_width = epw/float(10) #maximum column width - col_width_list = [23, 12, 30, 16, 30, 16, 30, 16] - - if len(self.datasets) <= 3: # 4 - col_count = 0 - kruskal_wallis_datasets = kruskal_wallis_datasets.to_numpy() - for row in kruskal_wallis_datasets: - for datum in row: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1) - col_count += 1 - col_count = 0 - self.analysis_report.ln(th) # critical - else: - # Print next 3 self.datasets - col_count = 0 - table1 = kruskal_wallis_datasets.iloc[:, :8] # 10 - table1 = table1.to_numpy() - for row in table1: - for datum in row: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1) - col_count += 1 - col_count = 0 - self.analysis_report.ln(th) # critical - self.analysis_report.y += 2 - - col_count = 0 - table1 = kruskal_wallis_datasets.iloc[:, 8:14] # 10:18 - met = kruskal_wallis_datasets.iloc[:, 0] - met2 = kruskal_wallis_datasets.iloc[:, 1] - table1 = pd.concat([met, met2, table1], axis=1) - table1 = table1.to_numpy() - for row in table1: - for datum in row: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1) - col_count += 1 - col_count = 0 - self.analysis_report.ln(th) # critical - self.analysis_report.y += 2 - - if len(self.datasets) > 6: # 8 - col_count = 0 - table1 = kruskal_wallis_datasets.iloc[:, 14:20] # 18:26 - met = kruskal_wallis_datasets.iloc[:, 0] - met2 = kruskal_wallis_datasets.iloc[:, 1] - table1 = pd.concat([met, met2, table1], axis=1) - table1 = table1.to_numpy() - for row in table1: - for datum in row: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1) - col_count += 1 - col_count = 0 - self.analysis_report.ln(th) # critical - self.analysis_report.y += 2 - - if len(self.datasets) > 9: - table1 = kruskal_wallis_datasets.iloc[:, 20:26] - met = kruskal_wallis_datasets.iloc[:, 0] - met2 = kruskal_wallis_datasets.iloc[:, 1] - table1 = pd.concat([met, met2, table1], axis=1) - table1 = table1.to_numpy() - for row in table1: - for datum in row: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1) - col_count += 1 - col_count = 0 - self.analysis_report.ln(th) # critical - self.analysis_report.y += 2 - - if len(self.datasets) > 12: - table1 = kruskal_wallis_datasets.iloc[:, 26:32] - met = kruskal_wallis_datasets.iloc[:, 0] - met2 = kruskal_wallis_datasets.iloc[:, 1] - table1 = pd.concat([met, met2, table1], axis=1) - table1 = table1.to_numpy() - for row in table1: - for datum in row: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1) - col_count += 1 - col_count = 0 - self.analysis_report.ln(th) # critical - self.analysis_report.y += 2 - - if len(self.datasets) > 15: - table1 = kruskal_wallis_datasets.iloc[:, 32:38] - met = kruskal_wallis_datasets.iloc[:, 0] - met2 = kruskal_wallis_datasets.iloc[:, 1] - table1 = pd.concat([met, met2, table1], axis=1) - table1 = table1.to_numpy() - for row in table1: - for datum in row: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1) - col_count += 1 - col_count = 0 - self.analysis_report.ln(th) # critical - self.analysis_report.y += 2 - - if len(self.datasets) > 18: - self.footer() - self.analysis_report.add_page(orientation='P') - self.analysis_report.set_margins(left=1, top=10, right=1, ) - - self.analysis_report.set_font('Times', 'B', 12) - self.analysis_report.cell(w=0, h=8, - txt='Using Best Performing Algorithms (Kruskall Wallis Compare Datasets): Page 2', - border=1, align="L", ln=2) - self.analysis_report.set_font(family='times', size=7) - self.analysis_report.y += 2 - - col_count = 0 - table1 = kruskal_wallis_datasets.iloc[:, 38:44] # 18:26 - met = kruskal_wallis_datasets.iloc[:, 0] - met2 = kruskal_wallis_datasets.iloc[:, 1] - table1 = pd.concat([met, met2, table1], axis=1) - table1 = table1.to_numpy() - for row in table1: - for datum in row: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1) - col_count += 1 - col_count = 0 - self.analysis_report.ln(th) # critical - self.analysis_report.y += 2 - - if len(self.datasets) > 21: - table1 = kruskal_wallis_datasets.iloc[:, 44:50] - met = kruskal_wallis_datasets.iloc[:, 0] - met2 = kruskal_wallis_datasets.iloc[:, 1] - table1 = pd.concat([met, met2, table1], axis=1) - table1 = table1.to_numpy() - for row in table1: - for datum in row: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1) - col_count += 1 - col_count = 0 - self.analysis_report.ln(th) # critical - self.analysis_report.y += 2 - - if len(self.datasets) > 24: - table1 = kruskal_wallis_datasets.iloc[:, 50:56] - met = kruskal_wallis_datasets.iloc[:, 0] - met2 = kruskal_wallis_datasets.iloc[:, 1] - table1 = pd.concat([met, met2, table1], axis=1) - table1 = table1.to_numpy() - for row in table1: - for datum in row: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1) - col_count += 1 - col_count = 0 - self.analysis_report.ln(th) # critical - self.analysis_report.y += 2 - - if len(self.datasets) > 27: - table1 = kruskal_wallis_datasets.iloc[:, 56:62] - met = kruskal_wallis_datasets.iloc[:, 0] - met2 = kruskal_wallis_datasets.iloc[:, 1] - table1 = pd.concat([met, met2, table1], axis=1) - table1 = table1.to_numpy() - for row in table1: - for datum in row: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1) - col_count += 1 - col_count = 0 - self.analysis_report.ln(th) # critical - self.analysis_report.y += 2 - - if len(self.datasets) > 30: - table1 = kruskal_wallis_datasets.iloc[:, 62:68] - met = kruskal_wallis_datasets.iloc[:, 0] - met2 = kruskal_wallis_datasets.iloc[:, 1] - table1 = pd.concat([met, met2, table1], axis=1) - table1 = table1.to_numpy() - for row in table1: - for datum in row: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1) - col_count += 1 - col_count = 0 - self.analysis_report.ln(th) # critical - self.analysis_report.y += 2 - - if len(self.datasets) > 33: - table1 = kruskal_wallis_datasets.iloc[:, 68:74] - met = kruskal_wallis_datasets.iloc[:, 0] - met2 = kruskal_wallis_datasets.iloc[:, 1] - table1 = pd.concat([met, met2, table1], axis=1) - table1 = table1.to_numpy() - for row in table1: - for datum in row: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1) - col_count += 1 - col_count = 0 - self.analysis_report.ln(th) # critical - self.analysis_report.y += 2 - - if len(self.datasets) > 36: - self.analysis_report.x = 0 - self.analysis_report.y = 280 - self.analysis_report.cell(0, 4, 'A maximum of 36 dataset results could be displayed', 1, - align="C") - self.footer() - #self.footer() - - # LAST PAGE - Create Runtime Summary Page--------------------------------------- - if self.training: - logging.info("Publishing Runtime Summary") - result_limit = 6 # Limits to this many dataset results per page - dataset_count = len(self.datasets) - # Determine number of pages needed for univariate results - page_count = dataset_count / float(result_limit) - page_count = math.ceil(page_count) # rounds up to next full integer - for page in range(0, page_count): # generate each page - self.pub_runtime(page, result_limit, page_count) - - # Output The PDF Object - try: - if self.training: - file_name = str(self.experiment_name) + '_STREAMLINE_Report.pdf' - self.analysis_report.output(self.experiment_path + '/' + file_name) - # Print phase completion - logging.info("Phase 8 complete") - try: - job_file = open(self.experiment_path + '/jobsCompleted/job_data_pdf_training.txt', 'w') - job_file.write('complete') - job_file.close() - except Exception: - pass - else: - file_name = str(self.experiment_name) + '_STREAMLINE_Replication_Report.pdf' - self.analysis_report.output( - self.experiment_path + '/' + self.train_name + '/replication/' + self.datasets[M] + '/' + file_name) - # Print phase completion - logging.info("Phase 10 complete") - try: - job_file = open(self.experiment_path + '/jobsCompleted/job_data_pdf_apply_' + str( - self.train_name) + '.txt', - 'w') - job_file.write('complete') - job_file.close() - except Exception: - pass - except Exception: - logging.info('Pdf Output Failed') - - def pub_univariate(self, page, result_limit, page_count): - """ Generates single page of univariate analysis results. Automatically moves to another page when runs out of - space. Maximum of 4 dataset results to a page.""" - dataset_count = len(self.datasets) - data_start = page * result_limit - count_limit = (page * result_limit) + result_limit - self.analysis_report.add_page(orientation='P') - self.analysis_report.set_font('Times', 'B', 12) - if page_count > 1: - self.analysis_report.cell(w=180, h=8, - txt='Univariate Analysis of Each Dataset (Top 10 Features for Each): Page ' + str( - page + 1), - border=1, align='L', ln=2) - else: - self.analysis_report.cell(w=180, h=8, txt='Univariate Analysis of Each Dataset (Top 10 Features for Each)', - border=1, - align='L', ln=2) - try: - # Try loop added to deal with versions specific change to using mannwhitneyu in scipy and - # avoid STREAMLINE crash in those circumstances. - for n in range(data_start, dataset_count): - if n >= count_limit: # Stops generating page when dataset count limit reached - break - self.analysis_report.y += 2 - sig_df = pd.read_csv( - self.experiment_path + '/' + self.datasets[ - n] + '/exploratory/univariate_analyses/Univariate_Significance.csv') - sig_ls = [] - sig_df = sig_df.nsmallest(10, ['p-value']) - - self.analysis_report.set_font('Times', 'B', 10) - self.analysis_report.multi_cell(w=160, h=6, txt='D' + str(n + 1) + ' = ' + self.datasets[n], border=0, - align='L') - - # for i in range(len(sig_df)): - # sig_ls.append(sig_df.iloc[i, 0] + '\t\t\t: ') - # sig_ls.append(str(sig_df.iloc[i, 1])) - # sig_ls.append('\t\t\t' + '(' + sig_df.iloc[i, 3] + ',' + str(sig_df.iloc[i, 2]) + ')' + '\n') - # self.analysis_report.set_font('Times', 'B', 10) - # self.analysis_report.multi_cell(w=180, h=4, txt='D' + str(n + 1) + ' = ' + self.datasets[n], border=1, - # align='L') - # self.analysis_report.y += 1 # Space below section header - # self.analysis_report.set_font('Times', 'B', 8) - # self.analysis_report.multi_cell(w=180, h=4, - # txt='Feature: \t\t\t P-Value \t\t\t (Test, test statistics)', border=1, - # align='L') - # self.analysis_report.set_font('Times', '', 8) - # self.analysis_report.multi_cell(w=180, h=4, txt=' ' + list_to_string(sig_ls), border=1, align='L') - - self.analysis_report.set_font('Times', '', 8) - # sig_df = sig_df.round(3) - # Format - sig_df.reset_index(inplace=True) - sig_df = pd.concat([sig_df.columns.to_frame().T, sig_df]) - sig_df.columns = range(len(sig_df.columns)) - th = self.analysis_report.font_size - col_width_list = [40, 40, 40, 40, 40, 20] - table1 = sig_df.iloc[:, :] - table1 = table1.to_numpy() - - # Print table header first - row_count = 0 - col_count = 0 - - for row in table1: # each row - for datum in row: - entry_list = str(datum).split(' ') - try: - if col_count == 0: - pass - else: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1, - align="C") - except Exception: - self.analysis_report.cell(col_width_list[col_count], th, ' ', border=1, align="C") - col_count += 1 - self.analysis_report.ln(th) # critical - col_count = 0 - row_count += 1 - - except Exception as e: - self.analysis_report.x = 5 - self.analysis_report.y = 40 - self.analysis_report.cell(180, 4, - # 'WARNING: Univariate analysis failed from scipy package error. To fix: pip ' - # 'install --upgrade scipy', - str(e), - 1, align="L") - self.footer() - - def pub_model_mean_stats(self, page, result_limit, page_count): - dataset_count = len(self.datasets) - data_start = page * result_limit - count_limit = (page * result_limit) + result_limit - # Create PDF and Set Options - self.analysis_report.set_margins(left=1, top=1, right=1, ) - self.analysis_report.add_page() - self.analysis_report.set_font('Times', 'B', 12) - if page_count > 1: - self.analysis_report.cell(w=0, h=8, - txt='Average Model Prediction Statistics (Rounded to 3 Decimal Points): Page ' - + str(page + 1), border=1, align='L', ln=2) - else: - self.analysis_report.cell(w=0, h=8, txt='Average Model Prediction Statistics (Rounded to 3 Decimal Points)', - border=1, - align='L', ln=2) - for n in range(data_start, dataset_count): - if n >= count_limit: - # Stops generating page when dataset count limit reached - break - self.analysis_report.y += 4 - self.analysis_report.set_font('Times', 'B', 10) - self.analysis_report.multi_cell(w=0, h=4, txt='D' + str(n + 1) + ' = ' + self.datasets[n], border=1, - align='L') - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 7) - if self.training: - stats_ds = pd.read_csv( - self.experiment_path + '/' + str( - self.datasets[n]) + '/model_evaluation/Summary_performance_mean.csv', - sep=',', - index_col=0) - else: - stats_ds = pd.read_csv(self.experiment_path + '/' + self.train_name + '/replication/' + self.datasets[ - n] + '/model_evaluation/Summary_performance_mean.csv', sep=',', index_col=0) - # Make list of top values for each metric - metric_name_list = ['Balanced Accuracy', 'Accuracy', 'F1 Score', 'Sensitivity (Recall)', 'Specificity', - 'Precision (PPV)', 'TP', 'TN', 'FP', 'FN', 'NPV', 'LR+', 'LR-', 'ROC AUC', 'PRC AUC', - 'PRC APS'] - best_metric_list = [] - if self.training: - ds2 = pd.read_csv( - self.experiment_path + '/' + self.datasets[n] + "/model_evaluation/Summary_performance_mean.csv") - else: - ds2 = pd.read_csv(self.experiment_path + '/' + self.train_name + '/replication/' + self.datasets[ - n] + '/model_evaluation/Summary_performance_mean.csv') - - self.format_fn(stats_ds, best_metric_list, metric_name_list, ds2) - - self.footer() - - def pub_model_median_stats(self, page, result_limit, page_count): - dataset_count = len(self.datasets) - data_start = page * result_limit - count_limit = (page * result_limit) + result_limit - # Create PDF and Set Options - self.analysis_report.set_margins(left=1, top=1, right=1, ) - self.analysis_report.add_page() - self.analysis_report.set_font('Times', 'B', 12) - if page_count > 1: - self.analysis_report.cell(w=0, h=8, - txt='Median Model Prediction Statistics (Rounded to 3 Decimal Points): Page ' - + str(page + 1), - border=1, align='L', ln=2) - else: - self.analysis_report.cell(w=0, h=8, txt='Median Model Prediction Statistics (Rounded to 3 Decimal Points)', - border=1, - align='L', ln=2) - for n in range(data_start, dataset_count): - if n >= count_limit: # Stops generating page when dataset count limit reached - break - self.analysis_report.y += 4 - self.analysis_report.set_font('Times', 'B', 10) - self.analysis_report.multi_cell(w=0, h=4, txt='D' + str(n + 1) + ' = ' + self.datasets[n], border=1, - align='L') - self.analysis_report.y += 1 # Space below section header - self.analysis_report.set_font('Times', '', 7) - if self.training: - stats_ds = pd.read_csv( - self.experiment_path + '/' + str( - self.datasets[n]) + '/model_evaluation/Summary_performance_median.csv', - sep=',', - index_col=0) - else: - stats_ds = pd.read_csv(self.experiment_path + '/' + self.train_name + '/replication/' + self.datasets[ - n] + '/model_evaluation/Summary_performance_median.csv', sep=',', index_col=0) - # Make list of top values for each metric - metric_name_list = ['Balanced Accuracy', 'Accuracy', 'F1 Score', 'Sensitivity (Recall)', 'Specificity', - 'Precision (PPV)', 'TP', 'TN', 'FP', 'FN', 'NPV', 'LR+', 'LR-', 'ROC AUC', 'PRC AUC', - 'PRC APS'] - best_metric_list = [] - if self.training: - ds2 = pd.read_csv( - self.experiment_path + '/' + self.datasets[n] + "/model_evaluation/Summary_performance_median.csv") - else: - ds2 = pd.read_csv(self.experiment_path + '/' + self.train_name + '/replication/' + self.datasets[ - n] + '/model_evaluation/Summary_performance_median.csv') - self.format_fn(stats_ds, best_metric_list, metric_name_list, ds2) - self.footer() - - def pub_runtime(self, page, result_limit, page_count): - """ - Generates single page of runtime analysis results. Automatically moves to another page when runs out of - space. Maximum of 4 dataset results to a page. - """ - col_width_1 = 45 # maximum column width - col_width_2 = 25 - dataset_count = len(self.datasets) - data_start = page * result_limit - count_limit = (page * result_limit) + result_limit - self.analysis_report.add_page(orientation='P') - self.analysis_report.set_font('Times', 'B', 12) - if page_count > 1: - self.analysis_report.cell(w=0, h=8, txt='Pipeline Runtime Summary: Page ' + str(page + 1), border=1, - align='L', - ln=2) - else: - self.analysis_report.cell(w=0, h=8, txt='Pipeline Runtime Summary', border=1, align='L', ln=2) - self.analysis_report.set_font('Times', '', 8) - th = self.analysis_report.font_size - self.analysis_report.y += 2 - left = True - for n in range(data_start, dataset_count): - if n >= count_limit: # Stops generating page when dataset count limit reached - break - last_y = self.analysis_report.y - last_x = self.analysis_report.x - if left: - self.analysis_report.x = 1 - time_df = pd.read_csv(self.experiment_path + '/' + self.datasets[n] + '/runtimes.csv') - time_df.iloc[:, 1] = time_df.iloc[:, 1].round(2) - time_df = pd.concat([time_df.columns.to_frame().T, time_df]) - time_df = time_df.to_numpy() - self.analysis_report.set_font('Times', 'B', 10) - self.analysis_report.cell(col_width_1 + col_width_2 * 2, 4, str(self.datasets[n]), 1, align="L") - self.analysis_report.y += 5 - self.analysis_report.x = last_x - self.analysis_report.set_font('Times', '', 7) - for row in time_df: - col = 0 - for datum in row: - if col == 0: - self.analysis_report.cell(col_width_1, th, str(datum), border=1) - else: - self.analysis_report.cell(col_width_2, th, str(datum), border=1) - col +=1 - self.analysis_report.ln(th) # critical - self.analysis_report.x = last_x - - if left: - self.analysis_report.x = (col_width_1 + col_width_2 * 2) + 2 - self.analysis_report.y = last_y - left = False - else: - self.analysis_report.x = 1 - self.analysis_report.y = last_y + 70 - left = True - self.footer() - - def format_fn(self, stats_ds, best_metric_list, metric_name_list, ds2): - low_val_better = ['FP', 'FN', 'LR-'] - for metric in metric_name_list: - if metric in low_val_better: - ds2[metric] = ds2[metric].astype(float).round(3) - metric_best = ds2[metric].min() - else: - ds2[metric] = ds2[metric].astype(float).round(3) - metric_best = ds2[metric].max() - best_metric_list.append(metric_best) - - stats_ds = stats_ds.round(3) - # Format - stats_ds.reset_index(inplace=True) - stats_ds = pd.concat([stats_ds.columns.to_frame().T, stats_ds]) - stats_ds.columns = range(len(stats_ds.columns)) - th = self.analysis_report.font_size - col_width_list = [32, 11, 11, 8, 12, 12, 10, 15, 15, 15, 15, 8, 9, 9, 8, 8, 8] - table1 = stats_ds.iloc[:, :18] - table1 = table1.to_numpy() - - # Print table header first - row_count = 0 - col_count = 0 - - for row in table1: # each row - if row_count == 0: - # Print first row - for datum in row: - if col_count == 0: - self.analysis_report.cell(col_width_list[col_count], th, 'ML Algorithm', border=0, align="C") - else: - entry_list = str(datum).split(' ') - self.analysis_report.cell(col_width_list[col_count], th, entry_list[0], border=0, align="C") - col_count += 1 - self.analysis_report.ln(th) # critical - col_count = 0 - # Print second row - for datum in row: - entry_list = str(datum).split(' ') - try: - self.analysis_report.cell(col_width_list[col_count], th, entry_list[1], border=0, align="C") - except Exception: - self.analysis_report.cell(col_width_list[col_count], th, ' ', border=0, align="C") - col_count += 1 - self.analysis_report.ln(th) # critical - col_count = 0 - else: # Print table contents - for datum in row: # each column - if col_count > 0 and float(datum) == float(best_metric_list[col_count - 1]): - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1, align="L", - fill=True) - else: - self.analysis_report.cell(col_width_list[col_count], th, str(datum), border=1, align="L") - col_count += 1 - self.analysis_report.ln(th) # critical - col_count = 0 - row_count += 1 - - def footer(self): - self.analysis_report.set_auto_page_break(auto=False, margin=3) - self.analysis_report.set_y(285) - self.analysis_report.set_font('Times', 'I', 7) - self.analysis_report.cell(0, 7, - 'Generated with STREAMLINE (' + version - + '): (https://github.com/UrbsLab/STREAMLINE)', 0, - 0, 'C') - self.analysis_report.set_font(family='times', size=9) - - -def list_to_string(s): - """Convert a list of string to string""" - str1 = " " - return str1.join(s) - - -def ngi(list1, n): - """Find N the greatest integers within a list""" - final_list = [] - for i in range(0, n): - max1 = 0 - for j in range(len(list1)): - if list1[j] > max1: - max1 = list1[j] - list1.remove(max1) - final_list.append(max1) diff --git a/streamline/postanalysis/model_replicate.py b/streamline/postanalysis/model_replicate.py deleted file mode 100644 index 1befd855..00000000 --- a/streamline/postanalysis/model_replicate.py +++ /dev/null @@ -1,600 +0,0 @@ -import csv -import glob -import logging -import os -import pickle -from pathlib import Path - -import pandas as pd -import numpy as np - -from streamline.dataprep.data_process import DataProcess -from streamline.modeling.basemodel import BaseModel -from streamline.modeling.utils import ABBREVIATION, SUPPORTED_MODELS, is_supported_model -from streamline.postanalysis.statistics import StatsJob -from streamline.utils.dataset import Dataset -from streamline.utils.job import Job - - -# Evaluation metrics -# from scipy import interp,stats - - -class ReplicateJob(Job): - """ - This 'Job' script conducts exploratory analysis on the new replication dataset then - applies and evaluates all trained models on one or more previously unseen hold-out - or replication study dataset(s). It also generates new evaluation figure. - It does not deal with model feature importance estimation as this is a part of model training interpretation only. - This script is run once for each replication dataset in rep_data_path. - """ - - def __init__(self, dataset_filename, dataset_for_rep, full_path, class_label, instance_label, match_label, - ignore_features=None, algorithms=None, exclude=("XCS", "eLCS"), cv_partitions=3, exclude_plots=None, - categorical_cutoff=10, sig_cutoff=0.05, scale_data=True, impute_data=True, - multi_impute=True, show_plots=False, scoring_metric='balanced_accuracy', random_state=None): - super().__init__() - self.dataset_filename = dataset_filename - self.dataset_for_rep = dataset_for_rep - - self.full_path = full_path - self.class_label = class_label - self.instance_label = instance_label - self.match_label = match_label - - if algorithms is None: - self.algorithms = SUPPORTED_MODELS - if exclude is not None: - for algorithm in exclude: - try: - self.algorithms.remove(algorithm) - except Exception: - Exception("Unknown algorithm in exclude: " + str(algorithm)) - else: - self.algorithms = list() - for algorithm in algorithms: - self.algorithms.append(is_supported_model(algorithm)) - - known_exclude_options = ['plot_ROC', 'plot_PRC', 'plot_metric_boxplots', 'feature_correlations'] - if exclude_plots is not None: - for x in exclude_plots: - if x not in known_exclude_options: - logging.warning("Unknown exclusion option " + str(x)) - else: - exclude_plots = list() - - self.plot_roc = 'plot_ROC' not in exclude_plots - self.plot_prc = 'plot_PRC' not in exclude_plots - self.plot_metric_boxplots = 'plot_metric_boxplots' not in exclude_plots - self.exclude_plots = exclude_plots - - self.export_feature_correlations = 'feature_correlations' not in exclude_plots - self.show_plots = show_plots - self.cv_partitions = cv_partitions - - self.categorical_cutoff = categorical_cutoff - self.sig_cutoff = sig_cutoff - self.scale_data = scale_data - self.impute_data = impute_data - self.scoring_metric = scoring_metric - self.multi_impute = multi_impute - self.ignore_features = ignore_features - self.random_state = random_state - - self.train_name = self.full_path.split('/')[-1] - self.experiment_path = '/'.join(self.full_path.split('/')[:-1]) - # replication dataset being analyzed in this job - self.apply_name = self.dataset_filename.split('/')[-1].split('.')[0] - - def run(self): - - # Load Replication Dataset - rep_data = Dataset(self.dataset_filename, self.class_label, self.match_label, self.instance_label) - rep_feature_list = list(rep_data.data.columns.values) - rep_feature_list.remove(self.class_label) - if self.match_label is not None: - rep_feature_list.remove(self.match_label) - if self.instance_label is not None: - rep_feature_list.remove(self.instance_label) - - # Load original training dataset (could include 'match label') - # replication dataset file extension - train_data = Dataset(self.dataset_for_rep, self.class_label, self.match_label, self.instance_label) - # train_data.clean_data(ignore_features=self.ignore_features) - - all_train_feature_list = list(train_data.data.columns.values) - all_train_feature_list.remove(self.class_label) - if self.match_label is not None: - all_train_feature_list.remove(self.match_label) - if self.instance_label is not None: - all_train_feature_list.remove(self.instance_label) - - # Confirm that all features in original training data appear in replication datasets - if not (set(all_train_feature_list).issubset(set(rep_feature_list))): - raise Exception('Error: One or more features in training dataset did not appear in replication dataset!') - - # Grab and order replication data columns to match training data columns - rep_data.data = rep_data.data[train_data.data.columns] - - # Create Folder hierarchy - if not os.path.exists(self.full_path + "/replication/" + self.apply_name + '/' + 'exploratory'): - os.mkdir(self.full_path + "/replication/" + self.apply_name + '/' + 'exploratory') - if not os.path.exists( - self.full_path + "/replication/" + self.apply_name + '/' + 'exploratory' + '/' + 'initial'): - os.mkdir(self.full_path + "/replication/" + self.apply_name + '/' + 'exploratory' + '/' + 'initial') - if not os.path.exists(self.full_path + "/replication/" + self.apply_name + '/' + 'model_evaluation'): - os.mkdir(self.full_path + "/replication/" + self.apply_name + '/' + 'model_evaluation') - if not os.path.exists( - self.full_path + "/replication/" + self.apply_name + '/' + 'model_evaluation' + '/' + 'pickled_metrics'): - os.mkdir( - self.full_path + "/replication/" + self.apply_name + '/' + 'model_evaluation' + '/' + 'pickled_metrics') - - # Load previously identified list of categorical - # variables and create an index list to identify respective columns - file = open(self.full_path + '/exploratory/initial/initial_categorical_features.pickle', 'rb') - categorical_variables = pickle.load(file) - file = open(self.full_path + '/exploratory/initial/initial_quantitative_features.pickle', 'rb') - quantitative_variables = pickle.load(file) - - rep_data.categorical_variables = categorical_variables - rep_data.quantitative_variables = quantitative_variables - - eda = DataProcess(rep_data, self.full_path, ignore_features=self.ignore_features, - categorical_features=categorical_variables, quantitative_features=quantitative_variables, - exclude_eda_output=None, - categorical_cutoff=self.categorical_cutoff, sig_cutoff=self.sig_cutoff, - random_state=self.random_state, show_plots=self.show_plots) - - # Arguments changed to send to correct locations describe_data(self) - eda.dataset.name = 'replication/' + self.apply_name - - eda.identify_feature_types() - - transition_df = pd.DataFrame(columns=['Instances', 'Total Features', - 'Categorical Features', - 'Quantitative Features', 'Missing Values', - 'Missing Percent', 'Class 0', 'Class 1']) - - transition_df.loc["Original"] = eda.counts_summary(save=False) - - with open(self.experiment_path + '/' + self.train_name + - '/exploratory/binary_categorical_dict.pickle', 'rb') as infile: - binary_categorical_dict = dict(pickle.load(infile)) - - for key in binary_categorical_dict: - unique_vals = list(eda.dataset.data[key].unique()) - unique_vals = [x for x in unique_vals if not pd.isnull(x)] - if sorted(unique_vals) != sorted(binary_categorical_dict[key]): - new_values = list(set(eda.dataset.data[key].unique()) - set(binary_categorical_dict[key])) - logging.warning("New Value found in Binary Categorical Variable " + str(key) - + ", replacing with null value") - for feat in new_values: - logging.warning('\t' + str(feat)) - eda.dataset.data[key].replace(new_values, np.nan, inplace=True) - - # ordinal decode the variables - try: - with open(self.experiment_path + '/' + self.train_name + - '/exploratory/ordinal_encoding.pickle', 'rb') as infile: - ord_labels = pickle.load(infile) - for feat in ord_labels.index: - - temp_y, labels = pd.factorize(eda.dataset.data[feat]) - - if set(ord_labels.loc[feat]['Category']) == set(labels): - eda.dataset.data[feat] = temp_y - elif len(ord_labels.loc[feat]['Category']) == 2: - new_labels = list(set(labels) - set(ord_labels.loc[feat]['Category'])) - labels = ord_labels.loc[feat]['Category'] - rename_dict = dict(enumerate(labels)) - for lab in new_labels: - rename_dict[None] = lab - rename_dict = {v: k for k, v in rename_dict.items()} - eda.dataset.data.replace({feat: rename_dict}, inplace=True) - ord_labels.loc[feat]['Category'] = list(labels) + new_labels - ord_labels.loc[feat]['Encoding'] = list(range(len(list(labels)))) + [None, ] * len(new_labels) - logging.warning("New Value found in Textual Binary Categorical Variable " + str(feat) - + ", replacing with null value") - for x in new_labels: - logging.warning('\t' + str(x)) - else: - new_labels = list(set(labels) - set(ord_labels.loc[feat]['Category'])) - labels = ord_labels.loc[feat]['Category'] - rename_dict = dict(enumerate(list(labels) + new_labels)) - rename_dict = {v: k for k, v in rename_dict.items()} - eda.dataset.data.replace({feat: rename_dict}, inplace=True) - ord_labels.loc[feat]['Category'] = list(labels) + new_labels - ord_labels.loc[feat]['Encoding'] = list(range(len(list(labels) + new_labels))) - with open(self.full_path + "/replication/" + self.apply_name + - '/exploratory/apply_ordinal_encoding.pickle', 'wb') as outfile: - pickle.dump(ord_labels, outfile) - ord_labels.to_csv(self.full_path + "/replication/" + self.apply_name + - '/exploratory/Numerical_Encoding_Map.csv') - except FileNotFoundError: - pass - - # ExploratoryAnalysis - basic data cleaning - eda.drop_ignored_rowcols() - - transition_df.loc["C1"] = eda.counts_summary(save=False) - - eda.dataset.initial_eda(self.experiment_path + '/' + self.train_name) - - # Missingness Feature Reconstruction - # Read all engineered feature names - try: - with open(self.experiment_path + '/' + self.train_name + - '/exploratory/engineered_features.pickle', 'rb') as infile: - eda.engineered_features = pickle.load(infile) - except FileNotFoundError: - eda.engineered_features = list() - - # Recreate missingness features in replication phase - for feat in eda.engineered_features: - eda.dataset.data['Miss_' + feat] = eda.dataset.data[feat].isnull().astype(int) - eda.categorical_features.append('Miss_' + feat) - eda.engineered_features = ['Miss_' + feat for feat in eda.engineered_features] - - #transition_df.loc["E1"] = eda.counts_summary(save=False) - - try: - # Removing dropped features - with open(self.experiment_path + '/' + self.train_name + - '/exploratory/removed_features.pickle', 'rb') as infile: - removed_features = list(pickle.load(infile)) - for feat in removed_features: - if feat in eda.categorical_features: - eda.categorical_features.remove(feat) - if feat in eda.quantitative_features: - eda.quantitative_features.remove(feat) - eda.dataset.data.drop(removed_features, axis=1, inplace=True) - except FileNotFoundError: - pass - - #transition_df.loc["C2"] = eda.counts_summary(save=False) - - try: - with open(self.experiment_path + '/' + self.train_name + - '/exploratory/post_processed_features.pickle', 'rb') as infile: - post_processed_vars = pickle.load(infile) - except Exception as e: - raise e - - non_binary_categorical = list() - for feat in eda.categorical_features: - if feat in eda.dataset.data.columns: - if eda.dataset.data[feat].nunique() > 2: - non_binary_categorical.append(feat) - # logging.warning(non_binary_categorical) - if len(non_binary_categorical) > 0: - one_hot_df = pd.get_dummies(eda.dataset.data[non_binary_categorical], columns=non_binary_categorical) - eda.one_hot_features = list(one_hot_df.columns) - eda.dataset.data.drop(non_binary_categorical, axis=1, inplace=True) - eda.dataset.data = pd.concat([eda.dataset.data, one_hot_df], axis=1) - # adding features not seen in test data - for feat in post_processed_vars: - if feat not in list(eda.dataset.data.columns): - eda.dataset.data[feat] = 0 - eda.one_hot_features.append(feat) - - eda.categorical_features += eda.one_hot_features - - try: - with open(self.experiment_path + '/' + self.train_name + - '/exploratory/correlated_features.pickle', 'rb') as infile: - correlated_features = list(pickle.load(infile)) - except FileNotFoundError: - correlated_features = list() - - # removing extra features - for feat in eda.dataset.data.columns: - if feat not in post_processed_vars and feat not in correlated_features: - eda.drop_ignored_rowcols([feat]) - - #transition_df.loc["E2"] = eda.counts_summary(save=False) - - # Removing highly correlated features - for feat in correlated_features: - if feat in eda.categorical_features: - eda.categorical_features.remove(feat) - if feat in eda.quantitative_features: - eda.quantitative_features.remove(feat) - eda.dataset.data.drop(correlated_features, axis=1, inplace=True) - - #transition_df.loc["C4"] = eda.counts_summary(save=False) - - eda.categorical_features = list(set(post_processed_vars).intersection(set(eda.categorical_features))) - eda.quantitative_features = list(set(post_processed_vars).intersection(set(eda.quantitative_features))) - - if len(list(set(post_processed_vars) - set(eda.quantitative_features + eda.quantitative_features))) > 0: - Exception("Final Variables in Train are not equal to post processed sum of " - "Categorical and Quantitative in Replication phase, something is wrong") - - eda.dataset.data = eda.dataset.data[post_processed_vars] - - transition_df.loc["R1"] = eda.counts_summary(save=False) - - transition_df.to_csv(self.full_path + "/replication/" + self.apply_name + '/exploratory/' - + 'DataProcessSummary.csv', index=True) - - # Pickle list of feature names to be treated as categorical variables - with open(self.full_path + "/replication/" + self.apply_name + - '/exploratory/categorical_features.pickle', 'wb') as outfile: - pickle.dump(eda.categorical_features, outfile) - - # Pickle list of processed feature names - with open(self.full_path + "/replication/" + self.apply_name + - '/exploratory/post_processed_features.pickle', 'wb') as outfile: - pickle.dump(list(eda.dataset.data.columns), outfile) - with open(self.full_path + "/replication/" + self.apply_name + - '/exploratory/ProcessedFeatureNames.csv', 'w') as outfile: - writer = csv.writer(outfile, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) - writer.writerow(list(eda.dataset.data.columns)) - - # Save a copy of the processed replication dataset (used by useful notebook to allign prediction probabilities to instance IDs) - eda.dataset.data.to_csv(self.full_path + "/replication/" + self.apply_name +"/"+self.apply_name+"_Processed.csv", index=False) - - # Export basic exploratory analysis files - eda.dataset.describe_data(self.experiment_path + '/' + self.train_name) - - total_missing = eda.dataset.missingness_counts(self.experiment_path + '/' + self.train_name) - - eda.counts_summary(total_missing, plot=True, replicate=True) - - # Create features-only version of dataset for some operations - x_rep_data = eda.dataset.feature_only_data() - - # Export feature correlation plot if user specified - if self.export_feature_correlations: - eda.dataset.feature_correlation(self.experiment_path + '/' + self.train_name, x_rep_data, show_plots=False) - del x_rep_data # memory cleanup - - # Rep Data Preparation for each Training Partition Model set - # (rep data will potentially be scaled, imputed and feature - # selected in the same was as was done for each corresponding CV training partition) - master_list = [] # Will hold all evalDict's, one for each cv dataset. - - cv_dataset_paths = list(glob.glob(self.full_path + "/CVDatasets/*_CV_*Train.csv")) - cv_dataset_paths = [str(Path(cv_dataset_path)) for cv_dataset_path in cv_dataset_paths] - cv_partitions = len(cv_dataset_paths) - for cv_count in range(0, cv_partitions): - # Get corresponding training CV dataset - cv_train_path = self.full_path + "/CVDatasets/" + self.train_name + '_CV_' + str(cv_count) + '_Train.csv' - cv_train_data = pd.read_csv(cv_train_path, na_values='NA', sep=",") - # Get List of features in cv dataset - # (if feature selection took place this may only include a subset of original training data features) - train_feature_list = list(cv_train_data.columns.values) - train_feature_list.remove(self.class_label) - if self.instance_label is not None: - if self.instance_label in train_feature_list: - train_feature_list.remove(self.instance_label) - if self.match_label is not None: - train_feature_list.remove(self.match_label) - # Working copy of original dataframe - - # a new version will be created for each CV partition to be applied to each corresponding set of models - cv_rep_data = rep_data.data.copy() - # Impute dataframe based on training imputation - - # if self.ignore_features is not None: - # for feature in self.ignore_features: - # if feature in all_train_feature_list: - # feature_name_list.remove(feature) - # - # if removed_features: - # for feature in removed_features: - # if feature in all_train_feature_list: - # feature_name_list.remove(feature) - # - # if correlated_features: - # for feature in correlated_features: - # if feature in all_train_feature_list: - # feature_name_list.remove(feature) - # one_hot_list = list() - # for var in post_processed_vars: - # if var not in all_train_feature_list: - # one_hot_list.append(var) - # - # feature_name_list = all_train_feature_list + engineered_features + one_hot_list - - feature_name_list = list(post_processed_vars) - feature_name_list.remove(eda.dataset.class_label) - if eda.dataset.instance_label: - feature_name_list.remove(eda.dataset.instance_label) - if eda.dataset.match_label: - feature_name_list.remove(eda.dataset.match_label) - - if self.impute_data: - try: - # assumes imputation was actually run in training (i.e. user had impute_data setting as 'True') - cv_rep_data = self.impute_rep_data(cv_count, cv_rep_data, feature_name_list, - eda.categorical_features, eda.quantitative_features) - except Exception as e: - logging.warning("Unknow Exception in Imputation: " - + str(self.apply_name)) - logging.warning(e) - # raise e - - # Scale dataframe based on training scaling - if self.scale_data: - try: - # assumes imputation was actually run in training (i.e. user had impute_data setting as 'True') - cv_rep_data = self.scale_rep_data(cv_count, cv_rep_data, feature_name_list) - except Exception as e: - # If there was no imputation data in respective dataset, - # thus no imputation files were created, bypass loading of imputation data. - # Requires new replication data to have no missing values, as there is no - # established internal scheme to conduct imputation. - # logging.warning(e) - logging.warning("Notice: Scaling was not conducted for the following target dataset, " - "so scaling was not conducted for replication data: " - + str(self.apply_name)) - # raise e - - # Conduct feature selection based on training selection - # (Filters out any features not in the final cv training dataset) - cv_rep_data = cv_rep_data[cv_train_data.columns] - del cv_train_data # memory cleanup - # Prep data for evaluation - if self.instance_label is not None: - cv_rep_data = cv_rep_data.drop(self.instance_label, axis=1) - x_test = cv_rep_data.drop(self.class_label, axis=1).values - y_test = cv_rep_data[self.class_label].values - # Unpickle algorithm info from training phases of pipeline - - eval_dict = dict() - for algorithm in self.algorithms: - ret = self.eval_model(algorithm, cv_count, x_test, y_test) - eval_dict[algorithm] = ret - pickle.dump(ret, open(self.full_path + "/replication/" - + self.apply_name + '/model_evaluation/pickled_metrics/' - + ABBREVIATION[algorithm] + '_CV_' - + str(cv_count) + "_metrics.pickle", 'wb')) - # includes everything from training except feature importance values - master_list.append(eval_dict) # update master list with evalDict for this CV model - - stats = StatsJob(self.full_path + '/replication/' + self.apply_name, - self.algorithms, self.class_label, self.instance_label, self.scoring_metric, - cv_partitions=self.cv_partitions, top_features=40, sig_cutoff=self.sig_cutoff, - metric_weight='balanced_accuracy', scale_data=self.scale_data, - exclude_plots=self.exclude_plots, show_plots=self.show_plots) - - result_table, metric_dict = stats.primary_stats(master_list, rep_data.data) - - stats.do_plot_roc(result_table) - stats.do_plot_prc(result_table, rep_data.data, True) - - metrics = list(metric_dict[self.algorithms[0]].keys()) - - stats.save_metric_stats(metrics, metric_dict) - - if self.plot_metric_boxplots: - stats.metric_boxplots(metrics, metric_dict) - - # Save Kruskal Wallis, Mann Whitney, and Wilcoxon Rank Sum Stats - if len(self.algorithms) > 1: - kruskal_summary = stats.kruskal_wallis(metrics, metric_dict) - stats.mann_whitney_u(metrics, metric_dict, kruskal_summary) - stats.wilcoxon_rank(metrics, metric_dict, kruskal_summary) - - # Print phase completion - logging.info(self.apply_name + " phase 9 complete") - job_file = open(self.experiment_path + '/jobsCompleted/job_apply_' + self.apply_name + '.txt', 'w') - job_file.write('complete') - job_file.close() - - def impute_rep_data(self, cv_count, cv_rep_data, all_train_feature_list, cat_features, quant_features): - # Impute categorical features (i.e. those included in the mode_dict) - try: - impute_cat_info = self.full_path + '/scale_impute/categorical_imputer_cv' + str( - cv_count) + '.pickle' # Corresponding pickle file name with scalingInfo - infile = open(impute_cat_info, 'rb') - mode_dict = pickle.load(infile) - infile.close() - for c in cv_rep_data.columns: - if c in mode_dict: # was the given feature identified as and treated as categorical during training? - cv_rep_data[c].fillna(mode_dict[c], inplace=True) - except Exception as e: - # If there was no missing data in respective dataset, - # thus no imputation files were created, bypass loading of imputation data and do simple imputation - if cv_rep_data.isna().sum().sum() > 0: - logging.warning("Notice: Categorical Imputation was not conducted for the following target dataset " - "so categorical values were imputed using the median:" - + str(self.apply_name)) - for feat in cat_features: - if cv_rep_data[feat].isnull().sum() > 0: - cv_rep_data[feat].fillna(cv_rep_data[feat].median(), inplace=True) - - impute_rep_df = None - - try: - impute_oridinal_info = self.full_path + '/scale_impute/ordinal_imputer_cv' + str( - cv_count) + '.pickle' # Corresponding pickle file name with scalingInfo - if self.multi_impute: # multiple imputation of quantitative features - infile = open(impute_oridinal_info, 'rb') - imputer = pickle.load(infile) - infile.close() - inst_rep = None - # Prepare data for scikit imputation - if self.instance_label is None or self.instance_label == 'None': - x_rep = cv_rep_data.drop([self.class_label], axis=1).values - else: - x_rep = cv_rep_data.drop([self.class_label, self.instance_label], axis=1).values - inst_rep = cv_rep_data[self.instance_label].values # pull out instance labels in case they include text - y_rep = cv_rep_data[self.class_label].values - x_rep_impute = imputer.transform(x_rep) - # Recombine x and y - if self.instance_label is None or self.instance_label == 'None': - impute_rep_df = pd.concat([pd.DataFrame(y_rep, columns=[self.class_label]), - pd.DataFrame(x_rep_impute, columns=all_train_feature_list)], axis=1, - sort=False) - else: - impute_rep_df = pd.concat( - [pd.DataFrame(y_rep, columns=[self.class_label]), - pd.DataFrame(inst_rep, columns=[self.instance_label]), - pd.DataFrame(x_rep_impute, columns=all_train_feature_list)], axis=1, sort=False) - else: # simple (median) imputation of quantitative features - infile = open(impute_oridinal_info, 'rb') - median_dict = pickle.load(infile) - infile.close() - for c in cv_rep_data.columns: - if c in median_dict: # was the given feature identified as and treated as categorical during training? - cv_rep_data[c].fillna(median_dict[c], inplace=True) - except FileNotFoundError: - # If there was no missing data in respective dataset, - # thus no imputation files were created, bypass loading of imputation data and do simple imputation - if cv_rep_data.isna().sum().sum() > 0: - logging.warning("Notice: Quantitative Imputation was not conducted for the following target dataset " - "so quantitative values were imputed with the mean: " - + str(self.apply_name)) - for feat in quant_features: - if cv_rep_data[feat].isnull().sum() > 0: - cv_rep_data[feat].fillna(cv_rep_data[feat].mean(), inplace=True) - impute_rep_df = cv_rep_data - - return impute_rep_df - - def scale_rep_data(self, cv_count, cv_rep_data, all_train_feature_list): - # Corresponding pickle file name with scalingInfo - scale_info = self.full_path + '/scale_impute/scaler_cv' + str( - cv_count) + '.pickle' - infile = open(scale_info, 'rb') - scaler = pickle.load(infile) - decimal_places = 7 - infile.close() - inst_rep = None - # Scale target replication data - if self.instance_label is None or self.instance_label == 'None': - x_rep = cv_rep_data.drop([self.class_label], axis=1) - else: - x_rep = cv_rep_data.drop([self.class_label, self.instance_label], axis=1) - inst_rep = cv_rep_data[self.instance_label] # pull out instance labels in case they include text - y_rep = cv_rep_data[self.class_label] - # Scale features (x) - x_rep_scaled = pd.DataFrame(scaler.transform(x_rep).round(decimal_places), columns=x_rep.columns) - # Recombine x and y - if self.instance_label is None or self.instance_label == 'None': - scale_rep_df = pd.concat([pd.DataFrame(y_rep, columns=[self.class_label]), - pd.DataFrame(x_rep_scaled, columns=all_train_feature_list)], axis=1, sort=False) - else: - scale_rep_df = pd.concat( - [pd.DataFrame(y_rep, columns=[self.class_label]), pd.DataFrame(inst_rep, columns=[self.instance_label]), - pd.DataFrame(x_rep_scaled, columns=all_train_feature_list)], axis=1, sort=False) - return scale_rep_df - - def eval_model(self, algorithm, cv_count, x_test, y_test): - model_info = self.full_path + '/models/pickledModels/' + ABBREVIATION[algorithm] + '_' \ - + str(cv_count) + '.pickle' - # Corresponding pickle file name with scalingInfo - infile = open(model_info, 'rb') - model = pickle.load(infile) - infile.close() - # Prediction evaluation - m = BaseModel(None, algorithm, scoring_metric=self.scoring_metric) - m.model = model - m.model_name = algorithm - m.small_name = ABBREVIATION[algorithm] - - metric_list, fpr, tpr, roc_auc, prec, recall, \ - prec_rec_auc, ave_prec, probas_ = m.model_evaluation(x_test, y_test) - - return [metric_list, fpr, tpr, roc_auc, prec, recall, prec_rec_auc, ave_prec, None, probas_] diff --git a/streamline/postanalysis/statistics.py b/streamline/postanalysis/statistics.py deleted file mode 100644 index 54ed61f5..00000000 --- a/streamline/postanalysis/statistics.py +++ /dev/null @@ -1,1174 +0,0 @@ -import csv -import glob -import os -import pickle -import time -import logging -from pathlib import Path - -import numpy as np -import pandas as pd -import matplotlib.pyplot as plt -from matplotlib import rc -from statistics import mean, median, stdev -from scipy.stats import kruskal, wilcoxon, mannwhitneyu -from streamline.utils.job import Job -from streamline.modeling.utils import ABBREVIATION, COLORS -import seaborn as sns - -sns.set_theme() - - -class StatsJob(Job): - """ - This 'Job' script creates summaries of ML classification evaluation statistics - (means and standard deviations), ROC and PRC plots (comparing CV performance - in the same ML algorithm and comparing average performance - between ML algorithms), model feature importance averages over CV runs, - boxplot comparing ML algorithms for each metric, Kruskal Wallis - and Mann Whitney statistical comparisons between ML algorithms, model - feature importance boxplot for each algorithm, and composite feature - importance plots summarizing model feature importance across all ML algorithms. - It is run for a single dataset from the original target - dataset folder (data_path) in Phase 1 (i.e. stats summary completed for all cv datasets). - """ - - def __init__(self, full_path, algorithms, class_label, instance_label, scoring_metric='balanced_accuracy', - cv_partitions=5, top_features=40, sig_cutoff=0.05, metric_weight='balanced_accuracy', scale_data=True, - exclude_plots=None, show_plots=False): - """ - - Args: - full_path: - algorithms: - class_label: - instance_label: - scoring_metric: - cv_partitions: - top_features: - sig_cutoff: - metric_weight: - scale_data: - show_plots: - """ - super().__init__() - self.full_path = full_path - self.algorithms = sorted(algorithms) - self.class_label = class_label - self.instance_label = instance_label - self.data_name = self.full_path.split('/')[-1] - self.experiment_path = '/'.join(self.full_path.split('/')[:-1]) - - known_exclude_options = ['plot_ROC', 'plot_PRC', 'plot_FI_box', 'plot_metric_boxplots'] - if exclude_plots is not None: - for x in exclude_plots: - if x not in known_exclude_options: - logging.warning("Unknown exclusion option " + str(x)) - else: - exclude_plots = list() - - self.plot_roc = 'plot_ROC' not in exclude_plots - self.plot_prc = 'plot_PRC' not in exclude_plots - self.plot_metric_boxplots = 'plot_metric_boxplots' not in exclude_plots - self.plot_fi_box = 'plot_FI_box' not in exclude_plots - - self.cv_partitions = cv_partitions - self.scale_data = scale_data - self.scoring_metric = scoring_metric - self.top_features = top_features - self.sig_cutoff = sig_cutoff - self.metric_weight = metric_weight - self.show_plots = show_plots - if self.plot_fi_box: - self.feature_headers = pd.read_csv(self.full_path + "/exploratory/ProcessedFeatureNames.csv", - sep=',').columns.values.tolist() # Get Original Headers - else: - try: - self.feature_headers = pd.read_csv(self.full_path - + "/exploratory/ProcessedFeatureNames.csv", - sep=',').columns.values.tolist() # Get Original Headers - # if self.plot_fi_box: - # self.original_headers = pd.read_csv(self.full_path + "/exploratory/OriginalFeatureNames.csv", - # sep=',').columns.values.tolist() # Get Original Headers - # else: - # try: - # self.original_headers = pd.read_csv(self.full_path - # + "/exploratory/OriginalFeatureNames.csv", - # sep=',').columns.values.tolist() - # # Get Original Headers - except Exception: - self.original_headers = None - # self.feature_headers = self.original_headers.copy() - # if self.instance_label is not None: - # if self.instance_label in self.feature_headers: - # self.feature_headers.remove(self.instance_label) - # self.feature_headers.remove(self.class_label) - - self.abbrev = dict((k, ABBREVIATION[k]) for k in self.algorithms if k in ABBREVIATION) - self.colors = dict((k, COLORS[k]) for k in self.algorithms if k in COLORS) - - def run(self): - self.job_start_time = time.time() # for tracking phase runtime - logging.info('Running Statistics Summary for ' + str(self.data_name)) - - # Translate metric name from scikit-learn standard - # (currently balanced accuracy is hardcoded for use in generating FI plots due to no-skill normalization) - metric_term_dict = {'balanced_accuracy': 'Balanced Accuracy', 'accuracy': 'Accuracy', 'f1': 'F1_Score', - 'recall': 'Sensitivity (Recall)', 'precision': 'Precision (PPV)', 'roc_auc': 'ROC AUC'} - - self.metric_weight = metric_term_dict[self.metric_weight] - - # Get algorithms run, specify algorithm abbreviations, colors to use for - # algorithms in plots, and original ordered feature name list - self.preparation() - - # Gather and summarize all evaluation metrics for each algorithm across all CVs. - # Returns result_table used to plot average ROC and PRC plots and metric_dict - # organizing all metrics over all algorithms and CVs. - result_table, metric_dict = self.primary_stats() - - # Plot ROC and PRC curves comparing average ML algorithm performance (averaged over all CVs) - logging.info('Generating ROC and PRC plots...') - - self.do_plot_roc(result_table) - self.do_plot_prc(result_table) - - # Make list of metric names - logging.info('Saving Metric Summaries...') - metrics = list(metric_dict[self.algorithms[0]].keys()) - - # Save metric means, median and standard deviations - self.save_metric_stats(metrics, metric_dict) - - # Generate boxplot comparing algorithm performance for each standard metric, if specified by user - if self.plot_metric_boxplots: - logging.info('Generating Metric Boxplots...') - self.metric_boxplots(metrics, metric_dict) - - # Calculate and export Kruskal Wallis, Mann Whitney, and wilcoxon Rank sum stats - # if more than one ML algorithm has been run (for the comparison) - note stats are based on - # comparing the multiple CV models for each algorithm. - if len(self.algorithms) > 1: - logging.info('Running Non-Parametric Statistical Significance Analysis...') - kruskal_summary = self.kruskal_wallis(metrics, metric_dict) - self.wilcoxon_rank(metrics, metric_dict, kruskal_summary) - self.mann_whitney_u(metrics, metric_dict, kruskal_summary) - - # Run FI Related stats and plots - self.fi_stats(metric_dict) - - # Export phase runtime - self.save_runtime() - - # Parse all pipeline runtime files into a single runtime report - self.parse_runtime() - - # Print phase completion - logging.info(self.data_name + " phase 5 complete") - job_file = open(self.experiment_path + '/jobsCompleted/job_stats_' + self.data_name + '.txt', 'w') - job_file.write('complete') - job_file.close() - - def fi_stats(self, metric_dict): - metric_ranking = 'mean' - metric_weighting = 'mean' - - # mean or median #Ryan add a run parameter to STREAMLINE to - # allow user to decide plot rankings for FI using mean by default - # Prepare for feature importance visualizations - logging.info('Preparing for Model Feature Importance Plotting...') - - # old - 'Balanced Accuracy' - fi_df_list, fi_med_list, fi_med_norm_list, med_metric_list, all_feature_list, \ - non_zero_union_features, \ - non_zero_union_indexes = self.prep_fi(metric_dict, metric_ranking, metric_weighting) - - # Select 'top' features for composite visualisation - features_to_viz = self.select_for_composite_viz(non_zero_union_features, non_zero_union_indexes, - med_metric_list, fi_med_norm_list) - - # Generate FI boxplots for each modeling algorithm if specified by user - if self.plot_fi_box: - logging.info('Generating Feature Importance Boxplot and Histograms...') - self.do_fi_boxplots(fi_df_list, fi_med_list, metric_ranking) - self.do_fi_histogram(fi_med_list, metric_ranking) - - # Visualize composite FI - Currently set up to only use Balanced Accuracy for composite FI plot visualization - logging.info('Generating Composite Feature Importance Plots...') - # Take top feature names to visualize and get associated feature importance values for each algorithm, - # and original data ordered feature names list - # If we want composite FI plots to be displayed in descending total bar height order. - top_fi_med_norm_list, all_feature_list_to_viz = self.get_fi_to_viz_sorted(features_to_viz, all_feature_list, - fi_med_norm_list) - - # Generate Normalized composite FI plot - - if metric_ranking == 'mean': - self.composite_fi_plot(top_fi_med_norm_list, all_feature_list_to_viz, 'Norm', - 'Normalized Mean Feature Importance', metric_ranking, metric_weighting) - elif metric_ranking == 'median': - self.composite_fi_plot(top_fi_med_norm_list, all_feature_list_to_viz, 'Norm', - 'Normalized Median Feature Importance', metric_ranking, metric_weighting) - else: - print("Error: metric_ranking selection not found (must be mean or median)") - - # # Fractionate FI scores for normalized and fractionated composite FI plot - # frac_lists = self.frac_fi(top_fi_med_norm_list) - - # # Generate Normalized and Fractionated composite FI plot - # composite_fi_plot(frac_lists, algorithms, list(colors.values()), - # all_feature_list_to_viz, 'Norm_Frac', - # 'Normalized and Fractionated Feature Importance') - - # Weight FI scores for normalized and (model performance) weighted composite FI plot - weighted_lists, weights = self.weight_fi(med_metric_list, top_fi_med_norm_list) - - # Generate Normalized and Weighted Compound FI plot - if metric_ranking == 'mean': - self.composite_fi_plot(weighted_lists, all_feature_list_to_viz, - 'Norm_Weight', 'Normalized and Weighted Mean Feature Importance', metric_ranking, - metric_weighting) - elif metric_ranking == 'median': - self.composite_fi_plot(weighted_lists, all_feature_list_to_viz, - 'Norm_Weight', 'Normalized and Weighted Median Feature Importance', metric_ranking, - metric_weighting) - else: - print("Error: metric_ranking selection not found (must be mean or median)") - - # Weight the Fractionated FI scores for normalized,fractionated, and weighted compound FI plot - # weighted_frac_lists = self.weight_frac_fi(frac_lists,weights) - - # Generate Normalized, Fractionated, and Weighted Compound FI plot - # self.composite_fi_plot(weighted_frac_lists, algorithms, list(colors.values()), - # all_feature_list_to_viz, 'Norm_Frac_Weight', - # 'Normalized, Fractionated, and Weighted Feature Importance') - - def preparation(self): - """ - Creates directory for all results files, decodes included ML modeling - algorithms that were run - """ - # Create Directory - if not os.path.exists(self.full_path + '/model_evaluation'): - os.mkdir(self.full_path + '/model_evaluation') - if not os.path.exists(self.full_path + '/model_evaluation/feature_importance/'): - os.mkdir(self.full_path + '/model_evaluation/feature_importance/') - - def primary_stats(self, master_list=None, rep_data=None): - """ - Combine classification metrics and model feature importance scores - as well as ROC and PRC plot data across all CV datasets. - Generate ROC and PRC plots comparing separate CV models for each individual modeling algorithm. - """ - result_table = [] - metric_dict = {} - - # completed for each individual ML modeling algorithm - for algorithm in self.algorithms: - - # stores values used in ROC and PRC plots - alg_result_table = [] - - # Define evaluation stats variable lists - s_bac, s_ac, s_f1, s_re, s_sp, s_pr, s_tp, s_tn, s_fp, s_fn, s_npv, s_lrp, s_lrm = [[] for _ in range(13)] - - # Define feature importance lists - # used to save model feature importance individually for - # each cv within single summary file (all original features - # in dataset prior to feature selection included) - fi_all = [] - - # Define ROC plot variable lists - tprs = [] # stores interpolated true positive rates for average CV line in ROC - aucs = [] # stores individual CV areas under ROC curve to calculate average - - mean_fpr = np.linspace(0, 1, 100) # used to plot average of CV line in ROC plot - mean_recall = np.linspace(0, 1, 100) # used to plot average of CV line in PRC plot - - # Define PRC plot variable lists - precs = [] # stores interpolated precision values for average CV line in PRC - praucs = [] # stores individual CV areas under PRC curve to calculate average - aveprecs = [] # stores individual CV average precisions for PRC to calculate CV average - - # Gather statistics over all CV partitions - for cv_count in range(0, self.cv_partitions): - - if master_list is None: - - # Unpickle saved metrics from previous phase - result_file = self.full_path + '/model_evaluation/pickled_metrics/' \ - + self.abbrev[algorithm] + "_CV_" + str(cv_count) + "_metrics.pickle" - file = open(result_file, 'rb') - results = pickle.load(file) - # [metricList, fpr, tpr, roc_auc, prec, recall, prec_rec_auc, ave_prec, fi, probas_] - file.close() - - # Separate pickled results - metric_list, fpr, tpr, roc_auc, prec, recall, prec_rec_auc, ave_prec, fi, probas_ = results - else: - results = master_list[cv_count][algorithm] - # grabs evalDict for a specific algorithm entry (with data values) - metric_list = results[0] - fpr = results[1] - tpr = results[2] - roc_auc = results[3] - prec = results[4] - recall = results[5] - prec_rec_auc = results[6] - ave_prec = results[7] - fi = results[8] - probas_ = results[9] - - # Separate metrics from metricList - s_bac.append(metric_list[0]) - s_ac.append(metric_list[1]) - s_f1.append(metric_list[2]) - s_re.append(metric_list[3]) - s_sp.append(metric_list[4]) - s_pr.append(metric_list[5]) - s_tp.append(metric_list[6]) - s_tn.append(metric_list[7]) - s_fp.append(metric_list[8]) - s_fn.append(metric_list[9]) - s_npv.append(metric_list[10]) - s_lrp.append(metric_list[11]) - s_lrm.append(metric_list[12]) - - # update list that stores values used in ROC and PRC plots - alg_result_table.append([fpr, tpr, roc_auc, prec, recall, prec_rec_auc, - ave_prec]) - - # Update ROC plot variable lists needed to plot all CVs in one ROC plot - tprs.append(np.interp(mean_fpr, fpr, tpr)) - tprs[-1][0] = 0.0 - aucs.append(roc_auc) - - # Update PRC plot variable lists needed to plot all CVs in one PRC plot - precs.append(np.interp(mean_recall, recall, prec)) - praucs.append(prec_rec_auc) - aveprecs.append(ave_prec) - - if master_list is None: - # Format feature importance scores as list - # (takes into account that all features are not in each CV partition) - temp_list = [] - j = 0 - headers = pd.read_csv( - self.full_path + '/CVDatasets/' + self.data_name - + '_CV_' + str(cv_count) + '_Test.csv').columns.values.tolist() - if self.instance_label is not None: # Match label will never be in CV datasets - if self.instance_label in headers: - headers.remove(self.instance_label) - headers.remove(self.class_label) - # for each in self.original_headers: - for each in self.feature_headers: - # Check if current feature from original dataset was in the partition - if each in headers: - # Deal with features not being in original order (find index of current feature list.index() - f_index = headers.index(each) - temp_list.append(fi[f_index]) - else: - temp_list.append(0) - j += 1 - fi_all.append(temp_list) - - logging.info("Running stats on " + algorithm) - - # Define values for the mean ROC line (mean of individual CVs) - mean_tpr = np.mean(tprs, axis=0) - mean_tpr[-1] = 1.0 - mean_auc = np.mean(aucs) - if self.plot_roc: - self.do_model_roc(algorithm, tprs, aucs, mean_fpr, alg_result_table) - - # Define values for the mean PRC line (mean of individual CVs) - mean_prec = np.mean(precs, axis=0) - mean_pr_auc = np.mean(praucs) - if self.plot_prc: - if master_list is None: - self.do_model_prc(algorithm, precs, praucs, mean_recall, alg_result_table) - else: - self.do_model_prc(algorithm, precs, praucs, mean_recall, alg_result_table, rep_data, True) - - # Export and save all CV metric stats for each individual algorithm - results = {'Balanced Accuracy': s_bac, 'Accuracy': s_ac, 'F1 Score': s_f1, 'Sensitivity (Recall)': s_re, - 'Specificity': s_sp, 'Precision (PPV)': s_pr, 'TP': s_tp, 'TN': s_tn, 'FP': s_fp, 'FN': s_fn, - 'NPV': s_npv, 'LR+': s_lrp, 'LR-': s_lrm, 'ROC AUC': aucs, 'PRC AUC': praucs, - 'PRC APS': aveprecs} - dr = pd.DataFrame(results) - filepath = self.full_path + '/model_evaluation/' + self.abbrev[algorithm] + "_performance.csv" - dr.to_csv(filepath, header=True, index=False) - metric_dict[algorithm] = results - - # Save FI scores for all CV models - if master_list is None: - self.save_fi(fi_all, self.abbrev[algorithm], self.feature_headers) - # self.save_fi(fi_all, self.abbrev[algorithm], self.original_headers) #bug - # Store ave metrics for creating global ROC and PRC plots later - mean_ave_prec = np.mean(aveprecs) - # result_dict = {'algorithm':algorithm,'fpr':mean_fpr, 'tpr':mean_tpr, - # 'auc':mean_auc, 'prec':mean_prec, 'pr_auc':mean_pr_auc, - # 'ave_prec':mean_ave_prec} - result_dict = {'algorithm': algorithm, 'fpr': mean_fpr, 'tpr': mean_tpr, - 'auc': mean_auc, 'prec': mean_prec, 'recall': mean_recall, - 'pr_auc': mean_pr_auc, 'ave_prec': mean_ave_prec} - result_table.append(result_dict) - - # Result table later used to create global ROC an PRC plots comparing average ML algorithm performance. - result_table = pd.DataFrame.from_dict(result_table) - result_table.set_index('algorithm', inplace=True) - return result_table, metric_dict - - def save_fi(self, fi_all, algorithm, global_feature_list): - """ - Creates directory to store model feature importance results and, - for each algorithm, exports a file of feature importance scores from each CV. - """ - dr = pd.DataFrame(fi_all) - if not os.path.exists(self.full_path + '/model_evaluation/feature_importance/'): - os.mkdir(self.full_path + '/model_evaluation/feature_importance/') - filepath = self.full_path + '/model_evaluation/feature_importance/' + algorithm + "_FI.csv" - dr.to_csv(filepath, header=global_feature_list, index=False) - - def do_model_roc(self, algorithm, tprs, aucs, mean_fpr, alg_result_table): - - # Define values for the mean ROC line (mean of individual CVs) - mean_tpr = np.mean(tprs, axis=0) - mean_tpr[-1] = 1.0 - mean_auc = np.mean(aucs) - - # Generate ROC Plot (including individual CV's lines, average line, and no skill line) - # based on https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc_crossval.html - - if self.plot_roc: - # Set figure dimensions - plt.rcParams["figure.figsize"] = (6, 6) - # Plot individual CV ROC lines - for i in range(self.cv_partitions): - plt.plot(alg_result_table[i][0], alg_result_table[i][1], lw=1, alpha=0.3, - label='ROC fold %d (AUC = %0.3f)' % (i, alg_result_table[i][2])) - # Plot no-skill line - plt.plot([0, 1], [0, 1], - linestyle='--', lw=2, color='black', label='No-Skill', alpha=.8) - # Plot average line for all CVs - std_auc = np.std(aucs) # AUC standard deviations across CVs - plt.plot(mean_fpr, mean_tpr, color=self.colors[algorithm], - label=r'Mean ROC (AUC = %0.3f $\pm$ %0.3f)' % (float(mean_auc), float(std_auc)), - lw=2, alpha=.8) - - # Plot standard deviation grey zone of curves - std_tpr = np.std(tprs, axis=0) - tprs_upper = np.minimum(mean_tpr + std_tpr, 1) - tprs_lower = np.maximum(mean_tpr - std_tpr, 0) - plt.fill_between(mean_fpr, tprs_lower, tprs_upper, color='grey', alpha=.2, label=r'$\pm$ 1 std. dev.') - # Specify plot axes,labels, and legend - plt.xlim([-0.05, 1.05]) - plt.ylim([-0.05, 1.05]) - plt.xlabel('False Positive Rate') - plt.ylabel('True Positive Rate') - plt.title(algorithm) - plt.legend(loc="upper left", bbox_to_anchor=(1.01, 1)) - # Export and/or show plot - plt.savefig(self.full_path + '/model_evaluation/' + - self.abbrev[algorithm] + "_ROC.png", bbox_inches="tight") - if self.show_plots: - plt.show() - else: - plt.close('all') - # plt.cla() # not required - - def do_model_prc(self, algorithm, precs, praucs, mean_recall, alg_result_table, rep_data=None, replicate=False): - # Define values for the mean PRC line (mean of individual CVs) - mean_prec = np.mean(precs, axis=0) - mean_pr_auc = np.mean(praucs) - - # Generate PRC Plot (including individual CV's lines, average line, and no skill line) - if self.plot_prc: - # Set figure dimensions - plt.rcParams["figure.figsize"] = (6, 6) - # Plot individual CV PRC lines - for i in range(self.cv_partitions): - plt.plot(alg_result_table[i][4], alg_result_table[i][3], lw=1, alpha=0.3, - label='PRC fold %d (AUC = %0.3f)' % (i, alg_result_table[i][5])) - # Estimate no skill line based on the fraction of cases found in the first test dataset - # Technically there could be a unique no-skill line for each CV dataset based - # on final class balance (however only one is needed, and stratified CV attempts - # to keep partitions with similar/same class balance) - - if not replicate: - # Estimate no skill line based on the fraction of cases found in the first test dataset - test = pd.read_csv( - self.full_path + '/CVDatasets/' + self.data_name + '_CV_0_Test.csv') - - test_y = test[self.class_label].values - else: - test_y = rep_data[self.class_label].values - - no_skill = len(test_y[test_y == 1]) / len(test_y) # Fraction of cases - # Plot no-skill line - plt.plot([0, 1], [no_skill, no_skill], color='black', linestyle='--', label='No-Skill', alpha=.8) - # Plot average line for all CVs - std_pr_auc = np.std(praucs) - plt.plot(mean_recall, mean_prec, color=self.colors[algorithm], - label=r'Mean PRC (AUC = %0.3f $\pm$ %0.3f)' % (float(mean_pr_auc), float(std_pr_auc)), - lw=2, alpha=.8) - # Plot standard deviation grey zone of curves - std_prec = np.std(precs, axis=0) - precs_upper = np.minimum(mean_prec + std_prec, 1) - precs_lower = np.maximum(mean_prec - std_prec, 0) - plt.fill_between(mean_recall, precs_lower, precs_upper, color='grey', - alpha=.2, label=r'$\pm$ 1 std. dev.') - # Specify plot axes,labels, and legend - plt.xlim([-0.05, 1.05]) - plt.ylim([-0.05, 1.05]) - plt.xlabel('Recall (Sensitivity)') - plt.ylabel('Precision (PPV)') - plt.title(algorithm) - plt.legend(loc="upper left", bbox_to_anchor=(1.01, 1)) - # Export and/or show plot - plt.savefig(self.full_path + '/model_evaluation/' + - self.abbrev[algorithm] + "_PRC.png", bbox_inches="tight") - if self.show_plots: - plt.show() - else: - plt.close('all') - # plt.cla() # not required - - def do_plot_roc(self, result_table): - """ - Generate ROC plot comparing average ML algorithm performance - (over all CV training/testing sets) - """ - count = 0 - # Plot curves for each individual ML algorithm - for i in result_table.index: - # plt.plot(result_table.loc[i]['fpr'],result_table.loc[i]['tpr'], - # color=colors[i],label="{}, AUC={:.3f}".format(i, result_table.loc[i]['auc'])) - plt.plot(result_table.loc[i]['fpr'], result_table.loc[i]['tpr'], color=self.colors[i], - label="{}, AUC={:.3f}".format(i, result_table.loc[i]['auc'])) - count += 1 - # Set figure dimensions - plt.rcParams["figure.figsize"] = (6, 6) - # Plot no-skill line - plt.plot([0, 1], [0, 1], color='black', linestyle='--', label='No-Skill', alpha=.8) - # Specify plot axes,labels, and legend - plt.xticks(np.arange(0.0, 1.1, step=0.1)) - plt.xlabel("False Positive Rate", fontsize=15) - plt.yticks(np.arange(0.0, 1.1, step=0.1)) - plt.ylabel("True Positive Rate", fontsize=15) - plt.legend(loc="upper left", bbox_to_anchor=(1.01, 1)) - # Export and/or show plot - plt.savefig(self.full_path + '/model_evaluation/Summary_ROC.png', bbox_inches="tight") - if self.show_plots: - plt.show() - else: - plt.close('all') - # plt.cla() # not required - - def do_plot_prc(self, result_table, rep_data=None, replicate=False): - """ - Generate PRC plot comparing average ML algorithm performance - (over all CV training/testing sets) - """ - count = 0 - # Plot curves for each individual ML algorithm - for i in result_table.index: - plt.plot(result_table.loc[i]['recall'], result_table.loc[i]['prec'], color=self.colors[i], - label="{}, AUC={:.3f}, APS={:.3f}".format(i, result_table.loc[i]['pr_auc'], - result_table.loc[i]['ave_prec'])) - count += 1 - - if not replicate: - # Estimate no skill line based on the fraction of cases found in the first test dataset - test = pd.read_csv(self.full_path + '/CVDatasets/' + self.data_name + '_CV_0_Test.csv') - if self.instance_label is not None: - test = test.drop(self.instance_label, axis=1) - test_y = test[self.class_label].values - else: - test_y = rep_data[self.class_label].values - - no_skill = len(test_y[test_y == 1]) / len(test_y) # Fraction of cases - - # Plot no-skill line - plt.plot([0, 1], [no_skill, no_skill], color='black', linestyle='--', label='No-Skill', alpha=.8) - # Specify plot axes,labels, and legend - plt.xticks(np.arange(0.0, 1.1, step=0.1)) - plt.xlabel("Recall (Sensitivity)", fontsize=15) - plt.yticks(np.arange(0.0, 1.1, step=0.1)) - plt.ylabel("Precision (PPV)", fontsize=15) - plt.legend(loc="upper left", bbox_to_anchor=(1.01, 1)) - # Export and/or show plot - plt.savefig(self.full_path + '/model_evaluation/Summary_PRC.png', bbox_inches="tight") - if self.show_plots: - plt.show() - else: - plt.close('all') - # plt.cla() # not required - - def save_metric_stats(self, metrics, metric_dict): - """ - Exports csv file with mean, median and std dev metric values - (over all CVs) for each ML modeling algorithm - """ - # TODO: Clean this function up, save everything together - with open(self.full_path + '/model_evaluation/Summary_performance_median.csv', mode='w', newline="") as file: - writer = csv.writer(file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) - e = [''] - e.extend(metrics) - writer.writerow(e) # Write headers (balanced accuracy, etc.) - for algorithm in metric_dict: - astats = [] - for li in list(metric_dict[algorithm].values()): - li = [float(i) for i in li] - mediani = median(li) - astats.append(str(mediani)) - to_add = [algorithm] - to_add.extend(astats) - writer.writerow(to_add) - file.close() - with open(self.full_path + '/model_evaluation/Summary_performance_mean.csv', mode='w', newline="") as file: - writer = csv.writer(file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) - e = [''] - e.extend(metrics) - writer.writerow(e) # Write headers (balanced accuracy, etc.) - for algorithm in metric_dict: - astats = [] - for li in list(metric_dict[algorithm].values()): - li = [float(i) for i in li] - meani = mean(li) - astats.append(str(meani)) - to_add = [algorithm] - to_add.extend(astats) - writer.writerow(to_add) - file.close() - with open(self.full_path + '/model_evaluation/Summary_performance_std.csv', mode='w', newline="") as file: - writer = csv.writer(file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) - e = [''] - e.extend(metrics) - writer.writerow(e) # Write headers (balanced accuracy, etc.) - for algorithm in metric_dict: - astats = [] - for li in list(metric_dict[algorithm].values()): - li = [float(i) for i in li] - std = stdev(li) - astats.append(str(std)) - to_add = [algorithm] - to_add.extend(astats) - writer.writerow(to_add) - file.close() - - def metric_boxplots(self, metrics, metric_dict): - """ - Export boxplots comparing algorithm performance for each standard metric - """ - if not os.path.exists(self.full_path + '/model_evaluation/metricBoxplots'): - os.mkdir(self.full_path + '/model_evaluation/metricBoxplots') - for metric in metrics: - temp_list = [] - for algorithm in self.algorithms: - temp_list.append(metric_dict[algorithm][metric]) - td = pd.DataFrame(temp_list) - td = td.transpose().astype('float') - - td.columns = self.algorithms - - # Generate boxplot - td.plot(kind='box', rot=90) - # Specify plot labels - plt.ylabel(str(metric)) - plt.xlabel('ML Algorithm') - # Export and/or show plot - plt.savefig(self.full_path + - '/model_evaluation/metricBoxplots/Compare_' + metric + '.png', bbox_inches="tight") - if self.show_plots: - plt.show() - else: - plt.close('all') - # plt.cla() # not required - - def kruskal_wallis(self, metrics, metric_dict): - """ - Apply non-parametric Kruskal Wallis one-way ANOVA on ranks. - Determines if there is a statistically significant difference in algorithm performance across CV runs. - Completed for each standard metric separately. - """ - # Create directory to store significance testing results (used for both Kruskal Wallis and MannWhitney U-test) - if not os.path.exists(self.full_path + '/model_evaluation/statistical_comparisons'): - os.mkdir(self.full_path + '/model_evaluation/statistical_comparisons') - # Create dataframe to store analysis results for each metric - label = ['Statistic', 'P-Value', 'Sig(*)'] - kruskal_summary = pd.DataFrame(index=metrics, columns=label) - # Apply Kruskal Wallis test for each metric - for metric in metrics: - temp_array = [] - for algorithm in self.algorithms: - temp_array.append(metric_dict[algorithm][metric]) - try: - result = kruskal(*temp_array) - except Exception: - result = [temp_array[0], 1] - kruskal_summary.at[metric, 'Statistic'] = str(round(result[0], 6)) - kruskal_summary.at[metric, 'P-Value'] = str(round(result[1], 6)) - if result[1] < self.sig_cutoff: - kruskal_summary.at[metric, 'Sig(*)'] = str('*') - else: - kruskal_summary.at[metric, 'Sig(*)'] = str('') - # Export analysis summary to .csv file - kruskal_summary.to_csv(self.full_path + '/model_evaluation/statistical_comparisons/KruskalWallis.csv') - return kruskal_summary - - def wilcoxon_rank(self, metrics, metric_dict, kruskal_summary): - """ - Apply non-parametric Wilcoxon signed-rank test (pairwise comparisons). - If a significant Kruskal Wallis algorithm difference was found for a - given metric, Wilcoxon tests individual algorithm pairs - to determine if there is a statistically significant difference in - algorithm performance across CV runs. Test statistic will be zero if - all scores from one set are - larger than the other. - """ - for metric in metrics: - if kruskal_summary['Sig(*)'][metric] == '*': - wilcoxon_stats = [] - done = [] - for algorithm1 in self.algorithms: - for algorithm2 in self.algorithms: - if (not [algorithm1, algorithm2] in done) and \ - (not [algorithm2, algorithm1] in done) and (algorithm1 != algorithm2): - set1 = metric_dict[algorithm1][metric] - set2 = metric_dict[algorithm2][metric] - # handle error when metric values are equal for both algorithms - if set1 == set2: # Check if all nums are equal in sets - report = ['NA', 1] - else: # Apply Wilcoxon Rank Sum test - try: - report = wilcoxon(set1, set2) - except Exception: - report = ['NA_error', 1] - # Summarize test information in list - tempstats = [algorithm1, algorithm2, report[0], report[1], ''] - if report[1] < self.sig_cutoff: - tempstats[4] = '*' - wilcoxon_stats.append(tempstats) - done.append([algorithm1, algorithm2]) - # Export test results - wilcoxon_stats_df = pd.DataFrame(wilcoxon_stats) - wilcoxon_stats_df.columns = ['Algorithm 1', 'Algorithm 2', 'Statistic', 'P-Value', 'Sig(*)'] - wilcoxon_stats_df.to_csv(self.full_path - + '/model_evaluation/statistical_comparisons/' - 'WilcoxonRank_' + metric + '.csv', index=False) - - def mann_whitney_u(self, metrics, metric_dict, kruskal_summary): - """ - Apply non-parametric Mann Whitney U-test (pairwise comparisons). - If a significant Kruskal Wallis algorithm difference was found for - a given metric, Mann Whitney tests individual algorithm pairs - to determine if there is a statistically significant difference - in algorithm performance across CV runs. Test statistic will be - zero if all scores from one set are larger than the other. - """ - for metric in metrics: - if kruskal_summary['Sig(*)'][metric] == '*': - mann_stats = [] - done = [] - for algorithm1 in self.algorithms: - for algorithm2 in self.algorithms: - if (not [algorithm1, algorithm2] in done) and \ - (not [algorithm2, algorithm1] in done) and (algorithm1 != algorithm2): - set1 = metric_dict[algorithm1][metric] - set2 = metric_dict[algorithm2][metric] - if set1 == set2: # Check if all nums are equal in sets - report = ['NA', 1] - else: # Apply Mann Whitney U test - try: - report = mannwhitneyu(set1, set2) - except Exception: - report = ['NA_error', 1] - # Summarize test information in list - tempstats = [algorithm1, algorithm2, report[0], report[1], ''] - if report[1] < self.sig_cutoff: - tempstats[4] = '*' - mann_stats.append(tempstats) - done.append([algorithm1, algorithm2]) - # Export test results - mann_stats_df = pd.DataFrame(mann_stats) - mann_stats_df.columns = ['Algorithm 1', 'Algorithm 2', 'Statistic', 'P-Value', 'Sig(*)'] - mann_stats_df.to_csv(self.full_path + - '/model_evaluation/' - 'statistical_comparisons/MannWhitneyU_' + metric + '.csv', index=False) - - def prep_fi(self, metric_dict, metric_ranking, metric_weighting): - """ - Organizes and prepares model feature importance - data for boxplot and composite feature importance figure generation. - """ - # Initialize required lists - # algorithm feature importance dataframe list (used to generate FI boxplot for each algorithm) - fi_df_list = [] - # algorithm feature importance medians list (used to generate composite FI barplots) - fi_med_list = [] - # algorithm focus metric medians list (used in weighted FI viz) - med_metric_list = [] - # list of pre-feature selection feature names as they appear in FI reports for each algorithm - all_feature_list = [] - - # Get necessary feature importance data and primary metric data - # (currently only 'balanced accuracy' can be used for this) - for algorithm in self.algorithms: - # Get relevant feature importance info - temp_df = pd.read_csv(self.full_path + '/model_evaluation/feature_importance/' + self.abbrev[ - algorithm] + "_FI.csv") # CV FI scores for all original features in dataset. - # Should be same for all algorithm files (i.e. all original features in standard CV dataset order) - if algorithm == self.algorithms[0]: - all_feature_list = temp_df.columns.tolist() - fi_df_list.append(temp_df) - if metric_ranking == 'mean': - fi_med_list.append(temp_df.mean().tolist()) # Saves mean FI scores over CV runs - elif metric_ranking == 'median': - fi_med_list.append(temp_df.median().tolist()) # Saves median FI scores over CV runs - else: - raise Exception("Error: metric_ranking selection not found (must be mean or median)") - - # Get relevant metric info - if metric_weighting == 'mean': - med_ba = mean(metric_dict[algorithm][self.metric_weight]) - elif metric_weighting == 'median': - med_ba = median(metric_dict[algorithm][self.metric_weight]) - else: # use mean as backup - raise Exception("Error: metric_weighting selection not found (must be mean or median)") - med_metric_list.append(med_ba) - - # Normalize Median Feature importance scores, so they fall between (0 - 1) - fi_med_norm_list = [] - for each in fi_med_list: # each algorithm - norm_list = [] - for i in range(len(each)): # each feature (score) in original data order - if each[i] <= 0: # Feature importance scores assumed to be uninformative if at or below 0 - norm_list.append(0) - else: - norm_list.append((each[i]) / (max(each))) - fi_med_norm_list.append(norm_list) - - # Identify features with non-zero medians - # (step towards excluding features that had zero feature importance for all algorithms) - alg_non_zero_fi_list = [] # stores list of feature name lists that are non-zero for each algorithm - for each in fi_med_list: # each algorithm - temp_non_zero_list = [] - for i in range(len(each)): # each feature - if each[i] > 0.0: - # add feature names with positive values (doesn't need to be normalized for this) - temp_non_zero_list.append(all_feature_list[i]) - alg_non_zero_fi_list.append(temp_non_zero_list) - non_zero_union_features = alg_non_zero_fi_list[0] # grab first algorithm's list - # Identify union of features with non-zero averages over all algorithms - # (i.e. if any algorithm found a non-zero score it will be considered - # for inclusion in top feature visualizations) - for j in range(1, len(self.algorithms)): - non_zero_union_features = list(set(non_zero_union_features) | set(alg_non_zero_fi_list[j])) - non_zero_union_indexes = [] - for i in non_zero_union_features: - non_zero_union_indexes.append(all_feature_list.index(i)) - # return fi_df_list, fi_ave_list, fi_ave_norm_list, ave_metric_list,\ - # all_feature_list, non_zero_union_features, non_zero_union_indexes - return fi_df_list, fi_med_list, fi_med_norm_list, med_metric_list, \ - all_feature_list, non_zero_union_features, non_zero_union_indexes - - def select_for_composite_viz(self, non_zero_union_features, - non_zero_union_indexes, - ave_metric_list, fi_ave_norm_list): - """ - Identify list of top features over all algorithms to visualize - (note that best features to visualize are chosen using algorithm - performance weighting and normalization: - frac plays no useful role here only for viz). All features included - if there are fewer than 'top_model_features'. Top features are - determined by the sum of performance - (i.e. balanced accuracy) weighted feature importance over all algorithms. - """ - # Create performance weighted score sum dictionary for all features - score_sum_dict = {} - i = 0 - for each in non_zero_union_features: # for each non-zero feature - for j in range(len(self.algorithms)): # for each algorithm - # grab target score from each algorithm - score = fi_ave_norm_list[j][non_zero_union_indexes[i]] - # multiply score by algorithm performance weight - weight = ave_metric_list[j] - if weight <= .5: # This is why this method is limited to balanced_accuracy and roc_auc - weight = 0 - if not weight == 0: - weight = (weight - 0.5) / 0.5 - score = score * weight - if not (each in score_sum_dict): - score_sum_dict[each] = score - else: - score_sum_dict[each] += score - i += 1 - # Sort features by decreasing score - score_sum_dict_features = sorted(score_sum_dict, key=lambda x: score_sum_dict[x], reverse=True) - # Keep all features if there are fewer than specified top results - if len(non_zero_union_features) > self.top_features: - features_to_viz = score_sum_dict_features[0:self.top_features] - else: - features_to_viz = score_sum_dict_features - return features_to_viz # list of feature names to visualize in composite FI plots. - - def do_fi_boxplots(self, fi_df_list, fi_med_list, metric_ranking): - """ - Generate individual feature importance boxplot for each algorithm - """ - algorithm_counter = 0 - for algorithm in self.algorithms: # each algorithms - # Make median feature importance score dictionary - score_dict = {} - counter = 0 - for med_score in fi_med_list[algorithm_counter]: # each feature - # score_dict[self.original_headers[counter]] = med_score - score_dict[self.feature_headers[counter]] = med_score - counter += 1 - # Sort features by decreasing score - score_dict_features = sorted(score_dict, key=lambda x: score_dict[x], reverse=True) - # Make list of feature names to visualize - # if len(self.original_headers) > self.top_features: - if len(self.feature_headers) > self.top_features: - features_to_viz = score_dict_features[0:self.top_features] - else: - features_to_viz = score_dict_features - # FI score dataframe for current algorithm - df = fi_df_list[algorithm_counter] - # Subset of dataframe (in ranked order) to visualize - viz_df = df[features_to_viz] - # Generate Boxplot - plt.figure(figsize=(15, 4)) - viz_df.boxplot(rot=90) - plt.title(algorithm) - plt.ylabel('Feature Importance') - if metric_ranking == 'mean': - plt.xlabel('Features (Mean Ranking)') - elif metric_ranking == 'median': - plt.xlabel('Features (Median Ranking)') - else: - print("Error: metric_ranking selection not found (must be mean or median)") - plt.xticks(np.arange(1, len(features_to_viz) + 1), features_to_viz, rotation='vertical') - plt.savefig(self.full_path + '/model_evaluation/feature_importance/' + algorithm + '_boxplot', - bbox_inches="tight") - if self.show_plots: - plt.show() - else: - plt.close('all') - # plt.cla() # not required - # Identify and sort (decreasing) features with top median FI - algorithm_counter += 1 - - def do_fi_histogram(self, fi_med_list, metric_ranking): - """ - Generate histogram showing distribution of median feature importance scores for each algorithm. - """ - algorithm_counter = 0 - for algorithm in self.algorithms: # each algorithms - med_scores = fi_med_list[algorithm_counter] - # Plot a histogram of average feature importance - plt.hist(med_scores, bins=100) - if metric_ranking == 'mean': - plt.xlabel("Mean Feature Importance") - elif metric_ranking == 'median': - plt.xlabel("Median Feature Importance") - else: - print("Error: metric_ranking selection not found (must be mean or median)") - plt.ylabel("Frequency") - plt.title(str(algorithm)) - plt.xticks(rotation='vertical') - plt.savefig(self.full_path - + '/model_evaluation/' - 'feature_importance/' + algorithm + '_histogram', bbox_inches="tight") - if self.show_plots: - plt.show() - else: - plt.close('all') - # plt.cla() # not required - - def composite_fi_plot(self, fi_list, all_feature_list_to_viz, fig_name, - y_label_text, metric_ranking, metric_weighting): - """ - Generate composite feature importance plot given list of feature names - and associated feature importance scores for each algorithm. - This is run for different transformations of the normalized feature importance scores. - """ - alg_colors = [COLORS[k] for k in self.algorithms] - algorithms, alg_colors, fi_list = (list(t) for t in zip(*sorted(zip(self.algorithms, alg_colors, fi_list), reverse=True))) - # Set basic plot properties - rc('font', weight='bold', size=16) - # The position of the bars on the x-axis - r = all_feature_list_to_viz # feature names - # Set width of bars - bar_width = 0.75 - # Set figure dimensions - plt.figure(figsize=(24, 12)) - # Plot first algorithm FI scores (lowest) bar - p1 = plt.bar(r, fi_list[0], color=alg_colors[0], edgecolor='white', width=bar_width) - # Automatically calculate space needed to plot next bar on top of the one before it - bottoms = [] # list of space used by previous - # algorithms for each feature (so next bar can be placed directly above it) - bottom = None - for i in range(len(algorithms) - 1): - for j in range(i + 1): - if j == 0: - bottom = np.array(fi_list[0]).astype('float64') - else: - bottom += np.array(fi_list[j]).astype('float64') - bottoms.append(bottom) - if not isinstance(bottoms, list): - bottoms = bottoms.tolist() - if len(self.algorithms) > 1: - # Plot subsequent feature bars for each subsequent algorithm - ps = [p1[0]] - for i in range(len(algorithms) - 1): - p = plt.bar(r, fi_list[i + 1], bottom=bottoms[i], color=alg_colors[i + 1], edgecolor='white', - width=bar_width) - ps.append(p[0]) - lines = tuple(ps) - else: - ps = [p1[0]] - lines = tuple(ps) - # Specify axes info and legend - plt.xticks(np.arange(len(all_feature_list_to_viz)), all_feature_list_to_viz, rotation='vertical') - plt.xlabel("Features (ranked by sum of " + metric_ranking + " feature importance: weighted by " + - metric_weighting + " model " + self.metric_weight.lower() + ")", fontsize=20) - plt.ylabel(y_label_text, fontsize=20) - plt.legend(lines[::-1], algorithms[::-1],loc="upper left", bbox_to_anchor=(1.01,1)) #legend outside plot - # algorithms_list, lines_list = (list(t) for t in zip(*sorted(zip(algorithms, lines)))) - # plt.legend(lines_list, algorithms_list, loc="upper right") - # Export and/or show plot - plt.savefig(self.full_path + '/model_evaluation/feature_importance/Compare_FI_' + fig_name + '.png', - bbox_inches='tight') - if self.show_plots: - plt.show() - else: - plt.close('all') - # plt.cla() # not required - - def get_fi_to_viz_sorted(self, features_to_viz, all_feature_list, fi_med_norm_list): - """ - Takes a list of top features names for visualisation, gets their - indexes. In every composite FI plot features are ordered the same way - they are selected for visualisation (i.e. normalized and performance - weighted). Because of this feature bars are only perfectly ordered in - descending order for the normalized + performance weighted composite plot. - """ - # Get original feature indexs for selected feature names - feature_index_to_viz = [] # indexes of top features - for i in features_to_viz: - feature_index_to_viz.append(all_feature_list.index(i)) - # Create list of top feature importance values in original dataset feature order - top_fi_med_norm_list = [] # feature importance values of top features for each algorithm (list of lists) - for i in range(len(self.algorithms)): - temp_list = [] - for j in feature_index_to_viz: # each top feature index - temp_list.append(fi_med_norm_list[i][j]) # add corresponding FI value - top_fi_med_norm_list.append(temp_list) - all_feature_list_to_viz = features_to_viz - return top_fi_med_norm_list, all_feature_list_to_viz - - @staticmethod - def frac_fi(top_fi_med_norm_list): - """ - Transforms feature scores so that they sum to 1 over all features - for a given algorithm. This way the normalized and fracionated composit bar plot - offers equal total bar area for every algorithm. The intuition - here is that if an algorithm gives the same FI scores for all top features it won't be - overly represented in the resulting plot (i.e. all features can - have the same maximum feature importance which might lead to the impression that an - algorithm is working better than it is.) Instead, that maximum - 'bar-real-estate' has to be divided by the total number of features. Notably, this - transformation has the potential to alter total algorithm FI bar height ranking of features. - """ - frac_lists = [] - for each in top_fi_med_norm_list: # each algorithm - frac_list = [] - for i in range(len(each)): # each feature - if sum(each) == 0: # check that all feature scores are not zero to avoid zero division error - frac_list.append(0) - else: - frac_list.append((each[i] / (sum(each)))) - frac_lists.append(frac_list) - return frac_lists - - @staticmethod - def weight_fi(med_metric_list, top_fi_med_norm_list): - """ - Weights the feature importance scores by algorithm performance - (intuitive because when interpreting feature importances we want - to place more weight on better performing algorithms) - """ - # Prepare weights - weights = [] - # replace all balanced accuraces <=.5 with 0 (i.e. these are no better than random chance) - for i in range(len(med_metric_list)): - if med_metric_list[i] <= .5: - med_metric_list[i] = 0 - # normalize balanced accuracies - for i in range(len(med_metric_list)): - if med_metric_list[i] == 0: - weights.append(0) - else: - weights.append((med_metric_list[i] - 0.5) / 0.5) - # Weight normalized feature importances - weighted_lists = [] - for i in range(len(top_fi_med_norm_list)): # each algorithm - weight_list = np.multiply(weights[i], top_fi_med_norm_list[i]).tolist() - weighted_lists.append(weight_list) - return weighted_lists, weights - - @staticmethod - def weight_frac_fi(frac_lists, weights): - """ Weight normalized and fractionated feature importances. """ - weighted_frac_lists = [] - for i in range(len(frac_lists)): - weight_list = np.multiply(weights[i], frac_lists[i]).tolist() - weighted_frac_lists.append(weight_list) - return weighted_frac_lists - - def parse_runtime(self): - """ - Loads runtime summaries from entire pipeline and parses them into a single summary file. - """ - dict_obj = dict() - dict_obj['preprocessing'] = 0 - for file_path in glob.glob(self.full_path + '/runtime/*.txt'): - file_path = str(Path(file_path).as_posix()) - f = open(file_path, 'r') - val = float(f.readline()) - ref = file_path.split('/')[-1].split('_')[1].split('.')[0] - if ref in self.abbrev: - ref = self.abbrev[ref] - if not (ref in dict_obj): - if 'preprocessing' in ref: - dict_obj['preprocessing'] += val - dict_obj[ref] = val - else: - dict_obj[ref] += val - with open(self.full_path + '/runtimes.csv', mode='w', newline="") as file: - writer = csv.writer(file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) - writer.writerow(["Pipeline Component", "Phase", "Time (sec)"]) - writer.writerow(["Exploratory Analysis", 1, dict_obj['exploratory']]) - writer.writerow(["Scale and Impute", 2, dict_obj['preprocessing']]) - try: - writer.writerow(["Mutual Information (Feature Importance)", 3, dict_obj['mutual']]) - except KeyError: - pass - try: - writer.writerow(["MultiSURF (Feature Importance)", 3, dict_obj['multisurf']]) - except KeyError: - pass - writer.writerow(["Feature Selection", 4, dict_obj['featureselection']]) - for algorithm in self.algorithms: # Report runtimes for each algorithm - writer.writerow(([algorithm + "(Modeling)", 5, dict_obj[self.abbrev[algorithm]]])) - writer.writerow(["Stats Summary", 6, dict_obj['Stats']]) - - def save_runtime(self): - """ - Save phase runtime - """ - runtime_file = open(self.full_path + '/runtime/runtime_Stats.txt', 'w') - runtime_file.write(str(time.time() - self.job_start_time)) - runtime_file.close() diff --git a/streamline/runners/clean_runner.py b/streamline/runners/clean_runner.py deleted file mode 100644 index 644f848a..00000000 --- a/streamline/runners/clean_runner.py +++ /dev/null @@ -1,9 +0,0 @@ -from streamline.utils.cleanup import Cleaner - - -class CleanRunner: - def __init__(self, output_path, experiment_name, del_time=True, del_old_cv=True): - self.clean = Cleaner(output_path, experiment_name, del_time, del_old_cv) - - def run(self, run_parallel=None): - self.clean.run() diff --git a/streamline/runners/compare_runner.py b/streamline/runners/compare_runner.py deleted file mode 100644 index 54740e7c..00000000 --- a/streamline/runners/compare_runner.py +++ /dev/null @@ -1,135 +0,0 @@ -import os -import time -import dask -from pathlib import Path -from joblib import Parallel, delayed -from streamline.modeling.utils import SUPPORTED_MODELS -from streamline.modeling.utils import is_supported_model -from streamline.postanalysis.dataset_compare import CompareJob -from streamline.utils.runners import runner_fn -from streamline.utils.cluster import get_cluster - - -class CompareRunner: - """ - Runner Class for collating dataset compare job - """ - - def __init__(self, output_path, experiment_name, experiment_path=None, algorithms=None, exclude=("XCS", "eLCS"), - class_label="Class", instance_label=None, sig_cutoff=0.05, show_plots=False, - run_cluster=False, queue='defq', reserved_memory=4): - """ - Args: - output_path: path to output directory - experiment_name: name of experiment (no spaces) - algorithms: list of str of ML models to run - sig_cutoff: significance cutoff, default=0.05 - show_plots: flag to show plots - """ - self.output_path = output_path - self.experiment_name = experiment_name - self.class_label = class_label - self.instance_label = instance_label - self.experiment_path = experiment_path - - if algorithms is None: - self.algorithms = SUPPORTED_MODELS - if exclude is not None: - for algorithm in exclude: - try: - self.algorithms.remove(algorithm) - except Exception: - Exception("Unknown algorithm in exclude: " + str(algorithm)) - else: - self.algorithms = list() - for algorithm in algorithms: - self.algorithms.append(is_supported_model(algorithm)) - - self.algorithms = sorted(self.algorithms) - - self.sig_cutoff = sig_cutoff - self.show_plots = show_plots - - self.run_cluster = run_cluster - self.queue = queue - self.reserved_memory = reserved_memory - - # Argument checks - if not os.path.exists(self.output_path): - raise Exception("Output path must exist (from phase 1) before phase 6 can begin") - if not os.path.exists(self.output_path + '/' + self.experiment_name): - raise Exception("Experiment must exist (from phase 1) before phase 6 can begin") - - def run(self, run_parallel=False): - if self.run_cluster in ["SLURMOld", "LSFOld"]: - if self.run_cluster == "SLURMOld": - self.submit_slurm_cluster_job() - - if self.run_cluster == "LSFOld": - self.submit_lsf_cluster_job() - else: - job_obj = CompareJob(self.output_path, self.experiment_name, None, self.algorithms, None, - self.class_label, self.instance_label, self.sig_cutoff, self.show_plots) - if run_parallel in ["multiprocessing", "True", True]: - # p = multiprocessing.Process(target=runner_fn, args=(job_obj, )) - # p.start() - # p.join() - Parallel()(delayed(runner_fn)(job_obj) for job_obj in [job_obj, ]) - elif self.run_cluster and "Old" not in self.run_cluster: - get_cluster(self.run_cluster, - self.output_path + '/' + self.experiment_name, self.queue, self.reserved_memory) - dask.compute([dask.delayed(runner_fn)(job_obj) for job_obj in [job_obj, ]]) - else: - job_obj.run() - - def get_cluster_params(self): - cluster_params = [self.output_path, self.experiment_name, None, False, None, - self.class_label, self.instance_label, self.sig_cutoff, self.show_plots] - cluster_params = [str(i) for i in cluster_params] - return cluster_params - - def submit_slurm_cluster_job(self): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/P1_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#SBATCH -p ' + self.queue + '\n') - sh_file.write('#SBATCH --job-name=' + job_ref + '\n') - sh_file.write('#SBATCH --mem=' + str(self.reserved_memory) + 'G' + '\n') - # sh_file.write('#BSUB -M '+str(maximum_memory)+'GB'+'\n') - sh_file.write( - '#SBATCH -o ' + self.output_path + '/' + self.experiment_name + - '/logs/P7_' + job_ref + '.o\n') - sh_file.write( - '#SBATCH -e ' + self.output_path + '/' + self.experiment_name + - '/logs/P7_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/CompareJobSubmit.py' - cluster_params = self.get_cluster_params() - command = ' '.join(['srun', 'python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('sbatch ' + job_name) - - def submit_lsf_cluster_job(self): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/P7_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#BSUB -q ' + self.queue + '\n') - sh_file.write('#BSUB -J ' + job_ref + '\n') - sh_file.write('#BSUB -R "rusage[mem=' + str(self.reserved_memory) + 'G]"' + '\n') - sh_file.write('#BSUB -M ' + str(self.reserved_memory) + 'GB' + '\n') - sh_file.write( - '#BSUB -o ' + self.output_path + '/' + self.experiment_name + - '/logs/P7_' + job_ref + '.o\n') - sh_file.write( - '#BSUB -e ' + self.output_path + '/' + self.experiment_name + - '/logs/P7_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/CompareJobSubmit.py' - cluster_params = self.get_cluster_params() - command = ' '.join(['python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('bsub < ' + job_name) diff --git a/streamline/runners/dataprocess_runner.py b/streamline/runners/dataprocess_runner.py deleted file mode 100644 index da8ee70c..00000000 --- a/streamline/runners/dataprocess_runner.py +++ /dev/null @@ -1,309 +0,0 @@ -import logging -import os -import pickle -import re -import glob -import time -import dask -from pathlib import Path -from streamline.utils.dataset import Dataset -from streamline.dataprep.data_process import DataProcess -from streamline.utils.runners import parallel_eda_call, num_cores -from joblib import Parallel, delayed -from streamline.utils.cluster import get_cluster - - -class DataProcessRunner: - """ - Description: Phase 1 of STREAMLINE - This 'Main' script manages Phase 1 run parameters, \ - updates the metadata file (with user specified run parameters across pipeline run) \ - and submits job to run locally (to run serially) or on a linux computing \ - cluster (parallelized). This script runs ExploratoryAnalysisJob.py which conducts initial \ - exploratory analysis of data and cross validation (CV) partitioning. Note \ - that this entire pipeline may also be run within Jupyter Notebook (see STREAMLINE-Notebook.ipynb). \ - All 'Main' scripts in this pipeline have the potential to be extended by \ - users to submit jobs to other parallel computing frameworks (e.g. cloud computing). \ - - Warnings: - - Before running, be sure to check that all run parameters have relevant/desired values including those with\ - default values available. - - 'Target' datasets for analysis should be in comma-separated format (.txt or .csv) - - Missing data values should be empty or indicated with an 'NA'. - - Dataset(s) includes a header giving column labels. - - Data columns include features, class label, and optionally instance (i.e. row) labels, or match labels\ - (if matched cross validation will be used) - - Binary class values are encoded as 0 (e.g. negative), and 1 (positive) with respect to true positive, \ - true negative, false positive, false negative metrics. PRC plots focus on classification of 'positives'. - - All feature values (both categorical and quantitative) are numerically encoded. Scikit-learn does not accept \ - text-based values. However, both instance_label and match_label values may be either numeric or text. - - One or more target datasets for analysis should be included in the same data_path folder. The path to this \ - folder is a critical pipeline run parameter. No spaces are allowed in filenames (this will lead to - 'invalid literal' by export_exploratory_analysis.) \ - If multiple datasets are being analyzed they must have the \ - same class_label, and (if present) the same instance_label and match_label. - - """ - - def __init__(self, data_path, output_path, experiment_name, exclude_eda_output=None, - class_label="Class", instance_label=None, match_label=None, n_splits=10, partition_method="Stratified", - ignore_features=None, categorical_features=None, quantitative_features=None, top_features=20, - categorical_cutoff=10, sig_cutoff=0.05, featureeng_missingness=0.5, cleaning_missingness=0.5, - correlation_removal_threshold=1.0, - random_state=None, run_cluster=False, queue='defq', reserved_memory=4, show_plots=False): - """ - Initializer for a runner class for Exploratory Data Analysis Jobs - - Args: - data_path: path to directory containing datasets - output_path: path to output directory - experiment_name: name of experiment output folder (no spaces) - exclude_eda_output: list of eda outputs to exclude - possible options ['describe_csv', 'univariate_plots', 'correlation_plots'] - class_label: outcome label of all datasets - instance_label: instance label of all datasets (if present) - match_label: only applies when M selected for partition-method; indicates column with \ - matched instance ids - n_splits: no of splits in cross-validation (default=10) - partition_method: method of partitioning in cross-validation must be in ["Random", "Stratified", "Group"]\ - (default="Stratified") - ignore_features: list of string of column names of features to ignore or \ - path to .csv file with feature labels to be ignored in analysis (default=None) - categorical_features: list of string of column names of features to ignore or \ - path to .csv file with feature labels specified to be treated as categorical where possible\ - (default=None) - categorical_cutoff: number of unique values for a variable is considered to be quantitative vs categorical\ - (default=10) - sig_cutoff: significance cutoff used throughout pipeline (default=0.05) - featureeng_missingness: the proportion of missing values within a feature (above which) a new - binary categorical feature is generated that indicates if the - value for an instance was missing or not - cleaning_missingness: the proportion of missing values, within a feature or instance, (at which) the - given feature or instance will be automatically cleaned (i.e. removed) - from the processed ‘target dataset’ - correlation_removal_threshold: the (pearson) feature correlation at which one out of a pair of - features is randomly removed from the processed ‘target dataset’ - random_state: sets a specific random seed for reproducible results (default=None) - run_cluster: name of cluster run setting or False (default=False) - queue: name of queue to be used in cluster run (default="defq") - reserved_memory: reserved memory for cluster run in GB (in default=4) - show_plots: flag to output plots for notebooks (default=False) - """ - - self.data_path = data_path - self.output_path = output_path - self.experiment_name = experiment_name - self.class_label = class_label - self.instance_label = instance_label - self.match_label = match_label - self.ignore_features = ignore_features - self.categorical_cutoff = categorical_cutoff - self.categorical_features = categorical_features - self.quantitative_features = quantitative_features - self.featureeng_missingness = featureeng_missingness - self.cleaning_missingness = cleaning_missingness - self.correlation_removal_threshold = correlation_removal_threshold - self.top_features = top_features - self.exclude_eda_output = exclude_eda_output - - known_exclude_options = ['describe_csv', 'univariate_plots', 'correlation_plots'] - - exploration_list = ["Describe", "Univariate Analysis", "Feature Correlation"] - plot_list = ["Describe", "Univariate Analysis", "Feature Correlation"] - - if exclude_eda_output is not None: - for x in exclude_eda_output: - if x not in known_exclude_options: - logging.warning("Unknown EDA exclusion option " + str(x)) - if 'describe_csv' in exclude_eda_output: - exploration_list.remove("Describe") - plot_list.remove("Describe") - if 'univariate_plots' in exclude_eda_output: - plot_list.remove("Univariate Analysis") - if 'correlation_plots' in exclude_eda_output: - plot_list.remove("Feature Correlation") - - self.exploration_list = exploration_list - self.plot_list = plot_list - - self.n_splits = n_splits - self.partition_method = partition_method - self.run_cluster = run_cluster - self.queue = queue - self.reserved_memory = reserved_memory - self.show_plots = show_plots - self.random_state = random_state - self.sig_cutoff = sig_cutoff - try: - self.make_dir_tree() - except Exception as e: - # shutil.rmtree(self.output_path) - raise e - self.save_metadata() - - def run(self, run_parallel=False): - file_count, job_counter = 0, 0 - unique_datanames = [] - job_obj_list = [] - for dataset_path in glob.glob(self.data_path + '/*'): - dataset_path = str(Path(dataset_path).as_posix()) - # Save unique dataset names so that analysis is run only once if there - # is both a .txt and .csv version of dataset with same name. - file_extension = dataset_path.split('/')[-1].split('.')[-1] - data_name = dataset_path.split('/')[-1].split('.')[0] - - if file_extension == 'txt' or file_extension == 'csv' or file_extension == 'tsv': - if data_name not in unique_datanames: - unique_datanames.append(data_name) - file_count += 1 - - if not os.path.exists(self.output_path + '/' + self.experiment_name + '/' + data_name): - os.makedirs(self.output_path + '/' + self.experiment_name + '/' + data_name) - - if self.run_cluster == "SLURMOld": - self.submit_slurm_cluster_job(dataset_path) - continue - - if self.run_cluster == "LSFOld": - self.submit_lsf_cluster_job(dataset_path) - continue - dataset = Dataset(dataset_path, self.class_label, self.match_label, self.instance_label) - # Ryan - dataset loading has to take place on individual compute nodes - # (bare minimum can be running on head node for cluster parallelization) - job_obj = DataProcess(dataset, self.output_path + '/' + self.experiment_name, - self.ignore_features, - self.categorical_features, self.quantitative_features, - self.exclude_eda_output, - self.categorical_cutoff, self.sig_cutoff, self.featureeng_missingness, - self.cleaning_missingness, self.correlation_removal_threshold, - self.partition_method, self.n_splits, - self.random_state, self.show_plots) - job_obj_list.append(job_obj) - # Cluster vs Non Cluster irrelevant as now local jobs are parallel too - if not run_parallel: # Run as job in parallel - job_obj_list[-1].run(self.top_features) - job_counter += 1 - - if file_count == 0: # Check that there was at least 1 dataset - raise Exception("There must be at least one .txt, .tsv, or .csv dataset in data_path directory") - - if run_parallel and run_parallel != "False" and not self.run_cluster: - Parallel(n_jobs=num_cores)( - delayed( - parallel_eda_call - )(job_obj, {'top_features': self.top_features}) for job_obj in job_obj_list) - - if self.run_cluster and "Old" not in self.run_cluster: - get_cluster(self.run_cluster, - self.output_path + '/' + self.experiment_name, self.queue, self.reserved_memory) - dask.compute([dask.delayed( - parallel_eda_call - )(job_obj, {'top_features': self.top_features}) for job_obj in job_obj_list]) - - def make_dir_tree(self): - """ - Checks existence of data folder path. - Checks that experiment output folder does not already exist as well as validity of experiment_name parameter. - Then generates initial output folder hierarchy. - """ - # Check to make sure data_path exists and experiment name is valid & unique - if not os.path.exists(self.data_path): - raise Exception("Provided data_path does not exist") - if os.path.exists(self.output_path + '/' + self.experiment_name): - raise Exception( - "Error: A folder with the specified experiment name already exists at " - "" + self.output_path + '/' + self.experiment_name + '. This path/folder name must be unique.') - if not re.match(r'^[A-Za-z0-9_]+$', self.experiment_name): - raise Exception('Experiment Name must be alphanumeric') - - # Create output folder if it doesn't already exist - if not os.path.exists(self.output_path): - os.mkdir(self.output_path) - # Create Experiment folder, with log and job folders - os.mkdir(self.output_path + '/' + self.experiment_name) - os.mkdir(self.output_path + '/' + self.experiment_name + '/jobsCompleted') - os.mkdir(self.output_path + '/' + self.experiment_name + '/jobs') - os.mkdir(self.output_path + '/' + self.experiment_name + '/logs') - - def save_metadata(self): - metadata = dict() - metadata['Data Path'] = self.data_path - metadata['Output Path'] = self.output_path - metadata['Experiment Name'] = self.experiment_name - metadata['Class Label'] = self.class_label - metadata['Instance Label'] = self.instance_label - metadata['Match Label'] = self.match_label - metadata['Ignored Features'] = self.ignore_features - metadata['Specified Categorical Features'] = self.categorical_features - metadata['Specified Quantitative Features'] = self.quantitative_features - metadata['CV Partitions'] = self.n_splits - metadata['Partition Method'] = self.partition_method - metadata['Categorical Cutoff'] = self.categorical_cutoff - metadata['Statistical Significance Cutoff'] = self.sig_cutoff - metadata['Engineering Missingness Cutoff'] = self.featureeng_missingness - metadata['Cleaning Missingness Cutoff'] = self.cleaning_missingness - metadata['Correlation Removal Threshold'] = self.correlation_removal_threshold - metadata['List of Exploratory Analysis Ran'] = self.exploration_list - metadata['List of Exploratory Plots Saved'] = self.plot_list - metadata['Random Seed'] = self.random_state - metadata['Run From Notebook'] = self.show_plots - # Pickle the metadata for future use - pickle_out = open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'wb') - pickle.dump(metadata, pickle_out) - pickle_out.close() - - def get_cluster_params(self, dataset_path): - exclude_param = ','.join(self.exclude_eda_output) if self.exclude_eda_output else None - cluster_params = [dataset_path, self.output_path, self.experiment_name, exclude_param, - self.class_label, self.instance_label, self.match_label, self.n_splits, - self.partition_method, self.ignore_features, self.categorical_features, - self.quantitative_features, self.top_features, - self.categorical_cutoff, self.sig_cutoff, self.featureeng_missingness, - self.cleaning_missingness, self.correlation_removal_threshold, self.random_state] - cluster_params = [str(i) if type(i) != list else '"' + str(i) + '"' for i in cluster_params] - return cluster_params - - def submit_slurm_cluster_job(self, dataset_path): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/P1_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#SBATCH -p ' + self.queue + '\n') - sh_file.write('#SBATCH --job-name=' + job_ref + '\n') - sh_file.write('#SBATCH --mem=' + str(self.reserved_memory) + 'G' + '\n') - # sh_file.write('#BSUB -M '+str(maximum_memory)+'GB'+'\n') - sh_file.write( - '#SBATCH -o ' + self.output_path + '/' + self.experiment_name + - '/logs/P1_' + job_ref + '.o\n') - sh_file.write( - '#SBATCH -e ' + self.output_path + '/' + self.experiment_name + - '/logs/P1_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/EDAJobSubmit.py' - cluster_params = self.get_cluster_params(dataset_path) - command = ' '.join(['srun', 'python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('sbatch ' + job_name) - - def submit_lsf_cluster_job(self, dataset_path): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/P1_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#BSUB -q ' + self.queue + '\n') - sh_file.write('#BSUB -J ' + job_ref + '\n') - sh_file.write('#BSUB -R "rusage[mem=' + str(self.reserved_memory) + 'G]"' + '\n') - sh_file.write('#BSUB -M ' + str(self.reserved_memory) + 'GB' + '\n') - sh_file.write( - '#BSUB -o ' + self.output_path + '/' + self.experiment_name + - '/logs/P1_' + job_ref + '.o\n') - sh_file.write( - '#BSUB -e ' + self.output_path + '/' + self.experiment_name + - '/logs/P1_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/EDAJobSubmit.py' - cluster_params = self.get_cluster_params(dataset_path) - command = ' '.join(['python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('bsub < ' + job_name) diff --git a/streamline/runners/feature_runner.py b/streamline/runners/feature_runner.py deleted file mode 100644 index c8355cd7..00000000 --- a/streamline/runners/feature_runner.py +++ /dev/null @@ -1,398 +0,0 @@ -import os -import glob -import pickle -import time -import dask -from pathlib import Path -from joblib import Parallel, delayed -from streamline.featurefns.selection import FeatureSelection -from streamline.featurefns.importance import FeatureImportance -from streamline.utils.runners import runner_fn, num_cores -from streamline.utils.cluster import get_cluster - - -class FeatureImportanceRunner: - """ - Runner Class for running feature importance jobs for - cross-validation splits. - """ - - def __init__(self, output_path, experiment_name, class_label="Class", instance_label=None, - instance_subset=None, algorithms=("MI", "MS"), use_turf=True, turf_pct=True, - random_state=None, n_jobs=None, - run_cluster=False, queue='defq', reserved_memory=4): - """ - - Args: - output_path: - experiment_name: - class_label: - instance_label: - instance_subset: - algorithms: - use_turf: - turf_pct: - random_state: - n_jobs: - - Returns: None - - """ - self.cv_count = None - self.dataset = None - self.output_path = output_path - self.experiment_name = experiment_name - self.class_label = class_label - self.instance_label = instance_label - self.instance_subset = instance_subset - self.algorithms = list(algorithms) - # assert (algorithms in ["MI", "MS"]) - self.use_turf = use_turf - self.turf_pct = turf_pct - self.random_state = random_state - self.n_jobs = n_jobs - self.run_cluster = run_cluster - self.queue = queue - self.reserved_memory = reserved_memory - - if self.turf_pct == 'False' or self.turf_pct == False: - self.turf_pct == False - else: - self.turf_pct == True - - if self.n_jobs is None: - self.n_jobs = 1 - - # Argument checks - if not os.path.exists(self.output_path): - raise Exception("Output path must exist (from phase 1) before phase 3 can begin") - if not os.path.exists(self.output_path + '/' + self.experiment_name): - raise Exception("Experiment must exist (from phase 1) before phase 3 can begin") - - self.save_metadata() - - def run(self, run_parallel=False): - - # Iterate through datasets, ignoring common folders - dataset_paths = os.listdir(self.output_path + "/" + self.experiment_name) - remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle', 'jobsCompleted', 'dask_logs', - 'logs', 'jobs', 'DatasetComparisons'] - - for text in remove_list: - if text in dataset_paths: - dataset_paths.remove(text) - - job_list = list() - - for dataset_directory_path in dataset_paths: - full_path = self.output_path + "/" + self.experiment_name + "/" + dataset_directory_path - experiment_path = self.output_path + '/' + self.experiment_name - - if self.algorithms is not None or self.algorithms != []: - if not os.path.exists(full_path + "/feature_selection"): - os.mkdir(full_path + "/feature_selection") - - if "MI" in self.algorithms: - if not os.path.exists(full_path + "/feature_selection/mutual_information"): - os.mkdir(full_path + "/feature_selection/mutual_information") - if not os.path.exists(full_path + "/feature_selection/mutual_information/pickledForPhase4"): - os.mkdir(full_path + "/feature_selection/mutual_information/pickledForPhase4") - for cv_train_path in glob.glob(full_path + "/CVDatasets/*_CV_*Train.csv"): - cv_train_path = str(Path(cv_train_path).as_posix()) - - if self.run_cluster == "SLURMOld": - self.submit_slurm_cluster_job(cv_train_path, experiment_path, "MI") - continue - - if self.run_cluster == "LSFOld": - self.submit_lsf_cluster_job(cv_train_path, experiment_path, "MI") - continue - - job_obj = FeatureImportance(cv_train_path, experiment_path, self.class_label, - self.instance_label, self.instance_subset, "MI", - self.use_turf, self.turf_pct, self.random_state, self.n_jobs) - if run_parallel: - # p = multiprocessing.Process(target=runner_fn, args=(job_obj,)) - job_list.append(job_obj) - else: - job_obj.run() - - if "MS" in self.algorithms: - if not os.path.exists(full_path + "/feature_selection/multisurf"): - os.mkdir(full_path + "/feature_selection/multisurf") - if not os.path.exists(full_path + "/feature_selection/multisurf/pickledForPhase4"): - os.mkdir(full_path + "/feature_selection/multisurf/pickledForPhase4") - for cv_train_path in glob.glob(full_path + "/CVDatasets/*_CV_*Train.csv"): - cv_train_path = str(Path(cv_train_path).as_posix()) - - if self.run_cluster == "SLURMOld": - self.submit_slurm_cluster_job(cv_train_path, experiment_path, "MS") - continue - - if self.run_cluster == "LSFOld": - self.submit_lsf_cluster_job(cv_train_path, experiment_path, "MS") - continue - - job_obj = FeatureImportance(cv_train_path, experiment_path, self.class_label, - self.instance_label, self.instance_subset, "MS", - self.use_turf, self.turf_pct, self.random_state, self.n_jobs) - if run_parallel: - # p = multiprocessing.Process(target=runner_fn, args=(job_obj,)) - job_list.append(job_obj) - else: - job_obj.run() - if run_parallel and run_parallel != "False" and not self.run_cluster: - Parallel(n_jobs=num_cores)(delayed(runner_fn)(job_obj) for job_obj in job_list) - if self.run_cluster and "Old" not in self.run_cluster: - get_cluster(self.run_cluster, - self.output_path + '/' + self.experiment_name, self.queue, self.reserved_memory) - dask.compute([dask.delayed(runner_fn)(job_obj) for job_obj in job_list]) - - def save_metadata(self): - file = open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'rb') - metadata = pickle.load(file) - file.close() - metadata['Use Mutual Information'] = "MI" in self.algorithms - metadata['Use MultiSURF'] = "MS" in self.algorithms - metadata['Use TURF'] = self.use_turf - metadata['TURF Cutoff'] = self.turf_pct - metadata['MultiSURF Instance Subset'] = self.instance_subset - pickle_out = open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'wb') - pickle.dump(metadata, pickle_out) - pickle_out.close() - - def get_cluster_params(self, cv_train_path, experiment_path, algorithm): - cluster_params = [cv_train_path, experiment_path, self.class_label, - self.instance_label, self.instance_subset, algorithm, - self.use_turf, self.turf_pct, self.random_state, self.n_jobs] - cluster_params = [str(i) for i in cluster_params] - return cluster_params - - def submit_slurm_cluster_job(self, cv_train_path, experiment_path, algorithm): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/P3_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#SBATCH -p ' + self.queue + '\n') - sh_file.write('#SBATCH --job-name=' + job_ref + '\n') - sh_file.write('#SBATCH --mem=' + str(self.reserved_memory) + 'G' + '\n') - # sh_file.write('#BSUB -M '+str(maximum_memory)+'GB'+'\n') - sh_file.write( - '#SBATCH -o ' + self.output_path + '/' + self.experiment_name + - '/logs/P3_' + job_ref + '.o\n') - sh_file.write( - '#SBATCH -e ' + self.output_path + '/' + self.experiment_name + - '/logs/P3_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/FImpJobSubmit.py' - cluster_params = self.get_cluster_params(cv_train_path, experiment_path, algorithm) - command = ' '.join(['srun', 'python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('sbatch ' + job_name) - - def submit_lsf_cluster_job(self, cv_train_path, experiment_path, algorithm): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/P3_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#BSUB -q ' + self.queue + '\n') - sh_file.write('#BSUB -J ' + job_ref + '\n') - sh_file.write('#BSUB -R "rusage[mem=' + str(self.reserved_memory) + 'G]"' + '\n') - sh_file.write('#BSUB -M ' + str(self.reserved_memory) + 'GB' + '\n') - sh_file.write( - '#BSUB -o ' + self.output_path + '/' + self.experiment_name + - '/logs/P3_' + job_ref + '.o\n') - sh_file.write( - '#BSUB -e ' + self.output_path + '/' + self.experiment_name + - '/logs/P3_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/FImpJobSubmit.py' - cluster_params = self.get_cluster_params(cv_train_path, experiment_path, algorithm) - command = ' '.join(['python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('bsub < ' + job_name) - - -class FeatureSelectionRunner: - """ - Runner Class for running feature selection jobs for - cross-validation splits. - """ - - def __init__(self, output_path, experiment_name, algorithms, class_label="Class", instance_label=None, - max_features_to_keep=2000, filter_poor_features=True, top_features=40, export_scores=True, - overwrite_cv=True, random_state=None, n_jobs=None, - run_cluster=False, queue='defq', reserved_memory=4, show_plots=False): - """ - - Args: - output_path: path other the output folder - experiment_name: name for the current experiment - algorithms: feature selection algorithms from last phase - max_features_to_keep: max features to keep (only applies if filter_poor_features is True), default=2000 - filter_poor_features: filter out the worst performing features prior to modeling,default='True' - top_features: number of top features to illustrate in figures, default=40) - export_scores: export figure summarizing average fi scores over cv partitions, default='True' - overwrite_cv: overwrites working cv datasets with new feature subset datasets,default="True" - random_state: random seed for reproducibility - n_jobs: n_jobs param for multiprocessing - - Returns: None - - """ - self.cv_count = None - self.dataset = None - self.output_path = output_path - self.experiment_name = experiment_name - self.class_label = class_label - self.instance_label = instance_label - - self.max_features_to_keep = max_features_to_keep - self.filter_poor_features = filter_poor_features - self.top_features = top_features - self.export_scores = export_scores - self.overwrite_cv = overwrite_cv - - self.algorithms = algorithms - self.random_state = random_state - self.n_jobs = n_jobs - - self.run_cluster = run_cluster - self.queue = queue - self.reserved_memory = reserved_memory - self.show_plots = show_plots - - if self.filter_poor_features == 'False' or self.filter_poor_features is False: - self.filter_poor_features = False - else: - self.filter_poor_features = True - if self.export_scores == 'False' or self.export_scores is False: - self.export_scores = False - else: - self.export_scores = True - if self.overwrite_cv == 'False' or self.overwrite_cv is False: - self.overwrite_cv = False - else: - self.overwrite_cv = True - - # Argument checks - if not os.path.exists(self.output_path): - raise Exception("Output path must exist (from phase 1) before phase 4 can begin") - if not os.path.exists(self.output_path + '/' + self.experiment_name): - raise Exception("Experiment must exist (from phase 1) before phase 4 can begin") - - self.save_metadata() - - def run(self, run_parallel=False): - - # Iterate through datasets, ignoring common folders - dataset_paths = os.listdir(self.output_path + "/" + self.experiment_name) - remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle', 'jobsCompleted', 'dask_logs', - 'logs', 'jobs', 'DatasetComparisons'] - - for text in remove_list: - if text in dataset_paths: - dataset_paths.remove(text) - - job_list = list() - - for dataset_directory_path in dataset_paths: - full_path = self.output_path + "/" + self.experiment_name + "/" + dataset_directory_path - experiment_path = self.output_path + '/' + self.experiment_name - - cv_dataset_paths = list(glob.glob(full_path + "/CVDatasets/*_CV_*Train.csv")) - cv_dataset_paths = [str(Path(cv_dataset_path)) for cv_dataset_path in cv_dataset_paths] - - if self.run_cluster == "SLURMOld": - self.submit_slurm_cluster_job(full_path, len(cv_dataset_paths)) - continue - - if self.run_cluster == "LSFOld": - self.submit_lsf_cluster_job(full_path, len(cv_dataset_paths)) - continue - - job_obj = FeatureSelection(full_path, len(cv_dataset_paths), self.algorithms, - self.class_label, self.instance_label, self.export_scores, - self.top_features, self.max_features_to_keep, - self.filter_poor_features, self.overwrite_cv, self.show_plots) - if run_parallel and run_parallel != "False": - # p = multiprocessing.Process(target=runner_fn, args=(job_obj,)) - job_list.append(job_obj) - else: - job_obj.run() - if run_parallel and run_parallel != "False" and not self.run_cluster: - Parallel(n_jobs=num_cores)(delayed(runner_fn)(job_obj) for job_obj in job_list) - if self.run_cluster and "Old" not in self.run_cluster: - get_cluster(self.run_cluster, - self.output_path + '/' + self.experiment_name, self.queue, self.reserved_memory) - dask.compute([dask.delayed(runner_fn)(job_obj) for job_obj in job_list]) - - def save_metadata(self): - file = open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'rb') - metadata = pickle.load(file) - file.close() - metadata['Max Features to Keep'] = self.max_features_to_keep - metadata['Filter Poor Features'] = self.filter_poor_features - metadata['Top Features to Display'] = self.top_features - metadata['Export Feature Importance Plot'] = self.export_scores - metadata['Overwrite CV Datasets'] = self.overwrite_cv - pickle_out = open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'wb') - pickle.dump(metadata, pickle_out) - pickle_out.close() - - def get_cluster_params(self, full_path, n_datasets): - algorithms = "'['" + "','".join(self.algorithms) + "']'" - cluster_params = [full_path, n_datasets, algorithms, - self.class_label, self.instance_label, self.export_scores, - self.top_features, self.max_features_to_keep, - self.filter_poor_features, self.overwrite_cv] - cluster_params = [str(i) for i in cluster_params] - return cluster_params - - def submit_slurm_cluster_job(self, full_path, n_datasets): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/P4_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#SBATCH -p ' + self.queue + '\n') - sh_file.write('#SBATCH --job-name=' + job_ref + '\n') - sh_file.write('#SBATCH --mem=' + str(self.reserved_memory) + 'G' + '\n') - # sh_file.write('#BSUB -M '+str(maximum_memory)+'GB'+'\n') - sh_file.write( - '#SBATCH -o ' + self.output_path + '/' + self.experiment_name + - '/logs/P4_' + job_ref + '.o\n') - sh_file.write( - '#SBATCH -e ' + self.output_path + '/' + self.experiment_name + - '/logs/P4_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/FSelJobSubmit.py' - cluster_params = self.get_cluster_params(full_path, n_datasets) - command = ' '.join(['srun', 'python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('sbatch ' + job_name) - - def submit_lsf_cluster_job(self, full_path, n_datasets): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/P4_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#BSUB -q ' + self.queue + '\n') - sh_file.write('#BSUB -J ' + job_ref + '\n') - sh_file.write('#BSUB -R "rusage[mem=' + str(self.reserved_memory) + 'G]"' + '\n') - sh_file.write('#BSUB -M ' + str(self.reserved_memory) + 'GB' + '\n') - sh_file.write( - '#BSUB -o ' + self.output_path + '/' + self.experiment_name + - '/logs/P4_' + job_ref + '.o\n') - sh_file.write( - '#BSUB -e ' + self.output_path + '/' + self.experiment_name + - '/logs/P4_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/FSelJobSubmit.py' - cluster_params = self.get_cluster_params(full_path, n_datasets) - command = ' '.join(['python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('bsub < ' + job_name) diff --git a/streamline/runners/imputation_runner.py b/streamline/runners/imputation_runner.py deleted file mode 100644 index a2521148..00000000 --- a/streamline/runners/imputation_runner.py +++ /dev/null @@ -1,167 +0,0 @@ -import os -import glob -import pickle -import time -import dask -from pathlib import Path -from joblib import Parallel, delayed -from streamline.dataprep.scale_and_impute import ScaleAndImpute -from streamline.utils.runners import runner_fn, num_cores -from streamline.utils.cluster import get_cluster - - -class ImputationRunner: - """ - Runner class for Data Processing Jobs of CV Splits - """ - - def __init__(self, output_path, experiment_name, scale_data=True, impute_data=True, - multi_impute=True, overwrite_cv=True, class_label="Class", instance_label=None, random_state=None, - run_cluster=False, queue='defq', reserved_memory=4): - """ - - Args: - output_path: - experiment_name: - scale_data: - impute_data: - multi_impute: - overwrite_cv: - """ - self.output_path = output_path - self.experiment_name = experiment_name - self.scale_data = scale_data - self.impute_data = impute_data - self.multi_impute = multi_impute - self.overwrite_cv = overwrite_cv - self.class_label = class_label - self.instance_label = instance_label - self.random_state = random_state - - self.run_cluster = run_cluster - self.queue = queue - self.reserved_memory = reserved_memory - - # Argument checks------------------------------------------------------------- - if not os.path.exists(self.output_path): - raise Exception("Output path must exist (from phase 1) before phase 2 can begin") - if not os.path.exists(self.output_path + '/' + self.experiment_name): - raise Exception("Experiment must exist (from phase 1) before phase 2 can begin") - - self.save_metadata() - - def run(self, run_parallel=False): - job_counter = 0 - job_list = [] - dataset_paths = os.listdir(self.output_path + "/" + self.experiment_name) - remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle', 'jobsCompleted', 'dask_logs', - 'logs', 'jobs', 'DatasetComparisons'] - for text in remove_list: - if text in dataset_paths: - dataset_paths.remove(text) - - for dataset_directory_path in dataset_paths: - full_path = self.output_path + "/" + self.experiment_name + "/" + dataset_directory_path - - # Create folder to store scaling and imputing files - if not os.path.exists(full_path + '/scale_impute/'): - os.makedirs(full_path + '/scale_impute/') - - for cv_train_path in glob.glob(full_path + "/CVDatasets/*Train.csv"): - cv_train_path = str(Path(cv_train_path).as_posix()) - job_counter += 1 - cv_test_path = cv_train_path.replace("Train.csv", "Test.csv") - - if self.run_cluster == "SLURMOld": - self.submit_slurm_cluster_job(cv_train_path, cv_test_path) - continue - - if self.run_cluster == "LSFOld": - self.submit_lsf_cluster_job(cv_train_path, cv_test_path) - continue - - if run_parallel and run_parallel != "False": - job_obj = ScaleAndImpute(cv_train_path, cv_test_path, - self.output_path + "/" + self.experiment_name, - self.scale_data, self.impute_data, self.multi_impute, self.overwrite_cv, - self.class_label, self.instance_label, self.random_state) - # p = multiprocessing.Process(target=runner_fn, args=(job_obj, )) - job_list.append(job_obj) - else: - job_obj = ScaleAndImpute(cv_train_path, cv_test_path, - self.output_path + "/" + self.experiment_name, - self.scale_data, self.impute_data, self.multi_impute, self.overwrite_cv, - self.class_label, self.instance_label, self.random_state) - job_obj.run() - if run_parallel and run_parallel != "False" and not self.run_cluster: - Parallel(n_jobs=num_cores)(delayed(runner_fn)(job_obj) for job_obj in job_list) - if self.run_cluster and "Old" not in self.run_cluster: - get_cluster(self.run_cluster, - self.output_path + '/' + self.experiment_name, self.queue, self.reserved_memory) - dask.compute([dask.delayed(runner_fn)(job_obj) for job_obj in job_list]) - - def save_metadata(self): - file = open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'rb') - metadata = pickle.load(file) - file.close() - metadata['Use Data Scaling'] = self.scale_data - metadata['Use Data Imputation'] = self.impute_data - metadata['Use Multivariate Imputation'] = self.multi_impute - # Pickle the metadata for future use - pickle_out = open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'wb') - pickle.dump(metadata, pickle_out) - pickle_out.close() - - def get_cluster_params(self, cv_train_path, cv_test_path): - cluster_params = [cv_train_path, cv_test_path, - self.output_path + "/" + self.experiment_name, - self.scale_data, self.impute_data, self.multi_impute, self.overwrite_cv, - self.class_label, self.instance_label, self.random_state] - cluster_params = [str(i) for i in cluster_params] - return cluster_params - - def submit_slurm_cluster_job(self, cv_train_path, cv_test_path): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/P1_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#SBATCH -p ' + self.queue + '\n') - sh_file.write('#SBATCH --job-name=' + job_ref + '\n') - sh_file.write('#SBATCH --mem=' + str(self.reserved_memory) + 'G' + '\n') - # sh_file.write('#BSUB -M '+str(maximum_memory)+'GB'+'\n') - sh_file.write( - '#SBATCH -o ' + self.output_path + '/' + self.experiment_name + - '/logs/P1_' + job_ref + '.o\n') - sh_file.write( - '#SBATCH -e ' + self.output_path + '/' + self.experiment_name + - '/logs/P1_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/DataJobSubmit.py' - cluster_params = self.get_cluster_params(cv_train_path, cv_test_path) - command = ' '.join(['srun', 'python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('sbatch ' + job_name) - - def submit_lsf_cluster_job(self, cv_train_path, cv_test_path): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/P2_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#BSUB -q ' + self.queue + '\n') - sh_file.write('#BSUB -J ' + job_ref + '\n') - sh_file.write('#BSUB -R "rusage[mem=' + str(self.reserved_memory) + 'G]"' + '\n') - sh_file.write('#BSUB -M ' + str(self.reserved_memory) + 'GB' + '\n') - sh_file.write( - '#BSUB -o ' + self.output_path + '/' + self.experiment_name + - '/logs/P2_' + job_ref + '.o\n') - sh_file.write( - '#BSUB -e ' + self.output_path + '/' + self.experiment_name + - '/logs/P2_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/DataJobSubmit.py' - cluster_params = self.get_cluster_params(cv_train_path, cv_test_path) - command = ' '.join(['python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('bsub < ' + job_name) diff --git a/streamline/runners/model_runner.py b/streamline/runners/model_runner.py deleted file mode 100644 index a31b24e3..00000000 --- a/streamline/runners/model_runner.py +++ /dev/null @@ -1,358 +0,0 @@ -import copy -import logging -import os -import glob -import pickle -import time -import dask -from tqdm import tqdm -from pathlib import Path -from joblib import Parallel, delayed -from streamline.modeling.utils import ABBREVIATION, COLORS -from streamline.modeling.modeljob import ModelJob -from streamline.modeling.utils import model_str_to_obj -from streamline.modeling.utils import SUPPORTED_MODELS -from streamline.modeling.utils import is_supported_model -from streamline.utils.runners import model_runner_fn, num_cores -from streamline.utils.cluster import get_cluster -from streamline.modeling.utils import get_fi_for_ExSTraCS - - -class ModelExperimentRunner: - """ - Runner Class for running all the model jobs for - cross-validation splits. - """ - - def __init__(self, output_path, experiment_name, algorithms=None, exclude=("XCS", "eLCS"), class_label="Class", - instance_label=None, scoring_metric='balanced_accuracy', metric_direction='maximize', - training_subsample=0, use_uniform_fi=True, n_trials=200, - timeout=900, save_plots=False, do_lcs_sweep=False, lcs_nu=1, lcs_n=2000, lcs_iterations=200000, - lcs_timeout=1200, resubmit=False, random_state=None, n_jobs=None, - run_cluster=False, - queue='defq', reserved_memory=4): - - """ - Args: - output_path: path to output directory - experiment_name: name of experiment (no spaces) - algorithms: list of str of ML models to run - scoring_metric: primary scikit-learn specified scoring metric used for hyperparameter optimization and \ - permutation-based model feature importance evaluation, default='balanced_accuracy' - metric_direction: direction to optimize the scoring metric in optuna, \ - either 'maximize' or 'minimize', default='maximize' - training_subsample: for long running algos (XGB,SVM,ANN,KNN), option to subsample training set \ - (0 for no subsample, default=0) - use_uniform_fi: overrides use of any available feature importance estimate methods from models, \ - instead using permutation_importance uniformly, default=True - n_trials: number of bayesian hyperparameter optimization trials using optuna \ - (specify an integer or None) default=200 - timeout: seconds until hyperparameter sweep stops running new trials \ - (Note: it may run longer to finish last trial started) \ - If set to None, STREAMLINE is completely replicable, but will take longer to run \ - default=900 i.e. 900 sec = 15 minutes default \ - save_plots: export optuna-generated hyperparameter sweep plots, default False - do_lcs_sweep: do LCS hyper-param tuning or use below params, default=False - lcs_nu: fixed LCS nu param (recommended range 1-10), set to larger value for data with \ - less or no noise, default=1 - lcs_iterations: fixed LCS number of learning iterations param, default=200000 - lcs_n: fixed LCS rule population maximum size param, default=2000 - lcs_timeout: seconds until hyperparameter sweep stops for LCS algorithms, default=1200 - - """ - self.cv_count = None - self.dataset = None - self.output_path = output_path - self.experiment_name = experiment_name - self.class_label = class_label - self.instance_label = instance_label - - if algorithms == "All" or algorithms == ['All']: - algorithms = None - - if algorithms is None: - self.algorithms = list(SUPPORTED_MODELS) - if exclude is not None: - for algorithm in exclude: - try: - algorithm = is_supported_model(algorithm) - self.algorithms.remove(algorithm) - except Exception: - Exception("Unknown algorithm in exclude: " + str(algorithm)) - else: - self.algorithms = list() - for algorithm in algorithms: - self.algorithms.append(is_supported_model(algorithm)) - if exclude is not None: - for algorithm in exclude: - try: - algorithm = is_supported_model(algorithm) - self.algorithms.remove(algorithm) - except Exception: - Exception("Unknown algorithm in exclude: " + str(algorithm)) - - # print(self.algorithms) - - self.scoring_metric = scoring_metric - self.metric_direction = metric_direction - self.training_subsample = training_subsample - self.uniform_fi = use_uniform_fi - self.n_trials = n_trials - self.timeout = timeout - self.save_plots = save_plots - self.do_lcs_sweep = do_lcs_sweep - self.lcs_nu = lcs_nu - self.lcs_n = lcs_n - self.lcs_iterations = lcs_iterations - self.lcs_timeout = lcs_timeout - - self.resubmit = resubmit - self.random_state = random_state - self.n_jobs = n_jobs - - self.run_cluster = run_cluster - self.queue = queue - self.reserved_memory = reserved_memory - - # Argument checks - if not os.path.exists(self.output_path): - raise Exception("Output path must exist (from phase 1) before phase 4 can begin") - if not os.path.exists(self.output_path + '/' + self.experiment_name): - raise Exception("Experiment must exist (from phase 1) before phase 4 can begin") - - self.save_metadata() - self.save_alginfo() - - def run(self, run_parallel=False): - - # Iterate through datasets, ignoring common folders - dataset_paths = os.listdir(self.output_path + "/" + self.experiment_name) - remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle', 'jobsCompleted', 'dask_logs', - 'logs', 'jobs', 'DatasetComparisons'] - - for text in remove_list: - if text in dataset_paths: - dataset_paths.remove(text) - - job_list = list() - - if self.resubmit: - phase5completed = [] - for filename in glob.glob(self.output_path + "/" + self.experiment_name + '/jobsCompleted/job_model*'): - filename = str(Path(filename).as_posix()) - ref = filename.split('/')[-1] - phase5completed.append(ref) - else: - phase5completed = [] - - file = open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'rb') - metadata = pickle.load(file) - filter_poor_features = metadata['Filter Poor Features'] - file.close() - - for dataset_directory_path in dataset_paths: - full_path = self.output_path + "/" + self.experiment_name + "/" + dataset_directory_path - if not os.path.exists(full_path + '/models'): - os.mkdir(full_path + '/models') - if not os.path.exists(full_path + '/model_evaluation'): - os.mkdir(full_path + '/model_evaluation') - if not os.path.exists(full_path + '/models/pickledModels'): - os.mkdir(full_path + '/models/pickledModels') - if not os.path.exists(full_path + '/model_evaluation/pickled_metrics'): - os.mkdir(full_path + '/model_evaluation/pickled_metrics') - - cv_dataset_paths = list(glob.glob(full_path + "/CVDatasets/*_CV_*Train.csv")) - cv_dataset_paths = [str(Path(cv_dataset_path)) for cv_dataset_path in cv_dataset_paths] - cv_partitions = len(cv_dataset_paths) - for cv_count in range(cv_partitions): - for algorithm in self.algorithms: - abbrev = ABBREVIATION[algorithm] - target_file = 'job_model_' + dataset_directory_path + '_' + str(cv_count) + '_' + \ - abbrev + '.txt' - if target_file in phase5completed: - continue - # target for a re-submit - - if self.run_cluster == "SLURMOld": - self.submit_slurm_cluster_job(full_path, abbrev, cv_count) - continue - - if self.run_cluster == "LSFOld": - self.submit_lsf_cluster_job(full_path, abbrev, cv_count) - continue - - # logging.info("Running Model "+str(algorithm)) - if algorithm not in ['eLCS', 'XCS', 'ExSTraCS']: - model = model_str_to_obj(algorithm)(cv_folds=3, - scoring_metric=self.scoring_metric, - metric_direction=self.metric_direction, - random_state=self.random_state, - cv=None, n_jobs=self.n_jobs) - else: - if algorithm == 'ExSTraCS': - expert_knowledge = get_fi_for_ExSTraCS(self.output_path, self.experiment_name, - dataset_directory_path, - self.class_label, self.instance_label, cv_count, - filter_poor_features) - if self.do_lcs_sweep: - model = model_str_to_obj(algorithm)(cv_folds=3, - scoring_metric=self.scoring_metric, - metric_direction=self.metric_direction, - random_state=self.random_state, - cv=None, n_jobs=self.n_jobs, - expert_knowledge=copy.deepcopy(expert_knowledge)) - else: - model = model_str_to_obj(algorithm)(cv_folds=3, - scoring_metric=self.scoring_metric, - metric_direction=self.metric_direction, - random_state=self.random_state, - cv=None, n_jobs=self.n_jobs, - iterations=self.lcs_iterations, - N=self.lcs_n, nu=self.lcs_nu, - expert_knowledge=copy.deepcopy(expert_knowledge)) - else: - if self.do_lcs_sweep: - model = model_str_to_obj(algorithm)(cv_folds=3, - scoring_metric=self.scoring_metric, - metric_direction=self.metric_direction, - random_state=self.random_state, - cv=None, n_jobs=self.n_jobs) - else: - model = model_str_to_obj(algorithm)(cv_folds=3, - scoring_metric=self.scoring_metric, - metric_direction=self.metric_direction, - random_state=self.random_state, - cv=None, n_jobs=self.n_jobs, - iterations=self.lcs_iterations, - N=self.lcs_n, nu=self.lcs_nu) - - job_obj = ModelJob(full_path, self.output_path, self.experiment_name, cv_count, self.class_label, - self.instance_label, self.scoring_metric, self.metric_direction, self.n_trials, - self.timeout, self.training_subsample, self.uniform_fi, - self.save_plots, self.random_state) - if run_parallel and run_parallel != "False": - # p = multiprocessing.Process(target=model_runner_fn, args=(job_obj, model)) - # job_list.append(p) - job_list.append((job_obj, copy.deepcopy(model))) - else: - job_obj.run(model) - if run_parallel and run_parallel != "False" and not self.run_cluster: - # run_jobs(job_list) - Parallel(n_jobs=num_cores)( - delayed(model_runner_fn)(job_obj, model - ) for job_obj, model in tqdm(job_list)) - if self.run_cluster and "Old" not in self.run_cluster: - get_cluster(self.run_cluster, - self.output_path + '/' + self.experiment_name, self.queue, self.reserved_memory) - dask.compute([dask.delayed(model_runner_fn)(job_obj, model - ) for job_obj, model in job_list]) - - def save_metadata(self): - # Load metadata - file = open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'rb') - metadata = pickle.load(file) - file.close() - # Update metadata - # Comment our this metadata, so it doesn't show up in the report. - # metadata['Naive Bayes'] = str('Naive Bayes' in self.algorithms) - # metadata['Logistic Regression'] = str('Logistic Regression' in self.algorithms) - # metadata['Decision Tree'] = str('Decision Tree' in self.algorithms) - # metadata['Random Forest'] = str('Random Forest' in self.algorithms) - # metadata['Gradient Boosting'] = str('Gradient Boosting' in self.algorithms) - # metadata['Extreme Gradient Boosting'] = str('Extreme Gradient Boosting' in self.algorithms) - # metadata['Light Gradient Boosting'] = str('Light Gradient Boosting' in self.algorithms) - # metadata['Category Gradient Boosting'] = str('Category Gradient Boosting' in self.algorithms) - # metadata['Support Vector Machine'] = str('Support Vector Machine' in self.algorithms) - # metadata['Artificial Neural Network'] = str('Artificial Neural Network' in self.algorithms) - # metadata['K-Nearest Neighbors'] = str('K-Nearest Neighbors' in self.algorithms) - # metadata['Genetic Programming'] = str('Genetic Programming' in self.algorithms) - # metadata['eLCS'] = str('eLCS' in self.algorithms) - # metadata['XCS'] = str('XCS' in self.algorithms) - # metadata['ExSTraCS'] = str('ExSTraCS' in self.algorithms) - # Add new algorithms here... - metadata['Primary Metric'] = self.scoring_metric - metadata['Training Subsample for KNN,ANN,SVM,and XGB'] = self.training_subsample - metadata['Uniform Feature Importance Estimation (Models)'] = self.uniform_fi - metadata['Hyperparameter Sweep Number of Trials'] = self.n_trials - metadata['Hyperparameter Timeout'] = self.timeout - metadata['Export Hyperparameter Sweep Plots'] = self.save_plots - metadata['Do LCS Hyperparameter Sweep'] = self.do_lcs_sweep - metadata['nu'] = self.lcs_nu - metadata['Training Iterations'] = self.lcs_iterations - metadata['N (Rule Population Size)'] = self.lcs_n - metadata['LCS Hyperparameter Sweep Timeout'] = self.lcs_timeout - # Pickle the metadata for future use - pickle_out = open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'wb') - pickle.dump(metadata, pickle_out) - pickle_out.close() - - def save_alginfo(self): - alg_info = dict() - for algorithm in SUPPORTED_MODELS: - if algorithm in self.algorithms: - alg_info[algorithm] = [True, ABBREVIATION[algorithm], COLORS[algorithm]] - else: - alg_info[algorithm] = [False, ABBREVIATION[algorithm], COLORS[algorithm]] - - # Pickle the algorithm information dictionary for future use - pickle_out = open(self.output_path + '/' + self.experiment_name + '/' + "algInfo.pickle", 'wb') - pickle.dump(alg_info, pickle_out) - pickle_out.close() - - def get_cluster_params(self, full_path, algorithm, cv_count): - cluster_params = [full_path, self.output_path, self.experiment_name, cv_count, self.class_label, - self.instance_label, self.scoring_metric, self.metric_direction, - self.n_trials, self.timeout, self.training_subsample, - self.uniform_fi, self.save_plots, self.random_state] - cluster_params += [algorithm, self.n_jobs, self.do_lcs_sweep, - self.lcs_iterations, self.lcs_n, self.lcs_nu] - cluster_params = [str(i) for i in cluster_params] - return cluster_params - - def submit_slurm_cluster_job(self, full_path, algorithm, cv_count): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/P5_' + str(algorithm) \ - + '_' + str(cv_count) + '_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#SBATCH -p ' + self.queue + '\n') - sh_file.write('#SBATCH --job-name=' + job_ref + '\n') - sh_file.write('#SBATCH --mem=' + str(self.reserved_memory) + 'G' + '\n') - # sh_file.write('#BSUB -M '+str(maximum_memory)+'GB'+'\n') - sh_file.write( - '#SBATCH -o ' + self.output_path + '/' + self.experiment_name + '/logs/P5_' - + str(algorithm) + '_' + str(cv_count) + '_' + job_ref + '.o\n') - sh_file.write( - '#SBATCH -e ' + self.output_path + '/' + self.experiment_name + '/logs/P5_' - + str(algorithm) + '_' + str(cv_count) + '_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/ModelJobSubmit.py' - cluster_params = self.get_cluster_params(full_path, algorithm, cv_count) - command = ' '.join(['srun', 'python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('sbatch ' + job_name) - - def submit_lsf_cluster_job(self, full_path, algorithm, cv_count): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name \ - + '/jobs/P5_' + str(algorithm) + '_' + str(cv_count) + '_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#BSUB -q ' + self.queue + '\n') - sh_file.write('#BSUB -J ' + job_ref + '\n') - sh_file.write('#BSUB -R "rusage[mem=' + str(self.reserved_memory) + 'G]"' + '\n') - sh_file.write('#BSUB -M ' + str(self.reserved_memory) + 'GB' + '\n') - sh_file.write( - '#BSUB -o ' + self.output_path + '/' + self.experiment_name - + '/logs/P5_' + str(algorithm) + '_' + str(cv_count) + '_' + job_ref + '.o\n') - sh_file.write( - '#BSUB -e ' + self.output_path + '/' + self.experiment_name - + '/logs/P5_' + str(algorithm) + '_' + str(cv_count) + '_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/ModelJobSubmit.py' - cluster_params = self.get_cluster_params(full_path, algorithm, cv_count) - command = ' '.join(['python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('bsub < ' + job_name) diff --git a/streamline/runners/replicate_runner.py b/streamline/runners/replicate_runner.py deleted file mode 100644 index b252c611..00000000 --- a/streamline/runners/replicate_runner.py +++ /dev/null @@ -1,274 +0,0 @@ -import logging -import os -import glob -import pickle -import time -import dask -from pathlib import Path -from joblib import Parallel, delayed -from streamline.modeling.utils import SUPPORTED_MODELS, is_supported_model -from streamline.postanalysis.model_replicate import ReplicateJob -from streamline.utils.runners import num_cores, runner_fn -from streamline.utils.cluster import get_cluster - - -class ReplicationRunner: - """ - Phase 9 of STREAMLINE (Optional)- This 'Main' script manages Phase 9 run parameters, - and submits job to run locally (to run serially) or on - cluster (parallelized). - """ - - def __init__(self, rep_data_path, dataset_for_rep, output_path, experiment_name, - class_label=None, instance_label=None, match_label=None, algorithms=None, load_algo=True, - exclude=("XCS", "eLCS"), exclude_plots=None, - run_cluster=False, queue='defq', reserved_memory=4, show_plots=False): - """ - - Args: - rep_data_path: path to directory containing replication or \ - hold-out testing datasets (must have at least all \ - features with same labels as in original training dataset) - dataset_for_rep: path to target original training dataset - output_path: path to output directory - experiment_name: name of experiment (no spaces) - match_label: applies if original training data included column with matched instance ids, default=None - exclude_plots: analysis to exclude from outputs, possible options given below. \ - export_feature_correlations, run and export feature correlation analysis (yields correlation heatmap), \ - default=True - plot_roc, Plot ROC curves individually for each algorithm including all CV results and averages, \ - default=True - plot_prc, Plot PRC curves individually for each algorithm including all CV results and averages, \ - default=True - plot_metric_boxplots, Plot box plot summaries comparing algorithms for each metric, default=True - """ - - self.rep_data_path = rep_data_path - self.dataset_for_rep = dataset_for_rep - self.output_path = output_path - self.experiment_name = experiment_name - # Param for future expansion - self.plot_lists = None - self.match_label = match_label - - known_exclude_options = ['plot_ROC', 'plot_PRC', 'plot_metric_boxplots', 'feature_correlations'] - if exclude_plots is not None: - for x in exclude_plots: - if x not in known_exclude_options: - logging.warning("Unknown exclusion option " + str(x)) - else: - exclude_plots = list() - - self.exclude_plots = exclude_plots - self.plot_roc = 'plot_ROC' not in exclude_plots - self.plot_prc = 'plot_PRC' not in exclude_plots - self.plot_metric_boxplots = 'plot_metric_boxplots' not in exclude_plots - self.plot_fi_box = 'plot_FI_box' not in exclude_plots - self.export_feature_correlations = 'feature_correlations' not in exclude_plots - - self.experiment_path = self.output_path + '/' + self.experiment_name - - # Save unique dataset names so that analysis is run only once if there is - # both a .txt and .csv version of dataset with same name. - self.data_name = self.dataset_for_rep.split('/')[-1].split('.')[0] - - # Unpickle metadata from previous phase - file = open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'rb') - metadata = pickle.load(file) - file.close() - # Load variables specified earlier in the pipeline from metadata - self.class_label = class_label - if not class_label: - self.class_label = metadata['Class Label'] - self.instance_label = instance_label - if not instance_label: - self.instance_label = metadata['Instance Label'] - self.ignore_features = metadata['Ignored Features'] - self.categorical_cutoff = metadata['Categorical Cutoff'] - self.sig_cutoff = metadata['Statistical Significance Cutoff'] - self.featureeng_missingness = metadata['Engineering Missingness Cutoff'] - self.cleaning_missingness = metadata['Cleaning Missingness Cutoff'] - self.cv_partitions = metadata['CV Partitions'] - self.scale_data = metadata['Use Data Scaling'] - self.impute_data = metadata['Use Data Imputation'] - self.multi_impute = metadata['Use Multivariate Imputation'] - self.show_plots = show_plots - self.scoring_metric = metadata['Primary Metric'] - self.random_state = metadata['Random Seed'] - - self.run_cluster = run_cluster - self.queue = queue - self.reserved_memory = reserved_memory - - # Argument checks - if not os.path.exists(self.output_path): - raise Exception("Output path must exist (from phase 1-8) before model application can begin") - if not os.path.exists(self.output_path + '/' + self.experiment_name): - raise Exception("Experiment must exist (from phase 1-8) before model application can begin") - - # location of folder containing models respective training dataset - self.full_path = self.output_path + "/" + self.experiment_name + "/" + self.data_name - - if not os.path.exists(self.full_path + "/replication"): - os.makedirs(self.full_path + "/replication") - - if not self.show_plots: - if not os.path.exists(self.output_path + "/" + self.experiment_name + '/jobs'): - os.mkdir(self.output_path + "/" + self.experiment_name + '/jobs') - if not os.path.exists(self.output_path + "/" + self.experiment_name + '/logs'): - os.mkdir(self.output_path + "/" + self.experiment_name + '/logs') - - if not load_algo: - if algorithms is None: - self.algorithms = SUPPORTED_MODELS - if exclude is not None: - for algorithm in exclude: - try: - self.algorithms.remove(algorithm) - except Exception: - Exception("Unknown algorithm in exclude: " + str(algorithm)) - else: - self.algorithms = list() - for algorithm in algorithms: - self.algorithms.append(is_supported_model(algorithm)) - else: - self.get_algorithms() - - self.save_metadata() - - def run(self, run_parallel=False): - # Determine file extension of datasets in target folder: - file_count = 0 - unique_datanames = list() - job_list = list() - for dataset_filename in glob.glob(self.rep_data_path + '/*'): - dataset_filename = str(Path(dataset_filename).as_posix()) - # Save unique dataset names so that analysis is run only once if - # there is both a .txt and .csv version of dataset with same name. - file_extension = dataset_filename.split('/')[-1].split('.')[-1] - apply_name = dataset_filename.split('/')[-1].split('.')[0] - - if not os.path.exists(self.full_path + "/replication/" + apply_name): - os.mkdir(self.full_path + "/replication/" + apply_name) - - if file_extension == 'txt' or file_extension == 'csv' or file_extension == 'tsv': - if apply_name not in unique_datanames: - file_count += 1 - unique_datanames.append(apply_name) - - if self.run_cluster == "SLURMOld": - self.submit_slurm_cluster_job(dataset_filename) - continue - - if self.run_cluster == "LSFOld": - self.submit_lsf_cluster_job(dataset_filename) - continue - - job_obj = ReplicateJob(dataset_filename, - self.dataset_for_rep, self.full_path, self.class_label, self.instance_label, - self.match_label, ignore_features=self.ignore_features, - algorithms=self.algorithms, exclude=None, - cv_partitions=self.cv_partitions, - exclude_plots=None, - categorical_cutoff=self.categorical_cutoff, - sig_cutoff=self.sig_cutoff, scale_data=self.scale_data, - impute_data=self.impute_data, - multi_impute=self.multi_impute, show_plots=self.show_plots, - scoring_metric=self.scoring_metric, - random_state=self.random_state) - if run_parallel and run_parallel != "False": - # p = multiprocessing.Process(target=runner_fn, args=(job_obj,)) - job_list.append(job_obj) - else: - job_obj.run() - if run_parallel and run_parallel != "False" and not self.run_cluster: - Parallel(n_jobs=num_cores)(delayed(runner_fn)(job_obj) for job_obj in job_list) - if self.run_cluster and "Old" not in self.run_cluster: - get_cluster(self.run_cluster, self.output_path + '/' + self.experiment_name, - self.queue, self.reserved_memory) - dask.compute([dask.delayed(runner_fn)(job_obj) for job_obj in job_list]) - if file_count == 0: - # Check that there was at least 1 dataset - raise Exception("There must be at least one .txt, .csv, or .tsv dataset in rep_data_path directory") - - def save_metadata(self): - # Update metadata this will alter the relevant - # metadata so that it is specific to the 'replication' analysis being run. - file = open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'rb') - metadata = pickle.load(file) - file.close() - metadata['Export Feature Correlations'] = self.export_feature_correlations - metadata['Export ROC Plot'] = self.plot_roc - metadata['Export PRC Plot'] = self.plot_prc - metadata['Export Metric Boxplots'] = self.plot_metric_boxplots - metadata['Match Label'] = self.match_label - # Pickle the metadata for future use - pickle_out = open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'wb') - pickle.dump(metadata, pickle_out) - pickle_out.close() - - def get_algorithms(self): - pickle_in = open(self.output_path + '/' + self.experiment_name + '/' + "algInfo.pickle", 'rb') - alg_info = pickle.load(pickle_in) - algorithms = list() - for algorithm in alg_info.keys(): - if alg_info[algorithm][0]: - algorithms.append(algorithm) - self.algorithms = algorithms - pickle_in.close() - - def get_cluster_params(self, dataset_filename): - exclude_param = ','.join(self.exclude_plots) if self.exclude_plots else None - cluster_params = [dataset_filename, self.dataset_for_rep, self.full_path, self.class_label, self.instance_label, - self.match_label, None, None, self.cv_partitions, exclude_param, - self.categorical_cutoff, self.sig_cutoff, - self.scale_data, self.impute_data, - self.multi_impute, self.show_plots, self.scoring_metric, self.random_state] - cluster_params = [str(i) for i in cluster_params] - return cluster_params - - def submit_slurm_cluster_job(self, dataset_filename): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/P9_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#SBATCH -p ' + self.queue + '\n') - sh_file.write('#SBATCH --job-name=' + job_ref + '\n') - sh_file.write('#SBATCH --mem=' + str(self.reserved_memory) + 'G' + '\n') - # sh_file.write('#BSUB -M '+str(maximum_memory)+'GB'+'\n') - sh_file.write( - '#SBATCH -o ' + self.output_path + '/' + self.experiment_name + - '/logs/P9_' + job_ref + '.o\n') - sh_file.write( - '#SBATCH -e ' + self.output_path + '/' + self.experiment_name + - '/logs/P9_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/RepJobSubmit.py' - cluster_params = self.get_cluster_params(dataset_filename) - command = ' '.join(['srun', 'python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('sbatch ' + job_name) - - def submit_lsf_cluster_job(self, dataset_filename): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/P9_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#BSUB -q ' + self.queue + '\n') - sh_file.write('#BSUB -J ' + job_ref + '\n') - sh_file.write('#BSUB -R "rusage[mem=' + str(self.reserved_memory) + 'G]"' + '\n') - sh_file.write('#BSUB -M ' + str(self.reserved_memory) + 'GB' + '\n') - sh_file.write( - '#BSUB -o ' + self.output_path + '/' + self.experiment_name + - '/logs/P9_' + job_ref + '.o\n') - sh_file.write( - '#BSUB -e ' + self.output_path + '/' + self.experiment_name + - '/logs/P9_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/RepJobSubmit.py' - cluster_params = self.get_cluster_params(dataset_filename) - command = ' '.join(['python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('bsub < ' + job_name) diff --git a/streamline/runners/report_runner.py b/streamline/runners/report_runner.py deleted file mode 100644 index 5e122448..00000000 --- a/streamline/runners/report_runner.py +++ /dev/null @@ -1,153 +0,0 @@ -import os -import time -import dask -from pathlib import Path -from joblib import Parallel, delayed -from streamline.modeling.utils import SUPPORTED_MODELS -from streamline.modeling.utils import is_supported_model -from streamline.postanalysis.gererate_report import ReportJob -from streamline.utils.runners import runner_fn -from streamline.utils.cluster import get_cluster - - -class ReportRunner: - """ - Runner Class for collating dataset compare job - """ - - def __init__(self, output_path=None, experiment_name=None, experiment_path=None, algorithms=None, - exclude=("XCS", "eLCS"), - training=True, rep_data_path=None, dataset_for_rep=None, - run_cluster=False, queue='defq', reserved_memory=4): - """ - Args: - output_path: path to output directory - experiment_name: name of experiment (no spaces) - algorithms: list of str of ML models to run - training: Indicate True or False for whether to generate pdf summary for pipeline \ - training or followup application analysis to new dataset,default=True - rep_data_path: path to directory containing replication or hold-out testing datasets \ - (must have at least all features with same labels as in - original training dataset),default=None - dataset_for_rep: path to target original training dataset - - """ - assert (output_path is not None and experiment_name is not None) or (experiment_path is not None) - if output_path is not None and experiment_name is not None: - self.output_path = output_path - self.experiment_name = experiment_name - self.experiment_path = self.output_path + '/' + self.experiment_name - else: - self.experiment_path = experiment_path - self.experiment_name = self.experiment_path.split('/')[-1] - self.output_path = self.experiment_path.split('/')[-2] - - self.training = training - self.rep_data_path = rep_data_path - self.train_data_path = dataset_for_rep - - self.run_cluster = run_cluster - self.queue = queue - self.reserved_memory = reserved_memory - - if algorithms is None: - self.algorithms = SUPPORTED_MODELS - if exclude is not None: - for algorithm in exclude: - try: - self.algorithms.remove(algorithm) - except Exception: - Exception("Unknown algorithm in exclude: " + str(algorithm)) - self.exclude = None - else: - self.algorithms = list() - for algorithm in algorithms: - self.algorithms.append(is_supported_model(algorithm)) - self.exclude = exclude - - # Argument checks - if not os.path.exists(self.output_path): - raise Exception("Output path must exist (from phase 1) before phase 6 can begin") - if not os.path.exists(self.output_path + '/' + self.experiment_name): - raise Exception("Experiment must exist (from phase 1) before phase 6 can begin") - - def run(self, run_parallel=False): - - if self.run_cluster in ["SLURMOld", "LSFOld"]: - if self.run_cluster == "SLURMOld": - self.submit_slurm_cluster_job() - - if self.run_cluster == "LSFOld": - self.submit_lsf_cluster_job() - else: - job_obj = ReportJob(self.output_path, self.experiment_name, None, self.algorithms, None, - self.training, self.train_data_path, self.rep_data_path) - # running direct because it's faster - HACK = not run_parallel - if not HACK: - if run_parallel and run_parallel != "False" and not self.run_cluster: - # p = multiprocessing.Process(target=runner_fn, args=(job_obj, )) - # p.start() - # p.join() - Parallel()(delayed(runner_fn)(job_obj) for job_obj in [job_obj, ]) - elif self.run_cluster and "Old" not in self.run_cluster: - get_cluster(self.run_cluster, self.output_path + '/' + self.experiment_name, - self.queue, self.reserved_memory) - dask.compute([dask.delayed(runner_fn)(job_obj) for job_obj in [job_obj, ]]) - else: - job_obj.run() - - else: - job_obj.run() - - def get_cluster_params(self): - cluster_params = [self.output_path, self.experiment_name, None, None, None, - self.training, self.train_data_path, self.rep_data_path] - cluster_params = [str(i) for i in cluster_params] - return cluster_params - - def submit_slurm_cluster_job(self): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/PDF_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#SBATCH -p ' + self.queue + '\n') - sh_file.write('#SBATCH --job-name=' + job_ref + '\n') - sh_file.write('#SBATCH --mem=' + str(self.reserved_memory) + 'G' + '\n') - # sh_file.write('#BSUB -M '+str(maximum_memory)+'GB'+'\n') - sh_file.write( - '#SBATCH -o ' + self.output_path + '/' + self.experiment_name + - '/logs/PDF_' + job_ref + '.o\n') - sh_file.write( - '#SBATCH -e ' + self.output_path + '/' + self.experiment_name + - '/logs/PDF_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/ReportJobSubmit.py' - cluster_params = self.get_cluster_params() - command = ' '.join(['srun', 'python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('sbatch ' + job_name) - - def submit_lsf_cluster_job(self): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/PDF_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#BSUB -q ' + self.queue + '\n') - sh_file.write('#BSUB -J ' + job_ref + '\n') - sh_file.write('#BSUB -R "rusage[mem=' + str(self.reserved_memory) + 'G]"' + '\n') - sh_file.write('#BSUB -M ' + str(self.reserved_memory) + 'GB' + '\n') - sh_file.write( - '#BSUB -o ' + self.output_path + '/' + self.experiment_name + - '/logs/PDF_' + job_ref + '.o\n') - sh_file.write( - '#BSUB -e ' + self.output_path + '/' + self.experiment_name + - '/logs/PDF_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/ReportJobSubmit.py' - cluster_params = self.get_cluster_params() - command = ' '.join(['python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('bsub < ' + job_name) diff --git a/streamline/runners/stats_runner.py b/streamline/runners/stats_runner.py deleted file mode 100644 index 68e3f14c..00000000 --- a/streamline/runners/stats_runner.py +++ /dev/null @@ -1,216 +0,0 @@ -import logging -import os -import glob -import time -import dask -import pickle -from pathlib import Path -from joblib import Parallel, delayed -from streamline.modeling.utils import SUPPORTED_MODELS -from streamline.modeling.utils import is_supported_model -from streamline.postanalysis.statistics import StatsJob -from streamline.utils.runners import runner_fn, num_cores -from streamline.utils.cluster import get_cluster - - -class StatsRunner: - """ - Runner Class for collating statistics of all the models - """ - - def __init__(self, output_path, experiment_name, algorithms=None, exclude=("XCS", "eLCS"), - class_label="Class", instance_label=None, scoring_metric='balanced_accuracy', - top_features=40, sig_cutoff=0.05, metric_weight='balanced_accuracy', scale_data=True, - exclude_plots=None, show_plots=False, - run_cluster=False, queue='defq', reserved_memory=4): - """ - Args: - output_path: path to output directory - experiment_name: name of experiment (no spaces) - algorithms: list of str of ML models to run - scoring_metric='balanced_accuracy' - sig_cutoff: significance cutoff, default=0.05 - metric_weight='balanced_accuracy' - scale_data=True - exclude_plots: - metric_weight: ML model metric used as weight in composite FI plots \ - (only supports balanced_accuracy or roc_auc as options). \ - Recommend setting the same as primary_metric if possible, \ - default='balanced_accuracy' - top_features: number of top features to illustrate in figures, default=40 - show_plots: flag to show plots - - """ - self.dataset = None - self.output_path = output_path - self.experiment_name = experiment_name - self.class_label = class_label - self.instance_label = instance_label - - if algorithms is None: - self.algorithms = SUPPORTED_MODELS - if exclude is not None: - for algorithm in exclude: - try: - self.algorithms.remove(algorithm) - except Exception: - Exception("Unknown algorithm in exclude: " + str(algorithm)) - else: - self.algorithms = list() - for algorithm in algorithms: - self.algorithms.append(is_supported_model(algorithm)) - - self.algorithms = sorted(self.algorithms) - - self.scale_data = scale_data - self.sig_cutoff = sig_cutoff - self.show_plots = show_plots - self.scoring_metric = scoring_metric - self.exclude_plots = exclude_plots - - known_exclude_options = ['plot_ROC', 'plot_PRC', 'plot_FI_box', 'plot_metric_boxplots'] - if exclude_plots is not None: - for x in exclude_plots: - if x not in known_exclude_options: - logging.warning("Unknown exclusion option " + str(x)) - else: - exclude_plots = list() - - self.plot_roc = 'plot_ROC' not in exclude_plots - self.plot_prc = 'plot_PRC' not in exclude_plots - self.plot_metric_boxplots = 'plot_metric_boxplots' not in exclude_plots - self.plot_fi_box = 'plot_FI_box' not in exclude_plots - self.metric_weight = metric_weight - self.top_features = top_features - - self.run_cluster = run_cluster - self.queue = queue - self.reserved_memory = reserved_memory - - # Argument checks - if not os.path.exists(self.output_path): - raise Exception("Output path must exist (from phase 1) before phase 6 can begin") - if not os.path.exists(self.output_path + '/' + self.experiment_name): - raise Exception("Experiment must exist (from phase 1) before phase 6 can begin") - - self.save_metadata() - - def run(self, run_parallel=False): - - # Iterate through datasets, ignoring common folders - dataset_paths = os.listdir(self.output_path + "/" + self.experiment_name) - remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle', 'jobsCompleted', 'dask_logs', - 'logs', 'jobs', 'DatasetComparisons', - self.experiment_name + '_STREAMLINE_Report.pdf'] - - for text in remove_list: - if text in dataset_paths: - dataset_paths.remove(text) - - job_list = list() - for dataset_directory_path in dataset_paths: - full_path = self.output_path + "/" + self.experiment_name + "/" + dataset_directory_path - - # Create folders for DT and GP visualizations - if "DT" in self.algorithms and not os.path.exists(full_path + '/model_evaluation/DT_Viz'): - os.mkdir(full_path + '/model_evaluation/DT_Viz') - if "GP" in self.algorithms and not os.path.exists(full_path + '/model_evaluation/GP_Viz'): - os.mkdir(full_path + '/model_evaluation/GP_Viz') - - cv_dataset_paths = list(glob.glob(full_path + "/CVDatasets/*_CV_*Train.csv")) - cv_dataset_paths = [str(Path(cv_dataset_path)) for cv_dataset_path in cv_dataset_paths] - cv_partitions = len(cv_dataset_paths) - - if self.run_cluster == "SLURMOld": - self.submit_slurm_cluster_job(full_path, cv_partitions) - continue - - if self.run_cluster == "LSFOld": - self.submit_lsf_cluster_job(full_path, cv_partitions) - continue - - job_obj = StatsJob(full_path, self.algorithms, self.class_label, self.instance_label, self.scoring_metric, - cv_partitions, self.top_features, self.sig_cutoff, self.metric_weight, self.scale_data, - self.exclude_plots, - self.show_plots) - if run_parallel and run_parallel != "False": - # p = multiprocessing.Process(target=runner_fn, args=(job_obj, )) - job_list.append(job_obj) - else: - job_obj.run() - if run_parallel and run_parallel != "False" and not self.run_cluster: - Parallel(n_jobs=num_cores)(delayed(runner_fn)(job_obj) for job_obj in job_list) - if self.run_cluster and "Old" not in self.run_cluster: - get_cluster(self.run_cluster, - self.output_path + '/' + self.experiment_name, self.queue, self.reserved_memory) - dask.compute([dask.delayed(runner_fn)(job_obj) for job_obj in job_list]) - - def save_metadata(self): - file = open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'rb') - metadata = pickle.load(file) - file.close() - metadata['Export ROC Plot'] = self.plot_roc - metadata['Export PRC Plot'] = self.plot_prc - metadata['Export Metric Boxplots'] = self.plot_metric_boxplots - metadata['Export Feature Importance Boxplots'] = self.plot_fi_box - metadata['Metric Weighting Composite FI Plots'] = self.metric_weight - metadata['Top Model Features To Display'] = self.top_features - # Pickle the metadata for future use - pickle_out = open(self.output_path + '/' + self.experiment_name + '/' + "metadata.pickle", 'wb') - pickle.dump(metadata, pickle_out) - pickle_out.close() - - def get_cluster_params(self, full_path, len_cv): - exclude_param = ','.join(self.exclude_plots) if self.exclude_plots else None - cluster_params = [full_path, None, self.class_label, self.instance_label, self.scoring_metric, - len_cv, self.top_features, self.sig_cutoff, self.metric_weight, self.scale_data, - exclude_param, - self.show_plots] - cluster_params = [str(i) for i in cluster_params] - return cluster_params - - def submit_slurm_cluster_job(self, dataset_path, len_cv): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/P6_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#SBATCH -p ' + self.queue + '\n') - sh_file.write('#SBATCH --job-name=' + job_ref + '\n') - sh_file.write('#SBATCH --mem=' + str(self.reserved_memory) + 'G' + '\n') - # sh_file.write('#BSUB -M '+str(maximum_memory)+'GB'+'\n') - sh_file.write( - '#SBATCH -o ' + self.output_path + '/' + self.experiment_name + - '/logs/P6_' + job_ref + '.o\n') - sh_file.write( - '#SBATCH -e ' + self.output_path + '/' + self.experiment_name + - '/logs/P6_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/StatsJobSubmit.py' - cluster_params = self.get_cluster_params(dataset_path, len_cv) - command = ' '.join(['srun', 'python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('sbatch ' + job_name) - - def submit_lsf_cluster_job(self, dataset_path, len_cv): - job_ref = str(time.time()) - job_name = self.output_path + '/' + self.experiment_name + '/jobs/P6_' + job_ref + '_run.sh' - sh_file = open(job_name, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#BSUB -q ' + self.queue + '\n') - sh_file.write('#BSUB -J ' + job_ref + '\n') - sh_file.write('#BSUB -R "rusage[mem=' + str(self.reserved_memory) + 'G]"' + '\n') - sh_file.write('#BSUB -M ' + str(self.reserved_memory) + 'GB' + '\n') - sh_file.write( - '#BSUB -o ' + self.output_path + '/' + self.experiment_name + - '/logs/P6_' + job_ref + '.o\n') - sh_file.write( - '#BSUB -e ' + self.output_path + '/' + self.experiment_name + - '/logs/P6_' + job_ref + '.e\n') - - file_path = str(Path(__file__).parent.parent.parent) + "/streamline/legacy" + '/StatsJobSubmit.py' - cluster_params = self.get_cluster_params(dataset_path, len_cv) - command = ' '.join(['python', file_path] + cluster_params) - sh_file.write(command + '\n') - sh_file.close() - os.system('bsub < ' + job_name) diff --git a/streamline/tests/conftest.py b/streamline/tests/conftest.py new file mode 100644 index 00000000..c14f8ad4 --- /dev/null +++ b/streamline/tests/conftest.py @@ -0,0 +1,10 @@ +from __future__ import annotations + +import sys + +import pytest + + +def pytest_sessionstart(session): + if sys.version_info < (3, 10): + pytest.exit("STREAMLINE tests require Python 3.10 or newer.", returncode=2) diff --git a/streamline/tests/old/test_00load_model.py b/streamline/tests/old/test_00load_model.py deleted file mode 100644 index 64ed4b47..00000000 --- a/streamline/tests/old/test_00load_model.py +++ /dev/null @@ -1,8 +0,0 @@ -import pytest -from streamline.modeling.load_models import load_class_from_folder - -pytest.skip("Tested Already", allow_module_level=True) - - -def test_load_class_from_folder(): - load_class_from_folder() diff --git a/streamline/tests/old/test_0kfold.py b/streamline/tests/old/test_0kfold.py deleted file mode 100644 index 0e2fe905..00000000 --- a/streamline/tests/old/test_0kfold.py +++ /dev/null @@ -1,40 +0,0 @@ -import shutil -import pytest -import pandas as pd -from streamline.utils.dataset import Dataset -from streamline.dataprep.kfold_partitioning import KFoldPartitioner - -pytest.skip("Tested Already", allow_module_level=True) - -dataset_valid = Dataset("./DemoData/hcc-data_example.csv", "Class") - - -@pytest.mark.parametrize( - ("dataset", "partition_method", "experiment_path", "exception"), - [ - ("", "Random", "./tests/", Exception), - (dataset_valid, "something", "./tests/", Exception), - (dataset_valid, "Group", "./tests/", Exception), - ], -) -def test_invalid_kfold(dataset, partition_method, experiment_path, exception): - with pytest.raises(exception): - KFoldPartitioner(dataset, partition_method, experiment_path) - - -def test_valid_kfold(): - partition_method, experiment_path = "Stratified", "./tests/" - kfold = KFoldPartitioner(dataset_valid, partition_method, experiment_path, n_splits=5, random_state=42) - train_dfs, test_dfs = kfold.cv_partitioner(return_dfs=False, save_dfs=False, - partition_method=partition_method) - assert (train_dfs is None) - assert (test_dfs is None) - train_dfs, test_dfs = kfold.cv_partitioner(return_dfs=True, save_dfs=False, - partition_method=partition_method) - for df in train_dfs + test_dfs: - print(len(df)) - assert (type(df) is pd.DataFrame and len(df) != 0) - - train_dfs, test_dfs = kfold.cv_partitioner(return_dfs=False, save_dfs=True, - partition_method=partition_method) - shutil.rmtree('./tests/') diff --git a/streamline/tests/old/test_1dataprep.py b/streamline/tests/old/test_1dataprep.py deleted file mode 100644 index 4ce6ba76..00000000 --- a/streamline/tests/old/test_1dataprep.py +++ /dev/null @@ -1,98 +0,0 @@ -import pytest -import shutil -from streamline.utils.dataset import Dataset -from streamline.dataprep.data_process import DataProcess - -pytest.skip("Tested Already", allow_module_level=True) - - -@pytest.mark.parametrize( - ("dataset_path", "class_label", "match_label", "instance_label", "exception"), - [ - ("", None, None, None, Exception), - ("./hcc-data_example.csv", "something", None, None, FileNotFoundError), - ("./hcc-data_example.csv", "something", None, None, Exception), - ("./hcc-data_example.csv", "something", "otherthing", None, Exception), - ("./hcc-data_example.csv", "something", None, "otherthing", Exception), - ], -) -def test_invalid_datapath(dataset_path, class_label, match_label, instance_label, exception): - with pytest.raises(exception): - Dataset(dataset_path, class_label, match_label, instance_label) - - -@pytest.mark.parametrize( - ("dataset_path", "class_label", "match_label", "instance_label"), - [ - ("./DemoData/hcc-data_example.csv", "Class", None, None), - ], -) -def test_valid_dataset(dataset_path, class_label, match_label, instance_label): - dataset = Dataset(dataset_path, class_label, match_label, instance_label) - drop_list = [class_label, ] - if match_label: - drop_list.append(match_label) - if instance_label: - drop_list.append(instance_label) - assert (class_label in dataset.data.columns) - assert (dataset.feature_only_data().equals(dataset.data.drop(drop_list, axis=1))) - assert (dataset.get_outcome().equals(dataset.data[dataset.class_label])) - dataset.clean_data(None) - dataset.set_headers('./tests/') - shutil.rmtree('./tests/') - - -@pytest.mark.parametrize( - ("dataset", "experiment_path", "exception"), - [ - ("", "./test/", Exception), - ("../sdsad.txt", "./test/", Exception), - ], -) -def test_invalid_eda(dataset, experiment_path, exception): - with pytest.raises(exception): - DataProcess(dataset, experiment_path) - - -def test_invalid_eda_2(): - dataset, experiment_path = "./DemoData/hcc-data_example.csv", "./tests/" - explorations = ["sdasd"] - plots = ["dsfsdf"] - with pytest.raises(Exception): - DataProcess(dataset, experiment_path, explorations=explorations) - with pytest.raises(Exception): - DataProcess(dataset, experiment_path, plots=plots) - - -def test_valid_eda(): - dataset = Dataset("./DemoData/hcc-data_example.csv", "Class", None, "InstanceID") - eda = DataProcess(dataset, "./tests/") - eda.make_log_folders() - assert (eda.dataset.data.equals(dataset.data)) - eda.drop_ignored_rowcols() - assert (eda.dataset.data.equals(dataset.data)) - categorical_variables = eda.identify_feature_types() - - test_cv = ['Gender', 'Symptoms ', 'Alcohol', 'Hepatitis B Surface Antigen', - 'Hepatitis B e Antigen', 'Hepatitis B Core Antibody', 'Hepatitis C Virus Antibody', - 'Cirrhosis', 'Endemic Countries', 'Smoking', 'Diabetes', 'Obesity', 'Hemochromatosis', - 'Arterial Hypertension', 'Chronic Renal Insufficiency', 'Human Immunodeficiency Virus', - 'Nonalcoholic Steatohepatitis', 'Esophageal Varices', 'Splenomegaly', 'Portal Hypertension', - 'Portal Vein Thrombosis', 'Liver Metastasis', 'Radiological Hallmark', 'Performance Status*', - 'Encephalopathy degree*', 'Ascites degree*', 'Number of Nodules'] - - assert (categorical_variables == test_cv) - eda.dataset.describe_data("./tests/") - eda.dataset.missingness_counts("./tests/") - eda.dataset.missing_count_plot("./tests/") - eda.counts_summary() - eda.univariate_analysis() - eda.univariate_plots() - shutil.rmtree('./tests/') - - -def test_valid_eda_general(): - dataset = Dataset("./DemoData/hcc-data_example.csv", "Class", None, "InstanceID") - eda = DataProcess(dataset, "./tests/") - eda.run() - shutil.rmtree('./tests/') diff --git a/streamline/tests/old/test_2edarunner.py b/streamline/tests/old/test_2edarunner.py deleted file mode 100644 index 7370e8ca..00000000 --- a/streamline/tests/old/test_2edarunner.py +++ /dev/null @@ -1,43 +0,0 @@ -import os -import time -import pytest -import shutil -import logging -from streamline.runners.dataprocess_runner import DataProcessRunner - -pytest.skip("Tested Already", allow_module_level=True) - - -@pytest.mark.parametrize( - ("dataset", "output_path", "experiment_name", "exception"), - [ - ("./random_folder/", "./tests/", 'demo', Exception), - ("./DemoData/", "./tests/", ".@!#@", Exception), - ], -) -def test_invalid_eda(dataset, output_path, experiment_name, exception): - with pytest.raises(exception): - DataProcessRunner(dataset, output_path, experiment_name) - - -def test_valid_eda(): - if not os.path.exists('./tests1/'): - os.mkdir('./tests1/') - - start = time.time() - eda = DataProcessRunner("./DemoData/", "./tests1/", 'demo', exploration_list=None, plot_list=None, - class_label="Class", instance_label="InstanceID", ignore_features=["Alcohol"]) - eda.run(run_parallel=False) - logging.warning("Exploratory Data Analysis, Time running serially: " + str(time.time() - start)) - - shutil.rmtree('./tests1/') - - if not os.path.exists('./tests2/'): - os.mkdir('./tests2/') - - start = time.time() - eda = DataProcessRunner("./DemoData/", "./tests2/", 'demo', exploration_list=None, plot_list=None, - class_label="Class", instance_label="InstanceID", ignore_features=["Alcohol"]) - eda.run(run_parallel=True) - logging.warning("Exploratory Data Analysis, Time running parallely: " + str(time.time() - start)) - shutil.rmtree('./tests2/') diff --git a/streamline/tests/old/test_3dataprocess.py b/streamline/tests/old/test_3dataprocess.py deleted file mode 100644 index e6b0aa49..00000000 --- a/streamline/tests/old/test_3dataprocess.py +++ /dev/null @@ -1,49 +0,0 @@ -import os -import time -import pytest -import shutil -import logging -from streamline.runners.dataprocess_runner import DataProcessRunner -from streamline.runners.imputation_runner import ImputationRunner - -pytest.skip("Tested Already", allow_module_level=True) - - -@pytest.mark.parametrize( - ("output_path", "experiment_name", "exception"), - [ - ("./tests/", 'demo', Exception), - ("./tests/", ".@!#@", Exception), - ], -) -def test_invalid_datap(output_path, experiment_name, exception): - with pytest.raises(exception): - ImputationRunner(output_path, experiment_name) - - -def test_valid_datap(): - if not os.path.exists('./tests3/'): - os.mkdir('./tests3/') - eda = DataProcessRunner("./DemoData/", "./tests3/", 'demo', exploration_list=None, plot_list=None, - class_label="Class") - eda.run(run_parallel=False) - - start = time.time() - dpr = ImputationRunner("./tests3/", 'demo') - dpr.run(run_parallel=False) - logging.warning("Data Scale and Impute, Time running serially: " + str(time.time() - start)) - - shutil.rmtree('./tests3/') - - if not os.path.exists('./tests3/'): - os.mkdir('./tests3/') - eda = DataProcessRunner("./DemoData/", "./tests3/", 'demo', exploration_list=None, plot_list=None, - class_label="Class") - eda.run(run_parallel=True) - - start = time.time() - dpr = ImputationRunner("./tests3/", 'demo') - dpr.run(run_parallel=True) - logging.warning("Data Scale and Impute, Time running parallely: " + str(time.time() - start)) - - shutil.rmtree('./tests3/') diff --git a/streamline/tests/old/test_4featurefns.py b/streamline/tests/old/test_4featurefns.py deleted file mode 100644 index 449de468..00000000 --- a/streamline/tests/old/test_4featurefns.py +++ /dev/null @@ -1,117 +0,0 @@ -import os -import time -import pytest -import shutil -import logging -from streamline.runners.dataprocess_runner import DataProcessRunner -from streamline.runners.imputation_runner import ImputationRunner -from streamline.runners.feature_runner import FeatureImportanceRunner -from streamline.runners.feature_runner import FeatureSelectionRunner - -pytest.skip("Tested Already", allow_module_level=True) - - -@pytest.mark.parametrize( - ("output_path", "experiment_name", "exception"), - [ - ("./tests/", 'demo', Exception), - ("./tests/", ".@!#@", Exception), - ], -) -def test_invalid_feature_imp(output_path, experiment_name, exception): - with pytest.raises(exception): - FeatureImportanceRunner(output_path, experiment_name) - - -@pytest.mark.parametrize( - ("output_path", "experiment_name", "exception"), - [ - ("./tests/", 'demo', Exception), - ("./tests/", ".@!#@", Exception), - ], -) -def test_invalid_feature_sel(output_path, experiment_name, exception): - with pytest.raises(exception): - FeatureSelectionRunner(output_path, experiment_name) - - -@pytest.mark.parametrize( - ("algorithms", "run_parallel", "use_turf", "turf_pct", "output_path"), - [ - (["MI"], False, None, None, "./tests4_1/"), - (["MS"], False, True, True, "./tests4_2/"), - (["MI", "MS"], False, True, True, "./tests4_3/"), - # (["MI"], True, None, None, "./tests4_2/"), - # (["MS"], False, True, False, "./tests4_4/"), - # (["MS"], False, False, False, "./tests4_5/"), - # (["MS"], True, True, True, "./tests4_3/"), - # (["MS"], True, True, False, "./tests4_4/"), - # (["MS"], True, False, False, "./tests4_5/"), - ], -) -def test_valid_feature_imp(algorithms, run_parallel, use_turf, turf_pct, output_path): - dataset_path, experiment_name = "./DemoData/", "demo", - if not os.path.exists(output_path): - os.mkdir(output_path) - eda = DataProcessRunner(dataset_path, output_path, experiment_name, exploration_list=None, plot_list=None, - class_label="Class") - eda.run(run_parallel=False) - - dpr = ImputationRunner(output_path, experiment_name) - dpr.run(run_parallel=False) - - start = time.time() - - f_imp = FeatureImportanceRunner(output_path, experiment_name, algorithms=algorithms, - use_turf=use_turf, turf_pct=turf_pct) - f_imp.run(run_parallel=run_parallel) - if run_parallel: - how = "parallely" - else: - how = "serially" - logging.warning("Feature Importance Step with " + str(algorithms) + - ", Time running " + how + ": " + str(time.time() - start)) - - shutil.rmtree(output_path) - - -@pytest.mark.parametrize( - ("algorithms", "run_parallel", "output_path"), - [ - (["MI", "MS"], False, "./tests5_1/"), - # (["MI", "MS"], True, "./tests5_2/"), - ], -) -def test_valid_feature_sel(algorithms, run_parallel, output_path): - dataset_path, experiment_name = "./DemoData/", "demo", - if not os.path.exists(output_path): - os.mkdir(output_path) - eda = DataProcessRunner(dataset_path, output_path, experiment_name, exploration_list=None, plot_list=None, - class_label="Class") - eda.run(run_parallel=False) - del eda - - dpr = ImputationRunner(output_path, experiment_name) - dpr.run(run_parallel=False) - del dpr - - f_imp = FeatureImportanceRunner(output_path, experiment_name, algorithms=algorithms) - f_imp.run(run_parallel=False) - del f_imp - - start = time.time() - - logging.warning("Running Feature Selection") - f_sel = FeatureSelectionRunner(output_path, experiment_name, algorithms=algorithms, overwrite_cv=False) - f_sel.run(run_parallel) - - del f_sel - - if run_parallel: - how = "parallely" - else: - how = "serially" - logging.warning("Feature Selection Step with " + str(algorithms) + - ", Time running " + how + ": " + str(time.time() - start)) - - shutil.rmtree(output_path) diff --git a/streamline/tests/old/test_5model.py b/streamline/tests/old/test_5model.py deleted file mode 100644 index 654b4874..00000000 --- a/streamline/tests/old/test_5model.py +++ /dev/null @@ -1,70 +0,0 @@ -import os -import time -import optuna -import pytest -import shutil -import logging -from streamline.runners.dataprocess_runner import DataProcessRunner -from streamline.runners.imputation_runner import ImputationRunner -from streamline.runners.feature_runner import FeatureImportanceRunner -from streamline.runners.feature_runner import FeatureSelectionRunner -from streamline.modeling.modeljob import ModelJob -from streamline.models.linear_model import LogisticRegression -from streamline.models.naive_bayes import NaiveBayesClassifier - -pytest.skip("Tested Already", allow_module_level=True) - - -algorithms, run_parallel, output_path = ["MI", "MS"], False, "./tests/" -dataset_path, experiment_name = "./DemoData/", "demo", - - -def test_setup(): - if not os.path.exists(output_path): - os.mkdir(output_path) - eda = DataProcessRunner(dataset_path, output_path, experiment_name, exploration_list=None, plot_list=None, - class_label="Class", n_splits=5) - eda.run(run_parallel=False) - del eda - - dpr = ImputationRunner(output_path, experiment_name) - dpr.run(run_parallel=False) - del dpr - - f_imp = FeatureImportanceRunner(output_path, experiment_name, algorithms=algorithms) - f_imp.run(run_parallel=False) - del f_imp - - f_sel = FeatureSelectionRunner(output_path, experiment_name, algorithms=algorithms) - f_sel.run(run_parallel) - - del f_sel - - -@pytest.mark.parametrize( - ("model", ), - [ - (LogisticRegression(), ), - (NaiveBayesClassifier(), ), - ], -) -def test_valid_models(model): - - start = time.time() - - logging.warning("Running " + model.small_name + " Model Optimization") - - optuna.logging.set_verbosity(optuna.logging.WARNING) - for i in range(1): - model_job = ModelJob(output_path + '/' + experiment_name + '/demodata', output_path, experiment_name, i) - model_job.run(model) - # logging.warning("Best Params:" + str(model.params)) - model_job = ModelJob(output_path + '/' + experiment_name + '/hcc-data_example_no_covariates', - output_path, experiment_name, i) - model_job.run(model) - # logging.warning("Best Params:" + str(model.params)) - - logging.warning(model.small_name + " Optimization Step, " - "Time running" + "" + ": " + str(time.time() - start)) - - shutil.rmtree(output_path) diff --git a/streamline/tests/old/test_6model_runner.py b/streamline/tests/old/test_6model_runner.py deleted file mode 100644 index 0dd45ad1..00000000 --- a/streamline/tests/old/test_6model_runner.py +++ /dev/null @@ -1,84 +0,0 @@ -import multiprocessing -import os -import time -import optuna -import pytest -import logging -import multiprocessing -from streamline.runners.dataprocess_runner import DataProcessRunner -from streamline.runners.imputation_runner import ImputationRunner -from streamline.runners.feature_runner import FeatureImportanceRunner -from streamline.runners.feature_runner import FeatureSelectionRunner -from streamline.runners.model_runner import ModelExperimentRunner -from streamline.modeling.utils import SUPPORTED_MODELS_SMALL - -pytest.skip("Tested Already", allow_module_level=True) - -num_cores = int(os.environ.get('SLURM_CPUS_PER_TASK', multiprocessing.cpu_count())) - -algorithms, run_parallel, output_path = ["MI", "MS"], False, "./tests/" -dataset_path, experiment_name = "./DemoData/", "demo", - - -def test_setup(): - if not os.path.exists(output_path): - os.mkdir(output_path) - eda = DataProcessRunner(dataset_path, output_path, experiment_name, exploration_list=None, plot_list=None, - class_label="Class", n_splits=5) - eda.run(run_parallel=False) - del eda - - dpr = ImputationRunner(output_path, experiment_name) - dpr.run(run_parallel=False) - del dpr - - f_imp = FeatureImportanceRunner(output_path, experiment_name, algorithms=algorithms) - f_imp.run(run_parallel=False) - del f_imp - - f_sel = FeatureSelectionRunner(output_path, experiment_name, algorithms=algorithms) - f_sel.run(run_parallel=False) - - del f_sel - - -test_algorithms = list() -for algorithm in SUPPORTED_MODELS_SMALL[:2]: - test_algorithms.append(([algorithm, ],)) - - -@pytest.mark.parametrize( - ("algorithms", "run_parallel"), - [ - # (['NB'], False), - # (["LR"], False), - (["NB", "LR", "DT"], False), - (["NB", "LR", "DT"], True), - # (['CGB'], False), - # (['LGB'], False), - # (['XGB'], False), - # (['GP'], False), - # (['XCS'], True), - # (SUPPORTED_MODELS_SMALL, True), - ] - # + - # [([algo], True) for algo in SUPPORTED_MODELS_SMALL] -) -def test_valid_model_runner(algorithms, run_parallel): - start = time.time() - - logging.warning("Running Modelling Phase") - logging.warning("Using " + str(num_cores) + " CPUs") - optuna.logging.set_verbosity(optuna.logging.WARNING) - - runner = ModelExperimentRunner(output_path, experiment_name, algorithms, save_plots=True) - runner.run(run_parallel) - - if run_parallel: - how = "parallely" - else: - how = "serially" - logging.warning("Modelling Step with " + str(algorithms) + - ", Time running " + how + ": " + str(time.time() - start)) - - # shutil.rmtree(output_path) diff --git a/streamline/tests/old/test_7stats.py b/streamline/tests/old/test_7stats.py deleted file mode 100644 index 44fffed4..00000000 --- a/streamline/tests/old/test_7stats.py +++ /dev/null @@ -1,71 +0,0 @@ -import os -import time -import optuna -import pytest -import logging -from streamline.runners.dataprocess_runner import DataProcessRunner -from streamline.runners.imputation_runner import ImputationRunner -from streamline.runners.feature_runner import FeatureImportanceRunner -from streamline.runners.feature_runner import FeatureSelectionRunner -from streamline.runners.model_runner import ModelExperimentRunner -from streamline.runners.stats_runner import StatsRunner - -pytest.skip("Tested Already", allow_module_level=True) - -algorithms, run_parallel, output_path = ["MI", "MS"], False, "./tests/" -dataset_path, experiment_name = "./DemoData/", "demo", -model_algorithms = ["NB", "LR", "DT"] - - -def test_setup(): - start = time.time() - if not os.path.exists(output_path): - os.mkdir(output_path) - eda = DataProcessRunner(dataset_path, output_path, experiment_name, exploration_list=None, plot_list=None, - class_label="Class", n_splits=5) - eda.run(run_parallel=False) - del eda - - dpr = ImputationRunner(output_path, experiment_name) - dpr.run(run_parallel=False) - del dpr - - f_imp = FeatureImportanceRunner(output_path, experiment_name, algorithms=algorithms) - f_imp.run(run_parallel=False) - del f_imp - - f_sel = FeatureSelectionRunner(output_path, experiment_name, algorithms=algorithms) - f_sel.run(run_parallel=False) - - optuna.logging.set_verbosity(optuna.logging.WARNING) - - runner = ModelExperimentRunner(output_path, experiment_name, model_algorithms) - runner.run(run_parallel=True) - - del runner - - logging.warning("Ran Setup in " + str(time.time() - start)) - - -@pytest.mark.parametrize( - ("algorithms", "run_parallel"), - [ - (model_algorithms, False), - ] -) -def test_valid_stats(algorithms, run_parallel): - start = time.time() - - logging.warning("Running Stats Phase") - - stats = StatsRunner(output_path, experiment_name, algorithms) - stats.run(run_parallel=run_parallel) - - if run_parallel: - how = "parallely" - else: - how = "serially" - logging.warning("Statistics Step with " + str(algorithms) + - ", Time running " + how + ": " + str(time.time() - start)) - - # shutil.rmtree(output_path) diff --git a/streamline/tests/old/test_8dataset_compare.py b/streamline/tests/old/test_8dataset_compare.py deleted file mode 100644 index 101543b5..00000000 --- a/streamline/tests/old/test_8dataset_compare.py +++ /dev/null @@ -1,79 +0,0 @@ -import os -import time -import optuna -import pytest -import logging -from streamline.runners.dataprocess_runner import DataProcessRunner -from streamline.runners.imputation_runner import ImputationRunner -from streamline.runners.feature_runner import FeatureImportanceRunner -from streamline.runners.feature_runner import FeatureSelectionRunner -from streamline.runners.model_runner import ModelExperimentRunner -from streamline.runners.stats_runner import StatsRunner -from streamline.runners.compare_runner import CompareRunner - -pytest.skip("Tested Already", allow_module_level=True) - -algorithms, run_parallel, output_path = ["MI", "MS"], False, "./tests/" -dataset_path, experiment_name = "./DemoData/", "demo", -model_algorithms = ["NB", "LR", "DT"] - - -def test_setup(): - start = time.time() - if not os.path.exists(output_path): - os.mkdir(output_path) - eda = DataProcessRunner(dataset_path, output_path, experiment_name, exploration_list=None, plot_list=None, - class_label="Class", n_splits=5) - eda.run(run_parallel=False) - del eda - - dpr = ImputationRunner(output_path, experiment_name) - dpr.run(run_parallel=False) - del dpr - - f_imp = FeatureImportanceRunner(output_path, experiment_name, algorithms=algorithms) - f_imp.run(run_parallel=False) - del f_imp - - f_sel = FeatureSelectionRunner(output_path, experiment_name, algorithms=algorithms) - f_sel.run(run_parallel=False) - - del f_sel - - optuna.logging.set_verbosity(optuna.logging.WARNING) - - runner = ModelExperimentRunner(output_path, experiment_name, model_algorithms) - runner.run(run_parallel=True) - - del runner - - stats = StatsRunner(output_path, experiment_name, model_algorithms) - stats.run(run_parallel=run_parallel) - - del stats - - logging.warning("Ran Setup in " + str(time.time() - start)) - - -@pytest.mark.parametrize( - ("algorithms", "run_parallel"), - [ - (model_algorithms, False), - ] -) -def test_valid_datacomp(algorithms, run_parallel): - start = time.time() - - logging.warning("Running Compare Phase") - - compare = CompareRunner(output_path, experiment_name, algorithms=model_algorithms) - compare.run(run_parallel) - - if run_parallel: - how = "parallely" - else: - how = "serially" - logging.warning("Statistics Step with " + str(algorithms) + - ", Time running " + how + ": " + str(time.time() - start)) - - # shutil.rmtree(output_path) diff --git a/streamline/tests/old/test_9report.py b/streamline/tests/old/test_9report.py deleted file mode 100644 index 1b909313..00000000 --- a/streamline/tests/old/test_9report.py +++ /dev/null @@ -1,103 +0,0 @@ -import os -import time -import optuna -import pytest -import logging -from streamline.runners.dataprocess_runner import DataProcessRunner -from streamline.runners.imputation_runner import ImputationRunner -from streamline.runners.feature_runner import FeatureImportanceRunner -from streamline.runners.feature_runner import FeatureSelectionRunner -from streamline.runners.model_runner import ModelExperimentRunner -from streamline.runners.stats_runner import StatsRunner -from streamline.runners.compare_runner import CompareRunner -from streamline.runners.report_runner import ReportRunner - -pytest.skip("Tested Already", allow_module_level=True) - -algorithms, run_parallel, output_path = ["MI", "MS"], False, "./tests/" -dataset_path, experiment_name = "./DemoData/", "demo", -model_algorithms = ["NB", "LR", "DT"] - - -def test_setup(): - start = time.time() - if not os.path.exists(output_path): - os.mkdir(output_path) - eda = DataProcessRunner(dataset_path, output_path, experiment_name, - exploration_list=None, - plot_list=None, - class_label="Class", instance_label="InstanceID", n_splits=3, ignore_features=["Alcohol"], - categorical_features=['Gender', 'Alcohol', 'Hepatitis B Surface Antigen', - 'Hepatitis B e Antigen', - 'Hepatitis B Core Antibody', 'Hepatitis C Virus Antibody', - 'Cirrhosis', - 'Endemic Countries', 'Smoking', 'Diabetes', 'Obesity', - 'Hemochromatosis', - 'Arterial Hypertension', 'Chronic Renal Insufficiency', - 'Human Immunodeficiency Virus', 'Nonalcoholic Steatohepatitis', - 'Esophageal Varices', 'Splenomegaly', 'Portal Hypertension', - 'Portal Vein Thrombosis', 'Liver Metastasis', 'Radiological Hallmark', - 'catTest4', 'catTest10'] - ) - eda.run(run_parallel=run_parallel) - del eda - - dpr = ImputationRunner(output_path, experiment_name, - class_label="Class", instance_label="InstanceID") - dpr.run(run_parallel=run_parallel) - del dpr - - f_imp = FeatureImportanceRunner(output_path, experiment_name, - class_label="Class", instance_label="InstanceID", - algorithms=algorithms) - f_imp.run(run_parallel=run_parallel) - del f_imp - - f_sel = FeatureSelectionRunner(output_path, experiment_name, - class_label="Class", instance_label="InstanceID", - algorithms=algorithms) - f_sel.run(run_parallel=run_parallel) - del f_sel - - optuna.logging.set_verbosity(optuna.logging.WARNING) - - runner = ModelExperimentRunner(output_path, experiment_name, model_algorithms, - class_label="Class", instance_label="InstanceID") - runner.run(run_parallel=run_parallel) - del runner - - stats = StatsRunner(output_path, experiment_name, model_algorithms, - class_label="Class", instance_label="InstanceID") - stats.run(run_parallel=run_parallel) - del stats - - compare = CompareRunner(output_path, experiment_name, algorithms=model_algorithms, - class_label="Class", instance_label="InstanceID") - compare.run(run_parallel=run_parallel) - del compare - - logging.warning("Ran Setup in " + str(time.time() - start)) - - -@pytest.mark.parametrize( - ("algorithms", "run_parallel"), - [ - (model_algorithms, False), - ] -) -def test_valid_report(algorithms, run_parallel): - start = time.time() - - logging.warning("Running Report Phase") - - report = ReportRunner(output_path, experiment_name, algorithms=model_algorithms) - report.run(run_parallel=run_parallel) - - if run_parallel: - how = "parallely" - else: - how = "serially" - logging.warning("Statistics Step with " + str(algorithms) + - ", Time running " + how + ": " + str(time.time() - start)) - - # shutil.rmtree(output_path) diff --git a/streamline/tests/old/test_b1zreplication.py b/streamline/tests/old/test_b1zreplication.py deleted file mode 100644 index c585a060..00000000 --- a/streamline/tests/old/test_b1zreplication.py +++ /dev/null @@ -1,110 +0,0 @@ -import os -import time -import optuna -import pytest -import logging -from streamline.runners.dataprocess_runner import DataProcessRunner -from streamline.runners.imputation_runner import ImputationRunner -from streamline.runners.feature_runner import FeatureImportanceRunner -from streamline.runners.feature_runner import FeatureSelectionRunner -from streamline.runners.model_runner import ModelExperimentRunner -from streamline.runners.stats_runner import StatsRunner -from streamline.runners.compare_runner import CompareRunner -from streamline.runners.report_runner import ReportRunner -from streamline.runners.replicate_runner import ReplicationRunner - -pytest.skip("Tested Already", allow_module_level=True) - -algorithms, run_parallel, output_path = ["MI", "MS"], False, "./tests/" -dataset_path, experiment_name = "./DemoData/", "demo", -model_algorithms = ["NB", "LR", "DT"] - - -def test_setup(): - start = time.time() - if not os.path.exists(output_path): - os.mkdir(output_path) - eda = DataProcessRunner(dataset_path, output_path, experiment_name, - exploration_list=None, - plot_list=None, - class_label="Class", instance_label="InstanceID", n_splits=3, ignore_features=["Alcohol"], - categorical_features=['Gender', 'Alcohol', 'Hepatitis B Surface Antigen', - 'Hepatitis B e Antigen', - 'Hepatitis B Core Antibody', 'Hepatitis C Virus Antibody', - 'Cirrhosis', - 'Endemic Countries', 'Smoking', 'Diabetes', 'Obesity', - 'Hemochromatosis', - 'Arterial Hypertension', 'Chronic Renal Insufficiency', - 'Human Immunodeficiency Virus', 'Nonalcoholic Steatohepatitis', - 'Esophageal Varices', 'Splenomegaly', 'Portal Hypertension', - 'Portal Vein Thrombosis', 'Liver Metastasis', 'Radiological Hallmark', - 'catTest4', 'catTest10'] - ) - eda.run(run_parallel=run_parallel) - del eda - - dpr = ImputationRunner(output_path, experiment_name, - class_label="Class", instance_label="InstanceID") - dpr.run(run_parallel=run_parallel) - del dpr - - f_imp = FeatureImportanceRunner(output_path, experiment_name, - class_label="Class", instance_label="InstanceID", - algorithms=algorithms) - f_imp.run(run_parallel=run_parallel) - del f_imp - - f_sel = FeatureSelectionRunner(output_path, experiment_name, - class_label="Class", instance_label="InstanceID", - algorithms=algorithms) - f_sel.run(run_parallel=run_parallel) - del f_sel - - optuna.logging.set_verbosity(optuna.logging.WARNING) - - runner = ModelExperimentRunner(output_path, experiment_name, model_algorithms, - class_label="Class", instance_label="InstanceID") - runner.run(run_parallel=run_parallel) - del runner - - stats = StatsRunner(output_path, experiment_name, model_algorithms, - class_label="Class", instance_label="InstanceID") - stats.run(run_parallel=run_parallel) - del stats - - compare = CompareRunner(output_path, experiment_name, algorithms=model_algorithms, - class_label="Class", instance_label="InstanceID") - compare.run(run_parallel=run_parallel) - del compare - - report = ReportRunner(output_path, experiment_name, algorithms=model_algorithms) - report.run(run_parallel=run_parallel) - del report - - logging.warning("Ran Setup in " + str(time.time() - start)) - - -@pytest.mark.parametrize( - ("rep_data_path", "run_parallel"), - [ - ("./DemoRepData/", False), - ] -) -def test_valid_repl(rep_data_path, run_parallel): - start = time.time() - - logging.warning("Running Replication Phase") - - repl = ReplicationRunner('./DemoRepData', dataset_path + 'hcc-data_example_phase1_tester.csv', - output_path, experiment_name, - load_algo=True) - repl.run(run_parallel=run_parallel) - - if run_parallel: - how = "parallely" - else: - how = "serially" - logging.warning("Statistics Step with " + str(algorithms) + - ", Time running " + how + ": " + str(time.time() - start)) - - # shutil.rmtree(output_path) diff --git a/streamline/tests/old/test_zzchecker.py b/streamline/tests/old/test_zzchecker.py deleted file mode 100644 index a19de0d9..00000000 --- a/streamline/tests/old/test_zzchecker.py +++ /dev/null @@ -1,26 +0,0 @@ -import os -import pytest -from streamline.utils.checker import FN_LIST - -pytest.skip("Tested Already", allow_module_level=True) - -output_path, experiment_name = './tests', 'demo' -datasets = os.listdir(output_path + "/" + experiment_name) -remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle', 'jobsCompleted', - 'dask_logs', 'logs', 'jobs', - 'DatasetComparisons', 'UsefulNotebooks', - experiment_name + '_ML_Pipeline_Report.pdf'] -for text in remove_list: - if text in datasets: - datasets.remove(text) - - -@pytest.mark.parametrize( - ("fn", "left"), - [ - (FN_LIST[i], 0) for i in range(len(FN_LIST)) - ] -) -def test_checker(fn, left): - output = fn(output_path, experiment_name, datasets) - assert (len(output) == left) diff --git a/streamline/tests/old/test_zzclean.py b/streamline/tests/old/test_zzclean.py deleted file mode 100644 index 3c5f6827..00000000 --- a/streamline/tests/old/test_zzclean.py +++ /dev/null @@ -1,12 +0,0 @@ -import os -import pytest -import shutil -DEBUG = False - -pytest.skip("Tested Already", allow_module_level=True) - - -def test_stub(): - if not DEBUG: - if os.path.exists('/tests/'): - shutil.rmtree('./tests/') diff --git a/streamline/tests/subtests/__init__.py b/streamline/tests/subtests/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/streamline/tests/subtests/tabpfn_smoke.py b/streamline/tests/subtests/tabpfn_smoke.py new file mode 100644 index 00000000..d7bdd379 --- /dev/null +++ b/streamline/tests/subtests/tabpfn_smoke.py @@ -0,0 +1,108 @@ +from pathlib import Path + +import json +import os + +import numpy as np +import pandas as pd +import pytest +from sklearn.datasets import make_classification + +from streamline.p6_modeling.modeling import ModelingPhaseJob + + +def make_binary_cv_dataset(root: Path) -> Path: + dataset_dir = root / "out" / "TabPFNExp" / "ToyBinary" + cv_dir = dataset_dir / "CVDatasets" + cv_dir.mkdir(parents=True, exist_ok=True) + (dataset_dir / "models").mkdir(exist_ok=True) + (dataset_dir / "model_evaluation").mkdir(exist_ok=True) + (dataset_dir.parent / "jobsCompleted").mkdir(exist_ok=True) + + x_values, y_values = make_classification( + n_samples=72, + n_features=6, + n_informative=4, + n_redundant=0, + class_sep=1.2, + random_state=17, + ) + data = pd.DataFrame(x_values, columns=[f"f{i}" for i in range(x_values.shape[1])]) + data.insert(0, "Class", y_values) + + indices = np.arange(len(data)) + rng = np.random.default_rng(17) + rng.shuffle(indices) + train_indices = indices[:50] + test_indices = indices[50:] + + data.iloc[train_indices].to_csv(cv_dir / "ToyBinary_CV_0_Train.csv", index=False) + data.iloc[test_indices].to_csv(cv_dir / "ToyBinary_CV_0_Test.csv", index=False) + return dataset_dir + + +def test_phase6_skips_tabpfn_without_token_and_runs_other_models(tmp_path, monkeypatch): + monkeypatch.delenv("TABPFN_TOKEN", raising=False) + dataset_dir = make_binary_cv_dataset(tmp_path) + + with pytest.warns(RuntimeWarning, match="TABPFN_TOKEN is not set"): + ModelingPhaseJob( + dataset_dir=str(dataset_dir), + outcome_label="Class", + model_type="Binary", + n_splits=1, + models="TabPFN,NB", + output_path=str(tmp_path / "out"), + experiment_name="TabPFNExp", + scoring_metric="balanced_accuracy", + metric_direction="maximize", + n_trials=1, + timeout=20, + random_state=17, + ).run_all_model_cv_jobs() + + nb_metrics = dataset_dir / "model_evaluation" / "metrics_by_cv" / "NB_CV_0.json" + nb_pickle = dataset_dir / "models" / "pickledModels" / "NB_0.pickle" + tabpfn_pickle = dataset_dir / "models" / "pickledModels" / "TabPFN_0.pickle" + phase_flag = dataset_dir.parent / "jobsCompleted" / "job_modeling_ToyBinary.txt" + + assert nb_metrics.exists() + assert nb_pickle.exists() + assert not tabpfn_pickle.exists() + assert phase_flag.exists() + + with open(nb_metrics, "r") as metrics_file: + payload = json.load(metrics_file) + assert "balanced_accuracy" in payload["metrics"] + + +@pytest.mark.skipif( + not os.environ.get("TABPFN_TOKEN"), + reason="TABPFN_TOKEN is required for the optional TabPFN fit smoke test.", +) +def test_tabpfn_binary_wrapper_fit_with_token(): + pytest.importorskip("tabpfn") + from streamline.p6_modeling.models.binary_classification.tabpfn import TabPFNClassifier + + x_values, y_values = make_classification( + n_samples=48, + n_features=5, + n_informative=3, + n_redundant=0, + class_sep=1.0, + random_state=23, + ) + x_frame = pd.DataFrame(x_values, columns=[f"f{i}" for i in range(x_values.shape[1])]) + y_series = pd.Series(y_values) + + model = TabPFNClassifier( + cv_folds=2, + scoring_metric="balanced_accuracy", + metric_direction="maximize", + random_state=23, + n_ensemble_configurations=8, + ) + model.fit(x_frame, y_series, n_trails=1, timeout=60) + + predictions = model.predict(x_frame.head(5)) + assert len(predictions) == 5 diff --git a/streamline/tests/subtests/test_p10_replication.py b/streamline/tests/subtests/test_p10_replication.py new file mode 100644 index 00000000..9e851faf --- /dev/null +++ b/streamline/tests/subtests/test_p10_replication.py @@ -0,0 +1,467 @@ +from __future__ import annotations + +import json +import pickle +import sys +from pathlib import Path + +import numpy as np +import pandas as pd +import pytest + +from streamline.p10_replication import p10_cli +from streamline.p10_replication.p10_runner import P10Runner +from streamline.p10_replication.replication import ( + ReplicationJob, + _normalize_outcome_type, + _read_table, +) + +pytest.skip("Tested Already", allow_module_level=True) + +class DummyEnsembleModel: + """Simple pickle-safe binary classifier with deterministic probabilities.""" + + def __init__(self, positive_prob: float = 0.7): + self.positive_prob = float(positive_prob) + self.classes_ = np.array([0, 1]) + + def predict_proba(self, x): + n = len(x) + p1 = np.clip(np.full(n, self.positive_prob), 1e-6, 1.0 - 1e-6) + return np.column_stack([1.0 - p1, p1]) + + def predict(self, x): + return (self.predict_proba(x)[:, 1] >= 0.5).astype(int) + + +def _make_train_layout( + base: Path, + outcome_label: str = "Class", + instance_label: str = "InstanceID", + outcome_type: str = "Binary", + cv_indices: tuple[int, ...] = (0,), +) -> tuple[Path, Path, Path]: + """ + Build a minimal train dataset output tree required by ReplicationJob. + + Returns: + (experiment_root, train_root, dataset_for_rep_file) + """ + exp_root = base / "out" / "exp" + train_name = "train_data" + train_root = exp_root / train_name + cv_dir = train_root / "CVDatasets" + model_dir = train_root / "models" / "pickledModels" + cv_dir.mkdir(parents=True, exist_ok=True) + model_dir.mkdir(parents=True, exist_ok=True) + + # Training raw table used to recover column ordering. + dataset_for_rep = base / f"{train_name}.csv" + train_raw = pd.DataFrame( + { + outcome_label: [0, 1, 0, 1], + instance_label: [10, 11, 12, 13], + "f1": [0.1, 0.2, 0.3, 0.4], + "f2": [1.0, 2.0, 3.0, 4.0], + } + ) + train_raw.to_csv(dataset_for_rep, index=False) + + for cv_idx in cv_indices: + cv_df = train_raw.copy() + cv_df.to_csv(cv_dir / f"{train_name}_CV_{cv_idx}_Train.csv", index=False) + cv_df.to_csv(cv_dir / f"{train_name}_CV_{cv_idx}_Test.csv", index=False) + + # Minimal metadata + algorithm registry. + metadata = { + "Outcome Type": outcome_type, + "Outcome Label": outcome_label, + "Instance Label": instance_label, + "Primary Metric": "balanced_accuracy", + } + with (exp_root / "metadata.pickle").open("wb") as f: + pickle.dump(metadata, f) + + alg_info = { + "AlgA": [True, "A"], + "AlgB": [True, "B"], + } + with (exp_root / "algInfo.pickle").open("wb") as f: + pickle.dump(alg_info, f) + + return exp_root, train_root, dataset_for_rep + + +def _make_replication_job( + base: Path, + outcome_type: str = "Binary", + outcome_label: str = "Class", + instance_label: str | None = "InstanceID", + cv_partitions: int = 3, +) -> ReplicationJob: + _, train_root, dataset_for_rep = _make_train_layout( + base=base, + outcome_type=outcome_type, + outcome_label=outcome_label, + instance_label=instance_label or "InstanceID", + cv_indices=(0, 1, 2), + ) + + rep_file = base / "rep.csv" + pd.DataFrame( + { + outcome_label: [0, 1, 1, 0], + "InstanceID": [100, 101, 102, 103], + "f1": [0.5, 0.6, np.nan, 0.8], + "f2": [5.0, 6.0, 7.0, np.nan], + } + ).to_csv(rep_file, index=False) + + return ReplicationJob( + dataset_filename=str(rep_file), + dataset_for_rep=str(dataset_for_rep), + full_path=str(train_root), + outcome_label=outcome_label, + outcome_type=outcome_type, + instance_label=instance_label, + match_label=None, + cv_partitions=cv_partitions, + show_plots=False, + ) + + +def test_normalize_outcome_type_aliases(): + assert _normalize_outcome_type("binary") == "Binary" + assert _normalize_outcome_type("classification_multiclass") == "Multiclass" + assert _normalize_outcome_type("regression") == "Continuous" + assert _normalize_outcome_type("Binary") == "Binary" + + +def test_read_table_supports_csv_tsv_txt(tmp_path): + csv_path = tmp_path / "a.csv" + tsv_path = tmp_path / "b.tsv" + txt_path = tmp_path / "c.txt" + bad_path = tmp_path / "d.json" + + frame = pd.DataFrame({"x": [1, 2], "y": [3, 4]}) + frame.to_csv(csv_path, index=False) + frame.to_csv(tsv_path, index=False, sep="\t") + txt_path.write_text("x y\n1 3\n2 4\n", encoding="utf-8") + bad_path.write_text("{}", encoding="utf-8") + + assert _read_table(str(csv_path)).shape == (2, 2) + assert _read_table(str(tsv_path)).shape == (2, 2) + assert _read_table(str(txt_path)).shape == (2, 2) + with pytest.raises(ValueError): + _read_table(str(bad_path)) + + +def test_resolve_fold_map_requires_model_fold_parity(tmp_path): + _, train_root, dataset_for_rep = _make_train_layout(base=tmp_path, cv_indices=(0, 1, 2)) + rep_file = tmp_path / "rep.csv" + pd.DataFrame( + { + "Class": [0, 1, 0], + "InstanceID": [1, 2, 3], + "f1": [0.1, 0.2, 0.3], + "f2": [1.0, 2.0, 3.0], + } + ).to_csv(rep_file, index=False) + + # A has models for folds 0 and 1; B has models for folds 1 and 2. + # Strict parity should fail because each algorithm must cover all expected folds. + model_dir = train_root / "models" / "pickledModels" + for name in ("A_0.pickle", "A_1.pickle", "B_1.pickle", "B_2.pickle"): + with (model_dir / name).open("wb") as f: + pickle.dump({"ok": True}, f) + + job = ReplicationJob( + dataset_filename=str(rep_file), + dataset_for_rep=str(dataset_for_rep), + full_path=str(train_root), + outcome_label="Class", + outcome_type="Binary", + instance_label="InstanceID", + match_label=None, + cv_partitions=3, + ) + + with pytest.raises(Exception, match="Strict fold parity failed"): + job._resolve_fold_map() + + +def test_resolve_fold_map_returns_all_expected_folds_when_parity_met(tmp_path): + _, train_root, dataset_for_rep = _make_train_layout(base=tmp_path, cv_indices=(0, 1, 2)) + rep_file = tmp_path / "rep.csv" + pd.DataFrame( + { + "Class": [0, 1, 0], + "InstanceID": [1, 2, 3], + "f1": [0.1, 0.2, 0.3], + "f2": [1.0, 2.0, 3.0], + } + ).to_csv(rep_file, index=False) + + model_dir = train_root / "models" / "pickledModels" + for name in ("A_0.pickle", "A_1.pickle", "A_2.pickle", "B_0.pickle", "B_1.pickle", "B_2.pickle"): + with (model_dir / name).open("wb") as f: + pickle.dump({"ok": True}, f) + + job = ReplicationJob( + dataset_filename=str(rep_file), + dataset_for_rep=str(dataset_for_rep), + full_path=str(train_root), + outcome_label="Class", + outcome_type="Binary", + instance_label="InstanceID", + match_label=None, + cv_partitions=3, + ) + + assert job._resolve_fold_map() == [(0, 0), (1, 1), (2, 2)] + + +def test_auto_correct_labels_and_metric_for_regression(tmp_path): + _, train_root, dataset_for_rep = _make_train_layout( + base=tmp_path, + outcome_label="Target", + instance_label="RID", + outcome_type="Continuous", + cv_indices=(0,), + ) + rep_file = tmp_path / "rep.csv" + pd.DataFrame({"Target": [1.1, 2.2], "RID": [9, 10], "f1": [0.1, 0.2], "f2": [1, 2]}).to_csv( + rep_file, index=False + ) + + job = ReplicationJob( + dataset_filename=str(rep_file), + dataset_for_rep=str(dataset_for_rep), + full_path=str(train_root), + outcome_label="WrongLabel", + outcome_type="Continuous", + instance_label="WrongLabel", + match_label="missing_match", + scoring_metric="balanced_accuracy", + ) + job._auto_correct_labels_from_training_cv() + + assert job.outcome_label == "Target" + assert job.instance_label is None + assert job.match_label is None + assert job.scoring_metric == "explained_variance" + + +def test_write_base_outputs_regression_creates_residual_pickle(tmp_path): + job = _make_replication_job(tmp_path, outcome_type="Continuous", outcome_label="Target", instance_label=None) + job._prepare_dirs() + + y_true = np.array([1.0, 2.0, 3.0], dtype=float) + y_pred = np.array([1.5, 1.8, 3.2], dtype=float) + residual = y_true - y_pred + + job._write_base_outputs( + rep_cv_idx=0, + small_name="A", + metrics_dict={"Explained Variance": 0.9}, + curves_dict=None, + fi_list=[0.2, 0.3], + residual_test=residual, + y_pred=y_pred, + y_true=y_true, + ) + + metrics_path = job.model_metrics_dir / "A_CV_0.json" + residual_path = job.model_pickled_metrics_dir / "A_CV_0_residuals.pickle" + + assert metrics_path.exists() + assert residual_path.exists() + + with metrics_path.open("r") as f: + payload = json.load(f) + assert "metrics" in payload + assert "feature_importance" in payload + assert payload["feature_importance"] == [0.2, 0.3] + + with residual_path.open("rb") as f: + residual_payload = pickle.load(f) + assert len(residual_payload) == 6 + assert np.allclose(residual_payload[1], residual) + assert np.allclose(residual_payload[3], y_pred) + assert np.allclose(residual_payload[5], y_true) + + +def test_evaluate_ensembles_writes_all_ensemble_algorithms(tmp_path): + job = _make_replication_job(tmp_path, outcome_type="Binary") + job._prepare_dirs() + + rep_test = pd.DataFrame( + { + "Class": [0, 1, 0, 1], + "InstanceID": [1, 2, 3, 4], + "f1": [0.2, 0.3, 0.4, 0.5], + "f2": [1.0, 1.1, 1.2, 1.3], + } + ) + rep_test.to_csv(job.cv_dir / f"{job.apply_name}_CV_0_Test.csv", index=False) + + src_pickled = job.train_root / "ensemble_evaluation" / "pickled_ensembles" + src_pickled.mkdir(parents=True, exist_ok=True) + with (src_pickled / "HEV_0.pickle").open("wb") as f: + pickle.dump(DummyEnsembleModel(0.8), f) + with (src_pickled / "SEV_0.pickle").open("wb") as f: + pickle.dump(DummyEnsembleModel(0.6), f) + + job._evaluate_ensembles(rep_test, fold_map=[(0, 0)]) + + metric_files = sorted(job.ensemble_metrics_dir.glob("*_CV_0.json")) + roc_files = sorted(job.ensemble_curves_dir.glob("*_CV_0_roc.json")) + prc_files = sorted(job.ensemble_curves_dir.glob("*_CV_0_prc.json")) + + assert [f.name for f in metric_files] == ["HEV_CV_0.json", "SEV_CV_0.json"] + assert [f.name for f in roc_files] == ["HEV_CV_0_roc.json", "SEV_CV_0_roc.json"] + assert [f.name for f in prc_files] == ["HEV_CV_0_prc.json", "SEV_CV_0_prc.json"] + + +def test_evaluate_ensembles_requires_fold_parity(tmp_path): + job = _make_replication_job(tmp_path, outcome_type="Binary") + job._prepare_dirs() + + src_pickled = job.train_root / "ensemble_evaluation" / "pickled_ensembles" + src_pickled.mkdir(parents=True, exist_ok=True) + with (src_pickled / "HEV_0.pickle").open("wb") as f: + pickle.dump(DummyEnsembleModel(0.8), f) + with (src_pickled / "HEV_1.pickle").open("wb") as f: + pickle.dump(DummyEnsembleModel(0.8), f) + with (src_pickled / "SEV_0.pickle").open("wb") as f: + pickle.dump(DummyEnsembleModel(0.6), f) + # SEV_1 is intentionally missing for strict parity failure. + + with pytest.raises(Exception, match="Strict fold parity failed"): + job._evaluate_ensembles(pd.DataFrame(), fold_map=[(0, 0), (1, 1)]) + + +def test_p10_runner_serial_runs_for_supported_extensions(tmp_path, monkeypatch): + rep_dir = tmp_path / "rep_data" + rep_dir.mkdir(parents=True, exist_ok=True) + (rep_dir / "a.csv").write_text("Class,f1\n0,1\n", encoding="utf-8") + (rep_dir / "b.tsv").write_text("Class\tf1\n1\t2\n", encoding="utf-8") + (rep_dir / "ignore.md").write_text("x", encoding="utf-8") + + output_path = tmp_path / "out" + exp_root = output_path / "exp" + train_file = tmp_path / "train_data.csv" + train_file.write_text("Class,InstanceID,f1\n0,1,2\n", encoding="utf-8") + + (exp_root / "train_data").mkdir(parents=True, exist_ok=True) + with (exp_root / "metadata.pickle").open("wb") as f: + pickle.dump( + { + "Outcome Type": "Binary", + "Outcome Label": "Class", + "Instance Label": "InstanceID", + "CV Partitions": 3, + "Use Data Scaling": True, + "Use Data Imputation": True, + "Use Multivariate Imputation": False, + }, + f, + ) + + calls: list[tuple[str, str]] = [] + + class StubReplicationJob: + def __init__(self, **kwargs): + self.dataset_filename = kwargs["dataset_filename"] + calls.append(("init", Path(self.dataset_filename).name)) + + def run(self): + calls.append(("run", Path(self.dataset_filename).name)) + + monkeypatch.setattr("streamline.p10_replication.p10_runner.ReplicationJob", StubReplicationJob) + + runner = P10Runner( + rep_data_path=str(rep_dir), + dataset_for_rep=str(train_file), + output_path=str(output_path), + experiment_name="exp", + run_cluster="Serial", + ) + runner.run() + + assert ("run", "a.csv") in calls + assert ("run", "b.tsv") in calls + assert all(name != "ignore.md" for _, name in calls) + + +def test_p10_runner_raises_when_no_supported_datasets(tmp_path): + rep_dir = tmp_path / "rep_data" + rep_dir.mkdir(parents=True, exist_ok=True) + (rep_dir / "notes.md").write_text("ignore", encoding="utf-8") + + output_path = tmp_path / "out" + exp_root = output_path / "exp" + train_file = tmp_path / "train_data.csv" + train_file.write_text("Class,InstanceID,f1\n0,1,2\n", encoding="utf-8") + + (exp_root / "train_data").mkdir(parents=True, exist_ok=True) + with (exp_root / "metadata.pickle").open("wb") as f: + pickle.dump( + {"Outcome Type": "Binary", "Outcome Label": "Class", "Instance Label": "InstanceID"}, + f, + ) + + runner = P10Runner( + rep_data_path=str(rep_dir), + dataset_for_rep=str(train_file), + output_path=str(output_path), + experiment_name="exp", + run_cluster="Serial", + ) + + with pytest.raises(Exception, match="There must be at least one"): + runner.run() + + +def test_p10_cli_parses_args_and_invokes_runner(monkeypatch, tmp_path): + rep_dir = tmp_path / "rep" + rep_dir.mkdir(parents=True, exist_ok=True) + train_file = tmp_path / "train.csv" + train_file.write_text("Class,InstanceID,f1\n0,1,2\n", encoding="utf-8") + + captured: dict[str, object] = {} + + class StubRunner: + def __init__(self, **kwargs): + captured.update(kwargs) + + def run(self): + captured["ran"] = True + + monkeypatch.setattr(p10_cli, "P10Runner", StubRunner) + monkeypatch.setattr( + sys, + "argv", + [ + "p10_cli.py", + "--rep_data_path", + str(rep_dir), + "--dataset_for_rep", + str(train_file), + "--output_path", + str(tmp_path / "out"), + "--experiment_name", + "exp", + "--exclude_plots", + "plot_ROC,plot_PRC", + "--show_plots", + "1", + ], + ) + + p10_cli.main() + + assert captured["exclude_plots"] == ["plot_ROC", "plot_PRC"] + assert captured["show_plots"] is True + assert captured["ran"] is True diff --git a/streamline/tests/subtests/test_p11.py b/streamline/tests/subtests/test_p11.py new file mode 100644 index 00000000..88ba76d8 --- /dev/null +++ b/streamline/tests/subtests/test_p11.py @@ -0,0 +1,237 @@ +import json +import pickle +from pathlib import Path + +import numpy as np +import pandas as pd +import pytest +from sklearn.datasets import make_classification + +pytest.skip("Tested Already", allow_module_level=True) + +from streamline.p6_modeling.p6_runner import P6Runner +from streamline.p7_ensembles.p7_runner import P7Runner +from streamline.p8_summary_statistics.p8_runner import P8Runner +from streamline.p9_compare_datasets.p9_runner import P9Runner +from streamline.p11_reporting.p11_runner import P11Runner + + +def _make_synthetic_cv_dataset(root: Path, n_splits: int = 3, n_samples: int = 120, random_state: int = 0): + """ + Same helper shape as in test_p6_p7_p8_integration.py: + creates //CVDatasets with CV Train/Test CSVs and metadata.pickle. + """ + from sklearn.datasets import make_classification + + rng = np.random.RandomState(random_state) + X, y = make_classification( + n_samples=n_samples, + n_features=5, + n_informative=3, + n_redundant=0, + n_repeated=0, + n_clusters_per_class=1, + class_sep=1.2, + flip_y=0.03, + random_state=random_state, + ) + + idx = np.arange(n_samples) + rng.shuffle(idx) + X = X[idx] + y = y[idx] + + dataset_name = "toy_dataset" + ds_dir = root / dataset_name + cv_dir = ds_dir / "CVDatasets" + cv_dir.mkdir(parents=True, exist_ok=True) + + # simple CV: contiguous chunks + fold_sizes = np.full(n_splits, n_samples // n_splits, dtype=int) + fold_sizes[: n_samples % n_splits] += 1 + current = 0 + + for cv_idx, fold_size in enumerate(fold_sizes): + start, stop = current, current + fold_size + current = stop + + test_mask = np.zeros(n_samples, dtype=bool) + test_mask[start:stop] = True + train_mask = ~test_mask + + X_train, y_train = X[train_mask], y[train_mask] + X_test, y_test = X[test_mask], y[test_mask] + + n_train = X_train.shape[0] + n_test = X_test.shape[0] + + cols = ["InstanceID", "Class"] + [f"f{i}" for i in range(X.shape[1])] + + train_df = pd.DataFrame( + np.column_stack( + [np.arange(n_train), y_train, X_train] + ), + columns=cols, + ) + test_df = pd.DataFrame( + np.column_stack( + [np.arange(n_test), y_test, X_test] + ), + columns=cols, + ) + + train_path = cv_dir / f"{dataset_name}_CV_{cv_idx}_Train.csv" + test_path = cv_dir / f"{dataset_name}_CV_{cv_idx}_Test.csv" + train_df.to_csv(train_path, index=False) + test_df.to_csv(test_path, index=False) + + meta = { + "Outcome Type": "Binary", + "Outcome Label": "Class", + "Instance Label": "InstanceID", + } + with open(root / "metadata.pickle", "wb") as f: + pickle.dump(meta, f) + + return dataset_name + + +@pytest.mark.integration +def test_p11_reporting_end_to_end(): + """ + End-to-end smoke test for reporting phase: + + 1. Create synthetic CV datasets. + 2. Run Phase 6 modeling (a few models). + 3. Run Phase 7 ensembles. + 4. Run Phase 8 statistics. + 5. Run Phase 9 dataset comparisons. + 6. Run Phase 10 reporting. + 7. Check that HTML + PDF reports exist and are non-empty. + """ + tmp_path = Path('./test') + # --- basic layout --- + output_path = tmp_path / "out" + experiment_name = "exp_reporting" + exp_root = output_path / experiment_name + exp_root.mkdir(parents=True, exist_ok=True) + + # synthetic dataset + dataset_name = _make_synthetic_cv_dataset( + exp_root, n_splits=3, n_samples=90, random_state=42 + ) + ds_dir = exp_root / dataset_name + + # --- Phase 6: modeling --- + p6 = P6Runner( + output_path=str(output_path), + experiment_name=experiment_name, + outcome_label="Class", + model_type="Binary", + instance_label="InstanceID", + n_splits=3, + models="NB,LR,DT", + calibrate=False, + scoring_metric="balanced_accuracy", + metric_direction="maximize", + n_trials=2, + timeout=15, + training_subsample=0, + uniform_fi=False, + save_plot=False, + random_state=42, + run_cluster="Serial", + ) + p6.run() + + # sanity: base models exist + models_dir = ds_dir / "models" / "pickledModels" + assert models_dir.is_dir() + assert list(models_dir.glob("*.pickle")) + + # --- Phase 7: ensembles --- + p7 = P7Runner( + output_path=str(output_path), + experiment_name=experiment_name, + n_splits=3, + outcome_label="Class", + instance_label="InstanceID", + ensembles="hard_voting,soft_voting,stack_lr", + base_models="NB,LR,DT", + meta_train_source="train", + calibrate=0, + calibrate_method="sigmoid", + calibrate_cv=3, + random_state=42, + run_cluster="Serial", + ) + p7.run() + + ens_root = ds_dir / "ensemble_evaluation" + assert ens_root.is_dir() + assert list((ens_root / "metrics_by_cv").glob("*.json")) + + # --- Phase 8: statistics --- + from streamline.p8_summary_statistics.p8_runner import P8Runner + + p8 = P8Runner( + output_path=str(output_path), + experiment_name=experiment_name, + outcome_label="Class", + outcome_type="Binary", + instance_label="InstanceID", + n_splits=3, + scoring_metric="balanced_accuracy", + top_features=10, + sig_cutoff=0.1, + metric_weight="balanced_accuracy", + scale_data=True, + exclude_plots="plot_FI_box", + show_plots=False, + run_cluster="Serial", + ) + p8.run() + + model_eval_dir = ds_dir / "model_evaluation" + assert (model_eval_dir / "Summary_performance_mean.csv").is_file() + + # --- Phase 9: dataset comparisons --- + from streamline.p9_compare_datasets.p9_runner import P9Runner + + p9 = P9Runner( + output_path=str(output_path), + experiment_name=experiment_name, + outcome_label="Class", + outcome_type="Binary", + instance_label="InstanceID", + sig_cutoff=0.1, + show_plots=False, + run_cluster="Serial", + ) + p9.run() + + dc_root = exp_root / "DatasetComparisons" + assert dc_root.is_dir() + assert list(dc_root.glob("KruskalWallis_*.csv")) + + # --- Phase 10: reporting --- + from streamline.p11_reporting.p11_runner import P11Runner + + p10 = P11Runner( + output_path=str(output_path), + experiment_name=experiment_name, + run_cluster="Serial", + ) + p10.run() + + reports_dir = exp_root / "reporting" + html_report = reports_dir / "report.html" + pdf_report = reports_dir / f"{experiment_name}_STREAMLINE_Report.pdf" + + assert reports_dir.is_dir(), "Reporting phase should create a reports/ directory" + assert html_report.is_file(), "Expected HTML report from reporting phase" + assert pdf_report.is_file(), "Expected PDF report from reporting phase" + + # basic non-empty checks + assert html_report.stat().st_size > 0 + assert pdf_report.stat().st_size > 0 diff --git a/streamline/tests/subtests/test_p11_replication_mode.py b/streamline/tests/subtests/test_p11_replication_mode.py new file mode 100644 index 00000000..2e7ff677 --- /dev/null +++ b/streamline/tests/subtests/test_p11_replication_mode.py @@ -0,0 +1,105 @@ +from __future__ import annotations + +import json +import pickle +import pytest +from pathlib import Path + +from streamline.p11_reporting.p11_runner import P11Runner +from streamline.p11_reporting.reporting import ReportPhaseJob + + +pytest.skip("Tested Already", allow_module_level=True) + +def _mk_dataset_root(path: Path) -> None: + (path / "exploratory").mkdir(parents=True, exist_ok=True) + (path / "model_evaluation").mkdir(parents=True, exist_ok=True) + + +def test_reportphasejob_replication_mode_discovers_replication_dirs(tmp_path: Path): + exp_root = tmp_path / "exp" + exp_root.mkdir(parents=True, exist_ok=True) + + with (exp_root / "metadata.pickle").open("wb") as f: + pickle.dump({"Outcome Label": "Class", "Outcome Type": "Binary"}, f) + + train_a = exp_root / "train_a" + train_b = exp_root / "train_b" + _mk_dataset_root(train_a) + _mk_dataset_root(train_b) + + rep_a = train_a / "replication" / "rep_a" + rep_b = train_b / "replication" / "rep_b" + _mk_dataset_root(rep_a) + _mk_dataset_root(rep_b) + + job = ReportPhaseJob( + experiment_path=str(exp_root), + report_mode="replication", + make_pdf=False, + enable_plots=False, + ) + discovered = job._list_datasets() + + assert [p.name for p in discovered] == ["rep_a", "rep_b"] + assert all("replication" in str(p) for p in discovered) + + +def test_reportphasejob_replication_mode_writes_replication_report_data(tmp_path: Path): + exp_root = tmp_path / "exp" + exp_root.mkdir(parents=True, exist_ok=True) + + with (exp_root / "metadata.pickle").open("wb") as f: + pickle.dump({"Outcome Label": "Class", "Outcome Type": "Binary"}, f) + + train_ds = exp_root / "train_data" + _mk_dataset_root(train_ds) + rep_ds = train_ds / "replication" / "rep_data" + _mk_dataset_root(rep_ds) + + job = ReportPhaseJob( + experiment_path=str(exp_root), + report_mode="replication", + make_pdf=False, + enable_plots=False, + ) + job.run() + + report_json = exp_root / "reporting_replication" / "report_data.json" + assert report_json.is_file() + + payload = json.loads(report_json.read_text()) + assert payload["report_mode"] == "replication" + assert payload["title"] == "STREAMLINE Replication Data Evaluation Report" + assert len(payload["datasets"]) == 1 + assert "replication" in payload["datasets"][0]["dataset_path"] + assert payload["dataset_comparisons"]["present"] is False + + +def test_p11_runner_passes_replication_mode_to_report_job(monkeypatch, tmp_path: Path): + exp_root = tmp_path / "exp" + exp_root.mkdir(parents=True, exist_ok=True) + + captured: dict[str, object] = {} + + class StubReportPhaseJob: + def __init__(self, **kwargs): + captured.update(kwargs) + + def run(self): + captured["ran"] = True + + monkeypatch.setattr("streamline.p11_reporting.p11_runner.ReportPhaseJob", StubReportPhaseJob) + + runner = P11Runner( + experiment_path=str(exp_root), + report_mode="replication", + make_pdf=False, + enable_plots=False, + run_cluster="Serial", + ) + runner.run() + + assert captured["report_mode"] == "replication" + assert captured["ran"] is True + diff --git a/streamline/tests/subtests/test_p1_data_process.py b/streamline/tests/subtests/test_p1_data_process.py new file mode 100644 index 00000000..53feffa1 --- /dev/null +++ b/streamline/tests/subtests/test_p1_data_process.py @@ -0,0 +1,73 @@ +import os +import time +import pytest +import logging + +from streamline.p1_data_process.p1_runner import P1Runner + +pytest.skip("Tested Already", allow_module_level=True) + +output_path = "./tests/" +dataset_path, experiment_name = "./data/UCIBinaryClassification/", "demo" + +# NEW: choose execution mode +# False -> serial +# "Local" -> local Dask parallel +# "BashSLURM"/"BashLSF" -> submit bash jobs +# "" -> use get_cluster(...) for remote cluster +run_cluster = "Local" + + +def test_classification(): + start = time.time() + if not os.path.exists(output_path): + os.mkdir(output_path) + + eda = P1Runner( + dataset_path, + output_path, + experiment_name, + exclude_eda_output=['correlation'], + outcome_label="Class", + instance_label="InstanceID", + n_splits=3, + ignore_features=None, + categorical_features="./data/UCIFeatureTypes/hcc_survival_categorical_features.csv", + quantitative_features="./data/UCIFeatureTypes/hcc_survival_quantitative_features.csv", + correlation_removal_threshold=1, + run_cluster=run_cluster, # NEW + force=1, + ) + eda.run() + del eda + + logging.warning("Ran Pipeline in " + str(time.time() - start)) + + # dpr = ImputationRunner( + # output_path, experiment_name, + # outcome_label="Class", + # instance_label="InstanceID", + # run_cluster=run_cluster, # NEW + # ) + # dpr.run() + # del dpr + + # f_imp = FeatureImportanceRunner( + # output_path, experiment_name, + # outcome_label="Class", + # instance_label="InstanceID", + # algorithms=algorithms, + # run_cluster=run_cluster, # NEW + # ) + # f_imp.run() + # del f_imp + + # f_sel = FeatureSelectionRunner( + # output_path, experiment_name, + # outcome_label="Class", + # instance_label="InstanceID", + # algorithms=algorithms, + # run_cluster=run_cluster, # NEW + # ) + # f_sel.run() + # del f_sel diff --git a/streamline/tests/subtests/test_p2_impute.py b/streamline/tests/subtests/test_p2_impute.py new file mode 100644 index 00000000..b45c8647 --- /dev/null +++ b/streamline/tests/subtests/test_p2_impute.py @@ -0,0 +1,145 @@ +# tests/phases/p2_impute_scale/test_runner_after_p1.py +import os +import json +import pytest +import pickle +from pathlib import Path + +import pandas as pd + +from streamline.p2_impute_scale.p2_runner import P2Runner + +pytest.skip("Tested Already", allow_module_level=True) + + +def _seed_phase1_outputs(tmp_path: Path, exp_name: str = "demo", ds_name: str = "Toy"): + """ + Create a minimal Phase-1-like experiment structure with: + - metadata.pickle + - exploratory/{DataCounts.csv, categorical_features.pickle} + - CVDatasets/{Toy_CV_1_Train.csv, Toy_CV_1_Test.csv} + - jobsCompleted/, jobs/, logs/ dirs + """ + exp_root = tmp_path / exp_name + ds_dir = exp_root / ds_name + cvd = ds_dir / "CVDatasets" + expl = ds_dir / "exploratory" + + # Make dirs + (exp_root / "jobsCompleted").mkdir(parents=True, exist_ok=True) + (exp_root / "jobs").mkdir(exist_ok=True) + (exp_root / "logs").mkdir(exist_ok=True) + ds_dir.mkdir(parents=True, exist_ok=True) + cvd.mkdir(parents=True, exist_ok=True) + expl.mkdir(parents=True, exist_ok=True) + + # Phase-1 metadata (values used by P2Runner as defaults) + meta = { + "Outcome Label": "Class", + "Instance Label": None, + "Random Seed": 7, + "Use Data Scaling": True, + "Use Data Imputation": True, + "Use Multivariate Imputation": False, + # Optional: store a default imputer choice (runner will honor if P2 not overridden) + "P2 Imputer Id": "median_map", + "P2 Imputer Params": json.dumps({}), + } + with open(exp_root / "metadata.pickle", "wb") as f: + pickle.dump(meta, f) + + # Exploratory artifacts + # 5th row ("Missing") Count is used in P2 to decide whether to impute + pd.DataFrame( + {"Type": ["A", "B", "C", "D", "Missing"], "Count": [0, 0, 0, 0, 3]} + ).to_csv(expl / "DataCounts.csv", index=False) + with open(expl / "categorical_features.pickle", "wb") as f: + pickle.dump(["cat1"], f) + + # One CV pair with some missing data + train = pd.DataFrame( + { + "Class": [0, 1, 0, 1], + "cat1": ["x", None, "x", None], + "num1": [1.0, None, 3.0, 4.0], + "num2": [None, 2.0, 5.0, 6.0], + } + ) + test = pd.DataFrame( + { + "Class": [1, 0], + "cat1": [None, None], + "num1": [None, 10.0], + "num2": [7.0, None], + } + ) + + tr = cvd / f"{ds_name}_CV_1_Train.csv" + te = cvd / f"{ds_name}_CV_1_Test.csv" + train.to_csv(tr, index=False) + test.to_csv(te, index=False) + + return exp_root, ds_dir, tr, te + + +def test_p2_runner_after_p1_serial(): + """ + Given a Phase-1-like experiment folder, running P2Runner in serial should: + - impute categorical (mode) + numeric (via metadata’s imputer or defaults) + - scale numeric (when metadata says True) + - write pickles (categorical/ordinal/scaler) + - rewrite CV Train/Test CSVs + - write jobsCompleted marker + - append run_params.pickle + """ + tmp_path = Path("tests") + exp_root, ds_dir, tr, te = _seed_phase1_outputs(tmp_path) + + r = P2Runner( + output_path=str(tmp_path), + experiment_name=exp_root.name, + run_cluster=False, # serial path + overwrite_cv=False + # leave Phase-2 flags as None so they’re sourced from metadata.pickle + ) + r.run() + + # CV files should be rewritten and contain no missing values + train = pd.read_csv(tr) + test = pd.read_csv(te) + assert train.isna().sum().sum() == 0 + assert test.isna().sum().sum() == 0 + + # Categorical imputation should have filled cat1 + assert train["cat1"].isna().sum() == 0 + assert test["cat1"].isna().sum() == 0 + + # Numeric columns should be imputed; and scaled when Use Data Scaling=True + for col in ["num1", "num2"]: + assert train[col].isna().sum() == 0 + assert test[col].isna().sum() == 0 + # mean ~ 0 after StandardScaler (tolerance due to small sample) + assert abs(train[col].mean()) < 1e-3 + + # Check artifacts + scale_dir = ds_dir / "impute_scale" + assert (scale_dir / "categorical_imputer_cv1.pickle").exists() + assert (scale_dir / "ordinal_imputer_cv1.pickle").exists() + assert (scale_dir / "scaler_cv1.pickle").exists() + + # jobsCompleted marker exists + jc = (exp_root / "jobsCompleted" / f"job_preprocessing_{ds_dir.name}_1.txt") + assert jc.exists() + + # run_params.pickle appended + rp = exp_root / "run_params.pickle" + assert rp.exists() + with open(rp, "rb") as f: + runs = pickle.load(f) + assert isinstance(runs, dict) and runs + # ensure last run stored Phase 2 fields + latest = sorted(runs.keys())[-1] + assert runs[latest]["phase"] == "p2_impute_scale" + assert runs[latest]["scale_data"] is True + assert runs[latest]["impute_data"] is True + diff --git a/streamline/tests/subtests/test_p2_impute_loader.py b/streamline/tests/subtests/test_p2_impute_loader.py new file mode 100644 index 00000000..396162a1 --- /dev/null +++ b/streamline/tests/subtests/test_p2_impute_loader.py @@ -0,0 +1,23 @@ +import types +import pytest +from streamline.p2_impute_scale.utils.impute_loader import list_imputers, load_imputer + +pytest.skip("Tested Already", allow_module_level=True) + +def test_list_imputers_has_core_ids(): + imps = list_imputers() + print(imps) + # Expect at least the built-ins (adjust if your repo changes) + for expected in ("simple", "median_map", "knn", "iterative"): + assert expected in imps, f"Missing imputer id: {expected}" + cls = imps[expected] + assert isinstance(cls, type) + assert hasattr(cls, "fit") and hasattr(cls, "transform") and hasattr(cls, "get_params") + +def test_load_imputer_instantiates(): + imp = load_imputer("simple", strategy="median") + print(imp) + assert hasattr(imp, "fit") + assert hasattr(imp, "transform") + assert hasattr(imp, "get_params") + diff --git a/streamline/tests/subtests/test_p2_scale.py b/streamline/tests/subtests/test_p2_scale.py new file mode 100644 index 00000000..faa6560b --- /dev/null +++ b/streamline/tests/subtests/test_p2_scale.py @@ -0,0 +1,235 @@ +# tests/phases/p2_impute_scale/test_scaler_minmax.py +import os +import json +import pytest +import pickle +from pathlib import Path + +import numpy as np +import pandas as pd + +from streamline.p2_impute_scale.p2_runner import ImputeAndScale + +# tmp_path = Path("tests") +pytest.skip("Tested Already", allow_module_level=True) + + + +def _seed_exp_no_missing(tmp_path: Path, dataset_name: str = "demo_data"): + """ + Minimal Phase-1-like layout with NO missing values, + so we can isolate scaling behavior (impute_data=False in the job). + """ + exp = tmp_path / "demo" + ds = exp / dataset_name + cvd = ds / "CVDatasets" + expl = ds / "exploratory" + (exp / "jobsCompleted").mkdir(parents=True, exist_ok=True) + for p in (ds, cvd, expl): + p.mkdir(parents=True, exist_ok=True) + + # DataCounts says zero missing (so imputation is skipped if caller sets impute_data=True accidentally) + pd.DataFrame( + {"Type": ["A", "B", "C", "D", "Missing"], "Count": [0, 0, 0, 0, 0]} + ).to_csv(expl / "DataCounts.csv", index=False) + + # One categorical column + with open(expl / "categorical_features.pickle", "wb") as f: + pickle.dump(["cat1"], f) + + # Train numeric ranges deliberately chosen (include negatives) + # - num1 ranges [-2, 8] in train + # - num2 is constant = 5 in train (edge case) + train = pd.DataFrame( + { + "Class": [0, 1, 0, 1], + "cat1": ["a", "b", "a", "b"], + "num1": [-2.0, 0.0, 3.0, 8.0], + "num2": [5.0, 5.0, 5.0, 5.0], # constant + } + ) + # Test includes values outside train min/max to ensure extrapolation + test = pd.DataFrame( + { + "Class": [1, 0], + "cat1": ["a", "b"], + "num1": [10.0, -4.0], # outside [-2, 8] + "num2": [5.0, 5.0], # constant column remains constant → scaled constant + } + ) + + tr = cvd / f"{dataset_name}_CV_1_Train.csv" + te = cvd / f"{dataset_name}_CV_1_Test.csv" + train.to_csv(tr, index=False) + test.to_csv(te, index=False) + return exp, ds, tr, te + + +def _read_csv(path: Path) -> pd.DataFrame: + return pd.read_csv(path) + + +def _minmax_transform(x, xmin, xmax, a=0.0, b=1.0): + # MinMax formula; if xmax == xmin, sklearn sets result to 0 (or 'a' after range mapping). + x = np.asarray(x, dtype=float) + if xmax == xmin: + return np.full_like(x, a, dtype=float) + return (x - xmin) / (xmax - xmin) * (b - a) + a + + +def test_minmax_default_range_formula_exact(): + """ + Verify exact MinMax scaling math on TRAIN (range [-2,8] for num1), + categorical untouched, and EXTRAPOLATION on TEST (values outside map <0 or >1). + """ + tmp_path = Path("tests") + exp, ds, tr, te = _seed_exp_no_missing(tmp_path) + + job = ImputeAndScale( + cv_train_path=str(tr), + cv_test_path=str(te), + experiment_path=str(exp), + scale_data=True, + impute_data=False, # isolate scaling + multi_impute=False, + overwrite_cv=True, + outcome_label="Class", + instance_label=None, + random_state=0, + scaler_id="minmax", + scaler_params={"feature_range": (0, 1)}, + ) + job.run() + + train = _read_csv(tr) + test = _read_csv(te) + + # Categorical remains unchanged + assert set(train["cat1"].unique()) == {"a", "b"} + assert set(test["cat1"].unique()) == {"a", "b"} + + # TRAIN: exact mapping into [0,1] + # num1 train min = -2, max = 8 + tr_raw = np.array([-2.0, 0.0, 3.0, 8.0], dtype=float) + tr_scaled_expected = _minmax_transform(tr_raw, xmin=-2.0, xmax=8.0, a=0.0, b=1.0) + # Compare against rows aligned by original order + np.testing.assert_allclose(train.loc[:, "num1"].to_numpy(), tr_scaled_expected, rtol=0, atol=1e-12) + + # num2 is constant; sklearn MinMax → zeros in default [0,1] + assert np.allclose(train["num2"].to_numpy(), 0.0, atol=0) + + # TEST: extrapolation for out-of-range values + # test num1 values: [10, -4] → expected > 1 and < 0 respectively + te_raw = np.array([10.0, -4.0], dtype=float) + te_scaled_expected = _minmax_transform(te_raw, xmin=-2.0, xmax=8.0, a=0.0, b=1.0) + np.testing.assert_allclose(test["num1"].to_numpy(), te_scaled_expected, rtol=0, atol=1e-12) + assert test["num1"].iloc[0] > 1.0 and test["num1"].iloc[1] < 0.0 + + # num2 constant in test as well → zeros + assert np.allclose(test["num2"].to_numpy(), 0.0, atol=0) + + # Check saved scaler artifact (registry path → dict with id/params) + pkl = ds / "impute_scale" / "scaler_cv1.pickle" + with open(pkl, "rb") as f: + obj = pickle.load(f) + assert isinstance(obj, dict) and obj.get("id") == "minmax" + assert obj.get("params", {}).get("feature_range") == (0, 1) + + +def test_minmax_custom_range_and_rounding(): + """ + Use a custom feature_range=(2,3). + - TRAIN num1 maps exactly to [2,3]. + - Constant column maps to 'a' (=2) for all rows. + - Output rounding to 7 decimals (from job) shouldn’t distort exact expectations. + """ + tmp_path = Path("tests") + exp, ds, tr, te = _seed_exp_no_missing(tmp_path) + + job = ImputeAndScale( + cv_train_path=str(tr), + cv_test_path=str(te), + experiment_path=str(exp), + scale_data=True, + impute_data=False, + multi_impute=False, + overwrite_cv=True, + outcome_label="Class", + instance_label=None, + random_state=0, + scaler_id="minmax", + scaler_params={"feature_range": (2.0, 3.0)}, + ) + job.run() + + train = _read_csv(tr) + test = _read_csv(te) + + # TRAIN exact [2,3] for num1 + tr_raw = np.array([-2.0, 0.0, 3.0, 8.0], dtype=float) + tr_exp = _minmax_transform(tr_raw, xmin=-2.0, xmax=8.0, a=2.0, b=3.0) + np.testing.assert_allclose(train["num1"].to_numpy(), tr_exp, rtol=0, atol=1e-7) + + # Constant column → 'a' == 2.0 + assert np.allclose(train["num2"].to_numpy(), 2.0, atol=0) + + # TEST extrapolation also uses the same mapping + te_raw = np.array([10.0, -4.0], dtype=float) + te_exp = _minmax_transform(te_raw, xmin=-2.0, xmax=8.0, a=2.0, b=3.0) + np.testing.assert_allclose(test["num1"].to_numpy(), te_exp, rtol=0, atol=1e-7) + + # Artifact contains chosen range + with open(ds / "impute_scale" / "scaler_cv1.pickle", "rb") as f: + obj = pickle.load(f) + assert obj.get("params", {}).get("feature_range") == (2.0, 3.0) + + +def test_minmax_idempotent_transform_calls(): + """ + Ensure that applying transform twice (without re-fit) doesn’t drift: + Our pipeline fits once on TRAIN, then transforms TRAIN/TEST. + Here we simulate a second transform pass and confirm invariance. + """ + tmp_path = Path("tests") + exp, ds, tr, te = _seed_exp_no_missing(tmp_path) + + # First run + job = ImputeAndScale( + cv_train_path=str(tr), + cv_test_path=str(te), + experiment_path=str(exp), + scale_data=True, + impute_data=False, + multi_impute=False, + overwrite_cv=True, + outcome_label="Class", + instance_label=None, + random_state=0, + scaler_id="minmax", + scaler_params={"feature_range": (0.0, 1.0)}, + ) + job.run() + train_1 = _read_csv(tr).copy() + test_1 = _read_csv(te).copy() + + # Second run (re-fit on TRAIN again; outputs should be identical) + job2 = ImputeAndScale( + cv_train_path=str(tr), + cv_test_path=str(te), + experiment_path=str(exp), + scale_data=True, + impute_data=False, + multi_impute=False, + overwrite_cv=True, + outcome_label="Class", + instance_label=None, + random_state=0, + scaler_id="minmax", + scaler_params={"feature_range": (0.0, 1.0)}, + ) + job2.run() + train_2 = _read_csv(tr) + test_2 = _read_csv(te) + + pd.testing.assert_frame_equal(train_1, train_2, check_exact=True) + pd.testing.assert_frame_equal(test_1, test_2, check_exact=True) diff --git a/streamline/tests/subtests/test_p3_pca.py b/streamline/tests/subtests/test_p3_pca.py new file mode 100644 index 00000000..29800452 --- /dev/null +++ b/streamline/tests/subtests/test_p3_pca.py @@ -0,0 +1,47 @@ +import os, pickle, json +from pathlib import Path +import pandas as pd +import logging +import pytest +from streamline.p3_feature_learning.feature_learn import FeatureLearn + +pytest.skip("Tested Already", allow_module_level=True) + +def _seed(tmp_path: Path, ds="hcc_demo"): + exp = tmp_path / "exp"; ds_dir = exp / ds + cvd = ds_dir / "CVDatasets"; expl = ds_dir / "exploratory" + (exp / "jobsCompleted").mkdir(parents=True, exist_ok=True) + for p in (ds_dir, cvd, expl): p.mkdir(parents=True, exist_ok=True) + # metadata with Outcome Label + with open(exp / "metadata.pickle", "wb") as f: pickle.dump({"Outcome Label":"Class"}, f) + # simple numeric data (no missing) + tr = cvd / f"{ds}_CV_1_Train.csv"; te = cvd / f"{ds}_CV_1_Test.csv" + pd.DataFrame({"Class":[0,1,0,1], "x1":[1,2,3,4], "x2":[4,3,2,1]}).to_csv(tr, index=False) + pd.DataFrame({"Class":[1,0], "x1":[10, 0], "x2":[0, 10]}).to_csv(te, index=False) + return exp, ds_dir, tr, te + +def test_p3_pca_writes_outputs(tmp_path): + tmp_path = Path("tests") + exp, ds_dir, tr, te = _seed(tmp_path) + FeatureLearn( + cv_train_path=str(tr), + cv_test_path=str(te), + experiment_path=str(exp), + learner_id="pca", + learner_params={"n_components": 2, "svd_solver":"auto"}, + feature_namespace="FL_PCA", + keep_original_features=True, + overwrite_cv=True, + outcome_label="Class", + random_state=0, + ).run() + + train = pd.read_csv(tr); test = pd.read_csv(te) + # original + 2 engineered features + assert "FL_PCA_PC1" in train.columns and "FL_PCA_PC2" in train.columns + assert "FL_PCA_PC1" in test.columns and "FL_PCA_PC2" in test.columns + + base = ds_dir / "feature_learning" + assert (base / "learner_cv1.pickle").exists() + assert (base / "features_cv1.txt").exists() + assert (base / "feature_manifest_cv1.json").exists() diff --git a/streamline/tests/subtests/test_p4_input_normalization.py b/streamline/tests/subtests/test_p4_input_normalization.py new file mode 100644 index 00000000..e3638df9 --- /dev/null +++ b/streamline/tests/subtests/test_p4_input_normalization.py @@ -0,0 +1,52 @@ +import numpy as np +import pandas as pd + +from streamline.p4_feature_importance.registry.mutualinformation import MutualInformation +from streamline.p4_feature_importance.utils.input_normalization import ( + normalize_feature_matrix, + normalize_target_vector, +) + + +def test_p4_normalize_feature_matrix_handles_nullable_pandas_dtypes(): + X = pd.DataFrame( + { + "float_ext": pd.Series([1.5, pd.NA, 3.5], dtype="Float64"), + "int_ext": pd.Series([1, 2, pd.NA], dtype="Int64"), + "bool_ext": pd.Series([True, False, pd.NA], dtype="boolean"), + } + ) + + X_numeric, X_array = normalize_feature_matrix(X) + + assert list(X_numeric.columns) == ["float_ext", "int_ext", "bool_ext"] + assert X_array.dtype == np.float64 + assert X_array.shape == (3, 3) + assert np.isnan(X_array[1, 0]) + assert np.isnan(X_array[2, 1]) + assert np.isnan(X_array[2, 2]) + + +def test_p4_normalize_target_vector_factorizes_non_numeric_labels(): + y = pd.Series(["A", "B", "A", "C"], dtype="string") + + y_array = normalize_target_vector(y) + + assert y_array.dtype == np.int64 + assert y_array.tolist() == [0, 1, 0, 2] + + +def test_mutual_information_accepts_nullable_numeric_pandas_inputs(): + X = pd.DataFrame( + { + "signal": pd.Series([0, 0, 1, 1, 0, 1], dtype="Int64"), + "noise": pd.Series([3, 1, 4, 1, 5, 9], dtype="Int64"), + } + ) + y = pd.Series([0, 0, 1, 1, 0, 1], dtype="Int64") + + model = MutualInformation(outcome_type="Binary", n_neighbors=3, random_state=0).fit(X, y) + scores = model.get_scores() + + assert set(scores) == {"signal", "noise"} + assert all(np.isfinite(v) for v in scores.values()) diff --git a/streamline/tests/subtests/test_p4_instance_subset.py b/streamline/tests/subtests/test_p4_instance_subset.py new file mode 100644 index 00000000..861e5013 --- /dev/null +++ b/streamline/tests/subtests/test_p4_instance_subset.py @@ -0,0 +1,110 @@ +from __future__ import annotations + +from pathlib import Path + +import pandas as pd + +import streamline.p4_feature_importance.importance as importance_module +from streamline.p4_feature_importance.importance import FeatureImportance +from streamline.p4_feature_importance.p4_runner import P4Runner + + +class RecordingImportanceModel: + path_name = "recording" + model_name = "Recording" + small_name = "REC" + + def __init__(self, *, uses_instance_subset: bool): + self.uses_instance_subset = uses_instance_subset + self.fit_rows = None + self.fit_index = None + self.columns = [] + + def fit(self, X, y): + self.fit_rows = len(X) + self.fit_index = list(X.index) + self.columns = list(X.columns) + return self + + def get_scores(self): + return {column: float(index) for index, column in enumerate(self.columns)} + + def get_params(self): + return {"uses_instance_subset": self.uses_instance_subset} + + +def make_cv_dataset(tmp_path: Path) -> tuple[Path, Path, Path]: + exp = tmp_path / "out" / "Exp" + ds = exp / "Toy" + cv = ds / "CVDatasets" + cv.mkdir(parents=True) + train = pd.DataFrame( + { + "Class": [0, 1] * 5, + "x1": range(10), + "x2": range(10, 20), + } + ) + test = pd.DataFrame({"Class": [0, 1], "x1": [100, 101], "x2": [200, 201]}) + train_path = cv / "Toy_CV_0_Train.csv" + test_path = cv / "Toy_CV_0_Test.csv" + train.to_csv(train_path, index=False) + test.to_csv(test_path, index=False) + return exp, train_path, test_path + + +def test_p4_runner_does_not_subset_by_default(tmp_path: Path): + exp = tmp_path / "out" / "Exp" + exp.mkdir(parents=True) + + runner = P4Runner(output_path=str(tmp_path / "out"), experiment_name="Exp") + + assert runner.instance_subset is None + + +def test_p4_instance_subset_only_samples_subset_aware_models(monkeypatch, tmp_path: Path): + exp, train_path, test_path = make_cv_dataset(tmp_path) + models: list[RecordingImportanceModel] = [] + + def fake_load_importance(model_id, **params): + model = RecordingImportanceModel(uses_instance_subset=True) + models.append(model) + return model + + monkeypatch.setattr(importance_module, "load_importance", fake_load_importance) + + FeatureImportance( + cv_train_path=str(train_path), + cv_test_path=str(test_path), + experiment_path=str(exp), + model_id="recording", + outcome_label="Class", + random_state=1, + instance_subset=3, + ).run() + + assert models[0].fit_rows == 3 + + +def test_p4_instance_subset_does_not_sample_other_models(monkeypatch, tmp_path: Path): + exp, train_path, test_path = make_cv_dataset(tmp_path) + models: list[RecordingImportanceModel] = [] + + def fake_load_importance(model_id, **params): + model = RecordingImportanceModel(uses_instance_subset=False) + models.append(model) + return model + + monkeypatch.setattr(importance_module, "load_importance", fake_load_importance) + + FeatureImportance( + cv_train_path=str(train_path), + cv_test_path=str(test_path), + experiment_path=str(exp), + model_id="recording", + outcome_label="Class", + random_state=1, + instance_subset=3, + ).run() + + assert models[0].fit_rows == 10 diff --git a/streamline/tests/subtests/test_p4_mi.py b/streamline/tests/subtests/test_p4_mi.py new file mode 100644 index 00000000..9f0bcf69 --- /dev/null +++ b/streamline/tests/subtests/test_p4_mi.py @@ -0,0 +1,51 @@ +import os, pickle +from pathlib import Path +import pandas as pd +import pytest + +from streamline.p4_feature_importance.importance import FeatureImportance + +pytest.skip("Tested Already", allow_module_level=True) + +def _seed(tmp: Path, ds="Toy"): + exp = tmp / "exp"; ds_dir = exp / ds + cvd = ds_dir / "CVDatasets" + (exp / "jobsCompleted").mkdir(parents=True, exist_ok=True) + for p in (ds_dir, cvd): p.mkdir(parents=True, exist_ok=True) + tr = cvd / f"{ds}_CV_1_Train.csv"; te = cvd / f"{ds}_CV_1_Test.csv" + # Simple signal in x1; x2 is noise + pd.DataFrame({"Class":[0,0,1,1,1,0,1,0], + "x1":[0,0,1,1,1,0,1,0], + "x2":[1,2,3,4,5,6,7,8]}).to_csv(tr, index=False) + pd.DataFrame({"Class":[1,0], "x1":[1,0], "x2":[9,10]}).to_csv(te, index=False) + with open(exp/"metadata.pickle", "wb") as f: pickle.dump({"Outcome Label":"Class","Outcome Type":"Binary"}, f) + return exp, ds_dir, tr, te + +def test_p4_mutual_info(): + tmp_path = Path("tests") + exp, ds_dir, tr, te = _seed(tmp_path) + FeatureImportance( + cv_train_path=str(tr), + cv_test_path=str(te), + experiment_path=str(exp), + model_id="mutualinformation", + model_params={"outcome_type":"Binary", "n_neighbors":3}, + top_k=1, + threshold=None, + keep_original_features=False, + overwrite_cv=True, + outcome_label="Class", + outcome_type="Binary", + random_state=0, + ).run() + + train = pd.read_csv(tr) + test = pd.read_csv(te) + # only one selected feature; should favor x1 + assert list(train.columns) == ["Class","x1"] + assert list(test.columns) == ["Class","x1"] + + base = ds_dir / "feature_importance" + assert (base / "scores_cv1.csv").exists() + assert (base / "importance_cv1.pickle").exists() + assert (base / "selected_features_cv1.txt").exists() diff --git a/streamline/tests/subtests/test_p4_rebate_082.py b/streamline/tests/subtests/test_p4_rebate_082.py new file mode 100644 index 00000000..5aa254b5 --- /dev/null +++ b/streamline/tests/subtests/test_p4_rebate_082.py @@ -0,0 +1,230 @@ +import pickle +import sys +import types + +import numpy as np +import pandas as pd + +from streamline.p4_feature_importance.importance import FeatureImportance +import streamline.p4_feature_importance.p4_runner as p4_runner_module +from streamline.p4_feature_importance.p4_runner import P4Runner +from streamline.p4_feature_importance.registry.multisurf import MultiSURF +from streamline.p4_feature_importance.registry.multisurfstar import MultiSURFStar +from streamline.p4_feature_importance.registry.multiswrfdb import MultiSWRFDB +from streamline.p5_feature_selection.registry.default import DefaultFeatureSelector + + +def install_fake_skrebate(monkeypatch): + module = types.ModuleType("skrebate") + module.created = [] + module.fit_arrays = [] + module.turf_created = [] + + class FakeRebate: + def __init__(self, **kwargs): + self.kwargs = kwargs + self.rank_absolute = kwargs.get("rank_absolute", False) + module.created.append((self.__class__.__name__, kwargs)) + + def fit(self, X, y): + module.fit_arrays.append(np.array(X, copy=True)) + self.feature_importances_ = np.arange(X.shape[1], dtype=float) + self.top_features_ = np.argsort(self.feature_importances_)[::-1] + return self + + class MultiSURF(FakeRebate): + pass + + class MultiSURFstar(FakeRebate): + pass + + class MultiSWRFDB(FakeRebate): + pass + + class MultiSWRFDBstar(FakeRebate): + pass + + class TURF: + def __init__(self, relief_object, pct=0.5, num_scores_to_return=100): + self.relief_object = relief_object + self.pct = pct + self.num_scores_to_return = num_scores_to_return + module.turf_created.append( + { + "relief_class": relief_object.__class__.__name__, + "pct": pct, + "num_scores_to_return": num_scores_to_return, + } + ) + + def fit(self, X, y): + self.relief_object.fit(X, y) + self.feature_importances_ = np.arange(X.shape[1], dtype=float) + 10.0 + self.top_features_ = np.argsort(self.feature_importances_)[::-1] + return self + + module.MultiSURF = MultiSURF + module.MultiSURFstar = MultiSURFstar + module.MultiSWRFDB = MultiSWRFDB + module.MultiSWRFDBstar = MultiSWRFDBstar + module.TURF = TURF + monkeypatch.setitem(sys.modules, "skrebate", module) + return module + + +def write_cv_fixture(tmp_path): + exp_root = tmp_path / "Experiment" + dataset_dir = exp_root / "Dataset" + cv_dir = dataset_dir / "CVDatasets" + exploratory_dir = dataset_dir / "exploratory" + cv_dir.mkdir(parents=True) + exploratory_dir.mkdir(parents=True) + + train = pd.DataFrame( + { + "Class": [0, 1, 0, 1], + "InstanceID": ["i1", "i2", "i3", "i4"], + "quant": [0.1, 0.2, 0.3, 0.4], + "cat_a": ["low", "high", "low", "medium"], + "cat_b": [1, 2, 1, 3], + "other": [4.0, 5.0, 6.0, 7.0], + } + ) + test = train.copy() + train_path = cv_dir / "Dataset_CV_0_Train.csv" + test_path = cv_dir / "Dataset_CV_0_Test.csv" + train.to_csv(train_path, index=False) + test.to_csv(test_path, index=False) + with open(exploratory_dir / "categorical_features.pickle", "wb") as f: + pickle.dump(["cat_a", "cat_b"], f) + return exp_root, train_path, test_path + + +def test_rebate_receives_streamline_categorical_feature_indexes(monkeypatch, tmp_path): + fake_skrebate = install_fake_skrebate(monkeypatch) + exp_root, train_path, test_path = write_cv_fixture(tmp_path) + + FeatureImportance( + cv_train_path=str(train_path), + cv_test_path=str(test_path), + experiment_path=str(exp_root), + model_id="multiswrfdb", + model_params={"categorical_features": [0], "n_jobs": 2}, + outcome_type="Binary", + instance_label="InstanceID", + random_state=3, + ).run() + + created_name, kwargs = fake_skrebate.created[-1] + assert created_name == "MultiSWRFDB" + assert kwargs["categorical_features"] == [1, 2] + assert kwargs["label_type"] == "binary" + assert kwargs["n_jobs"] == 2 + assert np.isfinite(fake_skrebate.fit_arrays[-1][:, 1]).all() + + score_path = exp_root / "Dataset" / "feature_importance" / "multiswrfdb" / "multiswrfdb_scores_cv_0.csv" + assert score_path.exists() + with open(exp_root / "Dataset" / "feature_importance" / "multiswrfdb" / "selector_cv0.pickle", "rb") as f: + payload = pickle.load(f) + assert payload["categorical_features"] == ["cat_a", "cat_b"] + assert payload["categorical_feature_indices"] == [1, 2] + assert (exp_root / "Dataset" / "runtime" / "runtime_feature_importance_multiswrfdb_cv0.txt").exists() + + +def test_rebate_turf_uses_full_feature_count_by_default(monkeypatch, tmp_path): + fake_skrebate = install_fake_skrebate(monkeypatch) + exp_root, train_path, test_path = write_cv_fixture(tmp_path) + + FeatureImportance( + cv_train_path=str(train_path), + cv_test_path=str(test_path), + experiment_path=str(exp_root), + model_id="MultiSWRFDB*", + model_params={"use_turf": True, "turf_pct": 0.25}, + outcome_type="Binary", + instance_label="InstanceID", + ).run() + + assert fake_skrebate.turf_created[-1] == { + "relief_class": "MultiSWRFDBstar", + "pct": 0.25, + "num_scores_to_return": 4, + } + assert ( + exp_root / "Dataset" / "feature_importance" / "multiswrfdbstar" / "multiswrfdbstar_scores_cv_0.csv" + ).exists() + + +def test_rebate_wrappers_accept_string_categorical_indexes(): + model = MultiSWRFDB(categorical_features=["1", "bad"]) + model.columns = ["quant", "cat"] + X = pd.DataFrame({"quant": [1.0, 2.0], "cat": ["a", "b"]}) + + X_array = model.normalize_rebate_matrix(X) + + assert X_array.shape == (2, 2) + assert np.isfinite(X_array[:, 1]).all() + + +def test_multisurf_wrappers_do_not_pass_neighbor_param_to_skrebate(): + assert "n_neighbors" not in MultiSURF(n_neighbors=7).build_rebate_params(3) + assert "n_neighbors" not in MultiSURFStar(n_neighbors=7).build_rebate_params(3) + + +def test_p4_runner_applies_rebate_n_jobs_defaults_for_active_models(tmp_path): + output_path = tmp_path / "out" + exp_root = output_path / "DemoExp" + exp_root.mkdir(parents=True) + + runner = P4Runner( + output_path=str(output_path), + experiment_name="DemoExp", + models="mutualinformation,multiswrfdb,multiswrfdbstar", + ) + + assert runner.models_params["multiswrfdb"]["n_jobs"] == 1 + assert runner.models_params["multiswrfdbstar"]["n_jobs"] == 1 + assert "mutualinformation" not in runner.models_params + + +def test_p4_runner_defaults_to_all_registered_importance_models(monkeypatch, tmp_path): + output_path = tmp_path / "out" + exp_root = output_path / "DemoExp" + exp_root.mkdir(parents=True) + + monkeypatch.setattr( + p4_runner_module, + "list_importances", + lambda: {"z_model": object, "a_model": object}, + ) + monkeypatch.setattr(p4_runner_module, "resolve_importance_id", lambda model_id: model_id) + + runner = P4Runner(output_path=str(output_path), experiment_name="DemoExp") + + assert runner.models == ["a_model", "z_model"] + + +def test_default_feature_selector_can_cap_more_than_two_algorithms(): + selector = DefaultFeatureSelector(export_scores=False) + selected = { + "mutualinformation": [["a"]], + "multiswrfdb": [["b"]], + "multiswrfdbstar": [["c"]], + } + ranks = { + "mutualinformation": [["a", "b", "c"]], + "multiswrfdb": [["b", "c", "a"]], + "multiswrfdbstar": [["c", "a", "b"]], + } + + cv_selected, informative, uninformative = selector._select_union_cap( + selected, + 3, + ranks, + ["mutualinformation", "multiswrfdb", "multiswrfdbstar"], + 1, + ) + + assert cv_selected == [["a", "b", "c"]] + assert informative == [3] + assert uninformative == [0] diff --git a/streamline/tests/subtests/test_p5_fs_mi_ms.py b/streamline/tests/subtests/test_p5_fs_mi_ms.py new file mode 100644 index 00000000..c97289fc --- /dev/null +++ b/streamline/tests/subtests/test_p5_fs_mi_ms.py @@ -0,0 +1,152 @@ +import os +import io +import json +import glob +import csv +import time +import shutil +import pathlib +import builtins + +import pytest + +from streamline.p5_feature_selection.p5_runner import P5Runner + +pytest.skip("Tested Already", allow_module_level=True) + +def _make_csv(path, rows): + os.makedirs(os.path.dirname(path), exist_ok=True) + with open(path, "w", newline="") as f: + writer = csv.writer(f) + writer.writerows(rows) + + +def _seed_experiment(tmp_path, n_splits=2, algs=("mutualinformation", "multisurf")): + """ + Create a minimal experiment tree: + + out/Exp/D1/ + CVDatasets/D1_CV_{i}_{Train,Test}.csv + feature_importance//_scores_cv_{i}.csv + """ + out = tmp_path / "out" + exp = out / "Exp" + d1 = exp / "D1" + (d1 / "CVDatasets").mkdir(parents=True) + # minimal train/test with features + for i in range(n_splits): + _make_csv( + d1 / "CVDatasets" / f"D1_CV_{i}_Train.csv", + [ + ["Class", "f1", "f2", "noise0"], + [1, 10, 0.1, 7], + [0, 5, 0.2, 9], + ], + ) + _make_csv( + d1 / "CVDatasets" / f"D1_CV_{i}_Test.csv", + [ + ["Class", "f1", "f2", "noise0"], + [0, 8, 0.05, 3], + ], + ) + + # phase-4 score CSVs + for alg in algs: + for i in range(n_splits): + _make_csv( + d1 / "feature_importance" / alg / f"{alg}_scores_cv_{i}.csv", + [ + ["feature", "score"], + ["f1", 0.9], + ["f2", 0.4], + ["noise0", 0.0], # should be filtered by > 0 rule + ], + ) + + # folders needed by runner in some modes + (exp / "jobs").mkdir(parents=True, exist_ok=True) + (exp / "logs").mkdir(parents=True, exist_ok=True) + return out, exp, d1 + + +def test_p5_runner_auto_serial_creates_outputs(tmp_path): + out, exp, d1 = _seed_experiment(tmp_path, n_splits=2) + + runner = P5Runner( + output_path=str(out), + experiment_name="Exp", + algorithms="auto", # <- discover from feature_importance/* + n_splits=2, + outcome_label="Class", + instance_label=None, + max_features_to_keep=5, + filter_poor_features=True, + overwrite_cv=False, # exercise rename path + selector_id="default", + selector_params=None, + export_scores=True, + top_features=5, + show_plots=False, + run_cluster="Serial", + ) + runner.run() + + # 1) InformativeFeatureSummary.csv + fs_summary = d1 / "feature_selection" / "InformativeFeatureSummary.csv" + assert fs_summary.exists(), "Phase 5 summary CSV not created" + + # 2) Plots per algorithm + for alg in ("mutualinformation", "multisurf"): + plot = d1 / "feature_importance" / alg / "TopAverageScores.png" + assert plot.exists(), f"Missing TopAverageScores.png for {alg}" + + # 3) Filtered CV CSVs should exist with only class + informative features (f1, f2) + for i in range(2): + tr = d1 / "CVDatasets" / f"D1_CV_{i}_Train.csv" + te = d1 / "CVDatasets" / f"D1_CV_{i}_Test.csv" + assert tr.exists() and te.exists() + # When overwrite_cv=False, originals are renamed to *_CVPre_* + pre_tr = d1 / "CVDatasets" / f"D1_CVPre_{i}_Train.csv" + pre_te = d1 / "CVDatasets" / f"D1_CVPre_{i}_Test.csv" + assert pre_tr.exists() and pre_te.exists() + + import pandas as pd + df_tr = pd.read_csv(tr) + df_te = pd.read_csv(te) + for df in (df_tr, df_te): + cols = list(df.columns) + assert cols[0] == "Class" + # noise0 should be removed because score==0 + assert "f1" in cols and "f2" in cols and "noise0" not in cols + + +@pytest.mark.skipif( + pytest.importorskip("dask") is None or pytest.importorskip("dask.distributed") is None, + reason="dask.distributed not available", +) +def test_p5_runner_auto_local_parallel(tmp_path): + out, exp, d1 = _seed_experiment(tmp_path, n_splits=2) + + runner = P5Runner( + output_path=str(out), + experiment_name="Exp", + algorithms="auto", + n_splits=2, + run_cluster="Local", # <- parallel via LocalCluster + outcome_label="Class", + max_features_to_keep=5, + filter_poor_features=True, + overwrite_cv=True, # exercise overwrite branch this time + selector_id="default", + export_scores=False, # no plots this time + ) + runner.run() + + # overwrite_cv=True means no *_CVPre_* files; final CVs exist + for i in range(2): + tr = d1 / "CVDatasets" / f"D1_CV_{i}_Train.csv" + te = d1 / "CVDatasets" / f"D1_CV_{i}_Test.csv" + assert tr.exists() and te.exists() + assert not (d1 / "CVDatasets" / f"D1_CVPre_{i}_Train.csv").exists() + assert not (d1 / "CVDatasets" / f"D1_CVPre_{i}_Test.csv").exists() diff --git a/streamline/tests/subtests/test_p5_loader.py b/streamline/tests/subtests/test_p5_loader.py new file mode 100644 index 00000000..c9a9af2e --- /dev/null +++ b/streamline/tests/subtests/test_p5_loader.py @@ -0,0 +1,23 @@ +import types +import pytest +from streamline.p3_feature_learning.utils.fl_loader import list_learners, load_learner + +pytest.skip("Tested Already", allow_module_level=True) + +def test_list_learner_has_core_ids(): + imps = list_learners() + # Expect at least the built-ins (adjust if your repo changes) + for expected in ("pca",): + assert expected in imps, f"Missing imputer id: {expected}" + cls = imps[expected] + assert isinstance(cls, type) + assert hasattr(cls, "fit") and hasattr(cls, "transform") and hasattr(cls, "get_params") and hasattr(cls, "get_feature_names") + +def test_load_learner_instantiates(): + lr = load_learner(learner_id="pca") + print(lr) + assert hasattr(lr, "fit") + assert hasattr(lr, "transform") + assert hasattr(lr, "get_feature_names") + assert hasattr(lr, "get_params") + diff --git a/streamline/tests/subtests/test_p6_model_loader.py b/streamline/tests/subtests/test_p6_model_loader.py new file mode 100644 index 00000000..7caae47f --- /dev/null +++ b/streamline/tests/subtests/test_p6_model_loader.py @@ -0,0 +1,78 @@ +import pytest + +from streamline.p6_modeling.utils.loader import ( + load_model_classes, + get_model_by_id, +) + +pytest.skip("Tested Already", allow_module_level=True) + +# --------------------------- +# load_model_classes() +# --------------------------- + +@pytest.mark.parametrize("model_type", [ + "Binary", + "Multiclass", + "Regression", +]) +def test_load_model_classes_returns_classes_and_shape(model_type): + classes = load_model_classes(model_type) + # It’s okay if some folders are empty; just assert a list is returned + assert isinstance(classes, list) + for cls in classes: + # Each class must expose the expected attrs the loader requires + for attr in ("small_name", "model_name", "model_type", "model_evaluation"): + assert hasattr(cls, attr), f"{cls} missing attribute '{attr}'" + # model_type on the class should match the requested type + assert getattr(cls, "model_type") == model_type + + +def test_load_model_classes_invalid_type(): + with pytest.raises(ValueError): + load_model_classes("TotallyNotAType") + + +# --------------------------- +# get_model_by_id() +# --------------------------- + +@pytest.mark.parametrize( + "model_type, candidates", + [ + # Try common binary models we’ve discussed; skip if they don't exist locally + ("Binary", ["LR", "NB", "SVM",]), + # Add your own multiclass/regression aliases if you have them + # ("Multiclass", []), + # ("Regression", []), + ], +) +def test_get_model_by_id_resolves_aliases_case_insensitive(model_type, candidates): + """ + For each candidate id, try to resolve a model class. + If a given id isn’t present in the repo, we SKIP that id gracefully. + """ + for mid in candidates: + try: + cls = get_model_by_id(model_type, mid) + except ValueError: + pytest.skip(f"Model id '{mid}' not found for type '{model_type}' in this checkout.") + continue + + # Basic shape checks on the resolved class + assert hasattr(cls, "small_name") + assert hasattr(cls, "model_name") + assert hasattr(cls, "model_type") + assert cls.model_type == model_type + + # Check alias logic: the id should match small_name or underscored model_name (case-insensitive) + aliases = { + cls.small_name.lower(), + cls.model_name.lower().replace(" ", "_"), + } + assert mid.lower() in aliases, f"Resolved class aliases {aliases} do not include requested id '{mid.lower()}'" + + +def test_get_model_by_id_raises_for_unknown(): + with pytest.raises(ValueError): + get_model_by_id("Binary", "definitely_not_a_model") diff --git a/streamline/tests/subtests/test_p6_modeling.py b/streamline/tests/subtests/test_p6_modeling.py new file mode 100644 index 00000000..52a8d4c0 --- /dev/null +++ b/streamline/tests/subtests/test_p6_modeling.py @@ -0,0 +1,229 @@ +# tests/test_p6_modeling.py +import os +import json +import pickle +import numpy as np +import pandas as pd +import pytest +from pathlib import Path +from sklearn.datasets import make_classification +from sklearn.calibration import CalibratedClassifierCV + +pytest.skip("Tested Already", allow_module_level=True) + +# Phase 6 entrypoint +from streamline.p6_modeling.modeling import ModelingPhaseJob + + +# ------------------------- +# Helpers +# ------------------------- +def _make_cv_dataset( + root: Path, + dataset_name: str = "ToyData", + n_features: int = 8, + n_samples: int = 300, +): + """ + Creates //CVDatasets with a single CV split (0) + and writes Train/Test CSVs. + + Columns: [Class, f0..f{n_features-1}] + """ + ds_dir = root / dataset_name + cv_dir = ds_dir / "CVDatasets" + cv_dir.mkdir(parents=True, exist_ok=True) + + X, y = make_classification( + n_samples=n_samples, + n_features=n_features, + n_informative=max(2, n_features // 3), + n_redundant=0, + n_repeated=0, + n_clusters_per_class=2, + class_sep=1.2, + random_state=42, + ) + + # simple split + idx = np.arange(n_samples) + rng = np.random.default_rng(7) + rng.shuffle(idx) + split = int(0.7 * n_samples) + tr, te = idx[:split], idx[split:] + + cols = [f"f{i}" for i in range(n_features)] + df = pd.DataFrame(X, columns=cols) + df.insert(0, "Class", y) + + train = df.iloc[tr].copy() + test = df.iloc[te].copy() + + train_path = cv_dir / f"{dataset_name}_CV_0_Train.csv" + test_path = cv_dir / f"{dataset_name}_CV_0_Test.csv" + train.to_csv(train_path, index=False) + test.to_csv(test_path, index=False) + + return ds_dir + + +def _run_p6_for_models( + exp_root: Path, + dataset_dir: Path, + models_csv: str, + calibrate: bool = True, +): + """ + Runs ModelingPhaseJob directly for a single dataset with n_splits=1. + """ + ModelingPhaseJob( + dataset_dir=str(dataset_dir), + outcome_label="Class", + model_type="Binary", + instance_label=None, + n_splits=1, + models=models_csv, # comma-separated: e.g., "LR,SVM,NB" + # calibration flows into BaseModel via construction + calibrate=calibrate, + calibrate_method="sigmoid", + calibrate_cv=3, + # ModelJob settings + output_path=str(exp_root.parent), # + experiment_name=str(exp_root.name), # + scoring_metric="balanced_accuracy", + metric_direction="maximize", + n_trials=2, # keep the test fast + timeout=30, # seconds budget for optuna + training_subsample=0, + uniform_fi=False, + save_plot=False, + random_state=123, + ).run_all_model_cv_jobs() + + +def _assert_artifacts(dataset_dir: Path, small_name: str): + """ + Verifies pickled model + JSON metrics and a sensible probability + interface post-calibration. + """ + # pickled model + model_pkl = dataset_dir / "models" / "pickledModels" / f"{small_name}_0.pickle" + assert model_pkl.exists(), f"Missing model pickle for {small_name}" + + # JSON metrics (new layout) + metrics_json = ( + dataset_dir + / "model_evaluation" + / "metrics_by_cv" + / f"{small_name}_CV_0.json" + ) + assert metrics_json.exists(), f"Missing metrics JSON for {small_name}" + + with open(metrics_json, "r") as f: + payload = json.load(f) + + # We expect either a nested {"metrics": {...}} or flat dict with metric keys + if "metrics" in payload: + m = payload["metrics"] + else: + m = payload + + # At minimum, balanced_accuracy must be present + assert "balanced_accuracy" in m, f"Expected 'balanced_accuracy' in metrics for {small_name}" + + # load and inspect calibration / proba + with open(model_pkl, "rb") as f: + est = pickle.load(f) + + # The calibrated estimator is either a CalibratedClassifierCV, + # or exposes predict_proba + has_proba = hasattr(est, "predict_proba") + is_calibrated = isinstance(est, CalibratedClassifierCV) + + # We accept either (SVM may need calibration to expose calibrated_classifiers_) + assert has_proba or is_calibrated, ( + f"Expected calibrated or proba-capable model for {small_name}" + ) + + +# ------------------------- +# Tests +# ------------------------- +@pytest.fixture +def phase6_layout(tmp_path: Path): + """ + Creates the Phase-1 style layout: + /out///CVDatasets/*.csv + and returns (output_path, experiment_path, dataset_dir). + """ + out = tmp_path / "out" + exp = out / "P6Exp" + exp.mkdir(parents=True, exist_ok=True) + ds_dir = _make_cv_dataset( + exp, + dataset_name="ToyData", + n_features=10, + n_samples=260, + ) + # phase folders that Phase 6 expects to exist or will create on demand + (ds_dir / "models").mkdir(exist_ok=True) + (ds_dir / "model_evaluation").mkdir(exist_ok=True) + (ds_dir / "runtime").mkdir(exist_ok=True) + (exp / "jobsCompleted").mkdir(exist_ok=True) + (exp / "jobs").mkdir(exist_ok=True) + (exp / "logs").mkdir(exist_ok=True) + return out, exp, ds_dir + + +@pytest.mark.parametrize( + "models_csv, expected_small_names", + [ + ("LR", ["LR"]), + ("NB", ["NB"]), + ("SVM", ["SVM"]), + ("LR,NB,SVM", ["LR", "NB", "SVM"]), + ], +) +def test_p6_modeling_smoke(phase6_layout, models_csv, expected_small_names): + """ + Smoke test Phase 6 modeling for LR, NB, SVM (individually and together). + Verifies model/metrics artifacts and that the estimator is calibrated or + proba-capable. + """ + out, exp, ds_dir = phase6_layout + + # Run once per models set + _run_p6_for_models( + exp_root=exp, + dataset_dir=ds_dir, + models_csv=models_csv, + calibrate=True, + ) + + # Check artifacts per expected small_name + for sn in expected_small_names: + _assert_artifacts(ds_dir, small_name=sn) + + +def test_p6_modeling_without_calibration(phase6_layout): + """ + Also run once without calibration to ensure the pipeline still writes artifacts. + """ + out, exp, ds_dir = phase6_layout + _run_p6_for_models( + exp_root=exp, + dataset_dir=ds_dir, + models_csv="LR,SVM,NB", + calibrate=False, + ) + + for sn in ["LR", "SVM", "NB"]: + model_pkl = ds_dir / "models" / "pickledModels" / f"{sn}_0.pickle" + metrics_json = ( + ds_dir + / "model_evaluation" + / "metrics_by_cv" + / f"{sn}_CV_0.json" + ) + assert model_pkl.exists() + assert metrics_json.exists() diff --git a/streamline/tests/subtests/test_p6_multiclass_evaluation.py b/streamline/tests/subtests/test_p6_multiclass_evaluation.py new file mode 100644 index 00000000..f6396281 --- /dev/null +++ b/streamline/tests/subtests/test_p6_multiclass_evaluation.py @@ -0,0 +1,48 @@ +import numpy as np + +from streamline.p6_modeling.utils.submodels import MulticlassClassificationModel + + +class _DummyMulticlassEstimator: + def __init__(self): + self.classes_ = np.array([0, 1, 2]) + self._proba = np.array( + [ + [0.90, 0.05, 0.05], + [0.10, 0.75, 0.15], + [0.05, 0.10, 0.85], + [0.15, 0.65, 0.20], + [0.80, 0.10, 0.10], + [0.10, 0.20, 0.70], + ] + ) + + def predict(self, x_test): + return self.classes_[np.argmax(self._proba[: len(x_test)], axis=1)] + + def predict_proba(self, x_test): + return self._proba[: len(x_test)] + + +class _DummyMulticlassModel(MulticlassClassificationModel): + def __init__(self): + super().__init__(model=None, model_name="Dummy Multiclass") + self.model = _DummyMulticlassEstimator() + + def objective(self, trial, params=None): + raise NotImplementedError + + +def test_multiclass_model_evaluation_supports_macro_micro_average_precision(): + model = _DummyMulticlassModel() + x_test = np.zeros((6, 2)) + y_test = np.array([0, 1, 2, 1, 0, 2]) + + metrics_dict, curves_dict = model.model_evaluation(x_test, y_test) + + assert metrics_dict["average_precision_macro"] is not None + assert metrics_dict["average_precision_micro"] is not None + assert metrics_dict["roc_auc_macro"] is not None + assert metrics_dict["roc_auc_micro"] is not None + assert set(curves_dict["roc"]) == {"micro", "macro"} + assert set(curves_dict["prc"]) == {"micro", "macro"} diff --git a/streamline/tests/subtests/test_p6_native_categorical.py b/streamline/tests/subtests/test_p6_native_categorical.py new file mode 100644 index 00000000..705d01be --- /dev/null +++ b/streamline/tests/subtests/test_p6_native_categorical.py @@ -0,0 +1,140 @@ +from __future__ import annotations + +import json +import pickle +from pathlib import Path + +import numpy as np +import pandas as pd + +from streamline.p6_modeling.modeling import ModelingPhaseJob +from streamline.p6_modeling.utils.categorical import ( + NATIVE_CATEGORICAL_MODELS_DEFAULT, + parse_model_id_csv, +) +from streamline.p6_modeling.utils.modeljob import ModelJob + + +class DummyExstracsEstimator: + def __init__(self): + self.discrete_attribute_limit = None + self.specified_attributes = None + + def get_params(self, deep=True): + return { + "discrete_attribute_limit": self.discrete_attribute_limit, + "specified_attributes": self.specified_attributes, + } + + def set_params(self, **params): + for key, value in params.items(): + setattr(self, key, value) + return self + + +class DummyExstracsModel: + small_name = "ExSTraCS" + model_name = "ExSTraCS" + + def __init__(self): + self.model = DummyExstracsEstimator() + + +def write_native_categorical_dataset(dataset_dir: Path) -> None: + cv_dir = dataset_dir / "CVDatasets" + exploratory_dir = dataset_dir / "exploratory" + cv_dir.mkdir(parents=True, exist_ok=True) + exploratory_dir.mkdir(parents=True, exist_ok=True) + + train = pd.DataFrame( + { + "Class": [0, 1, 0, 1], + "age": [50, 61, 45, 70], + "sex": ["M", "F", "F", "M"], + "stage": ["I", "II", "I", "III"], + "lab": [1.1, 2.2, 1.4, 3.0], + } + ) + test = pd.DataFrame( + { + "Class": [0, 1], + "age": [55, 68], + "sex": ["F", "M"], + "stage": ["II", "III"], + "lab": [1.8, 2.9], + } + ) + train.to_csv(cv_dir / f"{dataset_dir.name}_CV_0_Train.csv", index=False) + test.to_csv(cv_dir / f"{dataset_dir.name}_CV_0_Test.csv", index=False) + + feature_meta = { + "feature_names": ["age", "sex", "stage", "lab"], + "categorical_mask": [False, True, True, False], + "quantitative_mask": [True, False, False, True], + "one_hot": False, + "one_hot_features": [], + "categorical_features": ["sex", "stage"], + } + with (exploratory_dir / "feature_meta.pickle").open("wb") as handle: + pickle.dump(feature_meta, handle) + (exploratory_dir / "feature_meta.json").write_text(json.dumps(feature_meta)) + + +def make_model_job(tmp_path: Path) -> ModelJob: + exp_root = tmp_path / "out" / "Exp" + dataset_dir = exp_root / "ToyData" + write_native_categorical_dataset(dataset_dir) + return ModelJob( + full_path=str(dataset_dir), + output_path=str(tmp_path / "out"), + experiment_name="Exp", + cv_count=0, + outcome_label="Class", + scoring_metric="balanced_accuracy", + metric_direction="maximize", + native_categorical_models=NATIVE_CATEGORICAL_MODELS_DEFAULT, + ) + + +def test_default_native_categorical_models_include_exstracs(): + parsed = parse_model_id_csv(NATIVE_CATEGORICAL_MODELS_DEFAULT) + assert "cgb" in parsed + assert "exstracs" in parsed + + job = ModelingPhaseJob( + dataset_dir="/tmp/not-used", + output_path="/tmp", + experiment_name="not-used", + ) + assert {"cgb", "exstracs"}.issubset(job.native_categorical_model_ids) + + +def test_exstracs_native_categorical_data_prep_and_params(tmp_path: Path): + model_job = make_model_job(tmp_path) + model = DummyExstracsModel() + + x_train, y_train, x_test, y_test = model_job.data_prep(model) + model_job._configure_native_categorical_model(model) + + assert model_job.categorical_encoding_mode == "native" + assert list(x_train.columns) == ["age", "sex", "stage", "lab"] + assert list(x_test.columns) == ["age", "sex", "stage", "lab"] + assert y_train.tolist() == [0, 1, 0, 1] + assert y_test.tolist() == [0, 1] + assert model.model.discrete_attribute_limit == "d" + np.testing.assert_array_equal(model.model.specified_attributes, np.asarray([1, 2], dtype=int)) + report = model_job._categorical_report() + assert report["native_categorical_features"] == ["sex", "stage"] + assert report["native_categorical_indices"] == [1, 2] + + +def test_exstracs_params_are_not_forced_outside_native_mode(tmp_path: Path): + model_job = make_model_job(tmp_path) + model_job.categorical_encoding_mode = "none" + model_job.categorical_feature_names = [] + model = DummyExstracsModel() + + model_job._configure_native_categorical_model(model) + + assert model.model.discrete_attribute_limit is None + assert model.model.specified_attributes is None diff --git a/streamline/tests/subtests/test_p6_p7_p8.py b/streamline/tests/subtests/test_p6_p7_p8.py new file mode 100644 index 00000000..f20908ef --- /dev/null +++ b/streamline/tests/subtests/test_p6_p7_p8.py @@ -0,0 +1,234 @@ +# tests/test_p6_p7_p8_integration.py + +import os +import json +import pickle +from pathlib import Path + +import numpy as np +import pandas as pd +import pytest +from sklearn.datasets import make_classification + +pytest.skip("Tested Already", allow_module_level=True) + +# Phase 6 / 7 / 8 imports - adjust if your module paths differ +from streamline.p6_modeling.p6_runner import P6Runner +from streamline.p7_ensembles.p7_runner import P7Runner +from streamline.p8_summary_statistics.p8_runner import P8Runner + + +def _make_synthetic_cv_dataset(root: Path, n_splits: int = 3, n_samples: int = 120, random_state: int = 0): + """ + Create a tiny synthetic binary classification dataset and write + CV Train/Test CSVs into the expected STREAMLINE layout: + + ///CVDatasets/_CV__Train.csv + ///CVDatasets/_CV__Test.csv + + Columns: InstanceID, Class, f0, f1, f2, ... + """ + rng = np.random.RandomState(random_state) + X, y = make_classification( + n_samples=n_samples, + n_features=5, + n_informative=3, + n_redundant=0, + n_repeated=0, + n_clusters_per_class=1, + class_sep=1.2, + flip_y=0.03, + random_state=random_state, + ) + + idx = np.arange(n_samples) + rng.shuffle(idx) + X = X[idx] + y = y[idx] + + dataset_name = "toy_dataset" + ds_dir = root / dataset_name + cv_dir = ds_dir / "CVDatasets" + cv_dir.mkdir(parents=True, exist_ok=True) + + # simple CV: contiguous chunks + fold_sizes = np.full(n_splits, n_samples // n_splits, dtype=int) + fold_sizes[: n_samples % n_splits] += 1 + current = 0 + + for cv_idx, fold_size in enumerate(fold_sizes): + start, stop = current, current + fold_size + current = stop + + test_mask = np.zeros(n_samples, dtype=bool) + test_mask[start:stop] = True + train_mask = ~test_mask + + X_train, y_train = X[train_mask], y[train_mask] + X_test, y_test = X[test_mask], y[test_mask] + + # Build DataFrames + n_train = X_train.shape[0] + n_test = X_test.shape[0] + + cols = ["InstanceID", "Class"] + [f"f{i}" for i in range(X.shape[1])] + + train_df = pd.DataFrame( + np.column_stack( + [np.arange(n_train), y_train, X_train] + ), + columns=cols, + ) + test_df = pd.DataFrame( + np.column_stack( + [np.arange(n_test), y_test, X_test] + ), + columns=cols, + ) + + train_path = cv_dir / f"{dataset_name}_CV_{cv_idx}_Train.csv" + test_path = cv_dir / f"{dataset_name}_CV_{cv_idx}_Test.csv" + train_df.to_csv(train_path, index=False) + test_df.to_csv(test_path, index=False) + + # minimal metadata so phases that read it don't explode + meta = { + "Outcome Type": "Binary", + "Outcome Label": "Class", + "Instance Label": "InstanceID", + } + with open(root / "metadata.pickle", "wb") as f: + pickle.dump(meta, f) + + return dataset_name + + +@pytest.mark.integration +def test_p6_p7_p8_pipeline(): + """ + End-to-end smoke test: + + 1. Create synthetic CV datasets. + 2. Run Phase 6 modeling for a subset of models. + 3. Run Phase 7 ensembles using the base models. + 4. Run Phase 8 statistics summarization (incl. ensemble summary). + 5. Check that key artifacts were created. + """ + tmp_path = Path("./test/") + output_path = tmp_path / "out" + experiment_name = "exp_integration" + exp_root = output_path / experiment_name + exp_root.mkdir(parents=True, exist_ok=True) + + # 1) Synthetic dataset (writes CVDatasets + metadata.pickle) + dataset_name = _make_synthetic_cv_dataset(exp_root, n_splits=3, n_samples=90, random_state=42) + ds_dir = exp_root / dataset_name + + # 2) Phase 6 - run a few simple models. + # Adjust "NB,LR,DT" to match registry IDs (small_name) in your p6 loader. + p6 = P6Runner( + output_path=str(output_path), + experiment_name=experiment_name, + outcome_label="Class", + model_type="Binary", + instance_label="InstanceID", + n_splits=3, + models="NB,LR,DT", + calibrate=False, + scoring_metric="balanced_accuracy", + metric_direction="maximize", + n_trials=2, # keep tiny for tests + timeout=15, + training_subsample=0, + uniform_fi=False, + save_plot=False, + random_state=42, + run_cluster="Serial", + ) + p6.run() + + # Check that at least some base models were trained & pickled + models_dir = ds_dir / "models" / "pickledModels" + assert models_dir.is_dir(), "Phase 6 should create models/pickledModels" + base_pickles = [p for p in models_dir.glob("*.pickle")] + assert base_pickles, "Expected at least one base model pickle from Phase 6" + + # 3) Phase 7 - ensembles on top of the base models + # ensembles: hard/soft voting and one stacking variant. Adjust IDs to match your get_ensemble_by_id registry. + p7 = P7Runner( + output_path=str(output_path), + experiment_name=experiment_name, + n_splits=3, + outcome_label="Class", + instance_label="InstanceID", + ensembles="hard_voting,soft_voting,stack_lr", + base_models="NB,LR,DT", + calibrate=0, # keep off for speed + calibrate_method="sigmoid", + calibrate_cv=3, + random_state=42, + run_cluster="Serial", + ) + p7.run() + + ens_root = ds_dir / "ensemble_evaluation" + assert ens_root.is_dir(), "Phase 7 should create ensemble_evaluation directory" + + ens_models_dir = ens_root / "pickled_ensembles" + assert ens_models_dir.is_dir(), "Ensembles should be pickled under ensemble_evaluation/pickled_ensembles" + ens_pickles = list(ens_models_dir.glob("*.pickle")) + assert ens_pickles, "Expected at least one ensemble pickle from Phase 7" + + # check metrics jsons + metrics_dir = ens_root / "metrics_by_cv" + assert metrics_dir.is_dir() + metrics_files = list(metrics_dir.glob("*.json")) + assert metrics_files, "Expected per-CV ensemble metrics JSONs" + + # sanity check a metric file structure + with open(metrics_files[0]) as f: + m = json.load(f) + assert "Balanced Accuracy" in m and "Accuracy" in m + + # 4) Phase 8 - statistics summarization (base models + ensemble summaries) + p8 = P8Runner( + output_path=str(output_path), + experiment_name=experiment_name, + outcome_label="Class", + outcome_type="Binary", + instance_label="InstanceID", + n_splits=3, + scoring_metric="balanced_accuracy", + top_features=10, + sig_cutoff=0.1, # relaxed for tiny data + metric_weight="balanced_accuracy", + scale_data=True, + exclude_plots="plot_FI_box", # make tests faster / headless-safe + show_plots=False, + run_cluster="Serial", + ) + p8.run() + + # 5) Verify statistics outputs + + # Base model summaries + model_eval_dir = ds_dir / "model_evaluation" + assert model_eval_dir.is_dir() + + summary_mean = model_eval_dir / "Summary_performance_mean.csv" + assert summary_mean.is_file(), "Expected Summary_performance_mean.csv from P8Runner" + + df_mean = pd.read_csv(summary_mean) + assert not df_mean.empty + assert "Balanced Accuracy" in df_mean.columns + + # Ensemble summaries - file naming can be tweaked to match your implementation, + # here we only assert that at least one Summary*.csv exists in ensemble_evaluation. + ensemble_summary_csvs = list(ens_root.glob("Ensembles*_performance_*.csv")) + assert ( + ensemble_summary_csvs + ), "Expected at least one ensemble summary CSV (Ensembles*...) in ensemble_evaluation" + + # If a specific name is used (e.g. Summary_ensemble_performance_mean.csv), you can tighten this: + # ens_summary_mean = ens_root / "Summary_ensemble_performance_mean.csv" + # assert ens_summary_mean.is_file() diff --git a/streamline/tests/subtests/test_p9.py b/streamline/tests/subtests/test_p9.py new file mode 100644 index 00000000..924e9416 --- /dev/null +++ b/streamline/tests/subtests/test_p9.py @@ -0,0 +1,359 @@ +# tests/test_p6_p7_p8_integration.py + +import os +import json +import pickle +from pathlib import Path + +import numpy as np +import pandas as pd +import pytest +from sklearn.datasets import make_classification + +pytest.skip("Tested Already", allow_module_level=True) + +# Phase 6 / 7 / 8 / 9 imports - adjust if your module paths differ +from streamline.p6_modeling.p6_runner import P6Runner +from streamline.p7_ensembles.p7_runner import P7Runner +from streamline.p8_summary_statistics.p8_runner import P8Runner +from streamline.p9_compare_datasets.p9_runner import P9Runner + + +def _make_synthetic_cv_dataset( + root: Path, + dataset_name: str = "toy_dataset", + n_splits: int = 3, + n_samples: int = 120, + random_state: int = 0, +): + """ + Create a tiny synthetic binary classification dataset and write + CV Train/Test CSVs into the expected STREAMLINE layout: + + ///CVDatasets/_CV__Train.csv + ///CVDatasets/_CV__Test.csv + + Columns: InstanceID, Class, f0, f1, f2, ... + """ + rng = np.random.RandomState(random_state) + X, y = make_classification( + n_samples=n_samples, + n_features=5, + n_informative=3, + n_redundant=0, + n_repeated=0, + n_clusters_per_class=1, + class_sep=1.2, + flip_y=0.03, + random_state=random_state, + ) + + idx = np.arange(n_samples) + rng.shuffle(idx) + X = X[idx] + y = y[idx] + + ds_dir = root / dataset_name + cv_dir = ds_dir / "CVDatasets" + cv_dir.mkdir(parents=True, exist_ok=True) + + # simple CV: contiguous chunks + fold_sizes = np.full(n_splits, n_samples // n_splits, dtype=int) + fold_sizes[: n_samples % n_splits] += 1 + current = 0 + + for cv_idx, fold_size in enumerate(fold_sizes): + start, stop = current, current + fold_size + current = stop + + test_mask = np.zeros(n_samples, dtype=bool) + test_mask[start:stop] = True + train_mask = ~test_mask + + X_train, y_train = X[train_mask], y[train_mask] + X_test, y_test = X[test_mask], y[test_mask] + + # Build DataFrames + n_train = X_train.shape[0] + n_test = X_test.shape[0] + + cols = ["InstanceID", "Class"] + [f"f{i}" for i in range(X.shape[1])] + + train_df = pd.DataFrame( + np.column_stack([np.arange(n_train), y_train, X_train]), + columns=cols, + ) + test_df = pd.DataFrame( + np.column_stack([np.arange(n_test), y_test, X_test]), + columns=cols, + ) + + train_path = cv_dir / f"{dataset_name}_CV_{cv_idx}_Train.csv" + test_path = cv_dir / f"{dataset_name}_CV_{cv_idx}_Test.csv" + train_df.to_csv(train_path, index=False) + test_df.to_csv(test_path, index=False) + + # minimal metadata so phases that read it don't explode + meta = { + "Outcome Type": "Binary", + "Outcome Label": "Class", + "Instance Label": "InstanceID", + } + with open(root / "metadata.pickle", "wb") as f: + pickle.dump(meta, f) + + return dataset_name + + +@pytest.mark.integration +def test_p6_p7_p8_pipeline(): + """ + End-to-end smoke test: + + 1. Create synthetic CV datasets. + 2. Run Phase 6 modeling for a subset of models. + 3. Run Phase 7 ensembles using the base models. + 4. Run Phase 8 statistics summarization (incl. ensemble summary). + 5. Check that key artifacts were created. + """ + tmp_path = Path("./test/") + output_path = tmp_path / "out" + experiment_name = "exp_integration" + exp_root = output_path / experiment_name + exp_root.mkdir(parents=True, exist_ok=True) + + # 1) Synthetic dataset (writes CVDatasets + metadata.pickle) + dataset_name = _make_synthetic_cv_dataset( + exp_root, dataset_name="toy_dataset", n_splits=3, n_samples=90, random_state=42 + ) + ds_dir = exp_root / dataset_name + + # 2) Phase 6 - run a few simple models. + # Adjust "NB,LR,DT" to match registry IDs (small_name) in your p6 loader. + p6 = P6Runner( + output_path=str(output_path), + experiment_name=experiment_name, + outcome_label="Class", + model_type="Binary", + instance_label="InstanceID", + n_splits=3, + models="NB,LR,DT", + calibrate=False, + scoring_metric="balanced_accuracy", + metric_direction="maximize", + n_trials=2, # keep tiny for tests + timeout=15, + training_subsample=0, + uniform_fi=False, + save_plot=False, + random_state=42, + run_cluster="Serial", + ) + p6.run() + + # Check that at least some base models were trained & pickled + models_dir = ds_dir / "models" / "pickledModels" + assert models_dir.is_dir(), "Phase 6 should create models/pickledModels" + base_pickles = [p for p in models_dir.glob("*.pickle")] + assert base_pickles, "Expected at least one base model pickle from Phase 6" + + # 3) Phase 7 - ensembles on top of the base models + # ensembles: hard/soft voting and one stacking variant. Adjust IDs to match your get_ensemble_by_id registry. + p7 = P7Runner( + output_path=str(output_path), + experiment_name=experiment_name, + n_splits=3, + outcome_label="Class", + instance_label="InstanceID", + ensembles="hard_voting,soft_voting,stack_lr", + base_models="NB,LR,DT", + calibrate=0, # keep off for speed + calibrate_method="sigmoid", + calibrate_cv=3, + random_state=42, + run_cluster="Serial", + ) + p7.run() + + ens_root = ds_dir / "ensemble_evaluation" + assert ens_root.is_dir(), "Phase 7 should create ensemble_evaluation directory" + + ens_models_dir = ens_root / "pickled_ensembles" + assert ens_models_dir.is_dir(), "Ensembles should be pickled under ensemble_evaluation/pickled_ensembles" + ens_pickles = list(ens_models_dir.glob("*.pickle")) + assert ens_pickles, "Expected at least one ensemble pickle from Phase 7" + + # check metrics jsons + metrics_dir = ens_root / "metrics_by_cv" + assert metrics_dir.is_dir() + metrics_files = list(metrics_dir.glob("*.json")) + assert metrics_files, "Expected per-CV ensemble metrics JSONs" + + # sanity check a metric file structure + with open(metrics_files[0]) as f: + m = json.load(f) + assert "Balanced Accuracy" in m and "Accuracy" in m + + # 4) Phase 8 - statistics summarization (base models + ensemble summaries) + p8 = P8Runner( + output_path=str(output_path), + experiment_name=experiment_name, + outcome_label="Class", + outcome_type="Binary", + instance_label="InstanceID", + n_splits=3, + scoring_metric="balanced_accuracy", + top_features=10, + sig_cutoff=0.1, # relaxed for tiny data + metric_weight="balanced_accuracy", + scale_data=True, + exclude_plots="plot_FI_box", # make tests faster / headless-safe + show_plots=False, + run_cluster="Serial", + ) + p8.run() + + # 5) Verify statistics outputs + + # Base model summaries + model_eval_dir = ds_dir / "model_evaluation" + assert model_eval_dir.is_dir() + + summary_mean = model_eval_dir / "Summary_performance_mean.csv" + assert summary_mean.is_file(), "Expected Summary_performance_mean.csv from P8Runner" + + df_mean = pd.read_csv(summary_mean) + assert not df_mean.empty + assert "Balanced Accuracy" in df_mean.columns + + # Ensemble summaries - file naming can be tweaked to match your implementation, + # here we only assert that at least one Summary*.csv exists in ensemble_evaluation. + ensemble_summary_csvs = list(ens_root.glob("Ensembles*_performance_*.csv")) + assert ( + ensemble_summary_csvs + ), "Expected at least one ensemble summary CSV (Ensembles*...) in ensemble_evaluation" + + # If a specific name is used (e.g. Summary_ensemble_performance_mean.csv), you can tighten this: + # ens_summary_mean = ens_root / "Summary_ensemble_performance_mean.csv" + # assert ens_summary_mean.is_file() + + +@pytest.mark.integration +def test_p9_dataset_compare(): + """ + Phase 9 dataset-compare smoke test: + + 1. Create two synthetic datasets in the same experiment. + 2. Run Phase 6 modeling over both. + 3. Run Phase 8 statistics to produce Summary_performance_* and per-model performance CSVs. + 4. Run Phase 9 dataset comparison. + 5. Check that key DatasetComparisons artifacts were created. + """ + tmp_path = Path("./test/") + output_path = tmp_path / "out" + experiment_name = "exp_p9_compare" + exp_root = output_path / experiment_name + exp_root.mkdir(parents=True, exist_ok=True) + + # 1) Two synthetic datasets under the same experiment + ds1_name = _make_synthetic_cv_dataset( + exp_root, dataset_name="toy_ds1", n_splits=3, n_samples=90, random_state=1 + ) + ds2_name = _make_synthetic_cv_dataset( + exp_root, dataset_name="toy_ds2", n_splits=3, n_samples=90, random_state=2 + ) + + ds1_dir = exp_root / ds1_name + ds2_dir = exp_root / ds2_name + assert (ds1_dir / "CVDatasets").is_dir() + assert (ds2_dir / "CVDatasets").is_dir() + + # 2) Phase 6 - base models for both datasets + p6 = P6Runner( + output_path=str(output_path), + experiment_name=experiment_name, + outcome_label="Class", + model_type="Binary", + instance_label="InstanceID", + n_splits=3, + models="NB,LR,DT", + calibrate=False, + scoring_metric="balanced_accuracy", + metric_direction="maximize", + n_trials=1, # smaller for test + timeout=10, + training_subsample=0, + uniform_fi=False, + save_plot=False, + random_state=123, + run_cluster="Serial", + ) + p6.run() + + # sanity check Phase 6 artifacts for both datasets + for ds in (ds1_dir, ds2_dir): + models_dir = ds / "models" / "pickledModels" + assert models_dir.is_dir() + assert list(models_dir.glob("*.pickle")), f"Expected base model pickles for {ds.name}" + + # 3) Phase 8 - stats for both datasets + p8 = P8Runner( + output_path=str(output_path), + experiment_name=experiment_name, + outcome_label="Class", + outcome_type="Binary", + instance_label="InstanceID", + n_splits=3, + scoring_metric="balanced_accuracy", + top_features=5, + sig_cutoff=0.1, + metric_weight="balanced_accuracy", + scale_data=True, + exclude_plots="plot_FI_box", # keep headless-safe and fast + show_plots=False, + run_cluster="Serial", + ) + p8.run() + + # check Phase 8 core outputs exist for both datasets + for ds in (ds1_dir, ds2_dir): + model_eval_dir = ds / "model_evaluation" + assert model_eval_dir.is_dir() + summary_mean = model_eval_dir / "Summary_performance_mean.csv" + assert summary_mean.is_file(), f"Missing Summary_performance_mean.csv for {ds.name}" + + # 4) Phase 9 - dataset comparison + p9 = P9Runner( + output_path=str(output_path), + experiment_name=experiment_name, + outcome_label="Class", + outcome_type="Binary", + instance_label="InstanceID", + sig_cutoff=0.1, + show_plots=False, + run_cluster="Serial", + ) + p9.run() + + # 5) Verify dataset comparison outputs + comp_dir = exp_root / "DatasetComparisons" + assert comp_dir.is_dir(), "Phase 9 should create DatasetComparisons directory" + + # per-algorithm Kruskal-Wallis across datasets + kw_files = list(comp_dir.glob("KruskalWallis_*.csv")) + assert kw_files, "Expected at least one KruskalWallis_*.csv from Phase 9" + + # best-model comparisons + best_kw = comp_dir / "BestCompare_KruskalWallis.csv" + assert best_kw.is_file(), "Expected BestCompare_KruskalWallis.csv from Phase 9" + + # optional: existence of other best-compare outputs (soft assertion) + best_mw = comp_dir / "BestCompare_MannWhitney.csv" + best_wx = comp_dir / "BestCompare_WilcoxonRank.csv" + assert best_mw.is_file() or best_wx.is_file(), ( + "Expected at least one best-compare pairwise test CSV from Phase 9" + ) + + # boxplots folder (not checking specific PNGs to keep things robust) + bp_dir = comp_dir / "dataCompBoxplots" + assert bp_dir.is_dir(), "Expected dataCompBoxplots directory from Phase 9" diff --git a/streamline/tests/subtests/test_pipeline_runner.py b/streamline/tests/subtests/test_pipeline_runner.py new file mode 100644 index 00000000..54527abd --- /dev/null +++ b/streamline/tests/subtests/test_pipeline_runner.py @@ -0,0 +1,490 @@ +from pathlib import Path + +from streamline.pipeline.pipeline_runner import PipelineRunner, load_config +import streamline.p6_modeling.p6_runner as p6_runner_module +from streamline.p6_modeling.p6_runner import P6Runner +from streamline.p6_modeling.utils.loader import load_default_model_classes +from streamline.utils.run_commands import load_phase_run_command, snapshot_effective_args + + +PROJECT_ROOT = Path(__file__).resolve().parents[3] + + +def csv_values(value): + if value is None: + return [] + if isinstance(value, list): + return value + return [item.strip() for item in str(value).split(",") if item.strip()] + + +def test_pipeline_controls_use_phase_aliases(): + config = { + "run": { + "phases": ["p1", "p2", "p3", "p4"], + } + } + + runner = PipelineRunner( + config=config, + dry_run=True, + start_at="p2", + stop_after="p3", + skip="p2", + ) + + assert runner.resolve_phase_order() == ["p3_feature_learning"] + + +def test_do_till_report_matches_old_cfg_style(): + config = { + "run": { + "phases": ["p1", "p10", "p11"], + }, + "phase_controls": { + "do_till_report": True, + }, + "phases": { + "p10": { + "rep_data_path": "data/UCIRepBinaryClassification", + "dataset_for_rep": "data/UCIBinaryClassification/hcc_survival.csv", + } + }, + } + + runner = PipelineRunner(config=config, dry_run=True) + + assert runner.phase_is_enabled("p1_data_process") + assert not runner.phase_is_enabled("p10_replication") + assert runner.phase_is_enabled("p11_reporting") + + +def test_elcs_is_not_a_default_model(): + for model_type in ("Binary", "Multiclass"): + default_ids = { + getattr(model_class, "small_name", "").lower() + for model_class in load_default_model_classes(model_type) + } + + assert "elcs" not in default_ids + + +def test_example_configs_dry_run_expected_phases(): + cases = { + "uci_binary_hcc.cfg": [ + "p1_data_process", + "p2_impute_scale", + "p3_feature_learning", + "p4_feature_importance", + "p5_feature_selection", + "p6_modeling", + "p7_ensembles", + "p8_summary_statistics", + "p9_compare_datasets", + "p10_replication", + "p11_reporting", + ], + "uci_multiclass_student.cfg": [ + "p1_data_process", + "p2_impute_scale", + "p3_feature_learning", + "p4_feature_importance", + "p5_feature_selection", + "p6_modeling", + "p7_ensembles", + "p8_summary_statistics", + "p9_compare_datasets", + "p10_replication", + "p11_reporting", + ], + "uci_regression_auto_mpg.cfg": [ + "p1_data_process", + "p2_impute_scale", + "p3_feature_learning", + "p4_feature_importance", + "p5_feature_selection", + "p6_modeling", + "p8_summary_statistics", + "p9_compare_datasets", + "p10_replication", + "p11_reporting", + ], + } + + for config_name, expected_phases in cases.items(): + runner = PipelineRunner( + config_path=PROJECT_ROOT / "run_configs" / config_name, + dry_run=True, + ) + + assert runner.run() == expected_phases + + +def test_example_configs_include_explicit_non_json_phase_parameters(): + required_run_keys = { + "output_path", + "experiment_name", + "outcome_label", + "outcome_type", + "instance_label", + "n_splits", + "run_cluster", + "queue", + "reserved_memory", + "random_state", + } + required_phase_keys = { + "p1": { + "data_path", + "exclude_eda_output", + "match_label", + "ignore_features", + "categorical_features", + "quantitative_features", + "top_features", + "categorical_cutoff", + "sig_cutoff", + "featureeng_missingness", + "cleaning_missingness", + "correlation_removal_threshold", + "partition_method", + "show_plots", + "one_hot_encoding", + "cv_provided", + "cv_input_root", + "enable_plots", + "plot_missingness", + "plot_class_counts", + "plot_correlation", + "correlation_plot_max_features", + "plot_univariate", + "univariate_top_k", + "plot_anomalies", + "force", + }, + "p2": { + "scale_data", + "impute_data", + "multi_impute", + "overwrite_cv", + "imputer_id", + "scaler_id", + "smote", + "smote_method", + "smote_sampling_strategy", + "smote_k_neighbors", + }, + "p3": { + "learner_id", + "feature_namespace", + "keep_original_features", + "overwrite_cv", + }, + "p4": { + "models", + "top_k", + "threshold", + "keep_original_features", + "overwrite_cv", + "instance_subset", + }, + "p5": { + "algorithms", + "n_splits", + "max_features_to_keep", + "filter_poor_features", + "overwrite_cv", + "selector_id", + "export_scores", + "top_features", + "show_plots", + "strict_discovery", + }, + "p6": { + "outcome_type", + "model_type", + "models", + "calibrate", + "calibrate_method", + "calibrate_cv", + "scoring_metric", + "metric_direction", + "n_trials", + "timeout", + "training_subsample", + "uniform_fi", + "save_plot", + "bypass_one_hot_for_native_models", + "native_categorical_models", + }, + "p7": { + "ensembles", + "base_models", + "meta_train_source", + "calibrate", + "calibrate_method", + "calibrate_cv", + }, + "p8": { + "scoring_metric", + "metric_weight", + "top_features", + "sig_cutoff", + "scale_data", + "exclude_plots", + "show_plots", + "include_ensembles", + "multiclass_average", + }, + "p9": {"sig_cutoff", "show_plots"}, + "p10": { + "rep_data_path", + "dataset_for_rep", + "match_label", + "exclude_plots", + "show_plots", + }, + "p11": { + "report_modes", + "reporting_dir", + "outcome_label", + "outcome_type", + "instance_label", + "make_pdf", + "enable_plots", + "reuse_existing_figures", + }, + } + + for config_path in sorted((PROJECT_ROOT / "run_configs").glob("uci_*.cfg")): + config = load_config(config_path) + missing_run = required_run_keys.difference(config["run"]) + assert not missing_run, f"{config_path.name} missing [run] keys: {sorted(missing_run)}" + for phase, keys in required_phase_keys.items(): + missing = keys.difference(config["phases"].get(phase, {})) + assert not missing, f"{config_path.name} missing [{phase}] keys: {sorted(missing)}" + + +def test_example_configs_keep_current_fi_and_demo_model_sets(): + cases = { + "uci_binary_hcc.cfg": { + "model_type": "Binary", + "expected_p6_models": {"NB", "LR", "DT"}, + }, + "uci_multiclass_student.cfg": { + "model_type": "Multiclass", + "expected_p6_models": {"NB", "LR", "DT"}, + }, + "uci_regression_auto_mpg.cfg": { + "model_type": "Regression", + "expected_p6_models": {"LR", "RF"}, + }, + } + + for config_name, expected in cases.items(): + config = load_config(PROJECT_ROOT / "run_configs" / config_name) + p4_config = config["phases"]["p4"] + p6_config = config["phases"]["p6"] + + assert csv_values(p4_config["models"]) == ["mutualinformation", "multiswrfdb"] + assert set(p4_config["models_params"]) == {"mutualinformation", "multiswrfdb"} + + p6_models = set(csv_values(p6_config["models"])) + assert p6_models == expected["expected_p6_models"] + assert p6_config["model_params_json"] in (None, {}) + + +def test_p6_runner_uses_outcome_type_as_public_task_parameter(tmp_path): + output_path = tmp_path / "out" + exp_root = output_path / "DemoExp" + exp_root.mkdir(parents=True) + + runner = P6Runner( + output_path=str(output_path), + experiment_name="DemoExp", + outcome_type="Continuous", + ) + + assert runner.outcome_type == "Continuous" + assert runner.model_type == "Regression" + + legacy_runner = P6Runner( + output_path=str(output_path), + experiment_name="DemoExp", + model_type="Regression", + ) + + assert legacy_runner.outcome_type == "Continuous" + assert legacy_runner.model_type == "Regression" + + +def test_parallel_mode_name_and_p6_dispatch(monkeypatch, tmp_path): + output_path = tmp_path / "out" + dataset_dir = output_path / "DemoExp" / "DemoDataset" + (dataset_dir / "CVDatasets").mkdir(parents=True) + captured = {} + + def fake_parallel_jobs(function, jobs, **kwargs): + captured["jobs"] = list(jobs) + captured["function"] = function + captured["label"] = kwargs.get("label") + + def fail_get_cluster(*args, **kwargs): + raise AssertionError("Parallel mode should not use Dask cluster lookup") + + monkeypatch.setattr(p6_runner_module, "run_parallel_jobs", fake_parallel_jobs) + monkeypatch.setattr(p6_runner_module, "get_cluster", fail_get_cluster) + + runner = P6Runner( + output_path=str(output_path), + experiment_name="DemoExp", + outcome_type="Binary", + models="NB,LR", + n_splits=2, + run_cluster="Parallel", + ) + runner.run() + + assert len(captured["jobs"]) == 4 + assert {job[0] for job in captured["jobs"]} == {str(dataset_dir)} + assert [getattr(job[1], "small_name") for job in captured["jobs"]] == ["NB", "NB", "LR", "LR"] + assert [job[2] for job in captured["jobs"]] == [0, 1, 0, 1] + assert "4 model/CV jobs" in captured["label"] + assert callable(captured["function"]) + + +def test_p6_local_dask_dispatch_reports_model_cv_job_count(monkeypatch, tmp_path): + output_path = tmp_path / "out" + dataset_dir = output_path / "DemoExp" / "DemoDataset" + (dataset_dir / "CVDatasets").mkdir(parents=True) + captured = {} + + class DummyContext: + def __init__(self, *args, **kwargs): + pass + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc, tb): + return False + + def fake_run_dask_tasks(tasks, client, label=None): + captured["task_count"] = len(list(tasks)) + captured["label"] = label + + monkeypatch.setattr(p6_runner_module, "LocalCluster", DummyContext) + monkeypatch.setattr(p6_runner_module, "Client", DummyContext) + monkeypatch.setattr(p6_runner_module, "run_dask_tasks", fake_run_dask_tasks) + + runner = P6Runner( + output_path=str(output_path), + experiment_name="DemoExp", + outcome_type="Binary", + models="NB,LR", + n_splits=2, + run_cluster="Local", + ) + runner.run() + + assert captured["task_count"] == 4 + assert "4 model/CV jobs" in captured["label"] + assert "2 model(s)" in captured["label"] + + +def test_p6_bash_submission_writes_one_script_per_model_cv(monkeypatch, tmp_path): + output_path = tmp_path / "out" + dataset_dir = output_path / "DemoExp" / "DemoDataset" + (dataset_dir / "CVDatasets").mkdir(parents=True) + submitted = [] + + monkeypatch.setattr(p6_runner_module.os, "system", lambda cmd: submitted.append(cmd) or 0) + + runner = P6Runner( + output_path=str(output_path), + experiment_name="DemoExp", + outcome_type="Binary", + models="NB,LR", + n_splits=2, + run_cluster="BashSLURM", + ) + runner.run() + + scripts = sorted((output_path / "DemoExp" / "jobs").glob("P6_DemoDataset_*_run.sh")) + assert len(scripts) == 4 + assert len(submitted) == 4 + + script_text = "\n".join(path.read_text() for path in scripts) + assert script_text.count("--model_id NB") == 2 + assert script_text.count("--model_id LR") == 2 + assert script_text.count("--cv_idx 0") == 2 + assert script_text.count("--cv_idx 1") == 2 + + +def test_config_runner_records_phase_args_in_run_command_pickle(monkeypatch, tmp_path): + class FakeRunner: + def __init__(self, output_path, experiment_name, foo="default", optional=None, run_cluster="Serial"): + self.output_path = output_path + self.experiment_name = experiment_name + self.foo = foo + self.optional = "resolved-default" if optional is None else optional + self.run_cluster = run_cluster + + def run(self): + Path(self.output_path, self.experiment_name).mkdir(parents=True, exist_ok=True) + + monkeypatch.setitem( + __import__("streamline.pipeline.pipeline_runner", fromlist=["PHASE_RUNNERS"]).PHASE_RUNNERS, + "p1_data_process", + FakeRunner, + ) + + output_path = tmp_path / "out" + runner = PipelineRunner( + config={ + "run": { + "output_path": str(output_path), + "experiment_name": "DemoExp", + "phases": ["p1"], + }, + "phases": { + "p1": { + "foo": "bar", + } + }, + } + ) + + assert runner.run() == ["p1_data_process"] + + record = load_phase_run_command(output_path / "DemoExp", "p1_data_process") + assert record["args"]["foo"] == "bar" + assert record["args"]["optional"] == "resolved-default" + assert record["args"]["run_cluster"] == "Serial" + assert record["args"]["experiment_name"] == "DemoExp" + + +def test_effective_args_snapshot_uses_runner_kw_dict(): + class FakeRunner: + def __init__(self): + self.kw = { + "outcome_type": "Binary", + "show_plots": False, + } + self.queue = "defq" + self.runtime_only = "not saved" + + effective = snapshot_effective_args( + { + "outcome_type": None, + "show_plots": True, + "queue": "oldq", + }, + FakeRunner(), + ) + + assert effective == { + "outcome_type": "Binary", + "show_plots": False, + "queue": "defq", + } diff --git a/streamline/tests/subtests/test_reporting_run_commands.py b/streamline/tests/subtests/test_reporting_run_commands.py new file mode 100644 index 00000000..3fd826f7 --- /dev/null +++ b/streamline/tests/subtests/test_reporting_run_commands.py @@ -0,0 +1,376 @@ +from __future__ import annotations + +import json +import pickle +from pathlib import Path + +from streamline.p11_reporting.reporting import ReportPhaseJob, _format_number +from streamline.utils.run_commands import save_phase_run_command + + +def make_dataset(path: Path) -> None: + (path / "exploratory").mkdir(parents=True, exist_ok=True) + (path / "model_evaluation").mkdir(parents=True, exist_ok=True) + + +def save_demo_commands(exp_root: Path) -> None: + save_phase_run_command( + exp_root, + "p1_data_process", + { + "data_path": "data/UCIBinaryClassification", + "output_path": str(exp_root.parent), + "experiment_name": exp_root.name, + "outcome_label": "Class", + "outcome_type": "Binary", + "instance_label": "InstanceID", + "n_splits": 3, + "partition_method": "Stratified", + "one_hot_encoding": True, + "categorical_features": "data/UCIFeatureTypes/hcc_survival_categorical_features.csv", + "quantitative_features": "data/UCIFeatureTypes/hcc_survival_quantitative_features.csv", + }, + argv=["python", "-m", "streamline.p1_data_process.p1_cli"], + ) + save_phase_run_command( + exp_root, + "p2_impute_scale", + { + "output_path": str(exp_root.parent), + "experiment_name": exp_root.name, + "smote": False, + "smote_method": "auto", + }, + argv=["python", "-m", "streamline.p2_impute_scale.p2_cli"], + ) + save_phase_run_command( + exp_root, + "p6_modeling", + { + "output_path": str(exp_root.parent), + "experiment_name": exp_root.name, + "outcome_type": "Binary", + "models": "NB,LR,DT", + "scoring_metric": "balanced_accuracy", + "metric_direction": "maximize", + "n_trials": 200, + "timeout": 900, + "bypass_one_hot_for_native_models": 1, + "native_categorical_models": "CGB", + }, + argv=["python", "-m", "streamline.p6_modeling.p6_cli"], + ) + save_phase_run_command( + exp_root, + "p10_replication", + { + "output_path": str(exp_root.parent), + "experiment_name": exp_root.name, + "rep_data_path": "data/UCIRepBinaryClassification", + "dataset_for_rep": "data/UCIBinaryClassification/hcc_survival.csv", + "show_plots": 0, + }, + argv=["python", "-m", "streamline.p10_replication.p10_cli"], + ) + + +def summary_lines(payload: dict) -> list[str]: + lines = [] + for section in payload["run_command_summary"]["sections"]: + lines.extend(section["lines"]) + return lines + + +def test_report_number_formatter_handles_infinite_values(): + assert _format_number("inf") == "inf" + assert _format_number("-inf") == "-inf" + + +def summary_titles(payload: dict) -> list[str]: + return [ + section["title"] + for section in payload["run_command_summary"]["sections"] + ] + + +def test_report_data_includes_saved_command_summary(tmp_path: Path): + exp_root = tmp_path / "out" / "DemoExp" + exp_root.mkdir(parents=True) + with (exp_root / "metadata.pickle").open("wb") as handle: + pickle.dump( + { + "Outcome Label": "Class", + "Outcome Type": "Binary", + "Instance Label": "InstanceID", + }, + handle, + ) + make_dataset(exp_root / "hcc_survival") + save_demo_commands(exp_root) + + ReportPhaseJob( + experiment_path=str(exp_root), + report_mode="standard", + make_pdf=False, + enable_plots=False, + ).run() + + payload = json.loads((exp_root / "reporting" / "report_data.json").read_text()) + summary = payload["run_command_summary"] + sections = {section["title"]: section["lines"] for section in summary["sections"]} + + assert summary["present"] is True + assert "Saved Command Pickle" not in summary_titles(payload) + assert "P10 Replication Settings" not in sections + assert any("CV Splits: 3" in line for line in sections["P1 Data Processing and CV"]) + assert any("SMOTE: False" in line for line in sections["P1-P2 EDA, Scaling, Imputation, and SMOTE"]) + assert any("Models: NB,LR,DT" in line for line in sections["P6-P8 Modeling, Ensembles, and Metrics"]) + assert any("Categorical Handling: One-hot encoding enabled; native categorical models may bypass it (CGB)." in line for line in sections["P6-P8 Modeling, Ensembles, and Metrics"]) + assert not any(line.startswith("Selector:") for line in summary_lines(payload)) + assert not any("Task Type:" in line for line in sections["Target Dataset(s)"]) + assert not any("Not specified" in line for line in summary_lines(payload)) + + +def test_report_pdf_filenames_include_experiment_name_and_mode(tmp_path: Path): + exp_root = tmp_path / "out" / "Demo Exp" + exp_root.mkdir(parents=True) + + standard_job = ReportPhaseJob( + experiment_path=str(exp_root), + report_mode="standard", + make_pdf=False, + enable_plots=False, + ) + replication_job = ReportPhaseJob( + experiment_path=str(exp_root), + report_mode="replication", + make_pdf=False, + enable_plots=False, + ) + + assert standard_job.paths.pdf.name == "Demo_Exp_STREAMLINE_Report.pdf" + assert replication_job.paths.pdf.name == "Demo_Exp_STREAMLINE_Replication_Report.pdf" + + +def test_replication_report_first_page_summary_uses_replication_settings(tmp_path: Path): + exp_root = tmp_path / "out" / "DemoExp" + exp_root.mkdir(parents=True) + with (exp_root / "metadata.pickle").open("wb") as handle: + pickle.dump({"Outcome Label": "Class", "Outcome Type": "Binary"}, handle) + + train_ds = exp_root / "hcc_survival" + make_dataset(train_ds) + make_dataset(train_ds / "replication" / "hcc_survival_rep") + save_demo_commands(exp_root) + save_phase_run_command( + exp_root, + "p11_reporting", + { + "experiment_path": str(exp_root), + "report_mode": "standard", + "make_pdf": True, + "enable_plots": True, + "reuse_existing_figures": True, + }, + argv=["python", "-m", "streamline.p11_reporting.p11_cli", "--report_mode", "standard"], + ) + + ReportPhaseJob( + experiment_path=str(exp_root), + report_mode="replication", + make_pdf=False, + enable_plots=False, + ).run() + + payload = json.loads((exp_root / "reporting_replication" / "report_data.json").read_text()) + sections = {section["title"]: section["lines"] for section in payload["run_command_summary"]["sections"]} + + assert payload["report_mode"] == "replication" + assert any("Rep Report Focus: Held-out/external replication folders only" in line for line in sections["P10 Replication Settings"]) + assert any("Report Mode: replication" in line for line in sections["P11 Reporting Settings"]) + assert any("hcc_survival_rep from hcc_survival" in line for line in sections["Target Dataset(s)"]) + assert not any("Task Type:" in line for line in sections["Target Dataset(s)"]) + assert not any("Not specified" in line for line in summary_lines(payload)) + + +def test_legacy_report_summary_uses_run_params_and_artifacts(tmp_path: Path): + exp_root = tmp_path / "out" / "LegacyExp" + exp_root.mkdir(parents=True) + with (exp_root / "metadata.pickle").open("wb") as handle: + pickle.dump( + { + "Data Path": "data/Legacy", + "Outcome Label": "Class", + "Outcome Type": "Binary", + "Instance Label": "InstanceID", + "CV Partitions": 3, + "Partition Method": "Stratified", + "Specified Categorical Features": "categorical.csv", + "Specified Quantitative Features": "quantitative.csv", + }, + handle, + ) + with (exp_root / "run_params.pickle").open("wb") as handle: + pickle.dump( + { + "2026-01-01T00:00:00": { + "data_path": "data/Legacy", + "n_splits": 3, + "partition_method": "Stratified", + "one_hot_encoding": True, + }, + "2026-01-01T00:00:01": { + "phase": "p2_impute_scale", + "scale_data": True, + "impute_data": True, + "multi_impute": False, + "overwrite_cv": True, + "smote": False, + "smote_method": "auto", + }, + "2026-01-01T00:00:02": { + "phase": "p4_feature_importance", + "models": ["mutualinformation"], + "models_params": {}, + }, + }, + handle, + ) + + ds = exp_root / "legacy_data" + make_dataset(ds) + (ds / "impute_scale").mkdir(parents=True) + (ds / "impute_scale" / "scaler_cv0.pickle").write_bytes(b"") + (ds / "feature_importance" / "mutualinformation").mkdir(parents=True) + (ds / "feature_importance" / "mutualinformation" / "mutualinformation_scores_cv_0.csv").write_text("feature,score\nx,1\n") + (ds / "feature_selection").mkdir(parents=True) + (ds / "feature_selection" / "InformativeFeatureSummary.csv").write_text("CV_Partition,Informative,Uninformative\n0,2,0\n") + (ds / "models" / "pickledModels").mkdir(parents=True) + (ds / "models" / "pickledModels" / "LR_0.pickle").write_bytes(b"") + (ds / "models" / "optuna_trials").mkdir(parents=True) + (ds / "models" / "optuna_trials" / "LR_optuna_trials0.csv").write_text("number,value\n0,0.5\n1,0.6\n") + (ds / "ensemble_evaluation" / "metrics_by_cv").mkdir(parents=True) + (ds / "ensemble_evaluation" / "metrics_by_cv" / "HEV_CV_0.json").write_text("{}") + make_dataset(ds / "replication" / "legacy_data_rep") + + ReportPhaseJob( + experiment_path=str(exp_root), + report_mode="replication", + make_pdf=False, + enable_plots=False, + ).run() + + payload = json.loads((exp_root / "reporting_replication" / "report_data.json").read_text()) + lines = summary_lines(payload) + + assert "Saved Command Pickle" not in summary_titles(payload) + assert any("Data Path: data/Legacy" in line for line in lines) + assert any("SMOTE: False" in line for line in lines) + assert any("FI Models: mutualinformation" in line for line in lines) + assert any("Feature Learner: Not run" in line for line in lines) + assert any("Models: LR" in line for line in lines) + assert any("Ensembles: hard_voting" in line for line in lines) + assert any("Optuna Trials Completed: 2 completed across 1 model/CV runs" in line for line in lines) + assert any("Replication Data Path: legacy_data_rep from legacy_data" in line for line in lines) + assert not any("Not specified" in line for line in lines) + + +def test_regression_report_summary_uses_regression_metric_defaults(tmp_path: Path): + exp_root = tmp_path / "out" / "RegressionExp" + exp_root.mkdir(parents=True) + with (exp_root / "metadata.pickle").open("wb") as handle: + pickle.dump( + { + "Outcome Label": "MPG", + "Outcome Type": "Continuous", + "Instance Label": "InstanceID", + "One Hot Encoding": False, + }, + handle, + ) + + ds = exp_root / "auto_mpg" + make_dataset(ds) + (ds / "runtime").mkdir(parents=True) + (ds / "runtime" / "runtime_Stats.txt").write_text("1.0") + save_phase_run_command( + exp_root, + "p1_data_process", + { + "output_path": str(exp_root.parent), + "experiment_name": exp_root.name, + "outcome_label": "MPG", + "outcome_type": "Continuous", + "one_hot_encoding": False, + }, + argv=["python", "-m", "streamline.p1_data_process.p1_cli"], + ) + save_phase_run_command( + exp_root, + "p6_modeling", + { + "output_path": str(exp_root.parent), + "experiment_name": exp_root.name, + "outcome_type": "Continuous", + "models": "LR,RF", + "scoring_metric": "balanced_accuracy", + "bypass_one_hot_for_native_models": True, + "native_categorical_models": "CGB,ExSTraCS", + }, + argv=["python", "-m", "streamline.p6_modeling.p6_cli"], + ) + save_phase_run_command( + exp_root, + "p8_summary_statistics", + { + "output_path": str(exp_root.parent), + "experiment_name": exp_root.name, + "scoring_metric": "balanced_accuracy", + "metric_weight": "balanced_accuracy", + }, + argv=["python", "-m", "streamline.p8_summary_statistics.p8_cli"], + ) + + ReportPhaseJob( + experiment_path=str(exp_root), + report_mode="standard", + make_pdf=False, + enable_plots=False, + ).run() + + payload = json.loads((exp_root / "reporting" / "report_data.json").read_text()) + sections = {section["title"]: section["lines"] for section in payload["run_command_summary"]["sections"]} + modeling = sections["P6-P8 Modeling, Ensembles, and Metrics"] + reporting = sections["P11 Reporting Settings"] + + assert any("Scoring Metric: explained_variance" in line for line in modeling) + assert any("P8 Metric Weight: explained_variance" in line for line in reporting) + assert any("Categorical Handling: One-hot encoding disabled; categorical features are passed to native-capable models (CGB,ExSTraCS)." in line for line in modeling) + + +def test_report_dataset_page_titles_are_context_specific(tmp_path: Path): + exp_root = tmp_path / "out" / "TitleExp" + exp_root.mkdir(parents=True) + make_dataset(exp_root / "toy") + + job = ReportPhaseJob( + experiment_path=str(exp_root), + report_mode="standard", + make_pdf=False, + enable_plots=False, + ) + assert job.feature_summary_page_title() == "Feature Learning, Importance, and Selection" + assert job.feature_summary_page_title(continued=True) == "Feature Learning, Importance, and Selection (continued)" + assert job.performance_page_title() == "Cross-Validation Performance" + assert job.evaluation_page_title({"task_type": "Regression"}) == "Regression Evaluation" + assert job.evaluation_page_title({"task_type": "Multiclass Classification"}) == "ROC/PRC Evaluation" + + rep_job = ReportPhaseJob( + experiment_path=str(exp_root), + report_mode="replication", + make_pdf=False, + enable_plots=False, + ) + assert rep_job.performance_page_title() == "Replication Performance" + assert rep_job.evaluation_page_title({"task_type": "Regression"}) == "Replication Regression Evaluation" + assert rep_job.evaluation_page_title({"task_type": "Multiclass Classification"}) == "Replication ROC/PRC Evaluation" diff --git a/streamline/tests/subtests/test_uci_demo_datasets.py b/streamline/tests/subtests/test_uci_demo_datasets.py new file mode 100644 index 00000000..e2657f14 --- /dev/null +++ b/streamline/tests/subtests/test_uci_demo_datasets.py @@ -0,0 +1,132 @@ +from __future__ import annotations + +import csv +from pathlib import Path + + +REPO_ROOT = Path(__file__).resolve().parents[3] + + +UCI_DATASETS = [ + { + "name": "hcc_survival", + "csv": REPO_ROOT / "data" / "UCIBinaryClassification" / "hcc_survival.csv", + "copy_csv": REPO_ROOT / "data" / "UCIBinaryClassification" / "hcc_survival_copy.csv", + "rep_csv": REPO_ROOT / "data" / "UCIRepBinaryClassification" / "hcc_survival_rep.csv", + "categorical": REPO_ROOT / "data" / "UCIFeatureTypes" / "hcc_survival_categorical_features.csv", + "quantitative": REPO_ROOT / "data" / "UCIFeatureTypes" / "hcc_survival_quantitative_features.csv", + "outcome": "Class", + "expected_classes": {"0", "1"}, + "expected_rows": 132, + "expected_missing": 668, + "expected_rep_rows": 33, + "expected_rep_missing": 158, + "expected_full_rows": 165, + "expected_full_missing": 826, + "expected_categorical": 26, + "expected_quantitative": 23, + }, + { + "name": "student_dropout_academic_success", + "csv": REPO_ROOT / "data" / "UCIMulticlassClassification" / "student_dropout_academic_success.csv", + "copy_csv": REPO_ROOT / "data" / "UCIMulticlassClassification" / "student_dropout_academic_success_copy.csv", + "rep_csv": REPO_ROOT / "data" / "UCIRepMulticlassClassification" / "student_dropout_academic_success_rep.csv", + "categorical": REPO_ROOT / "data" / "UCIFeatureTypes" / "student_dropout_categorical_features.csv", + "quantitative": REPO_ROOT / "data" / "UCIFeatureTypes" / "student_dropout_quantitative_features.csv", + "outcome": "Class", + "expected_classes": {"0", "1", "2"}, + "expected_rows": 3539, + "expected_missing": 573, + "expected_rep_rows": 885, + "expected_rep_missing": 131, + "expected_full_rows": 4424, + "expected_full_missing": 704, + "expected_categorical": 17, + "expected_quantitative": 19, + }, + { + "name": "auto_mpg", + "csv": REPO_ROOT / "data" / "UCIRegression" / "auto_mpg.csv", + "copy_csv": REPO_ROOT / "data" / "UCIRegression" / "auto_mpg_copy.csv", + "rep_csv": REPO_ROOT / "data" / "UCIRepRegression" / "auto_mpg_rep.csv", + "categorical": REPO_ROOT / "data" / "UCIFeatureTypes" / "auto_mpg_categorical_features.csv", + "quantitative": REPO_ROOT / "data" / "UCIFeatureTypes" / "auto_mpg_quantitative_features.csv", + "outcome": "MPG", + "expected_classes": None, + "expected_rows": 318, + "expected_missing": 4, + "expected_rep_rows": 80, + "expected_rep_missing": 2, + "expected_full_rows": 398, + "expected_full_missing": 6, + "expected_categorical": 3, + "expected_quantitative": 4, + }, +] + + +def read_rows(path: Path): + with path.open(newline="") as f: + return list(csv.DictReader(f)) + + +def read_features(path: Path) -> list[str]: + with path.open(newline="") as f: + return [row["Feature"] for row in csv.DictReader(f)] + + +def test_uci_demo_datasets_have_expected_shapes_and_missing_values(): + for spec in UCI_DATASETS: + rows = read_rows(spec["csv"]) + assert rows, f"{spec['name']} should have rows" + assert len(rows) == spec["expected_rows"], f"{spec['name']} row count changed" + assert "InstanceID" in rows[0], f"{spec['name']} should include InstanceID" + assert spec["outcome"] in rows[0], f"{spec['name']} should include outcome" + missing_count = sum(value == "NA" for row in rows for value in row.values()) + assert missing_count == spec["expected_missing"], f"{spec['name']} missing value count changed" + + categorical = read_features(spec["categorical"]) + quantitative = read_features(spec["quantitative"]) + headers = set(rows[0]) + assert categorical, f"{spec['name']} should declare categorical features" + assert quantitative, f"{spec['name']} should declare quantitative features" + assert len(categorical) == spec["expected_categorical"], f"{spec['name']} categorical feature count changed" + assert len(quantitative) == spec["expected_quantitative"], f"{spec['name']} quantitative feature count changed" + assert not (set(categorical) & set(quantitative)), f"{spec['name']} feature types should not overlap" + assert set(categorical).issubset(headers), f"{spec['name']} categorical features should exist in CSV" + assert set(quantitative).issubset(headers), f"{spec['name']} quantitative features should exist in CSV" + assert "InstanceID" not in categorical + quantitative + assert spec["outcome"] not in categorical + quantitative + + if spec["expected_classes"] is not None: + observed = {row[spec["outcome"]] for row in rows} + assert observed == spec["expected_classes"], f"{spec['name']} class labels changed" + else: + assert all(row[spec["outcome"]] != "NA" for row in rows), f"{spec['name']} target should be complete" + + +def test_uci_companion_and_replication_datasets_match_training_schema(): + for spec in UCI_DATASETS: + train_rows = read_rows(spec["csv"]) + copy_rows = read_rows(spec["copy_csv"]) + rep_rows = read_rows(spec["rep_csv"]) + assert copy_rows, f"{spec['name']} companion copy data should have rows" + assert rep_rows, f"{spec['name']} replication data should have rows" + assert list(train_rows[0]) == list(copy_rows[0]), f"{spec['name']} companion copy schema should match training schema" + assert list(train_rows[0]) == list(rep_rows[0]), f"{spec['name']} replication schema should match training schema" + assert train_rows == copy_rows, f"{spec['name']} companion copy data should match the training split" + assert len(rep_rows) == spec["expected_rep_rows"], f"{spec['name']} replication row count changed" + + train_ids = {row["InstanceID"] for row in train_rows} + rep_ids = {row["InstanceID"] for row in rep_rows} + assert not (train_ids & rep_ids), f"{spec['name']} training and replication splits should be disjoint" + assert len(train_ids | rep_ids) == spec["expected_full_rows"], f"{spec['name']} full split row count changed" + + train_missing = sum(value == "NA" for row in train_rows for value in row.values()) + rep_missing = sum(value == "NA" for row in rep_rows for value in row.values()) + assert rep_missing == spec["expected_rep_missing"], f"{spec['name']} replication missing value count changed" + assert train_missing + rep_missing == spec["expected_full_missing"], f"{spec['name']} full missing value count changed" + + if spec["expected_classes"] is not None: + observed_rep = {row[spec["outcome"]] for row in rep_rows} + assert observed_rep == spec["expected_classes"], f"{spec['name']} replication class labels changed" diff --git a/streamline/tests/test_classification.py b/streamline/tests/test_classification.py deleted file mode 100644 index d10972ba..00000000 --- a/streamline/tests/test_classification.py +++ /dev/null @@ -1,114 +0,0 @@ -import os -import time -import optuna -import pytest -import logging -from streamline.runners.dataprocess_runner import DataProcessRunner -from streamline.runners.imputation_runner import ImputationRunner -from streamline.runners.feature_runner import FeatureImportanceRunner -from streamline.runners.feature_runner import FeatureSelectionRunner -from streamline.runners.model_runner import ModelExperimentRunner -from streamline.runners.stats_runner import StatsRunner -from streamline.runners.compare_runner import CompareRunner -from streamline.runners.report_runner import ReportRunner -from streamline.runners.replicate_runner import ReplicationRunner - -# pytest.skip("Tested Already", allow_module_level=True) - -algorithms, run_parallel, output_path = ["MI", "MS"], False, "./tests/" -dataset_path, experiment_name = "./data/DemoData/", "demo", -model_algorithms = ["LR", "DT", "NB"] -rep_data_path = "./data/DemoRepData/" - - -def test_classification(): - start = time.time() - if not os.path.exists(output_path): - os.mkdir(output_path) - - eda = DataProcessRunner(dataset_path, output_path, experiment_name, - exclude_eda_output=None, - class_label="Class", instance_label="InstanceID", n_splits=3, ignore_features=None, - categorical_features=['Gender', 'Symptoms ', 'Alcohol', 'Hepatitis B Surface Antigen', - 'Hepatitis B e Antigen', 'Hepatitis B Core Antibody', - 'Hepatitis C Virus Antibody', 'Cirrhosis', - 'Endemic Countries', 'Smoking', 'Diabetes', 'Obesity', - 'Hemochromatosis', 'Arterial Hypertension', - 'Chronic Renal Insufficiency', 'Human Immunodeficiency Virus', - 'Nonalcoholic Steatohepatitis', 'Esophageal Varices', 'Splenomegaly', - 'Portal Hypertension', 'Portal Vein Thrombosis', 'Liver Metastasis', - 'Radiological Hallmark', - 'Sim_Cat_2', 'Sim_Cat_3', 'Sim_Cat_4', 'Sim_Text_Cat_2', - 'Sim_Text_Cat_3', 'Sim_Text_Cat_4'], - quantitative_features=['Sim_Miss_0.6', 'Alkaline phosphatase (U/L)', - 'Aspartate transaminase (U/L)', - 'International Normalised Ratio*', 'Performance Status*', - 'Sim_Cor_-1.0_B', - 'Alanine transaminase (U/L)', 'Platelets', - 'Direct Bilirubin (mg/dL)', 'Encephalopathy degree*', - 'Sim_Cor_0.9_A', 'Albumin (mg/dL)', 'Number of Nodules', - 'Sim_Cor_1.0_A', 'Haemoglobin (g/dL)', - 'Major dimension of nodule (cm)', 'Leukocytes(G/L)', - 'Total Proteins (g/dL)', 'Sim_Miss_0.7', - 'Ascites degree*', 'Creatinine (mg/dL)', 'Iron', 'Sim_Cor_0.9_B', - 'Grams of Alcohol per day', - 'Sim_Cor_-1.0_A', 'Oxygen Saturation (%)', - 'Gamma glutamyl transferase (U/L)', 'Total Bilirubin(mg/dL)', - 'Ferritin (ng/mL)', 'Packs of cigarets per year', - 'Mean Corpuscular Volume', 'Sim_Cor_1.0_B', - 'Alpha-Fetoprotein (ng/mL)'], - correlation_removal_threshold=1) - eda.run(run_parallel=run_parallel) - del eda - - dpr = ImputationRunner(output_path, experiment_name, - class_label="Class", instance_label="InstanceID") - dpr.run(run_parallel=run_parallel) - del dpr - - f_imp = FeatureImportanceRunner(output_path, experiment_name, - class_label="Class", instance_label="InstanceID", - algorithms=algorithms) - f_imp.run(run_parallel=run_parallel) - del f_imp - - f_sel = FeatureSelectionRunner(output_path, experiment_name, - class_label="Class", instance_label="InstanceID", - algorithms=algorithms) - f_sel.run(run_parallel=run_parallel) - del f_sel - - optuna.logging.set_verbosity(optuna.logging.WARNING) - - runner = ModelExperimentRunner(output_path, experiment_name, model_algorithms, - class_label="Class", instance_label="InstanceID", scoring_metric='roc_auc', - lcs_nu=1, lcs_n=50, lcs_iterations=200) - runner.run(run_parallel=run_parallel) - del runner - - stats = StatsRunner(output_path, experiment_name, model_algorithms, - class_label="Class", instance_label="InstanceID") - stats.run(run_parallel=run_parallel) - del stats - - compare = CompareRunner(output_path, experiment_name, algorithms=model_algorithms, - class_label="Class", instance_label="InstanceID") - compare.run(run_parallel=run_parallel) - del compare - - report = ReportRunner(output_path, experiment_name, algorithms=model_algorithms) - report.run(run_parallel=run_parallel) - del report - - repl = ReplicationRunner('./data/DemoRepData', dataset_path + 'hcc_data_custom.csv', - output_path, experiment_name, - load_algo=True) - repl.run(run_parallel=run_parallel) - - report = ReportRunner(output_path, experiment_name, algorithms=model_algorithms, - training=False, rep_data_path="./data/DemoRepData/", - dataset_for_rep=dataset_path + 'hcc_data_custom.csv') - report.run(run_parallel) - del report - - logging.warning("Ran Setup in " + str(time.time() - start)) diff --git a/streamline/tests/test_complete_binary.py b/streamline/tests/test_complete_binary.py new file mode 100644 index 00000000..dc799b46 --- /dev/null +++ b/streamline/tests/test_complete_binary.py @@ -0,0 +1,249 @@ +from __future__ import annotations + +import pickle +from pathlib import Path + +import pytest + +from streamline.p1_data_process.p1_runner import P1Runner +from streamline.p2_impute_scale.p2_runner import P2Runner +from streamline.p3_feature_learning.p3_runner import P3Runner +from streamline.p4_feature_importance.p4_runner import P4Runner +from streamline.p5_feature_selection.p5_runner import P5Runner +from streamline.p6_modeling.p6_runner import P6Runner +from streamline.p7_ensembles.p7_runner import P7Runner +from streamline.p8_summary_statistics.p8_runner import P8Runner +from streamline.p9_compare_datasets.p9_runner import P9Runner +from streamline.p10_replication.p10_runner import P10Runner +from streamline.p11_reporting.p11_runner import P11Runner + + +def pick_first_dataset_dir(exp_root: Path) -> Path: + datasets = [ + d for d in exp_root.iterdir() + if d.is_dir() and (d / "CVDatasets").is_dir() + ] + assert datasets, f"Expected at least one dataset with CVDatasets under {exp_root}" + return sorted(datasets)[0] + + +@pytest.mark.integration +def test_full_streamline_pipeline_uci_binary_hcc(tmp_path: Path): + repo_root = Path(__file__).resolve().parent.parent.parent + tmp_path = repo_root / "test" + data_root = repo_root / "data" / "UCIBinaryClassification" + rep_data_root = repo_root / "data" / "UCIRepBinaryClassification" + feature_root = repo_root / "data" / "UCIFeatureTypes" + + assert data_root.is_dir(), f"Expected UCI binary data under {data_root}" + assert rep_data_root.is_dir(), f"Expected UCI binary replication data under {rep_data_root}" + + output_root = tmp_path / "out_full_uci_binary_pipeline" + experiment_name = "UCIHCCBinary" + outcome_label = "Class" + instance_label = "InstanceID" + cv_splits = 3 + output_root.mkdir(parents=True, exist_ok=True) + exp_root = output_root / experiment_name + + p1 = P1Runner( + data_path=str(data_root), + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + outcome_type="Binary", + instance_label=instance_label, + n_splits=cv_splits, + categorical_features=str(feature_root / "hcc_survival_categorical_features.csv"), + quantitative_features=str(feature_root / "hcc_survival_quantitative_features.csv"), + force=True, + ) + p1.run() + + assert exp_root.is_dir(), "Phase 1 should create experiment directory" + ds_dir = pick_first_dataset_dir(exp_root) + + p2 = P2Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + instance_label=instance_label, + run_cluster="Serial", + ) + p2.run() + + p3 = P3Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + instance_label=instance_label, + run_cluster="Serial", + ) + p3.run() + + assert (ds_dir / "feature_learning").exists(), "Phase 3 should produce feature learning outputs" + + p4 = P4Runner( + output_path=str(output_root), + experiment_name=experiment_name, + models="mutualinformation,multiswrfdb", + models_params={"mutualinformation": {"outcome_type": "Binary"}, "multiswrfdb": {"n_jobs": 1}}, + outcome_label=outcome_label, + outcome_type="Binary", + instance_label=instance_label, + instance_subset=2000, + run_cluster="Serial", + ) + p4.run() + + fi_dir = ds_dir / "feature_importance" + assert fi_dir.exists(), "Phase 4 should write feature importance artifacts" + selector_path = fi_dir / "multiswrfdb" / "selector_cv0.pickle" + assert selector_path.is_file(), "Phase 4 should save the MultiSWRFDB selector payload" + with open(selector_path, "rb") as f: + selector_payload = pickle.load(f) + assert selector_payload["instance_subset"] == 2000 + + p5 = P5Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + instance_label=instance_label, + n_splits=cv_splits, + run_cluster="Serial", + ) + p5.run() + + assert (ds_dir / "feature_selection").exists(), "Phase 5 should write feature selection artifacts" + + p6_models = ["NB", "LR", "DT"] + + p6 = P6Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + outcome_type="Binary", + instance_label=instance_label, + n_splits=cv_splits, + models=",".join(p6_models), + calibrate=False, + scoring_metric="balanced_accuracy", + metric_direction="maximize", + n_trials=1, + timeout=15, + training_subsample=0, + uniform_fi=False, + save_plot=False, + random_state=42, + run_cluster="Serial", + ) + p6.run() + + models_dir = ds_dir / "models" / "pickledModels" + assert models_dir.is_dir(), "Phase 6 should create pickled base models" + assert list(models_dir.glob("*.pickle")), "Expected base model pickles" + + p7 = P7Runner( + output_path=str(output_root), + experiment_name=experiment_name, + n_splits=cv_splits, + outcome_label=outcome_label, + instance_label=instance_label, + ensembles="hard_voting,soft_voting,stack_lr", + base_models=",".join(p6_models), + meta_train_source="train", + calibrate=0, + calibrate_method="sigmoid", + calibrate_cv=3, + run_cluster="Serial", + queue="defq", + reserved_memory=4, + random_state=42, + ) + p7.run() + + ens_root = ds_dir / "ensemble_evaluation" + assert ens_root.is_dir(), "Phase 7 should create ensemble_evaluation directory" + assert list((ens_root / "pickled_ensembles").glob("*.pickle")), "Expected at least one ensemble pickle" + + p8 = P8Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + outcome_type="Binary", + instance_label=instance_label, + n_splits=cv_splits, + scoring_metric="balanced_accuracy", + top_features=10, + sig_cutoff=0.1, + metric_weight="balanced_accuracy", + scale_data=True, + exclude_plots=None, + show_plots=False, + run_cluster="Serial", + ) + p8.run() + + model_eval_dir = ds_dir / "model_evaluation" + assert (model_eval_dir / "Summary_performance_mean.csv").is_file(), \ + "Expected Summary_performance_mean.csv from Phase 8" + + p9 = P9Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + outcome_type="Binary", + instance_label=instance_label, + sig_cutoff=0.1, + show_plots=False, + run_cluster="Serial", + ) + p9.run() + + dc_root = exp_root / "DatasetComparisons" + assert dc_root.is_dir(), "Phase 9 should create DatasetComparisons directory" + assert any(dc_root.glob("*.csv")), "Expected at least one dataset comparison CSV" + + dataset_for_rep = data_root / "hcc_survival.csv" + p10 = P10Runner( + rep_data_path=str(rep_data_root), + dataset_for_rep=str(dataset_for_rep), + output_path=str(output_root), + experiment_name=experiment_name, + run_cluster="Serial", + show_plots=False, + ) + p10.run() + + rep_ds_dir = exp_root / dataset_for_rep.stem / "replication" / "hcc_survival_rep" + assert rep_ds_dir.is_dir(), "Phase 10 should create replication dataset directory" + assert (rep_ds_dir / "model_evaluation" / "Summary_performance_mean.csv").is_file(), \ + "Phase 10 should produce replication model evaluation summary" + + p11 = P11Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + outcome_type="Binary", + instance_label=instance_label, + run_cluster="Serial", + ) + p11.run() + + assert list(exp_root.glob("**/*.pdf")), "Phase 11 should produce at least one PDF report" + + p11_rep = P11Runner( + output_path=str(output_root), + experiment_name=experiment_name, + report_mode="replication", + outcome_label=outcome_label, + outcome_type="Binary", + instance_label=instance_label, + run_cluster="Serial", + ) + p11_rep.run() + + rep_report_json = exp_root / "reporting_replication" / "report_data.json" + rep_report_pdf = exp_root / "reporting_replication" / f"{experiment_name}_STREAMLINE_Replication_Report.pdf" + assert rep_report_json.is_file(), "Phase 11 replication mode should produce report_data.json" + assert rep_report_pdf.is_file(), "Phase 11 replication mode should produce an experiment-named replication PDF" diff --git a/streamline/tests/test_complete_multiclass.py b/streamline/tests/test_complete_multiclass.py new file mode 100644 index 00000000..6dce79c1 --- /dev/null +++ b/streamline/tests/test_complete_multiclass.py @@ -0,0 +1,335 @@ +# tests/test_full_streamline_demodata_pipeline.py + +import os +from pathlib import Path + +import pytest + +# pytest.skip("Tested Already", allow_module_level=True) + +# Phase runners - adjust import paths if your repo differs +from streamline.p1_data_process.p1_runner import P1Runner +from streamline.p2_impute_scale.p2_runner import P2Runner +from streamline.p3_feature_learning.p3_runner import P3Runner +from streamline.p4_feature_importance.p4_runner import P4Runner +from streamline.p5_feature_selection.p5_runner import P5Runner +from streamline.p6_modeling.p6_runner import P6Runner +from streamline.p7_ensembles.p7_runner import P7Runner +from streamline.p8_summary_statistics.p8_runner import P8Runner +from streamline.p9_compare_datasets.p9_runner import P9Runner +from streamline.p10_replication.p10_runner import P10Runner +from streamline.p11_reporting.p11_runner import P11Runner + + +@pytest.mark.integration +def test_full_streamline_pipeline_uci_multiclass(tmp_path: Path): + """ + End-to-end smoke test on the UCI Student Dropout multiclass demo data: + + P1: data process + P2: impute & scale + P3: feature learning + P4: feature importance + P5: feature selection + P6: modeling + P7: ensembles + P8: statistics + P9: dataset comparison + P10: replication + P11: reporting (standard + replication mode) + + This test intentionally keeps hyperparameters tiny / defaults where possible + to keep runtime reasonable and only asserts for the presence of key artifacts. + """ + + # --- Layout --------------------------------------------------------- + repo_root = Path(__file__).resolve().parent.parent.parent + tmp_path = repo_root / "test" + data_root = repo_root / "data" / "UCIMulticlassClassification" + feature_root = repo_root / "data" / "UCIFeatureTypes" + assert data_root.is_dir(), f"Expected UCI multiclass data under {data_root}" + + output_root = tmp_path / "out_full_pipeline" + experiment_name = "UCIStudentDropoutExp" + cv_splits = 3 + + # P1 may create experiment folder itself; ensure parent exists + output_root.mkdir(parents=True, exist_ok=True) + + # Convenience handle + exp_root = output_root / experiment_name + + # ------------------------------------------------------------------ + # Phase 1: Data processing + # ------------------------------------------------------------------ + p1 = P1Runner( + data_path=str(data_root), + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label="Class", + outcome_type="Multiclass", + instance_label="InstanceID", + n_splits=cv_splits, + categorical_features=str(feature_root / "student_dropout_categorical_features.csv"), + quantitative_features=str(feature_root / "student_dropout_quantitative_features.csv"), + force=True + # any other args you normally pass can be added here + ) + p1.run() + + assert exp_root.is_dir(), "Phase 1 should create experiment directory" + # At least one dataset directory with CVDatasets must exist + datasets = [ + d for d in exp_root.iterdir() + if d.is_dir() and (d / "CVDatasets").is_dir() + ] + assert datasets, "Expected at least one dataset with CVDatasets after Phase 1" + ds_dir = datasets[0] # use first dataset as canonical for downstream sanity checks + + # ------------------------------------------------------------------ + # Phase 2: Impute & scale + # ------------------------------------------------------------------ + p2 = P2Runner( + output_path=str(output_root), + experiment_name=experiment_name, + instance_label="InstanceID", + # use defaults for impute/scale options + run_cluster="Serial", + ) + p2.run() + + datasets = [ + d for d in exp_root.iterdir() + if d.is_dir() and (d / "CVDatasets").is_dir() + ] + assert datasets, "Expected at least one dataset with CVDatasets after Phase 1" + ds_dir = datasets[0] # use first dataset as canonical for downstream sanity checks + + # Minimal sanity check: preprocessed data should exist (implementation-dependent) + # assert (ds_dir / "ScaledData").exists() or (ds_dir / "ScaledData.csv").exists(), \ + # "Phase 2 should produce scaled/imputed data artifacts" + + # ------------------------------------------------------------------ + # Phase 3: Feature learning + # ------------------------------------------------------------------ + p3 = P3Runner( + output_path=str(output_root), + experiment_name=experiment_name, + instance_label="InstanceID", + run_cluster="Serial", + ) + p3.run() + + # Sanity: something like learned features / representation dir + # Adjust name if your implementation differs + assert any( + (ds_dir / sub).exists() + for sub in ["feature_learning"] + ), "Phase 3 should produce some feature learning outputs" + + # ------------------------------------------------------------------ + # Phase 4: Feature importance + # ------------------------------------------------------------------ + p4 = P4Runner( + output_path=str(output_root), + experiment_name=experiment_name, + models="mutualinformation,multiswrfdb", + models_params={"mutualinformation": {"outcome_type": "Multiclass"}, "multiswrfdb": {"n_jobs": 1}}, + instance_label="InstanceID", + instance_subset=2000, + run_cluster="Serial", + ) + p4.run() + + # There should be FI outputs of some kind + assert (ds_dir / "feature_importance").exists() or ( + ds_dir / "model_evaluation" / "feature_importance" + ).exists(), "Phase 4 should write feature importance artifacts" + + # ------------------------------------------------------------------ + # Phase 5: Feature selection + # ------------------------------------------------------------------ + p5 = P5Runner( + output_path=str(output_root), + experiment_name=experiment_name, + instance_label="InstanceID", + n_splits=cv_splits, + run_cluster="Serial", + ) + p5.run() + + # Check for feature selection outputs (e.g., SelectedFeatures.csv or similar) + fs_dir_candidates = [ + ds_dir / "feature_selection", + ] + assert any(d.exists() for d in fs_dir_candidates), \ + "Phase 5 should write feature selection artifacts" + + # ------------------------------------------------------------------ + # Phase 6: Modeling + # ------------------------------------------------------------------ + # Use a small model set + tiny search to keep tests fast, similar to earlier tests + p6_models = ["NB", "LR", "DT"] + + p6 = P6Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label="Class", + model_type="Multiclass", + instance_label="InstanceID", + n_splits=cv_splits, + models=",".join(p6_models), + calibrate=False, + scoring_metric="balanced_accuracy", + metric_direction="maximize", + n_trials=2, + timeout=15, + training_subsample=0, + uniform_fi=False, + save_plot=False, + random_state=42, + run_cluster="Serial", + ) + p6.run() + + models_dir = ds_dir / "models" / "pickledModels" + assert models_dir.is_dir(), "Phase 6 should create pickled base models" + assert list(models_dir.glob("*.pickle")), "Expected base model pickles" + + # ------------------------------------------------------------------ + # Phase 7: Ensembles + # ------------------------------------------------------------------ + p7 = P7Runner( + output_path=str(output_root), + experiment_name=experiment_name, + n_splits=cv_splits, + outcome_label="Class", + instance_label="InstanceID", + ensembles="hard_voting,soft_voting,stack_lr", + base_models=",".join(p6_models), + meta_train_source="train", + calibrate=0, + calibrate_method="sigmoid", + calibrate_cv=3, + run_cluster="Serial", + queue="defq", + reserved_memory=4, + random_state=42, + ) + p7.run() + + ens_root = ds_dir / "ensemble_evaluation" + assert ens_root.is_dir(), "Phase 7 should create ensemble_evaluation directory" + assert (ens_root / "pickled_ensembles").is_dir(), "Expected pickled ensembles" + assert list((ens_root / "pickled_ensembles").glob("*.pickle")), \ + "Expected at least one ensemble pickle from Phase 7" + + # ------------------------------------------------------------------ + # Phase 8: Statistics (per-dataset, base + ensembles) + # ------------------------------------------------------------------ + p8 = P8Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label="Class", + outcome_type="Multiclass", + instance_label="InstanceID", + n_splits=cv_splits, + scoring_metric="balanced_accuracy", + top_features=10, + sig_cutoff=0.1, + metric_weight="balanced_accuracy", + scale_data=True, + exclude_plots=None, + show_plots=False, + run_cluster="Serial", + ) + p8.run() + + model_eval_dir = ds_dir / "model_evaluation" + assert model_eval_dir.is_dir() + assert (model_eval_dir / "Summary_performance_mean.csv").is_file(), \ + "Expected Summary_performance_mean.csv from Phase 8" + + # Ensemble summaries + ens_summary_csvs = list(ens_root.glob("Ensembles*_performance_*.csv")) + assert ens_summary_csvs, "Expected ensemble performance summary CSVs in Phase 8" + + # ------------------------------------------------------------------ + # Phase 9: Dataset-level comparison + # ------------------------------------------------------------------ + p9 = P9Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label="Class", + outcome_type="Multiclass", + instance_label="InstanceID", + sig_cutoff=0.1, + show_plots=False, + run_cluster="Serial", + ) + p9.run() + + dc_root = exp_root / "DatasetComparisons" + assert dc_root.is_dir(), "Phase 9 should create DatasetComparisons directory" + # e.g. Kruskal / Mann-Whitney outputs + assert any(dc_root.glob("*.csv")), "Expected at least one dataset comparison CSV" + + # ------------------------------------------------------------------ + # Phase 10: Replication (whatever semantics you defined) + # ------------------------------------------------------------------ + rep_data_root = repo_root / "data" / "UCIRepMulticlassClassification" + assert rep_data_root.is_dir(), f"Expected UCI multiclass replication data under {rep_data_root}" + + dataset_for_rep = data_root / "student_dropout_academic_success.csv" + assert dataset_for_rep.is_file(), f"Expected training dataset file at {dataset_for_rep}" + + p10 = P10Runner( + rep_data_path=str(rep_data_root), + dataset_for_rep=str(dataset_for_rep), + output_path=str(output_root), + experiment_name=experiment_name, + run_cluster="Serial", + show_plots=False, + ) + p10.run() + + rep_root = exp_root / dataset_for_rep.stem / "replication" + rep_ds_dir = rep_root / "student_dropout_academic_success_rep" + assert rep_root.is_dir(), "Phase 10 should create replication directory under training dataset" + assert rep_ds_dir.is_dir(), "Phase 10 should create replication dataset directory" + assert (rep_ds_dir / "model_evaluation" / "Summary_performance_mean.csv").is_file(), \ + "Phase 10 should produce replication model evaluation summary" + + # ------------------------------------------------------------------ + # Phase 11: Reporting (Streamlit-based report rendered via WeasyPrint) + # ------------------------------------------------------------------ + p11 = P11Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label="Class", + outcome_type="Multiclass", + instance_label="InstanceID", + run_cluster="Serial", + ) + p11.run() + + # Expect at least a PDF under the experiment root + pdf_candidates = list(exp_root.glob("**/*.pdf")) + assert pdf_candidates, "Phase 11 should produce at least one PDF report" + + # Replication reporting mode (Phase 11) + p11_rep = P11Runner( + output_path=str(output_root), + experiment_name=experiment_name, + report_mode="replication", + outcome_label="Class", + outcome_type="Multiclass", + instance_label="InstanceID", + run_cluster="Serial", + ) + p11_rep.run() + + rep_report_json = exp_root / "reporting_replication" / "report_data.json" + rep_report_pdf = exp_root / "reporting_replication" / f"{experiment_name}_STREAMLINE_Replication_Report.pdf" + assert rep_report_json.is_file(), "Phase 11 replication mode should produce report_data.json" + assert rep_report_pdf.is_file(), "Phase 11 replication mode should produce an experiment-named replication PDF" diff --git a/streamline/tests/test_complete_regression.py b/streamline/tests/test_complete_regression.py new file mode 100644 index 00000000..869a97a8 --- /dev/null +++ b/streamline/tests/test_complete_regression.py @@ -0,0 +1,377 @@ +# tests/test_full_streamline_demodata_regression_pipeline.py + +from __future__ import annotations + +import os +from pathlib import Path +from typing import Iterable, Optional + +import pytest + +# pytest.skip("Tested Already", allow_module_level=True) + +# Phase runners - adjust import paths if your repo differs +from streamline.p1_data_process.p1_runner import P1Runner +from streamline.p2_impute_scale.p2_runner import P2Runner +from streamline.p3_feature_learning.p3_runner import P3Runner +from streamline.p4_feature_importance.p4_runner import P4Runner +from streamline.p5_feature_selection.p5_runner import P5Runner +from streamline.p6_modeling.p6_runner import P6Runner +from streamline.p7_ensembles.p7_runner import P7Runner +from streamline.p8_summary_statistics.p8_runner import P8Runner +from streamline.p9_compare_datasets.p9_runner import P9Runner +from streamline.p10_replication.p10_runner import P10Runner +from streamline.p11_reporting.p11_runner import P11Runner + +SKIP_TILL_MODELING_PHASES = os.getenv("STREAMLINE_SKIP_TO_REGRESSION_PHASE8", "0").strip().lower() in {"1", "true", "yes"} + + +def _pick_first_dataset_dir(exp_root: Path) -> Path: + """ + STREAMLINE phase outputs typically look like: + ///CVDatasets/... + """ + datasets = [ + d for d in exp_root.iterdir() + if d.is_dir() and (d / "CVDatasets").is_dir() + ] + assert datasets, f"Expected at least one dataset with CVDatasets under {exp_root}" + return sorted(datasets)[0] + + +def _exists_any(path_candidates: Iterable[Path]) -> bool: + return any(p.exists() for p in path_candidates) + + +@pytest.mark.integration +def test_full_streamline_pipeline_demodata_regression(tmp_path: Path): + """ + End-to-end smoke test on the UCI Auto MPG regression demo data. + + P1: data process + P2: impute & scale + P3: feature learning + P4: feature importance + P5: feature selection + P6: modeling (Regression) + P7: ensembles (Regression-capable) + P8: statistics + P9: dataset comparison + P10: replication + P11: reporting (standard + replication mode) + + Notes: + - Set STREAMLINE_SKIP_TO_REGRESSION_PHASE8=1 only when precomputed outputs already exist. + """ + + # --- Layout --------------------------------------------------------- + outcome_label = "MPG" + instance_label = "InstanceID" + + repo_root = Path(__file__).resolve().parent.parent.parent + tmp_path = repo_root / "test" + data_root = repo_root / "data" / "UCIRegression" + feature_root = repo_root / "data" / "UCIFeatureTypes" + assert data_root.is_dir(), f"Expected UCI regression data under {data_root}" + + output_root = tmp_path / "out_full_uci_regression_pipeline" + experiment_name = "UCIAutoMPGRegression" + cv_splits = 3 + output_root.mkdir(parents=True, exist_ok=True) + exp_root = output_root / experiment_name + + if not SKIP_TILL_MODELING_PHASES: + + # ------------------------------------------------------------------ + # Phase 1: Data processing + # ------------------------------------------------------------------ + p1 = P1Runner( + data_path=str(data_root), + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + outcome_type="Continuous", + instance_label=instance_label, + n_splits=cv_splits, + categorical_features=str(feature_root / "auto_mpg_categorical_features.csv"), + quantitative_features=str(feature_root / "auto_mpg_quantitative_features.csv"), + force=True, + ) + p1.run() + + assert exp_root.is_dir(), "Phase 1 should create experiment directory" + ds_dir = _pick_first_dataset_dir(exp_root) + + # assert False, "Intentional stop after Phase 1 for testing purposes; comment out to run full pipeline" + + # ------------------------------------------------------------------ + # Phase 2: Impute & scale + # ------------------------------------------------------------------ + p2 = P2Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + instance_label=instance_label, + run_cluster="Serial", + ) + p2.run() + + ds_dir = _pick_first_dataset_dir(exp_root) + + # (Optional) sanity: some scaled/imputed artifacts exist (names vary by implementation) + scaled_candidates = [ + ds_dir / "impute_scale", + ] + # Don't hard-fail if your code writes elsewhere; comment in if you want stricter checks: + # assert _exists_any(scaled_candidates), "Phase 2 should produce scaled/imputed artifacts" + + # ------------------------------------------------------------------ + # Phase 3: Feature learning + # ------------------------------------------------------------------ + p3 = P3Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + instance_label=instance_label, + run_cluster="Serial", + ) + p3.run() + + assert _exists_any([ds_dir / "feature_learning"]), "Phase 3 should produce feature learning outputs" + + # ------------------------------------------------------------------ + # Phase 4: Feature importance + # ------------------------------------------------------------------ + p4 = P4Runner( + output_path=str(output_root), + experiment_name=experiment_name, + models="mutualinformation,multiswrfdb", + models_params={"mutualinformation": {"outcome_type": "Continuous"}, "multiswrfdb": {"n_jobs": 1}}, + outcome_label=outcome_label, + outcome_type="Continuous", + instance_label=instance_label, + instance_subset=2000, + run_cluster="Serial", + ) + p4.run() + + assert _exists_any([ + ds_dir / "feature_importance", + ds_dir / "model_evaluation" / "feature_importance", + ]), "Phase 4 should write feature importance artifacts" + + # ------------------------------------------------------------------ + # Phase 5: Feature selection + # ------------------------------------------------------------------ + p5 = P5Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + instance_label=instance_label, + n_splits=cv_splits, + run_cluster="Serial", + ) + p5.run() + + assert _exists_any([ds_dir / "feature_selection"]), "Phase 5 should write feature selection artifacts" + + # ------------------------------------------------------------------ + # Phase 6: Modeling (Regression) + # ------------------------------------------------------------------ + # Keep runtime tiny: small model set + tiny Optuna search + # + # Adjust 'models=' to whatever your regression registry supports. + # Common STREAMLINE abbreviations often include: LR, RF, SVR, EN (ElasticNet), LASSO, RIDGE, XGB, etc. + p6_models = ["LR", "RF", "SVR"] + + p6 = P6Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + model_type="Regression", + instance_label=instance_label, + n_splits=cv_splits, + models=",".join(p6_models), + calibrate=False, # usually not relevant for regression; harmless if ignored + scoring_metric="neg_mean_squared_error", # prefix with 'neg_' if using sklearn convention, don't change direction + metric_direction="maximize", + n_trials=1, + timeout=15, + training_subsample=0, + uniform_fi=False, + save_plot=False, + random_state=42, + run_cluster="Serial", + ) + p6.run() + + models_dir = ds_dir / "models" / "pickledModels" + assert models_dir.is_dir(), "Phase 6 should create pickled base models" + assert list(models_dir.glob("*.pickle")), "Expected base model pickles" + + # ------------------------------------------------------------------ + # Phase 7: Ensembles (Regression) + # ------------------------------------------------------------------ + # If your ensemble phase is classification-only, you can skip by setting: + # STREAMLINE_SKIP_REGRESSION_ENSEMBLES=1 + # if os.getenv("STREAMLINE_SKIP_REGRESSION_ENSEMBLES", "0").strip() not in {"1", "true", "True"}: + # p7 = P7Runner( + # output_path=str(output_root), + # experiment_name=experiment_name, + # n_splits=cv_splits, + # outcome_label=outcome_label, + # instance_label=instance_label, + # # Choose ensembles likely to generalize to regression; adjust to your implementation. + # ensembles="hard_voting,soft_voting,stack_lr", + # base_models="LR,RF,SVR", + # meta_train_source="train", + # calibrate=0, + # calibrate_method="sigmoid", + # calibrate_cv=3, + # run_cluster="Serial", + # queue="defq", + # reserved_memory=4, + # random_state=42, + # ) + # p7.run() + + # ens_root = ds_dir / "ensemble_evaluation" + # assert ens_root.is_dir(), "Phase 7 should create ensemble_evaluation directory" + # assert (ens_root / "pickled_ensembles").is_dir(), "Expected pickled ensembles" + # assert list((ens_root / "pickled_ensembles").glob("*.pickle")), \ + # "Expected at least one ensemble pickle from Phase 7" + else: + print("Skipping directly to Phase 8+ for faster testing of later phases") + assert exp_root.is_dir(), "Phase 1 should create experiment directory" + ds_dir = _pick_first_dataset_dir(exp_root) + + # (Optional) sanity: some scaled/imputed artifacts exist (names vary by implementation) + scaled_candidates = [ + ds_dir / "impute_scale", + ] + # Don't hard-fail if your code writes elsewhere; comment in if you want stricter checks: + # assert _exists_any(scaled_candidates), "Phase 2 should produce scaled/imputed artifacts" + + assert _exists_any([ds_dir / "feature_learning"]), "Phase 3 should produce feature learning outputs" + + assert _exists_any([ + ds_dir / "feature_importance", + ds_dir / "model_evaluation" / "feature_importance", + ]), "Phase 4 should write feature importance artifacts" + + assert _exists_any([ds_dir / "feature_selection"]), "Phase 5 should write feature selection artifacts" + + models_dir = ds_dir / "models" / "pickledModels" + assert models_dir.is_dir(), "Phase 6 should create pickled base models" + assert list(models_dir.glob("*.pickle")), "Expected base model pickles" + + # ens_root = ds_dir / "ensemble_evaluation" + # assert ens_root.is_dir(), "Phase 7 should create ensemble_evaluation directory" + # assert (ens_root / "pickled_ensembles").is_dir(), "Expected pickled ensembles" + # assert list((ens_root / "pickled_ensembles").glob("*.pickle")), \ + # "Expected at least one ensemble pickle from Phase 7" + + # ------------------------------------------------------------------ + # Phase 8: Statistics + # ------------------------------------------------------------------ + + p8 = P8Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + outcome_type="Continuous", + instance_label=instance_label, + n_splits=cv_splits, + scoring_metric="mean_squared_error", + top_features=10, + sig_cutoff=0.1, + metric_weight="mean_squared_error", + scale_data=True, + exclude_plots=None, + show_plots=False, + run_cluster="Serial", + ) + p8.run() + + model_eval_dir = ds_dir / "model_evaluation" + assert model_eval_dir.is_dir(), "Phase 8 should create model_evaluation directory" + assert (model_eval_dir / "Summary_performance_mean.csv").is_file(), \ + "Expected Summary_performance_mean.csv from Phase 8" + + # ------------------------------------------------------------------ + # Phase 9: Dataset-level comparison + # ------------------------------------------------------------------ + p9 = P9Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + outcome_type="Continuous", + instance_label=instance_label, + sig_cutoff=0.1, + show_plots=False, + run_cluster="Serial", + ) + p9.run() + + dc_root = exp_root / "DatasetComparisons" + assert dc_root.is_dir(), "Phase 9 should create DatasetComparisons directory" + assert any(dc_root.glob("*.csv")), "Expected at least one dataset comparison CSV" + + # ------------------------------------------------------------------ + # Phase 10: Replication + # ------------------------------------------------------------------ + rep_data_root = repo_root / "data" / "UCIRepRegression" + assert rep_data_root.is_dir(), f"Expected UCI regression replication data under {rep_data_root}" + + dataset_for_rep = data_root / "auto_mpg.csv" + assert dataset_for_rep.is_file(), f"Expected training dataset file at {dataset_for_rep}" + + p10 = P10Runner( + rep_data_path=str(rep_data_root), + dataset_for_rep=str(dataset_for_rep), + output_path=str(output_root), + experiment_name=experiment_name, + run_cluster="Serial", + show_plots=False, + ) + p10.run() + + rep_root = exp_root / dataset_for_rep.stem / "replication" + rep_ds_dir = rep_root / "auto_mpg_rep" + assert rep_root.is_dir(), "Phase 10 should create replication directory under training dataset" + assert rep_ds_dir.is_dir(), "Phase 10 should create replication dataset directory" + assert (rep_ds_dir / "model_evaluation" / "Summary_performance_mean.csv").is_file(), \ + "Phase 10 should produce replication model evaluation summary" + + # ------------------------------------------------------------------ + # Phase 11: Reporting + # ------------------------------------------------------------------ + p11 = P11Runner( + output_path=str(output_root), + experiment_name=experiment_name, + outcome_label=outcome_label, + outcome_type="Continuous", + instance_label=instance_label, + run_cluster="Serial", + ) + p11.run() + + pdf_candidates = list(exp_root.glob("**/*.pdf")) + assert pdf_candidates, "Phase 11 should produce at least one PDF report" + + # Replication reporting mode (Phase 11) + p11_rep = P11Runner( + output_path=str(output_root), + experiment_name=experiment_name, + report_mode="replication", + outcome_label=outcome_label, + outcome_type="Continuous", + instance_label=instance_label, + run_cluster="Serial", + ) + p11_rep.run() + + rep_report_json = exp_root / "reporting_replication" / "report_data.json" + rep_report_pdf = exp_root / "reporting_replication" / f"{experiment_name}_STREAMLINE_Replication_Report.pdf" + assert rep_report_json.is_file(), "Phase 11 replication mode should produce report_data.json" + assert rep_report_pdf.is_file(), "Phase 11 replication mode should produce an experiment-named replication PDF" diff --git a/streamline/utils/checker.py b/streamline/utils/checker.py deleted file mode 100644 index c6e303ca..00000000 --- a/streamline/utils/checker.py +++ /dev/null @@ -1,207 +0,0 @@ -import os -import glob -import pickle -from pathlib import Path - - -def check_phase_1(output_path, experiment_name, datasets): - phase1_jobs = [] - for dataset in datasets: - phase1_jobs.append('job_exploratory_' + dataset + '.txt') - for filename in glob.glob(output_path + "/" + experiment_name + '/jobsCompleted/job_exploratory*'): - filename = str(Path(filename).as_posix()) - ref = filename.split('/')[-1] - phase1_jobs.remove(ref) - return phase1_jobs - - -def check_phase_2(output_path, experiment_name, datasets): - file = open(output_path + '/' + experiment_name + '/' + "metadata.pickle", 'rb') - cv_partitions = pickle.load(file)['CV Partitions'] - file.close() - - phase2_jobs = [] - for dataset in datasets: - for cv in range(cv_partitions): - phase2_jobs.append('job_preprocessing_' + dataset + '_' + str(cv) + '.txt') - - for filename in glob.glob(output_path + "/" + experiment_name + '/jobsCompleted/job_preprocessing*'): - filename = str(Path(filename).as_posix()) - ref = filename.split('/')[-1] - phase2_jobs.remove(ref) - return phase2_jobs - - -def check_phase_3(output_path, experiment_name, datasets): - file = open(output_path + '/' + experiment_name + '/' + "metadata.pickle", 'rb') - metadata = pickle.load(file) - file.close() - cv_partitions = metadata['CV Partitions'] - do_multisurf = metadata['Use Mutual Information'] - do_mutual_info = metadata['Use MultiSURF'] - - phase3_jobs = [] - for dataset in datasets: - for cv in range(cv_partitions): - if do_multisurf: - phase3_jobs.append('job_multisurf_' + dataset + '_' + str(cv) + '.txt') - if do_mutual_info: - phase3_jobs.append('job_mutual_information_' + dataset + '_' + str(cv) + '.txt') - - for filename in glob.glob(output_path + "/" + experiment_name + '/jobsCompleted/job_mu*'): - filename = str(Path(filename).as_posix()) - ref = filename.split('/')[-1] - phase3_jobs.remove(ref) - return phase3_jobs - - -def check_phase_4(output_path, experiment_name, datasets): - phase4_jobs = [] - for dataset in datasets: - phase4_jobs.append('job_featureselection_' + dataset + '.txt') - - for filename in glob.glob(output_path + "/" + experiment_name + '/jobsCompleted/job_featureselection*'): - filename = str(Path(filename).as_posix()) - ref = filename.split('/')[-1] - phase4_jobs.remove(ref) - return phase4_jobs - - -def check_phase_5(output_path, experiment_name, datasets): - try: - file = open(output_path + '/' + experiment_name + '/' + "metadata.pickle", 'rb') - cv_partitions = pickle.load(file)['CV Partitions'] - file.close() - - pickle_in = open(output_path + '/' + experiment_name + '/' + "algInfo.pickle", 'rb') - alg_info = pickle.load(pickle_in) - algorithms = list() - ABBREVIATION = dict() - for algorithm in alg_info.keys(): - ABBREVIATION[algorithm] = alg_info[algorithm][1] - if alg_info[algorithm][0]: - algorithms.append(algorithm) - pickle_in.close() - phase5_jobs = [] - for dataset in datasets: - for cv in range(cv_partitions): - for algorithm in algorithms: - phase5_jobs.append('job_model_' + dataset + '_' + str(cv) + '_' + ABBREVIATION[algorithm] + '.txt') - - for filename in glob.glob(output_path + "/" + experiment_name + '/jobsCompleted/job_model*'): - filename = str(Path(filename).as_posix()) - ref = filename.split('/')[-1] - phase5_jobs.remove(ref) - return phase5_jobs - except Exception: - return ['NOT REACHED YET'] - - -def check_phase_6(output_path, experiment_name, datasets): - phase6_jobs = [] - for dataset in datasets: - phase6_jobs.append('job_stats_' + dataset + '.txt') - - for filename in glob.glob(output_path + "/" + experiment_name + '/jobsCompleted/job_stats*'): - filename = str(Path(filename).as_posix()) - ref = filename.split('/')[-1] - phase6_jobs.remove(ref) - return phase6_jobs - - -def check_phase_7(output_path, experiment_name, datasets=None): - for filename in glob.glob(output_path + "/" + experiment_name + '/jobsCompleted/job_data_compare*'): - filename = str(Path(filename).as_posix()) - if filename.split('/')[-1] == 'job_data_compare.txt': - return [] - else: - return ['job_data_compare.txt'] - return ['job_data_compare.txt'] - - -def check_phase_8(output_path, experiment_name, datasets=None): - # Make pdf summary for training analysis - for filename in glob.glob(output_path + "/" + experiment_name - + '/jobsCompleted/job_data_pdf_training*'): - filename = str(Path(filename).as_posix()) - if filename.split('/')[-1] == 'job_data_pdf_training.txt': - return [] - else: - return ['job_data_pdf_training.txt'] - return ['job_data_pdf_training.txt'] - - -def check_phase_9(output_path, experiment_name, rep_data_path): - phase9_jobs = [] - for dataset_filename in glob.glob(rep_data_path + '/*'): - dataset_filename = str(Path(dataset_filename).as_posix()) - apply_name = dataset_filename.split('/')[-1].split('.')[0] - phase9_jobs.append('job_apply_' + str(apply_name)) - for filename in glob.glob(output_path + "/" + experiment_name + '/jobsCompleted/job_apply*'): - filename = str(Path(filename).as_posix()) - ref = filename.split('/')[-1].split('.')[0] - try: - phase9_jobs.remove(ref) - except ValueError: - pass - return phase9_jobs - - -def check_phase_10(output_path, experiment_name, dataset_for_rep): - # Make pdf summary for application analysis - train_name = dataset_for_rep.split('/')[-1].split('.')[0] - for filename in glob.glob(output_path + "/" + experiment_name - + '/jobsCompleted/job_data_pdf_apply_' + str(train_name) + '*'): - filename = str(Path(filename).as_posix()) - if filename.split('/')[-1] == 'job_data_pdf_apply_' + str(train_name) + '.txt': - return [] - else: - return ['job_data_pdf_apply_' + str(train_name) + '.txt'] - return ['job_data_pdf_apply_' + str(train_name) + '.txt'] - - -def check_phase_11(output_path, experiment_name): - # Check if clean job is done - not_deleted = list(glob.glob(output_path + "/" + experiment_name + '/jobsCompleted/*')) + \ - list(glob.glob(output_path + "/" + experiment_name + '/jobs/*')) - not_deleted = [str(Path(path)) for path in not_deleted] - return not_deleted - - -FN_LIST = [check_phase_1, check_phase_2, check_phase_3, check_phase_4, - check_phase_5, check_phase_6, check_phase_7, check_phase_8, - check_phase_9, check_phase_10, check_phase_11] - - -def check_phase(output_path, experiment_name, phase=5, len_only=True, - rep_data_path=None, dataset_for_rep=None, output=True): - datasets = os.listdir(output_path + "/" + experiment_name) - remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle', - 'jobsCompleted', 'dask_logs', 'logs', 'jobs', - 'DatasetComparisons', 'UsefulNotebooks', - experiment_name + '_STREAMLINE_Report.pdf'] - for text in remove_list: - if text in datasets: - datasets.remove(text) - - if phase < 9: - phase_jobs = FN_LIST[phase - 1](output_path, experiment_name, datasets) - elif phase == 9: - phase_jobs = FN_LIST[phase - 1](output_path, experiment_name, rep_data_path) - elif phase == 10: - phase_jobs = FN_LIST[phase - 1](output_path, experiment_name, dataset_for_rep) - elif phase == 11: - phase_jobs = FN_LIST[phase - 1](output_path, experiment_name) - else: - raise Exception("Unknown Phase") - - if output: - if len(phase_jobs) == 0: - print("All Phase " + str(phase) + " Jobs Completed") - elif len_only: - print(str(len(phase_jobs)) + " Phase " + str(phase) + " Jobs Left") - else: - print("Below Phase " + str(phase) + " Jobs Not Completed:") - for job in phase_jobs: - print(job) - return phase_jobs diff --git a/streamline/utils/cleanup.py b/streamline/utils/cleanup.py deleted file mode 100644 index 61ccfc36..00000000 --- a/streamline/utils/cleanup.py +++ /dev/null @@ -1,124 +0,0 @@ -import sys -import os -import shutil -import glob -import argparse -from pathlib import Path - - -class Cleaner: - """ - Phase 11 of STREAMLINE (Optional)- This 'Main' script runs Phase 11 which deletes all - temporary files in pipeline output folder. - This script is not necessary to run, but serves as a convenience to reduce - space and clutter following a pipeline run. - """ - - def __init__(self, output_path, experiment_name, del_time=True, del_old_cv=True): - """ - Cleaner Class - Args: - output_path: path to output directory - experiment_name: name of experiment output folder (no spaces) - del_time: delete individual run-time files (but save summary), default=True - del_old_cv: delete any of the older versions of CV training and \ - testing datasets not overwritten (preserves final training and testing datasets, default=True - """ - - self.output_path = output_path - self.experiment_name = experiment_name - self.experiment_path = self.output_path + '/' + self.experiment_name - self.del_time = del_time - self.del_old_cv = del_old_cv - - if self.del_time == 'False' or self.del_time == False: - self.del_time == False - else: - self.del_time == True - if self.del_old_cv == 'False' or self.del_old_cv == False: - self.del_old_cv == False - else: - self.del_old_cv == True - - if not os.path.exists(self.output_path): - raise Exception("Provided output_path does not exist") - if not os.path.exists(self.experiment_path): - raise Exception("Provided experiment name in given output_path does not exist") - - def run(self): - # Get dataset paths for all completed dataset analyses in experiment folder - datasets = os.listdir(self.experiment_path) - remove_list = ['.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle', - 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs', - 'KeyFileCopy', 'dask_logs', - self.experiment_name + '_STREAMLINE_Report.pdf'] - for text in remove_list: - if text in datasets: - datasets.remove(text) - - # Delete log folder/files - self.rm_tree(self.experiment_path + '/' + 'logs') - # Delete job folder/files - self.rm_tree(self.experiment_path + '/' + 'jobs') - # Delete jobscompleted folder/files - self.rm_tree(self.experiment_path + '/' + 'jobsCompleted') - - # Remake folders (empty) incase user wants to rerun scripts like pdf report from command line - os.mkdir(self.experiment_path + '/jobsCompleted') - os.mkdir(self.experiment_path + '/jobs') - os.mkdir(self.experiment_path + '/logs') - - # Delete target files within each dataset subfolder - for dataset in datasets: - # Delete individual runtime files (save runtime summary generated in phase 6) - if self.del_time: - self.rm_tree(self.experiment_path + '/' + dataset + '/' + 'runtime') - - # Delete temporary feature importance pickle files - # (only needed for phase 4 and then saved as summary files in phase 6) - self.rm_tree(self.experiment_path + '/' + dataset + '/feature_selection/mutualinformation/pickledForPhase4') - self.rm_tree(self.experiment_path + '/' + dataset + '/feature_selection/multisurf/pickledForPhase4') - - # Delete older training and testing CV datasets (does not delete any - # final versions used for training). Older cv datasets might have been - # kept to see what they look like prior to preprocessing and feature selection. - if self.del_old_cv: - # Delete CV files generated after preprocessing but before feature selection - files = glob.glob(self.experiment_path + '/' + dataset + '/CVDatasets/*CVOnly*') - files = [str(Path(path)) for path in files] - for f in files: - self.rm_tree(f, False) - # Delete CV files generated after CV partitioning but before preprocessing - files = glob.glob(self.experiment_path + '/' + dataset + '/CVDatasets/*CVPre*') - files = [str(Path(path)) for path in files] - for f in files: - self.rm_tree(f, False) - - @staticmethod - def rm_tree(path, folder=True): - try: - if folder: - if os.path.exists(path): - shutil.rmtree(path) - else: - os.remove(path) - except Exception: - pass - - -if __name__ == '__main__': - parser = argparse.ArgumentParser(description="") - # No defaults - parser.add_argument('--out-path', dest='output_path', type=str, help='path to output directory') - parser.add_argument('--exp-name', dest='experiment_name', type=str, - help='name of experiment output folder (no spaces)') - parser.add_argument('--del-time', dest='del_time', type=str, - help='delete individual run-time files (but save summary)', default="True") - parser.add_argument('--del-oldCV', dest='del_old_cv', type=str, - help='delete any of the older versions of CV training and testing datasets not overwritten (' - 'preserves final training and testing datasets)', - default="True") - - options = parser.parse_args(sys.argv[1:]) - cleaner = Cleaner(options.output_path, options.experiment_name, - options.del_time, options.del_old_cv) diff --git a/streamline/utils/cluster.py b/streamline/utils/cluster.py index 26b4dc3b..abbd2b50 100644 --- a/streamline/utils/cluster.py +++ b/streamline/utils/cluster.py @@ -1,3 +1,4 @@ +import dask from dask.distributed import Client from dask_jobqueue import SLURMCluster, LSFCluster, SGECluster from dask_jobqueue import HTCondorCluster, MoabCluster, OARCluster, PBSCluster diff --git a/streamline/utils/dataset.py b/streamline/utils/dataset.py deleted file mode 100644 index 000b1d1a..00000000 --- a/streamline/utils/dataset.py +++ /dev/null @@ -1,355 +0,0 @@ -import csv -import logging -import os - -import numpy as np -import pandas as pd -import matplotlib.pyplot as plt -import seaborn as sns - -sns.set_theme() - - -class Dataset: - def __init__(self, dataset_path, class_label, match_label=None, instance_label=None): - """ - Creates dataset with path of tabular file - - Args: - dataset_path: path of tabular file (as csv, tsv, or txt) - class_label: column label for the outcome to be predicted in the dataset - match_label: column to identify unique groups of instances in the dataset \ - that have been 'matched' as part of preparing the dataset with cases and controls \ - that have been matched for some co-variates \ - Match label is really only used in the cross validation partitioning \ - It keeps any set of instances with the same match label value in the same partition. - instance_label: Instance label is mostly used by the rule based learner in modeling, \ - we use it to trace back heterogeneous subgroups to the instances in the original dataset - - """ - self.data = None - self.path = dataset_path - self.name = self.path.split('/')[-1].split('.')[0] - self.format = self.path.split('/')[-1].split('.')[-1] - self.class_label = class_label - self.match_label = match_label - self.instance_label = instance_label - self.categorical_variables = None - self.quantitative_variables = None - self.load_data() - - def load_data(self): - """ - Function to load data in dataset - """ - logging.info("------------------------------------------------------- ") - logging.info("Loading Dataset: " + str(self.name)) - if self.format == 'csv': - self.data = pd.read_csv(self.path, na_values='NA', sep=',') - elif self.format == 'tsv': - self.data = pd.read_csv(self.path, na_values='NA', sep='\t') - elif self.format == 'txt': - self.data = pd.read_csv(self.path, na_values='NA', delim_whitespace=True) - else: - raise Exception("Unknown file format") - - # Remove any whitespace from ends of individual data cells - self.data.columns = self.data.columns.str.strip() - - if not (self.class_label in self.data.columns): - raise Exception("Class label not found in file") - if self.match_label and not (self.match_label in self.data.columns): - logging.warning("Match label not found in file, setting match label to None") - self.match_label = None - if self.instance_label and not (self.instance_label in self.data.columns): - raise Exception("Instance label not found in file") - - def feature_only_data(self): - """ - Create features-only version of dataset for some operations - Returns: dataframe x_data with only features - - """ - - if self.instance_label is None and self.match_label is None: - x_data = self.data.drop([self.class_label], axis=1) # exclude class column - elif self.instance_label is not None and self.match_label is None: - x_data = self.data.drop([self.class_label, self.instance_label], axis=1) # exclude class column - elif self.instance_label is None and self.match_label is not None: - x_data = self.data.drop([self.class_label, self.match_label], axis=1) # exclude class column - else: - x_data = self.data.drop([self.class_label, self.instance_label, self.match_label], - axis=1) # exclude class column - return x_data - - def non_feature_data(self): - """ - Create non features version of dataset for some operations - Returns: dataframe y_data with only non features - - """ - if self.instance_label is None and self.match_label is None: - y_data = self.data[[self.class_label]] - elif self.instance_label is not None and self.match_label is None: - y_data = self.data[[self.class_label, self.instance_label]] - elif self.instance_label is None and self.match_label is not None: - y_data = self.data[[self.class_label, self.match_label]] - else: - y_data = self.data[[self.class_label, self.instance_label, self.match_label]] - return y_data - - def get_outcome(self): - """ - Function to get outcome value form data - Returns: outcome column - - """ - return self.data[self.class_label] - - def clean_data(self, ignore_features): - """ - Basic data cleaning: Drops any instances with a missing outcome - value as well as any features (ignore_features) specified by user - """ - # Remove instances with missing outcome values - self.data = self.data.dropna(axis=0, how='any', subset=[self.class_label]) - self.data = self.data.reset_index(drop=True) - self.data[self.class_label] = self.data[self.class_label].astype(dtype='int8') - # Remove columns to be ignored in analysis - if ignore_features: - self.data = self.data.drop(ignore_features, axis=1, errors='ignore') - - def get_headers(self): - """ - Return feature names of the datasets - - Returns: list of feature names - - """ - headers = list(self.data.columns.values) - headers.remove(self.class_label) - if not (self.match_label is None): - headers.remove(self.match_label) - if not (self.instance_label is None): - headers.remove(self.instance_label) - return headers - - def set_original_headers(self, experiment_path, phase='exploratory'): - """ - Exports dataset header labels for use as a reference later in the pipeline. - - Returns: list of headers labels - """ - # Get Original Headers - if not os.path.exists(experiment_path + '/' + self.name + '/' + phase): - os.makedirs(experiment_path + '/' + self.name + '/' + phase) - headers = self.data.columns.values.tolist() - headers.remove(self.class_label) - if not (self.match_label is None): - headers.remove(self.match_label) - if not (self.instance_label is None): - headers.remove(self.instance_label) - with open(experiment_path + '/' + self.name + '/' + phase + '/OriginalFeatureNames.csv', mode='w', - newline="") as file: - writer = csv.writer(file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) - writer.writerow(headers) - return headers - - def set_processed_headers(self, experiment_path, phase='exploratory'): - """ - Exports dataset header labels for use as a reference later in the pipeline. - - Returns: list of headers labels - """ - # Get Original Headers - if not os.path.exists(experiment_path + '/' + self.name + '/' + phase): - os.makedirs(experiment_path + '/' + self.name + '/' + phase) - headers = self.data.columns.values.tolist() - headers.remove(self.class_label) - if not (self.match_label is None): - headers.remove(self.match_label) - if not (self.instance_label is None): - headers.remove(self.instance_label) - with open(experiment_path + '/' + self.name + '/' + phase + '/ProcessedFeatureNames.csv', mode='w', - newline="") as file: - writer = csv.writer(file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) - writer.writerow(headers) - return headers - - def initial_eda(self, experiment_path, plot=False, initial='initial/'): - self.eda(experiment_path, plot=plot, initial=initial) - - def eda(self, experiment_path, plot=False, initial=''): - self.describe_data(experiment_path, initial=initial) - total_missing = self.missingness_counts(experiment_path, initial=initial) - self.missing_count_plot(experiment_path, plot=plot, initial=initial) - self.counts_summary(experiment_path, total_missing, show_plots=plot, initial=initial) - self.feature_correlation(experiment_path, None, show_plots=plot, initial=initial) - - def describe_data(self, experiment_path, initial=''): - """ - Conduct and export basic dataset descriptions including basic column statistics, column variable types - (i.e. int64 vs. float64), and unique value counts for each column - """ - self.data.describe().to_csv(experiment_path + '/' + self.name + - '/exploratory/' + initial + 'DescribeDataset.csv') - self.data.dtypes.to_csv(experiment_path + '/' + self.name + - '/exploratory/' + initial + 'DtypesDataset.csv', - header=['DataType'], index_label='Variable') - self.data.nunique().to_csv(experiment_path + '/' + self.name + - '/exploratory/' + initial + 'NumUniqueDataset.csv', - header=['Count'], index_label='Variable') - - def missingness_counts(self, experiment_path, initial='', save=True): - """ - Count and export missing values for all data columns. - """ - # Assess Missingness in all data columns - missing_count = self.data.isnull().sum() - total_missing = self.data.isnull().sum().sum() - if save: - missing_count.to_csv(experiment_path + '/' + self.name + '/exploratory/' + initial + 'DataMissingness.csv', - header=['Count'], index_label='Variable') - return total_missing - - def missing_count_plot(self, experiment_path, plot=False, initial=''): - """ - Plots a histogram of missingness across all data columns. - """ - missing_count = self.data.isnull().sum() - # Plot a histogram of the missingness observed over all columns in the dataset - plt.hist(missing_count, bins=100) - plt.xlabel("Missing Value Counts") - plt.ylabel("Frequency") - plt.title("Histogram of Missing Value Counts in Dataset") - plt.savefig(experiment_path + '/' + self.name + '/exploratory/' + initial + 'DataMissingnessHistogram.png', - bbox_inches='tight') - if plot: - plt.show() - else: - plt.close('all') - - def counts_summary(self, experiment_path, total_missing=None, plot=True, show_plots=False, initial=''): - """ - Reports various dataset counts: i.e. number of instances, total features, categorical features, quantitative - features, and class counts. Also saves a simple bar graph of class counts if user specified. - - Args: - experiment_path: - total_missing: total missing values (optional, runs again if not given) - plot: flag to output bar graph in the experiment log folder - show_plots: flag to show plots - initial: flag for initial eda - - Returns: - - """ - # Calculate, print, and export instance and feature counts - f_count = self.data.shape[1] - 1 - if not (self.instance_label is None): - f_count -= 1 - if not (self.match_label is None): - f_count -= 1 - if total_missing is None: - total_missing = self.missingness_counts(experiment_path) - percent_missing = int(total_missing) / float(self.data.shape[0] * f_count) - # n_categorical_variables = len(self.categorical_variables) - summary = [['instances', self.data.shape[0]], - ['features', f_count], - ['categorical_features', str(len(self.categorical_variables))], - ['quantitative_features', str(len(self.quantitative_variables))], - ['missing_values', total_missing], - ['missing_percent', round(percent_missing, 5)]] - - summary_df = pd.DataFrame(summary, columns=['Variable', 'Count']) - - summary_df.to_csv(experiment_path + '/' + self.name + '/exploratory/' + initial + 'DataCounts.csv', - index=False) - # Calculate, print, and export class counts - class_counts = self.data[self.class_label].value_counts() - class_counts.to_csv(experiment_path + '/' + self.name + - '/exploratory/' + initial + 'ClassCounts.csv', header=['Count'], - index_label='Class') - - logging.info('Initial Data Counts: ----------------') - logging.info('Instance Count = ' + str(self.data.shape[0])) - logging.info('Feature Count = ' + str(f_count)) - logging.info(' Categorical = ' + str(len(self.categorical_variables))) - logging.info(' Quantitative = ' + str(len(self.quantitative_variables))) - logging.info('Missing Count = ' + str(total_missing)) - logging.info(' Missing Percent = ' + str(percent_missing)) - logging.info('Class Counts: ----------------') - logging.info('Class Count Information') - df_value_counts = pd.DataFrame(class_counts) - df_value_counts = df_value_counts.reset_index() - df_value_counts.columns = ['Class', 'Instances'] - logging.info("\n" + df_value_counts.to_string()) - - # Generate and export class count bar graph - if plot: - class_counts.plot(kind='bar') - plt.ylabel('Count') - plt.title('Class Counts') - plt.savefig(experiment_path + '/' + self.name + '/exploratory/' + initial + 'ClassCountsBarPlot.png', - bbox_inches='tight') - if show_plots: - plt.show() - else: - plt.close('all') - - def feature_correlation(self, experiment_path, x_data=None, plot=True, show_plots=False, initial=''): - """ - Calculates feature correlations via pearson correlation and exports a respective heatmap visualization. - Due to computational expense this may not be recommended for datasets with a large number of instances - and/or features unless needed. The generated heatmap will be difficult to read with a large number - of features in the target dataset. - - Args: - - experiment_path: - x_data: data with only feature columns - plot: - show_plots: - initial: - """ - if x_data is None: - x_data = self.feature_only_data() - # Calculate correlation matrix - correlation_mat = x_data.corr(method='pearson', numeric_only=True) - # corr_matrix_abs = correlation_mat.abs() - - correlation_mat.to_csv(experiment_path + '/' + self.name - + '/exploratory/' + initial + 'FeatureCorrelations.csv') - - if plot: - # Create a mask for the upper triangle of the correlation matrix - mask = np.zeros_like(correlation_mat, dtype=bool) - mask[np.triu_indices_from(mask)] = True - - # Calculate the number of features in the dataset - num_features = len(x_data.columns) - - sns.set_style("white") - # Set the fig-size parameter based on the number of features - if num_features > 70: # - fig_size = (70 // 2, 70 // 2) - # Create a heatmap using Seaborn - plt.subplots(figsize=fig_size) - sns.heatmap(correlation_mat, xticklabels=False, yticklabels=False, mask=mask, vmax=1, vmin=-1, - square=True, cmap='RdBu', cbar_kws={"shrink": .75}) - else: - fig_size = (num_features // 2, num_features // 2) - # Create a heatmap using Seaborn - plt.subplots(figsize=fig_size) - sns.heatmap(correlation_mat, mask=mask, vmax=1, vmin=-1, square=True, cmap='RdBu', - cbar_kws={"shrink": .75}) - - plt.savefig(experiment_path + '/' + self.name + '/exploratory/' + initial + 'FeatureCorrelations.png', - bbox_inches='tight') - if show_plots: - plt.show() - plt.close('all') - else: - plt.close('all') - plt.close('all') - sns.set_theme() diff --git a/streamline/utils/evaluation.py b/streamline/utils/evaluation.py deleted file mode 100644 index 28129a19..00000000 --- a/streamline/utils/evaluation.py +++ /dev/null @@ -1,52 +0,0 @@ -from sklearn.metrics import accuracy_score -from sklearn.metrics import balanced_accuracy_score -from sklearn.metrics import recall_score, precision_score, f1_score, confusion_matrix - - -def class_eval(y_true, y_pred): - """ - Calculates standard classification metrics including: - True positives, false positives, true negative, false negatives, standard accuracy, balanced accuracy - recall, precision, f1 score, negative predictive value, likelihood ratio positive, and likelihood ratio negative - - Args: - y_true: True Labels - y_pred: Predicted Labels - - Returns: list [bac, ac, f1, re, sp, pr, tp, tn, fp, fn, npv, lrp, lrm] - ordered list of balanced accuracy, accuracy, F1-score, recall, specificity, precision, - true positive, true negatives, false positives, false negatives, negative predictive value, - likelihood ratio positive, and likelihood ratio negative - - """ - # Calculate true positive, true negative, false positive, and false negative. - tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel() - # Calculate Accuracy metrics - ac = accuracy_score(y_true, y_pred) - bac = balanced_accuracy_score(y_true, y_pred) - # Calculate Precision and Recall - re = recall_score(y_true, y_pred) # a.k.a. sensitivity or TPR - pr = precision_score(y_true, y_pred) - # Calculate F1 score - f1 = f1_score(y_true, y_pred) - # Calculate specificity, a.k.a. TNR - if tn == 0 and fp == 0: - sp = 0 - else: - sp = tn / float(tn + fp) - # Calculate Negative predictive value - if tn == 0 and fn == 0: - npv = 0 - else: - npv = tn / float(tn + fn) - # Calculate likelihood ratio postive - if sp == 1: - lrp = 0 - else: - lrp = re / float(1 - sp) # sensitivity / (1-specificity).... a.k.a. TPR/FPR... or TPR/(1-TNR) - # Calculate likelihood ratio negative - if sp == 0: - lrm = 0 - else: - lrm = (1 - re) / float(sp) # (1-sensitivity) / specificity... a.k.a. FNR/TNR ... or (1-TPR)/TNR - return [bac, ac, f1, re, sp, pr, tp, tn, fp, fn, npv, lrp, lrm] diff --git a/streamline/utils/job.py b/streamline/utils/job.py deleted file mode 100644 index 024a7095..00000000 --- a/streamline/utils/job.py +++ /dev/null @@ -1,15 +0,0 @@ -import os -import time -import logging - - -class Job: - def __init__(self): - self.cluster = None - self.job_start_time = time.time() - - def run(self): - pass - - def run_cluster(self): - pass diff --git a/streamline/utils/parser.py b/streamline/utils/parser.py deleted file mode 100644 index 81339208..00000000 --- a/streamline/utils/parser.py +++ /dev/null @@ -1,177 +0,0 @@ -import argparse -import configparser -from streamline.utils.parser_helpers import str2bool, save_config, load_config -from streamline.utils.parser_helpers import parse_general, parse_replicate -from streamline.utils.parser_helpers import parse_logistic -from streamline.utils.parser_helpers import parser_function_all -from streamline.utils.parser_helpers import PARSER_LIST - - -def process_params(params): - if params['run_cluster'] not in [False, "False"]: - params['run_parallel'] = True - - if params['do_till_report']: - params["do_eda"] = True - params["do_dataprep"] = True - params["do_feat_imp"] = True - params["do_feat_sel"] = True - params["do_model"] = True - params["do_stats"] = True - params["do_compare_dataset"] = True - params["do_report"] = True - - if params['do_feat_imp'] or params['do_feat_sel'] \ - or params['do_report'] or params['do_rep_report']: - if 'feat_algorithms' not in params: - feat_algorithms = list() - if params['do_mutual_info']: - feat_algorithms.append("MI") - if params['do_multisurf']: - feat_algorithms.append("MS") - params['feat_algorithms'] = feat_algorithms - - if params['do_model'] or params['do_stats'] or params["do_compare_dataset"] \ - or params['do_report'] or params['do_replicate'] or params['do_rep_report']: - if params['algorithms'] == 'All': - params['algorithms'] = None - if type(params['algorithms']) == list: - params['algorithms'] = sorted(params['algorithms']) - - if params['ignore_features_path'] == '' or params['ignore_features_path'] == 'None': - params['ignore_features_path'] = None - if params['categorical_feature_path'] == '' or params['categorical_feature_path'] == 'None': - params['categorical_feature_path'] = None - if params['match_label'] == '' or params['match_label'] == 'None': - params['match_label'] = None - if params['instance_label'] == '' or params['instance_label'] == 'None': - params['instance_label'] = None - if params['run_cluster'] == "False": - params['run_cluster'] = False - if params['run_parallel'] == "False": - params['run_parallel'] = False - if params['run_parallel'] == "True": - params['run_parallel'] = True - - return params - - -def single_parse(mode_params, argv, config_dict=None): - if config_dict is None: - config_dict = dict() - config_dict = parse_general(argv, config_dict) - keys = ['do_eda', - 'do_dataprep', - 'do_feat_imp', - 'do_feat_sel', - 'do_model', - 'do_stats', - 'do_compare_dataset', - 'do_report', - 'do_replicate', - 'do_rep_report', - 'do_cleanup', ] - for i in range(len(keys)): - if mode_params[keys[i]]: - if i == 0: - config_dict = PARSER_LIST[i](argv, config_dict) - save_config(config_dict['output_path'], - config_dict['experiment_name'], - config_dict) - if i not in [6, 7, 9]: - config_dict = load_config(config_dict['output_path'], - config_dict['experiment_name'], config_dict) - config_dict = PARSER_LIST[i](argv, config_dict) - save_config(config_dict['output_path'], - config_dict['experiment_name'], - config_dict) - else: - config_dict = load_config(config_dict['output_path'], - config_dict['experiment_name'], config_dict) - if i == 9: - config_dict_copy = parse_replicate(argv, config_dict) - if not config_dict_copy['rep_data_path'] == "": - config_dict['rep_data_path'] = config_dict_copy['rep_data_path'] - if not config_dict_copy['dataset_for_rep'] == "": - config_dict['dataset_for_rep'] = config_dict_copy['dataset_for_rep'] - if not config_dict_copy['rep_export_feature_correlations']: - config_dict['rep_export_feature_correlations'] \ - = config_dict_copy['rep_export_feature_correlations'] - if not config_dict_copy['exclude_rep_plots'] == 'None': - config_dict['exclude_rep_plots'] = config_dict_copy['exclude_rep_plots'] - config_dict = parse_logistic(argv, config_dict) - return config_dict - - -def parser_function(argv): - parser = argparse.ArgumentParser(description="STREAMLINE: \n" - "Simple Transparent End-To-End Automated Machine " - "Learning Pipeline for Supervised Learning in Tabular " - "Binary Classification Data", - formatter_class=argparse.ArgumentDefaultsHelpFormatter) - parser.add_argument('--config', '-c', - dest='config', type=str, default="", - help='flag to load config file') - parser.add_argument('--verbose', dest='verbose', type=str2bool, nargs='?', const=True, default=False, - help='give output to command line') - parser.add_argument('--do-till-report', '--dtr', dest='do_till_report', type=str2bool, nargs='?', const=True, - help='flag to do all phases', default=False) - parser.add_argument('--do-eda', dest='do_eda', type=str2bool, nargs='?', const=True, - help='flag to eda', default=False) - parser.add_argument('--do-dataprep', dest='do_dataprep', type=str2bool, nargs='?', const=True, - help='flag to data preprocessing', default=False) - parser.add_argument('--do-feat-imp', dest='do_feat_imp', type=str2bool, nargs='?', const=True, - help='flag to feature importance', default=False) - parser.add_argument('--do-feat-sel', dest='do_feat_sel', type=str2bool, nargs='?', const=True, - help='flag to feature selection', default=False) - parser.add_argument('--do-model', dest='do_model', type=str2bool, nargs='?', const=True, - help='flag to run models', default=False) - parser.add_argument('--do-stats', dest='do_stats', type=str2bool, nargs='?', const=True, - help='flag to run statistics', default=False) - parser.add_argument('--do-compare-dataset', dest='do_compare_dataset', type=str2bool, nargs='?', const=True, - help='flag to run compare dataset dataset', default=False) - parser.add_argument('--do-report', dest='do_report', type=str2bool, nargs='?', const=True, - help='flag to run report dataset', default=False) - parser.add_argument('--do-replicate', dest='do_replicate', type=str2bool, nargs='?', const=True, - help='flag to run replication dataset', default=False) - parser.add_argument('--do-rep-report', dest='do_rep_report', type=str2bool, nargs='?', const=True, - help='flag to run replication report', default=False) - parser.add_argument('--do-cleanup', dest='do_cleanup', type=str2bool, nargs='?', const=True, - help='flag to run cleanup', default=False) - args, unknown = parser.parse_known_args(argv[1:]) - mode_params = vars(args) - if len(mode_params) == 0 or ('verbose' in mode_params and len(mode_params) == 1): - return Exception("Improper Phase Declaration") - - config_dict = dict() - - if mode_params['config'] != "": - config_file = mode_params['config'] - config = configparser.ConfigParser() - config.read(config_file) - for s in config.sections(): - config_dict.update({k: eval(v) for k, v in config.items(s)}) - save_config(config_dict['output_path'], - config_dict['experiment_name'], - config_dict) - elif mode_params['do_till_report']: - print("Running till Report Generation Stage") - config = parser_function_all(argv) - config_dict.update(config) - config_dict.update(mode_params) - save_config(config_dict['output_path'], - config_dict['experiment_name'], - config_dict) - - for key in mode_params: - if mode_params[key] and key not in ['config', 'do_till_report']: - config = single_parse(mode_params, argv, config_dict) - config_dict.update(config) - config_dict.update(mode_params) - save_config(config_dict['output_path'], - config_dict['experiment_name'], - config_dict) - - config_dict = process_params(config_dict) - - return config_dict diff --git a/streamline/utils/parser_helpers.py b/streamline/utils/parser_helpers.py deleted file mode 100644 index e308b4c4..00000000 --- a/streamline/utils/parser_helpers.py +++ /dev/null @@ -1,406 +0,0 @@ -import os -import pickle -import argparse -import logging -from streamline.modeling.utils import SUPPORTED_MODELS_SMALL - - -def process_cli_param(param): - if param == "None": - p_praram = None - else: - try: - p_praram = eval(param) - except SyntaxError: - p_praram = str(param) - return p_praram - - -def comma_sep_choices(choices): - """ - Return a function that splits and checks comma-separated values. - """ - - def splitarg(arg): - if arg == 'None': - return None - elif ',' not in arg: - return [arg, ] - else: - values = arg.split(',') - for value in values: - if value not in choices: - raise argparse.ArgumentTypeError( - 'invalid choice: {!r} (choose from {})' - .format(value, ', '.join(map(repr, choices)))) - return values - - return splitarg - - -def str2bool(v): - if isinstance(v, bool): - return v - if v.lower() in ('yes', 'true', 't', 'y', '1'): - return True - elif v.lower() in ('no', 'false', 'f', 'n', '0'): - return False - else: - raise argparse.ArgumentTypeError('boolean value expected.') - - -def save_config(output_path, experiment_name, config_dict): - if not os.path.exists(config_dict['output_path']): - os.mkdir(str(config_dict['output_path'])) - with open(output_path + '/' + experiment_name + '_params.pickle', 'wb') as file: - pickle.dump(config_dict, file, protocol=pickle.HIGHEST_PROTOCOL) - - -def load_config(output_path, experiment_name, config=None): - if config is None: - config = dict() - try: - with open(output_path + '/' + experiment_name + '_params.pickle', 'rb') as file: - config_file = pickle.load(file) - config.update(config_file) - except FileNotFoundError: - logging.warning("CLI Params File Not Found") - return config - - -def update_dict_from_parser(argv, parser, params_dict=None): - if not params_dict: - params_dict = dict() - args, unknown = parser.parse_known_args(argv[1:]) - params_dict.update(vars(args)) - return params_dict - - -def parse_general(argv, params_dict=None): - # Parse arguments - parser = argparse.ArgumentParser(description="", - formatter_class=argparse.ArgumentDefaultsHelpFormatter) - # Arguments with no defaults - Global Args - parser.add_argument('--out-path', dest='output_path', type=str, help='path to output directory') - parser.add_argument('--exp-name', dest='experiment_name', type=str, - help='name of experiment output folder (no spaces)') - # Arguments with defaults available (but critical to check) - parser.add_argument('--verbose', dest='verbose', type=str2bool, nargs='?', default=False, - help='give output to command line') - return update_dict_from_parser(argv, parser, params_dict) - - -def parse_eda(argv, params_dict=None): - # Parse arguments - parser = argparse.ArgumentParser(description="", - formatter_class=argparse.ArgumentDefaultsHelpFormatter) - parser.add_argument('--data-path', dest='dataset_path', type=str, help='path to directory containing datasets') - parser.add_argument('--inst-label', dest='instance_label', type=str, - help='instance label of all datasets (if present)', default="") - parser.add_argument('--class-label', dest='class_label', type=str, help='outcome label of all datasets', - default="Class") - parser.add_argument('--match-label', dest='match_label', type=str, - help='only applies when Group selected for partition-method; ' - 'indicates column with matched instance ids', - default='') - # Arguments with defaults available (but less critical to check) - parser.add_argument('--fi', dest='ignore_features_path', type=str, - help='path to .csv file with feature labels to be ignored in analysis ' - '(e.g. ./droppedFeatures.csv))', - default=None) - parser.add_argument('--cf', dest='categorical_feature_path', type=str, - help='path to .csv file with feature labels specified to ' - 'be treated as categorical where possible', - default=None) - parser.add_argument('--qf', dest='quantitative_feature_path', type=str, - help='path to .csv file with feature labels specified to ' - 'be treated as categorical where possible', - default=None) - - parser.add_argument('--cv', dest='cv_partitions', type=int, help='number of CV partitions', default=10) - parser.add_argument('--part', dest='partition_method', type=str, - help="Stratified, Random, or Group Stratification", default="Stratified") - parser.add_argument('--cat-cutoff', dest='categorical_cutoff', type=int, - help='number of unique values after which a variable is ' - 'considered to be quantitative vs categorical', - default=10) - parser.add_argument('--top-uni-features', dest='top_uni_features', type=int, - help='number of top features to illustrate in figures', default=40) - parser.add_argument('--sig', dest='sig_cutoff', type=float, help='significance cutoff used throughout pipeline', - default=0.05) - parser.add_argument('--feat_miss', dest='featureeng_missingness', type=float, - help='feature missingness cutoff used throughout pipeline', - default=0.5) - parser.add_argument('--clean_miss', dest='cleaning_missingness', type=float, - help='cleaning missingness cutoff used throughout pipeline', - default=0.5) - parser.add_argument('--corr_thresh', dest='correlation_removal_threshold', type=float, - help='correlation removal threshold', - default=1.0) - # parser.add_argument('--export-fc', dest='export_feature_correlations', type=str2bool, nargs='?', - # help='run and export feature correlation analysis (yields correlation heatmap)', default=True) - # parser.add_argument('--export-up', dest='export_univariate_plots', type=str2bool, nargs='?', - # help='export univariate analysis plots (note: univariate analysis still output by default)', - # default=True) - parser.add_argument('--exclude-eda-output', dest='exclude_eda_output', - type=comma_sep_choices(['describe_csv', 'univariate_plots', 'correlation_plots']), - help='comma seperated list of eda outputs to exclude', - default='None') - - parser.add_argument('--rand-state', dest='random_state', type=int, - help='"Dont Panic" - sets a specific random seed for reproducible results', default=42) - return update_dict_from_parser(argv, parser, params_dict) - - -def parse_dataprep(argv, params_dict=None): - # Parse arguments - parser = argparse.ArgumentParser(description="", - formatter_class=argparse.ArgumentDefaultsHelpFormatter) - # Defaults available - Phase 2 - parser.add_argument('--scale', dest='scale_data', type=str2bool, nargs='?', - help='perform data scaling (required for SVM, and to use ' - 'Logistic regression with non-uniform feature importance estimation)', const=True, - default=True) - parser.add_argument('--impute', dest='impute_data', type=str2bool, nargs='?', - help='perform missing value data imputation ' - '(required for most ML algorithms if missing data is present)', const=True, - default=True) - parser.add_argument('--multi-impute', dest='multi_impute', type=str2bool, nargs='?', - help='applies multivariate imputation to ' - 'quantitative features, otherwise uses median imputation', const=True, - default=True) - parser.add_argument('--over-cv', dest='overwrite_cv', type=str2bool, nargs='?', const=False, - help='overwrites earlier cv datasets with new scaled/imputed ones', default=False) - - return update_dict_from_parser(argv, parser, params_dict) - - -def parse_feat_imp(argv, params_dict=None): - # Parse arguments - parser = argparse.ArgumentParser(description="", - formatter_class=argparse.ArgumentDefaultsHelpFormatter) - # Defaults available - Phase 3 - parser.add_argument('--do-mi', dest='do_mutual_info', type=str2bool, nargs='?', - help='do mutual information analysis', const=True, - default=True) - parser.add_argument('--do-ms', dest='do_multisurf', type=str2bool, nargs='?', const=True, - help='do multiSURF analysis', default=True) - parser.add_argument('--use-turf', dest='use_turf', type=str2bool, nargs='?', const=True, - help='use TURF wrapper around MultiSURF to improve feature ' - 'interaction detection in large feature spaces ' - '(only recommended if you have reason to believe at ' - 'least half of your features are non-informative)', - default=False) - parser.add_argument('--turf-pct', dest='turf_pct', type=float, - help='proportion of instances removed in an iteration (also dictates number of iterations)', - default=0.5) - parser.add_argument('--n-jobs', dest='n_jobs', type=int, - help='number of cores dedicated to running algorithm; ' - 'setting to -1 will use all available cores', - default=1) - parser.add_argument('--inst-sub', dest='instance_subset', type=int, help='sample subset size to use with multiSURF', - default=2000) - return update_dict_from_parser(argv, parser, params_dict) - - -def parse_feat_sel(argv, params_dict=None): - # Parse arguments - parser = argparse.ArgumentParser(description="", - formatter_class=argparse.ArgumentDefaultsHelpFormatter) - # Defaults available - Phase 4 - parser.add_argument('--max-feat', dest='max_features_to_keep', type=int, - help='max features to keep (only applies if filter_poor_features is True)', default=2000) - parser.add_argument('--filter-feat', dest='filter_poor_features', type=str2bool, nargs='?', const=True, - help='filter out the worst performing features prior to modeling', default=True) - parser.add_argument('--top-fi-features', dest='top_fi_features', type=int, - help='number of top features to illustrate in figures', default=40) - parser.add_argument('--export-scores', dest='export_scores', type=str2bool, nargs='?', - help='export figure summarizing average feature importance scores over cv partitions', - default=True) - parser.add_argument('--over-cv-feat', dest='overwrite_cv_feat', type=str2bool, nargs='?', const=True, - help='overwrites working cv datasets with new feature subset datasets', default=True) - return update_dict_from_parser(argv, parser, params_dict) - - -def parse_model(argv, params_dict=None): - # Parse arguments - parser = argparse.ArgumentParser(description="", - formatter_class=argparse.ArgumentDefaultsHelpFormatter) - - # Defaults available - Phase 5 - # Sets default run all or none to make algorithm selection from command line simpler - parser.add_argument('--do-all', dest='do_all', type=str2bool, nargs='?', - help='run all modeling algorithms by default (when set False, individual algorithms are ' - 'activated individually)', - default=False) #LIKELY REMOVE - - parser.add_argument('--algorithms', dest='algorithms', - type=comma_sep_choices(SUPPORTED_MODELS_SMALL), - help='comma seperated list of algorithms to exclude', - default=None) - - parser.add_argument('--model-resubmit', dest='model_resubmit', - type=str2bool, nargs='?', - help='flag to resubmit models instead', - default=False) - - parser.add_argument('--exclude', dest='exclude', - type=comma_sep_choices(SUPPORTED_MODELS_SMALL), - help='comma seperated list of algorithms to exclude', - default='eLCS,XCS') - - # Other Analysis Parameters - Defaults available - parser.add_argument('--metric', dest='primary_metric', type=str, - help='primary scikit-learn specified scoring metric used for hyper parameter optimization and ' - 'permutation-based model feature importance evaluation', - default='balanced_accuracy') - parser.add_argument('--metric-direction', dest='metric_direction', type=str, - help='optimization direction on primary metric, maximize or minimize, default maximize', - default='maximize') - parser.add_argument('--subsample', dest='training_subsample', type=int, - help='for long running algos (XGB,SVM,ANN,KN), option to subsample training set (0 for no ' - 'subsample)', - default=0) - parser.add_argument('--use-uniformFI', dest='use_uniform_fi', type=str, - help='overrides use of any available feature importance estimate methods from models, ' - 'instead using permutation_importance uniformly', - default='True') - # Hyperparameter sweep options - Defaults available - parser.add_argument('--n-trials', dest='n_trials', type=str, - help='# of bayesian hyperparameter optimization trials using optuna (specify an integer or ' - 'None)', - default=200) - parser.add_argument('--timeout', dest='timeout', type=str, - help='seconds until hyperparameter sweep stops running new trials (Note: it may run longer to ' - 'finish last trial started) If set to None, STREAMLINE is completely replicable, ' - 'but will take longer to run', - default=900) # 900 sec = 15 minutes default - parser.add_argument('--export-hyper-sweep', dest='export_hyper_sweep_plots', type=str, - help='export optuna-generated hyperparameter sweep plots', default='False') - # LCS specific parameters - Defaults available - parser.add_argument('--do-LCS-sweep', dest='do_lcs_sweep', type=str, - help='do LCS hyper-param tuning or use below params', default='False') - parser.add_argument('--nu', dest='lcs_nu', type=int, - help='fixed LCS nu param (recommended range 1-10), set to larger value for data with less or ' - 'no noise', - default=1) - parser.add_argument('--iter', dest='lcs_iterations', type=int, help='fixed LCS # learning iterations param', - default=200000) - parser.add_argument('--N', dest='lcs_n', type=int, help='fixed LCS rule population maximum size param', - default=2000) - parser.add_argument('--lcs-timeout', dest='lcs_timeout', type=int, help='seconds until hyper parameter sweep stops ' - 'for LCS algorithms', default=1200) - return update_dict_from_parser(argv, parser, params_dict) - - -def parse_stats(argv, params_dict=None): - # Parse arguments - parser = argparse.ArgumentParser(description="", - formatter_class=argparse.ArgumentDefaultsHelpFormatter) - # Defaults available - Phase 6 - # parser.add_argument('--plot-ROC', dest='plot_roc', type=str, - # help='Plot ROC curves individually for each algorithm including all CV results and averages', - # default='True') - # parser.add_argument('--plot-PRC', dest='plot_prc', type=str, - # help='Plot PRC curves individually for each algorithm including all CV results and averages', - # default='True') - # parser.add_argument('--plot-box', dest='plot_metric_boxplots', type=str, - # help='Plot box plot summaries comparing algorithms for each metric', default='True') - # parser.add_argument('--plot-FI_box', dest='plot_fi_box', type=str, - # help='Plot feature importance boxplots and histograms for each algorithm', default='True') - parser.add_argument('--exclude-plots', dest='exclude_plots', - type=comma_sep_choices(['plot_ROC', 'plot_PRC', 'plot_FI_box', 'plot_metric_boxplots']), - help='comma seperated list of plots to exclude ' - 'possible options plot_ROC, plot_PRC, plot_FI_box, plot_metric_boxplots', - default='None') - parser.add_argument('--metric-weight', dest='metric_weight', type=str, - help='ML model metric used as weight in composite FI plots (only supports balanced_accuracy ' - 'or roc_auc as options) Recommend setting the same as primary_metric if possible.', - default='balanced_accuracy') - parser.add_argument('--top-model-features', dest='top_model_fi_features', type=int, - help='number of top features to illustrate in figures', default=40) - return update_dict_from_parser(argv, parser, params_dict) - - -def parse_replicate(argv, params_dict=None): - # Parse arguments - parser = argparse.ArgumentParser(description="", - formatter_class=argparse.ArgumentDefaultsHelpFormatter) - # Phase 9/11 - parser.add_argument('--rep-path', dest='rep_data_path', type=str, - help='path to directory containing replication or hold-out testing datasets (must have at ' - 'least all features with same labels as in original training dataset)', default="") - - parser.add_argument('--dataset', dest='dataset_for_rep', type=str, - help='path to directory containing replication or hold-out testing datasets (must have at ' - 'least all features with same labels as in original training dataset)', default="") - # Defaults available - parser.add_argument('--rep-export-fc', dest='rep_export_feature_correlations', type=str2bool, nargs='?', - help='run and export feature correlation analysis (yields correlation heatmap)', default=True) - # parser.add_argument('--rep-plot-ROC', dest='rep_plot_roc', type=str2bool, nargs='?', - # help='Plot ROC curves individually for each algorithm including all CV results and averages', - # default=True) - # parser.add_argument('--rep-plot-PRC', dest='rep_plot_prc', type=str2bool, nargs='?', - # help='Plot PRC curves individually for each algorithm including all CV results and averages', - # default=True) - # parser.add_argument('--rep-plot-box', dest='rep_plot_metric_boxplots', type=str2bool, nargs='?', - # help='Plot box plot summaries comparing algorithms for each metric', default=True) - parser.add_argument('--exclude-rep-plots', dest='exclude_rep_plots', - type=comma_sep_choices(['plot_ROC', 'plot_PRC', - 'plot_metric_boxplots', 'feature_correlations']), - help='comma seperated list of plots to exclude ' - 'possible options plot_ROC, plot_PRC, plot_FI_box, plot_metric_boxplots', - default='None') - return update_dict_from_parser(argv, parser, params_dict) - - -def parse_cleanup(argv, params_dict=None): - # Parse arguments - parser = argparse.ArgumentParser(description="", - formatter_class=argparse.ArgumentDefaultsHelpFormatter) - parser.add_argument('--del-time', dest='del_time', type=str2bool, nargs='?', - help='flag to run cleanup', default=True) - parser.add_argument('--del-old-cv', dest='del_old_cv', type=str2bool, nargs='?', - help='flag to run cleanup', default=True) - return update_dict_from_parser(argv, parser, params_dict) - - -def parse_logistic(argv, params_dict=None): - # Parse arguments - parser = argparse.ArgumentParser(description="", - formatter_class=argparse.ArgumentDefaultsHelpFormatter) - # Logistical arguments - parser.add_argument('--run-parallel', dest='run_parallel', type=str, - help='if run parallel on through multiprocessing', default=False) - parser.add_argument('--run-cluster', dest='run_cluster', type=str, - help='if run parallel through SLURM process', default="SLURM") - parser.add_argument('--res-mem', dest='reserved_memory', type=int, - help='reserved memory for the job (in Gigabytes)', default=4) - parser.add_argument('--queue', dest='queue', type=str, - help='default partition queue', default="defq") - return update_dict_from_parser(argv, parser, params_dict) - - -def parser_function_all(argv, params_dict=None): - params_dict = parse_general(argv, params_dict) - params_dict = parse_eda(argv, params_dict) - params_dict = parse_dataprep(argv, params_dict) - params_dict = parse_feat_imp(argv, params_dict) - params_dict = parse_feat_sel(argv, params_dict) - params_dict = parse_model(argv, params_dict) - params_dict = parse_stats(argv, params_dict) - params_dict = parse_logistic(argv, params_dict) - return params_dict - - -PARSER_LIST = [parse_eda, - parse_dataprep, - parse_feat_imp, - parse_feat_sel, - parse_model, - parse_stats, - None, - None, - parse_replicate, - None, - parse_cleanup] diff --git a/streamline/utils/run_commands.py b/streamline/utils/run_commands.py new file mode 100644 index 00000000..b2806582 --- /dev/null +++ b/streamline/utils/run_commands.py @@ -0,0 +1,218 @@ +from __future__ import annotations + +import argparse +import copy +import logging +import pickle +import shlex +import sys +from datetime import datetime +from pathlib import Path +from typing import Any, Dict, Iterable, Optional, Sequence, Set + +RUN_COMMANDS_FILENAME = "run_commands.pickle" +SCHEMA_VERSION = 1 + +_CONTROL_DESTS = { + "ignore_saved_run_command", + "no_update_saved_run_command", + "update_saved_run_command", +} + + +def add_run_command_args(parser: argparse.ArgumentParser) -> None: + parser.add_argument( + "--ignore_saved_run_command", + action="store_true", + help="Ignore saved arguments from run_commands.pickle for this phase.", + ) + parser.add_argument( + "--no_update_saved_run_command", + action="store_true", + help="Do not update run_commands.pickle after this phase finishes.", + ) + + +def apply_saved_run_command( + parser: argparse.ArgumentParser, + args: argparse.Namespace, + phase: str, + argv: Optional[Sequence[str]] = None, +) -> argparse.Namespace: + if getattr(args, "ignore_saved_run_command", False): + return args + + exp_root = resolve_experiment_root(args) + if exp_root is None: + logging.warning("run_commands.pickle not used for %s: experiment path could not be resolved.", phase) + return args + + stored = load_phase_run_command(exp_root, phase) + if not stored: + logging.warning( + "No saved run command found for %s at %s; using parser/metadata defaults.", + phase, + exp_root / RUN_COMMANDS_FILENAME, + ) + return args + + saved_args = stored.get("args") or {} + if not isinstance(saved_args, dict): + return args + + explicit = _explicit_dests(parser, argv if argv is not None else sys.argv[1:]) + for key, value in saved_args.items(): + if key in _CONTROL_DESTS or key in explicit or not hasattr(args, key): + continue + setattr(args, key, copy.deepcopy(value)) + return args + + +def snapshot_args(args: argparse.Namespace) -> Dict[str, Any]: + return { + k: copy.deepcopy(v) + for k, v in vars(args).items() + if k not in _CONTROL_DESTS + } + + +def snapshot_effective_args(args_snapshot: Dict[str, Any], runner: Any) -> Dict[str, Any]: + effective = copy.deepcopy(args_snapshot or {}) + if runner is None: + return effective + + runner_values: Dict[str, Any] = {} + for key, value in vars(runner).items(): + if key.startswith("_"): + continue + if key == "kw" and isinstance(value, dict): + runner_values.update(value) + continue + runner_values[key] = value + + for key in list(effective): + if key in runner_values: + effective[key] = copy.deepcopy(runner_values[key]) + return effective + + +def save_run_command_from_args( + args: argparse.Namespace, + phase: str, + args_snapshot: Optional[Dict[str, Any]] = None, + argv: Optional[Sequence[str]] = None, + runner: Optional[Any] = None, +) -> None: + if getattr(args, "no_update_saved_run_command", False): + return + exp_root = resolve_experiment_root(args) + if exp_root is None: + logging.info("run_commands.pickle not updated for %s: experiment path could not be resolved.", phase) + return + saved_args = args_snapshot if args_snapshot is not None else snapshot_args(args) + if runner is not None: + saved_args = snapshot_effective_args(saved_args, runner) + save_phase_run_command( + exp_root=exp_root, + phase=phase, + args=saved_args, + argv=argv if argv is not None else sys.argv[1:], + ) + + +def require_args(parser: argparse.ArgumentParser, args: argparse.Namespace, names: Iterable[str]) -> None: + missing = [] + for name in names: + value = getattr(args, name, None) + if value is None or value == "": + missing.append(f"--{name}") + if missing: + parser.error( + "Missing required arguments after applying run_commands.pickle: " + + ", ".join(missing) + ) + + +def resolve_experiment_root(args: argparse.Namespace) -> Optional[Path]: + experiment_path = getattr(args, "experiment_path", None) + if experiment_path: + return Path(experiment_path) + + output_path = getattr(args, "output_path", None) + experiment_name = getattr(args, "experiment_name", None) + if output_path and experiment_name: + return Path(output_path) / experiment_name + + return None + + +def load_run_commands(exp_root: Path) -> Dict[str, Any]: + path = exp_root / RUN_COMMANDS_FILENAME + if not path.exists(): + return _empty_store() + try: + with path.open("rb") as f: + payload = pickle.load(f) + except Exception as exc: + logging.warning("Could not read %s: %s. Starting with an empty command store.", path, exc) + return _empty_store() + + if not isinstance(payload, dict): + return _empty_store() + payload.setdefault("schema_version", SCHEMA_VERSION) + payload.setdefault("phases", {}) + return payload + + +def load_phase_run_command(exp_root: Path, phase: str) -> Dict[str, Any]: + store = load_run_commands(exp_root) + phase_store = store.get("phases", {}).get(phase, {}) + if not isinstance(phase_store, dict): + return {} + latest = phase_store.get("latest", {}) + return latest if isinstance(latest, dict) else {} + + +def save_phase_run_command( + exp_root: Path, + phase: str, + args: Dict[str, Any], + argv: Optional[Sequence[str]] = None, +) -> None: + exp_root.mkdir(parents=True, exist_ok=True) + store = load_run_commands(exp_root) + phases = store.setdefault("phases", {}) + phase_store = phases.setdefault(phase, {}) + history = phase_store.setdefault("history", []) + + record = { + "phase": phase, + "updated_at": datetime.now().isoformat(), + "args": copy.deepcopy(args), + "argv": list(argv or []), + "command": " ".join(shlex.quote(str(part)) for part in (argv or [])), + } + phase_store["latest"] = record + history.append(record) + + path = exp_root / RUN_COMMANDS_FILENAME + with path.open("wb") as f: + pickle.dump(store, f) + + +def _empty_store() -> Dict[str, Any]: + return {"schema_version": SCHEMA_VERSION, "phases": {}} + + +def _explicit_dests(parser: argparse.ArgumentParser, argv: Sequence[str]) -> Set[str]: + option_to_dest: Dict[str, str] = {} + for action in parser._actions: + for option in action.option_strings: + option_to_dest[option] = action.dest + + explicit: Set[str] = set() + for token in argv: + option = token.split("=", 1)[0] + if option in option_to_dest: + explicit.add(option_to_dest[option]) + return explicit diff --git a/streamline/utils/runners.py b/streamline/utils/runners.py index 54144c3b..1c500900 100644 --- a/streamline/utils/runners.py +++ b/streamline/utils/runners.py @@ -6,21 +6,6 @@ num_cores = int(os.environ.get('SLURM_CPUS_PER_TASK', -1)) if num_cores == -1: num_cores = multiprocessing.cpu_count() - - -def check_if_single_phase(params): - phase_list = [params['do_eda'], params['do_dataprep'], params['do_feat_imp'], - params['do_feat_sel'], params['do_model'], params['do_stats'], - params['do_compare_dataset'], params['do_report'], params['do_replicate'], - params['do_rep_report'], params['do_cleanup']] - phase_count = 0 - for phase in phase_list: - if phase: - phase_count += 1 - if phase_count == 1: - return True - else: - return False def parallel_eda_call(eda_job, params): @@ -47,6 +32,98 @@ def runner_fn(job): job.run() +def progress_is_enabled(): + return str(os.environ.get("STREAMLINE_PROGRESS", "1")).strip().lower() not in { + "0", + "false", + "no", + "off", + } + + +def progress_bar(iterable, total=None, label=None): + if not progress_is_enabled(): + return iterable + try: + from tqdm.auto import tqdm + except Exception: + return iterable + return tqdm(iterable, total=total, desc=label, unit="job") + + +def run_dask_tasks(tasks, client, label=None): + task_list = list(tasks) + if not task_list: + return [] + futures = client.compute(task_list) + if progress_is_enabled(): + try: + from dask.distributed import progress + if label: + print(label) + progress(futures, notebook=False) + except Exception: + pass + return client.gather(futures) + + +def parallel_worker_count(total_jobs=None): + workers_raw = os.environ.get("STREAMLINE_PARALLEL_WORKERS") + try: + workers = int(workers_raw) if workers_raw else int(num_cores) + except (TypeError, ValueError): + workers = int(num_cores) + workers = max(1, workers) + if total_jobs is not None: + workers = min(workers, max(1, int(total_jobs))) + return workers + + +def run_parallel_jobs(function, jobs, workers=None, label="STREAMLINE Parallel"): + """ + Run tuple-argument jobs with local joblib parallelism. + """ + job_list = list(jobs) + if not job_list: + return [] + worker_count = workers if workers is not None else parallel_worker_count(len(job_list)) + worker_count = max(1, min(int(worker_count), len(job_list))) + if worker_count == 1: + return [function(*job) for job in progress_bar(job_list, total=len(job_list), label=label)] + results = Parallel(n_jobs=worker_count, backend="loky", return_as="generator")( + delayed(function)(*job) for job in job_list + ) + return list(progress_bar(results, total=len(job_list), label=label)) + + +def run_parallel_items(function, items, workers=None, label="STREAMLINE Parallel"): + """ + Run one-argument jobs with local joblib parallelism. + """ + item_list = list(items) + if not item_list: + return [] + worker_count = workers if workers is not None else parallel_worker_count(len(item_list)) + worker_count = max(1, min(int(worker_count), len(item_list))) + if worker_count == 1: + return [function(item) for item in progress_bar(item_list, total=len(item_list), label=label)] + results = Parallel(n_jobs=worker_count, backend="loky", return_as="generator")( + delayed(function)(item) for item in item_list + ) + return list(progress_bar(results, total=len(item_list), label=label)) + + +def run_callable(callable_obj): + return callable_obj() + + +def run_parallel_functions(functions, workers=None, label="STREAMLINE Parallel"): + """ + Run zero-argument callables with local joblib parallelism. + """ + return run_parallel_items(run_callable, functions, workers=workers, label=label) + + def run_jobs(job_list): """ Function to start and join a list of job objects diff --git a/streamline_app.py b/streamline_app.py new file mode 100644 index 00000000..5c61ced7 --- /dev/null +++ b/streamline_app.py @@ -0,0 +1,436 @@ +# app.py +import numpy as np +import pandas as pd +import streamlit as st + +from bokeh.plotting import figure +from bokeh.models import ColumnDataSource, HoverTool +from bokeh.transform import factor_cmap + +# ------------------------- +# Sample Data Generation +# ------------------------- + +def make_sample_metrics(): + models = ["LogisticRegression", "RandomForest", "XGBoost", "SVM", "NB"] + metrics = ["Balanced Accuracy", "Accuracy", "F1", "Precision", "Recall", "ROC AUC", "PRC APS"] + + rows = [] + rng = np.random.default_rng(42) + for m in models: + for metric in metrics: + mean = rng.uniform(0.7, 0.95) + std = rng.uniform(0.01, 0.04) + rows.append( + dict( + model=m, + metric=metric, + mean=mean, + std=std, + ) + ) + + df = pd.DataFrame(rows) + # Derive rank per metric (higher is better) + df["rank"] = df.groupby("metric")["mean"].rank(ascending=False, method="min") + return df + + +def make_sample_ensembles(): + rows = [ + # ensemble, best_base, Δ BalancedAcc, Δ ROC AUC, Δ PRC APS + ("Vote_Hard", "RandomForest", 0.01, 0.005, 0.007), + ("Vote_Soft", "XGBoost", 0.02, 0.012, 0.015), + ("Stack_LR", "XGBoost", 0.025, 0.018, 0.020), + ("Stack_RF", "RandomForest", 0.015, 0.010, 0.012), + ] + df = pd.DataFrame(rows, columns=["ensemble", "best_base", "delta_bal_acc", "delta_roc_auc", "delta_prc_aps"]) + return df + + +def make_sample_feature_importance(): + features = [f"Feature_{i}" for i in range(1, 21)] + algos = ["MI", "MSWRFDB", "MSWRFDB*"] + rng = np.random.default_rng(123) + + rows = [] + for algo in algos: + for rank, feat in enumerate(features, start=1): + importance = rng.uniform(0.0, 1.0) * (1.0 / rank) + rows.append( + dict( + feature=feat, + algorithm=algo, + avg_importance=importance, + avg_rank=rank, + ) + ) + df = pd.DataFrame(rows) + # Normalize importance within algorithm + df["norm_importance"] = df.groupby("algorithm")["avg_importance"].transform( + lambda x: x / x.max() + ) + return df + + +def make_sample_crossphase_correlations(): + features = [f"Feature_{i}" for i in range(1, 16)] + metrics = ["ROC AUC", "PRC APS", "F1"] + rng = np.random.default_rng(999) + + rows = [] + for feat in features: + for met in metrics: + corr = rng.uniform(-1.0, 1.0) + rows.append( + dict( + feature=feat, + metric=met, + correlation=corr, + ) + ) + df = pd.DataFrame(rows) + return df + + +def make_sample_curves(): + """Generate toy ROC & PRC curves per model.""" + rng = np.random.default_rng(777) + models = ["LogisticRegression", "RandomForest", "XGBoost", "SVM"] + + roc_curves = {} + prc_curves = {} + + for m in models: + # ROC + fpr = np.linspace(0, 1, 50) + base = rng.uniform(0.7, 0.9) + tpr_noise = rng.normal(0, 0.03, size=fpr.shape) + tpr = np.clip(base * fpr + 0.1 + tpr_noise, 0, 1) + roc_curves[m] = pd.DataFrame({"fpr": fpr, "tpr": tpr}) + + # PRC + recall = np.linspace(0, 1, 50) + prec_base = rng.uniform(0.7, 0.9) + prec_noise = rng.normal(0, 0.03, size=recall.shape) + precision = np.clip(prec_base * (1 - recall / 2) + prec_noise, 0, 1) + prc_curves[m] = pd.DataFrame({"recall": recall, "precision": precision}) + + return roc_curves, prc_curves + + +# ------------------------- +# Bokeh Plot Helpers +# ------------------------- + +def bokeh_bar_model_metric(df_metrics, metric): + df = df_metrics[df_metrics["metric"] == metric].copy() + df = df.sort_values("mean", ascending=False) + models = df["model"].tolist() + source = ColumnDataSource(df) + + p = figure( + x_range=models, + height=400, + title=f"{metric} by Model", + toolbar_location="right", + tools="pan,box_zoom,reset,save" + ) + cmap = factor_cmap("model", palette="Category10_10", factors=models) + + p.vbar( + x="model", + top="mean", + width=0.7, + source=source, + fill_color=cmap, + line_color="black", + ) + + p.add_tools( + HoverTool( + tooltips=[ + ("Model", "@model"), + ("Mean", "@mean{0.3f}"), + ("Std", "@std{0.3f}"), + ("Rank", "@rank{0}"), + ] + ) + ) + p.yaxis.axis_label = metric + p.xaxis.major_label_orientation = 1.0 + return p + + +def bokeh_bar_ensembles(df_ens, metric_col, title=None): + df = df_ens.copy() + ensembles = df["ensemble"].tolist() + source = ColumnDataSource(df) + + if title is None: + title = f"Ensemble Δ {metric_col} vs Best Base" + + p = figure( + x_range=ensembles, + height=400, + title=title, + toolbar_location="right", + tools="pan,box_zoom,reset,save" + ) + cmap = factor_cmap("ensemble", palette="Category10_10", factors=ensembles) + + p.vbar( + x="ensemble", + top=metric_col, + width=0.7, + source=source, + fill_color=cmap, + line_color="black", + ) + p.add_tools( + HoverTool( + tooltips=[ + ("Ensemble", "@ensemble"), + ("Best Base", "@best_base"), + (f"Δ {metric_col}", f"@{metric_col}{{0.3f}}"), + ] + ) + ) + p.yaxis.axis_label = f"Δ {metric_col}" + p.xaxis.major_label_orientation = 1.0 + return p + + +def bokeh_bar_feature_importance(df_fi, algorithm, top_k=15): + df = df_fi[df_fi["algorithm"] == algorithm].copy() + df = df.sort_values("norm_importance", ascending=False).head(top_k) + features = df["feature"].tolist() + df["feature_str"] = df["feature"].astype(str) + + source = ColumnDataSource(df) + + p = figure( + x_range=features, + height=400, + title=f"Top {top_k} Features ({algorithm})", + toolbar_location="right", + tools="pan,box_zoom,reset,save" + ) + cmap = factor_cmap("feature_str", palette="Category10_10", factors=features) + + p.vbar( + x="feature_str", + top="norm_importance", + width=0.7, + source=source, + fill_color=cmap, + line_color="black", + ) + + p.add_tools( + HoverTool( + tooltips=[ + ("Feature", "@feature"), + ("Avg Importance", "@avg_importance{0.3f}"), + ("Norm Importance", "@norm_importance{0.3f}"), + ("Avg Rank", "@avg_rank{0}"), + ] + ) + ) + + p.yaxis.axis_label = "Normalized Importance" + p.xaxis.major_label_orientation = 1.2 + return p + + +def bokeh_heatmap_crossphase(df_corr): + features = sorted(df_corr["feature"].unique()) + metrics = sorted(df_corr["metric"].unique()) + + df = df_corr.copy() + df["feature_idx"] = df["feature"].astype(str) + df["metric_idx"] = df["metric"].astype(str) + + source = ColumnDataSource(df) + + p = figure( + x_range=features, + y_range=list(reversed(metrics)), + x_axis_location="above", + height=400, + title="Cross-phase Correlations (Feature vs Metric)", + tools="pan,box_zoom,reset,save", + toolbar_location="right" + ) + + mapper_min, mapper_max = -1.0, 1.0 + + p.rect( + x="feature_idx", + y="metric_idx", + width=1, + height=1, + source=source, + line_color=None, + fill_color="navy", + fill_alpha=0.5, + ) + + p.add_tools( + HoverTool( + tooltips=[ + ("Feature", "@feature"), + ("Metric", "@metric"), + ("Correlation", "@correlation{0.3f}") + ] + ) + ) + + p.xaxis.major_label_orientation = 1.2 + return p + + +def bokeh_roc_plot(roc_curves, selected_models): + p = figure( + height=400, + title="ROC Curves", + x_axis_label="False Positive Rate", + y_axis_label="True Positive Rate", + tools="pan,box_zoom,reset,save", + toolbar_location="right", + ) + p.line([0, 1], [0, 1], line_dash="dashed", color="gray", legend_label="No-skill") + + colors = ["blue", "green", "red", "purple", "orange", "brown"] + for i, model in enumerate(selected_models): + df = roc_curves[model] + p.line(df["fpr"], df["tpr"], line_width=2, color=colors[i % len(colors)], legend_label=model) + + p.legend.location = "lower right" + return p + + +def bokeh_prc_plot(prc_curves, selected_models, no_skill_precision=0.3): + p = figure( + height=400, + title="PRC Curves", + x_axis_label="Recall", + y_axis_label="Precision", + tools="pan,box_zoom,reset,save", + toolbar_location="right", + ) + p.line([0, 1], [no_skill_precision, no_skill_precision], line_dash="dashed", color="gray", legend_label="No-skill") + + colors = ["blue", "green", "red", "purple", "orange", "brown"] + for i, model in enumerate(selected_models): + df = prc_curves[model] + p.line(df["recall"], df["precision"], line_width=2, color=colors[i % len(colors)], legend_label=model) + + p.legend.location = "lower left" + return p + + +# ------------------------- +# Streamlit App +# ------------------------- + +def main(): + st.set_page_config(page_title="STREAMLINE Statistics & Reporting Demo", layout="wide") + + st.title("STREAMLINE Phase 8 — Statistics & Reporting Demo") + st.write( + "Sample Streamlit app using **pandas** and **Bokeh** to visualize " + "the kinds of outputs our statistics/reporting phase should produce." + ) + + # Generate sample data once (could cache with st.cache_data in real app) + df_metrics = make_sample_metrics() + df_ensembles = make_sample_ensembles() + df_fi = make_sample_feature_importance() + df_corr = make_sample_crossphase_correlations() + roc_curves, prc_curves = make_sample_curves() + + st.sidebar.header("Controls") + section = st.sidebar.selectbox( + "Section", + [ + "Summary Metrics", + "Ensemble vs Base", + "Feature Importance", + "Cross-phase Correlations", + "ROC & PRC Curves", + ] + ) + + st.sidebar.markdown("---") + st.sidebar.caption("Demo only - all numbers are synthetic.") + + if section == "Summary Metrics": + st.subheader("Summary Metrics (per model)") + metric = st.selectbox("Metric", sorted(df_metrics["metric"].unique())) + st.dataframe(df_metrics[df_metrics["metric"] == metric].sort_values("mean", ascending=False)) + + p = bokeh_bar_model_metric(df_metrics, metric) + st.bokeh_chart(p, use_container_width=True) + + elif section == "Ensemble vs Base": + st.subheader("Ensemble vs Best Base Model") + st.dataframe(df_ensembles) + + metric_choice = st.selectbox( + "Delta metric", + ["delta_bal_acc", "delta_roc_auc", "delta_prc_aps"], + format_func=lambda x: { + "delta_bal_acc": "Δ Balanced Accuracy", + "delta_roc_auc": "Δ ROC AUC", + "delta_prc_aps": "Δ PRC APS", + }[x] + ) + p = bokeh_bar_ensembles(df_ensembles, metric_choice) + st.bokeh_chart(p, use_container_width=True) + + elif section == "Feature Importance": + st.subheader("Feature Importance Summary") + algorithm = st.selectbox("Algorithm", sorted(df_fi["algorithm"].unique())) + top_k = st.slider("Top K Features", 5, 30, 15) + st.dataframe( + df_fi[df_fi["algorithm"] == algorithm] + .sort_values("norm_importance", ascending=False) + .head(top_k) + ) + p = bokeh_bar_feature_importance(df_fi, algorithm, top_k=top_k) + st.bokeh_chart(p, use_container_width=True) + + elif section == "Cross-phase Correlations": + st.subheader("Feature vs Metric Correlations") + st.write("E.g., correlation between Feature Importance ranks and performance metrics.") + + st.dataframe(df_corr.head(25)) + p = bokeh_heatmap_crossphase(df_corr) + st.bokeh_chart(p, use_container_width=True) + + elif section == "ROC & PRC Curves": + st.subheader("ROC & PRC Curves (Aggregated by Model)") + models = sorted(roc_curves.keys()) + selected_models = st.multiselect("Models to plot", models, default=models[:3]) + + if selected_models: + col1, col2 = st.columns(2) + with col1: + p_roc = bokeh_roc_plot(roc_curves, selected_models) + st.bokeh_chart(p_roc, use_container_width=True) + + with col2: + # toy no-skill level + no_skill_precision = 0.3 + p_prc = bokeh_prc_plot(prc_curves, selected_models, no_skill_precision=no_skill_precision) + st.bokeh_chart(p_prc, use_container_width=True) + else: + st.info("Select at least one model to view curves.") + + st.markdown("---") + st.caption("STREAMLINE Phase 8 demo - replace synthetic data with real P6/P7/P4 outputs in production.") + + +if __name__ == "__main__": + main() diff --git a/usefulnotebooks/DecisionThreshold_Interactive.ipynb b/usefulnotebooks/DecisionThreshold_Interactive.ipynb new file mode 100644 index 00000000..8e3b84ce --- /dev/null +++ b/usefulnotebooks/DecisionThreshold_Interactive.ipynb @@ -0,0 +1,496 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Useful Notebook: Interactively View Alternative Decision Thresholds for a Trained Model\n", + "**This notebook will allow users to interactively examine different decision thresholds for a target model, and see how this new threshold impacts confusion matrix metrics (i.e. TP, TN, FP, FN).**\n", + "\n", + "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", + "\n", + "***\n", + "## Notebook Details\n", + "Allows users to interactively examine different decision thresholds (rather than the standard .5 probability of case) for a target model and see how new thresholds impact model performance metrics.\n", + "\n", + "This notebook is designed to be run on a single model (i.e. specific dataset, CV, and algorithm)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Notebook Run Parameters\n", + "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed).\n", + "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "experiment_path = \"/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/test/out_full_pipeline/DemoExp\" # path the target experiment folder \n", + "targetDataName = 'hcc_survival' # specify a specific dataset\n", + "algorithm = 'Decision Tree' # specify algorithm\n", + "cvCount = 0 #specify the CV number" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Housekeeping\n", + "### Import Packages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib notebook\n", + "from ipywidgets import *\n", + "\n", + "import os\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "from sklearn import metrics\n", + "pd.options.display.float_format = \"{:.4f}\".format\n", + "sns.set(palette='rainbow', context='talk')\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn import svm\n", + "from sklearn.svm import SVC\n", + "from sklearn.metrics import confusion_matrix\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import StandardScaler\n", + "from matplotlib.widgets import Slider\n", + "\n", + "import pickle\n", + "import seaborn as sns\n", + "from sklearn import metrics\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", + "#from IPython.core.interactiveshell import InteractiveShell\n", + "#InteractiveShell.ast_node_interactivity = \"all\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Automatically detect data folder names" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get dataset paths for all completed dataset analyses in experiment folder\n", + "experiment_name = experiment_path.split('/')[-1]\n", + "remove_list = {\n", + " '.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", + " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs', 'KeyFileCopy', 'dask_logs',\n", + " 'reporting', 'reporting_replication', 'run_params.pickle', 'runtime',\n", + " experiment_name + '_STREAMLINE_Report.pdf'\n", + "}\n", + "\n", + "datasets = []\n", + "for d in sorted(os.listdir(experiment_path)):\n", + " dpath = os.path.join(experiment_path, d)\n", + " if d in remove_list or not os.path.isdir(dpath):\n", + " continue\n", + " has_exploratory = os.path.isdir(os.path.join(dpath, 'exploratory'))\n", + " has_model_data = os.path.isdir(os.path.join(dpath, 'model_evaluation')) or os.path.isdir(os.path.join(dpath, 'models'))\n", + " if has_exploratory and has_model_data:\n", + " datasets.append(d)\n", + "\n", + "print(\"Analyzed Datasets: \" + str(datasets))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load other necessary parameters" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Unpickle metadata from previous phase\n", + "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", + "metadata = pickle.load(file)\n", + "file.close()\n", + "#Load variables specified earlier in the pipeline from metadata\n", + "outcome_label = metadata.get('Outcome Label', metadata.get('Class Label', 'Class'))\n", + "instance_label = metadata['Instance Label']\n", + "cv_partitions = int(metadata['CV Partitions'])\n", + "primary_metirc = metadata.get('Primary Metric', metadata.get('P6 Scoring Metric', metadata.get('P8 Scoring Metric', 'balanced_accuracy')))\n", + "\n", + "#Unpickle algorithm information from previous phase\n", + "alg_info_path = os.path.join(experiment_path, \"algInfo.pickle\")\n", + "if os.path.exists(alg_info_path):\n", + " with open(alg_info_path, \"rb\") as file:\n", + " algInfo = pickle.load(file)\n", + "else:\n", + " algInfo = {}\n", + "\n", + "algorithms = []\n", + "abbrev = {}\n", + "colors = {}\n", + "for key, value in algInfo.items():\n", + " if isinstance(value, (list, tuple)) and len(value) > 0 and bool(value[0]):\n", + " algorithms.append(key)\n", + " abbrev[key] = value[1] if len(value) > 1 else key\n", + " colors[key] = value[2] if len(value) > 2 else None\n", + "\n", + "# Fallback: infer algorithms from current output layout\n", + "if not algorithms:\n", + " inferred = set()\n", + " scan_datasets = [d for d in datasets if os.path.isdir(os.path.join(experiment_path, d))]\n", + " for ds_name in scan_datasets:\n", + " model_dir = os.path.join(experiment_path, ds_name, \"models\", \"pickledModels\")\n", + " if os.path.isdir(model_dir):\n", + " for fname in os.listdir(model_dir):\n", + " if fname.endswith('.pickle') and '_' in fname:\n", + " inferred.add(fname.rsplit('_', 1)[0])\n", + " metric_dir = os.path.join(experiment_path, ds_name, \"model_evaluation\", \"metrics_by_cv\")\n", + " if os.path.isdir(metric_dir):\n", + " for fname in os.listdir(metric_dir):\n", + " if fname.endswith('.json') and '_CV_' in fname:\n", + " inferred.add(fname.split('_CV_')[0])\n", + " for abr in sorted(inferred):\n", + " algorithms.append(abr)\n", + " abbrev[abr] = abr\n", + " colors[abr] = None\n", + "\n", + "palette = [\"#1f77b4\", \"#ff7f0e\", \"#2ca02c\", \"#d62728\", \"#9467bd\", \"#8c564b\", \"#e377c2\", \"#7f7f7f\", \"#bcbd22\", \"#17becf\"]\n", + "for idx, key in enumerate(algorithms):\n", + " if colors.get(key) is None:\n", + " colors[key] = palette[idx % len(palette)]\n", + "\n", + "print(\"Algorithms Ran: \" + str(algorithms))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define Necessary Methods" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def lnsp(initial, max, num):\n", + " diff = max - initial\n", + " list1 = []\n", + " for i in range(num):\n", + " list1.append(initial + (i * diff/num))\n", + " return list1\n", + "\n", + "\n", + "def get_fp_tp(y_test, proba, thresh):\n", + " pred = []\n", + " fp = 0\n", + " tp = 0\n", + " fn = 0\n", + " tn = 0\n", + " threshold = round(thresh, 2)\n", + " for i in range(len(proba)):\n", + " if proba[i] >= threshold:\n", + " pred.append(1)\n", + " elif proba[i] < threshold:\n", + " pred.append(0)\n", + " np.asarray(y_test)\n", + " y_test = y_test.tolist()\n", + " for i in range(len(y_test)):\n", + " if y_test[i] == pred[i]:\n", + " if y_test[i] == 1:\n", + " tp += 1\n", + " elif y_test[i] == 0:\n", + " tn += 1\n", + " elif y_test[i] != pred[i]:\n", + " if pred[i]== 1:\n", + " fp += 1\n", + " elif pred[i] == 0:\n", + " fn += 1\n", + " return fp, tp, fn, tn\n", + "\n", + "def get_fpr_tpr(y_test, proba):\n", + " negatives = np.sum(y_test == 0)\n", + " positives = np.sum(y_test == 1)\n", + " columns = ['threshold', 'false_positive_rate', 'true_positive_rate']\n", + " fptp = pd.DataFrame(columns=columns, dtype=np.number)\n", + " thresholds = np.linspace(0, 1, 101)\n", + " for i, threshold in enumerate(thresholds):\n", + " fptp.loc[i, 'threshold'] = threshold\n", + " false_positives, true_positives, fn, tn = get_fp_tp(y_test, proba, threshold)\n", + " fptp.loc[i, 'false_positive_rate'] = false_positives / negatives\n", + " fptp.loc[i, 'true_positive_rate'] = true_positives / positives\n", + " fptp.head(15)\n", + " return fptp\n", + "\n", + "def get_tfpn(y_test, proba):\n", + " columns = ['threshold', 'false_positives', 'true_positives', 'false_negatives',]\n", + " tfpn = pd.DataFrame(columns=columns, dtype=np.number)\n", + " thresholds = np.linspace(0, 1, 101)\n", + " for i, threshold in enumerate(thresholds):\n", + " tfpn.loc[i, 'threshold'] = round(threshold, 2)\n", + " false_positives, true_positives, false_negatives, true_negatives = get_fp_tp(y_test, proba, round(threshold, 2))\n", + " tfpn.loc[i, 'false_positives'] = false_positives\n", + " tfpn.loc[i, 'true_positives'] = true_positives\n", + " tfpn.loc[i, 'false_negatives'] = false_negatives\n", + " tfpn.loc[i, 'true_negatives'] = true_negatives\n", + " return tfpn\n", + "\n", + "def cm_maker(y_test, proba, thresh):\n", + " tfpn = get_tfpn(y_test, proba)\n", + " tfpn_partial = tfpn.loc[tfpn['threshold'] == thresh]\n", + " #print(np.array(tfpn_partial.true_positives))\n", + " cm_part_1 = np.array(tfpn_partial.true_positives)\n", + " cm_part_2 = np.array(tfpn_partial.false_negatives)\n", + " cm_part_3 = np.array(tfpn_partial.false_positives)\n", + " cm_part_4 = np.array(tfpn_partial.true_negatives)\n", + " merge = np.concatenate((cm_part_1, cm_part_2))\n", + " merge_2 = np.concatenate((cm_part_3, cm_part_4))\n", + " cm_final = np.concatenate(([merge], [merge_2]))\n", + " return cm_final\n", + "\n", + "def graph_roc(y_test, proba, fig, ax, threshold, tpr, fpr, AUC):\n", + " # ax = ax.flatten()\n", + " auc=metrics.roc_auc_score(y_test, proba)\n", + " # ax.plot(fpr, tpr, label=\"AUC=\" + str(auc))\n", + " ax.plot(fpr, tpr, label='AUC:' + str(AUC))\n", + " ax.set(ylabel = ('True Positive Rate'),\n", + " xlabel = ('False Positive Rate'))\n", + " ax.legend()\n", + "\n", + "def getdata(threshold, fprtpr):\n", + " point = fprtpr.loc[fprtpr['threshold'] == threshold]\n", + " fpr = np.array(point.false_positive_rate)\n", + " tpr = np.array(point.true_positive_rate)\n", + " return fpr, tpr\n", + "\n", + "def graph_line(ax, threshold, fprtpr):\n", + " fpr, tpr = getdata(threshold, fprtpr)\n", + " vert_line = ax.axvline(x=fpr, color='gray', linestyle='--')\n", + " hori_line = ax.axhline(y=tpr, color='gray', linestyle='--')\n", + "\n", + " # vert_line.remove(vert_line)\n", + " # vert_line = ax.axvline(x=(threshold*0.2), color='gray', linestyle='--')\n", + " return vert_line, hori_line\n", + "\n", + "def plot_point(ax, threshold, fprtpr):\n", + " fpr, tpr = getdata(threshold, fprtpr)\n", + " ptplt = ax.plot(fpr, tpr, color='blue', marker='o', markersize=8)\n", + " ax.legend()\n", + " return ptplt\n", + "\n", + "def get_cms(y_test, proba):\n", + " thresholds = np.linspace(0, 1, 101)\n", + " ls = []\n", + " for i in thresholds:\n", + " cm = cm_maker(y_test, proba, round(i, 2)).tolist()\n", + " ls.append(cm)\n", + " return ls\n", + "\n", + "def get_auc(model, x_test, y_test):\n", + " y_predict = model.predict(x_test)\n", + " AUC = metrics.roc_auc_score(y_test, y_predict)\n", + " print(AUC)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Activate an Interactive Window to Explore Model Decision Thresholds" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "global point, hline, vline, coordinate\n", + "\n", + "full_path = experiment_path+'/'+targetDataName\n", + "\n", + "# Resolve selected algorithm key\n", + "selected_algorithm = algorithm\n", + "if selected_algorithm not in abbrev:\n", + " reverse_map = {v: k for k, v in abbrev.items()}\n", + " if selected_algorithm in reverse_map:\n", + " selected_algorithm = reverse_map[selected_algorithm]\n", + "if selected_algorithm not in abbrev:\n", + " if not algorithms:\n", + " raise ValueError(\"No algorithms were discovered in this experiment.\")\n", + " print(\"Requested algorithm not found. Using first available algorithm: \" + str(algorithms[0]))\n", + " selected_algorithm = algorithms[0]\n", + "if cvCount >= cv_partitions:\n", + " raise ValueError(\"cvCount {} exceeds available CV partitions {}\".format(cvCount, cv_partitions))\n", + "\n", + "model_file = full_path+'/models/pickledModels/'+abbrev[selected_algorithm]+\"_\"+str(cvCount)+'.pickle'\n", + "with open(model_file, 'rb') as file:\n", + " model = pickle.load(file)\n", + "\n", + "#load testing data\n", + "test_file_path = full_path + '/CVDatasets/' + targetDataName + \"_CV_\" + str(cvCount) + \"_Test.csv\"\n", + "test = pd.read_csv(test_file_path)\n", + "if instance_label != 'None' and instance_label in test.columns:\n", + " test = test.drop(instance_label, axis=1)\n", + "x_test = test.drop(outcome_label,axis=1).values\n", + "y_test = test[outcome_label].values\n", + "\n", + "del test #memory cleanup\n", + "\n", + "if not hasattr(model, 'predict_proba'):\n", + " raise ValueError(\"Selected model does not support predict_proba.\")\n", + "proba_all = model.predict_proba(x_test)\n", + "if len(proba_all.shape) != 2 or proba_all.shape[1] < 2:\n", + " raise ValueError(\"DecisionThreshold_Interactive expects probability output.\")\n", + "\n", + "classes = list(getattr(model, 'classes_', range(proba_all.shape[1])))\n", + "if proba_all.shape[1] > 2 or len(np.unique(y_test)) > 2:\n", + " positive_class = 1 if 1 in classes else classes[0]\n", + " class_index = classes.index(positive_class)\n", + " y_eval = (y_test == positive_class).astype(int)\n", + " proba = proba_all[:, class_index]\n", + " print('Multiclass detected. Using one-vs-rest for class: ' + str(positive_class))\n", + "else:\n", + " y_eval = y_test\n", + " proba = proba_all[:,1]\n", + "\n", + "if len(np.unique(y_eval)) < 2:\n", + " raise ValueError('DecisionThreshold_Interactive requires two classes after conversion.')\n", + "\n", + "tfpn = get_tfpn(y_eval, proba)\n", + "\n", + "threshold = 0.5\n", + "fprtpr = get_fpr_tpr(y_eval, proba)\n", + "fprtpr.threshold = round(fprtpr.threshold, 2)\n", + "fpr_roc = fprtpr.false_positive_rate\n", + "tpr_roc = fprtpr.true_positive_rate\n", + "\n", + "y_predict = model.predict(x_test)\n", + "AUC = metrics.roc_auc_score(y_eval, proba)\n", + "\n", + "cms = get_cms(y_eval, proba)\n", + "cm = np.asarray(cms[int(round(threshold, 0) * 100)])\n", + "fig, ax = plt.subplots(nrows=1, ncols=2, figsize = (14, 7))\n", + "fig.tight_layout(pad = 2)\n", + "fpr, tpr = getdata(threshold, fprtpr)\n", + "coordinate = ax[0].text(fpr+0.05, tpr+0.02, s=str(fpr) + str(tpr), fontsize= 12)\n", + "graph_roc(y_eval, proba, fig, ax[0], threshold, tpr_roc, fpr_roc, AUC)\n", + "ax[1].imshow(cm, interpolation='nearest', cmap=plt.cm.Wistia)\n", + "fig.subplots_adjust(bottom=0.25)\n", + "classNames = ['Positive', 'Negative']\n", + "tick_marks = np.arange(len(classNames))\n", + "ax[1].set(ylabel = 'True label',\n", + " xlabel = 'Predicted label',\n", + " xticks = np.arange(len(classNames)),\n", + " yticks = np.arange(len(classNames)),\n", + " xticklabels = classNames,\n", + " yticklabels = classNames)\n", + "s = [['TP', 'FN'], ['FP', 'TN']]\n", + "for i in range(2):\n", + " for j in range(2):\n", + " ax[1].text(j-0.3, i, str(s[i][j]) + \" = \" + str(cm[i][j]))\n", + "fig.subplots_adjust(bottom=0.25)\n", + "\n", + "vline, hline = graph_line(ax[0], threshold, fprtpr)\n", + "point, = plot_point(ax[0], threshold, fprtpr)\n", + "\n", + "sli_ax = plt.axes([0.25, 0.1, .65, .03])\n", + "thr_slider = Slider(sli_ax, 'Threshold', valmin=0, valmax=1, valinit=0.5, valstep=0.01)\n", + "\n", + "\n", + "def update(val):\n", + " global point, coordinate\n", + " ax[1].clear()\n", + " threshold = round(thr_slider.val, 2)\n", + "\n", + " coordinate.remove()\n", + " fpr, tpr = getdata(threshold, fprtpr)\n", + " hline.set_ydata(y=tpr)\n", + " vline.set_xdata(x=fpr)\n", + " point.set_data(fpr, tpr)\n", + " point.set_data(fpr, tpr)\n", + " y_predict = model.predict(x_test)\n", + " AUC = metrics.roc_auc_score(y_eval, proba)\n", + " coordinate = ax[0].text(fpr+0.05, tpr+0.02, s=str(fpr)+str(tpr), fontsize = 12)\n", + "\n", + " cm = np.asarray(cms[int(round(threshold*100, 0))])\n", + " ax[1].imshow(cm, interpolation='nearest', cmap=plt.cm.Wistia)\n", + " classNames = ['Positive', 'Negative']\n", + " tick_marks = np.arange(len(classNames))\n", + " ax[1].set(ylabel='True label',\n", + " xlabel='Predicted label',\n", + " xticks=np.arange(len(classNames)),\n", + " yticks=np.arange(len(classNames)),\n", + " xticklabels=classNames,\n", + " yticklabels=classNames)\n", + " s = [['TP', 'FN'], ['FP', 'TN']]\n", + " for i in range(2):\n", + " for j in range(2):\n", + " ax[1].text(j-.4, i, str(s[i][j]) + \" = \" + str(cm[i][j]))\n", + "\n", + " fig.canvas.draw()\n", + "\n", + "thr_slider.on_changed(update)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "streamline", + "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.8.17" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/usefulnotebooks/DecisionThreshold_TestEval.ipynb b/usefulnotebooks/DecisionThreshold_TestEval.ipynb new file mode 100644 index 00000000..a83acc26 --- /dev/null +++ b/usefulnotebooks/DecisionThreshold_TestEval.ipynb @@ -0,0 +1,611 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Useful Notebook: Re-Evaluate Models Testing Data Performance Using an Alternative Decision Threshold\n", + "**This notebook will allow users to (1) re-evaluate all trained models on the respective testing datasets using a decision threshold other than the default 0.5, (2) re-generate metric evaluation boxplots comparing algorithm performance using this new decision threshold, and (3) re-run statistical significance analyses comparing algorithm performance using this new decision threshold.**\n", + "\n", + "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", + "\n", + "***\n", + "## Notebook Details\n", + "Allows users to specify alternative decision thresholds (rather than the standard 0.5 probability) and re-evaluate algorithm performane metrics. All results are saved in the same locations in the experiment folder as their original counterparts (with a modified name). \n", + "\n", + "Warning: Since this is run on testing data, this should not be used to pick a new decision threshold (otherwise the resulting model+threshold may be overfit). \n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Notebook Run Parameters\n", + "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed). \n", + "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "experiment_path = \"/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/test/out_full_pipeline/DemoExp\" # path the target experiment folder \n", + "targetDataName = None # 'None' if user wants to generate visualizations for all analyzed datasets\n", + "algorithms = [] # use empty list if user wishes re-evaluate all modeling algorithms that were run in pipeline.\n", + "threshold = 0.2 # Threshold of case probability used to predict case (typically 0.5 by default in modeling)\n", + "plot_metric_boxplots = True # Plot new boxplots for each metric using new threshold.\n", + "run_sig_test = True # Rerun non-parametric significance testing between all algorithms for each metric.\n", + "name_modifier = '_T_'+str(threshold) # Modifies names of stats files to avoid overwriting originals (This can be left as is or altered)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Housekeeping\n", + "### Import Packages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "import pickle\n", + "from statistics import mean,stdev\n", + "import numpy as np\n", + "from scipy import stats\n", + "interp = np.interp\n", + "# Evalutation metrics\n", + "from sklearn.metrics import accuracy_score\n", + "from sklearn.metrics import balanced_accuracy_score\n", + "from sklearn.metrics import recall_score\n", + "from sklearn.metrics import confusion_matrix\n", + "from sklearn.metrics import precision_score\n", + "from sklearn.metrics import f1_score\n", + "from sklearn.metrics import roc_curve, auc, precision_recall_curve\n", + "from sklearn import metrics\n", + "import csv\n", + "import matplotlib.pyplot as plt\n", + "import copy\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", + "from IPython.core.interactiveshell import InteractiveShell\n", + "InteractiveShell.ast_node_interactivity = \"all\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Automatically detect data folder names" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get dataset paths for all completed dataset analyses in experiment folder\n", + "experiment_name = experiment_path.split('/')[-1]\n", + "remove_list = {\n", + " '.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", + " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs', 'KeyFileCopy', 'dask_logs',\n", + " 'reporting', 'reporting_replication', 'run_params.pickle', 'runtime',\n", + " experiment_name + '_STREAMLINE_Report.pdf'\n", + "}\n", + "\n", + "datasets = []\n", + "for d in sorted(os.listdir(experiment_path)):\n", + " dpath = os.path.join(experiment_path, d)\n", + " if d in remove_list or not os.path.isdir(dpath):\n", + " continue\n", + " has_exploratory = os.path.isdir(os.path.join(dpath, 'exploratory'))\n", + " has_model_data = os.path.isdir(os.path.join(dpath, 'model_evaluation')) or os.path.isdir(os.path.join(dpath, 'models'))\n", + " if has_exploratory and has_model_data:\n", + " datasets.append(d)\n", + "\n", + "print(\"Analyzed Datasets: \" + str(datasets))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load other necessary parameters" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Unpickle metadata from previous phase\n", + "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", + "metadata = pickle.load(file)\n", + "file.close()\n", + "# Load variables specified earlier in the pipeline from metadata\n", + "outcome_label = metadata.get('Outcome Label', metadata.get('Class Label', 'Class'))\n", + "instance_label = metadata['Instance Label']\n", + "cv_partitions = int(metadata['CV Partitions'])\n", + "sig_cutoff =float(metadata['Statistical Significance Cutoff'])\n", + "primary_metirc = metadata.get('Primary Metric', metadata.get('P6 Scoring Metric', metadata.get('P8 Scoring Metric', 'balanced_accuracy')))\n", + "\n", + "requested_algorithms = list(algorithms) if isinstance(algorithms, list) else []\n", + "\n", + "# Unpickle algorithm information from previous phase\n", + "alg_info_path = os.path.join(experiment_path, \"algInfo.pickle\")\n", + "if os.path.exists(alg_info_path):\n", + " with open(alg_info_path, \"rb\") as file:\n", + " algInfo = pickle.load(file)\n", + "else:\n", + " algInfo = {}\n", + "\n", + "algorithms = []\n", + "abbrev = {}\n", + "colors = {}\n", + "for key, value in algInfo.items():\n", + " if isinstance(value, (list, tuple)) and len(value) > 0 and bool(value[0]):\n", + " algorithms.append(key)\n", + " abbrev[key] = value[1] if len(value) > 1 else key\n", + " colors[key] = value[2] if len(value) > 2 else None\n", + "\n", + "# Fallback: infer algorithms from current output layout\n", + "if not algorithms:\n", + " inferred = set()\n", + " scan_datasets = [d for d in datasets if os.path.isdir(os.path.join(experiment_path, d))]\n", + " for ds_name in scan_datasets:\n", + " model_dir = os.path.join(experiment_path, ds_name, \"models\", \"pickledModels\")\n", + " if os.path.isdir(model_dir):\n", + " for fname in os.listdir(model_dir):\n", + " if fname.endswith('.pickle') and '_' in fname:\n", + " inferred.add(fname.rsplit('_', 1)[0])\n", + " metric_dir = os.path.join(experiment_path, ds_name, \"model_evaluation\", \"metrics_by_cv\")\n", + " if os.path.isdir(metric_dir):\n", + " for fname in os.listdir(metric_dir):\n", + " if fname.endswith('.json') and '_CV_' in fname:\n", + " inferred.add(fname.split('_CV_')[0])\n", + " for abr in sorted(inferred):\n", + " algorithms.append(abr)\n", + " abbrev[abr] = abr\n", + " colors[abr] = None\n", + "\n", + "if requested_algorithms:\n", + " req = set(requested_algorithms)\n", + " filtered = [a for a in algorithms if a in req or abbrev.get(a) in req]\n", + " if filtered:\n", + " algorithms = filtered\n", + "\n", + "palette = [\"#1f77b4\", \"#ff7f0e\", \"#2ca02c\", \"#d62728\", \"#9467bd\", \"#8c564b\", \"#e377c2\", \"#7f7f7f\", \"#bcbd22\", \"#17becf\"]\n", + "for idx, key in enumerate(algorithms):\n", + " if colors.get(key) is None:\n", + " colors[key] = palette[idx % len(palette)]\n", + "\n", + "print(\"Algorithms Ran: \" + str(algorithms))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define Necessary Methods" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def classEval(y_true, y_pred):\n", + " \"\"\" Calculates standard classification metrics including:\n", + " True positives, false positives, true negative, false negatives, standard accuracy, balanced accuracy\n", + " recall, precision, f1 score, negative predictive value, likelihood ratio positive, and likelihood ratio negative\"\"\"\n", + " #Calculate true positive, true negative, false positive, and false negative.\n", + " tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()\n", + " #Calculate Accuracy metrics\n", + " ac = accuracy_score(y_true, y_pred)\n", + " bac = balanced_accuracy_score(y_true, y_pred)\n", + " #Calculate Precision and Recall\n", + " re = recall_score(y_true, y_pred)\n", + " pr = precision_score(y_true, y_pred)\n", + " #Calculate F1 score\n", + " f1 = f1_score(y_true, y_pred)\n", + " # Calculate specificity\n", + " if tn == 0 and fp == 0:\n", + " sp = 0\n", + " else:\n", + " sp = tn / float(tn + fp)\n", + " # Calculate Negative predictive value\n", + " if tn == 0 and fn == 0:\n", + " npv = 0\n", + " else:\n", + " npv = tn/float(tn+fn)\n", + " # Calculate likelihood ratio postive\n", + " if sp == 1:\n", + " lrp = 0\n", + " else:\n", + " lrp = re/float(1-sp)\n", + " # Calculate likeliehood ratio negative\n", + " if sp == 0:\n", + " lrm = 0\n", + " else:\n", + " lrm = (1-re)/float(sp)\n", + " return [bac, ac, f1, re, sp, pr, tp, tn, fp, fn, npv, lrp, lrm]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def saveMetricMeans(full_path,metrics,metric_dict,name_modifier):\n", + " \"\"\" Exports csv file with average metric values (over all CVs) for each ML modeling algorithm\"\"\"\n", + " with open(full_path+'/model_evaluation/Summary_performance_mean'+name_modifier+'.csv',mode='w', newline=\"\") as file:\n", + " writer = csv.writer(file, delimiter=',', quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n", + " e = ['']\n", + " e.extend(metrics)\n", + " writer.writerow(e) #Write headers (balanced accuracy, etc.)\n", + " for algorithm in metric_dict:\n", + " astats = []\n", + " for l in list(metric_dict[algorithm].values()):\n", + " l = [float(i) for i in l]\n", + " meani = mean(l)\n", + " std = stdev(l)\n", + " astats.append(str(meani))\n", + " toAdd = [algorithm]\n", + " toAdd.extend(astats)\n", + " writer.writerow(toAdd)\n", + " file.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def saveMetricStd(full_path,metrics,metric_dict,name_modifier):\n", + " \"\"\" Exports csv file with metric value standard deviations (over all CVs) for each ML modeling algorithm\"\"\"\n", + " with open(full_path + '/model_evaluation/Summary_performance_std'+name_modifier+'.csv', mode='w', newline=\"\") as file:\n", + " writer = csv.writer(file, delimiter=',', quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n", + " e = ['']\n", + " e.extend(metrics)\n", + " writer.writerow(e) # Write headers (balanced accuracy, etc.)\n", + " for algorithm in metric_dict:\n", + " astats = []\n", + " for l in list(metric_dict[algorithm].values()):\n", + " l = [float(i) for i in l]\n", + " std = stdev(l)\n", + " astats.append(str(std))\n", + " toAdd = [algorithm]\n", + " toAdd.extend(astats)\n", + " writer.writerow(toAdd)\n", + " file.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def metricBoxplots(full_path,metrics,algorithms,metric_dict,name_modifier):\n", + " \"\"\" Export boxplots comparing algorithm performance for each standard metric\"\"\"\n", + " if not os.path.exists(full_path + '/model_evaluation/metricBoxplots'):\n", + " os.mkdir(full_path + '/model_evaluation/metricBoxplots')\n", + " for metric in metrics:\n", + " tempList = []\n", + " for algorithm in algorithms:\n", + " tempList.append(metric_dict[algorithm][metric])\n", + " td = pd.DataFrame(tempList)\n", + " td = td.transpose()\n", + " td.columns = algorithms\n", + " #Generate boxplot\n", + " boxplot = td.boxplot(column=algorithms,rot=90)\n", + " #Specify plot labels\n", + " plt.ylabel(str(metric))\n", + " plt.xlabel('ML Algorithm')\n", + " #Export and/or show plot\n", + " plt.savefig(full_path + '/model_evaluation/metricBoxplots/Compare_'+metric+name_modifier+'.png', bbox_inches=\"tight\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def kruskalWallis(full_path,metrics,algorithms,metric_dict,sig_cutoff,name_modifier):\n", + " \"\"\" Apply non-parametric Kruskal Wallis one-way ANOVA on ranks. Determines if there is a statistically significant difference in algorithm performance across CV runs.\n", + " Completed for each standard metric separately.\"\"\"\n", + " # Create directory to store significance testing results (used for both Kruskal Wallis and MannWhitney U-test)\n", + " if not os.path.exists(full_path + '/model_evaluation/statistical_comparisons'):\n", + " os.mkdir(full_path + '/model_evaluation/statistical_comparisons')\n", + " #Create dataframe to store analysis results for each metric\n", + " label = ['Statistic', 'P-Value', 'Sig(*)']\n", + " kruskal_summary = pd.DataFrame(index=metrics, columns=label)\n", + " #Apply Kruskal Wallis test for each metric\n", + " for metric in metrics:\n", + " tempArray = []\n", + " for algorithm in algorithms:\n", + " tempArray.append(metric_dict[algorithm][metric])\n", + " try:\n", + " result = stats.kruskal(*tempArray)\n", + " except:\n", + " result = [tempArray[0],1]\n", + " kruskal_summary.at[metric, 'Statistic'] = str(round(result[0], 6))\n", + " kruskal_summary.at[metric, 'P-Value'] = str(round(result[1], 6))\n", + " if result[1] < sig_cutoff:\n", + " kruskal_summary.at[metric, 'Sig(*)'] = str('*')\n", + " else:\n", + " kruskal_summary.at[metric, 'Sig(*)'] = str('')\n", + " #Export analysis summary to .csv file\n", + " kruskal_summary.to_csv(full_path + '/model_evaluation/statistical_comparisons/KruskalWallis'+name_modifier+'.csv')\n", + " return kruskal_summary" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def wilcoxonRank(full_path,metrics,algorithms,metric_dict,kruskal_summary,sig_cutoff,name_modifier):\n", + " \"\"\" Apply non-parametric Wilcoxon signed-rank test (pairwise comparisons). If a significant Kruskal Wallis algorithm difference was found for a given metric, Wilcoxon tests individual algorithm pairs\n", + " to determine if there is a statistically significant difference in algorithm performance across CV runs. Test statistic will be zero if all scores from one set are\n", + " larger than the other.\"\"\"\n", + " for metric in metrics:\n", + " if kruskal_summary['Sig(*)'][metric] == '*':\n", + " wilcoxon_stats = []\n", + " done = []\n", + " for algorithm1 in algorithms:\n", + " for algorithm2 in algorithms:\n", + " if not [algorithm1,algorithm2] in done and not [algorithm2,algorithm1] in done and algorithm1 != algorithm2:\n", + " set1 = metric_dict[algorithm1][metric]\n", + " set2 = metric_dict[algorithm2][metric]\n", + " #handle error when metric values are equal for both algorithms\n", + " combined = copy.deepcopy(set1)\n", + " combined.extend(set2)\n", + " if all(x==combined[0] for x in combined): #Check if all nums are equal in sets\n", + " report = ['NA',1]\n", + " else: # Apply Wilcoxon Rank Sum test\n", + " report = stats.wilcoxon(set1,set2)\n", + " #Summarize test information in list\n", + " tempstats = [algorithm1,algorithm2,report[0],report[1],'']\n", + " if report[1] < sig_cutoff:\n", + " tempstats[4] = '*'\n", + " wilcoxon_stats.append(tempstats)\n", + " done.append([algorithm1,algorithm2])\n", + " #Export test results\n", + " wilcoxon_stats_df = pd.DataFrame(wilcoxon_stats)\n", + " wilcoxon_stats_df.columns = ['Algorithm 1', 'Algorithm 2', 'Statistic', 'P-Value', 'Sig(*)']\n", + " wilcoxon_stats_df.to_csv(full_path + '/model_evaluation/statistical_comparisons/WilcoxonRank_'+metric+name_modifier+'.csv', index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def mannWhitneyU(full_path,metrics,algorithms,metric_dict,kruskal_summary,sig_cutoff,name_modifier):\n", + " \"\"\" Apply non-parametric Mann Whitney U-test (pairwise comparisons). If a significant Kruskal Wallis algorithm difference was found for a given metric, Mann Whitney tests individual algorithm pairs\n", + " to determine if there is a statistically significant difference in algorithm performance across CV runs. Test statistic will be zero if all scores from one set are\n", + " larger than the other.\"\"\"\n", + " for metric in metrics:\n", + " if kruskal_summary['Sig(*)'][metric] == '*':\n", + " mann_stats = []\n", + " done = []\n", + " for algorithm1 in algorithms:\n", + " for algorithm2 in algorithms:\n", + " if not [algorithm1,algorithm2] in done and not [algorithm2,algorithm1] in done and algorithm1 != algorithm2:\n", + " set1 = metric_dict[algorithm1][metric]\n", + " set2 = metric_dict[algorithm2][metric]\n", + " #handle error when metric values are equal for both algorithms\n", + " combined = copy.deepcopy(set1)\n", + " combined.extend(set2)\n", + " if all(x==combined[0] for x in combined): #Check if all nums are equal in sets\n", + " report = ['NA',1]\n", + " else: #Apply Mann Whitney U test\n", + " report = stats.mannwhitneyu(set1,set2)\n", + " #Summarize test information in list\n", + " tempstats = [algorithm1,algorithm2,report[0],report[1],'']\n", + " if report[1] < sig_cutoff:\n", + " tempstats[4] = '*'\n", + " mann_stats.append(tempstats)\n", + " done.append([algorithm1,algorithm2])\n", + " #Export test results\n", + " mann_stats_df = pd.DataFrame(mann_stats)\n", + " mann_stats_df.columns = ['Algorithm 1', 'Algorithm 2', 'Statistic', 'P-Value', 'Sig(*)']\n", + " mann_stats_df.to_csv(full_path + '/model_evaluation/statistical_comparisons/MannWhitneyU_'+metric+name_modifier+'.csv', index=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run New Testing Evaluation and Metric Boxplot Generation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "if targetDataName not in (None, 'None'):\n", + " datasets = [d for d in datasets if d == targetDataName]\n", + "print(\"Vizualized Datasets: \" + str(datasets))\n", + "\n", + "if not algorithms:\n", + " raise ValueError(\"No algorithms discovered. Check experiment path and model outputs.\")\n", + "\n", + "for each in datasets: #each analyzed dataset to make plots for\n", + " print(\"---------------------------------------\")\n", + " print(each)\n", + " print(\"---------------------------------------\")\n", + " full_path = experiment_path+'/'+each\n", + " metric_dict = {}\n", + "\n", + " for algorithm in algorithms: #loop through algorithms\n", + " s_bac = []\n", + " s_ac = []\n", + " s_f1 = []\n", + " s_re = []\n", + " s_sp = []\n", + " s_pr = []\n", + " s_tp = []\n", + " s_tn = []\n", + " s_fp = []\n", + " s_fn = []\n", + " s_npv = []\n", + " s_lrp = []\n", + " s_lrm = []\n", + " aucs = []\n", + " praucs = []\n", + " aveprecs = []\n", + "\n", + " for cvCount in range(0,cv_partitions):\n", + " test_file_path = full_path + '/CVDatasets/' + each + \"_CV_\" + str(cvCount) + \"_Test.csv\"\n", + " test = pd.read_csv(test_file_path)\n", + " testY = test[outcome_label].values\n", + " drop_cols = [outcome_label]\n", + " if instance_label != 'None' and instance_label in test.columns:\n", + " drop_cols.append(instance_label)\n", + " testX = test.drop(columns=drop_cols).values\n", + " del test\n", + "\n", + " model_file = full_path+'/models/pickledModels/'+abbrev[algorithm]+\"_\"+str(cvCount)+'.pickle'\n", + " if not os.path.exists(model_file):\n", + " print(\"Missing model file: \" + model_file)\n", + " continue\n", + " with open(model_file, 'rb') as file:\n", + " model = pickle.load(file)\n", + "\n", + " if not hasattr(model, 'predict_proba'):\n", + " print(\"Skipping {} CV {} (predict_proba unavailable)\".format(algorithm, cvCount))\n", + " continue\n", + "\n", + " probas_all = model.predict_proba(testX)\n", + " if len(probas_all.shape) != 2 or probas_all.shape[1] < 2:\n", + " print(\"Skipping {} CV {} (requires probability output)\".format(algorithm, cvCount))\n", + " continue\n", + "\n", + " classes = list(getattr(model, 'classes_', range(probas_all.shape[1])))\n", + " if probas_all.shape[1] > 2 or len(np.unique(testY)) > 2:\n", + " positive_class = 1 if 1 in classes else classes[0]\n", + " class_index = classes.index(positive_class)\n", + " evalY = (testY == positive_class).astype(int)\n", + " probas_pos = probas_all[:, class_index]\n", + " else:\n", + " evalY = testY\n", + " probas_pos = probas_all[:,1]\n", + "\n", + " if len(np.unique(evalY)) < 2:\n", + " print(\"Skipping {} CV {} (only one class present after conversion)\".format(algorithm, cvCount))\n", + " continue\n", + "\n", + " y_pred = probas_pos > threshold\n", + " metricList = classEval(evalY, y_pred)\n", + "\n", + " fpr, tpr, _ = metrics.roc_curve(evalY, probas_pos)\n", + " roc_auc = auc(fpr, tpr)\n", + "\n", + " prec, recall, _ = metrics.precision_recall_curve(evalY, probas_pos)\n", + " prec, recall = prec[::-1], recall[::-1]\n", + " prec_rec_auc = auc(recall, prec)\n", + " ave_prec = metrics.average_precision_score(evalY, probas_pos)\n", + "\n", + " s_bac.append(metricList[0])\n", + " s_ac.append(metricList[1])\n", + " s_f1.append(metricList[2])\n", + " s_re.append(metricList[3])\n", + " s_sp.append(metricList[4])\n", + " s_pr.append(metricList[5])\n", + " s_tp.append(metricList[6])\n", + " s_tn.append(metricList[7])\n", + " s_fp.append(metricList[8])\n", + " s_fn.append(metricList[9])\n", + " s_npv.append(metricList[10])\n", + " s_lrp.append(metricList[11])\n", + " s_lrm.append(metricList[12])\n", + " aucs.append(roc_auc)\n", + " praucs.append(prec_rec_auc)\n", + " aveprecs.append(ave_prec)\n", + "\n", + " if not s_bac:\n", + " print(\"No valid CV predictions for algorithm: \" + str(algorithm))\n", + " continue\n", + "\n", + " results = {\n", + " 'Balanced Accuracy': s_bac, 'Accuracy': s_ac, 'F1 Score': s_f1,\n", + " 'Sensitivity (Recall)': s_re, 'Specificity': s_sp, 'Precision (PPV)': s_pr,\n", + " 'TP': s_tp, 'TN': s_tn, 'FP': s_fp, 'FN': s_fn,\n", + " 'NPV': s_npv, 'LR+': s_lrp, 'LR-': s_lrm,\n", + " 'ROC AUC': aucs, 'PRC AUC': praucs, 'PRC APS': aveprecs\n", + " }\n", + " dr = pd.DataFrame(results)\n", + " filepath = full_path+'/model_evaluation/'+abbrev[algorithm]+\"_performance\"+name_modifier+\".csv\"\n", + " dr.to_csv(filepath, header=True, index=False)\n", + " metric_dict[algorithm] = results\n", + "\n", + " if not metric_dict:\n", + " print(\"No algorithm metrics available for dataset: \" + each)\n", + " continue\n", + "\n", + " my_metrics = list(next(iter(metric_dict.values())).keys())\n", + "\n", + " saveMetricMeans(full_path,my_metrics,metric_dict,name_modifier)\n", + " saveMetricStd(full_path,my_metrics,metric_dict,name_modifier)\n", + "\n", + " if plot_metric_boxplots:\n", + " metricBoxplots(full_path,my_metrics,list(metric_dict.keys()),metric_dict,name_modifier)\n", + "\n", + " if run_sig_test and len(metric_dict) > 1:\n", + " compare_algs = list(metric_dict.keys())\n", + " kruskal_summary = kruskalWallis(full_path,my_metrics,compare_algs,metric_dict,sig_cutoff,name_modifier)\n", + " wilcoxonRank(full_path,my_metrics,compare_algs,metric_dict,kruskal_summary,sig_cutoff,name_modifier)\n", + " mannWhitneyU(full_path,my_metrics,compare_algs,metric_dict,kruskal_summary,sig_cutoff,name_modifier)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "streamline", + "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.8.17" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/usefulnotebooks/DecisionThreshold_TrainEval.ipynb b/usefulnotebooks/DecisionThreshold_TrainEval.ipynb new file mode 100644 index 00000000..fd9462d9 --- /dev/null +++ b/usefulnotebooks/DecisionThreshold_TrainEval.ipynb @@ -0,0 +1,761 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Useful Notebook: Re-Evaluate Models Training Data Performance Using an Alternative Decision Threshold\n", + "**This notebook will allow users to (1) re-evaluate all trained models on respective training datasets using the standard decision threshold of 0.5 or some other threshold, (2) re-generate metric evaluation boxplots comparing algorithm performance using this new decision threshold, and (3) re-run statistical significance analyses comparing algorithm performance using this new decision threshold.**\n", + "\n", + "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", + "\n", + "***\n", + "## Notebook Details\n", + "Allows users to specify alternative decision thresholds (rather than the standard 0.5 probability) and re-evaluate algorithm performane metrics.\n", + "\n", + "Unlike the main pipeline all results output by this notebook are based on the training performance. This script can be used to evaluate and report training data evaluation metrics using different decision threshold. This notebook can also be used to simply obtain training evaluation metrics for the entire pipeline that correspond to the testing output by setting the threshold parameter to 0.5. \n", + "\n", + "All files will be saved in a single new folder in the experiment folder for each target dataset (i.e. `model_training_evaluation`). Also outputs new metric boxplots, ROC, and PRC plots, but now for training performance rather than testing performance.\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Notebook Run Parameters\n", + "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed).\n", + "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "experiment_path = \"/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/test/out_full_pipeline/DemoExp\" # path the target experiment folder \n", + "targetDataName = None # 'None' if user wants to generate visualizations for all analyzed datasets or specify (str) list of target dataset names\n", + "algorithms = [] # use empty list if user wishes re-evaluate all modeling algorithms that were run in pipeline.\n", + "threshold = 0.5 # Threshold of case probability used to predict case (typically 0.5 by default in modeling)\n", + "plot_metric_boxplots = True #Plot new boxplots for each metric using new threshold.\n", + "run_sig_test = True # Rerun non-parametric significance testing between all algorithms for each metric.\n", + "name_modifier = '_T_'+str(threshold) # Modifies names of stats files to avoid overwriting originals (This can be left as is or altered)\n", + "plot_ROC = True #Plot ROC for training data \n", + "plot_PRC = True #Plot PRC for training data\n", + "#available_algorithms = ['Naive Bayes','Logistic Regression','Decision Tree','Random Forest','Gradient Boosting','XGB','LGB','SVM','ANN','K Neighbors','eLCS','XCS','ExSTraCS']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Housekeeping\n", + "### Import Packages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "import pickle\n", + "import copy\n", + "from statistics import mean,stdev\n", + "import numpy as np\n", + "from scipy import stats\n", + "interp = np.interp\n", + "# Evalutation metrics\n", + "from sklearn.metrics import accuracy_score\n", + "from sklearn.metrics import balanced_accuracy_score\n", + "from sklearn.metrics import recall_score\n", + "from sklearn.metrics import confusion_matrix\n", + "from sklearn.metrics import precision_score\n", + "from sklearn.metrics import f1_score\n", + "from sklearn.metrics import roc_curve, auc, precision_recall_curve\n", + "from sklearn import metrics\n", + "import csv\n", + "import matplotlib.pyplot as plt\n", + "import pickle\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", + "from IPython.core.interactiveshell import InteractiveShell\n", + "InteractiveShell.ast_node_interactivity = \"all\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Automatically detect data folder names" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get dataset paths for all completed dataset analyses in experiment folder\n", + "experiment_name = experiment_path.split('/')[-1]\n", + "remove_list = {\n", + " '.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", + " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs', 'KeyFileCopy', 'dask_logs',\n", + " 'reporting', 'reporting_replication', 'run_params.pickle', 'runtime',\n", + " experiment_name + '_STREAMLINE_Report.pdf'\n", + "}\n", + "\n", + "datasets = []\n", + "for d in sorted(os.listdir(experiment_path)):\n", + " dpath = os.path.join(experiment_path, d)\n", + " if d in remove_list or not os.path.isdir(dpath):\n", + " continue\n", + " has_exploratory = os.path.isdir(os.path.join(dpath, 'exploratory'))\n", + " has_model_data = os.path.isdir(os.path.join(dpath, 'model_evaluation')) or os.path.isdir(os.path.join(dpath, 'models'))\n", + " if has_exploratory and has_model_data:\n", + " datasets.append(d)\n", + "\n", + "print(\"Analyzed Datasets: \" + str(datasets))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load other necessary parameters" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Unpickle metadata from previous phase\n", + "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", + "metadata = pickle.load(file)\n", + "file.close()\n", + "# Load variables specified earlier in the pipeline from metadata\n", + "outcome_label = metadata.get('Outcome Label', metadata.get('Class Label', 'Class'))\n", + "instance_label = metadata['Instance Label']\n", + "cv_partitions = int(metadata['CV Partitions'])\n", + "sig_cutoff =float(metadata['Statistical Significance Cutoff'])\n", + "primary_metirc = metadata.get('Primary Metric', metadata.get('P6 Scoring Metric', metadata.get('P8 Scoring Metric', 'balanced_accuracy')))\n", + "\n", + "requested_algorithms = list(algorithms) if isinstance(algorithms, list) else []\n", + "\n", + "#Unpickle algorithm information from previous phase\n", + "alg_info_path = os.path.join(experiment_path, \"algInfo.pickle\")\n", + "if os.path.exists(alg_info_path):\n", + " with open(alg_info_path, \"rb\") as file:\n", + " algInfo = pickle.load(file)\n", + "else:\n", + " algInfo = {}\n", + "\n", + "algorithms = []\n", + "abbrev = {}\n", + "colors = {}\n", + "for key, value in algInfo.items():\n", + " if isinstance(value, (list, tuple)) and len(value) > 0 and bool(value[0]):\n", + " algorithms.append(key)\n", + " abbrev[key] = value[1] if len(value) > 1 else key\n", + " colors[key] = value[2] if len(value) > 2 else None\n", + "\n", + "# Fallback: infer algorithms from current output layout\n", + "if not algorithms:\n", + " inferred = set()\n", + " scan_datasets = [d for d in datasets if os.path.isdir(os.path.join(experiment_path, d))]\n", + " for ds_name in scan_datasets:\n", + " model_dir = os.path.join(experiment_path, ds_name, \"models\", \"pickledModels\")\n", + " if os.path.isdir(model_dir):\n", + " for fname in os.listdir(model_dir):\n", + " if fname.endswith('.pickle') and '_' in fname:\n", + " inferred.add(fname.rsplit('_', 1)[0])\n", + " metric_dir = os.path.join(experiment_path, ds_name, \"model_evaluation\", \"metrics_by_cv\")\n", + " if os.path.isdir(metric_dir):\n", + " for fname in os.listdir(metric_dir):\n", + " if fname.endswith('.json') and '_CV_' in fname:\n", + " inferred.add(fname.split('_CV_')[0])\n", + " for abr in sorted(inferred):\n", + " algorithms.append(abr)\n", + " abbrev[abr] = abr\n", + " colors[abr] = None\n", + "\n", + "if requested_algorithms:\n", + " req = set(requested_algorithms)\n", + " filtered = [a for a in algorithms if a in req or abbrev.get(a) in req]\n", + " if filtered:\n", + " algorithms = filtered\n", + "\n", + "palette = [\"#1f77b4\", \"#ff7f0e\", \"#2ca02c\", \"#d62728\", \"#9467bd\", \"#8c564b\", \"#e377c2\", \"#7f7f7f\", \"#bcbd22\", \"#17becf\"]\n", + "for idx, key in enumerate(algorithms):\n", + " if colors.get(key) is None:\n", + " colors[key] = palette[idx % len(palette)]\n", + "\n", + "print(\"Analyzed Datasets: \" + str(datasets))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define Necessary Methods" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def classEval(y_true, y_pred):\n", + " \"\"\" Calculates standard classification metrics including:\n", + " True positives, false positives, true negative, false negatives, standard accuracy, balanced accuracy\n", + " recall, precision, f1 score, negative predictive value, likelihood ratio positive, and likelihood ratio negative\"\"\"\n", + " #Calculate true positive, true negative, false positive, and false negative.\n", + " tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()\n", + " #Calculate Accuracy metrics\n", + " ac = accuracy_score(y_true, y_pred)\n", + " bac = balanced_accuracy_score(y_true, y_pred)\n", + " #Calculate Precision and Recall\n", + " re = recall_score(y_true, y_pred)\n", + " pr = precision_score(y_true, y_pred)\n", + " #Calculate F1 score\n", + " f1 = f1_score(y_true, y_pred)\n", + " # Calculate specificity\n", + " if tn == 0 and fp == 0:\n", + " sp = 0\n", + " else:\n", + " sp = tn / float(tn + fp)\n", + " # Calculate Negative predictive value\n", + " if tn == 0 and fn == 0:\n", + " npv = 0\n", + " else:\n", + " npv = tn/float(tn+fn)\n", + " # Calculate likelihood ratio postive\n", + " if sp == 1:\n", + " lrp = 0\n", + " else:\n", + " lrp = re/float(1-sp)\n", + " # Calculate likeliehood ratio negative\n", + " if sp == 0:\n", + " lrm = 0\n", + " else:\n", + " lrm = (1-re)/float(sp)\n", + " return [bac, ac, f1, re, sp, pr, tp, tn, fp, fn, npv, lrp, lrm]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def saveMetricMeans(full_path,metrics,metric_dict,name_modifier):\n", + " \"\"\" Exports csv file with average metric values (over all CVs) for each ML modeling algorithm\"\"\"\n", + " with open(full_path+'/model_training_evaluation/Summary_performance_mean'+name_modifier+'.csv',mode='w', newline=\"\") as file:\n", + " writer = csv.writer(file, delimiter=',', quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n", + " e = ['']\n", + " e.extend(metrics)\n", + " writer.writerow(e) #Write headers (balanced accuracy, etc.)\n", + " for algorithm in metric_dict:\n", + " astats = []\n", + " for l in list(metric_dict[algorithm].values()):\n", + " l = [float(i) for i in l]\n", + " meani = mean(l)\n", + " std = stdev(l)\n", + " astats.append(str(meani))\n", + " toAdd = [algorithm]\n", + " toAdd.extend(astats)\n", + " writer.writerow(toAdd)\n", + " file.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def saveMetricStd(full_path,metrics,metric_dict,name_modifier):\n", + " \"\"\" Exports csv file with metric value standard deviations (over all CVs) for each ML modeling algorithm\"\"\"\n", + " with open(full_path + '/model_training_evaluation/Summary_performance_std'+name_modifier+'.csv', mode='w', newline=\"\") as file:\n", + " writer = csv.writer(file, delimiter=',', quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n", + " e = ['']\n", + " e.extend(metrics)\n", + " writer.writerow(e) # Write headers (balanced accuracy, etc.)\n", + " for algorithm in metric_dict:\n", + " astats = []\n", + " for l in list(metric_dict[algorithm].values()):\n", + " l = [float(i) for i in l]\n", + " std = stdev(l)\n", + " astats.append(str(std))\n", + " toAdd = [algorithm]\n", + " toAdd.extend(astats)\n", + " writer.writerow(toAdd)\n", + " file.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def metricBoxplots(full_path,metrics,algorithms,metric_dict,name_modifier):\n", + " \"\"\" Export boxplots comparing algorithm performance for each standard metric\"\"\"\n", + " if not os.path.exists(full_path + '/model_training_evaluation/metricBoxplots'):\n", + " os.mkdir(full_path + '/model_training_evaluation/metricBoxplots')\n", + " for metric in metrics:\n", + " tempList = []\n", + " for algorithm in algorithms:\n", + " tempList.append(metric_dict[algorithm][metric])\n", + " td = pd.DataFrame(tempList)\n", + " td = td.transpose()\n", + " td.columns = algorithms\n", + " #Generate boxplot\n", + " boxplot = td.boxplot(column=algorithms,rot=90)\n", + " #Specify plot labels\n", + " plt.ylabel(str(metric))\n", + " plt.xlabel('ML Algorithm')\n", + " #Export and/or show plot\n", + " plt.savefig(full_path + '/model_training_evaluation/metricBoxplots/Compare_'+metric+name_modifier+'.png', bbox_inches=\"tight\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def kruskalWallis(full_path,metrics,algorithms,metric_dict,sig_cutoff,name_modifier):\n", + " \"\"\" Apply non-parametric Kruskal Wallis one-way ANOVA on ranks. Determines if there is a statistically significant difference in algorithm performance across CV runs.\n", + " Completed for each standard metric separately.\"\"\"\n", + " # Create directory to store significance testing results (used for both Kruskal Wallis and MannWhitney U-test)\n", + " if not os.path.exists(full_path + '/model_training_evaluation/statistical_comparisons'):\n", + " os.mkdir(full_path + '/model_training_evaluation/statistical_comparisons')\n", + " #Create dataframe to store analysis results for each metric\n", + " label = ['Statistic', 'P-Value', 'Sig(*)']\n", + " kruskal_summary = pd.DataFrame(index=metrics, columns=label)\n", + " #Apply Kruskal Wallis test for each metric\n", + " for metric in metrics:\n", + " tempArray = []\n", + " for algorithm in algorithms:\n", + " tempArray.append(metric_dict[algorithm][metric])\n", + " try:\n", + " result = stats.kruskal(*tempArray)\n", + " except:\n", + " result = [tempArray[0],1]\n", + " kruskal_summary.at[metric, 'Statistic'] = str(round(result[0], 6))\n", + " kruskal_summary.at[metric, 'P-Value'] = str(round(result[1], 6))\n", + " if result[1] < sig_cutoff:\n", + " kruskal_summary.at[metric, 'Sig(*)'] = str('*')\n", + " else:\n", + " kruskal_summary.at[metric, 'Sig(*)'] = str('')\n", + " #Export analysis summary to .csv file\n", + " kruskal_summary.to_csv(full_path + '/model_training_evaluation/statistical_comparisons/KruskalWallis'+name_modifier+'.csv')\n", + " return kruskal_summary" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def wilcoxonRank(full_path,metrics,algorithms,metric_dict,kruskal_summary,sig_cutoff,name_modifier):\n", + " \"\"\" Apply non-parametric Wilcoxon signed-rank test (pairwise comparisons). If a significant Kruskal Wallis algorithm difference was found for a given metric, Wilcoxon tests individual algorithm pairs\n", + " to determine if there is a statistically significant difference in algorithm performance across CV runs. Test statistic will be zero if all scores from one set are\n", + " larger than the other.\"\"\"\n", + " for metric in metrics:\n", + " if kruskal_summary['Sig(*)'][metric] == '*':\n", + " wilcoxon_stats = []\n", + " done = []\n", + " for algorithm1 in algorithms:\n", + " for algorithm2 in algorithms:\n", + " if not [algorithm1,algorithm2] in done and not [algorithm2,algorithm1] in done and algorithm1 != algorithm2:\n", + " set1 = metric_dict[algorithm1][metric]\n", + " set2 = metric_dict[algorithm2][metric]\n", + " #handle error when metric values are equal for both algorithms\n", + " combined = copy.deepcopy(set1)\n", + " combined.extend(set2)\n", + " if all(x==combined[0] for x in combined): #Check if all nums are equal in sets\n", + " report = ['NA',1]\n", + " else: # Apply Wilcoxon Rank Sum test\n", + " report = stats.wilcoxon(set1,set2)\n", + " #Summarize test information in list\n", + " tempstats = [algorithm1,algorithm2,report[0],report[1],'']\n", + " if report[1] < sig_cutoff:\n", + " tempstats[4] = '*'\n", + " wilcoxon_stats.append(tempstats)\n", + " done.append([algorithm1,algorithm2])\n", + " #Export test results\n", + " wilcoxon_stats_df = pd.DataFrame(wilcoxon_stats)\n", + " wilcoxon_stats_df.columns = ['Algorithm 1', 'Algorithm 2', 'Statistic', 'P-Value', 'Sig(*)']\n", + " wilcoxon_stats_df.to_csv(full_path + '/model_training_evaluation/statistical_comparisons/WilcoxonRank_'+metric+name_modifier+'.csv', index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def mannWhitneyU(full_path,metrics,algorithms,metric_dict,kruskal_summary,sig_cutoff,name_modifier):\n", + " \"\"\" Apply non-parametric Mann Whitney U-test (pairwise comparisons). If a significant Kruskal Wallis algorithm difference was found for a given metric, Mann Whitney tests individual algorithm pairs\n", + " to determine if there is a statistically significant difference in algorithm performance across CV runs. Test statistic will be zero if all scores from one set are\n", + " larger than the other.\"\"\"\n", + " for metric in metrics:\n", + " if kruskal_summary['Sig(*)'][metric] == '*':\n", + " mann_stats = []\n", + " done = []\n", + " for algorithm1 in algorithms:\n", + " for algorithm2 in algorithms:\n", + " if not [algorithm1,algorithm2] in done and not [algorithm2,algorithm1] in done and algorithm1 != algorithm2:\n", + " set1 = metric_dict[algorithm1][metric]\n", + " set2 = metric_dict[algorithm2][metric]\n", + " #handle error when metric values are equal for both algorithms\n", + " combined = copy.deepcopy(set1)\n", + " combined.extend(set2)\n", + " if all(x==combined[0] for x in combined): #Check if all nums are equal in sets\n", + " report = ['NA',1]\n", + " else: #Apply Mann Whitney U test\n", + " report = stats.mannwhitneyu(set1,set2)\n", + " #Summarize test information in list\n", + " tempstats = [algorithm1,algorithm2,report[0],report[1],'']\n", + " if report[1] < sig_cutoff:\n", + " tempstats[4] = '*'\n", + " mann_stats.append(tempstats)\n", + " done.append([algorithm1,algorithm2])\n", + " #Export test results\n", + " mann_stats_df = pd.DataFrame(mann_stats)\n", + " mann_stats_df.columns = ['Algorithm 1', 'Algorithm 2', 'Statistic', 'P-Value', 'Sig(*)']\n", + " mann_stats_df.to_csv(full_path + '/model_training_evaluation/statistical_comparisons/MannWhitneyU_'+metric+name_modifier+'.csv', index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def doPlotROC(result_table,colors,full_path):\n", + " \"\"\" Generate ROC plot comparing average ML algorithm performance (over all CV training/testing sets)\"\"\"\n", + " count = 0\n", + " #Plot curves for each individual ML algorithm\n", + " for i in result_table.index:\n", + " plt.plot(result_table.loc[i]['fpr'],result_table.loc[i]['tpr'], color=colors[i],label=\"{}, AUC={:.3f}\".format(i, result_table.loc[i]['auc']))\n", + " count += 1\n", + " # Set figure dimensions\n", + " plt.rcParams[\"figure.figsize\"] = (6,6)\n", + " # Plot no-skill line\n", + " plt.plot([0, 1], [0, 1], color='orange', linestyle='--', label='No-Skill', alpha=.8)\n", + " #Specify plot axes,labels, and legend\n", + " plt.xticks(np.arange(0.0, 1.1, step=0.1))\n", + " plt.xlabel(\"False Positive Rate\", fontsize=15)\n", + " plt.yticks(np.arange(0.0, 1.1, step=0.1))\n", + " plt.ylabel(\"True Positive Rate\", fontsize=15)\n", + " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", + " #Export and/or show plot\n", + " plt.savefig(full_path+'/model_training_evaluation/Summary_ROC.png', bbox_inches=\"tight\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def doPlotPRC(result_table,colors,full_path,data_name,instance_label,outcome_label):\n", + " \"\"\" Generate PRC plot comparing average ML algorithm performance (over all CV training/testing sets)\"\"\"\n", + " count = 0\n", + " #Plot curves for each individual ML algorithm\n", + " for i in result_table.index:\n", + " plt.plot(result_table.loc[i]['recall'],result_table.loc[i]['prec'], color=colors[i],label=\"{}, AUC={:.3f}, APS={:.3f}\".format(i, result_table.loc[i]['pr_auc'],result_table.loc[i]['ave_prec']))\n", + " count += 1\n", + " #Estimate no skill line based on the fraction of cases found in the first test dataset\n", + " test = pd.read_csv(full_path+'/CVDatasets/'+data_name+'_CV_0_Train.csv')\n", + " if instance_label != 'None':\n", + " test = test.drop(instance_label, axis=1)\n", + " testY = test[outcome_label].values\n", + " noskill = len(testY[testY == 1]) / len(testY) # Fraction of cases\n", + " # Plot no-skill line\n", + " plt.plot([0, 1], [noskill, noskill], color='orange', linestyle='--',label='No-Skill', alpha=.8)\n", + " #Specify plot axes,labels, and legend\n", + " plt.xticks(np.arange(0.0, 1.1, step=0.1))\n", + " plt.xlabel(\"Recall (Sensitivity)\", fontsize=15)\n", + " plt.yticks(np.arange(0.0, 1.1, step=0.1))\n", + " plt.ylabel(\"Precision (PPV)\", fontsize=15)\n", + " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", + " #Export and/or show plot\n", + " plt.savefig(full_path+'/model_training_evaluation/Summary_PRC.png', bbox_inches=\"tight\")\n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run Training Evaluation and Generate Metric Boxplots and ROC and PRC Plots" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "if targetDataName not in (None, 'None'):\n", + " datasets = [d for d in datasets if d == targetDataName]\n", + "print(\"Vizualized Datasets: \"+str(datasets))\n", + "\n", + "if not algorithms:\n", + " raise ValueError(\"No algorithms discovered. Check experiment path and model outputs.\")\n", + "\n", + "for each in datasets: #each analyzed dataset to make plots for\n", + " print(\"---------------------------------------\")\n", + " print(each)\n", + " print(\"---------------------------------------\")\n", + " full_path = experiment_path+'/'+each\n", + "\n", + " if not os.path.exists(full_path+\"/model_training_evaluation\"):\n", + " os.mkdir(full_path+\"/model_training_evaluation\")\n", + "\n", + " original_feature_file = full_path+\"/exploratory/OriginalFeatureNames.csv\"\n", + " if not os.path.exists(original_feature_file):\n", + " original_feature_file = full_path+\"/exploratory/ProcessedFeatureNames.csv\"\n", + " original_headers = pd.read_csv(original_feature_file,sep=',').columns.values.tolist()\n", + "\n", + " metric_dict = {}\n", + " result_table = []\n", + " for algorithm in algorithms:\n", + " alg_result_table = []\n", + " s_bac = []\n", + " s_ac = []\n", + " s_f1 = []\n", + " s_re = []\n", + " s_sp = []\n", + " s_pr = []\n", + " s_tp = []\n", + " s_tn = []\n", + " s_fp = []\n", + " s_fn = []\n", + " s_npv = []\n", + " s_lrp = []\n", + " s_lrm = []\n", + " tprs = []\n", + " aucs = []\n", + " mean_fpr = np.linspace(0, 1, 100)\n", + " mean_recall = np.linspace(0, 1, 100)\n", + " precs = []\n", + " praucs = []\n", + " aveprecs = []\n", + "\n", + " for cvCount in range(0,cv_partitions):\n", + " train_file_path = full_path + '/CVDatasets/' + each + \"_CV_\" + str(cvCount) + \"_Train.csv\"\n", + " train = pd.read_csv(train_file_path)\n", + " if instance_label != 'None' and instance_label in train.columns:\n", + " train = train.drop(instance_label,axis=1)\n", + " trainX = train.drop(outcome_label,axis=1).values\n", + " trainY = train[outcome_label].values\n", + " del train\n", + "\n", + " model_file = full_path+'/models/pickledModels/'+abbrev[algorithm]+\"_\"+str(cvCount)+'.pickle'\n", + " if not os.path.exists(model_file):\n", + " print(\"Missing model file: \" + model_file)\n", + " continue\n", + " with open(model_file, 'rb') as file:\n", + " model = pickle.load(file)\n", + "\n", + " if not hasattr(model, 'predict_proba'):\n", + " print(\"Skipping {} CV {} (predict_proba unavailable)\".format(algorithm, cvCount))\n", + " continue\n", + " probas_all = model.predict_proba(trainX)\n", + " if len(probas_all.shape) != 2 or probas_all.shape[1] < 2:\n", + " print(\"Skipping {} CV {} (requires probability output)\".format(algorithm, cvCount))\n", + " continue\n", + "\n", + " classes = list(getattr(model, 'classes_', range(probas_all.shape[1])))\n", + " if probas_all.shape[1] > 2 or len(np.unique(trainY)) > 2:\n", + " positive_class = 1 if 1 in classes else classes[0]\n", + " class_index = classes.index(positive_class)\n", + " evalY = (trainY == positive_class).astype(int)\n", + " probas_pos = probas_all[:, class_index]\n", + " else:\n", + " evalY = trainY\n", + " probas_pos = probas_all[:,1]\n", + "\n", + " if len(np.unique(evalY)) < 2:\n", + " print(\"Skipping {} CV {} (only one class present after conversion)\".format(algorithm, cvCount))\n", + " continue\n", + "\n", + " y_pred = probas_pos > threshold\n", + " metricList = classEval(evalY, y_pred)\n", + " fpr, tpr, _ = metrics.roc_curve(evalY, probas_pos)\n", + " roc_auc = auc(fpr, tpr)\n", + " prec, recall, _ = metrics.precision_recall_curve(evalY, probas_pos)\n", + " prec, recall = prec[::-1], recall[::-1]\n", + " prec_rec_auc = auc(recall, prec)\n", + " ave_prec = metrics.average_precision_score(evalY, probas_pos)\n", + "\n", + " s_bac.append(metricList[0])\n", + " s_ac.append(metricList[1])\n", + " s_f1.append(metricList[2])\n", + " s_re.append(metricList[3])\n", + " s_sp.append(metricList[4])\n", + " s_pr.append(metricList[5])\n", + " s_tp.append(metricList[6])\n", + " s_tn.append(metricList[7])\n", + " s_fp.append(metricList[8])\n", + " s_fn.append(metricList[9])\n", + " s_npv.append(metricList[10])\n", + " s_lrp.append(metricList[11])\n", + " s_lrm.append(metricList[12])\n", + "\n", + " alg_result_table.append([fpr, tpr, roc_auc, prec, recall, prec_rec_auc, ave_prec])\n", + " tprs.append(interp(mean_fpr, fpr, tpr))\n", + " tprs[-1][0] = 0.0\n", + " aucs.append(roc_auc)\n", + " precs.append(interp(mean_recall, recall, prec))\n", + " praucs.append(prec_rec_auc)\n", + " aveprecs.append(ave_prec)\n", + "\n", + " if not s_bac:\n", + " print(\"No valid CV predictions for algorithm: \" + str(algorithm))\n", + " continue\n", + "\n", + " mean_tpr = np.mean(tprs, axis=0)\n", + " mean_tpr[-1] = 1.0\n", + " mean_auc = np.mean(aucs)\n", + "\n", + " if plot_ROC:\n", + " plt.rcParams[\"figure.figsize\"] = (6,6)\n", + " for i in range(len(alg_result_table)):\n", + " plt.plot(alg_result_table[i][0], alg_result_table[i][1], lw=1, alpha=0.3,label='ROC fold %d (AUC = %0.3f)' % (i, alg_result_table[i][2]))\n", + " plt.plot([0, 1], [0, 1], linestyle='--', lw=2, color='r',label='No-Skill', alpha=.8)\n", + " std_auc = np.std(aucs)\n", + " plt.plot(mean_fpr, mean_tpr, color=colors[algorithm],label=r'Mean ROC (AUC = %0.3f $\\pm$ %0.3f)' % (mean_auc, std_auc),lw=2, alpha=.8)\n", + " std_tpr = np.std(tprs, axis=0)\n", + " tprs_upper = np.minimum(mean_tpr + std_tpr, 1)\n", + " tprs_lower = np.maximum(mean_tpr - std_tpr, 0)\n", + " plt.fill_between(mean_fpr, tprs_lower, tprs_upper, color='grey', alpha=.2,label=r'$\\pm$ 1 std. dev.')\n", + " plt.xlim([-0.05, 1.05])\n", + " plt.ylim([-0.05, 1.05])\n", + " plt.title(str(algorithm))\n", + " plt.xlabel('False Positive Rate')\n", + " plt.ylabel('True Positive Rate')\n", + " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", + " plt.savefig(full_path+'/model_training_evaluation/'+abbrev[algorithm]+\"_ROC.png\", bbox_inches=\"tight\")\n", + " plt.show()\n", + "\n", + " mean_prec = np.mean(precs, axis=0)\n", + " mean_pr_auc = np.mean(praucs)\n", + " if plot_PRC:\n", + " plt.rcParams[\"figure.figsize\"] = (6,6)\n", + " for i in range(len(alg_result_table)):\n", + " plt.plot(alg_result_table[i][4], alg_result_table[i][3], lw=1, alpha=0.3, label='PRC fold %d (AUC = %0.3f)' % (i, alg_result_table[i][5]))\n", + " test = pd.read_csv(full_path + '/CVDatasets/' + each + '_CV_0_Train.csv')\n", + " testY = test[outcome_label].values\n", + " noskill = len(testY[testY == 1]) / len(testY)\n", + " plt.plot([0, 1], [noskill, noskill], color='orange', linestyle='--', label='No-Skill', alpha=.8)\n", + " std_pr_auc = np.std(praucs)\n", + " plt.plot(mean_recall, mean_prec, color=colors[algorithm],label=r'Mean PRC (AUC = %0.3f $\\pm$ %0.3f)' % (mean_pr_auc, std_pr_auc),lw=2, alpha=.8)\n", + " std_prec = np.std(precs, axis=0)\n", + " precs_upper = np.minimum(mean_prec + std_prec, 1)\n", + " precs_lower = np.maximum(mean_prec - std_prec, 0)\n", + " plt.fill_between(mean_recall, precs_lower, precs_upper, color='grey', alpha=.2,label=r'$\\pm$ 1 std. dev.')\n", + " plt.xlim([-0.05, 1.05])\n", + " plt.ylim([-0.05, 1.05])\n", + " plt.title(str(algorithm))\n", + " plt.xlabel('Recall (Sensitivity)')\n", + " plt.ylabel('Precision (PPV)')\n", + " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", + " plt.savefig(full_path+'/model_training_evaluation/'+abbrev[algorithm]+\"_PRC.png\", bbox_inches=\"tight\")\n", + " plt.show()\n", + "\n", + " results = {\n", + " 'Balanced Accuracy': s_bac, 'Accuracy': s_ac, 'F1 Score': s_f1,\n", + " 'Sensitivity (Recall)': s_re, 'Specificity': s_sp, 'Precision (PPV)': s_pr,\n", + " 'TP': s_tp, 'TN': s_tn, 'FP': s_fp, 'FN': s_fn,\n", + " 'NPV': s_npv, 'LR+': s_lrp, 'LR-': s_lrm,\n", + " 'ROC AUC': aucs, 'PRC AUC': praucs, 'PRC APS': aveprecs\n", + " }\n", + " dr = pd.DataFrame(results)\n", + " filepath = full_path+'/model_training_evaluation/'+abbrev[algorithm]+\"_performance\"+name_modifier+\".csv\"\n", + " dr.to_csv(filepath, header=True, index=False)\n", + "\n", + " metric_dict[algorithm] = results\n", + "\n", + " mean_ave_prec = np.mean(aveprecs)\n", + " result_dict = {'algorithm':algorithm,'fpr':mean_fpr, 'tpr':mean_tpr, 'auc':mean_auc, 'prec':mean_prec, 'recall':mean_recall, 'pr_auc':mean_pr_auc, 'ave_prec':mean_ave_prec}\n", + " result_table.append(result_dict)\n", + "\n", + " if not metric_dict:\n", + " print(\"No algorithm metrics available for dataset: \" + each)\n", + " continue\n", + "\n", + " result_table = pd.DataFrame.from_dict(result_table)\n", + " if not result_table.empty:\n", + " result_table.set_index('algorithm',inplace=True)\n", + "\n", + " my_metrics = list(next(iter(metric_dict.values())).keys())\n", + "\n", + " if not result_table.empty:\n", + " doPlotROC(result_table,colors,full_path)\n", + " doPlotPRC(result_table,colors,full_path,each,instance_label,outcome_label)\n", + "\n", + " saveMetricMeans(full_path,my_metrics,metric_dict,name_modifier)\n", + " saveMetricStd(full_path,my_metrics,metric_dict,name_modifier)\n", + "\n", + " if plot_metric_boxplots:\n", + " metricBoxplots(full_path,my_metrics,list(metric_dict.keys()),metric_dict,name_modifier)\n", + "\n", + " if run_sig_test and len(metric_dict) > 1:\n", + " compare_algs = list(metric_dict.keys())\n", + " kruskal_summary = kruskalWallis(full_path,my_metrics,compare_algs,metric_dict,sig_cutoff,name_modifier)\n", + " wilcoxonRank(full_path,my_metrics,compare_algs,metric_dict,kruskal_summary,sig_cutoff,name_modifier)\n", + " mannWhitneyU(full_path,my_metrics,compare_algs,metric_dict,kruskal_summary,sig_cutoff,name_modifier)" + ] + }, + { + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/usefulnotebooks/GenPlots_CompositeFI.ipynb b/usefulnotebooks/GenPlots_CompositeFI.ipynb new file mode 100644 index 00000000..e37a6ffb --- /dev/null +++ b/usefulnotebooks/GenPlots_CompositeFI.ipynb @@ -0,0 +1,659 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Useful Notebook: Generate Custom Composite Feature Importance Plots\n", + "**This notebook will allow users to generate custom variations of the composite feature importance plots.**\n", + "\n", + "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", + "\n", + "***\n", + "## Notebook Details\n", + "Generates custom feature importance plots: (1) to include all features in the dataset or (2) some different number of top features, (3) composite FI plots that also includes fractionation (each algorithm has limited total bar area to fill in the overall plot), or (4) to provide a way to generate modified versions of these plots without rerunning or directly editing the code in the original pipeline. \n", + "\n", + "When run, 'as-is' this notebook will generate 4 feature composite plots: (1) normalized only, (2) normalized and weighted, (3) normalized and fractionated, and (4) normalized, weighted, and fractionated. However these plots will illustrate all features in the processed data (unless the user changes `top_model_features`). These plots will also present mean FI scores (but the user can change this to median using `fi_ranking`, and they will weight these FI scores using mean model balanced accuracy (however users can change this to median, and some other metric weighting with `fi_weighting` and `metric_weight`, respectively. These will be saved in the same location as the original composite feature importance plots within the experiment folder." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Notebook Run Parameters\n", + "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed). \n", + "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "experiment_path = \"/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/test/out_full_pipeline/DemoExp\" # path the target experiment folder \n", + "targetDataName = None # 'None' if user wants to generate visualizations for all analyzed datasets\n", + "algorithms = [] # use empty list if user wishes to plot feature importance for all modeling algorithms that were run in pipeline.\n", + "top_model_features = None # None - to plot all features in original dataset, or specify some (int) to indicate # of top features to plot.\n", + "name_modifier = '_AllFeatures' # Modifies standard composite FI plot filename to avoid overwriting originals.\n", + "viz_norm_only = True # Generate plot with only FI normalization\n", + "viz_norm_weight = True #Generate plot with FI normalization and performance metric weighting\n", + "viz_norm_frac = True # Generate plot with FI normalization and fractionation (each algorithm has limited bar area to distribute in plot)\n", + "viz_norm_weight_frac = True #Generate plot with FI normalization performance metric weighting and fractionation\n", + "legend_inside_plot = True # place legend ouside plot in upper right hand corner, other wise placed inside on upper right hand corner.\n", + "fi_ranking = 'mean' # specify either 'mean' or 'median' to indicate whether to take the mean or median CV FI value for these plots.\n", + "fi_weighting = 'mean' #sepcify either 'mean' or 'median' to indicate whether to take the mean or median of selected evaluation metric to weigh FI scores in composite FI plot\n", + "metric_weight = 'Balanced Accuracy' # model evaluation metric used to weigh model feature importances" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Housekeeping\n", + "### Import Packages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "import pickle\n", + "from statistics import mean, stdev, median\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import rc\n", + "import numpy as np\n", + "#from streamline.modeling.utils import ABBREVIATION, COLORS\n", + "import seaborn as sns\n", + "sns.set_theme()\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", + "from IPython.core.interactiveshell import InteractiveShell\n", + "InteractiveShell.ast_node_interactivity = \"all\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Automatically detect data folder names" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get dataset paths for all completed dataset analyses in experiment folder\n", + "experiment_name = experiment_path.split('/')[-1]\n", + "remove_list = {\n", + " '.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", + " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs', 'KeyFileCopy', 'dask_logs',\n", + " 'reporting', 'reporting_replication', 'run_params.pickle', 'runtime',\n", + " experiment_name + '_STREAMLINE_Report.pdf'\n", + "}\n", + "\n", + "datasets = []\n", + "for d in sorted(os.listdir(experiment_path)):\n", + " dpath = os.path.join(experiment_path, d)\n", + " if d in remove_list or not os.path.isdir(dpath):\n", + " continue\n", + " has_exploratory = os.path.isdir(os.path.join(dpath, 'exploratory'))\n", + " has_model_data = os.path.isdir(os.path.join(dpath, 'model_evaluation')) or os.path.isdir(os.path.join(dpath, 'models'))\n", + " if has_exploratory and has_model_data:\n", + " datasets.append(d)\n", + "\n", + "print(\"Analyzed Datasets: \" + str(datasets))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load other necessary parameters" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Unpickle metadata from previous phase\n", + "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", + "metadata = pickle.load(file)\n", + "file.close()\n", + "# Load variables specified earlier in the pipeline from metadata\n", + "outcome_label = metadata.get('Outcome Label', metadata.get('Class Label', 'Class'))\n", + "instance_label = metadata['Instance Label']\n", + "cv_partitions = int(metadata['CV Partitions'])\n", + "\n", + "requested_algorithms = list(algorithms) if isinstance(algorithms, list) else []\n", + "\n", + "# Unpickle algorithm information from previous phase\n", + "alg_info_path = os.path.join(experiment_path, \"algInfo.pickle\")\n", + "if os.path.exists(alg_info_path):\n", + " with open(alg_info_path, \"rb\") as file:\n", + " algInfo = pickle.load(file)\n", + "else:\n", + " algInfo = {}\n", + "\n", + "algorithms = []\n", + "abbrev = {}\n", + "colors = {}\n", + "algColors = []\n", + "for key, value in algInfo.items():\n", + " if isinstance(value, (list, tuple)) and len(value) > 0 and bool(value[0]):\n", + " algorithms.append(key)\n", + " abbrev[key] = value[1] if len(value) > 1 else key\n", + " colors[key] = value[2] if len(value) > 2 else None\n", + "\n", + "# Fallback: infer algorithms from current output layout\n", + "if not algorithms:\n", + " inferred = set()\n", + " scan_datasets = [d for d in datasets if os.path.isdir(os.path.join(experiment_path, d))]\n", + " for ds_name in scan_datasets:\n", + " model_dir = os.path.join(experiment_path, ds_name, \"models\", \"pickledModels\")\n", + " if os.path.isdir(model_dir):\n", + " for fname in os.listdir(model_dir):\n", + " if fname.endswith('.pickle') and '_' in fname:\n", + " inferred.add(fname.rsplit('_', 1)[0])\n", + " metric_dir = os.path.join(experiment_path, ds_name, \"model_evaluation\", \"metrics_by_cv\")\n", + " if os.path.isdir(metric_dir):\n", + " for fname in os.listdir(metric_dir):\n", + " if fname.endswith('.json') and '_CV_' in fname:\n", + " inferred.add(fname.split('_CV_')[0])\n", + " for abr in sorted(inferred):\n", + " algorithms.append(abr)\n", + " abbrev[abr] = abr\n", + " colors[abr] = None\n", + "\n", + "if requested_algorithms:\n", + " req = set(requested_algorithms)\n", + " filtered = [a for a in algorithms if a in req or abbrev.get(a) in req]\n", + " if filtered:\n", + " algorithms = filtered\n", + "\n", + "palette = [\"#1f77b4\", \"#ff7f0e\", \"#2ca02c\", \"#d62728\", \"#9467bd\", \"#8c564b\", \"#e377c2\", \"#7f7f7f\", \"#bcbd22\", \"#17becf\"]\n", + "for idx, key in enumerate(algorithms):\n", + " if colors.get(key) is None:\n", + " colors[key] = palette[idx % len(palette)]\n", + "\n", + "algColors = [colors[k] for k in algorithms]\n", + "print(\"Algorithms Ran: \" + str(algorithms))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define necessary methods" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def primaryStats(algorithms, original_headers, cv_partitions, full_path, data_name, instance_label, outcome_label, abbrev):\n", + " \"\"\"Load model evaluation performance from current CSV outputs.\"\"\"\n", + " metric_dict = {}\n", + " for algorithm in algorithms:\n", + " perf_file = full_path + '/model_evaluation/' + abbrev[algorithm] + '_performance.csv'\n", + " if not os.path.exists(perf_file):\n", + " print('Skipping algorithm with missing performance file: ' + str(algorithm))\n", + " continue\n", + " perf_df = pd.read_csv(perf_file)\n", + " if perf_df.empty:\n", + " print('Skipping algorithm with empty performance file: ' + str(algorithm))\n", + " continue\n", + "\n", + " # Standardize a few common naming variants\n", + " rename_map = {\n", + " 'F1_Score': 'F1 Score',\n", + " 'ROC_AUC': 'ROC AUC',\n", + " 'PRC_AUC': 'PRC AUC',\n", + " 'PRC_APS': 'PRC APS',\n", + " 'balanced_accuracy': 'Balanced Accuracy',\n", + " 'accuracy': 'Accuracy',\n", + " 'f1': 'F1 Score',\n", + " 'precision': 'Precision (PPV)',\n", + " 'recall': 'Sensitivity (Recall)'\n", + " }\n", + " perf_df = perf_df.rename(columns=rename_map)\n", + " metric_dict[algorithm] = {col: perf_df[col].tolist() for col in perf_df.columns}\n", + "\n", + " return metric_dict" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def prepFI(algorithms,full_path,abbrev,metric_dict,metric_weight,fi_ranking,fi_weighting):\n", + " \"\"\" Organizes and prepares model feature importance data for boxplot and composite feature importance figure generation.\"\"\"\n", + " def _get_metric_values(metric_data, metric_name):\n", + " candidates = [\n", + " metric_name,\n", + " metric_name.replace(' ', '_'),\n", + " metric_name.replace('_', ' '),\n", + " metric_name.lower(),\n", + " metric_name.lower().replace(' ', '_')\n", + " ]\n", + " for c in candidates:\n", + " if c in metric_data:\n", + " return metric_data[c]\n", + " return None\n", + "\n", + " fi_df_list = []\n", + " fi_ave_list = []\n", + " ave_metric_list = []\n", + " all_feature_list = []\n", + " used_algorithms = []\n", + "\n", + " for algorithm in algorithms:\n", + " fi_file = full_path+'/model_evaluation/feature_importance/'+abbrev[algorithm]+'_FI.csv'\n", + " if not os.path.exists(fi_file):\n", + " print('Skipping algorithm with missing FI file: ' + str(algorithm))\n", + " continue\n", + " if algorithm not in metric_dict:\n", + " print('Skipping algorithm with missing metric summary: ' + str(algorithm))\n", + " continue\n", + "\n", + " temp_df = pd.read_csv(fi_file)\n", + " if temp_df.empty:\n", + " print('Skipping algorithm with empty FI file: ' + str(algorithm))\n", + " continue\n", + "\n", + " if not all_feature_list:\n", + " all_feature_list = temp_df.columns.tolist()\n", + "\n", + " fi_df_list.append(temp_df)\n", + " used_algorithms.append(algorithm)\n", + "\n", + " if fi_ranking == 'mean':\n", + " fi_ave_list.append(temp_df.mean().tolist())\n", + " elif fi_ranking == 'median':\n", + " fi_ave_list.append(temp_df.median().tolist())\n", + " else:\n", + " print(\"Error: fi_ranking selection not found (must be mean or median)\")\n", + " fi_ave_list.append(temp_df.mean().tolist())\n", + "\n", + " metric_values = _get_metric_values(metric_dict[algorithm], metric_weight)\n", + " if metric_values is None or len(metric_values) == 0:\n", + " avg_metric = 0.5\n", + " else:\n", + " if fi_weighting == 'median':\n", + " avg_metric = median(metric_values)\n", + " else:\n", + " avg_metric = mean(metric_values)\n", + " ave_metric_list.append(avg_metric)\n", + "\n", + " fi_ave_norm_list = []\n", + " for each in fi_ave_list:\n", + " normList = []\n", + " max_each = max(each) if len(each) > 0 else 0\n", + " for i in range(len(each)):\n", + " if each[i] <= 0 or max_each <= 0:\n", + " normList.append(0)\n", + " else:\n", + " normList.append((each[i]) / max_each)\n", + " fi_ave_norm_list.append(normList)\n", + "\n", + " if not fi_ave_list:\n", + " return fi_df_list, fi_ave_norm_list, ave_metric_list, all_feature_list, [], [], used_algorithms\n", + "\n", + " alg_non_zero_FI_list = []\n", + " for each in fi_ave_list:\n", + " temp_non_zero_list = []\n", + " for i in range(len(each)):\n", + " if each[i] > 0.0:\n", + " temp_non_zero_list.append(all_feature_list[i])\n", + " alg_non_zero_FI_list.append(temp_non_zero_list)\n", + "\n", + " non_zero_union_features = list(alg_non_zero_FI_list[0])\n", + " for j in range(1, len(used_algorithms)):\n", + " non_zero_union_features = list(set(non_zero_union_features) | set(alg_non_zero_FI_list[j]))\n", + "\n", + " non_zero_union_indexes = []\n", + " for i in non_zero_union_features:\n", + " non_zero_union_indexes.append(all_feature_list.index(i))\n", + "\n", + " return fi_df_list,fi_ave_norm_list,ave_metric_list,all_feature_list,non_zero_union_features,non_zero_union_indexes,used_algorithms" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def selectForViz(top_model_features,non_zero_union_features,non_zero_union_indexes,algorithms,ave_metric_list,fi_ave_norm_list):\n", + " \"\"\" Identify list of top features over all algorithms to visualize (note that best features to vizualize are chosen using algorithm performance weighting and normalization:\n", + " frac plays no useful role here only for viz). All features included if there are fewer than 'top_model_features'. Top features are determined by the sum of performance\n", + " (i.e. balanced accuracy) weighted feature importances over all algorithms.\"\"\"\n", + " featuresToViz = None\n", + " #Create performance weighted score sum dictionary for all features\n", + " scoreSumDict = {}\n", + " i = 0\n", + " for each in non_zero_union_features: # for each non-zero feature\n", + " for j in range(len(algorithms)): # for each algorithm\n", + " # grab target score from each algorithm\n", + " score = fi_ave_norm_list[j][non_zero_union_indexes[i]]\n", + " # multiply score by algorithm performance weight\n", + " weight = ave_metric_list[j]\n", + " if weight <= .5:\n", + " weight = 0\n", + " if not weight == 0:\n", + " weight = (weight - 0.5) / 0.5\n", + " score = score * weight\n", + " #score = score * ave_metric_list[j]\n", + " if not each in scoreSumDict:\n", + " scoreSumDict[each] = score\n", + " else:\n", + " scoreSumDict[each] += score\n", + " i += 1\n", + " # Sort features by decreasing score\n", + " scoreSumDict_features = sorted(scoreSumDict, key=lambda x: scoreSumDict[x], reverse=True)\n", + " if top_model_features == None or not len(non_zero_union_features) > top_model_features:\n", + " featuresToViz = scoreSumDict_features\n", + " else:\n", + " featuresToViz = scoreSumDict_features[0:top_model_features]\n", + "\n", + " return featuresToViz #list of feature names to vizualize in composite FI plots." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def getFI_To_Viz_Sorted(featuresToViz,all_feature_list,algorithms,fi_ave_norm_list):\n", + " \"\"\" Takes a list of top features names for vizualization, gets their indexes. In every composite FI plot features are ordered the same way\n", + " they are selected for vizualization (i.e. normalized and performance weighted). Because of this feature bars are only perfectly ordered in\n", + " descending order for the normalized + performance weighted composite plot. \"\"\"\n", + " #Get original feature indexs for selected feature names\n", + " feature_indexToViz = [] #indexes of top features\n", + " for i in featuresToViz:\n", + " feature_indexToViz.append(all_feature_list.index(i))\n", + " # Create list of top feature importance values in original dataset feature order\n", + " top_fi_ave_norm_list = [] #feature importance values of top features for each algorithm (list of lists)\n", + " for i in range(len(algorithms)):\n", + " tempList = []\n", + " for j in feature_indexToViz: #each top feature index\n", + " tempList.append(fi_ave_norm_list[i][j]) #add corresponding FI value\n", + " top_fi_ave_norm_list.append(tempList)\n", + " all_feature_listToViz = featuresToViz\n", + " return top_fi_ave_norm_list,all_feature_listToViz" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def composite_FI_plot(fi_list, algorithms, algColors, all_feature_listToViz, figName,full_path,yLabelText,name_modifier,legend_inside_plot,fi_ranking,fi_weighting,metric_weight):\n", + "\n", + " algorithms, algColors, fi_list = (list(t) for t in zip(*sorted(zip(algorithms, algColors, fi_list), reverse=True)))\n", + " # Set basic plot properties\n", + " rc('font', weight='bold', size=16)\n", + " # The position of the bars on the x-axis\n", + " r = all_feature_listToViz # feature names\n", + " # Set width of bars\n", + " bar_width = 0.75\n", + " # Set figure dimensions\n", + " plt.figure(figsize=(24, 12))\n", + " # Plot first algorithm FI scores (lowest) bar\n", + " p1 = plt.bar(r, fi_list[0], color=algColors[0], edgecolor='white', width=bar_width)\n", + " # Automatically calculate space needed to plot next bar on top of the one before it\n", + " bottoms = [] # list of space used by previous\n", + " # algorithms for each feature (so next bar can be placed directly above it)\n", + " bottom = None\n", + " for i in range(len(algorithms) - 1):\n", + " for j in range(i + 1):\n", + " if j == 0:\n", + " bottom = np.array(fi_list[0]).astype('float64')\n", + " else:\n", + " bottom += np.array(fi_list[j]).astype('float64')\n", + " bottoms.append(bottom)\n", + " if not isinstance(bottoms, list):\n", + " bottoms = bottoms.tolist()\n", + " if len(algorithms) > 1:\n", + " # Plot subsequent feature bars for each subsequent algorithm\n", + " ps = [p1[0]]\n", + " for i in range(len(algorithms) - 1):\n", + " p = plt.bar(r, fi_list[i + 1], bottom=bottoms[i], color=algColors[i + 1], edgecolor='white',\n", + " width=bar_width)\n", + " ps.append(p[0])\n", + " lines = tuple(ps)\n", + " else:\n", + " ps = [p1[0]]\n", + " lines = tuple(ps)\n", + " # Specify axes info and legend\n", + " plt.xticks(np.arange(len(all_feature_listToViz)), all_feature_listToViz, rotation='vertical')\n", + " plt.xlabel(\"Features (ranked by sum of \"+fi_ranking+\" feature importance: weighted by \"+fi_weighting+\" model \"+metric_weight.lower()+\")\", fontsize=20)\n", + " plt.ylabel(yLabelText, fontsize=20)\n", + " algorithms_list, lines_list = (list(t) for t in zip(*sorted(zip(algorithms, lines))))\n", + " if legend_inside_plot:\n", + " plt.legend(lines[::-1], algorithms[::-1],loc=\"upper right\")\n", + " else:\n", + " plt.legend(lines[::-1], algorithms[::-1],loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", + " # Export and/or show plot\n", + " plt.savefig(full_path+'/model_evaluation/feature_importance/Compare_FI_' + figName +name_modifier+ '.png', bbox_inches='tight')\n", + " plt.show()\n", + " \n", + "\n", + " \n", + " \"\"\" Generate composite feature importance plot given list of feature names and associated feature importance scores for each algorithm.\n", + " This is run for different transformations of the normalized feature importance scores. \"\"\"\n", + " \"\"\"\n", + " # Set basic plot properites\n", + " rc('font', weight='bold', size=16)\n", + " # The position of the bars on the x-axis\n", + " r = all_feature_listToViz #feature names\n", + " #Set width of bars\n", + " barWidth = 0.75\n", + " #Set figure dimensions\n", + " plt.figure(figsize=(24, 12))\n", + " #Plot first algorithm FI scores (lowest) bar\n", + " p1 = plt.bar(r, fi_list[0], color=algColors[0], edgecolor='white', width=barWidth)\n", + " #Automatically calculate space needed to plot next bar on top of the one before it\n", + " bottoms = [] #list of space used by previous algorithms for each feature (so next bar can be placed directly above it)\n", + " for i in range(len(algorithms) - 1):\n", + " for j in range(i + 1):\n", + " if j == 0:\n", + " bottom = np.array(fi_list[0])\n", + " else:\n", + " bottom += np.array(fi_list[j])\n", + " bottoms.append(bottom)\n", + " if not isinstance(bottoms, list):\n", + " bottoms = bottoms.tolist()\n", + " #Plot subsequent feature bars for each subsequent algorithm\n", + " ps = [p1[0]]\n", + " for i in range(len(algorithms) - 1):\n", + " p = plt.bar(r, fi_list[i + 1], bottom=bottoms[i], color=algColors[i + 1], edgecolor='white', width=barWidth)\n", + " ps.append(p[0])\n", + " lines = tuple(ps)\n", + " # Specify axes info and legend\n", + " plt.xticks(np.arange(len(all_feature_listToViz)), all_feature_listToViz, rotation='vertical')\n", + " plt.xlabel(\"Feature\", fontsize=20)\n", + " plt.ylabel(yLabelText, fontsize=20)\n", + " if legend_inside_plot:\n", + " plt.legend(lines[::-1], algorithms[::-1],loc=\"upper right\")\n", + " else:\n", + " plt.legend(lines[::-1], algorithms[::-1],loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", + " #Export and/or show plot\n", + " plt.savefig(full_path+'/model_evaluation/feature_importance/Compare_FI_' + figName +name_modifier+ '.png', bbox_inches='tight')\n", + " plt.show()\n", + " \"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def fracFI(top_fi_ave_norm_list):\n", + " \"\"\" Transforms feature scores so that they sum to 1 over all features for a given algorithm. This way the normalized and fracionated composit bar plot\n", + " offers equal total bar area for every algorithm. The intuition here is that if an algorithm gives the same FI scores for all top features it won't be\n", + " overly represented in the resulting plot (i.e. all features can have the same maximum feature importance which might lead to the impression that an\n", + " algorithm is working better than it is.) Instead, that maximum 'bar-real-estate' has to be divided by the total number of features. Notably, this\n", + " transformation has the potential to alter total algorithm FI bar height ranking of features. \"\"\"\n", + " fracLists = []\n", + " for each in top_fi_ave_norm_list: #each algorithm\n", + " fracList = []\n", + " for i in range(len(each)): #each feature\n", + " if sum(each) == 0: #check that all feature scores are not zero to avoid zero division error\n", + " fracList.append(0)\n", + " else:\n", + " fracList.append((each[i] / (sum(each))))\n", + " fracLists.append(fracList)\n", + " return fracLists" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def weightFI(ave_metric_list,top_fi_ave_norm_list):\n", + " \"\"\" Weights the feature importance scores by algorithm performance (intuitive because when interpreting feature importances we want to place more weight on better performing algorithms) \"\"\"\n", + " # Prepare weights\n", + " weights = []\n", + " # replace all balanced accuraces <=.5 with 0 (i.e. these are no better than random chance)\n", + " for i in range(len(ave_metric_list)):\n", + " if ave_metric_list[i] <= .5:\n", + " ave_metric_list[i] = 0\n", + " # normalize balanced accuracies\n", + " for i in range(len(ave_metric_list)):\n", + " if ave_metric_list[i] == 0:\n", + " weights.append(0)\n", + " else:\n", + " weights.append((ave_metric_list[i] - 0.5) / 0.5)\n", + " # Weight normalized feature importances\n", + " weightedLists = []\n", + " for i in range(len(top_fi_ave_norm_list)): #each algorithm\n", + " weightList = np.multiply(weights[i], top_fi_ave_norm_list[i]).tolist()\n", + " weightedLists.append(weightList)\n", + " return weightedLists,weights" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def weightFracFI(fracLists,weights):\n", + " \"\"\" Weight normalized and fractionated feature importances. \"\"\"\n", + " weightedFracLists = []\n", + " for i in range(len(fracLists)):\n", + " weightList = np.multiply(weights[i], fracLists[i]).tolist()\n", + " weightedFracLists.append(weightList)\n", + " return weightedFracLists" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate composite feature importance plots" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "if targetDataName not in (None, 'None'):\n", + " datasets = [d for d in datasets if d == targetDataName]\n", + "\n", + "for each in datasets: #each analyzed dataset to make plots for\n", + " print(\"---------------------------------------\")\n", + " print(\"Dataset: \"+str(each))\n", + " print(\"---------------------------------------\")\n", + " full_path = experiment_path+'/'+each\n", + "\n", + " original_headers = pd.read_csv(full_path+\"/exploratory/ProcessedFeatureNames.csv\",sep=',').columns.values.tolist()\n", + "\n", + " available_algorithms = [a for a in algorithms if os.path.exists(full_path+'/model_evaluation/feature_importance/'+abbrev[a]+'_FI.csv')]\n", + " if not available_algorithms:\n", + " print('No available FI files for this dataset. Skipping.')\n", + " continue\n", + "\n", + " metric_dict = primaryStats(available_algorithms,original_headers,cv_partitions,full_path,each,instance_label,outcome_label,abbrev)\n", + "\n", + " fi_df_list,fi_ave_norm_list,ave_metric_list,all_feature_list,non_zero_union_features,non_zero_union_indexes,used_algorithms = prepFI(available_algorithms,full_path,abbrev,metric_dict,metric_weight,fi_ranking,fi_weighting)\n", + "\n", + " if not used_algorithms or not non_zero_union_features:\n", + " print('No non-zero FI values available for composite plot. Skipping.')\n", + " continue\n", + "\n", + " used_alg_colors = [colors.get(a, '#1f77b4') for a in used_algorithms]\n", + "\n", + " featuresToViz = selectForViz(top_model_features,non_zero_union_features,non_zero_union_indexes,used_algorithms,ave_metric_list,fi_ave_norm_list)\n", + "\n", + " top_fi_ave_norm_list,all_feature_listToViz = getFI_To_Viz_Sorted(featuresToViz,all_feature_list,used_algorithms,fi_ave_norm_list)\n", + "\n", + " if viz_norm_only:\n", + " composite_FI_plot(top_fi_ave_norm_list, used_algorithms, used_alg_colors, all_feature_listToViz, 'Norm',full_path, 'Normalized Feature Importance',name_modifier,legend_inside_plot,fi_ranking,fi_weighting,metric_weight)\n", + "\n", + " fracLists = fracFI(top_fi_ave_norm_list)\n", + "\n", + " if viz_norm_frac:\n", + " composite_FI_plot(fracLists, used_algorithms, used_alg_colors, all_feature_listToViz, 'Norm_Frac',full_path, 'Normalized and Fractioned Feature Importance',name_modifier,legend_inside_plot,fi_ranking,fi_weighting,metric_weight)\n", + "\n", + " weightedLists,weights = weightFI(ave_metric_list,top_fi_ave_norm_list)\n", + "\n", + " if viz_norm_weight:\n", + " composite_FI_plot(weightedLists, used_algorithms, used_alg_colors, all_feature_listToViz, 'Norm_Weight',full_path, 'Normalized and Weighted Feature Importance',name_modifier,legend_inside_plot,fi_ranking,fi_weighting,metric_weight)\n", + "\n", + " weightedFracLists = weightFracFI(fracLists,weights)\n", + "\n", + " if viz_norm_weight_frac:\n", + " composite_FI_plot(weightedFracLists, used_algorithms, used_alg_colors, all_feature_listToViz, 'Norm_Frac_Weight',full_path, 'Normalized, Fractioned, and Weighted Feature Importance',name_modifier,legend_inside_plot,fi_ranking,fi_weighting,metric_weight)" + ] + } + ], + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/usefulnotebooks/GenPlots_FI_Heatmap.ipynb b/usefulnotebooks/GenPlots_FI_Heatmap.ipynb new file mode 100644 index 00000000..27d87c58 --- /dev/null +++ b/usefulnotebooks/GenPlots_FI_Heatmap.ipynb @@ -0,0 +1,300 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Useful Notebook: Generate a New Ranked Feature Importance Heatmap\n", + "**This notebook will allow users to generate an interactive html visualization of ranked feature importance estimates across algorithms.**\n", + "\n", + "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", + "\n", + "***\n", + "## Notebook Details\n", + "Takes the feature importance scores from each model and generates a feature importance 'rank' heatmap across all algorithms for the target datasets. These are output as an interactive html visualization using bokeh.\n", + "\n", + "This notebook requires additional installation of the bokeh package: \n", + "```\n", + "pip install bokeh\n", + "```\n", + "When run, 'as-is' this notebook will save an html link within the experiment folder for each target dataset. Clicking this link will open an interactive feature importance heatmap, where features are ranked from top to bottom by average importance rank over all algorithms. In this heatmap blue = high importance, and yellow is low importance. Users can hover there mouse over cells to get additional information about that given datapoint. These links will be saved in the same folder as other model feature importance outputs. \n", + "\n", + "This code for this visualization was written provided by Sy Hwang in September of 2021.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Notebook Run Parameters\n", + "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed). \n", + "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "experiment_path = \"/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/test/out_full_pipeline/DemoExp\" # path the target experiment folder \n", + "targetDataName = None # 'None' if user wants to generate visualizations for all analyzed datasets, otherwise (str) list of target dataset names\n", + "algorithms = [] #use empty list if user wishes re-evaluate all modeling algorithms that were run in pipeline." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Housekeeping\n", + "### Import Packages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "pd.set_option('display.max_rows', None)\n", + "import os\n", + "\n", + "from bokeh.io import output_file, save, export_png\n", + "from bokeh.models import (BasicTicker, ColorBar, ColumnDataSource,\n", + " ContinuousColorMapper, LinearColorMapper, HoverTool)\n", + "from bokeh.plotting import figure\n", + "from bokeh.transform import transform\n", + "from bokeh.palettes import Cividis256\n", + "import pickle\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", + "from IPython.core.interactiveshell import InteractiveShell\n", + "InteractiveShell.ast_node_interactivity = \"all\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Unpickle metadata from previous phase\n", + "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", + "metadata = pickle.load(file)\n", + "file.close()\n", + "\n", + "requested_algorithms = list(algorithms) if isinstance(algorithms, list) else []\n", + "\n", + "# Unpickle algorithm information from previous phase\n", + "alg_info_path = os.path.join(experiment_path, \"algInfo.pickle\")\n", + "if os.path.exists(alg_info_path):\n", + " with open(alg_info_path, \"rb\") as file:\n", + " algInfo = pickle.load(file)\n", + "else:\n", + " algInfo = {}\n", + "\n", + "algorithms = []\n", + "abbrev = {}\n", + "for key, value in algInfo.items():\n", + " if isinstance(value, (list, tuple)) and len(value) > 0 and bool(value[0]):\n", + " algorithms.append(key)\n", + " abbrev[key] = value[1] if len(value) > 1 else key\n", + "\n", + "if not algorithms:\n", + " inferred = set()\n", + " remove_tokens = {\n", + " '.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle', 'DatasetComparisons',\n", + " 'jobs', 'jobsCompleted', 'logs', 'KeyFileCopy', 'dask_logs', 'reporting',\n", + " 'reporting_replication', 'run_params.pickle'\n", + " }\n", + " scan_datasets = []\n", + " for d in os.listdir(experiment_path):\n", + " dpath = os.path.join(experiment_path, d)\n", + " if os.path.isdir(dpath) and d not in remove_tokens:\n", + " scan_datasets.append(d)\n", + " for ds_name in sorted(scan_datasets):\n", + " model_dir = os.path.join(experiment_path, ds_name, 'models', 'pickledModels')\n", + " if os.path.isdir(model_dir):\n", + " for fname in os.listdir(model_dir):\n", + " if fname.endswith('.pickle') and '_' in fname:\n", + " inferred.add(fname.rsplit('_', 1)[0])\n", + " fi_dir = os.path.join(experiment_path, ds_name, 'model_evaluation', 'feature_importance')\n", + " if os.path.isdir(fi_dir):\n", + " for fname in os.listdir(fi_dir):\n", + " if fname.endswith('_FI.csv'):\n", + " inferred.add(fname.replace('_FI.csv', ''))\n", + " for abr in sorted(inferred):\n", + " algorithms.append(abr)\n", + " abbrev[abr] = abr\n", + "\n", + "if requested_algorithms:\n", + " req = set(requested_algorithms)\n", + " filtered = [a for a in algorithms if a in req or abbrev.get(a) in req]\n", + " if filtered:\n", + " algorithms = filtered\n", + "\n", + "print(\"Algorithms Ran: \" + str(algorithms))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Automatically Detect Dataset Names" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get dataset paths for all completed dataset analyses in experiment folder\n", + "experiment_name = experiment_path.split('/')[-1]\n", + "remove_list = {\n", + " '.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", + " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs', 'KeyFileCopy', 'dask_logs',\n", + " 'reporting', 'reporting_replication', 'run_params.pickle', 'runtime',\n", + " experiment_name + '_STREAMLINE_Report.pdf'\n", + "}\n", + "\n", + "datasets = []\n", + "for d in sorted(os.listdir(experiment_path)):\n", + " dpath = os.path.join(experiment_path, d)\n", + " if d in remove_list or not os.path.isdir(dpath):\n", + " continue\n", + " has_exploratory = os.path.isdir(os.path.join(dpath, 'exploratory'))\n", + " has_model_data = os.path.isdir(os.path.join(dpath, 'model_evaluation')) or os.path.isdir(os.path.join(dpath, 'models'))\n", + " if has_exploratory and has_model_data:\n", + " datasets.append(d)\n", + "\n", + "print(\"Analyzed Datasets: \" + str(datasets))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate Ranked Feature Importance Heatmap" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if targetDataName not in (None, 'None'):\n", + " datasets = [d for d in datasets if d == targetDataName]\n", + "\n", + "for each in datasets:\n", + " print(\"---------------------------------------\")\n", + " print(\"Dataset: \"+str(each))\n", + " print(\"---------------------------------------\")\n", + " full_path = experiment_path+'/'+each\n", + "\n", + " series = list()\n", + " feats = None\n", + " available_algorithms = [a for a in algorithms if os.path.exists(full_path+'/model_evaluation/feature_importance/'+abbrev[a]+'_FI.csv')]\n", + " if not available_algorithms:\n", + " print('No FI CSV files found for this dataset. Skipping.')\n", + " continue\n", + "\n", + " for algorithm in available_algorithms:\n", + " filename = full_path+'/model_evaluation/feature_importance/'+abbrev[algorithm]+'_FI.csv'\n", + " df = pd.read_csv(filename)\n", + " if df.empty:\n", + " continue\n", + " if feats is None:\n", + " feats = df.abs().mean().keys().to_list()\n", + " series.append(pd.Series(feats, name='feats'))\n", + " fi_avgrank = df.abs().mean().rank(ascending=False).values\n", + " series.append(pd.Series(fi_avgrank, name=algorithm.partition('_')[0]))\n", + "\n", + " if len(series) <= 1:\n", + " print('No FI ranks available to build heatmap. Skipping.')\n", + " continue\n", + "\n", + " finaldf = pd.concat(series, axis=1).set_index('feats')\n", + " finaldf['MeanRank'] = finaldf.mean(axis=1)\n", + " finaldf.sort_values(by='MeanRank', inplace=True)\n", + " finaldf.columns.name = 'algos'\n", + " inputdf = pd.DataFrame(finaldf.stack(), columns=['ranked']).reset_index()\n", + "\n", + " source = ColumnDataSource(inputdf)\n", + " mapper = LinearColorMapper(palette=Cividis256, low=inputdf.ranked.min(), high=inputdf.ranked.max())\n", + "\n", + " tools=[\"wheel_zoom\", \"pan\", \"reset\"]\n", + " p = figure(width=900,\n", + " height=1600,\n", + " title=\"FI Heatmap (All Variables)\",\n", + " x_range=list(finaldf.columns),\n", + " y_range=list(reversed(finaldf.index)),\n", + " tools=tools,\n", + " toolbar_location='left',\n", + " x_axis_location=\"above\"\n", + " )\n", + " p.rect(x=\"algos\",\n", + " y=\"feats\",\n", + " width=1,\n", + " height=1,\n", + " source=source,\n", + " line_color=\"white\",\n", + " fill_color={\"field\":\"ranked\", \"transform\": mapper},\n", + " )\n", + " tooltips = [(\"algo\", \"@algos\"),\n", + " (\"feature\", \"@feats\"),\n", + " (\"rank\", \"@ranked\")]\n", + "\n", + " hover = HoverTool(tooltips = tooltips)\n", + " p.add_tools(hover)\n", + " p.axis.axis_line_color = None\n", + " p.axis.major_tick_line_color = None\n", + " p.axis.major_label_text_font_size = \"14px\"\n", + " p.title.text_font_size = '24px'\n", + " p.axis.major_label_standoff = 0\n", + " p.xaxis.major_label_orientation = 1.0\n", + "\n", + " output_file(full_path+'/model_evaluation/feature_importance/'+'FI_Rank_Heatmap.html')\n", + " save(p)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "1a12a98ae265c92e0b59419562a28d4a83daa07b99af1da9cec83ddf5b471690" + }, + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/usefulnotebooks/GenPlots_ROC_PRC.ipynb b/usefulnotebooks/GenPlots_ROC_PRC.ipynb new file mode 100644 index 00000000..72e86368 --- /dev/null +++ b/usefulnotebooks/GenPlots_ROC_PRC.ipynb @@ -0,0 +1,518 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Useful Notebook: Generate Custom ROC and PRC Plots\n", + "**This notebook will allow users to generate (1) ROC and PRC plots for each algorithm (over all CV partitions) if this function was previously turned off in the pipeline, (2) all ROC and PRC plots with the legend inside the plot rather than to the upper right, and (3) allow code-savy users to easily modify this notebook to regenerate these plots to their own specifications.**\n", + "\n", + "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", + "\n", + "***\n", + "## Notebook Details\n", + "Generates custom ROC and PRC plots to provide a way to generate modified versions of these plots without rerunning or directly editing the code in the original pipeline. \n", + "\n", + "When run, 'as-is' this notebook will regenerate all ROC and PRC plots putting the legend inside of the plots: (1) in the upper right hand corner for PRC plots, and (2) in the lower right hand corner for ROC plots. However in some (maybe all cases) the legend will then obstruct the curves themselves. This simple customization of the plots is meant as an example. Users are welcome to modify the plot cells at the bottom of this notebook to further tweak the appearance of the respective plots. These will be saved in the same location within the 'experiment folder' as the original ROC and PRC plots, but with a filename modified by `name_modifier` below.\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Notebook Run Parameters\n", + "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed). \n", + "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "experiment_path = \"/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/test/out_full_pipeline/DemoExp\" # path the target experiment folder \n", + "targetDataName = None # 'None' if user wants to generate visualizations for all analyzed datasets, otherwise give a (str) list of target dataset names\n", + "algorithms = [] #use empty list if user wishes to plot feature importance for all modeling algorithms that were run in pipeline.\n", + "name_modifier = '_New' # Modifies standard plot filenames to avoid overwriting originals.\n", + "legend_inside_plot = True #place legend inside plot, other wise placed outside on upper right hand corner.\n", + "plot_ROC = True # For each algorithm plot ROC curve - including lines for each trained CV model.\n", + "plot_PRC = True # For each algorithm plot PRC curve - including lines for each trained CV model.\n", + "plot_meta_ROC = True #Generate ROC summarizing average ROC curves (all cvs) for each algorithm\n", + "plot_meta_PRC = True #Generate PRC summarizing average ROC curves (all cvs) for each algorithm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Housekeeping\n", + "### Import Packages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import json\n", + "import pandas as pd\n", + "import pickle\n", + "from statistics import mean,stdev\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import rc\n", + "import numpy as np\n", + "from scipy import stats\n", + "interp = np.interp\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", + "from IPython.core.interactiveshell import InteractiveShell\n", + "InteractiveShell.ast_node_interactivity = \"all\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Automatically detect data folder names" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get dataset paths for all completed dataset analyses in experiment folder\n", + "experiment_name = experiment_path.split('/')[-1]\n", + "remove_list = {\n", + " '.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", + " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs', 'KeyFileCopy', 'dask_logs',\n", + " 'reporting', 'reporting_replication', 'run_params.pickle', 'runtime',\n", + " experiment_name + '_STREAMLINE_Report.pdf'\n", + "}\n", + "\n", + "datasets = []\n", + "for d in sorted(os.listdir(experiment_path)):\n", + " dpath = os.path.join(experiment_path, d)\n", + " if d in remove_list or not os.path.isdir(dpath):\n", + " continue\n", + " has_exploratory = os.path.isdir(os.path.join(dpath, 'exploratory'))\n", + " has_model_data = os.path.isdir(os.path.join(dpath, 'model_evaluation')) or os.path.isdir(os.path.join(dpath, 'models'))\n", + " if has_exploratory and has_model_data:\n", + " datasets.append(d)\n", + "\n", + "print(\"Analyzed Datasets: \" + str(datasets))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load other necessary parameters" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Unpickle metadata from previous phase\n", + "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", + "metadata = pickle.load(file)\n", + "file.close()\n", + "# Load variables specified earlier in the pipeline from metadata\n", + "outcome_label = metadata.get('Outcome Label', metadata.get('Class Label', 'Class'))\n", + "instance_label = metadata['Instance Label']\n", + "cv_partitions = int(metadata['CV Partitions'])\n", + "\n", + "requested_algorithms = list(algorithms) if isinstance(algorithms, list) else []\n", + "\n", + "# Unpickle algorithm information from previous phase\n", + "alg_info_path = os.path.join(experiment_path, \"algInfo.pickle\")\n", + "if os.path.exists(alg_info_path):\n", + " with open(alg_info_path, \"rb\") as file:\n", + " algInfo = pickle.load(file)\n", + "else:\n", + " algInfo = {}\n", + "\n", + "algorithms = []\n", + "abbrev = {}\n", + "colors = {}\n", + "for key, value in algInfo.items():\n", + " if isinstance(value, (list, tuple)) and len(value) > 0 and bool(value[0]):\n", + " algorithms.append(key)\n", + " abbrev[key] = value[1] if len(value) > 1 else key\n", + " colors[key] = value[2] if len(value) > 2 else None\n", + "\n", + "# Fallback: infer algorithms from current output layout\n", + "if not algorithms:\n", + " inferred = set()\n", + " scan_datasets = [d for d in datasets if os.path.isdir(os.path.join(experiment_path, d))]\n", + " for ds_name in scan_datasets:\n", + " model_dir = os.path.join(experiment_path, ds_name, \"models\", \"pickledModels\")\n", + " if os.path.isdir(model_dir):\n", + " for fname in os.listdir(model_dir):\n", + " if fname.endswith('.pickle') and '_' in fname:\n", + " inferred.add(fname.rsplit('_', 1)[0])\n", + " metric_dir = os.path.join(experiment_path, ds_name, \"model_evaluation\", \"metrics_by_cv\")\n", + " if os.path.isdir(metric_dir):\n", + " for fname in os.listdir(metric_dir):\n", + " if fname.endswith('.json') and '_CV_' in fname:\n", + " inferred.add(fname.split('_CV_')[0])\n", + " for abr in sorted(inferred):\n", + " algorithms.append(abr)\n", + " abbrev[abr] = abr\n", + " colors[abr] = None\n", + "\n", + "if requested_algorithms:\n", + " req = set(requested_algorithms)\n", + " filtered = [a for a in algorithms if a in req or abbrev.get(a) in req]\n", + " if filtered:\n", + " algorithms = filtered\n", + "\n", + "palette = [\"#1f77b4\", \"#ff7f0e\", \"#2ca02c\", \"#d62728\", \"#9467bd\", \"#8c564b\", \"#e377c2\", \"#7f7f7f\", \"#bcbd22\", \"#17becf\"]\n", + "for idx, key in enumerate(algorithms):\n", + " if colors.get(key) is None:\n", + " colors[key] = palette[idx % len(palette)]\n", + "\n", + "print(algorithms)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define Necessary Methods" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def primaryStats(algorithms,original_headers,cv_partitions,full_path,data_name,instance_label,outcome_label,abbrev,colors,plot_ROC,plot_PRC,name_modifier,legend_inside_plot):\n", + " \"\"\"Combine classification metrics and curves from current JSON outputs.\"\"\"\n", + "\n", + " def _metric_val(metrics_map, keys, default=np.nan):\n", + " for k in keys:\n", + " if k in metrics_map and metrics_map[k] is not None:\n", + " return metrics_map[k]\n", + " return default\n", + "\n", + " def _load_curve(path):\n", + " if not os.path.exists(path):\n", + " return None\n", + " with open(path, 'r') as f:\n", + " payload = json.load(f)\n", + " if isinstance(payload, dict):\n", + " if 'micro' in payload and isinstance(payload['micro'], dict):\n", + " return payload['micro']\n", + " if 'binary' in payload and isinstance(payload['binary'], dict):\n", + " return payload['binary']\n", + " if 'fpr' in payload or 'precision' in payload:\n", + " return payload\n", + " return None\n", + "\n", + " def _safe_interp(x_new, x, y):\n", + " x = np.asarray(x, dtype=float)\n", + " y = np.asarray(y, dtype=float)\n", + " if len(x) == 0 or len(y) == 0:\n", + " return np.zeros_like(x_new)\n", + " order = np.argsort(x)\n", + " x = x[order]\n", + " y = y[order]\n", + " x_unique, idx = np.unique(x, return_index=True)\n", + " y_unique = y[idx]\n", + " if len(x_unique) == 1:\n", + " return np.full_like(x_new, y_unique[0], dtype=float)\n", + " return interp(x_new, x_unique, y_unique)\n", + "\n", + " result_table = []\n", + " metric_dict = {}\n", + " for algorithm in algorithms:\n", + " alg_result_table = []\n", + " s_bac, s_ac, s_f1, s_re, s_sp, s_pr = [], [], [], [], [], []\n", + " s_tp, s_tn, s_fp, s_fn, s_npv, s_lrp, s_lrm = [], [], [], [], [], [], []\n", + " tprs, aucs = [], []\n", + " mean_fpr = np.linspace(0, 1, 100)\n", + " mean_recall = np.linspace(0, 1, 100)\n", + " precs, praucs, aveprecs = [], [], []\n", + "\n", + " for cvCount in range(0,cv_partitions):\n", + " metrics_file = full_path+'/model_evaluation/metrics_by_cv/'+abbrev[algorithm]+'_CV_'+str(cvCount)+'.json'\n", + " roc_file = full_path+'/model_evaluation/curves_by_cv/'+abbrev[algorithm]+'_CV_'+str(cvCount)+'_roc.json'\n", + " prc_file = full_path+'/model_evaluation/curves_by_cv/'+abbrev[algorithm]+'_CV_'+str(cvCount)+'_prc.json'\n", + "\n", + " if not os.path.exists(metrics_file):\n", + " continue\n", + "\n", + " with open(metrics_file, 'r') as f:\n", + " metrics_payload = json.load(f)\n", + " metrics_map = metrics_payload.get('metrics', {})\n", + "\n", + " roc_curve = _load_curve(roc_file)\n", + " prc_curve = _load_curve(prc_file)\n", + " if roc_curve is None or prc_curve is None:\n", + " continue\n", + "\n", + " fpr = np.asarray(roc_curve.get('fpr', []), dtype=float)\n", + " tpr = np.asarray(roc_curve.get('tpr', []), dtype=float)\n", + " prec = np.asarray(prc_curve.get('precision', []), dtype=float)\n", + " recall = np.asarray(prc_curve.get('recall', []), dtype=float)\n", + " if len(fpr) < 2 or len(tpr) < 2 or len(prec) < 2 or len(recall) < 2:\n", + " continue\n", + "\n", + " roc_auc = float(_metric_val(metrics_map, ['roc_auc_micro', 'roc_auc', 'roc_auc_macro'], roc_curve.get('auc', np.nan)))\n", + " prec_rec_auc = float(_metric_val(metrics_map, ['average_precision_micro', 'average_precision', 'average_precision_macro'], prc_curve.get('pr_auc', np.nan)))\n", + " ave_prec = float(_metric_val(metrics_map, ['average_precision_micro', 'average_precision', 'average_precision_macro'], prc_curve.get('aps', np.nan)))\n", + "\n", + " s_bac.append(float(_metric_val(metrics_map, ['balanced_accuracy'], np.nan)))\n", + " s_ac.append(float(_metric_val(metrics_map, ['accuracy', 'f1_micro'], np.nan)))\n", + " s_f1.append(float(_metric_val(metrics_map, ['f1', 'f1_macro', 'f1_micro'], np.nan)))\n", + " s_re.append(float(_metric_val(metrics_map, ['recall', 'recall_macro', 'recall_micro', 'sensitivity'], np.nan)))\n", + " s_sp.append(np.nan)\n", + " s_pr.append(float(_metric_val(metrics_map, ['precision', 'precision_macro', 'precision_micro'], np.nan)))\n", + " s_tp.append(np.nan)\n", + " s_tn.append(np.nan)\n", + " s_fp.append(np.nan)\n", + " s_fn.append(np.nan)\n", + " s_npv.append(np.nan)\n", + " s_lrp.append(np.nan)\n", + " s_lrm.append(np.nan)\n", + "\n", + " alg_result_table.append([fpr, tpr, roc_auc, prec, recall, prec_rec_auc, ave_prec])\n", + " tprs.append(_safe_interp(mean_fpr, fpr, tpr))\n", + " tprs[-1][0] = 0.0\n", + " aucs.append(roc_auc)\n", + "\n", + " precs.append(_safe_interp(mean_recall, recall, prec))\n", + " praucs.append(prec_rec_auc)\n", + " aveprecs.append(ave_prec)\n", + "\n", + " if not aucs:\n", + " print('Skipping algorithm with no usable CV metrics: ' + str(algorithm))\n", + " continue\n", + "\n", + " print(algorithm)\n", + " mean_tpr = np.mean(tprs, axis=0)\n", + " mean_tpr[-1] = 1.0\n", + " mean_auc = np.mean(aucs)\n", + "\n", + " if plot_ROC:\n", + " plt.rcParams[\"figure.figsize\"] = (6,6)\n", + " for i in range(len(alg_result_table)):\n", + " plt.plot(alg_result_table[i][0], alg_result_table[i][1], lw=1, alpha=0.3,label='ROC fold %d (AUC = %0.3f)' % (i, alg_result_table[i][2]))\n", + " plt.plot([0, 1], [0, 1], linestyle='--', lw=2, color='r',label='No-Skill', alpha=.8)\n", + " std_auc = np.std(aucs)\n", + " plt.plot(mean_fpr, mean_tpr, color=colors[algorithm],label=r'Mean ROC (AUC = %0.3f $\\pm$ %0.3f)' % (mean_auc, std_auc),lw=2, alpha=.8)\n", + " std_tpr = np.std(tprs, axis=0)\n", + " tprs_upper = np.minimum(mean_tpr + std_tpr, 1)\n", + " tprs_lower = np.maximum(mean_tpr - std_tpr, 0)\n", + " plt.fill_between(mean_fpr, tprs_lower, tprs_upper, color='grey', alpha=.2,label=r'$\\pm$ 1 std. dev.')\n", + " plt.xlim([-0.05, 1.05])\n", + " plt.ylim([-0.05, 1.05])\n", + " plt.title(str(algorithm))\n", + " plt.xlabel('False Positive Rate')\n", + " plt.ylabel('True Positive Rate')\n", + " if legend_inside_plot:\n", + " plt.legend(loc=\"lower right\")\n", + " else:\n", + " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", + " plt.savefig(full_path+'/model_evaluation/'+abbrev[algorithm]+\"_ROC\"+name_modifier+\".png\", bbox_inches=\"tight\")\n", + " plt.show()\n", + "\n", + " mean_prec = np.mean(precs, axis=0)\n", + " mean_pr_auc = np.mean(praucs)\n", + " if plot_PRC:\n", + " plt.rcParams[\"figure.figsize\"] = (6,6)\n", + " for i in range(len(alg_result_table)):\n", + " plt.plot(alg_result_table[i][4], alg_result_table[i][3], lw=1, alpha=0.3, label='PRC fold %d (AUC = %0.3f)' % (i, alg_result_table[i][5]))\n", + " test = pd.read_csv(full_path + '/CVDatasets/' + data_name + '_CV_0_Test.csv')\n", + " testY = test[outcome_label].values\n", + " uniq = np.unique(testY)\n", + " noskill = 0.5\n", + " if len(uniq) == 2:\n", + " noskill = float(len(testY[testY == 1]) / len(testY))\n", + " plt.plot([0, 1], [noskill, noskill], color='orange', linestyle='--', label='No-Skill', alpha=.8)\n", + " std_pr_auc = np.std(praucs)\n", + " plt.plot(mean_recall, mean_prec, color=colors[algorithm],label=r'Mean PRC (AUC = %0.3f $\\pm$ %0.3f)' % (mean_pr_auc, std_pr_auc),lw=2, alpha=.8)\n", + " std_prec = np.std(precs, axis=0)\n", + " precs_upper = np.minimum(mean_prec + std_prec, 1)\n", + " precs_lower = np.maximum(mean_prec - std_prec, 0)\n", + " plt.fill_between(mean_recall, precs_lower, precs_upper, color='grey', alpha=.2,label=r'$\\pm$ 1 std. dev.')\n", + " plt.xlim([-0.05, 1.05])\n", + " plt.ylim([-0.05, 1.05])\n", + " plt.title(str(algorithm))\n", + " plt.xlabel('Recall (Sensitivity)')\n", + " plt.ylabel('Precision (PPV)')\n", + " if legend_inside_plot:\n", + " plt.legend(loc=\"upper right\")\n", + " else:\n", + " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", + " plt.savefig(full_path+'/model_evaluation/'+abbrev[algorithm]+\"_PRC\"+name_modifier+\".png\", bbox_inches=\"tight\")\n", + " plt.show()\n", + "\n", + " results = {\n", + " 'Balanced Accuracy': s_bac, 'Accuracy': s_ac, 'F1 Score': s_f1,\n", + " 'Sensitivity (Recall)': s_re, 'Specificity': s_sp, 'Precision (PPV)': s_pr,\n", + " 'TP': s_tp, 'TN': s_tn, 'FP': s_fp, 'FN': s_fn,\n", + " 'NPV': s_npv, 'LR+': s_lrp, 'LR-': s_lrm,\n", + " 'ROC AUC': aucs,'PRC AUC': praucs, 'PRC APS': aveprecs\n", + " }\n", + " metric_dict[algorithm] = results\n", + "\n", + " mean_ave_prec = np.mean(aveprecs)\n", + " result_dict = {\n", + " 'algorithm':algorithm,'fpr':mean_fpr, 'tpr':mean_tpr, 'auc':mean_auc,\n", + " 'prec':mean_prec, 'recall':mean_recall, 'pr_auc':mean_pr_auc, 'ave_prec':mean_ave_prec\n", + " }\n", + " result_table.append(result_dict)\n", + "\n", + " if result_table:\n", + " result_table = pd.DataFrame.from_dict(result_table)\n", + " result_table.set_index('algorithm',inplace=True)\n", + " else:\n", + " result_table = pd.DataFrame()\n", + "\n", + " return result_table,metric_dict" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def doPlotROC(result_table,colors,full_path,name_modifier,legend_inside_plot):\n", + " \"\"\" Generate ROC plot comparing average ML algorithm performance (over all CV training/testing sets)\"\"\"\n", + " if result_table is None or result_table.empty:\n", + " print('No ROC data available to plot.')\n", + " return\n", + " for i in result_table.index:\n", + " plt.plot(result_table.loc[i]['fpr'],result_table.loc[i]['tpr'], color=colors[i],label=\"{}, AUC={:.3f}\".format(i, result_table.loc[i]['auc']))\n", + " plt.rcParams[\"figure.figsize\"] = (6,6)\n", + " plt.plot([0, 1], [0, 1], color='orange', linestyle='--', label='No-Skill', alpha=.8)\n", + " plt.xticks(np.arange(0.0, 1.1, step=0.1))\n", + " plt.xlabel(\"False Positive Rate\", fontsize=15)\n", + " plt.yticks(np.arange(0.0, 1.1, step=0.1))\n", + " plt.ylabel(\"True Positive Rate\", fontsize=15)\n", + " if legend_inside_plot:\n", + " plt.legend(loc=\"lower right\")\n", + " else:\n", + " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", + " plt.savefig(full_path+'/model_evaluation/Summary_ROC'+name_modifier+'.png', bbox_inches=\"tight\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def doPlotPRC(result_table,colors,full_path,data_name,instance_label,outcome_label,name_modifier,legend_inside_plot):\n", + " \"\"\" Generate PRC plot comparing average ML algorithm performance (over all CV training/testing sets)\"\"\"\n", + " if result_table is None or result_table.empty:\n", + " print('No PRC data available to plot.')\n", + " return\n", + " for i in result_table.index:\n", + " plt.plot(result_table.loc[i]['recall'],result_table.loc[i]['prec'], color=colors[i],label=\"{}, AUC={:.3f}, APS={:.3f}\".format(i, result_table.loc[i]['pr_auc'],result_table.loc[i]['ave_prec']))\n", + "\n", + " test = pd.read_csv(full_path+'/CVDatasets/'+data_name+'_CV_0_Test.csv')\n", + " if instance_label != 'None' and instance_label in test.columns:\n", + " test = test.drop(instance_label, axis=1)\n", + " testY = test[outcome_label].values\n", + " uniq = np.unique(testY)\n", + " noskill = 0.5\n", + " if len(uniq) == 2:\n", + " noskill = len(testY[testY == 1]) / len(testY)\n", + " plt.plot([0, 1], [noskill, noskill], color='orange', linestyle='--',label='No-Skill', alpha=.8)\n", + " plt.xticks(np.arange(0.0, 1.1, step=0.1))\n", + " plt.xlabel(\"Recall (Sensitivity)\", fontsize=15)\n", + " plt.yticks(np.arange(0.0, 1.1, step=0.1))\n", + " plt.ylabel(\"Precision (PPV)\", fontsize=15)\n", + " if legend_inside_plot:\n", + " plt.legend(loc=\"upper right\")\n", + " else:\n", + " plt.legend(loc=\"upper left\", bbox_to_anchor=(1.01,1))\n", + " plt.savefig(full_path+'/model_evaluation/Summary_PRC'+name_modifier+'.png', bbox_inches=\"tight\")\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate all ROC and PRC Plots" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "if targetDataName not in (None, 'None'):\n", + " datasets = [d for d in datasets if d == targetDataName]\n", + "\n", + "if not algorithms:\n", + " raise ValueError(\"No algorithms discovered. Check experiment path and model outputs.\")\n", + "\n", + "for each in datasets: #each analyzed dataset to make plots for\n", + " print(\"---------------------------------------\")\n", + " print(\"Dataset: \"+str(each))\n", + " print(\"---------------------------------------\")\n", + " full_path = experiment_path+'/'+each\n", + " original_headers = pd.read_csv(full_path+\"/exploratory/ProcessedFeatureNames.csv\",sep=',').columns.values.tolist()\n", + "\n", + " result_table,metric_dict = primaryStats(algorithms,original_headers,cv_partitions,full_path,each,instance_label,outcome_label,abbrev,colors,plot_ROC,plot_PRC,name_modifier,legend_inside_plot)\n", + "\n", + " if plot_meta_ROC:\n", + " doPlotROC(result_table,colors,full_path,name_modifier,legend_inside_plot)\n", + " if plot_meta_PRC:\n", + " doPlotPRC(result_table,colors,full_path,each,instance_label,outcome_label,name_modifier,legend_inside_plot)" + ] + }, + { + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/usefulnotebooks/ModelViz_DT_GP.ipynb b/usefulnotebooks/ModelViz_DT_GP.ipynb new file mode 100644 index 00000000..c53d940f --- /dev/null +++ b/usefulnotebooks/ModelViz_DT_GP.ipynb @@ -0,0 +1,385 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Useful Notebook: Generate Model Visualizations for Decision Tree and Genetic Programming Algorithms\n", + "**This notebook will allow users to generate a direct visualization of the models generated by algorithms that create directly interpretable models.** \n", + "\n", + "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", + "\n", + "***\n", + "## Notebook Details\n", + "Generates decision tree and genetic programming model visualizations for each CV model trained by STREAMLINE. Opens each pickled decision tree and genetic programming model and generates a respective vizualization, and optionally saves them to a new folder in the working experiment folder for the given target dataset (`model_evaluation`). Can be run for a single dataset or all datasets. Includes an option to only visualize the best performing model (out of all CV datasets) determined by the user specified target metric (testing data evaluation). Also provides the option to inverse the standard scaling applied to the dataset, so that feature values can be interpreted in their original scale.\n", + "\n", + "Requirements: conda install python-graphviz \n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Notebook Run Parameters\n", + "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed). Note that in the basic demo, only Decision Tree is run, not Genetic Programming. \n", + "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "experiment_path = \"/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/test/out_full_pipeline/DemoExp\" # path the target experiment folder \n", + "targetDataName = None # 'None' if user wants to generate visualizations for all analyzed datasets\n", + "inverseScaling = True #If standardscaling was applied, revert scaled decision boundaries to their original data values.\n", + "bestOnly = False # Only generate viz. for best performing CV decision tree, otherwise generate one for each CV model.\n", + "targetMetric = 'ROC AUC' #Only used when bestOnly = True, names of different available metrics is included below.\n", + "\n", + "#metricOptions = ['Balanced Accuracy','Accuracy','F1_Score','Sensitivity (Recall)','Specificity','Precision (PPV)','TP','TN','FP','FN','NPV','LR+','LR-','ROC_AUC','PRC_AUC','PRC_APS']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Housekeeping\n", + "### Import Packages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pickle\n", + "import pandas as pd\n", + "try:\n", + " import graphviz\n", + "except ImportError:\n", + " graphviz = None\n", + "from sklearn import tree\n", + "from subprocess import call\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last.\n", + "from IPython.core.interactiveshell import InteractiveShell\n", + "InteractiveShell.ast_node_interactivity = \"all\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Automatically detect dataset folder names" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get dataset paths for all completed dataset analyses in experiment folder\n", + "experiment_name = experiment_path.split('/')[-1]\n", + "remove_list = {\n", + " '.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", + " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs', 'KeyFileCopy', 'dask_logs',\n", + " 'reporting', 'reporting_replication', 'run_params.pickle', 'runtime',\n", + " experiment_name + '_STREAMLINE_Report.pdf'\n", + "}\n", + "\n", + "datasets = []\n", + "for d in sorted(os.listdir(experiment_path)):\n", + " dpath = os.path.join(experiment_path, d)\n", + " if d in remove_list or not os.path.isdir(dpath):\n", + " continue\n", + " has_exploratory = os.path.isdir(os.path.join(dpath, 'exploratory'))\n", + " has_model_data = os.path.isdir(os.path.join(dpath, 'model_evaluation')) or os.path.isdir(os.path.join(dpath, 'models'))\n", + " if has_exploratory and has_model_data:\n", + " datasets.append(d)\n", + "\n", + "print(\"Analyzed Datasets: \" + str(datasets))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define Necessary Methods" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def unscaleTree(dotFilePath,original_headers,train_feature_list,scaler):\n", + " \"\"\" Takes a dot file goes in and finds feature names next to associated cutoff values. Then inverse scales these cutoff \n", + " values using previously pickled scaler. Scaling is reversed by multiplying by '.scale_' and adding '.mean_' from scaler.\n", + " These new values replace the old ones and the dot file is resaved with these changes.\"\"\"\n", + " my_file = open(dotFilePath)\n", + " file_list = my_file.readlines()\n", + " my_file.close()\n", + " new_file_list = []\n", + " for each in file_list: #Each line of file\n", + " for feature in original_headers: #check each feature name\n", + " if ('\"'+str(feature)) in each:\n", + " #Separate string by spaces\n", + " stringList = each.split(' ')\n", + " #Find chunk with \\nentropy\n", + " i = 0\n", + " purityText = None\n", + " for chunk in stringList:\n", + " if '\\\\nentropy' in chunk:\n", + " purityText = '\\\\nentropy'\n", + " #Isolate numerical value\n", + " targetValue = float(chunk.replace('\\\\nentropy',''))\n", + " break\n", + " elif '\\\\ngini' in chunk:\n", + " purityText = '\\\\ngini'\n", + " #Isolate numerical value\n", + " targetValue = float(chunk.replace('\\\\ngini',''))\n", + " break\n", + " i += 1\n", + " #Get index of target feature name in original feature ordering\n", + " feature_index = original_headers.index(feature)\n", + " #Inverse scale based on specific feature scale index (mean and std)\n", + " originalValue = (targetValue*scaler.scale_[feature_index]) + scaler.mean_[feature_index]\n", + " #Replace numerical value in original dot file with inverse scaled 'original' value\n", + " stringList[i] = str(originalValue)+purityText\n", + " #Rebuild string\n", + " each = \" \".join(stringList)\n", + " new_file_list.append(each)\n", + " my_file = open(dotFilePath, \"w\")\n", + " new_file_contents = \"\".join(new_file_list)\n", + " my_file.write(new_file_contents)\n", + " my_file.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def generateTreePlot(experiment_path,each,algorithm,cvCount,max_index,scale_data,outcome_label,instance_label,inverseScaling,targetMetric):\n", + " \"\"\" Takes all steps to generate a single decision tree visualization (for a given original dataset/cv training model).\n", + " Includes option to inverse scale all feature values in tree decision boundaries (to their original value range, pre-scaling)\"\"\"\n", + " if graphviz is None:\n", + " raise RuntimeError('graphviz package is not installed.')\n", + "\n", + " modelInfo = experiment_path+\"/\"+each+'/models/pickledModels/'+algorithm+'_'+str(cvCount)+'.pickle'\n", + " infile = open(modelInfo,'rb')\n", + " model = pickle.load(infile)\n", + " infile.close()\n", + "\n", + " if scale_data:\n", + " scaleInfo = experiment_path+\"/\"+each+'/scale_impute/scaler_cv'+str(cvCount)+'.pickle'\n", + " if not os.path.exists(scaleInfo):\n", + " scaleInfo = experiment_path+\"/\"+each+'/impute_scale/scaler_cv'+str(cvCount)+'.pickle'\n", + " if os.path.exists(scaleInfo):\n", + " infile = open(scaleInfo,'rb')\n", + " scaler = pickle.load(infile)\n", + " infile.close()\n", + " else:\n", + " scaler = None\n", + " else:\n", + " scaler = None\n", + "\n", + " original_headers_path = experiment_path+\"/\"+each+\"/exploratory/OriginalFeatureNames.csv\"\n", + " if not os.path.exists(original_headers_path):\n", + " original_headers_path = experiment_path+\"/\"+each+\"/exploratory/ProcessedFeatureNames.csv\"\n", + " original_headers = pd.read_csv(original_headers_path,sep=',').columns.values.tolist()\n", + "\n", + " cv_train_path = experiment_path+\"/\"+each+\"/CVDatasets/\"+each+'_CV_'+str(cvCount)+'_Train.csv'\n", + " cv_train_data = pd.read_csv(cv_train_path, na_values='NA', sep = \",\")\n", + " train_feature_list = list(cv_train_data.columns.values)\n", + " train_feature_list.remove(outcome_label)\n", + " try:\n", + " train_feature_list.remove(instance_label)\n", + " except:\n", + " pass\n", + "\n", + " tree_path = experiment_path+'/'+each+'/model_evaluation/DT_Viz/'\n", + " tree.export_graphviz(model, out_file=tree_path+\"DT_Tree_\"+str(cvCount)+'.dot', feature_names=train_feature_list, class_names=True, filled=True)\n", + " if scale_data and inverseScaling and scaler is not None:\n", + " unscaleTree(tree_path+\"DT_Tree_\"+str(cvCount)+'.dot',original_headers,train_feature_list,scaler)\n", + "\n", + " graph = graphviz.Source.from_file(tree_path+\"DT_Tree_\"+str(cvCount)+'.dot')\n", + " graph.format = \"png\"\n", + " if cvCount == max_index:\n", + " printMetric = targetMetric.replace(\" \", \"_\")\n", + " graph.render(tree_path+\"DT_Tree_\"+str(cvCount)+'_Best_'+printMetric)\n", + " else:\n", + " graph.render(tree_path+\"DT_Tree_\"+str(cvCount))\n", + " return graph" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def generateGPPlot(experiment_path,data_name,algorithm,cvCount,max_index,scale_data,outcome_label,instance_label,targetMetric):\n", + " \"\"\" Takes all steps to generate a single genetic programming tree. https://gplearn.readthedocs.io/en/stable/examples.html \"\"\"\n", + " if graphviz is None:\n", + " raise RuntimeError('graphviz package is not installed.')\n", + "\n", + " modelInfo = experiment_path+\"/\"+data_name+'/models/pickledModels/'+algorithm+'_'+str(cvCount)+'.pickle'\n", + " infile = open(modelInfo,'rb')\n", + " model = pickle.load(infile)\n", + " infile.close()\n", + "\n", + " tree_path = experiment_path+'/'+data_name+'/model_evaluation/GP_Viz/'\n", + " dot_data = model._program.export_graphviz()\n", + " graph = graphviz.Source(dot_data)\n", + " graph.format = \"png\"\n", + " if cvCount == max_index:\n", + " printMetric = targetMetric.replace(\" \", \"_\")\n", + " graph.render(tree_path+\"GP_Tree_\"+str(cvCount)+'_Best_'+printMetric)\n", + " else:\n", + " graph.render(tree_path+\"GP_Tree_\"+str(cvCount))\n", + " return graph" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate Decision Tree and/or Genetic Programming Tree Vizualizations" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if targetDataName not in (None, 'None'):\n", + " datasets = [d for d in datasets if d == targetDataName]\n", + "print(\"Vizualized Datasets: \"+str(datasets))\n", + "\n", + "# Unpickle metadata from previous phase\n", + "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", + "metadata = pickle.load(file)\n", + "file.close()\n", + "\n", + "alg_info_path = os.path.join(experiment_path, \"algInfo.pickle\")\n", + "if os.path.exists(alg_info_path):\n", + " with open(alg_info_path, \"rb\") as file:\n", + " algInfo = pickle.load(file)\n", + "else:\n", + " algInfo = {}\n", + "\n", + "outcome_label = metadata.get('Outcome Label', metadata.get('Class Label', 'Class'))\n", + "instance_label = metadata['Instance Label']\n", + "cv_partitions = metadata['CV Partitions']\n", + "scale_data = metadata.get('Use Data Scaling', False)\n", + "\n", + "do_DT = bool(algInfo.get('Decision Tree', [False])[0])\n", + "do_GP = bool(algInfo.get('Genetic Programming', [False])[0])\n", + "if not do_DT:\n", + " do_DT = any(os.path.exists(os.path.join(experiment_path, ds, 'model_evaluation', 'DT_performance.csv')) for ds in datasets)\n", + "if not do_GP:\n", + " do_GP = any(os.path.exists(os.path.join(experiment_path, ds, 'model_evaluation', 'GP_performance.csv')) for ds in datasets)\n", + "if 'Decision Tree' not in algInfo:\n", + " algInfo['Decision Tree'] = [do_DT, 'DT', None]\n", + "if 'Genetic Programming' not in algInfo:\n", + " algInfo['Genetic Programming'] = [do_GP, 'GP', None]\n", + "\n", + "if graphviz is None:\n", + " print('graphviz package is not installed. Skipping DT/GP visualization cells.')\n", + " do_DT = False\n", + " do_GP = False\n", + "\n", + "print(\"Number of CV Partitions: \"+str(cv_partitions))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "for each in datasets: #each analyzed dataset to make plots for\n", + " if do_DT:\n", + " #Create folder for tree vizualization files\n", + " if not os.path.exists(experiment_path+'/'+each+'/model_evaluation/DT_Viz'):\n", + " os.mkdir(experiment_path+'/'+each+'/model_evaluation/DT_Viz')\n", + " #Open results dictionary to get metric for each CV\n", + " cvMetrics = pd.read_csv(experiment_path+'/'+each+'/model_evaluation/DT_performance.csv',na_values='NA',sep=',')\n", + " metric_cv_list = cvMetrics[targetMetric].tolist()\n", + " #identify best CV\n", + " max_value = max(metric_cv_list)\n", + " max_index = metric_cv_list.index(max_value)\n", + " # Vizualize best performing model\n", + " print(str(targetMetric)+\" values for each CV training set with DT:\")\n", + " print(str(metric_cv_list))\n", + " print(\"Best \"+str(targetMetric)+\": \"+str(max_value))\n", + " for cvCount in range(0,int(cv_partitions)):\n", + " graph = generateTreePlot(experiment_path,each,algInfo['Decision Tree'][1],cvCount,max_index,scale_data,outcome_label,instance_label,inverseScaling,targetMetric)\n", + " print(\"---------------------------------------\")\n", + " print(each+\"- CV Dataset: \"+str(max_index))\n", + " print(\"---------------------------------------\")\n", + " graph\n", + " \n", + " if do_GP:\n", + " #Create folder for tree vizualization files\n", + " if not os.path.exists(experiment_path+'/'+each+'/model_evaluation/GP_Viz'):\n", + " os.mkdir(experiment_path+'/'+each+'/model_evaluation/GP_Viz')\n", + "\n", + " #Open results dictionary to get metric for each CV\n", + " cvMetrics = pd.read_csv(experiment_path+'/'+each+'/model_evaluation/GP_performance.csv',na_values='NA',sep=',')\n", + " metric_cv_list = cvMetrics[targetMetric].tolist()\n", + " #identify best CV\n", + " max_value = max(metric_cv_list)\n", + " max_index = metric_cv_list.index(max_value)\n", + " # Vizualize best performing model\n", + " print(str(targetMetric)+\" values for each CV training set with GP:\")\n", + " print(str(metric_cv_list))\n", + " print(\"Best \"+str(targetMetric)+\": \"+str(max_value))\n", + " for cvCount in range(0,int(cv_partitions)):\n", + " graph = generateGPPlot(experiment_path,each,algInfo['Genetic Programming'][1],cvCount,max_index,scale_data,outcome_label,instance_label,targetMetric)\n", + " print(\"---------------------------------------\")\n", + " print(each+\"- CV Dataset: \"+str(max_index))\n", + " print(\"---------------------------------------\")\n", + " graph" + ] + } + ], + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/usefulnotebooks/PredictionProbs_Replication.ipynb b/usefulnotebooks/PredictionProbs_Replication.ipynb new file mode 100644 index 00000000..e2545fb9 --- /dev/null +++ b/usefulnotebooks/PredictionProbs_Replication.ipynb @@ -0,0 +1,227 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Useful Notebook: Report Replication Data Prediction Probabilities\n", + "**This notebook will generate model (class 1) prediction probabilities for instances of respective replication dataset.**\n", + "\n", + "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6 and phase 8 - replication) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", + "\n", + "***\n", + "## Notebook Details\n", + "STREAMLINE outputs pickled objects with all the metric results during the initial testing evaluation of trained models as well as following application of trained models to additional hold out replication data.\n", + "\n", + "This notebook grabs these prediction probabilities for a specific replication dataset and reports them as .csv files for each algorithm and CV partition pair (i.e for each of the CV trained models).\n", + "\n", + "When run, the last code cell will generate a new folder (`prediction_probas`) in the pipeline's output experiment folder in the `/replication/[REPDATANAME]/model_evaluation` folder of the `dataset` specified below. Here the class 1 prediction probabilities are reported as a `.csv` file for each algorithm and CV partition pair. In these files is the instance's true outcome value, the unique instance ID, and the predicted probability of the instance being class 1 (i.e. which typically encodes cases or the less frequent class). \n", + "\n", + "* *This code is set up to run on a specific pair of an original dataset and a paired replication dataset one at a time.*\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Notebook Run Parameters\n", + "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed). \n", + "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "experiment_path = \"/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/test/out_full_pipeline/DemoExp\" # path the target experiment folder \n", + "dataname = 'hcc_survival' #name of target dataset folder in experiment output folder from pipeline\n", + "rep_dataname =\"hcc_survival_rep\"#path to replication dataset file (needed to grab instance labels and true class values)\n", + "algorithms = [] # use empty list if user wishes re-evaluate all modeling algorithms that were run in pipeline, otherwise specify a (str) list of algorithm identifiers." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Housekeeping\n", + "### Import Packages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "import pickle\n", + "import numpy as np\n", + "from statistics import mean\n", + "from scipy import stats\n", + "interp = np.interp\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", + "from IPython.core.interactiveshell import InteractiveShell\n", + "InteractiveShell.ast_node_interactivity = \"all\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load Other Necessary Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Unpickle metadata from previous phase\n", + "file = open(experiment_path+'/'+\"metadata.pickle\", 'rb')\n", + "metadata = pickle.load(file)\n", + "file.close()\n", + "# Load variables specified earlier in the pipeline from metadata\n", + "outcome_label = metadata.get('Outcome Label', metadata.get('Class Label', 'Class'))\n", + "instance_label = metadata['Instance Label']\n", + "cv_partitions = int(metadata['CV Partitions'])\n", + "\n", + "# Unpickle algorithm information from previous phase\n", + "alg_info_path = os.path.join(experiment_path, \"algInfo.pickle\")\n", + "if os.path.exists(alg_info_path):\n", + " with open(alg_info_path, \"rb\") as file:\n", + " algInfo = pickle.load(file)\n", + "else:\n", + " algInfo = {}\n", + "\n", + "algorithms = []\n", + "abbrev = {}\n", + "colors = {}\n", + "for key in algInfo:\n", + " if algInfo[key][0]: # If that algorithm was used\n", + " algorithms.append(key)\n", + " abbrev[key] = (algInfo[key][1])\n", + " colors[key] = (algInfo[key][2])\n", + " \n", + "# Fallback: infer algorithms when algInfo.pickle is missing or empty\n", + "if not algorithms:\n", + " inferred = {}\n", + " scan_datasets = []\n", + " if 'datasets' in locals():\n", + " scan_datasets = [d for d in datasets if os.path.isdir(os.path.join(experiment_path, d))]\n", + " elif 'dataname' in locals():\n", + " scan_datasets = [dataname]\n", + " for ds_name in scan_datasets:\n", + " pm_dir = os.path.join(experiment_path, ds_name, \"model_evaluation\", \"pickled_metrics\")\n", + " if not os.path.isdir(pm_dir):\n", + " continue\n", + " for fname in os.listdir(pm_dir):\n", + " if fname.endswith(\"_metrics.pickle\") and \"_CV_\" in fname:\n", + " abr = fname.split(\"_CV_\")[0]\n", + " inferred[abr] = [True, abr, None]\n", + " if inferred:\n", + " break\n", + " algInfo.update({k: v for k, v in inferred.items() if k not in algInfo})\n", + " for key in algInfo:\n", + " if algInfo[key][0] and key not in algorithms:\n", + " algorithms.append(key)\n", + " if 'abbrev' in locals():\n", + " abbrev[key] = algInfo[key][1] if len(algInfo[key]) > 1 else key\n", + " if 'colors' in locals():\n", + " colors[key] = algInfo[key][2] if len(algInfo[key]) > 2 else None\n", + "if 'colors' in locals():\n", + " palette = [\"#1f77b4\", \"#ff7f0e\", \"#2ca02c\", \"#d62728\", \"#9467bd\", \"#8c564b\", \"#e377c2\", \"#7f7f7f\", \"#bcbd22\", \"#17becf\"]\n", + " for idx, key in enumerate(algorithms):\n", + " if colors.get(key) is None:\n", + " colors[key] = palette[idx % len(palette)]\n", + "if 'algColors' in locals() and (not algColors):\n", + " algColors.extend([colors[k] for k in algorithms if k in colors])\n", + "\n", + "print(\"Algorithms Ran: \" + str(algorithms))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extract and Output Replication Data Prediction Probabilities " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "full_path = experiment_path+'/'+dataname\n", + "new_full_path = full_path+'/replication/'+rep_dataname\n", + " \n", + "#Make folder in experiment folder/datafolder to store all prediction probabilities per algorithm/CV combination\n", + "if not os.path.exists(new_full_path+'/model_evaluation/prediction_probas'):\n", + " os.mkdir(new_full_path+'/model_evaluation/prediction_probas')\n", + "\n", + "for algorithm in algorithms: #loop through algorithms\n", + " print(\"Algorithm: \"+str(algorithm))\n", + "\n", + " for cvCount in range(0,cv_partitions): #loop through cv's\n", + " print(\"CV: \"+str(cvCount))\n", + " #Load pickled metric file for given algorithm and cv\n", + " result_file = new_full_path+'/model_evaluation/pickled_metrics/'+abbrev[algorithm]+\"_CV_\"+str(cvCount)+\"_metrics.pickle\"\n", + " file = open(result_file, 'rb')\n", + " results = pickle.load(file)\n", + " file.close()\n", + "\n", + " #Load processed replication dataset (From which we will get the instancelabel values and class outcome values.)\n", + " rep_data = pd.read_csv(new_full_path+'/'+rep_dataname+'_Processed.csv')\n", + " probas_summary = rep_data[[outcome_label,instance_label]]\n", + "\n", + " #Separate pickled results\n", + " probas_ = results[9]\n", + " print(probas_[:,1])\n", + " probas_summary['1_prob'] = probas_[:,1]\n", + " file_name = new_full_path+'/model_evaluation/prediction_probas/' + algorithm + '_CV_'+str(cvCount)+'_class1_probas.csv'\n", + " probas_summary.to_csv(file_name, index=False)\n", + "\n" + ] + }, + { + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/usefulnotebooks/PredictionProbs_Test_EvalMetricAccess.ipynb b/usefulnotebooks/PredictionProbs_Test_EvalMetricAccess.ipynb new file mode 100644 index 00000000..6f1099d1 --- /dev/null +++ b/usefulnotebooks/PredictionProbs_Test_EvalMetricAccess.ipynb @@ -0,0 +1,473 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Useful Notebook: Report Testing Data Prediction Probabilities and Illustrate Accessing Evaluation Metrics\n", + "**This notebook will (1) show users how to access all model evaluation metrics from internal pickle files, and (2) generate model (class 1) prediction probabilities for instances of the respective testing dataset.**\n", + "\n", + "*This notebook is designed to run after having run STREAMLINE (at least phases 1-6) and will use the files from a specific STREAMLINE experiment folder, as well as save new output files to that same folder.*\n", + "\n", + "***\n", + "## Notebook Details\n", + "STREAMLINE outputs pickled objects with (1) all the metric results, (2) elements needed to build the ROC and PRC plots, as well as (3) the prediction probabilities on the testing data across all datasets, algorithm models, and CV dataset partitions. \n", + "\n", + "This notebook illustrates how the user can access the pickled metric information saved as a list object. \n", + "\n", + "It includes (1) grabbing and calculating all average metric scores over the CV partitions, (2) grabbing the elements needed to build the average ROC plot, (3) grabbing the elementes needed to build the average PRC plot, (4) grabbing and reporting average model feature importance scores, and (5) grabbing and reporting the model testing prediction probabilities for each instance of the dataset. \n", + "\n", + "When run, this last item will generate a new folder (`prediction_probas`) in the pipeline's output experiment folder in the `model_evaluation` folder for each dataset. Here the class 1 prediction probabilities are reported as a `.csv` file for each algorithm and CV partition pair. In these files is the instance's true outcome value, the unique instance ID, and the predicted probability of the instance being class 1 (i.e. which typically encodes cases or the less frequent class). \n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Notebook Run Parameters\n", + "* This notbook has been set up to run 'as-is' on the experiment folder generated when running the demo of STREAMLINE in any mode (if no run parameters were changed). \n", + "* If you have run STREAMLINE on different target data or saved the experiment to some other folder outside of STREAMLINE, you need to edit `experiment_path` below to point to the respective experiment folder." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "experiment_path = \"/Users/harshbandhey/Local/Cedars/Urbslab/STREAMLINEv3New/test/out_full_pipeline/DemoExp\" # path the target experiment folder \n", + "target_data_list = None # None if user wants to generate output for all analyzed target datasets, otherwise provide a (str) list of target dataset names to run\n", + "algorithms = [] # use empty list if user wishes re-evaluate all modeling algorithms that were run in pipeline, otherwise specify a (str) list of algorithm identifiers." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Housekeeping\n", + "### Import Packages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import json\n", + "import pandas as pd\n", + "import pickle\n", + "import numpy as np\n", + "from statistics import mean\n", + "from scipy import stats\n", + "interp = np.interp\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Jupyter Notebook Hack: This code ensures that the results of multiple commands within a given cell are all displayed, rather than just the last. \n", + "from IPython.core.interactiveshell import InteractiveShell\n", + "InteractiveShell.ast_node_interactivity = \"all\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Automatically Detect Dataset Names" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get dataset paths for all completed dataset analyses in experiment folder\n", + "experiment_name = experiment_path.split('/')[-1]\n", + "remove_list = {\n", + " '.DS_Store', 'metadata.pickle', 'metadata.csv', 'algInfo.pickle',\n", + " 'DatasetComparisons', 'jobs', 'jobsCompleted', 'logs', 'KeyFileCopy', 'dask_logs',\n", + " 'reporting', 'reporting_replication', 'run_params.pickle', 'runtime',\n", + " experiment_name + '_STREAMLINE_Report.pdf'\n", + "}\n", + "\n", + "datasets = []\n", + "for d in sorted(os.listdir(experiment_path)):\n", + " dpath = os.path.join(experiment_path, d)\n", + " if d in remove_list or not os.path.isdir(dpath):\n", + " continue\n", + " has_exploratory = os.path.isdir(os.path.join(dpath, 'exploratory'))\n", + " has_model_data = os.path.isdir(os.path.join(dpath, 'model_evaluation')) or os.path.isdir(os.path.join(dpath, 'models'))\n", + " if has_exploratory and has_model_data:\n", + " datasets.append(d)\n", + "\n", + "print(\"Analyzed Datasets: \" + str(datasets))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load Other Necessary Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Unpickle metadata from previous phase\n", + "file = open(experiment_path + '/' + \"metadata.pickle\", 'rb')\n", + "metadata = pickle.load(file)\n", + "file.close()\n", + "# Load variables specified earlier in the pipeline from metadata\n", + "outcome_label = metadata.get('Outcome Label', metadata.get('Class Label', 'Class'))\n", + "instance_label = metadata['Instance Label']\n", + "cv_partitions = int(metadata['CV Partitions'])\n", + "\n", + "requested_algorithms = list(algorithms) if isinstance(algorithms, list) else []\n", + "\n", + "# Unpickle algorithm information from previous phase\n", + "alg_info_path = os.path.join(experiment_path, \"algInfo.pickle\")\n", + "if os.path.exists(alg_info_path):\n", + " with open(alg_info_path, \"rb\") as file:\n", + " algInfo = pickle.load(file)\n", + "else:\n", + " algInfo = {}\n", + "\n", + "algorithms = []\n", + "abbrev = {}\n", + "for key, value in algInfo.items():\n", + " if isinstance(value, (list, tuple)) and len(value) > 0 and bool(value[0]):\n", + " algorithms.append(key)\n", + " abbrev[key] = value[1] if len(value) > 1 else key\n", + "\n", + "# Fallback: infer algorithms from current output layout\n", + "if not algorithms:\n", + " inferred = set()\n", + " scan_datasets = [d for d in datasets if os.path.isdir(os.path.join(experiment_path, d))]\n", + " for ds_name in scan_datasets:\n", + " model_dir = os.path.join(experiment_path, ds_name, \"models\", \"pickledModels\")\n", + " if os.path.isdir(model_dir):\n", + " for fname in os.listdir(model_dir):\n", + " if fname.endswith('.pickle') and '_' in fname:\n", + " inferred.add(fname.rsplit('_', 1)[0])\n", + " metric_dir = os.path.join(experiment_path, ds_name, \"model_evaluation\", \"metrics_by_cv\")\n", + " if os.path.isdir(metric_dir):\n", + " for fname in os.listdir(metric_dir):\n", + " if fname.endswith('.json') and '_CV_' in fname:\n", + " inferred.add(fname.split('_CV_')[0])\n", + " for abr in sorted(inferred):\n", + " algorithms.append(abr)\n", + " abbrev[abr] = abr\n", + "\n", + "if requested_algorithms:\n", + " req = set(requested_algorithms)\n", + " filtered = [a for a in algorithms if a in req or abbrev.get(a) in req]\n", + " if filtered:\n", + " algorithms = filtered\n", + "\n", + "print(\"Algorithms Ran: \" + str(algorithms))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## From Pickle: Extract Metric List and Cacluate CV Averages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def print_results(algorithm, full_path):\n", + " perf_file = full_path + '/model_evaluation/' + abbrev[algorithm] + '_performance.csv'\n", + " if not os.path.exists(perf_file):\n", + " print({'error': 'Missing performance file', 'file': perf_file})\n", + " return\n", + "\n", + " perf_df = pd.read_csv(perf_file)\n", + " if perf_df.empty:\n", + " print({'error': 'Performance file is empty', 'file': perf_file})\n", + " return\n", + "\n", + " rename_map = {\n", + " 'F1_Score': 'F1 Score',\n", + " 'ROC_AUC': 'ROC AUC',\n", + " 'PRC_AUC': 'PRC AUC',\n", + " 'PRC_APS': 'PRC APS'\n", + " }\n", + " perf_df = perf_df.rename(columns=rename_map)\n", + "\n", + " summary = {}\n", + " for col in perf_df.columns:\n", + " try:\n", + " summary[col] = float(np.nanmean(perf_df[col].values.astype(float)))\n", + " except Exception:\n", + " continue\n", + "\n", + " print(summary)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if target_data_list not in (None, 'None'):\n", + " selected = set(target_data_list) if isinstance(target_data_list, (list, tuple, set)) else {target_data_list}\n", + " datasets = [d for d in datasets if d in selected]\n", + "\n", + "for each in datasets:\n", + " print(\"---------------------------------------\")\n", + " print(\"Dataset: \"+str(each))\n", + " print(\"---------------------------------------\")\n", + " full_path = experiment_path + '/' + each\n", + " for algorithm in algorithms:\n", + " print(\"Algorithm: \"+str(algorithm))\n", + " print_results(algorithm, full_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## From Pickle: Extract list of true and false positive rates for constructing ROC" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if target_data_list not in (None, 'None'):\n", + " selected = set(target_data_list) if isinstance(target_data_list, (list, tuple, set)) else {target_data_list}\n", + " datasets = [d for d in datasets if d in selected]\n", + "\n", + "for each in datasets:\n", + " print(\"---------------------------------------\")\n", + " print(\"Dataset: \"+str(each))\n", + " print(\"---------------------------------------\")\n", + " full_path = experiment_path+ '/' + each\n", + " for algorithm in algorithms:\n", + " print(\"Algorithm: \"+str(algorithm))\n", + " tprs = []\n", + " mean_fpr = np.linspace(0, 1, 100)\n", + "\n", + " for cv_count in range(0, cv_partitions):\n", + " roc_file = full_path + '/model_evaluation/curves_by_cv/' + abbrev[algorithm] + '_CV_' + str(cv_count) + '_roc.json'\n", + " if not os.path.exists(roc_file):\n", + " continue\n", + " with open(roc_file, 'r') as f:\n", + " payload = json.load(f)\n", + " curve = payload.get('micro', payload.get('binary', payload))\n", + " fpr = np.asarray(curve.get('fpr', []), dtype=float)\n", + " tpr = np.asarray(curve.get('tpr', []), dtype=float)\n", + " if len(fpr) < 2 or len(tpr) < 2:\n", + " continue\n", + " order = np.argsort(fpr)\n", + " fpr = fpr[order]\n", + " tpr = tpr[order]\n", + " fpr_u, idx = np.unique(fpr, return_index=True)\n", + " tpr_u = tpr[idx]\n", + " if len(fpr_u) < 2:\n", + " continue\n", + " tprs.append(interp(mean_fpr, fpr_u, tpr_u))\n", + " tprs[-1][0] = 0.0\n", + "\n", + " if not tprs:\n", + " print({'error': 'No ROC curves found'})\n", + " else:\n", + " results = {'tprs': np.mean(tprs, axis=0)}\n", + " print(results)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## From Pickle: Extract list of precision and recall values for constructing PRC" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if target_data_list not in (None, 'None'):\n", + " selected = set(target_data_list) if isinstance(target_data_list, (list, tuple, set)) else {target_data_list}\n", + " datasets = [d for d in datasets if d in selected]\n", + "\n", + "for each in datasets:\n", + " print(\"---------------------------------------\")\n", + " print(\"Dataset: \"+str(each))\n", + " print(\"---------------------------------------\")\n", + " full_path = experiment_path + '/' + each\n", + " for algorithm in algorithms:\n", + " print(\"Algorithm: \"+str(algorithm))\n", + " precs = []\n", + " mean_recall = np.linspace(0, 1, 100)\n", + "\n", + " for cv_count in range(0, cv_partitions):\n", + " prc_file = full_path + '/model_evaluation/curves_by_cv/' + abbrev[algorithm] + '_CV_' + str(cv_count) + '_prc.json'\n", + " if not os.path.exists(prc_file):\n", + " continue\n", + " with open(prc_file, 'r') as f:\n", + " payload = json.load(f)\n", + " curve = payload.get('micro', payload.get('binary', payload))\n", + " prec = np.asarray(curve.get('precision', []), dtype=float)\n", + " recall = np.asarray(curve.get('recall', []), dtype=float)\n", + " if len(prec) < 2 or len(recall) < 2:\n", + " continue\n", + " order = np.argsort(recall)\n", + " recall = recall[order]\n", + " prec = prec[order]\n", + " recall_u, idx = np.unique(recall, return_index=True)\n", + " prec_u = prec[idx]\n", + " if len(recall_u) < 2:\n", + " continue\n", + " precs.append(interp(mean_recall, recall_u, prec_u))\n", + "\n", + " if not precs:\n", + " print({'error': 'No PRC curves found'})\n", + " else:\n", + " results = {'precs': np.mean(precs, axis=0)}\n", + " print(results)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## From Pickle: Extract Average Model Feature Importance Estimates (Over CVs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if target_data_list not in (None, 'None'):\n", + " selected = set(target_data_list) if isinstance(target_data_list, (list, tuple, set)) else {target_data_list}\n", + " datasets = [d for d in datasets if d in selected]\n", + "print(\"Dataset: \" + str(datasets))\n", + "\n", + "for each in datasets:\n", + " print(\"---------------------------------------\")\n", + " print(\"Dataset: \"+str(each))\n", + " print(\"---------------------------------------\")\n", + " full_path = experiment_path + '/' + each\n", + " for algorithm in algorithms:\n", + " print(\"Algorithm: \"+str(algorithm))\n", + " fi_file = full_path + '/model_evaluation/feature_importance/' + abbrev[algorithm] + '_FI.csv'\n", + " if not os.path.exists(fi_file):\n", + " print({'error': 'Missing FI file', 'file': fi_file})\n", + " continue\n", + " fi_df = pd.read_csv(fi_file)\n", + " if fi_df.empty:\n", + " print({'error': 'Empty FI file', 'file': fi_file})\n", + " continue\n", + " fi_dict = fi_df.mean(axis=0).to_dict()\n", + " print(fi_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extract and Output Testing Data Prediction Probabilities " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if target_data_list not in (None, 'None'):\n", + " selected = set(target_data_list) if isinstance(target_data_list, (list, tuple, set)) else {target_data_list}\n", + " datasets = [d for d in datasets if d in selected]\n", + "\n", + "for each in datasets:\n", + " print(\"---------------------------------------\")\n", + " print(\"Dataset: \"+str(each))\n", + " print(\"---------------------------------------\")\n", + "\n", + " full_path = experiment_path + '/' + each\n", + "\n", + " if not os.path.exists(full_path + '/model_evaluation/prediction_probas'):\n", + " os.mkdir(full_path + '/model_evaluation/prediction_probas')\n", + "\n", + " for algorithm in algorithms:\n", + " print(\"Algorithm: \"+str(algorithm))\n", + "\n", + " for cv_count in range(0,cv_partitions):\n", + " print(\"CV: \"+str(cv_count))\n", + " model_file = full_path + '/models/pickledModels/' + abbrev[algorithm] + '_' + str(cv_count) + '.pickle'\n", + " if not os.path.exists(model_file):\n", + " print('Missing model file: ' + model_file)\n", + " continue\n", + " with open(model_file, 'rb') as file:\n", + " model = pickle.load(file)\n", + " if not hasattr(model, 'predict_proba'):\n", + " print('Model has no predict_proba; skipping.')\n", + " continue\n", + "\n", + " test_data = pd.read_csv(full_path + '/CVDatasets/'+each+'_CV_' + str(cv_count) + '_Test.csv')\n", + " id_cols = [outcome_label]\n", + " if instance_label != 'None' and instance_label in test_data.columns:\n", + " id_cols.append(instance_label)\n", + " feature_df = test_data.drop(columns=id_cols)\n", + "\n", + " probas_all = model.predict_proba(feature_df.values)\n", + " if len(probas_all.shape) != 2:\n", + " print('Unexpected probability shape; skipping.')\n", + " continue\n", + " class_index = 1 if probas_all.shape[1] > 1 else 0\n", + "\n", + " summary_cols = [outcome_label]\n", + " if instance_label != 'None' and instance_label in test_data.columns:\n", + " summary_cols.append(instance_label)\n", + " probas_summary = test_data[summary_cols].copy()\n", + " probas_summary['1_prob'] = probas_all[:, class_index]\n", + "\n", + " file_name = full_path + '/model_evaluation/prediction_probas/' + algorithm + '_CV_'+str(cv_count) + '_class1_probas.csv'\n", + " probas_summary.to_csv(file_name, index=False)" + ] + } + ], + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}